From a0b39374d5fa4671132cfcd746cdeba41edbb0bf Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Wed, 12 Jun 2024 23:53:47 -0400 Subject: [PATCH 01/12] partial commit of main files without rt1 model with cleaned code --- .gitignore | 138 ++ LICENSE | 21 + Open_X_Embodiment_Datasets.ipynb | 2303 ++++++++++++++++++++++++++++++ README.md | 64 + ai2thor_env.py | 641 +++++++++ data.py | 536 +++++++ main.py | 257 ++++ main_ft.py | 385 +++++ main_ft_eval.py | 278 ++++ rollout_ai2thor.py | 366 +++++ setup.py | 44 + vd4rl_main.py | 389 +++++ 12 files changed, 5422 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 Open_X_Embodiment_Datasets.ipynb create mode 100644 ai2thor_env.py create mode 100644 data.py create mode 100644 main.py create mode 100644 main_ft.py create mode 100644 main_ft_eval.py create mode 100644 rollout_ai2thor.py create mode 100644 setup.py create mode 100644 vd4rl_main.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..5deb9495c --- /dev/null +++ b/.gitignore @@ -0,0 +1,138 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# Extras +checkpoints/* +datasets/* +wandb/ +rt1_dataset/* +traj_rollouts/* +run_rt1_main.sh +rt1_ft_env \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..272afdf8f --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Phil Wang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Open_X_Embodiment_Datasets.ipynb b/Open_X_Embodiment_Datasets.ipynb new file mode 100644 index 000000000..2b2235541 --- /dev/null +++ b/Open_X_Embodiment_Datasets.ipynb @@ -0,0 +1,2303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "EnWCKLGGaf-d" + }, + "source": [ + "# Open X-Embodiment Datasets\n", + "\n", + "![](https://robotics-transformer-x.github.io/img/overview.png)\n", + "\n", + "This colab helps you **visualize** the datasets in the Open X-Embodiment Dataset, explains how to **download** them and how to **train** with them.\n", + "\n", + "Table of Content:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "toc", + "id": "UyiiBjzmaIQu" + }, + "source": [ + ">[Open X-Embodiment Datasets](#scrollTo=EnWCKLGGaf-d)\n", + "\n", + ">[Visualize Datasets](#scrollTo=29c7oLlJbWwF)\n", + "\n", + ">[Download Datasets](#scrollTo=-WHN-2OrKqGo)\n", + "\n", + ">[Data Loader Example](#scrollTo=IyccDsRqwtMz)\n", + "\n", + ">[Interleave Multiple Datasets](#scrollTo=ekmsGRAnw3Bp)\n", + "\n", + ">[Example Dataloader to produce trajectories](#scrollTo=aew258oUbamg)\n", + "\n", + ">>[Demonstration of transformation from an episode to a trajectory](#scrollTo=BK4RRYkbLN5B)\n", + "\n", + ">>[Combination of multiple datasets](#scrollTo=Oy89HzymQyAq)\n", + "\n", + ">[Available datasets:](#scrollTo=N2Efw2aHVfSX)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "29c7oLlJbWwF" + }, + "source": [ + "# Visualize Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "l7OogZYi7qwT" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow_datasets as tfds\n", + "from PIL import Image\n", + "from IPython import display\n", + "\n", + "DATASETS = [\n", + " \"fractal20220817_data\",\n", + " \"kuka\",\n", + " \"bridge\",\n", + " \"taco_play\",\n", + " \"jaco_play\",\n", + " \"berkeley_cable_routing\",\n", + " \"roboturk\",\n", + " \"nyu_door_opening_surprising_effectiveness\",\n", + " \"viola\",\n", + " \"berkeley_autolab_ur5\",\n", + " \"toto\",\n", + " \"language_table\",\n", + " \"columbia_cairlab_pusht_real\",\n", + " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", + " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", + " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", + " \"austin_buds_dataset_converted_externally_to_rlds\",\n", + " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", + " \"maniskill_dataset_converted_externally_to_rlds\",\n", + " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", + " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", + " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", + " \"bc_z\",\n", + " \"usc_cloth_sim_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", + " \"utokyo_saytap_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", + " \"robo_net\",\n", + " \"berkeley_mvp_converted_externally_to_rlds\",\n", + " \"berkeley_rpt_converted_externally_to_rlds\",\n", + " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", + " \"stanford_mask_vit_converted_externally_to_rlds\",\n", + " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", + " \"dlr_sara_pour_converted_externally_to_rlds\",\n", + " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", + " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", + " \"asu_table_top_converted_externally_to_rlds\",\n", + " \"stanford_robocook_converted_externally_to_rlds\",\n", + " \"eth_agent_affordances\",\n", + " \"imperialcollege_sawyer_wrist_cam\",\n", + " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", + " \"uiuc_d3field\",\n", + " \"utaustin_mutex\",\n", + " \"berkeley_fanuc_manipulation\",\n", + " \"cmu_play_fusion\",\n", + " \"cmu_stretch\",\n", + " \"berkeley_gnm_recon\",\n", + " \"berkeley_gnm_cory_hall\",\n", + " \"berkeley_gnm_sac_son\",\n", + "]\n", + "\n", + "\n", + "def dataset2path(name):\n", + " if name == \"robo_net\":\n", + " version = \"1.0.0\"\n", + " elif name == \"language_table\":\n", + " version = \"0.0.1\"\n", + " else:\n", + " version = \"0.1.0\"\n", + " return f\"gs://gresearch/robotics/{name}/{version}\"\n", + "\n", + "\n", + "def as_gif(images, path=\"temp.gif\"):\n", + " # Render the images as the gif:\n", + " images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0)\n", + " gif_bytes = open(path, \"rb\").read()\n", + " return gif_bytes" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 497 + }, + "id": "Gcw4eHmxbZjx", + "outputId": "a2cc46f1-5eec-41b8-fa23-6b4797b1e1e1" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# choose the dataset path in the dropdown on the right and rerun this cell\n", + "# to see multiple samples\n", + "\n", + "dataset = \"fractal20220817_data\" # @param ['fractal20220817_data', 'kuka', 'bridge', 'taco_play', 'jaco_play', 'berkeley_cable_routing', 'roboturk', 'nyu_door_opening_surprising_effectiveness', 'viola', 'berkeley_autolab_ur5', 'toto', 'language_table', 'columbia_cairlab_pusht_real', 'stanford_kuka_multimodal_dataset_converted_externally_to_rlds', 'nyu_rot_dataset_converted_externally_to_rlds', 'stanford_hydra_dataset_converted_externally_to_rlds', 'austin_buds_dataset_converted_externally_to_rlds', 'nyu_franka_play_dataset_converted_externally_to_rlds', 'maniskill_dataset_converted_externally_to_rlds', 'furniture_bench_dataset_converted_externally_to_rlds', 'cmu_franka_exploration_dataset_converted_externally_to_rlds', 'ucsd_kitchen_dataset_converted_externally_to_rlds', 'ucsd_pick_and_place_dataset_converted_externally_to_rlds', 'austin_sailor_dataset_converted_externally_to_rlds', 'austin_sirius_dataset_converted_externally_to_rlds', 'bc_z', 'usc_cloth_sim_converted_externally_to_rlds', 'utokyo_pr2_opening_fridge_converted_externally_to_rlds', 'utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds', 'utokyo_saytap_converted_externally_to_rlds', 'utokyo_xarm_pick_and_place_converted_externally_to_rlds', 'utokyo_xarm_bimanual_converted_externally_to_rlds', 'robo_net', 'berkeley_mvp_converted_externally_to_rlds', 'berkeley_rpt_converted_externally_to_rlds', 'kaist_nonprehensile_converted_externally_to_rlds', 'stanford_mask_vit_converted_externally_to_rlds', 'tokyo_u_lsmo_converted_externally_to_rlds', 'dlr_sara_pour_converted_externally_to_rlds', 'dlr_sara_grid_clamp_converted_externally_to_rlds', 'dlr_edan_shared_control_converted_externally_to_rlds', 'asu_table_top_converted_externally_to_rlds', 'stanford_robocook_converted_externally_to_rlds', 'eth_agent_affordances', 'imperialcollege_sawyer_wrist_cam', 'iamlab_cmu_pickup_insert_converted_externally_to_rlds', 'uiuc_d3field', 'utaustin_mutex', 'berkeley_fanuc_manipulation', 'cmu_food_manipulation', 'cmu_play_fusion', 'cmu_stretch', 'berkeley_gnm_recon', 'berkeley_gnm_cory_hall', 'berkeley_gnm_sac_son']\n", + "display_key = \"image\"\n", + "\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "if display_key not in b.info.features[\"steps\"][\"observation\"]:\n", + " raise ValueError(\n", + " f\"The key {display_key} was not found in this dataset.\\n\"\n", + " + \"Please choose a different image key to display for this dataset.\\n\"\n", + " + \"Here is the observation spec:\\n\"\n", + " + str(b.info.features[\"steps\"][\"observation\"])\n", + " )\n", + "\n", + "ds = b.as_dataset(split=\"train[:10]\").shuffle(10) # take only first 10 episodes\n", + "episode = next(iter(ds))\n", + "images = [step[\"observation\"][display_key] for step in episode[\"steps\"]]\n", + "images = [Image.fromarray(image.numpy()) for image in images]\n", + "display.Image(as_gif(images))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YrD4_8P9JxBw", + "outputId": "6c4bcf5f-b738-472c-d084-9c87f56962c8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('action', {'base_displacement_vector': , 'base_displacement_vertical_rotation': , 'gripper_closedness_action': , 'rotation_delta': , 'terminate_episode': , 'world_vector': })\n", + "('is_first', )\n", + "('is_last', )\n", + "('is_terminal', )\n", + "('observation', {'base_pose_tool_reached': , 'gripper_closed': , 'gripper_closedness_commanded': , 'height_to_bottom': , 'image': , 'natural_language_embedding': , 'natural_language_instruction': , 'orientation_box': , 'orientation_start': , 'robot_orientation_positions_box': , 'rotation_delta_to_go': , 'src_rotation': , 'vector_to_go': , 'workspace_bounds': })\n", + "('reward', )\n" + ] + } + ], + "source": [ + "# other elements of the episode step --> this may vary for each dataset\n", + "for elem in next(iter(episode[\"steps\"])).items():\n", + " print(elem)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-WHN-2OrKqGo" + }, + "source": [ + "# Download Datasets\n", + "\n", + "All datasets can be downloaded simply via `tfds.load()`.\n", + "Below we provide a script that downloads all datasets into `~/tensorflow_datasets` on your local machine. Simply copy the code and run it on your local machine to download the full dataset (XXX TB).\n", + "\n", + "If you want to filter the dataset before download, please refer to\n", + "[this Google Sheet](https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit?usp=sharing). It allows you\n", + "to filter the data by attributes like robot model, number of cameras, type of tasks etc. You can then download only the filtered datasets by pasting the\n", + "dataset list from the spreadsheet into the code below.\n", + "\n", + "The download code will automatically skip any datasets you have previously downloaded." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 617 + }, + "id": "wcsQuLjY7c0o", + "outputId": "43f99670-13d6-4ecc-f58f-263960681bed" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: tfds-nightly in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (4.9.3.dev202310060044)\n", + "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.4.0)\n", + "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.5.0)\n", + "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (8.1.7)\n", + "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.1.8)\n", + "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (1.5.2)\n", + "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.25.0)\n", + "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3)\n", + "Requirement already satisfied: protobuf>=3.20 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (3.20.3)\n", + "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (5.9.0)\n", + "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.29.0)\n", + "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.0)\n", + "Requirement already satisfied: termcolor in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3.0)\n", + "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.10.2)\n", + "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (4.65.0)\n", + "Requirement already satisfied: wrapt in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.1)\n", + "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (2023.9.2)\n", + "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (6.1.1)\n", + "Requirement already satisfied: typing_extensions in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (4.6.3)\n", + "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (3.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2023.5.7)\n", + "Requirement already satisfied: six in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from promise->tfds-nightly) (1.16.0)\n", + "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tfds-nightly) (1.61.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install tfds-nightly # to get most up-to-date registered datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "XtNplr0AP-ZH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading 2 datasets to ~/tensorflow_datasets.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:07<00:00, 3.67s/it]\n" + ] + } + ], + "source": [ + "import tensorflow_datasets as tfds\n", + "import tqdm\n", + "\n", + "# optionally replace the DATASET_NAMES below with the list of filtered datasets from the google sheet\n", + "DATASET_NAMES = [\n", + " \"fractal20220817_data\",\n", + " \"kuka\",\n", + " \"bridge\",\n", + " \"taco_play\",\n", + " \"jaco_play\",\n", + " \"berkeley_cable_routing\",\n", + " \"roboturk\",\n", + " \"nyu_door_opening_surprising_effectiveness\",\n", + " \"viola\",\n", + " \"berkeley_autolab_ur5\",\n", + " \"toto\",\n", + " \"language_table\",\n", + " \"columbia_cairlab_pusht_real\",\n", + " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", + " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", + " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", + " \"austin_buds_dataset_converted_externally_to_rlds\",\n", + " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", + " \"maniskill_dataset_converted_externally_to_rlds\",\n", + " \"furniture_bench_dataset_converted_externally_to_rlds\",\n", + " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", + " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", + " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", + " \"bc_z\",\n", + " \"usc_cloth_sim_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", + " \"utokyo_saytap_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", + " \"robo_net\",\n", + " \"berkeley_mvp_converted_externally_to_rlds\",\n", + " \"berkeley_rpt_converted_externally_to_rlds\",\n", + " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", + " \"stanford_mask_vit_converted_externally_to_rlds\",\n", + " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", + " \"dlr_sara_pour_converted_externally_to_rlds\",\n", + " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", + " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", + " \"asu_table_top_converted_externally_to_rlds\",\n", + " \"stanford_robocook_converted_externally_to_rlds\",\n", + " \"eth_agent_affordances\",\n", + " \"imperialcollege_sawyer_wrist_cam\",\n", + " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", + " \"uiuc_d3field\",\n", + " \"utaustin_mutex\",\n", + " \"berkeley_fanuc_manipulation\",\n", + " \"cmu_food_manipulation\",\n", + " \"cmu_play_fusion\",\n", + " \"cmu_stretch\",\n", + " \"berkeley_gnm_recon\",\n", + " \"berkeley_gnm_cory_hall\",\n", + " \"berkeley_gnm_sac_son\",\n", + "]\n", + "DATASET_NAMES = [\"fractal20220817_data\", \"bc_z\"]\n", + "DOWNLOAD_DIR = \"~/tensorflow_datasets\"\n", + "\n", + "print(f\"Downloading {len(DATASET_NAMES)} datasets to {DOWNLOAD_DIR}.\")\n", + "for dataset_name in tqdm.tqdm(DATASET_NAMES):\n", + " b = tfds.builder_from_directory(builder_dir=dataset2path(dataset_name))\n", + " b.download_and_prepare(download_dir=DOWNLOAD_DIR)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IyccDsRqwtMz" + }, + "source": [ + "# Data Loader Example\n", + "\n", + "Below, we demonstrate a simple example of how to load the dataset into training batches, where each sample in the batch only contains one step." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "X17VECdRwzka" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow_datasets as tfds\n", + "\n", + "# load raw dataset --> replace this with tfds.load() on your\n", + "# local machine!\n", + "dataset = \"fractal20220817_data\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds = b.as_dataset(split=\"train[:10]\")\n", + "\n", + "\n", + "def episode2steps(episode):\n", + " return episode[\"steps\"]\n", + "\n", + "\n", + "def step_map_fn(step):\n", + " return {\n", + " \"observation\": {\n", + " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", + " },\n", + " \"action\": tf.concat(\n", + " [\n", + " step[\"action\"][\"world_vector\"],\n", + " step[\"action\"][\"rotation_delta\"],\n", + " step[\"action\"][\"gripper_closedness_action\"],\n", + " ],\n", + " axis=-1,\n", + " ),\n", + " }\n", + "\n", + "\n", + "# convert RLDS episode dataset to individual steps & reformat\n", + "ds = ds.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", + "ds = ds.map(step_map_fn, num_parallel_calls=tf.data.AUTOTUNE)\n", + "\n", + "# shuffle, repeat, pre-fetch, batch\n", + "ds = ds.cache() # optionally keep full dataset in memory\n", + "ds = ds.shuffle(100) # set shuffle buffer size\n", + "ds = ds.repeat() # ensure that data never runs out" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t0uJH3X6w1LZ", + "outputId": "a42005e8-1072-4203-e6ba-b56784971175" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0it [00:00, ?it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "10000it [00:05, 1955.09it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "for i, batch in tqdm.tqdm(enumerate(ds.prefetch(3).batch(4).as_numpy_iterator())):\n", + " # here you would add your Jax / PyTorch training code\n", + " if i == 10000:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ekmsGRAnw3Bp" + }, + "source": [ + "# Interleave Multiple Datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "CslwEuBZwmLP" + }, + "outputs": [], + "source": [ + "# Load second dataset --> replace this with tfds.load() on your\n", + "# local machine!\n", + "dataset = \"bc_z\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds2 = b.as_dataset(split=\"train[:10]\")\n", + "\n", + "\n", + "def step_map_fn_mutex(step):\n", + " # reformat to align specs of both datasets\n", + " return {\n", + " \"observation\": {\n", + " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", + " },\n", + " \"action\": tf.random.uniform(shape=(7,), dtype=tf.float32, name=None),\n", + " }\n", + "\n", + "\n", + "ds2 = ds2.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", + "ds2 = ds2.map(step_map_fn_mutex, num_parallel_calls=tf.data.AUTOTUNE)\n", + "\n", + "# shuffle, repeat, pre-fetch, batch\n", + "ds2 = ds2.cache() # optionally keep full dataset in memory\n", + "ds2 = ds2.shuffle(100) # set shuffle buffer size\n", + "ds2 = ds2.repeat() # ensure that data never runs out" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "G2hcCJd8w6-D" + }, + "outputs": [], + "source": [ + "# interleave datasets w/ equal sampling weight\n", + "ds_combined = tf.data.Dataset.sample_from_datasets([ds, ds2], [0.5, 0.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hEnVFP9nw8iI", + "outputId": "68567be3-9c3b-46c2-d569-f999c900f03c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "10000it [00:06, 1546.22it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "for i, batch in tqdm.tqdm(\n", + " enumerate(ds_combined.prefetch(3).batch(4).as_numpy_iterator())\n", + "):\n", + " # here you would add your Jax / PyTorch training code\n", + " if i == 10000:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aew258oUbamg" + }, + "source": [ + "# Example Dataloader to produce trajectories\n", + "\n", + "When training transformers, we usually use trajectories of fix-length as input into the transformers. This is to enable the transformer to condition on a fixed window of history when predicting actions.\n", + "\n", + "Below we demonstrate how one can load the TFDS datasets, transform the episodes\n", + "into fixed-length \"trajectories\" and mix multiple datasets by aligning their specs." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "YU0qKdrp7oBT" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: rlds[tensorflow] in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (0.1.8)\n", + "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.4.0)\n", + "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.25.0)\n", + "Requirement already satisfied: tensorflow in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: tensorflow-datasets in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (4.9.3)\n", + "Requirement already satisfied: dm-reverb in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (0.13.0)\n", + "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (0.1.8)\n", + "Requirement already satisfied: portpicker in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (1.6.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=23.5.26 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.5.26)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.5.4)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", + "Requirement already satisfied: h5py>=2.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.10.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (16.0.6)\n", + "Requirement already satisfied: ml-dtypes==0.2.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.3.0)\n", + "Requirement already satisfied: packaging in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.0)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.20.3)\n", + "Requirement already satisfied: setuptools in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (67.8.0)\n", + "Requirement already satisfied: six>=1.12.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.16.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.3.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (4.6.3)\n", + "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.14.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.34.0)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.59.2)\n", + "Requirement already satisfied: tensorboard<2.15,>=2.14 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.1)\n", + "Requirement already satisfied: tensorflow-estimator<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: keras<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.5.0)\n", + "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (8.1.7)\n", + "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (1.5.2)\n", + "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.3)\n", + "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (5.9.0)\n", + "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.29.0)\n", + "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (1.14.0)\n", + "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.10.2)\n", + "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (4.65.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow->rlds[tensorflow]) (0.38.4)\n", + "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (2023.9.2)\n", + "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (6.1.1)\n", + "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (3.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2023.5.7)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.23.4)\n", + "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.0.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.5.1)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.0.1)\n", + "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tensorflow-datasets->rlds[tensorflow]) (1.61.0)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (5.3.2)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.3.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (4.9)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.3.1)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.1.1)\n", + "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.5.0)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.2.2)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install rlds[tensorflow]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "N3b5BEt1JvQJ" + }, + "outputs": [], + "source": [ + "from typing import Any, Dict, Union, NamedTuple\n", + "\n", + "import numpy as np\n", + "import tensorflow_datasets as tfds\n", + "import rlds\n", + "import reverb\n", + "from rlds import transformations\n", + "import tensorflow_datasets as tfds\n", + "import tree\n", + "\n", + "import abc\n", + "import dataclasses\n", + "from typing import Dict, Optional\n", + "\n", + "from rlds import rlds_types\n", + "import tensorflow as tf\n", + "from PIL import Image\n", + "from IPython import display" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "cellView": "form", + "id": "Dgf1OxIhJwib" + }, + "outputs": [], + "source": [ + "# @title Transformation definitions\n", + "\n", + "\n", + "def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec:\n", + " \"\"\"Converts a tfds Feature into a TensorSpec.\"\"\"\n", + "\n", + " def _get_feature_spec(nested_feature: tfds.features.FeatureConnector):\n", + " if isinstance(nested_feature, tf.DType):\n", + " return tf.TensorSpec(shape=(), dtype=nested_feature)\n", + " else:\n", + " return nested_feature.get_tensor_spec()\n", + "\n", + " # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to\n", + " # make sure we deal with the nested structure.\n", + " return tf.nest.map_structure(_get_feature_spec, feature)\n", + "\n", + "\n", + "def _encoded_feature(\n", + " feature: Optional[tfds.features.FeatureConnector],\n", + " image_encoding: Optional[str],\n", + " tensor_encoding: Optional[tfds.features.Encoding],\n", + "):\n", + " \"\"\"Adds encoding to Images and/or Tensors.\"\"\"\n", + "\n", + " def _apply_encoding(\n", + " feature: tfds.features.FeatureConnector,\n", + " image_encoding: Optional[str],\n", + " tensor_encoding: Optional[tfds.features.Encoding],\n", + " ):\n", + " if image_encoding and isinstance(feature, tfds.features.Image):\n", + " return tfds.features.Image(\n", + " shape=feature.shape,\n", + " dtype=feature.dtype,\n", + " use_colormap=feature.use_colormap,\n", + " encoding_format=image_encoding,\n", + " )\n", + " if (\n", + " tensor_encoding\n", + " and isinstance(feature, tfds.features.Tensor)\n", + " and feature.dtype != tf.string\n", + " ):\n", + " return tfds.features.Tensor(\n", + " shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding\n", + " )\n", + " return feature\n", + "\n", + " if not feature:\n", + " return None\n", + " return tf.nest.map_structure(\n", + " lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature\n", + " )\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class RLDSSpec(metaclass=abc.ABCMeta):\n", + " \"\"\"Specification of an RLDS Dataset.\n", + "\n", + " It is used to hold a spec that can be converted into a TFDS DatasetInfo or\n", + " a `tf.data.Dataset` spec.\n", + " \"\"\"\n", + "\n", + " observation_info: Optional[tfds.features.FeatureConnector] = None\n", + " action_info: Optional[tfds.features.FeatureConnector] = None\n", + " reward_info: Optional[tfds.features.FeatureConnector] = None\n", + " discount_info: Optional[tfds.features.FeatureConnector] = None\n", + " step_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", + " episode_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", + "\n", + " def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", + " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", + " step = {}\n", + " if self.observation_info:\n", + " step[rlds_types.OBSERVATION] = _features_to_tensor_spec(\n", + " self.observation_info\n", + " )\n", + " if self.action_info:\n", + " step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info)\n", + " if self.discount_info:\n", + " step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info)\n", + " if self.reward_info:\n", + " step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info)\n", + " if self.step_metadata_info:\n", + " for k, v in self.step_metadata_info.items():\n", + " step[k] = _features_to_tensor_spec(v)\n", + "\n", + " step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool)\n", + " step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool)\n", + " step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool)\n", + " return step\n", + "\n", + " def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", + " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", + " episode = {}\n", + " episode[rlds_types.STEPS] = tf.data.DatasetSpec(\n", + " element_spec=self.step_tensor_spec()\n", + " )\n", + " if self.episode_metadata_info:\n", + " for k, v in self.episode_metadata_info.items():\n", + " episode[k] = _features_to_tensor_spec(v)\n", + " return episode\n", + "\n", + " def to_dataset_config(\n", + " self,\n", + " name: str,\n", + " image_encoding: Optional[str] = None,\n", + " tensor_encoding: Optional[tfds.features.Encoding] = None,\n", + " citation: Optional[str] = None,\n", + " homepage: Optional[str] = None,\n", + " description: Optional[str] = None,\n", + " overall_description: Optional[str] = None,\n", + " ) -> tfds.rlds.rlds_base.DatasetConfig:\n", + " \"\"\"Obtains the DatasetConfig for TFDS from the Spec.\"\"\"\n", + " return tfds.rlds.rlds_base.DatasetConfig(\n", + " name=name,\n", + " description=description,\n", + " overall_description=overall_description,\n", + " homepage=homepage,\n", + " citation=citation,\n", + " observation_info=_encoded_feature(\n", + " self.observation_info, image_encoding, tensor_encoding\n", + " ),\n", + " action_info=_encoded_feature(\n", + " self.action_info, image_encoding, tensor_encoding\n", + " ),\n", + " reward_info=_encoded_feature(\n", + " self.reward_info, image_encoding, tensor_encoding\n", + " ),\n", + " discount_info=_encoded_feature(\n", + " self.discount_info, image_encoding, tensor_encoding\n", + " ),\n", + " step_metadata_info=_encoded_feature(\n", + " self.step_metadata_info, image_encoding, tensor_encoding\n", + " ),\n", + " episode_metadata_info=_encoded_feature(\n", + " self.episode_metadata_info, image_encoding, tensor_encoding\n", + " ),\n", + " )\n", + "\n", + " def to_features_dict(self):\n", + " \"\"\"Returns a TFDS FeaturesDict representing the dataset config.\"\"\"\n", + " step_config = {\n", + " rlds_types.IS_FIRST: tf.bool,\n", + " rlds_types.IS_LAST: tf.bool,\n", + " rlds_types.IS_TERMINAL: tf.bool,\n", + " }\n", + "\n", + " if self.observation_info:\n", + " step_config[rlds_types.OBSERVATION] = self.observation_info\n", + " if self.action_info:\n", + " step_config[rlds_types.ACTION] = self.action_info\n", + " if self.discount_info:\n", + " step_config[rlds_types.DISCOUNT] = self.discount_info\n", + " if self.reward_info:\n", + " step_config[rlds_types.REWARD] = self.reward_info\n", + "\n", + " if self.step_metadata_info:\n", + " for k, v in self.step_metadata_info.items():\n", + " step_config[k] = v\n", + "\n", + " if self.episode_metadata_info:\n", + " return tfds.features.FeaturesDict(\n", + " {\n", + " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", + " **self.episode_metadata_info,\n", + " }\n", + " )\n", + " else:\n", + " return tfds.features.FeaturesDict(\n", + " {\n", + " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", + " }\n", + " )\n", + "\n", + "\n", + "RLDS_SPEC = RLDSSpec\n", + "TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]]\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class TrajectoryTransform(metaclass=abc.ABCMeta):\n", + " \"\"\"Specification the TrajectoryTransform applied to a dataset of episodes.\n", + "\n", + " A TrajectoryTransform is a set of rules transforming a dataset\n", + " of RLDS episodes to a dataset of trajectories.\n", + " This involves three distinct stages:\n", + " - An optional `episode_to_steps_map_fn(episode)` is called at the episode\n", + " level, and can be used to select or modify steps.\n", + " - Augmentation: an `episode_key` could be propagated to `steps` for\n", + " debugging.\n", + " - Selection: Particular steps can be selected.\n", + " - Stripping: Features can be removed from steps. Prefer using `step_map_fn`.\n", + " - An optional `step_map_fn` is called at the flattened steps dataset for each\n", + " step, and can be used to featurize a step, e.g. add/remove features, or\n", + " augument images\n", + " - A `pattern` leverages DM patterns to set a rule of slicing an episode to a\n", + " dataset of overlapping trajectories.\n", + "\n", + " Importantly, each TrajectoryTransform must define a `expected_tensor_spec`\n", + " which specifies a nested TensorSpec of the resulting dataset. This is what\n", + " this TrajectoryTransform will produce, and can be used as an interface with\n", + " a neural network.\n", + " \"\"\"\n", + "\n", + " episode_dataset_spec: RLDS_SPEC\n", + " episode_to_steps_fn_dataset_spec: RLDS_SPEC\n", + " steps_dataset_spec: Any\n", + " pattern: reverb.structured_writer.Pattern\n", + " episode_to_steps_map_fn: Any\n", + " expected_tensor_spec: TENSOR_SPEC\n", + " step_map_fn: Optional[Any] = None\n", + "\n", + " def get_for_cached_trajectory_transform(self):\n", + " \"\"\"Creates a copy of this traj transform to use with caching.\n", + "\n", + " The returned TrajectoryTransfrom copy will be initialized with the default\n", + " version of the `episode_to_steps_map_fn`, because the effect of that\n", + " function has already been materialized in the cached copy of the dataset.\n", + " Returns:\n", + " trajectory_transform: A copy of the TrajectoryTransform with overridden\n", + " `episode_to_steps_map_fn`.\n", + " \"\"\"\n", + " traj_copy = dataclasses.replace(self)\n", + " traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec\n", + " traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS]\n", + " return traj_copy\n", + "\n", + " def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset):\n", + " \"\"\"Applies this TrajectoryTransform to the dataset of episodes.\"\"\"\n", + "\n", + " # Convert the dataset of episodes to the dataset of steps.\n", + " steps_dataset = episodes_dataset.map(\n", + " self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE\n", + " ).flat_map(lambda x: x)\n", + "\n", + " return self._create_pattern_dataset(steps_dataset)\n", + "\n", + " def transform_steps_rlds_dataset(\n", + " self, steps_dataset: tf.data.Dataset\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Applies this TrajectoryTransform to the dataset of episode steps.\"\"\"\n", + "\n", + " return self._create_pattern_dataset(steps_dataset)\n", + "\n", + " def create_test_dataset(\n", + " self,\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Creates a test dataset of trajectories.\n", + "\n", + " It is guaranteed that the structure of this dataset will be the same as\n", + " when flowing real data. Hence this is a useful construct for tests or\n", + " initialization of JAX models.\n", + " Returns:\n", + " dataset: A test dataset made of zeros structurally identical to the\n", + " target dataset of trajectories.\n", + " \"\"\"\n", + " zeros = transformations.zeros_from_spec(self.expected_tensor_spec)\n", + "\n", + " return tf.data.Dataset.from_tensors(zeros)\n", + "\n", + " def _create_pattern_dataset(\n", + " self, steps_dataset: tf.data.Dataset\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Create PatternDataset from the `steps_dataset`.\"\"\"\n", + " config = create_structured_writer_config(\"temp\", self.pattern)\n", + "\n", + " # Further transform each step if the `step_map_fn` is provided.\n", + " if self.step_map_fn:\n", + " steps_dataset = steps_dataset.map(self.step_map_fn)\n", + " pattern_dataset = reverb.PatternDataset(\n", + " input_dataset=steps_dataset,\n", + " configs=[config],\n", + " respect_episode_boundaries=True,\n", + " is_end_of_episode=lambda x: x[rlds_types.IS_LAST],\n", + " )\n", + " return pattern_dataset\n", + "\n", + "\n", + "class TrajectoryTransformBuilder(object):\n", + " \"\"\"Facilitates creation of the `TrajectoryTransform`.\"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dataset_spec: RLDS_SPEC,\n", + " episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS],\n", + " step_map_fn=None,\n", + " pattern_fn=None,\n", + " expected_tensor_spec=None,\n", + " ):\n", + " self._rds_dataset_spec = dataset_spec\n", + " self._steps_spec = None\n", + " self._episode_to_steps_map_fn = episode_to_steps_map_fn\n", + " self._step_map_fn = step_map_fn\n", + " self._pattern_fn = pattern_fn\n", + " self._expected_tensor_spec = expected_tensor_spec\n", + "\n", + " def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform:\n", + " \"\"\"Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.\"\"\"\n", + "\n", + " if validate_expected_tensor_spec and self._expected_tensor_spec is None:\n", + " raise ValueError(\"`expected_tensor_spec` must be set.\")\n", + "\n", + " episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec)\n", + "\n", + " steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn)\n", + "\n", + " episode_to_steps_fn_dataset_spec = self._rds_dataset_spec\n", + "\n", + " if self._step_map_fn is not None:\n", + " steps_ds = steps_ds.map(self._step_map_fn)\n", + "\n", + " zeros_spec = transformations.zeros_from_spec(\n", + " steps_ds.element_spec\n", + " ) # pytype: disable=wrong-arg-types\n", + "\n", + " ref_step = reverb.structured_writer.create_reference_step(zeros_spec)\n", + "\n", + " pattern = self._pattern_fn(ref_step)\n", + "\n", + " steps_ds_spec = steps_ds.element_spec\n", + "\n", + " target_tensor_structure = create_reverb_table_signature(\n", + " \"temp_table\", steps_ds_spec, pattern\n", + " )\n", + "\n", + " if (\n", + " validate_expected_tensor_spec\n", + " and self._expected_tensor_spec != target_tensor_structure\n", + " ):\n", + " raise RuntimeError(\n", + " \"The tensor spec of the TrajectoryTransform doesn't \"\n", + " \"match the expected spec.\\n\"\n", + " \"Expected:\\n%s\\nActual:\\n%s\\n\"\n", + " % (\n", + " str(self._expected_tensor_spec).replace(\n", + " \"TensorSpec\", \"tf.TensorSpec\"\n", + " ),\n", + " str(target_tensor_structure).replace(\"TensorSpec\", \"tf.TensorSpec\"),\n", + " )\n", + " )\n", + "\n", + " return TrajectoryTransform(\n", + " episode_dataset_spec=self._rds_dataset_spec,\n", + " episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec,\n", + " steps_dataset_spec=steps_ds_spec,\n", + " pattern=pattern,\n", + " episode_to_steps_map_fn=self._episode_to_steps_map_fn,\n", + " step_map_fn=self._step_map_fn,\n", + " expected_tensor_spec=target_tensor_structure,\n", + " )\n", + "\n", + "\n", + "def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC):\n", + " \"\"\"Creates a zero valued dataset of episodes for the given RLDS Spec.\"\"\"\n", + "\n", + " def add_steps(episode, step_spec):\n", + " episode[rlds_types.STEPS] = transformations.zero_dataset_like(\n", + " tf.data.DatasetSpec(step_spec)\n", + " )\n", + " if \"fake\" in episode:\n", + " del episode[\"fake\"]\n", + " return episode\n", + "\n", + " episode_without_steps_spec = {\n", + " k: v\n", + " for k, v in rlds_spec.episode_tensor_spec().items()\n", + " if k != rlds_types.STEPS\n", + " }\n", + "\n", + " if episode_without_steps_spec:\n", + " episodes_dataset = transformations.zero_dataset_like(\n", + " tf.data.DatasetSpec(episode_without_steps_spec)\n", + " )\n", + " else:\n", + " episodes_dataset = tf.data.Dataset.from_tensors({\"fake\": \"\"})\n", + "\n", + " episodes_dataset_with_steps = episodes_dataset.map(\n", + " lambda episode: add_steps(episode, rlds_spec.step_tensor_spec())\n", + " )\n", + " return episodes_dataset_with_steps\n", + "\n", + "\n", + "def create_reverb_table_signature(\n", + " table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern\n", + ") -> reverb.reverb_types.SpecNest:\n", + " config = create_structured_writer_config(table_name, pattern)\n", + " reverb_table_spec = reverb.structured_writer.infer_signature(\n", + " [config], steps_dataset_spec\n", + " )\n", + " return reverb_table_spec\n", + "\n", + "\n", + "def create_structured_writer_config(\n", + " table_name: str, pattern: reverb.structured_writer.Pattern\n", + ") -> Any:\n", + " config = reverb.structured_writer.create_config(\n", + " pattern=pattern, table=table_name, conditions=[]\n", + " )\n", + " return config\n", + "\n", + "\n", + "def n_step_pattern_builder(n: int) -> Any:\n", + " \"\"\"Creates trajectory of length `n` from all fields of a `ref_step`.\"\"\"\n", + "\n", + " def transform_fn(ref_step):\n", + " traj = {}\n", + " for key in ref_step:\n", + " if isinstance(ref_step[key], dict):\n", + " transformed_entry = tree.map_structure(\n", + " lambda ref_node: ref_node[-n:], ref_step[key]\n", + " )\n", + " traj[key] = transformed_entry\n", + " else:\n", + " traj[key] = ref_step[key][-n:]\n", + "\n", + " return traj\n", + "\n", + " return transform_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BK4RRYkbLN5B" + }, + "source": [ + "## Demonstration of transformation from an episode to a trajectory\n", + "\n", + "A real ML pipeline would rarely learn from a whole episode. Instead the input to a model is a _trajectory_. A `Trajectory` is a particular way to slice a sequence of episode steps. `SARSA` trajectory is one well known example, but a trajectory of an arbitrary length `n` is also an option. Often, a set of _overlapping_ trajectories is produced from an episode. For example, given the following episode steps:\n", + "\n", + "`episode=[s_0, s_1, s_2, s_3, s_4, s_T]`\n", + "\n", + "and a target Trajectory of length `3`, the following trajectories are produced:\n", + "\n", + "`t_1=[s_0, s_1, s_2]`\n", + "\n", + "`t_2=[s_1, s_2, s_3]`\n", + "\n", + "`t_3=[s_2, s_3, s_4]`\n", + "\n", + "`t_4=[s_3, s_4, s_T]`\n", + "\n", + "\n", + "To perform such a slicing, the dataset of episode is first \"flattened\" to the dataset of steps. The `is_last` attribute of an RLDS step allows proper slicing, not crossing the episode boundary. The `TrajectoryTransformBuilder` demonstrates this:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "id": "_NsYnqnpNgNl" + }, + "outputs": [], + "source": [ + "import tensorflow_datasets as tfds\n", + "\n", + "dataset = \"fractal20220817_data\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds = b.as_dataset(split=\"train[:10]\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "2qvMcpGDx6hJ" + }, + "outputs": [], + "source": [ + "# The RLDSSpec for the RT1 dataset.\n", + "rt1_spec = RLDSSpec(\n", + " observation_info=b.info.features[\"steps\"][\"observation\"],\n", + " action_info=b.info.features[\"steps\"][\"action\"],\n", + ")\n", + "\n", + "# The following will create a trajectories of length 3.\n", + "trajectory_length = 3\n", + "trajectory_transform = TrajectoryTransformBuilder(\n", + " rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length)\n", + ").build(validate_expected_tensor_spec=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "Fk4ZfC_bMBw3" + }, + "outputs": [], + "source": [ + "trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds)\n", + "\n", + "trajectory_iter = iter(trajectory_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "fSxk3zF_x0FS" + }, + "outputs": [], + "source": [ + "trajectory = next(trajectory_iter)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t2V0xrIVMWNc", + "outputId": "5c71d7ef-2fc7-424e-a8ae-0e1c60252f42" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'action': {'base_displacement_vector': ,\n", + " 'gripper_closedness_action': ,\n", + " 'world_vector': ,\n", + " 'rotation_delta': ,\n", + " 'base_displacement_vertical_rotation': ,\n", + " 'terminate_episode': },\n", + " 'is_first': ,\n", + " 'is_last': ,\n", + " 'observation': {'robot_orientation_positions_box': ,\n", + " 'workspace_bounds': ,\n", + " 'natural_language_instruction': ,\n", + " 'image': ,\n", + " 'src_rotation': ,\n", + " 'orientation_box': ,\n", + " 'height_to_bottom': ,\n", + " 'vector_to_go': ,\n", + " 'rotation_delta_to_go': ,\n", + " 'gripper_closedness_commanded': ,\n", + " 'orientation_start': ,\n", + " 'gripper_closed': ,\n", + " 'base_pose_tool_reached': ,\n", + " 'natural_language_embedding': },\n", + " 'is_terminal': }" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajectory" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ytrvi945NTZz", + "outputId": "50dd5318-7521-4d85-a1cf-42aa046ce4c3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "TensorShape([3, 256, 320, 3])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Note that the leading dimension (3) corresponds to the trajectory_length\n", + "trajectory[\"observation\"][\"image\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 529 + }, + "id": "xhDX3BcWNmrl", + "outputId": "0d4c3c74-7d71-45e3-baea-c5f119eea9a4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "episode = next(iter(ds))\n", + "\n", + "# Iterate over steps of the episode. Collect images.\n", + "images = [\n", + " trajectory[\"observation\"][\"image\"][id]\n", + " for id in range(trajectory[\"observation\"][\"image\"].shape[0])\n", + "]\n", + "images = [Image.fromarray(image.numpy()) for image in images]\n", + "\n", + "display.Image(as_gif(images))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oy89HzymQyAq" + }, + "source": [ + "## Combination of multiple datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "id": "qs0-7alaQ3C9" + }, + "outputs": [], + "source": [ + "import tensorflow_datasets as tfds\n", + "\n", + "robo_net_builder = tfds.builder_from_directory(\n", + " builder_dir=\"gs://gresearch/robotics/robo_net/1.0.0/\"\n", + ")\n", + "\n", + "robo_net_builder_episodic_dataset = robo_net_builder.as_dataset(split=\"train[:10]\")\n", + "episodes = list(iter(robo_net_builder_episodic_dataset))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "id": "2tgJpMqARIFQ" + }, + "outputs": [], + "source": [ + "# The following will create a trajectories of length 3.\n", + "trajectory_length = 3\n", + "\n", + "robo_net_rlds_spec = RLDSSpec(\n", + " observation_info=robo_net_builder.info.features[\"steps\"][\"observation\"],\n", + " action_info=robo_net_builder.info.features[\"steps\"][\"action\"],\n", + ")\n", + "\n", + "\n", + "def robo_net_step_map_fn(step):\n", + " transformed_step = {}\n", + " transformed_step[\"observation\"] = step[\"observation\"][\"image\"]\n", + " transformed_step[\"is_first\"] = step[\"is_first\"]\n", + " transformed_step[\"is_last\"] = step[\"is_last\"]\n", + " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", + " return transformed_step\n", + "\n", + "\n", + "robo_net_trajectory_transform = TrajectoryTransformBuilder(\n", + " robo_net_rlds_spec,\n", + " step_map_fn=robo_net_step_map_fn,\n", + " pattern_fn=n_step_pattern_builder(trajectory_length),\n", + ").build(validate_expected_tensor_spec=False)\n", + "\n", + "\n", + "def mt_opt_step_map_fn(step):\n", + " transformed_step = {}\n", + " transformed_step[\"observation\"] = tf.cast(\n", + " tf.image.resize(step[\"observation\"][\"image\"], [240, 320]), tf.uint8\n", + " ) # Resize to be compatible with robo_net trajectory\n", + " transformed_step[\"is_first\"] = step[\"is_first\"]\n", + " transformed_step[\"is_last\"] = step[\"is_last\"]\n", + " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", + " return transformed_step\n", + "\n", + "\n", + "mt_opt_trajectory_transform = TrajectoryTransformBuilder(\n", + " rt1_spec,\n", + " step_map_fn=mt_opt_step_map_fn,\n", + " pattern_fn=n_step_pattern_builder(trajectory_length),\n", + ").build(validate_expected_tensor_spec=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "id": "anGArTQbTiHj" + }, + "outputs": [], + "source": [ + "# Validate that the specs are equal\n", + "assert (\n", + " robo_net_trajectory_transform.expected_tensor_spec\n", + " == mt_opt_trajectory_transform.expected_tensor_spec\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "id": "L9gRx6BfTGH-" + }, + "outputs": [], + "source": [ + "# Create trajectory datasets for the two normalized representations:\n", + "robo_net_trajectory_dataset = (\n", + " robo_net_trajectory_transform.transform_episodic_rlds_dataset(\n", + " robo_net_builder_episodic_dataset\n", + " )\n", + ")\n", + "mt_opt_trajectory_dataset = mt_opt_trajectory_transform.transform_episodic_rlds_dataset(\n", + " ds\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "id": "-SVkHpIxRVXz" + }, + "outputs": [], + "source": [ + "combined_dataset = tf.data.Dataset.sample_from_datasets(\n", + " [robo_net_trajectory_dataset, mt_opt_trajectory_dataset]\n", + ")\n", + "combined_dataset = combined_dataset.batch(2)\n", + "combined_dataset_it = iter(combined_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "id": "-CMdwIcsR30k" + }, + "outputs": [], + "source": [ + "example = next(combined_dataset_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "w2YJOvRKUb2E", + "outputId": "31daf4b7-9350-4d05-9c57-d9784bc34d44" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# First element of the batch returns a robot_net trajectory\n", + "Image.fromarray(example[\"observation\"].numpy()[0][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "FP0iz-f_UoTY", + "outputId": "244fb34b-fa72-4c02-e432-8a0382f45b17" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Second element of the batch returns a mt_opt trajectory\n", + "Image.fromarray(example[\"observation\"].numpy()[1][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N2Efw2aHVfSX" + }, + "source": [ + "# Available datasets and their sizes:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kQkeUKyrVhGK", + "outputId": "a61cb54f-fd1e-41d0-858b-19d30659c8b1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset gs://gresearch/robotics/fractal20220817_data/0.1.0 has size 111.07 GiB\n", + "Dataset gs://gresearch/robotics/kuka/0.1.0 has size 778.02 GiB\n", + "Dataset gs://gresearch/robotics/bridge/0.1.0 has size 387.49 GiB\n", + "Dataset gs://gresearch/robotics/taco_play/0.1.0 has size 47.77 GiB\n", + "Dataset gs://gresearch/robotics/jaco_play/0.1.0 has size 9.24 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_cable_routing/0.1.0 has size 4.67 GiB\n", + "Dataset gs://gresearch/robotics/roboturk/0.1.0 has size 45.39 GiB\n", + "Dataset gs://gresearch/robotics/nyu_door_opening_surprising_effectiveness/0.1.0 has size 7.12 GiB\n", + "Dataset gs://gresearch/robotics/viola/0.1.0 has size 10.40 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_autolab_ur5/0.1.0 has size 76.39 GiB\n", + "Dataset gs://gresearch/robotics/toto/0.1.0 has size 127.66 GiB\n", + "Dataset gs://gresearch/robotics/language_table/0.0.1 has size 399.23 GiB\n", + "Dataset gs://gresearch/robotics/columbia_cairlab_pusht_real/0.1.0 has size 2.80 GiB\n", + "Dataset gs://gresearch/robotics/stanford_kuka_multimodal_dataset_converted_externally_to_rlds/0.1.0 has size 31.98 GiB\n", + "Dataset gs://gresearch/robotics/nyu_rot_dataset_converted_externally_to_rlds/0.1.0 has size 5.33 MiB\n", + "Dataset gs://gresearch/robotics/stanford_hydra_dataset_converted_externally_to_rlds/0.1.0 has size 72.48 GiB\n", + "Dataset gs://gresearch/robotics/austin_buds_dataset_converted_externally_to_rlds/0.1.0 has size 1.49 GiB\n", + "Dataset gs://gresearch/robotics/nyu_franka_play_dataset_converted_externally_to_rlds/0.1.0 has size 5.18 GiB\n", + "Dataset gs://gresearch/robotics/maniskill_dataset_converted_externally_to_rlds/0.1.0 has size 151.05 GiB\n", + "Dataset gs://gresearch/robotics/cmu_franka_exploration_dataset_converted_externally_to_rlds/0.1.0 has size 602.24 MiB\n", + "Dataset gs://gresearch/robotics/ucsd_kitchen_dataset_converted_externally_to_rlds/0.1.0 has size 1.33 GiB\n", + "Dataset gs://gresearch/robotics/ucsd_pick_and_place_dataset_converted_externally_to_rlds/0.1.0 has size 3.53 GiB\n", + "Dataset gs://gresearch/robotics/austin_sailor_dataset_converted_externally_to_rlds/0.1.0 has size 18.85 GiB\n", + "Dataset gs://gresearch/robotics/austin_sirius_dataset_converted_externally_to_rlds/0.1.0 has size 6.55 GiB\n", + "Dataset gs://gresearch/robotics/bc_z/0.1.0 has size 80.54 GiB\n", + "Dataset gs://gresearch/robotics/usc_cloth_sim_converted_externally_to_rlds/0.1.0 has size 254.52 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_pr2_opening_fridge_converted_externally_to_rlds/0.1.0 has size 360.57 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds/0.1.0 has size 829.37 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_saytap_converted_externally_to_rlds/0.1.0 has size 55.34 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_xarm_pick_and_place_converted_externally_to_rlds/0.1.0 has size 1.29 GiB\n", + "Dataset gs://gresearch/robotics/utokyo_xarm_bimanual_converted_externally_to_rlds/0.1.0 has size 138.44 MiB\n", + "Dataset gs://gresearch/robotics/robo_net/1.0.0 has size 799.91 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_mvp_converted_externally_to_rlds/0.1.0 has size 12.34 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_rpt_converted_externally_to_rlds/0.1.0 has size 40.64 GiB\n", + "Dataset gs://gresearch/robotics/kaist_nonprehensile_converted_externally_to_rlds/0.1.0 has size 11.71 GiB\n", + "Dataset gs://gresearch/robotics/stanford_mask_vit_converted_externally_to_rlds/0.1.0 has size 76.17 GiB\n", + "Dataset gs://gresearch/robotics/tokyo_u_lsmo_converted_externally_to_rlds/0.1.0 has size 335.71 MiB\n", + "Dataset gs://gresearch/robotics/dlr_sara_pour_converted_externally_to_rlds/0.1.0 has size 2.92 GiB\n", + "Dataset gs://gresearch/robotics/dlr_sara_grid_clamp_converted_externally_to_rlds/0.1.0 has size 1.65 GiB\n", + "Dataset gs://gresearch/robotics/dlr_edan_shared_control_converted_externally_to_rlds/0.1.0 has size 3.09 GiB\n", + "Dataset gs://gresearch/robotics/asu_table_top_converted_externally_to_rlds/0.1.0 has size 737.60 MiB\n", + "Dataset gs://gresearch/robotics/stanford_robocook_converted_externally_to_rlds/0.1.0 has size 124.62 GiB\n", + "Dataset gs://gresearch/robotics/eth_agent_affordances/0.1.0 has size 17.27 GiB\n", + "Dataset gs://gresearch/robotics/imperialcollege_sawyer_wrist_cam/0.1.0 has size 81.87 MiB\n", + "Dataset gs://gresearch/robotics/iamlab_cmu_pickup_insert_converted_externally_to_rlds/0.1.0 has size 50.29 GiB\n", + "Dataset gs://gresearch/robotics/uiuc_d3field/0.1.0 has size 15.82 GiB\n", + "Dataset gs://gresearch/robotics/utaustin_mutex/0.1.0 has size 20.79 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_fanuc_manipulation/0.1.0 has size 8.85 GiB\n", + "Dataset gs://gresearch/robotics/cmu_play_fusion/0.1.0 has size 6.68 GiB\n", + "Dataset gs://gresearch/robotics/cmu_stretch/0.1.0 has size 728.06 MiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_recon/0.1.0 has size 18.73 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_cory_hall/0.1.0 has size 1.39 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_sac_son/0.1.0 has size 7.00 GiB\n" + ] + } + ], + "source": [ + "# Iterate over and make sure that a dataset can be created\n", + "for name in DATASETS:\n", + " uri = dataset2path(name)\n", + " b = tfds.builder_from_directory(builder_dir=uri)\n", + " split = list(b.info.splits.keys())[0]\n", + " b.as_dataset(split=split)\n", + " print(\"Dataset %s has size %s\" % (uri, b.info.dataset_size))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ZnRYMsVpaZKF", + "outputId": "d546a431-5dad-4aee-d6f6-b9aa4207e319" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/tensorflow/datasets.git\n", + " Cloning https://github.com/tensorflow/datasets.git to /tmp/pip-req-build-d48q8hrq\n", + " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/datasets.git /tmp/pip-req-build-d48q8hrq\n", + " Resolved https://github.com/tensorflow/datasets.git to commit 0f2cce155781202f05fbe8007a763e12ef9fc6ee\n", + " Installing build dependencies ... \u001b[?25ldone\n", + "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", + "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25hCollecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading absl_py-2.0.0-py3-none-any.whl.metadata (2.3 kB)\n", + "Collecting click (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading click-8.1.7-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting dm-tree (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading dm_tree-0.1.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (152 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.8/152.8 kB\u001b[0m \u001b[31m654.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m1m687.2 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hCollecting etils>=0.9.0 (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading etils-1.5.2-py3-none-any.whl.metadata (6.3 kB)\n", + "Collecting numpy (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.2/61.2 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting promise (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached promise-2.3-py3-none-any.whl\n", + "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading protobuf-4.25.0-cp37-abi3-manylinux2014_x86_64.whl.metadata (541 bytes)\n", + "Collecting psutil (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (21 kB)\n", + "Collecting requests>=2.19.0 (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading requests-2.31.0-py3-none-any.whl.metadata (4.6 kB)\n", + "Collecting tensorflow-metadata (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached tensorflow_metadata-1.14.0-py3-none-any.whl.metadata (2.1 kB)\n", + "Collecting termcolor (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", + "Collecting toml (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", + "Collecting tqdm (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading tqdm-4.66.1-py3-none-any.whl.metadata (57 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.6/57.6 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting wrapt (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n", + "Collecting array-record>=0.5.0 (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (503 bytes)\n", + "Collecting fsspec (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading fsspec-2023.10.0-py3-none-any.whl.metadata (6.8 kB)\n", + "Collecting importlib_resources (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading importlib_resources-6.1.1-py3-none-any.whl.metadata (4.1 kB)\n", + "Collecting typing_extensions (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading typing_extensions-4.8.0-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting zipp (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading zipp-3.17.0-py3-none-any.whl.metadata (3.7 kB)\n", + "Collecting charset-normalizer<4,>=2 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (33 kB)\n", + "Collecting idna<4,>=2.5 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading idna-3.4-py3-none-any.whl (61 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.5/61.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting urllib3<3,>=1.21.1 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading urllib3-2.0.7-py3-none-any.whl.metadata (6.6 kB)\n", + "Collecting certifi>=2017.4.17 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading certifi-2023.7.22-py3-none-any.whl.metadata (2.2 kB)\n", + "Collecting six (from promise->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n", + "Collecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached absl_py-1.4.0-py3-none-any.whl (126 kB)\n", + "Collecting googleapis-common-protos<2,>=1.52.0 (from tensorflow-metadata->tensorflow-datasets==4.9.3+nightly)\n", + " Using cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl.metadata (1.5 kB)\n", + "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached protobuf-3.20.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n", + "Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.0 MB)\n", + "Downloading etils-1.5.2-py3-none-any.whl (140 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading requests-2.31.0-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.6/62.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading click-8.1.7-py3-none-any.whl (97 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.9/97.9 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (283 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m283.6/283.6 kB\u001b[0m \u001b[31m16.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached tensorflow_metadata-1.14.0-py3-none-any.whl (28 kB)\n", + "Downloading tqdm-4.66.1-py3-none-any.whl (78 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.3/78.3 kB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (80 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m80.3/80.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading certifi-2023.7.22-py3-none-any.whl (158 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.3/158.3 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (142 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m142.1/142.1 kB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl (230 kB)\n", + "Downloading urllib3-2.0.7-py3-none-any.whl (124 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 kB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading fsspec-2023.10.0-py3-none-any.whl (166 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m166.4/166.4 kB\u001b[0m \u001b[31m13.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading importlib_resources-6.1.1-py3-none-any.whl (33 kB)\n", + "Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", + "Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", + "Building wheels for collected packages: tensorflow-datasets\n", + " Building wheel for tensorflow-datasets (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for tensorflow-datasets: filename=tensorflow_datasets-4.9.3+nightly-py3-none-any.whl size=5042188 sha256=b922a59c63a43266324047d6de8cc70c4e902e4be1002a629f6fc9144b42026e\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-yum8n3h3/wheels/69/95/f3/0a7e5341cee7ec33827b33149e1556b4e39317c704cb2751bd\n", + "Successfully built tensorflow-datasets\n", + "Installing collected packages: dm-tree, zipp, wrapt, urllib3, typing_extensions, tqdm, toml, termcolor, six, psutil, protobuf, numpy, importlib_resources, idna, fsspec, etils, click, charset-normalizer, certifi, absl-py, requests, promise, googleapis-common-protos, tensorflow-metadata, array-record, tensorflow-datasets\n", + " Attempting uninstall: dm-tree\n", + " Found existing installation: dm-tree 0.1.8\n", + " Uninstalling dm-tree-0.1.8:\n", + " Successfully uninstalled dm-tree-0.1.8\n", + " Attempting uninstall: zipp\n", + " Found existing installation: zipp 3.17.0\n", + " Uninstalling zipp-3.17.0:\n", + " Successfully uninstalled zipp-3.17.0\n", + " Attempting uninstall: wrapt\n", + " Found existing installation: wrapt 1.14.1\n", + " Uninstalling wrapt-1.14.1:\n", + " Successfully uninstalled wrapt-1.14.1\n", + " Attempting uninstall: urllib3\n", + " Found existing installation: urllib3 1.26.16\n", + " Uninstalling urllib3-1.26.16:\n", + " Successfully uninstalled urllib3-1.26.16\n", + " Attempting uninstall: typing_extensions\n", + " Found existing installation: typing_extensions 4.6.3\n", + " Uninstalling typing_extensions-4.6.3:\n", + " Successfully uninstalled typing_extensions-4.6.3\n", + " Attempting uninstall: tqdm\n", + " Found existing installation: tqdm 4.65.0\n", + " Uninstalling tqdm-4.65.0:\n", + " Successfully uninstalled tqdm-4.65.0\n", + " Attempting uninstall: toml\n", + " Found existing installation: toml 0.10.2\n", + " Uninstalling toml-0.10.2:\n", + " Successfully uninstalled toml-0.10.2\n", + " Attempting uninstall: termcolor\n", + " Found existing installation: termcolor 2.3.0\n", + " Uninstalling termcolor-2.3.0:\n", + " Successfully uninstalled termcolor-2.3.0\n", + " Attempting uninstall: six\n", + " Found existing installation: six 1.16.0\n", + " Uninstalling six-1.16.0:\n", + " Successfully uninstalled six-1.16.0\n", + " Attempting uninstall: psutil\n", + " Found existing installation: psutil 5.9.0\n", + " Uninstalling psutil-5.9.0:\n", + " Successfully uninstalled psutil-5.9.0\n", + " Attempting uninstall: protobuf\n", + " Found existing installation: protobuf 3.20.3\n", + " Uninstalling protobuf-3.20.3:\n", + " Successfully uninstalled protobuf-3.20.3\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 1.25.0\n", + " Uninstalling numpy-1.25.0:\n", + " Successfully uninstalled numpy-1.25.0\n", + " Attempting uninstall: importlib_resources\n", + " Found existing installation: importlib-resources 6.1.1\n", + " Uninstalling importlib-resources-6.1.1:\n", + " Successfully uninstalled importlib-resources-6.1.1\n", + " Attempting uninstall: idna\n", + " Found existing installation: idna 3.4\n", + " Uninstalling idna-3.4:\n", + " Successfully uninstalled idna-3.4\n", + " Attempting uninstall: fsspec\n", + " Found existing installation: fsspec 2023.9.2\n", + " Uninstalling fsspec-2023.9.2:\n", + " Successfully uninstalled fsspec-2023.9.2\n", + " Attempting uninstall: etils\n", + " Found existing installation: etils 1.5.2\n", + " Uninstalling etils-1.5.2:\n", + " Successfully uninstalled etils-1.5.2\n", + " Attempting uninstall: click\n", + " Found existing installation: click 8.1.7\n", + " Uninstalling click-8.1.7:\n", + " Successfully uninstalled click-8.1.7\n", + " Attempting uninstall: charset-normalizer\n", + " Found existing installation: charset-normalizer 2.0.4\n", + " Uninstalling charset-normalizer-2.0.4:\n", + " Successfully uninstalled charset-normalizer-2.0.4\n", + " Attempting uninstall: certifi\n", + " Found existing installation: certifi 2023.5.7\n", + " Uninstalling certifi-2023.5.7:\n", + " Successfully uninstalled certifi-2023.5.7\n", + " Attempting uninstall: absl-py\n", + " Found existing installation: absl-py 1.4.0\n", + " Uninstalling absl-py-1.4.0:\n", + " Successfully uninstalled absl-py-1.4.0\n", + " Attempting uninstall: requests\n", + " Found existing installation: requests 2.29.0\n", + " Uninstalling requests-2.29.0:\n", + " Successfully uninstalled requests-2.29.0\n", + " Attempting uninstall: promise\n", + " Found existing installation: promise 2.3\n", + " Uninstalling promise-2.3:\n", + " Successfully uninstalled promise-2.3\n", + " Attempting uninstall: googleapis-common-protos\n", + " Found existing installation: googleapis-common-protos 1.61.0\n", + " Uninstalling googleapis-common-protos-1.61.0:\n", + " Successfully uninstalled googleapis-common-protos-1.61.0\n", + " Attempting uninstall: tensorflow-metadata\n", + " Found existing installation: tensorflow-metadata 1.14.0\n", + " Uninstalling tensorflow-metadata-1.14.0:\n", + " Successfully uninstalled tensorflow-metadata-1.14.0\n", + " Attempting uninstall: array-record\n", + " Found existing installation: array-record 0.5.0\n", + " Uninstalling array-record-0.5.0:\n", + " Successfully uninstalled array-record-0.5.0\n", + " Attempting uninstall: tensorflow-datasets\n", + " Found existing installation: tensorflow-datasets 4.9.3\n", + " Uninstalling tensorflow-datasets-4.9.3:\n", + " Successfully uninstalled tensorflow-datasets-4.9.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "tensorflow 2.14.0 requires wrapt<1.15,>=1.11.0, but you have wrapt 1.16.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed absl-py-1.4.0 array-record-0.5.0 certifi-2023.7.22 charset-normalizer-3.3.2 click-8.1.7 dm-tree-0.1.8 etils-1.5.2 fsspec-2023.10.0 googleapis-common-protos-1.61.0 idna-3.4 importlib_resources-6.1.1 numpy-1.26.1 promise-2.3 protobuf-3.20.3 psutil-5.9.6 requests-2.31.0 six-1.16.0 tensorflow-datasets-4.9.3+nightly tensorflow-metadata-1.14.0 termcolor-2.3.0 toml-0.10.2 tqdm-4.66.1 typing_extensions-4.8.0 urllib3-2.0.7 wrapt-1.16.0 zipp-3.17.0\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "# Might require updating tensorflow datasets:\n", + "%pip install --upgrade --force-reinstall git+https://github.com/tensorflow/datasets.git" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bPhwnlk1a1lq", + "outputId": "90ec1c89-2ef7-4cd6-aa39-b2df72da15de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fractal20220817_data\n", + "bc_z\n" + ] + } + ], + "source": [ + "for name in DATASET_NAMES:\n", + " print(name)\n", + " b = tfds.builder_from_directory(builder_dir=dataset2path(name))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/README.md b/README.md index 3917eca8b..445d7c0e3 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,66 @@ # NPM-Dataset A comprehensive robotics dataset that includes navigation, perception, and manipulation data per data point. + +# RT-1 (Robotic Transformer) PyTorch Implementation + + +A forked implementation of RT1 (Robotic Transformer) originally inspired by the Google Research paper. + +This implemenetation of RT-1 was pretrained on the Bridge dataset and further fine-tuned on our LaNMP dataset for evaluation. Please find details of the repository below + +## Setup Instructions + +```bash +git clone https://github.com/h2r/NPM-Dataset.git +git checkout -b rt1-model +pip install -e . +``` + +## Overview of files + +This repository has 7 critical files/folders whose use cases are described below + +1) ```main.py```: used to pretrain RT-1 on the bridge dataset. Modifying this file to accomodate different datasets requires changing the ```observation_space``` and ```action_space``` according to the dataset being loaded, as well as changing the dataset keys in ```rt1_pytorch/tokenizers/action_tokenizer.py```. Running this file saves a series of checkpoints and logs losses using weights and biases +2) ```main_ft.py```: used to finetune RT-1 on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset finetuning (AI2Thor). Running this file saves a series of checkpoints and logs losses using weights and biases +3) ```main_ft_eval.py```: used to run RT-1 in inference mode on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset (AI2Thor). The file iterates/loads all saved checkpoints from finetuning and runs RT-1 on inference mode for the validation dataset on each checkpoint. The script logs the test losses using weights and biases +4) ```ai2thor_env.py```: contains a Gym environment style class to load and take steps in AI2Thor enivironment. This file is used to generate real-time trajectories based on the action tokens generated by a finetuned RT-1 model (specific for AI2Thor). The main ```step()``` function takes/executes the generated action by RT-1 and returns a success message along with information about the environment state e.g. object or agent metadata, which can be saved to capture the trajectory taken by the agent for a given task +5) ```rollout_ai2thor.py```: interfaces between the finetuned RT-1 model (from a loaded checkpoint after finetuning on LaNMP) and the ```ai2thor_env.py``` Gym environment, in order to send observations from the AI2Thor environment to RT-1 and execute proposed action tokens by RT-1 on AI2Thor. Note that this file should not be run on a headless machine since it requires/deploys AI2Thor simulator GUI +6) ```rt1_pytorch/rt1_policy.py```: contains the RT-1 model implementation in PyTorch. The ```loss()``` function performs forward pass of RT-1 for training and ```act()``` function performs the forward pass during inference. +7) ```lanmp_dataloader/rt1_dataloader.py```: contains the ```DatasetManager``` class that extracts trajectories from the LaNMP ```sim_data.hdf5``` dataset file. The script automatically separates train and validation subsets according to different splits e.g. k-fold by scene, task wise or for diversity ablation. The ```DatasetManager``` also handles tokenizing/detokenizing the raw trajectory data into 256 discrete buckets, whilst also chunking trajectories across non-overlapping window lengths of 6 steps + +## Details about file arguments + +Most relevant files in this repository accept the same set of arguments that are detailed below +* ```dataset```: only for the ```main.py``` file, specifies the dataset on which the RT-1 model should be pretrained +* ```train-split```: specifies what fraction of the loaded dataset should be used for training v.s. evaluation +* ```eval-split```: specifies what fraction of the laoded dataset should be used for evaluation v.s. training +* ```epochs```: total number of passes over the all batches of the training set +* ```lr```: learning rate for cross-entropy loss of RT1 +* ```train-batch-size```: the number of trajectories from which to sample data for the current training batch +* ```eval-batch-size```: the number of trajectories from which to sample data for the current evaluation batch +* ```trajectory-length```: the window size (context history of ```trajecotry-length``` previous images) used for each trajectory when feeding data to RT-1 model; this is set to 6 based on the RT-1 implementation +* ```sentence-transformer```: the language embedding to apply on the language-specified task +* ```device```: the device to load the model/data onto during training/inference +* ```eval-freq```: the interval of batches at which to run evaluation/inference on the validation dataset (currently set to 0 in ```main_ft.py```) +* ```checkpoint-freq```: the interval of batches at which to save a checkpoint during training +* ```checkpoint-dir```: the directory path at which to save a checkpoint during training +* ```load-checkpoint```: (optional) path of the pretrained checkpoint to load for further fine-tuning +* ```wandb```: boolean determining if logging to weights and biases should happen +* ```eval-scene```: the AI2Thor scene number in the dataset that is held out of the training set for evaluation during k-fold cross validation across scenes +* ```split-type```: determines the split type (i.e. k-fold by scene, task wise or diversity ablation) between train and evaluation used by the ```DatasetManager``` in ```rt1_dataloader.py``` +* ```num-diversity-scenes```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of scenes to perform diversity ablation over i.e. maximum of 4 for LaNMP simulation data +* ```max-diversity-trajectories```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of trajectories that are divided evenly across the number of ```num-diversity-scenes``` scenes +* ```train-subbatch```: the batch size to use during training/finetuning +* ```eval-subbatch```: the batch size to use during evaluation + +## Checkpoint samples + +Please find the follow checkpoints samples that can be loaded to the RT-1 model. These can be found on the supplementary Google Drive associated with this project +* ```sample_checkpoints/pretrained_bridge```: the final checkpoint saved when pretraining the RT-1 model on the Bridge dataset +* ```sample_checkpoints/task_gen```: the final checkpoint saved after finetuning RT-1 model on the task-wise split for the task generalization experiment + +## Additional notes + +When running any of the finetuning or pretraining scripts, please ensure the following modules are loaded +```module load cuda/11.8.0-lpttyok``` +```module load cudnn/8.7.0.84-11.8-lg2dpd5``` diff --git a/ai2thor_env.py b/ai2thor_env.py new file mode 100644 index 000000000..60047ecfc --- /dev/null +++ b/ai2thor_env.py @@ -0,0 +1,641 @@ + +import copy +import numpy as np +from collections import Counter, OrderedDict +import ai2thor +from ai2thor.controller import Controller +from json import load +from os import path +import sys +sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred') +sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred/gen') +import gen.constants as constants +# import gen.utils.image_util as image_util +# from gen.utils import game_util +# from gen.utils.game_util import get_objects_of_type, get_obj_of_type_closest_to_obj +from random import choice, randint +from time import sleep +import pdb + +DEFAULT_RENDER_SETTINGS = {'renderImage': True, + 'renderDepthImage': True, + 'renderClassImage': False, + 'renderObjectImage': False, + } + +class ThorEnv(): + def __init__(self, task, max_episode_length = 1500): + + self.controller = None + self.last_event = None + + self.task = task + self.max_episode_length = max_episode_length + + + def reset(self, scene_name): + ''' + reset scene / start scene + ''' + print('Starting Ai2Thor Env...') + self.controller = Controller( + agentMode="arm", + massThreshold=None, + scene=scene_name, + visibilityDistance=1.5, + gridSize=0.25, + renderDepthImage=False, + renderInstanceSegmentation=False, + snapToGrid=False, + width=300, + height=300, + fieldOfView=60 + ) + self.last_event = self.controller.last_event + return self.last_event + + + def step(self, action, kwargs): + + if action in set(['MoveAgent','RotateAgent']): + + if action == 'MoveAgent': + + event_move = self.controller.step( + action="Teleport", + position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) + ) + + #execute a rotation body operation + event_rotate = self.controller.step( + action="RotateAgent", + degrees=kwargs['body_yaw_delta'], + returnToStart=False, + speed=1, + fixedDeltaTime=0.02 + ) + + success = event_move.metadata['lastActionSuccess'] + error = [event_move.metadata['errorMessage']] + self.last_event = event_move + + + elif action == 'RotateAgent': + + #execute a rotation body operation + event_rotate = self.controller.step( + action="RotateAgent", + degrees=kwargs['body_yaw_delta'], + returnToStart=False, + speed=1, + fixedDeltaTime=0.02 + ) + + event_move = self.controller.step( + action="Teleport", + position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) + ) + + success = event_rotate.metadata['lastActionSuccess'] + error = [event_rotate.metadata['errorMessage']] + self.last_event = event_rotate + + + + elif action == 'MoveArm': + + #execute smooth move arm operation + event = self.controller.step( + action="MoveArm", + position=dict(x=kwargs['arm_position'][0], y=kwargs['arm_position'][1], z=kwargs['arm_position'][2]), + coordinateSpace="world", + restrictMovement=False, + speed=1, + returnToStart=False, + fixedDeltaTime=0.02 + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == 'PickupObject': + + #execute pickup + event = self.controller.step( + action="PickupObject", + objectIdCandidates=[] + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == 'ReleaseObject': + + #execute pickup + event = self.controller.step( + action="ReleaseObject", + objectIdCandidates=[] + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action in set(['LookDown','LookUp']): + + #execute smooth change in pitch + events = self.smooth_look(action) + + success = events[-1].metadata['lastActionSuccess'] if len(events)>0 else False + error = [events[-1].metadata['errorMessage']] if len(events)>0 else ['Reached boundary of LookUp/LookDown'] + self.last_event = events[-1] if len(events)>0 else self.last_event + + + elif action == 'stop': + #stop the execution + event = self.controller.step(action="Done") + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == None: + #no operation to be done + success = True + error = [''] + + else: + + raise Exception('Error: the provided action {} is not valid'.format(action)) + + return success, error, self.last_event + + def step_old(self, action, smooth_nav=False): + ''' + overrides ai2thor.controller.Controller.step() for smooth navigation and goal_condition updates + ''' + if 'action' in action: + if smooth_nav: + if "MoveAhead" in action['action']: + self.smooth_move_ahead(action) + elif "Rotate" in action['action']: + self.smooth_rotate(action) + elif "Look" in action['action']: + self.smooth_look(action) + else: + super().step(action) + else: + if "LookUp" in action['action']: + self.look_angle(-constants.AGENT_HORIZON_ADJ) + elif "LookDown" in action['action']: + self.look_angle(constants.AGENT_HORIZON_ADJ) + else: + super().step(action) + else: + super().step(action) + + event = self.update_states(action) + self.check_post_conditions(action) + return event + + + + def noop(self): + ''' + do nothing + ''' + super().step(dict(action='Pass')) + + def smooth_move_ahead(self, action, render_settings=None): + ''' + smoother MoveAhead + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + smoothing_factor = constants.RECORD_SMOOTHING_FACTOR + new_action = copy.deepcopy(action) + new_action['moveMagnitude'] = constants.AGENT_STEP_SIZE / smoothing_factor + + new_action['renderImage'] = render_settings['renderImage'] + new_action['renderClassImage'] = render_settings['renderClassImage'] + new_action['renderObjectImage'] = render_settings['renderObjectImage'] + new_action['renderDepthImage'] = render_settings['renderDepthImage'] + + events = [] + for xx in range(smoothing_factor - 1): + event = super().step(new_action) + if event.metadata['lastActionSuccess']: + events.append(event) + + event = super().step(new_action) + if event.metadata['lastActionSuccess']: + events.append(event) + return events + + def smooth_rotate(self, action, render_settings=None): + ''' + smoother RotateLeft and RotateRight + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) + position = event.metadata['agent']['position'] + rotation = event.metadata['agent']['rotation'] + start_rotation = rotation['y'] + if action['action'] == 'RotateLeft': + end_rotation = (start_rotation - 90) + else: + end_rotation = (start_rotation + 90) + + events = [] + for xx in np.arange(.1, 1.0001, .1): + if xx < 1: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + } + event = super().step(teleport_action) + else: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + } + event = super().step(teleport_action) + + if event.metadata['lastActionSuccess']: + events.append(event) + return events + + def smooth_look(self, action, render_settings=None): + ''' + smoother LookUp and LookDown + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + start_horizon = event.metadata['agent']['cameraHorizon'] + rotation = np.round(event.metadata['agent']['rotation']['y'], 4) + end_horizon = start_horizon + constants.AGENT_HORIZON_ADJ * (1 - 2 * int(action == 'LookUp')) + position = event.metadata['agent']['position'] + + events = [] + for xx in np.arange(.1, 1.0001, .1): + if xx < 1: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': rotation, + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + 'standing': True, + } + event = self.controller.step(teleport_action) + else: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': rotation, + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), + 'standing':True, + } + event = self.controller.step(teleport_action) + + if event.metadata['lastActionSuccess']: + events.append(event) + + return events + + def rotate_angle(self, angle, render_settings=None): + ''' + rotate at a specific angle + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) + position = event.metadata['agent']['position'] + rotation = event.metadata['agent']['rotation'] + start_rotation = rotation['y'] + end_rotation = start_rotation + angle + + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(end_rotation, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + } + event = super().step(teleport_action) + return event + + def to_thor_api_exec(self, action, object_id="", smooth_nav=False): + # TODO: parametrized navigation commands + + if "RotateLeft" in action: + action = dict(action="RotateLeft", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "RotateRight" in action: + action = dict(action="RotateRight", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "MoveAhead" in action: + action = dict(action="MoveAhead", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "LookUp" in action: + action = dict(action="LookUp", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "LookDown" in action: + action = dict(action="LookDown", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "OpenObject" in action: + action = dict(action="OpenObject", + objectId=object_id, + moveMagnitude=1.0) + event = self.step(action) + elif "CloseObject" in action: + action = dict(action="CloseObject", + objectId=object_id, + forceAction=True) + event = self.step(action) + elif "PickupObject" in action: + action = dict(action="PickupObject", + objectId=object_id) + event = self.step(action) + elif "PutObject" in action: + inventory_object_id = self.last_event.metadata['inventoryObjects'][0]['objectId'] + action = dict(action="PutObject", + objectId=object_id, + forceAction=True, + placeStationary=True) + event = self.step(action) + elif "ToggleObjectOn" in action: + action = dict(action="ToggleObjectOn", + objectId=object_id) + event = self.step(action) + + elif "ToggleObjectOff" in action: + action = dict(action="ToggleObjectOff", + objectId=object_id) + event = self.step(action) + elif "SliceObject" in action: + # check if agent is holding knife in hand + inventory_objects = self.last_event.metadata['inventoryObjects'] + if len(inventory_objects) == 0 or 'Knife' not in inventory_objects[0]['objectType']: + raise Exception("Agent should be holding a knife before slicing.") + + action = dict(action="SliceObject", + objectId=object_id) + event = self.step(action) + else: + raise Exception("Invalid action. Conversion to THOR API failed! (action='" + str(action) + "')") + + return event, action + + def take_action(self, word_action, num_action, rand_agent=False): + i = 0 + incr = 0.025 + x = 0 + y = 0 + z = 0 + fixedDeltaTime = 0.02 + move = 0.2 + a = None + + if rand_agent: + all_word_actions = ['PickupObject','ReleaseObject', 'LookUp', 'LookDown', 'MoveArm', 'MoveArmBase', 'RotateAgent', 'MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft', 'stop'] + rand_word_action = choice(all_word_actions) + if rand_word_action in ["stop"]: + return "stop", None + elif rand_word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: + a = dict(action = rand_word_action) + elif rand_word_action in ['MoveArm', 'MoveArmBase']: + global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] + curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] + rand_x_indx, rand_y_indx, rand_z_indx = randint(1, 256), randint(1, 256), randint(1, 256) # starts at 1 to skip NoOp + x_del, y_del, z_del = self.bins["4"][rand_x_indx], self.bins["5"][rand_y_indx], self.bins["6"][rand_z_indx] + new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del + a = dict(action='MoveArm', position=dict(x=new_x, y=new_y, z=new_z),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) + elif rand_word_action in ['RotateAgent']: + rand_yaw_indx = randint(1, 256) + new_yaw = self.bins["3"][rand_yaw_indx] + a = dict(action=rand_word_action, degrees=new_yaw, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + else: # move base + a = dict(action=rand_word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + + else: + if word_action in ['NoOp']: + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + if word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: + a = dict(action = word_action) + elif word_action in ['MoveArm', 'MoveArmBase']: + global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] + curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] + x_del, y_del, z_del = self.bins["4"][num_action[0]], self.bins["5"][num_action[1]], self.bins["6"][num_action[2]] + if x_del == -1000 or y_del == -1000 or z_del == -1000: # if any of them are NoOp then skip all. Can do it another way where only skip the specific axis + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del + a = dict(action='MoveArm',position=dict(x=new_x, y=new_z, z=new_y),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) + elif word_action in ['RotateAgent']: + yaw_del = num_action.item() + new_yaw = self.bins["3"][yaw_del] + if new_yaw == -1000: #make it variable later + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + a = dict(action=word_action, degrees=new_yaw,returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + else: # move base + a = dict(action=word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + + sleep(0.5) #for debugging/movement analysis + event = self.controller.step(a) + success = event.metadata['lastActionSuccess'] + error = event.metadata['errorMessage'] + self.last_event = event + #for debugging/movement analysis + sleep(0.5) + if rand_agent: + print(f"Random Word Action: {rand_word_action} ", end="\r") + # else: + # print(f"Word Action: {word_action} ", end="\r") + # print(f"Num Action: {num_action} ", end="\r") + + return success, error, self.last_event.metadata + + + + +if __name__ == '__main__': + + SCENE_NAME = 'FloorPlan_Train5_1' + TESTED_STEPS = 200 + + test = ThorEnv('Walk to the living room') + + event = test.reset(scene_name=SCENE_NAME) + + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + agent_holding = np.array([]) + + + test.controller.step( + action="MoveArmBase", + y=0.0, + speed=1, + returnToStart=True, + fixedDeltaTime=0.02 + ) + + + for i in range(TESTED_STEPS): + + print(''' + (1) Move X+ + (2) Move X- + (3) Move Z+ + (4) Move Z- + (5) Rotate Left + (6) Rotate Right + (7) Rotate Up + (8) Rotate Down + (9) Open Gripper + (0) Close Gripper + (h) Move Gripper up + (n) Move Gripper down + (b) Move Gripper left + (m) Move Gripper right + (z) Move Gripper forward + (x) Move Gripper backwards + ''') + + + action = input('>') + + + if action == '1': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[0] += 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '2': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[0] -= 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '3': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[2] += 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '4': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[2] -= 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '5': + + success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta': -90}) + + elif action == '6': + + success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta':+90}) + + elif action == '7': + + success, error, event = test.step('LookUp', {}) + + elif action == '8': + + success, error, event = test.step('LookDown', {}) + + elif action == '9': + + success, error, event = test.step('PickupObject', {}) + + elif action == '0': + + success, error, event = test.step('ReleaseObject', {}) + + elif action == 'h': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[1] += 0.20 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'n': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[1] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'b': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[0] += 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'm': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[0] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'z': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[2] += 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'x': + + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[2] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) diff --git a/data.py b/data.py new file mode 100644 index 000000000..71bff29ba --- /dev/null +++ b/data.py @@ -0,0 +1,536 @@ +# Taken from https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit#gid=0 +import abc +import dataclasses +from typing import Any, Dict, Iterable, Optional, Union +import pdb +import numpy as np +import reverb +import tensorflow as tf +import tensorflow_datasets as tfds +import tree +from rlds import rlds_types, transformations + +tf.config.experimental.set_visible_devices([], "GPU") + + +def dataset2path(name): + if name == "robo_net": + version = "1.0.0" + elif name == "language_table": + version = "0.0.1" + else: + version = "0.1.0" + return f"gs://gresearch/robotics/{name}/{version}" + + +def as_gif(images, path="temp.gif"): + # Render the images as the gif: + images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0) + gif_bytes = open(path, "rb").read() + return gif_bytes + + +def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec: + """Converts a tfds Feature into a TensorSpec.""" + + def _get_feature_spec(nested_feature: tfds.features.FeatureConnector): + if isinstance(nested_feature, tf.DType): + return tf.TensorSpec(shape=(), dtype=nested_feature) + else: + return nested_feature.get_tensor_spec() + + # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to + # make sure we deal with the nested structure. + return tf.nest.map_structure(_get_feature_spec, feature) + + +def _encoded_feature( + feature: Optional[tfds.features.FeatureConnector], + image_encoding: Optional[str], + tensor_encoding: Optional[tfds.features.Encoding], +): + """Adds encoding to Images and/or Tensors.""" + + def _apply_encoding( + feature: tfds.features.FeatureConnector, + image_encoding: Optional[str], + tensor_encoding: Optional[tfds.features.Encoding], + ): + if image_encoding and isinstance(feature, tfds.features.Image): + return tfds.features.Image( + shape=feature.shape, + dtype=feature.dtype, + use_colormap=feature.use_colormap, + encoding_format=image_encoding, + ) + if ( + tensor_encoding + and isinstance(feature, tfds.features.Tensor) + and feature.dtype != tf.string + ): + return tfds.features.Tensor( + shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding + ) + return feature + + if not feature: + return None + return tf.nest.map_structure( + lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature + ) + + +@dataclasses.dataclass +class RLDSSpec(metaclass=abc.ABCMeta): + """Specification of an RLDS Dataset. + + It is used to hold a spec that can be converted into a TFDS DatasetInfo or + a `tf.data.Dataset` spec. + """ + + observation_info: Optional[tfds.features.FeatureConnector] = None + action_info: Optional[tfds.features.FeatureConnector] = None + reward_info: Optional[tfds.features.FeatureConnector] = None + discount_info: Optional[tfds.features.FeatureConnector] = None + step_metadata_info: Optional[tfds.features.FeaturesDict] = None + episode_metadata_info: Optional[tfds.features.FeaturesDict] = None + + def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]: + """Obtains the TensorSpec of an RLDS step.""" + step = {} + if self.observation_info: + step[rlds_types.OBSERVATION] = _features_to_tensor_spec( + self.observation_info + ) + if self.action_info: + step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info) + if self.discount_info: + step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info) + if self.reward_info: + step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info) + if self.step_metadata_info: + for k, v in self.step_metadata_info.items(): + step[k] = _features_to_tensor_spec(v) + + step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool) + step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool) + step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool) + return step + + def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]: + """Obtains the TensorSpec of an RLDS step.""" + episode = {} + episode[rlds_types.STEPS] = tf.data.DatasetSpec( + element_spec=self.step_tensor_spec() + ) + if self.episode_metadata_info: + for k, v in self.episode_metadata_info.items(): + episode[k] = _features_to_tensor_spec(v) + return episode + + def to_dataset_config( + self, + name: str, + image_encoding: Optional[str] = None, + tensor_encoding: Optional[tfds.features.Encoding] = None, + citation: Optional[str] = None, + homepage: Optional[str] = None, + description: Optional[str] = None, + overall_description: Optional[str] = None, + ) -> tfds.rlds.rlds_base.DatasetConfig: + """Obtains the DatasetConfig for TFDS from the Spec.""" + return tfds.rlds.rlds_base.DatasetConfig( + name=name, + description=description, + overall_description=overall_description, + homepage=homepage, + citation=citation, + observation_info=_encoded_feature( + self.observation_info, image_encoding, tensor_encoding + ), + action_info=_encoded_feature( + self.action_info, image_encoding, tensor_encoding + ), + reward_info=_encoded_feature( + self.reward_info, image_encoding, tensor_encoding + ), + discount_info=_encoded_feature( + self.discount_info, image_encoding, tensor_encoding + ), + step_metadata_info=_encoded_feature( + self.step_metadata_info, image_encoding, tensor_encoding + ), + episode_metadata_info=_encoded_feature( + self.episode_metadata_info, image_encoding, tensor_encoding + ), + ) + + def to_features_dict(self): + """Returns a TFDS FeaturesDict representing the dataset config.""" + step_config = { + rlds_types.IS_FIRST: tf.bool, + rlds_types.IS_LAST: tf.bool, + rlds_types.IS_TERMINAL: tf.bool, + } + + if self.observation_info: + step_config[rlds_types.OBSERVATION] = self.observation_info + if self.action_info: + step_config[rlds_types.ACTION] = self.action_info + if self.discount_info: + step_config[rlds_types.DISCOUNT] = self.discount_info + if self.reward_info: + step_config[rlds_types.REWARD] = self.reward_info + + if self.step_metadata_info: + for k, v in self.step_metadata_info.items(): + step_config[k] = v + + if self.episode_metadata_info: + return tfds.features.FeaturesDict( + { + rlds_types.STEPS: tfds.features.Dataset(step_config), + **self.episode_metadata_info, + } + ) + else: + return tfds.features.FeaturesDict( + { + rlds_types.STEPS: tfds.features.Dataset(step_config), + } + ) + + +RLDS_SPEC = RLDSSpec +TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]] + + +@dataclasses.dataclass +class TrajectoryTransform(metaclass=abc.ABCMeta): + """Specification the TrajectoryTransform applied to a dataset of episodes. + + A TrajectoryTransform is a set of rules transforming a dataset + of RLDS episodes to a dataset of trajectories. + This involves three distinct stages: + - An optional `episode_to_steps_map_fn(episode)` is called at the episode + level, and can be used to select or modify steps. + - Augmentation: an `episode_key` could be propagated to `steps` for + debugging. + - Selection: Particular steps can be selected. + - Stripping: Features can be removed from steps. Prefer using `step_map_fn`. + - An optional `step_map_fn` is called at the flattened steps dataset for each + step, and can be used to featurize a step, e.g. add/remove features, or + augument images + - A `pattern` leverages DM patterns to set a rule of slicing an episode to a + dataset of overlapping trajectories. + + Importantly, each TrajectoryTransform must define a `expected_tensor_spec` + which specifies a nested TensorSpec of the resulting dataset. This is what + this TrajectoryTransform will produce, and can be used as an interface with + a neural network. + """ + + episode_dataset_spec: RLDS_SPEC + episode_to_steps_fn_dataset_spec: RLDS_SPEC + steps_dataset_spec: Any + pattern: reverb.structured_writer.Pattern + episode_to_steps_map_fn: Any + expected_tensor_spec: TENSOR_SPEC + step_map_fn: Optional[Any] = None + + def get_for_cached_trajectory_transform(self): + """Creates a copy of this traj transform to use with caching. + + The returned TrajectoryTransfrom copy will be initialized with the default + version of the `episode_to_steps_map_fn`, because the effect of that + function has already been materialized in the cached copy of the dataset. + Returns: + trajectory_transform: A copy of the TrajectoryTransform with overridden + `episode_to_steps_map_fn`. + """ + traj_copy = dataclasses.replace(self) + traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec + traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS] + return traj_copy + + def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset): + """Applies this TrajectoryTransform to the dataset of episodes.""" + + # Convert the dataset of episodes to the dataset of steps. + steps_dataset = episodes_dataset.map( + self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE + ).flat_map(lambda x: x) + + return self._create_pattern_dataset(steps_dataset) + + def transform_steps_rlds_dataset( + self, steps_dataset: tf.data.Dataset + ) -> tf.data.Dataset: + """Applies this TrajectoryTransform to the dataset of episode steps.""" + + return self._create_pattern_dataset(steps_dataset) + + def create_test_dataset( + self, + ) -> tf.data.Dataset: + """Creates a test dataset of trajectories. + + It is guaranteed that the structure of this dataset will be the same as + when flowing real data. Hence this is a useful construct for tests or + initialization of JAX models. + Returns: + dataset: A test dataset made of zeros structurally identical to the + target dataset of trajectories. + """ + zeros = transformations.zeros_from_spec(self.expected_tensor_spec) + + return tf.data.Dataset.from_tensors(zeros) + + def _create_pattern_dataset( + self, steps_dataset: tf.data.Dataset + ) -> tf.data.Dataset: + """Create PatternDataset from the `steps_dataset`.""" + config = create_structured_writer_config("temp", self.pattern) + + # Further transform each step if the `step_map_fn` is provided. + if self.step_map_fn: + steps_dataset = steps_dataset.map(self.step_map_fn) + pattern_dataset = reverb.PatternDataset( + input_dataset=steps_dataset, + configs=[config], + respect_episode_boundaries=True, + is_end_of_episode=lambda x: x[rlds_types.IS_LAST], + ) + return pattern_dataset + + +class TrajectoryTransformBuilder(object): + """Facilitates creation of the `TrajectoryTransform`.""" + + def __init__( + self, + dataset_spec: RLDS_SPEC, + episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS], + step_map_fn=None, + pattern_fn=None, + expected_tensor_spec=None, + ): + self._rds_dataset_spec = dataset_spec + self._steps_spec = None + self._episode_to_steps_map_fn = episode_to_steps_map_fn + self._step_map_fn = step_map_fn + self._pattern_fn = pattern_fn + self._expected_tensor_spec = expected_tensor_spec + + def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform: + """Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.""" + + if validate_expected_tensor_spec and self._expected_tensor_spec is None: + raise ValueError("`expected_tensor_spec` must be set.") + + episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec) + + steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn) + + episode_to_steps_fn_dataset_spec = self._rds_dataset_spec + + if self._step_map_fn is not None: + steps_ds = steps_ds.map(self._step_map_fn) + + zeros_spec = transformations.zeros_from_spec( + steps_ds.element_spec + ) # pytype: disable=wrong-arg-types + + ref_step = reverb.structured_writer.create_reference_step(zeros_spec) + + pattern = self._pattern_fn(ref_step) + + steps_ds_spec = steps_ds.element_spec + + target_tensor_structure = create_reverb_table_signature( + "temp_table", steps_ds_spec, pattern + ) + + if ( + validate_expected_tensor_spec + and self._expected_tensor_spec != target_tensor_structure + ): + raise RuntimeError( + "The tensor spec of the TrajectoryTransform doesn't " + "match the expected spec.\n" + "Expected:\n%s\nActual:\n%s\n" + % ( + str(self._expected_tensor_spec).replace( + "TensorSpec", "tf.TensorSpec" + ), + str(target_tensor_structure).replace("TensorSpec", "tf.TensorSpec"), + ) + ) + + return TrajectoryTransform( + episode_dataset_spec=self._rds_dataset_spec, + episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec, + steps_dataset_spec=steps_ds_spec, + pattern=pattern, + episode_to_steps_map_fn=self._episode_to_steps_map_fn, + step_map_fn=self._step_map_fn, + expected_tensor_spec=target_tensor_structure, + ) + + +def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC): + """Creates a zero valued dataset of episodes for the given RLDS Spec.""" + + def add_steps(episode, step_spec): + episode[rlds_types.STEPS] = transformations.zero_dataset_like( + tf.data.DatasetSpec(step_spec) + ) + if "fake" in episode: + del episode["fake"] + return episode + + episode_without_steps_spec = { + k: v + for k, v in rlds_spec.episode_tensor_spec().items() + if k != rlds_types.STEPS + } + + if episode_without_steps_spec: + episodes_dataset = transformations.zero_dataset_like( + tf.data.DatasetSpec(episode_without_steps_spec) + ) + else: + episodes_dataset = tf.data.Dataset.from_tensors({"fake": ""}) + + episodes_dataset_with_steps = episodes_dataset.map( + lambda episode: add_steps(episode, rlds_spec.step_tensor_spec()) + ) + return episodes_dataset_with_steps + + +def create_reverb_table_signature( + table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern +) -> reverb.reverb_types.SpecNest: + config = create_structured_writer_config(table_name, pattern) + reverb_table_spec = reverb.structured_writer.infer_signature( + [config], steps_dataset_spec + ) + return reverb_table_spec + + +def create_structured_writer_config( + table_name: str, pattern: reverb.structured_writer.Pattern +) -> Any: + config = reverb.structured_writer.create_config( + pattern=pattern, table=table_name, conditions=[] + ) + return config + + +def n_step_pattern_builder(n: int) -> Any: + """Creates trajectory of length `n` from all fields of a `ref_step`.""" + + def transform_fn(ref_step): + traj = {} + for key in ref_step: + if isinstance(ref_step[key], dict): + transformed_entry = tree.map_structure( + lambda ref_node: ref_node[-n:], ref_step[key] + ) + traj[key] = transformed_entry + else: + traj[key] = ref_step[key][-n:] + + return traj + + return transform_fn + + +def get_observation_and_action_from_step(step): + return { + "observation": { + "image": step["observation"]["image"], + "embedding": step["observation"]["natural_language_embedding"], + "instruction": step["observation"]["natural_language_instruction"], + }, + # Decode one hot discrete actions + "action": { + k: tf.argmax(v, axis=-1) if v.dtype == tf.int32 else v + for k, v in step["action"].items() + }, + } + + +def create_dataset( + datasets=["fractal20220817_data"], + split="train", + trajectory_length=6, + batch_size=32, + num_epochs=1, +) -> Iterable[Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]]: + trajectory_datasets = [] + #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) + for dataset in datasets: + #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) + + + # b = tfds.builder_from_directory(builder_dir='/oscar/data/stellex/shared/bridge/0.1.0') + #'~/data/sjulian2/bridge/0.1.0/' + # dataset = tfds.load('bridge', split='train') + #b = tfds.builder_from_directory(builder_dir='/users/sjulian2/data/sjulian2/jaco_play/0.1.0') + # b = tfds.builder_from_directory(builder_dir=dataset2path(dataset)) + + # pdb.set_trace() + b = tfds.builder_from_directory(builder_dir = '/oscar/data/stellex/ssunda11/NPM-Dataset/rt1-pytorch/rt1_dataset/0.1.0') + # ds = tfds.load("fractal20220817_data:0.1.0", data_dir="gs://gresearch/robotics") + + ds = b.as_dataset(split=split) + + # The RLDSSpec for the RT1 dataset. + rt1_spec = RLDSSpec( + observation_info=b.info.features["steps"]["observation"], + action_info=b.info.features["steps"]["action"], + ) + + trajectory_transform = TrajectoryTransformBuilder( + rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length) + ).build(validate_expected_tensor_spec=False) + + trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds) + #pdb.set_trace() + trajectory_datasets.append(trajectory_dataset) + + trajectory_dataset = tf.data.Dataset.sample_from_datasets(trajectory_datasets) + + trajectory_dataset = trajectory_dataset.map( + get_observation_and_action_from_step, num_parallel_calls=tf.data.AUTOTUNE + ) + + # Shuffle, batch, prefetch, repeat + trajectory_dataset = trajectory_dataset.shuffle(batch_size * 16) + trajectory_dataset = trajectory_dataset.batch( + batch_size, + drop_remainder=True, + num_parallel_calls=tf.data.AUTOTUNE, + deterministic=False, + ) + trajectory_dataset = trajectory_dataset.repeat(num_epochs) + trajectory_dataset = trajectory_dataset.prefetch(tf.data.AUTOTUNE) + # pdb.set_trace() + return iter(trajectory_dataset.as_numpy_iterator()) + + +if __name__ == "__main__": + #pdb.set_trace() + ds = create_dataset(datasets=["fractal20220817_data"], split="train[:10]") + it = next(ds) + + def print_shape(x): + if isinstance(x, dict): + shapes = tree.map_structure(lambda x: x.shape, x) + else: + shapes = x.shape + return shapes + + shapes = tree.map_structure(print_shape, it) + print(shapes) diff --git a/main.py b/main.py new file mode 100644 index 000000000..08e0365bd --- /dev/null +++ b/main.py @@ -0,0 +1,257 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +from tqdm import tqdm +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=['fractal20220817_data'], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--epochs", + type=int, + default=1, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--train-batch-size", + type=int, + default=8, + help="train batch size", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=8, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=0, + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=200, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/temp", #rt1_pretraining + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-pretraining-v1", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + print("Loading dataset...") + + train_dataset = create_dataset( + datasets=args.datasets, + split=args.train_split, + trajectory_length=args.trajectory_length, + batch_size=args.train_batch_size, + num_epochs=args.epochs, + ) + # eval_dataset = create_dataset( + # datasets=args.datasets, + # split=args.eval_split, + # trajectory_length=args.trajectory_length, + # batch_size=args.eval_batch_size, + # num_epochs=args.epochs, + # ) + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + action_space = gym.spaces.Dict( + world_vector=gym.spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + base_displacement_vertical_rotation=gym.spaces.Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 + ), + gripper_closedness_action=gym.spaces.Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=gym.spaces.Discrete(3), + base_displacement_vector=gym.spaces.Box( + low=-1.0, + high=1.0, + shape=(2,), + dtype=np.float32, + ), + rotation_delta=gym.spaces.Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else None + ) + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + if text_embedding_model is not None: + return text_embedding_model.encode(observation["instruction"]) + else: + return observation["embedding"] + + print("Training...") + num_batches = 0 + + for batch in tqdm(train_dataset): + + policy.model.train() + + num_batches += 1 + + if num_batches <= 0: + continue + + #Image Shape: 8, 6, 480, 640, 3 => (batch, length, height, width, channel) + #Context Shape: 8, 6, 512 => (batch, length, embedding) + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + + + actions = batch["action"] + + try: + loss, loss_std = policy.loss(observations, actions) + except: + print('-------------LOSS COMPUTATION FAILED!!!--------') + continue + + if args.wandb: + wandb.log({"loss": loss.item(), "loss_std": loss_std.item()}, step=num_batches * args.train_batch_size) + print(f"Train loss Batch {num_batches}: {loss.item()}") + else: + print(f"Train loss Batch {num_batches}: {loss.item()}") + optimizer.zero_grad() + loss.backward() + optimizer.step() + if args.eval_freq and num_batches % args.eval_freq == 0: + print("Evaluating...") + policy.model.eval() + batch = next(eval_dataset) + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + actions = batch["action"] + eval_loss, eval_loss_std = policy.loss(observations, actions) + eval_loss = eval_loss.item() + if args.wandb: + wandb.log( + {"eval_loss": eval_loss, "eval_loss_std": eval_loss_std.item()}, + step=num_batches * args.train_batch_size, + ) + else: + print(f"Eval loss Batch {num_batches}: {eval_loss}") + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{num_batches}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + print("finished training") + +if __name__ == "__main__": + main() diff --git a/main_ft.py b/main_ft.py new file mode 100644 index 000000000..545f3cb2b --- /dev/null +++ b/main_ft.py @@ -0,0 +1,385 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=["fractal20220817_data"], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--epochs", + type=int, + default=4, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--train-batch-size", + type=int, + default=3, + help="train batch size", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=0, #200 + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=100, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/diversity_v1_4", + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, #NOTE: include the path to load the checkpoint here + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=True, + ) + + parser.add_argument( + "--eval-scene", + default=4, + help = "scene used as validation during k-fold cross validation", + ) + + parser.add_argument( + "--split-type", + default = 'diversity_ablation', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + + parser.add_argument( + "--num-diversity-scenes", + default = 4, + ) + + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + + + parser.add_argument( + "--train-subbatch", + default=8, + ) + parser.add_argument( + "--eval-subbatch", + default=5, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-data-diversity-v1", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + print("Loading dataset...") + + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + + if args.wandb and args.split_type == 'diversity_ablation': + wandb.log({"task_keys": dataset_manager.train_dataset.dataset_keys}) + + train_dataloader = DataLoader(dataset_manager.train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches, drop_last = False) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=True, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + + #NOTE: has to be Not None because of raw instruction input + + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + print('EMBEDDING FAILED!') + + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + print("Training...") + num_batches = 0 + total_train_steps = 0 + total_val_steps = 0 + + + + + for epoch in range(args.epochs): + print("STARTING EPOCH {}".format(epoch+1)) + + for batch, train_batch in enumerate(train_dataloader): + + + batch_steps = train_batch[0].shape[0] + + for idx in range(0, batch_steps, args.train_subbatch): + + + + policy.model.train() + + num_batches += 1 + + + observations = { + "image": train_batch[0][idx : min(idx + args.train_subbatch, batch_steps)], + "context": get_text_embedding(train_batch[1][idx : min(idx + args.train_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': train_batch[2][idx : min(idx + args.train_subbatch, batch_steps)], + 'pickup_release': train_batch[3][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_position_delta': train_batch[4][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_yaw_delta': train_batch[5][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_pitch_delta': train_batch[6][idx : min(idx + args.train_subbatch, batch_steps)], + 'arm_position_delta': train_batch[7][idx : min(idx + args.train_subbatch, batch_steps)], + 'control_mode': train_batch[8][idx : min(idx + args.train_subbatch, batch_steps)] + } + + padding = train_batch[9][idx : min(idx + args.train_subbatch, batch_steps)] + total_train_steps += batch_steps + + + loss, loss_std = policy.loss(observations, actions) + + if args.wandb: + print(f"Train loss Batch {num_batches}: {loss.item()} ± {loss_std.item()}") + wandb.log({"train_loss": loss.item(), "train_loss_std": loss_std.item()}, step= total_train_steps) + else: + print(f"Train loss Batch {num_batches}: {loss.item()}") + + optimizer.zero_grad() + loss.backward() + optimizer.step() + observations = {}; actions = {} + + + if args.eval_freq and num_batches % args.eval_freq == 0: + + # Clear cache and collected garbage + gc.collect() + torch.cuda.empty_cache() + + total_eval_loss = 0 + total_eval_loss_std = 0 + total_eval_count = 0 + + + + print("Evaluating...") + for batch, val_batch in enumerate(val_dataloader): + + batch_steps = val_batch[0].shape[0] + + print(f'Section {batch+1} of {len(val_dataloader)}') + + for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): + + + policy.model.eval() + + + total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + + observations = { + "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], + "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], + 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], + 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], + 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] + } + + padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] + + eval_loss, eval_loss_std = policy.loss(observations, actions) + + + total_eval_loss += eval_loss.item()*observations['image'].shape[0] + total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] + + if args.wandb: + wandb.log( + {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, + step=total_train_steps, + ) + print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") + else: + print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") + + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{total_train_steps}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + + print("FINISHED EPOCH {}".format(epoch+1)) + print("finished training") + +if __name__ == "__main__": + main() diff --git a/main_ft_eval.py b/main_ft_eval.py new file mode 100644 index 000000000..831604d73 --- /dev/null +++ b/main_ft_eval.py @@ -0,0 +1,278 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=["fractal20220817_data"], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--checkpoint-path", + type=str, + default="checkpoints/scene4", + help="directory to save checkpoints", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=True, + ) + + parser.add_argument( + "--eval-scene", + default=4, + help = "scene used as validation during k-fold cross validation", + ) + parser.add_argument( + "--eval-subbatch", + default=5, + ) + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + + parser.add_argument( + "--num-diversity-scenes", + default = 4, + ) + + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + os.makedirs(args.checkpoint_path, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-finetuning", config=vars(args)) + + os.makedirs(args.checkpoint_path, exist_ok=True) + + assert(len(os.listdir(args.checkpoint_path)) > 0 , "ERROR: checkpoint path is empty and has no saved checkpoints") + + print("Loading dataset...") + + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + + + #NOTE: has to be Not None because of raw instruction input + + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + pdb.set_trace() + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + + def extract_train_step(filepath): + return int(filepath.split('_')[1]) + + + print("Evaluating...") + + + for idx, checkpoint_file in enumerate(list(sorted(os.listdir(args.checkpoint_path), key=extract_train_step))): + + print(f'Evaluating file: {idx} of {len(os.listdir(args.checkpoint_path))}') + total_train_steps = int(checkpoint_file.split('_')[1]) + total_val_steps = 0 + + + total_eval_loss = 0 + total_eval_loss_std = 0 + total_eval_count = 0 + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=os.path.join(args.checkpoint_path, checkpoint_file), + ) + + + + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + + + for batch, val_batch in enumerate(val_dataloader): + + batch_steps = val_batch[0].shape[0] + + print(f'Section {batch+1} of {len(val_dataloader)}') + + for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): + + + policy.model.eval() + + + total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + + observations = { + "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], + "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], + 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], + 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], + 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] + } + + padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] + + eval_loss, eval_loss_std = policy.loss(observations, actions) + + + total_eval_loss += eval_loss.item()*observations['image'].shape[0] + total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] + + if args.wandb: + wandb.log( + {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, + step=total_train_steps, + ) + print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") + else: + print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") + +if __name__ == "__main__": + main() diff --git a/rollout_ai2thor.py b/rollout_ai2thor.py new file mode 100644 index 000000000..0edf255ca --- /dev/null +++ b/rollout_ai2thor.py @@ -0,0 +1,366 @@ +import argparse +import os +os.environ["CUDA_VISIBLE_DEVICES"] = "0" +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc +import json +import pandas as pd +from ai2thor_env import ThorEnv +import pickle +import time +from tqdm import tqdm + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--checkpoint-file-path", + type=str, + default="checkpoints/scene2/checkpoint_299183_loss_152.175.pt", #NOTE: change according to checkpoint file that is to be loaded + help="directory to save checkpoints", + ) + + parser.add_argument( + "--trajectory-save-path", + type=str, + default="traj_rollouts/scene2", + help = "directory to save the generated trajectory predicted by the model" + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + parser.add_argument( + "--eval-scene", + default=2, + help = "scene used as validation during k-fold cross validation", + ) + parser.add_argument( + "--eval-subbatch", + default=1, + ) + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + parser.add_argument( + "--num-diversity-scenes", + default = 3, + ) + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + if args.wandb: + wandb.init(project="rt1-rollout-data", config=vars(args)) + + os.makedirs(args.trajectory_save_path, exist_ok=True) + + assert(os.path.isfile(args.checkpoint_file_path), "ERROR: checkpoint file does not exist") + + + print("Loading dataset...") + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + + + #NOTE: has to be Not None because of raw instruction input + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + raise Exception('Error: task descriptions could not be embedded') + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + + + + print("Loading chosen checkpoint to model...") + rt1_model_policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.checkpoint_file_path, + ) + rt1_model_policy.model.eval() + + # Total number of params + total_params = sum(p.numel() for p in rt1_model_policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in rt1_model_policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in rt1_model_policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + + print('Creating pandas dataframe for trajectories...') + + print_val = True + + + for task in tqdm(val_dataloader.dataset.dataset_keys): + + + #skip tasks that trajectory already generated for + if os.path.isfile(os.path.join(args.trajectory_save_path, task)): + continue + elif print_val: + print('START AT: ', val_dataloader.dataset.dataset_keys.index(task)) + print_val = False + + traj_group = val_dataloader.dataset.hdf[task] + + traj_steps = list(traj_group.keys()) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + language_command_embedding = get_text_embedding(np.array([[traj_json_dict['nl_command']]])) + language_command_embedding = np.repeat(language_command_embedding, 6, axis=1) + + + print('TASK: ', traj_json_dict['nl_command']) + + #initialize the AI2Thor environment + ai2thor_env = ThorEnv(traj_json_dict['nl_command']) + event = ai2thor_env.reset(traj_json_dict['scene']) + + + + #extract the visual observation from initialzed environment + curr_image = event.frame + visual_observation = np.expand_dims(np.expand_dims(curr_image, axis=0) , axis=0) + visual_observation = np.repeat(visual_observation, 6, axis=1) + + ''' + OLD OBS FROM DATASET + visual_observation = np.expand_dims(np.expand_dims(np.array(traj_group[traj_steps[0]]['rgb_0']), axis=0), axis=0) + visual_observation = np.repeat(visual_observation, 6, axis=1) + ''' + + #track the starting coordinates for body, yaw rotation and arm coordinate + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + agent_holding = np.array([]) + + + #track the total number of steps and the last control mode + num_steps = 0; curr_mode = None; is_terminal = False + + + #track data for all steps + trajectory_data = [] + + while (curr_mode != 'stop' or is_terminal) and num_steps < ai2thor_env.max_episode_length: + + #provide the current observation to the model + curr_observation = { + 'image': visual_observation, + 'context': language_command_embedding + } + + generated_action_tokens = rt1_model_policy.act(curr_observation) + + #de-tokenize the generated actions from RT1 + pickup_release = val_dataloader.dataset.detokenize_pickup_release(generated_action_tokens['pickup_release'][0]) + body_pitch = val_dataloader.dataset.detokenize_head_pitch(generated_action_tokens['body_pitch_delta'][0]) + curr_mode = val_dataloader.dataset.detokenize_mode(generated_action_tokens['control_mode'][0]) + + + + + terminate_episode = generated_action_tokens['terminate_episode'][0] + + continuous_variables = { + 'body_position_delta': generated_action_tokens['body_position_delta'], + 'body_yaw_delta': generated_action_tokens['body_yaw_delta'], + 'arm_position_delta': generated_action_tokens['arm_position_delta'], + 'curr_mode': curr_mode + } + + continuous_variables = val_dataloader.dataset.detokenize_continuous_data(continuous_variables) + body_position_delta = np.squeeze(continuous_variables['body_position_delta']) + body_yaw_delta = continuous_variables['body_yaw_delta'][0][0] + arm_position_delta = np.squeeze(continuous_variables['arm_position_delta']) + + curr_action = val_dataloader.dataset.detokenize_action(curr_mode, body_position_delta, body_yaw_delta, arm_position_delta, pickup_release, body_pitch) + + + + #update the tracked coordinate data based on model output + curr_body_coordinate += body_position_delta + curr_body_yaw += body_yaw_delta + curr_arm_coordinate += arm_position_delta + + + #execute the generated action in the AI2THOR simulator + step_args = { + 'xyz_body': curr_body_coordinate, + 'xyz_body_delta': body_position_delta, + 'curr_body_yaw': curr_body_yaw, + 'body_yaw_delta': body_yaw_delta, + 'arm_position_delta': arm_position_delta, + 'arm_position': curr_arm_coordinate + } + success, error, event = ai2thor_env.step(curr_action, step_args) + + time.sleep(0.25) + + #fetch object holding from simulator; also maybe fetch coordinate of body/arm + yaw from simulator + agent_holding = np.array(event.metadata['arm']['heldObjects']) + + #fetch the new visual observation from the simulator, update the current mode and increment number of steps + curr_image = np.expand_dims(np.expand_dims(event.frame, axis=0) , axis=0) + + visual_observation = visual_observation[:,1:,:,:,:] + visual_observation = np.concatenate((visual_observation, curr_image), axis=1) + num_steps +=1 + + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + + + #add data to the dataframe CSV + step_data = { + 'task': traj_json_dict['nl_command'], + 'scene': traj_json_dict['scene'], + 'img': curr_image, + 'xyz_body': curr_body_coordinate, + 'xyz_body_delta': body_position_delta, + 'yaw_body': curr_body_yaw, + 'yaw_body_delta': body_yaw_delta, + 'pitch_body': body_pitch, + 'xyz_ee': curr_arm_coordinate, + 'xyz_ee_delta': arm_position_delta, + 'pickup_dropoff': pickup_release, + 'holding_obj': agent_holding, + 'control_mode': curr_mode, + 'action': curr_action, + 'terminate': terminate_episode, + 'step': num_steps, + 'timeout': num_steps >= ai2thor_env.max_episode_length, + 'error': error + } + + trajectory_data.append(step_data) + + #save the final event with all metadata: save as a json file dict + save_path = os.path.join(args.trajectory_save_path, task) + with open(save_path, 'wb') as file: + pickle.dump({'trajectory_data': trajectory_data, 'final_state': event.metadata}, file) + + #close the old GUI for AI2Thor after trajectory finishes + ai2thor_env.controller.stop() + time.sleep(0.5) + + + + + + + +if __name__ == "__main__": + main() diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..4c3290111 --- /dev/null +++ b/setup.py @@ -0,0 +1,44 @@ +from setuptools import find_packages, setup + +setup( + name="rt1-pytorch", + packages=find_packages(exclude=[]), + version="0.1.0", + license="MIT", + description="PyTorch implementation of the RT-1.", + author="Rohan Potdar", + author_email="rohanpotdar138@gmail.com", + long_description_content_type="text/markdown", + url="https://github.com/Rohan138/rt1-pytorch", + keywords=[ + "artificial intelligence", + "deep learning", + "transformers", + "attention mechanism", + "robotics", + ], + install_requires=[ + "torch>=1.9", + "scikit-image", + "sentence-transformers", + "tensorflow", + "tensorflow_datasets", + "transformers", + "gymnasium[mujoco]", + "dm-reverb", + "dm-control", + "rlds", + "einops", + "dmc2gymnasium@git+https://github.com/imgeorgiev/dmc2gymnasium.git", + "h5py", + "wandb", + "tqdm", + ], + classifiers=[ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.6", + ], +) \ No newline at end of file diff --git a/vd4rl_main.py b/vd4rl_main.py new file mode 100644 index 000000000..bd7a6dc06 --- /dev/null +++ b/vd4rl_main.py @@ -0,0 +1,389 @@ +import argparse +import os +from typing import Dict, Iterable + +import gymnasium as gym +import h5py +import numpy as np +import requests +import torch +import tqdm +import wandb +from dmc2gymnasium import DMCGym +from sentence_transformers import SentenceTransformer +from torch.optim import Adam + +from rt1_pytorch.rt1_policy import RT1Policy + +DATASET_URL = "https://huggingface.co/datasets/conglu/vd4rl/resolve/main/vd4rl/main/{domain}_{task}/expert/84px/{index}_{domain}_{task}_expert.hdf5" +ACTION_REPEAT = 2 + + +class VD4RLEnv(gym.Env): + def __init__( + self, + env_id: str, + embedding: np.ndarray, + embedding_dim: int, + num_frames: int, + dataset_dir: str, + ): + super().__init__() + self.domain, self.task = env_id.split("-") + self.env = DMCGym(self.domain, self.task) + self.embedding = embedding + self.embedding_dim = embedding_dim + self.num_frames = num_frames + self._load_dataset(dataset_dir) + + @property + def observation_space(self): + return gym.spaces.Dict( + { + "image": gym.spaces.Box( + low=0, high=255, shape=(84, 84, 3), dtype=np.uint8 + ), + "embedding": gym.spaces.Box( + low=-1.0, high=1.0, shape=(self.embedding_dim,), dtype=np.float32 + ), + } + ) + + @property + def action_space(self): + return gym.spaces.Dict({"action_key": self.env.action_space}) + + def reset(self): + _, info = self.env.reset() + obs = self.env.render(84, 84) + return ({"image": obs, "embedding": self.embedding}, info) + + def step(self, action): + action = action["action_key"] + term = False + trunc = False + for _ in range(ACTION_REPEAT): + _, r, term, trunc, info = self.env.step(action) + if term or trunc: + break + o = self.env.render(84, 84) + return ({"image": o, "embedding": self.embedding}, r, term, trunc, info) + + def _load_dataset(self, dataset_dir: str): + os.makedirs(dataset_dir, exist_ok=True) + observations = [] + actions = [] + for index in tqdm.trange(4): + file = f"{index}_{self.domain}_{self.task}_expert.hdf5" + path = os.path.join(dataset_dir, file) + if not os.path.exists(path): + url = DATASET_URL.format( + domain=self.domain, + task=self.task, + index=index, + ) + if self.domain == "humanoid" and self.task == "walk": + url = url.rsplit("/")[0] + f"/{index}_expert.hdf5" + response = requests.get(url) + if response.status_code == 200: + with open(path, "wb") as f: + f.write(response.content) + with h5py.File(path, "r") as f: + observations.append(f["observation"][:]) + actions.append(f["action"][:]) + self.observations = np.concatenate(observations) + self.actions = np.concatenate(actions) + + def get_dataset(self, batch_size: int) -> Iterable[Dict]: + # We expect self.num_frames trajectories per episode + num_episodes = np.ceil(batch_size / self.num_frames).astype(int) + # Leftover trajectories from last episode + prev_obs = None + prev_act = None + for idx in range(0, self.actions.shape[0], num_episodes * 501): + # Get `batch_size` number of episodes + obs = self.observations[idx : idx + num_episodes * 501] + act = self.actions[idx : idx + num_episodes * 501] + + # Convert to (b, t, ...) + obs = np.reshape(obs, (num_episodes, 501, *obs.shape[1:])) + act = np.reshape(act, (num_episodes, 501, *act.shape[1:])) + + # drop the last timestep and action from each episode + obs = obs[:, :-1] + act = act[:, :-1] + + # frame-stack by rolling self.num_frames times over t + num_traj = 500 - self.num_frames + 1 + indices = np.stack( + [np.arange(s, s + num_traj) for s in range(self.num_frames)], + axis=-1, + ) + + # (b, t, ...) -> (b, t - f + 1, f, ...) + obs = np.take(obs, indices, axis=1) + act = np.take(act, indices, axis=1) + + # (b, t - f + 1, f, ...) -> (b * (t - f + 1), f, ...) + obs = np.reshape(obs, (num_episodes * num_traj, *obs.shape[2:])) + act = np.reshape(act, (num_episodes * num_traj, *act.shape[2:])) + + # Concatenate with leftover trajectories from last episode + if prev_obs is not None: + obs = np.concatenate([prev_obs, obs], axis=0) + act = np.concatenate([prev_act, act], axis=0) + + for batch in range(0, obs.shape[0], batch_size): + if batch + batch_size > obs.shape[0]: + # Save leftover trajectories and break + prev_obs = obs[batch:] + prev_act = act[batch:] + break + + yield { + "observation": { + "image": obs[batch : batch + batch_size], + "embedding": np.tile( + np.expand_dims(self.embedding, (0, 1)), + (batch_size, self.num_frames, 1), + ), + }, + "action": {"action_key": act[batch : batch + batch_size]}, + } + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--env", + type=str, + default="walker-walk", + help="name of the environment", + choices=[ + "walker-walk", + "cheetah-run", + "humanoid-walk", + ], + ) + parser.add_argument( + "--context", + type=str, + default="""Move forward by walking upright on two legs, + while maintaining balance and stability""", + ) + # cheetah-run: """Run forward rapidly on all four legs, + # coordinating movements for speed and efficiency""" + parser.add_argument( + "--epochs", + type=int, + default=10, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--batch-size", + type=int, + default=32, + help="batch size in number of trajectories", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=4, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default="all-MiniLM-L6-v2", + help="SentenceTransformer to use for text embedding", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=None, + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=None, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/vd4rl", + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--dataset-dir", + type=str, + default="datasets", + help="local directory for datasets", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + if args.wandb: + wandb.init(project="rt1-vd4rl", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + text_embedding_model = SentenceTransformer(args.sentence_transformer) + embedding_dim = text_embedding_model.get_sentence_embedding_dimension() + embedding = text_embedding_model.encode(args.context) + + print("Loading dataset...") + env = VD4RLEnv( + env_id=args.env, + embedding=embedding, + embedding_dim=embedding_dim, + num_frames=args.trajectory_length, + dataset_dir=args.dataset_dir, + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=env.observation_space, + action_space=env.action_space, + arch="efficientnet_b0", + action_bins=512, + num_layers=4, + num_heads=4, + feed_forward_size=512, + dropout_rate=0.01, + time_sequence_length=args.trajectory_length, + embedding_dim=embedding_dim, + use_token_learner=True, + token_learner_bottleneck_dim=32, + token_learner_num_output_tokens=8, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + return observation["embedding"] + + print("Training...") + num_batches = 0 + for epoch in range(1, args.epochs + 1): + train_dataset = env.get_dataset(batch_size=args.batch_size) + for batch in train_dataset: + policy.model.train() + num_batches += 1 + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + actions = batch["action"] + loss = policy.loss(observations, actions) + if args.wandb: + wandb.log( + {"train_loss": loss.item()}, + step=num_batches * args.batch_size, + ) + else: + print(f"Batch {num_batches} train loss: {loss.item()}") + optimizer.zero_grad() + loss.backward() + optimizer.step() + if args.eval_freq and num_batches % args.eval_freq == 0: + print("Evaluating...") + policy.model.eval() + obs, _ = env.reset() + obs_stacked = { + k: np.stack([v for _ in range(args.trajectory_length)]) + for k, v in obs.items() + } + observations = {"image": [], "context": []} + actions = {"action_key": []} + term = False + trunc = False + reward = 0.0 + ts = 0 + while not (term or trunc): + cur_obs = { + "image": obs_stacked["image"], + "context": get_text_embedding(obs_stacked), + } + + # add batch dimension + cur_obs["image"] = np.expand_dims(cur_obs["image"], axis=0) + cur_obs["context"] = np.expand_dims(cur_obs["context"], axis=0) + + act = policy.act(cur_obs) + + # remove batch dimension + act = {k: v[0] for k, v in act.items()} + new_obs, rew, term, trunc, info = env.step(act) + obs_stacked = { + k: np.concatenate( + [ + obs_stacked[k][1:], + np.expand_dims(new_obs[k], axis=0), + ] + ) + for k in new_obs.keys() + } + observations["image"].append(obs_stacked["image"]) + observations["context"].append(get_text_embedding(obs_stacked)) + actions["action_key"].append(act["action_key"]) + reward += rew * (info["discount"] ** ts) + ts += 1 + if args.wandb: + wandb.log( + {"eval_return": reward}, + step=num_batches * args.batch_size, + ) + else: + print(f"Batch {num_batches} eval return: {reward}") + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{num_batches * args.batch_size * epoch}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + + +if __name__ == "__main__": + main() \ No newline at end of file From c2b345e93f29ad983b852b809f1ece24ee8d51fe Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Wed, 12 Jun 2024 23:56:11 -0400 Subject: [PATCH 02/12] commit of the supporting files and RT1 model with cleaned uncommented code --- figures/rt1.png | Bin 0 -> 135877 bytes gen/README.md | 77 + gen/__init__.py | 0 gen/agents/agent_base.py | 60 + gen/agents/deterministic_planner_agent.py | 26 + gen/agents/plan_agent.py | 94 + gen/agents/semantic_map_planner_agent.py | 72 + gen/constants.py | 1221 ++++++ gen/ff_planner/README.md | 13 + gen/ff_planner/expressions.c | 2623 +++++++++++ gen/ff_planner/expressions.h | 106 + gen/ff_planner/ff.h | 2044 +++++++++ gen/ff_planner/inst_easy.c | 1220 ++++++ gen/ff_planner/inst_easy.h | 73 + gen/ff_planner/inst_final.c | 2797 ++++++++++++ gen/ff_planner/inst_final.h | 69 + gen/ff_planner/inst_hard.c | 1306 ++++++ gen/ff_planner/inst_hard.h | 71 + gen/ff_planner/inst_pre.c | 3854 +++++++++++++++++ gen/ff_planner/inst_pre.h | 123 + gen/ff_planner/lex-fct_pddl.l | 139 + gen/ff_planner/lex-ops_pddl.l | 151 + gen/ff_planner/main.c | 1230 ++++++ gen/ff_planner/makefile | 89 + gen/ff_planner/memory.c | 1278 ++++++ gen/ff_planner/memory.h | 109 + gen/ff_planner/output.c | 1482 +++++++ gen/ff_planner/output.h | 68 + gen/ff_planner/parse.c | 1339 ++++++ gen/ff_planner/parse.h | 63 + gen/ff_planner/relax.c | 2756 ++++++++++++ gen/ff_planner/relax.h | 93 + gen/ff_planner/run_sample.sh | 2 + gen/ff_planner/samples/PutTask_domain.pddl | 152 + gen/ff_planner/samples/problem_0_0.pddl | 390 ++ gen/ff_planner/scan-fct_pddl.y | 918 ++++ gen/ff_planner/scan-ops_pddl.y | 1086 +++++ gen/ff_planner/search.c | 2372 ++++++++++ gen/ff_planner/search.h | 105 + gen/game_states/__init__.py | 0 gen/game_states/game_state_base.py | 935 ++++ gen/game_states/planned_game_state.py | 490 +++ gen/game_states/task_game_state.py | 368 ++ .../task_game_state_full_knowledge.py | 444 ++ gen/goal_library.py | 682 +++ gen/graph/__init__.py | 0 gen/graph/graph_obj.py | 426 ++ gen/layouts/FloorPlan1-layout.npy | Bin 0 -> 2064 bytes gen/layouts/FloorPlan1-objects.json | 51 + gen/layouts/FloorPlan1-openable.json | 146 + gen/layouts/FloorPlan10-layout.npy | Bin 0 -> 3488 bytes gen/layouts/FloorPlan10-objects.json | 49 + gen/layouts/FloorPlan10-openable.json | 110 + gen/layouts/FloorPlan11-layout.npy | Bin 0 -> 1104 bytes gen/layouts/FloorPlan11-objects.json | 43 + gen/layouts/FloorPlan11-openable.json | 128 + gen/layouts/FloorPlan12-layout.npy | Bin 0 -> 1808 bytes gen/layouts/FloorPlan12-objects.json | 40 + gen/layouts/FloorPlan12-openable.json | 218 + gen/layouts/FloorPlan13-layout.npy | Bin 0 -> 3008 bytes gen/layouts/FloorPlan13-objects.json | 43 + gen/layouts/FloorPlan13-openable.json | 224 + gen/layouts/FloorPlan14-layout.npy | Bin 0 -> 1968 bytes gen/layouts/FloorPlan14-objects.json | 40 + gen/layouts/FloorPlan14-openable.json | 68 + gen/layouts/FloorPlan15-layout.npy | Bin 0 -> 1616 bytes gen/layouts/FloorPlan15-objects.json | 45 + gen/layouts/FloorPlan15-openable.json | 92 + gen/layouts/FloorPlan16-layout.npy | Bin 0 -> 3312 bytes gen/layouts/FloorPlan16-objects.json | 46 + gen/layouts/FloorPlan16-openable.json | 200 + gen/layouts/FloorPlan17-layout.npy | Bin 0 -> 1168 bytes gen/layouts/FloorPlan17-objects.json | 47 + gen/layouts/FloorPlan17-openable.json | 140 + gen/layouts/FloorPlan18-layout.npy | Bin 0 -> 3600 bytes gen/layouts/FloorPlan18-objects.json | 48 + gen/layouts/FloorPlan18-openable.json | 146 + gen/layouts/FloorPlan19-layout.npy | Bin 0 -> 1184 bytes gen/layouts/FloorPlan19-objects.json | 40 + gen/layouts/FloorPlan19-openable.json | 182 + gen/layouts/FloorPlan2-layout.npy | Bin 0 -> 1968 bytes gen/layouts/FloorPlan2-objects.json | 43 + gen/layouts/FloorPlan2-openable.json | 164 + gen/layouts/FloorPlan20-layout.npy | Bin 0 -> 1392 bytes gen/layouts/FloorPlan20-objects.json | 46 + gen/layouts/FloorPlan20-openable.json | 116 + gen/layouts/FloorPlan201-layout.npy | Bin 0 -> 3232 bytes gen/layouts/FloorPlan201-objects.json | 37 + gen/layouts/FloorPlan201-openable.json | 86 + gen/layouts/FloorPlan202-layout.npy | Bin 0 -> 2496 bytes gen/layouts/FloorPlan202-objects.json | 26 + gen/layouts/FloorPlan202-openable.json | 44 + gen/layouts/FloorPlan203-layout.npy | Bin 0 -> 8512 bytes gen/layouts/FloorPlan203-objects.json | 35 + gen/layouts/FloorPlan203-openable.json | 86 + gen/layouts/FloorPlan204-layout.npy | Bin 0 -> 2960 bytes gen/layouts/FloorPlan204-objects.json | 31 + gen/layouts/FloorPlan204-openable.json | 146 + gen/layouts/FloorPlan205-layout.npy | Bin 0 -> 4112 bytes gen/layouts/FloorPlan205-objects.json | 29 + gen/layouts/FloorPlan205-openable.json | 80 + gen/layouts/FloorPlan206-layout.npy | Bin 0 -> 1904 bytes gen/layouts/FloorPlan206-objects.json | 26 + gen/layouts/FloorPlan206-openable.json | 122 + gen/layouts/FloorPlan207-layout.npy | Bin 0 -> 2352 bytes gen/layouts/FloorPlan207-objects.json | 27 + gen/layouts/FloorPlan207-openable.json | 98 + gen/layouts/FloorPlan208-layout.npy | Bin 0 -> 3376 bytes gen/layouts/FloorPlan208-objects.json | 26 + gen/layouts/FloorPlan208-openable.json | 98 + gen/layouts/FloorPlan209-layout.npy | Bin 0 -> 4816 bytes gen/layouts/FloorPlan209-objects.json | 31 + gen/layouts/FloorPlan209-openable.json | 62 + gen/layouts/FloorPlan21-layout.npy | Bin 0 -> 1584 bytes gen/layouts/FloorPlan21-objects.json | 47 + gen/layouts/FloorPlan21-openable.json | 86 + gen/layouts/FloorPlan210-layout.npy | Bin 0 -> 4160 bytes gen/layouts/FloorPlan210-objects.json | 30 + gen/layouts/FloorPlan210-openable.json | 98 + gen/layouts/FloorPlan211-layout.npy | Bin 0 -> 2240 bytes gen/layouts/FloorPlan211-objects.json | 30 + gen/layouts/FloorPlan211-openable.json | 74 + gen/layouts/FloorPlan212-layout.npy | Bin 0 -> 1856 bytes gen/layouts/FloorPlan212-objects.json | 30 + gen/layouts/FloorPlan212-openable.json | 80 + gen/layouts/FloorPlan213-layout.npy | Bin 0 -> 4736 bytes gen/layouts/FloorPlan213-objects.json | 27 + gen/layouts/FloorPlan213-openable.json | 146 + gen/layouts/FloorPlan214-layout.npy | Bin 0 -> 3024 bytes gen/layouts/FloorPlan214-objects.json | 29 + gen/layouts/FloorPlan214-openable.json | 56 + gen/layouts/FloorPlan215-layout.npy | Bin 0 -> 6208 bytes gen/layouts/FloorPlan215-objects.json | 30 + gen/layouts/FloorPlan215-openable.json | 92 + gen/layouts/FloorPlan216-layout.npy | Bin 0 -> 2560 bytes gen/layouts/FloorPlan216-objects.json | 28 + gen/layouts/FloorPlan216-openable.json | 68 + gen/layouts/FloorPlan217-layout.npy | Bin 0 -> 2240 bytes gen/layouts/FloorPlan217-objects.json | 29 + gen/layouts/FloorPlan217-openable.json | 92 + gen/layouts/FloorPlan218-layout.npy | Bin 0 -> 6400 bytes gen/layouts/FloorPlan218-objects.json | 30 + gen/layouts/FloorPlan218-openable.json | 68 + gen/layouts/FloorPlan219-layout.npy | Bin 0 -> 3552 bytes gen/layouts/FloorPlan219-objects.json | 31 + gen/layouts/FloorPlan219-openable.json | 158 + gen/layouts/FloorPlan22-layout.npy | Bin 0 -> 2256 bytes gen/layouts/FloorPlan22-objects.json | 42 + gen/layouts/FloorPlan22-openable.json | 176 + gen/layouts/FloorPlan220-layout.npy | Bin 0 -> 3712 bytes gen/layouts/FloorPlan220-objects.json | 30 + gen/layouts/FloorPlan220-openable.json | 92 + gen/layouts/FloorPlan221-layout.npy | Bin 0 -> 1904 bytes gen/layouts/FloorPlan221-objects.json | 29 + gen/layouts/FloorPlan221-openable.json | 44 + gen/layouts/FloorPlan222-layout.npy | Bin 0 -> 1648 bytes gen/layouts/FloorPlan222-objects.json | 26 + gen/layouts/FloorPlan222-openable.json | 86 + gen/layouts/FloorPlan223-layout.npy | Bin 0 -> 3344 bytes gen/layouts/FloorPlan223-objects.json | 28 + gen/layouts/FloorPlan223-openable.json | 50 + gen/layouts/FloorPlan224-layout.npy | Bin 0 -> 4688 bytes gen/layouts/FloorPlan224-objects.json | 32 + gen/layouts/FloorPlan224-openable.json | 182 + gen/layouts/FloorPlan225-layout.npy | Bin 0 -> 2576 bytes gen/layouts/FloorPlan225-objects.json | 31 + gen/layouts/FloorPlan225-openable.json | 86 + gen/layouts/FloorPlan226-layout.npy | Bin 0 -> 1392 bytes gen/layouts/FloorPlan226-objects.json | 25 + gen/layouts/FloorPlan226-openable.json | 68 + gen/layouts/FloorPlan227-layout.npy | Bin 0 -> 3232 bytes gen/layouts/FloorPlan227-objects.json | 28 + gen/layouts/FloorPlan227-openable.json | 206 + gen/layouts/FloorPlan228-layout.npy | Bin 0 -> 2576 bytes gen/layouts/FloorPlan228-objects.json | 27 + gen/layouts/FloorPlan228-openable.json | 62 + gen/layouts/FloorPlan229-layout.npy | Bin 0 -> 3088 bytes gen/layouts/FloorPlan229-objects.json | 32 + gen/layouts/FloorPlan229-openable.json | 68 + gen/layouts/FloorPlan23-layout.npy | Bin 0 -> 1648 bytes gen/layouts/FloorPlan23-objects.json | 47 + gen/layouts/FloorPlan23-openable.json | 98 + gen/layouts/FloorPlan230-layout.npy | Bin 0 -> 6448 bytes gen/layouts/FloorPlan230-objects.json | 32 + gen/layouts/FloorPlan230-openable.json | 56 + gen/layouts/FloorPlan24-layout.npy | Bin 0 -> 1152 bytes gen/layouts/FloorPlan24-objects.json | 42 + gen/layouts/FloorPlan24-openable.json | 176 + gen/layouts/FloorPlan25-layout.npy | Bin 0 -> 560 bytes gen/layouts/FloorPlan25-objects.json | 41 + gen/layouts/FloorPlan25-openable.json | 92 + gen/layouts/FloorPlan26-layout.npy | Bin 0 -> 1344 bytes gen/layouts/FloorPlan26-objects.json | 40 + gen/layouts/FloorPlan26-openable.json | 92 + gen/layouts/FloorPlan27-layout.npy | Bin 0 -> 784 bytes gen/layouts/FloorPlan27-objects.json | 43 + gen/layouts/FloorPlan27-openable.json | 128 + gen/layouts/FloorPlan28-layout.npy | Bin 0 -> 1712 bytes gen/layouts/FloorPlan28-objects.json | 43 + gen/layouts/FloorPlan28-openable.json | 122 + gen/layouts/FloorPlan29-layout.npy | Bin 0 -> 1168 bytes gen/layouts/FloorPlan29-objects.json | 39 + gen/layouts/FloorPlan29-openable.json | 80 + gen/layouts/FloorPlan3-layout.npy | Bin 0 -> 1856 bytes gen/layouts/FloorPlan3-objects.json | 45 + gen/layouts/FloorPlan3-openable.json | 110 + gen/layouts/FloorPlan30-layout.npy | Bin 0 -> 1296 bytes gen/layouts/FloorPlan30-objects.json | 45 + gen/layouts/FloorPlan30-openable.json | 218 + gen/layouts/FloorPlan301-layout.npy | Bin 0 -> 1392 bytes gen/layouts/FloorPlan301-objects.json | 35 + gen/layouts/FloorPlan301-openable.json | 122 + gen/layouts/FloorPlan302-layout.npy | Bin 0 -> 848 bytes gen/layouts/FloorPlan302-objects.json | 31 + gen/layouts/FloorPlan302-openable.json | 80 + gen/layouts/FloorPlan303-layout.npy | Bin 0 -> 1168 bytes gen/layouts/FloorPlan303-objects.json | 35 + gen/layouts/FloorPlan303-openable.json | 122 + gen/layouts/FloorPlan304-layout.npy | Bin 0 -> 1808 bytes gen/layouts/FloorPlan304-objects.json | 30 + gen/layouts/FloorPlan304-openable.json | 26 + gen/layouts/FloorPlan305-layout.npy | Bin 0 -> 1472 bytes gen/layouts/FloorPlan305-objects.json | 32 + gen/layouts/FloorPlan305-openable.json | 62 + gen/layouts/FloorPlan306-layout.npy | Bin 0 -> 1632 bytes gen/layouts/FloorPlan306-objects.json | 27 + gen/layouts/FloorPlan306-openable.json | 68 + gen/layouts/FloorPlan307-layout.npy | Bin 0 -> 1424 bytes gen/layouts/FloorPlan307-objects.json | 34 + gen/layouts/FloorPlan307-openable.json | 104 + gen/layouts/FloorPlan308-layout.npy | Bin 0 -> 1744 bytes gen/layouts/FloorPlan308-objects.json | 30 + gen/layouts/FloorPlan308-openable.json | 104 + gen/layouts/FloorPlan309-layout.npy | Bin 0 -> 5760 bytes gen/layouts/FloorPlan309-objects.json | 33 + gen/layouts/FloorPlan309-openable.json | 74 + gen/layouts/FloorPlan310-layout.npy | Bin 0 -> 1152 bytes gen/layouts/FloorPlan310-objects.json | 31 + gen/layouts/FloorPlan310-openable.json | 50 + gen/layouts/FloorPlan311-layout.npy | Bin 0 -> 3760 bytes gen/layouts/FloorPlan311-objects.json | 32 + gen/layouts/FloorPlan311-openable.json | 56 + gen/layouts/FloorPlan312-layout.npy | Bin 0 -> 1440 bytes gen/layouts/FloorPlan312-objects.json | 27 + gen/layouts/FloorPlan312-openable.json | 74 + gen/layouts/FloorPlan313-layout.npy | Bin 0 -> 880 bytes gen/layouts/FloorPlan313-objects.json | 34 + gen/layouts/FloorPlan313-openable.json | 80 + gen/layouts/FloorPlan314-layout.npy | Bin 0 -> 1200 bytes gen/layouts/FloorPlan314-objects.json | 27 + gen/layouts/FloorPlan314-openable.json | 50 + gen/layouts/FloorPlan315-layout.npy | Bin 0 -> 1712 bytes gen/layouts/FloorPlan315-objects.json | 28 + gen/layouts/FloorPlan315-openable.json | 110 + gen/layouts/FloorPlan316-layout.npy | Bin 0 -> 1056 bytes gen/layouts/FloorPlan316-objects.json | 30 + gen/layouts/FloorPlan316-openable.json | 44 + gen/layouts/FloorPlan317-layout.npy | Bin 0 -> 1680 bytes gen/layouts/FloorPlan317-objects.json | 30 + gen/layouts/FloorPlan317-openable.json | 92 + gen/layouts/FloorPlan318-layout.npy | Bin 0 -> 1632 bytes gen/layouts/FloorPlan318-objects.json | 31 + gen/layouts/FloorPlan318-openable.json | 158 + gen/layouts/FloorPlan319-layout.npy | Bin 0 -> 1680 bytes gen/layouts/FloorPlan319-objects.json | 30 + gen/layouts/FloorPlan319-openable.json | 122 + gen/layouts/FloorPlan320-layout.npy | Bin 0 -> 1200 bytes gen/layouts/FloorPlan320-objects.json | 30 + gen/layouts/FloorPlan320-openable.json | 50 + gen/layouts/FloorPlan321-layout.npy | Bin 0 -> 1600 bytes gen/layouts/FloorPlan321-objects.json | 27 + gen/layouts/FloorPlan321-openable.json | 44 + gen/layouts/FloorPlan322-layout.npy | Bin 0 -> 1792 bytes gen/layouts/FloorPlan322-objects.json | 30 + gen/layouts/FloorPlan322-openable.json | 122 + gen/layouts/FloorPlan323-layout.npy | Bin 0 -> 3184 bytes gen/layouts/FloorPlan323-objects.json | 30 + gen/layouts/FloorPlan323-openable.json | 80 + gen/layouts/FloorPlan324-layout.npy | Bin 0 -> 1552 bytes gen/layouts/FloorPlan324-objects.json | 29 + gen/layouts/FloorPlan324-openable.json | 110 + gen/layouts/FloorPlan325-layout.npy | Bin 0 -> 3040 bytes gen/layouts/FloorPlan325-objects.json | 28 + gen/layouts/FloorPlan325-openable.json | 140 + gen/layouts/FloorPlan326-layout.npy | Bin 0 -> 1728 bytes gen/layouts/FloorPlan326-objects.json | 35 + gen/layouts/FloorPlan326-openable.json | 128 + gen/layouts/FloorPlan327-layout.npy | Bin 0 -> 1392 bytes gen/layouts/FloorPlan327-objects.json | 29 + gen/layouts/FloorPlan327-openable.json | 92 + gen/layouts/FloorPlan328-layout.npy | Bin 0 -> 1104 bytes gen/layouts/FloorPlan328-objects.json | 31 + gen/layouts/FloorPlan328-openable.json | 44 + gen/layouts/FloorPlan329-layout.npy | Bin 0 -> 1536 bytes gen/layouts/FloorPlan329-objects.json | 28 + gen/layouts/FloorPlan329-openable.json | 50 + gen/layouts/FloorPlan330-layout.npy | Bin 0 -> 2240 bytes gen/layouts/FloorPlan330-objects.json | 32 + gen/layouts/FloorPlan330-openable.json | 122 + gen/layouts/FloorPlan4-layout.npy | Bin 0 -> 1232 bytes gen/layouts/FloorPlan4-objects.json | 42 + gen/layouts/FloorPlan4-openable.json | 98 + gen/layouts/FloorPlan401-layout.npy | Bin 0 -> 1616 bytes gen/layouts/FloorPlan401-objects.json | 32 + gen/layouts/FloorPlan401-openable.json | 56 + gen/layouts/FloorPlan402-layout.npy | Bin 0 -> 1584 bytes gen/layouts/FloorPlan402-objects.json | 33 + gen/layouts/FloorPlan402-openable.json | 92 + gen/layouts/FloorPlan403-layout.npy | Bin 0 -> 1008 bytes gen/layouts/FloorPlan403-objects.json | 34 + gen/layouts/FloorPlan403-openable.json | 50 + gen/layouts/FloorPlan404-layout.npy | Bin 0 -> 1008 bytes gen/layouts/FloorPlan404-objects.json | 29 + gen/layouts/FloorPlan404-openable.json | 38 + gen/layouts/FloorPlan405-layout.npy | Bin 0 -> 576 bytes gen/layouts/FloorPlan405-objects.json | 28 + gen/layouts/FloorPlan405-openable.json | 56 + gen/layouts/FloorPlan406-layout.npy | Bin 0 -> 1664 bytes gen/layouts/FloorPlan406-objects.json | 28 + gen/layouts/FloorPlan406-openable.json | 26 + gen/layouts/FloorPlan407-layout.npy | Bin 0 -> 672 bytes gen/layouts/FloorPlan407-objects.json | 32 + gen/layouts/FloorPlan407-openable.json | 56 + gen/layouts/FloorPlan408-layout.npy | Bin 0 -> 704 bytes gen/layouts/FloorPlan408-objects.json | 28 + gen/layouts/FloorPlan408-openable.json | 62 + gen/layouts/FloorPlan409-layout.npy | Bin 0 -> 752 bytes gen/layouts/FloorPlan409-objects.json | 28 + gen/layouts/FloorPlan409-openable.json | 62 + gen/layouts/FloorPlan410-layout.npy | Bin 0 -> 1408 bytes gen/layouts/FloorPlan410-objects.json | 29 + gen/layouts/FloorPlan410-openable.json | 74 + gen/layouts/FloorPlan411-layout.npy | Bin 0 -> 1104 bytes gen/layouts/FloorPlan411-objects.json | 31 + gen/layouts/FloorPlan411-openable.json | 62 + gen/layouts/FloorPlan412-layout.npy | Bin 0 -> 784 bytes gen/layouts/FloorPlan412-objects.json | 29 + gen/layouts/FloorPlan412-openable.json | 50 + gen/layouts/FloorPlan413-layout.npy | Bin 0 -> 1216 bytes gen/layouts/FloorPlan413-objects.json | 32 + gen/layouts/FloorPlan413-openable.json | 92 + gen/layouts/FloorPlan414-layout.npy | Bin 0 -> 800 bytes gen/layouts/FloorPlan414-objects.json | 31 + gen/layouts/FloorPlan414-openable.json | 92 + gen/layouts/FloorPlan415-layout.npy | Bin 0 -> 880 bytes gen/layouts/FloorPlan415-objects.json | 31 + gen/layouts/FloorPlan415-openable.json | 68 + gen/layouts/FloorPlan416-layout.npy | Bin 0 -> 992 bytes gen/layouts/FloorPlan416-objects.json | 28 + gen/layouts/FloorPlan416-openable.json | 44 + gen/layouts/FloorPlan417-layout.npy | Bin 0 -> 1088 bytes gen/layouts/FloorPlan417-objects.json | 29 + gen/layouts/FloorPlan417-openable.json | 44 + gen/layouts/FloorPlan418-layout.npy | Bin 0 -> 864 bytes gen/layouts/FloorPlan418-objects.json | 29 + gen/layouts/FloorPlan418-openable.json | 44 + gen/layouts/FloorPlan419-layout.npy | Bin 0 -> 608 bytes gen/layouts/FloorPlan419-objects.json | 30 + gen/layouts/FloorPlan419-openable.json | 44 + gen/layouts/FloorPlan420-layout.npy | Bin 0 -> 560 bytes gen/layouts/FloorPlan420-objects.json | 29 + gen/layouts/FloorPlan420-openable.json | 32 + gen/layouts/FloorPlan421-layout.npy | Bin 0 -> 608 bytes gen/layouts/FloorPlan421-objects.json | 29 + gen/layouts/FloorPlan421-openable.json | 68 + gen/layouts/FloorPlan422-layout.npy | Bin 0 -> 656 bytes gen/layouts/FloorPlan422-objects.json | 33 + gen/layouts/FloorPlan422-openable.json | 86 + gen/layouts/FloorPlan423-layout.npy | Bin 0 -> 1008 bytes gen/layouts/FloorPlan423-objects.json | 32 + gen/layouts/FloorPlan423-openable.json | 86 + gen/layouts/FloorPlan424-layout.npy | Bin 0 -> 736 bytes gen/layouts/FloorPlan424-objects.json | 28 + gen/layouts/FloorPlan424-openable.json | 56 + gen/layouts/FloorPlan425-layout.npy | Bin 0 -> 512 bytes gen/layouts/FloorPlan425-objects.json | 30 + gen/layouts/FloorPlan425-openable.json | 56 + gen/layouts/FloorPlan426-layout.npy | Bin 0 -> 912 bytes gen/layouts/FloorPlan426-objects.json | 31 + gen/layouts/FloorPlan426-openable.json | 68 + gen/layouts/FloorPlan427-layout.npy | Bin 0 -> 992 bytes gen/layouts/FloorPlan427-objects.json | 32 + gen/layouts/FloorPlan427-openable.json | 80 + gen/layouts/FloorPlan428-layout.npy | Bin 0 -> 992 bytes gen/layouts/FloorPlan428-objects.json | 28 + gen/layouts/FloorPlan428-openable.json | 50 + gen/layouts/FloorPlan429-layout.npy | Bin 0 -> 1152 bytes gen/layouts/FloorPlan429-objects.json | 29 + gen/layouts/FloorPlan429-openable.json | 38 + gen/layouts/FloorPlan430-layout.npy | Bin 0 -> 1760 bytes gen/layouts/FloorPlan430-objects.json | 35 + gen/layouts/FloorPlan430-openable.json | 50 + gen/layouts/FloorPlan5-layout.npy | Bin 0 -> 1680 bytes gen/layouts/FloorPlan5-objects.json | 47 + gen/layouts/FloorPlan5-openable.json | 152 + gen/layouts/FloorPlan6-layout.npy | Bin 0 -> 2176 bytes gen/layouts/FloorPlan6-objects.json | 42 + gen/layouts/FloorPlan6-openable.json | 164 + gen/layouts/FloorPlan7-layout.npy | Bin 0 -> 4352 bytes gen/layouts/FloorPlan7-objects.json | 50 + gen/layouts/FloorPlan7-openable.json | 146 + gen/layouts/FloorPlan8-layout.npy | Bin 0 -> 2768 bytes gen/layouts/FloorPlan8-objects.json | 46 + gen/layouts/FloorPlan8-openable.json | 170 + gen/layouts/FloorPlan9-layout.npy | Bin 0 -> 1360 bytes gen/layouts/FloorPlan9-objects.json | 42 + gen/layouts/FloorPlan9-openable.json | 260 ++ gen/layouts/precompute_layout_locations.py | 350 ++ gen/planner/__init__.py | 0 .../domains/PutTaskExtended_domain.pddl | 302 ++ gen/planner/ff_planner_handler.py | 252 ++ gen/planner/pddl.pdf | Bin 0 -> 196613 bytes gen/scripts/augment_trajectories.py | 312 ++ gen/scripts/generate_trajectories.py | 752 ++++ gen/scripts/replay_checks.py | 217 + gen/utils/__init__.py | 0 gen/utils/bb_util.py | 139 + gen/utils/dataset_management_util.py | 69 + gen/utils/game_util.py | 363 ++ gen/utils/image_util.py | 57 + gen/utils/py_util.py | 84 + gen/utils/replay_json.py | 52 + gen/utils/video_util.py | 11 + lanmp_dataloader/attribute_limits.json | 1 + lanmp_dataloader/rt1_dataloader.py | 800 ++++ lanmp_dataloader/scene_to_keys.json | 1 + rt1_pytorch/__init__.py | 0 rt1_pytorch/film_efficientnet/__init__.py | 0 .../film_conditioning_layer.py | 38 + .../film_efficientnet/film_efficientnet.py | 446 ++ rt1_pytorch/rt1_model.py | 217 + rt1_pytorch/rt1_policy.py | 234 + rt1_pytorch/tokenizers/__init__.py | 0 rt1_pytorch/tokenizers/action_tokenizer.py | 184 + rt1_pytorch/tokenizers/image_tokenizer.py | 77 + rt1_pytorch/tokenizers/token_learner.py | 89 + tests/action_tokenizer_test.py | 166 + tests/film_conditioning_layer_test.py | 27 + tests/film_efficientnet_test.py | 57 + tests/image_tokenizer_test.py | 53 + tests/rt1_model_test.py | 54 + tests/rt1_policy_test.py | 64 + tests/token_learner_test.py | 40 + 443 files changed, 53971 insertions(+) create mode 100644 figures/rt1.png create mode 100644 gen/README.md create mode 100644 gen/__init__.py create mode 100644 gen/agents/agent_base.py create mode 100644 gen/agents/deterministic_planner_agent.py create mode 100644 gen/agents/plan_agent.py create mode 100644 gen/agents/semantic_map_planner_agent.py create mode 100644 gen/constants.py create mode 100644 gen/ff_planner/README.md create mode 100644 gen/ff_planner/expressions.c create mode 100644 gen/ff_planner/expressions.h create mode 100644 gen/ff_planner/ff.h create mode 100644 gen/ff_planner/inst_easy.c create mode 100644 gen/ff_planner/inst_easy.h create mode 100644 gen/ff_planner/inst_final.c create mode 100644 gen/ff_planner/inst_final.h create mode 100644 gen/ff_planner/inst_hard.c create mode 100644 gen/ff_planner/inst_hard.h create mode 100644 gen/ff_planner/inst_pre.c create mode 100644 gen/ff_planner/inst_pre.h create mode 100644 gen/ff_planner/lex-fct_pddl.l create mode 100644 gen/ff_planner/lex-ops_pddl.l create mode 100644 gen/ff_planner/main.c create mode 100644 gen/ff_planner/makefile create mode 100644 gen/ff_planner/memory.c create mode 100644 gen/ff_planner/memory.h create mode 100644 gen/ff_planner/output.c create mode 100644 gen/ff_planner/output.h create mode 100644 gen/ff_planner/parse.c create mode 100644 gen/ff_planner/parse.h create mode 100644 gen/ff_planner/relax.c create mode 100644 gen/ff_planner/relax.h create mode 100755 gen/ff_planner/run_sample.sh create mode 100644 gen/ff_planner/samples/PutTask_domain.pddl create mode 100644 gen/ff_planner/samples/problem_0_0.pddl create mode 100644 gen/ff_planner/scan-fct_pddl.y create mode 100644 gen/ff_planner/scan-ops_pddl.y create mode 100644 gen/ff_planner/search.c create mode 100644 gen/ff_planner/search.h create mode 100644 gen/game_states/__init__.py create mode 100644 gen/game_states/game_state_base.py create mode 100644 gen/game_states/planned_game_state.py create mode 100644 gen/game_states/task_game_state.py create mode 100644 gen/game_states/task_game_state_full_knowledge.py create mode 100644 gen/goal_library.py create mode 100644 gen/graph/__init__.py create mode 100644 gen/graph/graph_obj.py create mode 100644 gen/layouts/FloorPlan1-layout.npy create mode 100644 gen/layouts/FloorPlan1-objects.json create mode 100644 gen/layouts/FloorPlan1-openable.json create mode 100644 gen/layouts/FloorPlan10-layout.npy create mode 100644 gen/layouts/FloorPlan10-objects.json create mode 100644 gen/layouts/FloorPlan10-openable.json create mode 100644 gen/layouts/FloorPlan11-layout.npy create mode 100644 gen/layouts/FloorPlan11-objects.json create mode 100644 gen/layouts/FloorPlan11-openable.json create mode 100644 gen/layouts/FloorPlan12-layout.npy create mode 100644 gen/layouts/FloorPlan12-objects.json create mode 100644 gen/layouts/FloorPlan12-openable.json create mode 100644 gen/layouts/FloorPlan13-layout.npy create mode 100644 gen/layouts/FloorPlan13-objects.json create mode 100644 gen/layouts/FloorPlan13-openable.json create mode 100644 gen/layouts/FloorPlan14-layout.npy create mode 100644 gen/layouts/FloorPlan14-objects.json create mode 100644 gen/layouts/FloorPlan14-openable.json create mode 100644 gen/layouts/FloorPlan15-layout.npy create mode 100644 gen/layouts/FloorPlan15-objects.json create mode 100644 gen/layouts/FloorPlan15-openable.json create mode 100644 gen/layouts/FloorPlan16-layout.npy create mode 100644 gen/layouts/FloorPlan16-objects.json create mode 100644 gen/layouts/FloorPlan16-openable.json create mode 100644 gen/layouts/FloorPlan17-layout.npy create mode 100644 gen/layouts/FloorPlan17-objects.json create mode 100644 gen/layouts/FloorPlan17-openable.json create mode 100644 gen/layouts/FloorPlan18-layout.npy create mode 100644 gen/layouts/FloorPlan18-objects.json create mode 100644 gen/layouts/FloorPlan18-openable.json create mode 100644 gen/layouts/FloorPlan19-layout.npy create mode 100644 gen/layouts/FloorPlan19-objects.json create mode 100644 gen/layouts/FloorPlan19-openable.json create mode 100644 gen/layouts/FloorPlan2-layout.npy create mode 100644 gen/layouts/FloorPlan2-objects.json create mode 100644 gen/layouts/FloorPlan2-openable.json create mode 100644 gen/layouts/FloorPlan20-layout.npy create mode 100644 gen/layouts/FloorPlan20-objects.json create mode 100644 gen/layouts/FloorPlan20-openable.json create mode 100644 gen/layouts/FloorPlan201-layout.npy create mode 100644 gen/layouts/FloorPlan201-objects.json create mode 100644 gen/layouts/FloorPlan201-openable.json create mode 100644 gen/layouts/FloorPlan202-layout.npy create mode 100644 gen/layouts/FloorPlan202-objects.json create mode 100644 gen/layouts/FloorPlan202-openable.json create mode 100644 gen/layouts/FloorPlan203-layout.npy create mode 100644 gen/layouts/FloorPlan203-objects.json create mode 100644 gen/layouts/FloorPlan203-openable.json create mode 100644 gen/layouts/FloorPlan204-layout.npy create mode 100644 gen/layouts/FloorPlan204-objects.json create mode 100644 gen/layouts/FloorPlan204-openable.json create mode 100644 gen/layouts/FloorPlan205-layout.npy create mode 100644 gen/layouts/FloorPlan205-objects.json create mode 100644 gen/layouts/FloorPlan205-openable.json create mode 100644 gen/layouts/FloorPlan206-layout.npy create mode 100644 gen/layouts/FloorPlan206-objects.json create mode 100644 gen/layouts/FloorPlan206-openable.json create mode 100644 gen/layouts/FloorPlan207-layout.npy create mode 100644 gen/layouts/FloorPlan207-objects.json create mode 100644 gen/layouts/FloorPlan207-openable.json create mode 100644 gen/layouts/FloorPlan208-layout.npy create mode 100644 gen/layouts/FloorPlan208-objects.json create mode 100644 gen/layouts/FloorPlan208-openable.json create mode 100644 gen/layouts/FloorPlan209-layout.npy create mode 100644 gen/layouts/FloorPlan209-objects.json create mode 100644 gen/layouts/FloorPlan209-openable.json create mode 100644 gen/layouts/FloorPlan21-layout.npy create mode 100644 gen/layouts/FloorPlan21-objects.json create mode 100644 gen/layouts/FloorPlan21-openable.json create mode 100644 gen/layouts/FloorPlan210-layout.npy create mode 100644 gen/layouts/FloorPlan210-objects.json create mode 100644 gen/layouts/FloorPlan210-openable.json create mode 100644 gen/layouts/FloorPlan211-layout.npy create mode 100644 gen/layouts/FloorPlan211-objects.json create mode 100644 gen/layouts/FloorPlan211-openable.json create mode 100644 gen/layouts/FloorPlan212-layout.npy create mode 100644 gen/layouts/FloorPlan212-objects.json create mode 100644 gen/layouts/FloorPlan212-openable.json create mode 100644 gen/layouts/FloorPlan213-layout.npy create mode 100644 gen/layouts/FloorPlan213-objects.json create mode 100644 gen/layouts/FloorPlan213-openable.json create mode 100644 gen/layouts/FloorPlan214-layout.npy create mode 100644 gen/layouts/FloorPlan214-objects.json create mode 100644 gen/layouts/FloorPlan214-openable.json create mode 100644 gen/layouts/FloorPlan215-layout.npy create mode 100644 gen/layouts/FloorPlan215-objects.json create mode 100644 gen/layouts/FloorPlan215-openable.json create mode 100644 gen/layouts/FloorPlan216-layout.npy create mode 100644 gen/layouts/FloorPlan216-objects.json create mode 100644 gen/layouts/FloorPlan216-openable.json create mode 100644 gen/layouts/FloorPlan217-layout.npy create mode 100644 gen/layouts/FloorPlan217-objects.json create mode 100644 gen/layouts/FloorPlan217-openable.json create mode 100644 gen/layouts/FloorPlan218-layout.npy create mode 100644 gen/layouts/FloorPlan218-objects.json create mode 100644 gen/layouts/FloorPlan218-openable.json create mode 100644 gen/layouts/FloorPlan219-layout.npy create mode 100644 gen/layouts/FloorPlan219-objects.json create mode 100644 gen/layouts/FloorPlan219-openable.json create mode 100644 gen/layouts/FloorPlan22-layout.npy create mode 100644 gen/layouts/FloorPlan22-objects.json create mode 100644 gen/layouts/FloorPlan22-openable.json create mode 100644 gen/layouts/FloorPlan220-layout.npy create mode 100644 gen/layouts/FloorPlan220-objects.json create mode 100644 gen/layouts/FloorPlan220-openable.json create mode 100644 gen/layouts/FloorPlan221-layout.npy create mode 100644 gen/layouts/FloorPlan221-objects.json create mode 100644 gen/layouts/FloorPlan221-openable.json create mode 100644 gen/layouts/FloorPlan222-layout.npy create mode 100644 gen/layouts/FloorPlan222-objects.json create mode 100644 gen/layouts/FloorPlan222-openable.json create mode 100644 gen/layouts/FloorPlan223-layout.npy create mode 100644 gen/layouts/FloorPlan223-objects.json create mode 100644 gen/layouts/FloorPlan223-openable.json create mode 100644 gen/layouts/FloorPlan224-layout.npy create mode 100644 gen/layouts/FloorPlan224-objects.json create mode 100644 gen/layouts/FloorPlan224-openable.json create mode 100644 gen/layouts/FloorPlan225-layout.npy create mode 100644 gen/layouts/FloorPlan225-objects.json create mode 100644 gen/layouts/FloorPlan225-openable.json create mode 100644 gen/layouts/FloorPlan226-layout.npy create mode 100644 gen/layouts/FloorPlan226-objects.json create mode 100644 gen/layouts/FloorPlan226-openable.json create mode 100644 gen/layouts/FloorPlan227-layout.npy create mode 100644 gen/layouts/FloorPlan227-objects.json create mode 100644 gen/layouts/FloorPlan227-openable.json create mode 100644 gen/layouts/FloorPlan228-layout.npy create mode 100644 gen/layouts/FloorPlan228-objects.json create mode 100644 gen/layouts/FloorPlan228-openable.json create mode 100644 gen/layouts/FloorPlan229-layout.npy create mode 100644 gen/layouts/FloorPlan229-objects.json create mode 100644 gen/layouts/FloorPlan229-openable.json create mode 100644 gen/layouts/FloorPlan23-layout.npy create mode 100644 gen/layouts/FloorPlan23-objects.json create mode 100644 gen/layouts/FloorPlan23-openable.json create mode 100644 gen/layouts/FloorPlan230-layout.npy create mode 100644 gen/layouts/FloorPlan230-objects.json create mode 100644 gen/layouts/FloorPlan230-openable.json create mode 100644 gen/layouts/FloorPlan24-layout.npy create mode 100644 gen/layouts/FloorPlan24-objects.json create mode 100644 gen/layouts/FloorPlan24-openable.json create mode 100644 gen/layouts/FloorPlan25-layout.npy create mode 100644 gen/layouts/FloorPlan25-objects.json create mode 100644 gen/layouts/FloorPlan25-openable.json create mode 100644 gen/layouts/FloorPlan26-layout.npy create mode 100644 gen/layouts/FloorPlan26-objects.json create mode 100644 gen/layouts/FloorPlan26-openable.json create mode 100644 gen/layouts/FloorPlan27-layout.npy create mode 100644 gen/layouts/FloorPlan27-objects.json create mode 100644 gen/layouts/FloorPlan27-openable.json create mode 100644 gen/layouts/FloorPlan28-layout.npy create mode 100644 gen/layouts/FloorPlan28-objects.json create mode 100644 gen/layouts/FloorPlan28-openable.json create mode 100644 gen/layouts/FloorPlan29-layout.npy create mode 100644 gen/layouts/FloorPlan29-objects.json create mode 100644 gen/layouts/FloorPlan29-openable.json create mode 100644 gen/layouts/FloorPlan3-layout.npy create mode 100644 gen/layouts/FloorPlan3-objects.json create mode 100644 gen/layouts/FloorPlan3-openable.json create mode 100644 gen/layouts/FloorPlan30-layout.npy create mode 100644 gen/layouts/FloorPlan30-objects.json create mode 100644 gen/layouts/FloorPlan30-openable.json create mode 100644 gen/layouts/FloorPlan301-layout.npy create mode 100644 gen/layouts/FloorPlan301-objects.json create mode 100644 gen/layouts/FloorPlan301-openable.json create mode 100644 gen/layouts/FloorPlan302-layout.npy create mode 100644 gen/layouts/FloorPlan302-objects.json create mode 100644 gen/layouts/FloorPlan302-openable.json create mode 100644 gen/layouts/FloorPlan303-layout.npy create mode 100644 gen/layouts/FloorPlan303-objects.json create mode 100644 gen/layouts/FloorPlan303-openable.json create mode 100644 gen/layouts/FloorPlan304-layout.npy create mode 100644 gen/layouts/FloorPlan304-objects.json create mode 100644 gen/layouts/FloorPlan304-openable.json create mode 100644 gen/layouts/FloorPlan305-layout.npy create mode 100644 gen/layouts/FloorPlan305-objects.json create mode 100644 gen/layouts/FloorPlan305-openable.json create mode 100644 gen/layouts/FloorPlan306-layout.npy create mode 100644 gen/layouts/FloorPlan306-objects.json create mode 100644 gen/layouts/FloorPlan306-openable.json create mode 100644 gen/layouts/FloorPlan307-layout.npy create mode 100644 gen/layouts/FloorPlan307-objects.json create mode 100644 gen/layouts/FloorPlan307-openable.json create mode 100644 gen/layouts/FloorPlan308-layout.npy create mode 100644 gen/layouts/FloorPlan308-objects.json create mode 100644 gen/layouts/FloorPlan308-openable.json create mode 100644 gen/layouts/FloorPlan309-layout.npy create mode 100644 gen/layouts/FloorPlan309-objects.json create mode 100644 gen/layouts/FloorPlan309-openable.json create mode 100644 gen/layouts/FloorPlan310-layout.npy create mode 100644 gen/layouts/FloorPlan310-objects.json create mode 100644 gen/layouts/FloorPlan310-openable.json create mode 100644 gen/layouts/FloorPlan311-layout.npy create mode 100644 gen/layouts/FloorPlan311-objects.json create mode 100644 gen/layouts/FloorPlan311-openable.json create mode 100644 gen/layouts/FloorPlan312-layout.npy create mode 100644 gen/layouts/FloorPlan312-objects.json create mode 100644 gen/layouts/FloorPlan312-openable.json create mode 100644 gen/layouts/FloorPlan313-layout.npy create mode 100644 gen/layouts/FloorPlan313-objects.json create mode 100644 gen/layouts/FloorPlan313-openable.json create mode 100644 gen/layouts/FloorPlan314-layout.npy create mode 100644 gen/layouts/FloorPlan314-objects.json create mode 100644 gen/layouts/FloorPlan314-openable.json create mode 100644 gen/layouts/FloorPlan315-layout.npy create mode 100644 gen/layouts/FloorPlan315-objects.json create mode 100644 gen/layouts/FloorPlan315-openable.json create mode 100644 gen/layouts/FloorPlan316-layout.npy create mode 100644 gen/layouts/FloorPlan316-objects.json create mode 100644 gen/layouts/FloorPlan316-openable.json create mode 100644 gen/layouts/FloorPlan317-layout.npy create mode 100644 gen/layouts/FloorPlan317-objects.json create mode 100644 gen/layouts/FloorPlan317-openable.json create mode 100644 gen/layouts/FloorPlan318-layout.npy create mode 100644 gen/layouts/FloorPlan318-objects.json create mode 100644 gen/layouts/FloorPlan318-openable.json create mode 100644 gen/layouts/FloorPlan319-layout.npy create mode 100644 gen/layouts/FloorPlan319-objects.json create mode 100644 gen/layouts/FloorPlan319-openable.json create mode 100644 gen/layouts/FloorPlan320-layout.npy create mode 100644 gen/layouts/FloorPlan320-objects.json create mode 100644 gen/layouts/FloorPlan320-openable.json create mode 100644 gen/layouts/FloorPlan321-layout.npy create mode 100644 gen/layouts/FloorPlan321-objects.json create mode 100644 gen/layouts/FloorPlan321-openable.json create mode 100644 gen/layouts/FloorPlan322-layout.npy create mode 100644 gen/layouts/FloorPlan322-objects.json create mode 100644 gen/layouts/FloorPlan322-openable.json create mode 100644 gen/layouts/FloorPlan323-layout.npy create mode 100644 gen/layouts/FloorPlan323-objects.json create mode 100644 gen/layouts/FloorPlan323-openable.json create mode 100644 gen/layouts/FloorPlan324-layout.npy create mode 100644 gen/layouts/FloorPlan324-objects.json create mode 100644 gen/layouts/FloorPlan324-openable.json create mode 100644 gen/layouts/FloorPlan325-layout.npy create mode 100644 gen/layouts/FloorPlan325-objects.json create mode 100644 gen/layouts/FloorPlan325-openable.json create mode 100644 gen/layouts/FloorPlan326-layout.npy create mode 100644 gen/layouts/FloorPlan326-objects.json create mode 100644 gen/layouts/FloorPlan326-openable.json create mode 100644 gen/layouts/FloorPlan327-layout.npy create mode 100644 gen/layouts/FloorPlan327-objects.json create mode 100644 gen/layouts/FloorPlan327-openable.json create mode 100644 gen/layouts/FloorPlan328-layout.npy create mode 100644 gen/layouts/FloorPlan328-objects.json create mode 100644 gen/layouts/FloorPlan328-openable.json create mode 100644 gen/layouts/FloorPlan329-layout.npy create mode 100644 gen/layouts/FloorPlan329-objects.json create mode 100644 gen/layouts/FloorPlan329-openable.json create mode 100644 gen/layouts/FloorPlan330-layout.npy create mode 100644 gen/layouts/FloorPlan330-objects.json create mode 100644 gen/layouts/FloorPlan330-openable.json create mode 100644 gen/layouts/FloorPlan4-layout.npy create mode 100644 gen/layouts/FloorPlan4-objects.json create mode 100644 gen/layouts/FloorPlan4-openable.json create mode 100644 gen/layouts/FloorPlan401-layout.npy create mode 100644 gen/layouts/FloorPlan401-objects.json create mode 100644 gen/layouts/FloorPlan401-openable.json create mode 100644 gen/layouts/FloorPlan402-layout.npy create mode 100644 gen/layouts/FloorPlan402-objects.json create mode 100644 gen/layouts/FloorPlan402-openable.json create mode 100644 gen/layouts/FloorPlan403-layout.npy create mode 100644 gen/layouts/FloorPlan403-objects.json create mode 100644 gen/layouts/FloorPlan403-openable.json create mode 100644 gen/layouts/FloorPlan404-layout.npy create mode 100644 gen/layouts/FloorPlan404-objects.json create mode 100644 gen/layouts/FloorPlan404-openable.json create mode 100644 gen/layouts/FloorPlan405-layout.npy create mode 100644 gen/layouts/FloorPlan405-objects.json create mode 100644 gen/layouts/FloorPlan405-openable.json create mode 100644 gen/layouts/FloorPlan406-layout.npy create mode 100644 gen/layouts/FloorPlan406-objects.json create mode 100644 gen/layouts/FloorPlan406-openable.json create mode 100644 gen/layouts/FloorPlan407-layout.npy create mode 100644 gen/layouts/FloorPlan407-objects.json create mode 100644 gen/layouts/FloorPlan407-openable.json create mode 100644 gen/layouts/FloorPlan408-layout.npy create mode 100644 gen/layouts/FloorPlan408-objects.json create mode 100644 gen/layouts/FloorPlan408-openable.json create mode 100644 gen/layouts/FloorPlan409-layout.npy create mode 100644 gen/layouts/FloorPlan409-objects.json create mode 100644 gen/layouts/FloorPlan409-openable.json create mode 100644 gen/layouts/FloorPlan410-layout.npy create mode 100644 gen/layouts/FloorPlan410-objects.json create mode 100644 gen/layouts/FloorPlan410-openable.json create mode 100644 gen/layouts/FloorPlan411-layout.npy create mode 100644 gen/layouts/FloorPlan411-objects.json create mode 100644 gen/layouts/FloorPlan411-openable.json create mode 100644 gen/layouts/FloorPlan412-layout.npy create mode 100644 gen/layouts/FloorPlan412-objects.json create mode 100644 gen/layouts/FloorPlan412-openable.json create mode 100644 gen/layouts/FloorPlan413-layout.npy create mode 100644 gen/layouts/FloorPlan413-objects.json create mode 100644 gen/layouts/FloorPlan413-openable.json create mode 100644 gen/layouts/FloorPlan414-layout.npy create mode 100644 gen/layouts/FloorPlan414-objects.json create mode 100644 gen/layouts/FloorPlan414-openable.json create mode 100644 gen/layouts/FloorPlan415-layout.npy create mode 100644 gen/layouts/FloorPlan415-objects.json create mode 100644 gen/layouts/FloorPlan415-openable.json create mode 100644 gen/layouts/FloorPlan416-layout.npy create mode 100644 gen/layouts/FloorPlan416-objects.json create mode 100644 gen/layouts/FloorPlan416-openable.json create mode 100644 gen/layouts/FloorPlan417-layout.npy create mode 100644 gen/layouts/FloorPlan417-objects.json create mode 100644 gen/layouts/FloorPlan417-openable.json create mode 100644 gen/layouts/FloorPlan418-layout.npy create mode 100644 gen/layouts/FloorPlan418-objects.json create mode 100644 gen/layouts/FloorPlan418-openable.json create mode 100644 gen/layouts/FloorPlan419-layout.npy create mode 100644 gen/layouts/FloorPlan419-objects.json create mode 100644 gen/layouts/FloorPlan419-openable.json create mode 100644 gen/layouts/FloorPlan420-layout.npy create mode 100644 gen/layouts/FloorPlan420-objects.json create mode 100644 gen/layouts/FloorPlan420-openable.json create mode 100644 gen/layouts/FloorPlan421-layout.npy create mode 100644 gen/layouts/FloorPlan421-objects.json create mode 100644 gen/layouts/FloorPlan421-openable.json create mode 100644 gen/layouts/FloorPlan422-layout.npy create mode 100644 gen/layouts/FloorPlan422-objects.json create mode 100644 gen/layouts/FloorPlan422-openable.json create mode 100644 gen/layouts/FloorPlan423-layout.npy create mode 100644 gen/layouts/FloorPlan423-objects.json create mode 100644 gen/layouts/FloorPlan423-openable.json create mode 100644 gen/layouts/FloorPlan424-layout.npy create mode 100644 gen/layouts/FloorPlan424-objects.json create mode 100644 gen/layouts/FloorPlan424-openable.json create mode 100644 gen/layouts/FloorPlan425-layout.npy create mode 100644 gen/layouts/FloorPlan425-objects.json create mode 100644 gen/layouts/FloorPlan425-openable.json create mode 100644 gen/layouts/FloorPlan426-layout.npy create mode 100644 gen/layouts/FloorPlan426-objects.json create mode 100644 gen/layouts/FloorPlan426-openable.json create mode 100644 gen/layouts/FloorPlan427-layout.npy create mode 100644 gen/layouts/FloorPlan427-objects.json create mode 100644 gen/layouts/FloorPlan427-openable.json create mode 100644 gen/layouts/FloorPlan428-layout.npy create mode 100644 gen/layouts/FloorPlan428-objects.json create mode 100644 gen/layouts/FloorPlan428-openable.json create mode 100644 gen/layouts/FloorPlan429-layout.npy create mode 100644 gen/layouts/FloorPlan429-objects.json create mode 100644 gen/layouts/FloorPlan429-openable.json create mode 100644 gen/layouts/FloorPlan430-layout.npy create mode 100644 gen/layouts/FloorPlan430-objects.json create mode 100644 gen/layouts/FloorPlan430-openable.json create mode 100644 gen/layouts/FloorPlan5-layout.npy create mode 100644 gen/layouts/FloorPlan5-objects.json create mode 100644 gen/layouts/FloorPlan5-openable.json create mode 100644 gen/layouts/FloorPlan6-layout.npy create mode 100644 gen/layouts/FloorPlan6-objects.json create mode 100644 gen/layouts/FloorPlan6-openable.json create mode 100644 gen/layouts/FloorPlan7-layout.npy create mode 100644 gen/layouts/FloorPlan7-objects.json create mode 100644 gen/layouts/FloorPlan7-openable.json create mode 100644 gen/layouts/FloorPlan8-layout.npy create mode 100644 gen/layouts/FloorPlan8-objects.json create mode 100644 gen/layouts/FloorPlan8-openable.json create mode 100644 gen/layouts/FloorPlan9-layout.npy create mode 100644 gen/layouts/FloorPlan9-objects.json create mode 100644 gen/layouts/FloorPlan9-openable.json create mode 100644 gen/layouts/precompute_layout_locations.py create mode 100644 gen/planner/__init__.py create mode 100644 gen/planner/domains/PutTaskExtended_domain.pddl create mode 100644 gen/planner/ff_planner_handler.py create mode 100644 gen/planner/pddl.pdf create mode 100644 gen/scripts/augment_trajectories.py create mode 100644 gen/scripts/generate_trajectories.py create mode 100644 gen/scripts/replay_checks.py create mode 100644 gen/utils/__init__.py create mode 100644 gen/utils/bb_util.py create mode 100644 gen/utils/dataset_management_util.py create mode 100644 gen/utils/game_util.py create mode 100644 gen/utils/image_util.py create mode 100644 gen/utils/py_util.py create mode 100644 gen/utils/replay_json.py create mode 100644 gen/utils/video_util.py create mode 100644 lanmp_dataloader/attribute_limits.json create mode 100644 lanmp_dataloader/rt1_dataloader.py create mode 100644 lanmp_dataloader/scene_to_keys.json create mode 100644 rt1_pytorch/__init__.py create mode 100644 rt1_pytorch/film_efficientnet/__init__.py create mode 100644 rt1_pytorch/film_efficientnet/film_conditioning_layer.py create mode 100644 rt1_pytorch/film_efficientnet/film_efficientnet.py create mode 100644 rt1_pytorch/rt1_model.py create mode 100644 rt1_pytorch/rt1_policy.py create mode 100644 rt1_pytorch/tokenizers/__init__.py create mode 100644 rt1_pytorch/tokenizers/action_tokenizer.py create mode 100644 rt1_pytorch/tokenizers/image_tokenizer.py create mode 100644 rt1_pytorch/tokenizers/token_learner.py create mode 100644 tests/action_tokenizer_test.py create mode 100644 tests/film_conditioning_layer_test.py create mode 100644 tests/film_efficientnet_test.py create mode 100644 tests/image_tokenizer_test.py create mode 100644 tests/rt1_model_test.py create mode 100644 tests/rt1_policy_test.py create mode 100644 tests/token_learner_test.py diff --git a/figures/rt1.png b/figures/rt1.png new file mode 100644 index 0000000000000000000000000000000000000000..17426537180d0baaa5b824e60bd94298ce6d5c35 GIT binary patch literal 135877 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

Q!2CmkZcV&= zE+D`>`W_^B{DHWHk_O;J9rAJehtNMnEe>joZl0HySb1jUe(#U${00*%J^=++h&Kb@>ZJ;S*8W`YoJx)*Zf3>zW_*YW z81~rWl#i!SDs(OoS~!?vmv3Oiqc6_+UKX@%M4rcV=e{Oi2pK(;08wpITi|5R7i%H6}G@V%pSDL zJoa%3sDX5buxD4dFP4>sCzdwXQ|W{nk<3Fbu?0qREEcsvOF2g!OUrArn_yMml@}T< zO8!?}M3=7k@PlTlEx3ad z!G}6e72vI`uk*)-N^16YF6rH1v@qAt29{^PhUW~wctqQ_8~%r1hvIX20ICjG(j7_Z z)$@sss^78UaIivynHhLo5&^0j1}>ja{<$pAV3n`eieN+7!Gf>{WD;{0{5{s$%GMw8!-3OdF94dah*mc@A_IPzOZB|3O`K6a6`>cOg(csfx4oBx z{`m&#bP7Xm&k!scgo*Z_=z8Jh=+PM~JV90zhHj;!ke#SHv>H}oHXOf${Xt8O=~HfZ zn0miq5CksNRIcRNczM5^`OgvFA7YdWkq`x!k4?J#+>0xFJkqZq0FOhsF!O$BP@Cz) zS_S;wP*V}mLahUCCO_UM=op0Lv*gPFmt-B`%?&1YykZ|xoy;9jS95tn-V}Y&9LLa+ z8S;38Gq#CChX(0Z)OJGbmoV5FB4z3)SjPm^#+Gz7o%){BRJ>_1Umpictd)_HRAt9M zy^PsxR{C_g%6X`yqETSgpLdj&dp-^FyF23NCFOGmgbx{rN0vg07G>yxVS&(lkm@_@Yf%MDVw*CwEDV8#sp+tWft$N#Hc``gY!`=2^c;6nfXUn40i{g0*a_c$ub|5tPQ|3NH- Y#5u$X1_XKM0t5X>iOGvr3mXRgFLU@ATL1t6 literal 0 HcmV?d00001 diff --git a/gen/README.md b/gen/README.md new file mode 100644 index 000000000..607e80b9b --- /dev/null +++ b/gen/README.md @@ -0,0 +1,77 @@ +# Data Generation + +We also provide code for generating PDDL-based expert demonstrations. This can be used to extend the training data, albiet without human language annotations. + +## Installation + +Get dependencies and compile the planner: +```bash +$ sudo apt-get install ffmpeg flex bison + +$ cd $ALFRED_ROOT/gen/ff_planner +$ make +``` + +## Generation + +To spawn multiple generation threads: + +```bash +$ cd $ALFRED_ROOT/gen +$ python scripts/generate_trajectories.py --save_path data/new_trajs --in_parallel --debug --num_threads 2 +``` + +This will sample tasks based on the sampling mechanism described in the paper. You might notice a lot of failed executions, which are automatically discarded by the script. + +**Note:** The first time you run the generation script, use `--num_threads 1` to allow the script to download the THOR binary. + +## Replay Checks + +In parallel with generation, replay saved trajectories to check if they are reproducable: + +```bash +$ python scripts/replay_checks.py --data_path data/new_trajs --in_parallel +``` +This will ensure that the interaction masks and expert actions can be deterministically executed in THOR. + +## Data Augmentation + +Currently, the dataset only provides 300x300 RGB images. However, each trajectory can be replayed to save any additional info available from the simulator. See the [augment_trajectories.py](scripts/augment_trajectories.py) script as an example for saving 600x600 RGB, depth and instance segmentation masks from the existing dataset: + +```bash +python scripts/augment_trajectories.py --data_path data/json_2.1.0 --num_threads 2 --smooth_nav --time_delays +``` + +![](../media/aug.png) + +Note that these files consume a lot of storage space. + +## PDDL Tasks + +The goals for the planner are specified in [goal_library.py](goal_library.py). Here is a simple pick-and-place PDDL goal definition: + +``` +# basic pick and place (e.g: "put the apple in the microwave") +gdict["pick_and_place_simple"] = ''' + (:goal + (and + ;; make sure all the cabinets and doors are closed in the end + (forall (?re # receptacle) + (not (opened ?re)) + ) + + ;; make sure some object {obj} exists inside some receptacle {recep} + (exists (?r # receptacle) + (exists (?o # object) + (and + (inReceptacle ?o ?r) + (objectType ?o {obj}Type) + (receptacleType ?r {recep}Type) + ) + ) + ) + ) + ) +) +``` + diff --git a/gen/__init__.py b/gen/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/gen/agents/agent_base.py b/gen/agents/agent_base.py new file mode 100644 index 000000000..34cb3f725 --- /dev/null +++ b/gen/agents/agent_base.py @@ -0,0 +1,60 @@ +import copy +import time +import numpy as np + + +class AgentBase(object): + def __init__(self, thread_id=0, game_state=None): + assert(game_state is not None) + self.game_state = game_state + self.thread_id = thread_id + self.timers = np.zeros((2, 2)) + self.total_frame_count = 0 + self.current_frame_count = 0 + self.gt_graph = None + self.bounds = None + self.pose = None + self.terminal = False + self.num_invalid_actions = 0 + self.total_num_invalid_actions = 0 + + def setup_problem(self, game_state_problem_args, scene=None, objs=None): + self.game_state.setup_problem(**game_state_problem_args, scene=scene, objs=objs) + + def reset(self, game_state_reset_args, scene=None, objs=None): + self.game_state.reset(**game_state_reset_args, scene=scene, objs=objs) + + self.timers = np.zeros((2, 2)) + self.current_frame_count = 0 + self.gt_graph = None + self.bounds = None + self.pose = None + self.terminal = False + self.num_invalid_actions = 0 + + self.total_frame_count += 1 + self.gt_graph = self.game_state.gt_graph + self.bounds = self.game_state.bounds + self.pose = self.game_state.pose + + def step(self, action): + self.total_frame_count += 1 + self.current_frame_count += 1 + t_start = time.time() + self.game_state.step(action) + if not self.game_state.event.metadata['lastActionSuccess']: + self.num_invalid_actions += 1 + self.total_num_invalid_actions += 1 + self.timers[0, 0] += time.time() - t_start + self.timers[0, 1] += 1 + if self.timers[0, 1] % 100 == 0: + print('game state step time %.3f' % (self.timers[0, 0] / self.timers[0, 1])) + self.timers[0, :] = 0 + self.pose = self.game_state.pose + + def get_action(self, action_ind): + action = copy.deepcopy(self.game_state.action_space[action_ind]) + if action['action'] == 'End': + # Remove other arguments + action = {'action': 'End'} + return action diff --git a/gen/agents/deterministic_planner_agent.py b/gen/agents/deterministic_planner_agent.py new file mode 100644 index 000000000..b67e25457 --- /dev/null +++ b/gen/agents/deterministic_planner_agent.py @@ -0,0 +1,26 @@ +from agents.semantic_map_planner_agent import SemanticMapPlannerAgent + + +class DeterministicPlannerAgent(SemanticMapPlannerAgent): + def __init__(self, thread_id=0, game_state=None): + super(DeterministicPlannerAgent, self).__init__(thread_id, game_state) + self.action_sequence = None + self.question = None + + def reset(self, seed=None, info=None, scene=None, objs=None): + info = super(DeterministicPlannerAgent, self).reset(seed, info, scene=scene, objs=objs) + self.action_sequence = ['Plan', 'End'] + return info + + def step(self, action, executing_plan=False): + if not executing_plan: + self.action_sequence = self.action_sequence[1:] + super(DeterministicPlannerAgent, self).step(action) + + def get_action(self, action_ind=None): + assert(action_ind is None) + return {'action': self.action_sequence[0]} + + def get_reward(self): + return 0, self.terminal + diff --git a/gen/agents/plan_agent.py b/gen/agents/plan_agent.py new file mode 100644 index 000000000..eda12f215 --- /dev/null +++ b/gen/agents/plan_agent.py @@ -0,0 +1,94 @@ +import constants +from agents.agent_base import AgentBase +from game_states.planned_game_state import PlannedGameState +from utils import game_util + + +class PlanAgent(AgentBase): + def __init__(self, thread_id=0, game_state=None, controller_agent=None): + super(PlanAgent, self).__init__(thread_id, game_state) + assert(isinstance(game_state, PlannedGameState)) + self.controller_agent = controller_agent + self.planned = False + + def reset(self): + self.planned = False + + def execute_plan(self): + step_count = 0 + self.planned = True + self.controller_agent.planning = True + if constants.OPEN_LOOP: + plan = self.game_state.get_current_plan(force_update=True) + + if plan[0]['action'] == 'End': + raise ValueError('Empty plan is successful, no work to do') + + elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: + print ("Planning failed. Possibly because the goal was already satisfied") + raise ValueError("Symbolic Planning Failed") + + for idx, plan_action in enumerate(plan): + self.save_plan(plan, idx) + + if plan_action['action'] == 'GotoLocation': + plan_action = self.game_state.get_teleport_action(plan_action) + elif plan_action['action'] == 'End': + break + self.controller_agent.step(plan_action, executing_plan=True) + step_count += 1 + if self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH: + break + else: + past_plans = [] + plan = self.game_state.get_current_plan(force_update=True) + + if plan[0]['action'] == 'End': + raise ValueError('Empty plan is successful, no work to do') + elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: + print("Symbolic Planning Failed") + raise ValueError("Symbolic Planning Failed") + + plan_action = plan[0] + if constants.USE_DETERMINISTIC_CONTROLLER: + # Don't fail right away, just rotate a few times. + rotations = 0 + while rotations < 4 and (plan_action is None or plan_action['action'] == 'End'): + action = {'action': 'RotateLeft'} + self.controller_agent.step(action, executing_plan=True) + rotations += 1 + plan = self.game_state.get_current_plan(force_update=True) + plan_action = plan[0] + + while not(plan_action is None or plan_action['action'] == 'End'): + self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) + + # save data + self.save_plan(plan, 0) + + step_count += 1 + past_plans.append(plan) + if len(past_plans) > 5: + past_plans = past_plans[-5:] + plan = self.game_state.get_current_plan(force_update=True) + if plan[0]['action'] == 'End': + break + if (step_count >= constants.MAX_PLANNER_STEP_COUNT or + self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH): + # Too many steps, plan may be looping. + break + if len(plan) > 1 and any([plan == past_plan for past_plan in past_plans]): + plan_action = plan[0] + self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) + step_count += 1 + plan = plan[1:] + plan_action = plan[0] + + self.controller_agent.planning = False + + def save_plan(self, plan, idx=0): + plan_action = plan[idx] + constants.data_dict['plan']['high_pddl'].append({"high_idx": len(constants.data_dict['plan']['high_pddl']), + "planner_action": plan_action, + "discrete_action": game_util.get_discrete_hl_action(plan, idx)}) + constants.data_dict['template']['high_descs'].append(game_util.get_templated_action_str(plan, idx)) diff --git a/gen/agents/semantic_map_planner_agent.py b/gen/agents/semantic_map_planner_agent.py new file mode 100644 index 000000000..497ee242c --- /dev/null +++ b/gen/agents/semantic_map_planner_agent.py @@ -0,0 +1,72 @@ +import glob +import cv2 +import constants +from agents.agent_base import AgentBase +from agents.plan_agent import PlanAgent +from game_states.planned_game_state import PlannedGameState + + +class SemanticMapPlannerAgent(AgentBase): + def __init__(self, thread_id=0, game_state=None): + assert(isinstance(game_state, PlannedGameState)) + super(SemanticMapPlannerAgent, self).__init__(thread_id, game_state) + + self.plan_agent = PlanAgent(thread_id, game_state, self) + self.planning = False + + def reset(self, seed=None, info=None, scene=None, objs=None): + self.planning = False + info = self.game_state.get_setup_info(info, scene=scene)[0] + super(SemanticMapPlannerAgent, self).reset({'seed': seed, 'info': info}, scene=scene, objs=objs) + if self.plan_agent is not None: + self.plan_agent.reset() + return info + + def setup_problem(self, game_state_problem_args, scene=None, objs=None): + super(SemanticMapPlannerAgent, self).setup_problem(game_state_problem_args, scene=scene, objs=objs) + self.pose = self.game_state.pose + + def get_reward(self): + raise NotImplementedError + + def step(self, action, executing_plan=False): + if action['action'] == 'End': + self.current_frame_count += 1 + self.total_frame_count += 1 + self.terminal = True + + if constants.RECORD_VIDEO_IMAGES: + im_ind = len(glob.glob(constants.save_path + '/*.png')) + for _ in range(10): + cv2.imwrite(constants.save_path + '/%09d.png' % im_ind, + self.game_state.s_t[:, :, ::-1]) + im_ind += 1 + else: + if 'Teleport' in action['action']: + start_pose = self.pose + end_angle = action['horizon'] + end_pose = (int(action['x'] / constants.AGENT_STEP_SIZE), + int(action['z'] / constants.AGENT_STEP_SIZE), + int(action['rotation'] / 90), + int(end_angle)) + + self.game_state.gt_graph.navigate_to_goal(self.game_state, start_pose, end_pose) + self.pose = self.game_state.pose + elif action['action'] == 'Plan': + self.plan_agent.execute_plan() + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + elif action['action'] == 'Scan': + self.game_state.step(action) + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + elif action['action'] == 'Explore': + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + else: + super(SemanticMapPlannerAgent, self).step(action) + + diff --git a/gen/constants.py b/gen/constants.py new file mode 100644 index 000000000..e646c660d --- /dev/null +++ b/gen/constants.py @@ -0,0 +1,1221 @@ +from collections import OrderedDict + +######################################################################################################################## +# General Settings + +DEBUG = True +EVAL = False +LOG_FILE = 'logs_gen' + +RECORD_VIDEO_IMAGES = True +RECORD_SMOOTHING_FACTOR = 1 +DATA_SAVE_PATH = "dataset/new_trajectories" + +OPEN_LOOP = True +FULL_OBSERVABLE_STATE = True + +######################################################################################################################## +# Generation Ablations + +MAX_NUM_OF_OBJ_INSTANCES = 3 # when randomly initializing the scene, create duplicate instance up to this number +PICKUP_REPEAT_MAX = 4 # how many of the target pickup object to generate in [1, MAX] (randomly chosen) +RECEPTACLE_SPARSE_POINTS = 50 # increment for how many points to leave free for sparsely populated receptacles +RECEPTACLE_EMPTY_POINTS = 200 # increment for how many points to leave free for empty receptacles + +MIN_VISIBLE_RATIO = 0.0011 # minimum area ratio (with respect to image size) of visible object +PLANNER_MAX_STEPS = 100 # if the generated plan is more than these steps, discard the traj +MAX_EPISODE_LENGTH = 1000 # maximum number of API steps allowed per trajectory + +FORCED_SAMPLING = False # set True for debugging instead of proper sampling +PRUNE_UNREACHABLE_POINTS = True # prune navigation points that were deemed unreachable by the proprocessing script + +######################################################################################################################## +# Goals + +GOALS = [ + "pick_and_place_simple", + "pick_two_obj_and_place", + "look_at_obj_in_light", + "pick_clean_then_place_in_recep", + "pick_heat_then_place_in_recep", + "pick_cool_then_place_in_recep", + "pick_and_place_with_movable_recep", + ] +GOALS_VALID = {"pick_and_place_simple": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, + "pick_two_obj_and_place": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, + "look_at_obj_in_light": {"LivingRoom", "Bedroom"}, + "pick_clean_then_place_in_recep": {"Kitchen", "Bathroom"}, + "pick_heat_then_place_in_recep": {"Kitchen"}, + "pick_cool_then_place_in_recep": {"Kitchen"}, + "pick_and_place_with_movable_recep": {"Kitchen", "LivingRoom", "Bedroom"}} + +pddl_goal_type = "pick_and_place_simple" # default goal type + +######################################################################################################################## +# Video Settings + +# filler frame IDs +BEFORE = 0 +MIDDLE = 1 +AFTER = 2 + +# number of image frames to save before and after executing the specified action +SAVE_FRAME_BEFORE_AND_AFTER_COUNTS = { + 'OpenObject': [2, 0, 2], + 'CloseObject': [2, 0, 2], + 'PickupObject': [5, 0, 10], + 'PutObject': [5, 0, 10], + 'CleanObject': [3, 0, 5], + 'HeatObject': [3, 0, 5], + 'CoolObject': [3, 30, 5], + 'ToggleObjectOn': [3, 0, 15], + 'ToggleObjectOff': [1, 0, 5], + 'SliceObject': [3, 0, 7] +} + +# FPS +VIDEO_FRAME_RATE = 5 + +######################################################################################################################## +# Data & Storage + +save_path = DATA_SAVE_PATH +data_dict = OrderedDict() # dictionary for storing trajectory data to be dumped + +######################################################################################################################## +# Unity Hyperparameters + +BUILD_PATH = None +X_DISPLAY = '0' + +AGENT_STEP_SIZE = 0.25 +AGENT_HORIZON_ADJ = 30 +AGENT_ROTATE_ADJ = 90 +CAMERA_HEIGHT_OFFSET = 0.75 +VISIBILITY_DISTANCE = 1.5 +HORIZON_GRANULARITY = 30 + +RENDER_IMAGE = True +RENDER_DEPTH_IMAGE = True +RENDER_CLASS_IMAGE = True +RENDER_OBJECT_IMAGE = True + +MAX_DEPTH = 5000 +STEPS_AHEAD = 5 +SCENE_PADDING = STEPS_AHEAD * 3 +SCREEN_WIDTH = DETECTION_SCREEN_WIDTH = 300 +SCREEN_HEIGHT = DETECTION_SCREEN_HEIGHT = 300 +MIN_VISIBLE_PIXELS = 10 + +# (400) / (600*600) ~ 0.13% area of image +# int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float(DETECTION_SCREEN_HEIGHT)) +# MIN_VISIBLE_PIXELS = int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float( +# DETECTION_SCREEN_HEIGHT)) # (400) / (600*600) ~ 0.13% area of image + +######################################################################################################################## +# Scenes and Objects + +TRAIN_SCENE_NUMBERS = list(range(7, 31)) # Train Kitchens (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(207, 231))) # Train Living Rooms (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(307, 331))) # Train Bedrooms (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(407, 431))) # Train Bathrooms (24/30) + +TEST_SCENE_NUMBERS = list(range(1, 7)) # Test Kitchens (6/30) +TEST_SCENE_NUMBERS.extend(list(range(201, 207))) # Test Living Rooms (6/30) +TEST_SCENE_NUMBERS.extend(list(range(301, 307))) # Test Bedrooms (6/30) +TEST_SCENE_NUMBERS.extend(list(range(401, 407))) # Test Bathrooms (6/30) + +SCENE_NUMBERS = TRAIN_SCENE_NUMBERS + TEST_SCENE_NUMBERS + +# Scene types. +SCENE_TYPE = {"Kitchen": range(1, 31), + "LivingRoom": range(201, 231), + "Bedroom": range(301, 331), + "Bathroom": range(401, 431)} + +OBJECTS = [ + 'AlarmClock', + 'Apple', + 'ArmChair', + 'BaseballBat', + 'BasketBall', + 'Bathtub', + 'BathtubBasin', + 'Bed', + 'Blinds', + 'Book', + 'Boots', + 'Bowl', + 'Box', + 'Bread', + 'ButterKnife', + 'Cabinet', + 'Candle', + 'Cart', + 'CD', + 'CellPhone', + 'Chair', + 'Cloth', + 'CoffeeMachine', + 'CounterTop', + 'CreditCard', + 'Cup', + 'Curtains', + 'Desk', + 'DeskLamp', + 'DishSponge', + 'Drawer', + 'Dresser', + 'Egg', + 'FloorLamp', + 'Footstool', + 'Fork', + 'Fridge', + 'GarbageCan', + 'Glassbottle', + 'HandTowel', + 'HandTowelHolder', + 'HousePlant', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'LaundryHamper', + 'LaundryHamperLid', + 'Lettuce', + 'LightSwitch', + 'Microwave', + 'Mirror', + 'Mug', + 'Newspaper', + 'Ottoman', + 'Painting', + 'Pan', + 'PaperTowel', + 'PaperTowelRoll', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Pillow', + 'Plate', + 'Plunger', + 'Poster', + 'Pot', + 'Potato', + 'RemoteControl', + 'Safe', + 'SaltShaker', + 'ScrubBrush', + 'Shelf', + 'ShowerDoor', + 'ShowerGlass', + 'Sink', + 'SinkBasin', + 'SoapBar', + 'SoapBottle', + 'Sofa', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'StoveBurner', + 'StoveKnob', + 'DiningTable', + 'CoffeeTable', + 'SideTable', + 'TeddyBear', + 'Television', + 'TennisRacket', + 'TissueBox', + 'Toaster', + 'Toilet', + 'ToiletPaper', + 'ToiletPaperHanger', + 'ToiletPaperRoll', + 'Tomato', + 'Towel', + 'TowelHolder', + 'TVStand', + 'Vase', + 'Watch', + 'WateringCan', + 'Window', + 'WineBottle', +] + +OBJECTS_LOWER_TO_UPPER = {obj.lower(): obj for obj in OBJECTS} + +OBJECTS_SINGULAR = [ + 'alarmclock', + 'apple', + 'armchair', + 'baseballbat', + 'basketball', + 'bathtub', + 'bathtubbasin', + 'bed', + 'blinds', + 'book', + 'boots', + 'bowl', + 'box', + 'bread', + 'butterknife', + 'cabinet', + 'candle', + 'cart', + 'cd', + 'cellphone', + 'chair', + 'cloth', + 'coffeemachine', + 'countertop', + 'creditcard', + 'cup', + 'curtains', + 'desk', + 'desklamp', + 'dishsponge', + 'drawer', + 'dresser', + 'egg', + 'floorlamp', + 'footstool', + 'fork', + 'fridge', + 'garbagecan', + 'glassbottle', + 'handtowel', + 'handtowelholder', + 'houseplant', + 'kettle', + 'keychain', + 'knife', + 'ladle', + 'laptop', + 'laundryhamper', + 'laundryhamperlid', + 'lettuce', + 'lightswitch', + 'microwave', + 'mirror', + 'mug', + 'newspaper', + 'ottoman', + 'painting', + 'pan', + 'papertowel', + 'papertowelroll', + 'pen', + 'pencil', + 'peppershaker', + 'pillow', + 'plate', + 'plunger', + 'poster', + 'pot', + 'potato', + 'remotecontrol', + 'safe', + 'saltshaker', + 'scrubbrush', + 'shelf', + 'showerdoor', + 'showerglass', + 'sink', + 'sinkbasin', + 'soapbar', + 'soapbottle', + 'sofa', + 'spatula', + 'spoon', + 'spraybottle', + 'statue', + 'stoveburner', + 'stoveknob', + 'diningtable', + 'coffeetable', + 'sidetable' + 'teddybear', + 'television', + 'tennisracket', + 'tissuebox', + 'toaster', + 'toilet', + 'toiletpaper', + 'toiletpaperhanger', + 'toiletpaperroll', + 'tomato', + 'towel', + 'towelholder', + 'tvstand', + 'vase', + 'watch', + 'wateringcan', + 'window', + 'winebottle', +] + +OBJECTS_PLURAL = [ + 'alarmclocks', + 'apples', + 'armchairs', + 'baseballbats', + 'basketballs', + 'bathtubs', + 'bathtubbasins', + 'beds', + 'blinds', + 'books', + 'boots', + 'bottles', + 'bowls', + 'boxes', + 'bread', + 'butterknives', + 'cabinets', + 'candles', + 'carts', + 'cds', + 'cellphones', + 'chairs', + 'cloths', + 'coffeemachines', + 'countertops', + 'creditcards', + 'cups', + 'curtains', + 'desks', + 'desklamps', + 'dishsponges', + 'drawers', + 'dressers', + 'eggs', + 'floorlamps', + 'footstools', + 'forks', + 'fridges', + 'garbagecans', + 'glassbottles', + 'handtowels', + 'handtowelholders', + 'houseplants', + 'kettles', + 'keychains', + 'knives', + 'ladles', + 'laptops', + 'laundryhampers', + 'laundryhamperlids', + 'lettuces', + 'lightswitches', + 'microwaves', + 'mirrors', + 'mugs', + 'newspapers', + 'ottomans', + 'paintings', + 'pans', + 'papertowels', + 'papertowelrolls', + 'pens', + 'pencils', + 'peppershakers', + 'pillows', + 'plates', + 'plungers', + 'posters', + 'pots', + 'potatoes', + 'remotecontrollers', + 'safes', + 'saltshakers', + 'scrubbrushes', + 'shelves', + 'showerdoors', + 'showerglassess', + 'sinks', + 'sinkbasins', + 'soapbars', + 'soapbottles', + 'sofas', + 'spatulas', + 'spoons', + 'spraybottles', + 'statues', + 'stoveburners', + 'stoveknobs', + 'diningtables', + 'coffeetables', + 'sidetable', + 'teddybears', + 'televisions', + 'tennisrackets', + 'tissueboxes', + 'toasters', + 'toilets', + 'toiletpapers', + 'toiletpaperhangers', + 'toiletpaperrolls', + 'tomatoes', + 'towels', + 'towelholders', + 'tvstands', + 'vases', + 'watches', + 'wateringcans', + 'windows', + 'winebottles', +] + +MOVABLE_RECEPTACLES = [ + 'Bowl', + 'Box', + 'Cup', + 'Mug', + 'Plate', + 'Pan', + 'Pot', +] + +MOVABLE_RECEPTACLES_SET = set(MOVABLE_RECEPTACLES) +OBJECTS_SET = set(OBJECTS) | MOVABLE_RECEPTACLES_SET + +OBJECT_CLASS_TO_ID = {obj: ii for (ii, obj) in enumerate(OBJECTS)} + +RECEPTACLES = { + 'BathtubBasin', + 'Bowl', + 'Cup', + 'Drawer', + 'Mug', + 'Plate', + 'Shelf', + 'SinkBasin', + 'Box', + 'Cabinet', + 'CoffeeMachine', + 'CounterTop', + 'Fridge', + 'GarbageCan', + 'HandTowelHolder', + 'Microwave', + 'PaintingHanger', + 'Pan', + 'Pot', + 'StoveBurner', + 'DiningTable', + 'CoffeeTable', + 'SideTable', + 'ToiletPaperHanger', + 'TowelHolder', + 'Safe', + 'BathtubBasin', + 'ArmChair', + 'Toilet', + 'Sofa', + 'Ottoman', + 'Dresser', + 'LaundryHamper', + 'Desk', + 'Bed', + 'Cart', + 'TVStand', + 'Toaster', + } + +NON_RECEPTACLES = OBJECTS_SET - RECEPTACLES + +NUM_RECEPTACLES = len(RECEPTACLES) +NUM_CLASSES = len(OBJECTS) + +# For generating questions +QUESTION_OBJECT_CLASS_LIST = [ + 'Spoon', + 'Potato', + 'Fork', + 'Plate', + 'Egg', + 'Tomato', + 'Bowl', + 'Lettuce', + 'Apple', + 'Knife', + 'Container', + 'Bread', + 'Mug', +] + +VAL_RECEPTACLE_OBJECTS = { + 'Pot': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Pan': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Bowl': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'RemoteControl', + 'Watch'}, + 'CoffeeMachine': {'Mug'}, + 'Microwave': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Glassbottle', + 'Mug', + 'Plate', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced'}, + 'StoveBurner': {'Kettle', + 'Pan', + 'Pot'}, + 'Fridge': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Glassbottle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced', + 'WineBottle'}, + 'Mug': {'ButterKnife', + 'Fork', + 'Knife', + 'Pen', + 'Pencil', + 'Spoon', + 'KeyChain', + 'Watch'}, + 'Plate': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'AlarmClock', + 'Book', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Glassbottle', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'TissueBox', + 'Watch'}, + 'Cup': {'ButterKnife', + 'Fork', + 'Spoon'}, + 'Sofa': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'ArmChair': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'Box': {'AlarmClock', + 'Book', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Glassbottle', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'RemoteControl', + 'Statue', + 'TissueBox', + 'Vase', + 'Watch'}, + 'Ottoman': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'Dresser': {'AlarmClock', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'Glassbottle', + 'KeyChain', + 'Laptop', + 'Mug', + 'Newspaper', + 'Pen', + 'Pencil', + 'Plate', + 'RemoteControl', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle'}, + 'LaundryHamper': {'Cloth'}, + 'Desk': {'AlarmClock', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'Glassbottle', + 'KeyChain', + 'Laptop', + 'Mug', + 'Newspaper', + 'Pen', + 'Pencil', + 'Plate', + 'RemoteControl', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle'}, + 'Bed': {'BaseballBat', + 'BasketBall', + 'Book', + 'CellPhone', + 'Laptop', + 'Newspaper', + 'Pillow', + 'TennisRacket'}, + 'Toilet': {'Candle', + 'Cloth', + 'DishSponge', + 'Newspaper', + 'PaperTowel', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'HandTowel'}, + 'ToiletPaperHanger': {'ToiletPaper', + 'ToiletPaperRoll'}, + 'TowelHolder': {'Towel'}, + 'HandTowelHolder': {'HandTowel'}, + 'Cart': {'Candle', + 'Cloth', + 'DishSponge', + 'Mug', + 'PaperTowel', + 'Plunger', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'HandTowel'}, + 'BathtubBasin': {'Cloth', + 'DishSponge', + 'SoapBar', + 'HandTowel'}, + 'SinkBasin': {'Apple', + 'AppleSliced', + 'Bowl', + 'ButterKnife', + 'Cloth', + 'Cup', + 'DishSponge', + 'Egg', + 'Glassbottle', + 'Fork', + 'Kettle', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'HandTowel'}, + 'Cabinet': {'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'Cloth', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Kettle', + 'Ladle', + 'Mug', + 'Newspaper', + 'Pan', + 'PepperShaker', + 'Plate', + 'Plunger', + 'Pot', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'TableTop': {'AlarmClock', + 'Apple', + 'AppleSliced', + 'BaseballBat', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Bread', + 'BreadSliced', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Egg', + 'Fork', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Newspaper', + 'Pan', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'CounterTop': {'AlarmClock', + 'Apple', + 'AppleSliced', + 'BaseballBat', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Bread', + 'BreadSliced', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Egg', + 'Glassbottle', + 'Fork', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Newspaper', + 'Pan', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'Shelf': {'AlarmClock', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Kettle', + 'KeyChain', + 'Mug', + 'Newspaper', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'Drawer': {'Book', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Fork', + 'KeyChain', + 'Knife', + 'Ladle', + 'Newspaper', + 'Pen', + 'Pencil', + 'PepperShaker', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Watch', + 'WateringCan', + 'HandTowel'}, + 'GarbageCan': {'Apple', + 'AppleSliced', + 'Bread', + 'BreadSliced', + 'CD', + 'Cloth', + 'DishSponge', + 'Egg', + 'Lettuce', + 'LettuceSliced', + 'Newspaper', + 'PaperTowel', + 'Pen', + 'Pencil', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'WineBottle', + 'HandTowel'}, + 'Safe': {'CD', + 'CellPhone', + 'CreditCard', + 'KeyChain', + 'Statue', + 'Vase', + 'Watch'}, + 'TVStand': {'TissueBox'}, + 'Toaster': {'BreadSliced'}, +} +VAL_RECEPTACLE_OBJECTS['DiningTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +VAL_RECEPTACLE_OBJECTS['CoffeeTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +VAL_RECEPTACLE_OBJECTS['SideTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +del VAL_RECEPTACLE_OBJECTS['TableTop'] + +NON_RECEPTACLES_SET = (OBJECTS_SET - set(VAL_RECEPTACLE_OBJECTS.keys())) | set(MOVABLE_RECEPTACLES) + +VAL_ACTION_OBJECTS = { + 'Heatable': {'Apple', + 'AppleSliced', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Mug', + 'Plate', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced'}, + 'Coolable': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced', + 'WineBottle'}, + 'Cleanable': {'Apple', + 'AppleSliced', + 'Bowl', + 'ButterKnife', + 'Cloth', + 'Cup', + 'DishSponge', + 'Egg', + 'Fork', + 'Kettle', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Toggleable': {'DeskLamp', + 'FloorLamp'}, + 'Sliceable': {'Apple', + 'Bread', + 'Egg', + 'Lettuce', + 'Potato', + 'Tomato'} +} + +# object parents +OBJ_PARENTS = {obj: obj for obj in OBJECTS} +OBJ_PARENTS['AppleSliced'] = 'Apple' +OBJ_PARENTS['BreadSliced'] = 'Bread' +OBJ_PARENTS['LettuceSliced'] = 'Lettuce' +OBJ_PARENTS['PotatoSliced'] = 'Potato' +OBJ_PARENTS['TomatoSliced'] = 'Tomato' + +# force a different horizon view for objects of (type, location). If the location is None, force this horizon for all +# objects of that type. +FORCED_HORIZON_OBJS = { + ('FloorLamp', None): 0, + ('Fridge', 18): 30, + ('Toilet', None): 15, +} + +# openable objects with fixed states for transport. +FORCED_OPEN_STATE_ON_PICKUP = { + 'Laptop': False, +} + +# list of openable classes. +OPENABLE_CLASS_LIST = ['Fridge', 'Cabinet', 'Microwave', 'Drawer', 'Safe', 'Box'] +OPENABLE_CLASS_SET = set(OPENABLE_CLASS_LIST) + +######################################################################################################################## \ No newline at end of file diff --git a/gen/ff_planner/README.md b/gen/ff_planner/README.md new file mode 100644 index 000000000..81bc18c0f --- /dev/null +++ b/gen/ff_planner/README.md @@ -0,0 +1,13 @@ +# Metric FF Planner +Credit: https://fai.cs.uni-saarland.de/hoffmann/metric-ff.html. +Specifically this uses the Metric-FF Version 2.1 (https://fai.cs.uni-saarland.de/hoffmann/ff/Metric-FF-v2.1.tgz). + +Note that the code here is not exactly the same as the one you can download from that website. +Their code had issues that threw segfaults which I was able to fix for this project. +It is possible that my changes caused some other issues that I am unaware of. + +To compile: +```bash +$ cd +$ make +``` diff --git a/gen/ff_planner/expressions.c b/gen/ff_planner/expressions.c new file mode 100644 index 000000000..8fb8d2404 --- /dev/null +++ b/gen/ff_planner/expressions.c @@ -0,0 +1,2623 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/*********************************************************************** + * File: expressions.c + * Description: functions for handling numerical expressions + * + * - general utilities: + * comparisons between numbers etc. + * + * - LNF compilation: + * normalization of expressions + * translation of subtractions + * + * - LNF post-processing: + * summarization of effects + * encoding of non-minimal LNFs + * + * Author: Joerg Hoffmann 2001 + * + *********************************************************************/ + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + + + + + + + + + + + + + + + +/******************************************************* + * SIMPLE UTILITIES + *******************************************************/ + + + + + + + + + + + + + + + + +Bool number_comparison_holds( Comparator c, float l, float r ) + +{ + + switch ( c ) { + case LE: + if ( l < r ) return TRUE; + break; + case LEQ: + if ( l <= r ) return TRUE; + break; + case EQ: + if ( l == r ) return TRUE; + break; + case GEQ: + if ( l >= r ) return TRUE; + break; + case GE: + if ( l > r ) return TRUE; + break; + case IGUAL: + /* technical for non-required fluents + */ + return TRUE; + default: + printf("\n\nillegal comparator %d in number comp holds", c); + exit( 1 ); + } + + return FALSE; + +} + + + + + + + + + + + + + + + + + + + + + +/******************************************************* + * MACHINERY FOR LNF TRANSFORMATION!!!!!! + *******************************************************/ + + + + + + + + + + + + + + + + + + + + + + + + +Bool transform_to_LNF( void ) + +{ + + if ( !is_linear_task() ) { + return FALSE; + } + + normalize_expressions(); + if ( gcmd_line.display_info == 121 ) { + printf("\n\nnormalized expressions representation is:\n\n"); + print_lnf_representation(); + } + + translate_subtractions(); + if ( gcmd_line.display_info == 122 ) { + printf("\n\nLNF : translated subtractions representation is:\n\n"); + print_lnf_representation(); + } + + /* LNF computed. start post-processing. + */ + + /* do same-cond effects etc. summarization here so as to have + * as tight as possible an encoded LNF representation. + */ + summarize_effects(); + if ( gcmd_line.display_info == 123 ) { + printf("\n\nLNF - summarized effects representation is:\n\n"); + print_lnf_representation(); + } + + encode_lfns_as_artificial_fluents(); + /* optimization is translated into minimizing + * effect costs... here, determine the cost that + * each effect has. + * + * returns TRUE if a non-trivial optimization expression + * could be established. + */ + if ( setup_effect_costs() ) { + if ( gcmd_line.display_info > 1 ) { + printf("\nmetric established (normalized to minimize): "); + print_LnfExpNode( &glnf_metric ); + } + goptimization_established = TRUE; + } + if ( gcmd_line.display_info == 124 ) { + printf("\n\nencoded LNF representation is:\n\n"); + print_lnf_representation(); + } + + return TRUE; + +} + + + +/* simple syntax check + */ +Bool is_linear_task( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( a = gactions; a; a = a->next ) { + /* preconds + */ + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( !is_linear_expression( a->numeric_preconds_lh[i] ) ) { + return FALSE; + } + if ( !is_linear_expression( a->numeric_preconds_rh[i] ) ) { + return FALSE; + } + } + + /* effects + */ + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( !is_linear_expression( e->numeric_conditions_lh[j] ) ) { + return FALSE; + } + if ( !is_linear_expression( e->numeric_conditions_rh[j] ) ) { + return FALSE; + } + } + + if ( e->illegal ) { + /* we don't care whether that one's ok or not- + * it won't be applied anyway. + */ + continue; + } + + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( e->numeric_effects_neft[j] != INCREASE && + e->numeric_effects_neft[j] != DECREASE && + e->numeric_effects_neft[j] != ASSIGN ) { + return FALSE; + } + if ( !is_linear_expression( e->numeric_effects_rh[j] ) ) { + return FALSE; + } + } + } + } + + /* goal condition also... + */ + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( !is_linear_expression( gnumeric_goal_lh[i] ) ) { + return FALSE; + } + if ( !is_linear_expression( gnumeric_goal_rh[i] ) ) { + return FALSE; + } + } + + if ( gmetric != NULL ) { + if ( !is_linear_expression( gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: metric is no linear expression. defaulting to plan length."); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + } + + return TRUE; + +} + + + +Bool is_linear_expression( ExpNode *n ) + +{ + + switch ( n->connective ) { + case MU: + if ( !is_linear_expression( n->leftson ) || + !is_linear_expression( n->rightson ) ) { + return FALSE; + } + if ( n->leftson->connective != NUMBER && + n->rightson->connective != NUMBER ) { + return FALSE; + } + break; + case DI: + if ( !is_linear_expression( n->leftson ) || + n->rightson->connective != NUMBER ) { + return FALSE; + } + break; + case AD: + case SU: + if ( !is_linear_expression( n->leftson ) || + !is_linear_expression( n->rightson ) ) { + return FALSE; + } + break; + case MINUS: + if ( !is_linear_expression( n->son ) ) { + return FALSE; + } + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\nis linear exp: wrong specifier %d", + n->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void print_lnf_representation( void ) + +{ + + int i; + Action *a; + + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( !a->norm_operator && + !a->pseudo_action ) || + ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + print_lnf_Action( a ); + } + } + printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); + for ( a = gactions; a; a = a->next ) { + if ( !a->norm_operator && + !a->pseudo_action ) { + print_lnf_Action( a ); + } + } + + printf("\n\ninitial state is:\n\n"); + print_State( ginitial_state ); + + printf("\n\ngoal is:\n\n"); + for ( i = 0; i < gnum_logic_goal; i++ ) { + print_ft_name( glogic_goal[i] ); + printf("\n"); + } + for ( i = 0; i < gnum_lnf_goal; i++ ) { + switch ( glnf_goal_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator in lnf goal %d\n\n", glnf_goal_comp[i]); + exit( 1 ); + } + print_LnfExpNode( glnf_goal_lh[i] ); + printf(" %f", glnf_goal_rh[i]); + printf(")\n"); + } + + if ( gmetric ) { + printf("\n\nmetric is (minimize) (constant part skipped):\n"); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + +} + + + + + + + + + + + + + + + + + + +/******************************************************* + * SUBPART I: NORMALIZE THE EXPRESSIONS + *******************************************************/ + + + + + + + + + + + + + + + + + +/* local globals. + */ + +Comparator lcomp; + +int lF[MAX_LNF_F]; +float lC[MAX_LNF_F]; +int lnum_F; + +float lc; + + + + + + + + + + + +void normalize_expressions( void ) + +{ + + Action *a, *p, *t; + ActionEffect *e; + int i, j, k; + Bool eq; + LnfExpNode *lnf; + + /* first, pre-normalize all the expressions, i.e. translate + * divisions, and push muliplications downwards. + */ + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( !translate_divisions( &(gnumeric_goal_lh[i]) ) ) { + printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); + exit( 1 ); + } + push_multiplications_down( &(gnumeric_goal_lh[i]) ); + if ( !translate_divisions( &(gnumeric_goal_rh[i]) ) ) { + printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); + exit( 1 ); + } + push_multiplications_down( &(gnumeric_goal_rh[i]) ); + } + + a = gactions; p = NULL; + while ( a ) { + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( !translate_divisions( &(a->numeric_preconds_lh[i]) ) ) break; + push_multiplications_down( &(a->numeric_preconds_lh[i]) ); + if ( !translate_divisions( &(a->numeric_preconds_rh[i]) ) ) break; + push_multiplications_down( &(a->numeric_preconds_rh[i]) ); + } + if ( i < a->num_numeric_preconds ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in precond of "); + print_Action_name( a ); + printf(". skipping action."); + } + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( !translate_divisions( &(e->numeric_conditions_lh[j]) ) ) break; + push_multiplications_down( &(e->numeric_conditions_lh[j]) ); + if ( !translate_divisions( &(e->numeric_conditions_rh[j]) ) ) break; + push_multiplications_down( &(e->numeric_conditions_rh[j]) ); + } + if ( j < e->num_numeric_conditions ) break; + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( !translate_divisions( &(e->numeric_effects_rh[j]) ) ) break; + push_multiplications_down( &(e->numeric_effects_rh[j]) ); + } + if ( j < e->num_numeric_effects ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in effect rh of "); + print_Action_name( a ); + printf(". marking effect as illegal."); + } + e->illegal = TRUE; + } + } + if ( i < a->num_effects ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in effect cond of "); + print_Action_name( a ); + printf(". skipping action."); + } + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + + p = a; + a = a->next; + } + if ( gmetric != NULL ) { + if ( !translate_divisions( &gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in metric. replaced with plan length."); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + push_multiplications_down( &gmetric ); + } + + /* now, collect the normalized representations of all expressions. + */ + for ( a = gactions; a; a = a->next ) { + /* preconds + */ + a->lnf_preconds_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + a->lnf_preconds_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + a->lnf_preconds_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + a->num_lnf_preconds = 0; + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( a->numeric_preconds_comp[i] == EQ ) { + eq = TRUE; + a->numeric_preconds_comp[i] = LEQ; + } + put_comp_into_normalized_locals( a->numeric_preconds_comp[i], + a->numeric_preconds_lh[i], + a->numeric_preconds_rh[i] ); + a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; + a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); + lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + a->lnf_preconds_rh[a->num_lnf_preconds] = lc; + a->num_lnf_preconds++; + if ( eq ) { + if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + a->numeric_preconds_comp[i] = EQ; + put_comp_into_normalized_locals( GEQ, + a->numeric_preconds_lh[i], + a->numeric_preconds_rh[i] ); + a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; + a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); + lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + a->lnf_preconds_rh[a->num_lnf_preconds] = lc; + a->num_lnf_preconds++; + } + } + + /* effects + */ + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + e->lnf_conditions_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + e->lnf_conditions_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + e->lnf_conditions_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + e->num_lnf_conditions = 0; + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( e->numeric_conditions_comp[j] == EQ ) { + eq = TRUE; + e->numeric_conditions_comp[j] = LEQ; + } + put_comp_into_normalized_locals( e->numeric_conditions_comp[j], + e->numeric_conditions_lh[j], + e->numeric_conditions_rh[j] ); + e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; + e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); + lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_conditions_rh[e->num_lnf_conditions] = lc; + e->num_lnf_conditions++; + if ( eq ) { + if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + e->numeric_conditions_comp[j] = EQ; + put_comp_into_normalized_locals( GEQ, + e->numeric_conditions_lh[j], + e->numeric_conditions_rh[j] ); + e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; + e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); + lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_conditions_rh[e->num_lnf_conditions] = lc; + e->num_lnf_conditions++; + } + } + + if ( e->illegal ) { + /* we do have the LNF to know whether the effect appears. + * if it does, then this one is illegal anyway, remembered + * in inst final due to undefined fl access. + * + * if it is LEGAL, then all fluents we're gonna find and + * collect below are relevant!!! + */ + continue; + } + + e->lnf_effects_neft = ( NumericEffectType * ) calloc( MAX_LNF_EFFS, sizeof( NumericEffectType ) ); + e->lnf_effects_fl = ( int * ) calloc( MAX_LNF_EFFS, sizeof( int ) ); + e->lnf_effects_rh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_EFFS, sizeof( LnfExpNode_pointer ) ); + e->num_lnf_effects = 0; + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e->numeric_effects_neft[j]; + e->lnf_effects_fl[e->num_lnf_effects] = e->numeric_effects_fl[j]; + lnum_F = 0; + lc = 0; + if ( e->lnf_effects_neft[e->num_lnf_effects] == DECREASE ) { + collect_normalized_locals( e->numeric_effects_rh[j], FALSE ); + e->lnf_effects_neft[e->num_lnf_effects] = INCREASE; + } else { + collect_normalized_locals( e->numeric_effects_rh[j], TRUE ); + } + e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); + lnf = e->lnf_effects_rh[e->num_lnf_effects]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_effects_rh[e->num_lnf_effects]->c = lc; + e->num_lnf_effects++; + } + } + } + + /* goal condition also... + */ + glnf_goal_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + glnf_goal_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + glnf_goal_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + gnum_lnf_goal = 0; + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( gnum_lnf_goal == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( gnumeric_goal_comp[i] == EQ ) { + eq = TRUE; + gnumeric_goal_comp[i] = LEQ; + } + put_comp_into_normalized_locals( gnumeric_goal_comp[i], + gnumeric_goal_lh[i], + gnumeric_goal_rh[i] ); + glnf_goal_comp[gnum_lnf_goal] = lcomp; + glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); + lnf = glnf_goal_lh[gnum_lnf_goal]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + glnf_goal_rh[gnum_lnf_goal] = lc; + gnum_lnf_goal++; + if ( eq ) { + if ( gnum_lnf_goal == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + gnumeric_goal_comp[i] = EQ; + put_comp_into_normalized_locals( GEQ, + gnumeric_goal_lh[i], + gnumeric_goal_rh[i] ); + glnf_goal_comp[gnum_lnf_goal] = lcomp; + glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); + lnf = glnf_goal_lh[gnum_lnf_goal]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + glnf_goal_rh[gnum_lnf_goal] = lc; + gnum_lnf_goal++; + } + } + /* metric... + */ + lnum_F = 0; + lc = 0; + glnf_metric.num_pF = 0; + glnf_metric.num_nF = 0; + glnf_metric.c = 0; + collect_normalized_locals( gmetric, TRUE ); + lnf = &glnf_metric; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + + +} + + + +Bool translate_divisions( ExpNode **n ) + +{ + + ExpNode *tmp; + + /* "dirty": also normalize multiplications so that the constant + * is always on the left hand side --- + * simplifies function below a lot. + */ + switch ( (*n)->connective ) { + case DI: + /* rightson is number due to syntax check. + */ + if ( (*n)->rightson->value == 0 ) { + /* what needs to be done we can only decide further up. + */ + printf("\nwarning: division by zero."); + return FALSE; + } + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + (*n)->connective = MU; + (*n)->rightson->value = 1 / (*n)->rightson->value; + tmp = (*n)->rightson; + (*n)->rightson = (*n)->leftson; + (*n)->leftson = tmp; + break; + case MU: + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->rightson->connective == NUMBER ) { + tmp = (*n)->rightson; + (*n)->rightson = (*n)->leftson; + (*n)->leftson = tmp; + } + break; + case AD: + case SU: + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; + break; + case MINUS: + if ( !translate_divisions( &((*n)->son) ) ) return FALSE; + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\ntranslate divisions: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void push_multiplications_down( ExpNode **n ) + +{ + + ExpNode *tmp1, *tmp2; + + switch ( (*n)->connective ) { + case MU: + /* due to syntax check, at least one of sons is number, + * + * due to above, it's the left one. + * NOTE that this invariant is kept true troughout the + * modifications done here. + */ + if ( (*n)->rightson->connective == NUMBER ) { + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + free_ExpNode( (*n)->rightson ); + (*n)->leftson = NULL; + (*n)->rightson = NULL; + break; + } + if ( (*n)->rightson->connective == FHEAD ) { + (*n)->connective = FHEAD; + (*n)->fl = (*n)->rightson->fl; + (*n)->c = (*n)->leftson->value; + free_ExpNode( (*n)->leftson ); + free_ExpNode( (*n)->rightson ); + (*n)->leftson = NULL; + (*n)->rightson = NULL; + break; + } + if ( (*n)->rightson->connective == MINUS ) { + (*n)->connective = MINUS; + (*n)->son = (*n)->rightson; + (*n)->son->connective = MU; + (*n)->son->leftson = (*n)->leftson; + (*n)->son->rightson = (*n)->rightson->son; + (*n)->rightson = NULL; + (*n)->leftson = NULL; + (*n)->son->son = NULL; + push_multiplications_down( &((*n)->son) ); + break; + } + if ( (*n)->rightson->connective == MU ) { + (*n)->leftson->value *= (*n)->rightson->leftson->value; + tmp1 = (*n)->rightson->rightson; + (*n)->rightson->rightson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = tmp1; + push_multiplications_down( n ); + break; + } + + /* rigthson is either AD or SU + */ + tmp1 = new_ExpNode( NUMBER ); + tmp2 = new_ExpNode( NUMBER ); + tmp1->value = (*n)->leftson->value; + tmp2->value = (*n)->leftson->value; + + (*n)->connective = (*n)->rightson->connective; + (*n)->leftson->connective = MU; + (*n)->rightson->connective = MU; + (*n)->leftson->leftson = tmp1; + (*n)->leftson->rightson = (*n)->rightson->leftson; + (*n)->rightson->leftson = tmp2; + + push_multiplications_down( &((*n)->leftson) ); + push_multiplications_down( &((*n)->rightson) ); + break; + case AD: + case SU: + push_multiplications_down( &((*n)->leftson) ); + push_multiplications_down( &((*n)->rightson) ); + break; + case MINUS: + push_multiplications_down( &((*n)->son) ); + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\ntranslate divisions: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +void put_comp_into_normalized_locals( Comparator comp, + ExpNode *lh, + ExpNode *rh ) + +{ + + ExpNode *tmp; + + tmp = new_ExpNode( SU ); + + /* initialisation of normalized locals + */ + lnum_F = 0; + lc = 0; + + lcomp = comp; + + /* if comparison is LE or LEQ, then subtract + * left hand side from right hand side to obtain + * new left hand side. + */ + if ( lcomp == LE ) { + tmp->leftson = rh; + tmp->rightson = lh; + collect_normalized_locals( tmp, TRUE ); + lcomp = GE; + /* "subtract" the constant to get it to the right hand + * side. + */ + lc *= (-1); + free( tmp ); + return; + } + if ( lcomp == LEQ ) { + tmp->leftson = rh; + tmp->rightson = lh; + collect_normalized_locals( tmp, TRUE ); + lcomp = GEQ; + lc *= (-1); + free( tmp ); + return; + } + + /* otherwise, subtract right hand side from left hand side. + */ + tmp->leftson = lh; + tmp->rightson = rh; + collect_normalized_locals( tmp, TRUE ); + lc *= (-1); + free( tmp ); + +} + + + +void collect_normalized_locals( ExpNode *n, Bool positive ) + +{ + + Bool negative = positive ? FALSE : TRUE; + int i; + + if ( !n ) return; + + switch ( n->connective ) { + case AD: + collect_normalized_locals( n->leftson, positive ); + collect_normalized_locals( n->rightson, positive ); + break; + case SU: + collect_normalized_locals( n->leftson, positive ); + collect_normalized_locals( n->rightson, negative ); + break; + case MINUS: + collect_normalized_locals( n->son, negative ); + break; + case NUMBER: + if ( positive ) { + lc += n->value; + } else { + lc -= n->value; + } + break; + case FHEAD: + if ( n->fl < 0 && n->fl != -2 ) { + printf("\n\ncollecting non-relevant fluent for LNF!!\n\n"); + exit( 1 ); + } + for ( i = 0; i < lnum_F; i++ ) { + if ( lF[i] == n->fl ) break; + } + if ( i < lnum_F ) { + lC[i] += positive ? n->c : ((-1) * n->c); + } else { + if ( lnum_F == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + lF[lnum_F] = n->fl; + lC[lnum_F] = positive ? n->c : ((-1) * n->c); + lnum_F++; + } + break; + default: + printf("\n\ncollect_normalized_locals: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + + + + + + + + + + + + + + + + + + + +/******************************************************* + * SUBPART II: TRANSLATE THE SUBTRACTIONS + *******************************************************/ + + + + + + + + + + + + + + + +/* local globals. + */ + +int lminus_fluent[MAX_RELEVANT_FLUENTS]; + + + + + + + + + + + + +void translate_subtractions( void ) + +{ + + int i, fl; + + /* minus_fluent[fl] gives the number of the fluent that + * takes on the negative value to fl, or -1 if there is + * no such fluent. + */ + for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { + lminus_fluent[i] = -1; + } + + while ( TRUE ) { + /* ex fl \in nF for pre, cond, eff or goal? + */ + if ( !ex_fl_in_nF_of_pre_cond_eff_goal( &fl ) ) { + /* no --> we are finished. + */ + break; + } + if ( fl < 0 ) { + if ( fl != -2 ) { + printf("\n\nnon-relevant fluent in non-illegal part!\n\n"); + exit( 1 ); + } else { + printf("\n\nwarning: total-time occurs negatively in metric. no optimization done.\n\n"); + glnf_metric.num_pF = 0; + glnf_metric.num_nF = 0; + continue; + } + } + /* set the new number and name, incrementing + * gnum_relevant_fluents, and setting + * minus_fluent value for both directions. + */ + introduce_minus_fluent( fl ); + /* replace all occurences in effects and conds and goals + */ + replace_fl_in_nF_with_minus_fl( fl ); + /* set the initial value of the new fluent + */ + set_minus_fl_initial( fl ); + /* adjust the effects accordingly + */ + introduce_minus_fl_effects( fl ); + } + +} + + + +Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( glnf_goal_lh[i]->num_nF > 0 ) { + *fl = glnf_goal_lh[i]->nF[0]; + return TRUE; + } + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( a->lnf_preconds_lh[i]->num_nF > 0 ) { + *fl = a->lnf_preconds_lh[i]->nF[0]; + return TRUE; + } + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_nF > 0 ) { + *fl = e->lnf_conditions_lh[j]->nF[0]; + return TRUE; + } + } + + if ( e->illegal ) { + /* we don't care if there's something in here that + * wants to be translated. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_rh[j]->num_nF > 0 ) { + *fl = e->lnf_effects_rh[j]->nF[0]; + return TRUE; + } + } + } + } + + /* no need to throw costs away, even if we're not explicitly asked to + * minimize them + */ + if ( (1 || gcost_minimizing) && glnf_metric.num_nF > 0 ) { + *fl = glnf_metric.nF[0]; + return TRUE; + } + + return FALSE; + +} + + + +void introduce_minus_fluent( int fl ) + +{ + + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = -1; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], "MINUS-" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], + grelevant_fluents_name[fl] ); + lminus_fluent[fl] = gnum_relevant_fluents; + lminus_fluent[gnum_relevant_fluents] = fl; + gnum_relevant_fluents++; + +} + + + +void replace_fl_in_nF_with_minus_fl( int fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, l; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + for ( j = 0; j < glnf_goal_lh[i]->num_nF; j++ ) { + if ( glnf_goal_lh[i]->nF[j] == fl ) break; + } + if ( j == glnf_goal_lh[i]->num_nF ) continue; + /* now the jth fluent in subtraction is our translated one. + * + * first, put minus-fl into pF. Can't already be there + * because we have only just introduced it. + */ + if ( glnf_goal_lh[i]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + glnf_goal_lh[i]->pF[glnf_goal_lh[i]->num_pF] = lminus_fluent[fl]; + glnf_goal_lh[i]->pC[glnf_goal_lh[i]->num_pF++] = glnf_goal_lh[i]->nC[j]; + /* now remove fl from nF. + */ + for ( k = j; k < glnf_goal_lh[i]->num_nF - 1; k++ ) { + glnf_goal_lh[i]->nF[k] = glnf_goal_lh[i]->nF[k+1]; + glnf_goal_lh[i]->nC[k] = glnf_goal_lh[i]->nC[k+1]; + } + glnf_goal_lh[i]->num_nF--; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + for ( j = 0; j < a->lnf_preconds_lh[i]->num_nF; j++ ) { + if ( a->lnf_preconds_lh[i]->nF[j] == fl ) break; + } + if ( j == a->lnf_preconds_lh[i]->num_nF ) continue; + if ( a->lnf_preconds_lh[i]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + a->lnf_preconds_lh[i]->pF[a->lnf_preconds_lh[i]->num_pF] = lminus_fluent[fl]; + a->lnf_preconds_lh[i]->pC[a->lnf_preconds_lh[i]->num_pF++] = a->lnf_preconds_lh[i]->nC[j]; + for ( k = j; k < a->lnf_preconds_lh[i]->num_nF - 1; k++ ) { + a->lnf_preconds_lh[i]->nF[k] = a->lnf_preconds_lh[i]->nF[k+1]; + a->lnf_preconds_lh[i]->nC[k] = a->lnf_preconds_lh[i]->nC[k+1]; + } + a->lnf_preconds_lh[i]->num_nF--; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + for ( k = 0; k < e->lnf_conditions_lh[j]->num_nF; k++ ) { + if ( e->lnf_conditions_lh[j]->nF[k] == fl ) break; + } + if ( k == e->lnf_conditions_lh[j]->num_nF ) continue; + if ( e->lnf_conditions_lh[j]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + e->lnf_conditions_lh[j]->pF[e->lnf_conditions_lh[j]->num_pF] = lminus_fluent[fl]; + e->lnf_conditions_lh[j]->pC[e->lnf_conditions_lh[j]->num_pF++] = e->lnf_conditions_lh[j]->nC[k]; + for ( l = k; l < e->lnf_conditions_lh[j]->num_nF - 1; l++ ) { + e->lnf_conditions_lh[j]->nF[l] = e->lnf_conditions_lh[j]->nF[l+1]; + e->lnf_conditions_lh[j]->nC[l] = e->lnf_conditions_lh[j]->nC[l+1]; + } + e->lnf_conditions_lh[j]->num_nF--; + } + + if ( e->illegal ) { + /* like before, we don't care about effects that access + * irrelevant fluents + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { + if ( e->lnf_effects_rh[j]->nF[k] == fl ) break; + } + if ( k == e->lnf_effects_rh[j]->num_nF ) continue; + if ( e->lnf_effects_rh[j]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + e->lnf_effects_rh[j]->pF[e->lnf_effects_rh[j]->num_pF] = lminus_fluent[fl]; + e->lnf_effects_rh[j]->pC[e->lnf_effects_rh[j]->num_pF++] = e->lnf_effects_rh[j]->nC[k]; + for ( l = k; l < e->lnf_effects_rh[j]->num_nF - 1; l++ ) { + e->lnf_effects_rh[j]->nF[l] = e->lnf_effects_rh[j]->nF[l+1]; + e->lnf_effects_rh[j]->nC[l] = e->lnf_effects_rh[j]->nC[l+1]; + } + e->lnf_effects_rh[j]->num_nF--; + } + } + } + + for ( j = 0; j < glnf_metric.num_nF; j++ ) { + if ( glnf_metric.nF[j] == fl ) break; + } + if ( j < glnf_metric.num_nF ) { + if ( glnf_metric.num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + glnf_metric.pF[glnf_metric.num_pF] = lminus_fluent[fl]; + glnf_metric.pC[glnf_metric.num_pF++] = glnf_metric.nC[j]; + for ( k = j; k < glnf_metric.num_nF - 1; k++ ) { + glnf_metric.nF[k] = glnf_metric.nF[k+1]; + glnf_metric.nC[k] = glnf_metric.nC[k+1]; + } + glnf_metric.num_nF--; + } + +} + + + +void set_minus_fl_initial( int fl ) + +{ + + if ( ginitial_state.f_D[fl] ) { + ginitial_state.f_D[lminus_fluent[fl]] = TRUE; + ginitial_state.f_V[lminus_fluent[fl]] = (-1) * ginitial_state.f_V[fl]; + } + +} + + + +void introduce_minus_fl_effects( int fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, pf, nf; + LnfExpNode *len; + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->illegal ) { + /* no need to translate illegal effects. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_fl[j] != fl ) { + continue; + } + /* here is an effect that affects our fl. + * introduce inverse effect for minus_fl, + * making use of all minus-fl's that are already + * there. + */ + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e->lnf_effects_neft[j]; + e->lnf_effects_fl[e->num_lnf_effects] = lminus_fluent[fl]; + e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); + len = e->lnf_effects_rh[e->num_lnf_effects]; + /* now the most "difficult" part: setup the inverted pF and nF + * informations. + * + * NOTE: as fluent occurences are unique in original ef, + * so will they be in new ef. (no len contains both + * a fluent and its minus-fluent) + * --> invariant is or should be that the absolute + * fluents occur at most once in |pF| \cup |nF|. + * holds in the beginning. only thing we do is + * we exchange in that set for some fluents the + * positive with the negative version, so the + * invariant is in fact preserved. + */ + for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { + pf = e->lnf_effects_rh[j]->pF[k]; + if ( lminus_fluent[pf] == -1 ) { + /* not translated yet --> insert it into nF + */ + if ( len->num_nF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->nF[len->num_nF] = pf; + len->nC[len->num_nF++] = e->lnf_effects_rh[j]->pC[k]; + } else { + /* else, insert minus-pf into pF + */ + if ( len->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->pF[len->num_pF] = lminus_fluent[pf]; + len->pC[len->num_pF++] = e->lnf_effects_rh[j]->pC[k]; + } + } + for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { + nf = e->lnf_effects_rh[j]->nF[k]; + /* insert all of those into pF + */ + if ( len->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->pF[len->num_pF] = nf; + len->pC[len->num_pF++] = e->lnf_effects_rh[j]->nC[k]; + } + /* the constant must of course be inverted. + */ + len->c = (-1) * e->lnf_effects_rh[j]->c; + e->num_lnf_effects++; + } + } + } + +} + + + + + + + + + + + + + + + + + + +/************************************************************* + * LNF POST-PROCESSING I: SUMMARIZE EFFECTS. + *************************************************************/ + + + + + + + + + + + + + + + + + + + +int *lA, *lD; +int lnum_A, lnum_D; + + + + + + +void summarize_effects( void ) + +{ + + Action *a; + ActionEffect *e, *e_; + int i, j, k, l; + + lA = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); + lD = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); + + for ( a = gactions; a; a = a->next ) { + i = 0; + while ( i < a->num_effects ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* this one's already handled. + */ + i++; + continue; + } + + /* first, merge the effect's own effects together. logical: + */ + lnum_A = 0; + for ( j = 0; j < e->num_adds; j++ ) { + for ( k = 0; k < lnum_A; k++ ) { + if ( lA[k] == e->adds[j] ) break; + } + if ( k < lnum_A ) continue; + lA[lnum_A++] = e->adds[j]; + } + lnum_D = 0; + for ( j = 0; j < e->num_dels; j++ ) { + for ( k = 0; k < lnum_D; k++ ) { + if ( lD[k] == e->dels[j] ) break; + } + if ( k < lnum_D ) continue; + lD[lnum_D++] = e->dels[j]; + } + /* numerical: + */ + j = 0; + while ( j < e->num_lnf_effects ) { + /* merge all effects increasing the same fluent into + * effect j, and remove them. + */ + k = j + 1; + while ( k < e->num_lnf_effects ) { + if ( e->lnf_effects_fl[k] != e->lnf_effects_fl[j] ) { + k++; + continue; + } + if ( e->lnf_effects_neft[j] == ASSIGN ) { + if ( e->lnf_effects_neft[k] != ASSIGN || + !same_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ) ) { + e->illegal = TRUE; + break; + } + } else { + if ( e->lnf_effects_neft[k] == ASSIGN ) { + e->illegal = TRUE; + break; + } + merge_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ); + } + /* we also get here if we have two identical assigns. + */ + free( e->lnf_effects_rh[k] ); + for ( l = k; l < e->num_lnf_effects - 1; l++ ) { + e->lnf_effects_neft[l] = e->lnf_effects_neft[l+1]; + e->lnf_effects_fl[l] = e->lnf_effects_fl[l+1]; + e->lnf_effects_rh[l] = e->lnf_effects_rh[l+1]; + } + e->num_lnf_effects--; + } + if ( k < e->num_lnf_effects ) { + /* illegal combination + */ + break; + } + j++; + } + + /* now merge all effects after i with same condition + * into that. + */ + j = i + 1; + while ( j < a->num_effects ) { + e_ = &(a->effects[j]); + if ( e_->removed ) { + j++; + continue; + } + + if ( !same_condition( e, e_ ) ) { + j++; + continue; + } + /* no matter what happens, we can get rid of effect e_ + */ + e_->removed = TRUE; + + /* illegality is inherited in both directions. + */ + if ( e_->illegal ) { + e->illegal = TRUE; + } + if ( e->illegal ) { + /* just for docu; it is removed anyway. + */ + e_->illegal = TRUE; + } + + if ( !e->illegal ) { + /* the combined effect appears to be legal. merge it. + */ + merge_effects( e, e_ ); + if ( e->illegal ) { + /* e might have become illegal. again, docu this. + */ + e_->illegal = TRUE; + } + } + + j++; + } + + /* now put the updated A and D info into e. + * + * have to be careful: it might be that there are + * now too many facts and we need to re-allocate + * e's capabilities. + */ + if ( lnum_A > e->num_adds ) { + free( e->adds ); + e->adds = ( int * ) calloc( lnum_A, sizeof( int ) ); + } + for ( j = 0; j < lnum_A; j++ ) { + e->adds[j] = lA[j]; + } + e->num_adds = lnum_A; + if ( lnum_D > e->num_dels ) { + free( e->dels ); + e->dels = ( int * ) calloc( lnum_D, sizeof( int ) ); + } + for ( j = 0; j < lnum_D; j++ ) { + e->dels[j] = lD[j]; + } + e->num_dels = lnum_D; + + /* increment current effects counter. + */ + i++; + } + } + +} + + + +Bool same_condition( ActionEffect *e, ActionEffect *e_ ) + +{ + + int i, j; + + if ( e->num_conditions != e_->num_conditions || + e->num_lnf_conditions != e_->num_lnf_conditions ) return FALSE; + + for ( i = 0; i < e->num_conditions; i++ ) { + for ( j = 0; j < e_->num_conditions; j++ ) { + if ( e->conditions[i] == e_->conditions[j] ) break; + } + if ( j == e_->num_conditions ) break; + } + if ( i < e->num_conditions ) return FALSE; + + for ( i = 0; i < e->num_lnf_conditions; i++ ) { + for ( j = 0; j < e_->num_lnf_conditions; j++ ) { + if ( e_->lnf_conditions_comp[j] != e->lnf_conditions_comp[i] ) continue; + if ( e_->lnf_conditions_rh[j] != e->lnf_conditions_rh[i] ) continue; + if ( !same_lnfs( e_->lnf_conditions_lh[j], e->lnf_conditions_lh[i] ) ) continue; + break; + } + if ( j == e_->num_lnf_conditions ) break; + } + if ( i < e->num_lnf_conditions ) return FALSE; + + return TRUE; + +} + + + +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ) + +{ + + int i, j; + + if ( l->num_pF != r->num_pF || + l->c != r->c ) return FALSE; + + for ( i = 0; i < l->num_pF; i++ ) { + for ( j = 0; j < r->num_pF; j++ ) { + if ( l->pF[i] != r->pF[j] ) continue; + if ( l->pC[i] != r->pC[j] ) { + /* same fluent with different weighting. + */ + return FALSE; + } + break; + } + if ( j == r->num_pF ) break; + } + if ( i < l->num_pF ) return FALSE; + + return TRUE; + +} + + + +void merge_effects( ActionEffect *e, ActionEffect *e_ ) + +{ + + int i, j; + + /* we don't care whether adds and dels intersect: + * they're allowed to by semantics. + */ + for ( i = 0; i < e_->num_adds; i++ ) { + for ( j = 0; j < lnum_A; j++ ) { + if ( lA[j] == e_->adds[i] ) break; + } + if ( j < lnum_A ) continue; + lA[lnum_A++] = e_->adds[i]; + } + for ( i = 0; i < e_->num_dels; i++ ) { + for ( j = 0; j < lnum_D; j++ ) { + if ( lD[j] == e_->dels[i] ) break; + } + if ( j < lnum_D ) continue; + lD[lnum_D++] = e_->dels[i]; + } + + for ( i = 0; i < e_->num_lnf_effects; i++ ) { + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_fl[j] == e_->lnf_effects_fl[i] ) break; + } + if ( j == e->num_lnf_effects ) { + /* new affected fluent! + */ + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e_->lnf_effects_neft[i]; + e->lnf_effects_fl[e->num_lnf_effects] = e_->lnf_effects_fl[i]; + /* we can also simply take the pointer: e_ is only marked as removed, + * but not freed. + */ + e->lnf_effects_rh[e->num_lnf_effects] = e_->lnf_effects_rh[i]; + e->num_lnf_effects++; + } else { + if ( e->lnf_effects_neft[j] == ASSIGN ) { + if ( e_->lnf_effects_neft[i] != ASSIGN || + !same_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ) ) { + e->illegal = TRUE; + return; + } + /* identical assigns. nothing needs to be done. + */ + } else { + if ( e_->lnf_effects_neft[i] == ASSIGN ) { + e->illegal = TRUE; + return; + } + merge_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ); + } + } + } + +} + + + +/* merge both LNFs into the left one. + * (only pF needed as both are already + * fully transformed) + */ +void merge_lnfs( LnfExpNode *l, LnfExpNode *r ) + +{ + + int i, j, k; + + for ( i = 0; i < r->num_pF; i++ ) { + + for ( j = 0; j < l->num_pF; j++ ) { + if ( r->pF[i] == l->pF[j] ) break; + } + if ( j < l->num_pF ) { + /* got that one in dest LNF already + */ + l->pC[j] += r->pC[i]; + continue; + } + + if ( lminus_fluent[r->pF[i]] != -1 ) { + /* this one was already translated. let's see + * if its counterpart is in the left lnf. + */ + for ( j = 0; j < l->num_pF; j++ ) { + if ( lminus_fluent[r->pF[i]] == l->pF[j] ) break; + } + if ( j < l->num_pF ) { + /* for this, we got the inverse one! + */ + l->pC[j] -= r->pC[i]; + if ( l->pC[j] < 0 ) { + l->pF[j] = r->pF[i]; + l->pC[j] *= (-1); + } + if ( l->pC[j] == 0 ) { + /* remove this entirely. + */ + for ( k = j; k < l->num_pF - 1; k++ ) { + l->pF[k] = l->pF[k+1]; + l->pC[k] = l->pC[k+1]; + } + l->num_pF--; + } + continue; + } + } + + /* we got neither that nor its counterpart. + */ + if ( l->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + l->pF[l->num_pF] = r->pF[i]; + l->pC[l->num_pF++] = r->pC[i]; + } + + + l->c += r->c; + +} + + + + + + + + + + + + + + + + + + + + + + +/************************************************************* + * LNF POST-PROCESSING II: ENCODE NON-MINIMAL LNFs. + *************************************************************/ + + + + + + + + + + + + + + + + + + + + + + + +void encode_lfns_as_artificial_fluents( void ) + +{ + + int i; + + /* for the artificial new ones, this will be set + * to the respective LNF. + */ + for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { + grelevant_fluents_lnf[i] = NULL; + } + + while ( TRUE ) { + /* ex non-minimal lnf in pre, cond, eff, or goal? + * + * (i.e., lnf != fl + c) + */ + if ( !ex_non_minimal_lnf_in_pre_cond_goal_eff() ) { + /* no --> we are finished. + */ + break; + } + /* otherwise, the respective LNF, without the + * constant part, is set up in + * lF...; (local global borrowed from above); + * + * introduce a new artificial fluent for that + * LNF + */ + introduce_artificial_fluent(); + /* replace all occurences in pres, conds, effs, and goals + */ + replace_non_minimal_lnf_with_artificial_fl(); + } + +} + + + +Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( glnf_goal_lh[i]->num_pF > 1 || + (glnf_goal_lh[i]->num_pF == 1 && glnf_goal_lh[i]->pC[0] != 1) ) { + for ( j = 0; j < glnf_goal_lh[i]->num_pF; j++ ) { + lF[j] = glnf_goal_lh[i]->pF[j]; + lC[j] = glnf_goal_lh[i]->pC[j]; + } + lnum_F = glnf_goal_lh[i]->num_pF; + return TRUE; + } + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( a->lnf_preconds_lh[i]->num_pF > 1 || + (a->lnf_preconds_lh[i]->num_pF == 1 && a->lnf_preconds_lh[i]->pC[0] != 1) ) { + for ( j = 0; j < a->lnf_preconds_lh[i]->num_pF; j++ ) { + lF[j] = a->lnf_preconds_lh[i]->pF[j]; + lC[j] = a->lnf_preconds_lh[i]->pC[j]; + } + lnum_F = a->lnf_preconds_lh[i]->num_pF; + return TRUE; + } + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* these will not be included into conn: + * merged into somewhere else. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_pF > 1 || + (e->lnf_conditions_lh[j]->num_pF == 1 && e->lnf_conditions_lh[j]->pC[0] != 1) ) { + for ( k = 0; k < e->lnf_conditions_lh[j]->num_pF; k++ ) { + lF[k] = e->lnf_conditions_lh[j]->pF[k]; + lC[k] = e->lnf_conditions_lh[j]->pC[k]; + } + lnum_F = e->lnf_conditions_lh[j]->num_pF; + return TRUE; + } + } + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_rh[j]->num_pF > 1 || + (e->lnf_effects_rh[j]->num_pF == 1 && e->lnf_effects_rh[j]->pC[0] != 1) ) { + for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { + lF[k] = e->lnf_effects_rh[j]->pF[k]; + lC[k] = e->lnf_effects_rh[j]->pC[k]; + } + lnum_F = e->lnf_effects_rh[j]->num_pF; + return TRUE; + } + } + } + } + + return FALSE; + +} + + + +void introduce_artificial_fluent( void ) + +{ + + int i; + + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = -1; + + /* no name --> is inferred in this case from _lnf + */ + + grelevant_fluents_lnf[gnum_relevant_fluents] = new_LnfExpNode(); + for ( i = 0; i < lnum_F; i++ ) { + grelevant_fluents_lnf[gnum_relevant_fluents]->pF[i] = lF[i]; + grelevant_fluents_lnf[gnum_relevant_fluents]->pC[i] = lC[i]; + } + grelevant_fluents_lnf[gnum_relevant_fluents]->num_pF = lnum_F; + + gnum_relevant_fluents++; + +} + + + +void replace_non_minimal_lnf_with_artificial_fl( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( !is_artificial_fluent( glnf_goal_lh[i] ) ) { + continue; + } + /* the pF here is the pF we are currently replacing. + */ + glnf_goal_lh[i]->pF[0] = gnum_relevant_fluents - 1; + glnf_goal_lh[i]->pC[0] = 1; + glnf_goal_lh[i]->num_pF = 1; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( !is_artificial_fluent( a->lnf_preconds_lh[i] ) ) { + continue; + } + a->lnf_preconds_lh[i]->pF[0] = gnum_relevant_fluents - 1; + a->lnf_preconds_lh[i]->pC[0] = 1; + a->lnf_preconds_lh[i]->num_pF = 1; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* these will not be included into conn: + * merged into somewhere else. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( !is_artificial_fluent( e->lnf_conditions_lh[j] ) ) { + continue; + } + e->lnf_conditions_lh[j]->pF[0] = gnum_relevant_fluents - 1; + e->lnf_conditions_lh[j]->pC[0] = 1; + e->lnf_conditions_lh[j]->num_pF = 1; + } + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( !is_artificial_fluent( e->lnf_effects_rh[j] ) ) { + continue; + } + e->lnf_effects_rh[j]->pF[0] = gnum_relevant_fluents - 1; + e->lnf_effects_rh[j]->pC[0] = 1; + e->lnf_effects_rh[j]->num_pF = 1; + } + } + } + +} + + + +Bool is_artificial_fluent( LnfExpNode *n ) + +{ + + int i, j; + + if ( n->num_nF != 0 ) { + printf("\n\nchecking non-empty nF for multiple fl!\n\n"); + exit( 1 ); + } + + if ( n->num_pF != lnum_F ) { + return FALSE; + } + + for ( i = 0; i < lnum_F; i++ ) { + for ( j = 0; j < n->num_pF; j++ ) { + if ( n->pF[j] != lF[i] ) continue; + if ( n->pC[j] != lC[i] ) { + /* wrong constant multiplier! + */ + return FALSE; + } + break; + } + if ( j == n->num_pF ) { + /* didn't find this fluent i in here. + */ + return FALSE; + } + } + + return TRUE; + +} + + + + + + + + + + + + + + + + + + +/************************************************************* + * AT LAST: PREPARATIONS FOR METRIC FUNCTION + *************************************************************/ + + + + + + + + + + + + + + + + + + +Bool setup_effect_costs( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, fl; + Bool non_zero = FALSE; + + if ( glnf_metric.num_pF == 0 ) { + /* no metric, or previously failed + */ + if ( gcmd_line.display_info ) { + printf("\nno metric specified."); + } + return FALSE; + } + + /* also in here: check if all parts of metric are defined + * if not, then they won't ever be because we do not allow + * assigners anyway. + * + * also, setup gtt total-time multipl. + * currently needed since in h fn effect cists are summed up + * --> may count the same action more than once, if we insert the + * timing cost into the effect cost. + * + * ... this is AWKWARD... probably would be better to simply + * associate costs always (including relaxed plans) + * only with ACTIONS! + */ + gtt = 0; + for ( i = 0; i < glnf_metric.num_pF; i++ ) { + if ( glnf_metric.pF[i] == -2 ) { + gtt = glnf_metric.pC[i]; + continue; + } + if ( !ginitial_state.f_D[glnf_metric.pF[i]] ) break; + } + if ( i < glnf_metric.num_pF ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: metric undefined initially. no optimization done."); + } + return FALSE; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + e->cost = 0; + + if ( e->removed || + e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + fl = e->lnf_effects_fl[j]; + for ( k = 0; k < glnf_metric.num_pF; k++ ) { + if ( fl == glnf_metric.pF[k] ) break; + } + if ( k == glnf_metric.num_pF ) continue; + + if ( e->lnf_effects_rh[j]->num_pF > 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: non-constant effect on metric. no optimization done."); + } + return FALSE; + } + if ( e->lnf_effects_neft[j] != INCREASE ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: assign on metric. no optimization done."); + } + return FALSE; + } + if ( e->lnf_effects_rh[j]->c < 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: change on metric in wrong direction. no optimization done."); + } + return FALSE; + } + + e->cost += glnf_metric.pC[k] * e->lnf_effects_rh[j]->c; + if ( e->cost > 0 ) { + non_zero = TRUE; + } + } + } + } + + if ( !non_zero ) { + if ( gtt == 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: trivial metric, all costs 0. no optimization done."); + } + return FALSE; + } + } + + return TRUE; + +} + + + + + + + + + + + + + + + + + + + + + +/************************************************************* + * AT VERY LAST: ACYCLIC := EFFS, AND STATIC FL RELEVANCE + *************************************************************/ + + + + + + + + + + + + + + + + + + + + + + + +void check_assigncycles( void ) + +{ + + int i, j, k, c = 0; + + gassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + gTassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + gassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + gTassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + } + + if ( gcmd_line.display_info > 1 ) { + printf("\n\nchecking for cyclic := effects"); + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + gassign_influence[i][j] = i_influences_j( i, j ); + gTassign_influence[i][j] = i_influences_j( i, j ); + } + } + /* compute transitive closure on dependencies + */ + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( gTassign_influence[i][j] ) { + for ( k = 0; k < gnum_real_fl_conn; k++ ) { + if ( gTassign_influence[j][k] ) { + gTassign_influence[i][k] = TRUE; + } + } + } + } + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( gTassign_influence[i][i] ) { + printf("\nnumerical variable "); + print_fl_name( i ); + printf(" lies on := propagation cycle!"); + c++; + } + } + if ( c > 0 ) { + printf("\nexit. (mneed computation not possible, RPG termination unclear)"); + printf("\n (questions to Joerg Hoffmann)\n\n"); + exit( 1 ); + } else { + if ( gcmd_line.display_info > 1 ) { + printf(" --- OK."); + } + } + +} + + + +Bool i_influences_j( int fi, int fj ) + +{ + + int i, j, fl_; + + for ( i = 0; i < gfl_conn[fj].num_AS; i++ ) { + fl_ = gfl_conn[fj].AS_fl_[i]; + if ( fl_ < 0 ) continue; + if ( fl_ == fi ) return TRUE; + if ( !gfl_conn[fl_].artificial ) continue; + for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { + if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; + } + } + + return FALSE; + +} + + + +void determine_fl_relevance( void ) + +{ + + int i, j, k, fl, fl_, ef, pc, g; + Bool **influenced_by; + + /* this here contains transfers from i to j i.e. if + * i is relevant then j is too + */ + influenced_by = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + influenced_by[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + influenced_by[i][j] = ( gassign_influence[j][i] || + i_inc_influences_j( j, i ) ); + } + } + /* transitive closure so we'll have direct access below. + */ + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[i][j] ) { + for ( k = 0; k < gnum_real_fl_conn; k++ ) { + if ( influenced_by[j][k] ) { + influenced_by[i][k] = TRUE; + } + } + } + } + } + + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + gfl_conn[i].relevant = FALSE; + } + /* relevance originates in effect preconds and goals. + */ + for ( ef = 0; ef < gnum_ef_conn; ef++ ) { + for ( pc = 0; pc < gef_conn[ef].num_f_PC; pc++ ) { + /* constraint here is gef_conn[ef].f_PC_fl[pc] >= [>] gef_conn[ef].f_PC_c[pc] + * where lh side can be lnf expression. + */ + fl = gef_conn[ef].f_PC_fl[pc]; + if ( fl < 0 ) { + printf("\nnegative constr lh??\n\n"); + exit( 1 ); + } + if ( !gfl_conn[fl].artificial ) { + gfl_conn[fl].relevant = TRUE; + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; + } + } else { + for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { + fl_ = gfl_conn[fl].lnf_F[i]; + gfl_conn[fl_].relevant = TRUE; + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; + } + } + } + } + } + for ( g = 0; g < gnum_fnumeric_goal; g++ ) { + /* constraint here is gfnumeric_goal_fl[g] >= [>] gfnumeric_goal_c[g] + * where lh side can be lnf expression. + */ + fl = gfnumeric_goal_fl[g]; + if ( fl < 0 ) { + printf("\nnegative constr lh??\n\n"); + exit( 1 ); + } + if ( !gfl_conn[fl].artificial ) { + gfl_conn[fl].relevant = TRUE; + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; + } + } else { + for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { + fl_ = gfl_conn[fl].lnf_F[i]; + gfl_conn[fl_].relevant = TRUE; + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; + } + } + } + } + + if ( 0 ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + printf("\n"); print_fl_name( i ); + printf (" --- relevant: %d", gfl_conn[i].relevant); + } + } + +} + + + +Bool i_inc_influences_j( int fi, int fj ) + +{ + + int i, j, fl_; + + for ( i = 0; i < gfl_conn[fj].num_IN; i++ ) { + fl_ = gfl_conn[fj].IN_fl_[i]; + if ( fl_ < 0 ) continue; + if ( fl_ == fi ) return TRUE; + if ( !gfl_conn[fl_].artificial ) continue; + for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { + if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; + } + } + + return FALSE; + +} + diff --git a/gen/ff_planner/expressions.h b/gen/ff_planner/expressions.h new file mode 100644 index 000000000..3546f2acd --- /dev/null +++ b/gen/ff_planner/expressions.h @@ -0,0 +1,106 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: expressions.h + * Description: headers for handling numerical expressions + * + * Author: Joerg Hoffmann 2001 + * + *********************************************************************/ + + + + + + + + + + + + + + +#ifndef _EXPRESSIONS_H +#define _EXPRESSIONS_H + + + + +Bool number_comparison_holds( Comparator c, float l, float r ); + + + +Bool transform_to_LNF( void ); +Bool is_linear_task( void ); +Bool is_linear_expression( ExpNode *n ); +void print_lnf_representation( void ); + + + +void normalize_expressions( void ); +Bool translate_divisions( ExpNode **n ); +void push_multiplications_down( ExpNode **n ); +void put_comp_into_normalized_locals( Comparator comp, + ExpNode *lh, + ExpNode *rh ); +void collect_normalized_locals( ExpNode *n, Bool positive ); + + + +void translate_subtractions( void ); +Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ); +void introduce_minus_fluent( int fl ); +void replace_fl_in_nF_with_minus_fl( int fl ); +void set_minus_fl_initial( int fl ); +void introduce_minus_fl_effects( int fl ); + + + +void summarize_effects( void ); +Bool same_condition( ActionEffect *e, ActionEffect *e_ ); +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); +void merge_effects( ActionEffect *e, ActionEffect *e_ ); +void merge_lnfs( LnfExpNode *l, LnfExpNode *r ); + + + +void encode_lfns_as_artificial_fluents( void ); +Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ); +void introduce_artificial_fluent( void ); +void replace_non_minimal_lnf_with_artificial_fl( void ); +Bool is_artificial_fluent( LnfExpNode *n ); + + + +Bool setup_effect_costs( void ); + + + +void check_assigncycles( void ); +Bool i_influences_j( int fi, int fj ); +void determine_fl_relevance( void ); +Bool i_inc_influences_j( int fi, int fj ); + + + +#endif /* _EXPRESSIONS_H */ diff --git a/gen/ff_planner/ff.h b/gen/ff_planner/ff.h new file mode 100644 index 000000000..d244df7ae --- /dev/null +++ b/gen/ff_planner/ff.h @@ -0,0 +1,2044 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: ff.h + * Description: Types and structures for the Metric-FastForward planner. + * Enhanced version with derived predicates and A*-epsilon + * + * --------- PDDL2.1 level 2 :: VERSION v 1.0 -------------- + * + * Author: Joerg Hoffmann 2012 + * Contact: hoffmann@cs.uni-saarland.de + * + *********************************************************************/ + + + + + + + + +#ifndef __FF_H +#define __FF_H + + + + + + +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + +/* + * ------------------------------------ DEFINES ---------------------------- + */ + + + + + + + + + + + +/*********************** + * MEANINGLESS HELPERS * + ***********************/ + + + + +/* strcmp returns 0 if two strings are equal, which is not nice */ +#define SAME 0 + + + + + + + + + +/**************** + * PARSING ETC. * + ****************/ + + + + + + + + + +/* various defines used in parsing + */ +#define HIDDEN_STR "#" +#define AXIOM_STR "AXIOM" +#define NAME_STR "name\0" +#define VARIABLE_STR "variable\0" +#define STANDARD_TYPE "OBJECT\0" +#define EITHER_STR "EITHER" + + + + + + + + + +/*************************** + * SOME ARBITRARY SETTINGS * + ***************************/ + + + + + + + +/* maximal string length + */ +#define MAX_LENGTH 256 + + +/* marks border between connected items + */ +#define CONNECTOR "~" + + +/* size of goals_at array in 1P extraction + */ +#define RELAXED_STEPS_DEFAULT 25 + + +/* size of hash table for repeated states checking + * during EHC breadth first search + */ +#define EHC_HASH_SIZE 8192 +#define EHC_HASH_BITS 8191 + + +/* size of hash table for repeated states checking + * in plan construction + */ +#define PLAN_HASH_SIZE 1024 +#define PLAN_HASH_BITS 1023 + + +/* size of hash table for repeated states checking + * during BFS search + */ +#define BFS_HASH_SIZE 65536 +#define BFS_HASH_BITS 65535 + + +/* cut random values of facts off modulo this value, + * to make state sums fit into a single integer + */ +#define BIG_INT 1500000 + + +/* max number of different fluents in one list of LNF + */ +#define MAX_LNF_F 25 + + +/* max number of comps in one cond / precond / goal + */ +#define MAX_LNF_COMPS 100 + + +/* max number of lnf effects in one action effect + */ +#define MAX_LNF_EFFS 50 + + + + + + + +/************************ + * INSTANTIATION LIMITS * + ************************/ + + + + + + + + +#define MAX_CONSTANTS 2000 +#define MAX_PREDICATES 50 +#define MAX_FUNCTIONS 50 +#define MAX_TYPES 50 +#define MAX_ARITY 5 +#define MAX_VARS 15 + + +#define MAX_TYPE 2000 + + +#define MAX_OPERATORS 50000 + + +/* in DNF: AND with OR - sons - collect 'hitting set': + * one son of each OR node. + * + * this here is initial max number of such son s that can be collected + * (grows dynamically, if required) + */ +#define MAX_HITTING_SET_DEFAULT 1000 + + +#define MAX_TYPE_INTERSECTIONS 10 + + +#define MAX_RELEVANT_FACTS 150000 +#define MAX_RELEVANT_FLUENTS 1000 + + + + + + +/****************************************** + * DOMAIN STRUCTURE AND SEARCHING LIMITS * + ******************************************/ + + + + + + +#define MAX_STATE 800 + + +#define MAX_PLAN_LENGTH 500 + + + + + + +/**************** + * CODE DEFINES * + ****************/ + + + + + + + + + +/* not a real 'code' define; used in relax and search to encode + * infinite level number / plan length + */ +#ifndef INFINITY +#define INFINITY -1 +#endif + + + + + + + +/* define boolean types if not allready defined + */ +#ifndef Bool +typedef unsigned char Bool; +#ifndef TRUE /* we assume that FALSE is also not defined */ +#define TRUE 1 +#define FALSE 0 +#endif /* TRUE */ +#endif /* Bool */ + + +/* code a param number into a negative number and vice versa + */ +#define ENCODE_VAR( val ) (val * (-1)) - 1 +#define DECODE_VAR( val ) (val + 1) * (-1) + +#define GET_CONSTANT( val, pointer ) ( val >= 0 ) ? val : pointer->inst_table[DECODE_VAR( val )] + + +/* Check allocated memory + */ +#define CHECK_PTR(p) if (NULL == (p)) { \ + fprintf(stdout, "\n\aNO MEMORY in file %s:%d\n\n", __FILE__, __LINE__); \ + exit(1);} + + +/* add elapsed time from main local time vars to specified val + */ +#define TIME( val ) val += ( float ) ( ( end.tms_utime - start.tms_utime + \ + end.tms_stime - start.tms_stime ) / 100.0 ) + + + + + + + + + + + + +/* + * ------------------------------ DATA STRUCTURES ---------------------------- + */ + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + +/* all command switches + */ +struct _command_line { + + char path[MAX_LENGTH]; + char ops_file_name[MAX_LENGTH]; + char fct_file_name[MAX_LENGTH]; + int display_info; + int debug; + + int search_config; + Bool cost_rplans; + + int w; + + float cost_bound; + +}; + + +typedef char *Token; + + + + + + + + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + + + + +/* A list of strings + */ +typedef struct _TokenList { + + char *item; + struct _TokenList *next; + +} TokenList; + + + +/* list of string lists + */ +typedef struct _FactList { + + TokenList *item; + struct _FactList *next; + +} FactList; + + + +/* structure to store typed-list-of /, + * as they are declared in PDDL files + */ +typedef struct _TypedList { + + char *name; + + /* each item in this list is the name of a type which + * our type is the union of (EITHER - types ...) + * + * usually, this will default to a single-item TokenList. + */ + TokenList *type; + /* after first sweep, this will contain the number in type table + */ + int n; + + struct _TypedList *next; + +} TypedList; + + + +/* only needed to parse in the predicates and their arg + * definitions + */ +typedef struct _TypedListList { + + char *predicate; + + TypedList *args; + + struct _TypedListList *next; + +} TypedListList; + + + +typedef enum _ExpConnective{FHEAD = 1000, + NUMBER, + MINUS, + AD, + SU, + MU, + DI} ExpConnective; + + + +typedef struct _ParseExpNode { + + ExpConnective connective; + + /* NULL anywhere except when node is FHEAD or NUMBER + * (in which case it is fn name ... resp. number (int or float) as string + */ + TokenList *atom; + + /* both NULL in FHEAD; + * in MINUS, left is son and right is NULL + * else (binary operators), left and right operand + */ + struct _ParseExpNode *leftson, *rightson; + +} ParseExpNode; + + + +/* This type indicates whether a node in the pddl tree stands for + * an atomic expression, a junctor or a quantor. + */ +typedef enum _Connective{TRU = 2000, + FAL, + ATOM, + COMP, + NEF, + NOT, + AND, + OR, + ALL, + EX, + WHEN} Connective; + + + +typedef enum _Comparator{IGUAL = 3000, /* technical if conds are array comp exp, resp float */ + LE, + LEQ, + EQ, + GEQ, + GE} Comparator; + + + + +typedef enum _NumericEffectType{ASSIGN = 4000, + SCALE_UP, + SCALE_DOWN, + INCREASE, + DECREASE} NumericEffectType; + + + + +/* + * This is a node in the tree to parse PDDL files + */ +typedef struct _PlNode { + + /* type of the node + */ + Connective connective; + + /* only for parsing: the var args in quantifiers + */ + TypedList *parse_vars; + + /* AND, OR, NOT, WHEN, + * COMP, NEF => NULL + * ALL, EX => the quantified variable with its type + * ATOM => the atom as predicate->param1->param2->... + */ + TokenList *atom; + /* all except COMP, NEF => NULL + * COMP, NEF => left hand, right hand + */ + Comparator comp; + NumericEffectType neft; + ParseExpNode *lh, *rh; + + /* (a) for AND, OR this is the list of sons(a AND b AND c...), + * (b) for the rest this is the son, e.g. a subtree that is negated + * (c) for WHEN, the first son is the condition and the next son + * is the effect + */ + struct _PlNode *sons; + + /* if you have a list of sons, they are connected by next + */ + struct _PlNode *next; + +} PlNode; + + +/* + * This resembles an uninstantiated PDDL operator + */ +typedef struct _PlOperator { + + char *name; + Bool axiom; + + /* only important for PDDL where :VARS may be added to the param list + * which must be hidden when writing the plan to an output file + */ + int number_of_real_params; + + /* the params, as they are declared in domain file + */ + TypedList *parse_params; + + /* params is a list of variable/type pairs, such that: + * factlist->item = [variable] -> [type] + */ + FactList *params; + PlNode *preconds; + PlNode *effects; + + struct _PlOperator *next; + +} PlOperator; + + + + + + + + + + + + + + + +/***************** + * INSTANTIATION * + *****************/ + + + + + + + + + +/* helpers + */ + +typedef int TypeArray[MAX_TYPE_INTERSECTIONS]; + +typedef int *int_pointer; + + + + +/* first step structures: parsing & preprocessing + */ + +typedef struct _Fact { + + int predicate, args[MAX_ARITY]; + +} Fact; + + + +typedef struct _Fluent { + + int function, args[MAX_ARITY]; + +} Fluent; + + + +typedef struct _FluentValue { + + Fluent fluent; + float value; + +} FluentValue; + + + +typedef struct _Facts { + + Fact *fact; + + struct _Facts *next; + +} Facts; + + + +typedef struct _FluentValues { + + Fluent fluent; + float value; + + struct _FluentValues *next; + +} FluentValues; + + + +typedef struct _ExpNode { + + ExpConnective connective; + + /* in FHEAD nodes, pre-processing + */ + Fluent *fluent; + /* in FHEAD nodes after pre-processes have finished. + * (internal number of relevant fluent, or -1 if not + * relevant) + */ + int fl; + /* helper for LNF: if that fl is multiplied, this is the + * respective constant after pre-normalization. + */ + float c; + + /* in NUMBER nodes + */ + float value; + + /* in MINUS nodes + */ + struct _ExpNode *son; + + /* in all others + */ + struct _ExpNode *leftson, *rightson; + +} ExpNode, *ExpNode_pointer; + + + +typedef struct _WffNode { + + Connective connective; + + /* in ALL/EX s + */ + int var, var_type; + char *var_name; + + /* in AND/OR s + */ + struct _WffNode *sons; + /* sons are doubly connected linear list + */ + struct _WffNode *next; + struct _WffNode *prev; + + /* in ATOMs + */ + Fact *fact; + /* after translation: mark NOT-p s for efficiency + */ + int NOT_p; + + /* in ALL/EX/NOT + */ + struct _WffNode *son; + + /* in COMP + */ + Comparator comp; + ExpNode *lh, *rh; + + /* for expansion speedup + */ + Bool visited; + + /* no WHEN s here... use Pl Connectives anyway for simplicity + */ + +} WffNode, *WffNode_pointer; + + + +typedef struct _Literal { + + Bool negated; + + Fact fact; + + struct _Literal *next; + struct _Literal *prev; + +} Literal; + + + +typedef struct _NumericEffect { + + Fluent fluent; + NumericEffectType neft; + + ExpNode *rh; + + struct _NumericEffect *next; + struct _NumericEffect *prev; + +} NumericEffect; + + + +typedef struct _Effect { + + int num_vars, var_types[MAX_VARS]; + char *var_names[MAX_VARS]; + + WffNode *conditions; + + Literal *effects; + NumericEffect *numeric_effects; + + struct _Effect *next; + struct _Effect *prev; + +} Effect; + + + +typedef struct _Operator { + + char *name, *var_names[MAX_VARS]; + int number_of_real_params; + Bool axiom; + + int num_vars, var_types[MAX_VARS]; + Bool removed[MAX_VARS]; + + WffNode *preconds; + + Effect *effects; + + Bool hard; + +} Operator, *Operator_pointer; + + + + + + +/* second step: structures that keep already normalized + * operators + */ + + + + +typedef struct _NormEffect { + + int num_vars, var_types[MAX_VARS]; + int inst_table[MAX_VARS]; + + Fact *conditions; + int num_conditions; + + Fact *adds; + int num_adds; + Fact *dels; + int num_dels; + + /* numerical parts: not yet normalized any further; seems that + * normalizing requires certain additional structures + + * transformation, and that these will better be done when + * the representation is fully instantiated already. + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + Fluent *numeric_effects_fluent; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + struct _NormEffect *prev; + struct _NormEffect *next; + +} NormEffect; + + + +typedef struct _NormOperator { + + Operator *operator; + + int num_vars, var_types[MAX_VARS]; + int inst_table[MAX_VARS]; + int removed_vars[MAX_VARS], num_removed_vars, type_removed_vars[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric precondition still full scale represented, see above + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + NormEffect *effects; + + Bool out; + +} NormOperator, *NormOperator_pointer; + + + +/* minimal info for a fully instantiated easy operator; + * yields one action when expanded + */ +typedef struct _EasyTemplate { + + NormOperator *op; + int inst_table[MAX_VARS]; + + struct _EasyTemplate *prev; + struct _EasyTemplate *next; + +} EasyTemplate; + + + + + + +/* structures for hard ops + */ + + + + + +/* intermediate step: structure for keeping hard ops + * with normalized precondition, but arbitrary + * effect conditions + */ +typedef struct _MixedOperator { + + Operator *operator; + + int inst_table[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric part, pre-normalized + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + Effect *effects; + + struct _MixedOperator *next; + +} MixedOperator; + + + +/* last hard step: everything is action - like, except that + * facts are not yet integer coded + */ + + + +typedef struct _PseudoActionEffect { + + Fact *conditions; + int num_conditions; + + Fact *adds; + int num_adds; + Fact *dels; + int num_dels; + + + /* and the numeric parts again... + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + Fluent *numeric_effects_fluent; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + struct _PseudoActionEffect *next; + +} PseudoActionEffect; + + + +typedef struct _PseudoAction { + + Operator *operator; + + int inst_table[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric part, pre-normalized + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + PseudoActionEffect *effects; + int num_effects; + +} PseudoAction, *PseudoAction_pointer; + + + + +/* final domain representation structure + */ + + + +typedef struct _LnfExpNode { + + int pF[MAX_LNF_F]; + float pC[MAX_LNF_F]; + int num_pF; + + int nF[MAX_LNF_F]; + float nC[MAX_LNF_F]; + int num_nF; + + float c; + +} LnfExpNode, *LnfExpNode_pointer; + + + +typedef struct _ActionEffect { + + int *conditions; + int num_conditions; + + int *adds; + int num_adds; + int *dels; + int num_dels; + + /* and the numeric parts again; fluents all as fl ints; + * + * normalization for cond as below for pre; + * norm. for effects by restriction of types (?), + * right hand side float (?) + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + int *numeric_effects_fl; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + /* LNF + */ + Comparator *lnf_conditions_comp; + LnfExpNode_pointer *lnf_conditions_lh; + float *lnf_conditions_rh; + int num_lnf_conditions; + + NumericEffectType *lnf_effects_neft; + int *lnf_effects_fl; + LnfExpNode_pointer *lnf_effects_rh; + int num_lnf_effects; + + /* this is true iff the numerical part of the effects affects or accesses + * an undefined fluent (i.e. in numeric_effects_fl or numeric_effects_rh ) + * --- then, if the effect appears, the action is + * illegal. + */ + Bool illegal; + + /* helper + */ + Bool removed; + + float cost; + +} ActionEffect; + + + +typedef struct _Action { + + NormOperator *norm_operator; + PseudoAction *pseudo_action; + Bool axiom; + + char *name; + int num_name_vars; + int name_inst_table[MAX_VARS]; + + int inst_table[MAX_VARS]; + + int *preconds; + int num_preconds; + /* numeric part, in general format, with fluents encoded as fl ints + * + * also, will (?) be transformed to lh fl, rh float; then, expnodes as + * fast accessible as specialised structures. + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + /* LNF + */ + Comparator *lnf_preconds_comp; + LnfExpNode_pointer *lnf_preconds_lh; + float *lnf_preconds_rh; + int num_lnf_preconds; + + ActionEffect *effects; + int num_effects; + + struct _Action *next; + +} Action; + + + + + + + + + + + +/***************************************************** + * BASIC OP AND FT STRUCTURES FOR CONNECTIVITY GRAPH * + *****************************************************/ + + + + + + + + + + + +typedef struct _OpConn { + + /* to get name + */ + Action *action; + Bool axiom; + + /* effects + */ + int *E; + int num_E; + + /* member for applicable actions extraction + */ + Bool is_in_A; + Bool is_in_A_axioms; + + /* members for 1Ph - H(S) extraction + */ + int is_used; + Bool is_in_H; + + /* this is a bit imprecise since actually, in this + * framework here, the cost of the action may depend on + * which conditional effects actually apply. + * ... anyway, this makes things much easier for the case + * where there aren't any effect conditions. all cost handling + * is now based on this..!! + */ + float cost; + +} OpConn; + + + +typedef struct _EfConn { + + int op; + + /* true if access to always undefined fluent, or + * conflicting assignments. + * + * if that is the case then nothing except condition is set: + * the effect is completely ignored except that + * it renders the op unapplicable when its condition + * is true. + */ + Bool illegal; + + /* this one means we found in conn that it is useless (empty) + */ + Bool removed; + + /* this is the cost; can be non-zero if a metric was specified + * and established + */ + float cost; + + int *PC; + int num_PC; + /* numeric part + */ + Comparator *f_PC_comp; /* either GEQ or GE */ + int *f_PC_fl; + float *f_PC_c; + int num_f_PC; + /* array indexed by fl number, to fast know whether + * new fluent value is high enough + */ + Comparator *f_PC_direct_comp; + float *f_PC_direct_c; + + /* logic effects + */ + int *A; + int num_A; + int *D; + int num_D; + /* and the numeric ones; fl_ is the encoding of the LNF + * on the right hand side, without constant part + * (special treatment for that as it's supposed + * to be the most common thing!!) + */ + int *IN_fl; + int *IN_fl_; + float *IN_c; + int num_IN; + + int *AS_fl; + int *AS_fl_; + float *AS_c; + int num_AS; + + /* implied effects + */ + int *I; + int num_I; + + /* members for relaxed fixpoint computation + */ + int level;/* first "cost level" where ef appears */ + float RPGcost;/* max_{p prec} cost(p)+cost(op(ef)) */ + + Bool in_E; + int num_active_PCs; + Bool ch; + + /* RPG + */ + int num_active_f_PCs; + + /* 1P; an effect can be selected several times + * for increasing a fluent. + */ + int in_plan; + +} EfConn; + + + +typedef struct _FtConn { + + /* effects it is union conds, pres element of + */ + int *PC; + int num_PC; + + /* efs that add or del it + */ + int *A; + int num_A; + + int *D; + int num_D; + + /* members for orderings preprocessing + */ + int *False; + int num_False; + + /* members for relaxed fixpoint computation + */ + int level;/* first "cost level" where ft appears */ + float RPGcost;/* min_{e adder} cost(e) */ + Bool in_F; + + /* members for 1Ph extraction + */ + int is_goal; + int is_true; + Bool ch; + + /* search + */ + int rand;/* for hashing */ + + /* is this the effect of an axiom? + * needed to quickly filter out derived facts, in state + * transitions! + */ + Bool axiom_added; + +} FtConn; + + + +typedef struct _FlConn { + + /* effects it is union conds, pres required + */ + int *PC; + int num_PC; + + /* efs that inc, ass it and by which encoded fluents and constants + */ + int *IN; + int *IN_fl_; + float *IN_c; + int num_IN; + + int *AS; + int *AS_fl_; + float *AS_c;/* see above */ + int num_AS; + + /* is it an artificial fluent? + */ + Bool artificial; + /* if so, then this here is the linear equation + * it stands for + */ + int *lnf_F; + float *lnf_C; + int num_lnf; + + + /* the termination criterion for RPG building is based on mneed, see + * JAIR article for definition; + * + * as the name suggests, we use the bool to indicate that this one is not + * needed at all + */ + Bool mneed_is_minusinfty; + float mneed; + /* see JAIR; shortcut for never needed at all. + */ + Bool relevant; + + /* the following are members handled within heuristic algorithms. + */ + + /* this are arrays saying what the max value at + * the levels in the RPG is, resp. whether the value + * can be defined there at all, resp. what the increasers + * at that level have added. + */ + Bool *def; + float *level; + + /* for handling assigners in RPG: is an assigner in there yet, + * and if so what is their max value? + */ + Bool curr_assigned; + float curr_max_assigned; + + int rand;/* for hashing */ + +} FlConn; + + + + + + + + + + + + +/**************************** + * STRUCTURES FOR SEARCHING * + ****************************/ + + + + + + + + + +typedef struct _State { + + int *F; + int num_F; + + Bool *f_D; + float *f_V; + +} State, *State_pointer; + + + +typedef struct _EhcNode { + + State S; + + int op; + int depth; + + struct _EhcNode *father; + struct _EhcNode *next; + +} EhcNode; + + + +typedef struct _EhcHashEntry { + + int sum; + + EhcNode *ehc_node; + + struct _EhcHashEntry *next; + +} EhcHashEntry, *EhcHashEntry_pointer; + + + +typedef struct _PlanHashEntry { + + int sum; + State S; + + /* step is number of op that is EXECUTED in S; + * -1 means that this state is no longer contained in plan + */ + int step; + struct _PlanHashEntry *next_step; + + struct _PlanHashEntry *next; + +} PlanHashEntry, *PlanHashEntry_pointer; + + + +typedef struct _BfsNode { + + State S; + int op; + + /* number of steps from ini state to here + */ + int ini_distance; + + /* number of steps in relaxed plan for this state + */ + int goal_distance; + + /* g-value and h-value, ie summed-up cost to here, + * summed-up cost in rplan for here. + * used in all optimization configs + */ + float g; + float h; + + /* f-value. in weighted A*, f=g+w*h; in A*epsilon, f=g+h + */ + float f; + + /* The applicable actions -- may be only the helpful ones, + * in case helpful actions are used! + */ + int *A; + int num_A; + + struct _BfsNode *father; + + struct _BfsNode *next; + struct _BfsNode *prev; + +} BfsNode; + + + +typedef struct _BfsHashEntry { + + int sum; + + BfsNode *bfs_node; + + struct _BfsHashEntry *next; + +} BfsHashEntry, *BfsHashEntry_pointer; + + + + + + + + + + + + + +/* + * -------------------------------- MAIN FN HEADERS ---------------------------- + */ + + + + + + + + + + + + + + + + + +void output_planner_info( void ); +void ff_usage( void ); +Bool process_command_line( int argc, char *argv[] ); + + + + + + + + + +/* + * ----------------------------- GLOBAL VARIABLES ---------------------------- + */ + + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + + + +/* used to time the different stages of the planner + */ +extern float gtempl_time, greach_time, grelev_time, gconn_time; +extern float gLNF_time, gsearch_time; + +/* the command line inputs + */ +extern struct _command_line gcmd_line; + +/* number of states that got heuristically evaluated + */ +extern int gevaluated_states; + +/* maximal depth of breadth first search + */ +extern int gmax_search_depth; + + + + + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + + + + + +/* used for pddl parsing, flex only allows global variables + */ +extern int gbracket_count; +extern char *gproblem_name; + +/* The current input line number + */ +extern int lineno; + +/* The current input filename + */ +extern char *gact_filename; + +/* The pddl domain name + */ +extern char *gdomain_name; + +/* loaded, uninstantiated operators + */ +extern PlOperator *gloaded_ops; + +/* stores initials as fact_list + */ +extern PlNode *gorig_initial_facts; + +/* not yet preprocessed goal facts + */ +extern PlNode *gorig_goal_facts; + +/* the types, as defined in the domain file + */ +extern TypedList *gparse_types; + +/* the constants, as defined in domain file + */ +extern TypedList *gparse_constants; + +/* the predicates and their arg types, as defined in the domain file + */ +extern TypedListList *gparse_predicates; + +/* the functions and their arg types, as defined in the domain file + */ +extern TypedListList *gparse_functions; + +/* the objects, declared in the problem file + */ +extern TypedList *gparse_objects; + +/* the metric + */ +extern Token gparse_optimization; +extern ParseExpNode *gparse_metric; + + +/* connection to instantiation ( except ops, goal, initial ) + */ + +/* all typed objects + */ +extern FactList *gorig_constant_list; + +/* the predicates and their types + */ +extern FactList *gpredicates_and_types; + +/* the functions and their types + */ +extern FactList *gfunctions_and_types; + + + + + + + + + + + + + + +/***************** + * INSTANTIATING * + *****************/ + + + + + + + + + + +/* global arrays of constant names, + * type names (with their constants), + * predicate names, + * predicate aritys, + * defined types of predicate args + */ +extern Token gconstants[MAX_CONSTANTS]; +extern int gnum_constants; +extern Token gtype_names[MAX_TYPES]; +extern int gtype_consts[MAX_TYPES][MAX_TYPE]; +extern Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; +extern int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ +extern int gtype_size[MAX_TYPES]; +extern int gnum_types; +extern Token gpredicates[MAX_PREDICATES]; +extern int garity[MAX_PREDICATES]; +extern Bool gaxiom_added[MAX_PREDICATES]; +extern int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; +extern int gnum_predicates; +extern Token gfunctions[MAX_FUNCTIONS]; +extern int gf_arity[MAX_FUNCTIONS]; +extern int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; +extern int gnum_functions; + + + + +/* the domain in first step integer representation + */ +extern Operator_pointer goperators[MAX_OPERATORS]; +extern int gnum_operators; +extern Fact *gfull_initial; +extern int gnum_full_initial; +extern FluentValue *gfull_fluents_initial; +extern int gnum_full_fluents_initial; +extern WffNode *ggoal; + +extern ExpNode *gmetric; + + + +/* stores inertia - information: is any occurence of the predicate + * added / deleted in the uninstantiated ops ? + */ +extern Bool gis_added[MAX_PREDICATES]; +extern Bool gis_deleted[MAX_PREDICATES]; + +/* for functions we *might* want to say, symmetrically, whether it is + * increased resp. decreased at all. + * + * that is, however, somewhat involved because the right hand + * sides can be arbirtray expressions, so we have no guarantee + * that increasing really does adds to a functions value... + * + * thus (for the time being), we settle for "is the function changed at all?" + */ +extern Bool gis_changed[MAX_FUNCTIONS]; + + + +/* splitted initial state: + * initial non static facts, + * initial static facts, divided into predicates + * (will be two dimensional array, allocated directly before need) + */ +extern Facts *ginitial; +extern int gnum_initial; +extern Fact **ginitial_predicate; +extern int *gnum_initial_predicate; + +/* same thing for functions + */ +extern FluentValues *gf_initial; +extern int gnum_f_initial; +extern FluentValue **ginitial_function; +extern int *gnum_initial_function; + + + +/* the type numbers corresponding to any unary inertia + */ +extern int gtype_to_predicate[MAX_PREDICATES]; +extern int gpredicate_to_type[MAX_TYPES]; + +/* (ordered) numbers of types that new type is intersection of + */ +extern TypeArray gintersected_types[MAX_TYPES]; +extern int gnum_intersected_types[MAX_TYPES]; + + + +/* splitted domain: hard n easy ops + */ +extern Operator_pointer *ghard_operators; +extern int gnum_hard_operators; +extern NormOperator_pointer *geasy_operators; +extern int gnum_easy_operators; + + + +/* so called Templates for easy ops: possible inertia constrained + * instantiation constants + */ +extern EasyTemplate *geasy_templates; +extern int gnum_easy_templates; + + + +/* first step for hard ops: create mixed operators, with conjunctive + * precondition and arbitrary effects + */ +extern MixedOperator *ghard_mixed_operators; +extern int gnum_hard_mixed_operators; + + + +/* hard ''templates'' : pseudo actions + */ +extern PseudoAction_pointer *ghard_templates; +extern int gnum_hard_templates; + + + +/* store the final "relevant facts" + */ +extern Fact grelevant_facts[MAX_RELEVANT_FACTS]; +extern int gnum_relevant_facts; +extern int gnum_pp_facts; +/* store the "relevant fluents" + */ +extern Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; +extern int gnum_relevant_fluents; +extern Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; +/* this is NULL for normal, and the LNF for + * artificial fluents. + */ +extern LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; + + + +/* the final actions and problem representation + */ +extern Action *gactions; +extern int gnum_actions; +extern State ginitial_state; +extern int *glogic_goal; +extern int gnum_logic_goal; +extern Comparator *gnumeric_goal_comp; +extern ExpNode_pointer *gnumeric_goal_lh, *gnumeric_goal_rh; +extern int gnum_numeric_goal; + + + +/* to avoid memory leaks; too complicated to identify + * the exact state of the action to throw away (during construction), + * memory gain not worth the implementation effort. + */ +extern Action *gtrash_actions; + + + +/* additional lnf step between finalized inst and + * conn graph + */ +extern Comparator *glnf_goal_comp; +extern LnfExpNode_pointer *glnf_goal_lh; +extern float *glnf_goal_rh; +extern int gnum_lnf_goal; + +extern LnfExpNode glnf_metric; +extern Bool goptimization_established; + + + +/********************** + * CONNECTIVITY GRAPH * + **********************/ + + + + + +/* one ops (actions) array ... + */ +extern OpConn *gop_conn; +extern int gnum_op_conn; + + + +/* one effects array ... + */ +extern EfConn *gef_conn; +extern int gnum_ef_conn; + + + +/* one facts array. + */ +extern FtConn *gft_conn; +extern int gnum_ft_conn; + + + +/* and: one fluents array. + */ +extern FlConn *gfl_conn; +extern int gnum_fl_conn; +extern int gnum_real_fl_conn;/* number of non-artificial ones */ + + + +/* final goal is also transformed one more step. + */ +extern int *gflogic_goal; +extern int gnum_flogic_goal; +extern Comparator *gfnumeric_goal_comp; +extern int *gfnumeric_goal_fl; +extern float *gfnumeric_goal_c; +extern int gnum_fnumeric_goal; + +/* direct access (by relevant fluents) + */ +extern Comparator *gfnumeric_goal_direct_comp; +extern float *gfnumeric_goal_direct_c; + + + + + + + + + + + + + +/******************* + * SEARCHING NEEDS * + *******************/ + + + + + + + + + + + + +/* applicable actions + */ +extern int *gA;/* non-axioms */ +extern int gnum_A; +extern int *gA_axioms; /* axioms */ +extern int gnum_A_axioms; + + + +/* communication from extract 1.P. to search engine: + * 1P action choice + */ +extern int *gH; +extern int gnum_H; +/* added cost of relaxed plan + */ +extern float gh_cost; +/* hmax value + */ +extern float ghmax; + + + +/* to store plan + */ +extern int gplan_ops[MAX_PLAN_LENGTH]; +extern int gnum_plan_ops; + + + +/* stores the states that the current plan goes through + */ +extern State gplan_states[MAX_PLAN_LENGTH + 1]; + + + +/* dirty: multiplic. of total-time in final metric LNF + */ +extern float gtt; + + + + + + +/* the mneed structures + * + * assign propagation pairs i, j, and transitive such pairs. + */ +extern Bool **gassign_influence; +extern Bool **gTassign_influence; + + + +/* the real var input to the mneed computation. + */ +extern Bool *gmneed_start_D; +extern float *gmneed_start_V; + + + +/* does this contain conditional effects? + * (if it does then the state hashing has to be made more + * cautiously) + */ +extern Bool gconditional_effects; + + +/* easier to question: are we optimizing or no? + */ +extern Bool gcost_minimizing; + + +/* stores current A* weight: this is initially given by user, + * but changes during anytime search. + */ +extern float gw; +/* this is the minimum weight, ie we'll stop once the weight update + * does/would yield a value <= this. + * if no such minim weight is given, this will be -1 + */ +extern float gmin_w; + + +/* this one says whether or not we are actually using + * cost-minimizing rplans. + * this will be the case by default if we're running cost- + * minimizing searches. it can be switched off by a flag; + * it is automatically switched off in case there are + * numeric preconditions/goals: for this case, + * cost-minimizing rplans are not implemented (a numeric prec + * may cause an action to come in "later" on in the RPG although + * its logical pres are easy. in that case, any new effects will + * have a smaller RPGcost value than facts we already have waiting. + * in other words, the "Dijsktra" nature breaks. + * + * ... I suppose there may be a generic solution to this that + * can handle numeric precs/goals. Doesn't seem important enough + * to bother. + */ +extern Bool gcost_rplans; + + +#endif diff --git a/gen/ff_planner/inst_easy.c b/gen/ff_planner/inst_easy.c new file mode 100644 index 000000000..db6c1681b --- /dev/null +++ b/gen/ff_planner/inst_easy.c @@ -0,0 +1,1220 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: inst_easy.c + * Description: functions for multiplying easy operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_easy.h" + + + + + + + + +void build_easy_action_templates( void ) + +{ + + int i, j; + NormOperator *o; + EasyTemplate *t; + + cleanup_easy_domain(); + + if ( gcmd_line.display_info == 110 ) { + printf("\n\ncleaned up easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + encode_easy_unaries_as_types(); + + if ( gcmd_line.display_info == 111 ) { + printf("\n\nunaries encoded easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + multiply_easy_effect_parameters(); + + if ( gcmd_line.display_info == 112 ) { + printf("\n\neffects multiplied easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + multiply_easy_op_parameters(); + + if ( gcmd_line.display_info == 113 ) { + printf("\n\ninertia free easy operators are:"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + printf("\n\n"); + fflush( stdout ); + } + + if ( gcmd_line.display_info == 114 ) { + printf("\n\neasy operator templates are:\n"); + + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + printf("\n\n-----------operator %s:-----------", o->operator->name); + for ( t = geasy_templates; t; t = t->next ) { + if ( t->op != o ) { + continue; + } + printf("\ninst: "); + for ( j = 0; j < o->num_vars; j++ ) { + if ( t->inst_table[j] < 0 ) { + printf("\nuninstantiated param in template! debug me, please\n\n"); + exit( 1 ); + } + printf("x%d = %s", j, gconstants[t->inst_table[j]]); + if ( j < o->num_vars - 1 ) { + printf(", "); + } + } + } + } + fflush( stdout ); + } + +} + + + + + + + + + + + +/********************************* + * EASY DOMAIN CLEANUP FUNCTIONs * + *********************************/ + + + + + + + + + + + +void cleanup_easy_domain( void ) + +{ + + int i, i1, i2, i3, i4, a; + NormOperator *o; + NormEffect *e; + + /* most likely ( for sure ? ) we do not need this function call here, + * as empty types are recognised in translation already. + * + * however, who knows .. ? doesn't need any real computation time anyway. + * + * function DOES make sense after unaries encoding, as artificial types + * might well be empty. + */ + handle_empty_easy_parameters(); + + /* remove identical preconds and effects; + * VERY unlikely that such will get down to here, after all + * the formula preprocessing, but possible (?) in principle. + * takes no computation time. + * + * also, remove effect conditions that are contained in the + * preconditions. + */ + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + i1 = 0; + while ( i1 < o->num_preconds-1 ) { + i2 = i1+1; + while ( i2 < o->num_preconds ) { + if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) { + for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) { + o->preconds[i3].predicate = o->preconds[i3+1].predicate; + for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) { + o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4]; + } + } + o->num_preconds--; + } else { + i2++; + } + } + i1++; + } + + for ( e = o->effects; e; e = e->next ) { + i1 = 0; + while ( i1 < e->num_conditions-1 ) { + i2 = i1+1; + while ( i2 < e->num_conditions ) { + if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) { + for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) { + e->conditions[i3].predicate = e->conditions[i3+1].predicate; + /* here, we can still have equalities. nowhere else. + */ + a = ( e->conditions[i3].predicate < 0 ) ? + 2 : garity[e->conditions[i3].predicate]; + for ( i4 = 0; i4 < a; i4++ ) { + e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4]; + } + } + e->num_conditions--; + } else { + i2++; + } + } + i1++; + } + + i1 = 0; + while ( i1 < e->num_conditions ) { + for ( i2 = 0; i2 < o->num_preconds; i2++ ) { + if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) { + break; + } + } + if ( i2 == o->num_preconds ) { + i1++; + continue; + } + for ( i2 = i1; i2 < e->num_conditions-1; i2++ ) { + e->conditions[i2].predicate = e->conditions[i2+1].predicate; + for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) { + e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3]; + } + } + e->num_conditions--; + } + + i1 = 0; + while ( i1 < e->num_adds-1 ) { + i2 = i1+1; + while ( i2 < e->num_adds ) { + if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) { + for ( i3 = i2; i3 < e->num_adds-1; i3++ ) { + e->adds[i3].predicate = e->adds[i3+1].predicate; + for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) { + e->adds[i3].args[i4] = e->adds[i3+1].args[i4]; + } + } + e->num_adds--; + } else { + i2++; + } + } + i1++; + } + + i1 = 0; + while ( i1 < e->num_dels-1 ) { + i2 = i1+1; + while ( i2 < e->num_dels ) { + if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) { + for ( i3 = i2; i3 < e->num_dels-1; i3++ ) { + e->dels[i3].predicate = e->dels[i3+1].predicate; + for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) { + e->dels[i3].args[i4] = e->dels[i3+1].args[i4]; + } + } + e->num_dels--; + } else { + i2++; + } + } + i1++; + } + } + } + +} + + + +Bool identical_fact( Fact *f1, Fact *f2 ) + +{ + + int i, a; + + if ( f1->predicate != f2->predicate ) { + return FALSE; + } + + a = ( f1->predicate < 0 ) ? 2 : garity[f1->predicate]; + + for ( i = 0; i < a; i++ ) { + if ( f1->args[i] != f2->args[i] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +/* this one needs ONLY be used after unaries encoding, as all empty types + * are already recognised during translation, except the artificial ones, + * of course. + */ +void handle_empty_easy_parameters( void ) + +{ + + int i, j, k; + NormOperator *o; + NormEffect *e, *tmp; + + i = 0; + while ( i < gnum_easy_operators ) { + o = geasy_operators[i]; + + for ( j = 0; j < o->num_vars; j++ ) { + if ( gtype_size[o->var_types[j]] == 0 ) { + break; + } + } + if ( j < o->num_vars ) { + free_NormOperator( o ); + for ( k = i; k < gnum_easy_operators - 1; k++ ) { + geasy_operators[k] = geasy_operators[k+1]; + } + gnum_easy_operators--; + } else { + i++; + } + } + + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + e = o->effects; + while ( e ) { + for ( j = 0; j < e->num_vars; j++ ) { + if ( gtype_size[e->var_types[j]] == 0 ) { + break; + } + } + if ( j < e->num_vars ) { + if ( e->prev ) { + e->prev->next = e->next; + } else { + o->effects = e->next; + } + if ( e->next ) { + e->next->prev = e->prev; + } + tmp = e->next; + free_single_NormEffect( e ); + e = tmp; + } else { + e = e->next; + } + } + } + +} + + + + + + + + + + +/**************************** + * UNARY INERTIA INTO TYPES * + ****************************/ + + + + + + + + + + + + +void encode_easy_unaries_as_types( void ) + +{ + + NormOperator *o; + int i1, i, j, k, l, new_T, p, a; + TypeArray T; + int num_T; + NormEffect *e; + int intersected_type, var; + + for ( i1 = 0; i1 < gnum_easy_operators; i1++ ) { + o = geasy_operators[i1]; + + for ( i = 0; i < o->num_vars; i++ ) { + + T[0] = o->var_types[i]; + num_T = 1; + + j = 0; + while ( j < o->num_preconds ) { + p = o->preconds[j].predicate; + if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && + ( o->preconds[j].args[0] == ENCODE_VAR( i ) ) ) { + if ( num_T == MAX_TYPE_INTERSECTIONS ) { + printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", + MAX_TYPE_INTERSECTIONS); + exit( 1 ); + } + /* insert new type number into ordered array T; + * ---- all type numbers in T are different: + * new nr. is of inferred type - can't be type declared for param + * precondition facts occur at most once - doubles are removed + * during cleanup + */ + for ( k = 0; k < num_T; k++ ) { + if ( new_T < T[k] ) { + break; + } + } + for ( l = num_T; l > k; l-- ) { + T[l] = T[l-1]; + } + T[k] = new_T; + num_T++; + /* now remove superfluous precondition + */ + for ( k = j; k < o->num_preconds-1; k++ ) { + o->preconds[k].predicate = o->preconds[k+1].predicate; + for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { + o->preconds[k].args[l] = o->preconds[k+1].args[l]; + } + } + o->num_preconds--; + } else { + j++; + } + } + + /* if we did not hit any unary inertia concerning this parameter + * in the preconds, skip parameter and go to next one + */ + if ( num_T == 1 ) { + continue; + } + + /* now we have the ordered array of types to intersect for param i + * of op o in array T of size num_T; + * if there already is this intersected type, set type of this + * param to its number, otherwise create the new intersected type. + */ + if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { + /* type already there + */ + o->var_types[i] = intersected_type; + continue; + } + + /* create new type + */ + o->var_types[i] = create_intersected_type( T, num_T ); + } + + for ( e = o->effects; e; e = e->next ) { + for ( i = 0; i < e->num_vars; i++ ) { + T[0] = e->var_types[i]; + var = o->num_vars + i; + num_T = 1; + j = 0; + while ( j < e->num_conditions ) { + p = e->conditions[j].predicate; + if ( p < 0 ) { + j++; + continue; + } + if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && + ( e->conditions[j].args[0] == ENCODE_VAR( var ) ) ) { + if ( num_T == MAX_TYPE_INTERSECTIONS ) { + printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", + MAX_TYPE_INTERSECTIONS); + exit( 1 ); + } + for ( k = 0; k < num_T; k++ ) { + if ( new_T < T[k] ) { + break; + } + } + for ( l = num_T; l > k; l-- ) { + T[l] = T[l-1]; + } + T[k] = new_T; + num_T++; + for ( k = j; k < e->num_conditions-1; k++ ) { + e->conditions[k].predicate = e->conditions[k+1].predicate; + a = ( e->conditions[k].predicate < 0 ) ? + 2 : garity[e->conditions[k].predicate]; + for ( l = 0; l < a; l++ ) { + e->conditions[k].args[l] = e->conditions[k+1].args[l]; + } + } + e->num_conditions--; + } else { + j++; + } + } + if ( num_T == 1 ) { + continue; + } + if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { + e->var_types[i] = intersected_type; + continue; + } + e->var_types[i] = create_intersected_type( T, num_T ); + } + } + } + + handle_empty_easy_parameters(); + +} + + + +int create_intersected_type( TypeArray T, int num_T ) + +{ + + int i, j, k, intersected_type; + + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many (inferred and intersected) types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_names[gnum_types] = NULL; + gtype_size[gnum_types] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][gnum_types] = FALSE; + } + for ( i = 0; i < num_T; i++ ) { + gintersected_types[gnum_types][i] = T[i]; + } + gnum_intersected_types[gnum_types] = num_T; + intersected_type = gnum_types; + gnum_types++; + + for ( j = 0; j < gtype_size[T[0]]; j++ ) { + for ( k = 1; k < num_T; k++ ) { + if ( !gis_member[gtype_consts[T[0]][j]][T[k]] ) { + break; + } + } + if ( k < num_T ) { + continue; + } + /* add constant to new type + */ + if ( gtype_size[intersected_type] == MAX_TYPE ) { + printf("\ntoo many consts in intersected type! increase MAX_TYPE (currently %d)\n\n", + MAX_TYPE); + exit( 1 ); + } + gtype_consts[intersected_type][gtype_size[intersected_type]++] = gtype_consts[T[0]][j]; + gis_member[gtype_consts[T[0]][j]][intersected_type] = TRUE; + } + + /* now verify if the intersected type equals one of the types that we intersected. + * this is the case, iff one of the types in T has the same size as intersected_type + */ + for ( j = 0; j < num_T; j++ ) { + if ( gtype_size[intersected_type] != gtype_size[T[j]] ) { + continue; + } + /* type T[j] contains exactly the constants that we need! + * + * remove intersected type from table! + */ + gtype_size[intersected_type] = 0; + for ( k = 0; k < MAX_CONSTANTS; k++ ) { + gis_member[k][intersected_type] = FALSE; + } + gnum_intersected_types[intersected_type] = -1; + gnum_types--; + intersected_type = T[j]; + break; + } + + return intersected_type; + +} + + + +int find_intersected_type( TypeArray T, int num_T ) + +{ + + int i, j; + + for ( i = 0; i < gnum_types; i++ ) { + if ( gnum_intersected_types[i] == -1 ) { + continue; + } + + if ( gnum_intersected_types[i] != num_T ) { + continue; + } + + for ( j = 0; j < num_T; j++ ) { + if ( T[j] != gintersected_types[i][j] ) { + break; + } + } + if ( j < num_T ) { + continue; + } + + return i; + } + + return -1; + +} + + + + + + + + + + + + + + +/****************************** + * MULTIPLY EFFECT PARAMETERS * + ******************************/ + + + + + + + + + + + + +/* local globals for multiplying + */ + +int linertia_conds[MAX_VARS]; +int lnum_inertia_conds; + +int lmultiply_parameters[MAX_VARS]; +int lnum_multiply_parameters; + +NormOperator *lo; +NormEffect *le; + +NormEffect *lres; + + + + + + +void multiply_easy_effect_parameters( void ) + +{ + + int i, j, k, l, p, par; + NormEffect *e; + + for ( i = 0; i < gnum_easy_operators; i++ ) { + lo = geasy_operators[i]; + + lres = NULL; + for ( e = lo->effects; e; e = e->next ) { + le = e; + + lnum_inertia_conds = 0; + for ( j = 0; j < e->num_conditions; j++ ) { + for ( k = 0; k < garity[e->conditions[j].predicate]; k++ ) { + if ( e->conditions[j].args[k] < 0 && + DECODE_VAR( e->conditions[j].args[k] ) < lo->num_vars ) { + break; + } + } + if ( k < garity[e->conditions[j].predicate] ) { + /* only consider inertia constraining effect parameters + */ + continue; + } + if ( !gis_added[e->conditions[j].predicate] && + !gis_deleted[e->conditions[j].predicate] ) { + linertia_conds[lnum_inertia_conds++] = j; + } + } + + lnum_multiply_parameters = 0; + for ( j = 0; j < e->num_vars; j++ ) { + par = lo->num_vars + j; + for ( k = 0; k < lnum_inertia_conds; k++ ) { + p = e->conditions[linertia_conds[k]].predicate; + for ( l = 0; l < garity[p]; l++ ) { + if ( e->conditions[linertia_conds[k]].args[l] == + ENCODE_VAR( par ) ) { + break; + } + } + if ( l < garity[p] ) { + break; + } + } + if ( k < lnum_inertia_conds ) { + continue; + } + lmultiply_parameters[lnum_multiply_parameters++] = j; + } + + unify_easy_inertia_conditions( 0 ); + } + free_NormEffect( lo->effects ); + lo->effects = lres; + } + +} + + + +void unify_easy_inertia_conditions( int curr_inertia ) + +{ + + int p, i, j, af, hh; + int args[MAX_VARS]; + int affected_params[MAX_VARS]; + int num_affected_params = 0; + + if ( curr_inertia == lnum_inertia_conds ) { + multiply_easy_non_constrained_effect_parameters( 0 ); + return; + } + + p = le->conditions[linertia_conds[curr_inertia]].predicate; + for ( i = 0; i < garity[p]; i++ ) { + args[i] = le->conditions[linertia_conds[curr_inertia]].args[i]; + if ( args[i] < 0 ) { + hh = DECODE_VAR( args[i] ); + hh -= lo->num_vars; + if ( le->inst_table[hh] != -1 ) { + args[i] = le->inst_table[hh]; + } else { + affected_params[num_affected_params++] = hh; + } + } + } + + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + af = 0; + for ( j = 0; j < garity[p]; j++ ) { + if ( args[j] >= 0 ) { + if ( args[j] != ginitial_predicate[p][i].args[j] ) { + break; + } else { + continue; + } + } + le->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; + } + if ( j < garity[p] ) { + continue; + } + + unify_easy_inertia_conditions( curr_inertia + 1 ); + } + + for ( i = 0; i < num_affected_params; i++ ) { + le->inst_table[affected_params[i]] = -1; + } + +} + + + +void multiply_easy_non_constrained_effect_parameters( int curr_parameter ) + +{ + + int t, n, i, j, k, p, par; + NormEffect *tmp; + Bool rem; + + if ( curr_parameter == lnum_multiply_parameters ) { + /* create new effect, adjusting conds to inst, and + * partially instantiating effects; + * + * add result to lres + */ + tmp = new_NormEffect2( le ); + + /* instantiate param occurences + */ + for ( i = 0; i < le->num_vars; i++ ) { + par = lo->num_vars + i; + + /* numerical part + */ + for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_conditions_lh[j]), + par, le->inst_table[i] ); + } + for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_conditions_rh[j]), + par, le->inst_table[i] ); + } + /* was that already enough to get numbers? if yes, + * see whether comparison holds or not. + */ + j = 0; + while ( j < tmp->num_numeric_conditions ) { + if ( tmp->numeric_conditions_lh[j]->connective == NUMBER && + tmp->numeric_conditions_rh[j]->connective == NUMBER ) { + if ( number_comparison_holds( tmp->numeric_conditions_comp[j], + tmp->numeric_conditions_lh[j]->value, + tmp->numeric_conditions_rh[j]->value ) ) { + free_ExpNode( tmp->numeric_conditions_lh[j] ); + free_ExpNode( tmp->numeric_conditions_rh[j] ); + for ( k = j; k < tmp->num_numeric_conditions-1; k++ ) { + tmp->numeric_conditions_comp[k] = tmp->numeric_conditions_comp[k+1]; + tmp->numeric_conditions_lh[k] = tmp->numeric_conditions_lh[k+1]; + tmp->numeric_conditions_rh[k] = tmp->numeric_conditions_rh[k+1]; + } + tmp->num_numeric_conditions--; + } else { + free_NormEffect( tmp ); + return; + } + } else { + j++; + } + } + for ( j = 0; j < tmp->num_numeric_effects; j++ ) { + for ( k = 0; k < gf_arity[tmp->numeric_effects_fluent[j].function]; k++ ) { + if ( tmp->numeric_effects_fluent[j].args[k] == ENCODE_VAR( par ) ) { + tmp->numeric_effects_fluent[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_numeric_effects; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_effects_rh[j]), + par, le->inst_table[i] ); + } + + /* logical part + */ + for ( j = 0; j < tmp->num_conditions; j++ ) { + for ( k = 0; k < garity[tmp->conditions[j].predicate]; k++ ) { + if ( tmp->conditions[j].args[k] == ENCODE_VAR( par ) ) { + tmp->conditions[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_adds; j++ ) { + for ( k = 0; k < garity[tmp->adds[j].predicate]; k++ ) { + if ( tmp->adds[j].args[k] == ENCODE_VAR( par ) ) { + tmp->adds[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_dels; j++ ) { + for ( k = 0; k < garity[tmp->dels[j].predicate]; k++ ) { + if ( tmp->dels[j].args[k] == ENCODE_VAR( par ) ) { + tmp->dels[j].args[k] = le->inst_table[i]; + } + } + } + } + /* adjust conditions + */ + i = 0; + while ( i < tmp->num_conditions ) { + rem = FALSE; + p = tmp->conditions[i].predicate; + if ( !gis_added[p] && + !gis_deleted[p] ) { + for ( j = 0; j < garity[p]; j++ ) { + if ( tmp->conditions[i].args[j] < 0 && + DECODE_VAR( tmp->conditions[i].args[j] < lo->num_vars ) ) { + break; + } + } + if ( j == garity[p] ) { + /* inertia that constrain only effect params have been unified, + * are therefore TRUE + */ + rem = TRUE; + } + } + if ( rem ) { + for ( j = i; j < tmp->num_conditions - 1; j++ ) { + tmp->conditions[j].predicate = tmp->conditions[j+1].predicate; + for ( k = 0; k < garity[tmp->conditions[j+1].predicate]; k++ ) { + tmp->conditions[j].args[k] = tmp->conditions[j+1].args[k]; + } + } + tmp->num_conditions--; + } else { + i++; + } + } + /* add result to lres + */ + if ( lres ) { + lres->prev = tmp; + } + tmp->next = lres; + lres = tmp; + return; + } + + t = le->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + + for ( i = 0; i < n; i++ ) { + le->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + multiply_easy_non_constrained_effect_parameters( curr_parameter + 1 ); + } + + le->inst_table[lmultiply_parameters[curr_parameter]] = -1; + +} + + + + + + + + + + + + + + + + + + + +/************************** + * MULTIPLY OP PARAMETERS * + **************************/ + + + + + + + + + + + + + + +/* Bool bla; */ + + + + +void multiply_easy_op_parameters( void ) + +{ + + int i, j, k, l, p; + NormOperator *o; + + geasy_templates = NULL; + gnum_easy_templates = 0; + + for ( i = 0; i < gnum_easy_operators; i++ ) { + lo = geasy_operators[i]; +/* if ( strcmp(lo->operator->name, "PORT445_WIN2000") == 0 ) { */ +/* printf("\nmultiply easy OP: %s", lo->operator->name); */ +/* bla = TRUE; */ +/* } else { */ +/* bla = FALSE; */ +/* } */ + + lnum_inertia_conds = 0; + for ( j = 0; j < lo->num_preconds; j++ ) { + if ( !gis_added[lo->preconds[j].predicate] && + !gis_deleted[lo->preconds[j].predicate] ) { + linertia_conds[lnum_inertia_conds++] = j; +/* if ( bla ) { */ +/* printf("\n:inertia cond: %d (pred %s)", j, gpredicates[lo->preconds[j].predicate]); */ +/* fflush(stdout); */ +/* } */ + } + } + + + lnum_multiply_parameters = 0; + for ( j = 0; j < lo->num_vars; j++ ) { + for ( k = 0; k < lnum_inertia_conds; k++ ) { + p = lo->preconds[linertia_conds[k]].predicate; + for ( l = 0; l < garity[p]; l++ ) { + if ( lo->preconds[linertia_conds[k]].args[l] == + ENCODE_VAR( j ) ) { + break; + } + } + if ( l < garity[p] ) { + break; + } + } + if ( k < lnum_inertia_conds ) { + continue; + } +/* if ( bla ) { */ +/* printf("\nmultiply parameter: %d", j); */ +/* fflush(stdout); */ +/* } */ + lmultiply_parameters[lnum_multiply_parameters++] = j; + } + + unify_easy_inertia_preconds( 0 ); + } + + /* now remove inertia preconditions from operator schemata + */ + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + j = 0; + while ( j < o->num_preconds ) { + if ( !gis_added[o->preconds[j].predicate] && + !gis_deleted[o->preconds[j].predicate] ) { + for ( k = j; k < o->num_preconds - 1; k++ ) { + o->preconds[k].predicate = o->preconds[k+1].predicate; + for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { + o->preconds[k].args[l] = o->preconds[k+1].args[l]; + } + } + o->num_preconds--; + } else { + j++; + } + } + } + +} + + + +void unify_easy_inertia_preconds( int curr_inertia ) + +{ + + int p, i, j, af, hh; + int args[MAX_VARS]; + int affected_params[MAX_VARS]; + int num_affected_params = 0; + + if ( curr_inertia == lnum_inertia_conds ) { + multiply_easy_non_constrained_op_parameters( 0 ); + return; + } + + p = lo->preconds[linertia_conds[curr_inertia]].predicate; + for ( i = 0; i < garity[p]; i++ ) { + args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i]; + if ( args[i] < 0 ) { + hh = DECODE_VAR( args[i] ); + if ( lo->inst_table[hh] != -1 ) { + args[i] = lo->inst_table[hh]; + } else { + affected_params[num_affected_params++] = hh; + } + } + } + + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + af = 0; + for ( j = 0; j < garity[p]; j++ ) { + if ( args[j] >= 0 ) { + if ( args[j] != ginitial_predicate[p][i].args[j] ) { + break; + } else { + continue; + } + } + /* check whether that constant has the correct type for that + * parameter (can be not fulfilled due to encoding of unary inertia + */ + if ( !gis_member[ginitial_predicate[p][i].args[j]][lo->var_types[affected_params[af]]] ) { + break; + } + /* legal constant; set op parameter instantiation to it + */ + lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; + } + if ( j < garity[p] ) { + continue; + } + + unify_easy_inertia_preconds( curr_inertia + 1 ); + } + + for ( i = 0; i < num_affected_params; i++ ) { + lo->inst_table[affected_params[i]] = -1; + } + +} + + + +void multiply_easy_non_constrained_op_parameters( int curr_parameter ) + +{ + + EasyTemplate *tmp; + int i, j, t, n; + +/* if ( bla ) { */ +/* printf("\nEntry multiply!"); */ +/* fflush(stdout); */ +/* } */ + + if ( curr_parameter == lnum_multiply_parameters ) { + tmp = new_EasyTemplate( lo ); + for ( i = 0; i < lo->num_vars; i++ ) { + tmp->inst_table[i] = lo->inst_table[i]; + } + tmp->next = geasy_templates; + if ( geasy_templates ) { + geasy_templates->prev = tmp; + } + geasy_templates = tmp; + gnum_easy_templates++; + return; + } + + if ( curr_parameter == lnum_multiply_parameters - 1 ) { +/* if ( bla ) { */ +/* printf("\nEntry 1 missing!"); */ +/* fflush(stdout); */ +/* } */ + t = lo->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + for ( i = 0; i < n; i++ ) { + lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + +/* if ( bla ) { */ +/* printf("\nmaking instance (numvars %d):", lo->num_vars); */ +/* fflush(stdout); */ +/* } */ + tmp = new_EasyTemplate( lo ); + for ( j = 0; j < lo->num_vars; j++ ) { + tmp->inst_table[j] = lo->inst_table[j]; +/* if ( bla ) { */ +/* printf("%s (ID %d), ", gconstants[tmp->inst_table[j]], tmp->inst_table[j]); */ +/* fflush(stdout); */ +/* } */ + } + tmp->next = geasy_templates; + if ( geasy_templates ) { + geasy_templates->prev = tmp; + } + geasy_templates = tmp; + gnum_easy_templates++; + } + + lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; + + return; + } + + t = lo->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + for ( i = 0; i < n; i++ ) { + lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + + multiply_easy_non_constrained_op_parameters( curr_parameter + 1 ); + } + + lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; + +} diff --git a/gen/ff_planner/inst_easy.h b/gen/ff_planner/inst_easy.h new file mode 100644 index 000000000..1bc6eb1db --- /dev/null +++ b/gen/ff_planner/inst_easy.h @@ -0,0 +1,73 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + + + +/********************************************************************* + * File: inst_easy.h + * Description: headers for multiplying easy operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + +#ifndef _INST_EASY_H +#define _INST_EASY_H + + + +void build_easy_action_templates( void ); + + + +void cleanup_easy_domain( void ); +Bool identical_fact( Fact *f1, Fact *f2 ); +void handle_empty_easy_parameters( void ); + + + +void encode_easy_unaries_as_types( void ); +int create_intersected_type( TypeArray T, int num_T ); +int find_intersected_type( TypeArray T, int num_T ); + + + +void multiply_easy_effect_parameters( void ); +void unify_easy_inertia_conditions( int curr_inertia ); +void multiply_easy_non_constrained_effect_parameters( int curr_parameter ); + + + +void multiply_easy_op_parameters( void ); +void unify_easy_inertia_preconds( int curr_inertia ); +void multiply_easy_non_constrained_op_parameters( int curr_parameter ); + + + +#endif /* _INST_EASY_H */ diff --git a/gen/ff_planner/inst_final.c b/gen/ff_planner/inst_final.c new file mode 100644 index 000000000..3f51a89e6 --- /dev/null +++ b/gen/ff_planner/inst_final.c @@ -0,0 +1,2797 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_final.c + * Description: final domain representation functions + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_final.h" + + + + + + + + + + + + + + +/******************************** + * POSSIBLY TRUE FACTS ANALYSIS * + ********************************/ + + + + + + + + +/* local globals for this part + */ + +int_pointer lpos[MAX_PREDICATES]; +int_pointer lneg[MAX_PREDICATES]; +int_pointer luse[MAX_PREDICATES]; +int_pointer lindex[MAX_PREDICATES]; + +int lp; +int largs[MAX_VARS]; + + + +/* for collecting poss. defined fluents + */ +int_pointer lf_def[MAX_FUNCTIONS]; +int_pointer lf_index[MAX_FUNCTIONS]; + +int lf; +int lf_args[MAX_VARS]; + + + + + + +void perform_reachability_analysis( void ) + +{ + + int size, i, j, k, adr, num, pargtype; + Bool fixpoint; + Facts *f; + NormOperator *no; + EasyTemplate *t1, *t2; + NormEffect *ne; + Action *tmp, *a; + Bool *had_hard_template; + PseudoAction *pa; + PseudoActionEffect *pae; + + gactions = NULL; + gnum_actions = 0; + + for ( i = 0; i < gnum_predicates; i++ ) { + size = 1; + for ( j = 0; j < garity[i]; j++ ) { + pargtype = gpredicates_args_type[i][j]; + size *= gtype_size[pargtype]; + } + + lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + luse[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + + for ( j = 0; j < size; j++ ) { + lpos[i][j] = 0; + lneg[i][j] = 1;/* all facts but initials are poss. negative */ + luse[i][j] = 0; + lindex[i][j] = -1; + } + } + + had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) ); + for ( i = 0; i < gnum_hard_templates; i++ ) { + had_hard_template[i] = FALSE; + } + + /* mark initial facts as possibly positive, not poss. negative + */ + for ( i = 0; i < gnum_predicates; i++ ) { + lp = i; + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + for ( k = 0; k < garity[i]; k++ ) { + largs[k] = ginitial_predicate[i][j].args[k]; + } + adr = fact_adress(); + lpos[lp][adr] = 1; + lneg[lp][adr] = 0; + } + } + + /* compute fixpoint + */ + fixpoint = FALSE; + while ( !fixpoint ) { + fixpoint = TRUE; + + /* assign next layer of easy templates to possibly positive fixpoint + */ + t1 = geasy_templates; + while ( t1 ) { + no = t1->op; + for ( i = 0; i < no->num_preconds; i++ ) { + lp = no->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( no->preconds[i].args[j] >= 0 ) ? + no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; + } + if ( !lpos[lp][fact_adress()] ) { + break; + } + } + + if ( i < no->num_preconds ) { + t1 = t1->next; + continue; + } + + num = 0; + for ( ne = no->effects; ne; ne = ne->next ) { + num++; + /* currently, simply ignore effect conditions and assume + * they will all be made true eventually. + */ + for ( i = 0; i < ne->num_adds; i++ ) { + lp = ne->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->adds[i].args[j] >= 0 ) ? + ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) { + /* new relevant fact! (added non initial) + */ + lpos[lp][adr] = 1; + lneg[lp][adr] = 1; + luse[lp][adr] = 1; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + fixpoint = FALSE; + } + } + } + + tmp = new_Action(); + tmp->norm_operator = no; + tmp->axiom = no->operator->axiom; + for ( i = 0; i < no->num_vars; i++ ) { + tmp->inst_table[i] = t1->inst_table[i]; + } + tmp->name = no->operator->name; + tmp->num_name_vars = no->operator->number_of_real_params; + make_name_inst_table_from_NormOperator( tmp, no, t1 ); + tmp->next = gactions; + tmp->num_effects = num; + gactions = tmp; + gnum_actions++; + + t2 = t1->next; + if ( t1->next ) { + t1->next->prev = t1->prev; + } + if ( t1->prev ) { + t1->prev->next = t1->next; + } else { + geasy_templates = t1->next; + } + free_single_EasyTemplate( t1 ); + t1 = t2; + } + + /* now assign all hard templates that have not been transformed + * to actions yet. + */ + for ( i = 0; i < gnum_hard_templates; i++ ) { + if ( had_hard_template[i] ) { + continue; + } + pa = ghard_templates[i]; + + for ( j = 0; j < pa->num_preconds; j++ ) { + lp = pa->preconds[j].predicate; + for ( k = 0; k < garity[lp]; k++ ) { + largs[k] = pa->preconds[j].args[k]; + } + if ( !lpos[lp][fact_adress()] ) { + break; + } + } + + if ( j < pa->num_preconds ) { + continue; + } + + for ( pae = pa->effects; pae; pae = pae->next ) { + /* currently, simply ignore effect conditions and assume + * they will all be made true eventually. + */ + for ( j = 0; j < pae->num_adds; j++ ) { + lp = pae->adds[j].predicate; + for ( k = 0; k < garity[lp]; k++ ) { + largs[k] = pae->adds[j].args[k]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) { + /* new relevant fact! (added non initial) + */ + lpos[lp][adr] = 1; + lneg[lp][adr] = 1; + luse[lp][adr] = 1; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( k = 0; k < garity[lp]; k++ ) { + grelevant_facts[gnum_relevant_facts].args[k] = largs[k]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + fixpoint = FALSE; + } + } + } + + tmp = new_Action(); + tmp->pseudo_action = pa; + tmp->axiom = pa->operator->axiom; + for ( j = 0; j < pa->operator->num_vars; j++ ) { + tmp->inst_table[j] = pa->inst_table[j]; + } + tmp->name = pa->operator->name; + tmp->num_name_vars = pa->operator->number_of_real_params; + make_name_inst_table_from_PseudoAction( tmp, pa ); + tmp->next = gactions; + tmp->num_effects = pa->num_effects; + gactions = tmp; + gnum_actions++; + + had_hard_template[i] = TRUE; + } + } + + free( had_hard_template ); + + gnum_pp_facts = gnum_initial + gnum_relevant_facts; + + if ( gcmd_line.display_info == 118 ) { + printf("\nreachability analysys came up with:"); + + printf("\n\npossibly positive facts:"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + for ( i = 0; i < gnum_relevant_facts; i++ ) { + printf("\n"); + print_Fact( &(grelevant_facts[i]) ); + } + + printf("\n\nthis yields these %d action templates:", gnum_actions); + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\noperator %s:", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + printf("\ntemplate: "); + if ( a->axiom ) printf("(axiom) "); + for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) { + printf("%s", gconstants[a->name_inst_table[j]]); + if ( j < goperators[i]->num_vars-1 ) { + printf(" "); + } + } + } + } + printf("\n\n"); + } + +} + + + +/* bit complicated to avoid memory explosion when high arity predicates take + * num_obs ^ arity space. take space for individual arg types only; + * must consider pred args in smallest - to - largest - type order to make + * mapping injective. + */ +int fact_adress( void ) + +{ + + int r = 0, b = 1, i, j, min, minj; + Bool done[MAX_ARITY]; + + for ( i = 0; i < garity[lp]; i++ ) { + done[i] = FALSE; + } + + for ( i = 0; i < garity[lp]; i++ ) { + min = -1; + minj = -1; + for ( j = 0; j < garity[lp]; j++ ) { + if ( !done[j] ) { + if ( min == -1 || + gtype_size[gpredicates_args_type[lp][j]] < min ) { + min = gtype_size[gpredicates_args_type[lp][j]]; + minj = j; + } + } + } + if ( minj == -1 || min == -1 ) { + printf("\n\nmin or minj not made in fact adress?\n\n"); + exit( 1 ); + } + /* now minj is remaining arg with lowest type size min + */ + /* need number **within type** here! */ + r += b * gmember_nr[largs[minj]][gpredicates_args_type[lp][minj]]; + b *= min; + done[minj] = TRUE; + } + + return r; + +} + + + +int fluent_adress( void ) + +{ + + int r = 0, b = 1, i; + + for ( i = gf_arity[lf] - 1; i > -1; i-- ) { + r += b * lf_args[i]; + b *= gnum_constants; + } + + return r; + +} + + + +void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ) + +{ + + int i, r = 0, m = 0; + + for ( i = 0; i < o->operator->number_of_real_params; i++ ) { + if ( o->num_removed_vars > r && + o->removed_vars[r] == i ) { + /* this var has been removed in NormOp; + * insert type constraint constant + * + * at least one there, as empty typed pars ops are removed + */ + a->name_inst_table[i] = gtype_consts[o->type_removed_vars[r]][0]; + r++; + } else { + /* this par corresponds to par m in NormOp + */ + a->name_inst_table[i] = t->inst_table[m]; + m++; + } + } + +} + + + +void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ) + +{ + + int i; + + for ( i = 0; i < pa->operator->number_of_real_params; i++ ) { + a->name_inst_table[i] = pa->inst_table[i]; + } + +} + + + + + + + + + + + + + + + + + + +/*********************************************************** + * RELEVANCE ANALYSIS AND FINAL DOMAIN AND PROBLEM CLEANUP * + ***********************************************************/ + + + + + + + + + +/* counts effects for later allocation + */ +int lnum_effects; + + + + + + + + + +void collect_relevant_facts_and_fluents( void ) + +{ + + Action *a; + NormOperator *no; + NormEffect *ne; + int i, j, adr, size; + PseudoAction *pa; + PseudoActionEffect *pae; + FluentValues *fvs; + + /* facts: mark all deleted facts; such facts, that are also pos, are relevant. + */ + for ( a = gactions; a; a = a->next ) { + if ( a->norm_operator ) { + no = a->norm_operator; + + for ( ne = no->effects; ne; ne = ne->next ) { + for ( i = 0; i < ne->num_dels; i++ ) { + lp = ne->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->dels[i].args[j] >= 0 ) ? + ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; + } + adr = fact_adress(); + + lneg[lp][adr] = 1; + if ( lpos[lp][adr] && + !luse[lp][adr] ) { + luse[lp][adr] = 1; + lindex[lp][adr] = gnum_relevant_facts; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + } + } + } + } else { + pa = a->pseudo_action; + + for ( pae = pa->effects; pae; pae = pae->next ) { + for ( i = 0; i < pae->num_dels; i++ ) { + lp = pae->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->dels[i].args[j]; + } + adr = fact_adress(); + + lneg[lp][adr] = 1; + if ( lpos[lp][adr] && + !luse[lp][adr] ) { + luse[lp][adr] = 1; + lindex[lp][adr] = gnum_relevant_facts; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + } + } + } + } + } + /* fluents: collect all that are defined in initial state, plus + * all that are assigned to by an effect of an action + * (i.e. preconds poss. pos. due to reachability) + * + * first initialise fast access structures + */ + for ( i = 0; i < gnum_functions; i++ ) { + size = 1; + for ( j = 0; j < gf_arity[i]; j++ ) { + size *= gnum_constants; + } + lf_def[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lf_index[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + for ( j = 0; j < size; j++ ) { + lf_def[i][j] = 0; + lf_index[i][j] = -1; + } + } + /* from initial state, only those that are not static. + */ + for ( fvs = gf_initial; fvs; fvs = fvs->next ) { + lf = fvs->fluent.function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = fvs->fluent.args[j]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } else { + printf("\n\nfluent "); + print_Fluent( &(fvs->fluent) ); + printf(" defined twice in initial state! check input files\n\n"); + exit( 1 ); + } + } + /* from actions, all assigns (are non-static anyway) + */ + for ( a = gactions; a; a = a->next ) { + if ( a->norm_operator ) { + no = a->norm_operator; + for ( ne = no->effects; ne; ne = ne->next ) { + for ( i = 0; i < ne->num_numeric_effects; i++ ) { + if ( ne->numeric_effects_neft[i] != ASSIGN ) continue; + lf = ne->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? + ne->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } + } + } + } else { + pa = a->pseudo_action; + for ( pae = pa->effects; pae; pae = pae->next ) { + for ( i = 0; i < pae->num_numeric_effects; i++ ) { + if ( pae->numeric_effects_neft[i] != ASSIGN ) continue; + lf = pae->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( pae->numeric_effects_fluent[i].args[j] >= 0 ) ? + pae->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( pae->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } + } + } + } + } + + if ( gcmd_line.display_info == 119 ) { + printf("\n\nfacts selected as relevant:"); + for ( i = 0; i < gnum_relevant_facts; i++ ) { + printf("\n%d: ", i); + print_Fact( &(grelevant_facts[i]) ); + } + printf("\n\nfluents selected as relevant:"); + for ( i = 0; i < gnum_relevant_fluents; i++ ) { + printf("\n%d: ", i); + print_Fluent( &(grelevant_fluents[i]) ); + } + printf("\n\n"); + } + + lnum_effects = 0; + + create_final_goal_state(); + create_final_initial_state(); + create_final_actions(); + + if ( gmetric != NULL ) { + if ( !set_relevants_in_exp( &gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: undefined fluent used in optimization expression. defaulting to plan length"); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + } + + if ( gcmd_line.display_info == 120 ) { + printf("\n\nfinal domain representation is:\n\n"); + + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( !a->norm_operator && + !a->pseudo_action ) || + ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + print_Action( a ); + } + } + printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); + for ( a = gactions; a; a = a->next ) { + if ( !a->norm_operator && + !a->pseudo_action ) { + print_Action( a ); + } + } + + printf("\n\nfinal initial state is:\n\n"); + print_State( ginitial_state ); + + printf("\n\nfinal goal is:\n\n"); + for ( i = 0; i < gnum_logic_goal; i++ ) { + print_ft_name( glogic_goal[i] ); + printf("\n"); + } + for ( i = 0; i < gnum_numeric_goal; i++ ) { + switch ( gnumeric_goal_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator in gnumeric_goal %d\n\n", gnumeric_goal_comp[i]); + exit( 1 ); + } + print_ExpNode( gnumeric_goal_lh[i] ); + print_ExpNode( gnumeric_goal_rh[i] ); + printf(")\n"); + } + + if ( gmetric ) { + printf("\n\nmetric is (minimize):\n"); + print_ExpNode( gmetric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + } + +} + + + +void create_final_goal_state( void ) + +{ + + WffNode *w, *ww; + int m, mn, i, adr; + Action *tmp; + + if ( !set_relevants_in_wff( &ggoal ) ) { + printf("\n\nff: goal accesses a fluent that will never have a defined value. Problem unsolvable.\n\n"); + exit( 1 ); + } + cleanup_wff( &ggoal ); + + if ( ggoal->connective == TRU ) { + printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); + gnum_plan_ops = 0; + exit( 1 ); + } + if ( ggoal->connective == FAL ) { + printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); + exit( 1 ); + } + + switch ( ggoal->connective ) { + case OR: + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = -3; + gnum_relevant_facts++; + for ( w = ggoal->sons; w; w = w->next ) { + tmp = new_Action(); + if ( w->connective == AND ) { + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp->preconds = ( int * ) calloc( m, sizeof( int ) ); + tmp->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp->num_preconds = m; + tmp->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + lp = ww->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = ww->fact->args[i]; + } + adr = fact_adress(); + tmp->preconds[m] = lindex[lp][adr]; + m++; + } + if ( ww->connective == COMP ) { + tmp->numeric_preconds_comp[mn] = ww->comp; + tmp->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); + tmp->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp->preconds = ( int * ) calloc( 1, sizeof( int ) ); + tmp->num_preconds = 1; + lp = w->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = w->fact->args[i]; + } + adr = fact_adress(); + tmp->preconds[0] = lindex[lp][adr]; + } + if ( w->connective == COMP ) { + tmp->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_comp[0] = w->comp; + tmp->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp->num_numeric_preconds = 1; + } + } + tmp->effects = ( ActionEffect * ) calloc( 1, sizeof( ActionEffect ) ); + tmp->num_effects = 1; + tmp->effects[0].conditions = NULL; + tmp->effects[0].num_conditions = 0; + tmp->effects[0].dels = NULL; + tmp->effects[0].num_dels = 0; + tmp->effects[0].adds = ( int * ) calloc( 1, sizeof( int ) ); + tmp->effects[0].adds[0] = gnum_relevant_facts - 1; + tmp->effects[0].num_adds = 1; + tmp->effects[0].numeric_conditions_comp = NULL; + tmp->effects[0].numeric_conditions_lh = NULL; + tmp->effects[0].numeric_conditions_rh = NULL; + tmp->effects[0].num_numeric_conditions = 0; + tmp->effects[0].numeric_effects_neft = NULL; + tmp->effects[0].numeric_effects_fl = NULL; + tmp->effects[0].numeric_effects_rh = NULL; + tmp->effects[0].num_numeric_effects = 0; + + tmp->next = gactions; + gactions = tmp; + gnum_actions++; + lnum_effects++; + } + glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); + glogic_goal[0] = gnum_relevant_facts - 1; + gnum_logic_goal = 1; + break; + case AND: + m = 0; mn = 0; + for ( w = ggoal->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + glogic_goal = ( int * ) calloc( m, sizeof( int ) ); + gnumeric_goal_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + gnum_logic_goal = m; + gnum_numeric_goal = mn; + m = 0; mn = 0; + for ( w = ggoal->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + lp = w->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = w->fact->args[i]; + } + adr = fact_adress(); + glogic_goal[m] = lindex[lp][adr]; + m++; + } + if ( w->connective == COMP ) { + gnumeric_goal_comp[mn] = w->comp; + gnumeric_goal_lh[mn] = copy_Exp( w->lh ); + gnumeric_goal_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + break; + case ATOM: + glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); + gnum_logic_goal = 1; + lp = ggoal->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = ggoal->fact->args[i]; + } + adr = fact_adress(); + glogic_goal[0] = lindex[lp][adr]; + break; + case COMP: + gnumeric_goal_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + gnum_numeric_goal = 1; + gnumeric_goal_comp[0] = ggoal->comp; + gnumeric_goal_lh[0] = copy_Exp( ggoal->lh ); + gnumeric_goal_rh[0] = copy_Exp( ggoal->rh ); + break; + default: + printf("\n\nwon't get here: non COMP,ATOM,AND,OR in fully simplified goal\n\n"); + exit( 1 ); + } + +} + + + +Bool set_relevants_in_wff( WffNode **w ) + +{ + + WffNode *i; + int j, adr; + + switch ( (*w)->connective ) { + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + if ( !set_relevants_in_wff( &i ) ) { + return FALSE; + } + } + break; + case ATOM: + /* no equalities, as fully instantiated + */ + lp = (*w)->fact->predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = (*w)->fact->args[j]; + } + adr = fact_adress(); + + if ( !lneg[lp][adr] ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !lpos[lp][adr] ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + break; + case COMP: + if ( !set_relevants_in_exp( &((*w)->lh) ) || + !set_relevants_in_exp( &((*w)->rh) ) ) { + return FALSE; + } + break; + default: + printf("\n\nwon't get here: non ATOM,OR,AND in goal set relevants\n\n"); + exit( 1 ); + } + + return TRUE; + +} + + + +Bool set_relevants_in_exp( ExpNode **n ) + +{ + + int j, adr; + + /* can probably (for sure) forget about the simplification + * stuff here because it's been done before. + * + * igual.... + */ + switch ( (*n)->connective ) { + case AD: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + if ( !set_relevants_in_exp( &((*n)->son) ) ) return FALSE; + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + lf = (*n)->fluent->function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = (*n)->fluent->args[j]; + } + adr = fluent_adress(); + (*n)->fl = lf_index[lf][adr]; + free( (*n)->fluent ); + (*n)->fluent = NULL; + if ( lf_index[lf][adr] == -1 ) { + if ( lf == 0 ) { + /* ATTENTION!! FUNCTION 0 IS TOTAL-TIME WHICH IS *ONLY* USED + * IN OPTIMIZATION EXPRESSION. GETS A SPECIAL TREATMENT + * IN THE RESPECTIVE FUNCTION IN SEARCH.C!!!! + * + * we remember it as fluent -2!! + */ + (*n)->fl = -2; + } else { + return FALSE; + } + } + break; + default: + printf("\n\nset relevants in expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void create_final_initial_state( void ) + +{ + + Facts *f; + int i, adr, fl; + FluentValues *fvs; + + i = 0; +/* for ( f = ginitial; f; f = f->next ) i++; */ + /* we need space for transformation fluents to come! + * + * ALSO, we may need space for derived facts!!! + */ + make_state( &ginitial_state, gnum_relevant_facts + 1, MAX_RELEVANT_FLUENTS ); + + for ( f = ginitial; f; f = f->next ) { + lp = f->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = f->fact->args[i]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* non deleted ini */ + continue; + } + ginitial_state.F[ginitial_state.num_F++] = lindex[lp][adr]; + } + + for ( fvs = gf_initial; fvs; fvs = fvs->next ) { + lf = fvs->fluent.function; + for ( i = 0; i < gf_arity[lf]; i++ ) { + lf_args[i] = fvs->fluent.args[i]; + } + adr = fluent_adress(); + fl = lf_index[lf][adr]; + ginitial_state.f_D[fl] = TRUE; + ginitial_state.f_V[fl] = fvs->value; + } + +} + + + +void create_final_actions( void ) + +{ + + Action *a, *p, *t; + NormOperator *no; + NormEffect *ne; + int i, j, adr; + PseudoAction *pa; + PseudoActionEffect *pae; + ActionEffect *aa; + Bool false_cond; + + a = gactions; p = NULL; + while ( a ) { + if ( a->norm_operator ) { + /* action comes from an easy template NormOp + */ + no = a->norm_operator; + + if ( no->num_preconds > 0 ) { + a->preconds = ( int * ) calloc( no->num_preconds, sizeof( int ) ); + } + a->num_preconds = 0; + for ( i = 0; i < no->num_preconds; i++ ) { + lp = no->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( no->preconds[i].args[j] >= 0 ) ? + no->preconds[i].args[j] : a->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; + } + adr = fact_adress(); + /* preconds are lpos in all cases due to reachability analysis + */ + if ( !lneg[lp][adr] ) { + continue; + } + a->preconds[a->num_preconds++] = lindex[lp][adr]; + } + + /**************************NUMERIC PRECOND*************************/ + if ( no->num_numeric_preconds > 0 ) { + a->numeric_preconds_comp = ( Comparator * ) + calloc( no->num_numeric_preconds, sizeof( Comparator ) ); + a->numeric_preconds_lh = ( ExpNode_pointer * ) + calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->numeric_preconds_rh = ( ExpNode_pointer * ) + calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->num_numeric_preconds = 0; + } + for ( i = 0; i < no->num_numeric_preconds; i++ ) { + a->numeric_preconds_comp[a->num_numeric_preconds] = no->numeric_preconds_comp[i]; + a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_lh[i] ); + instantiate_exp_by_action( &(a->numeric_preconds_lh[a->num_numeric_preconds]), a ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; + a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_rh[i] ); + instantiate_exp_by_action( &(a->numeric_preconds_rh[a->num_numeric_preconds]), a ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; + if ( a->numeric_preconds_lh[a->num_numeric_preconds]->connective == NUMBER && + a->numeric_preconds_rh[a->num_numeric_preconds]->connective == NUMBER ) { + /* trivial numeric precond + */ + if ( number_comparison_holds( a->numeric_preconds_comp[a->num_numeric_preconds], + a->numeric_preconds_lh[a->num_numeric_preconds]->value, + a->numeric_preconds_rh[a->num_numeric_preconds]->value ) ) { + /* true precond -> throw precond away. by not incrementing number of such. + */ + free_ExpNode( a->numeric_preconds_lh[a->num_numeric_preconds] ); + free_ExpNode( a->numeric_preconds_rh[a->num_numeric_preconds] ); + continue; + } else { + /* false precond -> throw action away. + */ + break; + } + } + a->num_numeric_preconds++; + } + if ( i < no->num_numeric_preconds ) { + /* a precond accesses an undefined fluent, or is false -> remove action! + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + /**************************NUMERIC PRECOND-END*************************/ + + /* and now for the effects + */ + if ( a->num_effects > 0 ) { + a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); + for ( i = 0; i < a->num_effects; i++ ) { + a->effects[i].illegal = FALSE; + a->effects[i].removed = FALSE; + } + } + a->num_effects = 0; + for ( ne = no->effects; ne; ne = ne->next ) { + aa = &(a->effects[a->num_effects]); + + if ( ne->num_conditions > 0 ) { + aa->conditions = ( int * ) calloc( ne->num_conditions, sizeof( int ) ); + } + aa->num_conditions = 0; + for ( i = 0; i < ne->num_conditions; i++ ) { + lp = ne->conditions[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->conditions[i].args[j] >= 0 ) ? + ne->conditions[i].args[j] : a->inst_table[DECODE_VAR( ne->conditions[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ + break; + } + if ( !lneg[lp][adr] ) {/* condition always true: skip it */ + continue; + } + aa->conditions[aa->num_conditions++] = lindex[lp][adr]; + } + if ( i < ne->num_conditions ) {/* found unreachable condition: free condition space */ + free( aa->conditions ); + continue; + } + + /**************************NUMERIC COND*************************/ + if ( ne->num_numeric_conditions > 0 ) { + aa->numeric_conditions_comp = ( Comparator * ) + calloc( ne->num_numeric_conditions, sizeof( Comparator ) ); + aa->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + aa->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < ne->num_numeric_conditions; i++ ) { + aa->numeric_conditions_lh[i] = NULL; + aa->numeric_conditions_rh[i] = NULL; + } + aa->num_numeric_conditions = 0; + } + false_cond = FALSE; + for ( i = 0; i < ne->num_numeric_conditions; i++ ) { + aa->numeric_conditions_comp[aa->num_numeric_conditions] = ne->numeric_conditions_comp[i]; + aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_lh[i] ); + instantiate_exp_by_action( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_rh[i] ); + instantiate_exp_by_action( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; + if ( aa->numeric_conditions_lh[aa->num_numeric_conditions]->connective == NUMBER && + aa->numeric_conditions_rh[aa->num_numeric_conditions]->connective == NUMBER ) { + /* trivial numeric condition + */ + if ( number_comparison_holds( aa->numeric_conditions_comp[aa->num_numeric_conditions], + aa->numeric_conditions_lh[aa->num_numeric_conditions]->value, + aa->numeric_conditions_rh[aa->num_numeric_conditions]->value ) ) { + /* true cond -> throw cond away. by not incrementing number of such. + */ + free_ExpNode( aa->numeric_conditions_lh[aa->num_numeric_conditions] ); + free_ExpNode( aa->numeric_conditions_rh[aa->num_numeric_conditions] ); + aa->numeric_conditions_lh[aa->num_numeric_conditions] = NULL; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = NULL; + continue; + } else { + /* false cond -> throw effect away. + */ + false_cond = TRUE; + break; + } + } + aa->num_numeric_conditions++; + } + if ( i < ne->num_numeric_conditions ) { + if ( false_cond ) { + /* false numeric cond: free what's been done so far, and skip effect + */ + for ( i = 0; i <= aa->num_numeric_conditions; i++ ) { + free_ExpNode( aa->numeric_conditions_lh[i] ); + free_ExpNode( aa->numeric_conditions_rh[i] ); + } + free( aa->numeric_conditions_comp ); + free( aa->numeric_conditions_lh ); + free( aa->numeric_conditions_rh ); + continue;/* next effect, without incrementing action counter */ + } else { + /* numeric effect uses undefined fluent in condition --> + * THROW WHOLE ACTION AWAY! done by breaking out of the + * effects loop, which will be catched below overall + * effect handling. + */ + break; + } + } + /**************************NUMERIC COND - END*************************/ + + /* now create the add and del effects. + */ + if ( ne->num_adds > 0 ) { + aa->adds = ( int * ) calloc( ne->num_adds, sizeof( int ) ); + } + aa->num_adds = 0; + for ( i = 0; i < ne->num_adds; i++ ) { + lp = ne->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->adds[i].args[j] >= 0 ) ? + ne->adds[i].args[j] : a->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* effect always true: skip it */ + continue; + } + aa->adds[aa->num_adds++] = lindex[lp][adr]; + } + + if ( ne->num_dels > 0 ) { + aa->dels = ( int * ) calloc( ne->num_dels, sizeof( int ) ); + } + aa->num_dels = 0; + for ( i = 0; i < ne->num_dels; i++ ) { + lp = ne->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->dels[i].args[j] >= 0 ) ? + ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* effect always false: skip it */ + continue; + } + /* NO CHECK FOR ADD \CAP DEL!!!!! -> ALLOWED BY SEMANTICS!!! + */ + aa->dels[aa->num_dels++] = lindex[lp][adr]; + } + if ( i < ne->num_dels ) break; + + /**************************NUMERIC EFFECTS*************************/ + if ( ne->num_numeric_effects > 0 ) { + aa->numeric_effects_neft = ( NumericEffectType * ) + calloc( ne->num_numeric_effects, sizeof( NumericEffectType ) ); + aa->numeric_effects_fl = ( int * ) + calloc( ne->num_numeric_effects, sizeof( int ) ); + aa->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_effects, sizeof( ExpNode_pointer ) ); + aa->num_numeric_effects = 0; + } + for ( i = 0; i < ne->num_numeric_effects; i++ ) { + aa->numeric_effects_neft[aa->num_numeric_effects] = ne->numeric_effects_neft[i]; + lf = ne->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? + ne->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + /* if it's -1, simply let it in --- if that effect appears, then + * action is illegal, otherwise not. + */ + aa->numeric_effects_fl[i] = lf_index[lf][adr]; + if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; + aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( ne->numeric_effects_rh[i] ); + instantiate_exp_by_action( &(aa->numeric_effects_rh[aa->num_numeric_effects]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { + aa->illegal = TRUE; + } + if ( aa->illegal && + aa->num_conditions == 0 && + aa->num_numeric_conditions == 0 ) { + break; + } + /* that's it ???????????????? - !! + */ + aa->num_numeric_effects++; + } + if ( i < ne->num_numeric_effects ) { + /* an unconditional illegal effekt + */ + break; + } + /**************************NUMERIC EFFECTS - END*************************/ + + /* this effect is OK. go to next one in NormOp. + */ + a->num_effects++; + lnum_effects++; + } + if ( ne ) { + /* we get here if one effect was faulty + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + } else { + p = a; + a = a->next; + } + continue; + } + /**********************************second half: hard operators --> pseudo actions******************/ + if ( a->pseudo_action ) { + /* action is result of a PseudoAction + */ + pa = a->pseudo_action; + if ( pa->num_preconds > 0 ) { + a->preconds = ( int * ) calloc( pa->num_preconds, sizeof( int ) ); + } + a->num_preconds = 0; + for ( i = 0; i < pa->num_preconds; i++ ) { + lp = pa->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pa->preconds[i].args[j]; + } + adr = fact_adress(); + /* preconds are lpos in all cases due to reachability analysis + */ + if ( !lneg[lp][adr] ) { + continue; + } + a->preconds[a->num_preconds++] = lindex[lp][adr]; + } + + /**************************NUMERIC PRECOND*************************/ + if ( pa->num_numeric_preconds > 0 ) { + a->numeric_preconds_comp = ( Comparator * ) + calloc( pa->num_numeric_preconds, sizeof( Comparator ) ); + a->numeric_preconds_lh = ( ExpNode_pointer * ) + calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->numeric_preconds_rh = ( ExpNode_pointer * ) + calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->num_numeric_preconds = 0; + } + for ( i = 0; i < pa->num_numeric_preconds; i++ ) { + a->numeric_preconds_comp[a->num_numeric_preconds] = pa->numeric_preconds_comp[i]; + a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_lh[i] ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; + a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_rh[i] ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; + a->num_numeric_preconds++; + } + if ( i < pa->num_numeric_preconds ) { + /* a precond accesses an undefined fluent -> remove action! + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + /**************************NUMERIC PRECOND-END*************************/ + + /* and now for the effects + */ + if ( a->num_effects > 0 ) { + a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); + for ( i = 0; i < a->num_effects; i++ ) { + a->effects[i].illegal = FALSE; + a->effects[i].removed = FALSE; + } + } + a->num_effects = 0; + for ( pae = pa->effects; pae; pae = pae->next ) { + aa = &(a->effects[a->num_effects]); + + if ( pae->num_conditions > 0 ) { + aa->conditions = ( int * ) calloc( pae->num_conditions, sizeof( int ) ); + } + aa->num_conditions = 0; + for ( i = 0; i < pae->num_conditions; i++ ) { + lp = pae->conditions[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->conditions[i].args[j]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ + break; + } + if ( !lneg[lp][adr] ) {/* condition always true: skip it */ + continue; + } + aa->conditions[aa->num_conditions++] = lindex[lp][adr]; + } + if ( i < pae->num_conditions ) {/* found unreachable condition: free condition space */ + free( aa->conditions ); + continue; + } + + /**************************NUMERIC COND*************************/ + if ( pae->num_numeric_conditions > 0 ) { + aa->numeric_conditions_comp = ( Comparator * ) + calloc( pae->num_numeric_conditions, sizeof( Comparator ) ); + aa->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + aa->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < pae->num_numeric_conditions; i++ ) { + aa->numeric_conditions_lh[i] = NULL; + aa->numeric_conditions_rh[i] = NULL; + } + aa->num_numeric_conditions = 0; + } + for ( i = 0; i < pae->num_numeric_conditions; i++ ) { + aa->numeric_conditions_comp[aa->num_numeric_conditions] = pae->numeric_conditions_comp[i]; + aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_lh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_rh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; + aa->num_numeric_conditions++; + } + if ( i < pae->num_numeric_conditions ) { + /* numeric effect uses undefined fluent in condition --> + * THROW WHOLE ACTION AWAY! done by breaking out of the + * effects loop, which will be catched below overall + * effect handling. + */ + break; + } + /**************************NUMERIC COND - END*************************/ + + /* now create the add and del effects. + */ + if ( pae->num_adds > 0 ) { + aa->adds = ( int * ) calloc( pae->num_adds, sizeof( int ) ); + } + aa->num_adds = 0; + for ( i = 0; i < pae->num_adds; i++ ) { + lp = pae->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->adds[i].args[j]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* effect always true: skip it */ + continue; + } + aa->adds[aa->num_adds++] = lindex[lp][adr]; + } + + if ( pae->num_dels > 0 ) { + aa->dels = ( int * ) calloc( pae->num_dels, sizeof( int ) ); + } + aa->num_dels = 0; + for ( i = 0; i < pae->num_dels; i++ ) { + lp = pae->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->dels[i].args[j]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* effect always false: skip it */ + continue; + } + aa->dels[aa->num_dels++] = lindex[lp][adr]; + } + if ( i < pae->num_dels ) break; + + /**************************NUMERIC EFFECTS*************************/ + if ( pae->num_numeric_effects > 0 ) { + aa->numeric_effects_neft = ( NumericEffectType * ) + calloc( pae->num_numeric_effects, sizeof( NumericEffectType ) ); + aa->numeric_effects_fl = ( int * ) + calloc( pae->num_numeric_effects, sizeof( int ) ); + aa->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_effects, sizeof( ExpNode_pointer ) ); + aa->num_numeric_effects = 0; + } + for ( i = 0; i < pae->num_numeric_effects; i++ ) { + aa->numeric_effects_neft[aa->num_numeric_effects] = pae->numeric_effects_neft[i]; + lf = pae->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = pae->numeric_effects_fluent[i].args[j]; + if ( lf_args[j] < 0 ) { + printf("\n\nuninstantiated affected fluent in final actions! debug me.\n\n"); + exit( 1 ); + } + } + adr = fluent_adress(); + /* if it's -1, simply let it in --- if that effect appears, then + * action is illegal, otherwise not. + */ + aa->numeric_effects_fl[i] = lf_index[lf][adr]; + if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; + aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( pae->numeric_effects_rh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { + aa->illegal = TRUE; + } + if ( aa->illegal && + aa->num_conditions == 0 && + aa->num_numeric_conditions == 0 ) { + break; + } + /* that's it ???????????????? - !! + */ + aa->num_numeric_effects++; + } + if ( i < pae->num_numeric_effects ) { + /* an unconditional illegal effekt + */ + break; + } + /**************************NUMERIC EFFECTS - END*************************/ + + /* this effect is OK. go to next one in PseudoAction. + */ + a->num_effects++; + lnum_effects++; + } + if ( pae ) { + /* we get here if one effect was faulty + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + } else { + p = a; + a = a->next; + } + continue; + }/* end of if clause for PseudoAction */ + /* if action was neither normop, nor pseudo action determined, + * then it is an artificial action due to disjunctive goal + * conditions. + * + * these are already in final form. + */ + p = a; + a = a->next; + }/* endfor all actions ! */ + +} + + + +void instantiate_exp_by_action( ExpNode **n, Action *a ) + +{ + + int j, f, k, h; + Bool ok; + + switch ( (*n)->connective ) { + case AD: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + instantiate_exp_by_action( &((*n)->son), a ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + f = (*n)->fluent->function; + ok = TRUE; + for ( j = 0; j < gf_arity[f]; j++ ) { + h = ( (*n)->fluent->args[j] < 0 ) ? + a->inst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; + if ( h < 0 ) { + ok = FALSE; + } else { + (*n)->fluent->args[j] = h; + } + } + if ( !ok ) { + printf("\n\nnon-instantiated fluent in final actiona! debug me!!\n\n"); + exit( 1 ); + } + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\ninst. exp by action: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + + + + + + + + + + + + + + + + + + +/************************************************** + * CONNECTIVITY GRAPH. ULTRA CLEAN REPRESENTATION * + **************************************************/ + + + + + + + + + + + + + + + + + + + + +void build_connectivity_graph( void ) + +{ + + int i, j, k, l, n_op, n_ef, fl, ef, ef_, m; + float val; + Action *a; + ActionEffect *e; + + gnum_ft_conn = gnum_relevant_facts; + gnum_fl_conn = gnum_relevant_fluents; + gnum_op_conn = gnum_actions; + gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) ); + gfl_conn = ( FlConn * ) calloc( gnum_fl_conn, sizeof( FlConn ) ); + gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) ); + gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) ); + gnum_ef_conn = 0; + + for ( i = 0; i < gnum_ft_conn; i++ ) { + gft_conn[i].num_PC = 0; + gft_conn[i].num_A = 0; + gft_conn[i].num_D = 0; + + gft_conn[i].axiom_added = FALSE; + + gft_conn[i].rand = random() % BIG_INT; + } + + gnum_real_fl_conn = 0; + for ( i = 0; i < gnum_fl_conn; i++ ) { + gfl_conn[i].num_PC = 0; + gfl_conn[i].num_IN = 0; + gfl_conn[i].num_AS = 0; + + if ( grelevant_fluents_lnf[i] == NULL ) { + gfl_conn[i].artificial = FALSE; + gnum_real_fl_conn++; + gfl_conn[i].rand = random() % BIG_INT; + } else { + /* once we're in here we'll stay as all artificial + * fluents are appended to the end. + */ + gfl_conn[i].artificial = TRUE; + gfl_conn[i].lnf_F = ( int * ) + calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( int ) ); + gfl_conn[i].lnf_C = ( float * ) + calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( float ) ); + for ( j = 0; j < grelevant_fluents_lnf[i]->num_pF; j++ ) { + gfl_conn[i].lnf_F[j] = grelevant_fluents_lnf[i]->pF[j]; + gfl_conn[i].lnf_C[j] = grelevant_fluents_lnf[i]->pC[j]; + } + gfl_conn[i].num_lnf = grelevant_fluents_lnf[i]->num_pF; + } + } + + + /* why not do this here? + */ + gmneed_start_D = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + gmneed_start_V = ( float * ) calloc( gnum_real_fl_conn, sizeof( float ) ); + + + for ( i = 0; i < gnum_op_conn; i++ ) { + gop_conn[i].num_E = 0; + } + + for ( i = 0; i < lnum_effects; i++ ) { + gef_conn[i].num_PC = 0; + gef_conn[i].num_f_PC = 0; + gef_conn[i].num_A = 0; + gef_conn[i].num_D = 0; + gef_conn[i].num_I = 0; + gef_conn[i].num_IN = 0; + gef_conn[i].num_AS = 0; + + gef_conn[i].illegal = FALSE; + gef_conn[i].removed = FALSE; + } + + + /* determine if there are conditional effects. + */ + gconditional_effects = FALSE; + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->num_conditions > 0 ) { + break; + } + if ( e->num_lnf_conditions > 0 ) { + break; + } + } + if ( i < a->num_effects ) break; + } + if ( a ) { + printf("\n\ntask contains conditional effects. turning off state domination.\n\n"); + gconditional_effects = TRUE; + } + + n_op = 0; + n_ef = 0; + for ( a = gactions; a; a = a->next ) { + gop_conn[n_op].action = a; + gop_conn[n_op].axiom = a->axiom; + if ( a->num_effects == 0 ) { + continue; + } + + gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) ); + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + gef_conn[n_ef].cost = e->cost; + if ( e->removed ) { + /* this one disappeared through summarization + */ + continue; + } + gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef; + gef_conn[n_ef].op = n_op; + if ( e->illegal ) { + gef_conn[n_ef].illegal = TRUE; + } + + /*****************************CONDS********************************/ + gef_conn[n_ef].PC = ( int * ) + calloc( e->num_conditions + a->num_preconds, sizeof( int ) ); + for ( j = 0; j < a->num_preconds; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j]; + } + for ( j = 0; j < e->num_conditions; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j]; + } + /* similar thing for numeric conditions. + */ + gef_conn[n_ef].f_PC_comp = ( Comparator * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( Comparator ) ); + gef_conn[n_ef].f_PC_fl = ( int * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( int ) ); + gef_conn[n_ef].f_PC_c = ( float * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( float ) ); + gef_conn[n_ef].f_PC_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); + for ( j = 0; j < gnum_fl_conn; j++ ) { + gef_conn[n_ef].f_PC_direct_comp[j] = IGUAL; + } + gef_conn[n_ef].f_PC_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); + for ( j = 0; j < a->num_lnf_preconds; j++ ) { + if ( a->lnf_preconds_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final pre copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { + if ( gef_conn[n_ef].f_PC_fl[k] == a->lnf_preconds_lh[j]->pF[0] ) break; + } + if ( k < gef_conn[n_ef].num_f_PC ) { + if ( a->lnf_preconds_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { + /* weaker cond + */ + continue; + } + if ( a->lnf_preconds_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { + /* stronger cond + */ + gef_conn[n_ef].f_PC_c[k] = a->lnf_preconds_rh[j]; + gef_conn[n_ef].f_PC_comp[k] = a->lnf_preconds_comp[j]; + continue; + } + if ( a->lnf_preconds_comp[j] == GE ) { + /* we might need to strengthen our comp + */ + gef_conn[n_ef].f_PC_comp[k] = GE; + } + } else { + gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_comp[j]; + gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_lh[j]->pF[0]; + gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = a->lnf_preconds_rh[j]; + } + } + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final cond copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { + if ( gef_conn[n_ef].f_PC_fl[k] == e->lnf_conditions_lh[j]->pF[0] ) break; + } + if ( k < gef_conn[n_ef].num_f_PC ) { + if ( e->lnf_conditions_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { + continue; + } + if ( e->lnf_conditions_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { + gef_conn[n_ef].f_PC_c[k] = e->lnf_conditions_rh[j]; + gef_conn[n_ef].f_PC_comp[k] = e->lnf_conditions_comp[j]; + continue; + } + if ( e->lnf_conditions_comp[j] == GE ) { + gef_conn[n_ef].f_PC_comp[k] = GE; + } + } else { + gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_comp[j]; + gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_lh[j]->pF[0]; + gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = e->lnf_conditions_rh[j]; + } + } + /* now arrange the direct access structures from that. + */ + for ( j = 0; j < gef_conn[n_ef].num_f_PC; j++ ) { + gef_conn[n_ef].f_PC_direct_comp[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_comp[j]; + gef_conn[n_ef].f_PC_direct_c[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_c[j]; + } + /*****************************CONDS - END********************************/ + + + if ( e->illegal ) { + /* we don't care about the effects if they're illegal - + * all we care about is whether the condition is true or not. + */ + n_ef++; + gnum_ef_conn++; + continue; + } + /*****************************EFFECTS********************************/ + gef_conn[n_ef].A = ( int * ) calloc( e->num_adds, sizeof( int ) ); + gef_conn[n_ef].D = ( int * ) calloc( e->num_dels, sizeof( int ) ); + gef_conn[n_ef].IN_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].IN_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].IN_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); + gef_conn[n_ef].AS_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].AS_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].AS_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); + + /* duplicates removed in summarize already. + * + * but don't include adds that are in the conds. + * --- those are true anyway. + * + * and don't include dels that are in the adds + * --- those will be re-added anyway. + * + * NOTE: it is important that we use the *original* add list + * not the already reduced one, for the delete check! + * otherwise it may be that a delete that's in the add + * and also in the cond stays in! + * + * IT IS ALSO IMPORTANT THAT WE DO BOTH!!!, i.e. if we do + * the ads reduction then we *must* also do the dels + * reduction to avoid that things are deleted that + * would otherwise have been re-added. + */ + for ( j = 0; j < e->num_adds; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == e->adds[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j]; + } + for ( j = 0; j < e->num_dels; j++ ) { + for ( k = 0; k < e->num_adds; k++ ) { + if ( e->adds[k] == e->dels[j] ) break; + } + if ( k < e->num_adds ) continue; + gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j]; + } + + /* numeric part + */ + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_neft[j] != INCREASE ) continue; + gef_conn[n_ef].IN_fl[gef_conn[n_ef].num_IN] = e->lnf_effects_fl[j]; + if ( e->lnf_effects_rh[j]->num_pF == 1 ) { + if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { + printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); + exit( 1 ); + } + gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = e->lnf_effects_rh[j]->pF[0]; + } else { + if ( e->lnf_effects_rh[j]->num_pF != 0 ) { + printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); + exit( 1 ); + } + gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = -1; + } + gef_conn[n_ef].IN_c[gef_conn[n_ef].num_IN++] = e->lnf_effects_rh[j]->c; + } + /* now remove increasers by nothing. + */ + j = 0; + while ( j < gef_conn[n_ef].num_IN ) { + if ( gef_conn[n_ef].IN_fl_[j] != -1 || + gef_conn[n_ef].IN_c[j] != 0 ) { + j++; + continue; + } + for ( k = j; k < gef_conn[n_ef].num_IN - 1; k++ ) { + gef_conn[n_ef].IN_fl[k] = gef_conn[n_ef].IN_fl[k+1]; + gef_conn[n_ef].IN_fl_[k] = gef_conn[n_ef].IN_fl_[k+1]; + gef_conn[n_ef].IN_c[k] = gef_conn[n_ef].IN_c[k+1]; + } + gef_conn[n_ef].num_IN--; + } + /* now: the assigners... + */ + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_neft[j] != ASSIGN ) continue; + gef_conn[n_ef].AS_fl[gef_conn[n_ef].num_AS] = e->lnf_effects_fl[j]; + if ( e->lnf_effects_rh[j]->num_pF == 1 ) { + if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { + printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); + exit( 1 ); + } + gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = e->lnf_effects_rh[j]->pF[0]; + } else { + if ( e->lnf_effects_rh[j]->num_pF != 0 ) { + printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); + exit( 1 ); + } + gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = -1; + } + gef_conn[n_ef].AS_c[gef_conn[n_ef].num_AS++] = e->lnf_effects_rh[j]->c; + } + /*****************************EFFECTS - END********************************/ + + n_ef++; + gnum_ef_conn++; + }/* end all a->effects */ + + + /*****************************EMPTY EFFECTS********************************/ + if ( gop_conn[n_op].num_E >= 1 ) { + /* CHECK EMPTY EFFECTS! + * + * two step process --- first, remove all effects that are entirely empty. + * second, check if all remaining effects are illegal + * or only delete: + * in that case, the op will never do any good so we + * remove all its effects. + */ + i = 0; + while ( i < gop_conn[n_op].num_E ) { + /* illegal effects *must* stay in!!! + */ + if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { + i++; + continue; + } + if ( gef_conn[gop_conn[n_op].E[i]].num_A != 0 || + gef_conn[gop_conn[n_op].E[i]].num_D != 0 || + gef_conn[gop_conn[n_op].E[i]].num_IN != 0 || + gef_conn[gop_conn[n_op].E[i]].num_AS != 0 ) { + i++; + continue; + } + /* we keep it in the gef_conn (seems easier), + * but mark it as removed, which will exclude it from everything. + */ + gef_conn[gop_conn[n_op].E[i]].removed = TRUE; + for ( j = i; j < gop_conn[n_op].num_E - 1; j++ ) { + gop_conn[n_op].E[j] = gop_conn[n_op].E[j+1]; + } + gop_conn[n_op].num_E--; + } + + m = 0; + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { + m++; + continue; + } + if ( gef_conn[gop_conn[n_op].E[i]].num_A == 0 && + gef_conn[gop_conn[n_op].E[i]].num_IN == 0 && + gef_conn[gop_conn[n_op].E[i]].num_AS == 0 ) { + m++; + } + } + if ( m == gop_conn[n_op].num_E ) { + /* all remaining effects illegal or solely-deleters. + */ + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + gef_conn[gop_conn[n_op].E[i]].removed = TRUE; + } + gop_conn[n_op].num_E = 0; + } + } + /*****************************EMPTY EFFECTS - END********************************/ + + + /*****************************IMPLIED EFFECTS********************************/ + if ( gop_conn[n_op].num_E > 1 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + gef_conn[ef].I = ( int * ) calloc( gop_conn[n_op].num_E, sizeof( int ) ); + gef_conn[ef].num_I = 0; + } + for ( i = 0; i < gop_conn[n_op].num_E - 1; i++ ) { + ef = gop_conn[n_op].E[i]; + for ( j = i+1; j < gop_conn[n_op].num_E; j++ ) { + ef_ = gop_conn[n_op].E[j]; + /* ef ==> ef_ ? */ + for ( k = 0; k < gef_conn[ef_].num_PC; k++ ) { + for ( l = 0; l < gef_conn[ef].num_PC; l++ ) { + if ( gef_conn[ef].PC[l] == gef_conn[ef_].PC[k] ) break; + } + if ( l == gef_conn[ef].num_PC ) break; + } + if ( k == gef_conn[ef_].num_PC ) { + for ( k = 0; k < gnum_fl_conn; k++ ) { + if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL ) continue; + if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL || + gef_conn[ef].f_PC_direct_c[k] < gef_conn[ef_].f_PC_direct_c[k] || + ( gef_conn[ef].f_PC_direct_c[k] == gef_conn[ef_].f_PC_direct_c[k] && + gef_conn[ef].f_PC_direct_comp[k] == GEQ && + gef_conn[ef_].f_PC_direct_comp[k] == GE ) ) break; + } + if ( k == gnum_fl_conn ) { + gef_conn[ef].I[gef_conn[ef].num_I++] = ef_; + } + } + /* ef_ ==> ef ? */ + for ( k = 0; k < gef_conn[ef].num_PC; k++ ) { + for ( l = 0; l < gef_conn[ef_].num_PC; l++ ) { + if ( gef_conn[ef_].PC[l] == gef_conn[ef].PC[k] ) break; + } + if ( l == gef_conn[ef_].num_PC ) break; + } + if ( k == gef_conn[ef].num_PC ) { + for ( k = 0; k < gnum_fl_conn; k++ ) { + if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL ) continue; + if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL || + gef_conn[ef_].f_PC_direct_c[k] < gef_conn[ef].f_PC_direct_c[k] || + ( gef_conn[ef_].f_PC_direct_c[k] == gef_conn[ef].f_PC_direct_c[k] && + gef_conn[ef_].f_PC_direct_comp[k] == GEQ && + gef_conn[ef].f_PC_direct_comp[k] == GE ) ) break; + } + if ( k == gnum_fl_conn ) { + gef_conn[ef_].I[gef_conn[ef_].num_I++] = ef; + } + } + } + } + } + /*****************************IMPLIED EFFECTS - END********************************/ + + /* op cost is sum of eff costs + gtt*1: + * [gtt is multiplicator of TOTAL-TIME in final metric; if no + * total-time part in metric, it is 0] + * ie eff-costs plus the cost for the time taken by 1 more step. + */ + gop_conn[n_op].cost = gtt; + if ( gop_conn[n_op].num_E > 0 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + if ( gef_conn[ef].illegal ) { + continue; + } + if ( gef_conn[ef].removed ) { + continue; + } + gop_conn[n_op].cost += gef_conn[ef].cost; + } + } + + /* first sweep: only count the space we need for the fact arrays ! + */ + if ( gop_conn[n_op].num_E > 0 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + for ( j = 0; j < gef_conn[ef].num_PC; j++ ) { + gft_conn[gef_conn[ef].PC[j]].num_PC++; + } + for ( j = 0; j < gef_conn[ef].num_A; j++ ) { + gft_conn[gef_conn[ef].A[j]].num_A++; + if ( gop_conn[n_op].axiom ) { + gft_conn[gef_conn[ef].A[j]].axiom_added = TRUE; + } + } + for ( j = 0; j < gef_conn[ef].num_D; j++ ) { + gft_conn[gef_conn[ef].D[j]].num_D++; + } + /* similar increments for flconn + */ + for ( j = 0; j < gef_conn[ef].num_f_PC; j++ ) { + gfl_conn[gef_conn[ef].f_PC_fl[j]].num_PC++; + } + for ( j = 0; j < gef_conn[ef].num_IN; j++ ) { + gfl_conn[gef_conn[ef].IN_fl[j]].num_IN++; + } + for ( j = 0; j < gef_conn[ef].num_AS; j++ ) { + gfl_conn[gef_conn[ef].AS_fl[j]].num_AS++; + } + } + } + + + n_op++; + } + + /*****************************FLCONN********************************/ + for ( i = 0; i < gnum_ft_conn; i++ ) { + if ( gft_conn[i].num_PC > 0 ) { + gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) ); + } + gft_conn[i].num_PC = 0; + if ( gft_conn[i].num_A > 0 ) { + gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) ); + } + gft_conn[i].num_A = 0; + if ( gft_conn[i].num_D > 0 ) { + gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) ); + } + gft_conn[i].num_D = 0; + } + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gef_conn[i].removed ) continue; + for ( j = 0; j < gef_conn[i].num_PC; j++ ) { + gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i; + } + for ( j = 0; j < gef_conn[i].num_A; j++ ) { + gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i; + } + for ( j = 0; j < gef_conn[i].num_D; j++ ) { + gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i; + } + } + /*****************************FTCONN - END********************************/ + + + /*****************************FLCONN********************************/ + /* similar thing for flconn + */ + for ( i = 0; i < gnum_fl_conn; i++ ) { + if ( gfl_conn[i].num_PC > 0 ) { + gfl_conn[i].PC = ( int * ) calloc( gfl_conn[i].num_PC, sizeof( int ) ); + } + gfl_conn[i].num_PC = 0; + if ( gfl_conn[i].num_IN > 0 ) { + gfl_conn[i].IN = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); + gfl_conn[i].IN_fl_ = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); + gfl_conn[i].IN_c = ( float * ) calloc( gfl_conn[i].num_IN, sizeof( float ) ); + } + gfl_conn[i].num_IN = 0; + if ( gfl_conn[i].num_AS > 0 ) { + gfl_conn[i].AS = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); + gfl_conn[i].AS_fl_ = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); + gfl_conn[i].AS_c = ( float * ) calloc( gfl_conn[i].num_AS, sizeof( float ) ); + } + gfl_conn[i].num_AS = 0; + } + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gef_conn[i].removed ) continue; + /* PCs + */ + for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { + fl = gef_conn[i].f_PC_fl[j]; + gfl_conn[fl].PC[gfl_conn[fl].num_PC++] = i; + } + /* insert increasers by decreasing amount --> + * "best" - at least for constant part - are first! + */ + for ( j = 0; j < gef_conn[i].num_IN; j++ ) { + fl = gef_conn[i].IN_fl[j]; + val = gef_conn[i].IN_c[j]; + for ( k = 0; k < gfl_conn[fl].num_IN; k++ ) { + if ( gfl_conn[fl].IN_c[k] < val ) break; + } + for ( l = gfl_conn[fl].num_IN; l > k; l-- ) { + gfl_conn[fl].IN[l] = gfl_conn[fl].IN[l-1]; + gfl_conn[fl].IN_fl_[l] = gfl_conn[fl].IN_fl_[l-1]; + gfl_conn[fl].IN_c[l] = gfl_conn[fl].IN_c[l-1]; + } + gfl_conn[fl].IN[k] = i; + gfl_conn[fl].IN_fl_[k] = gef_conn[i].IN_fl_[j];/* the rh fluent */ + gfl_conn[fl].IN_c[k] = val; + gfl_conn[fl].num_IN++; + } + /* insert assigners by decreasing amount --> + * "best" - at least for constant part - are first! + */ + for ( j = 0; j < gef_conn[i].num_AS; j++ ) { + fl = gef_conn[i].AS_fl[j]; + val = gef_conn[i].AS_c[j]; + for ( k = 0; k < gfl_conn[fl].num_AS; k++ ) { + if ( gfl_conn[fl].AS_c[k] < val ) break; + } + for ( l = gfl_conn[fl].num_AS; l > k; l-- ) { + gfl_conn[fl].AS[l] = gfl_conn[fl].AS[l-1]; + gfl_conn[fl].AS_fl_[l] = gfl_conn[fl].AS_fl_[l-1]; + gfl_conn[fl].AS_c[l] = gfl_conn[fl].AS_c[l-1]; + } + gfl_conn[fl].AS[k] = i; + gfl_conn[fl].AS_fl_[k] = gef_conn[i].AS_fl_[j];/* the rh fluent */ + gfl_conn[fl].AS_c[k] = val; + gfl_conn[fl].num_AS++; + } + } + /*****************************FLCONN - END********************************/ + + + /*****************************GOAL********************************/ + gflogic_goal = ( int * ) calloc( gnum_logic_goal, sizeof( int ) ); + for ( j = 0; j < gnum_logic_goal; j++ ) { + for ( k = 0; k < gnum_flogic_goal; k++ ) { + if ( gflogic_goal[k] == glogic_goal[j] ) break; + } + if ( k < gnum_flogic_goal ) continue; + gflogic_goal[gnum_flogic_goal++] = glogic_goal[j]; + } + /* numeric part + */ + gfnumeric_goal_comp = ( Comparator * ) calloc( gnum_lnf_goal, sizeof( Comparator ) ); + gfnumeric_goal_fl = ( int * ) calloc( gnum_lnf_goal, sizeof( int ) ); + gfnumeric_goal_c = ( float * ) calloc( gnum_lnf_goal, sizeof( float ) ); + for ( j = 0; j < gnum_lnf_goal; j++ ) { + if ( glnf_goal_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final goal copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gnum_fnumeric_goal; k++ ) { + if ( gfnumeric_goal_fl[k] == glnf_goal_lh[j]->pF[0] ) break; + } + if ( k < gnum_fnumeric_goal ) { + if ( glnf_goal_rh[j] < gfnumeric_goal_c[k] ) continue; + if ( glnf_goal_rh[j] > gfnumeric_goal_c[k] ) { + gfnumeric_goal_comp[k] = glnf_goal_comp[j]; + gfnumeric_goal_c[k] = glnf_goal_rh[j]; + continue; + } + if ( glnf_goal_comp[j] == GE ) { + gfnumeric_goal_comp[k] = GE; + } + } else { + gfnumeric_goal_comp[gnum_fnumeric_goal] = glnf_goal_comp[j]; + gfnumeric_goal_fl[gnum_fnumeric_goal] = glnf_goal_lh[j]->pF[0]; + gfnumeric_goal_c[gnum_fnumeric_goal++] = glnf_goal_rh[j]; + } + } + gfnumeric_goal_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); + for ( j = 0; j < gnum_fl_conn; j++ ) { + gfnumeric_goal_direct_comp[j] = IGUAL; + } + gfnumeric_goal_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); + for ( k = 0; k < gnum_fnumeric_goal; k++ ) { + gfnumeric_goal_direct_comp[gfnumeric_goal_fl[k]] = gfnumeric_goal_comp[k]; + gfnumeric_goal_direct_c[gfnumeric_goal_fl[k]] = gfnumeric_goal_c[k]; + } + /*****************************GOAL - END********************************/ + + + + /******************** + * safety: if there are numeric precs/goals, need to turn + * cost-minimizing rplans off!!! + * (see comments with def of gcost_rplans + */ + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gcost_rplans && gef_conn[i].num_f_PC > 0 ) { + printf("\nwarning: numeric precondition. turning cost-minimizing relaxed plans OFF."); + gcost_rplans = FALSE; + break; + } + } + if ( gcost_rplans && gnum_fnumeric_goal > 0 ) { + printf("\nwarning: numeric goal. turning cost-minimizing relaxed plans OFF."); + gcost_rplans = FALSE; + } + + + + + if ( gcmd_line.display_info == 125 ) { + printf("\n\ncreated connectivity graph as follows:"); + + printf("\n\n------------------OP ARRAY:-----------------------"); + for ( i = 0; i < gnum_op_conn; i++ ) { + printf("\n\nOP %d: ", i); + if ( gop_conn[i].axiom ) printf("(axiom) "); + print_op_name( i ); + printf(" cost %f", gop_conn[i].cost); + printf("\n----------EFFS:"); + for ( j = 0; j < gop_conn[i].num_E; j++ ) { + printf("\neffect %d", gop_conn[i].E[j]); + } + } + + printf("\n\n-------------------EFFECT ARRAY:----------------------"); + for ( i = 0; i < gnum_ef_conn; i++ ) { + printf("\n\neffect %d of op %d cost %f: ", i, gef_conn[i].op, gef_conn[i].cost); + print_op_name( gef_conn[i].op ); + if ( gef_conn[i].illegal ) printf(" ******ILLEGAL************************"); + if ( gef_conn[i].removed ) printf(" ******REMOVED************************"); + printf("\n----------PCS:"); + for ( j = 0; j < gef_conn[i].num_PC; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].PC[j] ); + } + printf("\n----------f_PCS:"); + for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].f_PC_fl[j] ); + if ( gef_conn[i].f_PC_comp[j] == GEQ ) { + printf(" >= "); + } else { + printf(" > "); + } + printf("%f", gef_conn[i].f_PC_c[j]); + } + printf("\nDIRECT: "); + for ( j = 0; j < gnum_fl_conn; j++ ) { + if ( gef_conn[i].f_PC_direct_comp[j] == IGUAL ) { + printf("IGUAL | "); + } + if ( gef_conn[i].f_PC_direct_comp[j] == GEQ ) { + printf(">= %f | ", gef_conn[i].f_PC_direct_c[j]); + } + if ( gef_conn[i].f_PC_direct_comp[j] == GE ) { + printf("> %f | ", gef_conn[i].f_PC_direct_c[j]); + } + } + if ( gef_conn[i].illegal ) continue; + printf("\n----------ADDS:"); + for ( j = 0; j < gef_conn[i].num_A; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].A[j] ); + } + printf("\n----------DELS:"); + for ( j = 0; j < gef_conn[i].num_D; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].D[j] ); + } + printf("\n----------INCREASE:"); + for ( j = 0; j < gef_conn[i].num_IN; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].IN_fl[j] ); + printf(" by "); + if ( gef_conn[i].IN_fl_[j] >= 0 ) { + print_fl_name( gef_conn[i].IN_fl_[j] ); + printf(" + %f", gef_conn[i].IN_c[j]); + } else { + printf("%f", gef_conn[i].IN_c[j]); + } + } + printf("\n----------ASSIGN:"); + for ( j = 0; j < gef_conn[i].num_AS; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].AS_fl[j] ); + printf(" to "); + if ( gef_conn[i].AS_fl_[j] >= 0 ) { + print_fl_name( gef_conn[i].AS_fl_[j] ); + printf(" + %f", gef_conn[i].AS_c[j]); + } else { + printf("%f", gef_conn[i].AS_c[j]); + } + } + printf("\n----------IMPLIEDS:"); + for ( j = 0; j < gef_conn[i].num_I; j++ ) { + printf("\nimplied effect %d of op %d: ", + gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op); + print_op_name( gef_conn[gef_conn[i].I[j]].op ); + } + } + + printf("\n\n----------------------FT ARRAY:-----------------------------"); + for ( i = 0; i < gnum_ft_conn; i++ ) { + printf("\n\nFT: "); + print_ft_name( i ); + printf(" rand: %d", gft_conn[i].rand); + printf(" --------- AXIOM ADDED %d", gft_conn[i].axiom_added); + printf("\n----------PRE COND OF:"); + for ( j = 0; j < gft_conn[i].num_PC; j++ ) { + printf("\neffect %d", gft_conn[i].PC[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].PC[j]].op ); + } + printf("\n----------ADD BY:"); + for ( j = 0; j < gft_conn[i].num_A; j++ ) { + printf("\neffect %d", gft_conn[i].A[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].A[j]].op ); + } + printf("\n----------DEL BY:"); + for ( j = 0; j < gft_conn[i].num_D; j++ ) { + printf("\neffect %d", gft_conn[i].D[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].D[j]].op ); + } + } + + printf("\n\n----------------------FLUENT ARRAY:-----------------------------"); + for ( i = 0; i < gnum_fl_conn; i++ ) { + printf("\n\nFL: "); + print_fl_name( i ); + printf("\n----------PRE COND OF:"); + for ( j = 0; j < gfl_conn[i].num_PC; j++ ) { + printf("\neffect %d", gfl_conn[i].PC[j]); + printf(" - op "); print_op_name( gef_conn[gfl_conn[i].PC[j]].op ); + } + printf("\n----------INCREASED BY:"); + for ( j = 0; j < gfl_conn[i].num_IN; j++ ) { + if ( gfl_conn[i].IN_fl_[j] == -1 ) { + printf("\neffect %d --- %f", gfl_conn[i].IN[j], gfl_conn[i].IN_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); + } else { + printf("\neffect %d --- ", gfl_conn[i].IN[j]); + print_fl_name( gfl_conn[i].IN_fl_[j] ); + printf(" + %f", gfl_conn[i].IN_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); + } + } + printf("\n----------ASSIGNED BY:"); + for ( j = 0; j < gfl_conn[i].num_AS; j++ ) { + if ( gfl_conn[i].AS_fl_[j] == -1 ) { + printf("\neffect %d --- %f", gfl_conn[i].AS[j], gfl_conn[i].AS_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); + } else { + printf("\neffect %d --- ", gfl_conn[i].AS[j]); + print_fl_name( gfl_conn[i].AS_fl_[j] ); + printf(" + %f", gfl_conn[i].AS_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); + } + } + if ( gfl_conn[i].artificial ) { + printf("\n----------ARTIFICIAL FOR:"); + for ( j = 0; j < gfl_conn[i].num_lnf; j++ ) { + printf(" %f*", gfl_conn[i].lnf_C[j]); + print_fl_name( gfl_conn[i].lnf_F[j] ); + if ( j < gfl_conn[i].num_lnf - 1 ) { + printf(" +"); + } + } + } else { + printf("\n----------REAL"); + } + } + + printf("\n\n----------------------GOAL:-----------------------------"); + for ( j = 0; j < gnum_flogic_goal; j++ ) { + printf("\n"); + print_ft_name( gflogic_goal[j] ); + } + for ( j = 0; j < gnum_fnumeric_goal; j++ ) { + printf("\n"); + print_fl_name( gfnumeric_goal_fl[j] ); + if ( gfnumeric_goal_comp[j] == GEQ ) { + printf(" >= "); + } else { + printf(" > "); + } + printf("%f", gfnumeric_goal_c[j]); + } + printf("\nDIRECT: "); + for ( j = 0; j < gnum_fl_conn; j++ ) { + if ( gfnumeric_goal_direct_comp[j] == IGUAL ) { + printf("IGUAL | "); + } + if ( gfnumeric_goal_direct_comp[j] == GEQ ) { + printf(">= %f | ", gfnumeric_goal_direct_c[j]); + } + if ( gfnumeric_goal_direct_comp[j] == GE ) { + printf("> %f | ", gfnumeric_goal_direct_c[j]); + } + } + + printf("\n\n"); + } + +} + + + diff --git a/gen/ff_planner/inst_final.h b/gen/ff_planner/inst_final.h new file mode 100644 index 000000000..ab42b6097 --- /dev/null +++ b/gen/ff_planner/inst_final.h @@ -0,0 +1,69 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_final.h + * Description: headers for final domain representation functions + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + +#ifndef _INST_FINAL_H +#define _INST_FINAL_H + + + +void perform_reachability_analysis( void ); +int fact_adress( void ); +void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ); +void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ); + + + +void collect_relevant_facts_and_fluents( void ); +void create_final_goal_state( void ); +Bool set_relevants_in_wff( WffNode **w ); +Bool set_relevants_in_exp( ExpNode **n ); +void create_final_initial_state( void ); +void create_final_actions( void ); +void instantiate_exp_by_action( ExpNode **n, Action *a ); + + + +void build_connectivity_graph( void ); + + + +void summarize_effects( void ); +Bool same_condition( ActionEffect *e, ActionEffect *e_ ); +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); +void merge_effects( ActionEffect *e, ActionEffect *e_ ); + + + +#endif /* _INST_FINAL_H */ diff --git a/gen/ff_planner/inst_hard.c b/gen/ff_planner/inst_hard.c new file mode 100644 index 000000000..54f63d752 --- /dev/null +++ b/gen/ff_planner/inst_hard.c @@ -0,0 +1,1306 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: inst_hard.c + * Description: functions for multiplying hard operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_hard.h" + + + + + + + + + + + +/* used in multiplying routines + */ +int linst_table[MAX_VARS]; +int_pointer lini[MAX_PREDICATES]; + + + + + + + + +void build_hard_action_templates( void ) + +{ + + int i, j, size, adr; + MixedOperator *o; + + /* remove unused params; empty types are already recognised during + * domain translation; have to be handled after (or while) + * unaries encoding (if done), though. + */ + cleanup_hard_domain(); + + if ( gcmd_line.display_info == 115 ) { + printf("\n\ncleaned up hard domain representation is:\n\n"); + for ( i = 0; i < gnum_hard_operators; i++ ) { + print_Operator( ghard_operators[i] ); + } + fflush( stdout ); + } + + /* create local table of instantiated facts that occur in the + * initial state. for fast finding out if fact is in ini or not. + */ + for ( i = 0; i < gnum_predicates; i++ ) { + size = 1; + for ( j = 0; j < garity[i]; j++ ) { + size *= gnum_constants; + } + lini[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + for ( j = 0; j < size; j++ ) { + lini[i][j] = 0; + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + adr = instantiated_fact_adress( &ginitial_predicate[i][j] ); + lini[i][adr]++; + } + } + + + /* create mixed op for each param combination + */ + multiply_hard_op_parameters(); + + if ( gcmd_line.display_info == 116 ) { + printf("\n\nmixed hard domain representation is:\n\n"); + for ( o = ghard_mixed_operators; o; o = o->next ) { + print_MixedOperator( o ); + } + fflush( stdout ); + } + + /* create pseudo op for each mixed op + */ + multiply_hard_effect_parameters(); + + if ( gcmd_line.display_info == 117 ) { + printf("\n\npseudo hard domain representation is:\n\n"); + for ( i = 0; i < gnum_hard_templates; i++ ) { + print_PseudoAction( ghard_templates[i] ); + } + fflush( stdout ); + } + + +} + + + + + + + + + + + + +/**************** + * CLEANUP CODE * + ****************/ + + + + + + + + + + + + +void cleanup_hard_domain( void ) + +{ + + int i, j, k, par; + Operator *o; + Effect *e; + + /* so far, only unused parameters removal + */ + + for ( i = 0; i < gnum_hard_operators; i++ ) { + o = ghard_operators[i]; + + j = 0; + while ( j < o->num_vars ) { + if ( var_used_in_wff( ENCODE_VAR( j ), o->preconds ) ) { + j++; + continue; + } + + for ( e = o->effects; e; e = e->next ) { + if ( var_used_in_wff( ENCODE_VAR( j ), e->conditions ) ) { + break; + } + if ( var_used_in_literals( ENCODE_VAR( j ), e->effects ) ) { + break; + } + if ( var_used_in_numeric_effects( ENCODE_VAR( j ), e->numeric_effects ) ) { + break; + } + } + if ( e ) { + j++; + continue; + } + + o->removed[j] = TRUE; + j++; + } + + for ( e = o->effects; e; e = e->next ) { + j = 0; + while ( j < e->num_vars ) { + par = o->num_vars + j; + if ( var_used_in_wff( ENCODE_VAR( par ), e->conditions ) ) { + j++; + continue; + } + if ( var_used_in_literals( ENCODE_VAR( par ), e->effects ) ) { + j++; + continue; + } + if ( var_used_in_numeric_effects( ENCODE_VAR( par ), e->numeric_effects ) ) { + j++; + continue; + } + + if ( e->var_names[j] ) { + free( e->var_names[j] ); + } + for ( k = j; k < e->num_vars - 1; k++ ) { + e->var_names[k] = e->var_names[k+1]; + e->var_names[k] = e->var_names[k+1]; + } + e->num_vars--; + decrement_inferior_vars( par, e->conditions ); + decrement_inferior_vars_in_literals( par, e->effects ); + decrement_inferior_vars_in_numeric_effects( par, e->numeric_effects ); + } + } + } + +} + + + +Bool var_used_in_literals( int code_var, Literal *ef ) + +{ + + Literal *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + if ( l->fact.args[i] == code_var ) { + return TRUE; + } + } + } + + return FALSE; + +} + + + +Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ) + +{ + + NumericEffect *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { + if ( l->fluent.args[i] == code_var ) { + return TRUE; + } + } + if ( var_used_in_exp( code_var, l->rh ) ) { + return TRUE; + } + } + + return FALSE; + +} + + + +void decrement_inferior_vars_in_literals( int var, Literal *ef ) + +{ + + Literal *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + if ( l->fact.args[i] >= 0 ) { + continue; + } + if ( DECODE_VAR( l->fact.args[i] ) > var ) { + l->fact.args[i]++; + } + } + } + +} + + + +void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ) + +{ + + NumericEffect *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { + if ( l->fluent.args[i] >= 0 ) { + continue; + } + if ( DECODE_VAR( l->fluent.args[i] ) > var ) { + l->fluent.args[i]++; + } + } + decrement_inferior_vars_in_exp( var, l->rh ); + } + +} + + + + + + + + + + + + + + +/****************************** + * CODE THAT BUILDS MIXED OPS * + ******************************/ + + + + + + + + + + + + + + +void multiply_hard_op_parameters( void ) + +{ + + int i; + + ghard_mixed_operators = NULL; + + for ( i = 0; i < MAX_VARS; i++ ) { + linst_table[i] = -1; + } + + for ( i = 0; i < gnum_hard_operators; i++ ) { + create_hard_mixed_operators( ghard_operators[i], 0 ); + } + +} + + + +void create_hard_mixed_operators( Operator *o, int curr_var ) + +{ + + int t, i, m, mn; + WffNode *tmp1, *w, *ww; + MixedOperator *tmp2; + + if ( curr_var < o->num_vars ) { + if ( o->removed[curr_var] ) { + /* param doesn't matter -- select any appropriate type constant + * at least one there; otherwise, op would not have been translated. + */ + linst_table[curr_var] = gtype_consts[o->var_types[curr_var]][0]; + create_hard_mixed_operators( o, curr_var + 1 ); + linst_table[curr_var] = -1; + return; + } + + t = o->var_types[curr_var]; + for ( i = 0; i < gtype_size[t]; i++ ) { + linst_table[curr_var] = gtype_consts[t][i]; + + create_hard_mixed_operators( o, curr_var + 1 ); + + linst_table[curr_var] = -1; + } + return; + } + + + tmp1 = instantiate_wff( o->preconds ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + dnf( &tmp1 ); + cleanup_wff( &tmp1 ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + /* only debugging, REMOVE LATER + */ + if ( is_dnf( tmp1 ) == -1 ) { + printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", o->name); + print_Wff( tmp1, 0 ); + exit( 1 ); + } + + switch ( tmp1->connective ) { + case OR: + for ( w = tmp1->sons; w; w = w->next ) { + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + if ( w->connective == AND ) { + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_preconds = m; + tmp2->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp2->preconds[m].predicate = ww->fact->predicate; + for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { + tmp2->preconds[m].args[i] = ww->fact->args[i]; + } + m++; + } + if ( ww->connective == COMP ) { + tmp2->numeric_preconds_comp[mn] = ww->comp; + tmp2->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); + tmp2->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_preconds = 1; + tmp2->preconds[0].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->preconds[0].args[i] = w->fact->args[i]; + } + } + if ( w->connective == COMP ) { + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_comp[0] = w->comp; + tmp2->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp2->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp2->num_numeric_preconds = 1; + } + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + } + break; + case AND: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + m = 0; + mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_preconds = m; + tmp2->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + tmp2->preconds[m].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->preconds[m].args[i] = w->fact->args[i]; + } + m++; + } + if ( w->connective == COMP ) { + tmp2->numeric_preconds_comp[mn] = w->comp; + tmp2->numeric_preconds_lh[mn] = copy_Exp( w->lh ); + tmp2->numeric_preconds_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case ATOM: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_preconds = 1; + tmp2->preconds[0].predicate = tmp1->fact->predicate; + for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { + tmp2->preconds[0].args[i] = tmp1->fact->args[i]; + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case COMP: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_comp[0] = tmp1->comp; + tmp2->numeric_preconds_lh[0] = copy_Exp( tmp1->lh ); + tmp2->numeric_preconds_rh[0] = copy_Exp( tmp1->rh ); + tmp2->num_numeric_preconds = 1; + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case TRU: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + default: + printf("\n\nillegal connective %d in parsing DNF precond.\n\n", + tmp1->connective); + exit( 1 ); + } + + free_WffNode( tmp1 ); + +} + + + +Effect *instantiate_Effect( Effect *e ) + +{ + + Effect *res = NULL, *tmp, *i; + Literal *tt, *l; + NumericEffect *ne, *ttt; + int j; + + for ( i = e; i; i = i->next ) { + tmp = new_Effect(); + + for ( j = 0; j < i->num_vars; j++ ) { + tmp->var_types[j] = i->var_types[j]; + } + tmp->num_vars = i->num_vars; + + tmp->conditions = instantiate_wff( i->conditions ); + + if ( tmp->conditions->connective == FAL ) { + free_partial_Effect( tmp ); + continue; + } + + for ( l = i->effects; l; l = l->next ) { + tt = new_Literal(); + tt->negated = l->negated; + tt->fact.predicate = l->fact.predicate; + for ( j = 0; j < garity[tt->fact.predicate]; j++ ) { + tt->fact.args[j] = l->fact.args[j]; + if ( tt->fact.args[j] < 0 && + linst_table[DECODE_VAR( tt->fact.args[j] )] != -1 ) { + tt->fact.args[j] = linst_table[DECODE_VAR( tt->fact.args[j] )]; + } + } + tt->next = tmp->effects; + if ( tmp->effects ) { + tmp->effects->prev = tt; + } + tmp->effects = tt; + } + + for ( ne = i->numeric_effects; ne; ne = ne->next ) { + ttt = new_NumericEffect(); + ttt->neft = ne->neft; + ttt->fluent.function = ne->fluent.function; + for ( j = 0; j < gf_arity[ttt->fluent.function]; j++ ) { + ttt->fluent.args[j] = ne->fluent.args[j]; + if ( ttt->fluent.args[j] < 0 && + linst_table[DECODE_VAR( ttt->fluent.args[j] )] != -1 ) { + ttt->fluent.args[j] = linst_table[DECODE_VAR( ttt->fluent.args[j] )]; + } + } + ttt->rh = copy_Exp( ne->rh ); + instantiate_exp( &(ttt->rh) ); + ttt->next = tmp->numeric_effects; + if ( tmp->numeric_effects ) { + tmp->numeric_effects->prev = ttt; + } + tmp->numeric_effects = ttt; + } + + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + } + + return res; + +} + + + +WffNode *instantiate_wff( WffNode *w ) + +{ + + WffNode *res = NULL, *tmp, *i; + int j, m, h; + Bool ok, ct; + + switch ( w->connective ) { + case AND: + m = 0; + i = w->sons; + while ( i ) { + tmp = instantiate_wff( i ); + if ( tmp->connective == FAL ) { + free_WffNode( res ); + return tmp; + } + if ( tmp->connective == TRU ) { + free( tmp ); + i = i->next; + continue; + } + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + i = i->next; + m++; + } + if ( m == 0 ) { + res = new_WffNode( TRU ); + break; + } + if ( m == 1 ) { + break; + } + tmp = new_WffNode( AND ); + tmp->sons = res; + res = tmp; + break; + case OR: + m = 0; + i = w->sons; + while ( i ) { + tmp = instantiate_wff( i ); + if ( tmp->connective == TRU ) { + free_WffNode( res ); + return tmp; + } + if ( tmp->connective == FAL ) { + free( tmp ); + i = i->next; + continue; + } + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + i = i->next; + m++; + } + if ( m == 0 ) { + res = new_WffNode( FAL ); + break; + } + if ( m == 1 ) { + break; + } + tmp = new_WffNode( OR ); + tmp->sons = res; + res = tmp; + break; + case ATOM: + res = new_WffNode( ATOM ); + res->fact = new_Fact(); + res->fact->predicate = w->fact->predicate; + ok = TRUE; + for ( j = 0; j < garity[res->fact->predicate]; j++ ) { + h = ( w->fact->args[j] < 0 ) ? + linst_table[DECODE_VAR( w->fact->args[j] )] : w->fact->args[j]; + if ( h < 0 ) { + ok = FALSE; + res->fact->args[j] = w->fact->args[j]; + } else { + res->fact->args[j] = h; + } + } + if ( !ok ) {/* contains ef params */ + break; + } + if ( !full_possibly_negative( res->fact ) ) { + free( res->fact ); + res->fact = NULL; + res->connective = TRU; + break; + } + if ( !full_possibly_positive( res->fact ) ) { + free( res->fact ); + res->fact = NULL; + res->connective = FAL; + break; + } + break; + case COMP: + res = new_WffNode( COMP ); + res->comp = w->comp; + res->lh = copy_Exp( w->lh ); + res->rh = copy_Exp( w->rh ); + instantiate_exp( &(res->lh) ); + instantiate_exp( &(res->rh) ); + if ( res->lh->connective != NUMBER || + res->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( res->comp, res->lh->value, res->rh->value ); + if ( ct ) { + res->connective = TRU; + free_ExpNode( res->lh ); + res->lh = NULL; + free_ExpNode( res->rh ); + res->rh = NULL; + res->comp = -1; + } else { + res->connective = FAL; + free_ExpNode( res->lh ); + res->lh = NULL; + free_ExpNode( res->rh ); + res->rh = NULL; + res->comp = -1; + } + break; + case TRU: + case FAL: + res = new_WffNode( w->connective ); + break; + default: + printf("\n\nillegal connective %d in instantiate formula\n\n", + w->connective); + exit( 1 ); + } + + return res; + +} + + + +void instantiate_exp( ExpNode **n ) + +{ + + int j, f, k, h; + Bool ok; + + switch ( (*n)->connective ) { + case AD: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + instantiate_exp( &((*n)->son) ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + f = (*n)->fluent->function; + ok = TRUE; + for ( j = 0; j < gf_arity[f]; j++ ) { + h = ( (*n)->fluent->args[j] < 0 ) ? + linst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; + if ( h < 0 ) { + ok = FALSE; + } else { + (*n)->fluent->args[j] = h; + } + } + if ( !ok ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\ninst exp: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +Bool full_possibly_positive( Fact *f ) + +{ + + int adr; + + if ( gis_added[f->predicate] ) { + return TRUE; + } + + adr = instantiated_fact_adress( f ); + + if ( lini[f->predicate][adr] > 0 ) { + return TRUE; + } else { + return FALSE; + } + +} + + + +Bool full_possibly_negative( Fact *f ) + +{ + + int adr; + + if ( gis_deleted[f->predicate] ) { + return TRUE; + } + + adr = instantiated_fact_adress( f ); + + if ( lini[f->predicate][adr] > 0 ) { + return FALSE; + } else { + return TRUE; + } + +} + + + +int instantiated_fact_adress( Fact *f ) + +{ + + int r = 0, b = 1, i; + + for ( i = 0; i < garity[f->predicate]; i++ ) { + r += b * f->args[i]; + b *= gnum_constants; + } + + return r; + +} + + + + + + + + + + + + + + +/********************************************************* + * CODE THAT MULTIPLIES EFFECT PARAMS --> PSEUDO ACTIONS * + *********************************************************/ + + + + + + + + + + + + + + + +void multiply_hard_effect_parameters( void ) + +{ + + MixedOperator *o; + PseudoAction *tmp; + int i; + Effect *e; + + ghard_templates = ( PseudoAction_pointer * ) + calloc( gnum_hard_mixed_operators, sizeof ( PseudoAction_pointer ) ); + gnum_hard_templates = 0; + + for ( o = ghard_mixed_operators; o; o = o->next ) { + tmp = new_PseudoAction( o ); + + for ( i = 0; i < tmp->operator->num_vars; i++ ) { + linst_table[i] = tmp->inst_table[i]; + } + + for ( e = o->effects; e; e = e->next ) { + create_hard_pseudo_effects( tmp, e, 0 ); + } + + ghard_templates[gnum_hard_templates++] = tmp; + } +} + + + +void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ) + +{ + + int par, t, i, m, mn; + WffNode *tmp1, *w, *ww; + PseudoActionEffect *tmp2; + + if ( curr_var < e->num_vars ) { + par = a->operator->num_vars + curr_var; + + t = e->var_types[curr_var]; + for ( i = 0; i < gtype_size[t]; i++ ) { + linst_table[par] = gtype_consts[t][i]; + + create_hard_pseudo_effects( a, e, curr_var + 1 ); + + linst_table[par] = -1; + } + return; + } + + tmp1 = instantiate_wff( e->conditions ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + dnf( &tmp1 ); + cleanup_wff( &tmp1 ); + + /* only debugging, REMOVE LATER + */ + if ( is_dnf( tmp1 ) == -1 ) { + printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", a->operator->name); + print_Wff( tmp1, 0 ); + exit( 1 ); + } + + switch ( tmp1->connective ) { + case OR: + for ( w = tmp1->sons; w; w = w->next ) { + tmp2 = new_PseudoActionEffect(); + if ( w->connective == AND ) { + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_conditions = m; + tmp2->num_numeric_conditions = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp2->conditions[m].predicate = ww->fact->predicate; + for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { + tmp2->conditions[m].args[i] = ww->fact->args[i]; + } + m++; + } + if ( ww->connective == COMP ) { + tmp2->numeric_conditions_comp[mn] = ww->comp; + tmp2->numeric_conditions_lh[mn] = copy_Exp( ww->lh ); + tmp2->numeric_conditions_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_conditions = 1; + tmp2->conditions[0].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->conditions[0].args[i] = w->fact->args[i]; + } + } + if ( w->connective == COMP ) { + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_comp[0] = w->comp; + tmp2->numeric_conditions_lh[0] = copy_Exp( w->lh ); + tmp2->numeric_conditions_rh[0] = copy_Exp( w->rh ); + tmp2->num_numeric_conditions = 1; + } + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + } + break; + case AND: + tmp2 = new_PseudoActionEffect(); + m = 0; + mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_conditions = m; + tmp2->num_numeric_conditions = mn; + m = 0; mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + tmp2->conditions[m].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->conditions[m].args[i] = w->fact->args[i]; + } + m++; + } + if ( w->connective == COMP ) { + tmp2->numeric_conditions_comp[mn] = w->comp; + tmp2->numeric_conditions_lh[mn] = copy_Exp( w->lh ); + tmp2->numeric_conditions_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case ATOM: + tmp2 = new_PseudoActionEffect(); + tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_conditions = 1; + tmp2->conditions[0].predicate = tmp1->fact->predicate; + for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { + tmp2->conditions[0].args[i] = tmp1->fact->args[i]; + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case COMP: + tmp2 = new_PseudoActionEffect(); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_comp[0] = tmp1->comp; + tmp2->numeric_conditions_lh[0] = copy_Exp( tmp1->lh ); + tmp2->numeric_conditions_rh[0] = copy_Exp( tmp1->rh ); + tmp2->num_numeric_conditions = 1; + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case TRU: + tmp2 = new_PseudoActionEffect(); + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + default: + printf("\n\nillegal connective %d in parsing DNF condition.\n\n", + tmp1->connective); + exit( 1 ); + } + + free_WffNode( tmp1 ); + +} + + + +void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ) + +{ + + int ma = 0, md = 0, i; + Literal *l; + + for ( l = ll; l; l = l->next ) { + if ( l->negated ) { + md++; + } else { + ma++; + } + } + + e->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + e->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + + for ( l = ll; l; l = l->next ) { + if ( l->negated ) { + e->dels[e->num_dels].predicate = l->fact.predicate; + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + e->dels[e->num_dels].args[i] = ( l->fact.args[i] < 0 ) ? + linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; + } + e->num_dels++; + } else { + e->adds[e->num_adds].predicate = l->fact.predicate; + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + e->adds[e->num_adds].args[i] = ( l->fact.args[i] < 0 ) ? + linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; + } + e->num_adds++; + } + } + +} + + + +void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ) + +{ + + int m = 0, i; + NumericEffect *n; + + for ( n = ne; n; n = n->next ) m++; + + e->numeric_effects_neft = ( NumericEffectType * ) calloc( m, sizeof( NumericEffectType ) ); + e->numeric_effects_fluent = ( Fluent * ) calloc( m, sizeof( Fluent ) ); + e->numeric_effects_rh = ( ExpNode_pointer * ) calloc( m, sizeof( ExpNode_pointer ) ); + e->num_numeric_effects = m; + + m = 0; + for ( n = ne; n; n = n->next ) { + e->numeric_effects_neft[m] = n->neft; + e->numeric_effects_fluent[m].function = n->fluent.function; + for ( i = 0; i < gf_arity[n->fluent.function]; i++ ) { + e->numeric_effects_fluent[m].args[i] = ( n->fluent.args[i] < 0 ) ? + linst_table[DECODE_VAR( n->fluent.args[i] )] : n->fluent.args[i]; + } + e->numeric_effects_rh[m] = copy_Exp( n->rh ); + instantiate_exp( &(e->numeric_effects_rh[m]) ); + m++; + } + +} diff --git a/gen/ff_planner/inst_hard.h b/gen/ff_planner/inst_hard.h new file mode 100644 index 000000000..babebc20e --- /dev/null +++ b/gen/ff_planner/inst_hard.h @@ -0,0 +1,71 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: inst_hard.h + * Description: headers for multiplying hard operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + +#ifndef _INST_HARD_H +#define _INST_HARD_H + + + +void build_hard_action_templates( void ); + + + +void cleanup_hard_domain( void ); +Bool var_used_in_literals( int code_var, Literal *ef ); +Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ); +void decrement_inferior_vars_in_literals( int var, Literal *ef ); +void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ); + + + +void multiply_hard_op_parameters( void ); +void create_hard_mixed_operators( Operator *o, int curr_var ); +Effect *instantiate_Effect( Effect *e ); +WffNode *instantiate_wff( WffNode *w ); +void instantiate_exp( ExpNode **n ); +Bool full_possibly_positive( Fact *f ); +Bool full_possibly_negative( Fact *f ); +int instantiated_fact_adress( Fact *f ); + + + +void multiply_hard_effect_parameters( void ); +void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ); +void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ); +void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ); + + + +#endif /* _INST_HARD_H */ diff --git a/gen/ff_planner/inst_pre.c b/gen/ff_planner/inst_pre.c new file mode 100644 index 000000000..3e6877200 --- /dev/null +++ b/gen/ff_planner/inst_pre.c @@ -0,0 +1,3854 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_pre.c + * Description: functions for instantiating operators, preprocessing part. + * - transform domain into integers + * - inertia preprocessing: + * - collect inertia info + * - split initial state in special arrays + * - Wff normalization: + * - simplification + * - quantifier expansion + * - NOT s down + * - negative preconditions translation + * - split operators into easy and hard to instantiate + * + * - full DNF functions, only feasible for fully instantiated + * formulae + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" + + + + + + + + + + + + + + + + + + +/******************************************************* + * TRANSFORM DOMAIN INTO INTEGER (FACT) REPRESENTATION * + *******************************************************/ + + + + + + + + + +char *lvar_names[MAX_VARS]; +int lvar_types[MAX_VARS]; + + + + + + + + + + +void encode_domain_in_integers( void ) + +{ + + int i,j; + + collect_all_strings(); + create_member_nrs(); + + if ( gcmd_line.display_info == 103 ) { + printf("\nconstant table:"); + for ( i = 0; i < gnum_constants; i++ ) { + printf("\n%d --> %s", i, gconstants[i]); + } + + printf("\n\ntypes table:"); + for ( i = 0; i < gnum_types; i++ ) { + printf("\n%d --> %s: ", i, gtype_names[i]); + for ( j = 0; j < gtype_size[i]; j++ ) { + printf("%d ", gtype_consts[i][j]); + } + } + + printf("\n\npredicates table:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n%3d --> %s: ", i, gpredicates[i]); + for ( j = 0; j < garity[i]; j++ ) { + printf("%s ", gtype_names[gpredicates_args_type[i][j]]); + } + } + + printf("\n\nfunctions table:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n%3d --> %s: ", i, gfunctions[i]); + for ( j = 0; j < gf_arity[i]; j++ ) { + printf("%s ", gtype_names[gfunctions_args_type[i][j]]); + } + } + printf("\n\n"); + } + + create_integer_representation(); + + if ( gcmd_line.display_info == 104 ) { + printf("\n\nfirst step initial state is:"); + for ( i = 0; i < gnum_full_initial; i++ ) { + printf("\n"); + print_Fact( &(gfull_initial[i]) ); + } + printf("\n\nfirst step fluent initial state is:"); + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + printf("\n"); + print_Fluent( &(gfull_fluents_initial[i].fluent) ); + printf(": %f", gfull_fluents_initial[i].value); + } + + printf("\n\nfirst step operators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\n\nfirst step goal is:\n"); + print_Wff( ggoal, 0 ); + fflush( stdout ); + + printf("\n\nfirst step metric is: (normalized to minimize)\n"); + print_ExpNode( gmetric ); + fflush( stdout ); + } + +} + + + +void create_member_nrs( void ) + +{ + + int i, j, num; + + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + for ( j = 0; j < MAX_TYPES; j++ ) { + gmember_nr[i][j] = -1; + } + } + + for ( i = 0; i < gnum_types; i++ ) { + num = 0; + for ( j = 0; j < gtype_size[i]; j++ ) { + gmember_nr[gtype_consts[i][j]][i] = num; + num++; + } + } + +} + + + +void collect_all_strings( void ) + +{ + + FactList *f; + TokenList *t; + int p_num, type_num, c_num, ar; + int i; + + /* first are types and their objects. for = we make sure that there + * is one type that contains all objects. + */ + gtype_names[0] = new_Token( 50 ); + gtype_names[0] = "ARTFICIAL-ALL-OBJECTS"; + gtype_size[0] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][0] = FALSE; + } + gnum_types = 1; + + for ( f = gorig_constant_list; f; f = f->next ) { + if ( (type_num = position_in_types_table( f->item->next->item )) == -1 ) { + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_names[gnum_types] = new_Token( strlen( f->item->next->item ) + 1 ); + strcpy( gtype_names[gnum_types], f->item->next->item ); + gtype_size[gnum_types] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][gnum_types] = FALSE; + } + type_num = gnum_types++; + } + + if ( (c_num = position_in_constants_table( f->item->item )) == -1 ) { + if ( gnum_constants == MAX_CONSTANTS ) { + printf("\ntoo many constants! increase MAX_CONSTANTS (currently %d)\n\n", + MAX_CONSTANTS); + exit( 1 ); + } + gconstants[gnum_constants] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gconstants[gnum_constants], f->item->item ); + c_num = gnum_constants++; + + /* all constants into 0-type. + */ + if ( gtype_size[0] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[0], MAX_TYPE); + exit( 1 ); + } + gtype_consts[0][gtype_size[0]++] = c_num; + gis_member[c_num][0] = TRUE; + } + + if ( !gis_member[c_num][type_num] ) { + if ( gtype_size[type_num] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[type_num], MAX_TYPE); + exit( 1 ); + } + gtype_consts[type_num][gtype_size[type_num]++] = c_num; + gis_member[c_num][type_num] = TRUE; + } + } + + /* next are predicates; first of all, create in-built predicate = + */ + gpredicates[0] = new_Token( 5 ); + gpredicates[0] = "="; + gpredicates_args_type[0][0] = 0;/* all objects type */ + gpredicates_args_type[0][1] = 0; + garity[0] = 2; + gnum_predicates = 1; + + for ( f = gpredicates_and_types; f; f = f->next ) { + if ( (p_num = position_in_predicates_table( f->item->item )) != -1 ) { + printf("\npredicate %s declared twice!\n\n", f->item->item); + exit( 1 ); + } + if ( gnum_predicates == MAX_PREDICATES ) { + printf("\ntoo many predicates! increase MAX_PREDICATES (currently %d)\n\n", + MAX_PREDICATES); + exit( 1 ); + } + gpredicates[gnum_predicates] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gpredicates[gnum_predicates], f->item->item ); + ar = 0; + for ( t = f->item->next; t; t = t->next ) { + if ( (type_num = position_in_types_table( t->item )) == -1 ) { + printf("\npredicate %s is declared to use unknown or empty type %s\n\n", + f->item->item, t->item); + exit( 1 ); + } + if ( ar == MAX_ARITY ) { + printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", + gpredicates[gnum_predicates], MAX_ARITY); + exit( 1 ); + } + gpredicates_args_type[gnum_predicates][ar++] = type_num; + } + garity[gnum_predicates] = ar; + gaxiom_added[gnum_predicates] = FALSE; + gnum_predicates++; + } + + + /* next are functions; first of all, create in-built function total-time + * for sole use in metric + */ + gfunctions[0] = new_Token( 20 ); + gfunctions[0] = "TOTAL-TIME"; + gf_arity[0] = 0; + gnum_functions = 1; + + for ( f = gfunctions_and_types; f; f = f->next ) { + if ( (p_num = position_in_functions_table( f->item->item )) != -1 ) { + printf("\nfunction %s declared twice!\n\n", f->item->item); + exit( 1 ); + } + if ( gnum_functions == MAX_FUNCTIONS ) { + printf("\ntoo many functions! increase MAX_FUNCTIONS (currently %d)\n\n", + MAX_FUNCTIONS); + exit( 1 ); + } + gfunctions[gnum_functions] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gfunctions[gnum_functions], f->item->item ); + ar = 0; + for ( t = f->item->next; t; t = t->next ) { + if ( (type_num = position_in_types_table( t->item )) == -1 ) { + printf("\nfunction %s is declared to use unknown or empty type %s\n\n", + f->item->item, t->item); + exit( 1 ); + } + if ( ar == MAX_ARITY ) { + printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", + gfunctions[gnum_functions], MAX_ARITY); + exit( 1 ); + } + gfunctions_args_type[gnum_functions][ar++] = type_num; + } + gf_arity[gnum_functions++] = ar; + } + + free_FactList( gorig_constant_list ); + free_FactList( gpredicates_and_types ); + free_FactList( gfunctions_and_types ); + +} + + + +int position_in_types_table( char *str ) + +{ + + int i; + + /* start at 1 because 0 is our artificial one + */ + for ( i = 1; i < gnum_types; i++ ) { + if ( str == gtype_names[i] || + (strcmp( str, gtype_names[i] ) == SAME) ) { + break; + } + } + + return ( i == gnum_types ) ? -1 : i; + +} + + + +int position_in_constants_table( char *str ) + +{ + + int i; + + for ( i=0; isons; n; n = n->next ) sum++; + sum += gnum_constants;/* space for equalities */ + gfull_initial = ( Fact * ) calloc( sum, sizeof( Fact ) ); + gfull_fluents_initial = ( FluentValue * ) + calloc( sum, sizeof( FluentValue )); + + for ( n = gorig_initial_facts->sons; n; n = n->next ) { + if ( n->connective == ATOM ) { + make_Fact( &(gfull_initial[gnum_full_initial]), n, 0 ); + if ( gfull_initial[gnum_full_initial].predicate == 0 ) { + printf("\nequality in initial state! check input files.\n\n"); + exit( 1 ); + } + + /* duplicate check!! + */ + for ( i = 0; i < gnum_full_initial; i++ ) { + if ( gfull_initial[i].predicate != gfull_initial[gnum_full_initial].predicate ) { + /* predicate different --> this ini fact is not a duplicate! + */ + continue; + } + for ( j = 0; j < garity[gfull_initial[i].predicate]; j++ ) { + if ( gfull_initial[i].args[j] != gfull_initial[gnum_full_initial].args[j] ) { + /* arg different --> this ini fact is not a duplicate! + */ + break; + } + } + if ( j == garity[gfull_initial[i].predicate] ) { + /* found a duplicate! + */ + break; + } + } + if ( i < gnum_full_initial ) { + /* simply skip the second occurence... + */ + continue; + } + + gnum_full_initial++; + } else { + /* a fluent value assignment + */ + make_Fluent( &(gfull_fluents_initial[gnum_full_fluents_initial].fluent), + n->lh->atom, 0 ); + gfull_fluents_initial[gnum_full_fluents_initial].value = + ( float ) strtod( n->rh->atom->item, NULL); + gnum_full_fluents_initial++; + } + } + free_PlNode( gorig_initial_facts ); + } + + /* now insert all our artificial equality constraints into initial state. + */ + for ( i = 0; i < gnum_constants; i++ ) { + gfull_initial[gnum_full_initial].predicate = 0; + gfull_initial[gnum_full_initial].args[0] = i; + gfull_initial[gnum_full_initial].args[1] = i; + gnum_full_initial++; + } + /* FINITO. the rest of equality handling will fully + * automatically be done by the rest of the machinery. + */ + + ggoal = make_Wff( gorig_goal_facts, 0 ); + + if ( gparse_metric != NULL ) { + /* no need to throw costs away, even if we're not explicitly asked to + * minimize them + */ + if ( 0 && !gcost_minimizing ) { + if ( gcmd_line.display_info ) { + printf("\n\nno optimization required. skipping criterion.\n\n"); + } + } else { + gmetric = make_ExpNode( gparse_metric, 0 ); + if ( strcmp( gparse_optimization, "MINIMIZE" ) != SAME && + strcmp( gparse_optimization, "minimize" ) != SAME && + strcmp( gparse_optimization, "MAXIMIZE" ) != SAME && + strcmp( gparse_optimization, "maximize" ) != SAME ) { + if ( gcmd_line.display_info ) { + printf("\n\nunknown optimization method %s. check input files\n\n", + gparse_optimization); + } + exit( 1 ); + } + if ( strcmp( gparse_optimization, "MAXIMIZE" ) == SAME || + strcmp( gparse_optimization, "maximize" ) == SAME ) { + t = new_ExpNode( MINUS ); + t->son = gmetric; + gmetric = t; + } + } + } + + for ( o = gloaded_ops; o; o = o->next ) { + tmp = new_Operator( o->name, o->number_of_real_params ); + tmp->axiom = o->axiom; + + for ( ff = o->params; ff; ff = ff->next ) { + if ( (type_num = position_in_types_table( ff->item->next->item )) == -1 ) { + printf("\nwarning: parameter %s of op %s has unknown or empty type %s. skipping op", + ff->item->item, o->name, ff->item->next->item); + break; + } + if ( tmp->num_vars == MAX_VARS ) { + printf("\ntoo many parameters! increase MAX_VARS (currently %d)\n\n", + MAX_VARS); + exit( 1 ); + } + for ( i = 0; i < tmp->num_vars; i++ ) { + if ( tmp->var_names[i] == ff->item->item || + strcmp( tmp->var_names[i], ff->item->item ) == SAME ) { + printf("\nwarning: operator %s parameter %s overwrites previous declaration\n\n", + tmp->name, ff->item->item); + } + } + tmp->var_names[tmp->num_vars] = new_Token( strlen( ff->item->item ) + 1 ); + strcpy( tmp->var_names[tmp->num_vars], ff->item->item ); + tmp->var_types[tmp->num_vars++] = type_num; + } + if ( ff ) { + free_Operator( tmp ); + continue; + } + + for ( i = 0; i < tmp->num_vars; i++ ) { + lvar_types[i] = tmp->var_types[i]; + lvar_names[i] = tmp->var_names[i]; + } + + tmp->preconds = make_Wff( o->preconds, tmp->num_vars ); + + if ( o->effects ) { + /* in make_effect, make sure that no one afects equality. + */ + nn = o->effects->sons; + while ( nn && + (tmp->effects = make_effect( nn, tmp->num_vars )) == NULL ) { + nn = nn->next; + } + if ( nn ) { + for ( n = nn->next; n; n = n->next ) { + if ( (tmp->effects->prev = make_effect( n, tmp->num_vars )) == NULL ) { + continue; + } + tmp->effects->prev->next = tmp->effects; + tmp->effects = tmp->effects->prev; + } + } + } + + if ( gnum_operators == MAX_OPERATORS ) { + printf("\ntoo many operators! increase MAX_OPERATORS (currently %d)\n\n", + MAX_OPERATORS); + exit( 1 ); + } + goperators[gnum_operators++] = tmp; + } + + if ( 0 ) { + /* currently not in use; leads to free memory reads and + * free memory frees (no memory leaks), which are hard to explain. + * + * almost no memory consumption anyway. + */ + free_PlOperator( gloaded_ops ); + } + + /* establish gaxiom_added markers. + * ascertain that derived predicates do not appear in effects!! + */ + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( goperators[i]->axiom ) { + gaxiom_added[l->fact.predicate] = TRUE; + } + } + } + } + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( !goperators[i]->axiom && + gaxiom_added[l->fact.predicate] ) { + printf("\nA derived predicate appears in an operator effect."); + printf("\nSorry, this is not allowed. Bailing out.\n\n"); + exit( 1 ); + } + } + } + } + +} + + + +void make_Fact( Fact *f, PlNode *n, int num_vars ) + +{ + + int m, i; + TokenList *t; + + if ( !n->atom ) { + /* can't happen after previous syntax check. Oh well, whatever... + */ + printf("\nillegal (empty) atom used in domain. check input files\n\n"); + exit( 1 ); + } + + f->predicate = position_in_predicates_table( n->atom->item ); + if ( f->predicate == -1 ) { + printf("\nundeclared predicate %s used in domain definition\n\n", + n->atom->item); + exit( 1 ); + } + + m = 0; + for ( t = n->atom->next; t; t = t->next ) { + if ( t->item[0] == '?' ) { + for ( i=num_vars-1; i>-1; i-- ) { + /* downwards, to always get most recent declaration/quantification + * of that variable + */ + if ( lvar_names[i] == t->item || + strcmp( lvar_names[i], t->item ) == SAME ) { + break; + } + } + if ( i == -1 ) { + printf("\nundeclared variable %s in literal %s. check input files\n\n", + t->item, n->atom->item); + exit( 1 ); + } + if ( lvar_types[i] != gpredicates_args_type[f->predicate][m] && + !is_subtype( lvar_types[i], gpredicates_args_type[f->predicate][m] ) ) { + printf("\ntype of var %s does not match type of arg %d of predicate %s\n\n", + lvar_names[i], m, gpredicates[f->predicate]); + exit( 1 ); + } + f->args[m] = ENCODE_VAR( i ); + } else { + if ( (f->args[m] = + position_in_constants_table( t->item )) == -1 ) { + printf("\nunknown constant %s in literal %s. check input files\n\n", + t->item, n->atom->item); + exit( 1 ); + } + if ( !gis_member[f->args[m]][gpredicates_args_type[f->predicate][m]] ) { + printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", + gconstants[f->args[m]], m, gpredicates[f->predicate]); + exit( 1 ); + } + } + m++; + } + if ( m != garity[f->predicate] ) { + printf("\npredicate %s is declared to have %d (not %d) arguments. check input files\n\n", + gpredicates[f->predicate], + garity[f->predicate], m); + exit( 1 ); + } + +} + + + +void make_Fluent( Fluent *f, TokenList *atom, int num_vars ) + +{ + + int m, i; + TokenList *t; + + if ( !atom ) { + /* can't happen after previous syntax check. Oh well, whatever... + */ + printf("\nillegal (empty) atom used in domain. check input files\n\n"); + exit( 1 ); + } + + f->function = position_in_functions_table( atom->item ); + if ( f->function == -1 ) { + printf("\nundeclared function %s used in domain definition\n\n", + atom->item); + exit( 1 ); + } + + m = 0; + for ( t = atom->next; t; t = t->next ) { + if ( t->item[0] == '?' ) { + for ( i=num_vars-1; i>-1; i-- ) { + /* downwards, to always get most recent declaration/quantification + * of that variable + */ + if ( lvar_names[i] == t->item || + strcmp( lvar_names[i], t->item ) == SAME ) { + break; + } + } + if ( i == -1 ) { + printf("\nundeclared variable %s in function %s. check input files\n\n", + t->item, atom->item); + exit( 1 ); + } + if ( lvar_types[i] != gfunctions_args_type[f->function][m] && + !is_subtype( lvar_types[i], gfunctions_args_type[f->function][m] ) ) { + printf("\ntype of var %s does not match type of arg %d of function %s\n\n", + lvar_names[i], m, gfunctions[f->function]); + exit( 1 ); + } + f->args[m] = ENCODE_VAR( i ); + } else { + if ( (f->args[m] = + position_in_constants_table( t->item )) == -1 ) { + printf("\nunknown constant %s in function %s. check input files\n\n", + t->item, atom->item); + exit( 1 ); + } + if ( !gis_member[f->args[m]][gfunctions_args_type[f->function][m]] ) { + printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", + gconstants[f->args[m]], m, gfunctions[f->function]); + exit( 1 ); + } + } + m++; + } + + if ( m != gf_arity[f->function] ) { + printf("\nfunction %s is declared to have %d (not %d) arguments. check input files\n\n", + gfunctions[f->function], + gf_arity[f->function], m); + exit( 1 ); + } + +} + + + +Bool is_subtype( int t1, int t2 ) + +{ + + int i; + + for ( i = 0; i < gtype_size[t1]; i++ ) { + if ( !gis_member[gtype_consts[t1][i]][t2] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +WffNode *make_Wff( PlNode *p, int num_vars ) + +{ + + WffNode *tmp; + int i, t; + PlNode *n; + + if ( !p ) { + tmp = NULL; + return tmp; + } + + tmp = new_WffNode( p->connective ); + switch ( p->connective ) { + case ALL: + case EX: + for ( i = 0; i < num_vars; i++ ) { + if ( lvar_names[i] == p->atom->item || + strcmp( lvar_names[i], p->atom->item ) == SAME ) { + printf("\nwarning: var quantification of %s overwrites previous declaration\n\n", + p->atom->item); + } + } + if ( (t = position_in_types_table( p->atom->next->item )) == -1 ) { + printf("\nwarning: quantified var %s has unknown or empty type %s. simplifying.\n\n", + p->atom->item, p->atom->next->item); + tmp->connective = ( p->connective == EX ) ? FAL : TRU; + break; + } + tmp->var = num_vars; + tmp->var_type = t; + tmp->var_name = new_Token( strlen( p->atom->item ) + 1 ); + strcpy( tmp->var_name, p->atom->item ); + lvar_names[num_vars] = p->atom->item; + lvar_types[num_vars] = t; + tmp->son = make_Wff( p->sons, num_vars + 1 ); + break; + case AND: + case OR: + if ( !p->sons ) { + printf("\nwarning: empty con/disjunction in domain definition. simplifying.\n\n"); + tmp->connective = ( p->connective == OR ) ? FAL : TRU; + break; + } + tmp->sons = make_Wff( p->sons, num_vars ); + for ( n = p->sons->next; n; n = n->next ) { + tmp->sons->prev = make_Wff( n, num_vars ); + tmp->sons->prev->next = tmp->sons; + tmp->sons = tmp->sons->prev; + } + break; + case NOT: + tmp->son = make_Wff( p->sons, num_vars ); + break; + case ATOM: + tmp->fact = new_Fact(); + make_Fact( tmp->fact, p, num_vars ); + break; + case TRU: + case FAL: + break; + case COMP: + tmp->comp = p->comp; + tmp->lh = make_ExpNode( p->lh, num_vars ); + tmp->rh = make_ExpNode( p->rh, num_vars ); + break; + default: + printf("\nforbidden connective %d in Pl Wff. must be a bug somewhere...\n\n", + p->connective); + exit( 1 ); + } + + return tmp; + +} + + + +ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ) + +{ + + ExpNode *tmp; + + if ( !p ) { + tmp = NULL; + return tmp; + } + + tmp = new_ExpNode( p->connective ); + switch ( p->connective ) { + case AD: + case SU: + case MU: + case DI: + tmp->leftson = make_ExpNode( p->leftson, num_vars ); + tmp->rightson = make_ExpNode( p->rightson, num_vars ); + break; + case MINUS: + tmp->son = make_ExpNode( p->leftson, num_vars ); + break; + case NUMBER: + tmp->value = ( float ) strtod( p->atom->item, NULL ); + break; + case FHEAD: + tmp->fluent = new_Fluent(); + make_Fluent( tmp->fluent, p->atom, num_vars ); + break; + default: + printf("\n\nmake expnode: wrong specifier %d", + p->connective); + exit( 1 ); + } + + return tmp; + +} + + + +Effect *make_effect( PlNode *p, int num_vars ) + +{ + + Effect *tmp = new_Effect(); + PlNode *n, *m; + int t, i; + + for ( n = p; n && n->connective == ALL; n = n->sons ) { + if ( (t = position_in_types_table( n->atom->next->item )) == -1 ) { + printf("\nwarning: effect parameter %s has unknown or empty type %s. skipping effect.\n\n", + n->atom->item, n->atom->next->item); + return NULL; + } + for ( i = 0; i < num_vars + tmp->num_vars; i++ ) { + if ( lvar_names[i] == n->atom->item || + strcmp( lvar_names[i], n->atom->item ) == SAME ) { + printf("\nwarning: effect parameter %s overwrites previous declaration\n\n", + n->atom->item); + } + } + lvar_types[num_vars + tmp->num_vars] = t; + lvar_names[num_vars + tmp->num_vars] = n->atom->item; + tmp->var_names[tmp->num_vars] = new_Token( strlen( n->atom->item ) + 1 ); + strcpy( tmp->var_names[tmp->num_vars], n->atom->item ); + tmp->var_types[tmp->num_vars++] = t; + } + + if ( !n || n->connective != WHEN ) { + printf("\nnon WHEN %d at end of effect parameters. debug me\n\n", + n->connective); + exit( 1 ); + } + + tmp->conditions = make_Wff( n->sons, num_vars + tmp->num_vars ); + + if ( n->sons->next->connective != AND ) { + printf("\nnon AND %d in front of literal effect list. debug me\n\n", + n->sons->next->connective); + exit( 1 ); + } + if ( !n->sons->next->sons ) { + return tmp; + } + for ( m = n->sons->next->sons; m; m = m->next ) { + if ( m->connective == NEF ) { + if ( tmp->numeric_effects != NULL ) { + tmp->numeric_effects->prev = new_NumericEffect(); + make_Fluent( &(tmp->numeric_effects->prev->fluent), + m->lh->atom, num_vars + tmp->num_vars ); + tmp->numeric_effects->prev->neft = m->neft; + tmp->numeric_effects->prev->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); + + tmp->numeric_effects->prev->next = tmp->numeric_effects; + tmp->numeric_effects = tmp->numeric_effects->prev; + } else { + tmp->numeric_effects = new_NumericEffect(); + make_Fluent( &(tmp->numeric_effects->fluent), + m->lh->atom, num_vars + tmp->num_vars ); + tmp->numeric_effects->neft = m->neft; + tmp->numeric_effects->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); + } + } else { + if ( tmp->effects != NULL ) { + tmp->effects->prev = new_Literal(); + if ( m->connective == NOT ) { + tmp->effects->prev->negated = TRUE; + make_Fact( &(tmp->effects->prev->fact), m->sons, num_vars + tmp->num_vars ); + if ( (tmp->effects->prev->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } else { + tmp->effects->prev->negated = FALSE; + make_Fact( &(tmp->effects->prev->fact), m, num_vars + tmp->num_vars ); + if ( (tmp->effects->prev->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } + tmp->effects->prev->next = tmp->effects; + tmp->effects = tmp->effects->prev; + } else { + tmp->effects = new_Literal(); + if ( m->connective == NOT ) { + tmp->effects->negated = TRUE; + make_Fact( &(tmp->effects->fact), m->sons, num_vars + tmp->num_vars ); + if ( (tmp->effects->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } else { + tmp->effects->negated = FALSE; + make_Fact( &(tmp->effects->fact), m, num_vars + tmp->num_vars ); + if ( (tmp->effects->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } + } + } + } + + return tmp; + +} + + + + + + + + + + + +/************************* + * INERTIA PREPROCESSING * + *************************/ + + + + + + + + + + + +void do_inertia_preprocessing_step_1( void ) + +{ + + int i, j; + Facts *f; + FluentValues *ff; + + collect_inertia_information(); + + if ( gcmd_line.display_info == 105 ) { + printf("\n\npredicates inertia info:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n%3d --> %s: ", i, gpredicates[i]); + printf(" is %s, %s", + gis_added[i] ? "ADDED" : "NOT ADDED", + gis_deleted[i] ? "DELETED" : "NOT DELETED"); + } + printf("\n\nfunctions inertia info:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n%3d --> %s: ", i, gfunctions[i]); + printf(" is %s", + gis_changed[i] ? "CHANGED" : "NOT CHANGED"); + } + printf("\n\n"); + } + + split_initial_state(); + + if ( gcmd_line.display_info == 106 ) { + printf("\n\nsplitted initial state is:"); + printf("\nindividual predicates:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n\n%s:", gpredicates[i]); + if ( !gis_added[i] && + !gis_deleted[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + printf("\n"); + print_Fact( &(ginitial_predicate[i][j]) ); + } + } + printf("\n\nnon static part:"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + + printf("\n\nextended types table:"); + for ( i = 0; i < gnum_types; i++ ) { + printf("\n%d --> ", i); + if ( gpredicate_to_type[i] == -1 ) { + printf("%s ", gtype_names[i]); + } else { + printf("UNARY INERTIA TYPE (%s) ", gpredicates[gpredicate_to_type[i]]); + } + for ( j = 0; j < gtype_size[i]; j++ ) { + printf("%d ", gtype_consts[i][j]); + } + } + + printf("\nindividual functions:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n\n%s:", gfunctions[i]); + if ( !gis_changed[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_function[i]; j++ ) { + printf("\n"); + print_Fluent( &(ginitial_function[i][j].fluent) ); + printf(": %f", ginitial_function[i][j].value); + } + } + printf("\n\nnon static part:"); + for ( ff = gf_initial; ff; ff = ff->next ) { + printf("\n"); + print_Fluent( &(ff->fluent) ); + printf(": %f", ff->value); + } + } + +} + + + +void collect_inertia_information( void ) + +{ + + int i; + Effect *e; + Literal *l; + NumericEffect *ne; + + for ( i = 0; i < gnum_predicates; i++ ) { + gis_added[i] = FALSE; + gis_deleted[i] = FALSE; + } + for ( i = 0; i < gnum_functions; i++ ) { + gis_changed[i] = FALSE; + } + + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + gis_deleted[l->fact.predicate] = TRUE; + } else { + gis_added[l->fact.predicate] = TRUE; + } + } + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + gis_changed[ne->fluent.function] = TRUE; + } + } + } + +} + + + +void split_initial_state( void ) + +{ + + int i, j, p, t; + Facts *tmp; + FluentValues *ftmp; + + for ( i = 0; i < MAX_PREDICATES; i++ ) { + gtype_to_predicate[i] = -1; + } + for ( i = 0; i < MAX_TYPES; i++ ) { + gpredicate_to_type[i] = -1; + } + + for ( i = 0; i < gnum_predicates; i++ ) { + if ( !gis_added[i] && + !gis_deleted[i] && + garity[i] == 1 ) { + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many (inferred) types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_to_predicate[i] = gnum_types; + gpredicate_to_type[gnum_types] = i; + gtype_names[gnum_types] = NULL; + gtype_size[gnum_types] = 0; + for ( j = 0; j < MAX_CONSTANTS; j++ ) { + gis_member[j][gnum_types] = FALSE; + } + gnum_types++; + } + } + + + /* double size of predicates table as each predicate might need + * to be translated to NOT-p + */ + ginitial_predicate = ( Fact ** ) calloc( gnum_predicates * 2, sizeof( Fact * ) ); + gnum_initial_predicate = ( int * ) calloc( gnum_predicates * 2, sizeof( int ) ); + for ( i = 0; i < gnum_predicates * 2; i++ ) { + gnum_initial_predicate[i] = 0; + } + for ( i = 0; i < gnum_full_initial; i++ ) { + p = gfull_initial[i].predicate; + gnum_initial_predicate[p]++; + } + for ( i = 0; i < gnum_predicates; i++ ) { + ginitial_predicate[i] = ( Fact * ) calloc( gnum_initial_predicate[i], sizeof( Fact ) ); + gnum_initial_predicate[i] = 0; + } + ginitial = NULL; + gnum_initial = 0; + + for ( i = 0; i < gnum_full_initial; i++ ) { + p = gfull_initial[i].predicate; + ginitial_predicate[p][gnum_initial_predicate[p]].predicate = p; + for ( j = 0; j < garity[p]; j++ ) { + ginitial_predicate[p][gnum_initial_predicate[p]].args[j] = gfull_initial[i].args[j]; + } + gnum_initial_predicate[p]++; + if ( gis_added[p] || + gis_deleted[p] ) { + tmp = new_Facts(); + tmp->fact->predicate = p; + for ( j = 0; j < garity[p]; j++ ) { + tmp->fact->args[j] = gfull_initial[i].args[j]; + } + tmp->next = ginitial; + ginitial = tmp; + gnum_initial++; + } else { + if ( garity[p] == 1 ) { + t = gtype_to_predicate[p]; + if ( gtype_size[t] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[t], MAX_TYPE); + exit( 1 ); + } + if ( !gis_member[gfull_initial[i].args[0]][gpredicates_args_type[p][0]] ) { + printf("\ntype mismatch in initial state! %s as arg 0 of %s\n\n", + gconstants[gfull_initial[i].args[0]], gpredicates[p]); + exit( 1 ); + } + gtype_consts[t][gtype_size[t]++] = gfull_initial[i].args[0]; + gis_member[gfull_initial[i].args[0]][t] = TRUE; + } + } + } + + ginitial_function = ( FluentValue ** ) + calloc( gnum_functions, sizeof( FluentValue * ) ); + gnum_initial_function = ( int * ) calloc( gnum_functions, sizeof( int ) ); + for ( i = 0; i < gnum_functions; i++ ) { + gnum_initial_function[i] = 0; + } + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + p = gfull_fluents_initial[i].fluent.function; + gnum_initial_function[p]++; + } + for ( i = 0; i < gnum_functions; i++ ) { + ginitial_function[i] = ( FluentValue * ) + calloc( gnum_initial_function[i], sizeof( FluentValue ) ); + gnum_initial_function[i] = 0; + } + gf_initial = NULL; + gnum_f_initial = 0; + + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + p = gfull_fluents_initial[i].fluent.function; + ginitial_function[p][gnum_initial_function[p]].fluent.function = p; + for ( j = 0; j < gf_arity[p]; j++ ) { + ginitial_function[p][gnum_initial_function[p]].fluent.args[j] = + gfull_fluents_initial[i].fluent.args[j]; + } + ginitial_function[p][gnum_initial_function[p]].value = + gfull_fluents_initial[i].value; + gnum_initial_function[p]++; + if ( gis_changed[p] ) { + ftmp = new_FluentValues(); + ftmp->fluent.function = p; + for ( j = 0; j < gf_arity[p]; j++ ) { + ftmp->fluent.args[j] = gfull_fluents_initial[i].fluent.args[j]; + } + ftmp->value = gfull_fluents_initial[i].value; + ftmp->next = gf_initial; + gf_initial = ftmp; + gnum_f_initial++; + } + } + +} + + + + + + + + + + + +/****************************** + * NORMALIZE ALL PL1 FORMULAE * + ******************************/ + + + + + + + + + + + + +void normalize_all_wffs( void ) + +{ + + int i; + Effect *e; + + simplify_wff( &ggoal ); + remove_unused_vars_in_wff( &ggoal ); + expand_quantifiers_in_wff( &ggoal, -1, -1 ); + NOTs_down_in_wff( &ggoal ); + cleanup_wff( &ggoal ); + + if ( ggoal->connective == TRU ) { + printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); + gnum_plan_ops = 0; + exit( 1 ); + } + if ( ggoal->connective == FAL ) { + printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); + exit( 1 ); + } + + /* put goal into DNF right away: fully instantiated already + */ + dnf( &ggoal ); + cleanup_wff( &ggoal ); + + /* all we can do here is simplify if that's possible. + */ + if ( gmetric != NULL ) { + simplify_exp( &gmetric ); + } + + + for ( i = 0; i < gnum_operators; i++ ) { + simplify_wff( &(goperators[i]->preconds) ); + remove_unused_vars_in_wff( &(goperators[i]->preconds) ); + expand_quantifiers_in_wff( &(goperators[i]->preconds), -1, -1 ); + NOTs_down_in_wff( &(goperators[i]->preconds) ); + cleanup_wff( &(goperators[i]->preconds) ); + + for ( e = goperators[i]->effects; e; e = e->next ) { + simplify_wff( &(e->conditions) ); + remove_unused_vars_in_wff( &(e->conditions) ); + expand_quantifiers_in_wff( &(e->conditions), -1, -1 ); + NOTs_down_in_wff( &(e->conditions) ); + cleanup_wff( &(e->conditions) ); + } + } + + if ( gcmd_line.display_info == 107 ) { + printf("\n\ndomain with normalized PL1 formula:"); + + printf("\n\noperators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\n\ngoal is:\n"); + print_Wff( ggoal, 0 ); + + if ( gmetric ) { + printf("\n\nmetric is (minimize):\n"); + print_ExpNode( gmetric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + } + +} + + + +void remove_unused_vars_in_wff( WffNode **w ) + +{ + + WffNode *tmp; + WffNode *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + remove_unused_vars_in_wff( &((*w)->son) ); + if ( !var_used_in_wff( ENCODE_VAR( (*w)->var ), (*w)->son ) ) { + decrement_inferior_vars((*w)->var, (*w)->son ); + (*w)->connective = (*w)->son->connective; + (*w)->var = (*w)->son->var; + (*w)->var_type = (*w)->son->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->son->var_name; + (*w)->sons = (*w)->son->sons; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->son->fact; + (*w)->comp = (*w)->son->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->son->lh; + (*w)->rh = (*w)->son->rh; + + tmp = (*w)->son; + (*w)->son = (*w)->son->son; + free( tmp ); + } + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + remove_unused_vars_in_wff( &i ); + } + break; + case NOT: + remove_unused_vars_in_wff( &((*w)->son) ); + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: remove var, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +Bool var_used_in_wff( int code_var, WffNode *w ) + +{ + + WffNode *i; + int j; + + switch ( w->connective ) { + case ALL: + case EX: + return var_used_in_wff( code_var, w->son ); + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + if ( var_used_in_wff( code_var, i ) ) { + return TRUE; + } + } + return FALSE; + case NOT: + return var_used_in_wff( code_var, w->son ); + case ATOM: + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + if ( w->fact->args[j] >= 0 ) { + continue; + } + if ( w->fact->args[j] == code_var ) { + return TRUE; + } + } + return FALSE; + case COMP: + if ( var_used_in_exp( code_var, w->lh ) ) { + return TRUE; + } + if ( var_used_in_exp( code_var, w->rh ) ) { + return TRUE; + } + return FALSE; + case TRU: + case FAL: + return FALSE; + default: + printf("\nwon't get here: var used ?, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + +} + + + +Bool var_used_in_exp( int code_var, ExpNode *n ) + +{ + + int i; + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + if ( var_used_in_exp( code_var, n->leftson ) || + var_used_in_exp( code_var, n->rightson ) ) { + return TRUE; + } + return FALSE; + case MINUS: + if ( var_used_in_exp( code_var, n->son ) ) { + return TRUE; + } + return FALSE; + case NUMBER: + return FALSE; + case FHEAD: + if ( n->fluent ) { + for ( i = 0; i < gf_arity[n->fluent->function]; i++ ) { + if ( n->fluent->args[i] >= 0 ) { + continue; + } + if ( n->fluent->args[i] == code_var ) { + return TRUE; + } + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + } + return FALSE; + default: + printf("\n\nvar used in expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + +void decrement_inferior_vars( int var, WffNode *w ) + +{ + + WffNode *i; + int j; + + switch ( w->connective ) { + case ALL: + case EX: + w->var--; + decrement_inferior_vars( var, w->son ); + break; + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + decrement_inferior_vars( var, i ); + } + break; + case NOT: + decrement_inferior_vars( var, w->son ); + break; + case ATOM: + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + if ( w->fact->args[j] >= 0 ) { + continue; + } + if ( DECODE_VAR( w->fact->args[j] ) > var ) { + w->fact->args[j]++; + } + } + break; + case COMP: + decrement_inferior_vars_in_exp( var, w->lh ); + decrement_inferior_vars_in_exp( var, w->rh ); + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: decrement, non logical %d\n\n", + w->connective); + exit( 1 ); + } + +} + + + +void decrement_inferior_vars_in_exp( int var, ExpNode *n ) + +{ + + int j; + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + decrement_inferior_vars_in_exp( var, n->leftson ); + decrement_inferior_vars_in_exp( var, n->rightson ); + break; + case MINUS: + decrement_inferior_vars_in_exp( var, n->son ); + break; + case NUMBER: + break; + case FHEAD: + if ( n->fluent ) { + for ( j = 0; j < gf_arity[n->fluent->function]; j++ ) { + if ( n->fluent->args[j] >= 0 ) { + continue; + } + if ( DECODE_VAR( n->fluent->args[j] ) > var ) { + n->fluent->args[j]++; + } + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + } + break; + default: + printf("\n\ndecr inf vars in expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + +void simplify_wff( WffNode **w ) + +{ + + WffNode *i, *tmp; + int m; + Bool ct; + + switch ( (*w)->connective ) { + case ALL: + case EX: + simplify_wff( &((*w)->son) ); + if ( (*w)->son->connective == TRU || + (*w)->son->connective == FAL ) { + (*w)->connective = (*w)->son->connective; + free( (*w)->son ); + (*w)->son = NULL; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + } + break; + case AND: + m = 0; + i = (*w)->sons; + while ( i ) { + simplify_wff( &i ); + if ( i->connective == FAL ) { + (*w)->connective = FAL; + /* free_WffNode( (*w)->sons ); */ + (*w)->sons = NULL; + return; + } + if ( i->connective == TRU ) { + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + if ( i->next ) { + i->next->prev = i->prev; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + m++; + } + if ( m == 0 ) { + (*w)->connective = TRU; + free_WffNode( (*w)->sons ); + (*w)->sons = NULL; + } + if ( m == 1 ) { + (*w)->connective = (*w)->sons->connective; + (*w)->var = (*w)->sons->var; + (*w)->var_type = (*w)->sons->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->sons->var_name; + (*w)->son = (*w)->sons->son; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->sons->fact; + (*w)->comp = (*w)->sons->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->sons->lh; + (*w)->rh = (*w)->sons->rh; + + tmp = (*w)->sons; + (*w)->sons = (*w)->sons->sons; + free( tmp ); + } + break; + case OR: + m = 0; + i = (*w)->sons; + while ( i ) { + simplify_wff( &i ); + if ( i->connective == TRU ) { + (*w)->connective = TRU; + free_WffNode( (*w)->sons ); + (*w)->sons = NULL; + return; + } + if ( i->connective == FAL ) { + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + if ( i->next ) { + i->next->prev = i->prev; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + m++; + } + if ( m == 0 ) { + (*w)->connective = FAL; + /* free_WffNode( (*w)->sons ); */ + (*w)->sons = NULL; + } + if ( m == 1 ) { + (*w)->connective = (*w)->sons->connective; + (*w)->var = (*w)->sons->var; + (*w)->var_type = (*w)->sons->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->sons->var_name; + (*w)->son = (*w)->sons->son; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->sons->fact; + (*w)->comp = (*w)->sons->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->sons->lh; + (*w)->rh = (*w)->sons->rh; + + tmp = (*w)->sons; + (*w)->sons = (*w)->sons->sons; + free( tmp ); + } + break; + case NOT: + simplify_wff( &((*w)->son) ); + if ( (*w)->son->connective == TRU || + (*w)->son->connective == FAL ) { + (*w)->connective = ( (*w)->son->connective == TRU ) ? FAL : TRU; + free( (*w)->son ); + (*w)->son = NULL; + } + break; + case ATOM: + if ( (*w)->visited ) { + /* already seen and not changed + */ + break; + } + if ( !possibly_negative( (*w)->fact ) ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !possibly_positive( (*w)->fact ) ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + (*w)->visited = TRUE; + break; + case COMP: + simplify_exp( &((*w)->lh) ); + simplify_exp( &((*w)->rh) ); + if ( (*w)->lh->connective != NUMBER || + (*w)->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); + if ( ct ) { + (*w)->connective = TRU; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } else { + (*w)->connective = FAL; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: simplify, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void simplify_exp( ExpNode **n ) + +{ + + int j, f, k; + + switch ( (*n)->connective ) { + case AD: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + simplify_exp( &((*n)->son) ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + if ( !(*n)->fluent ) { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + break; + } + f = (*n)->fluent->function; + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] < 0 ) { + break; + } + } + if ( j < gf_arity[f] ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\nsimplify expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +void expand_quantifiers_in_wff( WffNode **w, int var, int constant ) + +{ + + WffNode *r = NULL, *tmp, *i; + int j, l; + Bool change, ct; + + if ( !(*w) ) { + return; + } + + switch ( (*w)->connective ) { + case ALL: + case EX: + if ( var != -1 ) {/* depth first: upper node is active */ + expand_quantifiers_in_wff( &((*w)->son), var, constant ); + return; + } + + (*w)->connective = ( (*w)->connective == ALL ) ? AND : OR; + for ( j = 0; j < gtype_size[(*w)->var_type]; j++ ) { + tmp = copy_Wff( (*w)->son ); + expand_quantifiers_in_wff( &tmp, (*w)->var, gtype_consts[(*w)->var_type][j] ); + tmp->next = r; + if ( r ) { + r->prev = tmp; + } + r = tmp; + } + + free_WffNode( (*w)->son ); + (*w)->sons = r; + (*w)->var = -1; + (*w)->var_type = -1; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = NULL; + + /* now make all sons expand their quantifiers + */ + for ( i = (*w)->sons; i; i = i->next ) { + expand_quantifiers_in_wff( &i, -1, -1 ); + } + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + expand_quantifiers_in_wff( &i, var, constant ); + } + break; + case NOT: + expand_quantifiers_in_wff( &((*w)->son), var, constant ); + break; + case ATOM: + if ( var == -1 ) { + break; + } + + change = FALSE; + for ( l = 0; l < garity[(*w)->fact->predicate]; l++ ) { + if ( (*w)->fact->args[l] == ENCODE_VAR( var ) ) { + (*w)->fact->args[l] = constant; + change = TRUE; + } + } + if ( !change && (*w)->visited ) { + /* we did not change anything and we've already seen that node + * --> it cant be simplified + */ + break; + } + if ( !possibly_negative( (*w)->fact ) ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !possibly_positive( (*w)->fact ) ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + (*w)->visited = TRUE; + break; + case COMP: + if ( var == -1 ) { + break; + } + + replace_var_with_const_in_exp( &((*w)->lh), var, constant ); + replace_var_with_const_in_exp( &((*w)->rh), var, constant ); + if ( (*w)->lh->connective != NUMBER || + (*w)->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); + if ( ct ) { + (*w)->connective = TRU; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } else { + (*w)->connective = FAL; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: expansion, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ) + +{ + + int j, f, k; + + switch ( (*n)->connective ) { + case AD: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + replace_var_with_const_in_exp( &((*n)->son), var, constant ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + if ( !(*n)->fluent ) { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + break; + } + f = (*n)->fluent->function; + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] == ENCODE_VAR( var ) ) { + (*n)->fluent->args[j] = constant; + } + } + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] < 0 ) { + break; + } + } + if ( j < gf_arity[f] ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\nreplace var with const in expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +WffNode *copy_Wff( WffNode *w ) + +{ + + WffNode *tmp, *tmp2, *i; + int j; + + tmp = new_WffNode( w->connective ); + + switch ( w->connective ) { + case ALL: + case EX: + tmp->var = w->var; + tmp->var_type = w->var_type; + tmp->son = copy_Wff( w->son ); + break; + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + tmp2 = copy_Wff( i ); + if ( tmp->sons ) { + tmp->sons->prev = tmp2; + } + tmp2->next = tmp->sons; + tmp->sons = tmp2; + } + break; + case NOT: + tmp->son = copy_Wff( w->son ); + break; + case ATOM: + tmp->fact = new_Fact(); + tmp->fact->predicate = w->fact->predicate; + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + tmp->fact->args[j] = w->fact->args[j]; + } + tmp->visited = w->visited; + break; + case COMP: + tmp->comp = w->comp; + tmp->lh = copy_Exp( w->lh ); + tmp->rh = copy_Exp( w->rh ); + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: copy, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + return tmp; + +} + + + +ExpNode *copy_Exp( ExpNode *n ) + +{ + + ExpNode *tmp; + int i; + + tmp = new_ExpNode( n->connective ); + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + tmp->leftson = copy_Exp( n->leftson ); + tmp->rightson = copy_Exp( n->rightson ); + break; + case MINUS: + tmp->son = copy_Exp( n->son ); + break; + case NUMBER: + tmp->value = n->value; + break; + case FHEAD: + if ( n->fluent ) { + tmp->fluent = new_Fluent(); + tmp->fluent->function = n->fluent->function; + for ( i = 0; i < gf_arity[tmp->fluent->function]; i++ ) { + tmp->fluent->args[i] = n->fluent->args[i]; + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + tmp->fl = n->fl; + } + break; + default: + printf("\n\ncopy expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + + return tmp; + +} + + + +Bool possibly_positive( Fact *f ) + +{ + + int i; + + if ( gis_added[f->predicate] ) { + return TRUE; + } + + for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { + if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { + return TRUE; + } + } + + return FALSE; + +} + + + +Bool possibly_negative( Fact *f ) + +{ + + int i; + + if ( gis_deleted[f->predicate] ) { + return TRUE; + } + + for ( i = 0; i < garity[f->predicate]; i++ ) { + if ( f->args[i] < 0 ) { + return TRUE; + } + } + + for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { + if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { + return FALSE; + } + } + + return TRUE; + +} + + + +Bool matches( Fact *f1, Fact *f2 ) + +{ + + int i; + + for ( i = 0; i < garity[f1->predicate]; i++ ) { + if ( f1->args[i] >= 0 ) { + if ( f2->args[i] >= 0 && + f1->args[i] != f2->args[i] ) { + return FALSE; + } + } + } + + return TRUE; + +} + + + +void cleanup_wff( WffNode **w ) + +{ + + merge_ANDs_and_ORs_in_wff( w ); + detect_tautologies_in_wff( w ); + simplify_wff( w ); + detect_tautologies_in_wff( w ); + merge_ANDs_and_ORs_in_wff( w ); + +} + + + +void detect_tautologies_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + switch ( (*w)->connective ) { + case ALL: + case EX: + detect_tautologies_in_wff( &((*w)->son) ); + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + detect_tautologies_in_wff( &i ); + } + for ( i = (*w)->sons; i && i->next; i = i->next ) { + j = i->next; + while ( j ) { + if ( are_identical_ATOMs( i, j ) ) { + j->prev->next = j->next; + if ( j->next ) { + j->next->prev = j->prev; + } + tmp = j; + j = j->next; + if ( tmp->fact ) { + free( tmp->fact ); + } + free( tmp ); + continue; + } + if ( i->connective == NOT && + are_identical_ATOMs( i->son, j ) ) { + (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; + free_WffNode( (*w)->son ); + (*w)->son = NULL; + return; + } + if ( j->connective == NOT && + are_identical_ATOMs( i, j->son ) ) { + (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; + free_WffNode( (*w)->son ); + (*w)->son = NULL; + return; + } + j = j->next; + } + } + break; + case NOT: + detect_tautologies_in_wff( &((*w)->son) ); + break; + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: tautologies, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ) + +{ + + int i; + + if ( w1->connective != ATOM || + w2->connective != ATOM ) { + return FALSE; + } + + if ( w1->fact->predicate != w2->fact->predicate ) { + return FALSE; + } + + for ( i = 0; i < garity[w1->fact->predicate]; i++ ) { + if ( w1->fact->args[i] != w2->fact->args[i] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +void merge_ANDs_and_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + switch ( (*w)->connective ) { + case ALL: + case EX: + merge_ANDs_and_ORs_in_wff( &((*w)->son) ); + break; + case AND: + case OR: + i = (*w)->sons; + while ( i ) { + merge_ANDs_and_ORs_in_wff( &i ); + if ( i->connective == (*w)->connective ) { + if ( !(i->sons) ) { + if ( i->next ) { + i->next->prev = i->prev; + } + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + for ( j = i->sons; j->next; j = j->next ); + j->next = i->next; + if ( i->next ) { + i->next->prev = j; + } + if ( i->prev ) { + i->prev->next = i->sons; + i->sons->prev = i->prev; + } else { + (*w)->sons = i->sons; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + } + break; + case NOT: + merge_ANDs_and_ORs_in_wff( &((*w)->son) ); + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: merge, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void NOTs_down_in_wff( WffNode **w ) + +{ + + WffNode *tmp1, *tmp2, *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\ntrying to put nots down in quantified formula! debug me\n\n"); + exit( 1 ); + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + NOTs_down_in_wff( &i ); + } + break; + case NOT: + if ( (*w)->son->connective == NOT ) { + (*w)->connective = (*w)->son->son->connective; + (*w)->fact = (*w)->son->son->fact; + (*w)->comp = (*w)->son->son->comp; + (*w)->lh = (*w)->son->son->lh; + (*w)->rh = (*w)->son->son->rh; + tmp1 = (*w)->son; + tmp2 = (*w)->son->son; + (*w)->sons = (*w)->son->son->sons; + (*w)->son = (*w)->son->son->son; + /* don't need to remember (*w)->son->son->next: this is empty because + * otherwise the resp. father, (*w)->son, would have been an + * AND or OR + */ + free( tmp1 ); + free( tmp2 ); + NOTs_down_in_wff( w ); + break; + } + if ( (*w)->son->connective == AND || + (*w)->son->connective == OR ) { + (*w)->connective = ( (*w)->son->connective == AND ) ? OR : AND; + (*w)->sons = (*w)->son->sons; + free( (*w)->son ); + (*w)->son = NULL; + for ( i = (*w)->sons; i; i = i->next ) { + tmp1 = new_WffNode( i->connective ); + tmp1->son = i->son; + tmp1->sons = i->sons; + tmp1->fact = i->fact; + tmp1->comp = i->comp; + tmp1->lh = i->lh; + tmp1->rh = i->rh; + i->connective = NOT; + i->son = tmp1; + i->sons = NULL; + i->fact = NULL; + i->comp = -1; + i->lh = NULL; + i->rh = NULL; + NOTs_down_in_wff( &i ); + } + break; + } + if ( (*w)->son->connective == COMP ) { + if ( (*w)->son->comp != EQ ) { + (*w)->connective = COMP; + (*w)->lh = (*w)->son->lh; + (*w)->rh = (*w)->son->rh; + switch ( (*w)->son->comp ) { + case LE: + (*w)->comp = GEQ; + break; + case LEQ: + (*w)->comp = GE; + break; + case GEQ: + (*w)->comp = LE; + break; + case GE: + (*w)->comp = LEQ; + break; + default: + printf("\n\nillegal comparator not EQ %d in nots down", + (*w)->son->comp); + exit( 1 ); + } + free( (*w)->son ); + (*w)->son = NULL; + } else { + (*w)->connective = OR; + (*w)->sons = (*w)->son; + (*w)->son = NULL; + (*w)->sons->comp = LE; + tmp1 = new_WffNode( COMP ); + tmp1->lh = copy_Exp( (*w)->sons->lh ); + tmp1->rh = copy_Exp( (*w)->sons->rh ); + tmp1->comp = GE; + tmp1->prev = (*w)->sons; + (*w)->sons->next = tmp1; + } + } + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: nots down, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + + +} + + + + + + + + + + + +/**************************************************** + * NEGATIVE PRE- AND EFFECT- CONDITIONS TRANSLATION * + ****************************************************/ + + + + + + + + +int lconsts[MAX_ARITY]; + + + + + + + + +void translate_negative_preconds( void ) + +{ + + int i, j; + Effect *e; + Facts *f; + FluentValues *ff; + + while ( translate_one_negative_cond( ggoal ) ); + + for ( i = 0; i < gnum_operators; i++ ) { + while ( translate_one_negative_cond( goperators[i]->preconds ) ); + + for ( e = goperators[i]->effects; e; e = e->next ) { + while ( translate_one_negative_cond( e->conditions ) ); + } + } + + if ( gcmd_line.display_info == 108 ) { + printf("\n\ndomain with translated negative conds:"); + + printf("\n\noperators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\ninitial state is:\n"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + printf("\n"); + for ( ff = gf_initial; ff; ff = ff->next ) { + printf("\n"); + print_Fluent( &(ff->fluent) ); + printf(": %f", ff->value); + } + printf("\n\n"); + + printf("\n\nindividual predicates:\n"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n\n%s:", gpredicates[i]); + if ( !gis_added[i] && + !gis_deleted[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + printf("\n"); + print_Fact( &(ginitial_predicate[i][j]) ); + } + } + printf("\n\nindividual functions:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n\n%s:", gfunctions[i]); + if ( !gis_changed[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_function[i]; j++ ) { + printf("\n"); + print_Fluent( &(ginitial_function[i][j].fluent) ); + printf(": %f", ginitial_function[i][j].value); + } + } + printf("\n\n"); + + printf("\n\ngoal is:\n"); + print_Wff( ggoal, 0 ); + printf("\n\n"); + } + +} + + + +Bool translate_one_negative_cond( WffNode *w ) + +{ + + WffNode *i; + int p, j, k, m; + Effect *e; + Literal *l, *tmp; + + switch ( w->connective ) { + case ALL: + case EX: + printf("\ntranslating NOT in quantified formula! debug me\n\n"); + exit( 1 ); + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + if ( translate_one_negative_cond( i ) ) { + return TRUE; + } + } + return FALSE; + case NOT: + if ( w->son->fact->predicate == -1 ) { + return FALSE; + } + break; + case COMP: + case ATOM: + case TRU: + case FAL: + return FALSE; + default: + printf("\nwon't get here: translate one neg cond, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + + if ( gnum_predicates == MAX_PREDICATES ) { + printf("\ntoo many predicates in translation! increase MAX_PREDICATES (currently %d)\n\n", + MAX_PREDICATES); + exit( 1 ); + } + p = w->son->fact->predicate; + /* safety check: we disallow negative conds on derived preds!! + */ + if ( gaxiom_added[p]) { + printf("\nA derived predicate appears negated in the negation normal form of a derivation rule condition, an operator precondition, or the goal."); + printf("\nSorry, this version of FF does not allow any of this. Bailing out.\n\n"); + exit( 1 ); + } else { + printf("\ntranslating negated cond for predicate %s", gpredicates[p]); + } + + gpredicates[gnum_predicates] = new_Token( strlen( gpredicates[p] ) + 5 ); + sprintf( gpredicates[gnum_predicates], "NOT-%s", gpredicates[p] ); + garity[gnum_predicates] = garity[p]; + for ( j = 0; j < garity[p]; j++ ) { + gpredicates_args_type[gnum_predicates][j] = + gpredicates_args_type[p][j]; + } + gis_added[gnum_predicates] = FALSE; + gis_deleted[gnum_predicates] = FALSE; + m = 1; + for ( j = 0; j < garity[gnum_predicates]; j++ ) { + m *= gtype_size[gpredicates_args_type[gnum_predicates][j]]; + } + ginitial_predicate[gnum_predicates] = ( Fact * ) calloc( m, sizeof( Fact ) ); + gnum_predicates++; + + + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, &ggoal ); + + for ( j = 0; j < gnum_operators; j++ ) { + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, + &(goperators[j]->preconds) ); + + for ( e = goperators[j]->effects; e; e = e->next ) { + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, + &(e->conditions) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->fact.predicate != p ) { + continue; + } + tmp = new_Literal(); + if ( l->negated ) { + tmp->negated = FALSE; + gis_added[gnum_predicates - 1] = TRUE; + } else { + tmp->negated = TRUE; + gis_deleted[gnum_predicates - 1] = TRUE; + } + tmp->fact.predicate = gnum_predicates - 1; + for ( k = 0; k < garity[p]; k++ ) { + tmp->fact.args[k] = l->fact.args[k]; + } + if ( l->prev ) { + tmp->prev = l->prev; + tmp->prev->next = tmp; + } else { + e->effects = tmp; + } + tmp->next = l; + l->prev = tmp; + } + } + } + + add_to_initial_state( p, gnum_predicates - 1, 0 ); + + return TRUE; + +} + + + +void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ) + +{ + + WffNode *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\nreplacing p with NOT-p in quantified formula! debug me\n\n"); + exit( 1 ); + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + replace_not_p_with_n_in_wff( p, n, &i ); + } + break; + case NOT: + if ( (*w)->son->fact->predicate == p ) { + (*w)->connective = ATOM; + (*w)->NOT_p = p; + (*w)->fact = (*w)->son->fact; + (*w)->fact->predicate = n; + free( (*w)->son ); + (*w)->son = NULL; + } + break; + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: replace p with NOT-p, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void add_to_initial_state( int p, int n, int index ) + +{ + + int i, j; + Facts *tmp; + + if ( index == garity[p] ) { + /* see if contrary fact is there in ini + */ + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + for ( j = 0; j < garity[p]; j++ ) { + if ( ginitial_predicate[p][i].args[j] != lconsts[j] ) { + break; + } + } + if ( j == garity[p] ) { + break; + } + } + if ( i < gnum_initial_predicate[p] ) { + return; + } + + /* no: add new fact to ini + */ + ginitial_predicate[n][gnum_initial_predicate[n]].predicate = n; + for ( i = 0; i < garity[n]; i++ ) { + ginitial_predicate[n][gnum_initial_predicate[n]].args[i] = lconsts[i]; + } + gnum_initial_predicate[n]++; + + if ( !gis_added[n] && + !gis_deleted[n] ) { + return; + } + + tmp = new_Facts(); + tmp->fact->predicate = n; + for ( i = 0; i < garity[p]; i++ ) { + tmp->fact->args[i] = lconsts[i]; + } + tmp->next = ginitial; + ginitial = tmp; + gnum_initial++; + return; + } + + for ( i = 0; i < gtype_size[gpredicates_args_type[p][index]]; i++ ) { + lconsts[index] = gtype_consts[gpredicates_args_type[p][index]][i]; + add_to_initial_state( p, n, index + 1 ); + } + +} + + + + + + + + + + + +/******************************************************************* + * SPLIT DOMAIN IN PREPARATION FOR SEPARATE INSTANTIATION ROUTINES * + *******************************************************************/ + + + + + + + + + + +void split_domain( void ) + +{ + + int i, j, m, s = 0, mn; + Effect *e; + WffNode *w, *ww, *www; + NormOperator *tmp_op; + Fact *tmp_ft; + + for ( i = 0; i < MAX_TYPES; i++ ) { + gnum_intersected_types[i] = -1; + } + + for ( i = 0; i < gnum_operators; i++ ) { + if ( (m = is_dnf( goperators[i]->preconds )) != -1 ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + if ( is_dnf( e->conditions ) == -1 ) { + break; + } + } + if ( !e ) { + goperators[i]->hard = FALSE; + s += m; + } + } + } + + ghard_operators = ( Operator_pointer * ) calloc( MAX_OPERATORS, sizeof( Operator ) ); + gnum_hard_operators = 0; + geasy_operators = ( NormOperator_pointer * ) calloc( s, sizeof( NormOperator_pointer ) ); + gnum_easy_operators = 0; + + for ( i = 0; i < gnum_operators; i++ ) { + if ( goperators[i]->hard ) { + ghard_operators[gnum_hard_operators++] = goperators[i]; + continue; + } + w = goperators[i]->preconds; + switch ( w->connective ) { + case OR: + for ( ww = w->sons; ww; ww = ww->next ) { + tmp_op = new_NormOperator( goperators[i] ); + if ( ww->connective == AND ) { + m = 0; + mn = 0; + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) m++; + if ( www->connective == COMP ) mn++; + } + tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) { + tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); + tmp_ft->predicate = www->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = www->fact->args[j]; + } + tmp_op->num_preconds++; + } + if ( www->connective == COMP ) { + tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = www->comp; + tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( www->lh ); + tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( www->rh ); + tmp_op->num_numeric_preconds++; + } + } + } else { + if ( ww->connective == ATOM ) { + tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_op->preconds[0]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_op->num_preconds = 1; + } + if ( ww->connective == COMP ) { + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_comp[0] = ww->comp; + tmp_op->numeric_preconds_lh[0] = copy_Exp( ww->lh ); + tmp_op->numeric_preconds_rh[0] = copy_Exp( ww->rh ); + tmp_op->num_numeric_preconds = 1; + } + } + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + } + break; + case AND: + tmp_op = new_NormOperator( goperators[i] ); + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_op->num_preconds++; + } + if ( ww->connective == COMP ) { + tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = ww->comp; + tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( ww->lh ); + tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( ww->rh ); + tmp_op->num_numeric_preconds++; + } + } + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case ATOM: + tmp_op = new_NormOperator( goperators[i] ); + tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_op->preconds[0]); + tmp_ft->predicate = w->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = w->fact->args[j]; + } + tmp_op->num_preconds = 1; + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case COMP: + tmp_op = new_NormOperator( goperators[i] ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_comp[0] = w->comp; + tmp_op->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp_op->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp_op->num_numeric_preconds = 1; + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case TRU: + tmp_op = new_NormOperator( goperators[i] ); + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case FAL: + break; + default: + printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); + exit( 1 ); + } + } + + if ( gcmd_line.display_info == 109 ) { + printf("\n\nsplitted operators are:\n"); + + printf("\nEASY:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + + printf("\n\n\nHARD:\n"); + for ( i = 0; i < gnum_hard_operators; i++ ) { + print_Operator( ghard_operators[i] ); + } + } + +} + + + +int is_dnf( WffNode *w ) + +{ + + WffNode *i; + int s = 0; + + switch ( w->connective ) { + case ALL: + case EX: + printf("\nchecking quantifier for dnf. debug me\n\n"); + exit( 1 ); + case AND: + for ( i = w->sons; i; i = i->next ) { + if ( i->connective == ATOM || + i->connective == COMP ) { + continue; + } + return -1; + } + return 1; + case OR: + for ( i = w->sons; i; i = i->next ) { + s++; + if ( i->connective == ATOM || + i->connective == COMP || + ( i->connective == AND && + is_dnf( i ) != -1 ) ) { + continue; + } + return -1; + } + return s; + case NOT: + printf("\n\nNOT in presimplified formula. debug me\n\n"); + exit( 1 ); + case ATOM: + case COMP: + case TRU: + case FAL: + return 1; + default: + printf("\nwon't get here: check dnf, conn %d\n\n", + w->connective); + exit( 1 ); + } + +} + + + +void make_normal_effects( NormOperator **nop, Operator *op ) + +{ + + Effect *e; + NormEffect *tmp_ef; + WffNode *w, *ww, *www; + int j, m, ma, md, mn; + Literal *l; + NumericEffect *ll; + Fact *tmp_ft; + Fluent *tmp_fl; + + for ( e = op->effects; e; e = e->next ) { + w = e->conditions; + switch ( w->connective ) { + case OR: + for ( ww = w->sons; ww; ww = ww->next ) { + tmp_ef = new_NormEffect1( e ); + if ( ww->connective == AND ) { + m = 0; + mn = 0; + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) m++; + if ( www->connective == COMP ) mn++; + } + tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) { + tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); + tmp_ft->predicate = www->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = www->fact->args[j]; + } + tmp_ef->num_conditions++; + } + if ( www->connective == COMP ) { + tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = www->comp; + tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( www->lh ); + tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( www->rh ); + tmp_ef->num_numeric_conditions++; + } + } + } else { + if ( ww->connective == ATOM ) { + tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_ef->conditions[0]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_ef->num_conditions = 1; + } + if ( ww->connective == COMP ) { + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_comp[0] = ww->comp; + tmp_ef->numeric_conditions_lh[0] = copy_Exp( ww->lh ); + tmp_ef->numeric_conditions_rh[0] = copy_Exp( ww->rh ); + tmp_ef->num_numeric_conditions = 1; + } + } + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + } + break; + case AND: + tmp_ef = new_NormEffect1( e ); + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_ef->num_conditions++; + } + if ( ww->connective == COMP ) { + tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = ww->comp; + tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->lh ); + tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->rh ); + tmp_ef->num_numeric_conditions++; + } + } + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case ATOM: + tmp_ef = new_NormEffect1( e ); + tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_ef->conditions[0]); + tmp_ft->predicate = w->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = w->fact->args[j]; + } + tmp_ef->num_conditions = 1; + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case COMP: + tmp_ef = new_NormEffect1( e ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_comp[0] = w->comp; + tmp_ef->numeric_conditions_lh[0] = copy_Exp( w->lh ); + tmp_ef->numeric_conditions_rh[0] = copy_Exp( w->rh ); + tmp_ef->num_numeric_conditions = 1; + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case TRU: + tmp_ef = new_NormEffect1( e ); + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case FAL: + break; + default: + printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); + exit( 1 ); + } + } + +} + + + + + + + + + +/************************************************************************* + * ADDITIONAL: FULL DNF, only compute on fully instantiated formulae!!!! * + *************************************************************************/ + + + + + + + + + + +/* dnf + */ + +WffNode *lhitting_sets; +WffNode_pointer *lset; +int lmax_set; + + + + + + +void dnf( WffNode **w ) + +{ + + static Bool first_call = TRUE; + + if ( first_call ) { + lset = ( WffNode_pointer * ) + calloc( MAX_HITTING_SET_DEFAULT, sizeof( WffNode_pointer ) ); + lmax_set = MAX_HITTING_SET_DEFAULT; + first_call = FALSE; + } + + ANDs_below_ORs_in_wff( w ); + +} + + + +void ANDs_below_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *tmp; + int c, m; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\ntrying to put quantified formula into DNF! (ands down) debug me\n\n"); + exit( 1 ); + break; + case AND: + c = 0; + m = 0; + for ( i = (*w)->sons; i; i = i->next ) { + ANDs_below_ORs_in_wff( &i ); + if ( i->connective == OR ) { + c++; + } + m++; + } + if ( c == 0 ) { + /* no ORs as sons --> all sons are literals. OK + */ + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + } + /* crucial part: AND node, sons can be merged OR's. + * (i.e., sons are either literals or disjunctions of + * conjunctions of literals) + * create OR node with one hitting set of w's sons for + * each disjunct + */ + lhitting_sets = NULL; + if ( m > lmax_set ) { + free( lset ); + lset = ( WffNode_pointer * ) calloc( m, sizeof( WffNode_pointer ) ); + lmax_set = m; + } + collect_hitting_sets( (*w)->sons, 0 ); + (*w)->connective = OR; + tmp = (*w)->sons; + (*w)->sons = lhitting_sets; + if ( 0 ) free_WffNode( tmp ); + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + ANDs_below_ORs_in_wff( &i ); + } + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + case NOT: + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: ands down, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void collect_hitting_sets( WffNode *ORlist, int index ) + +{ + + WffNode *tmp1, *tmp2, *j; + int i; + + if ( !ORlist ) { + tmp1 = new_WffNode( AND ); + for ( i = 0; i < index; i++ ) { + tmp2 = copy_Wff( lset[i] ); + tmp2->next = tmp1->sons; + if ( tmp1->sons ) { + tmp1->sons->prev = tmp2; + } + tmp1->sons = tmp2; + } + tmp1->next = lhitting_sets; + if ( lhitting_sets ) { + lhitting_sets->prev = tmp1; + } + lhitting_sets = tmp1; + return; + } + + if ( ORlist->connective != OR ) { + lset[index] = ORlist; + collect_hitting_sets( ORlist->next, index + 1 ); + return; + } + + for ( j = ORlist->sons; j; j = j->next ) { + lset[index] = j; + collect_hitting_sets( ORlist->next, index + 1 ); + } + +} + + + +void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + i = (*w)->sons; + while ( i ) { + if ( i->connective == (*w)->connective ) { + if ( !(i->sons) ) { + if ( i->next ) { + i->next->prev = i->prev; + } + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + for ( j = i->sons; j->next; j = j->next ); + j->next = i->next; + if ( i->next ) { + i->next->prev = j; + } + if ( i->prev ) { + i->prev->next = i->sons; + i->sons->prev = i->prev; + } else { + (*w)->sons = i->sons; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + } + +} + + + +/* switch ( (*w)->connective ) { */ +/* case ALL: */ +/* case EX: */ +/* break; */ +/* case AND: */ +/* case OR: */ +/* for ( i = (*w)->sons; i; i = i->next ) { */ +/* } */ +/* break; */ +/* case NOT: */ +/* break; */ +/* case ATOM: */ +/* case TRU: */ +/* case FAL: */ +/* break; */ +/* default: */ +/* printf("\nwon't get here: remove var, non logical %d\n\n", */ +/* (*w)->connective); */ +/* exit( 1 ); */ +/* } */ + + + + + + + + + diff --git a/gen/ff_planner/inst_pre.h b/gen/ff_planner/inst_pre.h new file mode 100644 index 000000000..de859b385 --- /dev/null +++ b/gen/ff_planner/inst_pre.h @@ -0,0 +1,123 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: inst_pre.h + * Description: headers for instantiating operators, preprocessing part. + * - transform domain into integers + * - inertia preprocessing: + * - collect inertia info + * - split initial state in special arrays + * - Wff normalization: + * - simplification + * - quantifier expansion + * - NOT s down + * - negative preconditions translation + * - split operators into easy and hard to instantiate ones + * + * - full DNF functions, only feasible for fully instantiated + * formulae + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + + + +#ifndef _INST_PRE_H +#define _INST_PRE_H + + + +void encode_domain_in_integers( void ); +void collect_all_strings( void ); +void create_member_nrs( void ); +int position_in_types_table( char *str ); +int position_in_constants_table( char *str ); +int position_in_predicates_table( char *str ); +int position_in_functions_table( char *str ); +void create_integer_representation( void ); +void make_Fact( Fact *f, PlNode *n, int num_vars ); +void make_Fluent( Fluent *f, TokenList *atom, int num_vars ); +Bool is_subtype( int t1, int t2 ); +WffNode *make_Wff( PlNode *p, int num_vars ); +ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ); +Effect *make_effect( PlNode *p, int num_vars ); + + + +void do_inertia_preprocessing_step_1( void ); +void collect_inertia_information( void ); +void split_initial_state( void ); + + + +void normalize_all_wffs( void ); +void remove_unused_vars_in_wff( WffNode **w ); +void decrement_inferior_vars( int var, WffNode *w ); +void decrement_inferior_vars_in_exp( int var, ExpNode *n ); +Bool var_used_in_wff( int code_var, WffNode *w ); +Bool var_used_in_exp( int code_var, ExpNode *n ); +void simplify_wff( WffNode **w ); +void simplify_exp( ExpNode **n ); +void expand_quantifiers_in_wff( WffNode **w, int var, int constant ); +void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ); +WffNode *copy_Wff( WffNode *w ); +ExpNode *copy_Exp( ExpNode *n ); +Bool possibly_positive( Fact *f ); +Bool possibly_negative( Fact *f ); +Bool matches( Fact *f1, Fact *f2 ); +void cleanup_wff( WffNode **w ); +void detect_tautologies_in_wff( WffNode **w ); +Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ); +void merge_ANDs_and_ORs_in_wff( WffNode **w ); +void NOTs_down_in_wff( WffNode **w ); + + + +void translate_negative_preconds( void ); +Bool translate_one_negative_cond( WffNode *w ); +void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ); +void add_to_initial_state( int p, int n, int index ); + + + +void split_domain( void ); +int is_dnf( WffNode *w ); +void make_normal_effects( NormOperator **nop, Operator *op ); + + + +void dnf( WffNode **w ); +void ANDs_below_ORs_in_wff( WffNode **w ); +void collect_hitting_sets( WffNode *ORlist, int index ); +void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ); + + + +#endif /* _INST_PRE_H */ diff --git a/gen/ff_planner/lex-fct_pddl.l b/gen/ff_planner/lex-fct_pddl.l new file mode 100644 index 000000000..850bbb407 --- /dev/null +++ b/gen/ff_planner/lex-fct_pddl.l @@ -0,0 +1,139 @@ +%{ +#include "ff.h" +#include "parse.h" + + /* default yywrap function - always treat EOF as an EOF */ +int fct_pddlwrap() { return 1; }; + +int gbracket_count = 0; + +%} + +a [Aa] +b [Bb] +c [Cc] +d [Dd] +e [Ee] +f [Ff] +g [Gg] +h [Hh] +i [Ii] +j [Jj] +k [Kk] +l [Ll] +m [Mm] +n [Nn] +o [Oo] +p [Pp] +q [Qq] +r [Rr] +s [Ss] +t [Tt] +u [Uu] +v [Vv] +w [Ww] +x [Xx] +y [Yy] +z [Zz] + +%x COMMENT OVERREAD + +%% + +"(" { return(OPEN_PAREN); } + +")" { return(CLOSE_PAREN); } + +\([ \t]*{i}{n}"-"{p}{a}{c}{k}{a}{g}{e} { gbracket_count = 1; + BEGIN OVERREAD; } + +\([ \t]*":"{l}{e}{n}{g}{t}{h} { gbracket_count = 1; + BEGIN OVERREAD; } + +\([ \t]*":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { gbracket_count = 1; + BEGIN OVERREAD; } + +{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } + +{p}{r}{o}{b}{l}{e}{m} { return(PROBLEM_TOK); } + +{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(SITUATION_TOK); } + +":"{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(BSITUATION_TOK); } + +":"{o}{b}{j}{e}{c}{t}{s} { return(OBJECTS_TOK); } + +":"{g}{o}{a}{l} { return(GOAL_TOK); } + +":"{m}{e}{t}{r}{i}{c} { return(METRIC_TOK); } + +":"{i}{n}{i}{t} { return(INIT_TOK); } + +":"{d}{o}{m}{a}{i}{n} { return(BDOMAIN_TOK); } + +\([ \t]*":"{e}{x}{t}{e}{n}{d}{s} { gbracket_count = 1; + BEGIN OVERREAD; } + +{a}{n}{d} { return(AND_TOK); } + +{i}{m}{p}{l}{y} { return(IMPLY_TOK); } + +{o}{r} { return(OR_TOK); } + +{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } + +{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } + +{n}{o}{t} { return(NOT_TOK); } + +"<" { return(LE_TOK); } + +"<=" { return(LEQ_TOK); } + +"=" { return(EQ_TOK); } + +">=" { return(GEQ_TOK); } + +">" { return(GE_TOK); } + +"-" { return(MINUS_TOK); } + +"+" { return(AD_TOK); } + +"*" { return(MU_TOK); } + +"/" { return(DI_TOK); } + +:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase( yytext ); + strcpy(yylval.string, yytext ); return(NAME); } + +\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* {strupcase( yytext ); + strcpy(yylval.string, yytext); return(VARIABLE); } + +"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} + +"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } + +\;(.)*\n { lineno++; } +\;(.)* { /* this will hold only in files that end with + a comment but no linefeed */ } + +(.^\")*\n { lineno++; } ; + +\" { BEGIN COMMENT;} + +\" { BEGIN INITIAL;} + +\n { lineno++; } + +(.^\(\))*\n { lineno++; } + +[^\(\)] { } + +\( { gbracket_count++; } + +\) { gbracket_count--; + if (!gbracket_count) BEGIN INITIAL; } + +. {} +%% diff --git a/gen/ff_planner/lex-ops_pddl.l b/gen/ff_planner/lex-ops_pddl.l new file mode 100644 index 000000000..0e9d8499d --- /dev/null +++ b/gen/ff_planner/lex-ops_pddl.l @@ -0,0 +1,151 @@ +%{ +#include "ff.h" +#include "parse.h" + +/* default yywrap function - always treat EOF as an EOF */ +int ops_pddlwrap() { return 1; }; + +%} + +a [Aa] +b [Bb] +c [Cc] +d [Dd] +e [Ee] +f [Ff] +g [Gg] +h [Hh] +i [Ii] +j [Jj] +k [Kk] +l [Ll] +m [Mm] +n [Nn] +o [Oo] +p [Pp] +q [Qq] +r [Rr] +s [Ss] +t [Tt] +u [Uu] +v [Vv] +w [Ww] +x [Xx] +y [Yy] +z [Zz] + +%x COMMENT OVERREAD + +%% + +"(" { return(OPEN_PAREN); } + +")" { return(CLOSE_PAREN); } + +{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } + +{d}{o}{m}{a}{i}{n} { return(DOMAIN_TOK); } + +":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { return(REQUIREMENTS_TOK); } + +":"{t}{y}{p}{e}{s} { return(TYPES_TOK); } + +{n}{u}{m}{b}{e}{r} { return(NUMBER_TOK); } + +":"{c}{o}{n}{s}{t}{a}{n}{t}{s} { return(CONSTANTS_TOK); } + +":"{p}{r}{e}{d}{i}{c}{a}{t}{e}{s} { return(PREDICATES_TOK); } + +":"{f}{u}{n}{c}{t}{i}{o}{n}{s} { return(FUNCTIONS_TOK); } + +":"{a}{c}{t}{i}{o}{n} { return(ACTION_TOK); } + +":"{d}{e}{r}{i}{v}{e}{d} { return(AXIOM_TOK); } + +":"{p}{a}{r}{a}{m}{e}{t}{e}{r}{s} { return(PARAMETERS_TOK); } + +":"{v}{a}{r}{s} { return(VARS_TOK); } + +":"{p}{r}{e}{c}{o}{n}{d}{i}{t}{i}{o}{n} { return(PRECONDITION_TOK); } + +":"{e}{f}{f}{e}{c}{t} { return(EFFECT_TOK); } + +":"{i}{m}{p}{l}{i}{e}{s} { return(IMPLIES_TOK); } + +{a}{n}{d} { return(AND_TOK); } + +{n}{o}{t} { return(NOT_TOK); } + +{w}{h}{e}{n} { return(WHEN_TOK); } + +{i}{m}{p}{l}{y} { return(IMPLY_TOK); } + +{o}{r} { return(OR_TOK); } + +{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } + +{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } + +"<" { return(LE_TOK); } + +"<=" { return(LEQ_TOK); } + +"=" { return(EQ_TOK); } + +">=" { return(GEQ_TOK); } + +">" { return(GE_TOK); } + +"-" { return(MINUS_TOK); } + +"+" { return(AD_TOK); } + +"*" { return(MU_TOK); } + +"/" { return(DI_TOK); } + +{a}{s}{s}{i}{g}{n} { return(ASSIGN_TOK); } + +{s}{c}{a}{l}{e}"-"{u}{p} { return(SCALE_UP_TOK); } + +{s}{c}{a}{l}{e}"-"{d}{o}{w}{n} { return(SCALE_DOWN_TOK); } + +{i}{n}{c}{r}{e}{a}{s}{e} { return(INCREASE_TOK); } + +{d}{e}{c}{r}{e}{a}{s}{e} { return(DECREASE_TOK); } + + +:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase(yytext); strcpy(yylval.string, yytext); + return(NAME); } + +\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* { strupcase(yytext); strcpy(yylval.string, yytext); + return(VARIABLE); } + +"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} + + +"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } + +\;(.)*\n { lineno++; } +\;(.)* { /* this will hold only in files that end with + a comment but no linefeed */ } + +(.^\")*\n { lineno++; } ; + +\" { BEGIN COMMENT;} + +\" { BEGIN INITIAL;} + +\n { lineno++; } + +(.^\(\))*\n { lineno++; } + +[^\(\)] { } + +\( { BEGIN OVERREAD; gbracket_count++; } + +\) { BEGIN OVERREAD; gbracket_count--; + if (!gbracket_count) BEGIN INITIAL; } + +. {} +%% diff --git a/gen/ff_planner/main.c b/gen/ff_planner/main.c new file mode 100644 index 000000000..bc3a795b5 --- /dev/null +++ b/gen/ff_planner/main.c @@ -0,0 +1,1230 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: main.c + * Description: The main routine for the Metric-FastForward Planner. + * Modified July 2011 to allow more command-line search + * confiogurations, including improved cost-minimization + * + * Author: original version Joerg Hoffmann 2001/2002 + * modified version Joerg Hoffmann 2012 + * + *********************************************************************/ + + + + + + + + +#include "ff.h" + +#include "memory.h" +#include "output.h" + +#include "parse.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_easy.h" +#include "inst_hard.h" +#include "inst_final.h" + +#include "relax.h" +#include "search.h" + + + + + + + + + + + +/* + * ----------------------------- GLOBAL VARIABLES ---------------------------- + */ + + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + +/* used to time the different stages of the planner + */ +float gtempl_time = 0, greach_time = 0, grelev_time = 0, gconn_time = 0; +float gLNF_time = 0, gsearch_time = 0; + + +/* the command line inputs + */ +struct _command_line gcmd_line; + +/* number of states that got heuristically evaluated + */ +int gevaluated_states = 0; + +/* maximal depth of breadth first search + */ +int gmax_search_depth = 0; + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + +/* used for pddl parsing, flex only allows global variables + */ +int gbracket_count; +char *gproblem_name; + +/* The current input line number + */ +int lineno = 1; + +/* The current input filename + */ +char *gact_filename; + +/* The pddl domain name + */ +char *gdomain_name = NULL; + +/* loaded, uninstantiated operators + */ +PlOperator *gloaded_ops = NULL; + +/* stores initials as fact_list + */ +PlNode *gorig_initial_facts = NULL; + +/* not yet preprocessed goal facts + */ +PlNode *gorig_goal_facts = NULL; + +/* axioms as in UCPOP before being changed to ops + */ +PlOperator *gloaded_axioms = NULL; + +/* the types, as defined in the domain file + */ +TypedList *gparse_types = NULL; + +/* the constants, as defined in domain file + */ +TypedList *gparse_constants = NULL; + +/* the predicates and their arg types, as defined in the domain file + */ +TypedListList *gparse_predicates = NULL; + +/* the functions and their arg types, as defined in the domain file + */ +TypedListList *gparse_functions = NULL; + +/* the objects, declared in the problem file + */ +TypedList *gparse_objects = NULL; + +/* the metric + */ +Token gparse_optimization; +ParseExpNode *gparse_metric = NULL; + + +/* connection to instantiation ( except ops, goal, initial ) + */ + +/* all typed objects + */ +FactList *gorig_constant_list = NULL; + +/* the predicates and their types + */ +FactList *gpredicates_and_types = NULL; + +/* the functions and their types + */ +FactList *gfunctions_and_types = NULL; + + + + + + + + + + + + +/***************** + * INSTANTIATING * + *****************/ + + + + + + + + + +/* global arrays of constant names, + * type names (with their constants), + * predicate names, + * predicate aritys, + * defined types of predicate args + */ +Token gconstants[MAX_CONSTANTS]; +int gnum_constants = 0; +Token gtype_names[MAX_TYPES]; +int gtype_consts[MAX_TYPES][MAX_TYPE]; +Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; +int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ +int gtype_size[MAX_TYPES]; +int gnum_types = 0; +Token gpredicates[MAX_PREDICATES]; +int garity[MAX_PREDICATES]; +Bool gaxiom_added[MAX_PREDICATES]; +int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; +int gnum_predicates = 0; +Token gfunctions[MAX_FUNCTIONS]; +int gf_arity[MAX_FUNCTIONS]; +int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; +int gnum_functions = 0; + + + + + +/* the domain in integer (Fact) representation + */ +Operator_pointer goperators[MAX_OPERATORS]; +int gnum_operators = 0; +Fact *gfull_initial; +int gnum_full_initial = 0; +FluentValue *gfull_fluents_initial; +int gnum_full_fluents_initial = 0; +WffNode *ggoal = NULL; + +ExpNode *gmetric = NULL; + + + +/* stores inertia - information: is any occurence of the predicate + * added / deleted in the uninstantiated ops ? + */ +Bool gis_added[MAX_PREDICATES]; +Bool gis_deleted[MAX_PREDICATES]; + + +/* for functions we *might* want to say, symmetrically, whether it is + * increased resp. decreased at all. + * + * that is, however, somewhat involved because the right hand + * sides can be arbirtray expressions, so we have no guarantee + * that increasing really does adds to a functions value... + * + * thus (for the time being), we settle for "is the function changed at all?" + */ +Bool gis_changed[MAX_FUNCTIONS]; + + + +/* splitted initial state: + * initial non static facts, + * initial static facts, divided into predicates + * (will be two dimensional array, allocated directly before need) + */ +Facts *ginitial = NULL; +int gnum_initial = 0; +Fact **ginitial_predicate; +int *gnum_initial_predicate; + +/* same thing for functions + */ +FluentValues *gf_initial; +int gnum_f_initial = 0; +FluentValue **ginitial_function; +int *gnum_initial_function; + + + +/* the type numbers corresponding to any unary inertia + */ +int gtype_to_predicate[MAX_PREDICATES]; +int gpredicate_to_type[MAX_TYPES]; + +/* (ordered) numbers of types that new type is intersection of + */ +TypeArray gintersected_types[MAX_TYPES]; +int gnum_intersected_types[MAX_TYPES]; + + + +/* splitted domain: hard n easy ops + */ +Operator_pointer *ghard_operators; +int gnum_hard_operators; +NormOperator_pointer *geasy_operators; +int gnum_easy_operators; + + + +/* so called Templates for easy ops: possible inertia constrained + * instantiation constants + */ +EasyTemplate *geasy_templates; +int gnum_easy_templates; + + + +/* first step for hard ops: create mixed operators, with conjunctive + * precondition and arbitrary effects + */ +MixedOperator *ghard_mixed_operators; +int gnum_hard_mixed_operators; + + + +/* hard ''templates'' : pseudo actions + */ +PseudoAction_pointer *ghard_templates; +int gnum_hard_templates; + + + +/* store the final "relevant facts" + */ +Fact grelevant_facts[MAX_RELEVANT_FACTS]; +int gnum_relevant_facts = 0; +int gnum_pp_facts = 0; +/* store the "relevant fluents" + */ +Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; +int gnum_relevant_fluents = 0; +Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; +/* this is NULL for normal, and the LNF for + * artificial fluents. + */ +LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; + + + +/* the final actions and problem representation + */ +Action *gactions = NULL; +int gnum_actions; +State ginitial_state; +int *glogic_goal = NULL; +int gnum_logic_goal = 0; +Comparator *gnumeric_goal_comp = NULL; +ExpNode_pointer *gnumeric_goal_lh = NULL, *gnumeric_goal_rh = NULL; +int gnum_numeric_goal = 0; + +/* direct numeric goal access + */ +Comparator *gnumeric_goal_direct_comp; +float *gnumeric_goal_direct_c; + + + +/* to avoid memory leaks; too complicated to identify + * the exact state of the action to throw away (during construction), + * memory gain not worth the implementation effort. + */ +Action *gtrash_actions = NULL; + + + +/* additional lnf step between finalized inst and + * conn graph + */ +Comparator *glnf_goal_comp = NULL; +LnfExpNode_pointer *glnf_goal_lh = NULL; +float *glnf_goal_rh = NULL; +int gnum_lnf_goal = 0; + +LnfExpNode glnf_metric; +Bool goptimization_established = FALSE; + + + + + + + +/********************** + * CONNECTIVITY GRAPH * + **********************/ + + + + + + + +/* one ops (actions) array ... + */ +OpConn *gop_conn; +int gnum_op_conn; + + + +/* one effects array ... + */ +EfConn *gef_conn; +int gnum_ef_conn; + + + +/* one facts array. + */ +FtConn *gft_conn; +int gnum_ft_conn; + + + +/* and: one fluents array. + */ +FlConn *gfl_conn; +int gnum_fl_conn; +int gnum_real_fl_conn;/* number of non-artificial ones */ + + + +/* final goal is also transformed one more step. + */ +int *gflogic_goal = NULL; +int gnum_flogic_goal = 0; +Comparator *gfnumeric_goal_comp = NULL; +int *gfnumeric_goal_fl = NULL; +float *gfnumeric_goal_c = NULL; +int gnum_fnumeric_goal = 0; + +/* direct access (by relevant fluents) + */ +Comparator *gfnumeric_goal_direct_comp = NULL; +float *gfnumeric_goal_direct_c = NULL; + + + + + + + + + + + +/******************* + * SEARCHING NEEDS * + *******************/ + + + + + + + + + + + +/* applicable actions + */ +int *gA;/* non-axioms */ +int gnum_A; +int *gA_axioms; /* axioms */ +int gnum_A_axioms; + + + +/* communication from extract 1.P. to search engine: + * 1P action choice + */ +int *gH; +int gnum_H; +/* added cost of relaxed plan + */ +float gh_cost; +/* hmax value + */ +float ghmax; + + + +/* to store plan + */ +int gplan_ops[MAX_PLAN_LENGTH]; +int gnum_plan_ops = 0; + + + +/* stores the states that the current plan goes through + * ( for knowing where new agenda entry starts from ) + */ +State gplan_states[MAX_PLAN_LENGTH + 1]; + + + + + + + +/* dirty: multiplic. of total-time in final metric LNF + */ +float gtt; + + + + + + + +/* the mneed structures + */ +Bool **gassign_influence; +Bool **gTassign_influence; + + + +/* the real var input to the mneed computation. + */ +Bool *gmneed_start_D; +float *gmneed_start_V; + + + +/* does this contain conditional effects? + * (if it does then the state hashing has to be made more + * cautiously) + */ +Bool gconditional_effects; + + + +/* easier to question: are we optimizing or no? + */ +Bool gcost_minimizing; + + + +/* stores current A* weight: this is initially given by user, + * but changes during anytime search. + */ +float gw; +/* this is the minimum weight, ie we'll stop once the weight update + * does/would yield a value <= this. + * if no such minim weight is given, this will be -1 + */ +float gmin_w = -1; + + + +/* this one says whether or not we are actually using + * cost-minimizing rplans. + * this will be the case by default if we're running cost- + * minimizing searches. it can be switched off by a flag; + * it is automatically switched off in case there are + * numeric preconditions/goals: for this case, + * cost-minimizing rplans are not implemented (a numeric prec + * may cause an action to come in "later" on in the RPG although + * its logical pres are easy. in that case, any new effects will + * have a smaller RPGcost value than facts we already have waiting. + * in other words, the "Dijsktra" nature breaks. + * + * ... I suppose there may be a generic solution to this that + * can handle numeric precs/goals. Doesn't seem important enough + * to bother. + */ +Bool gcost_rplans; + + + + + + + + + + + + + +/* + * ----------------------------- HEADERS FOR PARSING ---------------------------- + * ( fns defined in the scan-* files ) + */ + + + + + + + +void get_fct_file_name( char *filename ); +void load_ops_file( char *filename ); +void load_fct_file( char *filename ); + + + + + + + + + + + +/* + * ----------------------------- MAIN ROUTINE ---------------------------- + */ + + + + + +struct tms lstart, lend; + + + + + +int main( int argc, char *argv[] ) + +{ + + /* resulting name for ops file + */ + char ops_file[MAX_LENGTH] = ""; + /* same for fct file + */ + char fct_file[MAX_LENGTH] = ""; + + struct tms start, end; + + Bool found_plan; + int i; + float cost; + + Bool prev_gcost_rplans; + + + + times ( &lstart ); + + /* command line treatment + */ + gcmd_line.display_info = 1; + gcmd_line.debug = 0; + + /* search settings + */ + gcmd_line.search_config = 5; + gcmd_line.cost_rplans = TRUE; + gcmd_line.w = 5; + gcmd_line.cost_bound = -1; + + memset(gcmd_line.ops_file_name, 0, MAX_LENGTH); + memset(gcmd_line.fct_file_name, 0, MAX_LENGTH); + memset(gcmd_line.path, 0, MAX_LENGTH); + + if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { + ff_usage(); + exit( 1 ); + } + if ( !process_command_line( argc, argv ) ) { + ff_usage(); + exit( 1 ); + } + + + /* make file names + */ + + /* one input name missing + */ + if ( !gcmd_line.ops_file_name || + !gcmd_line.fct_file_name ) { + fprintf(stdout, "\nff: two input files needed\n\n"); + ff_usage(); + exit( 1 ); + } + /* add path info, complete file names will be stored in + * ops_file and fct_file + */ + sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); + sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); + + + /* parse the input files + */ + + /* start parse & instantiation timing + */ + times( &start ); + /* domain file (ops) + */ + if ( gcmd_line.display_info >= 1 ) { + printf("\nff: parsing domain file"); + } + /* it is important for the pddl language to define the domain before + * reading the problem + */ + load_ops_file( ops_file ); + /* problem file (facts) + */ + if ( gcmd_line.display_info >= 1 ) { + printf(" ... done.\nff: parsing problem file"); + } + load_fct_file( fct_file ); + if ( gcmd_line.display_info >= 1 ) { + printf(" ... done.\n\n"); + } + + /* This is needed to get all types. + */ + build_orig_constant_list(); + + /* last step of parsing: see if it's an ADL domain! + */ + if ( !make_adl_domain() ) { + printf("\nff: this is not an ADL problem!"); + printf("\n can't be handled by this version.\n\n"); + exit( 1 ); + } + + + /* now instantiate operators; + */ + + + /************************** + * first do PREPROCESSING * + **************************/ + + /* start by collecting all strings and thereby encoding + * the domain in integers. + */ + encode_domain_in_integers(); + + /* inertia preprocessing, first step: + * - collect inertia information + * - split initial state into + * - arrays for individual predicates + * - arrays for all static relations + * - array containing non - static relations + */ + do_inertia_preprocessing_step_1(); + + /* normalize all PL1 formulae in domain description: + * (goal, preconds and effect conditions) + * - simplify formula + * - expand quantifiers + * - NOTs down + */ + normalize_all_wffs(); + + /* translate negative preconds: introduce symmetric new predicate + * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) + */ + translate_negative_preconds(); + + /* split domain in easy (disjunction of conjunctive preconds) + * and hard (non DNF preconds) part, to apply + * different instantiation algorithms + */ + split_domain(); + + /*********************************************** + * PREPROCESSING FINISHED * + * * + * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * + ***********************************************/ + + build_easy_action_templates(); + build_hard_action_templates(); + + times( &end ); + TIME( gtempl_time ); + + times( &start ); + + /* perform reachability analysis in terms of relaxed + * fixpoint + */ + perform_reachability_analysis(); + + times( &end ); + TIME( greach_time ); + + times( &start ); + + /* collect the relevant facts and build final domain + * and problem representations. + */ + collect_relevant_facts_and_fluents(); + + times( &end ); + TIME( grelev_time ); + + + /* now transform problem to additive normal form, + * if possible + */ + times( &start ); + if ( !transform_to_LNF() ) { + printf("\n\nThis is not a linear task!\n\n"); + exit( 1 ); + } + times( &end ); + TIME( gLNF_time ); + + times( &start ); + + /* now build globally accessable connectivity graph + */ + build_connectivity_graph(); + + /* now check for acyclic := effects (in expressions.c) + */ + check_assigncycles(); + /* set the relevanc info (in expressions.c) + */ + determine_fl_relevance(); + + times( &end ); + TIME( gconn_time ); + + /*********************************************************** + * we are finally through with preprocessing and can worry * + * bout finding a plan instead. * + ***********************************************************/ + + if ( gcmd_line.display_info ) { + printf("\n\nff: search configuration is "); + switch ( gcmd_line.search_config ) { + case 0: + printf("Enforced Hill-Climbing, if that fails then best-first search.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION"); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 1: + printf("best-first search.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION"); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 2: + printf("best-first search with helpful actions pruning.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION."); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 3: + printf("weighted A* with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf(" plan length"); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + case 4: + printf("A*epsilon with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); + exit( 1 ); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + case 5: + printf("Enforced Hill-Climbing, then A*epsilon with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); + exit( 1 ); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + default: + printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); + exit( 1 ); + } + } else { + if ( gcmd_line.search_config == 4 && !goptimization_established ) { + exit( 1 ); + } + } + + + times( &start ); + + + + /* need to evaluate derived predicates in initial state! + */ + do_axiom_update( &ginitial_state ); + + + if ( !gcost_rplans ) { + gcmd_line.cost_bound = -1; + } + + switch ( gcmd_line.search_config ) { + case 0: + found_plan = do_enforced_hill_climbing(); + if ( found_plan ) { + if ( gcmd_line.display_info ) { + print_plan(); + } + } else { + if ( gcmd_line.display_info ) { + printf("\n\nEnforced Hill-climbing failed !"); + printf("\nswitching to Best-first Search now.\n"); + } + do_best_first_search(); + } + break; + case 1: + case 2: + do_best_first_search(); + break; + case 3: + do_weighted_Astar(); + break; + case 4: + do_Astar_epsilon(); + break; + case 5: + /* gcost_rplans controls whether or not we compute cost-minimal relaxed plans + * gcost_minimizing is only used in h fn to decide whether or not we + * need to count the weights of the operators in the relaxed plan. + * + * gcost_rplans may be false even for search options 3,4,5, namely if there are + * numeric preconditions/goals which make this relaxed plan variant invalid. + * hence we need to remember, when switching it off for EHC, whether or not + * it was previously on. + */ + prev_gcost_rplans = gcost_rplans; + gcost_rplans = FALSE; + gcost_minimizing = FALSE; + found_plan = do_enforced_hill_climbing(); + if ( found_plan ) { + print_plan(); + } else { + if ( gcmd_line.display_info ) { + printf("\n\nEnforced Hill-climbing not successful."); + printf("\nSwitching to A*epsilon now."); + } + gcost_rplans = prev_gcost_rplans; + gcost_minimizing = TRUE; + do_Astar_epsilon(); + } + break; + default: + printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); + exit( 1 ); + } + + times( &end ); + TIME( gsearch_time ); + + + + output_planner_info(); + + printf("\n\n"); + exit( 0 ); + +} + + + + + + + + + + + +/* + * ----------------------------- HELPING FUNCTIONS ---------------------------- + */ + + + + + + + + + + + + +void output_planner_info( void ) + +{ + + printf( "\n\ntime spent: %7.2f seconds instantiating %d easy, %d hard action templates", + gtempl_time, gnum_easy_templates, gnum_hard_mixed_operators ); + printf( "\n %7.2f seconds reachability analysis, yielding %d facts and %d actions", + greach_time, gnum_pp_facts, gnum_actions ); + printf( "\n %7.2f seconds creating final representation with %d relevant facts, %d relevant fluents", + grelev_time, gnum_relevant_facts, gnum_relevant_fluents ); + printf( "\n %7.2f seconds computing LNF", + gLNF_time ); + printf( "\n %7.2f seconds building connectivity graph", + gconn_time ); + printf( "\n %7.2f seconds searching, evaluating %d states, to a max depth of %d", + gsearch_time, gevaluated_states, gmax_search_depth ); + printf( "\n %7.2f seconds total time", + gtempl_time + greach_time + grelev_time + gLNF_time + gconn_time + gsearch_time ); + + printf("\n\n"); + + exit( 0 ); + +} + + + +void ff_usage( void ) + +{ + + printf("\nusage of ff:\n"); + + printf("\nOPTIONS DESCRIPTIONS\n\n"); + printf("-p Path for operator and fact file\n"); + printf("-o Operator file name\n"); + printf("-f Fact file name\n\n"); + + printf("-r Random seed [used for random restarts; preset: 0]\n\n"); + + printf("-s Search configuration [preset: s=5]; '+H': helpful actions pruning\n"); + printf(" 0 Standard-FF: EHC+H then BFS (cost minimization: NO)\n"); + printf(" 1 BFS (cost minimization: NO)\n"); + printf(" 2 BFS+H (cost minimization: NO)\n"); + printf(" 3 Weighted A* (cost minimization: YES)\n"); + printf(" 4 A*epsilon (cost minimization: YES)\n"); + printf(" 5 EHC+H then A*epsilon (cost minimization: YES)\n"); + printf("-w Set weight w for search configs 3,4,5 [preset: w=5]\n\n"); + + printf("-C Do NOT use cost-minimizing relaxed plans for options 3,4,5\n\n"); + + printf("-b Fixed upper bound on solution cost (prune based on g+hmax); active only with cost minimization\n\n"); + + if ( 0 ) { + printf("-i run-time information level( preset: 1 )\n"); + printf(" 0 only times\n"); + printf(" 1 problem name, planning process infos\n"); + printf(" 101 parsed problem data\n"); + printf(" 102 cleaned up ADL problem\n"); + printf(" 103 collected string tables\n"); + printf(" 104 encoded domain\n"); + printf(" 105 predicates inertia info\n"); + printf(" 106 splitted initial state\n"); + printf(" 107 domain with Wff s normalized\n"); + printf(" 108 domain with NOT conds translated\n"); + printf(" 109 splitted domain\n"); + printf(" 110 cleaned up easy domain\n"); + printf(" 111 unaries encoded easy domain\n"); + printf(" 112 effects multiplied easy domain\n"); + printf(" 113 inertia removed easy domain\n"); + printf(" 114 easy action templates\n"); + printf(" 115 cleaned up hard domain representation\n"); + printf(" 116 mixed hard domain representation\n"); + printf(" 117 final hard domain representation\n"); + printf(" 118 reachability analysis results\n"); + printf(" 119 facts selected as relevant\n"); + printf(" 120 final domain and problem representations\n"); + printf(" 121 normalized expressions representation\n"); + printf(" 122 LNF: translated subtractions representation\n"); + printf(" 123 summarized effects LNF representation\n"); + printf(" 124 encoded LNF representation\n"); + printf(" 125 connectivity graph\n"); + printf(" 126 fixpoint result on each evaluated state\n"); + printf(" 127 1P extracted on each evaluated state\n"); + printf(" 128 H set collected for each evaluated state\n"); + + printf("\n-d switch on debugging\n\n"); + } + +} + + + +Bool process_command_line( int argc, char *argv[] ) + +{ + + char option; + + while ( --argc && ++argv ) { + if ( *argv[0] != '-' || strlen(*argv) != 2 ) { + return FALSE; + } + option = *++argv[0]; + switch ( option ) { +/* case 'E': */ +/* gcmd_line.ehc = FALSE; */ +/* break; */ +/* case 'O': */ +/* gcmd_line.optimize = TRUE; */ +/* gcmd_line.ehc = FALSE; */ +/* break; */ + case 'C': + gcmd_line.cost_rplans = FALSE; + break; + default: + if ( --argc && ++argv ) { + switch ( option ) { + case 'p': + strncpy( gcmd_line.path, *argv, MAX_LENGTH ); + break; + case 'o': + strncpy( gcmd_line.ops_file_name, *argv, MAX_LENGTH ); + break; + case 'f': + strncpy( gcmd_line.fct_file_name, *argv, MAX_LENGTH ); + break; + case 'i': + sscanf( *argv, "%d", &gcmd_line.display_info ); + break; + case 'd': + sscanf( *argv, "%d", &gcmd_line.debug ); + break; + case 's': + sscanf( *argv, "%d", &gcmd_line.search_config ); + break; + case 'w': + sscanf( *argv, "%d", &gcmd_line.w ); + break; + case 'b': + sscanf( *argv, "%f", &gcmd_line.cost_bound ); + break; + default: + printf( "\nff: unknown option: %c entered\n\n", option ); + return FALSE; + } + } else { + return FALSE; + } + } + } + + if ( 0 > gcmd_line.search_config || gcmd_line.search_config > 5 ) { + printf("\n\nff: unknown search configuration %d.\n\n", + gcmd_line.search_config); + return FALSE; + } + + if ( gcmd_line.search_config <= 2 ) { + gcost_minimizing = FALSE; + gcost_rplans = FALSE; + } else { + gcost_minimizing = TRUE; + gcost_rplans = TRUE; + } + + gw = gcmd_line.w; + + if ( !gcmd_line.cost_rplans ) { + gcost_rplans = FALSE; + } + + if ( gcmd_line.cost_bound != -1 && gcmd_line.cost_bound < 0 ) { + printf("\n\nff: invalid cost bound %f; must be >= 0.\n\n", + gcmd_line.cost_bound); + return FALSE; + } + + return TRUE; + +} + diff --git a/gen/ff_planner/makefile b/gen/ff_planner/makefile new file mode 100644 index 000000000..b8ace7b81 --- /dev/null +++ b/gen/ff_planner/makefile @@ -0,0 +1,89 @@ +#!/bin/sh +# + + +####### FLAGS + +TYPE = +ADDONS = + +CC = gcc + +CFLAGS = -O6 -ansi $(TYPE) $(ADDONS) -g +# -g -pg + +LIBS = -lm + + +####### Files + +PDDL_PARSER_SRC = scan-fct_pddl.tab.c \ + scan-ops_pddl.tab.c \ + scan-probname.tab.c \ + lex.fct_pddl.c \ + lex.ops_pddl.c + +PDDL_PARSER_OBJ = scan-fct_pddl.tab.o \ + scan-ops_pddl.tab.o + + +SOURCES = main.c \ + memory.c \ + output.c \ + parse.c \ + expressions.c \ + inst_pre.c \ + inst_easy.c \ + inst_hard.c \ + inst_final.c \ + relax.c \ + search.c + +OBJECTS = $(SOURCES:.c=.o) + +####### Implicit rules + +.SUFFIXES: + +.SUFFIXES: .c .o + +.c.o:; $(CC) -c $(CFLAGS) $< + +####### Build rules + + +ff: $(OBJECTS) $(PDDL_PARSER_OBJ) + $(CC) -o ff $(OBJECTS) $(PDDL_PARSER_OBJ) $(CFLAGS) $(LIBS) + +# pddl syntax +scan-fct_pddl.tab.c: scan-fct_pddl.y lex.fct_pddl.c + bison -pfct_pddl -bscan-fct_pddl scan-fct_pddl.y + +scan-ops_pddl.tab.c: scan-ops_pddl.y lex.ops_pddl.c + bison -pops_pddl -bscan-ops_pddl scan-ops_pddl.y + +lex.fct_pddl.c: lex-fct_pddl.l + flex -Pfct_pddl lex-fct_pddl.l + +lex.ops_pddl.c: lex-ops_pddl.l + flex -Pops_pddl lex-ops_pddl.l + + +# misc +clean: + rm -f *.o *.bak *~ *% core *_pure_p9_c0_400.o.warnings \ + \#*\# $(RES_PARSER_SRC) $(PDDL_PARSER_SRC) + +veryclean: clean + rm -f ff H* J* K* L* O* graph.* *.symbex gmon.out \ + $(PDDL_PARSER_SRC) \ + lex.fct_pddl.c lex.ops_pddl.c lex.probname.c \ + *.output + +depend: + makedepend -- $(SOURCES) $(PDDL_PARSER_SRC) + +lint: + lclint -booltype Bool $(SOURCES) 2> output.lint + +# DO NOT DELETE diff --git a/gen/ff_planner/memory.c b/gen/ff_planner/memory.c new file mode 100644 index 000000000..601cea497 --- /dev/null +++ b/gen/ff_planner/memory.c @@ -0,0 +1,1278 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: memory.c + * Description: Creation and Deletion functions for all data structures. + * + * Author: Joerg Hoffmann + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" +#include "memory.h" + + +#include "inst_pre.h" + + + + + + +/********************** + * CREATION FUNCTIONS * + **********************/ + + + + + + + + + + + +/* parsing + */ + + + + + + + + + +char *new_Token( int len ) + +{ + + char *tok = ( char * ) calloc( len, sizeof( char ) ); + CHECK_PTR(tok); + + return tok; + +} + + + +TokenList *new_TokenList( void ) + +{ + + TokenList *result = ( TokenList * ) calloc( 1, sizeof( TokenList ) ); + CHECK_PTR(result); + + result->item = NULL; + result->next = NULL; + + return result; + +} + + + +FactList *new_FactList( void ) + +{ + + FactList *result = ( FactList * ) calloc( 1, sizeof( FactList ) ); + CHECK_PTR(result); + + result->item = NULL; + result->next = NULL; + + return result; + +} + + + +TypedList *new_TypedList( void ) + +{ + + TypedList *result = ( TypedList * ) calloc( 1, sizeof( TypedList ) ); + CHECK_PTR(result); + + result->name = NULL; + result->type = NULL; + result->n = -1; + + return result; + +} + + + +TypedListList *new_TypedListList( void ) + +{ + + TypedListList *result = ( TypedListList * ) calloc( 1, sizeof( TypedListList ) ); + CHECK_PTR(result); + + result->predicate = NULL; + result->args = NULL; + + return result; + +} + + + +ParseExpNode *new_ParseExpNode( ExpConnective c ) + +{ + + ParseExpNode *result = ( ParseExpNode * ) calloc( 1, sizeof( ParseExpNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->atom = NULL; + result->leftson = NULL; + result->rightson = NULL; + + return result; + +} + + + +PlNode *new_PlNode( Connective c ) + +{ + + PlNode *result = ( PlNode * ) calloc( 1, sizeof( PlNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->atom = NULL; + + result->comp = -1; + result->neft = -1; + result->lh = NULL; + result->rh = NULL; + + result->sons = NULL; + result->next = NULL; + + return result; + +} + + + +PlOperator *new_PlOperator( char *name ) + +{ + + PlOperator *result = ( PlOperator * ) calloc( 1, sizeof( PlOperator ) ); + CHECK_PTR(result); + + if ( name ) { + result->name = new_Token(strlen(name)+1); + CHECK_PTR(result->name); + strcpy(result->name, name); + } else { + result->name = NULL; + } + + result->params = NULL; + result->preconds = NULL; + result->effects = NULL; + result->number_of_real_params = 0; + result->next = NULL; + + return result; + +} + + + +PlOperator *new_axiom_op_list( void ) + +{ + + static int count; + char *name; + PlOperator *ret; + + /* WARNING: count should not exceed 999 + */ + count++; + if ( count == 10000 ) { + printf("\ntoo many axioms! look into memory.c, line 157\n\n"); + exit( 1 ); + } + name = new_Token(strlen(HIDDEN_STR)+strlen(AXIOM_STR)+4+1); + sprintf(name, "%s%s%4d", HIDDEN_STR, AXIOM_STR, count); + + ret = new_PlOperator(name); + free(name); + + return ret; + +} + + + + + + + + + + + + + + +/* instantiation + */ + + + + + + + + + + + +Fact *new_Fact( void ) + +{ + + Fact *result = ( Fact * ) calloc( 1, sizeof( Fact ) ); + CHECK_PTR(result); + + return result; + +} + + + +Fluent *new_Fluent( void ) + +{ + + Fluent *result = ( Fluent * ) calloc( 1, sizeof( Fluent ) ); + CHECK_PTR(result); + + return result; + +} + + + +FluentValue *new_FluentValue( void ) + +{ + + FluentValue *result = ( FluentValue * ) calloc( 1, sizeof( FluentValue ) ); + CHECK_PTR(result); + + return result; + +} + + + +Facts *new_Facts( void ) + +{ + + Facts *result = ( Facts * ) calloc( 1, sizeof( Facts ) ); + CHECK_PTR(result); + + result->fact = new_Fact(); + + result->next = NULL; + + return result; + +} + + + +FluentValues *new_FluentValues( void ) + +{ + + FluentValues *result = ( FluentValues * ) calloc( 1, sizeof( FluentValues ) ); + CHECK_PTR(result); + + result->next = NULL; + + return result; + +} + + + +ExpNode *new_ExpNode( ExpConnective c ) + +{ + + ExpNode *result = ( ExpNode * ) calloc( 1, sizeof( ExpNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->fluent = NULL; + result->fl = -2; + result->c = 1; + result->son = NULL; + result->leftson = NULL; + result->rightson = NULL; + + return result; + +} + + + +WffNode *new_WffNode( Connective c ) + +{ + + WffNode *result = ( WffNode * ) calloc( 1, sizeof( WffNode ) ); + CHECK_PTR(result); + + result->connective = c; + + result->var = -1; + result->var_type = -1; + result->var_name = NULL; + + result->sons = NULL; + result->next = NULL; + result->prev = NULL; + + result->fact = NULL; + result->NOT_p = -1; + + result->son = NULL; + + result->comp = -1; + result->lh = NULL; + result->rh = NULL; + + result->visited = FALSE; + + return result; + +} + + + +Literal *new_Literal( void ) + +{ + + Literal *result = ( Literal * ) calloc( 1, sizeof( Literal ) ); + CHECK_PTR(result); + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NumericEffect *new_NumericEffect( void ) + +{ + + NumericEffect *result = ( NumericEffect * ) calloc( 1, sizeof( NumericEffect ) ); + CHECK_PTR(result); + + result->rh = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +Effect *new_Effect( void ) + +{ + + Effect *result = ( Effect * ) calloc( 1, sizeof( Effect ) ); + CHECK_PTR(result); + + result->num_vars = 0; + + result->conditions = NULL; + + result->effects = NULL; + result->numeric_effects = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +Operator *new_Operator( char *name, int norp ) + +{ + + int i; + + Operator *result = ( Operator * ) calloc( 1, sizeof( Operator ) ); + CHECK_PTR(result); + + if ( name ) { + result->name = new_Token( strlen( name ) + 1 ); + CHECK_PTR( result->name ); + strcpy( result->name, name ); + } else { + result->name = NULL; + } + + result->num_vars = 0; + result->number_of_real_params = norp; + + for ( i = 0; i < MAX_VARS; i++ ) { + result->removed[i] = FALSE; + } + + result->preconds = NULL; + + result->effects = NULL; + + result->hard = TRUE; + + return result; + +} + + + +NormEffect *new_NormEffect1( Effect *e ) + +{ + + int i; + + NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); + CHECK_PTR(result); + + result->num_vars = e->num_vars; + for ( i = 0; i < e->num_vars; i++ ) { + result->var_types[i] = e->var_types[i]; + result->inst_table[i] = -1; + } + + result->conditions = NULL; + result->num_conditions = 0; + + result->adds = NULL; + result->num_adds = 0; + result->dels = NULL; + result->num_dels = 0; + + result->numeric_conditions_comp = NULL; + result->numeric_conditions_lh = NULL; + result->numeric_conditions_rh = NULL; + result->num_numeric_conditions = 0; + + result->numeric_effects_neft = NULL; + result->numeric_effects_fluent = NULL; + result->numeric_effects_rh = NULL; + result->num_numeric_effects = 0; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NormEffect *new_NormEffect2( NormEffect *e ) + +{ + + int i, j; + + NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); + CHECK_PTR(result); + + result->num_vars = 0; + + result->conditions = ( Fact * ) calloc( e->num_conditions, sizeof( Fact ) ); + result->num_conditions = e->num_conditions; + for ( i = 0; i < e->num_conditions; i++ ) { + result->conditions[i].predicate = e->conditions[i].predicate; + for ( j = 0; j < garity[e->conditions[i].predicate]; j++ ) { + result->conditions[i].args[j] = e->conditions[i].args[j]; + } + } + result->adds = ( Fact * ) calloc( e->num_adds, sizeof( Fact ) ); + result->num_adds = e->num_adds; + for ( i = 0; i < e->num_adds; i++ ) { + result->adds[i].predicate = e->adds[i].predicate; + for ( j = 0; j < garity[e->adds[i].predicate]; j++ ) { + result->adds[i].args[j] = e->adds[i].args[j]; + } + } + result->dels = ( Fact * ) calloc( e->num_dels, sizeof( Fact ) ); + result->num_dels = e->num_dels; + for ( i = 0; i < e->num_dels; i++ ) { + result->dels[i].predicate = e->dels[i].predicate; + for ( j = 0; j < garity[e->dels[i].predicate]; j++ ) { + result->dels[i].args[j] = e->dels[i].args[j]; + } + } + + result->numeric_conditions_comp = ( Comparator * ) + calloc( e->num_numeric_conditions, sizeof( Comparator ) ); + result->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + result->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + result->numeric_conditions_comp[i] = e->numeric_conditions_comp[i]; + result->numeric_conditions_lh[i] = copy_Exp( e->numeric_conditions_lh[i] ); + result->numeric_conditions_rh[i] = copy_Exp( e->numeric_conditions_rh[i] ); + } + result->num_numeric_conditions = e->num_numeric_conditions; + result->numeric_effects_neft = ( NumericEffectType * ) + calloc( e->num_numeric_effects, sizeof( NumericEffectType ) ); + result->numeric_effects_fluent = ( Fluent * ) + calloc( e->num_numeric_effects, sizeof( Fluent ) ); + result->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( e->num_numeric_effects, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < e->num_numeric_effects; i++ ) { + result->numeric_effects_neft[i] = e->numeric_effects_neft[i]; + result->numeric_effects_fluent[i].function = e->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[e->numeric_effects_fluent[i].function]; j++ ) { + result->numeric_effects_fluent[i].args[j] = e->numeric_effects_fluent[i].args[j]; + } + result->numeric_effects_rh[i] = copy_Exp( e->numeric_effects_rh[i] ); + } + result->num_numeric_effects = e->num_numeric_effects; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NormOperator *new_NormOperator( Operator *op ) + +{ + + int i; + + NormOperator *result = ( NormOperator * ) calloc( 1, sizeof( NormOperator ) ); + CHECK_PTR(result); + + result->operator = op; + + result->num_vars = op->num_vars; + for ( i = 0; i < op->num_vars; i++ ) { + result->var_types[i] = op->var_types[i]; + result->inst_table[i] = -1; + } + result->num_removed_vars = 0; + + result->preconds = NULL; + result->num_preconds = 0; + + result->numeric_preconds_comp = NULL; + result->numeric_preconds_lh = NULL; + result->numeric_preconds_rh = NULL; + result->num_numeric_preconds = 0; + + result->effects = NULL; + + return result; + +} + + + + +EasyTemplate *new_EasyTemplate( NormOperator *op ) + +{ + + EasyTemplate *result = ( EasyTemplate * ) calloc( 1, sizeof( EasyTemplate ) ); + CHECK_PTR(result); + + result->op = op; + + result->prev = NULL; + result->next = NULL; + + return result; + +} + + + +MixedOperator *new_MixedOperator( Operator *op ) + +{ + + MixedOperator *result = ( MixedOperator * ) calloc( 1, sizeof( MixedOperator ) ); + CHECK_PTR(result); + + result->operator = op; + + result->preconds = NULL; + result->num_preconds = 0; + + result->effects = NULL; + + return result; + +} + + + +PseudoActionEffect *new_PseudoActionEffect( void ) + +{ + + PseudoActionEffect *result = + ( PseudoActionEffect * ) calloc( 1, sizeof( PseudoActionEffect ) ); + CHECK_PTR(result); + + result->conditions = NULL; + result->num_conditions = 0; + + result->adds = NULL; + result->num_adds = 0; + result->dels = NULL; + result->num_dels = 0; + + result->numeric_conditions_comp = NULL; + result->numeric_conditions_lh = NULL; + result->numeric_conditions_rh = NULL; + result->num_numeric_conditions = 0; + + result->numeric_effects_neft = NULL; + result->numeric_effects_fluent = NULL; + result->numeric_effects_rh = NULL; + result->num_numeric_effects = 0; + + result->next = NULL; + + return result; + +} + + + +PseudoAction *new_PseudoAction( MixedOperator *op ) + +{ + + int i; + + PseudoAction *result = ( PseudoAction * ) calloc( 1, sizeof( PseudoAction ) ); + CHECK_PTR(result); + + result->operator = op->operator; + for ( i = 0; i < op->operator->num_vars; i++ ) { + result->inst_table[i] = op->inst_table[i]; + } + + result->preconds = op->preconds; + result->num_preconds = op->num_preconds; + + result->numeric_preconds_comp = op->numeric_preconds_comp; + result->numeric_preconds_lh = op->numeric_preconds_lh; + result->numeric_preconds_rh = op->numeric_preconds_rh; + result->num_numeric_preconds = op->num_numeric_preconds; + + result->effects = NULL; + result->num_effects = 0; + + return result; + +} + + + +LnfExpNode *new_LnfExpNode( void ) + +{ + + LnfExpNode *result = ( LnfExpNode * ) calloc( 1, sizeof( LnfExpNode ) ); + CHECK_PTR(result); + + result->num_pF = 0; + result->num_nF = 0; + + result->c = 0; + + return result; + +} + + + +Action *new_Action( void ) + +{ + + Action *result = ( Action * ) calloc( 1, sizeof( Action ) ); + CHECK_PTR(result); + + result->norm_operator = NULL; + result->pseudo_action = NULL; + + result->next = NULL; + + return result; + +} + + + +void make_state( State *pointer, int ft, int fl ) + +{ + + int i; + + pointer->F = ( int * ) calloc( ft, sizeof( int ) ); + pointer->f_D = ( Bool * ) calloc( fl, sizeof( Bool ) ); + pointer->f_V = ( float * ) calloc( fl, sizeof( float ) ); + + for ( i = 0; i < fl; i++ ) { + pointer->f_D[i] = FALSE; + } + +} + + + +EhcNode *new_EhcNode( void ) + +{ + + EhcNode *result = ( EhcNode * ) calloc( 1, sizeof( EhcNode ) ); + CHECK_PTR(result); + + make_state( &(result->S), gnum_ft_conn, gnum_fl_conn ); + + result->father = NULL; + result->next = NULL; + + return result; + +} + + + +EhcHashEntry *new_EhcHashEntry( void ) + +{ + + EhcHashEntry *result = ( EhcHashEntry * ) calloc( 1, sizeof( EhcHashEntry ) ); + CHECK_PTR(result); + + result->ehc_node = NULL; + + result->next = NULL; + + return result; + +} + + + +PlanHashEntry *new_PlanHashEntry( void ) + +{ + + PlanHashEntry *result = ( PlanHashEntry * ) calloc( 1, sizeof( PlanHashEntry ) ); + CHECK_PTR(result); + + result->next_step = NULL; + + result->next = NULL; + + return result; + +} + + + +BfsNode *new_BfsNode( void ) + +{ + + BfsNode *result = ( BfsNode * ) calloc( 1, sizeof( BfsNode ) ); + CHECK_PTR(result); + + result->father = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +BfsHashEntry *new_BfsHashEntry( void ) + +{ + + BfsHashEntry *result = ( BfsHashEntry * ) calloc( 1, sizeof( BfsHashEntry ) ); + CHECK_PTR(result); + + result->bfs_node = NULL; + + result->next = NULL; + + return result; + +} + + + + + + + + + + + +/********************** + * DELETION FUNCTIONS * + **********************/ + + + + + + + + + + + + +void free_TokenList( TokenList *source ) + +{ + + if ( source ) { + free_TokenList( source->next ); + if ( source->item ) { + free( source->item ); + } + free( source ); + } + +} + + + +void free_FactList( FactList *source ) + +{ + + if ( source ) { + free_FactList( source->next ); + free_TokenList( source->item ); + free( source ); + } + +} + + + +void free_ParseExpNode( ParseExpNode *n ) + +{ + + if ( n ) { + free_TokenList( n->atom ); + free_ParseExpNode( n->leftson ); + free_ParseExpNode( n->rightson ); + free( n ); + } + +} + + + +void free_PlNode( PlNode *node ) + +{ + + if ( node ) { + free_ParseExpNode( node->lh ); + free_ParseExpNode( node->rh ); + free_PlNode( node->sons ); + free_PlNode( node->next ); + free_TokenList( node->atom ); + free( node ); + } + +} + + + +void free_PlOperator( PlOperator *o ) + +{ + + if ( o ) { + free_PlOperator( o->next ); + + if ( o->name ) { + free( o->name ); + } + + free_FactList( o->params ); + free_PlNode( o->preconds ); + free_PlNode( o->effects ); + + free( o ); + } + +} + + + +void free_Operator( Operator *o ) + +{ + + if ( o ) { + /* need not free more: the only point where that happens + * is only directly after first allocation + */ + + if ( o->name ) { + free( o->name ); + } + + free( o ); + } + +} + + + +void free_ExpNode( ExpNode *n ) + +{ + + if ( n ) { + if ( n->fluent ) free( n->fluent ); + free_ExpNode( n->son ); + free_ExpNode( n->leftson ); + free_ExpNode( n->rightson ); + free( n ); + } + +} + + + +void free_WffNode( WffNode *w ) + +{ + + if ( w ) { + free_WffNode( w->son ); + free_WffNode( w->sons ); + free_WffNode( w->next ); + if ( w->var_name ) { + free( w->var_name ); + } + if ( w->fact ) free( w->fact ); + free_ExpNode( w->lh ); + free_ExpNode( w->rh ); + free( w ); + } + +} + + + +void free_NormEffect( NormEffect *e ) + +{ + + int i; + + if ( e ) { + free_NormEffect( e->next ); + + if ( e->conditions ) { + free( e->conditions ); + } + if ( e->adds ) { + free( e->adds ); + } + if ( e->dels ) { + free( e->dels ); + } + + if ( e->numeric_conditions_comp ) { + free( e->numeric_conditions_comp ); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + free_ExpNode( e->numeric_conditions_lh[i] ); + free_ExpNode( e->numeric_conditions_rh[i] ); + } + if ( e->numeric_conditions_lh ) { + free( e->numeric_conditions_lh ); + } + if ( e->numeric_conditions_rh ) { + free( e->numeric_conditions_rh ); + } + + if ( e->numeric_effects_neft ) { + free( e->numeric_effects_neft ); + } + if ( e->numeric_effects_fluent ) { + free( e->numeric_effects_fluent ); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + free_ExpNode( e->numeric_effects_rh[i] ); + } + if ( e->numeric_effects_rh ) { + free( e->numeric_effects_rh ); + } + + free( e ); + } + +} + + + +void free_partial_Effect( Effect *e ) + +{ + + if ( e ) { + free_partial_Effect( e->next ); + + free_WffNode( e->conditions ); + + free( e ); + } + +} + + + +void free_NormOperator( NormOperator *o ) + +{ + + int i; + + if ( o ) { + + if ( o->preconds ) { + free( o->preconds ); + } + if ( o->numeric_preconds_comp ) { + free( o->numeric_preconds_comp ); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + free_ExpNode( o->numeric_preconds_lh[i] ); + free_ExpNode( o->numeric_preconds_rh[i] ); + } + if ( o->numeric_preconds_lh ) { + free( o->numeric_preconds_lh ); + } + if ( o->numeric_preconds_rh ) { + free( o->numeric_preconds_rh ); + } + free_NormEffect( o->effects ); + + free( o ); + } + +} + + + +void free_single_NormEffect( NormEffect *e ) + +{ + + int i; + + if ( e ) { + if ( e->conditions ) { + free( e->conditions ); + } + if ( e->adds ) { + free( e->adds ); + } + if ( e->dels ) { + free( e->dels ); + } + + if ( e->numeric_conditions_comp ) { + free( e->numeric_conditions_comp ); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + free_ExpNode( e->numeric_conditions_lh[i] ); + free_ExpNode( e->numeric_conditions_rh[i] ); + } + if ( e->numeric_conditions_lh ) { + free( e->numeric_conditions_lh ); + } + if ( e->numeric_conditions_rh ) { + free( e->numeric_conditions_rh ); + } + + if ( e->numeric_effects_neft ) { + free( e->numeric_effects_neft ); + } + if ( e->numeric_effects_fluent ) { + free( e->numeric_effects_fluent ); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + free_ExpNode( e->numeric_effects_rh[i] ); + } + if ( e->numeric_effects_rh ) { + free( e->numeric_effects_rh ); + } + + free( e ); + } + +} + + + +void free_single_EasyTemplate( EasyTemplate *t ) + +{ + + if ( t ) { + free( t ); + } + +} + + + +void free_TypedList( TypedList *t ) + +{ + + if ( t ) { + if ( t->name ) { + free( t->name ); + t->name = NULL; + } + if ( t->type ) { + free_TokenList( t->type ); + t->type = NULL; + } + free_TypedList( t->next ); + + free( t ); + } + +} + + + +void free_TypedListList( TypedListList *t ) + +{ + + if ( t ) { + if ( t->predicate ) { + free( t->predicate ); + t->predicate = NULL; + } + if ( t->args ) { + free_TypedList( t->args ); + t->args = NULL; + } + free_TypedListList( t->next ); + + free( t ); + } + +} + + + +void free_BfsNode( BfsNode *n ) + +{ + + if ( n ) { + free_BfsNode( n->next ); + free( n ); + } + +} + + + +void free_BfsHashEntry( BfsHashEntry *n ) + +{ + + if ( n ) { + free_BfsHashEntry( n->next ); + free( n ); + } + +} diff --git a/gen/ff_planner/memory.h b/gen/ff_planner/memory.h new file mode 100644 index 000000000..13e8ddfb3 --- /dev/null +++ b/gen/ff_planner/memory.h @@ -0,0 +1,109 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: memory.h + * Description: Creation / Deletion functions for all data structures. + * + * Author: Joerg Hoffmann / Frank Rittinger + * + *********************************************************************/ + + + + + + +#ifndef _MEMORY_H +#define _MEMORY_H + + + + + +char *new_Token( int len ); +TokenList *new_TokenList( void ); +FactList *new_FactList( void ); +TypedList *new_TypedList( void ); +TypedListList *new_TypedListList( void ); +ParseExpNode *new_ParseExpNode( ExpConnective c ); +PlNode *new_PlNode( Connective c ); +PlOperator *new_PlOperator( char *name ); +PlOperator *new_axiom_op_list( void ); + + + +Fact *new_Fact( void ); +Fluent *new_Fluent( void ); +FluentValue *new_FluentValue( void ); +Facts *new_Facts( void ); +FluentValues *new_FluentValues( void ); +ExpNode *new_ExpNode( ExpConnective c ); +WffNode *new_WffNode( Connective c ); +Literal *new_Literal( void ); +NumericEffect *new_NumericEffect( void ); +Effect *new_Effect( void ); +Operator *new_Operator( char *name, int norp ); +NormEffect *new_NormEffect1( Effect *e ); +NormEffect *new_NormEffect2( NormEffect *e ); +NormOperator *new_NormOperator( Operator *op ); +EasyTemplate *new_EasyTemplate( NormOperator *op ); +MixedOperator *new_MixedOperator( Operator *op ); +PseudoActionEffect *new_PseudoActionEffect( void ); +PseudoAction *new_PseudoAction( MixedOperator *op ); +LnfExpNode *new_LnfExpNode( void ); +Action *new_Action( void ); +void make_state( State *pointer, int ft, int fl ); +EhcNode *new_EhcNode( void ); +EhcHashEntry *new_EhcHashEntry( void ); +PlanHashEntry *new_PlanHashEntry( void ); +BfsNode *new_BfsNode( void ); +BfsHashEntry *new_BfsHashEntry( void ); + + + + + + + +void free_TokenList( TokenList *source ); +void free_FactList( FactList *source ); +void free_ParseExpNode( ParseExpNode *n ); +void free_PlNode( PlNode *node ); +void free_PlOperator( PlOperator *o ); +void free_Operator( Operator *o ); +void free_ExpNode( ExpNode *n ); +void free_WffNode( WffNode *w ); +void free_NormEffect( NormEffect *e ); +void free_partial_Effect( Effect *e ); +void free_NormOperator( NormOperator *o ); +void free_single_NormEffect( NormEffect *e ); +void free_single_EasyTemplate( EasyTemplate *t ); +void free_TypedList( TypedList *t ); +void free_TypedListList( TypedListList *t ); +void free_ActionEffect( ActionEffect *e ); +void free_BfsNode( BfsNode *n ); +void free_BfsHashEntry( BfsHashEntry *n ); + + + + + + +#endif /* _MEMORY_H */ diff --git a/gen/ff_planner/output.c b/gen/ff_planner/output.c new file mode 100644 index 000000000..1341eff7a --- /dev/null +++ b/gen/ff_planner/output.c @@ -0,0 +1,1482 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: output.c + * Description: printing info out + * + * Author: Joerg Hoffmann + * + *********************************************************************/ + + + + + +#include "ff.h" + +#include "output.h" + + + + + + + +/* parsing + */ + + + + + + + +void print_FactList( FactList *list, char *sepf, char *sept ) + +{ + + FactList *i_list; + TokenList *i_tl; + + if ( list ) { + i_tl = list->item; + if (NULL == i_tl || NULL == i_tl->item) { + printf("empty"); + } else { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } + + while (NULL != i_tl) { + if (NULL != i_tl->item) { + printf("%s%s", sept, i_tl->item); + } + i_tl = i_tl->next; + } + + for ( i_list = list->next; i_list; i_list = i_list->next ) { + printf("%s", sepf); + i_tl = i_list->item; + if (NULL == i_tl || NULL == i_tl->item) { + printf("empty"); + } else { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } + + while (NULL != i_tl) { + if (NULL != i_tl->item) { + printf("%s%s", sept, i_tl->item); + } + i_tl = i_tl->next; + } + } + } + +} + + + +void print_hidden_TokenList( TokenList *list, char *sep ) + +{ + + TokenList *i_tl; + + i_tl = list; + if (NULL!=i_tl) { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } else { + printf("empty"); + } + + while (NULL != i_tl) { + printf("%s%s", sep, i_tl->item); + i_tl = i_tl->next; + } + +} + + + +void print_indent( int indent ) + +{ + + int i; + for (i=0;iconnective) { + case AD: + printf("(+ "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case SU: + printf("(- "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case MU: + printf("(* "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case DI: + printf("(/ "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case MINUS: + printf("(- "); + print_ParseExpNode( n->leftson ); + printf(")"); + break; + case NUMBER: + printf("%s", n->atom->item); + break; + case FHEAD: + printf("("); + print_hidden_TokenList(n->atom, " "); + printf(")"); + break; + default: + printf("\n\nprint Parseexpnode: wrong specifier %d", + n->connective); + } + +} + + + +void print_PlNode( PlNode *plnode, int indent ) + +{ + + PlNode *i_son; + + if ( !plnode ) { + printf("none\n"); + return; + } + + switch (plnode->connective) { + case ALL: + printf("ALL %s : %s\n", plnode->atom->item, + plnode->atom->next->item); + print_indent(indent); + printf("( "); + print_PlNode(plnode->sons,indent+4); + print_indent(indent); + printf(")\n"); + break; + case EX: + printf("EX %s : %s\n", plnode->atom->item, + plnode->atom->next->item); + print_indent(indent); + printf("( "); + print_PlNode(plnode->sons,indent+4); + print_indent(indent); + printf(")\n"); + break; + case AND: + printf("A( "); + print_PlNode(plnode->sons, indent+4); + if ( plnode->sons ) { + for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { + print_indent(indent); + printf("AND "); + print_PlNode(i_son,indent+4); + } + } + print_indent(indent); + printf(")\n"); + break; + case OR: + printf("O( "); + print_PlNode(plnode->sons, indent+4); + for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { + print_indent(indent); + printf("OR "); + print_PlNode(i_son,indent+4); + } + print_indent(indent); + printf(")\n"); + break; + case WHEN: + printf("IF "); + print_PlNode(plnode->sons,indent+5); + print_indent(indent); + printf("THEN "); + print_PlNode(plnode->sons->next,indent+5); + print_indent(indent); + printf("ENDIF\n"); + break; + case NOT: + if (ATOM==plnode->sons->connective) { + printf("NOT "); + print_PlNode(plnode->sons,indent+4); + } else { + printf("NOT("); + print_PlNode(plnode->sons,indent+4); + print_indent(indent+3); + printf(")\n"); + } + break; + case ATOM: + printf("("); + print_hidden_TokenList(plnode->atom, " "); + printf(")\n"); + break; + case TRU: + printf("(TRUE)\n"); + break; + case FAL: + printf("(FALSE)\n"); + break; + case COMP: + switch (plnode->comp) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\n\nillegal comp in parse tree!\n\n"); + exit( 1 ); + } + print_ParseExpNode( plnode->lh ); + print_ParseExpNode( plnode->rh ); + printf(")\n"); + break; + case NEF: + switch (plnode->neft) { + case ASSIGN: + printf("(assign "); + break; + case SCALE_UP: + printf("(scale-up "); + break; + case SCALE_DOWN: + printf("(scale-down "); + break; + case INCREASE: + printf("(increase "); + break; + case DECREASE: + printf("(decrease "); + break; + } + print_ParseExpNode( plnode->lh ); + print_ParseExpNode( plnode->rh ); + printf(")\n"); + break; + default: + printf("\n***** ERROR ****"); + printf("\nprint_plnode: %d > Wrong Node specifier\n", plnode->connective); + exit(1); + } + +} + + + +void print_plops( PlOperator *plop ) + +{ + + PlOperator *i_plop; + int count = 0; + + if ( !plop ) { + printf("none\n"); + } + + for ( i_plop = plop; i_plop!=NULL; i_plop = i_plop->next ) { + printf("\n"); + if ( i_plop->axiom ) printf("AXIOM-"); + printf("OPERATOR "); + printf("%s", i_plop->name); + printf("\nparameters: (%d real)\n", i_plop->number_of_real_params); + print_FactList ( i_plop->params, "\n", " : "); + printf("\n\npreconditions:\n"); + print_PlNode(i_plop->preconds, 0); + printf("effects:\n"); + print_PlNode(i_plop->effects, 0); + printf("\n-----\n"); + count++; + } + printf("\nAnzahl der Operatoren: %d\n", count); + +} + + + +void print_ExpNode( ExpNode *n ) + +{ + + if ( !n ) return; + + switch ( n->connective) { + case AD: + printf("(+ "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case SU: + printf("(- "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case MU: + printf("(* "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case DI: + printf("(/ "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case MINUS: + printf("(- "); + print_ExpNode( n->son ); + printf(")"); + break; + case NUMBER: + printf("%.2f", n->value); + break; + case FHEAD: + if ( n->fluent ) { + print_Fluent( n->fluent ); + } else { + if ( n->fl >= 0 ) { + printf(" %.2f*", n->c); + print_fl_name( n->fl ); + } else { + printf("[UNDEF]"); + } + } + break; + default: + printf("\n\nprint Expnode: wrong specifier %d", + n->connective); + } + +} + + + +void print_Wff( WffNode *n, int indent ) + +{ + + WffNode *i; + + if ( !n ) { + printf("none\n"); + return; + } + + switch (n->connective) { + case ALL: + printf("ALL x%d (%s): %s\n", n->var, n->var_name, + gtype_names[n->var_type]); + print_indent(indent); + printf("( "); + print_Wff(n->son,indent+4); + print_indent(indent); + printf(")\n"); + break; + case EX: + printf("EX x%d (%s) : %s\n", n->var, n->var_name, + gtype_names[n->var_type]); + print_indent(indent); + printf("( "); + print_Wff(n->son,indent+4); + print_indent(indent); + printf(")\n"); + break; + case AND: + printf("A( "); + print_Wff(n->sons, indent+4); + if ( n->sons ) { + for ( i = n->sons->next; i!=NULL; i = i->next ) { + if ( !i->prev ) { + printf("\nprev in AND not correctly set!\n\n"); + exit( 1 ); + } + print_indent(indent); + printf("AND "); + print_Wff(i,indent+4); + } + } + print_indent(indent); + printf(")\n"); + break; + case OR: + printf("O( "); + print_Wff(n->sons, indent+4); + for ( i = n->sons->next; i!=NULL; i = i->next ) { + print_indent(indent); + printf("OR "); + print_Wff(i,indent+4); + } + print_indent(indent); + printf(")\n"); + break; + case NOT: + if (ATOM==n->son->connective) { + printf("NOT "); + print_Wff(n->son,indent+4); + } else { + printf("NOT("); + print_Wff(n->son,indent+4); + print_indent(indent+3); + printf(")\n"); + } + break; + case ATOM: + print_Fact(n->fact); + if ( n->NOT_p != -1 ) printf(" - translation NOT"); + printf("\n"); + break; + case TRU: + printf("(TRUE)\n"); + break; + case FAL: + printf("(FALSE)\n"); + break; + case COMP: + switch (n->comp) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in WFF %d\n\n", n->comp); + exit( 1 ); + } + print_ExpNode( n->lh ); + print_ExpNode( n->rh ); + printf(")\n"); + break; + default: + printf("\n***** ERROR ****"); + printf("\nprint_Wff: %d > Wrong Node specifier\n", n->connective); + exit(1); + } + +} + + + +void print_Operator( Operator *o ) + +{ + + Effect *e; + Literal *l; + NumericEffect *ne; + int i, m = 0; + + printf("\n\n----------------Operator %s, axiom %d, translated form, step 1--------------\n", + o->name, o->axiom); + + for ( i = 0; i < o->num_vars; i++ ) { + printf("\nx%d (%s) of type %s, removed ? %s", + i, o->var_names[i], gtype_names[o->var_types[i]], + o->removed[i] ? "YES" : "NO"); + } + printf("\ntotal params %d, real params %d\n", + o->num_vars, o->number_of_real_params); + + printf("\nPreconds:\n"); + print_Wff( o->preconds, 0 ); + + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d (%s) of type %s", + o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]); + } + printf("\nConditions\n"); + print_Wff( e->conditions, 0 ); + printf("\nEffect Literals"); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + printf("\nNOT "); + } else { + printf("\n"); + } + print_Fact( &(l->fact) ); + } + printf("\nNumeric Effects"); + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + switch ( ne->neft ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); + exit( 1 ); + } + print_Fluent( &(ne->fluent) ); + print_ExpNode( ne->rh ); + } + } + +} + + + +void print_NormOperator( NormOperator *o ) + +{ + + NormEffect *e; + int i, m; + + printf("\n\n----------------Operator %s, normalized form--------------\n", + o->operator->name); + + for ( i = 0; i < o->num_vars; i++ ) { + printf("\nx%d of type ", i); + print_type( o->var_types[i] ); + } + printf("\n\n%d vars removed from original operator:", + o->num_removed_vars); + for ( i = 0; i < o->num_removed_vars; i++ ) { + m = o->removed_vars[i]; + printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m], + gtype_names[o->operator->var_types[m]]); + print_type( o->type_removed_vars[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d of type ", o->num_vars + i); + print_type( e->var_types[i] ); + } + printf("\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_Fact( &(e->conditions[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_Fact( &(e->adds[i]) ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_Fact( &(e->dels[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + print_Fluent( &(e->numeric_effects_fluent[i]) ); + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_MixedOperator( MixedOperator *o ) + +{ + + int i, m; + Effect *e; + NumericEffect *ne; + Literal *l; + + printf("\n\n----------------Operator %s, mixed form--------------\n", + o->operator->name); + + for ( i = 0; i < o->operator->num_vars; i++ ) { + printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); + print_type( o->operator->var_types[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d of type %s", + o->operator->num_vars + i, gtype_names[e->var_types[i]]); + } + printf("\nConditions\n"); + print_Wff( e->conditions, 0 ); + printf("\nEffect Literals"); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + printf("\nNOT "); + } else { + printf("\n"); + } + print_Fact( &(l->fact) ); + } + printf("\nNumeric Effects"); + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + switch ( ne->neft ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); + exit( 1 ); + } + print_Fluent( &(ne->fluent) ); + print_ExpNode( ne->rh ); + } + } + +} + + + +void print_PseudoAction( PseudoAction *o ) + +{ + + PseudoActionEffect *e; + int i, m; + + printf("\n\n----------------Pseudo Action %s--------------\n", + o->operator->name); + + for ( i = 0; i < o->operator->num_vars; i++ ) { + printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); + print_type( o->operator->var_types[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d", m++); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_Fact( &(e->conditions[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_Fact( &(e->adds[i]) ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_Fact( &(e->dels[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + print_Fluent( &(e->numeric_effects_fluent[i]) ); + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_Action( Action *a ) + +{ + + ActionEffect *e; + int i, j; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("\n\nAction REACH-GOAL"); + } else { + printf("\n\nAction %s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + + printf("\n\nPreconds:\n"); + for ( i = 0; i < a->num_preconds; i++ ) { + print_ft_name( a->preconds[i] ); + printf("\n"); + } + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + switch ( a->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in actionpre %d\n\n", + a->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( a->numeric_preconds_lh[i] ); + print_ExpNode( a->numeric_preconds_rh[i] ); + printf(")\n"); + } + + printf("\n\nEffects:"); + for ( j = 0; j < a->num_effects; j++ ) { + printf("\n\neffect %d", j); + e = &(a->effects[j]); + if ( e->illegal ) printf(" ILLEGAL EFFECT!"); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_ft_name( e->conditions[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_ft_name( e->adds[i] ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_ft_name( e->dels[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + if ( e->numeric_effects_fl[i] >= 0 ) { + print_fl_name( e->numeric_effects_fl[i] ); + } else { + printf("[UNDEF]"); + } + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_Action_name( Action *a ) + +{ + + int i; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("REACH-GOAL"); + } else { + printf("%s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + +} + + + +void print_lnf_Action( Action *a ) + +{ + + ActionEffect *e; + int i, j; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("\n\nAction REACH-GOAL"); + } else { + printf("\n\nAction %s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + + printf("\n\nPreconds:\n"); + for ( i = 0; i < a->num_preconds; i++ ) { + print_ft_name( a->preconds[i] ); + printf("\n"); + } + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + switch ( a->lnf_preconds_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in lnf actionpre %d\n\n", + a->lnf_preconds_comp[i]); + exit( 1 ); + } + print_LnfExpNode( a->lnf_preconds_lh[i] ); + printf(" %.2f)\n", a->lnf_preconds_rh[i]); + } + + printf("\n\nEffects:"); + for ( j = 0; j < a->num_effects; j++ ) { + printf("\n\neffect %d COST %f", j, a->effects[j].cost); + e = &(a->effects[j]); + if ( e->illegal ) printf(" ILLEGAL EFFECT!"); + if ( e->removed ) printf(" REMOVED!!!"); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_ft_name( e->conditions[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_lnf_conditions; i++ ) { + switch ( e->lnf_conditions_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in lnf normeff %d\n\n", + e->lnf_conditions_comp[i]); + exit( 1 ); + } + print_LnfExpNode( e->lnf_conditions_lh[i] ); + printf(" %.2f)\n", e->lnf_conditions_rh[i] ); + } + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_ft_name( e->adds[i] ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_ft_name( e->dels[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_lnf_effects; i++ ) { + switch ( e->lnf_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case INCREASE: + printf("\nincrease "); + break; + default: + printf("\n\nprint lnf normop: illegal neft %d\n\n", + e->lnf_effects_neft[i]); + exit( 1 ); + } + if ( e->lnf_effects_fl[i] >= 0 ) { + print_fl_name( e->lnf_effects_fl[i] ); + } else { + printf("[UNDEF]"); + } + print_LnfExpNode( e->lnf_effects_rh[i] ); + } + } + +} + + + +void print_type( int t ) + +{ + + int j; + + if ( gpredicate_to_type[t] == -1 ) { + if ( gnum_intersected_types[t] == -1 ) { + printf("%s", gtype_names[t]); + } else { + printf("INTERSECTED TYPE ("); + for ( j = 0; j < gnum_intersected_types[t]; j++ ) { + if ( gpredicate_to_type[gintersected_types[t][j]] == -1 ) { + printf("%s", gtype_names[gintersected_types[t][j]]); + } else { + printf("UNARY INERTIA TYPE (%s)", + gpredicates[gpredicate_to_type[gintersected_types[t][j]]]); + } + if ( j < gnum_intersected_types[t] - 1 ) { + printf(" and "); + } + } + printf(")"); + } + } else { + printf("UNARY INERTIA TYPE (%s)", gpredicates[gpredicate_to_type[t]]); + } + +} + + + +void print_Fact( Fact *f ) + +{ + + int j; + + if ( f->predicate == -3 ) { + printf("GOAL-REACHED"); + return; + } + + if ( f->predicate == -1 ) { + printf("(="); + for ( j=0; j<2; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + return; + } + + if ( f->predicate == -2 ) { + printf("(!="); + for ( j=0; j<2; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + return; + } + + printf("(%s", gpredicates[f->predicate]); + for ( j=0; jpredicate]; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + +} + + + +void print_Fluent( Fluent *f ) + +{ + + int j, ff = f->function; + + printf("(%s", gfunctions[ff]); + for ( j=0; jargs[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + +} + + + +void print_ft_name( int index ) + +{ + + print_Fact( &(grelevant_facts[index]) ); + +} + + + +void print_fl_name( int index ) + +{ + + int i; + + if ( index < 0 ) { + if ( index != -2 ) { + printf("[UNDEF]"); + } else { + printf("[TOTAL-TIME]"); + } + return; + } + + if ( grelevant_fluents_lnf[index] == NULL ) { + /* this is a non-artificial "atomic" one + * (or the mirrored version of one) + */ + printf("[RF%d](%s)", index, grelevant_fluents_name[index]); + } else { + /* this only summarizes a LNF requirement + */ + printf("[artRF%d]", index); + for ( i = 0; i < grelevant_fluents_lnf[index]->num_pF; i++ ) { + printf("%.2f*", grelevant_fluents_lnf[index]->pC[i] ); + print_fl_name( grelevant_fluents_lnf[index]->pF[i] ); + if ( i < grelevant_fluents_lnf[index]->num_pF - 1 ) { + printf(" + "); + } + } + } + +} + + + +void print_LnfExpNode( LnfExpNode *n ) + +{ + + int i; + + printf("(("); + for ( i = 0; i < n->num_pF; i++ ) { + printf("%.2f*", n->pC[i]); + print_fl_name( n->pF[i] ); + } + printf(") - ("); + for ( i = 0; i < n->num_nF; i++ ) { + printf("%.2f*", n->nC[i]); + print_fl_name( n->nF[i] ); + } + printf(") + %.2f)", n->c); + +} + + + +void print_op_name( int index ) + +{ + + int i; + Action *a = gop_conn[index].action; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("REACH-GOAL"); + } else { + printf("%s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + +} + + + +void print_State( State S ) + +{ + + int i; + + for ( i = 0; i < S.num_F; i++ ) { + printf("\n"); + print_ft_name( S.F[i] ); + } + for ( i = 0; i < gnum_relevant_fluents; i++ ) { + printf("\n"); + print_fl_name( i ); + printf(": "); + if ( S.f_D[i] ) { + printf("%.2f", S.f_V[i]); + } else { + printf("UNDEF"); + } + } + +} + + + + + + + + +/* + * program output routines + */ + + + + + + + + + +void print_plan( void ) + +{ + + int i; + float cost = 0; + + printf("\n\nff: found legal plan as follows"); + printf("\nstep "); + for ( i = 0; i < gnum_plan_ops; i++ ) { + printf("%4d: ", i); + print_op_name( gplan_ops[i] ); + if ( i < gnum_plan_ops-1 ) { + printf("\n "); + } + if ( goptimization_established ) { + cost += gop_conn[gplan_ops[i]].cost; + } + } + if ( goptimization_established ) { + printf("\nplan cost: %f", cost); + } + +} diff --git a/gen/ff_planner/output.h b/gen/ff_planner/output.h new file mode 100644 index 000000000..a74e87607 --- /dev/null +++ b/gen/ff_planner/output.h @@ -0,0 +1,68 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: output.h + * Description: print headers + * + * Author: Joerg Hoffmann 1999 + * + *********************************************************************/ + + + + + +#ifndef _OUTPUT_H +#define _OUTPUT_H + + + +void print_FactList( FactList *list, char *sepf, char *sept ); +void print_hidden_TokenList( TokenList *list, char *sep ); +void print_indent( int indent ); +void print_ParseExpNode( ParseExpNode *n ); +void print_PlNode( PlNode *plnode, int indent ); +void print_ExpNode( ExpNode *n ); +void print_Wff( WffNode *n, int indent ); +void print_plops( PlOperator *plop ); +void print_Operator( Operator *o ); +void print_NormOperator( NormOperator *o ); +void print_MixedOperator( MixedOperator *o ); +void print_PseudoAction( PseudoAction *o ); +void print_Action( Action *a ); +void print_Action_name( Action *a ); +void print_lnf_Action( Action *a ); +void print_type( int t ); +void print_Fact( Fact *f ); +void print_Fluent( Fluent *f ); +void print_ft_name( int index ); +void print_op_name( int index ); +void print_fl_name( int index ); +void print_LnfExpNode( LnfExpNode *n ); +void print_State( State S ); + + + +void print_plan( void ); + + + +#endif /* _OUTPUT_H */ diff --git a/gen/ff_planner/parse.c b/gen/ff_planner/parse.c new file mode 100644 index 000000000..cc5a099f9 --- /dev/null +++ b/gen/ff_planner/parse.c @@ -0,0 +1,1339 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: parse.c + * Description: Functions for the pddl parser + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + +#include "ff.h" + +#include "memory.h" +#include "output.h" + +#include "parse.h" + + + + + + + + + + + +/* simple parse helpers + */ + + + + + + + +char *copy_Token( char *s ) + +{ + + char *d = new_Token( strlen( s ) + 1 ); + strcpy(d, s); + + return d; + +} + + + +TokenList *copy_TokenList( TokenList *source ) + +{ + + TokenList *temp; + + if ( !source ) { + temp = NULL; + } else { + temp = new_TokenList(); + if ( source->item ) { + temp->item = new_Token( strlen( source->item ) + 1 ); + strcpy( temp->item, source->item ); + } + temp->next = copy_TokenList( source->next ); + } + + return temp; + +} + + + +void strupcase( char *from ) + +{ + + char tmp; + + tmp = *from; + while ('\0' != tmp) { + *from = (char) toupper((int) tmp); + tmp = *++from; + } + +} + + + +char *rmdash( char *s ) + +{ + + s++; + + for( ; (*s == ' ') || (*s == '\t'); s++ ); + + return s; + +} + + + + + + + + + + +/* typed-list-of preprocessing + */ + + + + + + + +Token ltype_names[MAX_TYPES]; +int lnum_types; + + +int leither_ty[MAX_TYPES][MAX_TYPES]; +int lnum_either_ty[MAX_TYPES]; + + + + + +void build_orig_constant_list( void ) + +{ + + char *tmp = NULL; + TypedList *tyl; + TypedListList *tyll; + TokenList *tl, *p_tl, *tmp_tl; + PlOperator *po; + + int i, j, k, n, std; + + Bool m[MAX_TYPES][MAX_TYPES]; + + FactList *fl, *p_fl; + + lnum_types = 0; + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + if ( get_type( tyl->name ) == -1 ) { + ltype_names[lnum_types++] = copy_Token( tyl->name ); + } + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + collect_type_names_in_pl( gorig_goal_facts ); + + for ( po = gloaded_ops; po; po = po->next ) { + collect_type_names_in_pl( po->preconds ); + collect_type_names_in_pl( po->effects ); + for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + + /* now get the numbers of all composed either types + */ + for ( i = 0; i < lnum_types; i++ ) { + lnum_either_ty[i] = 0; + } + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + make_either_ty_in_pl( gorig_goal_facts ); + for ( po = gloaded_ops; po; po = po->next ) { + make_either_ty_in_pl( po->preconds ); + make_either_ty_in_pl( po->effects ); + for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + + + /* now, compute the transitive closure of all type inclusions. + * first initialize the matrix. + */ + for ( i = 0; i < lnum_types; i++ ) { + for ( j = 0; j < lnum_types; j++ ) { + m[i][j] = ( i == j ? TRUE : FALSE ); + } + } + std = -1; + for ( i = 0; i < lnum_types; i++ ) { + if ( strcmp( ltype_names[i], STANDARD_TYPE ) == SAME ) { + std = i; + break; + } + } + for ( i = 0; i < lnum_types; i++ ) { + m[i][std] = TRUE;/* all types are subtypes of OBJECT */ + } + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + /* all inclusions as are defined in domain file + */ + m[get_type( tyl->name )][tyl->n] = TRUE; + } + /* compute transitive closure on inclusions matrix + */ + for ( j = 0; j < lnum_types; j++ ) { + for ( i = 0; i < lnum_types; i++ ) { + if ( m[i][j] ) { + for ( k = 0; k < lnum_types; k++ ) { + if ( m[j][k] ) { + m[i][k] = TRUE; + } + } + } + } + } + /* union types are subsets of all those types that contain all + * their components, and + * all component types are subsets of the either type ! + */ + for ( i = 0; i < lnum_types; i++ ) { + if ( lnum_either_ty[i] < 2 ) continue; + for ( j = 0; j < lnum_types; j++ ) { + if ( j == i ) continue; + /* get supertypes of all component types + */ + for ( k = 0; k < lnum_either_ty[i]; k++ ) { + if ( !m[leither_ty[i][k]][j] ) break; + } + if ( k < lnum_either_ty[i] ) continue; + m[i][j] = TRUE; + /* make components subtypes of either type + */ + for ( k = 0; k < lnum_either_ty[i]; k++ ) { + m[leither_ty[i][k]][i] = TRUE; + } + } + } + /* and again, compute transitive closure on inclusions matrix. + * I guess, this won't change anything (?), but it also won't need + * any remarkable computation time, so why should one think about it ? + */ + for ( j = 0; j < lnum_types; j++ ) { + for ( i = 0; i < lnum_types; i++ ) { + if ( m[i][j] ) { + for ( k = 0; k < lnum_types; k++ ) { + if ( m[j][k] ) { + m[i][k] = TRUE; + } + } + } + } + } + + + /* now build FactList of ALL constant -> type pairs. + * for each constant / object, let it appear separately + * for each type it is a member of; compute type + * membership based on propagating constants / objects + * through inclusions matrix. + * + * this might make the same pair appear doubly, if an object + * is declared in type T as well as in some supertype T'. + * such cases will be filtered out in string collection. + */ + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + fl->next = gorig_constant_list; + gorig_constant_list = fl; + /* now add constant to all supertypes + */ + n = get_type( fl->item->next->item ); + for ( i = 0; i < lnum_types; i++ ) { + if ( i == n || + !m[n][i] ) continue; + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + fl->item->next->item = copy_Token( ltype_names[i] ); + fl->next = gorig_constant_list; + gorig_constant_list = fl; + } + } + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + fl->next = gorig_constant_list; + gorig_constant_list = fl; + /* now add constant to all supertypes + */ + n = get_type( fl->item->next->item ); + for ( i = 0; i < lnum_types; i++ ) { + if ( i == n || + !m[n][i] ) continue; + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + fl->item->next->item = copy_Token( ltype_names[i] ); + fl->next = gorig_constant_list; + gorig_constant_list = fl; + } + } + + + /* now, normalize all typed-list-of s in domain and problem def, + * i.e., in all PlNode quantifiers and in op parameters + * + * at the same time, remove typed-listof structures in these defs + */ + normalize_tyl_in_pl( &gorig_goal_facts ); + for ( po = gloaded_ops; po; po = po->next ) { + normalize_tyl_in_pl( &po->preconds ); + normalize_tyl_in_pl( &po->effects ); + /* be careful to maintain parameter ordering ! + */ + if ( !po->parse_params ) { + continue;/* no params at all */ + } + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( po->parse_params->name ); + if ( po->parse_params->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = po->parse_params->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( po->parse_params->type->item ); + } + po->params = fl; + p_fl = fl; + for ( tyl = po->parse_params->next; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + p_fl->next = fl; + p_fl = fl; + } + free_TypedList( po->parse_params ); + po->parse_params = NULL; + } + + + /* finally, build gpredicates_and_types by chaining predicate names + * together with the names of their args' types. + */ + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->item = copy_Token( tyll->predicate ); + fl->next = gpredicates_and_types; + gpredicates_and_types = fl; + if ( !tyll->args ) continue; + /* add arg types; MAINTAIN ORDERING ! + */ + fl->item->next = new_TokenList(); + if ( tyll->args->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyll->args->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyll->args->type->item ); + } + p_tl = fl->item->next; + for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + if ( tyl->type->next ) { + tmp_tl->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->item, CONNECTOR ); + strcat( tmp_tl->item, tl->item ); + } + } else { + tmp_tl->item = copy_Token( tyl->type->item ); + } + p_tl->next = tmp_tl; + p_tl = tmp_tl; + } + } + + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->item = copy_Token( tyll->predicate ); + fl->next = gfunctions_and_types; + gfunctions_and_types = fl; + if ( !tyll->args ) continue; + /* add arg types; MAINTAIN ORDERING ! + */ + fl->item->next = new_TokenList(); + if ( tyll->args->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyll->args->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyll->args->type->item ); + } + p_tl = fl->item->next; + for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + if ( tyl->type->next ) { + tmp_tl->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->item, CONNECTOR ); + strcat( tmp_tl->item, tl->item ); + } + } else { + tmp_tl->item = copy_Token( tyl->type->item ); + } + p_tl->next = tmp_tl; + p_tl = tmp_tl; + } + } + + /* now get rid of remaining typed-list-of parsing structures + */ + free_TypedList( gparse_types ); + gparse_types = NULL; + free_TypedList( gparse_constants ); + gparse_constants = NULL; + free_TypedList( gparse_objects ); + gparse_objects = NULL; + free_TypedListList( gparse_predicates ); + gparse_predicates = NULL; + free_TypedListList( gparse_functions ); + gparse_functions = NULL; + +} + + + +void collect_type_names_in_pl( PlNode *n ) + +{ + + PlNode *i; + TypedList *tyl; + TokenList *tl; + char *tmp = NULL; + int nn; + + if ( !n ) { + return; + } + + switch( n->connective ) { + case ALL: + case EX: + for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (nn = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = nn; + } + free( tmp ); + tmp = NULL; + } + collect_type_names_in_pl( n->sons ); + break; + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + collect_type_names_in_pl( i ); + } + break; + case NOT: + collect_type_names_in_pl( n->sons ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + collect_type_names_in_pl( n->sons ); + collect_type_names_in_pl( n->sons->next ); + break; + default: + break; + } + +} + + + +int get_type( char *str ) + +{ + + int i; + + for ( i = 0; i < lnum_types; i++ ) { + if ( strcmp( str, ltype_names[i] ) == SAME ) return i; + } + + return -1; + +} + + + +void make_either_ty( TypedList *tyl ) + +{ + + TokenList *i; + + if ( lnum_either_ty[tyl->n] > 0 ) { + return; + } + + for ( i = tyl->type; i; i = i->next ) { + leither_ty[tyl->n][lnum_either_ty[tyl->n]++] = get_type( i->item ); + } + +} + + + +void make_either_ty_in_pl( PlNode *n ) + +{ + + PlNode *i; + TypedList *tyl; + + if ( !n ) { + return; + } + + switch( n->connective ) { + case ALL: + case EX: + for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + make_either_ty_in_pl( n->sons ); + break; + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + make_either_ty_in_pl( i ); + } + break; + case NOT: + make_either_ty_in_pl( n->sons ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + make_either_ty_in_pl( n->sons ); + make_either_ty_in_pl( n->sons->next ); + break; + default: + break; + } + +} + + + +void normalize_tyl_in_pl( PlNode **n ) + +{ + + PlNode *i; + TypedList *tyl; + PlNode *tmp_pl = NULL, *sons, *p_pl; + TokenList *tmp_tl, *tl; + + + if ( !(*n) ) { + return; + } + + switch( (*n)->connective ) { + case ALL: + case EX: + /* we need to make a sequence of quantifiers ( ->sons ...) + * out of the given sequence of TypedList elements, + * with connected type names, var - name in TokenList + * and KEEPING THE SAME ORDERING !! + */ + if ( !(*n)->parse_vars ) { + printf("\n\nquantifier without argument !! check input files.\n\n"); + exit( 1 ); + } + tmp_tl = new_TokenList(); + tmp_tl->next = new_TokenList(); + tmp_tl->item = copy_Token( (*n)->parse_vars->name ); + if ( (*n)->parse_vars->type->next ) { + tmp_tl->next->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->next->item, EITHER_STR ); + for ( tl = (*n)->parse_vars->type; tl; tl = tl->next ) { + strcat( tmp_tl->next->item, CONNECTOR ); + strcat( tmp_tl->next->item, tl->item ); + } + } else { + tmp_tl->next->item = copy_Token( (*n)->parse_vars->type->item ); + } + (*n)->atom = tmp_tl; + /* now add list of sons + */ + sons = (*n)->sons; + p_pl = *n; + for ( tyl = (*n)->parse_vars->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + tmp_tl->next = new_TokenList(); + tmp_tl->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + tmp_tl->next->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->next->item, CONNECTOR ); + strcat( tmp_tl->next->item, tl->item ); + } + } else { + tmp_tl->next->item = copy_Token( tyl->type->item ); + } + tmp_pl = new_PlNode( (*n)->connective ); + tmp_pl->atom = tmp_tl; + p_pl->sons = tmp_pl; + p_pl = tmp_pl; + } + /* remove typed-list-of info + */ + free_TypedList( (*n)->parse_vars ); + (*n)->parse_vars = NULL; + /* the last son in list takes over ->sons + */ + p_pl->sons = sons; + /* normalize this sons and get out + */ + normalize_tyl_in_pl( &(p_pl->sons) ); + break; + case AND: + case OR: + for ( i = (*n)->sons; i; i = i->next ) { + normalize_tyl_in_pl( &i ); + } + break; + case NOT: + normalize_tyl_in_pl( &((*n)->sons) ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + normalize_tyl_in_pl( &((*n)->sons) ); + normalize_tyl_in_pl( &((*n)->sons->next) ); + break; + default: + break; + } + +} + + + + + + + + + + + + +/* ADL syntax test - and normalization (AND s etc.) + */ + + + + + + + + + + + + +Bool make_adl_domain( void ) + +{ + + PlOperator *i; + FactList *ff; + + if ( gcmd_line.display_info == 101 ) { + printf("\noriginal problem parsing is:\n"); + printf("\nobjects:"); + for ( ff = gorig_constant_list; ff; ff = ff->next ) { + printf("\n%s : %s", ff->item->item, ff->item->next->item); + } + printf("\n\ninitial state:\n"); + print_PlNode( gorig_initial_facts, 0 ); + printf("\n\ngoal state:\n"); + print_PlNode( gorig_goal_facts, 0 ); + printf("\n\nops:"); + print_plops( gloaded_ops ); + } + + if ( !make_conjunction_of_atoms( &gorig_initial_facts ) ) { + printf("\nillegal initial state"); + return FALSE; + } + + if ( !gorig_goal_facts ) { + gorig_goal_facts = new_PlNode( TRU ); + } + + if ( !is_wff( gorig_goal_facts ) ) { + printf("\nillegal goal formula"); + print_PlNode( gorig_goal_facts, 0 ); + return FALSE; + } + + for ( i = gloaded_ops; i; i = i->next ) { + if ( !i->preconds ) { + i->preconds = new_PlNode( TRU ); + } + if ( !is_wff( i->preconds ) ) { + printf("\nop %s has illegal precondition", i->name); + return FALSE; + } + if ( !make_effects( &(i->effects) ) ) { + printf("\nop %s has illegal effects", i->name); + return FALSE; + } + } + + if ( gcmd_line.display_info == 102 ) { + printf("\nfinal ADL representation is:\n"); + printf("\nobjects:"); + for ( ff = gorig_constant_list; ff; ff = ff->next ) { + printf("\n%s : %s", ff->item->item, ff->item->next->item); + } + printf("\n\ninitial state:\n"); + print_PlNode( gorig_initial_facts, 0 ); + printf("\n\ngoal formula:\n"); + print_PlNode( gorig_goal_facts, 0 ); + printf("\n\nops:"); + print_plops( gloaded_ops ); + } + + return TRUE; + +} + + + +Bool make_conjunction_of_atoms( PlNode **n ) + +{ + + PlNode *tmp, *i, *p, *m; + + if ( !(*n) ) { + return TRUE; + } + + if ( (*n)->connective != AND ) { + switch ( (*n)->connective ) { + case ATOM: + tmp = new_PlNode( ATOM ); + tmp->atom = (*n)->atom; + (*n)->atom = NULL; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + case COMP: + tmp = new_PlNode( COMP ); + tmp->comp = (*n)->comp; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->comp = -1; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + case NOT: + free_PlNode( *n ); + (*n) = NULL; + return TRUE; + default: + return FALSE; + } + } + + p = NULL; + i = (*n)->sons; + while ( i ) { + switch ( i->connective ) { + case ATOM: + break; + case COMP: + break; + case NOT: + if ( p ) { + p->next = i->next; + } else { + (*n)->sons = i->next; + } + m = i->next; + i->next = NULL; + free_PlNode( i ); + i = m; + break; + default: + return FALSE; + } + if ( i->connective != NOT ) { + p = i; + i = i->next; + } + } + + return TRUE; + +} + + + +Bool is_wff( PlNode *n ) + +{ + + PlNode *i; + + if ( !n ) { + return FALSE; + } + + switch( n->connective ) { + case ALL: + case EX: + if ( !(n->atom) || + !(n->atom->next ) || + n->atom->next->next != NULL ) { + return FALSE; + } + return is_wff( n->sons ); + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + if ( !is_wff( i ) ) { + return FALSE; + } + } + return TRUE; + case NOT: + return is_wff( n->sons ); + case ATOM: + if ( !(n->atom) || + n->sons != NULL ) { + return FALSE; + } + return TRUE; + case TRU: + case FAL: + if ( n->sons != NULL ) { + return FALSE; + } + return TRUE; + case COMP: + if ( n->sons != NULL || + n->atom != NULL || + n->lh == NULL || + n->rh == NULL || + n->comp < 0 ) { + return FALSE; + } + return TRUE; + default: + return FALSE; + } + +} + + + +Bool make_effects( PlNode **n ) + +{ + + PlNode *tmp, *i, *literals, *j, *k, *next; + int m = 0; + + if ( (*n)->connective != AND ) { + if ( !is_eff_literal( *n ) && + (*n)->connective != ALL && + (*n)->connective != WHEN ) { + return FALSE; + } + tmp = new_PlNode( (*n)->connective ); + tmp->atom = (*n)->atom; + tmp->sons = (*n)->sons; + tmp->neft = (*n)->neft; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->connective = AND; + (*n)->sons = tmp; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->neft = -1; + } + + for ( i = (*n)->sons; i; i = i->next ) { + if ( is_eff_literal( i ) ) { + m++; + continue; + } + if ( i->connective == AND ) { + for ( j = i->sons; j; j = j->next ) { + if ( !is_eff_literal( j ) ) { + return FALSE; + } + m++; + } + continue; + } + if ( i->connective == ALL ) { + for ( j = i->sons; j && j->connective == ALL; j = j->sons ) { + if ( !j->atom || + !j->atom->next || + j->atom->next->next != NULL ) { + return FALSE; + } + } + if ( !j ) { + return FALSE; + } + if ( is_eff_literal( j ) ) { + tmp = new_PlNode( AND ); + for ( k = i; k->sons->connective == ALL; k = k->sons ); + k->sons = tmp; + tmp->sons = j; + j = tmp; + } + if ( j->connective == AND ) { + for ( k = j->sons; k; k = k->next ) { + if ( !is_eff_literal( k ) ) { + return FALSE; + } + } + tmp = new_PlNode( WHEN ); + for ( k = i; k->sons->connective == ALL; k = k->sons ); + k->sons = tmp; + tmp->sons = new_PlNode( TRU ); + tmp->sons->next = j; + continue; + } + if ( j->connective != WHEN ) { + return FALSE; + } + if ( !(j->sons) ) { + j->sons = new_PlNode( TRU ); + } + if ( !is_wff( j->sons ) ) { + return FALSE; + } + if ( !make_conjunction_of_literals( &(j->sons->next) ) ) { + return FALSE; + } + continue; + } + if ( i->connective != WHEN ) { + return FALSE; + } + if ( !(i->sons) ) { + i->sons = new_PlNode( TRU ); + } + if ( !is_wff( i->sons ) ) { + return FALSE; + } + if ( !make_conjunction_of_literals( &(i->sons->next) ) ) { + return FALSE; + } + } + + if ( m == 0 ) { + return TRUE; + } + + tmp = new_PlNode( WHEN ); + tmp->sons = new_PlNode( TRU ); + literals = new_PlNode( AND ); + tmp->sons->next = literals; + tmp->next = (*n)->sons; + (*n)->sons = tmp; + i = (*n)->sons; + while ( i->next ) { + if ( is_eff_literal( i->next ) ) { + next = i->next->next; + i->next->next = literals->sons; + literals->sons = i->next; + i->next = next; + continue; + } + if ( i->next->connective == AND ) { + next = i->next->next; + for ( j = i->next->sons; j && j->next; j = j->next ); + if ( j ) { + j->next = literals->sons; + literals->sons = i->next->sons; + } + i->next = next; + continue; + } + i = i->next; + } + return TRUE; + +} + + + +Bool is_eff_literal( PlNode *n ) + +{ + + if ( !n ) { + return FALSE; + } + + if ( n->connective == NOT ) { + if ( !n->sons || + n->sons->connective != ATOM || + !n->sons->atom ) { + return FALSE; + } + return TRUE; + } + + if ( n->connective == ATOM ) { + if ( !n->atom ) { + return FALSE; + } + return TRUE; + } + + if ( n->connective == NEF ) { + if ( !n->lh || + !n->rh || + n->neft < 0 ) { + return FALSE; + } + return TRUE; + } + + return FALSE; + +} + + + +Bool make_conjunction_of_literals( PlNode **n ) + +{ + + PlNode *tmp, *i; + + if ( !(*n) ) { + return FALSE; + } + + if ( (*n)->connective != AND ) { + if ( (*n)->connective == NOT ) { + if ( !((*n)->sons) || + (*n)->sons->connective != ATOM ) { + return FALSE; + } + tmp = new_PlNode( NOT ); + tmp->sons = (*n)->sons; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + if ( (*n)->connective == NEF ) { + tmp = new_PlNode( NEF ); + tmp->neft = (*n)->neft; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->neft = -1; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + if ( (*n)->connective != ATOM ) { + return FALSE; + } + tmp = new_PlNode( ATOM ); + tmp->atom = (*n)->atom; + (*n)->atom = NULL; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + + for ( i = (*n)->sons; i; i = i->next ) { + if ( !is_eff_literal( i ) ) { + return FALSE; + } + } + + return TRUE; + +} + + diff --git a/gen/ff_planner/parse.h b/gen/ff_planner/parse.h new file mode 100644 index 000000000..f9924c085 --- /dev/null +++ b/gen/ff_planner/parse.h @@ -0,0 +1,63 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: parse.h + * Description: Functions for the pddl parser + * + * Author: Frank Rittinger 1998 / Joerg Hoffmann 1999 + * + *********************************************************************/ + + + + + +#ifndef _PARSE_H +#define _PARSE_H + + + +char *copy_Token( char *s ); +TokenList *copy_TokenList( TokenList *source ); +void strupcase( char *from ); +char *rmdash( char *s ); + + + +void build_orig_constant_list( void ); +void collect_type_names_in_pl( PlNode *n ); +int get_type( char *str ); +void make_either_ty( TypedList *tyl ); +void make_either_ty_in_pl( PlNode *n ); +void normalize_tyl_in_pl( PlNode **n ); + + + +Bool make_adl_domain( void ); +Bool make_conjunction_of_atoms( PlNode **n ); +Bool is_wff( PlNode *n ); +Bool make_effects( PlNode **n ); +Bool is_eff_literal( PlNode *n ); +Bool make_conjunction_of_literals( PlNode **n ); + + + +#endif /* PARSE */ diff --git a/gen/ff_planner/relax.c b/gen/ff_planner/relax.c new file mode 100644 index 000000000..dd657ac60 --- /dev/null +++ b/gen/ff_planner/relax.c @@ -0,0 +1,2756 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: relax.c + * Description: this file handles the relaxed planning problem, i.e., + * the code is responsible for the heuristic evaluation + * of states during search. + * + * --- THE HEART PEACE OF THE FF PLANNER ! --- + * + * here: linear tasks +=,-=,:= / le / le le + * + * + * Author: Joerg Hoffmann 2000--2002, 2011 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "relax.h" +#include "search.h" + + + + + + + +/* local globals + */ + + + + + + + + +/* fixpoint + */ +int *lF; +int lnum_F; +int *lE; +int lnum_E; + +int *lch_E; +int lnum_ch_E; + +int *l0P_E; +int lnum_0P_E; + + + + + +/* 1P extraction + */ +int **lgoals_at; +int *lnum_goals_at; + +float **lf_goals_c_at; +Comparator **lf_goals_comp_at; + +int lh; + +int *lch_F; +int lnum_ch_F; + +int *lused_O; +int lnum_used_O; + +int *lin_plan_E; +int lnum_in_plan_E; + + +/* helpful actions numerical helpers + */ +Comparator *lHcomp; +float *lHc; + + + + + + + + + + + + + + + + + + + + +/************************************* + * helper, for -1 == INFINITY method * + *************************************/ + + + + + + + + + + + + +Bool LESS( int a, int b ) + +{ + + if ( a == INFINITY ) { + return FALSE; + } + + if ( b == INFINITY ) { + return TRUE; + } + + return ( a < b ? TRUE : FALSE ); + +} + + + +Bool FLOAT_LE( float a, float b ) + +{ + + if ( b == INFINITY ) { + return TRUE; + } + + if ( a == INFINITY ) { + return FALSE; + } + + return ( a <= b ? TRUE : FALSE ); + +} + + + + + + + + + + + + + + +/*********************************** + * FUNCTIONS ACCESSED FROM OUTSIDE * + ***********************************/ + + + + + + + + + + + + + + + + + +int get_1P( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + } else { + h = INFINITY; + } + + reset_fixpoint( max ); + + return h; + +} + + + +int get_1P_and_H( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + collect_H_info(); + } else { + h = INFINITY; + } + + reset_fixpoint( max ); + + return h; + +} + + + +int get_1P_and_A( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + } else { + h = INFINITY; + } + + collect_1P_and_A_info(); + reset_fixpoint( max ); + + return h; + +} + + + +void collect_1P_and_A_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_1P_and_A_info"); + } + + for ( i = 0; i < gnum_A; i++ ) { + gop_conn[gA[i]].is_in_A = FALSE; + } + gnum_A = 0; + + for ( i = 0; i < lnum_E; i++ ) { + if ( gef_conn[lE[i]].level != 0 ) break; + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; + gA[gnum_A++] = gef_conn[lE[i]].op; + } + +} + + + +void get_A( State *S ) + +{ + + int i; + + initialize_fixpoint( S ); + + for ( i = 0; i < lnum_F; i++ ) { + activate_ft( lF[i], 0 ); + } + for ( i = 0; i < lnum_0P_E; i++ ) { + if ( gef_conn[l0P_E[i]].in_E ) { + continue; + } + new_ef( l0P_E[i] ); + } + for ( i = 0; i < gnum_fl_conn; i++ ) { + activate_fl( i, 0 ); + } + + collect_A_info(); + + /* 0 should be enough here... + */ + reset_fixpoint( 1 ); + +} + + + +void collect_A_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_A_info"); + } + + for ( i = 0; i < gnum_A; i++ ) { + gop_conn[gA[i]].is_in_A = FALSE; + } + gnum_A = 0; + + for ( i = 0; i < lnum_E; i++ ) { + /* levels are not set unless we actually build the RPG! +/* if ( gef_conn[lE[i]].level != 0 ) break; */ + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; + gA[gnum_A++] = gef_conn[lE[i]].op; + } + +} + + + +void get_A_axioms( State *S ) + +{ + + int i; + + initialize_fixpoint( S ); + + for ( i = 0; i < lnum_F; i++ ) { + activate_ft( lF[i], 0 ); + } + for ( i = 0; i < lnum_0P_E; i++ ) { + if ( gef_conn[l0P_E[i]].in_E ) { + continue; + } + new_ef( l0P_E[i] ); + } + for ( i = 0; i < gnum_fl_conn; i++ ) { + activate_fl( i, 0 ); + } + + collect_A_axioms_info(); + + /* 0 should be enough here... + */ + reset_fixpoint( 1 ); + +} + + + +void collect_A_axioms_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA_axioms = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A_axioms = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_A_axioms_info"); + } + + for ( i = 0; i < gnum_A_axioms; i++ ) { + gop_conn[gA_axioms[i]].is_in_A_axioms = FALSE; + } + gnum_A_axioms = 0; + + for ( i = 0; i < lnum_E; i++ ) { + /* levels are not set unless we actually build the RPG! +/* if ( gef_conn[lE[i]].level != 0 ) break; */ + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A_axioms ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( !gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- no axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + + gop_conn[gef_conn[lE[i]].op].is_in_A_axioms = TRUE; + gA_axioms[gnum_A_axioms++] = gef_conn[lE[i]].op; + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +/******************************* + * RELAXED FIXPOINT ON A STATE * + *******************************/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Bool build_fixpoint( State *S, int *max ) + +{ + + int start_ft, stop_ft, start_ef, stop_ef, i, time = 0; + float costlevel; + + initialize_fixpoint( S ); + + start_ft = 0; + start_ef = 0; + while ( TRUE ) { + if ( gcmd_line.debug ) { + printf("\n======================================FP time %d", time); + } + + if ( all_goals_activated( time ) ) { + break; + } + if ( time > 0 || lnum_0P_E == 0 ) { + if ( start_ft == lnum_F ) { + if ( fluents_hopeless( time ) ) { + /* fixpoint, goals not reached + */ + *max = time; + return FALSE; + } + } + } + /* make space if necessary, and copy over + * info from time to time+1 for fluents + */ + extend_fluent_levels( time ); + for ( i = 0; i < gnum_fl_conn; i++ ) { + if ( gfl_conn[i].def[time] ) { + gfl_conn[i].def[time+1] = TRUE; + gfl_conn[i].level[time+1] = gfl_conn[i].level[time]; + } + } + + /* determine the next effect layer: + * - activate the facts + * - if level 0 activate the no preconds-ops + * - activate the fluents at their ;UFhfQoG<2!dn0!_Zi=71_+$Qc literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan206-objects.json b/gen/layouts/FloorPlan206-objects.json new file mode 100644 index 000000000..3fd08680a --- /dev/null +++ b/gen/layouts/FloorPlan206-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "KeyChain", + "Television", + "Window", + "Bowl", + "GarbageCan", + "CreditCard", + "TVStand", + "Cabinet", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan206-openable.json b/gen/layouts/FloorPlan206-openable.json new file mode 100644 index 000000000..6a7f82072 --- /dev/null +++ b/gen/layouts/FloorPlan206-openable.json @@ -0,0 +1,122 @@ +{ + "ArmChair|+02.34|+00.00|-02.04": [ + 1.5, + -2.0, + 90, + 30 + ], + "Cabinet|-01.83|+00.73|-02.36": [ + -0.75, + -1.75, + 270, + 30 + ], + "CoffeeTable|+00.02|00.00|-01.11": [ + 0.25, + -1.75, + 0, + 30 + ], + "GarbageCan|+00.74|00.00|-02.52": [ + 1.25, + -2.0, + 270, + 30 + ], + "Shelf|+00.34|+00.27|-02.38": [ + 1.0, + -1.25, + 270, + 30 + ], + "Shelf|+00.34|+00.47|-02.38": [ + 1.0, + -1.25, + 270, + 30 + ], + "Shelf|+00.34|+00.64|-02.38": [ + 1.0, + -1.0, + 180, + 0 + ], + "Shelf|-00.39|+00.30|-02.38": [ + -1.0, + -1.25, + 90, + 30 + ], + "Shelf|-00.39|+00.60|-02.38": [ + -1.0, + -1.0, + 180, + 0 + ], + "Shelf|-01.73|+00.28|-01.63": [ + -1.0, + -1.25, + 270, + 30 + ], + "Shelf|-01.73|+00.30|-00.48": [ + -0.5, + 0.25, + 180, + 30 + ], + "Shelf|-01.73|+00.45|-01.06": [ + -0.75, + -0.5, + 180, + 30 + ], + "Shelf|-01.73|+00.48|-01.63": [ + -0.25, + -1.75, + 270, + 0 + ], + "Shelf|-01.73|+00.60|-00.48": [ + -0.75, + 0.0, + 180, + 30 + ], + "Shelf|-01.73|+00.65|-01.63": [ + -0.5, + -1.75, + 270, + 0 + ], + "Shelf|-01.83|+01.45|-02.36": [ + -0.75, + -1.75, + 270, + -30 + ], + "Shelf|-01.83|+02.04|-02.36": [ + -0.75, + -1.75, + 270, + 0 + ], + "Sofa|+00.12|+00.01|+01.03": [ + -0.5, + 0.25, + 0, + 30 + ], + "TVStand|-00.03|00.00|-02.39": [ + 0.0, + -1.75, + 180, + 30 + ], + "TVStand|-01.73|00.00|-01.06": [ + -1.0, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan207-layout.npy b/gen/layouts/FloorPlan207-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a0929c7eba7ca9916298aef2062af25a96cebc6a GIT binary patch literal 2352 zcmbW(txhvR6b9gh5JCtSv2G!$0Spk5R^cER1d24!20?(d1VgwAE~vM#mw-gBs6Zh2 z+4GDzlA6ggbI#0r*iU?KXBVgEmn+qC_0rr-=GU|4sBVs@2hE^vrVq2H+4%nIVRke5 z-9H)M%_l$m^V{*`4(XXGeek8vS(|K~2yiEQ~_TF;Q z-|Ibok9}^F`>v`g=W##F%OB~yOO{u?ylj;_ukzcMpWDdK@^c$`SbmnDyHvkSmS4Sm zR{6M%d@LW!$MUg!EFa6q^08H}yvk=^K9-N=WBFJ<_I`OM{+_I#^|StxEBaYK>u3FC z4)4dR-?@I)U*?WJ*3bG`f3D-a>M#3?eiHlcWp$ia?=Mqs*3bGmul{}6cfWn#o!iLI zz6-aJi_ORKv3x8C=T-ezyrZ7gv-)b(CsohtS^a9NXZ6ML_gGV(?7ngyx!HZi(Z8PV zWB0Ln*nP!u-$uHRyL9gRJNNy$P4!j$%K5P0VBep8e>M-Bhs{$Q?{B7g*gR|=HV>PJ h&BJZX!{%Z0u>TiqrF<+O%g6Gud@LW!$MS8Bz5%}cShoNG literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan207-objects.json b/gen/layouts/FloorPlan207-objects.json new file mode 100644 index 000000000..96571469e --- /dev/null +++ b/gen/layouts/FloorPlan207-objects.json @@ -0,0 +1,27 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Cabinet", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan207-openable.json b/gen/layouts/FloorPlan207-openable.json new file mode 100644 index 000000000..3c460de3b --- /dev/null +++ b/gen/layouts/FloorPlan207-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|+00.40|+00.01|+02.19": [ + 0.5, + 1.5, + 0, + 30 + ], + "ArmChair|-00.63|+00.01|+02.19": [ + -0.75, + 1.5, + 0, + 30 + ], + "Cabinet|-01.77|+00.73|-01.59": [ + -1.0, + -1.25, + 270, + 30 + ], + "CoffeeTable|-00.15|+00.00|+00.42": [ + -0.75, + 0.5, + 90, + 30 + ], + "Shelf|+01.66|+00.27|+00.61": [ + 0.5, + 0.0, + 0, + 30 + ], + "Shelf|+01.66|+00.30|-00.12": [ + 0.5, + 0.5, + 180, + 30 + ], + "Shelf|+01.66|+00.44|+00.24": [ + 0.5, + 0.75, + 180, + 30 + ], + "Shelf|+01.66|+00.47|+00.61": [ + 0.5, + 0.0, + 0, + 30 + ], + "Shelf|+01.66|+00.60|-00.12": [ + 0.75, + -0.5, + 0, + 30 + ], + "Shelf|+01.66|+00.64|+00.61": [ + 0.75, + 0.25, + 0, + 30 + ], + "Shelf|-01.77|+01.45|-01.59": [ + -1.0, + -1.5, + 270, + 30 + ], + "Shelf|-01.77|+01.74|-01.59": [ + -0.75, + -1.5, + 270, + 30 + ], + "Shelf|-01.77|+02.04|-01.59": [ + -1.0, + -1.5, + 270, + 0 + ], + "SideTable|-01.57|00.00|+01.82": [ + -1.25, + 2.5, + 180, + 30 + ], + "Sofa|-01.45|+00.01|+00.42": [ + -0.75, + 0.5, + 270, + 30 + ], + "TVStand|+01.67|00.00|+00.24": [ + 1.0, + 0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan208-layout.npy b/gen/layouts/FloorPlan208-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..70465ddc524364501d653330bac2ce093f8ef854 GIT binary patch literal 3376 zcmbW&u}U0a6vgo`K}19(<_V^o1hx=uBm~wfUBo6us<6bB6hUP-qzQS7Jdi%ZJc6a= z6jN-mg=Y8r340(-rn&s@eD|DlXJ>c+oPGLu{`p1uS$?$_)A`p~`>tu)^&t3F@XO#5 zyu2-|>tDL`Rr;7drjO}kl}=WA`t&e8OmDyLrH|=hdYB%jw-#nRW`j|fUoG~4oRUUnLusqn_=ICSRa8~;I z^zr?8y(gw`jy`q{XQi*dsNY9?AKX>{=lj7A!F})$ya<+GF8MKEoK=4P;dcGJa3A~- zY+vWQxW85_#eMr?`(pdz#dtH1{p7YEex9p2^i}&|`(gWG`(gWG`LX<1ek`vX@?z(3 zR(bX1#qwf#usm2Ey7FLousNJn9({Q*f6U(;f6O2A$8>O3{`y^gFED@S_+$Q*t|QU!Oki>Um5b)4^GX znCGWI)aQ-6dLHw`{4hV9)%(Awy8JPJ%pdc|{4sybANxI6R{v$)7t4d?!RE{9`b{#A J&13WB^brgf0D%Ai literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan208-objects.json b/gen/layouts/FloorPlan208-objects.json new file mode 100644 index 000000000..0bee20c25 --- /dev/null +++ b/gen/layouts/FloorPlan208-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "GarbageCan", + "CreditCard", + "Ottoman", + "TVStand", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "Shelf", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan208-openable.json b/gen/layouts/FloorPlan208-openable.json new file mode 100644 index 000000000..ef1237543 --- /dev/null +++ b/gen/layouts/FloorPlan208-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|-00.56|+00.00|+01.95": [ + 0.25, + 1.5, + 270, + 30 + ], + "DiningTable|-03.10|+00.00|-03.61": [ + -2.25, + -3.5, + 270, + 30 + ], + "Drawer|+01.76|+00.77|+01.09": [ + 0.75, + 1.25, + 90, + 0 + ], + "GarbageCan|-01.34|+00.02|-04.83": [ + -2.0, + -4.5, + 90, + 30 + ], + "Ottoman|-00.58|+00.01|+01.05": [ + -1.25, + 1.75, + 180, + 30 + ], + "Shelf|-00.61|+00.88|-02.83": [ + -0.5, + -2.0, + 180, + 30 + ], + "Shelf|-00.61|+01.32|-02.83": [ + -0.5, + -2.0, + 180, + 30 + ], + "Shelf|-02.24|+00.27|+00.40": [ + -1.0, + -0.25, + 0, + 30 + ], + "Shelf|-02.24|+00.30|+01.13": [ + -1.0, + 0.5, + 0, + 30 + ], + "Shelf|-02.24|+00.44|+00.76": [ + -1.25, + 1.25, + 180, + 30 + ], + "Shelf|-02.24|+00.47|+00.40": [ + -0.75, + 0.5, + 270, + 0 + ], + "Shelf|-02.24|+00.60|+01.13": [ + -1.25, + 1.5, + 180, + 30 + ], + "Shelf|-02.24|+00.64|+00.40": [ + -1.25, + 0.75, + 180, + 30 + ], + "SideTable|+01.83|+00.00|+01.09": [ + 1.25, + 1.25, + 90, + 30 + ], + "Sofa|+00.88|+00.01|-00.59": [ + -0.25, + -0.5, + 90, + 30 + ], + "TVStand|-02.24|00.00|+00.76": [ + -1.5, + 1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan209-layout.npy b/gen/layouts/FloorPlan209-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e0abd893f321db939292b31685e32617dbd38425 GIT binary patch literal 4816 zcmbW)Juh=%7{KvEq>)C%`}@n;4oRn45VMU~3?@0z(-=hMR4n3C_(1hhIvNcIgF)5( zTdtAi;7M~PhZb3&n~VevZw61=v4iix;V~@lkQ>B%8PEVeyq#;>t5Zde(#@_ zcl~N~zkgdkR3q=Tj}BUSd%u;xPW1+NCL1b+>(@t2>sl^$P6 z*Uezh?{Ux1o}WEGdwyOHKi_@V`SAE$@NDo*a5H#1xDh-RJQuFpu98k2@#Ft9`j|Uu<7&Uu<982=myN$L)*l zi|vc;i|vc;%Q@_e?ThV;?ThV;?ThV;?ThV;?ThV;^<{loU)GoPWqny+)|d5VeOX_> z7y7cktS{@!`m(;PFYC+tvc9Y@>&yDGzN|0n%lfjutS{@!`m$c;)Qk0Ey;v{Si}hl? zSTBxOz1-J}^6oV!c=|*27$SupX=j>%n@k9_)EJUd`{m`PuwzejUxv=4bP> z`PuwzUiQ3fUN$eAm(6R>=4JD;dD*;dUN$eAm(9!OW%IIm{T`Z^&CBLx^Rju_ylh@J zFPoRm%jWfWVqP{co0rYY=4JD;dD*;dUN$d#ee!o~el|awpUuzaXY;f9+5BvNHb0x6 zy`TAa-p|x^=7?U&tdAVAM3~Z Rv3{%{n~%-M=40~>2S4)mgUSE^ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan209-objects.json b/gen/layouts/FloorPlan209-objects.json new file mode 100644 index 000000000..de861c186 --- /dev/null +++ b/gen/layouts/FloorPlan209-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "WateringCan", + "Dresser", + "Drawer", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Shelf", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan209-openable.json b/gen/layouts/FloorPlan209-openable.json new file mode 100644 index 000000000..79c456774 --- /dev/null +++ b/gen/layouts/FloorPlan209-openable.json @@ -0,0 +1,62 @@ +{ + "ArmChair|-04.33|+00.00|-03.53": [ + -4.0, + -4.25, + 0, + 30 + ], + "CoffeeTable|-02.47|+00.00|-02.49": [ + -1.75, + -2.5, + 270, + 30 + ], + "Drawer|-02.98|+00.17|-05.01": [ + -3.75, + -4.5, + 90, + 30 + ], + "Drawer|-04.02|+00.17|-05.01": [ + -3.25, + -4.5, + 270, + 30 + ], + "Dresser|-03.51|+00.00|-05.10": [ + -3.25, + -4.5, + 180, + 30 + ], + "GarbageCan|-00.97|-00.03|-05.06": [ + -1.5, + -4.75, + 90, + 30 + ], + "Shelf|-02.48|+00.12|-02.49": [ + -1.5, + -2.5, + 270, + 30 + ], + "SideTable|-02.02|+00.00|-05.08": [ + -2.5, + -4.5, + 90, + 30 + ], + "SideTable|-05.43|+00.00|-05.12": [ + -6.25, + -4.5, + 180, + 30 + ], + "Sofa|-04.36|+00.01|-02.09": [ + -3.5, + -2.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan21-layout.npy b/gen/layouts/FloorPlan21-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..762df682bbf580e2ff5a25f678c95c1078234285 GIT binary patch literal 1584 zcmbW#u}Z^G6b9g{h)ACzTNJYBq#|^4Q(PRJq}Y@WVkHq5@hN;D`v`f2j*b}|92~6X zeu!r@LoeS+&-qW%zMNm4U0iLX$MjTA>-MH8kBjnTc34(LIa@Rj&E)QS(M;>_`sw7h zt=IK-KDn>g-aXo{ii5qXcrN~XjndE6y$26WT6c9uN&*Y|bad47gQyj!fA}-=n_&~jn;3IVG zn4v?54%TzeXYfCImhkCK?!CY7&|h!gy*Yk=Cw)&p7AKqC$L-=pw|IH_e6j2nr)S%5 z+x3?ZXWNs_-@m_Jf8K3w|GxXQ{<^vKlhw1;vRge}c0arSJd;$;!+!Yu{c8Ap5PT4P zKlpL=Mg9Fzu=~62{_OtjewX2X{HWfa4}(3=b^-93h%?-hrJJbAND>xt^IfsJPvMyN5T8L&;9IUd#=MCwukLud)OYfhwWi| z*dDfr?O}V^o|~|T?O}V^9=3<=VSCsfwukLud)OYfC*@SmQ9pdLJ!}u#!}hQ}Y!BPR zZFv4D*dE`vhwW){D#sqShwWi|*dF%(i~WD(dwnX0?*`96oV!c=|){FIGy;v{Si`#zK$$D`UuBYIe^M8MT9efq6 zzx(UY`nP$wul}q*>(BbL{;WUi&-%0etUv3|`m_G5Kezp`llA8&T-V=q{aJt3pY><` zS^se!-b;VhpY><`S%21_^=JKAf7YM%=V|T5`m_GrhVSd|dK0ee@4Ei1KkLu>v;M6A zB&TxpXZ=}!)}Qrf{aJt3pY><`c~<-IG+2Mv_2)KxUw_y2XZ=}!)}Qrf{aJt3f0|P{ z`m_G5KkLu>v;M3<>(BbL{yeMwSbx@^$Km^Ju>QWUKkLu>v;M3<>(BbL{<`S%21_^=JKAf1cF7tQYIWda+)t7wa_-y;v{Si}hl?_@KT&>&1GpUaS}E O#d@**Y(LvS&wl_7N|d$$ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan210-objects.json b/gen/layouts/FloorPlan210-objects.json new file mode 100644 index 000000000..bae18ef7d --- /dev/null +++ b/gen/layouts/FloorPlan210-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "Ottoman", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "Dresser", + "Chair", + "DogBed", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan210-openable.json b/gen/layouts/FloorPlan210-openable.json new file mode 100644 index 000000000..d38e8c23d --- /dev/null +++ b/gen/layouts/FloorPlan210-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|-04.38|+00.01|+01.40": [ + -3.5, + 1.5, + 270, + 30 + ], + "Drawer|-00.36|+00.21|+03.80": [ + -1.5, + 3.25, + 0, + 30 + ], + "Drawer|-00.36|+00.21|+04.22": [ + -1.5, + 3.5, + 0, + 30 + ], + "Drawer|-00.36|+00.58|+03.79": [ + -1.25, + 3.25, + 0, + 30 + ], + "Drawer|-00.36|+00.59|+04.22": [ + -1.25, + 3.75, + 0, + 30 + ], + "Drawer|-02.29|+00.27|+04.11": [ + -1.75, + 3.5, + 0, + 30 + ], + "Drawer|-02.29|+00.75|+04.11": [ + -1.75, + 3.5, + 0, + 30 + ], + "Drawer|-02.83|+00.27|+04.11": [ + -2.25, + 3.25, + 270, + 30 + ], + "Drawer|-02.84|+00.75|+04.11": [ + -2.25, + 3.5, + 0, + 30 + ], + "Dresser|-00.27|+00.00|+04.01": [ + -0.75, + 4.0, + 90, + 30 + ], + "Dresser|-02.56|+00.01|+04.22": [ + -3.5, + 4.0, + 90, + 30 + ], + "Ottoman|-01.77|+00.00|+01.81": [ + -1.0, + 1.25, + 270, + 30 + ], + "SideTable|-00.25|+00.00|+02.10": [ + -0.75, + 3.0, + 90, + 30 + ], + "SideTable|-04.29|+00.01|+00.41": [ + -4.75, + 0.25, + 90, + 30 + ], + "SideTable|-06.72|+00.01|+00.00": [ + -6.25, + 0.5, + 180, + 30 + ], + "Sofa|-02.52|+00.01|+00.26": [ + -2.5, + 1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan211-layout.npy b/gen/layouts/FloorPlan211-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2bf7794512207ebc0a5eccdf4735e852efdff612 GIT binary patch literal 2240 zcmbW&F-ikL6b9fGL?n2K?N%X;u@MoH%1*Jdu##XBEW}76HsUEfP_8gXNSShrEmEW~ zy7L8mrD?`*XZF4S?PBtEb9a4vzgN5$AJu3)f1FhpWpz0@uexP5naiakGI$7Ps7*o*2kx3y>8h%>6V}6KR=z~_p@BI>n5)$xZN#^-G2Y?`DJjO?_cM2 z6|A3q{a8OvxjyU1tFT`OH^J-R{XyGNy@O!$G>i6}dDuK`9&Ya{3QoB{n}^NAbvSPx z`{vqxvn0o$Leuh)vLq* zEvv`samw?tx5G)@yqd$lJly1Zjr)S-u`dtH!}72^EDy`WzOUl6(8w)E#1Y%*tfUz;2!UN$EI07Xl#TFD4 z{_H#?eu<6SjL+=PygQhEzr4PEQ8pG98Y- z=g$WZv(eZ5?0)bx`trf?QMZ$y9Cq@z{GUfF`#JVMs&O^1#&&QkxEb6Ct_RnGv*2x7 z*ZP}aeaq0t`dA+~(t50q^|3zI$NIQTUA+Foi|}6TK8|CSj@^8(n&4&dI=Bqp1aE`0 z{_p44g6qMJ;AU_u*zcUB!~3)M;y5l+uX*p!t8iYg^Lkk?>*aReU)88zhkn-2?&dh^ zH?N=dvwqgk`dL5gx2}HH&-&SOIF9u3F}pY^kT*1ub4o_?3`f9$+|*3Y}=ru)qs z^|OA~&-z(E>tCn!>_6Lo*3XM{AM0o9a2(5Uzwd$Td=J?7fNTA#i0u#CAGSYif7t%8 M{n6=qc756V1VFa#_6Y@zY07o?RFp$EVfH!{Zl6t9y&p{a5>|y~XO)yQ2?B z2XCLhJ9>F|`u@X%H^+x3?;pQDcz<}3ckk}+?=9}$+FN{H{O7SVPLIvC_1WwA`E~nx z{e0e39yf|FX8tkfub$7F%41o)^3Z2qFa2C!AG~t<;rg1tS?gCGtKyw+o#*5B`Mjw- z?i8;)_KJ7r@B8$-oafKHsT_YepXT|(E5{$spLxFU%JGNuXMVT(S04PDuN>bv->%Ou zUOB#TzGc3@mG7D38|N3VJov>c$2ZQm>+_3Oj&GcA^ZeqK;~VGOJimD5>~EZJ^Zerc zj(OO>GsZ8@Ctf*zaemG7iB}$c;+5kU=hyZ5#4E=y&aZhs@yhXw^J|`8oZoK`w(l(0 z+t-=n7v~eN9KSff=J~`c$1l#Wc|P&VgHOD2{Nnt&KA(8y_;o&C-?#qaYvzB?*U9<9 z^)p{NeQ|xw>xWlPU+3%lqx#OAzPP@)et6~d#q~9>A6_|qov-iD>N|7#;`-wH;g!=D z*Vnv$c;)oPeV%@8`wsnQ-c(M1Tz~WW;+4}M*WbLpc;)oR_5WS{XHI`yU%Yaj2e{{f z?DOk-?hmh=`^DX_dH07`&i&%<_fOsL%(-9O{o$2!zqtD~?|Fw;&hroV{4>uNUOCS{ zoImq?;g$1y3Fpte?-SYY`LQ0S$ENb&7q2{)>(jB5V}15FzGu$o1Lqs(7q6V(OE}-= z`Nb>$`#zuj_%_e4`O4X^IN#>^#VcpOI)Ab4F)q$NmE#-dd*=AYm+NtMT%51`&b+Cd z{f+Z&o?pCj_BYPAd4BQA+21(d=J~}dXMf{-o43DlelM-Z*}><``F|B(&hzlf+0Qt? z=C9X$(zublmi^J|_@ymIz4&aZhs@yglHINvhgm!}85XO3^#`p&l=UODUI z);I6>v26V-+df%ew*Ji7U%2&g>*1C2|0b@Ftk2HuWBr-4K5l*7dU)lmk6V9d{TFzm B*Y5xT literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan213-objects.json b/gen/layouts/FloorPlan213-objects.json new file mode 100644 index 000000000..56f6f2380 --- /dev/null +++ b/gen/layouts/FloorPlan213-objects.json @@ -0,0 +1,27 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Book", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Shelf", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan213-openable.json b/gen/layouts/FloorPlan213-openable.json new file mode 100644 index 000000000..d5835af4b --- /dev/null +++ b/gen/layouts/FloorPlan213-openable.json @@ -0,0 +1,146 @@ +{ + "ArmChair|+08.22|+00.01|-00.08": [ + 8.75, + -0.25, + 270, + 30 + ], + "ArmChair|+08.23|+00.01|+00.77": [ + 8.75, + 1.5, + 180, + 30 + ], + "ArmChair|+09.50|+00.00|+03.27": [ + 9.25, + 2.5, + 0, + 30 + ], + "CoffeeTable|+10.82|-00.01|+00.93": [ + 11.25, + 0.25, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+00.56": [ + 13.0, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+01.07": [ + 13.0, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+01.58": [ + 13.0, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+02.10": [ + 13.0, + 1.5, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+00.56": [ + 13.25, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+01.07": [ + 13.25, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+01.58": [ + 13.25, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+02.10": [ + 13.0, + 2.75, + 180, + 30 + ], + "Drawer|+14.18|+00.58|+00.56": [ + 13.25, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+01.07": [ + 13.25, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+01.58": [ + 13.25, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+02.10": [ + 13.25, + 1.5, + 0, + 30 + ], + "Dresser|+14.33|+00.00|+01.32": [ + 13.5, + 1.25, + 90, + 30 + ], + "Shelf|+10.79|+00.23|+00.93": [ + 10.5, + 1.75, + 180, + 30 + ], + "SideTable|+11.38|+00.00|-01.16": [ + 10.75, + -0.5, + 90, + 30 + ], + "SideTable|+12.31|+00.00|-01.15": [ + 12.75, + -0.5, + 180, + 30 + ], + "SideTable|+14.33|+00.00|+00.07": [ + 13.5, + -0.5, + 0, + 30 + ], + "SideTable|+14.33|+00.00|+02.59": [ + 13.75, + 2.75, + 90, + 30 + ], + "SideTable|+14.62|00.00|-00.78": [ + 14.0, + -0.25, + 180, + 30 + ], + "Sofa|+11.45|+00.00|+03.21": [ + 11.5, + 2.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan214-layout.npy b/gen/layouts/FloorPlan214-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7de05a61f39ff149a9a2e2eac6cf891cf5255895 GIT binary patch literal 3024 zcmbW$y>1gh6b8^?WsM@sitO;8%AG-S6RHRyWhy!l4Fwglh$9L_kb`ItPr(B*k3vaF zLE$0=VP{TrOQu;J@7=xMm)PH5zJBrQ&8_q$eO;YzuiouePnWA_7pJTBa&>XJ`@GwH ze0#Y&-~Rjj`R2pb_U7}e_nS}K8$UWZJy|cGJYFxqE&uaO(|BgJUH510It@Mu&cT!5 zAvgtJ|48GpZy)?8_;>KH;GecjeQu5FGd!TPwb59`DG-iP&JeOMpXhxHjs%c&3R!?~vM45eKswOxnOueD#h^%=VL zVSQL1)`#_B`6nffM}C%{b8T}hKl^`h3iI;2FF(uA^0U0Tv>fuXyqx=fmY0WcKLyKc zUS5`$v^aB{hnvfv-w$=XY*|SFwC=gHa`#ZY@W?8!aSR2 z^G9Kx&GS)BzE1 zSzeZxy*?y_G9^2K9-N=WBJ(MZ?-4r zO`C)DVSQNsT-w*k&+@bUEI-T7^0WNx^ND>vvCk*gm-D90&7I(b;1p~hueT4|r(06< z*oW=I_F?<5eb_#1AGQzoYksy5+lO=be)~AL58H?B!}ei&^h#%;o+pyp?NSRa;`O9G zLtd7b&q`{ZX}yp2XZ?8;zF&Xm`m_G5KkLsqyubd=^=JKAf7YM+R#*K5QSh58H?B!#Uh%ALsUA`>=i3K5QSh&%=_M$3AQyp45D7AGQzM zhwa1mVf(OsIEVY~-MAGQzMhxLC{QuFA~`m_G5KkLu>v;M3<>(6=9=3@O>f7YM% zXZ_iq57z&2Y46pa^=JKAf7YM%XZ=}!&YLy|>(BbL{;WUi&-$~zPfB~QzN|0n%kE?M fvHRH1r`XS@Sf1mMhvi}SvHRG4>^}DM#pCi9x@2HO literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan215-objects.json b/gen/layouts/FloorPlan215-objects.json new file mode 100644 index 000000000..60b621433 --- /dev/null +++ b/gen/layouts/FloorPlan215-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Pillow", + "Statue", + "Box", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "Bowl", + "GarbageCan", + "CreditCard", + "WateringCan", + "DeskLamp", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan215-openable.json b/gen/layouts/FloorPlan215-openable.json new file mode 100644 index 000000000..69e837fe8 --- /dev/null +++ b/gen/layouts/FloorPlan215-openable.json @@ -0,0 +1,92 @@ +{ + "CoffeeTable|-02.49|+00.02|+04.04": [ + -3.25, + 4.0, + 90, + 30 + ], + "CoffeeTable|-05.56|+00.02|+06.83": [ + -5.25, + 6.0, + 0, + 30 + ], + "Shelf|-00.59|+00.25|+02.00": [ + -1.75, + 2.5, + 90, + 30 + ], + "Shelf|-00.59|+00.25|+05.98": [ + -1.5, + 5.75, + 90, + 30 + ], + "Shelf|-02.85|+00.47|+07.17": [ + -2.75, + 6.5, + 0, + 30 + ], + "Shelf|-02.85|+00.90|+07.17": [ + -2.75, + 6.25, + 0, + 0 + ], + "Shelf|-02.86|+00.16|+07.17": [ + -4.5, + 6.25, + 90, + 30 + ], + "Shelf|-02.87|+01.29|+07.17": [ + -3.0, + 6.5, + 0, + 0 + ], + "Shelf|-05.95|+00.16|+04.34": [ + -5.25, + 4.5, + 270, + 30 + ], + "Shelf|-05.95|+00.47|+04.34": [ + -5.25, + 4.25, + 270, + 30 + ], + "Shelf|-05.95|+00.90|+04.34": [ + -5.0, + 4.25, + 270, + 0 + ], + "Shelf|-05.95|+01.29|+04.35": [ + -5.25, + 4.75, + 270, + 0 + ], + "SideTable|-00.59|+00.01|+02.00": [ + -1.25, + 2.25, + 90, + 30 + ], + "SideTable|-00.59|+00.01|+05.98": [ + -1.25, + 6.25, + 90, + 30 + ], + "Sofa|-00.77|+00.02|+03.92": [ + -1.5, + 3.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan216-layout.npy b/gen/layouts/FloorPlan216-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..c199eae736d2c19c6344eab8dd577dcd539bc5ce GIT binary patch literal 2560 zcmbW&F-j{@6oBDTBuEg^9ZWY0X%qwz!Ol*xv9OY05-da|5gTz8E+{S`OGue=iYZc9 z7?bm*IHl7J-yPn$bAN}Iuj|{Zo4bwTz4)kl{n5j)IxDO5!D-bgtHI0gZPoF_7^@lIyvr?$A_Krv;61PE|ypOdv$Ncowt%VlZ)h^ak0F1V|^ap zNjBf}?ex5ryccfLd^VrWXY<*7-jDfp%(ovq58IFJ$M$3UvHfQ0JZwIj&*roFJijQG z7u#%!if^L-NMu)aENQScuH{T z-a|jukM(2ySU=W}^<(|G9$%y;v{Si}hl??9=*QJz>3AFV>6oV!gPDKCBn(#d@(` z>>Ql$dRf&1GpUaS}E#m>d~u9x*XI~`74!b*ZBScpm@HsVw41DVIMwAdm= zigoYI*Zk$)CVZKA?l~d&`{(74Usng|CB4?S%gxQYKC9~U)oDGe>eb`=dA)eJeq7%! z|Gj^)xZf6QRr8}+^;Z4o8K!a$x9#ihd;2;L9t97B2f;bGAKVL0 z!Ta}Ajy}8KKf(I%Lx0wv^=JJ#cYRoY)}Qrf{dw2*W&K(I)RfuD_s{yX{_H+>AG?p; z*9-Tt``CRfpXIasev`_vhvl<;me2B8eh&F8pXIZBme2ABA)n>5e3sAhS^hBO^JtsO zVfpO$$~k<#AKVL0!G1sT^k@B9|52058FzWCKkLtf@cA69zt8K>`m_G5KkLu>kDFAE z{;WUi&x5Wn=V1Lk*Pr!g{aJt3pQqh@hfOMH5^SI6_OX3D41aH*=Q%vL&vX0OKDLkT zWBXYDNt4RapY><`S%1#kHiz|R{aJt3pY><``Lp|f&-P54wue1z58K1`aNf2#Y!BPR S_OLx{58K1`@JF|A+WZAD>Eo>c literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan217-objects.json b/gen/layouts/FloorPlan217-objects.json new file mode 100644 index 000000000..fab11eadd --- /dev/null +++ b/gen/layouts/FloorPlan217-objects.json @@ -0,0 +1,29 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "Cabinet", + "DeskLamp", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan217-openable.json b/gen/layouts/FloorPlan217-openable.json new file mode 100644 index 000000000..ba058be94 --- /dev/null +++ b/gen/layouts/FloorPlan217-openable.json @@ -0,0 +1,92 @@ +{ + "ArmChair|-00.30|+00.00|+01.71": [ + -1.25, + 1.75, + 90, + 30 + ], + "ArmChair|-00.30|+00.00|+03.31": [ + -1.25, + 3.25, + 90, + 30 + ], + "Cabinet|-04.41|+00.50|+01.57": [ + -4.0, + 2.25, + 270, + 30 + ], + "Cabinet|-04.41|+00.50|+02.59": [ + -3.75, + 1.75, + 0, + 30 + ], + "Cabinet|-04.41|+00.50|+02.60": [ + -3.75, + 2.25, + 0, + 30 + ], + "Cabinet|-04.41|+00.50|+03.62": [ + -4.0, + 3.0, + 270, + 30 + ], + "CoffeeTable|-02.41|00.00|+02.55": [ + -2.5, + 3.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+01.82": [ + -4.0, + 2.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+02.34": [ + -4.0, + 2.75, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+02.85": [ + -4.0, + 3.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+03.37": [ + -4.0, + 3.75, + 180, + 30 + ], + "Dresser|-04.74|+00.00|+02.60": [ + -4.0, + 2.75, + 270, + 30 + ], + "GarbageCan|-04.81|-00.03|+01.24": [ + -4.0, + 1.5, + 270, + 30 + ], + "SideTable|-00.04|+00.00|+04.62": [ + -0.75, + 4.5, + 90, + 30 + ], + "Sofa|-02.46|00.00|+00.70": [ + -2.25, + 1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan218-layout.npy b/gen/layouts/FloorPlan218-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..43b4a4f9f53a2bfebe3ca8a381ed7d817cddc05e GIT binary patch literal 6400 zcmbW)y-rkJ6oBC^At!{8$?*SUGu>!Hg^d~$c4eorv9K~khFBOegRwDQg%`xR1TKM+ za*8P^rVv^CF=3TXLmtk|IeWbe{P=#qegEd&hezc{`8htFTzs02UyjDF&Yq7CN8_{e z>G$c$*N^AZ)5+iOzdreLF}eHx#pjc6lRH0o_TuPpboBIa^lS8=uhnw@TJGcP&2fBP zN-oKZ%ZKm3O`a#ul5dhde|G%v`Rw`Z`Rw^TZ}(@6oV!c=|){FIG zy;v{Si}m6`ALr(^Wc^&%kM(2ySU--ZmBRWBYFyEe^<({557vYAU_Dq5)`Run)z*jg zU_Dq5)`Rt6zmKfXF!f>cvU%COY+g1mo0nJHyu6ZZUf0db=4JD;`PS2XY(6$0n~%-M z=411*`Ph7HzieJMFPoRm%jVrk^Rju_ylh@JFPoRm%jRYCa@WU++3!E=!FsSBtOv*4 zOJO}WYh3aB&*o?Iv-#QlY<@OBo1eQr&cVyc{@!){w*B{o^6o;y6ty?B560 zZ>z>T^Tay;*P8n@fAK-t6yd z)_=Rk2lZ#YS#KWp@j2F;^=7?UZ|>6l^mbiu)|>Tay;*P8oAqYBS#OT%OJTiPZ`OOK z#wYb=KkuwRueUy|KkLu>v;M3<`S%21_^=JKAe~xOUu->dU>%CXwlX|ni zk9n)j&zs5i;ktdWeXxD7eXxD7eQ=kaZy&DP2iphR2iphR2iphR2iwO#AD8%Cv& z`+Bq9?Ego2w~x>9PV#oLeR;oqv3;?9v3;?9v3;?9v3+ru&Szh)+ZWpx+ZWpx+ZWpx z+ZWr%K`r+$`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`{1r`bJzH4AFkU6+XveR M+XveR+s8ru13&Ct_5c6? literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan218-objects.json b/gen/layouts/FloorPlan218-objects.json new file mode 100644 index 000000000..b52cc7c18 --- /dev/null +++ b/gen/layouts/FloorPlan218-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Curtains", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "CellPhone", + "Dresser", + "DeskLamp", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "CoffeeTable", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan218-openable.json b/gen/layouts/FloorPlan218-openable.json new file mode 100644 index 000000000..eec0c2905 --- /dev/null +++ b/gen/layouts/FloorPlan218-openable.json @@ -0,0 +1,68 @@ +{ + "CoffeeTable|-01.55|+00.00|+02.53": [ + -1.0, + 3.25, + 180, + 30 + ], + "DiningTable|-05.64|00.00|+04.91": [ + -6.5, + 5.0, + 90, + 30 + ], + "Drawer|+00.75|+00.23|+03.33": [ + -0.25, + 4.0, + 180, + 30 + ], + "Drawer|+00.75|+00.23|+04.10": [ + 0.25, + 3.75, + 90, + 30 + ], + "Drawer|+00.75|+00.67|+03.33": [ + 0.0, + 2.75, + 0, + 30 + ], + "Drawer|+00.75|+00.67|+04.10": [ + 0.0, + 3.5, + 0, + 30 + ], + "Dresser|+00.85|+00.00|+03.71": [ + 0.5, + 5.0, + 180, + 30 + ], + "GarbageCan|-07.10|-00.04|+02.30": [ + -6.5, + 3.0, + 270, + 30 + ], + "SideTable|+00.73|+00.01|+06.64": [ + 0.5, + 6.0, + 0, + 30 + ], + "SideTable|-03.41|+00.01|+01.66": [ + -2.75, + 1.5, + 270, + 30 + ], + "Sofa|-02.47|+00.00|+03.28": [ + -1.25, + 3.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan219-layout.npy b/gen/layouts/FloorPlan219-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..53a9e420d63206ac302712d7b74c3076e32f2be3 GIT binary patch literal 3552 zcmbW$KZ_GV7{K9i2}1}W_`lw671DTEhzK{8onm8QCBe&KA)X{+BYp}$ko$42OmRhu z6rMZtG;irN!;={{`~FCNzkUDa-G@8rNBTKjZ10rkAfctKM1}bd@tC%o^M_@FPoRm%Q-yXyw1(b=H=6$G%Y>`-vl3m^}0E) z&(VwZV!c=|){FIGy;v{Si}m6>*7sz+STEL#^yRcG4x~oSU=W}^<({5 zKh}@+WBph^){pgL{rJ@8XZ=`@Q|Q5ZupX=j>%n@k9;^rJ!FsSBtOx7CdaxdRY<*ad zRO;{6|BLltJy;LcgY{rNSP#~N^BF32kXIlupX=j>%n@k z9;^rJ!Ff#6>Pp>bW8J&b_Ob2FdUVZtupX?(tligx^-} z9_;tQDcsk?xgM-XF7AU z^)~7v)`Rt6Jy?%rNz>AU^1uW^td* gq-mL-&Clj%^RxNc{A_++wE1`*Y#!(4Ve_oYUmmn*5&!@I literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan219-objects.json b/gen/layouts/FloorPlan219-objects.json new file mode 100644 index 000000000..770f701c6 --- /dev/null +++ b/gen/layouts/FloorPlan219-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "GarbageCan", + "CreditCard", + "Newspaper", + "CellPhone", + "Cabinet", + "Dresser", + "DeskLamp", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Safe", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "TissueBox", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan219-openable.json b/gen/layouts/FloorPlan219-openable.json new file mode 100644 index 000000000..6daba59dd --- /dev/null +++ b/gen/layouts/FloorPlan219-openable.json @@ -0,0 +1,158 @@ +{ + "ArmChair|-02.03|+00.00|+04.42": [ + -2.0, + 3.75, + 0, + 30 + ], + "Cabinet|-02.88|+00.56|+04.21": [ + -3.5, + 3.75, + 0, + 30 + ], + "Cabinet|-04.03|+00.56|+04.21": [ + -3.75, + 3.75, + 0, + 30 + ], + "Cabinet|-04.05|+00.56|+04.21": [ + -3.75, + 3.5, + 270, + 30 + ], + "Cabinet|-05.20|+00.56|+04.21": [ + -5.5, + 3.5, + 90, + 30 + ], + "Drawer|-03.17|+01.01|+04.31": [ + -3.5, + 3.75, + 90, + 30 + ], + "Drawer|-03.75|+01.01|+04.31": [ + -3.25, + 3.75, + 270, + 30 + ], + "Drawer|-04.33|+01.01|+04.31": [ + -4.75, + 3.75, + 90, + 30 + ], + "Drawer|-04.92|+01.01|+04.31": [ + -4.5, + 3.75, + 270, + 30 + ], + "Drawer|-05.02|+00.90|+00.37": [ + -4.25, + 1.0, + 270, + 30 + ], + "Dresser|-04.04|00.00|+04.59": [ + -3.5, + 3.75, + 0, + 0 + ], + "Safe|-02.30|+00.00|+00.27": [ + -1.5, + 1.0, + 180, + 30 + ], + "Shelf|-00.25|+00.78|+01.06": [ + -0.75, + 1.25, + 90, + 30 + ], + "Shelf|-00.28|+00.27|+01.07": [ + -1.0, + 1.25, + 90, + 30 + ], + "Shelf|-00.28|+01.29|+01.05": [ + -1.0, + 1.0, + 90, + 0 + ], + "Shelf|-00.28|+01.81|+01.06": [ + -0.75, + 1.25, + 90, + 0 + ], + "Shelf|-01.22|+00.27|+00.26": [ + -1.5, + 1.0, + 180, + 30 + ], + "Shelf|-01.22|+00.78|+00.24": [ + -1.75, + 1.0, + 90, + 30 + ], + "Shelf|-01.22|+01.29|+00.27": [ + -1.75, + 1.0, + 180, + 30 + ], + "Shelf|-01.22|+01.81|+00.28": [ + -1.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.39|+00.09": [ + -4.75, + 1.0, + 180, + -30 + ], + "Shelf|-05.24|+01.58|+00.07": [ + -4.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.78|+00.07": [ + -4.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.97|+00.09": [ + -4.25, + 1.0, + 180, + 0 + ], + "SideTable|-05.02|+00.01|+00.27": [ + -5.0, + 1.0, + 180, + 30 + ], + "Sofa|-00.71|00.00|+02.75": [ + -1.5, + 2.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan22-layout.npy b/gen/layouts/FloorPlan22-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a2bddb6722cdbd16b4e4fb99ca0a8f3b62b32dbc GIT binary patch literal 2256 zcmbW$u};EJ6oBEYVe%=uRTCCvF~&qDH;s#flOa;#V8noNF+PP4B#+QXU}Wsjfq_A^ z=Ogisc4@x0_WT^=^ZNGc=58;&rT21N%^zmvSy7%(PRo8#PNuWh+35LxIvZC%*Dps; z^J;s2{y2K6wmv)_4En{%QNQ>o{&^gv?pSoE&TvSUoY3u$9h?>zthWlSuZ!y!FpLQ@8-IYo%On` zm-Tv1FYD#jo?;Jr-Pg-{SugA0{H#Z}9&V$D^{^h+!+KZ`>tQ{s`22cU59?t)tcUfm z9yY(p=Ck>1KAX?xv-xaZo6X}k_Rmdb^V~O&{r|1w{pPX#vUzMCo5$wy{-WFHCgz#X zo9Jir*?cyi&1dsj2lt{U4ZALVtdI5aI(k_j>tlVakM(gc`u4Lv*2nr-AM0a%tdI3^ z9iNv|99+lu%6_-(cf?Khe4E)mJZ~SpVfsCMUu++2A8a3NA8a3NA8a3NAKX=?#P-4V P!S=!S!S=!S(HnjPXOlrz literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan22-objects.json b/gen/layouts/FloorPlan22-objects.json new file mode 100644 index 000000000..51552ba88 --- /dev/null +++ b/gen/layouts/FloorPlan22-objects.json @@ -0,0 +1,42 @@ +[ + "StoveBurner", + "Stool", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "CreditCard", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan22-openable.json b/gen/layouts/FloorPlan22-openable.json new file mode 100644 index 000000000..445026e53 --- /dev/null +++ b/gen/layouts/FloorPlan22-openable.json @@ -0,0 +1,176 @@ +{ + "Cabinet|+00.17|+02.01|-01.20": [ + -0.5, + -0.5, + 180, + 0 + ], + "Cabinet|+00.24|+02.01|-01.20": [ + 0.0, + -0.5, + 180, + 0 + ], + "Cabinet|+00.48|+00.39|-00.90": [ + -0.25, + -0.25, + 90, + 30 + ], + "Cabinet|+01.12|+02.01|-01.20": [ + 0.5, + -0.5, + 180, + 0 + ], + "Cabinet|+01.13|+00.47|-00.90": [ + 0.25, + -0.25, + 90, + 30 + ], + "Cabinet|-00.77|+02.01|-01.20": [ + -1.0, + -0.5, + 180, + 0 + ], + "Cabinet|-00.82|+00.47|-00.91": [ + -1.75, + 0.0, + 90, + 30 + ], + "Cabinet|-00.84|+02.01|-01.20": [ + -1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-01.77|+02.01|-01.20": [ + -2.0, + -0.5, + 180, + 0 + ], + "Cabinet|-01.80|+00.47|-00.91": [ + -2.0, + -0.25, + 90, + 30 + ], + "Cabinet|-01.84|+02.01|-01.20": [ + -1.75, + -0.5, + 180, + 0 + ], + "Cabinet|-01.85|+00.39|-00.90": [ + -2.0, + -0.25, + 180, + 30 + ], + "Cabinet|-02.39|+00.39|+00.38": [ + -1.5, + -0.5, + 0, + 30 + ], + "Cabinet|-02.63|+02.01|-01.20": [ + -2.0, + -0.5, + 180, + -30 + ], + "Cabinet|-02.65|+02.01|+00.36": [ + -2.0, + -0.25, + 270, + 0 + ], + "Cabinet|-02.65|+02.01|-00.95": [ + -1.75, + 0.0, + 180, + 0 + ], + "Cabinet|-02.65|+02.08|-00.23": [ + -2.0, + 0.0, + 270, + 0 + ], + "Cabinet|-02.65|+02.08|-00.88": [ + -2.0, + -0.25, + 270, + 0 + ], + "Cabinet|-02.65|+02.20|+00.43": [ + -1.25, + 1.0, + 270, + 0 + ], + "Cabinet|-02.65|+02.20|+01.67": [ + -2.25, + 1.75, + 270, + -30 + ], + "CounterTop|+00.07|+00.95|-01.20": [ + 0.25, + -0.5, + 180, + 30 + ], + "CounterTop|+00.91|+01.15|+00.79": [ + 0.25, + 0.5, + 0, + 30 + ], + "CounterTop|-02.70|+00.95|+00.11": [ + -2.0, + -0.25, + 270, + 30 + ], + "Drawer|+00.26|+00.78|-01.08": [ + -0.25, + 0.0, + 180, + 0 + ], + "Drawer|-02.03|+00.78|-01.08": [ + -1.5, + 0.0, + 180, + 0 + ], + "Drawer|-02.57|+00.78|+00.10": [ + -1.75, + -0.5, + 0, + 30 + ], + "Fridge|-02.86|+00.00|+00.85": [ + -1.75, + 0.75, + 270, + 30 + ], + "Microwave|+00.28|+00.90|-01.33": [ + 0.0, + -0.5, + 180, + 0 + ], + "Sink|-01.33|+00.92|-01.23|SinkBasin": [ + -0.75, + -0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan220-layout.npy b/gen/layouts/FloorPlan220-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..cbfb298e970e68e3e6c6e2d1c50d344d6d943b48 GIT binary patch literal 3712 zcmbW&KWkG_9LM3~C0t4frS(teyIqA$p@WFvncS2v9h@ZC6bG@Ah>Q3td_mrq(3jA$ zV}=YFGFb09&+;41V0e0y)ARkH`1}3kyNeHx(vS4BzglfRt@~G9|N8o6KkxeMoAvkg z^6ST&_0{U%&)+V;Y*r6H-+W$vTRr&sVsSq27BA-AukJrz(=@(zf6Du9ecuM(2cHe) z^ZtAi>^#q%$IfHt-M%S5c{Y@Hej4oedHy&&KMi&tpLZX2A9kO+a36Lbb{}>hb{}>h zb{}>hcAxujA9f#hA9f#hA3mwQ_&9hLe5ijPe10EnpXc_meQe)0>|^`bKDLkTWBb@X zwvX*&`*>IPvVCkH+qVn**gm$8?PL4cKDLkTWBb@XwvV@UFWbj=;kmv0u$S#+d)Z#L zm+fVH*`?0-jFWbxZvb}8YA?#&)*&beu zo~$S9+2nFhJy}oIll5dhSx?rJ^<+I+Pi}`azM5R#CqsE}a(y4_d$pcTwVtde>&beu zo~$S9Imu~!>B)Mso~$S9$$GM$tS9TqdU89Id$OMF?&beuo~$S9$$GM$tS7g%59`TIc%Fjw^m#p5Pu7$5Wc`kE8ejUceykts$NI5; ztRK(nKGu)*<2HO=KhK-+TtCnCWBph^){pg?=2Tww_p$TY`RsglK0ALF&S&Sd^V#|A Te0KhEJ>U1)_u2Q^_fPU)3+t?9 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan220-objects.json b/gen/layouts/FloorPlan220-objects.json new file mode 100644 index 000000000..4ade16795 --- /dev/null +++ b/gen/layouts/FloorPlan220-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Candle", + "Pillow", + "Box", + "Boots", + "Sofa", + "Statue", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Drawer", + "Painting", + "RoomDecor", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan220-openable.json b/gen/layouts/FloorPlan220-openable.json new file mode 100644 index 000000000..39f0b25e7 --- /dev/null +++ b/gen/layouts/FloorPlan220-openable.json @@ -0,0 +1,92 @@ +{ + "ArmChair|-02.06|+00.01|+04.22": [ + -1.75, + 3.5, + 0, + 30 + ], + "CoffeeTable|-02.65|+00.01|+01.15": [ + -2.75, + 1.75, + 180, + 30 + ], + "DiningTable|+00.17|+00.67|+01.98": [ + -1.0, + 2.0, + 90, + 0 + ], + "DiningTable|+00.17|+00.86|+01.98": [ + -0.75, + 2.0, + 90, + 0 + ], + "Drawer|-00.31|+00.18|+03.61": [ + -1.5, + 2.75, + 0, + 30 + ], + "Drawer|-00.31|+00.47|+03.61": [ + -1.75, + 3.5, + 90, + 0 + ], + "Drawer|-00.31|+00.76|+03.61": [ + -1.5, + 3.5, + 90, + 0 + ], + "Drawer|-00.31|+01.05|+03.61": [ + -1.25, + 3.5, + 90, + 0 + ], + "Drawer|-00.36|+00.22|+00.52": [ + -1.0, + 0.0, + 90, + 30 + ], + "Drawer|-00.36|+00.58|+00.52": [ + -1.0, + 0.0, + 90, + 30 + ], + "Dresser|-00.27|+00.00|+03.61": [ + -0.75, + 2.75, + 0, + 30 + ], + "SideTable|-00.28|+00.01|+00.52": [ + -0.75, + 0.75, + 90, + 30 + ], + "Sofa|-02.68|+00.01|-00.12": [ + -1.75, + 0.75, + 180, + 30 + ], + "Sofa|-03.79|+00.02|+03.89": [ + -3.75, + 3.0, + 0, + 30 + ], + "TVStand|+00.17|+00.59|+01.98": [ + -0.5, + 2.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan221-layout.npy b/gen/layouts/FloorPlan221-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..1998dfe53466034f9930433a8609e39fc508e2a2 GIT binary patch literal 1904 zcmbW$u}Z^07zglEBuEjTAzKu>)Ja6>=BBtfI7zW74q_z{7x5{4AoB=)gpM6MbZ~I6 zn)@x^XqM~ma(CbVYm$$vo6GClo%EXCs%hQcH`Q5LozG6IVOh=Q%}Xp!FaLQB(%-e;^<$C8!#wWg@gR5*Y`^tIxNqLL8}6%T zUOiTi)noNI)-i8Pxjw6BUOjd`JD;7yas2*F{gvx}1#g1a!K>h9@FF-@OLE8;b8sBx zGcO;@$MUg!EFa6q@~JB~TgP#f&%AsrAIrz`v3x9_I`Xl6>^!z#F8kSfwq9=Qx#;?Y z`tUxo{cJz`-qiK}v-h8UZ>&D6&+4=K?EhkU`mR!vhvi{;xaj=qM|sT3!}72^?76e& z$ZOwQp731U_dm1#7UO&9~WJ}kM+m;WBsxISbx09{jmO6f2=>&-!k;a`eXgE T{#bwP{8c!gozKo^=dZ>;E<^}{ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan221-objects.json b/gen/layouts/FloorPlan221-objects.json new file mode 100644 index 000000000..0c292118a --- /dev/null +++ b/gen/layouts/FloorPlan221-objects.json @@ -0,0 +1,29 @@ +[ + "FloorLamp", + "Stool", + "Curtains", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan221-openable.json b/gen/layouts/FloorPlan221-openable.json new file mode 100644 index 000000000..616f56233 --- /dev/null +++ b/gen/layouts/FloorPlan221-openable.json @@ -0,0 +1,44 @@ +{ + "ArmChair|+00.66|+00.10|-01.78": [ + 0.0, + -1.5, + 90, + 30 + ], + "CoffeeTable|-01.05|+00.10|-02.47": [ + -0.5, + -1.75, + 180, + 30 + ], + "CoffeeTable|-01.09|+00.10|-00.74": [ + -0.5, + 0.0, + 180, + 30 + ], + "DiningTable|-03.43|+00.10|-01.19": [ + -2.25, + -1.5, + 270, + 30 + ], + "Drawer|-00.03|+00.87|-02.49": [ + -0.5, + -1.5, + 180, + 0 + ], + "SideTable|-00.03|+00.10|-02.55": [ + -0.25, + -2.0, + 180, + 30 + ], + "Sofa|-00.91|+00.10|+00.96": [ + -1.5, + 0.25, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan222-layout.npy b/gen/layouts/FloorPlan222-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..b2a8cc9718e5f2cf19ef4807f70182005f8015d7 GIT binary patch literal 1648 zcmbW$Ax;B96b9e{$tl(?Bvm9NKuB7JgJ2LS($FOcLdlk32&dpcy}}-$vU0_WiV6xd zpWsQ>ynM4e^Z(tpU)Q%+H+OsKJ$=-(X7SM0=T&|2cv_FD`f=XAwbPgTc{^)<)-R{e zi)OdJc$&U8J0G5%jH=_KQT18<_c}$+0 zm|r>wGWzmnqMEc`T3R zu{@UNcdG|`j^p$`toNlS>&N=BeyktsCr3ZlkL}|)^|P)Y>&N=BeypE!^<({5KXwks fsh@TISU=W}{coJ3FYC+BW9PB+^yrrPgw6OH;_3TC literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan222-objects.json b/gen/layouts/FloorPlan222-objects.json new file mode 100644 index 000000000..3b4888f48 --- /dev/null +++ b/gen/layouts/FloorPlan222-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan222-openable.json b/gen/layouts/FloorPlan222-openable.json new file mode 100644 index 000000000..78f79df35 --- /dev/null +++ b/gen/layouts/FloorPlan222-openable.json @@ -0,0 +1,86 @@ +{ + "ArmChair|+00.22|-00.01|-01.72": [ + 0.25, + -1.0, + 180, + 30 + ], + "CoffeeTable|+00.23|00.00|-00.16": [ + 0.75, + -0.5, + 270, + 30 + ], + "Drawer|+00.47|+00.06|-00.17": [ + 1.5, + 0.5, + 180, + 30 + ], + "Drawer|+00.47|+00.17|-00.17": [ + 1.5, + 0.5, + 180, + 30 + ], + "Drawer|+00.47|+00.27|-00.17": [ + 1.5, + -1.0, + 0, + 30 + ], + "Drawer|+02.00|+00.78|+01.71": [ + 1.5, + 1.0, + 90, + 30 + ], + "Drawer|-00.02|+00.06|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "Drawer|-00.02|+00.17|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "Drawer|-00.02|+00.27|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "SideTable|+02.00|+00.00|+01.75": [ + 1.75, + 1.25, + 0, + 30 + ], + "SideTable|+02.96|+00.00|+01.57": [ + 2.0, + 1.0, + 0, + 30 + ], + "SideTable|-00.68|+00.00|-01.60": [ + -0.25, + -1.0, + 180, + 30 + ], + "Sofa|+02.87|00.00|+00.25": [ + 2.0, + 0.25, + 90, + 30 + ], + "TVStand|+00.84|-00.01|+01.58": [ + 2.0, + 1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan223-layout.npy b/gen/layouts/FloorPlan223-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..665418e122d9cac06770ebc649028343ff60128b GIT binary patch literal 3344 zcmbW&v5FHx7zgli3E>FhGo*_`3cX51a4S2-#==U1m%~ClNyJ8c3LhwWgnfi7uiRpb z6e&D2-)|vbd1;2<>}KXa|AgJY??1l#@aa+cRemq7*4riT&@4lzg>OXuJ7l!UspfY_kMc${Kay9`D{7=Gk@S`R!*N`SI0w)eezxMZE}}f zS1ZMO-JA3EZ-yp*&cpg*eX+h+U#u_I7f<%}fO_)3VfS$!^=V$8-0jZSuPSA{9{sRB zS)bge`}N_vK3E^D57r0k!?~L1hfDG?&gZ)RSbuCE&ZGX!cWHh7jn|_O)*tJS^~3sM z{jmIU$vuUJ2< zAJz}+hdrNJU(TT~))(uG^~J-k=4bnG9`$8jU#u_I7we1l#rk6BwXgHC^Rn}@^YReq z<%@kizjI8J?eDt%+5UWt_1XSxf1bsDdXtCcVR={{mWSoxL*!$5SRTKdJS-2(!}72^ pEDy`W@~}KjTTUN&c)CALm!_@bWM9Xot)uTx!oJVbeZ6ne{sUHT-gy83 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan223-objects.json b/gen/layouts/FloorPlan223-objects.json new file mode 100644 index 000000000..e7796955d --- /dev/null +++ b/gen/layouts/FloorPlan223-objects.json @@ -0,0 +1,28 @@ +[ + "FloorLamp", + "Plate", + "Candle", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "TVStand", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan223-openable.json b/gen/layouts/FloorPlan223-openable.json new file mode 100644 index 000000000..926752e61 --- /dev/null +++ b/gen/layouts/FloorPlan223-openable.json @@ -0,0 +1,50 @@ +{ + "ArmChair|-00.43|+00.01|+01.06": [ + -1.0, + 0.25, + 0, + 30 + ], + "ArmChair|-00.44|+00.01|+01.92": [ + -1.25, + 2.0, + 90, + 30 + ], + "ArmChair|-02.01|+00.01|-01.58": [ + -1.25, + -1.0, + 270, + 30 + ], + "CoffeeTable|-02.02|+00.01|+00.02": [ + -1.25, + -0.25, + 270, + 30 + ], + "DiningTable|+01.88|+00.00|-00.29": [ + 3.0, + -0.25, + 270, + 30 + ], + "DiningTable|-01.86|+00.23|+02.79": [ + -2.5, + 1.75, + 90, + 30 + ], + "SideTable|-03.60|+00.00|-01.61": [ + -2.5, + -1.0, + 270, + 0 + ], + "Sofa|-03.42|+00.01|-00.04": [ + -2.5, + 0.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan224-layout.npy b/gen/layouts/FloorPlan224-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..32ec8b98d34f480b238ced98dc1ea711dd6487e8 GIT binary patch literal 4688 zcmbW%v5FHx7{Kvy2#fd>+pR*X1K|+Ct?U#V3o8j;4h!)l5gYL-e4y+j2kXJ*b}8{#=Vg6Z zAD+Ye`gorEasunaO?duzDDRuI30?*3>3uy}Pj)WHRZshRvYxCb>&1HUTzj!zocr|f z!+Nn^te1N?L-{=G#d@(`tQYIW&gHo3WnV8o9+vkjO3CxF_Ted5PtWyaJvsNw^Yrvw z&$EZ}zB%+`{a8QNkM(2y*tr~6{p=rWKQ6aTiS^^D_GA56Kh}?PA9@7q=ly0V@4L5t ztRL&g`muhjAM3~N!Ex2kez|Q*e5}3rHux@BZ}02Pdb8fFH|IX|3)b8F%~0Mqm)@*5 z>&<$z-mEu|hvj*Cd+uHw*YfF<&il0|>&<$z-aLiR>+QMTtT*R=Igj5Dp6kti-<`*}XZg$J)=n{;WUi&r|rk{+{d4`g896sjT|j)t~h| z-+L%eSWniIr`nJ8WIb6=)|1_f7M?5vYxCb zPqioO$$GM$tS9Tqdaxd>2kXIlupX=j>*0ISgY{rNSP#~N^N^v$Hn~$gZeY5%4d~7~8ADfTO$L3@6vH941&h`DV`Ph6s)%kb~HlOElHJ^R+ zvH941Y(6$0o6kAsWAm~3*nB+J`Ph8yT#l>x?3<6x$L3@6vHASH=Ht2Emrudw^W1!F yJ~ki6)jamy&%XPy`|+vXkKK>mkKK>mkDafp^V#|Ae0DxNpPkRn^Syb#>i+=xY_kFY literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan224-objects.json b/gen/layouts/FloorPlan224-objects.json new file mode 100644 index 000000000..c848824cf --- /dev/null +++ b/gen/layouts/FloorPlan224-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Stool", + "Pillow", + "Statue", + "Box", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Book", + "WateringCan", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "Dresser", + "Chair", + "DogBed", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan224-openable.json b/gen/layouts/FloorPlan224-openable.json new file mode 100644 index 000000000..0e044ef87 --- /dev/null +++ b/gen/layouts/FloorPlan224-openable.json @@ -0,0 +1,182 @@ +{ + "ArmChair|-02.86|+00.03|-02.04": [ + -2.25, + -1.5, + 270, + 30 + ], + "Drawer|+03.10|+00.17|+00.36": [ + 2.0, + -0.25, + 0, + 30 + ], + "Drawer|+03.10|+00.17|+01.40": [ + 2.0, + 0.75, + 0, + 30 + ], + "Drawer|+03.10|+00.17|-00.57": [ + 2.0, + 0.0, + 180, + 30 + ], + "Drawer|+03.10|+00.42|+00.36": [ + 2.25, + -0.25, + 0, + 30 + ], + "Drawer|+03.10|+00.42|+01.40": [ + 2.25, + 1.0, + 0, + 30 + ], + "Drawer|+03.10|+00.42|-00.57": [ + 2.25, + 0.0, + 180, + 30 + ], + "Drawer|-00.17|+00.47|-02.14": [ + -0.5, + -1.5, + 90, + 30 + ], + "Drawer|-00.19|+00.23|+00.95": [ + -1.25, + 1.5, + 180, + 30 + ], + "Drawer|-00.19|+00.48|+00.95": [ + -1.25, + 1.5, + 180, + 30 + ], + "Drawer|-00.19|+00.74|+00.95": [ + -1.0, + 0.5, + 0, + 30 + ], + "Drawer|-00.42|+00.35|+01.41": [ + -1.25, + 2.0, + 180, + 30 + ], + "Drawer|-00.42|+00.35|+01.92": [ + -1.25, + 1.25, + 0, + 30 + ], + "Drawer|-00.42|+00.35|+02.38": [ + -1.25, + 1.75, + 0, + 30 + ], + "Drawer|-00.42|+00.60|+01.41": [ + -1.25, + 2.0, + 180, + 30 + ], + "Drawer|-00.42|+00.60|+01.92": [ + -1.25, + 1.25, + 0, + 30 + ], + "Drawer|-00.42|+00.60|+02.38": [ + -1.25, + 1.75, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+01.41": [ + -1.0, + 1.0, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+01.92": [ + -1.0, + 1.5, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+02.38": [ + -1.0, + 2.0, + 0, + 30 + ], + "Drawer|-03.24|+00.17|-00.49": [ + -2.25, + -1.0, + 0, + 30 + ], + "Drawer|-03.24|+00.42|-00.49": [ + -2.5, + -1.0, + 0, + 30 + ], + "Dresser|-00.05|+00.03|+01.67": [ + -0.75, + 1.75, + 90, + 30 + ], + "GarbageCan|+03.16|+00.03|+00.89": [ + 2.75, + 0.5, + 90, + 30 + ], + "SideTable|+03.16|+00.03|+00.36": [ + 2.75, + -0.25, + 90, + 30 + ], + "SideTable|+03.16|+00.03|+01.40": [ + 2.75, + 1.5, + 90, + 30 + ], + "SideTable|+03.16|+00.03|-00.57": [ + 2.75, + -1.0, + 90, + 30 + ], + "SideTable|-00.17|+00.03|-02.28": [ + -0.75, + -1.75, + 90, + 30 + ], + "SideTable|-03.30|+00.03|-00.49": [ + -2.75, + -1.25, + 270, + 30 + ], + "Sofa|-02.96|+00.03|+01.39": [ + -2.25, + 1.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan225-layout.npy b/gen/layouts/FloorPlan225-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..ad7052df7af997c082b3bbf305788284e4c43c67 GIT binary patch literal 2576 zcmbW$F^dyH7zW^R2}1}W+~pUfTZJ^I2qMBwWvAF!TqVKFafNu2h>iFw{6X$dvApt% zD^jHJ+?l8FE1hO}GQ0D=Z#Mb)_Whf87mw1n^u52_?mzDOm#hBO)r)?;>aT8gUw50& zA8vM++rOW`-hA3`A3on-Z@z3F{P^tov-RrfllAJy>Oa>kjcYN~>+N~H&Vy&c)8HID z3GRYZ@bOm~m-+JCg*+?|%fq>y&+@Q5EDy`W^4y0!EDy`W@~}KC56i>y@S%NQd>?!l zd>i~bSii&h_!^S;&-$@`tRL&g`mug|Y&KI!p2LThm*r)7S)Q)cbNrrI9+rpmkjB-OdYugQ z+Ld}WpUr3UC+&Xo*?cyi^N_~H=Ck>1KAWFQJ;!`DpUvky)aTedHjmAlminA|Y#y7( zd8p5^d2Ak^wEJhJK4(79!@l|U&F38M_kG*<`(yc7K9+A@(zq7we3p;p<7v1*2g~RF zF6^gZ|9|)E!}_p3?ElaH|E%w#q;cuX`m(+}ZFxBd>uXKbA k#-%Uo%g$rx@v`+jZRec^n`hrVb{;!#8O~$pvGbPY50_ygkpKVy literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan225-objects.json b/gen/layouts/FloorPlan225-objects.json new file mode 100644 index 000000000..56cce5761 --- /dev/null +++ b/gen/layouts/FloorPlan225-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Shelf", + "Chair", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan225-openable.json b/gen/layouts/FloorPlan225-openable.json new file mode 100644 index 000000000..c14fbdb01 --- /dev/null +++ b/gen/layouts/FloorPlan225-openable.json @@ -0,0 +1,86 @@ +{ + "ArmChair|-00.88|+00.01|+00.57": [ + -0.75, + 1.25, + 180, + 30 + ], + "CoffeeTable|-01.97|+00.00|+02.62": [ + -1.25, + 3.0, + 270, + 30 + ], + "Drawer|-04.43|+00.47|+03.34": [ + -3.5, + 2.75, + 0, + 30 + ], + "GarbageCan|-00.23|+00.01|+04.78": [ + -0.5, + 4.25, + 0, + 30 + ], + "Shelf|-00.34|+00.28|+03.05": [ + -2.0, + 3.5, + 90, + 0 + ], + "Shelf|-00.34|+00.31|+02.31": [ + -1.5, + 1.75, + 0, + 30 + ], + "Shelf|-00.34|+00.45|+02.68": [ + -1.25, + 2.25, + 0, + 30 + ], + "Shelf|-00.34|+00.48|+03.05": [ + -1.25, + 3.5, + 180, + 30 + ], + "Shelf|-00.34|+00.60|+02.31": [ + -1.25, + 2.75, + 180, + 30 + ], + "Shelf|-00.34|+00.65|+03.05": [ + -1.25, + 3.5, + 180, + 30 + ], + "SideTable|-04.61|+00.01|+03.35": [ + -4.0, + 4.0, + 270, + 30 + ], + "Sofa|-02.12|+00.01|+04.56": [ + -2.25, + 3.75, + 0, + 30 + ], + "Sofa|-04.57|+00.01|+01.88": [ + -3.75, + 2.0, + 270, + 30 + ], + "TVStand|-00.34|+00.01|+02.68": [ + -1.0, + 2.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan226-layout.npy b/gen/layouts/FloorPlan226-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..612bff252a03c692fd9fae9587c56e6b1ca74d94 GIT binary patch literal 1392 zcmbW#El$Kh7zW^i

#+;>QM z@;Q!udd~bhxC?HB$KA4Qw|@F}|329HJ@5RypU&@G`mjE%H_PET>Sta*Zc{(jkK5FT zyI|kXeSPe!59`D7Sw72W`FhA_`7EF1vwW7{ruQPB<+FU2&+=Km_bi{~vwW7%@>%|F z-D3`!PI-O6B^RjguNBfz#AKR~+eglST B=!pOT literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan226-objects.json b/gen/layouts/FloorPlan226-objects.json new file mode 100644 index 000000000..955390880 --- /dev/null +++ b/gen/layouts/FloorPlan226-objects.json @@ -0,0 +1,25 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "Blinds", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan226-openable.json b/gen/layouts/FloorPlan226-openable.json new file mode 100644 index 000000000..3a0e5fab9 --- /dev/null +++ b/gen/layouts/FloorPlan226-openable.json @@ -0,0 +1,68 @@ +{ + "ArmChair|+01.51|+00.00|-00.59": [ + 1.25, + -1.25, + 0, + 30 + ], + "CoffeeTable|-00.71|+00.01|-00.37": [ + -0.5, + -1.0, + 0, + 30 + ], + "Drawer|+01.74|+00.77|+00.33": [ + 0.75, + 0.0, + 90, + 0 + ], + "Drawer|-00.71|+00.08|-00.17": [ + 0.25, + 0.5, + 270, + 30 + ], + "Drawer|-00.71|+00.08|-00.56": [ + -1.75, + -1.25, + 90, + 30 + ], + "Drawer|-00.71|+00.24|-00.17": [ + 0.25, + 0.5, + 270, + 30 + ], + "Drawer|-00.71|+00.40|-00.17": [ + -1.25, + 0.5, + 180, + 30 + ], + "Drawer|-00.71|+00.40|-00.56": [ + -0.25, + -1.25, + 0, + 30 + ], + "Drawer|-00.72|+00.24|-00.56": [ + -1.0, + -1.25, + 90, + 30 + ], + "SideTable|+01.81|+00.00|+00.33": [ + 1.25, + 0.5, + 90, + 30 + ], + "Sofa|-00.50|+00.01|-01.89": [ + -0.5, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan227-layout.npy b/gen/layouts/FloorPlan227-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..01fe02cc4a31f59c63203eb32ff53aed7fca0700 GIT binary patch literal 3232 zcmbW(v2N2)6b9f+6j@aiRc+I>l*yYx$^v2lgj7%6in?@QLJ>{HfGA233*sqwAp9sD zJ7(yRAp@=N{gyN0rTSv~{`Z{YxcT$p^8DiClk_wFYOWTm&&%dr-Mqhk)6DAT`eylK zIsf+QW_h)E{QPYGb+vf-eD!7ieevMuFWfiN$9;4JBCtdz~dz$|~4L%M& z3Vv36SMIkSTaT^B*5hed?=W~0d=R`JycfJ1JPsZO?*v!D!{9-%{;W%X)Whmw^{{$a zJ**y9537gO!|Gx6uzEO^`gr>{^#^Z)?}OLDcfq&8`gMPrbM%Y#i}j23i}j23i}j1E zF6XlTu>P?Au>P?Au>SD6)X)0E`osFMDgDt8)(_SX)(_SXRu6B>{#gDtfdhB}kzTGX?yPv(E*m`U|w%%S?kIjcS<^96mk1U_% zvwZgdcfaJHbg4hs?-Ta>g#A9@X}JF|SifBFd1B8Kd!E?y#N)93DA@Dl`YN3FJUQ?C z!TQg>?`$4y9&8?L9&8?L9tUme5A$I2VDsRkQXfx)&BJ-~VDn(}VDn(}VDn(}VDsQA h?9V)$HxD)sHV-xrHV-xrHV=0Hq)q+des=$){Rg6}TU`JE literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan227-objects.json b/gen/layouts/FloorPlan227-objects.json new file mode 100644 index 000000000..f87968d27 --- /dev/null +++ b/gen/layouts/FloorPlan227-objects.json @@ -0,0 +1,28 @@ +[ + "FloorLamp", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Cabinet", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Shelf", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan227-openable.json b/gen/layouts/FloorPlan227-openable.json new file mode 100644 index 000000000..76136ed5f --- /dev/null +++ b/gen/layouts/FloorPlan227-openable.json @@ -0,0 +1,206 @@ +{ + "ArmChair|-01.01|+00.03|+02.08": [ + -1.75, + 2.5, + 90, + 30 + ], + "ArmChair|-01.58|+00.03|+03.30": [ + -2.0, + 2.75, + 0, + 30 + ], + "Cabinet|-01.53|+01.87|+00.33": [ + -1.0, + 1.0, + 180, + 0 + ], + "Cabinet|-01.98|+01.17|+05.03": [ + -2.25, + 4.5, + 0, + 30 + ], + "Cabinet|-02.02|+01.71|+00.32": [ + -1.5, + 1.0, + 180, + 0 + ], + "Cabinet|-02.47|+01.33|+05.03": [ + -2.75, + 4.5, + 0, + 0 + ], + "Cabinet|-03.70|+01.71|+05.03": [ + -4.0, + 4.5, + 0, + 0 + ], + "Cabinet|-04.18|+01.87|+05.03": [ + -4.5, + 4.5, + 0, + 0 + ], + "Cabinet|-05.37|+01.17|+05.03": [ + -5.75, + 4.5, + 0, + 30 + ], + "Cabinet|-05.85|+01.33|+05.03": [ + -6.25, + 4.5, + 0, + 0 + ], + "CoffeeTable|-02.67|+00.03|+02.00": [ + -2.0, + 1.5, + 270, + 30 + ], + "DiningTable|-05.82|+00.03|+02.56": [ + -4.75, + 2.0, + 270, + 30 + ], + "Drawer|-01.09|+00.23|+00.46": [ + -1.0, + 1.25, + 180, + 30 + ], + "Drawer|-02.68|+00.23|+00.46": [ + -2.75, + 1.25, + 180, + 30 + ], + "Drawer|-02.94|+00.51|+05.00": [ + -3.25, + 4.5, + 0, + 30 + ], + "Drawer|-02.94|+00.82|+05.00": [ + -3.0, + 4.5, + 0, + 30 + ], + "Drawer|-04.26|+00.23|+00.46": [ + -4.75, + 1.25, + 180, + 30 + ], + "Drawer|-06.33|+00.51|+05.00": [ + -6.0, + 4.5, + 0, + 30 + ], + "Drawer|-06.33|+00.82|+05.00": [ + -6.25, + 4.5, + 0, + 30 + ], + "GarbageCan|-06.85|+00.02|+00.26": [ + -6.25, + 0.75, + 180, + 30 + ], + "Shelf|-00.81|+01.69|+00.19": [ + -1.0, + 1.0, + 180, + 0 + ], + "Shelf|-01.04|+01.00|+00.18": [ + -0.5, + 1.0, + 180, + 0 + ], + "Shelf|-01.04|+01.32|+00.18": [ + -0.5, + 1.0, + 180, + 0 + ], + "Shelf|-01.78|+00.99|+00.18": [ + -1.25, + 1.0, + 180, + 0 + ], + "Shelf|-02.22|+00.45|+05.17": [ + -2.75, + 4.25, + 90, + 30 + ], + "Shelf|-02.67|+00.61|+00.27": [ + -2.0, + 1.0, + 180, + 30 + ], + "Shelf|-03.19|+01.15|+05.17": [ + -3.25, + 4.5, + 0, + 0 + ], + "Shelf|-03.94|+00.99|+05.17": [ + -3.75, + 4.25, + 0, + 0 + ], + "Shelf|-04.67|+01.00|+05.17": [ + -4.75, + 4.5, + 0, + 30 + ], + "Shelf|-04.67|+01.32|+05.17": [ + -4.75, + 4.5, + 0, + 0 + ], + "Shelf|-04.90|+01.69|+05.17": [ + -4.75, + 4.5, + 0, + -30 + ], + "Shelf|-05.61|+00.45|+05.17": [ + -5.0, + 4.25, + 270, + 30 + ], + "Shelf|-06.57|+01.15|+05.17": [ + -6.5, + 4.5, + 0, + 0 + ], + "Sofa|-03.33|+00.02|+03.63": [ + -3.25, + 3.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan228-layout.npy b/gen/layouts/FloorPlan228-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a07f8bf3aa03848dd6ebd588c90ecca0333f83c GIT binary patch literal 2576 zcmbW%F>6y%7zW^D2!{|tXk*>)b}MADQV05uX-GAKmFT4KL<%@pZ^_N$>o89Ki z`PJ@X`|tUi&FB60;rag4=6d_!<7cPO*WJm}b@#pd&oxiuS`GE{_I3R{3_b{61}}o= z!L#5TJPm%_eAn{G$MUg!EFa6q^09m@AIrz`-M4(sXXmr?+4<~zc77^pT+Ub>%@e4K~6kLBY@c%OprTYmfXVSQL1)`#_B zedeX+^!w#S%ftGzzMR8;eZAM0^<{loU)GoPWqny+)^}0Txb$WJSM2|am#rV051S9q z!u}j=KK7drn-7~0n-7~0n-7~0n-81MvZQgD51S9051S9056@eFo(1P%^ReH2*nHT0 z*nHT0*nHT0*nId&%Xd)HxQ>F&&wKM@eL08k>+8L~tS{@!`m(;PFYC+t@=?ooSkk!k jWBph@mXGCQ`B*-dkL6?eRv{nD!}72^EDy`W@~p~VyiFZK9KteKEjq; zrbv+@h3n1v3Qy@Y%a=)J{_}^u`T6?ot2giNlyBvGcfQ(uSa;9b?)k-8w`jYI%k|gw z^7H%4_4(@W>o1p|Hmlp$Hy@W@R=0lm`0VMTee!70{%HSmHDy?*SI58CFOGljCGUUz zyMI6SZ{qzv&pyvS&$~E}AH;dvIM4a)e0DxNpLcOSZ*Emp=!5ma`e1#qK3E^D z57r0Qn2+_r`e1$VA^PBbvOetVgY{ARGAw( zKg-YZv-~VS%g^$&{477q&(|>zn`hjYVfjATJZv5|51WU})$v?551WV0!{%Z0uzA=# zwLji#9ySk~ht0#I$j>F&Joe4Q=3(=&dDuK`o=KXA&BNwl^RVX!Ph%eT{9w-yuIc^b zKm+ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan229-objects.json b/gen/layouts/FloorPlan229-objects.json new file mode 100644 index 000000000..2aca56e1f --- /dev/null +++ b/gen/layouts/FloorPlan229-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Boots", + "Sofa", + "Statue", + "Pencil", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "WateringCan", + "CellPhone", + "Drawer", + "Desk", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan229-openable.json b/gen/layouts/FloorPlan229-openable.json new file mode 100644 index 000000000..27d4df17e --- /dev/null +++ b/gen/layouts/FloorPlan229-openable.json @@ -0,0 +1,68 @@ +{ + "ArmChair|-01.32|+00.03|+03.65": [ + -1.75, + 3.0, + 0, + 30 + ], + "CoffeeTable|-03.04|+00.00|+02.34": [ + -3.25, + 3.0, + 180, + 30 + ], + "Desk|-00.31|+00.03|+00.62": [ + -1.0, + 1.0, + 90, + 30 + ], + "Drawer|-05.50|+00.21|+02.13": [ + -5.25, + 1.5, + 0, + 30 + ], + "Drawer|-05.50|+00.21|+02.68": [ + -5.25, + 3.25, + 180, + 30 + ], + "Drawer|-05.50|+00.52|+02.13": [ + -5.25, + 1.5, + 0, + 30 + ], + "Drawer|-05.50|+00.52|+02.68": [ + -5.25, + 3.25, + 180, + 30 + ], + "Dresser|-05.70|+00.02|+02.40": [ + -5.25, + 1.5, + 0, + 30 + ], + "SideTable|-00.31|+00.02|+01.52": [ + -0.75, + 2.0, + 90, + 30 + ], + "SideTable|-05.57|+00.02|+00.29": [ + -5.0, + 0.75, + 270, + 30 + ], + "Sofa|-03.13|+00.03|+00.61": [ + -3.25, + 1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan23-layout.npy b/gen/layouts/FloorPlan23-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..9e63fce2cd289e0c50458690a443b21b3d1666b8 GIT binary patch literal 1648 zcmbW$u}T9$6a~;xL?np#3Db?jRslhSwVh&FAr+tv8;`erLVrgwOYacY}9=w}bV|)z7ilzEwZ# zXZ@_7Q$G)zN3MC;JnT7+t9k63ht0$0;h#m?T>KsU75o|Oeazu~*!!^eVg0P1^|OA~ z@4fZ2e3sAhSw746J<4bKET84Ge3tKbk;n2_9?N5Sa?Hzdm2Y1@%V+tXlh5wsxXQOL zpXIwx9=ng@>Up{5V|gr(<*~ev{@lxB=bN2x*2nr-AM0C&KGw(j*#DUQPuRI;=a8Kv MHb0x6&A(i%0CTJP2LJ#7 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan23-objects.json b/gen/layouts/FloorPlan23-objects.json new file mode 100644 index 000000000..f21beb23b --- /dev/null +++ b/gen/layouts/FloorPlan23-objects.json @@ -0,0 +1,47 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Blinds", + "Pencil", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "Pen", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Shelf", + "Chair", + "LightSwitch", + "Bottle", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan23-openable.json b/gen/layouts/FloorPlan23-openable.json new file mode 100644 index 000000000..99352e9a3 --- /dev/null +++ b/gen/layouts/FloorPlan23-openable.json @@ -0,0 +1,98 @@ +{ + "Cabinet|-00.30|+01.92|-02.50": [ + -1.0, + -2.75, + 90, + 0 + ], + "Cabinet|-00.33|+01.92|-03.39": [ + -1.0, + -2.75, + 180, + 0 + ], + "Cabinet|-00.58|+00.39|-01.80": [ + -1.25, + -2.25, + 0, + 30 + ], + "Cabinet|-00.58|+00.39|-02.20": [ + -1.5, + -2.75, + 0, + 30 + ], + "Cabinet|-00.58|+00.39|-03.40": [ + -1.75, + -3.0, + 90, + 30 + ], + "Cabinet|-00.88|+00.39|-03.42": [ + -1.25, + -2.5, + 90, + 30 + ], + "Cabinet|-00.88|+02.14|-03.69": [ + -1.5, + -2.75, + 180, + 0 + ], + "Cabinet|-01.76|+02.14|-03.69": [ + -1.25, + -2.75, + 180, + 0 + ], + "CounterTop|-00.30|+00.95|-02.79": [ + -1.0, + -3.0, + 90, + 30 + ], + "DiningTable|-02.43|+00.00|-01.69": [ + -1.75, + -1.5, + 270, + 30 + ], + "Fridge|-00.33|+00.00|-00.77": [ + -1.25, + -0.75, + 90, + 0 + ], + "GarbageCan|-01.94|00.00|-03.76": [ + -2.25, + -3.5, + 90, + 30 + ], + "Microwave|-01.32|+01.52|-03.80": [ + -1.25, + -3.0, + 180, + -30 + ], + "Shelf|-02.43|+00.15|-01.69": [ + -3.25, + -0.75, + 90, + 30 + ], + "Shelf|-02.43|+00.52|-01.69": [ + -3.75, + -1.75, + 90, + 0 + ], + "Sink|-00.35|+00.91|-02.01|SinkBasin": [ + -1.0, + -2.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan230-layout.npy b/gen/layouts/FloorPlan230-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..35ea786ab0b1dda667f3723868c36a81bc2c172f GIT binary patch literal 6448 zcmbW(y=oL;6b9hWunfx*mfigMubXNWQYnIpkg4nx8w)E5W`l(o*@%q@xd$)Ey_A$G zQ>54;h4I_-OmRx52~Q@O^PYDzGx`1Y{hN0mZj>M8=k#!P@@YPOIhnpXdOqEoOplJ| z-{%KkKOWByXaBzc`rymS?E3pBpAWvxuKnogi)VY2Cy)0gzb5~A3`#w=7pt#l`>U^8 z$(zX=$>ZepINU;QcdkZ+lMnS7CKzw`aob?nFXWBalFcog|~m~4ON?a%h- zCjGwsonK4mOR|3ayna|etRL3TMe2w3!}?+UuzpxStRL17>xcEj`eFUBepo-OAHIyg z7uFB!=Q8!f`eFUBepo-OAC{lxXZcxvzKDHT{$N4Sw5DJmU_s`o+m6X%ggfeGV-##EHBH;@~x$OEFa6q^09m@ zAIrz`v3#sgmbcfIdgznoWqDa%mY3yad0AeTm*r)7o0OO3WqDa%mY3yad0AeTm*r)7 z`zbHW%kr|kEHBH;^0K@vFU!mF4pLs0m*r)7Szh+M<>8{#gS~IKN#}dXCHX4uU%#&( z)(`84^~3sM{j9g89_|;`59^2Z!}?+U@G$n{^y!1#`ec2M z+ENdFvOZa#tWVY_>y!1#`s6|M#rotXo!6)H`ec2wK3SivPu3^vll3=lOFi_*TalOb z$NFRavHUDQ%g^$&{478Fdtm!)qvY#+7{+lTGL_F?<5eb_#1AGQz6yBYh)%kr|k zEHBH;^0K@vFU!mFvbKDt>e1>*gQ6m&13V}Jhm^Je>=@*^VxhhpUr3U*?cztPMXi=v-xa3o6qL6 z`E35(G@s39^VxhhpUr3U+5CHHKAX?xv-xa3o6qL6`S;U&HlNLB^VxhhpUr3UAEfzg zKAX?xv-xa3o6qJyO!L`%HlIDe*z=1$zu5DOn?dB*l* z`?3AFw^&`5{r|__-|YR(-rwx~&Gu#cvVA%BJ>}T9bL`tW_U#<|c8+~I$3C57pU$yQ e=h&xn?9y!1l+x`WazMf(L literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan230-objects.json b/gen/layouts/FloorPlan230-objects.json new file mode 100644 index 000000000..7ddc799b5 --- /dev/null +++ b/gen/layouts/FloorPlan230-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Plate", + "Candle", + "Pillow", + "Box", + "Boots", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "DeskLamp", + "Mirror", + "Painting", + "RoomDecor", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan230-openable.json b/gen/layouts/FloorPlan230-openable.json new file mode 100644 index 000000000..b866dc6e2 --- /dev/null +++ b/gen/layouts/FloorPlan230-openable.json @@ -0,0 +1,56 @@ +{ + "ArmChair|-02.69|+00.01|+04.62": [ + -3.0, + 5.25, + 180, + 30 + ], + "ArmChair|-03.66|+00.01|+04.56": [ + -4.25, + 5.0, + 90, + 30 + ], + "CoffeeTable|-03.13|+00.02|+08.53": [ + -3.5, + 7.75, + 0, + 30 + ], + "CoffeeTable|-03.24|+00.01|+06.60": [ + -2.5, + 6.5, + 270, + 30 + ], + "DiningTable|-02.90|+00.01|+02.23": [ + -1.5, + 2.25, + 270, + 30 + ], + "GarbageCan|-05.71|+00.01|+00.30": [ + -5.25, + 0.75, + 180, + 30 + ], + "SideTable|-00.40|+00.01|+00.36": [ + -1.0, + 0.75, + 90, + 30 + ], + "SideTable|-00.53|+00.01|+08.52": [ + -1.0, + 8.0, + 90, + 30 + ], + "Sofa|-01.71|+00.00|+06.45": [ + -2.5, + 6.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan24-layout.npy b/gen/layouts/FloorPlan24-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..33ebd8c0cd3be20377e952e1aa38d20c79148755 GIT binary patch literal 1152 zcmbW!JxT*X7=YnXL?q-8)2+f*A|fJWD?7!;!b%pi!9tAeij8;*59Aecgp`&R7AaB~ zoq3um-DY{_XTO)^{qp+a>Simvgx6}?4R?KY8mqI}Nma*cHt(PN_VIS!PrKjs^Y&rr zHtWNE`_yf`e|%KO!-G1$#s5B|@b|1g(t9;Y??vIX8iIZ2*ZKS^pJ(^keRe-IX~%v3 z&fnv&!k>kgh0S;0d^Uf(n9t_3`D{L$&*pQ;4=*NZf%WV(Y2EL^dRPzZVLhye)07Zc z59`@2dRPzZVLhye^{^h+!+Q3L9@fKpSP$!AJ*<$BQ7Y~){@?_Lfs#Ug7fmB&xZYH@L3zO>K`8vr<-JO@`0x@fb^X@$_#QJC av3);t%zWt0G5^QhA9?pN_c8DFJ&wQsFq4rjK=gk>!`;^SsFN@uYsMhc6G4dQ|;AzZyPI ztM&8g)9|%g`{?Yn$WD%n>@)lC>7~u-&YF8ZXzosM3SND0&o6@)!SmpsVEv21c0cQ9 z{j8t$^Ste2{j7f(`dL5gXZ@_7^|OA~zY6`VpI7bs@G@Ax-}SS8_PtZt{Qvq`AM0a% ztdI4v{hhYYezu?OXZzWHw!d4Z&9R^DXZtzLn%r*L-102X@+`j>@+{BtEZ+-xmS=gE i-w%0~XLZgFumnbwLnDT7n^*f&+1d9bpoQKp+r|tWWSu zYQDU`-)p<#s`Y?UoK_8|M(9|be+wVRhw)*2l{SBn`(b<-ALbn@{QxH- BbR7Ty literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan27-objects.json b/gen/layouts/FloorPlan27-objects.json new file mode 100644 index 000000000..3b62eb5e3 --- /dev/null +++ b/gen/layouts/FloorPlan27-objects.json @@ -0,0 +1,43 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Curtains", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan27-openable.json b/gen/layouts/FloorPlan27-openable.json new file mode 100644 index 000000000..9dbe15133 --- /dev/null +++ b/gen/layouts/FloorPlan27-openable.json @@ -0,0 +1,128 @@ +{ + "Cabinet|+00.13|+00.39|+01.77": [ + 1.0, + 1.5, + 0, + 30 + ], + "Cabinet|+00.35|+00.39|+02.36": [ + 1.0, + 1.75, + 0, + 30 + ], + "Cabinet|+01.51|+00.39|+02.36": [ + 0.5, + 1.5, + 90, + 30 + ], + "Cabinet|+01.76|+00.39|+00.87": [ + 1.0, + 0.0, + 0, + 30 + ], + "Cabinet|+01.76|+00.39|+02.35": [ + 1.0, + 1.5, + 0, + 30 + ], + "Cabinet|+01.97|+02.11|+02.62": [ + 1.25, + 2.0, + 0, + 0 + ], + "Cabinet|+02.04|+01.81|+00.28": [ + 1.25, + 0.75, + 90, + 0 + ], + "Cabinet|+02.04|+01.81|+00.87": [ + 1.25, + 0.5, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+00.89": [ + 1.25, + 0.75, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+01.77": [ + 1.25, + 1.0, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+01.81": [ + 1.5, + 2.0, + 90, + -30 + ], + "Cabinet|+02.04|+02.11|+02.62": [ + 1.5, + 2.0, + 90, + -30 + ], + "CounterTop|+02.06|+00.97|+00.58": [ + 1.25, + 0.5, + 90, + 0 + ], + "DiningTable|-00.15|00.00|+01.07": [ + 0.5, + 1.0, + 270, + 30 + ], + "Drawer|+01.91|+00.77|+02.06": [ + 1.25, + 1.75, + 0, + 30 + ], + "Drawer|+02.17|+00.77|+00.58": [ + 1.25, + 1.0, + 180, + 30 + ], + "Drawer|-00.02|+00.77|+02.06": [ + 0.75, + 1.5, + 0, + 30 + ], + "Fridge|+02.10|+00.00|-00.28": [ + 1.0, + -0.25, + 90, + 30 + ], + "GarbageCan|-00.31|00.00|-00.81": [ + 0.25, + -0.25, + 180, + 30 + ], + "Microwave|-00.31|+00.93|+02.08": [ + 0.5, + 1.75, + 270, + 0 + ], + "Sink|+00.94|+00.94|+02.65|SinkBasin": [ + 1.0, + 2.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan28-layout.npy b/gen/layouts/FloorPlan28-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7b6b1a810345427619241bcd42635ed7ebe51d2a GIT binary patch literal 1712 zcmbW%F-ikL6oBDTBuEg?Fx@C@Wo5+LPO-7DlErLDAx3t^Mm&WFN{*7!GDQjt3uD}` z@Re>ee3Rt8KLqlAb#r-ryOUnhYZ*7)eOu0QIiH-CDwoNueQxW=yIDJKe(o>ohpyS& zchmZ*+4yKQs`ANkmEZDzpJCcQdyC(5zdv__Q}EaP@B2T4*TJh``v(17``A9VkL_do z*gkgJ8&CV)+t2p1{cJzm&xeb&ee5|19tOwXVGv$7*SvV@cdwuIvwqgk`pwnP`dL5g zXZ>ss$5X$1{j8t$vwm~*vwqgk`dL5gXL~uG`rYei{jA^T^s|1}&-z(E>u3F}gX5{+ zy?)m3efn8H>u3F}pY^kT*3Y^)p62@==Ck>1KAX?xv-uzW|DyS9KAX?xv-xcPGR$Z5 M*?cyi&0o&H0c$G?VE_OC literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan28-objects.json b/gen/layouts/FloorPlan28-objects.json new file mode 100644 index 000000000..7abe48eea --- /dev/null +++ b/gen/layouts/FloorPlan28-objects.json @@ -0,0 +1,43 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Blinds", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "SideTable", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Shelf", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan28-openable.json b/gen/layouts/FloorPlan28-openable.json new file mode 100644 index 000000000..a56b16123 --- /dev/null +++ b/gen/layouts/FloorPlan28-openable.json @@ -0,0 +1,122 @@ +{ + "Cabinet|-00.33|+01.89|-02.51": [ + -1.0, + -2.75, + 90, + 0 + ], + "Cabinet|-00.34|+01.89|-01.29": [ + -1.0, + -1.75, + 90, + 0 + ], + "Cabinet|-00.35|+01.89|-03.29": [ + -1.25, + -3.0, + 90, + 0 + ], + "Cabinet|-00.63|+00.39|-01.61": [ + -1.5, + -2.0, + 0, + 30 + ], + "Cabinet|-00.63|+00.39|-02.51": [ + -1.25, + -3.0, + 90, + 30 + ], + "Cabinet|-00.63|+00.39|-03.01": [ + -1.25, + -2.5, + 90, + 30 + ], + "Cabinet|-01.01|+00.39|-03.37": [ + -1.75, + -2.5, + 90, + 30 + ], + "CounterTop|-00.33|+00.98|-01.45": [ + -1.0, + -1.75, + 90, + 30 + ], + "CounterTop|-01.94|+00.98|-03.67": [ + -1.0, + -3.0, + 90, + 30 + ], + "DiningTable|-03.22|00.00|-00.45": [ + -2.5, + -0.5, + 270, + 30 + ], + "DiningTable|-03.59|+00.00|-03.26": [ + -3.75, + -2.25, + 180, + 30 + ], + "Drawer|-00.48|+00.78|-02.74": [ + -1.5, + -2.25, + 90, + 0 + ], + "Drawer|-00.50|+00.78|-01.45": [ + -1.25, + -1.0, + 180, + 30 + ], + "Fridge|-00.31|+00.00|-00.65": [ + -1.25, + -0.75, + 90, + 30 + ], + "GarbageCan|-02.42|-00.03|-03.54": [ + -1.75, + -2.75, + 270, + 30 + ], + "Microwave|-00.22|+01.47|-02.06": [ + -1.0, + -2.0, + 90, + -30 + ], + "Shelf|-04.03|+00.26|-00.30": [ + -3.5, + -1.5, + 270, + 30 + ], + "Shelf|-04.03|+00.49|-00.30": [ + -3.5, + -1.25, + 270, + 30 + ], + "SideTable|-04.03|+00.00|-00.30": [ + -3.75, + -1.5, + 0, + 0 + ], + "Sink|-00.60|+00.93|-03.39|SinkBasin": [ + -1.0, + -3.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan29-layout.npy b/gen/layouts/FloorPlan29-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3ae68148a7960946b2d57b4b5964ef738dbcc3ce GIT binary patch literal 1168 zcmbWzu}Z{16ouij^(oSgLMlNK5!}j7v9Yj{;AXK9R}!%ipTY;)SI8r5xn+tJ78b5% zzJLQZPILM1J#){QdB42AxVqU1FX1)L>-MgRCq+D69LKVVi)HiNRFAjIW?p~y&#Q;F z-uB!3>Z#uH-qB%M9PF3HTk+qs8-C7uHP%h4UB=@yglT^ETffeDlX0K(YP_HO;=IbE zFAwh0ek>1`2g`$p?EXi_eab7x^be_Tk9l6@o%(4%mKV#5<;6pGUtaS*<>D(ZmKW3e zM|w<;>E))!^qAhe=rKL+QvTtOcgj7zJLxcAY%lhom=EUvnfCI-{sHsD{4hVv5A((R V!;EvPiTRuJ$NVvW%pda)voGD%xz_*y literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan29-objects.json b/gen/layouts/FloorPlan29-objects.json new file mode 100644 index 000000000..017eb7373 --- /dev/null +++ b/gen/layouts/FloorPlan29-objects.json @@ -0,0 +1,39 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan29-openable.json b/gen/layouts/FloorPlan29-openable.json new file mode 100644 index 000000000..f3cc8c38c --- /dev/null +++ b/gen/layouts/FloorPlan29-openable.json @@ -0,0 +1,80 @@ +{ + "Cabinet|+01.32|+01.96|-01.31": [ + 1.0, + -0.75, + 180, + 0 + ], + "Cabinet|+01.34|+00.59|-01.11": [ + 0.75, + -0.75, + 180, + 30 + ], + "Cabinet|+01.99|+00.59|-01.11": [ + 1.25, + -0.5, + 90, + 30 + ], + "Cabinet|+01.99|+01.40|-01.11": [ + 1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-00.85|+00.59|-01.11": [ + -0.25, + -0.75, + 180, + 30 + ], + "Cabinet|-00.87|+01.96|-01.31": [ + -0.5, + -0.75, + 180, + 0 + ], + "Cabinet|-01.53|+00.59|-01.11": [ + -0.75, + -0.5, + 180, + 30 + ], + "CounterTop|+00.20|+01.08|-01.51": [ + 0.25, + -0.75, + 180, + 30 + ], + "CounterTop|+00.97|+01.08|+00.42": [ + 0.5, + -0.25, + 0, + 30 + ], + "Fridge|-01.29|+00.02|+01.83": [ + -0.25, + 1.75, + 270, + 30 + ], + "GarbageCan|+01.86|-00.02|+02.39": [ + 1.5, + 2.0, + 0, + 30 + ], + "Microwave|-01.19|+01.62|-01.28": [ + -1.0, + -0.5, + 180, + 0 + ], + "Sink|+00.93|+00.94|+00.32|SinkBasin": [ + 1.5, + -0.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan3-layout.npy b/gen/layouts/FloorPlan3-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e5a612c999fc9c14ac13d0d68e8f8c54b1fb94ce GIT binary patch literal 1856 zcmbWzu};EJ6oBC?qfgPTnlPvnF(xv(XZ zABktQ%guL6|I_k$b9a4ve~{kNdpWM=k9B!oloyjh*)Ph;tbVOW(}!6-u72iMqvv_G zo6ny{FV)URrzeAcadzAdsa0GPnuuo=VB{dMWf+kM&rO^|pDh z_hUWQV?EZ}gdXd$9_z8*I`mkN^;nPfoW7U!xXF82kDWU4)HBy(J#H?$3G2rW$5Y>2 zpY>VabM~^|aXj_+^Zfq23|qHbpY>Uv^;y5o|BpWFvp(x{lRK=x4t>_=X3-T{pWA$Y6MC%2 mdaTEK+t6b@)?+=^OT+Gt|C9AtkM&ru7kaG6dYtmr8-4>qmmo+0 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan3-objects.json b/gen/layouts/FloorPlan3-objects.json new file mode 100644 index 000000000..0f770854d --- /dev/null +++ b/gen/layouts/FloorPlan3-objects.json @@ -0,0 +1,45 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "SideTable", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan3-openable.json b/gen/layouts/FloorPlan3-openable.json new file mode 100644 index 000000000..1d586c647 --- /dev/null +++ b/gen/layouts/FloorPlan3-openable.json @@ -0,0 +1,110 @@ +{ + "Cabinet|+00.58|+00.78|-02.05": [ + -0.25, + -1.25, + 180, + 30 + ], + "Cabinet|-01.46|+00.78|+00.47": [ + -0.75, + 1.0, + 180, + 30 + ], + "Cabinet|-01.46|+00.78|+01.31": [ + -0.75, + 0.75, + 0, + 30 + ], + "Cabinet|-01.46|+00.78|-02.00": [ + -0.75, + -1.5, + 180, + 30 + ], + "CounterTop|-01.81|+01.36|+01.18": [ + -1.0, + 1.5, + 270, + 30 + ], + "Drawer|+00.65|+00.60|+00.68": [ + 0.0, + 0.25, + 0, + 30 + ], + "Drawer|+00.65|+00.60|+01.02": [ + -0.25, + 0.5, + 0, + 30 + ], + "Drawer|+00.65|+00.84|+00.68": [ + 0.0, + 0.25, + 0, + 30 + ], + "Drawer|+00.65|+00.84|+01.02": [ + 0.0, + 1.5, + 180, + 30 + ], + "Drawer|+00.65|+01.06|+00.68": [ + -0.25, + 0.0, + 90, + 0 + ], + "Drawer|+00.65|+01.06|+01.02": [ + -0.25, + 1.75, + 90, + 0 + ], + "Drawer|-01.61|+00.68|-00.43": [ + -1.0, + -1.0, + 0, + 30 + ], + "Drawer|-01.61|+00.68|-01.22": [ + -1.0, + -1.75, + 0, + 30 + ], + "Fridge|+01.01|+00.23|+01.92": [ + 0.0, + 2.0, + 90, + 0 + ], + "GarbageCan|-01.63|+00.21|+02.19": [ + -0.75, + 1.5, + 0, + 30 + ], + "Microwave|+00.99|+01.31|-02.16": [ + 0.0, + -1.75, + 90, + 0 + ], + "SideTable|+00.98|+00.21|+00.87": [ + 0.5, + 0.0, + 0, + 30 + ], + "Sink|-01.99|+01.14|-00.98|SinkBasin": [ + -0.25, + 0.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan30-layout.npy b/gen/layouts/FloorPlan30-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..4dff912e9ee932067c7ef80e65180eb5cb8d8469 GIT binary patch literal 1296 zcmbW$u}Z^07zgk(h=Wg&Eef4}I^%e369XodD(80m# z-7ny|ndSI>x%|KH()8o%=JNV>C%lHYYTV53+v=>W&L^kUpsXg-_N5&?-A&tZ^Ig9f zJJLR!FmdAV9{%#(AF5hib2;8N9OQb)1NuXEXc) D)dQw{ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan30-objects.json b/gen/layouts/FloorPlan30-objects.json new file mode 100644 index 000000000..03562e5d5 --- /dev/null +++ b/gen/layouts/FloorPlan30-objects.json @@ -0,0 +1,45 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "PepperShaker", + "Pan", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "CellPhone", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Mirror", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "Bottle", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan30-openable.json b/gen/layouts/FloorPlan30-openable.json new file mode 100644 index 000000000..779e34a00 --- /dev/null +++ b/gen/layouts/FloorPlan30-openable.json @@ -0,0 +1,218 @@ +{ + "Cabinet|+00.14|+01.67|-01.56": [ + 0.5, + -0.75, + 180, + -30 + ], + "Cabinet|+00.62|+01.87|-01.26": [ + 0.25, + -0.5, + 180, + 0 + ], + "Cabinet|+01.40|+01.87|-01.26": [ + 0.5, + -0.75, + 90, + 0 + ], + "Cabinet|+02.82|+01.77|-01.05": [ + 2.25, + -1.25, + 90, + -30 + ], + "Cabinet|+02.85|+00.42|+00.41": [ + 2.0, + 0.25, + 0, + 30 + ], + "Cabinet|+02.85|+00.42|-00.61": [ + 2.0, + -1.0, + 0, + 30 + ], + "Cabinet|+02.85|+00.42|-00.96": [ + 2.0, + -1.25, + 90, + 30 + ], + "Cabinet|+03.07|+01.67|-00.71": [ + 2.25, + -1.0, + 90, + -30 + ], + "Cabinet|-00.19|+01.67|-01.34": [ + 0.25, + -0.75, + 180, + 0 + ], + "Cabinet|-00.92|+01.67|-00.62": [ + -0.25, + -0.5, + 270, + 0 + ], + "CounterTop|+00.13|+00.94|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "CounterTop|+01.21|+00.94|+00.46": [ + 2.0, + 0.5, + 270, + 30 + ], + "CounterTop|+03.11|+00.94|+00.02": [ + 2.5, + 0.0, + 90, + 30 + ], + "CounterTop|-01.01|+00.94|-00.04": [ + -0.25, + 0.0, + 270, + 30 + ], + "Drawer|+00.38|+00.19|-01.51": [ + -0.25, + -0.25, + 90, + 30 + ], + "Drawer|+00.38|+00.38|-01.51": [ + 0.0, + -0.5, + 90, + 30 + ], + "Drawer|+00.38|+00.57|-01.51": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.38|+00.77|-01.51": [ + 0.0, + -0.75, + 90, + 30 + ], + "Drawer|+03.02|+00.77|+00.70": [ + 2.25, + 1.25, + 180, + 30 + ], + "Drawer|+03.02|+00.77|-00.41": [ + 2.25, + 0.0, + 180, + 30 + ], + "Drawer|+03.02|+00.77|-00.78": [ + 2.25, + -0.5, + 180, + 30 + ], + "Drawer|-00.86|+00.19|+00.66": [ + 0.0, + 1.5, + 270, + 30 + ], + "Drawer|-00.86|+00.19|+01.43": [ + 0.0, + 0.75, + 270, + 30 + ], + "Drawer|-00.86|+00.19|-00.10": [ + 0.0, + 0.75, + 270, + 30 + ], + "Drawer|-00.86|+00.39|+00.66": [ + 0.0, + 0.0, + 0, + 30 + ], + "Drawer|-00.86|+00.39|+01.43": [ + 0.0, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.39|-00.10": [ + 0.0, + -0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.58|+00.66": [ + -0.25, + 1.25, + 180, + 30 + ], + "Drawer|-00.86|+00.58|+01.43": [ + -0.25, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.58|-00.10": [ + -0.25, + 0.5, + 180, + 30 + ], + "Drawer|-00.86|+00.77|+00.66": [ + -0.25, + 1.25, + 180, + 30 + ], + "Drawer|-00.86|+00.77|+01.43": [ + -0.25, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.77|-00.10": [ + -0.25, + 0.75, + 180, + 30 + ], + "Fridge|+01.01|+00.03|-01.47": [ + 0.5, + -0.75, + 180, + 30 + ], + "Microwave|-01.03|+00.87|+01.43": [ + -0.25, + 1.25, + 270, + 0 + ], + "Sink|+03.08|+00.89|+00.09|SinkBasin": [ + 2.5, + 0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan301-layout.npy b/gen/layouts/FloorPlan301-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3db3b80bbcf3897bfc7704cfaef557cb0288243f GIT binary patch literal 1392 zcmbW#uTH~I7(nq$gW@Ub3P}})KOtEa4uV0TNW;1y7Dn1-hVT?T5U;RDn4GMrKp+_O z{z$lzns4XpUC&9kx9i)ho4dWR3NOX9=^onRJTES0r$w0;vqigX>!*V?=`Q@ZoSkvnJJG}FO**9a~&(47xre;%b~ED`TDE$T$1+Id(g)KA(+ATBOKs`(+6iVq+^gII%s$LM%s$LMES3G> M`#pT#53}DT9}otFVE_OC literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan302-objects.json b/gen/layouts/FloorPlan302-objects.json new file mode 100644 index 000000000..83f093816 --- /dev/null +++ b/gen/layouts/FloorPlan302-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Safe", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan302-openable.json b/gen/layouts/FloorPlan302-openable.json new file mode 100644 index 000000000..17003e4fb --- /dev/null +++ b/gen/layouts/FloorPlan302-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|+01.24|+00.00|-00.90": [ + 0.25, + -0.75, + 90, + 30 + ], + "Desk|-00.79|+00.00|-01.03": [ + -0.5, + -0.75, + 270, + 30 + ], + "Drawer|+00.30|+00.17|+01.16": [ + 1.0, + 0.75, + 270, + 30 + ], + "Drawer|+00.30|+00.46|+01.16": [ + -0.25, + 0.75, + 90, + 30 + ], + "Drawer|+00.42|+00.53|-01.55": [ + 0.0, + -1.25, + 90, + 30 + ], + "Safe|+01.62|+00.00|+00.45": [ + 0.75, + 0.5, + 90, + 30 + ], + "Shelf|-00.47|+00.83|-02.04": [ + 0.0, + -0.75, + 180, + 30 + ], + "Shelf|-01.29|+01.45|-00.60": [ + -0.5, + -0.5, + 270, + 30 + ], + "Shelf|-01.29|+01.45|-01.34": [ + -0.25, + -1.0, + 270, + 30 + ], + "Shelf|-01.29|+01.81|-00.60": [ + -0.5, + -0.75, + 270, + 0 + ], + "Shelf|-01.29|+01.81|-01.34": [ + -0.5, + -0.75, + 270, + 0 + ], + "SideTable|+00.31|+00.00|+01.23": [ + 0.75, + 0.75, + 0, + 30 + ], + "SideTable|+00.41|+00.00|-01.68": [ + -0.25, + -1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan303-layout.npy b/gen/layouts/FloorPlan303-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..486b0356b0c3ee8b46af7af8a9dd36b5de09ae91 GIT binary patch literal 1168 zcmbW#p-#g<9Khkj@)UK2q>2PW2+14{f7_p$qU$mbf@!K>gtIKSOwe?OaM*!yL@JcQ@RV9)7_qdxO}?qhwd zkM*%W*2ntT`((Ybi{q%*yk6GJdRZ^)WxcGI{omO4h+P~dF;HDz5#xW&Y}PS literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan303-objects.json b/gen/layouts/FloorPlan303-objects.json new file mode 100644 index 000000000..50bca7fac --- /dev/null +++ b/gen/layouts/FloorPlan303-objects.json @@ -0,0 +1,35 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "GarbageBag", + "Window", + "GarbageCan", + "Poster", + "Pen", + "Cloth", + "CreditCard", + "Book", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Vase", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan303-openable.json b/gen/layouts/FloorPlan303-openable.json new file mode 100644 index 000000000..8704b6b03 --- /dev/null +++ b/gen/layouts/FloorPlan303-openable.json @@ -0,0 +1,122 @@ +{ + "Bed|-01.05|+00.00|-01.85": [ + -1.0, + -1.0, + 180, + 30 + ], + "Desk|-01.71|+00.00|-00.37": [ + -1.0, + -0.5, + 270, + 30 + ], + "Drawer|-01.79|+00.10|-01.14": [ + -0.5, + -0.5, + 180, + 30 + ], + "Drawer|-01.79|+00.25|-01.14": [ + -0.75, + -0.75, + 180, + 30 + ], + "Drawer|-01.79|+00.39|-01.14": [ + -1.0, + -0.75, + 180, + 30 + ], + "Shelf|+01.31|+00.97|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.31|+01.17|-02.30": [ + 1.25, + -1.75, + 180, + 0 + ], + "Shelf|+01.31|+01.37|-02.30": [ + 1.25, + -1.75, + 180, + -30 + ], + "Shelf|+01.31|+01.57|-02.30": [ + 1.25, + -1.75, + 180, + 30 + ], + "Shelf|+01.32|+00.16|-02.30": [ + 0.75, + -1.25, + 90, + 30 + ], + "Shelf|+01.32|+00.46|-02.30": [ + 1.75, + -1.5, + 270, + 30 + ], + "Shelf|+01.59|+00.61|-02.31": [ + 1.25, + -1.75, + 180, + 30 + ], + "Shelf|+01.84|+00.97|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.84|+01.17|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.84|+01.37|-02.30": [ + 1.75, + -1.5, + 180, + -30 + ], + "Shelf|+01.84|+01.57|-02.30": [ + 1.75, + -1.5, + 180, + 30 + ], + "Shelf|+01.85|+00.15|-02.29": [ + 1.25, + -1.25, + 90, + 30 + ], + "Shelf|+01.85|+00.45|-02.30": [ + 1.25, + -1.5, + 90, + 30 + ], + "SideTable|+00.44|+00.04|-02.65": [ + 0.5, + -2.0, + 180, + 30 + ], + "SideTable|-01.82|+00.00|-01.14": [ + -1.0, + -0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan304-layout.npy b/gen/layouts/FloorPlan304-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d6e9934a5c069b8d62bd8481899144452732f6d5 GIT binary patch literal 1808 zcmbW#p-#hK6o%n4$yL-9k_jLoA%tX8I0y!TA`9z+AdGYbL%0eqXt&Tyn4GMbKp+_O zJQGJUbMl_Q{ob$bKCf@DZtnJqx8l8;){BRxIxnk>*;zF#tJ%DHZ6?q6^JZHA?k^`# zi+a0XJWgKfEgu{ooes;B!(sVR{`0qA{QcTdKf7f=SBW>VU&nMEZqs?6QWU%M$iwpS zI-PfkH<_2wGp0VPV7WL?eeLzd-Urqf>x=cp`tCS-@#>3Rhx62Lw;%NztRL17>xVb# zetVugy$^dn%!m0fALh%sI8Q!%KHPbpn0(IpmHr^ZN$8vF={Pz6z{FooN>AUee=f^xaPyR3ei)C-b{Foo}V}8t!`7!@@ s@?(C?kNGh_=EwZFjpr@KOfiG`obzEm%!m1~yg}s4!}72^EN?LW0Vy~K!2kdN literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan304-objects.json b/gen/layouts/FloorPlan304-objects.json new file mode 100644 index 000000000..3aed39397 --- /dev/null +++ b/gen/layouts/FloorPlan304-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "LaundryHamper", + "BasketBall", + "Pillow", + "Box", + "Statue", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Mug", + "Bed", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan304-openable.json b/gen/layouts/FloorPlan304-openable.json new file mode 100644 index 000000000..74d9722a3 --- /dev/null +++ b/gen/layouts/FloorPlan304-openable.json @@ -0,0 +1,26 @@ +{ + "Bed|-01.30|+01.94|+01.44": [ + -0.25, + 1.75, + 270, + 0 + ], + "Desk|-00.99|+00.01|-01.41": [ + -1.0, + -0.75, + 180, + 30 + ], + "Drawer|-01.41|+00.23|-01.30": [ + -0.75, + -0.5, + 270, + 30 + ], + "Shelf|+00.00|+00.01|+00.04": [ + -1.0, + -0.75, + 180, + -30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan305-layout.npy b/gen/layouts/FloorPlan305-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0df7e536cd06e4bcfb2e6140507b7d48aca555e5 GIT binary patch literal 1472 zcmbW#u}Z^G6o>J+`V`rskVzbh2;JNi7Y8Q^HpM}#B;r!~6h2U2A&=0pV}=YJt>*p$ zp3y9a@7#0#UvHDIyNBER$CKgH}Id&}O7Q8j(2i}Sp=7@rnpUW_O8Ydw6vpVXu3XMQ<+ znpT_n^l|u7ZG3okQs&1;W&V->_d3XauVueo*RyS}lIQ7ule`G_zWbhEhUeMyojv!* zIuG;qlv%b&bNjLLvHd!GFMQWNakXDJ@3#}SAKQxf$f4>*J8@w01AMAI| z(&cwx=j6Ehea-cp&SN-Nq>Sq0{pY^kT*3bG`KkH}x-8pA%A?s)T cte?B@rcQIKe%8Oe&5!wsO!Xi;`m*7-#35%uM)2l%lChX z`JYkc<5jxn*FdxhZ59z)AsP=>T;6A)DAKb@$ z%m?$qs@z=V>-Uk5D7bVe%@vRTBnrGR6cZH;s#flOa;#K*SW|V!R432rr?Rz{uF40|SFd z&(nl6+U4Z^{+##MhVXs&aC`rF6h6XdJ}DN@Wqy_A*VD_qpXJke`Cg7+pXTMH_^aQH zXNzK2U%ZUpiXER0&IkSM;;f&2W&eCm!v0we+jFyQ&vn98Ue(@``+WL*>%@ooFdyc_e3%dOtr8#R!+e+z^I<+*@x+tAs}I`>=EwY) zA2-Q9zrK?xB93^W!R+=hqL>?>qBj{~K5yT*v#dJXjtq508?#FKP z?bGe$QpNeD}Yn~#@*>$zpU>AroaeshVb8;!hdmE_9`-z3ykh5Y6*t27$q&h6@{~L$ z>*qQ3<2KG^{a8Qt9GtKExvwAV$NI5;tRF|M!uqj(tRL&g`tcn7SU=CDAM3~Zv3{%{ zJBRaCKlk-x{a8QNkM(2ySU=W}^<({5Ki1E4=*Rl8eykts$NI5zIbZd2Uq9B5^<({b zh@ThMkM-j*eO^EB>&N=ptsm>h`muhjAM3~Zu^pVR`nj(k4|lZ~>&HX%VEtG>9@FQi zWc_?zKRfkf{a8QNkM(2ySU=W}?c#jZ&;23#v3{%{>&N=Beykts$NJf&AM3~Zv3{%{ z>&N=Beyktc$@yx(j`p+tY(Lx2_OtzLKikh^d_UQKwx8|yeYcCC;Kd1d{Kikjtv;BOCJ#0VQ&-SzZY(Lw7Nc-7- zwx8{1`}q+2c}}+9`}VW_Y(Lvyx^jB?{bl>vezu?OXZv}M{cJzm&-SzZJfyEzpW^s$ zSN}I$#htLfTi*9~fXDRtDOs;3zMfv(_T}_yx_Vvo_1biC?c*BOs|oAHda+)t7wg4( zv0hx_#d@(`tQYIW`YgI~dg;S$U+=R%?B|I~`n*2g*N63CeOMpXhxOsQwiMQf^Q~l>+rHjseYi>Qmt=i>ULV$n^xcEjo787a zu?sv+$+BI2Hf6AVu=#ih_sv%qhcq|FKIHjzuM2g4cl9(M^Nab#{Ngd_`HjACjQq-X z$uH&?cWEBx7xRnx#r)#G{+Ta(Vmch7{p~@I=`lT~w>Lee$Ml%K3;%-YF+CpB`+HaO RF+HZo^!|Y!(_{L6_67EG(ZT=# literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan310-objects.json b/gen/layouts/FloorPlan310-objects.json new file mode 100644 index 000000000..abcb8f2a2 --- /dev/null +++ b/gen/layouts/FloorPlan310-objects.json @@ -0,0 +1,31 @@ +[ + "BaseballBat", + "AlarmClock", + "BasketBall", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Poster", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan310-openable.json b/gen/layouts/FloorPlan310-openable.json new file mode 100644 index 000000000..586254660 --- /dev/null +++ b/gen/layouts/FloorPlan310-openable.json @@ -0,0 +1,50 @@ +{ + "Cabinet|-00.24|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "Cabinet|-00.62|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "Desk|-00.96|00.00|-01.94": [ + -0.5, + -1.25, + 180, + 30 + ], + "Drawer|+01.62|+00.16|-00.99": [ + 1.0, + -1.75, + 90, + 30 + ], + "Drawer|+01.62|+00.45|-00.99": [ + 0.75, + -1.5, + 0, + 30 + ], + "GarbageCan|+00.13|-00.03|-02.15": [ + 0.25, + -1.5, + 180, + 30 + ], + "Shelf|-00.96|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "SideTable|+01.69|+00.00|-00.99": [ + 1.25, + -1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan311-layout.npy b/gen/layouts/FloorPlan311-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2cb922b71da809507481b3a1c9411bc8f03074aa GIT binary patch literal 3760 zcmbW%ziJdw6bImI5RnkXzp1BNg{`(xL~tuRC5?rZEXf87F|sQ*;#2rQd4+j|lqsi} zB87!9bG`+CrQ2M-d*`0>JG06DdiVbA(T7{@d;2jvS#OUwvzOiM)#;1byqle#ZN6<* zUp}5~PS$_-->g1w*Vp^oPphx%Yd>8qp3l3*vw8Qk`_IpQyZKz4PwQ2!eRw);ZFm0q z-{&vFm*F8ihOffE!)+P;&L@wx%FEMfYur~omY3z_A)c4lxx6edd!Iw(WBItRek>o$ z$3r|nhUN3TJeQG&yM?}z1Q`B{D*iyf7pXF!yS$>wEckjRElwV)@S$>wE z)#Y5}w=X{r-gm9?JC~pR|FhpK9_#zi*L-X~HXoah&Byw1uI95p)Ld*nHXoah&Bx}` z$9!x)HXoah&Bx|reK}Y2**71XkIl#CW2?Hks&8L?R-e^p^|KD=s=j^oS$$UDJ$>18 zoU8iw)#ttC^o_B8?&-(+v3s1We)iS3uRg2K>a#kWtNP|rpVepeS$$UT_Oji4)MNEn zJ$C<2+-LXMeRltD+-LXMeKrq!e!uE@o}C}WIXk}>=d2%lU-#>I_gQ~-pZog#eNgvX zeYmgRL-zZ^-XF`u@~}KC5Bq!Ly~@SDcb5NQJy-D?%g^$&{477q&+@bUEI-T7^0WMp zB0tN|^0Ry_AIrz`v3x8a`#)j*9#>xdSU=W}^<({5{U=eM)o1lteO8~a-ucY_=ziyv5ch|S~C*du;SIf44?5c}cU9M(T9jn#4d+nN+hjq7XfA3#4&wYEm z-#;~*_UNGp2z0xi+OAwo5$v{d2AksMSkyj-lVXeUD3mOSPu_*Ki0!~SP$!AJ!5qU zelM(t_3)5;SP$!AJv>?XYrN`l)x&x?c^~M0!N^vq_D6Q-F*~O zy3OYe%=^G|wOOvWJ#|xeliGam%uJhkHZ_qp+1XuPa@w6;YQOVEa?EWz&kxDPwmcY5 zB0U;L`l0_lef2wa;qx65ehF>@S0Uk2u(v7I-H-hQ#!upd@xl1uGWcK;k4${b@xl1u zD)`}Aa3h$0*#pa@zncdiOg~INOg~INUfvt#Ians&&zydk{*DWO#U6byeK32lO!}D9 S2RHm5GW4^DA7&56SH&MW35^s0 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan313-objects.json b/gen/layouts/FloorPlan313-objects.json new file mode 100644 index 000000000..31b0cedac --- /dev/null +++ b/gen/layouts/FloorPlan313-objects.json @@ -0,0 +1,34 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "TissueBox", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan313-openable.json b/gen/layouts/FloorPlan313-openable.json new file mode 100644 index 000000000..fa062d428 --- /dev/null +++ b/gen/layouts/FloorPlan313-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|-01.74|+00.00|-00.07": [ + -0.75, + 0.0, + 270, + 30 + ], + "Desk|+00.63|+00.00|-01.56": [ + -0.75, + -1.5, + 90, + 30 + ], + "Drawer|+00.27|+00.16|-01.43": [ + -0.25, + -0.25, + 90, + 30 + ], + "Drawer|+00.27|+00.35|-01.43": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.27|+00.55|-01.43": [ + 0.75, + -0.5, + 270, + 30 + ], + "Drawer|-00.16|+00.16|-01.43": [ + -0.75, + -0.25, + 90, + 30 + ], + "Drawer|-00.16|+00.35|-01.43": [ + 0.5, + -0.25, + 270, + 30 + ], + "Drawer|-00.16|+00.55|-01.43": [ + 0.25, + -0.5, + 270, + 30 + ], + "Shelf|+01.41|+00.18|-01.51": [ + 0.75, + -0.25, + 90, + 30 + ], + "Shelf|+01.41|+00.38|-01.51": [ + 1.0, + -0.5, + 90, + 30 + ], + "Shelf|+01.41|+00.57|-01.51": [ + 1.0, + -0.5, + 90, + 30 + ], + "Shelf|+01.54|+00.49|-00.48": [ + 0.75, + 0.0, + 180, + 30 + ], + "SideTable|+01.56|+00.00|-00.47": [ + 1.0, + -0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan314-layout.npy b/gen/layouts/FloorPlan314-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..f10c008a9a66b66ee3094394f56b5cc292d50f9a GIT binary patch literal 1200 zcmbW!uTH~Y6o=t&lUzmJ2T2uT5JJKf4uV0TNW;1y$VOU%AzTF)v|HFEOioTzAP@}N zM{p!HC-3R+&*}DYeS39tH%hPREzj!qp~+`OKA)fFvdHsg^U_p{`(-n$fA*KvQ(N!% z?PK*^@A+_YQWnQYW$|A8_c=(v&-S99-Kw9vz+K?az+Zvo?N)#Duskde%fs@vArH&L z^6+}NZ!`Eef#rMe`>}j1AG;UpTZcZZ59`C-a39u(^Q-9?Y-F}=I#F+Fx4<~R8;<^9Q|NrwkbdQAU)M%DVMUw-FanOnh|!P~{VW!Ay&``mqYe<$2$_t|}}%01Q_ zg&ym%9_#VfbG3f>Gx#I;J@_s7HQ2spUG`@CvVGaUY+tr7+n4Rj_GSCBY0o(A>)gI< zU$!sXm+i~;W&5&yS>Imztk3$a&-$$Icj~h~>$5)Vv%ddLpY>Uv^;w_wO?}p9eb#4v zHg)6FcdpO+tk3$f!*S|6*Jpj!chC2-_c%^{=lZPgJ$=?^_c%^{=lag|S)cV;hyUg` D0lgP8 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan315-objects.json b/gen/layouts/FloorPlan315-objects.json new file mode 100644 index 000000000..67d605fac --- /dev/null +++ b/gen/layouts/FloorPlan315-objects.json @@ -0,0 +1,28 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Mug", + "Bed", + "TableTopDecor", + "CoffeeTable", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan315-openable.json b/gen/layouts/FloorPlan315-openable.json new file mode 100644 index 000000000..9d1fe11f2 --- /dev/null +++ b/gen/layouts/FloorPlan315-openable.json @@ -0,0 +1,110 @@ +{ + "Bed|-02.98|+00.01|-01.18": [ + -1.75, + -1.0, + 270, + 30 + ], + "CoffeeTable|-00.50|+00.01|-03.99": [ + -1.0, + -2.5, + 180, + 0 + ], + "Desk|-00.86|+00.01|-04.03": [ + -0.75, + -3.25, + 180, + 30 + ], + "Drawer|-00.50|+00.07|-03.80": [ + -1.25, + -2.5, + 90, + 30 + ], + "Drawer|-00.50|+00.23|-03.80": [ + -1.25, + -2.75, + 90, + 30 + ], + "Drawer|-00.50|+00.39|-03.80": [ + -1.25, + -2.75, + 90, + 30 + ], + "Drawer|-03.61|+00.11|-03.26": [ + -2.25, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.11|-04.06": [ + -2.25, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.30|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.30|-04.06": [ + -2.5, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.49|-03.26": [ + -2.5, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.49|-04.06": [ + -2.5, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.69|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.69|-04.06": [ + -2.75, + -3.5, + 180, + 30 + ], + "Drawer|-03.61|+00.88|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.88|-04.06": [ + -2.75, + -3.5, + 180, + 30 + ], + "Dresser|-03.65|+00.01|-03.66": [ + -3.0, + -3.5, + 270, + 30 + ], + "GarbageCan|-01.84|-00.02|-03.90": [ + -2.25, + -4.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan316-layout.npy b/gen/layouts/FloorPlan316-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..6d83f59eb4e355ad5d0e7f104faadc30d538014d GIT binary patch literal 1056 zcmbWzu}Z^G7>42F>Q!Vr3Yi3-pY!=jtDKl7{Rxo>y# z{;7FwcYJa_sjIWox>{BLeU8)bv;N%YSIHsp{%uN!_tU@UH|6}cq&}<<>%&9o!|TBM z$Iy@UWBph^){i&EhsVJD()Zz^?1lL;Kjz2$m>)~tnEdAam>=_Fe$0>gqX)<2Kg`Sj s#Qc~a^W$x}Zyz3eV)t-N|HIrq*gn`k*gjb5jj7*UKOTKwN&Un08!2+Cy8r+H literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan316-objects.json b/gen/layouts/FloorPlan316-objects.json new file mode 100644 index 000000000..98fd21897 --- /dev/null +++ b/gen/layouts/FloorPlan316-objects.json @@ -0,0 +1,30 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "Desktop", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "HousePlant", + "Laptop", + "Bed", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan316-openable.json b/gen/layouts/FloorPlan316-openable.json new file mode 100644 index 000000000..bf39297e3 --- /dev/null +++ b/gen/layouts/FloorPlan316-openable.json @@ -0,0 +1,44 @@ +{ + "Bed|-01.70|+00.00|-00.45": [ + -0.75, + -0.25, + 270, + 30 + ], + "Desk|+00.62|+00.00|-01.51": [ + 1.0, + -1.0, + 90, + 30 + ], + "Drawer|-00.56|+00.16|+00.46": [ + 0.25, + -0.25, + 0, + 30 + ], + "Drawer|-00.56|+00.46|+00.46": [ + 0.0, + -0.25, + 270, + 30 + ], + "GarbageCan|+01.66|-00.02|-00.39": [ + 1.0, + 0.0, + 90, + 30 + ], + "Shelf|+01.62|+00.56|-00.80": [ + 0.25, + -1.5, + 90, + 0 + ], + "SideTable|-00.56|00.00|+00.53": [ + 0.0, + 0.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan317-layout.npy b/gen/layouts/FloorPlan317-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..8fb312dceb153889f4dd5423cd0fb302f6383aad GIT binary patch literal 1680 zcmbW$uTH~29Ki8nd5XG1GKJw!Na}D93<5(h&^dDR`j0LLXsrvZA75f>vr z%{O6x_qD!D>)z96eb#6Da2)l`>$AS+^jV+VbY9kH`*Ixh&Fh=jXMJu{pY>UvbvTat zO*yRSvp(yyKI^kS>$AS!xjuJ(AL)Gh*7aGR^;w_w{jc;{pY>Uv^;w_wS-%b6KkKtT Z>$5)VvpzSz*EBkp^*DCn`963z`Ui(uBv$|c literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan317-objects.json b/gen/layouts/FloorPlan317-objects.json new file mode 100644 index 000000000..0f7129662 --- /dev/null +++ b/gen/layouts/FloorPlan317-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "LaundryHamper", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Poster", + "Pen", + "Cloth", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Mirror", + "Floor", + "Safe", + "Laptop", + "Bed", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan317-openable.json b/gen/layouts/FloorPlan317-openable.json new file mode 100644 index 000000000..8145411a3 --- /dev/null +++ b/gen/layouts/FloorPlan317-openable.json @@ -0,0 +1,92 @@ +{ + "Bed|+01.38|+00.00|+00.07": [ + 1.5, + 1.0, + 180, + 30 + ], + "Drawer|+00.41|+00.11|-01.63": [ + -0.5, + -0.25, + 90, + 30 + ], + "Drawer|+00.41|+00.29|-01.63": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.41|+00.49|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.41|+00.68|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.41|+00.87|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.11|-01.63": [ + -1.25, + -0.25, + 90, + 30 + ], + "Drawer|-00.39|+00.29|-01.63": [ + -1.25, + -0.5, + 90, + 30 + ], + "Drawer|-00.39|+00.49|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.68|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.87|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Dresser|+00.01|+00.00|-01.68": [ + 1.0, + -1.25, + 270, + 30 + ], + "GarbageCan|-02.21|-00.02|-01.74": [ + -1.75, + -1.25, + 270, + 30 + ], + "Safe|+01.64|+00.00|-02.04": [ + 1.0, + -1.25, + 90, + 30 + ], + "SideTable|+02.24|00.00|+01.33": [ + 1.75, + 1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan318-layout.npy b/gen/layouts/FloorPlan318-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..998979a6b0345090aaf7d62dee99b1c068d3b895 GIT binary patch literal 1632 zcmbW$u}Z^G6b9g{h!me9TNE;hgNo2hZiMP_CI(E#Ep@W09 z$+w)*ESK;0p8vlI^!xVy=I&uHeWcHPS}mUH{4&e0X6Jd4<+FMHUQb>h=k>Ju+rOT? zEUNAP;(78`ZGC)kR%E9qMfR2b_c=O^SRTt`c`UC9c`T3RvHAXMrR00Dc{a~hIdPR|UmmyN z-oBGL@5%1X`dKc=Rlj}b<37i=9rum)yI^_F>0xsm*Jj9*Yo5)sd3N6a!g+R{o&O2% z!OpY$rLzAH=2;(`XY>1Ep3Sp)_MYrL*gaX_L78@s`?5aP$NE?w>tlU~p^x>kKGw(j USRd;fg+A8D`dA<9V|}CY7Xp6Z6aWAK literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan318-objects.json b/gen/layouts/FloorPlan318-objects.json new file mode 100644 index 000000000..8d246757f --- /dev/null +++ b/gen/layouts/FloorPlan318-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ArmChair", + "TennisRacket", + "Shelf", + "Dresser", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan318-openable.json b/gen/layouts/FloorPlan318-openable.json new file mode 100644 index 000000000..3f9814429 --- /dev/null +++ b/gen/layouts/FloorPlan318-openable.json @@ -0,0 +1,158 @@ +{ + "ArmChair|+01.71|00.00|+01.53": [ + 1.5, + 2.25, + 180, + 30 + ], + "Bed|-00.87|+00.01|-00.92": [ + 0.25, + -0.75, + 270, + 30 + ], + "Cabinet|-00.65|+00.27|+02.25": [ + 0.75, + 1.5, + 0, + 30 + ], + "Desk|+01.81|+00.00|-00.01": [ + 1.25, + -1.0, + 90, + 30 + ], + "Desk|-00.66|+00.01|+01.81": [ + 0.25, + 2.0, + 270, + 30 + ], + "Drawer|+01.69|+00.16|-00.38": [ + 0.5, + 0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.16|-00.81": [ + 0.5, + -0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.35|-00.38": [ + 0.5, + 0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.35|-00.81": [ + 0.75, + -0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.55|-00.38": [ + 0.75, + 0.0, + 180, + 30 + ], + "Drawer|+01.69|+00.55|-00.81": [ + 0.75, + -1.25, + 0, + 30 + ], + "Drawer|-00.55|+00.16|+02.94": [ + 0.25, + 2.25, + 0, + 30 + ], + "Drawer|-00.55|+00.38|+02.94": [ + 0.25, + 2.25, + 0, + 30 + ], + "Drawer|-00.55|+00.57|+02.94": [ + 0.25, + 2.5, + 270, + 30 + ], + "Drawer|-00.55|+00.58|+02.25": [ + 0.25, + 2.75, + 180, + 30 + ], + "Drawer|-00.66|+00.23|-01.31": [ + 0.5, + -0.5, + 180, + 30 + ], + "Drawer|-00.66|+00.55|-01.31": [ + 0.25, + -0.75, + 180, + 30 + ], + "Drawer|-00.66|+00.83|-01.31": [ + 0.25, + -0.75, + 180, + 30 + ], + "Dresser|-00.67|+00.00|+02.94": [ + 0.25, + 2.5, + 270, + 30 + ], + "GarbageCan|+02.02|-00.04|-01.24": [ + 1.5, + -1.5, + 90, + 30 + ], + "Shelf|+01.77|+00.18|+00.76": [ + 0.5, + 0.25, + 0, + 30 + ], + "Shelf|+01.77|+00.18|+00.94": [ + 0.5, + 0.5, + 0, + 30 + ], + "Shelf|+01.77|+00.38|+00.76": [ + 0.75, + 1.25, + 180, + 30 + ], + "Shelf|+01.77|+00.38|+00.94": [ + 0.75, + 0.5, + 0, + 30 + ], + "Shelf|+01.77|+00.57|+00.76": [ + 0.75, + 1.25, + 180, + 30 + ], + "Shelf|+01.77|+00.57|+00.94": [ + 0.75, + 0.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan319-layout.npy b/gen/layouts/FloorPlan319-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..5d5660830bfc55bf6e7fb23ecc3720fa4ffb1095 GIT binary patch literal 1680 zcmbW!ElvYb6o%nTC94=WkW^v#2}!GP5DWrE8af0)D47xrVHGT>TbLzOR#uFtsGxA~ zQ*k6?PTqTF-hAKO@0+{p+xvs`kv{8bGkkhSI;)3O{WNRe+sW(0terN$=U0=L zd9yp8KTqD89Uq;a4y%*nVf9u0_c=^|&vKOKc9CaScvILOuj0PE*O%D^&eoLn`|>^J z$NYF5-tPl%0&fGSaZbQD2)tb6{klx~ao(ncyW+?4WBIZCxDVgUZ!bTVAIpzdCAX;$ z?!sQ5{l4VE`e1#qKDZCx>tnAE)(7i@-IE@AV(;NN^>wZx=cp`eJ=C zpPYP{5A$I@%%^8x?gR5-KFo*ty5ix(e3%dO;dSx&&wQ8<^I<;B=brd5ALhe+n9t>tDDQ~+r8qoc&p}Zf8SMSWp%zdt?IH`EW4MkdAeJ6^Y&~1qIvAw z-G2YjJhwX^9G}$X(P3S_m;b%?i|=cgO>0_B>pJr$^O!khHg8=0p2y~~d7NS%JHLr} z&a?Bpjpy0(>v*1ru)b5xF1XZb9j<#4{rALBd9XZb9jq$$MRV|%V+tV UVxIrOnA!JmUmqT_^ZIOOp9X=z82|tP literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan320-objects.json b/gen/layouts/FloorPlan320-objects.json new file mode 100644 index 000000000..36b55cead --- /dev/null +++ b/gen/layouts/FloorPlan320-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "Curtains", + "BasketBall", + "Pillow", + "Pencil", + "SideTable", + "KeyChain", + "GarbageBag", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Footstool", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan320-openable.json b/gen/layouts/FloorPlan320-openable.json new file mode 100644 index 000000000..4461adc3d --- /dev/null +++ b/gen/layouts/FloorPlan320-openable.json @@ -0,0 +1,50 @@ +{ + "Bed|-01.04|+00.01|-00.69": [ + -0.5, + 0.25, + 180, + 30 + ], + "Desk|+01.52|+00.00|+00.39": [ + 0.75, + 0.5, + 90, + 30 + ], + "Desk|-01.72|+00.00|+00.92": [ + -1.0, + 1.0, + 270, + 30 + ], + "Shelf|-01.70|+00.16|+01.54": [ + -0.5, + 0.75, + 0, + 30 + ], + "Shelf|-01.70|+00.38|+01.54": [ + -0.5, + 0.75, + 0, + 30 + ], + "Shelf|-01.70|+00.57|+01.54": [ + -0.75, + 1.0, + 0, + 30 + ], + "Shelf|-01.84|+01.08|+01.24": [ + -1.25, + 1.5, + 270, + 30 + ], + "SideTable|+00.63|+00.00|-01.71": [ + 0.25, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan321-layout.npy b/gen/layouts/FloorPlan321-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..47b25677080275d02a7ad4d0d6c6cf0bced364f2 GIT binary patch literal 1600 zcmbW$u};E39KhkTA;$0&-Kq%_lNu8`xoKP+oD7i?1|y~z7vod-K=KGY0wW_s2L=Yw zyKlMCE|;(E{r;uE*X{ky-NR9M4#-i|aXUv^;v(F^;w_wS)cV; zKfbjPydTzQeb#4v)?ba{nWBy>>$5)Vvp(yuvp(yyKI^kS>-(L1e%5Dw)@Oaz-)7Ix c`mE3Ttk33jsqg>C{(tQAvH5I1o7atg0H)fy0{{R3 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan321-objects.json b/gen/layouts/FloorPlan321-objects.json new file mode 100644 index 000000000..8749b01dc --- /dev/null +++ b/gen/layouts/FloorPlan321-objects.json @@ -0,0 +1,27 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Bed", + "ArmChair", + "TissueBox", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan321-openable.json b/gen/layouts/FloorPlan321-openable.json new file mode 100644 index 000000000..6efd3c144 --- /dev/null +++ b/gen/layouts/FloorPlan321-openable.json @@ -0,0 +1,44 @@ +{ + "ArmChair|+00.85|00.00|-02.14": [ + 1.5, + -1.75, + 270, + 30 + ], + "Bed|+00.91|+00.00|+00.14": [ + 0.75, + 1.25, + 180, + 30 + ], + "Desk|+03.24|+00.00|-01.59": [ + 3.0, + -1.0, + 180, + 30 + ], + "Drawer|+00.33|+00.62|+01.30": [ + 1.5, + 1.25, + 270, + 0 + ], + "Drawer|+00.33|+00.62|-01.02": [ + 1.5, + -1.75, + 270, + 0 + ], + "SideTable|+00.28|+00.00|+01.30": [ + 0.75, + 1.25, + 270, + 30 + ], + "SideTable|+00.28|+00.00|-01.02": [ + 0.75, + -1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan322-layout.npy b/gen/layouts/FloorPlan322-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d55bd506cbc30551aafd5e5009bd845a49075629 GIT binary patch literal 1792 zcmbW$u};EJ6b9fcqfgPTnlPwwFvbKXH;s#flOa;#K*SW|Vtfi8h*#(%Ffw-N;J_f- z`_+y-~S zpTXN;dFGJE@>m|rV|ku~JeJ4uSRTvs9Obb*mdElqjr-@z@|#t^FQ4VJe3sAhd64^9 zU*DFJKJN1G!}?es>*K-Lr+(Gf&(aIWAkv6=V9}(dDuK`9*(Q~x9|S9qb~?*2~Yq4 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan322-objects.json b/gen/layouts/FloorPlan322-objects.json new file mode 100644 index 000000000..43380c052 --- /dev/null +++ b/gen/layouts/FloorPlan322-objects.json @@ -0,0 +1,30 @@ +[ + "BaseballBat", + "AlarmClock", + "Curtains", + "Pillow", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "Cloth", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ArmChair", + "Shelf", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan322-openable.json b/gen/layouts/FloorPlan322-openable.json new file mode 100644 index 000000000..ab36ff242 --- /dev/null +++ b/gen/layouts/FloorPlan322-openable.json @@ -0,0 +1,122 @@ +{ + "ArmChair|+02.57|+00.00|-00.82": [ + 2.0, + -0.5, + 90, + 30 + ], + "Bed|-00.75|-00.02|+00.11": [ + 0.75, + 0.0, + 270, + 30 + ], + "Cabinet|+02.48|+00.50|+01.00": [ + 1.75, + 0.25, + 0, + 30 + ], + "Cabinet|+02.48|+00.50|+01.01": [ + 1.75, + 1.75, + 180, + 30 + ], + "Cabinet|+02.48|+00.50|+02.03": [ + 1.75, + 1.25, + 0, + 30 + ], + "Cabinet|+02.48|+00.50|-00.02": [ + 1.75, + 0.75, + 180, + 30 + ], + "Drawer|+02.57|+00.90|+00.23": [ + 2.0, + -0.25, + 0, + 30 + ], + "Drawer|+02.57|+00.90|+00.75": [ + 2.0, + 1.0, + 180, + 30 + ], + "Drawer|+02.57|+00.90|+01.26": [ + 2.0, + 1.0, + 0, + 30 + ], + "Drawer|+02.57|+00.90|+01.78": [ + 2.0, + 1.5, + 0, + 30 + ], + "Drawer|-01.53|+00.46|+01.48": [ + -1.0, + 1.5, + 270, + 30 + ], + "Drawer|-01.53|+00.46|-01.25": [ + -1.0, + -1.25, + 270, + 30 + ], + "Dresser|+02.82|+00.00|+01.01": [ + 2.25, + 0.75, + 90, + 30 + ], + "GarbageCan|+01.35|+00.00|-01.69": [ + 0.75, + -1.0, + 90, + 30 + ], + "Shelf|-01.55|+00.04|+01.33": [ + 0.0, + 1.5, + 270, + 30 + ], + "Shelf|-01.55|+00.04|+01.60": [ + -0.5, + 1.5, + 270, + 30 + ], + "Shelf|-01.55|+00.04|-01.13": [ + -0.5, + -1.25, + 270, + 30 + ], + "Shelf|-01.55|+00.04|-01.40": [ + 0.0, + -1.25, + 270, + 30 + ], + "SideTable|-01.60|+00.00|+01.48": [ + -1.0, + 1.5, + 270, + 30 + ], + "SideTable|-01.60|+00.00|-01.25": [ + -1.0, + -1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan323-layout.npy b/gen/layouts/FloorPlan323-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0add409d466e1b9f7b3b2198c7ab57455ca4ff83 GIT binary patch literal 3184 zcmbW&u}ULB7{Kvy5jpNDwp)cXTAd=em7QX9#Z?kCVj(Jt*oaTz1G$f|k6>xJ#THwn zFvraAz^}X%PJRDv#|hKQWKZWAoTNHjmBYb(znp z&2#@bGgV!FqKEac9@fKpSP$!AJzTZ9gR?e2yZlTa>tlVakM*%W*2ns|YI6q{rS*G$ zrjPZpKGw(jcq-o?>tlUfwYh_{Qkp^^>tlVakM;3X`gk3z&+GbF-x&H>AM4|x%wv75 zkIfsxJT{NbWAk_{^VvN1d9dFbe+PX}>~mq=>>Q4(zo+*5a!+=D?n^(rKf6D>Kab)4 z?(cQ?XZP3X{_Otj{_OtjT#l>z+joCtQ`SmhXf0 zupYMRh^rp^dRPzZ;j#3v9@fKp;#`ia9{YND@OhL~kJt6E9@Z7-a9qu|Z$6vP=Ck`d z$9&es-p6q@-@f^5KAZ1-=Ck>1K0AlwYQBB*+2_yxe{j|2BG&6%z1)ZIU9Z>mvU54E fdhP3Fy{wn@IY%GsV|}cToy&36XI~%dn@+v}36aM& literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan323-objects.json b/gen/layouts/FloorPlan323-objects.json new file mode 100644 index 000000000..52144cfd1 --- /dev/null +++ b/gen/layouts/FloorPlan323-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Sofa", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Safe", + "Laptop", + "Mug", + "Bed", + "Dresser", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan323-openable.json b/gen/layouts/FloorPlan323-openable.json new file mode 100644 index 000000000..e202bfd8c --- /dev/null +++ b/gen/layouts/FloorPlan323-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|-01.61|-00.03|-01.86": [ + -1.5, + -0.75, + 180, + 30 + ], + "Desk|+02.32|-00.01|-03.22": [ + 2.0, + -2.5, + 180, + 30 + ], + "Drawer|+01.98|+00.21|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+01.98|+00.49|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+01.98|+00.73|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+02.64|+00.17|+01.51": [ + 2.0, + 1.0, + 0, + 30 + ], + "Drawer|+02.64|+00.45|+01.51": [ + 2.0, + 1.0, + 0, + 30 + ], + "Dresser|+02.68|+00.00|+01.51": [ + 2.25, + 1.5, + 90, + 30 + ], + "GarbageCan|+01.34|+00.00|-03.38": [ + 1.0, + -3.0, + 90, + 30 + ], + "Safe|+02.72|+01.23|+01.78": [ + 2.25, + 1.5, + 90, + 0 + ], + "SideTable|-02.42|00.00|-00.51": [ + -2.0, + -0.5, + 270, + 30 + ], + "SideTable|-02.42|00.00|-03.15": [ + -2.0, + -3.0, + 270, + 30 + ], + "Sofa|+02.38|+00.01|-00.29": [ + 1.5, + -0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan324-layout.npy b/gen/layouts/FloorPlan324-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..02f4fc67b619400618029e51b4123a4047667b80 GIT binary patch literal 1552 zcmbW#y-LGS7=YoUh=^B_Eef5Sst9#*Q(PRJq}YgqSV_f2yb3R6bS@U)Q%+H+MVfJ$;m;YVuH*XGMAb*e`oU`8clM>fy`%xE@u%=P!rP zlWKi_@-%#{);{W=_KK6^Uh!G{_c%;{$70&8>APFo;Cb*YxCzeFl6lQwd;TnV9^3}& zTTQq7SRdtlVakM*(rI_+os*?!-F{cJzm?>_Bk z`+1SyFE4}5^PJ3M^VmE#k5_pt*vB?=i1zKAX?xv-xbkRX?}+dTjp2)2`J2+F;+I-+dR{g#GS& R^LxHNyDrC7uk(86gCBu)^&tQN literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan324-objects.json b/gen/layouts/FloorPlan324-objects.json new file mode 100644 index 000000000..00fe94151 --- /dev/null +++ b/gen/layouts/FloorPlan324-objects.json @@ -0,0 +1,29 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "VacuumCleaner", + "CellPhone", + "DeskLamp", + "Drawer", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "Shelf", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan324-openable.json b/gen/layouts/FloorPlan324-openable.json new file mode 100644 index 000000000..18df29209 --- /dev/null +++ b/gen/layouts/FloorPlan324-openable.json @@ -0,0 +1,110 @@ +{ + "Bed|-00.84|00.00|-00.36": [ + -0.75, + 0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.09|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.09|-02.20": [ + 0.25, + -1.5, + 180, + 30 + ], + "Drawer|+01.60|+00.25|-01.46": [ + 0.0, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.25|-02.20": [ + 0.0, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.41|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.41|-02.20": [ + 0.5, + -1.5, + 180, + 30 + ], + "Drawer|+01.60|+00.57|-01.46": [ + 0.25, + -2.0, + 90, + 0 + ], + "Drawer|+01.60|+00.57|-02.20": [ + 0.25, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.73|-01.46": [ + 0.5, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.73|-02.20": [ + 0.5, + -2.0, + 90, + 0 + ], + "Dresser|+01.63|+00.00|-01.83": [ + 1.0, + -1.75, + 90, + 30 + ], + "GarbageCan|+03.38|+00.00|+00.22": [ + 2.5, + -0.25, + 0, + 30 + ], + "Shelf|+00.02|+00.18|-02.51": [ + -0.5, + -1.5, + 90, + 30 + ], + "Shelf|+00.24|+00.34|-02.51": [ + 0.75, + -1.75, + 270, + 30 + ], + "Shelf|+00.25|+00.67|-02.52": [ + 0.75, + -2.0, + 270, + 30 + ], + "Shelf|+00.36|+00.18|-02.51": [ + -0.25, + -1.5, + 90, + 30 + ], + "Shelf|+00.47|+00.34|-02.51": [ + 0.0, + -1.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan325-layout.npy b/gen/layouts/FloorPlan325-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..56831d6298ed3e097660d18a1df40c23b83aca2c GIT binary patch literal 3040 zcmbW&F-{vn6b9glg(8FyO5zJ_w;;K}6^fAJDjg9GMJi-rTNDV89i>4zMGj<+ut%VD zxy2SPTm+c;EcumjGx~NsZ~x!e%ikYY7neUjq~GbOo=g`v^ZIL5pU=+fK~>Kl=D+6S z`|F4KWcqgf`}l4#eZ9W89Y0QAeSCU098|-TLG`El&(}eEf4wa8x+!ZDoOe^&?tj~T z|4Z;H*!*>wYd)LLO*zlzv-xa(7v{71Y(AUM=5t%}a2LD|-UO#nPT+hmcrW;4@P647dIsz>(BbL{@jK0`rFr^_2*v6%lfnatUv3|`g2oyuR?#;pY><`S%2y#QSnw<#AmeZhanQmB+q3EDy`$K60}6aa`qby)8Ld z9+rpYVR_7zhvi}CIIi-zE)UDY^04o1NXOY zp68f(Y#y7(&U@}T&(5>wl;@)J>^wWa^>e<`8|8Jg-1R!R3vPquF;5)p=Q6OwX!8SxslnTQhojm^I_c&-JU( z^L(G7caEdTjA48NbvBF=srXHm!5Z{zIMarWCdi!^&_hRnNk zp8MO(U1q;;{W`n9%Dl`RQ-xsv@-klGQ2%w2SwHLbGxcNrSU=W}^<({5Kh}?9`Vd$@ z){pgL{n*qipZdA3AM3~Zv3{%{>&N=Beykts$Gtk8(8ejR9?oOuaZ$&8>^yd!={$BG zo1T;PY&~1=Ia<%F^nYgi*?!O6ezu?2={(+K?lNyP?=s8dJbAo#c~~Bnhvi{;SRR&# z4m;IYnI|slxClBfV{o?o8eoV9YoaQEQ3hew>UUwclkGHeQi|voR`Sm#E z^LP_jeh7IikL9s^AM#ip%VXbzQ}*~T`Ev@)hxxF)|0s{;u{_oX^O<~@5A$I@Z1Tj( zXPpo8VZNBdaq?N`!+g$p4|Wd6DbFj9<*_`DldsSBmJjn`KFo*X9P)h|vcC`PUfFjq pa0=)3``gc6tRL17>xcClLqDt^)(@xL59^0h_G108eptV8_64mfLl9g=T_LFfK?osP6%K+ypvc0yOb|v|f+1W57qna0B~(sUOdt>p zdVWiGB*%Pv&Y$o3-tP0}?)vtAFT92KVp6w{O>vPIm(%m2%!}!~d2Pne5A$YH|L$Ln zpW1q}-_FJ_^@fkmPRjiBxXeHD|E|OEx7MSf_KTr@CH$RmsCMrkB&^>m>4){h`r$10 z!}|&IIp^yVALhe+m=E(|KFqgFe3%dOVLr@<`S3b^{}7k|2lHV*oK=1emCr68mU9`s z=D_aZw07Rbx=OfDSU!E^!}4MIa8?ZyVfnCpSibF?i{U*UCpo_x;b S!}4MIa8~WkC!cfqy3r3)Rg?Pw literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan328-objects.json b/gen/layouts/FloorPlan328-objects.json new file mode 100644 index 000000000..1a17b7f1a --- /dev/null +++ b/gen/layouts/FloorPlan328-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "HousePlant", + "Laptop", + "Mug", + "Bed", + "TennisRacket", + "TissueBox", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan328-openable.json b/gen/layouts/FloorPlan328-openable.json new file mode 100644 index 000000000..742c72d37 --- /dev/null +++ b/gen/layouts/FloorPlan328-openable.json @@ -0,0 +1,44 @@ +{ + "Bed|+00.23|00.00|-00.95": [ + 1.25, + -1.0, + 270, + 30 + ], + "Desk|+02.50|+00.00|-01.60": [ + 2.75, + -1.0, + 180, + 30 + ], + "Drawer|+01.24|+00.13|-01.55": [ + 1.75, + -0.5, + 270, + 30 + ], + "Drawer|+01.24|+00.35|-01.55": [ + 1.75, + -0.75, + 270, + 30 + ], + "GarbageCan|+03.17|-00.01|-00.26": [ + 2.5, + 0.25, + 180, + 30 + ], + "Shelf|+03.03|+00.64|-01.58": [ + 2.5, + -0.75, + 90, + 30 + ], + "SideTable|+01.24|+00.00|-01.55": [ + 2.0, + -0.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan329-layout.npy b/gen/layouts/FloorPlan329-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2328b0b89d500347af2954dd40046c6b4fb53b70 GIT binary patch literal 1536 zcmbW!p-#hK6hPr(d5XG1QiW;=Nl~~F3<51LtC8Z#l^fT%Dk8_+Shjae7|UC&CmX7`m}8J z`{m>GrP=dIRh9YKX_a|3nSG6O2)qrv3!GgZzR$N?9r`dI=EHoLZyS7= z5A$I@%r^ud=EHoL5BKT+=z|aQVLr@<`8L6a`7j^m!@OPc+2c6Z={fuKbu+xK#|`cR zZvyM_{1EQzabFMCgY`J49_%?Br=GukIuF)^^^&T( z?_;kA>%n^Pkb1BltOx7CdYnTK)`Rt69vr70dp)@KJ<`%shfw@+TokNGh_ H=I`on>on)? literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan329-objects.json b/gen/layouts/FloorPlan329-objects.json new file mode 100644 index 000000000..96fb14e54 --- /dev/null +++ b/gen/layouts/FloorPlan329-objects.json @@ -0,0 +1,28 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "Shelf", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan329-openable.json b/gen/layouts/FloorPlan329-openable.json new file mode 100644 index 000000000..549094674 --- /dev/null +++ b/gen/layouts/FloorPlan329-openable.json @@ -0,0 +1,50 @@ +{ + "Bed|-00.12|00.00|-01.70": [ + 1.0, + -1.75, + 270, + 30 + ], + "Desk|-00.28|00.00|+00.83": [ + -0.75, + 0.25, + 0, + 30 + ], + "Drawer|+00.95|+00.17|-02.39": [ + 1.5, + -2.0, + 270, + 30 + ], + "Drawer|+00.95|+00.46|-02.39": [ + 1.5, + -2.0, + 270, + 30 + ], + "GarbageCan|+02.47|-00.03|+00.94": [ + 2.0, + 0.5, + 90, + 30 + ], + "Shelf|-00.28|+00.10|+00.83": [ + 1.25, + 0.25, + 0, + 30 + ], + "Shelf|-00.28|+00.35|+00.83": [ + 1.5, + 0.5, + 270, + 0 + ], + "SideTable|+00.95|+00.00|-02.46": [ + 1.5, + -2.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan330-layout.npy b/gen/layouts/FloorPlan330-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a63bb699dd8cc91bd1229f78cf5b331ecdecbff GIT binary patch literal 2240 zcmbW%Jx*Iu5QgEy6{5&0Zg&&OO-K`=NZg8!C=CTwWCbG%6p$U!AXdSGoF&{PP*S>Z z;esNBGtZGSWll4G=jWUGEX$8y&rZLc@0Gi9KU^$UKbFH$KYY3TJk0vx@@DyKIsf_n zW_hvrn?IRfuNJTQ)z$oV@yhQ%emb1>haYDBL;s)eU3q((b&UtVYkW?uzMtw?y-Rhh zUQ!*azr?V^q-PGrjO}k`j|eZ|D5zOeN4Zxxrp|u+lRO7>UR_U_G8~4wjbM%t6C{|q8qXK z40eb99JgtHm-r=d8UOXuCFb9r?Yj22J&E~O=O0h0zp9ne>Tw_DAM=mfU1?68f6PDj zKiT@?KD2B6c>fg^V#*g!Q z^ZEQ?{9JE*aC}-7M~7AMUi|kNr0vsfckjh;_wEFz;PvO<-(LkUgBQX3xwjndI)mVT za4*$840f8T!AXMNUZeb(=V ZKBqQqAJ%7m)@S{G=(9fSvp(zhM?dB_q@(}< literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan4-objects.json b/gen/layouts/FloorPlan4-objects.json new file mode 100644 index 000000000..60ee2f021 --- /dev/null +++ b/gen/layouts/FloorPlan4-objects.json @@ -0,0 +1,42 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "DiningTable", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan4-openable.json b/gen/layouts/FloorPlan4-openable.json new file mode 100644 index 000000000..b61a84d71 --- /dev/null +++ b/gen/layouts/FloorPlan4-openable.json @@ -0,0 +1,98 @@ +{ + "Cabinet|-01.00|+00.39|+00.73": [ + -1.75, + 1.5, + 90, + 30 + ], + "Cabinet|-01.73|+00.39|+00.73": [ + -2.0, + 1.5, + 90, + 30 + ], + "CounterTop|-00.52|+01.16|+00.49": [ + -1.0, + 1.0, + 90, + 30 + ], + "CounterTop|-02.28|+01.16|+00.38": [ + -1.75, + 1.0, + 180, + 30 + ], + "CounterTop|-03.86|+01.16|+00.38": [ + -3.25, + 1.25, + 180, + 0 + ], + "DiningTable|-00.62|+00.02|+02.49": [ + -1.25, + 2.5, + 90, + 30 + ], + "Drawer|-02.04|+00.22|+00.59": [ + -1.5, + 1.5, + 270, + 30 + ], + "Drawer|-02.04|+00.61|+00.59": [ + -2.5, + 1.25, + 90, + 30 + ], + "Drawer|-02.04|+00.94|+00.60": [ + -1.5, + 1.0, + 270, + 30 + ], + "Drawer|-02.50|+00.22|+00.59": [ + -3.0, + 1.5, + 90, + 30 + ], + "Drawer|-02.50|+00.61|+00.59": [ + -3.0, + 1.25, + 90, + 30 + ], + "Drawer|-02.51|+00.94|+00.60": [ + -2.0, + 1.0, + 270, + 30 + ], + "Fridge|-03.52|+00.00|+02.72": [ + -2.5, + 2.75, + 270, + 30 + ], + "GarbageCan|-03.70|+00.00|+02.01": [ + -3.5, + 1.5, + 0, + 30 + ], + "Microwave|-00.37|+01.11|+00.43": [ + -1.0, + 1.0, + 90, + 30 + ], + "Sink|-01.39|+00.98|+00.44|SinkBasin": [ + -1.25, + 1.75, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan401-layout.npy b/gen/layouts/FloorPlan401-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..8e4a04103feacbfd316e141080638154d285734a GIT binary patch literal 1616 zcmbW#u};EJ6oBE{kj5AuqFXg#(nXDlo!m4o4o-$hiGvYSjEnIpd?5P>K7u170|Ntt z2a?uR#>ds5tj3e}r5!%qP1;fOd;eni zIBnMVrw_yDX6^lxqd|FiFeu;4|6Y69=IV9Z^Xq(j=83b!tIxmRUnbW3PI|1zdaTDq z%%4S1pY6-~tk3$qi2YfAp6t*1tk3$qh(7Btl0NIRKI^kS>o1c&>$5)Vvp(yul0NIR zJ}=|h1r``(=IBXMNUZ|EE0qy)N5ac^zjLXV|pFIy3(J!L!dDuM8lJA@6bMx3dp2z!R^LLZ^oX0#ipUr3U*?cyiXR#04XD``@ i?ZftA`>=i3K5QSh4|^Z|*vEV}kIiHA*gQ6`U;hA}V9Xo< literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan401-objects.json b/gen/layouts/FloorPlan401-objects.json new file mode 100644 index 000000000..233e0276d --- /dev/null +++ b/gen/layouts/FloorPlan401-objects.json @@ -0,0 +1,32 @@ +[ + "PaperTowelRoll", + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "LightSwitch", + "Sink", + "Floor", + "SoapBar", + "HandTowel", + "Shelf", + "ShowerHead", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan401-openable.json b/gen/layouts/FloorPlan401-openable.json new file mode 100644 index 000000000..bfe92af8f --- /dev/null +++ b/gen/layouts/FloorPlan401-openable.json @@ -0,0 +1,56 @@ +{ + "Bathtub|-00.21|+00.36|+00.92|BathtubBasin": [ + -1.25, + 1.75, + 90, + 30 + ], + "GarbageCan|+00.05|00.00|+03.88": [ + -0.75, + 3.25, + 0, + 30 + ], + "Shelf|-02.59|+00.78|+03.91": [ + -2.25, + 3.0, + 0, + 0 + ], + "Shelf|-02.59|+01.03|+03.94": [ + -2.5, + 3.25, + 0, + 0 + ], + "Shelf|-02.59|+01.29|+03.94": [ + -2.5, + 3.5, + 0, + 0 + ], + "Shelf|-02.59|+01.53|+03.91": [ + -2.5, + 3.5, + 0, + 30 + ], + "SideTable|-03.17|+00.00|+00.17": [ + -2.75, + 0.75, + 180, + 30 + ], + "Sink|-03.12|-00.01|+01.53|SinkBasin": [ + -2.5, + 2.0, + 180, + 30 + ], + "Toilet|+00.06|+00.00|+03.10": [ + -0.75, + 3.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan402-layout.npy b/gen/layouts/FloorPlan402-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..fbbb5a2090f0968bd287946482cba894a287ca02 GIT binary patch literal 1584 zcmbW!u}T9$6a~;Rge8O!)cnA9tB^)36^p6t6dMaG31)+Z7)iuN{0cwF{S-?}3kwSi zV`fj`luomp+2p?a*q5`5)AP%X@ED$|X}!E&R7YiXJUghyWi^{G9u||ktNCJD|K6WW zZkP4yet9#wuUFnV+#8qsyW{e?{O{?9_31R}8De^VzW((`=J(8RndNobywIdP{%(KI zUzyGK-h4Kn&1dtwF{IO^2b<64v-xa3o6qKRx1CqSG*=%E*?WDw*N63CeOMpXhxO@Y zeOMpXhxK87SbjgtXZb9j<+FU2KgjY~KFeqMET4-etj{o}r+M6I(mk8U=COHf9{Yam z`?2rGMLT~prXKpSeykts$NI5;tRL&g`th*sx7GF=WbS9~WiB$?PoDkQer!LsAKQ=Z i$M$3UvHiAVSRebb{n&n7H0ggVZxqwLJeJ4uM)3zd*{L7^ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan402-objects.json b/gen/layouts/FloorPlan402-objects.json new file mode 100644 index 000000000..5135a1b2f --- /dev/null +++ b/gen/layouts/FloorPlan402-objects.json @@ -0,0 +1,33 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan402-openable.json b/gen/layouts/FloorPlan402-openable.json new file mode 100644 index 000000000..44dc45846 --- /dev/null +++ b/gen/layouts/FloorPlan402-openable.json @@ -0,0 +1,92 @@ +{ + "Bathtub|-02.90|+00.67|+02.86|BathtubBasin": [ + -2.75, + 3.75, + 270, + 30 + ], + "Cabinet|-00.12|+00.36|+04.63": [ + -1.0, + 3.75, + 90, + 30 + ], + "Cabinet|-01.03|+00.36|+04.63": [ + -1.5, + 3.75, + 90, + 30 + ], + "Cabinet|-01.06|+00.36|+04.63": [ + -0.75, + 3.75, + 270, + 30 + ], + "Cabinet|-01.96|+00.36|+04.63": [ + -2.25, + 4.0, + 90, + 30 + ], + "CounterTop|-01.02|+00.95|+04.88": [ + -0.75, + 4.25, + 0, + 30 + ], + "GarbageCan|-02.35|+00.00|+04.88": [ + -3.0, + 4.25, + 0, + 30 + ], + "HandTowelHolder|-00.07|+01.57|+04.81": [ + -0.5, + 4.25, + 0, + 30 + ], + "HandTowelHolder|-02.09|+01.54|+05.15": [ + -1.5, + 4.25, + 0, + -30 + ], + "Sink|-00.58|+00.93|+04.87|SinkBasin": [ + -0.75, + 4.25, + 0, + 0 + ], + "Sink|-01.53|+00.93|+04.87|SinkBasin": [ + -1.75, + 4.25, + 0, + 0 + ], + "ToiletPaperHanger|-00.07|+01.13|+03.69": [ + -0.5, + 4.0, + 180, + 30 + ], + "Toilet|-00.52|00.00|+03.22": [ + -0.5, + 2.75, + 0, + 30 + ], + "TowelHolder|-00.07|+01.41|+02.43": [ + -0.5, + 2.5, + 90, + 0 + ], + "TowelHolder|-01.72|+01.21|+01.74": [ + -1.75, + 2.25, + 180, + 0 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan403-layout.npy b/gen/layouts/FloorPlan403-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..50071edd0cc8cf7d828ff704ed437190a79a84e5 GIT binary patch literal 1008 zcmbW!F-pTw0LS5{h=Zrd7KKbgK}2Y#Zi2!IVsxmEC?NeJn+^pI~^Rs_e-*?Ss zzq_j+n~e`%QXY;)Gv7P(M^Si-Cu%7>& zm-SeW*ZI7xzYcxYXMNUZeb#4v*6%}~^;w_wdC2!;eb#6FA@o_F^;w_wxzFceebygC fpY>Uv^;w_wS)cW%&}V&~@_l#=*7seX^{4qam2{;B literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan404-objects.json b/gen/layouts/FloorPlan404-objects.json new file mode 100644 index 000000000..098f91eab --- /dev/null +++ b/gen/layouts/FloorPlan404-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan404-openable.json b/gen/layouts/FloorPlan404-openable.json new file mode 100644 index 000000000..6b3129c2f --- /dev/null +++ b/gen/layouts/FloorPlan404-openable.json @@ -0,0 +1,38 @@ +{ + "Bathtub|+00.22|+00.34|+00.64|BathtubBasin": [ + -0.75, + 1.25, + 90, + 30 + ], + "Shelf|-01.17|+00.28|+02.16": [ + -1.25, + 1.75, + 0, + 30 + ], + "Shelf|-01.17|+01.06|+02.16": [ + -1.0, + 1.75, + 0, + 30 + ], + "Shelf|-01.17|+01.76|+02.16": [ + -0.75, + 0.75, + 0, + 0 + ], + "Sink|-01.13|00.00|-00.59|SinkBasin": [ + -1.5, + 0.0, + 90, + 30 + ], + "Toilet|-02.15|+00.00|-00.41": [ + -1.5, + 0.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan405-layout.npy b/gen/layouts/FloorPlan405-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..b175551a305c675bce4672eaf23dc95cba71c2d0 GIT binary patch literal 576 zcmbWzAr8VY6oBDEP@JN!kW@`Agk%l}!5~m%VO41ah)5C9UO~1fbaD_Cp_$wi7Y8Q^HpM}#B;q1og%@Nm!Ao#-ba2Sf z!D{*p{YTGocmny}mb{){o?Tq6q^I zvwgOoisgN77r%$?vwgPDAK`ty)zD)-)?+=^V?EYeE7ITbeOQn6SdaBskKY&nm(#TC zt{2^{&-$#-`mE3Ttk3!zq0joP&-$#-`mE3Tz0hZU)@OazXMNUZ{msy4eb#4v)@Oaz zXZ@|vXMNUZeb#4v)@S|g&}V(tXMNUZeb#6FozQ1})@OazXMNV|haT&(9_z6l>-CEt DyrtJD literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan406-objects.json b/gen/layouts/FloorPlan406-objects.json new file mode 100644 index 000000000..fee4c2922 --- /dev/null +++ b/gen/layouts/FloorPlan406-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "SinkBasin", + "TowelHolder", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan406-openable.json b/gen/layouts/FloorPlan406-openable.json new file mode 100644 index 000000000..712dee310 --- /dev/null +++ b/gen/layouts/FloorPlan406-openable.json @@ -0,0 +1,26 @@ +{ + "Cabinet|+00.07|+00.38|+02.05": [ + -0.75, + 3.0, + 90, + 30 + ], + "CounterTop|+00.49|+01.02|+03.09": [ + -0.25, + 3.5, + 90, + 30 + ], + "Sink|+00.43|+01.04|+02.95|SinkBasin": [ + -0.25, + 3.0, + 90, + 0 + ], + "Toilet|+00.38|+00.00|+04.47": [ + -0.5, + 3.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan407-layout.npy b/gen/layouts/FloorPlan407-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e53430e434d631d6fb74bcfe6bc1187099066062 GIT binary patch literal 672 zcmbV_Ar1mD5JijS6m^B93J`>ltiwSt2o!19ZV-eeEx`~@!GX9!kAOrX5J(ovGb5?_ zdA~FBF0;jSzHF(ZI+@bPbuc4s#?{bRZK^sPg4?a?Q2I|laogydK5pFJH{9tDtnPKK zKI?y9TYcZ_n)C6?r(k;WF8*(Vli++^DfaPk2OrEFEE69+J{TX2k3D=aKA1gNCO&$6 hFh1t+!T4Z&Fn3^?_~_ZEXCGz`WqnzeXjrj literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan407-objects.json b/gen/layouts/FloorPlan407-objects.json new file mode 100644 index 000000000..0cec3c67e --- /dev/null +++ b/gen/layouts/FloorPlan407-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan407-openable.json b/gen/layouts/FloorPlan407-openable.json new file mode 100644 index 000000000..e7f8e434c --- /dev/null +++ b/gen/layouts/FloorPlan407-openable.json @@ -0,0 +1,56 @@ +{ + "Bathtub|+00.88|+00.39|-01.15|BathtubBasin": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|-00.07|+00.34|-01.33": [ + -1.0, + -0.5, + 90, + 30 + ], + "Cabinet|-01.04|+00.34|-01.33": [ + -1.5, + -0.5, + 90, + 30 + ], + "Cabinet|-01.05|+00.34|-01.33": [ + -1.25, + -0.75, + 180, + 30 + ], + "Cabinet|-02.02|+00.34|-01.33": [ + -1.0, + -0.25, + 270, + 30 + ], + "CounterTop|-01.04|+00.88|-01.53": [ + -1.5, + -1.0, + 180, + 30 + ], + "Sink|-00.53|+00.81|-01.60|SinkBasin": [ + -1.0, + -1.0, + 90, + 30 + ], + "Sink|-01.56|+00.81|-01.60|SinkBasin": [ + -1.25, + -1.0, + 180, + 30 + ], + "Toilet|-01.61|00.00|+00.21": [ + -1.25, + -0.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan408-layout.npy b/gen/layouts/FloorPlan408-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..97a2514fc98772512785982fd1a708a0fb640592 GIT binary patch literal 704 zcmbW!F$%&k6oBCKC!C#D~MQz`xv)5r8NeayS0i^&IyoqELp literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan408-objects.json b/gen/layouts/FloorPlan408-objects.json new file mode 100644 index 000000000..e855538bd --- /dev/null +++ b/gen/layouts/FloorPlan408-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan408-openable.json b/gen/layouts/FloorPlan408-openable.json new file mode 100644 index 000000000..a8048b4fb --- /dev/null +++ b/gen/layouts/FloorPlan408-openable.json @@ -0,0 +1,62 @@ +{ + "Bathtub|+00.29|+00.29|-00.08|BathtubBasin": [ + -0.5, + 0.25, + 90, + 30 + ], + "Cabinet|-01.50|+00.42|+00.43": [ + -2.25, + -0.5, + 90, + 30 + ], + "Cabinet|-02.29|+00.39|+00.42": [ + -2.5, + -0.25, + 90, + 30 + ], + "Cabinet|-02.31|+00.42|+00.43": [ + -2.25, + -0.25, + 0, + 30 + ], + "Cabinet|-03.09|+00.39|+00.42": [ + -2.5, + -0.5, + 0, + 30 + ], + "CounterTop|-02.30|+00.95|+00.69": [ + -2.25, + -0.25, + 0, + 0 + ], + "GarbageCan|-02.86|+00.02|-01.49": [ + -2.25, + -0.75, + 270, + 30 + ], + "Sink|-01.92|+00.93|+00.68|SinkBasin": [ + -1.75, + 0.0, + 0, + 0 + ], + "Sink|-02.68|+00.93|+00.68|SinkBasin": [ + -2.5, + 0.0, + 0, + 0 + ], + "Toilet|-01.05|+00.00|+00.55": [ + -0.5, + 0.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan409-layout.npy b/gen/layouts/FloorPlan409-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..278e0a1d880584b4bedf2ea9897c33979fadd4dd GIT binary patch literal 752 zcmbWyF$%&!5J1sYL?q-8+pR(>ZK4RKvQum2HK7jKuDOYCPqjyJh2_W3&A*~0B! zKhWJypilbW@l-j_OZC1+)%y^>3*UsfSJCf1<{op8uiqY~R~J1@57Wc+Fug{k%He;Q v9;S!sVR}u`!}KscOb^p*i5{kh>0x@9o+o;k9;S!sVS2vkVS1Pzrsqd*d}L}c literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan409-objects.json b/gen/layouts/FloorPlan409-objects.json new file mode 100644 index 000000000..670bad826 --- /dev/null +++ b/gen/layouts/FloorPlan409-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan409-openable.json b/gen/layouts/FloorPlan409-openable.json new file mode 100644 index 000000000..2d50fa700 --- /dev/null +++ b/gen/layouts/FloorPlan409-openable.json @@ -0,0 +1,62 @@ +{ + "CounterTop|+00.46|+00.79|+02.76": [ + -0.25, + 2.75, + 90, + 30 + ], + "Drawer|+00.44|+00.32|+02.19": [ + -0.75, + 1.75, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+02.57": [ + -0.75, + 2.0, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+02.94": [ + -0.75, + 2.25, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+03.31": [ + -0.75, + 2.75, + 0, + 30 + ], + "Drawer|+00.44|+00.62|+02.19": [ + -0.5, + 1.75, + 0, + 30 + ], + "Drawer|+00.44|+00.62|+03.31": [ + -0.5, + 2.75, + 0, + 30 + ], + "GarbageCan|+00.41|-00.03|+03.73": [ + -0.25, + 3.25, + 0, + 30 + ], + "Sink|+00.50|+00.66|+02.76|SinkBasin": [ + -0.25, + 3.25, + 180, + 30 + ], + "Toilet|+00.27|+00.00|+01.46": [ + -0.25, + 2.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan410-layout.npy b/gen/layouts/FloorPlan410-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..09bb6c6c837541d12eb2b3566f010329e8edca29 GIT binary patch literal 1408 zcmbWxu}Z^07{Kwfl%s@F+Be7+g%09W#Nj44#l^u%icN74E2+4MPvHZZ$8vD6CiyKl z`Yqv??{fKnUf*8b+#Q9t@Lp}|{X0vz_ z+x{Hu;Ze5NW3Pwxu%1ck|D%WXa2)=}dRPzZVLhyeXT$wP3f)XI>$BI#F*~o%ULWgY zeXNgX!~N3~y3xn_SRcoB_%8KNefIiTAM0a%ycq7E4foG8>$lg>`gxLlA2aKBUO($+ z{j8t$&r|3|KkH}xTnv4zpJTSyZ?B*Avwqgk`WGp5qo4J&e%8fJZ=#%4Lb1b+W3^z-`m>gH}IyoL92*iIh0^1LW7MrUPJl%sL?+BMJj<8Ijgy}xXp zChhwDJYQd&|M*9@}Gk zY>(}+J+`;X_ShcVV|#3m?eQ}G{!nlJKDNj9*dE(sd)%AGH@!NZVH(d~9nV#|54#^P zvhVKayZf>GvHNjI59{yN@q<3=vp(x{$_LilOMN}oV?EYmz5T4mdaTEKtk=(atjBt+ N$FuZ5=6Ui#{R?)Il9d1e literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan411-objects.json b/gen/layouts/FloorPlan411-objects.json new file mode 100644 index 000000000..f4d477e9d --- /dev/null +++ b/gen/layouts/FloorPlan411-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan411-openable.json b/gen/layouts/FloorPlan411-openable.json new file mode 100644 index 000000000..96017b5b6 --- /dev/null +++ b/gen/layouts/FloorPlan411-openable.json @@ -0,0 +1,62 @@ +{ + "Bathtub|-01.06|+00.30|+00.43|BathtubBasin": [ + -0.75, + 1.25, + 180, + 30 + ], + "CounterTop|+00.73|+00.70|+01.96": [ + 0.0, + 2.0, + 90, + 30 + ], + "CounterTop|-00.30|+00.16|+00.53": [ + -0.25, + 1.5, + 180, + 30 + ], + "Drawer|+00.41|+00.32|+01.49": [ + -1.0, + 2.0, + 90, + 0 + ], + "Drawer|+00.41|+00.32|+02.42": [ + -1.0, + 2.0, + 90, + 0 + ], + "Drawer|+00.41|+00.55|+01.49": [ + -0.75, + 1.75, + 90, + 0 + ], + "Drawer|+00.41|+00.55|+02.42": [ + -0.75, + 1.75, + 90, + 0 + ], + "GarbageCan|+00.71|-00.03|+03.11": [ + 0.5, + 3.5, + 180, + 30 + ], + "Sink|+00.81|+00.70|+01.92|SinkBasin": [ + 0.0, + 2.5, + 180, + 30 + ], + "Toilet|-02.23|+00.00|+01.63": [ + -2.0, + 2.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan412-layout.npy b/gen/layouts/FloorPlan412-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..1d3c8327df573213544b1cf76075351bfd9cf1d7 GIT binary patch literal 784 zcmbV{Ar8Vo5JeY48q!m&TS#gk2tr8ea1aavMH*UyAe6KOLpTKoqDSZvDv<~T0zqNt znU##0zCW|CyVu!bI$t)_Nu5oc9)PCeUV+X2&eruhJ||zWF5D3A+vt$g z+!^!&-R}naqW>*l{mLtBf8A_vIsBBI`NLsP_Sxe+>~{9?un#xI2P=o)@_**;z3|_i z_rUmJ{4jnPU*-5W!-VAJ8ypPU(}CX zv%TLv)X&Y{)yD6`a^|3w<>Ecc5+pER{{j8t$ zvwlwXf%Wfa{j8t$vwqgkefl5Rcgns)w&x(*!}hQ}Y!BPR_OLx{58E@z_OLx{58K1` Vusv)K+r#!uvpsAN+r#!us~?!{m^1(Y literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan413-objects.json b/gen/layouts/FloorPlan413-objects.json new file mode 100644 index 000000000..0e607a3e9 --- /dev/null +++ b/gen/layouts/FloorPlan413-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Dresser", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan413-openable.json b/gen/layouts/FloorPlan413-openable.json new file mode 100644 index 000000000..528e315b4 --- /dev/null +++ b/gen/layouts/FloorPlan413-openable.json @@ -0,0 +1,92 @@ +{ + "Bathtub|-01.41|00.00|+00.56|BathtubBasin": [ + -0.75, + 1.0, + 270, + 30 + ], + "Cabinet|-01.61|+00.31|+02.49": [ + -0.75, + 3.25, + 180, + 30 + ], + "Cabinet|-01.61|+00.31|+03.11": [ + -0.75, + 2.5, + 0, + 30 + ], + "Cabinet|-01.61|+00.31|+03.14": [ + -0.75, + 2.75, + 0, + 30 + ], + "Cabinet|-01.61|+00.31|+03.75": [ + -0.75, + 3.0, + 0, + 30 + ], + "CounterTop|-01.80|+00.75|+03.12": [ + -1.25, + 3.0, + 270, + 30 + ], + "Drawer|+00.20|+00.16|+03.81": [ + -0.5, + 3.25, + 90, + 30 + ], + "Drawer|+00.20|+00.42|+03.81": [ + 0.75, + 3.25, + 0, + 30 + ], + "Drawer|+00.20|+00.68|+03.81": [ + -0.5, + 3.5, + 90, + 30 + ], + "Drawer|+00.20|+00.94|+03.81": [ + -0.5, + 3.5, + 90, + 30 + ], + "Dresser|+00.21|+00.00|+03.83": [ + 0.25, + 3.25, + 0, + 0 + ], + "GarbageCan|+00.93|-00.03|+03.76": [ + 0.25, + 3.25, + 0, + 30 + ], + "Sink|-01.83|+00.69|+02.78|SinkBasin": [ + -1.25, + 3.25, + 180, + 30 + ], + "Sink|-01.83|+00.69|+03.47|SinkBasin": [ + -1.25, + 3.0, + 0, + 30 + ], + "Toilet|-01.57|00.00|+01.82": [ + -1.25, + 2.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan414-layout.npy b/gen/layouts/FloorPlan414-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..aa82fa1bb4208248476699ac51afd89bd2596dc5 GIT binary patch literal 800 zcmbWxu?oU46oug^BE_f37KKj5K}4{Vo8sc&B*jJ?#7ZhI;#2rQ^>I3O=+L2qwducP zG)wp{Ip^lR*{!$xo_L6-igkK4YA)5{G*iA*r^MV%bUh>{*1!2Gx}>_9r|0OV8;_@f zFN29MU-I8G678uod*@4gSB^`^g=6xClgH$-_}D#V_ntgvKPHcPUpf0Q?=kyoXCG!C zCXdOB(EgkKm^>zr$@iT+CXdPEA`|Vw^bJBg=RcS}OdqBXlOJ|{49l1VyavA~qIQvLqWUf{|UZ33&=1D0!Te78Vv3#$><3 zTRP3*znuH;?7ZLJkM150(py@TNz;wna+S;V^s-dBOy})uTR%U}+ez~~zo}QO z^-Htmlk=^W1wZD; z{Foo}WB$Q9?T+`s{Foo}WBtS4r;qiqzI*6neXQ@E`dA<9OMR@5y$_c5V%j&ikL|}E Qj%nZAf0*-O-`T8w0KJ8raR2}S literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan415-objects.json b/gen/layouts/FloorPlan415-objects.json new file mode 100644 index 000000000..1e083ec30 --- /dev/null +++ b/gen/layouts/FloorPlan415-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Shelf", + "Dresser", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan415-openable.json b/gen/layouts/FloorPlan415-openable.json new file mode 100644 index 000000000..78d0f5817 --- /dev/null +++ b/gen/layouts/FloorPlan415-openable.json @@ -0,0 +1,68 @@ +{ + "Bathtub|-02.10|+00.53|-00.83|BathtubBasin": [ + -1.75, + -0.75, + 270, + 30 + ], + "CounterTop|-02.71|+01.03|-02.92": [ + -1.75, + -3.0, + 270, + 0 + ], + "Drawer|-00.23|+00.16|-03.40": [ + -1.25, + -2.75, + 180, + 30 + ], + "Drawer|-00.23|+00.42|-03.40": [ + -0.75, + -3.0, + 90, + 30 + ], + "Drawer|-00.23|+00.68|-03.40": [ + -0.75, + -3.0, + 90, + 30 + ], + "Drawer|-00.23|+00.94|-03.40": [ + -0.75, + -3.0, + 180, + 30 + ], + "Dresser|-00.20|+00.00|-03.40": [ + -0.75, + -3.25, + 90, + 0 + ], + "GarbageCan|-00.27|-00.03|-02.75": [ + -1.0, + -3.25, + 0, + 30 + ], + "Shelf|-02.58|+00.40|-02.92": [ + -1.25, + -2.75, + 270, + 0 + ], + "Sink|-00.31|+00.00|-02.08|SinkBasin": [ + -0.75, + -1.5, + 90, + 30 + ], + "Toilet|-00.41|00.00|-00.55": [ + -0.75, + -1.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan416-layout.npy b/gen/layouts/FloorPlan416-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..97b05a34c900c4c1a2fa707d19b7fd11afd6c743 GIT binary patch literal 992 zcmbWzF-pWx6a~<)h)7nEE()ncK}2vWJH^JrN`jMN3UMS68*vpb$Sq_EQ(8_jg@uKq z`KNiMzX>OK_r4_WS2vf}w_E8Yy;jq+{@x9>To* zSMHN%d6wt#D^p^9-=UB7u|C$v`qE^4;{8}3>tp%tkY{<8XZf9wXL*+Aln?9M4SlSS n^|3x4@_%Oid!e88vwqgk`gxi6v3*6@$M&&(Y#-al_7#&KZ*++( literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan416-objects.json b/gen/layouts/FloorPlan416-objects.json new file mode 100644 index 000000000..c8adda2c6 --- /dev/null +++ b/gen/layouts/FloorPlan416-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan416-openable.json b/gen/layouts/FloorPlan416-openable.json new file mode 100644 index 000000000..afd6d54d0 --- /dev/null +++ b/gen/layouts/FloorPlan416-openable.json @@ -0,0 +1,44 @@ +{ + "CounterTop|-01.61|+00.70|+02.83": [ + -1.0, + 2.25, + 270, + 30 + ], + "Drawer|-01.34|+00.30|+02.13": [ + -0.75, + 1.75, + 270, + 30 + ], + "Drawer|-01.34|+00.30|+03.33": [ + -0.75, + 3.0, + 270, + 30 + ], + "GarbageCan|-01.74|-00.03|+01.27": [ + -1.0, + 1.75, + 180, + 30 + ], + "Sink|-01.70|+00.62|+02.28|SinkBasin": [ + -1.0, + 2.75, + 180, + 30 + ], + "Sink|-01.70|+00.62|+03.37|SinkBasin": [ + -1.0, + 3.0, + 0, + 30 + ], + "Toilet|-01.55|+00.00|+00.69": [ + -1.25, + 1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan417-layout.npy b/gen/layouts/FloorPlan417-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0e72aa5468376744d0ad51f9911a9e4a1cf2be8d GIT binary patch literal 1088 zcmbWxu};EJ6oBDE3U>X;-y&US=~M~`6}h{e3Z+S=gVf*REzs%Gpm31*VR*7@AvIv z^<3|LdU;-^i?cFq(tn>}@%OyH9_HZfF!`kONB6!T-m_VB@8kUL&fD*Tzk)x5^_};B ztRFiZr@p;D>$5)Vv%Y)%7yFLm)VJ4Xeb#4v_vo`eJI8VA+v~GF>pQ2<`mE3H;W+i} g^;zF{`mE3Ttk3S{IQ8xI?e$ro^;w_wS%;7F2ek>!DF6Tf literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan417-objects.json b/gen/layouts/FloorPlan417-objects.json new file mode 100644 index 000000000..6c7ccae54 --- /dev/null +++ b/gen/layouts/FloorPlan417-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan417-openable.json b/gen/layouts/FloorPlan417-openable.json new file mode 100644 index 000000000..111a6080f --- /dev/null +++ b/gen/layouts/FloorPlan417-openable.json @@ -0,0 +1,44 @@ +{ + "Cabinet|-02.50|+00.40|-01.24": [ + -1.75, + -1.5, + 0, + 30 + ], + "Cabinet|-02.50|+00.40|-02.21": [ + -2.0, + -1.5, + 270, + 30 + ], + "Cabinet|-02.51|+00.43|-00.29": [ + -1.75, + -1.0, + 0, + 30 + ], + "Cabinet|-02.51|+00.43|-01.26": [ + -1.75, + -2.0, + 0, + 30 + ], + "CounterTop|-02.75|+00.99|-01.24": [ + -2.25, + -1.5, + 270, + 30 + ], + "Sink|-02.91|+00.99|-00.73|SinkBasin": [ + -2.25, + -1.0, + 0, + 30 + ], + "Sink|-02.91|+00.99|-01.76|SinkBasin": [ + -2.25, + -1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan418-layout.npy b/gen/layouts/FloorPlan418-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3e47df778f8071a73ded546848c342dde1b5a976 GIT binary patch literal 864 zcmbW#u}Z^07{KvZq)6#Q+;$Z*l_FA{-4quGCkZyCgV>T37x5{4p!z5s9UUAT9IQ0I z!EbDq<9B!ej}Y>9eS39tcT_wVFL_qC4^5t?d@(=IWy)V`(-n$|MoAd$F|<> zw~K03?>w5Em1%rhrq^`nGbr}Y`+gaA>(A!Dzk|PmKZA>I&LGTV^VmGrpM;+EtY>{c z^sHw+>yJavdUn4T?z3~N@5|=c*RgvXSH1Vrv!3;=_Z{@CXFcov2YS}Cp7kHyf23zU M>)H9X>z!{mzctp3NB{r; literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan418-objects.json b/gen/layouts/FloorPlan418-objects.json new file mode 100644 index 000000000..6c7ccae54 --- /dev/null +++ b/gen/layouts/FloorPlan418-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan418-openable.json b/gen/layouts/FloorPlan418-openable.json new file mode 100644 index 000000000..fb4ef1367 --- /dev/null +++ b/gen/layouts/FloorPlan418-openable.json @@ -0,0 +1,44 @@ +{ + "Cabinet|-02.29|+00.32|-03.25": [ + -1.5, + -3.5, + 0, + 30 + ], + "Cabinet|-02.29|+00.32|-03.81": [ + -1.5, + -3.0, + 180, + 30 + ], + "Cabinet|-02.30|+00.35|-02.25": [ + -1.5, + -3.0, + 0, + 30 + ], + "CounterTop|-02.63|+00.84|-03.04": [ + -2.0, + -3.0, + 270, + 30 + ], + "GarbageCan|-00.46|-00.04|-03.77": [ + -1.25, + -3.25, + 180, + 30 + ], + "Sink|-02.66|+00.79|-03.07|SinkBasin": [ + -2.0, + -3.5, + 0, + 30 + ], + "Toilet|-00.45|+00.00|-03.05": [ + -1.0, + -3.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan419-layout.npy b/gen/layouts/FloorPlan419-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..191b53f1cfb6d90ecc8734f97572f8c9fded07b3 GIT binary patch literal 608 zcmbV`p$@_@6h#Y?uc#{|6$A_+XdDECK#_)ZK@hgIWM<(j_#pTcBocu@AQ)^XBu`Rv zbMEUq?POQRUvYQXw|daC z`l$as9rZoWbDix=oe#mxm6*fKU(Fu-FmsYQ%stt|GVkJ@n_zt0;~f|uEE69+K6-pG YKA1gN=C%1RJ$`!pFn$<6j0gVZ8}dbb$N&HU literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan419-objects.json b/gen/layouts/FloorPlan419-objects.json new file mode 100644 index 000000000..0a56e852a --- /dev/null +++ b/gen/layouts/FloorPlan419-objects.json @@ -0,0 +1,30 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan419-openable.json b/gen/layouts/FloorPlan419-openable.json new file mode 100644 index 000000000..46cace91d --- /dev/null +++ b/gen/layouts/FloorPlan419-openable.json @@ -0,0 +1,44 @@ +{ + "Bathtub|-00.98|-00.72|-02.93|BathtubBasin": [ + -1.25, + -2.25, + 180, + 30 + ], + "Drawer|-02.11|+00.16|-01.31": [ + -1.5, + -0.75, + 180, + 30 + ], + "Drawer|-02.11|+00.46|-01.31": [ + -1.75, + -0.75, + 180, + 30 + ], + "GarbageCan|-00.24|-00.03|-01.36": [ + -0.75, + -1.25, + 90, + 30 + ], + "SideTable|-02.18|00.00|-01.31": [ + -1.75, + -1.0, + 270, + 30 + ], + "Sink|-02.10|00.00|-02.03|SinkBasin": [ + -1.5, + -1.75, + 180, + 30 + ], + "Toilet|-00.47|+00.00|-01.88": [ + -0.75, + -1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan420-layout.npy b/gen/layouts/FloorPlan420-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3d239dd2e8222e42f8e0272eedc659e483177ba4 GIT binary patch literal 560 zcmbV{p$Y;)6h+7CSG+a~leQ>gwkcZ-CK=pW4C2a+SY*G#5As)xMuWj%aMe8sFFNIN zF7FnLS_~`M$_+Wf`2kXQ~j}OMH?_izm=`ZbnVZ8bd*2$ip LJw0BSJNTC`QxbM; literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan420-objects.json b/gen/layouts/FloorPlan420-objects.json new file mode 100644 index 000000000..9c3deeaff --- /dev/null +++ b/gen/layouts/FloorPlan420-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "HousePlant", + "SoapBar", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan420-openable.json b/gen/layouts/FloorPlan420-openable.json new file mode 100644 index 000000000..c23df54f5 --- /dev/null +++ b/gen/layouts/FloorPlan420-openable.json @@ -0,0 +1,32 @@ +{ + "Bathtub|-01.28|+00.28|-02.53|SinkBasin": [ + -1.25, + -1.75, + 180, + 30 + ], + "Drawer|-00.22|+00.78|-01.47": [ + -1.25, + -1.5, + 90, + 0 + ], + "SideTable|-00.15|+00.00|-01.47": [ + -0.5, + -1.0, + 90, + 30 + ], + "Sink|-02.27|+00.00|-01.52|SinkBasin": [ + -1.75, + -1.25, + 180, + 30 + ], + "Toilet|-02.05|+00.00|-00.36": [ + -1.5, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan421-layout.npy b/gen/layouts/FloorPlan421-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..bed785d7e97473038a76e7b8d4ebb2ca0e9451bf GIT binary patch literal 608 zcmbW!F%AJi6oBC&BC^>-OgAJ`2#tuuRyv|lsAOYjqYx`Iq7kQXAXic-6bg&|3$OH= zm;YtHYA&q9i zb|GJT&po_0yY+TI5O?uViO!Ek&81qTGZjdcX69z%%ONv~{@t(QbFSO_{1jhx>v0$c zaykj*Q~rBKqC5Vl{}#*sJ9O+h7LJ>DpCey8_U(M>?8ofK?8ofK?8lYu!}L{7AEpn} shv~!gVft`s`*Gozd~N@SJSLCHW9A#1XC5<;nHQ1h4)d6I&w2NvFV&=L)c^nh literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan422-objects.json b/gen/layouts/FloorPlan422-objects.json new file mode 100644 index 000000000..eed1f5ea6 --- /dev/null +++ b/gen/layouts/FloorPlan422-objects.json @@ -0,0 +1,33 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Shelf", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan422-openable.json b/gen/layouts/FloorPlan422-openable.json new file mode 100644 index 000000000..3da31098e --- /dev/null +++ b/gen/layouts/FloorPlan422-openable.json @@ -0,0 +1,86 @@ +{ + "Bathtub|-03.45|+00.18|+01.03|BathtubBasin": [ + -2.75, + 1.25, + 270, + 30 + ], + "Cabinet|-00.61|+00.46|+00.52": [ + -1.25, + 1.25, + 90, + 30 + ], + "Cabinet|-00.61|+01.99|+00.52": [ + -1.25, + 1.0, + 180, + -30 + ], + "Cabinet|-01.89|+00.44|+01.98": [ + -1.25, + 1.75, + 0, + 30 + ], + "Cabinet|-01.89|+01.88|+02.39": [ + -1.25, + 2.25, + 270, + 0 + ], + "Cabinet|-02.34|+00.46|+00.52": [ + -1.75, + 1.0, + 180, + 30 + ], + "CounterTop|-00.81|+00.09|+00.29": [ + -1.25, + 1.0, + 180, + 0 + ], + "CounterTop|-01.92|+00.00|+00.29": [ + -2.0, + 0.75, + 180, + 30 + ], + "Drawer|-00.81|+00.96|+00.38": [ + -1.5, + 1.0, + 90, + 0 + ], + "Drawer|-02.03|+00.94|+02.19": [ + -1.5, + 1.5, + 0, + 0 + ], + "Shelf|-02.03|+01.18|+02.19": [ + -1.25, + 1.75, + 270, + 0 + ], + "Shelf|-02.12|+01.39|+02.19": [ + -1.25, + 2.25, + 270, + -30 + ], + "Sink|-01.93|+00.77|+00.33|SinkBasin": [ + -2.5, + 0.75, + 90, + 30 + ], + "Toilet|-00.46|00.00|+02.26": [ + -1.0, + 2.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan423-layout.npy b/gen/layouts/FloorPlan423-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d85f2115b41423b356fe2292116cfad34b885d51 GIT binary patch literal 1008 zcmbWyu}Z^G0EW?P2|;{{Y*EN06hs6wxhXCVP7-WN2eFcfi}(~ika--(4jnRNur~J$ zW;Dy?B+d7ypEq~cxAzC(ExhN8x_xZ&^DMtup5;ZBFW1d$Q$0Vdn??P5|EhXw>)ri! zRlU?ZAJ6ASc6w4|AK8Deqp-h{Zalv)$8$Dun0Wa5`+M(iChxQN+56nb9v{ZNZS18J z+wTkEq?%>>WG^F literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan423-objects.json b/gen/layouts/FloorPlan423-objects.json new file mode 100644 index 000000000..3045886b8 --- /dev/null +++ b/gen/layouts/FloorPlan423-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan423-openable.json b/gen/layouts/FloorPlan423-openable.json new file mode 100644 index 000000000..21ea750b4 --- /dev/null +++ b/gen/layouts/FloorPlan423-openable.json @@ -0,0 +1,86 @@ +{ + "Bathtub|-03.59|+00.11|+01.52|BathtubBasin": [ + -3.0, + 1.25, + 270, + 30 + ], + "CounterTop|-00.28|+00.79|+01.93": [ + -1.0, + 2.25, + 90, + 30 + ], + "CounterTop|-02.54|+00.81|+00.28": [ + -1.75, + 0.75, + 270, + 30 + ], + "Drawer|-00.33|+00.32|+01.72": [ + -1.5, + 2.25, + 180, + 30 + ], + "Drawer|-00.33|+00.32|+02.16": [ + -1.5, + 2.75, + 180, + 30 + ], + "Drawer|-00.33|+00.32|+02.59": [ + -1.5, + 2.0, + 0, + 30 + ], + "Drawer|-00.33|+00.32|+03.03": [ + -1.5, + 2.5, + 0, + 30 + ], + "Drawer|-00.33|+00.62|+02.59": [ + -1.25, + 2.0, + 0, + 30 + ], + "Drawer|-00.33|+00.62|+03.03": [ + -1.25, + 2.5, + 0, + 30 + ], + "Drawer|-02.25|+00.32|+00.28": [ + -1.5, + 1.5, + 270, + 30 + ], + "Drawer|-02.84|+00.32|+00.28": [ + -2.25, + 1.5, + 270, + 30 + ], + "GarbageCan|-01.75|+00.00|+00.23": [ + -2.0, + 0.75, + 180, + 30 + ], + "Sink|-00.26|+00.66|+01.92|SinkBasin": [ + -1.0, + 2.5, + 180, + 30 + ], + "Toilet|-02.84|+00.00|+02.76": [ + -2.25, + 2.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan424-layout.npy b/gen/layouts/FloorPlan424-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..75490b8ceb8bb454345ff51e5d26c3a52caeaa75 GIT binary patch literal 736 zcmbWyF$%&k6oBCOA*0NZijFg;8U(`zNF8vcXnVS1Pz rrq>odOb^q;^f0}S=wW)89;S!s1)_)PVS1PzrWcAHribZadSUVgAzEoo literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan424-objects.json b/gen/layouts/FloorPlan424-objects.json new file mode 100644 index 000000000..f3988fd79 --- /dev/null +++ b/gen/layouts/FloorPlan424-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan424-openable.json b/gen/layouts/FloorPlan424-openable.json new file mode 100644 index 000000000..645647bca --- /dev/null +++ b/gen/layouts/FloorPlan424-openable.json @@ -0,0 +1,56 @@ +{ + "Cabinet|-00.49|+00.41|+02.06": [ + -1.25, + 1.75, + 0, + 30 + ], + "Cabinet|-00.49|+00.41|+02.86": [ + -1.25, + 2.5, + 0, + 30 + ], + "Cabinet|-00.50|+00.38|+02.84": [ + -1.25, + 2.25, + 0, + 30 + ], + "Cabinet|-00.50|+00.38|+03.65": [ + -1.25, + 3.0, + 0, + 30 + ], + "CounterTop|-00.26|+00.93|+02.84": [ + -0.75, + 2.5, + 90, + 30 + ], + "GarbageCan|-02.16|00.00|+03.76": [ + -1.75, + 3.25, + 0, + 30 + ], + "Sink|-00.30|+00.80|+02.42|SinkBasin": [ + -0.75, + 2.0, + 0, + 30 + ], + "Sink|-00.30|+00.80|+03.26|SinkBasin": [ + -0.75, + 3.0, + 90, + 30 + ], + "Toilet|-00.54|+00.00|+01.49": [ + -1.0, + 2.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan425-layout.npy b/gen/layouts/FloorPlan425-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a966f44e54c18b5049044de741c61d322c271a71 GIT binary patch literal 512 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I$7COQg6nmP)#3giMV1~B-rA431JhtMz3_z%$dF!c-$sOn*Sn0go=W*!q% zJxm_PzW_BK#)qkAK~oRo!_>q0F!gL`>S27CdKe$3o&!xij1N-}8F21LSSBNl^68f{|`q!o*J3J=7ibnMu{(81tO&v$S} zcacwf&+m8YI$KQV%bGcvvkRkiow$K@!?@>s>*9TKOoH8NpM=rp`6Sq;(ffJ22@cWQ zt#049owjc;_TSSq-_y8PzuD;5xwtOxu_rFneawAq)cxnpd=KwS<%e>ioGWL_p7cFN zRS(~X*$=ZHWADm08vMfQ~&?~ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan426-objects.json b/gen/layouts/FloorPlan426-objects.json new file mode 100644 index 000000000..f904e7328 --- /dev/null +++ b/gen/layouts/FloorPlan426-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan426-openable.json b/gen/layouts/FloorPlan426-openable.json new file mode 100644 index 000000000..c1f4edd71 --- /dev/null +++ b/gen/layouts/FloorPlan426-openable.json @@ -0,0 +1,68 @@ +{ + "Bathtub|-03.50|+00.15|+00.94|BathtubBasin": [ + -2.75, + 1.25, + 270, + 30 + ], + "CounterTop|-01.85|+00.00|+00.34": [ + -1.0, + 1.0, + 180, + 30 + ], + "Drawer|-00.29|+00.31|+00.31": [ + -1.0, + 1.5, + 90, + 30 + ], + "Drawer|-00.29|+00.61|+00.31": [ + -0.75, + 1.25, + 90, + 30 + ], + "Drawer|-00.81|+00.31|+00.31": [ + -1.5, + 1.5, + 90, + 30 + ], + "Drawer|-00.81|+00.61|+00.31": [ + -1.25, + 1.25, + 90, + 30 + ], + "Drawer|-01.32|+00.61|+00.31": [ + -0.75, + 1.25, + 270, + 30 + ], + "Drawer|-01.84|+00.31|+00.31": [ + -1.25, + 1.5, + 270, + 30 + ], + "Drawer|-01.84|+00.61|+00.31": [ + -1.25, + 1.25, + 270, + 30 + ], + "Sink|-00.46|-00.01|+03.05|SinkBasin": [ + -0.75, + 2.5, + 0, + 30 + ], + "Toilet|-01.84|+00.00|+02.50": [ + -1.25, + 1.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan427-layout.npy b/gen/layouts/FloorPlan427-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..78286bb77b667bbcec62afd1092b54c87bccbc53 GIT binary patch literal 992 zcmbW!F-pWh6oBCvd?>#gFscu9+{O{T={?_bcy1VWKZwD8_#-i| zu^tb($9=H=SLm}o>$5)Vvp(yy{&(oJKI^kS>$5)Vvwk1?tk3$a&-y&%@6Gz`e-F8@ f$9k;CdaTEN?z7%H^jMG0XY<*7Hh;|XJs;;kiPn^8 literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan427-objects.json b/gen/layouts/FloorPlan427-objects.json new file mode 100644 index 000000000..44d2e8f28 --- /dev/null +++ b/gen/layouts/FloorPlan427-objects.json @@ -0,0 +1,32 @@ +[ + "PaperTowelRoll", + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan427-openable.json b/gen/layouts/FloorPlan427-openable.json new file mode 100644 index 000000000..5cbe082d7 --- /dev/null +++ b/gen/layouts/FloorPlan427-openable.json @@ -0,0 +1,80 @@ +{ + "Bathtub|-03.71|+00.34|+00.64|BathtubBasin": [ + -2.75, + 1.0, + 270, + 30 + ], + "CounterTop|-02.80|+00.00|-00.59": [ + -2.0, + 0.0, + 180, + 30 + ], + "Drawer|-01.44|+00.27|-00.62": [ + -2.0, + 0.5, + 90, + 30 + ], + "Drawer|-01.44|+00.53|-00.62": [ + -1.0, + 0.25, + 270, + 30 + ], + "Drawer|-01.89|+00.27|-00.62": [ + -2.5, + 0.5, + 90, + 30 + ], + "Drawer|-01.89|+00.53|-00.62": [ + -2.5, + 0.75, + 180, + 0 + ], + "Drawer|-02.34|+00.27|-00.62": [ + -1.75, + 0.5, + 270, + 30 + ], + "Drawer|-02.34|+00.53|-00.62": [ + -2.75, + 1.0, + 180, + 0 + ], + "Drawer|-02.79|+00.27|-00.62": [ + -2.25, + 0.5, + 270, + 30 + ], + "Drawer|-02.79|+00.53|-00.62": [ + -2.25, + 0.25, + 270, + 30 + ], + "GarbageCan|-01.56|00.00|+01.91": [ + -1.0, + 1.75, + 270, + 30 + ], + "Sink|-01.92|+00.44|+02.03|SinkBasin": [ + -2.25, + 1.5, + 0, + 30 + ], + "Toilet|-00.72|+00.00|-00.31": [ + -1.25, + 0.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan428-layout.npy b/gen/layouts/FloorPlan428-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0c26e75d4946aea3c1fb14ac01ba8043cc639973 GIT binary patch literal 992 zcmbWyu}Z^07{KvUM5Oc~ZaalcVnIY`CO5^!!AXKmaS$tsxQI{T1NjPlgpM5@938A) zeuFo9OZZ*#ef;xwadm!qy%nCrOPaO)ZI@1BI-MVyYc?ysEUUNReX*AJ)`h@*6;cGHO+b$;(Lwx8{1`*}IdH@qsmF05y-=wUsqhxM=?*28*O m59=8fJ*Y^LY5SY58prB*dQ{c1n$Eh1uDQRSb(8jc|FpU5 z+x32b+sxawcMlKhxW8A&=lI`e6n>u9MOsJ8w7zBUWUmT4@4fTe#d&s~huq_kA0AH9 z2J3Gv)4q9FpY=I?Dg@SN{mr7!`mE3Ttk3$P=(9fSvp(yy{%5{d_rvW5F9R9E-T(jq literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan429-objects.json b/gen/layouts/FloorPlan429-objects.json new file mode 100644 index 000000000..07f7757be --- /dev/null +++ b/gen/layouts/FloorPlan429-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan429-openable.json b/gen/layouts/FloorPlan429-openable.json new file mode 100644 index 000000000..850de0b4b --- /dev/null +++ b/gen/layouts/FloorPlan429-openable.json @@ -0,0 +1,38 @@ +{ + "Bathtub|-02.12|-00.09|-03.12|BathtubBasin": [ + -1.0, + -2.75, + 270, + 30 + ], + "GarbageCan|-00.53|-00.05|-03.76": [ + -1.0, + -3.0, + 90, + 30 + ], + "SideTable|+00.78|+00.00|-00.67": [ + 0.25, + -1.25, + 90, + 30 + ], + "SideTable|+00.79|+00.00|-01.82": [ + 0.25, + -2.25, + 90, + 30 + ], + "SideTable|-01.53|+00.00|-00.17": [ + -1.0, + -0.75, + 0, + 30 + ], + "Toilet|+00.00|00.00|-03.44": [ + -0.5, + -3.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan430-layout.npy b/gen/layouts/FloorPlan430-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..720285dc4d0a54d810408c8459f90780d16de92f GIT binary patch literal 1760 zcmbW#p-#h46oBDEP&`FlA(?2RgN2>#x}RJm z>-Cmi*2``5vR>B9x;U@;no*oAwkzvnecbu};(dM2^|3zI$NF}To@LyxhxKq5J*tQ{thxM@kQx`q{@9g(uecZ+G t$8EAc=lZxw&+BupZ=L#BAM0a%+{QfC$NJd(KF#Mo?ql=Wd^W!y{Qy7=9rXYJ literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan430-objects.json b/gen/layouts/FloorPlan430-objects.json new file mode 100644 index 000000000..4ad43db6d --- /dev/null +++ b/gen/layouts/FloorPlan430-objects.json @@ -0,0 +1,35 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Footstool", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan430-openable.json b/gen/layouts/FloorPlan430-openable.json new file mode 100644 index 000000000..ebaf98b49 --- /dev/null +++ b/gen/layouts/FloorPlan430-openable.json @@ -0,0 +1,50 @@ +{ + "CounterTop|+00.20|+00.43|-02.01": [ + 0.0, + -1.25, + 180, + 30 + ], + "Drawer|+00.30|+00.30|-01.82": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.30|+00.49|-01.82": [ + -0.25, + -1.0, + 90, + 30 + ], + "Drawer|+00.30|+00.68|-01.82": [ + -0.25, + -1.0, + 90, + 30 + ], + "Drawer|+00.30|+00.83|-01.82": [ + -0.25, + -0.75, + 180, + 0 + ], + "SideTable|-02.85|+00.01|+01.51": [ + -2.25, + 1.5, + 270, + 30 + ], + "Sink|-02.80|+00.33|+00.76|SinkBasin": [ + -2.25, + 1.25, + 180, + 30 + ], + "Toilet|-00.06|+00.01|+01.84": [ + -0.75, + 1.25, + 0, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan5-layout.npy b/gen/layouts/FloorPlan5-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..86f544e919f217f153d279dff30bf3b77c6ed5c8 GIT binary patch literal 1680 zcmbW%Jx;?w5QgCeAqr06&LFv>;YUcJq65)TP@#x8qCf;Whz4;A4wNhS2q{y#NRfhq z5bqO-DRDD;cPI1CXC?W%xx2o--%0Q3qa4-K$EG|l%8T)7Srz4Y(!4dpmxoC+s(;U~ zhR@S_eLj5}zSe6#JUgk1vwR8@RtsX?s8T+dmJy2;2qc>t_8N zKFo*P{CUiW`7j^mTLd5G!+e+z^I<;Br?%OP`7j^m!+e+zt30vtZO`-j#C(_!^I`qw z>c{%AemV7H{dj4=T=koyAM3}f{5h&~J@_TA?#qweKFb|GZKIigb`LKLgJ}e*Z oay}lvYb-BrL%;mn`n+a literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan5-objects.json b/gen/layouts/FloorPlan5-objects.json new file mode 100644 index 000000000..67be1200d --- /dev/null +++ b/gen/layouts/FloorPlan5-objects.json @@ -0,0 +1,47 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Statue", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Vase", + "Mug", + "CounterTop", + "ShelvingUnit", + "Spatula", + "Shelf", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan5-openable.json b/gen/layouts/FloorPlan5-openable.json new file mode 100644 index 000000000..c4b6ea81e --- /dev/null +++ b/gen/layouts/FloorPlan5-openable.json @@ -0,0 +1,152 @@ +{ + "Cabinet|+00.20|+02.02|-02.00": [ + 0.75, + -1.25, + 180, + 0 + ], + "Cabinet|+01.18|+02.02|-02.00": [ + 0.75, + -1.25, + 180, + 0 + ], + "Cabinet|+01.39|+00.47|-01.06": [ + 0.75, + -1.25, + 90, + 30 + ], + "Cabinet|+01.74|+02.02|-02.00": [ + 1.0, + -1.25, + 180, + 0 + ], + "Cabinet|+01.75|+02.02|-01.03": [ + 1.0, + -1.25, + 90, + 0 + ], + "Cabinet|-00.42|+00.37|-00.01": [ + 0.5, + -0.75, + 270, + 30 + ], + "Cabinet|-00.45|+00.47|-00.01": [ + 0.0, + -1.0, + 270, + 30 + ], + "Cabinet|-00.82|+00.47|-01.69": [ + 0.0, + -0.75, + 270, + 30 + ], + "Cabinet|-00.84|+00.47|-00.05": [ + -0.25, + -0.75, + 0, + 30 + ], + "Cabinet|-00.84|+00.47|-01.67": [ + 0.0, + -1.0, + 180, + 30 + ], + "Cabinet|-01.15|+02.02|+00.38": [ + -0.5, + -0.25, + 270, + 0 + ], + "Cabinet|-01.15|+02.02|-00.77": [ + -0.5, + -0.5, + 270, + 0 + ], + "Cabinet|-01.15|+02.02|-01.98": [ + -0.5, + -1.25, + 270, + 0 + ], + "CounterTop|+01.16|+00.95|-02.01": [ + 1.0, + -1.25, + 180, + 30 + ], + "CounterTop|-00.63|+01.17|+00.57": [ + 0.0, + 1.25, + 180, + 0 + ], + "CounterTop|-00.67|+00.95|+00.19": [ + -0.5, + -0.25, + 0, + 30 + ], + "Drawer|-00.07|+00.75|-00.01": [ + 0.5, + -1.0, + 0, + 0 + ], + "Drawer|-00.45|+00.75|-00.01": [ + -0.25, + -0.5, + 270, + 30 + ], + "Drawer|-00.82|+00.75|-01.69": [ + -0.5, + -0.75, + 180, + 0 + ], + "Fridge|+01.98|+00.00|-00.54": [ + 1.0, + -0.5, + 90, + 30 + ], + "GarbageCan|+01.92|-00.01|+00.14": [ + 1.25, + 0.25, + 90, + 30 + ], + "Microwave|+01.83|+00.90|-01.35": [ + 1.0, + -1.0, + 90, + 0 + ], + "Shelf|+02.76|+00.55|+00.15": [ + 2.25, + 0.75, + 180, + 30 + ], + "Shelf|+02.76|+00.88|+00.14": [ + 2.25, + 1.0, + 180, + 0 + ], + "Sink|-00.12|+00.88|-02.01|SinkBasin": [ + -0.5, + -1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan6-layout.npy b/gen/layouts/FloorPlan6-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..eb8f5923c6598a033abf4ed882d8bcd55e632ffa GIT binary patch literal 2176 zcmbW$Ax;BP5C-4}L2-(83rP)C4I!Zl2f-jvq@isPgpw`65Kh5?xWXO*iCj@pQ2})4 zs~E|emv7iN|I7j(S2vf}w|nKayw%g$^1i80tNLs{ss~j)Uo*OrB@IJ~|nW2G#I*P`y|Gd=AU@`Tp$Bb(~+x>Z_>dvrBdTyr&3#ikAI_)# z>iTmV{kh++6mHM^3V$VkC!0^MJy;*kr}@;|n2*iJ=411*`M8UD*}QVi%jRYGIG^TK zH!qu)&CBLx^XY3oHXoah_2GP)Z+!{%f2vHA2dA9wNlWBarItUqt!zI*am9_z>Y zv3}mukM-j&z6ZOnulwviyU*^cyU*^kdz{Zz%%`ruy8gV1@5%OJd8{wzQ{Fn}kjL^^ z9?N5SERQ!a|0dC<*_`L$MRSn%iB+RERVaGhyDMv|9@`N z`z4;;&*QtYeb_#1AGQzM=U`m6kMGC!Vf(Os*gk9@?o&$PHuhoruzlD*Y@dVi54~bm AHUIzs literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan6-objects.json b/gen/layouts/FloorPlan6-objects.json new file mode 100644 index 000000000..b584a4738 --- /dev/null +++ b/gen/layouts/FloorPlan6-objects.json @@ -0,0 +1,42 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Stool", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan6-openable.json b/gen/layouts/FloorPlan6-openable.json new file mode 100644 index 000000000..8337ad36d --- /dev/null +++ b/gen/layouts/FloorPlan6-openable.json @@ -0,0 +1,164 @@ +{ + "Cabinet|+00.15|+02.01|-01.60": [ + 0.75, + -1.0, + 180, + 0 + ], + "Cabinet|+01.57|+02.01|+00.47": [ + 0.75, + 0.25, + 90, + 0 + ], + "Cabinet|+01.57|+02.01|-00.78": [ + 0.75, + -1.0, + 90, + 0 + ], + "Cabinet|-02.15|+00.40|+00.64": [ + -1.5, + 0.0, + 0, + 30 + ], + "Cabinet|-02.15|+00.40|+00.70": [ + -1.25, + 1.5, + 180, + 30 + ], + "Cabinet|-02.15|+00.40|+01.58": [ + -1.25, + 0.75, + 0, + 30 + ], + "Cabinet|-02.15|+00.40|-00.24": [ + -1.5, + -0.5, + 0, + 30 + ], + "Cabinet|-02.29|+01.97|-01.33": [ + -1.5, + -1.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+00.36": [ + -1.5, + -0.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+00.41": [ + -1.75, + 1.0, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+01.64": [ + -1.75, + 1.0, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+01.69": [ + -1.75, + 2.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+02.93": [ + -1.75, + 2.25, + 270, + 0 + ], + "Cabinet|-02.45|+02.15|-00.29": [ + -1.5, + 0.0, + 270, + 0 + ], + "Cabinet|-02.45|+02.15|-01.28": [ + -1.25, + -0.75, + 270, + 0 + ], + "CounterTop|+00.47|+00.95|-01.63": [ + 0.75, + -1.0, + 180, + 30 + ], + "CounterTop|+01.59|+00.95|+00.41": [ + 1.0, + 0.75, + 90, + 30 + ], + "CounterTop|-00.36|+00.95|+01.09": [ + 0.5, + 1.25, + 270, + 30 + ], + "CounterTop|-01.49|+00.95|+01.32": [ + -1.75, + 0.5, + 270, + 30 + ], + "Drawer|-02.28|+00.79|+00.44": [ + -1.5, + 0.0, + 0, + 30 + ], + "Drawer|-02.28|+00.79|+00.90": [ + -1.5, + 0.5, + 0, + 30 + ], + "Drawer|-02.28|+00.79|+01.37": [ + -1.5, + 1.75, + 180, + 30 + ], + "Drawer|-02.28|+00.79|-00.03": [ + -1.5, + -0.5, + 0, + 30 + ], + "Fridge|-02.48|+00.00|-00.78": [ + -1.5, + -0.75, + 270, + 30 + ], + "GarbageCan|+01.65|00.00|+00.68": [ + 1.0, + 1.0, + 90, + 30 + ], + "Microwave|-02.58|+00.90|+02.44": [ + -1.75, + 2.5, + 270, + 0 + ], + "Sink|+01.38|+00.81|-01.27|SinkBasin": [ + 0.75, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan7-layout.npy b/gen/layouts/FloorPlan7-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..17b04ef444e20b59a55d337e4b7bd3e6962f4de5 GIT binary patch literal 4352 zcmbW%F>Vt<6b9g7WvwF1hj3?*Ttx_>2#KxeKr|Fo$Rds?P=ahkgE$2T@*crQNSSgA z7cN{7^5$D9ugo@+Z)SF9-v11LKYV)s@$<9ttNdPEuD4$|i;MZ<&DHD0a=y5_+5FtB zuD{%DF4zC(->trH*Z1?=Z>t~cdp|#a^>R5sf3ckZnLqKFmWOB7$9UMqI88oFZj-$~ zr1#nT?0xqBU3#Cr&)(xa-q!D!-zS&)jO%Y>f^U=Wl859&vU=P@o~#~L50CfQ#l6fM z)x+xHeZ3E>ht^H+@W zH7j41FUyzZJGzg*)G1$EcE# zf0jSXpXJZ;AKl0I)ggbDKeuVW{H@EM<o(te-sV<9qI*f2@Dp zrv3V7UH@4B_*C;{{bT*(A???{alQ6~)x~*~uX*`$)0KyZ<;(JA`LcXjzRr~|%a_|e z&S&|ud|AGHs(JA-S-#fg#qP~{l$ZIYOZQEdm;Lf$d9l2lBQKT*%Y)^?^5A35gXO`_ cSJ$ME`q+8wJa!&CkDbTP^E>lB_Pt5>5B$3_i~s-t literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan7-objects.json b/gen/layouts/FloorPlan7-objects.json new file mode 100644 index 000000000..02e51c382 --- /dev/null +++ b/gen/layouts/FloorPlan7-objects.json @@ -0,0 +1,50 @@ +[ + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Statue", + "PepperShaker", + "Pan", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "Book", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "HousePlant", + "Potato", + "Vase", + "Mug", + "CounterTop", + "ShelvingUnit", + "Spatula", + "Shelf", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan7-openable.json b/gen/layouts/FloorPlan7-openable.json new file mode 100644 index 000000000..f0f78366b --- /dev/null +++ b/gen/layouts/FloorPlan7-openable.json @@ -0,0 +1,146 @@ +{ + "Cabinet|+00.38|+00.37|-01.24": [ + -0.25, + -0.5, + 90, + 30 + ], + "Cabinet|+00.52|+02.01|-01.54": [ + 0.25, + -0.75, + 180, + 0 + ], + "Cabinet|+00.78|+00.37|-01.24": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|+01.45|+02.26|-01.54": [ + 1.0, + -0.75, + 180, + 0 + ], + "Cabinet|+01.78|+00.37|-01.24": [ + 1.25, + -0.5, + 90, + 30 + ], + "Cabinet|+01.78|+02.01|-01.54": [ + 1.25, + -0.75, + 180, + 0 + ], + "Cabinet|-00.57|+00.37|-01.24": [ + 0.25, + -0.5, + 270, + 30 + ], + "Cabinet|-00.71|+02.01|-01.54": [ + -0.5, + -0.75, + 180, + 0 + ], + "Cabinet|-01.48|+00.37|-01.24": [ + -0.75, + -0.25, + 180, + 30 + ], + "Cabinet|-01.67|+02.01|-01.54": [ + -1.0, + -0.75, + 180, + 0 + ], + "Cabinet|-02.17|+02.01|-01.54": [ + -2.75, + -1.0, + 90, + 0 + ], + "Cabinet|-02.22|+00.37|-01.87": [ + -2.75, + -1.25, + 90, + 30 + ], + "CounterTop|+01.65|+00.95|-01.53": [ + 1.25, + -0.75, + 90, + 30 + ], + "CounterTop|-01.87|+00.95|-00.61": [ + -2.5, + 0.5, + 90, + 30 + ], + "DiningTable|-02.66|+00.00|+03.21": [ + -2.5, + 2.25, + 0, + 30 + ], + "Drawer|+00.60|+00.68|-01.40": [ + 1.0, + -0.75, + 270, + 30 + ], + "Drawer|-01.64|+00.68|-00.93": [ + -1.0, + -0.25, + 270, + 30 + ], + "Drawer|-02.06|+00.68|-01.58": [ + -3.0, + -1.0, + 180, + 30 + ], + "Fridge|-00.04|+00.00|+02.18": [ + 0.0, + 1.25, + 0, + 30 + ], + "GarbageCan|-00.87|00.00|+02.14": [ + -1.75, + 1.5, + 0, + 30 + ], + "Microwave|+01.15|+01.66|-01.61": [ + 0.75, + -0.75, + 180, + 0 + ], + "Shelf|+03.73|+00.55|+01.67": [ + 2.5, + 1.75, + 90, + 0 + ], + "Shelf|+03.73|+00.88|+01.67": [ + 3.25, + 1.75, + 90, + 30 + ], + "Sink|+00.02|+00.77|-01.71|SinkBasin": [ + -0.75, + -0.75, + 180, + 0 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan8-layout.npy b/gen/layouts/FloorPlan8-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..f768a488c36e0b0a939b69a01e5488a6c8e1cd65 GIT binary patch literal 2768 zcmbW$ze*!f6u{xDgcLr-bfb`Fgl@bI&ivyq^C#ySUsbPvyD2p3eWy+M}jDzWLpbn)c>?_Bfl|UER;F zr(gT0liT_9bASGC@-Y4M{*PZjN6q2EsCjAr^V%!l*Kk?a^`fr43J>BwyWgk#yc^GR zNp_C=d3}#_?U%T?JETD)wA7?@0<0o`QGc}`(X3ge0C1!)!)Ou`E0)D%xCl2 zd^Vq*%Xu~5{whANee>CTHlNLB^VuBEtNHKoJ(YWxcGI z^>R!rte5q&-reZa%X(Qa>t(&Hm-TXqi}kWz);k!N?@KT1WxcGI^|D^p%XMlgte5q2 eS=Kj(B9dbv(5h4r%D;rIgsV3kz> literal 0 HcmV?d00001 diff --git a/gen/layouts/FloorPlan8-objects.json b/gen/layouts/FloorPlan8-objects.json new file mode 100644 index 000000000..12da9582d --- /dev/null +++ b/gen/layouts/FloorPlan8-objects.json @@ -0,0 +1,46 @@ +[ + "ButterKnife", + "Drawer", + "Lettuce", + "Toaster", + "StoveKnob", + "SaltShaker", + "Pot", + "Microwave", + "Stool", + "HousePlant", + "Floor", + "Apple", + "Fork", + "Cabinet", + "StoveBurner", + "LightSwitch", + "CoffeeMachine", + "SprayBottle", + "SinkBasin", + "Knife", + "Fridge", + "Spatula", + "Mug", + "Faucet", + "Ladle", + "SoapBottle", + "Sink", + "CounterTop", + "Kettle", + "Tomato", + "Cup", + "Egg", + "GarbageCan", + "Bowl", + "Bread", + "DishSponge", + "PepperShaker", + "Pen", + "Bottle", + "Plate", + "Window", + "Pan", + "Spoon", + "Potato" +] \ No newline at end of file diff --git a/gen/layouts/FloorPlan8-openable.json b/gen/layouts/FloorPlan8-openable.json new file mode 100644 index 000000000..a327a281a --- /dev/null +++ b/gen/layouts/FloorPlan8-openable.json @@ -0,0 +1,170 @@ +{ + "Cabinet|+00.49|+02.06|-01.69": [ + 0.5, + -0.75, + 180, + 0 + ], + "Cabinet|+00.83|+00.40|-01.39": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|+00.67": [ + 0.0, + 0.0, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|-00.55": [ + 0.0, + -0.75, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|-01.37": [ + 0.0, + -1.0, + 90, + 30 + ], + "Cabinet|+01.16|+02.06|-00.34": [ + 0.5, + -0.75, + 90, + 0 + ], + "Cabinet|+01.16|+02.06|-01.02": [ + 0.25, + -1.0, + 90, + 0 + ], + "Cabinet|-00.19|+02.06|-01.69": [ + 0.0, + -1.0, + 180, + 0 + ], + "Cabinet|-00.20|+00.40|-01.39": [ + -0.5, + -0.5, + 90, + 30 + ], + "Cabinet|-00.24|+00.40|-01.39": [ + -0.75, + -0.75, + 90, + 30 + ], + "Cabinet|-00.82|+00.40|-01.39": [ + -1.25, + -0.5, + 90, + 30 + ], + "Cabinet|-00.82|+02.06|-01.69": [ + 0.0, + -1.0, + 180, + 0 + ], + "Cabinet|-00.87|+02.01|-01.69": [ + -1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-01.61|+02.01|-01.69": [ + -2.0, + -0.5, + 180, + 0 + ], + "Cabinet|-01.66|+02.06|-01.68": [ + -2.25, + -1.0, + 180, + 0 + ], + "Cabinet|-01.67|+00.40|-01.39": [ + -2.0, + -1.0, + 180, + 30 + ], + "Cabinet|-02.24|+00.40|-01.39": [ + -2.5, + -1.0, + 180, + 30 + ], + "CounterTop|+01.17|+00.95|-00.65": [ + 0.5, + -0.75, + 90, + 30 + ], + "CounterTop|+01.50|+01.20|-00.66": [ + 0.5, + -1.0, + 90, + 0 + ], + "CounterTop|-01.97|+00.95|-01.71": [ + -2.5, + -1.25, + 90, + 30 + ], + "CounterTop|-02.10|+00.95|+00.29": [ + -1.5, + -0.25, + 0, + 30 + ], + "Drawer|+00.59|+00.75|-01.39": [ + 0.0, + -0.75, + 90, + 30 + ], + "Drawer|+00.86|+00.75|+00.43": [ + 0.0, + 1.0, + 90, + 0 + ], + "Drawer|+00.87|+00.75|-01.14": [ + 0.0, + -1.0, + 90, + 0 + ], + "Fridge|+01.42|+00.00|+02.10": [ + 0.5, + 2.0, + 90, + 0 + ], + "GarbageCan|+01.34|+00.02|+01.04": [ + 0.5, + 0.5, + 0, + 30 + ], + "Microwave|+01.42|+01.15|+00.02": [ + 0.5, + 0.5, + 90, + 0 + ], + "Sink|+00.16|+00.82|-01.80|SinkBasin": [ + 0.5, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/gen/layouts/FloorPlan9-layout.npy b/gen/layouts/FloorPlan9-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..bd4533e3927e8b5b7557a060a87f6091d6716e6a GIT binary patch literal 1360 zcmbWzp-#h46b9hSLI~k0>I%seW`vMz3J1X;P^4j95QLGIUjvA*o7FV+|9i}l6&V) 0: + lock.acquire() + scene_num = all_scene_numbers.pop() + lock.release() + fn = os.path.join('layouts', ('FloorPlan%d-layout.npy') % scene_num) + if os.path.isfile(fn): + print("file %s already exists; skipping this floorplan" % fn) + continue + + openable_json_file = os.path.join('layouts', ('FloorPlan%d-openable.json') % scene_num) + scene_objs_json_file = os.path.join('layouts', ('FloorPlan%d-objects.json') % scene_num) + + scene_name = ('FloorPlan%d') % scene_num + print('Running ' + scene_name) + event = env.reset(scene_name, + render_image=False, + render_depth_image=False, + render_class_image=False, + render_object_image=True) + agent_height = event.metadata['agent']['position']['y'] + + scene_objs = list(set([obj['objectType'] for obj in event.metadata['objects']])) + with open(scene_objs_json_file, 'w') as sof: + json.dump(scene_objs, sof, sort_keys=True, indent=4) + + # Get all the reachable points through Unity for this step size. + event = env.step(dict(action='GetReachablePositions', + gridSize=constants.AGENT_STEP_SIZE / constants.RECORD_SMOOTHING_FACTOR)) + if event.metadata['actionReturn'] is None: + print("ERROR: scene %d 'GetReachablePositions' returns None" % scene_num) + else: + reachable_points = set() + for point in event.metadata['actionReturn']: + reachable_points.add((point['x'], point['z'])) + print("scene %d got %d reachable points, now checking" % (scene_num, len(reachable_points))) + + # Pick up a small object to use in testing whether points are good for openable objects. + open_test_objs = {'CD', 'CellPhone', 'Cloth', 'CreditCard', 'DishSponge', 'Fork', + 'KeyChain', 'Pen', 'Pencil', 'SoapBar', 'Spoon', 'Watch'} + good_obj_point = None + good_obj_point = get_obj(env, open_test_objs, reachable_points, agent_height, scene_name, good_obj_point) + + + best_open_point = {} # map from object names to the best point from which they can be successfully opened + best_sem_coverage = {} # number of pixels in the semantic map of the receptacle at the existing best openpt + checked_points = set() + scene_receptacles = set() + for point in reachable_points: + point_is_valid = True + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + } + event = env.step(action) + if event.metadata['lastActionSuccess']: + for horizon in [-30, 0, 30]: + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': 0, + 'horizon': horizon + } + event = env.step(action) + if not event.metadata['lastActionSuccess']: + point_is_valid = False + break + for rotation in range(3): + action = {'action': 'RotateLeft'} + event = env.step(action) + if not event.metadata['lastActionSuccess']: + point_is_valid = False + break + if not point_is_valid: + break + if point_is_valid: + checked_points.add(point) + else: + continue + + # Check whether we can open objects from here in any direction with any tilt. + for rotation in range(4): + # First try up, then down, then return to the horizon before moving again. + for horizon in [-30, 0, 30]: + + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': rotation * 90, + 'horizon': horizon + } + event = env.step(action) + for obj in event.metadata['objects']: + if (obj['visible'] and obj['objectId'] and obj['receptacle'] and not obj['pickupable'] + and obj['objectType'] in constants.VAL_RECEPTACLE_OBJECTS): + obj_name = obj['objectId'] + obj_point = (obj['position']['x'], obj['position']['y']) + scene_receptacles.add(obj_name) + + # Go ahead and attempt to close the object from this position if it's open. + if obj['openable'] and obj['isOpen']: + close_action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(close_action) + + point_to_recep = np.linalg.norm(np.array(point) - np.array(obj_point)) + if len(env.last_event.metadata['inventoryObjects']) > 0: + inv_obj = env.last_event.metadata['inventoryObjects'][0]['objectId'] + else: + inv_obj = None + + # Heuristic implemented in task_game_state has agent 0.5 or farther in agent space. + heuristic_far_enough_from_recep = 0.5 < point_to_recep + # Ensure this point affords a larger view according to the semantic segmentation + # of the receptacle than the existing. + point_sem_coverage = get_mask_of_obj(env, obj['objectId']) + if point_sem_coverage is None: + use_sem_heuristic = False + better_sem_covereage = False + else: + use_sem_heuristic = True + better_sem_covereage = (obj_name not in best_sem_coverage or + best_sem_coverage[obj_name] is None or + point_sem_coverage > best_sem_coverage[obj_name]) + # Ensure that this point is farther away than our existing best candidate. + # We'd like to open each receptacle from as far away as possible while retaining + # the ability to pick/place from it. + farther_than_existing_good_point = (obj_name not in best_open_point or + point_to_recep > + np.linalg.norm( + np.array(point) - + np.array(best_open_point[obj_name][:2]))) + # If we don't have an inventory object, though, we'll fall back to the heuristic + # of being able to open/close as _close_ as possible. + closer_than_existing_good_point = (obj_name not in best_open_point or + point_to_recep < + np.linalg.norm( + np.array(point) - + np.array(best_open_point[obj_name][:2]))) + # Semantic segmentation heuristic. + if ((use_sem_heuristic and heuristic_far_enough_from_recep and better_sem_covereage) + or (not use_sem_heuristic and + # Distance heuristics. + (heuristic_far_enough_from_recep and + (inv_obj and farther_than_existing_good_point) or + (not inv_obj and closer_than_existing_good_point)))): + if obj['openable']: + action = {'action': 'OpenObject', + 'objectId': obj['objectId']} + event = env.step(action) + if not obj['openable'] or event.metadata['lastActionSuccess']: + # We can open the object, so try placing our small inventory obj inside. + # If it can be placed inside and retrieved, then this is a safe point. + action = {'action': 'PutObject', + 'objectId': obj['objectId'], + 'forceAction': True, + 'placeStationary': True} + if inv_obj: + event = env.step(action) + if inv_obj is None or event.metadata['lastActionSuccess']: + action = {'action': 'PickupObject', + 'objectId': inv_obj} + if inv_obj: + event = env.step(action) + if inv_obj is None or event.metadata['lastActionSuccess']: + + # Finally, ensure we can also close the receptacle. + if obj['openable']: + action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(action) + if not obj['openable'] or event.metadata['lastActionSuccess']: + + # We can put/pick our inv object into the receptacle from here. + # We have already ensured this point is farther than any + # existing best, so this is the new best. + best_open_point[obj_name] = [point[0], point[1], rotation * 90, horizon] + best_sem_coverage[obj_name] = point_sem_coverage + + # We could not retrieve our inv object, so we need to go get another one + else: + good_obj_point = get_obj(env, open_test_objs, reachable_points, + agent_height, scene_name, good_obj_point) + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': rotation * 90, + 'horizon': horizon + } + event = env.step(action) + + # Regardless of what happened up there, try to close the receptacle again if + # it remained open. + if obj['isOpen']: + action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(action) + + essential_objs = [] + if scene_num in constants.SCENE_TYPE["Kitchen"]: + essential_objs.extend(["Microwave", "Fridge"]) + for obj in essential_objs: + if not np.any([obj in obj_key for obj_key in best_open_point]): + print("WARNING: Essential object %s has no open points in scene %d" % (obj, scene_num)) + + print("scene %d found open/pick/place/close positions for %d/%d receptacle objects" % + (scene_num, len(best_open_point), len(scene_receptacles))) + with open(openable_json_file, 'w') as f: + json.dump(best_open_point, f, sort_keys=True, indent=4) + + print("scene %d reachable %d, checked %d; taking intersection" % + (scene_num, len(reachable_points), len(checked_points))) + + points = np.array(list(checked_points))[:, :2] + points = points[np.lexsort((points[:, 0], points[:, 1])), :] + np.save(fn, points) + + env.stop() + print('Done') + + +threads = [] +for n in range(N_PROCS): + thread = threading.Thread(target=run, args=(n,)) + threads.append(thread) + thread.start() + time.sleep(1) diff --git a/gen/planner/__init__.py b/gen/planner/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/gen/planner/domains/PutTaskExtended_domain.pddl b/gen/planner/domains/PutTaskExtended_domain.pddl new file mode 100644 index 000000000..60280d713 --- /dev/null +++ b/gen/planner/domains/PutTaskExtended_domain.pddl @@ -0,0 +1,302 @@ +;; Specification in PDDL1 of the Extended Task domain + +(define (domain put_task) + (:requirements + :adl + ) + (:types + agent + location + receptacle + object + rtype + otype + ) + + + (:predicates + (atLocation ?a - agent ?l - location) ; true if the agent is at the location + (receptacleAtLocation ?r - receptacle ?l - location) ; true if the receptacle is at the location (constant) + (objectAtLocation ?o - object ?l - location) ; true if the object is at the location + (openable ?r - receptacle) ; true if a receptacle is openable + (opened ?r - receptacle) ; true if a receptacle is opened + (inReceptacle ?o - object ?r - receptacle) ; object ?o is in receptacle ?r + (isReceptacleObject ?o - object) ; true if the object can have things put inside it + (inReceptacleObject ?innerObject - object ?outerObject - object) ; object ?innerObject is inside object ?outerObject + (wasInReceptacle ?o - object ?r - receptacle) ; object ?o was or is in receptacle ?r now or some time in the past + ;(checked ?r - receptacle) ; whether the receptacle has been looked inside/visited + (receptacleType ?r - receptacle ?t - rtype) ; the type of receptacle (Cabinet vs Cabinet|01|2...) + (objectType ?o - object ?t - otype) ; the type of object (Apple vs Apple|01|2...) + (holds ?a - agent ?o - object) ; object ?o is held by agent ?a + (holdsAny ?a - agent) ; agent ?a holds an object + (holdsAnyReceptacleObject ?a - agent) ; agent ?a holds a receptacle object + ;(full ?r - receptacle) ; true if the receptacle has no remaining space + (isClean ?o - object) ; true if the object has been clean in sink + (cleanable ?o - object) ; true if the object can be placed in a sink + (isHot ?o - object) ; true if the object has been heated up + (heatable ?o - object) ; true if the object can be heated up in a microwave + (isCool ?o - object) ; true if the object has been cooled + (coolable ?o - object) ; true if the object can be cooled in the fridge + (toggleable ?o - object) ; true if the object can be turned on/off + (isOn ?o - object) ; true if the object is on + (isToggled ?o - object) ; true if the object has been toggled + (sliceable ?o - object) ; true if the object can be sliced + (isSliced ?o - object) ; true if the object is sliced + ) + + (:functions + (distance ?from ?to) + (totalCost) + ) + +;; All actions are specified such that the final arguments are the ones used +;; for performing actions in Unity. + +;; agent goes to receptacle + (:action GotoLocation + :parameters (?a - agent ?lStart - location ?lEnd - location) + :precondition (and + (atLocation ?a ?lStart) + (forall (?re - receptacle) + (not (opened ?re)) + ) + ) + :effect (and + (atLocation ?a ?lEnd) + (not (atLocation ?a ?lStart)) + (increase (totalCost) (distance ?lStart ?lEnd)) + ) + ) + +;; agent opens receptacle + (:action OpenObject + :parameters (?a - agent ?l - location ?r - receptacle) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (openable ?r) + (forall (?re - receptacle) + (not (opened ?re)) + ) + ) + :effect (and + (opened ?r) + (increase (totalCost) 1) + ) + ) +;; agent closes receptacle + (:action CloseObject + :parameters (?a - agent ?al - location ?r - receptacle) + :precondition (and + (atLocation ?a ?al) + (receptacleAtLocation ?r ?al) + (openable ?r) + (opened ?r) + ) + :effect (and + (not (opened ?r)) + (increase (totalCost) 1) + ) + + ) + +;; agent picks up object + (:action PickupObjectInReceptacle1 + :parameters (?a - agent ?l - location ?o - object ?r - receptacle) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (inReceptacle ?o ?r) + (not (holdsAny ?a)) + ) + :effect (and + (forall (?re - receptacle) + (not (inReceptacle ?o ?re)) + ) + (not (objectAtLocation ?o ?l)) + (holds ?a ?o) + (holdsAny ?a) + (increase (totalCost) 1) + ) + ) + +;; agent picks up object not in a receptacle + (:action PickupObjectNoReceptacle + :parameters (?a - agent ?l - location ?o - object) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (forall (?r - receptacle) + (not (inReceptacle ?o ?r)) + ) + (not (holdsAny ?a)) + ) + :effect (and + (not (objectAtLocation ?o ?l)) + (holds ?a ?o) + (holdsAny ?a) + (increase (totalCost) 1) + ) + ) + +;; agent puts down an object in a receptacle + (:action PutObjectInReceptacle1 + :parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle) ;?rt - rtype) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (objectType ?o ?ot) + (holds ?a ?o) + (not (holdsAnyReceptacleObject ?a)) + ) + :effect (and + (inReceptacle ?o ?r) + (not (holds ?a ?o)) + (not (holdsAny ?a)) + (increase (totalCost) 1) + (objectAtLocation ?o ?l) + ) + ) + +;; agent puts down an object + (:action PutObjectInReceptacleObject1 + :parameters (?a - agent ?l - location ?ot - otype ?o - object ?outerO - object ?outerR - receptacle) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?outerO ?l) + (isReceptacleObject ?outerO) + (not (isReceptacleObject ?o)) + (objectType ?o ?ot) + (holds ?a ?o) + (not (holdsAnyReceptacleObject ?a)) + (inReceptacle ?outerO ?outerR) + ) + :effect (and + (inReceptacleObject ?o ?outerO) + (inReceptacle ?o ?outerR) + (not (holds ?a ?o)) + (not (holdsAny ?a)) + (increase (totalCost) 1) + (objectAtLocation ?o ?l) + ) + ) + +;; agent puts down a receptacle object in a receptacle + (:action PutReceptacleObjectInReceptacle1 + :parameters (?a - agent ?l - location ?ot - otype ?outerO - object ?r - receptacle) ; ?rt - rtype) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (objectType ?outerO ?ot) + (holds ?a ?outerO) + (holdsAnyReceptacleObject ?a) + (isReceptacleObject ?outerO) + ) + :effect (and + (forall (?obj - object) + (when (holds ?a ?obj) + (and + (not (holds ?a ?obj)) + (objectAtLocation ?obj ?l) + (inReceptacle ?obj ?r) + ) + ) + ) + (not (holdsAny ?a)) + (not (holdsAnyReceptacleObject ?a)) + (increase (totalCost) 1) + ) + ) + +;; agent cleans some object + (:action CleanObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (receptacleType ?r SinkBasinType) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isClean ?o) + ) + ) + + +;; agent heats-up some object + (:action HeatObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (or + (receptacleType ?r MicrowaveType) + ) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isHot ?o) + ) + ) + +;; agent cools some object + (:action CoolObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (or + (receptacleType ?r FridgeType) + ) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isCool ?o) + ) + ) + + +;; agent toggle object + (:action ToggleObject + :parameters (?a - agent ?l - location ?o - object) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (toggleable ?o) + ) + :effect (and + (increase (totalCost) 5) + (when (isOn ?o) + (not (isOn ?o))) + (when (not (isOn ?o)) + (isOn ?o)) + (isToggled ?o) + ) + ) + + +;; agent slices some object with a knife + (:action SliceObject + :parameters (?a - agent ?l - location ?co - object ?ko - object) + :precondition + (and + (or + (objectType ?ko KnifeType) + (objectType ?ko ButterKnifeType) + ) + (atLocation ?a ?l) + (objectAtLocation ?co ?l) + (sliceable ?co) + (holds ?a ?ko) + ) + :effect (and + (increase (totalCost) 5) + (isSliced ?co) + ) + ) + + +) diff --git a/gen/planner/ff_planner_handler.py b/gen/planner/ff_planner_handler.py new file mode 100644 index 000000000..50937c677 --- /dev/null +++ b/gen/planner/ff_planner_handler.py @@ -0,0 +1,252 @@ +import pdb +import ast +import multiprocessing +import re +import shlex +import subprocess +import time + +import constants +from utils import game_util +from utils import py_util + +DEBUG = False + +CAPS_ACTION_TO_PLAN_ACTION = { + 'GOTOLOCATION': 'GotoLocation', + 'SCAN': 'Scan', + 'OPENOBJECT': 'OpenObject', + 'CLOSEOBJECT': 'CloseObject', + 'PICKUPOBJECT': 'PickupObject', + 'PICKUPOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', + 'PICKUPOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', + 'PICKUPRECEPTACLEOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', + 'PICKUPRECEPTACLEOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', + 'PICKUPOBJECTINOBJECT1': 'PickupObjectInObject', + 'PICKUPOBJECTINOBJECT2': 'PickupObjectInObject', + 'PUTOBJECTINRECEPTACLE1': 'PutObjectInReceptacle', + 'PUTOBJECTINRECEPTACLE2': 'PutObjectInReceptacle', + 'PUTOBJECTINRECEPTACLEOBJECT1': 'PutObjectInReceptacleObject', + 'PUTOBJECTINRECEPTACLEOBJECT2': 'PutObjectInReceptacleObject', + 'PUTRECEPTACLEOBJECTINRECEPTACLE1': 'PutReceptacleObjectInReceptacle', + 'PUTRECEPTACLEOBJECTINRECEPTACLE2': 'PutReceptacleObjectInReceptacle', + 'PICKUPOBJECTNORECEPTACLE': 'PickupObjectNoReceptacle', + 'PUTOBJECT': 'PutObject', + 'CLEANOBJECT': 'CleanObject', + 'HEATOBJECT': 'HeatObject', + 'TOGGLEOBJECT': 'ToggleObject', + 'COOLOBJECT': 'CoolObject', + 'SLICEOBJECT': 'SliceObject', + 'REACH-GOAL': 'End' +} + +LOWER_TO_FULL = {name.lower(): name for name in constants.OBJECTS} + + +def lower_to_full(input_str): + arr = input_str.split('|') + new_arr = [] + for item in arr: + if item in LOWER_TO_FULL: + new_arr.append(LOWER_TO_FULL[item]) + else: + new_arr.append(item) + return '|'.join(new_arr) + + + +def parse_action_arg(action_arg): + action_arg = action_arg.lower() + action_arg = py_util.multireplace(action_arg, + {'_minus_': '-', + '-': '#', + '_bar_': '|', + '_plus_': '+', + '_dot_': '.', + '_comma_': ','}) + action_arg = lower_to_full(action_arg) + return action_arg + + +def parse_line(line): + line = re.sub(r'^\s*step|\d+:\s*', '', line) + line = line.strip() + line_args = line.split(' ') + if line_args[0] not in CAPS_ACTION_TO_PLAN_ACTION: + return None + action = CAPS_ACTION_TO_PLAN_ACTION[line_args[0]] + if action == 'End': + return {'action': 'End', 'value': 1} + action_dict = {'action': action} + line_args = line_args[1:] # Remove action name from line_args + + if action in {'GotoLocation', 'Scan'}: + action_arg = line_args[2].lower() + action_arg = py_util.multireplace(action_arg, + {'_minus_': '-', + '-': '#', + '_bar_': '|', + '_plus_': '+', + '_dot_': '.', + '_comma_': ','}) + action_dict['location'] = action_arg + elif action in {'OpenObject', 'CloseObject', 'ToggleObject'}: + action_dict['objectId'] = parse_action_arg(line_args[2]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'HeatObject', 'CoolObject'}: + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'PickupObjectInReceptacle', 'PickupObjectNoReceptacle'}: + action_dict['action'] = 'PickupObject' + action_dict['objectId'] = parse_action_arg(line_args[2]) + if action == 'PickupObjectInReceptacle': + action_dict['receptacleObjectId'] = parse_action_arg(line_args[3]) + elif action in {'SliceObject'}: + action_dict['objectId'] = parse_action_arg(line_args[2]) + elif action in {'CleanObject'}: + action_dict['objectId'] = parse_action_arg(line_args[3]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'PutObjectInReceptacle', + 'PutObjectInReceptacleObject', + 'PutReceptacleObjectInReceptacle'}: + action_dict['action'] = 'PutObject' + action_dict['objectId'] = parse_action_arg(line_args[3]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[4]) + elif action in {'PickupObjectInObject'}: + action_dict['action'] = 'PickupObject' + + + return action_dict + + +def parse_plan(lines): + plan = [] + for line in lines: + action_dict = parse_line(line) + if action_dict is not None: + plan.append(action_dict) + return plan + + +def parse_plan_from_file(self, path): + lines = [line for line in open(path)] + return self.parse_plan(lines) + + +def get_plan_from_file(args): + domain, filepath, solver_type = args + + start_t = time.time() + try: + command = ('ff_planner/ff ' + '-o %s ' + '-s %d ' + '-f %s ' % (domain, solver_type, filepath)) + if DEBUG: + print(command) + planner_output = subprocess.check_output(shlex.split(command), timeout=30) + except subprocess.CalledProcessError as error: + # Plan is done + output_str = error.output.decode('utf-8') + if DEBUG: + print('output', output_str) + if ('goal can be simplified to FALSE' in output_str or + "won't get here: simplify, non logical" in output_str): + return [{'action': 'End', 'value': 0}] + elif 'goal can be simplified to TRUE' in output_str: + return [{'action': 'End', 'value': 1}] + elif len(output_str) == 0: + # Usually indicates segfault with ffplanner + # This happens when the goal needs an object that hasn't been seen yet like + # Q: "is there an egg in the garbage can," but no garbage can has been seen. + print('Empty plan') + print('Seg Fault') + return [{'action': 'End', 'value': 0}] + else: + print('problem', filepath) + print(output_str) + print('Empty plan') + return [{'action': 'End', 'value': 0}] + except subprocess.TimeoutExpired: + print('timeout solver', solver_type, 'problem', filepath) + print('Empty plan') + return ['timeout', {'action': 'End', 'value': 0}] + unparsed_plan = planner_output.decode('utf-8').split('\n') + if DEBUG: + print('unparsed', '\n'.join(unparsed_plan)) + parsed_plan = parse_plan(unparsed_plan) + if constants.DEBUG: + print('planned %s in %.5f, plan length %d solver type %d' % ( + filepath, time.time() - start_t, len(parsed_plan), solver_type)) + if len(parsed_plan) == 0: + parsed_plan = [{'action': 'End', 'value': 1}] + return parsed_plan + + +# Example of how to call ff +# /path/to/Metric-FF-v2.1/ff -o planner/domains/Question_domain.pddl -f planner/exists_problem.pddl +def get_plan_async(args): + domain, problem_id, solver_type = args + filepath = '%s/planner/generated_problems/problem_%s.pddl' % (constants.LOG_FILE, problem_id) + return get_plan_from_file((domain, filepath, solver_type)) + + +class PlanParser(object): + def __init__(self, domain_file_path): + self.domain = domain_file_path + self.problem_id = -1 + self.process_pool = multiprocessing.Pool(3) + #from multiprocessing.pool import ThreadPool + #self.process_pool = ThreadPool(3) + + def get_plan(self): + parsed_plans = self.process_pool.map(get_plan_async, zip([self.domain] * 3, [self.problem_id] * 3, range(3, 6))) + return self.find_best_plan(parsed_plans) + + def get_plan_from_file(self, domain_path, filepath): + parsed_plans = self.process_pool.map(get_plan_from_file, zip([domain_path] * 3, [filepath] * 3, range(3, 6))) + return self.find_best_plan(parsed_plans) + + # Unncessary, planner should be optimal. But the planner produces some weird actions + def clean_plan(self, plan): + cleaned_plan = list() + for i in range(len(plan)-1): + if not (plan[i]['action'] == 'GotoLocation' and plan[i+1]['action'] == 'GotoLocation'): + cleaned_plan.append(plan[i]) + cleaned_plan.append(plan[len(plan)-1]) + return cleaned_plan + + def find_best_plan(self, parsed_plans): + + if all([parsed_plan[0] == 'timeout' for parsed_plan in parsed_plans]): + parsed_plan = parsed_plans[0][1:] + else: + parsed_plans = [self.clean_plan(parsed_plan) for parsed_plan in parsed_plans if parsed_plan[0] != 'timeout'] + parsed_plan = min(parsed_plans, key=len) + + if constants.DEBUG: + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) + for pp, pl in enumerate(parsed_plan)])) + else: + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) + for pp, pl in enumerate(parsed_plan)])) + return parsed_plan + + +class SinglePlanParser(PlanParser): + def get_plan(self): + parsed_plan = get_plan_async([self.domain, self.problem_id, 3]) + return parsed_plan + + def get_plan_from_file(self, domain_path, filepath): + parsed_plan = get_plan_from_file([domain_path, filepath, 3]) + return parsed_plan + + +if __name__ == '__main__': + import sys + + DEBUG = constants.DEBUG + parser = PlanParser('planner/domains/PutTaskExtended_domain.pddl') + parser.problem_id = sys.argv[1] + result_plan = parser.get_plan() + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) for pp, pl in enumerate(result_plan)])) diff --git a/gen/planner/pddl.pdf b/gen/planner/pddl.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4acd4e0a5c03c58ab1177920fd70eaf3ce523982 GIT binary patch literal 196613 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

wc5{pc71>6lps{#4t; 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 literal 0 HcmV?d00001 diff --git a/gen/scripts/augment_trajectories.py b/gen/scripts/augment_trajectories.py new file mode 100644 index 000000000..19aeb9be2 --- /dev/null +++ b/gen/scripts/augment_trajectories.py @@ -0,0 +1,312 @@ +import os +import sys +sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) +sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) + +import json +import glob +import os +import constants +import cv2 +import shutil +import numpy as np +import argparse +import threading +import time +import copy +import random +from utils.video_util import VideoSaver +from utils.py_util import walklevel +from env.thor_env import ThorEnv + + +TRAJ_DATA_JSON_FILENAME = "traj_data.json" +AUGMENTED_TRAJ_DATA_JSON_FILENAME = "augmented_traj_data.json" + +ORIGINAL_IMAGES_FORLDER = "raw_images" +HIGH_RES_IMAGES_FOLDER = "high_res_images" +DEPTH_IMAGES_FOLDER = "depth_images" +INSTANCE_MASKS_FOLDER = "instance_masks" + +IMAGE_WIDTH = 600 +IMAGE_HEIGHT = 600 + +render_settings = dict() +render_settings['renderImage'] = True +render_settings['renderDepthImage'] = True +render_settings['renderObjectImage'] = True +render_settings['renderClassImage'] = True + +video_saver = VideoSaver() + + +def get_image_index(save_path): + return len(glob.glob(save_path + '/*.png')) + + +def save_image_with_delays(env, action, + save_path, direction=constants.BEFORE): + im_ind = get_image_index(save_path) + counts = constants.SAVE_FRAME_BEFORE_AND_AFTER_COUNTS[action['action']][direction] + for i in range(counts): + save_image(env.last_event, save_path) + env.noop() + return im_ind + + +def save_image(event, save_path): + # rgb + rgb_save_path = os.path.join(save_path, HIGH_RES_IMAGES_FOLDER) + rgb_image = event.frame[:, :, ::-1] + + # depth + depth_save_path = os.path.join(save_path, DEPTH_IMAGES_FOLDER) + depth_image = event.depth_frame + depth_image = depth_image * (255 / 10000) + depth_image = depth_image.astype(np.uint8) + + # masks + mask_save_path = os.path.join(save_path, INSTANCE_MASKS_FOLDER) + mask_image = event.instance_segmentation_frame + + # dump images + im_ind = get_image_index(rgb_save_path) + cv2.imwrite(rgb_save_path + '/%09d.png' % im_ind, rgb_image) + cv2.imwrite(depth_save_path + '/%09d.png' % im_ind, depth_image) + cv2.imwrite(mask_save_path + '/%09d.png' % im_ind, mask_image) + + return im_ind + + +def save_images_in_events(events, root_dir): + for event in events: + save_image(event, root_dir) + + +def clear_and_create_dir(path): + if os.path.exists(path): + shutil.rmtree(path) + os.mkdir(path) + + +def augment_traj(env, json_file): + # load json data + with open(json_file) as f: + traj_data = json.load(f) + + # make directories + root_dir = json_file.replace(TRAJ_DATA_JSON_FILENAME, "") + + orig_images_dir = os.path.join(root_dir, ORIGINAL_IMAGES_FORLDER) + high_res_images_dir = os.path.join(root_dir, HIGH_RES_IMAGES_FOLDER) + depth_images_dir = os.path.join(root_dir, DEPTH_IMAGES_FOLDER) + instance_masks_dir = os.path.join(root_dir, INSTANCE_MASKS_FOLDER) + augmented_json_file = os.path.join(root_dir, AUGMENTED_TRAJ_DATA_JSON_FILENAME) + + # fresh images list + traj_data['images'] = list() + + clear_and_create_dir(high_res_images_dir) + clear_and_create_dir(depth_images_dir) + clear_and_create_dir(instance_masks_dir) + + # scene setup + scene_num = traj_data['scene']['scene_num'] + object_poses = traj_data['scene']['object_poses'] + object_toggles = traj_data['scene']['object_toggles'] + dirty_and_empty = traj_data['scene']['dirty_and_empty'] + + # reset + scene_name = 'FloorPlan%d' % scene_num + env.reset(scene_name) + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + + env.step(dict(traj_data['scene']['init_action'])) + print("Task: %s" % (traj_data['template']['task_desc'])) + + # setup task + env.set_task(traj_data, args, reward_type='dense') + rewards = [] + + for ll_idx, ll_action in enumerate(traj_data['plan']['low_actions']): + # next cmd under the current hl_action + cmd = ll_action['api_action'] + hl_action = traj_data['plan']['high_pddl'][ll_action['high_idx']] + + # remove unnecessary keys + cmd = {k: cmd[k] for k in ['action', 'objectId', 'receptacleObjectId', 'placeStationary', 'forceAction'] if k in cmd} + + if "MoveAhead" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_move_ahead(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + elif "Rotate" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_rotate(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + elif "Look" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_look(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + # handle the exception for CoolObject tasks where the actual 'CoolObject' action is actually 'CloseObject' + # TODO: a proper fix for this issue + elif "CloseObject" in cmd['action'] and \ + "CoolObject" in hl_action['planner_action']['action'] and \ + "OpenObject" in traj_data['plan']['low_actions'][ll_idx + 1]['api_action']['action']: + if args.time_delays: + cool_action = hl_action['planner_action'] + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.BEFORE) + event = env.step(cmd) + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.MIDDLE) + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.AFTER) + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + else: + if args.time_delays: + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.BEFORE) + event = env.step(cmd) + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.MIDDLE) + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.AFTER) + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + # update image list + new_img_idx = get_image_index(high_res_images_dir) + last_img_idx = len(traj_data['images']) + num_new_images = new_img_idx - last_img_idx + for j in range(num_new_images): + traj_data['images'].append({ + 'low_idx': ll_idx, + 'high_idx': ll_action['high_idx'], + 'image_name': '%09d.png' % int(last_img_idx + j) + }) + + if not event.metadata['lastActionSuccess']: + raise Exception("Replay Failed: %s" % (env.last_event.metadata['errorMessage'])) + + reward, _ = env.get_transition_reward() + rewards.append(reward) + + # save 10 frames in the end as per the training data + for _ in range(10): + save_image(env.last_event, root_dir) + + # store color to object type dictionary + color_to_obj_id_type = {} + all_objects = env.last_event.metadata['objects'] + for color, object_id in env.last_event.color_to_object_id.items(): + for obj in all_objects: + if object_id == obj['objectId']: + color_to_obj_id_type[str(color)] = { + 'objectID': obj['objectId'], + 'objectType': obj['objectType'] + } + + augmented_traj_data = copy.deepcopy(traj_data) + augmented_traj_data['scene']['color_to_object_type'] = color_to_obj_id_type + augmented_traj_data['task'] = {'rewards': rewards, 'reward_upper_bound': sum(rewards)} + + with open(augmented_json_file, 'w') as aj: + json.dump(augmented_traj_data, aj, sort_keys=True, indent=4) + + # save video + images_path = os.path.join(high_res_images_dir, '*.png') + video_save_path = os.path.join(high_res_images_dir, 'high_res_video.mp4') + video_saver.save(images_path, video_save_path) + + # check if number of new images is the same as the number of original images + if args.smooth_nav and args.time_delays: + orig_img_count = get_image_index(high_res_images_dir) + new_img_count = get_image_index(orig_images_dir) + print ("Original Image Count %d, New Image Count %d" % (orig_img_count, new_img_count)) + if orig_img_count != new_img_count: + raise Exception("WARNING: the augmented sequence length doesn't match the original") + + +def run(): + ''' + replay loop + ''' + # start THOR env + env = ThorEnv(player_screen_width=IMAGE_WIDTH, + player_screen_height=IMAGE_HEIGHT) + + skipped_files = [] + + while len(traj_list) > 0: + lock.acquire() + json_file = traj_list.pop() + lock.release() + + print ("Augmenting: " + json_file) + try: + augment_traj(env, json_file) + except Exception as e: + import traceback + traceback.print_exc() + print ("Error: " + repr(e)) + print ("Skipping " + json_file) + skipped_files.append(json_file) + + env.stop() + print("Finished.") + + # skipped files + if len(skipped_files) > 0: + print("Skipped Files:") + print(skipped_files) + + +traj_list = [] +lock = threading.Lock() + +# parse arguments +parser = argparse.ArgumentParser() +parser.add_argument('--data_path', type=str, default="data/2.1.0") +parser.add_argument('--smooth_nav', dest='smooth_nav', action='store_true') +parser.add_argument('--time_delays', dest='time_delays', action='store_true') +parser.add_argument('--shuffle', dest='shuffle', action='store_true') +parser.add_argument('--num_threads', type=int, default=1) +parser.add_argument('--reward_config', type=str, default='../models/config/rewards.json') +args = parser.parse_args() + +# make a list of all the traj_data json files +for dir_name, subdir_list, file_list in walklevel(args.data_path, level=2): + if "trial_" in dir_name: + json_file = os.path.join(dir_name, TRAJ_DATA_JSON_FILENAME) + if not os.path.isfile(json_file): + continue + traj_list.append(json_file) + +# random shuffle +if args.shuffle: + random.shuffle(traj_list) + +# start threads +threads = [] +for n in range(args.num_threads): + thread = threading.Thread(target=run) + threads.append(thread) + thread.start() + time.sleep(1) \ No newline at end of file diff --git a/gen/scripts/generate_trajectories.py b/gen/scripts/generate_trajectories.py new file mode 100644 index 000000000..5e67ce0e8 --- /dev/null +++ b/gen/scripts/generate_trajectories.py @@ -0,0 +1,752 @@ +import os +import sys +sys.path.append(os.path.join('/Users/jiasenl/Code/alfred')) +sys.path.append(os.path.join('/Users/jiasenl/Code/alfred', 'gen')) + +import time +import multiprocessing as mp +import json +import random +import shutil +import argparse +import numpy as np +import pandas as pd +from collections import OrderedDict +from datetime import datetime +import glob +import constants +from agents.deterministic_planner_agent import DeterministicPlannerAgent +from env.thor_env import ThorEnv +from game_states.task_game_state_full_knowledge import TaskGameStateFullKnowledge +from utils.video_util import VideoSaver +from utils.dataset_management_util import load_successes_from_disk, load_fails_from_disk + +# params +RAW_IMAGES_FOLDER = 'raw_images/' +DATA_JSON_FILENAME = 'traj_data.json' +DEPTH_IMAGES_FOLDER = 'depth_images/' + +# video saver +video_saver = VideoSaver() + +# structures to help with constraint enforcement. +goal_to_required_variables = {"pick_and_place_simple": {"pickup", "receptacle", "scene"}, + "pick_two_obj_and_place": {"pickup", "receptacle", "scene"}, + "look_at_obj_in_light": {"pickup", "receptacle", "scene"}, + "pick_clean_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_heat_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_cool_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_and_place_with_movable_recep": {"pickup", "movable", "receptacle", "scene"}} +goal_to_pickup_type = {'pick_heat_then_place_in_recep': 'Heatable', + 'pick_cool_then_place_in_recep': 'Coolable', + 'pick_clean_then_place_in_recep': 'Cleanable'} +goal_to_receptacle_type = {'look_at_obj_in_light': "Toggleable"} +goal_to_invalid_receptacle = {'pick_heat_then_place_in_recep': {'Microwave'}, + 'pick_cool_then_place_in_recep': {'Fridge'}, + 'pick_clean_then_place_in_recep': {'SinkBasin'}, + 'pick_two_obj_and_place': {'CoffeeMachine', 'ToiletPaperHanger', 'HandTowelHolder'}} + +scene_id_to_objs = {} +obj_to_scene_ids = {} +scenes_for_goal = {g: [] for g in constants.GOALS} +scene_to_type = {} + + +def sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, receptacle_candidates, scene_candidates, + inject_noise=10): + # Get the current conditional distributions of all variables (goal/pickup/receptacle/scene). + goal_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + succ_traj.loc[ + (succ_traj['pickup'].isin(pickup_candidates) if 'pickup' in goal_to_required_variables[c] else True) & + (succ_traj['movable'].isin(movable_candidates) if 'movable' in goal_to_required_variables[c] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) if 'receptacle' in goal_to_required_variables[c] else True) + & (succ_traj['scene'].isin(scene_candidates) if 'scene' in goal_to_required_variables[c] else True)] + ['goal'].tolist().count(c))) # Conditional. + * (1 / (1 + succ_traj['goal'].tolist().count(c))) # Prior. + for c in goal_candidates] + goal_probs = [w / sum(goal_weight) for w in goal_weight] + + pickup_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['pickup'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['pickup'].tolist().count(c))) + for c in pickup_candidates] + pickup_probs = [w / sum(pickup_weight) for w in pickup_weight] + + movable_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['movable'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['movable'].tolist().count(c))) + for c in movable_candidates] + movable_probs = [w / sum(movable_weight) for w in movable_weight] + + receptacle_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['receptacle'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['receptacle'].tolist().count(c))) + for c in receptacle_candidates] + receptacle_probs = [w / sum(receptacle_weight) for w in receptacle_weight] + scene_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True)] + ['scene'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['scene'].tolist().count(c))) + for c in scene_candidates] + scene_probs = [w / sum(scene_weight) for w in scene_weight] + + # Calculate the probability difference between each value and the maximum so we can iterate over them to find a + # next-best candidate to sample subject to the constraints of knowing which will fail. + diffs = [("goal", goal_candidates[idx], goal_probs[idx] - min(goal_probs)) + for idx in range(len(goal_candidates)) if len(goal_candidates) > 1] + diffs.extend([("pickup", pickup_candidates[idx], pickup_probs[idx] - min(pickup_probs)) + for idx in range(len(pickup_candidates)) if len(pickup_candidates) > 1]) + diffs.extend([("movable", movable_candidates[idx], movable_probs[idx] - min(movable_probs)) + for idx in range(len(movable_candidates)) if len(movable_candidates) > 1]) + diffs.extend([("receptacle", receptacle_candidates[idx], receptacle_probs[idx] - min(receptacle_probs)) + for idx in range(len(receptacle_candidates)) if len(receptacle_candidates) > 1]) + diffs.extend([("scene", scene_candidates[idx], scene_probs[idx] - min(scene_probs)) + for idx in range(len(scene_candidates)) if len(scene_candidates) > 1]) + + # Iteratively pop the next biggest difference until we find a combination that is valid (e.g., not already + # flagged as impossible by the simulator). + variable_value_by_diff = {} + diffs_as_keys = [] # list of diffs; index into list will be used as key values. + for _, _, diff in diffs: + already_keyed = False + for existing_diff in diffs_as_keys: + if np.isclose(existing_diff, diff): + already_keyed = True + break + if not already_keyed: + diffs_as_keys.append(diff) + for variable, value, diff in diffs: + key = None + for kidx in range(len(diffs_as_keys)): + if np.isclose(diffs_as_keys[kidx], diff): + key = kidx + if key not in variable_value_by_diff: + variable_value_by_diff[key] = [] + variable_value_by_diff[key].append((variable, value)) + + for key, diff in sorted(enumerate(diffs_as_keys), key=lambda x: x[1], reverse=True): + variable_value = variable_value_by_diff[key] + random.shuffle(variable_value) + for variable, value in variable_value: + + # Select a goal. + if variable == "goal": + gtype = value + # print("sampled goal '%s' with prob %.4f" % (gtype, goal_probs[goal_candidates.index(gtype)])) + _goal_candidates = [gtype] + + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a pickup object. + elif variable == "pickup": + pickup_obj = value + # print("sampled pickup object '%s' with prob %.4f" % + # (pickup_obj, pickup_probs[pickup_candidates.index(pickup_obj)])) + _pickup_candidates = [pickup_obj] + + _goal_candidates = goal_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a movable object. + elif variable == "movable": + movable_obj = value + # print("sampled movable object '%s' with prob %.4f" % + # (movable_obj, movable_probs[movable_candidates.index(movable_obj)])) + _movable_candidates = [movable_obj] + _goal_candidates = [g for g in goal_candidates if g == 'pick_and_place_with_movable_recep'] + + _pickup_candidates = pickup_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a receptacle. + elif variable == "receptacle": + receptacle_obj = value + # print("sampled receptacle object '%s' with prob %.4f" % + # (receptacle_obj, receptacle_probs[receptacle_candidates.index(receptacle_obj)])) + _receptacle_candidates = [receptacle_obj] + + _goal_candidates = goal_candidates[:] + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a scene. + else: + sampled_scene = value + # print("sampled scene %s with prob %.4f" % + # (sampled_scene, scene_probs[scene_candidates.index(sampled_scene)])) + _scene_candidates = [sampled_scene] + + _goal_candidates = goal_candidates[:] + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + # Perform constraint propagation to determine whether this is a valid assignment. + propagation_finished = False + while not propagation_finished: + assignment_lens = (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), + len(_receptacle_candidates), len(_scene_candidates)) + # Constraints on goal. + _goal_candidates = [g for g in _goal_candidates if + (g not in goal_to_pickup_type or + len(set(_pickup_candidates).intersection( # Pickup constraint. + constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]])) > 0) + and (g not in goal_to_receptacle_type or + np.any([r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]] + for r in _receptacle_candidates])) # Valid by goal receptacle const. + and (g not in goal_to_invalid_receptacle or + len(set(_receptacle_candidates).difference( + goal_to_invalid_receptacle[g])) > 0) # Invalid by goal receptacle const. + and len(set(_scene_candidates).intersection( + scenes_for_goal[g])) > 0 # Scene constraint + ] + + # Define whether to consider constraints for each role based on current set of candidate goals. + pickup_constrained = np.any(["pickup" in goal_to_required_variables[g] for g in _goal_candidates]) + movable_constrained = np.any(["movable" in goal_to_required_variables[g] for g in _goal_candidates]) + receptacle_constrained = np.any(["receptacle" in goal_to_required_variables[g] + for g in _goal_candidates]) + scene_constrained = np.any(["scene" in goal_to_required_variables[g] for g in _goal_candidates]) + + # Constraints on pickup obj. + _pickup_candidates = [p for p in _pickup_candidates if + np.any([g not in goal_to_pickup_type or + p in constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]] + for g in _goal_candidates]) # Goal constraint. + and (not movable_constrained or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] + for m in _movable_candidates])) # Movable constraint. + and (not receptacle_constrained or + np.any([r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + p in constants.VAL_RECEPTACLE_OBJECTS[r] + for r in _receptacle_candidates])) # Receptacle constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[p]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on movable obj. + _movable_candidates = [m for m in _movable_candidates if + 'pick_and_place_with_movable_recep' in _goal_candidates # Goal constraint + and (not pickup_constrained or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] + for p in _pickup_candidates])) # Pickup constraint. + and (not receptacle_constrained or + np.any([r in constants.VAL_RECEPTACLE_OBJECTS and + m in constants.VAL_RECEPTACLE_OBJECTS[r] + for r in _receptacle_candidates])) # Receptacle constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[m]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on receptacle obj. + _receptacle_candidates = [r for r in _receptacle_candidates if + np.any([(g not in goal_to_receptacle_type or + r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]]) and + (g not in goal_to_invalid_receptacle or + r not in goal_to_invalid_receptacle[g]) + for g in _goal_candidates]) # Goal constraint. + and (not receptacle_constrained or + r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[r] + for p in _pickup_candidates])) # Pickup constraint. + and (not movable_constrained or + r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + np.any([m in constants.VAL_RECEPTACLE_OBJECTS[r] + for m in _movable_candidates])) # Movable constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[r]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on scene. + _scene_candidates = [s for s in _scene_candidates if + np.any([s in scenes_for_goal[g] + for g in _goal_candidates]) # Goal constraint. + and (not pickup_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[p]] + for p in _pickup_candidates])) # Pickup constraint. + and (not movable_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[m]] + for m in _movable_candidates])) # Movable constraint. + and (not receptacle_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[r]] + for r in _receptacle_candidates])) # Receptacle constraint. + ] + if assignment_lens == (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), + len(_receptacle_candidates), len(_scene_candidates)): + propagation_finished = True + + candidate_lens = {"goal": len(_goal_candidates), "pickup": len(_pickup_candidates), + "movable": len(_movable_candidates), "receptacle": len(_receptacle_candidates), + "scene": len(_scene_candidates)} + if candidate_lens["goal"] == 0: + # print("Goal over-constrained; skipping") + continue + if np.all([0 in [candidate_lens[v] for v in goal_to_required_variables[g]] for g in _goal_candidates]): + continue + + # Ensure some combination of the remaining constraints is not in failures and is not already populated + # by the target number of repeats. + failure_ensured = True + full_ensured = True + for g in _goal_candidates: + pickup_iter = _pickup_candidates if "pickup" in goal_to_required_variables[g] else ["None"] + for p in pickup_iter: + movable_iter = _movable_candidates if "movable" in goal_to_required_variables[g] else ["None"] + for m in movable_iter: + receptacle_iter = _receptacle_candidates if "receptacle" in goal_to_required_variables[g] \ + else ["None"] + for r in receptacle_iter: + scene_iter = _scene_candidates if "scene" in goal_to_required_variables[g] else ["None"] + for s in scene_iter: + if (g, p, m, r, s) not in fail_traj: + failure_ensured = False + if (g, p, m, r, s) not in full_traj: + full_ensured = False + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if failure_ensured: + continue + if full_ensured: + continue + + if candidate_lens["goal"] > 1 or np.any([np.any([candidate_lens[v] > 1 + for v in goal_to_required_variables[g]]) + for g in _goal_candidates]): + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + _goal_candidates, _pickup_candidates, _movable_candidates, + _receptacle_candidates, _scene_candidates) + sampled_task = next(task_sampler) + if sampled_task is None: + continue + else: + g = _goal_candidates[0] + p = _pickup_candidates[0] if "pickup" in goal_to_required_variables[g] else "None" + m = _movable_candidates[0] if "movable" in goal_to_required_variables[g] else "None" + r = _receptacle_candidates[0] if "receptacle" in goal_to_required_variables[g] else "None" + s = _scene_candidates[0] if "scene" in goal_to_required_variables[g] else "None" + sampled_task = (g, p, m, r, int(s)) + + yield sampled_task + + yield None # Discovered that there are no valid assignments remaining. + + +def print_successes(succ_traj): + print("###################################\n") + print("Successes: ") + print(succ_traj) + print("\n##################################") + + +def main(args, thread_num=0): + + print(thread_num) + # settings + alfred_dataset_path = '../data/json_2.1.0/train' + + constants.DATA_SAVE_PATH = args.save_path + print("Force Unsave Data: %s" % str(args.force_unsave)) + + # Set up data structure to track dataset balance and use for selecting next parameters. + # In actively gathering data, we will try to maximize entropy for each (e.g., uniform spread of goals, + # uniform spread over patient objects, uniform recipient objects, and uniform scenes). + succ_traj = pd.DataFrame(columns=["goal", "pickup", "movable", "receptacle", "scene"]) + + # objects-to-scene and scene-to-objects database + for scene_type, ids in constants.SCENE_TYPE.items(): + for id in ids: + obj_json_file = os.path.join('layouts', 'FloorPlan%d-objects.json' % id) + with open(obj_json_file, 'r') as of: + scene_objs = json.load(of) + + id_str = str(id) + scene_id_to_objs[id_str] = scene_objs + for obj in scene_objs: + if obj not in obj_to_scene_ids: + obj_to_scene_ids[obj] = set() + obj_to_scene_ids[obj].add(id_str) + + # scene-goal database + for g in constants.GOALS: + for st in constants.GOALS_VALID[g]: + scenes_for_goal[g].extend([str(s) for s in constants.SCENE_TYPE[st]]) + scenes_for_goal[g] = set(scenes_for_goal[g]) + + # scene-type database + for st in constants.SCENE_TYPE: + for s in constants.SCENE_TYPE[st]: + scene_to_type[str(s)] = st + + # pre-populate counts in this structure using saved trajectories path. + succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, args.just_examine, args.repeats_per_cond) + if args.just_examine: + print_successes(succ_traj) + return + + print(succ_traj.groupby('goal').count()) + # pre-populate failed trajectories. + fail_traj = load_fails_from_disk(args.save_path) + print("Loaded %d known failed tuples" % len(fail_traj)) + + # create env and agent + env = ThorEnv(x_display='0.%d' %(thread_num % 2)) + + game_state = TaskGameStateFullKnowledge(env) + agent = DeterministicPlannerAgent(thread_id=0, game_state=game_state) + + errors = {} # map from error strings to counts, to be shown after every failure. + goal_candidates = constants.GOALS[:] + pickup_candidates = list(set().union(*[constants.VAL_RECEPTACLE_OBJECTS[obj] # Union objects that can be placed. + for obj in constants.VAL_RECEPTACLE_OBJECTS])) + pickup_candidates = [p for p in pickup_candidates if constants.OBJ_PARENTS[p] in obj_to_scene_ids] + movable_candidates = list(set(constants.MOVABLE_RECEPTACLES).intersection(obj_to_scene_ids.keys())) + receptacle_candidates = [obj for obj in constants.VAL_RECEPTACLE_OBJECTS + if obj not in constants.MOVABLE_RECEPTACLES and obj in obj_to_scene_ids] + \ + [obj for obj in constants.VAL_ACTION_OBJECTS["Toggleable"] + if obj in obj_to_scene_ids] + + # toaster isn't interesting in terms of producing linguistic diversity + receptacle_candidates.remove('Toaster') + receptacle_candidates.sort() + + scene_candidates = list(scene_id_to_objs.keys()) + + n_until_load_successes = args.async_load_every_n_samples + print_successes(succ_traj) + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, + receptacle_candidates, scene_candidates) + + # main generation loop + # keeps trying out new task tuples as trajectories either fail or suceed + while True: + # for _ in range(20): + for ii, json_path in enumerate(glob.iglob(os.path.join(alfred_dataset_path, "**", "traj_data.json"), recursive=True)): + # if ii % args.num_threads == thread_num: + # if ii == 5: + sampled_task = json_path.split('/')[-3].split('-') + # sampled_task = next(task_sampler) + # print("===============") + # print(ii, json_path) + print(sampled_task) # DEBUG + # print("===============") + + if sampled_task is None: + sys.exit("No valid tuples left to sample (all are known to fail or already have %d trajectories" % + args.repeats_per_cond) + gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene = sampled_task + + sampled_scene = int(sampled_scene) + print("sampled tuple: " + str((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene))) + + tries_remaining = args.trials_before_fail + # only try to get the number of trajectories left to make this tuple full. + target_remaining = args.repeats_per_cond - len(succ_traj.loc[(succ_traj['goal'] == gtype) & + (succ_traj['pickup'] == pickup_obj) & + (succ_traj['movable'] == movable_obj) & + (succ_traj['receptacle'] == receptacle_obj) & + (succ_traj['scene'] == str(sampled_scene))]) + num_place_fails = 0 # count of errors related to placement failure for no valid positions. + + # continue until we're (out of tries + have never succeeded) or (have gathered the target number of instances) + while num_place_fails > args.trials_before_fail or target_remaining > 0: + + # environment setup + constants.pddl_goal_type = gtype + print("PDDLGoalType: " + constants.pddl_goal_type) + task_id = create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene) + + # setup data dictionary + setup_data_dict() + constants.data_dict['task_id'] = task_id + constants.data_dict['task_type'] = constants.pddl_goal_type + constants.data_dict['dataset_params']['video_frame_rate'] = constants.VIDEO_FRAME_RATE + + # plan & execute + try: + # if True: + # Agent reset to new scene. + constraint_objs = {'repeat': [(constants.OBJ_PARENTS[pickup_obj], # Generate multiple parent objs. + np.random.randint(2 if gtype == "pick_two_obj_and_place" else 1, + constants.PICKUP_REPEAT_MAX + 1))], + 'sparse': [(receptacle_obj.replace('Basin', ''), + num_place_fails * constants.RECEPTACLE_SPARSE_POINTS)]} + if movable_obj != "None": + constraint_objs['repeat'].append((movable_obj, + np.random.randint(1, constants.PICKUP_REPEAT_MAX + 1))) + for obj_type in scene_id_to_objs[str(sampled_scene)]: + if (obj_type in pickup_candidates and + obj_type != constants.OBJ_PARENTS[pickup_obj] and obj_type != movable_obj): + constraint_objs['repeat'].append((obj_type, + np.random.randint(1, constants.MAX_NUM_OF_OBJ_INSTANCES + 1))) + if gtype in goal_to_invalid_receptacle: + constraint_objs['empty'] = [(r.replace('Basin', ''), num_place_fails * constants.RECEPTACLE_EMPTY_POINTS) + for r in goal_to_invalid_receptacle[gtype]] + constraint_objs['seton'] = [] + if gtype == 'look_at_obj_in_light': + constraint_objs['seton'].append((receptacle_obj, False)) + if num_place_fails > 0: + print("Failed %d placements in the past; increased free point constraints: " % num_place_fails + + str(constraint_objs)) + scene_info = {'scene_num': sampled_scene, 'random_seed': random.randint(0, 2 ** 32)} + info = agent.reset(scene=scene_info, + objs=constraint_objs) + + # Problem initialization with given constraints. + task_objs = {'pickup': pickup_obj} + if movable_obj != "None": + task_objs['mrecep'] = movable_obj + if gtype == "look_at_obj_in_light": + task_objs['toggle'] = receptacle_obj + else: + task_objs['receptacle'] = receptacle_obj + agent.setup_problem({'info': info}, scene=scene_info, objs=task_objs) + + # Now that objects are in their initial places, record them. + object_poses = [{'objectName': obj['name'].split('(Clone)')[0], + 'position': obj['position'], + 'rotation': obj['rotation']} + for obj in env.last_event.metadata['objects'] if obj['pickupable']] + dirty_and_empty = gtype == 'pick_clean_then_place_in_recep' + object_toggles = [{'objectType': o, 'stateChange': 'toggleable', 'isToggled': v} + for o, v in constraint_objs['seton']] + constants.data_dict['scene']['object_poses'] = object_poses + constants.data_dict['scene']['dirty_and_empty'] = dirty_and_empty + constants.data_dict['scene']['object_toggles'] = object_toggles + + # Pre-restore the scene to cause objects to "jitter" like they will when the episode is replayed + # based on stored object and toggle info. This should put objects closer to the final positions they'll + # be inlay at inference time (e.g., mugs fallen and broken, knives fallen over, etc.). + print("Performing reset via thor_env API") + env.reset(sampled_scene) + print("Performing restore via thor_env API") + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + event = env.step(dict(constants.data_dict['scene']['init_action'])) + + terminal = False + while not terminal and agent.current_frame_count <= constants.MAX_EPISODE_LENGTH: + action_dict = agent.get_action(None) + agent.step(action_dict) + reward, terminal = agent.get_reward() + + dump_data_dict() + save_video() + # else: + except Exception as e: + import traceback + traceback.print_exc() + print("Error: " + repr(e)) + print("Invalid Task: skipping...") + if args.debug: + print(traceback.format_exc()) + + deleted = delete_save(args.in_parallel) + if not deleted: # another thread is filling this task successfully, so leave it alone. + target_remaining = 0 # stop trying to do this task. + else: + if str(e) == "API Action Failed: No valid positions to place object found": + # Try increasing the space available on sparse and empty flagged objects. + num_place_fails += 1 + tries_remaining -= 1 + else: # generic error + tries_remaining -= 1 + + estr = str(e) + if len(estr) > 120: + estr = estr[:120] + if estr not in errors: + errors[estr] = 0 + errors[estr] += 1 + print("%%%%%%%%%%") + es = sum([errors[er] for er in errors]) + print("\terrors (%d):" % es) + for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): + if v / es < 0.01: # stop showing below 1% of errors. + break + print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) + print("%%%%%%%%%%") + + continue + + if args.force_unsave: + delete_save(args.in_parallel) + + # add to save structure. + succ_traj = succ_traj.append({ + "goal": gtype, + "movable": movable_obj, + "pickup": pickup_obj, + "receptacle": receptacle_obj, + "scene": str(sampled_scene)}, ignore_index=True) + target_remaining -= 1 + tries_remaining += args.trials_before_fail # on success, add more tries for future successes + + # if this combination resulted in a certain number of failures with no successes, flag it as not possible. + if tries_remaining == 0 and target_remaining == args.repeats_per_cond: + new_fails = [(gtype, pickup_obj, movable_obj, receptacle_obj, str(sampled_scene))] + fail_traj = load_fails_from_disk(args.save_path, to_write=new_fails) + print("%%%%%%%%%%") + print("failures (%d)" % len(fail_traj)) + # print("\t" + "\n\t".join([str(ft) for ft in fail_traj])) + print("%%%%%%%%%%") + + # if this combination gave us the repeats we wanted, note it as filled. + if target_remaining == 0: + full_traj.add((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene)) + + # if we're sharing with other processes, reload successes from disk to update local copy with others' additions. + if args.in_parallel: + if n_until_load_successes > 0: + n_until_load_successes -= 1 + else: + print("Reloading trajectories from disk because of parallel processes...") + succ_traj = pd.DataFrame(columns=succ_traj.columns) # Drop all rows. + succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, False, args.repeats_per_cond) + print("... Loaded %d trajectories" % len(succ_traj.index)) + n_until_load_successes = args.async_load_every_n_samples + print_successes(succ_traj) + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, + receptacle_candidates, scene_candidates) + print("... Created fresh instance of sample_task_params generator") + + +def create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, scene_num): + task_id = 'trial_T' + datetime.now().strftime("%Y%m%d_%H%M%S_%f") + save_name = '%s-%s-%s-%s-%d' % (gtype, pickup_obj, movable_obj, receptacle_obj, scene_num) + '/' + task_id + + constants.save_path = os.path.join(constants.DATA_SAVE_PATH, save_name, RAW_IMAGES_FOLDER) + constants.save_depth_path = os.path.join(constants.DATA_SAVE_PATH, save_name, DEPTH_IMAGES_FOLDER) + + if not os.path.exists(constants.save_path): + os.makedirs(constants.save_path) + + if not os.path.exists(constants.save_depth_path): + os.makedirs(constants.save_depth_path) + + print("Saving images to: " + constants.save_path) + return task_id + + +def save_video(): + images_path = constants.save_path + '*.png' + video_path = os.path.join(constants.save_path.replace(RAW_IMAGES_FOLDER, ''), 'video.mp4') + video_saver.save(images_path, video_path) + + +def setup_data_dict(): + constants.data_dict = OrderedDict() + constants.data_dict['task_id'] = "" + constants.data_dict['task_type'] = "" + constants.data_dict['scene'] = {'floor_plan': "", 'random_seed': -1, 'scene_num': -1, 'init_action': [], + 'object_poses': [], 'dirty_and_empty': None, 'object_toggles': []} + constants.data_dict['plan'] = {'high_pddl': [], 'low_actions': []} + constants.data_dict['images'] = [] + constants.data_dict['template'] = {'task_desc': "", 'high_descs': []} + constants.data_dict['pddl_params'] = {'object_target': -1, 'object_sliced': -1, + 'parent_target': -1, 'toggle_target': -1, + 'mrecep_target': -1} + constants.data_dict['dataset_params'] = {'video_frame_rate': -1} + constants.data_dict['pddl_state'] = [] + + +def dump_data_dict(): + data_save_path = constants.save_path.replace(RAW_IMAGES_FOLDER, '') + with open(os.path.join(data_save_path, DATA_JSON_FILENAME), 'w') as fp: + json.dump(constants.data_dict, fp, sort_keys=True, indent=4) + + +def delete_save(in_parallel): + save_folder = constants.save_path.replace(RAW_IMAGES_FOLDER, '') + if os.path.exists(save_folder): + try: + shutil.rmtree(save_folder) + except OSError as e: + if in_parallel: # another thread succeeded at this task while this one failed. + return False + else: + raise e # if we're not running in parallel, this is an actual. + return True + + +def parallel_main(args): + procs = [mp.Process(target=main, args=(args,thread_num)) for thread_num in range(args.num_threads)] + try: + for proc in procs: + proc.start() + time.sleep(0.1) + finally: + for proc in procs: + proc.join() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + # settings + parser.add_argument('--force_unsave', action='store_true', help="don't save any data (for debugging purposes)") + parser.add_argument('--debug', action='store_true') + parser.add_argument('--save_path', type=str, default="dataset/new_trajectories_valid_seen", help="where to save the generated data") + parser.add_argument('--x_display', type=str, required=False, default=constants.X_DISPLAY, help="x_display id") + parser.add_argument("--just_examine", action='store_true', help="just examine what data is gathered; don't gather more") + parser.add_argument("--in_parallel", action='store_true', help="this collection will run in parallel with others, so load from disk on every new sample") + parser.add_argument("-n", "--num_threads", type=int, default=1, help="number of processes for parallel mode") + parser.add_argument('--json_file', type=str, default="", help="path to json file with trajectory dump") + + # params + parser.add_argument("--repeats_per_cond", type=int, default=3) + parser.add_argument("--trials_before_fail", type=int, default=5) + parser.add_argument("--async_load_every_n_samples", type=int, default=10) + parser.add_argument('--gpu_id', type=int, default=0) + + parse_args = parser.parse_args() + + # if parse_args.in_parallel and parse_args.num_threads > 1: + # parallel_main(parse_args) + # else: + main(parse_args) diff --git a/gen/scripts/replay_checks.py b/gen/scripts/replay_checks.py new file mode 100644 index 000000000..b0d31e82d --- /dev/null +++ b/gen/scripts/replay_checks.py @@ -0,0 +1,217 @@ +import os +import sys +# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) +# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) +sys.path.append(os.path.join('/home/jiasenl/code/alfred')) +sys.path.append(os.path.join('/home/jiasenl/code/alfred', 'gen')) + +import argparse +import json +import numpy as np +import shutil +import time +from env.thor_env import ThorEnv +from utils.replay_json import replay_json +import multiprocessing as mp +import time + + +JSON_FILENAME = "traj_data.json" + + +def parallel_replay_check(args): + procs = [mp.Process(target=replay_check, args=(args, thread_num)) for thread_num in range(args.num_threads)] + try: + for proc in procs: + proc.start() + time.sleep(0.1) + finally: + for proc in procs: + proc.join() + +def replay_check(args, thread_num=0): + env = ThorEnv(x_display='0.%d' %(thread_num % args.total_gpu)) + + # replay certificate filenames + replay_certificate_filenames = ["replay.certificate.%d" % idx for idx in range(args.num_replays)] + + # Clear existing failures in file recording. + if args.failure_filename is not None: + with open(args.failure_filename, 'w') as f: + f.write('') + + continue_check = True + total_checks, total_failures, crash_fails, unsat_fails, json_fails, nondet_fails = 0, 0, 0, 0, 0, 0 + errors = {} # map from error strings to counts, to be shown after every failure. + total_threads = args.total_gpu * args.num_threads + current_threads = args.gpu_id * args.num_threads + thread_num + + while continue_check: + + # Crawl the directory of trajectories and vet ones with no certificate. + failure_list = [] + valid_dirs = [] + count = 0 + for dir_name, subdir_list, file_list in os.walk(args.data_path): + if "trial_" in dir_name and (not "raw_images" in dir_name) and (not "pddl_states" in dir_name): + json_file = os.path.join(dir_name, JSON_FILENAME) + if not os.path.isfile(json_file): + continue + + # If we're just stripping certificates, do that and continue. + if args.remove_certificates: + for cidx in range(args.num_replays): + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + if os.path.isfile(certificate_file): + os.system("rm %s" % certificate_file) + continue + + if count % total_threads == current_threads: + valid_dirs.append(dir_name) + count += 1 + + print(len(valid_dirs)) + np.random.shuffle(valid_dirs) + for ii, dir_name in enumerate(valid_dirs): + + if not os.path.exists(dir_name): + continue + + json_file = os.path.join(dir_name, JSON_FILENAME) + if not os.path.isfile(json_file): + continue + + cidx = 0 + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + already_checked = False + while os.path.isfile(certificate_file): + cidx += 1 + if cidx == args.num_replays: + already_checked = True + break + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + if already_checked: + continue + + print(ii) + if not os.path.isfile(certificate_file): + total_checks += 1. / args.num_replays + failed = False + + with open(json_file) as f: + print("check %d/%d for file '%s'" % (cidx + 1, args.num_replays, json_file)) + try: + traj_data = json.load(f) + env.set_task(traj_data, args, reward_type='dense') + except json.decoder.JSONDecodeError: + failed = True + json_fails += 1 + + if not failed: + steps_taken = None + try: + steps_taken = replay_json(env, json_file) + except Exception as e: + import traceback + traceback.print_exc() + failed = True + crash_fails += 1 + + if str(e) not in errors: + errors[str(e)] = 0 + errors[str(e)] += 1 + print("%%%%%%%%%%") + es = sum([errors[er] for er in errors]) + print("\terrors (%d):" % es) + for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): + # if v / es < 0.01: # stop showing below 1% of errors. + # break + print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) + print("%%%%%%%%%%") + + if cidx > 1: + print("WARNING: replay that has succeeded before has failed at attempt %d" + % cidx) + nondet_fails += 1 + + if steps_taken is not None: # executed without crashing, so now we need to verify completion. + goal_satisfied = env.get_goal_satisfied() + + if goal_satisfied: + with open(certificate_file, 'w') as f: + f.write('%d' % steps_taken) + else: + failed = True + unsat_fails += 1 + print("Goal was not satisfied after execution!") + + if failed: + # Mark one failure and count the remainder of checks for this instance into the total. + total_failures += 1 + total_checks += args.num_replays - ((cidx + 1) / float(args.num_replays)) + + failure_list.append(json_file) + if args.failure_filename is not None: + with open(args.failure_filename, 'a') as f: + f.write("%s\n" % json_file) + # If we're deleting bad trajectories, do that here. + if args.move_failed_trajectories is not None: + print("Relocating failed trajectory '%s' to '%s'" % + (dir_name, os.path.join(args.move_failed_trajectories))) + try: + shutil.move(dir_name, args.move_failed_trajectories) + except shutil.Error as e: + print("WARNING: failed to perform move; error follows; deleting instead") + print(repr(e)) + shutil.rmtree(dir_name) + if args.remove_failed_trajectories: + print("Removing failed trajectory '%s'" % dir_name) + shutil.rmtree(dir_name) + + print("-------------------------") + print("Success Rate: %.2f/%.2f = %.3f" % + (total_checks - total_failures, total_checks, + float(total_checks - total_failures) / float(total_checks))) + if total_failures > 0: + print("Non-deterministic failure: %d/%d = %.3f" % (nondet_fails, total_failures, + float(nondet_fails) / total_failures)) + print("Failures by crash: %d/%d = %.3f" % (crash_fails, total_failures, + float(crash_fails) / total_failures)) + print("Failures by unsatisfied: %d/%d = %.3f" % (unsat_fails, total_failures, + float(unsat_fails) / total_failures)) + print("Failures by json decode error: %d/%d = %.3f" % (json_fails, total_failures, + float(json_fails) / total_failures)) + print("-------------------------") + + if not args.in_parallel: + continue_check = False + else: + time.sleep(60) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument('--data_path', type=str, default="dataset/2.1.0", + help="where to look for the generated data") + parser.add_argument("--failure_filename", type=str, required=False, + help="where to write failed trajectory dirs as strings, if anywhere") + parser.add_argument("--remove_failed_trajectories", dest='remove_failed_trajectories', action='store_true', + help="delete trajectory trials if they fail replay") + parser.add_argument("--move_failed_trajectories", type=str, required=False, + help="if given, relocate failed trajectories to this directory") + parser.add_argument("--remove_certificates", dest='remove_certificates', action='store_true', + help="instead of vetting trajectories, remove all vetting certificates") + parser.add_argument("--in_parallel", dest='in_parallel', action='store_true', + help="whether to run this script with parallel generation scripts in mind") + parser.add_argument('--reward_config', default='../models/config/rewards.json') + parser.add_argument('--num_replays', type=int, default=1) + parser.add_argument('--gpu_id', type=int, default=0) + parser.add_argument('--total_gpu', type=int, default=2) + parser.add_argument('--num_threads', type=int, default=2) + args = parser.parse_args() + + if args.num_threads > 1: + parallel_replay_check(args) + else: + replay_check(args) + diff --git a/gen/utils/__init__.py b/gen/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/gen/utils/bb_util.py b/gen/utils/bb_util.py new file mode 100644 index 000000000..46b574b69 --- /dev/null +++ b/gen/utils/bb_util.py @@ -0,0 +1,139 @@ +import numbers +import numpy as np + +LIMIT = 99999999 + +def clip_bbox(bboxes, min_clip, max_x_clip, max_y_clip): + ''' + # BBoxes are [x1, y1, x2, y2] + ''' + bboxes_out = bboxes + added_axis = False + if len(bboxes_out.shape) == 1: + added_axis = True + bboxes_out = bboxes_out[:, np.newaxis] + bboxes_out[[0, 2], ...] = np.clip(bboxes_out[[0, 2], ...], min_clip, max_x_clip) + bboxes_out[[1, 3], ...] = np.clip(bboxes_out[[1, 3], ...], min_clip, max_y_clip) + if added_axis: + bboxes_out = bboxes_out[:, 0] + return bboxes_out + + +def xyxy_to_xywh(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): + ''' + [x1 y1, x2, y2] to [xMid, yMid, width, height] + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + bboxes_out = np.zeros(bboxes.shape) + x1 = bboxes[0, ...] + y1 = bboxes[1, ...] + x2 = bboxes[2, ...] + y2 = bboxes[3, ...] + bboxes_out[0, ...] = (x1 + x2) / 2.0 + bboxes_out[1, ...] = (y1 + y2) / 2.0 + bboxes_out[2, ...] = x2 - x1 + bboxes_out[3, ...] = y2 - y1 + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if bboxes_out.shape[0] > 4: + bboxes_out[4:, ...] = bboxes[4:, ...] + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def xywh_to_xyxy(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): + ''' + [xMid, yMid, width, height] to [x1 y1, x2, y2] + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + bboxes_out = np.zeros(bboxes.shape) + x_mid = bboxes[0, ...] + y_mid = bboxes[1, ...] + width = bboxes[2, ...] + height = bboxes[3, ...] + bboxes_out[0, ...] = x_mid - width / 2.0 + bboxes_out[1, ...] = y_mid - height / 2.0 + bboxes_out[2, ...] = x_mid + width / 2.0 + bboxes_out[3, ...] = y_mid + height / 2.0 + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if bboxes_out.shape[0] > 4: + bboxes_out[4:, ...] = bboxes[4:, ...] + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def scale_bbox(bboxes, scalars, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False, in_place=False): + ''' + @bboxes {np.array} 4xn array of boxes to be scaled + @scalars{number or arraylike} scalars for width and height of boxes + @in_place{bool} If false, creates new bboxes. + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes, dtype=np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + if isinstance(scalars, numbers.Number): + scalars = np.full((2, bboxes.shape[1]), scalars, dtype=np.float32) + if not isinstance(scalars, np.ndarray): + scalars = np.array(scalars, dtype=np.float32) + if len(scalars.shape) == 1: + scalars = np.tile(scalars[:, np.newaxis], (1, bboxes.shape[1])) + + width = bboxes[2, ...] - bboxes[0, ...] + height = bboxes[3, ...] - bboxes[1, ...] + x_mid = (bboxes[0, ...] + bboxes[2, ...]) / 2.0 + y_mid = (bboxes[1, ...] + bboxes[3, ...]) / 2.0 + if not in_place: + bboxes_out = bboxes.copy() + else: + bboxes_out = bboxes + + bboxes_out[0, ...] = x_mid - width * scalars[0, ...] / 2.0 + bboxes_out[1, ...] = y_mid - height * scalars[1, ...] / 2.0 + bboxes_out[2, ...] = x_mid + width * scalars[0, ...] / 2.0 + bboxes_out[3, ...] = y_mid + height * scalars[1, ...] / 2.0 + + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def make_square(bboxes, in_place=False): + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + num_boxes = 1 + width = bboxes[2] - bboxes[0] + height = bboxes[3] - bboxes[1] + else: + num_boxes = bboxes.shape[1] + width = bboxes[2, ...] - bboxes[0, ...] + height = bboxes[3, ...] - bboxes[1, ...] + max_size = np.maximum(width, height) + scalars = np.zeros((2, num_boxes)) + scalars[0, ...] = max_size * 1.0 / width + scalars[1, ...] = max_size * 1.0 / height + return scale_bbox(bboxes, scalars, in_place=in_place) diff --git a/gen/utils/dataset_management_util.py b/gen/utils/dataset_management_util.py new file mode 100644 index 000000000..de13fa535 --- /dev/null +++ b/gen/utils/dataset_management_util.py @@ -0,0 +1,69 @@ +import os +import shutil + + +def load_successes_from_disk(succ_dir, succ_traj, prune_trials, target_count, + cap_count=None, min_count=None): + tuple_counts = {} + for root, dirs, files in os.walk(succ_dir): + for d in dirs: + if d.count('-') == 4: + goal, pickup, movable, receptacle, scene_num = d.split('-') + # Add an entry for every successful trial folder in the directory. + queue_for_delete = [] + deleted_all = True + for _, _dirs, _ in os.walk(os.path.join(succ_dir, d)): + for _d in _dirs: + for _, _, _files in os.walk(os.path.join(succ_dir, d, _d)): + if 'video.mp4' in _files: + k = (goal, pickup, movable, receptacle, scene_num) + if k not in tuple_counts: + tuple_counts[k] = 0 + tuple_counts[k] += 1 + deleted_all = False + else: + queue_for_delete.append(_d) + break # only examine top level + break # only examine top level + if prune_trials: + if deleted_all: + print("Removing trial-less parent dir '%s'" % os.path.join(succ_dir, d)) + shutil.rmtree(os.path.join(succ_dir, d)) + else: + for _d in queue_for_delete: + print("Removing unfinished trial '%s'" % os.path.join(succ_dir, d, _d)) + shutil.rmtree(os.path.join(succ_dir, d, _d)) + break # only examine top level + + # Populate dataframe based on tuple constraints. + for k in tuple_counts: + if min_count is None or tuple_counts[k] >= min_count: + to_add = tuple_counts[k] if cap_count is None else cap_count + for _ in range(to_add): + succ_traj = succ_traj.append({ + "goal": k[0], + "pickup": k[1], + "movable": k[2], + "receptacle": k[3], + "scene": k[4]}, ignore_index=True) + tuples_at_target_count = set([t for t in tuple_counts if tuple_counts[t] >= target_count]) + + return succ_traj, tuples_at_target_count + + +def load_fails_from_disk(succ_dir, to_write=None): + fail_traj = set() + fail_dir = os.path.join(succ_dir, "fails") + if not os.path.isdir(fail_dir): + os.makedirs(fail_dir) + if to_write is not None: + for goal, pickup, movable, receptacle, scene_num in to_write: + with open(os.path.join(fail_dir, '-'.join([goal, pickup, movable, receptacle, scene_num])), 'w') as f: + f.write("0") + for root, dirs, files in os.walk(fail_dir): + for fn in files: + if fn.count('-') == 4: + goal, pickup, movable, receptacle, scene_num = fn.split('-') + fail_traj.add((goal, pickup, movable, receptacle, scene_num)) + break # only examine top level + return fail_traj diff --git a/gen/utils/game_util.py b/gen/utils/game_util.py new file mode 100644 index 000000000..476ef5122 --- /dev/null +++ b/gen/utils/game_util.py @@ -0,0 +1,363 @@ +import copy +import random +import cv2 +import numpy as np +import constants +import goal_library as glib + + +def get_pose(event): + pose = event.pose + return (int(np.round(pose[0] / (1000 * constants.AGENT_STEP_SIZE))), + int(np.round(pose[1] / (1000 * constants.AGENT_STEP_SIZE))), + int(np.round(pose[2] / (1000 * 90))), + int(np.round(pose[3] / (1000)))) + + +def get_object_data(metadata): + return [ + {"objectName": obj["name"].split("(Clone)")[0], "position": obj["position"], "rotation": obj["rotation"]} + for obj in metadata["objects"] + if obj["pickupable"] + ] + + +def imresize(image, size, rescale=True): + if image is None: + return None + if image.shape[0] != size[0] or image.shape[1] != size[1]: + image = cv2.resize(image, size) + if rescale: + if image.dtype != np.float32: + image = image.astype(np.float32) + image /= 255.0 + return image + + +def depth_imresize(image, size, rescale=True, max_depth=constants.MAX_DEPTH): + if image is None: + return None + if image.shape[0] != size[0] or image.shape[1] != size[1]: + image = cv2.resize(image, size) + image[image > max_depth] = max_depth + if rescale: + if image.dtype != np.float32: + image = image.astype(np.float32) + image /= max_depth + return image + + +def get_camera_matrix(pose, camera_height): + assert(pose[2] in {0, 1, 2, 3}) + sin_x = np.sin(pose[3] * np.pi / 180) + cos_x = np.cos(pose[3] * np.pi / 180) + x_rotation = np.matrix([ + [1, 0, 0], + [0, cos_x, -sin_x], + [0, sin_x, cos_x]]) + sin_y = np.sin(pose[2] * np.pi / 180) + cos_y = np.cos(pose[2] * np.pi / 180) + y_rotation = np.matrix([ + [cos_y, 0, sin_y], + [0, 1, 0], + [-sin_y, 0, cos_y]]) + rotation_matrix = np.matmul(x_rotation, y_rotation) + transformation_matrix = np.matrix([pose[0], camera_height, pose[1], 1]).T + extrinsic_matrix = np.concatenate((np.concatenate((rotation_matrix, np.matrix([0, 0, 0])), axis=0), + transformation_matrix), axis=1) + return extrinsic_matrix + + +def get_rotation_matrix(pose): + assert(pose[2] in {0, 1, 2, 3}), 'rotation was %s' % str(pose[2]) + sin_x = np.sin(-pose[3] * np.pi / 180) + cos_x = np.cos(-pose[3] * np.pi / 180) + x_rotation = np.matrix([ + [1, 0, 0], + [0, cos_x, -sin_x], + [0, sin_x, cos_x]], dtype=np.float32) + sin_y = np.sin((-pose[2] % 4) * 90 * np.pi / 180) + cos_y = np.cos((-pose[2] % 4) * 90 * np.pi / 180) + y_rotation = np.matrix([ + [cos_y, 0, sin_y], + [0, 1, 0], + [-sin_y, 0, cos_y]], dtype=np.float32) + rotation_matrix = np.matmul(x_rotation, y_rotation) + return rotation_matrix + + +def depth_to_world_coordinates(depth, pose, camera_height): + x_points = np.arange(-constants.SCREEN_WIDTH / 2, constants.SCREEN_WIDTH / 2, dtype=depth.dtype) + x_vals = (depth * x_points / constants.FOCAL_LENGTH) + + y_points = np.arange(constants.SCREEN_HEIGHT / 2, -constants.SCREEN_HEIGHT / 2, -1, dtype=depth.dtype) + y_vals = (depth.T * y_points / constants.FOCAL_LENGTH).T + + z_vals = depth + xyz = np.stack((x_vals, y_vals, z_vals), axis=2) / (1000 * constants.AGENT_STEP_SIZE) + rotation_matrix = np.linalg.inv(get_rotation_matrix(pose)) + xyz = np.array(np.dot(rotation_matrix, xyz.reshape(-1, 3).T).T).reshape( + constants.SCREEN_HEIGHT, constants.SCREEN_WIDTH, 3) + xzy = xyz[:, :, [0, 2, 1]] + xzy += np.array([pose[0], pose[1], camera_height]) + return xzy + + +# coordinates should be [n, (xzy)] +def world_to_camera_coordinates(coordinates, pose, camera_height): + coordinates = coordinates.copy() + coordinates -= np.array([pose[0], pose[1], camera_height]) + xyz = coordinates[:, [0, 2, 1]] # [n, (xyz)] + rotation_matrix = get_rotation_matrix(pose) + xyd = np.array(np.dot(rotation_matrix, xyz.T).T) + xyd *= (1000 * constants.AGENT_STEP_SIZE) + depth = np.maximum(xyd[:, -1], 0.01) + x_points = xyd[:, 0] * constants.FOCAL_LENGTH / depth + constants.SCREEN_WIDTH / 2 + y_points = constants.SCREEN_HEIGHT - (xyd[:, 1] * constants.FOCAL_LENGTH / depth + constants.SCREEN_HEIGHT / 2) + return np.stack((x_points, y_points, depth)).T + + +def get_templated_action_str(plan, idx=0): + action = copy.deepcopy(plan[idx]) + object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) + + a_type = action['action'] + templated_str = "" + + if 'GotoLocation' in a_type: + templated_str = "go to the %s" % (next_recep_name if next_recep_name != "" else prev_object_name) + elif 'OpenObject' in a_type: + templated_str = "open the %s" % (object_name) + elif 'CloseObject' in a_type: + templated_str = "close the %s" % (object_name) + elif 'PickupObject' in a_type: + templated_str = "pick up the %s" % (object_name) + elif 'PutObject' in a_type: + templated_str = "put the %s in the %s" % (object_name, recep_name) + elif 'CleanObject' in a_type: + templated_str = "wash the %s" % (prev_object_name) + elif 'HeatObject' in a_type: + templated_str = "heat the %s" % (prev_object_name) + elif 'CoolObject' in a_type: + templated_str = "cool the %s" % (prev_object_name) + elif 'ToggleObject' in a_type: + templated_str = "toggle %s" % (object_name) + elif 'SliceObject' in a_type: + templated_str = "slice the %s" % (object_name) + elif 'End' in a_type: + templated_str = "<>" + + return templated_str + + +def get_discrete_hl_action(plan, idx=0): + action = copy.deepcopy(plan[idx]) + object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) + + a_type = action['action'] + discrete_action = {'action': "", 'args': []} + + if 'GotoLocation' in a_type: + discrete_action['action'] = "GotoLocation" + discrete_action['args'] = [next_recep_name if next_recep_name != "" else next_object_name] + elif 'OpenObject' in a_type: + discrete_action['action'] = "OpenObject" + discrete_action['args'] = [object_name] + elif 'CloseObject' in a_type: + discrete_action['action'] = "CloseObject" + discrete_action['args'] = [object_name] + elif 'PickupObject' in a_type: + discrete_action['action'] = "PickupObject" + discrete_action['args'] = [object_name] + elif 'PutObject' in a_type: + discrete_action['action'] = "PutObject" + discrete_action['args'] = [object_name, recep_name] + elif 'CleanObject' in a_type: + discrete_action['action'] = "CleanObject" + discrete_action['args'] = [prev_object_name] + elif 'HeatObject' in a_type: + discrete_action['action'] = "HeatObject" + discrete_action['args'] = [prev_object_name] + elif 'CoolObject' in a_type: + discrete_action['action'] = "CoolObject" + discrete_action['args'] = [prev_object_name] + elif 'ToggleObject' in a_type: + discrete_action['action'] = "ToggleObject" + discrete_action['args'] = [object_name] + elif 'SliceObject' in a_type: + discrete_action['action'] = "SliceObject" + discrete_action['args'] = [object_name] + else: + discrete_action['action'] = "NoOp" + discrete_action['args'] = [] + + return discrete_action + + +def object_id_to_name(object_id): + return object_id.split('|')[0] + + +def get_relevant_objs(action, plan, idx=0): + object_name = object_id_to_name(action['objectId']).lower() if 'objectId' in action else "" + recep_name = object_id_to_name(action['receptacleObjectId']).lower() if 'receptacleObjectId' in action else "" + prev_object_name, prev_recep_name = "", "" + next_object_name, next_recep_name = "", "" + + prev_idx = idx - 2 + if prev_idx >= 0: + prev_action = copy.deepcopy(plan[prev_idx]) + prev_object_name = object_id_to_name(prev_action['objectId']).lower() if 'objectId' in prev_action else "" + prev_recep_name = object_id_to_name(prev_action['receptacleObjectId']).lower() if 'receptacleObjectId' in prev_action else "" + + next_idx = idx + 1 + if next_idx < len(plan): + next_action = copy.deepcopy(plan[next_idx]) + next_object_name = object_id_to_name(next_action['objectId']).lower() if 'objectId' in next_action else "" + next_recep_name = object_id_to_name(next_action['receptacleObjectId']).lower() if 'receptacleObjectId' in next_action else "" + + return object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name + + +def get_action_str(action): + action = copy.deepcopy(action) + a_type = action['action'] + action_str = 'Action: ' + a_type + del action['action'] + + if 'Teleport' in a_type: + action_str = a_type + if 'x' in action: + action_str += ' x: %.03f' % action['x'] + del action['x'] + if 'y' in action: + action_str += ' y: %.03f' % action['y'] + del action['y'] + if 'z' in action: + action_str += ' z: %.03f' % action['z'] + del action['z'] + if 'rotation' in action and action.get('rotateOnTeleport', False): + if type(action['rotation']) == dict: + action_str += ' r: %d' % int(action['rotation']['y']) + else: + action_str += ' r: %d' % int(action['rotation']) + del action['rotation'] + del action['rotateOnTeleport'] + if 'horizon' in action: + action_str += ' h: %d' % int(action['horizon']) + del action['horizon'] + elif 'Goto' in a_type: + action_str = a_type + if 'location' in action: + action_str += ' loc: %s' % action['location'] + del action['location'] + elif a_type in {'OpenObject', 'CloseObject', 'PickupObject', 'ToggleObject', 'SliceObject'}: + if 'objectId' not in action: + action['objectId'] = 'None' + action_str = '%s %s' % (a_type, action['objectId']) + elif a_type in {'RotateByDegree', 'LookByDegree'}: + if type(action['rotation']) == dict: + action_str += ' r: %d' % int(action['rotation']['y']) + else: + action_str += ' r: %d' % int(action['rotation']) + action_str = '%s %d' % (a_type, action['rotation']['y']) + del action['rotation'] + elif a_type == 'PutObject': + action_str = a_type + if 'objectId' in action: + action_str += ' o: %s' % action['objectId'] + del action['objectId'] + if 'receptacleObjectId' in action: + action_str += ' r: %s' % action['receptacleObjectId'] + del action['receptacleObjectId'] + + if len(action) > 0: + action_str += '\tFull: ' + str(action) + return action_str + + +def get_object(object_id, metadata): + for obj in metadata['objects']: + if obj['objectId'] == object_id: + return obj + return None + + +def get_object_dict(metadata): + return {obj['objectId']: obj for obj in metadata['objects']} + + +def get_objects_of_type(object_type, metadata): + return [obj for obj in metadata['objects'] if obj['objectType'] == object_type] + + +def get_obj_of_type_closest_to_obj(object_type, ref_object_id, metadata): + objs_of_type = [obj for obj in metadata['objects'] if obj['objectType'] == object_type and obj['visible']] + ref_obj = get_object(ref_object_id, metadata) + closest_objs_of_type = sorted(objs_of_type, key=lambda o: np.linalg.norm(np.array([o['position']['x'], o['position']['y'], o['position']['z']]) - \ + np.array([ref_obj['position']['x'], ref_obj['position']['y'], ref_obj['position']['z']]))) + if len(closest_objs_of_type) == 0: + raise Exception("No closest %s found!" % (ref_obj)) + return closest_objs_of_type[0] # retrun the first closest visible object + + +def get_objects_with_name_and_prop(name, prop, metadata): + return [obj for obj in metadata['objects'] + if name in obj['objectId'] and obj[prop]] + + +def get_visible_objs(objs): + return [obj for obj in objs if obj['visible']] + + +def get_object_bounds(obj, scene_bounds): + # obj_bounds = np.array(obj['bounds3D'])[[0, 2, 3, 5]] # Get X and Z out + # Get a 'box' that is a singular point in (x,z) based on object position in place of now-unavailable 'bounds3d' + obj_bounds = np.array([obj['position']['x'], obj['position']['z'], obj['position']['x'], obj['position']['z']]) + obj_bounds /= constants.AGENT_STEP_SIZE + obj_bounds = np.round(obj_bounds).astype(np.int32) + obj_bounds[[2, 3]] = np.maximum(obj_bounds[[2, 3]], obj_bounds[[0, 1]] + 1) + obj_bounds[[0, 2]] = np.clip(obj_bounds[[0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) + obj_bounds[[1, 3]] = np.clip(obj_bounds[[1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) + obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] + return obj_bounds + + +def get_object_bounds_batch(boxes, scene_bounds): + obj_bounds = boxes[:, [0, 2, 3, 5]] # Get X and Z out + obj_bounds /= constants.AGENT_STEP_SIZE + obj_bounds = np.round(obj_bounds).astype(np.int32) + obj_bounds[:, [2, 3]] = np.maximum(obj_bounds[:, [2, 3]], obj_bounds[:, [0, 1]] + 1) + obj_bounds[:, [0, 2]] = np.clip(obj_bounds[:, [0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) + obj_bounds[:, [1, 3]] = np.clip(obj_bounds[:, [1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) + obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] + return obj_bounds + + +def get_task_str(object_ind, receptacle_ind=None, toggle_ind=None, mrecep_ind=None): + goal_str = constants.pddl_goal_type + if constants.data_dict['pddl_params']['object_sliced']: + goal_str += "_slice" + template = random.choice(glib.gdict[goal_str]['templates']) + obj = constants.OBJECTS[object_ind].lower() if object_ind is not None else "" + recep = constants.OBJECTS[receptacle_ind].lower() if receptacle_ind is not None else "" + tog = constants.OBJECTS[toggle_ind].lower() if toggle_ind is not None else "" + mrecep = constants.OBJECTS[mrecep_ind].lower() if mrecep_ind is not None else "" + filled_in_str = template.format(obj=obj, recep=recep, toggle=tog, mrecep=mrecep) + return filled_in_str + + +def get_last_hl_action_index(): + return len(constants.data_dict['plan']['high_pddl']) - 1 + + +def get_last_ll_action_index(): + return len(constants.data_dict['plan']['low_actions']) - 1 + + +def store_image_name(name): + constants.data_dict['images'].append({"high_idx": get_last_hl_action_index(), + "low_idx": get_last_ll_action_index(), + "image_name": name}) + + diff --git a/gen/utils/image_util.py b/gen/utils/image_util.py new file mode 100644 index 000000000..157812a2f --- /dev/null +++ b/gen/utils/image_util.py @@ -0,0 +1,57 @@ +import numpy as np +import gen.constants as constants + +def bbox_to_mask(bbox): + ''' + bbox to rectangle pixelwise mask + ''' + x1, y1, x2, y2 = bbox + mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) + mask[y1:y2, x1:x2] = 1 + return mask + + +def point_to_mask(point): + ''' + single point to dense pixelwise mask + ''' + x, y = point + mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) + mask[y, x] = 1 + return mask + + +def decompress_mask(compressed_mask): + ''' + decompress compressed mask array + ''' + mask = np.zeros((constants.DETECTION_SCREEN_WIDTH, constants.DETECTION_SCREEN_HEIGHT)) + for start_idx, run_len in compressed_mask: + for idx in range(start_idx, start_idx + run_len): + mask[idx // constants.DETECTION_SCREEN_WIDTH, idx % constants.DETECTION_SCREEN_HEIGHT] = 1 + return mask + + +def compress_mask(seg_mask): + ''' + compress mask array + ''' + run_len_compressed = [] # list of lists of run lengths for 1s, which are assumed to be less frequent. + idx = 0 + curr_run = False + run_len = 0 + for x_idx in range(len(seg_mask)): + for y_idx in range(len(seg_mask[x_idx])): + if seg_mask[x_idx][y_idx] == 1 and not curr_run: + curr_run = True + run_len_compressed.append([idx, None]) + if seg_mask[x_idx][y_idx] == 0 and curr_run: + curr_run = False + run_len_compressed[-1][1] = run_len + run_len = 0 + if curr_run: + run_len += 1 + idx += 1 + if curr_run: + run_len_compressed[-1][1] = run_len + return run_len_compressed \ No newline at end of file diff --git a/gen/utils/py_util.py b/gen/utils/py_util.py new file mode 100644 index 000000000..7a357f039 --- /dev/null +++ b/gen/utils/py_util.py @@ -0,0 +1,84 @@ +import random +import re +import time +import os +import string + + +def get_time_str(): + tt = time.localtime() + time_str = ('%04d_%02d_%02d_%02d_%02d_%02d' % + (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec)) + return time_str + + +def encode(string, encoding='utf-8'): + return string.encode(encoding) + + +def decode(string, encoding='utf-8'): + return string.decode(encoding) + + +def multireplace(string, replacements): + """ + Given a string and a replacement map, it returns the replaced string. + :param str string: string to execute replacements on + :param dict replacements: replacement dictionary {value to find: value to replace} + :rtype: str + Source https://gist.github.com/bgusach/a967e0587d6e01e889fd1d776c5f3729 + """ + # Place longer ones first to keep shorter substrings from matching where the longer ones should take place + # For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against the string 'hey abc', it should produce + # 'hey ABC' and not 'hey ABc' + substrs = sorted(replacements, key=len, reverse=True) + + # Create a big OR regex that matches any of the substrings to replace + regexp = re.compile('|'.join(map(re.escape, substrs))) + + # For each match, look up the new string in the replacements + return regexp.sub(lambda match: replacements[match.group(0)], string) + + +class SetWithGet(set): + def get_any(self): + return random.sample(self, 1)[0] + + def __getitem__(self, item): + return self.get_any() + + +class Noop(object): + def noop(*args, **kw): + pass + + def __getattr__(self, _): + return self.noop + + +def walklevel(some_dir, level=1): + some_dir = some_dir.rstrip(os.path.sep) + assert os.path.isdir(some_dir) + num_sep = some_dir.count(os.path.sep) + for root, dirs, files in os.walk(some_dir): + yield root, dirs, files + num_sep_this = root.count(os.path.sep) + if num_sep + level <= num_sep_this: + del dirs[:] + + +def remove_spaces(s): + cs = ' '.join(s.split()) + return cs + + +def remove_spaces_and_lower(s): + cs = remove_spaces(s) + cs = cs.lower() + return cs + + +def remove_punctuation(s): + cs = s.translate(str.maketrans('', '', string.punctuation)) + cs = remove_spaces_and_lower(cs) + return cs \ No newline at end of file diff --git a/gen/utils/replay_json.py b/gen/utils/replay_json.py new file mode 100644 index 000000000..96949414c --- /dev/null +++ b/gen/utils/replay_json.py @@ -0,0 +1,52 @@ +import json + +def replay_json(env, json_file): + # load json data + with open(json_file) as f: + traj_data = json.load(f) + + # setup + scene_num = traj_data['scene']['scene_num'] + object_poses = traj_data['scene']['object_poses'] + dirty_and_empty = traj_data['scene']['dirty_and_empty'] + object_toggles = traj_data['scene']['object_toggles'] + + scene_name = 'FloorPlan%d' % scene_num + env.reset(scene_name) + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + + # initialize + event = env.step(dict(traj_data['scene']['init_action'])) + # print("Task: %s" % (traj_data['template']['task_desc'])) + + steps_taken = 0 + for ll_action in traj_data['plan']['low_actions']: + hl_action_idx, traj_api_cmd, traj_discrete_action = \ + ll_action['high_idx'], ll_action['api_action'], ll_action['discrete_action'] + + # print templated low-level instructions & discrete action + # print("HL Templ: %s, LL Cmd: %s" % (traj_data['template']['high_descs'][hl_action_idx], + # traj_discrete_action['action'])) + + # Use the va_interact that modelers will have to use at inference time. + action_name, action_args = traj_discrete_action['action'], traj_discrete_action['args'] + + # three ways to specify object of interest mask + # 1. create a rectangular mask from bbox + # mask = env.bbox_to_mask(action_args['bbox']) if 'bbox' in action_args else None # some commands don't require any arguments + # 2. create a point mask from bbox + # mask = env.point_to_mask(action_args['point']) if 'point' in action_args else None + # 3. use full pixel-wise segmentation mask + compressed_mask = action_args['mask'] if 'mask' in action_args else None + if compressed_mask is not None: + mask = env.decompress_mask(compressed_mask) + else: + mask = None + + success, event, target_instance_id, err, _ = env.va_interact(action_name, interact_mask=mask) + if not success: + raise RuntimeError(err) + + steps_taken += 1 + + return steps_taken diff --git a/gen/utils/video_util.py b/gen/utils/video_util.py new file mode 100644 index 000000000..4c21b8a3a --- /dev/null +++ b/gen/utils/video_util.py @@ -0,0 +1,11 @@ +import subprocess +import constants + +class VideoSaver(object): + + def __init__(self, frame_rate=constants.VIDEO_FRAME_RATE): + self.frame_rate = frame_rate + + def save(self, image_path, save_path): + subprocess.call(["ffmpeg -r %d -pattern_type glob -y -i '%s' -c:v libx264 -pix_fmt yuv420p '%s'" % + (self.frame_rate, image_path, save_path)], shell=True) \ No newline at end of file diff --git a/lanmp_dataloader/attribute_limits.json b/lanmp_dataloader/attribute_limits.json new file mode 100644 index 000000000..0fdbbed9a --- /dev/null +++ b/lanmp_dataloader/attribute_limits.json @@ -0,0 +1 @@ +[{"min_x": -0.40000009536743164, "max_x": 0.40000009536743164, "min_y": 0, "max_y": 0, "min_z": -0.40000009536743164, "max_z": 0.40000009536743164}, {"min_yaw": -347.422251701355, "max_yaw": 358.85895166755654}, {"min_x": -1.146158218383789, "max_x": 0.6427476406097412, "min_y": -0.533308207988739, "max_y": 0.8237500190734863, "min_z": -0.5759885311126709, "max_z": 1.0145864486694336}] \ No newline at end of file diff --git a/lanmp_dataloader/rt1_dataloader.py b/lanmp_dataloader/rt1_dataloader.py new file mode 100644 index 000000000..7d574597a --- /dev/null +++ b/lanmp_dataloader/rt1_dataloader.py @@ -0,0 +1,800 @@ +import os +import sys + +import torch +from torchvision.io import read_image +from torch.utils.data import Dataset +from torch.utils.data import DataLoader +import h5py +from PIL import Image +from tqdm import tqdm +# from models.utils.data_utils import split_data +import pdb +#mainly for debugging +import matplotlib.pyplot as plt +import numpy as np +import re +import json +import sys +from copy import copy +import random + +sys.path.append('..') + +DATASET_PATH = '/oscar/data/stellex/shared/lanmp/sim_dataset.hdf5' + +''' +train_keys, val_keys, test_keys = split_data(self.args.data, splits['train'], splits['val'], splits['test']) +''' + +def split_data(hdf5_path, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1): + with h5py.File(hdf5_path, 'r') as hdf_file: + # Assuming trajectories or data units are top-level groups in the HDF5 file + keys = list(hdf_file.keys()) + total_items = len(keys) + + # Generate a shuffled array of indices + indices = np.arange(total_items) + np.random.shuffle(indices) + + # Calculate split sizes + train_end = int(train_ratio * total_items) + val_end = train_end + int(val_ratio * total_items) + + # Split the indices + train_indices = indices[:train_end] + val_indices = indices[train_end:val_end] + test_indices = indices[val_end:] + + # Convert indices back to keys (assuming order in keys list is stable and matches original order) + train_keys = [keys[i] for i in train_indices] + val_keys = [keys[i] for i in val_indices] + test_keys = [keys[i] for i in test_indices] + + return train_keys, val_keys, test_keys + +def split_by_scene(hdf5_path): + + #mapping which keys are relevant to specific scenes + scene_to_keys = {} + + with h5py.File(hdf5_path, 'r') as hdf_file: + + keys = list(hdf_file.keys()) + + for k in keys: + traj_json_dict = json.loads(hdf_file[k]['folder_0'].attrs['metadata']) + + if traj_json_dict['scene'] not in scene_to_keys: + scene_to_keys[traj_json_dict['scene']] = [] + + scene_to_keys[traj_json_dict['scene']].append(k) + + for k in scene_to_keys.keys(): + scene_to_keys[k] = list(sorted(scene_to_keys[k])) + + with open('./lanmp_dataloader/scene_to_keys.json', 'w') as f: + json.dump(scene_to_keys, f) + + return scene_to_keys + + + +def sort_folders(test_string): + return list(map(int, re.findall(r'\d+', test_string)))[0] + +class DatasetManager(object): + + ''' + NOTE: kwargs should contain a dictionary with keys {'train_split' : x, 'val_split': y, 'test_split':z} where x+y+z = 1 + ''' + def __init__(self, val_scene=1, train_split=0.8, val_split=0.1, test_split=0.1, split_style='task_split', diversity_scenes=1, max_trajectories=100): + + assert( train_split + val_split + test_split == 1.0, 'Error: train, val and test split do not sum to 1.0') + + + #train_keys, val_keys, test_keys = split_data(DATASET_PATH, train_split, val_split, test_split) + if 'scene_to_keys.json' not in os.listdir('./lanmp_dataloader'): + self.scene_to_keys = split_by_scene(DATASET_PATH) + else: + with open('./lanmp_dataloader/scene_to_keys.json') as f: + self.scene_to_keys = json.load(f) + + + self.scenes = list(sorted(list(self.scene_to_keys.keys()))) + + assert( split_style in ['k_fold_scene', 'task_split', 'diversity_ablation'], "Error: input split_style is invalid") + + if split_style == 'k_fold_scene': + assert( val_scene < len(self.scenes), "Error: input scene is out of index space") + train_keys = [] + for x in range(0, len(self.scenes)): + if x!=val_scene: + train_keys += self.scene_to_keys[self.scenes[x]] + + val_keys = self.scene_to_keys[self.scenes[val_scene]] + test_keys = None + + elif split_style == 'task_split': + + train_keys = [] + val_keys = [] + + for scene in self.scenes: + + scene_keys = copy(self.scene_to_keys[scene]) + random.shuffle(scene_keys) + + + split_idx = int(len(scene_keys)*(train_split + 0.5*val_split)) + + train_keys += scene_keys[:split_idx] + val_keys += scene_keys[split_idx:] + + print('Train Perc: ', len(train_keys) / (len(train_keys) + len(val_keys))) + + val_keys = ['data_13:02:17', 'data_19:58:40', 'data_15:50:55', 'data_16:22:44', 'data_15:40:22', 'data_17:08:14', 'data_15:37:13', 'data_18:38:30', 'data_13:56:07', 'data_15:22:59', 'data_13:33:54', 'data_13:18:11', 'data_19:36:17', 'data_14:38:16', 'data_13:04:13', 'data_12:04:43', 'data_16:37:57', 'data_15:38:38', 'data_16:40:44', 'data_17:59:00', 'data_20:57:07', 'data_16:03:52', 'data_16:40:36', 'data_19:31:51', 'data_16:45:24', 'data_21:09:57', 'data_17:26:17', 'data_15:01:27', 'data_14:02:16', 'data_13:29:09', 'data_14:22:29', 'data_16:43:00', 'data_13:46:04', 'data_15:13:04', 'data_16:45:58', 'data_13:33:29', 'data_17:17:50', 'data_11:19:28', 'data_17:45:27', 'data_16:00:55', 'data_15:03:19', 'data_16:06:05', 'data_16:02:46', 'data_17:41:00', 'data_17:35:45', 'data_14:05:06', 'data_18:22:47', 'data_17:02:46', 'data_15:08:23', 'data_16:15:15', 'data_19:00:23', 'data_11:50:57', 'data_15:19:33', 'data_14:52:27', 'data_16:58:53', 'data_11:44:50', 'data_16:10:21', 'data_13:10:05', 'data_17:48:24', 'data_18:09:10', 'data_18:01:35', 'data_13:34:59', 'data_12:48:23', 'data_22:17:48', 'data_16:57:05', 'data_16:49:20', 'data_17:51:34', 'data_12:54:21', 'data_16:23:48', 'data_14:24:32', 'data_16:18:35', 'data_14:26:22', 'data_16:11:06', 'data_11:58:17', 'data_17:13:00', 'data_19:34:02', 'data_13:29:42', 'data_17:20:01', 'data_15:20:09', 'data_16:53:34', 'data_15:25:56'] + + print('Train Keys: ', len(train_keys)) + print('Validation Keys: ', len(val_keys)) + print('Validation Keys: ', val_keys) + + elif split_style == 'diversity_ablation': + + assert(diversity_scenes < len(self.scene_to_keys.keys()), "Error: number of train scenes for diversity ablations cannot be {}".format(len(self.scene_to_keys.keys()))) + + ordered_scenes = []; ordered_trajs = [] + + for scene, traj in self.scene_to_keys.items(): + + ordered_scenes.append(scene) + ordered_trajs.append(len(traj)) + + + ordered_index = sorted(range(0, len(ordered_trajs)), key = lambda x: ordered_trajs[x]) + + ordered_trajs = list(sorted(ordered_trajs)) + ordered_scenes = [ordered_scenes[i] for i in ordered_index] + + print('EVAL SCENE: {} has {} trajectories'.format(ordered_scenes[-1], ordered_trajs[-1])) + val_keys = self.scene_to_keys[ordered_scenes[-1]] + other_scenes = list(reversed(ordered_scenes[:-1])) + other_trajs = list(reversed(ordered_trajs[:-1])) + + + num_per_scene = int(max_trajectories/diversity_scenes) + train_keys = [] + + for i in range(diversity_scenes): + train_keys += random.sample(self.scene_to_keys[other_scenes[i]], num_per_scene) + + if len(train_keys) < max_trajectories: + + random_scene = random.sample(other_scenes[:diversity_scenes], 1)[0] + train_keys += random.sample(self.scene_to_keys[random_scene], max_trajectories-len(train_keys)) + + + if 'attribute_limits.json' not in os.listdir('./lanmp_dataloader'): + body_pose_lim, body_orientation_lim, end_effector_pose_lim = self.determine_min_max_range([train_keys, val_keys, test_keys]) + else: + + with open('./lanmp_dataloader/attribute_limits.json') as f: + attribute_limits = json.load(f) + body_pose_lim, body_orientation_lim, end_effector_pose_lim = attribute_limits[0], attribute_limits[1], attribute_limits[2] + + self.train_dataset = RT1Dataset(train_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + self.val_dataset = RT1Dataset(val_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + # self.test_dataset = RT1Dataset(test_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + + def determine_min_max_range(self, data_subset_keys): + + body_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z':float('-inf')} + body_orientation = {'min_yaw': float('inf'), 'max_yaw': float('-inf')} + end_effector_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z': float('-inf')} + + + + + with h5py.File(DATASET_PATH, 'r') as hdf: + for dataset_keys in data_subset_keys: + + if dataset_keys is None: + continue + + + for i in range(len(dataset_keys)): + prev_body_x = None + prev_body_y = None + prev_body_z = None + prev_body_yaw = None + prev_ee_x = None + prev_ee_y = None + prev_ee_z = None + + print('Index: {} of {}'.format(i, len(dataset_keys))) + traj_group = hdf[dataset_keys[i]] + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + for j in range(len(traj_steps)): + + step_metadata = json.loads(traj_group[traj_steps[j]].attrs['metadata']) + + body_x = step_metadata['steps'][0]['state_body'][0] + body_y = step_metadata['steps'][0]['state_body'][1] + body_z = step_metadata['steps'][0]['state_body'][2] + + body_yaw = step_metadata['steps'][0]['state_body'][3] + + + ee_x = step_metadata['steps'][0]['state_ee'][0] + ee_y = step_metadata['steps'][0]['state_ee'][1] + ee_z = step_metadata['steps'][0]['state_ee'][2] + + + + body_pose['min_x'] = min(body_pose['min_x'], body_x - prev_body_x if prev_body_x is not None else 0) + body_pose['max_x'] = max(body_pose['max_x'], body_x - prev_body_x if prev_body_x is not None else 0) + + body_pose['min_y'] = min(body_pose['min_y'], body_y - prev_body_y if prev_body_y is not None else 0) + body_pose['max_y'] = max(body_pose['max_y'], body_y - prev_body_y if prev_body_y is not None else 0) + + body_pose['min_z'] = min(body_pose['min_z'], body_z - prev_body_z if prev_body_z is not None else 0) + body_pose['max_z'] = max(body_pose['max_z'], body_z - prev_body_z if prev_body_z is not None else 0) + + body_orientation['min_yaw'] = min(body_orientation['min_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) + body_orientation['max_yaw'] = max(body_orientation['max_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) + + end_effector_pose['min_x'] = min(end_effector_pose['min_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) + end_effector_pose['max_x'] = max(end_effector_pose['max_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) + + end_effector_pose['min_y'] = min(end_effector_pose['min_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) + end_effector_pose['max_y'] = max(end_effector_pose['max_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) + + end_effector_pose['min_z'] = min(end_effector_pose['min_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) + end_effector_pose['max_z'] = max(end_effector_pose['max_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) + + + prev_body_x = body_x + prev_body_y = body_y + prev_body_z = body_z + prev_body_yaw = body_yaw + prev_ee_x = ee_x + prev_ee_y = ee_y + prev_ee_z = ee_z + + + + #cache the saved max and min values if already computed to save time + attribute_limits = [body_pose, body_orientation, end_effector_pose] + with open('./lanmp_dataloader/attribute_limits.json', 'w') as f: + json.dump(attribute_limits, f) + + + return body_pose, body_orientation, end_effector_pose + + def collate_batches(self, batch, shuffle_batch = False): + + + collated_batch = [] + + # merging batch elements with variable length + for out in range(len(batch[0])): + collated_output = [] + for idx in range(len(batch)): + if batch[idx][out].dtype.type == np.str_: + collated_output.append(batch[idx][out]) + else: + collated_output.append(torch.from_numpy(batch[idx][out])) + + if batch[idx][out].dtype.type!=np.str_: + collated_output = torch.cat(collated_output, dim=0) + else: + + collated_output = np.concatenate(collated_output, axis=0) + + collated_batch.append(collated_output) + + #shuffling all the batched samples across the trajectories to get random order + if shuffle_batch: + permutation = torch.randperm(collated_batch[0].size(0)) + + for i in range(len(collated_batch)): + collated_batch[i] = collated_batch[i][permutation] + + return collated_batch + + + + + + + + + +class RT1Dataset(Dataset): + + + + def __init__(self, data_split_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim, tokenize_action=True): + + #stores the keys in the dataset for the appropriate split (train, validation or test) + self.dataset_keys = data_split_keys + self.body_pose_lim = body_pose_lim + self.body_orientation_lim = body_orientation_lim + self.end_effector_pose_lim = end_effector_pose_lim + self.num_bins = 254 + + self.tokenize_action = tokenize_action + + self.hdf = h5py.File(DATASET_PATH, 'r') + + def __len__(self): + return len(self.dataset_keys) + + + def make_data_discrete(self, dictionary): + + + + #body x, y, z coordinate + dictionary['body_position_deltas'][:,0] = 1 + (dictionary['body_position_deltas'][:,0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins + dictionary['body_position_deltas'][:,0] = dictionary['body_position_deltas'][:,0].astype(int) + + if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0: + dictionary['body_position_deltas'][:,1] = 1 + (dictionary['body_position_deltas'][:,1] - self.body_pose_lim['min_y'])/(self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins + else: + dictionary['body_position_deltas'][:,1].fill(0) + dictionary['body_position_deltas'][:,1] = dictionary['body_position_deltas'][:,1].astype(int) + + dictionary['body_position_deltas'][:,2] = 1 + (dictionary['body_position_deltas'][:,2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins + dictionary['body_position_deltas'][:,2] = dictionary['body_position_deltas'][:,2].astype(int) + + #body yaw and pitch + dictionary['body_yaw_deltas'] = 1 + (dictionary['body_yaw_deltas'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins + dictionary['body_yaw_deltas'] = dictionary['body_yaw_deltas'].astype(int) + + #end effector x, y, z coordinate + dictionary['arm_position_deltas'][:,0] = 1 + (dictionary['arm_position_deltas'][:,0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins + dictionary['arm_position_deltas'][:,0] = dictionary['arm_position_deltas'][:,0].astype(int) + + dictionary['arm_position_deltas'][:,1] = 1 + (dictionary['arm_position_deltas'][:,1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins + dictionary['arm_position_deltas'][:,1] = dictionary['arm_position_deltas'][:,1].astype(int) + + dictionary['arm_position_deltas'][:,2] = 1 + (dictionary['arm_position_deltas'][:,2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins + dictionary['arm_position_deltas'][:,2] = dictionary['arm_position_deltas'][:,2].astype(int) + + #find if and where episode terminates so you can fill those entries with 0s + if 1.0 in dictionary['terminate_episode']: + terminate_idx = np.where(np.array(dictionary['terminate_episode'])>0)[0][0] + + dictionary['body_position_deltas'][terminate_idx:,:].fill(0) + dictionary['body_yaw_deltas'][terminate_idx:].fill(0) + dictionary['arm_position_deltas'][terminate_idx:,:].fill(0) + + + return dictionary + + + def detokenize_continuous_data(self, dictionary): + + if dictionary['curr_mode'] == 'stop': + dictionary['body_position_delta'] = [[0.0, 0.0, 0.0]] + dictionary['body_yaw_delta'] = [[0.0]] + dictionary['arm_position_deltas'] = [[0.0, 0.0, 0.0]] + + else: + dictionary['body_position_delta'][0][0] = (dictionary['body_position_delta'][0][0] - 1) * (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x']) / self.num_bins + self.body_pose_lim['min_x'] + dictionary['body_position_delta'][0][1] = (dictionary['body_position_delta'][0][1] - 1) * (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y']) / self.num_bins + self.body_pose_lim['min_y'] + dictionary['body_position_delta'][0][2] = (dictionary['body_position_delta'][0][2] - 1) * (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z']) / self.num_bins + self.body_pose_lim['min_z'] + + dictionary['body_yaw_delta'][0][0] = (dictionary['body_yaw_delta'][0][0] - 1) * (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) / self.num_bins + self.body_orientation_lim['min_yaw'] + + + dictionary['arm_position_delta'][0][0] = (dictionary['arm_position_delta'][0][0] - 1) * (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x']) / self.num_bins + self.end_effector_pose_lim['min_x'] + dictionary['arm_position_delta'][0][1] = (dictionary['arm_position_delta'][0][1] - 1) * (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y']) / self.num_bins + self.end_effector_pose_lim['min_y'] + dictionary['arm_position_delta'][0][2] = (dictionary['arm_position_delta'][0][2] - 1) * (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z']) / self.num_bins + self.end_effector_pose_lim['min_z'] + return dictionary + + + def make_data_discrete_old(self, dictionary): + + if not bool(dictionary['is_terminal']): + + #body x, y, z coordinate + dictionary['body_position'][0] = 1 + int( (dictionary['body_position'][0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins) + + dictionary['body_position'][1] = 1 + int( (dictionary['body_position'][1] - self.body_pose_lim['min_y'])/ (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins) if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0 else 0 + + dictionary['body_position'][2] = 1 + int( (dictionary['body_position'][2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins) + + #body yaw and pitch + dictionary['body_yaw'] = 1 + int( (dictionary['body_yaw'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins) + + #end effector x, y, z coordinate + dictionary['arm_position'][0] = 1 + int( (dictionary['arm_position'][0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins) + dictionary['arm_position'][1] = 1 + int( (dictionary['arm_position'][1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins) + dictionary['arm_position'][2] = 1 + int( (dictionary['arm_position'][2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins) + + #if terminal action is chosen, then produce 'no action' discrete value for each of the state variables + else: + dictionary['body_position'][0] = 0 + dictionary['body_position'][1] = 0 + dictionary['body_position'][2] = 0 + + dictionary['body_yaw'] = 0 + + dictionary['arm_position'][0] = 0 + dictionary['arm_position'][1] = 0 + dictionary['arm_position'][2] = 0 + + def get_head_pitch(self, action): + + value = 0 + + if action == 'LookDown': + value = 1 + elif action == 'LookUp': + value = 2 + + return value + + def detokenize_head_pitch(self, token): + + tokenization_dict = {0:None, 1:'LookDown', 2:'LookUp'} + + return tokenization_dict[token] + + def get_mode(self, action): + + #mode: (0) stop, (1) body, (2) yaw, (3) manipulation, (4) grasping, (5) head pitch + + value = None + + if action == 'stop': + value = 0 + elif action in set( ['LookDown', 'LookUp']): + value = 5 + elif action in set(['MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft']): + value = 1 + elif action in set(['PickupObject', 'ReleaseObject']): + value = 4 + elif action in set(['MoveArm', 'MoveArmBase']): + value = 3 + elif action == 'RotateAgent': + value = 2 + + assert(type(value)==int, 'Get Mode didn\'t return an int') + return value + + def detokenize_mode(self, token): + + tokenization_dict = {0: 'stop', 1:'MoveAgent', 2:'RotateAgent', 3:'MoveArm', 4:'PickupReleaseObject', 5:'PitchAgent'} + + return tokenization_dict[token] + + def detokenize_action(self, detokenized_mode, body_position_delta, body_yaw_delta, arm_position_delta, detokenized_pickup_release, detokenized_head_pitch): + + + if detokenized_mode == 'PickupReleaseObject': + return detokenized_pickup_release + + elif detokenized_mode == 'PitchAgent': + return detokenized_head_pitch + else: + return detokenized_mode + + + def get_pickup_release(self, action): + + if action == 'PickupObject': + value = 1 + elif action == 'ReleaseObject': + value = 2 + else: + value = 0 + + return value + + def detokenize_pickup_release(self, token): + + tokenization_dict = {0:None, 1:'PickupObject', 2:'ReleaseObject'} + return tokenization_dict[token] + + def __getitem__(self, idx): + + # pdb.set_trace() + + traj_group = self.hdf[self.dataset_keys[idx]] + + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + nl_command = traj_json_dict['nl_command'] + + + #compute remainder in case padding of action tokens and observations needed + padding_length = 6 - (len(traj_steps)%6) if len(traj_steps)%6 > 0 else 0 + terminate = False + + start = 0; end = min(len(traj_steps), 6) + + #return list of dictionaries with attributes required for RT1 + all_image_obs = [] + all_nl_commands = [] + all_is_terminal = [] + all_pickup_release = [] + all_body_position_deltas = [] + all_body_yaw_deltas = [] + all_body_pitches = [] + all_arm_position_deltas = [] + all_control_mode = [] + + all_pad_lengths = [] + + + + #build the dictionary for each sequence + while end <= len(traj_steps) and not terminate: + + ''' + mode: stop, body, yaw, manipulation, grasping, head pitch + gripper: (x, y, z, grasp) + body: (x, y, yaw, look up/down) + ''' + image_obs = [] + nl_commands = [] + body_position_deltas = [] + body_yaw_deltas = [] + arm_position_deltas = [] + terminate_episodes = [] + pickup_releases = [] + body_pitches = [] + control_modes = [] + + for i in range(start, end): + + #visual observation + ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) + image_obs.append(ith_obs) + + #natural language command + nl_commands.append(nl_command) + + current_metadata = json.loads(traj_group[traj_steps[i]].attrs['metadata']) + + + if i < len(traj_steps)-1: + + next_metadata = json.loads(traj_group[traj_steps[i+1]].attrs['metadata']) + + #body position, body yaw, arm position + body_position_delta = np.array(next_metadata['steps'][0]['state_body'][:3])-np.array(current_metadata['steps'][0]['state_body'][:3]) + body_yaw_delta = next_metadata['steps'][0]['state_body'][3] - current_metadata['steps'][0]['state_body'][3] + arm_position_delta = np.array(next_metadata['steps'][0]['state_ee'][:3]) - np.array(current_metadata['steps'][0]['state_ee'][:3]) + + #terminate episode / pick up release / body pitch / mode + terminate_episode = int(i == len(traj_steps)-1) + pickup_release = self.get_pickup_release(next_metadata['steps'][0]['action']) + body_pitch = self.get_head_pitch(next_metadata['steps'][0]['action']) + control_mode = self.get_mode(next_metadata['steps'][0]['action']) + else: + + #body position, body yaw, arm positon -- for last step + body_position_delta = np.array([0.0, 0.0, 0.0]) + body_yaw_delta = 0.0 + arm_position_delta = np.array([0.0, 0.0, 0.0]) + + #is terminal / pick up release / body pitch / mode -- for last step + terminate_episode = int(i == len(traj_steps)-1) + pickup_release = self.get_pickup_release(None) + body_pitch = self.get_head_pitch(None) + control_mode = self.get_mode('stop') + + body_position_deltas.append(body_position_delta) + body_yaw_deltas.append(body_yaw_delta) + arm_position_deltas.append(arm_position_delta) + terminate_episodes.append(terminate_episode) + pickup_releases.append(pickup_release) + body_pitches.append(body_pitch) + control_modes.append(control_mode) + + + + #check for remainder and pad data with extra + if end >= len(traj_steps) and padding_length > 0: + + for pad in range(0, padding_length): + + image_obs.append(ith_obs) + nl_commands.append(nl_command) + + body_position_deltas.append(np.array([0.0, 0.0, 0.0])) + body_yaw_deltas.append(0.0) + arm_position_deltas.append(np.array([0.0, 0.0, 0.0])) + terminate_episodes.append(0) + pickup_releases.append(0.0) + body_pitches.append(0.0) + control_modes.append(0.0) + + terminate = True + elif end >= len(traj_steps): + terminate = True + + + + #pre-process and discretize numerical data + body_position_deltas = np.stack(body_position_deltas) + body_yaw_deltas = np.stack(body_yaw_deltas) + arm_position_deltas = np.stack(arm_position_deltas) + + if self.tokenize_action: + + tokenized_actions = { + 'body_position_deltas': body_position_deltas, + 'body_yaw_deltas': body_yaw_deltas, + 'arm_position_deltas': arm_position_deltas, + 'terminate_episode': terminate_episodes + } + + tokenized_actions = self.make_data_discrete(tokenized_actions) + + body_position_deltas = tokenized_actions['body_position_deltas'] + + body_yaw_deltas = np.expand_dims(tokenized_actions['body_yaw_deltas'], axis=1) + + arm_position_deltas = tokenized_actions['arm_position_deltas'] + + + + + all_image_obs.append(np.stack(image_obs)) + all_nl_commands.append(np.stack(nl_commands)) + all_is_terminal.append(np.stack(terminate_episodes)) + all_pickup_release.append(np.stack(pickup_releases)) + all_body_position_deltas.append(body_position_deltas) + all_body_yaw_deltas.append(body_yaw_deltas) + all_body_pitches.append(np.stack(body_pitches)) + all_arm_position_deltas.append(arm_position_deltas) + all_control_mode.append(np.stack(control_modes)) + + all_pad_lengths.append(0 if not end >= len(traj_steps) else padding_length) + + + start += 6 + end = min(end + 6, len(traj_steps)) + + + + + return np.stack(all_image_obs), np.stack(all_nl_commands), np.stack(all_is_terminal), np.stack(all_pickup_release), np.stack(all_body_position_deltas), np.stack(all_body_yaw_deltas), np.stack(all_body_pitches), np.stack(all_arm_position_deltas), np.stack(all_control_mode), np.stack(all_pad_lengths) + + + + def __getitem_old__(self, idx): + + + traj_group = self.hdf[self.dataset_keys[idx]] + + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + nl_command = traj_json_dict['nl_command'] + + start = 0; end = min(len(traj_steps), 6) + + #return list of dictionaries with attributes required for RT1 + all_image_obs = [] + all_nl_commands = [] + all_is_terminal = [] + all_pickup_release = [] + all_body_position = [] + all_body_yaw = [] + all_body_pitch = [] + all_arm_position = [] + all_mode = [] + + + + #build the dictionary for each sequence + while end < len(traj_steps): + + ''' + mode: stop, body, yaw, manipulation, grasping, head pitch + gripper: (x, y, z, grasp) + body: (x, y, yaw, look up/down) + ''' + image_obs = [] + + for i in range(start, end): + ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) + + image_obs.append(ith_obs) + + image_obs = np.stack(image_obs) + + + + before_end_step_metadata = json.loads(traj_group[traj_steps[end-1]].attrs['metadata']) + end_step_metadata = json.loads(traj_group[traj_steps[end]].attrs['metadata']) + + + + dictionary = { + 'observation': image_obs, + 'nl_command': nl_command, #DONE + 'is_terminal': int(end_step_metadata['steps'][0]['action']=='stop'), #DONE + 'pickup_release': self.get_pickup_release(end_step_metadata['steps'][0]['action']), #DONE + 'body_position': np.array(end_step_metadata['steps'][0]['state_body'][:3])-np.array(before_end_step_metadata['steps'][0]['state_body'][:3]), #DONE + 'body_yaw': end_step_metadata['steps'][0]['state_body'][3] - before_end_step_metadata['steps'][0]['state_body'][3], #DONE + 'body_pitch': self.get_head_pitch(end_step_metadata['steps'][0]['action']), #DONE + 'arm_position': np.array(end_step_metadata['steps'][0]['state_ee'][:3]) - np.array(before_end_step_metadata['steps'][0]['state_ee'][:3]), #DONE + 'mode': self.get_mode(end_step_metadata['steps'][0]['action']) #DONE + } + + #pre-process the data dictonary + if self.tokenize_action: + self.make_data_discrete(dictionary) + + + all_image_obs.append(dictionary['observation']) + all_nl_commands.append(dictionary['nl_command']) + all_is_terminal.append(dictionary['is_terminal']) + all_pickup_release.append(dictionary['pickup_release']) + all_body_position.append(dictionary['body_position']) + all_body_yaw.append(dictionary['body_yaw']) + all_body_pitch.append(dictionary['body_pitch']) + all_arm_position.append(dictionary['arm_position']) + all_mode.append(dictionary['mode']) + + + start += 1 + end += 1 + + #add the terminal 'stop' step + all_image_obs.append(dictionary['observation']) + all_nl_commands.append(dictionary['nl_command']) + all_is_terminal.append(1) + all_pickup_release.append(0) + all_body_position.append([0,0,0]) + all_body_yaw.append(0) + all_body_pitch.append(0) + all_arm_position.append([0,0,0]) + all_mode.append(0) + + + + + + return np.stack(all_image_obs), np.stack(all_nl_commands), np.expand_dims(np.stack(all_is_terminal), axis=1), np.expand_dims(np.stack(all_pickup_release), axis=1), np.stack(all_body_position), np.expand_dims(np.stack(all_body_yaw),axis=1), np.expand_dims(np.stack(all_body_pitch), axis=1), np.stack(all_arm_position), np.expand_dims(np.stack(all_mode), axis=1) + + +if __name__ == '__main__': + + + dataset_manager = DatasetManager(0, 0.8, 0.1, 0.1) + + dataloader = DataLoader(dataset_manager.train_dataset, batch_size=3, + shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) + + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size=2, + shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) + + + + for batch, sample_batch in enumerate(dataloader): + + # print('BATCH {}:'.format(batch)) + # print('Num Steps: {}'.format(sample_batch[0].shape[0])) + print('Batch {}: '.format(batch), sample_batch[0].shape[0]) + + + + + \ No newline at end of file diff --git a/lanmp_dataloader/scene_to_keys.json b/lanmp_dataloader/scene_to_keys.json new file mode 100644 index 000000000..da07b6395 --- /dev/null +++ b/lanmp_dataloader/scene_to_keys.json @@ -0,0 +1 @@ +{"FloorPlan_Train8_1": ["data_11:11:28", "data_11:38:43", "data_11:48:40", "data_11:51:31", "data_11:56:47", "data_11:58:17", "data_12:18:24", "data_12:31:00", "data_12:49:55", "data_12:53:51", "data_12:54:21", "data_12:57:45", "data_12:59:43", "data_13:00:14", "data_13:13:47", "data_13:18:03", "data_13:22:48", "data_13:24:35", "data_13:29:42", "data_13:30:35", "data_13:36:19", "data_13:37:24", "data_13:38:39", "data_13:42:32", "data_13:48:30", "data_13:52:48", "data_13:56:06", "data_13:58:42", "data_14:01:23", "data_14:24:32", "data_14:26:22", "data_14:31:39", "data_14:36:13", "data_14:38:15", "data_14:44:47", "data_14:45:23", "data_14:49:15", "data_14:53:25", "data_14:58:54", "data_15:06:22", "data_15:09:43", "data_15:13:05", "data_15:13:36", "data_15:14:10", "data_15:16:32", "data_15:20:09", "data_15:22:18", "data_15:25:56", "data_15:26:42", "data_15:29:24", "data_15:29:51", "data_15:30:35", "data_15:32:34", "data_15:39:22", "data_15:41:58", "data_15:43:27", "data_15:43:51", "data_16:05:05", "data_16:09:25", "data_16:11:06", "data_16:13:53", "data_16:18:35", "data_16:23:48", "data_16:26:23", "data_16:30:54", "data_16:43:19", "data_16:49:20", "data_16:52:28", "data_16:53:34", "data_16:59:06", "data_17:00:51", "data_17:02:54", "data_17:04:35", "data_17:06:16", "data_17:13:00", "data_17:20:01", "data_17:23:07", "data_17:26:09", "data_17:33:07", "data_17:47:57", "data_17:51:34", "data_17:56:54", "data_17:58:11", "data_17:59:29", "data_18:01:53", "data_18:08:32", "data_18:18:37", "data_18:22:56", "data_18:25:09", "data_18:33:34", "data_18:45:42", "data_19:09:57", "data_19:15:07", "data_19:20:52", "data_19:25:51", "data_19:34:02", "data_19:43:09", "data_19:48:33", "data_19:52:25", "data_19:53:51", "data_20:29:26", "data_21:11:22", "data_21:14:13", "data_22:26:52"], "FloorPlan_Train1_3": ["data_11:14:08", "data_12:27:37", "data_12:28:44", "data_12:30:42", "data_12:42:59", "data_12:48:44", "data_13:01:08", "data_13:10:23", "data_13:16:27", "data_13:26:27", "data_13:29:09", "data_13:33:21", "data_13:35:43", "data_13:45:31", "data_13:49:19", "data_13:53:16", "data_13:59:05", "data_14:02:16", "data_14:19:36", "data_14:22:29", "data_14:24:31", "data_14:26:42", "data_14:32:06", "data_14:34:15", "data_14:35:23", "data_14:38:31", "data_14:43:46", "data_14:46:49", "data_14:48:48", "data_14:50:47", "data_14:56:50", "data_15:01:27", "data_15:35:48", "data_15:38:38", "data_15:39:32", "data_15:42:27", "data_15:49:15", "data_15:50:49", "data_15:51:26", "data_15:52:55", "data_15:54:45", "data_15:56:44", "data_15:58:10", "data_16:01:04", "data_16:03:52", "data_16:04:17", "data_16:10:32", "data_16:10:59", "data_16:33:34", "data_16:37:28", "data_16:40:36", "data_16:40:44", "data_16:42:54", "data_16:43:00", "data_16:43:00:00", "data_16:44:16", "data_16:45:24", "data_16:47:46", "data_16:49:24", "data_16:55:46", "data_17:05:08", "data_17:07:34", "data_17:07:43", "data_17:21:35", "data_17:26:17", "data_17:29:14", "data_17:32:17", "data_17:32:27", "data_17:43:33", "data_17:47:03", "data_17:51:39", "data_17:59:00", "data_18:04:56", "data_18:11:24", "data_18:17:16", "data_18:22:49", "data_18:25:44", "data_18:28:13", "data_18:28:43", "data_18:29:38", "data_18:31:13", "data_18:35:58", "data_18:37:04", "data_18:46:02", "data_19:14:43", "data_19:31:51", "data_19:35:53", "data_20:11:23", "data_20:15:34", "data_20:57:07", "data_21:09:57", "data_21:35:32", "data_21:40:45", "data_22:55:44", "data_22:59:37", "data_23:02:34"], "FloorPlan_Train5_1": ["data_11:19:28", "data_11:23:37", "data_12:05:09", "data_12:15:11", "data_12:22:25", "data_12:37:24", "data_12:40:41", "data_12:43:21", "data_12:58:49", "data_13:14:36", "data_13:22:30", "data_13:25:14", "data_13:28:56", "data_13:29:25", "data_13:31:07", "data_13:33:29", "data_13:40:50", "data_13:42:24", "data_13:46:04", "data_14:03:55", "data_14:05:06", "data_14:09:28", "data_14:10:09", "data_14:14:11", "data_14:18:16", "data_14:23:38", "data_14:36:10", "data_14:40:10", "data_14:47:53", "data_14:50:55", "data_14:56:41", "data_14:58:02", "data_14:58:08", "data_15:03:19", "data_15:05:49", "data_15:06:39", "data_15:08:16", "data_15:13:04", "data_15:19:26", "data_15:22:08", "data_15:27:41", "data_15:29:40", "data_15:40:49", "data_15:44:42", "data_15:56:53", "data_15:58:27", "data_16:00:55", "data_16:02:46", "data_16:05:15", "data_16:06:05", "data_16:07:40", "data_16:09:36", "data_16:12:08", "data_16:26:34", "data_16:29:17", "data_16:31:09", "data_16:31:36", "data_16:35:27", "data_16:43:42", "data_16:45:58", "data_16:47:16", "data_16:50:06", "data_16:51:03", "data_16:53:36", "data_16:53:39", "data_16:53:42", "data_16:54:39", "data_16:56:38", "data_16:57:05:00", "data_16:57:25", "data_17:12:32", "data_17:17:50", "data_17:35:45", "data_17:39:05:00", "data_17:41:00", "data_17:41:08", "data_17:45:27", "data_17:50:42", "data_17:54:05", "data_17:56:23", "data_18:22:47", "data_18:31:07", "data_18:33:51", "data_18:37:38", "data_18:42:03", "data_18:44:54", "data_18:47:01", "data_18:50:53", "data_18:58:07", "data_19:04:21", "data_19:08:32", "data_19:27:25", "data_19:53:59", "data_19:57:56", "data_20:07:12", "data_22:02:06", "data_22:10:19", "data_23:06:06", "data_23:09:41", "data_23:16:06"], "FloorPlan_Train12_3": ["data_11:24:25", "data_12:04:43", "data_12:04:44", "data_12:09:11", "data_12:12:18", "data_12:13:00", "data_12:48:09", "data_12:55:46", "data_13:02:17", "data_13:04:13", "data_13:06:18", "data_13:07:22", "data_13:07:34", "data_13:08:21", "data_13:10:24", "data_13:15:55", "data_13:18:11", "data_13:19:12", "data_13:33:54", "data_13:37:23", "data_13:39:28", "data_13:40:16", "data_13:51:04", "data_13:52:30", "data_13:56:07", "data_13:57:55", "data_14:04:08", "data_14:06:14", "data_14:06:28", "data_14:07:59", "data_14:10:04", "data_14:19:43", "data_14:23:01", "data_14:25:51", "data_14:36:45", "data_14:38:16", "data_14:40:46", "data_15:04:08", "data_15:06:03", "data_15:08:14", "data_15:10:38", "data_15:13:32", "data_15:15:15", "data_15:21:58", "data_15:22:59", "data_15:23:17", "data_15:25:19", "data_15:27:29", "data_15:27:52", "data_15:34:50", "data_15:37:13", "data_15:37:30", "data_15:39:06", "data_15:39:14", "data_15:40:22", "data_15:41:15", "data_15:46:13", "data_15:47:54", "data_15:48:04", "data_15:50:55", "data_16:03:07", "data_16:11:48", "data_16:12:38", "data_16:15:33", "data_16:21:47", "data_16:22:10", "data_16:22:44", "data_16:25:33", "data_16:27:27", "data_16:33:37", "data_16:33:42", "data_16:35:20", "data_16:37:57", "data_16:58:28", "data_16:59:59", "data_17:02:20", "data_17:05:07", "data_17:07:22", "data_17:08:14", "data_17:08:43", "data_17:10:41", "data_17:12:20", "data_17:16:57", "data_17:25:26", "data_17:31:59", "data_17:39:05", "data_18:05:31", "data_18:06:05", "data_18:09:48", "data_18:11:32", "data_18:20:49", "data_18:38:30", "data_18:40:29", "data_18:44:56", "data_19:32:42", "data_19:36:17", "data_19:38:40", "data_19:55:46", "data_19:58:40", "data_20:04:58", "data_20:36:00", "data_20:40:25", "data_20:40:56", "data_20:43:46", "data_21:22:47", "data_21:27:13", "data_21:36:02", "data_21:39:40"], "FloorPlan_Train7_5": ["data_11:33:11", "data_11:35:24", "data_11:38:27", "data_11:44:50", "data_11:50:57", "data_12:03:39", "data_12:30:12", "data_12:36:36", "data_12:41:02", "data_12:45:50", "data_12:46:17", "data_12:48:23", "data_12:50:47", "data_12:59:13", "data_13:01:06", "data_13:06:40", "data_13:10:05", "data_13:19:26", "data_13:33:39", "data_13:34:59", "data_13:39:14", "data_13:39:53", "data_13:41:08", "data_13:44:39", "data_13:48:45", "data_13:53:16:00", "data_14:17:20", "data_14:19:54", "data_14:22:51", "data_14:23:49", "data_14:29:19", "data_14:40:36", "data_14:43:02", "data_14:45:24", "data_14:52:27", "data_15:00:11", "data_15:02:05", "data_15:05:00", "data_15:06:51", "data_15:08:00", "data_15:08:23", "data_15:09:40", "data_15:10:35", "data_15:15:28", "data_15:18:01", "data_15:19:33", "data_15:20:32", "data_15:22:15", "data_15:24:10", "data_15:33:02", "data_15:35:16", "data_15:36:12", "data_15:37:15", "data_15:58:50", "data_16:00:52", "data_16:02:56", "data_16:03:52:00", "data_16:04:13", "data_16:08:41", "data_16:10:21", "data_16:12:36", "data_16:15:15", "data_16:18:47", "data_16:21:30", "data_16:33:14", "data_16:35:18", "data_16:36:47", "data_16:37:29", "data_16:43:59", "data_16:47:31", "data_16:55:23", "data_16:55:40", "data_16:57:05", "data_16:57:21", "data_16:58:20", "data_16:58:53", "data_16:59:33", "data_16:59:34", "data_17:00:42", "data_17:00:58", "data_17:02:46", "data_17:02:49", "data_17:03:08", "data_17:10:18", "data_17:32:08", "data_17:39:16", "data_17:43:47", "data_17:46:14", "data_17:48:24", "data_17:58:02", "data_17:59:14", "data_18:01:35", "data_18:06:24", "data_18:09:10", "data_18:12:41", "data_18:15:58", "data_18:26:13", "data_18:39:40", "data_18:41:38", "data_18:45:39", "data_18:54:32", "data_18:57:41", "data_18:59:56", "data_19:00:23", "data_19:02:18", "data_19:03:13", "data_19:15:22", "data_19:18:14", "data_19:20:26", "data_19:27:05", "data_20:26:48", "data_20:33:59", "data_22:17:48", "data_23:21:12", "data_23:26:05", "data_23:27:44"]} \ No newline at end of file diff --git a/rt1_pytorch/__init__.py b/rt1_pytorch/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/rt1_pytorch/film_efficientnet/__init__.py b/rt1_pytorch/film_efficientnet/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/rt1_pytorch/film_efficientnet/film_conditioning_layer.py b/rt1_pytorch/film_efficientnet/film_conditioning_layer.py new file mode 100644 index 000000000..8524676fd --- /dev/null +++ b/rt1_pytorch/film_efficientnet/film_conditioning_layer.py @@ -0,0 +1,38 @@ +import torch +from torch import nn + + +class FilmConditioning(nn.Module): + def __init__(self, embedding_dim, num_channels): + super().__init__() + self._projection_add = nn.Linear(embedding_dim, num_channels) + self._projection_mult = nn.Linear(embedding_dim, num_channels) + self.num_channels = num_channels + self.embedding_dim = embedding_dim + # From the paper + nn.init.zeros_(self._projection_add.weight) + nn.init.zeros_(self._projection_mult.weight) + nn.init.zeros_(self._projection_add.bias) + nn.init.zeros_(self._projection_mult.bias) + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" + assert ( + context.shape[1] == self.embedding_dim + ), f"Unexpected context shape: {context.shape}" + assert ( + x.shape[0] == context.shape[0] + ), f"x and context must have the same batch size, but got {x.shape} and {context.shape}" + projected_cond_add = self._projection_add(context) + projected_cond_mult = self._projection_mult(context) + + if len(x.shape) == 4: + projected_cond_add = projected_cond_add.unsqueeze(2).unsqueeze(3) + projected_cond_mult = projected_cond_mult.unsqueeze(2).unsqueeze(3) + else: + assert len(x.shape) == 2 + + # Original FiLM paper argues that 1 + gamma centers the initialization at + # identity transform. + result = (1 + projected_cond_mult) * x + projected_cond_add + return result \ No newline at end of file diff --git a/rt1_pytorch/film_efficientnet/film_efficientnet.py b/rt1_pytorch/film_efficientnet/film_efficientnet.py new file mode 100644 index 000000000..a9c03573b --- /dev/null +++ b/rt1_pytorch/film_efficientnet/film_efficientnet.py @@ -0,0 +1,446 @@ +"""EfficientNet models modified with added film layers. + +Mostly taken from: +https://github.com/pytorch/vision/blob/main/torchvision/models/efficientnet.py +""" +import copy +import math +from functools import partial +from typing import Any, Callable, List, Optional, Sequence, Union + +import torch +from torch import nn +from torchvision.models._api import Weights +from torchvision.models._meta import _IMAGENET_CATEGORIES +from torchvision.models._utils import _ovewrite_named_param +from torchvision.models.efficientnet import ( + EfficientNet_B0_Weights, + EfficientNet_B1_Weights, + EfficientNet_B2_Weights, + EfficientNet_B3_Weights, + EfficientNet_B4_Weights, + EfficientNet_B5_Weights, + EfficientNet_B6_Weights, + EfficientNet_B7_Weights, + EfficientNet_V2_L_Weights, + EfficientNet_V2_M_Weights, + EfficientNet_V2_S_Weights, + FusedMBConv, + FusedMBConvConfig, + MBConv, + MBConvConfig, + _efficientnet_conf, + _MBConvConfig, +) +from torchvision.ops.misc import Conv2dNormActivation +from torchvision.utils import _log_api_usage_once + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning + + +class MBConvFilm(nn.Module): + """MBConv or FusedMBConv with FiLM context""" + + def __init__(self, embedding_dim: int, mbconv: Union[MBConv, FusedMBConv]): + super().__init__() + self.mbconv = mbconv + num_channels = mbconv.block[-1][1].num_features + self.film = FilmConditioning( + embedding_dim=embedding_dim, num_channels=num_channels + ) + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + x = self.mbconv(x) + x = self.film(x, context) + return x + + +class _FilmEfficientNet(nn.Module): + def __init__( + self, + inverted_residual_setting: Sequence[Union[MBConvConfig, FusedMBConvConfig]], + dropout: float, + include_top: bool = False, + stochastic_depth_prob: float = 0.2, + num_classes: int = 1000, + norm_layer: Optional[Callable[..., nn.Module]] = None, + last_channel: Optional[int] = None, + embedding_dim: Optional[int] = 512, + ) -> None: + """ + EfficientNet V1 and V2 main class with additional FiLM context layer + + Args: + inverted_residual_setting (Sequence[Union[MBConvConfig, FusedMBConvConfig]]): Network structure + dropout (float): The droupout probability + include_top (bool): Whether to include the classification head + stochastic_depth_prob (float): The stochastic depth probability + num_classes (int): Number of classes + norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use + last_channel (int): The number of channels on the penultimate layer + embedding_dim (int): The dimension of the embedding space + """ + super().__init__() + _log_api_usage_once(self) + + if not inverted_residual_setting: + raise ValueError("The inverted_residual_setting should not be empty") + elif not ( + isinstance(inverted_residual_setting, Sequence) + and all([isinstance(s, _MBConvConfig) for s in inverted_residual_setting]) + ): + raise TypeError( + "The inverted_residual_setting should be List[MBConvConfig]" + ) + + if norm_layer is None: + norm_layer = nn.BatchNorm2d + + layers: List[nn.Module] = [] + + # building first layer + firstconv_output_channels = inverted_residual_setting[0].input_channels + layers.append( + Conv2dNormActivation( + 3, + firstconv_output_channels, + kernel_size=3, + stride=2, + norm_layer=norm_layer, + activation_layer=nn.SiLU, + ) + ) + + # building inverted residual blocks + total_stage_blocks = sum(cnf.num_layers for cnf in inverted_residual_setting) + stage_block_id = 0 + for cnf in inverted_residual_setting: + stage: List[nn.Module] = [] + for _ in range(cnf.num_layers): + # copy to avoid modifications. shallow copy is enough + block_cnf = copy.copy(cnf) + + # overwrite info if not the first conv in the stage + if stage: + block_cnf.input_channels = block_cnf.out_channels + block_cnf.stride = 1 + + # adjust stochastic depth probability based on the depth of the stage block + sd_prob = ( + stochastic_depth_prob * float(stage_block_id) / total_stage_blocks + ) + stage.append( + MBConvFilm( + embedding_dim=embedding_dim, + mbconv=block_cnf.block(block_cnf, sd_prob, norm_layer), + ) + ) + stage_block_id += 1 + + layers.append(nn.Sequential(*stage)) + + # building last several layers + lastconv_input_channels = inverted_residual_setting[-1].out_channels + lastconv_output_channels = ( + last_channel if last_channel is not None else 4 * lastconv_input_channels + ) + layers.append( + Conv2dNormActivation( + lastconv_input_channels, + lastconv_output_channels, + kernel_size=1, + norm_layer=norm_layer, + activation_layer=nn.SiLU, + ) + ) + + self.features = nn.Sequential(*layers) + if include_top: + self.avgpool = nn.AdaptiveAvgPool2d(1) + self.classifier = nn.Sequential( + nn.Dropout(p=dropout, inplace=True), + nn.Linear(lastconv_output_channels, num_classes), + nn.Softmax(dim=1), + ) + else: + self.avgpool = nn.Identity() + self.classifier = nn.Identity() + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode="fan_out") + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): + nn.init.ones_(m.weight) + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Linear): + init_range = 1.0 / math.sqrt(m.out_features) + nn.init.uniform_(m.weight, -init_range, init_range) + nn.init.zeros_(m.bias) + + self.embedding_dim = embedding_dim + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + for feature in self.features: + for layer in feature: + if isinstance(layer, MBConvFilm): + x = layer(x, context) + else: + x = layer(x) + + x = self.avgpool(x) + x = torch.squeeze(x, dim=(2, 3)) # squeeze if h = w = 1 + x = self.classifier(x) + + return x + + +def get_weights(arch: str) -> Weights: + """ + Returns the default weights for the given EfficientNet model. + + Parameters: + arch (str): The EfficientNet variant to use. Allowed values are: + - 'efficientnet_b0' + - 'efficientnet_b1' + - 'efficientnet_b2' + - 'efficientnet_b3' + - 'efficientnet_b4' + - 'efficientnet_b5' + - 'efficientnet_b6' + - 'efficientnet_b7' + - 'efficientnet_v2_s' + - 'efficientnet_v2_m' + - 'efficientnet_v2_l' + + Returns: + WeightsEnum: The default weights for the given architecture. + + Raises: + ValueError: If the given architecture is not supported. + """ + + if arch == "efficientnet_b0": + weights = EfficientNet_B0_Weights.DEFAULT + elif arch == "efficientnet_b1": + weights = EfficientNet_B1_Weights.DEFAULT + elif arch == "efficientnet_b2": + weights = EfficientNet_B2_Weights.DEFAULT + elif arch == "efficientnet_b3": + weights = EfficientNet_B3_Weights.DEFAULT + elif arch == "efficientnet_b4": + weights = EfficientNet_B4_Weights.DEFAULT + elif arch == "efficientnet_b5": + weights = EfficientNet_B5_Weights.DEFAULT + elif arch == "efficientnet_b6": + weights = EfficientNet_B6_Weights.DEFAULT + elif arch == "efficientnet_b7": + weights = EfficientNet_B7_Weights.DEFAULT + elif arch == "efficientnet_v2_s": + weights = EfficientNet_V2_S_Weights.DEFAULT + elif arch == "efficientnet_v2_m": + weights = EfficientNet_V2_M_Weights.DEFAULT + elif arch == "efficientnet_v2_l": + weights = EfficientNet_V2_L_Weights.DEFAULT + else: + raise ValueError(f"Unsupported model type `{arch}`") + + return weights + + +class FilmEfficientNet(nn.Module): + def __init__( + self, + arch: str, + include_top: bool = False, + embedding_dim: int = 512, + pretrained: Optional[bool] = True, + weights: Optional[Weights] = None, + progress: Optional[bool] = True, + device: Optional[Union[str, torch.device]] = "cuda", + **kwargs, + ): + """Builds a FilmEfficientNet model. + + Args: + arch (str): The EfficientNet variant to use. Allowed values are: + - 'efficientnet_b0' + - 'efficientnet_b1' + - 'efficientnet_b2' + - 'efficientnet_b3' + - 'efficientnet_b4' + - 'efficientnet_b5' + - 'efficientnet_b6' + - 'efficientnet_b7' + - 'efficientnet_v2_s' + - 'efficientnet_v2_m' + - 'efficientnet_v2_l' + include_top (bool, optional): Whether to include the classification head + embedding_dim (int, optional): The dimensionality of the output embeddings. + pretrained (bool, optional): Whether to load pretrained EfficientNet weights. + Defaults to True. + weights (WeightsEnum, optional): The pretrained weights to use. + only allowed if `pretrained==False`. Defaults to None. + progress (bool, optional): If True, displays a progress bar of the + download to stderr. Default is True. + device (torch.device, optional): The device on which the model will be + **kwargs: parameters passed to the `FilmEfficientNet` class. + """ + super().__init__() + norm_layer = None + if arch == "efficientnet_b0": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.0, depth_mult=1.0 + ) + dropout = 0.2 + self.output_hw = 7 + elif arch == "efficientnet_b1": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.0, depth_mult=1.1 + ) + dropout = 0.2 + self.output_hw = 8 + elif arch == "efficientnet_b2": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.1, depth_mult=1.2 + ) + dropout = 0.3 + self.output_hw = 9 + elif arch == "efficientnet_b3": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.2, depth_mult=1.4 + ) + dropout = 0.3 + self.output_hw = 10 + elif arch == "efficientnet_b4": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.4, depth_mult=1.8 + ) + dropout = 0.4 + self.output_hw = 12 + elif arch == "efficientnet_b5": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.6, depth_mult=2.2 + ) + dropout = 0.4 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 15 + elif arch == "efficientnet_b6": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.8, depth_mult=2.6 + ) + dropout = 0.5 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 17 + elif arch == "efficientnet_b7": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=2.0, depth_mult=3.1 + ) + dropout = 0.5 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 20 + elif arch == "efficientnet_v2_s": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.2 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 12 + elif arch == "efficientnet_v2_m": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.3 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 15 + elif arch == "efficientnet_v2_l": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.4 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 15 + + assert ( + weights is None or not pretrained + ), "Cannot pass in custom weights with pretrained=True" + weights = get_weights(arch) if pretrained else weights + + if weights is not None: + _ovewrite_named_param( + kwargs, "num_classes", len(weights.meta["categories"]) + ) + + model = _FilmEfficientNet( + inverted_residual_setting, + dropout, + include_top=include_top, + last_channel=last_channel, + norm_layer=norm_layer, + embedding_dim=embedding_dim, + **kwargs, + ) + + if weights is not None: + state_dict = weights.get_state_dict(progress=progress) + new_state_dict = {} + for k, v in state_dict.items(): + if ".block" in k: + new_state_dict[k.replace(".block", ".mbconv.block")] = v + else: + new_state_dict[k] = v + model.load_state_dict( + new_state_dict, + strict=False, + ) + + self.model = model.to(device) + self.preprocess = weights.transforms(antialias=True) if weights else lambda x: x + + self.conv1x1 = nn.Conv2d( + in_channels=self.model.features[-1].out_channels, + out_channels=embedding_dim, + kernel_size=(1, 1), + stride=(1, 1), + padding="same", + bias=False, + device=device, + ) + nn.init.kaiming_normal_(self.conv1x1.weight) + self.film_layer = FilmConditioning(embedding_dim, embedding_dim).to(device) + self.include_top = include_top + self.embedding_dim = embedding_dim + + def forward( + self, image: torch.Tensor, context: Optional[torch.Tensor] = None + ) -> torch.Tensor: + if len(image.shape) == 3: + # Add batch dimension + image = image.unsqueeze(0) + assert len(image.shape) == 4, f"Unexpected image shape: {image.shape}" + if image.shape[-1] == 3: + # (B, H, W, C) -> (B, C, H, W) + image = image.permute(0, 3, 1, 2) + if torch.max(image) >= 1.0: + # Normalize to [0, 1] + image = image / 255.0 + assert torch.min(image) >= 0.0 and torch.max(image) <= 1.0 + image = self.preprocess(image) + + if context is not None and self.include_top: + raise ValueError("Context cannot be passed in if include_top=True") + elif context is None: + context = torch.zeros( + image.shape[0], self.embedding_dim, device=image.device + ) + + features = self.model(image, context) + if not self.include_top: + features = self.conv1x1(features) + features = self.film_layer(features, context) + return features + + +def decode_predictions(preds: torch.Tensor, top=5): + preds = preds.detach().cpu().numpy() + results = [] + for pred in preds: + top_indices = pred.argsort()[-top:][::-1] + result = [(_IMAGENET_CATEGORIES[i], pred[i]) for i in top_indices] + results.append(result) + return results \ No newline at end of file diff --git a/rt1_pytorch/rt1_model.py b/rt1_pytorch/rt1_model.py new file mode 100644 index 000000000..30388f638 --- /dev/null +++ b/rt1_pytorch/rt1_model.py @@ -0,0 +1,217 @@ +from typing import Optional + +import torch +from einops import rearrange +from torch import nn + +from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer + + +def posemb_sincos_1d(seq, dim, temperature=10000, device=None, dtype=torch.float32): + """ + Generate positional embeddings using sine and cosine functions for a 1-dimensional sequence. + + Parameters: + seq (int): The length of the sequence. + dim (int): The dimension of the positional embeddings. + temperature (float, optional): The temperature parameter for the sine function. Defaults to 10000. + device (torch.device, optional): The device for tensor operations. Defaults to None. + dtype (torch.dtype, optional): The data type of the positional embeddings. Defaults to torch.float32. + + Returns: + torch.Tensor: The positional embeddings of shape (seq, dim), with each element computed as the concatenation of the sine and cosine values. + + """ + n = torch.arange(seq, device=device) + omega = torch.arange(dim // 2, device=device) / (dim // 2 - 1) + omega = 1.0 / (temperature**omega) + + n = n[:, None] * omega[None, :] + pos_emb = torch.cat((n.sin(), n.cos()), dim=1) + return pos_emb.type(dtype) + + +# Robotic Transformer +class RT1Model(nn.Module): + def __init__( + self, + arch: str = "efficientnet_b3", + tokens_per_action=11, + action_bins=256, + num_layers=4, + num_heads=8, + feed_forward_size=512, + dropout_rate=0.1, + time_sequence_length=6, + embedding_dim=512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + device="cuda", + ): + """ + Initializes the RT1Model. + + Parameters: + arch (str): The efficientnet variant to use. Default is "efficientnet_b3". + tokens_per_action (int): The number of tokens per action. Default is 11. + action_bins (int): The number of action bins. Default is 256. + num_layers (int): The number of transformer layers. Default is 6. + num_heads (int): The number of attention heads. Default is 8. + feed_forward_size (int): The size of the feed-forward layer. Default is 512. + dropout_rate (float): The dropout rate. Default is 0.1. + time_sequence_length (int): The length of the time sequence. Default is 6. + embedding_dim (int): The dimension of the embedding. Default is 512. + use_token_learner (bool): Whether to use token learner. Default is True. + token_learner_bottleneck_dim (int): The dimension of the token learner bottleneck. Default is 64. + token_learner_num_output_tokens (int): The number of output tokens of the token learner. Default is 8. + device (torch.device, optional): The device for tensor operations. Defaults to "cuda". + + Returns: + None + """ + super().__init__() + self.time_sequence_length = time_sequence_length + self.action_encoder = nn.Linear(action_bins, embedding_dim, device=device) + self.image_tokenizer = RT1ImageTokenizer( + arch=arch, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_bottleneck_dim=token_learner_bottleneck_dim, + token_learner_num_output_tokens=token_learner_num_output_tokens, + dropout_rate=dropout_rate, + device=device, + ) + + self.num_tokens = self.image_tokenizer.num_output_tokens + + self.transformer = nn.Transformer( + d_model=embedding_dim, + nhead=num_heads, + num_encoder_layers=num_layers, + num_decoder_layers=num_layers, + dim_feedforward=feed_forward_size, + dropout=dropout_rate, + activation="gelu", + batch_first=True, + device=device, + ) + + self.to_logits = nn.Sequential( + nn.LayerNorm(embedding_dim), + nn.Linear(embedding_dim, action_bins), + ).to(device) + + self.tokens_per_action = tokens_per_action + self.action_bins = action_bins + self.embedding_dim = embedding_dim + self.device = device + + def forward( + self, + videos: torch.Tensor, + texts: Optional[torch.Tensor] = None, + action_logits: Optional[torch.Tensor] = None, + ): + """ + Forward pass of the model. + + Args: + videos (torch.Tensor): The input videos. + Shape is (b, f, h, w, c) or (b, f, c, h, w). + texts (Optional[torch.Tensor]): The input text embedding. + Shape is (b, f, embedding_dim). + action_logits (Optional[torch.Tensor]): The input action_logits. + Shape is (b, f, tokens_per_action, action_bins). + + Returns: + torch.Tensor: The output logits. + Shape is (b, f, tokens_per_action, action_bins). + """ + b, f, *_ = videos.shape + assert ( + f == self.time_sequence_length + ), f"Expected {self.time_sequence_length} frames, got videos.shape[1] = {f}" + + if texts is None: + texts = torch.zeros((b, f, self.embedding_dim), device=self.device) + if action_logits is None: + action_logits = torch.zeros( + (b, f, self.tokens_per_action, self.action_bins), device=self.device + ) + elif action_logits.shape != (b, f, self.tokens_per_action, self.action_bins): + raise ValueError( + f"""Expected action_logits.shape = (b, f, tokens_per_action, action_bins), + got {action_logits.shape}; did you pass in raw actions instead?""" + ) + + # pack time dimension into batch dimension + videos = rearrange(videos, "b f ... -> (b f) ...") + texts = rearrange(texts, "b f d -> (b f) d") + + # tokenize images and texts + tokens = self.image_tokenizer(videos, texts) + + # unpack time dimension from batch dimension + tokens = rearrange(tokens, "(b f) c n -> b f c n", b=b, f=f) + + # pack time dimension into token dimension + tokens = rearrange(tokens, "b f c n -> b (f n) c") + action_logits = rearrange(action_logits, "b f a d -> b (f a) d") + + # sinusoidal positional embedding + pos_emb = posemb_sincos_1d(tokens.shape[1], tokens.shape[2], device=self.device) + tokens = tokens + pos_emb + + # causal mask for tokens + token_mask = torch.ones( + tokens.shape[1], tokens.shape[1], dtype=torch.bool + ).tril(0) + token_mask = ~token_mask + token_mask = token_mask.to(self.device) + + # encode action_logits to have the same embedding dimension as tokens + action_tokens = self.action_encoder(action_logits) + + pos_emb = posemb_sincos_1d( + action_tokens.shape[1], action_tokens.shape[2], device=self.device + ) + action_tokens = action_tokens + pos_emb + + # action mask: do not let action_logits attend to previous action_logits, + # a_t is independent of a_{t-1} given pi and s_t + action_mask = torch.ones( + self.time_sequence_length, self.time_sequence_length, dtype=torch.bool + ).tril(0) + action_mask = torch.kron( + torch.eye(self.tokens_per_action, self.tokens_per_action, dtype=torch.bool), + action_mask, + ) + action_mask = ~action_mask + action_mask = action_mask.to(self.device) + + # causal mask between tokens and action_logits; + # a_t attends to s_t' for all t'<=t + memory_mask = torch.ones( + self.time_sequence_length, self.time_sequence_length, dtype=torch.bool + ).tril(0) + memory_mask = torch.kron( + memory_mask, + torch.ones(self.tokens_per_action, self.num_tokens, dtype=torch.bool), + ) + memory_mask = ~memory_mask + memory_mask = memory_mask.to(self.device) + + attended_tokens = self.transformer( + src=tokens, + src_mask=token_mask, + tgt=action_tokens, + tgt_mask=action_mask, + memory_mask=memory_mask, + ) + + # unpack time dimension from token dimension + attended_tokens = rearrange(attended_tokens, "b (f n) c -> b f n c", b=b, f=f) + + logits = self.to_logits(attended_tokens) + return logits \ No newline at end of file diff --git a/rt1_pytorch/rt1_policy.py b/rt1_pytorch/rt1_policy.py new file mode 100644 index 000000000..f68155a56 --- /dev/null +++ b/rt1_pytorch/rt1_policy.py @@ -0,0 +1,234 @@ +from typing import Dict, List, Optional, Tuple, Union + +import gymnasium as gym +import numpy as np +import torch +import tree +from einops import rearrange +from torch.nn import functional as F +import pdb + +from rt1_pytorch.rt1_model import RT1Model +from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer + + +class RT1Policy: + def __init__( + self, + observation_space: gym.spaces.Dict, + action_space: gym.spaces.Dict, + arch: str = "efficientnet_b3", + action_bins=256, + num_layers=4, + num_heads=8, + feed_forward_size=256, + dropout_rate=0.1, + time_sequence_length=6, + embedding_dim=512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + device="cuda", + checkpoint_path: Optional[str] = None, + ): + """ + Initializes an instance of the class. + + Args: + observation_space (gym.spaces.Dict): The observation space of the environment. + action_space (gym.spaces.Dict): The action space of the environment. + arch (str, optional): The architecture of the model. Defaults to "efficientnet_b3". + action_bins (int, optional): The number of bins for discretizing continuous action spaces. Defaults to 256. + num_layers (int, optional): The number of transformer layers in the model. Defaults to 8. + num_heads (int, optional): The number of attention heads in each transformer layer. Defaults to 8. + feed_forward_size (int, optional): The size of the feed-forward layer in the transformer. Defaults to 256. + dropout_rate (float, optional): The dropout rate for the transformer layers. Defaults to 0.1. + time_sequence_length (int, optional): The length of the time sequence for the model. Defaults to 6. + embedding_dim (int, optional): The dimensionality of the input embeddings. Defaults to 512. + use_token_learner (bool, optional): Whether to use the token learner module. Defaults to True. + token_learner_bottleneck_dim (int, optional): The dimensionality of the bottleneck layer in the token learner. Defaults to 64. + token_learner_num_output_tokens (int, optional): The number of output tokens from the token learner. Defaults to 8. + device (str, optional): The device to use for the model. Defaults to "cuda". + checkpoint_path (str, optional): load checkpoint from path. Defaults to None. + + Returns: + None + """ + self.observation_space = observation_space + self.action_space = action_space + self.action_bins = action_bins + self.action_tokenizer = RT1ActionTokenizer( + action_space=action_space, + action_bins=action_bins, + action_order=list(action_space.keys()), + ) + + self.model = RT1Model( + arch=arch, + tokens_per_action=self.action_tokenizer.tokens_per_action, + action_bins=action_bins, + num_layers=num_layers, + num_heads=num_heads, + feed_forward_size=feed_forward_size, + dropout_rate=dropout_rate, + time_sequence_length=time_sequence_length, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_bottleneck_dim=token_learner_bottleneck_dim, + token_learner_num_output_tokens=token_learner_num_output_tokens, + device=device, + ) + + self.embedding_dim = embedding_dim + + for action_space in self.action_space.values(): + if ( + isinstance(action_space, gym.spaces.Discrete) + and action_space.n == time_sequence_length + ): + raise ValueError( + f"""stupid hack:Time sequence length ({time_sequence_length}) + must be different from action space length ({action_space.n}).""" + ) + + self.device = device + if checkpoint_path is not None: + print(f"Loading checkpoint from {checkpoint_path}...") + self.model.load_state_dict(torch.load(checkpoint_path)) + + def preprocess( + self, + videos: Union[np.ndarray, List[np.ndarray]], + texts: Union[np.ndarray, List[np.ndarray]], + actions: Optional[Dict] = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Preprocesses the given videos, texts, and actions. + + Args: + videos (Union[np.ndarray, List[np.ndarray]]): The input videos to preprocess. + shape: (b, t, c, h, w) or (b, t, h, w, c) + texts (Union[np.ndarray, List[np.ndarray]]): The input texts to preprocess. + shape: (b, t, d) + actions (Optional[Dict]): The input actions to preprocess. Defaults to None. + shape: (b, t, a) + + Returns: + Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: A tuple containing the preprocessed videos, texts, and actions. + """ + if isinstance(videos, torch.Tensor): + videos = videos.to(self.device) + elif not isinstance(videos, np.ndarray): + videos = np.stack(videos, axis=0) + + if not isinstance(videos, torch.Tensor): + videos = torch.tensor(videos, device=self.device, dtype=torch.float32) + + if isinstance(texts, torch.Tensor): + texts = texts.to(self.device) + elif not isinstance(texts, np.ndarray): + texts = np.stack(texts, axis=0) + if not isinstance(texts, torch.Tensor): + texts = torch.tensor(texts, device=self.device, dtype=torch.float32) + + + if actions is not None: + actions = { + k: np.stack(v, axis=0) if not (isinstance(v, np.ndarray)) else v + for k, v in actions.items() + } + + + actions = tree.map_structure( + lambda a: rearrange(a, "b f ... -> (b f) ..."), actions + ) + actions = self.action_tokenizer.tokenize(actions) + actions = torch.tensor(actions, device=self.device, dtype=torch.long) + actions = rearrange(actions, "(b f) ... -> b f ...", b=videos.shape[0]) + + return videos, texts, actions + + def forward( + self, + videos: torch.Tensor, + texts: torch.Tensor, + action_logits: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Forward pass through the model. + + Args: + videos (torch.Tensor): Input videos. + texts (torch.Tensor): input contexts. + action_logits (Optional[torch.Tensor]): Optional input action logits. + + Returns: + action_logits (Tuple[torch.Tensor, torch.Tensor]): + A tuple containing the sampled actions and the action logits. + """ + action_logits = self.model(videos, texts, action_logits) + actions = torch.distributions.Categorical(logits=action_logits) + actions = actions.sample() + return actions, action_logits + + def loss(self, observations: Dict, target_actions: Dict) -> torch.Tensor: + """ + Calculates the loss function for the given inputs. + + Args: + observations (Dict): A dictionary containing the observations. + It should have the following keys: + - "image" (np.ndarray): The video observations. + - "context" (np.ndarray): The context. + target_actions (Dict): A dictionary containing the target actions. + + Returns: + torch.Tensor: The calculated loss value. + + Raises: + None + """ + videos = observations["image"] + texts = observations["context"] + videos, texts, target_actions = self.preprocess( + videos, + texts, + target_actions, + ) + _, action_logits = self.forward(videos, texts) + + action_logits = rearrange(action_logits, "b f a d -> (b f a) d") + target_actions = rearrange(target_actions, "b f a -> (b f a)") + loss = F.cross_entropy(action_logits, target_actions, reduction="sum") + loss = loss / videos.shape[0] + + + dummy_loss = F.cross_entropy(action_logits, target_actions, reduction="none") + loss_std = torch.std(dummy_loss) + + return loss, loss_std + + def act(self, observations: Dict) -> Dict[str, np.ndarray]: + """ + Performs an action based on the given observations. + Note that this takes in observations of shape (b,t, ...) + but only returns the last action for each trajectory of shape (b, ...). + + Args: + observations (Dict): A dictionary containing the observations. It should have the following keys: + - "image" (np.ndarray): The video observations. + - "context" (np.ndarray): The context. + + Returns: + Dict[str, np.ndarray]: A dictionary containing the actions. It has the following keys: + - "actions" (np.ndarray): The actions performed based on the observations. + """ + videos = observations["image"] + texts = observations["context"] + videos, texts, _ = self.preprocess(videos, texts) + with torch.no_grad(): + actions, _ = self.forward(videos, texts) + actions = actions.detach().cpu().numpy() + actions = self.action_tokenizer.detokenize(actions) + actions = tree.map_structure(lambda a: a[:, -1], actions) + return actions diff --git a/rt1_pytorch/tokenizers/__init__.py b/rt1_pytorch/tokenizers/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/rt1_pytorch/tokenizers/action_tokenizer.py b/rt1_pytorch/tokenizers/action_tokenizer.py new file mode 100644 index 000000000..542aa6ec3 --- /dev/null +++ b/rt1_pytorch/tokenizers/action_tokenizer.py @@ -0,0 +1,184 @@ +"""A simple action tokenizer used with Robotics Transformer 1. + +As an example, if an action is: +{ + 'base_displacement_vector': + , + 'base_displacement_vertical_rotation': + , + 'gripper_closedness_action': + , + 'rotation_delta': + , + 'terminate_episode': + , + 'world_vector': + +} + +Then we build a sequence of tokens of length 11 [one for each dimension]. +The int32 type action dimensions are already tokenized, +the float dimensions are bucketed according to the spaces min and max. Each +dimension has 'action_bins' buckets. + +Currently, this tokenizer assumes one action space and it is highly recommended +to spaceify the 'action_order', i.e. the order of keys in the dict. +Since after tokenization you lose that information, this +will be useful for debugging. Actions may also be subselected for prediction, +since not all actions are needed in the action_order. +""" +from typing import Dict, Optional + +import gymnasium as gym +import numpy as np +from gymnasium.spaces import Box, Discrete +import pdb + +class RT1ActionTokenizer: + """Tokenizes based on vocab size.""" + + def __init__( + self, + action_space: gym.spaces.Dict, + action_bins: int, + action_order: Optional[list[str]] = None, + ): + """Instantiates an RT1ActionTokenizer. + + Args: + action_bins: Number of buckets to discretize action to. + action_order: Order of the action names, used to discern the order of + tokenized actions to detokenize and assemble back to action tensor + """ + self._action_bins = action_bins + + # filter the action keys + lanmp_keys = ['terminate_episode', 'pickup_release', 'body_position_delta', 'body_yaw_delta','body_pitch_delta','arm_position_delta','control_mode'] + bridge_keys = ['terminate_episode','world_vector', 'open_gripper', "rotation_delta"] + jaco_keys = ['terminate_episode','world_vector', 'gripper_closedness_action'] + + #NOTE: change both lines below to the specific dataset keys + action_order = lanmp_keys #bridge_keys #jaco_keys + action_space = {key: action_space[key] for key in lanmp_keys if key in set(action_space.keys())} + self._action_space = action_space + if action_order is None: + self._action_order = list(action_space.keys()) + else: + for action in action_order: + assert ( + action in action_space.keys() + ), f"action: {action} not in action_space: {action_space.keys()}" + self._action_order = action_order + self._tokens_per_action = 0 + for action in self._action_order: + action_shape = action_space[action].shape + if isinstance(action_space, gym.spaces.Box) and len(action_shape) != 1: + raise ValueError( + f"Only action shapes with single dimension supported, got {action_shape}" + ) + if isinstance(action_space[action], Discrete): + # Int32 actions are already assumed to be tokens. + self._tokens_per_action += 1 + elif isinstance(action_space[action], Box): + if len(action_shape) != 1: + raise ValueError( + f"Only action shapes with single dimension supported, got {action_shape}" + ) + self._tokens_per_action += action_shape[0] + else: + raise ValueError( + f"Unsupported action space: {type(action_space[action])}" + ) + + # We measure # of action tokens in two different way. One is by checking + # from action_order (above) and the other is by looping through the + # action space (below). We aseert the # of action tokens are the same + # calculated by these two ways. This will assure action_order is correctly + # configured, otherwise, it will throw an error in the assert. + num_action_token = 0 + for space in action_space.values(): + if space.dtype == np.int_: + num_action_token += 1 + else: + num_action_token += space.shape[-1] + assert ( + self._tokens_per_action == num_action_token + ), f"{self._tokens_per_action} != {num_action_token}" + + @property + def tokens_per_action(self) -> int: + return self._tokens_per_action + + @property + def action_space(self) -> gym.spaces.Dict: + return self._action_space + + @property + def action_order(self) -> list[str]: + return self._action_order + + def tokenize(self, action: Dict) -> np.ndarray: + """Tokenizes an action.""" + + action_tokens = [] + for k in self._action_order: + #print("k equals " + str(k)) + #print(action.keys()) + #print(action) + act = action[k] # a is [batch, (time), action_size] + space = self._action_space[k] + if isinstance(space, gym.spaces.Discrete): + # Int32 actions are already assumed to be tokens + if not (isinstance(act, np.ndarray)): + act = np.array(act, dtype=np.int32) + act = np.expand_dims(act, axis=-1) + if not np.all(act < space.n): + raise ValueError(f"Invalid action: {act} >= {space.n}") + token = act + elif isinstance(space, gym.spaces.Box): + low = space.low[0] + high = space.high[0] + act = np.clip(act, low, high) + # Normalize the action [batch, actions_size] + token = (act - low) / (high - low) + # Bucket and discretize the action to action_bins, [batch, actions_size] + token = (token * (self._action_bins - 1)).astype(np.int32) + #TODO: bridge + if k == 'open_gripper': + token = token[:,None] + action_tokens.append(token) + #print(k, token.shape) + # Append all actions, [batch, (time), all_actions_size] + action_tokens = np.concatenate(action_tokens, axis=-1) + return action_tokens + + def detokenize(self, action_tokens: np.ndarray) -> Dict: + """Detokenizes an action.""" + action = {} + token_index = 0 + if not action_tokens.shape[-1] == self._tokens_per_action: + action_tokens = action_tokens.reshape( + *action_tokens.shape[:-1], self._tokens_per_action + ) + for k in self._action_order: + space = self._action_space[k] + if isinstance(space, gym.spaces.Discrete): + # Int32 actions are already assumed to be tokens. + action[k] = action_tokens[..., token_index] + # A poor model may output tokens outside the allowed range, in that case + # set them to a default value, the 0 token in this case. + action[k] = np.where( + action[k] >= space.n, np.zeros_like(action[k]), action[k] + ) + token_index += 1 + elif isinstance(space, gym.spaces.Box): + actions = [] + for _ in range(space.shape[0]): + a = action_tokens[..., token_index : token_index + 1] + a = a.astype(np.float32) + a = a / (self._action_bins - 1) + a = (a * (space.high[0] - space.low[0])) + space.low[0] + actions.append(a) + token_index += 1 + action[k] = np.concatenate(actions, axis=-1) + return action diff --git a/rt1_pytorch/tokenizers/image_tokenizer.py b/rt1_pytorch/tokenizers/image_tokenizer.py new file mode 100644 index 000000000..9cf4cdcb0 --- /dev/null +++ b/rt1_pytorch/tokenizers/image_tokenizer.py @@ -0,0 +1,77 @@ +"""The image tokenizer combining the FiLMEfficientNet and TokenLearner from RT1. +""" +import torch +from torch import nn + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning +from rt1_pytorch.film_efficientnet.film_efficientnet import FilmEfficientNet +from rt1_pytorch.tokenizers.token_learner import TokenLearner + + +class RT1ImageTokenizer(nn.Module): + """Tokenizes based on vocab size.""" + + def __init__( + self, + arch: str = "efficientnet_b3", + embedding_dim: int = 512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + dropout_rate=0.1, + device="cuda", + ): + """Instantiates a RT1ImageTokenizer. + + Args: + arch: The efficientnet variant to use. + embedding_dim: The embedding size of the tokens. + use_token_learner: Whether to use token learner. See + https://arxiv.org/abs/2106.11297 + num_tokens: Relevant only for token learner - the number of learned + tokens. + token_learner_bottleneck_dim: Relevant only for token learner - the + dimension of the bottleneck layer. + token_learner_num_output_tokens: Relevant only for token learner - + the number of output tokens. + dropout_rate: Relevant only for token learner - the dropout rate. + device: The device to place the model on. + """ + super().__init__() + + self.film_efficientnet = FilmEfficientNet( + arch=arch, embedding_dim=embedding_dim, device=device + ) + self.num_output_tokens = self.film_efficientnet.output_hw**2 + + self._use_token_learner = use_token_learner + if self._use_token_learner: + self._token_learner = TokenLearner( + embedding_dim=embedding_dim, + num_tokens=token_learner_num_output_tokens, + bottleneck_dim=token_learner_bottleneck_dim, + dropout_rate=dropout_rate, + device=device, + ) + self.num_output_tokens = token_learner_num_output_tokens + + def forward(self, image: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + """Gets image tokens. + + Args: + image: Images of shape (b, h, w, 3) to tokenize. + context: A context vector (e.g., a natural language embedding). + Expected to have shape (b, embedding_dim). + + Returns: + tokens: has shape (batch, num_tokens_per_timestep, embedding_dim) + """ + assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" + + tokens = self.film_efficientnet(image, context) + if len(tokens.shape) == 4: + # (b, c, h, w) -> (b, c, h*w) + tokens = tokens.reshape(tokens.shape[0], tokens.shape[1], -1) + if self._use_token_learner: + tokens = self._token_learner(tokens) + return tokens \ No newline at end of file diff --git a/rt1_pytorch/tokenizers/token_learner.py b/rt1_pytorch/tokenizers/token_learner.py new file mode 100644 index 000000000..8e04a4c30 --- /dev/null +++ b/rt1_pytorch/tokenizers/token_learner.py @@ -0,0 +1,89 @@ +"""Pytorch implementation of TokenLearner(Ryoo et al 2021).""" + +import torch +from torch import nn + + +class MlpBlock(nn.Module): + """Transformer MLP / feed-forward block.""" + + def __init__( + self, + input_dim: int, + mlp_dim: int, + out_dim: int, + dropout_rate: float = 0.1, + device="cuda", + ): + """Initializer for the MLP Block. + + This computes outer_dense(gelu(hidden_dense(input))), with dropout + applied as necessary. + + Args: + input_dim: The dimension of the input. + mlp_dim: The dimension of the inner representation (output of hidden + layer). Usually larger than the input/output dim. + out_dim: The output dimension of the block. + dropout_rate: Dropout rate to be applied after dense ( & activation) + layers. + device: The device to place the model on. + """ + super().__init__() + self._hidden_dropout = nn.Dropout(dropout_rate) + self._output_dropout = nn.Dropout(dropout_rate) + self._hidden_layer = nn.Linear(input_dim, mlp_dim, device=device) + self._output_layer = nn.Linear(mlp_dim, out_dim, device=device) + nn.init.xavier_uniform_(self._hidden_layer.weight) + nn.init.xavier_uniform_(self._output_layer.weight) + nn.init.normal_(self._hidden_layer.bias, std=1e-6) + nn.init.normal_(self._output_layer.bias, std=1e-6) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + """Applies Transformer MlpBlock module.""" + x = self._hidden_layer(inputs) + x = nn.functional.gelu(x) + x = self._hidden_dropout(x) + x = self._output_layer(x) + x = self._output_dropout(x) + return x + + +class TokenLearner(nn.Module): + """TokenLearner module V1.1 (https://arxiv.org/abs/2106.11297).""" + + def __init__( + self, + embedding_dim: int, + num_tokens: int, + bottleneck_dim: int = 64, + dropout_rate: float = 0.0, + device="cuda", + ): + super().__init__() + + self.layernorm = nn.LayerNorm(embedding_dim, eps=1e-6, device=device) + self.mlp = MlpBlock( + input_dim=embedding_dim, + mlp_dim=bottleneck_dim, + out_dim=num_tokens, + dropout_rate=dropout_rate, + device=device, + ) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + if len(inputs.shape) == 4: + bs, c, h, w = inputs.shape + inputs = torch.reshape(inputs, [bs, c, h * w]) + inputs = inputs.permute(0, 2, 1) # Shape: [bs, h*w, c] + + selected = self.layernorm(inputs) + + selected = self.mlp(selected) # Shape: [bs, h*w, n_token]. + selected = nn.functional.softmax(selected, dim=-1) + selected = selected.permute(0, 2, 1) # Shape: [bs, n_token, h*w] + + feat = torch.einsum("...si,...id->...sd", selected, inputs) + feat = feat.permute(0, 2, 1) + + return feat # Shape: [bs, c, n_token] \ No newline at end of file diff --git a/tests/action_tokenizer_test.py b/tests/action_tokenizer_test.py new file mode 100644 index 000000000..6b082840b --- /dev/null +++ b/tests/action_tokenizer_test.py @@ -0,0 +1,166 @@ +"""Tests for action_tokenizer.""" +import unittest + +import numpy as np +from gymnasium.spaces import Box, Dict, Discrete + +from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer + + +class ActionTokenizerTest(unittest.TestCase): + def testTokenize_int32(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(1, tokenizer.tokens_per_action) + action = dict(terminate_episode=np.array([1], dtype=np.int32)) + action_tokens = tokenizer.tokenize(action) + self.assertEqual(action["terminate_episode"], action_tokens) + + def testTokenize_int32_out_of_bounds(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(1, tokenizer.tokens_per_action) + action = dict(terminate_episode=np.array([3], dtype=np.int32)) + with self.assertRaises(ValueError): + tokenizer.tokenize(action) + + def testDetokenize_int32(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + action = tokenizer.detokenize(np.array([0], dtype=np.int32)) + self.assertEqual(action["terminate_episode"], np.array([0])) + # OOV 3 token should become a default one hot: [1, 0] + action = tokenizer.detokenize(np.array([3], dtype=np.int32)) + self.assertEqual(action["terminate_episode"], np.array([0])) + + def testTokenize_float(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(3, tokenizer.tokens_per_action) + action = dict(world_vector=[0.1, 0.5, -0.8]) + action_tokens = tokenizer.tokenize(action) + self.assertSequenceEqual([4, 6, 0], list(action_tokens.tolist())) + + def testTokenize_float_with_time_dimension(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(3, tokenizer.tokens_per_action) + batch_size = 2 + time_dimension = 3 + action = dict( + world_vector=np.array( + [ + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + ], + ).reshape((batch_size, time_dimension, 3)), + ) + action_tokens = tokenizer.tokenize(action) + self.assertSequenceEqual( + [batch_size, time_dimension, tokenizer.tokens_per_action], + action_tokens.shape, + ) + + def testTokenize_float_at_limits(self): + minimum = -1.0 + maximum = 1.0 + action_bins = 10 + action_space = Dict( + world_vector=Box(low=minimum, high=maximum, shape=(2,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=action_bins) + self.assertEqual(2, tokenizer.tokens_per_action) + action = dict(world_vector=[minimum, maximum]) + action_tokens = tokenizer.tokenize(action) + # Minimum value will go to 0 + # Maximum value witll go to action_bins-1 + self.assertSequenceEqual([0, action_bins - 1], action_tokens.tolist()) + + def testTokenize_invalid_action_space_shape(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(2, 2), dtype=np.float32) + ) + with self.assertRaises(ValueError): + RT1ActionTokenizer(action_space, action_bins=10) + + def testTokenizeAndDetokenizeIsEqual(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + rotation_delta=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + gripper_closedness_action=Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=Discrete(3), + ) + + tokenizer = RT1ActionTokenizer( + action_space, + action_bins=256, + action_order=[ + "terminate_episode", + "world_vector", + "rotation_delta", + "gripper_closedness_action", + ], + ) + self.assertEqual(8, tokenizer.tokens_per_action) + + # Repeat the following test N times with fuzzy inputs. + n_repeat = 10 + for _ in range(n_repeat): + action = dict( + world_vector=np.random.uniform(low=-1.0, high=1.0, size=3), + rotation_delta=np.random.uniform( + low=-np.pi / 2.0, high=np.pi / 2.0, size=3 + ), + gripper_closedness_action=np.random.uniform(low=0.0, high=1.0, size=1), + terminate_episode=np.array(0, dtype=np.int32), + ) + action_tokens = tokenizer.tokenize(action) + policy_action = tokenizer.detokenize(action_tokens) + + for k in action: + self.assertTrue( + np.allclose(action[k], policy_action[k], atol=1e-1), + f"Failed at {k} with {action[k]} != {policy_action[k]}.", + ) + + # Repeat the test with batched actions + batched_action = dict( + world_vector=[ + np.random.uniform(low=-1.0, high=1.0, size=3), + np.random.uniform(low=-1.0, high=1.0, size=3), + ], + rotation_delta=[ + np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), + np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), + ], + gripper_closedness_action=[ + np.random.uniform(low=0.0, high=1.0, size=1), + np.random.uniform(low=0.0, high=1.0, size=1), + ], + terminate_episode=[0, 1], + ) + action_tokens = tokenizer.tokenize(batched_action) + policy_action = tokenizer.detokenize(action_tokens) + + for k in batched_action: + for a, policy_a in zip(batched_action[k], policy_action[k]): + self.assertTrue( + np.allclose(a, policy_a, atol=1e-1), + f"Failed at {k} with {a} != {policy_a}.", + ) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/tests/film_conditioning_layer_test.py b/tests/film_conditioning_layer_test.py new file mode 100644 index 000000000..0cefd44b0 --- /dev/null +++ b/tests/film_conditioning_layer_test.py @@ -0,0 +1,27 @@ +"""Tests for film_conditioning_layer.""" +import torch +from absl.testing import absltest, parameterized + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning + + +class FilmConditioningLayerTest(parameterized.TestCase): + @parameterized.parameters([2, 4]) + def test_film_conditioning_rank_two_and_four(self, conv_rank): + batch = 2 + num_channels = 3 + embedding_dim = 512 + if conv_rank == 2: + conv_layer = torch.randn(size=(batch, num_channels)) + elif conv_rank == 4: + conv_layer = torch.randn(size=(batch, 1, 1, num_channels)) + else: + raise ValueError(f"Unexpected conv rank: {conv_rank}") + context = torch.rand(batch, embedding_dim) + film_layer = FilmConditioning(embedding_dim, num_channels) + out = film_layer(conv_layer, context) + assert len(out.shape) == conv_rank + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/tests/film_efficientnet_test.py b/tests/film_efficientnet_test.py new file mode 100644 index 000000000..8fa2944cc --- /dev/null +++ b/tests/film_efficientnet_test.py @@ -0,0 +1,57 @@ +"""Tests for pretrained_efficientnet_encoder.""" + +import torch +from absl.testing import absltest, parameterized +from skimage import data + +from rt1_pytorch.film_efficientnet.film_efficientnet import ( + FilmEfficientNet, + decode_predictions, +) + +MODELS = [ + "efficientnet_b0", + "efficientnet_b1", + "efficientnet_b2", + "efficientnet_b3", + # "efficientnet_b4", + # "efficientnet_b5", + # "efficientnet_b6", + # "efficientnet_b7", + "efficientnet_v2_s", + # "efficientnet_v2_m", + # "efficientnet_v2_l", +] + + +class FilmEfficientNetTest(parameterized.TestCase): + @parameterized.parameters(MODELS) + def test_encoding(self, model_name): + """Test that we get a correctly shaped encoding.""" + embedding_dim = 512 + batch_size = 4 + device = "cuda" if torch.cuda.is_available() else "cpu" + image = torch.tensor(data.chelsea()).repeat(batch_size, 1, 1, 1) + context = torch.FloatTensor(size=(batch_size, embedding_dim)).uniform_(-1, 1) + model = FilmEfficientNet(model_name, device=device).eval() + image = image.to(device) + context = context.to(device) + preds = model(image, context) + self.assertEqual( + preds.shape, (batch_size, 512, model.output_hw, model.output_hw) + ) + + @parameterized.parameters(MODELS) + def test_imagenet_classification(self, model_name): + """Test that we can correctly classify an image of a cat.""" + device = "cuda" if torch.cuda.is_available() else "cpu" + image = torch.tensor(data.chelsea()) + model = FilmEfficientNet(model_name, include_top=True, device=device).eval() + image = image.to(device) + preds = model(image) + predicted_names = [n[0] for n in decode_predictions(preds, top=3)[0]] + self.assertIn("tabby", predicted_names) + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/tests/image_tokenizer_test.py b/tests/image_tokenizer_test.py new file mode 100644 index 000000000..3b1dbd0e0 --- /dev/null +++ b/tests/image_tokenizer_test.py @@ -0,0 +1,53 @@ + +"""Tests for image_tokenizer.""" +import unittest + +import torch +from absl.testing import parameterized + +from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer + +MODELS = [ + "efficientnet_b0", + "efficientnet_b1", + "efficientnet_b2", + "efficientnet_b3", + # "efficientnet_b4", + # "efficientnet_b5", + # "efficientnet_b6", + # "efficientnet_b7", + "efficientnet_v2_s", + # "efficientnet_v2_m", + # "efficientnet_v2_l", +] + + +class ImageTokenizerTest(parameterized.TestCase): + @parameterized.named_parameters( + *[(f"sample_image_{m}", m, 512, 224, False, 8) for m in MODELS], + *[(f"sample_image_token_learner_{m}", m, 512, 224, True, 8) for m in MODELS], + ) + def testTokenize( + self, arch, embedding_dim, image_resolution, use_token_learner, num_tokens + ): + batch = 4 + device = "cuda" + tokenizer = RT1ImageTokenizer( + arch=arch, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_num_output_tokens=num_tokens, + device=device, + ) + + image = torch.randn((batch, image_resolution, image_resolution, 3)) + image = torch.clip(image, 0.0, 1.0) + image = image.to(device) + context_vector = torch.FloatTensor(size=(batch, 512)).uniform_() + context_vector = context_vector.to(device) + image_tokens = tokenizer(image, context_vector) + self.assertEqual(image_tokens.shape, (batch, 512, tokenizer.num_output_tokens)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/rt1_model_test.py b/tests/rt1_model_test.py new file mode 100644 index 000000000..6ac8b07dd --- /dev/null +++ b/tests/rt1_model_test.py @@ -0,0 +1,54 @@ +import torch +from absl.testing import absltest, parameterized + +from rt1_pytorch.rt1_model import RT1Model + + +class RT1ModelTest(parameterized.TestCase): + @parameterized.parameters(["cpu", "cuda"]) + def test_videos(self, device): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + logits = model(videos) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_texts(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + texts = torch.rand(batch_size, 6, 512, device=device) + logits = model(videos, texts) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_action_logits(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + action_logits = torch.rand(batch_size, 6, 11, 256, device=device) + logits = model(videos, action_logits=action_logits) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_texts_and_action_logits(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + texts = torch.rand(batch_size, 6, 512, device=device) + action_logits = torch.rand(batch_size, 6, 11, 256, device=device) + logits = model(videos, texts, action_logits) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/tests/rt1_policy_test.py b/tests/rt1_policy_test.py new file mode 100644 index 000000000..2d861dc58 --- /dev/null +++ b/tests/rt1_policy_test.py @@ -0,0 +1,64 @@ +import numpy as np +from absl.testing import absltest, parameterized +from gymnasium.spaces import Box, Dict, Discrete +from skimage import data + +from rt1_pytorch.rt1_policy import RT1Policy + + +class RT1PolicyTest(parameterized.TestCase): + @parameterized.parameters(["cpu", "cuda"]) + def test_policy_act_and_loss(self, device="cpu"): + observation_space = Dict( + image=Box(low=0, high=255, shape=(300, 451, 3), dtype=np.uint8), + context=Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + base_displacement_vertical_rotation=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 + ), + gripper_closedness_action=Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=Discrete(3), + base_displacement_vector=Box( + low=-1.0, + high=1.0, + shape=(3,), + dtype=np.float32, + ), + rotation_delta=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + ) + policy = RT1Policy(observation_space, action_space, device=device) + + image = data.chelsea() + videos = np.reshape(image, (1, 1, *image.shape)).repeat(6, axis=1) + # videos (b, f, h, w, c) = (1, 6, 300, 451, 3) + context = np.random.rand(1, 6, 512).astype(np.float32) + # context (b, f, d) = (1, 6, 512) + observations = {"image": videos, "context": context} + actions = policy.act(observations) + + action_tokens = policy.action_tokenizer.tokenize(actions) + + self.assertEqual(action_tokens.shape, (1, 12)) + obs = {k: v[0][0] for k, v in observations.items()} + act = {k: v[0] for k, v in actions.items()} + self.assertTrue(observation_space.contains(obs)) + self.assertTrue(action_space.contains(act)) + + target_actions = { + k: np.expand_dims(v, axis=1).repeat(6, axis=1) for k, v in actions.items() + } + + loss = policy.loss(observations=observations, target_actions=target_actions) + self.assertGreater(loss, 0) + + # TODO (Rohan138): Add more tests + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/tests/token_learner_test.py b/tests/token_learner_test.py new file mode 100644 index 000000000..a856b256d --- /dev/null +++ b/tests/token_learner_test.py @@ -0,0 +1,40 @@ +"""Tests for token_learner.""" +import unittest + +import torch + +from rt1_pytorch.tokenizers.token_learner import TokenLearner + + +class TokenLearnerTest(unittest.TestCase): + def testTokenLearner_h_w_split(self): + batch = 5 + embedding_dim = 512 + num_tokens = 8 + device = "cuda" if torch.cuda.is_available() else "cpu" + token_learner_layer = TokenLearner( + embedding_dim=embedding_dim, num_tokens=num_tokens, device=device + ) + + inputvec = torch.randn((batch, embedding_dim, 10, 10), device=device) + + learnedtokens = token_learner_layer(inputvec) + self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) + + def testTokenLearner_hw(self): + batch = 5 + embedding_dim = 512 + num_tokens = 8 + device = "cuda" if torch.cuda.is_available() else "cpu" + token_learner_layer = TokenLearner( + embedding_dim=embedding_dim, num_tokens=num_tokens, device=device + ) + + inputvec = torch.randn((batch, embedding_dim, 100), device=device) + + learnedtokens = token_learner_layer(inputvec) + self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 27bacb38f9996755be096d5d1b6da020a9d0f654 Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 13 Jun 2024 00:02:53 -0400 Subject: [PATCH 03/12] updated readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 445d7c0e3..930fa939a 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ This implemenetation of RT-1 was pretrained on the Date: Thu, 13 Jun 2024 00:35:43 -0400 Subject: [PATCH 05/12] commiting python3 environment --- rt1_env/bin/Activate.ps1 | 241 ++++++++++ rt1_env/bin/activate | 66 +++ rt1_env/bin/activate.csh | 25 ++ rt1_env/bin/activate.fish | 64 +++ rt1_env/bin/ai2thor-xorg | 267 +++++++++++ rt1_env/bin/convert-caffe2-to-onnx | 10 + rt1_env/bin/convert-onnx-to-caffe2 | 10 + rt1_env/bin/f2py | 10 + rt1_env/bin/flask | 10 + rt1_env/bin/huggingface-cli | 10 + rt1_env/bin/imageio_download_bin | 10 + rt1_env/bin/imageio_remove_bin | 10 + rt1_env/bin/import_pb_to_tensorboard | 10 + rt1_env/bin/isympy | 10 + rt1_env/bin/jp.py | 54 +++ rt1_env/bin/lsm2bin | 10 + rt1_env/bin/markdown-it | 10 + rt1_env/bin/markdown_py | 10 + rt1_env/bin/normalizer | 10 + rt1_env/bin/pip | 10 + rt1_env/bin/pip3 | 10 + rt1_env/bin/pip3.9 | 10 + rt1_env/bin/portserver.py | 415 ++++++++++++++++++ rt1_env/bin/progressbar | 10 + rt1_env/bin/pygmentize | 10 + rt1_env/bin/python | 1 + rt1_env/bin/python3 | 1 + rt1_env/bin/python3.9 | 1 + rt1_env/bin/pythoni | 36 ++ rt1_env/bin/pythoni1 | 17 + rt1_env/bin/reverb_server | 10 + rt1_env/bin/saved_model_cli | 10 + rt1_env/bin/tensorboard | 10 + rt1_env/bin/tf_upgrade_v2 | 10 + rt1_env/bin/tfds | 10 + rt1_env/bin/tflite_convert | 10 + rt1_env/bin/tiff2fsspec | 10 + rt1_env/bin/tiffcomment | 10 + rt1_env/bin/tifffile | 10 + rt1_env/bin/toco | 10 + rt1_env/bin/toco_from_protos | 10 + rt1_env/bin/torchrun | 10 + rt1_env/bin/tqdm | 10 + rt1_env/bin/transformers-cli | 10 + rt1_env/bin/tree-cli | 10 + rt1_env/bin/wandb | 10 + rt1_env/bin/wb | 10 + rt1_env/bin/wheel | 10 + .../site/python3.9/dm-reverb/checkpoint.proto | 77 ++++ .../site/python3.9/dm-reverb/patterns.proto | 123 ++++++ .../python3.9/dm-reverb/reverb_config.proto | 10 + .../site/python3.9/dm-reverb/schema.proto | 289 ++++++++++++ rt1_env/lib64 | 1 + rt1_env/pyvenv.cfg | 3 + rt1_env/share/man/man1/isympy.1 | 188 ++++++++ 55 files changed, 2239 insertions(+) create mode 100644 rt1_env/bin/Activate.ps1 create mode 100644 rt1_env/bin/activate create mode 100644 rt1_env/bin/activate.csh create mode 100644 rt1_env/bin/activate.fish create mode 100755 rt1_env/bin/ai2thor-xorg create mode 100755 rt1_env/bin/convert-caffe2-to-onnx create mode 100755 rt1_env/bin/convert-onnx-to-caffe2 create mode 100755 rt1_env/bin/f2py create mode 100755 rt1_env/bin/flask create mode 100755 rt1_env/bin/huggingface-cli create mode 100755 rt1_env/bin/imageio_download_bin create mode 100755 rt1_env/bin/imageio_remove_bin create mode 100755 rt1_env/bin/import_pb_to_tensorboard create mode 100755 rt1_env/bin/isympy create mode 100755 rt1_env/bin/jp.py create mode 100755 rt1_env/bin/lsm2bin create mode 100755 rt1_env/bin/markdown-it create mode 100755 rt1_env/bin/markdown_py create mode 100755 rt1_env/bin/normalizer create mode 100755 rt1_env/bin/pip create mode 100755 rt1_env/bin/pip3 create mode 100755 rt1_env/bin/pip3.9 create mode 100755 rt1_env/bin/portserver.py create mode 100755 rt1_env/bin/progressbar create mode 100755 rt1_env/bin/pygmentize create mode 120000 rt1_env/bin/python create mode 120000 rt1_env/bin/python3 create mode 120000 rt1_env/bin/python3.9 create mode 100755 rt1_env/bin/pythoni create mode 100755 rt1_env/bin/pythoni1 create mode 100755 rt1_env/bin/reverb_server create mode 100755 rt1_env/bin/saved_model_cli create mode 100755 rt1_env/bin/tensorboard create mode 100755 rt1_env/bin/tf_upgrade_v2 create mode 100755 rt1_env/bin/tfds create mode 100755 rt1_env/bin/tflite_convert create mode 100755 rt1_env/bin/tiff2fsspec create mode 100755 rt1_env/bin/tiffcomment create mode 100755 rt1_env/bin/tifffile create mode 100755 rt1_env/bin/toco create mode 100755 rt1_env/bin/toco_from_protos create mode 100755 rt1_env/bin/torchrun create mode 100755 rt1_env/bin/tqdm create mode 100755 rt1_env/bin/transformers-cli create mode 100755 rt1_env/bin/tree-cli create mode 100755 rt1_env/bin/wandb create mode 100755 rt1_env/bin/wb create mode 100755 rt1_env/bin/wheel create mode 100644 rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto create mode 100644 rt1_env/include/site/python3.9/dm-reverb/patterns.proto create mode 100644 rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto create mode 100644 rt1_env/include/site/python3.9/dm-reverb/schema.proto create mode 120000 rt1_env/lib64 create mode 100644 rt1_env/pyvenv.cfg create mode 100644 rt1_env/share/man/man1/isympy.1 diff --git a/rt1_env/bin/Activate.ps1 b/rt1_env/bin/Activate.ps1 new file mode 100644 index 000000000..9d3646a4f --- /dev/null +++ b/rt1_env/bin/Activate.ps1 @@ -0,0 +1,241 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/rt1_env/bin/activate b/rt1_env/bin/activate new file mode 100644 index 000000000..2fdaa7bfa --- /dev/null +++ b/rt1_env/bin/activate @@ -0,0 +1,66 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null + fi + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1="(rt1_env) ${PS1:-}" + export PS1 +fi + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null +fi diff --git a/rt1_env/bin/activate.csh b/rt1_env/bin/activate.csh new file mode 100644 index 000000000..af00fde95 --- /dev/null +++ b/rt1_env/bin/activate.csh @@ -0,0 +1,25 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . +# Ported to Python 3.3 venv by Andrew Svetlov + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" + +set _OLD_VIRTUAL_PATH="$PATH" +setenv PATH "$VIRTUAL_ENV/bin:$PATH" + + +set _OLD_VIRTUAL_PROMPT="$prompt" + +if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then + set prompt = "(rt1_env) $prompt" +endif + +alias pydoc python -m pydoc + +rehash diff --git a/rt1_env/bin/activate.fish b/rt1_env/bin/activate.fish new file mode 100644 index 000000000..388919ed3 --- /dev/null +++ b/rt1_env/bin/activate.fish @@ -0,0 +1,64 @@ +# This file must be used with "source /bin/activate.fish" *from fish* +# (https://fishshell.com/); you cannot run it directly. + +function deactivate -d "Exit virtual environment and return to normal shell environment" + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + functions -e fish_prompt + set -e _OLD_FISH_PROMPT_OVERRIDE + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + end + + set -e VIRTUAL_ENV + if test "$argv[1]" != "nondestructive" + # Self-destruct! + functions -e deactivate + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/bin" $PATH + +# Unset PYTHONHOME if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # fish uses a function instead of an env var to generate the prompt. + + # Save the current fish_prompt function as the function _old_fish_prompt. + functions -c fish_prompt _old_fish_prompt + + # With the original prompt function renamed, we can override with our own. + function fish_prompt + # Save the return status of the last command. + set -l old_status $status + + # Output the venv prompt; color taken from the blue of the Python logo. + printf "%s%s%s" (set_color 4B8BBE) "(rt1_env) " (set_color normal) + + # Restore the return status of the previous command. + echo "exit $old_status" | . + # Output the original/"old" prompt. + _old_fish_prompt + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" +end diff --git a/rt1_env/bin/ai2thor-xorg b/rt1_env/bin/ai2thor-xorg new file mode 100755 index 000000000..7bc6235a3 --- /dev/null +++ b/rt1_env/bin/ai2thor-xorg @@ -0,0 +1,267 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +import os +import sys +import time +import platform +import re +import shlex +import subprocess +import argparse +import signal + +# Turning off automatic black formatting for this script as it breaks quotes. +# fmt: off +from typing import List + +PID_FILE = "/var/run/ai2thor-xorg.pid" +CONFIG_FILE = "/tmp/ai2thor-xorg.conf" + +DEFAULT_HEIGHT = 768 +DEFAULT_WIDTH = 1024 + + +def process_alive(pid): + """ + Use kill(0) to determine if pid is alive + :param pid: process id + :rtype: bool + """ + try: + os.kill(pid, 0) + except OSError: + return False + + return True + + +def find_devices(excluded_device_ids): + devices = [] + id_counter = 0 + for r in pci_records(): + if r.get("Vendor", "") == "NVIDIA Corporation" and r["Class"] in [ + "VGA compatible controller", + "3D controller", + ]: + bus_id = "PCI:" + ":".join( + map(lambda x: str(int(x, 16)), re.split(r"[:\.]", r["Slot"])) + ) + + if id_counter not in excluded_device_ids: + devices.append(bus_id) + + id_counter += 1 + + if not devices: + print("Error: ai2thor-xorg requires at least one NVIDIA device") + sys.exit(1) + + return devices + +def active_display_bus_ids(): + # this determines whether a monitor is connected to the GPU + # if one is, the following Option is added for the Screen "UseDisplayDevice" "None" + command = "nvidia-smi --query-gpu=pci.bus_id,display_active --format=csv,noheader" + active_bus_ids = set() + result = subprocess.run(command, shell=True, stdout=subprocess.PIPE) + if result.returncode == 0: + for line in result.stdout.decode().strip().split("\n"): + nvidia_bus_id, display_status = re.split(r",\s?", line.strip()) + bus_id = "PCI:" + ":".join( + map(lambda x: str(int(x, 16)), re.split(r"[:\.]", nvidia_bus_id)[1:]) + ) + if display_status.lower() == "enabled": + active_bus_ids.add(bus_id) + + return active_bus_ids + +def pci_records(): + records = [] + command = shlex.split("lspci -vmm") + output = subprocess.check_output(command).decode() + + for devices in output.strip().split("\n\n"): + record = {} + records.append(record) + for row in devices.split("\n"): + key, value = row.split("\t") + record[key.split(":")[0]] = value + + return records + + +def read_pid(): + if os.path.isfile(PID_FILE): + with open(PID_FILE) as f: + return int(f.read()) + else: + return None + + +def start(display: str, excluded_device_ids: List[int], width: int, height: int): + pid = read_pid() + + if pid and process_alive(pid): + print("Error: ai2thor-xorg is already running with pid: %s" % pid) + sys.exit(1) + + with open(CONFIG_FILE, "w") as f: + f.write(generate_xorg_conf(excluded_device_ids, width=width, height=height)) + + log_file = "/var/log/ai2thor-xorg.%s.log" % display + error_log_file = "/var/log/ai2thor-xorg-error.%s.log" % display + command = shlex.split( + "Xorg -quiet -maxclients 1024 -noreset +extension GLX +extension RANDR +extension RENDER -logfile %s -config %s :%s" + % (log_file, CONFIG_FILE, display) + ) + + pid = None + with open(error_log_file, "w") as error_log_f: + proc = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=error_log_f) + pid = proc.pid + try: + proc.wait(timeout=0.25) + except subprocess.TimeoutExpired: + pass + + if pid and process_alive(pid): + with open(PID_FILE, "w") as f: + f.write(str(proc.pid)) + else: + print("Error: error with command '%s'" % " ".join(command)) + with open(error_log_file, "r") as f: + print(f.read()) + + +def print_config(excluded_device_ids: List[int], width: int, height: int): + print(generate_xorg_conf(excluded_device_ids, width=width, height=height)) + + +def stop(): + pid = read_pid() + if pid and process_alive(pid): + os.kill(pid, signal.SIGTERM) + + for i in range(10): + time.sleep(0.2) + if not process_alive(pid): + os.unlink(PID_FILE) + break + + +def generate_xorg_conf( + excluded_device_ids: List[int], width: int, height: int +): + devices = find_devices(excluded_device_ids) + active_display_devices = active_display_bus_ids() + + xorg_conf = [] + + device_section = """ +Section "Device" + Identifier "Device{device_id}" + Driver "nvidia" + VendorName "NVIDIA Corporation" + BusID "{bus_id}" +EndSection +""" + server_layout_section = """ +Section "ServerLayout" + Identifier "Layout0" + {screen_records} +EndSection +""" + screen_section = """ +Section "Screen" + Identifier "Screen{screen_id}" + Device "Device{device_id}" + DefaultDepth 24 + Option "AllowEmptyInitialConfiguration" "True" + Option "Interactive" "False" + {extra_options} + SubSection "Display" + Depth 24 + Virtual {width} {height} + EndSubSection +EndSection +""" + screen_records = [] + for i, bus_id in enumerate(devices): + extra_options = "" + if bus_id in active_display_devices: + # See https://github.com/allenai/ai2thor/pull/990 + # when a monitor is connected, this option must be used otherwise + # Xorg will fail to start + extra_options = 'Option "UseDisplayDevice" "None"' + xorg_conf.append(device_section.format(device_id=i, bus_id=bus_id)) + xorg_conf.append(screen_section.format(device_id=i, screen_id=i, width=width, height=height, extra_options=extra_options)) + screen_records.append( + 'Screen {screen_id} "Screen{screen_id}" 0 0'.format(screen_id=i) + ) + + xorg_conf.append( + server_layout_section.format(screen_records="\n ".join(screen_records)) + ) + + output = "\n".join(xorg_conf) + return output + + +# fmt: on + +if __name__ == "__main__": + if os.geteuid() != 0: + path = os.path.abspath(__file__) + print("Executing ai2thor-xorg with sudo") + args = ["--", path] + sys.argv[1:] + os.execvp("sudo", args) + + if platform.system() != "Linux": + print("Error: Can only run ai2thor-xorg on linux") + sys.exit(1) + + parser = argparse.ArgumentParser() + parser.add_argument( + "--exclude-device", + help="exclude a specific GPU device", + action="append", + type=int, + default=[], + ) + parser.add_argument( + "--width", + help="width of the screen to start (should be greater than the maximum" + f" width of any ai2thor instance you will start) [default: {DEFAULT_WIDTH}]", + type=int, + default=DEFAULT_WIDTH, + ) + parser.add_argument( + "--height", + help="height of the screen to start (should be greater than the maximum" + f" height of any ai2thor instance you will start) [default: {DEFAULT_HEIGHT}]", + type=int, + default=DEFAULT_HEIGHT, + ) + parser.add_argument( + "command", + help="command to be executed", + choices=["start", "stop", "print-config"], + ) + parser.add_argument( + "display", help="display to be used", nargs="?", type=int, default=0 + ) + args = parser.parse_args() + if args.command == "start": + start( + display=args.display, + excluded_device_ids=args.exclude_device, + height=args.height, + width=args.width, + ) + elif args.command == "stop": + stop() + elif args.command == "print-config": + print_config( + excluded_device_ids=args.exclude_device, + width=args.width, + height=args.height, + ) diff --git a/rt1_env/bin/convert-caffe2-to-onnx b/rt1_env/bin/convert-caffe2-to-onnx new file mode 100755 index 000000000..0294702e2 --- /dev/null +++ b/rt1_env/bin/convert-caffe2-to-onnx @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from caffe2.python.onnx.bin.conversion import caffe2_to_onnx +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(caffe2_to_onnx()) diff --git a/rt1_env/bin/convert-onnx-to-caffe2 b/rt1_env/bin/convert-onnx-to-caffe2 new file mode 100755 index 000000000..daed37802 --- /dev/null +++ b/rt1_env/bin/convert-onnx-to-caffe2 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from caffe2.python.onnx.bin.conversion import onnx_to_caffe2 +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(onnx_to_caffe2()) diff --git a/rt1_env/bin/f2py b/rt1_env/bin/f2py new file mode 100755 index 000000000..6ae2c3109 --- /dev/null +++ b/rt1_env/bin/f2py @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from numpy.f2py.f2py2e import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/flask b/rt1_env/bin/flask new file mode 100755 index 000000000..fa566a3ba --- /dev/null +++ b/rt1_env/bin/flask @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from flask.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/huggingface-cli b/rt1_env/bin/huggingface-cli new file mode 100755 index 000000000..5580d7dc9 --- /dev/null +++ b/rt1_env/bin/huggingface-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from huggingface_hub.commands.huggingface_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/imageio_download_bin b/rt1_env/bin/imageio_download_bin new file mode 100755 index 000000000..2e17ded5a --- /dev/null +++ b/rt1_env/bin/imageio_download_bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from imageio.__main__ import download_bin_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(download_bin_main()) diff --git a/rt1_env/bin/imageio_remove_bin b/rt1_env/bin/imageio_remove_bin new file mode 100755 index 000000000..bbbdac364 --- /dev/null +++ b/rt1_env/bin/imageio_remove_bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from imageio.__main__ import remove_bin_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(remove_bin_main()) diff --git a/rt1_env/bin/import_pb_to_tensorboard b/rt1_env/bin/import_pb_to_tensorboard new file mode 100755 index 000000000..47503b8c4 --- /dev/null +++ b/rt1_env/bin/import_pb_to_tensorboard @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.python.tools.import_pb_to_tensorboard import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/isympy b/rt1_env/bin/isympy new file mode 100755 index 000000000..8f709363b --- /dev/null +++ b/rt1_env/bin/isympy @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from isympy import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/jp.py b/rt1_env/bin/jp.py new file mode 100755 index 000000000..2a3859f1f --- /dev/null +++ b/rt1_env/bin/jp.py @@ -0,0 +1,54 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 + +import sys +import json +import argparse +from pprint import pformat + +import jmespath +from jmespath import exceptions + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('expression') + parser.add_argument('-f', '--filename', + help=('The filename containing the input data. ' + 'If a filename is not given then data is ' + 'read from stdin.')) + parser.add_argument('--ast', action='store_true', + help=('Pretty print the AST, do not search the data.')) + args = parser.parse_args() + expression = args.expression + if args.ast: + # Only print the AST + expression = jmespath.compile(args.expression) + sys.stdout.write(pformat(expression.parsed)) + sys.stdout.write('\n') + return 0 + if args.filename: + with open(args.filename, 'r') as f: + data = json.load(f) + else: + data = sys.stdin.read() + data = json.loads(data) + try: + sys.stdout.write(json.dumps( + jmespath.search(expression, data), indent=4, ensure_ascii=False)) + sys.stdout.write('\n') + except exceptions.ArityError as e: + sys.stderr.write("invalid-arity: %s\n" % e) + return 1 + except exceptions.JMESPathTypeError as e: + sys.stderr.write("invalid-type: %s\n" % e) + return 1 + except exceptions.UnknownFunctionError as e: + sys.stderr.write("unknown-function: %s\n" % e) + return 1 + except exceptions.ParseError as e: + sys.stderr.write("syntax-error: %s\n" % e) + return 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/rt1_env/bin/lsm2bin b/rt1_env/bin/lsm2bin new file mode 100755 index 000000000..a4b517af7 --- /dev/null +++ b/rt1_env/bin/lsm2bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.lsm2bin import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/markdown-it b/rt1_env/bin/markdown-it new file mode 100755 index 000000000..e58e8d1e4 --- /dev/null +++ b/rt1_env/bin/markdown-it @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from markdown_it.cli.parse import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/markdown_py b/rt1_env/bin/markdown_py new file mode 100755 index 000000000..8424ab33e --- /dev/null +++ b/rt1_env/bin/markdown_py @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from markdown.__main__ import run +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run()) diff --git a/rt1_env/bin/normalizer b/rt1_env/bin/normalizer new file mode 100755 index 000000000..e3a575f79 --- /dev/null +++ b/rt1_env/bin/normalizer @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from charset_normalizer.cli import cli_detect +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli_detect()) diff --git a/rt1_env/bin/pip b/rt1_env/bin/pip new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/rt1_env/bin/pip @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/pip3 b/rt1_env/bin/pip3 new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/rt1_env/bin/pip3 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/pip3.9 b/rt1_env/bin/pip3.9 new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/rt1_env/bin/pip3.9 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/portserver.py b/rt1_env/bin/portserver.py new file mode 100755 index 000000000..6cdc3c0f3 --- /dev/null +++ b/rt1_env/bin/portserver.py @@ -0,0 +1,415 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +# +# Copyright 2015 Google Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +"""A server to hand out network ports to applications running on one host. + +Typical usage: + 1) Run one instance of this process on each of your unittest farm hosts. + 2) Set the PORTSERVER_ADDRESS environment variable in your test runner + environment to let the portpicker library know to use a port server + rather than attempt to find ports on its own. + +$ /path/to/portserver.py & +$ export PORTSERVER_ADDRESS=@unittest-portserver +$ # ... launch a bunch of unittest runners using portpicker ... +""" + +import argparse +import asyncio +import collections +import logging +import signal +import socket +import sys +import psutil +import subprocess +from datetime import datetime, timezone, timedelta + +log = None # Initialized to a logging.Logger by _configure_logging(). + +_PROTOS = [(socket.SOCK_STREAM, socket.IPPROTO_TCP), + (socket.SOCK_DGRAM, socket.IPPROTO_UDP)] + + +def _get_process_command_line(pid): + try: + return psutil.Process(pid).cmdline() + except psutil.NoSuchProcess: + return '' + + +def _get_process_start_time(pid): + try: + return psutil.Process(pid).create_time() + except psutil.NoSuchProcess: + return 0.0 + + +# TODO: Consider importing portpicker.bind() instead of duplicating the code. +def _bind(port, socket_type, socket_proto): + """Try to bind to a socket of the specified type, protocol, and port. + + For the port to be considered available, the kernel must support at least + one of (IPv6, IPv4), and the port must be available on each supported + family. + + Args: + port: The port number to bind to, or 0 to have the OS pick a free port. + socket_type: The type of the socket (ex: socket.SOCK_STREAM). + socket_proto: The protocol of the socket (ex: socket.IPPROTO_TCP). + + Returns: + The port number on success or None on failure. + """ + got_socket = False + for family in (socket.AF_INET6, socket.AF_INET): + try: + sock = socket.socket(family, socket_type, socket_proto) + got_socket = True + except socket.error: + continue + try: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + sock.bind(('', port)) + if socket_type == socket.SOCK_STREAM: + sock.listen(1) + port = sock.getsockname()[1] + except socket.error: + return None + finally: + sock.close() + return port if got_socket else None + + +def _is_port_free(port): + """Check if specified port is free. + + Args: + port: integer, port to check + Returns: + boolean, whether it is free to use for both TCP and UDP + """ + return _bind(port, *_PROTOS[0]) and _bind(port, *_PROTOS[1]) + + +def _should_allocate_port(pid): + """Determine if we should allocate a port for use by the given process id.""" + if pid <= 0: + log.info('Not allocating a port to invalid pid') + return False + if pid == 1: + # The client probably meant to send us its parent pid but + # had been reparented to init. + log.info('Not allocating a port to init.') + return False + + if not psutil.pid_exists(pid): + log.info('Not allocating a port to a non-existent process') + return False + return True + + +async def _start_windows_server(client_connected_cb, path): + """Start the server on Windows using named pipes.""" + def protocol_factory(): + stream_reader = asyncio.StreamReader() + stream_reader_protocol = asyncio.StreamReaderProtocol( + stream_reader, client_connected_cb) + return stream_reader_protocol + + loop = asyncio.get_event_loop() + server, *_ = await loop.start_serving_pipe(protocol_factory, address=path) + + return server + + +class _PortInfo(object): + """Container class for information about a given port assignment. + + Attributes: + port: integer port number + pid: integer process id or 0 if unassigned. + start_time: Time in seconds since the epoch that the process started. + """ + + __slots__ = ('port', 'pid', 'start_time') + + def __init__(self, port): + self.port = port + self.pid = 0 + self.start_time = 0.0 + + +class _PortPool(object): + """Manage available ports for processes. + + Ports are reclaimed when the reserving process exits and the reserved port + is no longer in use. Only ports which are free for both TCP and UDP will be + handed out. It is easier to not differentiate between protocols. + + The pool must be pre-seeded with add_port_to_free_pool() calls + after which get_port_for_process() will allocate and reclaim ports. + The len() of a _PortPool returns the total number of ports being managed. + + Attributes: + ports_checked_for_last_request: The number of ports examined in order to + return from the most recent get_port_for_process() request. A high + number here likely means the number of available ports with no active + process using them is getting low. + """ + + def __init__(self): + self._port_queue = collections.deque() + self.ports_checked_for_last_request = 0 + + def num_ports(self): + return len(self._port_queue) + + def get_port_for_process(self, pid): + """Allocates and returns port for pid or 0 if none could be allocated.""" + if not self._port_queue: + raise RuntimeError('No ports being managed.') + + # Avoid an infinite loop if all ports are currently assigned. + check_count = 0 + max_ports_to_test = len(self._port_queue) + while check_count < max_ports_to_test: + # Get the next candidate port and move it to the back of the queue. + candidate = self._port_queue.pop() + self._port_queue.appendleft(candidate) + check_count += 1 + if (candidate.start_time == 0.0 or + candidate.start_time != _get_process_start_time(candidate.pid)): + if _is_port_free(candidate.port): + candidate.pid = pid + candidate.start_time = _get_process_start_time(pid) + if not candidate.start_time: + log.info("Can't read start time for pid %d.", pid) + self.ports_checked_for_last_request = check_count + return candidate.port + else: + log.info( + 'Port %d unexpectedly in use, last owning pid %d.', + candidate.port, candidate.pid) + + log.info('All ports in use.') + self.ports_checked_for_last_request = check_count + return 0 + + def add_port_to_free_pool(self, port): + """Add a new port to the free pool for allocation.""" + if port < 1 or port > 65535: + raise ValueError( + 'Port must be in the [1, 65535] range, not %d.' % port) + port_info = _PortInfo(port=port) + self._port_queue.append(port_info) + + +class _PortServerRequestHandler(object): + """A class to handle port allocation and status requests. + + Allocates ports to process ids via the dead simple port server protocol + when the handle_port_request asyncio.coroutine handler has been registered. + Statistics can be logged using the dump_stats method. + """ + + def __init__(self, ports_to_serve): + """Initialize a new port server. + + Args: + ports_to_serve: A sequence of unique port numbers to test and offer + up to clients. + """ + self._port_pool = _PortPool() + self._total_allocations = 0 + self._denied_allocations = 0 + self._client_request_errors = 0 + for port in ports_to_serve: + self._port_pool.add_port_to_free_pool(port) + + async def handle_port_request(self, reader, writer): + client_data = await reader.read(100) + self._handle_port_request(client_data, writer) + writer.close() + + def _handle_port_request(self, client_data, writer): + """Given a port request body, parse it and respond appropriately. + + Args: + client_data: The request bytes from the client. + writer: The asyncio Writer for the response to be written to. + """ + try: + if len(client_data) > 20: + raise ValueError('More than 20 characters in "pid".') + pid = int(client_data) + except ValueError as error: + self._client_request_errors += 1 + log.warning('Could not parse request: %s', error) + return + + log.info('Request on behalf of pid %d.', pid) + log.info('cmdline: %s', _get_process_command_line(pid)) + + if not _should_allocate_port(pid): + self._denied_allocations += 1 + return + + port = self._port_pool.get_port_for_process(pid) + if port > 0: + self._total_allocations += 1 + writer.write('{:d}\n'.format(port).encode('utf-8')) + log.debug('Allocated port %d to pid %d', port, pid) + else: + self._denied_allocations += 1 + + def dump_stats(self): + """Logs statistics of our operation.""" + log.info('Dumping statistics:') + stats = [] + stats.append( + 'client-request-errors {}'.format(self._client_request_errors)) + stats.append('denied-allocations {}'.format(self._denied_allocations)) + stats.append('num-ports-managed {}'.format(self._port_pool.num_ports())) + stats.append('num-ports-checked-for-last-request {}'.format( + self._port_pool.ports_checked_for_last_request)) + stats.append('total-allocations {}'.format(self._total_allocations)) + for stat in stats: + log.info(stat) + + +def _parse_command_line(): + """Configure and parse our command line flags.""" + parser = argparse.ArgumentParser() + parser.add_argument( + '--portserver_static_pool', + type=str, + default='15000-24999', + help='Comma separated N-P Range(s) of ports to manage (inclusive).') + parser.add_argument( + '--portserver_address', + '--portserver_unix_socket_address', # Alias to be backward compatible + type=str, + default='@unittest-portserver', + help='Address of AF_UNIX socket on which to listen on Unix (first @ is ' + 'a NUL) or the name of the pipe on Windows (first @ is the ' + r'\\.\pipe\ prefix).') + parser.add_argument('--verbose', + action='store_true', + default=False, + help='Enable verbose messages.') + parser.add_argument('--debug', + action='store_true', + default=False, + help='Enable full debug messages.') + return parser.parse_args(sys.argv[1:]) + + +def _parse_port_ranges(pool_str): + """Given a 'N-P,X-Y' description of port ranges, return a set of ints.""" + ports = set() + for range_str in pool_str.split(','): + try: + a, b = range_str.split('-', 1) + start, end = int(a), int(b) + except ValueError: + log.error('Ignoring unparsable port range %r.', range_str) + continue + if start < 1 or end > 65535: + log.error('Ignoring out of bounds port range %r.', range_str) + continue + ports.update(set(range(start, end + 1))) + return ports + + +def _configure_logging(verbose=False, debug=False): + """Configure the log global, message format, and verbosity settings.""" + overall_level = logging.DEBUG if debug else logging.INFO + logging.basicConfig( + format=('{levelname[0]}{asctime}.{msecs:03.0f} {thread} ' + '{filename}:{lineno}] {message}'), + datefmt='%m%d %H:%M:%S', + style='{', + level=overall_level) + global log + log = logging.getLogger('portserver') + # The verbosity controls our loggers logging level, not the global + # one above. This avoids debug messages from libraries such as asyncio. + log.setLevel(logging.DEBUG if verbose else overall_level) + + +def main(): + config = _parse_command_line() + if config.debug: + # Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access + asyncio.tasks._DEBUG = True + _configure_logging(verbose=config.verbose, debug=config.debug) + ports_to_serve = _parse_port_ranges(config.portserver_static_pool) + if not ports_to_serve: + log.error('No ports. Invalid port ranges in --portserver_static_pool?') + sys.exit(1) + + request_handler = _PortServerRequestHandler(ports_to_serve) + + if sys.platform == 'win32': + asyncio.set_event_loop(asyncio.ProactorEventLoop()) + + event_loop = asyncio.get_event_loop() + + if sys.platform == 'win32': + # On Windows, we need to periodically pause the loop to allow the user + # to send a break signal (e.g. ctrl+c) + def listen_for_signal(): + event_loop.call_later(0.5, listen_for_signal) + + event_loop.call_later(0.5, listen_for_signal) + + coro = _start_windows_server( + request_handler.handle_port_request, + path=config.portserver_address.replace('@', '\\\\.\\pipe\\', 1)) + else: + event_loop.add_signal_handler( + signal.SIGUSR1, request_handler.dump_stats) # pylint: disable=no-member + + old_py_loop = {'loop': event_loop} if sys.version_info < (3, 10) else {} + coro = asyncio.start_unix_server( + request_handler.handle_port_request, + path=config.portserver_address.replace('@', '\0', 1), + **old_py_loop) + + server_address = config.portserver_address + + server = event_loop.run_until_complete(coro) + log.info('Serving on %s', server_address) + try: + event_loop.run_forever() + except KeyboardInterrupt: + log.info('Stopping due to ^C.') + + server.close() + + if sys.platform != 'win32': + # PipeServer doesn't have a wait_closed() function + event_loop.run_until_complete(server.wait_closed()) + event_loop.remove_signal_handler(signal.SIGUSR1) # pylint: disable=no-member + + event_loop.close() + request_handler.dump_stats() + log.info('Goodbye.') + + +if __name__ == '__main__': + main() diff --git a/rt1_env/bin/progressbar b/rt1_env/bin/progressbar new file mode 100755 index 000000000..1136ebc7c --- /dev/null +++ b/rt1_env/bin/progressbar @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from progressbar.__main__ import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/pygmentize b/rt1_env/bin/pygmentize new file mode 100755 index 000000000..623ccdf50 --- /dev/null +++ b/rt1_env/bin/pygmentize @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pygments.cmdline import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/python b/rt1_env/bin/python new file mode 120000 index 000000000..b8a0adbbb --- /dev/null +++ b/rt1_env/bin/python @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/rt1_env/bin/python3 b/rt1_env/bin/python3 new file mode 120000 index 000000000..ae65fdaa1 --- /dev/null +++ b/rt1_env/bin/python3 @@ -0,0 +1 @@ +/usr/bin/python3 \ No newline at end of file diff --git a/rt1_env/bin/python3.9 b/rt1_env/bin/python3.9 new file mode 120000 index 000000000..b8a0adbbb --- /dev/null +++ b/rt1_env/bin/python3.9 @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/rt1_env/bin/pythoni b/rt1_env/bin/pythoni new file mode 100755 index 000000000..2d650f825 --- /dev/null +++ b/rt1_env/bin/pythoni @@ -0,0 +1,36 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 + +# Copyright 2000-2002 Michael Hudson mwh@python.net +# +# All Rights Reserved +# +# +# Permission to use, copy, modify, and distribute this software and +# its documentation for any purpose is hereby granted without fee, +# provided that the above copyright notice appear in all copies and +# that both that copyright notice and this permission notice appear in +# supporting documentation. +# +# THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO +# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +# AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, +# INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER +# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF +# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +import locale, pdb, sys +# I forget exactly why this is necessary: +try: + locale.setlocale(locale.LC_ALL, '') +except locale.Error: + pass # oh well + + +from pyrepl.python_reader import main +from pyrepl import cmdrepl + +# whizzy feature: graft pyrepl support onto pdb +#pdb.Pdb = cmdrepl.replize(pdb.Pdb, 1) + +main(use_pygame_console=('pg' in sys.argv)) diff --git a/rt1_env/bin/pythoni1 b/rt1_env/bin/pythoni1 new file mode 100755 index 000000000..f0a75c79d --- /dev/null +++ b/rt1_env/bin/pythoni1 @@ -0,0 +1,17 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +""" This is an alternative to pythoni which tries to look like the +CPython prompt as much as possible, with the exception of allowing +multiline input and multiline history entries. +""" + +import os, sys +from pyrepl import readline +from pyrepl.simple_interact import run_multiline_interactive_console + +sys.modules['readline'] = readline + +if os.getenv('PYTHONSTARTUP'): + execfile(os.getenv('PYTHONSTARTUP')) + +print 'Python', sys.version +run_multiline_interactive_console() diff --git a/rt1_env/bin/reverb_server b/rt1_env/bin/reverb_server new file mode 100755 index 000000000..b9d8a78f5 --- /dev/null +++ b/rt1_env/bin/reverb_server @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from reverb.server_executable.server_main import app_run_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(app_run_main()) diff --git a/rt1_env/bin/saved_model_cli b/rt1_env/bin/saved_model_cli new file mode 100755 index 000000000..44f84317c --- /dev/null +++ b/rt1_env/bin/saved_model_cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.python.tools.saved_model_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tensorboard b/rt1_env/bin/tensorboard new file mode 100755 index 000000000..2ee3b3204 --- /dev/null +++ b/rt1_env/bin/tensorboard @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorboard.main import run_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run_main()) diff --git a/rt1_env/bin/tf_upgrade_v2 b/rt1_env/bin/tf_upgrade_v2 new file mode 100755 index 000000000..aee84bff1 --- /dev/null +++ b/rt1_env/bin/tf_upgrade_v2 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.tools.compatibility.tf_upgrade_v2_main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tfds b/rt1_env/bin/tfds new file mode 100755 index 000000000..0f5636bc8 --- /dev/null +++ b/rt1_env/bin/tfds @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow_datasets.scripts.cli.main import launch_cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_cli()) diff --git a/rt1_env/bin/tflite_convert b/rt1_env/bin/tflite_convert new file mode 100755 index 000000000..0ebb370c7 --- /dev/null +++ b/rt1_env/bin/tflite_convert @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.python.tflite_convert import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tiff2fsspec b/rt1_env/bin/tiff2fsspec new file mode 100755 index 000000000..72322f48d --- /dev/null +++ b/rt1_env/bin/tiff2fsspec @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.tiff2fsspec import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tiffcomment b/rt1_env/bin/tiffcomment new file mode 100755 index 000000000..81e89dd82 --- /dev/null +++ b/rt1_env/bin/tiffcomment @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.tiffcomment import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tifffile b/rt1_env/bin/tifffile new file mode 100755 index 000000000..024aaecb3 --- /dev/null +++ b/rt1_env/bin/tifffile @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/toco b/rt1_env/bin/toco new file mode 100755 index 000000000..0ebb370c7 --- /dev/null +++ b/rt1_env/bin/toco @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.python.tflite_convert import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/toco_from_protos b/rt1_env/bin/toco_from_protos new file mode 100755 index 000000000..4a0931477 --- /dev/null +++ b/rt1_env/bin/toco_from_protos @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.toco.python.toco_from_protos import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/torchrun b/rt1_env/bin/torchrun new file mode 100755 index 000000000..bbd4216d0 --- /dev/null +++ b/rt1_env/bin/torchrun @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from torch.distributed.run import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tqdm b/rt1_env/bin/tqdm new file mode 100755 index 000000000..52aa9b22d --- /dev/null +++ b/rt1_env/bin/tqdm @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tqdm.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/transformers-cli b/rt1_env/bin/transformers-cli new file mode 100755 index 000000000..3cb3dba5c --- /dev/null +++ b/rt1_env/bin/transformers-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from transformers.commands.transformers_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/bin/tree-cli b/rt1_env/bin/tree-cli new file mode 100755 index 000000000..822fcbe27 --- /dev/null +++ b/rt1_env/bin/tree-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from Tree.cli import create_tree +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(create_tree()) diff --git a/rt1_env/bin/wandb b/rt1_env/bin/wandb new file mode 100755 index 000000000..ad3846609 --- /dev/null +++ b/rt1_env/bin/wandb @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wandb.cli.cli import cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli()) diff --git a/rt1_env/bin/wb b/rt1_env/bin/wb new file mode 100755 index 000000000..ad3846609 --- /dev/null +++ b/rt1_env/bin/wb @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wandb.cli.cli import cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli()) diff --git a/rt1_env/bin/wheel b/rt1_env/bin/wheel new file mode 100755 index 000000000..47a52e82e --- /dev/null +++ b/rt1_env/bin/wheel @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wheel.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto b/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto new file mode 100644 index 000000000..39512921e --- /dev/null +++ b/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto @@ -0,0 +1,77 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "reverb/cc/schema.proto"; +import "tensorflow/core/protobuf/struct.proto"; + +// Configs for reconstructing a distribution to its initial state. + +// Next ID: 11. +message PriorityTableCheckpoint { + // Name of the table. + string table_name = 1; + + // Maximum number of items in the table. + // If an insert would result in this value getting exceeded, `remover` is used + // to select an item to remove before proceeding with the insert. + int64 max_size = 6; + + // The maximum number of times an item can be sampled before being removed. + int32 max_times_sampled = 7; + + // Items in the table ordered by `inserted_at` (asc). + // When loading a checkpoint the items should be added in the same order so + // position based item selectors (e.g fifo) are reconstructed correctly. + // + // *NOTE*: This field is deprecated; instead, a separate record file is + // written with PrioritizedItem records for checkpointing (in the same + // order as described here). + repeated PrioritizedItem deprecated_items = 2 [deprecated = true]; + + // Checkpoint of the associated rate limiter. + RateLimiterCheckpoint rate_limiter = 3; + + // Options for constructing new samplers and removers of the correct type. + // Note that this does not include the state that they currently hold as it + // will be reproduced using the order of `items. + KeyDistributionOptions sampler = 4; + KeyDistributionOptions remover = 5; + + // The total number of episodes that were at some point referenced by items + // in the table but have since been removed. + int64 num_deleted_episodes = 8; + + // Optional data signature for tensors stored in the table. + tensorflow.StructuredValue signature = 9; + + // Number of unique items sampled from the table since the last reset. + int64 num_unique_samples = 10; +} + +message RateLimiterCheckpoint { + reserved 1; // Deprecated field `name`. + + // The average number of times each item should be sampled during its + // lifetime. + double samples_per_insert = 2; + + // The minimum and maximum values the cursor is allowed to reach. The cursor + // value is calculated as `insert_count * samples_per_insert - + // sample_count`. If the value would go beyond these limits then the call is + // blocked until it can proceed without violating the constraints. + double min_diff = 3; + double max_diff = 4; + + // The minimum number of inserts required before any sample operation. + int64 min_size_to_sample = 5; + + // The total number of samples that occurred before the checkpoint. + int64 sample_count = 6; + + // The total number of inserts that occurred before the checkpoint. + int64 insert_count = 7; + + // The total number of deletes that occurred before the checkpoint. + int64 delete_count = 8; +} diff --git a/rt1_env/include/site/python3.9/dm-reverb/patterns.proto b/rt1_env/include/site/python3.9/dm-reverb/patterns.proto new file mode 100644 index 000000000..3428db5a5 --- /dev/null +++ b/rt1_env/include/site/python3.9/dm-reverb/patterns.proto @@ -0,0 +1,123 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "tensorflow/core/protobuf/struct.proto"; + +message PatternNode { + // Index of the source column in the flattened step structure. + int32 flat_source_index = 1; + + // Slicing of the source column relative to the most recent step. + // + // These fields mimics the behavior of `slice` in Python. That is: + // + // * x[-1:] => (start=-1, stop=null) + // * x[-2] => (start=null, stop=-2) + // * x[-3:-1] => (start=-3, stop=-1) + // * x[-3:-1:2] => (start=-3, stop=-1, step=2) + // + // Furthermore, the following requirements applies: + // + // * Slices with undefined `start` (e.g. x[:-2]) are not supported. + // * For slices, `start` must be < 0 and `stop` must be <= 0. + // * `step` must be > 0 when defined. + // + oneof start_or_none { + int32 start = 2; + } + oneof stop_or_none { + int32 stop = 3; + } + oneof step_or_none { + int32 step = 4; + } +} + +message Condition { + // Given int32 `left`: `left % mod == eq`. + message ModuloEq { + int32 mod = 1; + int32 eq = 2; + } + + oneof left { + // The index of the most recent step within the episode. + bool step_index = 1; + + // The number of steps since the pattern was most recently applied. + bool steps_since_applied = 2; + + // The number of steps currently held by the buffer. + bool buffer_length = 3; + + // Set to 1 when `EndEpisode` is called, else 0. + bool is_end_episode = 4; + + // Extract scalar integer value from a column in the most recent step. If + // the column is not present in the data or it isn't a scalar of a supported + // type then the condition will return false. + // + // All integer types are casted to int32 and bool is converted to 1 if true + // and 0 if false. + // + int32 flat_source_index = 9; + } + + // TODO(b/205278205): Remove le and just use inverse + ge instead. + oneof cmp { + // `left == eq`. + int32 eq = 5; + + // `left >= ge`. + int32 ge = 6; + + // `left % mod_eq.mod == mod_eq.eq`. + ModuloEq mod_eq = 7; + } + + // Whether the condition result should be inversed. + bool inverse = 8; +} + +message Priority { + // Priority function that always return the same value. + message ConstantPriorityFn { + // Value to be returned by the priority function. + double value = 1; + } + + // Priority function that computes the trajectory TD Error using the per-step + // TD Error. See details of the TD Error in + // https://openreview.net/pdf?id=r1lyTjAqYX. + message TDError { + // Weight for the max priority in the TD Error computation. + double max_priority_weight = 1; + // Index of the field in the input step that contais the per-step TD Error. + int32 flat_source_index = 2; + } + + oneof priority_fn { + ConstantPriorityFn constant_fn = 1; + TDError td_error = 2; + } +} + +message StructuredWriterConfig { + // Flattened output structure. + repeated PatternNode flat = 1; + + // Serialised structure of the pattern. All leaf nodes must be None. If empty + // then pattern will be treated as a flat list. + tensorflow.StructuredValue pattern_structure = 2; + + // The table that generated trajectories will be inserted into. + string table = 3; + + // The priority assigned to all trajectories generated by this config. + Priority priority = 4; + + // Conditions which must be fulfilled for the configuration to be applied at + // the current step. + repeated Condition conditions = 5; +} diff --git a/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto b/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto new file mode 100644 index 000000000..a14a6ce56 --- /dev/null +++ b/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto @@ -0,0 +1,10 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "reverb/cc/checkpointing/checkpoint.proto"; + +message ReverbServerConfig { + repeated PriorityTableCheckpoint tables = 1; + int32 port = 2; +} diff --git a/rt1_env/include/site/python3.9/dm-reverb/schema.proto b/rt1_env/include/site/python3.9/dm-reverb/schema.proto new file mode 100644 index 000000000..3c37454c3 --- /dev/null +++ b/rt1_env/include/site/python3.9/dm-reverb/schema.proto @@ -0,0 +1,289 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "google/protobuf/timestamp.proto"; +import "tensorflow/core/framework/tensor.proto"; +import "tensorflow/core/protobuf/struct.proto"; + +// The actual data is stored in chunks. The data can be arbitrary tensors. We do +// not interpret the bytes data of the tensors on the server side. It is up to +// the client to compress the bytes blob within the tensors. +message ChunkData { + // Unique identifier of the chunk. + uint64 chunk_key = 1; + + // The timesteps within the episode that the chunk covers. + SequenceRange sequence_range = 2; + + // Actual tensor data. + message Data { + repeated tensorflow.TensorProto tensors = 1; + } + Data data = 5 [lazy = true]; + + // Number of tensors in the data field. Set explicitly so that Reverb server + // can check it without accessing lazy data field (which is expensive to + // parse). + int32 data_tensors_len = 6; + + // Size of the tensors in `data` before compression. + int64 data_uncompressed_size = 7; + + // True if delta encoding has been applied before compressing data. + bool delta_encoded = 4; + + // Deprecated December 2020 and retained to provide backward + // compatibility with checkpoints created before this point. + repeated tensorflow.TensorProto deprecated_data = 3 [deprecated = true]; +} + +// A range that specifies which items to slice out from a sequence of chunks. +// The length of all chunks must at least be `offset`+`length`. +message SliceRange { + // Offset where the slice should start. + int32 offset = 1; + + // Length of the slice. Can span multiple chunks. + int32 length = 2; +} + +message SequenceRange { + // Globally unique identifier of the episode the sequence belongs to. + uint64 episode_id = 1; + + // Index within the episode of the first timestep covered by the range. + int32 start = 2; + + // Index within the episode of the last timestep covered by the range. + // Must be >= start_index. + int32 end = 3; + + // If set then at least one step is missing from the data. The number of steps + // (i.e batch size) present in the data is unknown and thus must be manually + // checked. However, the `start` and `end` step is guaranteed to be at first + // and last position in the data. + bool sparse = 4; +} + +message FlatTrajectory { + message ChunkSlice { + // Unique identifier of the ChunkData which owns the compressed data. + uint64 chunk_key = 1; + + // Index of the first element in the chunk to include. + int32 offset = 2; + + // Number of elements from the chunk to include. + int32 length = 3; + + // Tensor index of the tensor within the chunk. + int32 index = 4; + } + + message Column { + // Chunk slices to concat. + repeated ChunkSlice chunk_slices = 1; + + // If true then the batch dim (must be 1) is emitted when unpacked. + // Requires that column is made up of exactly one ChunkSlice of length 1. + bool squeeze = 2; + } + + // Flattened columns of the trajectory. + repeated Column columns = 1; +} + +// A prioritized item is part of a table and references a chunk of +// data. Sampling happens based on the priority of items. +// +// Next ID: 9. +// LINT.IfChange +message PrioritizedItem { + // Unique identifier of this item. + uint64 key = 1; + + // Priority table that the item belongs to. + string table = 2; + + // Priority used for sampling. + double priority = 5; + + // The number of times the item has been sampled. + int32 times_sampled = 6; + + // The time when the item was first inserted. + google.protobuf.Timestamp inserted_at = 7; + + // Flattened representation of item's trajectory. + FlatTrajectory flat_trajectory = 8; + + // Deprecated January 2021 and retained to provide backward compatibility + // with checkpoints created before this point. + repeated uint64 deprecated_chunk_keys = 3 [deprecated = true]; + SliceRange deprecated_sequence_range = 4 [deprecated = true]; +} +// LINT.ThenChange(reverb_service_impl.cc) + +// Used for updating an existing PrioritizedItem. +message KeyWithPriority { + // Identifier of the PrioritizedItem. + uint64 key = 1; + + // Priority used for sampling. + double priority = 2; +} + +message SampleInfo { + // Item from that was sampled from the table. + PrioritizedItem item = 1; + + // Probability that this item had at sampling time. Useful for importance + // sampling. + double probability = 2; + + // Number of items in the table at the time of the sample operation. + int64 table_size = 3; + + // Whether the sample was delayed due to rate limiting of the sampler. + bool rate_limited = 4; +} + +// LINT.IfChange +// Metadata about the table, including (optional) data signature. +// +// These fields correspond to initialization arguments of the +// `Table` class, unless noted otherwise. +// +// Next ID: 13. +message TableInfo { + // Table's name. + string name = 8; + + // Sampler and remover metadata. + KeyDistributionOptions sampler_options = 1; + KeyDistributionOptions remover_options = 2; + + // Max size of the table. + int64 max_size = 3; + + // Max number of times an element can be sampled before being + // removed. + int32 max_times_sampled = 4; + + // How data read/write is rate limited. + RateLimiterInfo rate_limiter_info = 5; + + // Optional data signature for tensors stored in the table. Note + // that this data type is more flexible than we use. For example, + // we only store tensors (TensorSpecProto, TypeSpecProto) and not + // any special data types (no NoneValue or other special fixed values). + tensorflow.StructuredValue signature = 6; + + // Current size of table. + int64 current_size = 7; + + // Number of episodes referenced by the items in the table. + int64 num_episodes = 9; + + // Number of episodes once referenced by items in the table but no longer is. + // The total number of episodes thus is `num_episodes + num_deleted_episodes`. + int64 num_deleted_episodes = 10; + + // Number of unique items sampled from the table since the last reset. + int64 num_unique_samples = 11; + + // Table worker execution time distribution. + TableWorkerTime table_worker_time = 12; +} +// LINT.ThenChange(../py/reverb/reverb_types.py) + +message RateLimiterCallStats { + // The total number of completed calls. + int64 completed = 2; + + reserved 1, 3, 4, 5; +} + +message RateLimiterInfo { + // The average number of times each item should be sampled during its + // lifetime. + double samples_per_insert = 1; + + // The minimum and maximum values the cursor is allowed to reach. The cursor + // value is calculated as `insert_count * samples_per_insert - + // sample_count`. If the value would go beyond these limits then the call is + // blocked until it can proceed without violating the constraints. + double min_diff = 2; + double max_diff = 3; + + // The minimum number of inserts required before any sample operation. + int64 min_size_to_sample = 4; + + // Stats regarding the limiting of insert calls. + RateLimiterCallStats insert_stats = 5; + + // Stats regarding the limiting of sample calls. + RateLimiterCallStats sample_stats = 6; +} + +message TableWorkerTime { + // Cumulative time the table worker is performing general work. + int64 running_ms = 1; + + // Cumulative time the table worker is actively processing sampling requests. + int64 sampling_ms = 2; + + // Cumulative time the table worker is actively processing insert requests. + int64 inserting_ms = 3; + + // Cumulative time the table worker is sleeping as there is no work to do + // (there are no pending insert/sample requests to process). + int64 sleeping_ms = 4; + + // Cumulative time the table worker is blocked waiting for sampling requests + // There are pending insert requests which are blocked by the rate limiter, + // while there are no sampling requests which could unblock inserts. + // The system can't make further progress and the worker is put to sleep until + // sample request arives. + int64 waiting_for_sampling_ms = 5; + + // Cumulative time the table worker is blocked waiting for insert requests + // There are pending sample requests which are blocked by the rate + // limiter, while there are no insert requests which could unblock sampling. + // The system can't make further progress and the worker is put to sleep until + // insert request arives. + int64 waiting_for_inserts_ms = 6; +} + +// Metadata about sampler or remover. Describes its configuration. +message KeyDistributionOptions { + message Prioritized { + double priority_exponent = 1; + } + + message Heap { + bool min_heap = 1; + } + + oneof distribution { + bool fifo = 1; + bool uniform = 2; + Prioritized prioritized = 3; + Heap heap = 4; + bool lifo = 6; + } + reserved 5; + bool is_deterministic = 7; +} + +// Uint128 representation. Can be used for unique identifiers. +message Uint128 { + uint64 high = 1; + uint64 low = 2; +} + +// Representation of a timeout. A value < 0 means never time out. +message Timeout { + int64 milliseconds = 1; +} diff --git a/rt1_env/lib64 b/rt1_env/lib64 new file mode 120000 index 000000000..7951405f8 --- /dev/null +++ b/rt1_env/lib64 @@ -0,0 +1 @@ +lib \ No newline at end of file diff --git a/rt1_env/pyvenv.cfg b/rt1_env/pyvenv.cfg new file mode 100644 index 000000000..1997c5b53 --- /dev/null +++ b/rt1_env/pyvenv.cfg @@ -0,0 +1,3 @@ +home = /usr/bin +include-system-site-packages = false +version = 3.9.16 diff --git a/rt1_env/share/man/man1/isympy.1 b/rt1_env/share/man/man1/isympy.1 new file mode 100644 index 000000000..0ff966158 --- /dev/null +++ b/rt1_env/share/man/man1/isympy.1 @@ -0,0 +1,188 @@ +'\" -*- coding: us-ascii -*- +.if \n(.g .ds T< \\FC +.if \n(.g .ds T> \\F[\n[.fam]] +.de URL +\\$2 \(la\\$1\(ra\\$3 +.. +.if \n(.g .mso www.tmac +.TH isympy 1 2007-10-8 "" "" +.SH NAME +isympy \- interactive shell for SymPy +.SH SYNOPSIS +'nh +.fi +.ad l +\fBisympy\fR \kx +.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) +'in \n(.iu+\nxu +[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [ +-- | PYTHONOPTIONS] +'in \n(.iu-\nxu +.ad b +'hy +'nh +.fi +.ad l +\fBisympy\fR \kx +.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) +'in \n(.iu+\nxu +[ +{\fB-h\fR | \fB--help\fR} +| +{\fB-v\fR | \fB--version\fR} +] +'in \n(.iu-\nxu +.ad b +'hy +.SH DESCRIPTION +isympy is a Python shell for SymPy. It is just a normal python shell +(ipython shell if you have the ipython package installed) that executes +the following commands so that you don't have to: +.PP +.nf +\*(T< +>>> from __future__ import division +>>> from sympy import * +>>> x, y, z = symbols("x,y,z") +>>> k, m, n = symbols("k,m,n", integer=True) + \*(T> +.fi +.PP +So starting isympy is equivalent to starting python (or ipython) and +executing the above commands by hand. It is intended for easy and quick +experimentation with SymPy. For more complicated programs, it is recommended +to write a script and import things explicitly (using the "from sympy +import sin, log, Symbol, ..." idiom). +.SH OPTIONS +.TP +\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR +Use the specified shell (python or ipython) as +console backend instead of the default one (ipython +if present or python otherwise). + +Example: isympy -c python + +\fISHELL\fR could be either +\&'ipython' or 'python' +.TP +\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR +Setup pretty printing in SymPy. By default, the most pretty, unicode +printing is enabled (if the terminal supports it). You can use less +pretty ASCII printing instead or no pretty printing at all. + +Example: isympy -p no + +\fIENCODING\fR must be one of 'unicode', +\&'ascii' or 'no'. +.TP +\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR +Setup the ground types for the polys. By default, gmpy ground types +are used if gmpy2 or gmpy is installed, otherwise it falls back to python +ground types, which are a little bit slower. You can manually +choose python ground types even if gmpy is installed (e.g., for testing purposes). + +Note that sympy ground types are not supported, and should be used +only for experimental purposes. + +Note that the gmpy1 ground type is primarily intended for testing; it the +use of gmpy even if gmpy2 is available. + +This is the same as setting the environment variable +SYMPY_GROUND_TYPES to the given ground type (e.g., +SYMPY_GROUND_TYPES='gmpy') + +The ground types can be determined interactively from the variable +sympy.polys.domains.GROUND_TYPES inside the isympy shell itself. + +Example: isympy -t python + +\fITYPE\fR must be one of 'gmpy', +\&'gmpy1' or 'python'. +.TP +\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR +Setup the ordering of terms for printing. The default is lex, which +orders terms lexicographically (e.g., x**2 + x + 1). You can choose +other orderings, such as rev-lex, which will use reverse +lexicographic ordering (e.g., 1 + x + x**2). + +Note that for very large expressions, ORDER='none' may speed up +printing considerably, with the tradeoff that the order of the terms +in the printed expression will have no canonical order + +Example: isympy -o rev-lax + +\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex', +\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'. +.TP +\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T> +Print only Python's and SymPy's versions to stdout at startup, and nothing else. +.TP +\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T> +Use the same format that should be used for doctests. This is +equivalent to '\fIisympy -c python -p no\fR'. +.TP +\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T> +Disable the caching mechanism. Disabling the cache may slow certain +operations down considerably. This is useful for testing the cache, +or for benchmarking, as the cache can result in deceptive benchmark timings. + +This is the same as setting the environment variable SYMPY_USE_CACHE +to 'no'. +.TP +\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T> +Automatically create missing symbols. Normally, typing a name of a +Symbol that has not been instantiated first would raise NameError, +but with this option enabled, any undefined name will be +automatically created as a Symbol. This only works in IPython 0.11. + +Note that this is intended only for interactive, calculator style +usage. In a script that uses SymPy, Symbols should be instantiated +at the top, so that it's clear what they are. + +This will not override any names that are already defined, which +includes the single character letters represented by the mnemonic +QCOSINE (see the "Gotchas and Pitfalls" document in the +documentation). You can delete existing names by executing "del +name" in the shell itself. You can see if a name is defined by typing +"'name' in globals()". + +The Symbols that are created using this have default assumptions. +If you want to place assumptions on symbols, you should create them +using symbols() or var(). + +Finally, this only works in the top level namespace. So, for +example, if you define a function in isympy with an undefined +Symbol, it will not work. +.TP +\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T> +Enable debugging output. This is the same as setting the +environment variable SYMPY_DEBUG to 'True'. The debug status is set +in the variable SYMPY_DEBUG within isympy. +.TP +-- \fIPYTHONOPTIONS\fR +These options will be passed on to \fIipython (1)\fR shell. +Only supported when ipython is being used (standard python shell not supported). + +Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR +from the other isympy options. + +For example, to run iSymPy without startup banner and colors: + +isympy -q -c ipython -- --colors=NoColor +.TP +\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T> +Print help output and exit. +.TP +\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T> +Print isympy version information and exit. +.SH FILES +.TP +\*(T<\fI${HOME}/.sympy\-history\fR\*(T> +Saves the history of commands when using the python +shell as backend. +.SH BUGS +The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra +Please report all bugs that you find in there, this will help improve +the overall quality of SymPy. +.SH "SEE ALSO" +\fBipython\fR(1), \fBpython\fR(1) From 66f0b16bf3f2bac77b0db1228649085794b283ef Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 01:10:30 -0400 Subject: [PATCH 06/12] updates to rt1 --- .gitignore | 2 +- main_ft.py | 10 ++++++---- main_ft_eval.py | 3 ++- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index 5deb9495c..6d4daa44a 100644 --- a/.gitignore +++ b/.gitignore @@ -135,4 +135,4 @@ wandb/ rt1_dataset/* traj_rollouts/* run_rt1_main.sh -rt1_ft_env \ No newline at end of file +rt1_ft_env diff --git a/main_ft.py b/main_ft.py index 545f3cb2b..dca6394ab 100644 --- a/main_ft.py +++ b/main_ft.py @@ -91,20 +91,20 @@ def parse_args(): parser.add_argument( "--checkpoint-dir", type=str, - default="checkpoints/diversity_v1_4", + default="checkpoints/temp", #"checkpoints/diversity_v1_4" help="directory to save checkpoints", ) parser.add_argument( "--load-checkpoint", type=str, - default=None, #NOTE: include the path to load the checkpoint here + default='/oscar/data/stellex/shared/rt1-checkpoints/checkpoints/bridge/checkpoint_14400_loss_70.621.pt', #NOTE: include the path to load the checkpoint here help="checkpoint to load from; defaults to None", ) parser.add_argument( "--wandb", action="store_true", help="use wandb for logging", - default=True, + default=False, ) parser.add_argument( @@ -115,7 +115,7 @@ def parse_args(): parser.add_argument( "--split-type", - default = 'diversity_ablation', + default = 'k_fold_scene', choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], ) @@ -142,6 +142,8 @@ def parse_args(): def main(): + + args = parse_args() os.makedirs(args.checkpoint_dir, exist_ok=True) diff --git a/main_ft_eval.py b/main_ft_eval.py index 831604d73..708243b25 100644 --- a/main_ft_eval.py +++ b/main_ft_eval.py @@ -68,7 +68,7 @@ def parse_args(): "--wandb", action="store_true", help="use wandb for logging", - default=True, + default=False, ) parser.add_argument( @@ -100,6 +100,7 @@ def parse_args(): def main(): args = parse_args() + os.makedirs(args.checkpoint_path, exist_ok=True) From 34675441d352d83faa8c5446daf11556adc82d56 Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 17:50:22 -0400 Subject: [PATCH 07/12] updated restructure of RT1 branch for merge --- models/main_models/rt1/LICENSE | 21 + .../rt1/Open_X_Embodiment_Datasets.ipynb | 2303 ++++++++++ models/main_models/rt1/README.md | 66 + models/main_models/rt1/ai2thor_env.py | 641 +++ models/main_models/rt1/data.py | 536 +++ models/main_models/rt1/figures/rt1.png | Bin 0 -> 135877 bytes models/main_models/rt1/gen/README.md | 77 + models/main_models/rt1/gen/__init__.py | 0 .../main_models/rt1/gen/agents/agent_base.py | 60 + .../gen/agents/deterministic_planner_agent.py | 26 + .../main_models/rt1/gen/agents/plan_agent.py | 94 + .../gen/agents/semantic_map_planner_agent.py | 72 + models/main_models/rt1/gen/constants.py | 1221 ++++++ .../main_models/rt1/gen/ff_planner/README.md | 13 + .../rt1/gen/ff_planner/expressions.c | 2623 +++++++++++ .../rt1/gen/ff_planner/expressions.h | 106 + models/main_models/rt1/gen/ff_planner/ff.h | 2044 +++++++++ .../rt1/gen/ff_planner/inst_easy.c | 1220 ++++++ .../rt1/gen/ff_planner/inst_easy.h | 73 + .../rt1/gen/ff_planner/inst_final.c | 2797 ++++++++++++ .../rt1/gen/ff_planner/inst_final.h | 69 + .../rt1/gen/ff_planner/inst_hard.c | 1306 ++++++ .../rt1/gen/ff_planner/inst_hard.h | 71 + .../main_models/rt1/gen/ff_planner/inst_pre.c | 3854 +++++++++++++++++ .../main_models/rt1/gen/ff_planner/inst_pre.h | 123 + .../rt1/gen/ff_planner/lex-fct_pddl.l | 139 + .../rt1/gen/ff_planner/lex-ops_pddl.l | 151 + models/main_models/rt1/gen/ff_planner/main.c | 1230 ++++++ .../main_models/rt1/gen/ff_planner/makefile | 89 + .../main_models/rt1/gen/ff_planner/memory.c | 1278 ++++++ .../main_models/rt1/gen/ff_planner/memory.h | 109 + .../main_models/rt1/gen/ff_planner/output.c | 1482 +++++++ .../main_models/rt1/gen/ff_planner/output.h | 68 + models/main_models/rt1/gen/ff_planner/parse.c | 1339 ++++++ models/main_models/rt1/gen/ff_planner/parse.h | 63 + models/main_models/rt1/gen/ff_planner/relax.c | 2756 ++++++++++++ models/main_models/rt1/gen/ff_planner/relax.h | 93 + .../rt1/gen/ff_planner/run_sample.sh | 2 + .../ff_planner/samples/PutTask_domain.pddl | 152 + .../gen/ff_planner/samples/problem_0_0.pddl | 390 ++ .../rt1/gen/ff_planner/scan-fct_pddl.y | 918 ++++ .../rt1/gen/ff_planner/scan-ops_pddl.y | 1086 +++++ .../main_models/rt1/gen/ff_planner/search.c | 2372 ++++++++++ .../main_models/rt1/gen/ff_planner/search.h | 105 + .../rt1/gen/game_states/__init__.py | 0 .../rt1/gen/game_states/game_state_base.py | 935 ++++ .../rt1/gen/game_states/planned_game_state.py | 490 +++ .../rt1/gen/game_states/task_game_state.py | 368 ++ .../task_game_state_full_knowledge.py | 444 ++ models/main_models/rt1/gen/goal_library.py | 682 +++ models/main_models/rt1/gen/graph/__init__.py | 0 models/main_models/rt1/gen/graph/graph_obj.py | 426 ++ .../rt1/gen/layouts/FloorPlan1-layout.npy | Bin 0 -> 2064 bytes .../rt1/gen/layouts/FloorPlan1-objects.json | 51 + .../rt1/gen/layouts/FloorPlan1-openable.json | 146 + .../rt1/gen/layouts/FloorPlan10-layout.npy | Bin 0 -> 3488 bytes .../rt1/gen/layouts/FloorPlan10-objects.json | 49 + .../rt1/gen/layouts/FloorPlan10-openable.json | 110 + .../rt1/gen/layouts/FloorPlan11-layout.npy | Bin 0 -> 1104 bytes .../rt1/gen/layouts/FloorPlan11-objects.json | 43 + .../rt1/gen/layouts/FloorPlan11-openable.json | 128 + .../rt1/gen/layouts/FloorPlan12-layout.npy | Bin 0 -> 1808 bytes .../rt1/gen/layouts/FloorPlan12-objects.json | 40 + .../rt1/gen/layouts/FloorPlan12-openable.json | 218 + .../rt1/gen/layouts/FloorPlan13-layout.npy | Bin 0 -> 3008 bytes .../rt1/gen/layouts/FloorPlan13-objects.json | 43 + .../rt1/gen/layouts/FloorPlan13-openable.json | 224 + .../rt1/gen/layouts/FloorPlan14-layout.npy | Bin 0 -> 1968 bytes .../rt1/gen/layouts/FloorPlan14-objects.json | 40 + .../rt1/gen/layouts/FloorPlan14-openable.json | 68 + .../rt1/gen/layouts/FloorPlan15-layout.npy | Bin 0 -> 1616 bytes .../rt1/gen/layouts/FloorPlan15-objects.json | 45 + .../rt1/gen/layouts/FloorPlan15-openable.json | 92 + .../rt1/gen/layouts/FloorPlan16-layout.npy | Bin 0 -> 3312 bytes .../rt1/gen/layouts/FloorPlan16-objects.json | 46 + .../rt1/gen/layouts/FloorPlan16-openable.json | 200 + .../rt1/gen/layouts/FloorPlan17-layout.npy | Bin 0 -> 1168 bytes .../rt1/gen/layouts/FloorPlan17-objects.json | 47 + .../rt1/gen/layouts/FloorPlan17-openable.json | 140 + .../rt1/gen/layouts/FloorPlan18-layout.npy | Bin 0 -> 3600 bytes .../rt1/gen/layouts/FloorPlan18-objects.json | 48 + .../rt1/gen/layouts/FloorPlan18-openable.json | 146 + .../rt1/gen/layouts/FloorPlan19-layout.npy | Bin 0 -> 1184 bytes .../rt1/gen/layouts/FloorPlan19-objects.json | 40 + .../rt1/gen/layouts/FloorPlan19-openable.json | 182 + .../rt1/gen/layouts/FloorPlan2-layout.npy | Bin 0 -> 1968 bytes .../rt1/gen/layouts/FloorPlan2-objects.json | 43 + .../rt1/gen/layouts/FloorPlan2-openable.json | 164 + .../rt1/gen/layouts/FloorPlan20-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan20-objects.json | 46 + .../rt1/gen/layouts/FloorPlan20-openable.json | 116 + .../rt1/gen/layouts/FloorPlan201-layout.npy | Bin 0 -> 3232 bytes .../rt1/gen/layouts/FloorPlan201-objects.json | 37 + .../gen/layouts/FloorPlan201-openable.json | 86 + .../rt1/gen/layouts/FloorPlan202-layout.npy | Bin 0 -> 2496 bytes .../rt1/gen/layouts/FloorPlan202-objects.json | 26 + .../gen/layouts/FloorPlan202-openable.json | 44 + .../rt1/gen/layouts/FloorPlan203-layout.npy | Bin 0 -> 8512 bytes .../rt1/gen/layouts/FloorPlan203-objects.json | 35 + .../gen/layouts/FloorPlan203-openable.json | 86 + .../rt1/gen/layouts/FloorPlan204-layout.npy | Bin 0 -> 2960 bytes .../rt1/gen/layouts/FloorPlan204-objects.json | 31 + .../gen/layouts/FloorPlan204-openable.json | 146 + .../rt1/gen/layouts/FloorPlan205-layout.npy | Bin 0 -> 4112 bytes .../rt1/gen/layouts/FloorPlan205-objects.json | 29 + .../gen/layouts/FloorPlan205-openable.json | 80 + .../rt1/gen/layouts/FloorPlan206-layout.npy | Bin 0 -> 1904 bytes .../rt1/gen/layouts/FloorPlan206-objects.json | 26 + .../gen/layouts/FloorPlan206-openable.json | 122 + .../rt1/gen/layouts/FloorPlan207-layout.npy | Bin 0 -> 2352 bytes .../rt1/gen/layouts/FloorPlan207-objects.json | 27 + .../gen/layouts/FloorPlan207-openable.json | 98 + .../rt1/gen/layouts/FloorPlan208-layout.npy | Bin 0 -> 3376 bytes .../rt1/gen/layouts/FloorPlan208-objects.json | 26 + .../gen/layouts/FloorPlan208-openable.json | 98 + .../rt1/gen/layouts/FloorPlan209-layout.npy | Bin 0 -> 4816 bytes .../rt1/gen/layouts/FloorPlan209-objects.json | 31 + .../gen/layouts/FloorPlan209-openable.json | 62 + .../rt1/gen/layouts/FloorPlan21-layout.npy | Bin 0 -> 1584 bytes .../rt1/gen/layouts/FloorPlan21-objects.json | 47 + .../rt1/gen/layouts/FloorPlan21-openable.json | 86 + .../rt1/gen/layouts/FloorPlan210-layout.npy | Bin 0 -> 4160 bytes .../rt1/gen/layouts/FloorPlan210-objects.json | 30 + .../gen/layouts/FloorPlan210-openable.json | 98 + .../rt1/gen/layouts/FloorPlan211-layout.npy | Bin 0 -> 2240 bytes .../rt1/gen/layouts/FloorPlan211-objects.json | 30 + .../gen/layouts/FloorPlan211-openable.json | 74 + .../rt1/gen/layouts/FloorPlan212-layout.npy | Bin 0 -> 1856 bytes .../rt1/gen/layouts/FloorPlan212-objects.json | 30 + .../gen/layouts/FloorPlan212-openable.json | 80 + .../rt1/gen/layouts/FloorPlan213-layout.npy | Bin 0 -> 4736 bytes .../rt1/gen/layouts/FloorPlan213-objects.json | 27 + .../gen/layouts/FloorPlan213-openable.json | 146 + .../rt1/gen/layouts/FloorPlan214-layout.npy | Bin 0 -> 3024 bytes .../rt1/gen/layouts/FloorPlan214-objects.json | 29 + .../gen/layouts/FloorPlan214-openable.json | 56 + .../rt1/gen/layouts/FloorPlan215-layout.npy | Bin 0 -> 6208 bytes .../rt1/gen/layouts/FloorPlan215-objects.json | 30 + .../gen/layouts/FloorPlan215-openable.json | 92 + .../rt1/gen/layouts/FloorPlan216-layout.npy | Bin 0 -> 2560 bytes .../rt1/gen/layouts/FloorPlan216-objects.json | 28 + .../gen/layouts/FloorPlan216-openable.json | 68 + .../rt1/gen/layouts/FloorPlan217-layout.npy | Bin 0 -> 2240 bytes .../rt1/gen/layouts/FloorPlan217-objects.json | 29 + .../gen/layouts/FloorPlan217-openable.json | 92 + .../rt1/gen/layouts/FloorPlan218-layout.npy | Bin 0 -> 6400 bytes .../rt1/gen/layouts/FloorPlan218-objects.json | 30 + .../gen/layouts/FloorPlan218-openable.json | 68 + .../rt1/gen/layouts/FloorPlan219-layout.npy | Bin 0 -> 3552 bytes .../rt1/gen/layouts/FloorPlan219-objects.json | 31 + .../gen/layouts/FloorPlan219-openable.json | 158 + .../rt1/gen/layouts/FloorPlan22-layout.npy | Bin 0 -> 2256 bytes .../rt1/gen/layouts/FloorPlan22-objects.json | 42 + .../rt1/gen/layouts/FloorPlan22-openable.json | 176 + .../rt1/gen/layouts/FloorPlan220-layout.npy | Bin 0 -> 3712 bytes .../rt1/gen/layouts/FloorPlan220-objects.json | 30 + .../gen/layouts/FloorPlan220-openable.json | 92 + .../rt1/gen/layouts/FloorPlan221-layout.npy | Bin 0 -> 1904 bytes .../rt1/gen/layouts/FloorPlan221-objects.json | 29 + .../gen/layouts/FloorPlan221-openable.json | 44 + .../rt1/gen/layouts/FloorPlan222-layout.npy | Bin 0 -> 1648 bytes .../rt1/gen/layouts/FloorPlan222-objects.json | 26 + .../gen/layouts/FloorPlan222-openable.json | 86 + .../rt1/gen/layouts/FloorPlan223-layout.npy | Bin 0 -> 3344 bytes .../rt1/gen/layouts/FloorPlan223-objects.json | 28 + .../gen/layouts/FloorPlan223-openable.json | 50 + .../rt1/gen/layouts/FloorPlan224-layout.npy | Bin 0 -> 4688 bytes .../rt1/gen/layouts/FloorPlan224-objects.json | 32 + .../gen/layouts/FloorPlan224-openable.json | 182 + .../rt1/gen/layouts/FloorPlan225-layout.npy | Bin 0 -> 2576 bytes .../rt1/gen/layouts/FloorPlan225-objects.json | 31 + .../gen/layouts/FloorPlan225-openable.json | 86 + .../rt1/gen/layouts/FloorPlan226-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan226-objects.json | 25 + .../gen/layouts/FloorPlan226-openable.json | 68 + .../rt1/gen/layouts/FloorPlan227-layout.npy | Bin 0 -> 3232 bytes .../rt1/gen/layouts/FloorPlan227-objects.json | 28 + .../gen/layouts/FloorPlan227-openable.json | 206 + .../rt1/gen/layouts/FloorPlan228-layout.npy | Bin 0 -> 2576 bytes .../rt1/gen/layouts/FloorPlan228-objects.json | 27 + .../gen/layouts/FloorPlan228-openable.json | 62 + .../rt1/gen/layouts/FloorPlan229-layout.npy | Bin 0 -> 3088 bytes .../rt1/gen/layouts/FloorPlan229-objects.json | 32 + .../gen/layouts/FloorPlan229-openable.json | 68 + .../rt1/gen/layouts/FloorPlan23-layout.npy | Bin 0 -> 1648 bytes .../rt1/gen/layouts/FloorPlan23-objects.json | 47 + .../rt1/gen/layouts/FloorPlan23-openable.json | 98 + .../rt1/gen/layouts/FloorPlan230-layout.npy | Bin 0 -> 6448 bytes .../rt1/gen/layouts/FloorPlan230-objects.json | 32 + .../gen/layouts/FloorPlan230-openable.json | 56 + .../rt1/gen/layouts/FloorPlan24-layout.npy | Bin 0 -> 1152 bytes .../rt1/gen/layouts/FloorPlan24-objects.json | 42 + .../rt1/gen/layouts/FloorPlan24-openable.json | 176 + .../rt1/gen/layouts/FloorPlan25-layout.npy | Bin 0 -> 560 bytes .../rt1/gen/layouts/FloorPlan25-objects.json | 41 + .../rt1/gen/layouts/FloorPlan25-openable.json | 92 + .../rt1/gen/layouts/FloorPlan26-layout.npy | Bin 0 -> 1344 bytes .../rt1/gen/layouts/FloorPlan26-objects.json | 40 + .../rt1/gen/layouts/FloorPlan26-openable.json | 92 + .../rt1/gen/layouts/FloorPlan27-layout.npy | Bin 0 -> 784 bytes .../rt1/gen/layouts/FloorPlan27-objects.json | 43 + .../rt1/gen/layouts/FloorPlan27-openable.json | 128 + .../rt1/gen/layouts/FloorPlan28-layout.npy | Bin 0 -> 1712 bytes .../rt1/gen/layouts/FloorPlan28-objects.json | 43 + .../rt1/gen/layouts/FloorPlan28-openable.json | 122 + .../rt1/gen/layouts/FloorPlan29-layout.npy | Bin 0 -> 1168 bytes .../rt1/gen/layouts/FloorPlan29-objects.json | 39 + .../rt1/gen/layouts/FloorPlan29-openable.json | 80 + .../rt1/gen/layouts/FloorPlan3-layout.npy | Bin 0 -> 1856 bytes .../rt1/gen/layouts/FloorPlan3-objects.json | 45 + .../rt1/gen/layouts/FloorPlan3-openable.json | 110 + .../rt1/gen/layouts/FloorPlan30-layout.npy | Bin 0 -> 1296 bytes .../rt1/gen/layouts/FloorPlan30-objects.json | 45 + .../rt1/gen/layouts/FloorPlan30-openable.json | 218 + .../rt1/gen/layouts/FloorPlan301-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan301-objects.json | 35 + .../gen/layouts/FloorPlan301-openable.json | 122 + .../rt1/gen/layouts/FloorPlan302-layout.npy | Bin 0 -> 848 bytes .../rt1/gen/layouts/FloorPlan302-objects.json | 31 + .../gen/layouts/FloorPlan302-openable.json | 80 + .../rt1/gen/layouts/FloorPlan303-layout.npy | Bin 0 -> 1168 bytes .../rt1/gen/layouts/FloorPlan303-objects.json | 35 + .../gen/layouts/FloorPlan303-openable.json | 122 + .../rt1/gen/layouts/FloorPlan304-layout.npy | Bin 0 -> 1808 bytes .../rt1/gen/layouts/FloorPlan304-objects.json | 30 + .../gen/layouts/FloorPlan304-openable.json | 26 + .../rt1/gen/layouts/FloorPlan305-layout.npy | Bin 0 -> 1472 bytes .../rt1/gen/layouts/FloorPlan305-objects.json | 32 + .../gen/layouts/FloorPlan305-openable.json | 62 + .../rt1/gen/layouts/FloorPlan306-layout.npy | Bin 0 -> 1632 bytes .../rt1/gen/layouts/FloorPlan306-objects.json | 27 + .../gen/layouts/FloorPlan306-openable.json | 68 + .../rt1/gen/layouts/FloorPlan307-layout.npy | Bin 0 -> 1424 bytes .../rt1/gen/layouts/FloorPlan307-objects.json | 34 + .../gen/layouts/FloorPlan307-openable.json | 104 + .../rt1/gen/layouts/FloorPlan308-layout.npy | Bin 0 -> 1744 bytes .../rt1/gen/layouts/FloorPlan308-objects.json | 30 + .../gen/layouts/FloorPlan308-openable.json | 104 + .../rt1/gen/layouts/FloorPlan309-layout.npy | Bin 0 -> 5760 bytes .../rt1/gen/layouts/FloorPlan309-objects.json | 33 + .../gen/layouts/FloorPlan309-openable.json | 74 + .../rt1/gen/layouts/FloorPlan310-layout.npy | Bin 0 -> 1152 bytes .../rt1/gen/layouts/FloorPlan310-objects.json | 31 + .../gen/layouts/FloorPlan310-openable.json | 50 + .../rt1/gen/layouts/FloorPlan311-layout.npy | Bin 0 -> 3760 bytes .../rt1/gen/layouts/FloorPlan311-objects.json | 32 + .../gen/layouts/FloorPlan311-openable.json | 56 + .../rt1/gen/layouts/FloorPlan312-layout.npy | Bin 0 -> 1440 bytes .../rt1/gen/layouts/FloorPlan312-objects.json | 27 + .../gen/layouts/FloorPlan312-openable.json | 74 + .../rt1/gen/layouts/FloorPlan313-layout.npy | Bin 0 -> 880 bytes .../rt1/gen/layouts/FloorPlan313-objects.json | 34 + .../gen/layouts/FloorPlan313-openable.json | 80 + .../rt1/gen/layouts/FloorPlan314-layout.npy | Bin 0 -> 1200 bytes .../rt1/gen/layouts/FloorPlan314-objects.json | 27 + .../gen/layouts/FloorPlan314-openable.json | 50 + .../rt1/gen/layouts/FloorPlan315-layout.npy | Bin 0 -> 1712 bytes .../rt1/gen/layouts/FloorPlan315-objects.json | 28 + .../gen/layouts/FloorPlan315-openable.json | 110 + .../rt1/gen/layouts/FloorPlan316-layout.npy | Bin 0 -> 1056 bytes .../rt1/gen/layouts/FloorPlan316-objects.json | 30 + .../gen/layouts/FloorPlan316-openable.json | 44 + .../rt1/gen/layouts/FloorPlan317-layout.npy | Bin 0 -> 1680 bytes .../rt1/gen/layouts/FloorPlan317-objects.json | 30 + .../gen/layouts/FloorPlan317-openable.json | 92 + .../rt1/gen/layouts/FloorPlan318-layout.npy | Bin 0 -> 1632 bytes .../rt1/gen/layouts/FloorPlan318-objects.json | 31 + .../gen/layouts/FloorPlan318-openable.json | 158 + .../rt1/gen/layouts/FloorPlan319-layout.npy | Bin 0 -> 1680 bytes .../rt1/gen/layouts/FloorPlan319-objects.json | 30 + .../gen/layouts/FloorPlan319-openable.json | 122 + .../rt1/gen/layouts/FloorPlan320-layout.npy | Bin 0 -> 1200 bytes .../rt1/gen/layouts/FloorPlan320-objects.json | 30 + .../gen/layouts/FloorPlan320-openable.json | 50 + .../rt1/gen/layouts/FloorPlan321-layout.npy | Bin 0 -> 1600 bytes .../rt1/gen/layouts/FloorPlan321-objects.json | 27 + .../gen/layouts/FloorPlan321-openable.json | 44 + .../rt1/gen/layouts/FloorPlan322-layout.npy | Bin 0 -> 1792 bytes .../rt1/gen/layouts/FloorPlan322-objects.json | 30 + .../gen/layouts/FloorPlan322-openable.json | 122 + .../rt1/gen/layouts/FloorPlan323-layout.npy | Bin 0 -> 3184 bytes .../rt1/gen/layouts/FloorPlan323-objects.json | 30 + .../gen/layouts/FloorPlan323-openable.json | 80 + .../rt1/gen/layouts/FloorPlan324-layout.npy | Bin 0 -> 1552 bytes .../rt1/gen/layouts/FloorPlan324-objects.json | 29 + .../gen/layouts/FloorPlan324-openable.json | 110 + .../rt1/gen/layouts/FloorPlan325-layout.npy | Bin 0 -> 3040 bytes .../rt1/gen/layouts/FloorPlan325-objects.json | 28 + .../gen/layouts/FloorPlan325-openable.json | 140 + .../rt1/gen/layouts/FloorPlan326-layout.npy | Bin 0 -> 1728 bytes .../rt1/gen/layouts/FloorPlan326-objects.json | 35 + .../gen/layouts/FloorPlan326-openable.json | 128 + .../rt1/gen/layouts/FloorPlan327-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan327-objects.json | 29 + .../gen/layouts/FloorPlan327-openable.json | 92 + .../rt1/gen/layouts/FloorPlan328-layout.npy | Bin 0 -> 1104 bytes .../rt1/gen/layouts/FloorPlan328-objects.json | 31 + .../gen/layouts/FloorPlan328-openable.json | 44 + .../rt1/gen/layouts/FloorPlan329-layout.npy | Bin 0 -> 1536 bytes .../rt1/gen/layouts/FloorPlan329-objects.json | 28 + .../gen/layouts/FloorPlan329-openable.json | 50 + .../rt1/gen/layouts/FloorPlan330-layout.npy | Bin 0 -> 2240 bytes .../rt1/gen/layouts/FloorPlan330-objects.json | 32 + .../gen/layouts/FloorPlan330-openable.json | 122 + .../rt1/gen/layouts/FloorPlan4-layout.npy | Bin 0 -> 1232 bytes .../rt1/gen/layouts/FloorPlan4-objects.json | 42 + .../rt1/gen/layouts/FloorPlan4-openable.json | 98 + .../rt1/gen/layouts/FloorPlan401-layout.npy | Bin 0 -> 1616 bytes .../rt1/gen/layouts/FloorPlan401-objects.json | 32 + .../gen/layouts/FloorPlan401-openable.json | 56 + .../rt1/gen/layouts/FloorPlan402-layout.npy | Bin 0 -> 1584 bytes .../rt1/gen/layouts/FloorPlan402-objects.json | 33 + .../gen/layouts/FloorPlan402-openable.json | 92 + .../rt1/gen/layouts/FloorPlan403-layout.npy | Bin 0 -> 1008 bytes .../rt1/gen/layouts/FloorPlan403-objects.json | 34 + .../gen/layouts/FloorPlan403-openable.json | 50 + .../rt1/gen/layouts/FloorPlan404-layout.npy | Bin 0 -> 1008 bytes .../rt1/gen/layouts/FloorPlan404-objects.json | 29 + .../gen/layouts/FloorPlan404-openable.json | 38 + .../rt1/gen/layouts/FloorPlan405-layout.npy | Bin 0 -> 576 bytes .../rt1/gen/layouts/FloorPlan405-objects.json | 28 + .../gen/layouts/FloorPlan405-openable.json | 56 + .../rt1/gen/layouts/FloorPlan406-layout.npy | Bin 0 -> 1664 bytes .../rt1/gen/layouts/FloorPlan406-objects.json | 28 + .../gen/layouts/FloorPlan406-openable.json | 26 + .../rt1/gen/layouts/FloorPlan407-layout.npy | Bin 0 -> 672 bytes .../rt1/gen/layouts/FloorPlan407-objects.json | 32 + .../gen/layouts/FloorPlan407-openable.json | 56 + .../rt1/gen/layouts/FloorPlan408-layout.npy | Bin 0 -> 704 bytes .../rt1/gen/layouts/FloorPlan408-objects.json | 28 + .../gen/layouts/FloorPlan408-openable.json | 62 + .../rt1/gen/layouts/FloorPlan409-layout.npy | Bin 0 -> 752 bytes .../rt1/gen/layouts/FloorPlan409-objects.json | 28 + .../gen/layouts/FloorPlan409-openable.json | 62 + .../rt1/gen/layouts/FloorPlan410-layout.npy | Bin 0 -> 1408 bytes .../rt1/gen/layouts/FloorPlan410-objects.json | 29 + .../gen/layouts/FloorPlan410-openable.json | 74 + .../rt1/gen/layouts/FloorPlan411-layout.npy | Bin 0 -> 1104 bytes .../rt1/gen/layouts/FloorPlan411-objects.json | 31 + .../gen/layouts/FloorPlan411-openable.json | 62 + .../rt1/gen/layouts/FloorPlan412-layout.npy | Bin 0 -> 784 bytes .../rt1/gen/layouts/FloorPlan412-objects.json | 29 + .../gen/layouts/FloorPlan412-openable.json | 50 + .../rt1/gen/layouts/FloorPlan413-layout.npy | Bin 0 -> 1216 bytes .../rt1/gen/layouts/FloorPlan413-objects.json | 32 + .../gen/layouts/FloorPlan413-openable.json | 92 + .../rt1/gen/layouts/FloorPlan414-layout.npy | Bin 0 -> 800 bytes .../rt1/gen/layouts/FloorPlan414-objects.json | 31 + .../gen/layouts/FloorPlan414-openable.json | 92 + .../rt1/gen/layouts/FloorPlan415-layout.npy | Bin 0 -> 880 bytes .../rt1/gen/layouts/FloorPlan415-objects.json | 31 + .../gen/layouts/FloorPlan415-openable.json | 68 + .../rt1/gen/layouts/FloorPlan416-layout.npy | Bin 0 -> 992 bytes .../rt1/gen/layouts/FloorPlan416-objects.json | 28 + .../gen/layouts/FloorPlan416-openable.json | 44 + .../rt1/gen/layouts/FloorPlan417-layout.npy | Bin 0 -> 1088 bytes .../rt1/gen/layouts/FloorPlan417-objects.json | 29 + .../gen/layouts/FloorPlan417-openable.json | 44 + .../rt1/gen/layouts/FloorPlan418-layout.npy | Bin 0 -> 864 bytes .../rt1/gen/layouts/FloorPlan418-objects.json | 29 + .../gen/layouts/FloorPlan418-openable.json | 44 + .../rt1/gen/layouts/FloorPlan419-layout.npy | Bin 0 -> 608 bytes .../rt1/gen/layouts/FloorPlan419-objects.json | 30 + .../gen/layouts/FloorPlan419-openable.json | 44 + .../rt1/gen/layouts/FloorPlan420-layout.npy | Bin 0 -> 560 bytes .../rt1/gen/layouts/FloorPlan420-objects.json | 29 + .../gen/layouts/FloorPlan420-openable.json | 32 + .../rt1/gen/layouts/FloorPlan421-layout.npy | Bin 0 -> 608 bytes .../rt1/gen/layouts/FloorPlan421-objects.json | 29 + .../gen/layouts/FloorPlan421-openable.json | 68 + .../rt1/gen/layouts/FloorPlan422-layout.npy | Bin 0 -> 656 bytes .../rt1/gen/layouts/FloorPlan422-objects.json | 33 + .../gen/layouts/FloorPlan422-openable.json | 86 + .../rt1/gen/layouts/FloorPlan423-layout.npy | Bin 0 -> 1008 bytes .../rt1/gen/layouts/FloorPlan423-objects.json | 32 + .../gen/layouts/FloorPlan423-openable.json | 86 + .../rt1/gen/layouts/FloorPlan424-layout.npy | Bin 0 -> 736 bytes .../rt1/gen/layouts/FloorPlan424-objects.json | 28 + .../gen/layouts/FloorPlan424-openable.json | 56 + .../rt1/gen/layouts/FloorPlan425-layout.npy | Bin 0 -> 512 bytes .../rt1/gen/layouts/FloorPlan425-objects.json | 30 + .../gen/layouts/FloorPlan425-openable.json | 56 + .../rt1/gen/layouts/FloorPlan426-layout.npy | Bin 0 -> 912 bytes .../rt1/gen/layouts/FloorPlan426-objects.json | 31 + .../gen/layouts/FloorPlan426-openable.json | 68 + .../rt1/gen/layouts/FloorPlan427-layout.npy | Bin 0 -> 992 bytes .../rt1/gen/layouts/FloorPlan427-objects.json | 32 + .../gen/layouts/FloorPlan427-openable.json | 80 + .../rt1/gen/layouts/FloorPlan428-layout.npy | Bin 0 -> 992 bytes .../rt1/gen/layouts/FloorPlan428-objects.json | 28 + .../gen/layouts/FloorPlan428-openable.json | 50 + .../rt1/gen/layouts/FloorPlan429-layout.npy | Bin 0 -> 1152 bytes .../rt1/gen/layouts/FloorPlan429-objects.json | 29 + .../gen/layouts/FloorPlan429-openable.json | 38 + .../rt1/gen/layouts/FloorPlan430-layout.npy | Bin 0 -> 1760 bytes .../rt1/gen/layouts/FloorPlan430-objects.json | 35 + .../gen/layouts/FloorPlan430-openable.json | 50 + .../rt1/gen/layouts/FloorPlan5-layout.npy | Bin 0 -> 1680 bytes .../rt1/gen/layouts/FloorPlan5-objects.json | 47 + .../rt1/gen/layouts/FloorPlan5-openable.json | 152 + .../rt1/gen/layouts/FloorPlan6-layout.npy | Bin 0 -> 2176 bytes .../rt1/gen/layouts/FloorPlan6-objects.json | 42 + .../rt1/gen/layouts/FloorPlan6-openable.json | 164 + .../rt1/gen/layouts/FloorPlan7-layout.npy | Bin 0 -> 4352 bytes .../rt1/gen/layouts/FloorPlan7-objects.json | 50 + .../rt1/gen/layouts/FloorPlan7-openable.json | 146 + .../rt1/gen/layouts/FloorPlan8-layout.npy | Bin 0 -> 2768 bytes .../rt1/gen/layouts/FloorPlan8-objects.json | 46 + .../rt1/gen/layouts/FloorPlan8-openable.json | 170 + .../rt1/gen/layouts/FloorPlan9-layout.npy | Bin 0 -> 1360 bytes .../rt1/gen/layouts/FloorPlan9-objects.json | 42 + .../rt1/gen/layouts/FloorPlan9-openable.json | 260 ++ .../layouts/precompute_layout_locations.py | 350 ++ .../main_models/rt1/gen/planner/__init__.py | 0 .../domains/PutTaskExtended_domain.pddl | 302 ++ .../rt1/gen/planner/ff_planner_handler.py | 252 ++ models/main_models/rt1/gen/planner/pddl.pdf | Bin 0 -> 196613 bytes .../rt1/gen/scripts/augment_trajectories.py | 312 ++ .../rt1/gen/scripts/generate_trajectories.py | 752 ++++ .../rt1/gen/scripts/replay_checks.py | 217 + models/main_models/rt1/gen/utils/__init__.py | 0 models/main_models/rt1/gen/utils/bb_util.py | 139 + .../rt1/gen/utils/dataset_management_util.py | 69 + models/main_models/rt1/gen/utils/game_util.py | 363 ++ .../main_models/rt1/gen/utils/image_util.py | 57 + models/main_models/rt1/gen/utils/py_util.py | 84 + .../main_models/rt1/gen/utils/replay_json.py | 52 + .../main_models/rt1/gen/utils/video_util.py | 11 + .../lanmp_dataloader/attribute_limits.json | 1 + .../rt1/lanmp_dataloader/rt1_dataloader.py | 800 ++++ .../rt1/lanmp_dataloader/scene_to_keys.json | 1 + models/main_models/rt1/main.py | 257 ++ models/main_models/rt1/main_ft.py | 387 ++ models/main_models/rt1/main_ft_eval.py | 279 ++ models/main_models/rt1/rollout_ai2thor.py | 366 ++ .../main_models/rt1/rt1_env/bin/Activate.ps1 | 241 ++ models/main_models/rt1/rt1_env/bin/activate | 66 + .../main_models/rt1/rt1_env/bin/activate.csh | 25 + .../main_models/rt1/rt1_env/bin/activate.fish | 64 + .../main_models/rt1/rt1_env/bin/ai2thor-xorg | 267 ++ .../rt1/rt1_env/bin/convert-caffe2-to-onnx | 10 + .../rt1/rt1_env/bin/convert-onnx-to-caffe2 | 10 + models/main_models/rt1/rt1_env/bin/f2py | 10 + models/main_models/rt1/rt1_env/bin/flask | 10 + .../rt1/rt1_env/bin/huggingface-cli | 10 + .../rt1/rt1_env/bin/imageio_download_bin | 10 + .../rt1/rt1_env/bin/imageio_remove_bin | 10 + .../rt1/rt1_env/bin/import_pb_to_tensorboard | 10 + models/main_models/rt1/rt1_env/bin/isympy | 10 + models/main_models/rt1/rt1_env/bin/jp.py | 54 + models/main_models/rt1/rt1_env/bin/lsm2bin | 10 + .../main_models/rt1/rt1_env/bin/markdown-it | 10 + .../main_models/rt1/rt1_env/bin/markdown_py | 10 + models/main_models/rt1/rt1_env/bin/normalizer | 10 + models/main_models/rt1/rt1_env/bin/pip | 10 + models/main_models/rt1/rt1_env/bin/pip3 | 10 + models/main_models/rt1/rt1_env/bin/pip3.9 | 10 + .../main_models/rt1/rt1_env/bin/portserver.py | 415 ++ .../main_models/rt1/rt1_env/bin/progressbar | 10 + models/main_models/rt1/rt1_env/bin/pygmentize | 10 + models/main_models/rt1/rt1_env/bin/python | 1 + models/main_models/rt1/rt1_env/bin/python3 | 1 + models/main_models/rt1/rt1_env/bin/python3.9 | 1 + models/main_models/rt1/rt1_env/bin/pythoni | 36 + models/main_models/rt1/rt1_env/bin/pythoni1 | 17 + .../main_models/rt1/rt1_env/bin/reverb_server | 10 + .../rt1/rt1_env/bin/saved_model_cli | 10 + .../main_models/rt1/rt1_env/bin/tensorboard | 10 + .../main_models/rt1/rt1_env/bin/tf_upgrade_v2 | 10 + models/main_models/rt1/rt1_env/bin/tfds | 10 + .../rt1/rt1_env/bin/tflite_convert | 10 + .../main_models/rt1/rt1_env/bin/tiff2fsspec | 10 + .../main_models/rt1/rt1_env/bin/tiffcomment | 10 + models/main_models/rt1/rt1_env/bin/tifffile | 10 + models/main_models/rt1/rt1_env/bin/toco | 10 + .../rt1/rt1_env/bin/toco_from_protos | 10 + models/main_models/rt1/rt1_env/bin/torchrun | 10 + models/main_models/rt1/rt1_env/bin/tqdm | 10 + .../rt1/rt1_env/bin/transformers-cli | 10 + models/main_models/rt1/rt1_env/bin/tree-cli | 10 + models/main_models/rt1/rt1_env/bin/wandb | 10 + models/main_models/rt1/rt1_env/bin/wb | 10 + models/main_models/rt1/rt1_env/bin/wheel | 10 + .../site/python3.9/dm-reverb/checkpoint.proto | 77 + .../site/python3.9/dm-reverb/patterns.proto | 123 + .../python3.9/dm-reverb/reverb_config.proto | 10 + .../site/python3.9/dm-reverb/schema.proto | 289 ++ models/main_models/rt1/rt1_env/lib64 | 1 + models/main_models/rt1/rt1_env/pyvenv.cfg | 3 + .../rt1/rt1_env/share/man/man1/isympy.1 | 188 + .../main_models/rt1/rt1_pytorch/__init__.py | 0 .../rt1_pytorch/film_efficientnet/__init__.py | 0 .../film_conditioning_layer.py | 38 + .../film_efficientnet/film_efficientnet.py | 446 ++ .../main_models/rt1/rt1_pytorch/rt1_model.py | 217 + .../main_models/rt1/rt1_pytorch/rt1_policy.py | 234 + .../rt1/rt1_pytorch/tokenizers/__init__.py | 0 .../tokenizers/action_tokenizer.py | 184 + .../rt1_pytorch/tokenizers/image_tokenizer.py | 77 + .../rt1_pytorch/tokenizers/token_learner.py | 89 + models/main_models/rt1/setup.py | 44 + .../rt1/tests/action_tokenizer_test.py | 166 + .../rt1/tests/film_conditioning_layer_test.py | 27 + .../rt1/tests/film_efficientnet_test.py | 57 + .../rt1/tests/image_tokenizer_test.py | 53 + .../main_models/rt1/tests/rt1_model_test.py | 54 + .../main_models/rt1/tests/rt1_policy_test.py | 64 + .../rt1/tests/token_learner_test.py | 40 + models/main_models/rt1/vd4rl_main.py | 389 ++ 509 files changed, 61499 insertions(+) create mode 100644 models/main_models/rt1/LICENSE create mode 100644 models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb create mode 100644 models/main_models/rt1/README.md create mode 100644 models/main_models/rt1/ai2thor_env.py create mode 100644 models/main_models/rt1/data.py create mode 100644 models/main_models/rt1/figures/rt1.png create mode 100644 models/main_models/rt1/gen/README.md create mode 100644 models/main_models/rt1/gen/__init__.py create mode 100644 models/main_models/rt1/gen/agents/agent_base.py create mode 100644 models/main_models/rt1/gen/agents/deterministic_planner_agent.py create mode 100644 models/main_models/rt1/gen/agents/plan_agent.py create mode 100644 models/main_models/rt1/gen/agents/semantic_map_planner_agent.py create mode 100644 models/main_models/rt1/gen/constants.py create mode 100644 models/main_models/rt1/gen/ff_planner/README.md create mode 100644 models/main_models/rt1/gen/ff_planner/expressions.c create mode 100644 models/main_models/rt1/gen/ff_planner/expressions.h create mode 100644 models/main_models/rt1/gen/ff_planner/ff.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_easy.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_easy.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_final.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_final.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_hard.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_hard.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_pre.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_pre.h create mode 100644 models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l create mode 100644 models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l create mode 100644 models/main_models/rt1/gen/ff_planner/main.c create mode 100644 models/main_models/rt1/gen/ff_planner/makefile create mode 100644 models/main_models/rt1/gen/ff_planner/memory.c create mode 100644 models/main_models/rt1/gen/ff_planner/memory.h create mode 100644 models/main_models/rt1/gen/ff_planner/output.c create mode 100644 models/main_models/rt1/gen/ff_planner/output.h create mode 100644 models/main_models/rt1/gen/ff_planner/parse.c create mode 100644 models/main_models/rt1/gen/ff_planner/parse.h create mode 100644 models/main_models/rt1/gen/ff_planner/relax.c create mode 100644 models/main_models/rt1/gen/ff_planner/relax.h create mode 100755 models/main_models/rt1/gen/ff_planner/run_sample.sh create mode 100644 models/main_models/rt1/gen/ff_planner/samples/PutTask_domain.pddl create mode 100644 models/main_models/rt1/gen/ff_planner/samples/problem_0_0.pddl create mode 100644 models/main_models/rt1/gen/ff_planner/scan-fct_pddl.y create mode 100644 models/main_models/rt1/gen/ff_planner/scan-ops_pddl.y create mode 100644 models/main_models/rt1/gen/ff_planner/search.c create mode 100644 models/main_models/rt1/gen/ff_planner/search.h create mode 100644 models/main_models/rt1/gen/game_states/__init__.py create mode 100644 models/main_models/rt1/gen/game_states/game_state_base.py create mode 100644 models/main_models/rt1/gen/game_states/planned_game_state.py create mode 100644 models/main_models/rt1/gen/game_states/task_game_state.py create mode 100644 models/main_models/rt1/gen/game_states/task_game_state_full_knowledge.py create mode 100644 models/main_models/rt1/gen/goal_library.py create mode 100644 models/main_models/rt1/gen/graph/__init__.py create mode 100644 models/main_models/rt1/gen/graph/graph_obj.py create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-openable.json create mode 100644 models/main_models/rt1/gen/layouts/precompute_layout_locations.py create mode 100644 models/main_models/rt1/gen/planner/__init__.py create mode 100644 models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl create mode 100644 models/main_models/rt1/gen/planner/ff_planner_handler.py create mode 100644 models/main_models/rt1/gen/planner/pddl.pdf create mode 100644 models/main_models/rt1/gen/scripts/augment_trajectories.py create mode 100644 models/main_models/rt1/gen/scripts/generate_trajectories.py create mode 100644 models/main_models/rt1/gen/scripts/replay_checks.py create mode 100644 models/main_models/rt1/gen/utils/__init__.py create mode 100644 models/main_models/rt1/gen/utils/bb_util.py create mode 100644 models/main_models/rt1/gen/utils/dataset_management_util.py create mode 100644 models/main_models/rt1/gen/utils/game_util.py create mode 100644 models/main_models/rt1/gen/utils/image_util.py create mode 100644 models/main_models/rt1/gen/utils/py_util.py create mode 100644 models/main_models/rt1/gen/utils/replay_json.py create mode 100644 models/main_models/rt1/gen/utils/video_util.py create mode 100644 models/main_models/rt1/lanmp_dataloader/attribute_limits.json create mode 100644 models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py create mode 100644 models/main_models/rt1/lanmp_dataloader/scene_to_keys.json create mode 100644 models/main_models/rt1/main.py create mode 100644 models/main_models/rt1/main_ft.py create mode 100644 models/main_models/rt1/main_ft_eval.py create mode 100644 models/main_models/rt1/rollout_ai2thor.py create mode 100644 models/main_models/rt1/rt1_env/bin/Activate.ps1 create mode 100644 models/main_models/rt1/rt1_env/bin/activate create mode 100644 models/main_models/rt1/rt1_env/bin/activate.csh create mode 100644 models/main_models/rt1/rt1_env/bin/activate.fish create mode 100755 models/main_models/rt1/rt1_env/bin/ai2thor-xorg create mode 100755 models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx create mode 100755 models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 create mode 100755 models/main_models/rt1/rt1_env/bin/f2py create mode 100755 models/main_models/rt1/rt1_env/bin/flask create mode 100755 models/main_models/rt1/rt1_env/bin/huggingface-cli create mode 100755 models/main_models/rt1/rt1_env/bin/imageio_download_bin create mode 100755 models/main_models/rt1/rt1_env/bin/imageio_remove_bin create mode 100755 models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard create mode 100755 models/main_models/rt1/rt1_env/bin/isympy create mode 100755 models/main_models/rt1/rt1_env/bin/jp.py create mode 100755 models/main_models/rt1/rt1_env/bin/lsm2bin create mode 100755 models/main_models/rt1/rt1_env/bin/markdown-it create mode 100755 models/main_models/rt1/rt1_env/bin/markdown_py create mode 100755 models/main_models/rt1/rt1_env/bin/normalizer create mode 100755 models/main_models/rt1/rt1_env/bin/pip create mode 100755 models/main_models/rt1/rt1_env/bin/pip3 create mode 100755 models/main_models/rt1/rt1_env/bin/pip3.9 create mode 100755 models/main_models/rt1/rt1_env/bin/portserver.py create mode 100755 models/main_models/rt1/rt1_env/bin/progressbar create mode 100755 models/main_models/rt1/rt1_env/bin/pygmentize create mode 120000 models/main_models/rt1/rt1_env/bin/python create mode 120000 models/main_models/rt1/rt1_env/bin/python3 create mode 120000 models/main_models/rt1/rt1_env/bin/python3.9 create mode 100755 models/main_models/rt1/rt1_env/bin/pythoni create mode 100755 models/main_models/rt1/rt1_env/bin/pythoni1 create mode 100755 models/main_models/rt1/rt1_env/bin/reverb_server create mode 100755 models/main_models/rt1/rt1_env/bin/saved_model_cli create mode 100755 models/main_models/rt1/rt1_env/bin/tensorboard create mode 100755 models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 create mode 100755 models/main_models/rt1/rt1_env/bin/tfds create mode 100755 models/main_models/rt1/rt1_env/bin/tflite_convert create mode 100755 models/main_models/rt1/rt1_env/bin/tiff2fsspec create mode 100755 models/main_models/rt1/rt1_env/bin/tiffcomment create mode 100755 models/main_models/rt1/rt1_env/bin/tifffile create mode 100755 models/main_models/rt1/rt1_env/bin/toco create mode 100755 models/main_models/rt1/rt1_env/bin/toco_from_protos create mode 100755 models/main_models/rt1/rt1_env/bin/torchrun create mode 100755 models/main_models/rt1/rt1_env/bin/tqdm create mode 100755 models/main_models/rt1/rt1_env/bin/transformers-cli create mode 100755 models/main_models/rt1/rt1_env/bin/tree-cli create mode 100755 models/main_models/rt1/rt1_env/bin/wandb create mode 100755 models/main_models/rt1/rt1_env/bin/wb create mode 100755 models/main_models/rt1/rt1_env/bin/wheel create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto create mode 120000 models/main_models/rt1/rt1_env/lib64 create mode 100644 models/main_models/rt1/rt1_env/pyvenv.cfg create mode 100644 models/main_models/rt1/rt1_env/share/man/man1/isympy.1 create mode 100644 models/main_models/rt1/rt1_pytorch/__init__.py create mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py create mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py create mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py create mode 100644 models/main_models/rt1/rt1_pytorch/rt1_model.py create mode 100644 models/main_models/rt1/rt1_pytorch/rt1_policy.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py create mode 100644 models/main_models/rt1/setup.py create mode 100644 models/main_models/rt1/tests/action_tokenizer_test.py create mode 100644 models/main_models/rt1/tests/film_conditioning_layer_test.py create mode 100644 models/main_models/rt1/tests/film_efficientnet_test.py create mode 100644 models/main_models/rt1/tests/image_tokenizer_test.py create mode 100644 models/main_models/rt1/tests/rt1_model_test.py create mode 100644 models/main_models/rt1/tests/rt1_policy_test.py create mode 100644 models/main_models/rt1/tests/token_learner_test.py create mode 100644 models/main_models/rt1/vd4rl_main.py diff --git a/models/main_models/rt1/LICENSE b/models/main_models/rt1/LICENSE new file mode 100644 index 000000000..272afdf8f --- /dev/null +++ b/models/main_models/rt1/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Phil Wang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb b/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb new file mode 100644 index 000000000..2b2235541 --- /dev/null +++ b/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb @@ -0,0 +1,2303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "EnWCKLGGaf-d" + }, + "source": [ + "# Open X-Embodiment Datasets\n", + "\n", + "![](https://robotics-transformer-x.github.io/img/overview.png)\n", + "\n", + "This colab helps you **visualize** the datasets in the Open X-Embodiment Dataset, explains how to **download** them and how to **train** with them.\n", + "\n", + "Table of Content:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "toc", + "id": "UyiiBjzmaIQu" + }, + "source": [ + ">[Open X-Embodiment Datasets](#scrollTo=EnWCKLGGaf-d)\n", + "\n", + ">[Visualize Datasets](#scrollTo=29c7oLlJbWwF)\n", + "\n", + ">[Download Datasets](#scrollTo=-WHN-2OrKqGo)\n", + "\n", + ">[Data Loader Example](#scrollTo=IyccDsRqwtMz)\n", + "\n", + ">[Interleave Multiple Datasets](#scrollTo=ekmsGRAnw3Bp)\n", + "\n", + ">[Example Dataloader to produce trajectories](#scrollTo=aew258oUbamg)\n", + "\n", + ">>[Demonstration of transformation from an episode to a trajectory](#scrollTo=BK4RRYkbLN5B)\n", + "\n", + ">>[Combination of multiple datasets](#scrollTo=Oy89HzymQyAq)\n", + "\n", + ">[Available datasets:](#scrollTo=N2Efw2aHVfSX)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "29c7oLlJbWwF" + }, + "source": [ + "# Visualize Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "l7OogZYi7qwT" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow_datasets as tfds\n", + "from PIL import Image\n", + "from IPython import display\n", + "\n", + "DATASETS = [\n", + " \"fractal20220817_data\",\n", + " \"kuka\",\n", + " \"bridge\",\n", + " \"taco_play\",\n", + " \"jaco_play\",\n", + " \"berkeley_cable_routing\",\n", + " \"roboturk\",\n", + " \"nyu_door_opening_surprising_effectiveness\",\n", + " \"viola\",\n", + " \"berkeley_autolab_ur5\",\n", + " \"toto\",\n", + " \"language_table\",\n", + " \"columbia_cairlab_pusht_real\",\n", + " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", + " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", + " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", + " \"austin_buds_dataset_converted_externally_to_rlds\",\n", + " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", + " \"maniskill_dataset_converted_externally_to_rlds\",\n", + " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", + " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", + " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", + " \"bc_z\",\n", + " \"usc_cloth_sim_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", + " \"utokyo_saytap_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", + " \"robo_net\",\n", + " \"berkeley_mvp_converted_externally_to_rlds\",\n", + " \"berkeley_rpt_converted_externally_to_rlds\",\n", + " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", + " \"stanford_mask_vit_converted_externally_to_rlds\",\n", + " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", + " \"dlr_sara_pour_converted_externally_to_rlds\",\n", + " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", + " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", + " \"asu_table_top_converted_externally_to_rlds\",\n", + " \"stanford_robocook_converted_externally_to_rlds\",\n", + " \"eth_agent_affordances\",\n", + " \"imperialcollege_sawyer_wrist_cam\",\n", + " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", + " \"uiuc_d3field\",\n", + " \"utaustin_mutex\",\n", + " \"berkeley_fanuc_manipulation\",\n", + " \"cmu_play_fusion\",\n", + " \"cmu_stretch\",\n", + " \"berkeley_gnm_recon\",\n", + " \"berkeley_gnm_cory_hall\",\n", + " \"berkeley_gnm_sac_son\",\n", + "]\n", + "\n", + "\n", + "def dataset2path(name):\n", + " if name == \"robo_net\":\n", + " version = \"1.0.0\"\n", + " elif name == \"language_table\":\n", + " version = \"0.0.1\"\n", + " else:\n", + " version = \"0.1.0\"\n", + " return f\"gs://gresearch/robotics/{name}/{version}\"\n", + "\n", + "\n", + "def as_gif(images, path=\"temp.gif\"):\n", + " # Render the images as the gif:\n", + " images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0)\n", + " gif_bytes = open(path, \"rb\").read()\n", + " return gif_bytes" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 497 + }, + "id": "Gcw4eHmxbZjx", + "outputId": "a2cc46f1-5eec-41b8-fa23-6b4797b1e1e1" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# choose the dataset path in the dropdown on the right and rerun this cell\n", + "# to see multiple samples\n", + "\n", + "dataset = \"fractal20220817_data\" # @param ['fractal20220817_data', 'kuka', 'bridge', 'taco_play', 'jaco_play', 'berkeley_cable_routing', 'roboturk', 'nyu_door_opening_surprising_effectiveness', 'viola', 'berkeley_autolab_ur5', 'toto', 'language_table', 'columbia_cairlab_pusht_real', 'stanford_kuka_multimodal_dataset_converted_externally_to_rlds', 'nyu_rot_dataset_converted_externally_to_rlds', 'stanford_hydra_dataset_converted_externally_to_rlds', 'austin_buds_dataset_converted_externally_to_rlds', 'nyu_franka_play_dataset_converted_externally_to_rlds', 'maniskill_dataset_converted_externally_to_rlds', 'furniture_bench_dataset_converted_externally_to_rlds', 'cmu_franka_exploration_dataset_converted_externally_to_rlds', 'ucsd_kitchen_dataset_converted_externally_to_rlds', 'ucsd_pick_and_place_dataset_converted_externally_to_rlds', 'austin_sailor_dataset_converted_externally_to_rlds', 'austin_sirius_dataset_converted_externally_to_rlds', 'bc_z', 'usc_cloth_sim_converted_externally_to_rlds', 'utokyo_pr2_opening_fridge_converted_externally_to_rlds', 'utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds', 'utokyo_saytap_converted_externally_to_rlds', 'utokyo_xarm_pick_and_place_converted_externally_to_rlds', 'utokyo_xarm_bimanual_converted_externally_to_rlds', 'robo_net', 'berkeley_mvp_converted_externally_to_rlds', 'berkeley_rpt_converted_externally_to_rlds', 'kaist_nonprehensile_converted_externally_to_rlds', 'stanford_mask_vit_converted_externally_to_rlds', 'tokyo_u_lsmo_converted_externally_to_rlds', 'dlr_sara_pour_converted_externally_to_rlds', 'dlr_sara_grid_clamp_converted_externally_to_rlds', 'dlr_edan_shared_control_converted_externally_to_rlds', 'asu_table_top_converted_externally_to_rlds', 'stanford_robocook_converted_externally_to_rlds', 'eth_agent_affordances', 'imperialcollege_sawyer_wrist_cam', 'iamlab_cmu_pickup_insert_converted_externally_to_rlds', 'uiuc_d3field', 'utaustin_mutex', 'berkeley_fanuc_manipulation', 'cmu_food_manipulation', 'cmu_play_fusion', 'cmu_stretch', 'berkeley_gnm_recon', 'berkeley_gnm_cory_hall', 'berkeley_gnm_sac_son']\n", + "display_key = \"image\"\n", + "\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "if display_key not in b.info.features[\"steps\"][\"observation\"]:\n", + " raise ValueError(\n", + " f\"The key {display_key} was not found in this dataset.\\n\"\n", + " + \"Please choose a different image key to display for this dataset.\\n\"\n", + " + \"Here is the observation spec:\\n\"\n", + " + str(b.info.features[\"steps\"][\"observation\"])\n", + " )\n", + "\n", + "ds = b.as_dataset(split=\"train[:10]\").shuffle(10) # take only first 10 episodes\n", + "episode = next(iter(ds))\n", + "images = [step[\"observation\"][display_key] for step in episode[\"steps\"]]\n", + "images = [Image.fromarray(image.numpy()) for image in images]\n", + "display.Image(as_gif(images))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YrD4_8P9JxBw", + "outputId": "6c4bcf5f-b738-472c-d084-9c87f56962c8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('action', {'base_displacement_vector': , 'base_displacement_vertical_rotation': , 'gripper_closedness_action': , 'rotation_delta': , 'terminate_episode': , 'world_vector': })\n", + "('is_first', )\n", + "('is_last', )\n", + "('is_terminal', )\n", + "('observation', {'base_pose_tool_reached': , 'gripper_closed': , 'gripper_closedness_commanded': , 'height_to_bottom': , 'image': , 'natural_language_embedding': , 'natural_language_instruction': , 'orientation_box': , 'orientation_start': , 'robot_orientation_positions_box': , 'rotation_delta_to_go': , 'src_rotation': , 'vector_to_go': , 'workspace_bounds': })\n", + "('reward', )\n" + ] + } + ], + "source": [ + "# other elements of the episode step --> this may vary for each dataset\n", + "for elem in next(iter(episode[\"steps\"])).items():\n", + " print(elem)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-WHN-2OrKqGo" + }, + "source": [ + "# Download Datasets\n", + "\n", + "All datasets can be downloaded simply via `tfds.load()`.\n", + "Below we provide a script that downloads all datasets into `~/tensorflow_datasets` on your local machine. Simply copy the code and run it on your local machine to download the full dataset (XXX TB).\n", + "\n", + "If you want to filter the dataset before download, please refer to\n", + "[this Google Sheet](https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit?usp=sharing). It allows you\n", + "to filter the data by attributes like robot model, number of cameras, type of tasks etc. You can then download only the filtered datasets by pasting the\n", + "dataset list from the spreadsheet into the code below.\n", + "\n", + "The download code will automatically skip any datasets you have previously downloaded." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 617 + }, + "id": "wcsQuLjY7c0o", + "outputId": "43f99670-13d6-4ecc-f58f-263960681bed" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: tfds-nightly in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (4.9.3.dev202310060044)\n", + "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.4.0)\n", + "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.5.0)\n", + "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (8.1.7)\n", + "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.1.8)\n", + "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (1.5.2)\n", + "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.25.0)\n", + "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3)\n", + "Requirement already satisfied: protobuf>=3.20 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (3.20.3)\n", + "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (5.9.0)\n", + "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.29.0)\n", + "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.0)\n", + "Requirement already satisfied: termcolor in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3.0)\n", + "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.10.2)\n", + "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (4.65.0)\n", + "Requirement already satisfied: wrapt in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.1)\n", + "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (2023.9.2)\n", + "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (6.1.1)\n", + "Requirement already satisfied: typing_extensions in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (4.6.3)\n", + "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (3.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2023.5.7)\n", + "Requirement already satisfied: six in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from promise->tfds-nightly) (1.16.0)\n", + "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tfds-nightly) (1.61.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install tfds-nightly # to get most up-to-date registered datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "XtNplr0AP-ZH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading 2 datasets to ~/tensorflow_datasets.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:07<00:00, 3.67s/it]\n" + ] + } + ], + "source": [ + "import tensorflow_datasets as tfds\n", + "import tqdm\n", + "\n", + "# optionally replace the DATASET_NAMES below with the list of filtered datasets from the google sheet\n", + "DATASET_NAMES = [\n", + " \"fractal20220817_data\",\n", + " \"kuka\",\n", + " \"bridge\",\n", + " \"taco_play\",\n", + " \"jaco_play\",\n", + " \"berkeley_cable_routing\",\n", + " \"roboturk\",\n", + " \"nyu_door_opening_surprising_effectiveness\",\n", + " \"viola\",\n", + " \"berkeley_autolab_ur5\",\n", + " \"toto\",\n", + " \"language_table\",\n", + " \"columbia_cairlab_pusht_real\",\n", + " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", + " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", + " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", + " \"austin_buds_dataset_converted_externally_to_rlds\",\n", + " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", + " \"maniskill_dataset_converted_externally_to_rlds\",\n", + " \"furniture_bench_dataset_converted_externally_to_rlds\",\n", + " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", + " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", + " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", + " \"bc_z\",\n", + " \"usc_cloth_sim_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", + " \"utokyo_saytap_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", + " \"robo_net\",\n", + " \"berkeley_mvp_converted_externally_to_rlds\",\n", + " \"berkeley_rpt_converted_externally_to_rlds\",\n", + " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", + " \"stanford_mask_vit_converted_externally_to_rlds\",\n", + " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", + " \"dlr_sara_pour_converted_externally_to_rlds\",\n", + " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", + " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", + " \"asu_table_top_converted_externally_to_rlds\",\n", + " \"stanford_robocook_converted_externally_to_rlds\",\n", + " \"eth_agent_affordances\",\n", + " \"imperialcollege_sawyer_wrist_cam\",\n", + " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", + " \"uiuc_d3field\",\n", + " \"utaustin_mutex\",\n", + " \"berkeley_fanuc_manipulation\",\n", + " \"cmu_food_manipulation\",\n", + " \"cmu_play_fusion\",\n", + " \"cmu_stretch\",\n", + " \"berkeley_gnm_recon\",\n", + " \"berkeley_gnm_cory_hall\",\n", + " \"berkeley_gnm_sac_son\",\n", + "]\n", + "DATASET_NAMES = [\"fractal20220817_data\", \"bc_z\"]\n", + "DOWNLOAD_DIR = \"~/tensorflow_datasets\"\n", + "\n", + "print(f\"Downloading {len(DATASET_NAMES)} datasets to {DOWNLOAD_DIR}.\")\n", + "for dataset_name in tqdm.tqdm(DATASET_NAMES):\n", + " b = tfds.builder_from_directory(builder_dir=dataset2path(dataset_name))\n", + " b.download_and_prepare(download_dir=DOWNLOAD_DIR)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IyccDsRqwtMz" + }, + "source": [ + "# Data Loader Example\n", + "\n", + "Below, we demonstrate a simple example of how to load the dataset into training batches, where each sample in the batch only contains one step." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "X17VECdRwzka" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow_datasets as tfds\n", + "\n", + "# load raw dataset --> replace this with tfds.load() on your\n", + "# local machine!\n", + "dataset = \"fractal20220817_data\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds = b.as_dataset(split=\"train[:10]\")\n", + "\n", + "\n", + "def episode2steps(episode):\n", + " return episode[\"steps\"]\n", + "\n", + "\n", + "def step_map_fn(step):\n", + " return {\n", + " \"observation\": {\n", + " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", + " },\n", + " \"action\": tf.concat(\n", + " [\n", + " step[\"action\"][\"world_vector\"],\n", + " step[\"action\"][\"rotation_delta\"],\n", + " step[\"action\"][\"gripper_closedness_action\"],\n", + " ],\n", + " axis=-1,\n", + " ),\n", + " }\n", + "\n", + "\n", + "# convert RLDS episode dataset to individual steps & reformat\n", + "ds = ds.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", + "ds = ds.map(step_map_fn, num_parallel_calls=tf.data.AUTOTUNE)\n", + "\n", + "# shuffle, repeat, pre-fetch, batch\n", + "ds = ds.cache() # optionally keep full dataset in memory\n", + "ds = ds.shuffle(100) # set shuffle buffer size\n", + "ds = ds.repeat() # ensure that data never runs out" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t0uJH3X6w1LZ", + "outputId": "a42005e8-1072-4203-e6ba-b56784971175" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0it [00:00, ?it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "10000it [00:05, 1955.09it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "for i, batch in tqdm.tqdm(enumerate(ds.prefetch(3).batch(4).as_numpy_iterator())):\n", + " # here you would add your Jax / PyTorch training code\n", + " if i == 10000:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ekmsGRAnw3Bp" + }, + "source": [ + "# Interleave Multiple Datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "CslwEuBZwmLP" + }, + "outputs": [], + "source": [ + "# Load second dataset --> replace this with tfds.load() on your\n", + "# local machine!\n", + "dataset = \"bc_z\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds2 = b.as_dataset(split=\"train[:10]\")\n", + "\n", + "\n", + "def step_map_fn_mutex(step):\n", + " # reformat to align specs of both datasets\n", + " return {\n", + " \"observation\": {\n", + " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", + " },\n", + " \"action\": tf.random.uniform(shape=(7,), dtype=tf.float32, name=None),\n", + " }\n", + "\n", + "\n", + "ds2 = ds2.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", + "ds2 = ds2.map(step_map_fn_mutex, num_parallel_calls=tf.data.AUTOTUNE)\n", + "\n", + "# shuffle, repeat, pre-fetch, batch\n", + "ds2 = ds2.cache() # optionally keep full dataset in memory\n", + "ds2 = ds2.shuffle(100) # set shuffle buffer size\n", + "ds2 = ds2.repeat() # ensure that data never runs out" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "G2hcCJd8w6-D" + }, + "outputs": [], + "source": [ + "# interleave datasets w/ equal sampling weight\n", + "ds_combined = tf.data.Dataset.sample_from_datasets([ds, ds2], [0.5, 0.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hEnVFP9nw8iI", + "outputId": "68567be3-9c3b-46c2-d569-f999c900f03c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "10000it [00:06, 1546.22it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "for i, batch in tqdm.tqdm(\n", + " enumerate(ds_combined.prefetch(3).batch(4).as_numpy_iterator())\n", + "):\n", + " # here you would add your Jax / PyTorch training code\n", + " if i == 10000:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aew258oUbamg" + }, + "source": [ + "# Example Dataloader to produce trajectories\n", + "\n", + "When training transformers, we usually use trajectories of fix-length as input into the transformers. This is to enable the transformer to condition on a fixed window of history when predicting actions.\n", + "\n", + "Below we demonstrate how one can load the TFDS datasets, transform the episodes\n", + "into fixed-length \"trajectories\" and mix multiple datasets by aligning their specs." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "YU0qKdrp7oBT" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: rlds[tensorflow] in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (0.1.8)\n", + "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.4.0)\n", + "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.25.0)\n", + "Requirement already satisfied: tensorflow in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: tensorflow-datasets in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (4.9.3)\n", + "Requirement already satisfied: dm-reverb in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (0.13.0)\n", + "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (0.1.8)\n", + "Requirement already satisfied: portpicker in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (1.6.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=23.5.26 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.5.26)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.5.4)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", + "Requirement already satisfied: h5py>=2.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.10.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (16.0.6)\n", + "Requirement already satisfied: ml-dtypes==0.2.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.3.0)\n", + "Requirement already satisfied: packaging in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.0)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.20.3)\n", + "Requirement already satisfied: setuptools in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (67.8.0)\n", + "Requirement already satisfied: six>=1.12.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.16.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.3.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (4.6.3)\n", + "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.14.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.34.0)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.59.2)\n", + "Requirement already satisfied: tensorboard<2.15,>=2.14 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.1)\n", + "Requirement already satisfied: tensorflow-estimator<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: keras<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.5.0)\n", + "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (8.1.7)\n", + "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (1.5.2)\n", + "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.3)\n", + "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (5.9.0)\n", + "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.29.0)\n", + "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (1.14.0)\n", + "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.10.2)\n", + "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (4.65.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow->rlds[tensorflow]) (0.38.4)\n", + "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (2023.9.2)\n", + "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (6.1.1)\n", + "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (3.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2023.5.7)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.23.4)\n", + "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.0.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.5.1)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.0.1)\n", + "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tensorflow-datasets->rlds[tensorflow]) (1.61.0)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (5.3.2)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.3.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (4.9)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.3.1)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.1.1)\n", + "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.5.0)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.2.2)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install rlds[tensorflow]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "N3b5BEt1JvQJ" + }, + "outputs": [], + "source": [ + "from typing import Any, Dict, Union, NamedTuple\n", + "\n", + "import numpy as np\n", + "import tensorflow_datasets as tfds\n", + "import rlds\n", + "import reverb\n", + "from rlds import transformations\n", + "import tensorflow_datasets as tfds\n", + "import tree\n", + "\n", + "import abc\n", + "import dataclasses\n", + "from typing import Dict, Optional\n", + "\n", + "from rlds import rlds_types\n", + "import tensorflow as tf\n", + "from PIL import Image\n", + "from IPython import display" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "cellView": "form", + "id": "Dgf1OxIhJwib" + }, + "outputs": [], + "source": [ + "# @title Transformation definitions\n", + "\n", + "\n", + "def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec:\n", + " \"\"\"Converts a tfds Feature into a TensorSpec.\"\"\"\n", + "\n", + " def _get_feature_spec(nested_feature: tfds.features.FeatureConnector):\n", + " if isinstance(nested_feature, tf.DType):\n", + " return tf.TensorSpec(shape=(), dtype=nested_feature)\n", + " else:\n", + " return nested_feature.get_tensor_spec()\n", + "\n", + " # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to\n", + " # make sure we deal with the nested structure.\n", + " return tf.nest.map_structure(_get_feature_spec, feature)\n", + "\n", + "\n", + "def _encoded_feature(\n", + " feature: Optional[tfds.features.FeatureConnector],\n", + " image_encoding: Optional[str],\n", + " tensor_encoding: Optional[tfds.features.Encoding],\n", + "):\n", + " \"\"\"Adds encoding to Images and/or Tensors.\"\"\"\n", + "\n", + " def _apply_encoding(\n", + " feature: tfds.features.FeatureConnector,\n", + " image_encoding: Optional[str],\n", + " tensor_encoding: Optional[tfds.features.Encoding],\n", + " ):\n", + " if image_encoding and isinstance(feature, tfds.features.Image):\n", + " return tfds.features.Image(\n", + " shape=feature.shape,\n", + " dtype=feature.dtype,\n", + " use_colormap=feature.use_colormap,\n", + " encoding_format=image_encoding,\n", + " )\n", + " if (\n", + " tensor_encoding\n", + " and isinstance(feature, tfds.features.Tensor)\n", + " and feature.dtype != tf.string\n", + " ):\n", + " return tfds.features.Tensor(\n", + " shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding\n", + " )\n", + " return feature\n", + "\n", + " if not feature:\n", + " return None\n", + " return tf.nest.map_structure(\n", + " lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature\n", + " )\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class RLDSSpec(metaclass=abc.ABCMeta):\n", + " \"\"\"Specification of an RLDS Dataset.\n", + "\n", + " It is used to hold a spec that can be converted into a TFDS DatasetInfo or\n", + " a `tf.data.Dataset` spec.\n", + " \"\"\"\n", + "\n", + " observation_info: Optional[tfds.features.FeatureConnector] = None\n", + " action_info: Optional[tfds.features.FeatureConnector] = None\n", + " reward_info: Optional[tfds.features.FeatureConnector] = None\n", + " discount_info: Optional[tfds.features.FeatureConnector] = None\n", + " step_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", + " episode_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", + "\n", + " def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", + " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", + " step = {}\n", + " if self.observation_info:\n", + " step[rlds_types.OBSERVATION] = _features_to_tensor_spec(\n", + " self.observation_info\n", + " )\n", + " if self.action_info:\n", + " step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info)\n", + " if self.discount_info:\n", + " step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info)\n", + " if self.reward_info:\n", + " step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info)\n", + " if self.step_metadata_info:\n", + " for k, v in self.step_metadata_info.items():\n", + " step[k] = _features_to_tensor_spec(v)\n", + "\n", + " step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool)\n", + " step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool)\n", + " step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool)\n", + " return step\n", + "\n", + " def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", + " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", + " episode = {}\n", + " episode[rlds_types.STEPS] = tf.data.DatasetSpec(\n", + " element_spec=self.step_tensor_spec()\n", + " )\n", + " if self.episode_metadata_info:\n", + " for k, v in self.episode_metadata_info.items():\n", + " episode[k] = _features_to_tensor_spec(v)\n", + " return episode\n", + "\n", + " def to_dataset_config(\n", + " self,\n", + " name: str,\n", + " image_encoding: Optional[str] = None,\n", + " tensor_encoding: Optional[tfds.features.Encoding] = None,\n", + " citation: Optional[str] = None,\n", + " homepage: Optional[str] = None,\n", + " description: Optional[str] = None,\n", + " overall_description: Optional[str] = None,\n", + " ) -> tfds.rlds.rlds_base.DatasetConfig:\n", + " \"\"\"Obtains the DatasetConfig for TFDS from the Spec.\"\"\"\n", + " return tfds.rlds.rlds_base.DatasetConfig(\n", + " name=name,\n", + " description=description,\n", + " overall_description=overall_description,\n", + " homepage=homepage,\n", + " citation=citation,\n", + " observation_info=_encoded_feature(\n", + " self.observation_info, image_encoding, tensor_encoding\n", + " ),\n", + " action_info=_encoded_feature(\n", + " self.action_info, image_encoding, tensor_encoding\n", + " ),\n", + " reward_info=_encoded_feature(\n", + " self.reward_info, image_encoding, tensor_encoding\n", + " ),\n", + " discount_info=_encoded_feature(\n", + " self.discount_info, image_encoding, tensor_encoding\n", + " ),\n", + " step_metadata_info=_encoded_feature(\n", + " self.step_metadata_info, image_encoding, tensor_encoding\n", + " ),\n", + " episode_metadata_info=_encoded_feature(\n", + " self.episode_metadata_info, image_encoding, tensor_encoding\n", + " ),\n", + " )\n", + "\n", + " def to_features_dict(self):\n", + " \"\"\"Returns a TFDS FeaturesDict representing the dataset config.\"\"\"\n", + " step_config = {\n", + " rlds_types.IS_FIRST: tf.bool,\n", + " rlds_types.IS_LAST: tf.bool,\n", + " rlds_types.IS_TERMINAL: tf.bool,\n", + " }\n", + "\n", + " if self.observation_info:\n", + " step_config[rlds_types.OBSERVATION] = self.observation_info\n", + " if self.action_info:\n", + " step_config[rlds_types.ACTION] = self.action_info\n", + " if self.discount_info:\n", + " step_config[rlds_types.DISCOUNT] = self.discount_info\n", + " if self.reward_info:\n", + " step_config[rlds_types.REWARD] = self.reward_info\n", + "\n", + " if self.step_metadata_info:\n", + " for k, v in self.step_metadata_info.items():\n", + " step_config[k] = v\n", + "\n", + " if self.episode_metadata_info:\n", + " return tfds.features.FeaturesDict(\n", + " {\n", + " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", + " **self.episode_metadata_info,\n", + " }\n", + " )\n", + " else:\n", + " return tfds.features.FeaturesDict(\n", + " {\n", + " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", + " }\n", + " )\n", + "\n", + "\n", + "RLDS_SPEC = RLDSSpec\n", + "TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]]\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class TrajectoryTransform(metaclass=abc.ABCMeta):\n", + " \"\"\"Specification the TrajectoryTransform applied to a dataset of episodes.\n", + "\n", + " A TrajectoryTransform is a set of rules transforming a dataset\n", + " of RLDS episodes to a dataset of trajectories.\n", + " This involves three distinct stages:\n", + " - An optional `episode_to_steps_map_fn(episode)` is called at the episode\n", + " level, and can be used to select or modify steps.\n", + " - Augmentation: an `episode_key` could be propagated to `steps` for\n", + " debugging.\n", + " - Selection: Particular steps can be selected.\n", + " - Stripping: Features can be removed from steps. Prefer using `step_map_fn`.\n", + " - An optional `step_map_fn` is called at the flattened steps dataset for each\n", + " step, and can be used to featurize a step, e.g. add/remove features, or\n", + " augument images\n", + " - A `pattern` leverages DM patterns to set a rule of slicing an episode to a\n", + " dataset of overlapping trajectories.\n", + "\n", + " Importantly, each TrajectoryTransform must define a `expected_tensor_spec`\n", + " which specifies a nested TensorSpec of the resulting dataset. This is what\n", + " this TrajectoryTransform will produce, and can be used as an interface with\n", + " a neural network.\n", + " \"\"\"\n", + "\n", + " episode_dataset_spec: RLDS_SPEC\n", + " episode_to_steps_fn_dataset_spec: RLDS_SPEC\n", + " steps_dataset_spec: Any\n", + " pattern: reverb.structured_writer.Pattern\n", + " episode_to_steps_map_fn: Any\n", + " expected_tensor_spec: TENSOR_SPEC\n", + " step_map_fn: Optional[Any] = None\n", + "\n", + " def get_for_cached_trajectory_transform(self):\n", + " \"\"\"Creates a copy of this traj transform to use with caching.\n", + "\n", + " The returned TrajectoryTransfrom copy will be initialized with the default\n", + " version of the `episode_to_steps_map_fn`, because the effect of that\n", + " function has already been materialized in the cached copy of the dataset.\n", + " Returns:\n", + " trajectory_transform: A copy of the TrajectoryTransform with overridden\n", + " `episode_to_steps_map_fn`.\n", + " \"\"\"\n", + " traj_copy = dataclasses.replace(self)\n", + " traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec\n", + " traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS]\n", + " return traj_copy\n", + "\n", + " def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset):\n", + " \"\"\"Applies this TrajectoryTransform to the dataset of episodes.\"\"\"\n", + "\n", + " # Convert the dataset of episodes to the dataset of steps.\n", + " steps_dataset = episodes_dataset.map(\n", + " self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE\n", + " ).flat_map(lambda x: x)\n", + "\n", + " return self._create_pattern_dataset(steps_dataset)\n", + "\n", + " def transform_steps_rlds_dataset(\n", + " self, steps_dataset: tf.data.Dataset\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Applies this TrajectoryTransform to the dataset of episode steps.\"\"\"\n", + "\n", + " return self._create_pattern_dataset(steps_dataset)\n", + "\n", + " def create_test_dataset(\n", + " self,\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Creates a test dataset of trajectories.\n", + "\n", + " It is guaranteed that the structure of this dataset will be the same as\n", + " when flowing real data. Hence this is a useful construct for tests or\n", + " initialization of JAX models.\n", + " Returns:\n", + " dataset: A test dataset made of zeros structurally identical to the\n", + " target dataset of trajectories.\n", + " \"\"\"\n", + " zeros = transformations.zeros_from_spec(self.expected_tensor_spec)\n", + "\n", + " return tf.data.Dataset.from_tensors(zeros)\n", + "\n", + " def _create_pattern_dataset(\n", + " self, steps_dataset: tf.data.Dataset\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Create PatternDataset from the `steps_dataset`.\"\"\"\n", + " config = create_structured_writer_config(\"temp\", self.pattern)\n", + "\n", + " # Further transform each step if the `step_map_fn` is provided.\n", + " if self.step_map_fn:\n", + " steps_dataset = steps_dataset.map(self.step_map_fn)\n", + " pattern_dataset = reverb.PatternDataset(\n", + " input_dataset=steps_dataset,\n", + " configs=[config],\n", + " respect_episode_boundaries=True,\n", + " is_end_of_episode=lambda x: x[rlds_types.IS_LAST],\n", + " )\n", + " return pattern_dataset\n", + "\n", + "\n", + "class TrajectoryTransformBuilder(object):\n", + " \"\"\"Facilitates creation of the `TrajectoryTransform`.\"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dataset_spec: RLDS_SPEC,\n", + " episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS],\n", + " step_map_fn=None,\n", + " pattern_fn=None,\n", + " expected_tensor_spec=None,\n", + " ):\n", + " self._rds_dataset_spec = dataset_spec\n", + " self._steps_spec = None\n", + " self._episode_to_steps_map_fn = episode_to_steps_map_fn\n", + " self._step_map_fn = step_map_fn\n", + " self._pattern_fn = pattern_fn\n", + " self._expected_tensor_spec = expected_tensor_spec\n", + "\n", + " def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform:\n", + " \"\"\"Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.\"\"\"\n", + "\n", + " if validate_expected_tensor_spec and self._expected_tensor_spec is None:\n", + " raise ValueError(\"`expected_tensor_spec` must be set.\")\n", + "\n", + " episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec)\n", + "\n", + " steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn)\n", + "\n", + " episode_to_steps_fn_dataset_spec = self._rds_dataset_spec\n", + "\n", + " if self._step_map_fn is not None:\n", + " steps_ds = steps_ds.map(self._step_map_fn)\n", + "\n", + " zeros_spec = transformations.zeros_from_spec(\n", + " steps_ds.element_spec\n", + " ) # pytype: disable=wrong-arg-types\n", + "\n", + " ref_step = reverb.structured_writer.create_reference_step(zeros_spec)\n", + "\n", + " pattern = self._pattern_fn(ref_step)\n", + "\n", + " steps_ds_spec = steps_ds.element_spec\n", + "\n", + " target_tensor_structure = create_reverb_table_signature(\n", + " \"temp_table\", steps_ds_spec, pattern\n", + " )\n", + "\n", + " if (\n", + " validate_expected_tensor_spec\n", + " and self._expected_tensor_spec != target_tensor_structure\n", + " ):\n", + " raise RuntimeError(\n", + " \"The tensor spec of the TrajectoryTransform doesn't \"\n", + " \"match the expected spec.\\n\"\n", + " \"Expected:\\n%s\\nActual:\\n%s\\n\"\n", + " % (\n", + " str(self._expected_tensor_spec).replace(\n", + " \"TensorSpec\", \"tf.TensorSpec\"\n", + " ),\n", + " str(target_tensor_structure).replace(\"TensorSpec\", \"tf.TensorSpec\"),\n", + " )\n", + " )\n", + "\n", + " return TrajectoryTransform(\n", + " episode_dataset_spec=self._rds_dataset_spec,\n", + " episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec,\n", + " steps_dataset_spec=steps_ds_spec,\n", + " pattern=pattern,\n", + " episode_to_steps_map_fn=self._episode_to_steps_map_fn,\n", + " step_map_fn=self._step_map_fn,\n", + " expected_tensor_spec=target_tensor_structure,\n", + " )\n", + "\n", + "\n", + "def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC):\n", + " \"\"\"Creates a zero valued dataset of episodes for the given RLDS Spec.\"\"\"\n", + "\n", + " def add_steps(episode, step_spec):\n", + " episode[rlds_types.STEPS] = transformations.zero_dataset_like(\n", + " tf.data.DatasetSpec(step_spec)\n", + " )\n", + " if \"fake\" in episode:\n", + " del episode[\"fake\"]\n", + " return episode\n", + "\n", + " episode_without_steps_spec = {\n", + " k: v\n", + " for k, v in rlds_spec.episode_tensor_spec().items()\n", + " if k != rlds_types.STEPS\n", + " }\n", + "\n", + " if episode_without_steps_spec:\n", + " episodes_dataset = transformations.zero_dataset_like(\n", + " tf.data.DatasetSpec(episode_without_steps_spec)\n", + " )\n", + " else:\n", + " episodes_dataset = tf.data.Dataset.from_tensors({\"fake\": \"\"})\n", + "\n", + " episodes_dataset_with_steps = episodes_dataset.map(\n", + " lambda episode: add_steps(episode, rlds_spec.step_tensor_spec())\n", + " )\n", + " return episodes_dataset_with_steps\n", + "\n", + "\n", + "def create_reverb_table_signature(\n", + " table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern\n", + ") -> reverb.reverb_types.SpecNest:\n", + " config = create_structured_writer_config(table_name, pattern)\n", + " reverb_table_spec = reverb.structured_writer.infer_signature(\n", + " [config], steps_dataset_spec\n", + " )\n", + " return reverb_table_spec\n", + "\n", + "\n", + "def create_structured_writer_config(\n", + " table_name: str, pattern: reverb.structured_writer.Pattern\n", + ") -> Any:\n", + " config = reverb.structured_writer.create_config(\n", + " pattern=pattern, table=table_name, conditions=[]\n", + " )\n", + " return config\n", + "\n", + "\n", + "def n_step_pattern_builder(n: int) -> Any:\n", + " \"\"\"Creates trajectory of length `n` from all fields of a `ref_step`.\"\"\"\n", + "\n", + " def transform_fn(ref_step):\n", + " traj = {}\n", + " for key in ref_step:\n", + " if isinstance(ref_step[key], dict):\n", + " transformed_entry = tree.map_structure(\n", + " lambda ref_node: ref_node[-n:], ref_step[key]\n", + " )\n", + " traj[key] = transformed_entry\n", + " else:\n", + " traj[key] = ref_step[key][-n:]\n", + "\n", + " return traj\n", + "\n", + " return transform_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BK4RRYkbLN5B" + }, + "source": [ + "## Demonstration of transformation from an episode to a trajectory\n", + "\n", + "A real ML pipeline would rarely learn from a whole episode. Instead the input to a model is a _trajectory_. A `Trajectory` is a particular way to slice a sequence of episode steps. `SARSA` trajectory is one well known example, but a trajectory of an arbitrary length `n` is also an option. Often, a set of _overlapping_ trajectories is produced from an episode. For example, given the following episode steps:\n", + "\n", + "`episode=[s_0, s_1, s_2, s_3, s_4, s_T]`\n", + "\n", + "and a target Trajectory of length `3`, the following trajectories are produced:\n", + "\n", + "`t_1=[s_0, s_1, s_2]`\n", + "\n", + "`t_2=[s_1, s_2, s_3]`\n", + "\n", + "`t_3=[s_2, s_3, s_4]`\n", + "\n", + "`t_4=[s_3, s_4, s_T]`\n", + "\n", + "\n", + "To perform such a slicing, the dataset of episode is first \"flattened\" to the dataset of steps. The `is_last` attribute of an RLDS step allows proper slicing, not crossing the episode boundary. The `TrajectoryTransformBuilder` demonstrates this:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "id": "_NsYnqnpNgNl" + }, + "outputs": [], + "source": [ + "import tensorflow_datasets as tfds\n", + "\n", + "dataset = \"fractal20220817_data\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds = b.as_dataset(split=\"train[:10]\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "2qvMcpGDx6hJ" + }, + "outputs": [], + "source": [ + "# The RLDSSpec for the RT1 dataset.\n", + "rt1_spec = RLDSSpec(\n", + " observation_info=b.info.features[\"steps\"][\"observation\"],\n", + " action_info=b.info.features[\"steps\"][\"action\"],\n", + ")\n", + "\n", + "# The following will create a trajectories of length 3.\n", + "trajectory_length = 3\n", + "trajectory_transform = TrajectoryTransformBuilder(\n", + " rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length)\n", + ").build(validate_expected_tensor_spec=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "Fk4ZfC_bMBw3" + }, + "outputs": [], + "source": [ + "trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds)\n", + "\n", + "trajectory_iter = iter(trajectory_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "fSxk3zF_x0FS" + }, + "outputs": [], + "source": [ + "trajectory = next(trajectory_iter)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t2V0xrIVMWNc", + "outputId": "5c71d7ef-2fc7-424e-a8ae-0e1c60252f42" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'action': {'base_displacement_vector': ,\n", + " 'gripper_closedness_action': ,\n", + " 'world_vector': ,\n", + " 'rotation_delta': ,\n", + " 'base_displacement_vertical_rotation': ,\n", + " 'terminate_episode': },\n", + " 'is_first': ,\n", + " 'is_last': ,\n", + " 'observation': {'robot_orientation_positions_box': ,\n", + " 'workspace_bounds': ,\n", + " 'natural_language_instruction': ,\n", + " 'image': ,\n", + " 'src_rotation': ,\n", + " 'orientation_box': ,\n", + " 'height_to_bottom': ,\n", + " 'vector_to_go': ,\n", + " 'rotation_delta_to_go': ,\n", + " 'gripper_closedness_commanded': ,\n", + " 'orientation_start': ,\n", + " 'gripper_closed': ,\n", + " 'base_pose_tool_reached': ,\n", + " 'natural_language_embedding': },\n", + " 'is_terminal': }" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajectory" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ytrvi945NTZz", + "outputId": "50dd5318-7521-4d85-a1cf-42aa046ce4c3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "TensorShape([3, 256, 320, 3])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Note that the leading dimension (3) corresponds to the trajectory_length\n", + "trajectory[\"observation\"][\"image\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 529 + }, + "id": "xhDX3BcWNmrl", + "outputId": "0d4c3c74-7d71-45e3-baea-c5f119eea9a4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "episode = next(iter(ds))\n", + "\n", + "# Iterate over steps of the episode. Collect images.\n", + "images = [\n", + " trajectory[\"observation\"][\"image\"][id]\n", + " for id in range(trajectory[\"observation\"][\"image\"].shape[0])\n", + "]\n", + "images = [Image.fromarray(image.numpy()) for image in images]\n", + "\n", + "display.Image(as_gif(images))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oy89HzymQyAq" + }, + "source": [ + "## Combination of multiple datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "id": "qs0-7alaQ3C9" + }, + "outputs": [], + "source": [ + "import tensorflow_datasets as tfds\n", + "\n", + "robo_net_builder = tfds.builder_from_directory(\n", + " builder_dir=\"gs://gresearch/robotics/robo_net/1.0.0/\"\n", + ")\n", + "\n", + "robo_net_builder_episodic_dataset = robo_net_builder.as_dataset(split=\"train[:10]\")\n", + "episodes = list(iter(robo_net_builder_episodic_dataset))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "id": "2tgJpMqARIFQ" + }, + "outputs": [], + "source": [ + "# The following will create a trajectories of length 3.\n", + "trajectory_length = 3\n", + "\n", + "robo_net_rlds_spec = RLDSSpec(\n", + " observation_info=robo_net_builder.info.features[\"steps\"][\"observation\"],\n", + " action_info=robo_net_builder.info.features[\"steps\"][\"action\"],\n", + ")\n", + "\n", + "\n", + "def robo_net_step_map_fn(step):\n", + " transformed_step = {}\n", + " transformed_step[\"observation\"] = step[\"observation\"][\"image\"]\n", + " transformed_step[\"is_first\"] = step[\"is_first\"]\n", + " transformed_step[\"is_last\"] = step[\"is_last\"]\n", + " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", + " return transformed_step\n", + "\n", + "\n", + "robo_net_trajectory_transform = TrajectoryTransformBuilder(\n", + " robo_net_rlds_spec,\n", + " step_map_fn=robo_net_step_map_fn,\n", + " pattern_fn=n_step_pattern_builder(trajectory_length),\n", + ").build(validate_expected_tensor_spec=False)\n", + "\n", + "\n", + "def mt_opt_step_map_fn(step):\n", + " transformed_step = {}\n", + " transformed_step[\"observation\"] = tf.cast(\n", + " tf.image.resize(step[\"observation\"][\"image\"], [240, 320]), tf.uint8\n", + " ) # Resize to be compatible with robo_net trajectory\n", + " transformed_step[\"is_first\"] = step[\"is_first\"]\n", + " transformed_step[\"is_last\"] = step[\"is_last\"]\n", + " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", + " return transformed_step\n", + "\n", + "\n", + "mt_opt_trajectory_transform = TrajectoryTransformBuilder(\n", + " rt1_spec,\n", + " step_map_fn=mt_opt_step_map_fn,\n", + " pattern_fn=n_step_pattern_builder(trajectory_length),\n", + ").build(validate_expected_tensor_spec=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "id": "anGArTQbTiHj" + }, + "outputs": [], + "source": [ + "# Validate that the specs are equal\n", + "assert (\n", + " robo_net_trajectory_transform.expected_tensor_spec\n", + " == mt_opt_trajectory_transform.expected_tensor_spec\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "id": "L9gRx6BfTGH-" + }, + "outputs": [], + "source": [ + "# Create trajectory datasets for the two normalized representations:\n", + "robo_net_trajectory_dataset = (\n", + " robo_net_trajectory_transform.transform_episodic_rlds_dataset(\n", + " robo_net_builder_episodic_dataset\n", + " )\n", + ")\n", + "mt_opt_trajectory_dataset = mt_opt_trajectory_transform.transform_episodic_rlds_dataset(\n", + " ds\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "id": "-SVkHpIxRVXz" + }, + "outputs": [], + "source": [ + "combined_dataset = tf.data.Dataset.sample_from_datasets(\n", + " [robo_net_trajectory_dataset, mt_opt_trajectory_dataset]\n", + ")\n", + "combined_dataset = combined_dataset.batch(2)\n", + "combined_dataset_it = iter(combined_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "id": "-CMdwIcsR30k" + }, + "outputs": [], + "source": [ + "example = next(combined_dataset_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "w2YJOvRKUb2E", + "outputId": "31daf4b7-9350-4d05-9c57-d9784bc34d44" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# First element of the batch returns a robot_net trajectory\n", + "Image.fromarray(example[\"observation\"].numpy()[0][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "FP0iz-f_UoTY", + "outputId": "244fb34b-fa72-4c02-e432-8a0382f45b17" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Second element of the batch returns a mt_opt trajectory\n", + "Image.fromarray(example[\"observation\"].numpy()[1][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N2Efw2aHVfSX" + }, + "source": [ + "# Available datasets and their sizes:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kQkeUKyrVhGK", + "outputId": "a61cb54f-fd1e-41d0-858b-19d30659c8b1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset gs://gresearch/robotics/fractal20220817_data/0.1.0 has size 111.07 GiB\n", + "Dataset gs://gresearch/robotics/kuka/0.1.0 has size 778.02 GiB\n", + "Dataset gs://gresearch/robotics/bridge/0.1.0 has size 387.49 GiB\n", + "Dataset gs://gresearch/robotics/taco_play/0.1.0 has size 47.77 GiB\n", + "Dataset gs://gresearch/robotics/jaco_play/0.1.0 has size 9.24 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_cable_routing/0.1.0 has size 4.67 GiB\n", + "Dataset gs://gresearch/robotics/roboturk/0.1.0 has size 45.39 GiB\n", + "Dataset gs://gresearch/robotics/nyu_door_opening_surprising_effectiveness/0.1.0 has size 7.12 GiB\n", + "Dataset gs://gresearch/robotics/viola/0.1.0 has size 10.40 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_autolab_ur5/0.1.0 has size 76.39 GiB\n", + "Dataset gs://gresearch/robotics/toto/0.1.0 has size 127.66 GiB\n", + "Dataset gs://gresearch/robotics/language_table/0.0.1 has size 399.23 GiB\n", + "Dataset gs://gresearch/robotics/columbia_cairlab_pusht_real/0.1.0 has size 2.80 GiB\n", + "Dataset gs://gresearch/robotics/stanford_kuka_multimodal_dataset_converted_externally_to_rlds/0.1.0 has size 31.98 GiB\n", + "Dataset gs://gresearch/robotics/nyu_rot_dataset_converted_externally_to_rlds/0.1.0 has size 5.33 MiB\n", + "Dataset gs://gresearch/robotics/stanford_hydra_dataset_converted_externally_to_rlds/0.1.0 has size 72.48 GiB\n", + "Dataset gs://gresearch/robotics/austin_buds_dataset_converted_externally_to_rlds/0.1.0 has size 1.49 GiB\n", + "Dataset gs://gresearch/robotics/nyu_franka_play_dataset_converted_externally_to_rlds/0.1.0 has size 5.18 GiB\n", + "Dataset gs://gresearch/robotics/maniskill_dataset_converted_externally_to_rlds/0.1.0 has size 151.05 GiB\n", + "Dataset gs://gresearch/robotics/cmu_franka_exploration_dataset_converted_externally_to_rlds/0.1.0 has size 602.24 MiB\n", + "Dataset gs://gresearch/robotics/ucsd_kitchen_dataset_converted_externally_to_rlds/0.1.0 has size 1.33 GiB\n", + "Dataset gs://gresearch/robotics/ucsd_pick_and_place_dataset_converted_externally_to_rlds/0.1.0 has size 3.53 GiB\n", + "Dataset gs://gresearch/robotics/austin_sailor_dataset_converted_externally_to_rlds/0.1.0 has size 18.85 GiB\n", + "Dataset gs://gresearch/robotics/austin_sirius_dataset_converted_externally_to_rlds/0.1.0 has size 6.55 GiB\n", + "Dataset gs://gresearch/robotics/bc_z/0.1.0 has size 80.54 GiB\n", + "Dataset gs://gresearch/robotics/usc_cloth_sim_converted_externally_to_rlds/0.1.0 has size 254.52 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_pr2_opening_fridge_converted_externally_to_rlds/0.1.0 has size 360.57 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds/0.1.0 has size 829.37 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_saytap_converted_externally_to_rlds/0.1.0 has size 55.34 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_xarm_pick_and_place_converted_externally_to_rlds/0.1.0 has size 1.29 GiB\n", + "Dataset gs://gresearch/robotics/utokyo_xarm_bimanual_converted_externally_to_rlds/0.1.0 has size 138.44 MiB\n", + "Dataset gs://gresearch/robotics/robo_net/1.0.0 has size 799.91 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_mvp_converted_externally_to_rlds/0.1.0 has size 12.34 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_rpt_converted_externally_to_rlds/0.1.0 has size 40.64 GiB\n", + "Dataset gs://gresearch/robotics/kaist_nonprehensile_converted_externally_to_rlds/0.1.0 has size 11.71 GiB\n", + "Dataset gs://gresearch/robotics/stanford_mask_vit_converted_externally_to_rlds/0.1.0 has size 76.17 GiB\n", + "Dataset gs://gresearch/robotics/tokyo_u_lsmo_converted_externally_to_rlds/0.1.0 has size 335.71 MiB\n", + "Dataset gs://gresearch/robotics/dlr_sara_pour_converted_externally_to_rlds/0.1.0 has size 2.92 GiB\n", + "Dataset gs://gresearch/robotics/dlr_sara_grid_clamp_converted_externally_to_rlds/0.1.0 has size 1.65 GiB\n", + "Dataset gs://gresearch/robotics/dlr_edan_shared_control_converted_externally_to_rlds/0.1.0 has size 3.09 GiB\n", + "Dataset gs://gresearch/robotics/asu_table_top_converted_externally_to_rlds/0.1.0 has size 737.60 MiB\n", + "Dataset gs://gresearch/robotics/stanford_robocook_converted_externally_to_rlds/0.1.0 has size 124.62 GiB\n", + "Dataset gs://gresearch/robotics/eth_agent_affordances/0.1.0 has size 17.27 GiB\n", + "Dataset gs://gresearch/robotics/imperialcollege_sawyer_wrist_cam/0.1.0 has size 81.87 MiB\n", + "Dataset gs://gresearch/robotics/iamlab_cmu_pickup_insert_converted_externally_to_rlds/0.1.0 has size 50.29 GiB\n", + "Dataset gs://gresearch/robotics/uiuc_d3field/0.1.0 has size 15.82 GiB\n", + "Dataset gs://gresearch/robotics/utaustin_mutex/0.1.0 has size 20.79 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_fanuc_manipulation/0.1.0 has size 8.85 GiB\n", + "Dataset gs://gresearch/robotics/cmu_play_fusion/0.1.0 has size 6.68 GiB\n", + "Dataset gs://gresearch/robotics/cmu_stretch/0.1.0 has size 728.06 MiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_recon/0.1.0 has size 18.73 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_cory_hall/0.1.0 has size 1.39 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_sac_son/0.1.0 has size 7.00 GiB\n" + ] + } + ], + "source": [ + "# Iterate over and make sure that a dataset can be created\n", + "for name in DATASETS:\n", + " uri = dataset2path(name)\n", + " b = tfds.builder_from_directory(builder_dir=uri)\n", + " split = list(b.info.splits.keys())[0]\n", + " b.as_dataset(split=split)\n", + " print(\"Dataset %s has size %s\" % (uri, b.info.dataset_size))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ZnRYMsVpaZKF", + "outputId": "d546a431-5dad-4aee-d6f6-b9aa4207e319" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/tensorflow/datasets.git\n", + " Cloning https://github.com/tensorflow/datasets.git to /tmp/pip-req-build-d48q8hrq\n", + " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/datasets.git /tmp/pip-req-build-d48q8hrq\n", + " Resolved https://github.com/tensorflow/datasets.git to commit 0f2cce155781202f05fbe8007a763e12ef9fc6ee\n", + " Installing build dependencies ... \u001b[?25ldone\n", + "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", + "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25hCollecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading absl_py-2.0.0-py3-none-any.whl.metadata (2.3 kB)\n", + "Collecting click (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading click-8.1.7-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting dm-tree (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading dm_tree-0.1.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (152 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.8/152.8 kB\u001b[0m \u001b[31m654.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m1m687.2 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hCollecting etils>=0.9.0 (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading etils-1.5.2-py3-none-any.whl.metadata (6.3 kB)\n", + "Collecting numpy (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.2/61.2 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting promise (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached promise-2.3-py3-none-any.whl\n", + "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading protobuf-4.25.0-cp37-abi3-manylinux2014_x86_64.whl.metadata (541 bytes)\n", + "Collecting psutil (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (21 kB)\n", + "Collecting requests>=2.19.0 (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading requests-2.31.0-py3-none-any.whl.metadata (4.6 kB)\n", + "Collecting tensorflow-metadata (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached tensorflow_metadata-1.14.0-py3-none-any.whl.metadata (2.1 kB)\n", + "Collecting termcolor (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", + "Collecting toml (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", + "Collecting tqdm (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading tqdm-4.66.1-py3-none-any.whl.metadata (57 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.6/57.6 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting wrapt (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n", + "Collecting array-record>=0.5.0 (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (503 bytes)\n", + "Collecting fsspec (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading fsspec-2023.10.0-py3-none-any.whl.metadata (6.8 kB)\n", + "Collecting importlib_resources (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading importlib_resources-6.1.1-py3-none-any.whl.metadata (4.1 kB)\n", + "Collecting typing_extensions (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading typing_extensions-4.8.0-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting zipp (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading zipp-3.17.0-py3-none-any.whl.metadata (3.7 kB)\n", + "Collecting charset-normalizer<4,>=2 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (33 kB)\n", + "Collecting idna<4,>=2.5 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading idna-3.4-py3-none-any.whl (61 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.5/61.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting urllib3<3,>=1.21.1 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading urllib3-2.0.7-py3-none-any.whl.metadata (6.6 kB)\n", + "Collecting certifi>=2017.4.17 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading certifi-2023.7.22-py3-none-any.whl.metadata (2.2 kB)\n", + "Collecting six (from promise->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n", + "Collecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached absl_py-1.4.0-py3-none-any.whl (126 kB)\n", + "Collecting googleapis-common-protos<2,>=1.52.0 (from tensorflow-metadata->tensorflow-datasets==4.9.3+nightly)\n", + " Using cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl.metadata (1.5 kB)\n", + "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached protobuf-3.20.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n", + "Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.0 MB)\n", + "Downloading etils-1.5.2-py3-none-any.whl (140 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading requests-2.31.0-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.6/62.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading click-8.1.7-py3-none-any.whl (97 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.9/97.9 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (283 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m283.6/283.6 kB\u001b[0m \u001b[31m16.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached tensorflow_metadata-1.14.0-py3-none-any.whl (28 kB)\n", + "Downloading tqdm-4.66.1-py3-none-any.whl (78 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.3/78.3 kB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (80 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m80.3/80.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading certifi-2023.7.22-py3-none-any.whl (158 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.3/158.3 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (142 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m142.1/142.1 kB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl (230 kB)\n", + "Downloading urllib3-2.0.7-py3-none-any.whl (124 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 kB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading fsspec-2023.10.0-py3-none-any.whl (166 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m166.4/166.4 kB\u001b[0m \u001b[31m13.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading importlib_resources-6.1.1-py3-none-any.whl (33 kB)\n", + "Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", + "Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", + "Building wheels for collected packages: tensorflow-datasets\n", + " Building wheel for tensorflow-datasets (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for tensorflow-datasets: filename=tensorflow_datasets-4.9.3+nightly-py3-none-any.whl size=5042188 sha256=b922a59c63a43266324047d6de8cc70c4e902e4be1002a629f6fc9144b42026e\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-yum8n3h3/wheels/69/95/f3/0a7e5341cee7ec33827b33149e1556b4e39317c704cb2751bd\n", + "Successfully built tensorflow-datasets\n", + "Installing collected packages: dm-tree, zipp, wrapt, urllib3, typing_extensions, tqdm, toml, termcolor, six, psutil, protobuf, numpy, importlib_resources, idna, fsspec, etils, click, charset-normalizer, certifi, absl-py, requests, promise, googleapis-common-protos, tensorflow-metadata, array-record, tensorflow-datasets\n", + " Attempting uninstall: dm-tree\n", + " Found existing installation: dm-tree 0.1.8\n", + " Uninstalling dm-tree-0.1.8:\n", + " Successfully uninstalled dm-tree-0.1.8\n", + " Attempting uninstall: zipp\n", + " Found existing installation: zipp 3.17.0\n", + " Uninstalling zipp-3.17.0:\n", + " Successfully uninstalled zipp-3.17.0\n", + " Attempting uninstall: wrapt\n", + " Found existing installation: wrapt 1.14.1\n", + " Uninstalling wrapt-1.14.1:\n", + " Successfully uninstalled wrapt-1.14.1\n", + " Attempting uninstall: urllib3\n", + " Found existing installation: urllib3 1.26.16\n", + " Uninstalling urllib3-1.26.16:\n", + " Successfully uninstalled urllib3-1.26.16\n", + " Attempting uninstall: typing_extensions\n", + " Found existing installation: typing_extensions 4.6.3\n", + " Uninstalling typing_extensions-4.6.3:\n", + " Successfully uninstalled typing_extensions-4.6.3\n", + " Attempting uninstall: tqdm\n", + " Found existing installation: tqdm 4.65.0\n", + " Uninstalling tqdm-4.65.0:\n", + " Successfully uninstalled tqdm-4.65.0\n", + " Attempting uninstall: toml\n", + " Found existing installation: toml 0.10.2\n", + " Uninstalling toml-0.10.2:\n", + " Successfully uninstalled toml-0.10.2\n", + " Attempting uninstall: termcolor\n", + " Found existing installation: termcolor 2.3.0\n", + " Uninstalling termcolor-2.3.0:\n", + " Successfully uninstalled termcolor-2.3.0\n", + " Attempting uninstall: six\n", + " Found existing installation: six 1.16.0\n", + " Uninstalling six-1.16.0:\n", + " Successfully uninstalled six-1.16.0\n", + " Attempting uninstall: psutil\n", + " Found existing installation: psutil 5.9.0\n", + " Uninstalling psutil-5.9.0:\n", + " Successfully uninstalled psutil-5.9.0\n", + " Attempting uninstall: protobuf\n", + " Found existing installation: protobuf 3.20.3\n", + " Uninstalling protobuf-3.20.3:\n", + " Successfully uninstalled protobuf-3.20.3\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 1.25.0\n", + " Uninstalling numpy-1.25.0:\n", + " Successfully uninstalled numpy-1.25.0\n", + " Attempting uninstall: importlib_resources\n", + " Found existing installation: importlib-resources 6.1.1\n", + " Uninstalling importlib-resources-6.1.1:\n", + " Successfully uninstalled importlib-resources-6.1.1\n", + " Attempting uninstall: idna\n", + " Found existing installation: idna 3.4\n", + " Uninstalling idna-3.4:\n", + " Successfully uninstalled idna-3.4\n", + " Attempting uninstall: fsspec\n", + " Found existing installation: fsspec 2023.9.2\n", + " Uninstalling fsspec-2023.9.2:\n", + " Successfully uninstalled fsspec-2023.9.2\n", + " Attempting uninstall: etils\n", + " Found existing installation: etils 1.5.2\n", + " Uninstalling etils-1.5.2:\n", + " Successfully uninstalled etils-1.5.2\n", + " Attempting uninstall: click\n", + " Found existing installation: click 8.1.7\n", + " Uninstalling click-8.1.7:\n", + " Successfully uninstalled click-8.1.7\n", + " Attempting uninstall: charset-normalizer\n", + " Found existing installation: charset-normalizer 2.0.4\n", + " Uninstalling charset-normalizer-2.0.4:\n", + " Successfully uninstalled charset-normalizer-2.0.4\n", + " Attempting uninstall: certifi\n", + " Found existing installation: certifi 2023.5.7\n", + " Uninstalling certifi-2023.5.7:\n", + " Successfully uninstalled certifi-2023.5.7\n", + " Attempting uninstall: absl-py\n", + " Found existing installation: absl-py 1.4.0\n", + " Uninstalling absl-py-1.4.0:\n", + " Successfully uninstalled absl-py-1.4.0\n", + " Attempting uninstall: requests\n", + " Found existing installation: requests 2.29.0\n", + " Uninstalling requests-2.29.0:\n", + " Successfully uninstalled requests-2.29.0\n", + " Attempting uninstall: promise\n", + " Found existing installation: promise 2.3\n", + " Uninstalling promise-2.3:\n", + " Successfully uninstalled promise-2.3\n", + " Attempting uninstall: googleapis-common-protos\n", + " Found existing installation: googleapis-common-protos 1.61.0\n", + " Uninstalling googleapis-common-protos-1.61.0:\n", + " Successfully uninstalled googleapis-common-protos-1.61.0\n", + " Attempting uninstall: tensorflow-metadata\n", + " Found existing installation: tensorflow-metadata 1.14.0\n", + " Uninstalling tensorflow-metadata-1.14.0:\n", + " Successfully uninstalled tensorflow-metadata-1.14.0\n", + " Attempting uninstall: array-record\n", + " Found existing installation: array-record 0.5.0\n", + " Uninstalling array-record-0.5.0:\n", + " Successfully uninstalled array-record-0.5.0\n", + " Attempting uninstall: tensorflow-datasets\n", + " Found existing installation: tensorflow-datasets 4.9.3\n", + " Uninstalling tensorflow-datasets-4.9.3:\n", + " Successfully uninstalled tensorflow-datasets-4.9.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "tensorflow 2.14.0 requires wrapt<1.15,>=1.11.0, but you have wrapt 1.16.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed absl-py-1.4.0 array-record-0.5.0 certifi-2023.7.22 charset-normalizer-3.3.2 click-8.1.7 dm-tree-0.1.8 etils-1.5.2 fsspec-2023.10.0 googleapis-common-protos-1.61.0 idna-3.4 importlib_resources-6.1.1 numpy-1.26.1 promise-2.3 protobuf-3.20.3 psutil-5.9.6 requests-2.31.0 six-1.16.0 tensorflow-datasets-4.9.3+nightly tensorflow-metadata-1.14.0 termcolor-2.3.0 toml-0.10.2 tqdm-4.66.1 typing_extensions-4.8.0 urllib3-2.0.7 wrapt-1.16.0 zipp-3.17.0\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "# Might require updating tensorflow datasets:\n", + "%pip install --upgrade --force-reinstall git+https://github.com/tensorflow/datasets.git" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bPhwnlk1a1lq", + "outputId": "90ec1c89-2ef7-4cd6-aa39-b2df72da15de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fractal20220817_data\n", + "bc_z\n" + ] + } + ], + "source": [ + "for name in DATASET_NAMES:\n", + " print(name)\n", + " b = tfds.builder_from_directory(builder_dir=dataset2path(name))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/models/main_models/rt1/README.md b/models/main_models/rt1/README.md new file mode 100644 index 000000000..930fa939a --- /dev/null +++ b/models/main_models/rt1/README.md @@ -0,0 +1,66 @@ +# NPM-Dataset +A comprehensive robotics dataset that includes navigation, perception, and manipulation data per data point. + +# RT-1 (Robotic Transformer) PyTorch Implementation + + +A forked implementation of RT1 (Robotic Transformer) originally inspired by the Google Research paper. + +This implemenetation of RT-1 was pretrained on the Bridge dataset and further fine-tuned on our LaNMP dataset for evaluation. Please find details of the repository below + +## Setup Instructions + +```bash +git clone https://github.com/h2r/NPM-Dataset.git +git checkout -b rt1 +pip install -e . +``` + +## Overview of files + +This repository has 7 critical files/folders whose use cases are described below + +1) ```main.py```: used to pretrain RT-1 on the bridge dataset. Modifying this file to accomodate different datasets requires changing the ```observation_space``` and ```action_space``` according to the dataset being loaded, as well as changing the dataset keys in ```rt1_pytorch/tokenizers/action_tokenizer.py```. Running this file saves a series of checkpoints and logs losses using weights and biases +2) ```main_ft.py```: used to finetune RT-1 on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset finetuning (AI2Thor). Running this file saves a series of checkpoints and logs losses using weights and biases +3) ```main_ft_eval.py```: used to run RT-1 in inference mode on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset (AI2Thor). The file iterates/loads all saved checkpoints from finetuning and runs RT-1 on inference mode for the validation dataset on each checkpoint. The script logs the test losses using weights and biases +4) ```ai2thor_env.py```: contains a Gym environment style class to load and take steps in AI2Thor enivironment. This file is used to generate real-time trajectories based on the action tokens generated by a finetuned RT-1 model (specific for AI2Thor). The main ```step()``` function takes/executes the generated action by RT-1 and returns a success message along with information about the environment state e.g. object or agent metadata, which can be saved to capture the trajectory taken by the agent for a given task +5) ```rollout_ai2thor.py```: interfaces between the finetuned RT-1 model (from a loaded checkpoint after finetuning on LaNMP) and the ```ai2thor_env.py``` Gym environment, in order to send observations from the AI2Thor environment to RT-1 and execute proposed action tokens by RT-1 on AI2Thor. Note that this file should not be run on a headless machine since it requires/deploys AI2Thor simulator GUI +6) ```rt1_pytorch/rt1_policy.py```: contains the RT-1 model implementation in PyTorch. The ```loss()``` function performs forward pass of RT-1 for training and ```act()``` function performs the forward pass during inference. +7) ```lanmp_dataloader/rt1_dataloader.py```: contains the ```DatasetManager``` class that extracts trajectories from the LaNMP ```sim_data.hdf5``` dataset file. The script automatically separates train and validation subsets according to different splits e.g. k-fold by scene, task wise or for diversity ablation. The ```DatasetManager``` also handles tokenizing/detokenizing the raw trajectory data into 256 discrete buckets, whilst also chunking trajectories across non-overlapping window lengths of 6 steps + +## Details about file arguments + +Most relevant files in this repository accept the same set of arguments that are detailed below +* ```dataset```: only for the ```main.py``` file, specifies the dataset on which the RT-1 model should be pretrained +* ```train-split```: specifies what fraction of the loaded dataset should be used for training v.s. evaluation +* ```eval-split```: specifies what fraction of the laoded dataset should be used for evaluation v.s. training +* ```epochs```: total number of passes over the all batches of the training set +* ```lr```: learning rate for cross-entropy loss of RT1 +* ```train-batch-size```: the number of trajectories from which to sample data for the current training batch +* ```eval-batch-size```: the number of trajectories from which to sample data for the current evaluation batch +* ```trajectory-length```: the window size (context history of ```trajecotry-length``` previous images) used for each trajectory when feeding data to RT-1 model; this is set to 6 based on the RT-1 implementation +* ```sentence-transformer```: the language embedding to apply on the language-specified task +* ```device```: the device to load the model/data onto during training/inference +* ```eval-freq```: the interval of batches at which to run evaluation/inference on the validation dataset (currently set to 0 in ```main_ft.py```) +* ```checkpoint-freq```: the interval of batches at which to save a checkpoint during training +* ```checkpoint-dir```: the directory path at which to save a checkpoint during training +* ```load-checkpoint```: (optional) path of the pretrained checkpoint to load for further fine-tuning +* ```wandb```: boolean determining if logging to weights and biases should happen +* ```eval-scene```: the AI2Thor scene number in the dataset that is held out of the training set for evaluation during k-fold cross validation across scenes +* ```split-type```: determines the split type (i.e. k-fold by scene, task wise or diversity ablation) between train and evaluation used by the ```DatasetManager``` in ```rt1_dataloader.py``` +* ```num-diversity-scenes```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of scenes to perform diversity ablation over i.e. maximum of 4 for LaNMP simulation data +* ```max-diversity-trajectories```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of trajectories that are divided evenly across the number of ```num-diversity-scenes``` scenes +* ```train-subbatch```: the batch size to use during training/finetuning +* ```eval-subbatch```: the batch size to use during evaluation + +## Checkpoint samples + +Please find the follow checkpoints samples that can be loaded to the RT-1 model. These can be found on the supplementary Google Drive associated with this project +* ```sample_checkpoints/pretrained_bridge```: the final checkpoint saved when pretraining the RT-1 model on the Bridge dataset +* ```sample_checkpoints/task_gen```: the final checkpoint saved after finetuning RT-1 model on the task-wise split for the task generalization experiment + +## Additional notes + +When running any of the finetuning or pretraining scripts, please ensure the following modules are loaded +```module load cuda/11.8.0-lpttyok``` +```module load cudnn/8.7.0.84-11.8-lg2dpd5``` diff --git a/models/main_models/rt1/ai2thor_env.py b/models/main_models/rt1/ai2thor_env.py new file mode 100644 index 000000000..60047ecfc --- /dev/null +++ b/models/main_models/rt1/ai2thor_env.py @@ -0,0 +1,641 @@ + +import copy +import numpy as np +from collections import Counter, OrderedDict +import ai2thor +from ai2thor.controller import Controller +from json import load +from os import path +import sys +sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred') +sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred/gen') +import gen.constants as constants +# import gen.utils.image_util as image_util +# from gen.utils import game_util +# from gen.utils.game_util import get_objects_of_type, get_obj_of_type_closest_to_obj +from random import choice, randint +from time import sleep +import pdb + +DEFAULT_RENDER_SETTINGS = {'renderImage': True, + 'renderDepthImage': True, + 'renderClassImage': False, + 'renderObjectImage': False, + } + +class ThorEnv(): + def __init__(self, task, max_episode_length = 1500): + + self.controller = None + self.last_event = None + + self.task = task + self.max_episode_length = max_episode_length + + + def reset(self, scene_name): + ''' + reset scene / start scene + ''' + print('Starting Ai2Thor Env...') + self.controller = Controller( + agentMode="arm", + massThreshold=None, + scene=scene_name, + visibilityDistance=1.5, + gridSize=0.25, + renderDepthImage=False, + renderInstanceSegmentation=False, + snapToGrid=False, + width=300, + height=300, + fieldOfView=60 + ) + self.last_event = self.controller.last_event + return self.last_event + + + def step(self, action, kwargs): + + if action in set(['MoveAgent','RotateAgent']): + + if action == 'MoveAgent': + + event_move = self.controller.step( + action="Teleport", + position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) + ) + + #execute a rotation body operation + event_rotate = self.controller.step( + action="RotateAgent", + degrees=kwargs['body_yaw_delta'], + returnToStart=False, + speed=1, + fixedDeltaTime=0.02 + ) + + success = event_move.metadata['lastActionSuccess'] + error = [event_move.metadata['errorMessage']] + self.last_event = event_move + + + elif action == 'RotateAgent': + + #execute a rotation body operation + event_rotate = self.controller.step( + action="RotateAgent", + degrees=kwargs['body_yaw_delta'], + returnToStart=False, + speed=1, + fixedDeltaTime=0.02 + ) + + event_move = self.controller.step( + action="Teleport", + position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) + ) + + success = event_rotate.metadata['lastActionSuccess'] + error = [event_rotate.metadata['errorMessage']] + self.last_event = event_rotate + + + + elif action == 'MoveArm': + + #execute smooth move arm operation + event = self.controller.step( + action="MoveArm", + position=dict(x=kwargs['arm_position'][0], y=kwargs['arm_position'][1], z=kwargs['arm_position'][2]), + coordinateSpace="world", + restrictMovement=False, + speed=1, + returnToStart=False, + fixedDeltaTime=0.02 + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == 'PickupObject': + + #execute pickup + event = self.controller.step( + action="PickupObject", + objectIdCandidates=[] + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == 'ReleaseObject': + + #execute pickup + event = self.controller.step( + action="ReleaseObject", + objectIdCandidates=[] + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action in set(['LookDown','LookUp']): + + #execute smooth change in pitch + events = self.smooth_look(action) + + success = events[-1].metadata['lastActionSuccess'] if len(events)>0 else False + error = [events[-1].metadata['errorMessage']] if len(events)>0 else ['Reached boundary of LookUp/LookDown'] + self.last_event = events[-1] if len(events)>0 else self.last_event + + + elif action == 'stop': + #stop the execution + event = self.controller.step(action="Done") + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == None: + #no operation to be done + success = True + error = [''] + + else: + + raise Exception('Error: the provided action {} is not valid'.format(action)) + + return success, error, self.last_event + + def step_old(self, action, smooth_nav=False): + ''' + overrides ai2thor.controller.Controller.step() for smooth navigation and goal_condition updates + ''' + if 'action' in action: + if smooth_nav: + if "MoveAhead" in action['action']: + self.smooth_move_ahead(action) + elif "Rotate" in action['action']: + self.smooth_rotate(action) + elif "Look" in action['action']: + self.smooth_look(action) + else: + super().step(action) + else: + if "LookUp" in action['action']: + self.look_angle(-constants.AGENT_HORIZON_ADJ) + elif "LookDown" in action['action']: + self.look_angle(constants.AGENT_HORIZON_ADJ) + else: + super().step(action) + else: + super().step(action) + + event = self.update_states(action) + self.check_post_conditions(action) + return event + + + + def noop(self): + ''' + do nothing + ''' + super().step(dict(action='Pass')) + + def smooth_move_ahead(self, action, render_settings=None): + ''' + smoother MoveAhead + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + smoothing_factor = constants.RECORD_SMOOTHING_FACTOR + new_action = copy.deepcopy(action) + new_action['moveMagnitude'] = constants.AGENT_STEP_SIZE / smoothing_factor + + new_action['renderImage'] = render_settings['renderImage'] + new_action['renderClassImage'] = render_settings['renderClassImage'] + new_action['renderObjectImage'] = render_settings['renderObjectImage'] + new_action['renderDepthImage'] = render_settings['renderDepthImage'] + + events = [] + for xx in range(smoothing_factor - 1): + event = super().step(new_action) + if event.metadata['lastActionSuccess']: + events.append(event) + + event = super().step(new_action) + if event.metadata['lastActionSuccess']: + events.append(event) + return events + + def smooth_rotate(self, action, render_settings=None): + ''' + smoother RotateLeft and RotateRight + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) + position = event.metadata['agent']['position'] + rotation = event.metadata['agent']['rotation'] + start_rotation = rotation['y'] + if action['action'] == 'RotateLeft': + end_rotation = (start_rotation - 90) + else: + end_rotation = (start_rotation + 90) + + events = [] + for xx in np.arange(.1, 1.0001, .1): + if xx < 1: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + } + event = super().step(teleport_action) + else: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + } + event = super().step(teleport_action) + + if event.metadata['lastActionSuccess']: + events.append(event) + return events + + def smooth_look(self, action, render_settings=None): + ''' + smoother LookUp and LookDown + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + start_horizon = event.metadata['agent']['cameraHorizon'] + rotation = np.round(event.metadata['agent']['rotation']['y'], 4) + end_horizon = start_horizon + constants.AGENT_HORIZON_ADJ * (1 - 2 * int(action == 'LookUp')) + position = event.metadata['agent']['position'] + + events = [] + for xx in np.arange(.1, 1.0001, .1): + if xx < 1: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': rotation, + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + 'standing': True, + } + event = self.controller.step(teleport_action) + else: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': rotation, + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), + 'standing':True, + } + event = self.controller.step(teleport_action) + + if event.metadata['lastActionSuccess']: + events.append(event) + + return events + + def rotate_angle(self, angle, render_settings=None): + ''' + rotate at a specific angle + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) + position = event.metadata['agent']['position'] + rotation = event.metadata['agent']['rotation'] + start_rotation = rotation['y'] + end_rotation = start_rotation + angle + + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(end_rotation, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + } + event = super().step(teleport_action) + return event + + def to_thor_api_exec(self, action, object_id="", smooth_nav=False): + # TODO: parametrized navigation commands + + if "RotateLeft" in action: + action = dict(action="RotateLeft", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "RotateRight" in action: + action = dict(action="RotateRight", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "MoveAhead" in action: + action = dict(action="MoveAhead", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "LookUp" in action: + action = dict(action="LookUp", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "LookDown" in action: + action = dict(action="LookDown", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "OpenObject" in action: + action = dict(action="OpenObject", + objectId=object_id, + moveMagnitude=1.0) + event = self.step(action) + elif "CloseObject" in action: + action = dict(action="CloseObject", + objectId=object_id, + forceAction=True) + event = self.step(action) + elif "PickupObject" in action: + action = dict(action="PickupObject", + objectId=object_id) + event = self.step(action) + elif "PutObject" in action: + inventory_object_id = self.last_event.metadata['inventoryObjects'][0]['objectId'] + action = dict(action="PutObject", + objectId=object_id, + forceAction=True, + placeStationary=True) + event = self.step(action) + elif "ToggleObjectOn" in action: + action = dict(action="ToggleObjectOn", + objectId=object_id) + event = self.step(action) + + elif "ToggleObjectOff" in action: + action = dict(action="ToggleObjectOff", + objectId=object_id) + event = self.step(action) + elif "SliceObject" in action: + # check if agent is holding knife in hand + inventory_objects = self.last_event.metadata['inventoryObjects'] + if len(inventory_objects) == 0 or 'Knife' not in inventory_objects[0]['objectType']: + raise Exception("Agent should be holding a knife before slicing.") + + action = dict(action="SliceObject", + objectId=object_id) + event = self.step(action) + else: + raise Exception("Invalid action. Conversion to THOR API failed! (action='" + str(action) + "')") + + return event, action + + def take_action(self, word_action, num_action, rand_agent=False): + i = 0 + incr = 0.025 + x = 0 + y = 0 + z = 0 + fixedDeltaTime = 0.02 + move = 0.2 + a = None + + if rand_agent: + all_word_actions = ['PickupObject','ReleaseObject', 'LookUp', 'LookDown', 'MoveArm', 'MoveArmBase', 'RotateAgent', 'MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft', 'stop'] + rand_word_action = choice(all_word_actions) + if rand_word_action in ["stop"]: + return "stop", None + elif rand_word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: + a = dict(action = rand_word_action) + elif rand_word_action in ['MoveArm', 'MoveArmBase']: + global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] + curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] + rand_x_indx, rand_y_indx, rand_z_indx = randint(1, 256), randint(1, 256), randint(1, 256) # starts at 1 to skip NoOp + x_del, y_del, z_del = self.bins["4"][rand_x_indx], self.bins["5"][rand_y_indx], self.bins["6"][rand_z_indx] + new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del + a = dict(action='MoveArm', position=dict(x=new_x, y=new_y, z=new_z),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) + elif rand_word_action in ['RotateAgent']: + rand_yaw_indx = randint(1, 256) + new_yaw = self.bins["3"][rand_yaw_indx] + a = dict(action=rand_word_action, degrees=new_yaw, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + else: # move base + a = dict(action=rand_word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + + else: + if word_action in ['NoOp']: + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + if word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: + a = dict(action = word_action) + elif word_action in ['MoveArm', 'MoveArmBase']: + global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] + curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] + x_del, y_del, z_del = self.bins["4"][num_action[0]], self.bins["5"][num_action[1]], self.bins["6"][num_action[2]] + if x_del == -1000 or y_del == -1000 or z_del == -1000: # if any of them are NoOp then skip all. Can do it another way where only skip the specific axis + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del + a = dict(action='MoveArm',position=dict(x=new_x, y=new_z, z=new_y),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) + elif word_action in ['RotateAgent']: + yaw_del = num_action.item() + new_yaw = self.bins["3"][yaw_del] + if new_yaw == -1000: #make it variable later + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + a = dict(action=word_action, degrees=new_yaw,returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + else: # move base + a = dict(action=word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + + sleep(0.5) #for debugging/movement analysis + event = self.controller.step(a) + success = event.metadata['lastActionSuccess'] + error = event.metadata['errorMessage'] + self.last_event = event + #for debugging/movement analysis + sleep(0.5) + if rand_agent: + print(f"Random Word Action: {rand_word_action} ", end="\r") + # else: + # print(f"Word Action: {word_action} ", end="\r") + # print(f"Num Action: {num_action} ", end="\r") + + return success, error, self.last_event.metadata + + + + +if __name__ == '__main__': + + SCENE_NAME = 'FloorPlan_Train5_1' + TESTED_STEPS = 200 + + test = ThorEnv('Walk to the living room') + + event = test.reset(scene_name=SCENE_NAME) + + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + agent_holding = np.array([]) + + + test.controller.step( + action="MoveArmBase", + y=0.0, + speed=1, + returnToStart=True, + fixedDeltaTime=0.02 + ) + + + for i in range(TESTED_STEPS): + + print(''' + (1) Move X+ + (2) Move X- + (3) Move Z+ + (4) Move Z- + (5) Rotate Left + (6) Rotate Right + (7) Rotate Up + (8) Rotate Down + (9) Open Gripper + (0) Close Gripper + (h) Move Gripper up + (n) Move Gripper down + (b) Move Gripper left + (m) Move Gripper right + (z) Move Gripper forward + (x) Move Gripper backwards + ''') + + + action = input('>') + + + if action == '1': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[0] += 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '2': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[0] -= 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '3': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[2] += 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '4': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[2] -= 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '5': + + success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta': -90}) + + elif action == '6': + + success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta':+90}) + + elif action == '7': + + success, error, event = test.step('LookUp', {}) + + elif action == '8': + + success, error, event = test.step('LookDown', {}) + + elif action == '9': + + success, error, event = test.step('PickupObject', {}) + + elif action == '0': + + success, error, event = test.step('ReleaseObject', {}) + + elif action == 'h': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[1] += 0.20 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'n': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[1] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'b': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[0] += 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'm': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[0] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'z': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[2] += 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'x': + + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[2] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) diff --git a/models/main_models/rt1/data.py b/models/main_models/rt1/data.py new file mode 100644 index 000000000..71bff29ba --- /dev/null +++ b/models/main_models/rt1/data.py @@ -0,0 +1,536 @@ +# Taken from https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit#gid=0 +import abc +import dataclasses +from typing import Any, Dict, Iterable, Optional, Union +import pdb +import numpy as np +import reverb +import tensorflow as tf +import tensorflow_datasets as tfds +import tree +from rlds import rlds_types, transformations + +tf.config.experimental.set_visible_devices([], "GPU") + + +def dataset2path(name): + if name == "robo_net": + version = "1.0.0" + elif name == "language_table": + version = "0.0.1" + else: + version = "0.1.0" + return f"gs://gresearch/robotics/{name}/{version}" + + +def as_gif(images, path="temp.gif"): + # Render the images as the gif: + images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0) + gif_bytes = open(path, "rb").read() + return gif_bytes + + +def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec: + """Converts a tfds Feature into a TensorSpec.""" + + def _get_feature_spec(nested_feature: tfds.features.FeatureConnector): + if isinstance(nested_feature, tf.DType): + return tf.TensorSpec(shape=(), dtype=nested_feature) + else: + return nested_feature.get_tensor_spec() + + # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to + # make sure we deal with the nested structure. + return tf.nest.map_structure(_get_feature_spec, feature) + + +def _encoded_feature( + feature: Optional[tfds.features.FeatureConnector], + image_encoding: Optional[str], + tensor_encoding: Optional[tfds.features.Encoding], +): + """Adds encoding to Images and/or Tensors.""" + + def _apply_encoding( + feature: tfds.features.FeatureConnector, + image_encoding: Optional[str], + tensor_encoding: Optional[tfds.features.Encoding], + ): + if image_encoding and isinstance(feature, tfds.features.Image): + return tfds.features.Image( + shape=feature.shape, + dtype=feature.dtype, + use_colormap=feature.use_colormap, + encoding_format=image_encoding, + ) + if ( + tensor_encoding + and isinstance(feature, tfds.features.Tensor) + and feature.dtype != tf.string + ): + return tfds.features.Tensor( + shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding + ) + return feature + + if not feature: + return None + return tf.nest.map_structure( + lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature + ) + + +@dataclasses.dataclass +class RLDSSpec(metaclass=abc.ABCMeta): + """Specification of an RLDS Dataset. + + It is used to hold a spec that can be converted into a TFDS DatasetInfo or + a `tf.data.Dataset` spec. + """ + + observation_info: Optional[tfds.features.FeatureConnector] = None + action_info: Optional[tfds.features.FeatureConnector] = None + reward_info: Optional[tfds.features.FeatureConnector] = None + discount_info: Optional[tfds.features.FeatureConnector] = None + step_metadata_info: Optional[tfds.features.FeaturesDict] = None + episode_metadata_info: Optional[tfds.features.FeaturesDict] = None + + def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]: + """Obtains the TensorSpec of an RLDS step.""" + step = {} + if self.observation_info: + step[rlds_types.OBSERVATION] = _features_to_tensor_spec( + self.observation_info + ) + if self.action_info: + step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info) + if self.discount_info: + step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info) + if self.reward_info: + step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info) + if self.step_metadata_info: + for k, v in self.step_metadata_info.items(): + step[k] = _features_to_tensor_spec(v) + + step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool) + step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool) + step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool) + return step + + def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]: + """Obtains the TensorSpec of an RLDS step.""" + episode = {} + episode[rlds_types.STEPS] = tf.data.DatasetSpec( + element_spec=self.step_tensor_spec() + ) + if self.episode_metadata_info: + for k, v in self.episode_metadata_info.items(): + episode[k] = _features_to_tensor_spec(v) + return episode + + def to_dataset_config( + self, + name: str, + image_encoding: Optional[str] = None, + tensor_encoding: Optional[tfds.features.Encoding] = None, + citation: Optional[str] = None, + homepage: Optional[str] = None, + description: Optional[str] = None, + overall_description: Optional[str] = None, + ) -> tfds.rlds.rlds_base.DatasetConfig: + """Obtains the DatasetConfig for TFDS from the Spec.""" + return tfds.rlds.rlds_base.DatasetConfig( + name=name, + description=description, + overall_description=overall_description, + homepage=homepage, + citation=citation, + observation_info=_encoded_feature( + self.observation_info, image_encoding, tensor_encoding + ), + action_info=_encoded_feature( + self.action_info, image_encoding, tensor_encoding + ), + reward_info=_encoded_feature( + self.reward_info, image_encoding, tensor_encoding + ), + discount_info=_encoded_feature( + self.discount_info, image_encoding, tensor_encoding + ), + step_metadata_info=_encoded_feature( + self.step_metadata_info, image_encoding, tensor_encoding + ), + episode_metadata_info=_encoded_feature( + self.episode_metadata_info, image_encoding, tensor_encoding + ), + ) + + def to_features_dict(self): + """Returns a TFDS FeaturesDict representing the dataset config.""" + step_config = { + rlds_types.IS_FIRST: tf.bool, + rlds_types.IS_LAST: tf.bool, + rlds_types.IS_TERMINAL: tf.bool, + } + + if self.observation_info: + step_config[rlds_types.OBSERVATION] = self.observation_info + if self.action_info: + step_config[rlds_types.ACTION] = self.action_info + if self.discount_info: + step_config[rlds_types.DISCOUNT] = self.discount_info + if self.reward_info: + step_config[rlds_types.REWARD] = self.reward_info + + if self.step_metadata_info: + for k, v in self.step_metadata_info.items(): + step_config[k] = v + + if self.episode_metadata_info: + return tfds.features.FeaturesDict( + { + rlds_types.STEPS: tfds.features.Dataset(step_config), + **self.episode_metadata_info, + } + ) + else: + return tfds.features.FeaturesDict( + { + rlds_types.STEPS: tfds.features.Dataset(step_config), + } + ) + + +RLDS_SPEC = RLDSSpec +TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]] + + +@dataclasses.dataclass +class TrajectoryTransform(metaclass=abc.ABCMeta): + """Specification the TrajectoryTransform applied to a dataset of episodes. + + A TrajectoryTransform is a set of rules transforming a dataset + of RLDS episodes to a dataset of trajectories. + This involves three distinct stages: + - An optional `episode_to_steps_map_fn(episode)` is called at the episode + level, and can be used to select or modify steps. + - Augmentation: an `episode_key` could be propagated to `steps` for + debugging. + - Selection: Particular steps can be selected. + - Stripping: Features can be removed from steps. Prefer using `step_map_fn`. + - An optional `step_map_fn` is called at the flattened steps dataset for each + step, and can be used to featurize a step, e.g. add/remove features, or + augument images + - A `pattern` leverages DM patterns to set a rule of slicing an episode to a + dataset of overlapping trajectories. + + Importantly, each TrajectoryTransform must define a `expected_tensor_spec` + which specifies a nested TensorSpec of the resulting dataset. This is what + this TrajectoryTransform will produce, and can be used as an interface with + a neural network. + """ + + episode_dataset_spec: RLDS_SPEC + episode_to_steps_fn_dataset_spec: RLDS_SPEC + steps_dataset_spec: Any + pattern: reverb.structured_writer.Pattern + episode_to_steps_map_fn: Any + expected_tensor_spec: TENSOR_SPEC + step_map_fn: Optional[Any] = None + + def get_for_cached_trajectory_transform(self): + """Creates a copy of this traj transform to use with caching. + + The returned TrajectoryTransfrom copy will be initialized with the default + version of the `episode_to_steps_map_fn`, because the effect of that + function has already been materialized in the cached copy of the dataset. + Returns: + trajectory_transform: A copy of the TrajectoryTransform with overridden + `episode_to_steps_map_fn`. + """ + traj_copy = dataclasses.replace(self) + traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec + traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS] + return traj_copy + + def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset): + """Applies this TrajectoryTransform to the dataset of episodes.""" + + # Convert the dataset of episodes to the dataset of steps. + steps_dataset = episodes_dataset.map( + self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE + ).flat_map(lambda x: x) + + return self._create_pattern_dataset(steps_dataset) + + def transform_steps_rlds_dataset( + self, steps_dataset: tf.data.Dataset + ) -> tf.data.Dataset: + """Applies this TrajectoryTransform to the dataset of episode steps.""" + + return self._create_pattern_dataset(steps_dataset) + + def create_test_dataset( + self, + ) -> tf.data.Dataset: + """Creates a test dataset of trajectories. + + It is guaranteed that the structure of this dataset will be the same as + when flowing real data. Hence this is a useful construct for tests or + initialization of JAX models. + Returns: + dataset: A test dataset made of zeros structurally identical to the + target dataset of trajectories. + """ + zeros = transformations.zeros_from_spec(self.expected_tensor_spec) + + return tf.data.Dataset.from_tensors(zeros) + + def _create_pattern_dataset( + self, steps_dataset: tf.data.Dataset + ) -> tf.data.Dataset: + """Create PatternDataset from the `steps_dataset`.""" + config = create_structured_writer_config("temp", self.pattern) + + # Further transform each step if the `step_map_fn` is provided. + if self.step_map_fn: + steps_dataset = steps_dataset.map(self.step_map_fn) + pattern_dataset = reverb.PatternDataset( + input_dataset=steps_dataset, + configs=[config], + respect_episode_boundaries=True, + is_end_of_episode=lambda x: x[rlds_types.IS_LAST], + ) + return pattern_dataset + + +class TrajectoryTransformBuilder(object): + """Facilitates creation of the `TrajectoryTransform`.""" + + def __init__( + self, + dataset_spec: RLDS_SPEC, + episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS], + step_map_fn=None, + pattern_fn=None, + expected_tensor_spec=None, + ): + self._rds_dataset_spec = dataset_spec + self._steps_spec = None + self._episode_to_steps_map_fn = episode_to_steps_map_fn + self._step_map_fn = step_map_fn + self._pattern_fn = pattern_fn + self._expected_tensor_spec = expected_tensor_spec + + def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform: + """Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.""" + + if validate_expected_tensor_spec and self._expected_tensor_spec is None: + raise ValueError("`expected_tensor_spec` must be set.") + + episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec) + + steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn) + + episode_to_steps_fn_dataset_spec = self._rds_dataset_spec + + if self._step_map_fn is not None: + steps_ds = steps_ds.map(self._step_map_fn) + + zeros_spec = transformations.zeros_from_spec( + steps_ds.element_spec + ) # pytype: disable=wrong-arg-types + + ref_step = reverb.structured_writer.create_reference_step(zeros_spec) + + pattern = self._pattern_fn(ref_step) + + steps_ds_spec = steps_ds.element_spec + + target_tensor_structure = create_reverb_table_signature( + "temp_table", steps_ds_spec, pattern + ) + + if ( + validate_expected_tensor_spec + and self._expected_tensor_spec != target_tensor_structure + ): + raise RuntimeError( + "The tensor spec of the TrajectoryTransform doesn't " + "match the expected spec.\n" + "Expected:\n%s\nActual:\n%s\n" + % ( + str(self._expected_tensor_spec).replace( + "TensorSpec", "tf.TensorSpec" + ), + str(target_tensor_structure).replace("TensorSpec", "tf.TensorSpec"), + ) + ) + + return TrajectoryTransform( + episode_dataset_spec=self._rds_dataset_spec, + episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec, + steps_dataset_spec=steps_ds_spec, + pattern=pattern, + episode_to_steps_map_fn=self._episode_to_steps_map_fn, + step_map_fn=self._step_map_fn, + expected_tensor_spec=target_tensor_structure, + ) + + +def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC): + """Creates a zero valued dataset of episodes for the given RLDS Spec.""" + + def add_steps(episode, step_spec): + episode[rlds_types.STEPS] = transformations.zero_dataset_like( + tf.data.DatasetSpec(step_spec) + ) + if "fake" in episode: + del episode["fake"] + return episode + + episode_without_steps_spec = { + k: v + for k, v in rlds_spec.episode_tensor_spec().items() + if k != rlds_types.STEPS + } + + if episode_without_steps_spec: + episodes_dataset = transformations.zero_dataset_like( + tf.data.DatasetSpec(episode_without_steps_spec) + ) + else: + episodes_dataset = tf.data.Dataset.from_tensors({"fake": ""}) + + episodes_dataset_with_steps = episodes_dataset.map( + lambda episode: add_steps(episode, rlds_spec.step_tensor_spec()) + ) + return episodes_dataset_with_steps + + +def create_reverb_table_signature( + table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern +) -> reverb.reverb_types.SpecNest: + config = create_structured_writer_config(table_name, pattern) + reverb_table_spec = reverb.structured_writer.infer_signature( + [config], steps_dataset_spec + ) + return reverb_table_spec + + +def create_structured_writer_config( + table_name: str, pattern: reverb.structured_writer.Pattern +) -> Any: + config = reverb.structured_writer.create_config( + pattern=pattern, table=table_name, conditions=[] + ) + return config + + +def n_step_pattern_builder(n: int) -> Any: + """Creates trajectory of length `n` from all fields of a `ref_step`.""" + + def transform_fn(ref_step): + traj = {} + for key in ref_step: + if isinstance(ref_step[key], dict): + transformed_entry = tree.map_structure( + lambda ref_node: ref_node[-n:], ref_step[key] + ) + traj[key] = transformed_entry + else: + traj[key] = ref_step[key][-n:] + + return traj + + return transform_fn + + +def get_observation_and_action_from_step(step): + return { + "observation": { + "image": step["observation"]["image"], + "embedding": step["observation"]["natural_language_embedding"], + "instruction": step["observation"]["natural_language_instruction"], + }, + # Decode one hot discrete actions + "action": { + k: tf.argmax(v, axis=-1) if v.dtype == tf.int32 else v + for k, v in step["action"].items() + }, + } + + +def create_dataset( + datasets=["fractal20220817_data"], + split="train", + trajectory_length=6, + batch_size=32, + num_epochs=1, +) -> Iterable[Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]]: + trajectory_datasets = [] + #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) + for dataset in datasets: + #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) + + + # b = tfds.builder_from_directory(builder_dir='/oscar/data/stellex/shared/bridge/0.1.0') + #'~/data/sjulian2/bridge/0.1.0/' + # dataset = tfds.load('bridge', split='train') + #b = tfds.builder_from_directory(builder_dir='/users/sjulian2/data/sjulian2/jaco_play/0.1.0') + # b = tfds.builder_from_directory(builder_dir=dataset2path(dataset)) + + # pdb.set_trace() + b = tfds.builder_from_directory(builder_dir = '/oscar/data/stellex/ssunda11/NPM-Dataset/rt1-pytorch/rt1_dataset/0.1.0') + # ds = tfds.load("fractal20220817_data:0.1.0", data_dir="gs://gresearch/robotics") + + ds = b.as_dataset(split=split) + + # The RLDSSpec for the RT1 dataset. + rt1_spec = RLDSSpec( + observation_info=b.info.features["steps"]["observation"], + action_info=b.info.features["steps"]["action"], + ) + + trajectory_transform = TrajectoryTransformBuilder( + rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length) + ).build(validate_expected_tensor_spec=False) + + trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds) + #pdb.set_trace() + trajectory_datasets.append(trajectory_dataset) + + trajectory_dataset = tf.data.Dataset.sample_from_datasets(trajectory_datasets) + + trajectory_dataset = trajectory_dataset.map( + get_observation_and_action_from_step, num_parallel_calls=tf.data.AUTOTUNE + ) + + # Shuffle, batch, prefetch, repeat + trajectory_dataset = trajectory_dataset.shuffle(batch_size * 16) + trajectory_dataset = trajectory_dataset.batch( + batch_size, + drop_remainder=True, + num_parallel_calls=tf.data.AUTOTUNE, + deterministic=False, + ) + trajectory_dataset = trajectory_dataset.repeat(num_epochs) + trajectory_dataset = trajectory_dataset.prefetch(tf.data.AUTOTUNE) + # pdb.set_trace() + return iter(trajectory_dataset.as_numpy_iterator()) + + +if __name__ == "__main__": + #pdb.set_trace() + ds = create_dataset(datasets=["fractal20220817_data"], split="train[:10]") + it = next(ds) + + def print_shape(x): + if isinstance(x, dict): + shapes = tree.map_structure(lambda x: x.shape, x) + else: + shapes = x.shape + return shapes + + shapes = tree.map_structure(print_shape, it) + print(shapes) diff --git a/models/main_models/rt1/figures/rt1.png b/models/main_models/rt1/figures/rt1.png new file mode 100644 index 0000000000000000000000000000000000000000..17426537180d0baaa5b824e60bd94298ce6d5c35 GIT binary patch literal 135877 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

Q!2CmkZcV&= zE+D`>`W_^B{DHWHk_O;J9rAJehtNMnEe>joZl0HySb1jUe(#U${00*%J^=++h&Kb@>ZJ;S*8W`YoJx)*Zf3>zW_*YW z81~rWl#i!SDs(OoS~!?vmv3Oiqc6_+UKX@%M4rcV=e{Oi2pK(;08wpITi|5R7i%H6}G@V%pSDL zJoa%3sDX5buxD4dFP4>sCzdwXQ|W{nk<3Fbu?0qREEcsvOF2g!OUrArn_yMml@}T< zO8!?}M3=7k@PlTlEx3ad z!G}6e72vI`uk*)-N^16YF6rH1v@qAt29{^PhUW~wctqQ_8~%r1hvIX20ICjG(j7_Z z)$@sss^78UaIivynHhLo5&^0j1}>ja{<$pAV3n`eieN+7!Gf>{WD;{0{5{s$%GMw8!-3OdF94dah*mc@A_IPzOZB|3O`K6a6`>cOg(csfx4oBx z{`m&#bP7Xm&k!scgo*Z_=z8Jh=+PM~JV90zhHj;!ke#SHv>H}oHXOf${Xt8O=~HfZ zn0miq5CksNRIcRNczM5^`OgvFA7YdWkq`x!k4?J#+>0xFJkqZq0FOhsF!O$BP@Cz) zS_S;wP*V}mLahUCCO_UM=op0Lv*gPFmt-B`%?&1YykZ|xoy;9jS95tn-V}Y&9LLa+ z8S;38Gq#CChX(0Z)OJGbmoV5FB4z3)SjPm^#+Gz7o%){BRJ>_1Umpictd)_HRAt9M zy^PsxR{C_g%6X`yqETSgpLdj&dp-^FyF23NCFOGmgbx{rN0vg07G>yxVS&(lkm@_@Yf%MDVw*CwEDV8#sp+tWft$N#Hc``gY!`=2^c;6nfXUn40i{g0*a_c$ub|5tPQ|3NH- Y#5u$X1_XKM0t5X>iOGvr3mXRgFLU@ATL1t6 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/README.md b/models/main_models/rt1/gen/README.md new file mode 100644 index 000000000..607e80b9b --- /dev/null +++ b/models/main_models/rt1/gen/README.md @@ -0,0 +1,77 @@ +# Data Generation + +We also provide code for generating PDDL-based expert demonstrations. This can be used to extend the training data, albiet without human language annotations. + +## Installation + +Get dependencies and compile the planner: +```bash +$ sudo apt-get install ffmpeg flex bison + +$ cd $ALFRED_ROOT/gen/ff_planner +$ make +``` + +## Generation + +To spawn multiple generation threads: + +```bash +$ cd $ALFRED_ROOT/gen +$ python scripts/generate_trajectories.py --save_path data/new_trajs --in_parallel --debug --num_threads 2 +``` + +This will sample tasks based on the sampling mechanism described in the paper. You might notice a lot of failed executions, which are automatically discarded by the script. + +**Note:** The first time you run the generation script, use `--num_threads 1` to allow the script to download the THOR binary. + +## Replay Checks + +In parallel with generation, replay saved trajectories to check if they are reproducable: + +```bash +$ python scripts/replay_checks.py --data_path data/new_trajs --in_parallel +``` +This will ensure that the interaction masks and expert actions can be deterministically executed in THOR. + +## Data Augmentation + +Currently, the dataset only provides 300x300 RGB images. However, each trajectory can be replayed to save any additional info available from the simulator. See the [augment_trajectories.py](scripts/augment_trajectories.py) script as an example for saving 600x600 RGB, depth and instance segmentation masks from the existing dataset: + +```bash +python scripts/augment_trajectories.py --data_path data/json_2.1.0 --num_threads 2 --smooth_nav --time_delays +``` + +![](../media/aug.png) + +Note that these files consume a lot of storage space. + +## PDDL Tasks + +The goals for the planner are specified in [goal_library.py](goal_library.py). Here is a simple pick-and-place PDDL goal definition: + +``` +# basic pick and place (e.g: "put the apple in the microwave") +gdict["pick_and_place_simple"] = ''' + (:goal + (and + ;; make sure all the cabinets and doors are closed in the end + (forall (?re # receptacle) + (not (opened ?re)) + ) + + ;; make sure some object {obj} exists inside some receptacle {recep} + (exists (?r # receptacle) + (exists (?o # object) + (and + (inReceptacle ?o ?r) + (objectType ?o {obj}Type) + (receptacleType ?r {recep}Type) + ) + ) + ) + ) + ) +) +``` + diff --git a/models/main_models/rt1/gen/__init__.py b/models/main_models/rt1/gen/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/gen/agents/agent_base.py b/models/main_models/rt1/gen/agents/agent_base.py new file mode 100644 index 000000000..34cb3f725 --- /dev/null +++ b/models/main_models/rt1/gen/agents/agent_base.py @@ -0,0 +1,60 @@ +import copy +import time +import numpy as np + + +class AgentBase(object): + def __init__(self, thread_id=0, game_state=None): + assert(game_state is not None) + self.game_state = game_state + self.thread_id = thread_id + self.timers = np.zeros((2, 2)) + self.total_frame_count = 0 + self.current_frame_count = 0 + self.gt_graph = None + self.bounds = None + self.pose = None + self.terminal = False + self.num_invalid_actions = 0 + self.total_num_invalid_actions = 0 + + def setup_problem(self, game_state_problem_args, scene=None, objs=None): + self.game_state.setup_problem(**game_state_problem_args, scene=scene, objs=objs) + + def reset(self, game_state_reset_args, scene=None, objs=None): + self.game_state.reset(**game_state_reset_args, scene=scene, objs=objs) + + self.timers = np.zeros((2, 2)) + self.current_frame_count = 0 + self.gt_graph = None + self.bounds = None + self.pose = None + self.terminal = False + self.num_invalid_actions = 0 + + self.total_frame_count += 1 + self.gt_graph = self.game_state.gt_graph + self.bounds = self.game_state.bounds + self.pose = self.game_state.pose + + def step(self, action): + self.total_frame_count += 1 + self.current_frame_count += 1 + t_start = time.time() + self.game_state.step(action) + if not self.game_state.event.metadata['lastActionSuccess']: + self.num_invalid_actions += 1 + self.total_num_invalid_actions += 1 + self.timers[0, 0] += time.time() - t_start + self.timers[0, 1] += 1 + if self.timers[0, 1] % 100 == 0: + print('game state step time %.3f' % (self.timers[0, 0] / self.timers[0, 1])) + self.timers[0, :] = 0 + self.pose = self.game_state.pose + + def get_action(self, action_ind): + action = copy.deepcopy(self.game_state.action_space[action_ind]) + if action['action'] == 'End': + # Remove other arguments + action = {'action': 'End'} + return action diff --git a/models/main_models/rt1/gen/agents/deterministic_planner_agent.py b/models/main_models/rt1/gen/agents/deterministic_planner_agent.py new file mode 100644 index 000000000..b67e25457 --- /dev/null +++ b/models/main_models/rt1/gen/agents/deterministic_planner_agent.py @@ -0,0 +1,26 @@ +from agents.semantic_map_planner_agent import SemanticMapPlannerAgent + + +class DeterministicPlannerAgent(SemanticMapPlannerAgent): + def __init__(self, thread_id=0, game_state=None): + super(DeterministicPlannerAgent, self).__init__(thread_id, game_state) + self.action_sequence = None + self.question = None + + def reset(self, seed=None, info=None, scene=None, objs=None): + info = super(DeterministicPlannerAgent, self).reset(seed, info, scene=scene, objs=objs) + self.action_sequence = ['Plan', 'End'] + return info + + def step(self, action, executing_plan=False): + if not executing_plan: + self.action_sequence = self.action_sequence[1:] + super(DeterministicPlannerAgent, self).step(action) + + def get_action(self, action_ind=None): + assert(action_ind is None) + return {'action': self.action_sequence[0]} + + def get_reward(self): + return 0, self.terminal + diff --git a/models/main_models/rt1/gen/agents/plan_agent.py b/models/main_models/rt1/gen/agents/plan_agent.py new file mode 100644 index 000000000..eda12f215 --- /dev/null +++ b/models/main_models/rt1/gen/agents/plan_agent.py @@ -0,0 +1,94 @@ +import constants +from agents.agent_base import AgentBase +from game_states.planned_game_state import PlannedGameState +from utils import game_util + + +class PlanAgent(AgentBase): + def __init__(self, thread_id=0, game_state=None, controller_agent=None): + super(PlanAgent, self).__init__(thread_id, game_state) + assert(isinstance(game_state, PlannedGameState)) + self.controller_agent = controller_agent + self.planned = False + + def reset(self): + self.planned = False + + def execute_plan(self): + step_count = 0 + self.planned = True + self.controller_agent.planning = True + if constants.OPEN_LOOP: + plan = self.game_state.get_current_plan(force_update=True) + + if plan[0]['action'] == 'End': + raise ValueError('Empty plan is successful, no work to do') + + elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: + print ("Planning failed. Possibly because the goal was already satisfied") + raise ValueError("Symbolic Planning Failed") + + for idx, plan_action in enumerate(plan): + self.save_plan(plan, idx) + + if plan_action['action'] == 'GotoLocation': + plan_action = self.game_state.get_teleport_action(plan_action) + elif plan_action['action'] == 'End': + break + self.controller_agent.step(plan_action, executing_plan=True) + step_count += 1 + if self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH: + break + else: + past_plans = [] + plan = self.game_state.get_current_plan(force_update=True) + + if plan[0]['action'] == 'End': + raise ValueError('Empty plan is successful, no work to do') + elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: + print("Symbolic Planning Failed") + raise ValueError("Symbolic Planning Failed") + + plan_action = plan[0] + if constants.USE_DETERMINISTIC_CONTROLLER: + # Don't fail right away, just rotate a few times. + rotations = 0 + while rotations < 4 and (plan_action is None or plan_action['action'] == 'End'): + action = {'action': 'RotateLeft'} + self.controller_agent.step(action, executing_plan=True) + rotations += 1 + plan = self.game_state.get_current_plan(force_update=True) + plan_action = plan[0] + + while not(plan_action is None or plan_action['action'] == 'End'): + self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) + + # save data + self.save_plan(plan, 0) + + step_count += 1 + past_plans.append(plan) + if len(past_plans) > 5: + past_plans = past_plans[-5:] + plan = self.game_state.get_current_plan(force_update=True) + if plan[0]['action'] == 'End': + break + if (step_count >= constants.MAX_PLANNER_STEP_COUNT or + self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH): + # Too many steps, plan may be looping. + break + if len(plan) > 1 and any([plan == past_plan for past_plan in past_plans]): + plan_action = plan[0] + self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) + step_count += 1 + plan = plan[1:] + plan_action = plan[0] + + self.controller_agent.planning = False + + def save_plan(self, plan, idx=0): + plan_action = plan[idx] + constants.data_dict['plan']['high_pddl'].append({"high_idx": len(constants.data_dict['plan']['high_pddl']), + "planner_action": plan_action, + "discrete_action": game_util.get_discrete_hl_action(plan, idx)}) + constants.data_dict['template']['high_descs'].append(game_util.get_templated_action_str(plan, idx)) diff --git a/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py b/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py new file mode 100644 index 000000000..497ee242c --- /dev/null +++ b/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py @@ -0,0 +1,72 @@ +import glob +import cv2 +import constants +from agents.agent_base import AgentBase +from agents.plan_agent import PlanAgent +from game_states.planned_game_state import PlannedGameState + + +class SemanticMapPlannerAgent(AgentBase): + def __init__(self, thread_id=0, game_state=None): + assert(isinstance(game_state, PlannedGameState)) + super(SemanticMapPlannerAgent, self).__init__(thread_id, game_state) + + self.plan_agent = PlanAgent(thread_id, game_state, self) + self.planning = False + + def reset(self, seed=None, info=None, scene=None, objs=None): + self.planning = False + info = self.game_state.get_setup_info(info, scene=scene)[0] + super(SemanticMapPlannerAgent, self).reset({'seed': seed, 'info': info}, scene=scene, objs=objs) + if self.plan_agent is not None: + self.plan_agent.reset() + return info + + def setup_problem(self, game_state_problem_args, scene=None, objs=None): + super(SemanticMapPlannerAgent, self).setup_problem(game_state_problem_args, scene=scene, objs=objs) + self.pose = self.game_state.pose + + def get_reward(self): + raise NotImplementedError + + def step(self, action, executing_plan=False): + if action['action'] == 'End': + self.current_frame_count += 1 + self.total_frame_count += 1 + self.terminal = True + + if constants.RECORD_VIDEO_IMAGES: + im_ind = len(glob.glob(constants.save_path + '/*.png')) + for _ in range(10): + cv2.imwrite(constants.save_path + '/%09d.png' % im_ind, + self.game_state.s_t[:, :, ::-1]) + im_ind += 1 + else: + if 'Teleport' in action['action']: + start_pose = self.pose + end_angle = action['horizon'] + end_pose = (int(action['x'] / constants.AGENT_STEP_SIZE), + int(action['z'] / constants.AGENT_STEP_SIZE), + int(action['rotation'] / 90), + int(end_angle)) + + self.game_state.gt_graph.navigate_to_goal(self.game_state, start_pose, end_pose) + self.pose = self.game_state.pose + elif action['action'] == 'Plan': + self.plan_agent.execute_plan() + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + elif action['action'] == 'Scan': + self.game_state.step(action) + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + elif action['action'] == 'Explore': + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + else: + super(SemanticMapPlannerAgent, self).step(action) + + diff --git a/models/main_models/rt1/gen/constants.py b/models/main_models/rt1/gen/constants.py new file mode 100644 index 000000000..e646c660d --- /dev/null +++ b/models/main_models/rt1/gen/constants.py @@ -0,0 +1,1221 @@ +from collections import OrderedDict + +######################################################################################################################## +# General Settings + +DEBUG = True +EVAL = False +LOG_FILE = 'logs_gen' + +RECORD_VIDEO_IMAGES = True +RECORD_SMOOTHING_FACTOR = 1 +DATA_SAVE_PATH = "dataset/new_trajectories" + +OPEN_LOOP = True +FULL_OBSERVABLE_STATE = True + +######################################################################################################################## +# Generation Ablations + +MAX_NUM_OF_OBJ_INSTANCES = 3 # when randomly initializing the scene, create duplicate instance up to this number +PICKUP_REPEAT_MAX = 4 # how many of the target pickup object to generate in [1, MAX] (randomly chosen) +RECEPTACLE_SPARSE_POINTS = 50 # increment for how many points to leave free for sparsely populated receptacles +RECEPTACLE_EMPTY_POINTS = 200 # increment for how many points to leave free for empty receptacles + +MIN_VISIBLE_RATIO = 0.0011 # minimum area ratio (with respect to image size) of visible object +PLANNER_MAX_STEPS = 100 # if the generated plan is more than these steps, discard the traj +MAX_EPISODE_LENGTH = 1000 # maximum number of API steps allowed per trajectory + +FORCED_SAMPLING = False # set True for debugging instead of proper sampling +PRUNE_UNREACHABLE_POINTS = True # prune navigation points that were deemed unreachable by the proprocessing script + +######################################################################################################################## +# Goals + +GOALS = [ + "pick_and_place_simple", + "pick_two_obj_and_place", + "look_at_obj_in_light", + "pick_clean_then_place_in_recep", + "pick_heat_then_place_in_recep", + "pick_cool_then_place_in_recep", + "pick_and_place_with_movable_recep", + ] +GOALS_VALID = {"pick_and_place_simple": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, + "pick_two_obj_and_place": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, + "look_at_obj_in_light": {"LivingRoom", "Bedroom"}, + "pick_clean_then_place_in_recep": {"Kitchen", "Bathroom"}, + "pick_heat_then_place_in_recep": {"Kitchen"}, + "pick_cool_then_place_in_recep": {"Kitchen"}, + "pick_and_place_with_movable_recep": {"Kitchen", "LivingRoom", "Bedroom"}} + +pddl_goal_type = "pick_and_place_simple" # default goal type + +######################################################################################################################## +# Video Settings + +# filler frame IDs +BEFORE = 0 +MIDDLE = 1 +AFTER = 2 + +# number of image frames to save before and after executing the specified action +SAVE_FRAME_BEFORE_AND_AFTER_COUNTS = { + 'OpenObject': [2, 0, 2], + 'CloseObject': [2, 0, 2], + 'PickupObject': [5, 0, 10], + 'PutObject': [5, 0, 10], + 'CleanObject': [3, 0, 5], + 'HeatObject': [3, 0, 5], + 'CoolObject': [3, 30, 5], + 'ToggleObjectOn': [3, 0, 15], + 'ToggleObjectOff': [1, 0, 5], + 'SliceObject': [3, 0, 7] +} + +# FPS +VIDEO_FRAME_RATE = 5 + +######################################################################################################################## +# Data & Storage + +save_path = DATA_SAVE_PATH +data_dict = OrderedDict() # dictionary for storing trajectory data to be dumped + +######################################################################################################################## +# Unity Hyperparameters + +BUILD_PATH = None +X_DISPLAY = '0' + +AGENT_STEP_SIZE = 0.25 +AGENT_HORIZON_ADJ = 30 +AGENT_ROTATE_ADJ = 90 +CAMERA_HEIGHT_OFFSET = 0.75 +VISIBILITY_DISTANCE = 1.5 +HORIZON_GRANULARITY = 30 + +RENDER_IMAGE = True +RENDER_DEPTH_IMAGE = True +RENDER_CLASS_IMAGE = True +RENDER_OBJECT_IMAGE = True + +MAX_DEPTH = 5000 +STEPS_AHEAD = 5 +SCENE_PADDING = STEPS_AHEAD * 3 +SCREEN_WIDTH = DETECTION_SCREEN_WIDTH = 300 +SCREEN_HEIGHT = DETECTION_SCREEN_HEIGHT = 300 +MIN_VISIBLE_PIXELS = 10 + +# (400) / (600*600) ~ 0.13% area of image +# int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float(DETECTION_SCREEN_HEIGHT)) +# MIN_VISIBLE_PIXELS = int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float( +# DETECTION_SCREEN_HEIGHT)) # (400) / (600*600) ~ 0.13% area of image + +######################################################################################################################## +# Scenes and Objects + +TRAIN_SCENE_NUMBERS = list(range(7, 31)) # Train Kitchens (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(207, 231))) # Train Living Rooms (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(307, 331))) # Train Bedrooms (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(407, 431))) # Train Bathrooms (24/30) + +TEST_SCENE_NUMBERS = list(range(1, 7)) # Test Kitchens (6/30) +TEST_SCENE_NUMBERS.extend(list(range(201, 207))) # Test Living Rooms (6/30) +TEST_SCENE_NUMBERS.extend(list(range(301, 307))) # Test Bedrooms (6/30) +TEST_SCENE_NUMBERS.extend(list(range(401, 407))) # Test Bathrooms (6/30) + +SCENE_NUMBERS = TRAIN_SCENE_NUMBERS + TEST_SCENE_NUMBERS + +# Scene types. +SCENE_TYPE = {"Kitchen": range(1, 31), + "LivingRoom": range(201, 231), + "Bedroom": range(301, 331), + "Bathroom": range(401, 431)} + +OBJECTS = [ + 'AlarmClock', + 'Apple', + 'ArmChair', + 'BaseballBat', + 'BasketBall', + 'Bathtub', + 'BathtubBasin', + 'Bed', + 'Blinds', + 'Book', + 'Boots', + 'Bowl', + 'Box', + 'Bread', + 'ButterKnife', + 'Cabinet', + 'Candle', + 'Cart', + 'CD', + 'CellPhone', + 'Chair', + 'Cloth', + 'CoffeeMachine', + 'CounterTop', + 'CreditCard', + 'Cup', + 'Curtains', + 'Desk', + 'DeskLamp', + 'DishSponge', + 'Drawer', + 'Dresser', + 'Egg', + 'FloorLamp', + 'Footstool', + 'Fork', + 'Fridge', + 'GarbageCan', + 'Glassbottle', + 'HandTowel', + 'HandTowelHolder', + 'HousePlant', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'LaundryHamper', + 'LaundryHamperLid', + 'Lettuce', + 'LightSwitch', + 'Microwave', + 'Mirror', + 'Mug', + 'Newspaper', + 'Ottoman', + 'Painting', + 'Pan', + 'PaperTowel', + 'PaperTowelRoll', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Pillow', + 'Plate', + 'Plunger', + 'Poster', + 'Pot', + 'Potato', + 'RemoteControl', + 'Safe', + 'SaltShaker', + 'ScrubBrush', + 'Shelf', + 'ShowerDoor', + 'ShowerGlass', + 'Sink', + 'SinkBasin', + 'SoapBar', + 'SoapBottle', + 'Sofa', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'StoveBurner', + 'StoveKnob', + 'DiningTable', + 'CoffeeTable', + 'SideTable', + 'TeddyBear', + 'Television', + 'TennisRacket', + 'TissueBox', + 'Toaster', + 'Toilet', + 'ToiletPaper', + 'ToiletPaperHanger', + 'ToiletPaperRoll', + 'Tomato', + 'Towel', + 'TowelHolder', + 'TVStand', + 'Vase', + 'Watch', + 'WateringCan', + 'Window', + 'WineBottle', +] + +OBJECTS_LOWER_TO_UPPER = {obj.lower(): obj for obj in OBJECTS} + +OBJECTS_SINGULAR = [ + 'alarmclock', + 'apple', + 'armchair', + 'baseballbat', + 'basketball', + 'bathtub', + 'bathtubbasin', + 'bed', + 'blinds', + 'book', + 'boots', + 'bowl', + 'box', + 'bread', + 'butterknife', + 'cabinet', + 'candle', + 'cart', + 'cd', + 'cellphone', + 'chair', + 'cloth', + 'coffeemachine', + 'countertop', + 'creditcard', + 'cup', + 'curtains', + 'desk', + 'desklamp', + 'dishsponge', + 'drawer', + 'dresser', + 'egg', + 'floorlamp', + 'footstool', + 'fork', + 'fridge', + 'garbagecan', + 'glassbottle', + 'handtowel', + 'handtowelholder', + 'houseplant', + 'kettle', + 'keychain', + 'knife', + 'ladle', + 'laptop', + 'laundryhamper', + 'laundryhamperlid', + 'lettuce', + 'lightswitch', + 'microwave', + 'mirror', + 'mug', + 'newspaper', + 'ottoman', + 'painting', + 'pan', + 'papertowel', + 'papertowelroll', + 'pen', + 'pencil', + 'peppershaker', + 'pillow', + 'plate', + 'plunger', + 'poster', + 'pot', + 'potato', + 'remotecontrol', + 'safe', + 'saltshaker', + 'scrubbrush', + 'shelf', + 'showerdoor', + 'showerglass', + 'sink', + 'sinkbasin', + 'soapbar', + 'soapbottle', + 'sofa', + 'spatula', + 'spoon', + 'spraybottle', + 'statue', + 'stoveburner', + 'stoveknob', + 'diningtable', + 'coffeetable', + 'sidetable' + 'teddybear', + 'television', + 'tennisracket', + 'tissuebox', + 'toaster', + 'toilet', + 'toiletpaper', + 'toiletpaperhanger', + 'toiletpaperroll', + 'tomato', + 'towel', + 'towelholder', + 'tvstand', + 'vase', + 'watch', + 'wateringcan', + 'window', + 'winebottle', +] + +OBJECTS_PLURAL = [ + 'alarmclocks', + 'apples', + 'armchairs', + 'baseballbats', + 'basketballs', + 'bathtubs', + 'bathtubbasins', + 'beds', + 'blinds', + 'books', + 'boots', + 'bottles', + 'bowls', + 'boxes', + 'bread', + 'butterknives', + 'cabinets', + 'candles', + 'carts', + 'cds', + 'cellphones', + 'chairs', + 'cloths', + 'coffeemachines', + 'countertops', + 'creditcards', + 'cups', + 'curtains', + 'desks', + 'desklamps', + 'dishsponges', + 'drawers', + 'dressers', + 'eggs', + 'floorlamps', + 'footstools', + 'forks', + 'fridges', + 'garbagecans', + 'glassbottles', + 'handtowels', + 'handtowelholders', + 'houseplants', + 'kettles', + 'keychains', + 'knives', + 'ladles', + 'laptops', + 'laundryhampers', + 'laundryhamperlids', + 'lettuces', + 'lightswitches', + 'microwaves', + 'mirrors', + 'mugs', + 'newspapers', + 'ottomans', + 'paintings', + 'pans', + 'papertowels', + 'papertowelrolls', + 'pens', + 'pencils', + 'peppershakers', + 'pillows', + 'plates', + 'plungers', + 'posters', + 'pots', + 'potatoes', + 'remotecontrollers', + 'safes', + 'saltshakers', + 'scrubbrushes', + 'shelves', + 'showerdoors', + 'showerglassess', + 'sinks', + 'sinkbasins', + 'soapbars', + 'soapbottles', + 'sofas', + 'spatulas', + 'spoons', + 'spraybottles', + 'statues', + 'stoveburners', + 'stoveknobs', + 'diningtables', + 'coffeetables', + 'sidetable', + 'teddybears', + 'televisions', + 'tennisrackets', + 'tissueboxes', + 'toasters', + 'toilets', + 'toiletpapers', + 'toiletpaperhangers', + 'toiletpaperrolls', + 'tomatoes', + 'towels', + 'towelholders', + 'tvstands', + 'vases', + 'watches', + 'wateringcans', + 'windows', + 'winebottles', +] + +MOVABLE_RECEPTACLES = [ + 'Bowl', + 'Box', + 'Cup', + 'Mug', + 'Plate', + 'Pan', + 'Pot', +] + +MOVABLE_RECEPTACLES_SET = set(MOVABLE_RECEPTACLES) +OBJECTS_SET = set(OBJECTS) | MOVABLE_RECEPTACLES_SET + +OBJECT_CLASS_TO_ID = {obj: ii for (ii, obj) in enumerate(OBJECTS)} + +RECEPTACLES = { + 'BathtubBasin', + 'Bowl', + 'Cup', + 'Drawer', + 'Mug', + 'Plate', + 'Shelf', + 'SinkBasin', + 'Box', + 'Cabinet', + 'CoffeeMachine', + 'CounterTop', + 'Fridge', + 'GarbageCan', + 'HandTowelHolder', + 'Microwave', + 'PaintingHanger', + 'Pan', + 'Pot', + 'StoveBurner', + 'DiningTable', + 'CoffeeTable', + 'SideTable', + 'ToiletPaperHanger', + 'TowelHolder', + 'Safe', + 'BathtubBasin', + 'ArmChair', + 'Toilet', + 'Sofa', + 'Ottoman', + 'Dresser', + 'LaundryHamper', + 'Desk', + 'Bed', + 'Cart', + 'TVStand', + 'Toaster', + } + +NON_RECEPTACLES = OBJECTS_SET - RECEPTACLES + +NUM_RECEPTACLES = len(RECEPTACLES) +NUM_CLASSES = len(OBJECTS) + +# For generating questions +QUESTION_OBJECT_CLASS_LIST = [ + 'Spoon', + 'Potato', + 'Fork', + 'Plate', + 'Egg', + 'Tomato', + 'Bowl', + 'Lettuce', + 'Apple', + 'Knife', + 'Container', + 'Bread', + 'Mug', +] + +VAL_RECEPTACLE_OBJECTS = { + 'Pot': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Pan': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Bowl': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'RemoteControl', + 'Watch'}, + 'CoffeeMachine': {'Mug'}, + 'Microwave': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Glassbottle', + 'Mug', + 'Plate', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced'}, + 'StoveBurner': {'Kettle', + 'Pan', + 'Pot'}, + 'Fridge': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Glassbottle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced', + 'WineBottle'}, + 'Mug': {'ButterKnife', + 'Fork', + 'Knife', + 'Pen', + 'Pencil', + 'Spoon', + 'KeyChain', + 'Watch'}, + 'Plate': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'AlarmClock', + 'Book', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Glassbottle', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'TissueBox', + 'Watch'}, + 'Cup': {'ButterKnife', + 'Fork', + 'Spoon'}, + 'Sofa': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'ArmChair': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'Box': {'AlarmClock', + 'Book', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Glassbottle', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'RemoteControl', + 'Statue', + 'TissueBox', + 'Vase', + 'Watch'}, + 'Ottoman': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'Dresser': {'AlarmClock', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'Glassbottle', + 'KeyChain', + 'Laptop', + 'Mug', + 'Newspaper', + 'Pen', + 'Pencil', + 'Plate', + 'RemoteControl', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle'}, + 'LaundryHamper': {'Cloth'}, + 'Desk': {'AlarmClock', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'Glassbottle', + 'KeyChain', + 'Laptop', + 'Mug', + 'Newspaper', + 'Pen', + 'Pencil', + 'Plate', + 'RemoteControl', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle'}, + 'Bed': {'BaseballBat', + 'BasketBall', + 'Book', + 'CellPhone', + 'Laptop', + 'Newspaper', + 'Pillow', + 'TennisRacket'}, + 'Toilet': {'Candle', + 'Cloth', + 'DishSponge', + 'Newspaper', + 'PaperTowel', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'HandTowel'}, + 'ToiletPaperHanger': {'ToiletPaper', + 'ToiletPaperRoll'}, + 'TowelHolder': {'Towel'}, + 'HandTowelHolder': {'HandTowel'}, + 'Cart': {'Candle', + 'Cloth', + 'DishSponge', + 'Mug', + 'PaperTowel', + 'Plunger', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'HandTowel'}, + 'BathtubBasin': {'Cloth', + 'DishSponge', + 'SoapBar', + 'HandTowel'}, + 'SinkBasin': {'Apple', + 'AppleSliced', + 'Bowl', + 'ButterKnife', + 'Cloth', + 'Cup', + 'DishSponge', + 'Egg', + 'Glassbottle', + 'Fork', + 'Kettle', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'HandTowel'}, + 'Cabinet': {'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'Cloth', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Kettle', + 'Ladle', + 'Mug', + 'Newspaper', + 'Pan', + 'PepperShaker', + 'Plate', + 'Plunger', + 'Pot', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'TableTop': {'AlarmClock', + 'Apple', + 'AppleSliced', + 'BaseballBat', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Bread', + 'BreadSliced', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Egg', + 'Fork', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Newspaper', + 'Pan', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'CounterTop': {'AlarmClock', + 'Apple', + 'AppleSliced', + 'BaseballBat', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Bread', + 'BreadSliced', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Egg', + 'Glassbottle', + 'Fork', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Newspaper', + 'Pan', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'Shelf': {'AlarmClock', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Kettle', + 'KeyChain', + 'Mug', + 'Newspaper', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'Drawer': {'Book', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Fork', + 'KeyChain', + 'Knife', + 'Ladle', + 'Newspaper', + 'Pen', + 'Pencil', + 'PepperShaker', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Watch', + 'WateringCan', + 'HandTowel'}, + 'GarbageCan': {'Apple', + 'AppleSliced', + 'Bread', + 'BreadSliced', + 'CD', + 'Cloth', + 'DishSponge', + 'Egg', + 'Lettuce', + 'LettuceSliced', + 'Newspaper', + 'PaperTowel', + 'Pen', + 'Pencil', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'WineBottle', + 'HandTowel'}, + 'Safe': {'CD', + 'CellPhone', + 'CreditCard', + 'KeyChain', + 'Statue', + 'Vase', + 'Watch'}, + 'TVStand': {'TissueBox'}, + 'Toaster': {'BreadSliced'}, +} +VAL_RECEPTACLE_OBJECTS['DiningTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +VAL_RECEPTACLE_OBJECTS['CoffeeTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +VAL_RECEPTACLE_OBJECTS['SideTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +del VAL_RECEPTACLE_OBJECTS['TableTop'] + +NON_RECEPTACLES_SET = (OBJECTS_SET - set(VAL_RECEPTACLE_OBJECTS.keys())) | set(MOVABLE_RECEPTACLES) + +VAL_ACTION_OBJECTS = { + 'Heatable': {'Apple', + 'AppleSliced', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Mug', + 'Plate', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced'}, + 'Coolable': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced', + 'WineBottle'}, + 'Cleanable': {'Apple', + 'AppleSliced', + 'Bowl', + 'ButterKnife', + 'Cloth', + 'Cup', + 'DishSponge', + 'Egg', + 'Fork', + 'Kettle', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Toggleable': {'DeskLamp', + 'FloorLamp'}, + 'Sliceable': {'Apple', + 'Bread', + 'Egg', + 'Lettuce', + 'Potato', + 'Tomato'} +} + +# object parents +OBJ_PARENTS = {obj: obj for obj in OBJECTS} +OBJ_PARENTS['AppleSliced'] = 'Apple' +OBJ_PARENTS['BreadSliced'] = 'Bread' +OBJ_PARENTS['LettuceSliced'] = 'Lettuce' +OBJ_PARENTS['PotatoSliced'] = 'Potato' +OBJ_PARENTS['TomatoSliced'] = 'Tomato' + +# force a different horizon view for objects of (type, location). If the location is None, force this horizon for all +# objects of that type. +FORCED_HORIZON_OBJS = { + ('FloorLamp', None): 0, + ('Fridge', 18): 30, + ('Toilet', None): 15, +} + +# openable objects with fixed states for transport. +FORCED_OPEN_STATE_ON_PICKUP = { + 'Laptop': False, +} + +# list of openable classes. +OPENABLE_CLASS_LIST = ['Fridge', 'Cabinet', 'Microwave', 'Drawer', 'Safe', 'Box'] +OPENABLE_CLASS_SET = set(OPENABLE_CLASS_LIST) + +######################################################################################################################## \ No newline at end of file diff --git a/models/main_models/rt1/gen/ff_planner/README.md b/models/main_models/rt1/gen/ff_planner/README.md new file mode 100644 index 000000000..81bc18c0f --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/README.md @@ -0,0 +1,13 @@ +# Metric FF Planner +Credit: https://fai.cs.uni-saarland.de/hoffmann/metric-ff.html. +Specifically this uses the Metric-FF Version 2.1 (https://fai.cs.uni-saarland.de/hoffmann/ff/Metric-FF-v2.1.tgz). + +Note that the code here is not exactly the same as the one you can download from that website. +Their code had issues that threw segfaults which I was able to fix for this project. +It is possible that my changes caused some other issues that I am unaware of. + +To compile: +```bash +$ cd +$ make +``` diff --git a/models/main_models/rt1/gen/ff_planner/expressions.c b/models/main_models/rt1/gen/ff_planner/expressions.c new file mode 100644 index 000000000..8fb8d2404 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/expressions.c @@ -0,0 +1,2623 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/*********************************************************************** + * File: expressions.c + * Description: functions for handling numerical expressions + * + * - general utilities: + * comparisons between numbers etc. + * + * - LNF compilation: + * normalization of expressions + * translation of subtractions + * + * - LNF post-processing: + * summarization of effects + * encoding of non-minimal LNFs + * + * Author: Joerg Hoffmann 2001 + * + *********************************************************************/ + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + + + + + + + + + + + + + + + +/******************************************************* + * SIMPLE UTILITIES + *******************************************************/ + + + + + + + + + + + + + + + + +Bool number_comparison_holds( Comparator c, float l, float r ) + +{ + + switch ( c ) { + case LE: + if ( l < r ) return TRUE; + break; + case LEQ: + if ( l <= r ) return TRUE; + break; + case EQ: + if ( l == r ) return TRUE; + break; + case GEQ: + if ( l >= r ) return TRUE; + break; + case GE: + if ( l > r ) return TRUE; + break; + case IGUAL: + /* technical for non-required fluents + */ + return TRUE; + default: + printf("\n\nillegal comparator %d in number comp holds", c); + exit( 1 ); + } + + return FALSE; + +} + + + + + + + + + + + + + + + + + + + + + +/******************************************************* + * MACHINERY FOR LNF TRANSFORMATION!!!!!! + *******************************************************/ + + + + + + + + + + + + + + + + + + + + + + + + +Bool transform_to_LNF( void ) + +{ + + if ( !is_linear_task() ) { + return FALSE; + } + + normalize_expressions(); + if ( gcmd_line.display_info == 121 ) { + printf("\n\nnormalized expressions representation is:\n\n"); + print_lnf_representation(); + } + + translate_subtractions(); + if ( gcmd_line.display_info == 122 ) { + printf("\n\nLNF : translated subtractions representation is:\n\n"); + print_lnf_representation(); + } + + /* LNF computed. start post-processing. + */ + + /* do same-cond effects etc. summarization here so as to have + * as tight as possible an encoded LNF representation. + */ + summarize_effects(); + if ( gcmd_line.display_info == 123 ) { + printf("\n\nLNF - summarized effects representation is:\n\n"); + print_lnf_representation(); + } + + encode_lfns_as_artificial_fluents(); + /* optimization is translated into minimizing + * effect costs... here, determine the cost that + * each effect has. + * + * returns TRUE if a non-trivial optimization expression + * could be established. + */ + if ( setup_effect_costs() ) { + if ( gcmd_line.display_info > 1 ) { + printf("\nmetric established (normalized to minimize): "); + print_LnfExpNode( &glnf_metric ); + } + goptimization_established = TRUE; + } + if ( gcmd_line.display_info == 124 ) { + printf("\n\nencoded LNF representation is:\n\n"); + print_lnf_representation(); + } + + return TRUE; + +} + + + +/* simple syntax check + */ +Bool is_linear_task( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( a = gactions; a; a = a->next ) { + /* preconds + */ + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( !is_linear_expression( a->numeric_preconds_lh[i] ) ) { + return FALSE; + } + if ( !is_linear_expression( a->numeric_preconds_rh[i] ) ) { + return FALSE; + } + } + + /* effects + */ + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( !is_linear_expression( e->numeric_conditions_lh[j] ) ) { + return FALSE; + } + if ( !is_linear_expression( e->numeric_conditions_rh[j] ) ) { + return FALSE; + } + } + + if ( e->illegal ) { + /* we don't care whether that one's ok or not- + * it won't be applied anyway. + */ + continue; + } + + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( e->numeric_effects_neft[j] != INCREASE && + e->numeric_effects_neft[j] != DECREASE && + e->numeric_effects_neft[j] != ASSIGN ) { + return FALSE; + } + if ( !is_linear_expression( e->numeric_effects_rh[j] ) ) { + return FALSE; + } + } + } + } + + /* goal condition also... + */ + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( !is_linear_expression( gnumeric_goal_lh[i] ) ) { + return FALSE; + } + if ( !is_linear_expression( gnumeric_goal_rh[i] ) ) { + return FALSE; + } + } + + if ( gmetric != NULL ) { + if ( !is_linear_expression( gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: metric is no linear expression. defaulting to plan length."); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + } + + return TRUE; + +} + + + +Bool is_linear_expression( ExpNode *n ) + +{ + + switch ( n->connective ) { + case MU: + if ( !is_linear_expression( n->leftson ) || + !is_linear_expression( n->rightson ) ) { + return FALSE; + } + if ( n->leftson->connective != NUMBER && + n->rightson->connective != NUMBER ) { + return FALSE; + } + break; + case DI: + if ( !is_linear_expression( n->leftson ) || + n->rightson->connective != NUMBER ) { + return FALSE; + } + break; + case AD: + case SU: + if ( !is_linear_expression( n->leftson ) || + !is_linear_expression( n->rightson ) ) { + return FALSE; + } + break; + case MINUS: + if ( !is_linear_expression( n->son ) ) { + return FALSE; + } + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\nis linear exp: wrong specifier %d", + n->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void print_lnf_representation( void ) + +{ + + int i; + Action *a; + + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( !a->norm_operator && + !a->pseudo_action ) || + ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + print_lnf_Action( a ); + } + } + printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); + for ( a = gactions; a; a = a->next ) { + if ( !a->norm_operator && + !a->pseudo_action ) { + print_lnf_Action( a ); + } + } + + printf("\n\ninitial state is:\n\n"); + print_State( ginitial_state ); + + printf("\n\ngoal is:\n\n"); + for ( i = 0; i < gnum_logic_goal; i++ ) { + print_ft_name( glogic_goal[i] ); + printf("\n"); + } + for ( i = 0; i < gnum_lnf_goal; i++ ) { + switch ( glnf_goal_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator in lnf goal %d\n\n", glnf_goal_comp[i]); + exit( 1 ); + } + print_LnfExpNode( glnf_goal_lh[i] ); + printf(" %f", glnf_goal_rh[i]); + printf(")\n"); + } + + if ( gmetric ) { + printf("\n\nmetric is (minimize) (constant part skipped):\n"); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + +} + + + + + + + + + + + + + + + + + + +/******************************************************* + * SUBPART I: NORMALIZE THE EXPRESSIONS + *******************************************************/ + + + + + + + + + + + + + + + + + +/* local globals. + */ + +Comparator lcomp; + +int lF[MAX_LNF_F]; +float lC[MAX_LNF_F]; +int lnum_F; + +float lc; + + + + + + + + + + + +void normalize_expressions( void ) + +{ + + Action *a, *p, *t; + ActionEffect *e; + int i, j, k; + Bool eq; + LnfExpNode *lnf; + + /* first, pre-normalize all the expressions, i.e. translate + * divisions, and push muliplications downwards. + */ + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( !translate_divisions( &(gnumeric_goal_lh[i]) ) ) { + printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); + exit( 1 ); + } + push_multiplications_down( &(gnumeric_goal_lh[i]) ); + if ( !translate_divisions( &(gnumeric_goal_rh[i]) ) ) { + printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); + exit( 1 ); + } + push_multiplications_down( &(gnumeric_goal_rh[i]) ); + } + + a = gactions; p = NULL; + while ( a ) { + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( !translate_divisions( &(a->numeric_preconds_lh[i]) ) ) break; + push_multiplications_down( &(a->numeric_preconds_lh[i]) ); + if ( !translate_divisions( &(a->numeric_preconds_rh[i]) ) ) break; + push_multiplications_down( &(a->numeric_preconds_rh[i]) ); + } + if ( i < a->num_numeric_preconds ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in precond of "); + print_Action_name( a ); + printf(". skipping action."); + } + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( !translate_divisions( &(e->numeric_conditions_lh[j]) ) ) break; + push_multiplications_down( &(e->numeric_conditions_lh[j]) ); + if ( !translate_divisions( &(e->numeric_conditions_rh[j]) ) ) break; + push_multiplications_down( &(e->numeric_conditions_rh[j]) ); + } + if ( j < e->num_numeric_conditions ) break; + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( !translate_divisions( &(e->numeric_effects_rh[j]) ) ) break; + push_multiplications_down( &(e->numeric_effects_rh[j]) ); + } + if ( j < e->num_numeric_effects ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in effect rh of "); + print_Action_name( a ); + printf(". marking effect as illegal."); + } + e->illegal = TRUE; + } + } + if ( i < a->num_effects ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in effect cond of "); + print_Action_name( a ); + printf(". skipping action."); + } + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + + p = a; + a = a->next; + } + if ( gmetric != NULL ) { + if ( !translate_divisions( &gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in metric. replaced with plan length."); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + push_multiplications_down( &gmetric ); + } + + /* now, collect the normalized representations of all expressions. + */ + for ( a = gactions; a; a = a->next ) { + /* preconds + */ + a->lnf_preconds_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + a->lnf_preconds_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + a->lnf_preconds_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + a->num_lnf_preconds = 0; + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( a->numeric_preconds_comp[i] == EQ ) { + eq = TRUE; + a->numeric_preconds_comp[i] = LEQ; + } + put_comp_into_normalized_locals( a->numeric_preconds_comp[i], + a->numeric_preconds_lh[i], + a->numeric_preconds_rh[i] ); + a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; + a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); + lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + a->lnf_preconds_rh[a->num_lnf_preconds] = lc; + a->num_lnf_preconds++; + if ( eq ) { + if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + a->numeric_preconds_comp[i] = EQ; + put_comp_into_normalized_locals( GEQ, + a->numeric_preconds_lh[i], + a->numeric_preconds_rh[i] ); + a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; + a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); + lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + a->lnf_preconds_rh[a->num_lnf_preconds] = lc; + a->num_lnf_preconds++; + } + } + + /* effects + */ + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + e->lnf_conditions_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + e->lnf_conditions_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + e->lnf_conditions_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + e->num_lnf_conditions = 0; + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( e->numeric_conditions_comp[j] == EQ ) { + eq = TRUE; + e->numeric_conditions_comp[j] = LEQ; + } + put_comp_into_normalized_locals( e->numeric_conditions_comp[j], + e->numeric_conditions_lh[j], + e->numeric_conditions_rh[j] ); + e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; + e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); + lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_conditions_rh[e->num_lnf_conditions] = lc; + e->num_lnf_conditions++; + if ( eq ) { + if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + e->numeric_conditions_comp[j] = EQ; + put_comp_into_normalized_locals( GEQ, + e->numeric_conditions_lh[j], + e->numeric_conditions_rh[j] ); + e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; + e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); + lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_conditions_rh[e->num_lnf_conditions] = lc; + e->num_lnf_conditions++; + } + } + + if ( e->illegal ) { + /* we do have the LNF to know whether the effect appears. + * if it does, then this one is illegal anyway, remembered + * in inst final due to undefined fl access. + * + * if it is LEGAL, then all fluents we're gonna find and + * collect below are relevant!!! + */ + continue; + } + + e->lnf_effects_neft = ( NumericEffectType * ) calloc( MAX_LNF_EFFS, sizeof( NumericEffectType ) ); + e->lnf_effects_fl = ( int * ) calloc( MAX_LNF_EFFS, sizeof( int ) ); + e->lnf_effects_rh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_EFFS, sizeof( LnfExpNode_pointer ) ); + e->num_lnf_effects = 0; + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e->numeric_effects_neft[j]; + e->lnf_effects_fl[e->num_lnf_effects] = e->numeric_effects_fl[j]; + lnum_F = 0; + lc = 0; + if ( e->lnf_effects_neft[e->num_lnf_effects] == DECREASE ) { + collect_normalized_locals( e->numeric_effects_rh[j], FALSE ); + e->lnf_effects_neft[e->num_lnf_effects] = INCREASE; + } else { + collect_normalized_locals( e->numeric_effects_rh[j], TRUE ); + } + e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); + lnf = e->lnf_effects_rh[e->num_lnf_effects]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_effects_rh[e->num_lnf_effects]->c = lc; + e->num_lnf_effects++; + } + } + } + + /* goal condition also... + */ + glnf_goal_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + glnf_goal_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + glnf_goal_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + gnum_lnf_goal = 0; + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( gnum_lnf_goal == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( gnumeric_goal_comp[i] == EQ ) { + eq = TRUE; + gnumeric_goal_comp[i] = LEQ; + } + put_comp_into_normalized_locals( gnumeric_goal_comp[i], + gnumeric_goal_lh[i], + gnumeric_goal_rh[i] ); + glnf_goal_comp[gnum_lnf_goal] = lcomp; + glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); + lnf = glnf_goal_lh[gnum_lnf_goal]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + glnf_goal_rh[gnum_lnf_goal] = lc; + gnum_lnf_goal++; + if ( eq ) { + if ( gnum_lnf_goal == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + gnumeric_goal_comp[i] = EQ; + put_comp_into_normalized_locals( GEQ, + gnumeric_goal_lh[i], + gnumeric_goal_rh[i] ); + glnf_goal_comp[gnum_lnf_goal] = lcomp; + glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); + lnf = glnf_goal_lh[gnum_lnf_goal]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + glnf_goal_rh[gnum_lnf_goal] = lc; + gnum_lnf_goal++; + } + } + /* metric... + */ + lnum_F = 0; + lc = 0; + glnf_metric.num_pF = 0; + glnf_metric.num_nF = 0; + glnf_metric.c = 0; + collect_normalized_locals( gmetric, TRUE ); + lnf = &glnf_metric; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + + +} + + + +Bool translate_divisions( ExpNode **n ) + +{ + + ExpNode *tmp; + + /* "dirty": also normalize multiplications so that the constant + * is always on the left hand side --- + * simplifies function below a lot. + */ + switch ( (*n)->connective ) { + case DI: + /* rightson is number due to syntax check. + */ + if ( (*n)->rightson->value == 0 ) { + /* what needs to be done we can only decide further up. + */ + printf("\nwarning: division by zero."); + return FALSE; + } + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + (*n)->connective = MU; + (*n)->rightson->value = 1 / (*n)->rightson->value; + tmp = (*n)->rightson; + (*n)->rightson = (*n)->leftson; + (*n)->leftson = tmp; + break; + case MU: + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->rightson->connective == NUMBER ) { + tmp = (*n)->rightson; + (*n)->rightson = (*n)->leftson; + (*n)->leftson = tmp; + } + break; + case AD: + case SU: + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; + break; + case MINUS: + if ( !translate_divisions( &((*n)->son) ) ) return FALSE; + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\ntranslate divisions: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void push_multiplications_down( ExpNode **n ) + +{ + + ExpNode *tmp1, *tmp2; + + switch ( (*n)->connective ) { + case MU: + /* due to syntax check, at least one of sons is number, + * + * due to above, it's the left one. + * NOTE that this invariant is kept true troughout the + * modifications done here. + */ + if ( (*n)->rightson->connective == NUMBER ) { + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + free_ExpNode( (*n)->rightson ); + (*n)->leftson = NULL; + (*n)->rightson = NULL; + break; + } + if ( (*n)->rightson->connective == FHEAD ) { + (*n)->connective = FHEAD; + (*n)->fl = (*n)->rightson->fl; + (*n)->c = (*n)->leftson->value; + free_ExpNode( (*n)->leftson ); + free_ExpNode( (*n)->rightson ); + (*n)->leftson = NULL; + (*n)->rightson = NULL; + break; + } + if ( (*n)->rightson->connective == MINUS ) { + (*n)->connective = MINUS; + (*n)->son = (*n)->rightson; + (*n)->son->connective = MU; + (*n)->son->leftson = (*n)->leftson; + (*n)->son->rightson = (*n)->rightson->son; + (*n)->rightson = NULL; + (*n)->leftson = NULL; + (*n)->son->son = NULL; + push_multiplications_down( &((*n)->son) ); + break; + } + if ( (*n)->rightson->connective == MU ) { + (*n)->leftson->value *= (*n)->rightson->leftson->value; + tmp1 = (*n)->rightson->rightson; + (*n)->rightson->rightson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = tmp1; + push_multiplications_down( n ); + break; + } + + /* rigthson is either AD or SU + */ + tmp1 = new_ExpNode( NUMBER ); + tmp2 = new_ExpNode( NUMBER ); + tmp1->value = (*n)->leftson->value; + tmp2->value = (*n)->leftson->value; + + (*n)->connective = (*n)->rightson->connective; + (*n)->leftson->connective = MU; + (*n)->rightson->connective = MU; + (*n)->leftson->leftson = tmp1; + (*n)->leftson->rightson = (*n)->rightson->leftson; + (*n)->rightson->leftson = tmp2; + + push_multiplications_down( &((*n)->leftson) ); + push_multiplications_down( &((*n)->rightson) ); + break; + case AD: + case SU: + push_multiplications_down( &((*n)->leftson) ); + push_multiplications_down( &((*n)->rightson) ); + break; + case MINUS: + push_multiplications_down( &((*n)->son) ); + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\ntranslate divisions: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +void put_comp_into_normalized_locals( Comparator comp, + ExpNode *lh, + ExpNode *rh ) + +{ + + ExpNode *tmp; + + tmp = new_ExpNode( SU ); + + /* initialisation of normalized locals + */ + lnum_F = 0; + lc = 0; + + lcomp = comp; + + /* if comparison is LE or LEQ, then subtract + * left hand side from right hand side to obtain + * new left hand side. + */ + if ( lcomp == LE ) { + tmp->leftson = rh; + tmp->rightson = lh; + collect_normalized_locals( tmp, TRUE ); + lcomp = GE; + /* "subtract" the constant to get it to the right hand + * side. + */ + lc *= (-1); + free( tmp ); + return; + } + if ( lcomp == LEQ ) { + tmp->leftson = rh; + tmp->rightson = lh; + collect_normalized_locals( tmp, TRUE ); + lcomp = GEQ; + lc *= (-1); + free( tmp ); + return; + } + + /* otherwise, subtract right hand side from left hand side. + */ + tmp->leftson = lh; + tmp->rightson = rh; + collect_normalized_locals( tmp, TRUE ); + lc *= (-1); + free( tmp ); + +} + + + +void collect_normalized_locals( ExpNode *n, Bool positive ) + +{ + + Bool negative = positive ? FALSE : TRUE; + int i; + + if ( !n ) return; + + switch ( n->connective ) { + case AD: + collect_normalized_locals( n->leftson, positive ); + collect_normalized_locals( n->rightson, positive ); + break; + case SU: + collect_normalized_locals( n->leftson, positive ); + collect_normalized_locals( n->rightson, negative ); + break; + case MINUS: + collect_normalized_locals( n->son, negative ); + break; + case NUMBER: + if ( positive ) { + lc += n->value; + } else { + lc -= n->value; + } + break; + case FHEAD: + if ( n->fl < 0 && n->fl != -2 ) { + printf("\n\ncollecting non-relevant fluent for LNF!!\n\n"); + exit( 1 ); + } + for ( i = 0; i < lnum_F; i++ ) { + if ( lF[i] == n->fl ) break; + } + if ( i < lnum_F ) { + lC[i] += positive ? n->c : ((-1) * n->c); + } else { + if ( lnum_F == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + lF[lnum_F] = n->fl; + lC[lnum_F] = positive ? n->c : ((-1) * n->c); + lnum_F++; + } + break; + default: + printf("\n\ncollect_normalized_locals: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + + + + + + + + + + + + + + + + + + + +/******************************************************* + * SUBPART II: TRANSLATE THE SUBTRACTIONS + *******************************************************/ + + + + + + + + + + + + + + + +/* local globals. + */ + +int lminus_fluent[MAX_RELEVANT_FLUENTS]; + + + + + + + + + + + + +void translate_subtractions( void ) + +{ + + int i, fl; + + /* minus_fluent[fl] gives the number of the fluent that + * takes on the negative value to fl, or -1 if there is + * no such fluent. + */ + for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { + lminus_fluent[i] = -1; + } + + while ( TRUE ) { + /* ex fl \in nF for pre, cond, eff or goal? + */ + if ( !ex_fl_in_nF_of_pre_cond_eff_goal( &fl ) ) { + /* no --> we are finished. + */ + break; + } + if ( fl < 0 ) { + if ( fl != -2 ) { + printf("\n\nnon-relevant fluent in non-illegal part!\n\n"); + exit( 1 ); + } else { + printf("\n\nwarning: total-time occurs negatively in metric. no optimization done.\n\n"); + glnf_metric.num_pF = 0; + glnf_metric.num_nF = 0; + continue; + } + } + /* set the new number and name, incrementing + * gnum_relevant_fluents, and setting + * minus_fluent value for both directions. + */ + introduce_minus_fluent( fl ); + /* replace all occurences in effects and conds and goals + */ + replace_fl_in_nF_with_minus_fl( fl ); + /* set the initial value of the new fluent + */ + set_minus_fl_initial( fl ); + /* adjust the effects accordingly + */ + introduce_minus_fl_effects( fl ); + } + +} + + + +Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( glnf_goal_lh[i]->num_nF > 0 ) { + *fl = glnf_goal_lh[i]->nF[0]; + return TRUE; + } + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( a->lnf_preconds_lh[i]->num_nF > 0 ) { + *fl = a->lnf_preconds_lh[i]->nF[0]; + return TRUE; + } + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_nF > 0 ) { + *fl = e->lnf_conditions_lh[j]->nF[0]; + return TRUE; + } + } + + if ( e->illegal ) { + /* we don't care if there's something in here that + * wants to be translated. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_rh[j]->num_nF > 0 ) { + *fl = e->lnf_effects_rh[j]->nF[0]; + return TRUE; + } + } + } + } + + /* no need to throw costs away, even if we're not explicitly asked to + * minimize them + */ + if ( (1 || gcost_minimizing) && glnf_metric.num_nF > 0 ) { + *fl = glnf_metric.nF[0]; + return TRUE; + } + + return FALSE; + +} + + + +void introduce_minus_fluent( int fl ) + +{ + + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = -1; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], "MINUS-" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], + grelevant_fluents_name[fl] ); + lminus_fluent[fl] = gnum_relevant_fluents; + lminus_fluent[gnum_relevant_fluents] = fl; + gnum_relevant_fluents++; + +} + + + +void replace_fl_in_nF_with_minus_fl( int fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, l; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + for ( j = 0; j < glnf_goal_lh[i]->num_nF; j++ ) { + if ( glnf_goal_lh[i]->nF[j] == fl ) break; + } + if ( j == glnf_goal_lh[i]->num_nF ) continue; + /* now the jth fluent in subtraction is our translated one. + * + * first, put minus-fl into pF. Can't already be there + * because we have only just introduced it. + */ + if ( glnf_goal_lh[i]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + glnf_goal_lh[i]->pF[glnf_goal_lh[i]->num_pF] = lminus_fluent[fl]; + glnf_goal_lh[i]->pC[glnf_goal_lh[i]->num_pF++] = glnf_goal_lh[i]->nC[j]; + /* now remove fl from nF. + */ + for ( k = j; k < glnf_goal_lh[i]->num_nF - 1; k++ ) { + glnf_goal_lh[i]->nF[k] = glnf_goal_lh[i]->nF[k+1]; + glnf_goal_lh[i]->nC[k] = glnf_goal_lh[i]->nC[k+1]; + } + glnf_goal_lh[i]->num_nF--; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + for ( j = 0; j < a->lnf_preconds_lh[i]->num_nF; j++ ) { + if ( a->lnf_preconds_lh[i]->nF[j] == fl ) break; + } + if ( j == a->lnf_preconds_lh[i]->num_nF ) continue; + if ( a->lnf_preconds_lh[i]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + a->lnf_preconds_lh[i]->pF[a->lnf_preconds_lh[i]->num_pF] = lminus_fluent[fl]; + a->lnf_preconds_lh[i]->pC[a->lnf_preconds_lh[i]->num_pF++] = a->lnf_preconds_lh[i]->nC[j]; + for ( k = j; k < a->lnf_preconds_lh[i]->num_nF - 1; k++ ) { + a->lnf_preconds_lh[i]->nF[k] = a->lnf_preconds_lh[i]->nF[k+1]; + a->lnf_preconds_lh[i]->nC[k] = a->lnf_preconds_lh[i]->nC[k+1]; + } + a->lnf_preconds_lh[i]->num_nF--; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + for ( k = 0; k < e->lnf_conditions_lh[j]->num_nF; k++ ) { + if ( e->lnf_conditions_lh[j]->nF[k] == fl ) break; + } + if ( k == e->lnf_conditions_lh[j]->num_nF ) continue; + if ( e->lnf_conditions_lh[j]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + e->lnf_conditions_lh[j]->pF[e->lnf_conditions_lh[j]->num_pF] = lminus_fluent[fl]; + e->lnf_conditions_lh[j]->pC[e->lnf_conditions_lh[j]->num_pF++] = e->lnf_conditions_lh[j]->nC[k]; + for ( l = k; l < e->lnf_conditions_lh[j]->num_nF - 1; l++ ) { + e->lnf_conditions_lh[j]->nF[l] = e->lnf_conditions_lh[j]->nF[l+1]; + e->lnf_conditions_lh[j]->nC[l] = e->lnf_conditions_lh[j]->nC[l+1]; + } + e->lnf_conditions_lh[j]->num_nF--; + } + + if ( e->illegal ) { + /* like before, we don't care about effects that access + * irrelevant fluents + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { + if ( e->lnf_effects_rh[j]->nF[k] == fl ) break; + } + if ( k == e->lnf_effects_rh[j]->num_nF ) continue; + if ( e->lnf_effects_rh[j]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + e->lnf_effects_rh[j]->pF[e->lnf_effects_rh[j]->num_pF] = lminus_fluent[fl]; + e->lnf_effects_rh[j]->pC[e->lnf_effects_rh[j]->num_pF++] = e->lnf_effects_rh[j]->nC[k]; + for ( l = k; l < e->lnf_effects_rh[j]->num_nF - 1; l++ ) { + e->lnf_effects_rh[j]->nF[l] = e->lnf_effects_rh[j]->nF[l+1]; + e->lnf_effects_rh[j]->nC[l] = e->lnf_effects_rh[j]->nC[l+1]; + } + e->lnf_effects_rh[j]->num_nF--; + } + } + } + + for ( j = 0; j < glnf_metric.num_nF; j++ ) { + if ( glnf_metric.nF[j] == fl ) break; + } + if ( j < glnf_metric.num_nF ) { + if ( glnf_metric.num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + glnf_metric.pF[glnf_metric.num_pF] = lminus_fluent[fl]; + glnf_metric.pC[glnf_metric.num_pF++] = glnf_metric.nC[j]; + for ( k = j; k < glnf_metric.num_nF - 1; k++ ) { + glnf_metric.nF[k] = glnf_metric.nF[k+1]; + glnf_metric.nC[k] = glnf_metric.nC[k+1]; + } + glnf_metric.num_nF--; + } + +} + + + +void set_minus_fl_initial( int fl ) + +{ + + if ( ginitial_state.f_D[fl] ) { + ginitial_state.f_D[lminus_fluent[fl]] = TRUE; + ginitial_state.f_V[lminus_fluent[fl]] = (-1) * ginitial_state.f_V[fl]; + } + +} + + + +void introduce_minus_fl_effects( int fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, pf, nf; + LnfExpNode *len; + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->illegal ) { + /* no need to translate illegal effects. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_fl[j] != fl ) { + continue; + } + /* here is an effect that affects our fl. + * introduce inverse effect for minus_fl, + * making use of all minus-fl's that are already + * there. + */ + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e->lnf_effects_neft[j]; + e->lnf_effects_fl[e->num_lnf_effects] = lminus_fluent[fl]; + e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); + len = e->lnf_effects_rh[e->num_lnf_effects]; + /* now the most "difficult" part: setup the inverted pF and nF + * informations. + * + * NOTE: as fluent occurences are unique in original ef, + * so will they be in new ef. (no len contains both + * a fluent and its minus-fluent) + * --> invariant is or should be that the absolute + * fluents occur at most once in |pF| \cup |nF|. + * holds in the beginning. only thing we do is + * we exchange in that set for some fluents the + * positive with the negative version, so the + * invariant is in fact preserved. + */ + for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { + pf = e->lnf_effects_rh[j]->pF[k]; + if ( lminus_fluent[pf] == -1 ) { + /* not translated yet --> insert it into nF + */ + if ( len->num_nF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->nF[len->num_nF] = pf; + len->nC[len->num_nF++] = e->lnf_effects_rh[j]->pC[k]; + } else { + /* else, insert minus-pf into pF + */ + if ( len->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->pF[len->num_pF] = lminus_fluent[pf]; + len->pC[len->num_pF++] = e->lnf_effects_rh[j]->pC[k]; + } + } + for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { + nf = e->lnf_effects_rh[j]->nF[k]; + /* insert all of those into pF + */ + if ( len->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->pF[len->num_pF] = nf; + len->pC[len->num_pF++] = e->lnf_effects_rh[j]->nC[k]; + } + /* the constant must of course be inverted. + */ + len->c = (-1) * e->lnf_effects_rh[j]->c; + e->num_lnf_effects++; + } + } + } + +} + + + + + + + + + + + + + + + + + + +/************************************************************* + * LNF POST-PROCESSING I: SUMMARIZE EFFECTS. + *************************************************************/ + + + + + + + + + + + + + + + + + + + +int *lA, *lD; +int lnum_A, lnum_D; + + + + + + +void summarize_effects( void ) + +{ + + Action *a; + ActionEffect *e, *e_; + int i, j, k, l; + + lA = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); + lD = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); + + for ( a = gactions; a; a = a->next ) { + i = 0; + while ( i < a->num_effects ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* this one's already handled. + */ + i++; + continue; + } + + /* first, merge the effect's own effects together. logical: + */ + lnum_A = 0; + for ( j = 0; j < e->num_adds; j++ ) { + for ( k = 0; k < lnum_A; k++ ) { + if ( lA[k] == e->adds[j] ) break; + } + if ( k < lnum_A ) continue; + lA[lnum_A++] = e->adds[j]; + } + lnum_D = 0; + for ( j = 0; j < e->num_dels; j++ ) { + for ( k = 0; k < lnum_D; k++ ) { + if ( lD[k] == e->dels[j] ) break; + } + if ( k < lnum_D ) continue; + lD[lnum_D++] = e->dels[j]; + } + /* numerical: + */ + j = 0; + while ( j < e->num_lnf_effects ) { + /* merge all effects increasing the same fluent into + * effect j, and remove them. + */ + k = j + 1; + while ( k < e->num_lnf_effects ) { + if ( e->lnf_effects_fl[k] != e->lnf_effects_fl[j] ) { + k++; + continue; + } + if ( e->lnf_effects_neft[j] == ASSIGN ) { + if ( e->lnf_effects_neft[k] != ASSIGN || + !same_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ) ) { + e->illegal = TRUE; + break; + } + } else { + if ( e->lnf_effects_neft[k] == ASSIGN ) { + e->illegal = TRUE; + break; + } + merge_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ); + } + /* we also get here if we have two identical assigns. + */ + free( e->lnf_effects_rh[k] ); + for ( l = k; l < e->num_lnf_effects - 1; l++ ) { + e->lnf_effects_neft[l] = e->lnf_effects_neft[l+1]; + e->lnf_effects_fl[l] = e->lnf_effects_fl[l+1]; + e->lnf_effects_rh[l] = e->lnf_effects_rh[l+1]; + } + e->num_lnf_effects--; + } + if ( k < e->num_lnf_effects ) { + /* illegal combination + */ + break; + } + j++; + } + + /* now merge all effects after i with same condition + * into that. + */ + j = i + 1; + while ( j < a->num_effects ) { + e_ = &(a->effects[j]); + if ( e_->removed ) { + j++; + continue; + } + + if ( !same_condition( e, e_ ) ) { + j++; + continue; + } + /* no matter what happens, we can get rid of effect e_ + */ + e_->removed = TRUE; + + /* illegality is inherited in both directions. + */ + if ( e_->illegal ) { + e->illegal = TRUE; + } + if ( e->illegal ) { + /* just for docu; it is removed anyway. + */ + e_->illegal = TRUE; + } + + if ( !e->illegal ) { + /* the combined effect appears to be legal. merge it. + */ + merge_effects( e, e_ ); + if ( e->illegal ) { + /* e might have become illegal. again, docu this. + */ + e_->illegal = TRUE; + } + } + + j++; + } + + /* now put the updated A and D info into e. + * + * have to be careful: it might be that there are + * now too many facts and we need to re-allocate + * e's capabilities. + */ + if ( lnum_A > e->num_adds ) { + free( e->adds ); + e->adds = ( int * ) calloc( lnum_A, sizeof( int ) ); + } + for ( j = 0; j < lnum_A; j++ ) { + e->adds[j] = lA[j]; + } + e->num_adds = lnum_A; + if ( lnum_D > e->num_dels ) { + free( e->dels ); + e->dels = ( int * ) calloc( lnum_D, sizeof( int ) ); + } + for ( j = 0; j < lnum_D; j++ ) { + e->dels[j] = lD[j]; + } + e->num_dels = lnum_D; + + /* increment current effects counter. + */ + i++; + } + } + +} + + + +Bool same_condition( ActionEffect *e, ActionEffect *e_ ) + +{ + + int i, j; + + if ( e->num_conditions != e_->num_conditions || + e->num_lnf_conditions != e_->num_lnf_conditions ) return FALSE; + + for ( i = 0; i < e->num_conditions; i++ ) { + for ( j = 0; j < e_->num_conditions; j++ ) { + if ( e->conditions[i] == e_->conditions[j] ) break; + } + if ( j == e_->num_conditions ) break; + } + if ( i < e->num_conditions ) return FALSE; + + for ( i = 0; i < e->num_lnf_conditions; i++ ) { + for ( j = 0; j < e_->num_lnf_conditions; j++ ) { + if ( e_->lnf_conditions_comp[j] != e->lnf_conditions_comp[i] ) continue; + if ( e_->lnf_conditions_rh[j] != e->lnf_conditions_rh[i] ) continue; + if ( !same_lnfs( e_->lnf_conditions_lh[j], e->lnf_conditions_lh[i] ) ) continue; + break; + } + if ( j == e_->num_lnf_conditions ) break; + } + if ( i < e->num_lnf_conditions ) return FALSE; + + return TRUE; + +} + + + +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ) + +{ + + int i, j; + + if ( l->num_pF != r->num_pF || + l->c != r->c ) return FALSE; + + for ( i = 0; i < l->num_pF; i++ ) { + for ( j = 0; j < r->num_pF; j++ ) { + if ( l->pF[i] != r->pF[j] ) continue; + if ( l->pC[i] != r->pC[j] ) { + /* same fluent with different weighting. + */ + return FALSE; + } + break; + } + if ( j == r->num_pF ) break; + } + if ( i < l->num_pF ) return FALSE; + + return TRUE; + +} + + + +void merge_effects( ActionEffect *e, ActionEffect *e_ ) + +{ + + int i, j; + + /* we don't care whether adds and dels intersect: + * they're allowed to by semantics. + */ + for ( i = 0; i < e_->num_adds; i++ ) { + for ( j = 0; j < lnum_A; j++ ) { + if ( lA[j] == e_->adds[i] ) break; + } + if ( j < lnum_A ) continue; + lA[lnum_A++] = e_->adds[i]; + } + for ( i = 0; i < e_->num_dels; i++ ) { + for ( j = 0; j < lnum_D; j++ ) { + if ( lD[j] == e_->dels[i] ) break; + } + if ( j < lnum_D ) continue; + lD[lnum_D++] = e_->dels[i]; + } + + for ( i = 0; i < e_->num_lnf_effects; i++ ) { + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_fl[j] == e_->lnf_effects_fl[i] ) break; + } + if ( j == e->num_lnf_effects ) { + /* new affected fluent! + */ + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e_->lnf_effects_neft[i]; + e->lnf_effects_fl[e->num_lnf_effects] = e_->lnf_effects_fl[i]; + /* we can also simply take the pointer: e_ is only marked as removed, + * but not freed. + */ + e->lnf_effects_rh[e->num_lnf_effects] = e_->lnf_effects_rh[i]; + e->num_lnf_effects++; + } else { + if ( e->lnf_effects_neft[j] == ASSIGN ) { + if ( e_->lnf_effects_neft[i] != ASSIGN || + !same_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ) ) { + e->illegal = TRUE; + return; + } + /* identical assigns. nothing needs to be done. + */ + } else { + if ( e_->lnf_effects_neft[i] == ASSIGN ) { + e->illegal = TRUE; + return; + } + merge_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ); + } + } + } + +} + + + +/* merge both LNFs into the left one. + * (only pF needed as both are already + * fully transformed) + */ +void merge_lnfs( LnfExpNode *l, LnfExpNode *r ) + +{ + + int i, j, k; + + for ( i = 0; i < r->num_pF; i++ ) { + + for ( j = 0; j < l->num_pF; j++ ) { + if ( r->pF[i] == l->pF[j] ) break; + } + if ( j < l->num_pF ) { + /* got that one in dest LNF already + */ + l->pC[j] += r->pC[i]; + continue; + } + + if ( lminus_fluent[r->pF[i]] != -1 ) { + /* this one was already translated. let's see + * if its counterpart is in the left lnf. + */ + for ( j = 0; j < l->num_pF; j++ ) { + if ( lminus_fluent[r->pF[i]] == l->pF[j] ) break; + } + if ( j < l->num_pF ) { + /* for this, we got the inverse one! + */ + l->pC[j] -= r->pC[i]; + if ( l->pC[j] < 0 ) { + l->pF[j] = r->pF[i]; + l->pC[j] *= (-1); + } + if ( l->pC[j] == 0 ) { + /* remove this entirely. + */ + for ( k = j; k < l->num_pF - 1; k++ ) { + l->pF[k] = l->pF[k+1]; + l->pC[k] = l->pC[k+1]; + } + l->num_pF--; + } + continue; + } + } + + /* we got neither that nor its counterpart. + */ + if ( l->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + l->pF[l->num_pF] = r->pF[i]; + l->pC[l->num_pF++] = r->pC[i]; + } + + + l->c += r->c; + +} + + + + + + + + + + + + + + + + + + + + + + +/************************************************************* + * LNF POST-PROCESSING II: ENCODE NON-MINIMAL LNFs. + *************************************************************/ + + + + + + + + + + + + + + + + + + + + + + + +void encode_lfns_as_artificial_fluents( void ) + +{ + + int i; + + /* for the artificial new ones, this will be set + * to the respective LNF. + */ + for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { + grelevant_fluents_lnf[i] = NULL; + } + + while ( TRUE ) { + /* ex non-minimal lnf in pre, cond, eff, or goal? + * + * (i.e., lnf != fl + c) + */ + if ( !ex_non_minimal_lnf_in_pre_cond_goal_eff() ) { + /* no --> we are finished. + */ + break; + } + /* otherwise, the respective LNF, without the + * constant part, is set up in + * lF...; (local global borrowed from above); + * + * introduce a new artificial fluent for that + * LNF + */ + introduce_artificial_fluent(); + /* replace all occurences in pres, conds, effs, and goals + */ + replace_non_minimal_lnf_with_artificial_fl(); + } + +} + + + +Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( glnf_goal_lh[i]->num_pF > 1 || + (glnf_goal_lh[i]->num_pF == 1 && glnf_goal_lh[i]->pC[0] != 1) ) { + for ( j = 0; j < glnf_goal_lh[i]->num_pF; j++ ) { + lF[j] = glnf_goal_lh[i]->pF[j]; + lC[j] = glnf_goal_lh[i]->pC[j]; + } + lnum_F = glnf_goal_lh[i]->num_pF; + return TRUE; + } + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( a->lnf_preconds_lh[i]->num_pF > 1 || + (a->lnf_preconds_lh[i]->num_pF == 1 && a->lnf_preconds_lh[i]->pC[0] != 1) ) { + for ( j = 0; j < a->lnf_preconds_lh[i]->num_pF; j++ ) { + lF[j] = a->lnf_preconds_lh[i]->pF[j]; + lC[j] = a->lnf_preconds_lh[i]->pC[j]; + } + lnum_F = a->lnf_preconds_lh[i]->num_pF; + return TRUE; + } + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* these will not be included into conn: + * merged into somewhere else. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_pF > 1 || + (e->lnf_conditions_lh[j]->num_pF == 1 && e->lnf_conditions_lh[j]->pC[0] != 1) ) { + for ( k = 0; k < e->lnf_conditions_lh[j]->num_pF; k++ ) { + lF[k] = e->lnf_conditions_lh[j]->pF[k]; + lC[k] = e->lnf_conditions_lh[j]->pC[k]; + } + lnum_F = e->lnf_conditions_lh[j]->num_pF; + return TRUE; + } + } + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_rh[j]->num_pF > 1 || + (e->lnf_effects_rh[j]->num_pF == 1 && e->lnf_effects_rh[j]->pC[0] != 1) ) { + for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { + lF[k] = e->lnf_effects_rh[j]->pF[k]; + lC[k] = e->lnf_effects_rh[j]->pC[k]; + } + lnum_F = e->lnf_effects_rh[j]->num_pF; + return TRUE; + } + } + } + } + + return FALSE; + +} + + + +void introduce_artificial_fluent( void ) + +{ + + int i; + + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = -1; + + /* no name --> is inferred in this case from _lnf + */ + + grelevant_fluents_lnf[gnum_relevant_fluents] = new_LnfExpNode(); + for ( i = 0; i < lnum_F; i++ ) { + grelevant_fluents_lnf[gnum_relevant_fluents]->pF[i] = lF[i]; + grelevant_fluents_lnf[gnum_relevant_fluents]->pC[i] = lC[i]; + } + grelevant_fluents_lnf[gnum_relevant_fluents]->num_pF = lnum_F; + + gnum_relevant_fluents++; + +} + + + +void replace_non_minimal_lnf_with_artificial_fl( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( !is_artificial_fluent( glnf_goal_lh[i] ) ) { + continue; + } + /* the pF here is the pF we are currently replacing. + */ + glnf_goal_lh[i]->pF[0] = gnum_relevant_fluents - 1; + glnf_goal_lh[i]->pC[0] = 1; + glnf_goal_lh[i]->num_pF = 1; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( !is_artificial_fluent( a->lnf_preconds_lh[i] ) ) { + continue; + } + a->lnf_preconds_lh[i]->pF[0] = gnum_relevant_fluents - 1; + a->lnf_preconds_lh[i]->pC[0] = 1; + a->lnf_preconds_lh[i]->num_pF = 1; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* these will not be included into conn: + * merged into somewhere else. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( !is_artificial_fluent( e->lnf_conditions_lh[j] ) ) { + continue; + } + e->lnf_conditions_lh[j]->pF[0] = gnum_relevant_fluents - 1; + e->lnf_conditions_lh[j]->pC[0] = 1; + e->lnf_conditions_lh[j]->num_pF = 1; + } + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( !is_artificial_fluent( e->lnf_effects_rh[j] ) ) { + continue; + } + e->lnf_effects_rh[j]->pF[0] = gnum_relevant_fluents - 1; + e->lnf_effects_rh[j]->pC[0] = 1; + e->lnf_effects_rh[j]->num_pF = 1; + } + } + } + +} + + + +Bool is_artificial_fluent( LnfExpNode *n ) + +{ + + int i, j; + + if ( n->num_nF != 0 ) { + printf("\n\nchecking non-empty nF for multiple fl!\n\n"); + exit( 1 ); + } + + if ( n->num_pF != lnum_F ) { + return FALSE; + } + + for ( i = 0; i < lnum_F; i++ ) { + for ( j = 0; j < n->num_pF; j++ ) { + if ( n->pF[j] != lF[i] ) continue; + if ( n->pC[j] != lC[i] ) { + /* wrong constant multiplier! + */ + return FALSE; + } + break; + } + if ( j == n->num_pF ) { + /* didn't find this fluent i in here. + */ + return FALSE; + } + } + + return TRUE; + +} + + + + + + + + + + + + + + + + + + +/************************************************************* + * AT LAST: PREPARATIONS FOR METRIC FUNCTION + *************************************************************/ + + + + + + + + + + + + + + + + + + +Bool setup_effect_costs( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, fl; + Bool non_zero = FALSE; + + if ( glnf_metric.num_pF == 0 ) { + /* no metric, or previously failed + */ + if ( gcmd_line.display_info ) { + printf("\nno metric specified."); + } + return FALSE; + } + + /* also in here: check if all parts of metric are defined + * if not, then they won't ever be because we do not allow + * assigners anyway. + * + * also, setup gtt total-time multipl. + * currently needed since in h fn effect cists are summed up + * --> may count the same action more than once, if we insert the + * timing cost into the effect cost. + * + * ... this is AWKWARD... probably would be better to simply + * associate costs always (including relaxed plans) + * only with ACTIONS! + */ + gtt = 0; + for ( i = 0; i < glnf_metric.num_pF; i++ ) { + if ( glnf_metric.pF[i] == -2 ) { + gtt = glnf_metric.pC[i]; + continue; + } + if ( !ginitial_state.f_D[glnf_metric.pF[i]] ) break; + } + if ( i < glnf_metric.num_pF ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: metric undefined initially. no optimization done."); + } + return FALSE; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + e->cost = 0; + + if ( e->removed || + e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + fl = e->lnf_effects_fl[j]; + for ( k = 0; k < glnf_metric.num_pF; k++ ) { + if ( fl == glnf_metric.pF[k] ) break; + } + if ( k == glnf_metric.num_pF ) continue; + + if ( e->lnf_effects_rh[j]->num_pF > 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: non-constant effect on metric. no optimization done."); + } + return FALSE; + } + if ( e->lnf_effects_neft[j] != INCREASE ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: assign on metric. no optimization done."); + } + return FALSE; + } + if ( e->lnf_effects_rh[j]->c < 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: change on metric in wrong direction. no optimization done."); + } + return FALSE; + } + + e->cost += glnf_metric.pC[k] * e->lnf_effects_rh[j]->c; + if ( e->cost > 0 ) { + non_zero = TRUE; + } + } + } + } + + if ( !non_zero ) { + if ( gtt == 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: trivial metric, all costs 0. no optimization done."); + } + return FALSE; + } + } + + return TRUE; + +} + + + + + + + + + + + + + + + + + + + + + +/************************************************************* + * AT VERY LAST: ACYCLIC := EFFS, AND STATIC FL RELEVANCE + *************************************************************/ + + + + + + + + + + + + + + + + + + + + + + + +void check_assigncycles( void ) + +{ + + int i, j, k, c = 0; + + gassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + gTassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + gassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + gTassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + } + + if ( gcmd_line.display_info > 1 ) { + printf("\n\nchecking for cyclic := effects"); + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + gassign_influence[i][j] = i_influences_j( i, j ); + gTassign_influence[i][j] = i_influences_j( i, j ); + } + } + /* compute transitive closure on dependencies + */ + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( gTassign_influence[i][j] ) { + for ( k = 0; k < gnum_real_fl_conn; k++ ) { + if ( gTassign_influence[j][k] ) { + gTassign_influence[i][k] = TRUE; + } + } + } + } + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( gTassign_influence[i][i] ) { + printf("\nnumerical variable "); + print_fl_name( i ); + printf(" lies on := propagation cycle!"); + c++; + } + } + if ( c > 0 ) { + printf("\nexit. (mneed computation not possible, RPG termination unclear)"); + printf("\n (questions to Joerg Hoffmann)\n\n"); + exit( 1 ); + } else { + if ( gcmd_line.display_info > 1 ) { + printf(" --- OK."); + } + } + +} + + + +Bool i_influences_j( int fi, int fj ) + +{ + + int i, j, fl_; + + for ( i = 0; i < gfl_conn[fj].num_AS; i++ ) { + fl_ = gfl_conn[fj].AS_fl_[i]; + if ( fl_ < 0 ) continue; + if ( fl_ == fi ) return TRUE; + if ( !gfl_conn[fl_].artificial ) continue; + for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { + if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; + } + } + + return FALSE; + +} + + + +void determine_fl_relevance( void ) + +{ + + int i, j, k, fl, fl_, ef, pc, g; + Bool **influenced_by; + + /* this here contains transfers from i to j i.e. if + * i is relevant then j is too + */ + influenced_by = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + influenced_by[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + influenced_by[i][j] = ( gassign_influence[j][i] || + i_inc_influences_j( j, i ) ); + } + } + /* transitive closure so we'll have direct access below. + */ + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[i][j] ) { + for ( k = 0; k < gnum_real_fl_conn; k++ ) { + if ( influenced_by[j][k] ) { + influenced_by[i][k] = TRUE; + } + } + } + } + } + + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + gfl_conn[i].relevant = FALSE; + } + /* relevance originates in effect preconds and goals. + */ + for ( ef = 0; ef < gnum_ef_conn; ef++ ) { + for ( pc = 0; pc < gef_conn[ef].num_f_PC; pc++ ) { + /* constraint here is gef_conn[ef].f_PC_fl[pc] >= [>] gef_conn[ef].f_PC_c[pc] + * where lh side can be lnf expression. + */ + fl = gef_conn[ef].f_PC_fl[pc]; + if ( fl < 0 ) { + printf("\nnegative constr lh??\n\n"); + exit( 1 ); + } + if ( !gfl_conn[fl].artificial ) { + gfl_conn[fl].relevant = TRUE; + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; + } + } else { + for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { + fl_ = gfl_conn[fl].lnf_F[i]; + gfl_conn[fl_].relevant = TRUE; + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; + } + } + } + } + } + for ( g = 0; g < gnum_fnumeric_goal; g++ ) { + /* constraint here is gfnumeric_goal_fl[g] >= [>] gfnumeric_goal_c[g] + * where lh side can be lnf expression. + */ + fl = gfnumeric_goal_fl[g]; + if ( fl < 0 ) { + printf("\nnegative constr lh??\n\n"); + exit( 1 ); + } + if ( !gfl_conn[fl].artificial ) { + gfl_conn[fl].relevant = TRUE; + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; + } + } else { + for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { + fl_ = gfl_conn[fl].lnf_F[i]; + gfl_conn[fl_].relevant = TRUE; + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; + } + } + } + } + + if ( 0 ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + printf("\n"); print_fl_name( i ); + printf (" --- relevant: %d", gfl_conn[i].relevant); + } + } + +} + + + +Bool i_inc_influences_j( int fi, int fj ) + +{ + + int i, j, fl_; + + for ( i = 0; i < gfl_conn[fj].num_IN; i++ ) { + fl_ = gfl_conn[fj].IN_fl_[i]; + if ( fl_ < 0 ) continue; + if ( fl_ == fi ) return TRUE; + if ( !gfl_conn[fl_].artificial ) continue; + for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { + if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; + } + } + + return FALSE; + +} + diff --git a/models/main_models/rt1/gen/ff_planner/expressions.h b/models/main_models/rt1/gen/ff_planner/expressions.h new file mode 100644 index 000000000..3546f2acd --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/expressions.h @@ -0,0 +1,106 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: expressions.h + * Description: headers for handling numerical expressions + * + * Author: Joerg Hoffmann 2001 + * + *********************************************************************/ + + + + + + + + + + + + + + +#ifndef _EXPRESSIONS_H +#define _EXPRESSIONS_H + + + + +Bool number_comparison_holds( Comparator c, float l, float r ); + + + +Bool transform_to_LNF( void ); +Bool is_linear_task( void ); +Bool is_linear_expression( ExpNode *n ); +void print_lnf_representation( void ); + + + +void normalize_expressions( void ); +Bool translate_divisions( ExpNode **n ); +void push_multiplications_down( ExpNode **n ); +void put_comp_into_normalized_locals( Comparator comp, + ExpNode *lh, + ExpNode *rh ); +void collect_normalized_locals( ExpNode *n, Bool positive ); + + + +void translate_subtractions( void ); +Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ); +void introduce_minus_fluent( int fl ); +void replace_fl_in_nF_with_minus_fl( int fl ); +void set_minus_fl_initial( int fl ); +void introduce_minus_fl_effects( int fl ); + + + +void summarize_effects( void ); +Bool same_condition( ActionEffect *e, ActionEffect *e_ ); +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); +void merge_effects( ActionEffect *e, ActionEffect *e_ ); +void merge_lnfs( LnfExpNode *l, LnfExpNode *r ); + + + +void encode_lfns_as_artificial_fluents( void ); +Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ); +void introduce_artificial_fluent( void ); +void replace_non_minimal_lnf_with_artificial_fl( void ); +Bool is_artificial_fluent( LnfExpNode *n ); + + + +Bool setup_effect_costs( void ); + + + +void check_assigncycles( void ); +Bool i_influences_j( int fi, int fj ); +void determine_fl_relevance( void ); +Bool i_inc_influences_j( int fi, int fj ); + + + +#endif /* _EXPRESSIONS_H */ diff --git a/models/main_models/rt1/gen/ff_planner/ff.h b/models/main_models/rt1/gen/ff_planner/ff.h new file mode 100644 index 000000000..d244df7ae --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/ff.h @@ -0,0 +1,2044 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: ff.h + * Description: Types and structures for the Metric-FastForward planner. + * Enhanced version with derived predicates and A*-epsilon + * + * --------- PDDL2.1 level 2 :: VERSION v 1.0 -------------- + * + * Author: Joerg Hoffmann 2012 + * Contact: hoffmann@cs.uni-saarland.de + * + *********************************************************************/ + + + + + + + + +#ifndef __FF_H +#define __FF_H + + + + + + +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + +/* + * ------------------------------------ DEFINES ---------------------------- + */ + + + + + + + + + + + +/*********************** + * MEANINGLESS HELPERS * + ***********************/ + + + + +/* strcmp returns 0 if two strings are equal, which is not nice */ +#define SAME 0 + + + + + + + + + +/**************** + * PARSING ETC. * + ****************/ + + + + + + + + + +/* various defines used in parsing + */ +#define HIDDEN_STR "#" +#define AXIOM_STR "AXIOM" +#define NAME_STR "name\0" +#define VARIABLE_STR "variable\0" +#define STANDARD_TYPE "OBJECT\0" +#define EITHER_STR "EITHER" + + + + + + + + + +/*************************** + * SOME ARBITRARY SETTINGS * + ***************************/ + + + + + + + +/* maximal string length + */ +#define MAX_LENGTH 256 + + +/* marks border between connected items + */ +#define CONNECTOR "~" + + +/* size of goals_at array in 1P extraction + */ +#define RELAXED_STEPS_DEFAULT 25 + + +/* size of hash table for repeated states checking + * during EHC breadth first search + */ +#define EHC_HASH_SIZE 8192 +#define EHC_HASH_BITS 8191 + + +/* size of hash table for repeated states checking + * in plan construction + */ +#define PLAN_HASH_SIZE 1024 +#define PLAN_HASH_BITS 1023 + + +/* size of hash table for repeated states checking + * during BFS search + */ +#define BFS_HASH_SIZE 65536 +#define BFS_HASH_BITS 65535 + + +/* cut random values of facts off modulo this value, + * to make state sums fit into a single integer + */ +#define BIG_INT 1500000 + + +/* max number of different fluents in one list of LNF + */ +#define MAX_LNF_F 25 + + +/* max number of comps in one cond / precond / goal + */ +#define MAX_LNF_COMPS 100 + + +/* max number of lnf effects in one action effect + */ +#define MAX_LNF_EFFS 50 + + + + + + + +/************************ + * INSTANTIATION LIMITS * + ************************/ + + + + + + + + +#define MAX_CONSTANTS 2000 +#define MAX_PREDICATES 50 +#define MAX_FUNCTIONS 50 +#define MAX_TYPES 50 +#define MAX_ARITY 5 +#define MAX_VARS 15 + + +#define MAX_TYPE 2000 + + +#define MAX_OPERATORS 50000 + + +/* in DNF: AND with OR - sons - collect 'hitting set': + * one son of each OR node. + * + * this here is initial max number of such son s that can be collected + * (grows dynamically, if required) + */ +#define MAX_HITTING_SET_DEFAULT 1000 + + +#define MAX_TYPE_INTERSECTIONS 10 + + +#define MAX_RELEVANT_FACTS 150000 +#define MAX_RELEVANT_FLUENTS 1000 + + + + + + +/****************************************** + * DOMAIN STRUCTURE AND SEARCHING LIMITS * + ******************************************/ + + + + + + +#define MAX_STATE 800 + + +#define MAX_PLAN_LENGTH 500 + + + + + + +/**************** + * CODE DEFINES * + ****************/ + + + + + + + + + +/* not a real 'code' define; used in relax and search to encode + * infinite level number / plan length + */ +#ifndef INFINITY +#define INFINITY -1 +#endif + + + + + + + +/* define boolean types if not allready defined + */ +#ifndef Bool +typedef unsigned char Bool; +#ifndef TRUE /* we assume that FALSE is also not defined */ +#define TRUE 1 +#define FALSE 0 +#endif /* TRUE */ +#endif /* Bool */ + + +/* code a param number into a negative number and vice versa + */ +#define ENCODE_VAR( val ) (val * (-1)) - 1 +#define DECODE_VAR( val ) (val + 1) * (-1) + +#define GET_CONSTANT( val, pointer ) ( val >= 0 ) ? val : pointer->inst_table[DECODE_VAR( val )] + + +/* Check allocated memory + */ +#define CHECK_PTR(p) if (NULL == (p)) { \ + fprintf(stdout, "\n\aNO MEMORY in file %s:%d\n\n", __FILE__, __LINE__); \ + exit(1);} + + +/* add elapsed time from main local time vars to specified val + */ +#define TIME( val ) val += ( float ) ( ( end.tms_utime - start.tms_utime + \ + end.tms_stime - start.tms_stime ) / 100.0 ) + + + + + + + + + + + + +/* + * ------------------------------ DATA STRUCTURES ---------------------------- + */ + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + +/* all command switches + */ +struct _command_line { + + char path[MAX_LENGTH]; + char ops_file_name[MAX_LENGTH]; + char fct_file_name[MAX_LENGTH]; + int display_info; + int debug; + + int search_config; + Bool cost_rplans; + + int w; + + float cost_bound; + +}; + + +typedef char *Token; + + + + + + + + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + + + + +/* A list of strings + */ +typedef struct _TokenList { + + char *item; + struct _TokenList *next; + +} TokenList; + + + +/* list of string lists + */ +typedef struct _FactList { + + TokenList *item; + struct _FactList *next; + +} FactList; + + + +/* structure to store typed-list-of /, + * as they are declared in PDDL files + */ +typedef struct _TypedList { + + char *name; + + /* each item in this list is the name of a type which + * our type is the union of (EITHER - types ...) + * + * usually, this will default to a single-item TokenList. + */ + TokenList *type; + /* after first sweep, this will contain the number in type table + */ + int n; + + struct _TypedList *next; + +} TypedList; + + + +/* only needed to parse in the predicates and their arg + * definitions + */ +typedef struct _TypedListList { + + char *predicate; + + TypedList *args; + + struct _TypedListList *next; + +} TypedListList; + + + +typedef enum _ExpConnective{FHEAD = 1000, + NUMBER, + MINUS, + AD, + SU, + MU, + DI} ExpConnective; + + + +typedef struct _ParseExpNode { + + ExpConnective connective; + + /* NULL anywhere except when node is FHEAD or NUMBER + * (in which case it is fn name ... resp. number (int or float) as string + */ + TokenList *atom; + + /* both NULL in FHEAD; + * in MINUS, left is son and right is NULL + * else (binary operators), left and right operand + */ + struct _ParseExpNode *leftson, *rightson; + +} ParseExpNode; + + + +/* This type indicates whether a node in the pddl tree stands for + * an atomic expression, a junctor or a quantor. + */ +typedef enum _Connective{TRU = 2000, + FAL, + ATOM, + COMP, + NEF, + NOT, + AND, + OR, + ALL, + EX, + WHEN} Connective; + + + +typedef enum _Comparator{IGUAL = 3000, /* technical if conds are array comp exp, resp float */ + LE, + LEQ, + EQ, + GEQ, + GE} Comparator; + + + + +typedef enum _NumericEffectType{ASSIGN = 4000, + SCALE_UP, + SCALE_DOWN, + INCREASE, + DECREASE} NumericEffectType; + + + + +/* + * This is a node in the tree to parse PDDL files + */ +typedef struct _PlNode { + + /* type of the node + */ + Connective connective; + + /* only for parsing: the var args in quantifiers + */ + TypedList *parse_vars; + + /* AND, OR, NOT, WHEN, + * COMP, NEF => NULL + * ALL, EX => the quantified variable with its type + * ATOM => the atom as predicate->param1->param2->... + */ + TokenList *atom; + /* all except COMP, NEF => NULL + * COMP, NEF => left hand, right hand + */ + Comparator comp; + NumericEffectType neft; + ParseExpNode *lh, *rh; + + /* (a) for AND, OR this is the list of sons(a AND b AND c...), + * (b) for the rest this is the son, e.g. a subtree that is negated + * (c) for WHEN, the first son is the condition and the next son + * is the effect + */ + struct _PlNode *sons; + + /* if you have a list of sons, they are connected by next + */ + struct _PlNode *next; + +} PlNode; + + +/* + * This resembles an uninstantiated PDDL operator + */ +typedef struct _PlOperator { + + char *name; + Bool axiom; + + /* only important for PDDL where :VARS may be added to the param list + * which must be hidden when writing the plan to an output file + */ + int number_of_real_params; + + /* the params, as they are declared in domain file + */ + TypedList *parse_params; + + /* params is a list of variable/type pairs, such that: + * factlist->item = [variable] -> [type] + */ + FactList *params; + PlNode *preconds; + PlNode *effects; + + struct _PlOperator *next; + +} PlOperator; + + + + + + + + + + + + + + + +/***************** + * INSTANTIATION * + *****************/ + + + + + + + + + +/* helpers + */ + +typedef int TypeArray[MAX_TYPE_INTERSECTIONS]; + +typedef int *int_pointer; + + + + +/* first step structures: parsing & preprocessing + */ + +typedef struct _Fact { + + int predicate, args[MAX_ARITY]; + +} Fact; + + + +typedef struct _Fluent { + + int function, args[MAX_ARITY]; + +} Fluent; + + + +typedef struct _FluentValue { + + Fluent fluent; + float value; + +} FluentValue; + + + +typedef struct _Facts { + + Fact *fact; + + struct _Facts *next; + +} Facts; + + + +typedef struct _FluentValues { + + Fluent fluent; + float value; + + struct _FluentValues *next; + +} FluentValues; + + + +typedef struct _ExpNode { + + ExpConnective connective; + + /* in FHEAD nodes, pre-processing + */ + Fluent *fluent; + /* in FHEAD nodes after pre-processes have finished. + * (internal number of relevant fluent, or -1 if not + * relevant) + */ + int fl; + /* helper for LNF: if that fl is multiplied, this is the + * respective constant after pre-normalization. + */ + float c; + + /* in NUMBER nodes + */ + float value; + + /* in MINUS nodes + */ + struct _ExpNode *son; + + /* in all others + */ + struct _ExpNode *leftson, *rightson; + +} ExpNode, *ExpNode_pointer; + + + +typedef struct _WffNode { + + Connective connective; + + /* in ALL/EX s + */ + int var, var_type; + char *var_name; + + /* in AND/OR s + */ + struct _WffNode *sons; + /* sons are doubly connected linear list + */ + struct _WffNode *next; + struct _WffNode *prev; + + /* in ATOMs + */ + Fact *fact; + /* after translation: mark NOT-p s for efficiency + */ + int NOT_p; + + /* in ALL/EX/NOT + */ + struct _WffNode *son; + + /* in COMP + */ + Comparator comp; + ExpNode *lh, *rh; + + /* for expansion speedup + */ + Bool visited; + + /* no WHEN s here... use Pl Connectives anyway for simplicity + */ + +} WffNode, *WffNode_pointer; + + + +typedef struct _Literal { + + Bool negated; + + Fact fact; + + struct _Literal *next; + struct _Literal *prev; + +} Literal; + + + +typedef struct _NumericEffect { + + Fluent fluent; + NumericEffectType neft; + + ExpNode *rh; + + struct _NumericEffect *next; + struct _NumericEffect *prev; + +} NumericEffect; + + + +typedef struct _Effect { + + int num_vars, var_types[MAX_VARS]; + char *var_names[MAX_VARS]; + + WffNode *conditions; + + Literal *effects; + NumericEffect *numeric_effects; + + struct _Effect *next; + struct _Effect *prev; + +} Effect; + + + +typedef struct _Operator { + + char *name, *var_names[MAX_VARS]; + int number_of_real_params; + Bool axiom; + + int num_vars, var_types[MAX_VARS]; + Bool removed[MAX_VARS]; + + WffNode *preconds; + + Effect *effects; + + Bool hard; + +} Operator, *Operator_pointer; + + + + + + +/* second step: structures that keep already normalized + * operators + */ + + + + +typedef struct _NormEffect { + + int num_vars, var_types[MAX_VARS]; + int inst_table[MAX_VARS]; + + Fact *conditions; + int num_conditions; + + Fact *adds; + int num_adds; + Fact *dels; + int num_dels; + + /* numerical parts: not yet normalized any further; seems that + * normalizing requires certain additional structures + + * transformation, and that these will better be done when + * the representation is fully instantiated already. + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + Fluent *numeric_effects_fluent; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + struct _NormEffect *prev; + struct _NormEffect *next; + +} NormEffect; + + + +typedef struct _NormOperator { + + Operator *operator; + + int num_vars, var_types[MAX_VARS]; + int inst_table[MAX_VARS]; + int removed_vars[MAX_VARS], num_removed_vars, type_removed_vars[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric precondition still full scale represented, see above + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + NormEffect *effects; + + Bool out; + +} NormOperator, *NormOperator_pointer; + + + +/* minimal info for a fully instantiated easy operator; + * yields one action when expanded + */ +typedef struct _EasyTemplate { + + NormOperator *op; + int inst_table[MAX_VARS]; + + struct _EasyTemplate *prev; + struct _EasyTemplate *next; + +} EasyTemplate; + + + + + + +/* structures for hard ops + */ + + + + + +/* intermediate step: structure for keeping hard ops + * with normalized precondition, but arbitrary + * effect conditions + */ +typedef struct _MixedOperator { + + Operator *operator; + + int inst_table[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric part, pre-normalized + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + Effect *effects; + + struct _MixedOperator *next; + +} MixedOperator; + + + +/* last hard step: everything is action - like, except that + * facts are not yet integer coded + */ + + + +typedef struct _PseudoActionEffect { + + Fact *conditions; + int num_conditions; + + Fact *adds; + int num_adds; + Fact *dels; + int num_dels; + + + /* and the numeric parts again... + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + Fluent *numeric_effects_fluent; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + struct _PseudoActionEffect *next; + +} PseudoActionEffect; + + + +typedef struct _PseudoAction { + + Operator *operator; + + int inst_table[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric part, pre-normalized + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + PseudoActionEffect *effects; + int num_effects; + +} PseudoAction, *PseudoAction_pointer; + + + + +/* final domain representation structure + */ + + + +typedef struct _LnfExpNode { + + int pF[MAX_LNF_F]; + float pC[MAX_LNF_F]; + int num_pF; + + int nF[MAX_LNF_F]; + float nC[MAX_LNF_F]; + int num_nF; + + float c; + +} LnfExpNode, *LnfExpNode_pointer; + + + +typedef struct _ActionEffect { + + int *conditions; + int num_conditions; + + int *adds; + int num_adds; + int *dels; + int num_dels; + + /* and the numeric parts again; fluents all as fl ints; + * + * normalization for cond as below for pre; + * norm. for effects by restriction of types (?), + * right hand side float (?) + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + int *numeric_effects_fl; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + /* LNF + */ + Comparator *lnf_conditions_comp; + LnfExpNode_pointer *lnf_conditions_lh; + float *lnf_conditions_rh; + int num_lnf_conditions; + + NumericEffectType *lnf_effects_neft; + int *lnf_effects_fl; + LnfExpNode_pointer *lnf_effects_rh; + int num_lnf_effects; + + /* this is true iff the numerical part of the effects affects or accesses + * an undefined fluent (i.e. in numeric_effects_fl or numeric_effects_rh ) + * --- then, if the effect appears, the action is + * illegal. + */ + Bool illegal; + + /* helper + */ + Bool removed; + + float cost; + +} ActionEffect; + + + +typedef struct _Action { + + NormOperator *norm_operator; + PseudoAction *pseudo_action; + Bool axiom; + + char *name; + int num_name_vars; + int name_inst_table[MAX_VARS]; + + int inst_table[MAX_VARS]; + + int *preconds; + int num_preconds; + /* numeric part, in general format, with fluents encoded as fl ints + * + * also, will (?) be transformed to lh fl, rh float; then, expnodes as + * fast accessible as specialised structures. + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + /* LNF + */ + Comparator *lnf_preconds_comp; + LnfExpNode_pointer *lnf_preconds_lh; + float *lnf_preconds_rh; + int num_lnf_preconds; + + ActionEffect *effects; + int num_effects; + + struct _Action *next; + +} Action; + + + + + + + + + + + +/***************************************************** + * BASIC OP AND FT STRUCTURES FOR CONNECTIVITY GRAPH * + *****************************************************/ + + + + + + + + + + + +typedef struct _OpConn { + + /* to get name + */ + Action *action; + Bool axiom; + + /* effects + */ + int *E; + int num_E; + + /* member for applicable actions extraction + */ + Bool is_in_A; + Bool is_in_A_axioms; + + /* members for 1Ph - H(S) extraction + */ + int is_used; + Bool is_in_H; + + /* this is a bit imprecise since actually, in this + * framework here, the cost of the action may depend on + * which conditional effects actually apply. + * ... anyway, this makes things much easier for the case + * where there aren't any effect conditions. all cost handling + * is now based on this..!! + */ + float cost; + +} OpConn; + + + +typedef struct _EfConn { + + int op; + + /* true if access to always undefined fluent, or + * conflicting assignments. + * + * if that is the case then nothing except condition is set: + * the effect is completely ignored except that + * it renders the op unapplicable when its condition + * is true. + */ + Bool illegal; + + /* this one means we found in conn that it is useless (empty) + */ + Bool removed; + + /* this is the cost; can be non-zero if a metric was specified + * and established + */ + float cost; + + int *PC; + int num_PC; + /* numeric part + */ + Comparator *f_PC_comp; /* either GEQ or GE */ + int *f_PC_fl; + float *f_PC_c; + int num_f_PC; + /* array indexed by fl number, to fast know whether + * new fluent value is high enough + */ + Comparator *f_PC_direct_comp; + float *f_PC_direct_c; + + /* logic effects + */ + int *A; + int num_A; + int *D; + int num_D; + /* and the numeric ones; fl_ is the encoding of the LNF + * on the right hand side, without constant part + * (special treatment for that as it's supposed + * to be the most common thing!!) + */ + int *IN_fl; + int *IN_fl_; + float *IN_c; + int num_IN; + + int *AS_fl; + int *AS_fl_; + float *AS_c; + int num_AS; + + /* implied effects + */ + int *I; + int num_I; + + /* members for relaxed fixpoint computation + */ + int level;/* first "cost level" where ef appears */ + float RPGcost;/* max_{p prec} cost(p)+cost(op(ef)) */ + + Bool in_E; + int num_active_PCs; + Bool ch; + + /* RPG + */ + int num_active_f_PCs; + + /* 1P; an effect can be selected several times + * for increasing a fluent. + */ + int in_plan; + +} EfConn; + + + +typedef struct _FtConn { + + /* effects it is union conds, pres element of + */ + int *PC; + int num_PC; + + /* efs that add or del it + */ + int *A; + int num_A; + + int *D; + int num_D; + + /* members for orderings preprocessing + */ + int *False; + int num_False; + + /* members for relaxed fixpoint computation + */ + int level;/* first "cost level" where ft appears */ + float RPGcost;/* min_{e adder} cost(e) */ + Bool in_F; + + /* members for 1Ph extraction + */ + int is_goal; + int is_true; + Bool ch; + + /* search + */ + int rand;/* for hashing */ + + /* is this the effect of an axiom? + * needed to quickly filter out derived facts, in state + * transitions! + */ + Bool axiom_added; + +} FtConn; + + + +typedef struct _FlConn { + + /* effects it is union conds, pres required + */ + int *PC; + int num_PC; + + /* efs that inc, ass it and by which encoded fluents and constants + */ + int *IN; + int *IN_fl_; + float *IN_c; + int num_IN; + + int *AS; + int *AS_fl_; + float *AS_c;/* see above */ + int num_AS; + + /* is it an artificial fluent? + */ + Bool artificial; + /* if so, then this here is the linear equation + * it stands for + */ + int *lnf_F; + float *lnf_C; + int num_lnf; + + + /* the termination criterion for RPG building is based on mneed, see + * JAIR article for definition; + * + * as the name suggests, we use the bool to indicate that this one is not + * needed at all + */ + Bool mneed_is_minusinfty; + float mneed; + /* see JAIR; shortcut for never needed at all. + */ + Bool relevant; + + /* the following are members handled within heuristic algorithms. + */ + + /* this are arrays saying what the max value at + * the levels in the RPG is, resp. whether the value + * can be defined there at all, resp. what the increasers + * at that level have added. + */ + Bool *def; + float *level; + + /* for handling assigners in RPG: is an assigner in there yet, + * and if so what is their max value? + */ + Bool curr_assigned; + float curr_max_assigned; + + int rand;/* for hashing */ + +} FlConn; + + + + + + + + + + + + +/**************************** + * STRUCTURES FOR SEARCHING * + ****************************/ + + + + + + + + + +typedef struct _State { + + int *F; + int num_F; + + Bool *f_D; + float *f_V; + +} State, *State_pointer; + + + +typedef struct _EhcNode { + + State S; + + int op; + int depth; + + struct _EhcNode *father; + struct _EhcNode *next; + +} EhcNode; + + + +typedef struct _EhcHashEntry { + + int sum; + + EhcNode *ehc_node; + + struct _EhcHashEntry *next; + +} EhcHashEntry, *EhcHashEntry_pointer; + + + +typedef struct _PlanHashEntry { + + int sum; + State S; + + /* step is number of op that is EXECUTED in S; + * -1 means that this state is no longer contained in plan + */ + int step; + struct _PlanHashEntry *next_step; + + struct _PlanHashEntry *next; + +} PlanHashEntry, *PlanHashEntry_pointer; + + + +typedef struct _BfsNode { + + State S; + int op; + + /* number of steps from ini state to here + */ + int ini_distance; + + /* number of steps in relaxed plan for this state + */ + int goal_distance; + + /* g-value and h-value, ie summed-up cost to here, + * summed-up cost in rplan for here. + * used in all optimization configs + */ + float g; + float h; + + /* f-value. in weighted A*, f=g+w*h; in A*epsilon, f=g+h + */ + float f; + + /* The applicable actions -- may be only the helpful ones, + * in case helpful actions are used! + */ + int *A; + int num_A; + + struct _BfsNode *father; + + struct _BfsNode *next; + struct _BfsNode *prev; + +} BfsNode; + + + +typedef struct _BfsHashEntry { + + int sum; + + BfsNode *bfs_node; + + struct _BfsHashEntry *next; + +} BfsHashEntry, *BfsHashEntry_pointer; + + + + + + + + + + + + + +/* + * -------------------------------- MAIN FN HEADERS ---------------------------- + */ + + + + + + + + + + + + + + + + + +void output_planner_info( void ); +void ff_usage( void ); +Bool process_command_line( int argc, char *argv[] ); + + + + + + + + + +/* + * ----------------------------- GLOBAL VARIABLES ---------------------------- + */ + + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + + + +/* used to time the different stages of the planner + */ +extern float gtempl_time, greach_time, grelev_time, gconn_time; +extern float gLNF_time, gsearch_time; + +/* the command line inputs + */ +extern struct _command_line gcmd_line; + +/* number of states that got heuristically evaluated + */ +extern int gevaluated_states; + +/* maximal depth of breadth first search + */ +extern int gmax_search_depth; + + + + + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + + + + + +/* used for pddl parsing, flex only allows global variables + */ +extern int gbracket_count; +extern char *gproblem_name; + +/* The current input line number + */ +extern int lineno; + +/* The current input filename + */ +extern char *gact_filename; + +/* The pddl domain name + */ +extern char *gdomain_name; + +/* loaded, uninstantiated operators + */ +extern PlOperator *gloaded_ops; + +/* stores initials as fact_list + */ +extern PlNode *gorig_initial_facts; + +/* not yet preprocessed goal facts + */ +extern PlNode *gorig_goal_facts; + +/* the types, as defined in the domain file + */ +extern TypedList *gparse_types; + +/* the constants, as defined in domain file + */ +extern TypedList *gparse_constants; + +/* the predicates and their arg types, as defined in the domain file + */ +extern TypedListList *gparse_predicates; + +/* the functions and their arg types, as defined in the domain file + */ +extern TypedListList *gparse_functions; + +/* the objects, declared in the problem file + */ +extern TypedList *gparse_objects; + +/* the metric + */ +extern Token gparse_optimization; +extern ParseExpNode *gparse_metric; + + +/* connection to instantiation ( except ops, goal, initial ) + */ + +/* all typed objects + */ +extern FactList *gorig_constant_list; + +/* the predicates and their types + */ +extern FactList *gpredicates_and_types; + +/* the functions and their types + */ +extern FactList *gfunctions_and_types; + + + + + + + + + + + + + + +/***************** + * INSTANTIATING * + *****************/ + + + + + + + + + + +/* global arrays of constant names, + * type names (with their constants), + * predicate names, + * predicate aritys, + * defined types of predicate args + */ +extern Token gconstants[MAX_CONSTANTS]; +extern int gnum_constants; +extern Token gtype_names[MAX_TYPES]; +extern int gtype_consts[MAX_TYPES][MAX_TYPE]; +extern Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; +extern int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ +extern int gtype_size[MAX_TYPES]; +extern int gnum_types; +extern Token gpredicates[MAX_PREDICATES]; +extern int garity[MAX_PREDICATES]; +extern Bool gaxiom_added[MAX_PREDICATES]; +extern int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; +extern int gnum_predicates; +extern Token gfunctions[MAX_FUNCTIONS]; +extern int gf_arity[MAX_FUNCTIONS]; +extern int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; +extern int gnum_functions; + + + + +/* the domain in first step integer representation + */ +extern Operator_pointer goperators[MAX_OPERATORS]; +extern int gnum_operators; +extern Fact *gfull_initial; +extern int gnum_full_initial; +extern FluentValue *gfull_fluents_initial; +extern int gnum_full_fluents_initial; +extern WffNode *ggoal; + +extern ExpNode *gmetric; + + + +/* stores inertia - information: is any occurence of the predicate + * added / deleted in the uninstantiated ops ? + */ +extern Bool gis_added[MAX_PREDICATES]; +extern Bool gis_deleted[MAX_PREDICATES]; + +/* for functions we *might* want to say, symmetrically, whether it is + * increased resp. decreased at all. + * + * that is, however, somewhat involved because the right hand + * sides can be arbirtray expressions, so we have no guarantee + * that increasing really does adds to a functions value... + * + * thus (for the time being), we settle for "is the function changed at all?" + */ +extern Bool gis_changed[MAX_FUNCTIONS]; + + + +/* splitted initial state: + * initial non static facts, + * initial static facts, divided into predicates + * (will be two dimensional array, allocated directly before need) + */ +extern Facts *ginitial; +extern int gnum_initial; +extern Fact **ginitial_predicate; +extern int *gnum_initial_predicate; + +/* same thing for functions + */ +extern FluentValues *gf_initial; +extern int gnum_f_initial; +extern FluentValue **ginitial_function; +extern int *gnum_initial_function; + + + +/* the type numbers corresponding to any unary inertia + */ +extern int gtype_to_predicate[MAX_PREDICATES]; +extern int gpredicate_to_type[MAX_TYPES]; + +/* (ordered) numbers of types that new type is intersection of + */ +extern TypeArray gintersected_types[MAX_TYPES]; +extern int gnum_intersected_types[MAX_TYPES]; + + + +/* splitted domain: hard n easy ops + */ +extern Operator_pointer *ghard_operators; +extern int gnum_hard_operators; +extern NormOperator_pointer *geasy_operators; +extern int gnum_easy_operators; + + + +/* so called Templates for easy ops: possible inertia constrained + * instantiation constants + */ +extern EasyTemplate *geasy_templates; +extern int gnum_easy_templates; + + + +/* first step for hard ops: create mixed operators, with conjunctive + * precondition and arbitrary effects + */ +extern MixedOperator *ghard_mixed_operators; +extern int gnum_hard_mixed_operators; + + + +/* hard ''templates'' : pseudo actions + */ +extern PseudoAction_pointer *ghard_templates; +extern int gnum_hard_templates; + + + +/* store the final "relevant facts" + */ +extern Fact grelevant_facts[MAX_RELEVANT_FACTS]; +extern int gnum_relevant_facts; +extern int gnum_pp_facts; +/* store the "relevant fluents" + */ +extern Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; +extern int gnum_relevant_fluents; +extern Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; +/* this is NULL for normal, and the LNF for + * artificial fluents. + */ +extern LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; + + + +/* the final actions and problem representation + */ +extern Action *gactions; +extern int gnum_actions; +extern State ginitial_state; +extern int *glogic_goal; +extern int gnum_logic_goal; +extern Comparator *gnumeric_goal_comp; +extern ExpNode_pointer *gnumeric_goal_lh, *gnumeric_goal_rh; +extern int gnum_numeric_goal; + + + +/* to avoid memory leaks; too complicated to identify + * the exact state of the action to throw away (during construction), + * memory gain not worth the implementation effort. + */ +extern Action *gtrash_actions; + + + +/* additional lnf step between finalized inst and + * conn graph + */ +extern Comparator *glnf_goal_comp; +extern LnfExpNode_pointer *glnf_goal_lh; +extern float *glnf_goal_rh; +extern int gnum_lnf_goal; + +extern LnfExpNode glnf_metric; +extern Bool goptimization_established; + + + +/********************** + * CONNECTIVITY GRAPH * + **********************/ + + + + + +/* one ops (actions) array ... + */ +extern OpConn *gop_conn; +extern int gnum_op_conn; + + + +/* one effects array ... + */ +extern EfConn *gef_conn; +extern int gnum_ef_conn; + + + +/* one facts array. + */ +extern FtConn *gft_conn; +extern int gnum_ft_conn; + + + +/* and: one fluents array. + */ +extern FlConn *gfl_conn; +extern int gnum_fl_conn; +extern int gnum_real_fl_conn;/* number of non-artificial ones */ + + + +/* final goal is also transformed one more step. + */ +extern int *gflogic_goal; +extern int gnum_flogic_goal; +extern Comparator *gfnumeric_goal_comp; +extern int *gfnumeric_goal_fl; +extern float *gfnumeric_goal_c; +extern int gnum_fnumeric_goal; + +/* direct access (by relevant fluents) + */ +extern Comparator *gfnumeric_goal_direct_comp; +extern float *gfnumeric_goal_direct_c; + + + + + + + + + + + + + +/******************* + * SEARCHING NEEDS * + *******************/ + + + + + + + + + + + + +/* applicable actions + */ +extern int *gA;/* non-axioms */ +extern int gnum_A; +extern int *gA_axioms; /* axioms */ +extern int gnum_A_axioms; + + + +/* communication from extract 1.P. to search engine: + * 1P action choice + */ +extern int *gH; +extern int gnum_H; +/* added cost of relaxed plan + */ +extern float gh_cost; +/* hmax value + */ +extern float ghmax; + + + +/* to store plan + */ +extern int gplan_ops[MAX_PLAN_LENGTH]; +extern int gnum_plan_ops; + + + +/* stores the states that the current plan goes through + */ +extern State gplan_states[MAX_PLAN_LENGTH + 1]; + + + +/* dirty: multiplic. of total-time in final metric LNF + */ +extern float gtt; + + + + + + +/* the mneed structures + * + * assign propagation pairs i, j, and transitive such pairs. + */ +extern Bool **gassign_influence; +extern Bool **gTassign_influence; + + + +/* the real var input to the mneed computation. + */ +extern Bool *gmneed_start_D; +extern float *gmneed_start_V; + + + +/* does this contain conditional effects? + * (if it does then the state hashing has to be made more + * cautiously) + */ +extern Bool gconditional_effects; + + +/* easier to question: are we optimizing or no? + */ +extern Bool gcost_minimizing; + + +/* stores current A* weight: this is initially given by user, + * but changes during anytime search. + */ +extern float gw; +/* this is the minimum weight, ie we'll stop once the weight update + * does/would yield a value <= this. + * if no such minim weight is given, this will be -1 + */ +extern float gmin_w; + + +/* this one says whether or not we are actually using + * cost-minimizing rplans. + * this will be the case by default if we're running cost- + * minimizing searches. it can be switched off by a flag; + * it is automatically switched off in case there are + * numeric preconditions/goals: for this case, + * cost-minimizing rplans are not implemented (a numeric prec + * may cause an action to come in "later" on in the RPG although + * its logical pres are easy. in that case, any new effects will + * have a smaller RPGcost value than facts we already have waiting. + * in other words, the "Dijsktra" nature breaks. + * + * ... I suppose there may be a generic solution to this that + * can handle numeric precs/goals. Doesn't seem important enough + * to bother. + */ +extern Bool gcost_rplans; + + +#endif diff --git a/models/main_models/rt1/gen/ff_planner/inst_easy.c b/models/main_models/rt1/gen/ff_planner/inst_easy.c new file mode 100644 index 000000000..db6c1681b --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_easy.c @@ -0,0 +1,1220 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: inst_easy.c + * Description: functions for multiplying easy operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_easy.h" + + + + + + + + +void build_easy_action_templates( void ) + +{ + + int i, j; + NormOperator *o; + EasyTemplate *t; + + cleanup_easy_domain(); + + if ( gcmd_line.display_info == 110 ) { + printf("\n\ncleaned up easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + encode_easy_unaries_as_types(); + + if ( gcmd_line.display_info == 111 ) { + printf("\n\nunaries encoded easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + multiply_easy_effect_parameters(); + + if ( gcmd_line.display_info == 112 ) { + printf("\n\neffects multiplied easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + multiply_easy_op_parameters(); + + if ( gcmd_line.display_info == 113 ) { + printf("\n\ninertia free easy operators are:"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + printf("\n\n"); + fflush( stdout ); + } + + if ( gcmd_line.display_info == 114 ) { + printf("\n\neasy operator templates are:\n"); + + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + printf("\n\n-----------operator %s:-----------", o->operator->name); + for ( t = geasy_templates; t; t = t->next ) { + if ( t->op != o ) { + continue; + } + printf("\ninst: "); + for ( j = 0; j < o->num_vars; j++ ) { + if ( t->inst_table[j] < 0 ) { + printf("\nuninstantiated param in template! debug me, please\n\n"); + exit( 1 ); + } + printf("x%d = %s", j, gconstants[t->inst_table[j]]); + if ( j < o->num_vars - 1 ) { + printf(", "); + } + } + } + } + fflush( stdout ); + } + +} + + + + + + + + + + + +/********************************* + * EASY DOMAIN CLEANUP FUNCTIONs * + *********************************/ + + + + + + + + + + + +void cleanup_easy_domain( void ) + +{ + + int i, i1, i2, i3, i4, a; + NormOperator *o; + NormEffect *e; + + /* most likely ( for sure ? ) we do not need this function call here, + * as empty types are recognised in translation already. + * + * however, who knows .. ? doesn't need any real computation time anyway. + * + * function DOES make sense after unaries encoding, as artificial types + * might well be empty. + */ + handle_empty_easy_parameters(); + + /* remove identical preconds and effects; + * VERY unlikely that such will get down to here, after all + * the formula preprocessing, but possible (?) in principle. + * takes no computation time. + * + * also, remove effect conditions that are contained in the + * preconditions. + */ + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + i1 = 0; + while ( i1 < o->num_preconds-1 ) { + i2 = i1+1; + while ( i2 < o->num_preconds ) { + if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) { + for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) { + o->preconds[i3].predicate = o->preconds[i3+1].predicate; + for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) { + o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4]; + } + } + o->num_preconds--; + } else { + i2++; + } + } + i1++; + } + + for ( e = o->effects; e; e = e->next ) { + i1 = 0; + while ( i1 < e->num_conditions-1 ) { + i2 = i1+1; + while ( i2 < e->num_conditions ) { + if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) { + for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) { + e->conditions[i3].predicate = e->conditions[i3+1].predicate; + /* here, we can still have equalities. nowhere else. + */ + a = ( e->conditions[i3].predicate < 0 ) ? + 2 : garity[e->conditions[i3].predicate]; + for ( i4 = 0; i4 < a; i4++ ) { + e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4]; + } + } + e->num_conditions--; + } else { + i2++; + } + } + i1++; + } + + i1 = 0; + while ( i1 < e->num_conditions ) { + for ( i2 = 0; i2 < o->num_preconds; i2++ ) { + if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) { + break; + } + } + if ( i2 == o->num_preconds ) { + i1++; + continue; + } + for ( i2 = i1; i2 < e->num_conditions-1; i2++ ) { + e->conditions[i2].predicate = e->conditions[i2+1].predicate; + for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) { + e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3]; + } + } + e->num_conditions--; + } + + i1 = 0; + while ( i1 < e->num_adds-1 ) { + i2 = i1+1; + while ( i2 < e->num_adds ) { + if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) { + for ( i3 = i2; i3 < e->num_adds-1; i3++ ) { + e->adds[i3].predicate = e->adds[i3+1].predicate; + for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) { + e->adds[i3].args[i4] = e->adds[i3+1].args[i4]; + } + } + e->num_adds--; + } else { + i2++; + } + } + i1++; + } + + i1 = 0; + while ( i1 < e->num_dels-1 ) { + i2 = i1+1; + while ( i2 < e->num_dels ) { + if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) { + for ( i3 = i2; i3 < e->num_dels-1; i3++ ) { + e->dels[i3].predicate = e->dels[i3+1].predicate; + for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) { + e->dels[i3].args[i4] = e->dels[i3+1].args[i4]; + } + } + e->num_dels--; + } else { + i2++; + } + } + i1++; + } + } + } + +} + + + +Bool identical_fact( Fact *f1, Fact *f2 ) + +{ + + int i, a; + + if ( f1->predicate != f2->predicate ) { + return FALSE; + } + + a = ( f1->predicate < 0 ) ? 2 : garity[f1->predicate]; + + for ( i = 0; i < a; i++ ) { + if ( f1->args[i] != f2->args[i] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +/* this one needs ONLY be used after unaries encoding, as all empty types + * are already recognised during translation, except the artificial ones, + * of course. + */ +void handle_empty_easy_parameters( void ) + +{ + + int i, j, k; + NormOperator *o; + NormEffect *e, *tmp; + + i = 0; + while ( i < gnum_easy_operators ) { + o = geasy_operators[i]; + + for ( j = 0; j < o->num_vars; j++ ) { + if ( gtype_size[o->var_types[j]] == 0 ) { + break; + } + } + if ( j < o->num_vars ) { + free_NormOperator( o ); + for ( k = i; k < gnum_easy_operators - 1; k++ ) { + geasy_operators[k] = geasy_operators[k+1]; + } + gnum_easy_operators--; + } else { + i++; + } + } + + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + e = o->effects; + while ( e ) { + for ( j = 0; j < e->num_vars; j++ ) { + if ( gtype_size[e->var_types[j]] == 0 ) { + break; + } + } + if ( j < e->num_vars ) { + if ( e->prev ) { + e->prev->next = e->next; + } else { + o->effects = e->next; + } + if ( e->next ) { + e->next->prev = e->prev; + } + tmp = e->next; + free_single_NormEffect( e ); + e = tmp; + } else { + e = e->next; + } + } + } + +} + + + + + + + + + + +/**************************** + * UNARY INERTIA INTO TYPES * + ****************************/ + + + + + + + + + + + + +void encode_easy_unaries_as_types( void ) + +{ + + NormOperator *o; + int i1, i, j, k, l, new_T, p, a; + TypeArray T; + int num_T; + NormEffect *e; + int intersected_type, var; + + for ( i1 = 0; i1 < gnum_easy_operators; i1++ ) { + o = geasy_operators[i1]; + + for ( i = 0; i < o->num_vars; i++ ) { + + T[0] = o->var_types[i]; + num_T = 1; + + j = 0; + while ( j < o->num_preconds ) { + p = o->preconds[j].predicate; + if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && + ( o->preconds[j].args[0] == ENCODE_VAR( i ) ) ) { + if ( num_T == MAX_TYPE_INTERSECTIONS ) { + printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", + MAX_TYPE_INTERSECTIONS); + exit( 1 ); + } + /* insert new type number into ordered array T; + * ---- all type numbers in T are different: + * new nr. is of inferred type - can't be type declared for param + * precondition facts occur at most once - doubles are removed + * during cleanup + */ + for ( k = 0; k < num_T; k++ ) { + if ( new_T < T[k] ) { + break; + } + } + for ( l = num_T; l > k; l-- ) { + T[l] = T[l-1]; + } + T[k] = new_T; + num_T++; + /* now remove superfluous precondition + */ + for ( k = j; k < o->num_preconds-1; k++ ) { + o->preconds[k].predicate = o->preconds[k+1].predicate; + for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { + o->preconds[k].args[l] = o->preconds[k+1].args[l]; + } + } + o->num_preconds--; + } else { + j++; + } + } + + /* if we did not hit any unary inertia concerning this parameter + * in the preconds, skip parameter and go to next one + */ + if ( num_T == 1 ) { + continue; + } + + /* now we have the ordered array of types to intersect for param i + * of op o in array T of size num_T; + * if there already is this intersected type, set type of this + * param to its number, otherwise create the new intersected type. + */ + if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { + /* type already there + */ + o->var_types[i] = intersected_type; + continue; + } + + /* create new type + */ + o->var_types[i] = create_intersected_type( T, num_T ); + } + + for ( e = o->effects; e; e = e->next ) { + for ( i = 0; i < e->num_vars; i++ ) { + T[0] = e->var_types[i]; + var = o->num_vars + i; + num_T = 1; + j = 0; + while ( j < e->num_conditions ) { + p = e->conditions[j].predicate; + if ( p < 0 ) { + j++; + continue; + } + if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && + ( e->conditions[j].args[0] == ENCODE_VAR( var ) ) ) { + if ( num_T == MAX_TYPE_INTERSECTIONS ) { + printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", + MAX_TYPE_INTERSECTIONS); + exit( 1 ); + } + for ( k = 0; k < num_T; k++ ) { + if ( new_T < T[k] ) { + break; + } + } + for ( l = num_T; l > k; l-- ) { + T[l] = T[l-1]; + } + T[k] = new_T; + num_T++; + for ( k = j; k < e->num_conditions-1; k++ ) { + e->conditions[k].predicate = e->conditions[k+1].predicate; + a = ( e->conditions[k].predicate < 0 ) ? + 2 : garity[e->conditions[k].predicate]; + for ( l = 0; l < a; l++ ) { + e->conditions[k].args[l] = e->conditions[k+1].args[l]; + } + } + e->num_conditions--; + } else { + j++; + } + } + if ( num_T == 1 ) { + continue; + } + if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { + e->var_types[i] = intersected_type; + continue; + } + e->var_types[i] = create_intersected_type( T, num_T ); + } + } + } + + handle_empty_easy_parameters(); + +} + + + +int create_intersected_type( TypeArray T, int num_T ) + +{ + + int i, j, k, intersected_type; + + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many (inferred and intersected) types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_names[gnum_types] = NULL; + gtype_size[gnum_types] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][gnum_types] = FALSE; + } + for ( i = 0; i < num_T; i++ ) { + gintersected_types[gnum_types][i] = T[i]; + } + gnum_intersected_types[gnum_types] = num_T; + intersected_type = gnum_types; + gnum_types++; + + for ( j = 0; j < gtype_size[T[0]]; j++ ) { + for ( k = 1; k < num_T; k++ ) { + if ( !gis_member[gtype_consts[T[0]][j]][T[k]] ) { + break; + } + } + if ( k < num_T ) { + continue; + } + /* add constant to new type + */ + if ( gtype_size[intersected_type] == MAX_TYPE ) { + printf("\ntoo many consts in intersected type! increase MAX_TYPE (currently %d)\n\n", + MAX_TYPE); + exit( 1 ); + } + gtype_consts[intersected_type][gtype_size[intersected_type]++] = gtype_consts[T[0]][j]; + gis_member[gtype_consts[T[0]][j]][intersected_type] = TRUE; + } + + /* now verify if the intersected type equals one of the types that we intersected. + * this is the case, iff one of the types in T has the same size as intersected_type + */ + for ( j = 0; j < num_T; j++ ) { + if ( gtype_size[intersected_type] != gtype_size[T[j]] ) { + continue; + } + /* type T[j] contains exactly the constants that we need! + * + * remove intersected type from table! + */ + gtype_size[intersected_type] = 0; + for ( k = 0; k < MAX_CONSTANTS; k++ ) { + gis_member[k][intersected_type] = FALSE; + } + gnum_intersected_types[intersected_type] = -1; + gnum_types--; + intersected_type = T[j]; + break; + } + + return intersected_type; + +} + + + +int find_intersected_type( TypeArray T, int num_T ) + +{ + + int i, j; + + for ( i = 0; i < gnum_types; i++ ) { + if ( gnum_intersected_types[i] == -1 ) { + continue; + } + + if ( gnum_intersected_types[i] != num_T ) { + continue; + } + + for ( j = 0; j < num_T; j++ ) { + if ( T[j] != gintersected_types[i][j] ) { + break; + } + } + if ( j < num_T ) { + continue; + } + + return i; + } + + return -1; + +} + + + + + + + + + + + + + + +/****************************** + * MULTIPLY EFFECT PARAMETERS * + ******************************/ + + + + + + + + + + + + +/* local globals for multiplying + */ + +int linertia_conds[MAX_VARS]; +int lnum_inertia_conds; + +int lmultiply_parameters[MAX_VARS]; +int lnum_multiply_parameters; + +NormOperator *lo; +NormEffect *le; + +NormEffect *lres; + + + + + + +void multiply_easy_effect_parameters( void ) + +{ + + int i, j, k, l, p, par; + NormEffect *e; + + for ( i = 0; i < gnum_easy_operators; i++ ) { + lo = geasy_operators[i]; + + lres = NULL; + for ( e = lo->effects; e; e = e->next ) { + le = e; + + lnum_inertia_conds = 0; + for ( j = 0; j < e->num_conditions; j++ ) { + for ( k = 0; k < garity[e->conditions[j].predicate]; k++ ) { + if ( e->conditions[j].args[k] < 0 && + DECODE_VAR( e->conditions[j].args[k] ) < lo->num_vars ) { + break; + } + } + if ( k < garity[e->conditions[j].predicate] ) { + /* only consider inertia constraining effect parameters + */ + continue; + } + if ( !gis_added[e->conditions[j].predicate] && + !gis_deleted[e->conditions[j].predicate] ) { + linertia_conds[lnum_inertia_conds++] = j; + } + } + + lnum_multiply_parameters = 0; + for ( j = 0; j < e->num_vars; j++ ) { + par = lo->num_vars + j; + for ( k = 0; k < lnum_inertia_conds; k++ ) { + p = e->conditions[linertia_conds[k]].predicate; + for ( l = 0; l < garity[p]; l++ ) { + if ( e->conditions[linertia_conds[k]].args[l] == + ENCODE_VAR( par ) ) { + break; + } + } + if ( l < garity[p] ) { + break; + } + } + if ( k < lnum_inertia_conds ) { + continue; + } + lmultiply_parameters[lnum_multiply_parameters++] = j; + } + + unify_easy_inertia_conditions( 0 ); + } + free_NormEffect( lo->effects ); + lo->effects = lres; + } + +} + + + +void unify_easy_inertia_conditions( int curr_inertia ) + +{ + + int p, i, j, af, hh; + int args[MAX_VARS]; + int affected_params[MAX_VARS]; + int num_affected_params = 0; + + if ( curr_inertia == lnum_inertia_conds ) { + multiply_easy_non_constrained_effect_parameters( 0 ); + return; + } + + p = le->conditions[linertia_conds[curr_inertia]].predicate; + for ( i = 0; i < garity[p]; i++ ) { + args[i] = le->conditions[linertia_conds[curr_inertia]].args[i]; + if ( args[i] < 0 ) { + hh = DECODE_VAR( args[i] ); + hh -= lo->num_vars; + if ( le->inst_table[hh] != -1 ) { + args[i] = le->inst_table[hh]; + } else { + affected_params[num_affected_params++] = hh; + } + } + } + + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + af = 0; + for ( j = 0; j < garity[p]; j++ ) { + if ( args[j] >= 0 ) { + if ( args[j] != ginitial_predicate[p][i].args[j] ) { + break; + } else { + continue; + } + } + le->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; + } + if ( j < garity[p] ) { + continue; + } + + unify_easy_inertia_conditions( curr_inertia + 1 ); + } + + for ( i = 0; i < num_affected_params; i++ ) { + le->inst_table[affected_params[i]] = -1; + } + +} + + + +void multiply_easy_non_constrained_effect_parameters( int curr_parameter ) + +{ + + int t, n, i, j, k, p, par; + NormEffect *tmp; + Bool rem; + + if ( curr_parameter == lnum_multiply_parameters ) { + /* create new effect, adjusting conds to inst, and + * partially instantiating effects; + * + * add result to lres + */ + tmp = new_NormEffect2( le ); + + /* instantiate param occurences + */ + for ( i = 0; i < le->num_vars; i++ ) { + par = lo->num_vars + i; + + /* numerical part + */ + for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_conditions_lh[j]), + par, le->inst_table[i] ); + } + for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_conditions_rh[j]), + par, le->inst_table[i] ); + } + /* was that already enough to get numbers? if yes, + * see whether comparison holds or not. + */ + j = 0; + while ( j < tmp->num_numeric_conditions ) { + if ( tmp->numeric_conditions_lh[j]->connective == NUMBER && + tmp->numeric_conditions_rh[j]->connective == NUMBER ) { + if ( number_comparison_holds( tmp->numeric_conditions_comp[j], + tmp->numeric_conditions_lh[j]->value, + tmp->numeric_conditions_rh[j]->value ) ) { + free_ExpNode( tmp->numeric_conditions_lh[j] ); + free_ExpNode( tmp->numeric_conditions_rh[j] ); + for ( k = j; k < tmp->num_numeric_conditions-1; k++ ) { + tmp->numeric_conditions_comp[k] = tmp->numeric_conditions_comp[k+1]; + tmp->numeric_conditions_lh[k] = tmp->numeric_conditions_lh[k+1]; + tmp->numeric_conditions_rh[k] = tmp->numeric_conditions_rh[k+1]; + } + tmp->num_numeric_conditions--; + } else { + free_NormEffect( tmp ); + return; + } + } else { + j++; + } + } + for ( j = 0; j < tmp->num_numeric_effects; j++ ) { + for ( k = 0; k < gf_arity[tmp->numeric_effects_fluent[j].function]; k++ ) { + if ( tmp->numeric_effects_fluent[j].args[k] == ENCODE_VAR( par ) ) { + tmp->numeric_effects_fluent[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_numeric_effects; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_effects_rh[j]), + par, le->inst_table[i] ); + } + + /* logical part + */ + for ( j = 0; j < tmp->num_conditions; j++ ) { + for ( k = 0; k < garity[tmp->conditions[j].predicate]; k++ ) { + if ( tmp->conditions[j].args[k] == ENCODE_VAR( par ) ) { + tmp->conditions[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_adds; j++ ) { + for ( k = 0; k < garity[tmp->adds[j].predicate]; k++ ) { + if ( tmp->adds[j].args[k] == ENCODE_VAR( par ) ) { + tmp->adds[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_dels; j++ ) { + for ( k = 0; k < garity[tmp->dels[j].predicate]; k++ ) { + if ( tmp->dels[j].args[k] == ENCODE_VAR( par ) ) { + tmp->dels[j].args[k] = le->inst_table[i]; + } + } + } + } + /* adjust conditions + */ + i = 0; + while ( i < tmp->num_conditions ) { + rem = FALSE; + p = tmp->conditions[i].predicate; + if ( !gis_added[p] && + !gis_deleted[p] ) { + for ( j = 0; j < garity[p]; j++ ) { + if ( tmp->conditions[i].args[j] < 0 && + DECODE_VAR( tmp->conditions[i].args[j] < lo->num_vars ) ) { + break; + } + } + if ( j == garity[p] ) { + /* inertia that constrain only effect params have been unified, + * are therefore TRUE + */ + rem = TRUE; + } + } + if ( rem ) { + for ( j = i; j < tmp->num_conditions - 1; j++ ) { + tmp->conditions[j].predicate = tmp->conditions[j+1].predicate; + for ( k = 0; k < garity[tmp->conditions[j+1].predicate]; k++ ) { + tmp->conditions[j].args[k] = tmp->conditions[j+1].args[k]; + } + } + tmp->num_conditions--; + } else { + i++; + } + } + /* add result to lres + */ + if ( lres ) { + lres->prev = tmp; + } + tmp->next = lres; + lres = tmp; + return; + } + + t = le->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + + for ( i = 0; i < n; i++ ) { + le->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + multiply_easy_non_constrained_effect_parameters( curr_parameter + 1 ); + } + + le->inst_table[lmultiply_parameters[curr_parameter]] = -1; + +} + + + + + + + + + + + + + + + + + + + +/************************** + * MULTIPLY OP PARAMETERS * + **************************/ + + + + + + + + + + + + + + +/* Bool bla; */ + + + + +void multiply_easy_op_parameters( void ) + +{ + + int i, j, k, l, p; + NormOperator *o; + + geasy_templates = NULL; + gnum_easy_templates = 0; + + for ( i = 0; i < gnum_easy_operators; i++ ) { + lo = geasy_operators[i]; +/* if ( strcmp(lo->operator->name, "PORT445_WIN2000") == 0 ) { */ +/* printf("\nmultiply easy OP: %s", lo->operator->name); */ +/* bla = TRUE; */ +/* } else { */ +/* bla = FALSE; */ +/* } */ + + lnum_inertia_conds = 0; + for ( j = 0; j < lo->num_preconds; j++ ) { + if ( !gis_added[lo->preconds[j].predicate] && + !gis_deleted[lo->preconds[j].predicate] ) { + linertia_conds[lnum_inertia_conds++] = j; +/* if ( bla ) { */ +/* printf("\n:inertia cond: %d (pred %s)", j, gpredicates[lo->preconds[j].predicate]); */ +/* fflush(stdout); */ +/* } */ + } + } + + + lnum_multiply_parameters = 0; + for ( j = 0; j < lo->num_vars; j++ ) { + for ( k = 0; k < lnum_inertia_conds; k++ ) { + p = lo->preconds[linertia_conds[k]].predicate; + for ( l = 0; l < garity[p]; l++ ) { + if ( lo->preconds[linertia_conds[k]].args[l] == + ENCODE_VAR( j ) ) { + break; + } + } + if ( l < garity[p] ) { + break; + } + } + if ( k < lnum_inertia_conds ) { + continue; + } +/* if ( bla ) { */ +/* printf("\nmultiply parameter: %d", j); */ +/* fflush(stdout); */ +/* } */ + lmultiply_parameters[lnum_multiply_parameters++] = j; + } + + unify_easy_inertia_preconds( 0 ); + } + + /* now remove inertia preconditions from operator schemata + */ + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + j = 0; + while ( j < o->num_preconds ) { + if ( !gis_added[o->preconds[j].predicate] && + !gis_deleted[o->preconds[j].predicate] ) { + for ( k = j; k < o->num_preconds - 1; k++ ) { + o->preconds[k].predicate = o->preconds[k+1].predicate; + for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { + o->preconds[k].args[l] = o->preconds[k+1].args[l]; + } + } + o->num_preconds--; + } else { + j++; + } + } + } + +} + + + +void unify_easy_inertia_preconds( int curr_inertia ) + +{ + + int p, i, j, af, hh; + int args[MAX_VARS]; + int affected_params[MAX_VARS]; + int num_affected_params = 0; + + if ( curr_inertia == lnum_inertia_conds ) { + multiply_easy_non_constrained_op_parameters( 0 ); + return; + } + + p = lo->preconds[linertia_conds[curr_inertia]].predicate; + for ( i = 0; i < garity[p]; i++ ) { + args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i]; + if ( args[i] < 0 ) { + hh = DECODE_VAR( args[i] ); + if ( lo->inst_table[hh] != -1 ) { + args[i] = lo->inst_table[hh]; + } else { + affected_params[num_affected_params++] = hh; + } + } + } + + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + af = 0; + for ( j = 0; j < garity[p]; j++ ) { + if ( args[j] >= 0 ) { + if ( args[j] != ginitial_predicate[p][i].args[j] ) { + break; + } else { + continue; + } + } + /* check whether that constant has the correct type for that + * parameter (can be not fulfilled due to encoding of unary inertia + */ + if ( !gis_member[ginitial_predicate[p][i].args[j]][lo->var_types[affected_params[af]]] ) { + break; + } + /* legal constant; set op parameter instantiation to it + */ + lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; + } + if ( j < garity[p] ) { + continue; + } + + unify_easy_inertia_preconds( curr_inertia + 1 ); + } + + for ( i = 0; i < num_affected_params; i++ ) { + lo->inst_table[affected_params[i]] = -1; + } + +} + + + +void multiply_easy_non_constrained_op_parameters( int curr_parameter ) + +{ + + EasyTemplate *tmp; + int i, j, t, n; + +/* if ( bla ) { */ +/* printf("\nEntry multiply!"); */ +/* fflush(stdout); */ +/* } */ + + if ( curr_parameter == lnum_multiply_parameters ) { + tmp = new_EasyTemplate( lo ); + for ( i = 0; i < lo->num_vars; i++ ) { + tmp->inst_table[i] = lo->inst_table[i]; + } + tmp->next = geasy_templates; + if ( geasy_templates ) { + geasy_templates->prev = tmp; + } + geasy_templates = tmp; + gnum_easy_templates++; + return; + } + + if ( curr_parameter == lnum_multiply_parameters - 1 ) { +/* if ( bla ) { */ +/* printf("\nEntry 1 missing!"); */ +/* fflush(stdout); */ +/* } */ + t = lo->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + for ( i = 0; i < n; i++ ) { + lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + +/* if ( bla ) { */ +/* printf("\nmaking instance (numvars %d):", lo->num_vars); */ +/* fflush(stdout); */ +/* } */ + tmp = new_EasyTemplate( lo ); + for ( j = 0; j < lo->num_vars; j++ ) { + tmp->inst_table[j] = lo->inst_table[j]; +/* if ( bla ) { */ +/* printf("%s (ID %d), ", gconstants[tmp->inst_table[j]], tmp->inst_table[j]); */ +/* fflush(stdout); */ +/* } */ + } + tmp->next = geasy_templates; + if ( geasy_templates ) { + geasy_templates->prev = tmp; + } + geasy_templates = tmp; + gnum_easy_templates++; + } + + lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; + + return; + } + + t = lo->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + for ( i = 0; i < n; i++ ) { + lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + + multiply_easy_non_constrained_op_parameters( curr_parameter + 1 ); + } + + lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; + +} diff --git a/models/main_models/rt1/gen/ff_planner/inst_easy.h b/models/main_models/rt1/gen/ff_planner/inst_easy.h new file mode 100644 index 000000000..1bc6eb1db --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_easy.h @@ -0,0 +1,73 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + + + +/********************************************************************* + * File: inst_easy.h + * Description: headers for multiplying easy operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + +#ifndef _INST_EASY_H +#define _INST_EASY_H + + + +void build_easy_action_templates( void ); + + + +void cleanup_easy_domain( void ); +Bool identical_fact( Fact *f1, Fact *f2 ); +void handle_empty_easy_parameters( void ); + + + +void encode_easy_unaries_as_types( void ); +int create_intersected_type( TypeArray T, int num_T ); +int find_intersected_type( TypeArray T, int num_T ); + + + +void multiply_easy_effect_parameters( void ); +void unify_easy_inertia_conditions( int curr_inertia ); +void multiply_easy_non_constrained_effect_parameters( int curr_parameter ); + + + +void multiply_easy_op_parameters( void ); +void unify_easy_inertia_preconds( int curr_inertia ); +void multiply_easy_non_constrained_op_parameters( int curr_parameter ); + + + +#endif /* _INST_EASY_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_final.c b/models/main_models/rt1/gen/ff_planner/inst_final.c new file mode 100644 index 000000000..3f51a89e6 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_final.c @@ -0,0 +1,2797 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_final.c + * Description: final domain representation functions + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_final.h" + + + + + + + + + + + + + + +/******************************** + * POSSIBLY TRUE FACTS ANALYSIS * + ********************************/ + + + + + + + + +/* local globals for this part + */ + +int_pointer lpos[MAX_PREDICATES]; +int_pointer lneg[MAX_PREDICATES]; +int_pointer luse[MAX_PREDICATES]; +int_pointer lindex[MAX_PREDICATES]; + +int lp; +int largs[MAX_VARS]; + + + +/* for collecting poss. defined fluents + */ +int_pointer lf_def[MAX_FUNCTIONS]; +int_pointer lf_index[MAX_FUNCTIONS]; + +int lf; +int lf_args[MAX_VARS]; + + + + + + +void perform_reachability_analysis( void ) + +{ + + int size, i, j, k, adr, num, pargtype; + Bool fixpoint; + Facts *f; + NormOperator *no; + EasyTemplate *t1, *t2; + NormEffect *ne; + Action *tmp, *a; + Bool *had_hard_template; + PseudoAction *pa; + PseudoActionEffect *pae; + + gactions = NULL; + gnum_actions = 0; + + for ( i = 0; i < gnum_predicates; i++ ) { + size = 1; + for ( j = 0; j < garity[i]; j++ ) { + pargtype = gpredicates_args_type[i][j]; + size *= gtype_size[pargtype]; + } + + lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + luse[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + + for ( j = 0; j < size; j++ ) { + lpos[i][j] = 0; + lneg[i][j] = 1;/* all facts but initials are poss. negative */ + luse[i][j] = 0; + lindex[i][j] = -1; + } + } + + had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) ); + for ( i = 0; i < gnum_hard_templates; i++ ) { + had_hard_template[i] = FALSE; + } + + /* mark initial facts as possibly positive, not poss. negative + */ + for ( i = 0; i < gnum_predicates; i++ ) { + lp = i; + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + for ( k = 0; k < garity[i]; k++ ) { + largs[k] = ginitial_predicate[i][j].args[k]; + } + adr = fact_adress(); + lpos[lp][adr] = 1; + lneg[lp][adr] = 0; + } + } + + /* compute fixpoint + */ + fixpoint = FALSE; + while ( !fixpoint ) { + fixpoint = TRUE; + + /* assign next layer of easy templates to possibly positive fixpoint + */ + t1 = geasy_templates; + while ( t1 ) { + no = t1->op; + for ( i = 0; i < no->num_preconds; i++ ) { + lp = no->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( no->preconds[i].args[j] >= 0 ) ? + no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; + } + if ( !lpos[lp][fact_adress()] ) { + break; + } + } + + if ( i < no->num_preconds ) { + t1 = t1->next; + continue; + } + + num = 0; + for ( ne = no->effects; ne; ne = ne->next ) { + num++; + /* currently, simply ignore effect conditions and assume + * they will all be made true eventually. + */ + for ( i = 0; i < ne->num_adds; i++ ) { + lp = ne->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->adds[i].args[j] >= 0 ) ? + ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) { + /* new relevant fact! (added non initial) + */ + lpos[lp][adr] = 1; + lneg[lp][adr] = 1; + luse[lp][adr] = 1; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + fixpoint = FALSE; + } + } + } + + tmp = new_Action(); + tmp->norm_operator = no; + tmp->axiom = no->operator->axiom; + for ( i = 0; i < no->num_vars; i++ ) { + tmp->inst_table[i] = t1->inst_table[i]; + } + tmp->name = no->operator->name; + tmp->num_name_vars = no->operator->number_of_real_params; + make_name_inst_table_from_NormOperator( tmp, no, t1 ); + tmp->next = gactions; + tmp->num_effects = num; + gactions = tmp; + gnum_actions++; + + t2 = t1->next; + if ( t1->next ) { + t1->next->prev = t1->prev; + } + if ( t1->prev ) { + t1->prev->next = t1->next; + } else { + geasy_templates = t1->next; + } + free_single_EasyTemplate( t1 ); + t1 = t2; + } + + /* now assign all hard templates that have not been transformed + * to actions yet. + */ + for ( i = 0; i < gnum_hard_templates; i++ ) { + if ( had_hard_template[i] ) { + continue; + } + pa = ghard_templates[i]; + + for ( j = 0; j < pa->num_preconds; j++ ) { + lp = pa->preconds[j].predicate; + for ( k = 0; k < garity[lp]; k++ ) { + largs[k] = pa->preconds[j].args[k]; + } + if ( !lpos[lp][fact_adress()] ) { + break; + } + } + + if ( j < pa->num_preconds ) { + continue; + } + + for ( pae = pa->effects; pae; pae = pae->next ) { + /* currently, simply ignore effect conditions and assume + * they will all be made true eventually. + */ + for ( j = 0; j < pae->num_adds; j++ ) { + lp = pae->adds[j].predicate; + for ( k = 0; k < garity[lp]; k++ ) { + largs[k] = pae->adds[j].args[k]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) { + /* new relevant fact! (added non initial) + */ + lpos[lp][adr] = 1; + lneg[lp][adr] = 1; + luse[lp][adr] = 1; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( k = 0; k < garity[lp]; k++ ) { + grelevant_facts[gnum_relevant_facts].args[k] = largs[k]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + fixpoint = FALSE; + } + } + } + + tmp = new_Action(); + tmp->pseudo_action = pa; + tmp->axiom = pa->operator->axiom; + for ( j = 0; j < pa->operator->num_vars; j++ ) { + tmp->inst_table[j] = pa->inst_table[j]; + } + tmp->name = pa->operator->name; + tmp->num_name_vars = pa->operator->number_of_real_params; + make_name_inst_table_from_PseudoAction( tmp, pa ); + tmp->next = gactions; + tmp->num_effects = pa->num_effects; + gactions = tmp; + gnum_actions++; + + had_hard_template[i] = TRUE; + } + } + + free( had_hard_template ); + + gnum_pp_facts = gnum_initial + gnum_relevant_facts; + + if ( gcmd_line.display_info == 118 ) { + printf("\nreachability analysys came up with:"); + + printf("\n\npossibly positive facts:"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + for ( i = 0; i < gnum_relevant_facts; i++ ) { + printf("\n"); + print_Fact( &(grelevant_facts[i]) ); + } + + printf("\n\nthis yields these %d action templates:", gnum_actions); + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\noperator %s:", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + printf("\ntemplate: "); + if ( a->axiom ) printf("(axiom) "); + for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) { + printf("%s", gconstants[a->name_inst_table[j]]); + if ( j < goperators[i]->num_vars-1 ) { + printf(" "); + } + } + } + } + printf("\n\n"); + } + +} + + + +/* bit complicated to avoid memory explosion when high arity predicates take + * num_obs ^ arity space. take space for individual arg types only; + * must consider pred args in smallest - to - largest - type order to make + * mapping injective. + */ +int fact_adress( void ) + +{ + + int r = 0, b = 1, i, j, min, minj; + Bool done[MAX_ARITY]; + + for ( i = 0; i < garity[lp]; i++ ) { + done[i] = FALSE; + } + + for ( i = 0; i < garity[lp]; i++ ) { + min = -1; + minj = -1; + for ( j = 0; j < garity[lp]; j++ ) { + if ( !done[j] ) { + if ( min == -1 || + gtype_size[gpredicates_args_type[lp][j]] < min ) { + min = gtype_size[gpredicates_args_type[lp][j]]; + minj = j; + } + } + } + if ( minj == -1 || min == -1 ) { + printf("\n\nmin or minj not made in fact adress?\n\n"); + exit( 1 ); + } + /* now minj is remaining arg with lowest type size min + */ + /* need number **within type** here! */ + r += b * gmember_nr[largs[minj]][gpredicates_args_type[lp][minj]]; + b *= min; + done[minj] = TRUE; + } + + return r; + +} + + + +int fluent_adress( void ) + +{ + + int r = 0, b = 1, i; + + for ( i = gf_arity[lf] - 1; i > -1; i-- ) { + r += b * lf_args[i]; + b *= gnum_constants; + } + + return r; + +} + + + +void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ) + +{ + + int i, r = 0, m = 0; + + for ( i = 0; i < o->operator->number_of_real_params; i++ ) { + if ( o->num_removed_vars > r && + o->removed_vars[r] == i ) { + /* this var has been removed in NormOp; + * insert type constraint constant + * + * at least one there, as empty typed pars ops are removed + */ + a->name_inst_table[i] = gtype_consts[o->type_removed_vars[r]][0]; + r++; + } else { + /* this par corresponds to par m in NormOp + */ + a->name_inst_table[i] = t->inst_table[m]; + m++; + } + } + +} + + + +void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ) + +{ + + int i; + + for ( i = 0; i < pa->operator->number_of_real_params; i++ ) { + a->name_inst_table[i] = pa->inst_table[i]; + } + +} + + + + + + + + + + + + + + + + + + +/*********************************************************** + * RELEVANCE ANALYSIS AND FINAL DOMAIN AND PROBLEM CLEANUP * + ***********************************************************/ + + + + + + + + + +/* counts effects for later allocation + */ +int lnum_effects; + + + + + + + + + +void collect_relevant_facts_and_fluents( void ) + +{ + + Action *a; + NormOperator *no; + NormEffect *ne; + int i, j, adr, size; + PseudoAction *pa; + PseudoActionEffect *pae; + FluentValues *fvs; + + /* facts: mark all deleted facts; such facts, that are also pos, are relevant. + */ + for ( a = gactions; a; a = a->next ) { + if ( a->norm_operator ) { + no = a->norm_operator; + + for ( ne = no->effects; ne; ne = ne->next ) { + for ( i = 0; i < ne->num_dels; i++ ) { + lp = ne->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->dels[i].args[j] >= 0 ) ? + ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; + } + adr = fact_adress(); + + lneg[lp][adr] = 1; + if ( lpos[lp][adr] && + !luse[lp][adr] ) { + luse[lp][adr] = 1; + lindex[lp][adr] = gnum_relevant_facts; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + } + } + } + } else { + pa = a->pseudo_action; + + for ( pae = pa->effects; pae; pae = pae->next ) { + for ( i = 0; i < pae->num_dels; i++ ) { + lp = pae->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->dels[i].args[j]; + } + adr = fact_adress(); + + lneg[lp][adr] = 1; + if ( lpos[lp][adr] && + !luse[lp][adr] ) { + luse[lp][adr] = 1; + lindex[lp][adr] = gnum_relevant_facts; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + } + } + } + } + } + /* fluents: collect all that are defined in initial state, plus + * all that are assigned to by an effect of an action + * (i.e. preconds poss. pos. due to reachability) + * + * first initialise fast access structures + */ + for ( i = 0; i < gnum_functions; i++ ) { + size = 1; + for ( j = 0; j < gf_arity[i]; j++ ) { + size *= gnum_constants; + } + lf_def[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lf_index[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + for ( j = 0; j < size; j++ ) { + lf_def[i][j] = 0; + lf_index[i][j] = -1; + } + } + /* from initial state, only those that are not static. + */ + for ( fvs = gf_initial; fvs; fvs = fvs->next ) { + lf = fvs->fluent.function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = fvs->fluent.args[j]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } else { + printf("\n\nfluent "); + print_Fluent( &(fvs->fluent) ); + printf(" defined twice in initial state! check input files\n\n"); + exit( 1 ); + } + } + /* from actions, all assigns (are non-static anyway) + */ + for ( a = gactions; a; a = a->next ) { + if ( a->norm_operator ) { + no = a->norm_operator; + for ( ne = no->effects; ne; ne = ne->next ) { + for ( i = 0; i < ne->num_numeric_effects; i++ ) { + if ( ne->numeric_effects_neft[i] != ASSIGN ) continue; + lf = ne->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? + ne->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } + } + } + } else { + pa = a->pseudo_action; + for ( pae = pa->effects; pae; pae = pae->next ) { + for ( i = 0; i < pae->num_numeric_effects; i++ ) { + if ( pae->numeric_effects_neft[i] != ASSIGN ) continue; + lf = pae->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( pae->numeric_effects_fluent[i].args[j] >= 0 ) ? + pae->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( pae->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } + } + } + } + } + + if ( gcmd_line.display_info == 119 ) { + printf("\n\nfacts selected as relevant:"); + for ( i = 0; i < gnum_relevant_facts; i++ ) { + printf("\n%d: ", i); + print_Fact( &(grelevant_facts[i]) ); + } + printf("\n\nfluents selected as relevant:"); + for ( i = 0; i < gnum_relevant_fluents; i++ ) { + printf("\n%d: ", i); + print_Fluent( &(grelevant_fluents[i]) ); + } + printf("\n\n"); + } + + lnum_effects = 0; + + create_final_goal_state(); + create_final_initial_state(); + create_final_actions(); + + if ( gmetric != NULL ) { + if ( !set_relevants_in_exp( &gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: undefined fluent used in optimization expression. defaulting to plan length"); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + } + + if ( gcmd_line.display_info == 120 ) { + printf("\n\nfinal domain representation is:\n\n"); + + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( !a->norm_operator && + !a->pseudo_action ) || + ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + print_Action( a ); + } + } + printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); + for ( a = gactions; a; a = a->next ) { + if ( !a->norm_operator && + !a->pseudo_action ) { + print_Action( a ); + } + } + + printf("\n\nfinal initial state is:\n\n"); + print_State( ginitial_state ); + + printf("\n\nfinal goal is:\n\n"); + for ( i = 0; i < gnum_logic_goal; i++ ) { + print_ft_name( glogic_goal[i] ); + printf("\n"); + } + for ( i = 0; i < gnum_numeric_goal; i++ ) { + switch ( gnumeric_goal_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator in gnumeric_goal %d\n\n", gnumeric_goal_comp[i]); + exit( 1 ); + } + print_ExpNode( gnumeric_goal_lh[i] ); + print_ExpNode( gnumeric_goal_rh[i] ); + printf(")\n"); + } + + if ( gmetric ) { + printf("\n\nmetric is (minimize):\n"); + print_ExpNode( gmetric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + } + +} + + + +void create_final_goal_state( void ) + +{ + + WffNode *w, *ww; + int m, mn, i, adr; + Action *tmp; + + if ( !set_relevants_in_wff( &ggoal ) ) { + printf("\n\nff: goal accesses a fluent that will never have a defined value. Problem unsolvable.\n\n"); + exit( 1 ); + } + cleanup_wff( &ggoal ); + + if ( ggoal->connective == TRU ) { + printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); + gnum_plan_ops = 0; + exit( 1 ); + } + if ( ggoal->connective == FAL ) { + printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); + exit( 1 ); + } + + switch ( ggoal->connective ) { + case OR: + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = -3; + gnum_relevant_facts++; + for ( w = ggoal->sons; w; w = w->next ) { + tmp = new_Action(); + if ( w->connective == AND ) { + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp->preconds = ( int * ) calloc( m, sizeof( int ) ); + tmp->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp->num_preconds = m; + tmp->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + lp = ww->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = ww->fact->args[i]; + } + adr = fact_adress(); + tmp->preconds[m] = lindex[lp][adr]; + m++; + } + if ( ww->connective == COMP ) { + tmp->numeric_preconds_comp[mn] = ww->comp; + tmp->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); + tmp->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp->preconds = ( int * ) calloc( 1, sizeof( int ) ); + tmp->num_preconds = 1; + lp = w->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = w->fact->args[i]; + } + adr = fact_adress(); + tmp->preconds[0] = lindex[lp][adr]; + } + if ( w->connective == COMP ) { + tmp->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_comp[0] = w->comp; + tmp->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp->num_numeric_preconds = 1; + } + } + tmp->effects = ( ActionEffect * ) calloc( 1, sizeof( ActionEffect ) ); + tmp->num_effects = 1; + tmp->effects[0].conditions = NULL; + tmp->effects[0].num_conditions = 0; + tmp->effects[0].dels = NULL; + tmp->effects[0].num_dels = 0; + tmp->effects[0].adds = ( int * ) calloc( 1, sizeof( int ) ); + tmp->effects[0].adds[0] = gnum_relevant_facts - 1; + tmp->effects[0].num_adds = 1; + tmp->effects[0].numeric_conditions_comp = NULL; + tmp->effects[0].numeric_conditions_lh = NULL; + tmp->effects[0].numeric_conditions_rh = NULL; + tmp->effects[0].num_numeric_conditions = 0; + tmp->effects[0].numeric_effects_neft = NULL; + tmp->effects[0].numeric_effects_fl = NULL; + tmp->effects[0].numeric_effects_rh = NULL; + tmp->effects[0].num_numeric_effects = 0; + + tmp->next = gactions; + gactions = tmp; + gnum_actions++; + lnum_effects++; + } + glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); + glogic_goal[0] = gnum_relevant_facts - 1; + gnum_logic_goal = 1; + break; + case AND: + m = 0; mn = 0; + for ( w = ggoal->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + glogic_goal = ( int * ) calloc( m, sizeof( int ) ); + gnumeric_goal_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + gnum_logic_goal = m; + gnum_numeric_goal = mn; + m = 0; mn = 0; + for ( w = ggoal->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + lp = w->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = w->fact->args[i]; + } + adr = fact_adress(); + glogic_goal[m] = lindex[lp][adr]; + m++; + } + if ( w->connective == COMP ) { + gnumeric_goal_comp[mn] = w->comp; + gnumeric_goal_lh[mn] = copy_Exp( w->lh ); + gnumeric_goal_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + break; + case ATOM: + glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); + gnum_logic_goal = 1; + lp = ggoal->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = ggoal->fact->args[i]; + } + adr = fact_adress(); + glogic_goal[0] = lindex[lp][adr]; + break; + case COMP: + gnumeric_goal_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + gnum_numeric_goal = 1; + gnumeric_goal_comp[0] = ggoal->comp; + gnumeric_goal_lh[0] = copy_Exp( ggoal->lh ); + gnumeric_goal_rh[0] = copy_Exp( ggoal->rh ); + break; + default: + printf("\n\nwon't get here: non COMP,ATOM,AND,OR in fully simplified goal\n\n"); + exit( 1 ); + } + +} + + + +Bool set_relevants_in_wff( WffNode **w ) + +{ + + WffNode *i; + int j, adr; + + switch ( (*w)->connective ) { + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + if ( !set_relevants_in_wff( &i ) ) { + return FALSE; + } + } + break; + case ATOM: + /* no equalities, as fully instantiated + */ + lp = (*w)->fact->predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = (*w)->fact->args[j]; + } + adr = fact_adress(); + + if ( !lneg[lp][adr] ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !lpos[lp][adr] ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + break; + case COMP: + if ( !set_relevants_in_exp( &((*w)->lh) ) || + !set_relevants_in_exp( &((*w)->rh) ) ) { + return FALSE; + } + break; + default: + printf("\n\nwon't get here: non ATOM,OR,AND in goal set relevants\n\n"); + exit( 1 ); + } + + return TRUE; + +} + + + +Bool set_relevants_in_exp( ExpNode **n ) + +{ + + int j, adr; + + /* can probably (for sure) forget about the simplification + * stuff here because it's been done before. + * + * igual.... + */ + switch ( (*n)->connective ) { + case AD: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + if ( !set_relevants_in_exp( &((*n)->son) ) ) return FALSE; + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + lf = (*n)->fluent->function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = (*n)->fluent->args[j]; + } + adr = fluent_adress(); + (*n)->fl = lf_index[lf][adr]; + free( (*n)->fluent ); + (*n)->fluent = NULL; + if ( lf_index[lf][adr] == -1 ) { + if ( lf == 0 ) { + /* ATTENTION!! FUNCTION 0 IS TOTAL-TIME WHICH IS *ONLY* USED + * IN OPTIMIZATION EXPRESSION. GETS A SPECIAL TREATMENT + * IN THE RESPECTIVE FUNCTION IN SEARCH.C!!!! + * + * we remember it as fluent -2!! + */ + (*n)->fl = -2; + } else { + return FALSE; + } + } + break; + default: + printf("\n\nset relevants in expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void create_final_initial_state( void ) + +{ + + Facts *f; + int i, adr, fl; + FluentValues *fvs; + + i = 0; +/* for ( f = ginitial; f; f = f->next ) i++; */ + /* we need space for transformation fluents to come! + * + * ALSO, we may need space for derived facts!!! + */ + make_state( &ginitial_state, gnum_relevant_facts + 1, MAX_RELEVANT_FLUENTS ); + + for ( f = ginitial; f; f = f->next ) { + lp = f->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = f->fact->args[i]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* non deleted ini */ + continue; + } + ginitial_state.F[ginitial_state.num_F++] = lindex[lp][adr]; + } + + for ( fvs = gf_initial; fvs; fvs = fvs->next ) { + lf = fvs->fluent.function; + for ( i = 0; i < gf_arity[lf]; i++ ) { + lf_args[i] = fvs->fluent.args[i]; + } + adr = fluent_adress(); + fl = lf_index[lf][adr]; + ginitial_state.f_D[fl] = TRUE; + ginitial_state.f_V[fl] = fvs->value; + } + +} + + + +void create_final_actions( void ) + +{ + + Action *a, *p, *t; + NormOperator *no; + NormEffect *ne; + int i, j, adr; + PseudoAction *pa; + PseudoActionEffect *pae; + ActionEffect *aa; + Bool false_cond; + + a = gactions; p = NULL; + while ( a ) { + if ( a->norm_operator ) { + /* action comes from an easy template NormOp + */ + no = a->norm_operator; + + if ( no->num_preconds > 0 ) { + a->preconds = ( int * ) calloc( no->num_preconds, sizeof( int ) ); + } + a->num_preconds = 0; + for ( i = 0; i < no->num_preconds; i++ ) { + lp = no->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( no->preconds[i].args[j] >= 0 ) ? + no->preconds[i].args[j] : a->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; + } + adr = fact_adress(); + /* preconds are lpos in all cases due to reachability analysis + */ + if ( !lneg[lp][adr] ) { + continue; + } + a->preconds[a->num_preconds++] = lindex[lp][adr]; + } + + /**************************NUMERIC PRECOND*************************/ + if ( no->num_numeric_preconds > 0 ) { + a->numeric_preconds_comp = ( Comparator * ) + calloc( no->num_numeric_preconds, sizeof( Comparator ) ); + a->numeric_preconds_lh = ( ExpNode_pointer * ) + calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->numeric_preconds_rh = ( ExpNode_pointer * ) + calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->num_numeric_preconds = 0; + } + for ( i = 0; i < no->num_numeric_preconds; i++ ) { + a->numeric_preconds_comp[a->num_numeric_preconds] = no->numeric_preconds_comp[i]; + a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_lh[i] ); + instantiate_exp_by_action( &(a->numeric_preconds_lh[a->num_numeric_preconds]), a ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; + a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_rh[i] ); + instantiate_exp_by_action( &(a->numeric_preconds_rh[a->num_numeric_preconds]), a ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; + if ( a->numeric_preconds_lh[a->num_numeric_preconds]->connective == NUMBER && + a->numeric_preconds_rh[a->num_numeric_preconds]->connective == NUMBER ) { + /* trivial numeric precond + */ + if ( number_comparison_holds( a->numeric_preconds_comp[a->num_numeric_preconds], + a->numeric_preconds_lh[a->num_numeric_preconds]->value, + a->numeric_preconds_rh[a->num_numeric_preconds]->value ) ) { + /* true precond -> throw precond away. by not incrementing number of such. + */ + free_ExpNode( a->numeric_preconds_lh[a->num_numeric_preconds] ); + free_ExpNode( a->numeric_preconds_rh[a->num_numeric_preconds] ); + continue; + } else { + /* false precond -> throw action away. + */ + break; + } + } + a->num_numeric_preconds++; + } + if ( i < no->num_numeric_preconds ) { + /* a precond accesses an undefined fluent, or is false -> remove action! + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + /**************************NUMERIC PRECOND-END*************************/ + + /* and now for the effects + */ + if ( a->num_effects > 0 ) { + a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); + for ( i = 0; i < a->num_effects; i++ ) { + a->effects[i].illegal = FALSE; + a->effects[i].removed = FALSE; + } + } + a->num_effects = 0; + for ( ne = no->effects; ne; ne = ne->next ) { + aa = &(a->effects[a->num_effects]); + + if ( ne->num_conditions > 0 ) { + aa->conditions = ( int * ) calloc( ne->num_conditions, sizeof( int ) ); + } + aa->num_conditions = 0; + for ( i = 0; i < ne->num_conditions; i++ ) { + lp = ne->conditions[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->conditions[i].args[j] >= 0 ) ? + ne->conditions[i].args[j] : a->inst_table[DECODE_VAR( ne->conditions[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ + break; + } + if ( !lneg[lp][adr] ) {/* condition always true: skip it */ + continue; + } + aa->conditions[aa->num_conditions++] = lindex[lp][adr]; + } + if ( i < ne->num_conditions ) {/* found unreachable condition: free condition space */ + free( aa->conditions ); + continue; + } + + /**************************NUMERIC COND*************************/ + if ( ne->num_numeric_conditions > 0 ) { + aa->numeric_conditions_comp = ( Comparator * ) + calloc( ne->num_numeric_conditions, sizeof( Comparator ) ); + aa->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + aa->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < ne->num_numeric_conditions; i++ ) { + aa->numeric_conditions_lh[i] = NULL; + aa->numeric_conditions_rh[i] = NULL; + } + aa->num_numeric_conditions = 0; + } + false_cond = FALSE; + for ( i = 0; i < ne->num_numeric_conditions; i++ ) { + aa->numeric_conditions_comp[aa->num_numeric_conditions] = ne->numeric_conditions_comp[i]; + aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_lh[i] ); + instantiate_exp_by_action( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_rh[i] ); + instantiate_exp_by_action( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; + if ( aa->numeric_conditions_lh[aa->num_numeric_conditions]->connective == NUMBER && + aa->numeric_conditions_rh[aa->num_numeric_conditions]->connective == NUMBER ) { + /* trivial numeric condition + */ + if ( number_comparison_holds( aa->numeric_conditions_comp[aa->num_numeric_conditions], + aa->numeric_conditions_lh[aa->num_numeric_conditions]->value, + aa->numeric_conditions_rh[aa->num_numeric_conditions]->value ) ) { + /* true cond -> throw cond away. by not incrementing number of such. + */ + free_ExpNode( aa->numeric_conditions_lh[aa->num_numeric_conditions] ); + free_ExpNode( aa->numeric_conditions_rh[aa->num_numeric_conditions] ); + aa->numeric_conditions_lh[aa->num_numeric_conditions] = NULL; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = NULL; + continue; + } else { + /* false cond -> throw effect away. + */ + false_cond = TRUE; + break; + } + } + aa->num_numeric_conditions++; + } + if ( i < ne->num_numeric_conditions ) { + if ( false_cond ) { + /* false numeric cond: free what's been done so far, and skip effect + */ + for ( i = 0; i <= aa->num_numeric_conditions; i++ ) { + free_ExpNode( aa->numeric_conditions_lh[i] ); + free_ExpNode( aa->numeric_conditions_rh[i] ); + } + free( aa->numeric_conditions_comp ); + free( aa->numeric_conditions_lh ); + free( aa->numeric_conditions_rh ); + continue;/* next effect, without incrementing action counter */ + } else { + /* numeric effect uses undefined fluent in condition --> + * THROW WHOLE ACTION AWAY! done by breaking out of the + * effects loop, which will be catched below overall + * effect handling. + */ + break; + } + } + /**************************NUMERIC COND - END*************************/ + + /* now create the add and del effects. + */ + if ( ne->num_adds > 0 ) { + aa->adds = ( int * ) calloc( ne->num_adds, sizeof( int ) ); + } + aa->num_adds = 0; + for ( i = 0; i < ne->num_adds; i++ ) { + lp = ne->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->adds[i].args[j] >= 0 ) ? + ne->adds[i].args[j] : a->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* effect always true: skip it */ + continue; + } + aa->adds[aa->num_adds++] = lindex[lp][adr]; + } + + if ( ne->num_dels > 0 ) { + aa->dels = ( int * ) calloc( ne->num_dels, sizeof( int ) ); + } + aa->num_dels = 0; + for ( i = 0; i < ne->num_dels; i++ ) { + lp = ne->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->dels[i].args[j] >= 0 ) ? + ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* effect always false: skip it */ + continue; + } + /* NO CHECK FOR ADD \CAP DEL!!!!! -> ALLOWED BY SEMANTICS!!! + */ + aa->dels[aa->num_dels++] = lindex[lp][adr]; + } + if ( i < ne->num_dels ) break; + + /**************************NUMERIC EFFECTS*************************/ + if ( ne->num_numeric_effects > 0 ) { + aa->numeric_effects_neft = ( NumericEffectType * ) + calloc( ne->num_numeric_effects, sizeof( NumericEffectType ) ); + aa->numeric_effects_fl = ( int * ) + calloc( ne->num_numeric_effects, sizeof( int ) ); + aa->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_effects, sizeof( ExpNode_pointer ) ); + aa->num_numeric_effects = 0; + } + for ( i = 0; i < ne->num_numeric_effects; i++ ) { + aa->numeric_effects_neft[aa->num_numeric_effects] = ne->numeric_effects_neft[i]; + lf = ne->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? + ne->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + /* if it's -1, simply let it in --- if that effect appears, then + * action is illegal, otherwise not. + */ + aa->numeric_effects_fl[i] = lf_index[lf][adr]; + if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; + aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( ne->numeric_effects_rh[i] ); + instantiate_exp_by_action( &(aa->numeric_effects_rh[aa->num_numeric_effects]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { + aa->illegal = TRUE; + } + if ( aa->illegal && + aa->num_conditions == 0 && + aa->num_numeric_conditions == 0 ) { + break; + } + /* that's it ???????????????? - !! + */ + aa->num_numeric_effects++; + } + if ( i < ne->num_numeric_effects ) { + /* an unconditional illegal effekt + */ + break; + } + /**************************NUMERIC EFFECTS - END*************************/ + + /* this effect is OK. go to next one in NormOp. + */ + a->num_effects++; + lnum_effects++; + } + if ( ne ) { + /* we get here if one effect was faulty + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + } else { + p = a; + a = a->next; + } + continue; + } + /**********************************second half: hard operators --> pseudo actions******************/ + if ( a->pseudo_action ) { + /* action is result of a PseudoAction + */ + pa = a->pseudo_action; + if ( pa->num_preconds > 0 ) { + a->preconds = ( int * ) calloc( pa->num_preconds, sizeof( int ) ); + } + a->num_preconds = 0; + for ( i = 0; i < pa->num_preconds; i++ ) { + lp = pa->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pa->preconds[i].args[j]; + } + adr = fact_adress(); + /* preconds are lpos in all cases due to reachability analysis + */ + if ( !lneg[lp][adr] ) { + continue; + } + a->preconds[a->num_preconds++] = lindex[lp][adr]; + } + + /**************************NUMERIC PRECOND*************************/ + if ( pa->num_numeric_preconds > 0 ) { + a->numeric_preconds_comp = ( Comparator * ) + calloc( pa->num_numeric_preconds, sizeof( Comparator ) ); + a->numeric_preconds_lh = ( ExpNode_pointer * ) + calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->numeric_preconds_rh = ( ExpNode_pointer * ) + calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->num_numeric_preconds = 0; + } + for ( i = 0; i < pa->num_numeric_preconds; i++ ) { + a->numeric_preconds_comp[a->num_numeric_preconds] = pa->numeric_preconds_comp[i]; + a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_lh[i] ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; + a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_rh[i] ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; + a->num_numeric_preconds++; + } + if ( i < pa->num_numeric_preconds ) { + /* a precond accesses an undefined fluent -> remove action! + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + /**************************NUMERIC PRECOND-END*************************/ + + /* and now for the effects + */ + if ( a->num_effects > 0 ) { + a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); + for ( i = 0; i < a->num_effects; i++ ) { + a->effects[i].illegal = FALSE; + a->effects[i].removed = FALSE; + } + } + a->num_effects = 0; + for ( pae = pa->effects; pae; pae = pae->next ) { + aa = &(a->effects[a->num_effects]); + + if ( pae->num_conditions > 0 ) { + aa->conditions = ( int * ) calloc( pae->num_conditions, sizeof( int ) ); + } + aa->num_conditions = 0; + for ( i = 0; i < pae->num_conditions; i++ ) { + lp = pae->conditions[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->conditions[i].args[j]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ + break; + } + if ( !lneg[lp][adr] ) {/* condition always true: skip it */ + continue; + } + aa->conditions[aa->num_conditions++] = lindex[lp][adr]; + } + if ( i < pae->num_conditions ) {/* found unreachable condition: free condition space */ + free( aa->conditions ); + continue; + } + + /**************************NUMERIC COND*************************/ + if ( pae->num_numeric_conditions > 0 ) { + aa->numeric_conditions_comp = ( Comparator * ) + calloc( pae->num_numeric_conditions, sizeof( Comparator ) ); + aa->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + aa->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < pae->num_numeric_conditions; i++ ) { + aa->numeric_conditions_lh[i] = NULL; + aa->numeric_conditions_rh[i] = NULL; + } + aa->num_numeric_conditions = 0; + } + for ( i = 0; i < pae->num_numeric_conditions; i++ ) { + aa->numeric_conditions_comp[aa->num_numeric_conditions] = pae->numeric_conditions_comp[i]; + aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_lh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_rh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; + aa->num_numeric_conditions++; + } + if ( i < pae->num_numeric_conditions ) { + /* numeric effect uses undefined fluent in condition --> + * THROW WHOLE ACTION AWAY! done by breaking out of the + * effects loop, which will be catched below overall + * effect handling. + */ + break; + } + /**************************NUMERIC COND - END*************************/ + + /* now create the add and del effects. + */ + if ( pae->num_adds > 0 ) { + aa->adds = ( int * ) calloc( pae->num_adds, sizeof( int ) ); + } + aa->num_adds = 0; + for ( i = 0; i < pae->num_adds; i++ ) { + lp = pae->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->adds[i].args[j]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* effect always true: skip it */ + continue; + } + aa->adds[aa->num_adds++] = lindex[lp][adr]; + } + + if ( pae->num_dels > 0 ) { + aa->dels = ( int * ) calloc( pae->num_dels, sizeof( int ) ); + } + aa->num_dels = 0; + for ( i = 0; i < pae->num_dels; i++ ) { + lp = pae->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->dels[i].args[j]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* effect always false: skip it */ + continue; + } + aa->dels[aa->num_dels++] = lindex[lp][adr]; + } + if ( i < pae->num_dels ) break; + + /**************************NUMERIC EFFECTS*************************/ + if ( pae->num_numeric_effects > 0 ) { + aa->numeric_effects_neft = ( NumericEffectType * ) + calloc( pae->num_numeric_effects, sizeof( NumericEffectType ) ); + aa->numeric_effects_fl = ( int * ) + calloc( pae->num_numeric_effects, sizeof( int ) ); + aa->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_effects, sizeof( ExpNode_pointer ) ); + aa->num_numeric_effects = 0; + } + for ( i = 0; i < pae->num_numeric_effects; i++ ) { + aa->numeric_effects_neft[aa->num_numeric_effects] = pae->numeric_effects_neft[i]; + lf = pae->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = pae->numeric_effects_fluent[i].args[j]; + if ( lf_args[j] < 0 ) { + printf("\n\nuninstantiated affected fluent in final actions! debug me.\n\n"); + exit( 1 ); + } + } + adr = fluent_adress(); + /* if it's -1, simply let it in --- if that effect appears, then + * action is illegal, otherwise not. + */ + aa->numeric_effects_fl[i] = lf_index[lf][adr]; + if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; + aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( pae->numeric_effects_rh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { + aa->illegal = TRUE; + } + if ( aa->illegal && + aa->num_conditions == 0 && + aa->num_numeric_conditions == 0 ) { + break; + } + /* that's it ???????????????? - !! + */ + aa->num_numeric_effects++; + } + if ( i < pae->num_numeric_effects ) { + /* an unconditional illegal effekt + */ + break; + } + /**************************NUMERIC EFFECTS - END*************************/ + + /* this effect is OK. go to next one in PseudoAction. + */ + a->num_effects++; + lnum_effects++; + } + if ( pae ) { + /* we get here if one effect was faulty + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + } else { + p = a; + a = a->next; + } + continue; + }/* end of if clause for PseudoAction */ + /* if action was neither normop, nor pseudo action determined, + * then it is an artificial action due to disjunctive goal + * conditions. + * + * these are already in final form. + */ + p = a; + a = a->next; + }/* endfor all actions ! */ + +} + + + +void instantiate_exp_by_action( ExpNode **n, Action *a ) + +{ + + int j, f, k, h; + Bool ok; + + switch ( (*n)->connective ) { + case AD: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + instantiate_exp_by_action( &((*n)->son), a ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + f = (*n)->fluent->function; + ok = TRUE; + for ( j = 0; j < gf_arity[f]; j++ ) { + h = ( (*n)->fluent->args[j] < 0 ) ? + a->inst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; + if ( h < 0 ) { + ok = FALSE; + } else { + (*n)->fluent->args[j] = h; + } + } + if ( !ok ) { + printf("\n\nnon-instantiated fluent in final actiona! debug me!!\n\n"); + exit( 1 ); + } + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\ninst. exp by action: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + + + + + + + + + + + + + + + + + + +/************************************************** + * CONNECTIVITY GRAPH. ULTRA CLEAN REPRESENTATION * + **************************************************/ + + + + + + + + + + + + + + + + + + + + +void build_connectivity_graph( void ) + +{ + + int i, j, k, l, n_op, n_ef, fl, ef, ef_, m; + float val; + Action *a; + ActionEffect *e; + + gnum_ft_conn = gnum_relevant_facts; + gnum_fl_conn = gnum_relevant_fluents; + gnum_op_conn = gnum_actions; + gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) ); + gfl_conn = ( FlConn * ) calloc( gnum_fl_conn, sizeof( FlConn ) ); + gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) ); + gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) ); + gnum_ef_conn = 0; + + for ( i = 0; i < gnum_ft_conn; i++ ) { + gft_conn[i].num_PC = 0; + gft_conn[i].num_A = 0; + gft_conn[i].num_D = 0; + + gft_conn[i].axiom_added = FALSE; + + gft_conn[i].rand = random() % BIG_INT; + } + + gnum_real_fl_conn = 0; + for ( i = 0; i < gnum_fl_conn; i++ ) { + gfl_conn[i].num_PC = 0; + gfl_conn[i].num_IN = 0; + gfl_conn[i].num_AS = 0; + + if ( grelevant_fluents_lnf[i] == NULL ) { + gfl_conn[i].artificial = FALSE; + gnum_real_fl_conn++; + gfl_conn[i].rand = random() % BIG_INT; + } else { + /* once we're in here we'll stay as all artificial + * fluents are appended to the end. + */ + gfl_conn[i].artificial = TRUE; + gfl_conn[i].lnf_F = ( int * ) + calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( int ) ); + gfl_conn[i].lnf_C = ( float * ) + calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( float ) ); + for ( j = 0; j < grelevant_fluents_lnf[i]->num_pF; j++ ) { + gfl_conn[i].lnf_F[j] = grelevant_fluents_lnf[i]->pF[j]; + gfl_conn[i].lnf_C[j] = grelevant_fluents_lnf[i]->pC[j]; + } + gfl_conn[i].num_lnf = grelevant_fluents_lnf[i]->num_pF; + } + } + + + /* why not do this here? + */ + gmneed_start_D = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + gmneed_start_V = ( float * ) calloc( gnum_real_fl_conn, sizeof( float ) ); + + + for ( i = 0; i < gnum_op_conn; i++ ) { + gop_conn[i].num_E = 0; + } + + for ( i = 0; i < lnum_effects; i++ ) { + gef_conn[i].num_PC = 0; + gef_conn[i].num_f_PC = 0; + gef_conn[i].num_A = 0; + gef_conn[i].num_D = 0; + gef_conn[i].num_I = 0; + gef_conn[i].num_IN = 0; + gef_conn[i].num_AS = 0; + + gef_conn[i].illegal = FALSE; + gef_conn[i].removed = FALSE; + } + + + /* determine if there are conditional effects. + */ + gconditional_effects = FALSE; + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->num_conditions > 0 ) { + break; + } + if ( e->num_lnf_conditions > 0 ) { + break; + } + } + if ( i < a->num_effects ) break; + } + if ( a ) { + printf("\n\ntask contains conditional effects. turning off state domination.\n\n"); + gconditional_effects = TRUE; + } + + n_op = 0; + n_ef = 0; + for ( a = gactions; a; a = a->next ) { + gop_conn[n_op].action = a; + gop_conn[n_op].axiom = a->axiom; + if ( a->num_effects == 0 ) { + continue; + } + + gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) ); + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + gef_conn[n_ef].cost = e->cost; + if ( e->removed ) { + /* this one disappeared through summarization + */ + continue; + } + gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef; + gef_conn[n_ef].op = n_op; + if ( e->illegal ) { + gef_conn[n_ef].illegal = TRUE; + } + + /*****************************CONDS********************************/ + gef_conn[n_ef].PC = ( int * ) + calloc( e->num_conditions + a->num_preconds, sizeof( int ) ); + for ( j = 0; j < a->num_preconds; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j]; + } + for ( j = 0; j < e->num_conditions; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j]; + } + /* similar thing for numeric conditions. + */ + gef_conn[n_ef].f_PC_comp = ( Comparator * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( Comparator ) ); + gef_conn[n_ef].f_PC_fl = ( int * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( int ) ); + gef_conn[n_ef].f_PC_c = ( float * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( float ) ); + gef_conn[n_ef].f_PC_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); + for ( j = 0; j < gnum_fl_conn; j++ ) { + gef_conn[n_ef].f_PC_direct_comp[j] = IGUAL; + } + gef_conn[n_ef].f_PC_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); + for ( j = 0; j < a->num_lnf_preconds; j++ ) { + if ( a->lnf_preconds_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final pre copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { + if ( gef_conn[n_ef].f_PC_fl[k] == a->lnf_preconds_lh[j]->pF[0] ) break; + } + if ( k < gef_conn[n_ef].num_f_PC ) { + if ( a->lnf_preconds_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { + /* weaker cond + */ + continue; + } + if ( a->lnf_preconds_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { + /* stronger cond + */ + gef_conn[n_ef].f_PC_c[k] = a->lnf_preconds_rh[j]; + gef_conn[n_ef].f_PC_comp[k] = a->lnf_preconds_comp[j]; + continue; + } + if ( a->lnf_preconds_comp[j] == GE ) { + /* we might need to strengthen our comp + */ + gef_conn[n_ef].f_PC_comp[k] = GE; + } + } else { + gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_comp[j]; + gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_lh[j]->pF[0]; + gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = a->lnf_preconds_rh[j]; + } + } + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final cond copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { + if ( gef_conn[n_ef].f_PC_fl[k] == e->lnf_conditions_lh[j]->pF[0] ) break; + } + if ( k < gef_conn[n_ef].num_f_PC ) { + if ( e->lnf_conditions_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { + continue; + } + if ( e->lnf_conditions_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { + gef_conn[n_ef].f_PC_c[k] = e->lnf_conditions_rh[j]; + gef_conn[n_ef].f_PC_comp[k] = e->lnf_conditions_comp[j]; + continue; + } + if ( e->lnf_conditions_comp[j] == GE ) { + gef_conn[n_ef].f_PC_comp[k] = GE; + } + } else { + gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_comp[j]; + gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_lh[j]->pF[0]; + gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = e->lnf_conditions_rh[j]; + } + } + /* now arrange the direct access structures from that. + */ + for ( j = 0; j < gef_conn[n_ef].num_f_PC; j++ ) { + gef_conn[n_ef].f_PC_direct_comp[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_comp[j]; + gef_conn[n_ef].f_PC_direct_c[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_c[j]; + } + /*****************************CONDS - END********************************/ + + + if ( e->illegal ) { + /* we don't care about the effects if they're illegal - + * all we care about is whether the condition is true or not. + */ + n_ef++; + gnum_ef_conn++; + continue; + } + /*****************************EFFECTS********************************/ + gef_conn[n_ef].A = ( int * ) calloc( e->num_adds, sizeof( int ) ); + gef_conn[n_ef].D = ( int * ) calloc( e->num_dels, sizeof( int ) ); + gef_conn[n_ef].IN_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].IN_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].IN_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); + gef_conn[n_ef].AS_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].AS_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].AS_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); + + /* duplicates removed in summarize already. + * + * but don't include adds that are in the conds. + * --- those are true anyway. + * + * and don't include dels that are in the adds + * --- those will be re-added anyway. + * + * NOTE: it is important that we use the *original* add list + * not the already reduced one, for the delete check! + * otherwise it may be that a delete that's in the add + * and also in the cond stays in! + * + * IT IS ALSO IMPORTANT THAT WE DO BOTH!!!, i.e. if we do + * the ads reduction then we *must* also do the dels + * reduction to avoid that things are deleted that + * would otherwise have been re-added. + */ + for ( j = 0; j < e->num_adds; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == e->adds[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j]; + } + for ( j = 0; j < e->num_dels; j++ ) { + for ( k = 0; k < e->num_adds; k++ ) { + if ( e->adds[k] == e->dels[j] ) break; + } + if ( k < e->num_adds ) continue; + gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j]; + } + + /* numeric part + */ + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_neft[j] != INCREASE ) continue; + gef_conn[n_ef].IN_fl[gef_conn[n_ef].num_IN] = e->lnf_effects_fl[j]; + if ( e->lnf_effects_rh[j]->num_pF == 1 ) { + if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { + printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); + exit( 1 ); + } + gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = e->lnf_effects_rh[j]->pF[0]; + } else { + if ( e->lnf_effects_rh[j]->num_pF != 0 ) { + printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); + exit( 1 ); + } + gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = -1; + } + gef_conn[n_ef].IN_c[gef_conn[n_ef].num_IN++] = e->lnf_effects_rh[j]->c; + } + /* now remove increasers by nothing. + */ + j = 0; + while ( j < gef_conn[n_ef].num_IN ) { + if ( gef_conn[n_ef].IN_fl_[j] != -1 || + gef_conn[n_ef].IN_c[j] != 0 ) { + j++; + continue; + } + for ( k = j; k < gef_conn[n_ef].num_IN - 1; k++ ) { + gef_conn[n_ef].IN_fl[k] = gef_conn[n_ef].IN_fl[k+1]; + gef_conn[n_ef].IN_fl_[k] = gef_conn[n_ef].IN_fl_[k+1]; + gef_conn[n_ef].IN_c[k] = gef_conn[n_ef].IN_c[k+1]; + } + gef_conn[n_ef].num_IN--; + } + /* now: the assigners... + */ + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_neft[j] != ASSIGN ) continue; + gef_conn[n_ef].AS_fl[gef_conn[n_ef].num_AS] = e->lnf_effects_fl[j]; + if ( e->lnf_effects_rh[j]->num_pF == 1 ) { + if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { + printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); + exit( 1 ); + } + gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = e->lnf_effects_rh[j]->pF[0]; + } else { + if ( e->lnf_effects_rh[j]->num_pF != 0 ) { + printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); + exit( 1 ); + } + gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = -1; + } + gef_conn[n_ef].AS_c[gef_conn[n_ef].num_AS++] = e->lnf_effects_rh[j]->c; + } + /*****************************EFFECTS - END********************************/ + + n_ef++; + gnum_ef_conn++; + }/* end all a->effects */ + + + /*****************************EMPTY EFFECTS********************************/ + if ( gop_conn[n_op].num_E >= 1 ) { + /* CHECK EMPTY EFFECTS! + * + * two step process --- first, remove all effects that are entirely empty. + * second, check if all remaining effects are illegal + * or only delete: + * in that case, the op will never do any good so we + * remove all its effects. + */ + i = 0; + while ( i < gop_conn[n_op].num_E ) { + /* illegal effects *must* stay in!!! + */ + if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { + i++; + continue; + } + if ( gef_conn[gop_conn[n_op].E[i]].num_A != 0 || + gef_conn[gop_conn[n_op].E[i]].num_D != 0 || + gef_conn[gop_conn[n_op].E[i]].num_IN != 0 || + gef_conn[gop_conn[n_op].E[i]].num_AS != 0 ) { + i++; + continue; + } + /* we keep it in the gef_conn (seems easier), + * but mark it as removed, which will exclude it from everything. + */ + gef_conn[gop_conn[n_op].E[i]].removed = TRUE; + for ( j = i; j < gop_conn[n_op].num_E - 1; j++ ) { + gop_conn[n_op].E[j] = gop_conn[n_op].E[j+1]; + } + gop_conn[n_op].num_E--; + } + + m = 0; + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { + m++; + continue; + } + if ( gef_conn[gop_conn[n_op].E[i]].num_A == 0 && + gef_conn[gop_conn[n_op].E[i]].num_IN == 0 && + gef_conn[gop_conn[n_op].E[i]].num_AS == 0 ) { + m++; + } + } + if ( m == gop_conn[n_op].num_E ) { + /* all remaining effects illegal or solely-deleters. + */ + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + gef_conn[gop_conn[n_op].E[i]].removed = TRUE; + } + gop_conn[n_op].num_E = 0; + } + } + /*****************************EMPTY EFFECTS - END********************************/ + + + /*****************************IMPLIED EFFECTS********************************/ + if ( gop_conn[n_op].num_E > 1 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + gef_conn[ef].I = ( int * ) calloc( gop_conn[n_op].num_E, sizeof( int ) ); + gef_conn[ef].num_I = 0; + } + for ( i = 0; i < gop_conn[n_op].num_E - 1; i++ ) { + ef = gop_conn[n_op].E[i]; + for ( j = i+1; j < gop_conn[n_op].num_E; j++ ) { + ef_ = gop_conn[n_op].E[j]; + /* ef ==> ef_ ? */ + for ( k = 0; k < gef_conn[ef_].num_PC; k++ ) { + for ( l = 0; l < gef_conn[ef].num_PC; l++ ) { + if ( gef_conn[ef].PC[l] == gef_conn[ef_].PC[k] ) break; + } + if ( l == gef_conn[ef].num_PC ) break; + } + if ( k == gef_conn[ef_].num_PC ) { + for ( k = 0; k < gnum_fl_conn; k++ ) { + if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL ) continue; + if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL || + gef_conn[ef].f_PC_direct_c[k] < gef_conn[ef_].f_PC_direct_c[k] || + ( gef_conn[ef].f_PC_direct_c[k] == gef_conn[ef_].f_PC_direct_c[k] && + gef_conn[ef].f_PC_direct_comp[k] == GEQ && + gef_conn[ef_].f_PC_direct_comp[k] == GE ) ) break; + } + if ( k == gnum_fl_conn ) { + gef_conn[ef].I[gef_conn[ef].num_I++] = ef_; + } + } + /* ef_ ==> ef ? */ + for ( k = 0; k < gef_conn[ef].num_PC; k++ ) { + for ( l = 0; l < gef_conn[ef_].num_PC; l++ ) { + if ( gef_conn[ef_].PC[l] == gef_conn[ef].PC[k] ) break; + } + if ( l == gef_conn[ef_].num_PC ) break; + } + if ( k == gef_conn[ef].num_PC ) { + for ( k = 0; k < gnum_fl_conn; k++ ) { + if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL ) continue; + if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL || + gef_conn[ef_].f_PC_direct_c[k] < gef_conn[ef].f_PC_direct_c[k] || + ( gef_conn[ef_].f_PC_direct_c[k] == gef_conn[ef].f_PC_direct_c[k] && + gef_conn[ef_].f_PC_direct_comp[k] == GEQ && + gef_conn[ef].f_PC_direct_comp[k] == GE ) ) break; + } + if ( k == gnum_fl_conn ) { + gef_conn[ef_].I[gef_conn[ef_].num_I++] = ef; + } + } + } + } + } + /*****************************IMPLIED EFFECTS - END********************************/ + + /* op cost is sum of eff costs + gtt*1: + * [gtt is multiplicator of TOTAL-TIME in final metric; if no + * total-time part in metric, it is 0] + * ie eff-costs plus the cost for the time taken by 1 more step. + */ + gop_conn[n_op].cost = gtt; + if ( gop_conn[n_op].num_E > 0 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + if ( gef_conn[ef].illegal ) { + continue; + } + if ( gef_conn[ef].removed ) { + continue; + } + gop_conn[n_op].cost += gef_conn[ef].cost; + } + } + + /* first sweep: only count the space we need for the fact arrays ! + */ + if ( gop_conn[n_op].num_E > 0 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + for ( j = 0; j < gef_conn[ef].num_PC; j++ ) { + gft_conn[gef_conn[ef].PC[j]].num_PC++; + } + for ( j = 0; j < gef_conn[ef].num_A; j++ ) { + gft_conn[gef_conn[ef].A[j]].num_A++; + if ( gop_conn[n_op].axiom ) { + gft_conn[gef_conn[ef].A[j]].axiom_added = TRUE; + } + } + for ( j = 0; j < gef_conn[ef].num_D; j++ ) { + gft_conn[gef_conn[ef].D[j]].num_D++; + } + /* similar increments for flconn + */ + for ( j = 0; j < gef_conn[ef].num_f_PC; j++ ) { + gfl_conn[gef_conn[ef].f_PC_fl[j]].num_PC++; + } + for ( j = 0; j < gef_conn[ef].num_IN; j++ ) { + gfl_conn[gef_conn[ef].IN_fl[j]].num_IN++; + } + for ( j = 0; j < gef_conn[ef].num_AS; j++ ) { + gfl_conn[gef_conn[ef].AS_fl[j]].num_AS++; + } + } + } + + + n_op++; + } + + /*****************************FLCONN********************************/ + for ( i = 0; i < gnum_ft_conn; i++ ) { + if ( gft_conn[i].num_PC > 0 ) { + gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) ); + } + gft_conn[i].num_PC = 0; + if ( gft_conn[i].num_A > 0 ) { + gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) ); + } + gft_conn[i].num_A = 0; + if ( gft_conn[i].num_D > 0 ) { + gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) ); + } + gft_conn[i].num_D = 0; + } + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gef_conn[i].removed ) continue; + for ( j = 0; j < gef_conn[i].num_PC; j++ ) { + gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i; + } + for ( j = 0; j < gef_conn[i].num_A; j++ ) { + gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i; + } + for ( j = 0; j < gef_conn[i].num_D; j++ ) { + gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i; + } + } + /*****************************FTCONN - END********************************/ + + + /*****************************FLCONN********************************/ + /* similar thing for flconn + */ + for ( i = 0; i < gnum_fl_conn; i++ ) { + if ( gfl_conn[i].num_PC > 0 ) { + gfl_conn[i].PC = ( int * ) calloc( gfl_conn[i].num_PC, sizeof( int ) ); + } + gfl_conn[i].num_PC = 0; + if ( gfl_conn[i].num_IN > 0 ) { + gfl_conn[i].IN = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); + gfl_conn[i].IN_fl_ = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); + gfl_conn[i].IN_c = ( float * ) calloc( gfl_conn[i].num_IN, sizeof( float ) ); + } + gfl_conn[i].num_IN = 0; + if ( gfl_conn[i].num_AS > 0 ) { + gfl_conn[i].AS = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); + gfl_conn[i].AS_fl_ = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); + gfl_conn[i].AS_c = ( float * ) calloc( gfl_conn[i].num_AS, sizeof( float ) ); + } + gfl_conn[i].num_AS = 0; + } + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gef_conn[i].removed ) continue; + /* PCs + */ + for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { + fl = gef_conn[i].f_PC_fl[j]; + gfl_conn[fl].PC[gfl_conn[fl].num_PC++] = i; + } + /* insert increasers by decreasing amount --> + * "best" - at least for constant part - are first! + */ + for ( j = 0; j < gef_conn[i].num_IN; j++ ) { + fl = gef_conn[i].IN_fl[j]; + val = gef_conn[i].IN_c[j]; + for ( k = 0; k < gfl_conn[fl].num_IN; k++ ) { + if ( gfl_conn[fl].IN_c[k] < val ) break; + } + for ( l = gfl_conn[fl].num_IN; l > k; l-- ) { + gfl_conn[fl].IN[l] = gfl_conn[fl].IN[l-1]; + gfl_conn[fl].IN_fl_[l] = gfl_conn[fl].IN_fl_[l-1]; + gfl_conn[fl].IN_c[l] = gfl_conn[fl].IN_c[l-1]; + } + gfl_conn[fl].IN[k] = i; + gfl_conn[fl].IN_fl_[k] = gef_conn[i].IN_fl_[j];/* the rh fluent */ + gfl_conn[fl].IN_c[k] = val; + gfl_conn[fl].num_IN++; + } + /* insert assigners by decreasing amount --> + * "best" - at least for constant part - are first! + */ + for ( j = 0; j < gef_conn[i].num_AS; j++ ) { + fl = gef_conn[i].AS_fl[j]; + val = gef_conn[i].AS_c[j]; + for ( k = 0; k < gfl_conn[fl].num_AS; k++ ) { + if ( gfl_conn[fl].AS_c[k] < val ) break; + } + for ( l = gfl_conn[fl].num_AS; l > k; l-- ) { + gfl_conn[fl].AS[l] = gfl_conn[fl].AS[l-1]; + gfl_conn[fl].AS_fl_[l] = gfl_conn[fl].AS_fl_[l-1]; + gfl_conn[fl].AS_c[l] = gfl_conn[fl].AS_c[l-1]; + } + gfl_conn[fl].AS[k] = i; + gfl_conn[fl].AS_fl_[k] = gef_conn[i].AS_fl_[j];/* the rh fluent */ + gfl_conn[fl].AS_c[k] = val; + gfl_conn[fl].num_AS++; + } + } + /*****************************FLCONN - END********************************/ + + + /*****************************GOAL********************************/ + gflogic_goal = ( int * ) calloc( gnum_logic_goal, sizeof( int ) ); + for ( j = 0; j < gnum_logic_goal; j++ ) { + for ( k = 0; k < gnum_flogic_goal; k++ ) { + if ( gflogic_goal[k] == glogic_goal[j] ) break; + } + if ( k < gnum_flogic_goal ) continue; + gflogic_goal[gnum_flogic_goal++] = glogic_goal[j]; + } + /* numeric part + */ + gfnumeric_goal_comp = ( Comparator * ) calloc( gnum_lnf_goal, sizeof( Comparator ) ); + gfnumeric_goal_fl = ( int * ) calloc( gnum_lnf_goal, sizeof( int ) ); + gfnumeric_goal_c = ( float * ) calloc( gnum_lnf_goal, sizeof( float ) ); + for ( j = 0; j < gnum_lnf_goal; j++ ) { + if ( glnf_goal_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final goal copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gnum_fnumeric_goal; k++ ) { + if ( gfnumeric_goal_fl[k] == glnf_goal_lh[j]->pF[0] ) break; + } + if ( k < gnum_fnumeric_goal ) { + if ( glnf_goal_rh[j] < gfnumeric_goal_c[k] ) continue; + if ( glnf_goal_rh[j] > gfnumeric_goal_c[k] ) { + gfnumeric_goal_comp[k] = glnf_goal_comp[j]; + gfnumeric_goal_c[k] = glnf_goal_rh[j]; + continue; + } + if ( glnf_goal_comp[j] == GE ) { + gfnumeric_goal_comp[k] = GE; + } + } else { + gfnumeric_goal_comp[gnum_fnumeric_goal] = glnf_goal_comp[j]; + gfnumeric_goal_fl[gnum_fnumeric_goal] = glnf_goal_lh[j]->pF[0]; + gfnumeric_goal_c[gnum_fnumeric_goal++] = glnf_goal_rh[j]; + } + } + gfnumeric_goal_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); + for ( j = 0; j < gnum_fl_conn; j++ ) { + gfnumeric_goal_direct_comp[j] = IGUAL; + } + gfnumeric_goal_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); + for ( k = 0; k < gnum_fnumeric_goal; k++ ) { + gfnumeric_goal_direct_comp[gfnumeric_goal_fl[k]] = gfnumeric_goal_comp[k]; + gfnumeric_goal_direct_c[gfnumeric_goal_fl[k]] = gfnumeric_goal_c[k]; + } + /*****************************GOAL - END********************************/ + + + + /******************** + * safety: if there are numeric precs/goals, need to turn + * cost-minimizing rplans off!!! + * (see comments with def of gcost_rplans + */ + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gcost_rplans && gef_conn[i].num_f_PC > 0 ) { + printf("\nwarning: numeric precondition. turning cost-minimizing relaxed plans OFF."); + gcost_rplans = FALSE; + break; + } + } + if ( gcost_rplans && gnum_fnumeric_goal > 0 ) { + printf("\nwarning: numeric goal. turning cost-minimizing relaxed plans OFF."); + gcost_rplans = FALSE; + } + + + + + if ( gcmd_line.display_info == 125 ) { + printf("\n\ncreated connectivity graph as follows:"); + + printf("\n\n------------------OP ARRAY:-----------------------"); + for ( i = 0; i < gnum_op_conn; i++ ) { + printf("\n\nOP %d: ", i); + if ( gop_conn[i].axiom ) printf("(axiom) "); + print_op_name( i ); + printf(" cost %f", gop_conn[i].cost); + printf("\n----------EFFS:"); + for ( j = 0; j < gop_conn[i].num_E; j++ ) { + printf("\neffect %d", gop_conn[i].E[j]); + } + } + + printf("\n\n-------------------EFFECT ARRAY:----------------------"); + for ( i = 0; i < gnum_ef_conn; i++ ) { + printf("\n\neffect %d of op %d cost %f: ", i, gef_conn[i].op, gef_conn[i].cost); + print_op_name( gef_conn[i].op ); + if ( gef_conn[i].illegal ) printf(" ******ILLEGAL************************"); + if ( gef_conn[i].removed ) printf(" ******REMOVED************************"); + printf("\n----------PCS:"); + for ( j = 0; j < gef_conn[i].num_PC; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].PC[j] ); + } + printf("\n----------f_PCS:"); + for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].f_PC_fl[j] ); + if ( gef_conn[i].f_PC_comp[j] == GEQ ) { + printf(" >= "); + } else { + printf(" > "); + } + printf("%f", gef_conn[i].f_PC_c[j]); + } + printf("\nDIRECT: "); + for ( j = 0; j < gnum_fl_conn; j++ ) { + if ( gef_conn[i].f_PC_direct_comp[j] == IGUAL ) { + printf("IGUAL | "); + } + if ( gef_conn[i].f_PC_direct_comp[j] == GEQ ) { + printf(">= %f | ", gef_conn[i].f_PC_direct_c[j]); + } + if ( gef_conn[i].f_PC_direct_comp[j] == GE ) { + printf("> %f | ", gef_conn[i].f_PC_direct_c[j]); + } + } + if ( gef_conn[i].illegal ) continue; + printf("\n----------ADDS:"); + for ( j = 0; j < gef_conn[i].num_A; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].A[j] ); + } + printf("\n----------DELS:"); + for ( j = 0; j < gef_conn[i].num_D; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].D[j] ); + } + printf("\n----------INCREASE:"); + for ( j = 0; j < gef_conn[i].num_IN; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].IN_fl[j] ); + printf(" by "); + if ( gef_conn[i].IN_fl_[j] >= 0 ) { + print_fl_name( gef_conn[i].IN_fl_[j] ); + printf(" + %f", gef_conn[i].IN_c[j]); + } else { + printf("%f", gef_conn[i].IN_c[j]); + } + } + printf("\n----------ASSIGN:"); + for ( j = 0; j < gef_conn[i].num_AS; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].AS_fl[j] ); + printf(" to "); + if ( gef_conn[i].AS_fl_[j] >= 0 ) { + print_fl_name( gef_conn[i].AS_fl_[j] ); + printf(" + %f", gef_conn[i].AS_c[j]); + } else { + printf("%f", gef_conn[i].AS_c[j]); + } + } + printf("\n----------IMPLIEDS:"); + for ( j = 0; j < gef_conn[i].num_I; j++ ) { + printf("\nimplied effect %d of op %d: ", + gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op); + print_op_name( gef_conn[gef_conn[i].I[j]].op ); + } + } + + printf("\n\n----------------------FT ARRAY:-----------------------------"); + for ( i = 0; i < gnum_ft_conn; i++ ) { + printf("\n\nFT: "); + print_ft_name( i ); + printf(" rand: %d", gft_conn[i].rand); + printf(" --------- AXIOM ADDED %d", gft_conn[i].axiom_added); + printf("\n----------PRE COND OF:"); + for ( j = 0; j < gft_conn[i].num_PC; j++ ) { + printf("\neffect %d", gft_conn[i].PC[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].PC[j]].op ); + } + printf("\n----------ADD BY:"); + for ( j = 0; j < gft_conn[i].num_A; j++ ) { + printf("\neffect %d", gft_conn[i].A[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].A[j]].op ); + } + printf("\n----------DEL BY:"); + for ( j = 0; j < gft_conn[i].num_D; j++ ) { + printf("\neffect %d", gft_conn[i].D[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].D[j]].op ); + } + } + + printf("\n\n----------------------FLUENT ARRAY:-----------------------------"); + for ( i = 0; i < gnum_fl_conn; i++ ) { + printf("\n\nFL: "); + print_fl_name( i ); + printf("\n----------PRE COND OF:"); + for ( j = 0; j < gfl_conn[i].num_PC; j++ ) { + printf("\neffect %d", gfl_conn[i].PC[j]); + printf(" - op "); print_op_name( gef_conn[gfl_conn[i].PC[j]].op ); + } + printf("\n----------INCREASED BY:"); + for ( j = 0; j < gfl_conn[i].num_IN; j++ ) { + if ( gfl_conn[i].IN_fl_[j] == -1 ) { + printf("\neffect %d --- %f", gfl_conn[i].IN[j], gfl_conn[i].IN_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); + } else { + printf("\neffect %d --- ", gfl_conn[i].IN[j]); + print_fl_name( gfl_conn[i].IN_fl_[j] ); + printf(" + %f", gfl_conn[i].IN_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); + } + } + printf("\n----------ASSIGNED BY:"); + for ( j = 0; j < gfl_conn[i].num_AS; j++ ) { + if ( gfl_conn[i].AS_fl_[j] == -1 ) { + printf("\neffect %d --- %f", gfl_conn[i].AS[j], gfl_conn[i].AS_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); + } else { + printf("\neffect %d --- ", gfl_conn[i].AS[j]); + print_fl_name( gfl_conn[i].AS_fl_[j] ); + printf(" + %f", gfl_conn[i].AS_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); + } + } + if ( gfl_conn[i].artificial ) { + printf("\n----------ARTIFICIAL FOR:"); + for ( j = 0; j < gfl_conn[i].num_lnf; j++ ) { + printf(" %f*", gfl_conn[i].lnf_C[j]); + print_fl_name( gfl_conn[i].lnf_F[j] ); + if ( j < gfl_conn[i].num_lnf - 1 ) { + printf(" +"); + } + } + } else { + printf("\n----------REAL"); + } + } + + printf("\n\n----------------------GOAL:-----------------------------"); + for ( j = 0; j < gnum_flogic_goal; j++ ) { + printf("\n"); + print_ft_name( gflogic_goal[j] ); + } + for ( j = 0; j < gnum_fnumeric_goal; j++ ) { + printf("\n"); + print_fl_name( gfnumeric_goal_fl[j] ); + if ( gfnumeric_goal_comp[j] == GEQ ) { + printf(" >= "); + } else { + printf(" > "); + } + printf("%f", gfnumeric_goal_c[j]); + } + printf("\nDIRECT: "); + for ( j = 0; j < gnum_fl_conn; j++ ) { + if ( gfnumeric_goal_direct_comp[j] == IGUAL ) { + printf("IGUAL | "); + } + if ( gfnumeric_goal_direct_comp[j] == GEQ ) { + printf(">= %f | ", gfnumeric_goal_direct_c[j]); + } + if ( gfnumeric_goal_direct_comp[j] == GE ) { + printf("> %f | ", gfnumeric_goal_direct_c[j]); + } + } + + printf("\n\n"); + } + +} + + + diff --git a/models/main_models/rt1/gen/ff_planner/inst_final.h b/models/main_models/rt1/gen/ff_planner/inst_final.h new file mode 100644 index 000000000..ab42b6097 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_final.h @@ -0,0 +1,69 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_final.h + * Description: headers for final domain representation functions + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + +#ifndef _INST_FINAL_H +#define _INST_FINAL_H + + + +void perform_reachability_analysis( void ); +int fact_adress( void ); +void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ); +void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ); + + + +void collect_relevant_facts_and_fluents( void ); +void create_final_goal_state( void ); +Bool set_relevants_in_wff( WffNode **w ); +Bool set_relevants_in_exp( ExpNode **n ); +void create_final_initial_state( void ); +void create_final_actions( void ); +void instantiate_exp_by_action( ExpNode **n, Action *a ); + + + +void build_connectivity_graph( void ); + + + +void summarize_effects( void ); +Bool same_condition( ActionEffect *e, ActionEffect *e_ ); +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); +void merge_effects( ActionEffect *e, ActionEffect *e_ ); + + + +#endif /* _INST_FINAL_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_hard.c b/models/main_models/rt1/gen/ff_planner/inst_hard.c new file mode 100644 index 000000000..54f63d752 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_hard.c @@ -0,0 +1,1306 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: inst_hard.c + * Description: functions for multiplying hard operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_hard.h" + + + + + + + + + + + +/* used in multiplying routines + */ +int linst_table[MAX_VARS]; +int_pointer lini[MAX_PREDICATES]; + + + + + + + + +void build_hard_action_templates( void ) + +{ + + int i, j, size, adr; + MixedOperator *o; + + /* remove unused params; empty types are already recognised during + * domain translation; have to be handled after (or while) + * unaries encoding (if done), though. + */ + cleanup_hard_domain(); + + if ( gcmd_line.display_info == 115 ) { + printf("\n\ncleaned up hard domain representation is:\n\n"); + for ( i = 0; i < gnum_hard_operators; i++ ) { + print_Operator( ghard_operators[i] ); + } + fflush( stdout ); + } + + /* create local table of instantiated facts that occur in the + * initial state. for fast finding out if fact is in ini or not. + */ + for ( i = 0; i < gnum_predicates; i++ ) { + size = 1; + for ( j = 0; j < garity[i]; j++ ) { + size *= gnum_constants; + } + lini[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + for ( j = 0; j < size; j++ ) { + lini[i][j] = 0; + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + adr = instantiated_fact_adress( &ginitial_predicate[i][j] ); + lini[i][adr]++; + } + } + + + /* create mixed op for each param combination + */ + multiply_hard_op_parameters(); + + if ( gcmd_line.display_info == 116 ) { + printf("\n\nmixed hard domain representation is:\n\n"); + for ( o = ghard_mixed_operators; o; o = o->next ) { + print_MixedOperator( o ); + } + fflush( stdout ); + } + + /* create pseudo op for each mixed op + */ + multiply_hard_effect_parameters(); + + if ( gcmd_line.display_info == 117 ) { + printf("\n\npseudo hard domain representation is:\n\n"); + for ( i = 0; i < gnum_hard_templates; i++ ) { + print_PseudoAction( ghard_templates[i] ); + } + fflush( stdout ); + } + + +} + + + + + + + + + + + + +/**************** + * CLEANUP CODE * + ****************/ + + + + + + + + + + + + +void cleanup_hard_domain( void ) + +{ + + int i, j, k, par; + Operator *o; + Effect *e; + + /* so far, only unused parameters removal + */ + + for ( i = 0; i < gnum_hard_operators; i++ ) { + o = ghard_operators[i]; + + j = 0; + while ( j < o->num_vars ) { + if ( var_used_in_wff( ENCODE_VAR( j ), o->preconds ) ) { + j++; + continue; + } + + for ( e = o->effects; e; e = e->next ) { + if ( var_used_in_wff( ENCODE_VAR( j ), e->conditions ) ) { + break; + } + if ( var_used_in_literals( ENCODE_VAR( j ), e->effects ) ) { + break; + } + if ( var_used_in_numeric_effects( ENCODE_VAR( j ), e->numeric_effects ) ) { + break; + } + } + if ( e ) { + j++; + continue; + } + + o->removed[j] = TRUE; + j++; + } + + for ( e = o->effects; e; e = e->next ) { + j = 0; + while ( j < e->num_vars ) { + par = o->num_vars + j; + if ( var_used_in_wff( ENCODE_VAR( par ), e->conditions ) ) { + j++; + continue; + } + if ( var_used_in_literals( ENCODE_VAR( par ), e->effects ) ) { + j++; + continue; + } + if ( var_used_in_numeric_effects( ENCODE_VAR( par ), e->numeric_effects ) ) { + j++; + continue; + } + + if ( e->var_names[j] ) { + free( e->var_names[j] ); + } + for ( k = j; k < e->num_vars - 1; k++ ) { + e->var_names[k] = e->var_names[k+1]; + e->var_names[k] = e->var_names[k+1]; + } + e->num_vars--; + decrement_inferior_vars( par, e->conditions ); + decrement_inferior_vars_in_literals( par, e->effects ); + decrement_inferior_vars_in_numeric_effects( par, e->numeric_effects ); + } + } + } + +} + + + +Bool var_used_in_literals( int code_var, Literal *ef ) + +{ + + Literal *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + if ( l->fact.args[i] == code_var ) { + return TRUE; + } + } + } + + return FALSE; + +} + + + +Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ) + +{ + + NumericEffect *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { + if ( l->fluent.args[i] == code_var ) { + return TRUE; + } + } + if ( var_used_in_exp( code_var, l->rh ) ) { + return TRUE; + } + } + + return FALSE; + +} + + + +void decrement_inferior_vars_in_literals( int var, Literal *ef ) + +{ + + Literal *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + if ( l->fact.args[i] >= 0 ) { + continue; + } + if ( DECODE_VAR( l->fact.args[i] ) > var ) { + l->fact.args[i]++; + } + } + } + +} + + + +void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ) + +{ + + NumericEffect *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { + if ( l->fluent.args[i] >= 0 ) { + continue; + } + if ( DECODE_VAR( l->fluent.args[i] ) > var ) { + l->fluent.args[i]++; + } + } + decrement_inferior_vars_in_exp( var, l->rh ); + } + +} + + + + + + + + + + + + + + +/****************************** + * CODE THAT BUILDS MIXED OPS * + ******************************/ + + + + + + + + + + + + + + +void multiply_hard_op_parameters( void ) + +{ + + int i; + + ghard_mixed_operators = NULL; + + for ( i = 0; i < MAX_VARS; i++ ) { + linst_table[i] = -1; + } + + for ( i = 0; i < gnum_hard_operators; i++ ) { + create_hard_mixed_operators( ghard_operators[i], 0 ); + } + +} + + + +void create_hard_mixed_operators( Operator *o, int curr_var ) + +{ + + int t, i, m, mn; + WffNode *tmp1, *w, *ww; + MixedOperator *tmp2; + + if ( curr_var < o->num_vars ) { + if ( o->removed[curr_var] ) { + /* param doesn't matter -- select any appropriate type constant + * at least one there; otherwise, op would not have been translated. + */ + linst_table[curr_var] = gtype_consts[o->var_types[curr_var]][0]; + create_hard_mixed_operators( o, curr_var + 1 ); + linst_table[curr_var] = -1; + return; + } + + t = o->var_types[curr_var]; + for ( i = 0; i < gtype_size[t]; i++ ) { + linst_table[curr_var] = gtype_consts[t][i]; + + create_hard_mixed_operators( o, curr_var + 1 ); + + linst_table[curr_var] = -1; + } + return; + } + + + tmp1 = instantiate_wff( o->preconds ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + dnf( &tmp1 ); + cleanup_wff( &tmp1 ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + /* only debugging, REMOVE LATER + */ + if ( is_dnf( tmp1 ) == -1 ) { + printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", o->name); + print_Wff( tmp1, 0 ); + exit( 1 ); + } + + switch ( tmp1->connective ) { + case OR: + for ( w = tmp1->sons; w; w = w->next ) { + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + if ( w->connective == AND ) { + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_preconds = m; + tmp2->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp2->preconds[m].predicate = ww->fact->predicate; + for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { + tmp2->preconds[m].args[i] = ww->fact->args[i]; + } + m++; + } + if ( ww->connective == COMP ) { + tmp2->numeric_preconds_comp[mn] = ww->comp; + tmp2->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); + tmp2->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_preconds = 1; + tmp2->preconds[0].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->preconds[0].args[i] = w->fact->args[i]; + } + } + if ( w->connective == COMP ) { + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_comp[0] = w->comp; + tmp2->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp2->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp2->num_numeric_preconds = 1; + } + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + } + break; + case AND: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + m = 0; + mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_preconds = m; + tmp2->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + tmp2->preconds[m].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->preconds[m].args[i] = w->fact->args[i]; + } + m++; + } + if ( w->connective == COMP ) { + tmp2->numeric_preconds_comp[mn] = w->comp; + tmp2->numeric_preconds_lh[mn] = copy_Exp( w->lh ); + tmp2->numeric_preconds_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case ATOM: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_preconds = 1; + tmp2->preconds[0].predicate = tmp1->fact->predicate; + for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { + tmp2->preconds[0].args[i] = tmp1->fact->args[i]; + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case COMP: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_comp[0] = tmp1->comp; + tmp2->numeric_preconds_lh[0] = copy_Exp( tmp1->lh ); + tmp2->numeric_preconds_rh[0] = copy_Exp( tmp1->rh ); + tmp2->num_numeric_preconds = 1; + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case TRU: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + default: + printf("\n\nillegal connective %d in parsing DNF precond.\n\n", + tmp1->connective); + exit( 1 ); + } + + free_WffNode( tmp1 ); + +} + + + +Effect *instantiate_Effect( Effect *e ) + +{ + + Effect *res = NULL, *tmp, *i; + Literal *tt, *l; + NumericEffect *ne, *ttt; + int j; + + for ( i = e; i; i = i->next ) { + tmp = new_Effect(); + + for ( j = 0; j < i->num_vars; j++ ) { + tmp->var_types[j] = i->var_types[j]; + } + tmp->num_vars = i->num_vars; + + tmp->conditions = instantiate_wff( i->conditions ); + + if ( tmp->conditions->connective == FAL ) { + free_partial_Effect( tmp ); + continue; + } + + for ( l = i->effects; l; l = l->next ) { + tt = new_Literal(); + tt->negated = l->negated; + tt->fact.predicate = l->fact.predicate; + for ( j = 0; j < garity[tt->fact.predicate]; j++ ) { + tt->fact.args[j] = l->fact.args[j]; + if ( tt->fact.args[j] < 0 && + linst_table[DECODE_VAR( tt->fact.args[j] )] != -1 ) { + tt->fact.args[j] = linst_table[DECODE_VAR( tt->fact.args[j] )]; + } + } + tt->next = tmp->effects; + if ( tmp->effects ) { + tmp->effects->prev = tt; + } + tmp->effects = tt; + } + + for ( ne = i->numeric_effects; ne; ne = ne->next ) { + ttt = new_NumericEffect(); + ttt->neft = ne->neft; + ttt->fluent.function = ne->fluent.function; + for ( j = 0; j < gf_arity[ttt->fluent.function]; j++ ) { + ttt->fluent.args[j] = ne->fluent.args[j]; + if ( ttt->fluent.args[j] < 0 && + linst_table[DECODE_VAR( ttt->fluent.args[j] )] != -1 ) { + ttt->fluent.args[j] = linst_table[DECODE_VAR( ttt->fluent.args[j] )]; + } + } + ttt->rh = copy_Exp( ne->rh ); + instantiate_exp( &(ttt->rh) ); + ttt->next = tmp->numeric_effects; + if ( tmp->numeric_effects ) { + tmp->numeric_effects->prev = ttt; + } + tmp->numeric_effects = ttt; + } + + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + } + + return res; + +} + + + +WffNode *instantiate_wff( WffNode *w ) + +{ + + WffNode *res = NULL, *tmp, *i; + int j, m, h; + Bool ok, ct; + + switch ( w->connective ) { + case AND: + m = 0; + i = w->sons; + while ( i ) { + tmp = instantiate_wff( i ); + if ( tmp->connective == FAL ) { + free_WffNode( res ); + return tmp; + } + if ( tmp->connective == TRU ) { + free( tmp ); + i = i->next; + continue; + } + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + i = i->next; + m++; + } + if ( m == 0 ) { + res = new_WffNode( TRU ); + break; + } + if ( m == 1 ) { + break; + } + tmp = new_WffNode( AND ); + tmp->sons = res; + res = tmp; + break; + case OR: + m = 0; + i = w->sons; + while ( i ) { + tmp = instantiate_wff( i ); + if ( tmp->connective == TRU ) { + free_WffNode( res ); + return tmp; + } + if ( tmp->connective == FAL ) { + free( tmp ); + i = i->next; + continue; + } + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + i = i->next; + m++; + } + if ( m == 0 ) { + res = new_WffNode( FAL ); + break; + } + if ( m == 1 ) { + break; + } + tmp = new_WffNode( OR ); + tmp->sons = res; + res = tmp; + break; + case ATOM: + res = new_WffNode( ATOM ); + res->fact = new_Fact(); + res->fact->predicate = w->fact->predicate; + ok = TRUE; + for ( j = 0; j < garity[res->fact->predicate]; j++ ) { + h = ( w->fact->args[j] < 0 ) ? + linst_table[DECODE_VAR( w->fact->args[j] )] : w->fact->args[j]; + if ( h < 0 ) { + ok = FALSE; + res->fact->args[j] = w->fact->args[j]; + } else { + res->fact->args[j] = h; + } + } + if ( !ok ) {/* contains ef params */ + break; + } + if ( !full_possibly_negative( res->fact ) ) { + free( res->fact ); + res->fact = NULL; + res->connective = TRU; + break; + } + if ( !full_possibly_positive( res->fact ) ) { + free( res->fact ); + res->fact = NULL; + res->connective = FAL; + break; + } + break; + case COMP: + res = new_WffNode( COMP ); + res->comp = w->comp; + res->lh = copy_Exp( w->lh ); + res->rh = copy_Exp( w->rh ); + instantiate_exp( &(res->lh) ); + instantiate_exp( &(res->rh) ); + if ( res->lh->connective != NUMBER || + res->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( res->comp, res->lh->value, res->rh->value ); + if ( ct ) { + res->connective = TRU; + free_ExpNode( res->lh ); + res->lh = NULL; + free_ExpNode( res->rh ); + res->rh = NULL; + res->comp = -1; + } else { + res->connective = FAL; + free_ExpNode( res->lh ); + res->lh = NULL; + free_ExpNode( res->rh ); + res->rh = NULL; + res->comp = -1; + } + break; + case TRU: + case FAL: + res = new_WffNode( w->connective ); + break; + default: + printf("\n\nillegal connective %d in instantiate formula\n\n", + w->connective); + exit( 1 ); + } + + return res; + +} + + + +void instantiate_exp( ExpNode **n ) + +{ + + int j, f, k, h; + Bool ok; + + switch ( (*n)->connective ) { + case AD: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + instantiate_exp( &((*n)->son) ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + f = (*n)->fluent->function; + ok = TRUE; + for ( j = 0; j < gf_arity[f]; j++ ) { + h = ( (*n)->fluent->args[j] < 0 ) ? + linst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; + if ( h < 0 ) { + ok = FALSE; + } else { + (*n)->fluent->args[j] = h; + } + } + if ( !ok ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\ninst exp: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +Bool full_possibly_positive( Fact *f ) + +{ + + int adr; + + if ( gis_added[f->predicate] ) { + return TRUE; + } + + adr = instantiated_fact_adress( f ); + + if ( lini[f->predicate][adr] > 0 ) { + return TRUE; + } else { + return FALSE; + } + +} + + + +Bool full_possibly_negative( Fact *f ) + +{ + + int adr; + + if ( gis_deleted[f->predicate] ) { + return TRUE; + } + + adr = instantiated_fact_adress( f ); + + if ( lini[f->predicate][adr] > 0 ) { + return FALSE; + } else { + return TRUE; + } + +} + + + +int instantiated_fact_adress( Fact *f ) + +{ + + int r = 0, b = 1, i; + + for ( i = 0; i < garity[f->predicate]; i++ ) { + r += b * f->args[i]; + b *= gnum_constants; + } + + return r; + +} + + + + + + + + + + + + + + +/********************************************************* + * CODE THAT MULTIPLIES EFFECT PARAMS --> PSEUDO ACTIONS * + *********************************************************/ + + + + + + + + + + + + + + + +void multiply_hard_effect_parameters( void ) + +{ + + MixedOperator *o; + PseudoAction *tmp; + int i; + Effect *e; + + ghard_templates = ( PseudoAction_pointer * ) + calloc( gnum_hard_mixed_operators, sizeof ( PseudoAction_pointer ) ); + gnum_hard_templates = 0; + + for ( o = ghard_mixed_operators; o; o = o->next ) { + tmp = new_PseudoAction( o ); + + for ( i = 0; i < tmp->operator->num_vars; i++ ) { + linst_table[i] = tmp->inst_table[i]; + } + + for ( e = o->effects; e; e = e->next ) { + create_hard_pseudo_effects( tmp, e, 0 ); + } + + ghard_templates[gnum_hard_templates++] = tmp; + } +} + + + +void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ) + +{ + + int par, t, i, m, mn; + WffNode *tmp1, *w, *ww; + PseudoActionEffect *tmp2; + + if ( curr_var < e->num_vars ) { + par = a->operator->num_vars + curr_var; + + t = e->var_types[curr_var]; + for ( i = 0; i < gtype_size[t]; i++ ) { + linst_table[par] = gtype_consts[t][i]; + + create_hard_pseudo_effects( a, e, curr_var + 1 ); + + linst_table[par] = -1; + } + return; + } + + tmp1 = instantiate_wff( e->conditions ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + dnf( &tmp1 ); + cleanup_wff( &tmp1 ); + + /* only debugging, REMOVE LATER + */ + if ( is_dnf( tmp1 ) == -1 ) { + printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", a->operator->name); + print_Wff( tmp1, 0 ); + exit( 1 ); + } + + switch ( tmp1->connective ) { + case OR: + for ( w = tmp1->sons; w; w = w->next ) { + tmp2 = new_PseudoActionEffect(); + if ( w->connective == AND ) { + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_conditions = m; + tmp2->num_numeric_conditions = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp2->conditions[m].predicate = ww->fact->predicate; + for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { + tmp2->conditions[m].args[i] = ww->fact->args[i]; + } + m++; + } + if ( ww->connective == COMP ) { + tmp2->numeric_conditions_comp[mn] = ww->comp; + tmp2->numeric_conditions_lh[mn] = copy_Exp( ww->lh ); + tmp2->numeric_conditions_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_conditions = 1; + tmp2->conditions[0].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->conditions[0].args[i] = w->fact->args[i]; + } + } + if ( w->connective == COMP ) { + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_comp[0] = w->comp; + tmp2->numeric_conditions_lh[0] = copy_Exp( w->lh ); + tmp2->numeric_conditions_rh[0] = copy_Exp( w->rh ); + tmp2->num_numeric_conditions = 1; + } + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + } + break; + case AND: + tmp2 = new_PseudoActionEffect(); + m = 0; + mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_conditions = m; + tmp2->num_numeric_conditions = mn; + m = 0; mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + tmp2->conditions[m].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->conditions[m].args[i] = w->fact->args[i]; + } + m++; + } + if ( w->connective == COMP ) { + tmp2->numeric_conditions_comp[mn] = w->comp; + tmp2->numeric_conditions_lh[mn] = copy_Exp( w->lh ); + tmp2->numeric_conditions_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case ATOM: + tmp2 = new_PseudoActionEffect(); + tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_conditions = 1; + tmp2->conditions[0].predicate = tmp1->fact->predicate; + for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { + tmp2->conditions[0].args[i] = tmp1->fact->args[i]; + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case COMP: + tmp2 = new_PseudoActionEffect(); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_comp[0] = tmp1->comp; + tmp2->numeric_conditions_lh[0] = copy_Exp( tmp1->lh ); + tmp2->numeric_conditions_rh[0] = copy_Exp( tmp1->rh ); + tmp2->num_numeric_conditions = 1; + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case TRU: + tmp2 = new_PseudoActionEffect(); + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + default: + printf("\n\nillegal connective %d in parsing DNF condition.\n\n", + tmp1->connective); + exit( 1 ); + } + + free_WffNode( tmp1 ); + +} + + + +void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ) + +{ + + int ma = 0, md = 0, i; + Literal *l; + + for ( l = ll; l; l = l->next ) { + if ( l->negated ) { + md++; + } else { + ma++; + } + } + + e->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + e->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + + for ( l = ll; l; l = l->next ) { + if ( l->negated ) { + e->dels[e->num_dels].predicate = l->fact.predicate; + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + e->dels[e->num_dels].args[i] = ( l->fact.args[i] < 0 ) ? + linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; + } + e->num_dels++; + } else { + e->adds[e->num_adds].predicate = l->fact.predicate; + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + e->adds[e->num_adds].args[i] = ( l->fact.args[i] < 0 ) ? + linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; + } + e->num_adds++; + } + } + +} + + + +void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ) + +{ + + int m = 0, i; + NumericEffect *n; + + for ( n = ne; n; n = n->next ) m++; + + e->numeric_effects_neft = ( NumericEffectType * ) calloc( m, sizeof( NumericEffectType ) ); + e->numeric_effects_fluent = ( Fluent * ) calloc( m, sizeof( Fluent ) ); + e->numeric_effects_rh = ( ExpNode_pointer * ) calloc( m, sizeof( ExpNode_pointer ) ); + e->num_numeric_effects = m; + + m = 0; + for ( n = ne; n; n = n->next ) { + e->numeric_effects_neft[m] = n->neft; + e->numeric_effects_fluent[m].function = n->fluent.function; + for ( i = 0; i < gf_arity[n->fluent.function]; i++ ) { + e->numeric_effects_fluent[m].args[i] = ( n->fluent.args[i] < 0 ) ? + linst_table[DECODE_VAR( n->fluent.args[i] )] : n->fluent.args[i]; + } + e->numeric_effects_rh[m] = copy_Exp( n->rh ); + instantiate_exp( &(e->numeric_effects_rh[m]) ); + m++; + } + +} diff --git a/models/main_models/rt1/gen/ff_planner/inst_hard.h b/models/main_models/rt1/gen/ff_planner/inst_hard.h new file mode 100644 index 000000000..babebc20e --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_hard.h @@ -0,0 +1,71 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: inst_hard.h + * Description: headers for multiplying hard operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + +#ifndef _INST_HARD_H +#define _INST_HARD_H + + + +void build_hard_action_templates( void ); + + + +void cleanup_hard_domain( void ); +Bool var_used_in_literals( int code_var, Literal *ef ); +Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ); +void decrement_inferior_vars_in_literals( int var, Literal *ef ); +void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ); + + + +void multiply_hard_op_parameters( void ); +void create_hard_mixed_operators( Operator *o, int curr_var ); +Effect *instantiate_Effect( Effect *e ); +WffNode *instantiate_wff( WffNode *w ); +void instantiate_exp( ExpNode **n ); +Bool full_possibly_positive( Fact *f ); +Bool full_possibly_negative( Fact *f ); +int instantiated_fact_adress( Fact *f ); + + + +void multiply_hard_effect_parameters( void ); +void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ); +void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ); +void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ); + + + +#endif /* _INST_HARD_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_pre.c b/models/main_models/rt1/gen/ff_planner/inst_pre.c new file mode 100644 index 000000000..3e6877200 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_pre.c @@ -0,0 +1,3854 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_pre.c + * Description: functions for instantiating operators, preprocessing part. + * - transform domain into integers + * - inertia preprocessing: + * - collect inertia info + * - split initial state in special arrays + * - Wff normalization: + * - simplification + * - quantifier expansion + * - NOT s down + * - negative preconditions translation + * - split operators into easy and hard to instantiate + * + * - full DNF functions, only feasible for fully instantiated + * formulae + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" + + + + + + + + + + + + + + + + + + +/******************************************************* + * TRANSFORM DOMAIN INTO INTEGER (FACT) REPRESENTATION * + *******************************************************/ + + + + + + + + + +char *lvar_names[MAX_VARS]; +int lvar_types[MAX_VARS]; + + + + + + + + + + +void encode_domain_in_integers( void ) + +{ + + int i,j; + + collect_all_strings(); + create_member_nrs(); + + if ( gcmd_line.display_info == 103 ) { + printf("\nconstant table:"); + for ( i = 0; i < gnum_constants; i++ ) { + printf("\n%d --> %s", i, gconstants[i]); + } + + printf("\n\ntypes table:"); + for ( i = 0; i < gnum_types; i++ ) { + printf("\n%d --> %s: ", i, gtype_names[i]); + for ( j = 0; j < gtype_size[i]; j++ ) { + printf("%d ", gtype_consts[i][j]); + } + } + + printf("\n\npredicates table:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n%3d --> %s: ", i, gpredicates[i]); + for ( j = 0; j < garity[i]; j++ ) { + printf("%s ", gtype_names[gpredicates_args_type[i][j]]); + } + } + + printf("\n\nfunctions table:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n%3d --> %s: ", i, gfunctions[i]); + for ( j = 0; j < gf_arity[i]; j++ ) { + printf("%s ", gtype_names[gfunctions_args_type[i][j]]); + } + } + printf("\n\n"); + } + + create_integer_representation(); + + if ( gcmd_line.display_info == 104 ) { + printf("\n\nfirst step initial state is:"); + for ( i = 0; i < gnum_full_initial; i++ ) { + printf("\n"); + print_Fact( &(gfull_initial[i]) ); + } + printf("\n\nfirst step fluent initial state is:"); + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + printf("\n"); + print_Fluent( &(gfull_fluents_initial[i].fluent) ); + printf(": %f", gfull_fluents_initial[i].value); + } + + printf("\n\nfirst step operators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\n\nfirst step goal is:\n"); + print_Wff( ggoal, 0 ); + fflush( stdout ); + + printf("\n\nfirst step metric is: (normalized to minimize)\n"); + print_ExpNode( gmetric ); + fflush( stdout ); + } + +} + + + +void create_member_nrs( void ) + +{ + + int i, j, num; + + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + for ( j = 0; j < MAX_TYPES; j++ ) { + gmember_nr[i][j] = -1; + } + } + + for ( i = 0; i < gnum_types; i++ ) { + num = 0; + for ( j = 0; j < gtype_size[i]; j++ ) { + gmember_nr[gtype_consts[i][j]][i] = num; + num++; + } + } + +} + + + +void collect_all_strings( void ) + +{ + + FactList *f; + TokenList *t; + int p_num, type_num, c_num, ar; + int i; + + /* first are types and their objects. for = we make sure that there + * is one type that contains all objects. + */ + gtype_names[0] = new_Token( 50 ); + gtype_names[0] = "ARTFICIAL-ALL-OBJECTS"; + gtype_size[0] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][0] = FALSE; + } + gnum_types = 1; + + for ( f = gorig_constant_list; f; f = f->next ) { + if ( (type_num = position_in_types_table( f->item->next->item )) == -1 ) { + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_names[gnum_types] = new_Token( strlen( f->item->next->item ) + 1 ); + strcpy( gtype_names[gnum_types], f->item->next->item ); + gtype_size[gnum_types] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][gnum_types] = FALSE; + } + type_num = gnum_types++; + } + + if ( (c_num = position_in_constants_table( f->item->item )) == -1 ) { + if ( gnum_constants == MAX_CONSTANTS ) { + printf("\ntoo many constants! increase MAX_CONSTANTS (currently %d)\n\n", + MAX_CONSTANTS); + exit( 1 ); + } + gconstants[gnum_constants] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gconstants[gnum_constants], f->item->item ); + c_num = gnum_constants++; + + /* all constants into 0-type. + */ + if ( gtype_size[0] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[0], MAX_TYPE); + exit( 1 ); + } + gtype_consts[0][gtype_size[0]++] = c_num; + gis_member[c_num][0] = TRUE; + } + + if ( !gis_member[c_num][type_num] ) { + if ( gtype_size[type_num] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[type_num], MAX_TYPE); + exit( 1 ); + } + gtype_consts[type_num][gtype_size[type_num]++] = c_num; + gis_member[c_num][type_num] = TRUE; + } + } + + /* next are predicates; first of all, create in-built predicate = + */ + gpredicates[0] = new_Token( 5 ); + gpredicates[0] = "="; + gpredicates_args_type[0][0] = 0;/* all objects type */ + gpredicates_args_type[0][1] = 0; + garity[0] = 2; + gnum_predicates = 1; + + for ( f = gpredicates_and_types; f; f = f->next ) { + if ( (p_num = position_in_predicates_table( f->item->item )) != -1 ) { + printf("\npredicate %s declared twice!\n\n", f->item->item); + exit( 1 ); + } + if ( gnum_predicates == MAX_PREDICATES ) { + printf("\ntoo many predicates! increase MAX_PREDICATES (currently %d)\n\n", + MAX_PREDICATES); + exit( 1 ); + } + gpredicates[gnum_predicates] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gpredicates[gnum_predicates], f->item->item ); + ar = 0; + for ( t = f->item->next; t; t = t->next ) { + if ( (type_num = position_in_types_table( t->item )) == -1 ) { + printf("\npredicate %s is declared to use unknown or empty type %s\n\n", + f->item->item, t->item); + exit( 1 ); + } + if ( ar == MAX_ARITY ) { + printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", + gpredicates[gnum_predicates], MAX_ARITY); + exit( 1 ); + } + gpredicates_args_type[gnum_predicates][ar++] = type_num; + } + garity[gnum_predicates] = ar; + gaxiom_added[gnum_predicates] = FALSE; + gnum_predicates++; + } + + + /* next are functions; first of all, create in-built function total-time + * for sole use in metric + */ + gfunctions[0] = new_Token( 20 ); + gfunctions[0] = "TOTAL-TIME"; + gf_arity[0] = 0; + gnum_functions = 1; + + for ( f = gfunctions_and_types; f; f = f->next ) { + if ( (p_num = position_in_functions_table( f->item->item )) != -1 ) { + printf("\nfunction %s declared twice!\n\n", f->item->item); + exit( 1 ); + } + if ( gnum_functions == MAX_FUNCTIONS ) { + printf("\ntoo many functions! increase MAX_FUNCTIONS (currently %d)\n\n", + MAX_FUNCTIONS); + exit( 1 ); + } + gfunctions[gnum_functions] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gfunctions[gnum_functions], f->item->item ); + ar = 0; + for ( t = f->item->next; t; t = t->next ) { + if ( (type_num = position_in_types_table( t->item )) == -1 ) { + printf("\nfunction %s is declared to use unknown or empty type %s\n\n", + f->item->item, t->item); + exit( 1 ); + } + if ( ar == MAX_ARITY ) { + printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", + gfunctions[gnum_functions], MAX_ARITY); + exit( 1 ); + } + gfunctions_args_type[gnum_functions][ar++] = type_num; + } + gf_arity[gnum_functions++] = ar; + } + + free_FactList( gorig_constant_list ); + free_FactList( gpredicates_and_types ); + free_FactList( gfunctions_and_types ); + +} + + + +int position_in_types_table( char *str ) + +{ + + int i; + + /* start at 1 because 0 is our artificial one + */ + for ( i = 1; i < gnum_types; i++ ) { + if ( str == gtype_names[i] || + (strcmp( str, gtype_names[i] ) == SAME) ) { + break; + } + } + + return ( i == gnum_types ) ? -1 : i; + +} + + + +int position_in_constants_table( char *str ) + +{ + + int i; + + for ( i=0; isons; n; n = n->next ) sum++; + sum += gnum_constants;/* space for equalities */ + gfull_initial = ( Fact * ) calloc( sum, sizeof( Fact ) ); + gfull_fluents_initial = ( FluentValue * ) + calloc( sum, sizeof( FluentValue )); + + for ( n = gorig_initial_facts->sons; n; n = n->next ) { + if ( n->connective == ATOM ) { + make_Fact( &(gfull_initial[gnum_full_initial]), n, 0 ); + if ( gfull_initial[gnum_full_initial].predicate == 0 ) { + printf("\nequality in initial state! check input files.\n\n"); + exit( 1 ); + } + + /* duplicate check!! + */ + for ( i = 0; i < gnum_full_initial; i++ ) { + if ( gfull_initial[i].predicate != gfull_initial[gnum_full_initial].predicate ) { + /* predicate different --> this ini fact is not a duplicate! + */ + continue; + } + for ( j = 0; j < garity[gfull_initial[i].predicate]; j++ ) { + if ( gfull_initial[i].args[j] != gfull_initial[gnum_full_initial].args[j] ) { + /* arg different --> this ini fact is not a duplicate! + */ + break; + } + } + if ( j == garity[gfull_initial[i].predicate] ) { + /* found a duplicate! + */ + break; + } + } + if ( i < gnum_full_initial ) { + /* simply skip the second occurence... + */ + continue; + } + + gnum_full_initial++; + } else { + /* a fluent value assignment + */ + make_Fluent( &(gfull_fluents_initial[gnum_full_fluents_initial].fluent), + n->lh->atom, 0 ); + gfull_fluents_initial[gnum_full_fluents_initial].value = + ( float ) strtod( n->rh->atom->item, NULL); + gnum_full_fluents_initial++; + } + } + free_PlNode( gorig_initial_facts ); + } + + /* now insert all our artificial equality constraints into initial state. + */ + for ( i = 0; i < gnum_constants; i++ ) { + gfull_initial[gnum_full_initial].predicate = 0; + gfull_initial[gnum_full_initial].args[0] = i; + gfull_initial[gnum_full_initial].args[1] = i; + gnum_full_initial++; + } + /* FINITO. the rest of equality handling will fully + * automatically be done by the rest of the machinery. + */ + + ggoal = make_Wff( gorig_goal_facts, 0 ); + + if ( gparse_metric != NULL ) { + /* no need to throw costs away, even if we're not explicitly asked to + * minimize them + */ + if ( 0 && !gcost_minimizing ) { + if ( gcmd_line.display_info ) { + printf("\n\nno optimization required. skipping criterion.\n\n"); + } + } else { + gmetric = make_ExpNode( gparse_metric, 0 ); + if ( strcmp( gparse_optimization, "MINIMIZE" ) != SAME && + strcmp( gparse_optimization, "minimize" ) != SAME && + strcmp( gparse_optimization, "MAXIMIZE" ) != SAME && + strcmp( gparse_optimization, "maximize" ) != SAME ) { + if ( gcmd_line.display_info ) { + printf("\n\nunknown optimization method %s. check input files\n\n", + gparse_optimization); + } + exit( 1 ); + } + if ( strcmp( gparse_optimization, "MAXIMIZE" ) == SAME || + strcmp( gparse_optimization, "maximize" ) == SAME ) { + t = new_ExpNode( MINUS ); + t->son = gmetric; + gmetric = t; + } + } + } + + for ( o = gloaded_ops; o; o = o->next ) { + tmp = new_Operator( o->name, o->number_of_real_params ); + tmp->axiom = o->axiom; + + for ( ff = o->params; ff; ff = ff->next ) { + if ( (type_num = position_in_types_table( ff->item->next->item )) == -1 ) { + printf("\nwarning: parameter %s of op %s has unknown or empty type %s. skipping op", + ff->item->item, o->name, ff->item->next->item); + break; + } + if ( tmp->num_vars == MAX_VARS ) { + printf("\ntoo many parameters! increase MAX_VARS (currently %d)\n\n", + MAX_VARS); + exit( 1 ); + } + for ( i = 0; i < tmp->num_vars; i++ ) { + if ( tmp->var_names[i] == ff->item->item || + strcmp( tmp->var_names[i], ff->item->item ) == SAME ) { + printf("\nwarning: operator %s parameter %s overwrites previous declaration\n\n", + tmp->name, ff->item->item); + } + } + tmp->var_names[tmp->num_vars] = new_Token( strlen( ff->item->item ) + 1 ); + strcpy( tmp->var_names[tmp->num_vars], ff->item->item ); + tmp->var_types[tmp->num_vars++] = type_num; + } + if ( ff ) { + free_Operator( tmp ); + continue; + } + + for ( i = 0; i < tmp->num_vars; i++ ) { + lvar_types[i] = tmp->var_types[i]; + lvar_names[i] = tmp->var_names[i]; + } + + tmp->preconds = make_Wff( o->preconds, tmp->num_vars ); + + if ( o->effects ) { + /* in make_effect, make sure that no one afects equality. + */ + nn = o->effects->sons; + while ( nn && + (tmp->effects = make_effect( nn, tmp->num_vars )) == NULL ) { + nn = nn->next; + } + if ( nn ) { + for ( n = nn->next; n; n = n->next ) { + if ( (tmp->effects->prev = make_effect( n, tmp->num_vars )) == NULL ) { + continue; + } + tmp->effects->prev->next = tmp->effects; + tmp->effects = tmp->effects->prev; + } + } + } + + if ( gnum_operators == MAX_OPERATORS ) { + printf("\ntoo many operators! increase MAX_OPERATORS (currently %d)\n\n", + MAX_OPERATORS); + exit( 1 ); + } + goperators[gnum_operators++] = tmp; + } + + if ( 0 ) { + /* currently not in use; leads to free memory reads and + * free memory frees (no memory leaks), which are hard to explain. + * + * almost no memory consumption anyway. + */ + free_PlOperator( gloaded_ops ); + } + + /* establish gaxiom_added markers. + * ascertain that derived predicates do not appear in effects!! + */ + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( goperators[i]->axiom ) { + gaxiom_added[l->fact.predicate] = TRUE; + } + } + } + } + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( !goperators[i]->axiom && + gaxiom_added[l->fact.predicate] ) { + printf("\nA derived predicate appears in an operator effect."); + printf("\nSorry, this is not allowed. Bailing out.\n\n"); + exit( 1 ); + } + } + } + } + +} + + + +void make_Fact( Fact *f, PlNode *n, int num_vars ) + +{ + + int m, i; + TokenList *t; + + if ( !n->atom ) { + /* can't happen after previous syntax check. Oh well, whatever... + */ + printf("\nillegal (empty) atom used in domain. check input files\n\n"); + exit( 1 ); + } + + f->predicate = position_in_predicates_table( n->atom->item ); + if ( f->predicate == -1 ) { + printf("\nundeclared predicate %s used in domain definition\n\n", + n->atom->item); + exit( 1 ); + } + + m = 0; + for ( t = n->atom->next; t; t = t->next ) { + if ( t->item[0] == '?' ) { + for ( i=num_vars-1; i>-1; i-- ) { + /* downwards, to always get most recent declaration/quantification + * of that variable + */ + if ( lvar_names[i] == t->item || + strcmp( lvar_names[i], t->item ) == SAME ) { + break; + } + } + if ( i == -1 ) { + printf("\nundeclared variable %s in literal %s. check input files\n\n", + t->item, n->atom->item); + exit( 1 ); + } + if ( lvar_types[i] != gpredicates_args_type[f->predicate][m] && + !is_subtype( lvar_types[i], gpredicates_args_type[f->predicate][m] ) ) { + printf("\ntype of var %s does not match type of arg %d of predicate %s\n\n", + lvar_names[i], m, gpredicates[f->predicate]); + exit( 1 ); + } + f->args[m] = ENCODE_VAR( i ); + } else { + if ( (f->args[m] = + position_in_constants_table( t->item )) == -1 ) { + printf("\nunknown constant %s in literal %s. check input files\n\n", + t->item, n->atom->item); + exit( 1 ); + } + if ( !gis_member[f->args[m]][gpredicates_args_type[f->predicate][m]] ) { + printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", + gconstants[f->args[m]], m, gpredicates[f->predicate]); + exit( 1 ); + } + } + m++; + } + if ( m != garity[f->predicate] ) { + printf("\npredicate %s is declared to have %d (not %d) arguments. check input files\n\n", + gpredicates[f->predicate], + garity[f->predicate], m); + exit( 1 ); + } + +} + + + +void make_Fluent( Fluent *f, TokenList *atom, int num_vars ) + +{ + + int m, i; + TokenList *t; + + if ( !atom ) { + /* can't happen after previous syntax check. Oh well, whatever... + */ + printf("\nillegal (empty) atom used in domain. check input files\n\n"); + exit( 1 ); + } + + f->function = position_in_functions_table( atom->item ); + if ( f->function == -1 ) { + printf("\nundeclared function %s used in domain definition\n\n", + atom->item); + exit( 1 ); + } + + m = 0; + for ( t = atom->next; t; t = t->next ) { + if ( t->item[0] == '?' ) { + for ( i=num_vars-1; i>-1; i-- ) { + /* downwards, to always get most recent declaration/quantification + * of that variable + */ + if ( lvar_names[i] == t->item || + strcmp( lvar_names[i], t->item ) == SAME ) { + break; + } + } + if ( i == -1 ) { + printf("\nundeclared variable %s in function %s. check input files\n\n", + t->item, atom->item); + exit( 1 ); + } + if ( lvar_types[i] != gfunctions_args_type[f->function][m] && + !is_subtype( lvar_types[i], gfunctions_args_type[f->function][m] ) ) { + printf("\ntype of var %s does not match type of arg %d of function %s\n\n", + lvar_names[i], m, gfunctions[f->function]); + exit( 1 ); + } + f->args[m] = ENCODE_VAR( i ); + } else { + if ( (f->args[m] = + position_in_constants_table( t->item )) == -1 ) { + printf("\nunknown constant %s in function %s. check input files\n\n", + t->item, atom->item); + exit( 1 ); + } + if ( !gis_member[f->args[m]][gfunctions_args_type[f->function][m]] ) { + printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", + gconstants[f->args[m]], m, gfunctions[f->function]); + exit( 1 ); + } + } + m++; + } + + if ( m != gf_arity[f->function] ) { + printf("\nfunction %s is declared to have %d (not %d) arguments. check input files\n\n", + gfunctions[f->function], + gf_arity[f->function], m); + exit( 1 ); + } + +} + + + +Bool is_subtype( int t1, int t2 ) + +{ + + int i; + + for ( i = 0; i < gtype_size[t1]; i++ ) { + if ( !gis_member[gtype_consts[t1][i]][t2] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +WffNode *make_Wff( PlNode *p, int num_vars ) + +{ + + WffNode *tmp; + int i, t; + PlNode *n; + + if ( !p ) { + tmp = NULL; + return tmp; + } + + tmp = new_WffNode( p->connective ); + switch ( p->connective ) { + case ALL: + case EX: + for ( i = 0; i < num_vars; i++ ) { + if ( lvar_names[i] == p->atom->item || + strcmp( lvar_names[i], p->atom->item ) == SAME ) { + printf("\nwarning: var quantification of %s overwrites previous declaration\n\n", + p->atom->item); + } + } + if ( (t = position_in_types_table( p->atom->next->item )) == -1 ) { + printf("\nwarning: quantified var %s has unknown or empty type %s. simplifying.\n\n", + p->atom->item, p->atom->next->item); + tmp->connective = ( p->connective == EX ) ? FAL : TRU; + break; + } + tmp->var = num_vars; + tmp->var_type = t; + tmp->var_name = new_Token( strlen( p->atom->item ) + 1 ); + strcpy( tmp->var_name, p->atom->item ); + lvar_names[num_vars] = p->atom->item; + lvar_types[num_vars] = t; + tmp->son = make_Wff( p->sons, num_vars + 1 ); + break; + case AND: + case OR: + if ( !p->sons ) { + printf("\nwarning: empty con/disjunction in domain definition. simplifying.\n\n"); + tmp->connective = ( p->connective == OR ) ? FAL : TRU; + break; + } + tmp->sons = make_Wff( p->sons, num_vars ); + for ( n = p->sons->next; n; n = n->next ) { + tmp->sons->prev = make_Wff( n, num_vars ); + tmp->sons->prev->next = tmp->sons; + tmp->sons = tmp->sons->prev; + } + break; + case NOT: + tmp->son = make_Wff( p->sons, num_vars ); + break; + case ATOM: + tmp->fact = new_Fact(); + make_Fact( tmp->fact, p, num_vars ); + break; + case TRU: + case FAL: + break; + case COMP: + tmp->comp = p->comp; + tmp->lh = make_ExpNode( p->lh, num_vars ); + tmp->rh = make_ExpNode( p->rh, num_vars ); + break; + default: + printf("\nforbidden connective %d in Pl Wff. must be a bug somewhere...\n\n", + p->connective); + exit( 1 ); + } + + return tmp; + +} + + + +ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ) + +{ + + ExpNode *tmp; + + if ( !p ) { + tmp = NULL; + return tmp; + } + + tmp = new_ExpNode( p->connective ); + switch ( p->connective ) { + case AD: + case SU: + case MU: + case DI: + tmp->leftson = make_ExpNode( p->leftson, num_vars ); + tmp->rightson = make_ExpNode( p->rightson, num_vars ); + break; + case MINUS: + tmp->son = make_ExpNode( p->leftson, num_vars ); + break; + case NUMBER: + tmp->value = ( float ) strtod( p->atom->item, NULL ); + break; + case FHEAD: + tmp->fluent = new_Fluent(); + make_Fluent( tmp->fluent, p->atom, num_vars ); + break; + default: + printf("\n\nmake expnode: wrong specifier %d", + p->connective); + exit( 1 ); + } + + return tmp; + +} + + + +Effect *make_effect( PlNode *p, int num_vars ) + +{ + + Effect *tmp = new_Effect(); + PlNode *n, *m; + int t, i; + + for ( n = p; n && n->connective == ALL; n = n->sons ) { + if ( (t = position_in_types_table( n->atom->next->item )) == -1 ) { + printf("\nwarning: effect parameter %s has unknown or empty type %s. skipping effect.\n\n", + n->atom->item, n->atom->next->item); + return NULL; + } + for ( i = 0; i < num_vars + tmp->num_vars; i++ ) { + if ( lvar_names[i] == n->atom->item || + strcmp( lvar_names[i], n->atom->item ) == SAME ) { + printf("\nwarning: effect parameter %s overwrites previous declaration\n\n", + n->atom->item); + } + } + lvar_types[num_vars + tmp->num_vars] = t; + lvar_names[num_vars + tmp->num_vars] = n->atom->item; + tmp->var_names[tmp->num_vars] = new_Token( strlen( n->atom->item ) + 1 ); + strcpy( tmp->var_names[tmp->num_vars], n->atom->item ); + tmp->var_types[tmp->num_vars++] = t; + } + + if ( !n || n->connective != WHEN ) { + printf("\nnon WHEN %d at end of effect parameters. debug me\n\n", + n->connective); + exit( 1 ); + } + + tmp->conditions = make_Wff( n->sons, num_vars + tmp->num_vars ); + + if ( n->sons->next->connective != AND ) { + printf("\nnon AND %d in front of literal effect list. debug me\n\n", + n->sons->next->connective); + exit( 1 ); + } + if ( !n->sons->next->sons ) { + return tmp; + } + for ( m = n->sons->next->sons; m; m = m->next ) { + if ( m->connective == NEF ) { + if ( tmp->numeric_effects != NULL ) { + tmp->numeric_effects->prev = new_NumericEffect(); + make_Fluent( &(tmp->numeric_effects->prev->fluent), + m->lh->atom, num_vars + tmp->num_vars ); + tmp->numeric_effects->prev->neft = m->neft; + tmp->numeric_effects->prev->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); + + tmp->numeric_effects->prev->next = tmp->numeric_effects; + tmp->numeric_effects = tmp->numeric_effects->prev; + } else { + tmp->numeric_effects = new_NumericEffect(); + make_Fluent( &(tmp->numeric_effects->fluent), + m->lh->atom, num_vars + tmp->num_vars ); + tmp->numeric_effects->neft = m->neft; + tmp->numeric_effects->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); + } + } else { + if ( tmp->effects != NULL ) { + tmp->effects->prev = new_Literal(); + if ( m->connective == NOT ) { + tmp->effects->prev->negated = TRUE; + make_Fact( &(tmp->effects->prev->fact), m->sons, num_vars + tmp->num_vars ); + if ( (tmp->effects->prev->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } else { + tmp->effects->prev->negated = FALSE; + make_Fact( &(tmp->effects->prev->fact), m, num_vars + tmp->num_vars ); + if ( (tmp->effects->prev->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } + tmp->effects->prev->next = tmp->effects; + tmp->effects = tmp->effects->prev; + } else { + tmp->effects = new_Literal(); + if ( m->connective == NOT ) { + tmp->effects->negated = TRUE; + make_Fact( &(tmp->effects->fact), m->sons, num_vars + tmp->num_vars ); + if ( (tmp->effects->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } else { + tmp->effects->negated = FALSE; + make_Fact( &(tmp->effects->fact), m, num_vars + tmp->num_vars ); + if ( (tmp->effects->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } + } + } + } + + return tmp; + +} + + + + + + + + + + + +/************************* + * INERTIA PREPROCESSING * + *************************/ + + + + + + + + + + + +void do_inertia_preprocessing_step_1( void ) + +{ + + int i, j; + Facts *f; + FluentValues *ff; + + collect_inertia_information(); + + if ( gcmd_line.display_info == 105 ) { + printf("\n\npredicates inertia info:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n%3d --> %s: ", i, gpredicates[i]); + printf(" is %s, %s", + gis_added[i] ? "ADDED" : "NOT ADDED", + gis_deleted[i] ? "DELETED" : "NOT DELETED"); + } + printf("\n\nfunctions inertia info:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n%3d --> %s: ", i, gfunctions[i]); + printf(" is %s", + gis_changed[i] ? "CHANGED" : "NOT CHANGED"); + } + printf("\n\n"); + } + + split_initial_state(); + + if ( gcmd_line.display_info == 106 ) { + printf("\n\nsplitted initial state is:"); + printf("\nindividual predicates:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n\n%s:", gpredicates[i]); + if ( !gis_added[i] && + !gis_deleted[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + printf("\n"); + print_Fact( &(ginitial_predicate[i][j]) ); + } + } + printf("\n\nnon static part:"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + + printf("\n\nextended types table:"); + for ( i = 0; i < gnum_types; i++ ) { + printf("\n%d --> ", i); + if ( gpredicate_to_type[i] == -1 ) { + printf("%s ", gtype_names[i]); + } else { + printf("UNARY INERTIA TYPE (%s) ", gpredicates[gpredicate_to_type[i]]); + } + for ( j = 0; j < gtype_size[i]; j++ ) { + printf("%d ", gtype_consts[i][j]); + } + } + + printf("\nindividual functions:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n\n%s:", gfunctions[i]); + if ( !gis_changed[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_function[i]; j++ ) { + printf("\n"); + print_Fluent( &(ginitial_function[i][j].fluent) ); + printf(": %f", ginitial_function[i][j].value); + } + } + printf("\n\nnon static part:"); + for ( ff = gf_initial; ff; ff = ff->next ) { + printf("\n"); + print_Fluent( &(ff->fluent) ); + printf(": %f", ff->value); + } + } + +} + + + +void collect_inertia_information( void ) + +{ + + int i; + Effect *e; + Literal *l; + NumericEffect *ne; + + for ( i = 0; i < gnum_predicates; i++ ) { + gis_added[i] = FALSE; + gis_deleted[i] = FALSE; + } + for ( i = 0; i < gnum_functions; i++ ) { + gis_changed[i] = FALSE; + } + + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + gis_deleted[l->fact.predicate] = TRUE; + } else { + gis_added[l->fact.predicate] = TRUE; + } + } + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + gis_changed[ne->fluent.function] = TRUE; + } + } + } + +} + + + +void split_initial_state( void ) + +{ + + int i, j, p, t; + Facts *tmp; + FluentValues *ftmp; + + for ( i = 0; i < MAX_PREDICATES; i++ ) { + gtype_to_predicate[i] = -1; + } + for ( i = 0; i < MAX_TYPES; i++ ) { + gpredicate_to_type[i] = -1; + } + + for ( i = 0; i < gnum_predicates; i++ ) { + if ( !gis_added[i] && + !gis_deleted[i] && + garity[i] == 1 ) { + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many (inferred) types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_to_predicate[i] = gnum_types; + gpredicate_to_type[gnum_types] = i; + gtype_names[gnum_types] = NULL; + gtype_size[gnum_types] = 0; + for ( j = 0; j < MAX_CONSTANTS; j++ ) { + gis_member[j][gnum_types] = FALSE; + } + gnum_types++; + } + } + + + /* double size of predicates table as each predicate might need + * to be translated to NOT-p + */ + ginitial_predicate = ( Fact ** ) calloc( gnum_predicates * 2, sizeof( Fact * ) ); + gnum_initial_predicate = ( int * ) calloc( gnum_predicates * 2, sizeof( int ) ); + for ( i = 0; i < gnum_predicates * 2; i++ ) { + gnum_initial_predicate[i] = 0; + } + for ( i = 0; i < gnum_full_initial; i++ ) { + p = gfull_initial[i].predicate; + gnum_initial_predicate[p]++; + } + for ( i = 0; i < gnum_predicates; i++ ) { + ginitial_predicate[i] = ( Fact * ) calloc( gnum_initial_predicate[i], sizeof( Fact ) ); + gnum_initial_predicate[i] = 0; + } + ginitial = NULL; + gnum_initial = 0; + + for ( i = 0; i < gnum_full_initial; i++ ) { + p = gfull_initial[i].predicate; + ginitial_predicate[p][gnum_initial_predicate[p]].predicate = p; + for ( j = 0; j < garity[p]; j++ ) { + ginitial_predicate[p][gnum_initial_predicate[p]].args[j] = gfull_initial[i].args[j]; + } + gnum_initial_predicate[p]++; + if ( gis_added[p] || + gis_deleted[p] ) { + tmp = new_Facts(); + tmp->fact->predicate = p; + for ( j = 0; j < garity[p]; j++ ) { + tmp->fact->args[j] = gfull_initial[i].args[j]; + } + tmp->next = ginitial; + ginitial = tmp; + gnum_initial++; + } else { + if ( garity[p] == 1 ) { + t = gtype_to_predicate[p]; + if ( gtype_size[t] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[t], MAX_TYPE); + exit( 1 ); + } + if ( !gis_member[gfull_initial[i].args[0]][gpredicates_args_type[p][0]] ) { + printf("\ntype mismatch in initial state! %s as arg 0 of %s\n\n", + gconstants[gfull_initial[i].args[0]], gpredicates[p]); + exit( 1 ); + } + gtype_consts[t][gtype_size[t]++] = gfull_initial[i].args[0]; + gis_member[gfull_initial[i].args[0]][t] = TRUE; + } + } + } + + ginitial_function = ( FluentValue ** ) + calloc( gnum_functions, sizeof( FluentValue * ) ); + gnum_initial_function = ( int * ) calloc( gnum_functions, sizeof( int ) ); + for ( i = 0; i < gnum_functions; i++ ) { + gnum_initial_function[i] = 0; + } + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + p = gfull_fluents_initial[i].fluent.function; + gnum_initial_function[p]++; + } + for ( i = 0; i < gnum_functions; i++ ) { + ginitial_function[i] = ( FluentValue * ) + calloc( gnum_initial_function[i], sizeof( FluentValue ) ); + gnum_initial_function[i] = 0; + } + gf_initial = NULL; + gnum_f_initial = 0; + + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + p = gfull_fluents_initial[i].fluent.function; + ginitial_function[p][gnum_initial_function[p]].fluent.function = p; + for ( j = 0; j < gf_arity[p]; j++ ) { + ginitial_function[p][gnum_initial_function[p]].fluent.args[j] = + gfull_fluents_initial[i].fluent.args[j]; + } + ginitial_function[p][gnum_initial_function[p]].value = + gfull_fluents_initial[i].value; + gnum_initial_function[p]++; + if ( gis_changed[p] ) { + ftmp = new_FluentValues(); + ftmp->fluent.function = p; + for ( j = 0; j < gf_arity[p]; j++ ) { + ftmp->fluent.args[j] = gfull_fluents_initial[i].fluent.args[j]; + } + ftmp->value = gfull_fluents_initial[i].value; + ftmp->next = gf_initial; + gf_initial = ftmp; + gnum_f_initial++; + } + } + +} + + + + + + + + + + + +/****************************** + * NORMALIZE ALL PL1 FORMULAE * + ******************************/ + + + + + + + + + + + + +void normalize_all_wffs( void ) + +{ + + int i; + Effect *e; + + simplify_wff( &ggoal ); + remove_unused_vars_in_wff( &ggoal ); + expand_quantifiers_in_wff( &ggoal, -1, -1 ); + NOTs_down_in_wff( &ggoal ); + cleanup_wff( &ggoal ); + + if ( ggoal->connective == TRU ) { + printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); + gnum_plan_ops = 0; + exit( 1 ); + } + if ( ggoal->connective == FAL ) { + printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); + exit( 1 ); + } + + /* put goal into DNF right away: fully instantiated already + */ + dnf( &ggoal ); + cleanup_wff( &ggoal ); + + /* all we can do here is simplify if that's possible. + */ + if ( gmetric != NULL ) { + simplify_exp( &gmetric ); + } + + + for ( i = 0; i < gnum_operators; i++ ) { + simplify_wff( &(goperators[i]->preconds) ); + remove_unused_vars_in_wff( &(goperators[i]->preconds) ); + expand_quantifiers_in_wff( &(goperators[i]->preconds), -1, -1 ); + NOTs_down_in_wff( &(goperators[i]->preconds) ); + cleanup_wff( &(goperators[i]->preconds) ); + + for ( e = goperators[i]->effects; e; e = e->next ) { + simplify_wff( &(e->conditions) ); + remove_unused_vars_in_wff( &(e->conditions) ); + expand_quantifiers_in_wff( &(e->conditions), -1, -1 ); + NOTs_down_in_wff( &(e->conditions) ); + cleanup_wff( &(e->conditions) ); + } + } + + if ( gcmd_line.display_info == 107 ) { + printf("\n\ndomain with normalized PL1 formula:"); + + printf("\n\noperators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\n\ngoal is:\n"); + print_Wff( ggoal, 0 ); + + if ( gmetric ) { + printf("\n\nmetric is (minimize):\n"); + print_ExpNode( gmetric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + } + +} + + + +void remove_unused_vars_in_wff( WffNode **w ) + +{ + + WffNode *tmp; + WffNode *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + remove_unused_vars_in_wff( &((*w)->son) ); + if ( !var_used_in_wff( ENCODE_VAR( (*w)->var ), (*w)->son ) ) { + decrement_inferior_vars((*w)->var, (*w)->son ); + (*w)->connective = (*w)->son->connective; + (*w)->var = (*w)->son->var; + (*w)->var_type = (*w)->son->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->son->var_name; + (*w)->sons = (*w)->son->sons; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->son->fact; + (*w)->comp = (*w)->son->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->son->lh; + (*w)->rh = (*w)->son->rh; + + tmp = (*w)->son; + (*w)->son = (*w)->son->son; + free( tmp ); + } + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + remove_unused_vars_in_wff( &i ); + } + break; + case NOT: + remove_unused_vars_in_wff( &((*w)->son) ); + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: remove var, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +Bool var_used_in_wff( int code_var, WffNode *w ) + +{ + + WffNode *i; + int j; + + switch ( w->connective ) { + case ALL: + case EX: + return var_used_in_wff( code_var, w->son ); + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + if ( var_used_in_wff( code_var, i ) ) { + return TRUE; + } + } + return FALSE; + case NOT: + return var_used_in_wff( code_var, w->son ); + case ATOM: + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + if ( w->fact->args[j] >= 0 ) { + continue; + } + if ( w->fact->args[j] == code_var ) { + return TRUE; + } + } + return FALSE; + case COMP: + if ( var_used_in_exp( code_var, w->lh ) ) { + return TRUE; + } + if ( var_used_in_exp( code_var, w->rh ) ) { + return TRUE; + } + return FALSE; + case TRU: + case FAL: + return FALSE; + default: + printf("\nwon't get here: var used ?, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + +} + + + +Bool var_used_in_exp( int code_var, ExpNode *n ) + +{ + + int i; + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + if ( var_used_in_exp( code_var, n->leftson ) || + var_used_in_exp( code_var, n->rightson ) ) { + return TRUE; + } + return FALSE; + case MINUS: + if ( var_used_in_exp( code_var, n->son ) ) { + return TRUE; + } + return FALSE; + case NUMBER: + return FALSE; + case FHEAD: + if ( n->fluent ) { + for ( i = 0; i < gf_arity[n->fluent->function]; i++ ) { + if ( n->fluent->args[i] >= 0 ) { + continue; + } + if ( n->fluent->args[i] == code_var ) { + return TRUE; + } + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + } + return FALSE; + default: + printf("\n\nvar used in expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + +void decrement_inferior_vars( int var, WffNode *w ) + +{ + + WffNode *i; + int j; + + switch ( w->connective ) { + case ALL: + case EX: + w->var--; + decrement_inferior_vars( var, w->son ); + break; + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + decrement_inferior_vars( var, i ); + } + break; + case NOT: + decrement_inferior_vars( var, w->son ); + break; + case ATOM: + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + if ( w->fact->args[j] >= 0 ) { + continue; + } + if ( DECODE_VAR( w->fact->args[j] ) > var ) { + w->fact->args[j]++; + } + } + break; + case COMP: + decrement_inferior_vars_in_exp( var, w->lh ); + decrement_inferior_vars_in_exp( var, w->rh ); + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: decrement, non logical %d\n\n", + w->connective); + exit( 1 ); + } + +} + + + +void decrement_inferior_vars_in_exp( int var, ExpNode *n ) + +{ + + int j; + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + decrement_inferior_vars_in_exp( var, n->leftson ); + decrement_inferior_vars_in_exp( var, n->rightson ); + break; + case MINUS: + decrement_inferior_vars_in_exp( var, n->son ); + break; + case NUMBER: + break; + case FHEAD: + if ( n->fluent ) { + for ( j = 0; j < gf_arity[n->fluent->function]; j++ ) { + if ( n->fluent->args[j] >= 0 ) { + continue; + } + if ( DECODE_VAR( n->fluent->args[j] ) > var ) { + n->fluent->args[j]++; + } + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + } + break; + default: + printf("\n\ndecr inf vars in expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + +void simplify_wff( WffNode **w ) + +{ + + WffNode *i, *tmp; + int m; + Bool ct; + + switch ( (*w)->connective ) { + case ALL: + case EX: + simplify_wff( &((*w)->son) ); + if ( (*w)->son->connective == TRU || + (*w)->son->connective == FAL ) { + (*w)->connective = (*w)->son->connective; + free( (*w)->son ); + (*w)->son = NULL; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + } + break; + case AND: + m = 0; + i = (*w)->sons; + while ( i ) { + simplify_wff( &i ); + if ( i->connective == FAL ) { + (*w)->connective = FAL; + /* free_WffNode( (*w)->sons ); */ + (*w)->sons = NULL; + return; + } + if ( i->connective == TRU ) { + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + if ( i->next ) { + i->next->prev = i->prev; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + m++; + } + if ( m == 0 ) { + (*w)->connective = TRU; + free_WffNode( (*w)->sons ); + (*w)->sons = NULL; + } + if ( m == 1 ) { + (*w)->connective = (*w)->sons->connective; + (*w)->var = (*w)->sons->var; + (*w)->var_type = (*w)->sons->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->sons->var_name; + (*w)->son = (*w)->sons->son; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->sons->fact; + (*w)->comp = (*w)->sons->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->sons->lh; + (*w)->rh = (*w)->sons->rh; + + tmp = (*w)->sons; + (*w)->sons = (*w)->sons->sons; + free( tmp ); + } + break; + case OR: + m = 0; + i = (*w)->sons; + while ( i ) { + simplify_wff( &i ); + if ( i->connective == TRU ) { + (*w)->connective = TRU; + free_WffNode( (*w)->sons ); + (*w)->sons = NULL; + return; + } + if ( i->connective == FAL ) { + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + if ( i->next ) { + i->next->prev = i->prev; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + m++; + } + if ( m == 0 ) { + (*w)->connective = FAL; + /* free_WffNode( (*w)->sons ); */ + (*w)->sons = NULL; + } + if ( m == 1 ) { + (*w)->connective = (*w)->sons->connective; + (*w)->var = (*w)->sons->var; + (*w)->var_type = (*w)->sons->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->sons->var_name; + (*w)->son = (*w)->sons->son; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->sons->fact; + (*w)->comp = (*w)->sons->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->sons->lh; + (*w)->rh = (*w)->sons->rh; + + tmp = (*w)->sons; + (*w)->sons = (*w)->sons->sons; + free( tmp ); + } + break; + case NOT: + simplify_wff( &((*w)->son) ); + if ( (*w)->son->connective == TRU || + (*w)->son->connective == FAL ) { + (*w)->connective = ( (*w)->son->connective == TRU ) ? FAL : TRU; + free( (*w)->son ); + (*w)->son = NULL; + } + break; + case ATOM: + if ( (*w)->visited ) { + /* already seen and not changed + */ + break; + } + if ( !possibly_negative( (*w)->fact ) ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !possibly_positive( (*w)->fact ) ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + (*w)->visited = TRUE; + break; + case COMP: + simplify_exp( &((*w)->lh) ); + simplify_exp( &((*w)->rh) ); + if ( (*w)->lh->connective != NUMBER || + (*w)->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); + if ( ct ) { + (*w)->connective = TRU; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } else { + (*w)->connective = FAL; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: simplify, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void simplify_exp( ExpNode **n ) + +{ + + int j, f, k; + + switch ( (*n)->connective ) { + case AD: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + simplify_exp( &((*n)->son) ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + if ( !(*n)->fluent ) { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + break; + } + f = (*n)->fluent->function; + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] < 0 ) { + break; + } + } + if ( j < gf_arity[f] ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\nsimplify expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +void expand_quantifiers_in_wff( WffNode **w, int var, int constant ) + +{ + + WffNode *r = NULL, *tmp, *i; + int j, l; + Bool change, ct; + + if ( !(*w) ) { + return; + } + + switch ( (*w)->connective ) { + case ALL: + case EX: + if ( var != -1 ) {/* depth first: upper node is active */ + expand_quantifiers_in_wff( &((*w)->son), var, constant ); + return; + } + + (*w)->connective = ( (*w)->connective == ALL ) ? AND : OR; + for ( j = 0; j < gtype_size[(*w)->var_type]; j++ ) { + tmp = copy_Wff( (*w)->son ); + expand_quantifiers_in_wff( &tmp, (*w)->var, gtype_consts[(*w)->var_type][j] ); + tmp->next = r; + if ( r ) { + r->prev = tmp; + } + r = tmp; + } + + free_WffNode( (*w)->son ); + (*w)->sons = r; + (*w)->var = -1; + (*w)->var_type = -1; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = NULL; + + /* now make all sons expand their quantifiers + */ + for ( i = (*w)->sons; i; i = i->next ) { + expand_quantifiers_in_wff( &i, -1, -1 ); + } + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + expand_quantifiers_in_wff( &i, var, constant ); + } + break; + case NOT: + expand_quantifiers_in_wff( &((*w)->son), var, constant ); + break; + case ATOM: + if ( var == -1 ) { + break; + } + + change = FALSE; + for ( l = 0; l < garity[(*w)->fact->predicate]; l++ ) { + if ( (*w)->fact->args[l] == ENCODE_VAR( var ) ) { + (*w)->fact->args[l] = constant; + change = TRUE; + } + } + if ( !change && (*w)->visited ) { + /* we did not change anything and we've already seen that node + * --> it cant be simplified + */ + break; + } + if ( !possibly_negative( (*w)->fact ) ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !possibly_positive( (*w)->fact ) ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + (*w)->visited = TRUE; + break; + case COMP: + if ( var == -1 ) { + break; + } + + replace_var_with_const_in_exp( &((*w)->lh), var, constant ); + replace_var_with_const_in_exp( &((*w)->rh), var, constant ); + if ( (*w)->lh->connective != NUMBER || + (*w)->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); + if ( ct ) { + (*w)->connective = TRU; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } else { + (*w)->connective = FAL; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: expansion, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ) + +{ + + int j, f, k; + + switch ( (*n)->connective ) { + case AD: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + replace_var_with_const_in_exp( &((*n)->son), var, constant ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + if ( !(*n)->fluent ) { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + break; + } + f = (*n)->fluent->function; + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] == ENCODE_VAR( var ) ) { + (*n)->fluent->args[j] = constant; + } + } + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] < 0 ) { + break; + } + } + if ( j < gf_arity[f] ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\nreplace var with const in expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +WffNode *copy_Wff( WffNode *w ) + +{ + + WffNode *tmp, *tmp2, *i; + int j; + + tmp = new_WffNode( w->connective ); + + switch ( w->connective ) { + case ALL: + case EX: + tmp->var = w->var; + tmp->var_type = w->var_type; + tmp->son = copy_Wff( w->son ); + break; + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + tmp2 = copy_Wff( i ); + if ( tmp->sons ) { + tmp->sons->prev = tmp2; + } + tmp2->next = tmp->sons; + tmp->sons = tmp2; + } + break; + case NOT: + tmp->son = copy_Wff( w->son ); + break; + case ATOM: + tmp->fact = new_Fact(); + tmp->fact->predicate = w->fact->predicate; + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + tmp->fact->args[j] = w->fact->args[j]; + } + tmp->visited = w->visited; + break; + case COMP: + tmp->comp = w->comp; + tmp->lh = copy_Exp( w->lh ); + tmp->rh = copy_Exp( w->rh ); + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: copy, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + return tmp; + +} + + + +ExpNode *copy_Exp( ExpNode *n ) + +{ + + ExpNode *tmp; + int i; + + tmp = new_ExpNode( n->connective ); + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + tmp->leftson = copy_Exp( n->leftson ); + tmp->rightson = copy_Exp( n->rightson ); + break; + case MINUS: + tmp->son = copy_Exp( n->son ); + break; + case NUMBER: + tmp->value = n->value; + break; + case FHEAD: + if ( n->fluent ) { + tmp->fluent = new_Fluent(); + tmp->fluent->function = n->fluent->function; + for ( i = 0; i < gf_arity[tmp->fluent->function]; i++ ) { + tmp->fluent->args[i] = n->fluent->args[i]; + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + tmp->fl = n->fl; + } + break; + default: + printf("\n\ncopy expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + + return tmp; + +} + + + +Bool possibly_positive( Fact *f ) + +{ + + int i; + + if ( gis_added[f->predicate] ) { + return TRUE; + } + + for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { + if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { + return TRUE; + } + } + + return FALSE; + +} + + + +Bool possibly_negative( Fact *f ) + +{ + + int i; + + if ( gis_deleted[f->predicate] ) { + return TRUE; + } + + for ( i = 0; i < garity[f->predicate]; i++ ) { + if ( f->args[i] < 0 ) { + return TRUE; + } + } + + for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { + if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { + return FALSE; + } + } + + return TRUE; + +} + + + +Bool matches( Fact *f1, Fact *f2 ) + +{ + + int i; + + for ( i = 0; i < garity[f1->predicate]; i++ ) { + if ( f1->args[i] >= 0 ) { + if ( f2->args[i] >= 0 && + f1->args[i] != f2->args[i] ) { + return FALSE; + } + } + } + + return TRUE; + +} + + + +void cleanup_wff( WffNode **w ) + +{ + + merge_ANDs_and_ORs_in_wff( w ); + detect_tautologies_in_wff( w ); + simplify_wff( w ); + detect_tautologies_in_wff( w ); + merge_ANDs_and_ORs_in_wff( w ); + +} + + + +void detect_tautologies_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + switch ( (*w)->connective ) { + case ALL: + case EX: + detect_tautologies_in_wff( &((*w)->son) ); + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + detect_tautologies_in_wff( &i ); + } + for ( i = (*w)->sons; i && i->next; i = i->next ) { + j = i->next; + while ( j ) { + if ( are_identical_ATOMs( i, j ) ) { + j->prev->next = j->next; + if ( j->next ) { + j->next->prev = j->prev; + } + tmp = j; + j = j->next; + if ( tmp->fact ) { + free( tmp->fact ); + } + free( tmp ); + continue; + } + if ( i->connective == NOT && + are_identical_ATOMs( i->son, j ) ) { + (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; + free_WffNode( (*w)->son ); + (*w)->son = NULL; + return; + } + if ( j->connective == NOT && + are_identical_ATOMs( i, j->son ) ) { + (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; + free_WffNode( (*w)->son ); + (*w)->son = NULL; + return; + } + j = j->next; + } + } + break; + case NOT: + detect_tautologies_in_wff( &((*w)->son) ); + break; + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: tautologies, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ) + +{ + + int i; + + if ( w1->connective != ATOM || + w2->connective != ATOM ) { + return FALSE; + } + + if ( w1->fact->predicate != w2->fact->predicate ) { + return FALSE; + } + + for ( i = 0; i < garity[w1->fact->predicate]; i++ ) { + if ( w1->fact->args[i] != w2->fact->args[i] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +void merge_ANDs_and_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + switch ( (*w)->connective ) { + case ALL: + case EX: + merge_ANDs_and_ORs_in_wff( &((*w)->son) ); + break; + case AND: + case OR: + i = (*w)->sons; + while ( i ) { + merge_ANDs_and_ORs_in_wff( &i ); + if ( i->connective == (*w)->connective ) { + if ( !(i->sons) ) { + if ( i->next ) { + i->next->prev = i->prev; + } + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + for ( j = i->sons; j->next; j = j->next ); + j->next = i->next; + if ( i->next ) { + i->next->prev = j; + } + if ( i->prev ) { + i->prev->next = i->sons; + i->sons->prev = i->prev; + } else { + (*w)->sons = i->sons; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + } + break; + case NOT: + merge_ANDs_and_ORs_in_wff( &((*w)->son) ); + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: merge, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void NOTs_down_in_wff( WffNode **w ) + +{ + + WffNode *tmp1, *tmp2, *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\ntrying to put nots down in quantified formula! debug me\n\n"); + exit( 1 ); + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + NOTs_down_in_wff( &i ); + } + break; + case NOT: + if ( (*w)->son->connective == NOT ) { + (*w)->connective = (*w)->son->son->connective; + (*w)->fact = (*w)->son->son->fact; + (*w)->comp = (*w)->son->son->comp; + (*w)->lh = (*w)->son->son->lh; + (*w)->rh = (*w)->son->son->rh; + tmp1 = (*w)->son; + tmp2 = (*w)->son->son; + (*w)->sons = (*w)->son->son->sons; + (*w)->son = (*w)->son->son->son; + /* don't need to remember (*w)->son->son->next: this is empty because + * otherwise the resp. father, (*w)->son, would have been an + * AND or OR + */ + free( tmp1 ); + free( tmp2 ); + NOTs_down_in_wff( w ); + break; + } + if ( (*w)->son->connective == AND || + (*w)->son->connective == OR ) { + (*w)->connective = ( (*w)->son->connective == AND ) ? OR : AND; + (*w)->sons = (*w)->son->sons; + free( (*w)->son ); + (*w)->son = NULL; + for ( i = (*w)->sons; i; i = i->next ) { + tmp1 = new_WffNode( i->connective ); + tmp1->son = i->son; + tmp1->sons = i->sons; + tmp1->fact = i->fact; + tmp1->comp = i->comp; + tmp1->lh = i->lh; + tmp1->rh = i->rh; + i->connective = NOT; + i->son = tmp1; + i->sons = NULL; + i->fact = NULL; + i->comp = -1; + i->lh = NULL; + i->rh = NULL; + NOTs_down_in_wff( &i ); + } + break; + } + if ( (*w)->son->connective == COMP ) { + if ( (*w)->son->comp != EQ ) { + (*w)->connective = COMP; + (*w)->lh = (*w)->son->lh; + (*w)->rh = (*w)->son->rh; + switch ( (*w)->son->comp ) { + case LE: + (*w)->comp = GEQ; + break; + case LEQ: + (*w)->comp = GE; + break; + case GEQ: + (*w)->comp = LE; + break; + case GE: + (*w)->comp = LEQ; + break; + default: + printf("\n\nillegal comparator not EQ %d in nots down", + (*w)->son->comp); + exit( 1 ); + } + free( (*w)->son ); + (*w)->son = NULL; + } else { + (*w)->connective = OR; + (*w)->sons = (*w)->son; + (*w)->son = NULL; + (*w)->sons->comp = LE; + tmp1 = new_WffNode( COMP ); + tmp1->lh = copy_Exp( (*w)->sons->lh ); + tmp1->rh = copy_Exp( (*w)->sons->rh ); + tmp1->comp = GE; + tmp1->prev = (*w)->sons; + (*w)->sons->next = tmp1; + } + } + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: nots down, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + + +} + + + + + + + + + + + +/**************************************************** + * NEGATIVE PRE- AND EFFECT- CONDITIONS TRANSLATION * + ****************************************************/ + + + + + + + + +int lconsts[MAX_ARITY]; + + + + + + + + +void translate_negative_preconds( void ) + +{ + + int i, j; + Effect *e; + Facts *f; + FluentValues *ff; + + while ( translate_one_negative_cond( ggoal ) ); + + for ( i = 0; i < gnum_operators; i++ ) { + while ( translate_one_negative_cond( goperators[i]->preconds ) ); + + for ( e = goperators[i]->effects; e; e = e->next ) { + while ( translate_one_negative_cond( e->conditions ) ); + } + } + + if ( gcmd_line.display_info == 108 ) { + printf("\n\ndomain with translated negative conds:"); + + printf("\n\noperators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\ninitial state is:\n"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + printf("\n"); + for ( ff = gf_initial; ff; ff = ff->next ) { + printf("\n"); + print_Fluent( &(ff->fluent) ); + printf(": %f", ff->value); + } + printf("\n\n"); + + printf("\n\nindividual predicates:\n"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n\n%s:", gpredicates[i]); + if ( !gis_added[i] && + !gis_deleted[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + printf("\n"); + print_Fact( &(ginitial_predicate[i][j]) ); + } + } + printf("\n\nindividual functions:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n\n%s:", gfunctions[i]); + if ( !gis_changed[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_function[i]; j++ ) { + printf("\n"); + print_Fluent( &(ginitial_function[i][j].fluent) ); + printf(": %f", ginitial_function[i][j].value); + } + } + printf("\n\n"); + + printf("\n\ngoal is:\n"); + print_Wff( ggoal, 0 ); + printf("\n\n"); + } + +} + + + +Bool translate_one_negative_cond( WffNode *w ) + +{ + + WffNode *i; + int p, j, k, m; + Effect *e; + Literal *l, *tmp; + + switch ( w->connective ) { + case ALL: + case EX: + printf("\ntranslating NOT in quantified formula! debug me\n\n"); + exit( 1 ); + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + if ( translate_one_negative_cond( i ) ) { + return TRUE; + } + } + return FALSE; + case NOT: + if ( w->son->fact->predicate == -1 ) { + return FALSE; + } + break; + case COMP: + case ATOM: + case TRU: + case FAL: + return FALSE; + default: + printf("\nwon't get here: translate one neg cond, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + + if ( gnum_predicates == MAX_PREDICATES ) { + printf("\ntoo many predicates in translation! increase MAX_PREDICATES (currently %d)\n\n", + MAX_PREDICATES); + exit( 1 ); + } + p = w->son->fact->predicate; + /* safety check: we disallow negative conds on derived preds!! + */ + if ( gaxiom_added[p]) { + printf("\nA derived predicate appears negated in the negation normal form of a derivation rule condition, an operator precondition, or the goal."); + printf("\nSorry, this version of FF does not allow any of this. Bailing out.\n\n"); + exit( 1 ); + } else { + printf("\ntranslating negated cond for predicate %s", gpredicates[p]); + } + + gpredicates[gnum_predicates] = new_Token( strlen( gpredicates[p] ) + 5 ); + sprintf( gpredicates[gnum_predicates], "NOT-%s", gpredicates[p] ); + garity[gnum_predicates] = garity[p]; + for ( j = 0; j < garity[p]; j++ ) { + gpredicates_args_type[gnum_predicates][j] = + gpredicates_args_type[p][j]; + } + gis_added[gnum_predicates] = FALSE; + gis_deleted[gnum_predicates] = FALSE; + m = 1; + for ( j = 0; j < garity[gnum_predicates]; j++ ) { + m *= gtype_size[gpredicates_args_type[gnum_predicates][j]]; + } + ginitial_predicate[gnum_predicates] = ( Fact * ) calloc( m, sizeof( Fact ) ); + gnum_predicates++; + + + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, &ggoal ); + + for ( j = 0; j < gnum_operators; j++ ) { + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, + &(goperators[j]->preconds) ); + + for ( e = goperators[j]->effects; e; e = e->next ) { + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, + &(e->conditions) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->fact.predicate != p ) { + continue; + } + tmp = new_Literal(); + if ( l->negated ) { + tmp->negated = FALSE; + gis_added[gnum_predicates - 1] = TRUE; + } else { + tmp->negated = TRUE; + gis_deleted[gnum_predicates - 1] = TRUE; + } + tmp->fact.predicate = gnum_predicates - 1; + for ( k = 0; k < garity[p]; k++ ) { + tmp->fact.args[k] = l->fact.args[k]; + } + if ( l->prev ) { + tmp->prev = l->prev; + tmp->prev->next = tmp; + } else { + e->effects = tmp; + } + tmp->next = l; + l->prev = tmp; + } + } + } + + add_to_initial_state( p, gnum_predicates - 1, 0 ); + + return TRUE; + +} + + + +void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ) + +{ + + WffNode *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\nreplacing p with NOT-p in quantified formula! debug me\n\n"); + exit( 1 ); + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + replace_not_p_with_n_in_wff( p, n, &i ); + } + break; + case NOT: + if ( (*w)->son->fact->predicate == p ) { + (*w)->connective = ATOM; + (*w)->NOT_p = p; + (*w)->fact = (*w)->son->fact; + (*w)->fact->predicate = n; + free( (*w)->son ); + (*w)->son = NULL; + } + break; + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: replace p with NOT-p, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void add_to_initial_state( int p, int n, int index ) + +{ + + int i, j; + Facts *tmp; + + if ( index == garity[p] ) { + /* see if contrary fact is there in ini + */ + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + for ( j = 0; j < garity[p]; j++ ) { + if ( ginitial_predicate[p][i].args[j] != lconsts[j] ) { + break; + } + } + if ( j == garity[p] ) { + break; + } + } + if ( i < gnum_initial_predicate[p] ) { + return; + } + + /* no: add new fact to ini + */ + ginitial_predicate[n][gnum_initial_predicate[n]].predicate = n; + for ( i = 0; i < garity[n]; i++ ) { + ginitial_predicate[n][gnum_initial_predicate[n]].args[i] = lconsts[i]; + } + gnum_initial_predicate[n]++; + + if ( !gis_added[n] && + !gis_deleted[n] ) { + return; + } + + tmp = new_Facts(); + tmp->fact->predicate = n; + for ( i = 0; i < garity[p]; i++ ) { + tmp->fact->args[i] = lconsts[i]; + } + tmp->next = ginitial; + ginitial = tmp; + gnum_initial++; + return; + } + + for ( i = 0; i < gtype_size[gpredicates_args_type[p][index]]; i++ ) { + lconsts[index] = gtype_consts[gpredicates_args_type[p][index]][i]; + add_to_initial_state( p, n, index + 1 ); + } + +} + + + + + + + + + + + +/******************************************************************* + * SPLIT DOMAIN IN PREPARATION FOR SEPARATE INSTANTIATION ROUTINES * + *******************************************************************/ + + + + + + + + + + +void split_domain( void ) + +{ + + int i, j, m, s = 0, mn; + Effect *e; + WffNode *w, *ww, *www; + NormOperator *tmp_op; + Fact *tmp_ft; + + for ( i = 0; i < MAX_TYPES; i++ ) { + gnum_intersected_types[i] = -1; + } + + for ( i = 0; i < gnum_operators; i++ ) { + if ( (m = is_dnf( goperators[i]->preconds )) != -1 ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + if ( is_dnf( e->conditions ) == -1 ) { + break; + } + } + if ( !e ) { + goperators[i]->hard = FALSE; + s += m; + } + } + } + + ghard_operators = ( Operator_pointer * ) calloc( MAX_OPERATORS, sizeof( Operator ) ); + gnum_hard_operators = 0; + geasy_operators = ( NormOperator_pointer * ) calloc( s, sizeof( NormOperator_pointer ) ); + gnum_easy_operators = 0; + + for ( i = 0; i < gnum_operators; i++ ) { + if ( goperators[i]->hard ) { + ghard_operators[gnum_hard_operators++] = goperators[i]; + continue; + } + w = goperators[i]->preconds; + switch ( w->connective ) { + case OR: + for ( ww = w->sons; ww; ww = ww->next ) { + tmp_op = new_NormOperator( goperators[i] ); + if ( ww->connective == AND ) { + m = 0; + mn = 0; + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) m++; + if ( www->connective == COMP ) mn++; + } + tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) { + tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); + tmp_ft->predicate = www->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = www->fact->args[j]; + } + tmp_op->num_preconds++; + } + if ( www->connective == COMP ) { + tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = www->comp; + tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( www->lh ); + tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( www->rh ); + tmp_op->num_numeric_preconds++; + } + } + } else { + if ( ww->connective == ATOM ) { + tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_op->preconds[0]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_op->num_preconds = 1; + } + if ( ww->connective == COMP ) { + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_comp[0] = ww->comp; + tmp_op->numeric_preconds_lh[0] = copy_Exp( ww->lh ); + tmp_op->numeric_preconds_rh[0] = copy_Exp( ww->rh ); + tmp_op->num_numeric_preconds = 1; + } + } + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + } + break; + case AND: + tmp_op = new_NormOperator( goperators[i] ); + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_op->num_preconds++; + } + if ( ww->connective == COMP ) { + tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = ww->comp; + tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( ww->lh ); + tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( ww->rh ); + tmp_op->num_numeric_preconds++; + } + } + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case ATOM: + tmp_op = new_NormOperator( goperators[i] ); + tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_op->preconds[0]); + tmp_ft->predicate = w->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = w->fact->args[j]; + } + tmp_op->num_preconds = 1; + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case COMP: + tmp_op = new_NormOperator( goperators[i] ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_comp[0] = w->comp; + tmp_op->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp_op->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp_op->num_numeric_preconds = 1; + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case TRU: + tmp_op = new_NormOperator( goperators[i] ); + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case FAL: + break; + default: + printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); + exit( 1 ); + } + } + + if ( gcmd_line.display_info == 109 ) { + printf("\n\nsplitted operators are:\n"); + + printf("\nEASY:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + + printf("\n\n\nHARD:\n"); + for ( i = 0; i < gnum_hard_operators; i++ ) { + print_Operator( ghard_operators[i] ); + } + } + +} + + + +int is_dnf( WffNode *w ) + +{ + + WffNode *i; + int s = 0; + + switch ( w->connective ) { + case ALL: + case EX: + printf("\nchecking quantifier for dnf. debug me\n\n"); + exit( 1 ); + case AND: + for ( i = w->sons; i; i = i->next ) { + if ( i->connective == ATOM || + i->connective == COMP ) { + continue; + } + return -1; + } + return 1; + case OR: + for ( i = w->sons; i; i = i->next ) { + s++; + if ( i->connective == ATOM || + i->connective == COMP || + ( i->connective == AND && + is_dnf( i ) != -1 ) ) { + continue; + } + return -1; + } + return s; + case NOT: + printf("\n\nNOT in presimplified formula. debug me\n\n"); + exit( 1 ); + case ATOM: + case COMP: + case TRU: + case FAL: + return 1; + default: + printf("\nwon't get here: check dnf, conn %d\n\n", + w->connective); + exit( 1 ); + } + +} + + + +void make_normal_effects( NormOperator **nop, Operator *op ) + +{ + + Effect *e; + NormEffect *tmp_ef; + WffNode *w, *ww, *www; + int j, m, ma, md, mn; + Literal *l; + NumericEffect *ll; + Fact *tmp_ft; + Fluent *tmp_fl; + + for ( e = op->effects; e; e = e->next ) { + w = e->conditions; + switch ( w->connective ) { + case OR: + for ( ww = w->sons; ww; ww = ww->next ) { + tmp_ef = new_NormEffect1( e ); + if ( ww->connective == AND ) { + m = 0; + mn = 0; + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) m++; + if ( www->connective == COMP ) mn++; + } + tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) { + tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); + tmp_ft->predicate = www->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = www->fact->args[j]; + } + tmp_ef->num_conditions++; + } + if ( www->connective == COMP ) { + tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = www->comp; + tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( www->lh ); + tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( www->rh ); + tmp_ef->num_numeric_conditions++; + } + } + } else { + if ( ww->connective == ATOM ) { + tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_ef->conditions[0]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_ef->num_conditions = 1; + } + if ( ww->connective == COMP ) { + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_comp[0] = ww->comp; + tmp_ef->numeric_conditions_lh[0] = copy_Exp( ww->lh ); + tmp_ef->numeric_conditions_rh[0] = copy_Exp( ww->rh ); + tmp_ef->num_numeric_conditions = 1; + } + } + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + } + break; + case AND: + tmp_ef = new_NormEffect1( e ); + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_ef->num_conditions++; + } + if ( ww->connective == COMP ) { + tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = ww->comp; + tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->lh ); + tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->rh ); + tmp_ef->num_numeric_conditions++; + } + } + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case ATOM: + tmp_ef = new_NormEffect1( e ); + tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_ef->conditions[0]); + tmp_ft->predicate = w->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = w->fact->args[j]; + } + tmp_ef->num_conditions = 1; + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case COMP: + tmp_ef = new_NormEffect1( e ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_comp[0] = w->comp; + tmp_ef->numeric_conditions_lh[0] = copy_Exp( w->lh ); + tmp_ef->numeric_conditions_rh[0] = copy_Exp( w->rh ); + tmp_ef->num_numeric_conditions = 1; + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case TRU: + tmp_ef = new_NormEffect1( e ); + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case FAL: + break; + default: + printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); + exit( 1 ); + } + } + +} + + + + + + + + + +/************************************************************************* + * ADDITIONAL: FULL DNF, only compute on fully instantiated formulae!!!! * + *************************************************************************/ + + + + + + + + + + +/* dnf + */ + +WffNode *lhitting_sets; +WffNode_pointer *lset; +int lmax_set; + + + + + + +void dnf( WffNode **w ) + +{ + + static Bool first_call = TRUE; + + if ( first_call ) { + lset = ( WffNode_pointer * ) + calloc( MAX_HITTING_SET_DEFAULT, sizeof( WffNode_pointer ) ); + lmax_set = MAX_HITTING_SET_DEFAULT; + first_call = FALSE; + } + + ANDs_below_ORs_in_wff( w ); + +} + + + +void ANDs_below_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *tmp; + int c, m; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\ntrying to put quantified formula into DNF! (ands down) debug me\n\n"); + exit( 1 ); + break; + case AND: + c = 0; + m = 0; + for ( i = (*w)->sons; i; i = i->next ) { + ANDs_below_ORs_in_wff( &i ); + if ( i->connective == OR ) { + c++; + } + m++; + } + if ( c == 0 ) { + /* no ORs as sons --> all sons are literals. OK + */ + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + } + /* crucial part: AND node, sons can be merged OR's. + * (i.e., sons are either literals or disjunctions of + * conjunctions of literals) + * create OR node with one hitting set of w's sons for + * each disjunct + */ + lhitting_sets = NULL; + if ( m > lmax_set ) { + free( lset ); + lset = ( WffNode_pointer * ) calloc( m, sizeof( WffNode_pointer ) ); + lmax_set = m; + } + collect_hitting_sets( (*w)->sons, 0 ); + (*w)->connective = OR; + tmp = (*w)->sons; + (*w)->sons = lhitting_sets; + if ( 0 ) free_WffNode( tmp ); + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + ANDs_below_ORs_in_wff( &i ); + } + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + case NOT: + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: ands down, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void collect_hitting_sets( WffNode *ORlist, int index ) + +{ + + WffNode *tmp1, *tmp2, *j; + int i; + + if ( !ORlist ) { + tmp1 = new_WffNode( AND ); + for ( i = 0; i < index; i++ ) { + tmp2 = copy_Wff( lset[i] ); + tmp2->next = tmp1->sons; + if ( tmp1->sons ) { + tmp1->sons->prev = tmp2; + } + tmp1->sons = tmp2; + } + tmp1->next = lhitting_sets; + if ( lhitting_sets ) { + lhitting_sets->prev = tmp1; + } + lhitting_sets = tmp1; + return; + } + + if ( ORlist->connective != OR ) { + lset[index] = ORlist; + collect_hitting_sets( ORlist->next, index + 1 ); + return; + } + + for ( j = ORlist->sons; j; j = j->next ) { + lset[index] = j; + collect_hitting_sets( ORlist->next, index + 1 ); + } + +} + + + +void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + i = (*w)->sons; + while ( i ) { + if ( i->connective == (*w)->connective ) { + if ( !(i->sons) ) { + if ( i->next ) { + i->next->prev = i->prev; + } + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + for ( j = i->sons; j->next; j = j->next ); + j->next = i->next; + if ( i->next ) { + i->next->prev = j; + } + if ( i->prev ) { + i->prev->next = i->sons; + i->sons->prev = i->prev; + } else { + (*w)->sons = i->sons; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + } + +} + + + +/* switch ( (*w)->connective ) { */ +/* case ALL: */ +/* case EX: */ +/* break; */ +/* case AND: */ +/* case OR: */ +/* for ( i = (*w)->sons; i; i = i->next ) { */ +/* } */ +/* break; */ +/* case NOT: */ +/* break; */ +/* case ATOM: */ +/* case TRU: */ +/* case FAL: */ +/* break; */ +/* default: */ +/* printf("\nwon't get here: remove var, non logical %d\n\n", */ +/* (*w)->connective); */ +/* exit( 1 ); */ +/* } */ + + + + + + + + + diff --git a/models/main_models/rt1/gen/ff_planner/inst_pre.h b/models/main_models/rt1/gen/ff_planner/inst_pre.h new file mode 100644 index 000000000..de859b385 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_pre.h @@ -0,0 +1,123 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: inst_pre.h + * Description: headers for instantiating operators, preprocessing part. + * - transform domain into integers + * - inertia preprocessing: + * - collect inertia info + * - split initial state in special arrays + * - Wff normalization: + * - simplification + * - quantifier expansion + * - NOT s down + * - negative preconditions translation + * - split operators into easy and hard to instantiate ones + * + * - full DNF functions, only feasible for fully instantiated + * formulae + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + + + +#ifndef _INST_PRE_H +#define _INST_PRE_H + + + +void encode_domain_in_integers( void ); +void collect_all_strings( void ); +void create_member_nrs( void ); +int position_in_types_table( char *str ); +int position_in_constants_table( char *str ); +int position_in_predicates_table( char *str ); +int position_in_functions_table( char *str ); +void create_integer_representation( void ); +void make_Fact( Fact *f, PlNode *n, int num_vars ); +void make_Fluent( Fluent *f, TokenList *atom, int num_vars ); +Bool is_subtype( int t1, int t2 ); +WffNode *make_Wff( PlNode *p, int num_vars ); +ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ); +Effect *make_effect( PlNode *p, int num_vars ); + + + +void do_inertia_preprocessing_step_1( void ); +void collect_inertia_information( void ); +void split_initial_state( void ); + + + +void normalize_all_wffs( void ); +void remove_unused_vars_in_wff( WffNode **w ); +void decrement_inferior_vars( int var, WffNode *w ); +void decrement_inferior_vars_in_exp( int var, ExpNode *n ); +Bool var_used_in_wff( int code_var, WffNode *w ); +Bool var_used_in_exp( int code_var, ExpNode *n ); +void simplify_wff( WffNode **w ); +void simplify_exp( ExpNode **n ); +void expand_quantifiers_in_wff( WffNode **w, int var, int constant ); +void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ); +WffNode *copy_Wff( WffNode *w ); +ExpNode *copy_Exp( ExpNode *n ); +Bool possibly_positive( Fact *f ); +Bool possibly_negative( Fact *f ); +Bool matches( Fact *f1, Fact *f2 ); +void cleanup_wff( WffNode **w ); +void detect_tautologies_in_wff( WffNode **w ); +Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ); +void merge_ANDs_and_ORs_in_wff( WffNode **w ); +void NOTs_down_in_wff( WffNode **w ); + + + +void translate_negative_preconds( void ); +Bool translate_one_negative_cond( WffNode *w ); +void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ); +void add_to_initial_state( int p, int n, int index ); + + + +void split_domain( void ); +int is_dnf( WffNode *w ); +void make_normal_effects( NormOperator **nop, Operator *op ); + + + +void dnf( WffNode **w ); +void ANDs_below_ORs_in_wff( WffNode **w ); +void collect_hitting_sets( WffNode *ORlist, int index ); +void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ); + + + +#endif /* _INST_PRE_H */ diff --git a/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l b/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l new file mode 100644 index 000000000..850bbb407 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l @@ -0,0 +1,139 @@ +%{ +#include "ff.h" +#include "parse.h" + + /* default yywrap function - always treat EOF as an EOF */ +int fct_pddlwrap() { return 1; }; + +int gbracket_count = 0; + +%} + +a [Aa] +b [Bb] +c [Cc] +d [Dd] +e [Ee] +f [Ff] +g [Gg] +h [Hh] +i [Ii] +j [Jj] +k [Kk] +l [Ll] +m [Mm] +n [Nn] +o [Oo] +p [Pp] +q [Qq] +r [Rr] +s [Ss] +t [Tt] +u [Uu] +v [Vv] +w [Ww] +x [Xx] +y [Yy] +z [Zz] + +%x COMMENT OVERREAD + +%% + +"(" { return(OPEN_PAREN); } + +")" { return(CLOSE_PAREN); } + +\([ \t]*{i}{n}"-"{p}{a}{c}{k}{a}{g}{e} { gbracket_count = 1; + BEGIN OVERREAD; } + +\([ \t]*":"{l}{e}{n}{g}{t}{h} { gbracket_count = 1; + BEGIN OVERREAD; } + +\([ \t]*":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { gbracket_count = 1; + BEGIN OVERREAD; } + +{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } + +{p}{r}{o}{b}{l}{e}{m} { return(PROBLEM_TOK); } + +{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(SITUATION_TOK); } + +":"{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(BSITUATION_TOK); } + +":"{o}{b}{j}{e}{c}{t}{s} { return(OBJECTS_TOK); } + +":"{g}{o}{a}{l} { return(GOAL_TOK); } + +":"{m}{e}{t}{r}{i}{c} { return(METRIC_TOK); } + +":"{i}{n}{i}{t} { return(INIT_TOK); } + +":"{d}{o}{m}{a}{i}{n} { return(BDOMAIN_TOK); } + +\([ \t]*":"{e}{x}{t}{e}{n}{d}{s} { gbracket_count = 1; + BEGIN OVERREAD; } + +{a}{n}{d} { return(AND_TOK); } + +{i}{m}{p}{l}{y} { return(IMPLY_TOK); } + +{o}{r} { return(OR_TOK); } + +{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } + +{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } + +{n}{o}{t} { return(NOT_TOK); } + +"<" { return(LE_TOK); } + +"<=" { return(LEQ_TOK); } + +"=" { return(EQ_TOK); } + +">=" { return(GEQ_TOK); } + +">" { return(GE_TOK); } + +"-" { return(MINUS_TOK); } + +"+" { return(AD_TOK); } + +"*" { return(MU_TOK); } + +"/" { return(DI_TOK); } + +:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase( yytext ); + strcpy(yylval.string, yytext ); return(NAME); } + +\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* {strupcase( yytext ); + strcpy(yylval.string, yytext); return(VARIABLE); } + +"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} + +"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } + +\;(.)*\n { lineno++; } +\;(.)* { /* this will hold only in files that end with + a comment but no linefeed */ } + +(.^\")*\n { lineno++; } ; + +\" { BEGIN COMMENT;} + +\" { BEGIN INITIAL;} + +\n { lineno++; } + +(.^\(\))*\n { lineno++; } + +[^\(\)] { } + +\( { gbracket_count++; } + +\) { gbracket_count--; + if (!gbracket_count) BEGIN INITIAL; } + +. {} +%% diff --git a/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l b/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l new file mode 100644 index 000000000..0e9d8499d --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l @@ -0,0 +1,151 @@ +%{ +#include "ff.h" +#include "parse.h" + +/* default yywrap function - always treat EOF as an EOF */ +int ops_pddlwrap() { return 1; }; + +%} + +a [Aa] +b [Bb] +c [Cc] +d [Dd] +e [Ee] +f [Ff] +g [Gg] +h [Hh] +i [Ii] +j [Jj] +k [Kk] +l [Ll] +m [Mm] +n [Nn] +o [Oo] +p [Pp] +q [Qq] +r [Rr] +s [Ss] +t [Tt] +u [Uu] +v [Vv] +w [Ww] +x [Xx] +y [Yy] +z [Zz] + +%x COMMENT OVERREAD + +%% + +"(" { return(OPEN_PAREN); } + +")" { return(CLOSE_PAREN); } + +{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } + +{d}{o}{m}{a}{i}{n} { return(DOMAIN_TOK); } + +":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { return(REQUIREMENTS_TOK); } + +":"{t}{y}{p}{e}{s} { return(TYPES_TOK); } + +{n}{u}{m}{b}{e}{r} { return(NUMBER_TOK); } + +":"{c}{o}{n}{s}{t}{a}{n}{t}{s} { return(CONSTANTS_TOK); } + +":"{p}{r}{e}{d}{i}{c}{a}{t}{e}{s} { return(PREDICATES_TOK); } + +":"{f}{u}{n}{c}{t}{i}{o}{n}{s} { return(FUNCTIONS_TOK); } + +":"{a}{c}{t}{i}{o}{n} { return(ACTION_TOK); } + +":"{d}{e}{r}{i}{v}{e}{d} { return(AXIOM_TOK); } + +":"{p}{a}{r}{a}{m}{e}{t}{e}{r}{s} { return(PARAMETERS_TOK); } + +":"{v}{a}{r}{s} { return(VARS_TOK); } + +":"{p}{r}{e}{c}{o}{n}{d}{i}{t}{i}{o}{n} { return(PRECONDITION_TOK); } + +":"{e}{f}{f}{e}{c}{t} { return(EFFECT_TOK); } + +":"{i}{m}{p}{l}{i}{e}{s} { return(IMPLIES_TOK); } + +{a}{n}{d} { return(AND_TOK); } + +{n}{o}{t} { return(NOT_TOK); } + +{w}{h}{e}{n} { return(WHEN_TOK); } + +{i}{m}{p}{l}{y} { return(IMPLY_TOK); } + +{o}{r} { return(OR_TOK); } + +{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } + +{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } + +"<" { return(LE_TOK); } + +"<=" { return(LEQ_TOK); } + +"=" { return(EQ_TOK); } + +">=" { return(GEQ_TOK); } + +">" { return(GE_TOK); } + +"-" { return(MINUS_TOK); } + +"+" { return(AD_TOK); } + +"*" { return(MU_TOK); } + +"/" { return(DI_TOK); } + +{a}{s}{s}{i}{g}{n} { return(ASSIGN_TOK); } + +{s}{c}{a}{l}{e}"-"{u}{p} { return(SCALE_UP_TOK); } + +{s}{c}{a}{l}{e}"-"{d}{o}{w}{n} { return(SCALE_DOWN_TOK); } + +{i}{n}{c}{r}{e}{a}{s}{e} { return(INCREASE_TOK); } + +{d}{e}{c}{r}{e}{a}{s}{e} { return(DECREASE_TOK); } + + +:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase(yytext); strcpy(yylval.string, yytext); + return(NAME); } + +\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* { strupcase(yytext); strcpy(yylval.string, yytext); + return(VARIABLE); } + +"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} + + +"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } + +\;(.)*\n { lineno++; } +\;(.)* { /* this will hold only in files that end with + a comment but no linefeed */ } + +(.^\")*\n { lineno++; } ; + +\" { BEGIN COMMENT;} + +\" { BEGIN INITIAL;} + +\n { lineno++; } + +(.^\(\))*\n { lineno++; } + +[^\(\)] { } + +\( { BEGIN OVERREAD; gbracket_count++; } + +\) { BEGIN OVERREAD; gbracket_count--; + if (!gbracket_count) BEGIN INITIAL; } + +. {} +%% diff --git a/models/main_models/rt1/gen/ff_planner/main.c b/models/main_models/rt1/gen/ff_planner/main.c new file mode 100644 index 000000000..bc3a795b5 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/main.c @@ -0,0 +1,1230 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: main.c + * Description: The main routine for the Metric-FastForward Planner. + * Modified July 2011 to allow more command-line search + * confiogurations, including improved cost-minimization + * + * Author: original version Joerg Hoffmann 2001/2002 + * modified version Joerg Hoffmann 2012 + * + *********************************************************************/ + + + + + + + + +#include "ff.h" + +#include "memory.h" +#include "output.h" + +#include "parse.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_easy.h" +#include "inst_hard.h" +#include "inst_final.h" + +#include "relax.h" +#include "search.h" + + + + + + + + + + + +/* + * ----------------------------- GLOBAL VARIABLES ---------------------------- + */ + + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + +/* used to time the different stages of the planner + */ +float gtempl_time = 0, greach_time = 0, grelev_time = 0, gconn_time = 0; +float gLNF_time = 0, gsearch_time = 0; + + +/* the command line inputs + */ +struct _command_line gcmd_line; + +/* number of states that got heuristically evaluated + */ +int gevaluated_states = 0; + +/* maximal depth of breadth first search + */ +int gmax_search_depth = 0; + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + +/* used for pddl parsing, flex only allows global variables + */ +int gbracket_count; +char *gproblem_name; + +/* The current input line number + */ +int lineno = 1; + +/* The current input filename + */ +char *gact_filename; + +/* The pddl domain name + */ +char *gdomain_name = NULL; + +/* loaded, uninstantiated operators + */ +PlOperator *gloaded_ops = NULL; + +/* stores initials as fact_list + */ +PlNode *gorig_initial_facts = NULL; + +/* not yet preprocessed goal facts + */ +PlNode *gorig_goal_facts = NULL; + +/* axioms as in UCPOP before being changed to ops + */ +PlOperator *gloaded_axioms = NULL; + +/* the types, as defined in the domain file + */ +TypedList *gparse_types = NULL; + +/* the constants, as defined in domain file + */ +TypedList *gparse_constants = NULL; + +/* the predicates and their arg types, as defined in the domain file + */ +TypedListList *gparse_predicates = NULL; + +/* the functions and their arg types, as defined in the domain file + */ +TypedListList *gparse_functions = NULL; + +/* the objects, declared in the problem file + */ +TypedList *gparse_objects = NULL; + +/* the metric + */ +Token gparse_optimization; +ParseExpNode *gparse_metric = NULL; + + +/* connection to instantiation ( except ops, goal, initial ) + */ + +/* all typed objects + */ +FactList *gorig_constant_list = NULL; + +/* the predicates and their types + */ +FactList *gpredicates_and_types = NULL; + +/* the functions and their types + */ +FactList *gfunctions_and_types = NULL; + + + + + + + + + + + + +/***************** + * INSTANTIATING * + *****************/ + + + + + + + + + +/* global arrays of constant names, + * type names (with their constants), + * predicate names, + * predicate aritys, + * defined types of predicate args + */ +Token gconstants[MAX_CONSTANTS]; +int gnum_constants = 0; +Token gtype_names[MAX_TYPES]; +int gtype_consts[MAX_TYPES][MAX_TYPE]; +Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; +int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ +int gtype_size[MAX_TYPES]; +int gnum_types = 0; +Token gpredicates[MAX_PREDICATES]; +int garity[MAX_PREDICATES]; +Bool gaxiom_added[MAX_PREDICATES]; +int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; +int gnum_predicates = 0; +Token gfunctions[MAX_FUNCTIONS]; +int gf_arity[MAX_FUNCTIONS]; +int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; +int gnum_functions = 0; + + + + + +/* the domain in integer (Fact) representation + */ +Operator_pointer goperators[MAX_OPERATORS]; +int gnum_operators = 0; +Fact *gfull_initial; +int gnum_full_initial = 0; +FluentValue *gfull_fluents_initial; +int gnum_full_fluents_initial = 0; +WffNode *ggoal = NULL; + +ExpNode *gmetric = NULL; + + + +/* stores inertia - information: is any occurence of the predicate + * added / deleted in the uninstantiated ops ? + */ +Bool gis_added[MAX_PREDICATES]; +Bool gis_deleted[MAX_PREDICATES]; + + +/* for functions we *might* want to say, symmetrically, whether it is + * increased resp. decreased at all. + * + * that is, however, somewhat involved because the right hand + * sides can be arbirtray expressions, so we have no guarantee + * that increasing really does adds to a functions value... + * + * thus (for the time being), we settle for "is the function changed at all?" + */ +Bool gis_changed[MAX_FUNCTIONS]; + + + +/* splitted initial state: + * initial non static facts, + * initial static facts, divided into predicates + * (will be two dimensional array, allocated directly before need) + */ +Facts *ginitial = NULL; +int gnum_initial = 0; +Fact **ginitial_predicate; +int *gnum_initial_predicate; + +/* same thing for functions + */ +FluentValues *gf_initial; +int gnum_f_initial = 0; +FluentValue **ginitial_function; +int *gnum_initial_function; + + + +/* the type numbers corresponding to any unary inertia + */ +int gtype_to_predicate[MAX_PREDICATES]; +int gpredicate_to_type[MAX_TYPES]; + +/* (ordered) numbers of types that new type is intersection of + */ +TypeArray gintersected_types[MAX_TYPES]; +int gnum_intersected_types[MAX_TYPES]; + + + +/* splitted domain: hard n easy ops + */ +Operator_pointer *ghard_operators; +int gnum_hard_operators; +NormOperator_pointer *geasy_operators; +int gnum_easy_operators; + + + +/* so called Templates for easy ops: possible inertia constrained + * instantiation constants + */ +EasyTemplate *geasy_templates; +int gnum_easy_templates; + + + +/* first step for hard ops: create mixed operators, with conjunctive + * precondition and arbitrary effects + */ +MixedOperator *ghard_mixed_operators; +int gnum_hard_mixed_operators; + + + +/* hard ''templates'' : pseudo actions + */ +PseudoAction_pointer *ghard_templates; +int gnum_hard_templates; + + + +/* store the final "relevant facts" + */ +Fact grelevant_facts[MAX_RELEVANT_FACTS]; +int gnum_relevant_facts = 0; +int gnum_pp_facts = 0; +/* store the "relevant fluents" + */ +Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; +int gnum_relevant_fluents = 0; +Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; +/* this is NULL for normal, and the LNF for + * artificial fluents. + */ +LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; + + + +/* the final actions and problem representation + */ +Action *gactions = NULL; +int gnum_actions; +State ginitial_state; +int *glogic_goal = NULL; +int gnum_logic_goal = 0; +Comparator *gnumeric_goal_comp = NULL; +ExpNode_pointer *gnumeric_goal_lh = NULL, *gnumeric_goal_rh = NULL; +int gnum_numeric_goal = 0; + +/* direct numeric goal access + */ +Comparator *gnumeric_goal_direct_comp; +float *gnumeric_goal_direct_c; + + + +/* to avoid memory leaks; too complicated to identify + * the exact state of the action to throw away (during construction), + * memory gain not worth the implementation effort. + */ +Action *gtrash_actions = NULL; + + + +/* additional lnf step between finalized inst and + * conn graph + */ +Comparator *glnf_goal_comp = NULL; +LnfExpNode_pointer *glnf_goal_lh = NULL; +float *glnf_goal_rh = NULL; +int gnum_lnf_goal = 0; + +LnfExpNode glnf_metric; +Bool goptimization_established = FALSE; + + + + + + + +/********************** + * CONNECTIVITY GRAPH * + **********************/ + + + + + + + +/* one ops (actions) array ... + */ +OpConn *gop_conn; +int gnum_op_conn; + + + +/* one effects array ... + */ +EfConn *gef_conn; +int gnum_ef_conn; + + + +/* one facts array. + */ +FtConn *gft_conn; +int gnum_ft_conn; + + + +/* and: one fluents array. + */ +FlConn *gfl_conn; +int gnum_fl_conn; +int gnum_real_fl_conn;/* number of non-artificial ones */ + + + +/* final goal is also transformed one more step. + */ +int *gflogic_goal = NULL; +int gnum_flogic_goal = 0; +Comparator *gfnumeric_goal_comp = NULL; +int *gfnumeric_goal_fl = NULL; +float *gfnumeric_goal_c = NULL; +int gnum_fnumeric_goal = 0; + +/* direct access (by relevant fluents) + */ +Comparator *gfnumeric_goal_direct_comp = NULL; +float *gfnumeric_goal_direct_c = NULL; + + + + + + + + + + + +/******************* + * SEARCHING NEEDS * + *******************/ + + + + + + + + + + + +/* applicable actions + */ +int *gA;/* non-axioms */ +int gnum_A; +int *gA_axioms; /* axioms */ +int gnum_A_axioms; + + + +/* communication from extract 1.P. to search engine: + * 1P action choice + */ +int *gH; +int gnum_H; +/* added cost of relaxed plan + */ +float gh_cost; +/* hmax value + */ +float ghmax; + + + +/* to store plan + */ +int gplan_ops[MAX_PLAN_LENGTH]; +int gnum_plan_ops = 0; + + + +/* stores the states that the current plan goes through + * ( for knowing where new agenda entry starts from ) + */ +State gplan_states[MAX_PLAN_LENGTH + 1]; + + + + + + + +/* dirty: multiplic. of total-time in final metric LNF + */ +float gtt; + + + + + + + +/* the mneed structures + */ +Bool **gassign_influence; +Bool **gTassign_influence; + + + +/* the real var input to the mneed computation. + */ +Bool *gmneed_start_D; +float *gmneed_start_V; + + + +/* does this contain conditional effects? + * (if it does then the state hashing has to be made more + * cautiously) + */ +Bool gconditional_effects; + + + +/* easier to question: are we optimizing or no? + */ +Bool gcost_minimizing; + + + +/* stores current A* weight: this is initially given by user, + * but changes during anytime search. + */ +float gw; +/* this is the minimum weight, ie we'll stop once the weight update + * does/would yield a value <= this. + * if no such minim weight is given, this will be -1 + */ +float gmin_w = -1; + + + +/* this one says whether or not we are actually using + * cost-minimizing rplans. + * this will be the case by default if we're running cost- + * minimizing searches. it can be switched off by a flag; + * it is automatically switched off in case there are + * numeric preconditions/goals: for this case, + * cost-minimizing rplans are not implemented (a numeric prec + * may cause an action to come in "later" on in the RPG although + * its logical pres are easy. in that case, any new effects will + * have a smaller RPGcost value than facts we already have waiting. + * in other words, the "Dijsktra" nature breaks. + * + * ... I suppose there may be a generic solution to this that + * can handle numeric precs/goals. Doesn't seem important enough + * to bother. + */ +Bool gcost_rplans; + + + + + + + + + + + + + +/* + * ----------------------------- HEADERS FOR PARSING ---------------------------- + * ( fns defined in the scan-* files ) + */ + + + + + + + +void get_fct_file_name( char *filename ); +void load_ops_file( char *filename ); +void load_fct_file( char *filename ); + + + + + + + + + + + +/* + * ----------------------------- MAIN ROUTINE ---------------------------- + */ + + + + + +struct tms lstart, lend; + + + + + +int main( int argc, char *argv[] ) + +{ + + /* resulting name for ops file + */ + char ops_file[MAX_LENGTH] = ""; + /* same for fct file + */ + char fct_file[MAX_LENGTH] = ""; + + struct tms start, end; + + Bool found_plan; + int i; + float cost; + + Bool prev_gcost_rplans; + + + + times ( &lstart ); + + /* command line treatment + */ + gcmd_line.display_info = 1; + gcmd_line.debug = 0; + + /* search settings + */ + gcmd_line.search_config = 5; + gcmd_line.cost_rplans = TRUE; + gcmd_line.w = 5; + gcmd_line.cost_bound = -1; + + memset(gcmd_line.ops_file_name, 0, MAX_LENGTH); + memset(gcmd_line.fct_file_name, 0, MAX_LENGTH); + memset(gcmd_line.path, 0, MAX_LENGTH); + + if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { + ff_usage(); + exit( 1 ); + } + if ( !process_command_line( argc, argv ) ) { + ff_usage(); + exit( 1 ); + } + + + /* make file names + */ + + /* one input name missing + */ + if ( !gcmd_line.ops_file_name || + !gcmd_line.fct_file_name ) { + fprintf(stdout, "\nff: two input files needed\n\n"); + ff_usage(); + exit( 1 ); + } + /* add path info, complete file names will be stored in + * ops_file and fct_file + */ + sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); + sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); + + + /* parse the input files + */ + + /* start parse & instantiation timing + */ + times( &start ); + /* domain file (ops) + */ + if ( gcmd_line.display_info >= 1 ) { + printf("\nff: parsing domain file"); + } + /* it is important for the pddl language to define the domain before + * reading the problem + */ + load_ops_file( ops_file ); + /* problem file (facts) + */ + if ( gcmd_line.display_info >= 1 ) { + printf(" ... done.\nff: parsing problem file"); + } + load_fct_file( fct_file ); + if ( gcmd_line.display_info >= 1 ) { + printf(" ... done.\n\n"); + } + + /* This is needed to get all types. + */ + build_orig_constant_list(); + + /* last step of parsing: see if it's an ADL domain! + */ + if ( !make_adl_domain() ) { + printf("\nff: this is not an ADL problem!"); + printf("\n can't be handled by this version.\n\n"); + exit( 1 ); + } + + + /* now instantiate operators; + */ + + + /************************** + * first do PREPROCESSING * + **************************/ + + /* start by collecting all strings and thereby encoding + * the domain in integers. + */ + encode_domain_in_integers(); + + /* inertia preprocessing, first step: + * - collect inertia information + * - split initial state into + * - arrays for individual predicates + * - arrays for all static relations + * - array containing non - static relations + */ + do_inertia_preprocessing_step_1(); + + /* normalize all PL1 formulae in domain description: + * (goal, preconds and effect conditions) + * - simplify formula + * - expand quantifiers + * - NOTs down + */ + normalize_all_wffs(); + + /* translate negative preconds: introduce symmetric new predicate + * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) + */ + translate_negative_preconds(); + + /* split domain in easy (disjunction of conjunctive preconds) + * and hard (non DNF preconds) part, to apply + * different instantiation algorithms + */ + split_domain(); + + /*********************************************** + * PREPROCESSING FINISHED * + * * + * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * + ***********************************************/ + + build_easy_action_templates(); + build_hard_action_templates(); + + times( &end ); + TIME( gtempl_time ); + + times( &start ); + + /* perform reachability analysis in terms of relaxed + * fixpoint + */ + perform_reachability_analysis(); + + times( &end ); + TIME( greach_time ); + + times( &start ); + + /* collect the relevant facts and build final domain + * and problem representations. + */ + collect_relevant_facts_and_fluents(); + + times( &end ); + TIME( grelev_time ); + + + /* now transform problem to additive normal form, + * if possible + */ + times( &start ); + if ( !transform_to_LNF() ) { + printf("\n\nThis is not a linear task!\n\n"); + exit( 1 ); + } + times( &end ); + TIME( gLNF_time ); + + times( &start ); + + /* now build globally accessable connectivity graph + */ + build_connectivity_graph(); + + /* now check for acyclic := effects (in expressions.c) + */ + check_assigncycles(); + /* set the relevanc info (in expressions.c) + */ + determine_fl_relevance(); + + times( &end ); + TIME( gconn_time ); + + /*********************************************************** + * we are finally through with preprocessing and can worry * + * bout finding a plan instead. * + ***********************************************************/ + + if ( gcmd_line.display_info ) { + printf("\n\nff: search configuration is "); + switch ( gcmd_line.search_config ) { + case 0: + printf("Enforced Hill-Climbing, if that fails then best-first search.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION"); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 1: + printf("best-first search.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION"); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 2: + printf("best-first search with helpful actions pruning.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION."); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 3: + printf("weighted A* with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf(" plan length"); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + case 4: + printf("A*epsilon with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); + exit( 1 ); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + case 5: + printf("Enforced Hill-Climbing, then A*epsilon with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); + exit( 1 ); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + default: + printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); + exit( 1 ); + } + } else { + if ( gcmd_line.search_config == 4 && !goptimization_established ) { + exit( 1 ); + } + } + + + times( &start ); + + + + /* need to evaluate derived predicates in initial state! + */ + do_axiom_update( &ginitial_state ); + + + if ( !gcost_rplans ) { + gcmd_line.cost_bound = -1; + } + + switch ( gcmd_line.search_config ) { + case 0: + found_plan = do_enforced_hill_climbing(); + if ( found_plan ) { + if ( gcmd_line.display_info ) { + print_plan(); + } + } else { + if ( gcmd_line.display_info ) { + printf("\n\nEnforced Hill-climbing failed !"); + printf("\nswitching to Best-first Search now.\n"); + } + do_best_first_search(); + } + break; + case 1: + case 2: + do_best_first_search(); + break; + case 3: + do_weighted_Astar(); + break; + case 4: + do_Astar_epsilon(); + break; + case 5: + /* gcost_rplans controls whether or not we compute cost-minimal relaxed plans + * gcost_minimizing is only used in h fn to decide whether or not we + * need to count the weights of the operators in the relaxed plan. + * + * gcost_rplans may be false even for search options 3,4,5, namely if there are + * numeric preconditions/goals which make this relaxed plan variant invalid. + * hence we need to remember, when switching it off for EHC, whether or not + * it was previously on. + */ + prev_gcost_rplans = gcost_rplans; + gcost_rplans = FALSE; + gcost_minimizing = FALSE; + found_plan = do_enforced_hill_climbing(); + if ( found_plan ) { + print_plan(); + } else { + if ( gcmd_line.display_info ) { + printf("\n\nEnforced Hill-climbing not successful."); + printf("\nSwitching to A*epsilon now."); + } + gcost_rplans = prev_gcost_rplans; + gcost_minimizing = TRUE; + do_Astar_epsilon(); + } + break; + default: + printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); + exit( 1 ); + } + + times( &end ); + TIME( gsearch_time ); + + + + output_planner_info(); + + printf("\n\n"); + exit( 0 ); + +} + + + + + + + + + + + +/* + * ----------------------------- HELPING FUNCTIONS ---------------------------- + */ + + + + + + + + + + + + +void output_planner_info( void ) + +{ + + printf( "\n\ntime spent: %7.2f seconds instantiating %d easy, %d hard action templates", + gtempl_time, gnum_easy_templates, gnum_hard_mixed_operators ); + printf( "\n %7.2f seconds reachability analysis, yielding %d facts and %d actions", + greach_time, gnum_pp_facts, gnum_actions ); + printf( "\n %7.2f seconds creating final representation with %d relevant facts, %d relevant fluents", + grelev_time, gnum_relevant_facts, gnum_relevant_fluents ); + printf( "\n %7.2f seconds computing LNF", + gLNF_time ); + printf( "\n %7.2f seconds building connectivity graph", + gconn_time ); + printf( "\n %7.2f seconds searching, evaluating %d states, to a max depth of %d", + gsearch_time, gevaluated_states, gmax_search_depth ); + printf( "\n %7.2f seconds total time", + gtempl_time + greach_time + grelev_time + gLNF_time + gconn_time + gsearch_time ); + + printf("\n\n"); + + exit( 0 ); + +} + + + +void ff_usage( void ) + +{ + + printf("\nusage of ff:\n"); + + printf("\nOPTIONS DESCRIPTIONS\n\n"); + printf("-p Path for operator and fact file\n"); + printf("-o Operator file name\n"); + printf("-f Fact file name\n\n"); + + printf("-r Random seed [used for random restarts; preset: 0]\n\n"); + + printf("-s Search configuration [preset: s=5]; '+H': helpful actions pruning\n"); + printf(" 0 Standard-FF: EHC+H then BFS (cost minimization: NO)\n"); + printf(" 1 BFS (cost minimization: NO)\n"); + printf(" 2 BFS+H (cost minimization: NO)\n"); + printf(" 3 Weighted A* (cost minimization: YES)\n"); + printf(" 4 A*epsilon (cost minimization: YES)\n"); + printf(" 5 EHC+H then A*epsilon (cost minimization: YES)\n"); + printf("-w Set weight w for search configs 3,4,5 [preset: w=5]\n\n"); + + printf("-C Do NOT use cost-minimizing relaxed plans for options 3,4,5\n\n"); + + printf("-b Fixed upper bound on solution cost (prune based on g+hmax); active only with cost minimization\n\n"); + + if ( 0 ) { + printf("-i run-time information level( preset: 1 )\n"); + printf(" 0 only times\n"); + printf(" 1 problem name, planning process infos\n"); + printf(" 101 parsed problem data\n"); + printf(" 102 cleaned up ADL problem\n"); + printf(" 103 collected string tables\n"); + printf(" 104 encoded domain\n"); + printf(" 105 predicates inertia info\n"); + printf(" 106 splitted initial state\n"); + printf(" 107 domain with Wff s normalized\n"); + printf(" 108 domain with NOT conds translated\n"); + printf(" 109 splitted domain\n"); + printf(" 110 cleaned up easy domain\n"); + printf(" 111 unaries encoded easy domain\n"); + printf(" 112 effects multiplied easy domain\n"); + printf(" 113 inertia removed easy domain\n"); + printf(" 114 easy action templates\n"); + printf(" 115 cleaned up hard domain representation\n"); + printf(" 116 mixed hard domain representation\n"); + printf(" 117 final hard domain representation\n"); + printf(" 118 reachability analysis results\n"); + printf(" 119 facts selected as relevant\n"); + printf(" 120 final domain and problem representations\n"); + printf(" 121 normalized expressions representation\n"); + printf(" 122 LNF: translated subtractions representation\n"); + printf(" 123 summarized effects LNF representation\n"); + printf(" 124 encoded LNF representation\n"); + printf(" 125 connectivity graph\n"); + printf(" 126 fixpoint result on each evaluated state\n"); + printf(" 127 1P extracted on each evaluated state\n"); + printf(" 128 H set collected for each evaluated state\n"); + + printf("\n-d switch on debugging\n\n"); + } + +} + + + +Bool process_command_line( int argc, char *argv[] ) + +{ + + char option; + + while ( --argc && ++argv ) { + if ( *argv[0] != '-' || strlen(*argv) != 2 ) { + return FALSE; + } + option = *++argv[0]; + switch ( option ) { +/* case 'E': */ +/* gcmd_line.ehc = FALSE; */ +/* break; */ +/* case 'O': */ +/* gcmd_line.optimize = TRUE; */ +/* gcmd_line.ehc = FALSE; */ +/* break; */ + case 'C': + gcmd_line.cost_rplans = FALSE; + break; + default: + if ( --argc && ++argv ) { + switch ( option ) { + case 'p': + strncpy( gcmd_line.path, *argv, MAX_LENGTH ); + break; + case 'o': + strncpy( gcmd_line.ops_file_name, *argv, MAX_LENGTH ); + break; + case 'f': + strncpy( gcmd_line.fct_file_name, *argv, MAX_LENGTH ); + break; + case 'i': + sscanf( *argv, "%d", &gcmd_line.display_info ); + break; + case 'd': + sscanf( *argv, "%d", &gcmd_line.debug ); + break; + case 's': + sscanf( *argv, "%d", &gcmd_line.search_config ); + break; + case 'w': + sscanf( *argv, "%d", &gcmd_line.w ); + break; + case 'b': + sscanf( *argv, "%f", &gcmd_line.cost_bound ); + break; + default: + printf( "\nff: unknown option: %c entered\n\n", option ); + return FALSE; + } + } else { + return FALSE; + } + } + } + + if ( 0 > gcmd_line.search_config || gcmd_line.search_config > 5 ) { + printf("\n\nff: unknown search configuration %d.\n\n", + gcmd_line.search_config); + return FALSE; + } + + if ( gcmd_line.search_config <= 2 ) { + gcost_minimizing = FALSE; + gcost_rplans = FALSE; + } else { + gcost_minimizing = TRUE; + gcost_rplans = TRUE; + } + + gw = gcmd_line.w; + + if ( !gcmd_line.cost_rplans ) { + gcost_rplans = FALSE; + } + + if ( gcmd_line.cost_bound != -1 && gcmd_line.cost_bound < 0 ) { + printf("\n\nff: invalid cost bound %f; must be >= 0.\n\n", + gcmd_line.cost_bound); + return FALSE; + } + + return TRUE; + +} + diff --git a/models/main_models/rt1/gen/ff_planner/makefile b/models/main_models/rt1/gen/ff_planner/makefile new file mode 100644 index 000000000..b8ace7b81 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/makefile @@ -0,0 +1,89 @@ +#!/bin/sh +# + + +####### FLAGS + +TYPE = +ADDONS = + +CC = gcc + +CFLAGS = -O6 -ansi $(TYPE) $(ADDONS) -g +# -g -pg + +LIBS = -lm + + +####### Files + +PDDL_PARSER_SRC = scan-fct_pddl.tab.c \ + scan-ops_pddl.tab.c \ + scan-probname.tab.c \ + lex.fct_pddl.c \ + lex.ops_pddl.c + +PDDL_PARSER_OBJ = scan-fct_pddl.tab.o \ + scan-ops_pddl.tab.o + + +SOURCES = main.c \ + memory.c \ + output.c \ + parse.c \ + expressions.c \ + inst_pre.c \ + inst_easy.c \ + inst_hard.c \ + inst_final.c \ + relax.c \ + search.c + +OBJECTS = $(SOURCES:.c=.o) + +####### Implicit rules + +.SUFFIXES: + +.SUFFIXES: .c .o + +.c.o:; $(CC) -c $(CFLAGS) $< + +####### Build rules + + +ff: $(OBJECTS) $(PDDL_PARSER_OBJ) + $(CC) -o ff $(OBJECTS) $(PDDL_PARSER_OBJ) $(CFLAGS) $(LIBS) + +# pddl syntax +scan-fct_pddl.tab.c: scan-fct_pddl.y lex.fct_pddl.c + bison -pfct_pddl -bscan-fct_pddl scan-fct_pddl.y + +scan-ops_pddl.tab.c: scan-ops_pddl.y lex.ops_pddl.c + bison -pops_pddl -bscan-ops_pddl scan-ops_pddl.y + +lex.fct_pddl.c: lex-fct_pddl.l + flex -Pfct_pddl lex-fct_pddl.l + +lex.ops_pddl.c: lex-ops_pddl.l + flex -Pops_pddl lex-ops_pddl.l + + +# misc +clean: + rm -f *.o *.bak *~ *% core *_pure_p9_c0_400.o.warnings \ + \#*\# $(RES_PARSER_SRC) $(PDDL_PARSER_SRC) + +veryclean: clean + rm -f ff H* J* K* L* O* graph.* *.symbex gmon.out \ + $(PDDL_PARSER_SRC) \ + lex.fct_pddl.c lex.ops_pddl.c lex.probname.c \ + *.output + +depend: + makedepend -- $(SOURCES) $(PDDL_PARSER_SRC) + +lint: + lclint -booltype Bool $(SOURCES) 2> output.lint + +# DO NOT DELETE diff --git a/models/main_models/rt1/gen/ff_planner/memory.c b/models/main_models/rt1/gen/ff_planner/memory.c new file mode 100644 index 000000000..601cea497 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/memory.c @@ -0,0 +1,1278 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: memory.c + * Description: Creation and Deletion functions for all data structures. + * + * Author: Joerg Hoffmann + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" +#include "memory.h" + + +#include "inst_pre.h" + + + + + + +/********************** + * CREATION FUNCTIONS * + **********************/ + + + + + + + + + + + +/* parsing + */ + + + + + + + + + +char *new_Token( int len ) + +{ + + char *tok = ( char * ) calloc( len, sizeof( char ) ); + CHECK_PTR(tok); + + return tok; + +} + + + +TokenList *new_TokenList( void ) + +{ + + TokenList *result = ( TokenList * ) calloc( 1, sizeof( TokenList ) ); + CHECK_PTR(result); + + result->item = NULL; + result->next = NULL; + + return result; + +} + + + +FactList *new_FactList( void ) + +{ + + FactList *result = ( FactList * ) calloc( 1, sizeof( FactList ) ); + CHECK_PTR(result); + + result->item = NULL; + result->next = NULL; + + return result; + +} + + + +TypedList *new_TypedList( void ) + +{ + + TypedList *result = ( TypedList * ) calloc( 1, sizeof( TypedList ) ); + CHECK_PTR(result); + + result->name = NULL; + result->type = NULL; + result->n = -1; + + return result; + +} + + + +TypedListList *new_TypedListList( void ) + +{ + + TypedListList *result = ( TypedListList * ) calloc( 1, sizeof( TypedListList ) ); + CHECK_PTR(result); + + result->predicate = NULL; + result->args = NULL; + + return result; + +} + + + +ParseExpNode *new_ParseExpNode( ExpConnective c ) + +{ + + ParseExpNode *result = ( ParseExpNode * ) calloc( 1, sizeof( ParseExpNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->atom = NULL; + result->leftson = NULL; + result->rightson = NULL; + + return result; + +} + + + +PlNode *new_PlNode( Connective c ) + +{ + + PlNode *result = ( PlNode * ) calloc( 1, sizeof( PlNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->atom = NULL; + + result->comp = -1; + result->neft = -1; + result->lh = NULL; + result->rh = NULL; + + result->sons = NULL; + result->next = NULL; + + return result; + +} + + + +PlOperator *new_PlOperator( char *name ) + +{ + + PlOperator *result = ( PlOperator * ) calloc( 1, sizeof( PlOperator ) ); + CHECK_PTR(result); + + if ( name ) { + result->name = new_Token(strlen(name)+1); + CHECK_PTR(result->name); + strcpy(result->name, name); + } else { + result->name = NULL; + } + + result->params = NULL; + result->preconds = NULL; + result->effects = NULL; + result->number_of_real_params = 0; + result->next = NULL; + + return result; + +} + + + +PlOperator *new_axiom_op_list( void ) + +{ + + static int count; + char *name; + PlOperator *ret; + + /* WARNING: count should not exceed 999 + */ + count++; + if ( count == 10000 ) { + printf("\ntoo many axioms! look into memory.c, line 157\n\n"); + exit( 1 ); + } + name = new_Token(strlen(HIDDEN_STR)+strlen(AXIOM_STR)+4+1); + sprintf(name, "%s%s%4d", HIDDEN_STR, AXIOM_STR, count); + + ret = new_PlOperator(name); + free(name); + + return ret; + +} + + + + + + + + + + + + + + +/* instantiation + */ + + + + + + + + + + + +Fact *new_Fact( void ) + +{ + + Fact *result = ( Fact * ) calloc( 1, sizeof( Fact ) ); + CHECK_PTR(result); + + return result; + +} + + + +Fluent *new_Fluent( void ) + +{ + + Fluent *result = ( Fluent * ) calloc( 1, sizeof( Fluent ) ); + CHECK_PTR(result); + + return result; + +} + + + +FluentValue *new_FluentValue( void ) + +{ + + FluentValue *result = ( FluentValue * ) calloc( 1, sizeof( FluentValue ) ); + CHECK_PTR(result); + + return result; + +} + + + +Facts *new_Facts( void ) + +{ + + Facts *result = ( Facts * ) calloc( 1, sizeof( Facts ) ); + CHECK_PTR(result); + + result->fact = new_Fact(); + + result->next = NULL; + + return result; + +} + + + +FluentValues *new_FluentValues( void ) + +{ + + FluentValues *result = ( FluentValues * ) calloc( 1, sizeof( FluentValues ) ); + CHECK_PTR(result); + + result->next = NULL; + + return result; + +} + + + +ExpNode *new_ExpNode( ExpConnective c ) + +{ + + ExpNode *result = ( ExpNode * ) calloc( 1, sizeof( ExpNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->fluent = NULL; + result->fl = -2; + result->c = 1; + result->son = NULL; + result->leftson = NULL; + result->rightson = NULL; + + return result; + +} + + + +WffNode *new_WffNode( Connective c ) + +{ + + WffNode *result = ( WffNode * ) calloc( 1, sizeof( WffNode ) ); + CHECK_PTR(result); + + result->connective = c; + + result->var = -1; + result->var_type = -1; + result->var_name = NULL; + + result->sons = NULL; + result->next = NULL; + result->prev = NULL; + + result->fact = NULL; + result->NOT_p = -1; + + result->son = NULL; + + result->comp = -1; + result->lh = NULL; + result->rh = NULL; + + result->visited = FALSE; + + return result; + +} + + + +Literal *new_Literal( void ) + +{ + + Literal *result = ( Literal * ) calloc( 1, sizeof( Literal ) ); + CHECK_PTR(result); + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NumericEffect *new_NumericEffect( void ) + +{ + + NumericEffect *result = ( NumericEffect * ) calloc( 1, sizeof( NumericEffect ) ); + CHECK_PTR(result); + + result->rh = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +Effect *new_Effect( void ) + +{ + + Effect *result = ( Effect * ) calloc( 1, sizeof( Effect ) ); + CHECK_PTR(result); + + result->num_vars = 0; + + result->conditions = NULL; + + result->effects = NULL; + result->numeric_effects = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +Operator *new_Operator( char *name, int norp ) + +{ + + int i; + + Operator *result = ( Operator * ) calloc( 1, sizeof( Operator ) ); + CHECK_PTR(result); + + if ( name ) { + result->name = new_Token( strlen( name ) + 1 ); + CHECK_PTR( result->name ); + strcpy( result->name, name ); + } else { + result->name = NULL; + } + + result->num_vars = 0; + result->number_of_real_params = norp; + + for ( i = 0; i < MAX_VARS; i++ ) { + result->removed[i] = FALSE; + } + + result->preconds = NULL; + + result->effects = NULL; + + result->hard = TRUE; + + return result; + +} + + + +NormEffect *new_NormEffect1( Effect *e ) + +{ + + int i; + + NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); + CHECK_PTR(result); + + result->num_vars = e->num_vars; + for ( i = 0; i < e->num_vars; i++ ) { + result->var_types[i] = e->var_types[i]; + result->inst_table[i] = -1; + } + + result->conditions = NULL; + result->num_conditions = 0; + + result->adds = NULL; + result->num_adds = 0; + result->dels = NULL; + result->num_dels = 0; + + result->numeric_conditions_comp = NULL; + result->numeric_conditions_lh = NULL; + result->numeric_conditions_rh = NULL; + result->num_numeric_conditions = 0; + + result->numeric_effects_neft = NULL; + result->numeric_effects_fluent = NULL; + result->numeric_effects_rh = NULL; + result->num_numeric_effects = 0; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NormEffect *new_NormEffect2( NormEffect *e ) + +{ + + int i, j; + + NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); + CHECK_PTR(result); + + result->num_vars = 0; + + result->conditions = ( Fact * ) calloc( e->num_conditions, sizeof( Fact ) ); + result->num_conditions = e->num_conditions; + for ( i = 0; i < e->num_conditions; i++ ) { + result->conditions[i].predicate = e->conditions[i].predicate; + for ( j = 0; j < garity[e->conditions[i].predicate]; j++ ) { + result->conditions[i].args[j] = e->conditions[i].args[j]; + } + } + result->adds = ( Fact * ) calloc( e->num_adds, sizeof( Fact ) ); + result->num_adds = e->num_adds; + for ( i = 0; i < e->num_adds; i++ ) { + result->adds[i].predicate = e->adds[i].predicate; + for ( j = 0; j < garity[e->adds[i].predicate]; j++ ) { + result->adds[i].args[j] = e->adds[i].args[j]; + } + } + result->dels = ( Fact * ) calloc( e->num_dels, sizeof( Fact ) ); + result->num_dels = e->num_dels; + for ( i = 0; i < e->num_dels; i++ ) { + result->dels[i].predicate = e->dels[i].predicate; + for ( j = 0; j < garity[e->dels[i].predicate]; j++ ) { + result->dels[i].args[j] = e->dels[i].args[j]; + } + } + + result->numeric_conditions_comp = ( Comparator * ) + calloc( e->num_numeric_conditions, sizeof( Comparator ) ); + result->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + result->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + result->numeric_conditions_comp[i] = e->numeric_conditions_comp[i]; + result->numeric_conditions_lh[i] = copy_Exp( e->numeric_conditions_lh[i] ); + result->numeric_conditions_rh[i] = copy_Exp( e->numeric_conditions_rh[i] ); + } + result->num_numeric_conditions = e->num_numeric_conditions; + result->numeric_effects_neft = ( NumericEffectType * ) + calloc( e->num_numeric_effects, sizeof( NumericEffectType ) ); + result->numeric_effects_fluent = ( Fluent * ) + calloc( e->num_numeric_effects, sizeof( Fluent ) ); + result->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( e->num_numeric_effects, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < e->num_numeric_effects; i++ ) { + result->numeric_effects_neft[i] = e->numeric_effects_neft[i]; + result->numeric_effects_fluent[i].function = e->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[e->numeric_effects_fluent[i].function]; j++ ) { + result->numeric_effects_fluent[i].args[j] = e->numeric_effects_fluent[i].args[j]; + } + result->numeric_effects_rh[i] = copy_Exp( e->numeric_effects_rh[i] ); + } + result->num_numeric_effects = e->num_numeric_effects; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NormOperator *new_NormOperator( Operator *op ) + +{ + + int i; + + NormOperator *result = ( NormOperator * ) calloc( 1, sizeof( NormOperator ) ); + CHECK_PTR(result); + + result->operator = op; + + result->num_vars = op->num_vars; + for ( i = 0; i < op->num_vars; i++ ) { + result->var_types[i] = op->var_types[i]; + result->inst_table[i] = -1; + } + result->num_removed_vars = 0; + + result->preconds = NULL; + result->num_preconds = 0; + + result->numeric_preconds_comp = NULL; + result->numeric_preconds_lh = NULL; + result->numeric_preconds_rh = NULL; + result->num_numeric_preconds = 0; + + result->effects = NULL; + + return result; + +} + + + + +EasyTemplate *new_EasyTemplate( NormOperator *op ) + +{ + + EasyTemplate *result = ( EasyTemplate * ) calloc( 1, sizeof( EasyTemplate ) ); + CHECK_PTR(result); + + result->op = op; + + result->prev = NULL; + result->next = NULL; + + return result; + +} + + + +MixedOperator *new_MixedOperator( Operator *op ) + +{ + + MixedOperator *result = ( MixedOperator * ) calloc( 1, sizeof( MixedOperator ) ); + CHECK_PTR(result); + + result->operator = op; + + result->preconds = NULL; + result->num_preconds = 0; + + result->effects = NULL; + + return result; + +} + + + +PseudoActionEffect *new_PseudoActionEffect( void ) + +{ + + PseudoActionEffect *result = + ( PseudoActionEffect * ) calloc( 1, sizeof( PseudoActionEffect ) ); + CHECK_PTR(result); + + result->conditions = NULL; + result->num_conditions = 0; + + result->adds = NULL; + result->num_adds = 0; + result->dels = NULL; + result->num_dels = 0; + + result->numeric_conditions_comp = NULL; + result->numeric_conditions_lh = NULL; + result->numeric_conditions_rh = NULL; + result->num_numeric_conditions = 0; + + result->numeric_effects_neft = NULL; + result->numeric_effects_fluent = NULL; + result->numeric_effects_rh = NULL; + result->num_numeric_effects = 0; + + result->next = NULL; + + return result; + +} + + + +PseudoAction *new_PseudoAction( MixedOperator *op ) + +{ + + int i; + + PseudoAction *result = ( PseudoAction * ) calloc( 1, sizeof( PseudoAction ) ); + CHECK_PTR(result); + + result->operator = op->operator; + for ( i = 0; i < op->operator->num_vars; i++ ) { + result->inst_table[i] = op->inst_table[i]; + } + + result->preconds = op->preconds; + result->num_preconds = op->num_preconds; + + result->numeric_preconds_comp = op->numeric_preconds_comp; + result->numeric_preconds_lh = op->numeric_preconds_lh; + result->numeric_preconds_rh = op->numeric_preconds_rh; + result->num_numeric_preconds = op->num_numeric_preconds; + + result->effects = NULL; + result->num_effects = 0; + + return result; + +} + + + +LnfExpNode *new_LnfExpNode( void ) + +{ + + LnfExpNode *result = ( LnfExpNode * ) calloc( 1, sizeof( LnfExpNode ) ); + CHECK_PTR(result); + + result->num_pF = 0; + result->num_nF = 0; + + result->c = 0; + + return result; + +} + + + +Action *new_Action( void ) + +{ + + Action *result = ( Action * ) calloc( 1, sizeof( Action ) ); + CHECK_PTR(result); + + result->norm_operator = NULL; + result->pseudo_action = NULL; + + result->next = NULL; + + return result; + +} + + + +void make_state( State *pointer, int ft, int fl ) + +{ + + int i; + + pointer->F = ( int * ) calloc( ft, sizeof( int ) ); + pointer->f_D = ( Bool * ) calloc( fl, sizeof( Bool ) ); + pointer->f_V = ( float * ) calloc( fl, sizeof( float ) ); + + for ( i = 0; i < fl; i++ ) { + pointer->f_D[i] = FALSE; + } + +} + + + +EhcNode *new_EhcNode( void ) + +{ + + EhcNode *result = ( EhcNode * ) calloc( 1, sizeof( EhcNode ) ); + CHECK_PTR(result); + + make_state( &(result->S), gnum_ft_conn, gnum_fl_conn ); + + result->father = NULL; + result->next = NULL; + + return result; + +} + + + +EhcHashEntry *new_EhcHashEntry( void ) + +{ + + EhcHashEntry *result = ( EhcHashEntry * ) calloc( 1, sizeof( EhcHashEntry ) ); + CHECK_PTR(result); + + result->ehc_node = NULL; + + result->next = NULL; + + return result; + +} + + + +PlanHashEntry *new_PlanHashEntry( void ) + +{ + + PlanHashEntry *result = ( PlanHashEntry * ) calloc( 1, sizeof( PlanHashEntry ) ); + CHECK_PTR(result); + + result->next_step = NULL; + + result->next = NULL; + + return result; + +} + + + +BfsNode *new_BfsNode( void ) + +{ + + BfsNode *result = ( BfsNode * ) calloc( 1, sizeof( BfsNode ) ); + CHECK_PTR(result); + + result->father = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +BfsHashEntry *new_BfsHashEntry( void ) + +{ + + BfsHashEntry *result = ( BfsHashEntry * ) calloc( 1, sizeof( BfsHashEntry ) ); + CHECK_PTR(result); + + result->bfs_node = NULL; + + result->next = NULL; + + return result; + +} + + + + + + + + + + + +/********************** + * DELETION FUNCTIONS * + **********************/ + + + + + + + + + + + + +void free_TokenList( TokenList *source ) + +{ + + if ( source ) { + free_TokenList( source->next ); + if ( source->item ) { + free( source->item ); + } + free( source ); + } + +} + + + +void free_FactList( FactList *source ) + +{ + + if ( source ) { + free_FactList( source->next ); + free_TokenList( source->item ); + free( source ); + } + +} + + + +void free_ParseExpNode( ParseExpNode *n ) + +{ + + if ( n ) { + free_TokenList( n->atom ); + free_ParseExpNode( n->leftson ); + free_ParseExpNode( n->rightson ); + free( n ); + } + +} + + + +void free_PlNode( PlNode *node ) + +{ + + if ( node ) { + free_ParseExpNode( node->lh ); + free_ParseExpNode( node->rh ); + free_PlNode( node->sons ); + free_PlNode( node->next ); + free_TokenList( node->atom ); + free( node ); + } + +} + + + +void free_PlOperator( PlOperator *o ) + +{ + + if ( o ) { + free_PlOperator( o->next ); + + if ( o->name ) { + free( o->name ); + } + + free_FactList( o->params ); + free_PlNode( o->preconds ); + free_PlNode( o->effects ); + + free( o ); + } + +} + + + +void free_Operator( Operator *o ) + +{ + + if ( o ) { + /* need not free more: the only point where that happens + * is only directly after first allocation + */ + + if ( o->name ) { + free( o->name ); + } + + free( o ); + } + +} + + + +void free_ExpNode( ExpNode *n ) + +{ + + if ( n ) { + if ( n->fluent ) free( n->fluent ); + free_ExpNode( n->son ); + free_ExpNode( n->leftson ); + free_ExpNode( n->rightson ); + free( n ); + } + +} + + + +void free_WffNode( WffNode *w ) + +{ + + if ( w ) { + free_WffNode( w->son ); + free_WffNode( w->sons ); + free_WffNode( w->next ); + if ( w->var_name ) { + free( w->var_name ); + } + if ( w->fact ) free( w->fact ); + free_ExpNode( w->lh ); + free_ExpNode( w->rh ); + free( w ); + } + +} + + + +void free_NormEffect( NormEffect *e ) + +{ + + int i; + + if ( e ) { + free_NormEffect( e->next ); + + if ( e->conditions ) { + free( e->conditions ); + } + if ( e->adds ) { + free( e->adds ); + } + if ( e->dels ) { + free( e->dels ); + } + + if ( e->numeric_conditions_comp ) { + free( e->numeric_conditions_comp ); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + free_ExpNode( e->numeric_conditions_lh[i] ); + free_ExpNode( e->numeric_conditions_rh[i] ); + } + if ( e->numeric_conditions_lh ) { + free( e->numeric_conditions_lh ); + } + if ( e->numeric_conditions_rh ) { + free( e->numeric_conditions_rh ); + } + + if ( e->numeric_effects_neft ) { + free( e->numeric_effects_neft ); + } + if ( e->numeric_effects_fluent ) { + free( e->numeric_effects_fluent ); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + free_ExpNode( e->numeric_effects_rh[i] ); + } + if ( e->numeric_effects_rh ) { + free( e->numeric_effects_rh ); + } + + free( e ); + } + +} + + + +void free_partial_Effect( Effect *e ) + +{ + + if ( e ) { + free_partial_Effect( e->next ); + + free_WffNode( e->conditions ); + + free( e ); + } + +} + + + +void free_NormOperator( NormOperator *o ) + +{ + + int i; + + if ( o ) { + + if ( o->preconds ) { + free( o->preconds ); + } + if ( o->numeric_preconds_comp ) { + free( o->numeric_preconds_comp ); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + free_ExpNode( o->numeric_preconds_lh[i] ); + free_ExpNode( o->numeric_preconds_rh[i] ); + } + if ( o->numeric_preconds_lh ) { + free( o->numeric_preconds_lh ); + } + if ( o->numeric_preconds_rh ) { + free( o->numeric_preconds_rh ); + } + free_NormEffect( o->effects ); + + free( o ); + } + +} + + + +void free_single_NormEffect( NormEffect *e ) + +{ + + int i; + + if ( e ) { + if ( e->conditions ) { + free( e->conditions ); + } + if ( e->adds ) { + free( e->adds ); + } + if ( e->dels ) { + free( e->dels ); + } + + if ( e->numeric_conditions_comp ) { + free( e->numeric_conditions_comp ); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + free_ExpNode( e->numeric_conditions_lh[i] ); + free_ExpNode( e->numeric_conditions_rh[i] ); + } + if ( e->numeric_conditions_lh ) { + free( e->numeric_conditions_lh ); + } + if ( e->numeric_conditions_rh ) { + free( e->numeric_conditions_rh ); + } + + if ( e->numeric_effects_neft ) { + free( e->numeric_effects_neft ); + } + if ( e->numeric_effects_fluent ) { + free( e->numeric_effects_fluent ); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + free_ExpNode( e->numeric_effects_rh[i] ); + } + if ( e->numeric_effects_rh ) { + free( e->numeric_effects_rh ); + } + + free( e ); + } + +} + + + +void free_single_EasyTemplate( EasyTemplate *t ) + +{ + + if ( t ) { + free( t ); + } + +} + + + +void free_TypedList( TypedList *t ) + +{ + + if ( t ) { + if ( t->name ) { + free( t->name ); + t->name = NULL; + } + if ( t->type ) { + free_TokenList( t->type ); + t->type = NULL; + } + free_TypedList( t->next ); + + free( t ); + } + +} + + + +void free_TypedListList( TypedListList *t ) + +{ + + if ( t ) { + if ( t->predicate ) { + free( t->predicate ); + t->predicate = NULL; + } + if ( t->args ) { + free_TypedList( t->args ); + t->args = NULL; + } + free_TypedListList( t->next ); + + free( t ); + } + +} + + + +void free_BfsNode( BfsNode *n ) + +{ + + if ( n ) { + free_BfsNode( n->next ); + free( n ); + } + +} + + + +void free_BfsHashEntry( BfsHashEntry *n ) + +{ + + if ( n ) { + free_BfsHashEntry( n->next ); + free( n ); + } + +} diff --git a/models/main_models/rt1/gen/ff_planner/memory.h b/models/main_models/rt1/gen/ff_planner/memory.h new file mode 100644 index 000000000..13e8ddfb3 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/memory.h @@ -0,0 +1,109 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: memory.h + * Description: Creation / Deletion functions for all data structures. + * + * Author: Joerg Hoffmann / Frank Rittinger + * + *********************************************************************/ + + + + + + +#ifndef _MEMORY_H +#define _MEMORY_H + + + + + +char *new_Token( int len ); +TokenList *new_TokenList( void ); +FactList *new_FactList( void ); +TypedList *new_TypedList( void ); +TypedListList *new_TypedListList( void ); +ParseExpNode *new_ParseExpNode( ExpConnective c ); +PlNode *new_PlNode( Connective c ); +PlOperator *new_PlOperator( char *name ); +PlOperator *new_axiom_op_list( void ); + + + +Fact *new_Fact( void ); +Fluent *new_Fluent( void ); +FluentValue *new_FluentValue( void ); +Facts *new_Facts( void ); +FluentValues *new_FluentValues( void ); +ExpNode *new_ExpNode( ExpConnective c ); +WffNode *new_WffNode( Connective c ); +Literal *new_Literal( void ); +NumericEffect *new_NumericEffect( void ); +Effect *new_Effect( void ); +Operator *new_Operator( char *name, int norp ); +NormEffect *new_NormEffect1( Effect *e ); +NormEffect *new_NormEffect2( NormEffect *e ); +NormOperator *new_NormOperator( Operator *op ); +EasyTemplate *new_EasyTemplate( NormOperator *op ); +MixedOperator *new_MixedOperator( Operator *op ); +PseudoActionEffect *new_PseudoActionEffect( void ); +PseudoAction *new_PseudoAction( MixedOperator *op ); +LnfExpNode *new_LnfExpNode( void ); +Action *new_Action( void ); +void make_state( State *pointer, int ft, int fl ); +EhcNode *new_EhcNode( void ); +EhcHashEntry *new_EhcHashEntry( void ); +PlanHashEntry *new_PlanHashEntry( void ); +BfsNode *new_BfsNode( void ); +BfsHashEntry *new_BfsHashEntry( void ); + + + + + + + +void free_TokenList( TokenList *source ); +void free_FactList( FactList *source ); +void free_ParseExpNode( ParseExpNode *n ); +void free_PlNode( PlNode *node ); +void free_PlOperator( PlOperator *o ); +void free_Operator( Operator *o ); +void free_ExpNode( ExpNode *n ); +void free_WffNode( WffNode *w ); +void free_NormEffect( NormEffect *e ); +void free_partial_Effect( Effect *e ); +void free_NormOperator( NormOperator *o ); +void free_single_NormEffect( NormEffect *e ); +void free_single_EasyTemplate( EasyTemplate *t ); +void free_TypedList( TypedList *t ); +void free_TypedListList( TypedListList *t ); +void free_ActionEffect( ActionEffect *e ); +void free_BfsNode( BfsNode *n ); +void free_BfsHashEntry( BfsHashEntry *n ); + + + + + + +#endif /* _MEMORY_H */ diff --git a/models/main_models/rt1/gen/ff_planner/output.c b/models/main_models/rt1/gen/ff_planner/output.c new file mode 100644 index 000000000..1341eff7a --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/output.c @@ -0,0 +1,1482 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: output.c + * Description: printing info out + * + * Author: Joerg Hoffmann + * + *********************************************************************/ + + + + + +#include "ff.h" + +#include "output.h" + + + + + + + +/* parsing + */ + + + + + + + +void print_FactList( FactList *list, char *sepf, char *sept ) + +{ + + FactList *i_list; + TokenList *i_tl; + + if ( list ) { + i_tl = list->item; + if (NULL == i_tl || NULL == i_tl->item) { + printf("empty"); + } else { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } + + while (NULL != i_tl) { + if (NULL != i_tl->item) { + printf("%s%s", sept, i_tl->item); + } + i_tl = i_tl->next; + } + + for ( i_list = list->next; i_list; i_list = i_list->next ) { + printf("%s", sepf); + i_tl = i_list->item; + if (NULL == i_tl || NULL == i_tl->item) { + printf("empty"); + } else { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } + + while (NULL != i_tl) { + if (NULL != i_tl->item) { + printf("%s%s", sept, i_tl->item); + } + i_tl = i_tl->next; + } + } + } + +} + + + +void print_hidden_TokenList( TokenList *list, char *sep ) + +{ + + TokenList *i_tl; + + i_tl = list; + if (NULL!=i_tl) { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } else { + printf("empty"); + } + + while (NULL != i_tl) { + printf("%s%s", sep, i_tl->item); + i_tl = i_tl->next; + } + +} + + + +void print_indent( int indent ) + +{ + + int i; + for (i=0;iconnective) { + case AD: + printf("(+ "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case SU: + printf("(- "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case MU: + printf("(* "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case DI: + printf("(/ "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case MINUS: + printf("(- "); + print_ParseExpNode( n->leftson ); + printf(")"); + break; + case NUMBER: + printf("%s", n->atom->item); + break; + case FHEAD: + printf("("); + print_hidden_TokenList(n->atom, " "); + printf(")"); + break; + default: + printf("\n\nprint Parseexpnode: wrong specifier %d", + n->connective); + } + +} + + + +void print_PlNode( PlNode *plnode, int indent ) + +{ + + PlNode *i_son; + + if ( !plnode ) { + printf("none\n"); + return; + } + + switch (plnode->connective) { + case ALL: + printf("ALL %s : %s\n", plnode->atom->item, + plnode->atom->next->item); + print_indent(indent); + printf("( "); + print_PlNode(plnode->sons,indent+4); + print_indent(indent); + printf(")\n"); + break; + case EX: + printf("EX %s : %s\n", plnode->atom->item, + plnode->atom->next->item); + print_indent(indent); + printf("( "); + print_PlNode(plnode->sons,indent+4); + print_indent(indent); + printf(")\n"); + break; + case AND: + printf("A( "); + print_PlNode(plnode->sons, indent+4); + if ( plnode->sons ) { + for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { + print_indent(indent); + printf("AND "); + print_PlNode(i_son,indent+4); + } + } + print_indent(indent); + printf(")\n"); + break; + case OR: + printf("O( "); + print_PlNode(plnode->sons, indent+4); + for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { + print_indent(indent); + printf("OR "); + print_PlNode(i_son,indent+4); + } + print_indent(indent); + printf(")\n"); + break; + case WHEN: + printf("IF "); + print_PlNode(plnode->sons,indent+5); + print_indent(indent); + printf("THEN "); + print_PlNode(plnode->sons->next,indent+5); + print_indent(indent); + printf("ENDIF\n"); + break; + case NOT: + if (ATOM==plnode->sons->connective) { + printf("NOT "); + print_PlNode(plnode->sons,indent+4); + } else { + printf("NOT("); + print_PlNode(plnode->sons,indent+4); + print_indent(indent+3); + printf(")\n"); + } + break; + case ATOM: + printf("("); + print_hidden_TokenList(plnode->atom, " "); + printf(")\n"); + break; + case TRU: + printf("(TRUE)\n"); + break; + case FAL: + printf("(FALSE)\n"); + break; + case COMP: + switch (plnode->comp) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\n\nillegal comp in parse tree!\n\n"); + exit( 1 ); + } + print_ParseExpNode( plnode->lh ); + print_ParseExpNode( plnode->rh ); + printf(")\n"); + break; + case NEF: + switch (plnode->neft) { + case ASSIGN: + printf("(assign "); + break; + case SCALE_UP: + printf("(scale-up "); + break; + case SCALE_DOWN: + printf("(scale-down "); + break; + case INCREASE: + printf("(increase "); + break; + case DECREASE: + printf("(decrease "); + break; + } + print_ParseExpNode( plnode->lh ); + print_ParseExpNode( plnode->rh ); + printf(")\n"); + break; + default: + printf("\n***** ERROR ****"); + printf("\nprint_plnode: %d > Wrong Node specifier\n", plnode->connective); + exit(1); + } + +} + + + +void print_plops( PlOperator *plop ) + +{ + + PlOperator *i_plop; + int count = 0; + + if ( !plop ) { + printf("none\n"); + } + + for ( i_plop = plop; i_plop!=NULL; i_plop = i_plop->next ) { + printf("\n"); + if ( i_plop->axiom ) printf("AXIOM-"); + printf("OPERATOR "); + printf("%s", i_plop->name); + printf("\nparameters: (%d real)\n", i_plop->number_of_real_params); + print_FactList ( i_plop->params, "\n", " : "); + printf("\n\npreconditions:\n"); + print_PlNode(i_plop->preconds, 0); + printf("effects:\n"); + print_PlNode(i_plop->effects, 0); + printf("\n-----\n"); + count++; + } + printf("\nAnzahl der Operatoren: %d\n", count); + +} + + + +void print_ExpNode( ExpNode *n ) + +{ + + if ( !n ) return; + + switch ( n->connective) { + case AD: + printf("(+ "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case SU: + printf("(- "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case MU: + printf("(* "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case DI: + printf("(/ "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case MINUS: + printf("(- "); + print_ExpNode( n->son ); + printf(")"); + break; + case NUMBER: + printf("%.2f", n->value); + break; + case FHEAD: + if ( n->fluent ) { + print_Fluent( n->fluent ); + } else { + if ( n->fl >= 0 ) { + printf(" %.2f*", n->c); + print_fl_name( n->fl ); + } else { + printf("[UNDEF]"); + } + } + break; + default: + printf("\n\nprint Expnode: wrong specifier %d", + n->connective); + } + +} + + + +void print_Wff( WffNode *n, int indent ) + +{ + + WffNode *i; + + if ( !n ) { + printf("none\n"); + return; + } + + switch (n->connective) { + case ALL: + printf("ALL x%d (%s): %s\n", n->var, n->var_name, + gtype_names[n->var_type]); + print_indent(indent); + printf("( "); + print_Wff(n->son,indent+4); + print_indent(indent); + printf(")\n"); + break; + case EX: + printf("EX x%d (%s) : %s\n", n->var, n->var_name, + gtype_names[n->var_type]); + print_indent(indent); + printf("( "); + print_Wff(n->son,indent+4); + print_indent(indent); + printf(")\n"); + break; + case AND: + printf("A( "); + print_Wff(n->sons, indent+4); + if ( n->sons ) { + for ( i = n->sons->next; i!=NULL; i = i->next ) { + if ( !i->prev ) { + printf("\nprev in AND not correctly set!\n\n"); + exit( 1 ); + } + print_indent(indent); + printf("AND "); + print_Wff(i,indent+4); + } + } + print_indent(indent); + printf(")\n"); + break; + case OR: + printf("O( "); + print_Wff(n->sons, indent+4); + for ( i = n->sons->next; i!=NULL; i = i->next ) { + print_indent(indent); + printf("OR "); + print_Wff(i,indent+4); + } + print_indent(indent); + printf(")\n"); + break; + case NOT: + if (ATOM==n->son->connective) { + printf("NOT "); + print_Wff(n->son,indent+4); + } else { + printf("NOT("); + print_Wff(n->son,indent+4); + print_indent(indent+3); + printf(")\n"); + } + break; + case ATOM: + print_Fact(n->fact); + if ( n->NOT_p != -1 ) printf(" - translation NOT"); + printf("\n"); + break; + case TRU: + printf("(TRUE)\n"); + break; + case FAL: + printf("(FALSE)\n"); + break; + case COMP: + switch (n->comp) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in WFF %d\n\n", n->comp); + exit( 1 ); + } + print_ExpNode( n->lh ); + print_ExpNode( n->rh ); + printf(")\n"); + break; + default: + printf("\n***** ERROR ****"); + printf("\nprint_Wff: %d > Wrong Node specifier\n", n->connective); + exit(1); + } + +} + + + +void print_Operator( Operator *o ) + +{ + + Effect *e; + Literal *l; + NumericEffect *ne; + int i, m = 0; + + printf("\n\n----------------Operator %s, axiom %d, translated form, step 1--------------\n", + o->name, o->axiom); + + for ( i = 0; i < o->num_vars; i++ ) { + printf("\nx%d (%s) of type %s, removed ? %s", + i, o->var_names[i], gtype_names[o->var_types[i]], + o->removed[i] ? "YES" : "NO"); + } + printf("\ntotal params %d, real params %d\n", + o->num_vars, o->number_of_real_params); + + printf("\nPreconds:\n"); + print_Wff( o->preconds, 0 ); + + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d (%s) of type %s", + o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]); + } + printf("\nConditions\n"); + print_Wff( e->conditions, 0 ); + printf("\nEffect Literals"); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + printf("\nNOT "); + } else { + printf("\n"); + } + print_Fact( &(l->fact) ); + } + printf("\nNumeric Effects"); + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + switch ( ne->neft ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); + exit( 1 ); + } + print_Fluent( &(ne->fluent) ); + print_ExpNode( ne->rh ); + } + } + +} + + + +void print_NormOperator( NormOperator *o ) + +{ + + NormEffect *e; + int i, m; + + printf("\n\n----------------Operator %s, normalized form--------------\n", + o->operator->name); + + for ( i = 0; i < o->num_vars; i++ ) { + printf("\nx%d of type ", i); + print_type( o->var_types[i] ); + } + printf("\n\n%d vars removed from original operator:", + o->num_removed_vars); + for ( i = 0; i < o->num_removed_vars; i++ ) { + m = o->removed_vars[i]; + printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m], + gtype_names[o->operator->var_types[m]]); + print_type( o->type_removed_vars[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d of type ", o->num_vars + i); + print_type( e->var_types[i] ); + } + printf("\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_Fact( &(e->conditions[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_Fact( &(e->adds[i]) ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_Fact( &(e->dels[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + print_Fluent( &(e->numeric_effects_fluent[i]) ); + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_MixedOperator( MixedOperator *o ) + +{ + + int i, m; + Effect *e; + NumericEffect *ne; + Literal *l; + + printf("\n\n----------------Operator %s, mixed form--------------\n", + o->operator->name); + + for ( i = 0; i < o->operator->num_vars; i++ ) { + printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); + print_type( o->operator->var_types[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d of type %s", + o->operator->num_vars + i, gtype_names[e->var_types[i]]); + } + printf("\nConditions\n"); + print_Wff( e->conditions, 0 ); + printf("\nEffect Literals"); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + printf("\nNOT "); + } else { + printf("\n"); + } + print_Fact( &(l->fact) ); + } + printf("\nNumeric Effects"); + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + switch ( ne->neft ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); + exit( 1 ); + } + print_Fluent( &(ne->fluent) ); + print_ExpNode( ne->rh ); + } + } + +} + + + +void print_PseudoAction( PseudoAction *o ) + +{ + + PseudoActionEffect *e; + int i, m; + + printf("\n\n----------------Pseudo Action %s--------------\n", + o->operator->name); + + for ( i = 0; i < o->operator->num_vars; i++ ) { + printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); + print_type( o->operator->var_types[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d", m++); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_Fact( &(e->conditions[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_Fact( &(e->adds[i]) ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_Fact( &(e->dels[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + print_Fluent( &(e->numeric_effects_fluent[i]) ); + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_Action( Action *a ) + +{ + + ActionEffect *e; + int i, j; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("\n\nAction REACH-GOAL"); + } else { + printf("\n\nAction %s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + + printf("\n\nPreconds:\n"); + for ( i = 0; i < a->num_preconds; i++ ) { + print_ft_name( a->preconds[i] ); + printf("\n"); + } + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + switch ( a->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in actionpre %d\n\n", + a->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( a->numeric_preconds_lh[i] ); + print_ExpNode( a->numeric_preconds_rh[i] ); + printf(")\n"); + } + + printf("\n\nEffects:"); + for ( j = 0; j < a->num_effects; j++ ) { + printf("\n\neffect %d", j); + e = &(a->effects[j]); + if ( e->illegal ) printf(" ILLEGAL EFFECT!"); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_ft_name( e->conditions[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_ft_name( e->adds[i] ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_ft_name( e->dels[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + if ( e->numeric_effects_fl[i] >= 0 ) { + print_fl_name( e->numeric_effects_fl[i] ); + } else { + printf("[UNDEF]"); + } + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_Action_name( Action *a ) + +{ + + int i; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("REACH-GOAL"); + } else { + printf("%s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + +} + + + +void print_lnf_Action( Action *a ) + +{ + + ActionEffect *e; + int i, j; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("\n\nAction REACH-GOAL"); + } else { + printf("\n\nAction %s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + + printf("\n\nPreconds:\n"); + for ( i = 0; i < a->num_preconds; i++ ) { + print_ft_name( a->preconds[i] ); + printf("\n"); + } + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + switch ( a->lnf_preconds_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in lnf actionpre %d\n\n", + a->lnf_preconds_comp[i]); + exit( 1 ); + } + print_LnfExpNode( a->lnf_preconds_lh[i] ); + printf(" %.2f)\n", a->lnf_preconds_rh[i]); + } + + printf("\n\nEffects:"); + for ( j = 0; j < a->num_effects; j++ ) { + printf("\n\neffect %d COST %f", j, a->effects[j].cost); + e = &(a->effects[j]); + if ( e->illegal ) printf(" ILLEGAL EFFECT!"); + if ( e->removed ) printf(" REMOVED!!!"); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_ft_name( e->conditions[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_lnf_conditions; i++ ) { + switch ( e->lnf_conditions_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in lnf normeff %d\n\n", + e->lnf_conditions_comp[i]); + exit( 1 ); + } + print_LnfExpNode( e->lnf_conditions_lh[i] ); + printf(" %.2f)\n", e->lnf_conditions_rh[i] ); + } + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_ft_name( e->adds[i] ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_ft_name( e->dels[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_lnf_effects; i++ ) { + switch ( e->lnf_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case INCREASE: + printf("\nincrease "); + break; + default: + printf("\n\nprint lnf normop: illegal neft %d\n\n", + e->lnf_effects_neft[i]); + exit( 1 ); + } + if ( e->lnf_effects_fl[i] >= 0 ) { + print_fl_name( e->lnf_effects_fl[i] ); + } else { + printf("[UNDEF]"); + } + print_LnfExpNode( e->lnf_effects_rh[i] ); + } + } + +} + + + +void print_type( int t ) + +{ + + int j; + + if ( gpredicate_to_type[t] == -1 ) { + if ( gnum_intersected_types[t] == -1 ) { + printf("%s", gtype_names[t]); + } else { + printf("INTERSECTED TYPE ("); + for ( j = 0; j < gnum_intersected_types[t]; j++ ) { + if ( gpredicate_to_type[gintersected_types[t][j]] == -1 ) { + printf("%s", gtype_names[gintersected_types[t][j]]); + } else { + printf("UNARY INERTIA TYPE (%s)", + gpredicates[gpredicate_to_type[gintersected_types[t][j]]]); + } + if ( j < gnum_intersected_types[t] - 1 ) { + printf(" and "); + } + } + printf(")"); + } + } else { + printf("UNARY INERTIA TYPE (%s)", gpredicates[gpredicate_to_type[t]]); + } + +} + + + +void print_Fact( Fact *f ) + +{ + + int j; + + if ( f->predicate == -3 ) { + printf("GOAL-REACHED"); + return; + } + + if ( f->predicate == -1 ) { + printf("(="); + for ( j=0; j<2; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + return; + } + + if ( f->predicate == -2 ) { + printf("(!="); + for ( j=0; j<2; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + return; + } + + printf("(%s", gpredicates[f->predicate]); + for ( j=0; jpredicate]; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + +} + + + +void print_Fluent( Fluent *f ) + +{ + + int j, ff = f->function; + + printf("(%s", gfunctions[ff]); + for ( j=0; jargs[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + +} + + + +void print_ft_name( int index ) + +{ + + print_Fact( &(grelevant_facts[index]) ); + +} + + + +void print_fl_name( int index ) + +{ + + int i; + + if ( index < 0 ) { + if ( index != -2 ) { + printf("[UNDEF]"); + } else { + printf("[TOTAL-TIME]"); + } + return; + } + + if ( grelevant_fluents_lnf[index] == NULL ) { + /* this is a non-artificial "atomic" one + * (or the mirrored version of one) + */ + printf("[RF%d](%s)", index, grelevant_fluents_name[index]); + } else { + /* this only summarizes a LNF requirement + */ + printf("[artRF%d]", index); + for ( i = 0; i < grelevant_fluents_lnf[index]->num_pF; i++ ) { + printf("%.2f*", grelevant_fluents_lnf[index]->pC[i] ); + print_fl_name( grelevant_fluents_lnf[index]->pF[i] ); + if ( i < grelevant_fluents_lnf[index]->num_pF - 1 ) { + printf(" + "); + } + } + } + +} + + + +void print_LnfExpNode( LnfExpNode *n ) + +{ + + int i; + + printf("(("); + for ( i = 0; i < n->num_pF; i++ ) { + printf("%.2f*", n->pC[i]); + print_fl_name( n->pF[i] ); + } + printf(") - ("); + for ( i = 0; i < n->num_nF; i++ ) { + printf("%.2f*", n->nC[i]); + print_fl_name( n->nF[i] ); + } + printf(") + %.2f)", n->c); + +} + + + +void print_op_name( int index ) + +{ + + int i; + Action *a = gop_conn[index].action; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("REACH-GOAL"); + } else { + printf("%s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + +} + + + +void print_State( State S ) + +{ + + int i; + + for ( i = 0; i < S.num_F; i++ ) { + printf("\n"); + print_ft_name( S.F[i] ); + } + for ( i = 0; i < gnum_relevant_fluents; i++ ) { + printf("\n"); + print_fl_name( i ); + printf(": "); + if ( S.f_D[i] ) { + printf("%.2f", S.f_V[i]); + } else { + printf("UNDEF"); + } + } + +} + + + + + + + + +/* + * program output routines + */ + + + + + + + + + +void print_plan( void ) + +{ + + int i; + float cost = 0; + + printf("\n\nff: found legal plan as follows"); + printf("\nstep "); + for ( i = 0; i < gnum_plan_ops; i++ ) { + printf("%4d: ", i); + print_op_name( gplan_ops[i] ); + if ( i < gnum_plan_ops-1 ) { + printf("\n "); + } + if ( goptimization_established ) { + cost += gop_conn[gplan_ops[i]].cost; + } + } + if ( goptimization_established ) { + printf("\nplan cost: %f", cost); + } + +} diff --git a/models/main_models/rt1/gen/ff_planner/output.h b/models/main_models/rt1/gen/ff_planner/output.h new file mode 100644 index 000000000..a74e87607 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/output.h @@ -0,0 +1,68 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: output.h + * Description: print headers + * + * Author: Joerg Hoffmann 1999 + * + *********************************************************************/ + + + + + +#ifndef _OUTPUT_H +#define _OUTPUT_H + + + +void print_FactList( FactList *list, char *sepf, char *sept ); +void print_hidden_TokenList( TokenList *list, char *sep ); +void print_indent( int indent ); +void print_ParseExpNode( ParseExpNode *n ); +void print_PlNode( PlNode *plnode, int indent ); +void print_ExpNode( ExpNode *n ); +void print_Wff( WffNode *n, int indent ); +void print_plops( PlOperator *plop ); +void print_Operator( Operator *o ); +void print_NormOperator( NormOperator *o ); +void print_MixedOperator( MixedOperator *o ); +void print_PseudoAction( PseudoAction *o ); +void print_Action( Action *a ); +void print_Action_name( Action *a ); +void print_lnf_Action( Action *a ); +void print_type( int t ); +void print_Fact( Fact *f ); +void print_Fluent( Fluent *f ); +void print_ft_name( int index ); +void print_op_name( int index ); +void print_fl_name( int index ); +void print_LnfExpNode( LnfExpNode *n ); +void print_State( State S ); + + + +void print_plan( void ); + + + +#endif /* _OUTPUT_H */ diff --git a/models/main_models/rt1/gen/ff_planner/parse.c b/models/main_models/rt1/gen/ff_planner/parse.c new file mode 100644 index 000000000..cc5a099f9 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/parse.c @@ -0,0 +1,1339 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: parse.c + * Description: Functions for the pddl parser + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + +#include "ff.h" + +#include "memory.h" +#include "output.h" + +#include "parse.h" + + + + + + + + + + + +/* simple parse helpers + */ + + + + + + + +char *copy_Token( char *s ) + +{ + + char *d = new_Token( strlen( s ) + 1 ); + strcpy(d, s); + + return d; + +} + + + +TokenList *copy_TokenList( TokenList *source ) + +{ + + TokenList *temp; + + if ( !source ) { + temp = NULL; + } else { + temp = new_TokenList(); + if ( source->item ) { + temp->item = new_Token( strlen( source->item ) + 1 ); + strcpy( temp->item, source->item ); + } + temp->next = copy_TokenList( source->next ); + } + + return temp; + +} + + + +void strupcase( char *from ) + +{ + + char tmp; + + tmp = *from; + while ('\0' != tmp) { + *from = (char) toupper((int) tmp); + tmp = *++from; + } + +} + + + +char *rmdash( char *s ) + +{ + + s++; + + for( ; (*s == ' ') || (*s == '\t'); s++ ); + + return s; + +} + + + + + + + + + + +/* typed-list-of preprocessing + */ + + + + + + + +Token ltype_names[MAX_TYPES]; +int lnum_types; + + +int leither_ty[MAX_TYPES][MAX_TYPES]; +int lnum_either_ty[MAX_TYPES]; + + + + + +void build_orig_constant_list( void ) + +{ + + char *tmp = NULL; + TypedList *tyl; + TypedListList *tyll; + TokenList *tl, *p_tl, *tmp_tl; + PlOperator *po; + + int i, j, k, n, std; + + Bool m[MAX_TYPES][MAX_TYPES]; + + FactList *fl, *p_fl; + + lnum_types = 0; + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + if ( get_type( tyl->name ) == -1 ) { + ltype_names[lnum_types++] = copy_Token( tyl->name ); + } + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + collect_type_names_in_pl( gorig_goal_facts ); + + for ( po = gloaded_ops; po; po = po->next ) { + collect_type_names_in_pl( po->preconds ); + collect_type_names_in_pl( po->effects ); + for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + + /* now get the numbers of all composed either types + */ + for ( i = 0; i < lnum_types; i++ ) { + lnum_either_ty[i] = 0; + } + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + make_either_ty_in_pl( gorig_goal_facts ); + for ( po = gloaded_ops; po; po = po->next ) { + make_either_ty_in_pl( po->preconds ); + make_either_ty_in_pl( po->effects ); + for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + + + /* now, compute the transitive closure of all type inclusions. + * first initialize the matrix. + */ + for ( i = 0; i < lnum_types; i++ ) { + for ( j = 0; j < lnum_types; j++ ) { + m[i][j] = ( i == j ? TRUE : FALSE ); + } + } + std = -1; + for ( i = 0; i < lnum_types; i++ ) { + if ( strcmp( ltype_names[i], STANDARD_TYPE ) == SAME ) { + std = i; + break; + } + } + for ( i = 0; i < lnum_types; i++ ) { + m[i][std] = TRUE;/* all types are subtypes of OBJECT */ + } + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + /* all inclusions as are defined in domain file + */ + m[get_type( tyl->name )][tyl->n] = TRUE; + } + /* compute transitive closure on inclusions matrix + */ + for ( j = 0; j < lnum_types; j++ ) { + for ( i = 0; i < lnum_types; i++ ) { + if ( m[i][j] ) { + for ( k = 0; k < lnum_types; k++ ) { + if ( m[j][k] ) { + m[i][k] = TRUE; + } + } + } + } + } + /* union types are subsets of all those types that contain all + * their components, and + * all component types are subsets of the either type ! + */ + for ( i = 0; i < lnum_types; i++ ) { + if ( lnum_either_ty[i] < 2 ) continue; + for ( j = 0; j < lnum_types; j++ ) { + if ( j == i ) continue; + /* get supertypes of all component types + */ + for ( k = 0; k < lnum_either_ty[i]; k++ ) { + if ( !m[leither_ty[i][k]][j] ) break; + } + if ( k < lnum_either_ty[i] ) continue; + m[i][j] = TRUE; + /* make components subtypes of either type + */ + for ( k = 0; k < lnum_either_ty[i]; k++ ) { + m[leither_ty[i][k]][i] = TRUE; + } + } + } + /* and again, compute transitive closure on inclusions matrix. + * I guess, this won't change anything (?), but it also won't need + * any remarkable computation time, so why should one think about it ? + */ + for ( j = 0; j < lnum_types; j++ ) { + for ( i = 0; i < lnum_types; i++ ) { + if ( m[i][j] ) { + for ( k = 0; k < lnum_types; k++ ) { + if ( m[j][k] ) { + m[i][k] = TRUE; + } + } + } + } + } + + + /* now build FactList of ALL constant -> type pairs. + * for each constant / object, let it appear separately + * for each type it is a member of; compute type + * membership based on propagating constants / objects + * through inclusions matrix. + * + * this might make the same pair appear doubly, if an object + * is declared in type T as well as in some supertype T'. + * such cases will be filtered out in string collection. + */ + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + fl->next = gorig_constant_list; + gorig_constant_list = fl; + /* now add constant to all supertypes + */ + n = get_type( fl->item->next->item ); + for ( i = 0; i < lnum_types; i++ ) { + if ( i == n || + !m[n][i] ) continue; + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + fl->item->next->item = copy_Token( ltype_names[i] ); + fl->next = gorig_constant_list; + gorig_constant_list = fl; + } + } + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + fl->next = gorig_constant_list; + gorig_constant_list = fl; + /* now add constant to all supertypes + */ + n = get_type( fl->item->next->item ); + for ( i = 0; i < lnum_types; i++ ) { + if ( i == n || + !m[n][i] ) continue; + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + fl->item->next->item = copy_Token( ltype_names[i] ); + fl->next = gorig_constant_list; + gorig_constant_list = fl; + } + } + + + /* now, normalize all typed-list-of s in domain and problem def, + * i.e., in all PlNode quantifiers and in op parameters + * + * at the same time, remove typed-listof structures in these defs + */ + normalize_tyl_in_pl( &gorig_goal_facts ); + for ( po = gloaded_ops; po; po = po->next ) { + normalize_tyl_in_pl( &po->preconds ); + normalize_tyl_in_pl( &po->effects ); + /* be careful to maintain parameter ordering ! + */ + if ( !po->parse_params ) { + continue;/* no params at all */ + } + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( po->parse_params->name ); + if ( po->parse_params->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = po->parse_params->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( po->parse_params->type->item ); + } + po->params = fl; + p_fl = fl; + for ( tyl = po->parse_params->next; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + p_fl->next = fl; + p_fl = fl; + } + free_TypedList( po->parse_params ); + po->parse_params = NULL; + } + + + /* finally, build gpredicates_and_types by chaining predicate names + * together with the names of their args' types. + */ + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->item = copy_Token( tyll->predicate ); + fl->next = gpredicates_and_types; + gpredicates_and_types = fl; + if ( !tyll->args ) continue; + /* add arg types; MAINTAIN ORDERING ! + */ + fl->item->next = new_TokenList(); + if ( tyll->args->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyll->args->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyll->args->type->item ); + } + p_tl = fl->item->next; + for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + if ( tyl->type->next ) { + tmp_tl->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->item, CONNECTOR ); + strcat( tmp_tl->item, tl->item ); + } + } else { + tmp_tl->item = copy_Token( tyl->type->item ); + } + p_tl->next = tmp_tl; + p_tl = tmp_tl; + } + } + + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->item = copy_Token( tyll->predicate ); + fl->next = gfunctions_and_types; + gfunctions_and_types = fl; + if ( !tyll->args ) continue; + /* add arg types; MAINTAIN ORDERING ! + */ + fl->item->next = new_TokenList(); + if ( tyll->args->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyll->args->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyll->args->type->item ); + } + p_tl = fl->item->next; + for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + if ( tyl->type->next ) { + tmp_tl->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->item, CONNECTOR ); + strcat( tmp_tl->item, tl->item ); + } + } else { + tmp_tl->item = copy_Token( tyl->type->item ); + } + p_tl->next = tmp_tl; + p_tl = tmp_tl; + } + } + + /* now get rid of remaining typed-list-of parsing structures + */ + free_TypedList( gparse_types ); + gparse_types = NULL; + free_TypedList( gparse_constants ); + gparse_constants = NULL; + free_TypedList( gparse_objects ); + gparse_objects = NULL; + free_TypedListList( gparse_predicates ); + gparse_predicates = NULL; + free_TypedListList( gparse_functions ); + gparse_functions = NULL; + +} + + + +void collect_type_names_in_pl( PlNode *n ) + +{ + + PlNode *i; + TypedList *tyl; + TokenList *tl; + char *tmp = NULL; + int nn; + + if ( !n ) { + return; + } + + switch( n->connective ) { + case ALL: + case EX: + for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (nn = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = nn; + } + free( tmp ); + tmp = NULL; + } + collect_type_names_in_pl( n->sons ); + break; + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + collect_type_names_in_pl( i ); + } + break; + case NOT: + collect_type_names_in_pl( n->sons ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + collect_type_names_in_pl( n->sons ); + collect_type_names_in_pl( n->sons->next ); + break; + default: + break; + } + +} + + + +int get_type( char *str ) + +{ + + int i; + + for ( i = 0; i < lnum_types; i++ ) { + if ( strcmp( str, ltype_names[i] ) == SAME ) return i; + } + + return -1; + +} + + + +void make_either_ty( TypedList *tyl ) + +{ + + TokenList *i; + + if ( lnum_either_ty[tyl->n] > 0 ) { + return; + } + + for ( i = tyl->type; i; i = i->next ) { + leither_ty[tyl->n][lnum_either_ty[tyl->n]++] = get_type( i->item ); + } + +} + + + +void make_either_ty_in_pl( PlNode *n ) + +{ + + PlNode *i; + TypedList *tyl; + + if ( !n ) { + return; + } + + switch( n->connective ) { + case ALL: + case EX: + for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + make_either_ty_in_pl( n->sons ); + break; + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + make_either_ty_in_pl( i ); + } + break; + case NOT: + make_either_ty_in_pl( n->sons ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + make_either_ty_in_pl( n->sons ); + make_either_ty_in_pl( n->sons->next ); + break; + default: + break; + } + +} + + + +void normalize_tyl_in_pl( PlNode **n ) + +{ + + PlNode *i; + TypedList *tyl; + PlNode *tmp_pl = NULL, *sons, *p_pl; + TokenList *tmp_tl, *tl; + + + if ( !(*n) ) { + return; + } + + switch( (*n)->connective ) { + case ALL: + case EX: + /* we need to make a sequence of quantifiers ( ->sons ...) + * out of the given sequence of TypedList elements, + * with connected type names, var - name in TokenList + * and KEEPING THE SAME ORDERING !! + */ + if ( !(*n)->parse_vars ) { + printf("\n\nquantifier without argument !! check input files.\n\n"); + exit( 1 ); + } + tmp_tl = new_TokenList(); + tmp_tl->next = new_TokenList(); + tmp_tl->item = copy_Token( (*n)->parse_vars->name ); + if ( (*n)->parse_vars->type->next ) { + tmp_tl->next->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->next->item, EITHER_STR ); + for ( tl = (*n)->parse_vars->type; tl; tl = tl->next ) { + strcat( tmp_tl->next->item, CONNECTOR ); + strcat( tmp_tl->next->item, tl->item ); + } + } else { + tmp_tl->next->item = copy_Token( (*n)->parse_vars->type->item ); + } + (*n)->atom = tmp_tl; + /* now add list of sons + */ + sons = (*n)->sons; + p_pl = *n; + for ( tyl = (*n)->parse_vars->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + tmp_tl->next = new_TokenList(); + tmp_tl->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + tmp_tl->next->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->next->item, CONNECTOR ); + strcat( tmp_tl->next->item, tl->item ); + } + } else { + tmp_tl->next->item = copy_Token( tyl->type->item ); + } + tmp_pl = new_PlNode( (*n)->connective ); + tmp_pl->atom = tmp_tl; + p_pl->sons = tmp_pl; + p_pl = tmp_pl; + } + /* remove typed-list-of info + */ + free_TypedList( (*n)->parse_vars ); + (*n)->parse_vars = NULL; + /* the last son in list takes over ->sons + */ + p_pl->sons = sons; + /* normalize this sons and get out + */ + normalize_tyl_in_pl( &(p_pl->sons) ); + break; + case AND: + case OR: + for ( i = (*n)->sons; i; i = i->next ) { + normalize_tyl_in_pl( &i ); + } + break; + case NOT: + normalize_tyl_in_pl( &((*n)->sons) ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + normalize_tyl_in_pl( &((*n)->sons) ); + normalize_tyl_in_pl( &((*n)->sons->next) ); + break; + default: + break; + } + +} + + + + + + + + + + + + +/* ADL syntax test - and normalization (AND s etc.) + */ + + + + + + + + + + + + +Bool make_adl_domain( void ) + +{ + + PlOperator *i; + FactList *ff; + + if ( gcmd_line.display_info == 101 ) { + printf("\noriginal problem parsing is:\n"); + printf("\nobjects:"); + for ( ff = gorig_constant_list; ff; ff = ff->next ) { + printf("\n%s : %s", ff->item->item, ff->item->next->item); + } + printf("\n\ninitial state:\n"); + print_PlNode( gorig_initial_facts, 0 ); + printf("\n\ngoal state:\n"); + print_PlNode( gorig_goal_facts, 0 ); + printf("\n\nops:"); + print_plops( gloaded_ops ); + } + + if ( !make_conjunction_of_atoms( &gorig_initial_facts ) ) { + printf("\nillegal initial state"); + return FALSE; + } + + if ( !gorig_goal_facts ) { + gorig_goal_facts = new_PlNode( TRU ); + } + + if ( !is_wff( gorig_goal_facts ) ) { + printf("\nillegal goal formula"); + print_PlNode( gorig_goal_facts, 0 ); + return FALSE; + } + + for ( i = gloaded_ops; i; i = i->next ) { + if ( !i->preconds ) { + i->preconds = new_PlNode( TRU ); + } + if ( !is_wff( i->preconds ) ) { + printf("\nop %s has illegal precondition", i->name); + return FALSE; + } + if ( !make_effects( &(i->effects) ) ) { + printf("\nop %s has illegal effects", i->name); + return FALSE; + } + } + + if ( gcmd_line.display_info == 102 ) { + printf("\nfinal ADL representation is:\n"); + printf("\nobjects:"); + for ( ff = gorig_constant_list; ff; ff = ff->next ) { + printf("\n%s : %s", ff->item->item, ff->item->next->item); + } + printf("\n\ninitial state:\n"); + print_PlNode( gorig_initial_facts, 0 ); + printf("\n\ngoal formula:\n"); + print_PlNode( gorig_goal_facts, 0 ); + printf("\n\nops:"); + print_plops( gloaded_ops ); + } + + return TRUE; + +} + + + +Bool make_conjunction_of_atoms( PlNode **n ) + +{ + + PlNode *tmp, *i, *p, *m; + + if ( !(*n) ) { + return TRUE; + } + + if ( (*n)->connective != AND ) { + switch ( (*n)->connective ) { + case ATOM: + tmp = new_PlNode( ATOM ); + tmp->atom = (*n)->atom; + (*n)->atom = NULL; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + case COMP: + tmp = new_PlNode( COMP ); + tmp->comp = (*n)->comp; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->comp = -1; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + case NOT: + free_PlNode( *n ); + (*n) = NULL; + return TRUE; + default: + return FALSE; + } + } + + p = NULL; + i = (*n)->sons; + while ( i ) { + switch ( i->connective ) { + case ATOM: + break; + case COMP: + break; + case NOT: + if ( p ) { + p->next = i->next; + } else { + (*n)->sons = i->next; + } + m = i->next; + i->next = NULL; + free_PlNode( i ); + i = m; + break; + default: + return FALSE; + } + if ( i->connective != NOT ) { + p = i; + i = i->next; + } + } + + return TRUE; + +} + + + +Bool is_wff( PlNode *n ) + +{ + + PlNode *i; + + if ( !n ) { + return FALSE; + } + + switch( n->connective ) { + case ALL: + case EX: + if ( !(n->atom) || + !(n->atom->next ) || + n->atom->next->next != NULL ) { + return FALSE; + } + return is_wff( n->sons ); + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + if ( !is_wff( i ) ) { + return FALSE; + } + } + return TRUE; + case NOT: + return is_wff( n->sons ); + case ATOM: + if ( !(n->atom) || + n->sons != NULL ) { + return FALSE; + } + return TRUE; + case TRU: + case FAL: + if ( n->sons != NULL ) { + return FALSE; + } + return TRUE; + case COMP: + if ( n->sons != NULL || + n->atom != NULL || + n->lh == NULL || + n->rh == NULL || + n->comp < 0 ) { + return FALSE; + } + return TRUE; + default: + return FALSE; + } + +} + + + +Bool make_effects( PlNode **n ) + +{ + + PlNode *tmp, *i, *literals, *j, *k, *next; + int m = 0; + + if ( (*n)->connective != AND ) { + if ( !is_eff_literal( *n ) && + (*n)->connective != ALL && + (*n)->connective != WHEN ) { + return FALSE; + } + tmp = new_PlNode( (*n)->connective ); + tmp->atom = (*n)->atom; + tmp->sons = (*n)->sons; + tmp->neft = (*n)->neft; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->connective = AND; + (*n)->sons = tmp; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->neft = -1; + } + + for ( i = (*n)->sons; i; i = i->next ) { + if ( is_eff_literal( i ) ) { + m++; + continue; + } + if ( i->connective == AND ) { + for ( j = i->sons; j; j = j->next ) { + if ( !is_eff_literal( j ) ) { + return FALSE; + } + m++; + } + continue; + } + if ( i->connective == ALL ) { + for ( j = i->sons; j && j->connective == ALL; j = j->sons ) { + if ( !j->atom || + !j->atom->next || + j->atom->next->next != NULL ) { + return FALSE; + } + } + if ( !j ) { + return FALSE; + } + if ( is_eff_literal( j ) ) { + tmp = new_PlNode( AND ); + for ( k = i; k->sons->connective == ALL; k = k->sons ); + k->sons = tmp; + tmp->sons = j; + j = tmp; + } + if ( j->connective == AND ) { + for ( k = j->sons; k; k = k->next ) { + if ( !is_eff_literal( k ) ) { + return FALSE; + } + } + tmp = new_PlNode( WHEN ); + for ( k = i; k->sons->connective == ALL; k = k->sons ); + k->sons = tmp; + tmp->sons = new_PlNode( TRU ); + tmp->sons->next = j; + continue; + } + if ( j->connective != WHEN ) { + return FALSE; + } + if ( !(j->sons) ) { + j->sons = new_PlNode( TRU ); + } + if ( !is_wff( j->sons ) ) { + return FALSE; + } + if ( !make_conjunction_of_literals( &(j->sons->next) ) ) { + return FALSE; + } + continue; + } + if ( i->connective != WHEN ) { + return FALSE; + } + if ( !(i->sons) ) { + i->sons = new_PlNode( TRU ); + } + if ( !is_wff( i->sons ) ) { + return FALSE; + } + if ( !make_conjunction_of_literals( &(i->sons->next) ) ) { + return FALSE; + } + } + + if ( m == 0 ) { + return TRUE; + } + + tmp = new_PlNode( WHEN ); + tmp->sons = new_PlNode( TRU ); + literals = new_PlNode( AND ); + tmp->sons->next = literals; + tmp->next = (*n)->sons; + (*n)->sons = tmp; + i = (*n)->sons; + while ( i->next ) { + if ( is_eff_literal( i->next ) ) { + next = i->next->next; + i->next->next = literals->sons; + literals->sons = i->next; + i->next = next; + continue; + } + if ( i->next->connective == AND ) { + next = i->next->next; + for ( j = i->next->sons; j && j->next; j = j->next ); + if ( j ) { + j->next = literals->sons; + literals->sons = i->next->sons; + } + i->next = next; + continue; + } + i = i->next; + } + return TRUE; + +} + + + +Bool is_eff_literal( PlNode *n ) + +{ + + if ( !n ) { + return FALSE; + } + + if ( n->connective == NOT ) { + if ( !n->sons || + n->sons->connective != ATOM || + !n->sons->atom ) { + return FALSE; + } + return TRUE; + } + + if ( n->connective == ATOM ) { + if ( !n->atom ) { + return FALSE; + } + return TRUE; + } + + if ( n->connective == NEF ) { + if ( !n->lh || + !n->rh || + n->neft < 0 ) { + return FALSE; + } + return TRUE; + } + + return FALSE; + +} + + + +Bool make_conjunction_of_literals( PlNode **n ) + +{ + + PlNode *tmp, *i; + + if ( !(*n) ) { + return FALSE; + } + + if ( (*n)->connective != AND ) { + if ( (*n)->connective == NOT ) { + if ( !((*n)->sons) || + (*n)->sons->connective != ATOM ) { + return FALSE; + } + tmp = new_PlNode( NOT ); + tmp->sons = (*n)->sons; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + if ( (*n)->connective == NEF ) { + tmp = new_PlNode( NEF ); + tmp->neft = (*n)->neft; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->neft = -1; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + if ( (*n)->connective != ATOM ) { + return FALSE; + } + tmp = new_PlNode( ATOM ); + tmp->atom = (*n)->atom; + (*n)->atom = NULL; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + + for ( i = (*n)->sons; i; i = i->next ) { + if ( !is_eff_literal( i ) ) { + return FALSE; + } + } + + return TRUE; + +} + + diff --git a/models/main_models/rt1/gen/ff_planner/parse.h b/models/main_models/rt1/gen/ff_planner/parse.h new file mode 100644 index 000000000..f9924c085 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/parse.h @@ -0,0 +1,63 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: parse.h + * Description: Functions for the pddl parser + * + * Author: Frank Rittinger 1998 / Joerg Hoffmann 1999 + * + *********************************************************************/ + + + + + +#ifndef _PARSE_H +#define _PARSE_H + + + +char *copy_Token( char *s ); +TokenList *copy_TokenList( TokenList *source ); +void strupcase( char *from ); +char *rmdash( char *s ); + + + +void build_orig_constant_list( void ); +void collect_type_names_in_pl( PlNode *n ); +int get_type( char *str ); +void make_either_ty( TypedList *tyl ); +void make_either_ty_in_pl( PlNode *n ); +void normalize_tyl_in_pl( PlNode **n ); + + + +Bool make_adl_domain( void ); +Bool make_conjunction_of_atoms( PlNode **n ); +Bool is_wff( PlNode *n ); +Bool make_effects( PlNode **n ); +Bool is_eff_literal( PlNode *n ); +Bool make_conjunction_of_literals( PlNode **n ); + + + +#endif /* PARSE */ diff --git a/models/main_models/rt1/gen/ff_planner/relax.c b/models/main_models/rt1/gen/ff_planner/relax.c new file mode 100644 index 000000000..dd657ac60 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/relax.c @@ -0,0 +1,2756 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: relax.c + * Description: this file handles the relaxed planning problem, i.e., + * the code is responsible for the heuristic evaluation + * of states during search. + * + * --- THE HEART PEACE OF THE FF PLANNER ! --- + * + * here: linear tasks +=,-=,:= / le / le le + * + * + * Author: Joerg Hoffmann 2000--2002, 2011 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "relax.h" +#include "search.h" + + + + + + + +/* local globals + */ + + + + + + + + +/* fixpoint + */ +int *lF; +int lnum_F; +int *lE; +int lnum_E; + +int *lch_E; +int lnum_ch_E; + +int *l0P_E; +int lnum_0P_E; + + + + + +/* 1P extraction + */ +int **lgoals_at; +int *lnum_goals_at; + +float **lf_goals_c_at; +Comparator **lf_goals_comp_at; + +int lh; + +int *lch_F; +int lnum_ch_F; + +int *lused_O; +int lnum_used_O; + +int *lin_plan_E; +int lnum_in_plan_E; + + +/* helpful actions numerical helpers + */ +Comparator *lHcomp; +float *lHc; + + + + + + + + + + + + + + + + + + + + +/************************************* + * helper, for -1 == INFINITY method * + *************************************/ + + + + + + + + + + + + +Bool LESS( int a, int b ) + +{ + + if ( a == INFINITY ) { + return FALSE; + } + + if ( b == INFINITY ) { + return TRUE; + } + + return ( a < b ? TRUE : FALSE ); + +} + + + +Bool FLOAT_LE( float a, float b ) + +{ + + if ( b == INFINITY ) { + return TRUE; + } + + if ( a == INFINITY ) { + return FALSE; + } + + return ( a <= b ? TRUE : FALSE ); + +} + + + + + + + + + + + + + + +/*********************************** + * FUNCTIONS ACCESSED FROM OUTSIDE * + ***********************************/ + + + + + + + + + + + + + + + + + +int get_1P( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + } else { + h = INFINITY; + } + + reset_fixpoint( max ); + + return h; + +} + + + +int get_1P_and_H( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + collect_H_info(); + } else { + h = INFINITY; + } + + reset_fixpoint( max ); + + return h; + +} + + + +int get_1P_and_A( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + } else { + h = INFINITY; + } + + collect_1P_and_A_info(); + reset_fixpoint( max ); + + return h; + +} + + + +void collect_1P_and_A_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_1P_and_A_info"); + } + + for ( i = 0; i < gnum_A; i++ ) { + gop_conn[gA[i]].is_in_A = FALSE; + } + gnum_A = 0; + + for ( i = 0; i < lnum_E; i++ ) { + if ( gef_conn[lE[i]].level != 0 ) break; + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; + gA[gnum_A++] = gef_conn[lE[i]].op; + } + +} + + + +void get_A( State *S ) + +{ + + int i; + + initialize_fixpoint( S ); + + for ( i = 0; i < lnum_F; i++ ) { + activate_ft( lF[i], 0 ); + } + for ( i = 0; i < lnum_0P_E; i++ ) { + if ( gef_conn[l0P_E[i]].in_E ) { + continue; + } + new_ef( l0P_E[i] ); + } + for ( i = 0; i < gnum_fl_conn; i++ ) { + activate_fl( i, 0 ); + } + + collect_A_info(); + + /* 0 should be enough here... + */ + reset_fixpoint( 1 ); + +} + + + +void collect_A_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_A_info"); + } + + for ( i = 0; i < gnum_A; i++ ) { + gop_conn[gA[i]].is_in_A = FALSE; + } + gnum_A = 0; + + for ( i = 0; i < lnum_E; i++ ) { + /* levels are not set unless we actually build the RPG! +/* if ( gef_conn[lE[i]].level != 0 ) break; */ + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; + gA[gnum_A++] = gef_conn[lE[i]].op; + } + +} + + + +void get_A_axioms( State *S ) + +{ + + int i; + + initialize_fixpoint( S ); + + for ( i = 0; i < lnum_F; i++ ) { + activate_ft( lF[i], 0 ); + } + for ( i = 0; i < lnum_0P_E; i++ ) { + if ( gef_conn[l0P_E[i]].in_E ) { + continue; + } + new_ef( l0P_E[i] ); + } + for ( i = 0; i < gnum_fl_conn; i++ ) { + activate_fl( i, 0 ); + } + + collect_A_axioms_info(); + + /* 0 should be enough here... + */ + reset_fixpoint( 1 ); + +} + + + +void collect_A_axioms_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA_axioms = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A_axioms = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_A_axioms_info"); + } + + for ( i = 0; i < gnum_A_axioms; i++ ) { + gop_conn[gA_axioms[i]].is_in_A_axioms = FALSE; + } + gnum_A_axioms = 0; + + for ( i = 0; i < lnum_E; i++ ) { + /* levels are not set unless we actually build the RPG! +/* if ( gef_conn[lE[i]].level != 0 ) break; */ + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A_axioms ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( !gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- no axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + + gop_conn[gef_conn[lE[i]].op].is_in_A_axioms = TRUE; + gA_axioms[gnum_A_axioms++] = gef_conn[lE[i]].op; + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +/******************************* + * RELAXED FIXPOINT ON A STATE * + *******************************/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Bool build_fixpoint( State *S, int *max ) + +{ + + int start_ft, stop_ft, start_ef, stop_ef, i, time = 0; + float costlevel; + + initialize_fixpoint( S ); + + start_ft = 0; + start_ef = 0; + while ( TRUE ) { + if ( gcmd_line.debug ) { + printf("\n======================================FP time %d", time); + } + + if ( all_goals_activated( time ) ) { + break; + } + if ( time > 0 || lnum_0P_E == 0 ) { + if ( start_ft == lnum_F ) { + if ( fluents_hopeless( time ) ) { + /* fixpoint, goals not reached + */ + *max = time; + return FALSE; + } + } + } + /* make space if necessary, and copy over + * info from time to time+1 for fluents + */ + extend_fluent_levels( time ); + for ( i = 0; i < gnum_fl_conn; i++ ) { + if ( gfl_conn[i].def[time] ) { + gfl_conn[i].def[time+1] = TRUE; + gfl_conn[i].level[time+1] = gfl_conn[i].level[time]; + } + } + + /* determine the next effect layer: + * - activate the facts + * - if level 0 activate the no preconds-ops + * - activate the fluents at their ;UFhfQoG<2!dn0!_Zi=71_+$Qc literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json new file mode 100644 index 000000000..3fd08680a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "KeyChain", + "Television", + "Window", + "Bowl", + "GarbageCan", + "CreditCard", + "TVStand", + "Cabinet", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json new file mode 100644 index 000000000..6a7f82072 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json @@ -0,0 +1,122 @@ +{ + "ArmChair|+02.34|+00.00|-02.04": [ + 1.5, + -2.0, + 90, + 30 + ], + "Cabinet|-01.83|+00.73|-02.36": [ + -0.75, + -1.75, + 270, + 30 + ], + "CoffeeTable|+00.02|00.00|-01.11": [ + 0.25, + -1.75, + 0, + 30 + ], + "GarbageCan|+00.74|00.00|-02.52": [ + 1.25, + -2.0, + 270, + 30 + ], + "Shelf|+00.34|+00.27|-02.38": [ + 1.0, + -1.25, + 270, + 30 + ], + "Shelf|+00.34|+00.47|-02.38": [ + 1.0, + -1.25, + 270, + 30 + ], + "Shelf|+00.34|+00.64|-02.38": [ + 1.0, + -1.0, + 180, + 0 + ], + "Shelf|-00.39|+00.30|-02.38": [ + -1.0, + -1.25, + 90, + 30 + ], + "Shelf|-00.39|+00.60|-02.38": [ + -1.0, + -1.0, + 180, + 0 + ], + "Shelf|-01.73|+00.28|-01.63": [ + -1.0, + -1.25, + 270, + 30 + ], + "Shelf|-01.73|+00.30|-00.48": [ + -0.5, + 0.25, + 180, + 30 + ], + "Shelf|-01.73|+00.45|-01.06": [ + -0.75, + -0.5, + 180, + 30 + ], + "Shelf|-01.73|+00.48|-01.63": [ + -0.25, + -1.75, + 270, + 0 + ], + "Shelf|-01.73|+00.60|-00.48": [ + -0.75, + 0.0, + 180, + 30 + ], + "Shelf|-01.73|+00.65|-01.63": [ + -0.5, + -1.75, + 270, + 0 + ], + "Shelf|-01.83|+01.45|-02.36": [ + -0.75, + -1.75, + 270, + -30 + ], + "Shelf|-01.83|+02.04|-02.36": [ + -0.75, + -1.75, + 270, + 0 + ], + "Sofa|+00.12|+00.01|+01.03": [ + -0.5, + 0.25, + 0, + 30 + ], + "TVStand|-00.03|00.00|-02.39": [ + 0.0, + -1.75, + 180, + 30 + ], + "TVStand|-01.73|00.00|-01.06": [ + -1.0, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a0929c7eba7ca9916298aef2062af25a96cebc6a GIT binary patch literal 2352 zcmbW(txhvR6b9gh5JCtSv2G!$0Spk5R^cER1d24!20?(d1VgwAE~vM#mw-gBs6Zh2 z+4GDzlA6ggbI#0r*iU?KXBVgEmn+qC_0rr-=GU|4sBVs@2hE^vrVq2H+4%nIVRke5 z-9H)M%_l$m^V{*`4(XXGeek8vS(|K~2yiEQ~_TF;Q z-|Ibok9}^F`>v`g=W##F%OB~yOO{u?ylj;_ukzcMpWDdK@^c$`SbmnDyHvkSmS4Sm zR{6M%d@LW!$MUg!EFa6q^08H}yvk=^K9-N=WBFJ<_I`OM{+_I#^|StxEBaYK>u3FC z4)4dR-?@I)U*?WJ*3bG`f3D-a>M#3?eiHlcWp$ia?=Mqs*3bGmul{}6cfWn#o!iLI zz6-aJi_ORKv3x8C=T-ezyrZ7gv-)b(CsohtS^a9NXZ6ML_gGV(?7ngyx!HZi(Z8PV zWB0Ln*nP!u-$uHRyL9gRJNNy$P4!j$%K5P0VBep8e>M-Bhs{$Q?{B7g*gR|=HV>PJ h&BJZX!{%Z0u>TiqrF<+O%g6Gud@LW!$MS8Bz5%}cShoNG literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json new file mode 100644 index 000000000..96571469e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json @@ -0,0 +1,27 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Cabinet", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json new file mode 100644 index 000000000..3c460de3b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|+00.40|+00.01|+02.19": [ + 0.5, + 1.5, + 0, + 30 + ], + "ArmChair|-00.63|+00.01|+02.19": [ + -0.75, + 1.5, + 0, + 30 + ], + "Cabinet|-01.77|+00.73|-01.59": [ + -1.0, + -1.25, + 270, + 30 + ], + "CoffeeTable|-00.15|+00.00|+00.42": [ + -0.75, + 0.5, + 90, + 30 + ], + "Shelf|+01.66|+00.27|+00.61": [ + 0.5, + 0.0, + 0, + 30 + ], + "Shelf|+01.66|+00.30|-00.12": [ + 0.5, + 0.5, + 180, + 30 + ], + "Shelf|+01.66|+00.44|+00.24": [ + 0.5, + 0.75, + 180, + 30 + ], + "Shelf|+01.66|+00.47|+00.61": [ + 0.5, + 0.0, + 0, + 30 + ], + "Shelf|+01.66|+00.60|-00.12": [ + 0.75, + -0.5, + 0, + 30 + ], + "Shelf|+01.66|+00.64|+00.61": [ + 0.75, + 0.25, + 0, + 30 + ], + "Shelf|-01.77|+01.45|-01.59": [ + -1.0, + -1.5, + 270, + 30 + ], + "Shelf|-01.77|+01.74|-01.59": [ + -0.75, + -1.5, + 270, + 30 + ], + "Shelf|-01.77|+02.04|-01.59": [ + -1.0, + -1.5, + 270, + 0 + ], + "SideTable|-01.57|00.00|+01.82": [ + -1.25, + 2.5, + 180, + 30 + ], + "Sofa|-01.45|+00.01|+00.42": [ + -0.75, + 0.5, + 270, + 30 + ], + "TVStand|+01.67|00.00|+00.24": [ + 1.0, + 0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..70465ddc524364501d653330bac2ce093f8ef854 GIT binary patch literal 3376 zcmbW&u}U0a6vgo`K}19(<_V^o1hx=uBm~wfUBo6us<6bB6hUP-qzQS7Jdi%ZJc6a= z6jN-mg=Y8r340(-rn&s@eD|DlXJ>c+oPGLu{`p1uS$?$_)A`p~`>tu)^&t3F@XO#5 zyu2-|>tDL`Rr;7drjO}kl}=WA`t&e8OmDyLrH|=hdYB%jw-#nRW`j|fUoG~4oRUUnLusqn_=ICSRa8~;I z^zr?8y(gw`jy`q{XQi*dsNY9?AKX>{=lj7A!F})$ya<+GF8MKEoK=4P;dcGJa3A~- zY+vWQxW85_#eMr?`(pdz#dtH1{p7YEex9p2^i}&|`(gWG`(gWG`LX<1ek`vX@?z(3 zR(bX1#qwf#usm2Ey7FLousNJn9({Q*f6U(;f6O2A$8>O3{`y^gFED@S_+$Q*t|QU!Oki>Um5b)4^GX znCGWI)aQ-6dLHw`{4hV9)%(Awy8JPJ%pdc|{4sybANxI6R{v$)7t4d?!RE{9`b{#A J&13WB^brgf0D%Ai literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json new file mode 100644 index 000000000..0bee20c25 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "GarbageCan", + "CreditCard", + "Ottoman", + "TVStand", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "Shelf", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json new file mode 100644 index 000000000..ef1237543 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|-00.56|+00.00|+01.95": [ + 0.25, + 1.5, + 270, + 30 + ], + "DiningTable|-03.10|+00.00|-03.61": [ + -2.25, + -3.5, + 270, + 30 + ], + "Drawer|+01.76|+00.77|+01.09": [ + 0.75, + 1.25, + 90, + 0 + ], + "GarbageCan|-01.34|+00.02|-04.83": [ + -2.0, + -4.5, + 90, + 30 + ], + "Ottoman|-00.58|+00.01|+01.05": [ + -1.25, + 1.75, + 180, + 30 + ], + "Shelf|-00.61|+00.88|-02.83": [ + -0.5, + -2.0, + 180, + 30 + ], + "Shelf|-00.61|+01.32|-02.83": [ + -0.5, + -2.0, + 180, + 30 + ], + "Shelf|-02.24|+00.27|+00.40": [ + -1.0, + -0.25, + 0, + 30 + ], + "Shelf|-02.24|+00.30|+01.13": [ + -1.0, + 0.5, + 0, + 30 + ], + "Shelf|-02.24|+00.44|+00.76": [ + -1.25, + 1.25, + 180, + 30 + ], + "Shelf|-02.24|+00.47|+00.40": [ + -0.75, + 0.5, + 270, + 0 + ], + "Shelf|-02.24|+00.60|+01.13": [ + -1.25, + 1.5, + 180, + 30 + ], + "Shelf|-02.24|+00.64|+00.40": [ + -1.25, + 0.75, + 180, + 30 + ], + "SideTable|+01.83|+00.00|+01.09": [ + 1.25, + 1.25, + 90, + 30 + ], + "Sofa|+00.88|+00.01|-00.59": [ + -0.25, + -0.5, + 90, + 30 + ], + "TVStand|-02.24|00.00|+00.76": [ + -1.5, + 1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e0abd893f321db939292b31685e32617dbd38425 GIT binary patch literal 4816 zcmbW)Juh=%7{KvEq>)C%`}@n;4oRn45VMU~3?@0z(-=hMR4n3C_(1hhIvNcIgF)5( zTdtAi;7M~PhZb3&n~VevZw61=v4iix;V~@lkQ>B%8PEVeyq#;>t5Zde(#@_ zcl~N~zkgdkR3q=Tj}BUSd%u;xPW1+NCL1b+>(@t2>sl^$P6 z*Uezh?{Ux1o}WEGdwyOHKi_@V`SAE$@NDo*a5H#1xDh-RJQuFpu98k2@#Ft9`j|Uu<7&Uu<982=myN$L)*l zi|vc;i|vc;%Q@_e?ThV;?ThV;?ThV;?ThV;?ThV;^<{loU)GoPWqny+)|d5VeOX_> z7y7cktS{@!`m(;PFYC+tvc9Y@>&yDGzN|0n%lfjutS{@!`m$c;)Qk0Ey;v{Si}hl? zSTBxOz1-J}^6oV!c=|*27$SupX=j>%n@k9_)EJUd`{m`PuwzejUxv=4bP> z`PuwzUiQ3fUN$eAm(6R>=4JD;dD*;dUN$eAm(9!OW%IIm{T`Z^&CBLx^Rju_ylh@J zFPoRm%jWfWVqP{co0rYY=4JD;dD*;dUN$d#ee!o~el|awpUuzaXY;f9+5BvNHb0x6 zy`TAa-p|x^=7?U&tdAVAM3~Z Rv3{%{n~%-M=40~>2S4)mgUSE^ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json new file mode 100644 index 000000000..de861c186 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "WateringCan", + "Dresser", + "Drawer", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Shelf", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json new file mode 100644 index 000000000..79c456774 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json @@ -0,0 +1,62 @@ +{ + "ArmChair|-04.33|+00.00|-03.53": [ + -4.0, + -4.25, + 0, + 30 + ], + "CoffeeTable|-02.47|+00.00|-02.49": [ + -1.75, + -2.5, + 270, + 30 + ], + "Drawer|-02.98|+00.17|-05.01": [ + -3.75, + -4.5, + 90, + 30 + ], + "Drawer|-04.02|+00.17|-05.01": [ + -3.25, + -4.5, + 270, + 30 + ], + "Dresser|-03.51|+00.00|-05.10": [ + -3.25, + -4.5, + 180, + 30 + ], + "GarbageCan|-00.97|-00.03|-05.06": [ + -1.5, + -4.75, + 90, + 30 + ], + "Shelf|-02.48|+00.12|-02.49": [ + -1.5, + -2.5, + 270, + 30 + ], + "SideTable|-02.02|+00.00|-05.08": [ + -2.5, + -4.5, + 90, + 30 + ], + "SideTable|-05.43|+00.00|-05.12": [ + -6.25, + -4.5, + 180, + 30 + ], + "Sofa|-04.36|+00.01|-02.09": [ + -3.5, + -2.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..762df682bbf580e2ff5a25f678c95c1078234285 GIT binary patch literal 1584 zcmbW#u}Z^G6b9g{h)ACzTNJYBq#|^4Q(PRJq}Y@WVkHq5@hN;D`v`f2j*b}|92~6X zeu!r@LoeS+&-qW%zMNm4U0iLX$MjTA>-MH8kBjnTc34(LIa@Rj&E)QS(M;>_`sw7h zt=IK-KDn>g-aXo{ii5qXcrN~XjndE6y$26WT6c9uN&*Y|bad47gQyj!fA}-=n_&~jn;3IVG zn4v?54%TzeXYfCImhkCK?!CY7&|h!gy*Yk=Cw)&p7AKqC$L-=pw|IH_e6j2nr)S%5 z+x3?ZXWNs_-@m_Jf8K3w|GxXQ{<^vKlhw1;vRge}c0arSJd;$;!+!Yu{c8Ap5PT4P zKlpL=Mg9Fzu=~62{_OtjewX2X{HWfa4}(3=b^-93h%?-hrJJbAND>xt^IfsJPvMyN5T8L&;9IUd#=MCwukLud)OYfhwWi| z*dDfr?O}V^o|~|T?O}V^9=3<=VSCsfwukLud)OYfC*@SmQ9pdLJ!}u#!}hQ}Y!BPR zZFv4D*dE`vhwW){D#sqShwWi|*dF%(i~WD(dwnX0?*`96oV!c=|){FIGy;v{Si`#zK$$D`UuBYIe^M8MT9efq6 zzx(UY`nP$wul}q*>(BbL{;WUi&-%0etUv3|`m_G5Kezp`llA8&T-V=q{aJt3pY><` zS^se!-b;VhpY><`S%21_^=JKAf7YM%=V|T5`m_GrhVSd|dK0ee@4Ei1KkLu>v;M6A zB&TxpXZ=}!)}Qrf{aJt3pY><`c~<-IG+2Mv_2)KxUw_y2XZ=}!)}Qrf{aJt3f0|P{ z`m_G5KkLu>v;M3<>(BbL{yeMwSbx@^$Km^Ju>QWUKkLu>v;M3<>(BbL{<`S%21_^=JKAf1cF7tQYIWda+)t7wa_-y;v{Si}hl?_@KT&>&1GpUaS}E O#d@**Y(LvS&wl_7N|d$$ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json new file mode 100644 index 000000000..bae18ef7d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "Ottoman", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "Dresser", + "Chair", + "DogBed", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json new file mode 100644 index 000000000..d38e8c23d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|-04.38|+00.01|+01.40": [ + -3.5, + 1.5, + 270, + 30 + ], + "Drawer|-00.36|+00.21|+03.80": [ + -1.5, + 3.25, + 0, + 30 + ], + "Drawer|-00.36|+00.21|+04.22": [ + -1.5, + 3.5, + 0, + 30 + ], + "Drawer|-00.36|+00.58|+03.79": [ + -1.25, + 3.25, + 0, + 30 + ], + "Drawer|-00.36|+00.59|+04.22": [ + -1.25, + 3.75, + 0, + 30 + ], + "Drawer|-02.29|+00.27|+04.11": [ + -1.75, + 3.5, + 0, + 30 + ], + "Drawer|-02.29|+00.75|+04.11": [ + -1.75, + 3.5, + 0, + 30 + ], + "Drawer|-02.83|+00.27|+04.11": [ + -2.25, + 3.25, + 270, + 30 + ], + "Drawer|-02.84|+00.75|+04.11": [ + -2.25, + 3.5, + 0, + 30 + ], + "Dresser|-00.27|+00.00|+04.01": [ + -0.75, + 4.0, + 90, + 30 + ], + "Dresser|-02.56|+00.01|+04.22": [ + -3.5, + 4.0, + 90, + 30 + ], + "Ottoman|-01.77|+00.00|+01.81": [ + -1.0, + 1.25, + 270, + 30 + ], + "SideTable|-00.25|+00.00|+02.10": [ + -0.75, + 3.0, + 90, + 30 + ], + "SideTable|-04.29|+00.01|+00.41": [ + -4.75, + 0.25, + 90, + 30 + ], + "SideTable|-06.72|+00.01|+00.00": [ + -6.25, + 0.5, + 180, + 30 + ], + "Sofa|-02.52|+00.01|+00.26": [ + -2.5, + 1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2bf7794512207ebc0a5eccdf4735e852efdff612 GIT binary patch literal 2240 zcmbW&F-ikL6b9fGL?n2K?N%X;u@MoH%1*Jdu##XBEW}76HsUEfP_8gXNSShrEmEW~ zy7L8mrD?`*XZF4S?PBtEb9a4vzgN5$AJu3)f1FhpWpz0@uexP5naiakGI$7Ps7*o*2kx3y>8h%>6V}6KR=z~_p@BI>n5)$xZN#^-G2Y?`DJjO?_cM2 z6|A3q{a8OvxjyU1tFT`OH^J-R{XyGNy@O!$G>i6}dDuK`9&Ya{3QoB{n}^NAbvSPx z`{vqxvn0o$Leuh)vLq* zEvv`samw?tx5G)@yqd$lJly1Zjr)S-u`dtH!}72^EDy`WzOUl6(8w)E#1Y%*tfUz;2!UN$EI07Xl#TFD4 z{_H#?eu<6SjL+=PygQhEzr4PEQ8pG98Y- z=g$WZv(eZ5?0)bx`trf?QMZ$y9Cq@z{GUfF`#JVMs&O^1#&&QkxEb6Ct_RnGv*2x7 z*ZP}aeaq0t`dA+~(t50q^|3zI$NIQTUA+Foi|}6TK8|CSj@^8(n&4&dI=Bqp1aE`0 z{_p44g6qMJ;AU_u*zcUB!~3)M;y5l+uX*p!t8iYg^Lkk?>*aReU)88zhkn-2?&dh^ zH?N=dvwqgk`dL5gx2}HH&-&SOIF9u3F}pY^kT*1ub4o_?3`f9$+|*3Y}=ru)qs z^|OA~&-z(E>tCn!>_6Lo*3XM{AM0o9a2(5Uzwd$Td=J?7fNTA#i0u#CAGSYif7t%8 M{n6=qc756V1VFa#_6Y@zY07o?RFp$EVfH!{Zl6t9y&p{a5>|y~XO)yQ2?B z2XCLhJ9>F|`u@X%H^+x3?;pQDcz<}3ckk}+?=9}$+FN{H{O7SVPLIvC_1WwA`E~nx z{e0e39yf|FX8tkfub$7F%41o)^3Z2qFa2C!AG~t<;rg1tS?gCGtKyw+o#*5B`Mjw- z?i8;)_KJ7r@B8$-oafKHsT_YepXT|(E5{$spLxFU%JGNuXMVT(S04PDuN>bv->%Ou zUOB#TzGc3@mG7D38|N3VJov>c$2ZQm>+_3Oj&GcA^ZeqK;~VGOJimD5>~EZJ^Zerc zj(OO>GsZ8@Ctf*zaemG7iB}$c;+5kU=hyZ5#4E=y&aZhs@yhXw^J|`8oZoK`w(l(0 z+t-=n7v~eN9KSff=J~`c$1l#Wc|P&VgHOD2{Nnt&KA(8y_;o&C-?#qaYvzB?*U9<9 z^)p{NeQ|xw>xWlPU+3%lqx#OAzPP@)et6~d#q~9>A6_|qov-iD>N|7#;`-wH;g!=D z*Vnv$c;)oPeV%@8`wsnQ-c(M1Tz~WW;+4}M*WbLpc;)oR_5WS{XHI`yU%Yaj2e{{f z?DOk-?hmh=`^DX_dH07`&i&%<_fOsL%(-9O{o$2!zqtD~?|Fw;&hroV{4>uNUOCS{ zoImq?;g$1y3Fpte?-SYY`LQ0S$ENb&7q2{)>(jB5V}15FzGu$o1Lqs(7q6V(OE}-= z`Nb>$`#zuj_%_e4`O4X^IN#>^#VcpOI)Ab4F)q$NmE#-dd*=AYm+NtMT%51`&b+Cd z{f+Z&o?pCj_BYPAd4BQA+21(d=J~}dXMf{-o43DlelM-Z*}><``F|B(&hzlf+0Qt? z=C9X$(zublmi^J|_@ymIz4&aZhs@yglHINvhgm!}85XO3^#`p&l=UODUI z);I6>v26V-+df%ew*Ji7U%2&g>*1C2|0b@Ftk2HuWBr-4K5l*7dU)lmk6V9d{TFzm B*Y5xT literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json new file mode 100644 index 000000000..56f6f2380 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json @@ -0,0 +1,27 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Book", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Shelf", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json new file mode 100644 index 000000000..d5835af4b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json @@ -0,0 +1,146 @@ +{ + "ArmChair|+08.22|+00.01|-00.08": [ + 8.75, + -0.25, + 270, + 30 + ], + "ArmChair|+08.23|+00.01|+00.77": [ + 8.75, + 1.5, + 180, + 30 + ], + "ArmChair|+09.50|+00.00|+03.27": [ + 9.25, + 2.5, + 0, + 30 + ], + "CoffeeTable|+10.82|-00.01|+00.93": [ + 11.25, + 0.25, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+00.56": [ + 13.0, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+01.07": [ + 13.0, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+01.58": [ + 13.0, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+02.10": [ + 13.0, + 1.5, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+00.56": [ + 13.25, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+01.07": [ + 13.25, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+01.58": [ + 13.25, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+02.10": [ + 13.0, + 2.75, + 180, + 30 + ], + "Drawer|+14.18|+00.58|+00.56": [ + 13.25, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+01.07": [ + 13.25, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+01.58": [ + 13.25, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+02.10": [ + 13.25, + 1.5, + 0, + 30 + ], + "Dresser|+14.33|+00.00|+01.32": [ + 13.5, + 1.25, + 90, + 30 + ], + "Shelf|+10.79|+00.23|+00.93": [ + 10.5, + 1.75, + 180, + 30 + ], + "SideTable|+11.38|+00.00|-01.16": [ + 10.75, + -0.5, + 90, + 30 + ], + "SideTable|+12.31|+00.00|-01.15": [ + 12.75, + -0.5, + 180, + 30 + ], + "SideTable|+14.33|+00.00|+00.07": [ + 13.5, + -0.5, + 0, + 30 + ], + "SideTable|+14.33|+00.00|+02.59": [ + 13.75, + 2.75, + 90, + 30 + ], + "SideTable|+14.62|00.00|-00.78": [ + 14.0, + -0.25, + 180, + 30 + ], + "Sofa|+11.45|+00.00|+03.21": [ + 11.5, + 2.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7de05a61f39ff149a9a2e2eac6cf891cf5255895 GIT binary patch literal 3024 zcmbW$y>1gh6b8^?WsM@sitO;8%AG-S6RHRyWhy!l4Fwglh$9L_kb`ItPr(B*k3vaF zLE$0=VP{TrOQu;J@7=xMm)PH5zJBrQ&8_q$eO;YzuiouePnWA_7pJTBa&>XJ`@GwH ze0#Y&-~Rjj`R2pb_U7}e_nS}K8$UWZJy|cGJYFxqE&uaO(|BgJUH510It@Mu&cT!5 zAvgtJ|48GpZy)?8_;>KH;GecjeQu5FGd!TPwb59`DG-iP&JeOMpXhxHjs%c&3R!?~vM45eKswOxnOueD#h^%=VL zVSQL1)`#_B`6nffM}C%{b8T}hKl^`h3iI;2FF(uA^0U0Tv>fuXyqx=fmY0WcKLyKc zUS5`$v^aB{hnvfv-w$=XY*|SFwC=gHa`#ZY@W?8!aSR2 z^G9Kx&GS)BzE1 zSzeZxy*?y_G9^2K9-N=WBJ(MZ?-4r zO`C)DVSQNsT-w*k&+@bUEI-T7^0WNx^ND>vvCk*gm-D90&7I(b;1p~hueT4|r(06< z*oW=I_F?<5eb_#1AGQzoYksy5+lO=be)~AL58H?B!}ei&^h#%;o+pyp?NSRa;`O9G zLtd7b&q`{ZX}yp2XZ?8;zF&Xm`m_G5KkLsqyubd=^=JKAf7YM+R#*K5QSh58H?B!#Uh%ALsUA`>=i3K5QSh&%=_M$3AQyp45D7AGQzM zhwa1mVf(OsIEVY~-MAGQzMhxLC{QuFA~`m_G5KkLu>v;M3<>(6=9=3@O>f7YM% zXZ_iq57z&2Y46pa^=JKAf7YM%XZ=}!&YLy|>(BbL{;WUi&-$~zPfB~QzN|0n%kE?M fvHRH1r`XS@Sf1mMhvi}SvHRG4>^}DM#pCi9x@2HO literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json new file mode 100644 index 000000000..60b621433 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Pillow", + "Statue", + "Box", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "Bowl", + "GarbageCan", + "CreditCard", + "WateringCan", + "DeskLamp", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json new file mode 100644 index 000000000..69e837fe8 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json @@ -0,0 +1,92 @@ +{ + "CoffeeTable|-02.49|+00.02|+04.04": [ + -3.25, + 4.0, + 90, + 30 + ], + "CoffeeTable|-05.56|+00.02|+06.83": [ + -5.25, + 6.0, + 0, + 30 + ], + "Shelf|-00.59|+00.25|+02.00": [ + -1.75, + 2.5, + 90, + 30 + ], + "Shelf|-00.59|+00.25|+05.98": [ + -1.5, + 5.75, + 90, + 30 + ], + "Shelf|-02.85|+00.47|+07.17": [ + -2.75, + 6.5, + 0, + 30 + ], + "Shelf|-02.85|+00.90|+07.17": [ + -2.75, + 6.25, + 0, + 0 + ], + "Shelf|-02.86|+00.16|+07.17": [ + -4.5, + 6.25, + 90, + 30 + ], + "Shelf|-02.87|+01.29|+07.17": [ + -3.0, + 6.5, + 0, + 0 + ], + "Shelf|-05.95|+00.16|+04.34": [ + -5.25, + 4.5, + 270, + 30 + ], + "Shelf|-05.95|+00.47|+04.34": [ + -5.25, + 4.25, + 270, + 30 + ], + "Shelf|-05.95|+00.90|+04.34": [ + -5.0, + 4.25, + 270, + 0 + ], + "Shelf|-05.95|+01.29|+04.35": [ + -5.25, + 4.75, + 270, + 0 + ], + "SideTable|-00.59|+00.01|+02.00": [ + -1.25, + 2.25, + 90, + 30 + ], + "SideTable|-00.59|+00.01|+05.98": [ + -1.25, + 6.25, + 90, + 30 + ], + "Sofa|-00.77|+00.02|+03.92": [ + -1.5, + 3.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..c199eae736d2c19c6344eab8dd577dcd539bc5ce GIT binary patch literal 2560 zcmbW&F-j{@6oBDTBuEg^9ZWY0X%qwz!Ol*xv9OY05-da|5gTz8E+{S`OGue=iYZc9 z7?bm*IHl7J-yPn$bAN}Iuj|{Zo4bwTz4)kl{n5j)IxDO5!D-bgtHI0gZPoF_7^@lIyvr?$A_Krv;61PE|ypOdv$Ncowt%VlZ)h^ak0F1V|^ap zNjBf}?ex5ryccfLd^VrWXY<*7-jDfp%(ovq58IFJ$M$3UvHfQ0JZwIj&*roFJijQG z7u#%!if^L-NMu)aENQScuH{T z-a|jukM(2ySU=W}^<(|G9$%y;v{Si}hl??9=*QJz>3AFV>6oV!gPDKCBn(#d@(` z>>Ql$dRf&1GpUaS}E#m>d~u9x*XI~`74!b*ZBScpm@HsVw41DVIMwAdm= zigoYI*Zk$)CVZKA?l~d&`{(74Usng|CB4?S%gxQYKC9~U)oDGe>eb`=dA)eJeq7%! z|Gj^)xZf6QRr8}+^;Z4o8K!a$x9#ihd;2;L9t97B2f;bGAKVL0 z!Ta}Ajy}8KKf(I%Lx0wv^=JJ#cYRoY)}Qrf{dw2*W&K(I)RfuD_s{yX{_H+>AG?p; z*9-Tt``CRfpXIasev`_vhvl<;me2B8eh&F8pXIZBme2ABA)n>5e3sAhS^hBO^JtsO zVfpO$$~k<#AKVL0!G1sT^k@B9|52058FzWCKkLtf@cA69zt8K>`m_G5KkLu>kDFAE z{;WUi&x5Wn=V1Lk*Pr!g{aJt3pQqh@hfOMH5^SI6_OX3D41aH*=Q%vL&vX0OKDLkT zWBXYDNt4RapY><`S%1#kHiz|R{aJt3pY><``Lp|f&-P54wue1z58K1`aNf2#Y!BPR S_OLx{58K1`@JF|A+WZAD>Eo>c literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json new file mode 100644 index 000000000..fab11eadd --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json @@ -0,0 +1,29 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "Cabinet", + "DeskLamp", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json new file mode 100644 index 000000000..ba058be94 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json @@ -0,0 +1,92 @@ +{ + "ArmChair|-00.30|+00.00|+01.71": [ + -1.25, + 1.75, + 90, + 30 + ], + "ArmChair|-00.30|+00.00|+03.31": [ + -1.25, + 3.25, + 90, + 30 + ], + "Cabinet|-04.41|+00.50|+01.57": [ + -4.0, + 2.25, + 270, + 30 + ], + "Cabinet|-04.41|+00.50|+02.59": [ + -3.75, + 1.75, + 0, + 30 + ], + "Cabinet|-04.41|+00.50|+02.60": [ + -3.75, + 2.25, + 0, + 30 + ], + "Cabinet|-04.41|+00.50|+03.62": [ + -4.0, + 3.0, + 270, + 30 + ], + "CoffeeTable|-02.41|00.00|+02.55": [ + -2.5, + 3.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+01.82": [ + -4.0, + 2.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+02.34": [ + -4.0, + 2.75, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+02.85": [ + -4.0, + 3.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+03.37": [ + -4.0, + 3.75, + 180, + 30 + ], + "Dresser|-04.74|+00.00|+02.60": [ + -4.0, + 2.75, + 270, + 30 + ], + "GarbageCan|-04.81|-00.03|+01.24": [ + -4.0, + 1.5, + 270, + 30 + ], + "SideTable|-00.04|+00.00|+04.62": [ + -0.75, + 4.5, + 90, + 30 + ], + "Sofa|-02.46|00.00|+00.70": [ + -2.25, + 1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..43b4a4f9f53a2bfebe3ca8a381ed7d817cddc05e GIT binary patch literal 6400 zcmbW)y-rkJ6oBC^At!{8$?*SUGu>!Hg^d~$c4eorv9K~khFBOegRwDQg%`xR1TKM+ za*8P^rVv^CF=3TXLmtk|IeWbe{P=#qegEd&hezc{`8htFTzs02UyjDF&Yq7CN8_{e z>G$c$*N^AZ)5+iOzdreLF}eHx#pjc6lRH0o_TuPpboBIa^lS8=uhnw@TJGcP&2fBP zN-oKZ%ZKm3O`a#ul5dhde|G%v`Rw`Z`Rw^TZ}(@6oV!c=|){FIG zy;v{Si}m6`ALr(^Wc^&%kM(2ySU--ZmBRWBYFyEe^<({557vYAU_Dq5)`Run)z*jg zU_Dq5)`Rt6zmKfXF!f>cvU%COY+g1mo0nJHyu6ZZUf0db=4JD;`PS2XY(6$0n~%-M z=411*`Ph7HzieJMFPoRm%jVrk^Rju_ylh@JFPoRm%jRYCa@WU++3!E=!FsSBtOv*4 zOJO}WYh3aB&*o?Iv-#QlY<@OBo1eQr&cVyc{@!){w*B{o^6o;y6ty?B560 zZ>z>T^Tay;*P8n@fAK-t6yd z)_=Rk2lZ#YS#KWp@j2F;^=7?UZ|>6l^mbiu)|>Tay;*P8oAqYBS#OT%OJTiPZ`OOK z#wYb=KkuwRueUy|KkLu>v;M3<`S%21_^=JKAe~xOUu->dU>%CXwlX|ni zk9n)j&zs5i;ktdWeXxD7eXxD7eQ=kaZy&DP2iphR2iphR2iphR2iwO#AD8%Cv& z`+Bq9?Ego2w~x>9PV#oLeR;oqv3;?9v3;?9v3;?9v3+ru&Szh)+ZWpx+ZWpx+ZWpx z+ZWr%K`r+$`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`{1r`bJzH4AFkU6+XveR M+XveR+s8ru13&Ct_5c6? literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json new file mode 100644 index 000000000..b52cc7c18 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Curtains", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "CellPhone", + "Dresser", + "DeskLamp", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "CoffeeTable", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json new file mode 100644 index 000000000..eec0c2905 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json @@ -0,0 +1,68 @@ +{ + "CoffeeTable|-01.55|+00.00|+02.53": [ + -1.0, + 3.25, + 180, + 30 + ], + "DiningTable|-05.64|00.00|+04.91": [ + -6.5, + 5.0, + 90, + 30 + ], + "Drawer|+00.75|+00.23|+03.33": [ + -0.25, + 4.0, + 180, + 30 + ], + "Drawer|+00.75|+00.23|+04.10": [ + 0.25, + 3.75, + 90, + 30 + ], + "Drawer|+00.75|+00.67|+03.33": [ + 0.0, + 2.75, + 0, + 30 + ], + "Drawer|+00.75|+00.67|+04.10": [ + 0.0, + 3.5, + 0, + 30 + ], + "Dresser|+00.85|+00.00|+03.71": [ + 0.5, + 5.0, + 180, + 30 + ], + "GarbageCan|-07.10|-00.04|+02.30": [ + -6.5, + 3.0, + 270, + 30 + ], + "SideTable|+00.73|+00.01|+06.64": [ + 0.5, + 6.0, + 0, + 30 + ], + "SideTable|-03.41|+00.01|+01.66": [ + -2.75, + 1.5, + 270, + 30 + ], + "Sofa|-02.47|+00.00|+03.28": [ + -1.25, + 3.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..53a9e420d63206ac302712d7b74c3076e32f2be3 GIT binary patch literal 3552 zcmbW$KZ_GV7{K9i2}1}W_`lw671DTEhzK{8onm8QCBe&KA)X{+BYp}$ko$42OmRhu z6rMZtG;irN!;={{`~FCNzkUDa-G@8rNBTKjZ10rkAfctKM1}bd@tC%o^M_@FPoRm%Q-yXyw1(b=H=6$G%Y>`-vl3m^}0E) z&(VwZV!c=|){FIGy;v{Si}m6>*7sz+STEL#^yRcG4x~oSU=W}^<({5 zKh}@+WBph^){pgL{rJ@8XZ=`@Q|Q5ZupX=j>%n@k9;^rJ!FsSBtOx7CdaxdRY<*ad zRO;{6|BLltJy;LcgY{rNSP#~N^BF32kXIlupX=j>%n@k z9;^rJ!Ff#6>Pp>bW8J&b_Ob2FdUVZtupX?(tligx^-} z9_;tQDcsk?xgM-XF7AU z^)~7v)`Rt6Jy?%rNz>AU^1uW^td* gq-mL-&Clj%^RxNc{A_++wE1`*Y#!(4Ve_oYUmmn*5&!@I literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json new file mode 100644 index 000000000..770f701c6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "GarbageCan", + "CreditCard", + "Newspaper", + "CellPhone", + "Cabinet", + "Dresser", + "DeskLamp", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Safe", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "TissueBox", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json new file mode 100644 index 000000000..6daba59dd --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json @@ -0,0 +1,158 @@ +{ + "ArmChair|-02.03|+00.00|+04.42": [ + -2.0, + 3.75, + 0, + 30 + ], + "Cabinet|-02.88|+00.56|+04.21": [ + -3.5, + 3.75, + 0, + 30 + ], + "Cabinet|-04.03|+00.56|+04.21": [ + -3.75, + 3.75, + 0, + 30 + ], + "Cabinet|-04.05|+00.56|+04.21": [ + -3.75, + 3.5, + 270, + 30 + ], + "Cabinet|-05.20|+00.56|+04.21": [ + -5.5, + 3.5, + 90, + 30 + ], + "Drawer|-03.17|+01.01|+04.31": [ + -3.5, + 3.75, + 90, + 30 + ], + "Drawer|-03.75|+01.01|+04.31": [ + -3.25, + 3.75, + 270, + 30 + ], + "Drawer|-04.33|+01.01|+04.31": [ + -4.75, + 3.75, + 90, + 30 + ], + "Drawer|-04.92|+01.01|+04.31": [ + -4.5, + 3.75, + 270, + 30 + ], + "Drawer|-05.02|+00.90|+00.37": [ + -4.25, + 1.0, + 270, + 30 + ], + "Dresser|-04.04|00.00|+04.59": [ + -3.5, + 3.75, + 0, + 0 + ], + "Safe|-02.30|+00.00|+00.27": [ + -1.5, + 1.0, + 180, + 30 + ], + "Shelf|-00.25|+00.78|+01.06": [ + -0.75, + 1.25, + 90, + 30 + ], + "Shelf|-00.28|+00.27|+01.07": [ + -1.0, + 1.25, + 90, + 30 + ], + "Shelf|-00.28|+01.29|+01.05": [ + -1.0, + 1.0, + 90, + 0 + ], + "Shelf|-00.28|+01.81|+01.06": [ + -0.75, + 1.25, + 90, + 0 + ], + "Shelf|-01.22|+00.27|+00.26": [ + -1.5, + 1.0, + 180, + 30 + ], + "Shelf|-01.22|+00.78|+00.24": [ + -1.75, + 1.0, + 90, + 30 + ], + "Shelf|-01.22|+01.29|+00.27": [ + -1.75, + 1.0, + 180, + 30 + ], + "Shelf|-01.22|+01.81|+00.28": [ + -1.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.39|+00.09": [ + -4.75, + 1.0, + 180, + -30 + ], + "Shelf|-05.24|+01.58|+00.07": [ + -4.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.78|+00.07": [ + -4.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.97|+00.09": [ + -4.25, + 1.0, + 180, + 0 + ], + "SideTable|-05.02|+00.01|+00.27": [ + -5.0, + 1.0, + 180, + 30 + ], + "Sofa|-00.71|00.00|+02.75": [ + -1.5, + 2.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a2bddb6722cdbd16b4e4fb99ca0a8f3b62b32dbc GIT binary patch literal 2256 zcmbW$u};EJ6oBEYVe%=uRTCCvF~&qDH;s#flOa;#V8noNF+PP4B#+QXU}Wsjfq_A^ z=Ogisc4@x0_WT^=^ZNGc=58;&rT21N%^zmvSy7%(PRo8#PNuWh+35LxIvZC%*Dps; z^J;s2{y2K6wmv)_4En{%QNQ>o{&^gv?pSoE&TvSUoY3u$9h?>zthWlSuZ!y!FpLQ@8-IYo%On` zm-Tv1FYD#jo?;Jr-Pg-{SugA0{H#Z}9&V$D^{^h+!+KZ`>tQ{s`22cU59?t)tcUfm z9yY(p=Ck>1KAX?xv-xaZo6X}k_Rmdb^V~O&{r|1w{pPX#vUzMCo5$wy{-WFHCgz#X zo9Jir*?cyi&1dsj2lt{U4ZALVtdI5aI(k_j>tlVakM(gc`u4Lv*2nr-AM0a%tdI3^ z9iNv|99+lu%6_-(cf?Khe4E)mJZ~SpVfsCMUu++2A8a3NA8a3NA8a3NAKX=?#P-4V P!S=!S!S=!S(HnjPXOlrz literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json new file mode 100644 index 000000000..51552ba88 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json @@ -0,0 +1,42 @@ +[ + "StoveBurner", + "Stool", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "CreditCard", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json new file mode 100644 index 000000000..445026e53 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json @@ -0,0 +1,176 @@ +{ + "Cabinet|+00.17|+02.01|-01.20": [ + -0.5, + -0.5, + 180, + 0 + ], + "Cabinet|+00.24|+02.01|-01.20": [ + 0.0, + -0.5, + 180, + 0 + ], + "Cabinet|+00.48|+00.39|-00.90": [ + -0.25, + -0.25, + 90, + 30 + ], + "Cabinet|+01.12|+02.01|-01.20": [ + 0.5, + -0.5, + 180, + 0 + ], + "Cabinet|+01.13|+00.47|-00.90": [ + 0.25, + -0.25, + 90, + 30 + ], + "Cabinet|-00.77|+02.01|-01.20": [ + -1.0, + -0.5, + 180, + 0 + ], + "Cabinet|-00.82|+00.47|-00.91": [ + -1.75, + 0.0, + 90, + 30 + ], + "Cabinet|-00.84|+02.01|-01.20": [ + -1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-01.77|+02.01|-01.20": [ + -2.0, + -0.5, + 180, + 0 + ], + "Cabinet|-01.80|+00.47|-00.91": [ + -2.0, + -0.25, + 90, + 30 + ], + "Cabinet|-01.84|+02.01|-01.20": [ + -1.75, + -0.5, + 180, + 0 + ], + "Cabinet|-01.85|+00.39|-00.90": [ + -2.0, + -0.25, + 180, + 30 + ], + "Cabinet|-02.39|+00.39|+00.38": [ + -1.5, + -0.5, + 0, + 30 + ], + "Cabinet|-02.63|+02.01|-01.20": [ + -2.0, + -0.5, + 180, + -30 + ], + "Cabinet|-02.65|+02.01|+00.36": [ + -2.0, + -0.25, + 270, + 0 + ], + "Cabinet|-02.65|+02.01|-00.95": [ + -1.75, + 0.0, + 180, + 0 + ], + "Cabinet|-02.65|+02.08|-00.23": [ + -2.0, + 0.0, + 270, + 0 + ], + "Cabinet|-02.65|+02.08|-00.88": [ + -2.0, + -0.25, + 270, + 0 + ], + "Cabinet|-02.65|+02.20|+00.43": [ + -1.25, + 1.0, + 270, + 0 + ], + "Cabinet|-02.65|+02.20|+01.67": [ + -2.25, + 1.75, + 270, + -30 + ], + "CounterTop|+00.07|+00.95|-01.20": [ + 0.25, + -0.5, + 180, + 30 + ], + "CounterTop|+00.91|+01.15|+00.79": [ + 0.25, + 0.5, + 0, + 30 + ], + "CounterTop|-02.70|+00.95|+00.11": [ + -2.0, + -0.25, + 270, + 30 + ], + "Drawer|+00.26|+00.78|-01.08": [ + -0.25, + 0.0, + 180, + 0 + ], + "Drawer|-02.03|+00.78|-01.08": [ + -1.5, + 0.0, + 180, + 0 + ], + "Drawer|-02.57|+00.78|+00.10": [ + -1.75, + -0.5, + 0, + 30 + ], + "Fridge|-02.86|+00.00|+00.85": [ + -1.75, + 0.75, + 270, + 30 + ], + "Microwave|+00.28|+00.90|-01.33": [ + 0.0, + -0.5, + 180, + 0 + ], + "Sink|-01.33|+00.92|-01.23|SinkBasin": [ + -0.75, + -0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..cbfb298e970e68e3e6c6e2d1c50d344d6d943b48 GIT binary patch literal 3712 zcmbW&KWkG_9LM3~C0t4frS(teyIqA$p@WFvncS2v9h@ZC6bG@Ah>Q3td_mrq(3jA$ zV}=YFGFb09&+;41V0e0y)ARkH`1}3kyNeHx(vS4BzglfRt@~G9|N8o6KkxeMoAvkg z^6ST&_0{U%&)+V;Y*r6H-+W$vTRr&sVsSq27BA-AukJrz(=@(zf6Du9ecuM(2cHe) z^ZtAi>^#q%$IfHt-M%S5c{Y@Hej4oedHy&&KMi&tpLZX2A9kO+a36Lbb{}>hb{}>h zb{}>hcAxujA9f#hA9f#hA3mwQ_&9hLe5ijPe10EnpXc_meQe)0>|^`bKDLkTWBb@X zwvX*&`*>IPvVCkH+qVn**gm$8?PL4cKDLkTWBb@XwvV@UFWbj=;kmv0u$S#+d)Z#L zm+fVH*`?0-jFWbxZvb}8YA?#&)*&beu zo~$S9+2nFhJy}oIll5dhSx?rJ^<+I+Pi}`azM5R#CqsE}a(y4_d$pcTwVtde>&beu zo~$S9Imu~!>B)Mso~$S9$$GM$tS9TqdU89Id$OMF?&beuo~$S9$$GM$tS7g%59`TIc%Fjw^m#p5Pu7$5Wc`kE8ejUceykts$NI5; ztRK(nKGu)*<2HO=KhK-+TtCnCWBph^){pg?=2Tww_p$TY`RsglK0ALF&S&Sd^V#|A Te0KhEJ>U1)_u2Q^_fPU)3+t?9 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json new file mode 100644 index 000000000..4ade16795 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Candle", + "Pillow", + "Box", + "Boots", + "Sofa", + "Statue", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Drawer", + "Painting", + "RoomDecor", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json new file mode 100644 index 000000000..39f0b25e7 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json @@ -0,0 +1,92 @@ +{ + "ArmChair|-02.06|+00.01|+04.22": [ + -1.75, + 3.5, + 0, + 30 + ], + "CoffeeTable|-02.65|+00.01|+01.15": [ + -2.75, + 1.75, + 180, + 30 + ], + "DiningTable|+00.17|+00.67|+01.98": [ + -1.0, + 2.0, + 90, + 0 + ], + "DiningTable|+00.17|+00.86|+01.98": [ + -0.75, + 2.0, + 90, + 0 + ], + "Drawer|-00.31|+00.18|+03.61": [ + -1.5, + 2.75, + 0, + 30 + ], + "Drawer|-00.31|+00.47|+03.61": [ + -1.75, + 3.5, + 90, + 0 + ], + "Drawer|-00.31|+00.76|+03.61": [ + -1.5, + 3.5, + 90, + 0 + ], + "Drawer|-00.31|+01.05|+03.61": [ + -1.25, + 3.5, + 90, + 0 + ], + "Drawer|-00.36|+00.22|+00.52": [ + -1.0, + 0.0, + 90, + 30 + ], + "Drawer|-00.36|+00.58|+00.52": [ + -1.0, + 0.0, + 90, + 30 + ], + "Dresser|-00.27|+00.00|+03.61": [ + -0.75, + 2.75, + 0, + 30 + ], + "SideTable|-00.28|+00.01|+00.52": [ + -0.75, + 0.75, + 90, + 30 + ], + "Sofa|-02.68|+00.01|-00.12": [ + -1.75, + 0.75, + 180, + 30 + ], + "Sofa|-03.79|+00.02|+03.89": [ + -3.75, + 3.0, + 0, + 30 + ], + "TVStand|+00.17|+00.59|+01.98": [ + -0.5, + 2.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..1998dfe53466034f9930433a8609e39fc508e2a2 GIT binary patch literal 1904 zcmbW$u}Z^07zglEBuEjTAzKu>)Ja6>=BBtfI7zW74q_z{7x5{4AoB=)gpM6MbZ~I6 zn)@x^XqM~ma(CbVYm$$vo6GClo%EXCs%hQcH`Q5LozG6IVOh=Q%}Xp!FaLQB(%-e;^<$C8!#wWg@gR5*Y`^tIxNqLL8}6%T zUOiTi)noNI)-i8Pxjw6BUOjd`JD;7yas2*F{gvx}1#g1a!K>h9@FF-@OLE8;b8sBx zGcO;@$MUg!EFa6q@~JB~TgP#f&%AsrAIrz`v3x9_I`Xl6>^!z#F8kSfwq9=Qx#;?Y z`tUxo{cJz`-qiK}v-h8UZ>&D6&+4=K?EhkU`mR!vhvi{;xaj=qM|sT3!}72^?76e& z$ZOwQp731U_dm1#7UO&9~WJ}kM+m;WBsxISbx09{jmO6f2=>&-!k;a`eXgE T{#bwP{8c!gozKo^=dZ>;E<^}{ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json new file mode 100644 index 000000000..0c292118a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json @@ -0,0 +1,29 @@ +[ + "FloorLamp", + "Stool", + "Curtains", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json new file mode 100644 index 000000000..616f56233 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json @@ -0,0 +1,44 @@ +{ + "ArmChair|+00.66|+00.10|-01.78": [ + 0.0, + -1.5, + 90, + 30 + ], + "CoffeeTable|-01.05|+00.10|-02.47": [ + -0.5, + -1.75, + 180, + 30 + ], + "CoffeeTable|-01.09|+00.10|-00.74": [ + -0.5, + 0.0, + 180, + 30 + ], + "DiningTable|-03.43|+00.10|-01.19": [ + -2.25, + -1.5, + 270, + 30 + ], + "Drawer|-00.03|+00.87|-02.49": [ + -0.5, + -1.5, + 180, + 0 + ], + "SideTable|-00.03|+00.10|-02.55": [ + -0.25, + -2.0, + 180, + 30 + ], + "Sofa|-00.91|+00.10|+00.96": [ + -1.5, + 0.25, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..b2a8cc9718e5f2cf19ef4807f70182005f8015d7 GIT binary patch literal 1648 zcmbW$Ax;B96b9e{$tl(?Bvm9NKuB7JgJ2LS($FOcLdlk32&dpcy}}-$vU0_WiV6xd zpWsQ>ynM4e^Z(tpU)Q%+H+OsKJ$=-(X7SM0=T&|2cv_FD`f=XAwbPgTc{^)<)-R{e zi)OdJc$&U8J0G5%jH=_KQT18<_c}$+0 zm|r>wGWzmnqMEc`T3R zu{@UNcdG|`j^p$`toNlS>&N=BeyktsCr3ZlkL}|)^|P)Y>&N=BeypE!^<({5KXwks fsh@TISU=W}{coJ3FYC+BW9PB+^yrrPgw6OH;_3TC literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json new file mode 100644 index 000000000..3b4888f48 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json new file mode 100644 index 000000000..78f79df35 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json @@ -0,0 +1,86 @@ +{ + "ArmChair|+00.22|-00.01|-01.72": [ + 0.25, + -1.0, + 180, + 30 + ], + "CoffeeTable|+00.23|00.00|-00.16": [ + 0.75, + -0.5, + 270, + 30 + ], + "Drawer|+00.47|+00.06|-00.17": [ + 1.5, + 0.5, + 180, + 30 + ], + "Drawer|+00.47|+00.17|-00.17": [ + 1.5, + 0.5, + 180, + 30 + ], + "Drawer|+00.47|+00.27|-00.17": [ + 1.5, + -1.0, + 0, + 30 + ], + "Drawer|+02.00|+00.78|+01.71": [ + 1.5, + 1.0, + 90, + 30 + ], + "Drawer|-00.02|+00.06|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "Drawer|-00.02|+00.17|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "Drawer|-00.02|+00.27|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "SideTable|+02.00|+00.00|+01.75": [ + 1.75, + 1.25, + 0, + 30 + ], + "SideTable|+02.96|+00.00|+01.57": [ + 2.0, + 1.0, + 0, + 30 + ], + "SideTable|-00.68|+00.00|-01.60": [ + -0.25, + -1.0, + 180, + 30 + ], + "Sofa|+02.87|00.00|+00.25": [ + 2.0, + 0.25, + 90, + 30 + ], + "TVStand|+00.84|-00.01|+01.58": [ + 2.0, + 1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..665418e122d9cac06770ebc649028343ff60128b GIT binary patch literal 3344 zcmbW&v5FHx7zgli3E>FhGo*_`3cX51a4S2-#==U1m%~ClNyJ8c3LhwWgnfi7uiRpb z6e&D2-)|vbd1;2<>}KXa|AgJY??1l#@aa+cRemq7*4riT&@4lzg>OXuJ7l!UspfY_kMc${Kay9`D{7=Gk@S`R!*N`SI0w)eezxMZE}}f zS1ZMO-JA3EZ-yp*&cpg*eX+h+U#u_I7f<%}fO_)3VfS$!^=V$8-0jZSuPSA{9{sRB zS)bge`}N_vK3E^D57r0k!?~L1hfDG?&gZ)RSbuCE&ZGX!cWHh7jn|_O)*tJS^~3sM z{jmIU$vuUJ2< zAJz}+hdrNJU(TT~))(uG^~J-k=4bnG9`$8jU#u_I7we1l#rk6BwXgHC^Rn}@^YReq z<%@kizjI8J?eDt%+5UWt_1XSxf1bsDdXtCcVR={{mWSoxL*!$5SRTKdJS-2(!}72^ pEDy`W@~}KjTTUN&c)CALm!_@bWM9Xot)uTx!oJVbeZ6ne{sUHT-gy83 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json new file mode 100644 index 000000000..e7796955d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json @@ -0,0 +1,28 @@ +[ + "FloorLamp", + "Plate", + "Candle", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "TVStand", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json new file mode 100644 index 000000000..926752e61 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json @@ -0,0 +1,50 @@ +{ + "ArmChair|-00.43|+00.01|+01.06": [ + -1.0, + 0.25, + 0, + 30 + ], + "ArmChair|-00.44|+00.01|+01.92": [ + -1.25, + 2.0, + 90, + 30 + ], + "ArmChair|-02.01|+00.01|-01.58": [ + -1.25, + -1.0, + 270, + 30 + ], + "CoffeeTable|-02.02|+00.01|+00.02": [ + -1.25, + -0.25, + 270, + 30 + ], + "DiningTable|+01.88|+00.00|-00.29": [ + 3.0, + -0.25, + 270, + 30 + ], + "DiningTable|-01.86|+00.23|+02.79": [ + -2.5, + 1.75, + 90, + 30 + ], + "SideTable|-03.60|+00.00|-01.61": [ + -2.5, + -1.0, + 270, + 0 + ], + "Sofa|-03.42|+00.01|-00.04": [ + -2.5, + 0.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..32ec8b98d34f480b238ced98dc1ea711dd6487e8 GIT binary patch literal 4688 zcmbW%v5FHx7{Kvy2#fd>+pR*X1K|+Ct?U#V3o8j;4h!)l5gYL-e4y+j2kXJ*b}8{#=Vg6Z zAD+Ye`gorEasunaO?duzDDRuI30?*3>3uy}Pj)WHRZshRvYxCb>&1HUTzj!zocr|f z!+Nn^te1N?L-{=G#d@(`tQYIW&gHo3WnV8o9+vkjO3CxF_Ted5PtWyaJvsNw^Yrvw z&$EZ}zB%+`{a8QNkM(2y*tr~6{p=rWKQ6aTiS^^D_GA56Kh}?PA9@7q=ly0V@4L5t ztRL&g`muhjAM3~N!Ex2kez|Q*e5}3rHux@BZ}02Pdb8fFH|IX|3)b8F%~0Mqm)@*5 z>&<$z-mEu|hvj*Cd+uHw*YfF<&il0|>&<$z-aLiR>+QMTtT*R=Igj5Dp6kti-<`*}XZg$J)=n{;WUi&r|rk{+{d4`g896sjT|j)t~h| z-+L%eSWniIr`nJ8WIb6=)|1_f7M?5vYxCb zPqioO$$GM$tS9Tqdaxd>2kXIlupX=j>*0ISgY{rNSP#~N^N^v$Hn~$gZeY5%4d~7~8ADfTO$L3@6vH941&h`DV`Ph6s)%kb~HlOElHJ^R+ zvH941Y(6$0o6kAsWAm~3*nB+J`Ph8yT#l>x?3<6x$L3@6vHASH=Ht2Emrudw^W1!F yJ~ki6)jamy&%XPy`|+vXkKK>mkKK>mkDafp^V#|Ae0DxNpPkRn^Syb#>i+=xY_kFY literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json new file mode 100644 index 000000000..c848824cf --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Stool", + "Pillow", + "Statue", + "Box", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Book", + "WateringCan", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "Dresser", + "Chair", + "DogBed", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json new file mode 100644 index 000000000..0e044ef87 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json @@ -0,0 +1,182 @@ +{ + "ArmChair|-02.86|+00.03|-02.04": [ + -2.25, + -1.5, + 270, + 30 + ], + "Drawer|+03.10|+00.17|+00.36": [ + 2.0, + -0.25, + 0, + 30 + ], + "Drawer|+03.10|+00.17|+01.40": [ + 2.0, + 0.75, + 0, + 30 + ], + "Drawer|+03.10|+00.17|-00.57": [ + 2.0, + 0.0, + 180, + 30 + ], + "Drawer|+03.10|+00.42|+00.36": [ + 2.25, + -0.25, + 0, + 30 + ], + "Drawer|+03.10|+00.42|+01.40": [ + 2.25, + 1.0, + 0, + 30 + ], + "Drawer|+03.10|+00.42|-00.57": [ + 2.25, + 0.0, + 180, + 30 + ], + "Drawer|-00.17|+00.47|-02.14": [ + -0.5, + -1.5, + 90, + 30 + ], + "Drawer|-00.19|+00.23|+00.95": [ + -1.25, + 1.5, + 180, + 30 + ], + "Drawer|-00.19|+00.48|+00.95": [ + -1.25, + 1.5, + 180, + 30 + ], + "Drawer|-00.19|+00.74|+00.95": [ + -1.0, + 0.5, + 0, + 30 + ], + "Drawer|-00.42|+00.35|+01.41": [ + -1.25, + 2.0, + 180, + 30 + ], + "Drawer|-00.42|+00.35|+01.92": [ + -1.25, + 1.25, + 0, + 30 + ], + "Drawer|-00.42|+00.35|+02.38": [ + -1.25, + 1.75, + 0, + 30 + ], + "Drawer|-00.42|+00.60|+01.41": [ + -1.25, + 2.0, + 180, + 30 + ], + "Drawer|-00.42|+00.60|+01.92": [ + -1.25, + 1.25, + 0, + 30 + ], + "Drawer|-00.42|+00.60|+02.38": [ + -1.25, + 1.75, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+01.41": [ + -1.0, + 1.0, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+01.92": [ + -1.0, + 1.5, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+02.38": [ + -1.0, + 2.0, + 0, + 30 + ], + "Drawer|-03.24|+00.17|-00.49": [ + -2.25, + -1.0, + 0, + 30 + ], + "Drawer|-03.24|+00.42|-00.49": [ + -2.5, + -1.0, + 0, + 30 + ], + "Dresser|-00.05|+00.03|+01.67": [ + -0.75, + 1.75, + 90, + 30 + ], + "GarbageCan|+03.16|+00.03|+00.89": [ + 2.75, + 0.5, + 90, + 30 + ], + "SideTable|+03.16|+00.03|+00.36": [ + 2.75, + -0.25, + 90, + 30 + ], + "SideTable|+03.16|+00.03|+01.40": [ + 2.75, + 1.5, + 90, + 30 + ], + "SideTable|+03.16|+00.03|-00.57": [ + 2.75, + -1.0, + 90, + 30 + ], + "SideTable|-00.17|+00.03|-02.28": [ + -0.75, + -1.75, + 90, + 30 + ], + "SideTable|-03.30|+00.03|-00.49": [ + -2.75, + -1.25, + 270, + 30 + ], + "Sofa|-02.96|+00.03|+01.39": [ + -2.25, + 1.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..ad7052df7af997c082b3bbf305788284e4c43c67 GIT binary patch literal 2576 zcmbW$F^dyH7zW^R2}1}W+~pUfTZJ^I2qMBwWvAF!TqVKFafNu2h>iFw{6X$dvApt% zD^jHJ+?l8FE1hO}GQ0D=Z#Mb)_Whf87mw1n^u52_?mzDOm#hBO)r)?;>aT8gUw50& zA8vM++rOW`-hA3`A3on-Z@z3F{P^tov-RrfllAJy>Oa>kjcYN~>+N~H&Vy&c)8HID z3GRYZ@bOm~m-+JCg*+?|%fq>y&+@Q5EDy`W^4y0!EDy`W@~}KC56i>y@S%NQd>?!l zd>i~bSii&h_!^S;&-$@`tRL&g`mug|Y&KI!p2LThm*r)7S)Q)cbNrrI9+rpmkjB-OdYugQ z+Ld}WpUr3UC+&Xo*?cyi^N_~H=Ck>1KAWFQJ;!`DpUvky)aTedHjmAlminA|Y#y7( zd8p5^d2Ak^wEJhJK4(79!@l|U&F38M_kG*<`(yc7K9+A@(zq7we3p;p<7v1*2g~RF zF6^gZ|9|)E!}_p3?ElaH|E%w#q;cuX`m(+}ZFxBd>uXKbA k#-%Uo%g$rx@v`+jZRec^n`hrVb{;!#8O~$pvGbPY50_ygkpKVy literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json new file mode 100644 index 000000000..56cce5761 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Shelf", + "Chair", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json new file mode 100644 index 000000000..c14fbdb01 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json @@ -0,0 +1,86 @@ +{ + "ArmChair|-00.88|+00.01|+00.57": [ + -0.75, + 1.25, + 180, + 30 + ], + "CoffeeTable|-01.97|+00.00|+02.62": [ + -1.25, + 3.0, + 270, + 30 + ], + "Drawer|-04.43|+00.47|+03.34": [ + -3.5, + 2.75, + 0, + 30 + ], + "GarbageCan|-00.23|+00.01|+04.78": [ + -0.5, + 4.25, + 0, + 30 + ], + "Shelf|-00.34|+00.28|+03.05": [ + -2.0, + 3.5, + 90, + 0 + ], + "Shelf|-00.34|+00.31|+02.31": [ + -1.5, + 1.75, + 0, + 30 + ], + "Shelf|-00.34|+00.45|+02.68": [ + -1.25, + 2.25, + 0, + 30 + ], + "Shelf|-00.34|+00.48|+03.05": [ + -1.25, + 3.5, + 180, + 30 + ], + "Shelf|-00.34|+00.60|+02.31": [ + -1.25, + 2.75, + 180, + 30 + ], + "Shelf|-00.34|+00.65|+03.05": [ + -1.25, + 3.5, + 180, + 30 + ], + "SideTable|-04.61|+00.01|+03.35": [ + -4.0, + 4.0, + 270, + 30 + ], + "Sofa|-02.12|+00.01|+04.56": [ + -2.25, + 3.75, + 0, + 30 + ], + "Sofa|-04.57|+00.01|+01.88": [ + -3.75, + 2.0, + 270, + 30 + ], + "TVStand|-00.34|+00.01|+02.68": [ + -1.0, + 2.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..612bff252a03c692fd9fae9587c56e6b1ca74d94 GIT binary patch literal 1392 zcmbW#El$Kh7zW^i

#+;>QM z@;Q!udd~bhxC?HB$KA4Qw|@F}|329HJ@5RypU&@G`mjE%H_PET>Sta*Zc{(jkK5FT zyI|kXeSPe!59`D7Sw72W`FhA_`7EF1vwW7{ruQPB<+FU2&+=Km_bi{~vwW7%@>%|F z-D3`!PI-O6B^RjguNBfz#AKR~+eglST B=!pOT literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json new file mode 100644 index 000000000..955390880 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json @@ -0,0 +1,25 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "Blinds", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json new file mode 100644 index 000000000..3a0e5fab9 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json @@ -0,0 +1,68 @@ +{ + "ArmChair|+01.51|+00.00|-00.59": [ + 1.25, + -1.25, + 0, + 30 + ], + "CoffeeTable|-00.71|+00.01|-00.37": [ + -0.5, + -1.0, + 0, + 30 + ], + "Drawer|+01.74|+00.77|+00.33": [ + 0.75, + 0.0, + 90, + 0 + ], + "Drawer|-00.71|+00.08|-00.17": [ + 0.25, + 0.5, + 270, + 30 + ], + "Drawer|-00.71|+00.08|-00.56": [ + -1.75, + -1.25, + 90, + 30 + ], + "Drawer|-00.71|+00.24|-00.17": [ + 0.25, + 0.5, + 270, + 30 + ], + "Drawer|-00.71|+00.40|-00.17": [ + -1.25, + 0.5, + 180, + 30 + ], + "Drawer|-00.71|+00.40|-00.56": [ + -0.25, + -1.25, + 0, + 30 + ], + "Drawer|-00.72|+00.24|-00.56": [ + -1.0, + -1.25, + 90, + 30 + ], + "SideTable|+01.81|+00.00|+00.33": [ + 1.25, + 0.5, + 90, + 30 + ], + "Sofa|-00.50|+00.01|-01.89": [ + -0.5, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..01fe02cc4a31f59c63203eb32ff53aed7fca0700 GIT binary patch literal 3232 zcmbW(v2N2)6b9f+6j@aiRc+I>l*yYx$^v2lgj7%6in?@QLJ>{HfGA233*sqwAp9sD zJ7(yRAp@=N{gyN0rTSv~{`Z{YxcT$p^8DiClk_wFYOWTm&&%dr-Mqhk)6DAT`eylK zIsf+QW_h)E{QPYGb+vf-eD!7ieevMuFWfiN$9;4JBCtdz~dz$|~4L%M& z3Vv36SMIkSTaT^B*5hed?=W~0d=R`JycfJ1JPsZO?*v!D!{9-%{;W%X)Whmw^{{$a zJ**y9537gO!|Gx6uzEO^`gr>{^#^Z)?}OLDcfq&8`gMPrbM%Y#i}j23i}j23i}j1E zF6XlTu>P?Au>P?Au>SD6)X)0E`osFMDgDt8)(_SX)(_SXRu6B>{#gDtfdhB}kzTGX?yPv(E*m`U|w%%S?kIjcS<^96mk1U_% zvwZgdcfaJHbg4hs?-Ta>g#A9@X}JF|SifBFd1B8Kd!E?y#N)93DA@Dl`YN3FJUQ?C z!TQg>?`$4y9&8?L9&8?L9tUme5A$I2VDsRkQXfx)&BJ-~VDn(}VDn(}VDn(}VDsQA h?9V)$HxD)sHV-xrHV-xrHV=0Hq)q+des=$){Rg6}TU`JE literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json new file mode 100644 index 000000000..f87968d27 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json @@ -0,0 +1,28 @@ +[ + "FloorLamp", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Cabinet", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Shelf", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json new file mode 100644 index 000000000..76136ed5f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json @@ -0,0 +1,206 @@ +{ + "ArmChair|-01.01|+00.03|+02.08": [ + -1.75, + 2.5, + 90, + 30 + ], + "ArmChair|-01.58|+00.03|+03.30": [ + -2.0, + 2.75, + 0, + 30 + ], + "Cabinet|-01.53|+01.87|+00.33": [ + -1.0, + 1.0, + 180, + 0 + ], + "Cabinet|-01.98|+01.17|+05.03": [ + -2.25, + 4.5, + 0, + 30 + ], + "Cabinet|-02.02|+01.71|+00.32": [ + -1.5, + 1.0, + 180, + 0 + ], + "Cabinet|-02.47|+01.33|+05.03": [ + -2.75, + 4.5, + 0, + 0 + ], + "Cabinet|-03.70|+01.71|+05.03": [ + -4.0, + 4.5, + 0, + 0 + ], + "Cabinet|-04.18|+01.87|+05.03": [ + -4.5, + 4.5, + 0, + 0 + ], + "Cabinet|-05.37|+01.17|+05.03": [ + -5.75, + 4.5, + 0, + 30 + ], + "Cabinet|-05.85|+01.33|+05.03": [ + -6.25, + 4.5, + 0, + 0 + ], + "CoffeeTable|-02.67|+00.03|+02.00": [ + -2.0, + 1.5, + 270, + 30 + ], + "DiningTable|-05.82|+00.03|+02.56": [ + -4.75, + 2.0, + 270, + 30 + ], + "Drawer|-01.09|+00.23|+00.46": [ + -1.0, + 1.25, + 180, + 30 + ], + "Drawer|-02.68|+00.23|+00.46": [ + -2.75, + 1.25, + 180, + 30 + ], + "Drawer|-02.94|+00.51|+05.00": [ + -3.25, + 4.5, + 0, + 30 + ], + "Drawer|-02.94|+00.82|+05.00": [ + -3.0, + 4.5, + 0, + 30 + ], + "Drawer|-04.26|+00.23|+00.46": [ + -4.75, + 1.25, + 180, + 30 + ], + "Drawer|-06.33|+00.51|+05.00": [ + -6.0, + 4.5, + 0, + 30 + ], + "Drawer|-06.33|+00.82|+05.00": [ + -6.25, + 4.5, + 0, + 30 + ], + "GarbageCan|-06.85|+00.02|+00.26": [ + -6.25, + 0.75, + 180, + 30 + ], + "Shelf|-00.81|+01.69|+00.19": [ + -1.0, + 1.0, + 180, + 0 + ], + "Shelf|-01.04|+01.00|+00.18": [ + -0.5, + 1.0, + 180, + 0 + ], + "Shelf|-01.04|+01.32|+00.18": [ + -0.5, + 1.0, + 180, + 0 + ], + "Shelf|-01.78|+00.99|+00.18": [ + -1.25, + 1.0, + 180, + 0 + ], + "Shelf|-02.22|+00.45|+05.17": [ + -2.75, + 4.25, + 90, + 30 + ], + "Shelf|-02.67|+00.61|+00.27": [ + -2.0, + 1.0, + 180, + 30 + ], + "Shelf|-03.19|+01.15|+05.17": [ + -3.25, + 4.5, + 0, + 0 + ], + "Shelf|-03.94|+00.99|+05.17": [ + -3.75, + 4.25, + 0, + 0 + ], + "Shelf|-04.67|+01.00|+05.17": [ + -4.75, + 4.5, + 0, + 30 + ], + "Shelf|-04.67|+01.32|+05.17": [ + -4.75, + 4.5, + 0, + 0 + ], + "Shelf|-04.90|+01.69|+05.17": [ + -4.75, + 4.5, + 0, + -30 + ], + "Shelf|-05.61|+00.45|+05.17": [ + -5.0, + 4.25, + 270, + 30 + ], + "Shelf|-06.57|+01.15|+05.17": [ + -6.5, + 4.5, + 0, + 0 + ], + "Sofa|-03.33|+00.02|+03.63": [ + -3.25, + 3.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a07f8bf3aa03848dd6ebd588c90ecca0333f83c GIT binary patch literal 2576 zcmbW%F>6y%7zW^D2!{|tXk*>)b}MADQV05uX-GAKmFT4KL<%@pZ^_N$>o89Ki z`PJ@X`|tUi&FB60;rag4=6d_!<7cPO*WJm}b@#pd&oxiuS`GE{_I3R{3_b{61}}o= z!L#5TJPm%_eAn{G$MUg!EFa6q^09m@AIrz`-M4(sXXmr?+4<~zc77^pT+Ub>%@e4K~6kLBY@c%OprTYmfXVSQL1)`#_B zedeX+^!w#S%ftGzzMR8;eZAM0^<{loU)GoPWqny+)^}0Txb$WJSM2|am#rV051S9q z!u}j=KK7drn-7~0n-7~0n-7~0n-81MvZQgD51S9051S9056@eFo(1P%^ReH2*nHT0 z*nHT0*nHT0*nId&%Xd)HxQ>F&&wKM@eL08k>+8L~tS{@!`m(;PFYC+t@=?ooSkk!k jWBph@mXGCQ`B*-dkL6?eRv{nD!}72^EDy`W@~p~VyiFZK9KteKEjq; zrbv+@h3n1v3Qy@Y%a=)J{_}^u`T6?ot2giNlyBvGcfQ(uSa;9b?)k-8w`jYI%k|gw z^7H%4_4(@W>o1p|Hmlp$Hy@W@R=0lm`0VMTee!70{%HSmHDy?*SI58CFOGljCGUUz zyMI6SZ{qzv&pyvS&$~E}AH;dvIM4a)e0DxNpLcOSZ*Emp=!5ma`e1#qK3E^D z57r0Qn2+_r`e1$VA^PBbvOetVgY{ARGAw( zKg-YZv-~VS%g^$&{477q&(|>zn`hjYVfjATJZv5|51WU})$v?551WV0!{%Z0uzA=# zwLji#9ySk~ht0#I$j>F&Joe4Q=3(=&dDuK`o=KXA&BNwl^RVX!Ph%eT{9w-yuIc^b zKm+ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json new file mode 100644 index 000000000..2aca56e1f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Boots", + "Sofa", + "Statue", + "Pencil", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "WateringCan", + "CellPhone", + "Drawer", + "Desk", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json new file mode 100644 index 000000000..27d4df17e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json @@ -0,0 +1,68 @@ +{ + "ArmChair|-01.32|+00.03|+03.65": [ + -1.75, + 3.0, + 0, + 30 + ], + "CoffeeTable|-03.04|+00.00|+02.34": [ + -3.25, + 3.0, + 180, + 30 + ], + "Desk|-00.31|+00.03|+00.62": [ + -1.0, + 1.0, + 90, + 30 + ], + "Drawer|-05.50|+00.21|+02.13": [ + -5.25, + 1.5, + 0, + 30 + ], + "Drawer|-05.50|+00.21|+02.68": [ + -5.25, + 3.25, + 180, + 30 + ], + "Drawer|-05.50|+00.52|+02.13": [ + -5.25, + 1.5, + 0, + 30 + ], + "Drawer|-05.50|+00.52|+02.68": [ + -5.25, + 3.25, + 180, + 30 + ], + "Dresser|-05.70|+00.02|+02.40": [ + -5.25, + 1.5, + 0, + 30 + ], + "SideTable|-00.31|+00.02|+01.52": [ + -0.75, + 2.0, + 90, + 30 + ], + "SideTable|-05.57|+00.02|+00.29": [ + -5.0, + 0.75, + 270, + 30 + ], + "Sofa|-03.13|+00.03|+00.61": [ + -3.25, + 1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..9e63fce2cd289e0c50458690a443b21b3d1666b8 GIT binary patch literal 1648 zcmbW$u}T9$6a~;xL?np#3Db?jRslhSwVh&FAr+tv8;`erLVrgwOYacY}9=w}bV|)z7ilzEwZ# zXZ@_7Q$G)zN3MC;JnT7+t9k63ht0$0;h#m?T>KsU75o|Oeazu~*!!^eVg0P1^|OA~ z@4fZ2e3sAhSw746J<4bKET84Ge3tKbk;n2_9?N5Sa?Hzdm2Y1@%V+tXlh5wsxXQOL zpXIwx9=ng@>Up{5V|gr(<*~ev{@lxB=bN2x*2nr-AM0C&KGw(j*#DUQPuRI;=a8Kv MHb0x6&A(i%0CTJP2LJ#7 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json new file mode 100644 index 000000000..f21beb23b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json @@ -0,0 +1,47 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Blinds", + "Pencil", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "Pen", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Shelf", + "Chair", + "LightSwitch", + "Bottle", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json new file mode 100644 index 000000000..99352e9a3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json @@ -0,0 +1,98 @@ +{ + "Cabinet|-00.30|+01.92|-02.50": [ + -1.0, + -2.75, + 90, + 0 + ], + "Cabinet|-00.33|+01.92|-03.39": [ + -1.0, + -2.75, + 180, + 0 + ], + "Cabinet|-00.58|+00.39|-01.80": [ + -1.25, + -2.25, + 0, + 30 + ], + "Cabinet|-00.58|+00.39|-02.20": [ + -1.5, + -2.75, + 0, + 30 + ], + "Cabinet|-00.58|+00.39|-03.40": [ + -1.75, + -3.0, + 90, + 30 + ], + "Cabinet|-00.88|+00.39|-03.42": [ + -1.25, + -2.5, + 90, + 30 + ], + "Cabinet|-00.88|+02.14|-03.69": [ + -1.5, + -2.75, + 180, + 0 + ], + "Cabinet|-01.76|+02.14|-03.69": [ + -1.25, + -2.75, + 180, + 0 + ], + "CounterTop|-00.30|+00.95|-02.79": [ + -1.0, + -3.0, + 90, + 30 + ], + "DiningTable|-02.43|+00.00|-01.69": [ + -1.75, + -1.5, + 270, + 30 + ], + "Fridge|-00.33|+00.00|-00.77": [ + -1.25, + -0.75, + 90, + 0 + ], + "GarbageCan|-01.94|00.00|-03.76": [ + -2.25, + -3.5, + 90, + 30 + ], + "Microwave|-01.32|+01.52|-03.80": [ + -1.25, + -3.0, + 180, + -30 + ], + "Shelf|-02.43|+00.15|-01.69": [ + -3.25, + -0.75, + 90, + 30 + ], + "Shelf|-02.43|+00.52|-01.69": [ + -3.75, + -1.75, + 90, + 0 + ], + "Sink|-00.35|+00.91|-02.01|SinkBasin": [ + -1.0, + -2.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..35ea786ab0b1dda667f3723868c36a81bc2c172f GIT binary patch literal 6448 zcmbW(y=oL;6b9hWunfx*mfigMubXNWQYnIpkg4nx8w)E5W`l(o*@%q@xd$)Ey_A$G zQ>54;h4I_-OmRx52~Q@O^PYDzGx`1Y{hN0mZj>M8=k#!P@@YPOIhnpXdOqEoOplJ| z-{%KkKOWByXaBzc`rymS?E3pBpAWvxuKnogi)VY2Cy)0gzb5~A3`#w=7pt#l`>U^8 z$(zX=$>ZepINU;QcdkZ+lMnS7CKzw`aob?nFXWBalFcog|~m~4ON?a%h- zCjGwsonK4mOR|3ayna|etRL3TMe2w3!}?+UuzpxStRL17>xcEj`eFUBepo-OAHIyg z7uFB!=Q8!f`eFUBepo-OAC{lxXZcxvzKDHT{$N4Sw5DJmU_s`o+m6X%ggfeGV-##EHBH;@~x$OEFa6q^09m@ zAIrz`v3#sgmbcfIdgznoWqDa%mY3yad0AeTm*r)7o0OO3WqDa%mY3yad0AeTm*r)7 z`zbHW%kr|kEHBH;^0K@vFU!mF4pLs0m*r)7Szh+M<>8{#gS~IKN#}dXCHX4uU%#&( z)(`84^~3sM{j9g89_|;`59^2Z!}?+U@G$n{^y!1#`ec2M z+ENdFvOZa#tWVY_>y!1#`s6|M#rotXo!6)H`ec2wK3SivPu3^vll3=lOFi_*TalOb z$NFRavHUDQ%g^$&{478Fdtm!)qvY#+7{+lTGL_F?<5eb_#1AGQz6yBYh)%kr|k zEHBH;^0K@vFU!mFvbKDt>e1>*gQ6m&13V}Jhm^Je>=@*^VxhhpUr3U*?cztPMXi=v-xa3o6qL6 z`E35(G@s39^VxhhpUr3U+5CHHKAX?xv-xa3o6qL6`S;U&HlNLB^VxhhpUr3UAEfzg zKAX?xv-xa3o6qJyO!L`%HlIDe*z=1$zu5DOn?dB*l* z`?3AFw^&`5{r|__-|YR(-rwx~&Gu#cvVA%BJ>}T9bL`tW_U#<|c8+~I$3C57pU$yQ e=h&xn?9y!1l+x`WazMf(L literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json new file mode 100644 index 000000000..7ddc799b5 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Plate", + "Candle", + "Pillow", + "Box", + "Boots", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "DeskLamp", + "Mirror", + "Painting", + "RoomDecor", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json new file mode 100644 index 000000000..b866dc6e2 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json @@ -0,0 +1,56 @@ +{ + "ArmChair|-02.69|+00.01|+04.62": [ + -3.0, + 5.25, + 180, + 30 + ], + "ArmChair|-03.66|+00.01|+04.56": [ + -4.25, + 5.0, + 90, + 30 + ], + "CoffeeTable|-03.13|+00.02|+08.53": [ + -3.5, + 7.75, + 0, + 30 + ], + "CoffeeTable|-03.24|+00.01|+06.60": [ + -2.5, + 6.5, + 270, + 30 + ], + "DiningTable|-02.90|+00.01|+02.23": [ + -1.5, + 2.25, + 270, + 30 + ], + "GarbageCan|-05.71|+00.01|+00.30": [ + -5.25, + 0.75, + 180, + 30 + ], + "SideTable|-00.40|+00.01|+00.36": [ + -1.0, + 0.75, + 90, + 30 + ], + "SideTable|-00.53|+00.01|+08.52": [ + -1.0, + 8.0, + 90, + 30 + ], + "Sofa|-01.71|+00.00|+06.45": [ + -2.5, + 6.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..33ebd8c0cd3be20377e952e1aa38d20c79148755 GIT binary patch literal 1152 zcmbW!JxT*X7=YnXL?q-8)2+f*A|fJWD?7!;!b%pi!9tAeij8;*59Aecgp`&R7AaB~ zoq3um-DY{_XTO)^{qp+a>Simvgx6}?4R?KY8mqI}Nma*cHt(PN_VIS!PrKjs^Y&rr zHtWNE`_yf`e|%KO!-G1$#s5B|@b|1g(t9;Y??vIX8iIZ2*ZKS^pJ(^keRe-IX~%v3 z&fnv&!k>kgh0S;0d^Uf(n9t_3`D{L$&*pQ;4=*NZf%WV(Y2EL^dRPzZVLhye)07Zc z59`@2dRPzZVLhye^{^h+!+Q3L9@fKpSP$!AJ*<$BQ7Y~){@?_Lfs#Ug7fmB&xZYH@L3zO>K`8vr<-JO@`0x@fb^X@$_#QJC av3);t%zWt0G5^QhA9?pN_c8DFJ&wQsFq4rjK=gk>!`;^SsFN@uYsMhc6G4dQ|;AzZyPI ztM&8g)9|%g`{?Yn$WD%n>@)lC>7~u-&YF8ZXzosM3SND0&o6@)!SmpsVEv21c0cQ9 z{j8t$^Ste2{j7f(`dL5gXZ@_7^|OA~zY6`VpI7bs@G@Ax-}SS8_PtZt{Qvq`AM0a% ztdI4v{hhYYezu?OXZzWHw!d4Z&9R^DXZtzLn%r*L-102X@+`j>@+{BtEZ+-xmS=gE i-w%0~XLZgFumnbwLnDT7n^*f&+1d9bpoQKp+r|tWWSu zYQDU`-)p<#s`Y?UoK_8|M(9|be+wVRhw)*2l{SBn`(b<-ALbn@{QxH- BbR7Ty literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json new file mode 100644 index 000000000..3b62eb5e3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json @@ -0,0 +1,43 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Curtains", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json new file mode 100644 index 000000000..9dbe15133 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json @@ -0,0 +1,128 @@ +{ + "Cabinet|+00.13|+00.39|+01.77": [ + 1.0, + 1.5, + 0, + 30 + ], + "Cabinet|+00.35|+00.39|+02.36": [ + 1.0, + 1.75, + 0, + 30 + ], + "Cabinet|+01.51|+00.39|+02.36": [ + 0.5, + 1.5, + 90, + 30 + ], + "Cabinet|+01.76|+00.39|+00.87": [ + 1.0, + 0.0, + 0, + 30 + ], + "Cabinet|+01.76|+00.39|+02.35": [ + 1.0, + 1.5, + 0, + 30 + ], + "Cabinet|+01.97|+02.11|+02.62": [ + 1.25, + 2.0, + 0, + 0 + ], + "Cabinet|+02.04|+01.81|+00.28": [ + 1.25, + 0.75, + 90, + 0 + ], + "Cabinet|+02.04|+01.81|+00.87": [ + 1.25, + 0.5, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+00.89": [ + 1.25, + 0.75, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+01.77": [ + 1.25, + 1.0, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+01.81": [ + 1.5, + 2.0, + 90, + -30 + ], + "Cabinet|+02.04|+02.11|+02.62": [ + 1.5, + 2.0, + 90, + -30 + ], + "CounterTop|+02.06|+00.97|+00.58": [ + 1.25, + 0.5, + 90, + 0 + ], + "DiningTable|-00.15|00.00|+01.07": [ + 0.5, + 1.0, + 270, + 30 + ], + "Drawer|+01.91|+00.77|+02.06": [ + 1.25, + 1.75, + 0, + 30 + ], + "Drawer|+02.17|+00.77|+00.58": [ + 1.25, + 1.0, + 180, + 30 + ], + "Drawer|-00.02|+00.77|+02.06": [ + 0.75, + 1.5, + 0, + 30 + ], + "Fridge|+02.10|+00.00|-00.28": [ + 1.0, + -0.25, + 90, + 30 + ], + "GarbageCan|-00.31|00.00|-00.81": [ + 0.25, + -0.25, + 180, + 30 + ], + "Microwave|-00.31|+00.93|+02.08": [ + 0.5, + 1.75, + 270, + 0 + ], + "Sink|+00.94|+00.94|+02.65|SinkBasin": [ + 1.0, + 2.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7b6b1a810345427619241bcd42635ed7ebe51d2a GIT binary patch literal 1712 zcmbW%F-ikL6oBDTBuEg?Fx@C@Wo5+LPO-7DlErLDAx3t^Mm&WFN{*7!GDQjt3uD}` z@Re>ee3Rt8KLqlAb#r-ryOUnhYZ*7)eOu0QIiH-CDwoNueQxW=yIDJKe(o>ohpyS& zchmZ*+4yKQs`ANkmEZDzpJCcQdyC(5zdv__Q}EaP@B2T4*TJh``v(17``A9VkL_do z*gkgJ8&CV)+t2p1{cJzm&xeb&ee5|19tOwXVGv$7*SvV@cdwuIvwqgk`pwnP`dL5g zXZ>ss$5X$1{j8t$vwm~*vwqgk`dL5gXL~uG`rYei{jA^T^s|1}&-z(E>u3F}gX5{+ zy?)m3efn8H>u3F}pY^kT*3Y^)p62@==Ck>1KAX?xv-uzW|DyS9KAX?xv-xcPGR$Z5 M*?cyi&0o&H0c$G?VE_OC literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json new file mode 100644 index 000000000..7abe48eea --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json @@ -0,0 +1,43 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Blinds", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "SideTable", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Shelf", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json new file mode 100644 index 000000000..a56b16123 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json @@ -0,0 +1,122 @@ +{ + "Cabinet|-00.33|+01.89|-02.51": [ + -1.0, + -2.75, + 90, + 0 + ], + "Cabinet|-00.34|+01.89|-01.29": [ + -1.0, + -1.75, + 90, + 0 + ], + "Cabinet|-00.35|+01.89|-03.29": [ + -1.25, + -3.0, + 90, + 0 + ], + "Cabinet|-00.63|+00.39|-01.61": [ + -1.5, + -2.0, + 0, + 30 + ], + "Cabinet|-00.63|+00.39|-02.51": [ + -1.25, + -3.0, + 90, + 30 + ], + "Cabinet|-00.63|+00.39|-03.01": [ + -1.25, + -2.5, + 90, + 30 + ], + "Cabinet|-01.01|+00.39|-03.37": [ + -1.75, + -2.5, + 90, + 30 + ], + "CounterTop|-00.33|+00.98|-01.45": [ + -1.0, + -1.75, + 90, + 30 + ], + "CounterTop|-01.94|+00.98|-03.67": [ + -1.0, + -3.0, + 90, + 30 + ], + "DiningTable|-03.22|00.00|-00.45": [ + -2.5, + -0.5, + 270, + 30 + ], + "DiningTable|-03.59|+00.00|-03.26": [ + -3.75, + -2.25, + 180, + 30 + ], + "Drawer|-00.48|+00.78|-02.74": [ + -1.5, + -2.25, + 90, + 0 + ], + "Drawer|-00.50|+00.78|-01.45": [ + -1.25, + -1.0, + 180, + 30 + ], + "Fridge|-00.31|+00.00|-00.65": [ + -1.25, + -0.75, + 90, + 30 + ], + "GarbageCan|-02.42|-00.03|-03.54": [ + -1.75, + -2.75, + 270, + 30 + ], + "Microwave|-00.22|+01.47|-02.06": [ + -1.0, + -2.0, + 90, + -30 + ], + "Shelf|-04.03|+00.26|-00.30": [ + -3.5, + -1.5, + 270, + 30 + ], + "Shelf|-04.03|+00.49|-00.30": [ + -3.5, + -1.25, + 270, + 30 + ], + "SideTable|-04.03|+00.00|-00.30": [ + -3.75, + -1.5, + 0, + 0 + ], + "Sink|-00.60|+00.93|-03.39|SinkBasin": [ + -1.0, + -3.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3ae68148a7960946b2d57b4b5964ef738dbcc3ce GIT binary patch literal 1168 zcmbWzu}Z{16ouij^(oSgLMlNK5!}j7v9Yj{;AXK9R}!%ipTY;)SI8r5xn+tJ78b5% zzJLQZPILM1J#){QdB42AxVqU1FX1)L>-MgRCq+D69LKVVi)HiNRFAjIW?p~y&#Q;F z-uB!3>Z#uH-qB%M9PF3HTk+qs8-C7uHP%h4UB=@yglT^ETffeDlX0K(YP_HO;=IbE zFAwh0ek>1`2g`$p?EXi_eab7x^be_Tk9l6@o%(4%mKV#5<;6pGUtaS*<>D(ZmKW3e zM|w<;>E))!^qAhe=rKL+QvTtOcgj7zJLxcAY%lhom=EUvnfCI-{sHsD{4hVv5A((R V!;EvPiTRuJ$NVvW%pda)voGD%xz_*y literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json new file mode 100644 index 000000000..017eb7373 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json @@ -0,0 +1,39 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json new file mode 100644 index 000000000..f3cc8c38c --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json @@ -0,0 +1,80 @@ +{ + "Cabinet|+01.32|+01.96|-01.31": [ + 1.0, + -0.75, + 180, + 0 + ], + "Cabinet|+01.34|+00.59|-01.11": [ + 0.75, + -0.75, + 180, + 30 + ], + "Cabinet|+01.99|+00.59|-01.11": [ + 1.25, + -0.5, + 90, + 30 + ], + "Cabinet|+01.99|+01.40|-01.11": [ + 1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-00.85|+00.59|-01.11": [ + -0.25, + -0.75, + 180, + 30 + ], + "Cabinet|-00.87|+01.96|-01.31": [ + -0.5, + -0.75, + 180, + 0 + ], + "Cabinet|-01.53|+00.59|-01.11": [ + -0.75, + -0.5, + 180, + 30 + ], + "CounterTop|+00.20|+01.08|-01.51": [ + 0.25, + -0.75, + 180, + 30 + ], + "CounterTop|+00.97|+01.08|+00.42": [ + 0.5, + -0.25, + 0, + 30 + ], + "Fridge|-01.29|+00.02|+01.83": [ + -0.25, + 1.75, + 270, + 30 + ], + "GarbageCan|+01.86|-00.02|+02.39": [ + 1.5, + 2.0, + 0, + 30 + ], + "Microwave|-01.19|+01.62|-01.28": [ + -1.0, + -0.5, + 180, + 0 + ], + "Sink|+00.93|+00.94|+00.32|SinkBasin": [ + 1.5, + -0.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e5a612c999fc9c14ac13d0d68e8f8c54b1fb94ce GIT binary patch literal 1856 zcmbWzu};EJ6oBC?qfgPTnlPvnF(xv(XZ zABktQ%guL6|I_k$b9a4ve~{kNdpWM=k9B!oloyjh*)Ph;tbVOW(}!6-u72iMqvv_G zo6ny{FV)URrzeAcadzAdsa0GPnuuo=VB{dMWf+kM&rO^|pDh z_hUWQV?EZ}gdXd$9_z8*I`mkN^;nPfoW7U!xXF82kDWU4)HBy(J#H?$3G2rW$5Y>2 zpY>VabM~^|aXj_+^Zfq23|qHbpY>Uv^;y5o|BpWFvp(x{lRK=x4t>_=X3-T{pWA$Y6MC%2 mdaTEK+t6b@)?+=^OT+Gt|C9AtkM&ru7kaG6dYtmr8-4>qmmo+0 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json new file mode 100644 index 000000000..0f770854d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json @@ -0,0 +1,45 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "SideTable", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json new file mode 100644 index 000000000..1d586c647 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json @@ -0,0 +1,110 @@ +{ + "Cabinet|+00.58|+00.78|-02.05": [ + -0.25, + -1.25, + 180, + 30 + ], + "Cabinet|-01.46|+00.78|+00.47": [ + -0.75, + 1.0, + 180, + 30 + ], + "Cabinet|-01.46|+00.78|+01.31": [ + -0.75, + 0.75, + 0, + 30 + ], + "Cabinet|-01.46|+00.78|-02.00": [ + -0.75, + -1.5, + 180, + 30 + ], + "CounterTop|-01.81|+01.36|+01.18": [ + -1.0, + 1.5, + 270, + 30 + ], + "Drawer|+00.65|+00.60|+00.68": [ + 0.0, + 0.25, + 0, + 30 + ], + "Drawer|+00.65|+00.60|+01.02": [ + -0.25, + 0.5, + 0, + 30 + ], + "Drawer|+00.65|+00.84|+00.68": [ + 0.0, + 0.25, + 0, + 30 + ], + "Drawer|+00.65|+00.84|+01.02": [ + 0.0, + 1.5, + 180, + 30 + ], + "Drawer|+00.65|+01.06|+00.68": [ + -0.25, + 0.0, + 90, + 0 + ], + "Drawer|+00.65|+01.06|+01.02": [ + -0.25, + 1.75, + 90, + 0 + ], + "Drawer|-01.61|+00.68|-00.43": [ + -1.0, + -1.0, + 0, + 30 + ], + "Drawer|-01.61|+00.68|-01.22": [ + -1.0, + -1.75, + 0, + 30 + ], + "Fridge|+01.01|+00.23|+01.92": [ + 0.0, + 2.0, + 90, + 0 + ], + "GarbageCan|-01.63|+00.21|+02.19": [ + -0.75, + 1.5, + 0, + 30 + ], + "Microwave|+00.99|+01.31|-02.16": [ + 0.0, + -1.75, + 90, + 0 + ], + "SideTable|+00.98|+00.21|+00.87": [ + 0.5, + 0.0, + 0, + 30 + ], + "Sink|-01.99|+01.14|-00.98|SinkBasin": [ + -0.25, + 0.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..4dff912e9ee932067c7ef80e65180eb5cb8d8469 GIT binary patch literal 1296 zcmbW$u}Z^07zgk(h=Wg&Eef4}I^%e369XodD(80m# z-7ny|ndSI>x%|KH()8o%=JNV>C%lHYYTV53+v=>W&L^kUpsXg-_N5&?-A&tZ^Ig9f zJJLR!FmdAV9{%#(AF5hib2;8N9OQb)1NuXEXc) D)dQw{ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json new file mode 100644 index 000000000..03562e5d5 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json @@ -0,0 +1,45 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "PepperShaker", + "Pan", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "CellPhone", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Mirror", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "Bottle", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json new file mode 100644 index 000000000..779e34a00 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json @@ -0,0 +1,218 @@ +{ + "Cabinet|+00.14|+01.67|-01.56": [ + 0.5, + -0.75, + 180, + -30 + ], + "Cabinet|+00.62|+01.87|-01.26": [ + 0.25, + -0.5, + 180, + 0 + ], + "Cabinet|+01.40|+01.87|-01.26": [ + 0.5, + -0.75, + 90, + 0 + ], + "Cabinet|+02.82|+01.77|-01.05": [ + 2.25, + -1.25, + 90, + -30 + ], + "Cabinet|+02.85|+00.42|+00.41": [ + 2.0, + 0.25, + 0, + 30 + ], + "Cabinet|+02.85|+00.42|-00.61": [ + 2.0, + -1.0, + 0, + 30 + ], + "Cabinet|+02.85|+00.42|-00.96": [ + 2.0, + -1.25, + 90, + 30 + ], + "Cabinet|+03.07|+01.67|-00.71": [ + 2.25, + -1.0, + 90, + -30 + ], + "Cabinet|-00.19|+01.67|-01.34": [ + 0.25, + -0.75, + 180, + 0 + ], + "Cabinet|-00.92|+01.67|-00.62": [ + -0.25, + -0.5, + 270, + 0 + ], + "CounterTop|+00.13|+00.94|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "CounterTop|+01.21|+00.94|+00.46": [ + 2.0, + 0.5, + 270, + 30 + ], + "CounterTop|+03.11|+00.94|+00.02": [ + 2.5, + 0.0, + 90, + 30 + ], + "CounterTop|-01.01|+00.94|-00.04": [ + -0.25, + 0.0, + 270, + 30 + ], + "Drawer|+00.38|+00.19|-01.51": [ + -0.25, + -0.25, + 90, + 30 + ], + "Drawer|+00.38|+00.38|-01.51": [ + 0.0, + -0.5, + 90, + 30 + ], + "Drawer|+00.38|+00.57|-01.51": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.38|+00.77|-01.51": [ + 0.0, + -0.75, + 90, + 30 + ], + "Drawer|+03.02|+00.77|+00.70": [ + 2.25, + 1.25, + 180, + 30 + ], + "Drawer|+03.02|+00.77|-00.41": [ + 2.25, + 0.0, + 180, + 30 + ], + "Drawer|+03.02|+00.77|-00.78": [ + 2.25, + -0.5, + 180, + 30 + ], + "Drawer|-00.86|+00.19|+00.66": [ + 0.0, + 1.5, + 270, + 30 + ], + "Drawer|-00.86|+00.19|+01.43": [ + 0.0, + 0.75, + 270, + 30 + ], + "Drawer|-00.86|+00.19|-00.10": [ + 0.0, + 0.75, + 270, + 30 + ], + "Drawer|-00.86|+00.39|+00.66": [ + 0.0, + 0.0, + 0, + 30 + ], + "Drawer|-00.86|+00.39|+01.43": [ + 0.0, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.39|-00.10": [ + 0.0, + -0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.58|+00.66": [ + -0.25, + 1.25, + 180, + 30 + ], + "Drawer|-00.86|+00.58|+01.43": [ + -0.25, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.58|-00.10": [ + -0.25, + 0.5, + 180, + 30 + ], + "Drawer|-00.86|+00.77|+00.66": [ + -0.25, + 1.25, + 180, + 30 + ], + "Drawer|-00.86|+00.77|+01.43": [ + -0.25, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.77|-00.10": [ + -0.25, + 0.75, + 180, + 30 + ], + "Fridge|+01.01|+00.03|-01.47": [ + 0.5, + -0.75, + 180, + 30 + ], + "Microwave|-01.03|+00.87|+01.43": [ + -0.25, + 1.25, + 270, + 0 + ], + "Sink|+03.08|+00.89|+00.09|SinkBasin": [ + 2.5, + 0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3db3b80bbcf3897bfc7704cfaef557cb0288243f GIT binary patch literal 1392 zcmbW#uTH~I7(nq$gW@Ub3P}})KOtEa4uV0TNW;1y7Dn1-hVT?T5U;RDn4GMrKp+_O z{z$lzns4XpUC&9kx9i)ho4dWR3NOX9=^onRJTES0r$w0;vqigX>!*V?=`Q@ZoSkvnJJG}FO**9a~&(47xre;%b~ED`TDE$T$1+Id(g)KA(+ATBOKs`(+6iVq+^gII%s$LM%s$LMES3G> M`#pT#53}DT9}otFVE_OC literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json new file mode 100644 index 000000000..83f093816 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Safe", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json new file mode 100644 index 000000000..17003e4fb --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|+01.24|+00.00|-00.90": [ + 0.25, + -0.75, + 90, + 30 + ], + "Desk|-00.79|+00.00|-01.03": [ + -0.5, + -0.75, + 270, + 30 + ], + "Drawer|+00.30|+00.17|+01.16": [ + 1.0, + 0.75, + 270, + 30 + ], + "Drawer|+00.30|+00.46|+01.16": [ + -0.25, + 0.75, + 90, + 30 + ], + "Drawer|+00.42|+00.53|-01.55": [ + 0.0, + -1.25, + 90, + 30 + ], + "Safe|+01.62|+00.00|+00.45": [ + 0.75, + 0.5, + 90, + 30 + ], + "Shelf|-00.47|+00.83|-02.04": [ + 0.0, + -0.75, + 180, + 30 + ], + "Shelf|-01.29|+01.45|-00.60": [ + -0.5, + -0.5, + 270, + 30 + ], + "Shelf|-01.29|+01.45|-01.34": [ + -0.25, + -1.0, + 270, + 30 + ], + "Shelf|-01.29|+01.81|-00.60": [ + -0.5, + -0.75, + 270, + 0 + ], + "Shelf|-01.29|+01.81|-01.34": [ + -0.5, + -0.75, + 270, + 0 + ], + "SideTable|+00.31|+00.00|+01.23": [ + 0.75, + 0.75, + 0, + 30 + ], + "SideTable|+00.41|+00.00|-01.68": [ + -0.25, + -1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..486b0356b0c3ee8b46af7af8a9dd36b5de09ae91 GIT binary patch literal 1168 zcmbW#p-#g<9Khkj@)UK2q>2PW2+14{f7_p$qU$mbf@!K>gtIKSOwe?OaM*!yL@JcQ@RV9)7_qdxO}?qhwd zkM*%W*2ntT`((Ybi{q%*yk6GJdRZ^)WxcGI{omO4h+P~dF;HDz5#xW&Y}PS literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json new file mode 100644 index 000000000..50bca7fac --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json @@ -0,0 +1,35 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "GarbageBag", + "Window", + "GarbageCan", + "Poster", + "Pen", + "Cloth", + "CreditCard", + "Book", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Vase", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json new file mode 100644 index 000000000..8704b6b03 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json @@ -0,0 +1,122 @@ +{ + "Bed|-01.05|+00.00|-01.85": [ + -1.0, + -1.0, + 180, + 30 + ], + "Desk|-01.71|+00.00|-00.37": [ + -1.0, + -0.5, + 270, + 30 + ], + "Drawer|-01.79|+00.10|-01.14": [ + -0.5, + -0.5, + 180, + 30 + ], + "Drawer|-01.79|+00.25|-01.14": [ + -0.75, + -0.75, + 180, + 30 + ], + "Drawer|-01.79|+00.39|-01.14": [ + -1.0, + -0.75, + 180, + 30 + ], + "Shelf|+01.31|+00.97|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.31|+01.17|-02.30": [ + 1.25, + -1.75, + 180, + 0 + ], + "Shelf|+01.31|+01.37|-02.30": [ + 1.25, + -1.75, + 180, + -30 + ], + "Shelf|+01.31|+01.57|-02.30": [ + 1.25, + -1.75, + 180, + 30 + ], + "Shelf|+01.32|+00.16|-02.30": [ + 0.75, + -1.25, + 90, + 30 + ], + "Shelf|+01.32|+00.46|-02.30": [ + 1.75, + -1.5, + 270, + 30 + ], + "Shelf|+01.59|+00.61|-02.31": [ + 1.25, + -1.75, + 180, + 30 + ], + "Shelf|+01.84|+00.97|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.84|+01.17|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.84|+01.37|-02.30": [ + 1.75, + -1.5, + 180, + -30 + ], + "Shelf|+01.84|+01.57|-02.30": [ + 1.75, + -1.5, + 180, + 30 + ], + "Shelf|+01.85|+00.15|-02.29": [ + 1.25, + -1.25, + 90, + 30 + ], + "Shelf|+01.85|+00.45|-02.30": [ + 1.25, + -1.5, + 90, + 30 + ], + "SideTable|+00.44|+00.04|-02.65": [ + 0.5, + -2.0, + 180, + 30 + ], + "SideTable|-01.82|+00.00|-01.14": [ + -1.0, + -0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d6e9934a5c069b8d62bd8481899144452732f6d5 GIT binary patch literal 1808 zcmbW#p-#hK6o%n4$yL-9k_jLoA%tX8I0y!TA`9z+AdGYbL%0eqXt&Tyn4GMbKp+_O zJQGJUbMl_Q{ob$bKCf@DZtnJqx8l8;){BRxIxnk>*;zF#tJ%DHZ6?q6^JZHA?k^`# zi+a0XJWgKfEgu{ooes;B!(sVR{`0qA{QcTdKf7f=SBW>VU&nMEZqs?6QWU%M$iwpS zI-PfkH<_2wGp0VPV7WL?eeLzd-Urqf>x=cp`tCS-@#>3Rhx62Lw;%NztRL17>xVb# zetVugy$^dn%!m0fALh%sI8Q!%KHPbpn0(IpmHr^ZN$8vF={Pz6z{FooN>AUee=f^xaPyR3ei)C-b{Foo}V}8t!`7!@@ s@?(C?kNGh_=EwZFjpr@KOfiG`obzEm%!m1~yg}s4!}72^EN?LW0Vy~K!2kdN literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json new file mode 100644 index 000000000..3aed39397 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "LaundryHamper", + "BasketBall", + "Pillow", + "Box", + "Statue", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Mug", + "Bed", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json new file mode 100644 index 000000000..74d9722a3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json @@ -0,0 +1,26 @@ +{ + "Bed|-01.30|+01.94|+01.44": [ + -0.25, + 1.75, + 270, + 0 + ], + "Desk|-00.99|+00.01|-01.41": [ + -1.0, + -0.75, + 180, + 30 + ], + "Drawer|-01.41|+00.23|-01.30": [ + -0.75, + -0.5, + 270, + 30 + ], + "Shelf|+00.00|+00.01|+00.04": [ + -1.0, + -0.75, + 180, + -30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0df7e536cd06e4bcfb2e6140507b7d48aca555e5 GIT binary patch literal 1472 zcmbW#u}Z^G6o>J+`V`rskVzbh2;JNi7Y8Q^HpM}#B;r!~6h2U2A&=0pV}=YJt>*p$ zp3y9a@7#0#UvHDIyNBER$CKgH}Id&}O7Q8j(2i}Sp=7@rnpUW_O8Ydw6vpVXu3XMQ<+ znpT_n^l|u7ZG3okQs&1;W&V->_d3XauVueo*RyS}lIQ7ule`G_zWbhEhUeMyojv!* zIuG;qlv%b&bNjLLvHd!GFMQWNakXDJ@3#}SAKQxf$f4>*J8@w01AMAI| z(&cwx=j6Ehea-cp&SN-Nq>Sq0{pY^kT*3bG`KkH}x-8pA%A?s)T cte?B@rcQIKe%8Oe&5!wsO!Xi;`m*7-#35%uM)2l%lChX z`JYkc<5jxn*FdxhZ59z)AsP=>T;6A)DAKb@$ z%m?$qs@z=V>-Uk5D7bVe%@vRTBnrGR6cZH;s#flOa;#K*SW|V!R432rr?Rz{uF40|SFd z&(nl6+U4Z^{+##MhVXs&aC`rF6h6XdJ}DN@Wqy_A*VD_qpXJke`Cg7+pXTMH_^aQH zXNzK2U%ZUpiXER0&IkSM;;f&2W&eCm!v0we+jFyQ&vn98Ue(@``+WL*>%@ooFdyc_e3%dOtr8#R!+e+z^I<+*@x+tAs}I`>=EwY) zA2-Q9zrK?xB93^W!R+=hqL>?>qBj{~K5yT*v#dJXjtq508?#FKP z?bGe$QpNeD}Yn~#@*>$zpU>AroaeshVb8;!hdmE_9`-z3ykh5Y6*t27$q&h6@{~L$ z>*qQ3<2KG^{a8Qt9GtKExvwAV$NI5;tRF|M!uqj(tRL&g`tcn7SU=CDAM3~Zv3{%{ zJBRaCKlk-x{a8QNkM(2ySU=W}^<({5Ki1E4=*Rl8eykts$NI5zIbZd2Uq9B5^<({b zh@ThMkM-j*eO^EB>&N=ptsm>h`muhjAM3~Zu^pVR`nj(k4|lZ~>&HX%VEtG>9@FQi zWc_?zKRfkf{a8QNkM(2ySU=W}?c#jZ&;23#v3{%{>&N=Beykts$NJf&AM3~Zv3{%{ z>&N=Beyktc$@yx(j`p+tY(Lx2_OtzLKikh^d_UQKwx8|yeYcCC;Kd1d{Kikjtv;BOCJ#0VQ&-SzZY(Lw7Nc-7- zwx8{1`}q+2c}}+9`}VW_Y(Lvyx^jB?{bl>vezu?OXZv}M{cJzm&-SzZJfyEzpW^s$ zSN}I$#htLfTi*9~fXDRtDOs;3zMfv(_T}_yx_Vvo_1biC?c*BOs|oAHda+)t7wg4( zv0hx_#d@(`tQYIW`YgI~dg;S$U+=R%?B|I~`n*2g*N63CeOMpXhxOsQwiMQf^Q~l>+rHjseYi>Qmt=i>ULV$n^xcEjo787a zu?sv+$+BI2Hf6AVu=#ih_sv%qhcq|FKIHjzuM2g4cl9(M^Nab#{Ngd_`HjACjQq-X z$uH&?cWEBx7xRnx#r)#G{+Ta(Vmch7{p~@I=`lT~w>Lee$Ml%K3;%-YF+CpB`+HaO RF+HZo^!|Y!(_{L6_67EG(ZT=# literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json new file mode 100644 index 000000000..abcb8f2a2 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json @@ -0,0 +1,31 @@ +[ + "BaseballBat", + "AlarmClock", + "BasketBall", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Poster", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json new file mode 100644 index 000000000..586254660 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json @@ -0,0 +1,50 @@ +{ + "Cabinet|-00.24|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "Cabinet|-00.62|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "Desk|-00.96|00.00|-01.94": [ + -0.5, + -1.25, + 180, + 30 + ], + "Drawer|+01.62|+00.16|-00.99": [ + 1.0, + -1.75, + 90, + 30 + ], + "Drawer|+01.62|+00.45|-00.99": [ + 0.75, + -1.5, + 0, + 30 + ], + "GarbageCan|+00.13|-00.03|-02.15": [ + 0.25, + -1.5, + 180, + 30 + ], + "Shelf|-00.96|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "SideTable|+01.69|+00.00|-00.99": [ + 1.25, + -1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2cb922b71da809507481b3a1c9411bc8f03074aa GIT binary patch literal 3760 zcmbW%ziJdw6bImI5RnkXzp1BNg{`(xL~tuRC5?rZEXf87F|sQ*;#2rQd4+j|lqsi} zB87!9bG`+CrQ2M-d*`0>JG06DdiVbA(T7{@d;2jvS#OUwvzOiM)#;1byqle#ZN6<* zUp}5~PS$_-->g1w*Vp^oPphx%Yd>8qp3l3*vw8Qk`_IpQyZKz4PwQ2!eRw);ZFm0q z-{&vFm*F8ihOffE!)+P;&L@wx%FEMfYur~omY3z_A)c4lxx6edd!Iw(WBItRek>o$ z$3r|nhUN3TJeQG&yM?}z1Q`B{D*iyf7pXF!yS$>wEckjRElwV)@S$>wE z)#Y5}w=X{r-gm9?JC~pR|FhpK9_#zi*L-X~HXoah&Byw1uI95p)Ld*nHXoah&Bx}` z$9!x)HXoah&Bx|reK}Y2**71XkIl#CW2?Hks&8L?R-e^p^|KD=s=j^oS$$UDJ$>18 zoU8iw)#ttC^o_B8?&-(+v3s1We)iS3uRg2K>a#kWtNP|rpVepeS$$UT_Oji4)MNEn zJ$C<2+-LXMeRltD+-LXMeKrq!e!uE@o}C}WIXk}>=d2%lU-#>I_gQ~-pZog#eNgvX zeYmgRL-zZ^-XF`u@~}KC5Bq!Ly~@SDcb5NQJy-D?%g^$&{477q&+@bUEI-T7^0WMp zB0tN|^0Ry_AIrz`v3x8a`#)j*9#>xdSU=W}^<({5{U=eM)o1lteO8~a-ucY_=ziyv5ch|S~C*du;SIf44?5c}cU9M(T9jn#4d+nN+hjq7XfA3#4&wYEm z-#;~*_UNGp2z0xi+OAwo5$v{d2AksMSkyj-lVXeUD3mOSPu_*Ki0!~SP$!AJ!5qU zelM(t_3)5;SP$!AJv>?XYrN`l)x&x?c^~M0!N^vq_D6Q-F*~O zy3OYe%=^G|wOOvWJ#|xeliGam%uJhkHZ_qp+1XuPa@w6;YQOVEa?EWz&kxDPwmcY5 zB0U;L`l0_lef2wa;qx65ehF>@S0Uk2u(v7I-H-hQ#!upd@xl1uGWcK;k4${b@xl1u zD)`}Aa3h$0*#pa@zncdiOg~INOg~INUfvt#Ians&&zydk{*DWO#U6byeK32lO!}D9 S2RHm5GW4^DA7&56SH&MW35^s0 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json new file mode 100644 index 000000000..31b0cedac --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json @@ -0,0 +1,34 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "TissueBox", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json new file mode 100644 index 000000000..fa062d428 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|-01.74|+00.00|-00.07": [ + -0.75, + 0.0, + 270, + 30 + ], + "Desk|+00.63|+00.00|-01.56": [ + -0.75, + -1.5, + 90, + 30 + ], + "Drawer|+00.27|+00.16|-01.43": [ + -0.25, + -0.25, + 90, + 30 + ], + "Drawer|+00.27|+00.35|-01.43": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.27|+00.55|-01.43": [ + 0.75, + -0.5, + 270, + 30 + ], + "Drawer|-00.16|+00.16|-01.43": [ + -0.75, + -0.25, + 90, + 30 + ], + "Drawer|-00.16|+00.35|-01.43": [ + 0.5, + -0.25, + 270, + 30 + ], + "Drawer|-00.16|+00.55|-01.43": [ + 0.25, + -0.5, + 270, + 30 + ], + "Shelf|+01.41|+00.18|-01.51": [ + 0.75, + -0.25, + 90, + 30 + ], + "Shelf|+01.41|+00.38|-01.51": [ + 1.0, + -0.5, + 90, + 30 + ], + "Shelf|+01.41|+00.57|-01.51": [ + 1.0, + -0.5, + 90, + 30 + ], + "Shelf|+01.54|+00.49|-00.48": [ + 0.75, + 0.0, + 180, + 30 + ], + "SideTable|+01.56|+00.00|-00.47": [ + 1.0, + -0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..f10c008a9a66b66ee3094394f56b5cc292d50f9a GIT binary patch literal 1200 zcmbW!uTH~Y6o=t&lUzmJ2T2uT5JJKf4uV0TNW;1y$VOU%AzTF)v|HFEOioTzAP@}N zM{p!HC-3R+&*}DYeS39tH%hPREzj!qp~+`OKA)fFvdHsg^U_p{`(-n$fA*KvQ(N!% z?PK*^@A+_YQWnQYW$|A8_c=(v&-S99-Kw9vz+K?az+Zvo?N)#Duskde%fs@vArH&L z^6+}NZ!`Eef#rMe`>}j1AG;UpTZcZZ59`C-a39u(^Q-9?Y-F}=I#F+Fx4<~R8;<^9Q|NrwkbdQAU)M%DVMUw-FanOnh|!P~{VW!Ay&``mqYe<$2$_t|}}%01Q_ zg&ym%9_#VfbG3f>Gx#I;J@_s7HQ2spUG`@CvVGaUY+tr7+n4Rj_GSCBY0o(A>)gI< zU$!sXm+i~;W&5&yS>Imztk3$a&-$$Icj~h~>$5)Vv%ddLpY>Uv^;w_wO?}p9eb#4v zHg)6FcdpO+tk3$f!*S|6*Jpj!chC2-_c%^{=lZPgJ$=?^_c%^{=lag|S)cV;hyUg` D0lgP8 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json new file mode 100644 index 000000000..67d605fac --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json @@ -0,0 +1,28 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Mug", + "Bed", + "TableTopDecor", + "CoffeeTable", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json new file mode 100644 index 000000000..9d1fe11f2 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json @@ -0,0 +1,110 @@ +{ + "Bed|-02.98|+00.01|-01.18": [ + -1.75, + -1.0, + 270, + 30 + ], + "CoffeeTable|-00.50|+00.01|-03.99": [ + -1.0, + -2.5, + 180, + 0 + ], + "Desk|-00.86|+00.01|-04.03": [ + -0.75, + -3.25, + 180, + 30 + ], + "Drawer|-00.50|+00.07|-03.80": [ + -1.25, + -2.5, + 90, + 30 + ], + "Drawer|-00.50|+00.23|-03.80": [ + -1.25, + -2.75, + 90, + 30 + ], + "Drawer|-00.50|+00.39|-03.80": [ + -1.25, + -2.75, + 90, + 30 + ], + "Drawer|-03.61|+00.11|-03.26": [ + -2.25, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.11|-04.06": [ + -2.25, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.30|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.30|-04.06": [ + -2.5, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.49|-03.26": [ + -2.5, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.49|-04.06": [ + -2.5, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.69|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.69|-04.06": [ + -2.75, + -3.5, + 180, + 30 + ], + "Drawer|-03.61|+00.88|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.88|-04.06": [ + -2.75, + -3.5, + 180, + 30 + ], + "Dresser|-03.65|+00.01|-03.66": [ + -3.0, + -3.5, + 270, + 30 + ], + "GarbageCan|-01.84|-00.02|-03.90": [ + -2.25, + -4.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..6d83f59eb4e355ad5d0e7f104faadc30d538014d GIT binary patch literal 1056 zcmbWzu}Z^G7>42F>Q!Vr3Yi3-pY!=jtDKl7{Rxo>y# z{;7FwcYJa_sjIWox>{BLeU8)bv;N%YSIHsp{%uN!_tU@UH|6}cq&}<<>%&9o!|TBM z$Iy@UWBph^){i&EhsVJD()Zz^?1lL;Kjz2$m>)~tnEdAam>=_Fe$0>gqX)<2Kg`Sj s#Qc~a^W$x}Zyz3eV)t-N|HIrq*gn`k*gjb5jj7*UKOTKwN&Un08!2+Cy8r+H literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json new file mode 100644 index 000000000..98fd21897 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json @@ -0,0 +1,30 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "Desktop", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "HousePlant", + "Laptop", + "Bed", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json new file mode 100644 index 000000000..bf39297e3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json @@ -0,0 +1,44 @@ +{ + "Bed|-01.70|+00.00|-00.45": [ + -0.75, + -0.25, + 270, + 30 + ], + "Desk|+00.62|+00.00|-01.51": [ + 1.0, + -1.0, + 90, + 30 + ], + "Drawer|-00.56|+00.16|+00.46": [ + 0.25, + -0.25, + 0, + 30 + ], + "Drawer|-00.56|+00.46|+00.46": [ + 0.0, + -0.25, + 270, + 30 + ], + "GarbageCan|+01.66|-00.02|-00.39": [ + 1.0, + 0.0, + 90, + 30 + ], + "Shelf|+01.62|+00.56|-00.80": [ + 0.25, + -1.5, + 90, + 0 + ], + "SideTable|-00.56|00.00|+00.53": [ + 0.0, + 0.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..8fb312dceb153889f4dd5423cd0fb302f6383aad GIT binary patch literal 1680 zcmbW$uTH~29Ki8nd5XG1GKJw!Na}D93<5(h&^dDR`j0LLXsrvZA75f>vr z%{O6x_qD!D>)z96eb#6Da2)l`>$AS+^jV+VbY9kH`*Ixh&Fh=jXMJu{pY>UvbvTat zO*yRSvp(yyKI^kS>$AS!xjuJ(AL)Gh*7aGR^;w_w{jc;{pY>Uv^;w_wS-%b6KkKtT Z>$5)VvpzSz*EBkp^*DCn`963z`Ui(uBv$|c literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json new file mode 100644 index 000000000..0f7129662 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "LaundryHamper", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Poster", + "Pen", + "Cloth", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Mirror", + "Floor", + "Safe", + "Laptop", + "Bed", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json new file mode 100644 index 000000000..8145411a3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json @@ -0,0 +1,92 @@ +{ + "Bed|+01.38|+00.00|+00.07": [ + 1.5, + 1.0, + 180, + 30 + ], + "Drawer|+00.41|+00.11|-01.63": [ + -0.5, + -0.25, + 90, + 30 + ], + "Drawer|+00.41|+00.29|-01.63": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.41|+00.49|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.41|+00.68|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.41|+00.87|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.11|-01.63": [ + -1.25, + -0.25, + 90, + 30 + ], + "Drawer|-00.39|+00.29|-01.63": [ + -1.25, + -0.5, + 90, + 30 + ], + "Drawer|-00.39|+00.49|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.68|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.87|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Dresser|+00.01|+00.00|-01.68": [ + 1.0, + -1.25, + 270, + 30 + ], + "GarbageCan|-02.21|-00.02|-01.74": [ + -1.75, + -1.25, + 270, + 30 + ], + "Safe|+01.64|+00.00|-02.04": [ + 1.0, + -1.25, + 90, + 30 + ], + "SideTable|+02.24|00.00|+01.33": [ + 1.75, + 1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..998979a6b0345090aaf7d62dee99b1c068d3b895 GIT binary patch literal 1632 zcmbW$u}Z^G6b9g{h!me9TNE;hgNo2hZiMP_CI(E#Ep@W09 z$+w)*ESK;0p8vlI^!xVy=I&uHeWcHPS}mUH{4&e0X6Jd4<+FMHUQb>h=k>Ju+rOT? zEUNAP;(78`ZGC)kR%E9qMfR2b_c=O^SRTt`c`UC9c`T3RvHAXMrR00Dc{a~hIdPR|UmmyN z-oBGL@5%1X`dKc=Rlj}b<37i=9rum)yI^_F>0xsm*Jj9*Yo5)sd3N6a!g+R{o&O2% z!OpY$rLzAH=2;(`XY>1Ep3Sp)_MYrL*gaX_L78@s`?5aP$NE?w>tlU~p^x>kKGw(j USRd;fg+A8D`dA<9V|}CY7Xp6Z6aWAK literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json new file mode 100644 index 000000000..8d246757f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ArmChair", + "TennisRacket", + "Shelf", + "Dresser", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json new file mode 100644 index 000000000..3f9814429 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json @@ -0,0 +1,158 @@ +{ + "ArmChair|+01.71|00.00|+01.53": [ + 1.5, + 2.25, + 180, + 30 + ], + "Bed|-00.87|+00.01|-00.92": [ + 0.25, + -0.75, + 270, + 30 + ], + "Cabinet|-00.65|+00.27|+02.25": [ + 0.75, + 1.5, + 0, + 30 + ], + "Desk|+01.81|+00.00|-00.01": [ + 1.25, + -1.0, + 90, + 30 + ], + "Desk|-00.66|+00.01|+01.81": [ + 0.25, + 2.0, + 270, + 30 + ], + "Drawer|+01.69|+00.16|-00.38": [ + 0.5, + 0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.16|-00.81": [ + 0.5, + -0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.35|-00.38": [ + 0.5, + 0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.35|-00.81": [ + 0.75, + -0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.55|-00.38": [ + 0.75, + 0.0, + 180, + 30 + ], + "Drawer|+01.69|+00.55|-00.81": [ + 0.75, + -1.25, + 0, + 30 + ], + "Drawer|-00.55|+00.16|+02.94": [ + 0.25, + 2.25, + 0, + 30 + ], + "Drawer|-00.55|+00.38|+02.94": [ + 0.25, + 2.25, + 0, + 30 + ], + "Drawer|-00.55|+00.57|+02.94": [ + 0.25, + 2.5, + 270, + 30 + ], + "Drawer|-00.55|+00.58|+02.25": [ + 0.25, + 2.75, + 180, + 30 + ], + "Drawer|-00.66|+00.23|-01.31": [ + 0.5, + -0.5, + 180, + 30 + ], + "Drawer|-00.66|+00.55|-01.31": [ + 0.25, + -0.75, + 180, + 30 + ], + "Drawer|-00.66|+00.83|-01.31": [ + 0.25, + -0.75, + 180, + 30 + ], + "Dresser|-00.67|+00.00|+02.94": [ + 0.25, + 2.5, + 270, + 30 + ], + "GarbageCan|+02.02|-00.04|-01.24": [ + 1.5, + -1.5, + 90, + 30 + ], + "Shelf|+01.77|+00.18|+00.76": [ + 0.5, + 0.25, + 0, + 30 + ], + "Shelf|+01.77|+00.18|+00.94": [ + 0.5, + 0.5, + 0, + 30 + ], + "Shelf|+01.77|+00.38|+00.76": [ + 0.75, + 1.25, + 180, + 30 + ], + "Shelf|+01.77|+00.38|+00.94": [ + 0.75, + 0.5, + 0, + 30 + ], + "Shelf|+01.77|+00.57|+00.76": [ + 0.75, + 1.25, + 180, + 30 + ], + "Shelf|+01.77|+00.57|+00.94": [ + 0.75, + 0.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..5d5660830bfc55bf6e7fb23ecc3720fa4ffb1095 GIT binary patch literal 1680 zcmbW!ElvYb6o%nTC94=WkW^v#2}!GP5DWrE8af0)D47xrVHGT>TbLzOR#uFtsGxA~ zQ*k6?PTqTF-hAKO@0+{p+xvs`kv{8bGkkhSI;)3O{WNRe+sW(0terN$=U0=L zd9yp8KTqD89Uq;a4y%*nVf9u0_c=^|&vKOKc9CaScvILOuj0PE*O%D^&eoLn`|>^J z$NYF5-tPl%0&fGSaZbQD2)tb6{klx~ao(ncyW+?4WBIZCxDVgUZ!bTVAIpzdCAX;$ z?!sQ5{l4VE`e1#qKDZCx>tnAE)(7i@-IE@AV(;NN^>wZx=cp`eJ=C zpPYP{5A$I@%%^8x?gR5-KFo*ty5ix(e3%dO;dSx&&wQ8<^I<;B=brd5ALhe+n9t>tDDQ~+r8qoc&p}Zf8SMSWp%zdt?IH`EW4MkdAeJ6^Y&~1qIvAw z-G2YjJhwX^9G}$X(P3S_m;b%?i|=cgO>0_B>pJr$^O!khHg8=0p2y~~d7NS%JHLr} z&a?Bpjpy0(>v*1ru)b5xF1XZb9j<#4{rALBd9XZb9jq$$MRV|%V+tV UVxIrOnA!JmUmqT_^ZIOOp9X=z82|tP literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json new file mode 100644 index 000000000..36b55cead --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "Curtains", + "BasketBall", + "Pillow", + "Pencil", + "SideTable", + "KeyChain", + "GarbageBag", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Footstool", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json new file mode 100644 index 000000000..4461adc3d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json @@ -0,0 +1,50 @@ +{ + "Bed|-01.04|+00.01|-00.69": [ + -0.5, + 0.25, + 180, + 30 + ], + "Desk|+01.52|+00.00|+00.39": [ + 0.75, + 0.5, + 90, + 30 + ], + "Desk|-01.72|+00.00|+00.92": [ + -1.0, + 1.0, + 270, + 30 + ], + "Shelf|-01.70|+00.16|+01.54": [ + -0.5, + 0.75, + 0, + 30 + ], + "Shelf|-01.70|+00.38|+01.54": [ + -0.5, + 0.75, + 0, + 30 + ], + "Shelf|-01.70|+00.57|+01.54": [ + -0.75, + 1.0, + 0, + 30 + ], + "Shelf|-01.84|+01.08|+01.24": [ + -1.25, + 1.5, + 270, + 30 + ], + "SideTable|+00.63|+00.00|-01.71": [ + 0.25, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..47b25677080275d02a7ad4d0d6c6cf0bced364f2 GIT binary patch literal 1600 zcmbW$u};E39KhkTA;$0&-Kq%_lNu8`xoKP+oD7i?1|y~z7vod-K=KGY0wW_s2L=Yw zyKlMCE|;(E{r;uE*X{ky-NR9M4#-i|aXUv^;v(F^;w_wS)cV; zKfbjPydTzQeb#4v)?ba{nWBy>>$5)Vvp(yuvp(yyKI^kS>-(L1e%5Dw)@Oaz-)7Ix c`mE3Ttk33jsqg>C{(tQAvH5I1o7atg0H)fy0{{R3 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json new file mode 100644 index 000000000..8749b01dc --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json @@ -0,0 +1,27 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Bed", + "ArmChair", + "TissueBox", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json new file mode 100644 index 000000000..6efd3c144 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json @@ -0,0 +1,44 @@ +{ + "ArmChair|+00.85|00.00|-02.14": [ + 1.5, + -1.75, + 270, + 30 + ], + "Bed|+00.91|+00.00|+00.14": [ + 0.75, + 1.25, + 180, + 30 + ], + "Desk|+03.24|+00.00|-01.59": [ + 3.0, + -1.0, + 180, + 30 + ], + "Drawer|+00.33|+00.62|+01.30": [ + 1.5, + 1.25, + 270, + 0 + ], + "Drawer|+00.33|+00.62|-01.02": [ + 1.5, + -1.75, + 270, + 0 + ], + "SideTable|+00.28|+00.00|+01.30": [ + 0.75, + 1.25, + 270, + 30 + ], + "SideTable|+00.28|+00.00|-01.02": [ + 0.75, + -1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d55bd506cbc30551aafd5e5009bd845a49075629 GIT binary patch literal 1792 zcmbW$u};EJ6b9fcqfgPTnlPwwFvbKXH;s#flOa;#K*SW|Vtfi8h*#(%Ffw-N;J_f- z`_+y-~S zpTXN;dFGJE@>m|rV|ku~JeJ4uSRTvs9Obb*mdElqjr-@z@|#t^FQ4VJe3sAhd64^9 zU*DFJKJN1G!}?es>*K-Lr+(Gf&(aIWAkv6=V9}(dDuK`9*(Q~x9|S9qb~?*2~Yq4 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json new file mode 100644 index 000000000..43380c052 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json @@ -0,0 +1,30 @@ +[ + "BaseballBat", + "AlarmClock", + "Curtains", + "Pillow", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "Cloth", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ArmChair", + "Shelf", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json new file mode 100644 index 000000000..ab36ff242 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json @@ -0,0 +1,122 @@ +{ + "ArmChair|+02.57|+00.00|-00.82": [ + 2.0, + -0.5, + 90, + 30 + ], + "Bed|-00.75|-00.02|+00.11": [ + 0.75, + 0.0, + 270, + 30 + ], + "Cabinet|+02.48|+00.50|+01.00": [ + 1.75, + 0.25, + 0, + 30 + ], + "Cabinet|+02.48|+00.50|+01.01": [ + 1.75, + 1.75, + 180, + 30 + ], + "Cabinet|+02.48|+00.50|+02.03": [ + 1.75, + 1.25, + 0, + 30 + ], + "Cabinet|+02.48|+00.50|-00.02": [ + 1.75, + 0.75, + 180, + 30 + ], + "Drawer|+02.57|+00.90|+00.23": [ + 2.0, + -0.25, + 0, + 30 + ], + "Drawer|+02.57|+00.90|+00.75": [ + 2.0, + 1.0, + 180, + 30 + ], + "Drawer|+02.57|+00.90|+01.26": [ + 2.0, + 1.0, + 0, + 30 + ], + "Drawer|+02.57|+00.90|+01.78": [ + 2.0, + 1.5, + 0, + 30 + ], + "Drawer|-01.53|+00.46|+01.48": [ + -1.0, + 1.5, + 270, + 30 + ], + "Drawer|-01.53|+00.46|-01.25": [ + -1.0, + -1.25, + 270, + 30 + ], + "Dresser|+02.82|+00.00|+01.01": [ + 2.25, + 0.75, + 90, + 30 + ], + "GarbageCan|+01.35|+00.00|-01.69": [ + 0.75, + -1.0, + 90, + 30 + ], + "Shelf|-01.55|+00.04|+01.33": [ + 0.0, + 1.5, + 270, + 30 + ], + "Shelf|-01.55|+00.04|+01.60": [ + -0.5, + 1.5, + 270, + 30 + ], + "Shelf|-01.55|+00.04|-01.13": [ + -0.5, + -1.25, + 270, + 30 + ], + "Shelf|-01.55|+00.04|-01.40": [ + 0.0, + -1.25, + 270, + 30 + ], + "SideTable|-01.60|+00.00|+01.48": [ + -1.0, + 1.5, + 270, + 30 + ], + "SideTable|-01.60|+00.00|-01.25": [ + -1.0, + -1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0add409d466e1b9f7b3b2198c7ab57455ca4ff83 GIT binary patch literal 3184 zcmbW&u}ULB7{Kvy5jpNDwp)cXTAd=em7QX9#Z?kCVj(Jt*oaTz1G$f|k6>xJ#THwn zFvraAz^}X%PJRDv#|hKQWKZWAoTNHjmBYb(znp z&2#@bGgV!FqKEac9@fKpSP$!AJzTZ9gR?e2yZlTa>tlVakM*%W*2ns|YI6q{rS*G$ zrjPZpKGw(jcq-o?>tlUfwYh_{Qkp^^>tlVakM;3X`gk3z&+GbF-x&H>AM4|x%wv75 zkIfsxJT{NbWAk_{^VvN1d9dFbe+PX}>~mq=>>Q4(zo+*5a!+=D?n^(rKf6D>Kab)4 z?(cQ?XZP3X{_Otj{_OtjT#l>z+joCtQ`SmhXf0 zupYMRh^rp^dRPzZ;j#3v9@fKp;#`ia9{YND@OhL~kJt6E9@Z7-a9qu|Z$6vP=Ck`d z$9&es-p6q@-@f^5KAZ1-=Ck>1K0AlwYQBB*+2_yxe{j|2BG&6%z1)ZIU9Z>mvU54E fdhP3Fy{wn@IY%GsV|}cToy&36XI~%dn@+v}36aM& literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json new file mode 100644 index 000000000..52144cfd1 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Sofa", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Safe", + "Laptop", + "Mug", + "Bed", + "Dresser", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json new file mode 100644 index 000000000..e202bfd8c --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|-01.61|-00.03|-01.86": [ + -1.5, + -0.75, + 180, + 30 + ], + "Desk|+02.32|-00.01|-03.22": [ + 2.0, + -2.5, + 180, + 30 + ], + "Drawer|+01.98|+00.21|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+01.98|+00.49|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+01.98|+00.73|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+02.64|+00.17|+01.51": [ + 2.0, + 1.0, + 0, + 30 + ], + "Drawer|+02.64|+00.45|+01.51": [ + 2.0, + 1.0, + 0, + 30 + ], + "Dresser|+02.68|+00.00|+01.51": [ + 2.25, + 1.5, + 90, + 30 + ], + "GarbageCan|+01.34|+00.00|-03.38": [ + 1.0, + -3.0, + 90, + 30 + ], + "Safe|+02.72|+01.23|+01.78": [ + 2.25, + 1.5, + 90, + 0 + ], + "SideTable|-02.42|00.00|-00.51": [ + -2.0, + -0.5, + 270, + 30 + ], + "SideTable|-02.42|00.00|-03.15": [ + -2.0, + -3.0, + 270, + 30 + ], + "Sofa|+02.38|+00.01|-00.29": [ + 1.5, + -0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..02f4fc67b619400618029e51b4123a4047667b80 GIT binary patch literal 1552 zcmbW#y-LGS7=YoUh=^B_Eef5Sst9#*Q(PRJq}YgqSV_f2yb3R6bS@U)Q%+H+MVfJ$;m;YVuH*XGMAb*e`oU`8clM>fy`%xE@u%=P!rP zlWKi_@-%#{);{W=_KK6^Uh!G{_c%;{$70&8>APFo;Cb*YxCzeFl6lQwd;TnV9^3}& zTTQq7SRdtlVakM*(rI_+os*?!-F{cJzm?>_Bk z`+1SyFE4}5^PJ3M^VmE#k5_pt*vB?=i1zKAX?xv-xbkRX?}+dTjp2)2`J2+F;+I-+dR{g#GS& R^LxHNyDrC7uk(86gCBu)^&tQN literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json new file mode 100644 index 000000000..00fe94151 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json @@ -0,0 +1,29 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "VacuumCleaner", + "CellPhone", + "DeskLamp", + "Drawer", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "Shelf", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json new file mode 100644 index 000000000..18df29209 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json @@ -0,0 +1,110 @@ +{ + "Bed|-00.84|00.00|-00.36": [ + -0.75, + 0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.09|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.09|-02.20": [ + 0.25, + -1.5, + 180, + 30 + ], + "Drawer|+01.60|+00.25|-01.46": [ + 0.0, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.25|-02.20": [ + 0.0, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.41|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.41|-02.20": [ + 0.5, + -1.5, + 180, + 30 + ], + "Drawer|+01.60|+00.57|-01.46": [ + 0.25, + -2.0, + 90, + 0 + ], + "Drawer|+01.60|+00.57|-02.20": [ + 0.25, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.73|-01.46": [ + 0.5, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.73|-02.20": [ + 0.5, + -2.0, + 90, + 0 + ], + "Dresser|+01.63|+00.00|-01.83": [ + 1.0, + -1.75, + 90, + 30 + ], + "GarbageCan|+03.38|+00.00|+00.22": [ + 2.5, + -0.25, + 0, + 30 + ], + "Shelf|+00.02|+00.18|-02.51": [ + -0.5, + -1.5, + 90, + 30 + ], + "Shelf|+00.24|+00.34|-02.51": [ + 0.75, + -1.75, + 270, + 30 + ], + "Shelf|+00.25|+00.67|-02.52": [ + 0.75, + -2.0, + 270, + 30 + ], + "Shelf|+00.36|+00.18|-02.51": [ + -0.25, + -1.5, + 90, + 30 + ], + "Shelf|+00.47|+00.34|-02.51": [ + 0.0, + -1.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..56831d6298ed3e097660d18a1df40c23b83aca2c GIT binary patch literal 3040 zcmbW&F-{vn6b9glg(8FyO5zJ_w;;K}6^fAJDjg9GMJi-rTNDV89i>4zMGj<+ut%VD zxy2SPTm+c;EcumjGx~NsZ~x!e%ikYY7neUjq~GbOo=g`v^ZIL5pU=+fK~>Kl=D+6S z`|F4KWcqgf`}l4#eZ9W89Y0QAeSCU098|-TLG`El&(}eEf4wa8x+!ZDoOe^&?tj~T z|4Z;H*!*>wYd)LLO*zlzv-xa(7v{71Y(AUM=5t%}a2LD|-UO#nPT+hmcrW;4@P647dIsz>(BbL{@jK0`rFr^_2*v6%lfnatUv3|`g2oyuR?#;pY><`S%2y#QSnw<#AmeZhanQmB+q3EDy`$K60}6aa`qby)8Ld z9+rpYVR_7zhvi}CIIi-zE)UDY^04o1NXOY zp68f(Y#y7(&U@}T&(5>wl;@)J>^wWa^>e<`8|8Jg-1R!R3vPquF;5)p=Q6OwX!8SxslnTQhojm^I_c&-JU( z^L(G7caEdTjA48NbvBF=srXHm!5Z{zIMarWCdi!^&_hRnNk zp8MO(U1q;;{W`n9%Dl`RQ-xsv@-klGQ2%w2SwHLbGxcNrSU=W}^<({5Kh}?9`Vd$@ z){pgL{n*qipZdA3AM3~Zv3{%{>&N=Beykts$Gtk8(8ejR9?oOuaZ$&8>^yd!={$BG zo1T;PY&~1=Ia<%F^nYgi*?!O6ezu?2={(+K?lNyP?=s8dJbAo#c~~Bnhvi{;SRR&# z4m;IYnI|slxClBfV{o?o8eoV9YoaQEQ3hew>UUwclkGHeQi|voR`Sm#E z^LP_jeh7IikL9s^AM#ip%VXbzQ}*~T`Ev@)hxxF)|0s{;u{_oX^O<~@5A$I@Z1Tj( zXPpo8VZNBdaq?N`!+g$p4|Wd6DbFj9<*_`DldsSBmJjn`KFo*X9P)h|vcC`PUfFjq pa0=)3``gc6tRL17>xcClLqDt^)(@xL59^0h_G108eptV8_64mfLl9g=T_LFfK?osP6%K+ypvc0yOb|v|f+1W57qna0B~(sUOdt>p zdVWiGB*%Pv&Y$o3-tP0}?)vtAFT92KVp6w{O>vPIm(%m2%!}!~d2Pne5A$YH|L$Ln zpW1q}-_FJ_^@fkmPRjiBxXeHD|E|OEx7MSf_KTr@CH$RmsCMrkB&^>m>4){h`r$10 z!}|&IIp^yVALhe+m=E(|KFqgFe3%dOVLr@<`S3b^{}7k|2lHV*oK=1emCr68mU9`s z=D_aZw07Rbx=OfDSU!E^!}4MIa8?ZyVfnCpSibF?i{U*UCpo_x;b S!}4MIa8~WkC!cfqy3r3)Rg?Pw literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json new file mode 100644 index 000000000..1a17b7f1a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "HousePlant", + "Laptop", + "Mug", + "Bed", + "TennisRacket", + "TissueBox", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json new file mode 100644 index 000000000..742c72d37 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json @@ -0,0 +1,44 @@ +{ + "Bed|+00.23|00.00|-00.95": [ + 1.25, + -1.0, + 270, + 30 + ], + "Desk|+02.50|+00.00|-01.60": [ + 2.75, + -1.0, + 180, + 30 + ], + "Drawer|+01.24|+00.13|-01.55": [ + 1.75, + -0.5, + 270, + 30 + ], + "Drawer|+01.24|+00.35|-01.55": [ + 1.75, + -0.75, + 270, + 30 + ], + "GarbageCan|+03.17|-00.01|-00.26": [ + 2.5, + 0.25, + 180, + 30 + ], + "Shelf|+03.03|+00.64|-01.58": [ + 2.5, + -0.75, + 90, + 30 + ], + "SideTable|+01.24|+00.00|-01.55": [ + 2.0, + -0.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2328b0b89d500347af2954dd40046c6b4fb53b70 GIT binary patch literal 1536 zcmbW!p-#hK6hPr(d5XG1QiW;=Nl~~F3<51LtC8Z#l^fT%Dk8_+Shjae7|UC&CmX7`m}8J z`{m>GrP=dIRh9YKX_a|3nSG6O2)qrv3!GgZzR$N?9r`dI=EHoLZyS7= z5A$I@%r^ud=EHoL5BKT+=z|aQVLr@<`8L6a`7j^m!@OPc+2c6Z={fuKbu+xK#|`cR zZvyM_{1EQzabFMCgY`J49_%?Br=GukIuF)^^^&T( z?_;kA>%n^Pkb1BltOx7CdYnTK)`Rt69vr70dp)@KJ<`%shfw@+TokNGh_ H=I`on>on)? literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json new file mode 100644 index 000000000..96fb14e54 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json @@ -0,0 +1,28 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "Shelf", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json new file mode 100644 index 000000000..549094674 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json @@ -0,0 +1,50 @@ +{ + "Bed|-00.12|00.00|-01.70": [ + 1.0, + -1.75, + 270, + 30 + ], + "Desk|-00.28|00.00|+00.83": [ + -0.75, + 0.25, + 0, + 30 + ], + "Drawer|+00.95|+00.17|-02.39": [ + 1.5, + -2.0, + 270, + 30 + ], + "Drawer|+00.95|+00.46|-02.39": [ + 1.5, + -2.0, + 270, + 30 + ], + "GarbageCan|+02.47|-00.03|+00.94": [ + 2.0, + 0.5, + 90, + 30 + ], + "Shelf|-00.28|+00.10|+00.83": [ + 1.25, + 0.25, + 0, + 30 + ], + "Shelf|-00.28|+00.35|+00.83": [ + 1.5, + 0.5, + 270, + 0 + ], + "SideTable|+00.95|+00.00|-02.46": [ + 1.5, + -2.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a63bb699dd8cc91bd1229f78cf5b331ecdecbff GIT binary patch literal 2240 zcmbW%Jx*Iu5QgEy6{5&0Zg&&OO-K`=NZg8!C=CTwWCbG%6p$U!AXdSGoF&{PP*S>Z z;esNBGtZGSWll4G=jWUGEX$8y&rZLc@0Gi9KU^$UKbFH$KYY3TJk0vx@@DyKIsf_n zW_hvrn?IRfuNJTQ)z$oV@yhQ%emb1>haYDBL;s)eU3q((b&UtVYkW?uzMtw?y-Rhh zUQ!*azr?V^q-PGrjO}k`j|eZ|D5zOeN4Zxxrp|u+lRO7>UR_U_G8~4wjbM%t6C{|q8qXK z40eb99JgtHm-r=d8UOXuCFb9r?Yj22J&E~O=O0h0zp9ne>Tw_DAM=mfU1?68f6PDj zKiT@?KD2B6c>fg^V#*g!Q z^ZEQ?{9JE*aC}-7M~7AMUi|kNr0vsfckjh;_wEFz;PvO<-(LkUgBQX3xwjndI)mVT za4*$840f8T!AXMNUZeb(=V ZKBqQqAJ%7m)@S{G=(9fSvp(zhM?dB_q@(}< literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json new file mode 100644 index 000000000..60ee2f021 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json @@ -0,0 +1,42 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "DiningTable", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json new file mode 100644 index 000000000..b61a84d71 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json @@ -0,0 +1,98 @@ +{ + "Cabinet|-01.00|+00.39|+00.73": [ + -1.75, + 1.5, + 90, + 30 + ], + "Cabinet|-01.73|+00.39|+00.73": [ + -2.0, + 1.5, + 90, + 30 + ], + "CounterTop|-00.52|+01.16|+00.49": [ + -1.0, + 1.0, + 90, + 30 + ], + "CounterTop|-02.28|+01.16|+00.38": [ + -1.75, + 1.0, + 180, + 30 + ], + "CounterTop|-03.86|+01.16|+00.38": [ + -3.25, + 1.25, + 180, + 0 + ], + "DiningTable|-00.62|+00.02|+02.49": [ + -1.25, + 2.5, + 90, + 30 + ], + "Drawer|-02.04|+00.22|+00.59": [ + -1.5, + 1.5, + 270, + 30 + ], + "Drawer|-02.04|+00.61|+00.59": [ + -2.5, + 1.25, + 90, + 30 + ], + "Drawer|-02.04|+00.94|+00.60": [ + -1.5, + 1.0, + 270, + 30 + ], + "Drawer|-02.50|+00.22|+00.59": [ + -3.0, + 1.5, + 90, + 30 + ], + "Drawer|-02.50|+00.61|+00.59": [ + -3.0, + 1.25, + 90, + 30 + ], + "Drawer|-02.51|+00.94|+00.60": [ + -2.0, + 1.0, + 270, + 30 + ], + "Fridge|-03.52|+00.00|+02.72": [ + -2.5, + 2.75, + 270, + 30 + ], + "GarbageCan|-03.70|+00.00|+02.01": [ + -3.5, + 1.5, + 0, + 30 + ], + "Microwave|-00.37|+01.11|+00.43": [ + -1.0, + 1.0, + 90, + 30 + ], + "Sink|-01.39|+00.98|+00.44|SinkBasin": [ + -1.25, + 1.75, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..8e4a04103feacbfd316e141080638154d285734a GIT binary patch literal 1616 zcmbW#u};EJ6oBE{kj5AuqFXg#(nXDlo!m4o4o-$hiGvYSjEnIpd?5P>K7u170|Ntt z2a?uR#>ds5tj3e}r5!%qP1;fOd;eni zIBnMVrw_yDX6^lxqd|FiFeu;4|6Y69=IV9Z^Xq(j=83b!tIxmRUnbW3PI|1zdaTDq z%%4S1pY6-~tk3$qi2YfAp6t*1tk3$qh(7Btl0NIRKI^kS>o1c&>$5)Vvp(yul0NIR zJ}=|h1r``(=IBXMNUZ|EE0qy)N5ac^zjLXV|pFIy3(J!L!dDuM8lJA@6bMx3dp2z!R^LLZ^oX0#ipUr3U*?cyiXR#04XD``@ i?ZftA`>=i3K5QSh4|^Z|*vEV}kIiHA*gQ6`U;hA}V9Xo< literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json new file mode 100644 index 000000000..233e0276d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json @@ -0,0 +1,32 @@ +[ + "PaperTowelRoll", + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "LightSwitch", + "Sink", + "Floor", + "SoapBar", + "HandTowel", + "Shelf", + "ShowerHead", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json new file mode 100644 index 000000000..bfe92af8f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json @@ -0,0 +1,56 @@ +{ + "Bathtub|-00.21|+00.36|+00.92|BathtubBasin": [ + -1.25, + 1.75, + 90, + 30 + ], + "GarbageCan|+00.05|00.00|+03.88": [ + -0.75, + 3.25, + 0, + 30 + ], + "Shelf|-02.59|+00.78|+03.91": [ + -2.25, + 3.0, + 0, + 0 + ], + "Shelf|-02.59|+01.03|+03.94": [ + -2.5, + 3.25, + 0, + 0 + ], + "Shelf|-02.59|+01.29|+03.94": [ + -2.5, + 3.5, + 0, + 0 + ], + "Shelf|-02.59|+01.53|+03.91": [ + -2.5, + 3.5, + 0, + 30 + ], + "SideTable|-03.17|+00.00|+00.17": [ + -2.75, + 0.75, + 180, + 30 + ], + "Sink|-03.12|-00.01|+01.53|SinkBasin": [ + -2.5, + 2.0, + 180, + 30 + ], + "Toilet|+00.06|+00.00|+03.10": [ + -0.75, + 3.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..fbbb5a2090f0968bd287946482cba894a287ca02 GIT binary patch literal 1584 zcmbW!u}T9$6a~;Rge8O!)cnA9tB^)36^p6t6dMaG31)+Z7)iuN{0cwF{S-?}3kwSi zV`fj`luomp+2p?a*q5`5)AP%X@ED$|X}!E&R7YiXJUghyWi^{G9u||ktNCJD|K6WW zZkP4yet9#wuUFnV+#8qsyW{e?{O{?9_31R}8De^VzW((`=J(8RndNobywIdP{%(KI zUzyGK-h4Kn&1dtwF{IO^2b<64v-xa3o6qKRx1CqSG*=%E*?WDw*N63CeOMpXhxO@Y zeOMpXhxK87SbjgtXZb9j<+FU2KgjY~KFeqMET4-etj{o}r+M6I(mk8U=COHf9{Yam z`?2rGMLT~prXKpSeykts$NI5;tRL&g`th*sx7GF=WbS9~WiB$?PoDkQer!LsAKQ=Z i$M$3UvHiAVSRebb{n&n7H0ggVZxqwLJeJ4uM)3zd*{L7^ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json new file mode 100644 index 000000000..5135a1b2f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json @@ -0,0 +1,33 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json new file mode 100644 index 000000000..44dc45846 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json @@ -0,0 +1,92 @@ +{ + "Bathtub|-02.90|+00.67|+02.86|BathtubBasin": [ + -2.75, + 3.75, + 270, + 30 + ], + "Cabinet|-00.12|+00.36|+04.63": [ + -1.0, + 3.75, + 90, + 30 + ], + "Cabinet|-01.03|+00.36|+04.63": [ + -1.5, + 3.75, + 90, + 30 + ], + "Cabinet|-01.06|+00.36|+04.63": [ + -0.75, + 3.75, + 270, + 30 + ], + "Cabinet|-01.96|+00.36|+04.63": [ + -2.25, + 4.0, + 90, + 30 + ], + "CounterTop|-01.02|+00.95|+04.88": [ + -0.75, + 4.25, + 0, + 30 + ], + "GarbageCan|-02.35|+00.00|+04.88": [ + -3.0, + 4.25, + 0, + 30 + ], + "HandTowelHolder|-00.07|+01.57|+04.81": [ + -0.5, + 4.25, + 0, + 30 + ], + "HandTowelHolder|-02.09|+01.54|+05.15": [ + -1.5, + 4.25, + 0, + -30 + ], + "Sink|-00.58|+00.93|+04.87|SinkBasin": [ + -0.75, + 4.25, + 0, + 0 + ], + "Sink|-01.53|+00.93|+04.87|SinkBasin": [ + -1.75, + 4.25, + 0, + 0 + ], + "ToiletPaperHanger|-00.07|+01.13|+03.69": [ + -0.5, + 4.0, + 180, + 30 + ], + "Toilet|-00.52|00.00|+03.22": [ + -0.5, + 2.75, + 0, + 30 + ], + "TowelHolder|-00.07|+01.41|+02.43": [ + -0.5, + 2.5, + 90, + 0 + ], + "TowelHolder|-01.72|+01.21|+01.74": [ + -1.75, + 2.25, + 180, + 0 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..50071edd0cc8cf7d828ff704ed437190a79a84e5 GIT binary patch literal 1008 zcmbW!F-pTw0LS5{h=Zrd7KKbgK}2Y#Zi2!IVsxmEC?NeJn+^pI~^Rs_e-*?Ss zzq_j+n~e`%QXY;)Gv7P(M^Si-Cu%7>& zm-SeW*ZI7xzYcxYXMNUZeb#4v*6%}~^;w_wdC2!;eb#6FA@o_F^;w_wxzFceebygC fpY>Uv^;w_wS)cW%&}V&~@_l#=*7seX^{4qam2{;B literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json new file mode 100644 index 000000000..098f91eab --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json new file mode 100644 index 000000000..6b3129c2f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json @@ -0,0 +1,38 @@ +{ + "Bathtub|+00.22|+00.34|+00.64|BathtubBasin": [ + -0.75, + 1.25, + 90, + 30 + ], + "Shelf|-01.17|+00.28|+02.16": [ + -1.25, + 1.75, + 0, + 30 + ], + "Shelf|-01.17|+01.06|+02.16": [ + -1.0, + 1.75, + 0, + 30 + ], + "Shelf|-01.17|+01.76|+02.16": [ + -0.75, + 0.75, + 0, + 0 + ], + "Sink|-01.13|00.00|-00.59|SinkBasin": [ + -1.5, + 0.0, + 90, + 30 + ], + "Toilet|-02.15|+00.00|-00.41": [ + -1.5, + 0.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..b175551a305c675bce4672eaf23dc95cba71c2d0 GIT binary patch literal 576 zcmbWzAr8VY6oBDEP@JN!kW@`Agk%l}!5~m%VO41ah)5C9UO~1fbaD_Cp_$wi7Y8Q^HpM}#B;q1og%@Nm!Ao#-ba2Sf z!D{*p{YTGocmny}mb{){o?Tq6q^I zvwgOoisgN77r%$?vwgPDAK`ty)zD)-)?+=^V?EYeE7ITbeOQn6SdaBskKY&nm(#TC zt{2^{&-$#-`mE3Ttk3!zq0joP&-$#-`mE3Tz0hZU)@OazXMNUZ{msy4eb#4v)@Oaz zXZ@|vXMNUZeb#4v)@S|g&}V(tXMNUZeb#6FozQ1})@OazXMNV|haT&(9_z6l>-CEt DyrtJD literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json new file mode 100644 index 000000000..fee4c2922 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "SinkBasin", + "TowelHolder", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json new file mode 100644 index 000000000..712dee310 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json @@ -0,0 +1,26 @@ +{ + "Cabinet|+00.07|+00.38|+02.05": [ + -0.75, + 3.0, + 90, + 30 + ], + "CounterTop|+00.49|+01.02|+03.09": [ + -0.25, + 3.5, + 90, + 30 + ], + "Sink|+00.43|+01.04|+02.95|SinkBasin": [ + -0.25, + 3.0, + 90, + 0 + ], + "Toilet|+00.38|+00.00|+04.47": [ + -0.5, + 3.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e53430e434d631d6fb74bcfe6bc1187099066062 GIT binary patch literal 672 zcmbV_Ar1mD5JijS6m^B93J`>ltiwSt2o!19ZV-eeEx`~@!GX9!kAOrX5J(ovGb5?_ zdA~FBF0;jSzHF(ZI+@bPbuc4s#?{bRZK^sPg4?a?Q2I|laogydK5pFJH{9tDtnPKK zKI?y9TYcZ_n)C6?r(k;WF8*(Vli++^DfaPk2OrEFEE69+J{TX2k3D=aKA1gNCO&$6 hFh1t+!T4Z&Fn3^?_~_ZEXCGz`WqnzeXjrj literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json new file mode 100644 index 000000000..0cec3c67e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json new file mode 100644 index 000000000..e7f8e434c --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json @@ -0,0 +1,56 @@ +{ + "Bathtub|+00.88|+00.39|-01.15|BathtubBasin": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|-00.07|+00.34|-01.33": [ + -1.0, + -0.5, + 90, + 30 + ], + "Cabinet|-01.04|+00.34|-01.33": [ + -1.5, + -0.5, + 90, + 30 + ], + "Cabinet|-01.05|+00.34|-01.33": [ + -1.25, + -0.75, + 180, + 30 + ], + "Cabinet|-02.02|+00.34|-01.33": [ + -1.0, + -0.25, + 270, + 30 + ], + "CounterTop|-01.04|+00.88|-01.53": [ + -1.5, + -1.0, + 180, + 30 + ], + "Sink|-00.53|+00.81|-01.60|SinkBasin": [ + -1.0, + -1.0, + 90, + 30 + ], + "Sink|-01.56|+00.81|-01.60|SinkBasin": [ + -1.25, + -1.0, + 180, + 30 + ], + "Toilet|-01.61|00.00|+00.21": [ + -1.25, + -0.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..97a2514fc98772512785982fd1a708a0fb640592 GIT binary patch literal 704 zcmbW!F$%&k6oBCKC!C#D~MQz`xv)5r8NeayS0i^&IyoqELp literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json new file mode 100644 index 000000000..e855538bd --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json new file mode 100644 index 000000000..a8048b4fb --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json @@ -0,0 +1,62 @@ +{ + "Bathtub|+00.29|+00.29|-00.08|BathtubBasin": [ + -0.5, + 0.25, + 90, + 30 + ], + "Cabinet|-01.50|+00.42|+00.43": [ + -2.25, + -0.5, + 90, + 30 + ], + "Cabinet|-02.29|+00.39|+00.42": [ + -2.5, + -0.25, + 90, + 30 + ], + "Cabinet|-02.31|+00.42|+00.43": [ + -2.25, + -0.25, + 0, + 30 + ], + "Cabinet|-03.09|+00.39|+00.42": [ + -2.5, + -0.5, + 0, + 30 + ], + "CounterTop|-02.30|+00.95|+00.69": [ + -2.25, + -0.25, + 0, + 0 + ], + "GarbageCan|-02.86|+00.02|-01.49": [ + -2.25, + -0.75, + 270, + 30 + ], + "Sink|-01.92|+00.93|+00.68|SinkBasin": [ + -1.75, + 0.0, + 0, + 0 + ], + "Sink|-02.68|+00.93|+00.68|SinkBasin": [ + -2.5, + 0.0, + 0, + 0 + ], + "Toilet|-01.05|+00.00|+00.55": [ + -0.5, + 0.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..278e0a1d880584b4bedf2ea9897c33979fadd4dd GIT binary patch literal 752 zcmbWyF$%&!5J1sYL?q-8+pR(>ZK4RKvQum2HK7jKuDOYCPqjyJh2_W3&A*~0B! zKhWJypilbW@l-j_OZC1+)%y^>3*UsfSJCf1<{op8uiqY~R~J1@57Wc+Fug{k%He;Q v9;S!sVR}u`!}KscOb^p*i5{kh>0x@9o+o;k9;S!sVS2vkVS1Pzrsqd*d}L}c literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json new file mode 100644 index 000000000..670bad826 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json new file mode 100644 index 000000000..2d50fa700 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json @@ -0,0 +1,62 @@ +{ + "CounterTop|+00.46|+00.79|+02.76": [ + -0.25, + 2.75, + 90, + 30 + ], + "Drawer|+00.44|+00.32|+02.19": [ + -0.75, + 1.75, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+02.57": [ + -0.75, + 2.0, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+02.94": [ + -0.75, + 2.25, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+03.31": [ + -0.75, + 2.75, + 0, + 30 + ], + "Drawer|+00.44|+00.62|+02.19": [ + -0.5, + 1.75, + 0, + 30 + ], + "Drawer|+00.44|+00.62|+03.31": [ + -0.5, + 2.75, + 0, + 30 + ], + "GarbageCan|+00.41|-00.03|+03.73": [ + -0.25, + 3.25, + 0, + 30 + ], + "Sink|+00.50|+00.66|+02.76|SinkBasin": [ + -0.25, + 3.25, + 180, + 30 + ], + "Toilet|+00.27|+00.00|+01.46": [ + -0.25, + 2.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..09bb6c6c837541d12eb2b3566f010329e8edca29 GIT binary patch literal 1408 zcmbWxu}Z^07{Kwfl%s@F+Be7+g%09W#Nj44#l^u%icN74E2+4MPvHZZ$8vD6CiyKl z`Yqv??{fKnUf*8b+#Q9t@Lp}|{X0vz_ z+x{Hu;Ze5NW3Pwxu%1ck|D%WXa2)=}dRPzZVLhyeXT$wP3f)XI>$BI#F*~o%ULWgY zeXNgX!~N3~y3xn_SRcoB_%8KNefIiTAM0a%ycq7E4foG8>$lg>`gxLlA2aKBUO($+ z{j8t$&r|3|KkH}xTnv4zpJTSyZ?B*Avwqgk`WGp5qo4J&e%8fJZ=#%4Lb1b+W3^z-`m>gH}IyoL92*iIh0^1LW7MrUPJl%sL?+BMJj<8Ijgy}xXp zChhwDJYQd&|M*9@}Gk zY>(}+J+`;X_ShcVV|#3m?eQ}G{!nlJKDNj9*dE(sd)%AGH@!NZVH(d~9nV#|54#^P zvhVKayZf>GvHNjI59{yN@q<3=vp(x{$_LilOMN}oV?EYmz5T4mdaTEKtk=(atjBt+ N$FuZ5=6Ui#{R?)Il9d1e literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json new file mode 100644 index 000000000..f4d477e9d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json new file mode 100644 index 000000000..96017b5b6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json @@ -0,0 +1,62 @@ +{ + "Bathtub|-01.06|+00.30|+00.43|BathtubBasin": [ + -0.75, + 1.25, + 180, + 30 + ], + "CounterTop|+00.73|+00.70|+01.96": [ + 0.0, + 2.0, + 90, + 30 + ], + "CounterTop|-00.30|+00.16|+00.53": [ + -0.25, + 1.5, + 180, + 30 + ], + "Drawer|+00.41|+00.32|+01.49": [ + -1.0, + 2.0, + 90, + 0 + ], + "Drawer|+00.41|+00.32|+02.42": [ + -1.0, + 2.0, + 90, + 0 + ], + "Drawer|+00.41|+00.55|+01.49": [ + -0.75, + 1.75, + 90, + 0 + ], + "Drawer|+00.41|+00.55|+02.42": [ + -0.75, + 1.75, + 90, + 0 + ], + "GarbageCan|+00.71|-00.03|+03.11": [ + 0.5, + 3.5, + 180, + 30 + ], + "Sink|+00.81|+00.70|+01.92|SinkBasin": [ + 0.0, + 2.5, + 180, + 30 + ], + "Toilet|-02.23|+00.00|+01.63": [ + -2.0, + 2.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..1d3c8327df573213544b1cf76075351bfd9cf1d7 GIT binary patch literal 784 zcmbV{Ar8Vo5JeY48q!m&TS#gk2tr8ea1aavMH*UyAe6KOLpTKoqDSZvDv<~T0zqNt znU##0zCW|CyVu!bI$t)_Nu5oc9)PCeUV+X2&eruhJ||zWF5D3A+vt$g z+!^!&-R}naqW>*l{mLtBf8A_vIsBBI`NLsP_Sxe+>~{9?un#xI2P=o)@_**;z3|_i z_rUmJ{4jnPU*-5W!-VAJ8ypPU(}CX zv%TLv)X&Y{)yD6`a^|3w<>Ecc5+pER{{j8t$ zvwlwXf%Wfa{j8t$vwqgkefl5Rcgns)w&x(*!}hQ}Y!BPR_OLx{58E@z_OLx{58K1` Vusv)K+r#!uvpsAN+r#!us~?!{m^1(Y literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json new file mode 100644 index 000000000..0e607a3e9 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Dresser", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json new file mode 100644 index 000000000..528e315b4 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json @@ -0,0 +1,92 @@ +{ + "Bathtub|-01.41|00.00|+00.56|BathtubBasin": [ + -0.75, + 1.0, + 270, + 30 + ], + "Cabinet|-01.61|+00.31|+02.49": [ + -0.75, + 3.25, + 180, + 30 + ], + "Cabinet|-01.61|+00.31|+03.11": [ + -0.75, + 2.5, + 0, + 30 + ], + "Cabinet|-01.61|+00.31|+03.14": [ + -0.75, + 2.75, + 0, + 30 + ], + "Cabinet|-01.61|+00.31|+03.75": [ + -0.75, + 3.0, + 0, + 30 + ], + "CounterTop|-01.80|+00.75|+03.12": [ + -1.25, + 3.0, + 270, + 30 + ], + "Drawer|+00.20|+00.16|+03.81": [ + -0.5, + 3.25, + 90, + 30 + ], + "Drawer|+00.20|+00.42|+03.81": [ + 0.75, + 3.25, + 0, + 30 + ], + "Drawer|+00.20|+00.68|+03.81": [ + -0.5, + 3.5, + 90, + 30 + ], + "Drawer|+00.20|+00.94|+03.81": [ + -0.5, + 3.5, + 90, + 30 + ], + "Dresser|+00.21|+00.00|+03.83": [ + 0.25, + 3.25, + 0, + 0 + ], + "GarbageCan|+00.93|-00.03|+03.76": [ + 0.25, + 3.25, + 0, + 30 + ], + "Sink|-01.83|+00.69|+02.78|SinkBasin": [ + -1.25, + 3.25, + 180, + 30 + ], + "Sink|-01.83|+00.69|+03.47|SinkBasin": [ + -1.25, + 3.0, + 0, + 30 + ], + "Toilet|-01.57|00.00|+01.82": [ + -1.25, + 2.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..aa82fa1bb4208248476699ac51afd89bd2596dc5 GIT binary patch literal 800 zcmbWxu?oU46oug^BE_f37KKj5K}4{Vo8sc&B*jJ?#7ZhI;#2rQ^>I3O=+L2qwducP zG)wp{Ip^lR*{!$xo_L6-igkK4YA)5{G*iA*r^MV%bUh>{*1!2Gx}>_9r|0OV8;_@f zFN29MU-I8G678uod*@4gSB^`^g=6xClgH$-_}D#V_ntgvKPHcPUpf0Q?=kyoXCG!C zCXdOB(EgkKm^>zr$@iT+CXdPEA`|Vw^bJBg=RcS}OdqBXlOJ|{49l1VyavA~qIQvLqWUf{|UZ33&=1D0!Te78Vv3#$><3 zTRP3*znuH;?7ZLJkM150(py@TNz;wna+S;V^s-dBOy})uTR%U}+ez~~zo}QO z^-Htmlk=^W1wZD; z{Foo}WB$Q9?T+`s{Foo}WBtS4r;qiqzI*6neXQ@E`dA<9OMR@5y$_c5V%j&ikL|}E Qj%nZAf0*-O-`T8w0KJ8raR2}S literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json new file mode 100644 index 000000000..1e083ec30 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Shelf", + "Dresser", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json new file mode 100644 index 000000000..78d0f5817 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json @@ -0,0 +1,68 @@ +{ + "Bathtub|-02.10|+00.53|-00.83|BathtubBasin": [ + -1.75, + -0.75, + 270, + 30 + ], + "CounterTop|-02.71|+01.03|-02.92": [ + -1.75, + -3.0, + 270, + 0 + ], + "Drawer|-00.23|+00.16|-03.40": [ + -1.25, + -2.75, + 180, + 30 + ], + "Drawer|-00.23|+00.42|-03.40": [ + -0.75, + -3.0, + 90, + 30 + ], + "Drawer|-00.23|+00.68|-03.40": [ + -0.75, + -3.0, + 90, + 30 + ], + "Drawer|-00.23|+00.94|-03.40": [ + -0.75, + -3.0, + 180, + 30 + ], + "Dresser|-00.20|+00.00|-03.40": [ + -0.75, + -3.25, + 90, + 0 + ], + "GarbageCan|-00.27|-00.03|-02.75": [ + -1.0, + -3.25, + 0, + 30 + ], + "Shelf|-02.58|+00.40|-02.92": [ + -1.25, + -2.75, + 270, + 0 + ], + "Sink|-00.31|+00.00|-02.08|SinkBasin": [ + -0.75, + -1.5, + 90, + 30 + ], + "Toilet|-00.41|00.00|-00.55": [ + -0.75, + -1.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..97b05a34c900c4c1a2fa707d19b7fd11afd6c743 GIT binary patch literal 992 zcmbWzF-pWx6a~<)h)7nEE()ncK}2vWJH^JrN`jMN3UMS68*vpb$Sq_EQ(8_jg@uKq z`KNiMzX>OK_r4_WS2vf}w_E8Yy;jq+{@x9>To* zSMHN%d6wt#D^p^9-=UB7u|C$v`qE^4;{8}3>tp%tkY{<8XZf9wXL*+Aln?9M4SlSS n^|3x4@_%Oid!e88vwqgk`gxi6v3*6@$M&&(Y#-al_7#&KZ*++( literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json new file mode 100644 index 000000000..c8adda2c6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json new file mode 100644 index 000000000..afd6d54d0 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json @@ -0,0 +1,44 @@ +{ + "CounterTop|-01.61|+00.70|+02.83": [ + -1.0, + 2.25, + 270, + 30 + ], + "Drawer|-01.34|+00.30|+02.13": [ + -0.75, + 1.75, + 270, + 30 + ], + "Drawer|-01.34|+00.30|+03.33": [ + -0.75, + 3.0, + 270, + 30 + ], + "GarbageCan|-01.74|-00.03|+01.27": [ + -1.0, + 1.75, + 180, + 30 + ], + "Sink|-01.70|+00.62|+02.28|SinkBasin": [ + -1.0, + 2.75, + 180, + 30 + ], + "Sink|-01.70|+00.62|+03.37|SinkBasin": [ + -1.0, + 3.0, + 0, + 30 + ], + "Toilet|-01.55|+00.00|+00.69": [ + -1.25, + 1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0e72aa5468376744d0ad51f9911a9e4a1cf2be8d GIT binary patch literal 1088 zcmbWxu};EJ6oBDE3U>X;-y&US=~M~`6}h{e3Z+S=gVf*REzs%Gpm31*VR*7@AvIv z^<3|LdU;-^i?cFq(tn>}@%OyH9_HZfF!`kONB6!T-m_VB@8kUL&fD*Tzk)x5^_};B ztRFiZr@p;D>$5)Vv%Y)%7yFLm)VJ4Xeb#4v_vo`eJI8VA+v~GF>pQ2<`mE3H;W+i} g^;zF{`mE3Ttk3S{IQ8xI?e$ro^;w_wS%;7F2ek>!DF6Tf literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json new file mode 100644 index 000000000..6c7ccae54 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json new file mode 100644 index 000000000..111a6080f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json @@ -0,0 +1,44 @@ +{ + "Cabinet|-02.50|+00.40|-01.24": [ + -1.75, + -1.5, + 0, + 30 + ], + "Cabinet|-02.50|+00.40|-02.21": [ + -2.0, + -1.5, + 270, + 30 + ], + "Cabinet|-02.51|+00.43|-00.29": [ + -1.75, + -1.0, + 0, + 30 + ], + "Cabinet|-02.51|+00.43|-01.26": [ + -1.75, + -2.0, + 0, + 30 + ], + "CounterTop|-02.75|+00.99|-01.24": [ + -2.25, + -1.5, + 270, + 30 + ], + "Sink|-02.91|+00.99|-00.73|SinkBasin": [ + -2.25, + -1.0, + 0, + 30 + ], + "Sink|-02.91|+00.99|-01.76|SinkBasin": [ + -2.25, + -1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3e47df778f8071a73ded546848c342dde1b5a976 GIT binary patch literal 864 zcmbW#u}Z^07{KvZq)6#Q+;$Z*l_FA{-4quGCkZyCgV>T37x5{4p!z5s9UUAT9IQ0I z!EbDq<9B!ej}Y>9eS39tcT_wVFL_qC4^5t?d@(=IWy)V`(-n$|MoAd$F|<> zw~K03?>w5Em1%rhrq^`nGbr}Y`+gaA>(A!Dzk|PmKZA>I&LGTV^VmGrpM;+EtY>{c z^sHw+>yJavdUn4T?z3~N@5|=c*RgvXSH1Vrv!3;=_Z{@CXFcov2YS}Cp7kHyf23zU M>)H9X>z!{mzctp3NB{r; literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json new file mode 100644 index 000000000..6c7ccae54 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json new file mode 100644 index 000000000..fb4ef1367 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json @@ -0,0 +1,44 @@ +{ + "Cabinet|-02.29|+00.32|-03.25": [ + -1.5, + -3.5, + 0, + 30 + ], + "Cabinet|-02.29|+00.32|-03.81": [ + -1.5, + -3.0, + 180, + 30 + ], + "Cabinet|-02.30|+00.35|-02.25": [ + -1.5, + -3.0, + 0, + 30 + ], + "CounterTop|-02.63|+00.84|-03.04": [ + -2.0, + -3.0, + 270, + 30 + ], + "GarbageCan|-00.46|-00.04|-03.77": [ + -1.25, + -3.25, + 180, + 30 + ], + "Sink|-02.66|+00.79|-03.07|SinkBasin": [ + -2.0, + -3.5, + 0, + 30 + ], + "Toilet|-00.45|+00.00|-03.05": [ + -1.0, + -3.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..191b53f1cfb6d90ecc8734f97572f8c9fded07b3 GIT binary patch literal 608 zcmbV`p$@_@6h#Y?uc#{|6$A_+XdDECK#_)ZK@hgIWM<(j_#pTcBocu@AQ)^XBu`Rv zbMEUq?POQRUvYQXw|daC z`l$as9rZoWbDix=oe#mxm6*fKU(Fu-FmsYQ%stt|GVkJ@n_zt0;~f|uEE69+K6-pG YKA1gN=C%1RJ$`!pFn$<6j0gVZ8}dbb$N&HU literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json new file mode 100644 index 000000000..0a56e852a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json @@ -0,0 +1,30 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json new file mode 100644 index 000000000..46cace91d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json @@ -0,0 +1,44 @@ +{ + "Bathtub|-00.98|-00.72|-02.93|BathtubBasin": [ + -1.25, + -2.25, + 180, + 30 + ], + "Drawer|-02.11|+00.16|-01.31": [ + -1.5, + -0.75, + 180, + 30 + ], + "Drawer|-02.11|+00.46|-01.31": [ + -1.75, + -0.75, + 180, + 30 + ], + "GarbageCan|-00.24|-00.03|-01.36": [ + -0.75, + -1.25, + 90, + 30 + ], + "SideTable|-02.18|00.00|-01.31": [ + -1.75, + -1.0, + 270, + 30 + ], + "Sink|-02.10|00.00|-02.03|SinkBasin": [ + -1.5, + -1.75, + 180, + 30 + ], + "Toilet|-00.47|+00.00|-01.88": [ + -0.75, + -1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3d239dd2e8222e42f8e0272eedc659e483177ba4 GIT binary patch literal 560 zcmbV{p$Y;)6h+7CSG+a~leQ>gwkcZ-CK=pW4C2a+SY*G#5As)xMuWj%aMe8sFFNIN zF7FnLS_~`M$_+Wf`2kXQ~j}OMH?_izm=`ZbnVZ8bd*2$ip LJw0BSJNTC`QxbM; literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json new file mode 100644 index 000000000..9c3deeaff --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "HousePlant", + "SoapBar", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json new file mode 100644 index 000000000..c23df54f5 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json @@ -0,0 +1,32 @@ +{ + "Bathtub|-01.28|+00.28|-02.53|SinkBasin": [ + -1.25, + -1.75, + 180, + 30 + ], + "Drawer|-00.22|+00.78|-01.47": [ + -1.25, + -1.5, + 90, + 0 + ], + "SideTable|-00.15|+00.00|-01.47": [ + -0.5, + -1.0, + 90, + 30 + ], + "Sink|-02.27|+00.00|-01.52|SinkBasin": [ + -1.75, + -1.25, + 180, + 30 + ], + "Toilet|-02.05|+00.00|-00.36": [ + -1.5, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..bed785d7e97473038a76e7b8d4ebb2ca0e9451bf GIT binary patch literal 608 zcmbW!F%AJi6oBC&BC^>-OgAJ`2#tuuRyv|lsAOYjqYx`Iq7kQXAXic-6bg&|3$OH= zm;YtHYA&q9i zb|GJT&po_0yY+TI5O?uViO!Ek&81qTGZjdcX69z%%ONv~{@t(QbFSO_{1jhx>v0$c zaykj*Q~rBKqC5Vl{}#*sJ9O+h7LJ>DpCey8_U(M>?8ofK?8ofK?8lYu!}L{7AEpn} shv~!gVft`s`*Gozd~N@SJSLCHW9A#1XC5<;nHQ1h4)d6I&w2NvFV&=L)c^nh literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json new file mode 100644 index 000000000..eed1f5ea6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json @@ -0,0 +1,33 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Shelf", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json new file mode 100644 index 000000000..3da31098e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json @@ -0,0 +1,86 @@ +{ + "Bathtub|-03.45|+00.18|+01.03|BathtubBasin": [ + -2.75, + 1.25, + 270, + 30 + ], + "Cabinet|-00.61|+00.46|+00.52": [ + -1.25, + 1.25, + 90, + 30 + ], + "Cabinet|-00.61|+01.99|+00.52": [ + -1.25, + 1.0, + 180, + -30 + ], + "Cabinet|-01.89|+00.44|+01.98": [ + -1.25, + 1.75, + 0, + 30 + ], + "Cabinet|-01.89|+01.88|+02.39": [ + -1.25, + 2.25, + 270, + 0 + ], + "Cabinet|-02.34|+00.46|+00.52": [ + -1.75, + 1.0, + 180, + 30 + ], + "CounterTop|-00.81|+00.09|+00.29": [ + -1.25, + 1.0, + 180, + 0 + ], + "CounterTop|-01.92|+00.00|+00.29": [ + -2.0, + 0.75, + 180, + 30 + ], + "Drawer|-00.81|+00.96|+00.38": [ + -1.5, + 1.0, + 90, + 0 + ], + "Drawer|-02.03|+00.94|+02.19": [ + -1.5, + 1.5, + 0, + 0 + ], + "Shelf|-02.03|+01.18|+02.19": [ + -1.25, + 1.75, + 270, + 0 + ], + "Shelf|-02.12|+01.39|+02.19": [ + -1.25, + 2.25, + 270, + -30 + ], + "Sink|-01.93|+00.77|+00.33|SinkBasin": [ + -2.5, + 0.75, + 90, + 30 + ], + "Toilet|-00.46|00.00|+02.26": [ + -1.0, + 2.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d85f2115b41423b356fe2292116cfad34b885d51 GIT binary patch literal 1008 zcmbWyu}Z^G0EW?P2|;{{Y*EN06hs6wxhXCVP7-WN2eFcfi}(~ika--(4jnRNur~J$ zW;Dy?B+d7ypEq~cxAzC(ExhN8x_xZ&^DMtup5;ZBFW1d$Q$0Vdn??P5|EhXw>)ri! zRlU?ZAJ6ASc6w4|AK8Deqp-h{Zalv)$8$Dun0Wa5`+M(iChxQN+56nb9v{ZNZS18J z+wTkEq?%>>WG^F literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json new file mode 100644 index 000000000..3045886b8 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json new file mode 100644 index 000000000..21ea750b4 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json @@ -0,0 +1,86 @@ +{ + "Bathtub|-03.59|+00.11|+01.52|BathtubBasin": [ + -3.0, + 1.25, + 270, + 30 + ], + "CounterTop|-00.28|+00.79|+01.93": [ + -1.0, + 2.25, + 90, + 30 + ], + "CounterTop|-02.54|+00.81|+00.28": [ + -1.75, + 0.75, + 270, + 30 + ], + "Drawer|-00.33|+00.32|+01.72": [ + -1.5, + 2.25, + 180, + 30 + ], + "Drawer|-00.33|+00.32|+02.16": [ + -1.5, + 2.75, + 180, + 30 + ], + "Drawer|-00.33|+00.32|+02.59": [ + -1.5, + 2.0, + 0, + 30 + ], + "Drawer|-00.33|+00.32|+03.03": [ + -1.5, + 2.5, + 0, + 30 + ], + "Drawer|-00.33|+00.62|+02.59": [ + -1.25, + 2.0, + 0, + 30 + ], + "Drawer|-00.33|+00.62|+03.03": [ + -1.25, + 2.5, + 0, + 30 + ], + "Drawer|-02.25|+00.32|+00.28": [ + -1.5, + 1.5, + 270, + 30 + ], + "Drawer|-02.84|+00.32|+00.28": [ + -2.25, + 1.5, + 270, + 30 + ], + "GarbageCan|-01.75|+00.00|+00.23": [ + -2.0, + 0.75, + 180, + 30 + ], + "Sink|-00.26|+00.66|+01.92|SinkBasin": [ + -1.0, + 2.5, + 180, + 30 + ], + "Toilet|-02.84|+00.00|+02.76": [ + -2.25, + 2.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..75490b8ceb8bb454345ff51e5d26c3a52caeaa75 GIT binary patch literal 736 zcmbWyF$%&k6oBCOA*0NZijFg;8U(`zNF8vcXnVS1Pz rrq>odOb^q;^f0}S=wW)89;S!s1)_)PVS1PzrWcAHribZadSUVgAzEoo literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json new file mode 100644 index 000000000..f3988fd79 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json new file mode 100644 index 000000000..645647bca --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json @@ -0,0 +1,56 @@ +{ + "Cabinet|-00.49|+00.41|+02.06": [ + -1.25, + 1.75, + 0, + 30 + ], + "Cabinet|-00.49|+00.41|+02.86": [ + -1.25, + 2.5, + 0, + 30 + ], + "Cabinet|-00.50|+00.38|+02.84": [ + -1.25, + 2.25, + 0, + 30 + ], + "Cabinet|-00.50|+00.38|+03.65": [ + -1.25, + 3.0, + 0, + 30 + ], + "CounterTop|-00.26|+00.93|+02.84": [ + -0.75, + 2.5, + 90, + 30 + ], + "GarbageCan|-02.16|00.00|+03.76": [ + -1.75, + 3.25, + 0, + 30 + ], + "Sink|-00.30|+00.80|+02.42|SinkBasin": [ + -0.75, + 2.0, + 0, + 30 + ], + "Sink|-00.30|+00.80|+03.26|SinkBasin": [ + -0.75, + 3.0, + 90, + 30 + ], + "Toilet|-00.54|+00.00|+01.49": [ + -1.0, + 2.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a966f44e54c18b5049044de741c61d322c271a71 GIT binary patch literal 512 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I$7COQg6nmP)#3giMV1~B-rA431JhtMz3_z%$dF!c-$sOn*Sn0go=W*!q% zJxm_PzW_BK#)qkAK~oRo!_>q0F!gL`>S27CdKe$3o&!xij1N-}8F21LSSBNl^68f{|`q!o*J3J=7ibnMu{(81tO&v$S} zcacwf&+m8YI$KQV%bGcvvkRkiow$K@!?@>s>*9TKOoH8NpM=rp`6Sq;(ffJ22@cWQ zt#049owjc;_TSSq-_y8PzuD;5xwtOxu_rFneawAq)cxnpd=KwS<%e>ioGWL_p7cFN zRS(~X*$=ZHWADm08vMfQ~&?~ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json new file mode 100644 index 000000000..f904e7328 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json new file mode 100644 index 000000000..c1f4edd71 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json @@ -0,0 +1,68 @@ +{ + "Bathtub|-03.50|+00.15|+00.94|BathtubBasin": [ + -2.75, + 1.25, + 270, + 30 + ], + "CounterTop|-01.85|+00.00|+00.34": [ + -1.0, + 1.0, + 180, + 30 + ], + "Drawer|-00.29|+00.31|+00.31": [ + -1.0, + 1.5, + 90, + 30 + ], + "Drawer|-00.29|+00.61|+00.31": [ + -0.75, + 1.25, + 90, + 30 + ], + "Drawer|-00.81|+00.31|+00.31": [ + -1.5, + 1.5, + 90, + 30 + ], + "Drawer|-00.81|+00.61|+00.31": [ + -1.25, + 1.25, + 90, + 30 + ], + "Drawer|-01.32|+00.61|+00.31": [ + -0.75, + 1.25, + 270, + 30 + ], + "Drawer|-01.84|+00.31|+00.31": [ + -1.25, + 1.5, + 270, + 30 + ], + "Drawer|-01.84|+00.61|+00.31": [ + -1.25, + 1.25, + 270, + 30 + ], + "Sink|-00.46|-00.01|+03.05|SinkBasin": [ + -0.75, + 2.5, + 0, + 30 + ], + "Toilet|-01.84|+00.00|+02.50": [ + -1.25, + 1.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..78286bb77b667bbcec62afd1092b54c87bccbc53 GIT binary patch literal 992 zcmbW!F-pWh6oBCvd?>#gFscu9+{O{T={?_bcy1VWKZwD8_#-i| zu^tb($9=H=SLm}o>$5)Vvp(yy{&(oJKI^kS>$5)Vvwk1?tk3$a&-y&%@6Gz`e-F8@ f$9k;CdaTEN?z7%H^jMG0XY<*7Hh;|XJs;;kiPn^8 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json new file mode 100644 index 000000000..44d2e8f28 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json @@ -0,0 +1,32 @@ +[ + "PaperTowelRoll", + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json new file mode 100644 index 000000000..5cbe082d7 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json @@ -0,0 +1,80 @@ +{ + "Bathtub|-03.71|+00.34|+00.64|BathtubBasin": [ + -2.75, + 1.0, + 270, + 30 + ], + "CounterTop|-02.80|+00.00|-00.59": [ + -2.0, + 0.0, + 180, + 30 + ], + "Drawer|-01.44|+00.27|-00.62": [ + -2.0, + 0.5, + 90, + 30 + ], + "Drawer|-01.44|+00.53|-00.62": [ + -1.0, + 0.25, + 270, + 30 + ], + "Drawer|-01.89|+00.27|-00.62": [ + -2.5, + 0.5, + 90, + 30 + ], + "Drawer|-01.89|+00.53|-00.62": [ + -2.5, + 0.75, + 180, + 0 + ], + "Drawer|-02.34|+00.27|-00.62": [ + -1.75, + 0.5, + 270, + 30 + ], + "Drawer|-02.34|+00.53|-00.62": [ + -2.75, + 1.0, + 180, + 0 + ], + "Drawer|-02.79|+00.27|-00.62": [ + -2.25, + 0.5, + 270, + 30 + ], + "Drawer|-02.79|+00.53|-00.62": [ + -2.25, + 0.25, + 270, + 30 + ], + "GarbageCan|-01.56|00.00|+01.91": [ + -1.0, + 1.75, + 270, + 30 + ], + "Sink|-01.92|+00.44|+02.03|SinkBasin": [ + -2.25, + 1.5, + 0, + 30 + ], + "Toilet|-00.72|+00.00|-00.31": [ + -1.25, + 0.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0c26e75d4946aea3c1fb14ac01ba8043cc639973 GIT binary patch literal 992 zcmbWyu}Z^07{KvUM5Oc~ZaalcVnIY`CO5^!!AXKmaS$tsxQI{T1NjPlgpM5@938A) zeuFo9OZZ*#ef;xwadm!qy%nCrOPaO)ZI@1BI-MVyYc?ysEUUNReX*AJ)`h@*6;cGHO+b$;(Lwx8{1`*}IdH@qsmF05y-=wUsqhxM=?*28*O m59=8fJ*Y^LY5SY58prB*dQ{c1n$Eh1uDQRSb(8jc|FpU5 z+x32b+sxawcMlKhxW8A&=lI`e6n>u9MOsJ8w7zBUWUmT4@4fTe#d&s~huq_kA0AH9 z2J3Gv)4q9FpY=I?Dg@SN{mr7!`mE3Ttk3$P=(9fSvp(yy{%5{d_rvW5F9R9E-T(jq literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json new file mode 100644 index 000000000..07f7757be --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json new file mode 100644 index 000000000..850de0b4b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json @@ -0,0 +1,38 @@ +{ + "Bathtub|-02.12|-00.09|-03.12|BathtubBasin": [ + -1.0, + -2.75, + 270, + 30 + ], + "GarbageCan|-00.53|-00.05|-03.76": [ + -1.0, + -3.0, + 90, + 30 + ], + "SideTable|+00.78|+00.00|-00.67": [ + 0.25, + -1.25, + 90, + 30 + ], + "SideTable|+00.79|+00.00|-01.82": [ + 0.25, + -2.25, + 90, + 30 + ], + "SideTable|-01.53|+00.00|-00.17": [ + -1.0, + -0.75, + 0, + 30 + ], + "Toilet|+00.00|00.00|-03.44": [ + -0.5, + -3.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..720285dc4d0a54d810408c8459f90780d16de92f GIT binary patch literal 1760 zcmbW#p-#h46oBDEP&`FlA(?2RgN2>#x}RJm z>-Cmi*2``5vR>B9x;U@;no*oAwkzvnecbu};(dM2^|3zI$NF}To@LyxhxKq5J*tQ{thxM@kQx`q{@9g(uecZ+G t$8EAc=lZxw&+BupZ=L#BAM0a%+{QfC$NJd(KF#Mo?ql=Wd^W!y{Qy7=9rXYJ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json new file mode 100644 index 000000000..4ad43db6d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json @@ -0,0 +1,35 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Footstool", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json new file mode 100644 index 000000000..ebaf98b49 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json @@ -0,0 +1,50 @@ +{ + "CounterTop|+00.20|+00.43|-02.01": [ + 0.0, + -1.25, + 180, + 30 + ], + "Drawer|+00.30|+00.30|-01.82": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.30|+00.49|-01.82": [ + -0.25, + -1.0, + 90, + 30 + ], + "Drawer|+00.30|+00.68|-01.82": [ + -0.25, + -1.0, + 90, + 30 + ], + "Drawer|+00.30|+00.83|-01.82": [ + -0.25, + -0.75, + 180, + 0 + ], + "SideTable|-02.85|+00.01|+01.51": [ + -2.25, + 1.5, + 270, + 30 + ], + "Sink|-02.80|+00.33|+00.76|SinkBasin": [ + -2.25, + 1.25, + 180, + 30 + ], + "Toilet|-00.06|+00.01|+01.84": [ + -0.75, + 1.25, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..86f544e919f217f153d279dff30bf3b77c6ed5c8 GIT binary patch literal 1680 zcmbW%Jx;?w5QgCeAqr06&LFv>;YUcJq65)TP@#x8qCf;Whz4;A4wNhS2q{y#NRfhq z5bqO-DRDD;cPI1CXC?W%xx2o--%0Q3qa4-K$EG|l%8T)7Srz4Y(!4dpmxoC+s(;U~ zhR@S_eLj5}zSe6#JUgk1vwR8@RtsX?s8T+dmJy2;2qc>t_8N zKFo*P{CUiW`7j^mTLd5G!+e+z^I<;Br?%OP`7j^m!+e+zt30vtZO`-j#C(_!^I`qw z>c{%AemV7H{dj4=T=koyAM3}f{5h&~J@_TA?#qweKFb|GZKIigb`LKLgJ}e*Z oay}lvYb-BrL%;mn`n+a literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json new file mode 100644 index 000000000..67be1200d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json @@ -0,0 +1,47 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Statue", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Vase", + "Mug", + "CounterTop", + "ShelvingUnit", + "Spatula", + "Shelf", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json new file mode 100644 index 000000000..c4b6ea81e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json @@ -0,0 +1,152 @@ +{ + "Cabinet|+00.20|+02.02|-02.00": [ + 0.75, + -1.25, + 180, + 0 + ], + "Cabinet|+01.18|+02.02|-02.00": [ + 0.75, + -1.25, + 180, + 0 + ], + "Cabinet|+01.39|+00.47|-01.06": [ + 0.75, + -1.25, + 90, + 30 + ], + "Cabinet|+01.74|+02.02|-02.00": [ + 1.0, + -1.25, + 180, + 0 + ], + "Cabinet|+01.75|+02.02|-01.03": [ + 1.0, + -1.25, + 90, + 0 + ], + "Cabinet|-00.42|+00.37|-00.01": [ + 0.5, + -0.75, + 270, + 30 + ], + "Cabinet|-00.45|+00.47|-00.01": [ + 0.0, + -1.0, + 270, + 30 + ], + "Cabinet|-00.82|+00.47|-01.69": [ + 0.0, + -0.75, + 270, + 30 + ], + "Cabinet|-00.84|+00.47|-00.05": [ + -0.25, + -0.75, + 0, + 30 + ], + "Cabinet|-00.84|+00.47|-01.67": [ + 0.0, + -1.0, + 180, + 30 + ], + "Cabinet|-01.15|+02.02|+00.38": [ + -0.5, + -0.25, + 270, + 0 + ], + "Cabinet|-01.15|+02.02|-00.77": [ + -0.5, + -0.5, + 270, + 0 + ], + "Cabinet|-01.15|+02.02|-01.98": [ + -0.5, + -1.25, + 270, + 0 + ], + "CounterTop|+01.16|+00.95|-02.01": [ + 1.0, + -1.25, + 180, + 30 + ], + "CounterTop|-00.63|+01.17|+00.57": [ + 0.0, + 1.25, + 180, + 0 + ], + "CounterTop|-00.67|+00.95|+00.19": [ + -0.5, + -0.25, + 0, + 30 + ], + "Drawer|-00.07|+00.75|-00.01": [ + 0.5, + -1.0, + 0, + 0 + ], + "Drawer|-00.45|+00.75|-00.01": [ + -0.25, + -0.5, + 270, + 30 + ], + "Drawer|-00.82|+00.75|-01.69": [ + -0.5, + -0.75, + 180, + 0 + ], + "Fridge|+01.98|+00.00|-00.54": [ + 1.0, + -0.5, + 90, + 30 + ], + "GarbageCan|+01.92|-00.01|+00.14": [ + 1.25, + 0.25, + 90, + 30 + ], + "Microwave|+01.83|+00.90|-01.35": [ + 1.0, + -1.0, + 90, + 0 + ], + "Shelf|+02.76|+00.55|+00.15": [ + 2.25, + 0.75, + 180, + 30 + ], + "Shelf|+02.76|+00.88|+00.14": [ + 2.25, + 1.0, + 180, + 0 + ], + "Sink|-00.12|+00.88|-02.01|SinkBasin": [ + -0.5, + -1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..eb8f5923c6598a033abf4ed882d8bcd55e632ffa GIT binary patch literal 2176 zcmbW$Ax;BP5C-4}L2-(83rP)C4I!Zl2f-jvq@isPgpw`65Kh5?xWXO*iCj@pQ2})4 zs~E|emv7iN|I7j(S2vf}w|nKayw%g$^1i80tNLs{ss~j)Uo*OrB@IJ~|nW2G#I*P`y|Gd=AU@`Tp$Bb(~+x>Z_>dvrBdTyr&3#ikAI_)# z>iTmV{kh++6mHM^3V$VkC!0^MJy;*kr}@;|n2*iJ=411*`M8UD*}QVi%jRYGIG^TK zH!qu)&CBLx^XY3oHXoah_2GP)Z+!{%f2vHA2dA9wNlWBarItUqt!zI*am9_z>Y zv3}mukM-j&z6ZOnulwviyU*^cyU*^kdz{Zz%%`ruy8gV1@5%OJd8{wzQ{Fn}kjL^^ z9?N5SERQ!a|0dC<*_`L$MRSn%iB+RERVaGhyDMv|9@`N z`z4;;&*QtYeb_#1AGQzM=U`m6kMGC!Vf(Os*gk9@?o&$PHuhoruzlD*Y@dVi54~bm AHUIzs literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json new file mode 100644 index 000000000..b584a4738 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json @@ -0,0 +1,42 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Stool", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json new file mode 100644 index 000000000..8337ad36d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json @@ -0,0 +1,164 @@ +{ + "Cabinet|+00.15|+02.01|-01.60": [ + 0.75, + -1.0, + 180, + 0 + ], + "Cabinet|+01.57|+02.01|+00.47": [ + 0.75, + 0.25, + 90, + 0 + ], + "Cabinet|+01.57|+02.01|-00.78": [ + 0.75, + -1.0, + 90, + 0 + ], + "Cabinet|-02.15|+00.40|+00.64": [ + -1.5, + 0.0, + 0, + 30 + ], + "Cabinet|-02.15|+00.40|+00.70": [ + -1.25, + 1.5, + 180, + 30 + ], + "Cabinet|-02.15|+00.40|+01.58": [ + -1.25, + 0.75, + 0, + 30 + ], + "Cabinet|-02.15|+00.40|-00.24": [ + -1.5, + -0.5, + 0, + 30 + ], + "Cabinet|-02.29|+01.97|-01.33": [ + -1.5, + -1.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+00.36": [ + -1.5, + -0.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+00.41": [ + -1.75, + 1.0, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+01.64": [ + -1.75, + 1.0, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+01.69": [ + -1.75, + 2.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+02.93": [ + -1.75, + 2.25, + 270, + 0 + ], + "Cabinet|-02.45|+02.15|-00.29": [ + -1.5, + 0.0, + 270, + 0 + ], + "Cabinet|-02.45|+02.15|-01.28": [ + -1.25, + -0.75, + 270, + 0 + ], + "CounterTop|+00.47|+00.95|-01.63": [ + 0.75, + -1.0, + 180, + 30 + ], + "CounterTop|+01.59|+00.95|+00.41": [ + 1.0, + 0.75, + 90, + 30 + ], + "CounterTop|-00.36|+00.95|+01.09": [ + 0.5, + 1.25, + 270, + 30 + ], + "CounterTop|-01.49|+00.95|+01.32": [ + -1.75, + 0.5, + 270, + 30 + ], + "Drawer|-02.28|+00.79|+00.44": [ + -1.5, + 0.0, + 0, + 30 + ], + "Drawer|-02.28|+00.79|+00.90": [ + -1.5, + 0.5, + 0, + 30 + ], + "Drawer|-02.28|+00.79|+01.37": [ + -1.5, + 1.75, + 180, + 30 + ], + "Drawer|-02.28|+00.79|-00.03": [ + -1.5, + -0.5, + 0, + 30 + ], + "Fridge|-02.48|+00.00|-00.78": [ + -1.5, + -0.75, + 270, + 30 + ], + "GarbageCan|+01.65|00.00|+00.68": [ + 1.0, + 1.0, + 90, + 30 + ], + "Microwave|-02.58|+00.90|+02.44": [ + -1.75, + 2.5, + 270, + 0 + ], + "Sink|+01.38|+00.81|-01.27|SinkBasin": [ + 0.75, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..17b04ef444e20b59a55d337e4b7bd3e6962f4de5 GIT binary patch literal 4352 zcmbW%F>Vt<6b9g7WvwF1hj3?*Ttx_>2#KxeKr|Fo$Rds?P=ahkgE$2T@*crQNSSgA z7cN{7^5$D9ugo@+Z)SF9-v11LKYV)s@$<9ttNdPEuD4$|i;MZ<&DHD0a=y5_+5FtB zuD{%DF4zC(->trH*Z1?=Z>t~cdp|#a^>R5sf3ckZnLqKFmWOB7$9UMqI88oFZj-$~ zr1#nT?0xqBU3#Cr&)(xa-q!D!-zS&)jO%Y>f^U=Wl859&vU=P@o~#~L50CfQ#l6fM z)x+xHeZ3E>ht^H+@W zH7j41FUyzZJGzg*)G1$EcE# zf0jSXpXJZ;AKl0I)ggbDKeuVW{H@EM<o(te-sV<9qI*f2@Dp zrv3V7UH@4B_*C;{{bT*(A???{alQ6~)x~*~uX*`$)0KyZ<;(JA`LcXjzRr~|%a_|e z&S&|ud|AGHs(JA-S-#fg#qP~{l$ZIYOZQEdm;Lf$d9l2lBQKT*%Y)^?^5A35gXO`_ cSJ$ME`q+8wJa!&CkDbTP^E>lB_Pt5>5B$3_i~s-t literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json new file mode 100644 index 000000000..02e51c382 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json @@ -0,0 +1,50 @@ +[ + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Statue", + "PepperShaker", + "Pan", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "Book", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "HousePlant", + "Potato", + "Vase", + "Mug", + "CounterTop", + "ShelvingUnit", + "Spatula", + "Shelf", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json new file mode 100644 index 000000000..f0f78366b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json @@ -0,0 +1,146 @@ +{ + "Cabinet|+00.38|+00.37|-01.24": [ + -0.25, + -0.5, + 90, + 30 + ], + "Cabinet|+00.52|+02.01|-01.54": [ + 0.25, + -0.75, + 180, + 0 + ], + "Cabinet|+00.78|+00.37|-01.24": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|+01.45|+02.26|-01.54": [ + 1.0, + -0.75, + 180, + 0 + ], + "Cabinet|+01.78|+00.37|-01.24": [ + 1.25, + -0.5, + 90, + 30 + ], + "Cabinet|+01.78|+02.01|-01.54": [ + 1.25, + -0.75, + 180, + 0 + ], + "Cabinet|-00.57|+00.37|-01.24": [ + 0.25, + -0.5, + 270, + 30 + ], + "Cabinet|-00.71|+02.01|-01.54": [ + -0.5, + -0.75, + 180, + 0 + ], + "Cabinet|-01.48|+00.37|-01.24": [ + -0.75, + -0.25, + 180, + 30 + ], + "Cabinet|-01.67|+02.01|-01.54": [ + -1.0, + -0.75, + 180, + 0 + ], + "Cabinet|-02.17|+02.01|-01.54": [ + -2.75, + -1.0, + 90, + 0 + ], + "Cabinet|-02.22|+00.37|-01.87": [ + -2.75, + -1.25, + 90, + 30 + ], + "CounterTop|+01.65|+00.95|-01.53": [ + 1.25, + -0.75, + 90, + 30 + ], + "CounterTop|-01.87|+00.95|-00.61": [ + -2.5, + 0.5, + 90, + 30 + ], + "DiningTable|-02.66|+00.00|+03.21": [ + -2.5, + 2.25, + 0, + 30 + ], + "Drawer|+00.60|+00.68|-01.40": [ + 1.0, + -0.75, + 270, + 30 + ], + "Drawer|-01.64|+00.68|-00.93": [ + -1.0, + -0.25, + 270, + 30 + ], + "Drawer|-02.06|+00.68|-01.58": [ + -3.0, + -1.0, + 180, + 30 + ], + "Fridge|-00.04|+00.00|+02.18": [ + 0.0, + 1.25, + 0, + 30 + ], + "GarbageCan|-00.87|00.00|+02.14": [ + -1.75, + 1.5, + 0, + 30 + ], + "Microwave|+01.15|+01.66|-01.61": [ + 0.75, + -0.75, + 180, + 0 + ], + "Shelf|+03.73|+00.55|+01.67": [ + 2.5, + 1.75, + 90, + 0 + ], + "Shelf|+03.73|+00.88|+01.67": [ + 3.25, + 1.75, + 90, + 30 + ], + "Sink|+00.02|+00.77|-01.71|SinkBasin": [ + -0.75, + -0.75, + 180, + 0 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..f768a488c36e0b0a939b69a01e5488a6c8e1cd65 GIT binary patch literal 2768 zcmbW$ze*!f6u{xDgcLr-bfb`Fgl@bI&ivyq^C#ySUsbPvyD2p3eWy+M}jDzWLpbn)c>?_Bfl|UER;F zr(gT0liT_9bASGC@-Y4M{*PZjN6q2EsCjAr^V%!l*Kk?a^`fr43J>BwyWgk#yc^GR zNp_C=d3}#_?U%T?JETD)wA7?@0<0o`QGc}`(X3ge0C1!)!)Ou`E0)D%xCl2 zd^Vq*%Xu~5{whANee>CTHlNLB^VuBEtNHKoJ(YWxcGI z^>R!rte5q&-reZa%X(Qa>t(&Hm-TXqi}kWz);k!N?@KT1WxcGI^|D^p%XMlgte5q2 eS=Kj(B9dbv(5h4r%D;rIgsV3kz> literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json new file mode 100644 index 000000000..12da9582d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json @@ -0,0 +1,46 @@ +[ + "ButterKnife", + "Drawer", + "Lettuce", + "Toaster", + "StoveKnob", + "SaltShaker", + "Pot", + "Microwave", + "Stool", + "HousePlant", + "Floor", + "Apple", + "Fork", + "Cabinet", + "StoveBurner", + "LightSwitch", + "CoffeeMachine", + "SprayBottle", + "SinkBasin", + "Knife", + "Fridge", + "Spatula", + "Mug", + "Faucet", + "Ladle", + "SoapBottle", + "Sink", + "CounterTop", + "Kettle", + "Tomato", + "Cup", + "Egg", + "GarbageCan", + "Bowl", + "Bread", + "DishSponge", + "PepperShaker", + "Pen", + "Bottle", + "Plate", + "Window", + "Pan", + "Spoon", + "Potato" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json new file mode 100644 index 000000000..a327a281a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json @@ -0,0 +1,170 @@ +{ + "Cabinet|+00.49|+02.06|-01.69": [ + 0.5, + -0.75, + 180, + 0 + ], + "Cabinet|+00.83|+00.40|-01.39": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|+00.67": [ + 0.0, + 0.0, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|-00.55": [ + 0.0, + -0.75, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|-01.37": [ + 0.0, + -1.0, + 90, + 30 + ], + "Cabinet|+01.16|+02.06|-00.34": [ + 0.5, + -0.75, + 90, + 0 + ], + "Cabinet|+01.16|+02.06|-01.02": [ + 0.25, + -1.0, + 90, + 0 + ], + "Cabinet|-00.19|+02.06|-01.69": [ + 0.0, + -1.0, + 180, + 0 + ], + "Cabinet|-00.20|+00.40|-01.39": [ + -0.5, + -0.5, + 90, + 30 + ], + "Cabinet|-00.24|+00.40|-01.39": [ + -0.75, + -0.75, + 90, + 30 + ], + "Cabinet|-00.82|+00.40|-01.39": [ + -1.25, + -0.5, + 90, + 30 + ], + "Cabinet|-00.82|+02.06|-01.69": [ + 0.0, + -1.0, + 180, + 0 + ], + "Cabinet|-00.87|+02.01|-01.69": [ + -1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-01.61|+02.01|-01.69": [ + -2.0, + -0.5, + 180, + 0 + ], + "Cabinet|-01.66|+02.06|-01.68": [ + -2.25, + -1.0, + 180, + 0 + ], + "Cabinet|-01.67|+00.40|-01.39": [ + -2.0, + -1.0, + 180, + 30 + ], + "Cabinet|-02.24|+00.40|-01.39": [ + -2.5, + -1.0, + 180, + 30 + ], + "CounterTop|+01.17|+00.95|-00.65": [ + 0.5, + -0.75, + 90, + 30 + ], + "CounterTop|+01.50|+01.20|-00.66": [ + 0.5, + -1.0, + 90, + 0 + ], + "CounterTop|-01.97|+00.95|-01.71": [ + -2.5, + -1.25, + 90, + 30 + ], + "CounterTop|-02.10|+00.95|+00.29": [ + -1.5, + -0.25, + 0, + 30 + ], + "Drawer|+00.59|+00.75|-01.39": [ + 0.0, + -0.75, + 90, + 30 + ], + "Drawer|+00.86|+00.75|+00.43": [ + 0.0, + 1.0, + 90, + 0 + ], + "Drawer|+00.87|+00.75|-01.14": [ + 0.0, + -1.0, + 90, + 0 + ], + "Fridge|+01.42|+00.00|+02.10": [ + 0.5, + 2.0, + 90, + 0 + ], + "GarbageCan|+01.34|+00.02|+01.04": [ + 0.5, + 0.5, + 0, + 30 + ], + "Microwave|+01.42|+01.15|+00.02": [ + 0.5, + 0.5, + 90, + 0 + ], + "Sink|+00.16|+00.82|-01.80|SinkBasin": [ + 0.5, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..bd4533e3927e8b5b7557a060a87f6091d6716e6a GIT binary patch literal 1360 zcmbWzp-#h46b9hSLI~k0>I%seW`vMz3J1X;P^4j95QLGIUjvA*o7FV+|9i}l6&V) 0: + lock.acquire() + scene_num = all_scene_numbers.pop() + lock.release() + fn = os.path.join('layouts', ('FloorPlan%d-layout.npy') % scene_num) + if os.path.isfile(fn): + print("file %s already exists; skipping this floorplan" % fn) + continue + + openable_json_file = os.path.join('layouts', ('FloorPlan%d-openable.json') % scene_num) + scene_objs_json_file = os.path.join('layouts', ('FloorPlan%d-objects.json') % scene_num) + + scene_name = ('FloorPlan%d') % scene_num + print('Running ' + scene_name) + event = env.reset(scene_name, + render_image=False, + render_depth_image=False, + render_class_image=False, + render_object_image=True) + agent_height = event.metadata['agent']['position']['y'] + + scene_objs = list(set([obj['objectType'] for obj in event.metadata['objects']])) + with open(scene_objs_json_file, 'w') as sof: + json.dump(scene_objs, sof, sort_keys=True, indent=4) + + # Get all the reachable points through Unity for this step size. + event = env.step(dict(action='GetReachablePositions', + gridSize=constants.AGENT_STEP_SIZE / constants.RECORD_SMOOTHING_FACTOR)) + if event.metadata['actionReturn'] is None: + print("ERROR: scene %d 'GetReachablePositions' returns None" % scene_num) + else: + reachable_points = set() + for point in event.metadata['actionReturn']: + reachable_points.add((point['x'], point['z'])) + print("scene %d got %d reachable points, now checking" % (scene_num, len(reachable_points))) + + # Pick up a small object to use in testing whether points are good for openable objects. + open_test_objs = {'CD', 'CellPhone', 'Cloth', 'CreditCard', 'DishSponge', 'Fork', + 'KeyChain', 'Pen', 'Pencil', 'SoapBar', 'Spoon', 'Watch'} + good_obj_point = None + good_obj_point = get_obj(env, open_test_objs, reachable_points, agent_height, scene_name, good_obj_point) + + + best_open_point = {} # map from object names to the best point from which they can be successfully opened + best_sem_coverage = {} # number of pixels in the semantic map of the receptacle at the existing best openpt + checked_points = set() + scene_receptacles = set() + for point in reachable_points: + point_is_valid = True + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + } + event = env.step(action) + if event.metadata['lastActionSuccess']: + for horizon in [-30, 0, 30]: + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': 0, + 'horizon': horizon + } + event = env.step(action) + if not event.metadata['lastActionSuccess']: + point_is_valid = False + break + for rotation in range(3): + action = {'action': 'RotateLeft'} + event = env.step(action) + if not event.metadata['lastActionSuccess']: + point_is_valid = False + break + if not point_is_valid: + break + if point_is_valid: + checked_points.add(point) + else: + continue + + # Check whether we can open objects from here in any direction with any tilt. + for rotation in range(4): + # First try up, then down, then return to the horizon before moving again. + for horizon in [-30, 0, 30]: + + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': rotation * 90, + 'horizon': horizon + } + event = env.step(action) + for obj in event.metadata['objects']: + if (obj['visible'] and obj['objectId'] and obj['receptacle'] and not obj['pickupable'] + and obj['objectType'] in constants.VAL_RECEPTACLE_OBJECTS): + obj_name = obj['objectId'] + obj_point = (obj['position']['x'], obj['position']['y']) + scene_receptacles.add(obj_name) + + # Go ahead and attempt to close the object from this position if it's open. + if obj['openable'] and obj['isOpen']: + close_action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(close_action) + + point_to_recep = np.linalg.norm(np.array(point) - np.array(obj_point)) + if len(env.last_event.metadata['inventoryObjects']) > 0: + inv_obj = env.last_event.metadata['inventoryObjects'][0]['objectId'] + else: + inv_obj = None + + # Heuristic implemented in task_game_state has agent 0.5 or farther in agent space. + heuristic_far_enough_from_recep = 0.5 < point_to_recep + # Ensure this point affords a larger view according to the semantic segmentation + # of the receptacle than the existing. + point_sem_coverage = get_mask_of_obj(env, obj['objectId']) + if point_sem_coverage is None: + use_sem_heuristic = False + better_sem_covereage = False + else: + use_sem_heuristic = True + better_sem_covereage = (obj_name not in best_sem_coverage or + best_sem_coverage[obj_name] is None or + point_sem_coverage > best_sem_coverage[obj_name]) + # Ensure that this point is farther away than our existing best candidate. + # We'd like to open each receptacle from as far away as possible while retaining + # the ability to pick/place from it. + farther_than_existing_good_point = (obj_name not in best_open_point or + point_to_recep > + np.linalg.norm( + np.array(point) - + np.array(best_open_point[obj_name][:2]))) + # If we don't have an inventory object, though, we'll fall back to the heuristic + # of being able to open/close as _close_ as possible. + closer_than_existing_good_point = (obj_name not in best_open_point or + point_to_recep < + np.linalg.norm( + np.array(point) - + np.array(best_open_point[obj_name][:2]))) + # Semantic segmentation heuristic. + if ((use_sem_heuristic and heuristic_far_enough_from_recep and better_sem_covereage) + or (not use_sem_heuristic and + # Distance heuristics. + (heuristic_far_enough_from_recep and + (inv_obj and farther_than_existing_good_point) or + (not inv_obj and closer_than_existing_good_point)))): + if obj['openable']: + action = {'action': 'OpenObject', + 'objectId': obj['objectId']} + event = env.step(action) + if not obj['openable'] or event.metadata['lastActionSuccess']: + # We can open the object, so try placing our small inventory obj inside. + # If it can be placed inside and retrieved, then this is a safe point. + action = {'action': 'PutObject', + 'objectId': obj['objectId'], + 'forceAction': True, + 'placeStationary': True} + if inv_obj: + event = env.step(action) + if inv_obj is None or event.metadata['lastActionSuccess']: + action = {'action': 'PickupObject', + 'objectId': inv_obj} + if inv_obj: + event = env.step(action) + if inv_obj is None or event.metadata['lastActionSuccess']: + + # Finally, ensure we can also close the receptacle. + if obj['openable']: + action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(action) + if not obj['openable'] or event.metadata['lastActionSuccess']: + + # We can put/pick our inv object into the receptacle from here. + # We have already ensured this point is farther than any + # existing best, so this is the new best. + best_open_point[obj_name] = [point[0], point[1], rotation * 90, horizon] + best_sem_coverage[obj_name] = point_sem_coverage + + # We could not retrieve our inv object, so we need to go get another one + else: + good_obj_point = get_obj(env, open_test_objs, reachable_points, + agent_height, scene_name, good_obj_point) + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': rotation * 90, + 'horizon': horizon + } + event = env.step(action) + + # Regardless of what happened up there, try to close the receptacle again if + # it remained open. + if obj['isOpen']: + action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(action) + + essential_objs = [] + if scene_num in constants.SCENE_TYPE["Kitchen"]: + essential_objs.extend(["Microwave", "Fridge"]) + for obj in essential_objs: + if not np.any([obj in obj_key for obj_key in best_open_point]): + print("WARNING: Essential object %s has no open points in scene %d" % (obj, scene_num)) + + print("scene %d found open/pick/place/close positions for %d/%d receptacle objects" % + (scene_num, len(best_open_point), len(scene_receptacles))) + with open(openable_json_file, 'w') as f: + json.dump(best_open_point, f, sort_keys=True, indent=4) + + print("scene %d reachable %d, checked %d; taking intersection" % + (scene_num, len(reachable_points), len(checked_points))) + + points = np.array(list(checked_points))[:, :2] + points = points[np.lexsort((points[:, 0], points[:, 1])), :] + np.save(fn, points) + + env.stop() + print('Done') + + +threads = [] +for n in range(N_PROCS): + thread = threading.Thread(target=run, args=(n,)) + threads.append(thread) + thread.start() + time.sleep(1) diff --git a/models/main_models/rt1/gen/planner/__init__.py b/models/main_models/rt1/gen/planner/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl b/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl new file mode 100644 index 000000000..60280d713 --- /dev/null +++ b/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl @@ -0,0 +1,302 @@ +;; Specification in PDDL1 of the Extended Task domain + +(define (domain put_task) + (:requirements + :adl + ) + (:types + agent + location + receptacle + object + rtype + otype + ) + + + (:predicates + (atLocation ?a - agent ?l - location) ; true if the agent is at the location + (receptacleAtLocation ?r - receptacle ?l - location) ; true if the receptacle is at the location (constant) + (objectAtLocation ?o - object ?l - location) ; true if the object is at the location + (openable ?r - receptacle) ; true if a receptacle is openable + (opened ?r - receptacle) ; true if a receptacle is opened + (inReceptacle ?o - object ?r - receptacle) ; object ?o is in receptacle ?r + (isReceptacleObject ?o - object) ; true if the object can have things put inside it + (inReceptacleObject ?innerObject - object ?outerObject - object) ; object ?innerObject is inside object ?outerObject + (wasInReceptacle ?o - object ?r - receptacle) ; object ?o was or is in receptacle ?r now or some time in the past + ;(checked ?r - receptacle) ; whether the receptacle has been looked inside/visited + (receptacleType ?r - receptacle ?t - rtype) ; the type of receptacle (Cabinet vs Cabinet|01|2...) + (objectType ?o - object ?t - otype) ; the type of object (Apple vs Apple|01|2...) + (holds ?a - agent ?o - object) ; object ?o is held by agent ?a + (holdsAny ?a - agent) ; agent ?a holds an object + (holdsAnyReceptacleObject ?a - agent) ; agent ?a holds a receptacle object + ;(full ?r - receptacle) ; true if the receptacle has no remaining space + (isClean ?o - object) ; true if the object has been clean in sink + (cleanable ?o - object) ; true if the object can be placed in a sink + (isHot ?o - object) ; true if the object has been heated up + (heatable ?o - object) ; true if the object can be heated up in a microwave + (isCool ?o - object) ; true if the object has been cooled + (coolable ?o - object) ; true if the object can be cooled in the fridge + (toggleable ?o - object) ; true if the object can be turned on/off + (isOn ?o - object) ; true if the object is on + (isToggled ?o - object) ; true if the object has been toggled + (sliceable ?o - object) ; true if the object can be sliced + (isSliced ?o - object) ; true if the object is sliced + ) + + (:functions + (distance ?from ?to) + (totalCost) + ) + +;; All actions are specified such that the final arguments are the ones used +;; for performing actions in Unity. + +;; agent goes to receptacle + (:action GotoLocation + :parameters (?a - agent ?lStart - location ?lEnd - location) + :precondition (and + (atLocation ?a ?lStart) + (forall (?re - receptacle) + (not (opened ?re)) + ) + ) + :effect (and + (atLocation ?a ?lEnd) + (not (atLocation ?a ?lStart)) + (increase (totalCost) (distance ?lStart ?lEnd)) + ) + ) + +;; agent opens receptacle + (:action OpenObject + :parameters (?a - agent ?l - location ?r - receptacle) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (openable ?r) + (forall (?re - receptacle) + (not (opened ?re)) + ) + ) + :effect (and + (opened ?r) + (increase (totalCost) 1) + ) + ) +;; agent closes receptacle + (:action CloseObject + :parameters (?a - agent ?al - location ?r - receptacle) + :precondition (and + (atLocation ?a ?al) + (receptacleAtLocation ?r ?al) + (openable ?r) + (opened ?r) + ) + :effect (and + (not (opened ?r)) + (increase (totalCost) 1) + ) + + ) + +;; agent picks up object + (:action PickupObjectInReceptacle1 + :parameters (?a - agent ?l - location ?o - object ?r - receptacle) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (inReceptacle ?o ?r) + (not (holdsAny ?a)) + ) + :effect (and + (forall (?re - receptacle) + (not (inReceptacle ?o ?re)) + ) + (not (objectAtLocation ?o ?l)) + (holds ?a ?o) + (holdsAny ?a) + (increase (totalCost) 1) + ) + ) + +;; agent picks up object not in a receptacle + (:action PickupObjectNoReceptacle + :parameters (?a - agent ?l - location ?o - object) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (forall (?r - receptacle) + (not (inReceptacle ?o ?r)) + ) + (not (holdsAny ?a)) + ) + :effect (and + (not (objectAtLocation ?o ?l)) + (holds ?a ?o) + (holdsAny ?a) + (increase (totalCost) 1) + ) + ) + +;; agent puts down an object in a receptacle + (:action PutObjectInReceptacle1 + :parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle) ;?rt - rtype) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (objectType ?o ?ot) + (holds ?a ?o) + (not (holdsAnyReceptacleObject ?a)) + ) + :effect (and + (inReceptacle ?o ?r) + (not (holds ?a ?o)) + (not (holdsAny ?a)) + (increase (totalCost) 1) + (objectAtLocation ?o ?l) + ) + ) + +;; agent puts down an object + (:action PutObjectInReceptacleObject1 + :parameters (?a - agent ?l - location ?ot - otype ?o - object ?outerO - object ?outerR - receptacle) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?outerO ?l) + (isReceptacleObject ?outerO) + (not (isReceptacleObject ?o)) + (objectType ?o ?ot) + (holds ?a ?o) + (not (holdsAnyReceptacleObject ?a)) + (inReceptacle ?outerO ?outerR) + ) + :effect (and + (inReceptacleObject ?o ?outerO) + (inReceptacle ?o ?outerR) + (not (holds ?a ?o)) + (not (holdsAny ?a)) + (increase (totalCost) 1) + (objectAtLocation ?o ?l) + ) + ) + +;; agent puts down a receptacle object in a receptacle + (:action PutReceptacleObjectInReceptacle1 + :parameters (?a - agent ?l - location ?ot - otype ?outerO - object ?r - receptacle) ; ?rt - rtype) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (objectType ?outerO ?ot) + (holds ?a ?outerO) + (holdsAnyReceptacleObject ?a) + (isReceptacleObject ?outerO) + ) + :effect (and + (forall (?obj - object) + (when (holds ?a ?obj) + (and + (not (holds ?a ?obj)) + (objectAtLocation ?obj ?l) + (inReceptacle ?obj ?r) + ) + ) + ) + (not (holdsAny ?a)) + (not (holdsAnyReceptacleObject ?a)) + (increase (totalCost) 1) + ) + ) + +;; agent cleans some object + (:action CleanObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (receptacleType ?r SinkBasinType) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isClean ?o) + ) + ) + + +;; agent heats-up some object + (:action HeatObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (or + (receptacleType ?r MicrowaveType) + ) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isHot ?o) + ) + ) + +;; agent cools some object + (:action CoolObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (or + (receptacleType ?r FridgeType) + ) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isCool ?o) + ) + ) + + +;; agent toggle object + (:action ToggleObject + :parameters (?a - agent ?l - location ?o - object) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (toggleable ?o) + ) + :effect (and + (increase (totalCost) 5) + (when (isOn ?o) + (not (isOn ?o))) + (when (not (isOn ?o)) + (isOn ?o)) + (isToggled ?o) + ) + ) + + +;; agent slices some object with a knife + (:action SliceObject + :parameters (?a - agent ?l - location ?co - object ?ko - object) + :precondition + (and + (or + (objectType ?ko KnifeType) + (objectType ?ko ButterKnifeType) + ) + (atLocation ?a ?l) + (objectAtLocation ?co ?l) + (sliceable ?co) + (holds ?a ?ko) + ) + :effect (and + (increase (totalCost) 5) + (isSliced ?co) + ) + ) + + +) diff --git a/models/main_models/rt1/gen/planner/ff_planner_handler.py b/models/main_models/rt1/gen/planner/ff_planner_handler.py new file mode 100644 index 000000000..50937c677 --- /dev/null +++ b/models/main_models/rt1/gen/planner/ff_planner_handler.py @@ -0,0 +1,252 @@ +import pdb +import ast +import multiprocessing +import re +import shlex +import subprocess +import time + +import constants +from utils import game_util +from utils import py_util + +DEBUG = False + +CAPS_ACTION_TO_PLAN_ACTION = { + 'GOTOLOCATION': 'GotoLocation', + 'SCAN': 'Scan', + 'OPENOBJECT': 'OpenObject', + 'CLOSEOBJECT': 'CloseObject', + 'PICKUPOBJECT': 'PickupObject', + 'PICKUPOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', + 'PICKUPOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', + 'PICKUPRECEPTACLEOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', + 'PICKUPRECEPTACLEOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', + 'PICKUPOBJECTINOBJECT1': 'PickupObjectInObject', + 'PICKUPOBJECTINOBJECT2': 'PickupObjectInObject', + 'PUTOBJECTINRECEPTACLE1': 'PutObjectInReceptacle', + 'PUTOBJECTINRECEPTACLE2': 'PutObjectInReceptacle', + 'PUTOBJECTINRECEPTACLEOBJECT1': 'PutObjectInReceptacleObject', + 'PUTOBJECTINRECEPTACLEOBJECT2': 'PutObjectInReceptacleObject', + 'PUTRECEPTACLEOBJECTINRECEPTACLE1': 'PutReceptacleObjectInReceptacle', + 'PUTRECEPTACLEOBJECTINRECEPTACLE2': 'PutReceptacleObjectInReceptacle', + 'PICKUPOBJECTNORECEPTACLE': 'PickupObjectNoReceptacle', + 'PUTOBJECT': 'PutObject', + 'CLEANOBJECT': 'CleanObject', + 'HEATOBJECT': 'HeatObject', + 'TOGGLEOBJECT': 'ToggleObject', + 'COOLOBJECT': 'CoolObject', + 'SLICEOBJECT': 'SliceObject', + 'REACH-GOAL': 'End' +} + +LOWER_TO_FULL = {name.lower(): name for name in constants.OBJECTS} + + +def lower_to_full(input_str): + arr = input_str.split('|') + new_arr = [] + for item in arr: + if item in LOWER_TO_FULL: + new_arr.append(LOWER_TO_FULL[item]) + else: + new_arr.append(item) + return '|'.join(new_arr) + + + +def parse_action_arg(action_arg): + action_arg = action_arg.lower() + action_arg = py_util.multireplace(action_arg, + {'_minus_': '-', + '-': '#', + '_bar_': '|', + '_plus_': '+', + '_dot_': '.', + '_comma_': ','}) + action_arg = lower_to_full(action_arg) + return action_arg + + +def parse_line(line): + line = re.sub(r'^\s*step|\d+:\s*', '', line) + line = line.strip() + line_args = line.split(' ') + if line_args[0] not in CAPS_ACTION_TO_PLAN_ACTION: + return None + action = CAPS_ACTION_TO_PLAN_ACTION[line_args[0]] + if action == 'End': + return {'action': 'End', 'value': 1} + action_dict = {'action': action} + line_args = line_args[1:] # Remove action name from line_args + + if action in {'GotoLocation', 'Scan'}: + action_arg = line_args[2].lower() + action_arg = py_util.multireplace(action_arg, + {'_minus_': '-', + '-': '#', + '_bar_': '|', + '_plus_': '+', + '_dot_': '.', + '_comma_': ','}) + action_dict['location'] = action_arg + elif action in {'OpenObject', 'CloseObject', 'ToggleObject'}: + action_dict['objectId'] = parse_action_arg(line_args[2]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'HeatObject', 'CoolObject'}: + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'PickupObjectInReceptacle', 'PickupObjectNoReceptacle'}: + action_dict['action'] = 'PickupObject' + action_dict['objectId'] = parse_action_arg(line_args[2]) + if action == 'PickupObjectInReceptacle': + action_dict['receptacleObjectId'] = parse_action_arg(line_args[3]) + elif action in {'SliceObject'}: + action_dict['objectId'] = parse_action_arg(line_args[2]) + elif action in {'CleanObject'}: + action_dict['objectId'] = parse_action_arg(line_args[3]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'PutObjectInReceptacle', + 'PutObjectInReceptacleObject', + 'PutReceptacleObjectInReceptacle'}: + action_dict['action'] = 'PutObject' + action_dict['objectId'] = parse_action_arg(line_args[3]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[4]) + elif action in {'PickupObjectInObject'}: + action_dict['action'] = 'PickupObject' + + + return action_dict + + +def parse_plan(lines): + plan = [] + for line in lines: + action_dict = parse_line(line) + if action_dict is not None: + plan.append(action_dict) + return plan + + +def parse_plan_from_file(self, path): + lines = [line for line in open(path)] + return self.parse_plan(lines) + + +def get_plan_from_file(args): + domain, filepath, solver_type = args + + start_t = time.time() + try: + command = ('ff_planner/ff ' + '-o %s ' + '-s %d ' + '-f %s ' % (domain, solver_type, filepath)) + if DEBUG: + print(command) + planner_output = subprocess.check_output(shlex.split(command), timeout=30) + except subprocess.CalledProcessError as error: + # Plan is done + output_str = error.output.decode('utf-8') + if DEBUG: + print('output', output_str) + if ('goal can be simplified to FALSE' in output_str or + "won't get here: simplify, non logical" in output_str): + return [{'action': 'End', 'value': 0}] + elif 'goal can be simplified to TRUE' in output_str: + return [{'action': 'End', 'value': 1}] + elif len(output_str) == 0: + # Usually indicates segfault with ffplanner + # This happens when the goal needs an object that hasn't been seen yet like + # Q: "is there an egg in the garbage can," but no garbage can has been seen. + print('Empty plan') + print('Seg Fault') + return [{'action': 'End', 'value': 0}] + else: + print('problem', filepath) + print(output_str) + print('Empty plan') + return [{'action': 'End', 'value': 0}] + except subprocess.TimeoutExpired: + print('timeout solver', solver_type, 'problem', filepath) + print('Empty plan') + return ['timeout', {'action': 'End', 'value': 0}] + unparsed_plan = planner_output.decode('utf-8').split('\n') + if DEBUG: + print('unparsed', '\n'.join(unparsed_plan)) + parsed_plan = parse_plan(unparsed_plan) + if constants.DEBUG: + print('planned %s in %.5f, plan length %d solver type %d' % ( + filepath, time.time() - start_t, len(parsed_plan), solver_type)) + if len(parsed_plan) == 0: + parsed_plan = [{'action': 'End', 'value': 1}] + return parsed_plan + + +# Example of how to call ff +# /path/to/Metric-FF-v2.1/ff -o planner/domains/Question_domain.pddl -f planner/exists_problem.pddl +def get_plan_async(args): + domain, problem_id, solver_type = args + filepath = '%s/planner/generated_problems/problem_%s.pddl' % (constants.LOG_FILE, problem_id) + return get_plan_from_file((domain, filepath, solver_type)) + + +class PlanParser(object): + def __init__(self, domain_file_path): + self.domain = domain_file_path + self.problem_id = -1 + self.process_pool = multiprocessing.Pool(3) + #from multiprocessing.pool import ThreadPool + #self.process_pool = ThreadPool(3) + + def get_plan(self): + parsed_plans = self.process_pool.map(get_plan_async, zip([self.domain] * 3, [self.problem_id] * 3, range(3, 6))) + return self.find_best_plan(parsed_plans) + + def get_plan_from_file(self, domain_path, filepath): + parsed_plans = self.process_pool.map(get_plan_from_file, zip([domain_path] * 3, [filepath] * 3, range(3, 6))) + return self.find_best_plan(parsed_plans) + + # Unncessary, planner should be optimal. But the planner produces some weird actions + def clean_plan(self, plan): + cleaned_plan = list() + for i in range(len(plan)-1): + if not (plan[i]['action'] == 'GotoLocation' and plan[i+1]['action'] == 'GotoLocation'): + cleaned_plan.append(plan[i]) + cleaned_plan.append(plan[len(plan)-1]) + return cleaned_plan + + def find_best_plan(self, parsed_plans): + + if all([parsed_plan[0] == 'timeout' for parsed_plan in parsed_plans]): + parsed_plan = parsed_plans[0][1:] + else: + parsed_plans = [self.clean_plan(parsed_plan) for parsed_plan in parsed_plans if parsed_plan[0] != 'timeout'] + parsed_plan = min(parsed_plans, key=len) + + if constants.DEBUG: + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) + for pp, pl in enumerate(parsed_plan)])) + else: + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) + for pp, pl in enumerate(parsed_plan)])) + return parsed_plan + + +class SinglePlanParser(PlanParser): + def get_plan(self): + parsed_plan = get_plan_async([self.domain, self.problem_id, 3]) + return parsed_plan + + def get_plan_from_file(self, domain_path, filepath): + parsed_plan = get_plan_from_file([domain_path, filepath, 3]) + return parsed_plan + + +if __name__ == '__main__': + import sys + + DEBUG = constants.DEBUG + parser = PlanParser('planner/domains/PutTaskExtended_domain.pddl') + parser.problem_id = sys.argv[1] + result_plan = parser.get_plan() + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) for pp, pl in enumerate(result_plan)])) diff --git a/models/main_models/rt1/gen/planner/pddl.pdf b/models/main_models/rt1/gen/planner/pddl.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4acd4e0a5c03c58ab1177920fd70eaf3ce523982 GIT binary patch literal 196613 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

wc5{pc71>6lps{#4t; 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 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/scripts/augment_trajectories.py b/models/main_models/rt1/gen/scripts/augment_trajectories.py new file mode 100644 index 000000000..19aeb9be2 --- /dev/null +++ b/models/main_models/rt1/gen/scripts/augment_trajectories.py @@ -0,0 +1,312 @@ +import os +import sys +sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) +sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) + +import json +import glob +import os +import constants +import cv2 +import shutil +import numpy as np +import argparse +import threading +import time +import copy +import random +from utils.video_util import VideoSaver +from utils.py_util import walklevel +from env.thor_env import ThorEnv + + +TRAJ_DATA_JSON_FILENAME = "traj_data.json" +AUGMENTED_TRAJ_DATA_JSON_FILENAME = "augmented_traj_data.json" + +ORIGINAL_IMAGES_FORLDER = "raw_images" +HIGH_RES_IMAGES_FOLDER = "high_res_images" +DEPTH_IMAGES_FOLDER = "depth_images" +INSTANCE_MASKS_FOLDER = "instance_masks" + +IMAGE_WIDTH = 600 +IMAGE_HEIGHT = 600 + +render_settings = dict() +render_settings['renderImage'] = True +render_settings['renderDepthImage'] = True +render_settings['renderObjectImage'] = True +render_settings['renderClassImage'] = True + +video_saver = VideoSaver() + + +def get_image_index(save_path): + return len(glob.glob(save_path + '/*.png')) + + +def save_image_with_delays(env, action, + save_path, direction=constants.BEFORE): + im_ind = get_image_index(save_path) + counts = constants.SAVE_FRAME_BEFORE_AND_AFTER_COUNTS[action['action']][direction] + for i in range(counts): + save_image(env.last_event, save_path) + env.noop() + return im_ind + + +def save_image(event, save_path): + # rgb + rgb_save_path = os.path.join(save_path, HIGH_RES_IMAGES_FOLDER) + rgb_image = event.frame[:, :, ::-1] + + # depth + depth_save_path = os.path.join(save_path, DEPTH_IMAGES_FOLDER) + depth_image = event.depth_frame + depth_image = depth_image * (255 / 10000) + depth_image = depth_image.astype(np.uint8) + + # masks + mask_save_path = os.path.join(save_path, INSTANCE_MASKS_FOLDER) + mask_image = event.instance_segmentation_frame + + # dump images + im_ind = get_image_index(rgb_save_path) + cv2.imwrite(rgb_save_path + '/%09d.png' % im_ind, rgb_image) + cv2.imwrite(depth_save_path + '/%09d.png' % im_ind, depth_image) + cv2.imwrite(mask_save_path + '/%09d.png' % im_ind, mask_image) + + return im_ind + + +def save_images_in_events(events, root_dir): + for event in events: + save_image(event, root_dir) + + +def clear_and_create_dir(path): + if os.path.exists(path): + shutil.rmtree(path) + os.mkdir(path) + + +def augment_traj(env, json_file): + # load json data + with open(json_file) as f: + traj_data = json.load(f) + + # make directories + root_dir = json_file.replace(TRAJ_DATA_JSON_FILENAME, "") + + orig_images_dir = os.path.join(root_dir, ORIGINAL_IMAGES_FORLDER) + high_res_images_dir = os.path.join(root_dir, HIGH_RES_IMAGES_FOLDER) + depth_images_dir = os.path.join(root_dir, DEPTH_IMAGES_FOLDER) + instance_masks_dir = os.path.join(root_dir, INSTANCE_MASKS_FOLDER) + augmented_json_file = os.path.join(root_dir, AUGMENTED_TRAJ_DATA_JSON_FILENAME) + + # fresh images list + traj_data['images'] = list() + + clear_and_create_dir(high_res_images_dir) + clear_and_create_dir(depth_images_dir) + clear_and_create_dir(instance_masks_dir) + + # scene setup + scene_num = traj_data['scene']['scene_num'] + object_poses = traj_data['scene']['object_poses'] + object_toggles = traj_data['scene']['object_toggles'] + dirty_and_empty = traj_data['scene']['dirty_and_empty'] + + # reset + scene_name = 'FloorPlan%d' % scene_num + env.reset(scene_name) + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + + env.step(dict(traj_data['scene']['init_action'])) + print("Task: %s" % (traj_data['template']['task_desc'])) + + # setup task + env.set_task(traj_data, args, reward_type='dense') + rewards = [] + + for ll_idx, ll_action in enumerate(traj_data['plan']['low_actions']): + # next cmd under the current hl_action + cmd = ll_action['api_action'] + hl_action = traj_data['plan']['high_pddl'][ll_action['high_idx']] + + # remove unnecessary keys + cmd = {k: cmd[k] for k in ['action', 'objectId', 'receptacleObjectId', 'placeStationary', 'forceAction'] if k in cmd} + + if "MoveAhead" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_move_ahead(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + elif "Rotate" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_rotate(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + elif "Look" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_look(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + # handle the exception for CoolObject tasks where the actual 'CoolObject' action is actually 'CloseObject' + # TODO: a proper fix for this issue + elif "CloseObject" in cmd['action'] and \ + "CoolObject" in hl_action['planner_action']['action'] and \ + "OpenObject" in traj_data['plan']['low_actions'][ll_idx + 1]['api_action']['action']: + if args.time_delays: + cool_action = hl_action['planner_action'] + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.BEFORE) + event = env.step(cmd) + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.MIDDLE) + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.AFTER) + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + else: + if args.time_delays: + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.BEFORE) + event = env.step(cmd) + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.MIDDLE) + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.AFTER) + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + # update image list + new_img_idx = get_image_index(high_res_images_dir) + last_img_idx = len(traj_data['images']) + num_new_images = new_img_idx - last_img_idx + for j in range(num_new_images): + traj_data['images'].append({ + 'low_idx': ll_idx, + 'high_idx': ll_action['high_idx'], + 'image_name': '%09d.png' % int(last_img_idx + j) + }) + + if not event.metadata['lastActionSuccess']: + raise Exception("Replay Failed: %s" % (env.last_event.metadata['errorMessage'])) + + reward, _ = env.get_transition_reward() + rewards.append(reward) + + # save 10 frames in the end as per the training data + for _ in range(10): + save_image(env.last_event, root_dir) + + # store color to object type dictionary + color_to_obj_id_type = {} + all_objects = env.last_event.metadata['objects'] + for color, object_id in env.last_event.color_to_object_id.items(): + for obj in all_objects: + if object_id == obj['objectId']: + color_to_obj_id_type[str(color)] = { + 'objectID': obj['objectId'], + 'objectType': obj['objectType'] + } + + augmented_traj_data = copy.deepcopy(traj_data) + augmented_traj_data['scene']['color_to_object_type'] = color_to_obj_id_type + augmented_traj_data['task'] = {'rewards': rewards, 'reward_upper_bound': sum(rewards)} + + with open(augmented_json_file, 'w') as aj: + json.dump(augmented_traj_data, aj, sort_keys=True, indent=4) + + # save video + images_path = os.path.join(high_res_images_dir, '*.png') + video_save_path = os.path.join(high_res_images_dir, 'high_res_video.mp4') + video_saver.save(images_path, video_save_path) + + # check if number of new images is the same as the number of original images + if args.smooth_nav and args.time_delays: + orig_img_count = get_image_index(high_res_images_dir) + new_img_count = get_image_index(orig_images_dir) + print ("Original Image Count %d, New Image Count %d" % (orig_img_count, new_img_count)) + if orig_img_count != new_img_count: + raise Exception("WARNING: the augmented sequence length doesn't match the original") + + +def run(): + ''' + replay loop + ''' + # start THOR env + env = ThorEnv(player_screen_width=IMAGE_WIDTH, + player_screen_height=IMAGE_HEIGHT) + + skipped_files = [] + + while len(traj_list) > 0: + lock.acquire() + json_file = traj_list.pop() + lock.release() + + print ("Augmenting: " + json_file) + try: + augment_traj(env, json_file) + except Exception as e: + import traceback + traceback.print_exc() + print ("Error: " + repr(e)) + print ("Skipping " + json_file) + skipped_files.append(json_file) + + env.stop() + print("Finished.") + + # skipped files + if len(skipped_files) > 0: + print("Skipped Files:") + print(skipped_files) + + +traj_list = [] +lock = threading.Lock() + +# parse arguments +parser = argparse.ArgumentParser() +parser.add_argument('--data_path', type=str, default="data/2.1.0") +parser.add_argument('--smooth_nav', dest='smooth_nav', action='store_true') +parser.add_argument('--time_delays', dest='time_delays', action='store_true') +parser.add_argument('--shuffle', dest='shuffle', action='store_true') +parser.add_argument('--num_threads', type=int, default=1) +parser.add_argument('--reward_config', type=str, default='../models/config/rewards.json') +args = parser.parse_args() + +# make a list of all the traj_data json files +for dir_name, subdir_list, file_list in walklevel(args.data_path, level=2): + if "trial_" in dir_name: + json_file = os.path.join(dir_name, TRAJ_DATA_JSON_FILENAME) + if not os.path.isfile(json_file): + continue + traj_list.append(json_file) + +# random shuffle +if args.shuffle: + random.shuffle(traj_list) + +# start threads +threads = [] +for n in range(args.num_threads): + thread = threading.Thread(target=run) + threads.append(thread) + thread.start() + time.sleep(1) \ No newline at end of file diff --git a/models/main_models/rt1/gen/scripts/generate_trajectories.py b/models/main_models/rt1/gen/scripts/generate_trajectories.py new file mode 100644 index 000000000..5e67ce0e8 --- /dev/null +++ b/models/main_models/rt1/gen/scripts/generate_trajectories.py @@ -0,0 +1,752 @@ +import os +import sys +sys.path.append(os.path.join('/Users/jiasenl/Code/alfred')) +sys.path.append(os.path.join('/Users/jiasenl/Code/alfred', 'gen')) + +import time +import multiprocessing as mp +import json +import random +import shutil +import argparse +import numpy as np +import pandas as pd +from collections import OrderedDict +from datetime import datetime +import glob +import constants +from agents.deterministic_planner_agent import DeterministicPlannerAgent +from env.thor_env import ThorEnv +from game_states.task_game_state_full_knowledge import TaskGameStateFullKnowledge +from utils.video_util import VideoSaver +from utils.dataset_management_util import load_successes_from_disk, load_fails_from_disk + +# params +RAW_IMAGES_FOLDER = 'raw_images/' +DATA_JSON_FILENAME = 'traj_data.json' +DEPTH_IMAGES_FOLDER = 'depth_images/' + +# video saver +video_saver = VideoSaver() + +# structures to help with constraint enforcement. +goal_to_required_variables = {"pick_and_place_simple": {"pickup", "receptacle", "scene"}, + "pick_two_obj_and_place": {"pickup", "receptacle", "scene"}, + "look_at_obj_in_light": {"pickup", "receptacle", "scene"}, + "pick_clean_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_heat_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_cool_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_and_place_with_movable_recep": {"pickup", "movable", "receptacle", "scene"}} +goal_to_pickup_type = {'pick_heat_then_place_in_recep': 'Heatable', + 'pick_cool_then_place_in_recep': 'Coolable', + 'pick_clean_then_place_in_recep': 'Cleanable'} +goal_to_receptacle_type = {'look_at_obj_in_light': "Toggleable"} +goal_to_invalid_receptacle = {'pick_heat_then_place_in_recep': {'Microwave'}, + 'pick_cool_then_place_in_recep': {'Fridge'}, + 'pick_clean_then_place_in_recep': {'SinkBasin'}, + 'pick_two_obj_and_place': {'CoffeeMachine', 'ToiletPaperHanger', 'HandTowelHolder'}} + +scene_id_to_objs = {} +obj_to_scene_ids = {} +scenes_for_goal = {g: [] for g in constants.GOALS} +scene_to_type = {} + + +def sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, receptacle_candidates, scene_candidates, + inject_noise=10): + # Get the current conditional distributions of all variables (goal/pickup/receptacle/scene). + goal_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + succ_traj.loc[ + (succ_traj['pickup'].isin(pickup_candidates) if 'pickup' in goal_to_required_variables[c] else True) & + (succ_traj['movable'].isin(movable_candidates) if 'movable' in goal_to_required_variables[c] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) if 'receptacle' in goal_to_required_variables[c] else True) + & (succ_traj['scene'].isin(scene_candidates) if 'scene' in goal_to_required_variables[c] else True)] + ['goal'].tolist().count(c))) # Conditional. + * (1 / (1 + succ_traj['goal'].tolist().count(c))) # Prior. + for c in goal_candidates] + goal_probs = [w / sum(goal_weight) for w in goal_weight] + + pickup_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['pickup'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['pickup'].tolist().count(c))) + for c in pickup_candidates] + pickup_probs = [w / sum(pickup_weight) for w in pickup_weight] + + movable_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['movable'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['movable'].tolist().count(c))) + for c in movable_candidates] + movable_probs = [w / sum(movable_weight) for w in movable_weight] + + receptacle_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['receptacle'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['receptacle'].tolist().count(c))) + for c in receptacle_candidates] + receptacle_probs = [w / sum(receptacle_weight) for w in receptacle_weight] + scene_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True)] + ['scene'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['scene'].tolist().count(c))) + for c in scene_candidates] + scene_probs = [w / sum(scene_weight) for w in scene_weight] + + # Calculate the probability difference between each value and the maximum so we can iterate over them to find a + # next-best candidate to sample subject to the constraints of knowing which will fail. + diffs = [("goal", goal_candidates[idx], goal_probs[idx] - min(goal_probs)) + for idx in range(len(goal_candidates)) if len(goal_candidates) > 1] + diffs.extend([("pickup", pickup_candidates[idx], pickup_probs[idx] - min(pickup_probs)) + for idx in range(len(pickup_candidates)) if len(pickup_candidates) > 1]) + diffs.extend([("movable", movable_candidates[idx], movable_probs[idx] - min(movable_probs)) + for idx in range(len(movable_candidates)) if len(movable_candidates) > 1]) + diffs.extend([("receptacle", receptacle_candidates[idx], receptacle_probs[idx] - min(receptacle_probs)) + for idx in range(len(receptacle_candidates)) if len(receptacle_candidates) > 1]) + diffs.extend([("scene", scene_candidates[idx], scene_probs[idx] - min(scene_probs)) + for idx in range(len(scene_candidates)) if len(scene_candidates) > 1]) + + # Iteratively pop the next biggest difference until we find a combination that is valid (e.g., not already + # flagged as impossible by the simulator). + variable_value_by_diff = {} + diffs_as_keys = [] # list of diffs; index into list will be used as key values. + for _, _, diff in diffs: + already_keyed = False + for existing_diff in diffs_as_keys: + if np.isclose(existing_diff, diff): + already_keyed = True + break + if not already_keyed: + diffs_as_keys.append(diff) + for variable, value, diff in diffs: + key = None + for kidx in range(len(diffs_as_keys)): + if np.isclose(diffs_as_keys[kidx], diff): + key = kidx + if key not in variable_value_by_diff: + variable_value_by_diff[key] = [] + variable_value_by_diff[key].append((variable, value)) + + for key, diff in sorted(enumerate(diffs_as_keys), key=lambda x: x[1], reverse=True): + variable_value = variable_value_by_diff[key] + random.shuffle(variable_value) + for variable, value in variable_value: + + # Select a goal. + if variable == "goal": + gtype = value + # print("sampled goal '%s' with prob %.4f" % (gtype, goal_probs[goal_candidates.index(gtype)])) + _goal_candidates = [gtype] + + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a pickup object. + elif variable == "pickup": + pickup_obj = value + # print("sampled pickup object '%s' with prob %.4f" % + # (pickup_obj, pickup_probs[pickup_candidates.index(pickup_obj)])) + _pickup_candidates = [pickup_obj] + + _goal_candidates = goal_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a movable object. + elif variable == "movable": + movable_obj = value + # print("sampled movable object '%s' with prob %.4f" % + # (movable_obj, movable_probs[movable_candidates.index(movable_obj)])) + _movable_candidates = [movable_obj] + _goal_candidates = [g for g in goal_candidates if g == 'pick_and_place_with_movable_recep'] + + _pickup_candidates = pickup_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a receptacle. + elif variable == "receptacle": + receptacle_obj = value + # print("sampled receptacle object '%s' with prob %.4f" % + # (receptacle_obj, receptacle_probs[receptacle_candidates.index(receptacle_obj)])) + _receptacle_candidates = [receptacle_obj] + + _goal_candidates = goal_candidates[:] + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a scene. + else: + sampled_scene = value + # print("sampled scene %s with prob %.4f" % + # (sampled_scene, scene_probs[scene_candidates.index(sampled_scene)])) + _scene_candidates = [sampled_scene] + + _goal_candidates = goal_candidates[:] + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + # Perform constraint propagation to determine whether this is a valid assignment. + propagation_finished = False + while not propagation_finished: + assignment_lens = (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), + len(_receptacle_candidates), len(_scene_candidates)) + # Constraints on goal. + _goal_candidates = [g for g in _goal_candidates if + (g not in goal_to_pickup_type or + len(set(_pickup_candidates).intersection( # Pickup constraint. + constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]])) > 0) + and (g not in goal_to_receptacle_type or + np.any([r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]] + for r in _receptacle_candidates])) # Valid by goal receptacle const. + and (g not in goal_to_invalid_receptacle or + len(set(_receptacle_candidates).difference( + goal_to_invalid_receptacle[g])) > 0) # Invalid by goal receptacle const. + and len(set(_scene_candidates).intersection( + scenes_for_goal[g])) > 0 # Scene constraint + ] + + # Define whether to consider constraints for each role based on current set of candidate goals. + pickup_constrained = np.any(["pickup" in goal_to_required_variables[g] for g in _goal_candidates]) + movable_constrained = np.any(["movable" in goal_to_required_variables[g] for g in _goal_candidates]) + receptacle_constrained = np.any(["receptacle" in goal_to_required_variables[g] + for g in _goal_candidates]) + scene_constrained = np.any(["scene" in goal_to_required_variables[g] for g in _goal_candidates]) + + # Constraints on pickup obj. + _pickup_candidates = [p for p in _pickup_candidates if + np.any([g not in goal_to_pickup_type or + p in constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]] + for g in _goal_candidates]) # Goal constraint. + and (not movable_constrained or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] + for m in _movable_candidates])) # Movable constraint. + and (not receptacle_constrained or + np.any([r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + p in constants.VAL_RECEPTACLE_OBJECTS[r] + for r in _receptacle_candidates])) # Receptacle constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[p]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on movable obj. + _movable_candidates = [m for m in _movable_candidates if + 'pick_and_place_with_movable_recep' in _goal_candidates # Goal constraint + and (not pickup_constrained or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] + for p in _pickup_candidates])) # Pickup constraint. + and (not receptacle_constrained or + np.any([r in constants.VAL_RECEPTACLE_OBJECTS and + m in constants.VAL_RECEPTACLE_OBJECTS[r] + for r in _receptacle_candidates])) # Receptacle constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[m]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on receptacle obj. + _receptacle_candidates = [r for r in _receptacle_candidates if + np.any([(g not in goal_to_receptacle_type or + r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]]) and + (g not in goal_to_invalid_receptacle or + r not in goal_to_invalid_receptacle[g]) + for g in _goal_candidates]) # Goal constraint. + and (not receptacle_constrained or + r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[r] + for p in _pickup_candidates])) # Pickup constraint. + and (not movable_constrained or + r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + np.any([m in constants.VAL_RECEPTACLE_OBJECTS[r] + for m in _movable_candidates])) # Movable constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[r]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on scene. + _scene_candidates = [s for s in _scene_candidates if + np.any([s in scenes_for_goal[g] + for g in _goal_candidates]) # Goal constraint. + and (not pickup_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[p]] + for p in _pickup_candidates])) # Pickup constraint. + and (not movable_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[m]] + for m in _movable_candidates])) # Movable constraint. + and (not receptacle_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[r]] + for r in _receptacle_candidates])) # Receptacle constraint. + ] + if assignment_lens == (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), + len(_receptacle_candidates), len(_scene_candidates)): + propagation_finished = True + + candidate_lens = {"goal": len(_goal_candidates), "pickup": len(_pickup_candidates), + "movable": len(_movable_candidates), "receptacle": len(_receptacle_candidates), + "scene": len(_scene_candidates)} + if candidate_lens["goal"] == 0: + # print("Goal over-constrained; skipping") + continue + if np.all([0 in [candidate_lens[v] for v in goal_to_required_variables[g]] for g in _goal_candidates]): + continue + + # Ensure some combination of the remaining constraints is not in failures and is not already populated + # by the target number of repeats. + failure_ensured = True + full_ensured = True + for g in _goal_candidates: + pickup_iter = _pickup_candidates if "pickup" in goal_to_required_variables[g] else ["None"] + for p in pickup_iter: + movable_iter = _movable_candidates if "movable" in goal_to_required_variables[g] else ["None"] + for m in movable_iter: + receptacle_iter = _receptacle_candidates if "receptacle" in goal_to_required_variables[g] \ + else ["None"] + for r in receptacle_iter: + scene_iter = _scene_candidates if "scene" in goal_to_required_variables[g] else ["None"] + for s in scene_iter: + if (g, p, m, r, s) not in fail_traj: + failure_ensured = False + if (g, p, m, r, s) not in full_traj: + full_ensured = False + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if failure_ensured: + continue + if full_ensured: + continue + + if candidate_lens["goal"] > 1 or np.any([np.any([candidate_lens[v] > 1 + for v in goal_to_required_variables[g]]) + for g in _goal_candidates]): + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + _goal_candidates, _pickup_candidates, _movable_candidates, + _receptacle_candidates, _scene_candidates) + sampled_task = next(task_sampler) + if sampled_task is None: + continue + else: + g = _goal_candidates[0] + p = _pickup_candidates[0] if "pickup" in goal_to_required_variables[g] else "None" + m = _movable_candidates[0] if "movable" in goal_to_required_variables[g] else "None" + r = _receptacle_candidates[0] if "receptacle" in goal_to_required_variables[g] else "None" + s = _scene_candidates[0] if "scene" in goal_to_required_variables[g] else "None" + sampled_task = (g, p, m, r, int(s)) + + yield sampled_task + + yield None # Discovered that there are no valid assignments remaining. + + +def print_successes(succ_traj): + print("###################################\n") + print("Successes: ") + print(succ_traj) + print("\n##################################") + + +def main(args, thread_num=0): + + print(thread_num) + # settings + alfred_dataset_path = '../data/json_2.1.0/train' + + constants.DATA_SAVE_PATH = args.save_path + print("Force Unsave Data: %s" % str(args.force_unsave)) + + # Set up data structure to track dataset balance and use for selecting next parameters. + # In actively gathering data, we will try to maximize entropy for each (e.g., uniform spread of goals, + # uniform spread over patient objects, uniform recipient objects, and uniform scenes). + succ_traj = pd.DataFrame(columns=["goal", "pickup", "movable", "receptacle", "scene"]) + + # objects-to-scene and scene-to-objects database + for scene_type, ids in constants.SCENE_TYPE.items(): + for id in ids: + obj_json_file = os.path.join('layouts', 'FloorPlan%d-objects.json' % id) + with open(obj_json_file, 'r') as of: + scene_objs = json.load(of) + + id_str = str(id) + scene_id_to_objs[id_str] = scene_objs + for obj in scene_objs: + if obj not in obj_to_scene_ids: + obj_to_scene_ids[obj] = set() + obj_to_scene_ids[obj].add(id_str) + + # scene-goal database + for g in constants.GOALS: + for st in constants.GOALS_VALID[g]: + scenes_for_goal[g].extend([str(s) for s in constants.SCENE_TYPE[st]]) + scenes_for_goal[g] = set(scenes_for_goal[g]) + + # scene-type database + for st in constants.SCENE_TYPE: + for s in constants.SCENE_TYPE[st]: + scene_to_type[str(s)] = st + + # pre-populate counts in this structure using saved trajectories path. + succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, args.just_examine, args.repeats_per_cond) + if args.just_examine: + print_successes(succ_traj) + return + + print(succ_traj.groupby('goal').count()) + # pre-populate failed trajectories. + fail_traj = load_fails_from_disk(args.save_path) + print("Loaded %d known failed tuples" % len(fail_traj)) + + # create env and agent + env = ThorEnv(x_display='0.%d' %(thread_num % 2)) + + game_state = TaskGameStateFullKnowledge(env) + agent = DeterministicPlannerAgent(thread_id=0, game_state=game_state) + + errors = {} # map from error strings to counts, to be shown after every failure. + goal_candidates = constants.GOALS[:] + pickup_candidates = list(set().union(*[constants.VAL_RECEPTACLE_OBJECTS[obj] # Union objects that can be placed. + for obj in constants.VAL_RECEPTACLE_OBJECTS])) + pickup_candidates = [p for p in pickup_candidates if constants.OBJ_PARENTS[p] in obj_to_scene_ids] + movable_candidates = list(set(constants.MOVABLE_RECEPTACLES).intersection(obj_to_scene_ids.keys())) + receptacle_candidates = [obj for obj in constants.VAL_RECEPTACLE_OBJECTS + if obj not in constants.MOVABLE_RECEPTACLES and obj in obj_to_scene_ids] + \ + [obj for obj in constants.VAL_ACTION_OBJECTS["Toggleable"] + if obj in obj_to_scene_ids] + + # toaster isn't interesting in terms of producing linguistic diversity + receptacle_candidates.remove('Toaster') + receptacle_candidates.sort() + + scene_candidates = list(scene_id_to_objs.keys()) + + n_until_load_successes = args.async_load_every_n_samples + print_successes(succ_traj) + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, + receptacle_candidates, scene_candidates) + + # main generation loop + # keeps trying out new task tuples as trajectories either fail or suceed + while True: + # for _ in range(20): + for ii, json_path in enumerate(glob.iglob(os.path.join(alfred_dataset_path, "**", "traj_data.json"), recursive=True)): + # if ii % args.num_threads == thread_num: + # if ii == 5: + sampled_task = json_path.split('/')[-3].split('-') + # sampled_task = next(task_sampler) + # print("===============") + # print(ii, json_path) + print(sampled_task) # DEBUG + # print("===============") + + if sampled_task is None: + sys.exit("No valid tuples left to sample (all are known to fail or already have %d trajectories" % + args.repeats_per_cond) + gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene = sampled_task + + sampled_scene = int(sampled_scene) + print("sampled tuple: " + str((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene))) + + tries_remaining = args.trials_before_fail + # only try to get the number of trajectories left to make this tuple full. + target_remaining = args.repeats_per_cond - len(succ_traj.loc[(succ_traj['goal'] == gtype) & + (succ_traj['pickup'] == pickup_obj) & + (succ_traj['movable'] == movable_obj) & + (succ_traj['receptacle'] == receptacle_obj) & + (succ_traj['scene'] == str(sampled_scene))]) + num_place_fails = 0 # count of errors related to placement failure for no valid positions. + + # continue until we're (out of tries + have never succeeded) or (have gathered the target number of instances) + while num_place_fails > args.trials_before_fail or target_remaining > 0: + + # environment setup + constants.pddl_goal_type = gtype + print("PDDLGoalType: " + constants.pddl_goal_type) + task_id = create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene) + + # setup data dictionary + setup_data_dict() + constants.data_dict['task_id'] = task_id + constants.data_dict['task_type'] = constants.pddl_goal_type + constants.data_dict['dataset_params']['video_frame_rate'] = constants.VIDEO_FRAME_RATE + + # plan & execute + try: + # if True: + # Agent reset to new scene. + constraint_objs = {'repeat': [(constants.OBJ_PARENTS[pickup_obj], # Generate multiple parent objs. + np.random.randint(2 if gtype == "pick_two_obj_and_place" else 1, + constants.PICKUP_REPEAT_MAX + 1))], + 'sparse': [(receptacle_obj.replace('Basin', ''), + num_place_fails * constants.RECEPTACLE_SPARSE_POINTS)]} + if movable_obj != "None": + constraint_objs['repeat'].append((movable_obj, + np.random.randint(1, constants.PICKUP_REPEAT_MAX + 1))) + for obj_type in scene_id_to_objs[str(sampled_scene)]: + if (obj_type in pickup_candidates and + obj_type != constants.OBJ_PARENTS[pickup_obj] and obj_type != movable_obj): + constraint_objs['repeat'].append((obj_type, + np.random.randint(1, constants.MAX_NUM_OF_OBJ_INSTANCES + 1))) + if gtype in goal_to_invalid_receptacle: + constraint_objs['empty'] = [(r.replace('Basin', ''), num_place_fails * constants.RECEPTACLE_EMPTY_POINTS) + for r in goal_to_invalid_receptacle[gtype]] + constraint_objs['seton'] = [] + if gtype == 'look_at_obj_in_light': + constraint_objs['seton'].append((receptacle_obj, False)) + if num_place_fails > 0: + print("Failed %d placements in the past; increased free point constraints: " % num_place_fails + + str(constraint_objs)) + scene_info = {'scene_num': sampled_scene, 'random_seed': random.randint(0, 2 ** 32)} + info = agent.reset(scene=scene_info, + objs=constraint_objs) + + # Problem initialization with given constraints. + task_objs = {'pickup': pickup_obj} + if movable_obj != "None": + task_objs['mrecep'] = movable_obj + if gtype == "look_at_obj_in_light": + task_objs['toggle'] = receptacle_obj + else: + task_objs['receptacle'] = receptacle_obj + agent.setup_problem({'info': info}, scene=scene_info, objs=task_objs) + + # Now that objects are in their initial places, record them. + object_poses = [{'objectName': obj['name'].split('(Clone)')[0], + 'position': obj['position'], + 'rotation': obj['rotation']} + for obj in env.last_event.metadata['objects'] if obj['pickupable']] + dirty_and_empty = gtype == 'pick_clean_then_place_in_recep' + object_toggles = [{'objectType': o, 'stateChange': 'toggleable', 'isToggled': v} + for o, v in constraint_objs['seton']] + constants.data_dict['scene']['object_poses'] = object_poses + constants.data_dict['scene']['dirty_and_empty'] = dirty_and_empty + constants.data_dict['scene']['object_toggles'] = object_toggles + + # Pre-restore the scene to cause objects to "jitter" like they will when the episode is replayed + # based on stored object and toggle info. This should put objects closer to the final positions they'll + # be inlay at inference time (e.g., mugs fallen and broken, knives fallen over, etc.). + print("Performing reset via thor_env API") + env.reset(sampled_scene) + print("Performing restore via thor_env API") + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + event = env.step(dict(constants.data_dict['scene']['init_action'])) + + terminal = False + while not terminal and agent.current_frame_count <= constants.MAX_EPISODE_LENGTH: + action_dict = agent.get_action(None) + agent.step(action_dict) + reward, terminal = agent.get_reward() + + dump_data_dict() + save_video() + # else: + except Exception as e: + import traceback + traceback.print_exc() + print("Error: " + repr(e)) + print("Invalid Task: skipping...") + if args.debug: + print(traceback.format_exc()) + + deleted = delete_save(args.in_parallel) + if not deleted: # another thread is filling this task successfully, so leave it alone. + target_remaining = 0 # stop trying to do this task. + else: + if str(e) == "API Action Failed: No valid positions to place object found": + # Try increasing the space available on sparse and empty flagged objects. + num_place_fails += 1 + tries_remaining -= 1 + else: # generic error + tries_remaining -= 1 + + estr = str(e) + if len(estr) > 120: + estr = estr[:120] + if estr not in errors: + errors[estr] = 0 + errors[estr] += 1 + print("%%%%%%%%%%") + es = sum([errors[er] for er in errors]) + print("\terrors (%d):" % es) + for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): + if v / es < 0.01: # stop showing below 1% of errors. + break + print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) + print("%%%%%%%%%%") + + continue + + if args.force_unsave: + delete_save(args.in_parallel) + + # add to save structure. + succ_traj = succ_traj.append({ + "goal": gtype, + "movable": movable_obj, + "pickup": pickup_obj, + "receptacle": receptacle_obj, + "scene": str(sampled_scene)}, ignore_index=True) + target_remaining -= 1 + tries_remaining += args.trials_before_fail # on success, add more tries for future successes + + # if this combination resulted in a certain number of failures with no successes, flag it as not possible. + if tries_remaining == 0 and target_remaining == args.repeats_per_cond: + new_fails = [(gtype, pickup_obj, movable_obj, receptacle_obj, str(sampled_scene))] + fail_traj = load_fails_from_disk(args.save_path, to_write=new_fails) + print("%%%%%%%%%%") + print("failures (%d)" % len(fail_traj)) + # print("\t" + "\n\t".join([str(ft) for ft in fail_traj])) + print("%%%%%%%%%%") + + # if this combination gave us the repeats we wanted, note it as filled. + if target_remaining == 0: + full_traj.add((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene)) + + # if we're sharing with other processes, reload successes from disk to update local copy with others' additions. + if args.in_parallel: + if n_until_load_successes > 0: + n_until_load_successes -= 1 + else: + print("Reloading trajectories from disk because of parallel processes...") + succ_traj = pd.DataFrame(columns=succ_traj.columns) # Drop all rows. + succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, False, args.repeats_per_cond) + print("... Loaded %d trajectories" % len(succ_traj.index)) + n_until_load_successes = args.async_load_every_n_samples + print_successes(succ_traj) + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, + receptacle_candidates, scene_candidates) + print("... Created fresh instance of sample_task_params generator") + + +def create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, scene_num): + task_id = 'trial_T' + datetime.now().strftime("%Y%m%d_%H%M%S_%f") + save_name = '%s-%s-%s-%s-%d' % (gtype, pickup_obj, movable_obj, receptacle_obj, scene_num) + '/' + task_id + + constants.save_path = os.path.join(constants.DATA_SAVE_PATH, save_name, RAW_IMAGES_FOLDER) + constants.save_depth_path = os.path.join(constants.DATA_SAVE_PATH, save_name, DEPTH_IMAGES_FOLDER) + + if not os.path.exists(constants.save_path): + os.makedirs(constants.save_path) + + if not os.path.exists(constants.save_depth_path): + os.makedirs(constants.save_depth_path) + + print("Saving images to: " + constants.save_path) + return task_id + + +def save_video(): + images_path = constants.save_path + '*.png' + video_path = os.path.join(constants.save_path.replace(RAW_IMAGES_FOLDER, ''), 'video.mp4') + video_saver.save(images_path, video_path) + + +def setup_data_dict(): + constants.data_dict = OrderedDict() + constants.data_dict['task_id'] = "" + constants.data_dict['task_type'] = "" + constants.data_dict['scene'] = {'floor_plan': "", 'random_seed': -1, 'scene_num': -1, 'init_action': [], + 'object_poses': [], 'dirty_and_empty': None, 'object_toggles': []} + constants.data_dict['plan'] = {'high_pddl': [], 'low_actions': []} + constants.data_dict['images'] = [] + constants.data_dict['template'] = {'task_desc': "", 'high_descs': []} + constants.data_dict['pddl_params'] = {'object_target': -1, 'object_sliced': -1, + 'parent_target': -1, 'toggle_target': -1, + 'mrecep_target': -1} + constants.data_dict['dataset_params'] = {'video_frame_rate': -1} + constants.data_dict['pddl_state'] = [] + + +def dump_data_dict(): + data_save_path = constants.save_path.replace(RAW_IMAGES_FOLDER, '') + with open(os.path.join(data_save_path, DATA_JSON_FILENAME), 'w') as fp: + json.dump(constants.data_dict, fp, sort_keys=True, indent=4) + + +def delete_save(in_parallel): + save_folder = constants.save_path.replace(RAW_IMAGES_FOLDER, '') + if os.path.exists(save_folder): + try: + shutil.rmtree(save_folder) + except OSError as e: + if in_parallel: # another thread succeeded at this task while this one failed. + return False + else: + raise e # if we're not running in parallel, this is an actual. + return True + + +def parallel_main(args): + procs = [mp.Process(target=main, args=(args,thread_num)) for thread_num in range(args.num_threads)] + try: + for proc in procs: + proc.start() + time.sleep(0.1) + finally: + for proc in procs: + proc.join() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + # settings + parser.add_argument('--force_unsave', action='store_true', help="don't save any data (for debugging purposes)") + parser.add_argument('--debug', action='store_true') + parser.add_argument('--save_path', type=str, default="dataset/new_trajectories_valid_seen", help="where to save the generated data") + parser.add_argument('--x_display', type=str, required=False, default=constants.X_DISPLAY, help="x_display id") + parser.add_argument("--just_examine", action='store_true', help="just examine what data is gathered; don't gather more") + parser.add_argument("--in_parallel", action='store_true', help="this collection will run in parallel with others, so load from disk on every new sample") + parser.add_argument("-n", "--num_threads", type=int, default=1, help="number of processes for parallel mode") + parser.add_argument('--json_file', type=str, default="", help="path to json file with trajectory dump") + + # params + parser.add_argument("--repeats_per_cond", type=int, default=3) + parser.add_argument("--trials_before_fail", type=int, default=5) + parser.add_argument("--async_load_every_n_samples", type=int, default=10) + parser.add_argument('--gpu_id', type=int, default=0) + + parse_args = parser.parse_args() + + # if parse_args.in_parallel and parse_args.num_threads > 1: + # parallel_main(parse_args) + # else: + main(parse_args) diff --git a/models/main_models/rt1/gen/scripts/replay_checks.py b/models/main_models/rt1/gen/scripts/replay_checks.py new file mode 100644 index 000000000..b0d31e82d --- /dev/null +++ b/models/main_models/rt1/gen/scripts/replay_checks.py @@ -0,0 +1,217 @@ +import os +import sys +# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) +# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) +sys.path.append(os.path.join('/home/jiasenl/code/alfred')) +sys.path.append(os.path.join('/home/jiasenl/code/alfred', 'gen')) + +import argparse +import json +import numpy as np +import shutil +import time +from env.thor_env import ThorEnv +from utils.replay_json import replay_json +import multiprocessing as mp +import time + + +JSON_FILENAME = "traj_data.json" + + +def parallel_replay_check(args): + procs = [mp.Process(target=replay_check, args=(args, thread_num)) for thread_num in range(args.num_threads)] + try: + for proc in procs: + proc.start() + time.sleep(0.1) + finally: + for proc in procs: + proc.join() + +def replay_check(args, thread_num=0): + env = ThorEnv(x_display='0.%d' %(thread_num % args.total_gpu)) + + # replay certificate filenames + replay_certificate_filenames = ["replay.certificate.%d" % idx for idx in range(args.num_replays)] + + # Clear existing failures in file recording. + if args.failure_filename is not None: + with open(args.failure_filename, 'w') as f: + f.write('') + + continue_check = True + total_checks, total_failures, crash_fails, unsat_fails, json_fails, nondet_fails = 0, 0, 0, 0, 0, 0 + errors = {} # map from error strings to counts, to be shown after every failure. + total_threads = args.total_gpu * args.num_threads + current_threads = args.gpu_id * args.num_threads + thread_num + + while continue_check: + + # Crawl the directory of trajectories and vet ones with no certificate. + failure_list = [] + valid_dirs = [] + count = 0 + for dir_name, subdir_list, file_list in os.walk(args.data_path): + if "trial_" in dir_name and (not "raw_images" in dir_name) and (not "pddl_states" in dir_name): + json_file = os.path.join(dir_name, JSON_FILENAME) + if not os.path.isfile(json_file): + continue + + # If we're just stripping certificates, do that and continue. + if args.remove_certificates: + for cidx in range(args.num_replays): + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + if os.path.isfile(certificate_file): + os.system("rm %s" % certificate_file) + continue + + if count % total_threads == current_threads: + valid_dirs.append(dir_name) + count += 1 + + print(len(valid_dirs)) + np.random.shuffle(valid_dirs) + for ii, dir_name in enumerate(valid_dirs): + + if not os.path.exists(dir_name): + continue + + json_file = os.path.join(dir_name, JSON_FILENAME) + if not os.path.isfile(json_file): + continue + + cidx = 0 + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + already_checked = False + while os.path.isfile(certificate_file): + cidx += 1 + if cidx == args.num_replays: + already_checked = True + break + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + if already_checked: + continue + + print(ii) + if not os.path.isfile(certificate_file): + total_checks += 1. / args.num_replays + failed = False + + with open(json_file) as f: + print("check %d/%d for file '%s'" % (cidx + 1, args.num_replays, json_file)) + try: + traj_data = json.load(f) + env.set_task(traj_data, args, reward_type='dense') + except json.decoder.JSONDecodeError: + failed = True + json_fails += 1 + + if not failed: + steps_taken = None + try: + steps_taken = replay_json(env, json_file) + except Exception as e: + import traceback + traceback.print_exc() + failed = True + crash_fails += 1 + + if str(e) not in errors: + errors[str(e)] = 0 + errors[str(e)] += 1 + print("%%%%%%%%%%") + es = sum([errors[er] for er in errors]) + print("\terrors (%d):" % es) + for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): + # if v / es < 0.01: # stop showing below 1% of errors. + # break + print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) + print("%%%%%%%%%%") + + if cidx > 1: + print("WARNING: replay that has succeeded before has failed at attempt %d" + % cidx) + nondet_fails += 1 + + if steps_taken is not None: # executed without crashing, so now we need to verify completion. + goal_satisfied = env.get_goal_satisfied() + + if goal_satisfied: + with open(certificate_file, 'w') as f: + f.write('%d' % steps_taken) + else: + failed = True + unsat_fails += 1 + print("Goal was not satisfied after execution!") + + if failed: + # Mark one failure and count the remainder of checks for this instance into the total. + total_failures += 1 + total_checks += args.num_replays - ((cidx + 1) / float(args.num_replays)) + + failure_list.append(json_file) + if args.failure_filename is not None: + with open(args.failure_filename, 'a') as f: + f.write("%s\n" % json_file) + # If we're deleting bad trajectories, do that here. + if args.move_failed_trajectories is not None: + print("Relocating failed trajectory '%s' to '%s'" % + (dir_name, os.path.join(args.move_failed_trajectories))) + try: + shutil.move(dir_name, args.move_failed_trajectories) + except shutil.Error as e: + print("WARNING: failed to perform move; error follows; deleting instead") + print(repr(e)) + shutil.rmtree(dir_name) + if args.remove_failed_trajectories: + print("Removing failed trajectory '%s'" % dir_name) + shutil.rmtree(dir_name) + + print("-------------------------") + print("Success Rate: %.2f/%.2f = %.3f" % + (total_checks - total_failures, total_checks, + float(total_checks - total_failures) / float(total_checks))) + if total_failures > 0: + print("Non-deterministic failure: %d/%d = %.3f" % (nondet_fails, total_failures, + float(nondet_fails) / total_failures)) + print("Failures by crash: %d/%d = %.3f" % (crash_fails, total_failures, + float(crash_fails) / total_failures)) + print("Failures by unsatisfied: %d/%d = %.3f" % (unsat_fails, total_failures, + float(unsat_fails) / total_failures)) + print("Failures by json decode error: %d/%d = %.3f" % (json_fails, total_failures, + float(json_fails) / total_failures)) + print("-------------------------") + + if not args.in_parallel: + continue_check = False + else: + time.sleep(60) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument('--data_path', type=str, default="dataset/2.1.0", + help="where to look for the generated data") + parser.add_argument("--failure_filename", type=str, required=False, + help="where to write failed trajectory dirs as strings, if anywhere") + parser.add_argument("--remove_failed_trajectories", dest='remove_failed_trajectories', action='store_true', + help="delete trajectory trials if they fail replay") + parser.add_argument("--move_failed_trajectories", type=str, required=False, + help="if given, relocate failed trajectories to this directory") + parser.add_argument("--remove_certificates", dest='remove_certificates', action='store_true', + help="instead of vetting trajectories, remove all vetting certificates") + parser.add_argument("--in_parallel", dest='in_parallel', action='store_true', + help="whether to run this script with parallel generation scripts in mind") + parser.add_argument('--reward_config', default='../models/config/rewards.json') + parser.add_argument('--num_replays', type=int, default=1) + parser.add_argument('--gpu_id', type=int, default=0) + parser.add_argument('--total_gpu', type=int, default=2) + parser.add_argument('--num_threads', type=int, default=2) + args = parser.parse_args() + + if args.num_threads > 1: + parallel_replay_check(args) + else: + replay_check(args) + diff --git a/models/main_models/rt1/gen/utils/__init__.py b/models/main_models/rt1/gen/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/gen/utils/bb_util.py b/models/main_models/rt1/gen/utils/bb_util.py new file mode 100644 index 000000000..46b574b69 --- /dev/null +++ b/models/main_models/rt1/gen/utils/bb_util.py @@ -0,0 +1,139 @@ +import numbers +import numpy as np + +LIMIT = 99999999 + +def clip_bbox(bboxes, min_clip, max_x_clip, max_y_clip): + ''' + # BBoxes are [x1, y1, x2, y2] + ''' + bboxes_out = bboxes + added_axis = False + if len(bboxes_out.shape) == 1: + added_axis = True + bboxes_out = bboxes_out[:, np.newaxis] + bboxes_out[[0, 2], ...] = np.clip(bboxes_out[[0, 2], ...], min_clip, max_x_clip) + bboxes_out[[1, 3], ...] = np.clip(bboxes_out[[1, 3], ...], min_clip, max_y_clip) + if added_axis: + bboxes_out = bboxes_out[:, 0] + return bboxes_out + + +def xyxy_to_xywh(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): + ''' + [x1 y1, x2, y2] to [xMid, yMid, width, height] + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + bboxes_out = np.zeros(bboxes.shape) + x1 = bboxes[0, ...] + y1 = bboxes[1, ...] + x2 = bboxes[2, ...] + y2 = bboxes[3, ...] + bboxes_out[0, ...] = (x1 + x2) / 2.0 + bboxes_out[1, ...] = (y1 + y2) / 2.0 + bboxes_out[2, ...] = x2 - x1 + bboxes_out[3, ...] = y2 - y1 + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if bboxes_out.shape[0] > 4: + bboxes_out[4:, ...] = bboxes[4:, ...] + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def xywh_to_xyxy(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): + ''' + [xMid, yMid, width, height] to [x1 y1, x2, y2] + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + bboxes_out = np.zeros(bboxes.shape) + x_mid = bboxes[0, ...] + y_mid = bboxes[1, ...] + width = bboxes[2, ...] + height = bboxes[3, ...] + bboxes_out[0, ...] = x_mid - width / 2.0 + bboxes_out[1, ...] = y_mid - height / 2.0 + bboxes_out[2, ...] = x_mid + width / 2.0 + bboxes_out[3, ...] = y_mid + height / 2.0 + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if bboxes_out.shape[0] > 4: + bboxes_out[4:, ...] = bboxes[4:, ...] + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def scale_bbox(bboxes, scalars, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False, in_place=False): + ''' + @bboxes {np.array} 4xn array of boxes to be scaled + @scalars{number or arraylike} scalars for width and height of boxes + @in_place{bool} If false, creates new bboxes. + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes, dtype=np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + if isinstance(scalars, numbers.Number): + scalars = np.full((2, bboxes.shape[1]), scalars, dtype=np.float32) + if not isinstance(scalars, np.ndarray): + scalars = np.array(scalars, dtype=np.float32) + if len(scalars.shape) == 1: + scalars = np.tile(scalars[:, np.newaxis], (1, bboxes.shape[1])) + + width = bboxes[2, ...] - bboxes[0, ...] + height = bboxes[3, ...] - bboxes[1, ...] + x_mid = (bboxes[0, ...] + bboxes[2, ...]) / 2.0 + y_mid = (bboxes[1, ...] + bboxes[3, ...]) / 2.0 + if not in_place: + bboxes_out = bboxes.copy() + else: + bboxes_out = bboxes + + bboxes_out[0, ...] = x_mid - width * scalars[0, ...] / 2.0 + bboxes_out[1, ...] = y_mid - height * scalars[1, ...] / 2.0 + bboxes_out[2, ...] = x_mid + width * scalars[0, ...] / 2.0 + bboxes_out[3, ...] = y_mid + height * scalars[1, ...] / 2.0 + + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def make_square(bboxes, in_place=False): + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + num_boxes = 1 + width = bboxes[2] - bboxes[0] + height = bboxes[3] - bboxes[1] + else: + num_boxes = bboxes.shape[1] + width = bboxes[2, ...] - bboxes[0, ...] + height = bboxes[3, ...] - bboxes[1, ...] + max_size = np.maximum(width, height) + scalars = np.zeros((2, num_boxes)) + scalars[0, ...] = max_size * 1.0 / width + scalars[1, ...] = max_size * 1.0 / height + return scale_bbox(bboxes, scalars, in_place=in_place) diff --git a/models/main_models/rt1/gen/utils/dataset_management_util.py b/models/main_models/rt1/gen/utils/dataset_management_util.py new file mode 100644 index 000000000..de13fa535 --- /dev/null +++ b/models/main_models/rt1/gen/utils/dataset_management_util.py @@ -0,0 +1,69 @@ +import os +import shutil + + +def load_successes_from_disk(succ_dir, succ_traj, prune_trials, target_count, + cap_count=None, min_count=None): + tuple_counts = {} + for root, dirs, files in os.walk(succ_dir): + for d in dirs: + if d.count('-') == 4: + goal, pickup, movable, receptacle, scene_num = d.split('-') + # Add an entry for every successful trial folder in the directory. + queue_for_delete = [] + deleted_all = True + for _, _dirs, _ in os.walk(os.path.join(succ_dir, d)): + for _d in _dirs: + for _, _, _files in os.walk(os.path.join(succ_dir, d, _d)): + if 'video.mp4' in _files: + k = (goal, pickup, movable, receptacle, scene_num) + if k not in tuple_counts: + tuple_counts[k] = 0 + tuple_counts[k] += 1 + deleted_all = False + else: + queue_for_delete.append(_d) + break # only examine top level + break # only examine top level + if prune_trials: + if deleted_all: + print("Removing trial-less parent dir '%s'" % os.path.join(succ_dir, d)) + shutil.rmtree(os.path.join(succ_dir, d)) + else: + for _d in queue_for_delete: + print("Removing unfinished trial '%s'" % os.path.join(succ_dir, d, _d)) + shutil.rmtree(os.path.join(succ_dir, d, _d)) + break # only examine top level + + # Populate dataframe based on tuple constraints. + for k in tuple_counts: + if min_count is None or tuple_counts[k] >= min_count: + to_add = tuple_counts[k] if cap_count is None else cap_count + for _ in range(to_add): + succ_traj = succ_traj.append({ + "goal": k[0], + "pickup": k[1], + "movable": k[2], + "receptacle": k[3], + "scene": k[4]}, ignore_index=True) + tuples_at_target_count = set([t for t in tuple_counts if tuple_counts[t] >= target_count]) + + return succ_traj, tuples_at_target_count + + +def load_fails_from_disk(succ_dir, to_write=None): + fail_traj = set() + fail_dir = os.path.join(succ_dir, "fails") + if not os.path.isdir(fail_dir): + os.makedirs(fail_dir) + if to_write is not None: + for goal, pickup, movable, receptacle, scene_num in to_write: + with open(os.path.join(fail_dir, '-'.join([goal, pickup, movable, receptacle, scene_num])), 'w') as f: + f.write("0") + for root, dirs, files in os.walk(fail_dir): + for fn in files: + if fn.count('-') == 4: + goal, pickup, movable, receptacle, scene_num = fn.split('-') + fail_traj.add((goal, pickup, movable, receptacle, scene_num)) + break # only examine top level + return fail_traj diff --git a/models/main_models/rt1/gen/utils/game_util.py b/models/main_models/rt1/gen/utils/game_util.py new file mode 100644 index 000000000..476ef5122 --- /dev/null +++ b/models/main_models/rt1/gen/utils/game_util.py @@ -0,0 +1,363 @@ +import copy +import random +import cv2 +import numpy as np +import constants +import goal_library as glib + + +def get_pose(event): + pose = event.pose + return (int(np.round(pose[0] / (1000 * constants.AGENT_STEP_SIZE))), + int(np.round(pose[1] / (1000 * constants.AGENT_STEP_SIZE))), + int(np.round(pose[2] / (1000 * 90))), + int(np.round(pose[3] / (1000)))) + + +def get_object_data(metadata): + return [ + {"objectName": obj["name"].split("(Clone)")[0], "position": obj["position"], "rotation": obj["rotation"]} + for obj in metadata["objects"] + if obj["pickupable"] + ] + + +def imresize(image, size, rescale=True): + if image is None: + return None + if image.shape[0] != size[0] or image.shape[1] != size[1]: + image = cv2.resize(image, size) + if rescale: + if image.dtype != np.float32: + image = image.astype(np.float32) + image /= 255.0 + return image + + +def depth_imresize(image, size, rescale=True, max_depth=constants.MAX_DEPTH): + if image is None: + return None + if image.shape[0] != size[0] or image.shape[1] != size[1]: + image = cv2.resize(image, size) + image[image > max_depth] = max_depth + if rescale: + if image.dtype != np.float32: + image = image.astype(np.float32) + image /= max_depth + return image + + +def get_camera_matrix(pose, camera_height): + assert(pose[2] in {0, 1, 2, 3}) + sin_x = np.sin(pose[3] * np.pi / 180) + cos_x = np.cos(pose[3] * np.pi / 180) + x_rotation = np.matrix([ + [1, 0, 0], + [0, cos_x, -sin_x], + [0, sin_x, cos_x]]) + sin_y = np.sin(pose[2] * np.pi / 180) + cos_y = np.cos(pose[2] * np.pi / 180) + y_rotation = np.matrix([ + [cos_y, 0, sin_y], + [0, 1, 0], + [-sin_y, 0, cos_y]]) + rotation_matrix = np.matmul(x_rotation, y_rotation) + transformation_matrix = np.matrix([pose[0], camera_height, pose[1], 1]).T + extrinsic_matrix = np.concatenate((np.concatenate((rotation_matrix, np.matrix([0, 0, 0])), axis=0), + transformation_matrix), axis=1) + return extrinsic_matrix + + +def get_rotation_matrix(pose): + assert(pose[2] in {0, 1, 2, 3}), 'rotation was %s' % str(pose[2]) + sin_x = np.sin(-pose[3] * np.pi / 180) + cos_x = np.cos(-pose[3] * np.pi / 180) + x_rotation = np.matrix([ + [1, 0, 0], + [0, cos_x, -sin_x], + [0, sin_x, cos_x]], dtype=np.float32) + sin_y = np.sin((-pose[2] % 4) * 90 * np.pi / 180) + cos_y = np.cos((-pose[2] % 4) * 90 * np.pi / 180) + y_rotation = np.matrix([ + [cos_y, 0, sin_y], + [0, 1, 0], + [-sin_y, 0, cos_y]], dtype=np.float32) + rotation_matrix = np.matmul(x_rotation, y_rotation) + return rotation_matrix + + +def depth_to_world_coordinates(depth, pose, camera_height): + x_points = np.arange(-constants.SCREEN_WIDTH / 2, constants.SCREEN_WIDTH / 2, dtype=depth.dtype) + x_vals = (depth * x_points / constants.FOCAL_LENGTH) + + y_points = np.arange(constants.SCREEN_HEIGHT / 2, -constants.SCREEN_HEIGHT / 2, -1, dtype=depth.dtype) + y_vals = (depth.T * y_points / constants.FOCAL_LENGTH).T + + z_vals = depth + xyz = np.stack((x_vals, y_vals, z_vals), axis=2) / (1000 * constants.AGENT_STEP_SIZE) + rotation_matrix = np.linalg.inv(get_rotation_matrix(pose)) + xyz = np.array(np.dot(rotation_matrix, xyz.reshape(-1, 3).T).T).reshape( + constants.SCREEN_HEIGHT, constants.SCREEN_WIDTH, 3) + xzy = xyz[:, :, [0, 2, 1]] + xzy += np.array([pose[0], pose[1], camera_height]) + return xzy + + +# coordinates should be [n, (xzy)] +def world_to_camera_coordinates(coordinates, pose, camera_height): + coordinates = coordinates.copy() + coordinates -= np.array([pose[0], pose[1], camera_height]) + xyz = coordinates[:, [0, 2, 1]] # [n, (xyz)] + rotation_matrix = get_rotation_matrix(pose) + xyd = np.array(np.dot(rotation_matrix, xyz.T).T) + xyd *= (1000 * constants.AGENT_STEP_SIZE) + depth = np.maximum(xyd[:, -1], 0.01) + x_points = xyd[:, 0] * constants.FOCAL_LENGTH / depth + constants.SCREEN_WIDTH / 2 + y_points = constants.SCREEN_HEIGHT - (xyd[:, 1] * constants.FOCAL_LENGTH / depth + constants.SCREEN_HEIGHT / 2) + return np.stack((x_points, y_points, depth)).T + + +def get_templated_action_str(plan, idx=0): + action = copy.deepcopy(plan[idx]) + object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) + + a_type = action['action'] + templated_str = "" + + if 'GotoLocation' in a_type: + templated_str = "go to the %s" % (next_recep_name if next_recep_name != "" else prev_object_name) + elif 'OpenObject' in a_type: + templated_str = "open the %s" % (object_name) + elif 'CloseObject' in a_type: + templated_str = "close the %s" % (object_name) + elif 'PickupObject' in a_type: + templated_str = "pick up the %s" % (object_name) + elif 'PutObject' in a_type: + templated_str = "put the %s in the %s" % (object_name, recep_name) + elif 'CleanObject' in a_type: + templated_str = "wash the %s" % (prev_object_name) + elif 'HeatObject' in a_type: + templated_str = "heat the %s" % (prev_object_name) + elif 'CoolObject' in a_type: + templated_str = "cool the %s" % (prev_object_name) + elif 'ToggleObject' in a_type: + templated_str = "toggle %s" % (object_name) + elif 'SliceObject' in a_type: + templated_str = "slice the %s" % (object_name) + elif 'End' in a_type: + templated_str = "<>" + + return templated_str + + +def get_discrete_hl_action(plan, idx=0): + action = copy.deepcopy(plan[idx]) + object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) + + a_type = action['action'] + discrete_action = {'action': "", 'args': []} + + if 'GotoLocation' in a_type: + discrete_action['action'] = "GotoLocation" + discrete_action['args'] = [next_recep_name if next_recep_name != "" else next_object_name] + elif 'OpenObject' in a_type: + discrete_action['action'] = "OpenObject" + discrete_action['args'] = [object_name] + elif 'CloseObject' in a_type: + discrete_action['action'] = "CloseObject" + discrete_action['args'] = [object_name] + elif 'PickupObject' in a_type: + discrete_action['action'] = "PickupObject" + discrete_action['args'] = [object_name] + elif 'PutObject' in a_type: + discrete_action['action'] = "PutObject" + discrete_action['args'] = [object_name, recep_name] + elif 'CleanObject' in a_type: + discrete_action['action'] = "CleanObject" + discrete_action['args'] = [prev_object_name] + elif 'HeatObject' in a_type: + discrete_action['action'] = "HeatObject" + discrete_action['args'] = [prev_object_name] + elif 'CoolObject' in a_type: + discrete_action['action'] = "CoolObject" + discrete_action['args'] = [prev_object_name] + elif 'ToggleObject' in a_type: + discrete_action['action'] = "ToggleObject" + discrete_action['args'] = [object_name] + elif 'SliceObject' in a_type: + discrete_action['action'] = "SliceObject" + discrete_action['args'] = [object_name] + else: + discrete_action['action'] = "NoOp" + discrete_action['args'] = [] + + return discrete_action + + +def object_id_to_name(object_id): + return object_id.split('|')[0] + + +def get_relevant_objs(action, plan, idx=0): + object_name = object_id_to_name(action['objectId']).lower() if 'objectId' in action else "" + recep_name = object_id_to_name(action['receptacleObjectId']).lower() if 'receptacleObjectId' in action else "" + prev_object_name, prev_recep_name = "", "" + next_object_name, next_recep_name = "", "" + + prev_idx = idx - 2 + if prev_idx >= 0: + prev_action = copy.deepcopy(plan[prev_idx]) + prev_object_name = object_id_to_name(prev_action['objectId']).lower() if 'objectId' in prev_action else "" + prev_recep_name = object_id_to_name(prev_action['receptacleObjectId']).lower() if 'receptacleObjectId' in prev_action else "" + + next_idx = idx + 1 + if next_idx < len(plan): + next_action = copy.deepcopy(plan[next_idx]) + next_object_name = object_id_to_name(next_action['objectId']).lower() if 'objectId' in next_action else "" + next_recep_name = object_id_to_name(next_action['receptacleObjectId']).lower() if 'receptacleObjectId' in next_action else "" + + return object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name + + +def get_action_str(action): + action = copy.deepcopy(action) + a_type = action['action'] + action_str = 'Action: ' + a_type + del action['action'] + + if 'Teleport' in a_type: + action_str = a_type + if 'x' in action: + action_str += ' x: %.03f' % action['x'] + del action['x'] + if 'y' in action: + action_str += ' y: %.03f' % action['y'] + del action['y'] + if 'z' in action: + action_str += ' z: %.03f' % action['z'] + del action['z'] + if 'rotation' in action and action.get('rotateOnTeleport', False): + if type(action['rotation']) == dict: + action_str += ' r: %d' % int(action['rotation']['y']) + else: + action_str += ' r: %d' % int(action['rotation']) + del action['rotation'] + del action['rotateOnTeleport'] + if 'horizon' in action: + action_str += ' h: %d' % int(action['horizon']) + del action['horizon'] + elif 'Goto' in a_type: + action_str = a_type + if 'location' in action: + action_str += ' loc: %s' % action['location'] + del action['location'] + elif a_type in {'OpenObject', 'CloseObject', 'PickupObject', 'ToggleObject', 'SliceObject'}: + if 'objectId' not in action: + action['objectId'] = 'None' + action_str = '%s %s' % (a_type, action['objectId']) + elif a_type in {'RotateByDegree', 'LookByDegree'}: + if type(action['rotation']) == dict: + action_str += ' r: %d' % int(action['rotation']['y']) + else: + action_str += ' r: %d' % int(action['rotation']) + action_str = '%s %d' % (a_type, action['rotation']['y']) + del action['rotation'] + elif a_type == 'PutObject': + action_str = a_type + if 'objectId' in action: + action_str += ' o: %s' % action['objectId'] + del action['objectId'] + if 'receptacleObjectId' in action: + action_str += ' r: %s' % action['receptacleObjectId'] + del action['receptacleObjectId'] + + if len(action) > 0: + action_str += '\tFull: ' + str(action) + return action_str + + +def get_object(object_id, metadata): + for obj in metadata['objects']: + if obj['objectId'] == object_id: + return obj + return None + + +def get_object_dict(metadata): + return {obj['objectId']: obj for obj in metadata['objects']} + + +def get_objects_of_type(object_type, metadata): + return [obj for obj in metadata['objects'] if obj['objectType'] == object_type] + + +def get_obj_of_type_closest_to_obj(object_type, ref_object_id, metadata): + objs_of_type = [obj for obj in metadata['objects'] if obj['objectType'] == object_type and obj['visible']] + ref_obj = get_object(ref_object_id, metadata) + closest_objs_of_type = sorted(objs_of_type, key=lambda o: np.linalg.norm(np.array([o['position']['x'], o['position']['y'], o['position']['z']]) - \ + np.array([ref_obj['position']['x'], ref_obj['position']['y'], ref_obj['position']['z']]))) + if len(closest_objs_of_type) == 0: + raise Exception("No closest %s found!" % (ref_obj)) + return closest_objs_of_type[0] # retrun the first closest visible object + + +def get_objects_with_name_and_prop(name, prop, metadata): + return [obj for obj in metadata['objects'] + if name in obj['objectId'] and obj[prop]] + + +def get_visible_objs(objs): + return [obj for obj in objs if obj['visible']] + + +def get_object_bounds(obj, scene_bounds): + # obj_bounds = np.array(obj['bounds3D'])[[0, 2, 3, 5]] # Get X and Z out + # Get a 'box' that is a singular point in (x,z) based on object position in place of now-unavailable 'bounds3d' + obj_bounds = np.array([obj['position']['x'], obj['position']['z'], obj['position']['x'], obj['position']['z']]) + obj_bounds /= constants.AGENT_STEP_SIZE + obj_bounds = np.round(obj_bounds).astype(np.int32) + obj_bounds[[2, 3]] = np.maximum(obj_bounds[[2, 3]], obj_bounds[[0, 1]] + 1) + obj_bounds[[0, 2]] = np.clip(obj_bounds[[0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) + obj_bounds[[1, 3]] = np.clip(obj_bounds[[1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) + obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] + return obj_bounds + + +def get_object_bounds_batch(boxes, scene_bounds): + obj_bounds = boxes[:, [0, 2, 3, 5]] # Get X and Z out + obj_bounds /= constants.AGENT_STEP_SIZE + obj_bounds = np.round(obj_bounds).astype(np.int32) + obj_bounds[:, [2, 3]] = np.maximum(obj_bounds[:, [2, 3]], obj_bounds[:, [0, 1]] + 1) + obj_bounds[:, [0, 2]] = np.clip(obj_bounds[:, [0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) + obj_bounds[:, [1, 3]] = np.clip(obj_bounds[:, [1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) + obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] + return obj_bounds + + +def get_task_str(object_ind, receptacle_ind=None, toggle_ind=None, mrecep_ind=None): + goal_str = constants.pddl_goal_type + if constants.data_dict['pddl_params']['object_sliced']: + goal_str += "_slice" + template = random.choice(glib.gdict[goal_str]['templates']) + obj = constants.OBJECTS[object_ind].lower() if object_ind is not None else "" + recep = constants.OBJECTS[receptacle_ind].lower() if receptacle_ind is not None else "" + tog = constants.OBJECTS[toggle_ind].lower() if toggle_ind is not None else "" + mrecep = constants.OBJECTS[mrecep_ind].lower() if mrecep_ind is not None else "" + filled_in_str = template.format(obj=obj, recep=recep, toggle=tog, mrecep=mrecep) + return filled_in_str + + +def get_last_hl_action_index(): + return len(constants.data_dict['plan']['high_pddl']) - 1 + + +def get_last_ll_action_index(): + return len(constants.data_dict['plan']['low_actions']) - 1 + + +def store_image_name(name): + constants.data_dict['images'].append({"high_idx": get_last_hl_action_index(), + "low_idx": get_last_ll_action_index(), + "image_name": name}) + + diff --git a/models/main_models/rt1/gen/utils/image_util.py b/models/main_models/rt1/gen/utils/image_util.py new file mode 100644 index 000000000..157812a2f --- /dev/null +++ b/models/main_models/rt1/gen/utils/image_util.py @@ -0,0 +1,57 @@ +import numpy as np +import gen.constants as constants + +def bbox_to_mask(bbox): + ''' + bbox to rectangle pixelwise mask + ''' + x1, y1, x2, y2 = bbox + mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) + mask[y1:y2, x1:x2] = 1 + return mask + + +def point_to_mask(point): + ''' + single point to dense pixelwise mask + ''' + x, y = point + mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) + mask[y, x] = 1 + return mask + + +def decompress_mask(compressed_mask): + ''' + decompress compressed mask array + ''' + mask = np.zeros((constants.DETECTION_SCREEN_WIDTH, constants.DETECTION_SCREEN_HEIGHT)) + for start_idx, run_len in compressed_mask: + for idx in range(start_idx, start_idx + run_len): + mask[idx // constants.DETECTION_SCREEN_WIDTH, idx % constants.DETECTION_SCREEN_HEIGHT] = 1 + return mask + + +def compress_mask(seg_mask): + ''' + compress mask array + ''' + run_len_compressed = [] # list of lists of run lengths for 1s, which are assumed to be less frequent. + idx = 0 + curr_run = False + run_len = 0 + for x_idx in range(len(seg_mask)): + for y_idx in range(len(seg_mask[x_idx])): + if seg_mask[x_idx][y_idx] == 1 and not curr_run: + curr_run = True + run_len_compressed.append([idx, None]) + if seg_mask[x_idx][y_idx] == 0 and curr_run: + curr_run = False + run_len_compressed[-1][1] = run_len + run_len = 0 + if curr_run: + run_len += 1 + idx += 1 + if curr_run: + run_len_compressed[-1][1] = run_len + return run_len_compressed \ No newline at end of file diff --git a/models/main_models/rt1/gen/utils/py_util.py b/models/main_models/rt1/gen/utils/py_util.py new file mode 100644 index 000000000..7a357f039 --- /dev/null +++ b/models/main_models/rt1/gen/utils/py_util.py @@ -0,0 +1,84 @@ +import random +import re +import time +import os +import string + + +def get_time_str(): + tt = time.localtime() + time_str = ('%04d_%02d_%02d_%02d_%02d_%02d' % + (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec)) + return time_str + + +def encode(string, encoding='utf-8'): + return string.encode(encoding) + + +def decode(string, encoding='utf-8'): + return string.decode(encoding) + + +def multireplace(string, replacements): + """ + Given a string and a replacement map, it returns the replaced string. + :param str string: string to execute replacements on + :param dict replacements: replacement dictionary {value to find: value to replace} + :rtype: str + Source https://gist.github.com/bgusach/a967e0587d6e01e889fd1d776c5f3729 + """ + # Place longer ones first to keep shorter substrings from matching where the longer ones should take place + # For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against the string 'hey abc', it should produce + # 'hey ABC' and not 'hey ABc' + substrs = sorted(replacements, key=len, reverse=True) + + # Create a big OR regex that matches any of the substrings to replace + regexp = re.compile('|'.join(map(re.escape, substrs))) + + # For each match, look up the new string in the replacements + return regexp.sub(lambda match: replacements[match.group(0)], string) + + +class SetWithGet(set): + def get_any(self): + return random.sample(self, 1)[0] + + def __getitem__(self, item): + return self.get_any() + + +class Noop(object): + def noop(*args, **kw): + pass + + def __getattr__(self, _): + return self.noop + + +def walklevel(some_dir, level=1): + some_dir = some_dir.rstrip(os.path.sep) + assert os.path.isdir(some_dir) + num_sep = some_dir.count(os.path.sep) + for root, dirs, files in os.walk(some_dir): + yield root, dirs, files + num_sep_this = root.count(os.path.sep) + if num_sep + level <= num_sep_this: + del dirs[:] + + +def remove_spaces(s): + cs = ' '.join(s.split()) + return cs + + +def remove_spaces_and_lower(s): + cs = remove_spaces(s) + cs = cs.lower() + return cs + + +def remove_punctuation(s): + cs = s.translate(str.maketrans('', '', string.punctuation)) + cs = remove_spaces_and_lower(cs) + return cs \ No newline at end of file diff --git a/models/main_models/rt1/gen/utils/replay_json.py b/models/main_models/rt1/gen/utils/replay_json.py new file mode 100644 index 000000000..96949414c --- /dev/null +++ b/models/main_models/rt1/gen/utils/replay_json.py @@ -0,0 +1,52 @@ +import json + +def replay_json(env, json_file): + # load json data + with open(json_file) as f: + traj_data = json.load(f) + + # setup + scene_num = traj_data['scene']['scene_num'] + object_poses = traj_data['scene']['object_poses'] + dirty_and_empty = traj_data['scene']['dirty_and_empty'] + object_toggles = traj_data['scene']['object_toggles'] + + scene_name = 'FloorPlan%d' % scene_num + env.reset(scene_name) + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + + # initialize + event = env.step(dict(traj_data['scene']['init_action'])) + # print("Task: %s" % (traj_data['template']['task_desc'])) + + steps_taken = 0 + for ll_action in traj_data['plan']['low_actions']: + hl_action_idx, traj_api_cmd, traj_discrete_action = \ + ll_action['high_idx'], ll_action['api_action'], ll_action['discrete_action'] + + # print templated low-level instructions & discrete action + # print("HL Templ: %s, LL Cmd: %s" % (traj_data['template']['high_descs'][hl_action_idx], + # traj_discrete_action['action'])) + + # Use the va_interact that modelers will have to use at inference time. + action_name, action_args = traj_discrete_action['action'], traj_discrete_action['args'] + + # three ways to specify object of interest mask + # 1. create a rectangular mask from bbox + # mask = env.bbox_to_mask(action_args['bbox']) if 'bbox' in action_args else None # some commands don't require any arguments + # 2. create a point mask from bbox + # mask = env.point_to_mask(action_args['point']) if 'point' in action_args else None + # 3. use full pixel-wise segmentation mask + compressed_mask = action_args['mask'] if 'mask' in action_args else None + if compressed_mask is not None: + mask = env.decompress_mask(compressed_mask) + else: + mask = None + + success, event, target_instance_id, err, _ = env.va_interact(action_name, interact_mask=mask) + if not success: + raise RuntimeError(err) + + steps_taken += 1 + + return steps_taken diff --git a/models/main_models/rt1/gen/utils/video_util.py b/models/main_models/rt1/gen/utils/video_util.py new file mode 100644 index 000000000..4c21b8a3a --- /dev/null +++ b/models/main_models/rt1/gen/utils/video_util.py @@ -0,0 +1,11 @@ +import subprocess +import constants + +class VideoSaver(object): + + def __init__(self, frame_rate=constants.VIDEO_FRAME_RATE): + self.frame_rate = frame_rate + + def save(self, image_path, save_path): + subprocess.call(["ffmpeg -r %d -pattern_type glob -y -i '%s' -c:v libx264 -pix_fmt yuv420p '%s'" % + (self.frame_rate, image_path, save_path)], shell=True) \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/attribute_limits.json b/models/main_models/rt1/lanmp_dataloader/attribute_limits.json new file mode 100644 index 000000000..0fdbbed9a --- /dev/null +++ b/models/main_models/rt1/lanmp_dataloader/attribute_limits.json @@ -0,0 +1 @@ +[{"min_x": -0.40000009536743164, "max_x": 0.40000009536743164, "min_y": 0, "max_y": 0, "min_z": -0.40000009536743164, "max_z": 0.40000009536743164}, {"min_yaw": -347.422251701355, "max_yaw": 358.85895166755654}, {"min_x": -1.146158218383789, "max_x": 0.6427476406097412, "min_y": -0.533308207988739, "max_y": 0.8237500190734863, "min_z": -0.5759885311126709, "max_z": 1.0145864486694336}] \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py b/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py new file mode 100644 index 000000000..7d574597a --- /dev/null +++ b/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py @@ -0,0 +1,800 @@ +import os +import sys + +import torch +from torchvision.io import read_image +from torch.utils.data import Dataset +from torch.utils.data import DataLoader +import h5py +from PIL import Image +from tqdm import tqdm +# from models.utils.data_utils import split_data +import pdb +#mainly for debugging +import matplotlib.pyplot as plt +import numpy as np +import re +import json +import sys +from copy import copy +import random + +sys.path.append('..') + +DATASET_PATH = '/oscar/data/stellex/shared/lanmp/sim_dataset.hdf5' + +''' +train_keys, val_keys, test_keys = split_data(self.args.data, splits['train'], splits['val'], splits['test']) +''' + +def split_data(hdf5_path, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1): + with h5py.File(hdf5_path, 'r') as hdf_file: + # Assuming trajectories or data units are top-level groups in the HDF5 file + keys = list(hdf_file.keys()) + total_items = len(keys) + + # Generate a shuffled array of indices + indices = np.arange(total_items) + np.random.shuffle(indices) + + # Calculate split sizes + train_end = int(train_ratio * total_items) + val_end = train_end + int(val_ratio * total_items) + + # Split the indices + train_indices = indices[:train_end] + val_indices = indices[train_end:val_end] + test_indices = indices[val_end:] + + # Convert indices back to keys (assuming order in keys list is stable and matches original order) + train_keys = [keys[i] for i in train_indices] + val_keys = [keys[i] for i in val_indices] + test_keys = [keys[i] for i in test_indices] + + return train_keys, val_keys, test_keys + +def split_by_scene(hdf5_path): + + #mapping which keys are relevant to specific scenes + scene_to_keys = {} + + with h5py.File(hdf5_path, 'r') as hdf_file: + + keys = list(hdf_file.keys()) + + for k in keys: + traj_json_dict = json.loads(hdf_file[k]['folder_0'].attrs['metadata']) + + if traj_json_dict['scene'] not in scene_to_keys: + scene_to_keys[traj_json_dict['scene']] = [] + + scene_to_keys[traj_json_dict['scene']].append(k) + + for k in scene_to_keys.keys(): + scene_to_keys[k] = list(sorted(scene_to_keys[k])) + + with open('./lanmp_dataloader/scene_to_keys.json', 'w') as f: + json.dump(scene_to_keys, f) + + return scene_to_keys + + + +def sort_folders(test_string): + return list(map(int, re.findall(r'\d+', test_string)))[0] + +class DatasetManager(object): + + ''' + NOTE: kwargs should contain a dictionary with keys {'train_split' : x, 'val_split': y, 'test_split':z} where x+y+z = 1 + ''' + def __init__(self, val_scene=1, train_split=0.8, val_split=0.1, test_split=0.1, split_style='task_split', diversity_scenes=1, max_trajectories=100): + + assert( train_split + val_split + test_split == 1.0, 'Error: train, val and test split do not sum to 1.0') + + + #train_keys, val_keys, test_keys = split_data(DATASET_PATH, train_split, val_split, test_split) + if 'scene_to_keys.json' not in os.listdir('./lanmp_dataloader'): + self.scene_to_keys = split_by_scene(DATASET_PATH) + else: + with open('./lanmp_dataloader/scene_to_keys.json') as f: + self.scene_to_keys = json.load(f) + + + self.scenes = list(sorted(list(self.scene_to_keys.keys()))) + + assert( split_style in ['k_fold_scene', 'task_split', 'diversity_ablation'], "Error: input split_style is invalid") + + if split_style == 'k_fold_scene': + assert( val_scene < len(self.scenes), "Error: input scene is out of index space") + train_keys = [] + for x in range(0, len(self.scenes)): + if x!=val_scene: + train_keys += self.scene_to_keys[self.scenes[x]] + + val_keys = self.scene_to_keys[self.scenes[val_scene]] + test_keys = None + + elif split_style == 'task_split': + + train_keys = [] + val_keys = [] + + for scene in self.scenes: + + scene_keys = copy(self.scene_to_keys[scene]) + random.shuffle(scene_keys) + + + split_idx = int(len(scene_keys)*(train_split + 0.5*val_split)) + + train_keys += scene_keys[:split_idx] + val_keys += scene_keys[split_idx:] + + print('Train Perc: ', len(train_keys) / (len(train_keys) + len(val_keys))) + + val_keys = ['data_13:02:17', 'data_19:58:40', 'data_15:50:55', 'data_16:22:44', 'data_15:40:22', 'data_17:08:14', 'data_15:37:13', 'data_18:38:30', 'data_13:56:07', 'data_15:22:59', 'data_13:33:54', 'data_13:18:11', 'data_19:36:17', 'data_14:38:16', 'data_13:04:13', 'data_12:04:43', 'data_16:37:57', 'data_15:38:38', 'data_16:40:44', 'data_17:59:00', 'data_20:57:07', 'data_16:03:52', 'data_16:40:36', 'data_19:31:51', 'data_16:45:24', 'data_21:09:57', 'data_17:26:17', 'data_15:01:27', 'data_14:02:16', 'data_13:29:09', 'data_14:22:29', 'data_16:43:00', 'data_13:46:04', 'data_15:13:04', 'data_16:45:58', 'data_13:33:29', 'data_17:17:50', 'data_11:19:28', 'data_17:45:27', 'data_16:00:55', 'data_15:03:19', 'data_16:06:05', 'data_16:02:46', 'data_17:41:00', 'data_17:35:45', 'data_14:05:06', 'data_18:22:47', 'data_17:02:46', 'data_15:08:23', 'data_16:15:15', 'data_19:00:23', 'data_11:50:57', 'data_15:19:33', 'data_14:52:27', 'data_16:58:53', 'data_11:44:50', 'data_16:10:21', 'data_13:10:05', 'data_17:48:24', 'data_18:09:10', 'data_18:01:35', 'data_13:34:59', 'data_12:48:23', 'data_22:17:48', 'data_16:57:05', 'data_16:49:20', 'data_17:51:34', 'data_12:54:21', 'data_16:23:48', 'data_14:24:32', 'data_16:18:35', 'data_14:26:22', 'data_16:11:06', 'data_11:58:17', 'data_17:13:00', 'data_19:34:02', 'data_13:29:42', 'data_17:20:01', 'data_15:20:09', 'data_16:53:34', 'data_15:25:56'] + + print('Train Keys: ', len(train_keys)) + print('Validation Keys: ', len(val_keys)) + print('Validation Keys: ', val_keys) + + elif split_style == 'diversity_ablation': + + assert(diversity_scenes < len(self.scene_to_keys.keys()), "Error: number of train scenes for diversity ablations cannot be {}".format(len(self.scene_to_keys.keys()))) + + ordered_scenes = []; ordered_trajs = [] + + for scene, traj in self.scene_to_keys.items(): + + ordered_scenes.append(scene) + ordered_trajs.append(len(traj)) + + + ordered_index = sorted(range(0, len(ordered_trajs)), key = lambda x: ordered_trajs[x]) + + ordered_trajs = list(sorted(ordered_trajs)) + ordered_scenes = [ordered_scenes[i] for i in ordered_index] + + print('EVAL SCENE: {} has {} trajectories'.format(ordered_scenes[-1], ordered_trajs[-1])) + val_keys = self.scene_to_keys[ordered_scenes[-1]] + other_scenes = list(reversed(ordered_scenes[:-1])) + other_trajs = list(reversed(ordered_trajs[:-1])) + + + num_per_scene = int(max_trajectories/diversity_scenes) + train_keys = [] + + for i in range(diversity_scenes): + train_keys += random.sample(self.scene_to_keys[other_scenes[i]], num_per_scene) + + if len(train_keys) < max_trajectories: + + random_scene = random.sample(other_scenes[:diversity_scenes], 1)[0] + train_keys += random.sample(self.scene_to_keys[random_scene], max_trajectories-len(train_keys)) + + + if 'attribute_limits.json' not in os.listdir('./lanmp_dataloader'): + body_pose_lim, body_orientation_lim, end_effector_pose_lim = self.determine_min_max_range([train_keys, val_keys, test_keys]) + else: + + with open('./lanmp_dataloader/attribute_limits.json') as f: + attribute_limits = json.load(f) + body_pose_lim, body_orientation_lim, end_effector_pose_lim = attribute_limits[0], attribute_limits[1], attribute_limits[2] + + self.train_dataset = RT1Dataset(train_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + self.val_dataset = RT1Dataset(val_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + # self.test_dataset = RT1Dataset(test_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + + def determine_min_max_range(self, data_subset_keys): + + body_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z':float('-inf')} + body_orientation = {'min_yaw': float('inf'), 'max_yaw': float('-inf')} + end_effector_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z': float('-inf')} + + + + + with h5py.File(DATASET_PATH, 'r') as hdf: + for dataset_keys in data_subset_keys: + + if dataset_keys is None: + continue + + + for i in range(len(dataset_keys)): + prev_body_x = None + prev_body_y = None + prev_body_z = None + prev_body_yaw = None + prev_ee_x = None + prev_ee_y = None + prev_ee_z = None + + print('Index: {} of {}'.format(i, len(dataset_keys))) + traj_group = hdf[dataset_keys[i]] + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + for j in range(len(traj_steps)): + + step_metadata = json.loads(traj_group[traj_steps[j]].attrs['metadata']) + + body_x = step_metadata['steps'][0]['state_body'][0] + body_y = step_metadata['steps'][0]['state_body'][1] + body_z = step_metadata['steps'][0]['state_body'][2] + + body_yaw = step_metadata['steps'][0]['state_body'][3] + + + ee_x = step_metadata['steps'][0]['state_ee'][0] + ee_y = step_metadata['steps'][0]['state_ee'][1] + ee_z = step_metadata['steps'][0]['state_ee'][2] + + + + body_pose['min_x'] = min(body_pose['min_x'], body_x - prev_body_x if prev_body_x is not None else 0) + body_pose['max_x'] = max(body_pose['max_x'], body_x - prev_body_x if prev_body_x is not None else 0) + + body_pose['min_y'] = min(body_pose['min_y'], body_y - prev_body_y if prev_body_y is not None else 0) + body_pose['max_y'] = max(body_pose['max_y'], body_y - prev_body_y if prev_body_y is not None else 0) + + body_pose['min_z'] = min(body_pose['min_z'], body_z - prev_body_z if prev_body_z is not None else 0) + body_pose['max_z'] = max(body_pose['max_z'], body_z - prev_body_z if prev_body_z is not None else 0) + + body_orientation['min_yaw'] = min(body_orientation['min_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) + body_orientation['max_yaw'] = max(body_orientation['max_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) + + end_effector_pose['min_x'] = min(end_effector_pose['min_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) + end_effector_pose['max_x'] = max(end_effector_pose['max_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) + + end_effector_pose['min_y'] = min(end_effector_pose['min_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) + end_effector_pose['max_y'] = max(end_effector_pose['max_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) + + end_effector_pose['min_z'] = min(end_effector_pose['min_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) + end_effector_pose['max_z'] = max(end_effector_pose['max_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) + + + prev_body_x = body_x + prev_body_y = body_y + prev_body_z = body_z + prev_body_yaw = body_yaw + prev_ee_x = ee_x + prev_ee_y = ee_y + prev_ee_z = ee_z + + + + #cache the saved max and min values if already computed to save time + attribute_limits = [body_pose, body_orientation, end_effector_pose] + with open('./lanmp_dataloader/attribute_limits.json', 'w') as f: + json.dump(attribute_limits, f) + + + return body_pose, body_orientation, end_effector_pose + + def collate_batches(self, batch, shuffle_batch = False): + + + collated_batch = [] + + # merging batch elements with variable length + for out in range(len(batch[0])): + collated_output = [] + for idx in range(len(batch)): + if batch[idx][out].dtype.type == np.str_: + collated_output.append(batch[idx][out]) + else: + collated_output.append(torch.from_numpy(batch[idx][out])) + + if batch[idx][out].dtype.type!=np.str_: + collated_output = torch.cat(collated_output, dim=0) + else: + + collated_output = np.concatenate(collated_output, axis=0) + + collated_batch.append(collated_output) + + #shuffling all the batched samples across the trajectories to get random order + if shuffle_batch: + permutation = torch.randperm(collated_batch[0].size(0)) + + for i in range(len(collated_batch)): + collated_batch[i] = collated_batch[i][permutation] + + return collated_batch + + + + + + + + + +class RT1Dataset(Dataset): + + + + def __init__(self, data_split_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim, tokenize_action=True): + + #stores the keys in the dataset for the appropriate split (train, validation or test) + self.dataset_keys = data_split_keys + self.body_pose_lim = body_pose_lim + self.body_orientation_lim = body_orientation_lim + self.end_effector_pose_lim = end_effector_pose_lim + self.num_bins = 254 + + self.tokenize_action = tokenize_action + + self.hdf = h5py.File(DATASET_PATH, 'r') + + def __len__(self): + return len(self.dataset_keys) + + + def make_data_discrete(self, dictionary): + + + + #body x, y, z coordinate + dictionary['body_position_deltas'][:,0] = 1 + (dictionary['body_position_deltas'][:,0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins + dictionary['body_position_deltas'][:,0] = dictionary['body_position_deltas'][:,0].astype(int) + + if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0: + dictionary['body_position_deltas'][:,1] = 1 + (dictionary['body_position_deltas'][:,1] - self.body_pose_lim['min_y'])/(self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins + else: + dictionary['body_position_deltas'][:,1].fill(0) + dictionary['body_position_deltas'][:,1] = dictionary['body_position_deltas'][:,1].astype(int) + + dictionary['body_position_deltas'][:,2] = 1 + (dictionary['body_position_deltas'][:,2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins + dictionary['body_position_deltas'][:,2] = dictionary['body_position_deltas'][:,2].astype(int) + + #body yaw and pitch + dictionary['body_yaw_deltas'] = 1 + (dictionary['body_yaw_deltas'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins + dictionary['body_yaw_deltas'] = dictionary['body_yaw_deltas'].astype(int) + + #end effector x, y, z coordinate + dictionary['arm_position_deltas'][:,0] = 1 + (dictionary['arm_position_deltas'][:,0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins + dictionary['arm_position_deltas'][:,0] = dictionary['arm_position_deltas'][:,0].astype(int) + + dictionary['arm_position_deltas'][:,1] = 1 + (dictionary['arm_position_deltas'][:,1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins + dictionary['arm_position_deltas'][:,1] = dictionary['arm_position_deltas'][:,1].astype(int) + + dictionary['arm_position_deltas'][:,2] = 1 + (dictionary['arm_position_deltas'][:,2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins + dictionary['arm_position_deltas'][:,2] = dictionary['arm_position_deltas'][:,2].astype(int) + + #find if and where episode terminates so you can fill those entries with 0s + if 1.0 in dictionary['terminate_episode']: + terminate_idx = np.where(np.array(dictionary['terminate_episode'])>0)[0][0] + + dictionary['body_position_deltas'][terminate_idx:,:].fill(0) + dictionary['body_yaw_deltas'][terminate_idx:].fill(0) + dictionary['arm_position_deltas'][terminate_idx:,:].fill(0) + + + return dictionary + + + def detokenize_continuous_data(self, dictionary): + + if dictionary['curr_mode'] == 'stop': + dictionary['body_position_delta'] = [[0.0, 0.0, 0.0]] + dictionary['body_yaw_delta'] = [[0.0]] + dictionary['arm_position_deltas'] = [[0.0, 0.0, 0.0]] + + else: + dictionary['body_position_delta'][0][0] = (dictionary['body_position_delta'][0][0] - 1) * (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x']) / self.num_bins + self.body_pose_lim['min_x'] + dictionary['body_position_delta'][0][1] = (dictionary['body_position_delta'][0][1] - 1) * (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y']) / self.num_bins + self.body_pose_lim['min_y'] + dictionary['body_position_delta'][0][2] = (dictionary['body_position_delta'][0][2] - 1) * (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z']) / self.num_bins + self.body_pose_lim['min_z'] + + dictionary['body_yaw_delta'][0][0] = (dictionary['body_yaw_delta'][0][0] - 1) * (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) / self.num_bins + self.body_orientation_lim['min_yaw'] + + + dictionary['arm_position_delta'][0][0] = (dictionary['arm_position_delta'][0][0] - 1) * (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x']) / self.num_bins + self.end_effector_pose_lim['min_x'] + dictionary['arm_position_delta'][0][1] = (dictionary['arm_position_delta'][0][1] - 1) * (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y']) / self.num_bins + self.end_effector_pose_lim['min_y'] + dictionary['arm_position_delta'][0][2] = (dictionary['arm_position_delta'][0][2] - 1) * (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z']) / self.num_bins + self.end_effector_pose_lim['min_z'] + return dictionary + + + def make_data_discrete_old(self, dictionary): + + if not bool(dictionary['is_terminal']): + + #body x, y, z coordinate + dictionary['body_position'][0] = 1 + int( (dictionary['body_position'][0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins) + + dictionary['body_position'][1] = 1 + int( (dictionary['body_position'][1] - self.body_pose_lim['min_y'])/ (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins) if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0 else 0 + + dictionary['body_position'][2] = 1 + int( (dictionary['body_position'][2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins) + + #body yaw and pitch + dictionary['body_yaw'] = 1 + int( (dictionary['body_yaw'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins) + + #end effector x, y, z coordinate + dictionary['arm_position'][0] = 1 + int( (dictionary['arm_position'][0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins) + dictionary['arm_position'][1] = 1 + int( (dictionary['arm_position'][1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins) + dictionary['arm_position'][2] = 1 + int( (dictionary['arm_position'][2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins) + + #if terminal action is chosen, then produce 'no action' discrete value for each of the state variables + else: + dictionary['body_position'][0] = 0 + dictionary['body_position'][1] = 0 + dictionary['body_position'][2] = 0 + + dictionary['body_yaw'] = 0 + + dictionary['arm_position'][0] = 0 + dictionary['arm_position'][1] = 0 + dictionary['arm_position'][2] = 0 + + def get_head_pitch(self, action): + + value = 0 + + if action == 'LookDown': + value = 1 + elif action == 'LookUp': + value = 2 + + return value + + def detokenize_head_pitch(self, token): + + tokenization_dict = {0:None, 1:'LookDown', 2:'LookUp'} + + return tokenization_dict[token] + + def get_mode(self, action): + + #mode: (0) stop, (1) body, (2) yaw, (3) manipulation, (4) grasping, (5) head pitch + + value = None + + if action == 'stop': + value = 0 + elif action in set( ['LookDown', 'LookUp']): + value = 5 + elif action in set(['MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft']): + value = 1 + elif action in set(['PickupObject', 'ReleaseObject']): + value = 4 + elif action in set(['MoveArm', 'MoveArmBase']): + value = 3 + elif action == 'RotateAgent': + value = 2 + + assert(type(value)==int, 'Get Mode didn\'t return an int') + return value + + def detokenize_mode(self, token): + + tokenization_dict = {0: 'stop', 1:'MoveAgent', 2:'RotateAgent', 3:'MoveArm', 4:'PickupReleaseObject', 5:'PitchAgent'} + + return tokenization_dict[token] + + def detokenize_action(self, detokenized_mode, body_position_delta, body_yaw_delta, arm_position_delta, detokenized_pickup_release, detokenized_head_pitch): + + + if detokenized_mode == 'PickupReleaseObject': + return detokenized_pickup_release + + elif detokenized_mode == 'PitchAgent': + return detokenized_head_pitch + else: + return detokenized_mode + + + def get_pickup_release(self, action): + + if action == 'PickupObject': + value = 1 + elif action == 'ReleaseObject': + value = 2 + else: + value = 0 + + return value + + def detokenize_pickup_release(self, token): + + tokenization_dict = {0:None, 1:'PickupObject', 2:'ReleaseObject'} + return tokenization_dict[token] + + def __getitem__(self, idx): + + # pdb.set_trace() + + traj_group = self.hdf[self.dataset_keys[idx]] + + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + nl_command = traj_json_dict['nl_command'] + + + #compute remainder in case padding of action tokens and observations needed + padding_length = 6 - (len(traj_steps)%6) if len(traj_steps)%6 > 0 else 0 + terminate = False + + start = 0; end = min(len(traj_steps), 6) + + #return list of dictionaries with attributes required for RT1 + all_image_obs = [] + all_nl_commands = [] + all_is_terminal = [] + all_pickup_release = [] + all_body_position_deltas = [] + all_body_yaw_deltas = [] + all_body_pitches = [] + all_arm_position_deltas = [] + all_control_mode = [] + + all_pad_lengths = [] + + + + #build the dictionary for each sequence + while end <= len(traj_steps) and not terminate: + + ''' + mode: stop, body, yaw, manipulation, grasping, head pitch + gripper: (x, y, z, grasp) + body: (x, y, yaw, look up/down) + ''' + image_obs = [] + nl_commands = [] + body_position_deltas = [] + body_yaw_deltas = [] + arm_position_deltas = [] + terminate_episodes = [] + pickup_releases = [] + body_pitches = [] + control_modes = [] + + for i in range(start, end): + + #visual observation + ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) + image_obs.append(ith_obs) + + #natural language command + nl_commands.append(nl_command) + + current_metadata = json.loads(traj_group[traj_steps[i]].attrs['metadata']) + + + if i < len(traj_steps)-1: + + next_metadata = json.loads(traj_group[traj_steps[i+1]].attrs['metadata']) + + #body position, body yaw, arm position + body_position_delta = np.array(next_metadata['steps'][0]['state_body'][:3])-np.array(current_metadata['steps'][0]['state_body'][:3]) + body_yaw_delta = next_metadata['steps'][0]['state_body'][3] - current_metadata['steps'][0]['state_body'][3] + arm_position_delta = np.array(next_metadata['steps'][0]['state_ee'][:3]) - np.array(current_metadata['steps'][0]['state_ee'][:3]) + + #terminate episode / pick up release / body pitch / mode + terminate_episode = int(i == len(traj_steps)-1) + pickup_release = self.get_pickup_release(next_metadata['steps'][0]['action']) + body_pitch = self.get_head_pitch(next_metadata['steps'][0]['action']) + control_mode = self.get_mode(next_metadata['steps'][0]['action']) + else: + + #body position, body yaw, arm positon -- for last step + body_position_delta = np.array([0.0, 0.0, 0.0]) + body_yaw_delta = 0.0 + arm_position_delta = np.array([0.0, 0.0, 0.0]) + + #is terminal / pick up release / body pitch / mode -- for last step + terminate_episode = int(i == len(traj_steps)-1) + pickup_release = self.get_pickup_release(None) + body_pitch = self.get_head_pitch(None) + control_mode = self.get_mode('stop') + + body_position_deltas.append(body_position_delta) + body_yaw_deltas.append(body_yaw_delta) + arm_position_deltas.append(arm_position_delta) + terminate_episodes.append(terminate_episode) + pickup_releases.append(pickup_release) + body_pitches.append(body_pitch) + control_modes.append(control_mode) + + + + #check for remainder and pad data with extra + if end >= len(traj_steps) and padding_length > 0: + + for pad in range(0, padding_length): + + image_obs.append(ith_obs) + nl_commands.append(nl_command) + + body_position_deltas.append(np.array([0.0, 0.0, 0.0])) + body_yaw_deltas.append(0.0) + arm_position_deltas.append(np.array([0.0, 0.0, 0.0])) + terminate_episodes.append(0) + pickup_releases.append(0.0) + body_pitches.append(0.0) + control_modes.append(0.0) + + terminate = True + elif end >= len(traj_steps): + terminate = True + + + + #pre-process and discretize numerical data + body_position_deltas = np.stack(body_position_deltas) + body_yaw_deltas = np.stack(body_yaw_deltas) + arm_position_deltas = np.stack(arm_position_deltas) + + if self.tokenize_action: + + tokenized_actions = { + 'body_position_deltas': body_position_deltas, + 'body_yaw_deltas': body_yaw_deltas, + 'arm_position_deltas': arm_position_deltas, + 'terminate_episode': terminate_episodes + } + + tokenized_actions = self.make_data_discrete(tokenized_actions) + + body_position_deltas = tokenized_actions['body_position_deltas'] + + body_yaw_deltas = np.expand_dims(tokenized_actions['body_yaw_deltas'], axis=1) + + arm_position_deltas = tokenized_actions['arm_position_deltas'] + + + + + all_image_obs.append(np.stack(image_obs)) + all_nl_commands.append(np.stack(nl_commands)) + all_is_terminal.append(np.stack(terminate_episodes)) + all_pickup_release.append(np.stack(pickup_releases)) + all_body_position_deltas.append(body_position_deltas) + all_body_yaw_deltas.append(body_yaw_deltas) + all_body_pitches.append(np.stack(body_pitches)) + all_arm_position_deltas.append(arm_position_deltas) + all_control_mode.append(np.stack(control_modes)) + + all_pad_lengths.append(0 if not end >= len(traj_steps) else padding_length) + + + start += 6 + end = min(end + 6, len(traj_steps)) + + + + + return np.stack(all_image_obs), np.stack(all_nl_commands), np.stack(all_is_terminal), np.stack(all_pickup_release), np.stack(all_body_position_deltas), np.stack(all_body_yaw_deltas), np.stack(all_body_pitches), np.stack(all_arm_position_deltas), np.stack(all_control_mode), np.stack(all_pad_lengths) + + + + def __getitem_old__(self, idx): + + + traj_group = self.hdf[self.dataset_keys[idx]] + + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + nl_command = traj_json_dict['nl_command'] + + start = 0; end = min(len(traj_steps), 6) + + #return list of dictionaries with attributes required for RT1 + all_image_obs = [] + all_nl_commands = [] + all_is_terminal = [] + all_pickup_release = [] + all_body_position = [] + all_body_yaw = [] + all_body_pitch = [] + all_arm_position = [] + all_mode = [] + + + + #build the dictionary for each sequence + while end < len(traj_steps): + + ''' + mode: stop, body, yaw, manipulation, grasping, head pitch + gripper: (x, y, z, grasp) + body: (x, y, yaw, look up/down) + ''' + image_obs = [] + + for i in range(start, end): + ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) + + image_obs.append(ith_obs) + + image_obs = np.stack(image_obs) + + + + before_end_step_metadata = json.loads(traj_group[traj_steps[end-1]].attrs['metadata']) + end_step_metadata = json.loads(traj_group[traj_steps[end]].attrs['metadata']) + + + + dictionary = { + 'observation': image_obs, + 'nl_command': nl_command, #DONE + 'is_terminal': int(end_step_metadata['steps'][0]['action']=='stop'), #DONE + 'pickup_release': self.get_pickup_release(end_step_metadata['steps'][0]['action']), #DONE + 'body_position': np.array(end_step_metadata['steps'][0]['state_body'][:3])-np.array(before_end_step_metadata['steps'][0]['state_body'][:3]), #DONE + 'body_yaw': end_step_metadata['steps'][0]['state_body'][3] - before_end_step_metadata['steps'][0]['state_body'][3], #DONE + 'body_pitch': self.get_head_pitch(end_step_metadata['steps'][0]['action']), #DONE + 'arm_position': np.array(end_step_metadata['steps'][0]['state_ee'][:3]) - np.array(before_end_step_metadata['steps'][0]['state_ee'][:3]), #DONE + 'mode': self.get_mode(end_step_metadata['steps'][0]['action']) #DONE + } + + #pre-process the data dictonary + if self.tokenize_action: + self.make_data_discrete(dictionary) + + + all_image_obs.append(dictionary['observation']) + all_nl_commands.append(dictionary['nl_command']) + all_is_terminal.append(dictionary['is_terminal']) + all_pickup_release.append(dictionary['pickup_release']) + all_body_position.append(dictionary['body_position']) + all_body_yaw.append(dictionary['body_yaw']) + all_body_pitch.append(dictionary['body_pitch']) + all_arm_position.append(dictionary['arm_position']) + all_mode.append(dictionary['mode']) + + + start += 1 + end += 1 + + #add the terminal 'stop' step + all_image_obs.append(dictionary['observation']) + all_nl_commands.append(dictionary['nl_command']) + all_is_terminal.append(1) + all_pickup_release.append(0) + all_body_position.append([0,0,0]) + all_body_yaw.append(0) + all_body_pitch.append(0) + all_arm_position.append([0,0,0]) + all_mode.append(0) + + + + + + return np.stack(all_image_obs), np.stack(all_nl_commands), np.expand_dims(np.stack(all_is_terminal), axis=1), np.expand_dims(np.stack(all_pickup_release), axis=1), np.stack(all_body_position), np.expand_dims(np.stack(all_body_yaw),axis=1), np.expand_dims(np.stack(all_body_pitch), axis=1), np.stack(all_arm_position), np.expand_dims(np.stack(all_mode), axis=1) + + +if __name__ == '__main__': + + + dataset_manager = DatasetManager(0, 0.8, 0.1, 0.1) + + dataloader = DataLoader(dataset_manager.train_dataset, batch_size=3, + shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) + + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size=2, + shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) + + + + for batch, sample_batch in enumerate(dataloader): + + # print('BATCH {}:'.format(batch)) + # print('Num Steps: {}'.format(sample_batch[0].shape[0])) + print('Batch {}: '.format(batch), sample_batch[0].shape[0]) + + + + + \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json b/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json new file mode 100644 index 000000000..da07b6395 --- /dev/null +++ b/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json @@ -0,0 +1 @@ +{"FloorPlan_Train8_1": ["data_11:11:28", "data_11:38:43", "data_11:48:40", "data_11:51:31", "data_11:56:47", "data_11:58:17", "data_12:18:24", "data_12:31:00", "data_12:49:55", "data_12:53:51", "data_12:54:21", "data_12:57:45", "data_12:59:43", "data_13:00:14", "data_13:13:47", "data_13:18:03", "data_13:22:48", "data_13:24:35", "data_13:29:42", "data_13:30:35", "data_13:36:19", "data_13:37:24", "data_13:38:39", "data_13:42:32", "data_13:48:30", "data_13:52:48", "data_13:56:06", "data_13:58:42", "data_14:01:23", "data_14:24:32", "data_14:26:22", "data_14:31:39", "data_14:36:13", "data_14:38:15", "data_14:44:47", "data_14:45:23", "data_14:49:15", "data_14:53:25", "data_14:58:54", "data_15:06:22", "data_15:09:43", "data_15:13:05", "data_15:13:36", "data_15:14:10", "data_15:16:32", "data_15:20:09", "data_15:22:18", "data_15:25:56", "data_15:26:42", "data_15:29:24", "data_15:29:51", "data_15:30:35", "data_15:32:34", "data_15:39:22", "data_15:41:58", "data_15:43:27", "data_15:43:51", "data_16:05:05", "data_16:09:25", "data_16:11:06", "data_16:13:53", "data_16:18:35", "data_16:23:48", "data_16:26:23", "data_16:30:54", "data_16:43:19", "data_16:49:20", "data_16:52:28", "data_16:53:34", "data_16:59:06", "data_17:00:51", "data_17:02:54", "data_17:04:35", "data_17:06:16", "data_17:13:00", "data_17:20:01", "data_17:23:07", "data_17:26:09", "data_17:33:07", "data_17:47:57", "data_17:51:34", "data_17:56:54", "data_17:58:11", "data_17:59:29", "data_18:01:53", "data_18:08:32", "data_18:18:37", "data_18:22:56", "data_18:25:09", "data_18:33:34", "data_18:45:42", "data_19:09:57", "data_19:15:07", "data_19:20:52", "data_19:25:51", "data_19:34:02", "data_19:43:09", "data_19:48:33", "data_19:52:25", "data_19:53:51", "data_20:29:26", "data_21:11:22", "data_21:14:13", "data_22:26:52"], "FloorPlan_Train1_3": ["data_11:14:08", "data_12:27:37", "data_12:28:44", "data_12:30:42", "data_12:42:59", "data_12:48:44", "data_13:01:08", "data_13:10:23", "data_13:16:27", "data_13:26:27", "data_13:29:09", "data_13:33:21", "data_13:35:43", "data_13:45:31", "data_13:49:19", "data_13:53:16", "data_13:59:05", "data_14:02:16", "data_14:19:36", "data_14:22:29", "data_14:24:31", "data_14:26:42", "data_14:32:06", "data_14:34:15", "data_14:35:23", "data_14:38:31", "data_14:43:46", "data_14:46:49", "data_14:48:48", "data_14:50:47", "data_14:56:50", "data_15:01:27", "data_15:35:48", "data_15:38:38", "data_15:39:32", "data_15:42:27", "data_15:49:15", "data_15:50:49", "data_15:51:26", "data_15:52:55", "data_15:54:45", "data_15:56:44", "data_15:58:10", "data_16:01:04", "data_16:03:52", "data_16:04:17", "data_16:10:32", "data_16:10:59", "data_16:33:34", "data_16:37:28", "data_16:40:36", "data_16:40:44", "data_16:42:54", "data_16:43:00", "data_16:43:00:00", "data_16:44:16", "data_16:45:24", "data_16:47:46", "data_16:49:24", "data_16:55:46", "data_17:05:08", "data_17:07:34", "data_17:07:43", "data_17:21:35", "data_17:26:17", "data_17:29:14", "data_17:32:17", "data_17:32:27", "data_17:43:33", "data_17:47:03", "data_17:51:39", "data_17:59:00", "data_18:04:56", "data_18:11:24", "data_18:17:16", "data_18:22:49", "data_18:25:44", "data_18:28:13", "data_18:28:43", "data_18:29:38", "data_18:31:13", "data_18:35:58", "data_18:37:04", "data_18:46:02", "data_19:14:43", "data_19:31:51", "data_19:35:53", "data_20:11:23", "data_20:15:34", "data_20:57:07", "data_21:09:57", "data_21:35:32", "data_21:40:45", "data_22:55:44", "data_22:59:37", "data_23:02:34"], "FloorPlan_Train5_1": ["data_11:19:28", "data_11:23:37", "data_12:05:09", "data_12:15:11", "data_12:22:25", "data_12:37:24", "data_12:40:41", "data_12:43:21", "data_12:58:49", "data_13:14:36", "data_13:22:30", "data_13:25:14", "data_13:28:56", "data_13:29:25", "data_13:31:07", "data_13:33:29", "data_13:40:50", "data_13:42:24", "data_13:46:04", "data_14:03:55", "data_14:05:06", "data_14:09:28", "data_14:10:09", "data_14:14:11", "data_14:18:16", "data_14:23:38", "data_14:36:10", "data_14:40:10", "data_14:47:53", "data_14:50:55", "data_14:56:41", "data_14:58:02", "data_14:58:08", "data_15:03:19", "data_15:05:49", "data_15:06:39", "data_15:08:16", "data_15:13:04", "data_15:19:26", "data_15:22:08", "data_15:27:41", "data_15:29:40", "data_15:40:49", "data_15:44:42", "data_15:56:53", "data_15:58:27", "data_16:00:55", "data_16:02:46", "data_16:05:15", "data_16:06:05", "data_16:07:40", "data_16:09:36", "data_16:12:08", "data_16:26:34", "data_16:29:17", "data_16:31:09", "data_16:31:36", "data_16:35:27", "data_16:43:42", "data_16:45:58", "data_16:47:16", "data_16:50:06", "data_16:51:03", "data_16:53:36", "data_16:53:39", "data_16:53:42", "data_16:54:39", "data_16:56:38", "data_16:57:05:00", "data_16:57:25", "data_17:12:32", "data_17:17:50", "data_17:35:45", "data_17:39:05:00", "data_17:41:00", "data_17:41:08", "data_17:45:27", "data_17:50:42", "data_17:54:05", "data_17:56:23", "data_18:22:47", "data_18:31:07", "data_18:33:51", "data_18:37:38", "data_18:42:03", "data_18:44:54", "data_18:47:01", "data_18:50:53", "data_18:58:07", "data_19:04:21", "data_19:08:32", "data_19:27:25", "data_19:53:59", "data_19:57:56", "data_20:07:12", "data_22:02:06", "data_22:10:19", "data_23:06:06", "data_23:09:41", "data_23:16:06"], "FloorPlan_Train12_3": ["data_11:24:25", "data_12:04:43", "data_12:04:44", "data_12:09:11", "data_12:12:18", "data_12:13:00", "data_12:48:09", "data_12:55:46", "data_13:02:17", "data_13:04:13", "data_13:06:18", "data_13:07:22", "data_13:07:34", "data_13:08:21", "data_13:10:24", "data_13:15:55", "data_13:18:11", "data_13:19:12", "data_13:33:54", "data_13:37:23", "data_13:39:28", "data_13:40:16", "data_13:51:04", "data_13:52:30", "data_13:56:07", "data_13:57:55", "data_14:04:08", "data_14:06:14", "data_14:06:28", "data_14:07:59", "data_14:10:04", "data_14:19:43", "data_14:23:01", "data_14:25:51", "data_14:36:45", "data_14:38:16", "data_14:40:46", "data_15:04:08", "data_15:06:03", "data_15:08:14", "data_15:10:38", "data_15:13:32", "data_15:15:15", "data_15:21:58", "data_15:22:59", "data_15:23:17", "data_15:25:19", "data_15:27:29", "data_15:27:52", "data_15:34:50", "data_15:37:13", "data_15:37:30", "data_15:39:06", "data_15:39:14", "data_15:40:22", "data_15:41:15", "data_15:46:13", "data_15:47:54", "data_15:48:04", "data_15:50:55", "data_16:03:07", "data_16:11:48", "data_16:12:38", "data_16:15:33", "data_16:21:47", "data_16:22:10", "data_16:22:44", "data_16:25:33", "data_16:27:27", "data_16:33:37", "data_16:33:42", "data_16:35:20", "data_16:37:57", "data_16:58:28", "data_16:59:59", "data_17:02:20", "data_17:05:07", "data_17:07:22", "data_17:08:14", "data_17:08:43", "data_17:10:41", "data_17:12:20", "data_17:16:57", "data_17:25:26", "data_17:31:59", "data_17:39:05", "data_18:05:31", "data_18:06:05", "data_18:09:48", "data_18:11:32", "data_18:20:49", "data_18:38:30", "data_18:40:29", "data_18:44:56", "data_19:32:42", "data_19:36:17", "data_19:38:40", "data_19:55:46", "data_19:58:40", "data_20:04:58", "data_20:36:00", "data_20:40:25", "data_20:40:56", "data_20:43:46", "data_21:22:47", "data_21:27:13", "data_21:36:02", "data_21:39:40"], "FloorPlan_Train7_5": ["data_11:33:11", "data_11:35:24", "data_11:38:27", "data_11:44:50", "data_11:50:57", "data_12:03:39", "data_12:30:12", "data_12:36:36", "data_12:41:02", "data_12:45:50", "data_12:46:17", "data_12:48:23", "data_12:50:47", "data_12:59:13", "data_13:01:06", "data_13:06:40", "data_13:10:05", "data_13:19:26", "data_13:33:39", "data_13:34:59", "data_13:39:14", "data_13:39:53", "data_13:41:08", "data_13:44:39", "data_13:48:45", "data_13:53:16:00", "data_14:17:20", "data_14:19:54", "data_14:22:51", "data_14:23:49", "data_14:29:19", "data_14:40:36", "data_14:43:02", "data_14:45:24", "data_14:52:27", "data_15:00:11", "data_15:02:05", "data_15:05:00", "data_15:06:51", "data_15:08:00", "data_15:08:23", "data_15:09:40", "data_15:10:35", "data_15:15:28", "data_15:18:01", "data_15:19:33", "data_15:20:32", "data_15:22:15", "data_15:24:10", "data_15:33:02", "data_15:35:16", "data_15:36:12", "data_15:37:15", "data_15:58:50", "data_16:00:52", "data_16:02:56", "data_16:03:52:00", "data_16:04:13", "data_16:08:41", "data_16:10:21", "data_16:12:36", "data_16:15:15", "data_16:18:47", "data_16:21:30", "data_16:33:14", "data_16:35:18", "data_16:36:47", "data_16:37:29", "data_16:43:59", "data_16:47:31", "data_16:55:23", "data_16:55:40", "data_16:57:05", "data_16:57:21", "data_16:58:20", "data_16:58:53", "data_16:59:33", "data_16:59:34", "data_17:00:42", "data_17:00:58", "data_17:02:46", "data_17:02:49", "data_17:03:08", "data_17:10:18", "data_17:32:08", "data_17:39:16", "data_17:43:47", "data_17:46:14", "data_17:48:24", "data_17:58:02", "data_17:59:14", "data_18:01:35", "data_18:06:24", "data_18:09:10", "data_18:12:41", "data_18:15:58", "data_18:26:13", "data_18:39:40", "data_18:41:38", "data_18:45:39", "data_18:54:32", "data_18:57:41", "data_18:59:56", "data_19:00:23", "data_19:02:18", "data_19:03:13", "data_19:15:22", "data_19:18:14", "data_19:20:26", "data_19:27:05", "data_20:26:48", "data_20:33:59", "data_22:17:48", "data_23:21:12", "data_23:26:05", "data_23:27:44"]} \ No newline at end of file diff --git a/models/main_models/rt1/main.py b/models/main_models/rt1/main.py new file mode 100644 index 000000000..29f6032bd --- /dev/null +++ b/models/main_models/rt1/main.py @@ -0,0 +1,257 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +from tqdm import tqdm +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=['fractal20220817_data'], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--epochs", + type=int, + default=1, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--train-batch-size", + type=int, + default=8, + help="train batch size", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=8, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=0, + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=200, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/rt1_pretraining", + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-pretraining-v1", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + print("Loading dataset...") + + train_dataset = create_dataset( + datasets=args.datasets, + split=args.train_split, + trajectory_length=args.trajectory_length, + batch_size=args.train_batch_size, + num_epochs=args.epochs, + ) + # eval_dataset = create_dataset( + # datasets=args.datasets, + # split=args.eval_split, + # trajectory_length=args.trajectory_length, + # batch_size=args.eval_batch_size, + # num_epochs=args.epochs, + # ) + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + action_space = gym.spaces.Dict( + world_vector=gym.spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + base_displacement_vertical_rotation=gym.spaces.Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 + ), + gripper_closedness_action=gym.spaces.Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=gym.spaces.Discrete(3), + base_displacement_vector=gym.spaces.Box( + low=-1.0, + high=1.0, + shape=(2,), + dtype=np.float32, + ), + rotation_delta=gym.spaces.Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else None + ) + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + if text_embedding_model is not None: + return text_embedding_model.encode(observation["instruction"]) + else: + return observation["embedding"] + + print("Training...") + num_batches = 0 + + for batch in tqdm(train_dataset): + + policy.model.train() + + num_batches += 1 + + if num_batches <= 0: + continue + + #Image Shape: 8, 6, 480, 640, 3 => (batch, length, height, width, channel) + #Context Shape: 8, 6, 512 => (batch, length, embedding) + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + + + actions = batch["action"] + + try: + loss, loss_std = policy.loss(observations, actions) + except: + print('-------------LOSS COMPUTATION FAILED!!!--------') + continue + + if args.wandb: + wandb.log({"loss": loss.item(), "loss_std": loss_std.item()}, step=num_batches * args.train_batch_size) + print(f"Train loss Batch {num_batches}: {loss.item()}") + else: + print(f"Train loss Batch {num_batches}: {loss.item()}") + optimizer.zero_grad() + loss.backward() + optimizer.step() + if args.eval_freq and num_batches % args.eval_freq == 0: + print("Evaluating...") + policy.model.eval() + batch = next(eval_dataset) + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + actions = batch["action"] + eval_loss, eval_loss_std = policy.loss(observations, actions) + eval_loss = eval_loss.item() + if args.wandb: + wandb.log( + {"eval_loss": eval_loss, "eval_loss_std": eval_loss_std.item()}, + step=num_batches * args.train_batch_size, + ) + else: + print(f"Eval loss Batch {num_batches}: {eval_loss}") + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{num_batches}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + print("finished training") + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/main_ft.py b/models/main_models/rt1/main_ft.py new file mode 100644 index 000000000..dca6394ab --- /dev/null +++ b/models/main_models/rt1/main_ft.py @@ -0,0 +1,387 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=["fractal20220817_data"], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--epochs", + type=int, + default=4, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--train-batch-size", + type=int, + default=3, + help="train batch size", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=0, #200 + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=100, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/temp", #"checkpoints/diversity_v1_4" + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default='/oscar/data/stellex/shared/rt1-checkpoints/checkpoints/bridge/checkpoint_14400_loss_70.621.pt', #NOTE: include the path to load the checkpoint here + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + + parser.add_argument( + "--eval-scene", + default=4, + help = "scene used as validation during k-fold cross validation", + ) + + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + + parser.add_argument( + "--num-diversity-scenes", + default = 4, + ) + + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + + + parser.add_argument( + "--train-subbatch", + default=8, + ) + parser.add_argument( + "--eval-subbatch", + default=5, + ) + return parser.parse_args() + + +def main(): + + + args = parse_args() + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-data-diversity-v1", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + print("Loading dataset...") + + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + + if args.wandb and args.split_type == 'diversity_ablation': + wandb.log({"task_keys": dataset_manager.train_dataset.dataset_keys}) + + train_dataloader = DataLoader(dataset_manager.train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches, drop_last = False) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=True, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + + #NOTE: has to be Not None because of raw instruction input + + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + print('EMBEDDING FAILED!') + + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + print("Training...") + num_batches = 0 + total_train_steps = 0 + total_val_steps = 0 + + + + + for epoch in range(args.epochs): + print("STARTING EPOCH {}".format(epoch+1)) + + for batch, train_batch in enumerate(train_dataloader): + + + batch_steps = train_batch[0].shape[0] + + for idx in range(0, batch_steps, args.train_subbatch): + + + + policy.model.train() + + num_batches += 1 + + + observations = { + "image": train_batch[0][idx : min(idx + args.train_subbatch, batch_steps)], + "context": get_text_embedding(train_batch[1][idx : min(idx + args.train_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': train_batch[2][idx : min(idx + args.train_subbatch, batch_steps)], + 'pickup_release': train_batch[3][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_position_delta': train_batch[4][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_yaw_delta': train_batch[5][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_pitch_delta': train_batch[6][idx : min(idx + args.train_subbatch, batch_steps)], + 'arm_position_delta': train_batch[7][idx : min(idx + args.train_subbatch, batch_steps)], + 'control_mode': train_batch[8][idx : min(idx + args.train_subbatch, batch_steps)] + } + + padding = train_batch[9][idx : min(idx + args.train_subbatch, batch_steps)] + total_train_steps += batch_steps + + + loss, loss_std = policy.loss(observations, actions) + + if args.wandb: + print(f"Train loss Batch {num_batches}: {loss.item()} ± {loss_std.item()}") + wandb.log({"train_loss": loss.item(), "train_loss_std": loss_std.item()}, step= total_train_steps) + else: + print(f"Train loss Batch {num_batches}: {loss.item()}") + + optimizer.zero_grad() + loss.backward() + optimizer.step() + observations = {}; actions = {} + + + if args.eval_freq and num_batches % args.eval_freq == 0: + + # Clear cache and collected garbage + gc.collect() + torch.cuda.empty_cache() + + total_eval_loss = 0 + total_eval_loss_std = 0 + total_eval_count = 0 + + + + print("Evaluating...") + for batch, val_batch in enumerate(val_dataloader): + + batch_steps = val_batch[0].shape[0] + + print(f'Section {batch+1} of {len(val_dataloader)}') + + for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): + + + policy.model.eval() + + + total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + + observations = { + "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], + "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], + 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], + 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], + 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] + } + + padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] + + eval_loss, eval_loss_std = policy.loss(observations, actions) + + + total_eval_loss += eval_loss.item()*observations['image'].shape[0] + total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] + + if args.wandb: + wandb.log( + {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, + step=total_train_steps, + ) + print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") + else: + print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") + + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{total_train_steps}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + + print("FINISHED EPOCH {}".format(epoch+1)) + print("finished training") + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/main_ft_eval.py b/models/main_models/rt1/main_ft_eval.py new file mode 100644 index 000000000..708243b25 --- /dev/null +++ b/models/main_models/rt1/main_ft_eval.py @@ -0,0 +1,279 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=["fractal20220817_data"], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--checkpoint-path", + type=str, + default="checkpoints/scene4", + help="directory to save checkpoints", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + + parser.add_argument( + "--eval-scene", + default=4, + help = "scene used as validation during k-fold cross validation", + ) + parser.add_argument( + "--eval-subbatch", + default=5, + ) + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + + parser.add_argument( + "--num-diversity-scenes", + default = 4, + ) + + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + + os.makedirs(args.checkpoint_path, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-finetuning", config=vars(args)) + + os.makedirs(args.checkpoint_path, exist_ok=True) + + assert(len(os.listdir(args.checkpoint_path)) > 0 , "ERROR: checkpoint path is empty and has no saved checkpoints") + + print("Loading dataset...") + + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + + + #NOTE: has to be Not None because of raw instruction input + + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + pdb.set_trace() + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + + def extract_train_step(filepath): + return int(filepath.split('_')[1]) + + + print("Evaluating...") + + + for idx, checkpoint_file in enumerate(list(sorted(os.listdir(args.checkpoint_path), key=extract_train_step))): + + print(f'Evaluating file: {idx} of {len(os.listdir(args.checkpoint_path))}') + total_train_steps = int(checkpoint_file.split('_')[1]) + total_val_steps = 0 + + + total_eval_loss = 0 + total_eval_loss_std = 0 + total_eval_count = 0 + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=os.path.join(args.checkpoint_path, checkpoint_file), + ) + + + + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + + + for batch, val_batch in enumerate(val_dataloader): + + batch_steps = val_batch[0].shape[0] + + print(f'Section {batch+1} of {len(val_dataloader)}') + + for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): + + + policy.model.eval() + + + total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + + observations = { + "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], + "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], + 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], + 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], + 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] + } + + padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] + + eval_loss, eval_loss_std = policy.loss(observations, actions) + + + total_eval_loss += eval_loss.item()*observations['image'].shape[0] + total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] + + if args.wandb: + wandb.log( + {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, + step=total_train_steps, + ) + print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") + else: + print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/rollout_ai2thor.py b/models/main_models/rt1/rollout_ai2thor.py new file mode 100644 index 000000000..0edf255ca --- /dev/null +++ b/models/main_models/rt1/rollout_ai2thor.py @@ -0,0 +1,366 @@ +import argparse +import os +os.environ["CUDA_VISIBLE_DEVICES"] = "0" +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc +import json +import pandas as pd +from ai2thor_env import ThorEnv +import pickle +import time +from tqdm import tqdm + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--checkpoint-file-path", + type=str, + default="checkpoints/scene2/checkpoint_299183_loss_152.175.pt", #NOTE: change according to checkpoint file that is to be loaded + help="directory to save checkpoints", + ) + + parser.add_argument( + "--trajectory-save-path", + type=str, + default="traj_rollouts/scene2", + help = "directory to save the generated trajectory predicted by the model" + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + parser.add_argument( + "--eval-scene", + default=2, + help = "scene used as validation during k-fold cross validation", + ) + parser.add_argument( + "--eval-subbatch", + default=1, + ) + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + parser.add_argument( + "--num-diversity-scenes", + default = 3, + ) + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + if args.wandb: + wandb.init(project="rt1-rollout-data", config=vars(args)) + + os.makedirs(args.trajectory_save_path, exist_ok=True) + + assert(os.path.isfile(args.checkpoint_file_path), "ERROR: checkpoint file does not exist") + + + print("Loading dataset...") + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + + + #NOTE: has to be Not None because of raw instruction input + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + raise Exception('Error: task descriptions could not be embedded') + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + + + + print("Loading chosen checkpoint to model...") + rt1_model_policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.checkpoint_file_path, + ) + rt1_model_policy.model.eval() + + # Total number of params + total_params = sum(p.numel() for p in rt1_model_policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in rt1_model_policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in rt1_model_policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + + print('Creating pandas dataframe for trajectories...') + + print_val = True + + + for task in tqdm(val_dataloader.dataset.dataset_keys): + + + #skip tasks that trajectory already generated for + if os.path.isfile(os.path.join(args.trajectory_save_path, task)): + continue + elif print_val: + print('START AT: ', val_dataloader.dataset.dataset_keys.index(task)) + print_val = False + + traj_group = val_dataloader.dataset.hdf[task] + + traj_steps = list(traj_group.keys()) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + language_command_embedding = get_text_embedding(np.array([[traj_json_dict['nl_command']]])) + language_command_embedding = np.repeat(language_command_embedding, 6, axis=1) + + + print('TASK: ', traj_json_dict['nl_command']) + + #initialize the AI2Thor environment + ai2thor_env = ThorEnv(traj_json_dict['nl_command']) + event = ai2thor_env.reset(traj_json_dict['scene']) + + + + #extract the visual observation from initialzed environment + curr_image = event.frame + visual_observation = np.expand_dims(np.expand_dims(curr_image, axis=0) , axis=0) + visual_observation = np.repeat(visual_observation, 6, axis=1) + + ''' + OLD OBS FROM DATASET + visual_observation = np.expand_dims(np.expand_dims(np.array(traj_group[traj_steps[0]]['rgb_0']), axis=0), axis=0) + visual_observation = np.repeat(visual_observation, 6, axis=1) + ''' + + #track the starting coordinates for body, yaw rotation and arm coordinate + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + agent_holding = np.array([]) + + + #track the total number of steps and the last control mode + num_steps = 0; curr_mode = None; is_terminal = False + + + #track data for all steps + trajectory_data = [] + + while (curr_mode != 'stop' or is_terminal) and num_steps < ai2thor_env.max_episode_length: + + #provide the current observation to the model + curr_observation = { + 'image': visual_observation, + 'context': language_command_embedding + } + + generated_action_tokens = rt1_model_policy.act(curr_observation) + + #de-tokenize the generated actions from RT1 + pickup_release = val_dataloader.dataset.detokenize_pickup_release(generated_action_tokens['pickup_release'][0]) + body_pitch = val_dataloader.dataset.detokenize_head_pitch(generated_action_tokens['body_pitch_delta'][0]) + curr_mode = val_dataloader.dataset.detokenize_mode(generated_action_tokens['control_mode'][0]) + + + + + terminate_episode = generated_action_tokens['terminate_episode'][0] + + continuous_variables = { + 'body_position_delta': generated_action_tokens['body_position_delta'], + 'body_yaw_delta': generated_action_tokens['body_yaw_delta'], + 'arm_position_delta': generated_action_tokens['arm_position_delta'], + 'curr_mode': curr_mode + } + + continuous_variables = val_dataloader.dataset.detokenize_continuous_data(continuous_variables) + body_position_delta = np.squeeze(continuous_variables['body_position_delta']) + body_yaw_delta = continuous_variables['body_yaw_delta'][0][0] + arm_position_delta = np.squeeze(continuous_variables['arm_position_delta']) + + curr_action = val_dataloader.dataset.detokenize_action(curr_mode, body_position_delta, body_yaw_delta, arm_position_delta, pickup_release, body_pitch) + + + + #update the tracked coordinate data based on model output + curr_body_coordinate += body_position_delta + curr_body_yaw += body_yaw_delta + curr_arm_coordinate += arm_position_delta + + + #execute the generated action in the AI2THOR simulator + step_args = { + 'xyz_body': curr_body_coordinate, + 'xyz_body_delta': body_position_delta, + 'curr_body_yaw': curr_body_yaw, + 'body_yaw_delta': body_yaw_delta, + 'arm_position_delta': arm_position_delta, + 'arm_position': curr_arm_coordinate + } + success, error, event = ai2thor_env.step(curr_action, step_args) + + time.sleep(0.25) + + #fetch object holding from simulator; also maybe fetch coordinate of body/arm + yaw from simulator + agent_holding = np.array(event.metadata['arm']['heldObjects']) + + #fetch the new visual observation from the simulator, update the current mode and increment number of steps + curr_image = np.expand_dims(np.expand_dims(event.frame, axis=0) , axis=0) + + visual_observation = visual_observation[:,1:,:,:,:] + visual_observation = np.concatenate((visual_observation, curr_image), axis=1) + num_steps +=1 + + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + + + #add data to the dataframe CSV + step_data = { + 'task': traj_json_dict['nl_command'], + 'scene': traj_json_dict['scene'], + 'img': curr_image, + 'xyz_body': curr_body_coordinate, + 'xyz_body_delta': body_position_delta, + 'yaw_body': curr_body_yaw, + 'yaw_body_delta': body_yaw_delta, + 'pitch_body': body_pitch, + 'xyz_ee': curr_arm_coordinate, + 'xyz_ee_delta': arm_position_delta, + 'pickup_dropoff': pickup_release, + 'holding_obj': agent_holding, + 'control_mode': curr_mode, + 'action': curr_action, + 'terminate': terminate_episode, + 'step': num_steps, + 'timeout': num_steps >= ai2thor_env.max_episode_length, + 'error': error + } + + trajectory_data.append(step_data) + + #save the final event with all metadata: save as a json file dict + save_path = os.path.join(args.trajectory_save_path, task) + with open(save_path, 'wb') as file: + pickle.dump({'trajectory_data': trajectory_data, 'final_state': event.metadata}, file) + + #close the old GUI for AI2Thor after trajectory finishes + ai2thor_env.controller.stop() + time.sleep(0.5) + + + + + + + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/rt1_env/bin/Activate.ps1 b/models/main_models/rt1/rt1_env/bin/Activate.ps1 new file mode 100644 index 000000000..9d3646a4f --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/Activate.ps1 @@ -0,0 +1,241 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/models/main_models/rt1/rt1_env/bin/activate b/models/main_models/rt1/rt1_env/bin/activate new file mode 100644 index 000000000..2fdaa7bfa --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/activate @@ -0,0 +1,66 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null + fi + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1="(rt1_env) ${PS1:-}" + export PS1 +fi + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null +fi diff --git a/models/main_models/rt1/rt1_env/bin/activate.csh b/models/main_models/rt1/rt1_env/bin/activate.csh new file mode 100644 index 000000000..af00fde95 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/activate.csh @@ -0,0 +1,25 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . +# Ported to Python 3.3 venv by Andrew Svetlov + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" + +set _OLD_VIRTUAL_PATH="$PATH" +setenv PATH "$VIRTUAL_ENV/bin:$PATH" + + +set _OLD_VIRTUAL_PROMPT="$prompt" + +if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then + set prompt = "(rt1_env) $prompt" +endif + +alias pydoc python -m pydoc + +rehash diff --git a/models/main_models/rt1/rt1_env/bin/activate.fish b/models/main_models/rt1/rt1_env/bin/activate.fish new file mode 100644 index 000000000..388919ed3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/activate.fish @@ -0,0 +1,64 @@ +# This file must be used with "source /bin/activate.fish" *from fish* +# (https://fishshell.com/); you cannot run it directly. + +function deactivate -d "Exit virtual environment and return to normal shell environment" + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + functions -e fish_prompt + set -e _OLD_FISH_PROMPT_OVERRIDE + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + end + + set -e VIRTUAL_ENV + if test "$argv[1]" != "nondestructive" + # Self-destruct! + functions -e deactivate + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/bin" $PATH + +# Unset PYTHONHOME if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # fish uses a function instead of an env var to generate the prompt. + + # Save the current fish_prompt function as the function _old_fish_prompt. + functions -c fish_prompt _old_fish_prompt + + # With the original prompt function renamed, we can override with our own. + function fish_prompt + # Save the return status of the last command. + set -l old_status $status + + # Output the venv prompt; color taken from the blue of the Python logo. + printf "%s%s%s" (set_color 4B8BBE) "(rt1_env) " (set_color normal) + + # Restore the return status of the previous command. + echo "exit $old_status" | . + # Output the original/"old" prompt. + _old_fish_prompt + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" +end diff --git a/models/main_models/rt1/rt1_env/bin/ai2thor-xorg b/models/main_models/rt1/rt1_env/bin/ai2thor-xorg new file mode 100755 index 000000000..7bc6235a3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/ai2thor-xorg @@ -0,0 +1,267 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +import os +import sys +import time +import platform +import re +import shlex +import subprocess +import argparse +import signal + +# Turning off automatic black formatting for this script as it breaks quotes. +# fmt: off +from typing import List + +PID_FILE = "/var/run/ai2thor-xorg.pid" +CONFIG_FILE = "/tmp/ai2thor-xorg.conf" + +DEFAULT_HEIGHT = 768 +DEFAULT_WIDTH = 1024 + + +def process_alive(pid): + """ + Use kill(0) to determine if pid is alive + :param pid: process id + :rtype: bool + """ + try: + os.kill(pid, 0) + except OSError: + return False + + return True + + +def find_devices(excluded_device_ids): + devices = [] + id_counter = 0 + for r in pci_records(): + if r.get("Vendor", "") == "NVIDIA Corporation" and r["Class"] in [ + "VGA compatible controller", + "3D controller", + ]: + bus_id = "PCI:" + ":".join( + map(lambda x: str(int(x, 16)), re.split(r"[:\.]", r["Slot"])) + ) + + if id_counter not in excluded_device_ids: + devices.append(bus_id) + + id_counter += 1 + + if not devices: + print("Error: ai2thor-xorg requires at least one NVIDIA device") + sys.exit(1) + + return devices + +def active_display_bus_ids(): + # this determines whether a monitor is connected to the GPU + # if one is, the following Option is added for the Screen "UseDisplayDevice" "None" + command = "nvidia-smi --query-gpu=pci.bus_id,display_active --format=csv,noheader" + active_bus_ids = set() + result = subprocess.run(command, shell=True, stdout=subprocess.PIPE) + if result.returncode == 0: + for line in result.stdout.decode().strip().split("\n"): + nvidia_bus_id, display_status = re.split(r",\s?", line.strip()) + bus_id = "PCI:" + ":".join( + map(lambda x: str(int(x, 16)), re.split(r"[:\.]", nvidia_bus_id)[1:]) + ) + if display_status.lower() == "enabled": + active_bus_ids.add(bus_id) + + return active_bus_ids + +def pci_records(): + records = [] + command = shlex.split("lspci -vmm") + output = subprocess.check_output(command).decode() + + for devices in output.strip().split("\n\n"): + record = {} + records.append(record) + for row in devices.split("\n"): + key, value = row.split("\t") + record[key.split(":")[0]] = value + + return records + + +def read_pid(): + if os.path.isfile(PID_FILE): + with open(PID_FILE) as f: + return int(f.read()) + else: + return None + + +def start(display: str, excluded_device_ids: List[int], width: int, height: int): + pid = read_pid() + + if pid and process_alive(pid): + print("Error: ai2thor-xorg is already running with pid: %s" % pid) + sys.exit(1) + + with open(CONFIG_FILE, "w") as f: + f.write(generate_xorg_conf(excluded_device_ids, width=width, height=height)) + + log_file = "/var/log/ai2thor-xorg.%s.log" % display + error_log_file = "/var/log/ai2thor-xorg-error.%s.log" % display + command = shlex.split( + "Xorg -quiet -maxclients 1024 -noreset +extension GLX +extension RANDR +extension RENDER -logfile %s -config %s :%s" + % (log_file, CONFIG_FILE, display) + ) + + pid = None + with open(error_log_file, "w") as error_log_f: + proc = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=error_log_f) + pid = proc.pid + try: + proc.wait(timeout=0.25) + except subprocess.TimeoutExpired: + pass + + if pid and process_alive(pid): + with open(PID_FILE, "w") as f: + f.write(str(proc.pid)) + else: + print("Error: error with command '%s'" % " ".join(command)) + with open(error_log_file, "r") as f: + print(f.read()) + + +def print_config(excluded_device_ids: List[int], width: int, height: int): + print(generate_xorg_conf(excluded_device_ids, width=width, height=height)) + + +def stop(): + pid = read_pid() + if pid and process_alive(pid): + os.kill(pid, signal.SIGTERM) + + for i in range(10): + time.sleep(0.2) + if not process_alive(pid): + os.unlink(PID_FILE) + break + + +def generate_xorg_conf( + excluded_device_ids: List[int], width: int, height: int +): + devices = find_devices(excluded_device_ids) + active_display_devices = active_display_bus_ids() + + xorg_conf = [] + + device_section = """ +Section "Device" + Identifier "Device{device_id}" + Driver "nvidia" + VendorName "NVIDIA Corporation" + BusID "{bus_id}" +EndSection +""" + server_layout_section = """ +Section "ServerLayout" + Identifier "Layout0" + {screen_records} +EndSection +""" + screen_section = """ +Section "Screen" + Identifier "Screen{screen_id}" + Device "Device{device_id}" + DefaultDepth 24 + Option "AllowEmptyInitialConfiguration" "True" + Option "Interactive" "False" + {extra_options} + SubSection "Display" + Depth 24 + Virtual {width} {height} + EndSubSection +EndSection +""" + screen_records = [] + for i, bus_id in enumerate(devices): + extra_options = "" + if bus_id in active_display_devices: + # See https://github.com/allenai/ai2thor/pull/990 + # when a monitor is connected, this option must be used otherwise + # Xorg will fail to start + extra_options = 'Option "UseDisplayDevice" "None"' + xorg_conf.append(device_section.format(device_id=i, bus_id=bus_id)) + xorg_conf.append(screen_section.format(device_id=i, screen_id=i, width=width, height=height, extra_options=extra_options)) + screen_records.append( + 'Screen {screen_id} "Screen{screen_id}" 0 0'.format(screen_id=i) + ) + + xorg_conf.append( + server_layout_section.format(screen_records="\n ".join(screen_records)) + ) + + output = "\n".join(xorg_conf) + return output + + +# fmt: on + +if __name__ == "__main__": + if os.geteuid() != 0: + path = os.path.abspath(__file__) + print("Executing ai2thor-xorg with sudo") + args = ["--", path] + sys.argv[1:] + os.execvp("sudo", args) + + if platform.system() != "Linux": + print("Error: Can only run ai2thor-xorg on linux") + sys.exit(1) + + parser = argparse.ArgumentParser() + parser.add_argument( + "--exclude-device", + help="exclude a specific GPU device", + action="append", + type=int, + default=[], + ) + parser.add_argument( + "--width", + help="width of the screen to start (should be greater than the maximum" + f" width of any ai2thor instance you will start) [default: {DEFAULT_WIDTH}]", + type=int, + default=DEFAULT_WIDTH, + ) + parser.add_argument( + "--height", + help="height of the screen to start (should be greater than the maximum" + f" height of any ai2thor instance you will start) [default: {DEFAULT_HEIGHT}]", + type=int, + default=DEFAULT_HEIGHT, + ) + parser.add_argument( + "command", + help="command to be executed", + choices=["start", "stop", "print-config"], + ) + parser.add_argument( + "display", help="display to be used", nargs="?", type=int, default=0 + ) + args = parser.parse_args() + if args.command == "start": + start( + display=args.display, + excluded_device_ids=args.exclude_device, + height=args.height, + width=args.width, + ) + elif args.command == "stop": + stop() + elif args.command == "print-config": + print_config( + excluded_device_ids=args.exclude_device, + width=args.width, + height=args.height, + ) diff --git a/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx b/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx new file mode 100755 index 000000000..0294702e2 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from caffe2.python.onnx.bin.conversion import caffe2_to_onnx +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(caffe2_to_onnx()) diff --git a/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 b/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 new file mode 100755 index 000000000..daed37802 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from caffe2.python.onnx.bin.conversion import onnx_to_caffe2 +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(onnx_to_caffe2()) diff --git a/models/main_models/rt1/rt1_env/bin/f2py b/models/main_models/rt1/rt1_env/bin/f2py new file mode 100755 index 000000000..6ae2c3109 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/f2py @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from numpy.f2py.f2py2e import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/flask b/models/main_models/rt1/rt1_env/bin/flask new file mode 100755 index 000000000..fa566a3ba --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/flask @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from flask.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/huggingface-cli b/models/main_models/rt1/rt1_env/bin/huggingface-cli new file mode 100755 index 000000000..5580d7dc9 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/huggingface-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from huggingface_hub.commands.huggingface_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/imageio_download_bin b/models/main_models/rt1/rt1_env/bin/imageio_download_bin new file mode 100755 index 000000000..2e17ded5a --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/imageio_download_bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from imageio.__main__ import download_bin_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(download_bin_main()) diff --git a/models/main_models/rt1/rt1_env/bin/imageio_remove_bin b/models/main_models/rt1/rt1_env/bin/imageio_remove_bin new file mode 100755 index 000000000..bbbdac364 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/imageio_remove_bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from imageio.__main__ import remove_bin_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(remove_bin_main()) diff --git a/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard b/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard new file mode 100755 index 000000000..47503b8c4 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.python.tools.import_pb_to_tensorboard import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/isympy b/models/main_models/rt1/rt1_env/bin/isympy new file mode 100755 index 000000000..8f709363b --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/isympy @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from isympy import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/jp.py b/models/main_models/rt1/rt1_env/bin/jp.py new file mode 100755 index 000000000..2a3859f1f --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/jp.py @@ -0,0 +1,54 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 + +import sys +import json +import argparse +from pprint import pformat + +import jmespath +from jmespath import exceptions + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('expression') + parser.add_argument('-f', '--filename', + help=('The filename containing the input data. ' + 'If a filename is not given then data is ' + 'read from stdin.')) + parser.add_argument('--ast', action='store_true', + help=('Pretty print the AST, do not search the data.')) + args = parser.parse_args() + expression = args.expression + if args.ast: + # Only print the AST + expression = jmespath.compile(args.expression) + sys.stdout.write(pformat(expression.parsed)) + sys.stdout.write('\n') + return 0 + if args.filename: + with open(args.filename, 'r') as f: + data = json.load(f) + else: + data = sys.stdin.read() + data = json.loads(data) + try: + sys.stdout.write(json.dumps( + jmespath.search(expression, data), indent=4, ensure_ascii=False)) + sys.stdout.write('\n') + except exceptions.ArityError as e: + sys.stderr.write("invalid-arity: %s\n" % e) + return 1 + except exceptions.JMESPathTypeError as e: + sys.stderr.write("invalid-type: %s\n" % e) + return 1 + except exceptions.UnknownFunctionError as e: + sys.stderr.write("unknown-function: %s\n" % e) + return 1 + except exceptions.ParseError as e: + sys.stderr.write("syntax-error: %s\n" % e) + return 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/lsm2bin b/models/main_models/rt1/rt1_env/bin/lsm2bin new file mode 100755 index 000000000..a4b517af7 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/lsm2bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.lsm2bin import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/markdown-it b/models/main_models/rt1/rt1_env/bin/markdown-it new file mode 100755 index 000000000..e58e8d1e4 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/markdown-it @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from markdown_it.cli.parse import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/markdown_py b/models/main_models/rt1/rt1_env/bin/markdown_py new file mode 100755 index 000000000..8424ab33e --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/markdown_py @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from markdown.__main__ import run +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run()) diff --git a/models/main_models/rt1/rt1_env/bin/normalizer b/models/main_models/rt1/rt1_env/bin/normalizer new file mode 100755 index 000000000..e3a575f79 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/normalizer @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from charset_normalizer.cli import cli_detect +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli_detect()) diff --git a/models/main_models/rt1/rt1_env/bin/pip b/models/main_models/rt1/rt1_env/bin/pip new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pip @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pip3 b/models/main_models/rt1/rt1_env/bin/pip3 new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pip3 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pip3.9 b/models/main_models/rt1/rt1_env/bin/pip3.9 new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pip3.9 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/portserver.py b/models/main_models/rt1/rt1_env/bin/portserver.py new file mode 100755 index 000000000..6cdc3c0f3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/portserver.py @@ -0,0 +1,415 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +# +# Copyright 2015 Google Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +"""A server to hand out network ports to applications running on one host. + +Typical usage: + 1) Run one instance of this process on each of your unittest farm hosts. + 2) Set the PORTSERVER_ADDRESS environment variable in your test runner + environment to let the portpicker library know to use a port server + rather than attempt to find ports on its own. + +$ /path/to/portserver.py & +$ export PORTSERVER_ADDRESS=@unittest-portserver +$ # ... launch a bunch of unittest runners using portpicker ... +""" + +import argparse +import asyncio +import collections +import logging +import signal +import socket +import sys +import psutil +import subprocess +from datetime import datetime, timezone, timedelta + +log = None # Initialized to a logging.Logger by _configure_logging(). + +_PROTOS = [(socket.SOCK_STREAM, socket.IPPROTO_TCP), + (socket.SOCK_DGRAM, socket.IPPROTO_UDP)] + + +def _get_process_command_line(pid): + try: + return psutil.Process(pid).cmdline() + except psutil.NoSuchProcess: + return '' + + +def _get_process_start_time(pid): + try: + return psutil.Process(pid).create_time() + except psutil.NoSuchProcess: + return 0.0 + + +# TODO: Consider importing portpicker.bind() instead of duplicating the code. +def _bind(port, socket_type, socket_proto): + """Try to bind to a socket of the specified type, protocol, and port. + + For the port to be considered available, the kernel must support at least + one of (IPv6, IPv4), and the port must be available on each supported + family. + + Args: + port: The port number to bind to, or 0 to have the OS pick a free port. + socket_type: The type of the socket (ex: socket.SOCK_STREAM). + socket_proto: The protocol of the socket (ex: socket.IPPROTO_TCP). + + Returns: + The port number on success or None on failure. + """ + got_socket = False + for family in (socket.AF_INET6, socket.AF_INET): + try: + sock = socket.socket(family, socket_type, socket_proto) + got_socket = True + except socket.error: + continue + try: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + sock.bind(('', port)) + if socket_type == socket.SOCK_STREAM: + sock.listen(1) + port = sock.getsockname()[1] + except socket.error: + return None + finally: + sock.close() + return port if got_socket else None + + +def _is_port_free(port): + """Check if specified port is free. + + Args: + port: integer, port to check + Returns: + boolean, whether it is free to use for both TCP and UDP + """ + return _bind(port, *_PROTOS[0]) and _bind(port, *_PROTOS[1]) + + +def _should_allocate_port(pid): + """Determine if we should allocate a port for use by the given process id.""" + if pid <= 0: + log.info('Not allocating a port to invalid pid') + return False + if pid == 1: + # The client probably meant to send us its parent pid but + # had been reparented to init. + log.info('Not allocating a port to init.') + return False + + if not psutil.pid_exists(pid): + log.info('Not allocating a port to a non-existent process') + return False + return True + + +async def _start_windows_server(client_connected_cb, path): + """Start the server on Windows using named pipes.""" + def protocol_factory(): + stream_reader = asyncio.StreamReader() + stream_reader_protocol = asyncio.StreamReaderProtocol( + stream_reader, client_connected_cb) + return stream_reader_protocol + + loop = asyncio.get_event_loop() + server, *_ = await loop.start_serving_pipe(protocol_factory, address=path) + + return server + + +class _PortInfo(object): + """Container class for information about a given port assignment. + + Attributes: + port: integer port number + pid: integer process id or 0 if unassigned. + start_time: Time in seconds since the epoch that the process started. + """ + + __slots__ = ('port', 'pid', 'start_time') + + def __init__(self, port): + self.port = port + self.pid = 0 + self.start_time = 0.0 + + +class _PortPool(object): + """Manage available ports for processes. + + Ports are reclaimed when the reserving process exits and the reserved port + is no longer in use. Only ports which are free for both TCP and UDP will be + handed out. It is easier to not differentiate between protocols. + + The pool must be pre-seeded with add_port_to_free_pool() calls + after which get_port_for_process() will allocate and reclaim ports. + The len() of a _PortPool returns the total number of ports being managed. + + Attributes: + ports_checked_for_last_request: The number of ports examined in order to + return from the most recent get_port_for_process() request. A high + number here likely means the number of available ports with no active + process using them is getting low. + """ + + def __init__(self): + self._port_queue = collections.deque() + self.ports_checked_for_last_request = 0 + + def num_ports(self): + return len(self._port_queue) + + def get_port_for_process(self, pid): + """Allocates and returns port for pid or 0 if none could be allocated.""" + if not self._port_queue: + raise RuntimeError('No ports being managed.') + + # Avoid an infinite loop if all ports are currently assigned. + check_count = 0 + max_ports_to_test = len(self._port_queue) + while check_count < max_ports_to_test: + # Get the next candidate port and move it to the back of the queue. + candidate = self._port_queue.pop() + self._port_queue.appendleft(candidate) + check_count += 1 + if (candidate.start_time == 0.0 or + candidate.start_time != _get_process_start_time(candidate.pid)): + if _is_port_free(candidate.port): + candidate.pid = pid + candidate.start_time = _get_process_start_time(pid) + if not candidate.start_time: + log.info("Can't read start time for pid %d.", pid) + self.ports_checked_for_last_request = check_count + return candidate.port + else: + log.info( + 'Port %d unexpectedly in use, last owning pid %d.', + candidate.port, candidate.pid) + + log.info('All ports in use.') + self.ports_checked_for_last_request = check_count + return 0 + + def add_port_to_free_pool(self, port): + """Add a new port to the free pool for allocation.""" + if port < 1 or port > 65535: + raise ValueError( + 'Port must be in the [1, 65535] range, not %d.' % port) + port_info = _PortInfo(port=port) + self._port_queue.append(port_info) + + +class _PortServerRequestHandler(object): + """A class to handle port allocation and status requests. + + Allocates ports to process ids via the dead simple port server protocol + when the handle_port_request asyncio.coroutine handler has been registered. + Statistics can be logged using the dump_stats method. + """ + + def __init__(self, ports_to_serve): + """Initialize a new port server. + + Args: + ports_to_serve: A sequence of unique port numbers to test and offer + up to clients. + """ + self._port_pool = _PortPool() + self._total_allocations = 0 + self._denied_allocations = 0 + self._client_request_errors = 0 + for port in ports_to_serve: + self._port_pool.add_port_to_free_pool(port) + + async def handle_port_request(self, reader, writer): + client_data = await reader.read(100) + self._handle_port_request(client_data, writer) + writer.close() + + def _handle_port_request(self, client_data, writer): + """Given a port request body, parse it and respond appropriately. + + Args: + client_data: The request bytes from the client. + writer: The asyncio Writer for the response to be written to. + """ + try: + if len(client_data) > 20: + raise ValueError('More than 20 characters in "pid".') + pid = int(client_data) + except ValueError as error: + self._client_request_errors += 1 + log.warning('Could not parse request: %s', error) + return + + log.info('Request on behalf of pid %d.', pid) + log.info('cmdline: %s', _get_process_command_line(pid)) + + if not _should_allocate_port(pid): + self._denied_allocations += 1 + return + + port = self._port_pool.get_port_for_process(pid) + if port > 0: + self._total_allocations += 1 + writer.write('{:d}\n'.format(port).encode('utf-8')) + log.debug('Allocated port %d to pid %d', port, pid) + else: + self._denied_allocations += 1 + + def dump_stats(self): + """Logs statistics of our operation.""" + log.info('Dumping statistics:') + stats = [] + stats.append( + 'client-request-errors {}'.format(self._client_request_errors)) + stats.append('denied-allocations {}'.format(self._denied_allocations)) + stats.append('num-ports-managed {}'.format(self._port_pool.num_ports())) + stats.append('num-ports-checked-for-last-request {}'.format( + self._port_pool.ports_checked_for_last_request)) + stats.append('total-allocations {}'.format(self._total_allocations)) + for stat in stats: + log.info(stat) + + +def _parse_command_line(): + """Configure and parse our command line flags.""" + parser = argparse.ArgumentParser() + parser.add_argument( + '--portserver_static_pool', + type=str, + default='15000-24999', + help='Comma separated N-P Range(s) of ports to manage (inclusive).') + parser.add_argument( + '--portserver_address', + '--portserver_unix_socket_address', # Alias to be backward compatible + type=str, + default='@unittest-portserver', + help='Address of AF_UNIX socket on which to listen on Unix (first @ is ' + 'a NUL) or the name of the pipe on Windows (first @ is the ' + r'\\.\pipe\ prefix).') + parser.add_argument('--verbose', + action='store_true', + default=False, + help='Enable verbose messages.') + parser.add_argument('--debug', + action='store_true', + default=False, + help='Enable full debug messages.') + return parser.parse_args(sys.argv[1:]) + + +def _parse_port_ranges(pool_str): + """Given a 'N-P,X-Y' description of port ranges, return a set of ints.""" + ports = set() + for range_str in pool_str.split(','): + try: + a, b = range_str.split('-', 1) + start, end = int(a), int(b) + except ValueError: + log.error('Ignoring unparsable port range %r.', range_str) + continue + if start < 1 or end > 65535: + log.error('Ignoring out of bounds port range %r.', range_str) + continue + ports.update(set(range(start, end + 1))) + return ports + + +def _configure_logging(verbose=False, debug=False): + """Configure the log global, message format, and verbosity settings.""" + overall_level = logging.DEBUG if debug else logging.INFO + logging.basicConfig( + format=('{levelname[0]}{asctime}.{msecs:03.0f} {thread} ' + '{filename}:{lineno}] {message}'), + datefmt='%m%d %H:%M:%S', + style='{', + level=overall_level) + global log + log = logging.getLogger('portserver') + # The verbosity controls our loggers logging level, not the global + # one above. This avoids debug messages from libraries such as asyncio. + log.setLevel(logging.DEBUG if verbose else overall_level) + + +def main(): + config = _parse_command_line() + if config.debug: + # Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access + asyncio.tasks._DEBUG = True + _configure_logging(verbose=config.verbose, debug=config.debug) + ports_to_serve = _parse_port_ranges(config.portserver_static_pool) + if not ports_to_serve: + log.error('No ports. Invalid port ranges in --portserver_static_pool?') + sys.exit(1) + + request_handler = _PortServerRequestHandler(ports_to_serve) + + if sys.platform == 'win32': + asyncio.set_event_loop(asyncio.ProactorEventLoop()) + + event_loop = asyncio.get_event_loop() + + if sys.platform == 'win32': + # On Windows, we need to periodically pause the loop to allow the user + # to send a break signal (e.g. ctrl+c) + def listen_for_signal(): + event_loop.call_later(0.5, listen_for_signal) + + event_loop.call_later(0.5, listen_for_signal) + + coro = _start_windows_server( + request_handler.handle_port_request, + path=config.portserver_address.replace('@', '\\\\.\\pipe\\', 1)) + else: + event_loop.add_signal_handler( + signal.SIGUSR1, request_handler.dump_stats) # pylint: disable=no-member + + old_py_loop = {'loop': event_loop} if sys.version_info < (3, 10) else {} + coro = asyncio.start_unix_server( + request_handler.handle_port_request, + path=config.portserver_address.replace('@', '\0', 1), + **old_py_loop) + + server_address = config.portserver_address + + server = event_loop.run_until_complete(coro) + log.info('Serving on %s', server_address) + try: + event_loop.run_forever() + except KeyboardInterrupt: + log.info('Stopping due to ^C.') + + server.close() + + if sys.platform != 'win32': + # PipeServer doesn't have a wait_closed() function + event_loop.run_until_complete(server.wait_closed()) + event_loop.remove_signal_handler(signal.SIGUSR1) # pylint: disable=no-member + + event_loop.close() + request_handler.dump_stats() + log.info('Goodbye.') + + +if __name__ == '__main__': + main() diff --git a/models/main_models/rt1/rt1_env/bin/progressbar b/models/main_models/rt1/rt1_env/bin/progressbar new file mode 100755 index 000000000..1136ebc7c --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/progressbar @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from progressbar.__main__ import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pygmentize b/models/main_models/rt1/rt1_env/bin/pygmentize new file mode 100755 index 000000000..623ccdf50 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pygmentize @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pygments.cmdline import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/python b/models/main_models/rt1/rt1_env/bin/python new file mode 120000 index 000000000..b8a0adbbb --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/python @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/python3 b/models/main_models/rt1/rt1_env/bin/python3 new file mode 120000 index 000000000..ae65fdaa1 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/python3 @@ -0,0 +1 @@ +/usr/bin/python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/python3.9 b/models/main_models/rt1/rt1_env/bin/python3.9 new file mode 120000 index 000000000..b8a0adbbb --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/python3.9 @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/pythoni b/models/main_models/rt1/rt1_env/bin/pythoni new file mode 100755 index 000000000..2d650f825 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pythoni @@ -0,0 +1,36 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 + +# Copyright 2000-2002 Michael Hudson mwh@python.net +# +# All Rights Reserved +# +# +# Permission to use, copy, modify, and distribute this software and +# its documentation for any purpose is hereby granted without fee, +# provided that the above copyright notice appear in all copies and +# that both that copyright notice and this permission notice appear in +# supporting documentation. +# +# THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO +# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +# AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, +# INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER +# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF +# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +import locale, pdb, sys +# I forget exactly why this is necessary: +try: + locale.setlocale(locale.LC_ALL, '') +except locale.Error: + pass # oh well + + +from pyrepl.python_reader import main +from pyrepl import cmdrepl + +# whizzy feature: graft pyrepl support onto pdb +#pdb.Pdb = cmdrepl.replize(pdb.Pdb, 1) + +main(use_pygame_console=('pg' in sys.argv)) diff --git a/models/main_models/rt1/rt1_env/bin/pythoni1 b/models/main_models/rt1/rt1_env/bin/pythoni1 new file mode 100755 index 000000000..f0a75c79d --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pythoni1 @@ -0,0 +1,17 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +""" This is an alternative to pythoni which tries to look like the +CPython prompt as much as possible, with the exception of allowing +multiline input and multiline history entries. +""" + +import os, sys +from pyrepl import readline +from pyrepl.simple_interact import run_multiline_interactive_console + +sys.modules['readline'] = readline + +if os.getenv('PYTHONSTARTUP'): + execfile(os.getenv('PYTHONSTARTUP')) + +print 'Python', sys.version +run_multiline_interactive_console() diff --git a/models/main_models/rt1/rt1_env/bin/reverb_server b/models/main_models/rt1/rt1_env/bin/reverb_server new file mode 100755 index 000000000..b9d8a78f5 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/reverb_server @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from reverb.server_executable.server_main import app_run_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(app_run_main()) diff --git a/models/main_models/rt1/rt1_env/bin/saved_model_cli b/models/main_models/rt1/rt1_env/bin/saved_model_cli new file mode 100755 index 000000000..44f84317c --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/saved_model_cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.python.tools.saved_model_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tensorboard b/models/main_models/rt1/rt1_env/bin/tensorboard new file mode 100755 index 000000000..2ee3b3204 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tensorboard @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorboard.main import run_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run_main()) diff --git a/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 b/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 new file mode 100755 index 000000000..aee84bff1 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.tools.compatibility.tf_upgrade_v2_main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tfds b/models/main_models/rt1/rt1_env/bin/tfds new file mode 100755 index 000000000..0f5636bc8 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tfds @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow_datasets.scripts.cli.main import launch_cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_cli()) diff --git a/models/main_models/rt1/rt1_env/bin/tflite_convert b/models/main_models/rt1/rt1_env/bin/tflite_convert new file mode 100755 index 000000000..0ebb370c7 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tflite_convert @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.python.tflite_convert import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tiff2fsspec b/models/main_models/rt1/rt1_env/bin/tiff2fsspec new file mode 100755 index 000000000..72322f48d --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tiff2fsspec @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.tiff2fsspec import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tiffcomment b/models/main_models/rt1/rt1_env/bin/tiffcomment new file mode 100755 index 000000000..81e89dd82 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tiffcomment @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.tiffcomment import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tifffile b/models/main_models/rt1/rt1_env/bin/tifffile new file mode 100755 index 000000000..024aaecb3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tifffile @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/toco b/models/main_models/rt1/rt1_env/bin/toco new file mode 100755 index 000000000..0ebb370c7 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/toco @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.python.tflite_convert import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/toco_from_protos b/models/main_models/rt1/rt1_env/bin/toco_from_protos new file mode 100755 index 000000000..4a0931477 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/toco_from_protos @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.toco.python.toco_from_protos import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/torchrun b/models/main_models/rt1/rt1_env/bin/torchrun new file mode 100755 index 000000000..bbd4216d0 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/torchrun @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from torch.distributed.run import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tqdm b/models/main_models/rt1/rt1_env/bin/tqdm new file mode 100755 index 000000000..52aa9b22d --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tqdm @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tqdm.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/transformers-cli b/models/main_models/rt1/rt1_env/bin/transformers-cli new file mode 100755 index 000000000..3cb3dba5c --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/transformers-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from transformers.commands.transformers_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tree-cli b/models/main_models/rt1/rt1_env/bin/tree-cli new file mode 100755 index 000000000..822fcbe27 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tree-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from Tree.cli import create_tree +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(create_tree()) diff --git a/models/main_models/rt1/rt1_env/bin/wandb b/models/main_models/rt1/rt1_env/bin/wandb new file mode 100755 index 000000000..ad3846609 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/wandb @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wandb.cli.cli import cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli()) diff --git a/models/main_models/rt1/rt1_env/bin/wb b/models/main_models/rt1/rt1_env/bin/wb new file mode 100755 index 000000000..ad3846609 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/wb @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wandb.cli.cli import cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli()) diff --git a/models/main_models/rt1/rt1_env/bin/wheel b/models/main_models/rt1/rt1_env/bin/wheel new file mode 100755 index 000000000..47a52e82e --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/wheel @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wheel.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto new file mode 100644 index 000000000..39512921e --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto @@ -0,0 +1,77 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "reverb/cc/schema.proto"; +import "tensorflow/core/protobuf/struct.proto"; + +// Configs for reconstructing a distribution to its initial state. + +// Next ID: 11. +message PriorityTableCheckpoint { + // Name of the table. + string table_name = 1; + + // Maximum number of items in the table. + // If an insert would result in this value getting exceeded, `remover` is used + // to select an item to remove before proceeding with the insert. + int64 max_size = 6; + + // The maximum number of times an item can be sampled before being removed. + int32 max_times_sampled = 7; + + // Items in the table ordered by `inserted_at` (asc). + // When loading a checkpoint the items should be added in the same order so + // position based item selectors (e.g fifo) are reconstructed correctly. + // + // *NOTE*: This field is deprecated; instead, a separate record file is + // written with PrioritizedItem records for checkpointing (in the same + // order as described here). + repeated PrioritizedItem deprecated_items = 2 [deprecated = true]; + + // Checkpoint of the associated rate limiter. + RateLimiterCheckpoint rate_limiter = 3; + + // Options for constructing new samplers and removers of the correct type. + // Note that this does not include the state that they currently hold as it + // will be reproduced using the order of `items. + KeyDistributionOptions sampler = 4; + KeyDistributionOptions remover = 5; + + // The total number of episodes that were at some point referenced by items + // in the table but have since been removed. + int64 num_deleted_episodes = 8; + + // Optional data signature for tensors stored in the table. + tensorflow.StructuredValue signature = 9; + + // Number of unique items sampled from the table since the last reset. + int64 num_unique_samples = 10; +} + +message RateLimiterCheckpoint { + reserved 1; // Deprecated field `name`. + + // The average number of times each item should be sampled during its + // lifetime. + double samples_per_insert = 2; + + // The minimum and maximum values the cursor is allowed to reach. The cursor + // value is calculated as `insert_count * samples_per_insert - + // sample_count`. If the value would go beyond these limits then the call is + // blocked until it can proceed without violating the constraints. + double min_diff = 3; + double max_diff = 4; + + // The minimum number of inserts required before any sample operation. + int64 min_size_to_sample = 5; + + // The total number of samples that occurred before the checkpoint. + int64 sample_count = 6; + + // The total number of inserts that occurred before the checkpoint. + int64 insert_count = 7; + + // The total number of deletes that occurred before the checkpoint. + int64 delete_count = 8; +} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto new file mode 100644 index 000000000..3428db5a5 --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto @@ -0,0 +1,123 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "tensorflow/core/protobuf/struct.proto"; + +message PatternNode { + // Index of the source column in the flattened step structure. + int32 flat_source_index = 1; + + // Slicing of the source column relative to the most recent step. + // + // These fields mimics the behavior of `slice` in Python. That is: + // + // * x[-1:] => (start=-1, stop=null) + // * x[-2] => (start=null, stop=-2) + // * x[-3:-1] => (start=-3, stop=-1) + // * x[-3:-1:2] => (start=-3, stop=-1, step=2) + // + // Furthermore, the following requirements applies: + // + // * Slices with undefined `start` (e.g. x[:-2]) are not supported. + // * For slices, `start` must be < 0 and `stop` must be <= 0. + // * `step` must be > 0 when defined. + // + oneof start_or_none { + int32 start = 2; + } + oneof stop_or_none { + int32 stop = 3; + } + oneof step_or_none { + int32 step = 4; + } +} + +message Condition { + // Given int32 `left`: `left % mod == eq`. + message ModuloEq { + int32 mod = 1; + int32 eq = 2; + } + + oneof left { + // The index of the most recent step within the episode. + bool step_index = 1; + + // The number of steps since the pattern was most recently applied. + bool steps_since_applied = 2; + + // The number of steps currently held by the buffer. + bool buffer_length = 3; + + // Set to 1 when `EndEpisode` is called, else 0. + bool is_end_episode = 4; + + // Extract scalar integer value from a column in the most recent step. If + // the column is not present in the data or it isn't a scalar of a supported + // type then the condition will return false. + // + // All integer types are casted to int32 and bool is converted to 1 if true + // and 0 if false. + // + int32 flat_source_index = 9; + } + + // TODO(b/205278205): Remove le and just use inverse + ge instead. + oneof cmp { + // `left == eq`. + int32 eq = 5; + + // `left >= ge`. + int32 ge = 6; + + // `left % mod_eq.mod == mod_eq.eq`. + ModuloEq mod_eq = 7; + } + + // Whether the condition result should be inversed. + bool inverse = 8; +} + +message Priority { + // Priority function that always return the same value. + message ConstantPriorityFn { + // Value to be returned by the priority function. + double value = 1; + } + + // Priority function that computes the trajectory TD Error using the per-step + // TD Error. See details of the TD Error in + // https://openreview.net/pdf?id=r1lyTjAqYX. + message TDError { + // Weight for the max priority in the TD Error computation. + double max_priority_weight = 1; + // Index of the field in the input step that contais the per-step TD Error. + int32 flat_source_index = 2; + } + + oneof priority_fn { + ConstantPriorityFn constant_fn = 1; + TDError td_error = 2; + } +} + +message StructuredWriterConfig { + // Flattened output structure. + repeated PatternNode flat = 1; + + // Serialised structure of the pattern. All leaf nodes must be None. If empty + // then pattern will be treated as a flat list. + tensorflow.StructuredValue pattern_structure = 2; + + // The table that generated trajectories will be inserted into. + string table = 3; + + // The priority assigned to all trajectories generated by this config. + Priority priority = 4; + + // Conditions which must be fulfilled for the configuration to be applied at + // the current step. + repeated Condition conditions = 5; +} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto new file mode 100644 index 000000000..a14a6ce56 --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto @@ -0,0 +1,10 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "reverb/cc/checkpointing/checkpoint.proto"; + +message ReverbServerConfig { + repeated PriorityTableCheckpoint tables = 1; + int32 port = 2; +} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto new file mode 100644 index 000000000..3c37454c3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto @@ -0,0 +1,289 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "google/protobuf/timestamp.proto"; +import "tensorflow/core/framework/tensor.proto"; +import "tensorflow/core/protobuf/struct.proto"; + +// The actual data is stored in chunks. The data can be arbitrary tensors. We do +// not interpret the bytes data of the tensors on the server side. It is up to +// the client to compress the bytes blob within the tensors. +message ChunkData { + // Unique identifier of the chunk. + uint64 chunk_key = 1; + + // The timesteps within the episode that the chunk covers. + SequenceRange sequence_range = 2; + + // Actual tensor data. + message Data { + repeated tensorflow.TensorProto tensors = 1; + } + Data data = 5 [lazy = true]; + + // Number of tensors in the data field. Set explicitly so that Reverb server + // can check it without accessing lazy data field (which is expensive to + // parse). + int32 data_tensors_len = 6; + + // Size of the tensors in `data` before compression. + int64 data_uncompressed_size = 7; + + // True if delta encoding has been applied before compressing data. + bool delta_encoded = 4; + + // Deprecated December 2020 and retained to provide backward + // compatibility with checkpoints created before this point. + repeated tensorflow.TensorProto deprecated_data = 3 [deprecated = true]; +} + +// A range that specifies which items to slice out from a sequence of chunks. +// The length of all chunks must at least be `offset`+`length`. +message SliceRange { + // Offset where the slice should start. + int32 offset = 1; + + // Length of the slice. Can span multiple chunks. + int32 length = 2; +} + +message SequenceRange { + // Globally unique identifier of the episode the sequence belongs to. + uint64 episode_id = 1; + + // Index within the episode of the first timestep covered by the range. + int32 start = 2; + + // Index within the episode of the last timestep covered by the range. + // Must be >= start_index. + int32 end = 3; + + // If set then at least one step is missing from the data. The number of steps + // (i.e batch size) present in the data is unknown and thus must be manually + // checked. However, the `start` and `end` step is guaranteed to be at first + // and last position in the data. + bool sparse = 4; +} + +message FlatTrajectory { + message ChunkSlice { + // Unique identifier of the ChunkData which owns the compressed data. + uint64 chunk_key = 1; + + // Index of the first element in the chunk to include. + int32 offset = 2; + + // Number of elements from the chunk to include. + int32 length = 3; + + // Tensor index of the tensor within the chunk. + int32 index = 4; + } + + message Column { + // Chunk slices to concat. + repeated ChunkSlice chunk_slices = 1; + + // If true then the batch dim (must be 1) is emitted when unpacked. + // Requires that column is made up of exactly one ChunkSlice of length 1. + bool squeeze = 2; + } + + // Flattened columns of the trajectory. + repeated Column columns = 1; +} + +// A prioritized item is part of a table and references a chunk of +// data. Sampling happens based on the priority of items. +// +// Next ID: 9. +// LINT.IfChange +message PrioritizedItem { + // Unique identifier of this item. + uint64 key = 1; + + // Priority table that the item belongs to. + string table = 2; + + // Priority used for sampling. + double priority = 5; + + // The number of times the item has been sampled. + int32 times_sampled = 6; + + // The time when the item was first inserted. + google.protobuf.Timestamp inserted_at = 7; + + // Flattened representation of item's trajectory. + FlatTrajectory flat_trajectory = 8; + + // Deprecated January 2021 and retained to provide backward compatibility + // with checkpoints created before this point. + repeated uint64 deprecated_chunk_keys = 3 [deprecated = true]; + SliceRange deprecated_sequence_range = 4 [deprecated = true]; +} +// LINT.ThenChange(reverb_service_impl.cc) + +// Used for updating an existing PrioritizedItem. +message KeyWithPriority { + // Identifier of the PrioritizedItem. + uint64 key = 1; + + // Priority used for sampling. + double priority = 2; +} + +message SampleInfo { + // Item from that was sampled from the table. + PrioritizedItem item = 1; + + // Probability that this item had at sampling time. Useful for importance + // sampling. + double probability = 2; + + // Number of items in the table at the time of the sample operation. + int64 table_size = 3; + + // Whether the sample was delayed due to rate limiting of the sampler. + bool rate_limited = 4; +} + +// LINT.IfChange +// Metadata about the table, including (optional) data signature. +// +// These fields correspond to initialization arguments of the +// `Table` class, unless noted otherwise. +// +// Next ID: 13. +message TableInfo { + // Table's name. + string name = 8; + + // Sampler and remover metadata. + KeyDistributionOptions sampler_options = 1; + KeyDistributionOptions remover_options = 2; + + // Max size of the table. + int64 max_size = 3; + + // Max number of times an element can be sampled before being + // removed. + int32 max_times_sampled = 4; + + // How data read/write is rate limited. + RateLimiterInfo rate_limiter_info = 5; + + // Optional data signature for tensors stored in the table. Note + // that this data type is more flexible than we use. For example, + // we only store tensors (TensorSpecProto, TypeSpecProto) and not + // any special data types (no NoneValue or other special fixed values). + tensorflow.StructuredValue signature = 6; + + // Current size of table. + int64 current_size = 7; + + // Number of episodes referenced by the items in the table. + int64 num_episodes = 9; + + // Number of episodes once referenced by items in the table but no longer is. + // The total number of episodes thus is `num_episodes + num_deleted_episodes`. + int64 num_deleted_episodes = 10; + + // Number of unique items sampled from the table since the last reset. + int64 num_unique_samples = 11; + + // Table worker execution time distribution. + TableWorkerTime table_worker_time = 12; +} +// LINT.ThenChange(../py/reverb/reverb_types.py) + +message RateLimiterCallStats { + // The total number of completed calls. + int64 completed = 2; + + reserved 1, 3, 4, 5; +} + +message RateLimiterInfo { + // The average number of times each item should be sampled during its + // lifetime. + double samples_per_insert = 1; + + // The minimum and maximum values the cursor is allowed to reach. The cursor + // value is calculated as `insert_count * samples_per_insert - + // sample_count`. If the value would go beyond these limits then the call is + // blocked until it can proceed without violating the constraints. + double min_diff = 2; + double max_diff = 3; + + // The minimum number of inserts required before any sample operation. + int64 min_size_to_sample = 4; + + // Stats regarding the limiting of insert calls. + RateLimiterCallStats insert_stats = 5; + + // Stats regarding the limiting of sample calls. + RateLimiterCallStats sample_stats = 6; +} + +message TableWorkerTime { + // Cumulative time the table worker is performing general work. + int64 running_ms = 1; + + // Cumulative time the table worker is actively processing sampling requests. + int64 sampling_ms = 2; + + // Cumulative time the table worker is actively processing insert requests. + int64 inserting_ms = 3; + + // Cumulative time the table worker is sleeping as there is no work to do + // (there are no pending insert/sample requests to process). + int64 sleeping_ms = 4; + + // Cumulative time the table worker is blocked waiting for sampling requests + // There are pending insert requests which are blocked by the rate limiter, + // while there are no sampling requests which could unblock inserts. + // The system can't make further progress and the worker is put to sleep until + // sample request arives. + int64 waiting_for_sampling_ms = 5; + + // Cumulative time the table worker is blocked waiting for insert requests + // There are pending sample requests which are blocked by the rate + // limiter, while there are no insert requests which could unblock sampling. + // The system can't make further progress and the worker is put to sleep until + // insert request arives. + int64 waiting_for_inserts_ms = 6; +} + +// Metadata about sampler or remover. Describes its configuration. +message KeyDistributionOptions { + message Prioritized { + double priority_exponent = 1; + } + + message Heap { + bool min_heap = 1; + } + + oneof distribution { + bool fifo = 1; + bool uniform = 2; + Prioritized prioritized = 3; + Heap heap = 4; + bool lifo = 6; + } + reserved 5; + bool is_deterministic = 7; +} + +// Uint128 representation. Can be used for unique identifiers. +message Uint128 { + uint64 high = 1; + uint64 low = 2; +} + +// Representation of a timeout. A value < 0 means never time out. +message Timeout { + int64 milliseconds = 1; +} diff --git a/models/main_models/rt1/rt1_env/lib64 b/models/main_models/rt1/rt1_env/lib64 new file mode 120000 index 000000000..7951405f8 --- /dev/null +++ b/models/main_models/rt1/rt1_env/lib64 @@ -0,0 +1 @@ +lib \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/pyvenv.cfg b/models/main_models/rt1/rt1_env/pyvenv.cfg new file mode 100644 index 000000000..1997c5b53 --- /dev/null +++ b/models/main_models/rt1/rt1_env/pyvenv.cfg @@ -0,0 +1,3 @@ +home = /usr/bin +include-system-site-packages = false +version = 3.9.16 diff --git a/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 b/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 new file mode 100644 index 000000000..0ff966158 --- /dev/null +++ b/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 @@ -0,0 +1,188 @@ +'\" -*- coding: us-ascii -*- +.if \n(.g .ds T< \\FC +.if \n(.g .ds T> \\F[\n[.fam]] +.de URL +\\$2 \(la\\$1\(ra\\$3 +.. +.if \n(.g .mso www.tmac +.TH isympy 1 2007-10-8 "" "" +.SH NAME +isympy \- interactive shell for SymPy +.SH SYNOPSIS +'nh +.fi +.ad l +\fBisympy\fR \kx +.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) +'in \n(.iu+\nxu +[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [ +-- | PYTHONOPTIONS] +'in \n(.iu-\nxu +.ad b +'hy +'nh +.fi +.ad l +\fBisympy\fR \kx +.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) +'in \n(.iu+\nxu +[ +{\fB-h\fR | \fB--help\fR} +| +{\fB-v\fR | \fB--version\fR} +] +'in \n(.iu-\nxu +.ad b +'hy +.SH DESCRIPTION +isympy is a Python shell for SymPy. It is just a normal python shell +(ipython shell if you have the ipython package installed) that executes +the following commands so that you don't have to: +.PP +.nf +\*(T< +>>> from __future__ import division +>>> from sympy import * +>>> x, y, z = symbols("x,y,z") +>>> k, m, n = symbols("k,m,n", integer=True) + \*(T> +.fi +.PP +So starting isympy is equivalent to starting python (or ipython) and +executing the above commands by hand. It is intended for easy and quick +experimentation with SymPy. For more complicated programs, it is recommended +to write a script and import things explicitly (using the "from sympy +import sin, log, Symbol, ..." idiom). +.SH OPTIONS +.TP +\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR +Use the specified shell (python or ipython) as +console backend instead of the default one (ipython +if present or python otherwise). + +Example: isympy -c python + +\fISHELL\fR could be either +\&'ipython' or 'python' +.TP +\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR +Setup pretty printing in SymPy. By default, the most pretty, unicode +printing is enabled (if the terminal supports it). You can use less +pretty ASCII printing instead or no pretty printing at all. + +Example: isympy -p no + +\fIENCODING\fR must be one of 'unicode', +\&'ascii' or 'no'. +.TP +\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR +Setup the ground types for the polys. By default, gmpy ground types +are used if gmpy2 or gmpy is installed, otherwise it falls back to python +ground types, which are a little bit slower. You can manually +choose python ground types even if gmpy is installed (e.g., for testing purposes). + +Note that sympy ground types are not supported, and should be used +only for experimental purposes. + +Note that the gmpy1 ground type is primarily intended for testing; it the +use of gmpy even if gmpy2 is available. + +This is the same as setting the environment variable +SYMPY_GROUND_TYPES to the given ground type (e.g., +SYMPY_GROUND_TYPES='gmpy') + +The ground types can be determined interactively from the variable +sympy.polys.domains.GROUND_TYPES inside the isympy shell itself. + +Example: isympy -t python + +\fITYPE\fR must be one of 'gmpy', +\&'gmpy1' or 'python'. +.TP +\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR +Setup the ordering of terms for printing. The default is lex, which +orders terms lexicographically (e.g., x**2 + x + 1). You can choose +other orderings, such as rev-lex, which will use reverse +lexicographic ordering (e.g., 1 + x + x**2). + +Note that for very large expressions, ORDER='none' may speed up +printing considerably, with the tradeoff that the order of the terms +in the printed expression will have no canonical order + +Example: isympy -o rev-lax + +\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex', +\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'. +.TP +\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T> +Print only Python's and SymPy's versions to stdout at startup, and nothing else. +.TP +\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T> +Use the same format that should be used for doctests. This is +equivalent to '\fIisympy -c python -p no\fR'. +.TP +\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T> +Disable the caching mechanism. Disabling the cache may slow certain +operations down considerably. This is useful for testing the cache, +or for benchmarking, as the cache can result in deceptive benchmark timings. + +This is the same as setting the environment variable SYMPY_USE_CACHE +to 'no'. +.TP +\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T> +Automatically create missing symbols. Normally, typing a name of a +Symbol that has not been instantiated first would raise NameError, +but with this option enabled, any undefined name will be +automatically created as a Symbol. This only works in IPython 0.11. + +Note that this is intended only for interactive, calculator style +usage. In a script that uses SymPy, Symbols should be instantiated +at the top, so that it's clear what they are. + +This will not override any names that are already defined, which +includes the single character letters represented by the mnemonic +QCOSINE (see the "Gotchas and Pitfalls" document in the +documentation). You can delete existing names by executing "del +name" in the shell itself. You can see if a name is defined by typing +"'name' in globals()". + +The Symbols that are created using this have default assumptions. +If you want to place assumptions on symbols, you should create them +using symbols() or var(). + +Finally, this only works in the top level namespace. So, for +example, if you define a function in isympy with an undefined +Symbol, it will not work. +.TP +\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T> +Enable debugging output. This is the same as setting the +environment variable SYMPY_DEBUG to 'True'. The debug status is set +in the variable SYMPY_DEBUG within isympy. +.TP +-- \fIPYTHONOPTIONS\fR +These options will be passed on to \fIipython (1)\fR shell. +Only supported when ipython is being used (standard python shell not supported). + +Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR +from the other isympy options. + +For example, to run iSymPy without startup banner and colors: + +isympy -q -c ipython -- --colors=NoColor +.TP +\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T> +Print help output and exit. +.TP +\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T> +Print isympy version information and exit. +.SH FILES +.TP +\*(T<\fI${HOME}/.sympy\-history\fR\*(T> +Saves the history of commands when using the python +shell as backend. +.SH BUGS +The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra +Please report all bugs that you find in there, this will help improve +the overall quality of SymPy. +.SH "SEE ALSO" +\fBipython\fR(1), \fBpython\fR(1) diff --git a/models/main_models/rt1/rt1_pytorch/__init__.py b/models/main_models/rt1/rt1_pytorch/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py new file mode 100644 index 000000000..8524676fd --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py @@ -0,0 +1,38 @@ +import torch +from torch import nn + + +class FilmConditioning(nn.Module): + def __init__(self, embedding_dim, num_channels): + super().__init__() + self._projection_add = nn.Linear(embedding_dim, num_channels) + self._projection_mult = nn.Linear(embedding_dim, num_channels) + self.num_channels = num_channels + self.embedding_dim = embedding_dim + # From the paper + nn.init.zeros_(self._projection_add.weight) + nn.init.zeros_(self._projection_mult.weight) + nn.init.zeros_(self._projection_add.bias) + nn.init.zeros_(self._projection_mult.bias) + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" + assert ( + context.shape[1] == self.embedding_dim + ), f"Unexpected context shape: {context.shape}" + assert ( + x.shape[0] == context.shape[0] + ), f"x and context must have the same batch size, but got {x.shape} and {context.shape}" + projected_cond_add = self._projection_add(context) + projected_cond_mult = self._projection_mult(context) + + if len(x.shape) == 4: + projected_cond_add = projected_cond_add.unsqueeze(2).unsqueeze(3) + projected_cond_mult = projected_cond_mult.unsqueeze(2).unsqueeze(3) + else: + assert len(x.shape) == 2 + + # Original FiLM paper argues that 1 + gamma centers the initialization at + # identity transform. + result = (1 + projected_cond_mult) * x + projected_cond_add + return result \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py new file mode 100644 index 000000000..a9c03573b --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py @@ -0,0 +1,446 @@ +"""EfficientNet models modified with added film layers. + +Mostly taken from: +https://github.com/pytorch/vision/blob/main/torchvision/models/efficientnet.py +""" +import copy +import math +from functools import partial +from typing import Any, Callable, List, Optional, Sequence, Union + +import torch +from torch import nn +from torchvision.models._api import Weights +from torchvision.models._meta import _IMAGENET_CATEGORIES +from torchvision.models._utils import _ovewrite_named_param +from torchvision.models.efficientnet import ( + EfficientNet_B0_Weights, + EfficientNet_B1_Weights, + EfficientNet_B2_Weights, + EfficientNet_B3_Weights, + EfficientNet_B4_Weights, + EfficientNet_B5_Weights, + EfficientNet_B6_Weights, + EfficientNet_B7_Weights, + EfficientNet_V2_L_Weights, + EfficientNet_V2_M_Weights, + EfficientNet_V2_S_Weights, + FusedMBConv, + FusedMBConvConfig, + MBConv, + MBConvConfig, + _efficientnet_conf, + _MBConvConfig, +) +from torchvision.ops.misc import Conv2dNormActivation +from torchvision.utils import _log_api_usage_once + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning + + +class MBConvFilm(nn.Module): + """MBConv or FusedMBConv with FiLM context""" + + def __init__(self, embedding_dim: int, mbconv: Union[MBConv, FusedMBConv]): + super().__init__() + self.mbconv = mbconv + num_channels = mbconv.block[-1][1].num_features + self.film = FilmConditioning( + embedding_dim=embedding_dim, num_channels=num_channels + ) + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + x = self.mbconv(x) + x = self.film(x, context) + return x + + +class _FilmEfficientNet(nn.Module): + def __init__( + self, + inverted_residual_setting: Sequence[Union[MBConvConfig, FusedMBConvConfig]], + dropout: float, + include_top: bool = False, + stochastic_depth_prob: float = 0.2, + num_classes: int = 1000, + norm_layer: Optional[Callable[..., nn.Module]] = None, + last_channel: Optional[int] = None, + embedding_dim: Optional[int] = 512, + ) -> None: + """ + EfficientNet V1 and V2 main class with additional FiLM context layer + + Args: + inverted_residual_setting (Sequence[Union[MBConvConfig, FusedMBConvConfig]]): Network structure + dropout (float): The droupout probability + include_top (bool): Whether to include the classification head + stochastic_depth_prob (float): The stochastic depth probability + num_classes (int): Number of classes + norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use + last_channel (int): The number of channels on the penultimate layer + embedding_dim (int): The dimension of the embedding space + """ + super().__init__() + _log_api_usage_once(self) + + if not inverted_residual_setting: + raise ValueError("The inverted_residual_setting should not be empty") + elif not ( + isinstance(inverted_residual_setting, Sequence) + and all([isinstance(s, _MBConvConfig) for s in inverted_residual_setting]) + ): + raise TypeError( + "The inverted_residual_setting should be List[MBConvConfig]" + ) + + if norm_layer is None: + norm_layer = nn.BatchNorm2d + + layers: List[nn.Module] = [] + + # building first layer + firstconv_output_channels = inverted_residual_setting[0].input_channels + layers.append( + Conv2dNormActivation( + 3, + firstconv_output_channels, + kernel_size=3, + stride=2, + norm_layer=norm_layer, + activation_layer=nn.SiLU, + ) + ) + + # building inverted residual blocks + total_stage_blocks = sum(cnf.num_layers for cnf in inverted_residual_setting) + stage_block_id = 0 + for cnf in inverted_residual_setting: + stage: List[nn.Module] = [] + for _ in range(cnf.num_layers): + # copy to avoid modifications. shallow copy is enough + block_cnf = copy.copy(cnf) + + # overwrite info if not the first conv in the stage + if stage: + block_cnf.input_channels = block_cnf.out_channels + block_cnf.stride = 1 + + # adjust stochastic depth probability based on the depth of the stage block + sd_prob = ( + stochastic_depth_prob * float(stage_block_id) / total_stage_blocks + ) + stage.append( + MBConvFilm( + embedding_dim=embedding_dim, + mbconv=block_cnf.block(block_cnf, sd_prob, norm_layer), + ) + ) + stage_block_id += 1 + + layers.append(nn.Sequential(*stage)) + + # building last several layers + lastconv_input_channels = inverted_residual_setting[-1].out_channels + lastconv_output_channels = ( + last_channel if last_channel is not None else 4 * lastconv_input_channels + ) + layers.append( + Conv2dNormActivation( + lastconv_input_channels, + lastconv_output_channels, + kernel_size=1, + norm_layer=norm_layer, + activation_layer=nn.SiLU, + ) + ) + + self.features = nn.Sequential(*layers) + if include_top: + self.avgpool = nn.AdaptiveAvgPool2d(1) + self.classifier = nn.Sequential( + nn.Dropout(p=dropout, inplace=True), + nn.Linear(lastconv_output_channels, num_classes), + nn.Softmax(dim=1), + ) + else: + self.avgpool = nn.Identity() + self.classifier = nn.Identity() + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode="fan_out") + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): + nn.init.ones_(m.weight) + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Linear): + init_range = 1.0 / math.sqrt(m.out_features) + nn.init.uniform_(m.weight, -init_range, init_range) + nn.init.zeros_(m.bias) + + self.embedding_dim = embedding_dim + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + for feature in self.features: + for layer in feature: + if isinstance(layer, MBConvFilm): + x = layer(x, context) + else: + x = layer(x) + + x = self.avgpool(x) + x = torch.squeeze(x, dim=(2, 3)) # squeeze if h = w = 1 + x = self.classifier(x) + + return x + + +def get_weights(arch: str) -> Weights: + """ + Returns the default weights for the given EfficientNet model. + + Parameters: + arch (str): The EfficientNet variant to use. Allowed values are: + - 'efficientnet_b0' + - 'efficientnet_b1' + - 'efficientnet_b2' + - 'efficientnet_b3' + - 'efficientnet_b4' + - 'efficientnet_b5' + - 'efficientnet_b6' + - 'efficientnet_b7' + - 'efficientnet_v2_s' + - 'efficientnet_v2_m' + - 'efficientnet_v2_l' + + Returns: + WeightsEnum: The default weights for the given architecture. + + Raises: + ValueError: If the given architecture is not supported. + """ + + if arch == "efficientnet_b0": + weights = EfficientNet_B0_Weights.DEFAULT + elif arch == "efficientnet_b1": + weights = EfficientNet_B1_Weights.DEFAULT + elif arch == "efficientnet_b2": + weights = EfficientNet_B2_Weights.DEFAULT + elif arch == "efficientnet_b3": + weights = EfficientNet_B3_Weights.DEFAULT + elif arch == "efficientnet_b4": + weights = EfficientNet_B4_Weights.DEFAULT + elif arch == "efficientnet_b5": + weights = EfficientNet_B5_Weights.DEFAULT + elif arch == "efficientnet_b6": + weights = EfficientNet_B6_Weights.DEFAULT + elif arch == "efficientnet_b7": + weights = EfficientNet_B7_Weights.DEFAULT + elif arch == "efficientnet_v2_s": + weights = EfficientNet_V2_S_Weights.DEFAULT + elif arch == "efficientnet_v2_m": + weights = EfficientNet_V2_M_Weights.DEFAULT + elif arch == "efficientnet_v2_l": + weights = EfficientNet_V2_L_Weights.DEFAULT + else: + raise ValueError(f"Unsupported model type `{arch}`") + + return weights + + +class FilmEfficientNet(nn.Module): + def __init__( + self, + arch: str, + include_top: bool = False, + embedding_dim: int = 512, + pretrained: Optional[bool] = True, + weights: Optional[Weights] = None, + progress: Optional[bool] = True, + device: Optional[Union[str, torch.device]] = "cuda", + **kwargs, + ): + """Builds a FilmEfficientNet model. + + Args: + arch (str): The EfficientNet variant to use. Allowed values are: + - 'efficientnet_b0' + - 'efficientnet_b1' + - 'efficientnet_b2' + - 'efficientnet_b3' + - 'efficientnet_b4' + - 'efficientnet_b5' + - 'efficientnet_b6' + - 'efficientnet_b7' + - 'efficientnet_v2_s' + - 'efficientnet_v2_m' + - 'efficientnet_v2_l' + include_top (bool, optional): Whether to include the classification head + embedding_dim (int, optional): The dimensionality of the output embeddings. + pretrained (bool, optional): Whether to load pretrained EfficientNet weights. + Defaults to True. + weights (WeightsEnum, optional): The pretrained weights to use. + only allowed if `pretrained==False`. Defaults to None. + progress (bool, optional): If True, displays a progress bar of the + download to stderr. Default is True. + device (torch.device, optional): The device on which the model will be + **kwargs: parameters passed to the `FilmEfficientNet` class. + """ + super().__init__() + norm_layer = None + if arch == "efficientnet_b0": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.0, depth_mult=1.0 + ) + dropout = 0.2 + self.output_hw = 7 + elif arch == "efficientnet_b1": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.0, depth_mult=1.1 + ) + dropout = 0.2 + self.output_hw = 8 + elif arch == "efficientnet_b2": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.1, depth_mult=1.2 + ) + dropout = 0.3 + self.output_hw = 9 + elif arch == "efficientnet_b3": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.2, depth_mult=1.4 + ) + dropout = 0.3 + self.output_hw = 10 + elif arch == "efficientnet_b4": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.4, depth_mult=1.8 + ) + dropout = 0.4 + self.output_hw = 12 + elif arch == "efficientnet_b5": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.6, depth_mult=2.2 + ) + dropout = 0.4 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 15 + elif arch == "efficientnet_b6": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.8, depth_mult=2.6 + ) + dropout = 0.5 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 17 + elif arch == "efficientnet_b7": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=2.0, depth_mult=3.1 + ) + dropout = 0.5 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 20 + elif arch == "efficientnet_v2_s": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.2 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 12 + elif arch == "efficientnet_v2_m": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.3 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 15 + elif arch == "efficientnet_v2_l": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.4 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 15 + + assert ( + weights is None or not pretrained + ), "Cannot pass in custom weights with pretrained=True" + weights = get_weights(arch) if pretrained else weights + + if weights is not None: + _ovewrite_named_param( + kwargs, "num_classes", len(weights.meta["categories"]) + ) + + model = _FilmEfficientNet( + inverted_residual_setting, + dropout, + include_top=include_top, + last_channel=last_channel, + norm_layer=norm_layer, + embedding_dim=embedding_dim, + **kwargs, + ) + + if weights is not None: + state_dict = weights.get_state_dict(progress=progress) + new_state_dict = {} + for k, v in state_dict.items(): + if ".block" in k: + new_state_dict[k.replace(".block", ".mbconv.block")] = v + else: + new_state_dict[k] = v + model.load_state_dict( + new_state_dict, + strict=False, + ) + + self.model = model.to(device) + self.preprocess = weights.transforms(antialias=True) if weights else lambda x: x + + self.conv1x1 = nn.Conv2d( + in_channels=self.model.features[-1].out_channels, + out_channels=embedding_dim, + kernel_size=(1, 1), + stride=(1, 1), + padding="same", + bias=False, + device=device, + ) + nn.init.kaiming_normal_(self.conv1x1.weight) + self.film_layer = FilmConditioning(embedding_dim, embedding_dim).to(device) + self.include_top = include_top + self.embedding_dim = embedding_dim + + def forward( + self, image: torch.Tensor, context: Optional[torch.Tensor] = None + ) -> torch.Tensor: + if len(image.shape) == 3: + # Add batch dimension + image = image.unsqueeze(0) + assert len(image.shape) == 4, f"Unexpected image shape: {image.shape}" + if image.shape[-1] == 3: + # (B, H, W, C) -> (B, C, H, W) + image = image.permute(0, 3, 1, 2) + if torch.max(image) >= 1.0: + # Normalize to [0, 1] + image = image / 255.0 + assert torch.min(image) >= 0.0 and torch.max(image) <= 1.0 + image = self.preprocess(image) + + if context is not None and self.include_top: + raise ValueError("Context cannot be passed in if include_top=True") + elif context is None: + context = torch.zeros( + image.shape[0], self.embedding_dim, device=image.device + ) + + features = self.model(image, context) + if not self.include_top: + features = self.conv1x1(features) + features = self.film_layer(features, context) + return features + + +def decode_predictions(preds: torch.Tensor, top=5): + preds = preds.detach().cpu().numpy() + results = [] + for pred in preds: + top_indices = pred.argsort()[-top:][::-1] + result = [(_IMAGENET_CATEGORIES[i], pred[i]) for i in top_indices] + results.append(result) + return results \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/rt1_model.py b/models/main_models/rt1/rt1_pytorch/rt1_model.py new file mode 100644 index 000000000..30388f638 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/rt1_model.py @@ -0,0 +1,217 @@ +from typing import Optional + +import torch +from einops import rearrange +from torch import nn + +from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer + + +def posemb_sincos_1d(seq, dim, temperature=10000, device=None, dtype=torch.float32): + """ + Generate positional embeddings using sine and cosine functions for a 1-dimensional sequence. + + Parameters: + seq (int): The length of the sequence. + dim (int): The dimension of the positional embeddings. + temperature (float, optional): The temperature parameter for the sine function. Defaults to 10000. + device (torch.device, optional): The device for tensor operations. Defaults to None. + dtype (torch.dtype, optional): The data type of the positional embeddings. Defaults to torch.float32. + + Returns: + torch.Tensor: The positional embeddings of shape (seq, dim), with each element computed as the concatenation of the sine and cosine values. + + """ + n = torch.arange(seq, device=device) + omega = torch.arange(dim // 2, device=device) / (dim // 2 - 1) + omega = 1.0 / (temperature**omega) + + n = n[:, None] * omega[None, :] + pos_emb = torch.cat((n.sin(), n.cos()), dim=1) + return pos_emb.type(dtype) + + +# Robotic Transformer +class RT1Model(nn.Module): + def __init__( + self, + arch: str = "efficientnet_b3", + tokens_per_action=11, + action_bins=256, + num_layers=4, + num_heads=8, + feed_forward_size=512, + dropout_rate=0.1, + time_sequence_length=6, + embedding_dim=512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + device="cuda", + ): + """ + Initializes the RT1Model. + + Parameters: + arch (str): The efficientnet variant to use. Default is "efficientnet_b3". + tokens_per_action (int): The number of tokens per action. Default is 11. + action_bins (int): The number of action bins. Default is 256. + num_layers (int): The number of transformer layers. Default is 6. + num_heads (int): The number of attention heads. Default is 8. + feed_forward_size (int): The size of the feed-forward layer. Default is 512. + dropout_rate (float): The dropout rate. Default is 0.1. + time_sequence_length (int): The length of the time sequence. Default is 6. + embedding_dim (int): The dimension of the embedding. Default is 512. + use_token_learner (bool): Whether to use token learner. Default is True. + token_learner_bottleneck_dim (int): The dimension of the token learner bottleneck. Default is 64. + token_learner_num_output_tokens (int): The number of output tokens of the token learner. Default is 8. + device (torch.device, optional): The device for tensor operations. Defaults to "cuda". + + Returns: + None + """ + super().__init__() + self.time_sequence_length = time_sequence_length + self.action_encoder = nn.Linear(action_bins, embedding_dim, device=device) + self.image_tokenizer = RT1ImageTokenizer( + arch=arch, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_bottleneck_dim=token_learner_bottleneck_dim, + token_learner_num_output_tokens=token_learner_num_output_tokens, + dropout_rate=dropout_rate, + device=device, + ) + + self.num_tokens = self.image_tokenizer.num_output_tokens + + self.transformer = nn.Transformer( + d_model=embedding_dim, + nhead=num_heads, + num_encoder_layers=num_layers, + num_decoder_layers=num_layers, + dim_feedforward=feed_forward_size, + dropout=dropout_rate, + activation="gelu", + batch_first=True, + device=device, + ) + + self.to_logits = nn.Sequential( + nn.LayerNorm(embedding_dim), + nn.Linear(embedding_dim, action_bins), + ).to(device) + + self.tokens_per_action = tokens_per_action + self.action_bins = action_bins + self.embedding_dim = embedding_dim + self.device = device + + def forward( + self, + videos: torch.Tensor, + texts: Optional[torch.Tensor] = None, + action_logits: Optional[torch.Tensor] = None, + ): + """ + Forward pass of the model. + + Args: + videos (torch.Tensor): The input videos. + Shape is (b, f, h, w, c) or (b, f, c, h, w). + texts (Optional[torch.Tensor]): The input text embedding. + Shape is (b, f, embedding_dim). + action_logits (Optional[torch.Tensor]): The input action_logits. + Shape is (b, f, tokens_per_action, action_bins). + + Returns: + torch.Tensor: The output logits. + Shape is (b, f, tokens_per_action, action_bins). + """ + b, f, *_ = videos.shape + assert ( + f == self.time_sequence_length + ), f"Expected {self.time_sequence_length} frames, got videos.shape[1] = {f}" + + if texts is None: + texts = torch.zeros((b, f, self.embedding_dim), device=self.device) + if action_logits is None: + action_logits = torch.zeros( + (b, f, self.tokens_per_action, self.action_bins), device=self.device + ) + elif action_logits.shape != (b, f, self.tokens_per_action, self.action_bins): + raise ValueError( + f"""Expected action_logits.shape = (b, f, tokens_per_action, action_bins), + got {action_logits.shape}; did you pass in raw actions instead?""" + ) + + # pack time dimension into batch dimension + videos = rearrange(videos, "b f ... -> (b f) ...") + texts = rearrange(texts, "b f d -> (b f) d") + + # tokenize images and texts + tokens = self.image_tokenizer(videos, texts) + + # unpack time dimension from batch dimension + tokens = rearrange(tokens, "(b f) c n -> b f c n", b=b, f=f) + + # pack time dimension into token dimension + tokens = rearrange(tokens, "b f c n -> b (f n) c") + action_logits = rearrange(action_logits, "b f a d -> b (f a) d") + + # sinusoidal positional embedding + pos_emb = posemb_sincos_1d(tokens.shape[1], tokens.shape[2], device=self.device) + tokens = tokens + pos_emb + + # causal mask for tokens + token_mask = torch.ones( + tokens.shape[1], tokens.shape[1], dtype=torch.bool + ).tril(0) + token_mask = ~token_mask + token_mask = token_mask.to(self.device) + + # encode action_logits to have the same embedding dimension as tokens + action_tokens = self.action_encoder(action_logits) + + pos_emb = posemb_sincos_1d( + action_tokens.shape[1], action_tokens.shape[2], device=self.device + ) + action_tokens = action_tokens + pos_emb + + # action mask: do not let action_logits attend to previous action_logits, + # a_t is independent of a_{t-1} given pi and s_t + action_mask = torch.ones( + self.time_sequence_length, self.time_sequence_length, dtype=torch.bool + ).tril(0) + action_mask = torch.kron( + torch.eye(self.tokens_per_action, self.tokens_per_action, dtype=torch.bool), + action_mask, + ) + action_mask = ~action_mask + action_mask = action_mask.to(self.device) + + # causal mask between tokens and action_logits; + # a_t attends to s_t' for all t'<=t + memory_mask = torch.ones( + self.time_sequence_length, self.time_sequence_length, dtype=torch.bool + ).tril(0) + memory_mask = torch.kron( + memory_mask, + torch.ones(self.tokens_per_action, self.num_tokens, dtype=torch.bool), + ) + memory_mask = ~memory_mask + memory_mask = memory_mask.to(self.device) + + attended_tokens = self.transformer( + src=tokens, + src_mask=token_mask, + tgt=action_tokens, + tgt_mask=action_mask, + memory_mask=memory_mask, + ) + + # unpack time dimension from token dimension + attended_tokens = rearrange(attended_tokens, "b (f n) c -> b f n c", b=b, f=f) + + logits = self.to_logits(attended_tokens) + return logits \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/rt1_policy.py b/models/main_models/rt1/rt1_pytorch/rt1_policy.py new file mode 100644 index 000000000..f68155a56 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/rt1_policy.py @@ -0,0 +1,234 @@ +from typing import Dict, List, Optional, Tuple, Union + +import gymnasium as gym +import numpy as np +import torch +import tree +from einops import rearrange +from torch.nn import functional as F +import pdb + +from rt1_pytorch.rt1_model import RT1Model +from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer + + +class RT1Policy: + def __init__( + self, + observation_space: gym.spaces.Dict, + action_space: gym.spaces.Dict, + arch: str = "efficientnet_b3", + action_bins=256, + num_layers=4, + num_heads=8, + feed_forward_size=256, + dropout_rate=0.1, + time_sequence_length=6, + embedding_dim=512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + device="cuda", + checkpoint_path: Optional[str] = None, + ): + """ + Initializes an instance of the class. + + Args: + observation_space (gym.spaces.Dict): The observation space of the environment. + action_space (gym.spaces.Dict): The action space of the environment. + arch (str, optional): The architecture of the model. Defaults to "efficientnet_b3". + action_bins (int, optional): The number of bins for discretizing continuous action spaces. Defaults to 256. + num_layers (int, optional): The number of transformer layers in the model. Defaults to 8. + num_heads (int, optional): The number of attention heads in each transformer layer. Defaults to 8. + feed_forward_size (int, optional): The size of the feed-forward layer in the transformer. Defaults to 256. + dropout_rate (float, optional): The dropout rate for the transformer layers. Defaults to 0.1. + time_sequence_length (int, optional): The length of the time sequence for the model. Defaults to 6. + embedding_dim (int, optional): The dimensionality of the input embeddings. Defaults to 512. + use_token_learner (bool, optional): Whether to use the token learner module. Defaults to True. + token_learner_bottleneck_dim (int, optional): The dimensionality of the bottleneck layer in the token learner. Defaults to 64. + token_learner_num_output_tokens (int, optional): The number of output tokens from the token learner. Defaults to 8. + device (str, optional): The device to use for the model. Defaults to "cuda". + checkpoint_path (str, optional): load checkpoint from path. Defaults to None. + + Returns: + None + """ + self.observation_space = observation_space + self.action_space = action_space + self.action_bins = action_bins + self.action_tokenizer = RT1ActionTokenizer( + action_space=action_space, + action_bins=action_bins, + action_order=list(action_space.keys()), + ) + + self.model = RT1Model( + arch=arch, + tokens_per_action=self.action_tokenizer.tokens_per_action, + action_bins=action_bins, + num_layers=num_layers, + num_heads=num_heads, + feed_forward_size=feed_forward_size, + dropout_rate=dropout_rate, + time_sequence_length=time_sequence_length, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_bottleneck_dim=token_learner_bottleneck_dim, + token_learner_num_output_tokens=token_learner_num_output_tokens, + device=device, + ) + + self.embedding_dim = embedding_dim + + for action_space in self.action_space.values(): + if ( + isinstance(action_space, gym.spaces.Discrete) + and action_space.n == time_sequence_length + ): + raise ValueError( + f"""stupid hack:Time sequence length ({time_sequence_length}) + must be different from action space length ({action_space.n}).""" + ) + + self.device = device + if checkpoint_path is not None: + print(f"Loading checkpoint from {checkpoint_path}...") + self.model.load_state_dict(torch.load(checkpoint_path)) + + def preprocess( + self, + videos: Union[np.ndarray, List[np.ndarray]], + texts: Union[np.ndarray, List[np.ndarray]], + actions: Optional[Dict] = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Preprocesses the given videos, texts, and actions. + + Args: + videos (Union[np.ndarray, List[np.ndarray]]): The input videos to preprocess. + shape: (b, t, c, h, w) or (b, t, h, w, c) + texts (Union[np.ndarray, List[np.ndarray]]): The input texts to preprocess. + shape: (b, t, d) + actions (Optional[Dict]): The input actions to preprocess. Defaults to None. + shape: (b, t, a) + + Returns: + Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: A tuple containing the preprocessed videos, texts, and actions. + """ + if isinstance(videos, torch.Tensor): + videos = videos.to(self.device) + elif not isinstance(videos, np.ndarray): + videos = np.stack(videos, axis=0) + + if not isinstance(videos, torch.Tensor): + videos = torch.tensor(videos, device=self.device, dtype=torch.float32) + + if isinstance(texts, torch.Tensor): + texts = texts.to(self.device) + elif not isinstance(texts, np.ndarray): + texts = np.stack(texts, axis=0) + if not isinstance(texts, torch.Tensor): + texts = torch.tensor(texts, device=self.device, dtype=torch.float32) + + + if actions is not None: + actions = { + k: np.stack(v, axis=0) if not (isinstance(v, np.ndarray)) else v + for k, v in actions.items() + } + + + actions = tree.map_structure( + lambda a: rearrange(a, "b f ... -> (b f) ..."), actions + ) + actions = self.action_tokenizer.tokenize(actions) + actions = torch.tensor(actions, device=self.device, dtype=torch.long) + actions = rearrange(actions, "(b f) ... -> b f ...", b=videos.shape[0]) + + return videos, texts, actions + + def forward( + self, + videos: torch.Tensor, + texts: torch.Tensor, + action_logits: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Forward pass through the model. + + Args: + videos (torch.Tensor): Input videos. + texts (torch.Tensor): input contexts. + action_logits (Optional[torch.Tensor]): Optional input action logits. + + Returns: + action_logits (Tuple[torch.Tensor, torch.Tensor]): + A tuple containing the sampled actions and the action logits. + """ + action_logits = self.model(videos, texts, action_logits) + actions = torch.distributions.Categorical(logits=action_logits) + actions = actions.sample() + return actions, action_logits + + def loss(self, observations: Dict, target_actions: Dict) -> torch.Tensor: + """ + Calculates the loss function for the given inputs. + + Args: + observations (Dict): A dictionary containing the observations. + It should have the following keys: + - "image" (np.ndarray): The video observations. + - "context" (np.ndarray): The context. + target_actions (Dict): A dictionary containing the target actions. + + Returns: + torch.Tensor: The calculated loss value. + + Raises: + None + """ + videos = observations["image"] + texts = observations["context"] + videos, texts, target_actions = self.preprocess( + videos, + texts, + target_actions, + ) + _, action_logits = self.forward(videos, texts) + + action_logits = rearrange(action_logits, "b f a d -> (b f a) d") + target_actions = rearrange(target_actions, "b f a -> (b f a)") + loss = F.cross_entropy(action_logits, target_actions, reduction="sum") + loss = loss / videos.shape[0] + + + dummy_loss = F.cross_entropy(action_logits, target_actions, reduction="none") + loss_std = torch.std(dummy_loss) + + return loss, loss_std + + def act(self, observations: Dict) -> Dict[str, np.ndarray]: + """ + Performs an action based on the given observations. + Note that this takes in observations of shape (b,t, ...) + but only returns the last action for each trajectory of shape (b, ...). + + Args: + observations (Dict): A dictionary containing the observations. It should have the following keys: + - "image" (np.ndarray): The video observations. + - "context" (np.ndarray): The context. + + Returns: + Dict[str, np.ndarray]: A dictionary containing the actions. It has the following keys: + - "actions" (np.ndarray): The actions performed based on the observations. + """ + videos = observations["image"] + texts = observations["context"] + videos, texts, _ = self.preprocess(videos, texts) + with torch.no_grad(): + actions, _ = self.forward(videos, texts) + actions = actions.detach().cpu().numpy() + actions = self.action_tokenizer.detokenize(actions) + actions = tree.map_structure(lambda a: a[:, -1], actions) + return actions diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py b/models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py b/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py new file mode 100644 index 000000000..542aa6ec3 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py @@ -0,0 +1,184 @@ +"""A simple action tokenizer used with Robotics Transformer 1. + +As an example, if an action is: +{ + 'base_displacement_vector': + , + 'base_displacement_vertical_rotation': + , + 'gripper_closedness_action': + , + 'rotation_delta': + , + 'terminate_episode': + , + 'world_vector': + +} + +Then we build a sequence of tokens of length 11 [one for each dimension]. +The int32 type action dimensions are already tokenized, +the float dimensions are bucketed according to the spaces min and max. Each +dimension has 'action_bins' buckets. + +Currently, this tokenizer assumes one action space and it is highly recommended +to spaceify the 'action_order', i.e. the order of keys in the dict. +Since after tokenization you lose that information, this +will be useful for debugging. Actions may also be subselected for prediction, +since not all actions are needed in the action_order. +""" +from typing import Dict, Optional + +import gymnasium as gym +import numpy as np +from gymnasium.spaces import Box, Discrete +import pdb + +class RT1ActionTokenizer: + """Tokenizes based on vocab size.""" + + def __init__( + self, + action_space: gym.spaces.Dict, + action_bins: int, + action_order: Optional[list[str]] = None, + ): + """Instantiates an RT1ActionTokenizer. + + Args: + action_bins: Number of buckets to discretize action to. + action_order: Order of the action names, used to discern the order of + tokenized actions to detokenize and assemble back to action tensor + """ + self._action_bins = action_bins + + # filter the action keys + lanmp_keys = ['terminate_episode', 'pickup_release', 'body_position_delta', 'body_yaw_delta','body_pitch_delta','arm_position_delta','control_mode'] + bridge_keys = ['terminate_episode','world_vector', 'open_gripper', "rotation_delta"] + jaco_keys = ['terminate_episode','world_vector', 'gripper_closedness_action'] + + #NOTE: change both lines below to the specific dataset keys + action_order = lanmp_keys #bridge_keys #jaco_keys + action_space = {key: action_space[key] for key in lanmp_keys if key in set(action_space.keys())} + self._action_space = action_space + if action_order is None: + self._action_order = list(action_space.keys()) + else: + for action in action_order: + assert ( + action in action_space.keys() + ), f"action: {action} not in action_space: {action_space.keys()}" + self._action_order = action_order + self._tokens_per_action = 0 + for action in self._action_order: + action_shape = action_space[action].shape + if isinstance(action_space, gym.spaces.Box) and len(action_shape) != 1: + raise ValueError( + f"Only action shapes with single dimension supported, got {action_shape}" + ) + if isinstance(action_space[action], Discrete): + # Int32 actions are already assumed to be tokens. + self._tokens_per_action += 1 + elif isinstance(action_space[action], Box): + if len(action_shape) != 1: + raise ValueError( + f"Only action shapes with single dimension supported, got {action_shape}" + ) + self._tokens_per_action += action_shape[0] + else: + raise ValueError( + f"Unsupported action space: {type(action_space[action])}" + ) + + # We measure # of action tokens in two different way. One is by checking + # from action_order (above) and the other is by looping through the + # action space (below). We aseert the # of action tokens are the same + # calculated by these two ways. This will assure action_order is correctly + # configured, otherwise, it will throw an error in the assert. + num_action_token = 0 + for space in action_space.values(): + if space.dtype == np.int_: + num_action_token += 1 + else: + num_action_token += space.shape[-1] + assert ( + self._tokens_per_action == num_action_token + ), f"{self._tokens_per_action} != {num_action_token}" + + @property + def tokens_per_action(self) -> int: + return self._tokens_per_action + + @property + def action_space(self) -> gym.spaces.Dict: + return self._action_space + + @property + def action_order(self) -> list[str]: + return self._action_order + + def tokenize(self, action: Dict) -> np.ndarray: + """Tokenizes an action.""" + + action_tokens = [] + for k in self._action_order: + #print("k equals " + str(k)) + #print(action.keys()) + #print(action) + act = action[k] # a is [batch, (time), action_size] + space = self._action_space[k] + if isinstance(space, gym.spaces.Discrete): + # Int32 actions are already assumed to be tokens + if not (isinstance(act, np.ndarray)): + act = np.array(act, dtype=np.int32) + act = np.expand_dims(act, axis=-1) + if not np.all(act < space.n): + raise ValueError(f"Invalid action: {act} >= {space.n}") + token = act + elif isinstance(space, gym.spaces.Box): + low = space.low[0] + high = space.high[0] + act = np.clip(act, low, high) + # Normalize the action [batch, actions_size] + token = (act - low) / (high - low) + # Bucket and discretize the action to action_bins, [batch, actions_size] + token = (token * (self._action_bins - 1)).astype(np.int32) + #TODO: bridge + if k == 'open_gripper': + token = token[:,None] + action_tokens.append(token) + #print(k, token.shape) + # Append all actions, [batch, (time), all_actions_size] + action_tokens = np.concatenate(action_tokens, axis=-1) + return action_tokens + + def detokenize(self, action_tokens: np.ndarray) -> Dict: + """Detokenizes an action.""" + action = {} + token_index = 0 + if not action_tokens.shape[-1] == self._tokens_per_action: + action_tokens = action_tokens.reshape( + *action_tokens.shape[:-1], self._tokens_per_action + ) + for k in self._action_order: + space = self._action_space[k] + if isinstance(space, gym.spaces.Discrete): + # Int32 actions are already assumed to be tokens. + action[k] = action_tokens[..., token_index] + # A poor model may output tokens outside the allowed range, in that case + # set them to a default value, the 0 token in this case. + action[k] = np.where( + action[k] >= space.n, np.zeros_like(action[k]), action[k] + ) + token_index += 1 + elif isinstance(space, gym.spaces.Box): + actions = [] + for _ in range(space.shape[0]): + a = action_tokens[..., token_index : token_index + 1] + a = a.astype(np.float32) + a = a / (self._action_bins - 1) + a = (a * (space.high[0] - space.low[0])) + space.low[0] + actions.append(a) + token_index += 1 + action[k] = np.concatenate(actions, axis=-1) + return action diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py b/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py new file mode 100644 index 000000000..9cf4cdcb0 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py @@ -0,0 +1,77 @@ +"""The image tokenizer combining the FiLMEfficientNet and TokenLearner from RT1. +""" +import torch +from torch import nn + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning +from rt1_pytorch.film_efficientnet.film_efficientnet import FilmEfficientNet +from rt1_pytorch.tokenizers.token_learner import TokenLearner + + +class RT1ImageTokenizer(nn.Module): + """Tokenizes based on vocab size.""" + + def __init__( + self, + arch: str = "efficientnet_b3", + embedding_dim: int = 512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + dropout_rate=0.1, + device="cuda", + ): + """Instantiates a RT1ImageTokenizer. + + Args: + arch: The efficientnet variant to use. + embedding_dim: The embedding size of the tokens. + use_token_learner: Whether to use token learner. See + https://arxiv.org/abs/2106.11297 + num_tokens: Relevant only for token learner - the number of learned + tokens. + token_learner_bottleneck_dim: Relevant only for token learner - the + dimension of the bottleneck layer. + token_learner_num_output_tokens: Relevant only for token learner - + the number of output tokens. + dropout_rate: Relevant only for token learner - the dropout rate. + device: The device to place the model on. + """ + super().__init__() + + self.film_efficientnet = FilmEfficientNet( + arch=arch, embedding_dim=embedding_dim, device=device + ) + self.num_output_tokens = self.film_efficientnet.output_hw**2 + + self._use_token_learner = use_token_learner + if self._use_token_learner: + self._token_learner = TokenLearner( + embedding_dim=embedding_dim, + num_tokens=token_learner_num_output_tokens, + bottleneck_dim=token_learner_bottleneck_dim, + dropout_rate=dropout_rate, + device=device, + ) + self.num_output_tokens = token_learner_num_output_tokens + + def forward(self, image: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + """Gets image tokens. + + Args: + image: Images of shape (b, h, w, 3) to tokenize. + context: A context vector (e.g., a natural language embedding). + Expected to have shape (b, embedding_dim). + + Returns: + tokens: has shape (batch, num_tokens_per_timestep, embedding_dim) + """ + assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" + + tokens = self.film_efficientnet(image, context) + if len(tokens.shape) == 4: + # (b, c, h, w) -> (b, c, h*w) + tokens = tokens.reshape(tokens.shape[0], tokens.shape[1], -1) + if self._use_token_learner: + tokens = self._token_learner(tokens) + return tokens \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py b/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py new file mode 100644 index 000000000..8e04a4c30 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py @@ -0,0 +1,89 @@ +"""Pytorch implementation of TokenLearner(Ryoo et al 2021).""" + +import torch +from torch import nn + + +class MlpBlock(nn.Module): + """Transformer MLP / feed-forward block.""" + + def __init__( + self, + input_dim: int, + mlp_dim: int, + out_dim: int, + dropout_rate: float = 0.1, + device="cuda", + ): + """Initializer for the MLP Block. + + This computes outer_dense(gelu(hidden_dense(input))), with dropout + applied as necessary. + + Args: + input_dim: The dimension of the input. + mlp_dim: The dimension of the inner representation (output of hidden + layer). Usually larger than the input/output dim. + out_dim: The output dimension of the block. + dropout_rate: Dropout rate to be applied after dense ( & activation) + layers. + device: The device to place the model on. + """ + super().__init__() + self._hidden_dropout = nn.Dropout(dropout_rate) + self._output_dropout = nn.Dropout(dropout_rate) + self._hidden_layer = nn.Linear(input_dim, mlp_dim, device=device) + self._output_layer = nn.Linear(mlp_dim, out_dim, device=device) + nn.init.xavier_uniform_(self._hidden_layer.weight) + nn.init.xavier_uniform_(self._output_layer.weight) + nn.init.normal_(self._hidden_layer.bias, std=1e-6) + nn.init.normal_(self._output_layer.bias, std=1e-6) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + """Applies Transformer MlpBlock module.""" + x = self._hidden_layer(inputs) + x = nn.functional.gelu(x) + x = self._hidden_dropout(x) + x = self._output_layer(x) + x = self._output_dropout(x) + return x + + +class TokenLearner(nn.Module): + """TokenLearner module V1.1 (https://arxiv.org/abs/2106.11297).""" + + def __init__( + self, + embedding_dim: int, + num_tokens: int, + bottleneck_dim: int = 64, + dropout_rate: float = 0.0, + device="cuda", + ): + super().__init__() + + self.layernorm = nn.LayerNorm(embedding_dim, eps=1e-6, device=device) + self.mlp = MlpBlock( + input_dim=embedding_dim, + mlp_dim=bottleneck_dim, + out_dim=num_tokens, + dropout_rate=dropout_rate, + device=device, + ) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + if len(inputs.shape) == 4: + bs, c, h, w = inputs.shape + inputs = torch.reshape(inputs, [bs, c, h * w]) + inputs = inputs.permute(0, 2, 1) # Shape: [bs, h*w, c] + + selected = self.layernorm(inputs) + + selected = self.mlp(selected) # Shape: [bs, h*w, n_token]. + selected = nn.functional.softmax(selected, dim=-1) + selected = selected.permute(0, 2, 1) # Shape: [bs, n_token, h*w] + + feat = torch.einsum("...si,...id->...sd", selected, inputs) + feat = feat.permute(0, 2, 1) + + return feat # Shape: [bs, c, n_token] \ No newline at end of file diff --git a/models/main_models/rt1/setup.py b/models/main_models/rt1/setup.py new file mode 100644 index 000000000..4c3290111 --- /dev/null +++ b/models/main_models/rt1/setup.py @@ -0,0 +1,44 @@ +from setuptools import find_packages, setup + +setup( + name="rt1-pytorch", + packages=find_packages(exclude=[]), + version="0.1.0", + license="MIT", + description="PyTorch implementation of the RT-1.", + author="Rohan Potdar", + author_email="rohanpotdar138@gmail.com", + long_description_content_type="text/markdown", + url="https://github.com/Rohan138/rt1-pytorch", + keywords=[ + "artificial intelligence", + "deep learning", + "transformers", + "attention mechanism", + "robotics", + ], + install_requires=[ + "torch>=1.9", + "scikit-image", + "sentence-transformers", + "tensorflow", + "tensorflow_datasets", + "transformers", + "gymnasium[mujoco]", + "dm-reverb", + "dm-control", + "rlds", + "einops", + "dmc2gymnasium@git+https://github.com/imgeorgiev/dmc2gymnasium.git", + "h5py", + "wandb", + "tqdm", + ], + classifiers=[ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.6", + ], +) \ No newline at end of file diff --git a/models/main_models/rt1/tests/action_tokenizer_test.py b/models/main_models/rt1/tests/action_tokenizer_test.py new file mode 100644 index 000000000..6b082840b --- /dev/null +++ b/models/main_models/rt1/tests/action_tokenizer_test.py @@ -0,0 +1,166 @@ +"""Tests for action_tokenizer.""" +import unittest + +import numpy as np +from gymnasium.spaces import Box, Dict, Discrete + +from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer + + +class ActionTokenizerTest(unittest.TestCase): + def testTokenize_int32(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(1, tokenizer.tokens_per_action) + action = dict(terminate_episode=np.array([1], dtype=np.int32)) + action_tokens = tokenizer.tokenize(action) + self.assertEqual(action["terminate_episode"], action_tokens) + + def testTokenize_int32_out_of_bounds(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(1, tokenizer.tokens_per_action) + action = dict(terminate_episode=np.array([3], dtype=np.int32)) + with self.assertRaises(ValueError): + tokenizer.tokenize(action) + + def testDetokenize_int32(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + action = tokenizer.detokenize(np.array([0], dtype=np.int32)) + self.assertEqual(action["terminate_episode"], np.array([0])) + # OOV 3 token should become a default one hot: [1, 0] + action = tokenizer.detokenize(np.array([3], dtype=np.int32)) + self.assertEqual(action["terminate_episode"], np.array([0])) + + def testTokenize_float(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(3, tokenizer.tokens_per_action) + action = dict(world_vector=[0.1, 0.5, -0.8]) + action_tokens = tokenizer.tokenize(action) + self.assertSequenceEqual([4, 6, 0], list(action_tokens.tolist())) + + def testTokenize_float_with_time_dimension(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(3, tokenizer.tokens_per_action) + batch_size = 2 + time_dimension = 3 + action = dict( + world_vector=np.array( + [ + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + ], + ).reshape((batch_size, time_dimension, 3)), + ) + action_tokens = tokenizer.tokenize(action) + self.assertSequenceEqual( + [batch_size, time_dimension, tokenizer.tokens_per_action], + action_tokens.shape, + ) + + def testTokenize_float_at_limits(self): + minimum = -1.0 + maximum = 1.0 + action_bins = 10 + action_space = Dict( + world_vector=Box(low=minimum, high=maximum, shape=(2,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=action_bins) + self.assertEqual(2, tokenizer.tokens_per_action) + action = dict(world_vector=[minimum, maximum]) + action_tokens = tokenizer.tokenize(action) + # Minimum value will go to 0 + # Maximum value witll go to action_bins-1 + self.assertSequenceEqual([0, action_bins - 1], action_tokens.tolist()) + + def testTokenize_invalid_action_space_shape(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(2, 2), dtype=np.float32) + ) + with self.assertRaises(ValueError): + RT1ActionTokenizer(action_space, action_bins=10) + + def testTokenizeAndDetokenizeIsEqual(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + rotation_delta=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + gripper_closedness_action=Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=Discrete(3), + ) + + tokenizer = RT1ActionTokenizer( + action_space, + action_bins=256, + action_order=[ + "terminate_episode", + "world_vector", + "rotation_delta", + "gripper_closedness_action", + ], + ) + self.assertEqual(8, tokenizer.tokens_per_action) + + # Repeat the following test N times with fuzzy inputs. + n_repeat = 10 + for _ in range(n_repeat): + action = dict( + world_vector=np.random.uniform(low=-1.0, high=1.0, size=3), + rotation_delta=np.random.uniform( + low=-np.pi / 2.0, high=np.pi / 2.0, size=3 + ), + gripper_closedness_action=np.random.uniform(low=0.0, high=1.0, size=1), + terminate_episode=np.array(0, dtype=np.int32), + ) + action_tokens = tokenizer.tokenize(action) + policy_action = tokenizer.detokenize(action_tokens) + + for k in action: + self.assertTrue( + np.allclose(action[k], policy_action[k], atol=1e-1), + f"Failed at {k} with {action[k]} != {policy_action[k]}.", + ) + + # Repeat the test with batched actions + batched_action = dict( + world_vector=[ + np.random.uniform(low=-1.0, high=1.0, size=3), + np.random.uniform(low=-1.0, high=1.0, size=3), + ], + rotation_delta=[ + np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), + np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), + ], + gripper_closedness_action=[ + np.random.uniform(low=0.0, high=1.0, size=1), + np.random.uniform(low=0.0, high=1.0, size=1), + ], + terminate_episode=[0, 1], + ) + action_tokens = tokenizer.tokenize(batched_action) + policy_action = tokenizer.detokenize(action_tokens) + + for k in batched_action: + for a, policy_a in zip(batched_action[k], policy_action[k]): + self.assertTrue( + np.allclose(a, policy_a, atol=1e-1), + f"Failed at {k} with {a} != {policy_a}.", + ) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/film_conditioning_layer_test.py b/models/main_models/rt1/tests/film_conditioning_layer_test.py new file mode 100644 index 000000000..0cefd44b0 --- /dev/null +++ b/models/main_models/rt1/tests/film_conditioning_layer_test.py @@ -0,0 +1,27 @@ +"""Tests for film_conditioning_layer.""" +import torch +from absl.testing import absltest, parameterized + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning + + +class FilmConditioningLayerTest(parameterized.TestCase): + @parameterized.parameters([2, 4]) + def test_film_conditioning_rank_two_and_four(self, conv_rank): + batch = 2 + num_channels = 3 + embedding_dim = 512 + if conv_rank == 2: + conv_layer = torch.randn(size=(batch, num_channels)) + elif conv_rank == 4: + conv_layer = torch.randn(size=(batch, 1, 1, num_channels)) + else: + raise ValueError(f"Unexpected conv rank: {conv_rank}") + context = torch.rand(batch, embedding_dim) + film_layer = FilmConditioning(embedding_dim, num_channels) + out = film_layer(conv_layer, context) + assert len(out.shape) == conv_rank + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/film_efficientnet_test.py b/models/main_models/rt1/tests/film_efficientnet_test.py new file mode 100644 index 000000000..8fa2944cc --- /dev/null +++ b/models/main_models/rt1/tests/film_efficientnet_test.py @@ -0,0 +1,57 @@ +"""Tests for pretrained_efficientnet_encoder.""" + +import torch +from absl.testing import absltest, parameterized +from skimage import data + +from rt1_pytorch.film_efficientnet.film_efficientnet import ( + FilmEfficientNet, + decode_predictions, +) + +MODELS = [ + "efficientnet_b0", + "efficientnet_b1", + "efficientnet_b2", + "efficientnet_b3", + # "efficientnet_b4", + # "efficientnet_b5", + # "efficientnet_b6", + # "efficientnet_b7", + "efficientnet_v2_s", + # "efficientnet_v2_m", + # "efficientnet_v2_l", +] + + +class FilmEfficientNetTest(parameterized.TestCase): + @parameterized.parameters(MODELS) + def test_encoding(self, model_name): + """Test that we get a correctly shaped encoding.""" + embedding_dim = 512 + batch_size = 4 + device = "cuda" if torch.cuda.is_available() else "cpu" + image = torch.tensor(data.chelsea()).repeat(batch_size, 1, 1, 1) + context = torch.FloatTensor(size=(batch_size, embedding_dim)).uniform_(-1, 1) + model = FilmEfficientNet(model_name, device=device).eval() + image = image.to(device) + context = context.to(device) + preds = model(image, context) + self.assertEqual( + preds.shape, (batch_size, 512, model.output_hw, model.output_hw) + ) + + @parameterized.parameters(MODELS) + def test_imagenet_classification(self, model_name): + """Test that we can correctly classify an image of a cat.""" + device = "cuda" if torch.cuda.is_available() else "cpu" + image = torch.tensor(data.chelsea()) + model = FilmEfficientNet(model_name, include_top=True, device=device).eval() + image = image.to(device) + preds = model(image) + predicted_names = [n[0] for n in decode_predictions(preds, top=3)[0]] + self.assertIn("tabby", predicted_names) + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/image_tokenizer_test.py b/models/main_models/rt1/tests/image_tokenizer_test.py new file mode 100644 index 000000000..3b1dbd0e0 --- /dev/null +++ b/models/main_models/rt1/tests/image_tokenizer_test.py @@ -0,0 +1,53 @@ + +"""Tests for image_tokenizer.""" +import unittest + +import torch +from absl.testing import parameterized + +from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer + +MODELS = [ + "efficientnet_b0", + "efficientnet_b1", + "efficientnet_b2", + "efficientnet_b3", + # "efficientnet_b4", + # "efficientnet_b5", + # "efficientnet_b6", + # "efficientnet_b7", + "efficientnet_v2_s", + # "efficientnet_v2_m", + # "efficientnet_v2_l", +] + + +class ImageTokenizerTest(parameterized.TestCase): + @parameterized.named_parameters( + *[(f"sample_image_{m}", m, 512, 224, False, 8) for m in MODELS], + *[(f"sample_image_token_learner_{m}", m, 512, 224, True, 8) for m in MODELS], + ) + def testTokenize( + self, arch, embedding_dim, image_resolution, use_token_learner, num_tokens + ): + batch = 4 + device = "cuda" + tokenizer = RT1ImageTokenizer( + arch=arch, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_num_output_tokens=num_tokens, + device=device, + ) + + image = torch.randn((batch, image_resolution, image_resolution, 3)) + image = torch.clip(image, 0.0, 1.0) + image = image.to(device) + context_vector = torch.FloatTensor(size=(batch, 512)).uniform_() + context_vector = context_vector.to(device) + image_tokens = tokenizer(image, context_vector) + self.assertEqual(image_tokens.shape, (batch, 512, tokenizer.num_output_tokens)) + + +if __name__ == "__main__": + unittest.main() diff --git a/models/main_models/rt1/tests/rt1_model_test.py b/models/main_models/rt1/tests/rt1_model_test.py new file mode 100644 index 000000000..6ac8b07dd --- /dev/null +++ b/models/main_models/rt1/tests/rt1_model_test.py @@ -0,0 +1,54 @@ +import torch +from absl.testing import absltest, parameterized + +from rt1_pytorch.rt1_model import RT1Model + + +class RT1ModelTest(parameterized.TestCase): + @parameterized.parameters(["cpu", "cuda"]) + def test_videos(self, device): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + logits = model(videos) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_texts(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + texts = torch.rand(batch_size, 6, 512, device=device) + logits = model(videos, texts) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_action_logits(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + action_logits = torch.rand(batch_size, 6, 11, 256, device=device) + logits = model(videos, action_logits=action_logits) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_texts_and_action_logits(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + texts = torch.rand(batch_size, 6, 512, device=device) + action_logits = torch.rand(batch_size, 6, 11, 256, device=device) + logits = model(videos, texts, action_logits) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/rt1_policy_test.py b/models/main_models/rt1/tests/rt1_policy_test.py new file mode 100644 index 000000000..2d861dc58 --- /dev/null +++ b/models/main_models/rt1/tests/rt1_policy_test.py @@ -0,0 +1,64 @@ +import numpy as np +from absl.testing import absltest, parameterized +from gymnasium.spaces import Box, Dict, Discrete +from skimage import data + +from rt1_pytorch.rt1_policy import RT1Policy + + +class RT1PolicyTest(parameterized.TestCase): + @parameterized.parameters(["cpu", "cuda"]) + def test_policy_act_and_loss(self, device="cpu"): + observation_space = Dict( + image=Box(low=0, high=255, shape=(300, 451, 3), dtype=np.uint8), + context=Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + base_displacement_vertical_rotation=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 + ), + gripper_closedness_action=Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=Discrete(3), + base_displacement_vector=Box( + low=-1.0, + high=1.0, + shape=(3,), + dtype=np.float32, + ), + rotation_delta=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + ) + policy = RT1Policy(observation_space, action_space, device=device) + + image = data.chelsea() + videos = np.reshape(image, (1, 1, *image.shape)).repeat(6, axis=1) + # videos (b, f, h, w, c) = (1, 6, 300, 451, 3) + context = np.random.rand(1, 6, 512).astype(np.float32) + # context (b, f, d) = (1, 6, 512) + observations = {"image": videos, "context": context} + actions = policy.act(observations) + + action_tokens = policy.action_tokenizer.tokenize(actions) + + self.assertEqual(action_tokens.shape, (1, 12)) + obs = {k: v[0][0] for k, v in observations.items()} + act = {k: v[0] for k, v in actions.items()} + self.assertTrue(observation_space.contains(obs)) + self.assertTrue(action_space.contains(act)) + + target_actions = { + k: np.expand_dims(v, axis=1).repeat(6, axis=1) for k, v in actions.items() + } + + loss = policy.loss(observations=observations, target_actions=target_actions) + self.assertGreater(loss, 0) + + # TODO (Rohan138): Add more tests + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/token_learner_test.py b/models/main_models/rt1/tests/token_learner_test.py new file mode 100644 index 000000000..a856b256d --- /dev/null +++ b/models/main_models/rt1/tests/token_learner_test.py @@ -0,0 +1,40 @@ +"""Tests for token_learner.""" +import unittest + +import torch + +from rt1_pytorch.tokenizers.token_learner import TokenLearner + + +class TokenLearnerTest(unittest.TestCase): + def testTokenLearner_h_w_split(self): + batch = 5 + embedding_dim = 512 + num_tokens = 8 + device = "cuda" if torch.cuda.is_available() else "cpu" + token_learner_layer = TokenLearner( + embedding_dim=embedding_dim, num_tokens=num_tokens, device=device + ) + + inputvec = torch.randn((batch, embedding_dim, 10, 10), device=device) + + learnedtokens = token_learner_layer(inputvec) + self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) + + def testTokenLearner_hw(self): + batch = 5 + embedding_dim = 512 + num_tokens = 8 + device = "cuda" if torch.cuda.is_available() else "cpu" + token_learner_layer = TokenLearner( + embedding_dim=embedding_dim, num_tokens=num_tokens, device=device + ) + + inputvec = torch.randn((batch, embedding_dim, 100), device=device) + + learnedtokens = token_learner_layer(inputvec) + self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/models/main_models/rt1/vd4rl_main.py b/models/main_models/rt1/vd4rl_main.py new file mode 100644 index 000000000..bd7a6dc06 --- /dev/null +++ b/models/main_models/rt1/vd4rl_main.py @@ -0,0 +1,389 @@ +import argparse +import os +from typing import Dict, Iterable + +import gymnasium as gym +import h5py +import numpy as np +import requests +import torch +import tqdm +import wandb +from dmc2gymnasium import DMCGym +from sentence_transformers import SentenceTransformer +from torch.optim import Adam + +from rt1_pytorch.rt1_policy import RT1Policy + +DATASET_URL = "https://huggingface.co/datasets/conglu/vd4rl/resolve/main/vd4rl/main/{domain}_{task}/expert/84px/{index}_{domain}_{task}_expert.hdf5" +ACTION_REPEAT = 2 + + +class VD4RLEnv(gym.Env): + def __init__( + self, + env_id: str, + embedding: np.ndarray, + embedding_dim: int, + num_frames: int, + dataset_dir: str, + ): + super().__init__() + self.domain, self.task = env_id.split("-") + self.env = DMCGym(self.domain, self.task) + self.embedding = embedding + self.embedding_dim = embedding_dim + self.num_frames = num_frames + self._load_dataset(dataset_dir) + + @property + def observation_space(self): + return gym.spaces.Dict( + { + "image": gym.spaces.Box( + low=0, high=255, shape=(84, 84, 3), dtype=np.uint8 + ), + "embedding": gym.spaces.Box( + low=-1.0, high=1.0, shape=(self.embedding_dim,), dtype=np.float32 + ), + } + ) + + @property + def action_space(self): + return gym.spaces.Dict({"action_key": self.env.action_space}) + + def reset(self): + _, info = self.env.reset() + obs = self.env.render(84, 84) + return ({"image": obs, "embedding": self.embedding}, info) + + def step(self, action): + action = action["action_key"] + term = False + trunc = False + for _ in range(ACTION_REPEAT): + _, r, term, trunc, info = self.env.step(action) + if term or trunc: + break + o = self.env.render(84, 84) + return ({"image": o, "embedding": self.embedding}, r, term, trunc, info) + + def _load_dataset(self, dataset_dir: str): + os.makedirs(dataset_dir, exist_ok=True) + observations = [] + actions = [] + for index in tqdm.trange(4): + file = f"{index}_{self.domain}_{self.task}_expert.hdf5" + path = os.path.join(dataset_dir, file) + if not os.path.exists(path): + url = DATASET_URL.format( + domain=self.domain, + task=self.task, + index=index, + ) + if self.domain == "humanoid" and self.task == "walk": + url = url.rsplit("/")[0] + f"/{index}_expert.hdf5" + response = requests.get(url) + if response.status_code == 200: + with open(path, "wb") as f: + f.write(response.content) + with h5py.File(path, "r") as f: + observations.append(f["observation"][:]) + actions.append(f["action"][:]) + self.observations = np.concatenate(observations) + self.actions = np.concatenate(actions) + + def get_dataset(self, batch_size: int) -> Iterable[Dict]: + # We expect self.num_frames trajectories per episode + num_episodes = np.ceil(batch_size / self.num_frames).astype(int) + # Leftover trajectories from last episode + prev_obs = None + prev_act = None + for idx in range(0, self.actions.shape[0], num_episodes * 501): + # Get `batch_size` number of episodes + obs = self.observations[idx : idx + num_episodes * 501] + act = self.actions[idx : idx + num_episodes * 501] + + # Convert to (b, t, ...) + obs = np.reshape(obs, (num_episodes, 501, *obs.shape[1:])) + act = np.reshape(act, (num_episodes, 501, *act.shape[1:])) + + # drop the last timestep and action from each episode + obs = obs[:, :-1] + act = act[:, :-1] + + # frame-stack by rolling self.num_frames times over t + num_traj = 500 - self.num_frames + 1 + indices = np.stack( + [np.arange(s, s + num_traj) for s in range(self.num_frames)], + axis=-1, + ) + + # (b, t, ...) -> (b, t - f + 1, f, ...) + obs = np.take(obs, indices, axis=1) + act = np.take(act, indices, axis=1) + + # (b, t - f + 1, f, ...) -> (b * (t - f + 1), f, ...) + obs = np.reshape(obs, (num_episodes * num_traj, *obs.shape[2:])) + act = np.reshape(act, (num_episodes * num_traj, *act.shape[2:])) + + # Concatenate with leftover trajectories from last episode + if prev_obs is not None: + obs = np.concatenate([prev_obs, obs], axis=0) + act = np.concatenate([prev_act, act], axis=0) + + for batch in range(0, obs.shape[0], batch_size): + if batch + batch_size > obs.shape[0]: + # Save leftover trajectories and break + prev_obs = obs[batch:] + prev_act = act[batch:] + break + + yield { + "observation": { + "image": obs[batch : batch + batch_size], + "embedding": np.tile( + np.expand_dims(self.embedding, (0, 1)), + (batch_size, self.num_frames, 1), + ), + }, + "action": {"action_key": act[batch : batch + batch_size]}, + } + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--env", + type=str, + default="walker-walk", + help="name of the environment", + choices=[ + "walker-walk", + "cheetah-run", + "humanoid-walk", + ], + ) + parser.add_argument( + "--context", + type=str, + default="""Move forward by walking upright on two legs, + while maintaining balance and stability""", + ) + # cheetah-run: """Run forward rapidly on all four legs, + # coordinating movements for speed and efficiency""" + parser.add_argument( + "--epochs", + type=int, + default=10, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--batch-size", + type=int, + default=32, + help="batch size in number of trajectories", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=4, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default="all-MiniLM-L6-v2", + help="SentenceTransformer to use for text embedding", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=None, + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=None, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/vd4rl", + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--dataset-dir", + type=str, + default="datasets", + help="local directory for datasets", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + if args.wandb: + wandb.init(project="rt1-vd4rl", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + text_embedding_model = SentenceTransformer(args.sentence_transformer) + embedding_dim = text_embedding_model.get_sentence_embedding_dimension() + embedding = text_embedding_model.encode(args.context) + + print("Loading dataset...") + env = VD4RLEnv( + env_id=args.env, + embedding=embedding, + embedding_dim=embedding_dim, + num_frames=args.trajectory_length, + dataset_dir=args.dataset_dir, + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=env.observation_space, + action_space=env.action_space, + arch="efficientnet_b0", + action_bins=512, + num_layers=4, + num_heads=4, + feed_forward_size=512, + dropout_rate=0.01, + time_sequence_length=args.trajectory_length, + embedding_dim=embedding_dim, + use_token_learner=True, + token_learner_bottleneck_dim=32, + token_learner_num_output_tokens=8, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + return observation["embedding"] + + print("Training...") + num_batches = 0 + for epoch in range(1, args.epochs + 1): + train_dataset = env.get_dataset(batch_size=args.batch_size) + for batch in train_dataset: + policy.model.train() + num_batches += 1 + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + actions = batch["action"] + loss = policy.loss(observations, actions) + if args.wandb: + wandb.log( + {"train_loss": loss.item()}, + step=num_batches * args.batch_size, + ) + else: + print(f"Batch {num_batches} train loss: {loss.item()}") + optimizer.zero_grad() + loss.backward() + optimizer.step() + if args.eval_freq and num_batches % args.eval_freq == 0: + print("Evaluating...") + policy.model.eval() + obs, _ = env.reset() + obs_stacked = { + k: np.stack([v for _ in range(args.trajectory_length)]) + for k, v in obs.items() + } + observations = {"image": [], "context": []} + actions = {"action_key": []} + term = False + trunc = False + reward = 0.0 + ts = 0 + while not (term or trunc): + cur_obs = { + "image": obs_stacked["image"], + "context": get_text_embedding(obs_stacked), + } + + # add batch dimension + cur_obs["image"] = np.expand_dims(cur_obs["image"], axis=0) + cur_obs["context"] = np.expand_dims(cur_obs["context"], axis=0) + + act = policy.act(cur_obs) + + # remove batch dimension + act = {k: v[0] for k, v in act.items()} + new_obs, rew, term, trunc, info = env.step(act) + obs_stacked = { + k: np.concatenate( + [ + obs_stacked[k][1:], + np.expand_dims(new_obs[k], axis=0), + ] + ) + for k in new_obs.keys() + } + observations["image"].append(obs_stacked["image"]) + observations["context"].append(get_text_embedding(obs_stacked)) + actions["action_key"].append(act["action_key"]) + reward += rew * (info["discount"] ** ts) + ts += 1 + if args.wandb: + wandb.log( + {"eval_return": reward}, + step=num_batches * args.batch_size, + ) + else: + print(f"Batch {num_batches} eval return: {reward}") + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{num_batches * args.batch_size * epoch}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + + +if __name__ == "__main__": + main() \ No newline at end of file From 4bfdc0e42ba0339665046d171b963635229eb49d Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 18:29:36 -0400 Subject: [PATCH 08/12] removing old file structure --- models/main_models/rt1/LICENSE | 21 - .../rt1/Open_X_Embodiment_Datasets.ipynb | 2303 ---------- models/main_models/rt1/README.md | 66 - models/main_models/rt1/ai2thor_env.py | 641 --- models/main_models/rt1/data.py | 536 --- models/main_models/rt1/figures/rt1.png | Bin 135877 -> 0 bytes models/main_models/rt1/gen/README.md | 77 - models/main_models/rt1/gen/__init__.py | 0 .../main_models/rt1/gen/agents/agent_base.py | 60 - .../gen/agents/deterministic_planner_agent.py | 26 - .../main_models/rt1/gen/agents/plan_agent.py | 94 - .../gen/agents/semantic_map_planner_agent.py | 72 - models/main_models/rt1/gen/constants.py | 1221 ------ .../main_models/rt1/gen/ff_planner/README.md | 13 - .../rt1/gen/ff_planner/expressions.c | 2623 ----------- .../rt1/gen/ff_planner/expressions.h | 106 - models/main_models/rt1/gen/ff_planner/ff.h | 2044 --------- .../rt1/gen/ff_planner/inst_easy.c | 1220 ------ .../rt1/gen/ff_planner/inst_easy.h | 73 - .../rt1/gen/ff_planner/inst_final.c | 2797 ------------ .../rt1/gen/ff_planner/inst_final.h | 69 - .../rt1/gen/ff_planner/inst_hard.c | 1306 ------ .../rt1/gen/ff_planner/inst_hard.h | 71 - .../main_models/rt1/gen/ff_planner/inst_pre.c | 3854 ----------------- .../main_models/rt1/gen/ff_planner/inst_pre.h | 123 - .../rt1/gen/ff_planner/lex-fct_pddl.l | 139 - .../rt1/gen/ff_planner/lex-ops_pddl.l | 151 - models/main_models/rt1/gen/ff_planner/main.c | 1230 ------ .../main_models/rt1/gen/ff_planner/makefile | 89 - .../main_models/rt1/gen/ff_planner/memory.c | 1278 ------ .../main_models/rt1/gen/ff_planner/memory.h | 109 - .../main_models/rt1/gen/ff_planner/output.c | 1482 ------- .../main_models/rt1/gen/ff_planner/output.h | 68 - models/main_models/rt1/gen/ff_planner/parse.c | 1339 ------ models/main_models/rt1/gen/ff_planner/parse.h | 63 - models/main_models/rt1/gen/ff_planner/relax.c | 2756 ------------ models/main_models/rt1/gen/ff_planner/relax.h | 93 - .../rt1/gen/ff_planner/run_sample.sh | 2 - .../ff_planner/samples/PutTask_domain.pddl | 152 - .../gen/ff_planner/samples/problem_0_0.pddl | 390 -- .../rt1/gen/ff_planner/scan-fct_pddl.y | 918 ---- .../rt1/gen/ff_planner/scan-ops_pddl.y | 1086 ----- .../main_models/rt1/gen/ff_planner/search.c | 2372 ---------- .../main_models/rt1/gen/ff_planner/search.h | 105 - .../rt1/gen/game_states/__init__.py | 0 .../rt1/gen/game_states/game_state_base.py | 935 ---- .../rt1/gen/game_states/planned_game_state.py | 490 --- .../rt1/gen/game_states/task_game_state.py | 368 -- .../task_game_state_full_knowledge.py | 444 -- models/main_models/rt1/gen/goal_library.py | 682 --- models/main_models/rt1/gen/graph/__init__.py | 0 models/main_models/rt1/gen/graph/graph_obj.py | 426 -- .../rt1/gen/layouts/FloorPlan1-layout.npy | Bin 2064 -> 0 bytes .../rt1/gen/layouts/FloorPlan1-objects.json | 51 - .../rt1/gen/layouts/FloorPlan1-openable.json | 146 - .../rt1/gen/layouts/FloorPlan10-layout.npy | Bin 3488 -> 0 bytes .../rt1/gen/layouts/FloorPlan10-objects.json | 49 - .../rt1/gen/layouts/FloorPlan10-openable.json | 110 - .../rt1/gen/layouts/FloorPlan11-layout.npy | Bin 1104 -> 0 bytes .../rt1/gen/layouts/FloorPlan11-objects.json | 43 - .../rt1/gen/layouts/FloorPlan11-openable.json | 128 - .../rt1/gen/layouts/FloorPlan12-layout.npy | Bin 1808 -> 0 bytes .../rt1/gen/layouts/FloorPlan12-objects.json | 40 - .../rt1/gen/layouts/FloorPlan12-openable.json | 218 - .../rt1/gen/layouts/FloorPlan13-layout.npy | Bin 3008 -> 0 bytes .../rt1/gen/layouts/FloorPlan13-objects.json | 43 - .../rt1/gen/layouts/FloorPlan13-openable.json | 224 - .../rt1/gen/layouts/FloorPlan14-layout.npy | Bin 1968 -> 0 bytes .../rt1/gen/layouts/FloorPlan14-objects.json | 40 - .../rt1/gen/layouts/FloorPlan14-openable.json | 68 - .../rt1/gen/layouts/FloorPlan15-layout.npy | Bin 1616 -> 0 bytes .../rt1/gen/layouts/FloorPlan15-objects.json | 45 - .../rt1/gen/layouts/FloorPlan15-openable.json | 92 - .../rt1/gen/layouts/FloorPlan16-layout.npy | Bin 3312 -> 0 bytes .../rt1/gen/layouts/FloorPlan16-objects.json | 46 - .../rt1/gen/layouts/FloorPlan16-openable.json | 200 - .../rt1/gen/layouts/FloorPlan17-layout.npy | Bin 1168 -> 0 bytes .../rt1/gen/layouts/FloorPlan17-objects.json | 47 - .../rt1/gen/layouts/FloorPlan17-openable.json | 140 - .../rt1/gen/layouts/FloorPlan18-layout.npy | Bin 3600 -> 0 bytes .../rt1/gen/layouts/FloorPlan18-objects.json | 48 - .../rt1/gen/layouts/FloorPlan18-openable.json | 146 - .../rt1/gen/layouts/FloorPlan19-layout.npy | Bin 1184 -> 0 bytes .../rt1/gen/layouts/FloorPlan19-objects.json | 40 - .../rt1/gen/layouts/FloorPlan19-openable.json | 182 - .../rt1/gen/layouts/FloorPlan2-layout.npy | Bin 1968 -> 0 bytes .../rt1/gen/layouts/FloorPlan2-objects.json | 43 - .../rt1/gen/layouts/FloorPlan2-openable.json | 164 - .../rt1/gen/layouts/FloorPlan20-layout.npy | Bin 1392 -> 0 bytes .../rt1/gen/layouts/FloorPlan20-objects.json | 46 - .../rt1/gen/layouts/FloorPlan20-openable.json | 116 - .../rt1/gen/layouts/FloorPlan201-layout.npy | Bin 3232 -> 0 bytes .../rt1/gen/layouts/FloorPlan201-objects.json | 37 - .../gen/layouts/FloorPlan201-openable.json | 86 - .../rt1/gen/layouts/FloorPlan202-layout.npy | Bin 2496 -> 0 bytes .../rt1/gen/layouts/FloorPlan202-objects.json | 26 - .../gen/layouts/FloorPlan202-openable.json | 44 - .../rt1/gen/layouts/FloorPlan203-layout.npy | Bin 8512 -> 0 bytes .../rt1/gen/layouts/FloorPlan203-objects.json | 35 - .../gen/layouts/FloorPlan203-openable.json | 86 - .../rt1/gen/layouts/FloorPlan204-layout.npy | Bin 2960 -> 0 bytes .../rt1/gen/layouts/FloorPlan204-objects.json | 31 - .../gen/layouts/FloorPlan204-openable.json | 146 - .../rt1/gen/layouts/FloorPlan205-layout.npy | Bin 4112 -> 0 bytes .../rt1/gen/layouts/FloorPlan205-objects.json | 29 - .../gen/layouts/FloorPlan205-openable.json | 80 - .../rt1/gen/layouts/FloorPlan206-layout.npy | Bin 1904 -> 0 bytes .../rt1/gen/layouts/FloorPlan206-objects.json | 26 - .../gen/layouts/FloorPlan206-openable.json | 122 - .../rt1/gen/layouts/FloorPlan207-layout.npy | Bin 2352 -> 0 bytes .../rt1/gen/layouts/FloorPlan207-objects.json | 27 - .../gen/layouts/FloorPlan207-openable.json | 98 - .../rt1/gen/layouts/FloorPlan208-layout.npy | Bin 3376 -> 0 bytes .../rt1/gen/layouts/FloorPlan208-objects.json | 26 - .../gen/layouts/FloorPlan208-openable.json | 98 - .../rt1/gen/layouts/FloorPlan209-layout.npy | Bin 4816 -> 0 bytes .../rt1/gen/layouts/FloorPlan209-objects.json | 31 - .../gen/layouts/FloorPlan209-openable.json | 62 - .../rt1/gen/layouts/FloorPlan21-layout.npy | Bin 1584 -> 0 bytes .../rt1/gen/layouts/FloorPlan21-objects.json | 47 - .../rt1/gen/layouts/FloorPlan21-openable.json | 86 - .../rt1/gen/layouts/FloorPlan210-layout.npy | Bin 4160 -> 0 bytes .../rt1/gen/layouts/FloorPlan210-objects.json | 30 - .../gen/layouts/FloorPlan210-openable.json | 98 - .../rt1/gen/layouts/FloorPlan211-layout.npy | Bin 2240 -> 0 bytes .../rt1/gen/layouts/FloorPlan211-objects.json | 30 - .../gen/layouts/FloorPlan211-openable.json | 74 - .../rt1/gen/layouts/FloorPlan212-layout.npy | Bin 1856 -> 0 bytes .../rt1/gen/layouts/FloorPlan212-objects.json | 30 - .../gen/layouts/FloorPlan212-openable.json | 80 - .../rt1/gen/layouts/FloorPlan213-layout.npy | Bin 4736 -> 0 bytes .../rt1/gen/layouts/FloorPlan213-objects.json | 27 - .../gen/layouts/FloorPlan213-openable.json | 146 - .../rt1/gen/layouts/FloorPlan214-layout.npy | Bin 3024 -> 0 bytes .../rt1/gen/layouts/FloorPlan214-objects.json | 29 - .../gen/layouts/FloorPlan214-openable.json | 56 - .../rt1/gen/layouts/FloorPlan215-layout.npy | Bin 6208 -> 0 bytes .../rt1/gen/layouts/FloorPlan215-objects.json | 30 - .../gen/layouts/FloorPlan215-openable.json | 92 - .../rt1/gen/layouts/FloorPlan216-layout.npy | Bin 2560 -> 0 bytes .../rt1/gen/layouts/FloorPlan216-objects.json | 28 - .../gen/layouts/FloorPlan216-openable.json | 68 - .../rt1/gen/layouts/FloorPlan217-layout.npy | Bin 2240 -> 0 bytes .../rt1/gen/layouts/FloorPlan217-objects.json | 29 - .../gen/layouts/FloorPlan217-openable.json | 92 - .../rt1/gen/layouts/FloorPlan218-layout.npy | Bin 6400 -> 0 bytes .../rt1/gen/layouts/FloorPlan218-objects.json | 30 - .../gen/layouts/FloorPlan218-openable.json | 68 - .../rt1/gen/layouts/FloorPlan219-layout.npy | Bin 3552 -> 0 bytes .../rt1/gen/layouts/FloorPlan219-objects.json | 31 - .../gen/layouts/FloorPlan219-openable.json | 158 - .../rt1/gen/layouts/FloorPlan22-layout.npy | Bin 2256 -> 0 bytes .../rt1/gen/layouts/FloorPlan22-objects.json | 42 - .../rt1/gen/layouts/FloorPlan22-openable.json | 176 - .../rt1/gen/layouts/FloorPlan220-layout.npy | Bin 3712 -> 0 bytes .../rt1/gen/layouts/FloorPlan220-objects.json | 30 - .../gen/layouts/FloorPlan220-openable.json | 92 - .../rt1/gen/layouts/FloorPlan221-layout.npy | Bin 1904 -> 0 bytes .../rt1/gen/layouts/FloorPlan221-objects.json | 29 - .../gen/layouts/FloorPlan221-openable.json | 44 - .../rt1/gen/layouts/FloorPlan222-layout.npy | Bin 1648 -> 0 bytes .../rt1/gen/layouts/FloorPlan222-objects.json | 26 - .../gen/layouts/FloorPlan222-openable.json | 86 - .../rt1/gen/layouts/FloorPlan223-layout.npy | Bin 3344 -> 0 bytes .../rt1/gen/layouts/FloorPlan223-objects.json | 28 - .../gen/layouts/FloorPlan223-openable.json | 50 - .../rt1/gen/layouts/FloorPlan224-layout.npy | Bin 4688 -> 0 bytes .../rt1/gen/layouts/FloorPlan224-objects.json | 32 - .../gen/layouts/FloorPlan224-openable.json | 182 - .../rt1/gen/layouts/FloorPlan225-layout.npy | Bin 2576 -> 0 bytes .../rt1/gen/layouts/FloorPlan225-objects.json | 31 - .../gen/layouts/FloorPlan225-openable.json | 86 - .../rt1/gen/layouts/FloorPlan226-layout.npy | Bin 1392 -> 0 bytes .../rt1/gen/layouts/FloorPlan226-objects.json | 25 - .../gen/layouts/FloorPlan226-openable.json | 68 - .../rt1/gen/layouts/FloorPlan227-layout.npy | Bin 3232 -> 0 bytes .../rt1/gen/layouts/FloorPlan227-objects.json | 28 - .../gen/layouts/FloorPlan227-openable.json | 206 - .../rt1/gen/layouts/FloorPlan228-layout.npy | Bin 2576 -> 0 bytes .../rt1/gen/layouts/FloorPlan228-objects.json | 27 - .../gen/layouts/FloorPlan228-openable.json | 62 - .../rt1/gen/layouts/FloorPlan229-layout.npy | Bin 3088 -> 0 bytes .../rt1/gen/layouts/FloorPlan229-objects.json | 32 - .../gen/layouts/FloorPlan229-openable.json | 68 - .../rt1/gen/layouts/FloorPlan23-layout.npy | Bin 1648 -> 0 bytes .../rt1/gen/layouts/FloorPlan23-objects.json | 47 - .../rt1/gen/layouts/FloorPlan23-openable.json | 98 - .../rt1/gen/layouts/FloorPlan230-layout.npy | Bin 6448 -> 0 bytes .../rt1/gen/layouts/FloorPlan230-objects.json | 32 - .../gen/layouts/FloorPlan230-openable.json | 56 - .../rt1/gen/layouts/FloorPlan24-layout.npy | Bin 1152 -> 0 bytes .../rt1/gen/layouts/FloorPlan24-objects.json | 42 - .../rt1/gen/layouts/FloorPlan24-openable.json | 176 - .../rt1/gen/layouts/FloorPlan25-layout.npy | Bin 560 -> 0 bytes .../rt1/gen/layouts/FloorPlan25-objects.json | 41 - .../rt1/gen/layouts/FloorPlan25-openable.json | 92 - .../rt1/gen/layouts/FloorPlan26-layout.npy | Bin 1344 -> 0 bytes .../rt1/gen/layouts/FloorPlan26-objects.json | 40 - .../rt1/gen/layouts/FloorPlan26-openable.json | 92 - .../rt1/gen/layouts/FloorPlan27-layout.npy | Bin 784 -> 0 bytes .../rt1/gen/layouts/FloorPlan27-objects.json | 43 - .../rt1/gen/layouts/FloorPlan27-openable.json | 128 - .../rt1/gen/layouts/FloorPlan28-layout.npy | Bin 1712 -> 0 bytes .../rt1/gen/layouts/FloorPlan28-objects.json | 43 - .../rt1/gen/layouts/FloorPlan28-openable.json | 122 - .../rt1/gen/layouts/FloorPlan29-layout.npy | Bin 1168 -> 0 bytes .../rt1/gen/layouts/FloorPlan29-objects.json | 39 - .../rt1/gen/layouts/FloorPlan29-openable.json | 80 - .../rt1/gen/layouts/FloorPlan3-layout.npy | Bin 1856 -> 0 bytes .../rt1/gen/layouts/FloorPlan3-objects.json | 45 - .../rt1/gen/layouts/FloorPlan3-openable.json | 110 - .../rt1/gen/layouts/FloorPlan30-layout.npy | Bin 1296 -> 0 bytes .../rt1/gen/layouts/FloorPlan30-objects.json | 45 - .../rt1/gen/layouts/FloorPlan30-openable.json | 218 - .../rt1/gen/layouts/FloorPlan301-layout.npy | Bin 1392 -> 0 bytes .../rt1/gen/layouts/FloorPlan301-objects.json | 35 - .../gen/layouts/FloorPlan301-openable.json | 122 - .../rt1/gen/layouts/FloorPlan302-layout.npy | Bin 848 -> 0 bytes .../rt1/gen/layouts/FloorPlan302-objects.json | 31 - .../gen/layouts/FloorPlan302-openable.json | 80 - .../rt1/gen/layouts/FloorPlan303-layout.npy | Bin 1168 -> 0 bytes .../rt1/gen/layouts/FloorPlan303-objects.json | 35 - .../gen/layouts/FloorPlan303-openable.json | 122 - .../rt1/gen/layouts/FloorPlan304-layout.npy | Bin 1808 -> 0 bytes .../rt1/gen/layouts/FloorPlan304-objects.json | 30 - .../gen/layouts/FloorPlan304-openable.json | 26 - .../rt1/gen/layouts/FloorPlan305-layout.npy | Bin 1472 -> 0 bytes .../rt1/gen/layouts/FloorPlan305-objects.json | 32 - .../gen/layouts/FloorPlan305-openable.json | 62 - .../rt1/gen/layouts/FloorPlan306-layout.npy | Bin 1632 -> 0 bytes .../rt1/gen/layouts/FloorPlan306-objects.json | 27 - .../gen/layouts/FloorPlan306-openable.json | 68 - .../rt1/gen/layouts/FloorPlan307-layout.npy | Bin 1424 -> 0 bytes .../rt1/gen/layouts/FloorPlan307-objects.json | 34 - .../gen/layouts/FloorPlan307-openable.json | 104 - .../rt1/gen/layouts/FloorPlan308-layout.npy | Bin 1744 -> 0 bytes .../rt1/gen/layouts/FloorPlan308-objects.json | 30 - .../gen/layouts/FloorPlan308-openable.json | 104 - .../rt1/gen/layouts/FloorPlan309-layout.npy | Bin 5760 -> 0 bytes .../rt1/gen/layouts/FloorPlan309-objects.json | 33 - .../gen/layouts/FloorPlan309-openable.json | 74 - .../rt1/gen/layouts/FloorPlan310-layout.npy | Bin 1152 -> 0 bytes .../rt1/gen/layouts/FloorPlan310-objects.json | 31 - .../gen/layouts/FloorPlan310-openable.json | 50 - .../rt1/gen/layouts/FloorPlan311-layout.npy | Bin 3760 -> 0 bytes .../rt1/gen/layouts/FloorPlan311-objects.json | 32 - .../gen/layouts/FloorPlan311-openable.json | 56 - .../rt1/gen/layouts/FloorPlan312-layout.npy | Bin 1440 -> 0 bytes .../rt1/gen/layouts/FloorPlan312-objects.json | 27 - .../gen/layouts/FloorPlan312-openable.json | 74 - .../rt1/gen/layouts/FloorPlan313-layout.npy | Bin 880 -> 0 bytes .../rt1/gen/layouts/FloorPlan313-objects.json | 34 - .../gen/layouts/FloorPlan313-openable.json | 80 - .../rt1/gen/layouts/FloorPlan314-layout.npy | Bin 1200 -> 0 bytes .../rt1/gen/layouts/FloorPlan314-objects.json | 27 - .../gen/layouts/FloorPlan314-openable.json | 50 - .../rt1/gen/layouts/FloorPlan315-layout.npy | Bin 1712 -> 0 bytes .../rt1/gen/layouts/FloorPlan315-objects.json | 28 - .../gen/layouts/FloorPlan315-openable.json | 110 - .../rt1/gen/layouts/FloorPlan316-layout.npy | Bin 1056 -> 0 bytes .../rt1/gen/layouts/FloorPlan316-objects.json | 30 - .../gen/layouts/FloorPlan316-openable.json | 44 - .../rt1/gen/layouts/FloorPlan317-layout.npy | Bin 1680 -> 0 bytes .../rt1/gen/layouts/FloorPlan317-objects.json | 30 - .../gen/layouts/FloorPlan317-openable.json | 92 - .../rt1/gen/layouts/FloorPlan318-layout.npy | Bin 1632 -> 0 bytes .../rt1/gen/layouts/FloorPlan318-objects.json | 31 - .../gen/layouts/FloorPlan318-openable.json | 158 - .../rt1/gen/layouts/FloorPlan319-layout.npy | Bin 1680 -> 0 bytes .../rt1/gen/layouts/FloorPlan319-objects.json | 30 - .../gen/layouts/FloorPlan319-openable.json | 122 - .../rt1/gen/layouts/FloorPlan320-layout.npy | Bin 1200 -> 0 bytes .../rt1/gen/layouts/FloorPlan320-objects.json | 30 - .../gen/layouts/FloorPlan320-openable.json | 50 - .../rt1/gen/layouts/FloorPlan321-layout.npy | Bin 1600 -> 0 bytes .../rt1/gen/layouts/FloorPlan321-objects.json | 27 - .../gen/layouts/FloorPlan321-openable.json | 44 - .../rt1/gen/layouts/FloorPlan322-layout.npy | Bin 1792 -> 0 bytes .../rt1/gen/layouts/FloorPlan322-objects.json | 30 - .../gen/layouts/FloorPlan322-openable.json | 122 - .../rt1/gen/layouts/FloorPlan323-layout.npy | Bin 3184 -> 0 bytes .../rt1/gen/layouts/FloorPlan323-objects.json | 30 - .../gen/layouts/FloorPlan323-openable.json | 80 - .../rt1/gen/layouts/FloorPlan324-layout.npy | Bin 1552 -> 0 bytes .../rt1/gen/layouts/FloorPlan324-objects.json | 29 - .../gen/layouts/FloorPlan324-openable.json | 110 - .../rt1/gen/layouts/FloorPlan325-layout.npy | Bin 3040 -> 0 bytes .../rt1/gen/layouts/FloorPlan325-objects.json | 28 - .../gen/layouts/FloorPlan325-openable.json | 140 - .../rt1/gen/layouts/FloorPlan326-layout.npy | Bin 1728 -> 0 bytes .../rt1/gen/layouts/FloorPlan326-objects.json | 35 - .../gen/layouts/FloorPlan326-openable.json | 128 - .../rt1/gen/layouts/FloorPlan327-layout.npy | Bin 1392 -> 0 bytes .../rt1/gen/layouts/FloorPlan327-objects.json | 29 - .../gen/layouts/FloorPlan327-openable.json | 92 - .../rt1/gen/layouts/FloorPlan328-layout.npy | Bin 1104 -> 0 bytes .../rt1/gen/layouts/FloorPlan328-objects.json | 31 - .../gen/layouts/FloorPlan328-openable.json | 44 - .../rt1/gen/layouts/FloorPlan329-layout.npy | Bin 1536 -> 0 bytes .../rt1/gen/layouts/FloorPlan329-objects.json | 28 - .../gen/layouts/FloorPlan329-openable.json | 50 - .../rt1/gen/layouts/FloorPlan330-layout.npy | Bin 2240 -> 0 bytes .../rt1/gen/layouts/FloorPlan330-objects.json | 32 - .../gen/layouts/FloorPlan330-openable.json | 122 - .../rt1/gen/layouts/FloorPlan4-layout.npy | Bin 1232 -> 0 bytes .../rt1/gen/layouts/FloorPlan4-objects.json | 42 - .../rt1/gen/layouts/FloorPlan4-openable.json | 98 - .../rt1/gen/layouts/FloorPlan401-layout.npy | Bin 1616 -> 0 bytes .../rt1/gen/layouts/FloorPlan401-objects.json | 32 - .../gen/layouts/FloorPlan401-openable.json | 56 - .../rt1/gen/layouts/FloorPlan402-layout.npy | Bin 1584 -> 0 bytes .../rt1/gen/layouts/FloorPlan402-objects.json | 33 - .../gen/layouts/FloorPlan402-openable.json | 92 - .../rt1/gen/layouts/FloorPlan403-layout.npy | Bin 1008 -> 0 bytes .../rt1/gen/layouts/FloorPlan403-objects.json | 34 - .../gen/layouts/FloorPlan403-openable.json | 50 - .../rt1/gen/layouts/FloorPlan404-layout.npy | Bin 1008 -> 0 bytes .../rt1/gen/layouts/FloorPlan404-objects.json | 29 - .../gen/layouts/FloorPlan404-openable.json | 38 - .../rt1/gen/layouts/FloorPlan405-layout.npy | Bin 576 -> 0 bytes .../rt1/gen/layouts/FloorPlan405-objects.json | 28 - .../gen/layouts/FloorPlan405-openable.json | 56 - .../rt1/gen/layouts/FloorPlan406-layout.npy | Bin 1664 -> 0 bytes .../rt1/gen/layouts/FloorPlan406-objects.json | 28 - .../gen/layouts/FloorPlan406-openable.json | 26 - .../rt1/gen/layouts/FloorPlan407-layout.npy | Bin 672 -> 0 bytes .../rt1/gen/layouts/FloorPlan407-objects.json | 32 - .../gen/layouts/FloorPlan407-openable.json | 56 - .../rt1/gen/layouts/FloorPlan408-layout.npy | Bin 704 -> 0 bytes .../rt1/gen/layouts/FloorPlan408-objects.json | 28 - .../gen/layouts/FloorPlan408-openable.json | 62 - .../rt1/gen/layouts/FloorPlan409-layout.npy | Bin 752 -> 0 bytes .../rt1/gen/layouts/FloorPlan409-objects.json | 28 - .../gen/layouts/FloorPlan409-openable.json | 62 - .../rt1/gen/layouts/FloorPlan410-layout.npy | Bin 1408 -> 0 bytes .../rt1/gen/layouts/FloorPlan410-objects.json | 29 - .../gen/layouts/FloorPlan410-openable.json | 74 - .../rt1/gen/layouts/FloorPlan411-layout.npy | Bin 1104 -> 0 bytes .../rt1/gen/layouts/FloorPlan411-objects.json | 31 - .../gen/layouts/FloorPlan411-openable.json | 62 - .../rt1/gen/layouts/FloorPlan412-layout.npy | Bin 784 -> 0 bytes .../rt1/gen/layouts/FloorPlan412-objects.json | 29 - .../gen/layouts/FloorPlan412-openable.json | 50 - .../rt1/gen/layouts/FloorPlan413-layout.npy | Bin 1216 -> 0 bytes .../rt1/gen/layouts/FloorPlan413-objects.json | 32 - .../gen/layouts/FloorPlan413-openable.json | 92 - .../rt1/gen/layouts/FloorPlan414-layout.npy | Bin 800 -> 0 bytes .../rt1/gen/layouts/FloorPlan414-objects.json | 31 - .../gen/layouts/FloorPlan414-openable.json | 92 - .../rt1/gen/layouts/FloorPlan415-layout.npy | Bin 880 -> 0 bytes .../rt1/gen/layouts/FloorPlan415-objects.json | 31 - .../gen/layouts/FloorPlan415-openable.json | 68 - .../rt1/gen/layouts/FloorPlan416-layout.npy | Bin 992 -> 0 bytes .../rt1/gen/layouts/FloorPlan416-objects.json | 28 - .../gen/layouts/FloorPlan416-openable.json | 44 - .../rt1/gen/layouts/FloorPlan417-layout.npy | Bin 1088 -> 0 bytes .../rt1/gen/layouts/FloorPlan417-objects.json | 29 - .../gen/layouts/FloorPlan417-openable.json | 44 - .../rt1/gen/layouts/FloorPlan418-layout.npy | Bin 864 -> 0 bytes .../rt1/gen/layouts/FloorPlan418-objects.json | 29 - .../gen/layouts/FloorPlan418-openable.json | 44 - .../rt1/gen/layouts/FloorPlan419-layout.npy | Bin 608 -> 0 bytes .../rt1/gen/layouts/FloorPlan419-objects.json | 30 - .../gen/layouts/FloorPlan419-openable.json | 44 - .../rt1/gen/layouts/FloorPlan420-layout.npy | Bin 560 -> 0 bytes .../rt1/gen/layouts/FloorPlan420-objects.json | 29 - .../gen/layouts/FloorPlan420-openable.json | 32 - .../rt1/gen/layouts/FloorPlan421-layout.npy | Bin 608 -> 0 bytes .../rt1/gen/layouts/FloorPlan421-objects.json | 29 - .../gen/layouts/FloorPlan421-openable.json | 68 - .../rt1/gen/layouts/FloorPlan422-layout.npy | Bin 656 -> 0 bytes .../rt1/gen/layouts/FloorPlan422-objects.json | 33 - .../gen/layouts/FloorPlan422-openable.json | 86 - .../rt1/gen/layouts/FloorPlan423-layout.npy | Bin 1008 -> 0 bytes .../rt1/gen/layouts/FloorPlan423-objects.json | 32 - .../gen/layouts/FloorPlan423-openable.json | 86 - .../rt1/gen/layouts/FloorPlan424-layout.npy | Bin 736 -> 0 bytes .../rt1/gen/layouts/FloorPlan424-objects.json | 28 - .../gen/layouts/FloorPlan424-openable.json | 56 - .../rt1/gen/layouts/FloorPlan425-layout.npy | Bin 512 -> 0 bytes .../rt1/gen/layouts/FloorPlan425-objects.json | 30 - .../gen/layouts/FloorPlan425-openable.json | 56 - .../rt1/gen/layouts/FloorPlan426-layout.npy | Bin 912 -> 0 bytes .../rt1/gen/layouts/FloorPlan426-objects.json | 31 - .../gen/layouts/FloorPlan426-openable.json | 68 - .../rt1/gen/layouts/FloorPlan427-layout.npy | Bin 992 -> 0 bytes .../rt1/gen/layouts/FloorPlan427-objects.json | 32 - .../gen/layouts/FloorPlan427-openable.json | 80 - .../rt1/gen/layouts/FloorPlan428-layout.npy | Bin 992 -> 0 bytes .../rt1/gen/layouts/FloorPlan428-objects.json | 28 - .../gen/layouts/FloorPlan428-openable.json | 50 - .../rt1/gen/layouts/FloorPlan429-layout.npy | Bin 1152 -> 0 bytes .../rt1/gen/layouts/FloorPlan429-objects.json | 29 - .../gen/layouts/FloorPlan429-openable.json | 38 - .../rt1/gen/layouts/FloorPlan430-layout.npy | Bin 1760 -> 0 bytes .../rt1/gen/layouts/FloorPlan430-objects.json | 35 - .../gen/layouts/FloorPlan430-openable.json | 50 - .../rt1/gen/layouts/FloorPlan5-layout.npy | Bin 1680 -> 0 bytes .../rt1/gen/layouts/FloorPlan5-objects.json | 47 - .../rt1/gen/layouts/FloorPlan5-openable.json | 152 - .../rt1/gen/layouts/FloorPlan6-layout.npy | Bin 2176 -> 0 bytes .../rt1/gen/layouts/FloorPlan6-objects.json | 42 - .../rt1/gen/layouts/FloorPlan6-openable.json | 164 - .../rt1/gen/layouts/FloorPlan7-layout.npy | Bin 4352 -> 0 bytes .../rt1/gen/layouts/FloorPlan7-objects.json | 50 - .../rt1/gen/layouts/FloorPlan7-openable.json | 146 - .../rt1/gen/layouts/FloorPlan8-layout.npy | Bin 2768 -> 0 bytes .../rt1/gen/layouts/FloorPlan8-objects.json | 46 - .../rt1/gen/layouts/FloorPlan8-openable.json | 170 - .../rt1/gen/layouts/FloorPlan9-layout.npy | Bin 1360 -> 0 bytes .../rt1/gen/layouts/FloorPlan9-objects.json | 42 - .../rt1/gen/layouts/FloorPlan9-openable.json | 260 -- .../layouts/precompute_layout_locations.py | 350 -- .../main_models/rt1/gen/planner/__init__.py | 0 .../domains/PutTaskExtended_domain.pddl | 302 -- .../rt1/gen/planner/ff_planner_handler.py | 252 -- models/main_models/rt1/gen/planner/pddl.pdf | Bin 196613 -> 0 bytes .../rt1/gen/scripts/augment_trajectories.py | 312 -- .../rt1/gen/scripts/generate_trajectories.py | 752 ---- .../rt1/gen/scripts/replay_checks.py | 217 - models/main_models/rt1/gen/utils/__init__.py | 0 models/main_models/rt1/gen/utils/bb_util.py | 139 - .../rt1/gen/utils/dataset_management_util.py | 69 - models/main_models/rt1/gen/utils/game_util.py | 363 -- .../main_models/rt1/gen/utils/image_util.py | 57 - models/main_models/rt1/gen/utils/py_util.py | 84 - .../main_models/rt1/gen/utils/replay_json.py | 52 - .../main_models/rt1/gen/utils/video_util.py | 11 - .../lanmp_dataloader/attribute_limits.json | 1 - .../rt1/lanmp_dataloader/rt1_dataloader.py | 800 ---- .../rt1/lanmp_dataloader/scene_to_keys.json | 1 - models/main_models/rt1/main.py | 257 -- models/main_models/rt1/main_ft.py | 387 -- models/main_models/rt1/main_ft_eval.py | 279 -- models/main_models/rt1/rollout_ai2thor.py | 366 -- .../main_models/rt1/rt1_env/bin/Activate.ps1 | 241 -- models/main_models/rt1/rt1_env/bin/activate | 66 - .../main_models/rt1/rt1_env/bin/activate.csh | 25 - .../main_models/rt1/rt1_env/bin/activate.fish | 64 - .../main_models/rt1/rt1_env/bin/ai2thor-xorg | 267 -- .../rt1/rt1_env/bin/convert-caffe2-to-onnx | 10 - .../rt1/rt1_env/bin/convert-onnx-to-caffe2 | 10 - models/main_models/rt1/rt1_env/bin/f2py | 10 - models/main_models/rt1/rt1_env/bin/flask | 10 - .../rt1/rt1_env/bin/huggingface-cli | 10 - .../rt1/rt1_env/bin/imageio_download_bin | 10 - .../rt1/rt1_env/bin/imageio_remove_bin | 10 - .../rt1/rt1_env/bin/import_pb_to_tensorboard | 10 - models/main_models/rt1/rt1_env/bin/isympy | 10 - models/main_models/rt1/rt1_env/bin/jp.py | 54 - models/main_models/rt1/rt1_env/bin/lsm2bin | 10 - .../main_models/rt1/rt1_env/bin/markdown-it | 10 - .../main_models/rt1/rt1_env/bin/markdown_py | 10 - models/main_models/rt1/rt1_env/bin/normalizer | 10 - models/main_models/rt1/rt1_env/bin/pip | 10 - models/main_models/rt1/rt1_env/bin/pip3 | 10 - models/main_models/rt1/rt1_env/bin/pip3.9 | 10 - .../main_models/rt1/rt1_env/bin/portserver.py | 415 -- .../main_models/rt1/rt1_env/bin/progressbar | 10 - models/main_models/rt1/rt1_env/bin/pygmentize | 10 - models/main_models/rt1/rt1_env/bin/python | 1 - models/main_models/rt1/rt1_env/bin/python3 | 1 - models/main_models/rt1/rt1_env/bin/python3.9 | 1 - models/main_models/rt1/rt1_env/bin/pythoni | 36 - models/main_models/rt1/rt1_env/bin/pythoni1 | 17 - .../main_models/rt1/rt1_env/bin/reverb_server | 10 - .../rt1/rt1_env/bin/saved_model_cli | 10 - .../main_models/rt1/rt1_env/bin/tensorboard | 10 - .../main_models/rt1/rt1_env/bin/tf_upgrade_v2 | 10 - models/main_models/rt1/rt1_env/bin/tfds | 10 - .../rt1/rt1_env/bin/tflite_convert | 10 - .../main_models/rt1/rt1_env/bin/tiff2fsspec | 10 - .../main_models/rt1/rt1_env/bin/tiffcomment | 10 - models/main_models/rt1/rt1_env/bin/tifffile | 10 - models/main_models/rt1/rt1_env/bin/toco | 10 - .../rt1/rt1_env/bin/toco_from_protos | 10 - models/main_models/rt1/rt1_env/bin/torchrun | 10 - models/main_models/rt1/rt1_env/bin/tqdm | 10 - .../rt1/rt1_env/bin/transformers-cli | 10 - models/main_models/rt1/rt1_env/bin/tree-cli | 10 - models/main_models/rt1/rt1_env/bin/wandb | 10 - models/main_models/rt1/rt1_env/bin/wb | 10 - models/main_models/rt1/rt1_env/bin/wheel | 10 - .../site/python3.9/dm-reverb/checkpoint.proto | 77 - .../site/python3.9/dm-reverb/patterns.proto | 123 - .../python3.9/dm-reverb/reverb_config.proto | 10 - .../site/python3.9/dm-reverb/schema.proto | 289 -- models/main_models/rt1/rt1_env/lib64 | 1 - models/main_models/rt1/rt1_env/pyvenv.cfg | 3 - .../rt1/rt1_env/share/man/man1/isympy.1 | 188 - .../main_models/rt1/rt1_pytorch/__init__.py | 0 .../rt1_pytorch/film_efficientnet/__init__.py | 0 .../film_conditioning_layer.py | 38 - .../film_efficientnet/film_efficientnet.py | 446 -- .../main_models/rt1/rt1_pytorch/rt1_model.py | 217 - .../main_models/rt1/rt1_pytorch/rt1_policy.py | 234 - .../rt1/rt1_pytorch/tokenizers/__init__.py | 0 .../tokenizers/action_tokenizer.py | 184 - .../rt1_pytorch/tokenizers/image_tokenizer.py | 77 - .../rt1_pytorch/tokenizers/token_learner.py | 89 - models/main_models/rt1/setup.py | 44 - .../rt1/tests/action_tokenizer_test.py | 166 - .../rt1/tests/film_conditioning_layer_test.py | 27 - .../rt1/tests/film_efficientnet_test.py | 57 - .../rt1/tests/image_tokenizer_test.py | 53 - .../main_models/rt1/tests/rt1_model_test.py | 54 - .../main_models/rt1/tests/rt1_policy_test.py | 64 - .../rt1/tests/token_learner_test.py | 40 - models/main_models/rt1/vd4rl_main.py | 389 -- 509 files changed, 61499 deletions(-) delete mode 100644 models/main_models/rt1/LICENSE delete mode 100644 models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb delete mode 100644 models/main_models/rt1/README.md delete mode 100644 models/main_models/rt1/ai2thor_env.py delete mode 100644 models/main_models/rt1/data.py delete mode 100644 models/main_models/rt1/figures/rt1.png delete mode 100644 models/main_models/rt1/gen/README.md delete mode 100644 models/main_models/rt1/gen/__init__.py delete mode 100644 models/main_models/rt1/gen/agents/agent_base.py delete mode 100644 models/main_models/rt1/gen/agents/deterministic_planner_agent.py delete mode 100644 models/main_models/rt1/gen/agents/plan_agent.py delete mode 100644 models/main_models/rt1/gen/agents/semantic_map_planner_agent.py delete mode 100644 models/main_models/rt1/gen/constants.py delete mode 100644 models/main_models/rt1/gen/ff_planner/README.md delete mode 100644 models/main_models/rt1/gen/ff_planner/expressions.c delete mode 100644 models/main_models/rt1/gen/ff_planner/expressions.h delete mode 100644 models/main_models/rt1/gen/ff_planner/ff.h delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_easy.c delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_easy.h delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_final.c delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_final.h delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_hard.c delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_hard.h delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_pre.c delete mode 100644 models/main_models/rt1/gen/ff_planner/inst_pre.h delete mode 100644 models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l delete mode 100644 models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l delete mode 100644 models/main_models/rt1/gen/ff_planner/main.c delete mode 100644 models/main_models/rt1/gen/ff_planner/makefile delete mode 100644 models/main_models/rt1/gen/ff_planner/memory.c delete mode 100644 models/main_models/rt1/gen/ff_planner/memory.h delete mode 100644 models/main_models/rt1/gen/ff_planner/output.c delete mode 100644 models/main_models/rt1/gen/ff_planner/output.h delete mode 100644 models/main_models/rt1/gen/ff_planner/parse.c delete mode 100644 models/main_models/rt1/gen/ff_planner/parse.h delete mode 100644 models/main_models/rt1/gen/ff_planner/relax.c delete mode 100644 models/main_models/rt1/gen/ff_planner/relax.h delete mode 100755 models/main_models/rt1/gen/ff_planner/run_sample.sh delete mode 100644 models/main_models/rt1/gen/ff_planner/samples/PutTask_domain.pddl delete mode 100644 models/main_models/rt1/gen/ff_planner/samples/problem_0_0.pddl delete mode 100644 models/main_models/rt1/gen/ff_planner/scan-fct_pddl.y delete mode 100644 models/main_models/rt1/gen/ff_planner/scan-ops_pddl.y delete mode 100644 models/main_models/rt1/gen/ff_planner/search.c delete mode 100644 models/main_models/rt1/gen/ff_planner/search.h delete mode 100644 models/main_models/rt1/gen/game_states/__init__.py delete mode 100644 models/main_models/rt1/gen/game_states/game_state_base.py delete mode 100644 models/main_models/rt1/gen/game_states/planned_game_state.py delete mode 100644 models/main_models/rt1/gen/game_states/task_game_state.py delete mode 100644 models/main_models/rt1/gen/game_states/task_game_state_full_knowledge.py delete mode 100644 models/main_models/rt1/gen/goal_library.py delete mode 100644 models/main_models/rt1/gen/graph/__init__.py delete mode 100644 models/main_models/rt1/gen/graph/graph_obj.py delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-objects.json delete mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-openable.json delete mode 100644 models/main_models/rt1/gen/layouts/precompute_layout_locations.py delete mode 100644 models/main_models/rt1/gen/planner/__init__.py delete mode 100644 models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl delete mode 100644 models/main_models/rt1/gen/planner/ff_planner_handler.py delete mode 100644 models/main_models/rt1/gen/planner/pddl.pdf delete mode 100644 models/main_models/rt1/gen/scripts/augment_trajectories.py delete mode 100644 models/main_models/rt1/gen/scripts/generate_trajectories.py delete mode 100644 models/main_models/rt1/gen/scripts/replay_checks.py delete mode 100644 models/main_models/rt1/gen/utils/__init__.py delete mode 100644 models/main_models/rt1/gen/utils/bb_util.py delete mode 100644 models/main_models/rt1/gen/utils/dataset_management_util.py delete mode 100644 models/main_models/rt1/gen/utils/game_util.py delete mode 100644 models/main_models/rt1/gen/utils/image_util.py delete mode 100644 models/main_models/rt1/gen/utils/py_util.py delete mode 100644 models/main_models/rt1/gen/utils/replay_json.py delete mode 100644 models/main_models/rt1/gen/utils/video_util.py delete mode 100644 models/main_models/rt1/lanmp_dataloader/attribute_limits.json delete mode 100644 models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py delete mode 100644 models/main_models/rt1/lanmp_dataloader/scene_to_keys.json delete mode 100644 models/main_models/rt1/main.py delete mode 100644 models/main_models/rt1/main_ft.py delete mode 100644 models/main_models/rt1/main_ft_eval.py delete mode 100644 models/main_models/rt1/rollout_ai2thor.py delete mode 100644 models/main_models/rt1/rt1_env/bin/Activate.ps1 delete mode 100644 models/main_models/rt1/rt1_env/bin/activate delete mode 100644 models/main_models/rt1/rt1_env/bin/activate.csh delete mode 100644 models/main_models/rt1/rt1_env/bin/activate.fish delete mode 100755 models/main_models/rt1/rt1_env/bin/ai2thor-xorg delete mode 100755 models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx delete mode 100755 models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 delete mode 100755 models/main_models/rt1/rt1_env/bin/f2py delete mode 100755 models/main_models/rt1/rt1_env/bin/flask delete mode 100755 models/main_models/rt1/rt1_env/bin/huggingface-cli delete mode 100755 models/main_models/rt1/rt1_env/bin/imageio_download_bin delete mode 100755 models/main_models/rt1/rt1_env/bin/imageio_remove_bin delete mode 100755 models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard delete mode 100755 models/main_models/rt1/rt1_env/bin/isympy delete mode 100755 models/main_models/rt1/rt1_env/bin/jp.py delete mode 100755 models/main_models/rt1/rt1_env/bin/lsm2bin delete mode 100755 models/main_models/rt1/rt1_env/bin/markdown-it delete mode 100755 models/main_models/rt1/rt1_env/bin/markdown_py delete mode 100755 models/main_models/rt1/rt1_env/bin/normalizer delete mode 100755 models/main_models/rt1/rt1_env/bin/pip delete mode 100755 models/main_models/rt1/rt1_env/bin/pip3 delete mode 100755 models/main_models/rt1/rt1_env/bin/pip3.9 delete mode 100755 models/main_models/rt1/rt1_env/bin/portserver.py delete mode 100755 models/main_models/rt1/rt1_env/bin/progressbar delete mode 100755 models/main_models/rt1/rt1_env/bin/pygmentize delete mode 120000 models/main_models/rt1/rt1_env/bin/python delete mode 120000 models/main_models/rt1/rt1_env/bin/python3 delete mode 120000 models/main_models/rt1/rt1_env/bin/python3.9 delete mode 100755 models/main_models/rt1/rt1_env/bin/pythoni delete mode 100755 models/main_models/rt1/rt1_env/bin/pythoni1 delete mode 100755 models/main_models/rt1/rt1_env/bin/reverb_server delete mode 100755 models/main_models/rt1/rt1_env/bin/saved_model_cli delete mode 100755 models/main_models/rt1/rt1_env/bin/tensorboard delete mode 100755 models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 delete mode 100755 models/main_models/rt1/rt1_env/bin/tfds delete mode 100755 models/main_models/rt1/rt1_env/bin/tflite_convert delete mode 100755 models/main_models/rt1/rt1_env/bin/tiff2fsspec delete mode 100755 models/main_models/rt1/rt1_env/bin/tiffcomment delete mode 100755 models/main_models/rt1/rt1_env/bin/tifffile delete mode 100755 models/main_models/rt1/rt1_env/bin/toco delete mode 100755 models/main_models/rt1/rt1_env/bin/toco_from_protos delete mode 100755 models/main_models/rt1/rt1_env/bin/torchrun delete mode 100755 models/main_models/rt1/rt1_env/bin/tqdm delete mode 100755 models/main_models/rt1/rt1_env/bin/transformers-cli delete mode 100755 models/main_models/rt1/rt1_env/bin/tree-cli delete mode 100755 models/main_models/rt1/rt1_env/bin/wandb delete mode 100755 models/main_models/rt1/rt1_env/bin/wb delete mode 100755 models/main_models/rt1/rt1_env/bin/wheel delete mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto delete mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto delete mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto delete mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto delete mode 120000 models/main_models/rt1/rt1_env/lib64 delete mode 100644 models/main_models/rt1/rt1_env/pyvenv.cfg delete mode 100644 models/main_models/rt1/rt1_env/share/man/man1/isympy.1 delete mode 100644 models/main_models/rt1/rt1_pytorch/__init__.py delete mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py delete mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py delete mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py delete mode 100644 models/main_models/rt1/rt1_pytorch/rt1_model.py delete mode 100644 models/main_models/rt1/rt1_pytorch/rt1_policy.py delete mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py delete mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py delete mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py delete mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py delete mode 100644 models/main_models/rt1/setup.py delete mode 100644 models/main_models/rt1/tests/action_tokenizer_test.py delete mode 100644 models/main_models/rt1/tests/film_conditioning_layer_test.py delete mode 100644 models/main_models/rt1/tests/film_efficientnet_test.py delete mode 100644 models/main_models/rt1/tests/image_tokenizer_test.py delete mode 100644 models/main_models/rt1/tests/rt1_model_test.py delete mode 100644 models/main_models/rt1/tests/rt1_policy_test.py delete mode 100644 models/main_models/rt1/tests/token_learner_test.py delete mode 100644 models/main_models/rt1/vd4rl_main.py diff --git a/models/main_models/rt1/LICENSE b/models/main_models/rt1/LICENSE deleted file mode 100644 index 272afdf8f..000000000 --- a/models/main_models/rt1/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2022 Phil Wang - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb b/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb deleted file mode 100644 index 2b2235541..000000000 --- a/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb +++ /dev/null @@ -1,2303 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "EnWCKLGGaf-d" - }, - "source": [ - "# Open X-Embodiment Datasets\n", - "\n", - "![](https://robotics-transformer-x.github.io/img/overview.png)\n", - "\n", - "This colab helps you **visualize** the datasets in the Open X-Embodiment Dataset, explains how to **download** them and how to **train** with them.\n", - "\n", - "Table of Content:" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "toc", - "id": "UyiiBjzmaIQu" - }, - "source": [ - ">[Open X-Embodiment Datasets](#scrollTo=EnWCKLGGaf-d)\n", - "\n", - ">[Visualize Datasets](#scrollTo=29c7oLlJbWwF)\n", - "\n", - ">[Download Datasets](#scrollTo=-WHN-2OrKqGo)\n", - "\n", - ">[Data Loader Example](#scrollTo=IyccDsRqwtMz)\n", - "\n", - ">[Interleave Multiple Datasets](#scrollTo=ekmsGRAnw3Bp)\n", - "\n", - ">[Example Dataloader to produce trajectories](#scrollTo=aew258oUbamg)\n", - "\n", - ">>[Demonstration of transformation from an episode to a trajectory](#scrollTo=BK4RRYkbLN5B)\n", - "\n", - ">>[Combination of multiple datasets](#scrollTo=Oy89HzymQyAq)\n", - "\n", - ">[Available datasets:](#scrollTo=N2Efw2aHVfSX)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "29c7oLlJbWwF" - }, - "source": [ - "# Visualize Datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "id": "l7OogZYi7qwT" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import tensorflow_datasets as tfds\n", - "from PIL import Image\n", - "from IPython import display\n", - "\n", - "DATASETS = [\n", - " \"fractal20220817_data\",\n", - " \"kuka\",\n", - " \"bridge\",\n", - " \"taco_play\",\n", - " \"jaco_play\",\n", - " \"berkeley_cable_routing\",\n", - " \"roboturk\",\n", - " \"nyu_door_opening_surprising_effectiveness\",\n", - " \"viola\",\n", - " \"berkeley_autolab_ur5\",\n", - " \"toto\",\n", - " \"language_table\",\n", - " \"columbia_cairlab_pusht_real\",\n", - " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", - " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", - " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", - " \"austin_buds_dataset_converted_externally_to_rlds\",\n", - " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", - " \"maniskill_dataset_converted_externally_to_rlds\",\n", - " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", - " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", - " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", - " \"bc_z\",\n", - " \"usc_cloth_sim_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", - " \"utokyo_saytap_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", - " \"robo_net\",\n", - " \"berkeley_mvp_converted_externally_to_rlds\",\n", - " \"berkeley_rpt_converted_externally_to_rlds\",\n", - " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", - " \"stanford_mask_vit_converted_externally_to_rlds\",\n", - " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", - " \"dlr_sara_pour_converted_externally_to_rlds\",\n", - " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", - " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", - " \"asu_table_top_converted_externally_to_rlds\",\n", - " \"stanford_robocook_converted_externally_to_rlds\",\n", - " \"eth_agent_affordances\",\n", - " \"imperialcollege_sawyer_wrist_cam\",\n", - " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", - " \"uiuc_d3field\",\n", - " \"utaustin_mutex\",\n", - " \"berkeley_fanuc_manipulation\",\n", - " \"cmu_play_fusion\",\n", - " \"cmu_stretch\",\n", - " \"berkeley_gnm_recon\",\n", - " \"berkeley_gnm_cory_hall\",\n", - " \"berkeley_gnm_sac_son\",\n", - "]\n", - "\n", - "\n", - "def dataset2path(name):\n", - " if name == \"robo_net\":\n", - " version = \"1.0.0\"\n", - " elif name == \"language_table\":\n", - " version = \"0.0.1\"\n", - " else:\n", - " version = \"0.1.0\"\n", - " return f\"gs://gresearch/robotics/{name}/{version}\"\n", - "\n", - "\n", - "def as_gif(images, path=\"temp.gif\"):\n", - " # Render the images as the gif:\n", - " images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0)\n", - " gif_bytes = open(path, \"rb\").read()\n", - " return gif_bytes" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 497 - }, - "id": "Gcw4eHmxbZjx", - "outputId": "a2cc46f1-5eec-41b8-fa23-6b4797b1e1e1" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# choose the dataset path in the dropdown on the right and rerun this cell\n", - "# to see multiple samples\n", - "\n", - "dataset = \"fractal20220817_data\" # @param ['fractal20220817_data', 'kuka', 'bridge', 'taco_play', 'jaco_play', 'berkeley_cable_routing', 'roboturk', 'nyu_door_opening_surprising_effectiveness', 'viola', 'berkeley_autolab_ur5', 'toto', 'language_table', 'columbia_cairlab_pusht_real', 'stanford_kuka_multimodal_dataset_converted_externally_to_rlds', 'nyu_rot_dataset_converted_externally_to_rlds', 'stanford_hydra_dataset_converted_externally_to_rlds', 'austin_buds_dataset_converted_externally_to_rlds', 'nyu_franka_play_dataset_converted_externally_to_rlds', 'maniskill_dataset_converted_externally_to_rlds', 'furniture_bench_dataset_converted_externally_to_rlds', 'cmu_franka_exploration_dataset_converted_externally_to_rlds', 'ucsd_kitchen_dataset_converted_externally_to_rlds', 'ucsd_pick_and_place_dataset_converted_externally_to_rlds', 'austin_sailor_dataset_converted_externally_to_rlds', 'austin_sirius_dataset_converted_externally_to_rlds', 'bc_z', 'usc_cloth_sim_converted_externally_to_rlds', 'utokyo_pr2_opening_fridge_converted_externally_to_rlds', 'utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds', 'utokyo_saytap_converted_externally_to_rlds', 'utokyo_xarm_pick_and_place_converted_externally_to_rlds', 'utokyo_xarm_bimanual_converted_externally_to_rlds', 'robo_net', 'berkeley_mvp_converted_externally_to_rlds', 'berkeley_rpt_converted_externally_to_rlds', 'kaist_nonprehensile_converted_externally_to_rlds', 'stanford_mask_vit_converted_externally_to_rlds', 'tokyo_u_lsmo_converted_externally_to_rlds', 'dlr_sara_pour_converted_externally_to_rlds', 'dlr_sara_grid_clamp_converted_externally_to_rlds', 'dlr_edan_shared_control_converted_externally_to_rlds', 'asu_table_top_converted_externally_to_rlds', 'stanford_robocook_converted_externally_to_rlds', 'eth_agent_affordances', 'imperialcollege_sawyer_wrist_cam', 'iamlab_cmu_pickup_insert_converted_externally_to_rlds', 'uiuc_d3field', 'utaustin_mutex', 'berkeley_fanuc_manipulation', 'cmu_food_manipulation', 'cmu_play_fusion', 'cmu_stretch', 'berkeley_gnm_recon', 'berkeley_gnm_cory_hall', 'berkeley_gnm_sac_son']\n", - "display_key = \"image\"\n", - "\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "if display_key not in b.info.features[\"steps\"][\"observation\"]:\n", - " raise ValueError(\n", - " f\"The key {display_key} was not found in this dataset.\\n\"\n", - " + \"Please choose a different image key to display for this dataset.\\n\"\n", - " + \"Here is the observation spec:\\n\"\n", - " + str(b.info.features[\"steps\"][\"observation\"])\n", - " )\n", - "\n", - "ds = b.as_dataset(split=\"train[:10]\").shuffle(10) # take only first 10 episodes\n", - "episode = next(iter(ds))\n", - "images = [step[\"observation\"][display_key] for step in episode[\"steps\"]]\n", - "images = [Image.fromarray(image.numpy()) for image in images]\n", - "display.Image(as_gif(images))" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "YrD4_8P9JxBw", - "outputId": "6c4bcf5f-b738-472c-d084-9c87f56962c8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('action', {'base_displacement_vector': , 'base_displacement_vertical_rotation': , 'gripper_closedness_action': , 'rotation_delta': , 'terminate_episode': , 'world_vector': })\n", - "('is_first', )\n", - "('is_last', )\n", - "('is_terminal', )\n", - "('observation', {'base_pose_tool_reached': , 'gripper_closed': , 'gripper_closedness_commanded': , 'height_to_bottom': , 'image': , 'natural_language_embedding': , 'natural_language_instruction': , 'orientation_box': , 'orientation_start': , 'robot_orientation_positions_box': , 'rotation_delta_to_go': , 'src_rotation': , 'vector_to_go': , 'workspace_bounds': })\n", - "('reward', )\n" - ] - } - ], - "source": [ - "# other elements of the episode step --> this may vary for each dataset\n", - "for elem in next(iter(episode[\"steps\"])).items():\n", - " print(elem)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-WHN-2OrKqGo" - }, - "source": [ - "# Download Datasets\n", - "\n", - "All datasets can be downloaded simply via `tfds.load()`.\n", - "Below we provide a script that downloads all datasets into `~/tensorflow_datasets` on your local machine. Simply copy the code and run it on your local machine to download the full dataset (XXX TB).\n", - "\n", - "If you want to filter the dataset before download, please refer to\n", - "[this Google Sheet](https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit?usp=sharing). It allows you\n", - "to filter the data by attributes like robot model, number of cameras, type of tasks etc. You can then download only the filtered datasets by pasting the\n", - "dataset list from the spreadsheet into the code below.\n", - "\n", - "The download code will automatically skip any datasets you have previously downloaded." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 617 - }, - "id": "wcsQuLjY7c0o", - "outputId": "43f99670-13d6-4ecc-f58f-263960681bed" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: tfds-nightly in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (4.9.3.dev202310060044)\n", - "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.4.0)\n", - "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.5.0)\n", - "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (8.1.7)\n", - "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.1.8)\n", - "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (1.5.2)\n", - "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.25.0)\n", - "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3)\n", - "Requirement already satisfied: protobuf>=3.20 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (3.20.3)\n", - "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (5.9.0)\n", - "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.29.0)\n", - "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.0)\n", - "Requirement already satisfied: termcolor in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3.0)\n", - "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.10.2)\n", - "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (4.65.0)\n", - "Requirement already satisfied: wrapt in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.1)\n", - "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (2023.9.2)\n", - "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (6.1.1)\n", - "Requirement already satisfied: typing_extensions in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (4.6.3)\n", - "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (3.17.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2.0.4)\n", - "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (3.4)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (1.26.16)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2023.5.7)\n", - "Requirement already satisfied: six in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from promise->tfds-nightly) (1.16.0)\n", - "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tfds-nightly) (1.61.0)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install tfds-nightly # to get most up-to-date registered datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": { - "id": "XtNplr0AP-ZH" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading 2 datasets to ~/tensorflow_datasets.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:07<00:00, 3.67s/it]\n" - ] - } - ], - "source": [ - "import tensorflow_datasets as tfds\n", - "import tqdm\n", - "\n", - "# optionally replace the DATASET_NAMES below with the list of filtered datasets from the google sheet\n", - "DATASET_NAMES = [\n", - " \"fractal20220817_data\",\n", - " \"kuka\",\n", - " \"bridge\",\n", - " \"taco_play\",\n", - " \"jaco_play\",\n", - " \"berkeley_cable_routing\",\n", - " \"roboturk\",\n", - " \"nyu_door_opening_surprising_effectiveness\",\n", - " \"viola\",\n", - " \"berkeley_autolab_ur5\",\n", - " \"toto\",\n", - " \"language_table\",\n", - " \"columbia_cairlab_pusht_real\",\n", - " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", - " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", - " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", - " \"austin_buds_dataset_converted_externally_to_rlds\",\n", - " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", - " \"maniskill_dataset_converted_externally_to_rlds\",\n", - " \"furniture_bench_dataset_converted_externally_to_rlds\",\n", - " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", - " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", - " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", - " \"bc_z\",\n", - " \"usc_cloth_sim_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", - " \"utokyo_saytap_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", - " \"robo_net\",\n", - " \"berkeley_mvp_converted_externally_to_rlds\",\n", - " \"berkeley_rpt_converted_externally_to_rlds\",\n", - " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", - " \"stanford_mask_vit_converted_externally_to_rlds\",\n", - " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", - " \"dlr_sara_pour_converted_externally_to_rlds\",\n", - " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", - " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", - " \"asu_table_top_converted_externally_to_rlds\",\n", - " \"stanford_robocook_converted_externally_to_rlds\",\n", - " \"eth_agent_affordances\",\n", - " \"imperialcollege_sawyer_wrist_cam\",\n", - " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", - " \"uiuc_d3field\",\n", - " \"utaustin_mutex\",\n", - " \"berkeley_fanuc_manipulation\",\n", - " \"cmu_food_manipulation\",\n", - " \"cmu_play_fusion\",\n", - " \"cmu_stretch\",\n", - " \"berkeley_gnm_recon\",\n", - " \"berkeley_gnm_cory_hall\",\n", - " \"berkeley_gnm_sac_son\",\n", - "]\n", - "DATASET_NAMES = [\"fractal20220817_data\", \"bc_z\"]\n", - "DOWNLOAD_DIR = \"~/tensorflow_datasets\"\n", - "\n", - "print(f\"Downloading {len(DATASET_NAMES)} datasets to {DOWNLOAD_DIR}.\")\n", - "for dataset_name in tqdm.tqdm(DATASET_NAMES):\n", - " b = tfds.builder_from_directory(builder_dir=dataset2path(dataset_name))\n", - " b.download_and_prepare(download_dir=DOWNLOAD_DIR)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IyccDsRqwtMz" - }, - "source": [ - "# Data Loader Example\n", - "\n", - "Below, we demonstrate a simple example of how to load the dataset into training batches, where each sample in the batch only contains one step." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "id": "X17VECdRwzka" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "import tensorflow_datasets as tfds\n", - "\n", - "# load raw dataset --> replace this with tfds.load() on your\n", - "# local machine!\n", - "dataset = \"fractal20220817_data\"\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "ds = b.as_dataset(split=\"train[:10]\")\n", - "\n", - "\n", - "def episode2steps(episode):\n", - " return episode[\"steps\"]\n", - "\n", - "\n", - "def step_map_fn(step):\n", - " return {\n", - " \"observation\": {\n", - " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", - " },\n", - " \"action\": tf.concat(\n", - " [\n", - " step[\"action\"][\"world_vector\"],\n", - " step[\"action\"][\"rotation_delta\"],\n", - " step[\"action\"][\"gripper_closedness_action\"],\n", - " ],\n", - " axis=-1,\n", - " ),\n", - " }\n", - "\n", - "\n", - "# convert RLDS episode dataset to individual steps & reformat\n", - "ds = ds.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", - "ds = ds.map(step_map_fn, num_parallel_calls=tf.data.AUTOTUNE)\n", - "\n", - "# shuffle, repeat, pre-fetch, batch\n", - "ds = ds.cache() # optionally keep full dataset in memory\n", - "ds = ds.shuffle(100) # set shuffle buffer size\n", - "ds = ds.repeat() # ensure that data never runs out" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "t0uJH3X6w1LZ", - "outputId": "a42005e8-1072-4203-e6ba-b56784971175" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "0it [00:00, ?it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "10000it [00:05, 1955.09it/s]\n" - ] - } - ], - "source": [ - "import tqdm\n", - "\n", - "for i, batch in tqdm.tqdm(enumerate(ds.prefetch(3).batch(4).as_numpy_iterator())):\n", - " # here you would add your Jax / PyTorch training code\n", - " if i == 10000:\n", - " break" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ekmsGRAnw3Bp" - }, - "source": [ - "# Interleave Multiple Datasets\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "id": "CslwEuBZwmLP" - }, - "outputs": [], - "source": [ - "# Load second dataset --> replace this with tfds.load() on your\n", - "# local machine!\n", - "dataset = \"bc_z\"\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "ds2 = b.as_dataset(split=\"train[:10]\")\n", - "\n", - "\n", - "def step_map_fn_mutex(step):\n", - " # reformat to align specs of both datasets\n", - " return {\n", - " \"observation\": {\n", - " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", - " },\n", - " \"action\": tf.random.uniform(shape=(7,), dtype=tf.float32, name=None),\n", - " }\n", - "\n", - "\n", - "ds2 = ds2.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", - "ds2 = ds2.map(step_map_fn_mutex, num_parallel_calls=tf.data.AUTOTUNE)\n", - "\n", - "# shuffle, repeat, pre-fetch, batch\n", - "ds2 = ds2.cache() # optionally keep full dataset in memory\n", - "ds2 = ds2.shuffle(100) # set shuffle buffer size\n", - "ds2 = ds2.repeat() # ensure that data never runs out" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "id": "G2hcCJd8w6-D" - }, - "outputs": [], - "source": [ - "# interleave datasets w/ equal sampling weight\n", - "ds_combined = tf.data.Dataset.sample_from_datasets([ds, ds2], [0.5, 0.5])" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "hEnVFP9nw8iI", - "outputId": "68567be3-9c3b-46c2-d569-f999c900f03c" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "10000it [00:06, 1546.22it/s]\n" - ] - } - ], - "source": [ - "import tqdm\n", - "\n", - "for i, batch in tqdm.tqdm(\n", - " enumerate(ds_combined.prefetch(3).batch(4).as_numpy_iterator())\n", - "):\n", - " # here you would add your Jax / PyTorch training code\n", - " if i == 10000:\n", - " break" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aew258oUbamg" - }, - "source": [ - "# Example Dataloader to produce trajectories\n", - "\n", - "When training transformers, we usually use trajectories of fix-length as input into the transformers. This is to enable the transformer to condition on a fixed window of history when predicting actions.\n", - "\n", - "Below we demonstrate how one can load the TFDS datasets, transform the episodes\n", - "into fixed-length \"trajectories\" and mix multiple datasets by aligning their specs." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "id": "YU0qKdrp7oBT" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: rlds[tensorflow] in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (0.1.8)\n", - "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.4.0)\n", - "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.25.0)\n", - "Requirement already satisfied: tensorflow in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (2.14.0)\n", - "Requirement already satisfied: tensorflow-datasets in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (4.9.3)\n", - "Requirement already satisfied: dm-reverb in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (0.13.0)\n", - "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (0.1.8)\n", - "Requirement already satisfied: portpicker in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (1.6.0)\n", - "Requirement already satisfied: astunparse>=1.6.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.6.3)\n", - "Requirement already satisfied: flatbuffers>=23.5.26 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.5.26)\n", - "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.5.4)\n", - "Requirement already satisfied: google-pasta>=0.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", - "Requirement already satisfied: h5py>=2.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.10.0)\n", - "Requirement already satisfied: libclang>=13.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (16.0.6)\n", - "Requirement already satisfied: ml-dtypes==0.2.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", - "Requirement already satisfied: opt-einsum>=2.3.2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.3.0)\n", - "Requirement already satisfied: packaging in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.0)\n", - "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.20.3)\n", - "Requirement already satisfied: setuptools in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (67.8.0)\n", - "Requirement already satisfied: six>=1.12.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.16.0)\n", - "Requirement already satisfied: termcolor>=1.1.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.3.0)\n", - "Requirement already satisfied: typing-extensions>=3.6.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (4.6.3)\n", - "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.14.1)\n", - "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.34.0)\n", - "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.59.2)\n", - "Requirement already satisfied: tensorboard<2.15,>=2.14 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.1)\n", - "Requirement already satisfied: tensorflow-estimator<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", - "Requirement already satisfied: keras<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", - "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.5.0)\n", - "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (8.1.7)\n", - "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (1.5.2)\n", - "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.3)\n", - "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (5.9.0)\n", - "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.29.0)\n", - "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (1.14.0)\n", - "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.10.2)\n", - "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (4.65.0)\n", - "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow->rlds[tensorflow]) (0.38.4)\n", - "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (2023.9.2)\n", - "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (6.1.1)\n", - "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (3.17.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2.0.4)\n", - "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (3.4)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (1.26.16)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2023.5.7)\n", - "Requirement already satisfied: google-auth<3,>=1.6.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.23.4)\n", - "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.0.0)\n", - "Requirement already satisfied: markdown>=2.6.8 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.5.1)\n", - "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.7.2)\n", - "Requirement already satisfied: werkzeug>=1.0.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.0.1)\n", - "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tensorflow-datasets->rlds[tensorflow]) (1.61.0)\n", - "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (5.3.2)\n", - "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.3.0)\n", - "Requirement already satisfied: rsa<5,>=3.1.4 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (4.9)\n", - "Requirement already satisfied: requests-oauthlib>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.3.1)\n", - "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.1.1)\n", - "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.5.0)\n", - "Requirement already satisfied: oauthlib>=3.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.2.2)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install rlds[tensorflow]" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "id": "N3b5BEt1JvQJ" - }, - "outputs": [], - "source": [ - "from typing import Any, Dict, Union, NamedTuple\n", - "\n", - "import numpy as np\n", - "import tensorflow_datasets as tfds\n", - "import rlds\n", - "import reverb\n", - "from rlds import transformations\n", - "import tensorflow_datasets as tfds\n", - "import tree\n", - "\n", - "import abc\n", - "import dataclasses\n", - "from typing import Dict, Optional\n", - "\n", - "from rlds import rlds_types\n", - "import tensorflow as tf\n", - "from PIL import Image\n", - "from IPython import display" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "cellView": "form", - "id": "Dgf1OxIhJwib" - }, - "outputs": [], - "source": [ - "# @title Transformation definitions\n", - "\n", - "\n", - "def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec:\n", - " \"\"\"Converts a tfds Feature into a TensorSpec.\"\"\"\n", - "\n", - " def _get_feature_spec(nested_feature: tfds.features.FeatureConnector):\n", - " if isinstance(nested_feature, tf.DType):\n", - " return tf.TensorSpec(shape=(), dtype=nested_feature)\n", - " else:\n", - " return nested_feature.get_tensor_spec()\n", - "\n", - " # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to\n", - " # make sure we deal with the nested structure.\n", - " return tf.nest.map_structure(_get_feature_spec, feature)\n", - "\n", - "\n", - "def _encoded_feature(\n", - " feature: Optional[tfds.features.FeatureConnector],\n", - " image_encoding: Optional[str],\n", - " tensor_encoding: Optional[tfds.features.Encoding],\n", - "):\n", - " \"\"\"Adds encoding to Images and/or Tensors.\"\"\"\n", - "\n", - " def _apply_encoding(\n", - " feature: tfds.features.FeatureConnector,\n", - " image_encoding: Optional[str],\n", - " tensor_encoding: Optional[tfds.features.Encoding],\n", - " ):\n", - " if image_encoding and isinstance(feature, tfds.features.Image):\n", - " return tfds.features.Image(\n", - " shape=feature.shape,\n", - " dtype=feature.dtype,\n", - " use_colormap=feature.use_colormap,\n", - " encoding_format=image_encoding,\n", - " )\n", - " if (\n", - " tensor_encoding\n", - " and isinstance(feature, tfds.features.Tensor)\n", - " and feature.dtype != tf.string\n", - " ):\n", - " return tfds.features.Tensor(\n", - " shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding\n", - " )\n", - " return feature\n", - "\n", - " if not feature:\n", - " return None\n", - " return tf.nest.map_structure(\n", - " lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature\n", - " )\n", - "\n", - "\n", - "@dataclasses.dataclass\n", - "class RLDSSpec(metaclass=abc.ABCMeta):\n", - " \"\"\"Specification of an RLDS Dataset.\n", - "\n", - " It is used to hold a spec that can be converted into a TFDS DatasetInfo or\n", - " a `tf.data.Dataset` spec.\n", - " \"\"\"\n", - "\n", - " observation_info: Optional[tfds.features.FeatureConnector] = None\n", - " action_info: Optional[tfds.features.FeatureConnector] = None\n", - " reward_info: Optional[tfds.features.FeatureConnector] = None\n", - " discount_info: Optional[tfds.features.FeatureConnector] = None\n", - " step_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", - " episode_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", - "\n", - " def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", - " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", - " step = {}\n", - " if self.observation_info:\n", - " step[rlds_types.OBSERVATION] = _features_to_tensor_spec(\n", - " self.observation_info\n", - " )\n", - " if self.action_info:\n", - " step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info)\n", - " if self.discount_info:\n", - " step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info)\n", - " if self.reward_info:\n", - " step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info)\n", - " if self.step_metadata_info:\n", - " for k, v in self.step_metadata_info.items():\n", - " step[k] = _features_to_tensor_spec(v)\n", - "\n", - " step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool)\n", - " step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool)\n", - " step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool)\n", - " return step\n", - "\n", - " def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", - " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", - " episode = {}\n", - " episode[rlds_types.STEPS] = tf.data.DatasetSpec(\n", - " element_spec=self.step_tensor_spec()\n", - " )\n", - " if self.episode_metadata_info:\n", - " for k, v in self.episode_metadata_info.items():\n", - " episode[k] = _features_to_tensor_spec(v)\n", - " return episode\n", - "\n", - " def to_dataset_config(\n", - " self,\n", - " name: str,\n", - " image_encoding: Optional[str] = None,\n", - " tensor_encoding: Optional[tfds.features.Encoding] = None,\n", - " citation: Optional[str] = None,\n", - " homepage: Optional[str] = None,\n", - " description: Optional[str] = None,\n", - " overall_description: Optional[str] = None,\n", - " ) -> tfds.rlds.rlds_base.DatasetConfig:\n", - " \"\"\"Obtains the DatasetConfig for TFDS from the Spec.\"\"\"\n", - " return tfds.rlds.rlds_base.DatasetConfig(\n", - " name=name,\n", - " description=description,\n", - " overall_description=overall_description,\n", - " homepage=homepage,\n", - " citation=citation,\n", - " observation_info=_encoded_feature(\n", - " self.observation_info, image_encoding, tensor_encoding\n", - " ),\n", - " action_info=_encoded_feature(\n", - " self.action_info, image_encoding, tensor_encoding\n", - " ),\n", - " reward_info=_encoded_feature(\n", - " self.reward_info, image_encoding, tensor_encoding\n", - " ),\n", - " discount_info=_encoded_feature(\n", - " self.discount_info, image_encoding, tensor_encoding\n", - " ),\n", - " step_metadata_info=_encoded_feature(\n", - " self.step_metadata_info, image_encoding, tensor_encoding\n", - " ),\n", - " episode_metadata_info=_encoded_feature(\n", - " self.episode_metadata_info, image_encoding, tensor_encoding\n", - " ),\n", - " )\n", - "\n", - " def to_features_dict(self):\n", - " \"\"\"Returns a TFDS FeaturesDict representing the dataset config.\"\"\"\n", - " step_config = {\n", - " rlds_types.IS_FIRST: tf.bool,\n", - " rlds_types.IS_LAST: tf.bool,\n", - " rlds_types.IS_TERMINAL: tf.bool,\n", - " }\n", - "\n", - " if self.observation_info:\n", - " step_config[rlds_types.OBSERVATION] = self.observation_info\n", - " if self.action_info:\n", - " step_config[rlds_types.ACTION] = self.action_info\n", - " if self.discount_info:\n", - " step_config[rlds_types.DISCOUNT] = self.discount_info\n", - " if self.reward_info:\n", - " step_config[rlds_types.REWARD] = self.reward_info\n", - "\n", - " if self.step_metadata_info:\n", - " for k, v in self.step_metadata_info.items():\n", - " step_config[k] = v\n", - "\n", - " if self.episode_metadata_info:\n", - " return tfds.features.FeaturesDict(\n", - " {\n", - " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", - " **self.episode_metadata_info,\n", - " }\n", - " )\n", - " else:\n", - " return tfds.features.FeaturesDict(\n", - " {\n", - " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", - " }\n", - " )\n", - "\n", - "\n", - "RLDS_SPEC = RLDSSpec\n", - "TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]]\n", - "\n", - "\n", - "@dataclasses.dataclass\n", - "class TrajectoryTransform(metaclass=abc.ABCMeta):\n", - " \"\"\"Specification the TrajectoryTransform applied to a dataset of episodes.\n", - "\n", - " A TrajectoryTransform is a set of rules transforming a dataset\n", - " of RLDS episodes to a dataset of trajectories.\n", - " This involves three distinct stages:\n", - " - An optional `episode_to_steps_map_fn(episode)` is called at the episode\n", - " level, and can be used to select or modify steps.\n", - " - Augmentation: an `episode_key` could be propagated to `steps` for\n", - " debugging.\n", - " - Selection: Particular steps can be selected.\n", - " - Stripping: Features can be removed from steps. Prefer using `step_map_fn`.\n", - " - An optional `step_map_fn` is called at the flattened steps dataset for each\n", - " step, and can be used to featurize a step, e.g. add/remove features, or\n", - " augument images\n", - " - A `pattern` leverages DM patterns to set a rule of slicing an episode to a\n", - " dataset of overlapping trajectories.\n", - "\n", - " Importantly, each TrajectoryTransform must define a `expected_tensor_spec`\n", - " which specifies a nested TensorSpec of the resulting dataset. This is what\n", - " this TrajectoryTransform will produce, and can be used as an interface with\n", - " a neural network.\n", - " \"\"\"\n", - "\n", - " episode_dataset_spec: RLDS_SPEC\n", - " episode_to_steps_fn_dataset_spec: RLDS_SPEC\n", - " steps_dataset_spec: Any\n", - " pattern: reverb.structured_writer.Pattern\n", - " episode_to_steps_map_fn: Any\n", - " expected_tensor_spec: TENSOR_SPEC\n", - " step_map_fn: Optional[Any] = None\n", - "\n", - " def get_for_cached_trajectory_transform(self):\n", - " \"\"\"Creates a copy of this traj transform to use with caching.\n", - "\n", - " The returned TrajectoryTransfrom copy will be initialized with the default\n", - " version of the `episode_to_steps_map_fn`, because the effect of that\n", - " function has already been materialized in the cached copy of the dataset.\n", - " Returns:\n", - " trajectory_transform: A copy of the TrajectoryTransform with overridden\n", - " `episode_to_steps_map_fn`.\n", - " \"\"\"\n", - " traj_copy = dataclasses.replace(self)\n", - " traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec\n", - " traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS]\n", - " return traj_copy\n", - "\n", - " def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset):\n", - " \"\"\"Applies this TrajectoryTransform to the dataset of episodes.\"\"\"\n", - "\n", - " # Convert the dataset of episodes to the dataset of steps.\n", - " steps_dataset = episodes_dataset.map(\n", - " self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE\n", - " ).flat_map(lambda x: x)\n", - "\n", - " return self._create_pattern_dataset(steps_dataset)\n", - "\n", - " def transform_steps_rlds_dataset(\n", - " self, steps_dataset: tf.data.Dataset\n", - " ) -> tf.data.Dataset:\n", - " \"\"\"Applies this TrajectoryTransform to the dataset of episode steps.\"\"\"\n", - "\n", - " return self._create_pattern_dataset(steps_dataset)\n", - "\n", - " def create_test_dataset(\n", - " self,\n", - " ) -> tf.data.Dataset:\n", - " \"\"\"Creates a test dataset of trajectories.\n", - "\n", - " It is guaranteed that the structure of this dataset will be the same as\n", - " when flowing real data. Hence this is a useful construct for tests or\n", - " initialization of JAX models.\n", - " Returns:\n", - " dataset: A test dataset made of zeros structurally identical to the\n", - " target dataset of trajectories.\n", - " \"\"\"\n", - " zeros = transformations.zeros_from_spec(self.expected_tensor_spec)\n", - "\n", - " return tf.data.Dataset.from_tensors(zeros)\n", - "\n", - " def _create_pattern_dataset(\n", - " self, steps_dataset: tf.data.Dataset\n", - " ) -> tf.data.Dataset:\n", - " \"\"\"Create PatternDataset from the `steps_dataset`.\"\"\"\n", - " config = create_structured_writer_config(\"temp\", self.pattern)\n", - "\n", - " # Further transform each step if the `step_map_fn` is provided.\n", - " if self.step_map_fn:\n", - " steps_dataset = steps_dataset.map(self.step_map_fn)\n", - " pattern_dataset = reverb.PatternDataset(\n", - " input_dataset=steps_dataset,\n", - " configs=[config],\n", - " respect_episode_boundaries=True,\n", - " is_end_of_episode=lambda x: x[rlds_types.IS_LAST],\n", - " )\n", - " return pattern_dataset\n", - "\n", - "\n", - "class TrajectoryTransformBuilder(object):\n", - " \"\"\"Facilitates creation of the `TrajectoryTransform`.\"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " dataset_spec: RLDS_SPEC,\n", - " episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS],\n", - " step_map_fn=None,\n", - " pattern_fn=None,\n", - " expected_tensor_spec=None,\n", - " ):\n", - " self._rds_dataset_spec = dataset_spec\n", - " self._steps_spec = None\n", - " self._episode_to_steps_map_fn = episode_to_steps_map_fn\n", - " self._step_map_fn = step_map_fn\n", - " self._pattern_fn = pattern_fn\n", - " self._expected_tensor_spec = expected_tensor_spec\n", - "\n", - " def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform:\n", - " \"\"\"Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.\"\"\"\n", - "\n", - " if validate_expected_tensor_spec and self._expected_tensor_spec is None:\n", - " raise ValueError(\"`expected_tensor_spec` must be set.\")\n", - "\n", - " episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec)\n", - "\n", - " steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn)\n", - "\n", - " episode_to_steps_fn_dataset_spec = self._rds_dataset_spec\n", - "\n", - " if self._step_map_fn is not None:\n", - " steps_ds = steps_ds.map(self._step_map_fn)\n", - "\n", - " zeros_spec = transformations.zeros_from_spec(\n", - " steps_ds.element_spec\n", - " ) # pytype: disable=wrong-arg-types\n", - "\n", - " ref_step = reverb.structured_writer.create_reference_step(zeros_spec)\n", - "\n", - " pattern = self._pattern_fn(ref_step)\n", - "\n", - " steps_ds_spec = steps_ds.element_spec\n", - "\n", - " target_tensor_structure = create_reverb_table_signature(\n", - " \"temp_table\", steps_ds_spec, pattern\n", - " )\n", - "\n", - " if (\n", - " validate_expected_tensor_spec\n", - " and self._expected_tensor_spec != target_tensor_structure\n", - " ):\n", - " raise RuntimeError(\n", - " \"The tensor spec of the TrajectoryTransform doesn't \"\n", - " \"match the expected spec.\\n\"\n", - " \"Expected:\\n%s\\nActual:\\n%s\\n\"\n", - " % (\n", - " str(self._expected_tensor_spec).replace(\n", - " \"TensorSpec\", \"tf.TensorSpec\"\n", - " ),\n", - " str(target_tensor_structure).replace(\"TensorSpec\", \"tf.TensorSpec\"),\n", - " )\n", - " )\n", - "\n", - " return TrajectoryTransform(\n", - " episode_dataset_spec=self._rds_dataset_spec,\n", - " episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec,\n", - " steps_dataset_spec=steps_ds_spec,\n", - " pattern=pattern,\n", - " episode_to_steps_map_fn=self._episode_to_steps_map_fn,\n", - " step_map_fn=self._step_map_fn,\n", - " expected_tensor_spec=target_tensor_structure,\n", - " )\n", - "\n", - "\n", - "def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC):\n", - " \"\"\"Creates a zero valued dataset of episodes for the given RLDS Spec.\"\"\"\n", - "\n", - " def add_steps(episode, step_spec):\n", - " episode[rlds_types.STEPS] = transformations.zero_dataset_like(\n", - " tf.data.DatasetSpec(step_spec)\n", - " )\n", - " if \"fake\" in episode:\n", - " del episode[\"fake\"]\n", - " return episode\n", - "\n", - " episode_without_steps_spec = {\n", - " k: v\n", - " for k, v in rlds_spec.episode_tensor_spec().items()\n", - " if k != rlds_types.STEPS\n", - " }\n", - "\n", - " if episode_without_steps_spec:\n", - " episodes_dataset = transformations.zero_dataset_like(\n", - " tf.data.DatasetSpec(episode_without_steps_spec)\n", - " )\n", - " else:\n", - " episodes_dataset = tf.data.Dataset.from_tensors({\"fake\": \"\"})\n", - "\n", - " episodes_dataset_with_steps = episodes_dataset.map(\n", - " lambda episode: add_steps(episode, rlds_spec.step_tensor_spec())\n", - " )\n", - " return episodes_dataset_with_steps\n", - "\n", - "\n", - "def create_reverb_table_signature(\n", - " table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern\n", - ") -> reverb.reverb_types.SpecNest:\n", - " config = create_structured_writer_config(table_name, pattern)\n", - " reverb_table_spec = reverb.structured_writer.infer_signature(\n", - " [config], steps_dataset_spec\n", - " )\n", - " return reverb_table_spec\n", - "\n", - "\n", - "def create_structured_writer_config(\n", - " table_name: str, pattern: reverb.structured_writer.Pattern\n", - ") -> Any:\n", - " config = reverb.structured_writer.create_config(\n", - " pattern=pattern, table=table_name, conditions=[]\n", - " )\n", - " return config\n", - "\n", - "\n", - "def n_step_pattern_builder(n: int) -> Any:\n", - " \"\"\"Creates trajectory of length `n` from all fields of a `ref_step`.\"\"\"\n", - "\n", - " def transform_fn(ref_step):\n", - " traj = {}\n", - " for key in ref_step:\n", - " if isinstance(ref_step[key], dict):\n", - " transformed_entry = tree.map_structure(\n", - " lambda ref_node: ref_node[-n:], ref_step[key]\n", - " )\n", - " traj[key] = transformed_entry\n", - " else:\n", - " traj[key] = ref_step[key][-n:]\n", - "\n", - " return traj\n", - "\n", - " return transform_fn" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BK4RRYkbLN5B" - }, - "source": [ - "## Demonstration of transformation from an episode to a trajectory\n", - "\n", - "A real ML pipeline would rarely learn from a whole episode. Instead the input to a model is a _trajectory_. A `Trajectory` is a particular way to slice a sequence of episode steps. `SARSA` trajectory is one well known example, but a trajectory of an arbitrary length `n` is also an option. Often, a set of _overlapping_ trajectories is produced from an episode. For example, given the following episode steps:\n", - "\n", - "`episode=[s_0, s_1, s_2, s_3, s_4, s_T]`\n", - "\n", - "and a target Trajectory of length `3`, the following trajectories are produced:\n", - "\n", - "`t_1=[s_0, s_1, s_2]`\n", - "\n", - "`t_2=[s_1, s_2, s_3]`\n", - "\n", - "`t_3=[s_2, s_3, s_4]`\n", - "\n", - "`t_4=[s_3, s_4, s_T]`\n", - "\n", - "\n", - "To perform such a slicing, the dataset of episode is first \"flattened\" to the dataset of steps. The `is_last` attribute of an RLDS step allows proper slicing, not crossing the episode boundary. The `TrajectoryTransformBuilder` demonstrates this:" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "id": "_NsYnqnpNgNl" - }, - "outputs": [], - "source": [ - "import tensorflow_datasets as tfds\n", - "\n", - "dataset = \"fractal20220817_data\"\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "ds = b.as_dataset(split=\"train[:10]\")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "id": "2qvMcpGDx6hJ" - }, - "outputs": [], - "source": [ - "# The RLDSSpec for the RT1 dataset.\n", - "rt1_spec = RLDSSpec(\n", - " observation_info=b.info.features[\"steps\"][\"observation\"],\n", - " action_info=b.info.features[\"steps\"][\"action\"],\n", - ")\n", - "\n", - "# The following will create a trajectories of length 3.\n", - "trajectory_length = 3\n", - "trajectory_transform = TrajectoryTransformBuilder(\n", - " rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length)\n", - ").build(validate_expected_tensor_spec=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "id": "Fk4ZfC_bMBw3" - }, - "outputs": [], - "source": [ - "trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds)\n", - "\n", - "trajectory_iter = iter(trajectory_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "id": "fSxk3zF_x0FS" - }, - "outputs": [], - "source": [ - "trajectory = next(trajectory_iter)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "t2V0xrIVMWNc", - "outputId": "5c71d7ef-2fc7-424e-a8ae-0e1c60252f42" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'action': {'base_displacement_vector': ,\n", - " 'gripper_closedness_action': ,\n", - " 'world_vector': ,\n", - " 'rotation_delta': ,\n", - " 'base_displacement_vertical_rotation': ,\n", - " 'terminate_episode': },\n", - " 'is_first': ,\n", - " 'is_last': ,\n", - " 'observation': {'robot_orientation_positions_box': ,\n", - " 'workspace_bounds': ,\n", - " 'natural_language_instruction': ,\n", - " 'image': ,\n", - " 'src_rotation': ,\n", - " 'orientation_box': ,\n", - " 'height_to_bottom': ,\n", - " 'vector_to_go': ,\n", - " 'rotation_delta_to_go': ,\n", - " 'gripper_closedness_commanded': ,\n", - " 'orientation_start': ,\n", - " 'gripper_closed': ,\n", - " 'base_pose_tool_reached': ,\n", - " 'natural_language_embedding': },\n", - " 'is_terminal': }" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "trajectory" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ytrvi945NTZz", - "outputId": "50dd5318-7521-4d85-a1cf-42aa046ce4c3" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "TensorShape([3, 256, 320, 3])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Note that the leading dimension (3) corresponds to the trajectory_length\n", - "trajectory[\"observation\"][\"image\"].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 529 - }, - "id": "xhDX3BcWNmrl", - "outputId": "0d4c3c74-7d71-45e3-baea-c5f119eea9a4" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "episode = next(iter(ds))\n", - "\n", - "# Iterate over steps of the episode. Collect images.\n", - "images = [\n", - " trajectory[\"observation\"][\"image\"][id]\n", - " for id in range(trajectory[\"observation\"][\"image\"].shape[0])\n", - "]\n", - "images = [Image.fromarray(image.numpy()) for image in images]\n", - "\n", - "display.Image(as_gif(images))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Oy89HzymQyAq" - }, - "source": [ - "## Combination of multiple datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "id": "qs0-7alaQ3C9" - }, - "outputs": [], - "source": [ - "import tensorflow_datasets as tfds\n", - "\n", - "robo_net_builder = tfds.builder_from_directory(\n", - " builder_dir=\"gs://gresearch/robotics/robo_net/1.0.0/\"\n", - ")\n", - "\n", - "robo_net_builder_episodic_dataset = robo_net_builder.as_dataset(split=\"train[:10]\")\n", - "episodes = list(iter(robo_net_builder_episodic_dataset))" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "id": "2tgJpMqARIFQ" - }, - "outputs": [], - "source": [ - "# The following will create a trajectories of length 3.\n", - "trajectory_length = 3\n", - "\n", - "robo_net_rlds_spec = RLDSSpec(\n", - " observation_info=robo_net_builder.info.features[\"steps\"][\"observation\"],\n", - " action_info=robo_net_builder.info.features[\"steps\"][\"action\"],\n", - ")\n", - "\n", - "\n", - "def robo_net_step_map_fn(step):\n", - " transformed_step = {}\n", - " transformed_step[\"observation\"] = step[\"observation\"][\"image\"]\n", - " transformed_step[\"is_first\"] = step[\"is_first\"]\n", - " transformed_step[\"is_last\"] = step[\"is_last\"]\n", - " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", - " return transformed_step\n", - "\n", - "\n", - "robo_net_trajectory_transform = TrajectoryTransformBuilder(\n", - " robo_net_rlds_spec,\n", - " step_map_fn=robo_net_step_map_fn,\n", - " pattern_fn=n_step_pattern_builder(trajectory_length),\n", - ").build(validate_expected_tensor_spec=False)\n", - "\n", - "\n", - "def mt_opt_step_map_fn(step):\n", - " transformed_step = {}\n", - " transformed_step[\"observation\"] = tf.cast(\n", - " tf.image.resize(step[\"observation\"][\"image\"], [240, 320]), tf.uint8\n", - " ) # Resize to be compatible with robo_net trajectory\n", - " transformed_step[\"is_first\"] = step[\"is_first\"]\n", - " transformed_step[\"is_last\"] = step[\"is_last\"]\n", - " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", - " return transformed_step\n", - "\n", - "\n", - "mt_opt_trajectory_transform = TrajectoryTransformBuilder(\n", - " rt1_spec,\n", - " step_map_fn=mt_opt_step_map_fn,\n", - " pattern_fn=n_step_pattern_builder(trajectory_length),\n", - ").build(validate_expected_tensor_spec=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "id": "anGArTQbTiHj" - }, - "outputs": [], - "source": [ - "# Validate that the specs are equal\n", - "assert (\n", - " robo_net_trajectory_transform.expected_tensor_spec\n", - " == mt_opt_trajectory_transform.expected_tensor_spec\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "id": "L9gRx6BfTGH-" - }, - "outputs": [], - "source": [ - "# Create trajectory datasets for the two normalized representations:\n", - "robo_net_trajectory_dataset = (\n", - " robo_net_trajectory_transform.transform_episodic_rlds_dataset(\n", - " robo_net_builder_episodic_dataset\n", - " )\n", - ")\n", - "mt_opt_trajectory_dataset = mt_opt_trajectory_transform.transform_episodic_rlds_dataset(\n", - " ds\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": { - "id": "-SVkHpIxRVXz" - }, - "outputs": [], - "source": [ - "combined_dataset = tf.data.Dataset.sample_from_datasets(\n", - " [robo_net_trajectory_dataset, mt_opt_trajectory_dataset]\n", - ")\n", - "combined_dataset = combined_dataset.batch(2)\n", - "combined_dataset_it = iter(combined_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "id": "-CMdwIcsR30k" - }, - "outputs": [], - "source": [ - "example = next(combined_dataset_it)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 257 - }, - "id": "w2YJOvRKUb2E", - "outputId": "31daf4b7-9350-4d05-9c57-d9784bc34d44" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# First element of the batch returns a robot_net trajectory\n", - "Image.fromarray(example[\"observation\"].numpy()[0][0])" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 257 - }, - "id": "FP0iz-f_UoTY", - "outputId": "244fb34b-fa72-4c02-e432-8a0382f45b17" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Second element of the batch returns a mt_opt trajectory\n", - "Image.fromarray(example[\"observation\"].numpy()[1][0])" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "N2Efw2aHVfSX" - }, - "source": [ - "# Available datasets and their sizes:" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "kQkeUKyrVhGK", - "outputId": "a61cb54f-fd1e-41d0-858b-19d30659c8b1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset gs://gresearch/robotics/fractal20220817_data/0.1.0 has size 111.07 GiB\n", - "Dataset gs://gresearch/robotics/kuka/0.1.0 has size 778.02 GiB\n", - "Dataset gs://gresearch/robotics/bridge/0.1.0 has size 387.49 GiB\n", - "Dataset gs://gresearch/robotics/taco_play/0.1.0 has size 47.77 GiB\n", - "Dataset gs://gresearch/robotics/jaco_play/0.1.0 has size 9.24 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_cable_routing/0.1.0 has size 4.67 GiB\n", - "Dataset gs://gresearch/robotics/roboturk/0.1.0 has size 45.39 GiB\n", - "Dataset gs://gresearch/robotics/nyu_door_opening_surprising_effectiveness/0.1.0 has size 7.12 GiB\n", - "Dataset gs://gresearch/robotics/viola/0.1.0 has size 10.40 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_autolab_ur5/0.1.0 has size 76.39 GiB\n", - "Dataset gs://gresearch/robotics/toto/0.1.0 has size 127.66 GiB\n", - "Dataset gs://gresearch/robotics/language_table/0.0.1 has size 399.23 GiB\n", - "Dataset gs://gresearch/robotics/columbia_cairlab_pusht_real/0.1.0 has size 2.80 GiB\n", - "Dataset gs://gresearch/robotics/stanford_kuka_multimodal_dataset_converted_externally_to_rlds/0.1.0 has size 31.98 GiB\n", - "Dataset gs://gresearch/robotics/nyu_rot_dataset_converted_externally_to_rlds/0.1.0 has size 5.33 MiB\n", - "Dataset gs://gresearch/robotics/stanford_hydra_dataset_converted_externally_to_rlds/0.1.0 has size 72.48 GiB\n", - "Dataset gs://gresearch/robotics/austin_buds_dataset_converted_externally_to_rlds/0.1.0 has size 1.49 GiB\n", - "Dataset gs://gresearch/robotics/nyu_franka_play_dataset_converted_externally_to_rlds/0.1.0 has size 5.18 GiB\n", - "Dataset gs://gresearch/robotics/maniskill_dataset_converted_externally_to_rlds/0.1.0 has size 151.05 GiB\n", - "Dataset gs://gresearch/robotics/cmu_franka_exploration_dataset_converted_externally_to_rlds/0.1.0 has size 602.24 MiB\n", - "Dataset gs://gresearch/robotics/ucsd_kitchen_dataset_converted_externally_to_rlds/0.1.0 has size 1.33 GiB\n", - "Dataset gs://gresearch/robotics/ucsd_pick_and_place_dataset_converted_externally_to_rlds/0.1.0 has size 3.53 GiB\n", - "Dataset gs://gresearch/robotics/austin_sailor_dataset_converted_externally_to_rlds/0.1.0 has size 18.85 GiB\n", - "Dataset gs://gresearch/robotics/austin_sirius_dataset_converted_externally_to_rlds/0.1.0 has size 6.55 GiB\n", - "Dataset gs://gresearch/robotics/bc_z/0.1.0 has size 80.54 GiB\n", - "Dataset gs://gresearch/robotics/usc_cloth_sim_converted_externally_to_rlds/0.1.0 has size 254.52 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_pr2_opening_fridge_converted_externally_to_rlds/0.1.0 has size 360.57 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds/0.1.0 has size 829.37 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_saytap_converted_externally_to_rlds/0.1.0 has size 55.34 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_xarm_pick_and_place_converted_externally_to_rlds/0.1.0 has size 1.29 GiB\n", - "Dataset gs://gresearch/robotics/utokyo_xarm_bimanual_converted_externally_to_rlds/0.1.0 has size 138.44 MiB\n", - "Dataset gs://gresearch/robotics/robo_net/1.0.0 has size 799.91 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_mvp_converted_externally_to_rlds/0.1.0 has size 12.34 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_rpt_converted_externally_to_rlds/0.1.0 has size 40.64 GiB\n", - "Dataset gs://gresearch/robotics/kaist_nonprehensile_converted_externally_to_rlds/0.1.0 has size 11.71 GiB\n", - "Dataset gs://gresearch/robotics/stanford_mask_vit_converted_externally_to_rlds/0.1.0 has size 76.17 GiB\n", - "Dataset gs://gresearch/robotics/tokyo_u_lsmo_converted_externally_to_rlds/0.1.0 has size 335.71 MiB\n", - "Dataset gs://gresearch/robotics/dlr_sara_pour_converted_externally_to_rlds/0.1.0 has size 2.92 GiB\n", - "Dataset gs://gresearch/robotics/dlr_sara_grid_clamp_converted_externally_to_rlds/0.1.0 has size 1.65 GiB\n", - "Dataset gs://gresearch/robotics/dlr_edan_shared_control_converted_externally_to_rlds/0.1.0 has size 3.09 GiB\n", - "Dataset gs://gresearch/robotics/asu_table_top_converted_externally_to_rlds/0.1.0 has size 737.60 MiB\n", - "Dataset gs://gresearch/robotics/stanford_robocook_converted_externally_to_rlds/0.1.0 has size 124.62 GiB\n", - "Dataset gs://gresearch/robotics/eth_agent_affordances/0.1.0 has size 17.27 GiB\n", - "Dataset gs://gresearch/robotics/imperialcollege_sawyer_wrist_cam/0.1.0 has size 81.87 MiB\n", - "Dataset gs://gresearch/robotics/iamlab_cmu_pickup_insert_converted_externally_to_rlds/0.1.0 has size 50.29 GiB\n", - "Dataset gs://gresearch/robotics/uiuc_d3field/0.1.0 has size 15.82 GiB\n", - "Dataset gs://gresearch/robotics/utaustin_mutex/0.1.0 has size 20.79 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_fanuc_manipulation/0.1.0 has size 8.85 GiB\n", - "Dataset gs://gresearch/robotics/cmu_play_fusion/0.1.0 has size 6.68 GiB\n", - "Dataset gs://gresearch/robotics/cmu_stretch/0.1.0 has size 728.06 MiB\n", - "Dataset gs://gresearch/robotics/berkeley_gnm_recon/0.1.0 has size 18.73 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_gnm_cory_hall/0.1.0 has size 1.39 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_gnm_sac_son/0.1.0 has size 7.00 GiB\n" - ] - } - ], - "source": [ - "# Iterate over and make sure that a dataset can be created\n", - "for name in DATASETS:\n", - " uri = dataset2path(name)\n", - " b = tfds.builder_from_directory(builder_dir=uri)\n", - " split = list(b.info.splits.keys())[0]\n", - " b.as_dataset(split=split)\n", - " print(\"Dataset %s has size %s\" % (uri, b.info.dataset_size))" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "ZnRYMsVpaZKF", - "outputId": "d546a431-5dad-4aee-d6f6-b9aa4207e319" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting git+https://github.com/tensorflow/datasets.git\n", - " Cloning https://github.com/tensorflow/datasets.git to /tmp/pip-req-build-d48q8hrq\n", - " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/datasets.git /tmp/pip-req-build-d48q8hrq\n", - " Resolved https://github.com/tensorflow/datasets.git to commit 0f2cce155781202f05fbe8007a763e12ef9fc6ee\n", - " Installing build dependencies ... \u001b[?25ldone\n", - "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", - "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", - "\u001b[?25hCollecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading absl_py-2.0.0-py3-none-any.whl.metadata (2.3 kB)\n", - "Collecting click (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading click-8.1.7-py3-none-any.whl.metadata (3.0 kB)\n", - "Collecting dm-tree (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading dm_tree-0.1.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (152 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.8/152.8 kB\u001b[0m \u001b[31m654.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m1m687.2 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25hCollecting etils>=0.9.0 (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading etils-1.5.2-py3-none-any.whl.metadata (6.3 kB)\n", - "Collecting numpy (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.2/61.2 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting promise (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached promise-2.3-py3-none-any.whl\n", - "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading protobuf-4.25.0-cp37-abi3-manylinux2014_x86_64.whl.metadata (541 bytes)\n", - "Collecting psutil (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (21 kB)\n", - "Collecting requests>=2.19.0 (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading requests-2.31.0-py3-none-any.whl.metadata (4.6 kB)\n", - "Collecting tensorflow-metadata (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached tensorflow_metadata-1.14.0-py3-none-any.whl.metadata (2.1 kB)\n", - "Collecting termcolor (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", - "Collecting toml (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", - "Collecting tqdm (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading tqdm-4.66.1-py3-none-any.whl.metadata (57 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.6/57.6 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting wrapt (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n", - "Collecting array-record>=0.5.0 (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (503 bytes)\n", - "Collecting fsspec (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading fsspec-2023.10.0-py3-none-any.whl.metadata (6.8 kB)\n", - "Collecting importlib_resources (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading importlib_resources-6.1.1-py3-none-any.whl.metadata (4.1 kB)\n", - "Collecting typing_extensions (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading typing_extensions-4.8.0-py3-none-any.whl.metadata (3.0 kB)\n", - "Collecting zipp (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading zipp-3.17.0-py3-none-any.whl.metadata (3.7 kB)\n", - "Collecting charset-normalizer<4,>=2 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (33 kB)\n", - "Collecting idna<4,>=2.5 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading idna-3.4-py3-none-any.whl (61 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.5/61.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting urllib3<3,>=1.21.1 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading urllib3-2.0.7-py3-none-any.whl.metadata (6.6 kB)\n", - "Collecting certifi>=2017.4.17 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading certifi-2023.7.22-py3-none-any.whl.metadata (2.2 kB)\n", - "Collecting six (from promise->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n", - "Collecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached absl_py-1.4.0-py3-none-any.whl (126 kB)\n", - "Collecting googleapis-common-protos<2,>=1.52.0 (from tensorflow-metadata->tensorflow-datasets==4.9.3+nightly)\n", - " Using cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl.metadata (1.5 kB)\n", - "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached protobuf-3.20.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n", - "Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.0 MB)\n", - "Downloading etils-1.5.2-py3-none-any.whl (140 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading requests-2.31.0-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.6/62.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading click-8.1.7-py3-none-any.whl (97 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.9/97.9 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m[36m0:00:01\u001b[0m\n", - "\u001b[?25hDownloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (283 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m283.6/283.6 kB\u001b[0m \u001b[31m16.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hUsing cached tensorflow_metadata-1.14.0-py3-none-any.whl (28 kB)\n", - "Downloading tqdm-4.66.1-py3-none-any.whl (78 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.3/78.3 kB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (80 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m80.3/80.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading certifi-2023.7.22-py3-none-any.whl (158 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.3/158.3 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (142 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m142.1/142.1 kB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hUsing cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl (230 kB)\n", - "Downloading urllib3-2.0.7-py3-none-any.whl (124 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 kB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading fsspec-2023.10.0-py3-none-any.whl (166 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m166.4/166.4 kB\u001b[0m \u001b[31m13.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading importlib_resources-6.1.1-py3-none-any.whl (33 kB)\n", - "Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", - "Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", - "Building wheels for collected packages: tensorflow-datasets\n", - " Building wheel for tensorflow-datasets (pyproject.toml) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for tensorflow-datasets: filename=tensorflow_datasets-4.9.3+nightly-py3-none-any.whl size=5042188 sha256=b922a59c63a43266324047d6de8cc70c4e902e4be1002a629f6fc9144b42026e\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-yum8n3h3/wheels/69/95/f3/0a7e5341cee7ec33827b33149e1556b4e39317c704cb2751bd\n", - "Successfully built tensorflow-datasets\n", - "Installing collected packages: dm-tree, zipp, wrapt, urllib3, typing_extensions, tqdm, toml, termcolor, six, psutil, protobuf, numpy, importlib_resources, idna, fsspec, etils, click, charset-normalizer, certifi, absl-py, requests, promise, googleapis-common-protos, tensorflow-metadata, array-record, tensorflow-datasets\n", - " Attempting uninstall: dm-tree\n", - " Found existing installation: dm-tree 0.1.8\n", - " Uninstalling dm-tree-0.1.8:\n", - " Successfully uninstalled dm-tree-0.1.8\n", - " Attempting uninstall: zipp\n", - " Found existing installation: zipp 3.17.0\n", - " Uninstalling zipp-3.17.0:\n", - " Successfully uninstalled zipp-3.17.0\n", - " Attempting uninstall: wrapt\n", - " Found existing installation: wrapt 1.14.1\n", - " Uninstalling wrapt-1.14.1:\n", - " Successfully uninstalled wrapt-1.14.1\n", - " Attempting uninstall: urllib3\n", - " Found existing installation: urllib3 1.26.16\n", - " Uninstalling urllib3-1.26.16:\n", - " Successfully uninstalled urllib3-1.26.16\n", - " Attempting uninstall: typing_extensions\n", - " Found existing installation: typing_extensions 4.6.3\n", - " Uninstalling typing_extensions-4.6.3:\n", - " Successfully uninstalled typing_extensions-4.6.3\n", - " Attempting uninstall: tqdm\n", - " Found existing installation: tqdm 4.65.0\n", - " Uninstalling tqdm-4.65.0:\n", - " Successfully uninstalled tqdm-4.65.0\n", - " Attempting uninstall: toml\n", - " Found existing installation: toml 0.10.2\n", - " Uninstalling toml-0.10.2:\n", - " Successfully uninstalled toml-0.10.2\n", - " Attempting uninstall: termcolor\n", - " Found existing installation: termcolor 2.3.0\n", - " Uninstalling termcolor-2.3.0:\n", - " Successfully uninstalled termcolor-2.3.0\n", - " Attempting uninstall: six\n", - " Found existing installation: six 1.16.0\n", - " Uninstalling six-1.16.0:\n", - " Successfully uninstalled six-1.16.0\n", - " Attempting uninstall: psutil\n", - " Found existing installation: psutil 5.9.0\n", - " Uninstalling psutil-5.9.0:\n", - " Successfully uninstalled psutil-5.9.0\n", - " Attempting uninstall: protobuf\n", - " Found existing installation: protobuf 3.20.3\n", - " Uninstalling protobuf-3.20.3:\n", - " Successfully uninstalled protobuf-3.20.3\n", - " Attempting uninstall: numpy\n", - " Found existing installation: numpy 1.25.0\n", - " Uninstalling numpy-1.25.0:\n", - " Successfully uninstalled numpy-1.25.0\n", - " Attempting uninstall: importlib_resources\n", - " Found existing installation: importlib-resources 6.1.1\n", - " Uninstalling importlib-resources-6.1.1:\n", - " Successfully uninstalled importlib-resources-6.1.1\n", - " Attempting uninstall: idna\n", - " Found existing installation: idna 3.4\n", - " Uninstalling idna-3.4:\n", - " Successfully uninstalled idna-3.4\n", - " Attempting uninstall: fsspec\n", - " Found existing installation: fsspec 2023.9.2\n", - " Uninstalling fsspec-2023.9.2:\n", - " Successfully uninstalled fsspec-2023.9.2\n", - " Attempting uninstall: etils\n", - " Found existing installation: etils 1.5.2\n", - " Uninstalling etils-1.5.2:\n", - " Successfully uninstalled etils-1.5.2\n", - " Attempting uninstall: click\n", - " Found existing installation: click 8.1.7\n", - " Uninstalling click-8.1.7:\n", - " Successfully uninstalled click-8.1.7\n", - " Attempting uninstall: charset-normalizer\n", - " Found existing installation: charset-normalizer 2.0.4\n", - " Uninstalling charset-normalizer-2.0.4:\n", - " Successfully uninstalled charset-normalizer-2.0.4\n", - " Attempting uninstall: certifi\n", - " Found existing installation: certifi 2023.5.7\n", - " Uninstalling certifi-2023.5.7:\n", - " Successfully uninstalled certifi-2023.5.7\n", - " Attempting uninstall: absl-py\n", - " Found existing installation: absl-py 1.4.0\n", - " Uninstalling absl-py-1.4.0:\n", - " Successfully uninstalled absl-py-1.4.0\n", - " Attempting uninstall: requests\n", - " Found existing installation: requests 2.29.0\n", - " Uninstalling requests-2.29.0:\n", - " Successfully uninstalled requests-2.29.0\n", - " Attempting uninstall: promise\n", - " Found existing installation: promise 2.3\n", - " Uninstalling promise-2.3:\n", - " Successfully uninstalled promise-2.3\n", - " Attempting uninstall: googleapis-common-protos\n", - " Found existing installation: googleapis-common-protos 1.61.0\n", - " Uninstalling googleapis-common-protos-1.61.0:\n", - " Successfully uninstalled googleapis-common-protos-1.61.0\n", - " Attempting uninstall: tensorflow-metadata\n", - " Found existing installation: tensorflow-metadata 1.14.0\n", - " Uninstalling tensorflow-metadata-1.14.0:\n", - " Successfully uninstalled tensorflow-metadata-1.14.0\n", - " Attempting uninstall: array-record\n", - " Found existing installation: array-record 0.5.0\n", - " Uninstalling array-record-0.5.0:\n", - " Successfully uninstalled array-record-0.5.0\n", - " Attempting uninstall: tensorflow-datasets\n", - " Found existing installation: tensorflow-datasets 4.9.3\n", - " Uninstalling tensorflow-datasets-4.9.3:\n", - " Successfully uninstalled tensorflow-datasets-4.9.3\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "tensorflow 2.14.0 requires wrapt<1.15,>=1.11.0, but you have wrapt 1.16.0 which is incompatible.\u001b[0m\u001b[31m\n", - "\u001b[0mSuccessfully installed absl-py-1.4.0 array-record-0.5.0 certifi-2023.7.22 charset-normalizer-3.3.2 click-8.1.7 dm-tree-0.1.8 etils-1.5.2 fsspec-2023.10.0 googleapis-common-protos-1.61.0 idna-3.4 importlib_resources-6.1.1 numpy-1.26.1 promise-2.3 protobuf-3.20.3 psutil-5.9.6 requests-2.31.0 six-1.16.0 tensorflow-datasets-4.9.3+nightly tensorflow-metadata-1.14.0 termcolor-2.3.0 toml-0.10.2 tqdm-4.66.1 typing_extensions-4.8.0 urllib3-2.0.7 wrapt-1.16.0 zipp-3.17.0\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "# Might require updating tensorflow datasets:\n", - "%pip install --upgrade --force-reinstall git+https://github.com/tensorflow/datasets.git" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bPhwnlk1a1lq", - "outputId": "90ec1c89-2ef7-4cd6-aa39-b2df72da15de" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fractal20220817_data\n", - "bc_z\n" - ] - } - ], - "source": [ - "for name in DATASET_NAMES:\n", - " print(name)\n", - " b = tfds.builder_from_directory(builder_dir=dataset2path(name))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/models/main_models/rt1/README.md b/models/main_models/rt1/README.md deleted file mode 100644 index 930fa939a..000000000 --- a/models/main_models/rt1/README.md +++ /dev/null @@ -1,66 +0,0 @@ -# NPM-Dataset -A comprehensive robotics dataset that includes navigation, perception, and manipulation data per data point. - -# RT-1 (Robotic Transformer) PyTorch Implementation - - -A forked implementation of RT1 (Robotic Transformer) originally inspired by the Google Research paper. - -This implemenetation of RT-1 was pretrained on the Bridge dataset and further fine-tuned on our LaNMP dataset for evaluation. Please find details of the repository below - -## Setup Instructions - -```bash -git clone https://github.com/h2r/NPM-Dataset.git -git checkout -b rt1 -pip install -e . -``` - -## Overview of files - -This repository has 7 critical files/folders whose use cases are described below - -1) ```main.py```: used to pretrain RT-1 on the bridge dataset. Modifying this file to accomodate different datasets requires changing the ```observation_space``` and ```action_space``` according to the dataset being loaded, as well as changing the dataset keys in ```rt1_pytorch/tokenizers/action_tokenizer.py```. Running this file saves a series of checkpoints and logs losses using weights and biases -2) ```main_ft.py```: used to finetune RT-1 on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset finetuning (AI2Thor). Running this file saves a series of checkpoints and logs losses using weights and biases -3) ```main_ft_eval.py```: used to run RT-1 in inference mode on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset (AI2Thor). The file iterates/loads all saved checkpoints from finetuning and runs RT-1 on inference mode for the validation dataset on each checkpoint. The script logs the test losses using weights and biases -4) ```ai2thor_env.py```: contains a Gym environment style class to load and take steps in AI2Thor enivironment. This file is used to generate real-time trajectories based on the action tokens generated by a finetuned RT-1 model (specific for AI2Thor). The main ```step()``` function takes/executes the generated action by RT-1 and returns a success message along with information about the environment state e.g. object or agent metadata, which can be saved to capture the trajectory taken by the agent for a given task -5) ```rollout_ai2thor.py```: interfaces between the finetuned RT-1 model (from a loaded checkpoint after finetuning on LaNMP) and the ```ai2thor_env.py``` Gym environment, in order to send observations from the AI2Thor environment to RT-1 and execute proposed action tokens by RT-1 on AI2Thor. Note that this file should not be run on a headless machine since it requires/deploys AI2Thor simulator GUI -6) ```rt1_pytorch/rt1_policy.py```: contains the RT-1 model implementation in PyTorch. The ```loss()``` function performs forward pass of RT-1 for training and ```act()``` function performs the forward pass during inference. -7) ```lanmp_dataloader/rt1_dataloader.py```: contains the ```DatasetManager``` class that extracts trajectories from the LaNMP ```sim_data.hdf5``` dataset file. The script automatically separates train and validation subsets according to different splits e.g. k-fold by scene, task wise or for diversity ablation. The ```DatasetManager``` also handles tokenizing/detokenizing the raw trajectory data into 256 discrete buckets, whilst also chunking trajectories across non-overlapping window lengths of 6 steps - -## Details about file arguments - -Most relevant files in this repository accept the same set of arguments that are detailed below -* ```dataset```: only for the ```main.py``` file, specifies the dataset on which the RT-1 model should be pretrained -* ```train-split```: specifies what fraction of the loaded dataset should be used for training v.s. evaluation -* ```eval-split```: specifies what fraction of the laoded dataset should be used for evaluation v.s. training -* ```epochs```: total number of passes over the all batches of the training set -* ```lr```: learning rate for cross-entropy loss of RT1 -* ```train-batch-size```: the number of trajectories from which to sample data for the current training batch -* ```eval-batch-size```: the number of trajectories from which to sample data for the current evaluation batch -* ```trajectory-length```: the window size (context history of ```trajecotry-length``` previous images) used for each trajectory when feeding data to RT-1 model; this is set to 6 based on the RT-1 implementation -* ```sentence-transformer```: the language embedding to apply on the language-specified task -* ```device```: the device to load the model/data onto during training/inference -* ```eval-freq```: the interval of batches at which to run evaluation/inference on the validation dataset (currently set to 0 in ```main_ft.py```) -* ```checkpoint-freq```: the interval of batches at which to save a checkpoint during training -* ```checkpoint-dir```: the directory path at which to save a checkpoint during training -* ```load-checkpoint```: (optional) path of the pretrained checkpoint to load for further fine-tuning -* ```wandb```: boolean determining if logging to weights and biases should happen -* ```eval-scene```: the AI2Thor scene number in the dataset that is held out of the training set for evaluation during k-fold cross validation across scenes -* ```split-type```: determines the split type (i.e. k-fold by scene, task wise or diversity ablation) between train and evaluation used by the ```DatasetManager``` in ```rt1_dataloader.py``` -* ```num-diversity-scenes```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of scenes to perform diversity ablation over i.e. maximum of 4 for LaNMP simulation data -* ```max-diversity-trajectories```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of trajectories that are divided evenly across the number of ```num-diversity-scenes``` scenes -* ```train-subbatch```: the batch size to use during training/finetuning -* ```eval-subbatch```: the batch size to use during evaluation - -## Checkpoint samples - -Please find the follow checkpoints samples that can be loaded to the RT-1 model. These can be found on the supplementary Google Drive associated with this project -* ```sample_checkpoints/pretrained_bridge```: the final checkpoint saved when pretraining the RT-1 model on the Bridge dataset -* ```sample_checkpoints/task_gen```: the final checkpoint saved after finetuning RT-1 model on the task-wise split for the task generalization experiment - -## Additional notes - -When running any of the finetuning or pretraining scripts, please ensure the following modules are loaded -```module load cuda/11.8.0-lpttyok``` -```module load cudnn/8.7.0.84-11.8-lg2dpd5``` diff --git a/models/main_models/rt1/ai2thor_env.py b/models/main_models/rt1/ai2thor_env.py deleted file mode 100644 index 60047ecfc..000000000 --- a/models/main_models/rt1/ai2thor_env.py +++ /dev/null @@ -1,641 +0,0 @@ - -import copy -import numpy as np -from collections import Counter, OrderedDict -import ai2thor -from ai2thor.controller import Controller -from json import load -from os import path -import sys -sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred') -sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred/gen') -import gen.constants as constants -# import gen.utils.image_util as image_util -# from gen.utils import game_util -# from gen.utils.game_util import get_objects_of_type, get_obj_of_type_closest_to_obj -from random import choice, randint -from time import sleep -import pdb - -DEFAULT_RENDER_SETTINGS = {'renderImage': True, - 'renderDepthImage': True, - 'renderClassImage': False, - 'renderObjectImage': False, - } - -class ThorEnv(): - def __init__(self, task, max_episode_length = 1500): - - self.controller = None - self.last_event = None - - self.task = task - self.max_episode_length = max_episode_length - - - def reset(self, scene_name): - ''' - reset scene / start scene - ''' - print('Starting Ai2Thor Env...') - self.controller = Controller( - agentMode="arm", - massThreshold=None, - scene=scene_name, - visibilityDistance=1.5, - gridSize=0.25, - renderDepthImage=False, - renderInstanceSegmentation=False, - snapToGrid=False, - width=300, - height=300, - fieldOfView=60 - ) - self.last_event = self.controller.last_event - return self.last_event - - - def step(self, action, kwargs): - - if action in set(['MoveAgent','RotateAgent']): - - if action == 'MoveAgent': - - event_move = self.controller.step( - action="Teleport", - position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) - ) - - #execute a rotation body operation - event_rotate = self.controller.step( - action="RotateAgent", - degrees=kwargs['body_yaw_delta'], - returnToStart=False, - speed=1, - fixedDeltaTime=0.02 - ) - - success = event_move.metadata['lastActionSuccess'] - error = [event_move.metadata['errorMessage']] - self.last_event = event_move - - - elif action == 'RotateAgent': - - #execute a rotation body operation - event_rotate = self.controller.step( - action="RotateAgent", - degrees=kwargs['body_yaw_delta'], - returnToStart=False, - speed=1, - fixedDeltaTime=0.02 - ) - - event_move = self.controller.step( - action="Teleport", - position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) - ) - - success = event_rotate.metadata['lastActionSuccess'] - error = [event_rotate.metadata['errorMessage']] - self.last_event = event_rotate - - - - elif action == 'MoveArm': - - #execute smooth move arm operation - event = self.controller.step( - action="MoveArm", - position=dict(x=kwargs['arm_position'][0], y=kwargs['arm_position'][1], z=kwargs['arm_position'][2]), - coordinateSpace="world", - restrictMovement=False, - speed=1, - returnToStart=False, - fixedDeltaTime=0.02 - ) - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action == 'PickupObject': - - #execute pickup - event = self.controller.step( - action="PickupObject", - objectIdCandidates=[] - ) - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action == 'ReleaseObject': - - #execute pickup - event = self.controller.step( - action="ReleaseObject", - objectIdCandidates=[] - ) - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action in set(['LookDown','LookUp']): - - #execute smooth change in pitch - events = self.smooth_look(action) - - success = events[-1].metadata['lastActionSuccess'] if len(events)>0 else False - error = [events[-1].metadata['errorMessage']] if len(events)>0 else ['Reached boundary of LookUp/LookDown'] - self.last_event = events[-1] if len(events)>0 else self.last_event - - - elif action == 'stop': - #stop the execution - event = self.controller.step(action="Done") - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action == None: - #no operation to be done - success = True - error = [''] - - else: - - raise Exception('Error: the provided action {} is not valid'.format(action)) - - return success, error, self.last_event - - def step_old(self, action, smooth_nav=False): - ''' - overrides ai2thor.controller.Controller.step() for smooth navigation and goal_condition updates - ''' - if 'action' in action: - if smooth_nav: - if "MoveAhead" in action['action']: - self.smooth_move_ahead(action) - elif "Rotate" in action['action']: - self.smooth_rotate(action) - elif "Look" in action['action']: - self.smooth_look(action) - else: - super().step(action) - else: - if "LookUp" in action['action']: - self.look_angle(-constants.AGENT_HORIZON_ADJ) - elif "LookDown" in action['action']: - self.look_angle(constants.AGENT_HORIZON_ADJ) - else: - super().step(action) - else: - super().step(action) - - event = self.update_states(action) - self.check_post_conditions(action) - return event - - - - def noop(self): - ''' - do nothing - ''' - super().step(dict(action='Pass')) - - def smooth_move_ahead(self, action, render_settings=None): - ''' - smoother MoveAhead - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - smoothing_factor = constants.RECORD_SMOOTHING_FACTOR - new_action = copy.deepcopy(action) - new_action['moveMagnitude'] = constants.AGENT_STEP_SIZE / smoothing_factor - - new_action['renderImage'] = render_settings['renderImage'] - new_action['renderClassImage'] = render_settings['renderClassImage'] - new_action['renderObjectImage'] = render_settings['renderObjectImage'] - new_action['renderDepthImage'] = render_settings['renderDepthImage'] - - events = [] - for xx in range(smoothing_factor - 1): - event = super().step(new_action) - if event.metadata['lastActionSuccess']: - events.append(event) - - event = super().step(new_action) - if event.metadata['lastActionSuccess']: - events.append(event) - return events - - def smooth_rotate(self, action, render_settings=None): - ''' - smoother RotateLeft and RotateRight - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - event = self.last_event - horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) - position = event.metadata['agent']['position'] - rotation = event.metadata['agent']['rotation'] - start_rotation = rotation['y'] - if action['action'] == 'RotateLeft': - end_rotation = (start_rotation - 90) - else: - end_rotation = (start_rotation + 90) - - events = [] - for xx in np.arange(.1, 1.0001, .1): - if xx < 1: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': horizon, - 'tempRenderChange': True, - 'renderNormalsImage': False, - 'renderImage': render_settings['renderImage'], - 'renderClassImage': render_settings['renderClassImage'], - 'renderObjectImage': render_settings['renderObjectImage'], - 'renderDepthImage': render_settings['renderDepthImage'], - } - event = super().step(teleport_action) - else: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': horizon, - } - event = super().step(teleport_action) - - if event.metadata['lastActionSuccess']: - events.append(event) - return events - - def smooth_look(self, action, render_settings=None): - ''' - smoother LookUp and LookDown - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - event = self.last_event - start_horizon = event.metadata['agent']['cameraHorizon'] - rotation = np.round(event.metadata['agent']['rotation']['y'], 4) - end_horizon = start_horizon + constants.AGENT_HORIZON_ADJ * (1 - 2 * int(action == 'LookUp')) - position = event.metadata['agent']['position'] - - events = [] - for xx in np.arange(.1, 1.0001, .1): - if xx < 1: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': rotation, - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), - 'tempRenderChange': True, - 'renderNormalsImage': False, - 'renderImage': render_settings['renderImage'], - 'renderClassImage': render_settings['renderClassImage'], - 'renderObjectImage': render_settings['renderObjectImage'], - 'renderDepthImage': render_settings['renderDepthImage'], - 'standing': True, - } - event = self.controller.step(teleport_action) - else: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': rotation, - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), - 'standing':True, - } - event = self.controller.step(teleport_action) - - if event.metadata['lastActionSuccess']: - events.append(event) - - return events - - def rotate_angle(self, angle, render_settings=None): - ''' - rotate at a specific angle - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - event = self.last_event - horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) - position = event.metadata['agent']['position'] - rotation = event.metadata['agent']['rotation'] - start_rotation = rotation['y'] - end_rotation = start_rotation + angle - - teleport_action = { - 'action': 'TeleportFull', - 'rotation': np.round(end_rotation, 3), - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': horizon, - 'tempRenderChange': True, - 'renderNormalsImage': False, - 'renderImage': render_settings['renderImage'], - 'renderClassImage': render_settings['renderClassImage'], - 'renderObjectImage': render_settings['renderObjectImage'], - 'renderDepthImage': render_settings['renderDepthImage'], - } - event = super().step(teleport_action) - return event - - def to_thor_api_exec(self, action, object_id="", smooth_nav=False): - # TODO: parametrized navigation commands - - if "RotateLeft" in action: - action = dict(action="RotateLeft", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "RotateRight" in action: - action = dict(action="RotateRight", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "MoveAhead" in action: - action = dict(action="MoveAhead", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "LookUp" in action: - action = dict(action="LookUp", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "LookDown" in action: - action = dict(action="LookDown", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "OpenObject" in action: - action = dict(action="OpenObject", - objectId=object_id, - moveMagnitude=1.0) - event = self.step(action) - elif "CloseObject" in action: - action = dict(action="CloseObject", - objectId=object_id, - forceAction=True) - event = self.step(action) - elif "PickupObject" in action: - action = dict(action="PickupObject", - objectId=object_id) - event = self.step(action) - elif "PutObject" in action: - inventory_object_id = self.last_event.metadata['inventoryObjects'][0]['objectId'] - action = dict(action="PutObject", - objectId=object_id, - forceAction=True, - placeStationary=True) - event = self.step(action) - elif "ToggleObjectOn" in action: - action = dict(action="ToggleObjectOn", - objectId=object_id) - event = self.step(action) - - elif "ToggleObjectOff" in action: - action = dict(action="ToggleObjectOff", - objectId=object_id) - event = self.step(action) - elif "SliceObject" in action: - # check if agent is holding knife in hand - inventory_objects = self.last_event.metadata['inventoryObjects'] - if len(inventory_objects) == 0 or 'Knife' not in inventory_objects[0]['objectType']: - raise Exception("Agent should be holding a knife before slicing.") - - action = dict(action="SliceObject", - objectId=object_id) - event = self.step(action) - else: - raise Exception("Invalid action. Conversion to THOR API failed! (action='" + str(action) + "')") - - return event, action - - def take_action(self, word_action, num_action, rand_agent=False): - i = 0 - incr = 0.025 - x = 0 - y = 0 - z = 0 - fixedDeltaTime = 0.02 - move = 0.2 - a = None - - if rand_agent: - all_word_actions = ['PickupObject','ReleaseObject', 'LookUp', 'LookDown', 'MoveArm', 'MoveArmBase', 'RotateAgent', 'MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft', 'stop'] - rand_word_action = choice(all_word_actions) - if rand_word_action in ["stop"]: - return "stop", None - elif rand_word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: - a = dict(action = rand_word_action) - elif rand_word_action in ['MoveArm', 'MoveArmBase']: - global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] - curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] - rand_x_indx, rand_y_indx, rand_z_indx = randint(1, 256), randint(1, 256), randint(1, 256) # starts at 1 to skip NoOp - x_del, y_del, z_del = self.bins["4"][rand_x_indx], self.bins["5"][rand_y_indx], self.bins["6"][rand_z_indx] - new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del - a = dict(action='MoveArm', position=dict(x=new_x, y=new_y, z=new_z),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) - elif rand_word_action in ['RotateAgent']: - rand_yaw_indx = randint(1, 256) - new_yaw = self.bins["3"][rand_yaw_indx] - a = dict(action=rand_word_action, degrees=new_yaw, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - else: # move base - a = dict(action=rand_word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - - else: - if word_action in ['NoOp']: - print(f"Word Action: NoOP", end="\r") # for debugging - return None, None, self.last_event.metadata - if word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: - a = dict(action = word_action) - elif word_action in ['MoveArm', 'MoveArmBase']: - global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] - curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] - x_del, y_del, z_del = self.bins["4"][num_action[0]], self.bins["5"][num_action[1]], self.bins["6"][num_action[2]] - if x_del == -1000 or y_del == -1000 or z_del == -1000: # if any of them are NoOp then skip all. Can do it another way where only skip the specific axis - print(f"Word Action: NoOP", end="\r") # for debugging - return None, None, self.last_event.metadata - new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del - a = dict(action='MoveArm',position=dict(x=new_x, y=new_z, z=new_y),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) - elif word_action in ['RotateAgent']: - yaw_del = num_action.item() - new_yaw = self.bins["3"][yaw_del] - if new_yaw == -1000: #make it variable later - print(f"Word Action: NoOP", end="\r") # for debugging - return None, None, self.last_event.metadata - a = dict(action=word_action, degrees=new_yaw,returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - else: # move base - a = dict(action=word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - - sleep(0.5) #for debugging/movement analysis - event = self.controller.step(a) - success = event.metadata['lastActionSuccess'] - error = event.metadata['errorMessage'] - self.last_event = event - #for debugging/movement analysis - sleep(0.5) - if rand_agent: - print(f"Random Word Action: {rand_word_action} ", end="\r") - # else: - # print(f"Word Action: {word_action} ", end="\r") - # print(f"Num Action: {num_action} ", end="\r") - - return success, error, self.last_event.metadata - - - - -if __name__ == '__main__': - - SCENE_NAME = 'FloorPlan_Train5_1' - TESTED_STEPS = 200 - - test = ThorEnv('Walk to the living room') - - event = test.reset(scene_name=SCENE_NAME) - - curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) - curr_body_yaw = event.metadata['agent']['rotation']['y'] - curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) - agent_holding = np.array([]) - - - test.controller.step( - action="MoveArmBase", - y=0.0, - speed=1, - returnToStart=True, - fixedDeltaTime=0.02 - ) - - - for i in range(TESTED_STEPS): - - print(''' - (1) Move X+ - (2) Move X- - (3) Move Z+ - (4) Move Z- - (5) Rotate Left - (6) Rotate Right - (7) Rotate Up - (8) Rotate Down - (9) Open Gripper - (0) Close Gripper - (h) Move Gripper up - (n) Move Gripper down - (b) Move Gripper left - (m) Move Gripper right - (z) Move Gripper forward - (x) Move Gripper backwards - ''') - - - action = input('>') - - - if action == '1': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[0] += 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '2': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[0] -= 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '3': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[2] += 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '4': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[2] -= 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '5': - - success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta': -90}) - - elif action == '6': - - success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta':+90}) - - elif action == '7': - - success, error, event = test.step('LookUp', {}) - - elif action == '8': - - success, error, event = test.step('LookDown', {}) - - elif action == '9': - - success, error, event = test.step('PickupObject', {}) - - elif action == '0': - - success, error, event = test.step('ReleaseObject', {}) - - elif action == 'h': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[1] += 0.20 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'n': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[1] -= 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'b': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[0] += 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'm': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[0] -= 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'z': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[2] += 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'x': - - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[2] -= 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) diff --git a/models/main_models/rt1/data.py b/models/main_models/rt1/data.py deleted file mode 100644 index 71bff29ba..000000000 --- a/models/main_models/rt1/data.py +++ /dev/null @@ -1,536 +0,0 @@ -# Taken from https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit#gid=0 -import abc -import dataclasses -from typing import Any, Dict, Iterable, Optional, Union -import pdb -import numpy as np -import reverb -import tensorflow as tf -import tensorflow_datasets as tfds -import tree -from rlds import rlds_types, transformations - -tf.config.experimental.set_visible_devices([], "GPU") - - -def dataset2path(name): - if name == "robo_net": - version = "1.0.0" - elif name == "language_table": - version = "0.0.1" - else: - version = "0.1.0" - return f"gs://gresearch/robotics/{name}/{version}" - - -def as_gif(images, path="temp.gif"): - # Render the images as the gif: - images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0) - gif_bytes = open(path, "rb").read() - return gif_bytes - - -def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec: - """Converts a tfds Feature into a TensorSpec.""" - - def _get_feature_spec(nested_feature: tfds.features.FeatureConnector): - if isinstance(nested_feature, tf.DType): - return tf.TensorSpec(shape=(), dtype=nested_feature) - else: - return nested_feature.get_tensor_spec() - - # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to - # make sure we deal with the nested structure. - return tf.nest.map_structure(_get_feature_spec, feature) - - -def _encoded_feature( - feature: Optional[tfds.features.FeatureConnector], - image_encoding: Optional[str], - tensor_encoding: Optional[tfds.features.Encoding], -): - """Adds encoding to Images and/or Tensors.""" - - def _apply_encoding( - feature: tfds.features.FeatureConnector, - image_encoding: Optional[str], - tensor_encoding: Optional[tfds.features.Encoding], - ): - if image_encoding and isinstance(feature, tfds.features.Image): - return tfds.features.Image( - shape=feature.shape, - dtype=feature.dtype, - use_colormap=feature.use_colormap, - encoding_format=image_encoding, - ) - if ( - tensor_encoding - and isinstance(feature, tfds.features.Tensor) - and feature.dtype != tf.string - ): - return tfds.features.Tensor( - shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding - ) - return feature - - if not feature: - return None - return tf.nest.map_structure( - lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature - ) - - -@dataclasses.dataclass -class RLDSSpec(metaclass=abc.ABCMeta): - """Specification of an RLDS Dataset. - - It is used to hold a spec that can be converted into a TFDS DatasetInfo or - a `tf.data.Dataset` spec. - """ - - observation_info: Optional[tfds.features.FeatureConnector] = None - action_info: Optional[tfds.features.FeatureConnector] = None - reward_info: Optional[tfds.features.FeatureConnector] = None - discount_info: Optional[tfds.features.FeatureConnector] = None - step_metadata_info: Optional[tfds.features.FeaturesDict] = None - episode_metadata_info: Optional[tfds.features.FeaturesDict] = None - - def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]: - """Obtains the TensorSpec of an RLDS step.""" - step = {} - if self.observation_info: - step[rlds_types.OBSERVATION] = _features_to_tensor_spec( - self.observation_info - ) - if self.action_info: - step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info) - if self.discount_info: - step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info) - if self.reward_info: - step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info) - if self.step_metadata_info: - for k, v in self.step_metadata_info.items(): - step[k] = _features_to_tensor_spec(v) - - step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool) - step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool) - step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool) - return step - - def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]: - """Obtains the TensorSpec of an RLDS step.""" - episode = {} - episode[rlds_types.STEPS] = tf.data.DatasetSpec( - element_spec=self.step_tensor_spec() - ) - if self.episode_metadata_info: - for k, v in self.episode_metadata_info.items(): - episode[k] = _features_to_tensor_spec(v) - return episode - - def to_dataset_config( - self, - name: str, - image_encoding: Optional[str] = None, - tensor_encoding: Optional[tfds.features.Encoding] = None, - citation: Optional[str] = None, - homepage: Optional[str] = None, - description: Optional[str] = None, - overall_description: Optional[str] = None, - ) -> tfds.rlds.rlds_base.DatasetConfig: - """Obtains the DatasetConfig for TFDS from the Spec.""" - return tfds.rlds.rlds_base.DatasetConfig( - name=name, - description=description, - overall_description=overall_description, - homepage=homepage, - citation=citation, - observation_info=_encoded_feature( - self.observation_info, image_encoding, tensor_encoding - ), - action_info=_encoded_feature( - self.action_info, image_encoding, tensor_encoding - ), - reward_info=_encoded_feature( - self.reward_info, image_encoding, tensor_encoding - ), - discount_info=_encoded_feature( - self.discount_info, image_encoding, tensor_encoding - ), - step_metadata_info=_encoded_feature( - self.step_metadata_info, image_encoding, tensor_encoding - ), - episode_metadata_info=_encoded_feature( - self.episode_metadata_info, image_encoding, tensor_encoding - ), - ) - - def to_features_dict(self): - """Returns a TFDS FeaturesDict representing the dataset config.""" - step_config = { - rlds_types.IS_FIRST: tf.bool, - rlds_types.IS_LAST: tf.bool, - rlds_types.IS_TERMINAL: tf.bool, - } - - if self.observation_info: - step_config[rlds_types.OBSERVATION] = self.observation_info - if self.action_info: - step_config[rlds_types.ACTION] = self.action_info - if self.discount_info: - step_config[rlds_types.DISCOUNT] = self.discount_info - if self.reward_info: - step_config[rlds_types.REWARD] = self.reward_info - - if self.step_metadata_info: - for k, v in self.step_metadata_info.items(): - step_config[k] = v - - if self.episode_metadata_info: - return tfds.features.FeaturesDict( - { - rlds_types.STEPS: tfds.features.Dataset(step_config), - **self.episode_metadata_info, - } - ) - else: - return tfds.features.FeaturesDict( - { - rlds_types.STEPS: tfds.features.Dataset(step_config), - } - ) - - -RLDS_SPEC = RLDSSpec -TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]] - - -@dataclasses.dataclass -class TrajectoryTransform(metaclass=abc.ABCMeta): - """Specification the TrajectoryTransform applied to a dataset of episodes. - - A TrajectoryTransform is a set of rules transforming a dataset - of RLDS episodes to a dataset of trajectories. - This involves three distinct stages: - - An optional `episode_to_steps_map_fn(episode)` is called at the episode - level, and can be used to select or modify steps. - - Augmentation: an `episode_key` could be propagated to `steps` for - debugging. - - Selection: Particular steps can be selected. - - Stripping: Features can be removed from steps. Prefer using `step_map_fn`. - - An optional `step_map_fn` is called at the flattened steps dataset for each - step, and can be used to featurize a step, e.g. add/remove features, or - augument images - - A `pattern` leverages DM patterns to set a rule of slicing an episode to a - dataset of overlapping trajectories. - - Importantly, each TrajectoryTransform must define a `expected_tensor_spec` - which specifies a nested TensorSpec of the resulting dataset. This is what - this TrajectoryTransform will produce, and can be used as an interface with - a neural network. - """ - - episode_dataset_spec: RLDS_SPEC - episode_to_steps_fn_dataset_spec: RLDS_SPEC - steps_dataset_spec: Any - pattern: reverb.structured_writer.Pattern - episode_to_steps_map_fn: Any - expected_tensor_spec: TENSOR_SPEC - step_map_fn: Optional[Any] = None - - def get_for_cached_trajectory_transform(self): - """Creates a copy of this traj transform to use with caching. - - The returned TrajectoryTransfrom copy will be initialized with the default - version of the `episode_to_steps_map_fn`, because the effect of that - function has already been materialized in the cached copy of the dataset. - Returns: - trajectory_transform: A copy of the TrajectoryTransform with overridden - `episode_to_steps_map_fn`. - """ - traj_copy = dataclasses.replace(self) - traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec - traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS] - return traj_copy - - def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset): - """Applies this TrajectoryTransform to the dataset of episodes.""" - - # Convert the dataset of episodes to the dataset of steps. - steps_dataset = episodes_dataset.map( - self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE - ).flat_map(lambda x: x) - - return self._create_pattern_dataset(steps_dataset) - - def transform_steps_rlds_dataset( - self, steps_dataset: tf.data.Dataset - ) -> tf.data.Dataset: - """Applies this TrajectoryTransform to the dataset of episode steps.""" - - return self._create_pattern_dataset(steps_dataset) - - def create_test_dataset( - self, - ) -> tf.data.Dataset: - """Creates a test dataset of trajectories. - - It is guaranteed that the structure of this dataset will be the same as - when flowing real data. Hence this is a useful construct for tests or - initialization of JAX models. - Returns: - dataset: A test dataset made of zeros structurally identical to the - target dataset of trajectories. - """ - zeros = transformations.zeros_from_spec(self.expected_tensor_spec) - - return tf.data.Dataset.from_tensors(zeros) - - def _create_pattern_dataset( - self, steps_dataset: tf.data.Dataset - ) -> tf.data.Dataset: - """Create PatternDataset from the `steps_dataset`.""" - config = create_structured_writer_config("temp", self.pattern) - - # Further transform each step if the `step_map_fn` is provided. - if self.step_map_fn: - steps_dataset = steps_dataset.map(self.step_map_fn) - pattern_dataset = reverb.PatternDataset( - input_dataset=steps_dataset, - configs=[config], - respect_episode_boundaries=True, - is_end_of_episode=lambda x: x[rlds_types.IS_LAST], - ) - return pattern_dataset - - -class TrajectoryTransformBuilder(object): - """Facilitates creation of the `TrajectoryTransform`.""" - - def __init__( - self, - dataset_spec: RLDS_SPEC, - episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS], - step_map_fn=None, - pattern_fn=None, - expected_tensor_spec=None, - ): - self._rds_dataset_spec = dataset_spec - self._steps_spec = None - self._episode_to_steps_map_fn = episode_to_steps_map_fn - self._step_map_fn = step_map_fn - self._pattern_fn = pattern_fn - self._expected_tensor_spec = expected_tensor_spec - - def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform: - """Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.""" - - if validate_expected_tensor_spec and self._expected_tensor_spec is None: - raise ValueError("`expected_tensor_spec` must be set.") - - episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec) - - steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn) - - episode_to_steps_fn_dataset_spec = self._rds_dataset_spec - - if self._step_map_fn is not None: - steps_ds = steps_ds.map(self._step_map_fn) - - zeros_spec = transformations.zeros_from_spec( - steps_ds.element_spec - ) # pytype: disable=wrong-arg-types - - ref_step = reverb.structured_writer.create_reference_step(zeros_spec) - - pattern = self._pattern_fn(ref_step) - - steps_ds_spec = steps_ds.element_spec - - target_tensor_structure = create_reverb_table_signature( - "temp_table", steps_ds_spec, pattern - ) - - if ( - validate_expected_tensor_spec - and self._expected_tensor_spec != target_tensor_structure - ): - raise RuntimeError( - "The tensor spec of the TrajectoryTransform doesn't " - "match the expected spec.\n" - "Expected:\n%s\nActual:\n%s\n" - % ( - str(self._expected_tensor_spec).replace( - "TensorSpec", "tf.TensorSpec" - ), - str(target_tensor_structure).replace("TensorSpec", "tf.TensorSpec"), - ) - ) - - return TrajectoryTransform( - episode_dataset_spec=self._rds_dataset_spec, - episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec, - steps_dataset_spec=steps_ds_spec, - pattern=pattern, - episode_to_steps_map_fn=self._episode_to_steps_map_fn, - step_map_fn=self._step_map_fn, - expected_tensor_spec=target_tensor_structure, - ) - - -def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC): - """Creates a zero valued dataset of episodes for the given RLDS Spec.""" - - def add_steps(episode, step_spec): - episode[rlds_types.STEPS] = transformations.zero_dataset_like( - tf.data.DatasetSpec(step_spec) - ) - if "fake" in episode: - del episode["fake"] - return episode - - episode_without_steps_spec = { - k: v - for k, v in rlds_spec.episode_tensor_spec().items() - if k != rlds_types.STEPS - } - - if episode_without_steps_spec: - episodes_dataset = transformations.zero_dataset_like( - tf.data.DatasetSpec(episode_without_steps_spec) - ) - else: - episodes_dataset = tf.data.Dataset.from_tensors({"fake": ""}) - - episodes_dataset_with_steps = episodes_dataset.map( - lambda episode: add_steps(episode, rlds_spec.step_tensor_spec()) - ) - return episodes_dataset_with_steps - - -def create_reverb_table_signature( - table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern -) -> reverb.reverb_types.SpecNest: - config = create_structured_writer_config(table_name, pattern) - reverb_table_spec = reverb.structured_writer.infer_signature( - [config], steps_dataset_spec - ) - return reverb_table_spec - - -def create_structured_writer_config( - table_name: str, pattern: reverb.structured_writer.Pattern -) -> Any: - config = reverb.structured_writer.create_config( - pattern=pattern, table=table_name, conditions=[] - ) - return config - - -def n_step_pattern_builder(n: int) -> Any: - """Creates trajectory of length `n` from all fields of a `ref_step`.""" - - def transform_fn(ref_step): - traj = {} - for key in ref_step: - if isinstance(ref_step[key], dict): - transformed_entry = tree.map_structure( - lambda ref_node: ref_node[-n:], ref_step[key] - ) - traj[key] = transformed_entry - else: - traj[key] = ref_step[key][-n:] - - return traj - - return transform_fn - - -def get_observation_and_action_from_step(step): - return { - "observation": { - "image": step["observation"]["image"], - "embedding": step["observation"]["natural_language_embedding"], - "instruction": step["observation"]["natural_language_instruction"], - }, - # Decode one hot discrete actions - "action": { - k: tf.argmax(v, axis=-1) if v.dtype == tf.int32 else v - for k, v in step["action"].items() - }, - } - - -def create_dataset( - datasets=["fractal20220817_data"], - split="train", - trajectory_length=6, - batch_size=32, - num_epochs=1, -) -> Iterable[Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]]: - trajectory_datasets = [] - #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) - for dataset in datasets: - #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) - - - # b = tfds.builder_from_directory(builder_dir='/oscar/data/stellex/shared/bridge/0.1.0') - #'~/data/sjulian2/bridge/0.1.0/' - # dataset = tfds.load('bridge', split='train') - #b = tfds.builder_from_directory(builder_dir='/users/sjulian2/data/sjulian2/jaco_play/0.1.0') - # b = tfds.builder_from_directory(builder_dir=dataset2path(dataset)) - - # pdb.set_trace() - b = tfds.builder_from_directory(builder_dir = '/oscar/data/stellex/ssunda11/NPM-Dataset/rt1-pytorch/rt1_dataset/0.1.0') - # ds = tfds.load("fractal20220817_data:0.1.0", data_dir="gs://gresearch/robotics") - - ds = b.as_dataset(split=split) - - # The RLDSSpec for the RT1 dataset. - rt1_spec = RLDSSpec( - observation_info=b.info.features["steps"]["observation"], - action_info=b.info.features["steps"]["action"], - ) - - trajectory_transform = TrajectoryTransformBuilder( - rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length) - ).build(validate_expected_tensor_spec=False) - - trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds) - #pdb.set_trace() - trajectory_datasets.append(trajectory_dataset) - - trajectory_dataset = tf.data.Dataset.sample_from_datasets(trajectory_datasets) - - trajectory_dataset = trajectory_dataset.map( - get_observation_and_action_from_step, num_parallel_calls=tf.data.AUTOTUNE - ) - - # Shuffle, batch, prefetch, repeat - trajectory_dataset = trajectory_dataset.shuffle(batch_size * 16) - trajectory_dataset = trajectory_dataset.batch( - batch_size, - drop_remainder=True, - num_parallel_calls=tf.data.AUTOTUNE, - deterministic=False, - ) - trajectory_dataset = trajectory_dataset.repeat(num_epochs) - trajectory_dataset = trajectory_dataset.prefetch(tf.data.AUTOTUNE) - # pdb.set_trace() - return iter(trajectory_dataset.as_numpy_iterator()) - - -if __name__ == "__main__": - #pdb.set_trace() - ds = create_dataset(datasets=["fractal20220817_data"], split="train[:10]") - it = next(ds) - - def print_shape(x): - if isinstance(x, dict): - shapes = tree.map_structure(lambda x: x.shape, x) - else: - shapes = x.shape - return shapes - - shapes = tree.map_structure(print_shape, it) - print(shapes) diff --git a/models/main_models/rt1/figures/rt1.png b/models/main_models/rt1/figures/rt1.png deleted file mode 100644 index 17426537180d0baaa5b824e60bd94298ce6d5c35..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 135877 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

Q!2CmkZcV&= zE+D`>`W_^B{DHWHk_O;J9rAJehtNMnEe>joZl0HySb1jUe(#U${00*%J^=++h&Kb@>ZJ;S*8W`YoJx)*Zf3>zW_*YW z81~rWl#i!SDs(OoS~!?vmv3Oiqc6_+UKX@%M4rcV=e{Oi2pK(;08wpITi|5R7i%H6}G@V%pSDL zJoa%3sDX5buxD4dFP4>sCzdwXQ|W{nk<3Fbu?0qREEcsvOF2g!OUrArn_yMml@}T< zO8!?}M3=7k@PlTlEx3ad z!G}6e72vI`uk*)-N^16YF6rH1v@qAt29{^PhUW~wctqQ_8~%r1hvIX20ICjG(j7_Z z)$@sss^78UaIivynHhLo5&^0j1}>ja{<$pAV3n`eieN+7!Gf>{WD;{0{5{s$%GMw8!-3OdF94dah*mc@A_IPzOZB|3O`K6a6`>cOg(csfx4oBx z{`m&#bP7Xm&k!scgo*Z_=z8Jh=+PM~JV90zhHj;!ke#SHv>H}oHXOf${Xt8O=~HfZ zn0miq5CksNRIcRNczM5^`OgvFA7YdWkq`x!k4?J#+>0xFJkqZq0FOhsF!O$BP@Cz) zS_S;wP*V}mLahUCCO_UM=op0Lv*gPFmt-B`%?&1YykZ|xoy;9jS95tn-V}Y&9LLa+ z8S;38Gq#CChX(0Z)OJGbmoV5FB4z3)SjPm^#+Gz7o%){BRJ>_1Umpictd)_HRAt9M zy^PsxR{C_g%6X`yqETSgpLdj&dp-^FyF23NCFOGmgbx{rN0vg07G>yxVS&(lkm@_@Yf%MDVw*CwEDV8#sp+tWft$N#Hc``gY!`=2^c;6nfXUn40i{g0*a_c$ub|5tPQ|3NH- Y#5u$X1_XKM0t5X>iOGvr3mXRgFLU@ATL1t6 diff --git a/models/main_models/rt1/gen/README.md b/models/main_models/rt1/gen/README.md deleted file mode 100644 index 607e80b9b..000000000 --- a/models/main_models/rt1/gen/README.md +++ /dev/null @@ -1,77 +0,0 @@ -# Data Generation - -We also provide code for generating PDDL-based expert demonstrations. This can be used to extend the training data, albiet without human language annotations. - -## Installation - -Get dependencies and compile the planner: -```bash -$ sudo apt-get install ffmpeg flex bison - -$ cd $ALFRED_ROOT/gen/ff_planner -$ make -``` - -## Generation - -To spawn multiple generation threads: - -```bash -$ cd $ALFRED_ROOT/gen -$ python scripts/generate_trajectories.py --save_path data/new_trajs --in_parallel --debug --num_threads 2 -``` - -This will sample tasks based on the sampling mechanism described in the paper. You might notice a lot of failed executions, which are automatically discarded by the script. - -**Note:** The first time you run the generation script, use `--num_threads 1` to allow the script to download the THOR binary. - -## Replay Checks - -In parallel with generation, replay saved trajectories to check if they are reproducable: - -```bash -$ python scripts/replay_checks.py --data_path data/new_trajs --in_parallel -``` -This will ensure that the interaction masks and expert actions can be deterministically executed in THOR. - -## Data Augmentation - -Currently, the dataset only provides 300x300 RGB images. However, each trajectory can be replayed to save any additional info available from the simulator. See the [augment_trajectories.py](scripts/augment_trajectories.py) script as an example for saving 600x600 RGB, depth and instance segmentation masks from the existing dataset: - -```bash -python scripts/augment_trajectories.py --data_path data/json_2.1.0 --num_threads 2 --smooth_nav --time_delays -``` - -![](../media/aug.png) - -Note that these files consume a lot of storage space. - -## PDDL Tasks - -The goals for the planner are specified in [goal_library.py](goal_library.py). Here is a simple pick-and-place PDDL goal definition: - -``` -# basic pick and place (e.g: "put the apple in the microwave") -gdict["pick_and_place_simple"] = ''' - (:goal - (and - ;; make sure all the cabinets and doors are closed in the end - (forall (?re # receptacle) - (not (opened ?re)) - ) - - ;; make sure some object {obj} exists inside some receptacle {recep} - (exists (?r # receptacle) - (exists (?o # object) - (and - (inReceptacle ?o ?r) - (objectType ?o {obj}Type) - (receptacleType ?r {recep}Type) - ) - ) - ) - ) - ) -) -``` - diff --git a/models/main_models/rt1/gen/__init__.py b/models/main_models/rt1/gen/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/models/main_models/rt1/gen/agents/agent_base.py b/models/main_models/rt1/gen/agents/agent_base.py deleted file mode 100644 index 34cb3f725..000000000 --- a/models/main_models/rt1/gen/agents/agent_base.py +++ /dev/null @@ -1,60 +0,0 @@ -import copy -import time -import numpy as np - - -class AgentBase(object): - def __init__(self, thread_id=0, game_state=None): - assert(game_state is not None) - self.game_state = game_state - self.thread_id = thread_id - self.timers = np.zeros((2, 2)) - self.total_frame_count = 0 - self.current_frame_count = 0 - self.gt_graph = None - self.bounds = None - self.pose = None - self.terminal = False - self.num_invalid_actions = 0 - self.total_num_invalid_actions = 0 - - def setup_problem(self, game_state_problem_args, scene=None, objs=None): - self.game_state.setup_problem(**game_state_problem_args, scene=scene, objs=objs) - - def reset(self, game_state_reset_args, scene=None, objs=None): - self.game_state.reset(**game_state_reset_args, scene=scene, objs=objs) - - self.timers = np.zeros((2, 2)) - self.current_frame_count = 0 - self.gt_graph = None - self.bounds = None - self.pose = None - self.terminal = False - self.num_invalid_actions = 0 - - self.total_frame_count += 1 - self.gt_graph = self.game_state.gt_graph - self.bounds = self.game_state.bounds - self.pose = self.game_state.pose - - def step(self, action): - self.total_frame_count += 1 - self.current_frame_count += 1 - t_start = time.time() - self.game_state.step(action) - if not self.game_state.event.metadata['lastActionSuccess']: - self.num_invalid_actions += 1 - self.total_num_invalid_actions += 1 - self.timers[0, 0] += time.time() - t_start - self.timers[0, 1] += 1 - if self.timers[0, 1] % 100 == 0: - print('game state step time %.3f' % (self.timers[0, 0] / self.timers[0, 1])) - self.timers[0, :] = 0 - self.pose = self.game_state.pose - - def get_action(self, action_ind): - action = copy.deepcopy(self.game_state.action_space[action_ind]) - if action['action'] == 'End': - # Remove other arguments - action = {'action': 'End'} - return action diff --git a/models/main_models/rt1/gen/agents/deterministic_planner_agent.py b/models/main_models/rt1/gen/agents/deterministic_planner_agent.py deleted file mode 100644 index b67e25457..000000000 --- a/models/main_models/rt1/gen/agents/deterministic_planner_agent.py +++ /dev/null @@ -1,26 +0,0 @@ -from agents.semantic_map_planner_agent import SemanticMapPlannerAgent - - -class DeterministicPlannerAgent(SemanticMapPlannerAgent): - def __init__(self, thread_id=0, game_state=None): - super(DeterministicPlannerAgent, self).__init__(thread_id, game_state) - self.action_sequence = None - self.question = None - - def reset(self, seed=None, info=None, scene=None, objs=None): - info = super(DeterministicPlannerAgent, self).reset(seed, info, scene=scene, objs=objs) - self.action_sequence = ['Plan', 'End'] - return info - - def step(self, action, executing_plan=False): - if not executing_plan: - self.action_sequence = self.action_sequence[1:] - super(DeterministicPlannerAgent, self).step(action) - - def get_action(self, action_ind=None): - assert(action_ind is None) - return {'action': self.action_sequence[0]} - - def get_reward(self): - return 0, self.terminal - diff --git a/models/main_models/rt1/gen/agents/plan_agent.py b/models/main_models/rt1/gen/agents/plan_agent.py deleted file mode 100644 index eda12f215..000000000 --- a/models/main_models/rt1/gen/agents/plan_agent.py +++ /dev/null @@ -1,94 +0,0 @@ -import constants -from agents.agent_base import AgentBase -from game_states.planned_game_state import PlannedGameState -from utils import game_util - - -class PlanAgent(AgentBase): - def __init__(self, thread_id=0, game_state=None, controller_agent=None): - super(PlanAgent, self).__init__(thread_id, game_state) - assert(isinstance(game_state, PlannedGameState)) - self.controller_agent = controller_agent - self.planned = False - - def reset(self): - self.planned = False - - def execute_plan(self): - step_count = 0 - self.planned = True - self.controller_agent.planning = True - if constants.OPEN_LOOP: - plan = self.game_state.get_current_plan(force_update=True) - - if plan[0]['action'] == 'End': - raise ValueError('Empty plan is successful, no work to do') - - elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: - print ("Planning failed. Possibly because the goal was already satisfied") - raise ValueError("Symbolic Planning Failed") - - for idx, plan_action in enumerate(plan): - self.save_plan(plan, idx) - - if plan_action['action'] == 'GotoLocation': - plan_action = self.game_state.get_teleport_action(plan_action) - elif plan_action['action'] == 'End': - break - self.controller_agent.step(plan_action, executing_plan=True) - step_count += 1 - if self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH: - break - else: - past_plans = [] - plan = self.game_state.get_current_plan(force_update=True) - - if plan[0]['action'] == 'End': - raise ValueError('Empty plan is successful, no work to do') - elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: - print("Symbolic Planning Failed") - raise ValueError("Symbolic Planning Failed") - - plan_action = plan[0] - if constants.USE_DETERMINISTIC_CONTROLLER: - # Don't fail right away, just rotate a few times. - rotations = 0 - while rotations < 4 and (plan_action is None or plan_action['action'] == 'End'): - action = {'action': 'RotateLeft'} - self.controller_agent.step(action, executing_plan=True) - rotations += 1 - plan = self.game_state.get_current_plan(force_update=True) - plan_action = plan[0] - - while not(plan_action is None or plan_action['action'] == 'End'): - self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) - - # save data - self.save_plan(plan, 0) - - step_count += 1 - past_plans.append(plan) - if len(past_plans) > 5: - past_plans = past_plans[-5:] - plan = self.game_state.get_current_plan(force_update=True) - if plan[0]['action'] == 'End': - break - if (step_count >= constants.MAX_PLANNER_STEP_COUNT or - self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH): - # Too many steps, plan may be looping. - break - if len(plan) > 1 and any([plan == past_plan for past_plan in past_plans]): - plan_action = plan[0] - self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) - step_count += 1 - plan = plan[1:] - plan_action = plan[0] - - self.controller_agent.planning = False - - def save_plan(self, plan, idx=0): - plan_action = plan[idx] - constants.data_dict['plan']['high_pddl'].append({"high_idx": len(constants.data_dict['plan']['high_pddl']), - "planner_action": plan_action, - "discrete_action": game_util.get_discrete_hl_action(plan, idx)}) - constants.data_dict['template']['high_descs'].append(game_util.get_templated_action_str(plan, idx)) diff --git a/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py b/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py deleted file mode 100644 index 497ee242c..000000000 --- a/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py +++ /dev/null @@ -1,72 +0,0 @@ -import glob -import cv2 -import constants -from agents.agent_base import AgentBase -from agents.plan_agent import PlanAgent -from game_states.planned_game_state import PlannedGameState - - -class SemanticMapPlannerAgent(AgentBase): - def __init__(self, thread_id=0, game_state=None): - assert(isinstance(game_state, PlannedGameState)) - super(SemanticMapPlannerAgent, self).__init__(thread_id, game_state) - - self.plan_agent = PlanAgent(thread_id, game_state, self) - self.planning = False - - def reset(self, seed=None, info=None, scene=None, objs=None): - self.planning = False - info = self.game_state.get_setup_info(info, scene=scene)[0] - super(SemanticMapPlannerAgent, self).reset({'seed': seed, 'info': info}, scene=scene, objs=objs) - if self.plan_agent is not None: - self.plan_agent.reset() - return info - - def setup_problem(self, game_state_problem_args, scene=None, objs=None): - super(SemanticMapPlannerAgent, self).setup_problem(game_state_problem_args, scene=scene, objs=objs) - self.pose = self.game_state.pose - - def get_reward(self): - raise NotImplementedError - - def step(self, action, executing_plan=False): - if action['action'] == 'End': - self.current_frame_count += 1 - self.total_frame_count += 1 - self.terminal = True - - if constants.RECORD_VIDEO_IMAGES: - im_ind = len(glob.glob(constants.save_path + '/*.png')) - for _ in range(10): - cv2.imwrite(constants.save_path + '/%09d.png' % im_ind, - self.game_state.s_t[:, :, ::-1]) - im_ind += 1 - else: - if 'Teleport' in action['action']: - start_pose = self.pose - end_angle = action['horizon'] - end_pose = (int(action['x'] / constants.AGENT_STEP_SIZE), - int(action['z'] / constants.AGENT_STEP_SIZE), - int(action['rotation'] / 90), - int(end_angle)) - - self.game_state.gt_graph.navigate_to_goal(self.game_state, start_pose, end_pose) - self.pose = self.game_state.pose - elif action['action'] == 'Plan': - self.plan_agent.execute_plan() - if not constants.EVAL: - self.current_frame_count += 1 - self.total_frame_count += 1 - elif action['action'] == 'Scan': - self.game_state.step(action) - if not constants.EVAL: - self.current_frame_count += 1 - self.total_frame_count += 1 - elif action['action'] == 'Explore': - if not constants.EVAL: - self.current_frame_count += 1 - self.total_frame_count += 1 - else: - super(SemanticMapPlannerAgent, self).step(action) - - diff --git a/models/main_models/rt1/gen/constants.py b/models/main_models/rt1/gen/constants.py deleted file mode 100644 index e646c660d..000000000 --- a/models/main_models/rt1/gen/constants.py +++ /dev/null @@ -1,1221 +0,0 @@ -from collections import OrderedDict - -######################################################################################################################## -# General Settings - -DEBUG = True -EVAL = False -LOG_FILE = 'logs_gen' - -RECORD_VIDEO_IMAGES = True -RECORD_SMOOTHING_FACTOR = 1 -DATA_SAVE_PATH = "dataset/new_trajectories" - -OPEN_LOOP = True -FULL_OBSERVABLE_STATE = True - -######################################################################################################################## -# Generation Ablations - -MAX_NUM_OF_OBJ_INSTANCES = 3 # when randomly initializing the scene, create duplicate instance up to this number -PICKUP_REPEAT_MAX = 4 # how many of the target pickup object to generate in [1, MAX] (randomly chosen) -RECEPTACLE_SPARSE_POINTS = 50 # increment for how many points to leave free for sparsely populated receptacles -RECEPTACLE_EMPTY_POINTS = 200 # increment for how many points to leave free for empty receptacles - -MIN_VISIBLE_RATIO = 0.0011 # minimum area ratio (with respect to image size) of visible object -PLANNER_MAX_STEPS = 100 # if the generated plan is more than these steps, discard the traj -MAX_EPISODE_LENGTH = 1000 # maximum number of API steps allowed per trajectory - -FORCED_SAMPLING = False # set True for debugging instead of proper sampling -PRUNE_UNREACHABLE_POINTS = True # prune navigation points that were deemed unreachable by the proprocessing script - -######################################################################################################################## -# Goals - -GOALS = [ - "pick_and_place_simple", - "pick_two_obj_and_place", - "look_at_obj_in_light", - "pick_clean_then_place_in_recep", - "pick_heat_then_place_in_recep", - "pick_cool_then_place_in_recep", - "pick_and_place_with_movable_recep", - ] -GOALS_VALID = {"pick_and_place_simple": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, - "pick_two_obj_and_place": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, - "look_at_obj_in_light": {"LivingRoom", "Bedroom"}, - "pick_clean_then_place_in_recep": {"Kitchen", "Bathroom"}, - "pick_heat_then_place_in_recep": {"Kitchen"}, - "pick_cool_then_place_in_recep": {"Kitchen"}, - "pick_and_place_with_movable_recep": {"Kitchen", "LivingRoom", "Bedroom"}} - -pddl_goal_type = "pick_and_place_simple" # default goal type - -######################################################################################################################## -# Video Settings - -# filler frame IDs -BEFORE = 0 -MIDDLE = 1 -AFTER = 2 - -# number of image frames to save before and after executing the specified action -SAVE_FRAME_BEFORE_AND_AFTER_COUNTS = { - 'OpenObject': [2, 0, 2], - 'CloseObject': [2, 0, 2], - 'PickupObject': [5, 0, 10], - 'PutObject': [5, 0, 10], - 'CleanObject': [3, 0, 5], - 'HeatObject': [3, 0, 5], - 'CoolObject': [3, 30, 5], - 'ToggleObjectOn': [3, 0, 15], - 'ToggleObjectOff': [1, 0, 5], - 'SliceObject': [3, 0, 7] -} - -# FPS -VIDEO_FRAME_RATE = 5 - -######################################################################################################################## -# Data & Storage - -save_path = DATA_SAVE_PATH -data_dict = OrderedDict() # dictionary for storing trajectory data to be dumped - -######################################################################################################################## -# Unity Hyperparameters - -BUILD_PATH = None -X_DISPLAY = '0' - -AGENT_STEP_SIZE = 0.25 -AGENT_HORIZON_ADJ = 30 -AGENT_ROTATE_ADJ = 90 -CAMERA_HEIGHT_OFFSET = 0.75 -VISIBILITY_DISTANCE = 1.5 -HORIZON_GRANULARITY = 30 - -RENDER_IMAGE = True -RENDER_DEPTH_IMAGE = True -RENDER_CLASS_IMAGE = True -RENDER_OBJECT_IMAGE = True - -MAX_DEPTH = 5000 -STEPS_AHEAD = 5 -SCENE_PADDING = STEPS_AHEAD * 3 -SCREEN_WIDTH = DETECTION_SCREEN_WIDTH = 300 -SCREEN_HEIGHT = DETECTION_SCREEN_HEIGHT = 300 -MIN_VISIBLE_PIXELS = 10 - -# (400) / (600*600) ~ 0.13% area of image -# int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float(DETECTION_SCREEN_HEIGHT)) -# MIN_VISIBLE_PIXELS = int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float( -# DETECTION_SCREEN_HEIGHT)) # (400) / (600*600) ~ 0.13% area of image - -######################################################################################################################## -# Scenes and Objects - -TRAIN_SCENE_NUMBERS = list(range(7, 31)) # Train Kitchens (24/30) -TRAIN_SCENE_NUMBERS.extend(list(range(207, 231))) # Train Living Rooms (24/30) -TRAIN_SCENE_NUMBERS.extend(list(range(307, 331))) # Train Bedrooms (24/30) -TRAIN_SCENE_NUMBERS.extend(list(range(407, 431))) # Train Bathrooms (24/30) - -TEST_SCENE_NUMBERS = list(range(1, 7)) # Test Kitchens (6/30) -TEST_SCENE_NUMBERS.extend(list(range(201, 207))) # Test Living Rooms (6/30) -TEST_SCENE_NUMBERS.extend(list(range(301, 307))) # Test Bedrooms (6/30) -TEST_SCENE_NUMBERS.extend(list(range(401, 407))) # Test Bathrooms (6/30) - -SCENE_NUMBERS = TRAIN_SCENE_NUMBERS + TEST_SCENE_NUMBERS - -# Scene types. -SCENE_TYPE = {"Kitchen": range(1, 31), - "LivingRoom": range(201, 231), - "Bedroom": range(301, 331), - "Bathroom": range(401, 431)} - -OBJECTS = [ - 'AlarmClock', - 'Apple', - 'ArmChair', - 'BaseballBat', - 'BasketBall', - 'Bathtub', - 'BathtubBasin', - 'Bed', - 'Blinds', - 'Book', - 'Boots', - 'Bowl', - 'Box', - 'Bread', - 'ButterKnife', - 'Cabinet', - 'Candle', - 'Cart', - 'CD', - 'CellPhone', - 'Chair', - 'Cloth', - 'CoffeeMachine', - 'CounterTop', - 'CreditCard', - 'Cup', - 'Curtains', - 'Desk', - 'DeskLamp', - 'DishSponge', - 'Drawer', - 'Dresser', - 'Egg', - 'FloorLamp', - 'Footstool', - 'Fork', - 'Fridge', - 'GarbageCan', - 'Glassbottle', - 'HandTowel', - 'HandTowelHolder', - 'HousePlant', - 'Kettle', - 'KeyChain', - 'Knife', - 'Ladle', - 'Laptop', - 'LaundryHamper', - 'LaundryHamperLid', - 'Lettuce', - 'LightSwitch', - 'Microwave', - 'Mirror', - 'Mug', - 'Newspaper', - 'Ottoman', - 'Painting', - 'Pan', - 'PaperTowel', - 'PaperTowelRoll', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Pillow', - 'Plate', - 'Plunger', - 'Poster', - 'Pot', - 'Potato', - 'RemoteControl', - 'Safe', - 'SaltShaker', - 'ScrubBrush', - 'Shelf', - 'ShowerDoor', - 'ShowerGlass', - 'Sink', - 'SinkBasin', - 'SoapBar', - 'SoapBottle', - 'Sofa', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'Statue', - 'StoveBurner', - 'StoveKnob', - 'DiningTable', - 'CoffeeTable', - 'SideTable', - 'TeddyBear', - 'Television', - 'TennisRacket', - 'TissueBox', - 'Toaster', - 'Toilet', - 'ToiletPaper', - 'ToiletPaperHanger', - 'ToiletPaperRoll', - 'Tomato', - 'Towel', - 'TowelHolder', - 'TVStand', - 'Vase', - 'Watch', - 'WateringCan', - 'Window', - 'WineBottle', -] - -OBJECTS_LOWER_TO_UPPER = {obj.lower(): obj for obj in OBJECTS} - -OBJECTS_SINGULAR = [ - 'alarmclock', - 'apple', - 'armchair', - 'baseballbat', - 'basketball', - 'bathtub', - 'bathtubbasin', - 'bed', - 'blinds', - 'book', - 'boots', - 'bowl', - 'box', - 'bread', - 'butterknife', - 'cabinet', - 'candle', - 'cart', - 'cd', - 'cellphone', - 'chair', - 'cloth', - 'coffeemachine', - 'countertop', - 'creditcard', - 'cup', - 'curtains', - 'desk', - 'desklamp', - 'dishsponge', - 'drawer', - 'dresser', - 'egg', - 'floorlamp', - 'footstool', - 'fork', - 'fridge', - 'garbagecan', - 'glassbottle', - 'handtowel', - 'handtowelholder', - 'houseplant', - 'kettle', - 'keychain', - 'knife', - 'ladle', - 'laptop', - 'laundryhamper', - 'laundryhamperlid', - 'lettuce', - 'lightswitch', - 'microwave', - 'mirror', - 'mug', - 'newspaper', - 'ottoman', - 'painting', - 'pan', - 'papertowel', - 'papertowelroll', - 'pen', - 'pencil', - 'peppershaker', - 'pillow', - 'plate', - 'plunger', - 'poster', - 'pot', - 'potato', - 'remotecontrol', - 'safe', - 'saltshaker', - 'scrubbrush', - 'shelf', - 'showerdoor', - 'showerglass', - 'sink', - 'sinkbasin', - 'soapbar', - 'soapbottle', - 'sofa', - 'spatula', - 'spoon', - 'spraybottle', - 'statue', - 'stoveburner', - 'stoveknob', - 'diningtable', - 'coffeetable', - 'sidetable' - 'teddybear', - 'television', - 'tennisracket', - 'tissuebox', - 'toaster', - 'toilet', - 'toiletpaper', - 'toiletpaperhanger', - 'toiletpaperroll', - 'tomato', - 'towel', - 'towelholder', - 'tvstand', - 'vase', - 'watch', - 'wateringcan', - 'window', - 'winebottle', -] - -OBJECTS_PLURAL = [ - 'alarmclocks', - 'apples', - 'armchairs', - 'baseballbats', - 'basketballs', - 'bathtubs', - 'bathtubbasins', - 'beds', - 'blinds', - 'books', - 'boots', - 'bottles', - 'bowls', - 'boxes', - 'bread', - 'butterknives', - 'cabinets', - 'candles', - 'carts', - 'cds', - 'cellphones', - 'chairs', - 'cloths', - 'coffeemachines', - 'countertops', - 'creditcards', - 'cups', - 'curtains', - 'desks', - 'desklamps', - 'dishsponges', - 'drawers', - 'dressers', - 'eggs', - 'floorlamps', - 'footstools', - 'forks', - 'fridges', - 'garbagecans', - 'glassbottles', - 'handtowels', - 'handtowelholders', - 'houseplants', - 'kettles', - 'keychains', - 'knives', - 'ladles', - 'laptops', - 'laundryhampers', - 'laundryhamperlids', - 'lettuces', - 'lightswitches', - 'microwaves', - 'mirrors', - 'mugs', - 'newspapers', - 'ottomans', - 'paintings', - 'pans', - 'papertowels', - 'papertowelrolls', - 'pens', - 'pencils', - 'peppershakers', - 'pillows', - 'plates', - 'plungers', - 'posters', - 'pots', - 'potatoes', - 'remotecontrollers', - 'safes', - 'saltshakers', - 'scrubbrushes', - 'shelves', - 'showerdoors', - 'showerglassess', - 'sinks', - 'sinkbasins', - 'soapbars', - 'soapbottles', - 'sofas', - 'spatulas', - 'spoons', - 'spraybottles', - 'statues', - 'stoveburners', - 'stoveknobs', - 'diningtables', - 'coffeetables', - 'sidetable', - 'teddybears', - 'televisions', - 'tennisrackets', - 'tissueboxes', - 'toasters', - 'toilets', - 'toiletpapers', - 'toiletpaperhangers', - 'toiletpaperrolls', - 'tomatoes', - 'towels', - 'towelholders', - 'tvstands', - 'vases', - 'watches', - 'wateringcans', - 'windows', - 'winebottles', -] - -MOVABLE_RECEPTACLES = [ - 'Bowl', - 'Box', - 'Cup', - 'Mug', - 'Plate', - 'Pan', - 'Pot', -] - -MOVABLE_RECEPTACLES_SET = set(MOVABLE_RECEPTACLES) -OBJECTS_SET = set(OBJECTS) | MOVABLE_RECEPTACLES_SET - -OBJECT_CLASS_TO_ID = {obj: ii for (ii, obj) in enumerate(OBJECTS)} - -RECEPTACLES = { - 'BathtubBasin', - 'Bowl', - 'Cup', - 'Drawer', - 'Mug', - 'Plate', - 'Shelf', - 'SinkBasin', - 'Box', - 'Cabinet', - 'CoffeeMachine', - 'CounterTop', - 'Fridge', - 'GarbageCan', - 'HandTowelHolder', - 'Microwave', - 'PaintingHanger', - 'Pan', - 'Pot', - 'StoveBurner', - 'DiningTable', - 'CoffeeTable', - 'SideTable', - 'ToiletPaperHanger', - 'TowelHolder', - 'Safe', - 'BathtubBasin', - 'ArmChair', - 'Toilet', - 'Sofa', - 'Ottoman', - 'Dresser', - 'LaundryHamper', - 'Desk', - 'Bed', - 'Cart', - 'TVStand', - 'Toaster', - } - -NON_RECEPTACLES = OBJECTS_SET - RECEPTACLES - -NUM_RECEPTACLES = len(RECEPTACLES) -NUM_CLASSES = len(OBJECTS) - -# For generating questions -QUESTION_OBJECT_CLASS_LIST = [ - 'Spoon', - 'Potato', - 'Fork', - 'Plate', - 'Egg', - 'Tomato', - 'Bowl', - 'Lettuce', - 'Apple', - 'Knife', - 'Container', - 'Bread', - 'Mug', -] - -VAL_RECEPTACLE_OBJECTS = { - 'Pot': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced'}, - 'Pan': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced'}, - 'Bowl': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'KeyChain', - 'Mug', - 'PaperTowel', - 'Pen', - 'Pencil', - 'RemoteControl', - 'Watch'}, - 'CoffeeMachine': {'Mug'}, - 'Microwave': {'Apple', - 'AppleSliced', - 'Bowl', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Glassbottle', - 'Mug', - 'Plate', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced'}, - 'StoveBurner': {'Kettle', - 'Pan', - 'Pot'}, - 'Fridge': {'Apple', - 'AppleSliced', - 'Bowl', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Glassbottle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced', - 'WineBottle'}, - 'Mug': {'ButterKnife', - 'Fork', - 'Knife', - 'Pen', - 'Pencil', - 'Spoon', - 'KeyChain', - 'Watch'}, - 'Plate': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced', - 'AlarmClock', - 'Book', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'Glassbottle', - 'KeyChain', - 'Mug', - 'PaperTowel', - 'Pen', - 'Pencil', - 'TissueBox', - 'Watch'}, - 'Cup': {'ButterKnife', - 'Fork', - 'Spoon'}, - 'Sofa': {'BasketBall', - 'Book', - 'Box', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'KeyChain', - 'Laptop', - 'Newspaper', - 'Pillow', - 'RemoteControl'}, - 'ArmChair': {'BasketBall', - 'Book', - 'Box', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'KeyChain', - 'Laptop', - 'Newspaper', - 'Pillow', - 'RemoteControl'}, - 'Box': {'AlarmClock', - 'Book', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'Glassbottle', - 'KeyChain', - 'Mug', - 'PaperTowel', - 'Pen', - 'Pencil', - 'RemoteControl', - 'Statue', - 'TissueBox', - 'Vase', - 'Watch'}, - 'Ottoman': {'BasketBall', - 'Book', - 'Box', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'KeyChain', - 'Laptop', - 'Newspaper', - 'Pillow', - 'RemoteControl'}, - 'Dresser': {'AlarmClock', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'Glassbottle', - 'KeyChain', - 'Laptop', - 'Mug', - 'Newspaper', - 'Pen', - 'Pencil', - 'Plate', - 'RemoteControl', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle'}, - 'LaundryHamper': {'Cloth'}, - 'Desk': {'AlarmClock', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'Glassbottle', - 'KeyChain', - 'Laptop', - 'Mug', - 'Newspaper', - 'Pen', - 'Pencil', - 'Plate', - 'RemoteControl', - 'SoapBottle', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle'}, - 'Bed': {'BaseballBat', - 'BasketBall', - 'Book', - 'CellPhone', - 'Laptop', - 'Newspaper', - 'Pillow', - 'TennisRacket'}, - 'Toilet': {'Candle', - 'Cloth', - 'DishSponge', - 'Newspaper', - 'PaperTowel', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'HandTowel'}, - 'ToiletPaperHanger': {'ToiletPaper', - 'ToiletPaperRoll'}, - 'TowelHolder': {'Towel'}, - 'HandTowelHolder': {'HandTowel'}, - 'Cart': {'Candle', - 'Cloth', - 'DishSponge', - 'Mug', - 'PaperTowel', - 'Plunger', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'Statue', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'HandTowel'}, - 'BathtubBasin': {'Cloth', - 'DishSponge', - 'SoapBar', - 'HandTowel'}, - 'SinkBasin': {'Apple', - 'AppleSliced', - 'Bowl', - 'ButterKnife', - 'Cloth', - 'Cup', - 'DishSponge', - 'Egg', - 'Glassbottle', - 'Fork', - 'Kettle', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'SoapBar', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced', - 'HandTowel'}, - 'Cabinet': {'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'Cloth', - 'Cup', - 'DishSponge', - 'Glassbottle', - 'Kettle', - 'Ladle', - 'Mug', - 'Newspaper', - 'Pan', - 'PepperShaker', - 'Plate', - 'Plunger', - 'Pot', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'TableTop': {'AlarmClock', - 'Apple', - 'AppleSliced', - 'BaseballBat', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Bread', - 'BreadSliced', - 'ButterKnife', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'DishSponge', - 'Glassbottle', - 'Egg', - 'Fork', - 'Kettle', - 'KeyChain', - 'Knife', - 'Ladle', - 'Laptop', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Newspaper', - 'Pan', - 'PaperTowel', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Tomato', - 'TomatoSliced', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'CounterTop': {'AlarmClock', - 'Apple', - 'AppleSliced', - 'BaseballBat', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Bread', - 'BreadSliced', - 'ButterKnife', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'DishSponge', - 'Egg', - 'Glassbottle', - 'Fork', - 'Kettle', - 'KeyChain', - 'Knife', - 'Ladle', - 'Laptop', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Newspaper', - 'Pan', - 'PaperTowel', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Tomato', - 'TomatoSliced', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'Shelf': {'AlarmClock', - 'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'DishSponge', - 'Glassbottle', - 'Kettle', - 'KeyChain', - 'Mug', - 'Newspaper', - 'PaperTowel', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Plate', - 'Pot', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'Statue', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'Drawer': {'Book', - 'ButterKnife', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'Fork', - 'KeyChain', - 'Knife', - 'Ladle', - 'Newspaper', - 'Pen', - 'Pencil', - 'PepperShaker', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Watch', - 'WateringCan', - 'HandTowel'}, - 'GarbageCan': {'Apple', - 'AppleSliced', - 'Bread', - 'BreadSliced', - 'CD', - 'Cloth', - 'DishSponge', - 'Egg', - 'Lettuce', - 'LettuceSliced', - 'Newspaper', - 'PaperTowel', - 'Pen', - 'Pencil', - 'Potato', - 'PotatoSliced', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Tomato', - 'TomatoSliced', - 'WineBottle', - 'HandTowel'}, - 'Safe': {'CD', - 'CellPhone', - 'CreditCard', - 'KeyChain', - 'Statue', - 'Vase', - 'Watch'}, - 'TVStand': {'TissueBox'}, - 'Toaster': {'BreadSliced'}, -} -VAL_RECEPTACLE_OBJECTS['DiningTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] -VAL_RECEPTACLE_OBJECTS['CoffeeTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] -VAL_RECEPTACLE_OBJECTS['SideTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] -del VAL_RECEPTACLE_OBJECTS['TableTop'] - -NON_RECEPTACLES_SET = (OBJECTS_SET - set(VAL_RECEPTACLE_OBJECTS.keys())) | set(MOVABLE_RECEPTACLES) - -VAL_ACTION_OBJECTS = { - 'Heatable': {'Apple', - 'AppleSliced', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Mug', - 'Plate', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced'}, - 'Coolable': {'Apple', - 'AppleSliced', - 'Bowl', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced', - 'WineBottle'}, - 'Cleanable': {'Apple', - 'AppleSliced', - 'Bowl', - 'ButterKnife', - 'Cloth', - 'Cup', - 'DishSponge', - 'Egg', - 'Fork', - 'Kettle', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'SoapBar', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced'}, - 'Toggleable': {'DeskLamp', - 'FloorLamp'}, - 'Sliceable': {'Apple', - 'Bread', - 'Egg', - 'Lettuce', - 'Potato', - 'Tomato'} -} - -# object parents -OBJ_PARENTS = {obj: obj for obj in OBJECTS} -OBJ_PARENTS['AppleSliced'] = 'Apple' -OBJ_PARENTS['BreadSliced'] = 'Bread' -OBJ_PARENTS['LettuceSliced'] = 'Lettuce' -OBJ_PARENTS['PotatoSliced'] = 'Potato' -OBJ_PARENTS['TomatoSliced'] = 'Tomato' - -# force a different horizon view for objects of (type, location). If the location is None, force this horizon for all -# objects of that type. -FORCED_HORIZON_OBJS = { - ('FloorLamp', None): 0, - ('Fridge', 18): 30, - ('Toilet', None): 15, -} - -# openable objects with fixed states for transport. -FORCED_OPEN_STATE_ON_PICKUP = { - 'Laptop': False, -} - -# list of openable classes. -OPENABLE_CLASS_LIST = ['Fridge', 'Cabinet', 'Microwave', 'Drawer', 'Safe', 'Box'] -OPENABLE_CLASS_SET = set(OPENABLE_CLASS_LIST) - -######################################################################################################################## \ No newline at end of file diff --git a/models/main_models/rt1/gen/ff_planner/README.md b/models/main_models/rt1/gen/ff_planner/README.md deleted file mode 100644 index 81bc18c0f..000000000 --- a/models/main_models/rt1/gen/ff_planner/README.md +++ /dev/null @@ -1,13 +0,0 @@ -# Metric FF Planner -Credit: https://fai.cs.uni-saarland.de/hoffmann/metric-ff.html. -Specifically this uses the Metric-FF Version 2.1 (https://fai.cs.uni-saarland.de/hoffmann/ff/Metric-FF-v2.1.tgz). - -Note that the code here is not exactly the same as the one you can download from that website. -Their code had issues that threw segfaults which I was able to fix for this project. -It is possible that my changes caused some other issues that I am unaware of. - -To compile: -```bash -$ cd -$ make -``` diff --git a/models/main_models/rt1/gen/ff_planner/expressions.c b/models/main_models/rt1/gen/ff_planner/expressions.c deleted file mode 100644 index 8fb8d2404..000000000 --- a/models/main_models/rt1/gen/ff_planner/expressions.c +++ /dev/null @@ -1,2623 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/*********************************************************************** - * File: expressions.c - * Description: functions for handling numerical expressions - * - * - general utilities: - * comparisons between numbers etc. - * - * - LNF compilation: - * normalization of expressions - * translation of subtractions - * - * - LNF post-processing: - * summarization of effects - * encoding of non-minimal LNFs - * - * Author: Joerg Hoffmann 2001 - * - *********************************************************************/ - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - - - - - - - - - - - - - - - -/******************************************************* - * SIMPLE UTILITIES - *******************************************************/ - - - - - - - - - - - - - - - - -Bool number_comparison_holds( Comparator c, float l, float r ) - -{ - - switch ( c ) { - case LE: - if ( l < r ) return TRUE; - break; - case LEQ: - if ( l <= r ) return TRUE; - break; - case EQ: - if ( l == r ) return TRUE; - break; - case GEQ: - if ( l >= r ) return TRUE; - break; - case GE: - if ( l > r ) return TRUE; - break; - case IGUAL: - /* technical for non-required fluents - */ - return TRUE; - default: - printf("\n\nillegal comparator %d in number comp holds", c); - exit( 1 ); - } - - return FALSE; - -} - - - - - - - - - - - - - - - - - - - - - -/******************************************************* - * MACHINERY FOR LNF TRANSFORMATION!!!!!! - *******************************************************/ - - - - - - - - - - - - - - - - - - - - - - - - -Bool transform_to_LNF( void ) - -{ - - if ( !is_linear_task() ) { - return FALSE; - } - - normalize_expressions(); - if ( gcmd_line.display_info == 121 ) { - printf("\n\nnormalized expressions representation is:\n\n"); - print_lnf_representation(); - } - - translate_subtractions(); - if ( gcmd_line.display_info == 122 ) { - printf("\n\nLNF : translated subtractions representation is:\n\n"); - print_lnf_representation(); - } - - /* LNF computed. start post-processing. - */ - - /* do same-cond effects etc. summarization here so as to have - * as tight as possible an encoded LNF representation. - */ - summarize_effects(); - if ( gcmd_line.display_info == 123 ) { - printf("\n\nLNF - summarized effects representation is:\n\n"); - print_lnf_representation(); - } - - encode_lfns_as_artificial_fluents(); - /* optimization is translated into minimizing - * effect costs... here, determine the cost that - * each effect has. - * - * returns TRUE if a non-trivial optimization expression - * could be established. - */ - if ( setup_effect_costs() ) { - if ( gcmd_line.display_info > 1 ) { - printf("\nmetric established (normalized to minimize): "); - print_LnfExpNode( &glnf_metric ); - } - goptimization_established = TRUE; - } - if ( gcmd_line.display_info == 124 ) { - printf("\n\nencoded LNF representation is:\n\n"); - print_lnf_representation(); - } - - return TRUE; - -} - - - -/* simple syntax check - */ -Bool is_linear_task( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j; - - for ( a = gactions; a; a = a->next ) { - /* preconds - */ - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - if ( !is_linear_expression( a->numeric_preconds_lh[i] ) ) { - return FALSE; - } - if ( !is_linear_expression( a->numeric_preconds_rh[i] ) ) { - return FALSE; - } - } - - /* effects - */ - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - for ( j = 0; j < e->num_numeric_conditions; j++ ) { - if ( !is_linear_expression( e->numeric_conditions_lh[j] ) ) { - return FALSE; - } - if ( !is_linear_expression( e->numeric_conditions_rh[j] ) ) { - return FALSE; - } - } - - if ( e->illegal ) { - /* we don't care whether that one's ok or not- - * it won't be applied anyway. - */ - continue; - } - - for ( j = 0; j < e->num_numeric_effects; j++ ) { - if ( e->numeric_effects_neft[j] != INCREASE && - e->numeric_effects_neft[j] != DECREASE && - e->numeric_effects_neft[j] != ASSIGN ) { - return FALSE; - } - if ( !is_linear_expression( e->numeric_effects_rh[j] ) ) { - return FALSE; - } - } - } - } - - /* goal condition also... - */ - for ( i = 0; i < gnum_numeric_goal; i++ ) { - if ( !is_linear_expression( gnumeric_goal_lh[i] ) ) { - return FALSE; - } - if ( !is_linear_expression( gnumeric_goal_rh[i] ) ) { - return FALSE; - } - } - - if ( gmetric != NULL ) { - if ( !is_linear_expression( gmetric ) ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: metric is no linear expression. defaulting to plan length."); - } - free_ExpNode( gmetric ); - gmetric = NULL; - } - } - - return TRUE; - -} - - - -Bool is_linear_expression( ExpNode *n ) - -{ - - switch ( n->connective ) { - case MU: - if ( !is_linear_expression( n->leftson ) || - !is_linear_expression( n->rightson ) ) { - return FALSE; - } - if ( n->leftson->connective != NUMBER && - n->rightson->connective != NUMBER ) { - return FALSE; - } - break; - case DI: - if ( !is_linear_expression( n->leftson ) || - n->rightson->connective != NUMBER ) { - return FALSE; - } - break; - case AD: - case SU: - if ( !is_linear_expression( n->leftson ) || - !is_linear_expression( n->rightson ) ) { - return FALSE; - } - break; - case MINUS: - if ( !is_linear_expression( n->son ) ) { - return FALSE; - } - break; - case NUMBER: - case FHEAD: - break; - default: - printf("\n\nis linear exp: wrong specifier %d", - n->connective); - exit( 1 ); - } - - return TRUE; - -} - - - -void print_lnf_representation( void ) - -{ - - int i; - Action *a; - - for ( i = 0; i < gnum_operators; i++ ) { - printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); - for ( a = gactions; a; a = a->next ) { - if ( ( !a->norm_operator && - !a->pseudo_action ) || - ( a->norm_operator && - a->norm_operator->operator != goperators[i] ) || - ( a->pseudo_action && - a->pseudo_action->operator != goperators[i] ) ) { - continue; - } - print_lnf_Action( a ); - } - } - printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); - for ( a = gactions; a; a = a->next ) { - if ( !a->norm_operator && - !a->pseudo_action ) { - print_lnf_Action( a ); - } - } - - printf("\n\ninitial state is:\n\n"); - print_State( ginitial_state ); - - printf("\n\ngoal is:\n\n"); - for ( i = 0; i < gnum_logic_goal; i++ ) { - print_ft_name( glogic_goal[i] ); - printf("\n"); - } - for ( i = 0; i < gnum_lnf_goal; i++ ) { - switch ( glnf_goal_comp[i] ) { - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator in lnf goal %d\n\n", glnf_goal_comp[i]); - exit( 1 ); - } - print_LnfExpNode( glnf_goal_lh[i] ); - printf(" %f", glnf_goal_rh[i]); - printf(")\n"); - } - - if ( gmetric ) { - printf("\n\nmetric is (minimize) (constant part skipped):\n"); - print_LnfExpNode( &glnf_metric ); - } else { - printf("\n\nmetric: none, i.e. plan length\n"); - } - -} - - - - - - - - - - - - - - - - - - -/******************************************************* - * SUBPART I: NORMALIZE THE EXPRESSIONS - *******************************************************/ - - - - - - - - - - - - - - - - - -/* local globals. - */ - -Comparator lcomp; - -int lF[MAX_LNF_F]; -float lC[MAX_LNF_F]; -int lnum_F; - -float lc; - - - - - - - - - - - -void normalize_expressions( void ) - -{ - - Action *a, *p, *t; - ActionEffect *e; - int i, j, k; - Bool eq; - LnfExpNode *lnf; - - /* first, pre-normalize all the expressions, i.e. translate - * divisions, and push muliplications downwards. - */ - for ( i = 0; i < gnum_numeric_goal; i++ ) { - if ( !translate_divisions( &(gnumeric_goal_lh[i]) ) ) { - printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); - exit( 1 ); - } - push_multiplications_down( &(gnumeric_goal_lh[i]) ); - if ( !translate_divisions( &(gnumeric_goal_rh[i]) ) ) { - printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); - exit( 1 ); - } - push_multiplications_down( &(gnumeric_goal_rh[i]) ); - } - - a = gactions; p = NULL; - while ( a ) { - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - if ( !translate_divisions( &(a->numeric_preconds_lh[i]) ) ) break; - push_multiplications_down( &(a->numeric_preconds_lh[i]) ); - if ( !translate_divisions( &(a->numeric_preconds_rh[i]) ) ) break; - push_multiplications_down( &(a->numeric_preconds_rh[i]) ); - } - if ( i < a->num_numeric_preconds ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in precond of "); - print_Action_name( a ); - printf(". skipping action."); - } - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - for ( j = 0; j < e->num_numeric_conditions; j++ ) { - if ( !translate_divisions( &(e->numeric_conditions_lh[j]) ) ) break; - push_multiplications_down( &(e->numeric_conditions_lh[j]) ); - if ( !translate_divisions( &(e->numeric_conditions_rh[j]) ) ) break; - push_multiplications_down( &(e->numeric_conditions_rh[j]) ); - } - if ( j < e->num_numeric_conditions ) break; - - if ( e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_numeric_effects; j++ ) { - if ( !translate_divisions( &(e->numeric_effects_rh[j]) ) ) break; - push_multiplications_down( &(e->numeric_effects_rh[j]) ); - } - if ( j < e->num_numeric_effects ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in effect rh of "); - print_Action_name( a ); - printf(". marking effect as illegal."); - } - e->illegal = TRUE; - } - } - if ( i < a->num_effects ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in effect cond of "); - print_Action_name( a ); - printf(". skipping action."); - } - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - - p = a; - a = a->next; - } - if ( gmetric != NULL ) { - if ( !translate_divisions( &gmetric ) ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in metric. replaced with plan length."); - } - free_ExpNode( gmetric ); - gmetric = NULL; - } - push_multiplications_down( &gmetric ); - } - - /* now, collect the normalized representations of all expressions. - */ - for ( a = gactions; a; a = a->next ) { - /* preconds - */ - a->lnf_preconds_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); - a->lnf_preconds_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); - a->lnf_preconds_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); - a->num_lnf_preconds = 0; - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - eq = FALSE; - if ( a->numeric_preconds_comp[i] == EQ ) { - eq = TRUE; - a->numeric_preconds_comp[i] = LEQ; - } - put_comp_into_normalized_locals( a->numeric_preconds_comp[i], - a->numeric_preconds_lh[i], - a->numeric_preconds_rh[i] ); - a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; - a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); - lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - a->lnf_preconds_rh[a->num_lnf_preconds] = lc; - a->num_lnf_preconds++; - if ( eq ) { - if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - a->numeric_preconds_comp[i] = EQ; - put_comp_into_normalized_locals( GEQ, - a->numeric_preconds_lh[i], - a->numeric_preconds_rh[i] ); - a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; - a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); - lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - a->lnf_preconds_rh[a->num_lnf_preconds] = lc; - a->num_lnf_preconds++; - } - } - - /* effects - */ - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - e->lnf_conditions_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); - e->lnf_conditions_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); - e->lnf_conditions_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); - e->num_lnf_conditions = 0; - for ( j = 0; j < e->num_numeric_conditions; j++ ) { - if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - eq = FALSE; - if ( e->numeric_conditions_comp[j] == EQ ) { - eq = TRUE; - e->numeric_conditions_comp[j] = LEQ; - } - put_comp_into_normalized_locals( e->numeric_conditions_comp[j], - e->numeric_conditions_lh[j], - e->numeric_conditions_rh[j] ); - e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; - e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); - lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; - for ( k = 0; k < lnum_F; k++ ) { - if ( lC[k] == 0 ) continue; - if ( lC[k] > 0 ) { - lnf->pF[lnf->num_pF] = lF[k]; - lnf->pC[lnf->num_pF++] = lC[k]; - } else { - lnf->nF[lnf->num_nF] = lF[k]; - lnf->nC[lnf->num_nF++] = (-1) * lC[k]; - } - } - e->lnf_conditions_rh[e->num_lnf_conditions] = lc; - e->num_lnf_conditions++; - if ( eq ) { - if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - e->numeric_conditions_comp[j] = EQ; - put_comp_into_normalized_locals( GEQ, - e->numeric_conditions_lh[j], - e->numeric_conditions_rh[j] ); - e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; - e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); - lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; - for ( k = 0; k < lnum_F; k++ ) { - if ( lC[k] == 0 ) continue; - if ( lC[k] > 0 ) { - lnf->pF[lnf->num_pF] = lF[k]; - lnf->pC[lnf->num_pF++] = lC[k]; - } else { - lnf->nF[lnf->num_nF] = lF[k]; - lnf->nC[lnf->num_nF++] = (-1) * lC[k]; - } - } - e->lnf_conditions_rh[e->num_lnf_conditions] = lc; - e->num_lnf_conditions++; - } - } - - if ( e->illegal ) { - /* we do have the LNF to know whether the effect appears. - * if it does, then this one is illegal anyway, remembered - * in inst final due to undefined fl access. - * - * if it is LEGAL, then all fluents we're gonna find and - * collect below are relevant!!! - */ - continue; - } - - e->lnf_effects_neft = ( NumericEffectType * ) calloc( MAX_LNF_EFFS, sizeof( NumericEffectType ) ); - e->lnf_effects_fl = ( int * ) calloc( MAX_LNF_EFFS, sizeof( int ) ); - e->lnf_effects_rh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_EFFS, sizeof( LnfExpNode_pointer ) ); - e->num_lnf_effects = 0; - for ( j = 0; j < e->num_numeric_effects; j++ ) { - if ( e->num_lnf_effects == MAX_LNF_EFFS ) { - printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); - exit( 1 ); - } - e->lnf_effects_neft[e->num_lnf_effects] = e->numeric_effects_neft[j]; - e->lnf_effects_fl[e->num_lnf_effects] = e->numeric_effects_fl[j]; - lnum_F = 0; - lc = 0; - if ( e->lnf_effects_neft[e->num_lnf_effects] == DECREASE ) { - collect_normalized_locals( e->numeric_effects_rh[j], FALSE ); - e->lnf_effects_neft[e->num_lnf_effects] = INCREASE; - } else { - collect_normalized_locals( e->numeric_effects_rh[j], TRUE ); - } - e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); - lnf = e->lnf_effects_rh[e->num_lnf_effects]; - for ( k = 0; k < lnum_F; k++ ) { - if ( lC[k] == 0 ) continue; - if ( lC[k] > 0 ) { - lnf->pF[lnf->num_pF] = lF[k]; - lnf->pC[lnf->num_pF++] = lC[k]; - } else { - lnf->nF[lnf->num_nF] = lF[k]; - lnf->nC[lnf->num_nF++] = (-1) * lC[k]; - } - } - e->lnf_effects_rh[e->num_lnf_effects]->c = lc; - e->num_lnf_effects++; - } - } - } - - /* goal condition also... - */ - glnf_goal_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); - glnf_goal_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); - glnf_goal_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); - gnum_lnf_goal = 0; - for ( i = 0; i < gnum_numeric_goal; i++ ) { - if ( gnum_lnf_goal == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - eq = FALSE; - if ( gnumeric_goal_comp[i] == EQ ) { - eq = TRUE; - gnumeric_goal_comp[i] = LEQ; - } - put_comp_into_normalized_locals( gnumeric_goal_comp[i], - gnumeric_goal_lh[i], - gnumeric_goal_rh[i] ); - glnf_goal_comp[gnum_lnf_goal] = lcomp; - glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); - lnf = glnf_goal_lh[gnum_lnf_goal]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - glnf_goal_rh[gnum_lnf_goal] = lc; - gnum_lnf_goal++; - if ( eq ) { - if ( gnum_lnf_goal == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - gnumeric_goal_comp[i] = EQ; - put_comp_into_normalized_locals( GEQ, - gnumeric_goal_lh[i], - gnumeric_goal_rh[i] ); - glnf_goal_comp[gnum_lnf_goal] = lcomp; - glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); - lnf = glnf_goal_lh[gnum_lnf_goal]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - glnf_goal_rh[gnum_lnf_goal] = lc; - gnum_lnf_goal++; - } - } - /* metric... - */ - lnum_F = 0; - lc = 0; - glnf_metric.num_pF = 0; - glnf_metric.num_nF = 0; - glnf_metric.c = 0; - collect_normalized_locals( gmetric, TRUE ); - lnf = &glnf_metric; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - - -} - - - -Bool translate_divisions( ExpNode **n ) - -{ - - ExpNode *tmp; - - /* "dirty": also normalize multiplications so that the constant - * is always on the left hand side --- - * simplifies function below a lot. - */ - switch ( (*n)->connective ) { - case DI: - /* rightson is number due to syntax check. - */ - if ( (*n)->rightson->value == 0 ) { - /* what needs to be done we can only decide further up. - */ - printf("\nwarning: division by zero."); - return FALSE; - } - if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; - (*n)->connective = MU; - (*n)->rightson->value = 1 / (*n)->rightson->value; - tmp = (*n)->rightson; - (*n)->rightson = (*n)->leftson; - (*n)->leftson = tmp; - break; - case MU: - if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; - if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->rightson->connective == NUMBER ) { - tmp = (*n)->rightson; - (*n)->rightson = (*n)->leftson; - (*n)->leftson = tmp; - } - break; - case AD: - case SU: - if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; - if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; - break; - case MINUS: - if ( !translate_divisions( &((*n)->son) ) ) return FALSE; - break; - case NUMBER: - case FHEAD: - break; - default: - printf("\n\ntranslate divisions: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - - return TRUE; - -} - - - -void push_multiplications_down( ExpNode **n ) - -{ - - ExpNode *tmp1, *tmp2; - - switch ( (*n)->connective ) { - case MU: - /* due to syntax check, at least one of sons is number, - * - * due to above, it's the left one. - * NOTE that this invariant is kept true troughout the - * modifications done here. - */ - if ( (*n)->rightson->connective == NUMBER ) { - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - free_ExpNode( (*n)->rightson ); - (*n)->leftson = NULL; - (*n)->rightson = NULL; - break; - } - if ( (*n)->rightson->connective == FHEAD ) { - (*n)->connective = FHEAD; - (*n)->fl = (*n)->rightson->fl; - (*n)->c = (*n)->leftson->value; - free_ExpNode( (*n)->leftson ); - free_ExpNode( (*n)->rightson ); - (*n)->leftson = NULL; - (*n)->rightson = NULL; - break; - } - if ( (*n)->rightson->connective == MINUS ) { - (*n)->connective = MINUS; - (*n)->son = (*n)->rightson; - (*n)->son->connective = MU; - (*n)->son->leftson = (*n)->leftson; - (*n)->son->rightson = (*n)->rightson->son; - (*n)->rightson = NULL; - (*n)->leftson = NULL; - (*n)->son->son = NULL; - push_multiplications_down( &((*n)->son) ); - break; - } - if ( (*n)->rightson->connective == MU ) { - (*n)->leftson->value *= (*n)->rightson->leftson->value; - tmp1 = (*n)->rightson->rightson; - (*n)->rightson->rightson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = tmp1; - push_multiplications_down( n ); - break; - } - - /* rigthson is either AD or SU - */ - tmp1 = new_ExpNode( NUMBER ); - tmp2 = new_ExpNode( NUMBER ); - tmp1->value = (*n)->leftson->value; - tmp2->value = (*n)->leftson->value; - - (*n)->connective = (*n)->rightson->connective; - (*n)->leftson->connective = MU; - (*n)->rightson->connective = MU; - (*n)->leftson->leftson = tmp1; - (*n)->leftson->rightson = (*n)->rightson->leftson; - (*n)->rightson->leftson = tmp2; - - push_multiplications_down( &((*n)->leftson) ); - push_multiplications_down( &((*n)->rightson) ); - break; - case AD: - case SU: - push_multiplications_down( &((*n)->leftson) ); - push_multiplications_down( &((*n)->rightson) ); - break; - case MINUS: - push_multiplications_down( &((*n)->son) ); - break; - case NUMBER: - case FHEAD: - break; - default: - printf("\n\ntranslate divisions: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -void put_comp_into_normalized_locals( Comparator comp, - ExpNode *lh, - ExpNode *rh ) - -{ - - ExpNode *tmp; - - tmp = new_ExpNode( SU ); - - /* initialisation of normalized locals - */ - lnum_F = 0; - lc = 0; - - lcomp = comp; - - /* if comparison is LE or LEQ, then subtract - * left hand side from right hand side to obtain - * new left hand side. - */ - if ( lcomp == LE ) { - tmp->leftson = rh; - tmp->rightson = lh; - collect_normalized_locals( tmp, TRUE ); - lcomp = GE; - /* "subtract" the constant to get it to the right hand - * side. - */ - lc *= (-1); - free( tmp ); - return; - } - if ( lcomp == LEQ ) { - tmp->leftson = rh; - tmp->rightson = lh; - collect_normalized_locals( tmp, TRUE ); - lcomp = GEQ; - lc *= (-1); - free( tmp ); - return; - } - - /* otherwise, subtract right hand side from left hand side. - */ - tmp->leftson = lh; - tmp->rightson = rh; - collect_normalized_locals( tmp, TRUE ); - lc *= (-1); - free( tmp ); - -} - - - -void collect_normalized_locals( ExpNode *n, Bool positive ) - -{ - - Bool negative = positive ? FALSE : TRUE; - int i; - - if ( !n ) return; - - switch ( n->connective ) { - case AD: - collect_normalized_locals( n->leftson, positive ); - collect_normalized_locals( n->rightson, positive ); - break; - case SU: - collect_normalized_locals( n->leftson, positive ); - collect_normalized_locals( n->rightson, negative ); - break; - case MINUS: - collect_normalized_locals( n->son, negative ); - break; - case NUMBER: - if ( positive ) { - lc += n->value; - } else { - lc -= n->value; - } - break; - case FHEAD: - if ( n->fl < 0 && n->fl != -2 ) { - printf("\n\ncollecting non-relevant fluent for LNF!!\n\n"); - exit( 1 ); - } - for ( i = 0; i < lnum_F; i++ ) { - if ( lF[i] == n->fl ) break; - } - if ( i < lnum_F ) { - lC[i] += positive ? n->c : ((-1) * n->c); - } else { - if ( lnum_F == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - lF[lnum_F] = n->fl; - lC[lnum_F] = positive ? n->c : ((-1) * n->c); - lnum_F++; - } - break; - default: - printf("\n\ncollect_normalized_locals: wrong specifier %d", - n->connective); - exit( 1 ); - } - -} - - - - - - - - - - - - - - - - - - - - - -/******************************************************* - * SUBPART II: TRANSLATE THE SUBTRACTIONS - *******************************************************/ - - - - - - - - - - - - - - - -/* local globals. - */ - -int lminus_fluent[MAX_RELEVANT_FLUENTS]; - - - - - - - - - - - - -void translate_subtractions( void ) - -{ - - int i, fl; - - /* minus_fluent[fl] gives the number of the fluent that - * takes on the negative value to fl, or -1 if there is - * no such fluent. - */ - for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { - lminus_fluent[i] = -1; - } - - while ( TRUE ) { - /* ex fl \in nF for pre, cond, eff or goal? - */ - if ( !ex_fl_in_nF_of_pre_cond_eff_goal( &fl ) ) { - /* no --> we are finished. - */ - break; - } - if ( fl < 0 ) { - if ( fl != -2 ) { - printf("\n\nnon-relevant fluent in non-illegal part!\n\n"); - exit( 1 ); - } else { - printf("\n\nwarning: total-time occurs negatively in metric. no optimization done.\n\n"); - glnf_metric.num_pF = 0; - glnf_metric.num_nF = 0; - continue; - } - } - /* set the new number and name, incrementing - * gnum_relevant_fluents, and setting - * minus_fluent value for both directions. - */ - introduce_minus_fluent( fl ); - /* replace all occurences in effects and conds and goals - */ - replace_fl_in_nF_with_minus_fl( fl ); - /* set the initial value of the new fluent - */ - set_minus_fl_initial( fl ); - /* adjust the effects accordingly - */ - introduce_minus_fl_effects( fl ); - } - -} - - - -Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ) - -{ - - Action *a; - ActionEffect *e; - int i, j; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - if ( glnf_goal_lh[i]->num_nF > 0 ) { - *fl = glnf_goal_lh[i]->nF[0]; - return TRUE; - } - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - if ( a->lnf_preconds_lh[i]->num_nF > 0 ) { - *fl = a->lnf_preconds_lh[i]->nF[0]; - return TRUE; - } - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( e->lnf_conditions_lh[j]->num_nF > 0 ) { - *fl = e->lnf_conditions_lh[j]->nF[0]; - return TRUE; - } - } - - if ( e->illegal ) { - /* we don't care if there's something in here that - * wants to be translated. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_rh[j]->num_nF > 0 ) { - *fl = e->lnf_effects_rh[j]->nF[0]; - return TRUE; - } - } - } - } - - /* no need to throw costs away, even if we're not explicitly asked to - * minimize them - */ - if ( (1 || gcost_minimizing) && glnf_metric.num_nF > 0 ) { - *fl = glnf_metric.nF[0]; - return TRUE; - } - - return FALSE; - -} - - - -void introduce_minus_fluent( int fl ) - -{ - - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = -1; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], "MINUS-" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], - grelevant_fluents_name[fl] ); - lminus_fluent[fl] = gnum_relevant_fluents; - lminus_fluent[gnum_relevant_fluents] = fl; - gnum_relevant_fluents++; - -} - - - -void replace_fl_in_nF_with_minus_fl( int fl ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k, l; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - for ( j = 0; j < glnf_goal_lh[i]->num_nF; j++ ) { - if ( glnf_goal_lh[i]->nF[j] == fl ) break; - } - if ( j == glnf_goal_lh[i]->num_nF ) continue; - /* now the jth fluent in subtraction is our translated one. - * - * first, put minus-fl into pF. Can't already be there - * because we have only just introduced it. - */ - if ( glnf_goal_lh[i]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - glnf_goal_lh[i]->pF[glnf_goal_lh[i]->num_pF] = lminus_fluent[fl]; - glnf_goal_lh[i]->pC[glnf_goal_lh[i]->num_pF++] = glnf_goal_lh[i]->nC[j]; - /* now remove fl from nF. - */ - for ( k = j; k < glnf_goal_lh[i]->num_nF - 1; k++ ) { - glnf_goal_lh[i]->nF[k] = glnf_goal_lh[i]->nF[k+1]; - glnf_goal_lh[i]->nC[k] = glnf_goal_lh[i]->nC[k+1]; - } - glnf_goal_lh[i]->num_nF--; - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - for ( j = 0; j < a->lnf_preconds_lh[i]->num_nF; j++ ) { - if ( a->lnf_preconds_lh[i]->nF[j] == fl ) break; - } - if ( j == a->lnf_preconds_lh[i]->num_nF ) continue; - if ( a->lnf_preconds_lh[i]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - a->lnf_preconds_lh[i]->pF[a->lnf_preconds_lh[i]->num_pF] = lminus_fluent[fl]; - a->lnf_preconds_lh[i]->pC[a->lnf_preconds_lh[i]->num_pF++] = a->lnf_preconds_lh[i]->nC[j]; - for ( k = j; k < a->lnf_preconds_lh[i]->num_nF - 1; k++ ) { - a->lnf_preconds_lh[i]->nF[k] = a->lnf_preconds_lh[i]->nF[k+1]; - a->lnf_preconds_lh[i]->nC[k] = a->lnf_preconds_lh[i]->nC[k+1]; - } - a->lnf_preconds_lh[i]->num_nF--; - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - for ( k = 0; k < e->lnf_conditions_lh[j]->num_nF; k++ ) { - if ( e->lnf_conditions_lh[j]->nF[k] == fl ) break; - } - if ( k == e->lnf_conditions_lh[j]->num_nF ) continue; - if ( e->lnf_conditions_lh[j]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - e->lnf_conditions_lh[j]->pF[e->lnf_conditions_lh[j]->num_pF] = lminus_fluent[fl]; - e->lnf_conditions_lh[j]->pC[e->lnf_conditions_lh[j]->num_pF++] = e->lnf_conditions_lh[j]->nC[k]; - for ( l = k; l < e->lnf_conditions_lh[j]->num_nF - 1; l++ ) { - e->lnf_conditions_lh[j]->nF[l] = e->lnf_conditions_lh[j]->nF[l+1]; - e->lnf_conditions_lh[j]->nC[l] = e->lnf_conditions_lh[j]->nC[l+1]; - } - e->lnf_conditions_lh[j]->num_nF--; - } - - if ( e->illegal ) { - /* like before, we don't care about effects that access - * irrelevant fluents - */ - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { - if ( e->lnf_effects_rh[j]->nF[k] == fl ) break; - } - if ( k == e->lnf_effects_rh[j]->num_nF ) continue; - if ( e->lnf_effects_rh[j]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - e->lnf_effects_rh[j]->pF[e->lnf_effects_rh[j]->num_pF] = lminus_fluent[fl]; - e->lnf_effects_rh[j]->pC[e->lnf_effects_rh[j]->num_pF++] = e->lnf_effects_rh[j]->nC[k]; - for ( l = k; l < e->lnf_effects_rh[j]->num_nF - 1; l++ ) { - e->lnf_effects_rh[j]->nF[l] = e->lnf_effects_rh[j]->nF[l+1]; - e->lnf_effects_rh[j]->nC[l] = e->lnf_effects_rh[j]->nC[l+1]; - } - e->lnf_effects_rh[j]->num_nF--; - } - } - } - - for ( j = 0; j < glnf_metric.num_nF; j++ ) { - if ( glnf_metric.nF[j] == fl ) break; - } - if ( j < glnf_metric.num_nF ) { - if ( glnf_metric.num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - glnf_metric.pF[glnf_metric.num_pF] = lminus_fluent[fl]; - glnf_metric.pC[glnf_metric.num_pF++] = glnf_metric.nC[j]; - for ( k = j; k < glnf_metric.num_nF - 1; k++ ) { - glnf_metric.nF[k] = glnf_metric.nF[k+1]; - glnf_metric.nC[k] = glnf_metric.nC[k+1]; - } - glnf_metric.num_nF--; - } - -} - - - -void set_minus_fl_initial( int fl ) - -{ - - if ( ginitial_state.f_D[fl] ) { - ginitial_state.f_D[lminus_fluent[fl]] = TRUE; - ginitial_state.f_V[lminus_fluent[fl]] = (-1) * ginitial_state.f_V[fl]; - } - -} - - - -void introduce_minus_fl_effects( int fl ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k, pf, nf; - LnfExpNode *len; - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->illegal ) { - /* no need to translate illegal effects. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_fl[j] != fl ) { - continue; - } - /* here is an effect that affects our fl. - * introduce inverse effect for minus_fl, - * making use of all minus-fl's that are already - * there. - */ - if ( e->num_lnf_effects == MAX_LNF_EFFS ) { - printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); - exit( 1 ); - } - e->lnf_effects_neft[e->num_lnf_effects] = e->lnf_effects_neft[j]; - e->lnf_effects_fl[e->num_lnf_effects] = lminus_fluent[fl]; - e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); - len = e->lnf_effects_rh[e->num_lnf_effects]; - /* now the most "difficult" part: setup the inverted pF and nF - * informations. - * - * NOTE: as fluent occurences are unique in original ef, - * so will they be in new ef. (no len contains both - * a fluent and its minus-fluent) - * --> invariant is or should be that the absolute - * fluents occur at most once in |pF| \cup |nF|. - * holds in the beginning. only thing we do is - * we exchange in that set for some fluents the - * positive with the negative version, so the - * invariant is in fact preserved. - */ - for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { - pf = e->lnf_effects_rh[j]->pF[k]; - if ( lminus_fluent[pf] == -1 ) { - /* not translated yet --> insert it into nF - */ - if ( len->num_nF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - len->nF[len->num_nF] = pf; - len->nC[len->num_nF++] = e->lnf_effects_rh[j]->pC[k]; - } else { - /* else, insert minus-pf into pF - */ - if ( len->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - len->pF[len->num_pF] = lminus_fluent[pf]; - len->pC[len->num_pF++] = e->lnf_effects_rh[j]->pC[k]; - } - } - for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { - nf = e->lnf_effects_rh[j]->nF[k]; - /* insert all of those into pF - */ - if ( len->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - len->pF[len->num_pF] = nf; - len->pC[len->num_pF++] = e->lnf_effects_rh[j]->nC[k]; - } - /* the constant must of course be inverted. - */ - len->c = (-1) * e->lnf_effects_rh[j]->c; - e->num_lnf_effects++; - } - } - } - -} - - - - - - - - - - - - - - - - - - -/************************************************************* - * LNF POST-PROCESSING I: SUMMARIZE EFFECTS. - *************************************************************/ - - - - - - - - - - - - - - - - - - - -int *lA, *lD; -int lnum_A, lnum_D; - - - - - - -void summarize_effects( void ) - -{ - - Action *a; - ActionEffect *e, *e_; - int i, j, k, l; - - lA = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); - lD = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); - - for ( a = gactions; a; a = a->next ) { - i = 0; - while ( i < a->num_effects ) { - e = &(a->effects[i]); - if ( e->removed ) { - /* this one's already handled. - */ - i++; - continue; - } - - /* first, merge the effect's own effects together. logical: - */ - lnum_A = 0; - for ( j = 0; j < e->num_adds; j++ ) { - for ( k = 0; k < lnum_A; k++ ) { - if ( lA[k] == e->adds[j] ) break; - } - if ( k < lnum_A ) continue; - lA[lnum_A++] = e->adds[j]; - } - lnum_D = 0; - for ( j = 0; j < e->num_dels; j++ ) { - for ( k = 0; k < lnum_D; k++ ) { - if ( lD[k] == e->dels[j] ) break; - } - if ( k < lnum_D ) continue; - lD[lnum_D++] = e->dels[j]; - } - /* numerical: - */ - j = 0; - while ( j < e->num_lnf_effects ) { - /* merge all effects increasing the same fluent into - * effect j, and remove them. - */ - k = j + 1; - while ( k < e->num_lnf_effects ) { - if ( e->lnf_effects_fl[k] != e->lnf_effects_fl[j] ) { - k++; - continue; - } - if ( e->lnf_effects_neft[j] == ASSIGN ) { - if ( e->lnf_effects_neft[k] != ASSIGN || - !same_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ) ) { - e->illegal = TRUE; - break; - } - } else { - if ( e->lnf_effects_neft[k] == ASSIGN ) { - e->illegal = TRUE; - break; - } - merge_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ); - } - /* we also get here if we have two identical assigns. - */ - free( e->lnf_effects_rh[k] ); - for ( l = k; l < e->num_lnf_effects - 1; l++ ) { - e->lnf_effects_neft[l] = e->lnf_effects_neft[l+1]; - e->lnf_effects_fl[l] = e->lnf_effects_fl[l+1]; - e->lnf_effects_rh[l] = e->lnf_effects_rh[l+1]; - } - e->num_lnf_effects--; - } - if ( k < e->num_lnf_effects ) { - /* illegal combination - */ - break; - } - j++; - } - - /* now merge all effects after i with same condition - * into that. - */ - j = i + 1; - while ( j < a->num_effects ) { - e_ = &(a->effects[j]); - if ( e_->removed ) { - j++; - continue; - } - - if ( !same_condition( e, e_ ) ) { - j++; - continue; - } - /* no matter what happens, we can get rid of effect e_ - */ - e_->removed = TRUE; - - /* illegality is inherited in both directions. - */ - if ( e_->illegal ) { - e->illegal = TRUE; - } - if ( e->illegal ) { - /* just for docu; it is removed anyway. - */ - e_->illegal = TRUE; - } - - if ( !e->illegal ) { - /* the combined effect appears to be legal. merge it. - */ - merge_effects( e, e_ ); - if ( e->illegal ) { - /* e might have become illegal. again, docu this. - */ - e_->illegal = TRUE; - } - } - - j++; - } - - /* now put the updated A and D info into e. - * - * have to be careful: it might be that there are - * now too many facts and we need to re-allocate - * e's capabilities. - */ - if ( lnum_A > e->num_adds ) { - free( e->adds ); - e->adds = ( int * ) calloc( lnum_A, sizeof( int ) ); - } - for ( j = 0; j < lnum_A; j++ ) { - e->adds[j] = lA[j]; - } - e->num_adds = lnum_A; - if ( lnum_D > e->num_dels ) { - free( e->dels ); - e->dels = ( int * ) calloc( lnum_D, sizeof( int ) ); - } - for ( j = 0; j < lnum_D; j++ ) { - e->dels[j] = lD[j]; - } - e->num_dels = lnum_D; - - /* increment current effects counter. - */ - i++; - } - } - -} - - - -Bool same_condition( ActionEffect *e, ActionEffect *e_ ) - -{ - - int i, j; - - if ( e->num_conditions != e_->num_conditions || - e->num_lnf_conditions != e_->num_lnf_conditions ) return FALSE; - - for ( i = 0; i < e->num_conditions; i++ ) { - for ( j = 0; j < e_->num_conditions; j++ ) { - if ( e->conditions[i] == e_->conditions[j] ) break; - } - if ( j == e_->num_conditions ) break; - } - if ( i < e->num_conditions ) return FALSE; - - for ( i = 0; i < e->num_lnf_conditions; i++ ) { - for ( j = 0; j < e_->num_lnf_conditions; j++ ) { - if ( e_->lnf_conditions_comp[j] != e->lnf_conditions_comp[i] ) continue; - if ( e_->lnf_conditions_rh[j] != e->lnf_conditions_rh[i] ) continue; - if ( !same_lnfs( e_->lnf_conditions_lh[j], e->lnf_conditions_lh[i] ) ) continue; - break; - } - if ( j == e_->num_lnf_conditions ) break; - } - if ( i < e->num_lnf_conditions ) return FALSE; - - return TRUE; - -} - - - -Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ) - -{ - - int i, j; - - if ( l->num_pF != r->num_pF || - l->c != r->c ) return FALSE; - - for ( i = 0; i < l->num_pF; i++ ) { - for ( j = 0; j < r->num_pF; j++ ) { - if ( l->pF[i] != r->pF[j] ) continue; - if ( l->pC[i] != r->pC[j] ) { - /* same fluent with different weighting. - */ - return FALSE; - } - break; - } - if ( j == r->num_pF ) break; - } - if ( i < l->num_pF ) return FALSE; - - return TRUE; - -} - - - -void merge_effects( ActionEffect *e, ActionEffect *e_ ) - -{ - - int i, j; - - /* we don't care whether adds and dels intersect: - * they're allowed to by semantics. - */ - for ( i = 0; i < e_->num_adds; i++ ) { - for ( j = 0; j < lnum_A; j++ ) { - if ( lA[j] == e_->adds[i] ) break; - } - if ( j < lnum_A ) continue; - lA[lnum_A++] = e_->adds[i]; - } - for ( i = 0; i < e_->num_dels; i++ ) { - for ( j = 0; j < lnum_D; j++ ) { - if ( lD[j] == e_->dels[i] ) break; - } - if ( j < lnum_D ) continue; - lD[lnum_D++] = e_->dels[i]; - } - - for ( i = 0; i < e_->num_lnf_effects; i++ ) { - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_fl[j] == e_->lnf_effects_fl[i] ) break; - } - if ( j == e->num_lnf_effects ) { - /* new affected fluent! - */ - if ( e->num_lnf_effects == MAX_LNF_EFFS ) { - printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); - exit( 1 ); - } - e->lnf_effects_neft[e->num_lnf_effects] = e_->lnf_effects_neft[i]; - e->lnf_effects_fl[e->num_lnf_effects] = e_->lnf_effects_fl[i]; - /* we can also simply take the pointer: e_ is only marked as removed, - * but not freed. - */ - e->lnf_effects_rh[e->num_lnf_effects] = e_->lnf_effects_rh[i]; - e->num_lnf_effects++; - } else { - if ( e->lnf_effects_neft[j] == ASSIGN ) { - if ( e_->lnf_effects_neft[i] != ASSIGN || - !same_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ) ) { - e->illegal = TRUE; - return; - } - /* identical assigns. nothing needs to be done. - */ - } else { - if ( e_->lnf_effects_neft[i] == ASSIGN ) { - e->illegal = TRUE; - return; - } - merge_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ); - } - } - } - -} - - - -/* merge both LNFs into the left one. - * (only pF needed as both are already - * fully transformed) - */ -void merge_lnfs( LnfExpNode *l, LnfExpNode *r ) - -{ - - int i, j, k; - - for ( i = 0; i < r->num_pF; i++ ) { - - for ( j = 0; j < l->num_pF; j++ ) { - if ( r->pF[i] == l->pF[j] ) break; - } - if ( j < l->num_pF ) { - /* got that one in dest LNF already - */ - l->pC[j] += r->pC[i]; - continue; - } - - if ( lminus_fluent[r->pF[i]] != -1 ) { - /* this one was already translated. let's see - * if its counterpart is in the left lnf. - */ - for ( j = 0; j < l->num_pF; j++ ) { - if ( lminus_fluent[r->pF[i]] == l->pF[j] ) break; - } - if ( j < l->num_pF ) { - /* for this, we got the inverse one! - */ - l->pC[j] -= r->pC[i]; - if ( l->pC[j] < 0 ) { - l->pF[j] = r->pF[i]; - l->pC[j] *= (-1); - } - if ( l->pC[j] == 0 ) { - /* remove this entirely. - */ - for ( k = j; k < l->num_pF - 1; k++ ) { - l->pF[k] = l->pF[k+1]; - l->pC[k] = l->pC[k+1]; - } - l->num_pF--; - } - continue; - } - } - - /* we got neither that nor its counterpart. - */ - if ( l->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - l->pF[l->num_pF] = r->pF[i]; - l->pC[l->num_pF++] = r->pC[i]; - } - - - l->c += r->c; - -} - - - - - - - - - - - - - - - - - - - - - - -/************************************************************* - * LNF POST-PROCESSING II: ENCODE NON-MINIMAL LNFs. - *************************************************************/ - - - - - - - - - - - - - - - - - - - - - - - -void encode_lfns_as_artificial_fluents( void ) - -{ - - int i; - - /* for the artificial new ones, this will be set - * to the respective LNF. - */ - for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { - grelevant_fluents_lnf[i] = NULL; - } - - while ( TRUE ) { - /* ex non-minimal lnf in pre, cond, eff, or goal? - * - * (i.e., lnf != fl + c) - */ - if ( !ex_non_minimal_lnf_in_pre_cond_goal_eff() ) { - /* no --> we are finished. - */ - break; - } - /* otherwise, the respective LNF, without the - * constant part, is set up in - * lF...; (local global borrowed from above); - * - * introduce a new artificial fluent for that - * LNF - */ - introduce_artificial_fluent(); - /* replace all occurences in pres, conds, effs, and goals - */ - replace_non_minimal_lnf_with_artificial_fl(); - } - -} - - - -Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - if ( glnf_goal_lh[i]->num_pF > 1 || - (glnf_goal_lh[i]->num_pF == 1 && glnf_goal_lh[i]->pC[0] != 1) ) { - for ( j = 0; j < glnf_goal_lh[i]->num_pF; j++ ) { - lF[j] = glnf_goal_lh[i]->pF[j]; - lC[j] = glnf_goal_lh[i]->pC[j]; - } - lnum_F = glnf_goal_lh[i]->num_pF; - return TRUE; - } - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - if ( a->lnf_preconds_lh[i]->num_pF > 1 || - (a->lnf_preconds_lh[i]->num_pF == 1 && a->lnf_preconds_lh[i]->pC[0] != 1) ) { - for ( j = 0; j < a->lnf_preconds_lh[i]->num_pF; j++ ) { - lF[j] = a->lnf_preconds_lh[i]->pF[j]; - lC[j] = a->lnf_preconds_lh[i]->pC[j]; - } - lnum_F = a->lnf_preconds_lh[i]->num_pF; - return TRUE; - } - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->removed ) { - /* these will not be included into conn: - * merged into somewhere else. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( e->lnf_conditions_lh[j]->num_pF > 1 || - (e->lnf_conditions_lh[j]->num_pF == 1 && e->lnf_conditions_lh[j]->pC[0] != 1) ) { - for ( k = 0; k < e->lnf_conditions_lh[j]->num_pF; k++ ) { - lF[k] = e->lnf_conditions_lh[j]->pF[k]; - lC[k] = e->lnf_conditions_lh[j]->pC[k]; - } - lnum_F = e->lnf_conditions_lh[j]->num_pF; - return TRUE; - } - } - - if ( e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_rh[j]->num_pF > 1 || - (e->lnf_effects_rh[j]->num_pF == 1 && e->lnf_effects_rh[j]->pC[0] != 1) ) { - for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { - lF[k] = e->lnf_effects_rh[j]->pF[k]; - lC[k] = e->lnf_effects_rh[j]->pC[k]; - } - lnum_F = e->lnf_effects_rh[j]->num_pF; - return TRUE; - } - } - } - } - - return FALSE; - -} - - - -void introduce_artificial_fluent( void ) - -{ - - int i; - - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = -1; - - /* no name --> is inferred in this case from _lnf - */ - - grelevant_fluents_lnf[gnum_relevant_fluents] = new_LnfExpNode(); - for ( i = 0; i < lnum_F; i++ ) { - grelevant_fluents_lnf[gnum_relevant_fluents]->pF[i] = lF[i]; - grelevant_fluents_lnf[gnum_relevant_fluents]->pC[i] = lC[i]; - } - grelevant_fluents_lnf[gnum_relevant_fluents]->num_pF = lnum_F; - - gnum_relevant_fluents++; - -} - - - -void replace_non_minimal_lnf_with_artificial_fl( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - if ( !is_artificial_fluent( glnf_goal_lh[i] ) ) { - continue; - } - /* the pF here is the pF we are currently replacing. - */ - glnf_goal_lh[i]->pF[0] = gnum_relevant_fluents - 1; - glnf_goal_lh[i]->pC[0] = 1; - glnf_goal_lh[i]->num_pF = 1; - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - if ( !is_artificial_fluent( a->lnf_preconds_lh[i] ) ) { - continue; - } - a->lnf_preconds_lh[i]->pF[0] = gnum_relevant_fluents - 1; - a->lnf_preconds_lh[i]->pC[0] = 1; - a->lnf_preconds_lh[i]->num_pF = 1; - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->removed ) { - /* these will not be included into conn: - * merged into somewhere else. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( !is_artificial_fluent( e->lnf_conditions_lh[j] ) ) { - continue; - } - e->lnf_conditions_lh[j]->pF[0] = gnum_relevant_fluents - 1; - e->lnf_conditions_lh[j]->pC[0] = 1; - e->lnf_conditions_lh[j]->num_pF = 1; - } - - if ( e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( !is_artificial_fluent( e->lnf_effects_rh[j] ) ) { - continue; - } - e->lnf_effects_rh[j]->pF[0] = gnum_relevant_fluents - 1; - e->lnf_effects_rh[j]->pC[0] = 1; - e->lnf_effects_rh[j]->num_pF = 1; - } - } - } - -} - - - -Bool is_artificial_fluent( LnfExpNode *n ) - -{ - - int i, j; - - if ( n->num_nF != 0 ) { - printf("\n\nchecking non-empty nF for multiple fl!\n\n"); - exit( 1 ); - } - - if ( n->num_pF != lnum_F ) { - return FALSE; - } - - for ( i = 0; i < lnum_F; i++ ) { - for ( j = 0; j < n->num_pF; j++ ) { - if ( n->pF[j] != lF[i] ) continue; - if ( n->pC[j] != lC[i] ) { - /* wrong constant multiplier! - */ - return FALSE; - } - break; - } - if ( j == n->num_pF ) { - /* didn't find this fluent i in here. - */ - return FALSE; - } - } - - return TRUE; - -} - - - - - - - - - - - - - - - - - - -/************************************************************* - * AT LAST: PREPARATIONS FOR METRIC FUNCTION - *************************************************************/ - - - - - - - - - - - - - - - - - - -Bool setup_effect_costs( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k, fl; - Bool non_zero = FALSE; - - if ( glnf_metric.num_pF == 0 ) { - /* no metric, or previously failed - */ - if ( gcmd_line.display_info ) { - printf("\nno metric specified."); - } - return FALSE; - } - - /* also in here: check if all parts of metric are defined - * if not, then they won't ever be because we do not allow - * assigners anyway. - * - * also, setup gtt total-time multipl. - * currently needed since in h fn effect cists are summed up - * --> may count the same action more than once, if we insert the - * timing cost into the effect cost. - * - * ... this is AWKWARD... probably would be better to simply - * associate costs always (including relaxed plans) - * only with ACTIONS! - */ - gtt = 0; - for ( i = 0; i < glnf_metric.num_pF; i++ ) { - if ( glnf_metric.pF[i] == -2 ) { - gtt = glnf_metric.pC[i]; - continue; - } - if ( !ginitial_state.f_D[glnf_metric.pF[i]] ) break; - } - if ( i < glnf_metric.num_pF ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: metric undefined initially. no optimization done."); - } - return FALSE; - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - e->cost = 0; - - if ( e->removed || - e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - fl = e->lnf_effects_fl[j]; - for ( k = 0; k < glnf_metric.num_pF; k++ ) { - if ( fl == glnf_metric.pF[k] ) break; - } - if ( k == glnf_metric.num_pF ) continue; - - if ( e->lnf_effects_rh[j]->num_pF > 0 ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: non-constant effect on metric. no optimization done."); - } - return FALSE; - } - if ( e->lnf_effects_neft[j] != INCREASE ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: assign on metric. no optimization done."); - } - return FALSE; - } - if ( e->lnf_effects_rh[j]->c < 0 ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: change on metric in wrong direction. no optimization done."); - } - return FALSE; - } - - e->cost += glnf_metric.pC[k] * e->lnf_effects_rh[j]->c; - if ( e->cost > 0 ) { - non_zero = TRUE; - } - } - } - } - - if ( !non_zero ) { - if ( gtt == 0 ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: trivial metric, all costs 0. no optimization done."); - } - return FALSE; - } - } - - return TRUE; - -} - - - - - - - - - - - - - - - - - - - - - -/************************************************************* - * AT VERY LAST: ACYCLIC := EFFS, AND STATIC FL RELEVANCE - *************************************************************/ - - - - - - - - - - - - - - - - - - - - - - - -void check_assigncycles( void ) - -{ - - int i, j, k, c = 0; - - gassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); - gTassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - gassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - gTassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - } - - if ( gcmd_line.display_info > 1 ) { - printf("\n\nchecking for cyclic := effects"); - } - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - gassign_influence[i][j] = i_influences_j( i, j ); - gTassign_influence[i][j] = i_influences_j( i, j ); - } - } - /* compute transitive closure on dependencies - */ - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( gTassign_influence[i][j] ) { - for ( k = 0; k < gnum_real_fl_conn; k++ ) { - if ( gTassign_influence[j][k] ) { - gTassign_influence[i][k] = TRUE; - } - } - } - } - } - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( gTassign_influence[i][i] ) { - printf("\nnumerical variable "); - print_fl_name( i ); - printf(" lies on := propagation cycle!"); - c++; - } - } - if ( c > 0 ) { - printf("\nexit. (mneed computation not possible, RPG termination unclear)"); - printf("\n (questions to Joerg Hoffmann)\n\n"); - exit( 1 ); - } else { - if ( gcmd_line.display_info > 1 ) { - printf(" --- OK."); - } - } - -} - - - -Bool i_influences_j( int fi, int fj ) - -{ - - int i, j, fl_; - - for ( i = 0; i < gfl_conn[fj].num_AS; i++ ) { - fl_ = gfl_conn[fj].AS_fl_[i]; - if ( fl_ < 0 ) continue; - if ( fl_ == fi ) return TRUE; - if ( !gfl_conn[fl_].artificial ) continue; - for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { - if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; - } - } - - return FALSE; - -} - - - -void determine_fl_relevance( void ) - -{ - - int i, j, k, fl, fl_, ef, pc, g; - Bool **influenced_by; - - /* this here contains transfers from i to j i.e. if - * i is relevant then j is too - */ - influenced_by = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - influenced_by[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - } - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - influenced_by[i][j] = ( gassign_influence[j][i] || - i_inc_influences_j( j, i ) ); - } - } - /* transitive closure so we'll have direct access below. - */ - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( influenced_by[i][j] ) { - for ( k = 0; k < gnum_real_fl_conn; k++ ) { - if ( influenced_by[j][k] ) { - influenced_by[i][k] = TRUE; - } - } - } - } - } - - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - gfl_conn[i].relevant = FALSE; - } - /* relevance originates in effect preconds and goals. - */ - for ( ef = 0; ef < gnum_ef_conn; ef++ ) { - for ( pc = 0; pc < gef_conn[ef].num_f_PC; pc++ ) { - /* constraint here is gef_conn[ef].f_PC_fl[pc] >= [>] gef_conn[ef].f_PC_c[pc] - * where lh side can be lnf expression. - */ - fl = gef_conn[ef].f_PC_fl[pc]; - if ( fl < 0 ) { - printf("\nnegative constr lh??\n\n"); - exit( 1 ); - } - if ( !gfl_conn[fl].artificial ) { - gfl_conn[fl].relevant = TRUE; - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; - } - } else { - for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { - fl_ = gfl_conn[fl].lnf_F[i]; - gfl_conn[fl_].relevant = TRUE; - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; - } - } - } - } - } - for ( g = 0; g < gnum_fnumeric_goal; g++ ) { - /* constraint here is gfnumeric_goal_fl[g] >= [>] gfnumeric_goal_c[g] - * where lh side can be lnf expression. - */ - fl = gfnumeric_goal_fl[g]; - if ( fl < 0 ) { - printf("\nnegative constr lh??\n\n"); - exit( 1 ); - } - if ( !gfl_conn[fl].artificial ) { - gfl_conn[fl].relevant = TRUE; - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; - } - } else { - for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { - fl_ = gfl_conn[fl].lnf_F[i]; - gfl_conn[fl_].relevant = TRUE; - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; - } - } - } - } - - if ( 0 ) { - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - printf("\n"); print_fl_name( i ); - printf (" --- relevant: %d", gfl_conn[i].relevant); - } - } - -} - - - -Bool i_inc_influences_j( int fi, int fj ) - -{ - - int i, j, fl_; - - for ( i = 0; i < gfl_conn[fj].num_IN; i++ ) { - fl_ = gfl_conn[fj].IN_fl_[i]; - if ( fl_ < 0 ) continue; - if ( fl_ == fi ) return TRUE; - if ( !gfl_conn[fl_].artificial ) continue; - for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { - if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; - } - } - - return FALSE; - -} - diff --git a/models/main_models/rt1/gen/ff_planner/expressions.h b/models/main_models/rt1/gen/ff_planner/expressions.h deleted file mode 100644 index 3546f2acd..000000000 --- a/models/main_models/rt1/gen/ff_planner/expressions.h +++ /dev/null @@ -1,106 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - -/********************************************************************* - * File: expressions.h - * Description: headers for handling numerical expressions - * - * Author: Joerg Hoffmann 2001 - * - *********************************************************************/ - - - - - - - - - - - - - - -#ifndef _EXPRESSIONS_H -#define _EXPRESSIONS_H - - - - -Bool number_comparison_holds( Comparator c, float l, float r ); - - - -Bool transform_to_LNF( void ); -Bool is_linear_task( void ); -Bool is_linear_expression( ExpNode *n ); -void print_lnf_representation( void ); - - - -void normalize_expressions( void ); -Bool translate_divisions( ExpNode **n ); -void push_multiplications_down( ExpNode **n ); -void put_comp_into_normalized_locals( Comparator comp, - ExpNode *lh, - ExpNode *rh ); -void collect_normalized_locals( ExpNode *n, Bool positive ); - - - -void translate_subtractions( void ); -Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ); -void introduce_minus_fluent( int fl ); -void replace_fl_in_nF_with_minus_fl( int fl ); -void set_minus_fl_initial( int fl ); -void introduce_minus_fl_effects( int fl ); - - - -void summarize_effects( void ); -Bool same_condition( ActionEffect *e, ActionEffect *e_ ); -Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); -void merge_effects( ActionEffect *e, ActionEffect *e_ ); -void merge_lnfs( LnfExpNode *l, LnfExpNode *r ); - - - -void encode_lfns_as_artificial_fluents( void ); -Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ); -void introduce_artificial_fluent( void ); -void replace_non_minimal_lnf_with_artificial_fl( void ); -Bool is_artificial_fluent( LnfExpNode *n ); - - - -Bool setup_effect_costs( void ); - - - -void check_assigncycles( void ); -Bool i_influences_j( int fi, int fj ); -void determine_fl_relevance( void ); -Bool i_inc_influences_j( int fi, int fj ); - - - -#endif /* _EXPRESSIONS_H */ diff --git a/models/main_models/rt1/gen/ff_planner/ff.h b/models/main_models/rt1/gen/ff_planner/ff.h deleted file mode 100644 index d244df7ae..000000000 --- a/models/main_models/rt1/gen/ff_planner/ff.h +++ /dev/null @@ -1,2044 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - -/********************************************************************* - * File: ff.h - * Description: Types and structures for the Metric-FastForward planner. - * Enhanced version with derived predicates and A*-epsilon - * - * --------- PDDL2.1 level 2 :: VERSION v 1.0 -------------- - * - * Author: Joerg Hoffmann 2012 - * Contact: hoffmann@cs.uni-saarland.de - * - *********************************************************************/ - - - - - - - - -#ifndef __FF_H -#define __FF_H - - - - - - -#include -#include -#include -#include -#include -#include -#include - - - - - - - - - -/* - * ------------------------------------ DEFINES ---------------------------- - */ - - - - - - - - - - - -/*********************** - * MEANINGLESS HELPERS * - ***********************/ - - - - -/* strcmp returns 0 if two strings are equal, which is not nice */ -#define SAME 0 - - - - - - - - - -/**************** - * PARSING ETC. * - ****************/ - - - - - - - - - -/* various defines used in parsing - */ -#define HIDDEN_STR "#" -#define AXIOM_STR "AXIOM" -#define NAME_STR "name\0" -#define VARIABLE_STR "variable\0" -#define STANDARD_TYPE "OBJECT\0" -#define EITHER_STR "EITHER" - - - - - - - - - -/*************************** - * SOME ARBITRARY SETTINGS * - ***************************/ - - - - - - - -/* maximal string length - */ -#define MAX_LENGTH 256 - - -/* marks border between connected items - */ -#define CONNECTOR "~" - - -/* size of goals_at array in 1P extraction - */ -#define RELAXED_STEPS_DEFAULT 25 - - -/* size of hash table for repeated states checking - * during EHC breadth first search - */ -#define EHC_HASH_SIZE 8192 -#define EHC_HASH_BITS 8191 - - -/* size of hash table for repeated states checking - * in plan construction - */ -#define PLAN_HASH_SIZE 1024 -#define PLAN_HASH_BITS 1023 - - -/* size of hash table for repeated states checking - * during BFS search - */ -#define BFS_HASH_SIZE 65536 -#define BFS_HASH_BITS 65535 - - -/* cut random values of facts off modulo this value, - * to make state sums fit into a single integer - */ -#define BIG_INT 1500000 - - -/* max number of different fluents in one list of LNF - */ -#define MAX_LNF_F 25 - - -/* max number of comps in one cond / precond / goal - */ -#define MAX_LNF_COMPS 100 - - -/* max number of lnf effects in one action effect - */ -#define MAX_LNF_EFFS 50 - - - - - - - -/************************ - * INSTANTIATION LIMITS * - ************************/ - - - - - - - - -#define MAX_CONSTANTS 2000 -#define MAX_PREDICATES 50 -#define MAX_FUNCTIONS 50 -#define MAX_TYPES 50 -#define MAX_ARITY 5 -#define MAX_VARS 15 - - -#define MAX_TYPE 2000 - - -#define MAX_OPERATORS 50000 - - -/* in DNF: AND with OR - sons - collect 'hitting set': - * one son of each OR node. - * - * this here is initial max number of such son s that can be collected - * (grows dynamically, if required) - */ -#define MAX_HITTING_SET_DEFAULT 1000 - - -#define MAX_TYPE_INTERSECTIONS 10 - - -#define MAX_RELEVANT_FACTS 150000 -#define MAX_RELEVANT_FLUENTS 1000 - - - - - - -/****************************************** - * DOMAIN STRUCTURE AND SEARCHING LIMITS * - ******************************************/ - - - - - - -#define MAX_STATE 800 - - -#define MAX_PLAN_LENGTH 500 - - - - - - -/**************** - * CODE DEFINES * - ****************/ - - - - - - - - - -/* not a real 'code' define; used in relax and search to encode - * infinite level number / plan length - */ -#ifndef INFINITY -#define INFINITY -1 -#endif - - - - - - - -/* define boolean types if not allready defined - */ -#ifndef Bool -typedef unsigned char Bool; -#ifndef TRUE /* we assume that FALSE is also not defined */ -#define TRUE 1 -#define FALSE 0 -#endif /* TRUE */ -#endif /* Bool */ - - -/* code a param number into a negative number and vice versa - */ -#define ENCODE_VAR( val ) (val * (-1)) - 1 -#define DECODE_VAR( val ) (val + 1) * (-1) - -#define GET_CONSTANT( val, pointer ) ( val >= 0 ) ? val : pointer->inst_table[DECODE_VAR( val )] - - -/* Check allocated memory - */ -#define CHECK_PTR(p) if (NULL == (p)) { \ - fprintf(stdout, "\n\aNO MEMORY in file %s:%d\n\n", __FILE__, __LINE__); \ - exit(1);} - - -/* add elapsed time from main local time vars to specified val - */ -#define TIME( val ) val += ( float ) ( ( end.tms_utime - start.tms_utime + \ - end.tms_stime - start.tms_stime ) / 100.0 ) - - - - - - - - - - - - -/* - * ------------------------------ DATA STRUCTURES ---------------------------- - */ - - - - - - - - - - - -/******************* - * GENERAL HELPERS * - *******************/ - - - - - - - - -/* all command switches - */ -struct _command_line { - - char path[MAX_LENGTH]; - char ops_file_name[MAX_LENGTH]; - char fct_file_name[MAX_LENGTH]; - int display_info; - int debug; - - int search_config; - Bool cost_rplans; - - int w; - - float cost_bound; - -}; - - -typedef char *Token; - - - - - - - - - - - - -/*********** - * PARSING * - ***********/ - - - - - - - - - - -/* A list of strings - */ -typedef struct _TokenList { - - char *item; - struct _TokenList *next; - -} TokenList; - - - -/* list of string lists - */ -typedef struct _FactList { - - TokenList *item; - struct _FactList *next; - -} FactList; - - - -/* structure to store typed-list-of /, - * as they are declared in PDDL files - */ -typedef struct _TypedList { - - char *name; - - /* each item in this list is the name of a type which - * our type is the union of (EITHER - types ...) - * - * usually, this will default to a single-item TokenList. - */ - TokenList *type; - /* after first sweep, this will contain the number in type table - */ - int n; - - struct _TypedList *next; - -} TypedList; - - - -/* only needed to parse in the predicates and their arg - * definitions - */ -typedef struct _TypedListList { - - char *predicate; - - TypedList *args; - - struct _TypedListList *next; - -} TypedListList; - - - -typedef enum _ExpConnective{FHEAD = 1000, - NUMBER, - MINUS, - AD, - SU, - MU, - DI} ExpConnective; - - - -typedef struct _ParseExpNode { - - ExpConnective connective; - - /* NULL anywhere except when node is FHEAD or NUMBER - * (in which case it is fn name ... resp. number (int or float) as string - */ - TokenList *atom; - - /* both NULL in FHEAD; - * in MINUS, left is son and right is NULL - * else (binary operators), left and right operand - */ - struct _ParseExpNode *leftson, *rightson; - -} ParseExpNode; - - - -/* This type indicates whether a node in the pddl tree stands for - * an atomic expression, a junctor or a quantor. - */ -typedef enum _Connective{TRU = 2000, - FAL, - ATOM, - COMP, - NEF, - NOT, - AND, - OR, - ALL, - EX, - WHEN} Connective; - - - -typedef enum _Comparator{IGUAL = 3000, /* technical if conds are array comp exp, resp float */ - LE, - LEQ, - EQ, - GEQ, - GE} Comparator; - - - - -typedef enum _NumericEffectType{ASSIGN = 4000, - SCALE_UP, - SCALE_DOWN, - INCREASE, - DECREASE} NumericEffectType; - - - - -/* - * This is a node in the tree to parse PDDL files - */ -typedef struct _PlNode { - - /* type of the node - */ - Connective connective; - - /* only for parsing: the var args in quantifiers - */ - TypedList *parse_vars; - - /* AND, OR, NOT, WHEN, - * COMP, NEF => NULL - * ALL, EX => the quantified variable with its type - * ATOM => the atom as predicate->param1->param2->... - */ - TokenList *atom; - /* all except COMP, NEF => NULL - * COMP, NEF => left hand, right hand - */ - Comparator comp; - NumericEffectType neft; - ParseExpNode *lh, *rh; - - /* (a) for AND, OR this is the list of sons(a AND b AND c...), - * (b) for the rest this is the son, e.g. a subtree that is negated - * (c) for WHEN, the first son is the condition and the next son - * is the effect - */ - struct _PlNode *sons; - - /* if you have a list of sons, they are connected by next - */ - struct _PlNode *next; - -} PlNode; - - -/* - * This resembles an uninstantiated PDDL operator - */ -typedef struct _PlOperator { - - char *name; - Bool axiom; - - /* only important for PDDL where :VARS may be added to the param list - * which must be hidden when writing the plan to an output file - */ - int number_of_real_params; - - /* the params, as they are declared in domain file - */ - TypedList *parse_params; - - /* params is a list of variable/type pairs, such that: - * factlist->item = [variable] -> [type] - */ - FactList *params; - PlNode *preconds; - PlNode *effects; - - struct _PlOperator *next; - -} PlOperator; - - - - - - - - - - - - - - - -/***************** - * INSTANTIATION * - *****************/ - - - - - - - - - -/* helpers - */ - -typedef int TypeArray[MAX_TYPE_INTERSECTIONS]; - -typedef int *int_pointer; - - - - -/* first step structures: parsing & preprocessing - */ - -typedef struct _Fact { - - int predicate, args[MAX_ARITY]; - -} Fact; - - - -typedef struct _Fluent { - - int function, args[MAX_ARITY]; - -} Fluent; - - - -typedef struct _FluentValue { - - Fluent fluent; - float value; - -} FluentValue; - - - -typedef struct _Facts { - - Fact *fact; - - struct _Facts *next; - -} Facts; - - - -typedef struct _FluentValues { - - Fluent fluent; - float value; - - struct _FluentValues *next; - -} FluentValues; - - - -typedef struct _ExpNode { - - ExpConnective connective; - - /* in FHEAD nodes, pre-processing - */ - Fluent *fluent; - /* in FHEAD nodes after pre-processes have finished. - * (internal number of relevant fluent, or -1 if not - * relevant) - */ - int fl; - /* helper for LNF: if that fl is multiplied, this is the - * respective constant after pre-normalization. - */ - float c; - - /* in NUMBER nodes - */ - float value; - - /* in MINUS nodes - */ - struct _ExpNode *son; - - /* in all others - */ - struct _ExpNode *leftson, *rightson; - -} ExpNode, *ExpNode_pointer; - - - -typedef struct _WffNode { - - Connective connective; - - /* in ALL/EX s - */ - int var, var_type; - char *var_name; - - /* in AND/OR s - */ - struct _WffNode *sons; - /* sons are doubly connected linear list - */ - struct _WffNode *next; - struct _WffNode *prev; - - /* in ATOMs - */ - Fact *fact; - /* after translation: mark NOT-p s for efficiency - */ - int NOT_p; - - /* in ALL/EX/NOT - */ - struct _WffNode *son; - - /* in COMP - */ - Comparator comp; - ExpNode *lh, *rh; - - /* for expansion speedup - */ - Bool visited; - - /* no WHEN s here... use Pl Connectives anyway for simplicity - */ - -} WffNode, *WffNode_pointer; - - - -typedef struct _Literal { - - Bool negated; - - Fact fact; - - struct _Literal *next; - struct _Literal *prev; - -} Literal; - - - -typedef struct _NumericEffect { - - Fluent fluent; - NumericEffectType neft; - - ExpNode *rh; - - struct _NumericEffect *next; - struct _NumericEffect *prev; - -} NumericEffect; - - - -typedef struct _Effect { - - int num_vars, var_types[MAX_VARS]; - char *var_names[MAX_VARS]; - - WffNode *conditions; - - Literal *effects; - NumericEffect *numeric_effects; - - struct _Effect *next; - struct _Effect *prev; - -} Effect; - - - -typedef struct _Operator { - - char *name, *var_names[MAX_VARS]; - int number_of_real_params; - Bool axiom; - - int num_vars, var_types[MAX_VARS]; - Bool removed[MAX_VARS]; - - WffNode *preconds; - - Effect *effects; - - Bool hard; - -} Operator, *Operator_pointer; - - - - - - -/* second step: structures that keep already normalized - * operators - */ - - - - -typedef struct _NormEffect { - - int num_vars, var_types[MAX_VARS]; - int inst_table[MAX_VARS]; - - Fact *conditions; - int num_conditions; - - Fact *adds; - int num_adds; - Fact *dels; - int num_dels; - - /* numerical parts: not yet normalized any further; seems that - * normalizing requires certain additional structures + - * transformation, and that these will better be done when - * the representation is fully instantiated already. - */ - Comparator *numeric_conditions_comp; - ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; - int num_numeric_conditions; - - NumericEffectType *numeric_effects_neft; - Fluent *numeric_effects_fluent; - ExpNode_pointer *numeric_effects_rh; - int num_numeric_effects; - - struct _NormEffect *prev; - struct _NormEffect *next; - -} NormEffect; - - - -typedef struct _NormOperator { - - Operator *operator; - - int num_vars, var_types[MAX_VARS]; - int inst_table[MAX_VARS]; - int removed_vars[MAX_VARS], num_removed_vars, type_removed_vars[MAX_VARS]; - - Fact *preconds; - int num_preconds; - /* numeric precondition still full scale represented, see above - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - NormEffect *effects; - - Bool out; - -} NormOperator, *NormOperator_pointer; - - - -/* minimal info for a fully instantiated easy operator; - * yields one action when expanded - */ -typedef struct _EasyTemplate { - - NormOperator *op; - int inst_table[MAX_VARS]; - - struct _EasyTemplate *prev; - struct _EasyTemplate *next; - -} EasyTemplate; - - - - - - -/* structures for hard ops - */ - - - - - -/* intermediate step: structure for keeping hard ops - * with normalized precondition, but arbitrary - * effect conditions - */ -typedef struct _MixedOperator { - - Operator *operator; - - int inst_table[MAX_VARS]; - - Fact *preconds; - int num_preconds; - /* numeric part, pre-normalized - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - Effect *effects; - - struct _MixedOperator *next; - -} MixedOperator; - - - -/* last hard step: everything is action - like, except that - * facts are not yet integer coded - */ - - - -typedef struct _PseudoActionEffect { - - Fact *conditions; - int num_conditions; - - Fact *adds; - int num_adds; - Fact *dels; - int num_dels; - - - /* and the numeric parts again... - */ - Comparator *numeric_conditions_comp; - ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; - int num_numeric_conditions; - - NumericEffectType *numeric_effects_neft; - Fluent *numeric_effects_fluent; - ExpNode_pointer *numeric_effects_rh; - int num_numeric_effects; - - struct _PseudoActionEffect *next; - -} PseudoActionEffect; - - - -typedef struct _PseudoAction { - - Operator *operator; - - int inst_table[MAX_VARS]; - - Fact *preconds; - int num_preconds; - /* numeric part, pre-normalized - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - PseudoActionEffect *effects; - int num_effects; - -} PseudoAction, *PseudoAction_pointer; - - - - -/* final domain representation structure - */ - - - -typedef struct _LnfExpNode { - - int pF[MAX_LNF_F]; - float pC[MAX_LNF_F]; - int num_pF; - - int nF[MAX_LNF_F]; - float nC[MAX_LNF_F]; - int num_nF; - - float c; - -} LnfExpNode, *LnfExpNode_pointer; - - - -typedef struct _ActionEffect { - - int *conditions; - int num_conditions; - - int *adds; - int num_adds; - int *dels; - int num_dels; - - /* and the numeric parts again; fluents all as fl ints; - * - * normalization for cond as below for pre; - * norm. for effects by restriction of types (?), - * right hand side float (?) - */ - Comparator *numeric_conditions_comp; - ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; - int num_numeric_conditions; - - NumericEffectType *numeric_effects_neft; - int *numeric_effects_fl; - ExpNode_pointer *numeric_effects_rh; - int num_numeric_effects; - - /* LNF - */ - Comparator *lnf_conditions_comp; - LnfExpNode_pointer *lnf_conditions_lh; - float *lnf_conditions_rh; - int num_lnf_conditions; - - NumericEffectType *lnf_effects_neft; - int *lnf_effects_fl; - LnfExpNode_pointer *lnf_effects_rh; - int num_lnf_effects; - - /* this is true iff the numerical part of the effects affects or accesses - * an undefined fluent (i.e. in numeric_effects_fl or numeric_effects_rh ) - * --- then, if the effect appears, the action is - * illegal. - */ - Bool illegal; - - /* helper - */ - Bool removed; - - float cost; - -} ActionEffect; - - - -typedef struct _Action { - - NormOperator *norm_operator; - PseudoAction *pseudo_action; - Bool axiom; - - char *name; - int num_name_vars; - int name_inst_table[MAX_VARS]; - - int inst_table[MAX_VARS]; - - int *preconds; - int num_preconds; - /* numeric part, in general format, with fluents encoded as fl ints - * - * also, will (?) be transformed to lh fl, rh float; then, expnodes as - * fast accessible as specialised structures. - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - /* LNF - */ - Comparator *lnf_preconds_comp; - LnfExpNode_pointer *lnf_preconds_lh; - float *lnf_preconds_rh; - int num_lnf_preconds; - - ActionEffect *effects; - int num_effects; - - struct _Action *next; - -} Action; - - - - - - - - - - - -/***************************************************** - * BASIC OP AND FT STRUCTURES FOR CONNECTIVITY GRAPH * - *****************************************************/ - - - - - - - - - - - -typedef struct _OpConn { - - /* to get name - */ - Action *action; - Bool axiom; - - /* effects - */ - int *E; - int num_E; - - /* member for applicable actions extraction - */ - Bool is_in_A; - Bool is_in_A_axioms; - - /* members for 1Ph - H(S) extraction - */ - int is_used; - Bool is_in_H; - - /* this is a bit imprecise since actually, in this - * framework here, the cost of the action may depend on - * which conditional effects actually apply. - * ... anyway, this makes things much easier for the case - * where there aren't any effect conditions. all cost handling - * is now based on this..!! - */ - float cost; - -} OpConn; - - - -typedef struct _EfConn { - - int op; - - /* true if access to always undefined fluent, or - * conflicting assignments. - * - * if that is the case then nothing except condition is set: - * the effect is completely ignored except that - * it renders the op unapplicable when its condition - * is true. - */ - Bool illegal; - - /* this one means we found in conn that it is useless (empty) - */ - Bool removed; - - /* this is the cost; can be non-zero if a metric was specified - * and established - */ - float cost; - - int *PC; - int num_PC; - /* numeric part - */ - Comparator *f_PC_comp; /* either GEQ or GE */ - int *f_PC_fl; - float *f_PC_c; - int num_f_PC; - /* array indexed by fl number, to fast know whether - * new fluent value is high enough - */ - Comparator *f_PC_direct_comp; - float *f_PC_direct_c; - - /* logic effects - */ - int *A; - int num_A; - int *D; - int num_D; - /* and the numeric ones; fl_ is the encoding of the LNF - * on the right hand side, without constant part - * (special treatment for that as it's supposed - * to be the most common thing!!) - */ - int *IN_fl; - int *IN_fl_; - float *IN_c; - int num_IN; - - int *AS_fl; - int *AS_fl_; - float *AS_c; - int num_AS; - - /* implied effects - */ - int *I; - int num_I; - - /* members for relaxed fixpoint computation - */ - int level;/* first "cost level" where ef appears */ - float RPGcost;/* max_{p prec} cost(p)+cost(op(ef)) */ - - Bool in_E; - int num_active_PCs; - Bool ch; - - /* RPG - */ - int num_active_f_PCs; - - /* 1P; an effect can be selected several times - * for increasing a fluent. - */ - int in_plan; - -} EfConn; - - - -typedef struct _FtConn { - - /* effects it is union conds, pres element of - */ - int *PC; - int num_PC; - - /* efs that add or del it - */ - int *A; - int num_A; - - int *D; - int num_D; - - /* members for orderings preprocessing - */ - int *False; - int num_False; - - /* members for relaxed fixpoint computation - */ - int level;/* first "cost level" where ft appears */ - float RPGcost;/* min_{e adder} cost(e) */ - Bool in_F; - - /* members for 1Ph extraction - */ - int is_goal; - int is_true; - Bool ch; - - /* search - */ - int rand;/* for hashing */ - - /* is this the effect of an axiom? - * needed to quickly filter out derived facts, in state - * transitions! - */ - Bool axiom_added; - -} FtConn; - - - -typedef struct _FlConn { - - /* effects it is union conds, pres required - */ - int *PC; - int num_PC; - - /* efs that inc, ass it and by which encoded fluents and constants - */ - int *IN; - int *IN_fl_; - float *IN_c; - int num_IN; - - int *AS; - int *AS_fl_; - float *AS_c;/* see above */ - int num_AS; - - /* is it an artificial fluent? - */ - Bool artificial; - /* if so, then this here is the linear equation - * it stands for - */ - int *lnf_F; - float *lnf_C; - int num_lnf; - - - /* the termination criterion for RPG building is based on mneed, see - * JAIR article for definition; - * - * as the name suggests, we use the bool to indicate that this one is not - * needed at all - */ - Bool mneed_is_minusinfty; - float mneed; - /* see JAIR; shortcut for never needed at all. - */ - Bool relevant; - - /* the following are members handled within heuristic algorithms. - */ - - /* this are arrays saying what the max value at - * the levels in the RPG is, resp. whether the value - * can be defined there at all, resp. what the increasers - * at that level have added. - */ - Bool *def; - float *level; - - /* for handling assigners in RPG: is an assigner in there yet, - * and if so what is their max value? - */ - Bool curr_assigned; - float curr_max_assigned; - - int rand;/* for hashing */ - -} FlConn; - - - - - - - - - - - - -/**************************** - * STRUCTURES FOR SEARCHING * - ****************************/ - - - - - - - - - -typedef struct _State { - - int *F; - int num_F; - - Bool *f_D; - float *f_V; - -} State, *State_pointer; - - - -typedef struct _EhcNode { - - State S; - - int op; - int depth; - - struct _EhcNode *father; - struct _EhcNode *next; - -} EhcNode; - - - -typedef struct _EhcHashEntry { - - int sum; - - EhcNode *ehc_node; - - struct _EhcHashEntry *next; - -} EhcHashEntry, *EhcHashEntry_pointer; - - - -typedef struct _PlanHashEntry { - - int sum; - State S; - - /* step is number of op that is EXECUTED in S; - * -1 means that this state is no longer contained in plan - */ - int step; - struct _PlanHashEntry *next_step; - - struct _PlanHashEntry *next; - -} PlanHashEntry, *PlanHashEntry_pointer; - - - -typedef struct _BfsNode { - - State S; - int op; - - /* number of steps from ini state to here - */ - int ini_distance; - - /* number of steps in relaxed plan for this state - */ - int goal_distance; - - /* g-value and h-value, ie summed-up cost to here, - * summed-up cost in rplan for here. - * used in all optimization configs - */ - float g; - float h; - - /* f-value. in weighted A*, f=g+w*h; in A*epsilon, f=g+h - */ - float f; - - /* The applicable actions -- may be only the helpful ones, - * in case helpful actions are used! - */ - int *A; - int num_A; - - struct _BfsNode *father; - - struct _BfsNode *next; - struct _BfsNode *prev; - -} BfsNode; - - - -typedef struct _BfsHashEntry { - - int sum; - - BfsNode *bfs_node; - - struct _BfsHashEntry *next; - -} BfsHashEntry, *BfsHashEntry_pointer; - - - - - - - - - - - - - -/* - * -------------------------------- MAIN FN HEADERS ---------------------------- - */ - - - - - - - - - - - - - - - - - -void output_planner_info( void ); -void ff_usage( void ); -Bool process_command_line( int argc, char *argv[] ); - - - - - - - - - -/* - * ----------------------------- GLOBAL VARIABLES ---------------------------- - */ - - - - - - - - - - - - -/******************* - * GENERAL HELPERS * - *******************/ - - - - - - - - - - -/* used to time the different stages of the planner - */ -extern float gtempl_time, greach_time, grelev_time, gconn_time; -extern float gLNF_time, gsearch_time; - -/* the command line inputs - */ -extern struct _command_line gcmd_line; - -/* number of states that got heuristically evaluated - */ -extern int gevaluated_states; - -/* maximal depth of breadth first search - */ -extern int gmax_search_depth; - - - - - - - - - -/*********** - * PARSING * - ***********/ - - - - - - - - - - - -/* used for pddl parsing, flex only allows global variables - */ -extern int gbracket_count; -extern char *gproblem_name; - -/* The current input line number - */ -extern int lineno; - -/* The current input filename - */ -extern char *gact_filename; - -/* The pddl domain name - */ -extern char *gdomain_name; - -/* loaded, uninstantiated operators - */ -extern PlOperator *gloaded_ops; - -/* stores initials as fact_list - */ -extern PlNode *gorig_initial_facts; - -/* not yet preprocessed goal facts - */ -extern PlNode *gorig_goal_facts; - -/* the types, as defined in the domain file - */ -extern TypedList *gparse_types; - -/* the constants, as defined in domain file - */ -extern TypedList *gparse_constants; - -/* the predicates and their arg types, as defined in the domain file - */ -extern TypedListList *gparse_predicates; - -/* the functions and their arg types, as defined in the domain file - */ -extern TypedListList *gparse_functions; - -/* the objects, declared in the problem file - */ -extern TypedList *gparse_objects; - -/* the metric - */ -extern Token gparse_optimization; -extern ParseExpNode *gparse_metric; - - -/* connection to instantiation ( except ops, goal, initial ) - */ - -/* all typed objects - */ -extern FactList *gorig_constant_list; - -/* the predicates and their types - */ -extern FactList *gpredicates_and_types; - -/* the functions and their types - */ -extern FactList *gfunctions_and_types; - - - - - - - - - - - - - - -/***************** - * INSTANTIATING * - *****************/ - - - - - - - - - - -/* global arrays of constant names, - * type names (with their constants), - * predicate names, - * predicate aritys, - * defined types of predicate args - */ -extern Token gconstants[MAX_CONSTANTS]; -extern int gnum_constants; -extern Token gtype_names[MAX_TYPES]; -extern int gtype_consts[MAX_TYPES][MAX_TYPE]; -extern Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; -extern int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ -extern int gtype_size[MAX_TYPES]; -extern int gnum_types; -extern Token gpredicates[MAX_PREDICATES]; -extern int garity[MAX_PREDICATES]; -extern Bool gaxiom_added[MAX_PREDICATES]; -extern int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; -extern int gnum_predicates; -extern Token gfunctions[MAX_FUNCTIONS]; -extern int gf_arity[MAX_FUNCTIONS]; -extern int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; -extern int gnum_functions; - - - - -/* the domain in first step integer representation - */ -extern Operator_pointer goperators[MAX_OPERATORS]; -extern int gnum_operators; -extern Fact *gfull_initial; -extern int gnum_full_initial; -extern FluentValue *gfull_fluents_initial; -extern int gnum_full_fluents_initial; -extern WffNode *ggoal; - -extern ExpNode *gmetric; - - - -/* stores inertia - information: is any occurence of the predicate - * added / deleted in the uninstantiated ops ? - */ -extern Bool gis_added[MAX_PREDICATES]; -extern Bool gis_deleted[MAX_PREDICATES]; - -/* for functions we *might* want to say, symmetrically, whether it is - * increased resp. decreased at all. - * - * that is, however, somewhat involved because the right hand - * sides can be arbirtray expressions, so we have no guarantee - * that increasing really does adds to a functions value... - * - * thus (for the time being), we settle for "is the function changed at all?" - */ -extern Bool gis_changed[MAX_FUNCTIONS]; - - - -/* splitted initial state: - * initial non static facts, - * initial static facts, divided into predicates - * (will be two dimensional array, allocated directly before need) - */ -extern Facts *ginitial; -extern int gnum_initial; -extern Fact **ginitial_predicate; -extern int *gnum_initial_predicate; - -/* same thing for functions - */ -extern FluentValues *gf_initial; -extern int gnum_f_initial; -extern FluentValue **ginitial_function; -extern int *gnum_initial_function; - - - -/* the type numbers corresponding to any unary inertia - */ -extern int gtype_to_predicate[MAX_PREDICATES]; -extern int gpredicate_to_type[MAX_TYPES]; - -/* (ordered) numbers of types that new type is intersection of - */ -extern TypeArray gintersected_types[MAX_TYPES]; -extern int gnum_intersected_types[MAX_TYPES]; - - - -/* splitted domain: hard n easy ops - */ -extern Operator_pointer *ghard_operators; -extern int gnum_hard_operators; -extern NormOperator_pointer *geasy_operators; -extern int gnum_easy_operators; - - - -/* so called Templates for easy ops: possible inertia constrained - * instantiation constants - */ -extern EasyTemplate *geasy_templates; -extern int gnum_easy_templates; - - - -/* first step for hard ops: create mixed operators, with conjunctive - * precondition and arbitrary effects - */ -extern MixedOperator *ghard_mixed_operators; -extern int gnum_hard_mixed_operators; - - - -/* hard ''templates'' : pseudo actions - */ -extern PseudoAction_pointer *ghard_templates; -extern int gnum_hard_templates; - - - -/* store the final "relevant facts" - */ -extern Fact grelevant_facts[MAX_RELEVANT_FACTS]; -extern int gnum_relevant_facts; -extern int gnum_pp_facts; -/* store the "relevant fluents" - */ -extern Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; -extern int gnum_relevant_fluents; -extern Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; -/* this is NULL for normal, and the LNF for - * artificial fluents. - */ -extern LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; - - - -/* the final actions and problem representation - */ -extern Action *gactions; -extern int gnum_actions; -extern State ginitial_state; -extern int *glogic_goal; -extern int gnum_logic_goal; -extern Comparator *gnumeric_goal_comp; -extern ExpNode_pointer *gnumeric_goal_lh, *gnumeric_goal_rh; -extern int gnum_numeric_goal; - - - -/* to avoid memory leaks; too complicated to identify - * the exact state of the action to throw away (during construction), - * memory gain not worth the implementation effort. - */ -extern Action *gtrash_actions; - - - -/* additional lnf step between finalized inst and - * conn graph - */ -extern Comparator *glnf_goal_comp; -extern LnfExpNode_pointer *glnf_goal_lh; -extern float *glnf_goal_rh; -extern int gnum_lnf_goal; - -extern LnfExpNode glnf_metric; -extern Bool goptimization_established; - - - -/********************** - * CONNECTIVITY GRAPH * - **********************/ - - - - - -/* one ops (actions) array ... - */ -extern OpConn *gop_conn; -extern int gnum_op_conn; - - - -/* one effects array ... - */ -extern EfConn *gef_conn; -extern int gnum_ef_conn; - - - -/* one facts array. - */ -extern FtConn *gft_conn; -extern int gnum_ft_conn; - - - -/* and: one fluents array. - */ -extern FlConn *gfl_conn; -extern int gnum_fl_conn; -extern int gnum_real_fl_conn;/* number of non-artificial ones */ - - - -/* final goal is also transformed one more step. - */ -extern int *gflogic_goal; -extern int gnum_flogic_goal; -extern Comparator *gfnumeric_goal_comp; -extern int *gfnumeric_goal_fl; -extern float *gfnumeric_goal_c; -extern int gnum_fnumeric_goal; - -/* direct access (by relevant fluents) - */ -extern Comparator *gfnumeric_goal_direct_comp; -extern float *gfnumeric_goal_direct_c; - - - - - - - - - - - - - -/******************* - * SEARCHING NEEDS * - *******************/ - - - - - - - - - - - - -/* applicable actions - */ -extern int *gA;/* non-axioms */ -extern int gnum_A; -extern int *gA_axioms; /* axioms */ -extern int gnum_A_axioms; - - - -/* communication from extract 1.P. to search engine: - * 1P action choice - */ -extern int *gH; -extern int gnum_H; -/* added cost of relaxed plan - */ -extern float gh_cost; -/* hmax value - */ -extern float ghmax; - - - -/* to store plan - */ -extern int gplan_ops[MAX_PLAN_LENGTH]; -extern int gnum_plan_ops; - - - -/* stores the states that the current plan goes through - */ -extern State gplan_states[MAX_PLAN_LENGTH + 1]; - - - -/* dirty: multiplic. of total-time in final metric LNF - */ -extern float gtt; - - - - - - -/* the mneed structures - * - * assign propagation pairs i, j, and transitive such pairs. - */ -extern Bool **gassign_influence; -extern Bool **gTassign_influence; - - - -/* the real var input to the mneed computation. - */ -extern Bool *gmneed_start_D; -extern float *gmneed_start_V; - - - -/* does this contain conditional effects? - * (if it does then the state hashing has to be made more - * cautiously) - */ -extern Bool gconditional_effects; - - -/* easier to question: are we optimizing or no? - */ -extern Bool gcost_minimizing; - - -/* stores current A* weight: this is initially given by user, - * but changes during anytime search. - */ -extern float gw; -/* this is the minimum weight, ie we'll stop once the weight update - * does/would yield a value <= this. - * if no such minim weight is given, this will be -1 - */ -extern float gmin_w; - - -/* this one says whether or not we are actually using - * cost-minimizing rplans. - * this will be the case by default if we're running cost- - * minimizing searches. it can be switched off by a flag; - * it is automatically switched off in case there are - * numeric preconditions/goals: for this case, - * cost-minimizing rplans are not implemented (a numeric prec - * may cause an action to come in "later" on in the RPG although - * its logical pres are easy. in that case, any new effects will - * have a smaller RPGcost value than facts we already have waiting. - * in other words, the "Dijsktra" nature breaks. - * - * ... I suppose there may be a generic solution to this that - * can handle numeric precs/goals. Doesn't seem important enough - * to bother. - */ -extern Bool gcost_rplans; - - -#endif diff --git a/models/main_models/rt1/gen/ff_planner/inst_easy.c b/models/main_models/rt1/gen/ff_planner/inst_easy.c deleted file mode 100644 index db6c1681b..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_easy.c +++ /dev/null @@ -1,1220 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - -/********************************************************************* - * File: inst_easy.c - * Description: functions for multiplying easy operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_easy.h" - - - - - - - - -void build_easy_action_templates( void ) - -{ - - int i, j; - NormOperator *o; - EasyTemplate *t; - - cleanup_easy_domain(); - - if ( gcmd_line.display_info == 110 ) { - printf("\n\ncleaned up easy operators are:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - fflush( stdout ); - } - - encode_easy_unaries_as_types(); - - if ( gcmd_line.display_info == 111 ) { - printf("\n\nunaries encoded easy operators are:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - fflush( stdout ); - } - - multiply_easy_effect_parameters(); - - if ( gcmd_line.display_info == 112 ) { - printf("\n\neffects multiplied easy operators are:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - fflush( stdout ); - } - - multiply_easy_op_parameters(); - - if ( gcmd_line.display_info == 113 ) { - printf("\n\ninertia free easy operators are:"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - printf("\n\n"); - fflush( stdout ); - } - - if ( gcmd_line.display_info == 114 ) { - printf("\n\neasy operator templates are:\n"); - - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - printf("\n\n-----------operator %s:-----------", o->operator->name); - for ( t = geasy_templates; t; t = t->next ) { - if ( t->op != o ) { - continue; - } - printf("\ninst: "); - for ( j = 0; j < o->num_vars; j++ ) { - if ( t->inst_table[j] < 0 ) { - printf("\nuninstantiated param in template! debug me, please\n\n"); - exit( 1 ); - } - printf("x%d = %s", j, gconstants[t->inst_table[j]]); - if ( j < o->num_vars - 1 ) { - printf(", "); - } - } - } - } - fflush( stdout ); - } - -} - - - - - - - - - - - -/********************************* - * EASY DOMAIN CLEANUP FUNCTIONs * - *********************************/ - - - - - - - - - - - -void cleanup_easy_domain( void ) - -{ - - int i, i1, i2, i3, i4, a; - NormOperator *o; - NormEffect *e; - - /* most likely ( for sure ? ) we do not need this function call here, - * as empty types are recognised in translation already. - * - * however, who knows .. ? doesn't need any real computation time anyway. - * - * function DOES make sense after unaries encoding, as artificial types - * might well be empty. - */ - handle_empty_easy_parameters(); - - /* remove identical preconds and effects; - * VERY unlikely that such will get down to here, after all - * the formula preprocessing, but possible (?) in principle. - * takes no computation time. - * - * also, remove effect conditions that are contained in the - * preconditions. - */ - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - i1 = 0; - while ( i1 < o->num_preconds-1 ) { - i2 = i1+1; - while ( i2 < o->num_preconds ) { - if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) { - for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) { - o->preconds[i3].predicate = o->preconds[i3+1].predicate; - for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) { - o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4]; - } - } - o->num_preconds--; - } else { - i2++; - } - } - i1++; - } - - for ( e = o->effects; e; e = e->next ) { - i1 = 0; - while ( i1 < e->num_conditions-1 ) { - i2 = i1+1; - while ( i2 < e->num_conditions ) { - if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) { - for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) { - e->conditions[i3].predicate = e->conditions[i3+1].predicate; - /* here, we can still have equalities. nowhere else. - */ - a = ( e->conditions[i3].predicate < 0 ) ? - 2 : garity[e->conditions[i3].predicate]; - for ( i4 = 0; i4 < a; i4++ ) { - e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4]; - } - } - e->num_conditions--; - } else { - i2++; - } - } - i1++; - } - - i1 = 0; - while ( i1 < e->num_conditions ) { - for ( i2 = 0; i2 < o->num_preconds; i2++ ) { - if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) { - break; - } - } - if ( i2 == o->num_preconds ) { - i1++; - continue; - } - for ( i2 = i1; i2 < e->num_conditions-1; i2++ ) { - e->conditions[i2].predicate = e->conditions[i2+1].predicate; - for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) { - e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3]; - } - } - e->num_conditions--; - } - - i1 = 0; - while ( i1 < e->num_adds-1 ) { - i2 = i1+1; - while ( i2 < e->num_adds ) { - if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) { - for ( i3 = i2; i3 < e->num_adds-1; i3++ ) { - e->adds[i3].predicate = e->adds[i3+1].predicate; - for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) { - e->adds[i3].args[i4] = e->adds[i3+1].args[i4]; - } - } - e->num_adds--; - } else { - i2++; - } - } - i1++; - } - - i1 = 0; - while ( i1 < e->num_dels-1 ) { - i2 = i1+1; - while ( i2 < e->num_dels ) { - if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) { - for ( i3 = i2; i3 < e->num_dels-1; i3++ ) { - e->dels[i3].predicate = e->dels[i3+1].predicate; - for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) { - e->dels[i3].args[i4] = e->dels[i3+1].args[i4]; - } - } - e->num_dels--; - } else { - i2++; - } - } - i1++; - } - } - } - -} - - - -Bool identical_fact( Fact *f1, Fact *f2 ) - -{ - - int i, a; - - if ( f1->predicate != f2->predicate ) { - return FALSE; - } - - a = ( f1->predicate < 0 ) ? 2 : garity[f1->predicate]; - - for ( i = 0; i < a; i++ ) { - if ( f1->args[i] != f2->args[i] ) { - return FALSE; - } - } - - return TRUE; - -} - - - -/* this one needs ONLY be used after unaries encoding, as all empty types - * are already recognised during translation, except the artificial ones, - * of course. - */ -void handle_empty_easy_parameters( void ) - -{ - - int i, j, k; - NormOperator *o; - NormEffect *e, *tmp; - - i = 0; - while ( i < gnum_easy_operators ) { - o = geasy_operators[i]; - - for ( j = 0; j < o->num_vars; j++ ) { - if ( gtype_size[o->var_types[j]] == 0 ) { - break; - } - } - if ( j < o->num_vars ) { - free_NormOperator( o ); - for ( k = i; k < gnum_easy_operators - 1; k++ ) { - geasy_operators[k] = geasy_operators[k+1]; - } - gnum_easy_operators--; - } else { - i++; - } - } - - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - e = o->effects; - while ( e ) { - for ( j = 0; j < e->num_vars; j++ ) { - if ( gtype_size[e->var_types[j]] == 0 ) { - break; - } - } - if ( j < e->num_vars ) { - if ( e->prev ) { - e->prev->next = e->next; - } else { - o->effects = e->next; - } - if ( e->next ) { - e->next->prev = e->prev; - } - tmp = e->next; - free_single_NormEffect( e ); - e = tmp; - } else { - e = e->next; - } - } - } - -} - - - - - - - - - - -/**************************** - * UNARY INERTIA INTO TYPES * - ****************************/ - - - - - - - - - - - - -void encode_easy_unaries_as_types( void ) - -{ - - NormOperator *o; - int i1, i, j, k, l, new_T, p, a; - TypeArray T; - int num_T; - NormEffect *e; - int intersected_type, var; - - for ( i1 = 0; i1 < gnum_easy_operators; i1++ ) { - o = geasy_operators[i1]; - - for ( i = 0; i < o->num_vars; i++ ) { - - T[0] = o->var_types[i]; - num_T = 1; - - j = 0; - while ( j < o->num_preconds ) { - p = o->preconds[j].predicate; - if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && - ( o->preconds[j].args[0] == ENCODE_VAR( i ) ) ) { - if ( num_T == MAX_TYPE_INTERSECTIONS ) { - printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", - MAX_TYPE_INTERSECTIONS); - exit( 1 ); - } - /* insert new type number into ordered array T; - * ---- all type numbers in T are different: - * new nr. is of inferred type - can't be type declared for param - * precondition facts occur at most once - doubles are removed - * during cleanup - */ - for ( k = 0; k < num_T; k++ ) { - if ( new_T < T[k] ) { - break; - } - } - for ( l = num_T; l > k; l-- ) { - T[l] = T[l-1]; - } - T[k] = new_T; - num_T++; - /* now remove superfluous precondition - */ - for ( k = j; k < o->num_preconds-1; k++ ) { - o->preconds[k].predicate = o->preconds[k+1].predicate; - for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { - o->preconds[k].args[l] = o->preconds[k+1].args[l]; - } - } - o->num_preconds--; - } else { - j++; - } - } - - /* if we did not hit any unary inertia concerning this parameter - * in the preconds, skip parameter and go to next one - */ - if ( num_T == 1 ) { - continue; - } - - /* now we have the ordered array of types to intersect for param i - * of op o in array T of size num_T; - * if there already is this intersected type, set type of this - * param to its number, otherwise create the new intersected type. - */ - if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { - /* type already there - */ - o->var_types[i] = intersected_type; - continue; - } - - /* create new type - */ - o->var_types[i] = create_intersected_type( T, num_T ); - } - - for ( e = o->effects; e; e = e->next ) { - for ( i = 0; i < e->num_vars; i++ ) { - T[0] = e->var_types[i]; - var = o->num_vars + i; - num_T = 1; - j = 0; - while ( j < e->num_conditions ) { - p = e->conditions[j].predicate; - if ( p < 0 ) { - j++; - continue; - } - if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && - ( e->conditions[j].args[0] == ENCODE_VAR( var ) ) ) { - if ( num_T == MAX_TYPE_INTERSECTIONS ) { - printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", - MAX_TYPE_INTERSECTIONS); - exit( 1 ); - } - for ( k = 0; k < num_T; k++ ) { - if ( new_T < T[k] ) { - break; - } - } - for ( l = num_T; l > k; l-- ) { - T[l] = T[l-1]; - } - T[k] = new_T; - num_T++; - for ( k = j; k < e->num_conditions-1; k++ ) { - e->conditions[k].predicate = e->conditions[k+1].predicate; - a = ( e->conditions[k].predicate < 0 ) ? - 2 : garity[e->conditions[k].predicate]; - for ( l = 0; l < a; l++ ) { - e->conditions[k].args[l] = e->conditions[k+1].args[l]; - } - } - e->num_conditions--; - } else { - j++; - } - } - if ( num_T == 1 ) { - continue; - } - if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { - e->var_types[i] = intersected_type; - continue; - } - e->var_types[i] = create_intersected_type( T, num_T ); - } - } - } - - handle_empty_easy_parameters(); - -} - - - -int create_intersected_type( TypeArray T, int num_T ) - -{ - - int i, j, k, intersected_type; - - if ( gnum_types == MAX_TYPES ) { - printf("\ntoo many (inferred and intersected) types! increase MAX_TYPES (currently %d)\n\n", - MAX_TYPES); - exit( 1 ); - } - gtype_names[gnum_types] = NULL; - gtype_size[gnum_types] = 0; - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - gis_member[i][gnum_types] = FALSE; - } - for ( i = 0; i < num_T; i++ ) { - gintersected_types[gnum_types][i] = T[i]; - } - gnum_intersected_types[gnum_types] = num_T; - intersected_type = gnum_types; - gnum_types++; - - for ( j = 0; j < gtype_size[T[0]]; j++ ) { - for ( k = 1; k < num_T; k++ ) { - if ( !gis_member[gtype_consts[T[0]][j]][T[k]] ) { - break; - } - } - if ( k < num_T ) { - continue; - } - /* add constant to new type - */ - if ( gtype_size[intersected_type] == MAX_TYPE ) { - printf("\ntoo many consts in intersected type! increase MAX_TYPE (currently %d)\n\n", - MAX_TYPE); - exit( 1 ); - } - gtype_consts[intersected_type][gtype_size[intersected_type]++] = gtype_consts[T[0]][j]; - gis_member[gtype_consts[T[0]][j]][intersected_type] = TRUE; - } - - /* now verify if the intersected type equals one of the types that we intersected. - * this is the case, iff one of the types in T has the same size as intersected_type - */ - for ( j = 0; j < num_T; j++ ) { - if ( gtype_size[intersected_type] != gtype_size[T[j]] ) { - continue; - } - /* type T[j] contains exactly the constants that we need! - * - * remove intersected type from table! - */ - gtype_size[intersected_type] = 0; - for ( k = 0; k < MAX_CONSTANTS; k++ ) { - gis_member[k][intersected_type] = FALSE; - } - gnum_intersected_types[intersected_type] = -1; - gnum_types--; - intersected_type = T[j]; - break; - } - - return intersected_type; - -} - - - -int find_intersected_type( TypeArray T, int num_T ) - -{ - - int i, j; - - for ( i = 0; i < gnum_types; i++ ) { - if ( gnum_intersected_types[i] == -1 ) { - continue; - } - - if ( gnum_intersected_types[i] != num_T ) { - continue; - } - - for ( j = 0; j < num_T; j++ ) { - if ( T[j] != gintersected_types[i][j] ) { - break; - } - } - if ( j < num_T ) { - continue; - } - - return i; - } - - return -1; - -} - - - - - - - - - - - - - - -/****************************** - * MULTIPLY EFFECT PARAMETERS * - ******************************/ - - - - - - - - - - - - -/* local globals for multiplying - */ - -int linertia_conds[MAX_VARS]; -int lnum_inertia_conds; - -int lmultiply_parameters[MAX_VARS]; -int lnum_multiply_parameters; - -NormOperator *lo; -NormEffect *le; - -NormEffect *lres; - - - - - - -void multiply_easy_effect_parameters( void ) - -{ - - int i, j, k, l, p, par; - NormEffect *e; - - for ( i = 0; i < gnum_easy_operators; i++ ) { - lo = geasy_operators[i]; - - lres = NULL; - for ( e = lo->effects; e; e = e->next ) { - le = e; - - lnum_inertia_conds = 0; - for ( j = 0; j < e->num_conditions; j++ ) { - for ( k = 0; k < garity[e->conditions[j].predicate]; k++ ) { - if ( e->conditions[j].args[k] < 0 && - DECODE_VAR( e->conditions[j].args[k] ) < lo->num_vars ) { - break; - } - } - if ( k < garity[e->conditions[j].predicate] ) { - /* only consider inertia constraining effect parameters - */ - continue; - } - if ( !gis_added[e->conditions[j].predicate] && - !gis_deleted[e->conditions[j].predicate] ) { - linertia_conds[lnum_inertia_conds++] = j; - } - } - - lnum_multiply_parameters = 0; - for ( j = 0; j < e->num_vars; j++ ) { - par = lo->num_vars + j; - for ( k = 0; k < lnum_inertia_conds; k++ ) { - p = e->conditions[linertia_conds[k]].predicate; - for ( l = 0; l < garity[p]; l++ ) { - if ( e->conditions[linertia_conds[k]].args[l] == - ENCODE_VAR( par ) ) { - break; - } - } - if ( l < garity[p] ) { - break; - } - } - if ( k < lnum_inertia_conds ) { - continue; - } - lmultiply_parameters[lnum_multiply_parameters++] = j; - } - - unify_easy_inertia_conditions( 0 ); - } - free_NormEffect( lo->effects ); - lo->effects = lres; - } - -} - - - -void unify_easy_inertia_conditions( int curr_inertia ) - -{ - - int p, i, j, af, hh; - int args[MAX_VARS]; - int affected_params[MAX_VARS]; - int num_affected_params = 0; - - if ( curr_inertia == lnum_inertia_conds ) { - multiply_easy_non_constrained_effect_parameters( 0 ); - return; - } - - p = le->conditions[linertia_conds[curr_inertia]].predicate; - for ( i = 0; i < garity[p]; i++ ) { - args[i] = le->conditions[linertia_conds[curr_inertia]].args[i]; - if ( args[i] < 0 ) { - hh = DECODE_VAR( args[i] ); - hh -= lo->num_vars; - if ( le->inst_table[hh] != -1 ) { - args[i] = le->inst_table[hh]; - } else { - affected_params[num_affected_params++] = hh; - } - } - } - - for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { - af = 0; - for ( j = 0; j < garity[p]; j++ ) { - if ( args[j] >= 0 ) { - if ( args[j] != ginitial_predicate[p][i].args[j] ) { - break; - } else { - continue; - } - } - le->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; - } - if ( j < garity[p] ) { - continue; - } - - unify_easy_inertia_conditions( curr_inertia + 1 ); - } - - for ( i = 0; i < num_affected_params; i++ ) { - le->inst_table[affected_params[i]] = -1; - } - -} - - - -void multiply_easy_non_constrained_effect_parameters( int curr_parameter ) - -{ - - int t, n, i, j, k, p, par; - NormEffect *tmp; - Bool rem; - - if ( curr_parameter == lnum_multiply_parameters ) { - /* create new effect, adjusting conds to inst, and - * partially instantiating effects; - * - * add result to lres - */ - tmp = new_NormEffect2( le ); - - /* instantiate param occurences - */ - for ( i = 0; i < le->num_vars; i++ ) { - par = lo->num_vars + i; - - /* numerical part - */ - for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { - replace_var_with_const_in_exp( &(tmp->numeric_conditions_lh[j]), - par, le->inst_table[i] ); - } - for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { - replace_var_with_const_in_exp( &(tmp->numeric_conditions_rh[j]), - par, le->inst_table[i] ); - } - /* was that already enough to get numbers? if yes, - * see whether comparison holds or not. - */ - j = 0; - while ( j < tmp->num_numeric_conditions ) { - if ( tmp->numeric_conditions_lh[j]->connective == NUMBER && - tmp->numeric_conditions_rh[j]->connective == NUMBER ) { - if ( number_comparison_holds( tmp->numeric_conditions_comp[j], - tmp->numeric_conditions_lh[j]->value, - tmp->numeric_conditions_rh[j]->value ) ) { - free_ExpNode( tmp->numeric_conditions_lh[j] ); - free_ExpNode( tmp->numeric_conditions_rh[j] ); - for ( k = j; k < tmp->num_numeric_conditions-1; k++ ) { - tmp->numeric_conditions_comp[k] = tmp->numeric_conditions_comp[k+1]; - tmp->numeric_conditions_lh[k] = tmp->numeric_conditions_lh[k+1]; - tmp->numeric_conditions_rh[k] = tmp->numeric_conditions_rh[k+1]; - } - tmp->num_numeric_conditions--; - } else { - free_NormEffect( tmp ); - return; - } - } else { - j++; - } - } - for ( j = 0; j < tmp->num_numeric_effects; j++ ) { - for ( k = 0; k < gf_arity[tmp->numeric_effects_fluent[j].function]; k++ ) { - if ( tmp->numeric_effects_fluent[j].args[k] == ENCODE_VAR( par ) ) { - tmp->numeric_effects_fluent[j].args[k] = le->inst_table[i]; - } - } - } - for ( j = 0; j < tmp->num_numeric_effects; j++ ) { - replace_var_with_const_in_exp( &(tmp->numeric_effects_rh[j]), - par, le->inst_table[i] ); - } - - /* logical part - */ - for ( j = 0; j < tmp->num_conditions; j++ ) { - for ( k = 0; k < garity[tmp->conditions[j].predicate]; k++ ) { - if ( tmp->conditions[j].args[k] == ENCODE_VAR( par ) ) { - tmp->conditions[j].args[k] = le->inst_table[i]; - } - } - } - for ( j = 0; j < tmp->num_adds; j++ ) { - for ( k = 0; k < garity[tmp->adds[j].predicate]; k++ ) { - if ( tmp->adds[j].args[k] == ENCODE_VAR( par ) ) { - tmp->adds[j].args[k] = le->inst_table[i]; - } - } - } - for ( j = 0; j < tmp->num_dels; j++ ) { - for ( k = 0; k < garity[tmp->dels[j].predicate]; k++ ) { - if ( tmp->dels[j].args[k] == ENCODE_VAR( par ) ) { - tmp->dels[j].args[k] = le->inst_table[i]; - } - } - } - } - /* adjust conditions - */ - i = 0; - while ( i < tmp->num_conditions ) { - rem = FALSE; - p = tmp->conditions[i].predicate; - if ( !gis_added[p] && - !gis_deleted[p] ) { - for ( j = 0; j < garity[p]; j++ ) { - if ( tmp->conditions[i].args[j] < 0 && - DECODE_VAR( tmp->conditions[i].args[j] < lo->num_vars ) ) { - break; - } - } - if ( j == garity[p] ) { - /* inertia that constrain only effect params have been unified, - * are therefore TRUE - */ - rem = TRUE; - } - } - if ( rem ) { - for ( j = i; j < tmp->num_conditions - 1; j++ ) { - tmp->conditions[j].predicate = tmp->conditions[j+1].predicate; - for ( k = 0; k < garity[tmp->conditions[j+1].predicate]; k++ ) { - tmp->conditions[j].args[k] = tmp->conditions[j+1].args[k]; - } - } - tmp->num_conditions--; - } else { - i++; - } - } - /* add result to lres - */ - if ( lres ) { - lres->prev = tmp; - } - tmp->next = lres; - lres = tmp; - return; - } - - t = le->var_types[lmultiply_parameters[curr_parameter]]; - n = gtype_size[t]; - - for ( i = 0; i < n; i++ ) { - le->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; - multiply_easy_non_constrained_effect_parameters( curr_parameter + 1 ); - } - - le->inst_table[lmultiply_parameters[curr_parameter]] = -1; - -} - - - - - - - - - - - - - - - - - - - -/************************** - * MULTIPLY OP PARAMETERS * - **************************/ - - - - - - - - - - - - - - -/* Bool bla; */ - - - - -void multiply_easy_op_parameters( void ) - -{ - - int i, j, k, l, p; - NormOperator *o; - - geasy_templates = NULL; - gnum_easy_templates = 0; - - for ( i = 0; i < gnum_easy_operators; i++ ) { - lo = geasy_operators[i]; -/* if ( strcmp(lo->operator->name, "PORT445_WIN2000") == 0 ) { */ -/* printf("\nmultiply easy OP: %s", lo->operator->name); */ -/* bla = TRUE; */ -/* } else { */ -/* bla = FALSE; */ -/* } */ - - lnum_inertia_conds = 0; - for ( j = 0; j < lo->num_preconds; j++ ) { - if ( !gis_added[lo->preconds[j].predicate] && - !gis_deleted[lo->preconds[j].predicate] ) { - linertia_conds[lnum_inertia_conds++] = j; -/* if ( bla ) { */ -/* printf("\n:inertia cond: %d (pred %s)", j, gpredicates[lo->preconds[j].predicate]); */ -/* fflush(stdout); */ -/* } */ - } - } - - - lnum_multiply_parameters = 0; - for ( j = 0; j < lo->num_vars; j++ ) { - for ( k = 0; k < lnum_inertia_conds; k++ ) { - p = lo->preconds[linertia_conds[k]].predicate; - for ( l = 0; l < garity[p]; l++ ) { - if ( lo->preconds[linertia_conds[k]].args[l] == - ENCODE_VAR( j ) ) { - break; - } - } - if ( l < garity[p] ) { - break; - } - } - if ( k < lnum_inertia_conds ) { - continue; - } -/* if ( bla ) { */ -/* printf("\nmultiply parameter: %d", j); */ -/* fflush(stdout); */ -/* } */ - lmultiply_parameters[lnum_multiply_parameters++] = j; - } - - unify_easy_inertia_preconds( 0 ); - } - - /* now remove inertia preconditions from operator schemata - */ - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - j = 0; - while ( j < o->num_preconds ) { - if ( !gis_added[o->preconds[j].predicate] && - !gis_deleted[o->preconds[j].predicate] ) { - for ( k = j; k < o->num_preconds - 1; k++ ) { - o->preconds[k].predicate = o->preconds[k+1].predicate; - for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { - o->preconds[k].args[l] = o->preconds[k+1].args[l]; - } - } - o->num_preconds--; - } else { - j++; - } - } - } - -} - - - -void unify_easy_inertia_preconds( int curr_inertia ) - -{ - - int p, i, j, af, hh; - int args[MAX_VARS]; - int affected_params[MAX_VARS]; - int num_affected_params = 0; - - if ( curr_inertia == lnum_inertia_conds ) { - multiply_easy_non_constrained_op_parameters( 0 ); - return; - } - - p = lo->preconds[linertia_conds[curr_inertia]].predicate; - for ( i = 0; i < garity[p]; i++ ) { - args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i]; - if ( args[i] < 0 ) { - hh = DECODE_VAR( args[i] ); - if ( lo->inst_table[hh] != -1 ) { - args[i] = lo->inst_table[hh]; - } else { - affected_params[num_affected_params++] = hh; - } - } - } - - for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { - af = 0; - for ( j = 0; j < garity[p]; j++ ) { - if ( args[j] >= 0 ) { - if ( args[j] != ginitial_predicate[p][i].args[j] ) { - break; - } else { - continue; - } - } - /* check whether that constant has the correct type for that - * parameter (can be not fulfilled due to encoding of unary inertia - */ - if ( !gis_member[ginitial_predicate[p][i].args[j]][lo->var_types[affected_params[af]]] ) { - break; - } - /* legal constant; set op parameter instantiation to it - */ - lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; - } - if ( j < garity[p] ) { - continue; - } - - unify_easy_inertia_preconds( curr_inertia + 1 ); - } - - for ( i = 0; i < num_affected_params; i++ ) { - lo->inst_table[affected_params[i]] = -1; - } - -} - - - -void multiply_easy_non_constrained_op_parameters( int curr_parameter ) - -{ - - EasyTemplate *tmp; - int i, j, t, n; - -/* if ( bla ) { */ -/* printf("\nEntry multiply!"); */ -/* fflush(stdout); */ -/* } */ - - if ( curr_parameter == lnum_multiply_parameters ) { - tmp = new_EasyTemplate( lo ); - for ( i = 0; i < lo->num_vars; i++ ) { - tmp->inst_table[i] = lo->inst_table[i]; - } - tmp->next = geasy_templates; - if ( geasy_templates ) { - geasy_templates->prev = tmp; - } - geasy_templates = tmp; - gnum_easy_templates++; - return; - } - - if ( curr_parameter == lnum_multiply_parameters - 1 ) { -/* if ( bla ) { */ -/* printf("\nEntry 1 missing!"); */ -/* fflush(stdout); */ -/* } */ - t = lo->var_types[lmultiply_parameters[curr_parameter]]; - n = gtype_size[t]; - for ( i = 0; i < n; i++ ) { - lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; - -/* if ( bla ) { */ -/* printf("\nmaking instance (numvars %d):", lo->num_vars); */ -/* fflush(stdout); */ -/* } */ - tmp = new_EasyTemplate( lo ); - for ( j = 0; j < lo->num_vars; j++ ) { - tmp->inst_table[j] = lo->inst_table[j]; -/* if ( bla ) { */ -/* printf("%s (ID %d), ", gconstants[tmp->inst_table[j]], tmp->inst_table[j]); */ -/* fflush(stdout); */ -/* } */ - } - tmp->next = geasy_templates; - if ( geasy_templates ) { - geasy_templates->prev = tmp; - } - geasy_templates = tmp; - gnum_easy_templates++; - } - - lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; - - return; - } - - t = lo->var_types[lmultiply_parameters[curr_parameter]]; - n = gtype_size[t]; - for ( i = 0; i < n; i++ ) { - lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; - - multiply_easy_non_constrained_op_parameters( curr_parameter + 1 ); - } - - lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; - -} diff --git a/models/main_models/rt1/gen/ff_planner/inst_easy.h b/models/main_models/rt1/gen/ff_planner/inst_easy.h deleted file mode 100644 index 1bc6eb1db..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_easy.h +++ /dev/null @@ -1,73 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - - - -/********************************************************************* - * File: inst_easy.h - * Description: headers for multiplying easy operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - -#ifndef _INST_EASY_H -#define _INST_EASY_H - - - -void build_easy_action_templates( void ); - - - -void cleanup_easy_domain( void ); -Bool identical_fact( Fact *f1, Fact *f2 ); -void handle_empty_easy_parameters( void ); - - - -void encode_easy_unaries_as_types( void ); -int create_intersected_type( TypeArray T, int num_T ); -int find_intersected_type( TypeArray T, int num_T ); - - - -void multiply_easy_effect_parameters( void ); -void unify_easy_inertia_conditions( int curr_inertia ); -void multiply_easy_non_constrained_effect_parameters( int curr_parameter ); - - - -void multiply_easy_op_parameters( void ); -void unify_easy_inertia_preconds( int curr_inertia ); -void multiply_easy_non_constrained_op_parameters( int curr_parameter ); - - - -#endif /* _INST_EASY_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_final.c b/models/main_models/rt1/gen/ff_planner/inst_final.c deleted file mode 100644 index 3f51a89e6..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_final.c +++ /dev/null @@ -1,2797 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/********************************************************************* - * File: inst_final.c - * Description: final domain representation functions - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_final.h" - - - - - - - - - - - - - - -/******************************** - * POSSIBLY TRUE FACTS ANALYSIS * - ********************************/ - - - - - - - - -/* local globals for this part - */ - -int_pointer lpos[MAX_PREDICATES]; -int_pointer lneg[MAX_PREDICATES]; -int_pointer luse[MAX_PREDICATES]; -int_pointer lindex[MAX_PREDICATES]; - -int lp; -int largs[MAX_VARS]; - - - -/* for collecting poss. defined fluents - */ -int_pointer lf_def[MAX_FUNCTIONS]; -int_pointer lf_index[MAX_FUNCTIONS]; - -int lf; -int lf_args[MAX_VARS]; - - - - - - -void perform_reachability_analysis( void ) - -{ - - int size, i, j, k, adr, num, pargtype; - Bool fixpoint; - Facts *f; - NormOperator *no; - EasyTemplate *t1, *t2; - NormEffect *ne; - Action *tmp, *a; - Bool *had_hard_template; - PseudoAction *pa; - PseudoActionEffect *pae; - - gactions = NULL; - gnum_actions = 0; - - for ( i = 0; i < gnum_predicates; i++ ) { - size = 1; - for ( j = 0; j < garity[i]; j++ ) { - pargtype = gpredicates_args_type[i][j]; - size *= gtype_size[pargtype]; - } - - lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - luse[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - - for ( j = 0; j < size; j++ ) { - lpos[i][j] = 0; - lneg[i][j] = 1;/* all facts but initials are poss. negative */ - luse[i][j] = 0; - lindex[i][j] = -1; - } - } - - had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) ); - for ( i = 0; i < gnum_hard_templates; i++ ) { - had_hard_template[i] = FALSE; - } - - /* mark initial facts as possibly positive, not poss. negative - */ - for ( i = 0; i < gnum_predicates; i++ ) { - lp = i; - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - for ( k = 0; k < garity[i]; k++ ) { - largs[k] = ginitial_predicate[i][j].args[k]; - } - adr = fact_adress(); - lpos[lp][adr] = 1; - lneg[lp][adr] = 0; - } - } - - /* compute fixpoint - */ - fixpoint = FALSE; - while ( !fixpoint ) { - fixpoint = TRUE; - - /* assign next layer of easy templates to possibly positive fixpoint - */ - t1 = geasy_templates; - while ( t1 ) { - no = t1->op; - for ( i = 0; i < no->num_preconds; i++ ) { - lp = no->preconds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( no->preconds[i].args[j] >= 0 ) ? - no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; - } - if ( !lpos[lp][fact_adress()] ) { - break; - } - } - - if ( i < no->num_preconds ) { - t1 = t1->next; - continue; - } - - num = 0; - for ( ne = no->effects; ne; ne = ne->next ) { - num++; - /* currently, simply ignore effect conditions and assume - * they will all be made true eventually. - */ - for ( i = 0; i < ne->num_adds; i++ ) { - lp = ne->adds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->adds[i].args[j] >= 0 ) ? - ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) { - /* new relevant fact! (added non initial) - */ - lpos[lp][adr] = 1; - lneg[lp][adr] = 1; - luse[lp][adr] = 1; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( j = 0; j < garity[lp]; j++ ) { - grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - fixpoint = FALSE; - } - } - } - - tmp = new_Action(); - tmp->norm_operator = no; - tmp->axiom = no->operator->axiom; - for ( i = 0; i < no->num_vars; i++ ) { - tmp->inst_table[i] = t1->inst_table[i]; - } - tmp->name = no->operator->name; - tmp->num_name_vars = no->operator->number_of_real_params; - make_name_inst_table_from_NormOperator( tmp, no, t1 ); - tmp->next = gactions; - tmp->num_effects = num; - gactions = tmp; - gnum_actions++; - - t2 = t1->next; - if ( t1->next ) { - t1->next->prev = t1->prev; - } - if ( t1->prev ) { - t1->prev->next = t1->next; - } else { - geasy_templates = t1->next; - } - free_single_EasyTemplate( t1 ); - t1 = t2; - } - - /* now assign all hard templates that have not been transformed - * to actions yet. - */ - for ( i = 0; i < gnum_hard_templates; i++ ) { - if ( had_hard_template[i] ) { - continue; - } - pa = ghard_templates[i]; - - for ( j = 0; j < pa->num_preconds; j++ ) { - lp = pa->preconds[j].predicate; - for ( k = 0; k < garity[lp]; k++ ) { - largs[k] = pa->preconds[j].args[k]; - } - if ( !lpos[lp][fact_adress()] ) { - break; - } - } - - if ( j < pa->num_preconds ) { - continue; - } - - for ( pae = pa->effects; pae; pae = pae->next ) { - /* currently, simply ignore effect conditions and assume - * they will all be made true eventually. - */ - for ( j = 0; j < pae->num_adds; j++ ) { - lp = pae->adds[j].predicate; - for ( k = 0; k < garity[lp]; k++ ) { - largs[k] = pae->adds[j].args[k]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) { - /* new relevant fact! (added non initial) - */ - lpos[lp][adr] = 1; - lneg[lp][adr] = 1; - luse[lp][adr] = 1; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( k = 0; k < garity[lp]; k++ ) { - grelevant_facts[gnum_relevant_facts].args[k] = largs[k]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - fixpoint = FALSE; - } - } - } - - tmp = new_Action(); - tmp->pseudo_action = pa; - tmp->axiom = pa->operator->axiom; - for ( j = 0; j < pa->operator->num_vars; j++ ) { - tmp->inst_table[j] = pa->inst_table[j]; - } - tmp->name = pa->operator->name; - tmp->num_name_vars = pa->operator->number_of_real_params; - make_name_inst_table_from_PseudoAction( tmp, pa ); - tmp->next = gactions; - tmp->num_effects = pa->num_effects; - gactions = tmp; - gnum_actions++; - - had_hard_template[i] = TRUE; - } - } - - free( had_hard_template ); - - gnum_pp_facts = gnum_initial + gnum_relevant_facts; - - if ( gcmd_line.display_info == 118 ) { - printf("\nreachability analysys came up with:"); - - printf("\n\npossibly positive facts:"); - for ( f = ginitial; f; f = f->next ) { - printf("\n"); - print_Fact( f->fact ); - } - for ( i = 0; i < gnum_relevant_facts; i++ ) { - printf("\n"); - print_Fact( &(grelevant_facts[i]) ); - } - - printf("\n\nthis yields these %d action templates:", gnum_actions); - for ( i = 0; i < gnum_operators; i++ ) { - printf("\n\noperator %s:", goperators[i]->name); - for ( a = gactions; a; a = a->next ) { - if ( ( a->norm_operator && - a->norm_operator->operator != goperators[i] ) || - ( a->pseudo_action && - a->pseudo_action->operator != goperators[i] ) ) { - continue; - } - printf("\ntemplate: "); - if ( a->axiom ) printf("(axiom) "); - for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) { - printf("%s", gconstants[a->name_inst_table[j]]); - if ( j < goperators[i]->num_vars-1 ) { - printf(" "); - } - } - } - } - printf("\n\n"); - } - -} - - - -/* bit complicated to avoid memory explosion when high arity predicates take - * num_obs ^ arity space. take space for individual arg types only; - * must consider pred args in smallest - to - largest - type order to make - * mapping injective. - */ -int fact_adress( void ) - -{ - - int r = 0, b = 1, i, j, min, minj; - Bool done[MAX_ARITY]; - - for ( i = 0; i < garity[lp]; i++ ) { - done[i] = FALSE; - } - - for ( i = 0; i < garity[lp]; i++ ) { - min = -1; - minj = -1; - for ( j = 0; j < garity[lp]; j++ ) { - if ( !done[j] ) { - if ( min == -1 || - gtype_size[gpredicates_args_type[lp][j]] < min ) { - min = gtype_size[gpredicates_args_type[lp][j]]; - minj = j; - } - } - } - if ( minj == -1 || min == -1 ) { - printf("\n\nmin or minj not made in fact adress?\n\n"); - exit( 1 ); - } - /* now minj is remaining arg with lowest type size min - */ - /* need number **within type** here! */ - r += b * gmember_nr[largs[minj]][gpredicates_args_type[lp][minj]]; - b *= min; - done[minj] = TRUE; - } - - return r; - -} - - - -int fluent_adress( void ) - -{ - - int r = 0, b = 1, i; - - for ( i = gf_arity[lf] - 1; i > -1; i-- ) { - r += b * lf_args[i]; - b *= gnum_constants; - } - - return r; - -} - - - -void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ) - -{ - - int i, r = 0, m = 0; - - for ( i = 0; i < o->operator->number_of_real_params; i++ ) { - if ( o->num_removed_vars > r && - o->removed_vars[r] == i ) { - /* this var has been removed in NormOp; - * insert type constraint constant - * - * at least one there, as empty typed pars ops are removed - */ - a->name_inst_table[i] = gtype_consts[o->type_removed_vars[r]][0]; - r++; - } else { - /* this par corresponds to par m in NormOp - */ - a->name_inst_table[i] = t->inst_table[m]; - m++; - } - } - -} - - - -void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ) - -{ - - int i; - - for ( i = 0; i < pa->operator->number_of_real_params; i++ ) { - a->name_inst_table[i] = pa->inst_table[i]; - } - -} - - - - - - - - - - - - - - - - - - -/*********************************************************** - * RELEVANCE ANALYSIS AND FINAL DOMAIN AND PROBLEM CLEANUP * - ***********************************************************/ - - - - - - - - - -/* counts effects for later allocation - */ -int lnum_effects; - - - - - - - - - -void collect_relevant_facts_and_fluents( void ) - -{ - - Action *a; - NormOperator *no; - NormEffect *ne; - int i, j, adr, size; - PseudoAction *pa; - PseudoActionEffect *pae; - FluentValues *fvs; - - /* facts: mark all deleted facts; such facts, that are also pos, are relevant. - */ - for ( a = gactions; a; a = a->next ) { - if ( a->norm_operator ) { - no = a->norm_operator; - - for ( ne = no->effects; ne; ne = ne->next ) { - for ( i = 0; i < ne->num_dels; i++ ) { - lp = ne->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->dels[i].args[j] >= 0 ) ? - ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; - } - adr = fact_adress(); - - lneg[lp][adr] = 1; - if ( lpos[lp][adr] && - !luse[lp][adr] ) { - luse[lp][adr] = 1; - lindex[lp][adr] = gnum_relevant_facts; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( j = 0; j < garity[lp]; j++ ) { - grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - } - } - } - } else { - pa = a->pseudo_action; - - for ( pae = pa->effects; pae; pae = pae->next ) { - for ( i = 0; i < pae->num_dels; i++ ) { - lp = pae->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->dels[i].args[j]; - } - adr = fact_adress(); - - lneg[lp][adr] = 1; - if ( lpos[lp][adr] && - !luse[lp][adr] ) { - luse[lp][adr] = 1; - lindex[lp][adr] = gnum_relevant_facts; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( j = 0; j < garity[lp]; j++ ) { - grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - } - } - } - } - } - /* fluents: collect all that are defined in initial state, plus - * all that are assigned to by an effect of an action - * (i.e. preconds poss. pos. due to reachability) - * - * first initialise fast access structures - */ - for ( i = 0; i < gnum_functions; i++ ) { - size = 1; - for ( j = 0; j < gf_arity[i]; j++ ) { - size *= gnum_constants; - } - lf_def[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - lf_index[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - for ( j = 0; j < size; j++ ) { - lf_def[i][j] = 0; - lf_index[i][j] = -1; - } - } - /* from initial state, only those that are not static. - */ - for ( fvs = gf_initial; fvs; fvs = fvs->next ) { - lf = fvs->fluent.function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = fvs->fluent.args[j]; - } - adr = fluent_adress(); - if ( !lf_def[lf][adr] ) { - lf_def[lf][adr] = 1; - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = lf; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); - for ( j = 0; j < gf_arity[lf]; j++ ) { - grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; - strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); - } - lf_index[lf][adr] = gnum_relevant_fluents; - gnum_relevant_fluents++; - } else { - printf("\n\nfluent "); - print_Fluent( &(fvs->fluent) ); - printf(" defined twice in initial state! check input files\n\n"); - exit( 1 ); - } - } - /* from actions, all assigns (are non-static anyway) - */ - for ( a = gactions; a; a = a->next ) { - if ( a->norm_operator ) { - no = a->norm_operator; - for ( ne = no->effects; ne; ne = ne->next ) { - for ( i = 0; i < ne->num_numeric_effects; i++ ) { - if ( ne->numeric_effects_neft[i] != ASSIGN ) continue; - lf = ne->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? - ne->numeric_effects_fluent[i].args[j] : - a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; - } - adr = fluent_adress(); - if ( !lf_def[lf][adr] ) { - lf_def[lf][adr] = 1; - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = lf; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); - for ( j = 0; j < gf_arity[lf]; j++ ) { - grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; - strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); - } - lf_index[lf][adr] = gnum_relevant_fluents; - gnum_relevant_fluents++; - } - } - } - } else { - pa = a->pseudo_action; - for ( pae = pa->effects; pae; pae = pae->next ) { - for ( i = 0; i < pae->num_numeric_effects; i++ ) { - if ( pae->numeric_effects_neft[i] != ASSIGN ) continue; - lf = pae->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = ( pae->numeric_effects_fluent[i].args[j] >= 0 ) ? - pae->numeric_effects_fluent[i].args[j] : - a->inst_table[DECODE_VAR( pae->numeric_effects_fluent[i].args[j] )]; - } - adr = fluent_adress(); - if ( !lf_def[lf][adr] ) { - lf_def[lf][adr] = 1; - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = lf; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); - for ( j = 0; j < gf_arity[lf]; j++ ) { - grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; - strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); - } - lf_index[lf][adr] = gnum_relevant_fluents; - gnum_relevant_fluents++; - } - } - } - } - } - - if ( gcmd_line.display_info == 119 ) { - printf("\n\nfacts selected as relevant:"); - for ( i = 0; i < gnum_relevant_facts; i++ ) { - printf("\n%d: ", i); - print_Fact( &(grelevant_facts[i]) ); - } - printf("\n\nfluents selected as relevant:"); - for ( i = 0; i < gnum_relevant_fluents; i++ ) { - printf("\n%d: ", i); - print_Fluent( &(grelevant_fluents[i]) ); - } - printf("\n\n"); - } - - lnum_effects = 0; - - create_final_goal_state(); - create_final_initial_state(); - create_final_actions(); - - if ( gmetric != NULL ) { - if ( !set_relevants_in_exp( &gmetric ) ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: undefined fluent used in optimization expression. defaulting to plan length"); - } - free_ExpNode( gmetric ); - gmetric = NULL; - } - } - - if ( gcmd_line.display_info == 120 ) { - printf("\n\nfinal domain representation is:\n\n"); - - for ( i = 0; i < gnum_operators; i++ ) { - printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); - for ( a = gactions; a; a = a->next ) { - if ( ( !a->norm_operator && - !a->pseudo_action ) || - ( a->norm_operator && - a->norm_operator->operator != goperators[i] ) || - ( a->pseudo_action && - a->pseudo_action->operator != goperators[i] ) ) { - continue; - } - print_Action( a ); - } - } - printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); - for ( a = gactions; a; a = a->next ) { - if ( !a->norm_operator && - !a->pseudo_action ) { - print_Action( a ); - } - } - - printf("\n\nfinal initial state is:\n\n"); - print_State( ginitial_state ); - - printf("\n\nfinal goal is:\n\n"); - for ( i = 0; i < gnum_logic_goal; i++ ) { - print_ft_name( glogic_goal[i] ); - printf("\n"); - } - for ( i = 0; i < gnum_numeric_goal; i++ ) { - switch ( gnumeric_goal_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator in gnumeric_goal %d\n\n", gnumeric_goal_comp[i]); - exit( 1 ); - } - print_ExpNode( gnumeric_goal_lh[i] ); - print_ExpNode( gnumeric_goal_rh[i] ); - printf(")\n"); - } - - if ( gmetric ) { - printf("\n\nmetric is (minimize):\n"); - print_ExpNode( gmetric ); - } else { - printf("\n\nmetric: none, i.e. plan length\n"); - } - } - -} - - - -void create_final_goal_state( void ) - -{ - - WffNode *w, *ww; - int m, mn, i, adr; - Action *tmp; - - if ( !set_relevants_in_wff( &ggoal ) ) { - printf("\n\nff: goal accesses a fluent that will never have a defined value. Problem unsolvable.\n\n"); - exit( 1 ); - } - cleanup_wff( &ggoal ); - - if ( ggoal->connective == TRU ) { - printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); - gnum_plan_ops = 0; - exit( 1 ); - } - if ( ggoal->connective == FAL ) { - printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); - exit( 1 ); - } - - switch ( ggoal->connective ) { - case OR: - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = -3; - gnum_relevant_facts++; - for ( w = ggoal->sons; w; w = w->next ) { - tmp = new_Action(); - if ( w->connective == AND ) { - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp->preconds = ( int * ) calloc( m, sizeof( int ) ); - tmp->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp->num_preconds = m; - tmp->num_numeric_preconds = mn; - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - lp = ww->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = ww->fact->args[i]; - } - adr = fact_adress(); - tmp->preconds[m] = lindex[lp][adr]; - m++; - } - if ( ww->connective == COMP ) { - tmp->numeric_preconds_comp[mn] = ww->comp; - tmp->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); - tmp->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); - mn++; - } - } - } else { - if ( w->connective == ATOM ) { - tmp->preconds = ( int * ) calloc( 1, sizeof( int ) ); - tmp->num_preconds = 1; - lp = w->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = w->fact->args[i]; - } - adr = fact_adress(); - tmp->preconds[0] = lindex[lp][adr]; - } - if ( w->connective == COMP ) { - tmp->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp->numeric_preconds_comp[0] = w->comp; - tmp->numeric_preconds_lh[0] = copy_Exp( w->lh ); - tmp->numeric_preconds_rh[0] = copy_Exp( w->rh ); - tmp->num_numeric_preconds = 1; - } - } - tmp->effects = ( ActionEffect * ) calloc( 1, sizeof( ActionEffect ) ); - tmp->num_effects = 1; - tmp->effects[0].conditions = NULL; - tmp->effects[0].num_conditions = 0; - tmp->effects[0].dels = NULL; - tmp->effects[0].num_dels = 0; - tmp->effects[0].adds = ( int * ) calloc( 1, sizeof( int ) ); - tmp->effects[0].adds[0] = gnum_relevant_facts - 1; - tmp->effects[0].num_adds = 1; - tmp->effects[0].numeric_conditions_comp = NULL; - tmp->effects[0].numeric_conditions_lh = NULL; - tmp->effects[0].numeric_conditions_rh = NULL; - tmp->effects[0].num_numeric_conditions = 0; - tmp->effects[0].numeric_effects_neft = NULL; - tmp->effects[0].numeric_effects_fl = NULL; - tmp->effects[0].numeric_effects_rh = NULL; - tmp->effects[0].num_numeric_effects = 0; - - tmp->next = gactions; - gactions = tmp; - gnum_actions++; - lnum_effects++; - } - glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); - glogic_goal[0] = gnum_relevant_facts - 1; - gnum_logic_goal = 1; - break; - case AND: - m = 0; mn = 0; - for ( w = ggoal->sons; w; w = w->next ) { - if ( w->connective == ATOM ) m++; - if ( w->connective == COMP ) mn++; - } - glogic_goal = ( int * ) calloc( m, sizeof( int ) ); - gnumeric_goal_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - gnum_logic_goal = m; - gnum_numeric_goal = mn; - m = 0; mn = 0; - for ( w = ggoal->sons; w; w = w->next ) { - if ( w->connective == ATOM ) { - lp = w->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = w->fact->args[i]; - } - adr = fact_adress(); - glogic_goal[m] = lindex[lp][adr]; - m++; - } - if ( w->connective == COMP ) { - gnumeric_goal_comp[mn] = w->comp; - gnumeric_goal_lh[mn] = copy_Exp( w->lh ); - gnumeric_goal_rh[mn] = copy_Exp( w->rh ); - mn++; - } - } - break; - case ATOM: - glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); - gnum_logic_goal = 1; - lp = ggoal->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = ggoal->fact->args[i]; - } - adr = fact_adress(); - glogic_goal[0] = lindex[lp][adr]; - break; - case COMP: - gnumeric_goal_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - gnum_numeric_goal = 1; - gnumeric_goal_comp[0] = ggoal->comp; - gnumeric_goal_lh[0] = copy_Exp( ggoal->lh ); - gnumeric_goal_rh[0] = copy_Exp( ggoal->rh ); - break; - default: - printf("\n\nwon't get here: non COMP,ATOM,AND,OR in fully simplified goal\n\n"); - exit( 1 ); - } - -} - - - -Bool set_relevants_in_wff( WffNode **w ) - -{ - - WffNode *i; - int j, adr; - - switch ( (*w)->connective ) { - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - if ( !set_relevants_in_wff( &i ) ) { - return FALSE; - } - } - break; - case ATOM: - /* no equalities, as fully instantiated - */ - lp = (*w)->fact->predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = (*w)->fact->args[j]; - } - adr = fact_adress(); - - if ( !lneg[lp][adr] ) { - (*w)->connective = TRU; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - if ( !lpos[lp][adr] ) { - (*w)->connective = FAL; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - break; - case COMP: - if ( !set_relevants_in_exp( &((*w)->lh) ) || - !set_relevants_in_exp( &((*w)->rh) ) ) { - return FALSE; - } - break; - default: - printf("\n\nwon't get here: non ATOM,OR,AND in goal set relevants\n\n"); - exit( 1 ); - } - - return TRUE; - -} - - - -Bool set_relevants_in_exp( ExpNode **n ) - -{ - - int j, adr; - - /* can probably (for sure) forget about the simplification - * stuff here because it's been done before. - * - * igual.... - */ - switch ( (*n)->connective ) { - case AD: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - if ( !set_relevants_in_exp( &((*n)->son) ) ) return FALSE; - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - lf = (*n)->fluent->function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = (*n)->fluent->args[j]; - } - adr = fluent_adress(); - (*n)->fl = lf_index[lf][adr]; - free( (*n)->fluent ); - (*n)->fluent = NULL; - if ( lf_index[lf][adr] == -1 ) { - if ( lf == 0 ) { - /* ATTENTION!! FUNCTION 0 IS TOTAL-TIME WHICH IS *ONLY* USED - * IN OPTIMIZATION EXPRESSION. GETS A SPECIAL TREATMENT - * IN THE RESPECTIVE FUNCTION IN SEARCH.C!!!! - * - * we remember it as fluent -2!! - */ - (*n)->fl = -2; - } else { - return FALSE; - } - } - break; - default: - printf("\n\nset relevants in expnode: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - - return TRUE; - -} - - - -void create_final_initial_state( void ) - -{ - - Facts *f; - int i, adr, fl; - FluentValues *fvs; - - i = 0; -/* for ( f = ginitial; f; f = f->next ) i++; */ - /* we need space for transformation fluents to come! - * - * ALSO, we may need space for derived facts!!! - */ - make_state( &ginitial_state, gnum_relevant_facts + 1, MAX_RELEVANT_FLUENTS ); - - for ( f = ginitial; f; f = f->next ) { - lp = f->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = f->fact->args[i]; - } - adr = fact_adress(); - if ( !lneg[lp][adr] ) {/* non deleted ini */ - continue; - } - ginitial_state.F[ginitial_state.num_F++] = lindex[lp][adr]; - } - - for ( fvs = gf_initial; fvs; fvs = fvs->next ) { - lf = fvs->fluent.function; - for ( i = 0; i < gf_arity[lf]; i++ ) { - lf_args[i] = fvs->fluent.args[i]; - } - adr = fluent_adress(); - fl = lf_index[lf][adr]; - ginitial_state.f_D[fl] = TRUE; - ginitial_state.f_V[fl] = fvs->value; - } - -} - - - -void create_final_actions( void ) - -{ - - Action *a, *p, *t; - NormOperator *no; - NormEffect *ne; - int i, j, adr; - PseudoAction *pa; - PseudoActionEffect *pae; - ActionEffect *aa; - Bool false_cond; - - a = gactions; p = NULL; - while ( a ) { - if ( a->norm_operator ) { - /* action comes from an easy template NormOp - */ - no = a->norm_operator; - - if ( no->num_preconds > 0 ) { - a->preconds = ( int * ) calloc( no->num_preconds, sizeof( int ) ); - } - a->num_preconds = 0; - for ( i = 0; i < no->num_preconds; i++ ) { - lp = no->preconds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( no->preconds[i].args[j] >= 0 ) ? - no->preconds[i].args[j] : a->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; - } - adr = fact_adress(); - /* preconds are lpos in all cases due to reachability analysis - */ - if ( !lneg[lp][adr] ) { - continue; - } - a->preconds[a->num_preconds++] = lindex[lp][adr]; - } - - /**************************NUMERIC PRECOND*************************/ - if ( no->num_numeric_preconds > 0 ) { - a->numeric_preconds_comp = ( Comparator * ) - calloc( no->num_numeric_preconds, sizeof( Comparator ) ); - a->numeric_preconds_lh = ( ExpNode_pointer * ) - calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->numeric_preconds_rh = ( ExpNode_pointer * ) - calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->num_numeric_preconds = 0; - } - for ( i = 0; i < no->num_numeric_preconds; i++ ) { - a->numeric_preconds_comp[a->num_numeric_preconds] = no->numeric_preconds_comp[i]; - a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_lh[i] ); - instantiate_exp_by_action( &(a->numeric_preconds_lh[a->num_numeric_preconds]), a ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; - a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_rh[i] ); - instantiate_exp_by_action( &(a->numeric_preconds_rh[a->num_numeric_preconds]), a ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; - if ( a->numeric_preconds_lh[a->num_numeric_preconds]->connective == NUMBER && - a->numeric_preconds_rh[a->num_numeric_preconds]->connective == NUMBER ) { - /* trivial numeric precond - */ - if ( number_comparison_holds( a->numeric_preconds_comp[a->num_numeric_preconds], - a->numeric_preconds_lh[a->num_numeric_preconds]->value, - a->numeric_preconds_rh[a->num_numeric_preconds]->value ) ) { - /* true precond -> throw precond away. by not incrementing number of such. - */ - free_ExpNode( a->numeric_preconds_lh[a->num_numeric_preconds] ); - free_ExpNode( a->numeric_preconds_rh[a->num_numeric_preconds] ); - continue; - } else { - /* false precond -> throw action away. - */ - break; - } - } - a->num_numeric_preconds++; - } - if ( i < no->num_numeric_preconds ) { - /* a precond accesses an undefined fluent, or is false -> remove action! - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - /**************************NUMERIC PRECOND-END*************************/ - - /* and now for the effects - */ - if ( a->num_effects > 0 ) { - a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); - for ( i = 0; i < a->num_effects; i++ ) { - a->effects[i].illegal = FALSE; - a->effects[i].removed = FALSE; - } - } - a->num_effects = 0; - for ( ne = no->effects; ne; ne = ne->next ) { - aa = &(a->effects[a->num_effects]); - - if ( ne->num_conditions > 0 ) { - aa->conditions = ( int * ) calloc( ne->num_conditions, sizeof( int ) ); - } - aa->num_conditions = 0; - for ( i = 0; i < ne->num_conditions; i++ ) { - lp = ne->conditions[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->conditions[i].args[j] >= 0 ) ? - ne->conditions[i].args[j] : a->inst_table[DECODE_VAR( ne->conditions[i].args[j] )]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ - break; - } - if ( !lneg[lp][adr] ) {/* condition always true: skip it */ - continue; - } - aa->conditions[aa->num_conditions++] = lindex[lp][adr]; - } - if ( i < ne->num_conditions ) {/* found unreachable condition: free condition space */ - free( aa->conditions ); - continue; - } - - /**************************NUMERIC COND*************************/ - if ( ne->num_numeric_conditions > 0 ) { - aa->numeric_conditions_comp = ( Comparator * ) - calloc( ne->num_numeric_conditions, sizeof( Comparator ) ); - aa->numeric_conditions_lh = ( ExpNode_pointer * ) - calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - aa->numeric_conditions_rh = ( ExpNode_pointer * ) - calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < ne->num_numeric_conditions; i++ ) { - aa->numeric_conditions_lh[i] = NULL; - aa->numeric_conditions_rh[i] = NULL; - } - aa->num_numeric_conditions = 0; - } - false_cond = FALSE; - for ( i = 0; i < ne->num_numeric_conditions; i++ ) { - aa->numeric_conditions_comp[aa->num_numeric_conditions] = ne->numeric_conditions_comp[i]; - aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_lh[i] ); - instantiate_exp_by_action( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]), a ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; - aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_rh[i] ); - instantiate_exp_by_action( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]), a ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; - if ( aa->numeric_conditions_lh[aa->num_numeric_conditions]->connective == NUMBER && - aa->numeric_conditions_rh[aa->num_numeric_conditions]->connective == NUMBER ) { - /* trivial numeric condition - */ - if ( number_comparison_holds( aa->numeric_conditions_comp[aa->num_numeric_conditions], - aa->numeric_conditions_lh[aa->num_numeric_conditions]->value, - aa->numeric_conditions_rh[aa->num_numeric_conditions]->value ) ) { - /* true cond -> throw cond away. by not incrementing number of such. - */ - free_ExpNode( aa->numeric_conditions_lh[aa->num_numeric_conditions] ); - free_ExpNode( aa->numeric_conditions_rh[aa->num_numeric_conditions] ); - aa->numeric_conditions_lh[aa->num_numeric_conditions] = NULL; - aa->numeric_conditions_rh[aa->num_numeric_conditions] = NULL; - continue; - } else { - /* false cond -> throw effect away. - */ - false_cond = TRUE; - break; - } - } - aa->num_numeric_conditions++; - } - if ( i < ne->num_numeric_conditions ) { - if ( false_cond ) { - /* false numeric cond: free what's been done so far, and skip effect - */ - for ( i = 0; i <= aa->num_numeric_conditions; i++ ) { - free_ExpNode( aa->numeric_conditions_lh[i] ); - free_ExpNode( aa->numeric_conditions_rh[i] ); - } - free( aa->numeric_conditions_comp ); - free( aa->numeric_conditions_lh ); - free( aa->numeric_conditions_rh ); - continue;/* next effect, without incrementing action counter */ - } else { - /* numeric effect uses undefined fluent in condition --> - * THROW WHOLE ACTION AWAY! done by breaking out of the - * effects loop, which will be catched below overall - * effect handling. - */ - break; - } - } - /**************************NUMERIC COND - END*************************/ - - /* now create the add and del effects. - */ - if ( ne->num_adds > 0 ) { - aa->adds = ( int * ) calloc( ne->num_adds, sizeof( int ) ); - } - aa->num_adds = 0; - for ( i = 0; i < ne->num_adds; i++ ) { - lp = ne->adds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->adds[i].args[j] >= 0 ) ? - ne->adds[i].args[j] : a->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; - } - adr = fact_adress(); - if ( !lneg[lp][adr] ) {/* effect always true: skip it */ - continue; - } - aa->adds[aa->num_adds++] = lindex[lp][adr]; - } - - if ( ne->num_dels > 0 ) { - aa->dels = ( int * ) calloc( ne->num_dels, sizeof( int ) ); - } - aa->num_dels = 0; - for ( i = 0; i < ne->num_dels; i++ ) { - lp = ne->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->dels[i].args[j] >= 0 ) ? - ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* effect always false: skip it */ - continue; - } - /* NO CHECK FOR ADD \CAP DEL!!!!! -> ALLOWED BY SEMANTICS!!! - */ - aa->dels[aa->num_dels++] = lindex[lp][adr]; - } - if ( i < ne->num_dels ) break; - - /**************************NUMERIC EFFECTS*************************/ - if ( ne->num_numeric_effects > 0 ) { - aa->numeric_effects_neft = ( NumericEffectType * ) - calloc( ne->num_numeric_effects, sizeof( NumericEffectType ) ); - aa->numeric_effects_fl = ( int * ) - calloc( ne->num_numeric_effects, sizeof( int ) ); - aa->numeric_effects_rh = ( ExpNode_pointer * ) - calloc( ne->num_numeric_effects, sizeof( ExpNode_pointer ) ); - aa->num_numeric_effects = 0; - } - for ( i = 0; i < ne->num_numeric_effects; i++ ) { - aa->numeric_effects_neft[aa->num_numeric_effects] = ne->numeric_effects_neft[i]; - lf = ne->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? - ne->numeric_effects_fluent[i].args[j] : - a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; - } - adr = fluent_adress(); - /* if it's -1, simply let it in --- if that effect appears, then - * action is illegal, otherwise not. - */ - aa->numeric_effects_fl[i] = lf_index[lf][adr]; - if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; - aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( ne->numeric_effects_rh[i] ); - instantiate_exp_by_action( &(aa->numeric_effects_rh[aa->num_numeric_effects]), a ); - if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { - aa->illegal = TRUE; - } - if ( aa->illegal && - aa->num_conditions == 0 && - aa->num_numeric_conditions == 0 ) { - break; - } - /* that's it ???????????????? - !! - */ - aa->num_numeric_effects++; - } - if ( i < ne->num_numeric_effects ) { - /* an unconditional illegal effekt - */ - break; - } - /**************************NUMERIC EFFECTS - END*************************/ - - /* this effect is OK. go to next one in NormOp. - */ - a->num_effects++; - lnum_effects++; - } - if ( ne ) { - /* we get here if one effect was faulty - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - } else { - p = a; - a = a->next; - } - continue; - } - /**********************************second half: hard operators --> pseudo actions******************/ - if ( a->pseudo_action ) { - /* action is result of a PseudoAction - */ - pa = a->pseudo_action; - if ( pa->num_preconds > 0 ) { - a->preconds = ( int * ) calloc( pa->num_preconds, sizeof( int ) ); - } - a->num_preconds = 0; - for ( i = 0; i < pa->num_preconds; i++ ) { - lp = pa->preconds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pa->preconds[i].args[j]; - } - adr = fact_adress(); - /* preconds are lpos in all cases due to reachability analysis - */ - if ( !lneg[lp][adr] ) { - continue; - } - a->preconds[a->num_preconds++] = lindex[lp][adr]; - } - - /**************************NUMERIC PRECOND*************************/ - if ( pa->num_numeric_preconds > 0 ) { - a->numeric_preconds_comp = ( Comparator * ) - calloc( pa->num_numeric_preconds, sizeof( Comparator ) ); - a->numeric_preconds_lh = ( ExpNode_pointer * ) - calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->numeric_preconds_rh = ( ExpNode_pointer * ) - calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->num_numeric_preconds = 0; - } - for ( i = 0; i < pa->num_numeric_preconds; i++ ) { - a->numeric_preconds_comp[a->num_numeric_preconds] = pa->numeric_preconds_comp[i]; - a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_lh[i] ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; - a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_rh[i] ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; - a->num_numeric_preconds++; - } - if ( i < pa->num_numeric_preconds ) { - /* a precond accesses an undefined fluent -> remove action! - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - /**************************NUMERIC PRECOND-END*************************/ - - /* and now for the effects - */ - if ( a->num_effects > 0 ) { - a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); - for ( i = 0; i < a->num_effects; i++ ) { - a->effects[i].illegal = FALSE; - a->effects[i].removed = FALSE; - } - } - a->num_effects = 0; - for ( pae = pa->effects; pae; pae = pae->next ) { - aa = &(a->effects[a->num_effects]); - - if ( pae->num_conditions > 0 ) { - aa->conditions = ( int * ) calloc( pae->num_conditions, sizeof( int ) ); - } - aa->num_conditions = 0; - for ( i = 0; i < pae->num_conditions; i++ ) { - lp = pae->conditions[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->conditions[i].args[j]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ - break; - } - if ( !lneg[lp][adr] ) {/* condition always true: skip it */ - continue; - } - aa->conditions[aa->num_conditions++] = lindex[lp][adr]; - } - if ( i < pae->num_conditions ) {/* found unreachable condition: free condition space */ - free( aa->conditions ); - continue; - } - - /**************************NUMERIC COND*************************/ - if ( pae->num_numeric_conditions > 0 ) { - aa->numeric_conditions_comp = ( Comparator * ) - calloc( pae->num_numeric_conditions, sizeof( Comparator ) ); - aa->numeric_conditions_lh = ( ExpNode_pointer * ) - calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - aa->numeric_conditions_rh = ( ExpNode_pointer * ) - calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < pae->num_numeric_conditions; i++ ) { - aa->numeric_conditions_lh[i] = NULL; - aa->numeric_conditions_rh[i] = NULL; - } - aa->num_numeric_conditions = 0; - } - for ( i = 0; i < pae->num_numeric_conditions; i++ ) { - aa->numeric_conditions_comp[aa->num_numeric_conditions] = pae->numeric_conditions_comp[i]; - aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_lh[i] ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; - aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_rh[i] ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; - aa->num_numeric_conditions++; - } - if ( i < pae->num_numeric_conditions ) { - /* numeric effect uses undefined fluent in condition --> - * THROW WHOLE ACTION AWAY! done by breaking out of the - * effects loop, which will be catched below overall - * effect handling. - */ - break; - } - /**************************NUMERIC COND - END*************************/ - - /* now create the add and del effects. - */ - if ( pae->num_adds > 0 ) { - aa->adds = ( int * ) calloc( pae->num_adds, sizeof( int ) ); - } - aa->num_adds = 0; - for ( i = 0; i < pae->num_adds; i++ ) { - lp = pae->adds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->adds[i].args[j]; - } - adr = fact_adress(); - if ( !lneg[lp][adr] ) {/* effect always true: skip it */ - continue; - } - aa->adds[aa->num_adds++] = lindex[lp][adr]; - } - - if ( pae->num_dels > 0 ) { - aa->dels = ( int * ) calloc( pae->num_dels, sizeof( int ) ); - } - aa->num_dels = 0; - for ( i = 0; i < pae->num_dels; i++ ) { - lp = pae->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->dels[i].args[j]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* effect always false: skip it */ - continue; - } - aa->dels[aa->num_dels++] = lindex[lp][adr]; - } - if ( i < pae->num_dels ) break; - - /**************************NUMERIC EFFECTS*************************/ - if ( pae->num_numeric_effects > 0 ) { - aa->numeric_effects_neft = ( NumericEffectType * ) - calloc( pae->num_numeric_effects, sizeof( NumericEffectType ) ); - aa->numeric_effects_fl = ( int * ) - calloc( pae->num_numeric_effects, sizeof( int ) ); - aa->numeric_effects_rh = ( ExpNode_pointer * ) - calloc( pae->num_numeric_effects, sizeof( ExpNode_pointer ) ); - aa->num_numeric_effects = 0; - } - for ( i = 0; i < pae->num_numeric_effects; i++ ) { - aa->numeric_effects_neft[aa->num_numeric_effects] = pae->numeric_effects_neft[i]; - lf = pae->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = pae->numeric_effects_fluent[i].args[j]; - if ( lf_args[j] < 0 ) { - printf("\n\nuninstantiated affected fluent in final actions! debug me.\n\n"); - exit( 1 ); - } - } - adr = fluent_adress(); - /* if it's -1, simply let it in --- if that effect appears, then - * action is illegal, otherwise not. - */ - aa->numeric_effects_fl[i] = lf_index[lf][adr]; - if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; - aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( pae->numeric_effects_rh[i] ); - if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { - aa->illegal = TRUE; - } - if ( aa->illegal && - aa->num_conditions == 0 && - aa->num_numeric_conditions == 0 ) { - break; - } - /* that's it ???????????????? - !! - */ - aa->num_numeric_effects++; - } - if ( i < pae->num_numeric_effects ) { - /* an unconditional illegal effekt - */ - break; - } - /**************************NUMERIC EFFECTS - END*************************/ - - /* this effect is OK. go to next one in PseudoAction. - */ - a->num_effects++; - lnum_effects++; - } - if ( pae ) { - /* we get here if one effect was faulty - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - } else { - p = a; - a = a->next; - } - continue; - }/* end of if clause for PseudoAction */ - /* if action was neither normop, nor pseudo action determined, - * then it is an artificial action due to disjunctive goal - * conditions. - * - * these are already in final form. - */ - p = a; - a = a->next; - }/* endfor all actions ! */ - -} - - - -void instantiate_exp_by_action( ExpNode **n, Action *a ) - -{ - - int j, f, k, h; - Bool ok; - - switch ( (*n)->connective ) { - case AD: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - instantiate_exp_by_action( &((*n)->son), a ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - f = (*n)->fluent->function; - ok = TRUE; - for ( j = 0; j < gf_arity[f]; j++ ) { - h = ( (*n)->fluent->args[j] < 0 ) ? - a->inst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; - if ( h < 0 ) { - ok = FALSE; - } else { - (*n)->fluent->args[j] = h; - } - } - if ( !ok ) { - printf("\n\nnon-instantiated fluent in final actiona! debug me!!\n\n"); - exit( 1 ); - } - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\ninst. exp by action: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - - - - - - - - - - - - - - - - - - -/************************************************** - * CONNECTIVITY GRAPH. ULTRA CLEAN REPRESENTATION * - **************************************************/ - - - - - - - - - - - - - - - - - - - - -void build_connectivity_graph( void ) - -{ - - int i, j, k, l, n_op, n_ef, fl, ef, ef_, m; - float val; - Action *a; - ActionEffect *e; - - gnum_ft_conn = gnum_relevant_facts; - gnum_fl_conn = gnum_relevant_fluents; - gnum_op_conn = gnum_actions; - gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) ); - gfl_conn = ( FlConn * ) calloc( gnum_fl_conn, sizeof( FlConn ) ); - gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) ); - gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) ); - gnum_ef_conn = 0; - - for ( i = 0; i < gnum_ft_conn; i++ ) { - gft_conn[i].num_PC = 0; - gft_conn[i].num_A = 0; - gft_conn[i].num_D = 0; - - gft_conn[i].axiom_added = FALSE; - - gft_conn[i].rand = random() % BIG_INT; - } - - gnum_real_fl_conn = 0; - for ( i = 0; i < gnum_fl_conn; i++ ) { - gfl_conn[i].num_PC = 0; - gfl_conn[i].num_IN = 0; - gfl_conn[i].num_AS = 0; - - if ( grelevant_fluents_lnf[i] == NULL ) { - gfl_conn[i].artificial = FALSE; - gnum_real_fl_conn++; - gfl_conn[i].rand = random() % BIG_INT; - } else { - /* once we're in here we'll stay as all artificial - * fluents are appended to the end. - */ - gfl_conn[i].artificial = TRUE; - gfl_conn[i].lnf_F = ( int * ) - calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( int ) ); - gfl_conn[i].lnf_C = ( float * ) - calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( float ) ); - for ( j = 0; j < grelevant_fluents_lnf[i]->num_pF; j++ ) { - gfl_conn[i].lnf_F[j] = grelevant_fluents_lnf[i]->pF[j]; - gfl_conn[i].lnf_C[j] = grelevant_fluents_lnf[i]->pC[j]; - } - gfl_conn[i].num_lnf = grelevant_fluents_lnf[i]->num_pF; - } - } - - - /* why not do this here? - */ - gmneed_start_D = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - gmneed_start_V = ( float * ) calloc( gnum_real_fl_conn, sizeof( float ) ); - - - for ( i = 0; i < gnum_op_conn; i++ ) { - gop_conn[i].num_E = 0; - } - - for ( i = 0; i < lnum_effects; i++ ) { - gef_conn[i].num_PC = 0; - gef_conn[i].num_f_PC = 0; - gef_conn[i].num_A = 0; - gef_conn[i].num_D = 0; - gef_conn[i].num_I = 0; - gef_conn[i].num_IN = 0; - gef_conn[i].num_AS = 0; - - gef_conn[i].illegal = FALSE; - gef_conn[i].removed = FALSE; - } - - - /* determine if there are conditional effects. - */ - gconditional_effects = FALSE; - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->num_conditions > 0 ) { - break; - } - if ( e->num_lnf_conditions > 0 ) { - break; - } - } - if ( i < a->num_effects ) break; - } - if ( a ) { - printf("\n\ntask contains conditional effects. turning off state domination.\n\n"); - gconditional_effects = TRUE; - } - - n_op = 0; - n_ef = 0; - for ( a = gactions; a; a = a->next ) { - gop_conn[n_op].action = a; - gop_conn[n_op].axiom = a->axiom; - if ( a->num_effects == 0 ) { - continue; - } - - gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) ); - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - gef_conn[n_ef].cost = e->cost; - if ( e->removed ) { - /* this one disappeared through summarization - */ - continue; - } - gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef; - gef_conn[n_ef].op = n_op; - if ( e->illegal ) { - gef_conn[n_ef].illegal = TRUE; - } - - /*****************************CONDS********************************/ - gef_conn[n_ef].PC = ( int * ) - calloc( e->num_conditions + a->num_preconds, sizeof( int ) ); - for ( j = 0; j < a->num_preconds; j++ ) { - for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { - if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break; - } - if ( k < gef_conn[n_ef].num_PC ) continue; - gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j]; - } - for ( j = 0; j < e->num_conditions; j++ ) { - for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { - if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break; - } - if ( k < gef_conn[n_ef].num_PC ) continue; - gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j]; - } - /* similar thing for numeric conditions. - */ - gef_conn[n_ef].f_PC_comp = ( Comparator * ) - calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( Comparator ) ); - gef_conn[n_ef].f_PC_fl = ( int * ) - calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( int ) ); - gef_conn[n_ef].f_PC_c = ( float * ) - calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( float ) ); - gef_conn[n_ef].f_PC_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); - for ( j = 0; j < gnum_fl_conn; j++ ) { - gef_conn[n_ef].f_PC_direct_comp[j] = IGUAL; - } - gef_conn[n_ef].f_PC_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); - for ( j = 0; j < a->num_lnf_preconds; j++ ) { - if ( a->lnf_preconds_lh[j]->num_pF != 1 ) { - printf("\n\nnon 1 card. in comp lh final pre copyover.\n\n"); - exit( 1 ); - } - for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { - if ( gef_conn[n_ef].f_PC_fl[k] == a->lnf_preconds_lh[j]->pF[0] ) break; - } - if ( k < gef_conn[n_ef].num_f_PC ) { - if ( a->lnf_preconds_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { - /* weaker cond - */ - continue; - } - if ( a->lnf_preconds_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { - /* stronger cond - */ - gef_conn[n_ef].f_PC_c[k] = a->lnf_preconds_rh[j]; - gef_conn[n_ef].f_PC_comp[k] = a->lnf_preconds_comp[j]; - continue; - } - if ( a->lnf_preconds_comp[j] == GE ) { - /* we might need to strengthen our comp - */ - gef_conn[n_ef].f_PC_comp[k] = GE; - } - } else { - gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_comp[j]; - gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_lh[j]->pF[0]; - gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = a->lnf_preconds_rh[j]; - } - } - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( e->lnf_conditions_lh[j]->num_pF != 1 ) { - printf("\n\nnon 1 card. in comp lh final cond copyover.\n\n"); - exit( 1 ); - } - for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { - if ( gef_conn[n_ef].f_PC_fl[k] == e->lnf_conditions_lh[j]->pF[0] ) break; - } - if ( k < gef_conn[n_ef].num_f_PC ) { - if ( e->lnf_conditions_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { - continue; - } - if ( e->lnf_conditions_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { - gef_conn[n_ef].f_PC_c[k] = e->lnf_conditions_rh[j]; - gef_conn[n_ef].f_PC_comp[k] = e->lnf_conditions_comp[j]; - continue; - } - if ( e->lnf_conditions_comp[j] == GE ) { - gef_conn[n_ef].f_PC_comp[k] = GE; - } - } else { - gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_comp[j]; - gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_lh[j]->pF[0]; - gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = e->lnf_conditions_rh[j]; - } - } - /* now arrange the direct access structures from that. - */ - for ( j = 0; j < gef_conn[n_ef].num_f_PC; j++ ) { - gef_conn[n_ef].f_PC_direct_comp[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_comp[j]; - gef_conn[n_ef].f_PC_direct_c[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_c[j]; - } - /*****************************CONDS - END********************************/ - - - if ( e->illegal ) { - /* we don't care about the effects if they're illegal - - * all we care about is whether the condition is true or not. - */ - n_ef++; - gnum_ef_conn++; - continue; - } - /*****************************EFFECTS********************************/ - gef_conn[n_ef].A = ( int * ) calloc( e->num_adds, sizeof( int ) ); - gef_conn[n_ef].D = ( int * ) calloc( e->num_dels, sizeof( int ) ); - gef_conn[n_ef].IN_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].IN_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].IN_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); - gef_conn[n_ef].AS_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].AS_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].AS_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); - - /* duplicates removed in summarize already. - * - * but don't include adds that are in the conds. - * --- those are true anyway. - * - * and don't include dels that are in the adds - * --- those will be re-added anyway. - * - * NOTE: it is important that we use the *original* add list - * not the already reduced one, for the delete check! - * otherwise it may be that a delete that's in the add - * and also in the cond stays in! - * - * IT IS ALSO IMPORTANT THAT WE DO BOTH!!!, i.e. if we do - * the ads reduction then we *must* also do the dels - * reduction to avoid that things are deleted that - * would otherwise have been re-added. - */ - for ( j = 0; j < e->num_adds; j++ ) { - for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { - if ( gef_conn[n_ef].PC[k] == e->adds[j] ) break; - } - if ( k < gef_conn[n_ef].num_PC ) continue; - gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j]; - } - for ( j = 0; j < e->num_dels; j++ ) { - for ( k = 0; k < e->num_adds; k++ ) { - if ( e->adds[k] == e->dels[j] ) break; - } - if ( k < e->num_adds ) continue; - gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j]; - } - - /* numeric part - */ - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_neft[j] != INCREASE ) continue; - gef_conn[n_ef].IN_fl[gef_conn[n_ef].num_IN] = e->lnf_effects_fl[j]; - if ( e->lnf_effects_rh[j]->num_pF == 1 ) { - if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { - printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); - exit( 1 ); - } - gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = e->lnf_effects_rh[j]->pF[0]; - } else { - if ( e->lnf_effects_rh[j]->num_pF != 0 ) { - printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); - exit( 1 ); - } - gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = -1; - } - gef_conn[n_ef].IN_c[gef_conn[n_ef].num_IN++] = e->lnf_effects_rh[j]->c; - } - /* now remove increasers by nothing. - */ - j = 0; - while ( j < gef_conn[n_ef].num_IN ) { - if ( gef_conn[n_ef].IN_fl_[j] != -1 || - gef_conn[n_ef].IN_c[j] != 0 ) { - j++; - continue; - } - for ( k = j; k < gef_conn[n_ef].num_IN - 1; k++ ) { - gef_conn[n_ef].IN_fl[k] = gef_conn[n_ef].IN_fl[k+1]; - gef_conn[n_ef].IN_fl_[k] = gef_conn[n_ef].IN_fl_[k+1]; - gef_conn[n_ef].IN_c[k] = gef_conn[n_ef].IN_c[k+1]; - } - gef_conn[n_ef].num_IN--; - } - /* now: the assigners... - */ - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_neft[j] != ASSIGN ) continue; - gef_conn[n_ef].AS_fl[gef_conn[n_ef].num_AS] = e->lnf_effects_fl[j]; - if ( e->lnf_effects_rh[j]->num_pF == 1 ) { - if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { - printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); - exit( 1 ); - } - gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = e->lnf_effects_rh[j]->pF[0]; - } else { - if ( e->lnf_effects_rh[j]->num_pF != 0 ) { - printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); - exit( 1 ); - } - gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = -1; - } - gef_conn[n_ef].AS_c[gef_conn[n_ef].num_AS++] = e->lnf_effects_rh[j]->c; - } - /*****************************EFFECTS - END********************************/ - - n_ef++; - gnum_ef_conn++; - }/* end all a->effects */ - - - /*****************************EMPTY EFFECTS********************************/ - if ( gop_conn[n_op].num_E >= 1 ) { - /* CHECK EMPTY EFFECTS! - * - * two step process --- first, remove all effects that are entirely empty. - * second, check if all remaining effects are illegal - * or only delete: - * in that case, the op will never do any good so we - * remove all its effects. - */ - i = 0; - while ( i < gop_conn[n_op].num_E ) { - /* illegal effects *must* stay in!!! - */ - if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { - i++; - continue; - } - if ( gef_conn[gop_conn[n_op].E[i]].num_A != 0 || - gef_conn[gop_conn[n_op].E[i]].num_D != 0 || - gef_conn[gop_conn[n_op].E[i]].num_IN != 0 || - gef_conn[gop_conn[n_op].E[i]].num_AS != 0 ) { - i++; - continue; - } - /* we keep it in the gef_conn (seems easier), - * but mark it as removed, which will exclude it from everything. - */ - gef_conn[gop_conn[n_op].E[i]].removed = TRUE; - for ( j = i; j < gop_conn[n_op].num_E - 1; j++ ) { - gop_conn[n_op].E[j] = gop_conn[n_op].E[j+1]; - } - gop_conn[n_op].num_E--; - } - - m = 0; - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { - m++; - continue; - } - if ( gef_conn[gop_conn[n_op].E[i]].num_A == 0 && - gef_conn[gop_conn[n_op].E[i]].num_IN == 0 && - gef_conn[gop_conn[n_op].E[i]].num_AS == 0 ) { - m++; - } - } - if ( m == gop_conn[n_op].num_E ) { - /* all remaining effects illegal or solely-deleters. - */ - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - gef_conn[gop_conn[n_op].E[i]].removed = TRUE; - } - gop_conn[n_op].num_E = 0; - } - } - /*****************************EMPTY EFFECTS - END********************************/ - - - /*****************************IMPLIED EFFECTS********************************/ - if ( gop_conn[n_op].num_E > 1 ) { - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - ef = gop_conn[n_op].E[i]; - gef_conn[ef].I = ( int * ) calloc( gop_conn[n_op].num_E, sizeof( int ) ); - gef_conn[ef].num_I = 0; - } - for ( i = 0; i < gop_conn[n_op].num_E - 1; i++ ) { - ef = gop_conn[n_op].E[i]; - for ( j = i+1; j < gop_conn[n_op].num_E; j++ ) { - ef_ = gop_conn[n_op].E[j]; - /* ef ==> ef_ ? */ - for ( k = 0; k < gef_conn[ef_].num_PC; k++ ) { - for ( l = 0; l < gef_conn[ef].num_PC; l++ ) { - if ( gef_conn[ef].PC[l] == gef_conn[ef_].PC[k] ) break; - } - if ( l == gef_conn[ef].num_PC ) break; - } - if ( k == gef_conn[ef_].num_PC ) { - for ( k = 0; k < gnum_fl_conn; k++ ) { - if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL ) continue; - if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL || - gef_conn[ef].f_PC_direct_c[k] < gef_conn[ef_].f_PC_direct_c[k] || - ( gef_conn[ef].f_PC_direct_c[k] == gef_conn[ef_].f_PC_direct_c[k] && - gef_conn[ef].f_PC_direct_comp[k] == GEQ && - gef_conn[ef_].f_PC_direct_comp[k] == GE ) ) break; - } - if ( k == gnum_fl_conn ) { - gef_conn[ef].I[gef_conn[ef].num_I++] = ef_; - } - } - /* ef_ ==> ef ? */ - for ( k = 0; k < gef_conn[ef].num_PC; k++ ) { - for ( l = 0; l < gef_conn[ef_].num_PC; l++ ) { - if ( gef_conn[ef_].PC[l] == gef_conn[ef].PC[k] ) break; - } - if ( l == gef_conn[ef_].num_PC ) break; - } - if ( k == gef_conn[ef].num_PC ) { - for ( k = 0; k < gnum_fl_conn; k++ ) { - if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL ) continue; - if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL || - gef_conn[ef_].f_PC_direct_c[k] < gef_conn[ef].f_PC_direct_c[k] || - ( gef_conn[ef_].f_PC_direct_c[k] == gef_conn[ef].f_PC_direct_c[k] && - gef_conn[ef_].f_PC_direct_comp[k] == GEQ && - gef_conn[ef].f_PC_direct_comp[k] == GE ) ) break; - } - if ( k == gnum_fl_conn ) { - gef_conn[ef_].I[gef_conn[ef_].num_I++] = ef; - } - } - } - } - } - /*****************************IMPLIED EFFECTS - END********************************/ - - /* op cost is sum of eff costs + gtt*1: - * [gtt is multiplicator of TOTAL-TIME in final metric; if no - * total-time part in metric, it is 0] - * ie eff-costs plus the cost for the time taken by 1 more step. - */ - gop_conn[n_op].cost = gtt; - if ( gop_conn[n_op].num_E > 0 ) { - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - ef = gop_conn[n_op].E[i]; - if ( gef_conn[ef].illegal ) { - continue; - } - if ( gef_conn[ef].removed ) { - continue; - } - gop_conn[n_op].cost += gef_conn[ef].cost; - } - } - - /* first sweep: only count the space we need for the fact arrays ! - */ - if ( gop_conn[n_op].num_E > 0 ) { - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - ef = gop_conn[n_op].E[i]; - for ( j = 0; j < gef_conn[ef].num_PC; j++ ) { - gft_conn[gef_conn[ef].PC[j]].num_PC++; - } - for ( j = 0; j < gef_conn[ef].num_A; j++ ) { - gft_conn[gef_conn[ef].A[j]].num_A++; - if ( gop_conn[n_op].axiom ) { - gft_conn[gef_conn[ef].A[j]].axiom_added = TRUE; - } - } - for ( j = 0; j < gef_conn[ef].num_D; j++ ) { - gft_conn[gef_conn[ef].D[j]].num_D++; - } - /* similar increments for flconn - */ - for ( j = 0; j < gef_conn[ef].num_f_PC; j++ ) { - gfl_conn[gef_conn[ef].f_PC_fl[j]].num_PC++; - } - for ( j = 0; j < gef_conn[ef].num_IN; j++ ) { - gfl_conn[gef_conn[ef].IN_fl[j]].num_IN++; - } - for ( j = 0; j < gef_conn[ef].num_AS; j++ ) { - gfl_conn[gef_conn[ef].AS_fl[j]].num_AS++; - } - } - } - - - n_op++; - } - - /*****************************FLCONN********************************/ - for ( i = 0; i < gnum_ft_conn; i++ ) { - if ( gft_conn[i].num_PC > 0 ) { - gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) ); - } - gft_conn[i].num_PC = 0; - if ( gft_conn[i].num_A > 0 ) { - gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) ); - } - gft_conn[i].num_A = 0; - if ( gft_conn[i].num_D > 0 ) { - gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) ); - } - gft_conn[i].num_D = 0; - } - for ( i = 0; i < gnum_ef_conn; i++ ) { - if ( gef_conn[i].removed ) continue; - for ( j = 0; j < gef_conn[i].num_PC; j++ ) { - gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i; - } - for ( j = 0; j < gef_conn[i].num_A; j++ ) { - gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i; - } - for ( j = 0; j < gef_conn[i].num_D; j++ ) { - gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i; - } - } - /*****************************FTCONN - END********************************/ - - - /*****************************FLCONN********************************/ - /* similar thing for flconn - */ - for ( i = 0; i < gnum_fl_conn; i++ ) { - if ( gfl_conn[i].num_PC > 0 ) { - gfl_conn[i].PC = ( int * ) calloc( gfl_conn[i].num_PC, sizeof( int ) ); - } - gfl_conn[i].num_PC = 0; - if ( gfl_conn[i].num_IN > 0 ) { - gfl_conn[i].IN = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); - gfl_conn[i].IN_fl_ = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); - gfl_conn[i].IN_c = ( float * ) calloc( gfl_conn[i].num_IN, sizeof( float ) ); - } - gfl_conn[i].num_IN = 0; - if ( gfl_conn[i].num_AS > 0 ) { - gfl_conn[i].AS = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); - gfl_conn[i].AS_fl_ = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); - gfl_conn[i].AS_c = ( float * ) calloc( gfl_conn[i].num_AS, sizeof( float ) ); - } - gfl_conn[i].num_AS = 0; - } - for ( i = 0; i < gnum_ef_conn; i++ ) { - if ( gef_conn[i].removed ) continue; - /* PCs - */ - for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { - fl = gef_conn[i].f_PC_fl[j]; - gfl_conn[fl].PC[gfl_conn[fl].num_PC++] = i; - } - /* insert increasers by decreasing amount --> - * "best" - at least for constant part - are first! - */ - for ( j = 0; j < gef_conn[i].num_IN; j++ ) { - fl = gef_conn[i].IN_fl[j]; - val = gef_conn[i].IN_c[j]; - for ( k = 0; k < gfl_conn[fl].num_IN; k++ ) { - if ( gfl_conn[fl].IN_c[k] < val ) break; - } - for ( l = gfl_conn[fl].num_IN; l > k; l-- ) { - gfl_conn[fl].IN[l] = gfl_conn[fl].IN[l-1]; - gfl_conn[fl].IN_fl_[l] = gfl_conn[fl].IN_fl_[l-1]; - gfl_conn[fl].IN_c[l] = gfl_conn[fl].IN_c[l-1]; - } - gfl_conn[fl].IN[k] = i; - gfl_conn[fl].IN_fl_[k] = gef_conn[i].IN_fl_[j];/* the rh fluent */ - gfl_conn[fl].IN_c[k] = val; - gfl_conn[fl].num_IN++; - } - /* insert assigners by decreasing amount --> - * "best" - at least for constant part - are first! - */ - for ( j = 0; j < gef_conn[i].num_AS; j++ ) { - fl = gef_conn[i].AS_fl[j]; - val = gef_conn[i].AS_c[j]; - for ( k = 0; k < gfl_conn[fl].num_AS; k++ ) { - if ( gfl_conn[fl].AS_c[k] < val ) break; - } - for ( l = gfl_conn[fl].num_AS; l > k; l-- ) { - gfl_conn[fl].AS[l] = gfl_conn[fl].AS[l-1]; - gfl_conn[fl].AS_fl_[l] = gfl_conn[fl].AS_fl_[l-1]; - gfl_conn[fl].AS_c[l] = gfl_conn[fl].AS_c[l-1]; - } - gfl_conn[fl].AS[k] = i; - gfl_conn[fl].AS_fl_[k] = gef_conn[i].AS_fl_[j];/* the rh fluent */ - gfl_conn[fl].AS_c[k] = val; - gfl_conn[fl].num_AS++; - } - } - /*****************************FLCONN - END********************************/ - - - /*****************************GOAL********************************/ - gflogic_goal = ( int * ) calloc( gnum_logic_goal, sizeof( int ) ); - for ( j = 0; j < gnum_logic_goal; j++ ) { - for ( k = 0; k < gnum_flogic_goal; k++ ) { - if ( gflogic_goal[k] == glogic_goal[j] ) break; - } - if ( k < gnum_flogic_goal ) continue; - gflogic_goal[gnum_flogic_goal++] = glogic_goal[j]; - } - /* numeric part - */ - gfnumeric_goal_comp = ( Comparator * ) calloc( gnum_lnf_goal, sizeof( Comparator ) ); - gfnumeric_goal_fl = ( int * ) calloc( gnum_lnf_goal, sizeof( int ) ); - gfnumeric_goal_c = ( float * ) calloc( gnum_lnf_goal, sizeof( float ) ); - for ( j = 0; j < gnum_lnf_goal; j++ ) { - if ( glnf_goal_lh[j]->num_pF != 1 ) { - printf("\n\nnon 1 card. in comp lh final goal copyover.\n\n"); - exit( 1 ); - } - for ( k = 0; k < gnum_fnumeric_goal; k++ ) { - if ( gfnumeric_goal_fl[k] == glnf_goal_lh[j]->pF[0] ) break; - } - if ( k < gnum_fnumeric_goal ) { - if ( glnf_goal_rh[j] < gfnumeric_goal_c[k] ) continue; - if ( glnf_goal_rh[j] > gfnumeric_goal_c[k] ) { - gfnumeric_goal_comp[k] = glnf_goal_comp[j]; - gfnumeric_goal_c[k] = glnf_goal_rh[j]; - continue; - } - if ( glnf_goal_comp[j] == GE ) { - gfnumeric_goal_comp[k] = GE; - } - } else { - gfnumeric_goal_comp[gnum_fnumeric_goal] = glnf_goal_comp[j]; - gfnumeric_goal_fl[gnum_fnumeric_goal] = glnf_goal_lh[j]->pF[0]; - gfnumeric_goal_c[gnum_fnumeric_goal++] = glnf_goal_rh[j]; - } - } - gfnumeric_goal_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); - for ( j = 0; j < gnum_fl_conn; j++ ) { - gfnumeric_goal_direct_comp[j] = IGUAL; - } - gfnumeric_goal_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); - for ( k = 0; k < gnum_fnumeric_goal; k++ ) { - gfnumeric_goal_direct_comp[gfnumeric_goal_fl[k]] = gfnumeric_goal_comp[k]; - gfnumeric_goal_direct_c[gfnumeric_goal_fl[k]] = gfnumeric_goal_c[k]; - } - /*****************************GOAL - END********************************/ - - - - /******************** - * safety: if there are numeric precs/goals, need to turn - * cost-minimizing rplans off!!! - * (see comments with def of gcost_rplans - */ - for ( i = 0; i < gnum_ef_conn; i++ ) { - if ( gcost_rplans && gef_conn[i].num_f_PC > 0 ) { - printf("\nwarning: numeric precondition. turning cost-minimizing relaxed plans OFF."); - gcost_rplans = FALSE; - break; - } - } - if ( gcost_rplans && gnum_fnumeric_goal > 0 ) { - printf("\nwarning: numeric goal. turning cost-minimizing relaxed plans OFF."); - gcost_rplans = FALSE; - } - - - - - if ( gcmd_line.display_info == 125 ) { - printf("\n\ncreated connectivity graph as follows:"); - - printf("\n\n------------------OP ARRAY:-----------------------"); - for ( i = 0; i < gnum_op_conn; i++ ) { - printf("\n\nOP %d: ", i); - if ( gop_conn[i].axiom ) printf("(axiom) "); - print_op_name( i ); - printf(" cost %f", gop_conn[i].cost); - printf("\n----------EFFS:"); - for ( j = 0; j < gop_conn[i].num_E; j++ ) { - printf("\neffect %d", gop_conn[i].E[j]); - } - } - - printf("\n\n-------------------EFFECT ARRAY:----------------------"); - for ( i = 0; i < gnum_ef_conn; i++ ) { - printf("\n\neffect %d of op %d cost %f: ", i, gef_conn[i].op, gef_conn[i].cost); - print_op_name( gef_conn[i].op ); - if ( gef_conn[i].illegal ) printf(" ******ILLEGAL************************"); - if ( gef_conn[i].removed ) printf(" ******REMOVED************************"); - printf("\n----------PCS:"); - for ( j = 0; j < gef_conn[i].num_PC; j++ ) { - printf("\n"); - print_ft_name( gef_conn[i].PC[j] ); - } - printf("\n----------f_PCS:"); - for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { - printf("\n"); - print_fl_name( gef_conn[i].f_PC_fl[j] ); - if ( gef_conn[i].f_PC_comp[j] == GEQ ) { - printf(" >= "); - } else { - printf(" > "); - } - printf("%f", gef_conn[i].f_PC_c[j]); - } - printf("\nDIRECT: "); - for ( j = 0; j < gnum_fl_conn; j++ ) { - if ( gef_conn[i].f_PC_direct_comp[j] == IGUAL ) { - printf("IGUAL | "); - } - if ( gef_conn[i].f_PC_direct_comp[j] == GEQ ) { - printf(">= %f | ", gef_conn[i].f_PC_direct_c[j]); - } - if ( gef_conn[i].f_PC_direct_comp[j] == GE ) { - printf("> %f | ", gef_conn[i].f_PC_direct_c[j]); - } - } - if ( gef_conn[i].illegal ) continue; - printf("\n----------ADDS:"); - for ( j = 0; j < gef_conn[i].num_A; j++ ) { - printf("\n"); - print_ft_name( gef_conn[i].A[j] ); - } - printf("\n----------DELS:"); - for ( j = 0; j < gef_conn[i].num_D; j++ ) { - printf("\n"); - print_ft_name( gef_conn[i].D[j] ); - } - printf("\n----------INCREASE:"); - for ( j = 0; j < gef_conn[i].num_IN; j++ ) { - printf("\n"); - print_fl_name( gef_conn[i].IN_fl[j] ); - printf(" by "); - if ( gef_conn[i].IN_fl_[j] >= 0 ) { - print_fl_name( gef_conn[i].IN_fl_[j] ); - printf(" + %f", gef_conn[i].IN_c[j]); - } else { - printf("%f", gef_conn[i].IN_c[j]); - } - } - printf("\n----------ASSIGN:"); - for ( j = 0; j < gef_conn[i].num_AS; j++ ) { - printf("\n"); - print_fl_name( gef_conn[i].AS_fl[j] ); - printf(" to "); - if ( gef_conn[i].AS_fl_[j] >= 0 ) { - print_fl_name( gef_conn[i].AS_fl_[j] ); - printf(" + %f", gef_conn[i].AS_c[j]); - } else { - printf("%f", gef_conn[i].AS_c[j]); - } - } - printf("\n----------IMPLIEDS:"); - for ( j = 0; j < gef_conn[i].num_I; j++ ) { - printf("\nimplied effect %d of op %d: ", - gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op); - print_op_name( gef_conn[gef_conn[i].I[j]].op ); - } - } - - printf("\n\n----------------------FT ARRAY:-----------------------------"); - for ( i = 0; i < gnum_ft_conn; i++ ) { - printf("\n\nFT: "); - print_ft_name( i ); - printf(" rand: %d", gft_conn[i].rand); - printf(" --------- AXIOM ADDED %d", gft_conn[i].axiom_added); - printf("\n----------PRE COND OF:"); - for ( j = 0; j < gft_conn[i].num_PC; j++ ) { - printf("\neffect %d", gft_conn[i].PC[j]); - printf(" - op "); print_op_name( gef_conn[gft_conn[i].PC[j]].op ); - } - printf("\n----------ADD BY:"); - for ( j = 0; j < gft_conn[i].num_A; j++ ) { - printf("\neffect %d", gft_conn[i].A[j]); - printf(" - op "); print_op_name( gef_conn[gft_conn[i].A[j]].op ); - } - printf("\n----------DEL BY:"); - for ( j = 0; j < gft_conn[i].num_D; j++ ) { - printf("\neffect %d", gft_conn[i].D[j]); - printf(" - op "); print_op_name( gef_conn[gft_conn[i].D[j]].op ); - } - } - - printf("\n\n----------------------FLUENT ARRAY:-----------------------------"); - for ( i = 0; i < gnum_fl_conn; i++ ) { - printf("\n\nFL: "); - print_fl_name( i ); - printf("\n----------PRE COND OF:"); - for ( j = 0; j < gfl_conn[i].num_PC; j++ ) { - printf("\neffect %d", gfl_conn[i].PC[j]); - printf(" - op "); print_op_name( gef_conn[gfl_conn[i].PC[j]].op ); - } - printf("\n----------INCREASED BY:"); - for ( j = 0; j < gfl_conn[i].num_IN; j++ ) { - if ( gfl_conn[i].IN_fl_[j] == -1 ) { - printf("\neffect %d --- %f", gfl_conn[i].IN[j], gfl_conn[i].IN_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); - } else { - printf("\neffect %d --- ", gfl_conn[i].IN[j]); - print_fl_name( gfl_conn[i].IN_fl_[j] ); - printf(" + %f", gfl_conn[i].IN_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); - } - } - printf("\n----------ASSIGNED BY:"); - for ( j = 0; j < gfl_conn[i].num_AS; j++ ) { - if ( gfl_conn[i].AS_fl_[j] == -1 ) { - printf("\neffect %d --- %f", gfl_conn[i].AS[j], gfl_conn[i].AS_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); - } else { - printf("\neffect %d --- ", gfl_conn[i].AS[j]); - print_fl_name( gfl_conn[i].AS_fl_[j] ); - printf(" + %f", gfl_conn[i].AS_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); - } - } - if ( gfl_conn[i].artificial ) { - printf("\n----------ARTIFICIAL FOR:"); - for ( j = 0; j < gfl_conn[i].num_lnf; j++ ) { - printf(" %f*", gfl_conn[i].lnf_C[j]); - print_fl_name( gfl_conn[i].lnf_F[j] ); - if ( j < gfl_conn[i].num_lnf - 1 ) { - printf(" +"); - } - } - } else { - printf("\n----------REAL"); - } - } - - printf("\n\n----------------------GOAL:-----------------------------"); - for ( j = 0; j < gnum_flogic_goal; j++ ) { - printf("\n"); - print_ft_name( gflogic_goal[j] ); - } - for ( j = 0; j < gnum_fnumeric_goal; j++ ) { - printf("\n"); - print_fl_name( gfnumeric_goal_fl[j] ); - if ( gfnumeric_goal_comp[j] == GEQ ) { - printf(" >= "); - } else { - printf(" > "); - } - printf("%f", gfnumeric_goal_c[j]); - } - printf("\nDIRECT: "); - for ( j = 0; j < gnum_fl_conn; j++ ) { - if ( gfnumeric_goal_direct_comp[j] == IGUAL ) { - printf("IGUAL | "); - } - if ( gfnumeric_goal_direct_comp[j] == GEQ ) { - printf(">= %f | ", gfnumeric_goal_direct_c[j]); - } - if ( gfnumeric_goal_direct_comp[j] == GE ) { - printf("> %f | ", gfnumeric_goal_direct_c[j]); - } - } - - printf("\n\n"); - } - -} - - - diff --git a/models/main_models/rt1/gen/ff_planner/inst_final.h b/models/main_models/rt1/gen/ff_planner/inst_final.h deleted file mode 100644 index ab42b6097..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_final.h +++ /dev/null @@ -1,69 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/********************************************************************* - * File: inst_final.h - * Description: headers for final domain representation functions - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - -#ifndef _INST_FINAL_H -#define _INST_FINAL_H - - - -void perform_reachability_analysis( void ); -int fact_adress( void ); -void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ); -void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ); - - - -void collect_relevant_facts_and_fluents( void ); -void create_final_goal_state( void ); -Bool set_relevants_in_wff( WffNode **w ); -Bool set_relevants_in_exp( ExpNode **n ); -void create_final_initial_state( void ); -void create_final_actions( void ); -void instantiate_exp_by_action( ExpNode **n, Action *a ); - - - -void build_connectivity_graph( void ); - - - -void summarize_effects( void ); -Bool same_condition( ActionEffect *e, ActionEffect *e_ ); -Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); -void merge_effects( ActionEffect *e, ActionEffect *e_ ); - - - -#endif /* _INST_FINAL_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_hard.c b/models/main_models/rt1/gen/ff_planner/inst_hard.c deleted file mode 100644 index 54f63d752..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_hard.c +++ /dev/null @@ -1,1306 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - -/********************************************************************* - * File: inst_hard.c - * Description: functions for multiplying hard operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_hard.h" - - - - - - - - - - - -/* used in multiplying routines - */ -int linst_table[MAX_VARS]; -int_pointer lini[MAX_PREDICATES]; - - - - - - - - -void build_hard_action_templates( void ) - -{ - - int i, j, size, adr; - MixedOperator *o; - - /* remove unused params; empty types are already recognised during - * domain translation; have to be handled after (or while) - * unaries encoding (if done), though. - */ - cleanup_hard_domain(); - - if ( gcmd_line.display_info == 115 ) { - printf("\n\ncleaned up hard domain representation is:\n\n"); - for ( i = 0; i < gnum_hard_operators; i++ ) { - print_Operator( ghard_operators[i] ); - } - fflush( stdout ); - } - - /* create local table of instantiated facts that occur in the - * initial state. for fast finding out if fact is in ini or not. - */ - for ( i = 0; i < gnum_predicates; i++ ) { - size = 1; - for ( j = 0; j < garity[i]; j++ ) { - size *= gnum_constants; - } - lini[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - for ( j = 0; j < size; j++ ) { - lini[i][j] = 0; - } - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - adr = instantiated_fact_adress( &ginitial_predicate[i][j] ); - lini[i][adr]++; - } - } - - - /* create mixed op for each param combination - */ - multiply_hard_op_parameters(); - - if ( gcmd_line.display_info == 116 ) { - printf("\n\nmixed hard domain representation is:\n\n"); - for ( o = ghard_mixed_operators; o; o = o->next ) { - print_MixedOperator( o ); - } - fflush( stdout ); - } - - /* create pseudo op for each mixed op - */ - multiply_hard_effect_parameters(); - - if ( gcmd_line.display_info == 117 ) { - printf("\n\npseudo hard domain representation is:\n\n"); - for ( i = 0; i < gnum_hard_templates; i++ ) { - print_PseudoAction( ghard_templates[i] ); - } - fflush( stdout ); - } - - -} - - - - - - - - - - - - -/**************** - * CLEANUP CODE * - ****************/ - - - - - - - - - - - - -void cleanup_hard_domain( void ) - -{ - - int i, j, k, par; - Operator *o; - Effect *e; - - /* so far, only unused parameters removal - */ - - for ( i = 0; i < gnum_hard_operators; i++ ) { - o = ghard_operators[i]; - - j = 0; - while ( j < o->num_vars ) { - if ( var_used_in_wff( ENCODE_VAR( j ), o->preconds ) ) { - j++; - continue; - } - - for ( e = o->effects; e; e = e->next ) { - if ( var_used_in_wff( ENCODE_VAR( j ), e->conditions ) ) { - break; - } - if ( var_used_in_literals( ENCODE_VAR( j ), e->effects ) ) { - break; - } - if ( var_used_in_numeric_effects( ENCODE_VAR( j ), e->numeric_effects ) ) { - break; - } - } - if ( e ) { - j++; - continue; - } - - o->removed[j] = TRUE; - j++; - } - - for ( e = o->effects; e; e = e->next ) { - j = 0; - while ( j < e->num_vars ) { - par = o->num_vars + j; - if ( var_used_in_wff( ENCODE_VAR( par ), e->conditions ) ) { - j++; - continue; - } - if ( var_used_in_literals( ENCODE_VAR( par ), e->effects ) ) { - j++; - continue; - } - if ( var_used_in_numeric_effects( ENCODE_VAR( par ), e->numeric_effects ) ) { - j++; - continue; - } - - if ( e->var_names[j] ) { - free( e->var_names[j] ); - } - for ( k = j; k < e->num_vars - 1; k++ ) { - e->var_names[k] = e->var_names[k+1]; - e->var_names[k] = e->var_names[k+1]; - } - e->num_vars--; - decrement_inferior_vars( par, e->conditions ); - decrement_inferior_vars_in_literals( par, e->effects ); - decrement_inferior_vars_in_numeric_effects( par, e->numeric_effects ); - } - } - } - -} - - - -Bool var_used_in_literals( int code_var, Literal *ef ) - -{ - - Literal *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - if ( l->fact.args[i] == code_var ) { - return TRUE; - } - } - } - - return FALSE; - -} - - - -Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ) - -{ - - NumericEffect *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { - if ( l->fluent.args[i] == code_var ) { - return TRUE; - } - } - if ( var_used_in_exp( code_var, l->rh ) ) { - return TRUE; - } - } - - return FALSE; - -} - - - -void decrement_inferior_vars_in_literals( int var, Literal *ef ) - -{ - - Literal *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - if ( l->fact.args[i] >= 0 ) { - continue; - } - if ( DECODE_VAR( l->fact.args[i] ) > var ) { - l->fact.args[i]++; - } - } - } - -} - - - -void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ) - -{ - - NumericEffect *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { - if ( l->fluent.args[i] >= 0 ) { - continue; - } - if ( DECODE_VAR( l->fluent.args[i] ) > var ) { - l->fluent.args[i]++; - } - } - decrement_inferior_vars_in_exp( var, l->rh ); - } - -} - - - - - - - - - - - - - - -/****************************** - * CODE THAT BUILDS MIXED OPS * - ******************************/ - - - - - - - - - - - - - - -void multiply_hard_op_parameters( void ) - -{ - - int i; - - ghard_mixed_operators = NULL; - - for ( i = 0; i < MAX_VARS; i++ ) { - linst_table[i] = -1; - } - - for ( i = 0; i < gnum_hard_operators; i++ ) { - create_hard_mixed_operators( ghard_operators[i], 0 ); - } - -} - - - -void create_hard_mixed_operators( Operator *o, int curr_var ) - -{ - - int t, i, m, mn; - WffNode *tmp1, *w, *ww; - MixedOperator *tmp2; - - if ( curr_var < o->num_vars ) { - if ( o->removed[curr_var] ) { - /* param doesn't matter -- select any appropriate type constant - * at least one there; otherwise, op would not have been translated. - */ - linst_table[curr_var] = gtype_consts[o->var_types[curr_var]][0]; - create_hard_mixed_operators( o, curr_var + 1 ); - linst_table[curr_var] = -1; - return; - } - - t = o->var_types[curr_var]; - for ( i = 0; i < gtype_size[t]; i++ ) { - linst_table[curr_var] = gtype_consts[t][i]; - - create_hard_mixed_operators( o, curr_var + 1 ); - - linst_table[curr_var] = -1; - } - return; - } - - - tmp1 = instantiate_wff( o->preconds ); - - if ( tmp1->connective == FAL ) { - free_WffNode( tmp1 ); - return; - } - - dnf( &tmp1 ); - cleanup_wff( &tmp1 ); - - if ( tmp1->connective == FAL ) { - free_WffNode( tmp1 ); - return; - } - - /* only debugging, REMOVE LATER - */ - if ( is_dnf( tmp1 ) == -1 ) { - printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", o->name); - print_Wff( tmp1, 0 ); - exit( 1 ); - } - - switch ( tmp1->connective ) { - case OR: - for ( w = tmp1->sons; w; w = w->next ) { - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - if ( w->connective == AND ) { - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_preconds = m; - tmp2->num_numeric_preconds = mn; - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp2->preconds[m].predicate = ww->fact->predicate; - for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { - tmp2->preconds[m].args[i] = ww->fact->args[i]; - } - m++; - } - if ( ww->connective == COMP ) { - tmp2->numeric_preconds_comp[mn] = ww->comp; - tmp2->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); - tmp2->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); - mn++; - } - } - } else { - if ( w->connective == ATOM ) { - tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_preconds = 1; - tmp2->preconds[0].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->preconds[0].args[i] = w->fact->args[i]; - } - } - if ( w->connective == COMP ) { - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_comp[0] = w->comp; - tmp2->numeric_preconds_lh[0] = copy_Exp( w->lh ); - tmp2->numeric_preconds_rh[0] = copy_Exp( w->rh ); - tmp2->num_numeric_preconds = 1; - } - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - } - break; - case AND: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - m = 0; - mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) m++; - if ( w->connective == COMP ) mn++; - } - tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_preconds = m; - tmp2->num_numeric_preconds = mn; - m = 0; mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) { - tmp2->preconds[m].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->preconds[m].args[i] = w->fact->args[i]; - } - m++; - } - if ( w->connective == COMP ) { - tmp2->numeric_preconds_comp[mn] = w->comp; - tmp2->numeric_preconds_lh[mn] = copy_Exp( w->lh ); - tmp2->numeric_preconds_rh[mn] = copy_Exp( w->rh ); - mn++; - } - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - case ATOM: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_preconds = 1; - tmp2->preconds[0].predicate = tmp1->fact->predicate; - for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { - tmp2->preconds[0].args[i] = tmp1->fact->args[i]; - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - case COMP: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_comp[0] = tmp1->comp; - tmp2->numeric_preconds_lh[0] = copy_Exp( tmp1->lh ); - tmp2->numeric_preconds_rh[0] = copy_Exp( tmp1->rh ); - tmp2->num_numeric_preconds = 1; - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - case TRU: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - default: - printf("\n\nillegal connective %d in parsing DNF precond.\n\n", - tmp1->connective); - exit( 1 ); - } - - free_WffNode( tmp1 ); - -} - - - -Effect *instantiate_Effect( Effect *e ) - -{ - - Effect *res = NULL, *tmp, *i; - Literal *tt, *l; - NumericEffect *ne, *ttt; - int j; - - for ( i = e; i; i = i->next ) { - tmp = new_Effect(); - - for ( j = 0; j < i->num_vars; j++ ) { - tmp->var_types[j] = i->var_types[j]; - } - tmp->num_vars = i->num_vars; - - tmp->conditions = instantiate_wff( i->conditions ); - - if ( tmp->conditions->connective == FAL ) { - free_partial_Effect( tmp ); - continue; - } - - for ( l = i->effects; l; l = l->next ) { - tt = new_Literal(); - tt->negated = l->negated; - tt->fact.predicate = l->fact.predicate; - for ( j = 0; j < garity[tt->fact.predicate]; j++ ) { - tt->fact.args[j] = l->fact.args[j]; - if ( tt->fact.args[j] < 0 && - linst_table[DECODE_VAR( tt->fact.args[j] )] != -1 ) { - tt->fact.args[j] = linst_table[DECODE_VAR( tt->fact.args[j] )]; - } - } - tt->next = tmp->effects; - if ( tmp->effects ) { - tmp->effects->prev = tt; - } - tmp->effects = tt; - } - - for ( ne = i->numeric_effects; ne; ne = ne->next ) { - ttt = new_NumericEffect(); - ttt->neft = ne->neft; - ttt->fluent.function = ne->fluent.function; - for ( j = 0; j < gf_arity[ttt->fluent.function]; j++ ) { - ttt->fluent.args[j] = ne->fluent.args[j]; - if ( ttt->fluent.args[j] < 0 && - linst_table[DECODE_VAR( ttt->fluent.args[j] )] != -1 ) { - ttt->fluent.args[j] = linst_table[DECODE_VAR( ttt->fluent.args[j] )]; - } - } - ttt->rh = copy_Exp( ne->rh ); - instantiate_exp( &(ttt->rh) ); - ttt->next = tmp->numeric_effects; - if ( tmp->numeric_effects ) { - tmp->numeric_effects->prev = ttt; - } - tmp->numeric_effects = ttt; - } - - tmp->next = res; - if ( res ) { - res->prev = tmp; - } - res = tmp; - } - - return res; - -} - - - -WffNode *instantiate_wff( WffNode *w ) - -{ - - WffNode *res = NULL, *tmp, *i; - int j, m, h; - Bool ok, ct; - - switch ( w->connective ) { - case AND: - m = 0; - i = w->sons; - while ( i ) { - tmp = instantiate_wff( i ); - if ( tmp->connective == FAL ) { - free_WffNode( res ); - return tmp; - } - if ( tmp->connective == TRU ) { - free( tmp ); - i = i->next; - continue; - } - tmp->next = res; - if ( res ) { - res->prev = tmp; - } - res = tmp; - i = i->next; - m++; - } - if ( m == 0 ) { - res = new_WffNode( TRU ); - break; - } - if ( m == 1 ) { - break; - } - tmp = new_WffNode( AND ); - tmp->sons = res; - res = tmp; - break; - case OR: - m = 0; - i = w->sons; - while ( i ) { - tmp = instantiate_wff( i ); - if ( tmp->connective == TRU ) { - free_WffNode( res ); - return tmp; - } - if ( tmp->connective == FAL ) { - free( tmp ); - i = i->next; - continue; - } - tmp->next = res; - if ( res ) { - res->prev = tmp; - } - res = tmp; - i = i->next; - m++; - } - if ( m == 0 ) { - res = new_WffNode( FAL ); - break; - } - if ( m == 1 ) { - break; - } - tmp = new_WffNode( OR ); - tmp->sons = res; - res = tmp; - break; - case ATOM: - res = new_WffNode( ATOM ); - res->fact = new_Fact(); - res->fact->predicate = w->fact->predicate; - ok = TRUE; - for ( j = 0; j < garity[res->fact->predicate]; j++ ) { - h = ( w->fact->args[j] < 0 ) ? - linst_table[DECODE_VAR( w->fact->args[j] )] : w->fact->args[j]; - if ( h < 0 ) { - ok = FALSE; - res->fact->args[j] = w->fact->args[j]; - } else { - res->fact->args[j] = h; - } - } - if ( !ok ) {/* contains ef params */ - break; - } - if ( !full_possibly_negative( res->fact ) ) { - free( res->fact ); - res->fact = NULL; - res->connective = TRU; - break; - } - if ( !full_possibly_positive( res->fact ) ) { - free( res->fact ); - res->fact = NULL; - res->connective = FAL; - break; - } - break; - case COMP: - res = new_WffNode( COMP ); - res->comp = w->comp; - res->lh = copy_Exp( w->lh ); - res->rh = copy_Exp( w->rh ); - instantiate_exp( &(res->lh) ); - instantiate_exp( &(res->rh) ); - if ( res->lh->connective != NUMBER || - res->rh->connective != NUMBER ) { - /* logical simplification only possible if both parts are numbers - */ - break; - } - ct = number_comparison_holds( res->comp, res->lh->value, res->rh->value ); - if ( ct ) { - res->connective = TRU; - free_ExpNode( res->lh ); - res->lh = NULL; - free_ExpNode( res->rh ); - res->rh = NULL; - res->comp = -1; - } else { - res->connective = FAL; - free_ExpNode( res->lh ); - res->lh = NULL; - free_ExpNode( res->rh ); - res->rh = NULL; - res->comp = -1; - } - break; - case TRU: - case FAL: - res = new_WffNode( w->connective ); - break; - default: - printf("\n\nillegal connective %d in instantiate formula\n\n", - w->connective); - exit( 1 ); - } - - return res; - -} - - - -void instantiate_exp( ExpNode **n ) - -{ - - int j, f, k, h; - Bool ok; - - switch ( (*n)->connective ) { - case AD: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - instantiate_exp( &((*n)->son) ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - f = (*n)->fluent->function; - ok = TRUE; - for ( j = 0; j < gf_arity[f]; j++ ) { - h = ( (*n)->fluent->args[j] < 0 ) ? - linst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; - if ( h < 0 ) { - ok = FALSE; - } else { - (*n)->fluent->args[j] = h; - } - } - if ( !ok ) { - break; - } - /* we handle only the case where the fluent is fully instantiated, - * static, and in the initial state. - */ - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\ninst exp: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -Bool full_possibly_positive( Fact *f ) - -{ - - int adr; - - if ( gis_added[f->predicate] ) { - return TRUE; - } - - adr = instantiated_fact_adress( f ); - - if ( lini[f->predicate][adr] > 0 ) { - return TRUE; - } else { - return FALSE; - } - -} - - - -Bool full_possibly_negative( Fact *f ) - -{ - - int adr; - - if ( gis_deleted[f->predicate] ) { - return TRUE; - } - - adr = instantiated_fact_adress( f ); - - if ( lini[f->predicate][adr] > 0 ) { - return FALSE; - } else { - return TRUE; - } - -} - - - -int instantiated_fact_adress( Fact *f ) - -{ - - int r = 0, b = 1, i; - - for ( i = 0; i < garity[f->predicate]; i++ ) { - r += b * f->args[i]; - b *= gnum_constants; - } - - return r; - -} - - - - - - - - - - - - - - -/********************************************************* - * CODE THAT MULTIPLIES EFFECT PARAMS --> PSEUDO ACTIONS * - *********************************************************/ - - - - - - - - - - - - - - - -void multiply_hard_effect_parameters( void ) - -{ - - MixedOperator *o; - PseudoAction *tmp; - int i; - Effect *e; - - ghard_templates = ( PseudoAction_pointer * ) - calloc( gnum_hard_mixed_operators, sizeof ( PseudoAction_pointer ) ); - gnum_hard_templates = 0; - - for ( o = ghard_mixed_operators; o; o = o->next ) { - tmp = new_PseudoAction( o ); - - for ( i = 0; i < tmp->operator->num_vars; i++ ) { - linst_table[i] = tmp->inst_table[i]; - } - - for ( e = o->effects; e; e = e->next ) { - create_hard_pseudo_effects( tmp, e, 0 ); - } - - ghard_templates[gnum_hard_templates++] = tmp; - } -} - - - -void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ) - -{ - - int par, t, i, m, mn; - WffNode *tmp1, *w, *ww; - PseudoActionEffect *tmp2; - - if ( curr_var < e->num_vars ) { - par = a->operator->num_vars + curr_var; - - t = e->var_types[curr_var]; - for ( i = 0; i < gtype_size[t]; i++ ) { - linst_table[par] = gtype_consts[t][i]; - - create_hard_pseudo_effects( a, e, curr_var + 1 ); - - linst_table[par] = -1; - } - return; - } - - tmp1 = instantiate_wff( e->conditions ); - - if ( tmp1->connective == FAL ) { - free_WffNode( tmp1 ); - return; - } - - dnf( &tmp1 ); - cleanup_wff( &tmp1 ); - - /* only debugging, REMOVE LATER - */ - if ( is_dnf( tmp1 ) == -1 ) { - printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", a->operator->name); - print_Wff( tmp1, 0 ); - exit( 1 ); - } - - switch ( tmp1->connective ) { - case OR: - for ( w = tmp1->sons; w; w = w->next ) { - tmp2 = new_PseudoActionEffect(); - if ( w->connective == AND ) { - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_conditions = m; - tmp2->num_numeric_conditions = mn; - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp2->conditions[m].predicate = ww->fact->predicate; - for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { - tmp2->conditions[m].args[i] = ww->fact->args[i]; - } - m++; - } - if ( ww->connective == COMP ) { - tmp2->numeric_conditions_comp[mn] = ww->comp; - tmp2->numeric_conditions_lh[mn] = copy_Exp( ww->lh ); - tmp2->numeric_conditions_rh[mn] = copy_Exp( ww->rh ); - mn++; - } - } - } else { - if ( w->connective == ATOM ) { - tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_conditions = 1; - tmp2->conditions[0].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->conditions[0].args[i] = w->fact->args[i]; - } - } - if ( w->connective == COMP ) { - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_comp[0] = w->comp; - tmp2->numeric_conditions_lh[0] = copy_Exp( w->lh ); - tmp2->numeric_conditions_rh[0] = copy_Exp( w->rh ); - tmp2->num_numeric_conditions = 1; - } - } - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - } - break; - case AND: - tmp2 = new_PseudoActionEffect(); - m = 0; - mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) m++; - if ( w->connective == COMP ) mn++; - } - tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_conditions = m; - tmp2->num_numeric_conditions = mn; - m = 0; mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) { - tmp2->conditions[m].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->conditions[m].args[i] = w->fact->args[i]; - } - m++; - } - if ( w->connective == COMP ) { - tmp2->numeric_conditions_comp[mn] = w->comp; - tmp2->numeric_conditions_lh[mn] = copy_Exp( w->lh ); - tmp2->numeric_conditions_rh[mn] = copy_Exp( w->rh ); - mn++; - } - } - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - case ATOM: - tmp2 = new_PseudoActionEffect(); - tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_conditions = 1; - tmp2->conditions[0].predicate = tmp1->fact->predicate; - for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { - tmp2->conditions[0].args[i] = tmp1->fact->args[i]; - } - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - case COMP: - tmp2 = new_PseudoActionEffect(); - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_comp[0] = tmp1->comp; - tmp2->numeric_conditions_lh[0] = copy_Exp( tmp1->lh ); - tmp2->numeric_conditions_rh[0] = copy_Exp( tmp1->rh ); - tmp2->num_numeric_conditions = 1; - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - case TRU: - tmp2 = new_PseudoActionEffect(); - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - default: - printf("\n\nillegal connective %d in parsing DNF condition.\n\n", - tmp1->connective); - exit( 1 ); - } - - free_WffNode( tmp1 ); - -} - - - -void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ) - -{ - - int ma = 0, md = 0, i; - Literal *l; - - for ( l = ll; l; l = l->next ) { - if ( l->negated ) { - md++; - } else { - ma++; - } - } - - e->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - e->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - - for ( l = ll; l; l = l->next ) { - if ( l->negated ) { - e->dels[e->num_dels].predicate = l->fact.predicate; - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - e->dels[e->num_dels].args[i] = ( l->fact.args[i] < 0 ) ? - linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; - } - e->num_dels++; - } else { - e->adds[e->num_adds].predicate = l->fact.predicate; - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - e->adds[e->num_adds].args[i] = ( l->fact.args[i] < 0 ) ? - linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; - } - e->num_adds++; - } - } - -} - - - -void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ) - -{ - - int m = 0, i; - NumericEffect *n; - - for ( n = ne; n; n = n->next ) m++; - - e->numeric_effects_neft = ( NumericEffectType * ) calloc( m, sizeof( NumericEffectType ) ); - e->numeric_effects_fluent = ( Fluent * ) calloc( m, sizeof( Fluent ) ); - e->numeric_effects_rh = ( ExpNode_pointer * ) calloc( m, sizeof( ExpNode_pointer ) ); - e->num_numeric_effects = m; - - m = 0; - for ( n = ne; n; n = n->next ) { - e->numeric_effects_neft[m] = n->neft; - e->numeric_effects_fluent[m].function = n->fluent.function; - for ( i = 0; i < gf_arity[n->fluent.function]; i++ ) { - e->numeric_effects_fluent[m].args[i] = ( n->fluent.args[i] < 0 ) ? - linst_table[DECODE_VAR( n->fluent.args[i] )] : n->fluent.args[i]; - } - e->numeric_effects_rh[m] = copy_Exp( n->rh ); - instantiate_exp( &(e->numeric_effects_rh[m]) ); - m++; - } - -} diff --git a/models/main_models/rt1/gen/ff_planner/inst_hard.h b/models/main_models/rt1/gen/ff_planner/inst_hard.h deleted file mode 100644 index babebc20e..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_hard.h +++ /dev/null @@ -1,71 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: inst_hard.h - * Description: headers for multiplying hard operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - -#ifndef _INST_HARD_H -#define _INST_HARD_H - - - -void build_hard_action_templates( void ); - - - -void cleanup_hard_domain( void ); -Bool var_used_in_literals( int code_var, Literal *ef ); -Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ); -void decrement_inferior_vars_in_literals( int var, Literal *ef ); -void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ); - - - -void multiply_hard_op_parameters( void ); -void create_hard_mixed_operators( Operator *o, int curr_var ); -Effect *instantiate_Effect( Effect *e ); -WffNode *instantiate_wff( WffNode *w ); -void instantiate_exp( ExpNode **n ); -Bool full_possibly_positive( Fact *f ); -Bool full_possibly_negative( Fact *f ); -int instantiated_fact_adress( Fact *f ); - - - -void multiply_hard_effect_parameters( void ); -void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ); -void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ); -void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ); - - - -#endif /* _INST_HARD_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_pre.c b/models/main_models/rt1/gen/ff_planner/inst_pre.c deleted file mode 100644 index 3e6877200..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_pre.c +++ /dev/null @@ -1,3854 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/********************************************************************* - * File: inst_pre.c - * Description: functions for instantiating operators, preprocessing part. - * - transform domain into integers - * - inertia preprocessing: - * - collect inertia info - * - split initial state in special arrays - * - Wff normalization: - * - simplification - * - quantifier expansion - * - NOT s down - * - negative preconditions translation - * - split operators into easy and hard to instantiate - * - * - full DNF functions, only feasible for fully instantiated - * formulae - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" - - - - - - - - - - - - - - - - - - -/******************************************************* - * TRANSFORM DOMAIN INTO INTEGER (FACT) REPRESENTATION * - *******************************************************/ - - - - - - - - - -char *lvar_names[MAX_VARS]; -int lvar_types[MAX_VARS]; - - - - - - - - - - -void encode_domain_in_integers( void ) - -{ - - int i,j; - - collect_all_strings(); - create_member_nrs(); - - if ( gcmd_line.display_info == 103 ) { - printf("\nconstant table:"); - for ( i = 0; i < gnum_constants; i++ ) { - printf("\n%d --> %s", i, gconstants[i]); - } - - printf("\n\ntypes table:"); - for ( i = 0; i < gnum_types; i++ ) { - printf("\n%d --> %s: ", i, gtype_names[i]); - for ( j = 0; j < gtype_size[i]; j++ ) { - printf("%d ", gtype_consts[i][j]); - } - } - - printf("\n\npredicates table:"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n%3d --> %s: ", i, gpredicates[i]); - for ( j = 0; j < garity[i]; j++ ) { - printf("%s ", gtype_names[gpredicates_args_type[i][j]]); - } - } - - printf("\n\nfunctions table:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n%3d --> %s: ", i, gfunctions[i]); - for ( j = 0; j < gf_arity[i]; j++ ) { - printf("%s ", gtype_names[gfunctions_args_type[i][j]]); - } - } - printf("\n\n"); - } - - create_integer_representation(); - - if ( gcmd_line.display_info == 104 ) { - printf("\n\nfirst step initial state is:"); - for ( i = 0; i < gnum_full_initial; i++ ) { - printf("\n"); - print_Fact( &(gfull_initial[i]) ); - } - printf("\n\nfirst step fluent initial state is:"); - for ( i = 0; i < gnum_full_fluents_initial; i++ ) { - printf("\n"); - print_Fluent( &(gfull_fluents_initial[i].fluent) ); - printf(": %f", gfull_fluents_initial[i].value); - } - - printf("\n\nfirst step operators are:"); - for ( i = 0; i < gnum_operators; i++ ) { - print_Operator( goperators[i] ); - } - printf("\n\n"); - - printf("\n\nfirst step goal is:\n"); - print_Wff( ggoal, 0 ); - fflush( stdout ); - - printf("\n\nfirst step metric is: (normalized to minimize)\n"); - print_ExpNode( gmetric ); - fflush( stdout ); - } - -} - - - -void create_member_nrs( void ) - -{ - - int i, j, num; - - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - for ( j = 0; j < MAX_TYPES; j++ ) { - gmember_nr[i][j] = -1; - } - } - - for ( i = 0; i < gnum_types; i++ ) { - num = 0; - for ( j = 0; j < gtype_size[i]; j++ ) { - gmember_nr[gtype_consts[i][j]][i] = num; - num++; - } - } - -} - - - -void collect_all_strings( void ) - -{ - - FactList *f; - TokenList *t; - int p_num, type_num, c_num, ar; - int i; - - /* first are types and their objects. for = we make sure that there - * is one type that contains all objects. - */ - gtype_names[0] = new_Token( 50 ); - gtype_names[0] = "ARTFICIAL-ALL-OBJECTS"; - gtype_size[0] = 0; - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - gis_member[i][0] = FALSE; - } - gnum_types = 1; - - for ( f = gorig_constant_list; f; f = f->next ) { - if ( (type_num = position_in_types_table( f->item->next->item )) == -1 ) { - if ( gnum_types == MAX_TYPES ) { - printf("\ntoo many types! increase MAX_TYPES (currently %d)\n\n", - MAX_TYPES); - exit( 1 ); - } - gtype_names[gnum_types] = new_Token( strlen( f->item->next->item ) + 1 ); - strcpy( gtype_names[gnum_types], f->item->next->item ); - gtype_size[gnum_types] = 0; - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - gis_member[i][gnum_types] = FALSE; - } - type_num = gnum_types++; - } - - if ( (c_num = position_in_constants_table( f->item->item )) == -1 ) { - if ( gnum_constants == MAX_CONSTANTS ) { - printf("\ntoo many constants! increase MAX_CONSTANTS (currently %d)\n\n", - MAX_CONSTANTS); - exit( 1 ); - } - gconstants[gnum_constants] = new_Token( strlen( f->item->item ) + 1 ); - strcpy( gconstants[gnum_constants], f->item->item ); - c_num = gnum_constants++; - - /* all constants into 0-type. - */ - if ( gtype_size[0] == MAX_TYPE ) { - printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", - gtype_names[0], MAX_TYPE); - exit( 1 ); - } - gtype_consts[0][gtype_size[0]++] = c_num; - gis_member[c_num][0] = TRUE; - } - - if ( !gis_member[c_num][type_num] ) { - if ( gtype_size[type_num] == MAX_TYPE ) { - printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", - gtype_names[type_num], MAX_TYPE); - exit( 1 ); - } - gtype_consts[type_num][gtype_size[type_num]++] = c_num; - gis_member[c_num][type_num] = TRUE; - } - } - - /* next are predicates; first of all, create in-built predicate = - */ - gpredicates[0] = new_Token( 5 ); - gpredicates[0] = "="; - gpredicates_args_type[0][0] = 0;/* all objects type */ - gpredicates_args_type[0][1] = 0; - garity[0] = 2; - gnum_predicates = 1; - - for ( f = gpredicates_and_types; f; f = f->next ) { - if ( (p_num = position_in_predicates_table( f->item->item )) != -1 ) { - printf("\npredicate %s declared twice!\n\n", f->item->item); - exit( 1 ); - } - if ( gnum_predicates == MAX_PREDICATES ) { - printf("\ntoo many predicates! increase MAX_PREDICATES (currently %d)\n\n", - MAX_PREDICATES); - exit( 1 ); - } - gpredicates[gnum_predicates] = new_Token( strlen( f->item->item ) + 1 ); - strcpy( gpredicates[gnum_predicates], f->item->item ); - ar = 0; - for ( t = f->item->next; t; t = t->next ) { - if ( (type_num = position_in_types_table( t->item )) == -1 ) { - printf("\npredicate %s is declared to use unknown or empty type %s\n\n", - f->item->item, t->item); - exit( 1 ); - } - if ( ar == MAX_ARITY ) { - printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", - gpredicates[gnum_predicates], MAX_ARITY); - exit( 1 ); - } - gpredicates_args_type[gnum_predicates][ar++] = type_num; - } - garity[gnum_predicates] = ar; - gaxiom_added[gnum_predicates] = FALSE; - gnum_predicates++; - } - - - /* next are functions; first of all, create in-built function total-time - * for sole use in metric - */ - gfunctions[0] = new_Token( 20 ); - gfunctions[0] = "TOTAL-TIME"; - gf_arity[0] = 0; - gnum_functions = 1; - - for ( f = gfunctions_and_types; f; f = f->next ) { - if ( (p_num = position_in_functions_table( f->item->item )) != -1 ) { - printf("\nfunction %s declared twice!\n\n", f->item->item); - exit( 1 ); - } - if ( gnum_functions == MAX_FUNCTIONS ) { - printf("\ntoo many functions! increase MAX_FUNCTIONS (currently %d)\n\n", - MAX_FUNCTIONS); - exit( 1 ); - } - gfunctions[gnum_functions] = new_Token( strlen( f->item->item ) + 1 ); - strcpy( gfunctions[gnum_functions], f->item->item ); - ar = 0; - for ( t = f->item->next; t; t = t->next ) { - if ( (type_num = position_in_types_table( t->item )) == -1 ) { - printf("\nfunction %s is declared to use unknown or empty type %s\n\n", - f->item->item, t->item); - exit( 1 ); - } - if ( ar == MAX_ARITY ) { - printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", - gfunctions[gnum_functions], MAX_ARITY); - exit( 1 ); - } - gfunctions_args_type[gnum_functions][ar++] = type_num; - } - gf_arity[gnum_functions++] = ar; - } - - free_FactList( gorig_constant_list ); - free_FactList( gpredicates_and_types ); - free_FactList( gfunctions_and_types ); - -} - - - -int position_in_types_table( char *str ) - -{ - - int i; - - /* start at 1 because 0 is our artificial one - */ - for ( i = 1; i < gnum_types; i++ ) { - if ( str == gtype_names[i] || - (strcmp( str, gtype_names[i] ) == SAME) ) { - break; - } - } - - return ( i == gnum_types ) ? -1 : i; - -} - - - -int position_in_constants_table( char *str ) - -{ - - int i; - - for ( i=0; isons; n; n = n->next ) sum++; - sum += gnum_constants;/* space for equalities */ - gfull_initial = ( Fact * ) calloc( sum, sizeof( Fact ) ); - gfull_fluents_initial = ( FluentValue * ) - calloc( sum, sizeof( FluentValue )); - - for ( n = gorig_initial_facts->sons; n; n = n->next ) { - if ( n->connective == ATOM ) { - make_Fact( &(gfull_initial[gnum_full_initial]), n, 0 ); - if ( gfull_initial[gnum_full_initial].predicate == 0 ) { - printf("\nequality in initial state! check input files.\n\n"); - exit( 1 ); - } - - /* duplicate check!! - */ - for ( i = 0; i < gnum_full_initial; i++ ) { - if ( gfull_initial[i].predicate != gfull_initial[gnum_full_initial].predicate ) { - /* predicate different --> this ini fact is not a duplicate! - */ - continue; - } - for ( j = 0; j < garity[gfull_initial[i].predicate]; j++ ) { - if ( gfull_initial[i].args[j] != gfull_initial[gnum_full_initial].args[j] ) { - /* arg different --> this ini fact is not a duplicate! - */ - break; - } - } - if ( j == garity[gfull_initial[i].predicate] ) { - /* found a duplicate! - */ - break; - } - } - if ( i < gnum_full_initial ) { - /* simply skip the second occurence... - */ - continue; - } - - gnum_full_initial++; - } else { - /* a fluent value assignment - */ - make_Fluent( &(gfull_fluents_initial[gnum_full_fluents_initial].fluent), - n->lh->atom, 0 ); - gfull_fluents_initial[gnum_full_fluents_initial].value = - ( float ) strtod( n->rh->atom->item, NULL); - gnum_full_fluents_initial++; - } - } - free_PlNode( gorig_initial_facts ); - } - - /* now insert all our artificial equality constraints into initial state. - */ - for ( i = 0; i < gnum_constants; i++ ) { - gfull_initial[gnum_full_initial].predicate = 0; - gfull_initial[gnum_full_initial].args[0] = i; - gfull_initial[gnum_full_initial].args[1] = i; - gnum_full_initial++; - } - /* FINITO. the rest of equality handling will fully - * automatically be done by the rest of the machinery. - */ - - ggoal = make_Wff( gorig_goal_facts, 0 ); - - if ( gparse_metric != NULL ) { - /* no need to throw costs away, even if we're not explicitly asked to - * minimize them - */ - if ( 0 && !gcost_minimizing ) { - if ( gcmd_line.display_info ) { - printf("\n\nno optimization required. skipping criterion.\n\n"); - } - } else { - gmetric = make_ExpNode( gparse_metric, 0 ); - if ( strcmp( gparse_optimization, "MINIMIZE" ) != SAME && - strcmp( gparse_optimization, "minimize" ) != SAME && - strcmp( gparse_optimization, "MAXIMIZE" ) != SAME && - strcmp( gparse_optimization, "maximize" ) != SAME ) { - if ( gcmd_line.display_info ) { - printf("\n\nunknown optimization method %s. check input files\n\n", - gparse_optimization); - } - exit( 1 ); - } - if ( strcmp( gparse_optimization, "MAXIMIZE" ) == SAME || - strcmp( gparse_optimization, "maximize" ) == SAME ) { - t = new_ExpNode( MINUS ); - t->son = gmetric; - gmetric = t; - } - } - } - - for ( o = gloaded_ops; o; o = o->next ) { - tmp = new_Operator( o->name, o->number_of_real_params ); - tmp->axiom = o->axiom; - - for ( ff = o->params; ff; ff = ff->next ) { - if ( (type_num = position_in_types_table( ff->item->next->item )) == -1 ) { - printf("\nwarning: parameter %s of op %s has unknown or empty type %s. skipping op", - ff->item->item, o->name, ff->item->next->item); - break; - } - if ( tmp->num_vars == MAX_VARS ) { - printf("\ntoo many parameters! increase MAX_VARS (currently %d)\n\n", - MAX_VARS); - exit( 1 ); - } - for ( i = 0; i < tmp->num_vars; i++ ) { - if ( tmp->var_names[i] == ff->item->item || - strcmp( tmp->var_names[i], ff->item->item ) == SAME ) { - printf("\nwarning: operator %s parameter %s overwrites previous declaration\n\n", - tmp->name, ff->item->item); - } - } - tmp->var_names[tmp->num_vars] = new_Token( strlen( ff->item->item ) + 1 ); - strcpy( tmp->var_names[tmp->num_vars], ff->item->item ); - tmp->var_types[tmp->num_vars++] = type_num; - } - if ( ff ) { - free_Operator( tmp ); - continue; - } - - for ( i = 0; i < tmp->num_vars; i++ ) { - lvar_types[i] = tmp->var_types[i]; - lvar_names[i] = tmp->var_names[i]; - } - - tmp->preconds = make_Wff( o->preconds, tmp->num_vars ); - - if ( o->effects ) { - /* in make_effect, make sure that no one afects equality. - */ - nn = o->effects->sons; - while ( nn && - (tmp->effects = make_effect( nn, tmp->num_vars )) == NULL ) { - nn = nn->next; - } - if ( nn ) { - for ( n = nn->next; n; n = n->next ) { - if ( (tmp->effects->prev = make_effect( n, tmp->num_vars )) == NULL ) { - continue; - } - tmp->effects->prev->next = tmp->effects; - tmp->effects = tmp->effects->prev; - } - } - } - - if ( gnum_operators == MAX_OPERATORS ) { - printf("\ntoo many operators! increase MAX_OPERATORS (currently %d)\n\n", - MAX_OPERATORS); - exit( 1 ); - } - goperators[gnum_operators++] = tmp; - } - - if ( 0 ) { - /* currently not in use; leads to free memory reads and - * free memory frees (no memory leaks), which are hard to explain. - * - * almost no memory consumption anyway. - */ - free_PlOperator( gloaded_ops ); - } - - /* establish gaxiom_added markers. - * ascertain that derived predicates do not appear in effects!! - */ - for ( i = 0; i < gnum_operators; i++ ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - for ( l = e->effects; l; l = l->next ) { - if ( goperators[i]->axiom ) { - gaxiom_added[l->fact.predicate] = TRUE; - } - } - } - } - for ( i = 0; i < gnum_operators; i++ ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - for ( l = e->effects; l; l = l->next ) { - if ( !goperators[i]->axiom && - gaxiom_added[l->fact.predicate] ) { - printf("\nA derived predicate appears in an operator effect."); - printf("\nSorry, this is not allowed. Bailing out.\n\n"); - exit( 1 ); - } - } - } - } - -} - - - -void make_Fact( Fact *f, PlNode *n, int num_vars ) - -{ - - int m, i; - TokenList *t; - - if ( !n->atom ) { - /* can't happen after previous syntax check. Oh well, whatever... - */ - printf("\nillegal (empty) atom used in domain. check input files\n\n"); - exit( 1 ); - } - - f->predicate = position_in_predicates_table( n->atom->item ); - if ( f->predicate == -1 ) { - printf("\nundeclared predicate %s used in domain definition\n\n", - n->atom->item); - exit( 1 ); - } - - m = 0; - for ( t = n->atom->next; t; t = t->next ) { - if ( t->item[0] == '?' ) { - for ( i=num_vars-1; i>-1; i-- ) { - /* downwards, to always get most recent declaration/quantification - * of that variable - */ - if ( lvar_names[i] == t->item || - strcmp( lvar_names[i], t->item ) == SAME ) { - break; - } - } - if ( i == -1 ) { - printf("\nundeclared variable %s in literal %s. check input files\n\n", - t->item, n->atom->item); - exit( 1 ); - } - if ( lvar_types[i] != gpredicates_args_type[f->predicate][m] && - !is_subtype( lvar_types[i], gpredicates_args_type[f->predicate][m] ) ) { - printf("\ntype of var %s does not match type of arg %d of predicate %s\n\n", - lvar_names[i], m, gpredicates[f->predicate]); - exit( 1 ); - } - f->args[m] = ENCODE_VAR( i ); - } else { - if ( (f->args[m] = - position_in_constants_table( t->item )) == -1 ) { - printf("\nunknown constant %s in literal %s. check input files\n\n", - t->item, n->atom->item); - exit( 1 ); - } - if ( !gis_member[f->args[m]][gpredicates_args_type[f->predicate][m]] ) { - printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", - gconstants[f->args[m]], m, gpredicates[f->predicate]); - exit( 1 ); - } - } - m++; - } - if ( m != garity[f->predicate] ) { - printf("\npredicate %s is declared to have %d (not %d) arguments. check input files\n\n", - gpredicates[f->predicate], - garity[f->predicate], m); - exit( 1 ); - } - -} - - - -void make_Fluent( Fluent *f, TokenList *atom, int num_vars ) - -{ - - int m, i; - TokenList *t; - - if ( !atom ) { - /* can't happen after previous syntax check. Oh well, whatever... - */ - printf("\nillegal (empty) atom used in domain. check input files\n\n"); - exit( 1 ); - } - - f->function = position_in_functions_table( atom->item ); - if ( f->function == -1 ) { - printf("\nundeclared function %s used in domain definition\n\n", - atom->item); - exit( 1 ); - } - - m = 0; - for ( t = atom->next; t; t = t->next ) { - if ( t->item[0] == '?' ) { - for ( i=num_vars-1; i>-1; i-- ) { - /* downwards, to always get most recent declaration/quantification - * of that variable - */ - if ( lvar_names[i] == t->item || - strcmp( lvar_names[i], t->item ) == SAME ) { - break; - } - } - if ( i == -1 ) { - printf("\nundeclared variable %s in function %s. check input files\n\n", - t->item, atom->item); - exit( 1 ); - } - if ( lvar_types[i] != gfunctions_args_type[f->function][m] && - !is_subtype( lvar_types[i], gfunctions_args_type[f->function][m] ) ) { - printf("\ntype of var %s does not match type of arg %d of function %s\n\n", - lvar_names[i], m, gfunctions[f->function]); - exit( 1 ); - } - f->args[m] = ENCODE_VAR( i ); - } else { - if ( (f->args[m] = - position_in_constants_table( t->item )) == -1 ) { - printf("\nunknown constant %s in function %s. check input files\n\n", - t->item, atom->item); - exit( 1 ); - } - if ( !gis_member[f->args[m]][gfunctions_args_type[f->function][m]] ) { - printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", - gconstants[f->args[m]], m, gfunctions[f->function]); - exit( 1 ); - } - } - m++; - } - - if ( m != gf_arity[f->function] ) { - printf("\nfunction %s is declared to have %d (not %d) arguments. check input files\n\n", - gfunctions[f->function], - gf_arity[f->function], m); - exit( 1 ); - } - -} - - - -Bool is_subtype( int t1, int t2 ) - -{ - - int i; - - for ( i = 0; i < gtype_size[t1]; i++ ) { - if ( !gis_member[gtype_consts[t1][i]][t2] ) { - return FALSE; - } - } - - return TRUE; - -} - - - -WffNode *make_Wff( PlNode *p, int num_vars ) - -{ - - WffNode *tmp; - int i, t; - PlNode *n; - - if ( !p ) { - tmp = NULL; - return tmp; - } - - tmp = new_WffNode( p->connective ); - switch ( p->connective ) { - case ALL: - case EX: - for ( i = 0; i < num_vars; i++ ) { - if ( lvar_names[i] == p->atom->item || - strcmp( lvar_names[i], p->atom->item ) == SAME ) { - printf("\nwarning: var quantification of %s overwrites previous declaration\n\n", - p->atom->item); - } - } - if ( (t = position_in_types_table( p->atom->next->item )) == -1 ) { - printf("\nwarning: quantified var %s has unknown or empty type %s. simplifying.\n\n", - p->atom->item, p->atom->next->item); - tmp->connective = ( p->connective == EX ) ? FAL : TRU; - break; - } - tmp->var = num_vars; - tmp->var_type = t; - tmp->var_name = new_Token( strlen( p->atom->item ) + 1 ); - strcpy( tmp->var_name, p->atom->item ); - lvar_names[num_vars] = p->atom->item; - lvar_types[num_vars] = t; - tmp->son = make_Wff( p->sons, num_vars + 1 ); - break; - case AND: - case OR: - if ( !p->sons ) { - printf("\nwarning: empty con/disjunction in domain definition. simplifying.\n\n"); - tmp->connective = ( p->connective == OR ) ? FAL : TRU; - break; - } - tmp->sons = make_Wff( p->sons, num_vars ); - for ( n = p->sons->next; n; n = n->next ) { - tmp->sons->prev = make_Wff( n, num_vars ); - tmp->sons->prev->next = tmp->sons; - tmp->sons = tmp->sons->prev; - } - break; - case NOT: - tmp->son = make_Wff( p->sons, num_vars ); - break; - case ATOM: - tmp->fact = new_Fact(); - make_Fact( tmp->fact, p, num_vars ); - break; - case TRU: - case FAL: - break; - case COMP: - tmp->comp = p->comp; - tmp->lh = make_ExpNode( p->lh, num_vars ); - tmp->rh = make_ExpNode( p->rh, num_vars ); - break; - default: - printf("\nforbidden connective %d in Pl Wff. must be a bug somewhere...\n\n", - p->connective); - exit( 1 ); - } - - return tmp; - -} - - - -ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ) - -{ - - ExpNode *tmp; - - if ( !p ) { - tmp = NULL; - return tmp; - } - - tmp = new_ExpNode( p->connective ); - switch ( p->connective ) { - case AD: - case SU: - case MU: - case DI: - tmp->leftson = make_ExpNode( p->leftson, num_vars ); - tmp->rightson = make_ExpNode( p->rightson, num_vars ); - break; - case MINUS: - tmp->son = make_ExpNode( p->leftson, num_vars ); - break; - case NUMBER: - tmp->value = ( float ) strtod( p->atom->item, NULL ); - break; - case FHEAD: - tmp->fluent = new_Fluent(); - make_Fluent( tmp->fluent, p->atom, num_vars ); - break; - default: - printf("\n\nmake expnode: wrong specifier %d", - p->connective); - exit( 1 ); - } - - return tmp; - -} - - - -Effect *make_effect( PlNode *p, int num_vars ) - -{ - - Effect *tmp = new_Effect(); - PlNode *n, *m; - int t, i; - - for ( n = p; n && n->connective == ALL; n = n->sons ) { - if ( (t = position_in_types_table( n->atom->next->item )) == -1 ) { - printf("\nwarning: effect parameter %s has unknown or empty type %s. skipping effect.\n\n", - n->atom->item, n->atom->next->item); - return NULL; - } - for ( i = 0; i < num_vars + tmp->num_vars; i++ ) { - if ( lvar_names[i] == n->atom->item || - strcmp( lvar_names[i], n->atom->item ) == SAME ) { - printf("\nwarning: effect parameter %s overwrites previous declaration\n\n", - n->atom->item); - } - } - lvar_types[num_vars + tmp->num_vars] = t; - lvar_names[num_vars + tmp->num_vars] = n->atom->item; - tmp->var_names[tmp->num_vars] = new_Token( strlen( n->atom->item ) + 1 ); - strcpy( tmp->var_names[tmp->num_vars], n->atom->item ); - tmp->var_types[tmp->num_vars++] = t; - } - - if ( !n || n->connective != WHEN ) { - printf("\nnon WHEN %d at end of effect parameters. debug me\n\n", - n->connective); - exit( 1 ); - } - - tmp->conditions = make_Wff( n->sons, num_vars + tmp->num_vars ); - - if ( n->sons->next->connective != AND ) { - printf("\nnon AND %d in front of literal effect list. debug me\n\n", - n->sons->next->connective); - exit( 1 ); - } - if ( !n->sons->next->sons ) { - return tmp; - } - for ( m = n->sons->next->sons; m; m = m->next ) { - if ( m->connective == NEF ) { - if ( tmp->numeric_effects != NULL ) { - tmp->numeric_effects->prev = new_NumericEffect(); - make_Fluent( &(tmp->numeric_effects->prev->fluent), - m->lh->atom, num_vars + tmp->num_vars ); - tmp->numeric_effects->prev->neft = m->neft; - tmp->numeric_effects->prev->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); - - tmp->numeric_effects->prev->next = tmp->numeric_effects; - tmp->numeric_effects = tmp->numeric_effects->prev; - } else { - tmp->numeric_effects = new_NumericEffect(); - make_Fluent( &(tmp->numeric_effects->fluent), - m->lh->atom, num_vars + tmp->num_vars ); - tmp->numeric_effects->neft = m->neft; - tmp->numeric_effects->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); - } - } else { - if ( tmp->effects != NULL ) { - tmp->effects->prev = new_Literal(); - if ( m->connective == NOT ) { - tmp->effects->prev->negated = TRUE; - make_Fact( &(tmp->effects->prev->fact), m->sons, num_vars + tmp->num_vars ); - if ( (tmp->effects->prev->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } else { - tmp->effects->prev->negated = FALSE; - make_Fact( &(tmp->effects->prev->fact), m, num_vars + tmp->num_vars ); - if ( (tmp->effects->prev->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } - tmp->effects->prev->next = tmp->effects; - tmp->effects = tmp->effects->prev; - } else { - tmp->effects = new_Literal(); - if ( m->connective == NOT ) { - tmp->effects->negated = TRUE; - make_Fact( &(tmp->effects->fact), m->sons, num_vars + tmp->num_vars ); - if ( (tmp->effects->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } else { - tmp->effects->negated = FALSE; - make_Fact( &(tmp->effects->fact), m, num_vars + tmp->num_vars ); - if ( (tmp->effects->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } - } - } - } - - return tmp; - -} - - - - - - - - - - - -/************************* - * INERTIA PREPROCESSING * - *************************/ - - - - - - - - - - - -void do_inertia_preprocessing_step_1( void ) - -{ - - int i, j; - Facts *f; - FluentValues *ff; - - collect_inertia_information(); - - if ( gcmd_line.display_info == 105 ) { - printf("\n\npredicates inertia info:"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n%3d --> %s: ", i, gpredicates[i]); - printf(" is %s, %s", - gis_added[i] ? "ADDED" : "NOT ADDED", - gis_deleted[i] ? "DELETED" : "NOT DELETED"); - } - printf("\n\nfunctions inertia info:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n%3d --> %s: ", i, gfunctions[i]); - printf(" is %s", - gis_changed[i] ? "CHANGED" : "NOT CHANGED"); - } - printf("\n\n"); - } - - split_initial_state(); - - if ( gcmd_line.display_info == 106 ) { - printf("\n\nsplitted initial state is:"); - printf("\nindividual predicates:"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n\n%s:", gpredicates[i]); - if ( !gis_added[i] && - !gis_deleted[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - printf("\n"); - print_Fact( &(ginitial_predicate[i][j]) ); - } - } - printf("\n\nnon static part:"); - for ( f = ginitial; f; f = f->next ) { - printf("\n"); - print_Fact( f->fact ); - } - - printf("\n\nextended types table:"); - for ( i = 0; i < gnum_types; i++ ) { - printf("\n%d --> ", i); - if ( gpredicate_to_type[i] == -1 ) { - printf("%s ", gtype_names[i]); - } else { - printf("UNARY INERTIA TYPE (%s) ", gpredicates[gpredicate_to_type[i]]); - } - for ( j = 0; j < gtype_size[i]; j++ ) { - printf("%d ", gtype_consts[i][j]); - } - } - - printf("\nindividual functions:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n\n%s:", gfunctions[i]); - if ( !gis_changed[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_function[i]; j++ ) { - printf("\n"); - print_Fluent( &(ginitial_function[i][j].fluent) ); - printf(": %f", ginitial_function[i][j].value); - } - } - printf("\n\nnon static part:"); - for ( ff = gf_initial; ff; ff = ff->next ) { - printf("\n"); - print_Fluent( &(ff->fluent) ); - printf(": %f", ff->value); - } - } - -} - - - -void collect_inertia_information( void ) - -{ - - int i; - Effect *e; - Literal *l; - NumericEffect *ne; - - for ( i = 0; i < gnum_predicates; i++ ) { - gis_added[i] = FALSE; - gis_deleted[i] = FALSE; - } - for ( i = 0; i < gnum_functions; i++ ) { - gis_changed[i] = FALSE; - } - - for ( i = 0; i < gnum_operators; i++ ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - gis_deleted[l->fact.predicate] = TRUE; - } else { - gis_added[l->fact.predicate] = TRUE; - } - } - for ( ne = e->numeric_effects; ne; ne = ne->next ) { - gis_changed[ne->fluent.function] = TRUE; - } - } - } - -} - - - -void split_initial_state( void ) - -{ - - int i, j, p, t; - Facts *tmp; - FluentValues *ftmp; - - for ( i = 0; i < MAX_PREDICATES; i++ ) { - gtype_to_predicate[i] = -1; - } - for ( i = 0; i < MAX_TYPES; i++ ) { - gpredicate_to_type[i] = -1; - } - - for ( i = 0; i < gnum_predicates; i++ ) { - if ( !gis_added[i] && - !gis_deleted[i] && - garity[i] == 1 ) { - if ( gnum_types == MAX_TYPES ) { - printf("\ntoo many (inferred) types! increase MAX_TYPES (currently %d)\n\n", - MAX_TYPES); - exit( 1 ); - } - gtype_to_predicate[i] = gnum_types; - gpredicate_to_type[gnum_types] = i; - gtype_names[gnum_types] = NULL; - gtype_size[gnum_types] = 0; - for ( j = 0; j < MAX_CONSTANTS; j++ ) { - gis_member[j][gnum_types] = FALSE; - } - gnum_types++; - } - } - - - /* double size of predicates table as each predicate might need - * to be translated to NOT-p - */ - ginitial_predicate = ( Fact ** ) calloc( gnum_predicates * 2, sizeof( Fact * ) ); - gnum_initial_predicate = ( int * ) calloc( gnum_predicates * 2, sizeof( int ) ); - for ( i = 0; i < gnum_predicates * 2; i++ ) { - gnum_initial_predicate[i] = 0; - } - for ( i = 0; i < gnum_full_initial; i++ ) { - p = gfull_initial[i].predicate; - gnum_initial_predicate[p]++; - } - for ( i = 0; i < gnum_predicates; i++ ) { - ginitial_predicate[i] = ( Fact * ) calloc( gnum_initial_predicate[i], sizeof( Fact ) ); - gnum_initial_predicate[i] = 0; - } - ginitial = NULL; - gnum_initial = 0; - - for ( i = 0; i < gnum_full_initial; i++ ) { - p = gfull_initial[i].predicate; - ginitial_predicate[p][gnum_initial_predicate[p]].predicate = p; - for ( j = 0; j < garity[p]; j++ ) { - ginitial_predicate[p][gnum_initial_predicate[p]].args[j] = gfull_initial[i].args[j]; - } - gnum_initial_predicate[p]++; - if ( gis_added[p] || - gis_deleted[p] ) { - tmp = new_Facts(); - tmp->fact->predicate = p; - for ( j = 0; j < garity[p]; j++ ) { - tmp->fact->args[j] = gfull_initial[i].args[j]; - } - tmp->next = ginitial; - ginitial = tmp; - gnum_initial++; - } else { - if ( garity[p] == 1 ) { - t = gtype_to_predicate[p]; - if ( gtype_size[t] == MAX_TYPE ) { - printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", - gtype_names[t], MAX_TYPE); - exit( 1 ); - } - if ( !gis_member[gfull_initial[i].args[0]][gpredicates_args_type[p][0]] ) { - printf("\ntype mismatch in initial state! %s as arg 0 of %s\n\n", - gconstants[gfull_initial[i].args[0]], gpredicates[p]); - exit( 1 ); - } - gtype_consts[t][gtype_size[t]++] = gfull_initial[i].args[0]; - gis_member[gfull_initial[i].args[0]][t] = TRUE; - } - } - } - - ginitial_function = ( FluentValue ** ) - calloc( gnum_functions, sizeof( FluentValue * ) ); - gnum_initial_function = ( int * ) calloc( gnum_functions, sizeof( int ) ); - for ( i = 0; i < gnum_functions; i++ ) { - gnum_initial_function[i] = 0; - } - for ( i = 0; i < gnum_full_fluents_initial; i++ ) { - p = gfull_fluents_initial[i].fluent.function; - gnum_initial_function[p]++; - } - for ( i = 0; i < gnum_functions; i++ ) { - ginitial_function[i] = ( FluentValue * ) - calloc( gnum_initial_function[i], sizeof( FluentValue ) ); - gnum_initial_function[i] = 0; - } - gf_initial = NULL; - gnum_f_initial = 0; - - for ( i = 0; i < gnum_full_fluents_initial; i++ ) { - p = gfull_fluents_initial[i].fluent.function; - ginitial_function[p][gnum_initial_function[p]].fluent.function = p; - for ( j = 0; j < gf_arity[p]; j++ ) { - ginitial_function[p][gnum_initial_function[p]].fluent.args[j] = - gfull_fluents_initial[i].fluent.args[j]; - } - ginitial_function[p][gnum_initial_function[p]].value = - gfull_fluents_initial[i].value; - gnum_initial_function[p]++; - if ( gis_changed[p] ) { - ftmp = new_FluentValues(); - ftmp->fluent.function = p; - for ( j = 0; j < gf_arity[p]; j++ ) { - ftmp->fluent.args[j] = gfull_fluents_initial[i].fluent.args[j]; - } - ftmp->value = gfull_fluents_initial[i].value; - ftmp->next = gf_initial; - gf_initial = ftmp; - gnum_f_initial++; - } - } - -} - - - - - - - - - - - -/****************************** - * NORMALIZE ALL PL1 FORMULAE * - ******************************/ - - - - - - - - - - - - -void normalize_all_wffs( void ) - -{ - - int i; - Effect *e; - - simplify_wff( &ggoal ); - remove_unused_vars_in_wff( &ggoal ); - expand_quantifiers_in_wff( &ggoal, -1, -1 ); - NOTs_down_in_wff( &ggoal ); - cleanup_wff( &ggoal ); - - if ( ggoal->connective == TRU ) { - printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); - gnum_plan_ops = 0; - exit( 1 ); - } - if ( ggoal->connective == FAL ) { - printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); - exit( 1 ); - } - - /* put goal into DNF right away: fully instantiated already - */ - dnf( &ggoal ); - cleanup_wff( &ggoal ); - - /* all we can do here is simplify if that's possible. - */ - if ( gmetric != NULL ) { - simplify_exp( &gmetric ); - } - - - for ( i = 0; i < gnum_operators; i++ ) { - simplify_wff( &(goperators[i]->preconds) ); - remove_unused_vars_in_wff( &(goperators[i]->preconds) ); - expand_quantifiers_in_wff( &(goperators[i]->preconds), -1, -1 ); - NOTs_down_in_wff( &(goperators[i]->preconds) ); - cleanup_wff( &(goperators[i]->preconds) ); - - for ( e = goperators[i]->effects; e; e = e->next ) { - simplify_wff( &(e->conditions) ); - remove_unused_vars_in_wff( &(e->conditions) ); - expand_quantifiers_in_wff( &(e->conditions), -1, -1 ); - NOTs_down_in_wff( &(e->conditions) ); - cleanup_wff( &(e->conditions) ); - } - } - - if ( gcmd_line.display_info == 107 ) { - printf("\n\ndomain with normalized PL1 formula:"); - - printf("\n\noperators are:"); - for ( i = 0; i < gnum_operators; i++ ) { - print_Operator( goperators[i] ); - } - printf("\n\n"); - - printf("\n\ngoal is:\n"); - print_Wff( ggoal, 0 ); - - if ( gmetric ) { - printf("\n\nmetric is (minimize):\n"); - print_ExpNode( gmetric ); - } else { - printf("\n\nmetric: none, i.e. plan length\n"); - } - } - -} - - - -void remove_unused_vars_in_wff( WffNode **w ) - -{ - - WffNode *tmp; - WffNode *i; - - switch ( (*w)->connective ) { - case ALL: - case EX: - remove_unused_vars_in_wff( &((*w)->son) ); - if ( !var_used_in_wff( ENCODE_VAR( (*w)->var ), (*w)->son ) ) { - decrement_inferior_vars((*w)->var, (*w)->son ); - (*w)->connective = (*w)->son->connective; - (*w)->var = (*w)->son->var; - (*w)->var_type = (*w)->son->var_type; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = (*w)->son->var_name; - (*w)->sons = (*w)->son->sons; - if ( (*w)->fact ) { - free( (*w)->fact ); - } - (*w)->fact = (*w)->son->fact; - (*w)->comp = (*w)->son->comp; - if ( (*w)->lh ) free_ExpNode( (*w)->lh ); - if ( (*w)->rh ) free_ExpNode( (*w)->rh ); - (*w)->lh = (*w)->son->lh; - (*w)->rh = (*w)->son->rh; - - tmp = (*w)->son; - (*w)->son = (*w)->son->son; - free( tmp ); - } - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - remove_unused_vars_in_wff( &i ); - } - break; - case NOT: - remove_unused_vars_in_wff( &((*w)->son) ); - break; - case COMP: - case ATOM: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: remove var, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -Bool var_used_in_wff( int code_var, WffNode *w ) - -{ - - WffNode *i; - int j; - - switch ( w->connective ) { - case ALL: - case EX: - return var_used_in_wff( code_var, w->son ); - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - if ( var_used_in_wff( code_var, i ) ) { - return TRUE; - } - } - return FALSE; - case NOT: - return var_used_in_wff( code_var, w->son ); - case ATOM: - for ( j = 0; j < garity[w->fact->predicate]; j++ ) { - if ( w->fact->args[j] >= 0 ) { - continue; - } - if ( w->fact->args[j] == code_var ) { - return TRUE; - } - } - return FALSE; - case COMP: - if ( var_used_in_exp( code_var, w->lh ) ) { - return TRUE; - } - if ( var_used_in_exp( code_var, w->rh ) ) { - return TRUE; - } - return FALSE; - case TRU: - case FAL: - return FALSE; - default: - printf("\nwon't get here: var used ?, non logical %d\n\n", - w->connective); - exit( 1 ); - } - - -} - - - -Bool var_used_in_exp( int code_var, ExpNode *n ) - -{ - - int i; - - switch ( n->connective ) { - case AD: - case SU: - case MU: - case DI: - if ( var_used_in_exp( code_var, n->leftson ) || - var_used_in_exp( code_var, n->rightson ) ) { - return TRUE; - } - return FALSE; - case MINUS: - if ( var_used_in_exp( code_var, n->son ) ) { - return TRUE; - } - return FALSE; - case NUMBER: - return FALSE; - case FHEAD: - if ( n->fluent ) { - for ( i = 0; i < gf_arity[n->fluent->function]; i++ ) { - if ( n->fluent->args[i] >= 0 ) { - continue; - } - if ( n->fluent->args[i] == code_var ) { - return TRUE; - } - } - } else { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - } - return FALSE; - default: - printf("\n\nvar used in expnode: wrong specifier %d", - n->connective); - exit( 1 ); - } - -} - - - -void decrement_inferior_vars( int var, WffNode *w ) - -{ - - WffNode *i; - int j; - - switch ( w->connective ) { - case ALL: - case EX: - w->var--; - decrement_inferior_vars( var, w->son ); - break; - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - decrement_inferior_vars( var, i ); - } - break; - case NOT: - decrement_inferior_vars( var, w->son ); - break; - case ATOM: - for ( j = 0; j < garity[w->fact->predicate]; j++ ) { - if ( w->fact->args[j] >= 0 ) { - continue; - } - if ( DECODE_VAR( w->fact->args[j] ) > var ) { - w->fact->args[j]++; - } - } - break; - case COMP: - decrement_inferior_vars_in_exp( var, w->lh ); - decrement_inferior_vars_in_exp( var, w->rh ); - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: decrement, non logical %d\n\n", - w->connective); - exit( 1 ); - } - -} - - - -void decrement_inferior_vars_in_exp( int var, ExpNode *n ) - -{ - - int j; - - switch ( n->connective ) { - case AD: - case SU: - case MU: - case DI: - decrement_inferior_vars_in_exp( var, n->leftson ); - decrement_inferior_vars_in_exp( var, n->rightson ); - break; - case MINUS: - decrement_inferior_vars_in_exp( var, n->son ); - break; - case NUMBER: - break; - case FHEAD: - if ( n->fluent ) { - for ( j = 0; j < gf_arity[n->fluent->function]; j++ ) { - if ( n->fluent->args[j] >= 0 ) { - continue; - } - if ( DECODE_VAR( n->fluent->args[j] ) > var ) { - n->fluent->args[j]++; - } - } - } else { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - } - break; - default: - printf("\n\ndecr inf vars in expnode: wrong specifier %d", - n->connective); - exit( 1 ); - } - -} - - - -void simplify_wff( WffNode **w ) - -{ - - WffNode *i, *tmp; - int m; - Bool ct; - - switch ( (*w)->connective ) { - case ALL: - case EX: - simplify_wff( &((*w)->son) ); - if ( (*w)->son->connective == TRU || - (*w)->son->connective == FAL ) { - (*w)->connective = (*w)->son->connective; - free( (*w)->son ); - (*w)->son = NULL; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - } - break; - case AND: - m = 0; - i = (*w)->sons; - while ( i ) { - simplify_wff( &i ); - if ( i->connective == FAL ) { - (*w)->connective = FAL; - /* free_WffNode( (*w)->sons ); */ - (*w)->sons = NULL; - return; - } - if ( i->connective == TRU ) { - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - if ( i->next ) { - i->next->prev = i->prev; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - m++; - } - if ( m == 0 ) { - (*w)->connective = TRU; - free_WffNode( (*w)->sons ); - (*w)->sons = NULL; - } - if ( m == 1 ) { - (*w)->connective = (*w)->sons->connective; - (*w)->var = (*w)->sons->var; - (*w)->var_type = (*w)->sons->var_type; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = (*w)->sons->var_name; - (*w)->son = (*w)->sons->son; - if ( (*w)->fact ) { - free( (*w)->fact ); - } - (*w)->fact = (*w)->sons->fact; - (*w)->comp = (*w)->sons->comp; - if ( (*w)->lh ) free_ExpNode( (*w)->lh ); - if ( (*w)->rh ) free_ExpNode( (*w)->rh ); - (*w)->lh = (*w)->sons->lh; - (*w)->rh = (*w)->sons->rh; - - tmp = (*w)->sons; - (*w)->sons = (*w)->sons->sons; - free( tmp ); - } - break; - case OR: - m = 0; - i = (*w)->sons; - while ( i ) { - simplify_wff( &i ); - if ( i->connective == TRU ) { - (*w)->connective = TRU; - free_WffNode( (*w)->sons ); - (*w)->sons = NULL; - return; - } - if ( i->connective == FAL ) { - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - if ( i->next ) { - i->next->prev = i->prev; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - m++; - } - if ( m == 0 ) { - (*w)->connective = FAL; - /* free_WffNode( (*w)->sons ); */ - (*w)->sons = NULL; - } - if ( m == 1 ) { - (*w)->connective = (*w)->sons->connective; - (*w)->var = (*w)->sons->var; - (*w)->var_type = (*w)->sons->var_type; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = (*w)->sons->var_name; - (*w)->son = (*w)->sons->son; - if ( (*w)->fact ) { - free( (*w)->fact ); - } - (*w)->fact = (*w)->sons->fact; - (*w)->comp = (*w)->sons->comp; - if ( (*w)->lh ) free_ExpNode( (*w)->lh ); - if ( (*w)->rh ) free_ExpNode( (*w)->rh ); - (*w)->lh = (*w)->sons->lh; - (*w)->rh = (*w)->sons->rh; - - tmp = (*w)->sons; - (*w)->sons = (*w)->sons->sons; - free( tmp ); - } - break; - case NOT: - simplify_wff( &((*w)->son) ); - if ( (*w)->son->connective == TRU || - (*w)->son->connective == FAL ) { - (*w)->connective = ( (*w)->son->connective == TRU ) ? FAL : TRU; - free( (*w)->son ); - (*w)->son = NULL; - } - break; - case ATOM: - if ( (*w)->visited ) { - /* already seen and not changed - */ - break; - } - if ( !possibly_negative( (*w)->fact ) ) { - (*w)->connective = TRU; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - if ( !possibly_positive( (*w)->fact ) ) { - (*w)->connective = FAL; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - (*w)->visited = TRUE; - break; - case COMP: - simplify_exp( &((*w)->lh) ); - simplify_exp( &((*w)->rh) ); - if ( (*w)->lh->connective != NUMBER || - (*w)->rh->connective != NUMBER ) { - /* logical simplification only possible if both parts are numbers - */ - break; - } - ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); - if ( ct ) { - (*w)->connective = TRU; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } else { - (*w)->connective = FAL; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: simplify, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void simplify_exp( ExpNode **n ) - -{ - - int j, f, k; - - switch ( (*n)->connective ) { - case AD: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - simplify_exp( &((*n)->son) ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - if ( !(*n)->fluent ) { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - break; - } - f = (*n)->fluent->function; - for ( j = 0; j < gf_arity[f]; j++ ) { - if ( (*n)->fluent->args[j] < 0 ) { - break; - } - } - if ( j < gf_arity[f] ) { - break; - } - /* we handle only the case where the fluent is fully instantiated, - * static, and in the initial state. - */ - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\nsimplify expnode: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -void expand_quantifiers_in_wff( WffNode **w, int var, int constant ) - -{ - - WffNode *r = NULL, *tmp, *i; - int j, l; - Bool change, ct; - - if ( !(*w) ) { - return; - } - - switch ( (*w)->connective ) { - case ALL: - case EX: - if ( var != -1 ) {/* depth first: upper node is active */ - expand_quantifiers_in_wff( &((*w)->son), var, constant ); - return; - } - - (*w)->connective = ( (*w)->connective == ALL ) ? AND : OR; - for ( j = 0; j < gtype_size[(*w)->var_type]; j++ ) { - tmp = copy_Wff( (*w)->son ); - expand_quantifiers_in_wff( &tmp, (*w)->var, gtype_consts[(*w)->var_type][j] ); - tmp->next = r; - if ( r ) { - r->prev = tmp; - } - r = tmp; - } - - free_WffNode( (*w)->son ); - (*w)->sons = r; - (*w)->var = -1; - (*w)->var_type = -1; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = NULL; - - /* now make all sons expand their quantifiers - */ - for ( i = (*w)->sons; i; i = i->next ) { - expand_quantifiers_in_wff( &i, -1, -1 ); - } - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - expand_quantifiers_in_wff( &i, var, constant ); - } - break; - case NOT: - expand_quantifiers_in_wff( &((*w)->son), var, constant ); - break; - case ATOM: - if ( var == -1 ) { - break; - } - - change = FALSE; - for ( l = 0; l < garity[(*w)->fact->predicate]; l++ ) { - if ( (*w)->fact->args[l] == ENCODE_VAR( var ) ) { - (*w)->fact->args[l] = constant; - change = TRUE; - } - } - if ( !change && (*w)->visited ) { - /* we did not change anything and we've already seen that node - * --> it cant be simplified - */ - break; - } - if ( !possibly_negative( (*w)->fact ) ) { - (*w)->connective = TRU; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - if ( !possibly_positive( (*w)->fact ) ) { - (*w)->connective = FAL; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - (*w)->visited = TRUE; - break; - case COMP: - if ( var == -1 ) { - break; - } - - replace_var_with_const_in_exp( &((*w)->lh), var, constant ); - replace_var_with_const_in_exp( &((*w)->rh), var, constant ); - if ( (*w)->lh->connective != NUMBER || - (*w)->rh->connective != NUMBER ) { - /* logical simplification only possible if both parts are numbers - */ - break; - } - ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); - if ( ct ) { - (*w)->connective = TRU; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } else { - (*w)->connective = FAL; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: expansion, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ) - -{ - - int j, f, k; - - switch ( (*n)->connective ) { - case AD: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - replace_var_with_const_in_exp( &((*n)->son), var, constant ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - if ( !(*n)->fluent ) { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - break; - } - f = (*n)->fluent->function; - for ( j = 0; j < gf_arity[f]; j++ ) { - if ( (*n)->fluent->args[j] == ENCODE_VAR( var ) ) { - (*n)->fluent->args[j] = constant; - } - } - for ( j = 0; j < gf_arity[f]; j++ ) { - if ( (*n)->fluent->args[j] < 0 ) { - break; - } - } - if ( j < gf_arity[f] ) { - break; - } - /* we handle only the case where the fluent is fully instantiated, - * static, and in the initial state. - */ - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\nreplace var with const in expnode: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -WffNode *copy_Wff( WffNode *w ) - -{ - - WffNode *tmp, *tmp2, *i; - int j; - - tmp = new_WffNode( w->connective ); - - switch ( w->connective ) { - case ALL: - case EX: - tmp->var = w->var; - tmp->var_type = w->var_type; - tmp->son = copy_Wff( w->son ); - break; - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - tmp2 = copy_Wff( i ); - if ( tmp->sons ) { - tmp->sons->prev = tmp2; - } - tmp2->next = tmp->sons; - tmp->sons = tmp2; - } - break; - case NOT: - tmp->son = copy_Wff( w->son ); - break; - case ATOM: - tmp->fact = new_Fact(); - tmp->fact->predicate = w->fact->predicate; - for ( j = 0; j < garity[w->fact->predicate]; j++ ) { - tmp->fact->args[j] = w->fact->args[j]; - } - tmp->visited = w->visited; - break; - case COMP: - tmp->comp = w->comp; - tmp->lh = copy_Exp( w->lh ); - tmp->rh = copy_Exp( w->rh ); - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: copy, non logical %d\n\n", - w->connective); - exit( 1 ); - } - - return tmp; - -} - - - -ExpNode *copy_Exp( ExpNode *n ) - -{ - - ExpNode *tmp; - int i; - - tmp = new_ExpNode( n->connective ); - - switch ( n->connective ) { - case AD: - case SU: - case MU: - case DI: - tmp->leftson = copy_Exp( n->leftson ); - tmp->rightson = copy_Exp( n->rightson ); - break; - case MINUS: - tmp->son = copy_Exp( n->son ); - break; - case NUMBER: - tmp->value = n->value; - break; - case FHEAD: - if ( n->fluent ) { - tmp->fluent = new_Fluent(); - tmp->fluent->function = n->fluent->function; - for ( i = 0; i < gf_arity[tmp->fluent->function]; i++ ) { - tmp->fluent->args[i] = n->fluent->args[i]; - } - } else { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - tmp->fl = n->fl; - } - break; - default: - printf("\n\ncopy expnode: wrong specifier %d", - n->connective); - exit( 1 ); - } - - return tmp; - -} - - - -Bool possibly_positive( Fact *f ) - -{ - - int i; - - if ( gis_added[f->predicate] ) { - return TRUE; - } - - for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { - if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { - return TRUE; - } - } - - return FALSE; - -} - - - -Bool possibly_negative( Fact *f ) - -{ - - int i; - - if ( gis_deleted[f->predicate] ) { - return TRUE; - } - - for ( i = 0; i < garity[f->predicate]; i++ ) { - if ( f->args[i] < 0 ) { - return TRUE; - } - } - - for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { - if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { - return FALSE; - } - } - - return TRUE; - -} - - - -Bool matches( Fact *f1, Fact *f2 ) - -{ - - int i; - - for ( i = 0; i < garity[f1->predicate]; i++ ) { - if ( f1->args[i] >= 0 ) { - if ( f2->args[i] >= 0 && - f1->args[i] != f2->args[i] ) { - return FALSE; - } - } - } - - return TRUE; - -} - - - -void cleanup_wff( WffNode **w ) - -{ - - merge_ANDs_and_ORs_in_wff( w ); - detect_tautologies_in_wff( w ); - simplify_wff( w ); - detect_tautologies_in_wff( w ); - merge_ANDs_and_ORs_in_wff( w ); - -} - - - -void detect_tautologies_in_wff( WffNode **w ) - -{ - - WffNode *i, *j, *tmp; - - switch ( (*w)->connective ) { - case ALL: - case EX: - detect_tautologies_in_wff( &((*w)->son) ); - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - detect_tautologies_in_wff( &i ); - } - for ( i = (*w)->sons; i && i->next; i = i->next ) { - j = i->next; - while ( j ) { - if ( are_identical_ATOMs( i, j ) ) { - j->prev->next = j->next; - if ( j->next ) { - j->next->prev = j->prev; - } - tmp = j; - j = j->next; - if ( tmp->fact ) { - free( tmp->fact ); - } - free( tmp ); - continue; - } - if ( i->connective == NOT && - are_identical_ATOMs( i->son, j ) ) { - (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; - free_WffNode( (*w)->son ); - (*w)->son = NULL; - return; - } - if ( j->connective == NOT && - are_identical_ATOMs( i, j->son ) ) { - (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; - free_WffNode( (*w)->son ); - (*w)->son = NULL; - return; - } - j = j->next; - } - } - break; - case NOT: - detect_tautologies_in_wff( &((*w)->son) ); - break; - case ATOM: - case COMP: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: tautologies, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ) - -{ - - int i; - - if ( w1->connective != ATOM || - w2->connective != ATOM ) { - return FALSE; - } - - if ( w1->fact->predicate != w2->fact->predicate ) { - return FALSE; - } - - for ( i = 0; i < garity[w1->fact->predicate]; i++ ) { - if ( w1->fact->args[i] != w2->fact->args[i] ) { - return FALSE; - } - } - - return TRUE; - -} - - - -void merge_ANDs_and_ORs_in_wff( WffNode **w ) - -{ - - WffNode *i, *j, *tmp; - - switch ( (*w)->connective ) { - case ALL: - case EX: - merge_ANDs_and_ORs_in_wff( &((*w)->son) ); - break; - case AND: - case OR: - i = (*w)->sons; - while ( i ) { - merge_ANDs_and_ORs_in_wff( &i ); - if ( i->connective == (*w)->connective ) { - if ( !(i->sons) ) { - if ( i->next ) { - i->next->prev = i->prev; - } - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - for ( j = i->sons; j->next; j = j->next ); - j->next = i->next; - if ( i->next ) { - i->next->prev = j; - } - if ( i->prev ) { - i->prev->next = i->sons; - i->sons->prev = i->prev; - } else { - (*w)->sons = i->sons; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - } - break; - case NOT: - merge_ANDs_and_ORs_in_wff( &((*w)->son) ); - break; - case COMP: - case ATOM: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: merge, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void NOTs_down_in_wff( WffNode **w ) - -{ - - WffNode *tmp1, *tmp2, *i; - - switch ( (*w)->connective ) { - case ALL: - case EX: - printf("\ntrying to put nots down in quantified formula! debug me\n\n"); - exit( 1 ); - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - NOTs_down_in_wff( &i ); - } - break; - case NOT: - if ( (*w)->son->connective == NOT ) { - (*w)->connective = (*w)->son->son->connective; - (*w)->fact = (*w)->son->son->fact; - (*w)->comp = (*w)->son->son->comp; - (*w)->lh = (*w)->son->son->lh; - (*w)->rh = (*w)->son->son->rh; - tmp1 = (*w)->son; - tmp2 = (*w)->son->son; - (*w)->sons = (*w)->son->son->sons; - (*w)->son = (*w)->son->son->son; - /* don't need to remember (*w)->son->son->next: this is empty because - * otherwise the resp. father, (*w)->son, would have been an - * AND or OR - */ - free( tmp1 ); - free( tmp2 ); - NOTs_down_in_wff( w ); - break; - } - if ( (*w)->son->connective == AND || - (*w)->son->connective == OR ) { - (*w)->connective = ( (*w)->son->connective == AND ) ? OR : AND; - (*w)->sons = (*w)->son->sons; - free( (*w)->son ); - (*w)->son = NULL; - for ( i = (*w)->sons; i; i = i->next ) { - tmp1 = new_WffNode( i->connective ); - tmp1->son = i->son; - tmp1->sons = i->sons; - tmp1->fact = i->fact; - tmp1->comp = i->comp; - tmp1->lh = i->lh; - tmp1->rh = i->rh; - i->connective = NOT; - i->son = tmp1; - i->sons = NULL; - i->fact = NULL; - i->comp = -1; - i->lh = NULL; - i->rh = NULL; - NOTs_down_in_wff( &i ); - } - break; - } - if ( (*w)->son->connective == COMP ) { - if ( (*w)->son->comp != EQ ) { - (*w)->connective = COMP; - (*w)->lh = (*w)->son->lh; - (*w)->rh = (*w)->son->rh; - switch ( (*w)->son->comp ) { - case LE: - (*w)->comp = GEQ; - break; - case LEQ: - (*w)->comp = GE; - break; - case GEQ: - (*w)->comp = LE; - break; - case GE: - (*w)->comp = LEQ; - break; - default: - printf("\n\nillegal comparator not EQ %d in nots down", - (*w)->son->comp); - exit( 1 ); - } - free( (*w)->son ); - (*w)->son = NULL; - } else { - (*w)->connective = OR; - (*w)->sons = (*w)->son; - (*w)->son = NULL; - (*w)->sons->comp = LE; - tmp1 = new_WffNode( COMP ); - tmp1->lh = copy_Exp( (*w)->sons->lh ); - tmp1->rh = copy_Exp( (*w)->sons->rh ); - tmp1->comp = GE; - tmp1->prev = (*w)->sons; - (*w)->sons->next = tmp1; - } - } - break; - case COMP: - case ATOM: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: nots down, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - - -} - - - - - - - - - - - -/**************************************************** - * NEGATIVE PRE- AND EFFECT- CONDITIONS TRANSLATION * - ****************************************************/ - - - - - - - - -int lconsts[MAX_ARITY]; - - - - - - - - -void translate_negative_preconds( void ) - -{ - - int i, j; - Effect *e; - Facts *f; - FluentValues *ff; - - while ( translate_one_negative_cond( ggoal ) ); - - for ( i = 0; i < gnum_operators; i++ ) { - while ( translate_one_negative_cond( goperators[i]->preconds ) ); - - for ( e = goperators[i]->effects; e; e = e->next ) { - while ( translate_one_negative_cond( e->conditions ) ); - } - } - - if ( gcmd_line.display_info == 108 ) { - printf("\n\ndomain with translated negative conds:"); - - printf("\n\noperators are:"); - for ( i = 0; i < gnum_operators; i++ ) { - print_Operator( goperators[i] ); - } - printf("\n\n"); - - printf("\ninitial state is:\n"); - for ( f = ginitial; f; f = f->next ) { - printf("\n"); - print_Fact( f->fact ); - } - printf("\n"); - for ( ff = gf_initial; ff; ff = ff->next ) { - printf("\n"); - print_Fluent( &(ff->fluent) ); - printf(": %f", ff->value); - } - printf("\n\n"); - - printf("\n\nindividual predicates:\n"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n\n%s:", gpredicates[i]); - if ( !gis_added[i] && - !gis_deleted[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - printf("\n"); - print_Fact( &(ginitial_predicate[i][j]) ); - } - } - printf("\n\nindividual functions:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n\n%s:", gfunctions[i]); - if ( !gis_changed[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_function[i]; j++ ) { - printf("\n"); - print_Fluent( &(ginitial_function[i][j].fluent) ); - printf(": %f", ginitial_function[i][j].value); - } - } - printf("\n\n"); - - printf("\n\ngoal is:\n"); - print_Wff( ggoal, 0 ); - printf("\n\n"); - } - -} - - - -Bool translate_one_negative_cond( WffNode *w ) - -{ - - WffNode *i; - int p, j, k, m; - Effect *e; - Literal *l, *tmp; - - switch ( w->connective ) { - case ALL: - case EX: - printf("\ntranslating NOT in quantified formula! debug me\n\n"); - exit( 1 ); - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - if ( translate_one_negative_cond( i ) ) { - return TRUE; - } - } - return FALSE; - case NOT: - if ( w->son->fact->predicate == -1 ) { - return FALSE; - } - break; - case COMP: - case ATOM: - case TRU: - case FAL: - return FALSE; - default: - printf("\nwon't get here: translate one neg cond, non logical %d\n\n", - w->connective); - exit( 1 ); - } - - - if ( gnum_predicates == MAX_PREDICATES ) { - printf("\ntoo many predicates in translation! increase MAX_PREDICATES (currently %d)\n\n", - MAX_PREDICATES); - exit( 1 ); - } - p = w->son->fact->predicate; - /* safety check: we disallow negative conds on derived preds!! - */ - if ( gaxiom_added[p]) { - printf("\nA derived predicate appears negated in the negation normal form of a derivation rule condition, an operator precondition, or the goal."); - printf("\nSorry, this version of FF does not allow any of this. Bailing out.\n\n"); - exit( 1 ); - } else { - printf("\ntranslating negated cond for predicate %s", gpredicates[p]); - } - - gpredicates[gnum_predicates] = new_Token( strlen( gpredicates[p] ) + 5 ); - sprintf( gpredicates[gnum_predicates], "NOT-%s", gpredicates[p] ); - garity[gnum_predicates] = garity[p]; - for ( j = 0; j < garity[p]; j++ ) { - gpredicates_args_type[gnum_predicates][j] = - gpredicates_args_type[p][j]; - } - gis_added[gnum_predicates] = FALSE; - gis_deleted[gnum_predicates] = FALSE; - m = 1; - for ( j = 0; j < garity[gnum_predicates]; j++ ) { - m *= gtype_size[gpredicates_args_type[gnum_predicates][j]]; - } - ginitial_predicate[gnum_predicates] = ( Fact * ) calloc( m, sizeof( Fact ) ); - gnum_predicates++; - - - replace_not_p_with_n_in_wff( p, gnum_predicates - 1, &ggoal ); - - for ( j = 0; j < gnum_operators; j++ ) { - replace_not_p_with_n_in_wff( p, gnum_predicates - 1, - &(goperators[j]->preconds) ); - - for ( e = goperators[j]->effects; e; e = e->next ) { - replace_not_p_with_n_in_wff( p, gnum_predicates - 1, - &(e->conditions) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->fact.predicate != p ) { - continue; - } - tmp = new_Literal(); - if ( l->negated ) { - tmp->negated = FALSE; - gis_added[gnum_predicates - 1] = TRUE; - } else { - tmp->negated = TRUE; - gis_deleted[gnum_predicates - 1] = TRUE; - } - tmp->fact.predicate = gnum_predicates - 1; - for ( k = 0; k < garity[p]; k++ ) { - tmp->fact.args[k] = l->fact.args[k]; - } - if ( l->prev ) { - tmp->prev = l->prev; - tmp->prev->next = tmp; - } else { - e->effects = tmp; - } - tmp->next = l; - l->prev = tmp; - } - } - } - - add_to_initial_state( p, gnum_predicates - 1, 0 ); - - return TRUE; - -} - - - -void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ) - -{ - - WffNode *i; - - switch ( (*w)->connective ) { - case ALL: - case EX: - printf("\nreplacing p with NOT-p in quantified formula! debug me\n\n"); - exit( 1 ); - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - replace_not_p_with_n_in_wff( p, n, &i ); - } - break; - case NOT: - if ( (*w)->son->fact->predicate == p ) { - (*w)->connective = ATOM; - (*w)->NOT_p = p; - (*w)->fact = (*w)->son->fact; - (*w)->fact->predicate = n; - free( (*w)->son ); - (*w)->son = NULL; - } - break; - case ATOM: - case COMP: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: replace p with NOT-p, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void add_to_initial_state( int p, int n, int index ) - -{ - - int i, j; - Facts *tmp; - - if ( index == garity[p] ) { - /* see if contrary fact is there in ini - */ - for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { - for ( j = 0; j < garity[p]; j++ ) { - if ( ginitial_predicate[p][i].args[j] != lconsts[j] ) { - break; - } - } - if ( j == garity[p] ) { - break; - } - } - if ( i < gnum_initial_predicate[p] ) { - return; - } - - /* no: add new fact to ini - */ - ginitial_predicate[n][gnum_initial_predicate[n]].predicate = n; - for ( i = 0; i < garity[n]; i++ ) { - ginitial_predicate[n][gnum_initial_predicate[n]].args[i] = lconsts[i]; - } - gnum_initial_predicate[n]++; - - if ( !gis_added[n] && - !gis_deleted[n] ) { - return; - } - - tmp = new_Facts(); - tmp->fact->predicate = n; - for ( i = 0; i < garity[p]; i++ ) { - tmp->fact->args[i] = lconsts[i]; - } - tmp->next = ginitial; - ginitial = tmp; - gnum_initial++; - return; - } - - for ( i = 0; i < gtype_size[gpredicates_args_type[p][index]]; i++ ) { - lconsts[index] = gtype_consts[gpredicates_args_type[p][index]][i]; - add_to_initial_state( p, n, index + 1 ); - } - -} - - - - - - - - - - - -/******************************************************************* - * SPLIT DOMAIN IN PREPARATION FOR SEPARATE INSTANTIATION ROUTINES * - *******************************************************************/ - - - - - - - - - - -void split_domain( void ) - -{ - - int i, j, m, s = 0, mn; - Effect *e; - WffNode *w, *ww, *www; - NormOperator *tmp_op; - Fact *tmp_ft; - - for ( i = 0; i < MAX_TYPES; i++ ) { - gnum_intersected_types[i] = -1; - } - - for ( i = 0; i < gnum_operators; i++ ) { - if ( (m = is_dnf( goperators[i]->preconds )) != -1 ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - if ( is_dnf( e->conditions ) == -1 ) { - break; - } - } - if ( !e ) { - goperators[i]->hard = FALSE; - s += m; - } - } - } - - ghard_operators = ( Operator_pointer * ) calloc( MAX_OPERATORS, sizeof( Operator ) ); - gnum_hard_operators = 0; - geasy_operators = ( NormOperator_pointer * ) calloc( s, sizeof( NormOperator_pointer ) ); - gnum_easy_operators = 0; - - for ( i = 0; i < gnum_operators; i++ ) { - if ( goperators[i]->hard ) { - ghard_operators[gnum_hard_operators++] = goperators[i]; - continue; - } - w = goperators[i]->preconds; - switch ( w->connective ) { - case OR: - for ( ww = w->sons; ww; ww = ww->next ) { - tmp_op = new_NormOperator( goperators[i] ); - if ( ww->connective == AND ) { - m = 0; - mn = 0; - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) m++; - if ( www->connective == COMP ) mn++; - } - tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) { - tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); - tmp_ft->predicate = www->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = www->fact->args[j]; - } - tmp_op->num_preconds++; - } - if ( www->connective == COMP ) { - tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = www->comp; - tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( www->lh ); - tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( www->rh ); - tmp_op->num_numeric_preconds++; - } - } - } else { - if ( ww->connective == ATOM ) { - tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_op->preconds[0]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_op->num_preconds = 1; - } - if ( ww->connective == COMP ) { - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_comp[0] = ww->comp; - tmp_op->numeric_preconds_lh[0] = copy_Exp( ww->lh ); - tmp_op->numeric_preconds_rh[0] = copy_Exp( ww->rh ); - tmp_op->num_numeric_preconds = 1; - } - } - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - } - break; - case AND: - tmp_op = new_NormOperator( goperators[i] ); - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_op->num_preconds++; - } - if ( ww->connective == COMP ) { - tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = ww->comp; - tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( ww->lh ); - tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( ww->rh ); - tmp_op->num_numeric_preconds++; - } - } - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case ATOM: - tmp_op = new_NormOperator( goperators[i] ); - tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_op->preconds[0]); - tmp_ft->predicate = w->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = w->fact->args[j]; - } - tmp_op->num_preconds = 1; - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case COMP: - tmp_op = new_NormOperator( goperators[i] ); - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_comp[0] = w->comp; - tmp_op->numeric_preconds_lh[0] = copy_Exp( w->lh ); - tmp_op->numeric_preconds_rh[0] = copy_Exp( w->rh ); - tmp_op->num_numeric_preconds = 1; - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case TRU: - tmp_op = new_NormOperator( goperators[i] ); - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case FAL: - break; - default: - printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); - exit( 1 ); - } - } - - if ( gcmd_line.display_info == 109 ) { - printf("\n\nsplitted operators are:\n"); - - printf("\nEASY:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - - printf("\n\n\nHARD:\n"); - for ( i = 0; i < gnum_hard_operators; i++ ) { - print_Operator( ghard_operators[i] ); - } - } - -} - - - -int is_dnf( WffNode *w ) - -{ - - WffNode *i; - int s = 0; - - switch ( w->connective ) { - case ALL: - case EX: - printf("\nchecking quantifier for dnf. debug me\n\n"); - exit( 1 ); - case AND: - for ( i = w->sons; i; i = i->next ) { - if ( i->connective == ATOM || - i->connective == COMP ) { - continue; - } - return -1; - } - return 1; - case OR: - for ( i = w->sons; i; i = i->next ) { - s++; - if ( i->connective == ATOM || - i->connective == COMP || - ( i->connective == AND && - is_dnf( i ) != -1 ) ) { - continue; - } - return -1; - } - return s; - case NOT: - printf("\n\nNOT in presimplified formula. debug me\n\n"); - exit( 1 ); - case ATOM: - case COMP: - case TRU: - case FAL: - return 1; - default: - printf("\nwon't get here: check dnf, conn %d\n\n", - w->connective); - exit( 1 ); - } - -} - - - -void make_normal_effects( NormOperator **nop, Operator *op ) - -{ - - Effect *e; - NormEffect *tmp_ef; - WffNode *w, *ww, *www; - int j, m, ma, md, mn; - Literal *l; - NumericEffect *ll; - Fact *tmp_ft; - Fluent *tmp_fl; - - for ( e = op->effects; e; e = e->next ) { - w = e->conditions; - switch ( w->connective ) { - case OR: - for ( ww = w->sons; ww; ww = ww->next ) { - tmp_ef = new_NormEffect1( e ); - if ( ww->connective == AND ) { - m = 0; - mn = 0; - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) m++; - if ( www->connective == COMP ) mn++; - } - tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) { - tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); - tmp_ft->predicate = www->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = www->fact->args[j]; - } - tmp_ef->num_conditions++; - } - if ( www->connective == COMP ) { - tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = www->comp; - tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( www->lh ); - tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( www->rh ); - tmp_ef->num_numeric_conditions++; - } - } - } else { - if ( ww->connective == ATOM ) { - tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_ef->conditions[0]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_ef->num_conditions = 1; - } - if ( ww->connective == COMP ) { - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_comp[0] = ww->comp; - tmp_ef->numeric_conditions_lh[0] = copy_Exp( ww->lh ); - tmp_ef->numeric_conditions_rh[0] = copy_Exp( ww->rh ); - tmp_ef->num_numeric_conditions = 1; - } - } - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - } - break; - case AND: - tmp_ef = new_NormEffect1( e ); - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_ef->num_conditions++; - } - if ( ww->connective == COMP ) { - tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = ww->comp; - tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->lh ); - tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->rh ); - tmp_ef->num_numeric_conditions++; - } - } - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case ATOM: - tmp_ef = new_NormEffect1( e ); - tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_ef->conditions[0]); - tmp_ft->predicate = w->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = w->fact->args[j]; - } - tmp_ef->num_conditions = 1; - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case COMP: - tmp_ef = new_NormEffect1( e ); - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_comp[0] = w->comp; - tmp_ef->numeric_conditions_lh[0] = copy_Exp( w->lh ); - tmp_ef->numeric_conditions_rh[0] = copy_Exp( w->rh ); - tmp_ef->num_numeric_conditions = 1; - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case TRU: - tmp_ef = new_NormEffect1( e ); - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case FAL: - break; - default: - printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); - exit( 1 ); - } - } - -} - - - - - - - - - -/************************************************************************* - * ADDITIONAL: FULL DNF, only compute on fully instantiated formulae!!!! * - *************************************************************************/ - - - - - - - - - - -/* dnf - */ - -WffNode *lhitting_sets; -WffNode_pointer *lset; -int lmax_set; - - - - - - -void dnf( WffNode **w ) - -{ - - static Bool first_call = TRUE; - - if ( first_call ) { - lset = ( WffNode_pointer * ) - calloc( MAX_HITTING_SET_DEFAULT, sizeof( WffNode_pointer ) ); - lmax_set = MAX_HITTING_SET_DEFAULT; - first_call = FALSE; - } - - ANDs_below_ORs_in_wff( w ); - -} - - - -void ANDs_below_ORs_in_wff( WffNode **w ) - -{ - - WffNode *i, *tmp; - int c, m; - - switch ( (*w)->connective ) { - case ALL: - case EX: - printf("\ntrying to put quantified formula into DNF! (ands down) debug me\n\n"); - exit( 1 ); - break; - case AND: - c = 0; - m = 0; - for ( i = (*w)->sons; i; i = i->next ) { - ANDs_below_ORs_in_wff( &i ); - if ( i->connective == OR ) { - c++; - } - m++; - } - if ( c == 0 ) { - /* no ORs as sons --> all sons are literals. OK - */ - merge_next_step_ANDs_and_ORs_in_wff( w ); - break; - } - /* crucial part: AND node, sons can be merged OR's. - * (i.e., sons are either literals or disjunctions of - * conjunctions of literals) - * create OR node with one hitting set of w's sons for - * each disjunct - */ - lhitting_sets = NULL; - if ( m > lmax_set ) { - free( lset ); - lset = ( WffNode_pointer * ) calloc( m, sizeof( WffNode_pointer ) ); - lmax_set = m; - } - collect_hitting_sets( (*w)->sons, 0 ); - (*w)->connective = OR; - tmp = (*w)->sons; - (*w)->sons = lhitting_sets; - if ( 0 ) free_WffNode( tmp ); - merge_next_step_ANDs_and_ORs_in_wff( w ); - break; - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - ANDs_below_ORs_in_wff( &i ); - } - merge_next_step_ANDs_and_ORs_in_wff( w ); - break; - case NOT: - case ATOM: - case COMP: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: ands down, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void collect_hitting_sets( WffNode *ORlist, int index ) - -{ - - WffNode *tmp1, *tmp2, *j; - int i; - - if ( !ORlist ) { - tmp1 = new_WffNode( AND ); - for ( i = 0; i < index; i++ ) { - tmp2 = copy_Wff( lset[i] ); - tmp2->next = tmp1->sons; - if ( tmp1->sons ) { - tmp1->sons->prev = tmp2; - } - tmp1->sons = tmp2; - } - tmp1->next = lhitting_sets; - if ( lhitting_sets ) { - lhitting_sets->prev = tmp1; - } - lhitting_sets = tmp1; - return; - } - - if ( ORlist->connective != OR ) { - lset[index] = ORlist; - collect_hitting_sets( ORlist->next, index + 1 ); - return; - } - - for ( j = ORlist->sons; j; j = j->next ) { - lset[index] = j; - collect_hitting_sets( ORlist->next, index + 1 ); - } - -} - - - -void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ) - -{ - - WffNode *i, *j, *tmp; - - i = (*w)->sons; - while ( i ) { - if ( i->connective == (*w)->connective ) { - if ( !(i->sons) ) { - if ( i->next ) { - i->next->prev = i->prev; - } - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - for ( j = i->sons; j->next; j = j->next ); - j->next = i->next; - if ( i->next ) { - i->next->prev = j; - } - if ( i->prev ) { - i->prev->next = i->sons; - i->sons->prev = i->prev; - } else { - (*w)->sons = i->sons; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - } - -} - - - -/* switch ( (*w)->connective ) { */ -/* case ALL: */ -/* case EX: */ -/* break; */ -/* case AND: */ -/* case OR: */ -/* for ( i = (*w)->sons; i; i = i->next ) { */ -/* } */ -/* break; */ -/* case NOT: */ -/* break; */ -/* case ATOM: */ -/* case TRU: */ -/* case FAL: */ -/* break; */ -/* default: */ -/* printf("\nwon't get here: remove var, non logical %d\n\n", */ -/* (*w)->connective); */ -/* exit( 1 ); */ -/* } */ - - - - - - - - - diff --git a/models/main_models/rt1/gen/ff_planner/inst_pre.h b/models/main_models/rt1/gen/ff_planner/inst_pre.h deleted file mode 100644 index de859b385..000000000 --- a/models/main_models/rt1/gen/ff_planner/inst_pre.h +++ /dev/null @@ -1,123 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: inst_pre.h - * Description: headers for instantiating operators, preprocessing part. - * - transform domain into integers - * - inertia preprocessing: - * - collect inertia info - * - split initial state in special arrays - * - Wff normalization: - * - simplification - * - quantifier expansion - * - NOT s down - * - negative preconditions translation - * - split operators into easy and hard to instantiate ones - * - * - full DNF functions, only feasible for fully instantiated - * formulae - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - - - -#ifndef _INST_PRE_H -#define _INST_PRE_H - - - -void encode_domain_in_integers( void ); -void collect_all_strings( void ); -void create_member_nrs( void ); -int position_in_types_table( char *str ); -int position_in_constants_table( char *str ); -int position_in_predicates_table( char *str ); -int position_in_functions_table( char *str ); -void create_integer_representation( void ); -void make_Fact( Fact *f, PlNode *n, int num_vars ); -void make_Fluent( Fluent *f, TokenList *atom, int num_vars ); -Bool is_subtype( int t1, int t2 ); -WffNode *make_Wff( PlNode *p, int num_vars ); -ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ); -Effect *make_effect( PlNode *p, int num_vars ); - - - -void do_inertia_preprocessing_step_1( void ); -void collect_inertia_information( void ); -void split_initial_state( void ); - - - -void normalize_all_wffs( void ); -void remove_unused_vars_in_wff( WffNode **w ); -void decrement_inferior_vars( int var, WffNode *w ); -void decrement_inferior_vars_in_exp( int var, ExpNode *n ); -Bool var_used_in_wff( int code_var, WffNode *w ); -Bool var_used_in_exp( int code_var, ExpNode *n ); -void simplify_wff( WffNode **w ); -void simplify_exp( ExpNode **n ); -void expand_quantifiers_in_wff( WffNode **w, int var, int constant ); -void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ); -WffNode *copy_Wff( WffNode *w ); -ExpNode *copy_Exp( ExpNode *n ); -Bool possibly_positive( Fact *f ); -Bool possibly_negative( Fact *f ); -Bool matches( Fact *f1, Fact *f2 ); -void cleanup_wff( WffNode **w ); -void detect_tautologies_in_wff( WffNode **w ); -Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ); -void merge_ANDs_and_ORs_in_wff( WffNode **w ); -void NOTs_down_in_wff( WffNode **w ); - - - -void translate_negative_preconds( void ); -Bool translate_one_negative_cond( WffNode *w ); -void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ); -void add_to_initial_state( int p, int n, int index ); - - - -void split_domain( void ); -int is_dnf( WffNode *w ); -void make_normal_effects( NormOperator **nop, Operator *op ); - - - -void dnf( WffNode **w ); -void ANDs_below_ORs_in_wff( WffNode **w ); -void collect_hitting_sets( WffNode *ORlist, int index ); -void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ); - - - -#endif /* _INST_PRE_H */ diff --git a/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l b/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l deleted file mode 100644 index 850bbb407..000000000 --- a/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l +++ /dev/null @@ -1,139 +0,0 @@ -%{ -#include "ff.h" -#include "parse.h" - - /* default yywrap function - always treat EOF as an EOF */ -int fct_pddlwrap() { return 1; }; - -int gbracket_count = 0; - -%} - -a [Aa] -b [Bb] -c [Cc] -d [Dd] -e [Ee] -f [Ff] -g [Gg] -h [Hh] -i [Ii] -j [Jj] -k [Kk] -l [Ll] -m [Mm] -n [Nn] -o [Oo] -p [Pp] -q [Qq] -r [Rr] -s [Ss] -t [Tt] -u [Uu] -v [Vv] -w [Ww] -x [Xx] -y [Yy] -z [Zz] - -%x COMMENT OVERREAD - -%% - -"(" { return(OPEN_PAREN); } - -")" { return(CLOSE_PAREN); } - -\([ \t]*{i}{n}"-"{p}{a}{c}{k}{a}{g}{e} { gbracket_count = 1; - BEGIN OVERREAD; } - -\([ \t]*":"{l}{e}{n}{g}{t}{h} { gbracket_count = 1; - BEGIN OVERREAD; } - -\([ \t]*":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { gbracket_count = 1; - BEGIN OVERREAD; } - -{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } - -{p}{r}{o}{b}{l}{e}{m} { return(PROBLEM_TOK); } - -{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(SITUATION_TOK); } - -":"{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(BSITUATION_TOK); } - -":"{o}{b}{j}{e}{c}{t}{s} { return(OBJECTS_TOK); } - -":"{g}{o}{a}{l} { return(GOAL_TOK); } - -":"{m}{e}{t}{r}{i}{c} { return(METRIC_TOK); } - -":"{i}{n}{i}{t} { return(INIT_TOK); } - -":"{d}{o}{m}{a}{i}{n} { return(BDOMAIN_TOK); } - -\([ \t]*":"{e}{x}{t}{e}{n}{d}{s} { gbracket_count = 1; - BEGIN OVERREAD; } - -{a}{n}{d} { return(AND_TOK); } - -{i}{m}{p}{l}{y} { return(IMPLY_TOK); } - -{o}{r} { return(OR_TOK); } - -{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } - -{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } - -{n}{o}{t} { return(NOT_TOK); } - -"<" { return(LE_TOK); } - -"<=" { return(LEQ_TOK); } - -"=" { return(EQ_TOK); } - -">=" { return(GEQ_TOK); } - -">" { return(GE_TOK); } - -"-" { return(MINUS_TOK); } - -"+" { return(AD_TOK); } - -"*" { return(MU_TOK); } - -"/" { return(DI_TOK); } - -:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase( yytext ); - strcpy(yylval.string, yytext ); return(NAME); } - -\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* {strupcase( yytext ); - strcpy(yylval.string, yytext); return(VARIABLE); } - -"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} - -"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } - -\;(.)*\n { lineno++; } -\;(.)* { /* this will hold only in files that end with - a comment but no linefeed */ } - -(.^\")*\n { lineno++; } ; - -\" { BEGIN COMMENT;} - -\" { BEGIN INITIAL;} - -\n { lineno++; } - -(.^\(\))*\n { lineno++; } - -[^\(\)] { } - -\( { gbracket_count++; } - -\) { gbracket_count--; - if (!gbracket_count) BEGIN INITIAL; } - -. {} -%% diff --git a/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l b/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l deleted file mode 100644 index 0e9d8499d..000000000 --- a/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l +++ /dev/null @@ -1,151 +0,0 @@ -%{ -#include "ff.h" -#include "parse.h" - -/* default yywrap function - always treat EOF as an EOF */ -int ops_pddlwrap() { return 1; }; - -%} - -a [Aa] -b [Bb] -c [Cc] -d [Dd] -e [Ee] -f [Ff] -g [Gg] -h [Hh] -i [Ii] -j [Jj] -k [Kk] -l [Ll] -m [Mm] -n [Nn] -o [Oo] -p [Pp] -q [Qq] -r [Rr] -s [Ss] -t [Tt] -u [Uu] -v [Vv] -w [Ww] -x [Xx] -y [Yy] -z [Zz] - -%x COMMENT OVERREAD - -%% - -"(" { return(OPEN_PAREN); } - -")" { return(CLOSE_PAREN); } - -{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } - -{d}{o}{m}{a}{i}{n} { return(DOMAIN_TOK); } - -":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { return(REQUIREMENTS_TOK); } - -":"{t}{y}{p}{e}{s} { return(TYPES_TOK); } - -{n}{u}{m}{b}{e}{r} { return(NUMBER_TOK); } - -":"{c}{o}{n}{s}{t}{a}{n}{t}{s} { return(CONSTANTS_TOK); } - -":"{p}{r}{e}{d}{i}{c}{a}{t}{e}{s} { return(PREDICATES_TOK); } - -":"{f}{u}{n}{c}{t}{i}{o}{n}{s} { return(FUNCTIONS_TOK); } - -":"{a}{c}{t}{i}{o}{n} { return(ACTION_TOK); } - -":"{d}{e}{r}{i}{v}{e}{d} { return(AXIOM_TOK); } - -":"{p}{a}{r}{a}{m}{e}{t}{e}{r}{s} { return(PARAMETERS_TOK); } - -":"{v}{a}{r}{s} { return(VARS_TOK); } - -":"{p}{r}{e}{c}{o}{n}{d}{i}{t}{i}{o}{n} { return(PRECONDITION_TOK); } - -":"{e}{f}{f}{e}{c}{t} { return(EFFECT_TOK); } - -":"{i}{m}{p}{l}{i}{e}{s} { return(IMPLIES_TOK); } - -{a}{n}{d} { return(AND_TOK); } - -{n}{o}{t} { return(NOT_TOK); } - -{w}{h}{e}{n} { return(WHEN_TOK); } - -{i}{m}{p}{l}{y} { return(IMPLY_TOK); } - -{o}{r} { return(OR_TOK); } - -{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } - -{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } - -"<" { return(LE_TOK); } - -"<=" { return(LEQ_TOK); } - -"=" { return(EQ_TOK); } - -">=" { return(GEQ_TOK); } - -">" { return(GE_TOK); } - -"-" { return(MINUS_TOK); } - -"+" { return(AD_TOK); } - -"*" { return(MU_TOK); } - -"/" { return(DI_TOK); } - -{a}{s}{s}{i}{g}{n} { return(ASSIGN_TOK); } - -{s}{c}{a}{l}{e}"-"{u}{p} { return(SCALE_UP_TOK); } - -{s}{c}{a}{l}{e}"-"{d}{o}{w}{n} { return(SCALE_DOWN_TOK); } - -{i}{n}{c}{r}{e}{a}{s}{e} { return(INCREASE_TOK); } - -{d}{e}{c}{r}{e}{a}{s}{e} { return(DECREASE_TOK); } - - -:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase(yytext); strcpy(yylval.string, yytext); - return(NAME); } - -\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* { strupcase(yytext); strcpy(yylval.string, yytext); - return(VARIABLE); } - -"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} - - -"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } - -\;(.)*\n { lineno++; } -\;(.)* { /* this will hold only in files that end with - a comment but no linefeed */ } - -(.^\")*\n { lineno++; } ; - -\" { BEGIN COMMENT;} - -\" { BEGIN INITIAL;} - -\n { lineno++; } - -(.^\(\))*\n { lineno++; } - -[^\(\)] { } - -\( { BEGIN OVERREAD; gbracket_count++; } - -\) { BEGIN OVERREAD; gbracket_count--; - if (!gbracket_count) BEGIN INITIAL; } - -. {} -%% diff --git a/models/main_models/rt1/gen/ff_planner/main.c b/models/main_models/rt1/gen/ff_planner/main.c deleted file mode 100644 index bc3a795b5..000000000 --- a/models/main_models/rt1/gen/ff_planner/main.c +++ /dev/null @@ -1,1230 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - -/********************************************************************* - * File: main.c - * Description: The main routine for the Metric-FastForward Planner. - * Modified July 2011 to allow more command-line search - * confiogurations, including improved cost-minimization - * - * Author: original version Joerg Hoffmann 2001/2002 - * modified version Joerg Hoffmann 2012 - * - *********************************************************************/ - - - - - - - - -#include "ff.h" - -#include "memory.h" -#include "output.h" - -#include "parse.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_easy.h" -#include "inst_hard.h" -#include "inst_final.h" - -#include "relax.h" -#include "search.h" - - - - - - - - - - - -/* - * ----------------------------- GLOBAL VARIABLES ---------------------------- - */ - - - - - - - - - - - - -/******************* - * GENERAL HELPERS * - *******************/ - - - - - - - - -/* used to time the different stages of the planner - */ -float gtempl_time = 0, greach_time = 0, grelev_time = 0, gconn_time = 0; -float gLNF_time = 0, gsearch_time = 0; - - -/* the command line inputs - */ -struct _command_line gcmd_line; - -/* number of states that got heuristically evaluated - */ -int gevaluated_states = 0; - -/* maximal depth of breadth first search - */ -int gmax_search_depth = 0; - - - - - -/*********** - * PARSING * - ***********/ - - - - - - - -/* used for pddl parsing, flex only allows global variables - */ -int gbracket_count; -char *gproblem_name; - -/* The current input line number - */ -int lineno = 1; - -/* The current input filename - */ -char *gact_filename; - -/* The pddl domain name - */ -char *gdomain_name = NULL; - -/* loaded, uninstantiated operators - */ -PlOperator *gloaded_ops = NULL; - -/* stores initials as fact_list - */ -PlNode *gorig_initial_facts = NULL; - -/* not yet preprocessed goal facts - */ -PlNode *gorig_goal_facts = NULL; - -/* axioms as in UCPOP before being changed to ops - */ -PlOperator *gloaded_axioms = NULL; - -/* the types, as defined in the domain file - */ -TypedList *gparse_types = NULL; - -/* the constants, as defined in domain file - */ -TypedList *gparse_constants = NULL; - -/* the predicates and their arg types, as defined in the domain file - */ -TypedListList *gparse_predicates = NULL; - -/* the functions and their arg types, as defined in the domain file - */ -TypedListList *gparse_functions = NULL; - -/* the objects, declared in the problem file - */ -TypedList *gparse_objects = NULL; - -/* the metric - */ -Token gparse_optimization; -ParseExpNode *gparse_metric = NULL; - - -/* connection to instantiation ( except ops, goal, initial ) - */ - -/* all typed objects - */ -FactList *gorig_constant_list = NULL; - -/* the predicates and their types - */ -FactList *gpredicates_and_types = NULL; - -/* the functions and their types - */ -FactList *gfunctions_and_types = NULL; - - - - - - - - - - - - -/***************** - * INSTANTIATING * - *****************/ - - - - - - - - - -/* global arrays of constant names, - * type names (with their constants), - * predicate names, - * predicate aritys, - * defined types of predicate args - */ -Token gconstants[MAX_CONSTANTS]; -int gnum_constants = 0; -Token gtype_names[MAX_TYPES]; -int gtype_consts[MAX_TYPES][MAX_TYPE]; -Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; -int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ -int gtype_size[MAX_TYPES]; -int gnum_types = 0; -Token gpredicates[MAX_PREDICATES]; -int garity[MAX_PREDICATES]; -Bool gaxiom_added[MAX_PREDICATES]; -int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; -int gnum_predicates = 0; -Token gfunctions[MAX_FUNCTIONS]; -int gf_arity[MAX_FUNCTIONS]; -int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; -int gnum_functions = 0; - - - - - -/* the domain in integer (Fact) representation - */ -Operator_pointer goperators[MAX_OPERATORS]; -int gnum_operators = 0; -Fact *gfull_initial; -int gnum_full_initial = 0; -FluentValue *gfull_fluents_initial; -int gnum_full_fluents_initial = 0; -WffNode *ggoal = NULL; - -ExpNode *gmetric = NULL; - - - -/* stores inertia - information: is any occurence of the predicate - * added / deleted in the uninstantiated ops ? - */ -Bool gis_added[MAX_PREDICATES]; -Bool gis_deleted[MAX_PREDICATES]; - - -/* for functions we *might* want to say, symmetrically, whether it is - * increased resp. decreased at all. - * - * that is, however, somewhat involved because the right hand - * sides can be arbirtray expressions, so we have no guarantee - * that increasing really does adds to a functions value... - * - * thus (for the time being), we settle for "is the function changed at all?" - */ -Bool gis_changed[MAX_FUNCTIONS]; - - - -/* splitted initial state: - * initial non static facts, - * initial static facts, divided into predicates - * (will be two dimensional array, allocated directly before need) - */ -Facts *ginitial = NULL; -int gnum_initial = 0; -Fact **ginitial_predicate; -int *gnum_initial_predicate; - -/* same thing for functions - */ -FluentValues *gf_initial; -int gnum_f_initial = 0; -FluentValue **ginitial_function; -int *gnum_initial_function; - - - -/* the type numbers corresponding to any unary inertia - */ -int gtype_to_predicate[MAX_PREDICATES]; -int gpredicate_to_type[MAX_TYPES]; - -/* (ordered) numbers of types that new type is intersection of - */ -TypeArray gintersected_types[MAX_TYPES]; -int gnum_intersected_types[MAX_TYPES]; - - - -/* splitted domain: hard n easy ops - */ -Operator_pointer *ghard_operators; -int gnum_hard_operators; -NormOperator_pointer *geasy_operators; -int gnum_easy_operators; - - - -/* so called Templates for easy ops: possible inertia constrained - * instantiation constants - */ -EasyTemplate *geasy_templates; -int gnum_easy_templates; - - - -/* first step for hard ops: create mixed operators, with conjunctive - * precondition and arbitrary effects - */ -MixedOperator *ghard_mixed_operators; -int gnum_hard_mixed_operators; - - - -/* hard ''templates'' : pseudo actions - */ -PseudoAction_pointer *ghard_templates; -int gnum_hard_templates; - - - -/* store the final "relevant facts" - */ -Fact grelevant_facts[MAX_RELEVANT_FACTS]; -int gnum_relevant_facts = 0; -int gnum_pp_facts = 0; -/* store the "relevant fluents" - */ -Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; -int gnum_relevant_fluents = 0; -Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; -/* this is NULL for normal, and the LNF for - * artificial fluents. - */ -LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; - - - -/* the final actions and problem representation - */ -Action *gactions = NULL; -int gnum_actions; -State ginitial_state; -int *glogic_goal = NULL; -int gnum_logic_goal = 0; -Comparator *gnumeric_goal_comp = NULL; -ExpNode_pointer *gnumeric_goal_lh = NULL, *gnumeric_goal_rh = NULL; -int gnum_numeric_goal = 0; - -/* direct numeric goal access - */ -Comparator *gnumeric_goal_direct_comp; -float *gnumeric_goal_direct_c; - - - -/* to avoid memory leaks; too complicated to identify - * the exact state of the action to throw away (during construction), - * memory gain not worth the implementation effort. - */ -Action *gtrash_actions = NULL; - - - -/* additional lnf step between finalized inst and - * conn graph - */ -Comparator *glnf_goal_comp = NULL; -LnfExpNode_pointer *glnf_goal_lh = NULL; -float *glnf_goal_rh = NULL; -int gnum_lnf_goal = 0; - -LnfExpNode glnf_metric; -Bool goptimization_established = FALSE; - - - - - - - -/********************** - * CONNECTIVITY GRAPH * - **********************/ - - - - - - - -/* one ops (actions) array ... - */ -OpConn *gop_conn; -int gnum_op_conn; - - - -/* one effects array ... - */ -EfConn *gef_conn; -int gnum_ef_conn; - - - -/* one facts array. - */ -FtConn *gft_conn; -int gnum_ft_conn; - - - -/* and: one fluents array. - */ -FlConn *gfl_conn; -int gnum_fl_conn; -int gnum_real_fl_conn;/* number of non-artificial ones */ - - - -/* final goal is also transformed one more step. - */ -int *gflogic_goal = NULL; -int gnum_flogic_goal = 0; -Comparator *gfnumeric_goal_comp = NULL; -int *gfnumeric_goal_fl = NULL; -float *gfnumeric_goal_c = NULL; -int gnum_fnumeric_goal = 0; - -/* direct access (by relevant fluents) - */ -Comparator *gfnumeric_goal_direct_comp = NULL; -float *gfnumeric_goal_direct_c = NULL; - - - - - - - - - - - -/******************* - * SEARCHING NEEDS * - *******************/ - - - - - - - - - - - -/* applicable actions - */ -int *gA;/* non-axioms */ -int gnum_A; -int *gA_axioms; /* axioms */ -int gnum_A_axioms; - - - -/* communication from extract 1.P. to search engine: - * 1P action choice - */ -int *gH; -int gnum_H; -/* added cost of relaxed plan - */ -float gh_cost; -/* hmax value - */ -float ghmax; - - - -/* to store plan - */ -int gplan_ops[MAX_PLAN_LENGTH]; -int gnum_plan_ops = 0; - - - -/* stores the states that the current plan goes through - * ( for knowing where new agenda entry starts from ) - */ -State gplan_states[MAX_PLAN_LENGTH + 1]; - - - - - - - -/* dirty: multiplic. of total-time in final metric LNF - */ -float gtt; - - - - - - - -/* the mneed structures - */ -Bool **gassign_influence; -Bool **gTassign_influence; - - - -/* the real var input to the mneed computation. - */ -Bool *gmneed_start_D; -float *gmneed_start_V; - - - -/* does this contain conditional effects? - * (if it does then the state hashing has to be made more - * cautiously) - */ -Bool gconditional_effects; - - - -/* easier to question: are we optimizing or no? - */ -Bool gcost_minimizing; - - - -/* stores current A* weight: this is initially given by user, - * but changes during anytime search. - */ -float gw; -/* this is the minimum weight, ie we'll stop once the weight update - * does/would yield a value <= this. - * if no such minim weight is given, this will be -1 - */ -float gmin_w = -1; - - - -/* this one says whether or not we are actually using - * cost-minimizing rplans. - * this will be the case by default if we're running cost- - * minimizing searches. it can be switched off by a flag; - * it is automatically switched off in case there are - * numeric preconditions/goals: for this case, - * cost-minimizing rplans are not implemented (a numeric prec - * may cause an action to come in "later" on in the RPG although - * its logical pres are easy. in that case, any new effects will - * have a smaller RPGcost value than facts we already have waiting. - * in other words, the "Dijsktra" nature breaks. - * - * ... I suppose there may be a generic solution to this that - * can handle numeric precs/goals. Doesn't seem important enough - * to bother. - */ -Bool gcost_rplans; - - - - - - - - - - - - - -/* - * ----------------------------- HEADERS FOR PARSING ---------------------------- - * ( fns defined in the scan-* files ) - */ - - - - - - - -void get_fct_file_name( char *filename ); -void load_ops_file( char *filename ); -void load_fct_file( char *filename ); - - - - - - - - - - - -/* - * ----------------------------- MAIN ROUTINE ---------------------------- - */ - - - - - -struct tms lstart, lend; - - - - - -int main( int argc, char *argv[] ) - -{ - - /* resulting name for ops file - */ - char ops_file[MAX_LENGTH] = ""; - /* same for fct file - */ - char fct_file[MAX_LENGTH] = ""; - - struct tms start, end; - - Bool found_plan; - int i; - float cost; - - Bool prev_gcost_rplans; - - - - times ( &lstart ); - - /* command line treatment - */ - gcmd_line.display_info = 1; - gcmd_line.debug = 0; - - /* search settings - */ - gcmd_line.search_config = 5; - gcmd_line.cost_rplans = TRUE; - gcmd_line.w = 5; - gcmd_line.cost_bound = -1; - - memset(gcmd_line.ops_file_name, 0, MAX_LENGTH); - memset(gcmd_line.fct_file_name, 0, MAX_LENGTH); - memset(gcmd_line.path, 0, MAX_LENGTH); - - if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { - ff_usage(); - exit( 1 ); - } - if ( !process_command_line( argc, argv ) ) { - ff_usage(); - exit( 1 ); - } - - - /* make file names - */ - - /* one input name missing - */ - if ( !gcmd_line.ops_file_name || - !gcmd_line.fct_file_name ) { - fprintf(stdout, "\nff: two input files needed\n\n"); - ff_usage(); - exit( 1 ); - } - /* add path info, complete file names will be stored in - * ops_file and fct_file - */ - sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); - sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); - - - /* parse the input files - */ - - /* start parse & instantiation timing - */ - times( &start ); - /* domain file (ops) - */ - if ( gcmd_line.display_info >= 1 ) { - printf("\nff: parsing domain file"); - } - /* it is important for the pddl language to define the domain before - * reading the problem - */ - load_ops_file( ops_file ); - /* problem file (facts) - */ - if ( gcmd_line.display_info >= 1 ) { - printf(" ... done.\nff: parsing problem file"); - } - load_fct_file( fct_file ); - if ( gcmd_line.display_info >= 1 ) { - printf(" ... done.\n\n"); - } - - /* This is needed to get all types. - */ - build_orig_constant_list(); - - /* last step of parsing: see if it's an ADL domain! - */ - if ( !make_adl_domain() ) { - printf("\nff: this is not an ADL problem!"); - printf("\n can't be handled by this version.\n\n"); - exit( 1 ); - } - - - /* now instantiate operators; - */ - - - /************************** - * first do PREPROCESSING * - **************************/ - - /* start by collecting all strings and thereby encoding - * the domain in integers. - */ - encode_domain_in_integers(); - - /* inertia preprocessing, first step: - * - collect inertia information - * - split initial state into - * - arrays for individual predicates - * - arrays for all static relations - * - array containing non - static relations - */ - do_inertia_preprocessing_step_1(); - - /* normalize all PL1 formulae in domain description: - * (goal, preconds and effect conditions) - * - simplify formula - * - expand quantifiers - * - NOTs down - */ - normalize_all_wffs(); - - /* translate negative preconds: introduce symmetric new predicate - * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) - */ - translate_negative_preconds(); - - /* split domain in easy (disjunction of conjunctive preconds) - * and hard (non DNF preconds) part, to apply - * different instantiation algorithms - */ - split_domain(); - - /*********************************************** - * PREPROCESSING FINISHED * - * * - * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * - ***********************************************/ - - build_easy_action_templates(); - build_hard_action_templates(); - - times( &end ); - TIME( gtempl_time ); - - times( &start ); - - /* perform reachability analysis in terms of relaxed - * fixpoint - */ - perform_reachability_analysis(); - - times( &end ); - TIME( greach_time ); - - times( &start ); - - /* collect the relevant facts and build final domain - * and problem representations. - */ - collect_relevant_facts_and_fluents(); - - times( &end ); - TIME( grelev_time ); - - - /* now transform problem to additive normal form, - * if possible - */ - times( &start ); - if ( !transform_to_LNF() ) { - printf("\n\nThis is not a linear task!\n\n"); - exit( 1 ); - } - times( &end ); - TIME( gLNF_time ); - - times( &start ); - - /* now build globally accessable connectivity graph - */ - build_connectivity_graph(); - - /* now check for acyclic := effects (in expressions.c) - */ - check_assigncycles(); - /* set the relevanc info (in expressions.c) - */ - determine_fl_relevance(); - - times( &end ); - TIME( gconn_time ); - - /*********************************************************** - * we are finally through with preprocessing and can worry * - * bout finding a plan instead. * - ***********************************************************/ - - if ( gcmd_line.display_info ) { - printf("\n\nff: search configuration is "); - switch ( gcmd_line.search_config ) { - case 0: - printf("Enforced Hill-Climbing, if that fails then best-first search.\nMetric is plan length."); - printf("\nNO COST MINIMIZATION"); - if ( !gcost_rplans ) { - printf(" (and no cost-minimizing relaxed plans)."); - } else { - printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); - exit( 1 ); - } - break; - case 1: - printf("best-first search.\nMetric is plan length."); - printf("\nNO COST MINIMIZATION"); - if ( !gcost_rplans ) { - printf(" (and no cost-minimizing relaxed plans)."); - } else { - printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); - exit( 1 ); - } - break; - case 2: - printf("best-first search with helpful actions pruning.\nMetric is plan length."); - printf("\nNO COST MINIMIZATION."); - if ( !gcost_rplans ) { - printf(" (and no cost-minimizing relaxed plans)."); - } else { - printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); - exit( 1 ); - } - break; - case 3: - printf("weighted A* with weight %d.", gcmd_line.w); - if ( goptimization_established ) { - printf("\nMetric is "); - print_LnfExpNode( &glnf_metric ); - } else { - printf(" plan length"); - } - printf("\nCOST MINIMIZATION DONE"); - if ( !gcost_rplans ) { - printf(" (WITHOUT cost-minimizing relaxed plans)."); - } else { - printf(" (WITH cost-minimizing relaxed plans)."); - } - break; - case 4: - printf("A*epsilon with weight %d.", gcmd_line.w); - if ( goptimization_established ) { - printf("\nMetric is "); - print_LnfExpNode( &glnf_metric ); - } else { - printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); - exit( 1 ); - } - printf("\nCOST MINIMIZATION DONE"); - if ( !gcost_rplans ) { - printf(" (WITHOUT cost-minimizing relaxed plans)."); - } else { - printf(" (WITH cost-minimizing relaxed plans)."); - } - break; - case 5: - printf("Enforced Hill-Climbing, then A*epsilon with weight %d.", gcmd_line.w); - if ( goptimization_established ) { - printf("\nMetric is "); - print_LnfExpNode( &glnf_metric ); - } else { - printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); - exit( 1 ); - } - printf("\nCOST MINIMIZATION DONE"); - if ( !gcost_rplans ) { - printf(" (WITHOUT cost-minimizing relaxed plans)."); - } else { - printf(" (WITH cost-minimizing relaxed plans)."); - } - break; - default: - printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); - exit( 1 ); - } - } else { - if ( gcmd_line.search_config == 4 && !goptimization_established ) { - exit( 1 ); - } - } - - - times( &start ); - - - - /* need to evaluate derived predicates in initial state! - */ - do_axiom_update( &ginitial_state ); - - - if ( !gcost_rplans ) { - gcmd_line.cost_bound = -1; - } - - switch ( gcmd_line.search_config ) { - case 0: - found_plan = do_enforced_hill_climbing(); - if ( found_plan ) { - if ( gcmd_line.display_info ) { - print_plan(); - } - } else { - if ( gcmd_line.display_info ) { - printf("\n\nEnforced Hill-climbing failed !"); - printf("\nswitching to Best-first Search now.\n"); - } - do_best_first_search(); - } - break; - case 1: - case 2: - do_best_first_search(); - break; - case 3: - do_weighted_Astar(); - break; - case 4: - do_Astar_epsilon(); - break; - case 5: - /* gcost_rplans controls whether or not we compute cost-minimal relaxed plans - * gcost_minimizing is only used in h fn to decide whether or not we - * need to count the weights of the operators in the relaxed plan. - * - * gcost_rplans may be false even for search options 3,4,5, namely if there are - * numeric preconditions/goals which make this relaxed plan variant invalid. - * hence we need to remember, when switching it off for EHC, whether or not - * it was previously on. - */ - prev_gcost_rplans = gcost_rplans; - gcost_rplans = FALSE; - gcost_minimizing = FALSE; - found_plan = do_enforced_hill_climbing(); - if ( found_plan ) { - print_plan(); - } else { - if ( gcmd_line.display_info ) { - printf("\n\nEnforced Hill-climbing not successful."); - printf("\nSwitching to A*epsilon now."); - } - gcost_rplans = prev_gcost_rplans; - gcost_minimizing = TRUE; - do_Astar_epsilon(); - } - break; - default: - printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); - exit( 1 ); - } - - times( &end ); - TIME( gsearch_time ); - - - - output_planner_info(); - - printf("\n\n"); - exit( 0 ); - -} - - - - - - - - - - - -/* - * ----------------------------- HELPING FUNCTIONS ---------------------------- - */ - - - - - - - - - - - - -void output_planner_info( void ) - -{ - - printf( "\n\ntime spent: %7.2f seconds instantiating %d easy, %d hard action templates", - gtempl_time, gnum_easy_templates, gnum_hard_mixed_operators ); - printf( "\n %7.2f seconds reachability analysis, yielding %d facts and %d actions", - greach_time, gnum_pp_facts, gnum_actions ); - printf( "\n %7.2f seconds creating final representation with %d relevant facts, %d relevant fluents", - grelev_time, gnum_relevant_facts, gnum_relevant_fluents ); - printf( "\n %7.2f seconds computing LNF", - gLNF_time ); - printf( "\n %7.2f seconds building connectivity graph", - gconn_time ); - printf( "\n %7.2f seconds searching, evaluating %d states, to a max depth of %d", - gsearch_time, gevaluated_states, gmax_search_depth ); - printf( "\n %7.2f seconds total time", - gtempl_time + greach_time + grelev_time + gLNF_time + gconn_time + gsearch_time ); - - printf("\n\n"); - - exit( 0 ); - -} - - - -void ff_usage( void ) - -{ - - printf("\nusage of ff:\n"); - - printf("\nOPTIONS DESCRIPTIONS\n\n"); - printf("-p Path for operator and fact file\n"); - printf("-o Operator file name\n"); - printf("-f Fact file name\n\n"); - - printf("-r Random seed [used for random restarts; preset: 0]\n\n"); - - printf("-s Search configuration [preset: s=5]; '+H': helpful actions pruning\n"); - printf(" 0 Standard-FF: EHC+H then BFS (cost minimization: NO)\n"); - printf(" 1 BFS (cost minimization: NO)\n"); - printf(" 2 BFS+H (cost minimization: NO)\n"); - printf(" 3 Weighted A* (cost minimization: YES)\n"); - printf(" 4 A*epsilon (cost minimization: YES)\n"); - printf(" 5 EHC+H then A*epsilon (cost minimization: YES)\n"); - printf("-w Set weight w for search configs 3,4,5 [preset: w=5]\n\n"); - - printf("-C Do NOT use cost-minimizing relaxed plans for options 3,4,5\n\n"); - - printf("-b Fixed upper bound on solution cost (prune based on g+hmax); active only with cost minimization\n\n"); - - if ( 0 ) { - printf("-i run-time information level( preset: 1 )\n"); - printf(" 0 only times\n"); - printf(" 1 problem name, planning process infos\n"); - printf(" 101 parsed problem data\n"); - printf(" 102 cleaned up ADL problem\n"); - printf(" 103 collected string tables\n"); - printf(" 104 encoded domain\n"); - printf(" 105 predicates inertia info\n"); - printf(" 106 splitted initial state\n"); - printf(" 107 domain with Wff s normalized\n"); - printf(" 108 domain with NOT conds translated\n"); - printf(" 109 splitted domain\n"); - printf(" 110 cleaned up easy domain\n"); - printf(" 111 unaries encoded easy domain\n"); - printf(" 112 effects multiplied easy domain\n"); - printf(" 113 inertia removed easy domain\n"); - printf(" 114 easy action templates\n"); - printf(" 115 cleaned up hard domain representation\n"); - printf(" 116 mixed hard domain representation\n"); - printf(" 117 final hard domain representation\n"); - printf(" 118 reachability analysis results\n"); - printf(" 119 facts selected as relevant\n"); - printf(" 120 final domain and problem representations\n"); - printf(" 121 normalized expressions representation\n"); - printf(" 122 LNF: translated subtractions representation\n"); - printf(" 123 summarized effects LNF representation\n"); - printf(" 124 encoded LNF representation\n"); - printf(" 125 connectivity graph\n"); - printf(" 126 fixpoint result on each evaluated state\n"); - printf(" 127 1P extracted on each evaluated state\n"); - printf(" 128 H set collected for each evaluated state\n"); - - printf("\n-d switch on debugging\n\n"); - } - -} - - - -Bool process_command_line( int argc, char *argv[] ) - -{ - - char option; - - while ( --argc && ++argv ) { - if ( *argv[0] != '-' || strlen(*argv) != 2 ) { - return FALSE; - } - option = *++argv[0]; - switch ( option ) { -/* case 'E': */ -/* gcmd_line.ehc = FALSE; */ -/* break; */ -/* case 'O': */ -/* gcmd_line.optimize = TRUE; */ -/* gcmd_line.ehc = FALSE; */ -/* break; */ - case 'C': - gcmd_line.cost_rplans = FALSE; - break; - default: - if ( --argc && ++argv ) { - switch ( option ) { - case 'p': - strncpy( gcmd_line.path, *argv, MAX_LENGTH ); - break; - case 'o': - strncpy( gcmd_line.ops_file_name, *argv, MAX_LENGTH ); - break; - case 'f': - strncpy( gcmd_line.fct_file_name, *argv, MAX_LENGTH ); - break; - case 'i': - sscanf( *argv, "%d", &gcmd_line.display_info ); - break; - case 'd': - sscanf( *argv, "%d", &gcmd_line.debug ); - break; - case 's': - sscanf( *argv, "%d", &gcmd_line.search_config ); - break; - case 'w': - sscanf( *argv, "%d", &gcmd_line.w ); - break; - case 'b': - sscanf( *argv, "%f", &gcmd_line.cost_bound ); - break; - default: - printf( "\nff: unknown option: %c entered\n\n", option ); - return FALSE; - } - } else { - return FALSE; - } - } - } - - if ( 0 > gcmd_line.search_config || gcmd_line.search_config > 5 ) { - printf("\n\nff: unknown search configuration %d.\n\n", - gcmd_line.search_config); - return FALSE; - } - - if ( gcmd_line.search_config <= 2 ) { - gcost_minimizing = FALSE; - gcost_rplans = FALSE; - } else { - gcost_minimizing = TRUE; - gcost_rplans = TRUE; - } - - gw = gcmd_line.w; - - if ( !gcmd_line.cost_rplans ) { - gcost_rplans = FALSE; - } - - if ( gcmd_line.cost_bound != -1 && gcmd_line.cost_bound < 0 ) { - printf("\n\nff: invalid cost bound %f; must be >= 0.\n\n", - gcmd_line.cost_bound); - return FALSE; - } - - return TRUE; - -} - diff --git a/models/main_models/rt1/gen/ff_planner/makefile b/models/main_models/rt1/gen/ff_planner/makefile deleted file mode 100644 index b8ace7b81..000000000 --- a/models/main_models/rt1/gen/ff_planner/makefile +++ /dev/null @@ -1,89 +0,0 @@ -#!/bin/sh -# - - -####### FLAGS - -TYPE = -ADDONS = - -CC = gcc - -CFLAGS = -O6 -ansi $(TYPE) $(ADDONS) -g -# -g -pg - -LIBS = -lm - - -####### Files - -PDDL_PARSER_SRC = scan-fct_pddl.tab.c \ - scan-ops_pddl.tab.c \ - scan-probname.tab.c \ - lex.fct_pddl.c \ - lex.ops_pddl.c - -PDDL_PARSER_OBJ = scan-fct_pddl.tab.o \ - scan-ops_pddl.tab.o - - -SOURCES = main.c \ - memory.c \ - output.c \ - parse.c \ - expressions.c \ - inst_pre.c \ - inst_easy.c \ - inst_hard.c \ - inst_final.c \ - relax.c \ - search.c - -OBJECTS = $(SOURCES:.c=.o) - -####### Implicit rules - -.SUFFIXES: - -.SUFFIXES: .c .o - -.c.o:; $(CC) -c $(CFLAGS) $< - -####### Build rules - - -ff: $(OBJECTS) $(PDDL_PARSER_OBJ) - $(CC) -o ff $(OBJECTS) $(PDDL_PARSER_OBJ) $(CFLAGS) $(LIBS) - -# pddl syntax -scan-fct_pddl.tab.c: scan-fct_pddl.y lex.fct_pddl.c - bison -pfct_pddl -bscan-fct_pddl scan-fct_pddl.y - -scan-ops_pddl.tab.c: scan-ops_pddl.y lex.ops_pddl.c - bison -pops_pddl -bscan-ops_pddl scan-ops_pddl.y - -lex.fct_pddl.c: lex-fct_pddl.l - flex -Pfct_pddl lex-fct_pddl.l - -lex.ops_pddl.c: lex-ops_pddl.l - flex -Pops_pddl lex-ops_pddl.l - - -# misc -clean: - rm -f *.o *.bak *~ *% core *_pure_p9_c0_400.o.warnings \ - \#*\# $(RES_PARSER_SRC) $(PDDL_PARSER_SRC) - -veryclean: clean - rm -f ff H* J* K* L* O* graph.* *.symbex gmon.out \ - $(PDDL_PARSER_SRC) \ - lex.fct_pddl.c lex.ops_pddl.c lex.probname.c \ - *.output - -depend: - makedepend -- $(SOURCES) $(PDDL_PARSER_SRC) - -lint: - lclint -booltype Bool $(SOURCES) 2> output.lint - -# DO NOT DELETE diff --git a/models/main_models/rt1/gen/ff_planner/memory.c b/models/main_models/rt1/gen/ff_planner/memory.c deleted file mode 100644 index 601cea497..000000000 --- a/models/main_models/rt1/gen/ff_planner/memory.c +++ /dev/null @@ -1,1278 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: memory.c - * Description: Creation and Deletion functions for all data structures. - * - * Author: Joerg Hoffmann - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" -#include "memory.h" - - -#include "inst_pre.h" - - - - - - -/********************** - * CREATION FUNCTIONS * - **********************/ - - - - - - - - - - - -/* parsing - */ - - - - - - - - - -char *new_Token( int len ) - -{ - - char *tok = ( char * ) calloc( len, sizeof( char ) ); - CHECK_PTR(tok); - - return tok; - -} - - - -TokenList *new_TokenList( void ) - -{ - - TokenList *result = ( TokenList * ) calloc( 1, sizeof( TokenList ) ); - CHECK_PTR(result); - - result->item = NULL; - result->next = NULL; - - return result; - -} - - - -FactList *new_FactList( void ) - -{ - - FactList *result = ( FactList * ) calloc( 1, sizeof( FactList ) ); - CHECK_PTR(result); - - result->item = NULL; - result->next = NULL; - - return result; - -} - - - -TypedList *new_TypedList( void ) - -{ - - TypedList *result = ( TypedList * ) calloc( 1, sizeof( TypedList ) ); - CHECK_PTR(result); - - result->name = NULL; - result->type = NULL; - result->n = -1; - - return result; - -} - - - -TypedListList *new_TypedListList( void ) - -{ - - TypedListList *result = ( TypedListList * ) calloc( 1, sizeof( TypedListList ) ); - CHECK_PTR(result); - - result->predicate = NULL; - result->args = NULL; - - return result; - -} - - - -ParseExpNode *new_ParseExpNode( ExpConnective c ) - -{ - - ParseExpNode *result = ( ParseExpNode * ) calloc( 1, sizeof( ParseExpNode ) ); - CHECK_PTR(result); - - result->connective = c; - result->atom = NULL; - result->leftson = NULL; - result->rightson = NULL; - - return result; - -} - - - -PlNode *new_PlNode( Connective c ) - -{ - - PlNode *result = ( PlNode * ) calloc( 1, sizeof( PlNode ) ); - CHECK_PTR(result); - - result->connective = c; - result->atom = NULL; - - result->comp = -1; - result->neft = -1; - result->lh = NULL; - result->rh = NULL; - - result->sons = NULL; - result->next = NULL; - - return result; - -} - - - -PlOperator *new_PlOperator( char *name ) - -{ - - PlOperator *result = ( PlOperator * ) calloc( 1, sizeof( PlOperator ) ); - CHECK_PTR(result); - - if ( name ) { - result->name = new_Token(strlen(name)+1); - CHECK_PTR(result->name); - strcpy(result->name, name); - } else { - result->name = NULL; - } - - result->params = NULL; - result->preconds = NULL; - result->effects = NULL; - result->number_of_real_params = 0; - result->next = NULL; - - return result; - -} - - - -PlOperator *new_axiom_op_list( void ) - -{ - - static int count; - char *name; - PlOperator *ret; - - /* WARNING: count should not exceed 999 - */ - count++; - if ( count == 10000 ) { - printf("\ntoo many axioms! look into memory.c, line 157\n\n"); - exit( 1 ); - } - name = new_Token(strlen(HIDDEN_STR)+strlen(AXIOM_STR)+4+1); - sprintf(name, "%s%s%4d", HIDDEN_STR, AXIOM_STR, count); - - ret = new_PlOperator(name); - free(name); - - return ret; - -} - - - - - - - - - - - - - - -/* instantiation - */ - - - - - - - - - - - -Fact *new_Fact( void ) - -{ - - Fact *result = ( Fact * ) calloc( 1, sizeof( Fact ) ); - CHECK_PTR(result); - - return result; - -} - - - -Fluent *new_Fluent( void ) - -{ - - Fluent *result = ( Fluent * ) calloc( 1, sizeof( Fluent ) ); - CHECK_PTR(result); - - return result; - -} - - - -FluentValue *new_FluentValue( void ) - -{ - - FluentValue *result = ( FluentValue * ) calloc( 1, sizeof( FluentValue ) ); - CHECK_PTR(result); - - return result; - -} - - - -Facts *new_Facts( void ) - -{ - - Facts *result = ( Facts * ) calloc( 1, sizeof( Facts ) ); - CHECK_PTR(result); - - result->fact = new_Fact(); - - result->next = NULL; - - return result; - -} - - - -FluentValues *new_FluentValues( void ) - -{ - - FluentValues *result = ( FluentValues * ) calloc( 1, sizeof( FluentValues ) ); - CHECK_PTR(result); - - result->next = NULL; - - return result; - -} - - - -ExpNode *new_ExpNode( ExpConnective c ) - -{ - - ExpNode *result = ( ExpNode * ) calloc( 1, sizeof( ExpNode ) ); - CHECK_PTR(result); - - result->connective = c; - result->fluent = NULL; - result->fl = -2; - result->c = 1; - result->son = NULL; - result->leftson = NULL; - result->rightson = NULL; - - return result; - -} - - - -WffNode *new_WffNode( Connective c ) - -{ - - WffNode *result = ( WffNode * ) calloc( 1, sizeof( WffNode ) ); - CHECK_PTR(result); - - result->connective = c; - - result->var = -1; - result->var_type = -1; - result->var_name = NULL; - - result->sons = NULL; - result->next = NULL; - result->prev = NULL; - - result->fact = NULL; - result->NOT_p = -1; - - result->son = NULL; - - result->comp = -1; - result->lh = NULL; - result->rh = NULL; - - result->visited = FALSE; - - return result; - -} - - - -Literal *new_Literal( void ) - -{ - - Literal *result = ( Literal * ) calloc( 1, sizeof( Literal ) ); - CHECK_PTR(result); - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -NumericEffect *new_NumericEffect( void ) - -{ - - NumericEffect *result = ( NumericEffect * ) calloc( 1, sizeof( NumericEffect ) ); - CHECK_PTR(result); - - result->rh = NULL; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -Effect *new_Effect( void ) - -{ - - Effect *result = ( Effect * ) calloc( 1, sizeof( Effect ) ); - CHECK_PTR(result); - - result->num_vars = 0; - - result->conditions = NULL; - - result->effects = NULL; - result->numeric_effects = NULL; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -Operator *new_Operator( char *name, int norp ) - -{ - - int i; - - Operator *result = ( Operator * ) calloc( 1, sizeof( Operator ) ); - CHECK_PTR(result); - - if ( name ) { - result->name = new_Token( strlen( name ) + 1 ); - CHECK_PTR( result->name ); - strcpy( result->name, name ); - } else { - result->name = NULL; - } - - result->num_vars = 0; - result->number_of_real_params = norp; - - for ( i = 0; i < MAX_VARS; i++ ) { - result->removed[i] = FALSE; - } - - result->preconds = NULL; - - result->effects = NULL; - - result->hard = TRUE; - - return result; - -} - - - -NormEffect *new_NormEffect1( Effect *e ) - -{ - - int i; - - NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); - CHECK_PTR(result); - - result->num_vars = e->num_vars; - for ( i = 0; i < e->num_vars; i++ ) { - result->var_types[i] = e->var_types[i]; - result->inst_table[i] = -1; - } - - result->conditions = NULL; - result->num_conditions = 0; - - result->adds = NULL; - result->num_adds = 0; - result->dels = NULL; - result->num_dels = 0; - - result->numeric_conditions_comp = NULL; - result->numeric_conditions_lh = NULL; - result->numeric_conditions_rh = NULL; - result->num_numeric_conditions = 0; - - result->numeric_effects_neft = NULL; - result->numeric_effects_fluent = NULL; - result->numeric_effects_rh = NULL; - result->num_numeric_effects = 0; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -NormEffect *new_NormEffect2( NormEffect *e ) - -{ - - int i, j; - - NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); - CHECK_PTR(result); - - result->num_vars = 0; - - result->conditions = ( Fact * ) calloc( e->num_conditions, sizeof( Fact ) ); - result->num_conditions = e->num_conditions; - for ( i = 0; i < e->num_conditions; i++ ) { - result->conditions[i].predicate = e->conditions[i].predicate; - for ( j = 0; j < garity[e->conditions[i].predicate]; j++ ) { - result->conditions[i].args[j] = e->conditions[i].args[j]; - } - } - result->adds = ( Fact * ) calloc( e->num_adds, sizeof( Fact ) ); - result->num_adds = e->num_adds; - for ( i = 0; i < e->num_adds; i++ ) { - result->adds[i].predicate = e->adds[i].predicate; - for ( j = 0; j < garity[e->adds[i].predicate]; j++ ) { - result->adds[i].args[j] = e->adds[i].args[j]; - } - } - result->dels = ( Fact * ) calloc( e->num_dels, sizeof( Fact ) ); - result->num_dels = e->num_dels; - for ( i = 0; i < e->num_dels; i++ ) { - result->dels[i].predicate = e->dels[i].predicate; - for ( j = 0; j < garity[e->dels[i].predicate]; j++ ) { - result->dels[i].args[j] = e->dels[i].args[j]; - } - } - - result->numeric_conditions_comp = ( Comparator * ) - calloc( e->num_numeric_conditions, sizeof( Comparator ) ); - result->numeric_conditions_lh = ( ExpNode_pointer * ) - calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - result->numeric_conditions_rh = ( ExpNode_pointer * ) - calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - result->numeric_conditions_comp[i] = e->numeric_conditions_comp[i]; - result->numeric_conditions_lh[i] = copy_Exp( e->numeric_conditions_lh[i] ); - result->numeric_conditions_rh[i] = copy_Exp( e->numeric_conditions_rh[i] ); - } - result->num_numeric_conditions = e->num_numeric_conditions; - result->numeric_effects_neft = ( NumericEffectType * ) - calloc( e->num_numeric_effects, sizeof( NumericEffectType ) ); - result->numeric_effects_fluent = ( Fluent * ) - calloc( e->num_numeric_effects, sizeof( Fluent ) ); - result->numeric_effects_rh = ( ExpNode_pointer * ) - calloc( e->num_numeric_effects, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < e->num_numeric_effects; i++ ) { - result->numeric_effects_neft[i] = e->numeric_effects_neft[i]; - result->numeric_effects_fluent[i].function = e->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[e->numeric_effects_fluent[i].function]; j++ ) { - result->numeric_effects_fluent[i].args[j] = e->numeric_effects_fluent[i].args[j]; - } - result->numeric_effects_rh[i] = copy_Exp( e->numeric_effects_rh[i] ); - } - result->num_numeric_effects = e->num_numeric_effects; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -NormOperator *new_NormOperator( Operator *op ) - -{ - - int i; - - NormOperator *result = ( NormOperator * ) calloc( 1, sizeof( NormOperator ) ); - CHECK_PTR(result); - - result->operator = op; - - result->num_vars = op->num_vars; - for ( i = 0; i < op->num_vars; i++ ) { - result->var_types[i] = op->var_types[i]; - result->inst_table[i] = -1; - } - result->num_removed_vars = 0; - - result->preconds = NULL; - result->num_preconds = 0; - - result->numeric_preconds_comp = NULL; - result->numeric_preconds_lh = NULL; - result->numeric_preconds_rh = NULL; - result->num_numeric_preconds = 0; - - result->effects = NULL; - - return result; - -} - - - - -EasyTemplate *new_EasyTemplate( NormOperator *op ) - -{ - - EasyTemplate *result = ( EasyTemplate * ) calloc( 1, sizeof( EasyTemplate ) ); - CHECK_PTR(result); - - result->op = op; - - result->prev = NULL; - result->next = NULL; - - return result; - -} - - - -MixedOperator *new_MixedOperator( Operator *op ) - -{ - - MixedOperator *result = ( MixedOperator * ) calloc( 1, sizeof( MixedOperator ) ); - CHECK_PTR(result); - - result->operator = op; - - result->preconds = NULL; - result->num_preconds = 0; - - result->effects = NULL; - - return result; - -} - - - -PseudoActionEffect *new_PseudoActionEffect( void ) - -{ - - PseudoActionEffect *result = - ( PseudoActionEffect * ) calloc( 1, sizeof( PseudoActionEffect ) ); - CHECK_PTR(result); - - result->conditions = NULL; - result->num_conditions = 0; - - result->adds = NULL; - result->num_adds = 0; - result->dels = NULL; - result->num_dels = 0; - - result->numeric_conditions_comp = NULL; - result->numeric_conditions_lh = NULL; - result->numeric_conditions_rh = NULL; - result->num_numeric_conditions = 0; - - result->numeric_effects_neft = NULL; - result->numeric_effects_fluent = NULL; - result->numeric_effects_rh = NULL; - result->num_numeric_effects = 0; - - result->next = NULL; - - return result; - -} - - - -PseudoAction *new_PseudoAction( MixedOperator *op ) - -{ - - int i; - - PseudoAction *result = ( PseudoAction * ) calloc( 1, sizeof( PseudoAction ) ); - CHECK_PTR(result); - - result->operator = op->operator; - for ( i = 0; i < op->operator->num_vars; i++ ) { - result->inst_table[i] = op->inst_table[i]; - } - - result->preconds = op->preconds; - result->num_preconds = op->num_preconds; - - result->numeric_preconds_comp = op->numeric_preconds_comp; - result->numeric_preconds_lh = op->numeric_preconds_lh; - result->numeric_preconds_rh = op->numeric_preconds_rh; - result->num_numeric_preconds = op->num_numeric_preconds; - - result->effects = NULL; - result->num_effects = 0; - - return result; - -} - - - -LnfExpNode *new_LnfExpNode( void ) - -{ - - LnfExpNode *result = ( LnfExpNode * ) calloc( 1, sizeof( LnfExpNode ) ); - CHECK_PTR(result); - - result->num_pF = 0; - result->num_nF = 0; - - result->c = 0; - - return result; - -} - - - -Action *new_Action( void ) - -{ - - Action *result = ( Action * ) calloc( 1, sizeof( Action ) ); - CHECK_PTR(result); - - result->norm_operator = NULL; - result->pseudo_action = NULL; - - result->next = NULL; - - return result; - -} - - - -void make_state( State *pointer, int ft, int fl ) - -{ - - int i; - - pointer->F = ( int * ) calloc( ft, sizeof( int ) ); - pointer->f_D = ( Bool * ) calloc( fl, sizeof( Bool ) ); - pointer->f_V = ( float * ) calloc( fl, sizeof( float ) ); - - for ( i = 0; i < fl; i++ ) { - pointer->f_D[i] = FALSE; - } - -} - - - -EhcNode *new_EhcNode( void ) - -{ - - EhcNode *result = ( EhcNode * ) calloc( 1, sizeof( EhcNode ) ); - CHECK_PTR(result); - - make_state( &(result->S), gnum_ft_conn, gnum_fl_conn ); - - result->father = NULL; - result->next = NULL; - - return result; - -} - - - -EhcHashEntry *new_EhcHashEntry( void ) - -{ - - EhcHashEntry *result = ( EhcHashEntry * ) calloc( 1, sizeof( EhcHashEntry ) ); - CHECK_PTR(result); - - result->ehc_node = NULL; - - result->next = NULL; - - return result; - -} - - - -PlanHashEntry *new_PlanHashEntry( void ) - -{ - - PlanHashEntry *result = ( PlanHashEntry * ) calloc( 1, sizeof( PlanHashEntry ) ); - CHECK_PTR(result); - - result->next_step = NULL; - - result->next = NULL; - - return result; - -} - - - -BfsNode *new_BfsNode( void ) - -{ - - BfsNode *result = ( BfsNode * ) calloc( 1, sizeof( BfsNode ) ); - CHECK_PTR(result); - - result->father = NULL; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -BfsHashEntry *new_BfsHashEntry( void ) - -{ - - BfsHashEntry *result = ( BfsHashEntry * ) calloc( 1, sizeof( BfsHashEntry ) ); - CHECK_PTR(result); - - result->bfs_node = NULL; - - result->next = NULL; - - return result; - -} - - - - - - - - - - - -/********************** - * DELETION FUNCTIONS * - **********************/ - - - - - - - - - - - - -void free_TokenList( TokenList *source ) - -{ - - if ( source ) { - free_TokenList( source->next ); - if ( source->item ) { - free( source->item ); - } - free( source ); - } - -} - - - -void free_FactList( FactList *source ) - -{ - - if ( source ) { - free_FactList( source->next ); - free_TokenList( source->item ); - free( source ); - } - -} - - - -void free_ParseExpNode( ParseExpNode *n ) - -{ - - if ( n ) { - free_TokenList( n->atom ); - free_ParseExpNode( n->leftson ); - free_ParseExpNode( n->rightson ); - free( n ); - } - -} - - - -void free_PlNode( PlNode *node ) - -{ - - if ( node ) { - free_ParseExpNode( node->lh ); - free_ParseExpNode( node->rh ); - free_PlNode( node->sons ); - free_PlNode( node->next ); - free_TokenList( node->atom ); - free( node ); - } - -} - - - -void free_PlOperator( PlOperator *o ) - -{ - - if ( o ) { - free_PlOperator( o->next ); - - if ( o->name ) { - free( o->name ); - } - - free_FactList( o->params ); - free_PlNode( o->preconds ); - free_PlNode( o->effects ); - - free( o ); - } - -} - - - -void free_Operator( Operator *o ) - -{ - - if ( o ) { - /* need not free more: the only point where that happens - * is only directly after first allocation - */ - - if ( o->name ) { - free( o->name ); - } - - free( o ); - } - -} - - - -void free_ExpNode( ExpNode *n ) - -{ - - if ( n ) { - if ( n->fluent ) free( n->fluent ); - free_ExpNode( n->son ); - free_ExpNode( n->leftson ); - free_ExpNode( n->rightson ); - free( n ); - } - -} - - - -void free_WffNode( WffNode *w ) - -{ - - if ( w ) { - free_WffNode( w->son ); - free_WffNode( w->sons ); - free_WffNode( w->next ); - if ( w->var_name ) { - free( w->var_name ); - } - if ( w->fact ) free( w->fact ); - free_ExpNode( w->lh ); - free_ExpNode( w->rh ); - free( w ); - } - -} - - - -void free_NormEffect( NormEffect *e ) - -{ - - int i; - - if ( e ) { - free_NormEffect( e->next ); - - if ( e->conditions ) { - free( e->conditions ); - } - if ( e->adds ) { - free( e->adds ); - } - if ( e->dels ) { - free( e->dels ); - } - - if ( e->numeric_conditions_comp ) { - free( e->numeric_conditions_comp ); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - free_ExpNode( e->numeric_conditions_lh[i] ); - free_ExpNode( e->numeric_conditions_rh[i] ); - } - if ( e->numeric_conditions_lh ) { - free( e->numeric_conditions_lh ); - } - if ( e->numeric_conditions_rh ) { - free( e->numeric_conditions_rh ); - } - - if ( e->numeric_effects_neft ) { - free( e->numeric_effects_neft ); - } - if ( e->numeric_effects_fluent ) { - free( e->numeric_effects_fluent ); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - free_ExpNode( e->numeric_effects_rh[i] ); - } - if ( e->numeric_effects_rh ) { - free( e->numeric_effects_rh ); - } - - free( e ); - } - -} - - - -void free_partial_Effect( Effect *e ) - -{ - - if ( e ) { - free_partial_Effect( e->next ); - - free_WffNode( e->conditions ); - - free( e ); - } - -} - - - -void free_NormOperator( NormOperator *o ) - -{ - - int i; - - if ( o ) { - - if ( o->preconds ) { - free( o->preconds ); - } - if ( o->numeric_preconds_comp ) { - free( o->numeric_preconds_comp ); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - free_ExpNode( o->numeric_preconds_lh[i] ); - free_ExpNode( o->numeric_preconds_rh[i] ); - } - if ( o->numeric_preconds_lh ) { - free( o->numeric_preconds_lh ); - } - if ( o->numeric_preconds_rh ) { - free( o->numeric_preconds_rh ); - } - free_NormEffect( o->effects ); - - free( o ); - } - -} - - - -void free_single_NormEffect( NormEffect *e ) - -{ - - int i; - - if ( e ) { - if ( e->conditions ) { - free( e->conditions ); - } - if ( e->adds ) { - free( e->adds ); - } - if ( e->dels ) { - free( e->dels ); - } - - if ( e->numeric_conditions_comp ) { - free( e->numeric_conditions_comp ); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - free_ExpNode( e->numeric_conditions_lh[i] ); - free_ExpNode( e->numeric_conditions_rh[i] ); - } - if ( e->numeric_conditions_lh ) { - free( e->numeric_conditions_lh ); - } - if ( e->numeric_conditions_rh ) { - free( e->numeric_conditions_rh ); - } - - if ( e->numeric_effects_neft ) { - free( e->numeric_effects_neft ); - } - if ( e->numeric_effects_fluent ) { - free( e->numeric_effects_fluent ); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - free_ExpNode( e->numeric_effects_rh[i] ); - } - if ( e->numeric_effects_rh ) { - free( e->numeric_effects_rh ); - } - - free( e ); - } - -} - - - -void free_single_EasyTemplate( EasyTemplate *t ) - -{ - - if ( t ) { - free( t ); - } - -} - - - -void free_TypedList( TypedList *t ) - -{ - - if ( t ) { - if ( t->name ) { - free( t->name ); - t->name = NULL; - } - if ( t->type ) { - free_TokenList( t->type ); - t->type = NULL; - } - free_TypedList( t->next ); - - free( t ); - } - -} - - - -void free_TypedListList( TypedListList *t ) - -{ - - if ( t ) { - if ( t->predicate ) { - free( t->predicate ); - t->predicate = NULL; - } - if ( t->args ) { - free_TypedList( t->args ); - t->args = NULL; - } - free_TypedListList( t->next ); - - free( t ); - } - -} - - - -void free_BfsNode( BfsNode *n ) - -{ - - if ( n ) { - free_BfsNode( n->next ); - free( n ); - } - -} - - - -void free_BfsHashEntry( BfsHashEntry *n ) - -{ - - if ( n ) { - free_BfsHashEntry( n->next ); - free( n ); - } - -} diff --git a/models/main_models/rt1/gen/ff_planner/memory.h b/models/main_models/rt1/gen/ff_planner/memory.h deleted file mode 100644 index 13e8ddfb3..000000000 --- a/models/main_models/rt1/gen/ff_planner/memory.h +++ /dev/null @@ -1,109 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - -/********************************************************************* - * File: memory.h - * Description: Creation / Deletion functions for all data structures. - * - * Author: Joerg Hoffmann / Frank Rittinger - * - *********************************************************************/ - - - - - - -#ifndef _MEMORY_H -#define _MEMORY_H - - - - - -char *new_Token( int len ); -TokenList *new_TokenList( void ); -FactList *new_FactList( void ); -TypedList *new_TypedList( void ); -TypedListList *new_TypedListList( void ); -ParseExpNode *new_ParseExpNode( ExpConnective c ); -PlNode *new_PlNode( Connective c ); -PlOperator *new_PlOperator( char *name ); -PlOperator *new_axiom_op_list( void ); - - - -Fact *new_Fact( void ); -Fluent *new_Fluent( void ); -FluentValue *new_FluentValue( void ); -Facts *new_Facts( void ); -FluentValues *new_FluentValues( void ); -ExpNode *new_ExpNode( ExpConnective c ); -WffNode *new_WffNode( Connective c ); -Literal *new_Literal( void ); -NumericEffect *new_NumericEffect( void ); -Effect *new_Effect( void ); -Operator *new_Operator( char *name, int norp ); -NormEffect *new_NormEffect1( Effect *e ); -NormEffect *new_NormEffect2( NormEffect *e ); -NormOperator *new_NormOperator( Operator *op ); -EasyTemplate *new_EasyTemplate( NormOperator *op ); -MixedOperator *new_MixedOperator( Operator *op ); -PseudoActionEffect *new_PseudoActionEffect( void ); -PseudoAction *new_PseudoAction( MixedOperator *op ); -LnfExpNode *new_LnfExpNode( void ); -Action *new_Action( void ); -void make_state( State *pointer, int ft, int fl ); -EhcNode *new_EhcNode( void ); -EhcHashEntry *new_EhcHashEntry( void ); -PlanHashEntry *new_PlanHashEntry( void ); -BfsNode *new_BfsNode( void ); -BfsHashEntry *new_BfsHashEntry( void ); - - - - - - - -void free_TokenList( TokenList *source ); -void free_FactList( FactList *source ); -void free_ParseExpNode( ParseExpNode *n ); -void free_PlNode( PlNode *node ); -void free_PlOperator( PlOperator *o ); -void free_Operator( Operator *o ); -void free_ExpNode( ExpNode *n ); -void free_WffNode( WffNode *w ); -void free_NormEffect( NormEffect *e ); -void free_partial_Effect( Effect *e ); -void free_NormOperator( NormOperator *o ); -void free_single_NormEffect( NormEffect *e ); -void free_single_EasyTemplate( EasyTemplate *t ); -void free_TypedList( TypedList *t ); -void free_TypedListList( TypedListList *t ); -void free_ActionEffect( ActionEffect *e ); -void free_BfsNode( BfsNode *n ); -void free_BfsHashEntry( BfsHashEntry *n ); - - - - - - -#endif /* _MEMORY_H */ diff --git a/models/main_models/rt1/gen/ff_planner/output.c b/models/main_models/rt1/gen/ff_planner/output.c deleted file mode 100644 index 1341eff7a..000000000 --- a/models/main_models/rt1/gen/ff_planner/output.c +++ /dev/null @@ -1,1482 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: output.c - * Description: printing info out - * - * Author: Joerg Hoffmann - * - *********************************************************************/ - - - - - -#include "ff.h" - -#include "output.h" - - - - - - - -/* parsing - */ - - - - - - - -void print_FactList( FactList *list, char *sepf, char *sept ) - -{ - - FactList *i_list; - TokenList *i_tl; - - if ( list ) { - i_tl = list->item; - if (NULL == i_tl || NULL == i_tl->item) { - printf("empty"); - } else { - printf("%s", i_tl->item); - i_tl = i_tl->next; - } - - while (NULL != i_tl) { - if (NULL != i_tl->item) { - printf("%s%s", sept, i_tl->item); - } - i_tl = i_tl->next; - } - - for ( i_list = list->next; i_list; i_list = i_list->next ) { - printf("%s", sepf); - i_tl = i_list->item; - if (NULL == i_tl || NULL == i_tl->item) { - printf("empty"); - } else { - printf("%s", i_tl->item); - i_tl = i_tl->next; - } - - while (NULL != i_tl) { - if (NULL != i_tl->item) { - printf("%s%s", sept, i_tl->item); - } - i_tl = i_tl->next; - } - } - } - -} - - - -void print_hidden_TokenList( TokenList *list, char *sep ) - -{ - - TokenList *i_tl; - - i_tl = list; - if (NULL!=i_tl) { - printf("%s", i_tl->item); - i_tl = i_tl->next; - } else { - printf("empty"); - } - - while (NULL != i_tl) { - printf("%s%s", sep, i_tl->item); - i_tl = i_tl->next; - } - -} - - - -void print_indent( int indent ) - -{ - - int i; - for (i=0;iconnective) { - case AD: - printf("(+ "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case SU: - printf("(- "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case MU: - printf("(* "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case DI: - printf("(/ "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case MINUS: - printf("(- "); - print_ParseExpNode( n->leftson ); - printf(")"); - break; - case NUMBER: - printf("%s", n->atom->item); - break; - case FHEAD: - printf("("); - print_hidden_TokenList(n->atom, " "); - printf(")"); - break; - default: - printf("\n\nprint Parseexpnode: wrong specifier %d", - n->connective); - } - -} - - - -void print_PlNode( PlNode *plnode, int indent ) - -{ - - PlNode *i_son; - - if ( !plnode ) { - printf("none\n"); - return; - } - - switch (plnode->connective) { - case ALL: - printf("ALL %s : %s\n", plnode->atom->item, - plnode->atom->next->item); - print_indent(indent); - printf("( "); - print_PlNode(plnode->sons,indent+4); - print_indent(indent); - printf(")\n"); - break; - case EX: - printf("EX %s : %s\n", plnode->atom->item, - plnode->atom->next->item); - print_indent(indent); - printf("( "); - print_PlNode(plnode->sons,indent+4); - print_indent(indent); - printf(")\n"); - break; - case AND: - printf("A( "); - print_PlNode(plnode->sons, indent+4); - if ( plnode->sons ) { - for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { - print_indent(indent); - printf("AND "); - print_PlNode(i_son,indent+4); - } - } - print_indent(indent); - printf(")\n"); - break; - case OR: - printf("O( "); - print_PlNode(plnode->sons, indent+4); - for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { - print_indent(indent); - printf("OR "); - print_PlNode(i_son,indent+4); - } - print_indent(indent); - printf(")\n"); - break; - case WHEN: - printf("IF "); - print_PlNode(plnode->sons,indent+5); - print_indent(indent); - printf("THEN "); - print_PlNode(plnode->sons->next,indent+5); - print_indent(indent); - printf("ENDIF\n"); - break; - case NOT: - if (ATOM==plnode->sons->connective) { - printf("NOT "); - print_PlNode(plnode->sons,indent+4); - } else { - printf("NOT("); - print_PlNode(plnode->sons,indent+4); - print_indent(indent+3); - printf(")\n"); - } - break; - case ATOM: - printf("("); - print_hidden_TokenList(plnode->atom, " "); - printf(")\n"); - break; - case TRU: - printf("(TRUE)\n"); - break; - case FAL: - printf("(FALSE)\n"); - break; - case COMP: - switch (plnode->comp) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\n\nillegal comp in parse tree!\n\n"); - exit( 1 ); - } - print_ParseExpNode( plnode->lh ); - print_ParseExpNode( plnode->rh ); - printf(")\n"); - break; - case NEF: - switch (plnode->neft) { - case ASSIGN: - printf("(assign "); - break; - case SCALE_UP: - printf("(scale-up "); - break; - case SCALE_DOWN: - printf("(scale-down "); - break; - case INCREASE: - printf("(increase "); - break; - case DECREASE: - printf("(decrease "); - break; - } - print_ParseExpNode( plnode->lh ); - print_ParseExpNode( plnode->rh ); - printf(")\n"); - break; - default: - printf("\n***** ERROR ****"); - printf("\nprint_plnode: %d > Wrong Node specifier\n", plnode->connective); - exit(1); - } - -} - - - -void print_plops( PlOperator *plop ) - -{ - - PlOperator *i_plop; - int count = 0; - - if ( !plop ) { - printf("none\n"); - } - - for ( i_plop = plop; i_plop!=NULL; i_plop = i_plop->next ) { - printf("\n"); - if ( i_plop->axiom ) printf("AXIOM-"); - printf("OPERATOR "); - printf("%s", i_plop->name); - printf("\nparameters: (%d real)\n", i_plop->number_of_real_params); - print_FactList ( i_plop->params, "\n", " : "); - printf("\n\npreconditions:\n"); - print_PlNode(i_plop->preconds, 0); - printf("effects:\n"); - print_PlNode(i_plop->effects, 0); - printf("\n-----\n"); - count++; - } - printf("\nAnzahl der Operatoren: %d\n", count); - -} - - - -void print_ExpNode( ExpNode *n ) - -{ - - if ( !n ) return; - - switch ( n->connective) { - case AD: - printf("(+ "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case SU: - printf("(- "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case MU: - printf("(* "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case DI: - printf("(/ "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case MINUS: - printf("(- "); - print_ExpNode( n->son ); - printf(")"); - break; - case NUMBER: - printf("%.2f", n->value); - break; - case FHEAD: - if ( n->fluent ) { - print_Fluent( n->fluent ); - } else { - if ( n->fl >= 0 ) { - printf(" %.2f*", n->c); - print_fl_name( n->fl ); - } else { - printf("[UNDEF]"); - } - } - break; - default: - printf("\n\nprint Expnode: wrong specifier %d", - n->connective); - } - -} - - - -void print_Wff( WffNode *n, int indent ) - -{ - - WffNode *i; - - if ( !n ) { - printf("none\n"); - return; - } - - switch (n->connective) { - case ALL: - printf("ALL x%d (%s): %s\n", n->var, n->var_name, - gtype_names[n->var_type]); - print_indent(indent); - printf("( "); - print_Wff(n->son,indent+4); - print_indent(indent); - printf(")\n"); - break; - case EX: - printf("EX x%d (%s) : %s\n", n->var, n->var_name, - gtype_names[n->var_type]); - print_indent(indent); - printf("( "); - print_Wff(n->son,indent+4); - print_indent(indent); - printf(")\n"); - break; - case AND: - printf("A( "); - print_Wff(n->sons, indent+4); - if ( n->sons ) { - for ( i = n->sons->next; i!=NULL; i = i->next ) { - if ( !i->prev ) { - printf("\nprev in AND not correctly set!\n\n"); - exit( 1 ); - } - print_indent(indent); - printf("AND "); - print_Wff(i,indent+4); - } - } - print_indent(indent); - printf(")\n"); - break; - case OR: - printf("O( "); - print_Wff(n->sons, indent+4); - for ( i = n->sons->next; i!=NULL; i = i->next ) { - print_indent(indent); - printf("OR "); - print_Wff(i,indent+4); - } - print_indent(indent); - printf(")\n"); - break; - case NOT: - if (ATOM==n->son->connective) { - printf("NOT "); - print_Wff(n->son,indent+4); - } else { - printf("NOT("); - print_Wff(n->son,indent+4); - print_indent(indent+3); - printf(")\n"); - } - break; - case ATOM: - print_Fact(n->fact); - if ( n->NOT_p != -1 ) printf(" - translation NOT"); - printf("\n"); - break; - case TRU: - printf("(TRUE)\n"); - break; - case FAL: - printf("(FALSE)\n"); - break; - case COMP: - switch (n->comp) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in WFF %d\n\n", n->comp); - exit( 1 ); - } - print_ExpNode( n->lh ); - print_ExpNode( n->rh ); - printf(")\n"); - break; - default: - printf("\n***** ERROR ****"); - printf("\nprint_Wff: %d > Wrong Node specifier\n", n->connective); - exit(1); - } - -} - - - -void print_Operator( Operator *o ) - -{ - - Effect *e; - Literal *l; - NumericEffect *ne; - int i, m = 0; - - printf("\n\n----------------Operator %s, axiom %d, translated form, step 1--------------\n", - o->name, o->axiom); - - for ( i = 0; i < o->num_vars; i++ ) { - printf("\nx%d (%s) of type %s, removed ? %s", - i, o->var_names[i], gtype_names[o->var_types[i]], - o->removed[i] ? "YES" : "NO"); - } - printf("\ntotal params %d, real params %d\n", - o->num_vars, o->number_of_real_params); - - printf("\nPreconds:\n"); - print_Wff( o->preconds, 0 ); - - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d, parameters %d", m++, e->num_vars); - - for ( i = 0; i < e->num_vars; i++ ) { - printf("\nx%d (%s) of type %s", - o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]); - } - printf("\nConditions\n"); - print_Wff( e->conditions, 0 ); - printf("\nEffect Literals"); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - printf("\nNOT "); - } else { - printf("\n"); - } - print_Fact( &(l->fact) ); - } - printf("\nNumeric Effects"); - for ( ne = e->numeric_effects; ne; ne = ne->next ) { - switch ( ne->neft ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); - exit( 1 ); - } - print_Fluent( &(ne->fluent) ); - print_ExpNode( ne->rh ); - } - } - -} - - - -void print_NormOperator( NormOperator *o ) - -{ - - NormEffect *e; - int i, m; - - printf("\n\n----------------Operator %s, normalized form--------------\n", - o->operator->name); - - for ( i = 0; i < o->num_vars; i++ ) { - printf("\nx%d of type ", i); - print_type( o->var_types[i] ); - } - printf("\n\n%d vars removed from original operator:", - o->num_removed_vars); - for ( i = 0; i < o->num_removed_vars; i++ ) { - m = o->removed_vars[i]; - printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m], - gtype_names[o->operator->var_types[m]]); - print_type( o->type_removed_vars[i] ); - } - - printf("\nPreconds:\n"); - for ( i = 0; i < o->num_preconds; i++ ) { - print_Fact( &(o->preconds[i]) ); - printf("\n"); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - switch ( o->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normpre %d\n\n", - o->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( o->numeric_preconds_lh[i] ); - print_ExpNode( o->numeric_preconds_rh[i] ); - printf(")\n"); - } - - m = 0; - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d, parameters %d", m++, e->num_vars); - - for ( i = 0; i < e->num_vars; i++ ) { - printf("\nx%d of type ", o->num_vars + i); - print_type( e->var_types[i] ); - } - printf("\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_Fact( &(e->conditions[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - switch ( e->numeric_conditions_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normeff %d\n\n", - e->numeric_conditions_comp[i]); - exit( 1 ); - } - print_ExpNode( e->numeric_conditions_lh[i] ); - print_ExpNode( e->numeric_conditions_rh[i] ); - printf(")\n"); - } - - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_Fact( &(e->adds[i]) ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_Fact( &(e->dels[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - switch ( e->numeric_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint normop: illegal neft %d\n\n", - e->numeric_effects_neft[i]); - exit( 1 ); - } - print_Fluent( &(e->numeric_effects_fluent[i]) ); - print_ExpNode( e->numeric_effects_rh[i] ); - } - } - -} - - - -void print_MixedOperator( MixedOperator *o ) - -{ - - int i, m; - Effect *e; - NumericEffect *ne; - Literal *l; - - printf("\n\n----------------Operator %s, mixed form--------------\n", - o->operator->name); - - for ( i = 0; i < o->operator->num_vars; i++ ) { - printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); - print_type( o->operator->var_types[i] ); - } - - printf("\nPreconds:\n"); - for ( i = 0; i < o->num_preconds; i++ ) { - print_Fact( &(o->preconds[i]) ); - printf("\n"); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - switch ( o->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", - o->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( o->numeric_preconds_lh[i] ); - print_ExpNode( o->numeric_preconds_rh[i] ); - printf(")\n"); - } - - m = 0; - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d, parameters %d", m++, e->num_vars); - - for ( i = 0; i < e->num_vars; i++ ) { - printf("\nx%d of type %s", - o->operator->num_vars + i, gtype_names[e->var_types[i]]); - } - printf("\nConditions\n"); - print_Wff( e->conditions, 0 ); - printf("\nEffect Literals"); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - printf("\nNOT "); - } else { - printf("\n"); - } - print_Fact( &(l->fact) ); - } - printf("\nNumeric Effects"); - for ( ne = e->numeric_effects; ne; ne = ne->next ) { - switch ( ne->neft ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); - exit( 1 ); - } - print_Fluent( &(ne->fluent) ); - print_ExpNode( ne->rh ); - } - } - -} - - - -void print_PseudoAction( PseudoAction *o ) - -{ - - PseudoActionEffect *e; - int i, m; - - printf("\n\n----------------Pseudo Action %s--------------\n", - o->operator->name); - - for ( i = 0; i < o->operator->num_vars; i++ ) { - printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); - print_type( o->operator->var_types[i] ); - } - - printf("\nPreconds:\n"); - for ( i = 0; i < o->num_preconds; i++ ) { - print_Fact( &(o->preconds[i]) ); - printf("\n"); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - switch ( o->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", - o->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( o->numeric_preconds_lh[i] ); - print_ExpNode( o->numeric_preconds_rh[i] ); - printf(")\n"); - } - - m = 0; - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d", m++); - printf("\n\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_Fact( &(e->conditions[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - switch ( e->numeric_conditions_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normeff %d\n\n", - e->numeric_conditions_comp[i]); - exit( 1 ); - } - print_ExpNode( e->numeric_conditions_lh[i] ); - print_ExpNode( e->numeric_conditions_rh[i] ); - printf(")\n"); - } - - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_Fact( &(e->adds[i]) ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_Fact( &(e->dels[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - switch ( e->numeric_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint normop: illegal neft %d\n\n", - e->numeric_effects_neft[i]); - exit( 1 ); - } - print_Fluent( &(e->numeric_effects_fluent[i]) ); - print_ExpNode( e->numeric_effects_rh[i] ); - } - } - -} - - - -void print_Action( Action *a ) - -{ - - ActionEffect *e; - int i, j; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("\n\nAction REACH-GOAL"); - } else { - printf("\n\nAction %s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - - printf("\n\nPreconds:\n"); - for ( i = 0; i < a->num_preconds; i++ ) { - print_ft_name( a->preconds[i] ); - printf("\n"); - } - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - switch ( a->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in actionpre %d\n\n", - a->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( a->numeric_preconds_lh[i] ); - print_ExpNode( a->numeric_preconds_rh[i] ); - printf(")\n"); - } - - printf("\n\nEffects:"); - for ( j = 0; j < a->num_effects; j++ ) { - printf("\n\neffect %d", j); - e = &(a->effects[j]); - if ( e->illegal ) printf(" ILLEGAL EFFECT!"); - printf("\n\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_ft_name( e->conditions[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - switch ( e->numeric_conditions_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normeff %d\n\n", - e->numeric_conditions_comp[i]); - exit( 1 ); - } - print_ExpNode( e->numeric_conditions_lh[i] ); - print_ExpNode( e->numeric_conditions_rh[i] ); - printf(")\n"); - } - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_ft_name( e->adds[i] ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_ft_name( e->dels[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - switch ( e->numeric_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint normop: illegal neft %d\n\n", - e->numeric_effects_neft[i]); - exit( 1 ); - } - if ( e->numeric_effects_fl[i] >= 0 ) { - print_fl_name( e->numeric_effects_fl[i] ); - } else { - printf("[UNDEF]"); - } - print_ExpNode( e->numeric_effects_rh[i] ); - } - } - -} - - - -void print_Action_name( Action *a ) - -{ - - int i; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("REACH-GOAL"); - } else { - printf("%s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - -} - - - -void print_lnf_Action( Action *a ) - -{ - - ActionEffect *e; - int i, j; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("\n\nAction REACH-GOAL"); - } else { - printf("\n\nAction %s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - - printf("\n\nPreconds:\n"); - for ( i = 0; i < a->num_preconds; i++ ) { - print_ft_name( a->preconds[i] ); - printf("\n"); - } - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - switch ( a->lnf_preconds_comp[i] ) { - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in lnf actionpre %d\n\n", - a->lnf_preconds_comp[i]); - exit( 1 ); - } - print_LnfExpNode( a->lnf_preconds_lh[i] ); - printf(" %.2f)\n", a->lnf_preconds_rh[i]); - } - - printf("\n\nEffects:"); - for ( j = 0; j < a->num_effects; j++ ) { - printf("\n\neffect %d COST %f", j, a->effects[j].cost); - e = &(a->effects[j]); - if ( e->illegal ) printf(" ILLEGAL EFFECT!"); - if ( e->removed ) printf(" REMOVED!!!"); - printf("\n\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_ft_name( e->conditions[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_lnf_conditions; i++ ) { - switch ( e->lnf_conditions_comp[i] ) { - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in lnf normeff %d\n\n", - e->lnf_conditions_comp[i]); - exit( 1 ); - } - print_LnfExpNode( e->lnf_conditions_lh[i] ); - printf(" %.2f)\n", e->lnf_conditions_rh[i] ); - } - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_ft_name( e->adds[i] ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_ft_name( e->dels[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_lnf_effects; i++ ) { - switch ( e->lnf_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case INCREASE: - printf("\nincrease "); - break; - default: - printf("\n\nprint lnf normop: illegal neft %d\n\n", - e->lnf_effects_neft[i]); - exit( 1 ); - } - if ( e->lnf_effects_fl[i] >= 0 ) { - print_fl_name( e->lnf_effects_fl[i] ); - } else { - printf("[UNDEF]"); - } - print_LnfExpNode( e->lnf_effects_rh[i] ); - } - } - -} - - - -void print_type( int t ) - -{ - - int j; - - if ( gpredicate_to_type[t] == -1 ) { - if ( gnum_intersected_types[t] == -1 ) { - printf("%s", gtype_names[t]); - } else { - printf("INTERSECTED TYPE ("); - for ( j = 0; j < gnum_intersected_types[t]; j++ ) { - if ( gpredicate_to_type[gintersected_types[t][j]] == -1 ) { - printf("%s", gtype_names[gintersected_types[t][j]]); - } else { - printf("UNARY INERTIA TYPE (%s)", - gpredicates[gpredicate_to_type[gintersected_types[t][j]]]); - } - if ( j < gnum_intersected_types[t] - 1 ) { - printf(" and "); - } - } - printf(")"); - } - } else { - printf("UNARY INERTIA TYPE (%s)", gpredicates[gpredicate_to_type[t]]); - } - -} - - - -void print_Fact( Fact *f ) - -{ - - int j; - - if ( f->predicate == -3 ) { - printf("GOAL-REACHED"); - return; - } - - if ( f->predicate == -1 ) { - printf("(="); - for ( j=0; j<2; j++ ) { - printf(" "); - if ( f->args[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - return; - } - - if ( f->predicate == -2 ) { - printf("(!="); - for ( j=0; j<2; j++ ) { - printf(" "); - if ( f->args[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - return; - } - - printf("(%s", gpredicates[f->predicate]); - for ( j=0; jpredicate]; j++ ) { - printf(" "); - if ( f->args[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - -} - - - -void print_Fluent( Fluent *f ) - -{ - - int j, ff = f->function; - - printf("(%s", gfunctions[ff]); - for ( j=0; jargs[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - -} - - - -void print_ft_name( int index ) - -{ - - print_Fact( &(grelevant_facts[index]) ); - -} - - - -void print_fl_name( int index ) - -{ - - int i; - - if ( index < 0 ) { - if ( index != -2 ) { - printf("[UNDEF]"); - } else { - printf("[TOTAL-TIME]"); - } - return; - } - - if ( grelevant_fluents_lnf[index] == NULL ) { - /* this is a non-artificial "atomic" one - * (or the mirrored version of one) - */ - printf("[RF%d](%s)", index, grelevant_fluents_name[index]); - } else { - /* this only summarizes a LNF requirement - */ - printf("[artRF%d]", index); - for ( i = 0; i < grelevant_fluents_lnf[index]->num_pF; i++ ) { - printf("%.2f*", grelevant_fluents_lnf[index]->pC[i] ); - print_fl_name( grelevant_fluents_lnf[index]->pF[i] ); - if ( i < grelevant_fluents_lnf[index]->num_pF - 1 ) { - printf(" + "); - } - } - } - -} - - - -void print_LnfExpNode( LnfExpNode *n ) - -{ - - int i; - - printf("(("); - for ( i = 0; i < n->num_pF; i++ ) { - printf("%.2f*", n->pC[i]); - print_fl_name( n->pF[i] ); - } - printf(") - ("); - for ( i = 0; i < n->num_nF; i++ ) { - printf("%.2f*", n->nC[i]); - print_fl_name( n->nF[i] ); - } - printf(") + %.2f)", n->c); - -} - - - -void print_op_name( int index ) - -{ - - int i; - Action *a = gop_conn[index].action; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("REACH-GOAL"); - } else { - printf("%s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - -} - - - -void print_State( State S ) - -{ - - int i; - - for ( i = 0; i < S.num_F; i++ ) { - printf("\n"); - print_ft_name( S.F[i] ); - } - for ( i = 0; i < gnum_relevant_fluents; i++ ) { - printf("\n"); - print_fl_name( i ); - printf(": "); - if ( S.f_D[i] ) { - printf("%.2f", S.f_V[i]); - } else { - printf("UNDEF"); - } - } - -} - - - - - - - - -/* - * program output routines - */ - - - - - - - - - -void print_plan( void ) - -{ - - int i; - float cost = 0; - - printf("\n\nff: found legal plan as follows"); - printf("\nstep "); - for ( i = 0; i < gnum_plan_ops; i++ ) { - printf("%4d: ", i); - print_op_name( gplan_ops[i] ); - if ( i < gnum_plan_ops-1 ) { - printf("\n "); - } - if ( goptimization_established ) { - cost += gop_conn[gplan_ops[i]].cost; - } - } - if ( goptimization_established ) { - printf("\nplan cost: %f", cost); - } - -} diff --git a/models/main_models/rt1/gen/ff_planner/output.h b/models/main_models/rt1/gen/ff_planner/output.h deleted file mode 100644 index a74e87607..000000000 --- a/models/main_models/rt1/gen/ff_planner/output.h +++ /dev/null @@ -1,68 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: output.h - * Description: print headers - * - * Author: Joerg Hoffmann 1999 - * - *********************************************************************/ - - - - - -#ifndef _OUTPUT_H -#define _OUTPUT_H - - - -void print_FactList( FactList *list, char *sepf, char *sept ); -void print_hidden_TokenList( TokenList *list, char *sep ); -void print_indent( int indent ); -void print_ParseExpNode( ParseExpNode *n ); -void print_PlNode( PlNode *plnode, int indent ); -void print_ExpNode( ExpNode *n ); -void print_Wff( WffNode *n, int indent ); -void print_plops( PlOperator *plop ); -void print_Operator( Operator *o ); -void print_NormOperator( NormOperator *o ); -void print_MixedOperator( MixedOperator *o ); -void print_PseudoAction( PseudoAction *o ); -void print_Action( Action *a ); -void print_Action_name( Action *a ); -void print_lnf_Action( Action *a ); -void print_type( int t ); -void print_Fact( Fact *f ); -void print_Fluent( Fluent *f ); -void print_ft_name( int index ); -void print_op_name( int index ); -void print_fl_name( int index ); -void print_LnfExpNode( LnfExpNode *n ); -void print_State( State S ); - - - -void print_plan( void ); - - - -#endif /* _OUTPUT_H */ diff --git a/models/main_models/rt1/gen/ff_planner/parse.c b/models/main_models/rt1/gen/ff_planner/parse.c deleted file mode 100644 index cc5a099f9..000000000 --- a/models/main_models/rt1/gen/ff_planner/parse.c +++ /dev/null @@ -1,1339 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: parse.c - * Description: Functions for the pddl parser - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - -#include "ff.h" - -#include "memory.h" -#include "output.h" - -#include "parse.h" - - - - - - - - - - - -/* simple parse helpers - */ - - - - - - - -char *copy_Token( char *s ) - -{ - - char *d = new_Token( strlen( s ) + 1 ); - strcpy(d, s); - - return d; - -} - - - -TokenList *copy_TokenList( TokenList *source ) - -{ - - TokenList *temp; - - if ( !source ) { - temp = NULL; - } else { - temp = new_TokenList(); - if ( source->item ) { - temp->item = new_Token( strlen( source->item ) + 1 ); - strcpy( temp->item, source->item ); - } - temp->next = copy_TokenList( source->next ); - } - - return temp; - -} - - - -void strupcase( char *from ) - -{ - - char tmp; - - tmp = *from; - while ('\0' != tmp) { - *from = (char) toupper((int) tmp); - tmp = *++from; - } - -} - - - -char *rmdash( char *s ) - -{ - - s++; - - for( ; (*s == ' ') || (*s == '\t'); s++ ); - - return s; - -} - - - - - - - - - - -/* typed-list-of preprocessing - */ - - - - - - - -Token ltype_names[MAX_TYPES]; -int lnum_types; - - -int leither_ty[MAX_TYPES][MAX_TYPES]; -int lnum_either_ty[MAX_TYPES]; - - - - - -void build_orig_constant_list( void ) - -{ - - char *tmp = NULL; - TypedList *tyl; - TypedListList *tyll; - TokenList *tl, *p_tl, *tmp_tl; - PlOperator *po; - - int i, j, k, n, std; - - Bool m[MAX_TYPES][MAX_TYPES]; - - FactList *fl, *p_fl; - - lnum_types = 0; - for ( tyl = gparse_types; tyl; tyl = tyl->next ) { - if ( get_type( tyl->name ) == -1 ) { - ltype_names[lnum_types++] = copy_Token( tyl->name ); - } - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - - for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - - for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - - for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - } - - for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - } - - collect_type_names_in_pl( gorig_goal_facts ); - - for ( po = gloaded_ops; po; po = po->next ) { - collect_type_names_in_pl( po->preconds ); - collect_type_names_in_pl( po->effects ); - for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - } - - - /* now get the numbers of all composed either types - */ - for ( i = 0; i < lnum_types; i++ ) { - lnum_either_ty[i] = 0; - } - for ( tyl = gparse_types; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - } - for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - } - make_either_ty_in_pl( gorig_goal_facts ); - for ( po = gloaded_ops; po; po = po->next ) { - make_either_ty_in_pl( po->preconds ); - make_either_ty_in_pl( po->effects ); - for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - } - - - /* now, compute the transitive closure of all type inclusions. - * first initialize the matrix. - */ - for ( i = 0; i < lnum_types; i++ ) { - for ( j = 0; j < lnum_types; j++ ) { - m[i][j] = ( i == j ? TRUE : FALSE ); - } - } - std = -1; - for ( i = 0; i < lnum_types; i++ ) { - if ( strcmp( ltype_names[i], STANDARD_TYPE ) == SAME ) { - std = i; - break; - } - } - for ( i = 0; i < lnum_types; i++ ) { - m[i][std] = TRUE;/* all types are subtypes of OBJECT */ - } - for ( tyl = gparse_types; tyl; tyl = tyl->next ) { - /* all inclusions as are defined in domain file - */ - m[get_type( tyl->name )][tyl->n] = TRUE; - } - /* compute transitive closure on inclusions matrix - */ - for ( j = 0; j < lnum_types; j++ ) { - for ( i = 0; i < lnum_types; i++ ) { - if ( m[i][j] ) { - for ( k = 0; k < lnum_types; k++ ) { - if ( m[j][k] ) { - m[i][k] = TRUE; - } - } - } - } - } - /* union types are subsets of all those types that contain all - * their components, and - * all component types are subsets of the either type ! - */ - for ( i = 0; i < lnum_types; i++ ) { - if ( lnum_either_ty[i] < 2 ) continue; - for ( j = 0; j < lnum_types; j++ ) { - if ( j == i ) continue; - /* get supertypes of all component types - */ - for ( k = 0; k < lnum_either_ty[i]; k++ ) { - if ( !m[leither_ty[i][k]][j] ) break; - } - if ( k < lnum_either_ty[i] ) continue; - m[i][j] = TRUE; - /* make components subtypes of either type - */ - for ( k = 0; k < lnum_either_ty[i]; k++ ) { - m[leither_ty[i][k]][i] = TRUE; - } - } - } - /* and again, compute transitive closure on inclusions matrix. - * I guess, this won't change anything (?), but it also won't need - * any remarkable computation time, so why should one think about it ? - */ - for ( j = 0; j < lnum_types; j++ ) { - for ( i = 0; i < lnum_types; i++ ) { - if ( m[i][j] ) { - for ( k = 0; k < lnum_types; k++ ) { - if ( m[j][k] ) { - m[i][k] = TRUE; - } - } - } - } - } - - - /* now build FactList of ALL constant -> type pairs. - * for each constant / object, let it appear separately - * for each type it is a member of; compute type - * membership based on propagating constants / objects - * through inclusions matrix. - * - * this might make the same pair appear doubly, if an object - * is declared in type T as well as in some supertype T'. - * such cases will be filtered out in string collection. - */ - for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyl->type->item ); - } - fl->next = gorig_constant_list; - gorig_constant_list = fl; - /* now add constant to all supertypes - */ - n = get_type( fl->item->next->item ); - for ( i = 0; i < lnum_types; i++ ) { - if ( i == n || - !m[n][i] ) continue; - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - fl->item->next->item = copy_Token( ltype_names[i] ); - fl->next = gorig_constant_list; - gorig_constant_list = fl; - } - } - for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyl->type->item ); - } - fl->next = gorig_constant_list; - gorig_constant_list = fl; - /* now add constant to all supertypes - */ - n = get_type( fl->item->next->item ); - for ( i = 0; i < lnum_types; i++ ) { - if ( i == n || - !m[n][i] ) continue; - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - fl->item->next->item = copy_Token( ltype_names[i] ); - fl->next = gorig_constant_list; - gorig_constant_list = fl; - } - } - - - /* now, normalize all typed-list-of s in domain and problem def, - * i.e., in all PlNode quantifiers and in op parameters - * - * at the same time, remove typed-listof structures in these defs - */ - normalize_tyl_in_pl( &gorig_goal_facts ); - for ( po = gloaded_ops; po; po = po->next ) { - normalize_tyl_in_pl( &po->preconds ); - normalize_tyl_in_pl( &po->effects ); - /* be careful to maintain parameter ordering ! - */ - if ( !po->parse_params ) { - continue;/* no params at all */ - } - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( po->parse_params->name ); - if ( po->parse_params->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = po->parse_params->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( po->parse_params->type->item ); - } - po->params = fl; - p_fl = fl; - for ( tyl = po->parse_params->next; tyl; tyl = tyl->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyl->type->item ); - } - p_fl->next = fl; - p_fl = fl; - } - free_TypedList( po->parse_params ); - po->parse_params = NULL; - } - - - /* finally, build gpredicates_and_types by chaining predicate names - * together with the names of their args' types. - */ - for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->item = copy_Token( tyll->predicate ); - fl->next = gpredicates_and_types; - gpredicates_and_types = fl; - if ( !tyll->args ) continue; - /* add arg types; MAINTAIN ORDERING ! - */ - fl->item->next = new_TokenList(); - if ( tyll->args->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyll->args->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyll->args->type->item ); - } - p_tl = fl->item->next; - for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { - tmp_tl = new_TokenList(); - if ( tyl->type->next ) { - tmp_tl->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp_tl->item, CONNECTOR ); - strcat( tmp_tl->item, tl->item ); - } - } else { - tmp_tl->item = copy_Token( tyl->type->item ); - } - p_tl->next = tmp_tl; - p_tl = tmp_tl; - } - } - - for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->item = copy_Token( tyll->predicate ); - fl->next = gfunctions_and_types; - gfunctions_and_types = fl; - if ( !tyll->args ) continue; - /* add arg types; MAINTAIN ORDERING ! - */ - fl->item->next = new_TokenList(); - if ( tyll->args->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyll->args->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyll->args->type->item ); - } - p_tl = fl->item->next; - for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { - tmp_tl = new_TokenList(); - if ( tyl->type->next ) { - tmp_tl->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp_tl->item, CONNECTOR ); - strcat( tmp_tl->item, tl->item ); - } - } else { - tmp_tl->item = copy_Token( tyl->type->item ); - } - p_tl->next = tmp_tl; - p_tl = tmp_tl; - } - } - - /* now get rid of remaining typed-list-of parsing structures - */ - free_TypedList( gparse_types ); - gparse_types = NULL; - free_TypedList( gparse_constants ); - gparse_constants = NULL; - free_TypedList( gparse_objects ); - gparse_objects = NULL; - free_TypedListList( gparse_predicates ); - gparse_predicates = NULL; - free_TypedListList( gparse_functions ); - gparse_functions = NULL; - -} - - - -void collect_type_names_in_pl( PlNode *n ) - -{ - - PlNode *i; - TypedList *tyl; - TokenList *tl; - char *tmp = NULL; - int nn; - - if ( !n ) { - return; - } - - switch( n->connective ) { - case ALL: - case EX: - for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (nn = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = nn; - } - free( tmp ); - tmp = NULL; - } - collect_type_names_in_pl( n->sons ); - break; - case AND: - case OR: - for ( i = n->sons; i; i = i->next ) { - collect_type_names_in_pl( i ); - } - break; - case NOT: - collect_type_names_in_pl( n->sons ); - break; - case ATOM: - case TRU: - case FAL: - break; - case WHEN: - collect_type_names_in_pl( n->sons ); - collect_type_names_in_pl( n->sons->next ); - break; - default: - break; - } - -} - - - -int get_type( char *str ) - -{ - - int i; - - for ( i = 0; i < lnum_types; i++ ) { - if ( strcmp( str, ltype_names[i] ) == SAME ) return i; - } - - return -1; - -} - - - -void make_either_ty( TypedList *tyl ) - -{ - - TokenList *i; - - if ( lnum_either_ty[tyl->n] > 0 ) { - return; - } - - for ( i = tyl->type; i; i = i->next ) { - leither_ty[tyl->n][lnum_either_ty[tyl->n]++] = get_type( i->item ); - } - -} - - - -void make_either_ty_in_pl( PlNode *n ) - -{ - - PlNode *i; - TypedList *tyl; - - if ( !n ) { - return; - } - - switch( n->connective ) { - case ALL: - case EX: - for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - make_either_ty_in_pl( n->sons ); - break; - case AND: - case OR: - for ( i = n->sons; i; i = i->next ) { - make_either_ty_in_pl( i ); - } - break; - case NOT: - make_either_ty_in_pl( n->sons ); - break; - case ATOM: - case TRU: - case FAL: - break; - case WHEN: - make_either_ty_in_pl( n->sons ); - make_either_ty_in_pl( n->sons->next ); - break; - default: - break; - } - -} - - - -void normalize_tyl_in_pl( PlNode **n ) - -{ - - PlNode *i; - TypedList *tyl; - PlNode *tmp_pl = NULL, *sons, *p_pl; - TokenList *tmp_tl, *tl; - - - if ( !(*n) ) { - return; - } - - switch( (*n)->connective ) { - case ALL: - case EX: - /* we need to make a sequence of quantifiers ( ->sons ...) - * out of the given sequence of TypedList elements, - * with connected type names, var - name in TokenList - * and KEEPING THE SAME ORDERING !! - */ - if ( !(*n)->parse_vars ) { - printf("\n\nquantifier without argument !! check input files.\n\n"); - exit( 1 ); - } - tmp_tl = new_TokenList(); - tmp_tl->next = new_TokenList(); - tmp_tl->item = copy_Token( (*n)->parse_vars->name ); - if ( (*n)->parse_vars->type->next ) { - tmp_tl->next->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->next->item, EITHER_STR ); - for ( tl = (*n)->parse_vars->type; tl; tl = tl->next ) { - strcat( tmp_tl->next->item, CONNECTOR ); - strcat( tmp_tl->next->item, tl->item ); - } - } else { - tmp_tl->next->item = copy_Token( (*n)->parse_vars->type->item ); - } - (*n)->atom = tmp_tl; - /* now add list of sons - */ - sons = (*n)->sons; - p_pl = *n; - for ( tyl = (*n)->parse_vars->next; tyl; tyl = tyl->next ) { - tmp_tl = new_TokenList(); - tmp_tl->next = new_TokenList(); - tmp_tl->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - tmp_tl->next->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp_tl->next->item, CONNECTOR ); - strcat( tmp_tl->next->item, tl->item ); - } - } else { - tmp_tl->next->item = copy_Token( tyl->type->item ); - } - tmp_pl = new_PlNode( (*n)->connective ); - tmp_pl->atom = tmp_tl; - p_pl->sons = tmp_pl; - p_pl = tmp_pl; - } - /* remove typed-list-of info - */ - free_TypedList( (*n)->parse_vars ); - (*n)->parse_vars = NULL; - /* the last son in list takes over ->sons - */ - p_pl->sons = sons; - /* normalize this sons and get out - */ - normalize_tyl_in_pl( &(p_pl->sons) ); - break; - case AND: - case OR: - for ( i = (*n)->sons; i; i = i->next ) { - normalize_tyl_in_pl( &i ); - } - break; - case NOT: - normalize_tyl_in_pl( &((*n)->sons) ); - break; - case ATOM: - case TRU: - case FAL: - break; - case WHEN: - normalize_tyl_in_pl( &((*n)->sons) ); - normalize_tyl_in_pl( &((*n)->sons->next) ); - break; - default: - break; - } - -} - - - - - - - - - - - - -/* ADL syntax test - and normalization (AND s etc.) - */ - - - - - - - - - - - - -Bool make_adl_domain( void ) - -{ - - PlOperator *i; - FactList *ff; - - if ( gcmd_line.display_info == 101 ) { - printf("\noriginal problem parsing is:\n"); - printf("\nobjects:"); - for ( ff = gorig_constant_list; ff; ff = ff->next ) { - printf("\n%s : %s", ff->item->item, ff->item->next->item); - } - printf("\n\ninitial state:\n"); - print_PlNode( gorig_initial_facts, 0 ); - printf("\n\ngoal state:\n"); - print_PlNode( gorig_goal_facts, 0 ); - printf("\n\nops:"); - print_plops( gloaded_ops ); - } - - if ( !make_conjunction_of_atoms( &gorig_initial_facts ) ) { - printf("\nillegal initial state"); - return FALSE; - } - - if ( !gorig_goal_facts ) { - gorig_goal_facts = new_PlNode( TRU ); - } - - if ( !is_wff( gorig_goal_facts ) ) { - printf("\nillegal goal formula"); - print_PlNode( gorig_goal_facts, 0 ); - return FALSE; - } - - for ( i = gloaded_ops; i; i = i->next ) { - if ( !i->preconds ) { - i->preconds = new_PlNode( TRU ); - } - if ( !is_wff( i->preconds ) ) { - printf("\nop %s has illegal precondition", i->name); - return FALSE; - } - if ( !make_effects( &(i->effects) ) ) { - printf("\nop %s has illegal effects", i->name); - return FALSE; - } - } - - if ( gcmd_line.display_info == 102 ) { - printf("\nfinal ADL representation is:\n"); - printf("\nobjects:"); - for ( ff = gorig_constant_list; ff; ff = ff->next ) { - printf("\n%s : %s", ff->item->item, ff->item->next->item); - } - printf("\n\ninitial state:\n"); - print_PlNode( gorig_initial_facts, 0 ); - printf("\n\ngoal formula:\n"); - print_PlNode( gorig_goal_facts, 0 ); - printf("\n\nops:"); - print_plops( gloaded_ops ); - } - - return TRUE; - -} - - - -Bool make_conjunction_of_atoms( PlNode **n ) - -{ - - PlNode *tmp, *i, *p, *m; - - if ( !(*n) ) { - return TRUE; - } - - if ( (*n)->connective != AND ) { - switch ( (*n)->connective ) { - case ATOM: - tmp = new_PlNode( ATOM ); - tmp->atom = (*n)->atom; - (*n)->atom = NULL; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - case COMP: - tmp = new_PlNode( COMP ); - tmp->comp = (*n)->comp; - tmp->lh = (*n)->lh; - tmp->rh = (*n)->rh; - (*n)->lh = NULL; - (*n)->rh = NULL; - (*n)->comp = -1; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - case NOT: - free_PlNode( *n ); - (*n) = NULL; - return TRUE; - default: - return FALSE; - } - } - - p = NULL; - i = (*n)->sons; - while ( i ) { - switch ( i->connective ) { - case ATOM: - break; - case COMP: - break; - case NOT: - if ( p ) { - p->next = i->next; - } else { - (*n)->sons = i->next; - } - m = i->next; - i->next = NULL; - free_PlNode( i ); - i = m; - break; - default: - return FALSE; - } - if ( i->connective != NOT ) { - p = i; - i = i->next; - } - } - - return TRUE; - -} - - - -Bool is_wff( PlNode *n ) - -{ - - PlNode *i; - - if ( !n ) { - return FALSE; - } - - switch( n->connective ) { - case ALL: - case EX: - if ( !(n->atom) || - !(n->atom->next ) || - n->atom->next->next != NULL ) { - return FALSE; - } - return is_wff( n->sons ); - case AND: - case OR: - for ( i = n->sons; i; i = i->next ) { - if ( !is_wff( i ) ) { - return FALSE; - } - } - return TRUE; - case NOT: - return is_wff( n->sons ); - case ATOM: - if ( !(n->atom) || - n->sons != NULL ) { - return FALSE; - } - return TRUE; - case TRU: - case FAL: - if ( n->sons != NULL ) { - return FALSE; - } - return TRUE; - case COMP: - if ( n->sons != NULL || - n->atom != NULL || - n->lh == NULL || - n->rh == NULL || - n->comp < 0 ) { - return FALSE; - } - return TRUE; - default: - return FALSE; - } - -} - - - -Bool make_effects( PlNode **n ) - -{ - - PlNode *tmp, *i, *literals, *j, *k, *next; - int m = 0; - - if ( (*n)->connective != AND ) { - if ( !is_eff_literal( *n ) && - (*n)->connective != ALL && - (*n)->connective != WHEN ) { - return FALSE; - } - tmp = new_PlNode( (*n)->connective ); - tmp->atom = (*n)->atom; - tmp->sons = (*n)->sons; - tmp->neft = (*n)->neft; - tmp->lh = (*n)->lh; - tmp->rh = (*n)->rh; - (*n)->connective = AND; - (*n)->sons = tmp; - (*n)->lh = NULL; - (*n)->rh = NULL; - (*n)->neft = -1; - } - - for ( i = (*n)->sons; i; i = i->next ) { - if ( is_eff_literal( i ) ) { - m++; - continue; - } - if ( i->connective == AND ) { - for ( j = i->sons; j; j = j->next ) { - if ( !is_eff_literal( j ) ) { - return FALSE; - } - m++; - } - continue; - } - if ( i->connective == ALL ) { - for ( j = i->sons; j && j->connective == ALL; j = j->sons ) { - if ( !j->atom || - !j->atom->next || - j->atom->next->next != NULL ) { - return FALSE; - } - } - if ( !j ) { - return FALSE; - } - if ( is_eff_literal( j ) ) { - tmp = new_PlNode( AND ); - for ( k = i; k->sons->connective == ALL; k = k->sons ); - k->sons = tmp; - tmp->sons = j; - j = tmp; - } - if ( j->connective == AND ) { - for ( k = j->sons; k; k = k->next ) { - if ( !is_eff_literal( k ) ) { - return FALSE; - } - } - tmp = new_PlNode( WHEN ); - for ( k = i; k->sons->connective == ALL; k = k->sons ); - k->sons = tmp; - tmp->sons = new_PlNode( TRU ); - tmp->sons->next = j; - continue; - } - if ( j->connective != WHEN ) { - return FALSE; - } - if ( !(j->sons) ) { - j->sons = new_PlNode( TRU ); - } - if ( !is_wff( j->sons ) ) { - return FALSE; - } - if ( !make_conjunction_of_literals( &(j->sons->next) ) ) { - return FALSE; - } - continue; - } - if ( i->connective != WHEN ) { - return FALSE; - } - if ( !(i->sons) ) { - i->sons = new_PlNode( TRU ); - } - if ( !is_wff( i->sons ) ) { - return FALSE; - } - if ( !make_conjunction_of_literals( &(i->sons->next) ) ) { - return FALSE; - } - } - - if ( m == 0 ) { - return TRUE; - } - - tmp = new_PlNode( WHEN ); - tmp->sons = new_PlNode( TRU ); - literals = new_PlNode( AND ); - tmp->sons->next = literals; - tmp->next = (*n)->sons; - (*n)->sons = tmp; - i = (*n)->sons; - while ( i->next ) { - if ( is_eff_literal( i->next ) ) { - next = i->next->next; - i->next->next = literals->sons; - literals->sons = i->next; - i->next = next; - continue; - } - if ( i->next->connective == AND ) { - next = i->next->next; - for ( j = i->next->sons; j && j->next; j = j->next ); - if ( j ) { - j->next = literals->sons; - literals->sons = i->next->sons; - } - i->next = next; - continue; - } - i = i->next; - } - return TRUE; - -} - - - -Bool is_eff_literal( PlNode *n ) - -{ - - if ( !n ) { - return FALSE; - } - - if ( n->connective == NOT ) { - if ( !n->sons || - n->sons->connective != ATOM || - !n->sons->atom ) { - return FALSE; - } - return TRUE; - } - - if ( n->connective == ATOM ) { - if ( !n->atom ) { - return FALSE; - } - return TRUE; - } - - if ( n->connective == NEF ) { - if ( !n->lh || - !n->rh || - n->neft < 0 ) { - return FALSE; - } - return TRUE; - } - - return FALSE; - -} - - - -Bool make_conjunction_of_literals( PlNode **n ) - -{ - - PlNode *tmp, *i; - - if ( !(*n) ) { - return FALSE; - } - - if ( (*n)->connective != AND ) { - if ( (*n)->connective == NOT ) { - if ( !((*n)->sons) || - (*n)->sons->connective != ATOM ) { - return FALSE; - } - tmp = new_PlNode( NOT ); - tmp->sons = (*n)->sons; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - } - if ( (*n)->connective == NEF ) { - tmp = new_PlNode( NEF ); - tmp->neft = (*n)->neft; - tmp->lh = (*n)->lh; - tmp->rh = (*n)->rh; - (*n)->lh = NULL; - (*n)->rh = NULL; - (*n)->neft = -1; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - } - if ( (*n)->connective != ATOM ) { - return FALSE; - } - tmp = new_PlNode( ATOM ); - tmp->atom = (*n)->atom; - (*n)->atom = NULL; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - } - - for ( i = (*n)->sons; i; i = i->next ) { - if ( !is_eff_literal( i ) ) { - return FALSE; - } - } - - return TRUE; - -} - - diff --git a/models/main_models/rt1/gen/ff_planner/parse.h b/models/main_models/rt1/gen/ff_planner/parse.h deleted file mode 100644 index f9924c085..000000000 --- a/models/main_models/rt1/gen/ff_planner/parse.h +++ /dev/null @@ -1,63 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: parse.h - * Description: Functions for the pddl parser - * - * Author: Frank Rittinger 1998 / Joerg Hoffmann 1999 - * - *********************************************************************/ - - - - - -#ifndef _PARSE_H -#define _PARSE_H - - - -char *copy_Token( char *s ); -TokenList *copy_TokenList( TokenList *source ); -void strupcase( char *from ); -char *rmdash( char *s ); - - - -void build_orig_constant_list( void ); -void collect_type_names_in_pl( PlNode *n ); -int get_type( char *str ); -void make_either_ty( TypedList *tyl ); -void make_either_ty_in_pl( PlNode *n ); -void normalize_tyl_in_pl( PlNode **n ); - - - -Bool make_adl_domain( void ); -Bool make_conjunction_of_atoms( PlNode **n ); -Bool is_wff( PlNode *n ); -Bool make_effects( PlNode **n ); -Bool is_eff_literal( PlNode *n ); -Bool make_conjunction_of_literals( PlNode **n ); - - - -#endif /* PARSE */ diff --git a/models/main_models/rt1/gen/ff_planner/relax.c b/models/main_models/rt1/gen/ff_planner/relax.c deleted file mode 100644 index dd657ac60..000000000 --- a/models/main_models/rt1/gen/ff_planner/relax.c +++ /dev/null @@ -1,2756 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: relax.c - * Description: this file handles the relaxed planning problem, i.e., - * the code is responsible for the heuristic evaluation - * of states during search. - * - * --- THE HEART PEACE OF THE FF PLANNER ! --- - * - * here: linear tasks +=,-=,:= / le / le le - * - * - * Author: Joerg Hoffmann 2000--2002, 2011 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "relax.h" -#include "search.h" - - - - - - - -/* local globals - */ - - - - - - - - -/* fixpoint - */ -int *lF; -int lnum_F; -int *lE; -int lnum_E; - -int *lch_E; -int lnum_ch_E; - -int *l0P_E; -int lnum_0P_E; - - - - - -/* 1P extraction - */ -int **lgoals_at; -int *lnum_goals_at; - -float **lf_goals_c_at; -Comparator **lf_goals_comp_at; - -int lh; - -int *lch_F; -int lnum_ch_F; - -int *lused_O; -int lnum_used_O; - -int *lin_plan_E; -int lnum_in_plan_E; - - -/* helpful actions numerical helpers - */ -Comparator *lHcomp; -float *lHc; - - - - - - - - - - - - - - - - - - - - -/************************************* - * helper, for -1 == INFINITY method * - *************************************/ - - - - - - - - - - - - -Bool LESS( int a, int b ) - -{ - - if ( a == INFINITY ) { - return FALSE; - } - - if ( b == INFINITY ) { - return TRUE; - } - - return ( a < b ? TRUE : FALSE ); - -} - - - -Bool FLOAT_LE( float a, float b ) - -{ - - if ( b == INFINITY ) { - return TRUE; - } - - if ( a == INFINITY ) { - return FALSE; - } - - return ( a <= b ? TRUE : FALSE ); - -} - - - - - - - - - - - - - - -/*********************************** - * FUNCTIONS ACCESSED FROM OUTSIDE * - ***********************************/ - - - - - - - - - - - - - - - - - -int get_1P( State *S ) - -{ - - int max, h; - Bool solvable; - - gevaluated_states++; - - solvable = build_fixpoint( S, &max ); - - if ( gcmd_line.display_info == 126 ) { - print_fixpoint_result(); - } - - if ( solvable ) { - h = extract_1P( max ); - } else { - h = INFINITY; - } - - reset_fixpoint( max ); - - return h; - -} - - - -int get_1P_and_H( State *S ) - -{ - - int max, h; - Bool solvable; - - gevaluated_states++; - - solvable = build_fixpoint( S, &max ); - - if ( gcmd_line.display_info == 126 ) { - print_fixpoint_result(); - } - - if ( solvable ) { - h = extract_1P( max ); - collect_H_info(); - } else { - h = INFINITY; - } - - reset_fixpoint( max ); - - return h; - -} - - - -int get_1P_and_A( State *S ) - -{ - - int max, h; - Bool solvable; - - gevaluated_states++; - - solvable = build_fixpoint( S, &max ); - - if ( gcmd_line.display_info == 126 ) { - print_fixpoint_result(); - } - - if ( solvable ) { - h = extract_1P( max ); - } else { - h = INFINITY; - } - - collect_1P_and_A_info(); - reset_fixpoint( max ); - - return h; - -} - - - -void collect_1P_and_A_info( void ) - -{ - - static Bool first_call = TRUE; - - int i; - - if ( first_call ) { - gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); - gnum_A = 0; - first_call = FALSE; - } - - if ( gcmd_line.debug ) { - printf("\ncollect_1P_and_A_info"); - } - - for ( i = 0; i < gnum_A; i++ ) { - gop_conn[gA[i]].is_in_A = FALSE; - } - gnum_A = 0; - - for ( i = 0; i < lnum_E; i++ ) { - if ( gef_conn[lE[i]].level != 0 ) break; - if ( gcmd_line.debug ) { - printf("\ngot applicable op: "); - print_op_name(gef_conn[lE[i]].op); - } - if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { - if ( gcmd_line.debug ) { - printf(" -- already in, skipping it!"); - } - continue; - } - if ( gop_conn[gef_conn[lE[i]].op].axiom ) { - if ( gcmd_line.debug ) { - printf(" -- axiom, skipping it!"); - } - continue; - } - if ( gcmd_line.debug ) { - printf(" -- adding it!"); - } - gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; - gA[gnum_A++] = gef_conn[lE[i]].op; - } - -} - - - -void get_A( State *S ) - -{ - - int i; - - initialize_fixpoint( S ); - - for ( i = 0; i < lnum_F; i++ ) { - activate_ft( lF[i], 0 ); - } - for ( i = 0; i < lnum_0P_E; i++ ) { - if ( gef_conn[l0P_E[i]].in_E ) { - continue; - } - new_ef( l0P_E[i] ); - } - for ( i = 0; i < gnum_fl_conn; i++ ) { - activate_fl( i, 0 ); - } - - collect_A_info(); - - /* 0 should be enough here... - */ - reset_fixpoint( 1 ); - -} - - - -void collect_A_info( void ) - -{ - - static Bool first_call = TRUE; - - int i; - - if ( first_call ) { - gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); - gnum_A = 0; - first_call = FALSE; - } - - if ( gcmd_line.debug ) { - printf("\ncollect_A_info"); - } - - for ( i = 0; i < gnum_A; i++ ) { - gop_conn[gA[i]].is_in_A = FALSE; - } - gnum_A = 0; - - for ( i = 0; i < lnum_E; i++ ) { - /* levels are not set unless we actually build the RPG! -/* if ( gef_conn[lE[i]].level != 0 ) break; */ - if ( gcmd_line.debug ) { - printf("\ngot applicable op: "); - print_op_name(gef_conn[lE[i]].op); - } - if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { - if ( gcmd_line.debug ) { - printf(" -- already in, skipping it!"); - } - continue; - } - if ( gop_conn[gef_conn[lE[i]].op].axiom ) { - if ( gcmd_line.debug ) { - printf(" -- axiom, skipping it!"); - } - continue; - } - if ( gcmd_line.debug ) { - printf(" -- adding it!"); - } - gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; - gA[gnum_A++] = gef_conn[lE[i]].op; - } - -} - - - -void get_A_axioms( State *S ) - -{ - - int i; - - initialize_fixpoint( S ); - - for ( i = 0; i < lnum_F; i++ ) { - activate_ft( lF[i], 0 ); - } - for ( i = 0; i < lnum_0P_E; i++ ) { - if ( gef_conn[l0P_E[i]].in_E ) { - continue; - } - new_ef( l0P_E[i] ); - } - for ( i = 0; i < gnum_fl_conn; i++ ) { - activate_fl( i, 0 ); - } - - collect_A_axioms_info(); - - /* 0 should be enough here... - */ - reset_fixpoint( 1 ); - -} - - - -void collect_A_axioms_info( void ) - -{ - - static Bool first_call = TRUE; - - int i; - - if ( first_call ) { - gA_axioms = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); - gnum_A_axioms = 0; - first_call = FALSE; - } - - if ( gcmd_line.debug ) { - printf("\ncollect_A_axioms_info"); - } - - for ( i = 0; i < gnum_A_axioms; i++ ) { - gop_conn[gA_axioms[i]].is_in_A_axioms = FALSE; - } - gnum_A_axioms = 0; - - for ( i = 0; i < lnum_E; i++ ) { - /* levels are not set unless we actually build the RPG! -/* if ( gef_conn[lE[i]].level != 0 ) break; */ - if ( gcmd_line.debug ) { - printf("\ngot applicable op: "); - print_op_name(gef_conn[lE[i]].op); - } - if ( gop_conn[gef_conn[lE[i]].op].is_in_A_axioms ) { - if ( gcmd_line.debug ) { - printf(" -- already in, skipping it!"); - } - continue; - } - if ( !gop_conn[gef_conn[lE[i]].op].axiom ) { - if ( gcmd_line.debug ) { - printf(" -- no axiom, skipping it!"); - } - continue; - } - if ( gcmd_line.debug ) { - printf(" -- adding it!"); - } - - gop_conn[gef_conn[lE[i]].op].is_in_A_axioms = TRUE; - gA_axioms[gnum_A_axioms++] = gef_conn[lE[i]].op; - } - -} - - - - - - - - - - - - - - - - - - - - - - - - - - - -/******************************* - * RELAXED FIXPOINT ON A STATE * - *******************************/ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Bool build_fixpoint( State *S, int *max ) - -{ - - int start_ft, stop_ft, start_ef, stop_ef, i, time = 0; - float costlevel; - - initialize_fixpoint( S ); - - start_ft = 0; - start_ef = 0; - while ( TRUE ) { - if ( gcmd_line.debug ) { - printf("\n======================================FP time %d", time); - } - - if ( all_goals_activated( time ) ) { - break; - } - if ( time > 0 || lnum_0P_E == 0 ) { - if ( start_ft == lnum_F ) { - if ( fluents_hopeless( time ) ) { - /* fixpoint, goals not reached - */ - *max = time; - return FALSE; - } - } - } - /* make space if necessary, and copy over - * info from time to time+1 for fluents - */ - extend_fluent_levels( time ); - for ( i = 0; i < gnum_fl_conn; i++ ) { - if ( gfl_conn[i].def[time] ) { - gfl_conn[i].def[time+1] = TRUE; - gfl_conn[i].level[time+1] = gfl_conn[i].level[time]; - } - } - - /* determine the next effect layer: - * - activate the facts - * - if level 0 activate the no preconds-ops - * - activate the fluents at their ;UFhfQoG<2!dn0!_Zi=71_+$Qc diff --git a/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json deleted file mode 100644 index 3fd08680a..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json +++ /dev/null @@ -1,26 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "KeyChain", - "Television", - "Window", - "Bowl", - "GarbageCan", - "CreditCard", - "TVStand", - "Cabinet", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "ShelvingUnit", - "CoffeeTable", - "Shelf", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json deleted file mode 100644 index 6a7f82072..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "ArmChair|+02.34|+00.00|-02.04": [ - 1.5, - -2.0, - 90, - 30 - ], - "Cabinet|-01.83|+00.73|-02.36": [ - -0.75, - -1.75, - 270, - 30 - ], - "CoffeeTable|+00.02|00.00|-01.11": [ - 0.25, - -1.75, - 0, - 30 - ], - "GarbageCan|+00.74|00.00|-02.52": [ - 1.25, - -2.0, - 270, - 30 - ], - "Shelf|+00.34|+00.27|-02.38": [ - 1.0, - -1.25, - 270, - 30 - ], - "Shelf|+00.34|+00.47|-02.38": [ - 1.0, - -1.25, - 270, - 30 - ], - "Shelf|+00.34|+00.64|-02.38": [ - 1.0, - -1.0, - 180, - 0 - ], - "Shelf|-00.39|+00.30|-02.38": [ - -1.0, - -1.25, - 90, - 30 - ], - "Shelf|-00.39|+00.60|-02.38": [ - -1.0, - -1.0, - 180, - 0 - ], - "Shelf|-01.73|+00.28|-01.63": [ - -1.0, - -1.25, - 270, - 30 - ], - "Shelf|-01.73|+00.30|-00.48": [ - -0.5, - 0.25, - 180, - 30 - ], - "Shelf|-01.73|+00.45|-01.06": [ - -0.75, - -0.5, - 180, - 30 - ], - "Shelf|-01.73|+00.48|-01.63": [ - -0.25, - -1.75, - 270, - 0 - ], - "Shelf|-01.73|+00.60|-00.48": [ - -0.75, - 0.0, - 180, - 30 - ], - "Shelf|-01.73|+00.65|-01.63": [ - -0.5, - -1.75, - 270, - 0 - ], - "Shelf|-01.83|+01.45|-02.36": [ - -0.75, - -1.75, - 270, - -30 - ], - "Shelf|-01.83|+02.04|-02.36": [ - -0.75, - -1.75, - 270, - 0 - ], - "Sofa|+00.12|+00.01|+01.03": [ - -0.5, - 0.25, - 0, - 30 - ], - "TVStand|-00.03|00.00|-02.39": [ - 0.0, - -1.75, - 180, - 30 - ], - "TVStand|-01.73|00.00|-01.06": [ - -1.0, - -1.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy deleted file mode 100644 index a0929c7eba7ca9916298aef2062af25a96cebc6a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2352 zcmbW(txhvR6b9gh5JCtSv2G!$0Spk5R^cER1d24!20?(d1VgwAE~vM#mw-gBs6Zh2 z+4GDzlA6ggbI#0r*iU?KXBVgEmn+qC_0rr-=GU|4sBVs@2hE^vrVq2H+4%nIVRke5 z-9H)M%_l$m^V{*`4(XXGeek8vS(|K~2yiEQ~_TF;Q z-|Ibok9}^F`>v`g=W##F%OB~yOO{u?ylj;_ukzcMpWDdK@^c$`SbmnDyHvkSmS4Sm zR{6M%d@LW!$MUg!EFa6q^08H}yvk=^K9-N=WBFJ<_I`OM{+_I#^|StxEBaYK>u3FC z4)4dR-?@I)U*?WJ*3bG`f3D-a>M#3?eiHlcWp$ia?=Mqs*3bGmul{}6cfWn#o!iLI zz6-aJi_ORKv3x8C=T-ezyrZ7gv-)b(CsohtS^a9NXZ6ML_gGV(?7ngyx!HZi(Z8PV zWB0Ln*nP!u-$uHRyL9gRJNNy$P4!j$%K5P0VBep8e>M-Bhs{$Q?{B7g*gR|=HV>PJ h&BJZX!{%Z0u>TiqrF<+O%g6Gud@LW!$MS8Bz5%}cShoNG diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json deleted file mode 100644 index 96571469e..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "TVStand", - "Cabinet", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "ShelvingUnit", - "CoffeeTable", - "Shelf", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json deleted file mode 100644 index 3c460de3b..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "ArmChair|+00.40|+00.01|+02.19": [ - 0.5, - 1.5, - 0, - 30 - ], - "ArmChair|-00.63|+00.01|+02.19": [ - -0.75, - 1.5, - 0, - 30 - ], - "Cabinet|-01.77|+00.73|-01.59": [ - -1.0, - -1.25, - 270, - 30 - ], - "CoffeeTable|-00.15|+00.00|+00.42": [ - -0.75, - 0.5, - 90, - 30 - ], - "Shelf|+01.66|+00.27|+00.61": [ - 0.5, - 0.0, - 0, - 30 - ], - "Shelf|+01.66|+00.30|-00.12": [ - 0.5, - 0.5, - 180, - 30 - ], - "Shelf|+01.66|+00.44|+00.24": [ - 0.5, - 0.75, - 180, - 30 - ], - "Shelf|+01.66|+00.47|+00.61": [ - 0.5, - 0.0, - 0, - 30 - ], - "Shelf|+01.66|+00.60|-00.12": [ - 0.75, - -0.5, - 0, - 30 - ], - "Shelf|+01.66|+00.64|+00.61": [ - 0.75, - 0.25, - 0, - 30 - ], - "Shelf|-01.77|+01.45|-01.59": [ - -1.0, - -1.5, - 270, - 30 - ], - "Shelf|-01.77|+01.74|-01.59": [ - -0.75, - -1.5, - 270, - 30 - ], - "Shelf|-01.77|+02.04|-01.59": [ - -1.0, - -1.5, - 270, - 0 - ], - "SideTable|-01.57|00.00|+01.82": [ - -1.25, - 2.5, - 180, - 30 - ], - "Sofa|-01.45|+00.01|+00.42": [ - -0.75, - 0.5, - 270, - 30 - ], - "TVStand|+01.67|00.00|+00.24": [ - 1.0, - 0.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy deleted file mode 100644 index 70465ddc524364501d653330bac2ce093f8ef854..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3376 zcmbW&u}U0a6vgo`K}19(<_V^o1hx=uBm~wfUBo6us<6bB6hUP-qzQS7Jdi%ZJc6a= z6jN-mg=Y8r340(-rn&s@eD|DlXJ>c+oPGLu{`p1uS$?$_)A`p~`>tu)^&t3F@XO#5 zyu2-|>tDL`Rr;7drjO}kl}=WA`t&e8OmDyLrH|=hdYB%jw-#nRW`j|fUoG~4oRUUnLusqn_=ICSRa8~;I z^zr?8y(gw`jy`q{XQi*dsNY9?AKX>{=lj7A!F})$ya<+GF8MKEoK=4P;dcGJa3A~- zY+vWQxW85_#eMr?`(pdz#dtH1{p7YEex9p2^i}&|`(gWG`(gWG`LX<1ek`vX@?z(3 zR(bX1#qwf#usm2Ey7FLousNJn9({Q*f6U(;f6O2A$8>O3{`y^gFED@S_+$Q*t|QU!Oki>Um5b)4^GX znCGWI)aQ-6dLHw`{4hV9)%(Awy8JPJ%pdc|{4sybANxI6R{v$)7t4d?!RE{9`b{#A J&13WB^brgf0D%Ai diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json deleted file mode 100644 index 0bee20c25..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json +++ /dev/null @@ -1,26 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Television", - "GarbageCan", - "CreditCard", - "Ottoman", - "TVStand", - "Drawer", - "Painting", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "Shelf", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json deleted file mode 100644 index ef1237543..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "ArmChair|-00.56|+00.00|+01.95": [ - 0.25, - 1.5, - 270, - 30 - ], - "DiningTable|-03.10|+00.00|-03.61": [ - -2.25, - -3.5, - 270, - 30 - ], - "Drawer|+01.76|+00.77|+01.09": [ - 0.75, - 1.25, - 90, - 0 - ], - "GarbageCan|-01.34|+00.02|-04.83": [ - -2.0, - -4.5, - 90, - 30 - ], - "Ottoman|-00.58|+00.01|+01.05": [ - -1.25, - 1.75, - 180, - 30 - ], - "Shelf|-00.61|+00.88|-02.83": [ - -0.5, - -2.0, - 180, - 30 - ], - "Shelf|-00.61|+01.32|-02.83": [ - -0.5, - -2.0, - 180, - 30 - ], - "Shelf|-02.24|+00.27|+00.40": [ - -1.0, - -0.25, - 0, - 30 - ], - "Shelf|-02.24|+00.30|+01.13": [ - -1.0, - 0.5, - 0, - 30 - ], - "Shelf|-02.24|+00.44|+00.76": [ - -1.25, - 1.25, - 180, - 30 - ], - "Shelf|-02.24|+00.47|+00.40": [ - -0.75, - 0.5, - 270, - 0 - ], - "Shelf|-02.24|+00.60|+01.13": [ - -1.25, - 1.5, - 180, - 30 - ], - "Shelf|-02.24|+00.64|+00.40": [ - -1.25, - 0.75, - 180, - 30 - ], - "SideTable|+01.83|+00.00|+01.09": [ - 1.25, - 1.25, - 90, - 30 - ], - "Sofa|+00.88|+00.01|-00.59": [ - -0.25, - -0.5, - 90, - 30 - ], - "TVStand|-02.24|00.00|+00.76": [ - -1.5, - 1.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy deleted file mode 100644 index e0abd893f321db939292b31685e32617dbd38425..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4816 zcmbW)Juh=%7{KvEq>)C%`}@n;4oRn45VMU~3?@0z(-=hMR4n3C_(1hhIvNcIgF)5( zTdtAi;7M~PhZb3&n~VevZw61=v4iix;V~@lkQ>B%8PEVeyq#;>t5Zde(#@_ zcl~N~zkgdkR3q=Tj}BUSd%u;xPW1+NCL1b+>(@t2>sl^$P6 z*Uezh?{Ux1o}WEGdwyOHKi_@V`SAE$@NDo*a5H#1xDh-RJQuFpu98k2@#Ft9`j|Uu<7&Uu<982=myN$L)*l zi|vc;i|vc;%Q@_e?ThV;?ThV;?ThV;?ThV;?ThV;^<{loU)GoPWqny+)|d5VeOX_> z7y7cktS{@!`m(;PFYC+tvc9Y@>&yDGzN|0n%lfjutS{@!`m$c;)Qk0Ey;v{Si}hl? zSTBxOz1-J}^6oV!c=|*27$SupX=j>%n@k9_)EJUd`{m`PuwzejUxv=4bP> z`PuwzUiQ3fUN$eAm(6R>=4JD;dD*;dUN$eAm(9!OW%IIm{T`Z^&CBLx^Rju_ylh@J zFPoRm%jWfWVqP{co0rYY=4JD;dD*;dUN$d#ee!o~el|awpUuzaXY;f9+5BvNHb0x6 zy`TAa-p|x^=7?U&tdAVAM3~Z Rv3{%{n~%-M=40~>2S4)mgUSE^ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json deleted file mode 100644 index de861c186..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "WateringCan", - "Dresser", - "Drawer", - "Mirror", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "CoffeeTable", - "Shelf", - "Newspaper", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json deleted file mode 100644 index 79c456774..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "ArmChair|-04.33|+00.00|-03.53": [ - -4.0, - -4.25, - 0, - 30 - ], - "CoffeeTable|-02.47|+00.00|-02.49": [ - -1.75, - -2.5, - 270, - 30 - ], - "Drawer|-02.98|+00.17|-05.01": [ - -3.75, - -4.5, - 90, - 30 - ], - "Drawer|-04.02|+00.17|-05.01": [ - -3.25, - -4.5, - 270, - 30 - ], - "Dresser|-03.51|+00.00|-05.10": [ - -3.25, - -4.5, - 180, - 30 - ], - "GarbageCan|-00.97|-00.03|-05.06": [ - -1.5, - -4.75, - 90, - 30 - ], - "Shelf|-02.48|+00.12|-02.49": [ - -1.5, - -2.5, - 270, - 30 - ], - "SideTable|-02.02|+00.00|-05.08": [ - -2.5, - -4.5, - 90, - 30 - ], - "SideTable|-05.43|+00.00|-05.12": [ - -6.25, - -4.5, - 180, - 30 - ], - "Sofa|-04.36|+00.01|-02.09": [ - -3.5, - -2.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy deleted file mode 100644 index 762df682bbf580e2ff5a25f678c95c1078234285..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1584 zcmbW#u}Z^G6b9g{h)ACzTNJYBq#|^4Q(PRJq}Y@WVkHq5@hN;D`v`f2j*b}|92~6X zeu!r@LoeS+&-qW%zMNm4U0iLX$MjTA>-MH8kBjnTc34(LIa@Rj&E)QS(M;>_`sw7h zt=IK-KDn>g-aXo{ii5qXcrN~XjndE6y$26WT6c9uN&*Y|bad47gQyj!fA}-=n_&~jn;3IVG zn4v?54%TzeXYfCImhkCK?!CY7&|h!gy*Yk=Cw)&p7AKqC$L-=pw|IH_e6j2nr)S%5 z+x3?ZXWNs_-@m_Jf8K3w|GxXQ{<^vKlhw1;vRge}c0arSJd;$;!+!Yu{c8Ap5PT4P zKlpL=Mg9Fzu=~62{_OtjewX2X{HWfa4}(3=b^-93h%?-hrJJbAND>xt^IfsJPvMyN5T8L&;9IUd#=MCwukLud)OYfhwWi| z*dDfr?O}V^o|~|T?O}V^9=3<=VSCsfwukLud)OYfC*@SmQ9pdLJ!}u#!}hQ}Y!BPR zZFv4D*dE`vhwW){D#sqShwWi|*dF%(i~WD(dwnX0?*`96oV!c=|){FIGy;v{Si`#zK$$D`UuBYIe^M8MT9efq6 zzx(UY`nP$wul}q*>(BbL{;WUi&-%0etUv3|`m_G5Kezp`llA8&T-V=q{aJt3pY><` zS^se!-b;VhpY><`S%21_^=JKAf7YM%=V|T5`m_GrhVSd|dK0ee@4Ei1KkLu>v;M6A zB&TxpXZ=}!)}Qrf{aJt3pY><`c~<-IG+2Mv_2)KxUw_y2XZ=}!)}Qrf{aJt3f0|P{ z`m_G5KkLu>v;M3<>(BbL{yeMwSbx@^$Km^Ju>QWUKkLu>v;M3<>(BbL{<`S%21_^=JKAf1cF7tQYIWda+)t7wa_-y;v{Si}hl?_@KT&>&1GpUaS}E O#d@**Y(LvS&wl_7N|d$$ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json deleted file mode 100644 index bae18ef7d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "FloorLamp", - "Curtains", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "WateringCan", - "Ottoman", - "DeskLamp", - "Drawer", - "LightSwitch", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "Dresser", - "Chair", - "DogBed", - "Newspaper", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json deleted file mode 100644 index d38e8c23d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "ArmChair|-04.38|+00.01|+01.40": [ - -3.5, - 1.5, - 270, - 30 - ], - "Drawer|-00.36|+00.21|+03.80": [ - -1.5, - 3.25, - 0, - 30 - ], - "Drawer|-00.36|+00.21|+04.22": [ - -1.5, - 3.5, - 0, - 30 - ], - "Drawer|-00.36|+00.58|+03.79": [ - -1.25, - 3.25, - 0, - 30 - ], - "Drawer|-00.36|+00.59|+04.22": [ - -1.25, - 3.75, - 0, - 30 - ], - "Drawer|-02.29|+00.27|+04.11": [ - -1.75, - 3.5, - 0, - 30 - ], - "Drawer|-02.29|+00.75|+04.11": [ - -1.75, - 3.5, - 0, - 30 - ], - "Drawer|-02.83|+00.27|+04.11": [ - -2.25, - 3.25, - 270, - 30 - ], - "Drawer|-02.84|+00.75|+04.11": [ - -2.25, - 3.5, - 0, - 30 - ], - "Dresser|-00.27|+00.00|+04.01": [ - -0.75, - 4.0, - 90, - 30 - ], - "Dresser|-02.56|+00.01|+04.22": [ - -3.5, - 4.0, - 90, - 30 - ], - "Ottoman|-01.77|+00.00|+01.81": [ - -1.0, - 1.25, - 270, - 30 - ], - "SideTable|-00.25|+00.00|+02.10": [ - -0.75, - 3.0, - 90, - 30 - ], - "SideTable|-04.29|+00.01|+00.41": [ - -4.75, - 0.25, - 90, - 30 - ], - "SideTable|-06.72|+00.01|+00.00": [ - -6.25, - 0.5, - 180, - 30 - ], - "Sofa|-02.52|+00.01|+00.26": [ - -2.5, - 1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy deleted file mode 100644 index 2bf7794512207ebc0a5eccdf4735e852efdff612..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2240 zcmbW&F-ikL6b9fGL?n2K?N%X;u@MoH%1*Jdu##XBEW}76HsUEfP_8gXNSShrEmEW~ zy7L8mrD?`*XZF4S?PBtEb9a4vzgN5$AJu3)f1FhpWpz0@uexP5naiakGI$7Ps7*o*2kx3y>8h%>6V}6KR=z~_p@BI>n5)$xZN#^-G2Y?`DJjO?_cM2 z6|A3q{a8OvxjyU1tFT`OH^J-R{XyGNy@O!$G>i6}dDuK`9&Ya{3QoB{n}^NAbvSPx z`{vqxvn0o$Leuh)vLq* zEvv`samw?tx5G)@yqd$lJly1Zjr)S-u`dtH!}72^EDy`WzOUl6(8w)E#1Y%*tfUz;2!UN$EI07Xl#TFD4 z{_H#?eu<6SjL+=PygQhEzr4PEQ8pG98Y- z=g$WZv(eZ5?0)bx`trf?QMZ$y9Cq@z{GUfF`#JVMs&O^1#&&QkxEb6Ct_RnGv*2x7 z*ZP}aeaq0t`dA+~(t50q^|3zI$NIQTUA+Foi|}6TK8|CSj@^8(n&4&dI=Bqp1aE`0 z{_p44g6qMJ;AU_u*zcUB!~3)M;y5l+uX*p!t8iYg^Lkk?>*aReU)88zhkn-2?&dh^ zH?N=dvwqgk`dL5gx2}HH&-&SOIF9u3F}pY^kT*1ub4o_?3`f9$+|*3Y}=ru)qs z^|OA~&-z(E>tCn!>_6Lo*3XM{AM0o9a2(5Uzwd$Td=J?7fNTA#i0u#CAGSYif7t%8 M{n6=qc756V1VFa#_6Y@zY07o?RFp$EVfH!{Zl6t9y&p{a5>|y~XO)yQ2?B z2XCLhJ9>F|`u@X%H^+x3?;pQDcz<}3ckk}+?=9}$+FN{H{O7SVPLIvC_1WwA`E~nx z{e0e39yf|FX8tkfub$7F%41o)^3Z2qFa2C!AG~t<;rg1tS?gCGtKyw+o#*5B`Mjw- z?i8;)_KJ7r@B8$-oafKHsT_YepXT|(E5{$spLxFU%JGNuXMVT(S04PDuN>bv->%Ou zUOB#TzGc3@mG7D38|N3VJov>c$2ZQm>+_3Oj&GcA^ZeqK;~VGOJimD5>~EZJ^Zerc zj(OO>GsZ8@Ctf*zaemG7iB}$c;+5kU=hyZ5#4E=y&aZhs@yhXw^J|`8oZoK`w(l(0 z+t-=n7v~eN9KSff=J~`c$1l#Wc|P&VgHOD2{Nnt&KA(8y_;o&C-?#qaYvzB?*U9<9 z^)p{NeQ|xw>xWlPU+3%lqx#OAzPP@)et6~d#q~9>A6_|qov-iD>N|7#;`-wH;g!=D z*Vnv$c;)oPeV%@8`wsnQ-c(M1Tz~WW;+4}M*WbLpc;)oR_5WS{XHI`yU%Yaj2e{{f z?DOk-?hmh=`^DX_dH07`&i&%<_fOsL%(-9O{o$2!zqtD~?|Fw;&hroV{4>uNUOCS{ zoImq?;g$1y3Fpte?-SYY`LQ0S$ENb&7q2{)>(jB5V}15FzGu$o1Lqs(7q6V(OE}-= z`Nb>$`#zuj_%_e4`O4X^IN#>^#VcpOI)Ab4F)q$NmE#-dd*=AYm+NtMT%51`&b+Cd z{f+Z&o?pCj_BYPAd4BQA+21(d=J~}dXMf{-o43DlelM-Z*}><``F|B(&hzlf+0Qt? z=C9X$(zublmi^J|_@ymIz4&aZhs@yglHINvhgm!}85XO3^#`p&l=UODUI z);I6>v26V-+df%ew*Ji7U%2&g>*1C2|0b@Ftk2HuWBr-4K5l*7dU)lmk6V9d{TFzm B*Y5xT diff --git a/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json deleted file mode 100644 index 56f6f2380..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "Book", - "Drawer", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "Shelf", - "Dresser", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json deleted file mode 100644 index d5835af4b..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json +++ /dev/null @@ -1,146 +0,0 @@ -{ - "ArmChair|+08.22|+00.01|-00.08": [ - 8.75, - -0.25, - 270, - 30 - ], - "ArmChair|+08.23|+00.01|+00.77": [ - 8.75, - 1.5, - 180, - 30 - ], - "ArmChair|+09.50|+00.00|+03.27": [ - 9.25, - 2.5, - 0, - 30 - ], - "CoffeeTable|+10.82|-00.01|+00.93": [ - 11.25, - 0.25, - 0, - 30 - ], - "Drawer|+14.18|+00.17|+00.56": [ - 13.0, - 0.0, - 0, - 30 - ], - "Drawer|+14.18|+00.17|+01.07": [ - 13.0, - 0.5, - 0, - 30 - ], - "Drawer|+14.18|+00.17|+01.58": [ - 13.0, - 1.0, - 0, - 30 - ], - "Drawer|+14.18|+00.17|+02.10": [ - 13.0, - 1.5, - 0, - 30 - ], - "Drawer|+14.18|+00.37|+00.56": [ - 13.25, - 0.0, - 0, - 30 - ], - "Drawer|+14.18|+00.37|+01.07": [ - 13.25, - 0.5, - 0, - 30 - ], - "Drawer|+14.18|+00.37|+01.58": [ - 13.25, - 1.0, - 0, - 30 - ], - "Drawer|+14.18|+00.37|+02.10": [ - 13.0, - 2.75, - 180, - 30 - ], - "Drawer|+14.18|+00.58|+00.56": [ - 13.25, - 0.0, - 0, - 30 - ], - "Drawer|+14.18|+00.58|+01.07": [ - 13.25, - 0.5, - 0, - 30 - ], - "Drawer|+14.18|+00.58|+01.58": [ - 13.25, - 1.0, - 0, - 30 - ], - "Drawer|+14.18|+00.58|+02.10": [ - 13.25, - 1.5, - 0, - 30 - ], - "Dresser|+14.33|+00.00|+01.32": [ - 13.5, - 1.25, - 90, - 30 - ], - "Shelf|+10.79|+00.23|+00.93": [ - 10.5, - 1.75, - 180, - 30 - ], - "SideTable|+11.38|+00.00|-01.16": [ - 10.75, - -0.5, - 90, - 30 - ], - "SideTable|+12.31|+00.00|-01.15": [ - 12.75, - -0.5, - 180, - 30 - ], - "SideTable|+14.33|+00.00|+00.07": [ - 13.5, - -0.5, - 0, - 30 - ], - "SideTable|+14.33|+00.00|+02.59": [ - 13.75, - 2.75, - 90, - 30 - ], - "SideTable|+14.62|00.00|-00.78": [ - 14.0, - -0.25, - 180, - 30 - ], - "Sofa|+11.45|+00.00|+03.21": [ - 11.5, - 2.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy deleted file mode 100644 index 7de05a61f39ff149a9a2e2eac6cf891cf5255895..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3024 zcmbW$y>1gh6b8^?WsM@sitO;8%AG-S6RHRyWhy!l4Fwglh$9L_kb`ItPr(B*k3vaF zLE$0=VP{TrOQu;J@7=xMm)PH5zJBrQ&8_q$eO;YzuiouePnWA_7pJTBa&>XJ`@GwH ze0#Y&-~Rjj`R2pb_U7}e_nS}K8$UWZJy|cGJYFxqE&uaO(|BgJUH510It@Mu&cT!5 zAvgtJ|48GpZy)?8_;>KH;GecjeQu5FGd!TPwb59`DG-iP&JeOMpXhxHjs%c&3R!?~vM45eKswOxnOueD#h^%=VL zVSQL1)`#_B`6nffM}C%{b8T}hKl^`h3iI;2FF(uA^0U0Tv>fuXyqx=fmY0WcKLyKc zUS5`$v^aB{hnvfv-w$=XY*|SFwC=gHa`#ZY@W?8!aSR2 z^G9Kx&GS)BzE1 zSzeZxy*?y_G9^2K9-N=WBJ(MZ?-4r zO`C)DVSQNsT-w*k&+@bUEI-T7^0WNx^ND>vvCk*gm-D90&7I(b;1p~hueT4|r(06< z*oW=I_F?<5eb_#1AGQzoYksy5+lO=be)~AL58H?B!}ei&^h#%;o+pyp?NSRa;`O9G zLtd7b&q`{ZX}yp2XZ?8;zF&Xm`m_G5KkLsqyubd=^=JKAf7YM+R#*K5QSh58H?B!#Uh%ALsUA`>=i3K5QSh&%=_M$3AQyp45D7AGQzM zhwa1mVf(OsIEVY~-MAGQzMhxLC{QuFA~`m_G5KkLu>v;M3<>(6=9=3@O>f7YM% zXZ_iq57z&2Y46pa^=JKAf7YM%XZ=}!&YLy|>(BbL{;WUi&-$~zPfB~QzN|0n%kE?M fvHRH1r`XS@Sf1mMhvi}SvHRG4>^}DM#pCi9x@2HO diff --git a/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json deleted file mode 100644 index 60b621433..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Statue", - "Box", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "Bowl", - "GarbageCan", - "CreditCard", - "WateringCan", - "DeskLamp", - "Mirror", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ShelvingUnit", - "CoffeeTable", - "Shelf", - "Newspaper", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json deleted file mode 100644 index 69e837fe8..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "CoffeeTable|-02.49|+00.02|+04.04": [ - -3.25, - 4.0, - 90, - 30 - ], - "CoffeeTable|-05.56|+00.02|+06.83": [ - -5.25, - 6.0, - 0, - 30 - ], - "Shelf|-00.59|+00.25|+02.00": [ - -1.75, - 2.5, - 90, - 30 - ], - "Shelf|-00.59|+00.25|+05.98": [ - -1.5, - 5.75, - 90, - 30 - ], - "Shelf|-02.85|+00.47|+07.17": [ - -2.75, - 6.5, - 0, - 30 - ], - "Shelf|-02.85|+00.90|+07.17": [ - -2.75, - 6.25, - 0, - 0 - ], - "Shelf|-02.86|+00.16|+07.17": [ - -4.5, - 6.25, - 90, - 30 - ], - "Shelf|-02.87|+01.29|+07.17": [ - -3.0, - 6.5, - 0, - 0 - ], - "Shelf|-05.95|+00.16|+04.34": [ - -5.25, - 4.5, - 270, - 30 - ], - "Shelf|-05.95|+00.47|+04.34": [ - -5.25, - 4.25, - 270, - 30 - ], - "Shelf|-05.95|+00.90|+04.34": [ - -5.0, - 4.25, - 270, - 0 - ], - "Shelf|-05.95|+01.29|+04.35": [ - -5.25, - 4.75, - 270, - 0 - ], - "SideTable|-00.59|+00.01|+02.00": [ - -1.25, - 2.25, - 90, - 30 - ], - "SideTable|-00.59|+00.01|+05.98": [ - -1.25, - 6.25, - 90, - 30 - ], - "Sofa|-00.77|+00.02|+03.92": [ - -1.5, - 3.75, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy deleted file mode 100644 index c199eae736d2c19c6344eab8dd577dcd539bc5ce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2560 zcmbW&F-j{@6oBDTBuEg^9ZWY0X%qwz!Ol*xv9OY05-da|5gTz8E+{S`OGue=iYZc9 z7?bm*IHl7J-yPn$bAN}Iuj|{Zo4bwTz4)kl{n5j)IxDO5!D-bgtHI0gZPoF_7^@lIyvr?$A_Krv;61PE|ypOdv$Ncowt%VlZ)h^ak0F1V|^ap zNjBf}?ex5ryccfLd^VrWXY<*7-jDfp%(ovq58IFJ$M$3UvHfQ0JZwIj&*roFJijQG z7u#%!if^L-NMu)aENQScuH{T z-a|jukM(2ySU=W}^<(|G9$%y;v{Si}hl??9=*QJz>3AFV>6oV!gPDKCBn(#d@(` z>>Ql$dRf&1GpUaS}E#m>d~u9x*XI~`74!b*ZBScpm@HsVw41DVIMwAdm= zigoYI*Zk$)CVZKA?l~d&`{(74Usng|CB4?S%gxQYKC9~U)oDGe>eb`=dA)eJeq7%! z|Gj^)xZf6QRr8}+^;Z4o8K!a$x9#ihd;2;L9t97B2f;bGAKVL0 z!Ta}Ajy}8KKf(I%Lx0wv^=JJ#cYRoY)}Qrf{dw2*W&K(I)RfuD_s{yX{_H+>AG?p; z*9-Tt``CRfpXIasev`_vhvl<;me2B8eh&F8pXIZBme2ABA)n>5e3sAhS^hBO^JtsO zVfpO$$~k<#AKVL0!G1sT^k@B9|52058FzWCKkLtf@cA69zt8K>`m_G5KkLu>kDFAE z{;WUi&x5Wn=V1Lk*Pr!g{aJt3pQqh@hfOMH5^SI6_OX3D41aH*=Q%vL&vX0OKDLkT zWBXYDNt4RapY><`S%1#kHiz|R{aJt3pY><``Lp|f&-P54wue1z58K1`aNf2#Y!BPR S_OLx{58K1`@JF|A+WZAD>Eo>c diff --git a/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json deleted file mode 100644 index fab11eadd..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "FloorLamp", - "Curtains", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "WateringCan", - "Cabinet", - "DeskLamp", - "Drawer", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "Dresser", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json deleted file mode 100644 index ba058be94..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "ArmChair|-00.30|+00.00|+01.71": [ - -1.25, - 1.75, - 90, - 30 - ], - "ArmChair|-00.30|+00.00|+03.31": [ - -1.25, - 3.25, - 90, - 30 - ], - "Cabinet|-04.41|+00.50|+01.57": [ - -4.0, - 2.25, - 270, - 30 - ], - "Cabinet|-04.41|+00.50|+02.59": [ - -3.75, - 1.75, - 0, - 30 - ], - "Cabinet|-04.41|+00.50|+02.60": [ - -3.75, - 2.25, - 0, - 30 - ], - "Cabinet|-04.41|+00.50|+03.62": [ - -4.0, - 3.0, - 270, - 30 - ], - "CoffeeTable|-02.41|00.00|+02.55": [ - -2.5, - 3.25, - 180, - 30 - ], - "Drawer|-04.50|+00.90|+01.82": [ - -4.0, - 2.25, - 180, - 30 - ], - "Drawer|-04.50|+00.90|+02.34": [ - -4.0, - 2.75, - 180, - 30 - ], - "Drawer|-04.50|+00.90|+02.85": [ - -4.0, - 3.25, - 180, - 30 - ], - "Drawer|-04.50|+00.90|+03.37": [ - -4.0, - 3.75, - 180, - 30 - ], - "Dresser|-04.74|+00.00|+02.60": [ - -4.0, - 2.75, - 270, - 30 - ], - "GarbageCan|-04.81|-00.03|+01.24": [ - -4.0, - 1.5, - 270, - 30 - ], - "SideTable|-00.04|+00.00|+04.62": [ - -0.75, - 4.5, - 90, - 30 - ], - "Sofa|-02.46|00.00|+00.70": [ - -2.25, - 1.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy deleted file mode 100644 index 43b4a4f9f53a2bfebe3ca8a381ed7d817cddc05e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6400 zcmbW)y-rkJ6oBC^At!{8$?*SUGu>!Hg^d~$c4eorv9K~khFBOegRwDQg%`xR1TKM+ za*8P^rVv^CF=3TXLmtk|IeWbe{P=#qegEd&hezc{`8htFTzs02UyjDF&Yq7CN8_{e z>G$c$*N^AZ)5+iOzdreLF}eHx#pjc6lRH0o_TuPpboBIa^lS8=uhnw@TJGcP&2fBP zN-oKZ%ZKm3O`a#ul5dhde|G%v`Rw`Z`Rw^TZ}(@6oV!c=|){FIG zy;v{Si}m6`ALr(^Wc^&%kM(2ySU--ZmBRWBYFyEe^<({557vYAU_Dq5)`Run)z*jg zU_Dq5)`Rt6zmKfXF!f>cvU%COY+g1mo0nJHyu6ZZUf0db=4JD;`PS2XY(6$0n~%-M z=411*`Ph7HzieJMFPoRm%jVrk^Rju_ylh@JFPoRm%jRYCa@WU++3!E=!FsSBtOv*4 zOJO}WYh3aB&*o?Iv-#QlY<@OBo1eQr&cVyc{@!){w*B{o^6o;y6ty?B560 zZ>z>T^Tay;*P8n@fAK-t6yd z)_=Rk2lZ#YS#KWp@j2F;^=7?UZ|>6l^mbiu)|>Tay;*P8oAqYBS#OT%OJTiPZ`OOK z#wYb=KkuwRueUy|KkLu>v;M3<`S%21_^=JKAe~xOUu->dU>%CXwlX|ni zk9n)j&zs5i;ktdWeXxD7eXxD7eQ=kaZy&DP2iphR2iphR2iphR2iwO#AD8%Cv& z`+Bq9?Ego2w~x>9PV#oLeR;oqv3;?9v3;?9v3;?9v3+ru&Szh)+ZWpx+ZWpx+ZWpx z+ZWr%K`r+$`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`{1r`bJzH4AFkU6+XveR M+XveR+s8ru13&Ct_5c6? diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json deleted file mode 100644 index b52cc7c18..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "FloorLamp", - "Curtains", - "Plate", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "WateringCan", - "CellPhone", - "Dresser", - "DeskLamp", - "Drawer", - "Painting", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "CoffeeTable", - "Newspaper", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json deleted file mode 100644 index eec0c2905..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "CoffeeTable|-01.55|+00.00|+02.53": [ - -1.0, - 3.25, - 180, - 30 - ], - "DiningTable|-05.64|00.00|+04.91": [ - -6.5, - 5.0, - 90, - 30 - ], - "Drawer|+00.75|+00.23|+03.33": [ - -0.25, - 4.0, - 180, - 30 - ], - "Drawer|+00.75|+00.23|+04.10": [ - 0.25, - 3.75, - 90, - 30 - ], - "Drawer|+00.75|+00.67|+03.33": [ - 0.0, - 2.75, - 0, - 30 - ], - "Drawer|+00.75|+00.67|+04.10": [ - 0.0, - 3.5, - 0, - 30 - ], - "Dresser|+00.85|+00.00|+03.71": [ - 0.5, - 5.0, - 180, - 30 - ], - "GarbageCan|-07.10|-00.04|+02.30": [ - -6.5, - 3.0, - 270, - 30 - ], - "SideTable|+00.73|+00.01|+06.64": [ - 0.5, - 6.0, - 0, - 30 - ], - "SideTable|-03.41|+00.01|+01.66": [ - -2.75, - 1.5, - 270, - 30 - ], - "Sofa|-02.47|+00.00|+03.28": [ - -1.25, - 3.5, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy deleted file mode 100644 index 53a9e420d63206ac302712d7b74c3076e32f2be3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3552 zcmbW$KZ_GV7{K9i2}1}W_`lw671DTEhzK{8onm8QCBe&KA)X{+BYp}$ko$42OmRhu z6rMZtG;irN!;={{`~FCNzkUDa-G@8rNBTKjZ10rkAfctKM1}bd@tC%o^M_@FPoRm%Q-yXyw1(b=H=6$G%Y>`-vl3m^}0E) z&(VwZV!c=|){FIGy;v{Si}m6>*7sz+STEL#^yRcG4x~oSU=W}^<({5 zKh}@+WBph^){pgL{rJ@8XZ=`@Q|Q5ZupX=j>%n@k9;^rJ!FsSBtOx7CdaxdRY<*ad zRO;{6|BLltJy;LcgY{rNSP#~N^BF32kXIlupX=j>%n@k z9;^rJ!Ff#6>Pp>bW8J&b_Ob2FdUVZtupX?(tligx^-} z9_;tQDcsk?xgM-XF7AU z^)~7v)`Rt6Jy?%rNz>AU^1uW^td* gq-mL-&Clj%^RxNc{A_++wE1`*Y#!(4Ve_oYUmmn*5&!@I diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json deleted file mode 100644 index 770f701c6..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "GarbageCan", - "CreditCard", - "Newspaper", - "CellPhone", - "Cabinet", - "Dresser", - "DeskLamp", - "Drawer", - "Painting", - "Floor", - "HousePlant", - "Safe", - "Laptop", - "Vase", - "ArmChair", - "ShelvingUnit", - "TissueBox", - "Shelf", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json deleted file mode 100644 index 6daba59dd..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json +++ /dev/null @@ -1,158 +0,0 @@ -{ - "ArmChair|-02.03|+00.00|+04.42": [ - -2.0, - 3.75, - 0, - 30 - ], - "Cabinet|-02.88|+00.56|+04.21": [ - -3.5, - 3.75, - 0, - 30 - ], - "Cabinet|-04.03|+00.56|+04.21": [ - -3.75, - 3.75, - 0, - 30 - ], - "Cabinet|-04.05|+00.56|+04.21": [ - -3.75, - 3.5, - 270, - 30 - ], - "Cabinet|-05.20|+00.56|+04.21": [ - -5.5, - 3.5, - 90, - 30 - ], - "Drawer|-03.17|+01.01|+04.31": [ - -3.5, - 3.75, - 90, - 30 - ], - "Drawer|-03.75|+01.01|+04.31": [ - -3.25, - 3.75, - 270, - 30 - ], - "Drawer|-04.33|+01.01|+04.31": [ - -4.75, - 3.75, - 90, - 30 - ], - "Drawer|-04.92|+01.01|+04.31": [ - -4.5, - 3.75, - 270, - 30 - ], - "Drawer|-05.02|+00.90|+00.37": [ - -4.25, - 1.0, - 270, - 30 - ], - "Dresser|-04.04|00.00|+04.59": [ - -3.5, - 3.75, - 0, - 0 - ], - "Safe|-02.30|+00.00|+00.27": [ - -1.5, - 1.0, - 180, - 30 - ], - "Shelf|-00.25|+00.78|+01.06": [ - -0.75, - 1.25, - 90, - 30 - ], - "Shelf|-00.28|+00.27|+01.07": [ - -1.0, - 1.25, - 90, - 30 - ], - "Shelf|-00.28|+01.29|+01.05": [ - -1.0, - 1.0, - 90, - 0 - ], - "Shelf|-00.28|+01.81|+01.06": [ - -0.75, - 1.25, - 90, - 0 - ], - "Shelf|-01.22|+00.27|+00.26": [ - -1.5, - 1.0, - 180, - 30 - ], - "Shelf|-01.22|+00.78|+00.24": [ - -1.75, - 1.0, - 90, - 30 - ], - "Shelf|-01.22|+01.29|+00.27": [ - -1.75, - 1.0, - 180, - 30 - ], - "Shelf|-01.22|+01.81|+00.28": [ - -1.25, - 1.0, - 180, - 30 - ], - "Shelf|-05.24|+01.39|+00.09": [ - -4.75, - 1.0, - 180, - -30 - ], - "Shelf|-05.24|+01.58|+00.07": [ - -4.25, - 1.0, - 180, - 30 - ], - "Shelf|-05.24|+01.78|+00.07": [ - -4.25, - 1.0, - 180, - 30 - ], - "Shelf|-05.24|+01.97|+00.09": [ - -4.25, - 1.0, - 180, - 0 - ], - "SideTable|-05.02|+00.01|+00.27": [ - -5.0, - 1.0, - 180, - 30 - ], - "Sofa|-00.71|00.00|+02.75": [ - -1.5, - 2.75, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy deleted file mode 100644 index a2bddb6722cdbd16b4e4fb99ca0a8f3b62b32dbc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2256 zcmbW$u};EJ6oBEYVe%=uRTCCvF~&qDH;s#flOa;#V8noNF+PP4B#+QXU}Wsjfq_A^ z=Ogisc4@x0_WT^=^ZNGc=58;&rT21N%^zmvSy7%(PRo8#PNuWh+35LxIvZC%*Dps; z^J;s2{y2K6wmv)_4En{%QNQ>o{&^gv?pSoE&TvSUoY3u$9h?>zthWlSuZ!y!FpLQ@8-IYo%On` zm-Tv1FYD#jo?;Jr-Pg-{SugA0{H#Z}9&V$D^{^h+!+KZ`>tQ{s`22cU59?t)tcUfm z9yY(p=Ck>1KAX?xv-xaZo6X}k_Rmdb^V~O&{r|1w{pPX#vUzMCo5$wy{-WFHCgz#X zo9Jir*?cyi&1dsj2lt{U4ZALVtdI5aI(k_j>tlVakM(gc`u4Lv*2nr-AM0a%tdI3^ z9iNv|99+lu%6_-(cf?Khe4E)mJZ~SpVfsCMUu++2A8a3NA8a3NA8a3NAKX=?#P-4V P!S=!S!S=!S(HnjPXOlrz diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json deleted file mode 100644 index 51552ba88..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - "StoveBurner", - "Stool", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "CreditCard", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json deleted file mode 100644 index 445026e53..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json +++ /dev/null @@ -1,176 +0,0 @@ -{ - "Cabinet|+00.17|+02.01|-01.20": [ - -0.5, - -0.5, - 180, - 0 - ], - "Cabinet|+00.24|+02.01|-01.20": [ - 0.0, - -0.5, - 180, - 0 - ], - "Cabinet|+00.48|+00.39|-00.90": [ - -0.25, - -0.25, - 90, - 30 - ], - "Cabinet|+01.12|+02.01|-01.20": [ - 0.5, - -0.5, - 180, - 0 - ], - "Cabinet|+01.13|+00.47|-00.90": [ - 0.25, - -0.25, - 90, - 30 - ], - "Cabinet|-00.77|+02.01|-01.20": [ - -1.0, - -0.5, - 180, - 0 - ], - "Cabinet|-00.82|+00.47|-00.91": [ - -1.75, - 0.0, - 90, - 30 - ], - "Cabinet|-00.84|+02.01|-01.20": [ - -1.5, - -0.5, - 180, - 0 - ], - "Cabinet|-01.77|+02.01|-01.20": [ - -2.0, - -0.5, - 180, - 0 - ], - "Cabinet|-01.80|+00.47|-00.91": [ - -2.0, - -0.25, - 90, - 30 - ], - "Cabinet|-01.84|+02.01|-01.20": [ - -1.75, - -0.5, - 180, - 0 - ], - "Cabinet|-01.85|+00.39|-00.90": [ - -2.0, - -0.25, - 180, - 30 - ], - "Cabinet|-02.39|+00.39|+00.38": [ - -1.5, - -0.5, - 0, - 30 - ], - "Cabinet|-02.63|+02.01|-01.20": [ - -2.0, - -0.5, - 180, - -30 - ], - "Cabinet|-02.65|+02.01|+00.36": [ - -2.0, - -0.25, - 270, - 0 - ], - "Cabinet|-02.65|+02.01|-00.95": [ - -1.75, - 0.0, - 180, - 0 - ], - "Cabinet|-02.65|+02.08|-00.23": [ - -2.0, - 0.0, - 270, - 0 - ], - "Cabinet|-02.65|+02.08|-00.88": [ - -2.0, - -0.25, - 270, - 0 - ], - "Cabinet|-02.65|+02.20|+00.43": [ - -1.25, - 1.0, - 270, - 0 - ], - "Cabinet|-02.65|+02.20|+01.67": [ - -2.25, - 1.75, - 270, - -30 - ], - "CounterTop|+00.07|+00.95|-01.20": [ - 0.25, - -0.5, - 180, - 30 - ], - "CounterTop|+00.91|+01.15|+00.79": [ - 0.25, - 0.5, - 0, - 30 - ], - "CounterTop|-02.70|+00.95|+00.11": [ - -2.0, - -0.25, - 270, - 30 - ], - "Drawer|+00.26|+00.78|-01.08": [ - -0.25, - 0.0, - 180, - 0 - ], - "Drawer|-02.03|+00.78|-01.08": [ - -1.5, - 0.0, - 180, - 0 - ], - "Drawer|-02.57|+00.78|+00.10": [ - -1.75, - -0.5, - 0, - 30 - ], - "Fridge|-02.86|+00.00|+00.85": [ - -1.75, - 0.75, - 270, - 30 - ], - "Microwave|+00.28|+00.90|-01.33": [ - 0.0, - -0.5, - 180, - 0 - ], - "Sink|-01.33|+00.92|-01.23|SinkBasin": [ - -0.75, - -0.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy deleted file mode 100644 index cbfb298e970e68e3e6c6e2d1c50d344d6d943b48..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3712 zcmbW&KWkG_9LM3~C0t4frS(teyIqA$p@WFvncS2v9h@ZC6bG@Ah>Q3td_mrq(3jA$ zV}=YFGFb09&+;41V0e0y)ARkH`1}3kyNeHx(vS4BzglfRt@~G9|N8o6KkxeMoAvkg z^6ST&_0{U%&)+V;Y*r6H-+W$vTRr&sVsSq27BA-AukJrz(=@(zf6Du9ecuM(2cHe) z^ZtAi>^#q%$IfHt-M%S5c{Y@Hej4oedHy&&KMi&tpLZX2A9kO+a36Lbb{}>hb{}>h zb{}>hcAxujA9f#hA9f#hA3mwQ_&9hLe5ijPe10EnpXc_meQe)0>|^`bKDLkTWBb@X zwvX*&`*>IPvVCkH+qVn**gm$8?PL4cKDLkTWBb@XwvV@UFWbj=;kmv0u$S#+d)Z#L zm+fVH*`?0-jFWbxZvb}8YA?#&)*&beu zo~$S9+2nFhJy}oIll5dhSx?rJ^<+I+Pi}`azM5R#CqsE}a(y4_d$pcTwVtde>&beu zo~$S9Imu~!>B)Mso~$S9$$GM$tS9TqdU89Id$OMF?&beuo~$S9$$GM$tS7g%59`TIc%Fjw^m#p5Pu7$5Wc`kE8ejUceykts$NI5; ztRK(nKGu)*<2HO=KhK-+TtCnCWBph^){pg?=2Tww_p$TY`RsglK0ALF&S&Sd^V#|A Te0KhEJ>U1)_u2Q^_fPU)3+t?9 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json deleted file mode 100644 index 4ade16795..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "FloorLamp", - "Candle", - "Pillow", - "Box", - "Boots", - "Sofa", - "Statue", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "TVStand", - "Drawer", - "Painting", - "RoomDecor", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "TissueBox", - "Dresser", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json deleted file mode 100644 index 39f0b25e7..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "ArmChair|-02.06|+00.01|+04.22": [ - -1.75, - 3.5, - 0, - 30 - ], - "CoffeeTable|-02.65|+00.01|+01.15": [ - -2.75, - 1.75, - 180, - 30 - ], - "DiningTable|+00.17|+00.67|+01.98": [ - -1.0, - 2.0, - 90, - 0 - ], - "DiningTable|+00.17|+00.86|+01.98": [ - -0.75, - 2.0, - 90, - 0 - ], - "Drawer|-00.31|+00.18|+03.61": [ - -1.5, - 2.75, - 0, - 30 - ], - "Drawer|-00.31|+00.47|+03.61": [ - -1.75, - 3.5, - 90, - 0 - ], - "Drawer|-00.31|+00.76|+03.61": [ - -1.5, - 3.5, - 90, - 0 - ], - "Drawer|-00.31|+01.05|+03.61": [ - -1.25, - 3.5, - 90, - 0 - ], - "Drawer|-00.36|+00.22|+00.52": [ - -1.0, - 0.0, - 90, - 30 - ], - "Drawer|-00.36|+00.58|+00.52": [ - -1.0, - 0.0, - 90, - 30 - ], - "Dresser|-00.27|+00.00|+03.61": [ - -0.75, - 2.75, - 0, - 30 - ], - "SideTable|-00.28|+00.01|+00.52": [ - -0.75, - 0.75, - 90, - 30 - ], - "Sofa|-02.68|+00.01|-00.12": [ - -1.75, - 0.75, - 180, - 30 - ], - "Sofa|-03.79|+00.02|+03.89": [ - -3.75, - 3.0, - 0, - 30 - ], - "TVStand|+00.17|+00.59|+01.98": [ - -0.5, - 2.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy deleted file mode 100644 index 1998dfe53466034f9930433a8609e39fc508e2a2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1904 zcmbW$u}Z^07zglEBuEjTAzKu>)Ja6>=BBtfI7zW74q_z{7x5{4AoB=)gpM6MbZ~I6 zn)@x^XqM~ma(CbVYm$$vo6GClo%EXCs%hQcH`Q5LozG6IVOh=Q%}Xp!FaLQB(%-e;^<$C8!#wWg@gR5*Y`^tIxNqLL8}6%T zUOiTi)noNI)-i8Pxjw6BUOjd`JD;7yas2*F{gvx}1#g1a!K>h9@FF-@OLE8;b8sBx zGcO;@$MUg!EFa6q@~JB~TgP#f&%AsrAIrz`v3x9_I`Xl6>^!z#F8kSfwq9=Qx#;?Y z`tUxo{cJz`-qiK}v-h8UZ>&D6&+4=K?EhkU`mR!vhvi{;xaj=qM|sT3!}72^?76e& z$ZOwQp731U_dm1#7UO&9~WJ}kM+m;WBsxISbx09{jmO6f2=>&-!k;a`eXgE T{#bwP{8c!gozKo^=dZ>;E<^}{ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json deleted file mode 100644 index 0c292118a..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "FloorLamp", - "Stool", - "Curtains", - "Plate", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Drawer", - "Painting", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "CoffeeTable", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json deleted file mode 100644 index 616f56233..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "ArmChair|+00.66|+00.10|-01.78": [ - 0.0, - -1.5, - 90, - 30 - ], - "CoffeeTable|-01.05|+00.10|-02.47": [ - -0.5, - -1.75, - 180, - 30 - ], - "CoffeeTable|-01.09|+00.10|-00.74": [ - -0.5, - 0.0, - 180, - 30 - ], - "DiningTable|-03.43|+00.10|-01.19": [ - -2.25, - -1.5, - 270, - 30 - ], - "Drawer|-00.03|+00.87|-02.49": [ - -0.5, - -1.5, - 180, - 0 - ], - "SideTable|-00.03|+00.10|-02.55": [ - -0.25, - -2.0, - 180, - 30 - ], - "Sofa|-00.91|+00.10|+00.96": [ - -1.5, - 0.25, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy deleted file mode 100644 index b2a8cc9718e5f2cf19ef4807f70182005f8015d7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1648 zcmbW$Ax;B96b9e{$tl(?Bvm9NKuB7JgJ2LS($FOcLdlk32&dpcy}}-$vU0_WiV6xd zpWsQ>ynM4e^Z(tpU)Q%+H+OsKJ$=-(X7SM0=T&|2cv_FD`f=XAwbPgTc{^)<)-R{e zi)OdJc$&U8J0G5%jH=_KQT18<_c}$+0 zm|r>wGWzmnqMEc`T3R zu{@UNcdG|`j^p$`toNlS>&N=BeyktsCr3ZlkL}|)^|P)Y>&N=BeypE!^<({5KXwks fsh@TISU=W}{coJ3FYC+BW9PB+^yrrPgw6OH;_3TC diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json deleted file mode 100644 index 3b4888f48..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json +++ /dev/null @@ -1,26 +0,0 @@ -[ - "FloorLamp", - "Curtains", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "TVStand", - "Drawer", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "Newspaper", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json deleted file mode 100644 index 78f79df35..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "ArmChair|+00.22|-00.01|-01.72": [ - 0.25, - -1.0, - 180, - 30 - ], - "CoffeeTable|+00.23|00.00|-00.16": [ - 0.75, - -0.5, - 270, - 30 - ], - "Drawer|+00.47|+00.06|-00.17": [ - 1.5, - 0.5, - 180, - 30 - ], - "Drawer|+00.47|+00.17|-00.17": [ - 1.5, - 0.5, - 180, - 30 - ], - "Drawer|+00.47|+00.27|-00.17": [ - 1.5, - -1.0, - 0, - 30 - ], - "Drawer|+02.00|+00.78|+01.71": [ - 1.5, - 1.0, - 90, - 30 - ], - "Drawer|-00.02|+00.06|-00.17": [ - -0.25, - -1.0, - 0, - 30 - ], - "Drawer|-00.02|+00.17|-00.17": [ - -0.25, - -1.0, - 0, - 30 - ], - "Drawer|-00.02|+00.27|-00.17": [ - -0.25, - -1.0, - 0, - 30 - ], - "SideTable|+02.00|+00.00|+01.75": [ - 1.75, - 1.25, - 0, - 30 - ], - "SideTable|+02.96|+00.00|+01.57": [ - 2.0, - 1.0, - 0, - 30 - ], - "SideTable|-00.68|+00.00|-01.60": [ - -0.25, - -1.0, - 180, - 30 - ], - "Sofa|+02.87|00.00|+00.25": [ - 2.0, - 0.25, - 90, - 30 - ], - "TVStand|+00.84|-00.01|+01.58": [ - 2.0, - 1.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy deleted file mode 100644 index 665418e122d9cac06770ebc649028343ff60128b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3344 zcmbW&v5FHx7zgli3E>FhGo*_`3cX51a4S2-#==U1m%~ClNyJ8c3LhwWgnfi7uiRpb z6e&D2-)|vbd1;2<>}KXa|AgJY??1l#@aa+cRemq7*4riT&@4lzg>OXuJ7l!UspfY_kMc${Kay9`D{7=Gk@S`R!*N`SI0w)eezxMZE}}f zS1ZMO-JA3EZ-yp*&cpg*eX+h+U#u_I7f<%}fO_)3VfS$!^=V$8-0jZSuPSA{9{sRB zS)bge`}N_vK3E^D57r0k!?~L1hfDG?&gZ)RSbuCE&ZGX!cWHh7jn|_O)*tJS^~3sM z{jmIU$vuUJ2< zAJz}+hdrNJU(TT~))(uG^~J-k=4bnG9`$8jU#u_I7we1l#rk6BwXgHC^Rn}@^YReq z<%@kizjI8J?eDt%+5UWt_1XSxf1bsDdXtCcVR={{mWSoxL*!$5SRTKdJS-2(!}72^ pEDy`W@~}KjTTUN&c)CALm!_@bWM9Xot)uTx!oJVbeZ6ne{sUHT-gy83 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json deleted file mode 100644 index e7796955d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "FloorLamp", - "Plate", - "Candle", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "WateringCan", - "TVStand", - "Painting", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "CoffeeTable", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json deleted file mode 100644 index 926752e61..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "ArmChair|-00.43|+00.01|+01.06": [ - -1.0, - 0.25, - 0, - 30 - ], - "ArmChair|-00.44|+00.01|+01.92": [ - -1.25, - 2.0, - 90, - 30 - ], - "ArmChair|-02.01|+00.01|-01.58": [ - -1.25, - -1.0, - 270, - 30 - ], - "CoffeeTable|-02.02|+00.01|+00.02": [ - -1.25, - -0.25, - 270, - 30 - ], - "DiningTable|+01.88|+00.00|-00.29": [ - 3.0, - -0.25, - 270, - 30 - ], - "DiningTable|-01.86|+00.23|+02.79": [ - -2.5, - 1.75, - 90, - 30 - ], - "SideTable|-03.60|+00.00|-01.61": [ - -2.5, - -1.0, - 270, - 0 - ], - "Sofa|-03.42|+00.01|-00.04": [ - -2.5, - 0.75, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy deleted file mode 100644 index 32ec8b98d34f480b238ced98dc1ea711dd6487e8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4688 zcmbW%v5FHx7{Kvy2#fd>+pR*X1K|+Ct?U#V3o8j;4h!)l5gYL-e4y+j2kXJ*b}8{#=Vg6Z zAD+Ye`gorEasunaO?duzDDRuI30?*3>3uy}Pj)WHRZshRvYxCb>&1HUTzj!zocr|f z!+Nn^te1N?L-{=G#d@(`tQYIW&gHo3WnV8o9+vkjO3CxF_Ted5PtWyaJvsNw^Yrvw z&$EZ}zB%+`{a8QNkM(2y*tr~6{p=rWKQ6aTiS^^D_GA56Kh}?PA9@7q=ly0V@4L5t ztRL&g`muhjAM3~N!Ex2kez|Q*e5}3rHux@BZ}02Pdb8fFH|IX|3)b8F%~0Mqm)@*5 z>&<$z-mEu|hvj*Cd+uHw*YfF<&il0|>&<$z-aLiR>+QMTtT*R=Igj5Dp6kti-<`*}XZg$J)=n{;WUi&r|rk{+{d4`g896sjT|j)t~h| z-+L%eSWniIr`nJ8WIb6=)|1_f7M?5vYxCb zPqioO$$GM$tS9Tqdaxd>2kXIlupX=j>*0ISgY{rNSP#~N^N^v$Hn~$gZeY5%4d~7~8ADfTO$L3@6vH941&h`DV`Ph6s)%kb~HlOElHJ^R+ zvH941Y(6$0o6kAsWAm~3*nB+J`Ph8yT#l>x?3<6x$L3@6vHASH=Ht2Emrudw^W1!F yJ~ki6)jamy&%XPy`|+vXkKK>mkKK>mkDafp^V#|Ae0DxNpPkRn^Syb#>i+=xY_kFY diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json deleted file mode 100644 index c848824cf..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "FloorLamp", - "Stool", - "Pillow", - "Statue", - "Box", - "Sofa", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "Book", - "WateringCan", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "LightSwitch", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "Dresser", - "Chair", - "DogBed", - "Newspaper", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json deleted file mode 100644 index 0e044ef87..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json +++ /dev/null @@ -1,182 +0,0 @@ -{ - "ArmChair|-02.86|+00.03|-02.04": [ - -2.25, - -1.5, - 270, - 30 - ], - "Drawer|+03.10|+00.17|+00.36": [ - 2.0, - -0.25, - 0, - 30 - ], - "Drawer|+03.10|+00.17|+01.40": [ - 2.0, - 0.75, - 0, - 30 - ], - "Drawer|+03.10|+00.17|-00.57": [ - 2.0, - 0.0, - 180, - 30 - ], - "Drawer|+03.10|+00.42|+00.36": [ - 2.25, - -0.25, - 0, - 30 - ], - "Drawer|+03.10|+00.42|+01.40": [ - 2.25, - 1.0, - 0, - 30 - ], - "Drawer|+03.10|+00.42|-00.57": [ - 2.25, - 0.0, - 180, - 30 - ], - "Drawer|-00.17|+00.47|-02.14": [ - -0.5, - -1.5, - 90, - 30 - ], - "Drawer|-00.19|+00.23|+00.95": [ - -1.25, - 1.5, - 180, - 30 - ], - "Drawer|-00.19|+00.48|+00.95": [ - -1.25, - 1.5, - 180, - 30 - ], - "Drawer|-00.19|+00.74|+00.95": [ - -1.0, - 0.5, - 0, - 30 - ], - "Drawer|-00.42|+00.35|+01.41": [ - -1.25, - 2.0, - 180, - 30 - ], - "Drawer|-00.42|+00.35|+01.92": [ - -1.25, - 1.25, - 0, - 30 - ], - "Drawer|-00.42|+00.35|+02.38": [ - -1.25, - 1.75, - 0, - 30 - ], - "Drawer|-00.42|+00.60|+01.41": [ - -1.25, - 2.0, - 180, - 30 - ], - "Drawer|-00.42|+00.60|+01.92": [ - -1.25, - 1.25, - 0, - 30 - ], - "Drawer|-00.42|+00.60|+02.38": [ - -1.25, - 1.75, - 0, - 30 - ], - "Drawer|-00.42|+00.85|+01.41": [ - -1.0, - 1.0, - 0, - 30 - ], - "Drawer|-00.42|+00.85|+01.92": [ - -1.0, - 1.5, - 0, - 30 - ], - "Drawer|-00.42|+00.85|+02.38": [ - -1.0, - 2.0, - 0, - 30 - ], - "Drawer|-03.24|+00.17|-00.49": [ - -2.25, - -1.0, - 0, - 30 - ], - "Drawer|-03.24|+00.42|-00.49": [ - -2.5, - -1.0, - 0, - 30 - ], - "Dresser|-00.05|+00.03|+01.67": [ - -0.75, - 1.75, - 90, - 30 - ], - "GarbageCan|+03.16|+00.03|+00.89": [ - 2.75, - 0.5, - 90, - 30 - ], - "SideTable|+03.16|+00.03|+00.36": [ - 2.75, - -0.25, - 90, - 30 - ], - "SideTable|+03.16|+00.03|+01.40": [ - 2.75, - 1.5, - 90, - 30 - ], - "SideTable|+03.16|+00.03|-00.57": [ - 2.75, - -1.0, - 90, - 30 - ], - "SideTable|-00.17|+00.03|-02.28": [ - -0.75, - -1.75, - 90, - 30 - ], - "SideTable|-03.30|+00.03|-00.49": [ - -2.75, - -1.25, - 270, - 30 - ], - "Sofa|-02.96|+00.03|+01.39": [ - -2.25, - 1.5, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy deleted file mode 100644 index ad7052df7af997c082b3bbf305788284e4c43c67..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2576 zcmbW$F^dyH7zW^R2}1}W+~pUfTZJ^I2qMBwWvAF!TqVKFafNu2h>iFw{6X$dvApt% zD^jHJ+?l8FE1hO}GQ0D=Z#Mb)_Whf87mw1n^u52_?mzDOm#hBO)r)?;>aT8gUw50& zA8vM++rOW`-hA3`A3on-Z@z3F{P^tov-RrfllAJy>Oa>kjcYN~>+N~H&Vy&c)8HID z3GRYZ@bOm~m-+JCg*+?|%fq>y&+@Q5EDy`W^4y0!EDy`W@~}KC56i>y@S%NQd>?!l zd>i~bSii&h_!^S;&-$@`tRL&g`mug|Y&KI!p2LThm*r)7S)Q)cbNrrI9+rpmkjB-OdYugQ z+Ld}WpUr3UC+&Xo*?cyi^N_~H=Ck>1KAWFQJ;!`DpUvky)aTedHjmAlminA|Y#y7( zd8p5^d2Ak^wEJhJK4(79!@l|U&F38M_kG*<`(yc7K9+A@(zq7we3p;p<7v1*2g~RF zF6^gZ|9|)E!}_p3?ElaH|E%w#q;cuX`m(+}ZFxBd>uXKbA k#-%Uo%g$rx@v`+jZRec^n`hrVb{;!#8O~$pvGbPY50_ygkpKVy diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json deleted file mode 100644 index 56cce5761..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "FloorLamp", - "Curtains", - "Pillow", - "Box", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "TVStand", - "DeskLamp", - "Drawer", - "LightSwitch", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "CoffeeTable", - "TissueBox", - "Shelf", - "Chair", - "Newspaper", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json deleted file mode 100644 index c14fbdb01..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "ArmChair|-00.88|+00.01|+00.57": [ - -0.75, - 1.25, - 180, - 30 - ], - "CoffeeTable|-01.97|+00.00|+02.62": [ - -1.25, - 3.0, - 270, - 30 - ], - "Drawer|-04.43|+00.47|+03.34": [ - -3.5, - 2.75, - 0, - 30 - ], - "GarbageCan|-00.23|+00.01|+04.78": [ - -0.5, - 4.25, - 0, - 30 - ], - "Shelf|-00.34|+00.28|+03.05": [ - -2.0, - 3.5, - 90, - 0 - ], - "Shelf|-00.34|+00.31|+02.31": [ - -1.5, - 1.75, - 0, - 30 - ], - "Shelf|-00.34|+00.45|+02.68": [ - -1.25, - 2.25, - 0, - 30 - ], - "Shelf|-00.34|+00.48|+03.05": [ - -1.25, - 3.5, - 180, - 30 - ], - "Shelf|-00.34|+00.60|+02.31": [ - -1.25, - 2.75, - 180, - 30 - ], - "Shelf|-00.34|+00.65|+03.05": [ - -1.25, - 3.5, - 180, - 30 - ], - "SideTable|-04.61|+00.01|+03.35": [ - -4.0, - 4.0, - 270, - 30 - ], - "Sofa|-02.12|+00.01|+04.56": [ - -2.25, - 3.75, - 0, - 30 - ], - "Sofa|-04.57|+00.01|+01.88": [ - -3.75, - 2.0, - 270, - 30 - ], - "TVStand|-00.34|+00.01|+02.68": [ - -1.0, - 2.5, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy deleted file mode 100644 index 612bff252a03c692fd9fae9587c56e6b1ca74d94..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1392 zcmbW#El$Kh7zW^i

#+;>QM z@;Q!udd~bhxC?HB$KA4Qw|@F}|329HJ@5RypU&@G`mjE%H_PET>Sta*Zc{(jkK5FT zyI|kXeSPe!59`D7Sw72W`FhA_`7EF1vwW7{ruQPB<+FU2&+=Km_bi{~vwW7%@>%|F z-D3`!PI-O6B^RjguNBfz#AKR~+eglST B=!pOT diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json deleted file mode 100644 index 955390880..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json +++ /dev/null @@ -1,25 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "Blinds", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "Drawer", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "Newspaper", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json deleted file mode 100644 index 3a0e5fab9..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "ArmChair|+01.51|+00.00|-00.59": [ - 1.25, - -1.25, - 0, - 30 - ], - "CoffeeTable|-00.71|+00.01|-00.37": [ - -0.5, - -1.0, - 0, - 30 - ], - "Drawer|+01.74|+00.77|+00.33": [ - 0.75, - 0.0, - 90, - 0 - ], - "Drawer|-00.71|+00.08|-00.17": [ - 0.25, - 0.5, - 270, - 30 - ], - "Drawer|-00.71|+00.08|-00.56": [ - -1.75, - -1.25, - 90, - 30 - ], - "Drawer|-00.71|+00.24|-00.17": [ - 0.25, - 0.5, - 270, - 30 - ], - "Drawer|-00.71|+00.40|-00.17": [ - -1.25, - 0.5, - 180, - 30 - ], - "Drawer|-00.71|+00.40|-00.56": [ - -0.25, - -1.25, - 0, - 30 - ], - "Drawer|-00.72|+00.24|-00.56": [ - -1.0, - -1.25, - 90, - 30 - ], - "SideTable|+01.81|+00.00|+00.33": [ - 1.25, - 0.5, - 90, - 30 - ], - "Sofa|-00.50|+00.01|-01.89": [ - -0.5, - -1.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy deleted file mode 100644 index 01fe02cc4a31f59c63203eb32ff53aed7fca0700..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3232 zcmbW(v2N2)6b9f+6j@aiRc+I>l*yYx$^v2lgj7%6in?@QLJ>{HfGA233*sqwAp9sD zJ7(yRAp@=N{gyN0rTSv~{`Z{YxcT$p^8DiClk_wFYOWTm&&%dr-Mqhk)6DAT`eylK zIsf+QW_h)E{QPYGb+vf-eD!7ieevMuFWfiN$9;4JBCtdz~dz$|~4L%M& z3Vv36SMIkSTaT^B*5hed?=W~0d=R`JycfJ1JPsZO?*v!D!{9-%{;W%X)Whmw^{{$a zJ**y9537gO!|Gx6uzEO^`gr>{^#^Z)?}OLDcfq&8`gMPrbM%Y#i}j23i}j23i}j1E zF6XlTu>P?Au>P?Au>SD6)X)0E`osFMDgDt8)(_SX)(_SXRu6B>{#gDtfdhB}kzTGX?yPv(E*m`U|w%%S?kIjcS<^96mk1U_% zvwZgdcfaJHbg4hs?-Ta>g#A9@X}JF|SifBFd1B8Kd!E?y#N)93DA@Dl`YN3FJUQ?C z!TQg>?`$4y9&8?L9&8?L9tUme5A$I2VDsRkQXfx)&BJ-~VDn(}VDn(}VDn(}VDsQA h?9V)$HxD)sHV-xrHV-xrHV=0Hq)q+des=$){Rg6}TU`JE diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json deleted file mode 100644 index f87968d27..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "FloorLamp", - "Plate", - "Pillow", - "Box", - "Statue", - "Sofa", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "Cabinet", - "Drawer", - "Painting", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "CoffeeTable", - "Shelf", - "Newspaper", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json deleted file mode 100644 index 76136ed5f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json +++ /dev/null @@ -1,206 +0,0 @@ -{ - "ArmChair|-01.01|+00.03|+02.08": [ - -1.75, - 2.5, - 90, - 30 - ], - "ArmChair|-01.58|+00.03|+03.30": [ - -2.0, - 2.75, - 0, - 30 - ], - "Cabinet|-01.53|+01.87|+00.33": [ - -1.0, - 1.0, - 180, - 0 - ], - "Cabinet|-01.98|+01.17|+05.03": [ - -2.25, - 4.5, - 0, - 30 - ], - "Cabinet|-02.02|+01.71|+00.32": [ - -1.5, - 1.0, - 180, - 0 - ], - "Cabinet|-02.47|+01.33|+05.03": [ - -2.75, - 4.5, - 0, - 0 - ], - "Cabinet|-03.70|+01.71|+05.03": [ - -4.0, - 4.5, - 0, - 0 - ], - "Cabinet|-04.18|+01.87|+05.03": [ - -4.5, - 4.5, - 0, - 0 - ], - "Cabinet|-05.37|+01.17|+05.03": [ - -5.75, - 4.5, - 0, - 30 - ], - "Cabinet|-05.85|+01.33|+05.03": [ - -6.25, - 4.5, - 0, - 0 - ], - "CoffeeTable|-02.67|+00.03|+02.00": [ - -2.0, - 1.5, - 270, - 30 - ], - "DiningTable|-05.82|+00.03|+02.56": [ - -4.75, - 2.0, - 270, - 30 - ], - "Drawer|-01.09|+00.23|+00.46": [ - -1.0, - 1.25, - 180, - 30 - ], - "Drawer|-02.68|+00.23|+00.46": [ - -2.75, - 1.25, - 180, - 30 - ], - "Drawer|-02.94|+00.51|+05.00": [ - -3.25, - 4.5, - 0, - 30 - ], - "Drawer|-02.94|+00.82|+05.00": [ - -3.0, - 4.5, - 0, - 30 - ], - "Drawer|-04.26|+00.23|+00.46": [ - -4.75, - 1.25, - 180, - 30 - ], - "Drawer|-06.33|+00.51|+05.00": [ - -6.0, - 4.5, - 0, - 30 - ], - "Drawer|-06.33|+00.82|+05.00": [ - -6.25, - 4.5, - 0, - 30 - ], - "GarbageCan|-06.85|+00.02|+00.26": [ - -6.25, - 0.75, - 180, - 30 - ], - "Shelf|-00.81|+01.69|+00.19": [ - -1.0, - 1.0, - 180, - 0 - ], - "Shelf|-01.04|+01.00|+00.18": [ - -0.5, - 1.0, - 180, - 0 - ], - "Shelf|-01.04|+01.32|+00.18": [ - -0.5, - 1.0, - 180, - 0 - ], - "Shelf|-01.78|+00.99|+00.18": [ - -1.25, - 1.0, - 180, - 0 - ], - "Shelf|-02.22|+00.45|+05.17": [ - -2.75, - 4.25, - 90, - 30 - ], - "Shelf|-02.67|+00.61|+00.27": [ - -2.0, - 1.0, - 180, - 30 - ], - "Shelf|-03.19|+01.15|+05.17": [ - -3.25, - 4.5, - 0, - 0 - ], - "Shelf|-03.94|+00.99|+05.17": [ - -3.75, - 4.25, - 0, - 0 - ], - "Shelf|-04.67|+01.00|+05.17": [ - -4.75, - 4.5, - 0, - 30 - ], - "Shelf|-04.67|+01.32|+05.17": [ - -4.75, - 4.5, - 0, - 0 - ], - "Shelf|-04.90|+01.69|+05.17": [ - -4.75, - 4.5, - 0, - -30 - ], - "Shelf|-05.61|+00.45|+05.17": [ - -5.0, - 4.25, - 270, - 30 - ], - "Shelf|-06.57|+01.15|+05.17": [ - -6.5, - 4.5, - 0, - 0 - ], - "Sofa|-03.33|+00.02|+03.63": [ - -3.25, - 3.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy deleted file mode 100644 index 7a07f8bf3aa03848dd6ebd588c90ecca0333f83c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2576 zcmbW%F>6y%7zW^D2!{|tXk*>)b}MADQV05uX-GAKmFT4KL<%@pZ^_N$>o89Ki z`PJ@X`|tUi&FB60;rag4=6d_!<7cPO*WJm}b@#pd&oxiuS`GE{_I3R{3_b{61}}o= z!L#5TJPm%_eAn{G$MUg!EFa6q^09m@AIrz`-M4(sXXmr?+4<~zc77^pT+Ub>%@e4K~6kLBY@c%OprTYmfXVSQL1)`#_B zedeX+^!w#S%ftGzzMR8;eZAM0^<{loU)GoPWqny+)^}0Txb$WJSM2|am#rV051S9q z!u}j=KK7drn-7~0n-7~0n-7~0n-81MvZQgD51S9051S9056@eFo(1P%^ReH2*nHT0 z*nHT0*nHT0*nId&%Xd)HxQ>F&&wKM@eL08k>+8L~tS{@!`m(;PFYC+t@=?ooSkk!k jWBph@mXGCQ`B*-dkL6?eRv{nD!}72^EDy`W@~p~VyiFZK9KteKEjq; zrbv+@h3n1v3Qy@Y%a=)J{_}^u`T6?ot2giNlyBvGcfQ(uSa;9b?)k-8w`jYI%k|gw z^7H%4_4(@W>o1p|Hmlp$Hy@W@R=0lm`0VMTee!70{%HSmHDy?*SI58CFOGljCGUUz zyMI6SZ{qzv&pyvS&$~E}AH;dvIM4a)e0DxNpLcOSZ*Emp=!5ma`e1#qK3E^D z57r0Qn2+_r`e1$VA^PBbvOetVgY{ARGAw( zKg-YZv-~VS%g^$&{477q&(|>zn`hjYVfjATJZv5|51WU})$v?551WV0!{%Z0uzA=# zwLji#9ySk~ht0#I$j>F&Joe4Q=3(=&dDuK`o=KXA&BNwl^RVX!Ph%eT{9w-yuIc^b zKm+ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json deleted file mode 100644 index 2aca56e1f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Boots", - "Sofa", - "Statue", - "Pencil", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "WateringCan", - "CellPhone", - "Drawer", - "Desk", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "TissueBox", - "Dresser", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json deleted file mode 100644 index 27d4df17e..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "ArmChair|-01.32|+00.03|+03.65": [ - -1.75, - 3.0, - 0, - 30 - ], - "CoffeeTable|-03.04|+00.00|+02.34": [ - -3.25, - 3.0, - 180, - 30 - ], - "Desk|-00.31|+00.03|+00.62": [ - -1.0, - 1.0, - 90, - 30 - ], - "Drawer|-05.50|+00.21|+02.13": [ - -5.25, - 1.5, - 0, - 30 - ], - "Drawer|-05.50|+00.21|+02.68": [ - -5.25, - 3.25, - 180, - 30 - ], - "Drawer|-05.50|+00.52|+02.13": [ - -5.25, - 1.5, - 0, - 30 - ], - "Drawer|-05.50|+00.52|+02.68": [ - -5.25, - 3.25, - 180, - 30 - ], - "Dresser|-05.70|+00.02|+02.40": [ - -5.25, - 1.5, - 0, - 30 - ], - "SideTable|-00.31|+00.02|+01.52": [ - -0.75, - 2.0, - 90, - 30 - ], - "SideTable|-05.57|+00.02|+00.29": [ - -5.0, - 0.75, - 270, - 30 - ], - "Sofa|-03.13|+00.03|+00.61": [ - -3.25, - 1.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy deleted file mode 100644 index 9e63fce2cd289e0c50458690a443b21b3d1666b8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1648 zcmbW$u}T9$6a~;xL?np#3Db?jRslhSwVh&FAr+tv8;`erLVrgwOYacY}9=w}bV|)z7ilzEwZ# zXZ@_7Q$G)zN3MC;JnT7+t9k63ht0$0;h#m?T>KsU75o|Oeazu~*!!^eVg0P1^|OA~ z@4fZ2e3sAhSw746J<4bKET84Ge3tKbk;n2_9?N5Sa?Hzdm2Y1@%V+tXlh5wsxXQOL zpXIwx9=ng@>Up{5V|gr(<*~ev{@lxB=bN2x*2nr-AM0C&KGw(j*#DUQPuRI;=a8Kv MHb0x6&A(i%0CTJP2LJ#7 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json deleted file mode 100644 index f21beb23b..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Blinds", - "Pencil", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "Pen", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "DiningTable", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Shelf", - "Chair", - "LightSwitch", - "Bottle", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json deleted file mode 100644 index 99352e9a3..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "Cabinet|-00.30|+01.92|-02.50": [ - -1.0, - -2.75, - 90, - 0 - ], - "Cabinet|-00.33|+01.92|-03.39": [ - -1.0, - -2.75, - 180, - 0 - ], - "Cabinet|-00.58|+00.39|-01.80": [ - -1.25, - -2.25, - 0, - 30 - ], - "Cabinet|-00.58|+00.39|-02.20": [ - -1.5, - -2.75, - 0, - 30 - ], - "Cabinet|-00.58|+00.39|-03.40": [ - -1.75, - -3.0, - 90, - 30 - ], - "Cabinet|-00.88|+00.39|-03.42": [ - -1.25, - -2.5, - 90, - 30 - ], - "Cabinet|-00.88|+02.14|-03.69": [ - -1.5, - -2.75, - 180, - 0 - ], - "Cabinet|-01.76|+02.14|-03.69": [ - -1.25, - -2.75, - 180, - 0 - ], - "CounterTop|-00.30|+00.95|-02.79": [ - -1.0, - -3.0, - 90, - 30 - ], - "DiningTable|-02.43|+00.00|-01.69": [ - -1.75, - -1.5, - 270, - 30 - ], - "Fridge|-00.33|+00.00|-00.77": [ - -1.25, - -0.75, - 90, - 0 - ], - "GarbageCan|-01.94|00.00|-03.76": [ - -2.25, - -3.5, - 90, - 30 - ], - "Microwave|-01.32|+01.52|-03.80": [ - -1.25, - -3.0, - 180, - -30 - ], - "Shelf|-02.43|+00.15|-01.69": [ - -3.25, - -0.75, - 90, - 30 - ], - "Shelf|-02.43|+00.52|-01.69": [ - -3.75, - -1.75, - 90, - 0 - ], - "Sink|-00.35|+00.91|-02.01|SinkBasin": [ - -1.0, - -2.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy deleted file mode 100644 index 35ea786ab0b1dda667f3723868c36a81bc2c172f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6448 zcmbW(y=oL;6b9hWunfx*mfigMubXNWQYnIpkg4nx8w)E5W`l(o*@%q@xd$)Ey_A$G zQ>54;h4I_-OmRx52~Q@O^PYDzGx`1Y{hN0mZj>M8=k#!P@@YPOIhnpXdOqEoOplJ| z-{%KkKOWByXaBzc`rymS?E3pBpAWvxuKnogi)VY2Cy)0gzb5~A3`#w=7pt#l`>U^8 z$(zX=$>ZepINU;QcdkZ+lMnS7CKzw`aob?nFXWBalFcog|~m~4ON?a%h- zCjGwsonK4mOR|3ayna|etRL3TMe2w3!}?+UuzpxStRL17>xcEj`eFUBepo-OAHIyg z7uFB!=Q8!f`eFUBepo-OAC{lxXZcxvzKDHT{$N4Sw5DJmU_s`o+m6X%ggfeGV-##EHBH;@~x$OEFa6q^09m@ zAIrz`v3#sgmbcfIdgznoWqDa%mY3yad0AeTm*r)7o0OO3WqDa%mY3yad0AeTm*r)7 z`zbHW%kr|kEHBH;^0K@vFU!mF4pLs0m*r)7Szh+M<>8{#gS~IKN#}dXCHX4uU%#&( z)(`84^~3sM{j9g89_|;`59^2Z!}?+U@G$n{^y!1#`ec2M z+ENdFvOZa#tWVY_>y!1#`s6|M#rotXo!6)H`ec2wK3SivPu3^vll3=lOFi_*TalOb z$NFRavHUDQ%g^$&{478Fdtm!)qvY#+7{+lTGL_F?<5eb_#1AGQz6yBYh)%kr|k zEHBH;^0K@vFU!mFvbKDt>e1>*gQ6m&13V}Jhm^Je>=@*^VxhhpUr3U*?cztPMXi=v-xa3o6qL6 z`E35(G@s39^VxhhpUr3U+5CHHKAX?xv-xa3o6qL6`S;U&HlNLB^VxhhpUr3UAEfzg zKAX?xv-xa3o6qJyO!L`%HlIDe*z=1$zu5DOn?dB*l* z`?3AFw^&`5{r|__-|YR(-rwx~&Gu#cvVA%BJ>}T9bL`tW_U#<|c8+~I$3C57pU$yQ e=h&xn?9y!1l+x`WazMf(L diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json deleted file mode 100644 index 7ddc799b5..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "FloorLamp", - "Plate", - "Candle", - "Pillow", - "Box", - "Boots", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "DeskLamp", - "Mirror", - "Painting", - "RoomDecor", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "TissueBox", - "Newspaper", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json deleted file mode 100644 index b866dc6e2..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "ArmChair|-02.69|+00.01|+04.62": [ - -3.0, - 5.25, - 180, - 30 - ], - "ArmChair|-03.66|+00.01|+04.56": [ - -4.25, - 5.0, - 90, - 30 - ], - "CoffeeTable|-03.13|+00.02|+08.53": [ - -3.5, - 7.75, - 0, - 30 - ], - "CoffeeTable|-03.24|+00.01|+06.60": [ - -2.5, - 6.5, - 270, - 30 - ], - "DiningTable|-02.90|+00.01|+02.23": [ - -1.5, - 2.25, - 270, - 30 - ], - "GarbageCan|-05.71|+00.01|+00.30": [ - -5.25, - 0.75, - 180, - 30 - ], - "SideTable|-00.40|+00.01|+00.36": [ - -1.0, - 0.75, - 90, - 30 - ], - "SideTable|-00.53|+00.01|+08.52": [ - -1.0, - 8.0, - 90, - 30 - ], - "Sofa|-01.71|+00.00|+06.45": [ - -2.5, - 6.5, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy deleted file mode 100644 index 33ebd8c0cd3be20377e952e1aa38d20c79148755..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1152 zcmbW!JxT*X7=YnXL?q-8)2+f*A|fJWD?7!;!b%pi!9tAeij8;*59Aecgp`&R7AaB~ zoq3um-DY{_XTO)^{qp+a>Simvgx6}?4R?KY8mqI}Nma*cHt(PN_VIS!PrKjs^Y&rr zHtWNE`_yf`e|%KO!-G1$#s5B|@b|1g(t9;Y??vIX8iIZ2*ZKS^pJ(^keRe-IX~%v3 z&fnv&!k>kgh0S;0d^Uf(n9t_3`D{L$&*pQ;4=*NZf%WV(Y2EL^dRPzZVLhye)07Zc z59`@2dRPzZVLhye^{^h+!+Q3L9@fKpSP$!AJ*<$BQ7Y~){@?_Lfs#Ug7fmB&xZYH@L3zO>K`8vr<-JO@`0x@fb^X@$_#QJC av3);t%zWt0G5^QhA9?pN_c8DFJ&wQsFq4rjK=gk>!`;^SsFN@uYsMhc6G4dQ|;AzZyPI ztM&8g)9|%g`{?Yn$WD%n>@)lC>7~u-&YF8ZXzosM3SND0&o6@)!SmpsVEv21c0cQ9 z{j8t$^Ste2{j7f(`dL5gXZ@_7^|OA~zY6`VpI7bs@G@Ax-}SS8_PtZt{Qvq`AM0a% ztdI4v{hhYYezu?OXZzWHw!d4Z&9R^DXZtzLn%r*L-102X@+`j>@+{BtEZ+-xmS=gE i-w%0~XLZgFumnbwLnDT7n^*f&+1d9bpoQKp+r|tWWSu zYQDU`-)p<#s`Y?UoK_8|M(9|be+wVRhw)*2l{SBn`(b<-ALbn@{QxH- BbR7Ty diff --git a/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json deleted file mode 100644 index 3b62eb5e3..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json +++ /dev/null @@ -1,43 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Curtains", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Bread", - "Sink", - "DiningTable", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Chair", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json deleted file mode 100644 index 9dbe15133..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json +++ /dev/null @@ -1,128 +0,0 @@ -{ - "Cabinet|+00.13|+00.39|+01.77": [ - 1.0, - 1.5, - 0, - 30 - ], - "Cabinet|+00.35|+00.39|+02.36": [ - 1.0, - 1.75, - 0, - 30 - ], - "Cabinet|+01.51|+00.39|+02.36": [ - 0.5, - 1.5, - 90, - 30 - ], - "Cabinet|+01.76|+00.39|+00.87": [ - 1.0, - 0.0, - 0, - 30 - ], - "Cabinet|+01.76|+00.39|+02.35": [ - 1.0, - 1.5, - 0, - 30 - ], - "Cabinet|+01.97|+02.11|+02.62": [ - 1.25, - 2.0, - 0, - 0 - ], - "Cabinet|+02.04|+01.81|+00.28": [ - 1.25, - 0.75, - 90, - 0 - ], - "Cabinet|+02.04|+01.81|+00.87": [ - 1.25, - 0.5, - 90, - 0 - ], - "Cabinet|+02.04|+02.11|+00.89": [ - 1.25, - 0.75, - 90, - 0 - ], - "Cabinet|+02.04|+02.11|+01.77": [ - 1.25, - 1.0, - 90, - 0 - ], - "Cabinet|+02.04|+02.11|+01.81": [ - 1.5, - 2.0, - 90, - -30 - ], - "Cabinet|+02.04|+02.11|+02.62": [ - 1.5, - 2.0, - 90, - -30 - ], - "CounterTop|+02.06|+00.97|+00.58": [ - 1.25, - 0.5, - 90, - 0 - ], - "DiningTable|-00.15|00.00|+01.07": [ - 0.5, - 1.0, - 270, - 30 - ], - "Drawer|+01.91|+00.77|+02.06": [ - 1.25, - 1.75, - 0, - 30 - ], - "Drawer|+02.17|+00.77|+00.58": [ - 1.25, - 1.0, - 180, - 30 - ], - "Drawer|-00.02|+00.77|+02.06": [ - 0.75, - 1.5, - 0, - 30 - ], - "Fridge|+02.10|+00.00|-00.28": [ - 1.0, - -0.25, - 90, - 30 - ], - "GarbageCan|-00.31|00.00|-00.81": [ - 0.25, - -0.25, - 180, - 30 - ], - "Microwave|-00.31|+00.93|+02.08": [ - 0.5, - 1.75, - 270, - 0 - ], - "Sink|+00.94|+00.94|+02.65|SinkBasin": [ - 1.0, - 2.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy deleted file mode 100644 index 7b6b1a810345427619241bcd42635ed7ebe51d2a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1712 zcmbW%F-ikL6oBDTBuEg?Fx@C@Wo5+LPO-7DlErLDAx3t^Mm&WFN{*7!GDQjt3uD}` z@Re>ee3Rt8KLqlAb#r-ryOUnhYZ*7)eOu0QIiH-CDwoNueQxW=yIDJKe(o>ohpyS& zchmZ*+4yKQs`ANkmEZDzpJCcQdyC(5zdv__Q}EaP@B2T4*TJh``v(17``A9VkL_do z*gkgJ8&CV)+t2p1{cJzm&xeb&ee5|19tOwXVGv$7*SvV@cdwuIvwqgk`pwnP`dL5g zXZ>ss$5X$1{j8t$vwm~*vwqgk`dL5gXL~uG`rYei{jA^T^s|1}&-z(E>u3F}gX5{+ zy?)m3efn8H>u3F}pY^kT*3Y^)p62@==Ck>1KAX?xv-uzW|DyS9KAX?xv-xcPGR$Z5 M*?cyi&0o&H0c$G?VE_OC diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json deleted file mode 100644 index 7abe48eea..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json +++ /dev/null @@ -1,43 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Blinds", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "SideTable", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "DiningTable", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Shelf", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json deleted file mode 100644 index a56b16123..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "Cabinet|-00.33|+01.89|-02.51": [ - -1.0, - -2.75, - 90, - 0 - ], - "Cabinet|-00.34|+01.89|-01.29": [ - -1.0, - -1.75, - 90, - 0 - ], - "Cabinet|-00.35|+01.89|-03.29": [ - -1.25, - -3.0, - 90, - 0 - ], - "Cabinet|-00.63|+00.39|-01.61": [ - -1.5, - -2.0, - 0, - 30 - ], - "Cabinet|-00.63|+00.39|-02.51": [ - -1.25, - -3.0, - 90, - 30 - ], - "Cabinet|-00.63|+00.39|-03.01": [ - -1.25, - -2.5, - 90, - 30 - ], - "Cabinet|-01.01|+00.39|-03.37": [ - -1.75, - -2.5, - 90, - 30 - ], - "CounterTop|-00.33|+00.98|-01.45": [ - -1.0, - -1.75, - 90, - 30 - ], - "CounterTop|-01.94|+00.98|-03.67": [ - -1.0, - -3.0, - 90, - 30 - ], - "DiningTable|-03.22|00.00|-00.45": [ - -2.5, - -0.5, - 270, - 30 - ], - "DiningTable|-03.59|+00.00|-03.26": [ - -3.75, - -2.25, - 180, - 30 - ], - "Drawer|-00.48|+00.78|-02.74": [ - -1.5, - -2.25, - 90, - 0 - ], - "Drawer|-00.50|+00.78|-01.45": [ - -1.25, - -1.0, - 180, - 30 - ], - "Fridge|-00.31|+00.00|-00.65": [ - -1.25, - -0.75, - 90, - 30 - ], - "GarbageCan|-02.42|-00.03|-03.54": [ - -1.75, - -2.75, - 270, - 30 - ], - "Microwave|-00.22|+01.47|-02.06": [ - -1.0, - -2.0, - 90, - -30 - ], - "Shelf|-04.03|+00.26|-00.30": [ - -3.5, - -1.5, - 270, - 30 - ], - "Shelf|-04.03|+00.49|-00.30": [ - -3.5, - -1.25, - 270, - 30 - ], - "SideTable|-04.03|+00.00|-00.30": [ - -3.75, - -1.5, - 0, - 0 - ], - "Sink|-00.60|+00.93|-03.39|SinkBasin": [ - -1.0, - -3.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy deleted file mode 100644 index 3ae68148a7960946b2d57b4b5964ef738dbcc3ce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1168 zcmbWzu}Z{16ouij^(oSgLMlNK5!}j7v9Yj{;AXK9R}!%ipTY;)SI8r5xn+tJ78b5% zzJLQZPILM1J#){QdB42AxVqU1FX1)L>-MgRCq+D69LKVVi)HiNRFAjIW?p~y&#Q;F z-uB!3>Z#uH-qB%M9PF3HTk+qs8-C7uHP%h4UB=@yglT^ETffeDlX0K(YP_HO;=IbE zFAwh0ek>1`2g`$p?EXi_eab7x^be_Tk9l6@o%(4%mKV#5<;6pGUtaS*<>D(ZmKW3e zM|w<;>E))!^qAhe=rKL+QvTtOcgj7zJLxcAY%lhom=EUvnfCI-{sHsD{4hVv5A((R V!;EvPiTRuJ$NVvW%pda)voGD%xz_*y diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json deleted file mode 100644 index 017eb7373..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json +++ /dev/null @@ -1,39 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Bread", - "Sink", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Chair", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json deleted file mode 100644 index f3cc8c38c..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Cabinet|+01.32|+01.96|-01.31": [ - 1.0, - -0.75, - 180, - 0 - ], - "Cabinet|+01.34|+00.59|-01.11": [ - 0.75, - -0.75, - 180, - 30 - ], - "Cabinet|+01.99|+00.59|-01.11": [ - 1.25, - -0.5, - 90, - 30 - ], - "Cabinet|+01.99|+01.40|-01.11": [ - 1.5, - -0.5, - 180, - 0 - ], - "Cabinet|-00.85|+00.59|-01.11": [ - -0.25, - -0.75, - 180, - 30 - ], - "Cabinet|-00.87|+01.96|-01.31": [ - -0.5, - -0.75, - 180, - 0 - ], - "Cabinet|-01.53|+00.59|-01.11": [ - -0.75, - -0.5, - 180, - 30 - ], - "CounterTop|+00.20|+01.08|-01.51": [ - 0.25, - -0.75, - 180, - 30 - ], - "CounterTop|+00.97|+01.08|+00.42": [ - 0.5, - -0.25, - 0, - 30 - ], - "Fridge|-01.29|+00.02|+01.83": [ - -0.25, - 1.75, - 270, - 30 - ], - "GarbageCan|+01.86|-00.02|+02.39": [ - 1.5, - 2.0, - 0, - 30 - ], - "Microwave|-01.19|+01.62|-01.28": [ - -1.0, - -0.5, - 180, - 0 - ], - "Sink|+00.93|+00.94|+00.32|SinkBasin": [ - 1.5, - -0.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy deleted file mode 100644 index e5a612c999fc9c14ac13d0d68e8f8c54b1fb94ce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1856 zcmbWzu};EJ6oBC?qfgPTnlPvnF(xv(XZ zABktQ%guL6|I_k$b9a4ve~{kNdpWM=k9B!oloyjh*)Ph;tbVOW(}!6-u72iMqvv_G zo6ny{FV)URrzeAcadzAdsa0GPnuuo=VB{dMWf+kM&rO^|pDh z_hUWQV?EZ}gdXd$9_z8*I`mkN^;nPfoW7U!xXF82kDWU4)HBy(J#H?$3G2rW$5Y>2 zpY>VabM~^|aXj_+^Zfq23|qHbpY>Uv^;y5o|BpWFvp(x{lRK=x4t>_=X3-T{pWA$Y6MC%2 mdaTEK+t6b@)?+=^OT+Gt|C9AtkM&ru7kaG6dYtmr8-4>qmmo+0 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json deleted file mode 100644 index 0f770854d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json +++ /dev/null @@ -1,45 +0,0 @@ -[ - "PaperTowelRoll", - "StoveBurner", - "Faucet", - "Stool", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "SideTable", - "Tomato", - "Window", - "Bowl", - "Knife", - "GarbageCan", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "Floor", - "HousePlant", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json deleted file mode 100644 index 1d586c647..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "Cabinet|+00.58|+00.78|-02.05": [ - -0.25, - -1.25, - 180, - 30 - ], - "Cabinet|-01.46|+00.78|+00.47": [ - -0.75, - 1.0, - 180, - 30 - ], - "Cabinet|-01.46|+00.78|+01.31": [ - -0.75, - 0.75, - 0, - 30 - ], - "Cabinet|-01.46|+00.78|-02.00": [ - -0.75, - -1.5, - 180, - 30 - ], - "CounterTop|-01.81|+01.36|+01.18": [ - -1.0, - 1.5, - 270, - 30 - ], - "Drawer|+00.65|+00.60|+00.68": [ - 0.0, - 0.25, - 0, - 30 - ], - "Drawer|+00.65|+00.60|+01.02": [ - -0.25, - 0.5, - 0, - 30 - ], - "Drawer|+00.65|+00.84|+00.68": [ - 0.0, - 0.25, - 0, - 30 - ], - "Drawer|+00.65|+00.84|+01.02": [ - 0.0, - 1.5, - 180, - 30 - ], - "Drawer|+00.65|+01.06|+00.68": [ - -0.25, - 0.0, - 90, - 0 - ], - "Drawer|+00.65|+01.06|+01.02": [ - -0.25, - 1.75, - 90, - 0 - ], - "Drawer|-01.61|+00.68|-00.43": [ - -1.0, - -1.0, - 0, - 30 - ], - "Drawer|-01.61|+00.68|-01.22": [ - -1.0, - -1.75, - 0, - 30 - ], - "Fridge|+01.01|+00.23|+01.92": [ - 0.0, - 2.0, - 90, - 0 - ], - "GarbageCan|-01.63|+00.21|+02.19": [ - -0.75, - 1.5, - 0, - 30 - ], - "Microwave|+00.99|+01.31|-02.16": [ - 0.0, - -1.75, - 90, - 0 - ], - "SideTable|+00.98|+00.21|+00.87": [ - 0.5, - 0.0, - 0, - 30 - ], - "Sink|-01.99|+01.14|-00.98|SinkBasin": [ - -0.25, - 0.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy deleted file mode 100644 index 4dff912e9ee932067c7ef80e65180eb5cb8d8469..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1296 zcmbW$u}Z^07zgk(h=Wg&Eef4}I^%e369XodD(80m# z-7ny|ndSI>x%|KH()8o%=JNV>C%lHYYTV53+v=>W&L^kUpsXg-_N5&?-A&tZ^Ig9f zJJLR!FmdAV9{%#(AF5hib2;8N9OQb)1NuXEXc) D)dQw{ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json deleted file mode 100644 index 03562e5d5..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json +++ /dev/null @@ -1,45 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "PepperShaker", - "Pan", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "CellPhone", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Mirror", - "Bread", - "Sink", - "Floor", - "HousePlant", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "Bottle", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json deleted file mode 100644 index 779e34a00..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json +++ /dev/null @@ -1,218 +0,0 @@ -{ - "Cabinet|+00.14|+01.67|-01.56": [ - 0.5, - -0.75, - 180, - -30 - ], - "Cabinet|+00.62|+01.87|-01.26": [ - 0.25, - -0.5, - 180, - 0 - ], - "Cabinet|+01.40|+01.87|-01.26": [ - 0.5, - -0.75, - 90, - 0 - ], - "Cabinet|+02.82|+01.77|-01.05": [ - 2.25, - -1.25, - 90, - -30 - ], - "Cabinet|+02.85|+00.42|+00.41": [ - 2.0, - 0.25, - 0, - 30 - ], - "Cabinet|+02.85|+00.42|-00.61": [ - 2.0, - -1.0, - 0, - 30 - ], - "Cabinet|+02.85|+00.42|-00.96": [ - 2.0, - -1.25, - 90, - 30 - ], - "Cabinet|+03.07|+01.67|-00.71": [ - 2.25, - -1.0, - 90, - -30 - ], - "Cabinet|-00.19|+01.67|-01.34": [ - 0.25, - -0.75, - 180, - 0 - ], - "Cabinet|-00.92|+01.67|-00.62": [ - -0.25, - -0.5, - 270, - 0 - ], - "CounterTop|+00.13|+00.94|-01.46": [ - 0.5, - -0.75, - 180, - 30 - ], - "CounterTop|+01.21|+00.94|+00.46": [ - 2.0, - 0.5, - 270, - 30 - ], - "CounterTop|+03.11|+00.94|+00.02": [ - 2.5, - 0.0, - 90, - 30 - ], - "CounterTop|-01.01|+00.94|-00.04": [ - -0.25, - 0.0, - 270, - 30 - ], - "Drawer|+00.38|+00.19|-01.51": [ - -0.25, - -0.25, - 90, - 30 - ], - "Drawer|+00.38|+00.38|-01.51": [ - 0.0, - -0.5, - 90, - 30 - ], - "Drawer|+00.38|+00.57|-01.51": [ - -0.25, - -0.5, - 90, - 30 - ], - "Drawer|+00.38|+00.77|-01.51": [ - 0.0, - -0.75, - 90, - 30 - ], - "Drawer|+03.02|+00.77|+00.70": [ - 2.25, - 1.25, - 180, - 30 - ], - "Drawer|+03.02|+00.77|-00.41": [ - 2.25, - 0.0, - 180, - 30 - ], - "Drawer|+03.02|+00.77|-00.78": [ - 2.25, - -0.5, - 180, - 30 - ], - "Drawer|-00.86|+00.19|+00.66": [ - 0.0, - 1.5, - 270, - 30 - ], - "Drawer|-00.86|+00.19|+01.43": [ - 0.0, - 0.75, - 270, - 30 - ], - "Drawer|-00.86|+00.19|-00.10": [ - 0.0, - 0.75, - 270, - 30 - ], - "Drawer|-00.86|+00.39|+00.66": [ - 0.0, - 0.0, - 0, - 30 - ], - "Drawer|-00.86|+00.39|+01.43": [ - 0.0, - 0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.39|-00.10": [ - 0.0, - -0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.58|+00.66": [ - -0.25, - 1.25, - 180, - 30 - ], - "Drawer|-00.86|+00.58|+01.43": [ - -0.25, - 0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.58|-00.10": [ - -0.25, - 0.5, - 180, - 30 - ], - "Drawer|-00.86|+00.77|+00.66": [ - -0.25, - 1.25, - 180, - 30 - ], - "Drawer|-00.86|+00.77|+01.43": [ - -0.25, - 0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.77|-00.10": [ - -0.25, - 0.75, - 180, - 30 - ], - "Fridge|+01.01|+00.03|-01.47": [ - 0.5, - -0.75, - 180, - 30 - ], - "Microwave|-01.03|+00.87|+01.43": [ - -0.25, - 1.25, - 270, - 0 - ], - "Sink|+03.08|+00.89|+00.09|SinkBasin": [ - 2.5, - 0.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy deleted file mode 100644 index 3db3b80bbcf3897bfc7704cfaef557cb0288243f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1392 zcmbW#uTH~I7(nq$gW@Ub3P}})KOtEa4uV0TNW;1y7Dn1-hVT?T5U;RDn4GMrKp+_O z{z$lzns4XpUC&9kx9i)ho4dWR3NOX9=^onRJTES0r$w0;vqigX>!*V?=`Q@ZoSkvnJJG}FO**9a~&(47xre;%b~ED`TDE$T$1+Id(g)KA(+ATBOKs`(+6iVq+^gII%s$LM%s$LMES3G> M`#pT#53}DT9}otFVE_OC diff --git a/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json deleted file mode 100644 index 83f093816..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "HousePlant", - "Safe", - "Laptop", - "Bed", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json deleted file mode 100644 index 17003e4fb..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bed|+01.24|+00.00|-00.90": [ - 0.25, - -0.75, - 90, - 30 - ], - "Desk|-00.79|+00.00|-01.03": [ - -0.5, - -0.75, - 270, - 30 - ], - "Drawer|+00.30|+00.17|+01.16": [ - 1.0, - 0.75, - 270, - 30 - ], - "Drawer|+00.30|+00.46|+01.16": [ - -0.25, - 0.75, - 90, - 30 - ], - "Drawer|+00.42|+00.53|-01.55": [ - 0.0, - -1.25, - 90, - 30 - ], - "Safe|+01.62|+00.00|+00.45": [ - 0.75, - 0.5, - 90, - 30 - ], - "Shelf|-00.47|+00.83|-02.04": [ - 0.0, - -0.75, - 180, - 30 - ], - "Shelf|-01.29|+01.45|-00.60": [ - -0.5, - -0.5, - 270, - 30 - ], - "Shelf|-01.29|+01.45|-01.34": [ - -0.25, - -1.0, - 270, - 30 - ], - "Shelf|-01.29|+01.81|-00.60": [ - -0.5, - -0.75, - 270, - 0 - ], - "Shelf|-01.29|+01.81|-01.34": [ - -0.5, - -0.75, - 270, - 0 - ], - "SideTable|+00.31|+00.00|+01.23": [ - 0.75, - 0.75, - 0, - 30 - ], - "SideTable|+00.41|+00.00|-01.68": [ - -0.25, - -1.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy deleted file mode 100644 index 486b0356b0c3ee8b46af7af8a9dd36b5de09ae91..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1168 zcmbW#p-#g<9Khkj@)UK2q>2PW2+14{f7_p$qU$mbf@!K>gtIKSOwe?OaM*!yL@JcQ@RV9)7_qdxO}?qhwd zkM*%W*2ntT`((Ybi{q%*yk6GJdRZ^)WxcGI{omO4h+P~dF;HDz5#xW&Y}PS diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json deleted file mode 100644 index 50bca7fac..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json +++ /dev/null @@ -1,35 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "GarbageBag", - "Window", - "GarbageCan", - "Poster", - "Pen", - "Cloth", - "CreditCard", - "Book", - "CellPhone", - "Dumbbell", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Vase", - "Mug", - "Bed", - "ShelvingUnit", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json deleted file mode 100644 index 8704b6b03..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "Bed|-01.05|+00.00|-01.85": [ - -1.0, - -1.0, - 180, - 30 - ], - "Desk|-01.71|+00.00|-00.37": [ - -1.0, - -0.5, - 270, - 30 - ], - "Drawer|-01.79|+00.10|-01.14": [ - -0.5, - -0.5, - 180, - 30 - ], - "Drawer|-01.79|+00.25|-01.14": [ - -0.75, - -0.75, - 180, - 30 - ], - "Drawer|-01.79|+00.39|-01.14": [ - -1.0, - -0.75, - 180, - 30 - ], - "Shelf|+01.31|+00.97|-02.30": [ - 1.5, - -1.5, - 180, - 0 - ], - "Shelf|+01.31|+01.17|-02.30": [ - 1.25, - -1.75, - 180, - 0 - ], - "Shelf|+01.31|+01.37|-02.30": [ - 1.25, - -1.75, - 180, - -30 - ], - "Shelf|+01.31|+01.57|-02.30": [ - 1.25, - -1.75, - 180, - 30 - ], - "Shelf|+01.32|+00.16|-02.30": [ - 0.75, - -1.25, - 90, - 30 - ], - "Shelf|+01.32|+00.46|-02.30": [ - 1.75, - -1.5, - 270, - 30 - ], - "Shelf|+01.59|+00.61|-02.31": [ - 1.25, - -1.75, - 180, - 30 - ], - "Shelf|+01.84|+00.97|-02.30": [ - 1.5, - -1.5, - 180, - 0 - ], - "Shelf|+01.84|+01.17|-02.30": [ - 1.5, - -1.5, - 180, - 0 - ], - "Shelf|+01.84|+01.37|-02.30": [ - 1.75, - -1.5, - 180, - -30 - ], - "Shelf|+01.84|+01.57|-02.30": [ - 1.75, - -1.5, - 180, - 30 - ], - "Shelf|+01.85|+00.15|-02.29": [ - 1.25, - -1.25, - 90, - 30 - ], - "Shelf|+01.85|+00.45|-02.30": [ - 1.25, - -1.5, - 90, - 30 - ], - "SideTable|+00.44|+00.04|-02.65": [ - 0.5, - -2.0, - 180, - 30 - ], - "SideTable|-01.82|+00.00|-01.14": [ - -1.0, - -0.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy deleted file mode 100644 index d6e9934a5c069b8d62bd8481899144452732f6d5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1808 zcmbW#p-#hK6o%n4$yL-9k_jLoA%tX8I0y!TA`9z+AdGYbL%0eqXt&Tyn4GMbKp+_O zJQGJUbMl_Q{ob$bKCf@DZtnJqx8l8;){BRxIxnk>*;zF#tJ%DHZ6?q6^JZHA?k^`# zi+a0XJWgKfEgu{ooes;B!(sVR{`0qA{QcTdKf7f=SBW>VU&nMEZqs?6QWU%M$iwpS zI-PfkH<_2wGp0VPV7WL?eeLzd-Urqf>x=cp`tCS-@#>3Rhx62Lw;%NztRL17>xVb# zetVugy$^dn%!m0fALh%sI8Q!%KHPbpn0(IpmHr^ZN$8vF={Pz6z{FooN>AUee=f^xaPyR3ei)C-b{Foo}V}8t!`7!@@ s@?(C?kNGh_=EwZFjpr@KOfiG`obzEm%!m1~yg}s4!}72^EN?LW0Vy~K!2kdN diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json deleted file mode 100644 index 3aed39397..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "LaundryHamper", - "BasketBall", - "Pillow", - "Box", - "Statue", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Mug", - "Bed", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json deleted file mode 100644 index 74d9722a3..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "Bed|-01.30|+01.94|+01.44": [ - -0.25, - 1.75, - 270, - 0 - ], - "Desk|-00.99|+00.01|-01.41": [ - -1.0, - -0.75, - 180, - 30 - ], - "Drawer|-01.41|+00.23|-01.30": [ - -0.75, - -0.5, - 270, - 30 - ], - "Shelf|+00.00|+00.01|+00.04": [ - -1.0, - -0.75, - 180, - -30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy deleted file mode 100644 index 0df7e536cd06e4bcfb2e6140507b7d48aca555e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1472 zcmbW#u}Z^G6o>J+`V`rskVzbh2;JNi7Y8Q^HpM}#B;r!~6h2U2A&=0pV}=YJt>*p$ zp3y9a@7#0#UvHDIyNBER$CKgH}Id&}O7Q8j(2i}Sp=7@rnpUW_O8Ydw6vpVXu3XMQ<+ znpT_n^l|u7ZG3okQs&1;W&V->_d3XauVueo*RyS}lIQ7ule`G_zWbhEhUeMyojv!* zIuG;qlv%b&bNjLLvHd!GFMQWNakXDJ@3#}SAKQxf$f4>*J8@w01AMAI| z(&cwx=j6Ehea-cp&SN-Nq>Sq0{pY^kT*3bG`KkH}x-8pA%A?s)T cte?B@rcQIKe%8Oe&5!wsO!Xi;`m*7-#35%uM)2l%lChX z`JYkc<5jxn*FdxhZ59z)AsP=>T;6A)DAKb@$ z%m?$qs@z=V>-Uk5D7bVe%@vRTBnrGR6cZH;s#flOa;#K*SW|V!R432rr?Rz{uF40|SFd z&(nl6+U4Z^{+##MhVXs&aC`rF6h6XdJ}DN@Wqy_A*VD_qpXJke`Cg7+pXTMH_^aQH zXNzK2U%ZUpiXER0&IkSM;;f&2W&eCm!v0we+jFyQ&vn98Ue(@``+WL*>%@ooFdyc_e3%dOtr8#R!+e+z^I<+*@x+tAs}I`>=EwY) zA2-Q9zrK?xB93^W!R+=hqL>?>qBj{~K5yT*v#dJXjtq508?#FKP z?bGe$QpNeD}Yn~#@*>$zpU>AroaeshVb8;!hdmE_9`-z3ykh5Y6*t27$q&h6@{~L$ z>*qQ3<2KG^{a8Qt9GtKExvwAV$NI5;tRF|M!uqj(tRL&g`tcn7SU=CDAM3~Zv3{%{ zJBRaCKlk-x{a8QNkM(2ySU=W}^<({5Ki1E4=*Rl8eykts$NI5zIbZd2Uq9B5^<({b zh@ThMkM-j*eO^EB>&N=ptsm>h`muhjAM3~Zu^pVR`nj(k4|lZ~>&HX%VEtG>9@FQi zWc_?zKRfkf{a8QNkM(2ySU=W}?c#jZ&;23#v3{%{>&N=Beykts$NJf&AM3~Zv3{%{ z>&N=Beyktc$@yx(j`p+tY(Lx2_OtzLKikh^d_UQKwx8|yeYcCC;Kd1d{Kikjtv;BOCJ#0VQ&-SzZY(Lw7Nc-7- zwx8{1`}q+2c}}+9`}VW_Y(Lvyx^jB?{bl>vezu?OXZv}M{cJzm&-SzZJfyEzpW^s$ zSN}I$#htLfTi*9~fXDRtDOs;3zMfv(_T}_yx_Vvo_1biC?c*BOs|oAHda+)t7wg4( zv0hx_#d@(`tQYIW`YgI~dg;S$U+=R%?B|I~`n*2g*N63CeOMpXhxOsQwiMQf^Q~l>+rHjseYi>Qmt=i>ULV$n^xcEjo787a zu?sv+$+BI2Hf6AVu=#ih_sv%qhcq|FKIHjzuM2g4cl9(M^Nab#{Ngd_`HjACjQq-X z$uH&?cWEBx7xRnx#r)#G{+Ta(Vmch7{p~@I=`lT~w>Lee$Ml%K3;%-YF+CpB`+HaO RF+HZo^!|Y!(_{L6_67EG(ZT=# diff --git a/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json deleted file mode 100644 index abcb8f2a2..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "BasketBall", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Poster", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Bed", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json deleted file mode 100644 index 586254660..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "Cabinet|-00.24|+01.53|-02.10": [ - -0.5, - -1.25, - 180, - 30 - ], - "Cabinet|-00.62|+01.53|-02.10": [ - -0.5, - -1.25, - 180, - 30 - ], - "Desk|-00.96|00.00|-01.94": [ - -0.5, - -1.25, - 180, - 30 - ], - "Drawer|+01.62|+00.16|-00.99": [ - 1.0, - -1.75, - 90, - 30 - ], - "Drawer|+01.62|+00.45|-00.99": [ - 0.75, - -1.5, - 0, - 30 - ], - "GarbageCan|+00.13|-00.03|-02.15": [ - 0.25, - -1.5, - 180, - 30 - ], - "Shelf|-00.96|+01.53|-02.10": [ - -0.5, - -1.25, - 180, - 30 - ], - "SideTable|+01.69|+00.00|-00.99": [ - 1.25, - -1.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy deleted file mode 100644 index 2cb922b71da809507481b3a1c9411bc8f03074aa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3760 zcmbW%ziJdw6bImI5RnkXzp1BNg{`(xL~tuRC5?rZEXf87F|sQ*;#2rQd4+j|lqsi} zB87!9bG`+CrQ2M-d*`0>JG06DdiVbA(T7{@d;2jvS#OUwvzOiM)#;1byqle#ZN6<* zUp}5~PS$_-->g1w*Vp^oPphx%Yd>8qp3l3*vw8Qk`_IpQyZKz4PwQ2!eRw);ZFm0q z-{&vFm*F8ihOffE!)+P;&L@wx%FEMfYur~omY3z_A)c4lxx6edd!Iw(WBItRek>o$ z$3r|nhUN3TJeQG&yM?}z1Q`B{D*iyf7pXF!yS$>wEckjRElwV)@S$>wE z)#Y5}w=X{r-gm9?JC~pR|FhpK9_#zi*L-X~HXoah&Byw1uI95p)Ld*nHXoah&Bx}` z$9!x)HXoah&Bx|reK}Y2**71XkIl#CW2?Hks&8L?R-e^p^|KD=s=j^oS$$UDJ$>18 zoU8iw)#ttC^o_B8?&-(+v3s1We)iS3uRg2K>a#kWtNP|rpVepeS$$UT_Oji4)MNEn zJ$C<2+-LXMeRltD+-LXMeKrq!e!uE@o}C}WIXk}>=d2%lU-#>I_gQ~-pZog#eNgvX zeYmgRL-zZ^-XF`u@~}KC5Bq!Ly~@SDcb5NQJy-D?%g^$&{477q&+@bUEI-T7^0WMp zB0tN|^0Ry_AIrz`v3x8a`#)j*9#>xdSU=W}^<({5{U=eM)o1lteO8~a-ucY_=ziyv5ch|S~C*du;SIf44?5c}cU9M(T9jn#4d+nN+hjq7XfA3#4&wYEm z-#;~*_UNGp2z0xi+OAwo5$v{d2AksMSkyj-lVXeUD3mOSPu_*Ki0!~SP$!AJ!5qU zelM(t_3)5;SP$!AJv>?XYrN`l)x&x?c^~M0!N^vq_D6Q-F*~O zy3OYe%=^G|wOOvWJ#|xeliGam%uJhkHZ_qp+1XuPa@w6;YQOVEa?EWz&kxDPwmcY5 zB0U;L`l0_lef2wa;qx65ehF>@S0Uk2u(v7I-H-hQ#!upd@xl1uGWcK;k4${b@xl1u zD)`}Aa3h$0*#pa@zncdiOg~INOg~INUfvt#Ians&&zydk{*DWO#U6byeK32lO!}D9 S2RHm5GW4^DA7&56SH&MW35^s0 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json deleted file mode 100644 index 31b0cedac..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json +++ /dev/null @@ -1,34 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Mug", - "Bed", - "ShelvingUnit", - "TennisRacket", - "TissueBox", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json deleted file mode 100644 index fa062d428..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bed|-01.74|+00.00|-00.07": [ - -0.75, - 0.0, - 270, - 30 - ], - "Desk|+00.63|+00.00|-01.56": [ - -0.75, - -1.5, - 90, - 30 - ], - "Drawer|+00.27|+00.16|-01.43": [ - -0.25, - -0.25, - 90, - 30 - ], - "Drawer|+00.27|+00.35|-01.43": [ - -0.25, - -0.5, - 90, - 30 - ], - "Drawer|+00.27|+00.55|-01.43": [ - 0.75, - -0.5, - 270, - 30 - ], - "Drawer|-00.16|+00.16|-01.43": [ - -0.75, - -0.25, - 90, - 30 - ], - "Drawer|-00.16|+00.35|-01.43": [ - 0.5, - -0.25, - 270, - 30 - ], - "Drawer|-00.16|+00.55|-01.43": [ - 0.25, - -0.5, - 270, - 30 - ], - "Shelf|+01.41|+00.18|-01.51": [ - 0.75, - -0.25, - 90, - 30 - ], - "Shelf|+01.41|+00.38|-01.51": [ - 1.0, - -0.5, - 90, - 30 - ], - "Shelf|+01.41|+00.57|-01.51": [ - 1.0, - -0.5, - 90, - 30 - ], - "Shelf|+01.54|+00.49|-00.48": [ - 0.75, - 0.0, - 180, - 30 - ], - "SideTable|+01.56|+00.00|-00.47": [ - 1.0, - -0.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy deleted file mode 100644 index f10c008a9a66b66ee3094394f56b5cc292d50f9a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1200 zcmbW!uTH~Y6o=t&lUzmJ2T2uT5JJKf4uV0TNW;1y$VOU%AzTF)v|HFEOioTzAP@}N zM{p!HC-3R+&*}DYeS39tH%hPREzj!qp~+`OKA)fFvdHsg^U_p{`(-n$fA*KvQ(N!% z?PK*^@A+_YQWnQYW$|A8_c=(v&-S99-Kw9vz+K?az+Zvo?N)#Duskde%fs@vArH&L z^6+}NZ!`Eef#rMe`>}j1AG;UpTZcZZ59`C-a39u(^Q-9?Y-F}=I#F+Fx4<~R8;<^9Q|NrwkbdQAU)M%DVMUw-FanOnh|!P~{VW!Ay&``mqYe<$2$_t|}}%01Q_ zg&ym%9_#VfbG3f>Gx#I;J@_s7HQ2spUG`@CvVGaUY+tr7+n4Rj_GSCBY0o(A>)gI< zU$!sXm+i~;W&5&yS>Imztk3$a&-$$Icj~h~>$5)Vv%ddLpY>Uv^;w_wO?}p9eb#4v zHg)6FcdpO+tk3$f!*S|6*Jpj!chC2-_c%^{=lZPgJ$=?^_c%^{=lag|S)cV;hyUg` D0lgP8 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json deleted file mode 100644 index 67d605fac..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Mug", - "Bed", - "TableTopDecor", - "CoffeeTable", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json deleted file mode 100644 index 9d1fe11f2..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "Bed|-02.98|+00.01|-01.18": [ - -1.75, - -1.0, - 270, - 30 - ], - "CoffeeTable|-00.50|+00.01|-03.99": [ - -1.0, - -2.5, - 180, - 0 - ], - "Desk|-00.86|+00.01|-04.03": [ - -0.75, - -3.25, - 180, - 30 - ], - "Drawer|-00.50|+00.07|-03.80": [ - -1.25, - -2.5, - 90, - 30 - ], - "Drawer|-00.50|+00.23|-03.80": [ - -1.25, - -2.75, - 90, - 30 - ], - "Drawer|-00.50|+00.39|-03.80": [ - -1.25, - -2.75, - 90, - 30 - ], - "Drawer|-03.61|+00.11|-03.26": [ - -2.25, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.11|-04.06": [ - -2.25, - -3.25, - 180, - 30 - ], - "Drawer|-03.61|+00.30|-03.26": [ - -2.75, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.30|-04.06": [ - -2.5, - -3.25, - 180, - 30 - ], - "Drawer|-03.61|+00.49|-03.26": [ - -2.5, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.49|-04.06": [ - -2.5, - -3.25, - 180, - 30 - ], - "Drawer|-03.61|+00.69|-03.26": [ - -2.75, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.69|-04.06": [ - -2.75, - -3.5, - 180, - 30 - ], - "Drawer|-03.61|+00.88|-03.26": [ - -2.75, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.88|-04.06": [ - -2.75, - -3.5, - 180, - 30 - ], - "Dresser|-03.65|+00.01|-03.66": [ - -3.0, - -3.5, - 270, - 30 - ], - "GarbageCan|-01.84|-00.02|-03.90": [ - -2.25, - -4.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy deleted file mode 100644 index 6d83f59eb4e355ad5d0e7f104faadc30d538014d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1056 zcmbWzu}Z^G7>42F>Q!Vr3Yi3-pY!=jtDKl7{Rxo>y# z{;7FwcYJa_sjIWox>{BLeU8)bv;N%YSIHsp{%uN!_tU@UH|6}cq&}<<>%&9o!|TBM z$Iy@UWBph^){i&EhsVJD()Zz^?1lL;Kjz2$m>)~tnEdAam>=_Fe$0>gqX)<2Kg`Sj s#Qc~a^W$x}Zyz3eV)t-N|HIrq*gn`k*gjb5jj7*UKOTKwN&Un08!2+Cy8r+H diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json deleted file mode 100644 index 98fd21897..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "Desktop", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "HousePlant", - "Laptop", - "Bed", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json deleted file mode 100644 index bf39297e3..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Bed|-01.70|+00.00|-00.45": [ - -0.75, - -0.25, - 270, - 30 - ], - "Desk|+00.62|+00.00|-01.51": [ - 1.0, - -1.0, - 90, - 30 - ], - "Drawer|-00.56|+00.16|+00.46": [ - 0.25, - -0.25, - 0, - 30 - ], - "Drawer|-00.56|+00.46|+00.46": [ - 0.0, - -0.25, - 270, - 30 - ], - "GarbageCan|+01.66|-00.02|-00.39": [ - 1.0, - 0.0, - 90, - 30 - ], - "Shelf|+01.62|+00.56|-00.80": [ - 0.25, - -1.5, - 90, - 0 - ], - "SideTable|-00.56|00.00|+00.53": [ - 0.0, - 0.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy deleted file mode 100644 index 8fb312dceb153889f4dd5423cd0fb302f6383aad..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1680 zcmbW$uTH~29Ki8nd5XG1GKJw!Na}D93<5(h&^dDR`j0LLXsrvZA75f>vr z%{O6x_qD!D>)z96eb#6Da2)l`>$AS+^jV+VbY9kH`*Ixh&Fh=jXMJu{pY>UvbvTat zO*yRSvp(yyKI^kS>$AS!xjuJ(AL)Gh*7aGR^;w_w{jc;{pY>Uv^;w_wS-%b6KkKtT Z>$5)VvpzSz*EBkp^*DCn`963z`Ui(uBv$|c diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json deleted file mode 100644 index 0f7129662..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "LaundryHamper", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Poster", - "Pen", - "Cloth", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Mirror", - "Floor", - "Safe", - "Laptop", - "Bed", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json deleted file mode 100644 index 8145411a3..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "Bed|+01.38|+00.00|+00.07": [ - 1.5, - 1.0, - 180, - 30 - ], - "Drawer|+00.41|+00.11|-01.63": [ - -0.5, - -0.25, - 90, - 30 - ], - "Drawer|+00.41|+00.29|-01.63": [ - -0.25, - -0.5, - 90, - 30 - ], - "Drawer|+00.41|+00.49|-01.63": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|+00.41|+00.68|-01.63": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|+00.41|+00.87|-01.63": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|-00.39|+00.11|-01.63": [ - -1.25, - -0.25, - 90, - 30 - ], - "Drawer|-00.39|+00.29|-01.63": [ - -1.25, - -0.5, - 90, - 30 - ], - "Drawer|-00.39|+00.49|-01.63": [ - -1.0, - -0.75, - 90, - 30 - ], - "Drawer|-00.39|+00.68|-01.63": [ - -1.0, - -0.75, - 90, - 30 - ], - "Drawer|-00.39|+00.87|-01.63": [ - -1.0, - -0.75, - 90, - 30 - ], - "Dresser|+00.01|+00.00|-01.68": [ - 1.0, - -1.25, - 270, - 30 - ], - "GarbageCan|-02.21|-00.02|-01.74": [ - -1.75, - -1.25, - 270, - 30 - ], - "Safe|+01.64|+00.00|-02.04": [ - 1.0, - -1.25, - 90, - 30 - ], - "SideTable|+02.24|00.00|+01.33": [ - 1.75, - 1.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy deleted file mode 100644 index 998979a6b0345090aaf7d62dee99b1c068d3b895..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1632 zcmbW$u}Z^G6b9g{h!me9TNE;hgNo2hZiMP_CI(E#Ep@W09 z$+w)*ESK;0p8vlI^!xVy=I&uHeWcHPS}mUH{4&e0X6Jd4<+FMHUQb>h=k>Ju+rOT? zEUNAP;(78`ZGC)kR%E9qMfR2b_c=O^SRTt`c`UC9c`T3RvHAXMrR00Dc{a~hIdPR|UmmyN z-oBGL@5%1X`dKc=Rlj}b<37i=9rum)yI^_F>0xsm*Jj9*Yo5)sd3N6a!g+R{o&O2% z!OpY$rLzAH=2;(`XY>1Ep3Sp)_MYrL*gaX_L78@s`?5aP$NE?w>tlU~p^x>kKGw(j USRd;fg+A8D`dA<9V|}CY7Xp6Z6aWAK diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json deleted file mode 100644 index 8d246757f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "ArmChair", - "TennisRacket", - "Shelf", - "Dresser", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json deleted file mode 100644 index 3f9814429..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json +++ /dev/null @@ -1,158 +0,0 @@ -{ - "ArmChair|+01.71|00.00|+01.53": [ - 1.5, - 2.25, - 180, - 30 - ], - "Bed|-00.87|+00.01|-00.92": [ - 0.25, - -0.75, - 270, - 30 - ], - "Cabinet|-00.65|+00.27|+02.25": [ - 0.75, - 1.5, - 0, - 30 - ], - "Desk|+01.81|+00.00|-00.01": [ - 1.25, - -1.0, - 90, - 30 - ], - "Desk|-00.66|+00.01|+01.81": [ - 0.25, - 2.0, - 270, - 30 - ], - "Drawer|+01.69|+00.16|-00.38": [ - 0.5, - 0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.16|-00.81": [ - 0.5, - -0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.35|-00.38": [ - 0.5, - 0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.35|-00.81": [ - 0.75, - -0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.55|-00.38": [ - 0.75, - 0.0, - 180, - 30 - ], - "Drawer|+01.69|+00.55|-00.81": [ - 0.75, - -1.25, - 0, - 30 - ], - "Drawer|-00.55|+00.16|+02.94": [ - 0.25, - 2.25, - 0, - 30 - ], - "Drawer|-00.55|+00.38|+02.94": [ - 0.25, - 2.25, - 0, - 30 - ], - "Drawer|-00.55|+00.57|+02.94": [ - 0.25, - 2.5, - 270, - 30 - ], - "Drawer|-00.55|+00.58|+02.25": [ - 0.25, - 2.75, - 180, - 30 - ], - "Drawer|-00.66|+00.23|-01.31": [ - 0.5, - -0.5, - 180, - 30 - ], - "Drawer|-00.66|+00.55|-01.31": [ - 0.25, - -0.75, - 180, - 30 - ], - "Drawer|-00.66|+00.83|-01.31": [ - 0.25, - -0.75, - 180, - 30 - ], - "Dresser|-00.67|+00.00|+02.94": [ - 0.25, - 2.5, - 270, - 30 - ], - "GarbageCan|+02.02|-00.04|-01.24": [ - 1.5, - -1.5, - 90, - 30 - ], - "Shelf|+01.77|+00.18|+00.76": [ - 0.5, - 0.25, - 0, - 30 - ], - "Shelf|+01.77|+00.18|+00.94": [ - 0.5, - 0.5, - 0, - 30 - ], - "Shelf|+01.77|+00.38|+00.76": [ - 0.75, - 1.25, - 180, - 30 - ], - "Shelf|+01.77|+00.38|+00.94": [ - 0.75, - 0.5, - 0, - 30 - ], - "Shelf|+01.77|+00.57|+00.76": [ - 0.75, - 1.25, - 180, - 30 - ], - "Shelf|+01.77|+00.57|+00.94": [ - 0.75, - 0.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy deleted file mode 100644 index 5d5660830bfc55bf6e7fb23ecc3720fa4ffb1095..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1680 zcmbW!ElvYb6o%nTC94=WkW^v#2}!GP5DWrE8af0)D47xrVHGT>TbLzOR#uFtsGxA~ zQ*k6?PTqTF-hAKO@0+{p+xvs`kv{8bGkkhSI;)3O{WNRe+sW(0terN$=U0=L zd9yp8KTqD89Uq;a4y%*nVf9u0_c=^|&vKOKc9CaScvILOuj0PE*O%D^&eoLn`|>^J z$NYF5-tPl%0&fGSaZbQD2)tb6{klx~ao(ncyW+?4WBIZCxDVgUZ!bTVAIpzdCAX;$ z?!sQ5{l4VE`e1#qKDZCx>tnAE)(7i@-IE@AV(;NN^>wZx=cp`eJ=C zpPYP{5A$I@%%^8x?gR5-KFo*ty5ix(e3%dO;dSx&&wQ8<^I<;B=brd5ALhe+n9t>tDDQ~+r8qoc&p}Zf8SMSWp%zdt?IH`EW4MkdAeJ6^Y&~1qIvAw z-G2YjJhwX^9G}$X(P3S_m;b%?i|=cgO>0_B>pJr$^O!khHg8=0p2y~~d7NS%JHLr} z&a?Bpjpy0(>v*1ru)b5xF1XZb9j<#4{rALBd9XZb9jq$$MRV|%V+tV UVxIrOnA!JmUmqT_^ZIOOp9X=z82|tP diff --git a/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json deleted file mode 100644 index 36b55cead..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "Curtains", - "BasketBall", - "Pillow", - "Pencil", - "SideTable", - "KeyChain", - "GarbageBag", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "Dumbbell", - "DeskLamp", - "Footstool", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Bed", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json deleted file mode 100644 index 4461adc3d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "Bed|-01.04|+00.01|-00.69": [ - -0.5, - 0.25, - 180, - 30 - ], - "Desk|+01.52|+00.00|+00.39": [ - 0.75, - 0.5, - 90, - 30 - ], - "Desk|-01.72|+00.00|+00.92": [ - -1.0, - 1.0, - 270, - 30 - ], - "Shelf|-01.70|+00.16|+01.54": [ - -0.5, - 0.75, - 0, - 30 - ], - "Shelf|-01.70|+00.38|+01.54": [ - -0.5, - 0.75, - 0, - 30 - ], - "Shelf|-01.70|+00.57|+01.54": [ - -0.75, - 1.0, - 0, - 30 - ], - "Shelf|-01.84|+01.08|+01.24": [ - -1.25, - 1.5, - 270, - 30 - ], - "SideTable|+00.63|+00.00|-01.71": [ - 0.25, - -1.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy deleted file mode 100644 index 47b25677080275d02a7ad4d0d6c6cf0bced364f2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1600 zcmbW$u};E39KhkTA;$0&-Kq%_lNu8`xoKP+oD7i?1|y~z7vod-K=KGY0wW_s2L=Yw zyKlMCE|;(E{r;uE*X{ky-NR9M4#-i|aXUv^;v(F^;w_wS)cV; zKfbjPydTzQeb#4v)?ba{nWBy>>$5)Vvp(yuvp(yyKI^kS>-(L1e%5Dw)@Oaz-)7Ix c`mE3Ttk33jsqg>C{(tQAvH5I1o7atg0H)fy0{{R3 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json deleted file mode 100644 index 8749b01dc..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Bed", - "ArmChair", - "TissueBox", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json deleted file mode 100644 index 6efd3c144..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "ArmChair|+00.85|00.00|-02.14": [ - 1.5, - -1.75, - 270, - 30 - ], - "Bed|+00.91|+00.00|+00.14": [ - 0.75, - 1.25, - 180, - 30 - ], - "Desk|+03.24|+00.00|-01.59": [ - 3.0, - -1.0, - 180, - 30 - ], - "Drawer|+00.33|+00.62|+01.30": [ - 1.5, - 1.25, - 270, - 0 - ], - "Drawer|+00.33|+00.62|-01.02": [ - 1.5, - -1.75, - 270, - 0 - ], - "SideTable|+00.28|+00.00|+01.30": [ - 0.75, - 1.25, - 270, - 30 - ], - "SideTable|+00.28|+00.00|-01.02": [ - 0.75, - -1.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy deleted file mode 100644 index d55bd506cbc30551aafd5e5009bd845a49075629..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1792 zcmbW$u};EJ6b9fcqfgPTnlPwwFvbKXH;s#flOa;#K*SW|Vtfi8h*#(%Ffw-N;J_f- z`_+y-~S zpTXN;dFGJE@>m|rV|ku~JeJ4uSRTvs9Obb*mdElqjr-@z@|#t^FQ4VJe3sAhd64^9 zU*DFJKJN1G!}?es>*K-Lr+(Gf&(aIWAkv6=V9}(dDuK`9*(Q~x9|S9qb~?*2~Yq4 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json deleted file mode 100644 index 43380c052..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Curtains", - "Pillow", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "Cloth", - "CreditCard", - "Book", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "ArmChair", - "Shelf", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json deleted file mode 100644 index ab36ff242..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "ArmChair|+02.57|+00.00|-00.82": [ - 2.0, - -0.5, - 90, - 30 - ], - "Bed|-00.75|-00.02|+00.11": [ - 0.75, - 0.0, - 270, - 30 - ], - "Cabinet|+02.48|+00.50|+01.00": [ - 1.75, - 0.25, - 0, - 30 - ], - "Cabinet|+02.48|+00.50|+01.01": [ - 1.75, - 1.75, - 180, - 30 - ], - "Cabinet|+02.48|+00.50|+02.03": [ - 1.75, - 1.25, - 0, - 30 - ], - "Cabinet|+02.48|+00.50|-00.02": [ - 1.75, - 0.75, - 180, - 30 - ], - "Drawer|+02.57|+00.90|+00.23": [ - 2.0, - -0.25, - 0, - 30 - ], - "Drawer|+02.57|+00.90|+00.75": [ - 2.0, - 1.0, - 180, - 30 - ], - "Drawer|+02.57|+00.90|+01.26": [ - 2.0, - 1.0, - 0, - 30 - ], - "Drawer|+02.57|+00.90|+01.78": [ - 2.0, - 1.5, - 0, - 30 - ], - "Drawer|-01.53|+00.46|+01.48": [ - -1.0, - 1.5, - 270, - 30 - ], - "Drawer|-01.53|+00.46|-01.25": [ - -1.0, - -1.25, - 270, - 30 - ], - "Dresser|+02.82|+00.00|+01.01": [ - 2.25, - 0.75, - 90, - 30 - ], - "GarbageCan|+01.35|+00.00|-01.69": [ - 0.75, - -1.0, - 90, - 30 - ], - "Shelf|-01.55|+00.04|+01.33": [ - 0.0, - 1.5, - 270, - 30 - ], - "Shelf|-01.55|+00.04|+01.60": [ - -0.5, - 1.5, - 270, - 30 - ], - "Shelf|-01.55|+00.04|-01.13": [ - -0.5, - -1.25, - 270, - 30 - ], - "Shelf|-01.55|+00.04|-01.40": [ - 0.0, - -1.25, - 270, - 30 - ], - "SideTable|-01.60|+00.00|+01.48": [ - -1.0, - 1.5, - 270, - 30 - ], - "SideTable|-01.60|+00.00|-01.25": [ - -1.0, - -1.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy deleted file mode 100644 index 0add409d466e1b9f7b3b2198c7ab57455ca4ff83..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3184 zcmbW&u}ULB7{Kvy5jpNDwp)cXTAd=em7QX9#Z?kCVj(Jt*oaTz1G$f|k6>xJ#THwn zFvraAz^}X%PJRDv#|hKQWKZWAoTNHjmBYb(znp z&2#@bGgV!FqKEac9@fKpSP$!AJzTZ9gR?e2yZlTa>tlVakM*%W*2ns|YI6q{rS*G$ zrjPZpKGw(jcq-o?>tlUfwYh_{Qkp^^>tlVakM;3X`gk3z&+GbF-x&H>AM4|x%wv75 zkIfsxJT{NbWAk_{^VvN1d9dFbe+PX}>~mq=>>Q4(zo+*5a!+=D?n^(rKf6D>Kab)4 z?(cQ?XZP3X{_Otj{_OtjT#l>z+joCtQ`SmhXf0 zupYMRh^rp^dRPzZ;j#3v9@fKp;#`ia9{YND@OhL~kJt6E9@Z7-a9qu|Z$6vP=Ck`d z$9&es-p6q@-@f^5KAZ1-=Ck>1K0AlwYQBB*+2_yxe{j|2BG&6%z1)ZIU9Z>mvU54E fdhP3Fy{wn@IY%GsV|}cToy&36XI~%dn@+v}36aM& diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json deleted file mode 100644 index 52144cfd1..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Sofa", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Safe", - "Laptop", - "Mug", - "Bed", - "Dresser", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json deleted file mode 100644 index e202bfd8c..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bed|-01.61|-00.03|-01.86": [ - -1.5, - -0.75, - 180, - 30 - ], - "Desk|+02.32|-00.01|-03.22": [ - 2.0, - -2.5, - 180, - 30 - ], - "Drawer|+01.98|+00.21|-02.99": [ - 1.25, - -2.5, - 90, - 30 - ], - "Drawer|+01.98|+00.49|-02.99": [ - 1.25, - -2.5, - 90, - 30 - ], - "Drawer|+01.98|+00.73|-02.99": [ - 1.25, - -2.5, - 90, - 30 - ], - "Drawer|+02.64|+00.17|+01.51": [ - 2.0, - 1.0, - 0, - 30 - ], - "Drawer|+02.64|+00.45|+01.51": [ - 2.0, - 1.0, - 0, - 30 - ], - "Dresser|+02.68|+00.00|+01.51": [ - 2.25, - 1.5, - 90, - 30 - ], - "GarbageCan|+01.34|+00.00|-03.38": [ - 1.0, - -3.0, - 90, - 30 - ], - "Safe|+02.72|+01.23|+01.78": [ - 2.25, - 1.5, - 90, - 0 - ], - "SideTable|-02.42|00.00|-00.51": [ - -2.0, - -0.5, - 270, - 30 - ], - "SideTable|-02.42|00.00|-03.15": [ - -2.0, - -3.0, - 270, - 30 - ], - "Sofa|+02.38|+00.01|-00.29": [ - 1.5, - -0.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy deleted file mode 100644 index 02f4fc67b619400618029e51b4123a4047667b80..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1552 zcmbW#y-LGS7=YoUh=^B_Eef5Sst9#*Q(PRJq}YgqSV_f2yb3R6bS@U)Q%+H+MVfJ$;m;YVuH*XGMAb*e`oU`8clM>fy`%xE@u%=P!rP zlWKi_@-%#{);{W=_KK6^Uh!G{_c%;{$70&8>APFo;Cb*YxCzeFl6lQwd;TnV9^3}& zTTQq7SRdtlVakM*(rI_+os*?!-F{cJzm?>_Bk z`+1SyFE4}5^PJ3M^VmE#k5_pt*vB?=i1zKAX?xv-xbkRX?}+dTjp2)2`J2+F;+I-+dR{g#GS& R^LxHNyDrC7uk(86gCBu)^&tQN diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json deleted file mode 100644 index 00fe94151..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "VacuumCleaner", - "CellPhone", - "DeskLamp", - "Drawer", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "ShelvingUnit", - "TennisRacket", - "Shelf", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json deleted file mode 100644 index 18df29209..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "Bed|-00.84|00.00|-00.36": [ - -0.75, - 0.75, - 180, - 30 - ], - "Drawer|+01.60|+00.09|-01.46": [ - 0.5, - -0.75, - 180, - 30 - ], - "Drawer|+01.60|+00.09|-02.20": [ - 0.25, - -1.5, - 180, - 30 - ], - "Drawer|+01.60|+00.25|-01.46": [ - 0.0, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.25|-02.20": [ - 0.0, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.41|-01.46": [ - 0.5, - -0.75, - 180, - 30 - ], - "Drawer|+01.60|+00.41|-02.20": [ - 0.5, - -1.5, - 180, - 30 - ], - "Drawer|+01.60|+00.57|-01.46": [ - 0.25, - -2.0, - 90, - 0 - ], - "Drawer|+01.60|+00.57|-02.20": [ - 0.25, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.73|-01.46": [ - 0.5, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.73|-02.20": [ - 0.5, - -2.0, - 90, - 0 - ], - "Dresser|+01.63|+00.00|-01.83": [ - 1.0, - -1.75, - 90, - 30 - ], - "GarbageCan|+03.38|+00.00|+00.22": [ - 2.5, - -0.25, - 0, - 30 - ], - "Shelf|+00.02|+00.18|-02.51": [ - -0.5, - -1.5, - 90, - 30 - ], - "Shelf|+00.24|+00.34|-02.51": [ - 0.75, - -1.75, - 270, - 30 - ], - "Shelf|+00.25|+00.67|-02.52": [ - 0.75, - -2.0, - 270, - 30 - ], - "Shelf|+00.36|+00.18|-02.51": [ - -0.25, - -1.5, - 90, - 30 - ], - "Shelf|+00.47|+00.34|-02.51": [ - 0.0, - -1.75, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy deleted file mode 100644 index 56831d6298ed3e097660d18a1df40c23b83aca2c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3040 zcmbW&F-{vn6b9glg(8FyO5zJ_w;;K}6^fAJDjg9GMJi-rTNDV89i>4zMGj<+ut%VD zxy2SPTm+c;EcumjGx~NsZ~x!e%ikYY7neUjq~GbOo=g`v^ZIL5pU=+fK~>Kl=D+6S z`|F4KWcqgf`}l4#eZ9W89Y0QAeSCU098|-TLG`El&(}eEf4wa8x+!ZDoOe^&?tj~T z|4Z;H*!*>wYd)LLO*zlzv-xa(7v{71Y(AUM=5t%}a2LD|-UO#nPT+hmcrW;4@P647dIsz>(BbL{@jK0`rFr^_2*v6%lfnatUv3|`g2oyuR?#;pY><`S%2y#QSnw<#AmeZhanQmB+q3EDy`$K60}6aa`qby)8Ld z9+rpYVR_7zhvi}CIIi-zE)UDY^04o1NXOY zp68f(Y#y7(&U@}T&(5>wl;@)J>^wWa^>e<`8|8Jg-1R!R3vPquF;5)p=Q6OwX!8SxslnTQhojm^I_c&-JU( z^L(G7caEdTjA48NbvBF=srXHm!5Z{zIMarWCdi!^&_hRnNk zp8MO(U1q;;{W`n9%Dl`RQ-xsv@-klGQ2%w2SwHLbGxcNrSU=W}^<({5Kh}?9`Vd$@ z){pgL{n*qipZdA3AM3~Zv3{%{>&N=Beykts$Gtk8(8ejR9?oOuaZ$&8>^yd!={$BG zo1T;PY&~1=Ia<%F^nYgi*?!O6ezu?2={(+K?lNyP?=s8dJbAo#c~~Bnhvi{;SRR&# z4m;IYnI|slxClBfV{o?o8eoV9YoaQEQ3hew>UUwclkGHeQi|voR`Sm#E z^LP_jeh7IikL9s^AM#ip%VXbzQ}*~T`Ev@)hxxF)|0s{;u{_oX^O<~@5A$I@Z1Tj( zXPpo8VZNBdaq?N`!+g$p4|Wd6DbFj9<*_`DldsSBmJjn`KFo*X9P)h|vcC`PUfFjq pa0=)3``gc6tRL17>xcClLqDt^)(@xL59^0h_G108eptV8_64mfLl9g=T_LFfK?osP6%K+ypvc0yOb|v|f+1W57qna0B~(sUOdt>p zdVWiGB*%Pv&Y$o3-tP0}?)vtAFT92KVp6w{O>vPIm(%m2%!}!~d2Pne5A$YH|L$Ln zpW1q}-_FJ_^@fkmPRjiBxXeHD|E|OEx7MSf_KTr@CH$RmsCMrkB&^>m>4){h`r$10 z!}|&IIp^yVALhe+m=E(|KFqgFe3%dOVLr@<`S3b^{}7k|2lHV*oK=1emCr68mU9`s z=D_aZw07Rbx=OfDSU!E^!}4MIa8?ZyVfnCpSibF?i{U*UCpo_x;b S!}4MIa8~WkC!cfqy3r3)Rg?Pw diff --git a/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json deleted file mode 100644 index 1a17b7f1a..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "Dumbbell", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "HousePlant", - "Laptop", - "Mug", - "Bed", - "TennisRacket", - "TissueBox", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json deleted file mode 100644 index 742c72d37..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Bed|+00.23|00.00|-00.95": [ - 1.25, - -1.0, - 270, - 30 - ], - "Desk|+02.50|+00.00|-01.60": [ - 2.75, - -1.0, - 180, - 30 - ], - "Drawer|+01.24|+00.13|-01.55": [ - 1.75, - -0.5, - 270, - 30 - ], - "Drawer|+01.24|+00.35|-01.55": [ - 1.75, - -0.75, - 270, - 30 - ], - "GarbageCan|+03.17|-00.01|-00.26": [ - 2.5, - 0.25, - 180, - 30 - ], - "Shelf|+03.03|+00.64|-01.58": [ - 2.5, - -0.75, - 90, - 30 - ], - "SideTable|+01.24|+00.00|-01.55": [ - 2.0, - -0.75, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy deleted file mode 100644 index 2328b0b89d500347af2954dd40046c6b4fb53b70..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1536 zcmbW!p-#hK6hPr(d5XG1QiW;=Nl~~F3<51LtC8Z#l^fT%Dk8_+Shjae7|UC&CmX7`m}8J z`{m>GrP=dIRh9YKX_a|3nSG6O2)qrv3!GgZzR$N?9r`dI=EHoLZyS7= z5A$I@%r^ud=EHoL5BKT+=z|aQVLr@<`8L6a`7j^m!@OPc+2c6Z={fuKbu+xK#|`cR zZvyM_{1EQzabFMCgY`J49_%?Br=GukIuF)^^^&T( z?_;kA>%n^Pkb1BltOx7CdYnTK)`Rt69vr70dp)@KJ<`%shfw@+TokNGh_ H=I`on>on)? diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json deleted file mode 100644 index 96fb14e54..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "Shelf", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json deleted file mode 100644 index 549094674..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "Bed|-00.12|00.00|-01.70": [ - 1.0, - -1.75, - 270, - 30 - ], - "Desk|-00.28|00.00|+00.83": [ - -0.75, - 0.25, - 0, - 30 - ], - "Drawer|+00.95|+00.17|-02.39": [ - 1.5, - -2.0, - 270, - 30 - ], - "Drawer|+00.95|+00.46|-02.39": [ - 1.5, - -2.0, - 270, - 30 - ], - "GarbageCan|+02.47|-00.03|+00.94": [ - 2.0, - 0.5, - 90, - 30 - ], - "Shelf|-00.28|+00.10|+00.83": [ - 1.25, - 0.25, - 0, - 30 - ], - "Shelf|-00.28|+00.35|+00.83": [ - 1.5, - 0.5, - 270, - 0 - ], - "SideTable|+00.95|+00.00|-02.46": [ - 1.5, - -2.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy deleted file mode 100644 index 7a63bb699dd8cc91bd1229f78cf5b331ecdecbff..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2240 zcmbW%Jx*Iu5QgEy6{5&0Zg&&OO-K`=NZg8!C=CTwWCbG%6p$U!AXdSGoF&{PP*S>Z z;esNBGtZGSWll4G=jWUGEX$8y&rZLc@0Gi9KU^$UKbFH$KYY3TJk0vx@@DyKIsf_n zW_hvrn?IRfuNJTQ)z$oV@yhQ%emb1>haYDBL;s)eU3q((b&UtVYkW?uzMtw?y-Rhh zUQ!*azr?V^q-PGrjO}k`j|eZ|D5zOeN4Zxxrp|u+lRO7>UR_U_G8~4wjbM%t6C{|q8qXK z40eb99JgtHm-r=d8UOXuCFb9r?Yj22J&E~O=O0h0zp9ne>Tw_DAM=mfU1?68f6PDj zKiT@?KD2B6c>fg^V#*g!Q z^ZEQ?{9JE*aC}-7M~7AMUi|kNr0vsfckjh;_wEFz;PvO<-(LkUgBQX3xwjndI)mVT za4*$840f8T!AXMNUZeb(=V ZKBqQqAJ%7m)@S{G=(9fSvp(zhM?dB_q@(}< diff --git a/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json deleted file mode 100644 index 60ee2f021..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Bread", - "Sink", - "DiningTable", - "Floor", - "HousePlant", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json deleted file mode 100644 index b61a84d71..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "Cabinet|-01.00|+00.39|+00.73": [ - -1.75, - 1.5, - 90, - 30 - ], - "Cabinet|-01.73|+00.39|+00.73": [ - -2.0, - 1.5, - 90, - 30 - ], - "CounterTop|-00.52|+01.16|+00.49": [ - -1.0, - 1.0, - 90, - 30 - ], - "CounterTop|-02.28|+01.16|+00.38": [ - -1.75, - 1.0, - 180, - 30 - ], - "CounterTop|-03.86|+01.16|+00.38": [ - -3.25, - 1.25, - 180, - 0 - ], - "DiningTable|-00.62|+00.02|+02.49": [ - -1.25, - 2.5, - 90, - 30 - ], - "Drawer|-02.04|+00.22|+00.59": [ - -1.5, - 1.5, - 270, - 30 - ], - "Drawer|-02.04|+00.61|+00.59": [ - -2.5, - 1.25, - 90, - 30 - ], - "Drawer|-02.04|+00.94|+00.60": [ - -1.5, - 1.0, - 270, - 30 - ], - "Drawer|-02.50|+00.22|+00.59": [ - -3.0, - 1.5, - 90, - 30 - ], - "Drawer|-02.50|+00.61|+00.59": [ - -3.0, - 1.25, - 90, - 30 - ], - "Drawer|-02.51|+00.94|+00.60": [ - -2.0, - 1.0, - 270, - 30 - ], - "Fridge|-03.52|+00.00|+02.72": [ - -2.5, - 2.75, - 270, - 30 - ], - "GarbageCan|-03.70|+00.00|+02.01": [ - -3.5, - 1.5, - 0, - 30 - ], - "Microwave|-00.37|+01.11|+00.43": [ - -1.0, - 1.0, - 90, - 30 - ], - "Sink|-01.39|+00.98|+00.44|SinkBasin": [ - -1.25, - 1.75, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy deleted file mode 100644 index 8e4a04103feacbfd316e141080638154d285734a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1616 zcmbW#u};EJ6oBE{kj5AuqFXg#(nXDlo!m4o4o-$hiGvYSjEnIpd?5P>K7u170|Ntt z2a?uR#>ds5tj3e}r5!%qP1;fOd;eni zIBnMVrw_yDX6^lxqd|FiFeu;4|6Y69=IV9Z^Xq(j=83b!tIxmRUnbW3PI|1zdaTDq z%%4S1pY6-~tk3$qi2YfAp6t*1tk3$qh(7Btl0NIRKI^kS>o1c&>$5)Vvp(yul0NIR zJ}=|h1r``(=IBXMNUZ|EE0qy)N5ac^zjLXV|pFIy3(J!L!dDuM8lJA@6bMx3dp2z!R^LLZ^oX0#ipUr3U*?cyiXR#04XD``@ i?ZftA`>=i3K5QSh4|^Z|*vEV}kIiHA*gQ6`U;hA}V9Xo< diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json deleted file mode 100644 index 233e0276d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "PaperTowelRoll", - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "LightSwitch", - "Sink", - "Floor", - "SoapBar", - "HandTowel", - "Shelf", - "ShowerHead", - "Bathtub", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json deleted file mode 100644 index bfe92af8f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "Bathtub|-00.21|+00.36|+00.92|BathtubBasin": [ - -1.25, - 1.75, - 90, - 30 - ], - "GarbageCan|+00.05|00.00|+03.88": [ - -0.75, - 3.25, - 0, - 30 - ], - "Shelf|-02.59|+00.78|+03.91": [ - -2.25, - 3.0, - 0, - 0 - ], - "Shelf|-02.59|+01.03|+03.94": [ - -2.5, - 3.25, - 0, - 0 - ], - "Shelf|-02.59|+01.29|+03.94": [ - -2.5, - 3.5, - 0, - 0 - ], - "Shelf|-02.59|+01.53|+03.91": [ - -2.5, - 3.5, - 0, - 30 - ], - "SideTable|-03.17|+00.00|+00.17": [ - -2.75, - 0.75, - 180, - 30 - ], - "Sink|-03.12|-00.01|+01.53|SinkBasin": [ - -2.5, - 2.0, - 180, - 30 - ], - "Toilet|+00.06|+00.00|+03.10": [ - -0.75, - 3.5, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy deleted file mode 100644 index fbbb5a2090f0968bd287946482cba894a287ca02..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1584 zcmbW!u}T9$6a~;Rge8O!)cnA9tB^)36^p6t6dMaG31)+Z7)iuN{0cwF{S-?}3kwSi zV`fj`luomp+2p?a*q5`5)AP%X@ED$|X}!E&R7YiXJUghyWi^{G9u||ktNCJD|K6WW zZkP4yet9#wuUFnV+#8qsyW{e?{O{?9_31R}8De^VzW((`=J(8RndNobywIdP{%(KI zUzyGK-h4Kn&1dtwF{IO^2b<64v-xa3o6qKRx1CqSG*=%E*?WDw*N63CeOMpXhxO@Y zeOMpXhxK87SbjgtXZb9j<+FU2KgjY~KFeqMET4-etj{o}r+M6I(mk8U=COHf9{Yam z`?2rGMLT~prXKpSeykts$NI5;tRL&g`th*sx7GF=WbS9~WiB$?PoDkQer!LsAKQ=Z i$M$3UvHiAVSRebb{n&n7H0ggVZxqwLJeJ4uM)3zd*{L7^ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json deleted file mode 100644 index 5135a1b2f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json +++ /dev/null @@ -1,33 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "Shelf", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json deleted file mode 100644 index 44dc45846..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "Bathtub|-02.90|+00.67|+02.86|BathtubBasin": [ - -2.75, - 3.75, - 270, - 30 - ], - "Cabinet|-00.12|+00.36|+04.63": [ - -1.0, - 3.75, - 90, - 30 - ], - "Cabinet|-01.03|+00.36|+04.63": [ - -1.5, - 3.75, - 90, - 30 - ], - "Cabinet|-01.06|+00.36|+04.63": [ - -0.75, - 3.75, - 270, - 30 - ], - "Cabinet|-01.96|+00.36|+04.63": [ - -2.25, - 4.0, - 90, - 30 - ], - "CounterTop|-01.02|+00.95|+04.88": [ - -0.75, - 4.25, - 0, - 30 - ], - "GarbageCan|-02.35|+00.00|+04.88": [ - -3.0, - 4.25, - 0, - 30 - ], - "HandTowelHolder|-00.07|+01.57|+04.81": [ - -0.5, - 4.25, - 0, - 30 - ], - "HandTowelHolder|-02.09|+01.54|+05.15": [ - -1.5, - 4.25, - 0, - -30 - ], - "Sink|-00.58|+00.93|+04.87|SinkBasin": [ - -0.75, - 4.25, - 0, - 0 - ], - "Sink|-01.53|+00.93|+04.87|SinkBasin": [ - -1.75, - 4.25, - 0, - 0 - ], - "ToiletPaperHanger|-00.07|+01.13|+03.69": [ - -0.5, - 4.0, - 180, - 30 - ], - "Toilet|-00.52|00.00|+03.22": [ - -0.5, - 2.75, - 0, - 30 - ], - "TowelHolder|-00.07|+01.41|+02.43": [ - -0.5, - 2.5, - 90, - 0 - ], - "TowelHolder|-01.72|+01.21|+01.74": [ - -1.75, - 2.25, - 180, - 0 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy deleted file mode 100644 index 50071edd0cc8cf7d828ff704ed437190a79a84e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1008 zcmbW!F-pTw0LS5{h=Zrd7KKbgK}2Y#Zi2!IVsxmEC?NeJn+^pI~^Rs_e-*?Ss zzq_j+n~e`%QXY;)Gv7P(M^Si-Cu%7>& zm-SeW*ZI7xzYcxYXMNUZeb#4v*6%}~^;w_wdC2!;eb#6FA@o_F^;w_wxzFceebygC fpY>Uv^;w_wS)cW%&}V&~@_l#=*7seX^{4qam2{;B diff --git a/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json deleted file mode 100644 index 098f91eab..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "ShowerHead", - "HandTowel", - "TissueBox", - "Shelf", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json deleted file mode 100644 index 6b3129c2f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "Bathtub|+00.22|+00.34|+00.64|BathtubBasin": [ - -0.75, - 1.25, - 90, - 30 - ], - "Shelf|-01.17|+00.28|+02.16": [ - -1.25, - 1.75, - 0, - 30 - ], - "Shelf|-01.17|+01.06|+02.16": [ - -1.0, - 1.75, - 0, - 30 - ], - "Shelf|-01.17|+01.76|+02.16": [ - -0.75, - 0.75, - 0, - 0 - ], - "Sink|-01.13|00.00|-00.59|SinkBasin": [ - -1.5, - 0.0, - 90, - 30 - ], - "Toilet|-02.15|+00.00|-00.41": [ - -1.5, - 0.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy deleted file mode 100644 index b175551a305c675bce4672eaf23dc95cba71c2d0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 576 zcmbWzAr8VY6oBDEP@JN!kW@`Agk%l}!5~m%VO41ah)5C9UO~1fbaD_Cp_$wi7Y8Q^HpM}#B;q1og%@Nm!Ao#-ba2Sf z!D{*p{YTGocmny}mb{){o?Tq6q^I zvwgOoisgN77r%$?vwgPDAK`ty)zD)-)?+=^V?EYeE7ITbeOQn6SdaBskKY&nm(#TC zt{2^{&-$#-`mE3Ttk3!zq0joP&-$#-`mE3Tz0hZU)@OazXMNUZ{msy4eb#4v)@Oaz zXZ@|vXMNUZeb#4v)@S|g&}V(tXMNUZeb#6FozQ1})@OazXMNV|haT&(9_z6l>-CEt DyrtJD diff --git a/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json deleted file mode 100644 index fee4c2922..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "SinkBasin", - "TowelHolder", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json deleted file mode 100644 index 712dee310..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "Cabinet|+00.07|+00.38|+02.05": [ - -0.75, - 3.0, - 90, - 30 - ], - "CounterTop|+00.49|+01.02|+03.09": [ - -0.25, - 3.5, - 90, - 30 - ], - "Sink|+00.43|+01.04|+02.95|SinkBasin": [ - -0.25, - 3.0, - 90, - 0 - ], - "Toilet|+00.38|+00.00|+04.47": [ - -0.5, - 3.75, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy deleted file mode 100644 index e53430e434d631d6fb74bcfe6bc1187099066062..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 672 zcmbV_Ar1mD5JijS6m^B93J`>ltiwSt2o!19ZV-eeEx`~@!GX9!kAOrX5J(ovGb5?_ zdA~FBF0;jSzHF(ZI+@bPbuc4s#?{bRZK^sPg4?a?Q2I|laogydK5pFJH{9tDtnPKK zKI?y9TYcZ_n)C6?r(k;WF8*(Vli++^DfaPk2OrEFEE69+J{TX2k3D=aKA1gNCO&$6 hFh1t+!T4Z&Fn3^?_~_ZEXCGz`WqnzeXjrj diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json deleted file mode 100644 index 0cec3c67e..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json deleted file mode 100644 index e7f8e434c..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "Bathtub|+00.88|+00.39|-01.15|BathtubBasin": [ - 0.0, - -0.5, - 90, - 30 - ], - "Cabinet|-00.07|+00.34|-01.33": [ - -1.0, - -0.5, - 90, - 30 - ], - "Cabinet|-01.04|+00.34|-01.33": [ - -1.5, - -0.5, - 90, - 30 - ], - "Cabinet|-01.05|+00.34|-01.33": [ - -1.25, - -0.75, - 180, - 30 - ], - "Cabinet|-02.02|+00.34|-01.33": [ - -1.0, - -0.25, - 270, - 30 - ], - "CounterTop|-01.04|+00.88|-01.53": [ - -1.5, - -1.0, - 180, - 30 - ], - "Sink|-00.53|+00.81|-01.60|SinkBasin": [ - -1.0, - -1.0, - 90, - 30 - ], - "Sink|-01.56|+00.81|-01.60|SinkBasin": [ - -1.25, - -1.0, - 180, - 30 - ], - "Toilet|-01.61|00.00|+00.21": [ - -1.25, - -0.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy deleted file mode 100644 index 97a2514fc98772512785982fd1a708a0fb640592..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 704 zcmbW!F$%&k6oBCKC!C#D~MQz`xv)5r8NeayS0i^&IyoqELp diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json deleted file mode 100644 index e855538bd..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json deleted file mode 100644 index a8048b4fb..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "Bathtub|+00.29|+00.29|-00.08|BathtubBasin": [ - -0.5, - 0.25, - 90, - 30 - ], - "Cabinet|-01.50|+00.42|+00.43": [ - -2.25, - -0.5, - 90, - 30 - ], - "Cabinet|-02.29|+00.39|+00.42": [ - -2.5, - -0.25, - 90, - 30 - ], - "Cabinet|-02.31|+00.42|+00.43": [ - -2.25, - -0.25, - 0, - 30 - ], - "Cabinet|-03.09|+00.39|+00.42": [ - -2.5, - -0.5, - 0, - 30 - ], - "CounterTop|-02.30|+00.95|+00.69": [ - -2.25, - -0.25, - 0, - 0 - ], - "GarbageCan|-02.86|+00.02|-01.49": [ - -2.25, - -0.75, - 270, - 30 - ], - "Sink|-01.92|+00.93|+00.68|SinkBasin": [ - -1.75, - 0.0, - 0, - 0 - ], - "Sink|-02.68|+00.93|+00.68|SinkBasin": [ - -2.5, - 0.0, - 0, - 0 - ], - "Toilet|-01.05|+00.00|+00.55": [ - -0.5, - 0.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy deleted file mode 100644 index 278e0a1d880584b4bedf2ea9897c33979fadd4dd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 752 zcmbWyF$%&!5J1sYL?q-8+pR(>ZK4RKvQum2HK7jKuDOYCPqjyJh2_W3&A*~0B! zKhWJypilbW@l-j_OZC1+)%y^>3*UsfSJCf1<{op8uiqY~R~J1@57Wc+Fug{k%He;Q v9;S!sVR}u`!}KscOb^p*i5{kh>0x@9o+o;k9;S!sVS2vkVS1Pzrsqd*d}L}c diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json deleted file mode 100644 index 670bad826..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json deleted file mode 100644 index 2d50fa700..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "CounterTop|+00.46|+00.79|+02.76": [ - -0.25, - 2.75, - 90, - 30 - ], - "Drawer|+00.44|+00.32|+02.19": [ - -0.75, - 1.75, - 0, - 30 - ], - "Drawer|+00.44|+00.32|+02.57": [ - -0.75, - 2.0, - 0, - 30 - ], - "Drawer|+00.44|+00.32|+02.94": [ - -0.75, - 2.25, - 0, - 30 - ], - "Drawer|+00.44|+00.32|+03.31": [ - -0.75, - 2.75, - 0, - 30 - ], - "Drawer|+00.44|+00.62|+02.19": [ - -0.5, - 1.75, - 0, - 30 - ], - "Drawer|+00.44|+00.62|+03.31": [ - -0.5, - 2.75, - 0, - 30 - ], - "GarbageCan|+00.41|-00.03|+03.73": [ - -0.25, - 3.25, - 0, - 30 - ], - "Sink|+00.50|+00.66|+02.76|SinkBasin": [ - -0.25, - 3.25, - 180, - 30 - ], - "Toilet|+00.27|+00.00|+01.46": [ - -0.25, - 2.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy deleted file mode 100644 index 09bb6c6c837541d12eb2b3566f010329e8edca29..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1408 zcmbWxu}Z^07{Kwfl%s@F+Be7+g%09W#Nj44#l^u%icN74E2+4MPvHZZ$8vD6CiyKl z`Yqv??{fKnUf*8b+#Q9t@Lp}|{X0vz_ z+x{Hu;Ze5NW3Pwxu%1ck|D%WXa2)=}dRPzZVLhyeXT$wP3f)XI>$BI#F*~o%ULWgY zeXNgX!~N3~y3xn_SRcoB_%8KNefIiTAM0a%ycq7E4foG8>$lg>`gxLlA2aKBUO($+ z{j8t$&r|3|KkH}xTnv4zpJTSyZ?B*Avwqgk`WGp5qo4J&e%8fJZ=#%4Lb1b+W3^z-`m>gH}IyoL92*iIh0^1LW7MrUPJl%sL?+BMJj<8Ijgy}xXp zChhwDJYQd&|M*9@}Gk zY>(}+J+`;X_ShcVV|#3m?eQ}G{!nlJKDNj9*dE(sd)%AGH@!NZVH(d~9nV#|54#^P zvhVKayZf>GvHNjI59{yN@q<3=vp(x{$_LilOMN}oV?EYmz5T4mdaTEKtk=(atjBt+ N$FuZ5=6Ui#{R?)Il9d1e diff --git a/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json deleted file mode 100644 index f4d477e9d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json deleted file mode 100644 index 96017b5b6..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "Bathtub|-01.06|+00.30|+00.43|BathtubBasin": [ - -0.75, - 1.25, - 180, - 30 - ], - "CounterTop|+00.73|+00.70|+01.96": [ - 0.0, - 2.0, - 90, - 30 - ], - "CounterTop|-00.30|+00.16|+00.53": [ - -0.25, - 1.5, - 180, - 30 - ], - "Drawer|+00.41|+00.32|+01.49": [ - -1.0, - 2.0, - 90, - 0 - ], - "Drawer|+00.41|+00.32|+02.42": [ - -1.0, - 2.0, - 90, - 0 - ], - "Drawer|+00.41|+00.55|+01.49": [ - -0.75, - 1.75, - 90, - 0 - ], - "Drawer|+00.41|+00.55|+02.42": [ - -0.75, - 1.75, - 90, - 0 - ], - "GarbageCan|+00.71|-00.03|+03.11": [ - 0.5, - 3.5, - 180, - 30 - ], - "Sink|+00.81|+00.70|+01.92|SinkBasin": [ - 0.0, - 2.5, - 180, - 30 - ], - "Toilet|-02.23|+00.00|+01.63": [ - -2.0, - 2.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy deleted file mode 100644 index 1d3c8327df573213544b1cf76075351bfd9cf1d7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 784 zcmbV{Ar8Vo5JeY48q!m&TS#gk2tr8ea1aavMH*UyAe6KOLpTKoqDSZvDv<~T0zqNt znU##0zCW|CyVu!bI$t)_Nu5oc9)PCeUV+X2&eruhJ||zWF5D3A+vt$g z+!^!&-R}naqW>*l{mLtBf8A_vIsBBI`NLsP_Sxe+>~{9?un#xI2P=o)@_**;z3|_i z_rUmJ{4jnPU*-5W!-VAJ8ypPU(}CX zv%TLv)X&Y{)yD6`a^|3w<>Ecc5+pER{{j8t$ zvwlwXf%Wfa{j8t$vwqgkefl5Rcgns)w&x(*!}hQ}Y!BPR_OLx{58E@z_OLx{58K1` Vusv)K+r#!uvpsAN+r#!us~?!{m^1(Y diff --git a/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json deleted file mode 100644 index 0e607a3e9..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "Dresser", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json deleted file mode 100644 index 528e315b4..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "Bathtub|-01.41|00.00|+00.56|BathtubBasin": [ - -0.75, - 1.0, - 270, - 30 - ], - "Cabinet|-01.61|+00.31|+02.49": [ - -0.75, - 3.25, - 180, - 30 - ], - "Cabinet|-01.61|+00.31|+03.11": [ - -0.75, - 2.5, - 0, - 30 - ], - "Cabinet|-01.61|+00.31|+03.14": [ - -0.75, - 2.75, - 0, - 30 - ], - "Cabinet|-01.61|+00.31|+03.75": [ - -0.75, - 3.0, - 0, - 30 - ], - "CounterTop|-01.80|+00.75|+03.12": [ - -1.25, - 3.0, - 270, - 30 - ], - "Drawer|+00.20|+00.16|+03.81": [ - -0.5, - 3.25, - 90, - 30 - ], - "Drawer|+00.20|+00.42|+03.81": [ - 0.75, - 3.25, - 0, - 30 - ], - "Drawer|+00.20|+00.68|+03.81": [ - -0.5, - 3.5, - 90, - 30 - ], - "Drawer|+00.20|+00.94|+03.81": [ - -0.5, - 3.5, - 90, - 30 - ], - "Dresser|+00.21|+00.00|+03.83": [ - 0.25, - 3.25, - 0, - 0 - ], - "GarbageCan|+00.93|-00.03|+03.76": [ - 0.25, - 3.25, - 0, - 30 - ], - "Sink|-01.83|+00.69|+02.78|SinkBasin": [ - -1.25, - 3.25, - 180, - 30 - ], - "Sink|-01.83|+00.69|+03.47|SinkBasin": [ - -1.25, - 3.0, - 0, - 30 - ], - "Toilet|-01.57|00.00|+01.82": [ - -1.25, - 2.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy deleted file mode 100644 index aa82fa1bb4208248476699ac51afd89bd2596dc5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 800 zcmbWxu?oU46oug^BE_f37KKj5K}4{Vo8sc&B*jJ?#7ZhI;#2rQ^>I3O=+L2qwducP zG)wp{Ip^lR*{!$xo_L6-igkK4YA)5{G*iA*r^MV%bUh>{*1!2Gx}>_9r|0OV8;_@f zFN29MU-I8G678uod*@4gSB^`^g=6xClgH$-_}D#V_ntgvKPHcPUpf0Q?=kyoXCG!C zCXdOB(EgkKm^>zr$@iT+CXdPEA`|Vw^bJBg=RcS}OdqBXlOJ|{49l1VyavA~qIQvLqWUf{|UZ33&=1D0!Te78Vv3#$><3 zTRP3*znuH;?7ZLJkM150(py@TNz;wna+S;V^s-dBOy})uTR%U}+ez~~zo}QO z^-Htmlk=^W1wZD; z{Foo}WB$Q9?T+`s{Foo}WBtS4r;qiqzI*6neXQ@E`dA<9OMR@5y$_c5V%j&ikL|}E Qj%nZAf0*-O-`T8w0KJ8raR2}S diff --git a/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json deleted file mode 100644 index 1e083ec30..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "Shelf", - "Dresser", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json deleted file mode 100644 index 78d0f5817..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "Bathtub|-02.10|+00.53|-00.83|BathtubBasin": [ - -1.75, - -0.75, - 270, - 30 - ], - "CounterTop|-02.71|+01.03|-02.92": [ - -1.75, - -3.0, - 270, - 0 - ], - "Drawer|-00.23|+00.16|-03.40": [ - -1.25, - -2.75, - 180, - 30 - ], - "Drawer|-00.23|+00.42|-03.40": [ - -0.75, - -3.0, - 90, - 30 - ], - "Drawer|-00.23|+00.68|-03.40": [ - -0.75, - -3.0, - 90, - 30 - ], - "Drawer|-00.23|+00.94|-03.40": [ - -0.75, - -3.0, - 180, - 30 - ], - "Dresser|-00.20|+00.00|-03.40": [ - -0.75, - -3.25, - 90, - 0 - ], - "GarbageCan|-00.27|-00.03|-02.75": [ - -1.0, - -3.25, - 0, - 30 - ], - "Shelf|-02.58|+00.40|-02.92": [ - -1.25, - -2.75, - 270, - 0 - ], - "Sink|-00.31|+00.00|-02.08|SinkBasin": [ - -0.75, - -1.5, - 90, - 30 - ], - "Toilet|-00.41|00.00|-00.55": [ - -0.75, - -1.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy deleted file mode 100644 index 97b05a34c900c4c1a2fa707d19b7fd11afd6c743..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 992 zcmbWzF-pWx6a~<)h)7nEE()ncK}2vWJH^JrN`jMN3UMS68*vpb$Sq_EQ(8_jg@uKq z`KNiMzX>OK_r4_WS2vf}w_E8Yy;jq+{@x9>To* zSMHN%d6wt#D^p^9-=UB7u|C$v`qE^4;{8}3>tp%tkY{<8XZf9wXL*+Aln?9M4SlSS n^|3x4@_%Oid!e88vwqgk`gxi6v3*6@$M&&(Y#-al_7#&KZ*++( diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json deleted file mode 100644 index c8adda2c6..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json deleted file mode 100644 index afd6d54d0..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "CounterTop|-01.61|+00.70|+02.83": [ - -1.0, - 2.25, - 270, - 30 - ], - "Drawer|-01.34|+00.30|+02.13": [ - -0.75, - 1.75, - 270, - 30 - ], - "Drawer|-01.34|+00.30|+03.33": [ - -0.75, - 3.0, - 270, - 30 - ], - "GarbageCan|-01.74|-00.03|+01.27": [ - -1.0, - 1.75, - 180, - 30 - ], - "Sink|-01.70|+00.62|+02.28|SinkBasin": [ - -1.0, - 2.75, - 180, - 30 - ], - "Sink|-01.70|+00.62|+03.37|SinkBasin": [ - -1.0, - 3.0, - 0, - 30 - ], - "Toilet|-01.55|+00.00|+00.69": [ - -1.25, - 1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy deleted file mode 100644 index 0e72aa5468376744d0ad51f9911a9e4a1cf2be8d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1088 zcmbWxu};EJ6oBDE3U>X;-y&US=~M~`6}h{e3Z+S=gVf*REzs%Gpm31*VR*7@AvIv z^<3|LdU;-^i?cFq(tn>}@%OyH9_HZfF!`kONB6!T-m_VB@8kUL&fD*Tzk)x5^_};B ztRFiZr@p;D>$5)Vv%Y)%7yFLm)VJ4Xeb#4v_vo`eJI8VA+v~GF>pQ2<`mE3H;W+i} g^;zF{`mE3Ttk3S{IQ8xI?e$ro^;w_wS%;7F2ek>!DF6Tf diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json deleted file mode 100644 index 6c7ccae54..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json deleted file mode 100644 index 111a6080f..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Cabinet|-02.50|+00.40|-01.24": [ - -1.75, - -1.5, - 0, - 30 - ], - "Cabinet|-02.50|+00.40|-02.21": [ - -2.0, - -1.5, - 270, - 30 - ], - "Cabinet|-02.51|+00.43|-00.29": [ - -1.75, - -1.0, - 0, - 30 - ], - "Cabinet|-02.51|+00.43|-01.26": [ - -1.75, - -2.0, - 0, - 30 - ], - "CounterTop|-02.75|+00.99|-01.24": [ - -2.25, - -1.5, - 270, - 30 - ], - "Sink|-02.91|+00.99|-00.73|SinkBasin": [ - -2.25, - -1.0, - 0, - 30 - ], - "Sink|-02.91|+00.99|-01.76|SinkBasin": [ - -2.25, - -1.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy deleted file mode 100644 index 3e47df778f8071a73ded546848c342dde1b5a976..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 864 zcmbW#u}Z^07{KvZq)6#Q+;$Z*l_FA{-4quGCkZyCgV>T37x5{4p!z5s9UUAT9IQ0I z!EbDq<9B!ej}Y>9eS39tcT_wVFL_qC4^5t?d@(=IWy)V`(-n$|MoAd$F|<> zw~K03?>w5Em1%rhrq^`nGbr}Y`+gaA>(A!Dzk|PmKZA>I&LGTV^VmGrpM;+EtY>{c z^sHw+>yJavdUn4T?z3~N@5|=c*RgvXSH1Vrv!3;=_Z{@CXFcov2YS}Cp7kHyf23zU M>)H9X>z!{mzctp3NB{r; diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json deleted file mode 100644 index 6c7ccae54..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json deleted file mode 100644 index fb4ef1367..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Cabinet|-02.29|+00.32|-03.25": [ - -1.5, - -3.5, - 0, - 30 - ], - "Cabinet|-02.29|+00.32|-03.81": [ - -1.5, - -3.0, - 180, - 30 - ], - "Cabinet|-02.30|+00.35|-02.25": [ - -1.5, - -3.0, - 0, - 30 - ], - "CounterTop|-02.63|+00.84|-03.04": [ - -2.0, - -3.0, - 270, - 30 - ], - "GarbageCan|-00.46|-00.04|-03.77": [ - -1.25, - -3.25, - 180, - 30 - ], - "Sink|-02.66|+00.79|-03.07|SinkBasin": [ - -2.0, - -3.5, - 0, - 30 - ], - "Toilet|-00.45|+00.00|-03.05": [ - -1.0, - -3.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy deleted file mode 100644 index 191b53f1cfb6d90ecc8734f97572f8c9fded07b3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 608 zcmbV`p$@_@6h#Y?uc#{|6$A_+XdDECK#_)ZK@hgIWM<(j_#pTcBocu@AQ)^XBu`Rv zbMEUq?POQRUvYQXw|daC z`l$as9rZoWbDix=oe#mxm6*fKU(Fu-FmsYQ%stt|GVkJ@n_zt0;~f|uEE69+K6-pG YKA1gN=C%1RJ$`!pFn$<6j0gVZ8}dbb$N&HU diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json deleted file mode 100644 index 0a56e852a..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "ShowerHead", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json deleted file mode 100644 index 46cace91d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Bathtub|-00.98|-00.72|-02.93|BathtubBasin": [ - -1.25, - -2.25, - 180, - 30 - ], - "Drawer|-02.11|+00.16|-01.31": [ - -1.5, - -0.75, - 180, - 30 - ], - "Drawer|-02.11|+00.46|-01.31": [ - -1.75, - -0.75, - 180, - 30 - ], - "GarbageCan|-00.24|-00.03|-01.36": [ - -0.75, - -1.25, - 90, - 30 - ], - "SideTable|-02.18|00.00|-01.31": [ - -1.75, - -1.0, - 270, - 30 - ], - "Sink|-02.10|00.00|-02.03|SinkBasin": [ - -1.5, - -1.75, - 180, - 30 - ], - "Toilet|-00.47|+00.00|-01.88": [ - -0.75, - -1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy deleted file mode 100644 index 3d239dd2e8222e42f8e0272eedc659e483177ba4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 560 zcmbV{p$Y;)6h+7CSG+a~leQ>gwkcZ-CK=pW4C2a+SY*G#5As)xMuWj%aMe8sFFNIN zF7FnLS_~`M$_+Wf`2kXQ~j}OMH?_izm=`ZbnVZ8bd*2$ip LJw0BSJNTC`QxbM; diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json deleted file mode 100644 index 9c3deeaff..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "HousePlant", - "SoapBar", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json deleted file mode 100644 index c23df54f5..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "Bathtub|-01.28|+00.28|-02.53|SinkBasin": [ - -1.25, - -1.75, - 180, - 30 - ], - "Drawer|-00.22|+00.78|-01.47": [ - -1.25, - -1.5, - 90, - 0 - ], - "SideTable|-00.15|+00.00|-01.47": [ - -0.5, - -1.0, - 90, - 30 - ], - "Sink|-02.27|+00.00|-01.52|SinkBasin": [ - -1.75, - -1.25, - 180, - 30 - ], - "Toilet|-02.05|+00.00|-00.36": [ - -1.5, - -1.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy deleted file mode 100644 index bed785d7e97473038a76e7b8d4ebb2ca0e9451bf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 608 zcmbW!F%AJi6oBC&BC^>-OgAJ`2#tuuRyv|lsAOYjqYx`Iq7kQXAXic-6bg&|3$OH= zm;YtHYA&q9i zb|GJT&po_0yY+TI5O?uViO!Ek&81qTGZjdcX69z%%ONv~{@t(QbFSO_{1jhx>v0$c zaykj*Q~rBKqC5Vl{}#*sJ9O+h7LJ>DpCey8_U(M>?8ofK?8ofK?8lYu!}L{7AEpn} shv~!gVft`s`*Gozd~N@SJSLCHW9A#1XC5<;nHQ1h4)d6I&w2NvFV&=L)c^nh diff --git a/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json deleted file mode 100644 index eed1f5ea6..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json +++ /dev/null @@ -1,33 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "Shelf", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json deleted file mode 100644 index 3da31098e..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "Bathtub|-03.45|+00.18|+01.03|BathtubBasin": [ - -2.75, - 1.25, - 270, - 30 - ], - "Cabinet|-00.61|+00.46|+00.52": [ - -1.25, - 1.25, - 90, - 30 - ], - "Cabinet|-00.61|+01.99|+00.52": [ - -1.25, - 1.0, - 180, - -30 - ], - "Cabinet|-01.89|+00.44|+01.98": [ - -1.25, - 1.75, - 0, - 30 - ], - "Cabinet|-01.89|+01.88|+02.39": [ - -1.25, - 2.25, - 270, - 0 - ], - "Cabinet|-02.34|+00.46|+00.52": [ - -1.75, - 1.0, - 180, - 30 - ], - "CounterTop|-00.81|+00.09|+00.29": [ - -1.25, - 1.0, - 180, - 0 - ], - "CounterTop|-01.92|+00.00|+00.29": [ - -2.0, - 0.75, - 180, - 30 - ], - "Drawer|-00.81|+00.96|+00.38": [ - -1.5, - 1.0, - 90, - 0 - ], - "Drawer|-02.03|+00.94|+02.19": [ - -1.5, - 1.5, - 0, - 0 - ], - "Shelf|-02.03|+01.18|+02.19": [ - -1.25, - 1.75, - 270, - 0 - ], - "Shelf|-02.12|+01.39|+02.19": [ - -1.25, - 2.25, - 270, - -30 - ], - "Sink|-01.93|+00.77|+00.33|SinkBasin": [ - -2.5, - 0.75, - 90, - 30 - ], - "Toilet|-00.46|00.00|+02.26": [ - -1.0, - 2.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy deleted file mode 100644 index d85f2115b41423b356fe2292116cfad34b885d51..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1008 zcmbWyu}Z^G0EW?P2|;{{Y*EN06hs6wxhXCVP7-WN2eFcfi}(~ika--(4jnRNur~J$ zW;Dy?B+d7ypEq~cxAzC(ExhN8x_xZ&^DMtup5;ZBFW1d$Q$0Vdn??P5|EhXw>)ri! zRlU?ZAJ6ASc6w4|AK8Deqp-h{Zalv)$8$Dun0Wa5`+M(iChxQN+56nb9v{ZNZS18J z+wTkEq?%>>WG^F diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json deleted file mode 100644 index 3045886b8..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json deleted file mode 100644 index 21ea750b4..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "Bathtub|-03.59|+00.11|+01.52|BathtubBasin": [ - -3.0, - 1.25, - 270, - 30 - ], - "CounterTop|-00.28|+00.79|+01.93": [ - -1.0, - 2.25, - 90, - 30 - ], - "CounterTop|-02.54|+00.81|+00.28": [ - -1.75, - 0.75, - 270, - 30 - ], - "Drawer|-00.33|+00.32|+01.72": [ - -1.5, - 2.25, - 180, - 30 - ], - "Drawer|-00.33|+00.32|+02.16": [ - -1.5, - 2.75, - 180, - 30 - ], - "Drawer|-00.33|+00.32|+02.59": [ - -1.5, - 2.0, - 0, - 30 - ], - "Drawer|-00.33|+00.32|+03.03": [ - -1.5, - 2.5, - 0, - 30 - ], - "Drawer|-00.33|+00.62|+02.59": [ - -1.25, - 2.0, - 0, - 30 - ], - "Drawer|-00.33|+00.62|+03.03": [ - -1.25, - 2.5, - 0, - 30 - ], - "Drawer|-02.25|+00.32|+00.28": [ - -1.5, - 1.5, - 270, - 30 - ], - "Drawer|-02.84|+00.32|+00.28": [ - -2.25, - 1.5, - 270, - 30 - ], - "GarbageCan|-01.75|+00.00|+00.23": [ - -2.0, - 0.75, - 180, - 30 - ], - "Sink|-00.26|+00.66|+01.92|SinkBasin": [ - -1.0, - 2.5, - 180, - 30 - ], - "Toilet|-02.84|+00.00|+02.76": [ - -2.25, - 2.5, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy deleted file mode 100644 index 75490b8ceb8bb454345ff51e5d26c3a52caeaa75..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 736 zcmbWyF$%&k6oBCOA*0NZijFg;8U(`zNF8vcXnVS1Pz rrq>odOb^q;^f0}S=wW)89;S!s1)_)PVS1PzrWcAHribZadSUVgAzEoo diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json deleted file mode 100644 index f3988fd79..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json deleted file mode 100644 index 645647bca..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "Cabinet|-00.49|+00.41|+02.06": [ - -1.25, - 1.75, - 0, - 30 - ], - "Cabinet|-00.49|+00.41|+02.86": [ - -1.25, - 2.5, - 0, - 30 - ], - "Cabinet|-00.50|+00.38|+02.84": [ - -1.25, - 2.25, - 0, - 30 - ], - "Cabinet|-00.50|+00.38|+03.65": [ - -1.25, - 3.0, - 0, - 30 - ], - "CounterTop|-00.26|+00.93|+02.84": [ - -0.75, - 2.5, - 90, - 30 - ], - "GarbageCan|-02.16|00.00|+03.76": [ - -1.75, - 3.25, - 0, - 30 - ], - "Sink|-00.30|+00.80|+02.42|SinkBasin": [ - -0.75, - 2.0, - 0, - 30 - ], - "Sink|-00.30|+00.80|+03.26|SinkBasin": [ - -0.75, - 3.0, - 90, - 30 - ], - "Toilet|-00.54|+00.00|+01.49": [ - -1.0, - 2.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy deleted file mode 100644 index a966f44e54c18b5049044de741c61d322c271a71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 512 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I$7COQg6nmP)#3giMV1~B-rA431JhtMz3_z%$dF!c-$sOn*Sn0go=W*!q% zJxm_PzW_BK#)qkAK~oRo!_>q0F!gL`>S27CdKe$3o&!xij1N-}8F21LSSBNl^68f{|`q!o*J3J=7ibnMu{(81tO&v$S} zcacwf&+m8YI$KQV%bGcvvkRkiow$K@!?@>s>*9TKOoH8NpM=rp`6Sq;(ffJ22@cWQ zt#049owjc;_TSSq-_y8PzuD;5xwtOxu_rFneawAq)cxnpd=KwS<%e>ioGWL_p7cFN zRS(~X*$=ZHWADm08vMfQ~&?~ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json deleted file mode 100644 index f904e7328..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json deleted file mode 100644 index c1f4edd71..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "Bathtub|-03.50|+00.15|+00.94|BathtubBasin": [ - -2.75, - 1.25, - 270, - 30 - ], - "CounterTop|-01.85|+00.00|+00.34": [ - -1.0, - 1.0, - 180, - 30 - ], - "Drawer|-00.29|+00.31|+00.31": [ - -1.0, - 1.5, - 90, - 30 - ], - "Drawer|-00.29|+00.61|+00.31": [ - -0.75, - 1.25, - 90, - 30 - ], - "Drawer|-00.81|+00.31|+00.31": [ - -1.5, - 1.5, - 90, - 30 - ], - "Drawer|-00.81|+00.61|+00.31": [ - -1.25, - 1.25, - 90, - 30 - ], - "Drawer|-01.32|+00.61|+00.31": [ - -0.75, - 1.25, - 270, - 30 - ], - "Drawer|-01.84|+00.31|+00.31": [ - -1.25, - 1.5, - 270, - 30 - ], - "Drawer|-01.84|+00.61|+00.31": [ - -1.25, - 1.25, - 270, - 30 - ], - "Sink|-00.46|-00.01|+03.05|SinkBasin": [ - -0.75, - 2.5, - 0, - 30 - ], - "Toilet|-01.84|+00.00|+02.50": [ - -1.25, - 1.75, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy deleted file mode 100644 index 78286bb77b667bbcec62afd1092b54c87bccbc53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 992 zcmbW!F-pWh6oBCvd?>#gFscu9+{O{T={?_bcy1VWKZwD8_#-i| zu^tb($9=H=SLm}o>$5)Vvp(yy{&(oJKI^kS>$5)Vvwk1?tk3$a&-y&%@6Gz`e-F8@ f$9k;CdaTEN?z7%H^jMG0XY<*7Hh;|XJs;;kiPn^8 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json deleted file mode 100644 index 44d2e8f28..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "PaperTowelRoll", - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json deleted file mode 100644 index 5cbe082d7..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bathtub|-03.71|+00.34|+00.64|BathtubBasin": [ - -2.75, - 1.0, - 270, - 30 - ], - "CounterTop|-02.80|+00.00|-00.59": [ - -2.0, - 0.0, - 180, - 30 - ], - "Drawer|-01.44|+00.27|-00.62": [ - -2.0, - 0.5, - 90, - 30 - ], - "Drawer|-01.44|+00.53|-00.62": [ - -1.0, - 0.25, - 270, - 30 - ], - "Drawer|-01.89|+00.27|-00.62": [ - -2.5, - 0.5, - 90, - 30 - ], - "Drawer|-01.89|+00.53|-00.62": [ - -2.5, - 0.75, - 180, - 0 - ], - "Drawer|-02.34|+00.27|-00.62": [ - -1.75, - 0.5, - 270, - 30 - ], - "Drawer|-02.34|+00.53|-00.62": [ - -2.75, - 1.0, - 180, - 0 - ], - "Drawer|-02.79|+00.27|-00.62": [ - -2.25, - 0.5, - 270, - 30 - ], - "Drawer|-02.79|+00.53|-00.62": [ - -2.25, - 0.25, - 270, - 30 - ], - "GarbageCan|-01.56|00.00|+01.91": [ - -1.0, - 1.75, - 270, - 30 - ], - "Sink|-01.92|+00.44|+02.03|SinkBasin": [ - -2.25, - 1.5, - 0, - 30 - ], - "Toilet|-00.72|+00.00|-00.31": [ - -1.25, - 0.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy deleted file mode 100644 index 0c26e75d4946aea3c1fb14ac01ba8043cc639973..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 992 zcmbWyu}Z^07{KvUM5Oc~ZaalcVnIY`CO5^!!AXKmaS$tsxQI{T1NjPlgpM5@938A) zeuFo9OZZ*#ef;xwadm!qy%nCrOPaO)ZI@1BI-MVyYc?ysEUUNReX*AJ)`h@*6;cGHO+b$;(Lwx8{1`*}IdH@qsmF05y-=wUsqhxM=?*28*O m59=8fJ*Y^LY5SY58prB*dQ{c1n$Eh1uDQRSb(8jc|FpU5 z+x32b+sxawcMlKhxW8A&=lI`e6n>u9MOsJ8w7zBUWUmT4@4fTe#d&s~huq_kA0AH9 z2J3Gv)4q9FpY=I?Dg@SN{mr7!`mE3Ttk3$P=(9fSvp(yy{%5{d_rvW5F9R9E-T(jq diff --git a/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json deleted file mode 100644 index 07f7757be..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json deleted file mode 100644 index 850de0b4b..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "Bathtub|-02.12|-00.09|-03.12|BathtubBasin": [ - -1.0, - -2.75, - 270, - 30 - ], - "GarbageCan|-00.53|-00.05|-03.76": [ - -1.0, - -3.0, - 90, - 30 - ], - "SideTable|+00.78|+00.00|-00.67": [ - 0.25, - -1.25, - 90, - 30 - ], - "SideTable|+00.79|+00.00|-01.82": [ - 0.25, - -2.25, - 90, - 30 - ], - "SideTable|-01.53|+00.00|-00.17": [ - -1.0, - -0.75, - 0, - 30 - ], - "Toilet|+00.00|00.00|-03.44": [ - -0.5, - -3.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy deleted file mode 100644 index 720285dc4d0a54d810408c8459f90780d16de92f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1760 zcmbW#p-#h46oBDEP&`FlA(?2RgN2>#x}RJm z>-Cmi*2``5vR>B9x;U@;no*oAwkzvnecbu};(dM2^|3zI$NF}To@LyxhxKq5J*tQ{thxM@kQx`q{@9g(uecZ+G t$8EAc=lZxw&+BupZ=L#BAM0a%+{QfC$NJd(KF#Mo?ql=Wd^W!y{Qy7=9rXYJ diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json deleted file mode 100644 index 4ad43db6d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json +++ /dev/null @@ -1,35 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Footstool", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "Shelf", - "LightSwitch", - "Bathtub", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json deleted file mode 100644 index ebaf98b49..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "CounterTop|+00.20|+00.43|-02.01": [ - 0.0, - -1.25, - 180, - 30 - ], - "Drawer|+00.30|+00.30|-01.82": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|+00.30|+00.49|-01.82": [ - -0.25, - -1.0, - 90, - 30 - ], - "Drawer|+00.30|+00.68|-01.82": [ - -0.25, - -1.0, - 90, - 30 - ], - "Drawer|+00.30|+00.83|-01.82": [ - -0.25, - -0.75, - 180, - 0 - ], - "SideTable|-02.85|+00.01|+01.51": [ - -2.25, - 1.5, - 270, - 30 - ], - "Sink|-02.80|+00.33|+00.76|SinkBasin": [ - -2.25, - 1.25, - 180, - 30 - ], - "Toilet|-00.06|+00.01|+01.84": [ - -0.75, - 1.25, - 0, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy deleted file mode 100644 index 86f544e919f217f153d279dff30bf3b77c6ed5c8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1680 zcmbW%Jx;?w5QgCeAqr06&LFv>;YUcJq65)TP@#x8qCf;Whz4;A4wNhS2q{y#NRfhq z5bqO-DRDD;cPI1CXC?W%xx2o--%0Q3qa4-K$EG|l%8T)7Srz4Y(!4dpmxoC+s(;U~ zhR@S_eLj5}zSe6#JUgk1vwR8@RtsX?s8T+dmJy2;2qc>t_8N zKFo*P{CUiW`7j^mTLd5G!+e+z^I<;Br?%OP`7j^m!+e+zt30vtZO`-j#C(_!^I`qw z>c{%AemV7H{dj4=T=koyAM3}f{5h&~J@_TA?#qweKFb|GZKIigb`LKLgJ}e*Z oay}lvYb-BrL%;mn`n+a diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json deleted file mode 100644 index 67be1200d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - "PaperTowelRoll", - "StoveBurner", - "Faucet", - "Stool", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Statue", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Bread", - "Sink", - "Floor", - "HousePlant", - "Potato", - "Vase", - "Mug", - "CounterTop", - "ShelvingUnit", - "Spatula", - "Shelf", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json deleted file mode 100644 index c4b6ea81e..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json +++ /dev/null @@ -1,152 +0,0 @@ -{ - "Cabinet|+00.20|+02.02|-02.00": [ - 0.75, - -1.25, - 180, - 0 - ], - "Cabinet|+01.18|+02.02|-02.00": [ - 0.75, - -1.25, - 180, - 0 - ], - "Cabinet|+01.39|+00.47|-01.06": [ - 0.75, - -1.25, - 90, - 30 - ], - "Cabinet|+01.74|+02.02|-02.00": [ - 1.0, - -1.25, - 180, - 0 - ], - "Cabinet|+01.75|+02.02|-01.03": [ - 1.0, - -1.25, - 90, - 0 - ], - "Cabinet|-00.42|+00.37|-00.01": [ - 0.5, - -0.75, - 270, - 30 - ], - "Cabinet|-00.45|+00.47|-00.01": [ - 0.0, - -1.0, - 270, - 30 - ], - "Cabinet|-00.82|+00.47|-01.69": [ - 0.0, - -0.75, - 270, - 30 - ], - "Cabinet|-00.84|+00.47|-00.05": [ - -0.25, - -0.75, - 0, - 30 - ], - "Cabinet|-00.84|+00.47|-01.67": [ - 0.0, - -1.0, - 180, - 30 - ], - "Cabinet|-01.15|+02.02|+00.38": [ - -0.5, - -0.25, - 270, - 0 - ], - "Cabinet|-01.15|+02.02|-00.77": [ - -0.5, - -0.5, - 270, - 0 - ], - "Cabinet|-01.15|+02.02|-01.98": [ - -0.5, - -1.25, - 270, - 0 - ], - "CounterTop|+01.16|+00.95|-02.01": [ - 1.0, - -1.25, - 180, - 30 - ], - "CounterTop|-00.63|+01.17|+00.57": [ - 0.0, - 1.25, - 180, - 0 - ], - "CounterTop|-00.67|+00.95|+00.19": [ - -0.5, - -0.25, - 0, - 30 - ], - "Drawer|-00.07|+00.75|-00.01": [ - 0.5, - -1.0, - 0, - 0 - ], - "Drawer|-00.45|+00.75|-00.01": [ - -0.25, - -0.5, - 270, - 30 - ], - "Drawer|-00.82|+00.75|-01.69": [ - -0.5, - -0.75, - 180, - 0 - ], - "Fridge|+01.98|+00.00|-00.54": [ - 1.0, - -0.5, - 90, - 30 - ], - "GarbageCan|+01.92|-00.01|+00.14": [ - 1.25, - 0.25, - 90, - 30 - ], - "Microwave|+01.83|+00.90|-01.35": [ - 1.0, - -1.0, - 90, - 0 - ], - "Shelf|+02.76|+00.55|+00.15": [ - 2.25, - 0.75, - 180, - 30 - ], - "Shelf|+02.76|+00.88|+00.14": [ - 2.25, - 1.0, - 180, - 0 - ], - "Sink|-00.12|+00.88|-02.01|SinkBasin": [ - -0.5, - -1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy deleted file mode 100644 index eb8f5923c6598a033abf4ed882d8bcd55e632ffa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2176 zcmbW$Ax;BP5C-4}L2-(83rP)C4I!Zl2f-jvq@isPgpw`65Kh5?xWXO*iCj@pQ2})4 zs~E|emv7iN|I7j(S2vf}w|nKayw%g$^1i80tNLs{ss~j)Uo*OrB@IJ~|nW2G#I*P`y|Gd=AU@`Tp$Bb(~+x>Z_>dvrBdTyr&3#ikAI_)# z>iTmV{kh++6mHM^3V$VkC!0^MJy;*kr}@;|n2*iJ=411*`M8UD*}QVi%jRYGIG^TK zH!qu)&CBLx^XY3oHXoah_2GP)Z+!{%f2vHA2dA9wNlWBarItUqt!zI*am9_z>Y zv3}mukM-j&z6ZOnulwviyU*^cyU*^kdz{Zz%%`ruy8gV1@5%OJd8{wzQ{Fn}kjL^^ z9?N5SERQ!a|0dC<*_`L$MRSn%iB+RERVaGhyDMv|9@`N z`z4;;&*QtYeb_#1AGQzM=U`m6kMGC!Vf(Os*gk9@?o&$PHuhoruzlD*Y@dVi54~bm AHUIzs diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json deleted file mode 100644 index b584a4738..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - "PaperTowelRoll", - "StoveBurner", - "Stool", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "Knife", - "GarbageCan", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json deleted file mode 100644 index 8337ad36d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json +++ /dev/null @@ -1,164 +0,0 @@ -{ - "Cabinet|+00.15|+02.01|-01.60": [ - 0.75, - -1.0, - 180, - 0 - ], - "Cabinet|+01.57|+02.01|+00.47": [ - 0.75, - 0.25, - 90, - 0 - ], - "Cabinet|+01.57|+02.01|-00.78": [ - 0.75, - -1.0, - 90, - 0 - ], - "Cabinet|-02.15|+00.40|+00.64": [ - -1.5, - 0.0, - 0, - 30 - ], - "Cabinet|-02.15|+00.40|+00.70": [ - -1.25, - 1.5, - 180, - 30 - ], - "Cabinet|-02.15|+00.40|+01.58": [ - -1.25, - 0.75, - 0, - 30 - ], - "Cabinet|-02.15|+00.40|-00.24": [ - -1.5, - -0.5, - 0, - 30 - ], - "Cabinet|-02.29|+01.97|-01.33": [ - -1.5, - -1.25, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+00.36": [ - -1.5, - -0.25, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+00.41": [ - -1.75, - 1.0, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+01.64": [ - -1.75, - 1.0, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+01.69": [ - -1.75, - 2.25, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+02.93": [ - -1.75, - 2.25, - 270, - 0 - ], - "Cabinet|-02.45|+02.15|-00.29": [ - -1.5, - 0.0, - 270, - 0 - ], - "Cabinet|-02.45|+02.15|-01.28": [ - -1.25, - -0.75, - 270, - 0 - ], - "CounterTop|+00.47|+00.95|-01.63": [ - 0.75, - -1.0, - 180, - 30 - ], - "CounterTop|+01.59|+00.95|+00.41": [ - 1.0, - 0.75, - 90, - 30 - ], - "CounterTop|-00.36|+00.95|+01.09": [ - 0.5, - 1.25, - 270, - 30 - ], - "CounterTop|-01.49|+00.95|+01.32": [ - -1.75, - 0.5, - 270, - 30 - ], - "Drawer|-02.28|+00.79|+00.44": [ - -1.5, - 0.0, - 0, - 30 - ], - "Drawer|-02.28|+00.79|+00.90": [ - -1.5, - 0.5, - 0, - 30 - ], - "Drawer|-02.28|+00.79|+01.37": [ - -1.5, - 1.75, - 180, - 30 - ], - "Drawer|-02.28|+00.79|-00.03": [ - -1.5, - -0.5, - 0, - 30 - ], - "Fridge|-02.48|+00.00|-00.78": [ - -1.5, - -0.75, - 270, - 30 - ], - "GarbageCan|+01.65|00.00|+00.68": [ - 1.0, - 1.0, - 90, - 30 - ], - "Microwave|-02.58|+00.90|+02.44": [ - -1.75, - 2.5, - 270, - 0 - ], - "Sink|+01.38|+00.81|-01.27|SinkBasin": [ - 0.75, - -1.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy deleted file mode 100644 index 17b04ef444e20b59a55d337e4b7bd3e6962f4de5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4352 zcmbW%F>Vt<6b9g7WvwF1hj3?*Ttx_>2#KxeKr|Fo$Rds?P=ahkgE$2T@*crQNSSgA z7cN{7^5$D9ugo@+Z)SF9-v11LKYV)s@$<9ttNdPEuD4$|i;MZ<&DHD0a=y5_+5FtB zuD{%DF4zC(->trH*Z1?=Z>t~cdp|#a^>R5sf3ckZnLqKFmWOB7$9UMqI88oFZj-$~ zr1#nT?0xqBU3#Cr&)(xa-q!D!-zS&)jO%Y>f^U=Wl859&vU=P@o~#~L50CfQ#l6fM z)x+xHeZ3E>ht^H+@W zH7j41FUyzZJGzg*)G1$EcE# zf0jSXpXJZ;AKl0I)ggbDKeuVW{H@EM<o(te-sV<9qI*f2@Dp zrv3V7UH@4B_*C;{{bT*(A???{alQ6~)x~*~uX*`$)0KyZ<;(JA`LcXjzRr~|%a_|e z&S&|ud|AGHs(JA-S-#fg#qP~{l$ZIYOZQEdm;Lf$d9l2lBQKT*%Y)^?^5A35gXO`_ cSJ$ME`q+8wJa!&CkDbTP^E>lB_Pt5>5B$3_i~s-t diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json deleted file mode 100644 index 02e51c382..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json +++ /dev/null @@ -1,50 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Stool", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Statue", - "PepperShaker", - "Pan", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "Knife", - "GarbageCan", - "Book", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "DiningTable", - "Floor", - "HousePlant", - "Potato", - "Vase", - "Mug", - "CounterTop", - "ShelvingUnit", - "Spatula", - "Shelf", - "Chair", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json deleted file mode 100644 index f0f78366b..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json +++ /dev/null @@ -1,146 +0,0 @@ -{ - "Cabinet|+00.38|+00.37|-01.24": [ - -0.25, - -0.5, - 90, - 30 - ], - "Cabinet|+00.52|+02.01|-01.54": [ - 0.25, - -0.75, - 180, - 0 - ], - "Cabinet|+00.78|+00.37|-01.24": [ - 0.0, - -0.5, - 90, - 30 - ], - "Cabinet|+01.45|+02.26|-01.54": [ - 1.0, - -0.75, - 180, - 0 - ], - "Cabinet|+01.78|+00.37|-01.24": [ - 1.25, - -0.5, - 90, - 30 - ], - "Cabinet|+01.78|+02.01|-01.54": [ - 1.25, - -0.75, - 180, - 0 - ], - "Cabinet|-00.57|+00.37|-01.24": [ - 0.25, - -0.5, - 270, - 30 - ], - "Cabinet|-00.71|+02.01|-01.54": [ - -0.5, - -0.75, - 180, - 0 - ], - "Cabinet|-01.48|+00.37|-01.24": [ - -0.75, - -0.25, - 180, - 30 - ], - "Cabinet|-01.67|+02.01|-01.54": [ - -1.0, - -0.75, - 180, - 0 - ], - "Cabinet|-02.17|+02.01|-01.54": [ - -2.75, - -1.0, - 90, - 0 - ], - "Cabinet|-02.22|+00.37|-01.87": [ - -2.75, - -1.25, - 90, - 30 - ], - "CounterTop|+01.65|+00.95|-01.53": [ - 1.25, - -0.75, - 90, - 30 - ], - "CounterTop|-01.87|+00.95|-00.61": [ - -2.5, - 0.5, - 90, - 30 - ], - "DiningTable|-02.66|+00.00|+03.21": [ - -2.5, - 2.25, - 0, - 30 - ], - "Drawer|+00.60|+00.68|-01.40": [ - 1.0, - -0.75, - 270, - 30 - ], - "Drawer|-01.64|+00.68|-00.93": [ - -1.0, - -0.25, - 270, - 30 - ], - "Drawer|-02.06|+00.68|-01.58": [ - -3.0, - -1.0, - 180, - 30 - ], - "Fridge|-00.04|+00.00|+02.18": [ - 0.0, - 1.25, - 0, - 30 - ], - "GarbageCan|-00.87|00.00|+02.14": [ - -1.75, - 1.5, - 0, - 30 - ], - "Microwave|+01.15|+01.66|-01.61": [ - 0.75, - -0.75, - 180, - 0 - ], - "Shelf|+03.73|+00.55|+01.67": [ - 2.5, - 1.75, - 90, - 0 - ], - "Shelf|+03.73|+00.88|+01.67": [ - 3.25, - 1.75, - 90, - 30 - ], - "Sink|+00.02|+00.77|-01.71|SinkBasin": [ - -0.75, - -0.75, - 180, - 0 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy deleted file mode 100644 index f768a488c36e0b0a939b69a01e5488a6c8e1cd65..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2768 zcmbW$ze*!f6u{xDgcLr-bfb`Fgl@bI&ivyq^C#ySUsbPvyD2p3eWy+M}jDzWLpbn)c>?_Bfl|UER;F zr(gT0liT_9bASGC@-Y4M{*PZjN6q2EsCjAr^V%!l*Kk?a^`fr43J>BwyWgk#yc^GR zNp_C=d3}#_?U%T?JETD)wA7?@0<0o`QGc}`(X3ge0C1!)!)Ou`E0)D%xCl2 zd^Vq*%Xu~5{whANee>CTHlNLB^VuBEtNHKoJ(YWxcGI z^>R!rte5q&-reZa%X(Qa>t(&Hm-TXqi}kWz);k!N?@KT1WxcGI^|D^p%XMlgte5q2 eS=Kj(B9dbv(5h4r%D;rIgsV3kz> diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json deleted file mode 100644 index 12da9582d..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json +++ /dev/null @@ -1,46 +0,0 @@ -[ - "ButterKnife", - "Drawer", - "Lettuce", - "Toaster", - "StoveKnob", - "SaltShaker", - "Pot", - "Microwave", - "Stool", - "HousePlant", - "Floor", - "Apple", - "Fork", - "Cabinet", - "StoveBurner", - "LightSwitch", - "CoffeeMachine", - "SprayBottle", - "SinkBasin", - "Knife", - "Fridge", - "Spatula", - "Mug", - "Faucet", - "Ladle", - "SoapBottle", - "Sink", - "CounterTop", - "Kettle", - "Tomato", - "Cup", - "Egg", - "GarbageCan", - "Bowl", - "Bread", - "DishSponge", - "PepperShaker", - "Pen", - "Bottle", - "Plate", - "Window", - "Pan", - "Spoon", - "Potato" -] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json deleted file mode 100644 index a327a281a..000000000 --- a/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json +++ /dev/null @@ -1,170 +0,0 @@ -{ - "Cabinet|+00.49|+02.06|-01.69": [ - 0.5, - -0.75, - 180, - 0 - ], - "Cabinet|+00.83|+00.40|-01.39": [ - 0.0, - -0.5, - 90, - 30 - ], - "Cabinet|+00.86|+00.40|+00.67": [ - 0.0, - 0.0, - 90, - 30 - ], - "Cabinet|+00.86|+00.40|-00.55": [ - 0.0, - -0.75, - 90, - 30 - ], - "Cabinet|+00.86|+00.40|-01.37": [ - 0.0, - -1.0, - 90, - 30 - ], - "Cabinet|+01.16|+02.06|-00.34": [ - 0.5, - -0.75, - 90, - 0 - ], - "Cabinet|+01.16|+02.06|-01.02": [ - 0.25, - -1.0, - 90, - 0 - ], - "Cabinet|-00.19|+02.06|-01.69": [ - 0.0, - -1.0, - 180, - 0 - ], - "Cabinet|-00.20|+00.40|-01.39": [ - -0.5, - -0.5, - 90, - 30 - ], - "Cabinet|-00.24|+00.40|-01.39": [ - -0.75, - -0.75, - 90, - 30 - ], - "Cabinet|-00.82|+00.40|-01.39": [ - -1.25, - -0.5, - 90, - 30 - ], - "Cabinet|-00.82|+02.06|-01.69": [ - 0.0, - -1.0, - 180, - 0 - ], - "Cabinet|-00.87|+02.01|-01.69": [ - -1.5, - -0.5, - 180, - 0 - ], - "Cabinet|-01.61|+02.01|-01.69": [ - -2.0, - -0.5, - 180, - 0 - ], - "Cabinet|-01.66|+02.06|-01.68": [ - -2.25, - -1.0, - 180, - 0 - ], - "Cabinet|-01.67|+00.40|-01.39": [ - -2.0, - -1.0, - 180, - 30 - ], - "Cabinet|-02.24|+00.40|-01.39": [ - -2.5, - -1.0, - 180, - 30 - ], - "CounterTop|+01.17|+00.95|-00.65": [ - 0.5, - -0.75, - 90, - 30 - ], - "CounterTop|+01.50|+01.20|-00.66": [ - 0.5, - -1.0, - 90, - 0 - ], - "CounterTop|-01.97|+00.95|-01.71": [ - -2.5, - -1.25, - 90, - 30 - ], - "CounterTop|-02.10|+00.95|+00.29": [ - -1.5, - -0.25, - 0, - 30 - ], - "Drawer|+00.59|+00.75|-01.39": [ - 0.0, - -0.75, - 90, - 30 - ], - "Drawer|+00.86|+00.75|+00.43": [ - 0.0, - 1.0, - 90, - 0 - ], - "Drawer|+00.87|+00.75|-01.14": [ - 0.0, - -1.0, - 90, - 0 - ], - "Fridge|+01.42|+00.00|+02.10": [ - 0.5, - 2.0, - 90, - 0 - ], - "GarbageCan|+01.34|+00.02|+01.04": [ - 0.5, - 0.5, - 0, - 30 - ], - "Microwave|+01.42|+01.15|+00.02": [ - 0.5, - 0.5, - 90, - 0 - ], - "Sink|+00.16|+00.82|-01.80|SinkBasin": [ - 0.5, - -1.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy deleted file mode 100644 index bd4533e3927e8b5b7557a060a87f6091d6716e6a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1360 zcmbWzp-#h46b9hSLI~k0>I%seW`vMz3J1X;P^4j95QLGIUjvA*o7FV+|9i}l6&V) 0: - lock.acquire() - scene_num = all_scene_numbers.pop() - lock.release() - fn = os.path.join('layouts', ('FloorPlan%d-layout.npy') % scene_num) - if os.path.isfile(fn): - print("file %s already exists; skipping this floorplan" % fn) - continue - - openable_json_file = os.path.join('layouts', ('FloorPlan%d-openable.json') % scene_num) - scene_objs_json_file = os.path.join('layouts', ('FloorPlan%d-objects.json') % scene_num) - - scene_name = ('FloorPlan%d') % scene_num - print('Running ' + scene_name) - event = env.reset(scene_name, - render_image=False, - render_depth_image=False, - render_class_image=False, - render_object_image=True) - agent_height = event.metadata['agent']['position']['y'] - - scene_objs = list(set([obj['objectType'] for obj in event.metadata['objects']])) - with open(scene_objs_json_file, 'w') as sof: - json.dump(scene_objs, sof, sort_keys=True, indent=4) - - # Get all the reachable points through Unity for this step size. - event = env.step(dict(action='GetReachablePositions', - gridSize=constants.AGENT_STEP_SIZE / constants.RECORD_SMOOTHING_FACTOR)) - if event.metadata['actionReturn'] is None: - print("ERROR: scene %d 'GetReachablePositions' returns None" % scene_num) - else: - reachable_points = set() - for point in event.metadata['actionReturn']: - reachable_points.add((point['x'], point['z'])) - print("scene %d got %d reachable points, now checking" % (scene_num, len(reachable_points))) - - # Pick up a small object to use in testing whether points are good for openable objects. - open_test_objs = {'CD', 'CellPhone', 'Cloth', 'CreditCard', 'DishSponge', 'Fork', - 'KeyChain', 'Pen', 'Pencil', 'SoapBar', 'Spoon', 'Watch'} - good_obj_point = None - good_obj_point = get_obj(env, open_test_objs, reachable_points, agent_height, scene_name, good_obj_point) - - - best_open_point = {} # map from object names to the best point from which they can be successfully opened - best_sem_coverage = {} # number of pixels in the semantic map of the receptacle at the existing best openpt - checked_points = set() - scene_receptacles = set() - for point in reachable_points: - point_is_valid = True - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - } - event = env.step(action) - if event.metadata['lastActionSuccess']: - for horizon in [-30, 0, 30]: - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - 'rotateOnTeleport': True, - 'rotation': 0, - 'horizon': horizon - } - event = env.step(action) - if not event.metadata['lastActionSuccess']: - point_is_valid = False - break - for rotation in range(3): - action = {'action': 'RotateLeft'} - event = env.step(action) - if not event.metadata['lastActionSuccess']: - point_is_valid = False - break - if not point_is_valid: - break - if point_is_valid: - checked_points.add(point) - else: - continue - - # Check whether we can open objects from here in any direction with any tilt. - for rotation in range(4): - # First try up, then down, then return to the horizon before moving again. - for horizon in [-30, 0, 30]: - - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - 'rotateOnTeleport': True, - 'rotation': rotation * 90, - 'horizon': horizon - } - event = env.step(action) - for obj in event.metadata['objects']: - if (obj['visible'] and obj['objectId'] and obj['receptacle'] and not obj['pickupable'] - and obj['objectType'] in constants.VAL_RECEPTACLE_OBJECTS): - obj_name = obj['objectId'] - obj_point = (obj['position']['x'], obj['position']['y']) - scene_receptacles.add(obj_name) - - # Go ahead and attempt to close the object from this position if it's open. - if obj['openable'] and obj['isOpen']: - close_action = {'action': 'CloseObject', - 'objectId': obj['objectId']} - event = env.step(close_action) - - point_to_recep = np.linalg.norm(np.array(point) - np.array(obj_point)) - if len(env.last_event.metadata['inventoryObjects']) > 0: - inv_obj = env.last_event.metadata['inventoryObjects'][0]['objectId'] - else: - inv_obj = None - - # Heuristic implemented in task_game_state has agent 0.5 or farther in agent space. - heuristic_far_enough_from_recep = 0.5 < point_to_recep - # Ensure this point affords a larger view according to the semantic segmentation - # of the receptacle than the existing. - point_sem_coverage = get_mask_of_obj(env, obj['objectId']) - if point_sem_coverage is None: - use_sem_heuristic = False - better_sem_covereage = False - else: - use_sem_heuristic = True - better_sem_covereage = (obj_name not in best_sem_coverage or - best_sem_coverage[obj_name] is None or - point_sem_coverage > best_sem_coverage[obj_name]) - # Ensure that this point is farther away than our existing best candidate. - # We'd like to open each receptacle from as far away as possible while retaining - # the ability to pick/place from it. - farther_than_existing_good_point = (obj_name not in best_open_point or - point_to_recep > - np.linalg.norm( - np.array(point) - - np.array(best_open_point[obj_name][:2]))) - # If we don't have an inventory object, though, we'll fall back to the heuristic - # of being able to open/close as _close_ as possible. - closer_than_existing_good_point = (obj_name not in best_open_point or - point_to_recep < - np.linalg.norm( - np.array(point) - - np.array(best_open_point[obj_name][:2]))) - # Semantic segmentation heuristic. - if ((use_sem_heuristic and heuristic_far_enough_from_recep and better_sem_covereage) - or (not use_sem_heuristic and - # Distance heuristics. - (heuristic_far_enough_from_recep and - (inv_obj and farther_than_existing_good_point) or - (not inv_obj and closer_than_existing_good_point)))): - if obj['openable']: - action = {'action': 'OpenObject', - 'objectId': obj['objectId']} - event = env.step(action) - if not obj['openable'] or event.metadata['lastActionSuccess']: - # We can open the object, so try placing our small inventory obj inside. - # If it can be placed inside and retrieved, then this is a safe point. - action = {'action': 'PutObject', - 'objectId': obj['objectId'], - 'forceAction': True, - 'placeStationary': True} - if inv_obj: - event = env.step(action) - if inv_obj is None or event.metadata['lastActionSuccess']: - action = {'action': 'PickupObject', - 'objectId': inv_obj} - if inv_obj: - event = env.step(action) - if inv_obj is None or event.metadata['lastActionSuccess']: - - # Finally, ensure we can also close the receptacle. - if obj['openable']: - action = {'action': 'CloseObject', - 'objectId': obj['objectId']} - event = env.step(action) - if not obj['openable'] or event.metadata['lastActionSuccess']: - - # We can put/pick our inv object into the receptacle from here. - # We have already ensured this point is farther than any - # existing best, so this is the new best. - best_open_point[obj_name] = [point[0], point[1], rotation * 90, horizon] - best_sem_coverage[obj_name] = point_sem_coverage - - # We could not retrieve our inv object, so we need to go get another one - else: - good_obj_point = get_obj(env, open_test_objs, reachable_points, - agent_height, scene_name, good_obj_point) - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - 'rotateOnTeleport': True, - 'rotation': rotation * 90, - 'horizon': horizon - } - event = env.step(action) - - # Regardless of what happened up there, try to close the receptacle again if - # it remained open. - if obj['isOpen']: - action = {'action': 'CloseObject', - 'objectId': obj['objectId']} - event = env.step(action) - - essential_objs = [] - if scene_num in constants.SCENE_TYPE["Kitchen"]: - essential_objs.extend(["Microwave", "Fridge"]) - for obj in essential_objs: - if not np.any([obj in obj_key for obj_key in best_open_point]): - print("WARNING: Essential object %s has no open points in scene %d" % (obj, scene_num)) - - print("scene %d found open/pick/place/close positions for %d/%d receptacle objects" % - (scene_num, len(best_open_point), len(scene_receptacles))) - with open(openable_json_file, 'w') as f: - json.dump(best_open_point, f, sort_keys=True, indent=4) - - print("scene %d reachable %d, checked %d; taking intersection" % - (scene_num, len(reachable_points), len(checked_points))) - - points = np.array(list(checked_points))[:, :2] - points = points[np.lexsort((points[:, 0], points[:, 1])), :] - np.save(fn, points) - - env.stop() - print('Done') - - -threads = [] -for n in range(N_PROCS): - thread = threading.Thread(target=run, args=(n,)) - threads.append(thread) - thread.start() - time.sleep(1) diff --git a/models/main_models/rt1/gen/planner/__init__.py b/models/main_models/rt1/gen/planner/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl b/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl deleted file mode 100644 index 60280d713..000000000 --- a/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl +++ /dev/null @@ -1,302 +0,0 @@ -;; Specification in PDDL1 of the Extended Task domain - -(define (domain put_task) - (:requirements - :adl - ) - (:types - agent - location - receptacle - object - rtype - otype - ) - - - (:predicates - (atLocation ?a - agent ?l - location) ; true if the agent is at the location - (receptacleAtLocation ?r - receptacle ?l - location) ; true if the receptacle is at the location (constant) - (objectAtLocation ?o - object ?l - location) ; true if the object is at the location - (openable ?r - receptacle) ; true if a receptacle is openable - (opened ?r - receptacle) ; true if a receptacle is opened - (inReceptacle ?o - object ?r - receptacle) ; object ?o is in receptacle ?r - (isReceptacleObject ?o - object) ; true if the object can have things put inside it - (inReceptacleObject ?innerObject - object ?outerObject - object) ; object ?innerObject is inside object ?outerObject - (wasInReceptacle ?o - object ?r - receptacle) ; object ?o was or is in receptacle ?r now or some time in the past - ;(checked ?r - receptacle) ; whether the receptacle has been looked inside/visited - (receptacleType ?r - receptacle ?t - rtype) ; the type of receptacle (Cabinet vs Cabinet|01|2...) - (objectType ?o - object ?t - otype) ; the type of object (Apple vs Apple|01|2...) - (holds ?a - agent ?o - object) ; object ?o is held by agent ?a - (holdsAny ?a - agent) ; agent ?a holds an object - (holdsAnyReceptacleObject ?a - agent) ; agent ?a holds a receptacle object - ;(full ?r - receptacle) ; true if the receptacle has no remaining space - (isClean ?o - object) ; true if the object has been clean in sink - (cleanable ?o - object) ; true if the object can be placed in a sink - (isHot ?o - object) ; true if the object has been heated up - (heatable ?o - object) ; true if the object can be heated up in a microwave - (isCool ?o - object) ; true if the object has been cooled - (coolable ?o - object) ; true if the object can be cooled in the fridge - (toggleable ?o - object) ; true if the object can be turned on/off - (isOn ?o - object) ; true if the object is on - (isToggled ?o - object) ; true if the object has been toggled - (sliceable ?o - object) ; true if the object can be sliced - (isSliced ?o - object) ; true if the object is sliced - ) - - (:functions - (distance ?from ?to) - (totalCost) - ) - -;; All actions are specified such that the final arguments are the ones used -;; for performing actions in Unity. - -;; agent goes to receptacle - (:action GotoLocation - :parameters (?a - agent ?lStart - location ?lEnd - location) - :precondition (and - (atLocation ?a ?lStart) - (forall (?re - receptacle) - (not (opened ?re)) - ) - ) - :effect (and - (atLocation ?a ?lEnd) - (not (atLocation ?a ?lStart)) - (increase (totalCost) (distance ?lStart ?lEnd)) - ) - ) - -;; agent opens receptacle - (:action OpenObject - :parameters (?a - agent ?l - location ?r - receptacle) - :precondition (and - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (openable ?r) - (forall (?re - receptacle) - (not (opened ?re)) - ) - ) - :effect (and - (opened ?r) - (increase (totalCost) 1) - ) - ) -;; agent closes receptacle - (:action CloseObject - :parameters (?a - agent ?al - location ?r - receptacle) - :precondition (and - (atLocation ?a ?al) - (receptacleAtLocation ?r ?al) - (openable ?r) - (opened ?r) - ) - :effect (and - (not (opened ?r)) - (increase (totalCost) 1) - ) - - ) - -;; agent picks up object - (:action PickupObjectInReceptacle1 - :parameters (?a - agent ?l - location ?o - object ?r - receptacle) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?o ?l) - (inReceptacle ?o ?r) - (not (holdsAny ?a)) - ) - :effect (and - (forall (?re - receptacle) - (not (inReceptacle ?o ?re)) - ) - (not (objectAtLocation ?o ?l)) - (holds ?a ?o) - (holdsAny ?a) - (increase (totalCost) 1) - ) - ) - -;; agent picks up object not in a receptacle - (:action PickupObjectNoReceptacle - :parameters (?a - agent ?l - location ?o - object) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?o ?l) - (forall (?r - receptacle) - (not (inReceptacle ?o ?r)) - ) - (not (holdsAny ?a)) - ) - :effect (and - (not (objectAtLocation ?o ?l)) - (holds ?a ?o) - (holdsAny ?a) - (increase (totalCost) 1) - ) - ) - -;; agent puts down an object in a receptacle - (:action PutObjectInReceptacle1 - :parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle) ;?rt - rtype) - :precondition (and - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (objectType ?o ?ot) - (holds ?a ?o) - (not (holdsAnyReceptacleObject ?a)) - ) - :effect (and - (inReceptacle ?o ?r) - (not (holds ?a ?o)) - (not (holdsAny ?a)) - (increase (totalCost) 1) - (objectAtLocation ?o ?l) - ) - ) - -;; agent puts down an object - (:action PutObjectInReceptacleObject1 - :parameters (?a - agent ?l - location ?ot - otype ?o - object ?outerO - object ?outerR - receptacle) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?outerO ?l) - (isReceptacleObject ?outerO) - (not (isReceptacleObject ?o)) - (objectType ?o ?ot) - (holds ?a ?o) - (not (holdsAnyReceptacleObject ?a)) - (inReceptacle ?outerO ?outerR) - ) - :effect (and - (inReceptacleObject ?o ?outerO) - (inReceptacle ?o ?outerR) - (not (holds ?a ?o)) - (not (holdsAny ?a)) - (increase (totalCost) 1) - (objectAtLocation ?o ?l) - ) - ) - -;; agent puts down a receptacle object in a receptacle - (:action PutReceptacleObjectInReceptacle1 - :parameters (?a - agent ?l - location ?ot - otype ?outerO - object ?r - receptacle) ; ?rt - rtype) - :precondition (and - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (objectType ?outerO ?ot) - (holds ?a ?outerO) - (holdsAnyReceptacleObject ?a) - (isReceptacleObject ?outerO) - ) - :effect (and - (forall (?obj - object) - (when (holds ?a ?obj) - (and - (not (holds ?a ?obj)) - (objectAtLocation ?obj ?l) - (inReceptacle ?obj ?r) - ) - ) - ) - (not (holdsAny ?a)) - (not (holdsAnyReceptacleObject ?a)) - (increase (totalCost) 1) - ) - ) - -;; agent cleans some object - (:action CleanObject - :parameters (?a - agent ?l - location ?r - receptacle ?o - object) - :precondition (and - (receptacleType ?r SinkBasinType) - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (holds ?a ?o) - ) - :effect (and - (increase (totalCost) 5) - (isClean ?o) - ) - ) - - -;; agent heats-up some object - (:action HeatObject - :parameters (?a - agent ?l - location ?r - receptacle ?o - object) - :precondition (and - (or - (receptacleType ?r MicrowaveType) - ) - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (holds ?a ?o) - ) - :effect (and - (increase (totalCost) 5) - (isHot ?o) - ) - ) - -;; agent cools some object - (:action CoolObject - :parameters (?a - agent ?l - location ?r - receptacle ?o - object) - :precondition (and - (or - (receptacleType ?r FridgeType) - ) - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (holds ?a ?o) - ) - :effect (and - (increase (totalCost) 5) - (isCool ?o) - ) - ) - - -;; agent toggle object - (:action ToggleObject - :parameters (?a - agent ?l - location ?o - object) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?o ?l) - (toggleable ?o) - ) - :effect (and - (increase (totalCost) 5) - (when (isOn ?o) - (not (isOn ?o))) - (when (not (isOn ?o)) - (isOn ?o)) - (isToggled ?o) - ) - ) - - -;; agent slices some object with a knife - (:action SliceObject - :parameters (?a - agent ?l - location ?co - object ?ko - object) - :precondition - (and - (or - (objectType ?ko KnifeType) - (objectType ?ko ButterKnifeType) - ) - (atLocation ?a ?l) - (objectAtLocation ?co ?l) - (sliceable ?co) - (holds ?a ?ko) - ) - :effect (and - (increase (totalCost) 5) - (isSliced ?co) - ) - ) - - -) diff --git a/models/main_models/rt1/gen/planner/ff_planner_handler.py b/models/main_models/rt1/gen/planner/ff_planner_handler.py deleted file mode 100644 index 50937c677..000000000 --- a/models/main_models/rt1/gen/planner/ff_planner_handler.py +++ /dev/null @@ -1,252 +0,0 @@ -import pdb -import ast -import multiprocessing -import re -import shlex -import subprocess -import time - -import constants -from utils import game_util -from utils import py_util - -DEBUG = False - -CAPS_ACTION_TO_PLAN_ACTION = { - 'GOTOLOCATION': 'GotoLocation', - 'SCAN': 'Scan', - 'OPENOBJECT': 'OpenObject', - 'CLOSEOBJECT': 'CloseObject', - 'PICKUPOBJECT': 'PickupObject', - 'PICKUPOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', - 'PICKUPOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', - 'PICKUPRECEPTACLEOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', - 'PICKUPRECEPTACLEOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', - 'PICKUPOBJECTINOBJECT1': 'PickupObjectInObject', - 'PICKUPOBJECTINOBJECT2': 'PickupObjectInObject', - 'PUTOBJECTINRECEPTACLE1': 'PutObjectInReceptacle', - 'PUTOBJECTINRECEPTACLE2': 'PutObjectInReceptacle', - 'PUTOBJECTINRECEPTACLEOBJECT1': 'PutObjectInReceptacleObject', - 'PUTOBJECTINRECEPTACLEOBJECT2': 'PutObjectInReceptacleObject', - 'PUTRECEPTACLEOBJECTINRECEPTACLE1': 'PutReceptacleObjectInReceptacle', - 'PUTRECEPTACLEOBJECTINRECEPTACLE2': 'PutReceptacleObjectInReceptacle', - 'PICKUPOBJECTNORECEPTACLE': 'PickupObjectNoReceptacle', - 'PUTOBJECT': 'PutObject', - 'CLEANOBJECT': 'CleanObject', - 'HEATOBJECT': 'HeatObject', - 'TOGGLEOBJECT': 'ToggleObject', - 'COOLOBJECT': 'CoolObject', - 'SLICEOBJECT': 'SliceObject', - 'REACH-GOAL': 'End' -} - -LOWER_TO_FULL = {name.lower(): name for name in constants.OBJECTS} - - -def lower_to_full(input_str): - arr = input_str.split('|') - new_arr = [] - for item in arr: - if item in LOWER_TO_FULL: - new_arr.append(LOWER_TO_FULL[item]) - else: - new_arr.append(item) - return '|'.join(new_arr) - - - -def parse_action_arg(action_arg): - action_arg = action_arg.lower() - action_arg = py_util.multireplace(action_arg, - {'_minus_': '-', - '-': '#', - '_bar_': '|', - '_plus_': '+', - '_dot_': '.', - '_comma_': ','}) - action_arg = lower_to_full(action_arg) - return action_arg - - -def parse_line(line): - line = re.sub(r'^\s*step|\d+:\s*', '', line) - line = line.strip() - line_args = line.split(' ') - if line_args[0] not in CAPS_ACTION_TO_PLAN_ACTION: - return None - action = CAPS_ACTION_TO_PLAN_ACTION[line_args[0]] - if action == 'End': - return {'action': 'End', 'value': 1} - action_dict = {'action': action} - line_args = line_args[1:] # Remove action name from line_args - - if action in {'GotoLocation', 'Scan'}: - action_arg = line_args[2].lower() - action_arg = py_util.multireplace(action_arg, - {'_minus_': '-', - '-': '#', - '_bar_': '|', - '_plus_': '+', - '_dot_': '.', - '_comma_': ','}) - action_dict['location'] = action_arg - elif action in {'OpenObject', 'CloseObject', 'ToggleObject'}: - action_dict['objectId'] = parse_action_arg(line_args[2]) - action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) - elif action in {'HeatObject', 'CoolObject'}: - action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) - elif action in {'PickupObjectInReceptacle', 'PickupObjectNoReceptacle'}: - action_dict['action'] = 'PickupObject' - action_dict['objectId'] = parse_action_arg(line_args[2]) - if action == 'PickupObjectInReceptacle': - action_dict['receptacleObjectId'] = parse_action_arg(line_args[3]) - elif action in {'SliceObject'}: - action_dict['objectId'] = parse_action_arg(line_args[2]) - elif action in {'CleanObject'}: - action_dict['objectId'] = parse_action_arg(line_args[3]) - action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) - elif action in {'PutObjectInReceptacle', - 'PutObjectInReceptacleObject', - 'PutReceptacleObjectInReceptacle'}: - action_dict['action'] = 'PutObject' - action_dict['objectId'] = parse_action_arg(line_args[3]) - action_dict['receptacleObjectId'] = parse_action_arg(line_args[4]) - elif action in {'PickupObjectInObject'}: - action_dict['action'] = 'PickupObject' - - - return action_dict - - -def parse_plan(lines): - plan = [] - for line in lines: - action_dict = parse_line(line) - if action_dict is not None: - plan.append(action_dict) - return plan - - -def parse_plan_from_file(self, path): - lines = [line for line in open(path)] - return self.parse_plan(lines) - - -def get_plan_from_file(args): - domain, filepath, solver_type = args - - start_t = time.time() - try: - command = ('ff_planner/ff ' - '-o %s ' - '-s %d ' - '-f %s ' % (domain, solver_type, filepath)) - if DEBUG: - print(command) - planner_output = subprocess.check_output(shlex.split(command), timeout=30) - except subprocess.CalledProcessError as error: - # Plan is done - output_str = error.output.decode('utf-8') - if DEBUG: - print('output', output_str) - if ('goal can be simplified to FALSE' in output_str or - "won't get here: simplify, non logical" in output_str): - return [{'action': 'End', 'value': 0}] - elif 'goal can be simplified to TRUE' in output_str: - return [{'action': 'End', 'value': 1}] - elif len(output_str) == 0: - # Usually indicates segfault with ffplanner - # This happens when the goal needs an object that hasn't been seen yet like - # Q: "is there an egg in the garbage can," but no garbage can has been seen. - print('Empty plan') - print('Seg Fault') - return [{'action': 'End', 'value': 0}] - else: - print('problem', filepath) - print(output_str) - print('Empty plan') - return [{'action': 'End', 'value': 0}] - except subprocess.TimeoutExpired: - print('timeout solver', solver_type, 'problem', filepath) - print('Empty plan') - return ['timeout', {'action': 'End', 'value': 0}] - unparsed_plan = planner_output.decode('utf-8').split('\n') - if DEBUG: - print('unparsed', '\n'.join(unparsed_plan)) - parsed_plan = parse_plan(unparsed_plan) - if constants.DEBUG: - print('planned %s in %.5f, plan length %d solver type %d' % ( - filepath, time.time() - start_t, len(parsed_plan), solver_type)) - if len(parsed_plan) == 0: - parsed_plan = [{'action': 'End', 'value': 1}] - return parsed_plan - - -# Example of how to call ff -# /path/to/Metric-FF-v2.1/ff -o planner/domains/Question_domain.pddl -f planner/exists_problem.pddl -def get_plan_async(args): - domain, problem_id, solver_type = args - filepath = '%s/planner/generated_problems/problem_%s.pddl' % (constants.LOG_FILE, problem_id) - return get_plan_from_file((domain, filepath, solver_type)) - - -class PlanParser(object): - def __init__(self, domain_file_path): - self.domain = domain_file_path - self.problem_id = -1 - self.process_pool = multiprocessing.Pool(3) - #from multiprocessing.pool import ThreadPool - #self.process_pool = ThreadPool(3) - - def get_plan(self): - parsed_plans = self.process_pool.map(get_plan_async, zip([self.domain] * 3, [self.problem_id] * 3, range(3, 6))) - return self.find_best_plan(parsed_plans) - - def get_plan_from_file(self, domain_path, filepath): - parsed_plans = self.process_pool.map(get_plan_from_file, zip([domain_path] * 3, [filepath] * 3, range(3, 6))) - return self.find_best_plan(parsed_plans) - - # Unncessary, planner should be optimal. But the planner produces some weird actions - def clean_plan(self, plan): - cleaned_plan = list() - for i in range(len(plan)-1): - if not (plan[i]['action'] == 'GotoLocation' and plan[i+1]['action'] == 'GotoLocation'): - cleaned_plan.append(plan[i]) - cleaned_plan.append(plan[len(plan)-1]) - return cleaned_plan - - def find_best_plan(self, parsed_plans): - - if all([parsed_plan[0] == 'timeout' for parsed_plan in parsed_plans]): - parsed_plan = parsed_plans[0][1:] - else: - parsed_plans = [self.clean_plan(parsed_plan) for parsed_plan in parsed_plans if parsed_plan[0] != 'timeout'] - parsed_plan = min(parsed_plans, key=len) - - if constants.DEBUG: - print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) - for pp, pl in enumerate(parsed_plan)])) - else: - print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) - for pp, pl in enumerate(parsed_plan)])) - return parsed_plan - - -class SinglePlanParser(PlanParser): - def get_plan(self): - parsed_plan = get_plan_async([self.domain, self.problem_id, 3]) - return parsed_plan - - def get_plan_from_file(self, domain_path, filepath): - parsed_plan = get_plan_from_file([domain_path, filepath, 3]) - return parsed_plan - - -if __name__ == '__main__': - import sys - - DEBUG = constants.DEBUG - parser = PlanParser('planner/domains/PutTaskExtended_domain.pddl') - parser.problem_id = sys.argv[1] - result_plan = parser.get_plan() - print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) for pp, pl in enumerate(result_plan)])) diff --git a/models/main_models/rt1/gen/planner/pddl.pdf b/models/main_models/rt1/gen/planner/pddl.pdf deleted file mode 100644 index 4acd4e0a5c03c58ab1177920fd70eaf3ce523982..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 196613 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

wc5{pc71>6lps{#4t; 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 diff --git a/models/main_models/rt1/gen/scripts/augment_trajectories.py b/models/main_models/rt1/gen/scripts/augment_trajectories.py deleted file mode 100644 index 19aeb9be2..000000000 --- a/models/main_models/rt1/gen/scripts/augment_trajectories.py +++ /dev/null @@ -1,312 +0,0 @@ -import os -import sys -sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) -sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) - -import json -import glob -import os -import constants -import cv2 -import shutil -import numpy as np -import argparse -import threading -import time -import copy -import random -from utils.video_util import VideoSaver -from utils.py_util import walklevel -from env.thor_env import ThorEnv - - -TRAJ_DATA_JSON_FILENAME = "traj_data.json" -AUGMENTED_TRAJ_DATA_JSON_FILENAME = "augmented_traj_data.json" - -ORIGINAL_IMAGES_FORLDER = "raw_images" -HIGH_RES_IMAGES_FOLDER = "high_res_images" -DEPTH_IMAGES_FOLDER = "depth_images" -INSTANCE_MASKS_FOLDER = "instance_masks" - -IMAGE_WIDTH = 600 -IMAGE_HEIGHT = 600 - -render_settings = dict() -render_settings['renderImage'] = True -render_settings['renderDepthImage'] = True -render_settings['renderObjectImage'] = True -render_settings['renderClassImage'] = True - -video_saver = VideoSaver() - - -def get_image_index(save_path): - return len(glob.glob(save_path + '/*.png')) - - -def save_image_with_delays(env, action, - save_path, direction=constants.BEFORE): - im_ind = get_image_index(save_path) - counts = constants.SAVE_FRAME_BEFORE_AND_AFTER_COUNTS[action['action']][direction] - for i in range(counts): - save_image(env.last_event, save_path) - env.noop() - return im_ind - - -def save_image(event, save_path): - # rgb - rgb_save_path = os.path.join(save_path, HIGH_RES_IMAGES_FOLDER) - rgb_image = event.frame[:, :, ::-1] - - # depth - depth_save_path = os.path.join(save_path, DEPTH_IMAGES_FOLDER) - depth_image = event.depth_frame - depth_image = depth_image * (255 / 10000) - depth_image = depth_image.astype(np.uint8) - - # masks - mask_save_path = os.path.join(save_path, INSTANCE_MASKS_FOLDER) - mask_image = event.instance_segmentation_frame - - # dump images - im_ind = get_image_index(rgb_save_path) - cv2.imwrite(rgb_save_path + '/%09d.png' % im_ind, rgb_image) - cv2.imwrite(depth_save_path + '/%09d.png' % im_ind, depth_image) - cv2.imwrite(mask_save_path + '/%09d.png' % im_ind, mask_image) - - return im_ind - - -def save_images_in_events(events, root_dir): - for event in events: - save_image(event, root_dir) - - -def clear_and_create_dir(path): - if os.path.exists(path): - shutil.rmtree(path) - os.mkdir(path) - - -def augment_traj(env, json_file): - # load json data - with open(json_file) as f: - traj_data = json.load(f) - - # make directories - root_dir = json_file.replace(TRAJ_DATA_JSON_FILENAME, "") - - orig_images_dir = os.path.join(root_dir, ORIGINAL_IMAGES_FORLDER) - high_res_images_dir = os.path.join(root_dir, HIGH_RES_IMAGES_FOLDER) - depth_images_dir = os.path.join(root_dir, DEPTH_IMAGES_FOLDER) - instance_masks_dir = os.path.join(root_dir, INSTANCE_MASKS_FOLDER) - augmented_json_file = os.path.join(root_dir, AUGMENTED_TRAJ_DATA_JSON_FILENAME) - - # fresh images list - traj_data['images'] = list() - - clear_and_create_dir(high_res_images_dir) - clear_and_create_dir(depth_images_dir) - clear_and_create_dir(instance_masks_dir) - - # scene setup - scene_num = traj_data['scene']['scene_num'] - object_poses = traj_data['scene']['object_poses'] - object_toggles = traj_data['scene']['object_toggles'] - dirty_and_empty = traj_data['scene']['dirty_and_empty'] - - # reset - scene_name = 'FloorPlan%d' % scene_num - env.reset(scene_name) - env.restore_scene(object_poses, object_toggles, dirty_and_empty) - - env.step(dict(traj_data['scene']['init_action'])) - print("Task: %s" % (traj_data['template']['task_desc'])) - - # setup task - env.set_task(traj_data, args, reward_type='dense') - rewards = [] - - for ll_idx, ll_action in enumerate(traj_data['plan']['low_actions']): - # next cmd under the current hl_action - cmd = ll_action['api_action'] - hl_action = traj_data['plan']['high_pddl'][ll_action['high_idx']] - - # remove unnecessary keys - cmd = {k: cmd[k] for k in ['action', 'objectId', 'receptacleObjectId', 'placeStationary', 'forceAction'] if k in cmd} - - if "MoveAhead" in cmd['action']: - if args.smooth_nav: - save_image(env.last_event, root_dir) - events = env.smooth_move_ahead(cmd, render_settings) - save_images_in_events(events, root_dir) - event = events[-1] - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - elif "Rotate" in cmd['action']: - if args.smooth_nav: - save_image(env.last_event, root_dir) - events = env.smooth_rotate(cmd, render_settings) - save_images_in_events(events, root_dir) - event = events[-1] - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - elif "Look" in cmd['action']: - if args.smooth_nav: - save_image(env.last_event, root_dir) - events = env.smooth_look(cmd, render_settings) - save_images_in_events(events, root_dir) - event = events[-1] - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - # handle the exception for CoolObject tasks where the actual 'CoolObject' action is actually 'CloseObject' - # TODO: a proper fix for this issue - elif "CloseObject" in cmd['action'] and \ - "CoolObject" in hl_action['planner_action']['action'] and \ - "OpenObject" in traj_data['plan']['low_actions'][ll_idx + 1]['api_action']['action']: - if args.time_delays: - cool_action = hl_action['planner_action'] - save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.BEFORE) - event = env.step(cmd) - save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.MIDDLE) - save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.AFTER) - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - else: - if args.time_delays: - save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.BEFORE) - event = env.step(cmd) - save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.MIDDLE) - save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.AFTER) - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - # update image list - new_img_idx = get_image_index(high_res_images_dir) - last_img_idx = len(traj_data['images']) - num_new_images = new_img_idx - last_img_idx - for j in range(num_new_images): - traj_data['images'].append({ - 'low_idx': ll_idx, - 'high_idx': ll_action['high_idx'], - 'image_name': '%09d.png' % int(last_img_idx + j) - }) - - if not event.metadata['lastActionSuccess']: - raise Exception("Replay Failed: %s" % (env.last_event.metadata['errorMessage'])) - - reward, _ = env.get_transition_reward() - rewards.append(reward) - - # save 10 frames in the end as per the training data - for _ in range(10): - save_image(env.last_event, root_dir) - - # store color to object type dictionary - color_to_obj_id_type = {} - all_objects = env.last_event.metadata['objects'] - for color, object_id in env.last_event.color_to_object_id.items(): - for obj in all_objects: - if object_id == obj['objectId']: - color_to_obj_id_type[str(color)] = { - 'objectID': obj['objectId'], - 'objectType': obj['objectType'] - } - - augmented_traj_data = copy.deepcopy(traj_data) - augmented_traj_data['scene']['color_to_object_type'] = color_to_obj_id_type - augmented_traj_data['task'] = {'rewards': rewards, 'reward_upper_bound': sum(rewards)} - - with open(augmented_json_file, 'w') as aj: - json.dump(augmented_traj_data, aj, sort_keys=True, indent=4) - - # save video - images_path = os.path.join(high_res_images_dir, '*.png') - video_save_path = os.path.join(high_res_images_dir, 'high_res_video.mp4') - video_saver.save(images_path, video_save_path) - - # check if number of new images is the same as the number of original images - if args.smooth_nav and args.time_delays: - orig_img_count = get_image_index(high_res_images_dir) - new_img_count = get_image_index(orig_images_dir) - print ("Original Image Count %d, New Image Count %d" % (orig_img_count, new_img_count)) - if orig_img_count != new_img_count: - raise Exception("WARNING: the augmented sequence length doesn't match the original") - - -def run(): - ''' - replay loop - ''' - # start THOR env - env = ThorEnv(player_screen_width=IMAGE_WIDTH, - player_screen_height=IMAGE_HEIGHT) - - skipped_files = [] - - while len(traj_list) > 0: - lock.acquire() - json_file = traj_list.pop() - lock.release() - - print ("Augmenting: " + json_file) - try: - augment_traj(env, json_file) - except Exception as e: - import traceback - traceback.print_exc() - print ("Error: " + repr(e)) - print ("Skipping " + json_file) - skipped_files.append(json_file) - - env.stop() - print("Finished.") - - # skipped files - if len(skipped_files) > 0: - print("Skipped Files:") - print(skipped_files) - - -traj_list = [] -lock = threading.Lock() - -# parse arguments -parser = argparse.ArgumentParser() -parser.add_argument('--data_path', type=str, default="data/2.1.0") -parser.add_argument('--smooth_nav', dest='smooth_nav', action='store_true') -parser.add_argument('--time_delays', dest='time_delays', action='store_true') -parser.add_argument('--shuffle', dest='shuffle', action='store_true') -parser.add_argument('--num_threads', type=int, default=1) -parser.add_argument('--reward_config', type=str, default='../models/config/rewards.json') -args = parser.parse_args() - -# make a list of all the traj_data json files -for dir_name, subdir_list, file_list in walklevel(args.data_path, level=2): - if "trial_" in dir_name: - json_file = os.path.join(dir_name, TRAJ_DATA_JSON_FILENAME) - if not os.path.isfile(json_file): - continue - traj_list.append(json_file) - -# random shuffle -if args.shuffle: - random.shuffle(traj_list) - -# start threads -threads = [] -for n in range(args.num_threads): - thread = threading.Thread(target=run) - threads.append(thread) - thread.start() - time.sleep(1) \ No newline at end of file diff --git a/models/main_models/rt1/gen/scripts/generate_trajectories.py b/models/main_models/rt1/gen/scripts/generate_trajectories.py deleted file mode 100644 index 5e67ce0e8..000000000 --- a/models/main_models/rt1/gen/scripts/generate_trajectories.py +++ /dev/null @@ -1,752 +0,0 @@ -import os -import sys -sys.path.append(os.path.join('/Users/jiasenl/Code/alfred')) -sys.path.append(os.path.join('/Users/jiasenl/Code/alfred', 'gen')) - -import time -import multiprocessing as mp -import json -import random -import shutil -import argparse -import numpy as np -import pandas as pd -from collections import OrderedDict -from datetime import datetime -import glob -import constants -from agents.deterministic_planner_agent import DeterministicPlannerAgent -from env.thor_env import ThorEnv -from game_states.task_game_state_full_knowledge import TaskGameStateFullKnowledge -from utils.video_util import VideoSaver -from utils.dataset_management_util import load_successes_from_disk, load_fails_from_disk - -# params -RAW_IMAGES_FOLDER = 'raw_images/' -DATA_JSON_FILENAME = 'traj_data.json' -DEPTH_IMAGES_FOLDER = 'depth_images/' - -# video saver -video_saver = VideoSaver() - -# structures to help with constraint enforcement. -goal_to_required_variables = {"pick_and_place_simple": {"pickup", "receptacle", "scene"}, - "pick_two_obj_and_place": {"pickup", "receptacle", "scene"}, - "look_at_obj_in_light": {"pickup", "receptacle", "scene"}, - "pick_clean_then_place_in_recep": {"pickup", "receptacle", "scene"}, - "pick_heat_then_place_in_recep": {"pickup", "receptacle", "scene"}, - "pick_cool_then_place_in_recep": {"pickup", "receptacle", "scene"}, - "pick_and_place_with_movable_recep": {"pickup", "movable", "receptacle", "scene"}} -goal_to_pickup_type = {'pick_heat_then_place_in_recep': 'Heatable', - 'pick_cool_then_place_in_recep': 'Coolable', - 'pick_clean_then_place_in_recep': 'Cleanable'} -goal_to_receptacle_type = {'look_at_obj_in_light': "Toggleable"} -goal_to_invalid_receptacle = {'pick_heat_then_place_in_recep': {'Microwave'}, - 'pick_cool_then_place_in_recep': {'Fridge'}, - 'pick_clean_then_place_in_recep': {'SinkBasin'}, - 'pick_two_obj_and_place': {'CoffeeMachine', 'ToiletPaperHanger', 'HandTowelHolder'}} - -scene_id_to_objs = {} -obj_to_scene_ids = {} -scenes_for_goal = {g: [] for g in constants.GOALS} -scene_to_type = {} - - -def sample_task_params(succ_traj, full_traj, fail_traj, - goal_candidates, pickup_candidates, movable_candidates, receptacle_candidates, scene_candidates, - inject_noise=10): - # Get the current conditional distributions of all variables (goal/pickup/receptacle/scene). - goal_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + succ_traj.loc[ - (succ_traj['pickup'].isin(pickup_candidates) if 'pickup' in goal_to_required_variables[c] else True) & - (succ_traj['movable'].isin(movable_candidates) if 'movable' in goal_to_required_variables[c] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) if 'receptacle' in goal_to_required_variables[c] else True) - & (succ_traj['scene'].isin(scene_candidates) if 'scene' in goal_to_required_variables[c] else True)] - ['goal'].tolist().count(c))) # Conditional. - * (1 / (1 + succ_traj['goal'].tolist().count(c))) # Prior. - for c in goal_candidates] - goal_probs = [w / sum(goal_weight) for w in goal_weight] - - pickup_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['movable'].isin(movable_candidates) - if 'movable' in goal_to_required_variables[g] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) - if 'receptacle' in goal_to_required_variables[g] else True) & - (succ_traj['scene'].isin(scene_candidates) - if 'scene' in goal_to_required_variables[g] else True)] - ['pickup'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['pickup'].tolist().count(c))) - for c in pickup_candidates] - pickup_probs = [w / sum(pickup_weight) for w in pickup_weight] - - movable_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['pickup'].isin(pickup_candidates) - if 'pickup' in goal_to_required_variables[g] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) - if 'receptacle' in goal_to_required_variables[g] else True) & - (succ_traj['scene'].isin(scene_candidates) - if 'scene' in goal_to_required_variables[g] else True)] - ['movable'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['movable'].tolist().count(c))) - for c in movable_candidates] - movable_probs = [w / sum(movable_weight) for w in movable_weight] - - receptacle_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['pickup'].isin(pickup_candidates) - if 'pickup' in goal_to_required_variables[g] else True) & - (succ_traj['movable'].isin(movable_candidates) - if 'movable' in goal_to_required_variables[g] else True) & - (succ_traj['scene'].isin(scene_candidates) - if 'scene' in goal_to_required_variables[g] else True)] - ['receptacle'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['receptacle'].tolist().count(c))) - for c in receptacle_candidates] - receptacle_probs = [w / sum(receptacle_weight) for w in receptacle_weight] - scene_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['pickup'].isin(pickup_candidates) - if 'pickup' in goal_to_required_variables[g] else True) & - (succ_traj['movable'].isin(movable_candidates) - if 'movable' in goal_to_required_variables[g] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) - if 'receptacle' in goal_to_required_variables[g] else True)] - ['scene'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['scene'].tolist().count(c))) - for c in scene_candidates] - scene_probs = [w / sum(scene_weight) for w in scene_weight] - - # Calculate the probability difference between each value and the maximum so we can iterate over them to find a - # next-best candidate to sample subject to the constraints of knowing which will fail. - diffs = [("goal", goal_candidates[idx], goal_probs[idx] - min(goal_probs)) - for idx in range(len(goal_candidates)) if len(goal_candidates) > 1] - diffs.extend([("pickup", pickup_candidates[idx], pickup_probs[idx] - min(pickup_probs)) - for idx in range(len(pickup_candidates)) if len(pickup_candidates) > 1]) - diffs.extend([("movable", movable_candidates[idx], movable_probs[idx] - min(movable_probs)) - for idx in range(len(movable_candidates)) if len(movable_candidates) > 1]) - diffs.extend([("receptacle", receptacle_candidates[idx], receptacle_probs[idx] - min(receptacle_probs)) - for idx in range(len(receptacle_candidates)) if len(receptacle_candidates) > 1]) - diffs.extend([("scene", scene_candidates[idx], scene_probs[idx] - min(scene_probs)) - for idx in range(len(scene_candidates)) if len(scene_candidates) > 1]) - - # Iteratively pop the next biggest difference until we find a combination that is valid (e.g., not already - # flagged as impossible by the simulator). - variable_value_by_diff = {} - diffs_as_keys = [] # list of diffs; index into list will be used as key values. - for _, _, diff in diffs: - already_keyed = False - for existing_diff in diffs_as_keys: - if np.isclose(existing_diff, diff): - already_keyed = True - break - if not already_keyed: - diffs_as_keys.append(diff) - for variable, value, diff in diffs: - key = None - for kidx in range(len(diffs_as_keys)): - if np.isclose(diffs_as_keys[kidx], diff): - key = kidx - if key not in variable_value_by_diff: - variable_value_by_diff[key] = [] - variable_value_by_diff[key].append((variable, value)) - - for key, diff in sorted(enumerate(diffs_as_keys), key=lambda x: x[1], reverse=True): - variable_value = variable_value_by_diff[key] - random.shuffle(variable_value) - for variable, value in variable_value: - - # Select a goal. - if variable == "goal": - gtype = value - # print("sampled goal '%s' with prob %.4f" % (gtype, goal_probs[goal_candidates.index(gtype)])) - _goal_candidates = [gtype] - - _pickup_candidates = pickup_candidates[:] - _movable_candidates = movable_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a pickup object. - elif variable == "pickup": - pickup_obj = value - # print("sampled pickup object '%s' with prob %.4f" % - # (pickup_obj, pickup_probs[pickup_candidates.index(pickup_obj)])) - _pickup_candidates = [pickup_obj] - - _goal_candidates = goal_candidates[:] - _movable_candidates = movable_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a movable object. - elif variable == "movable": - movable_obj = value - # print("sampled movable object '%s' with prob %.4f" % - # (movable_obj, movable_probs[movable_candidates.index(movable_obj)])) - _movable_candidates = [movable_obj] - _goal_candidates = [g for g in goal_candidates if g == 'pick_and_place_with_movable_recep'] - - _pickup_candidates = pickup_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a receptacle. - elif variable == "receptacle": - receptacle_obj = value - # print("sampled receptacle object '%s' with prob %.4f" % - # (receptacle_obj, receptacle_probs[receptacle_candidates.index(receptacle_obj)])) - _receptacle_candidates = [receptacle_obj] - - _goal_candidates = goal_candidates[:] - _pickup_candidates = pickup_candidates[:] - _movable_candidates = movable_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a scene. - else: - sampled_scene = value - # print("sampled scene %s with prob %.4f" % - # (sampled_scene, scene_probs[scene_candidates.index(sampled_scene)])) - _scene_candidates = [sampled_scene] - - _goal_candidates = goal_candidates[:] - _pickup_candidates = pickup_candidates[:] - _movable_candidates = movable_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - # Perform constraint propagation to determine whether this is a valid assignment. - propagation_finished = False - while not propagation_finished: - assignment_lens = (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), - len(_receptacle_candidates), len(_scene_candidates)) - # Constraints on goal. - _goal_candidates = [g for g in _goal_candidates if - (g not in goal_to_pickup_type or - len(set(_pickup_candidates).intersection( # Pickup constraint. - constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]])) > 0) - and (g not in goal_to_receptacle_type or - np.any([r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]] - for r in _receptacle_candidates])) # Valid by goal receptacle const. - and (g not in goal_to_invalid_receptacle or - len(set(_receptacle_candidates).difference( - goal_to_invalid_receptacle[g])) > 0) # Invalid by goal receptacle const. - and len(set(_scene_candidates).intersection( - scenes_for_goal[g])) > 0 # Scene constraint - ] - - # Define whether to consider constraints for each role based on current set of candidate goals. - pickup_constrained = np.any(["pickup" in goal_to_required_variables[g] for g in _goal_candidates]) - movable_constrained = np.any(["movable" in goal_to_required_variables[g] for g in _goal_candidates]) - receptacle_constrained = np.any(["receptacle" in goal_to_required_variables[g] - for g in _goal_candidates]) - scene_constrained = np.any(["scene" in goal_to_required_variables[g] for g in _goal_candidates]) - - # Constraints on pickup obj. - _pickup_candidates = [p for p in _pickup_candidates if - np.any([g not in goal_to_pickup_type or - p in constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]] - for g in _goal_candidates]) # Goal constraint. - and (not movable_constrained or - np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] - for m in _movable_candidates])) # Movable constraint. - and (not receptacle_constrained or - np.any([r in constants.VAL_ACTION_OBJECTS["Toggleable"] or - p in constants.VAL_RECEPTACLE_OBJECTS[r] - for r in _receptacle_candidates])) # Receptacle constraint. - and (not scene_constrained or - np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[p]] - for s in _scene_candidates])) # Scene constraint - ] - # Constraints on movable obj. - _movable_candidates = [m for m in _movable_candidates if - 'pick_and_place_with_movable_recep' in _goal_candidates # Goal constraint - and (not pickup_constrained or - np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] - for p in _pickup_candidates])) # Pickup constraint. - and (not receptacle_constrained or - np.any([r in constants.VAL_RECEPTACLE_OBJECTS and - m in constants.VAL_RECEPTACLE_OBJECTS[r] - for r in _receptacle_candidates])) # Receptacle constraint. - and (not scene_constrained or - np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[m]] - for s in _scene_candidates])) # Scene constraint - ] - # Constraints on receptacle obj. - _receptacle_candidates = [r for r in _receptacle_candidates if - np.any([(g not in goal_to_receptacle_type or - r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]]) and - (g not in goal_to_invalid_receptacle or - r not in goal_to_invalid_receptacle[g]) - for g in _goal_candidates]) # Goal constraint. - and (not receptacle_constrained or - r in constants.VAL_ACTION_OBJECTS["Toggleable"] or - np.any([p in constants.VAL_RECEPTACLE_OBJECTS[r] - for p in _pickup_candidates])) # Pickup constraint. - and (not movable_constrained or - r in constants.VAL_ACTION_OBJECTS["Toggleable"] or - np.any([m in constants.VAL_RECEPTACLE_OBJECTS[r] - for m in _movable_candidates])) # Movable constraint. - and (not scene_constrained or - np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[r]] - for s in _scene_candidates])) # Scene constraint - ] - # Constraints on scene. - _scene_candidates = [s for s in _scene_candidates if - np.any([s in scenes_for_goal[g] - for g in _goal_candidates]) # Goal constraint. - and (not pickup_constrained or - np.any([obj_to_scene_ids[constants.OBJ_PARENTS[p]] - for p in _pickup_candidates])) # Pickup constraint. - and (not movable_constrained or - np.any([obj_to_scene_ids[constants.OBJ_PARENTS[m]] - for m in _movable_candidates])) # Movable constraint. - and (not receptacle_constrained or - np.any([obj_to_scene_ids[constants.OBJ_PARENTS[r]] - for r in _receptacle_candidates])) # Receptacle constraint. - ] - if assignment_lens == (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), - len(_receptacle_candidates), len(_scene_candidates)): - propagation_finished = True - - candidate_lens = {"goal": len(_goal_candidates), "pickup": len(_pickup_candidates), - "movable": len(_movable_candidates), "receptacle": len(_receptacle_candidates), - "scene": len(_scene_candidates)} - if candidate_lens["goal"] == 0: - # print("Goal over-constrained; skipping") - continue - if np.all([0 in [candidate_lens[v] for v in goal_to_required_variables[g]] for g in _goal_candidates]): - continue - - # Ensure some combination of the remaining constraints is not in failures and is not already populated - # by the target number of repeats. - failure_ensured = True - full_ensured = True - for g in _goal_candidates: - pickup_iter = _pickup_candidates if "pickup" in goal_to_required_variables[g] else ["None"] - for p in pickup_iter: - movable_iter = _movable_candidates if "movable" in goal_to_required_variables[g] else ["None"] - for m in movable_iter: - receptacle_iter = _receptacle_candidates if "receptacle" in goal_to_required_variables[g] \ - else ["None"] - for r in receptacle_iter: - scene_iter = _scene_candidates if "scene" in goal_to_required_variables[g] else ["None"] - for s in scene_iter: - if (g, p, m, r, s) not in fail_traj: - failure_ensured = False - if (g, p, m, r, s) not in full_traj: - full_ensured = False - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if failure_ensured: - continue - if full_ensured: - continue - - if candidate_lens["goal"] > 1 or np.any([np.any([candidate_lens[v] > 1 - for v in goal_to_required_variables[g]]) - for g in _goal_candidates]): - task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, - _goal_candidates, _pickup_candidates, _movable_candidates, - _receptacle_candidates, _scene_candidates) - sampled_task = next(task_sampler) - if sampled_task is None: - continue - else: - g = _goal_candidates[0] - p = _pickup_candidates[0] if "pickup" in goal_to_required_variables[g] else "None" - m = _movable_candidates[0] if "movable" in goal_to_required_variables[g] else "None" - r = _receptacle_candidates[0] if "receptacle" in goal_to_required_variables[g] else "None" - s = _scene_candidates[0] if "scene" in goal_to_required_variables[g] else "None" - sampled_task = (g, p, m, r, int(s)) - - yield sampled_task - - yield None # Discovered that there are no valid assignments remaining. - - -def print_successes(succ_traj): - print("###################################\n") - print("Successes: ") - print(succ_traj) - print("\n##################################") - - -def main(args, thread_num=0): - - print(thread_num) - # settings - alfred_dataset_path = '../data/json_2.1.0/train' - - constants.DATA_SAVE_PATH = args.save_path - print("Force Unsave Data: %s" % str(args.force_unsave)) - - # Set up data structure to track dataset balance and use for selecting next parameters. - # In actively gathering data, we will try to maximize entropy for each (e.g., uniform spread of goals, - # uniform spread over patient objects, uniform recipient objects, and uniform scenes). - succ_traj = pd.DataFrame(columns=["goal", "pickup", "movable", "receptacle", "scene"]) - - # objects-to-scene and scene-to-objects database - for scene_type, ids in constants.SCENE_TYPE.items(): - for id in ids: - obj_json_file = os.path.join('layouts', 'FloorPlan%d-objects.json' % id) - with open(obj_json_file, 'r') as of: - scene_objs = json.load(of) - - id_str = str(id) - scene_id_to_objs[id_str] = scene_objs - for obj in scene_objs: - if obj not in obj_to_scene_ids: - obj_to_scene_ids[obj] = set() - obj_to_scene_ids[obj].add(id_str) - - # scene-goal database - for g in constants.GOALS: - for st in constants.GOALS_VALID[g]: - scenes_for_goal[g].extend([str(s) for s in constants.SCENE_TYPE[st]]) - scenes_for_goal[g] = set(scenes_for_goal[g]) - - # scene-type database - for st in constants.SCENE_TYPE: - for s in constants.SCENE_TYPE[st]: - scene_to_type[str(s)] = st - - # pre-populate counts in this structure using saved trajectories path. - succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, args.just_examine, args.repeats_per_cond) - if args.just_examine: - print_successes(succ_traj) - return - - print(succ_traj.groupby('goal').count()) - # pre-populate failed trajectories. - fail_traj = load_fails_from_disk(args.save_path) - print("Loaded %d known failed tuples" % len(fail_traj)) - - # create env and agent - env = ThorEnv(x_display='0.%d' %(thread_num % 2)) - - game_state = TaskGameStateFullKnowledge(env) - agent = DeterministicPlannerAgent(thread_id=0, game_state=game_state) - - errors = {} # map from error strings to counts, to be shown after every failure. - goal_candidates = constants.GOALS[:] - pickup_candidates = list(set().union(*[constants.VAL_RECEPTACLE_OBJECTS[obj] # Union objects that can be placed. - for obj in constants.VAL_RECEPTACLE_OBJECTS])) - pickup_candidates = [p for p in pickup_candidates if constants.OBJ_PARENTS[p] in obj_to_scene_ids] - movable_candidates = list(set(constants.MOVABLE_RECEPTACLES).intersection(obj_to_scene_ids.keys())) - receptacle_candidates = [obj for obj in constants.VAL_RECEPTACLE_OBJECTS - if obj not in constants.MOVABLE_RECEPTACLES and obj in obj_to_scene_ids] + \ - [obj for obj in constants.VAL_ACTION_OBJECTS["Toggleable"] - if obj in obj_to_scene_ids] - - # toaster isn't interesting in terms of producing linguistic diversity - receptacle_candidates.remove('Toaster') - receptacle_candidates.sort() - - scene_candidates = list(scene_id_to_objs.keys()) - - n_until_load_successes = args.async_load_every_n_samples - print_successes(succ_traj) - task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, - goal_candidates, pickup_candidates, movable_candidates, - receptacle_candidates, scene_candidates) - - # main generation loop - # keeps trying out new task tuples as trajectories either fail or suceed - while True: - # for _ in range(20): - for ii, json_path in enumerate(glob.iglob(os.path.join(alfred_dataset_path, "**", "traj_data.json"), recursive=True)): - # if ii % args.num_threads == thread_num: - # if ii == 5: - sampled_task = json_path.split('/')[-3].split('-') - # sampled_task = next(task_sampler) - # print("===============") - # print(ii, json_path) - print(sampled_task) # DEBUG - # print("===============") - - if sampled_task is None: - sys.exit("No valid tuples left to sample (all are known to fail or already have %d trajectories" % - args.repeats_per_cond) - gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene = sampled_task - - sampled_scene = int(sampled_scene) - print("sampled tuple: " + str((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene))) - - tries_remaining = args.trials_before_fail - # only try to get the number of trajectories left to make this tuple full. - target_remaining = args.repeats_per_cond - len(succ_traj.loc[(succ_traj['goal'] == gtype) & - (succ_traj['pickup'] == pickup_obj) & - (succ_traj['movable'] == movable_obj) & - (succ_traj['receptacle'] == receptacle_obj) & - (succ_traj['scene'] == str(sampled_scene))]) - num_place_fails = 0 # count of errors related to placement failure for no valid positions. - - # continue until we're (out of tries + have never succeeded) or (have gathered the target number of instances) - while num_place_fails > args.trials_before_fail or target_remaining > 0: - - # environment setup - constants.pddl_goal_type = gtype - print("PDDLGoalType: " + constants.pddl_goal_type) - task_id = create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene) - - # setup data dictionary - setup_data_dict() - constants.data_dict['task_id'] = task_id - constants.data_dict['task_type'] = constants.pddl_goal_type - constants.data_dict['dataset_params']['video_frame_rate'] = constants.VIDEO_FRAME_RATE - - # plan & execute - try: - # if True: - # Agent reset to new scene. - constraint_objs = {'repeat': [(constants.OBJ_PARENTS[pickup_obj], # Generate multiple parent objs. - np.random.randint(2 if gtype == "pick_two_obj_and_place" else 1, - constants.PICKUP_REPEAT_MAX + 1))], - 'sparse': [(receptacle_obj.replace('Basin', ''), - num_place_fails * constants.RECEPTACLE_SPARSE_POINTS)]} - if movable_obj != "None": - constraint_objs['repeat'].append((movable_obj, - np.random.randint(1, constants.PICKUP_REPEAT_MAX + 1))) - for obj_type in scene_id_to_objs[str(sampled_scene)]: - if (obj_type in pickup_candidates and - obj_type != constants.OBJ_PARENTS[pickup_obj] and obj_type != movable_obj): - constraint_objs['repeat'].append((obj_type, - np.random.randint(1, constants.MAX_NUM_OF_OBJ_INSTANCES + 1))) - if gtype in goal_to_invalid_receptacle: - constraint_objs['empty'] = [(r.replace('Basin', ''), num_place_fails * constants.RECEPTACLE_EMPTY_POINTS) - for r in goal_to_invalid_receptacle[gtype]] - constraint_objs['seton'] = [] - if gtype == 'look_at_obj_in_light': - constraint_objs['seton'].append((receptacle_obj, False)) - if num_place_fails > 0: - print("Failed %d placements in the past; increased free point constraints: " % num_place_fails - + str(constraint_objs)) - scene_info = {'scene_num': sampled_scene, 'random_seed': random.randint(0, 2 ** 32)} - info = agent.reset(scene=scene_info, - objs=constraint_objs) - - # Problem initialization with given constraints. - task_objs = {'pickup': pickup_obj} - if movable_obj != "None": - task_objs['mrecep'] = movable_obj - if gtype == "look_at_obj_in_light": - task_objs['toggle'] = receptacle_obj - else: - task_objs['receptacle'] = receptacle_obj - agent.setup_problem({'info': info}, scene=scene_info, objs=task_objs) - - # Now that objects are in their initial places, record them. - object_poses = [{'objectName': obj['name'].split('(Clone)')[0], - 'position': obj['position'], - 'rotation': obj['rotation']} - for obj in env.last_event.metadata['objects'] if obj['pickupable']] - dirty_and_empty = gtype == 'pick_clean_then_place_in_recep' - object_toggles = [{'objectType': o, 'stateChange': 'toggleable', 'isToggled': v} - for o, v in constraint_objs['seton']] - constants.data_dict['scene']['object_poses'] = object_poses - constants.data_dict['scene']['dirty_and_empty'] = dirty_and_empty - constants.data_dict['scene']['object_toggles'] = object_toggles - - # Pre-restore the scene to cause objects to "jitter" like they will when the episode is replayed - # based on stored object and toggle info. This should put objects closer to the final positions they'll - # be inlay at inference time (e.g., mugs fallen and broken, knives fallen over, etc.). - print("Performing reset via thor_env API") - env.reset(sampled_scene) - print("Performing restore via thor_env API") - env.restore_scene(object_poses, object_toggles, dirty_and_empty) - event = env.step(dict(constants.data_dict['scene']['init_action'])) - - terminal = False - while not terminal and agent.current_frame_count <= constants.MAX_EPISODE_LENGTH: - action_dict = agent.get_action(None) - agent.step(action_dict) - reward, terminal = agent.get_reward() - - dump_data_dict() - save_video() - # else: - except Exception as e: - import traceback - traceback.print_exc() - print("Error: " + repr(e)) - print("Invalid Task: skipping...") - if args.debug: - print(traceback.format_exc()) - - deleted = delete_save(args.in_parallel) - if not deleted: # another thread is filling this task successfully, so leave it alone. - target_remaining = 0 # stop trying to do this task. - else: - if str(e) == "API Action Failed: No valid positions to place object found": - # Try increasing the space available on sparse and empty flagged objects. - num_place_fails += 1 - tries_remaining -= 1 - else: # generic error - tries_remaining -= 1 - - estr = str(e) - if len(estr) > 120: - estr = estr[:120] - if estr not in errors: - errors[estr] = 0 - errors[estr] += 1 - print("%%%%%%%%%%") - es = sum([errors[er] for er in errors]) - print("\terrors (%d):" % es) - for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): - if v / es < 0.01: # stop showing below 1% of errors. - break - print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) - print("%%%%%%%%%%") - - continue - - if args.force_unsave: - delete_save(args.in_parallel) - - # add to save structure. - succ_traj = succ_traj.append({ - "goal": gtype, - "movable": movable_obj, - "pickup": pickup_obj, - "receptacle": receptacle_obj, - "scene": str(sampled_scene)}, ignore_index=True) - target_remaining -= 1 - tries_remaining += args.trials_before_fail # on success, add more tries for future successes - - # if this combination resulted in a certain number of failures with no successes, flag it as not possible. - if tries_remaining == 0 and target_remaining == args.repeats_per_cond: - new_fails = [(gtype, pickup_obj, movable_obj, receptacle_obj, str(sampled_scene))] - fail_traj = load_fails_from_disk(args.save_path, to_write=new_fails) - print("%%%%%%%%%%") - print("failures (%d)" % len(fail_traj)) - # print("\t" + "\n\t".join([str(ft) for ft in fail_traj])) - print("%%%%%%%%%%") - - # if this combination gave us the repeats we wanted, note it as filled. - if target_remaining == 0: - full_traj.add((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene)) - - # if we're sharing with other processes, reload successes from disk to update local copy with others' additions. - if args.in_parallel: - if n_until_load_successes > 0: - n_until_load_successes -= 1 - else: - print("Reloading trajectories from disk because of parallel processes...") - succ_traj = pd.DataFrame(columns=succ_traj.columns) # Drop all rows. - succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, False, args.repeats_per_cond) - print("... Loaded %d trajectories" % len(succ_traj.index)) - n_until_load_successes = args.async_load_every_n_samples - print_successes(succ_traj) - task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, - goal_candidates, pickup_candidates, movable_candidates, - receptacle_candidates, scene_candidates) - print("... Created fresh instance of sample_task_params generator") - - -def create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, scene_num): - task_id = 'trial_T' + datetime.now().strftime("%Y%m%d_%H%M%S_%f") - save_name = '%s-%s-%s-%s-%d' % (gtype, pickup_obj, movable_obj, receptacle_obj, scene_num) + '/' + task_id - - constants.save_path = os.path.join(constants.DATA_SAVE_PATH, save_name, RAW_IMAGES_FOLDER) - constants.save_depth_path = os.path.join(constants.DATA_SAVE_PATH, save_name, DEPTH_IMAGES_FOLDER) - - if not os.path.exists(constants.save_path): - os.makedirs(constants.save_path) - - if not os.path.exists(constants.save_depth_path): - os.makedirs(constants.save_depth_path) - - print("Saving images to: " + constants.save_path) - return task_id - - -def save_video(): - images_path = constants.save_path + '*.png' - video_path = os.path.join(constants.save_path.replace(RAW_IMAGES_FOLDER, ''), 'video.mp4') - video_saver.save(images_path, video_path) - - -def setup_data_dict(): - constants.data_dict = OrderedDict() - constants.data_dict['task_id'] = "" - constants.data_dict['task_type'] = "" - constants.data_dict['scene'] = {'floor_plan': "", 'random_seed': -1, 'scene_num': -1, 'init_action': [], - 'object_poses': [], 'dirty_and_empty': None, 'object_toggles': []} - constants.data_dict['plan'] = {'high_pddl': [], 'low_actions': []} - constants.data_dict['images'] = [] - constants.data_dict['template'] = {'task_desc': "", 'high_descs': []} - constants.data_dict['pddl_params'] = {'object_target': -1, 'object_sliced': -1, - 'parent_target': -1, 'toggle_target': -1, - 'mrecep_target': -1} - constants.data_dict['dataset_params'] = {'video_frame_rate': -1} - constants.data_dict['pddl_state'] = [] - - -def dump_data_dict(): - data_save_path = constants.save_path.replace(RAW_IMAGES_FOLDER, '') - with open(os.path.join(data_save_path, DATA_JSON_FILENAME), 'w') as fp: - json.dump(constants.data_dict, fp, sort_keys=True, indent=4) - - -def delete_save(in_parallel): - save_folder = constants.save_path.replace(RAW_IMAGES_FOLDER, '') - if os.path.exists(save_folder): - try: - shutil.rmtree(save_folder) - except OSError as e: - if in_parallel: # another thread succeeded at this task while this one failed. - return False - else: - raise e # if we're not running in parallel, this is an actual. - return True - - -def parallel_main(args): - procs = [mp.Process(target=main, args=(args,thread_num)) for thread_num in range(args.num_threads)] - try: - for proc in procs: - proc.start() - time.sleep(0.1) - finally: - for proc in procs: - proc.join() - - -if __name__ == "__main__": - parser = argparse.ArgumentParser() - - # settings - parser.add_argument('--force_unsave', action='store_true', help="don't save any data (for debugging purposes)") - parser.add_argument('--debug', action='store_true') - parser.add_argument('--save_path', type=str, default="dataset/new_trajectories_valid_seen", help="where to save the generated data") - parser.add_argument('--x_display', type=str, required=False, default=constants.X_DISPLAY, help="x_display id") - parser.add_argument("--just_examine", action='store_true', help="just examine what data is gathered; don't gather more") - parser.add_argument("--in_parallel", action='store_true', help="this collection will run in parallel with others, so load from disk on every new sample") - parser.add_argument("-n", "--num_threads", type=int, default=1, help="number of processes for parallel mode") - parser.add_argument('--json_file', type=str, default="", help="path to json file with trajectory dump") - - # params - parser.add_argument("--repeats_per_cond", type=int, default=3) - parser.add_argument("--trials_before_fail", type=int, default=5) - parser.add_argument("--async_load_every_n_samples", type=int, default=10) - parser.add_argument('--gpu_id', type=int, default=0) - - parse_args = parser.parse_args() - - # if parse_args.in_parallel and parse_args.num_threads > 1: - # parallel_main(parse_args) - # else: - main(parse_args) diff --git a/models/main_models/rt1/gen/scripts/replay_checks.py b/models/main_models/rt1/gen/scripts/replay_checks.py deleted file mode 100644 index b0d31e82d..000000000 --- a/models/main_models/rt1/gen/scripts/replay_checks.py +++ /dev/null @@ -1,217 +0,0 @@ -import os -import sys -# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) -# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) -sys.path.append(os.path.join('/home/jiasenl/code/alfred')) -sys.path.append(os.path.join('/home/jiasenl/code/alfred', 'gen')) - -import argparse -import json -import numpy as np -import shutil -import time -from env.thor_env import ThorEnv -from utils.replay_json import replay_json -import multiprocessing as mp -import time - - -JSON_FILENAME = "traj_data.json" - - -def parallel_replay_check(args): - procs = [mp.Process(target=replay_check, args=(args, thread_num)) for thread_num in range(args.num_threads)] - try: - for proc in procs: - proc.start() - time.sleep(0.1) - finally: - for proc in procs: - proc.join() - -def replay_check(args, thread_num=0): - env = ThorEnv(x_display='0.%d' %(thread_num % args.total_gpu)) - - # replay certificate filenames - replay_certificate_filenames = ["replay.certificate.%d" % idx for idx in range(args.num_replays)] - - # Clear existing failures in file recording. - if args.failure_filename is not None: - with open(args.failure_filename, 'w') as f: - f.write('') - - continue_check = True - total_checks, total_failures, crash_fails, unsat_fails, json_fails, nondet_fails = 0, 0, 0, 0, 0, 0 - errors = {} # map from error strings to counts, to be shown after every failure. - total_threads = args.total_gpu * args.num_threads - current_threads = args.gpu_id * args.num_threads + thread_num - - while continue_check: - - # Crawl the directory of trajectories and vet ones with no certificate. - failure_list = [] - valid_dirs = [] - count = 0 - for dir_name, subdir_list, file_list in os.walk(args.data_path): - if "trial_" in dir_name and (not "raw_images" in dir_name) and (not "pddl_states" in dir_name): - json_file = os.path.join(dir_name, JSON_FILENAME) - if not os.path.isfile(json_file): - continue - - # If we're just stripping certificates, do that and continue. - if args.remove_certificates: - for cidx in range(args.num_replays): - certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) - if os.path.isfile(certificate_file): - os.system("rm %s" % certificate_file) - continue - - if count % total_threads == current_threads: - valid_dirs.append(dir_name) - count += 1 - - print(len(valid_dirs)) - np.random.shuffle(valid_dirs) - for ii, dir_name in enumerate(valid_dirs): - - if not os.path.exists(dir_name): - continue - - json_file = os.path.join(dir_name, JSON_FILENAME) - if not os.path.isfile(json_file): - continue - - cidx = 0 - certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) - already_checked = False - while os.path.isfile(certificate_file): - cidx += 1 - if cidx == args.num_replays: - already_checked = True - break - certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) - if already_checked: - continue - - print(ii) - if not os.path.isfile(certificate_file): - total_checks += 1. / args.num_replays - failed = False - - with open(json_file) as f: - print("check %d/%d for file '%s'" % (cidx + 1, args.num_replays, json_file)) - try: - traj_data = json.load(f) - env.set_task(traj_data, args, reward_type='dense') - except json.decoder.JSONDecodeError: - failed = True - json_fails += 1 - - if not failed: - steps_taken = None - try: - steps_taken = replay_json(env, json_file) - except Exception as e: - import traceback - traceback.print_exc() - failed = True - crash_fails += 1 - - if str(e) not in errors: - errors[str(e)] = 0 - errors[str(e)] += 1 - print("%%%%%%%%%%") - es = sum([errors[er] for er in errors]) - print("\terrors (%d):" % es) - for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): - # if v / es < 0.01: # stop showing below 1% of errors. - # break - print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) - print("%%%%%%%%%%") - - if cidx > 1: - print("WARNING: replay that has succeeded before has failed at attempt %d" - % cidx) - nondet_fails += 1 - - if steps_taken is not None: # executed without crashing, so now we need to verify completion. - goal_satisfied = env.get_goal_satisfied() - - if goal_satisfied: - with open(certificate_file, 'w') as f: - f.write('%d' % steps_taken) - else: - failed = True - unsat_fails += 1 - print("Goal was not satisfied after execution!") - - if failed: - # Mark one failure and count the remainder of checks for this instance into the total. - total_failures += 1 - total_checks += args.num_replays - ((cidx + 1) / float(args.num_replays)) - - failure_list.append(json_file) - if args.failure_filename is not None: - with open(args.failure_filename, 'a') as f: - f.write("%s\n" % json_file) - # If we're deleting bad trajectories, do that here. - if args.move_failed_trajectories is not None: - print("Relocating failed trajectory '%s' to '%s'" % - (dir_name, os.path.join(args.move_failed_trajectories))) - try: - shutil.move(dir_name, args.move_failed_trajectories) - except shutil.Error as e: - print("WARNING: failed to perform move; error follows; deleting instead") - print(repr(e)) - shutil.rmtree(dir_name) - if args.remove_failed_trajectories: - print("Removing failed trajectory '%s'" % dir_name) - shutil.rmtree(dir_name) - - print("-------------------------") - print("Success Rate: %.2f/%.2f = %.3f" % - (total_checks - total_failures, total_checks, - float(total_checks - total_failures) / float(total_checks))) - if total_failures > 0: - print("Non-deterministic failure: %d/%d = %.3f" % (nondet_fails, total_failures, - float(nondet_fails) / total_failures)) - print("Failures by crash: %d/%d = %.3f" % (crash_fails, total_failures, - float(crash_fails) / total_failures)) - print("Failures by unsatisfied: %d/%d = %.3f" % (unsat_fails, total_failures, - float(unsat_fails) / total_failures)) - print("Failures by json decode error: %d/%d = %.3f" % (json_fails, total_failures, - float(json_fails) / total_failures)) - print("-------------------------") - - if not args.in_parallel: - continue_check = False - else: - time.sleep(60) - - -if __name__ == "__main__": - parser = argparse.ArgumentParser() - parser.add_argument('--data_path', type=str, default="dataset/2.1.0", - help="where to look for the generated data") - parser.add_argument("--failure_filename", type=str, required=False, - help="where to write failed trajectory dirs as strings, if anywhere") - parser.add_argument("--remove_failed_trajectories", dest='remove_failed_trajectories', action='store_true', - help="delete trajectory trials if they fail replay") - parser.add_argument("--move_failed_trajectories", type=str, required=False, - help="if given, relocate failed trajectories to this directory") - parser.add_argument("--remove_certificates", dest='remove_certificates', action='store_true', - help="instead of vetting trajectories, remove all vetting certificates") - parser.add_argument("--in_parallel", dest='in_parallel', action='store_true', - help="whether to run this script with parallel generation scripts in mind") - parser.add_argument('--reward_config', default='../models/config/rewards.json') - parser.add_argument('--num_replays', type=int, default=1) - parser.add_argument('--gpu_id', type=int, default=0) - parser.add_argument('--total_gpu', type=int, default=2) - parser.add_argument('--num_threads', type=int, default=2) - args = parser.parse_args() - - if args.num_threads > 1: - parallel_replay_check(args) - else: - replay_check(args) - diff --git a/models/main_models/rt1/gen/utils/__init__.py b/models/main_models/rt1/gen/utils/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/models/main_models/rt1/gen/utils/bb_util.py b/models/main_models/rt1/gen/utils/bb_util.py deleted file mode 100644 index 46b574b69..000000000 --- a/models/main_models/rt1/gen/utils/bb_util.py +++ /dev/null @@ -1,139 +0,0 @@ -import numbers -import numpy as np - -LIMIT = 99999999 - -def clip_bbox(bboxes, min_clip, max_x_clip, max_y_clip): - ''' - # BBoxes are [x1, y1, x2, y2] - ''' - bboxes_out = bboxes - added_axis = False - if len(bboxes_out.shape) == 1: - added_axis = True - bboxes_out = bboxes_out[:, np.newaxis] - bboxes_out[[0, 2], ...] = np.clip(bboxes_out[[0, 2], ...], min_clip, max_x_clip) - bboxes_out[[1, 3], ...] = np.clip(bboxes_out[[1, 3], ...], min_clip, max_y_clip) - if added_axis: - bboxes_out = bboxes_out[:, 0] - return bboxes_out - - -def xyxy_to_xywh(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): - ''' - [x1 y1, x2, y2] to [xMid, yMid, width, height] - ''' - added_axis = False - if isinstance(bboxes, list): - bboxes = np.array(bboxes).astype(np.float32) - if len(bboxes.shape) == 1: - added_axis = True - bboxes = bboxes[:, np.newaxis] - bboxes_out = np.zeros(bboxes.shape) - x1 = bboxes[0, ...] - y1 = bboxes[1, ...] - x2 = bboxes[2, ...] - y2 = bboxes[3, ...] - bboxes_out[0, ...] = (x1 + x2) / 2.0 - bboxes_out[1, ...] = (y1 + y2) / 2.0 - bboxes_out[2, ...] = x2 - x1 - bboxes_out[3, ...] = y2 - y1 - if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: - bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) - if bboxes_out.shape[0] > 4: - bboxes_out[4:, ...] = bboxes[4:, ...] - if added_axis: - bboxes_out = bboxes_out[:, 0] - if round: - bboxes_out = np.round(bboxes_out).astype(int) - return bboxes_out - - -def xywh_to_xyxy(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): - ''' - [xMid, yMid, width, height] to [x1 y1, x2, y2] - ''' - added_axis = False - if isinstance(bboxes, list): - bboxes = np.array(bboxes).astype(np.float32) - if len(bboxes.shape) == 1: - added_axis = True - bboxes = bboxes[:, np.newaxis] - bboxes_out = np.zeros(bboxes.shape) - x_mid = bboxes[0, ...] - y_mid = bboxes[1, ...] - width = bboxes[2, ...] - height = bboxes[3, ...] - bboxes_out[0, ...] = x_mid - width / 2.0 - bboxes_out[1, ...] = y_mid - height / 2.0 - bboxes_out[2, ...] = x_mid + width / 2.0 - bboxes_out[3, ...] = y_mid + height / 2.0 - if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: - bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) - if bboxes_out.shape[0] > 4: - bboxes_out[4:, ...] = bboxes[4:, ...] - if added_axis: - bboxes_out = bboxes_out[:, 0] - if round: - bboxes_out = np.round(bboxes_out).astype(int) - return bboxes_out - - -def scale_bbox(bboxes, scalars, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False, in_place=False): - ''' - @bboxes {np.array} 4xn array of boxes to be scaled - @scalars{number or arraylike} scalars for width and height of boxes - @in_place{bool} If false, creates new bboxes. - ''' - added_axis = False - if isinstance(bboxes, list): - bboxes = np.array(bboxes, dtype=np.float32) - if len(bboxes.shape) == 1: - added_axis = True - bboxes = bboxes[:, np.newaxis] - if isinstance(scalars, numbers.Number): - scalars = np.full((2, bboxes.shape[1]), scalars, dtype=np.float32) - if not isinstance(scalars, np.ndarray): - scalars = np.array(scalars, dtype=np.float32) - if len(scalars.shape) == 1: - scalars = np.tile(scalars[:, np.newaxis], (1, bboxes.shape[1])) - - width = bboxes[2, ...] - bboxes[0, ...] - height = bboxes[3, ...] - bboxes[1, ...] - x_mid = (bboxes[0, ...] + bboxes[2, ...]) / 2.0 - y_mid = (bboxes[1, ...] + bboxes[3, ...]) / 2.0 - if not in_place: - bboxes_out = bboxes.copy() - else: - bboxes_out = bboxes - - bboxes_out[0, ...] = x_mid - width * scalars[0, ...] / 2.0 - bboxes_out[1, ...] = y_mid - height * scalars[1, ...] / 2.0 - bboxes_out[2, ...] = x_mid + width * scalars[0, ...] / 2.0 - bboxes_out[3, ...] = y_mid + height * scalars[1, ...] / 2.0 - - if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: - bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) - if added_axis: - bboxes_out = bboxes_out[:, 0] - if round: - bboxes_out = np.round(bboxes_out).astype(int) - return bboxes_out - - -def make_square(bboxes, in_place=False): - if isinstance(bboxes, list): - bboxes = np.array(bboxes).astype(np.float32) - if len(bboxes.shape) == 1: - num_boxes = 1 - width = bboxes[2] - bboxes[0] - height = bboxes[3] - bboxes[1] - else: - num_boxes = bboxes.shape[1] - width = bboxes[2, ...] - bboxes[0, ...] - height = bboxes[3, ...] - bboxes[1, ...] - max_size = np.maximum(width, height) - scalars = np.zeros((2, num_boxes)) - scalars[0, ...] = max_size * 1.0 / width - scalars[1, ...] = max_size * 1.0 / height - return scale_bbox(bboxes, scalars, in_place=in_place) diff --git a/models/main_models/rt1/gen/utils/dataset_management_util.py b/models/main_models/rt1/gen/utils/dataset_management_util.py deleted file mode 100644 index de13fa535..000000000 --- a/models/main_models/rt1/gen/utils/dataset_management_util.py +++ /dev/null @@ -1,69 +0,0 @@ -import os -import shutil - - -def load_successes_from_disk(succ_dir, succ_traj, prune_trials, target_count, - cap_count=None, min_count=None): - tuple_counts = {} - for root, dirs, files in os.walk(succ_dir): - for d in dirs: - if d.count('-') == 4: - goal, pickup, movable, receptacle, scene_num = d.split('-') - # Add an entry for every successful trial folder in the directory. - queue_for_delete = [] - deleted_all = True - for _, _dirs, _ in os.walk(os.path.join(succ_dir, d)): - for _d in _dirs: - for _, _, _files in os.walk(os.path.join(succ_dir, d, _d)): - if 'video.mp4' in _files: - k = (goal, pickup, movable, receptacle, scene_num) - if k not in tuple_counts: - tuple_counts[k] = 0 - tuple_counts[k] += 1 - deleted_all = False - else: - queue_for_delete.append(_d) - break # only examine top level - break # only examine top level - if prune_trials: - if deleted_all: - print("Removing trial-less parent dir '%s'" % os.path.join(succ_dir, d)) - shutil.rmtree(os.path.join(succ_dir, d)) - else: - for _d in queue_for_delete: - print("Removing unfinished trial '%s'" % os.path.join(succ_dir, d, _d)) - shutil.rmtree(os.path.join(succ_dir, d, _d)) - break # only examine top level - - # Populate dataframe based on tuple constraints. - for k in tuple_counts: - if min_count is None or tuple_counts[k] >= min_count: - to_add = tuple_counts[k] if cap_count is None else cap_count - for _ in range(to_add): - succ_traj = succ_traj.append({ - "goal": k[0], - "pickup": k[1], - "movable": k[2], - "receptacle": k[3], - "scene": k[4]}, ignore_index=True) - tuples_at_target_count = set([t for t in tuple_counts if tuple_counts[t] >= target_count]) - - return succ_traj, tuples_at_target_count - - -def load_fails_from_disk(succ_dir, to_write=None): - fail_traj = set() - fail_dir = os.path.join(succ_dir, "fails") - if not os.path.isdir(fail_dir): - os.makedirs(fail_dir) - if to_write is not None: - for goal, pickup, movable, receptacle, scene_num in to_write: - with open(os.path.join(fail_dir, '-'.join([goal, pickup, movable, receptacle, scene_num])), 'w') as f: - f.write("0") - for root, dirs, files in os.walk(fail_dir): - for fn in files: - if fn.count('-') == 4: - goal, pickup, movable, receptacle, scene_num = fn.split('-') - fail_traj.add((goal, pickup, movable, receptacle, scene_num)) - break # only examine top level - return fail_traj diff --git a/models/main_models/rt1/gen/utils/game_util.py b/models/main_models/rt1/gen/utils/game_util.py deleted file mode 100644 index 476ef5122..000000000 --- a/models/main_models/rt1/gen/utils/game_util.py +++ /dev/null @@ -1,363 +0,0 @@ -import copy -import random -import cv2 -import numpy as np -import constants -import goal_library as glib - - -def get_pose(event): - pose = event.pose - return (int(np.round(pose[0] / (1000 * constants.AGENT_STEP_SIZE))), - int(np.round(pose[1] / (1000 * constants.AGENT_STEP_SIZE))), - int(np.round(pose[2] / (1000 * 90))), - int(np.round(pose[3] / (1000)))) - - -def get_object_data(metadata): - return [ - {"objectName": obj["name"].split("(Clone)")[0], "position": obj["position"], "rotation": obj["rotation"]} - for obj in metadata["objects"] - if obj["pickupable"] - ] - - -def imresize(image, size, rescale=True): - if image is None: - return None - if image.shape[0] != size[0] or image.shape[1] != size[1]: - image = cv2.resize(image, size) - if rescale: - if image.dtype != np.float32: - image = image.astype(np.float32) - image /= 255.0 - return image - - -def depth_imresize(image, size, rescale=True, max_depth=constants.MAX_DEPTH): - if image is None: - return None - if image.shape[0] != size[0] or image.shape[1] != size[1]: - image = cv2.resize(image, size) - image[image > max_depth] = max_depth - if rescale: - if image.dtype != np.float32: - image = image.astype(np.float32) - image /= max_depth - return image - - -def get_camera_matrix(pose, camera_height): - assert(pose[2] in {0, 1, 2, 3}) - sin_x = np.sin(pose[3] * np.pi / 180) - cos_x = np.cos(pose[3] * np.pi / 180) - x_rotation = np.matrix([ - [1, 0, 0], - [0, cos_x, -sin_x], - [0, sin_x, cos_x]]) - sin_y = np.sin(pose[2] * np.pi / 180) - cos_y = np.cos(pose[2] * np.pi / 180) - y_rotation = np.matrix([ - [cos_y, 0, sin_y], - [0, 1, 0], - [-sin_y, 0, cos_y]]) - rotation_matrix = np.matmul(x_rotation, y_rotation) - transformation_matrix = np.matrix([pose[0], camera_height, pose[1], 1]).T - extrinsic_matrix = np.concatenate((np.concatenate((rotation_matrix, np.matrix([0, 0, 0])), axis=0), - transformation_matrix), axis=1) - return extrinsic_matrix - - -def get_rotation_matrix(pose): - assert(pose[2] in {0, 1, 2, 3}), 'rotation was %s' % str(pose[2]) - sin_x = np.sin(-pose[3] * np.pi / 180) - cos_x = np.cos(-pose[3] * np.pi / 180) - x_rotation = np.matrix([ - [1, 0, 0], - [0, cos_x, -sin_x], - [0, sin_x, cos_x]], dtype=np.float32) - sin_y = np.sin((-pose[2] % 4) * 90 * np.pi / 180) - cos_y = np.cos((-pose[2] % 4) * 90 * np.pi / 180) - y_rotation = np.matrix([ - [cos_y, 0, sin_y], - [0, 1, 0], - [-sin_y, 0, cos_y]], dtype=np.float32) - rotation_matrix = np.matmul(x_rotation, y_rotation) - return rotation_matrix - - -def depth_to_world_coordinates(depth, pose, camera_height): - x_points = np.arange(-constants.SCREEN_WIDTH / 2, constants.SCREEN_WIDTH / 2, dtype=depth.dtype) - x_vals = (depth * x_points / constants.FOCAL_LENGTH) - - y_points = np.arange(constants.SCREEN_HEIGHT / 2, -constants.SCREEN_HEIGHT / 2, -1, dtype=depth.dtype) - y_vals = (depth.T * y_points / constants.FOCAL_LENGTH).T - - z_vals = depth - xyz = np.stack((x_vals, y_vals, z_vals), axis=2) / (1000 * constants.AGENT_STEP_SIZE) - rotation_matrix = np.linalg.inv(get_rotation_matrix(pose)) - xyz = np.array(np.dot(rotation_matrix, xyz.reshape(-1, 3).T).T).reshape( - constants.SCREEN_HEIGHT, constants.SCREEN_WIDTH, 3) - xzy = xyz[:, :, [0, 2, 1]] - xzy += np.array([pose[0], pose[1], camera_height]) - return xzy - - -# coordinates should be [n, (xzy)] -def world_to_camera_coordinates(coordinates, pose, camera_height): - coordinates = coordinates.copy() - coordinates -= np.array([pose[0], pose[1], camera_height]) - xyz = coordinates[:, [0, 2, 1]] # [n, (xyz)] - rotation_matrix = get_rotation_matrix(pose) - xyd = np.array(np.dot(rotation_matrix, xyz.T).T) - xyd *= (1000 * constants.AGENT_STEP_SIZE) - depth = np.maximum(xyd[:, -1], 0.01) - x_points = xyd[:, 0] * constants.FOCAL_LENGTH / depth + constants.SCREEN_WIDTH / 2 - y_points = constants.SCREEN_HEIGHT - (xyd[:, 1] * constants.FOCAL_LENGTH / depth + constants.SCREEN_HEIGHT / 2) - return np.stack((x_points, y_points, depth)).T - - -def get_templated_action_str(plan, idx=0): - action = copy.deepcopy(plan[idx]) - object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) - - a_type = action['action'] - templated_str = "" - - if 'GotoLocation' in a_type: - templated_str = "go to the %s" % (next_recep_name if next_recep_name != "" else prev_object_name) - elif 'OpenObject' in a_type: - templated_str = "open the %s" % (object_name) - elif 'CloseObject' in a_type: - templated_str = "close the %s" % (object_name) - elif 'PickupObject' in a_type: - templated_str = "pick up the %s" % (object_name) - elif 'PutObject' in a_type: - templated_str = "put the %s in the %s" % (object_name, recep_name) - elif 'CleanObject' in a_type: - templated_str = "wash the %s" % (prev_object_name) - elif 'HeatObject' in a_type: - templated_str = "heat the %s" % (prev_object_name) - elif 'CoolObject' in a_type: - templated_str = "cool the %s" % (prev_object_name) - elif 'ToggleObject' in a_type: - templated_str = "toggle %s" % (object_name) - elif 'SliceObject' in a_type: - templated_str = "slice the %s" % (object_name) - elif 'End' in a_type: - templated_str = "<>" - - return templated_str - - -def get_discrete_hl_action(plan, idx=0): - action = copy.deepcopy(plan[idx]) - object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) - - a_type = action['action'] - discrete_action = {'action': "", 'args': []} - - if 'GotoLocation' in a_type: - discrete_action['action'] = "GotoLocation" - discrete_action['args'] = [next_recep_name if next_recep_name != "" else next_object_name] - elif 'OpenObject' in a_type: - discrete_action['action'] = "OpenObject" - discrete_action['args'] = [object_name] - elif 'CloseObject' in a_type: - discrete_action['action'] = "CloseObject" - discrete_action['args'] = [object_name] - elif 'PickupObject' in a_type: - discrete_action['action'] = "PickupObject" - discrete_action['args'] = [object_name] - elif 'PutObject' in a_type: - discrete_action['action'] = "PutObject" - discrete_action['args'] = [object_name, recep_name] - elif 'CleanObject' in a_type: - discrete_action['action'] = "CleanObject" - discrete_action['args'] = [prev_object_name] - elif 'HeatObject' in a_type: - discrete_action['action'] = "HeatObject" - discrete_action['args'] = [prev_object_name] - elif 'CoolObject' in a_type: - discrete_action['action'] = "CoolObject" - discrete_action['args'] = [prev_object_name] - elif 'ToggleObject' in a_type: - discrete_action['action'] = "ToggleObject" - discrete_action['args'] = [object_name] - elif 'SliceObject' in a_type: - discrete_action['action'] = "SliceObject" - discrete_action['args'] = [object_name] - else: - discrete_action['action'] = "NoOp" - discrete_action['args'] = [] - - return discrete_action - - -def object_id_to_name(object_id): - return object_id.split('|')[0] - - -def get_relevant_objs(action, plan, idx=0): - object_name = object_id_to_name(action['objectId']).lower() if 'objectId' in action else "" - recep_name = object_id_to_name(action['receptacleObjectId']).lower() if 'receptacleObjectId' in action else "" - prev_object_name, prev_recep_name = "", "" - next_object_name, next_recep_name = "", "" - - prev_idx = idx - 2 - if prev_idx >= 0: - prev_action = copy.deepcopy(plan[prev_idx]) - prev_object_name = object_id_to_name(prev_action['objectId']).lower() if 'objectId' in prev_action else "" - prev_recep_name = object_id_to_name(prev_action['receptacleObjectId']).lower() if 'receptacleObjectId' in prev_action else "" - - next_idx = idx + 1 - if next_idx < len(plan): - next_action = copy.deepcopy(plan[next_idx]) - next_object_name = object_id_to_name(next_action['objectId']).lower() if 'objectId' in next_action else "" - next_recep_name = object_id_to_name(next_action['receptacleObjectId']).lower() if 'receptacleObjectId' in next_action else "" - - return object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name - - -def get_action_str(action): - action = copy.deepcopy(action) - a_type = action['action'] - action_str = 'Action: ' + a_type - del action['action'] - - if 'Teleport' in a_type: - action_str = a_type - if 'x' in action: - action_str += ' x: %.03f' % action['x'] - del action['x'] - if 'y' in action: - action_str += ' y: %.03f' % action['y'] - del action['y'] - if 'z' in action: - action_str += ' z: %.03f' % action['z'] - del action['z'] - if 'rotation' in action and action.get('rotateOnTeleport', False): - if type(action['rotation']) == dict: - action_str += ' r: %d' % int(action['rotation']['y']) - else: - action_str += ' r: %d' % int(action['rotation']) - del action['rotation'] - del action['rotateOnTeleport'] - if 'horizon' in action: - action_str += ' h: %d' % int(action['horizon']) - del action['horizon'] - elif 'Goto' in a_type: - action_str = a_type - if 'location' in action: - action_str += ' loc: %s' % action['location'] - del action['location'] - elif a_type in {'OpenObject', 'CloseObject', 'PickupObject', 'ToggleObject', 'SliceObject'}: - if 'objectId' not in action: - action['objectId'] = 'None' - action_str = '%s %s' % (a_type, action['objectId']) - elif a_type in {'RotateByDegree', 'LookByDegree'}: - if type(action['rotation']) == dict: - action_str += ' r: %d' % int(action['rotation']['y']) - else: - action_str += ' r: %d' % int(action['rotation']) - action_str = '%s %d' % (a_type, action['rotation']['y']) - del action['rotation'] - elif a_type == 'PutObject': - action_str = a_type - if 'objectId' in action: - action_str += ' o: %s' % action['objectId'] - del action['objectId'] - if 'receptacleObjectId' in action: - action_str += ' r: %s' % action['receptacleObjectId'] - del action['receptacleObjectId'] - - if len(action) > 0: - action_str += '\tFull: ' + str(action) - return action_str - - -def get_object(object_id, metadata): - for obj in metadata['objects']: - if obj['objectId'] == object_id: - return obj - return None - - -def get_object_dict(metadata): - return {obj['objectId']: obj for obj in metadata['objects']} - - -def get_objects_of_type(object_type, metadata): - return [obj for obj in metadata['objects'] if obj['objectType'] == object_type] - - -def get_obj_of_type_closest_to_obj(object_type, ref_object_id, metadata): - objs_of_type = [obj for obj in metadata['objects'] if obj['objectType'] == object_type and obj['visible']] - ref_obj = get_object(ref_object_id, metadata) - closest_objs_of_type = sorted(objs_of_type, key=lambda o: np.linalg.norm(np.array([o['position']['x'], o['position']['y'], o['position']['z']]) - \ - np.array([ref_obj['position']['x'], ref_obj['position']['y'], ref_obj['position']['z']]))) - if len(closest_objs_of_type) == 0: - raise Exception("No closest %s found!" % (ref_obj)) - return closest_objs_of_type[0] # retrun the first closest visible object - - -def get_objects_with_name_and_prop(name, prop, metadata): - return [obj for obj in metadata['objects'] - if name in obj['objectId'] and obj[prop]] - - -def get_visible_objs(objs): - return [obj for obj in objs if obj['visible']] - - -def get_object_bounds(obj, scene_bounds): - # obj_bounds = np.array(obj['bounds3D'])[[0, 2, 3, 5]] # Get X and Z out - # Get a 'box' that is a singular point in (x,z) based on object position in place of now-unavailable 'bounds3d' - obj_bounds = np.array([obj['position']['x'], obj['position']['z'], obj['position']['x'], obj['position']['z']]) - obj_bounds /= constants.AGENT_STEP_SIZE - obj_bounds = np.round(obj_bounds).astype(np.int32) - obj_bounds[[2, 3]] = np.maximum(obj_bounds[[2, 3]], obj_bounds[[0, 1]] + 1) - obj_bounds[[0, 2]] = np.clip(obj_bounds[[0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) - obj_bounds[[1, 3]] = np.clip(obj_bounds[[1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) - obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] - return obj_bounds - - -def get_object_bounds_batch(boxes, scene_bounds): - obj_bounds = boxes[:, [0, 2, 3, 5]] # Get X and Z out - obj_bounds /= constants.AGENT_STEP_SIZE - obj_bounds = np.round(obj_bounds).astype(np.int32) - obj_bounds[:, [2, 3]] = np.maximum(obj_bounds[:, [2, 3]], obj_bounds[:, [0, 1]] + 1) - obj_bounds[:, [0, 2]] = np.clip(obj_bounds[:, [0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) - obj_bounds[:, [1, 3]] = np.clip(obj_bounds[:, [1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) - obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] - return obj_bounds - - -def get_task_str(object_ind, receptacle_ind=None, toggle_ind=None, mrecep_ind=None): - goal_str = constants.pddl_goal_type - if constants.data_dict['pddl_params']['object_sliced']: - goal_str += "_slice" - template = random.choice(glib.gdict[goal_str]['templates']) - obj = constants.OBJECTS[object_ind].lower() if object_ind is not None else "" - recep = constants.OBJECTS[receptacle_ind].lower() if receptacle_ind is not None else "" - tog = constants.OBJECTS[toggle_ind].lower() if toggle_ind is not None else "" - mrecep = constants.OBJECTS[mrecep_ind].lower() if mrecep_ind is not None else "" - filled_in_str = template.format(obj=obj, recep=recep, toggle=tog, mrecep=mrecep) - return filled_in_str - - -def get_last_hl_action_index(): - return len(constants.data_dict['plan']['high_pddl']) - 1 - - -def get_last_ll_action_index(): - return len(constants.data_dict['plan']['low_actions']) - 1 - - -def store_image_name(name): - constants.data_dict['images'].append({"high_idx": get_last_hl_action_index(), - "low_idx": get_last_ll_action_index(), - "image_name": name}) - - diff --git a/models/main_models/rt1/gen/utils/image_util.py b/models/main_models/rt1/gen/utils/image_util.py deleted file mode 100644 index 157812a2f..000000000 --- a/models/main_models/rt1/gen/utils/image_util.py +++ /dev/null @@ -1,57 +0,0 @@ -import numpy as np -import gen.constants as constants - -def bbox_to_mask(bbox): - ''' - bbox to rectangle pixelwise mask - ''' - x1, y1, x2, y2 = bbox - mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) - mask[y1:y2, x1:x2] = 1 - return mask - - -def point_to_mask(point): - ''' - single point to dense pixelwise mask - ''' - x, y = point - mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) - mask[y, x] = 1 - return mask - - -def decompress_mask(compressed_mask): - ''' - decompress compressed mask array - ''' - mask = np.zeros((constants.DETECTION_SCREEN_WIDTH, constants.DETECTION_SCREEN_HEIGHT)) - for start_idx, run_len in compressed_mask: - for idx in range(start_idx, start_idx + run_len): - mask[idx // constants.DETECTION_SCREEN_WIDTH, idx % constants.DETECTION_SCREEN_HEIGHT] = 1 - return mask - - -def compress_mask(seg_mask): - ''' - compress mask array - ''' - run_len_compressed = [] # list of lists of run lengths for 1s, which are assumed to be less frequent. - idx = 0 - curr_run = False - run_len = 0 - for x_idx in range(len(seg_mask)): - for y_idx in range(len(seg_mask[x_idx])): - if seg_mask[x_idx][y_idx] == 1 and not curr_run: - curr_run = True - run_len_compressed.append([idx, None]) - if seg_mask[x_idx][y_idx] == 0 and curr_run: - curr_run = False - run_len_compressed[-1][1] = run_len - run_len = 0 - if curr_run: - run_len += 1 - idx += 1 - if curr_run: - run_len_compressed[-1][1] = run_len - return run_len_compressed \ No newline at end of file diff --git a/models/main_models/rt1/gen/utils/py_util.py b/models/main_models/rt1/gen/utils/py_util.py deleted file mode 100644 index 7a357f039..000000000 --- a/models/main_models/rt1/gen/utils/py_util.py +++ /dev/null @@ -1,84 +0,0 @@ -import random -import re -import time -import os -import string - - -def get_time_str(): - tt = time.localtime() - time_str = ('%04d_%02d_%02d_%02d_%02d_%02d' % - (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec)) - return time_str - - -def encode(string, encoding='utf-8'): - return string.encode(encoding) - - -def decode(string, encoding='utf-8'): - return string.decode(encoding) - - -def multireplace(string, replacements): - """ - Given a string and a replacement map, it returns the replaced string. - :param str string: string to execute replacements on - :param dict replacements: replacement dictionary {value to find: value to replace} - :rtype: str - Source https://gist.github.com/bgusach/a967e0587d6e01e889fd1d776c5f3729 - """ - # Place longer ones first to keep shorter substrings from matching where the longer ones should take place - # For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against the string 'hey abc', it should produce - # 'hey ABC' and not 'hey ABc' - substrs = sorted(replacements, key=len, reverse=True) - - # Create a big OR regex that matches any of the substrings to replace - regexp = re.compile('|'.join(map(re.escape, substrs))) - - # For each match, look up the new string in the replacements - return regexp.sub(lambda match: replacements[match.group(0)], string) - - -class SetWithGet(set): - def get_any(self): - return random.sample(self, 1)[0] - - def __getitem__(self, item): - return self.get_any() - - -class Noop(object): - def noop(*args, **kw): - pass - - def __getattr__(self, _): - return self.noop - - -def walklevel(some_dir, level=1): - some_dir = some_dir.rstrip(os.path.sep) - assert os.path.isdir(some_dir) - num_sep = some_dir.count(os.path.sep) - for root, dirs, files in os.walk(some_dir): - yield root, dirs, files - num_sep_this = root.count(os.path.sep) - if num_sep + level <= num_sep_this: - del dirs[:] - - -def remove_spaces(s): - cs = ' '.join(s.split()) - return cs - - -def remove_spaces_and_lower(s): - cs = remove_spaces(s) - cs = cs.lower() - return cs - - -def remove_punctuation(s): - cs = s.translate(str.maketrans('', '', string.punctuation)) - cs = remove_spaces_and_lower(cs) - return cs \ No newline at end of file diff --git a/models/main_models/rt1/gen/utils/replay_json.py b/models/main_models/rt1/gen/utils/replay_json.py deleted file mode 100644 index 96949414c..000000000 --- a/models/main_models/rt1/gen/utils/replay_json.py +++ /dev/null @@ -1,52 +0,0 @@ -import json - -def replay_json(env, json_file): - # load json data - with open(json_file) as f: - traj_data = json.load(f) - - # setup - scene_num = traj_data['scene']['scene_num'] - object_poses = traj_data['scene']['object_poses'] - dirty_and_empty = traj_data['scene']['dirty_and_empty'] - object_toggles = traj_data['scene']['object_toggles'] - - scene_name = 'FloorPlan%d' % scene_num - env.reset(scene_name) - env.restore_scene(object_poses, object_toggles, dirty_and_empty) - - # initialize - event = env.step(dict(traj_data['scene']['init_action'])) - # print("Task: %s" % (traj_data['template']['task_desc'])) - - steps_taken = 0 - for ll_action in traj_data['plan']['low_actions']: - hl_action_idx, traj_api_cmd, traj_discrete_action = \ - ll_action['high_idx'], ll_action['api_action'], ll_action['discrete_action'] - - # print templated low-level instructions & discrete action - # print("HL Templ: %s, LL Cmd: %s" % (traj_data['template']['high_descs'][hl_action_idx], - # traj_discrete_action['action'])) - - # Use the va_interact that modelers will have to use at inference time. - action_name, action_args = traj_discrete_action['action'], traj_discrete_action['args'] - - # three ways to specify object of interest mask - # 1. create a rectangular mask from bbox - # mask = env.bbox_to_mask(action_args['bbox']) if 'bbox' in action_args else None # some commands don't require any arguments - # 2. create a point mask from bbox - # mask = env.point_to_mask(action_args['point']) if 'point' in action_args else None - # 3. use full pixel-wise segmentation mask - compressed_mask = action_args['mask'] if 'mask' in action_args else None - if compressed_mask is not None: - mask = env.decompress_mask(compressed_mask) - else: - mask = None - - success, event, target_instance_id, err, _ = env.va_interact(action_name, interact_mask=mask) - if not success: - raise RuntimeError(err) - - steps_taken += 1 - - return steps_taken diff --git a/models/main_models/rt1/gen/utils/video_util.py b/models/main_models/rt1/gen/utils/video_util.py deleted file mode 100644 index 4c21b8a3a..000000000 --- a/models/main_models/rt1/gen/utils/video_util.py +++ /dev/null @@ -1,11 +0,0 @@ -import subprocess -import constants - -class VideoSaver(object): - - def __init__(self, frame_rate=constants.VIDEO_FRAME_RATE): - self.frame_rate = frame_rate - - def save(self, image_path, save_path): - subprocess.call(["ffmpeg -r %d -pattern_type glob -y -i '%s' -c:v libx264 -pix_fmt yuv420p '%s'" % - (self.frame_rate, image_path, save_path)], shell=True) \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/attribute_limits.json b/models/main_models/rt1/lanmp_dataloader/attribute_limits.json deleted file mode 100644 index 0fdbbed9a..000000000 --- a/models/main_models/rt1/lanmp_dataloader/attribute_limits.json +++ /dev/null @@ -1 +0,0 @@ -[{"min_x": -0.40000009536743164, "max_x": 0.40000009536743164, "min_y": 0, "max_y": 0, "min_z": -0.40000009536743164, "max_z": 0.40000009536743164}, {"min_yaw": -347.422251701355, "max_yaw": 358.85895166755654}, {"min_x": -1.146158218383789, "max_x": 0.6427476406097412, "min_y": -0.533308207988739, "max_y": 0.8237500190734863, "min_z": -0.5759885311126709, "max_z": 1.0145864486694336}] \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py b/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py deleted file mode 100644 index 7d574597a..000000000 --- a/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py +++ /dev/null @@ -1,800 +0,0 @@ -import os -import sys - -import torch -from torchvision.io import read_image -from torch.utils.data import Dataset -from torch.utils.data import DataLoader -import h5py -from PIL import Image -from tqdm import tqdm -# from models.utils.data_utils import split_data -import pdb -#mainly for debugging -import matplotlib.pyplot as plt -import numpy as np -import re -import json -import sys -from copy import copy -import random - -sys.path.append('..') - -DATASET_PATH = '/oscar/data/stellex/shared/lanmp/sim_dataset.hdf5' - -''' -train_keys, val_keys, test_keys = split_data(self.args.data, splits['train'], splits['val'], splits['test']) -''' - -def split_data(hdf5_path, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1): - with h5py.File(hdf5_path, 'r') as hdf_file: - # Assuming trajectories or data units are top-level groups in the HDF5 file - keys = list(hdf_file.keys()) - total_items = len(keys) - - # Generate a shuffled array of indices - indices = np.arange(total_items) - np.random.shuffle(indices) - - # Calculate split sizes - train_end = int(train_ratio * total_items) - val_end = train_end + int(val_ratio * total_items) - - # Split the indices - train_indices = indices[:train_end] - val_indices = indices[train_end:val_end] - test_indices = indices[val_end:] - - # Convert indices back to keys (assuming order in keys list is stable and matches original order) - train_keys = [keys[i] for i in train_indices] - val_keys = [keys[i] for i in val_indices] - test_keys = [keys[i] for i in test_indices] - - return train_keys, val_keys, test_keys - -def split_by_scene(hdf5_path): - - #mapping which keys are relevant to specific scenes - scene_to_keys = {} - - with h5py.File(hdf5_path, 'r') as hdf_file: - - keys = list(hdf_file.keys()) - - for k in keys: - traj_json_dict = json.loads(hdf_file[k]['folder_0'].attrs['metadata']) - - if traj_json_dict['scene'] not in scene_to_keys: - scene_to_keys[traj_json_dict['scene']] = [] - - scene_to_keys[traj_json_dict['scene']].append(k) - - for k in scene_to_keys.keys(): - scene_to_keys[k] = list(sorted(scene_to_keys[k])) - - with open('./lanmp_dataloader/scene_to_keys.json', 'w') as f: - json.dump(scene_to_keys, f) - - return scene_to_keys - - - -def sort_folders(test_string): - return list(map(int, re.findall(r'\d+', test_string)))[0] - -class DatasetManager(object): - - ''' - NOTE: kwargs should contain a dictionary with keys {'train_split' : x, 'val_split': y, 'test_split':z} where x+y+z = 1 - ''' - def __init__(self, val_scene=1, train_split=0.8, val_split=0.1, test_split=0.1, split_style='task_split', diversity_scenes=1, max_trajectories=100): - - assert( train_split + val_split + test_split == 1.0, 'Error: train, val and test split do not sum to 1.0') - - - #train_keys, val_keys, test_keys = split_data(DATASET_PATH, train_split, val_split, test_split) - if 'scene_to_keys.json' not in os.listdir('./lanmp_dataloader'): - self.scene_to_keys = split_by_scene(DATASET_PATH) - else: - with open('./lanmp_dataloader/scene_to_keys.json') as f: - self.scene_to_keys = json.load(f) - - - self.scenes = list(sorted(list(self.scene_to_keys.keys()))) - - assert( split_style in ['k_fold_scene', 'task_split', 'diversity_ablation'], "Error: input split_style is invalid") - - if split_style == 'k_fold_scene': - assert( val_scene < len(self.scenes), "Error: input scene is out of index space") - train_keys = [] - for x in range(0, len(self.scenes)): - if x!=val_scene: - train_keys += self.scene_to_keys[self.scenes[x]] - - val_keys = self.scene_to_keys[self.scenes[val_scene]] - test_keys = None - - elif split_style == 'task_split': - - train_keys = [] - val_keys = [] - - for scene in self.scenes: - - scene_keys = copy(self.scene_to_keys[scene]) - random.shuffle(scene_keys) - - - split_idx = int(len(scene_keys)*(train_split + 0.5*val_split)) - - train_keys += scene_keys[:split_idx] - val_keys += scene_keys[split_idx:] - - print('Train Perc: ', len(train_keys) / (len(train_keys) + len(val_keys))) - - val_keys = ['data_13:02:17', 'data_19:58:40', 'data_15:50:55', 'data_16:22:44', 'data_15:40:22', 'data_17:08:14', 'data_15:37:13', 'data_18:38:30', 'data_13:56:07', 'data_15:22:59', 'data_13:33:54', 'data_13:18:11', 'data_19:36:17', 'data_14:38:16', 'data_13:04:13', 'data_12:04:43', 'data_16:37:57', 'data_15:38:38', 'data_16:40:44', 'data_17:59:00', 'data_20:57:07', 'data_16:03:52', 'data_16:40:36', 'data_19:31:51', 'data_16:45:24', 'data_21:09:57', 'data_17:26:17', 'data_15:01:27', 'data_14:02:16', 'data_13:29:09', 'data_14:22:29', 'data_16:43:00', 'data_13:46:04', 'data_15:13:04', 'data_16:45:58', 'data_13:33:29', 'data_17:17:50', 'data_11:19:28', 'data_17:45:27', 'data_16:00:55', 'data_15:03:19', 'data_16:06:05', 'data_16:02:46', 'data_17:41:00', 'data_17:35:45', 'data_14:05:06', 'data_18:22:47', 'data_17:02:46', 'data_15:08:23', 'data_16:15:15', 'data_19:00:23', 'data_11:50:57', 'data_15:19:33', 'data_14:52:27', 'data_16:58:53', 'data_11:44:50', 'data_16:10:21', 'data_13:10:05', 'data_17:48:24', 'data_18:09:10', 'data_18:01:35', 'data_13:34:59', 'data_12:48:23', 'data_22:17:48', 'data_16:57:05', 'data_16:49:20', 'data_17:51:34', 'data_12:54:21', 'data_16:23:48', 'data_14:24:32', 'data_16:18:35', 'data_14:26:22', 'data_16:11:06', 'data_11:58:17', 'data_17:13:00', 'data_19:34:02', 'data_13:29:42', 'data_17:20:01', 'data_15:20:09', 'data_16:53:34', 'data_15:25:56'] - - print('Train Keys: ', len(train_keys)) - print('Validation Keys: ', len(val_keys)) - print('Validation Keys: ', val_keys) - - elif split_style == 'diversity_ablation': - - assert(diversity_scenes < len(self.scene_to_keys.keys()), "Error: number of train scenes for diversity ablations cannot be {}".format(len(self.scene_to_keys.keys()))) - - ordered_scenes = []; ordered_trajs = [] - - for scene, traj in self.scene_to_keys.items(): - - ordered_scenes.append(scene) - ordered_trajs.append(len(traj)) - - - ordered_index = sorted(range(0, len(ordered_trajs)), key = lambda x: ordered_trajs[x]) - - ordered_trajs = list(sorted(ordered_trajs)) - ordered_scenes = [ordered_scenes[i] for i in ordered_index] - - print('EVAL SCENE: {} has {} trajectories'.format(ordered_scenes[-1], ordered_trajs[-1])) - val_keys = self.scene_to_keys[ordered_scenes[-1]] - other_scenes = list(reversed(ordered_scenes[:-1])) - other_trajs = list(reversed(ordered_trajs[:-1])) - - - num_per_scene = int(max_trajectories/diversity_scenes) - train_keys = [] - - for i in range(diversity_scenes): - train_keys += random.sample(self.scene_to_keys[other_scenes[i]], num_per_scene) - - if len(train_keys) < max_trajectories: - - random_scene = random.sample(other_scenes[:diversity_scenes], 1)[0] - train_keys += random.sample(self.scene_to_keys[random_scene], max_trajectories-len(train_keys)) - - - if 'attribute_limits.json' not in os.listdir('./lanmp_dataloader'): - body_pose_lim, body_orientation_lim, end_effector_pose_lim = self.determine_min_max_range([train_keys, val_keys, test_keys]) - else: - - with open('./lanmp_dataloader/attribute_limits.json') as f: - attribute_limits = json.load(f) - body_pose_lim, body_orientation_lim, end_effector_pose_lim = attribute_limits[0], attribute_limits[1], attribute_limits[2] - - self.train_dataset = RT1Dataset(train_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) - self.val_dataset = RT1Dataset(val_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) - # self.test_dataset = RT1Dataset(test_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) - - def determine_min_max_range(self, data_subset_keys): - - body_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z':float('-inf')} - body_orientation = {'min_yaw': float('inf'), 'max_yaw': float('-inf')} - end_effector_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z': float('-inf')} - - - - - with h5py.File(DATASET_PATH, 'r') as hdf: - for dataset_keys in data_subset_keys: - - if dataset_keys is None: - continue - - - for i in range(len(dataset_keys)): - prev_body_x = None - prev_body_y = None - prev_body_z = None - prev_body_yaw = None - prev_ee_x = None - prev_ee_y = None - prev_ee_z = None - - print('Index: {} of {}'.format(i, len(dataset_keys))) - traj_group = hdf[dataset_keys[i]] - traj_steps = list(traj_group.keys()) - traj_steps.sort(key=sort_folders) - - for j in range(len(traj_steps)): - - step_metadata = json.loads(traj_group[traj_steps[j]].attrs['metadata']) - - body_x = step_metadata['steps'][0]['state_body'][0] - body_y = step_metadata['steps'][0]['state_body'][1] - body_z = step_metadata['steps'][0]['state_body'][2] - - body_yaw = step_metadata['steps'][0]['state_body'][3] - - - ee_x = step_metadata['steps'][0]['state_ee'][0] - ee_y = step_metadata['steps'][0]['state_ee'][1] - ee_z = step_metadata['steps'][0]['state_ee'][2] - - - - body_pose['min_x'] = min(body_pose['min_x'], body_x - prev_body_x if prev_body_x is not None else 0) - body_pose['max_x'] = max(body_pose['max_x'], body_x - prev_body_x if prev_body_x is not None else 0) - - body_pose['min_y'] = min(body_pose['min_y'], body_y - prev_body_y if prev_body_y is not None else 0) - body_pose['max_y'] = max(body_pose['max_y'], body_y - prev_body_y if prev_body_y is not None else 0) - - body_pose['min_z'] = min(body_pose['min_z'], body_z - prev_body_z if prev_body_z is not None else 0) - body_pose['max_z'] = max(body_pose['max_z'], body_z - prev_body_z if prev_body_z is not None else 0) - - body_orientation['min_yaw'] = min(body_orientation['min_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) - body_orientation['max_yaw'] = max(body_orientation['max_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) - - end_effector_pose['min_x'] = min(end_effector_pose['min_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) - end_effector_pose['max_x'] = max(end_effector_pose['max_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) - - end_effector_pose['min_y'] = min(end_effector_pose['min_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) - end_effector_pose['max_y'] = max(end_effector_pose['max_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) - - end_effector_pose['min_z'] = min(end_effector_pose['min_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) - end_effector_pose['max_z'] = max(end_effector_pose['max_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) - - - prev_body_x = body_x - prev_body_y = body_y - prev_body_z = body_z - prev_body_yaw = body_yaw - prev_ee_x = ee_x - prev_ee_y = ee_y - prev_ee_z = ee_z - - - - #cache the saved max and min values if already computed to save time - attribute_limits = [body_pose, body_orientation, end_effector_pose] - with open('./lanmp_dataloader/attribute_limits.json', 'w') as f: - json.dump(attribute_limits, f) - - - return body_pose, body_orientation, end_effector_pose - - def collate_batches(self, batch, shuffle_batch = False): - - - collated_batch = [] - - # merging batch elements with variable length - for out in range(len(batch[0])): - collated_output = [] - for idx in range(len(batch)): - if batch[idx][out].dtype.type == np.str_: - collated_output.append(batch[idx][out]) - else: - collated_output.append(torch.from_numpy(batch[idx][out])) - - if batch[idx][out].dtype.type!=np.str_: - collated_output = torch.cat(collated_output, dim=0) - else: - - collated_output = np.concatenate(collated_output, axis=0) - - collated_batch.append(collated_output) - - #shuffling all the batched samples across the trajectories to get random order - if shuffle_batch: - permutation = torch.randperm(collated_batch[0].size(0)) - - for i in range(len(collated_batch)): - collated_batch[i] = collated_batch[i][permutation] - - return collated_batch - - - - - - - - - -class RT1Dataset(Dataset): - - - - def __init__(self, data_split_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim, tokenize_action=True): - - #stores the keys in the dataset for the appropriate split (train, validation or test) - self.dataset_keys = data_split_keys - self.body_pose_lim = body_pose_lim - self.body_orientation_lim = body_orientation_lim - self.end_effector_pose_lim = end_effector_pose_lim - self.num_bins = 254 - - self.tokenize_action = tokenize_action - - self.hdf = h5py.File(DATASET_PATH, 'r') - - def __len__(self): - return len(self.dataset_keys) - - - def make_data_discrete(self, dictionary): - - - - #body x, y, z coordinate - dictionary['body_position_deltas'][:,0] = 1 + (dictionary['body_position_deltas'][:,0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins - dictionary['body_position_deltas'][:,0] = dictionary['body_position_deltas'][:,0].astype(int) - - if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0: - dictionary['body_position_deltas'][:,1] = 1 + (dictionary['body_position_deltas'][:,1] - self.body_pose_lim['min_y'])/(self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins - else: - dictionary['body_position_deltas'][:,1].fill(0) - dictionary['body_position_deltas'][:,1] = dictionary['body_position_deltas'][:,1].astype(int) - - dictionary['body_position_deltas'][:,2] = 1 + (dictionary['body_position_deltas'][:,2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins - dictionary['body_position_deltas'][:,2] = dictionary['body_position_deltas'][:,2].astype(int) - - #body yaw and pitch - dictionary['body_yaw_deltas'] = 1 + (dictionary['body_yaw_deltas'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins - dictionary['body_yaw_deltas'] = dictionary['body_yaw_deltas'].astype(int) - - #end effector x, y, z coordinate - dictionary['arm_position_deltas'][:,0] = 1 + (dictionary['arm_position_deltas'][:,0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins - dictionary['arm_position_deltas'][:,0] = dictionary['arm_position_deltas'][:,0].astype(int) - - dictionary['arm_position_deltas'][:,1] = 1 + (dictionary['arm_position_deltas'][:,1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins - dictionary['arm_position_deltas'][:,1] = dictionary['arm_position_deltas'][:,1].astype(int) - - dictionary['arm_position_deltas'][:,2] = 1 + (dictionary['arm_position_deltas'][:,2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins - dictionary['arm_position_deltas'][:,2] = dictionary['arm_position_deltas'][:,2].astype(int) - - #find if and where episode terminates so you can fill those entries with 0s - if 1.0 in dictionary['terminate_episode']: - terminate_idx = np.where(np.array(dictionary['terminate_episode'])>0)[0][0] - - dictionary['body_position_deltas'][terminate_idx:,:].fill(0) - dictionary['body_yaw_deltas'][terminate_idx:].fill(0) - dictionary['arm_position_deltas'][terminate_idx:,:].fill(0) - - - return dictionary - - - def detokenize_continuous_data(self, dictionary): - - if dictionary['curr_mode'] == 'stop': - dictionary['body_position_delta'] = [[0.0, 0.0, 0.0]] - dictionary['body_yaw_delta'] = [[0.0]] - dictionary['arm_position_deltas'] = [[0.0, 0.0, 0.0]] - - else: - dictionary['body_position_delta'][0][0] = (dictionary['body_position_delta'][0][0] - 1) * (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x']) / self.num_bins + self.body_pose_lim['min_x'] - dictionary['body_position_delta'][0][1] = (dictionary['body_position_delta'][0][1] - 1) * (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y']) / self.num_bins + self.body_pose_lim['min_y'] - dictionary['body_position_delta'][0][2] = (dictionary['body_position_delta'][0][2] - 1) * (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z']) / self.num_bins + self.body_pose_lim['min_z'] - - dictionary['body_yaw_delta'][0][0] = (dictionary['body_yaw_delta'][0][0] - 1) * (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) / self.num_bins + self.body_orientation_lim['min_yaw'] - - - dictionary['arm_position_delta'][0][0] = (dictionary['arm_position_delta'][0][0] - 1) * (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x']) / self.num_bins + self.end_effector_pose_lim['min_x'] - dictionary['arm_position_delta'][0][1] = (dictionary['arm_position_delta'][0][1] - 1) * (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y']) / self.num_bins + self.end_effector_pose_lim['min_y'] - dictionary['arm_position_delta'][0][2] = (dictionary['arm_position_delta'][0][2] - 1) * (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z']) / self.num_bins + self.end_effector_pose_lim['min_z'] - return dictionary - - - def make_data_discrete_old(self, dictionary): - - if not bool(dictionary['is_terminal']): - - #body x, y, z coordinate - dictionary['body_position'][0] = 1 + int( (dictionary['body_position'][0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins) - - dictionary['body_position'][1] = 1 + int( (dictionary['body_position'][1] - self.body_pose_lim['min_y'])/ (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins) if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0 else 0 - - dictionary['body_position'][2] = 1 + int( (dictionary['body_position'][2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins) - - #body yaw and pitch - dictionary['body_yaw'] = 1 + int( (dictionary['body_yaw'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins) - - #end effector x, y, z coordinate - dictionary['arm_position'][0] = 1 + int( (dictionary['arm_position'][0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins) - dictionary['arm_position'][1] = 1 + int( (dictionary['arm_position'][1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins) - dictionary['arm_position'][2] = 1 + int( (dictionary['arm_position'][2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins) - - #if terminal action is chosen, then produce 'no action' discrete value for each of the state variables - else: - dictionary['body_position'][0] = 0 - dictionary['body_position'][1] = 0 - dictionary['body_position'][2] = 0 - - dictionary['body_yaw'] = 0 - - dictionary['arm_position'][0] = 0 - dictionary['arm_position'][1] = 0 - dictionary['arm_position'][2] = 0 - - def get_head_pitch(self, action): - - value = 0 - - if action == 'LookDown': - value = 1 - elif action == 'LookUp': - value = 2 - - return value - - def detokenize_head_pitch(self, token): - - tokenization_dict = {0:None, 1:'LookDown', 2:'LookUp'} - - return tokenization_dict[token] - - def get_mode(self, action): - - #mode: (0) stop, (1) body, (2) yaw, (3) manipulation, (4) grasping, (5) head pitch - - value = None - - if action == 'stop': - value = 0 - elif action in set( ['LookDown', 'LookUp']): - value = 5 - elif action in set(['MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft']): - value = 1 - elif action in set(['PickupObject', 'ReleaseObject']): - value = 4 - elif action in set(['MoveArm', 'MoveArmBase']): - value = 3 - elif action == 'RotateAgent': - value = 2 - - assert(type(value)==int, 'Get Mode didn\'t return an int') - return value - - def detokenize_mode(self, token): - - tokenization_dict = {0: 'stop', 1:'MoveAgent', 2:'RotateAgent', 3:'MoveArm', 4:'PickupReleaseObject', 5:'PitchAgent'} - - return tokenization_dict[token] - - def detokenize_action(self, detokenized_mode, body_position_delta, body_yaw_delta, arm_position_delta, detokenized_pickup_release, detokenized_head_pitch): - - - if detokenized_mode == 'PickupReleaseObject': - return detokenized_pickup_release - - elif detokenized_mode == 'PitchAgent': - return detokenized_head_pitch - else: - return detokenized_mode - - - def get_pickup_release(self, action): - - if action == 'PickupObject': - value = 1 - elif action == 'ReleaseObject': - value = 2 - else: - value = 0 - - return value - - def detokenize_pickup_release(self, token): - - tokenization_dict = {0:None, 1:'PickupObject', 2:'ReleaseObject'} - return tokenization_dict[token] - - def __getitem__(self, idx): - - # pdb.set_trace() - - traj_group = self.hdf[self.dataset_keys[idx]] - - traj_steps = list(traj_group.keys()) - traj_steps.sort(key=sort_folders) - - #extract the NL command - json_str = traj_group[traj_steps[0]].attrs['metadata'] - traj_json_dict = json.loads(json_str) - nl_command = traj_json_dict['nl_command'] - - - #compute remainder in case padding of action tokens and observations needed - padding_length = 6 - (len(traj_steps)%6) if len(traj_steps)%6 > 0 else 0 - terminate = False - - start = 0; end = min(len(traj_steps), 6) - - #return list of dictionaries with attributes required for RT1 - all_image_obs = [] - all_nl_commands = [] - all_is_terminal = [] - all_pickup_release = [] - all_body_position_deltas = [] - all_body_yaw_deltas = [] - all_body_pitches = [] - all_arm_position_deltas = [] - all_control_mode = [] - - all_pad_lengths = [] - - - - #build the dictionary for each sequence - while end <= len(traj_steps) and not terminate: - - ''' - mode: stop, body, yaw, manipulation, grasping, head pitch - gripper: (x, y, z, grasp) - body: (x, y, yaw, look up/down) - ''' - image_obs = [] - nl_commands = [] - body_position_deltas = [] - body_yaw_deltas = [] - arm_position_deltas = [] - terminate_episodes = [] - pickup_releases = [] - body_pitches = [] - control_modes = [] - - for i in range(start, end): - - #visual observation - ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) - image_obs.append(ith_obs) - - #natural language command - nl_commands.append(nl_command) - - current_metadata = json.loads(traj_group[traj_steps[i]].attrs['metadata']) - - - if i < len(traj_steps)-1: - - next_metadata = json.loads(traj_group[traj_steps[i+1]].attrs['metadata']) - - #body position, body yaw, arm position - body_position_delta = np.array(next_metadata['steps'][0]['state_body'][:3])-np.array(current_metadata['steps'][0]['state_body'][:3]) - body_yaw_delta = next_metadata['steps'][0]['state_body'][3] - current_metadata['steps'][0]['state_body'][3] - arm_position_delta = np.array(next_metadata['steps'][0]['state_ee'][:3]) - np.array(current_metadata['steps'][0]['state_ee'][:3]) - - #terminate episode / pick up release / body pitch / mode - terminate_episode = int(i == len(traj_steps)-1) - pickup_release = self.get_pickup_release(next_metadata['steps'][0]['action']) - body_pitch = self.get_head_pitch(next_metadata['steps'][0]['action']) - control_mode = self.get_mode(next_metadata['steps'][0]['action']) - else: - - #body position, body yaw, arm positon -- for last step - body_position_delta = np.array([0.0, 0.0, 0.0]) - body_yaw_delta = 0.0 - arm_position_delta = np.array([0.0, 0.0, 0.0]) - - #is terminal / pick up release / body pitch / mode -- for last step - terminate_episode = int(i == len(traj_steps)-1) - pickup_release = self.get_pickup_release(None) - body_pitch = self.get_head_pitch(None) - control_mode = self.get_mode('stop') - - body_position_deltas.append(body_position_delta) - body_yaw_deltas.append(body_yaw_delta) - arm_position_deltas.append(arm_position_delta) - terminate_episodes.append(terminate_episode) - pickup_releases.append(pickup_release) - body_pitches.append(body_pitch) - control_modes.append(control_mode) - - - - #check for remainder and pad data with extra - if end >= len(traj_steps) and padding_length > 0: - - for pad in range(0, padding_length): - - image_obs.append(ith_obs) - nl_commands.append(nl_command) - - body_position_deltas.append(np.array([0.0, 0.0, 0.0])) - body_yaw_deltas.append(0.0) - arm_position_deltas.append(np.array([0.0, 0.0, 0.0])) - terminate_episodes.append(0) - pickup_releases.append(0.0) - body_pitches.append(0.0) - control_modes.append(0.0) - - terminate = True - elif end >= len(traj_steps): - terminate = True - - - - #pre-process and discretize numerical data - body_position_deltas = np.stack(body_position_deltas) - body_yaw_deltas = np.stack(body_yaw_deltas) - arm_position_deltas = np.stack(arm_position_deltas) - - if self.tokenize_action: - - tokenized_actions = { - 'body_position_deltas': body_position_deltas, - 'body_yaw_deltas': body_yaw_deltas, - 'arm_position_deltas': arm_position_deltas, - 'terminate_episode': terminate_episodes - } - - tokenized_actions = self.make_data_discrete(tokenized_actions) - - body_position_deltas = tokenized_actions['body_position_deltas'] - - body_yaw_deltas = np.expand_dims(tokenized_actions['body_yaw_deltas'], axis=1) - - arm_position_deltas = tokenized_actions['arm_position_deltas'] - - - - - all_image_obs.append(np.stack(image_obs)) - all_nl_commands.append(np.stack(nl_commands)) - all_is_terminal.append(np.stack(terminate_episodes)) - all_pickup_release.append(np.stack(pickup_releases)) - all_body_position_deltas.append(body_position_deltas) - all_body_yaw_deltas.append(body_yaw_deltas) - all_body_pitches.append(np.stack(body_pitches)) - all_arm_position_deltas.append(arm_position_deltas) - all_control_mode.append(np.stack(control_modes)) - - all_pad_lengths.append(0 if not end >= len(traj_steps) else padding_length) - - - start += 6 - end = min(end + 6, len(traj_steps)) - - - - - return np.stack(all_image_obs), np.stack(all_nl_commands), np.stack(all_is_terminal), np.stack(all_pickup_release), np.stack(all_body_position_deltas), np.stack(all_body_yaw_deltas), np.stack(all_body_pitches), np.stack(all_arm_position_deltas), np.stack(all_control_mode), np.stack(all_pad_lengths) - - - - def __getitem_old__(self, idx): - - - traj_group = self.hdf[self.dataset_keys[idx]] - - traj_steps = list(traj_group.keys()) - traj_steps.sort(key=sort_folders) - - #extract the NL command - json_str = traj_group[traj_steps[0]].attrs['metadata'] - traj_json_dict = json.loads(json_str) - nl_command = traj_json_dict['nl_command'] - - start = 0; end = min(len(traj_steps), 6) - - #return list of dictionaries with attributes required for RT1 - all_image_obs = [] - all_nl_commands = [] - all_is_terminal = [] - all_pickup_release = [] - all_body_position = [] - all_body_yaw = [] - all_body_pitch = [] - all_arm_position = [] - all_mode = [] - - - - #build the dictionary for each sequence - while end < len(traj_steps): - - ''' - mode: stop, body, yaw, manipulation, grasping, head pitch - gripper: (x, y, z, grasp) - body: (x, y, yaw, look up/down) - ''' - image_obs = [] - - for i in range(start, end): - ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) - - image_obs.append(ith_obs) - - image_obs = np.stack(image_obs) - - - - before_end_step_metadata = json.loads(traj_group[traj_steps[end-1]].attrs['metadata']) - end_step_metadata = json.loads(traj_group[traj_steps[end]].attrs['metadata']) - - - - dictionary = { - 'observation': image_obs, - 'nl_command': nl_command, #DONE - 'is_terminal': int(end_step_metadata['steps'][0]['action']=='stop'), #DONE - 'pickup_release': self.get_pickup_release(end_step_metadata['steps'][0]['action']), #DONE - 'body_position': np.array(end_step_metadata['steps'][0]['state_body'][:3])-np.array(before_end_step_metadata['steps'][0]['state_body'][:3]), #DONE - 'body_yaw': end_step_metadata['steps'][0]['state_body'][3] - before_end_step_metadata['steps'][0]['state_body'][3], #DONE - 'body_pitch': self.get_head_pitch(end_step_metadata['steps'][0]['action']), #DONE - 'arm_position': np.array(end_step_metadata['steps'][0]['state_ee'][:3]) - np.array(before_end_step_metadata['steps'][0]['state_ee'][:3]), #DONE - 'mode': self.get_mode(end_step_metadata['steps'][0]['action']) #DONE - } - - #pre-process the data dictonary - if self.tokenize_action: - self.make_data_discrete(dictionary) - - - all_image_obs.append(dictionary['observation']) - all_nl_commands.append(dictionary['nl_command']) - all_is_terminal.append(dictionary['is_terminal']) - all_pickup_release.append(dictionary['pickup_release']) - all_body_position.append(dictionary['body_position']) - all_body_yaw.append(dictionary['body_yaw']) - all_body_pitch.append(dictionary['body_pitch']) - all_arm_position.append(dictionary['arm_position']) - all_mode.append(dictionary['mode']) - - - start += 1 - end += 1 - - #add the terminal 'stop' step - all_image_obs.append(dictionary['observation']) - all_nl_commands.append(dictionary['nl_command']) - all_is_terminal.append(1) - all_pickup_release.append(0) - all_body_position.append([0,0,0]) - all_body_yaw.append(0) - all_body_pitch.append(0) - all_arm_position.append([0,0,0]) - all_mode.append(0) - - - - - - return np.stack(all_image_obs), np.stack(all_nl_commands), np.expand_dims(np.stack(all_is_terminal), axis=1), np.expand_dims(np.stack(all_pickup_release), axis=1), np.stack(all_body_position), np.expand_dims(np.stack(all_body_yaw),axis=1), np.expand_dims(np.stack(all_body_pitch), axis=1), np.stack(all_arm_position), np.expand_dims(np.stack(all_mode), axis=1) - - -if __name__ == '__main__': - - - dataset_manager = DatasetManager(0, 0.8, 0.1, 0.1) - - dataloader = DataLoader(dataset_manager.train_dataset, batch_size=3, - shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) - - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size=2, - shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) - - - - for batch, sample_batch in enumerate(dataloader): - - # print('BATCH {}:'.format(batch)) - # print('Num Steps: {}'.format(sample_batch[0].shape[0])) - print('Batch {}: '.format(batch), sample_batch[0].shape[0]) - - - - - \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json b/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json deleted file mode 100644 index da07b6395..000000000 --- a/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json +++ /dev/null @@ -1 +0,0 @@ -{"FloorPlan_Train8_1": ["data_11:11:28", "data_11:38:43", "data_11:48:40", "data_11:51:31", "data_11:56:47", "data_11:58:17", "data_12:18:24", "data_12:31:00", "data_12:49:55", "data_12:53:51", "data_12:54:21", "data_12:57:45", "data_12:59:43", "data_13:00:14", "data_13:13:47", "data_13:18:03", "data_13:22:48", "data_13:24:35", "data_13:29:42", "data_13:30:35", "data_13:36:19", "data_13:37:24", "data_13:38:39", "data_13:42:32", "data_13:48:30", "data_13:52:48", "data_13:56:06", "data_13:58:42", "data_14:01:23", "data_14:24:32", "data_14:26:22", "data_14:31:39", "data_14:36:13", "data_14:38:15", "data_14:44:47", "data_14:45:23", "data_14:49:15", "data_14:53:25", "data_14:58:54", "data_15:06:22", "data_15:09:43", "data_15:13:05", "data_15:13:36", "data_15:14:10", "data_15:16:32", "data_15:20:09", "data_15:22:18", "data_15:25:56", "data_15:26:42", "data_15:29:24", "data_15:29:51", "data_15:30:35", "data_15:32:34", "data_15:39:22", "data_15:41:58", "data_15:43:27", "data_15:43:51", "data_16:05:05", "data_16:09:25", "data_16:11:06", "data_16:13:53", "data_16:18:35", "data_16:23:48", "data_16:26:23", "data_16:30:54", "data_16:43:19", "data_16:49:20", "data_16:52:28", "data_16:53:34", "data_16:59:06", "data_17:00:51", "data_17:02:54", "data_17:04:35", "data_17:06:16", "data_17:13:00", "data_17:20:01", "data_17:23:07", "data_17:26:09", "data_17:33:07", "data_17:47:57", "data_17:51:34", "data_17:56:54", "data_17:58:11", "data_17:59:29", "data_18:01:53", "data_18:08:32", "data_18:18:37", "data_18:22:56", "data_18:25:09", "data_18:33:34", "data_18:45:42", "data_19:09:57", "data_19:15:07", "data_19:20:52", "data_19:25:51", "data_19:34:02", "data_19:43:09", "data_19:48:33", "data_19:52:25", "data_19:53:51", "data_20:29:26", "data_21:11:22", "data_21:14:13", "data_22:26:52"], "FloorPlan_Train1_3": ["data_11:14:08", "data_12:27:37", "data_12:28:44", "data_12:30:42", "data_12:42:59", "data_12:48:44", "data_13:01:08", "data_13:10:23", "data_13:16:27", "data_13:26:27", "data_13:29:09", "data_13:33:21", "data_13:35:43", "data_13:45:31", "data_13:49:19", "data_13:53:16", "data_13:59:05", "data_14:02:16", "data_14:19:36", "data_14:22:29", "data_14:24:31", "data_14:26:42", "data_14:32:06", "data_14:34:15", "data_14:35:23", "data_14:38:31", "data_14:43:46", "data_14:46:49", "data_14:48:48", "data_14:50:47", "data_14:56:50", "data_15:01:27", "data_15:35:48", "data_15:38:38", "data_15:39:32", "data_15:42:27", "data_15:49:15", "data_15:50:49", "data_15:51:26", "data_15:52:55", "data_15:54:45", "data_15:56:44", "data_15:58:10", "data_16:01:04", "data_16:03:52", "data_16:04:17", "data_16:10:32", "data_16:10:59", "data_16:33:34", "data_16:37:28", "data_16:40:36", "data_16:40:44", "data_16:42:54", "data_16:43:00", "data_16:43:00:00", "data_16:44:16", "data_16:45:24", "data_16:47:46", "data_16:49:24", "data_16:55:46", "data_17:05:08", "data_17:07:34", "data_17:07:43", "data_17:21:35", "data_17:26:17", "data_17:29:14", "data_17:32:17", "data_17:32:27", "data_17:43:33", "data_17:47:03", "data_17:51:39", "data_17:59:00", "data_18:04:56", "data_18:11:24", "data_18:17:16", "data_18:22:49", "data_18:25:44", "data_18:28:13", "data_18:28:43", "data_18:29:38", "data_18:31:13", "data_18:35:58", "data_18:37:04", "data_18:46:02", "data_19:14:43", "data_19:31:51", "data_19:35:53", "data_20:11:23", "data_20:15:34", "data_20:57:07", "data_21:09:57", "data_21:35:32", "data_21:40:45", "data_22:55:44", "data_22:59:37", "data_23:02:34"], "FloorPlan_Train5_1": ["data_11:19:28", "data_11:23:37", "data_12:05:09", "data_12:15:11", "data_12:22:25", "data_12:37:24", "data_12:40:41", "data_12:43:21", "data_12:58:49", "data_13:14:36", "data_13:22:30", "data_13:25:14", "data_13:28:56", "data_13:29:25", "data_13:31:07", "data_13:33:29", "data_13:40:50", "data_13:42:24", "data_13:46:04", "data_14:03:55", "data_14:05:06", "data_14:09:28", "data_14:10:09", "data_14:14:11", "data_14:18:16", "data_14:23:38", "data_14:36:10", "data_14:40:10", "data_14:47:53", "data_14:50:55", "data_14:56:41", "data_14:58:02", "data_14:58:08", "data_15:03:19", "data_15:05:49", "data_15:06:39", "data_15:08:16", "data_15:13:04", "data_15:19:26", "data_15:22:08", "data_15:27:41", "data_15:29:40", "data_15:40:49", "data_15:44:42", "data_15:56:53", "data_15:58:27", "data_16:00:55", "data_16:02:46", "data_16:05:15", "data_16:06:05", "data_16:07:40", "data_16:09:36", "data_16:12:08", "data_16:26:34", "data_16:29:17", "data_16:31:09", "data_16:31:36", "data_16:35:27", "data_16:43:42", "data_16:45:58", "data_16:47:16", "data_16:50:06", "data_16:51:03", "data_16:53:36", "data_16:53:39", "data_16:53:42", "data_16:54:39", "data_16:56:38", "data_16:57:05:00", "data_16:57:25", "data_17:12:32", "data_17:17:50", "data_17:35:45", "data_17:39:05:00", "data_17:41:00", "data_17:41:08", "data_17:45:27", "data_17:50:42", "data_17:54:05", "data_17:56:23", "data_18:22:47", "data_18:31:07", "data_18:33:51", "data_18:37:38", "data_18:42:03", "data_18:44:54", "data_18:47:01", "data_18:50:53", "data_18:58:07", "data_19:04:21", "data_19:08:32", "data_19:27:25", "data_19:53:59", "data_19:57:56", "data_20:07:12", "data_22:02:06", "data_22:10:19", "data_23:06:06", "data_23:09:41", "data_23:16:06"], "FloorPlan_Train12_3": ["data_11:24:25", "data_12:04:43", "data_12:04:44", "data_12:09:11", "data_12:12:18", "data_12:13:00", "data_12:48:09", "data_12:55:46", "data_13:02:17", "data_13:04:13", "data_13:06:18", "data_13:07:22", "data_13:07:34", "data_13:08:21", "data_13:10:24", "data_13:15:55", "data_13:18:11", "data_13:19:12", "data_13:33:54", "data_13:37:23", "data_13:39:28", "data_13:40:16", "data_13:51:04", "data_13:52:30", "data_13:56:07", "data_13:57:55", "data_14:04:08", "data_14:06:14", "data_14:06:28", "data_14:07:59", "data_14:10:04", "data_14:19:43", "data_14:23:01", "data_14:25:51", "data_14:36:45", "data_14:38:16", "data_14:40:46", "data_15:04:08", "data_15:06:03", "data_15:08:14", "data_15:10:38", "data_15:13:32", "data_15:15:15", "data_15:21:58", "data_15:22:59", "data_15:23:17", "data_15:25:19", "data_15:27:29", "data_15:27:52", "data_15:34:50", "data_15:37:13", "data_15:37:30", "data_15:39:06", "data_15:39:14", "data_15:40:22", "data_15:41:15", "data_15:46:13", "data_15:47:54", "data_15:48:04", "data_15:50:55", "data_16:03:07", "data_16:11:48", "data_16:12:38", "data_16:15:33", "data_16:21:47", "data_16:22:10", "data_16:22:44", "data_16:25:33", "data_16:27:27", "data_16:33:37", "data_16:33:42", "data_16:35:20", "data_16:37:57", "data_16:58:28", "data_16:59:59", "data_17:02:20", "data_17:05:07", "data_17:07:22", "data_17:08:14", "data_17:08:43", "data_17:10:41", "data_17:12:20", "data_17:16:57", "data_17:25:26", "data_17:31:59", "data_17:39:05", "data_18:05:31", "data_18:06:05", "data_18:09:48", "data_18:11:32", "data_18:20:49", "data_18:38:30", "data_18:40:29", "data_18:44:56", "data_19:32:42", "data_19:36:17", "data_19:38:40", "data_19:55:46", "data_19:58:40", "data_20:04:58", "data_20:36:00", "data_20:40:25", "data_20:40:56", "data_20:43:46", "data_21:22:47", "data_21:27:13", "data_21:36:02", "data_21:39:40"], "FloorPlan_Train7_5": ["data_11:33:11", "data_11:35:24", "data_11:38:27", "data_11:44:50", "data_11:50:57", "data_12:03:39", "data_12:30:12", "data_12:36:36", "data_12:41:02", "data_12:45:50", "data_12:46:17", "data_12:48:23", "data_12:50:47", "data_12:59:13", "data_13:01:06", "data_13:06:40", "data_13:10:05", "data_13:19:26", "data_13:33:39", "data_13:34:59", "data_13:39:14", "data_13:39:53", "data_13:41:08", "data_13:44:39", "data_13:48:45", "data_13:53:16:00", "data_14:17:20", "data_14:19:54", "data_14:22:51", "data_14:23:49", "data_14:29:19", "data_14:40:36", "data_14:43:02", "data_14:45:24", "data_14:52:27", "data_15:00:11", "data_15:02:05", "data_15:05:00", "data_15:06:51", "data_15:08:00", "data_15:08:23", "data_15:09:40", "data_15:10:35", "data_15:15:28", "data_15:18:01", "data_15:19:33", "data_15:20:32", "data_15:22:15", "data_15:24:10", "data_15:33:02", "data_15:35:16", "data_15:36:12", "data_15:37:15", "data_15:58:50", "data_16:00:52", "data_16:02:56", "data_16:03:52:00", "data_16:04:13", "data_16:08:41", "data_16:10:21", "data_16:12:36", "data_16:15:15", "data_16:18:47", "data_16:21:30", "data_16:33:14", "data_16:35:18", "data_16:36:47", "data_16:37:29", "data_16:43:59", "data_16:47:31", "data_16:55:23", "data_16:55:40", "data_16:57:05", "data_16:57:21", "data_16:58:20", "data_16:58:53", "data_16:59:33", "data_16:59:34", "data_17:00:42", "data_17:00:58", "data_17:02:46", "data_17:02:49", "data_17:03:08", "data_17:10:18", "data_17:32:08", "data_17:39:16", "data_17:43:47", "data_17:46:14", "data_17:48:24", "data_17:58:02", "data_17:59:14", "data_18:01:35", "data_18:06:24", "data_18:09:10", "data_18:12:41", "data_18:15:58", "data_18:26:13", "data_18:39:40", "data_18:41:38", "data_18:45:39", "data_18:54:32", "data_18:57:41", "data_18:59:56", "data_19:00:23", "data_19:02:18", "data_19:03:13", "data_19:15:22", "data_19:18:14", "data_19:20:26", "data_19:27:05", "data_20:26:48", "data_20:33:59", "data_22:17:48", "data_23:21:12", "data_23:26:05", "data_23:27:44"]} \ No newline at end of file diff --git a/models/main_models/rt1/main.py b/models/main_models/rt1/main.py deleted file mode 100644 index 29f6032bd..000000000 --- a/models/main_models/rt1/main.py +++ /dev/null @@ -1,257 +0,0 @@ -import argparse -import os -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -from tqdm import tqdm -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--datasets", - type=list, - default=['fractal20220817_data'], - ) - parser.add_argument( - "--train-split", - type=str, - default="train[:-1000]", - help="use e.g. train[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-split", - type=str, - default="train[-1000:]", - help="use e.g. eval[:100] for the first 100 episodes", - ) - parser.add_argument( - "--epochs", - type=int, - default=1, - help="number of training epochs", - ) - parser.add_argument( - "--lr", - type=float, - default=1e-4, - help="learning rate", - ) - parser.add_argument( - "--train-batch-size", - type=int, - default=8, - help="train batch size", - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=8, - help="eval batch size", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=6, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--eval-freq", - type=int, - default=0, - help="eval frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-freq", - type=int, - default=200, - help="checkpoint frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-dir", - type=str, - default="checkpoints/rt1_pretraining", - help="directory to save checkpoints", - ) - parser.add_argument( - "--load-checkpoint", - type=str, - default=None, - help="checkpoint to load from; defaults to None", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - if args.wandb: - wandb.init(project="rt1-pretraining-v1", config=vars(args)) - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - print("Loading dataset...") - - train_dataset = create_dataset( - datasets=args.datasets, - split=args.train_split, - trajectory_length=args.trajectory_length, - batch_size=args.train_batch_size, - num_epochs=args.epochs, - ) - # eval_dataset = create_dataset( - # datasets=args.datasets, - # split=args.eval_split, - # trajectory_length=args.trajectory_length, - # batch_size=args.eval_batch_size, - # num_epochs=args.epochs, - # ) - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - action_space = gym.spaces.Dict( - world_vector=gym.spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), - base_displacement_vertical_rotation=gym.spaces.Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 - ), - gripper_closedness_action=gym.spaces.Box( - low=-1.0, high=1.0, shape=(1,), dtype=np.float32 - ), - terminate_episode=gym.spaces.Discrete(3), - base_displacement_vector=gym.spaces.Box( - low=-1.0, - high=1.0, - shape=(2,), - dtype=np.float32, - ), - rotation_delta=gym.spaces.Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 - ), - ) - - print("Building policy...") - policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=args.load_checkpoint, - ) - - policy.model.train() - optimizer = Adam(policy.model.parameters(), lr=args.lr) - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else None - ) - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - def get_text_embedding(observation: Dict): - if text_embedding_model is not None: - return text_embedding_model.encode(observation["instruction"]) - else: - return observation["embedding"] - - print("Training...") - num_batches = 0 - - for batch in tqdm(train_dataset): - - policy.model.train() - - num_batches += 1 - - if num_batches <= 0: - continue - - #Image Shape: 8, 6, 480, 640, 3 => (batch, length, height, width, channel) - #Context Shape: 8, 6, 512 => (batch, length, embedding) - observations = { - "image": batch["observation"]["image"], - "context": get_text_embedding(batch["observation"]), - } - - - actions = batch["action"] - - try: - loss, loss_std = policy.loss(observations, actions) - except: - print('-------------LOSS COMPUTATION FAILED!!!--------') - continue - - if args.wandb: - wandb.log({"loss": loss.item(), "loss_std": loss_std.item()}, step=num_batches * args.train_batch_size) - print(f"Train loss Batch {num_batches}: {loss.item()}") - else: - print(f"Train loss Batch {num_batches}: {loss.item()}") - optimizer.zero_grad() - loss.backward() - optimizer.step() - if args.eval_freq and num_batches % args.eval_freq == 0: - print("Evaluating...") - policy.model.eval() - batch = next(eval_dataset) - observations = { - "image": batch["observation"]["image"], - "context": get_text_embedding(batch["observation"]), - } - actions = batch["action"] - eval_loss, eval_loss_std = policy.loss(observations, actions) - eval_loss = eval_loss.item() - if args.wandb: - wandb.log( - {"eval_loss": eval_loss, "eval_loss_std": eval_loss_std.item()}, - step=num_batches * args.train_batch_size, - ) - else: - print(f"Eval loss Batch {num_batches}: {eval_loss}") - if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: - checkpoint_path = ( - f"{args.checkpoint_dir}/checkpoint_" - + f"{num_batches}" - + f"_loss_{loss.item():.3f}.pt" - ) - torch.save(policy.model.state_dict(), checkpoint_path) - print(f"Saved checkpoint to {checkpoint_path}") - print("finished training") - -if __name__ == "__main__": - main() diff --git a/models/main_models/rt1/main_ft.py b/models/main_models/rt1/main_ft.py deleted file mode 100644 index dca6394ab..000000000 --- a/models/main_models/rt1/main_ft.py +++ /dev/null @@ -1,387 +0,0 @@ -import argparse -import os -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -import tensorflow_hub as hub -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy -from tqdm import tqdm -from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader -import gc - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--datasets", - type=list, - default=["fractal20220817_data"], - ) - parser.add_argument( - "--train-split", - type=str, - default="train[:-1000]", - help="use e.g. train[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-split", - type=str, - default="train[-1000:]", - help="use e.g. eval[:100] for the first 100 episodes", - ) - parser.add_argument( - "--epochs", - type=int, - default=4, - help="number of training epochs", - ) - parser.add_argument( - "--lr", - type=float, - default=1e-4, - help="learning rate", - ) - parser.add_argument( - "--train-batch-size", - type=int, - default=3, - help="train batch size", - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=3, - help="eval batch size", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=6, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--eval-freq", - type=int, - default=0, #200 - help="eval frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-freq", - type=int, - default=100, - help="checkpoint frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-dir", - type=str, - default="checkpoints/temp", #"checkpoints/diversity_v1_4" - help="directory to save checkpoints", - ) - parser.add_argument( - "--load-checkpoint", - type=str, - default='/oscar/data/stellex/shared/rt1-checkpoints/checkpoints/bridge/checkpoint_14400_loss_70.621.pt', #NOTE: include the path to load the checkpoint here - help="checkpoint to load from; defaults to None", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - - parser.add_argument( - "--eval-scene", - default=4, - help = "scene used as validation during k-fold cross validation", - ) - - parser.add_argument( - "--split-type", - default = 'k_fold_scene', - choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], - ) - - parser.add_argument( - "--num-diversity-scenes", - default = 4, - ) - - parser.add_argument( - "--max-diversity-trajectories", - default = 100, - ) - - - parser.add_argument( - "--train-subbatch", - default=8, - ) - parser.add_argument( - "--eval-subbatch", - default=5, - ) - return parser.parse_args() - - -def main(): - - - args = parse_args() - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - if args.wandb: - wandb.init(project="rt1-data-diversity-v1", config=vars(args)) - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - print("Loading dataset...") - - - dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) - - if args.wandb and args.split_type == 'diversity_ablation': - wandb.log({"task_keys": dataset_manager.train_dataset.dataset_keys}) - - train_dataloader = DataLoader(dataset_manager.train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches, drop_last = False) - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=True, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) - - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - - action_space = gym.spaces.Dict( - - body_yaw_delta = gym.spaces.Box( - low= 0, #train_dataloader.body_orientation_lim['min_yaw'] - high= 255, #train_dataloader.body_orientation_lim['max_yaw'] - shape=(1,), - dtype=int - ), - - body_pitch_delta = gym.spaces.Discrete(3), - - terminate_episode=gym.spaces.Discrete(2), - - pickup_release = gym.spaces.Discrete(3), - - body_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - arm_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - control_mode = gym.spaces.Discrete(7), - - ) - - print("Building policy...") - policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=args.load_checkpoint, - ) - - policy.model.train() - optimizer = Adam(policy.model.parameters(), lr=args.lr) - - #NOTE: has to be Not None because of raw instruction input - - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") - ) - - - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - def get_text_embedding(observation: Dict): - - if args.sentence_transformer is not None: - return text_embedding_model.encode(observation) - else: - embedded_observation = [] - - for i in range(0, observation.shape[1]): - - try: - embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) - except: - print('EMBEDDING FAILED!') - - - embedded_observation = np.stack(embedded_observation, axis=1) - return embedded_observation - - print("Training...") - num_batches = 0 - total_train_steps = 0 - total_val_steps = 0 - - - - - for epoch in range(args.epochs): - print("STARTING EPOCH {}".format(epoch+1)) - - for batch, train_batch in enumerate(train_dataloader): - - - batch_steps = train_batch[0].shape[0] - - for idx in range(0, batch_steps, args.train_subbatch): - - - - policy.model.train() - - num_batches += 1 - - - observations = { - "image": train_batch[0][idx : min(idx + args.train_subbatch, batch_steps)], - "context": get_text_embedding(train_batch[1][idx : min(idx + args.train_subbatch, batch_steps)]), - } - - - actions = { - 'terminate_episode': train_batch[2][idx : min(idx + args.train_subbatch, batch_steps)], - 'pickup_release': train_batch[3][idx : min(idx + args.train_subbatch, batch_steps)], - 'body_position_delta': train_batch[4][idx : min(idx + args.train_subbatch, batch_steps)], - 'body_yaw_delta': train_batch[5][idx : min(idx + args.train_subbatch, batch_steps)], - 'body_pitch_delta': train_batch[6][idx : min(idx + args.train_subbatch, batch_steps)], - 'arm_position_delta': train_batch[7][idx : min(idx + args.train_subbatch, batch_steps)], - 'control_mode': train_batch[8][idx : min(idx + args.train_subbatch, batch_steps)] - } - - padding = train_batch[9][idx : min(idx + args.train_subbatch, batch_steps)] - total_train_steps += batch_steps - - - loss, loss_std = policy.loss(observations, actions) - - if args.wandb: - print(f"Train loss Batch {num_batches}: {loss.item()} ± {loss_std.item()}") - wandb.log({"train_loss": loss.item(), "train_loss_std": loss_std.item()}, step= total_train_steps) - else: - print(f"Train loss Batch {num_batches}: {loss.item()}") - - optimizer.zero_grad() - loss.backward() - optimizer.step() - observations = {}; actions = {} - - - if args.eval_freq and num_batches % args.eval_freq == 0: - - # Clear cache and collected garbage - gc.collect() - torch.cuda.empty_cache() - - total_eval_loss = 0 - total_eval_loss_std = 0 - total_eval_count = 0 - - - - print("Evaluating...") - for batch, val_batch in enumerate(val_dataloader): - - batch_steps = val_batch[0].shape[0] - - print(f'Section {batch+1} of {len(val_dataloader)}') - - for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): - - - policy.model.eval() - - - total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - - observations = { - "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], - "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), - } - - - actions = { - 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], - 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], - 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], - 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] - } - - padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] - - eval_loss, eval_loss_std = policy.loss(observations, actions) - - - total_eval_loss += eval_loss.item()*observations['image'].shape[0] - total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] - - if args.wandb: - wandb.log( - {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, - step=total_train_steps, - ) - print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") - else: - print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") - - if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: - checkpoint_path = ( - f"{args.checkpoint_dir}/checkpoint_" - + f"{total_train_steps}" - + f"_loss_{loss.item():.3f}.pt" - ) - torch.save(policy.model.state_dict(), checkpoint_path) - print(f"Saved checkpoint to {checkpoint_path}") - - print("FINISHED EPOCH {}".format(epoch+1)) - print("finished training") - -if __name__ == "__main__": - main() diff --git a/models/main_models/rt1/main_ft_eval.py b/models/main_models/rt1/main_ft_eval.py deleted file mode 100644 index 708243b25..000000000 --- a/models/main_models/rt1/main_ft_eval.py +++ /dev/null @@ -1,279 +0,0 @@ -import argparse -import os -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -import tensorflow_hub as hub -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy -from tqdm import tqdm -from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader -import gc - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--datasets", - type=list, - default=["fractal20220817_data"], - ) - parser.add_argument( - "--train-split", - type=str, - default="train[:-1000]", - help="use e.g. train[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-split", - type=str, - default="train[-1000:]", - help="use e.g. eval[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=3, - help="eval batch size", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=6, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--checkpoint-path", - type=str, - default="checkpoints/scene4", - help="directory to save checkpoints", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - - parser.add_argument( - "--eval-scene", - default=4, - help = "scene used as validation during k-fold cross validation", - ) - parser.add_argument( - "--eval-subbatch", - default=5, - ) - parser.add_argument( - "--split-type", - default = 'k_fold_scene', - choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], - ) - - parser.add_argument( - "--num-diversity-scenes", - default = 4, - ) - - parser.add_argument( - "--max-diversity-trajectories", - default = 100, - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - - os.makedirs(args.checkpoint_path, exist_ok=True) - - if args.wandb: - wandb.init(project="rt1-finetuning", config=vars(args)) - - os.makedirs(args.checkpoint_path, exist_ok=True) - - assert(len(os.listdir(args.checkpoint_path)) > 0 , "ERROR: checkpoint path is empty and has no saved checkpoints") - - print("Loading dataset...") - - - dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) - - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - - action_space = gym.spaces.Dict( - - body_yaw_delta = gym.spaces.Box( - low= 0, #train_dataloader.body_orientation_lim['min_yaw'] - high= 255, #train_dataloader.body_orientation_lim['max_yaw'] - shape=(1,), - dtype=int - ), - - body_pitch_delta = gym.spaces.Discrete(3), - - terminate_episode=gym.spaces.Discrete(2), - - pickup_release = gym.spaces.Discrete(3), - - body_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - arm_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - control_mode = gym.spaces.Discrete(7), - - ) - - - - #NOTE: has to be Not None because of raw instruction input - - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") - ) - - - - - def get_text_embedding(observation: Dict): - - if args.sentence_transformer is not None: - return text_embedding_model.encode(observation) - else: - embedded_observation = [] - - for i in range(0, observation.shape[1]): - - try: - embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) - except: - pdb.set_trace() - - embedded_observation = np.stack(embedded_observation, axis=1) - return embedded_observation - - - def extract_train_step(filepath): - return int(filepath.split('_')[1]) - - - print("Evaluating...") - - - for idx, checkpoint_file in enumerate(list(sorted(os.listdir(args.checkpoint_path), key=extract_train_step))): - - print(f'Evaluating file: {idx} of {len(os.listdir(args.checkpoint_path))}') - total_train_steps = int(checkpoint_file.split('_')[1]) - total_val_steps = 0 - - - total_eval_loss = 0 - total_eval_loss_std = 0 - total_eval_count = 0 - - print("Building policy...") - policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=os.path.join(args.checkpoint_path, checkpoint_file), - ) - - - - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - - - for batch, val_batch in enumerate(val_dataloader): - - batch_steps = val_batch[0].shape[0] - - print(f'Section {batch+1} of {len(val_dataloader)}') - - for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): - - - policy.model.eval() - - - total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - - observations = { - "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], - "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), - } - - - actions = { - 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], - 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], - 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], - 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] - } - - padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] - - eval_loss, eval_loss_std = policy.loss(observations, actions) - - - total_eval_loss += eval_loss.item()*observations['image'].shape[0] - total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] - - if args.wandb: - wandb.log( - {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, - step=total_train_steps, - ) - print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") - else: - print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") - -if __name__ == "__main__": - main() diff --git a/models/main_models/rt1/rollout_ai2thor.py b/models/main_models/rt1/rollout_ai2thor.py deleted file mode 100644 index 0edf255ca..000000000 --- a/models/main_models/rt1/rollout_ai2thor.py +++ /dev/null @@ -1,366 +0,0 @@ -import argparse -import os -os.environ["CUDA_VISIBLE_DEVICES"] = "0" -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -import tensorflow_hub as hub -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy -from tqdm import tqdm -from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader -import gc -import json -import pandas as pd -from ai2thor_env import ThorEnv -import pickle -import time -from tqdm import tqdm - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--checkpoint-file-path", - type=str, - default="checkpoints/scene2/checkpoint_299183_loss_152.175.pt", #NOTE: change according to checkpoint file that is to be loaded - help="directory to save checkpoints", - ) - - parser.add_argument( - "--trajectory-save-path", - type=str, - default="traj_rollouts/scene2", - help = "directory to save the generated trajectory predicted by the model" - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - parser.add_argument( - "--eval-scene", - default=2, - help = "scene used as validation during k-fold cross validation", - ) - parser.add_argument( - "--eval-subbatch", - default=1, - ) - parser.add_argument( - "--split-type", - default = 'k_fold_scene', - choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], - ) - parser.add_argument( - "--num-diversity-scenes", - default = 3, - ) - parser.add_argument( - "--max-diversity-trajectories", - default = 100, - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=3, - help="eval batch size", - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - if args.wandb: - wandb.init(project="rt1-rollout-data", config=vars(args)) - - os.makedirs(args.trajectory_save_path, exist_ok=True) - - assert(os.path.isfile(args.checkpoint_file_path), "ERROR: checkpoint file does not exist") - - - print("Loading dataset...") - - dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) - - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - - action_space = gym.spaces.Dict( - - body_yaw_delta = gym.spaces.Box( - low= 0, #train_dataloader.body_orientation_lim['min_yaw'] - high= 255, #train_dataloader.body_orientation_lim['max_yaw'] - shape=(1,), - dtype=int - ), - - body_pitch_delta = gym.spaces.Discrete(3), - - terminate_episode=gym.spaces.Discrete(2), - - pickup_release = gym.spaces.Discrete(3), - - body_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - arm_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - control_mode = gym.spaces.Discrete(7), - - ) - - - - #NOTE: has to be Not None because of raw instruction input - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") - ) - - - - - def get_text_embedding(observation: Dict): - - if args.sentence_transformer is not None: - return text_embedding_model.encode(observation) - else: - embedded_observation = [] - - for i in range(0, observation.shape[1]): - - try: - embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) - except: - raise Exception('Error: task descriptions could not be embedded') - - embedded_observation = np.stack(embedded_observation, axis=1) - return embedded_observation - - - - - print("Loading chosen checkpoint to model...") - rt1_model_policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=args.checkpoint_file_path, - ) - rt1_model_policy.model.eval() - - # Total number of params - total_params = sum(p.numel() for p in rt1_model_policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in rt1_model_policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in rt1_model_policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - - print('Creating pandas dataframe for trajectories...') - - print_val = True - - - for task in tqdm(val_dataloader.dataset.dataset_keys): - - - #skip tasks that trajectory already generated for - if os.path.isfile(os.path.join(args.trajectory_save_path, task)): - continue - elif print_val: - print('START AT: ', val_dataloader.dataset.dataset_keys.index(task)) - print_val = False - - traj_group = val_dataloader.dataset.hdf[task] - - traj_steps = list(traj_group.keys()) - - #extract the NL command - json_str = traj_group[traj_steps[0]].attrs['metadata'] - traj_json_dict = json.loads(json_str) - language_command_embedding = get_text_embedding(np.array([[traj_json_dict['nl_command']]])) - language_command_embedding = np.repeat(language_command_embedding, 6, axis=1) - - - print('TASK: ', traj_json_dict['nl_command']) - - #initialize the AI2Thor environment - ai2thor_env = ThorEnv(traj_json_dict['nl_command']) - event = ai2thor_env.reset(traj_json_dict['scene']) - - - - #extract the visual observation from initialzed environment - curr_image = event.frame - visual_observation = np.expand_dims(np.expand_dims(curr_image, axis=0) , axis=0) - visual_observation = np.repeat(visual_observation, 6, axis=1) - - ''' - OLD OBS FROM DATASET - visual_observation = np.expand_dims(np.expand_dims(np.array(traj_group[traj_steps[0]]['rgb_0']), axis=0), axis=0) - visual_observation = np.repeat(visual_observation, 6, axis=1) - ''' - - #track the starting coordinates for body, yaw rotation and arm coordinate - curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) - curr_body_yaw = event.metadata['agent']['rotation']['y'] - curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) - agent_holding = np.array([]) - - - #track the total number of steps and the last control mode - num_steps = 0; curr_mode = None; is_terminal = False - - - #track data for all steps - trajectory_data = [] - - while (curr_mode != 'stop' or is_terminal) and num_steps < ai2thor_env.max_episode_length: - - #provide the current observation to the model - curr_observation = { - 'image': visual_observation, - 'context': language_command_embedding - } - - generated_action_tokens = rt1_model_policy.act(curr_observation) - - #de-tokenize the generated actions from RT1 - pickup_release = val_dataloader.dataset.detokenize_pickup_release(generated_action_tokens['pickup_release'][0]) - body_pitch = val_dataloader.dataset.detokenize_head_pitch(generated_action_tokens['body_pitch_delta'][0]) - curr_mode = val_dataloader.dataset.detokenize_mode(generated_action_tokens['control_mode'][0]) - - - - - terminate_episode = generated_action_tokens['terminate_episode'][0] - - continuous_variables = { - 'body_position_delta': generated_action_tokens['body_position_delta'], - 'body_yaw_delta': generated_action_tokens['body_yaw_delta'], - 'arm_position_delta': generated_action_tokens['arm_position_delta'], - 'curr_mode': curr_mode - } - - continuous_variables = val_dataloader.dataset.detokenize_continuous_data(continuous_variables) - body_position_delta = np.squeeze(continuous_variables['body_position_delta']) - body_yaw_delta = continuous_variables['body_yaw_delta'][0][0] - arm_position_delta = np.squeeze(continuous_variables['arm_position_delta']) - - curr_action = val_dataloader.dataset.detokenize_action(curr_mode, body_position_delta, body_yaw_delta, arm_position_delta, pickup_release, body_pitch) - - - - #update the tracked coordinate data based on model output - curr_body_coordinate += body_position_delta - curr_body_yaw += body_yaw_delta - curr_arm_coordinate += arm_position_delta - - - #execute the generated action in the AI2THOR simulator - step_args = { - 'xyz_body': curr_body_coordinate, - 'xyz_body_delta': body_position_delta, - 'curr_body_yaw': curr_body_yaw, - 'body_yaw_delta': body_yaw_delta, - 'arm_position_delta': arm_position_delta, - 'arm_position': curr_arm_coordinate - } - success, error, event = ai2thor_env.step(curr_action, step_args) - - time.sleep(0.25) - - #fetch object holding from simulator; also maybe fetch coordinate of body/arm + yaw from simulator - agent_holding = np.array(event.metadata['arm']['heldObjects']) - - #fetch the new visual observation from the simulator, update the current mode and increment number of steps - curr_image = np.expand_dims(np.expand_dims(event.frame, axis=0) , axis=0) - - visual_observation = visual_observation[:,1:,:,:,:] - visual_observation = np.concatenate((visual_observation, curr_image), axis=1) - num_steps +=1 - - curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) - curr_body_yaw = event.metadata['agent']['rotation']['y'] - curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) - - - #add data to the dataframe CSV - step_data = { - 'task': traj_json_dict['nl_command'], - 'scene': traj_json_dict['scene'], - 'img': curr_image, - 'xyz_body': curr_body_coordinate, - 'xyz_body_delta': body_position_delta, - 'yaw_body': curr_body_yaw, - 'yaw_body_delta': body_yaw_delta, - 'pitch_body': body_pitch, - 'xyz_ee': curr_arm_coordinate, - 'xyz_ee_delta': arm_position_delta, - 'pickup_dropoff': pickup_release, - 'holding_obj': agent_holding, - 'control_mode': curr_mode, - 'action': curr_action, - 'terminate': terminate_episode, - 'step': num_steps, - 'timeout': num_steps >= ai2thor_env.max_episode_length, - 'error': error - } - - trajectory_data.append(step_data) - - #save the final event with all metadata: save as a json file dict - save_path = os.path.join(args.trajectory_save_path, task) - with open(save_path, 'wb') as file: - pickle.dump({'trajectory_data': trajectory_data, 'final_state': event.metadata}, file) - - #close the old GUI for AI2Thor after trajectory finishes - ai2thor_env.controller.stop() - time.sleep(0.5) - - - - - - - -if __name__ == "__main__": - main() diff --git a/models/main_models/rt1/rt1_env/bin/Activate.ps1 b/models/main_models/rt1/rt1_env/bin/Activate.ps1 deleted file mode 100644 index 9d3646a4f..000000000 --- a/models/main_models/rt1/rt1_env/bin/Activate.ps1 +++ /dev/null @@ -1,241 +0,0 @@ -<# -.Synopsis -Activate a Python virtual environment for the current PowerShell session. - -.Description -Pushes the python executable for a virtual environment to the front of the -$Env:PATH environment variable and sets the prompt to signify that you are -in a Python virtual environment. Makes use of the command line switches as -well as the `pyvenv.cfg` file values present in the virtual environment. - -.Parameter VenvDir -Path to the directory that contains the virtual environment to activate. The -default value for this is the parent of the directory that the Activate.ps1 -script is located within. - -.Parameter Prompt -The prompt prefix to display when this virtual environment is activated. By -default, this prompt is the name of the virtual environment folder (VenvDir) -surrounded by parentheses and followed by a single space (ie. '(.venv) '). - -.Example -Activate.ps1 -Activates the Python virtual environment that contains the Activate.ps1 script. - -.Example -Activate.ps1 -Verbose -Activates the Python virtual environment that contains the Activate.ps1 script, -and shows extra information about the activation as it executes. - -.Example -Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv -Activates the Python virtual environment located in the specified location. - -.Example -Activate.ps1 -Prompt "MyPython" -Activates the Python virtual environment that contains the Activate.ps1 script, -and prefixes the current prompt with the specified string (surrounded in -parentheses) while the virtual environment is active. - -.Notes -On Windows, it may be required to enable this Activate.ps1 script by setting the -execution policy for the user. You can do this by issuing the following PowerShell -command: - -PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser - -For more information on Execution Policies: -https://go.microsoft.com/fwlink/?LinkID=135170 - -#> -Param( - [Parameter(Mandatory = $false)] - [String] - $VenvDir, - [Parameter(Mandatory = $false)] - [String] - $Prompt -) - -<# Function declarations --------------------------------------------------- #> - -<# -.Synopsis -Remove all shell session elements added by the Activate script, including the -addition of the virtual environment's Python executable from the beginning of -the PATH variable. - -.Parameter NonDestructive -If present, do not remove this function from the global namespace for the -session. - -#> -function global:deactivate ([switch]$NonDestructive) { - # Revert to original values - - # The prior prompt: - if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { - Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt - Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT - } - - # The prior PYTHONHOME: - if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { - Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME - Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME - } - - # The prior PATH: - if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { - Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH - Remove-Item -Path Env:_OLD_VIRTUAL_PATH - } - - # Just remove the VIRTUAL_ENV altogether: - if (Test-Path -Path Env:VIRTUAL_ENV) { - Remove-Item -Path env:VIRTUAL_ENV - } - - # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: - if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { - Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force - } - - # Leave deactivate function in the global namespace if requested: - if (-not $NonDestructive) { - Remove-Item -Path function:deactivate - } -} - -<# -.Description -Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the -given folder, and returns them in a map. - -For each line in the pyvenv.cfg file, if that line can be parsed into exactly -two strings separated by `=` (with any amount of whitespace surrounding the =) -then it is considered a `key = value` line. The left hand string is the key, -the right hand is the value. - -If the value starts with a `'` or a `"` then the first and last character is -stripped from the value before being captured. - -.Parameter ConfigDir -Path to the directory that contains the `pyvenv.cfg` file. -#> -function Get-PyVenvConfig( - [String] - $ConfigDir -) { - Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" - - # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). - $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue - - # An empty map will be returned if no config file is found. - $pyvenvConfig = @{ } - - if ($pyvenvConfigPath) { - - Write-Verbose "File exists, parse `key = value` lines" - $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath - - $pyvenvConfigContent | ForEach-Object { - $keyval = $PSItem -split "\s*=\s*", 2 - if ($keyval[0] -and $keyval[1]) { - $val = $keyval[1] - - # Remove extraneous quotations around a string value. - if ("'""".Contains($val.Substring(0, 1))) { - $val = $val.Substring(1, $val.Length - 2) - } - - $pyvenvConfig[$keyval[0]] = $val - Write-Verbose "Adding Key: '$($keyval[0])'='$val'" - } - } - } - return $pyvenvConfig -} - - -<# Begin Activate script --------------------------------------------------- #> - -# Determine the containing directory of this script -$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition -$VenvExecDir = Get-Item -Path $VenvExecPath - -Write-Verbose "Activation script is located in path: '$VenvExecPath'" -Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" -Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" - -# Set values required in priority: CmdLine, ConfigFile, Default -# First, get the location of the virtual environment, it might not be -# VenvExecDir if specified on the command line. -if ($VenvDir) { - Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" -} -else { - Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." - $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") - Write-Verbose "VenvDir=$VenvDir" -} - -# Next, read the `pyvenv.cfg` file to determine any required value such -# as `prompt`. -$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir - -# Next, set the prompt from the command line, or the config file, or -# just use the name of the virtual environment folder. -if ($Prompt) { - Write-Verbose "Prompt specified as argument, using '$Prompt'" -} -else { - Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" - if ($pyvenvCfg -and $pyvenvCfg['prompt']) { - Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" - $Prompt = $pyvenvCfg['prompt']; - } - else { - Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" - Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" - $Prompt = Split-Path -Path $venvDir -Leaf - } -} - -Write-Verbose "Prompt = '$Prompt'" -Write-Verbose "VenvDir='$VenvDir'" - -# Deactivate any currently active virtual environment, but leave the -# deactivate function in place. -deactivate -nondestructive - -# Now set the environment variable VIRTUAL_ENV, used by many tools to determine -# that there is an activated venv. -$env:VIRTUAL_ENV = $VenvDir - -if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { - - Write-Verbose "Setting prompt to '$Prompt'" - - # Set the prompt to include the env name - # Make sure _OLD_VIRTUAL_PROMPT is global - function global:_OLD_VIRTUAL_PROMPT { "" } - Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT - New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt - - function global:prompt { - Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " - _OLD_VIRTUAL_PROMPT - } -} - -# Clear PYTHONHOME -if (Test-Path -Path Env:PYTHONHOME) { - Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME - Remove-Item -Path Env:PYTHONHOME -} - -# Add the venv to the PATH -Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH -$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/models/main_models/rt1/rt1_env/bin/activate b/models/main_models/rt1/rt1_env/bin/activate deleted file mode 100644 index 2fdaa7bfa..000000000 --- a/models/main_models/rt1/rt1_env/bin/activate +++ /dev/null @@ -1,66 +0,0 @@ -# This file must be used with "source bin/activate" *from bash* -# you cannot run it directly - -deactivate () { - # reset old environment variables - if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then - PATH="${_OLD_VIRTUAL_PATH:-}" - export PATH - unset _OLD_VIRTUAL_PATH - fi - if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then - PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" - export PYTHONHOME - unset _OLD_VIRTUAL_PYTHONHOME - fi - - # This should detect bash and zsh, which have a hash command that must - # be called to get it to forget past commands. Without forgetting - # past commands the $PATH changes we made may not be respected - if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then - hash -r 2> /dev/null - fi - - if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then - PS1="${_OLD_VIRTUAL_PS1:-}" - export PS1 - unset _OLD_VIRTUAL_PS1 - fi - - unset VIRTUAL_ENV - if [ ! "${1:-}" = "nondestructive" ] ; then - # Self destruct! - unset -f deactivate - fi -} - -# unset irrelevant variables -deactivate nondestructive - -VIRTUAL_ENV="/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" -export VIRTUAL_ENV - -_OLD_VIRTUAL_PATH="$PATH" -PATH="$VIRTUAL_ENV/bin:$PATH" -export PATH - -# unset PYTHONHOME if set -# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) -# could use `if (set -u; : $PYTHONHOME) ;` in bash -if [ -n "${PYTHONHOME:-}" ] ; then - _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" - unset PYTHONHOME -fi - -if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then - _OLD_VIRTUAL_PS1="${PS1:-}" - PS1="(rt1_env) ${PS1:-}" - export PS1 -fi - -# This should detect bash and zsh, which have a hash command that must -# be called to get it to forget past commands. Without forgetting -# past commands the $PATH changes we made may not be respected -if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then - hash -r 2> /dev/null -fi diff --git a/models/main_models/rt1/rt1_env/bin/activate.csh b/models/main_models/rt1/rt1_env/bin/activate.csh deleted file mode 100644 index af00fde95..000000000 --- a/models/main_models/rt1/rt1_env/bin/activate.csh +++ /dev/null @@ -1,25 +0,0 @@ -# This file must be used with "source bin/activate.csh" *from csh*. -# You cannot run it directly. -# Created by Davide Di Blasi . -# Ported to Python 3.3 venv by Andrew Svetlov - -alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate' - -# Unset irrelevant variables. -deactivate nondestructive - -setenv VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" - -set _OLD_VIRTUAL_PATH="$PATH" -setenv PATH "$VIRTUAL_ENV/bin:$PATH" - - -set _OLD_VIRTUAL_PROMPT="$prompt" - -if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then - set prompt = "(rt1_env) $prompt" -endif - -alias pydoc python -m pydoc - -rehash diff --git a/models/main_models/rt1/rt1_env/bin/activate.fish b/models/main_models/rt1/rt1_env/bin/activate.fish deleted file mode 100644 index 388919ed3..000000000 --- a/models/main_models/rt1/rt1_env/bin/activate.fish +++ /dev/null @@ -1,64 +0,0 @@ -# This file must be used with "source /bin/activate.fish" *from fish* -# (https://fishshell.com/); you cannot run it directly. - -function deactivate -d "Exit virtual environment and return to normal shell environment" - # reset old environment variables - if test -n "$_OLD_VIRTUAL_PATH" - set -gx PATH $_OLD_VIRTUAL_PATH - set -e _OLD_VIRTUAL_PATH - end - if test -n "$_OLD_VIRTUAL_PYTHONHOME" - set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME - set -e _OLD_VIRTUAL_PYTHONHOME - end - - if test -n "$_OLD_FISH_PROMPT_OVERRIDE" - functions -e fish_prompt - set -e _OLD_FISH_PROMPT_OVERRIDE - functions -c _old_fish_prompt fish_prompt - functions -e _old_fish_prompt - end - - set -e VIRTUAL_ENV - if test "$argv[1]" != "nondestructive" - # Self-destruct! - functions -e deactivate - end -end - -# Unset irrelevant variables. -deactivate nondestructive - -set -gx VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" - -set -gx _OLD_VIRTUAL_PATH $PATH -set -gx PATH "$VIRTUAL_ENV/bin" $PATH - -# Unset PYTHONHOME if set. -if set -q PYTHONHOME - set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME - set -e PYTHONHOME -end - -if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" - # fish uses a function instead of an env var to generate the prompt. - - # Save the current fish_prompt function as the function _old_fish_prompt. - functions -c fish_prompt _old_fish_prompt - - # With the original prompt function renamed, we can override with our own. - function fish_prompt - # Save the return status of the last command. - set -l old_status $status - - # Output the venv prompt; color taken from the blue of the Python logo. - printf "%s%s%s" (set_color 4B8BBE) "(rt1_env) " (set_color normal) - - # Restore the return status of the previous command. - echo "exit $old_status" | . - # Output the original/"old" prompt. - _old_fish_prompt - end - - set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" -end diff --git a/models/main_models/rt1/rt1_env/bin/ai2thor-xorg b/models/main_models/rt1/rt1_env/bin/ai2thor-xorg deleted file mode 100755 index 7bc6235a3..000000000 --- a/models/main_models/rt1/rt1_env/bin/ai2thor-xorg +++ /dev/null @@ -1,267 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 -import os -import sys -import time -import platform -import re -import shlex -import subprocess -import argparse -import signal - -# Turning off automatic black formatting for this script as it breaks quotes. -# fmt: off -from typing import List - -PID_FILE = "/var/run/ai2thor-xorg.pid" -CONFIG_FILE = "/tmp/ai2thor-xorg.conf" - -DEFAULT_HEIGHT = 768 -DEFAULT_WIDTH = 1024 - - -def process_alive(pid): - """ - Use kill(0) to determine if pid is alive - :param pid: process id - :rtype: bool - """ - try: - os.kill(pid, 0) - except OSError: - return False - - return True - - -def find_devices(excluded_device_ids): - devices = [] - id_counter = 0 - for r in pci_records(): - if r.get("Vendor", "") == "NVIDIA Corporation" and r["Class"] in [ - "VGA compatible controller", - "3D controller", - ]: - bus_id = "PCI:" + ":".join( - map(lambda x: str(int(x, 16)), re.split(r"[:\.]", r["Slot"])) - ) - - if id_counter not in excluded_device_ids: - devices.append(bus_id) - - id_counter += 1 - - if not devices: - print("Error: ai2thor-xorg requires at least one NVIDIA device") - sys.exit(1) - - return devices - -def active_display_bus_ids(): - # this determines whether a monitor is connected to the GPU - # if one is, the following Option is added for the Screen "UseDisplayDevice" "None" - command = "nvidia-smi --query-gpu=pci.bus_id,display_active --format=csv,noheader" - active_bus_ids = set() - result = subprocess.run(command, shell=True, stdout=subprocess.PIPE) - if result.returncode == 0: - for line in result.stdout.decode().strip().split("\n"): - nvidia_bus_id, display_status = re.split(r",\s?", line.strip()) - bus_id = "PCI:" + ":".join( - map(lambda x: str(int(x, 16)), re.split(r"[:\.]", nvidia_bus_id)[1:]) - ) - if display_status.lower() == "enabled": - active_bus_ids.add(bus_id) - - return active_bus_ids - -def pci_records(): - records = [] - command = shlex.split("lspci -vmm") - output = subprocess.check_output(command).decode() - - for devices in output.strip().split("\n\n"): - record = {} - records.append(record) - for row in devices.split("\n"): - key, value = row.split("\t") - record[key.split(":")[0]] = value - - return records - - -def read_pid(): - if os.path.isfile(PID_FILE): - with open(PID_FILE) as f: - return int(f.read()) - else: - return None - - -def start(display: str, excluded_device_ids: List[int], width: int, height: int): - pid = read_pid() - - if pid and process_alive(pid): - print("Error: ai2thor-xorg is already running with pid: %s" % pid) - sys.exit(1) - - with open(CONFIG_FILE, "w") as f: - f.write(generate_xorg_conf(excluded_device_ids, width=width, height=height)) - - log_file = "/var/log/ai2thor-xorg.%s.log" % display - error_log_file = "/var/log/ai2thor-xorg-error.%s.log" % display - command = shlex.split( - "Xorg -quiet -maxclients 1024 -noreset +extension GLX +extension RANDR +extension RENDER -logfile %s -config %s :%s" - % (log_file, CONFIG_FILE, display) - ) - - pid = None - with open(error_log_file, "w") as error_log_f: - proc = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=error_log_f) - pid = proc.pid - try: - proc.wait(timeout=0.25) - except subprocess.TimeoutExpired: - pass - - if pid and process_alive(pid): - with open(PID_FILE, "w") as f: - f.write(str(proc.pid)) - else: - print("Error: error with command '%s'" % " ".join(command)) - with open(error_log_file, "r") as f: - print(f.read()) - - -def print_config(excluded_device_ids: List[int], width: int, height: int): - print(generate_xorg_conf(excluded_device_ids, width=width, height=height)) - - -def stop(): - pid = read_pid() - if pid and process_alive(pid): - os.kill(pid, signal.SIGTERM) - - for i in range(10): - time.sleep(0.2) - if not process_alive(pid): - os.unlink(PID_FILE) - break - - -def generate_xorg_conf( - excluded_device_ids: List[int], width: int, height: int -): - devices = find_devices(excluded_device_ids) - active_display_devices = active_display_bus_ids() - - xorg_conf = [] - - device_section = """ -Section "Device" - Identifier "Device{device_id}" - Driver "nvidia" - VendorName "NVIDIA Corporation" - BusID "{bus_id}" -EndSection -""" - server_layout_section = """ -Section "ServerLayout" - Identifier "Layout0" - {screen_records} -EndSection -""" - screen_section = """ -Section "Screen" - Identifier "Screen{screen_id}" - Device "Device{device_id}" - DefaultDepth 24 - Option "AllowEmptyInitialConfiguration" "True" - Option "Interactive" "False" - {extra_options} - SubSection "Display" - Depth 24 - Virtual {width} {height} - EndSubSection -EndSection -""" - screen_records = [] - for i, bus_id in enumerate(devices): - extra_options = "" - if bus_id in active_display_devices: - # See https://github.com/allenai/ai2thor/pull/990 - # when a monitor is connected, this option must be used otherwise - # Xorg will fail to start - extra_options = 'Option "UseDisplayDevice" "None"' - xorg_conf.append(device_section.format(device_id=i, bus_id=bus_id)) - xorg_conf.append(screen_section.format(device_id=i, screen_id=i, width=width, height=height, extra_options=extra_options)) - screen_records.append( - 'Screen {screen_id} "Screen{screen_id}" 0 0'.format(screen_id=i) - ) - - xorg_conf.append( - server_layout_section.format(screen_records="\n ".join(screen_records)) - ) - - output = "\n".join(xorg_conf) - return output - - -# fmt: on - -if __name__ == "__main__": - if os.geteuid() != 0: - path = os.path.abspath(__file__) - print("Executing ai2thor-xorg with sudo") - args = ["--", path] + sys.argv[1:] - os.execvp("sudo", args) - - if platform.system() != "Linux": - print("Error: Can only run ai2thor-xorg on linux") - sys.exit(1) - - parser = argparse.ArgumentParser() - parser.add_argument( - "--exclude-device", - help="exclude a specific GPU device", - action="append", - type=int, - default=[], - ) - parser.add_argument( - "--width", - help="width of the screen to start (should be greater than the maximum" - f" width of any ai2thor instance you will start) [default: {DEFAULT_WIDTH}]", - type=int, - default=DEFAULT_WIDTH, - ) - parser.add_argument( - "--height", - help="height of the screen to start (should be greater than the maximum" - f" height of any ai2thor instance you will start) [default: {DEFAULT_HEIGHT}]", - type=int, - default=DEFAULT_HEIGHT, - ) - parser.add_argument( - "command", - help="command to be executed", - choices=["start", "stop", "print-config"], - ) - parser.add_argument( - "display", help="display to be used", nargs="?", type=int, default=0 - ) - args = parser.parse_args() - if args.command == "start": - start( - display=args.display, - excluded_device_ids=args.exclude_device, - height=args.height, - width=args.width, - ) - elif args.command == "stop": - stop() - elif args.command == "print-config": - print_config( - excluded_device_ids=args.exclude_device, - width=args.width, - height=args.height, - ) diff --git a/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx b/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx deleted file mode 100755 index 0294702e2..000000000 --- a/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from caffe2.python.onnx.bin.conversion import caffe2_to_onnx -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(caffe2_to_onnx()) diff --git a/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 b/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 deleted file mode 100755 index daed37802..000000000 --- a/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from caffe2.python.onnx.bin.conversion import onnx_to_caffe2 -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(onnx_to_caffe2()) diff --git a/models/main_models/rt1/rt1_env/bin/f2py b/models/main_models/rt1/rt1_env/bin/f2py deleted file mode 100755 index 6ae2c3109..000000000 --- a/models/main_models/rt1/rt1_env/bin/f2py +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from numpy.f2py.f2py2e import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/flask b/models/main_models/rt1/rt1_env/bin/flask deleted file mode 100755 index fa566a3ba..000000000 --- a/models/main_models/rt1/rt1_env/bin/flask +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from flask.cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/huggingface-cli b/models/main_models/rt1/rt1_env/bin/huggingface-cli deleted file mode 100755 index 5580d7dc9..000000000 --- a/models/main_models/rt1/rt1_env/bin/huggingface-cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from huggingface_hub.commands.huggingface_cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/imageio_download_bin b/models/main_models/rt1/rt1_env/bin/imageio_download_bin deleted file mode 100755 index 2e17ded5a..000000000 --- a/models/main_models/rt1/rt1_env/bin/imageio_download_bin +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from imageio.__main__ import download_bin_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(download_bin_main()) diff --git a/models/main_models/rt1/rt1_env/bin/imageio_remove_bin b/models/main_models/rt1/rt1_env/bin/imageio_remove_bin deleted file mode 100755 index bbbdac364..000000000 --- a/models/main_models/rt1/rt1_env/bin/imageio_remove_bin +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from imageio.__main__ import remove_bin_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(remove_bin_main()) diff --git a/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard b/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard deleted file mode 100755 index 47503b8c4..000000000 --- a/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.python.tools.import_pb_to_tensorboard import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/isympy b/models/main_models/rt1/rt1_env/bin/isympy deleted file mode 100755 index 8f709363b..000000000 --- a/models/main_models/rt1/rt1_env/bin/isympy +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from isympy import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/jp.py b/models/main_models/rt1/rt1_env/bin/jp.py deleted file mode 100755 index 2a3859f1f..000000000 --- a/models/main_models/rt1/rt1_env/bin/jp.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 - -import sys -import json -import argparse -from pprint import pformat - -import jmespath -from jmespath import exceptions - - -def main(): - parser = argparse.ArgumentParser() - parser.add_argument('expression') - parser.add_argument('-f', '--filename', - help=('The filename containing the input data. ' - 'If a filename is not given then data is ' - 'read from stdin.')) - parser.add_argument('--ast', action='store_true', - help=('Pretty print the AST, do not search the data.')) - args = parser.parse_args() - expression = args.expression - if args.ast: - # Only print the AST - expression = jmespath.compile(args.expression) - sys.stdout.write(pformat(expression.parsed)) - sys.stdout.write('\n') - return 0 - if args.filename: - with open(args.filename, 'r') as f: - data = json.load(f) - else: - data = sys.stdin.read() - data = json.loads(data) - try: - sys.stdout.write(json.dumps( - jmespath.search(expression, data), indent=4, ensure_ascii=False)) - sys.stdout.write('\n') - except exceptions.ArityError as e: - sys.stderr.write("invalid-arity: %s\n" % e) - return 1 - except exceptions.JMESPathTypeError as e: - sys.stderr.write("invalid-type: %s\n" % e) - return 1 - except exceptions.UnknownFunctionError as e: - sys.stderr.write("unknown-function: %s\n" % e) - return 1 - except exceptions.ParseError as e: - sys.stderr.write("syntax-error: %s\n" % e) - return 1 - - -if __name__ == '__main__': - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/lsm2bin b/models/main_models/rt1/rt1_env/bin/lsm2bin deleted file mode 100755 index a4b517af7..000000000 --- a/models/main_models/rt1/rt1_env/bin/lsm2bin +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile.lsm2bin import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/markdown-it b/models/main_models/rt1/rt1_env/bin/markdown-it deleted file mode 100755 index e58e8d1e4..000000000 --- a/models/main_models/rt1/rt1_env/bin/markdown-it +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from markdown_it.cli.parse import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/markdown_py b/models/main_models/rt1/rt1_env/bin/markdown_py deleted file mode 100755 index 8424ab33e..000000000 --- a/models/main_models/rt1/rt1_env/bin/markdown_py +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from markdown.__main__ import run -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(run()) diff --git a/models/main_models/rt1/rt1_env/bin/normalizer b/models/main_models/rt1/rt1_env/bin/normalizer deleted file mode 100755 index e3a575f79..000000000 --- a/models/main_models/rt1/rt1_env/bin/normalizer +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from charset_normalizer.cli import cli_detect -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(cli_detect()) diff --git a/models/main_models/rt1/rt1_env/bin/pip b/models/main_models/rt1/rt1_env/bin/pip deleted file mode 100755 index 95ae2f451..000000000 --- a/models/main_models/rt1/rt1_env/bin/pip +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pip._internal.cli.main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pip3 b/models/main_models/rt1/rt1_env/bin/pip3 deleted file mode 100755 index 95ae2f451..000000000 --- a/models/main_models/rt1/rt1_env/bin/pip3 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pip._internal.cli.main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pip3.9 b/models/main_models/rt1/rt1_env/bin/pip3.9 deleted file mode 100755 index 95ae2f451..000000000 --- a/models/main_models/rt1/rt1_env/bin/pip3.9 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pip._internal.cli.main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/portserver.py b/models/main_models/rt1/rt1_env/bin/portserver.py deleted file mode 100755 index 6cdc3c0f3..000000000 --- a/models/main_models/rt1/rt1_env/bin/portserver.py +++ /dev/null @@ -1,415 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 -# -# Copyright 2015 Google Inc. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -"""A server to hand out network ports to applications running on one host. - -Typical usage: - 1) Run one instance of this process on each of your unittest farm hosts. - 2) Set the PORTSERVER_ADDRESS environment variable in your test runner - environment to let the portpicker library know to use a port server - rather than attempt to find ports on its own. - -$ /path/to/portserver.py & -$ export PORTSERVER_ADDRESS=@unittest-portserver -$ # ... launch a bunch of unittest runners using portpicker ... -""" - -import argparse -import asyncio -import collections -import logging -import signal -import socket -import sys -import psutil -import subprocess -from datetime import datetime, timezone, timedelta - -log = None # Initialized to a logging.Logger by _configure_logging(). - -_PROTOS = [(socket.SOCK_STREAM, socket.IPPROTO_TCP), - (socket.SOCK_DGRAM, socket.IPPROTO_UDP)] - - -def _get_process_command_line(pid): - try: - return psutil.Process(pid).cmdline() - except psutil.NoSuchProcess: - return '' - - -def _get_process_start_time(pid): - try: - return psutil.Process(pid).create_time() - except psutil.NoSuchProcess: - return 0.0 - - -# TODO: Consider importing portpicker.bind() instead of duplicating the code. -def _bind(port, socket_type, socket_proto): - """Try to bind to a socket of the specified type, protocol, and port. - - For the port to be considered available, the kernel must support at least - one of (IPv6, IPv4), and the port must be available on each supported - family. - - Args: - port: The port number to bind to, or 0 to have the OS pick a free port. - socket_type: The type of the socket (ex: socket.SOCK_STREAM). - socket_proto: The protocol of the socket (ex: socket.IPPROTO_TCP). - - Returns: - The port number on success or None on failure. - """ - got_socket = False - for family in (socket.AF_INET6, socket.AF_INET): - try: - sock = socket.socket(family, socket_type, socket_proto) - got_socket = True - except socket.error: - continue - try: - sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - sock.bind(('', port)) - if socket_type == socket.SOCK_STREAM: - sock.listen(1) - port = sock.getsockname()[1] - except socket.error: - return None - finally: - sock.close() - return port if got_socket else None - - -def _is_port_free(port): - """Check if specified port is free. - - Args: - port: integer, port to check - Returns: - boolean, whether it is free to use for both TCP and UDP - """ - return _bind(port, *_PROTOS[0]) and _bind(port, *_PROTOS[1]) - - -def _should_allocate_port(pid): - """Determine if we should allocate a port for use by the given process id.""" - if pid <= 0: - log.info('Not allocating a port to invalid pid') - return False - if pid == 1: - # The client probably meant to send us its parent pid but - # had been reparented to init. - log.info('Not allocating a port to init.') - return False - - if not psutil.pid_exists(pid): - log.info('Not allocating a port to a non-existent process') - return False - return True - - -async def _start_windows_server(client_connected_cb, path): - """Start the server on Windows using named pipes.""" - def protocol_factory(): - stream_reader = asyncio.StreamReader() - stream_reader_protocol = asyncio.StreamReaderProtocol( - stream_reader, client_connected_cb) - return stream_reader_protocol - - loop = asyncio.get_event_loop() - server, *_ = await loop.start_serving_pipe(protocol_factory, address=path) - - return server - - -class _PortInfo(object): - """Container class for information about a given port assignment. - - Attributes: - port: integer port number - pid: integer process id or 0 if unassigned. - start_time: Time in seconds since the epoch that the process started. - """ - - __slots__ = ('port', 'pid', 'start_time') - - def __init__(self, port): - self.port = port - self.pid = 0 - self.start_time = 0.0 - - -class _PortPool(object): - """Manage available ports for processes. - - Ports are reclaimed when the reserving process exits and the reserved port - is no longer in use. Only ports which are free for both TCP and UDP will be - handed out. It is easier to not differentiate between protocols. - - The pool must be pre-seeded with add_port_to_free_pool() calls - after which get_port_for_process() will allocate and reclaim ports. - The len() of a _PortPool returns the total number of ports being managed. - - Attributes: - ports_checked_for_last_request: The number of ports examined in order to - return from the most recent get_port_for_process() request. A high - number here likely means the number of available ports with no active - process using them is getting low. - """ - - def __init__(self): - self._port_queue = collections.deque() - self.ports_checked_for_last_request = 0 - - def num_ports(self): - return len(self._port_queue) - - def get_port_for_process(self, pid): - """Allocates and returns port for pid or 0 if none could be allocated.""" - if not self._port_queue: - raise RuntimeError('No ports being managed.') - - # Avoid an infinite loop if all ports are currently assigned. - check_count = 0 - max_ports_to_test = len(self._port_queue) - while check_count < max_ports_to_test: - # Get the next candidate port and move it to the back of the queue. - candidate = self._port_queue.pop() - self._port_queue.appendleft(candidate) - check_count += 1 - if (candidate.start_time == 0.0 or - candidate.start_time != _get_process_start_time(candidate.pid)): - if _is_port_free(candidate.port): - candidate.pid = pid - candidate.start_time = _get_process_start_time(pid) - if not candidate.start_time: - log.info("Can't read start time for pid %d.", pid) - self.ports_checked_for_last_request = check_count - return candidate.port - else: - log.info( - 'Port %d unexpectedly in use, last owning pid %d.', - candidate.port, candidate.pid) - - log.info('All ports in use.') - self.ports_checked_for_last_request = check_count - return 0 - - def add_port_to_free_pool(self, port): - """Add a new port to the free pool for allocation.""" - if port < 1 or port > 65535: - raise ValueError( - 'Port must be in the [1, 65535] range, not %d.' % port) - port_info = _PortInfo(port=port) - self._port_queue.append(port_info) - - -class _PortServerRequestHandler(object): - """A class to handle port allocation and status requests. - - Allocates ports to process ids via the dead simple port server protocol - when the handle_port_request asyncio.coroutine handler has been registered. - Statistics can be logged using the dump_stats method. - """ - - def __init__(self, ports_to_serve): - """Initialize a new port server. - - Args: - ports_to_serve: A sequence of unique port numbers to test and offer - up to clients. - """ - self._port_pool = _PortPool() - self._total_allocations = 0 - self._denied_allocations = 0 - self._client_request_errors = 0 - for port in ports_to_serve: - self._port_pool.add_port_to_free_pool(port) - - async def handle_port_request(self, reader, writer): - client_data = await reader.read(100) - self._handle_port_request(client_data, writer) - writer.close() - - def _handle_port_request(self, client_data, writer): - """Given a port request body, parse it and respond appropriately. - - Args: - client_data: The request bytes from the client. - writer: The asyncio Writer for the response to be written to. - """ - try: - if len(client_data) > 20: - raise ValueError('More than 20 characters in "pid".') - pid = int(client_data) - except ValueError as error: - self._client_request_errors += 1 - log.warning('Could not parse request: %s', error) - return - - log.info('Request on behalf of pid %d.', pid) - log.info('cmdline: %s', _get_process_command_line(pid)) - - if not _should_allocate_port(pid): - self._denied_allocations += 1 - return - - port = self._port_pool.get_port_for_process(pid) - if port > 0: - self._total_allocations += 1 - writer.write('{:d}\n'.format(port).encode('utf-8')) - log.debug('Allocated port %d to pid %d', port, pid) - else: - self._denied_allocations += 1 - - def dump_stats(self): - """Logs statistics of our operation.""" - log.info('Dumping statistics:') - stats = [] - stats.append( - 'client-request-errors {}'.format(self._client_request_errors)) - stats.append('denied-allocations {}'.format(self._denied_allocations)) - stats.append('num-ports-managed {}'.format(self._port_pool.num_ports())) - stats.append('num-ports-checked-for-last-request {}'.format( - self._port_pool.ports_checked_for_last_request)) - stats.append('total-allocations {}'.format(self._total_allocations)) - for stat in stats: - log.info(stat) - - -def _parse_command_line(): - """Configure and parse our command line flags.""" - parser = argparse.ArgumentParser() - parser.add_argument( - '--portserver_static_pool', - type=str, - default='15000-24999', - help='Comma separated N-P Range(s) of ports to manage (inclusive).') - parser.add_argument( - '--portserver_address', - '--portserver_unix_socket_address', # Alias to be backward compatible - type=str, - default='@unittest-portserver', - help='Address of AF_UNIX socket on which to listen on Unix (first @ is ' - 'a NUL) or the name of the pipe on Windows (first @ is the ' - r'\\.\pipe\ prefix).') - parser.add_argument('--verbose', - action='store_true', - default=False, - help='Enable verbose messages.') - parser.add_argument('--debug', - action='store_true', - default=False, - help='Enable full debug messages.') - return parser.parse_args(sys.argv[1:]) - - -def _parse_port_ranges(pool_str): - """Given a 'N-P,X-Y' description of port ranges, return a set of ints.""" - ports = set() - for range_str in pool_str.split(','): - try: - a, b = range_str.split('-', 1) - start, end = int(a), int(b) - except ValueError: - log.error('Ignoring unparsable port range %r.', range_str) - continue - if start < 1 or end > 65535: - log.error('Ignoring out of bounds port range %r.', range_str) - continue - ports.update(set(range(start, end + 1))) - return ports - - -def _configure_logging(verbose=False, debug=False): - """Configure the log global, message format, and verbosity settings.""" - overall_level = logging.DEBUG if debug else logging.INFO - logging.basicConfig( - format=('{levelname[0]}{asctime}.{msecs:03.0f} {thread} ' - '{filename}:{lineno}] {message}'), - datefmt='%m%d %H:%M:%S', - style='{', - level=overall_level) - global log - log = logging.getLogger('portserver') - # The verbosity controls our loggers logging level, not the global - # one above. This avoids debug messages from libraries such as asyncio. - log.setLevel(logging.DEBUG if verbose else overall_level) - - -def main(): - config = _parse_command_line() - if config.debug: - # Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access - asyncio.tasks._DEBUG = True - _configure_logging(verbose=config.verbose, debug=config.debug) - ports_to_serve = _parse_port_ranges(config.portserver_static_pool) - if not ports_to_serve: - log.error('No ports. Invalid port ranges in --portserver_static_pool?') - sys.exit(1) - - request_handler = _PortServerRequestHandler(ports_to_serve) - - if sys.platform == 'win32': - asyncio.set_event_loop(asyncio.ProactorEventLoop()) - - event_loop = asyncio.get_event_loop() - - if sys.platform == 'win32': - # On Windows, we need to periodically pause the loop to allow the user - # to send a break signal (e.g. ctrl+c) - def listen_for_signal(): - event_loop.call_later(0.5, listen_for_signal) - - event_loop.call_later(0.5, listen_for_signal) - - coro = _start_windows_server( - request_handler.handle_port_request, - path=config.portserver_address.replace('@', '\\\\.\\pipe\\', 1)) - else: - event_loop.add_signal_handler( - signal.SIGUSR1, request_handler.dump_stats) # pylint: disable=no-member - - old_py_loop = {'loop': event_loop} if sys.version_info < (3, 10) else {} - coro = asyncio.start_unix_server( - request_handler.handle_port_request, - path=config.portserver_address.replace('@', '\0', 1), - **old_py_loop) - - server_address = config.portserver_address - - server = event_loop.run_until_complete(coro) - log.info('Serving on %s', server_address) - try: - event_loop.run_forever() - except KeyboardInterrupt: - log.info('Stopping due to ^C.') - - server.close() - - if sys.platform != 'win32': - # PipeServer doesn't have a wait_closed() function - event_loop.run_until_complete(server.wait_closed()) - event_loop.remove_signal_handler(signal.SIGUSR1) # pylint: disable=no-member - - event_loop.close() - request_handler.dump_stats() - log.info('Goodbye.') - - -if __name__ == '__main__': - main() diff --git a/models/main_models/rt1/rt1_env/bin/progressbar b/models/main_models/rt1/rt1_env/bin/progressbar deleted file mode 100755 index 1136ebc7c..000000000 --- a/models/main_models/rt1/rt1_env/bin/progressbar +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from progressbar.__main__ import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pygmentize b/models/main_models/rt1/rt1_env/bin/pygmentize deleted file mode 100755 index 623ccdf50..000000000 --- a/models/main_models/rt1/rt1_env/bin/pygmentize +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pygments.cmdline import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/python b/models/main_models/rt1/rt1_env/bin/python deleted file mode 120000 index b8a0adbbb..000000000 --- a/models/main_models/rt1/rt1_env/bin/python +++ /dev/null @@ -1 +0,0 @@ -python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/python3 b/models/main_models/rt1/rt1_env/bin/python3 deleted file mode 120000 index ae65fdaa1..000000000 --- a/models/main_models/rt1/rt1_env/bin/python3 +++ /dev/null @@ -1 +0,0 @@ -/usr/bin/python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/python3.9 b/models/main_models/rt1/rt1_env/bin/python3.9 deleted file mode 120000 index b8a0adbbb..000000000 --- a/models/main_models/rt1/rt1_env/bin/python3.9 +++ /dev/null @@ -1 +0,0 @@ -python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/pythoni b/models/main_models/rt1/rt1_env/bin/pythoni deleted file mode 100755 index 2d650f825..000000000 --- a/models/main_models/rt1/rt1_env/bin/pythoni +++ /dev/null @@ -1,36 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 - -# Copyright 2000-2002 Michael Hudson mwh@python.net -# -# All Rights Reserved -# -# -# Permission to use, copy, modify, and distribute this software and -# its documentation for any purpose is hereby granted without fee, -# provided that the above copyright notice appear in all copies and -# that both that copyright notice and this permission notice appear in -# supporting documentation. -# -# THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO -# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY -# AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, -# INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER -# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF -# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN -# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import locale, pdb, sys -# I forget exactly why this is necessary: -try: - locale.setlocale(locale.LC_ALL, '') -except locale.Error: - pass # oh well - - -from pyrepl.python_reader import main -from pyrepl import cmdrepl - -# whizzy feature: graft pyrepl support onto pdb -#pdb.Pdb = cmdrepl.replize(pdb.Pdb, 1) - -main(use_pygame_console=('pg' in sys.argv)) diff --git a/models/main_models/rt1/rt1_env/bin/pythoni1 b/models/main_models/rt1/rt1_env/bin/pythoni1 deleted file mode 100755 index f0a75c79d..000000000 --- a/models/main_models/rt1/rt1_env/bin/pythoni1 +++ /dev/null @@ -1,17 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 -""" This is an alternative to pythoni which tries to look like the -CPython prompt as much as possible, with the exception of allowing -multiline input and multiline history entries. -""" - -import os, sys -from pyrepl import readline -from pyrepl.simple_interact import run_multiline_interactive_console - -sys.modules['readline'] = readline - -if os.getenv('PYTHONSTARTUP'): - execfile(os.getenv('PYTHONSTARTUP')) - -print 'Python', sys.version -run_multiline_interactive_console() diff --git a/models/main_models/rt1/rt1_env/bin/reverb_server b/models/main_models/rt1/rt1_env/bin/reverb_server deleted file mode 100755 index b9d8a78f5..000000000 --- a/models/main_models/rt1/rt1_env/bin/reverb_server +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from reverb.server_executable.server_main import app_run_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(app_run_main()) diff --git a/models/main_models/rt1/rt1_env/bin/saved_model_cli b/models/main_models/rt1/rt1_env/bin/saved_model_cli deleted file mode 100755 index 44f84317c..000000000 --- a/models/main_models/rt1/rt1_env/bin/saved_model_cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.python.tools.saved_model_cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tensorboard b/models/main_models/rt1/rt1_env/bin/tensorboard deleted file mode 100755 index 2ee3b3204..000000000 --- a/models/main_models/rt1/rt1_env/bin/tensorboard +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorboard.main import run_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(run_main()) diff --git a/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 b/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 deleted file mode 100755 index aee84bff1..000000000 --- a/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.tools.compatibility.tf_upgrade_v2_main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tfds b/models/main_models/rt1/rt1_env/bin/tfds deleted file mode 100755 index 0f5636bc8..000000000 --- a/models/main_models/rt1/rt1_env/bin/tfds +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow_datasets.scripts.cli.main import launch_cli -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(launch_cli()) diff --git a/models/main_models/rt1/rt1_env/bin/tflite_convert b/models/main_models/rt1/rt1_env/bin/tflite_convert deleted file mode 100755 index 0ebb370c7..000000000 --- a/models/main_models/rt1/rt1_env/bin/tflite_convert +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.lite.python.tflite_convert import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tiff2fsspec b/models/main_models/rt1/rt1_env/bin/tiff2fsspec deleted file mode 100755 index 72322f48d..000000000 --- a/models/main_models/rt1/rt1_env/bin/tiff2fsspec +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile.tiff2fsspec import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tiffcomment b/models/main_models/rt1/rt1_env/bin/tiffcomment deleted file mode 100755 index 81e89dd82..000000000 --- a/models/main_models/rt1/rt1_env/bin/tiffcomment +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile.tiffcomment import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tifffile b/models/main_models/rt1/rt1_env/bin/tifffile deleted file mode 100755 index 024aaecb3..000000000 --- a/models/main_models/rt1/rt1_env/bin/tifffile +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/toco b/models/main_models/rt1/rt1_env/bin/toco deleted file mode 100755 index 0ebb370c7..000000000 --- a/models/main_models/rt1/rt1_env/bin/toco +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.lite.python.tflite_convert import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/toco_from_protos b/models/main_models/rt1/rt1_env/bin/toco_from_protos deleted file mode 100755 index 4a0931477..000000000 --- a/models/main_models/rt1/rt1_env/bin/toco_from_protos +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.lite.toco.python.toco_from_protos import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/torchrun b/models/main_models/rt1/rt1_env/bin/torchrun deleted file mode 100755 index bbd4216d0..000000000 --- a/models/main_models/rt1/rt1_env/bin/torchrun +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from torch.distributed.run import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tqdm b/models/main_models/rt1/rt1_env/bin/tqdm deleted file mode 100755 index 52aa9b22d..000000000 --- a/models/main_models/rt1/rt1_env/bin/tqdm +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tqdm.cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/transformers-cli b/models/main_models/rt1/rt1_env/bin/transformers-cli deleted file mode 100755 index 3cb3dba5c..000000000 --- a/models/main_models/rt1/rt1_env/bin/transformers-cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from transformers.commands.transformers_cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tree-cli b/models/main_models/rt1/rt1_env/bin/tree-cli deleted file mode 100755 index 822fcbe27..000000000 --- a/models/main_models/rt1/rt1_env/bin/tree-cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from Tree.cli import create_tree -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(create_tree()) diff --git a/models/main_models/rt1/rt1_env/bin/wandb b/models/main_models/rt1/rt1_env/bin/wandb deleted file mode 100755 index ad3846609..000000000 --- a/models/main_models/rt1/rt1_env/bin/wandb +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from wandb.cli.cli import cli -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(cli()) diff --git a/models/main_models/rt1/rt1_env/bin/wb b/models/main_models/rt1/rt1_env/bin/wb deleted file mode 100755 index ad3846609..000000000 --- a/models/main_models/rt1/rt1_env/bin/wb +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from wandb.cli.cli import cli -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(cli()) diff --git a/models/main_models/rt1/rt1_env/bin/wheel b/models/main_models/rt1/rt1_env/bin/wheel deleted file mode 100755 index 47a52e82e..000000000 --- a/models/main_models/rt1/rt1_env/bin/wheel +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from wheel.cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto deleted file mode 100644 index 39512921e..000000000 --- a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto +++ /dev/null @@ -1,77 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "reverb/cc/schema.proto"; -import "tensorflow/core/protobuf/struct.proto"; - -// Configs for reconstructing a distribution to its initial state. - -// Next ID: 11. -message PriorityTableCheckpoint { - // Name of the table. - string table_name = 1; - - // Maximum number of items in the table. - // If an insert would result in this value getting exceeded, `remover` is used - // to select an item to remove before proceeding with the insert. - int64 max_size = 6; - - // The maximum number of times an item can be sampled before being removed. - int32 max_times_sampled = 7; - - // Items in the table ordered by `inserted_at` (asc). - // When loading a checkpoint the items should be added in the same order so - // position based item selectors (e.g fifo) are reconstructed correctly. - // - // *NOTE*: This field is deprecated; instead, a separate record file is - // written with PrioritizedItem records for checkpointing (in the same - // order as described here). - repeated PrioritizedItem deprecated_items = 2 [deprecated = true]; - - // Checkpoint of the associated rate limiter. - RateLimiterCheckpoint rate_limiter = 3; - - // Options for constructing new samplers and removers of the correct type. - // Note that this does not include the state that they currently hold as it - // will be reproduced using the order of `items. - KeyDistributionOptions sampler = 4; - KeyDistributionOptions remover = 5; - - // The total number of episodes that were at some point referenced by items - // in the table but have since been removed. - int64 num_deleted_episodes = 8; - - // Optional data signature for tensors stored in the table. - tensorflow.StructuredValue signature = 9; - - // Number of unique items sampled from the table since the last reset. - int64 num_unique_samples = 10; -} - -message RateLimiterCheckpoint { - reserved 1; // Deprecated field `name`. - - // The average number of times each item should be sampled during its - // lifetime. - double samples_per_insert = 2; - - // The minimum and maximum values the cursor is allowed to reach. The cursor - // value is calculated as `insert_count * samples_per_insert - - // sample_count`. If the value would go beyond these limits then the call is - // blocked until it can proceed without violating the constraints. - double min_diff = 3; - double max_diff = 4; - - // The minimum number of inserts required before any sample operation. - int64 min_size_to_sample = 5; - - // The total number of samples that occurred before the checkpoint. - int64 sample_count = 6; - - // The total number of inserts that occurred before the checkpoint. - int64 insert_count = 7; - - // The total number of deletes that occurred before the checkpoint. - int64 delete_count = 8; -} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto deleted file mode 100644 index 3428db5a5..000000000 --- a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto +++ /dev/null @@ -1,123 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "tensorflow/core/protobuf/struct.proto"; - -message PatternNode { - // Index of the source column in the flattened step structure. - int32 flat_source_index = 1; - - // Slicing of the source column relative to the most recent step. - // - // These fields mimics the behavior of `slice` in Python. That is: - // - // * x[-1:] => (start=-1, stop=null) - // * x[-2] => (start=null, stop=-2) - // * x[-3:-1] => (start=-3, stop=-1) - // * x[-3:-1:2] => (start=-3, stop=-1, step=2) - // - // Furthermore, the following requirements applies: - // - // * Slices with undefined `start` (e.g. x[:-2]) are not supported. - // * For slices, `start` must be < 0 and `stop` must be <= 0. - // * `step` must be > 0 when defined. - // - oneof start_or_none { - int32 start = 2; - } - oneof stop_or_none { - int32 stop = 3; - } - oneof step_or_none { - int32 step = 4; - } -} - -message Condition { - // Given int32 `left`: `left % mod == eq`. - message ModuloEq { - int32 mod = 1; - int32 eq = 2; - } - - oneof left { - // The index of the most recent step within the episode. - bool step_index = 1; - - // The number of steps since the pattern was most recently applied. - bool steps_since_applied = 2; - - // The number of steps currently held by the buffer. - bool buffer_length = 3; - - // Set to 1 when `EndEpisode` is called, else 0. - bool is_end_episode = 4; - - // Extract scalar integer value from a column in the most recent step. If - // the column is not present in the data or it isn't a scalar of a supported - // type then the condition will return false. - // - // All integer types are casted to int32 and bool is converted to 1 if true - // and 0 if false. - // - int32 flat_source_index = 9; - } - - // TODO(b/205278205): Remove le and just use inverse + ge instead. - oneof cmp { - // `left == eq`. - int32 eq = 5; - - // `left >= ge`. - int32 ge = 6; - - // `left % mod_eq.mod == mod_eq.eq`. - ModuloEq mod_eq = 7; - } - - // Whether the condition result should be inversed. - bool inverse = 8; -} - -message Priority { - // Priority function that always return the same value. - message ConstantPriorityFn { - // Value to be returned by the priority function. - double value = 1; - } - - // Priority function that computes the trajectory TD Error using the per-step - // TD Error. See details of the TD Error in - // https://openreview.net/pdf?id=r1lyTjAqYX. - message TDError { - // Weight for the max priority in the TD Error computation. - double max_priority_weight = 1; - // Index of the field in the input step that contais the per-step TD Error. - int32 flat_source_index = 2; - } - - oneof priority_fn { - ConstantPriorityFn constant_fn = 1; - TDError td_error = 2; - } -} - -message StructuredWriterConfig { - // Flattened output structure. - repeated PatternNode flat = 1; - - // Serialised structure of the pattern. All leaf nodes must be None. If empty - // then pattern will be treated as a flat list. - tensorflow.StructuredValue pattern_structure = 2; - - // The table that generated trajectories will be inserted into. - string table = 3; - - // The priority assigned to all trajectories generated by this config. - Priority priority = 4; - - // Conditions which must be fulfilled for the configuration to be applied at - // the current step. - repeated Condition conditions = 5; -} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto deleted file mode 100644 index a14a6ce56..000000000 --- a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto +++ /dev/null @@ -1,10 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "reverb/cc/checkpointing/checkpoint.proto"; - -message ReverbServerConfig { - repeated PriorityTableCheckpoint tables = 1; - int32 port = 2; -} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto deleted file mode 100644 index 3c37454c3..000000000 --- a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto +++ /dev/null @@ -1,289 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "google/protobuf/timestamp.proto"; -import "tensorflow/core/framework/tensor.proto"; -import "tensorflow/core/protobuf/struct.proto"; - -// The actual data is stored in chunks. The data can be arbitrary tensors. We do -// not interpret the bytes data of the tensors on the server side. It is up to -// the client to compress the bytes blob within the tensors. -message ChunkData { - // Unique identifier of the chunk. - uint64 chunk_key = 1; - - // The timesteps within the episode that the chunk covers. - SequenceRange sequence_range = 2; - - // Actual tensor data. - message Data { - repeated tensorflow.TensorProto tensors = 1; - } - Data data = 5 [lazy = true]; - - // Number of tensors in the data field. Set explicitly so that Reverb server - // can check it without accessing lazy data field (which is expensive to - // parse). - int32 data_tensors_len = 6; - - // Size of the tensors in `data` before compression. - int64 data_uncompressed_size = 7; - - // True if delta encoding has been applied before compressing data. - bool delta_encoded = 4; - - // Deprecated December 2020 and retained to provide backward - // compatibility with checkpoints created before this point. - repeated tensorflow.TensorProto deprecated_data = 3 [deprecated = true]; -} - -// A range that specifies which items to slice out from a sequence of chunks. -// The length of all chunks must at least be `offset`+`length`. -message SliceRange { - // Offset where the slice should start. - int32 offset = 1; - - // Length of the slice. Can span multiple chunks. - int32 length = 2; -} - -message SequenceRange { - // Globally unique identifier of the episode the sequence belongs to. - uint64 episode_id = 1; - - // Index within the episode of the first timestep covered by the range. - int32 start = 2; - - // Index within the episode of the last timestep covered by the range. - // Must be >= start_index. - int32 end = 3; - - // If set then at least one step is missing from the data. The number of steps - // (i.e batch size) present in the data is unknown and thus must be manually - // checked. However, the `start` and `end` step is guaranteed to be at first - // and last position in the data. - bool sparse = 4; -} - -message FlatTrajectory { - message ChunkSlice { - // Unique identifier of the ChunkData which owns the compressed data. - uint64 chunk_key = 1; - - // Index of the first element in the chunk to include. - int32 offset = 2; - - // Number of elements from the chunk to include. - int32 length = 3; - - // Tensor index of the tensor within the chunk. - int32 index = 4; - } - - message Column { - // Chunk slices to concat. - repeated ChunkSlice chunk_slices = 1; - - // If true then the batch dim (must be 1) is emitted when unpacked. - // Requires that column is made up of exactly one ChunkSlice of length 1. - bool squeeze = 2; - } - - // Flattened columns of the trajectory. - repeated Column columns = 1; -} - -// A prioritized item is part of a table and references a chunk of -// data. Sampling happens based on the priority of items. -// -// Next ID: 9. -// LINT.IfChange -message PrioritizedItem { - // Unique identifier of this item. - uint64 key = 1; - - // Priority table that the item belongs to. - string table = 2; - - // Priority used for sampling. - double priority = 5; - - // The number of times the item has been sampled. - int32 times_sampled = 6; - - // The time when the item was first inserted. - google.protobuf.Timestamp inserted_at = 7; - - // Flattened representation of item's trajectory. - FlatTrajectory flat_trajectory = 8; - - // Deprecated January 2021 and retained to provide backward compatibility - // with checkpoints created before this point. - repeated uint64 deprecated_chunk_keys = 3 [deprecated = true]; - SliceRange deprecated_sequence_range = 4 [deprecated = true]; -} -// LINT.ThenChange(reverb_service_impl.cc) - -// Used for updating an existing PrioritizedItem. -message KeyWithPriority { - // Identifier of the PrioritizedItem. - uint64 key = 1; - - // Priority used for sampling. - double priority = 2; -} - -message SampleInfo { - // Item from that was sampled from the table. - PrioritizedItem item = 1; - - // Probability that this item had at sampling time. Useful for importance - // sampling. - double probability = 2; - - // Number of items in the table at the time of the sample operation. - int64 table_size = 3; - - // Whether the sample was delayed due to rate limiting of the sampler. - bool rate_limited = 4; -} - -// LINT.IfChange -// Metadata about the table, including (optional) data signature. -// -// These fields correspond to initialization arguments of the -// `Table` class, unless noted otherwise. -// -// Next ID: 13. -message TableInfo { - // Table's name. - string name = 8; - - // Sampler and remover metadata. - KeyDistributionOptions sampler_options = 1; - KeyDistributionOptions remover_options = 2; - - // Max size of the table. - int64 max_size = 3; - - // Max number of times an element can be sampled before being - // removed. - int32 max_times_sampled = 4; - - // How data read/write is rate limited. - RateLimiterInfo rate_limiter_info = 5; - - // Optional data signature for tensors stored in the table. Note - // that this data type is more flexible than we use. For example, - // we only store tensors (TensorSpecProto, TypeSpecProto) and not - // any special data types (no NoneValue or other special fixed values). - tensorflow.StructuredValue signature = 6; - - // Current size of table. - int64 current_size = 7; - - // Number of episodes referenced by the items in the table. - int64 num_episodes = 9; - - // Number of episodes once referenced by items in the table but no longer is. - // The total number of episodes thus is `num_episodes + num_deleted_episodes`. - int64 num_deleted_episodes = 10; - - // Number of unique items sampled from the table since the last reset. - int64 num_unique_samples = 11; - - // Table worker execution time distribution. - TableWorkerTime table_worker_time = 12; -} -// LINT.ThenChange(../py/reverb/reverb_types.py) - -message RateLimiterCallStats { - // The total number of completed calls. - int64 completed = 2; - - reserved 1, 3, 4, 5; -} - -message RateLimiterInfo { - // The average number of times each item should be sampled during its - // lifetime. - double samples_per_insert = 1; - - // The minimum and maximum values the cursor is allowed to reach. The cursor - // value is calculated as `insert_count * samples_per_insert - - // sample_count`. If the value would go beyond these limits then the call is - // blocked until it can proceed without violating the constraints. - double min_diff = 2; - double max_diff = 3; - - // The minimum number of inserts required before any sample operation. - int64 min_size_to_sample = 4; - - // Stats regarding the limiting of insert calls. - RateLimiterCallStats insert_stats = 5; - - // Stats regarding the limiting of sample calls. - RateLimiterCallStats sample_stats = 6; -} - -message TableWorkerTime { - // Cumulative time the table worker is performing general work. - int64 running_ms = 1; - - // Cumulative time the table worker is actively processing sampling requests. - int64 sampling_ms = 2; - - // Cumulative time the table worker is actively processing insert requests. - int64 inserting_ms = 3; - - // Cumulative time the table worker is sleeping as there is no work to do - // (there are no pending insert/sample requests to process). - int64 sleeping_ms = 4; - - // Cumulative time the table worker is blocked waiting for sampling requests - // There are pending insert requests which are blocked by the rate limiter, - // while there are no sampling requests which could unblock inserts. - // The system can't make further progress and the worker is put to sleep until - // sample request arives. - int64 waiting_for_sampling_ms = 5; - - // Cumulative time the table worker is blocked waiting for insert requests - // There are pending sample requests which are blocked by the rate - // limiter, while there are no insert requests which could unblock sampling. - // The system can't make further progress and the worker is put to sleep until - // insert request arives. - int64 waiting_for_inserts_ms = 6; -} - -// Metadata about sampler or remover. Describes its configuration. -message KeyDistributionOptions { - message Prioritized { - double priority_exponent = 1; - } - - message Heap { - bool min_heap = 1; - } - - oneof distribution { - bool fifo = 1; - bool uniform = 2; - Prioritized prioritized = 3; - Heap heap = 4; - bool lifo = 6; - } - reserved 5; - bool is_deterministic = 7; -} - -// Uint128 representation. Can be used for unique identifiers. -message Uint128 { - uint64 high = 1; - uint64 low = 2; -} - -// Representation of a timeout. A value < 0 means never time out. -message Timeout { - int64 milliseconds = 1; -} diff --git a/models/main_models/rt1/rt1_env/lib64 b/models/main_models/rt1/rt1_env/lib64 deleted file mode 120000 index 7951405f8..000000000 --- a/models/main_models/rt1/rt1_env/lib64 +++ /dev/null @@ -1 +0,0 @@ -lib \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/pyvenv.cfg b/models/main_models/rt1/rt1_env/pyvenv.cfg deleted file mode 100644 index 1997c5b53..000000000 --- a/models/main_models/rt1/rt1_env/pyvenv.cfg +++ /dev/null @@ -1,3 +0,0 @@ -home = /usr/bin -include-system-site-packages = false -version = 3.9.16 diff --git a/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 b/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 deleted file mode 100644 index 0ff966158..000000000 --- a/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 +++ /dev/null @@ -1,188 +0,0 @@ -'\" -*- coding: us-ascii -*- -.if \n(.g .ds T< \\FC -.if \n(.g .ds T> \\F[\n[.fam]] -.de URL -\\$2 \(la\\$1\(ra\\$3 -.. -.if \n(.g .mso www.tmac -.TH isympy 1 2007-10-8 "" "" -.SH NAME -isympy \- interactive shell for SymPy -.SH SYNOPSIS -'nh -.fi -.ad l -\fBisympy\fR \kx -.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) -'in \n(.iu+\nxu -[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [ --- | PYTHONOPTIONS] -'in \n(.iu-\nxu -.ad b -'hy -'nh -.fi -.ad l -\fBisympy\fR \kx -.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) -'in \n(.iu+\nxu -[ -{\fB-h\fR | \fB--help\fR} -| -{\fB-v\fR | \fB--version\fR} -] -'in \n(.iu-\nxu -.ad b -'hy -.SH DESCRIPTION -isympy is a Python shell for SymPy. It is just a normal python shell -(ipython shell if you have the ipython package installed) that executes -the following commands so that you don't have to: -.PP -.nf -\*(T< ->>> from __future__ import division ->>> from sympy import * ->>> x, y, z = symbols("x,y,z") ->>> k, m, n = symbols("k,m,n", integer=True) - \*(T> -.fi -.PP -So starting isympy is equivalent to starting python (or ipython) and -executing the above commands by hand. It is intended for easy and quick -experimentation with SymPy. For more complicated programs, it is recommended -to write a script and import things explicitly (using the "from sympy -import sin, log, Symbol, ..." idiom). -.SH OPTIONS -.TP -\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR -Use the specified shell (python or ipython) as -console backend instead of the default one (ipython -if present or python otherwise). - -Example: isympy -c python - -\fISHELL\fR could be either -\&'ipython' or 'python' -.TP -\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR -Setup pretty printing in SymPy. By default, the most pretty, unicode -printing is enabled (if the terminal supports it). You can use less -pretty ASCII printing instead or no pretty printing at all. - -Example: isympy -p no - -\fIENCODING\fR must be one of 'unicode', -\&'ascii' or 'no'. -.TP -\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR -Setup the ground types for the polys. By default, gmpy ground types -are used if gmpy2 or gmpy is installed, otherwise it falls back to python -ground types, which are a little bit slower. You can manually -choose python ground types even if gmpy is installed (e.g., for testing purposes). - -Note that sympy ground types are not supported, and should be used -only for experimental purposes. - -Note that the gmpy1 ground type is primarily intended for testing; it the -use of gmpy even if gmpy2 is available. - -This is the same as setting the environment variable -SYMPY_GROUND_TYPES to the given ground type (e.g., -SYMPY_GROUND_TYPES='gmpy') - -The ground types can be determined interactively from the variable -sympy.polys.domains.GROUND_TYPES inside the isympy shell itself. - -Example: isympy -t python - -\fITYPE\fR must be one of 'gmpy', -\&'gmpy1' or 'python'. -.TP -\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR -Setup the ordering of terms for printing. The default is lex, which -orders terms lexicographically (e.g., x**2 + x + 1). You can choose -other orderings, such as rev-lex, which will use reverse -lexicographic ordering (e.g., 1 + x + x**2). - -Note that for very large expressions, ORDER='none' may speed up -printing considerably, with the tradeoff that the order of the terms -in the printed expression will have no canonical order - -Example: isympy -o rev-lax - -\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex', -\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'. -.TP -\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T> -Print only Python's and SymPy's versions to stdout at startup, and nothing else. -.TP -\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T> -Use the same format that should be used for doctests. This is -equivalent to '\fIisympy -c python -p no\fR'. -.TP -\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T> -Disable the caching mechanism. Disabling the cache may slow certain -operations down considerably. This is useful for testing the cache, -or for benchmarking, as the cache can result in deceptive benchmark timings. - -This is the same as setting the environment variable SYMPY_USE_CACHE -to 'no'. -.TP -\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T> -Automatically create missing symbols. Normally, typing a name of a -Symbol that has not been instantiated first would raise NameError, -but with this option enabled, any undefined name will be -automatically created as a Symbol. This only works in IPython 0.11. - -Note that this is intended only for interactive, calculator style -usage. In a script that uses SymPy, Symbols should be instantiated -at the top, so that it's clear what they are. - -This will not override any names that are already defined, which -includes the single character letters represented by the mnemonic -QCOSINE (see the "Gotchas and Pitfalls" document in the -documentation). You can delete existing names by executing "del -name" in the shell itself. You can see if a name is defined by typing -"'name' in globals()". - -The Symbols that are created using this have default assumptions. -If you want to place assumptions on symbols, you should create them -using symbols() or var(). - -Finally, this only works in the top level namespace. So, for -example, if you define a function in isympy with an undefined -Symbol, it will not work. -.TP -\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T> -Enable debugging output. This is the same as setting the -environment variable SYMPY_DEBUG to 'True'. The debug status is set -in the variable SYMPY_DEBUG within isympy. -.TP --- \fIPYTHONOPTIONS\fR -These options will be passed on to \fIipython (1)\fR shell. -Only supported when ipython is being used (standard python shell not supported). - -Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR -from the other isympy options. - -For example, to run iSymPy without startup banner and colors: - -isympy -q -c ipython -- --colors=NoColor -.TP -\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T> -Print help output and exit. -.TP -\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T> -Print isympy version information and exit. -.SH FILES -.TP -\*(T<\fI${HOME}/.sympy\-history\fR\*(T> -Saves the history of commands when using the python -shell as backend. -.SH BUGS -The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra -Please report all bugs that you find in there, this will help improve -the overall quality of SymPy. -.SH "SEE ALSO" -\fBipython\fR(1), \fBpython\fR(1) diff --git a/models/main_models/rt1/rt1_pytorch/__init__.py b/models/main_models/rt1/rt1_pytorch/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py deleted file mode 100644 index 8524676fd..000000000 --- a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py +++ /dev/null @@ -1,38 +0,0 @@ -import torch -from torch import nn - - -class FilmConditioning(nn.Module): - def __init__(self, embedding_dim, num_channels): - super().__init__() - self._projection_add = nn.Linear(embedding_dim, num_channels) - self._projection_mult = nn.Linear(embedding_dim, num_channels) - self.num_channels = num_channels - self.embedding_dim = embedding_dim - # From the paper - nn.init.zeros_(self._projection_add.weight) - nn.init.zeros_(self._projection_mult.weight) - nn.init.zeros_(self._projection_add.bias) - nn.init.zeros_(self._projection_mult.bias) - - def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" - assert ( - context.shape[1] == self.embedding_dim - ), f"Unexpected context shape: {context.shape}" - assert ( - x.shape[0] == context.shape[0] - ), f"x and context must have the same batch size, but got {x.shape} and {context.shape}" - projected_cond_add = self._projection_add(context) - projected_cond_mult = self._projection_mult(context) - - if len(x.shape) == 4: - projected_cond_add = projected_cond_add.unsqueeze(2).unsqueeze(3) - projected_cond_mult = projected_cond_mult.unsqueeze(2).unsqueeze(3) - else: - assert len(x.shape) == 2 - - # Original FiLM paper argues that 1 + gamma centers the initialization at - # identity transform. - result = (1 + projected_cond_mult) * x + projected_cond_add - return result \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py deleted file mode 100644 index a9c03573b..000000000 --- a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py +++ /dev/null @@ -1,446 +0,0 @@ -"""EfficientNet models modified with added film layers. - -Mostly taken from: -https://github.com/pytorch/vision/blob/main/torchvision/models/efficientnet.py -""" -import copy -import math -from functools import partial -from typing import Any, Callable, List, Optional, Sequence, Union - -import torch -from torch import nn -from torchvision.models._api import Weights -from torchvision.models._meta import _IMAGENET_CATEGORIES -from torchvision.models._utils import _ovewrite_named_param -from torchvision.models.efficientnet import ( - EfficientNet_B0_Weights, - EfficientNet_B1_Weights, - EfficientNet_B2_Weights, - EfficientNet_B3_Weights, - EfficientNet_B4_Weights, - EfficientNet_B5_Weights, - EfficientNet_B6_Weights, - EfficientNet_B7_Weights, - EfficientNet_V2_L_Weights, - EfficientNet_V2_M_Weights, - EfficientNet_V2_S_Weights, - FusedMBConv, - FusedMBConvConfig, - MBConv, - MBConvConfig, - _efficientnet_conf, - _MBConvConfig, -) -from torchvision.ops.misc import Conv2dNormActivation -from torchvision.utils import _log_api_usage_once - -from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning - - -class MBConvFilm(nn.Module): - """MBConv or FusedMBConv with FiLM context""" - - def __init__(self, embedding_dim: int, mbconv: Union[MBConv, FusedMBConv]): - super().__init__() - self.mbconv = mbconv - num_channels = mbconv.block[-1][1].num_features - self.film = FilmConditioning( - embedding_dim=embedding_dim, num_channels=num_channels - ) - - def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - x = self.mbconv(x) - x = self.film(x, context) - return x - - -class _FilmEfficientNet(nn.Module): - def __init__( - self, - inverted_residual_setting: Sequence[Union[MBConvConfig, FusedMBConvConfig]], - dropout: float, - include_top: bool = False, - stochastic_depth_prob: float = 0.2, - num_classes: int = 1000, - norm_layer: Optional[Callable[..., nn.Module]] = None, - last_channel: Optional[int] = None, - embedding_dim: Optional[int] = 512, - ) -> None: - """ - EfficientNet V1 and V2 main class with additional FiLM context layer - - Args: - inverted_residual_setting (Sequence[Union[MBConvConfig, FusedMBConvConfig]]): Network structure - dropout (float): The droupout probability - include_top (bool): Whether to include the classification head - stochastic_depth_prob (float): The stochastic depth probability - num_classes (int): Number of classes - norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use - last_channel (int): The number of channels on the penultimate layer - embedding_dim (int): The dimension of the embedding space - """ - super().__init__() - _log_api_usage_once(self) - - if not inverted_residual_setting: - raise ValueError("The inverted_residual_setting should not be empty") - elif not ( - isinstance(inverted_residual_setting, Sequence) - and all([isinstance(s, _MBConvConfig) for s in inverted_residual_setting]) - ): - raise TypeError( - "The inverted_residual_setting should be List[MBConvConfig]" - ) - - if norm_layer is None: - norm_layer = nn.BatchNorm2d - - layers: List[nn.Module] = [] - - # building first layer - firstconv_output_channels = inverted_residual_setting[0].input_channels - layers.append( - Conv2dNormActivation( - 3, - firstconv_output_channels, - kernel_size=3, - stride=2, - norm_layer=norm_layer, - activation_layer=nn.SiLU, - ) - ) - - # building inverted residual blocks - total_stage_blocks = sum(cnf.num_layers for cnf in inverted_residual_setting) - stage_block_id = 0 - for cnf in inverted_residual_setting: - stage: List[nn.Module] = [] - for _ in range(cnf.num_layers): - # copy to avoid modifications. shallow copy is enough - block_cnf = copy.copy(cnf) - - # overwrite info if not the first conv in the stage - if stage: - block_cnf.input_channels = block_cnf.out_channels - block_cnf.stride = 1 - - # adjust stochastic depth probability based on the depth of the stage block - sd_prob = ( - stochastic_depth_prob * float(stage_block_id) / total_stage_blocks - ) - stage.append( - MBConvFilm( - embedding_dim=embedding_dim, - mbconv=block_cnf.block(block_cnf, sd_prob, norm_layer), - ) - ) - stage_block_id += 1 - - layers.append(nn.Sequential(*stage)) - - # building last several layers - lastconv_input_channels = inverted_residual_setting[-1].out_channels - lastconv_output_channels = ( - last_channel if last_channel is not None else 4 * lastconv_input_channels - ) - layers.append( - Conv2dNormActivation( - lastconv_input_channels, - lastconv_output_channels, - kernel_size=1, - norm_layer=norm_layer, - activation_layer=nn.SiLU, - ) - ) - - self.features = nn.Sequential(*layers) - if include_top: - self.avgpool = nn.AdaptiveAvgPool2d(1) - self.classifier = nn.Sequential( - nn.Dropout(p=dropout, inplace=True), - nn.Linear(lastconv_output_channels, num_classes), - nn.Softmax(dim=1), - ) - else: - self.avgpool = nn.Identity() - self.classifier = nn.Identity() - - for m in self.modules(): - if isinstance(m, nn.Conv2d): - nn.init.kaiming_normal_(m.weight, mode="fan_out") - if m.bias is not None: - nn.init.zeros_(m.bias) - elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): - nn.init.ones_(m.weight) - nn.init.zeros_(m.bias) - elif isinstance(m, nn.Linear): - init_range = 1.0 / math.sqrt(m.out_features) - nn.init.uniform_(m.weight, -init_range, init_range) - nn.init.zeros_(m.bias) - - self.embedding_dim = embedding_dim - - def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - for feature in self.features: - for layer in feature: - if isinstance(layer, MBConvFilm): - x = layer(x, context) - else: - x = layer(x) - - x = self.avgpool(x) - x = torch.squeeze(x, dim=(2, 3)) # squeeze if h = w = 1 - x = self.classifier(x) - - return x - - -def get_weights(arch: str) -> Weights: - """ - Returns the default weights for the given EfficientNet model. - - Parameters: - arch (str): The EfficientNet variant to use. Allowed values are: - - 'efficientnet_b0' - - 'efficientnet_b1' - - 'efficientnet_b2' - - 'efficientnet_b3' - - 'efficientnet_b4' - - 'efficientnet_b5' - - 'efficientnet_b6' - - 'efficientnet_b7' - - 'efficientnet_v2_s' - - 'efficientnet_v2_m' - - 'efficientnet_v2_l' - - Returns: - WeightsEnum: The default weights for the given architecture. - - Raises: - ValueError: If the given architecture is not supported. - """ - - if arch == "efficientnet_b0": - weights = EfficientNet_B0_Weights.DEFAULT - elif arch == "efficientnet_b1": - weights = EfficientNet_B1_Weights.DEFAULT - elif arch == "efficientnet_b2": - weights = EfficientNet_B2_Weights.DEFAULT - elif arch == "efficientnet_b3": - weights = EfficientNet_B3_Weights.DEFAULT - elif arch == "efficientnet_b4": - weights = EfficientNet_B4_Weights.DEFAULT - elif arch == "efficientnet_b5": - weights = EfficientNet_B5_Weights.DEFAULT - elif arch == "efficientnet_b6": - weights = EfficientNet_B6_Weights.DEFAULT - elif arch == "efficientnet_b7": - weights = EfficientNet_B7_Weights.DEFAULT - elif arch == "efficientnet_v2_s": - weights = EfficientNet_V2_S_Weights.DEFAULT - elif arch == "efficientnet_v2_m": - weights = EfficientNet_V2_M_Weights.DEFAULT - elif arch == "efficientnet_v2_l": - weights = EfficientNet_V2_L_Weights.DEFAULT - else: - raise ValueError(f"Unsupported model type `{arch}`") - - return weights - - -class FilmEfficientNet(nn.Module): - def __init__( - self, - arch: str, - include_top: bool = False, - embedding_dim: int = 512, - pretrained: Optional[bool] = True, - weights: Optional[Weights] = None, - progress: Optional[bool] = True, - device: Optional[Union[str, torch.device]] = "cuda", - **kwargs, - ): - """Builds a FilmEfficientNet model. - - Args: - arch (str): The EfficientNet variant to use. Allowed values are: - - 'efficientnet_b0' - - 'efficientnet_b1' - - 'efficientnet_b2' - - 'efficientnet_b3' - - 'efficientnet_b4' - - 'efficientnet_b5' - - 'efficientnet_b6' - - 'efficientnet_b7' - - 'efficientnet_v2_s' - - 'efficientnet_v2_m' - - 'efficientnet_v2_l' - include_top (bool, optional): Whether to include the classification head - embedding_dim (int, optional): The dimensionality of the output embeddings. - pretrained (bool, optional): Whether to load pretrained EfficientNet weights. - Defaults to True. - weights (WeightsEnum, optional): The pretrained weights to use. - only allowed if `pretrained==False`. Defaults to None. - progress (bool, optional): If True, displays a progress bar of the - download to stderr. Default is True. - device (torch.device, optional): The device on which the model will be - **kwargs: parameters passed to the `FilmEfficientNet` class. - """ - super().__init__() - norm_layer = None - if arch == "efficientnet_b0": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.0, depth_mult=1.0 - ) - dropout = 0.2 - self.output_hw = 7 - elif arch == "efficientnet_b1": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.0, depth_mult=1.1 - ) - dropout = 0.2 - self.output_hw = 8 - elif arch == "efficientnet_b2": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.1, depth_mult=1.2 - ) - dropout = 0.3 - self.output_hw = 9 - elif arch == "efficientnet_b3": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.2, depth_mult=1.4 - ) - dropout = 0.3 - self.output_hw = 10 - elif arch == "efficientnet_b4": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.4, depth_mult=1.8 - ) - dropout = 0.4 - self.output_hw = 12 - elif arch == "efficientnet_b5": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.6, depth_mult=2.2 - ) - dropout = 0.4 - norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) - self.output_hw = 15 - elif arch == "efficientnet_b6": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.8, depth_mult=2.6 - ) - dropout = 0.5 - norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) - self.output_hw = 17 - elif arch == "efficientnet_b7": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=2.0, depth_mult=3.1 - ) - dropout = 0.5 - norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) - self.output_hw = 20 - elif arch == "efficientnet_v2_s": - inverted_residual_setting, last_channel = _efficientnet_conf(arch) - dropout = 0.2 - norm_layer = partial(nn.BatchNorm2d, eps=1e-03) - self.output_hw = 12 - elif arch == "efficientnet_v2_m": - inverted_residual_setting, last_channel = _efficientnet_conf(arch) - dropout = 0.3 - norm_layer = partial(nn.BatchNorm2d, eps=1e-03) - self.output_hw = 15 - elif arch == "efficientnet_v2_l": - inverted_residual_setting, last_channel = _efficientnet_conf(arch) - dropout = 0.4 - norm_layer = partial(nn.BatchNorm2d, eps=1e-03) - self.output_hw = 15 - - assert ( - weights is None or not pretrained - ), "Cannot pass in custom weights with pretrained=True" - weights = get_weights(arch) if pretrained else weights - - if weights is not None: - _ovewrite_named_param( - kwargs, "num_classes", len(weights.meta["categories"]) - ) - - model = _FilmEfficientNet( - inverted_residual_setting, - dropout, - include_top=include_top, - last_channel=last_channel, - norm_layer=norm_layer, - embedding_dim=embedding_dim, - **kwargs, - ) - - if weights is not None: - state_dict = weights.get_state_dict(progress=progress) - new_state_dict = {} - for k, v in state_dict.items(): - if ".block" in k: - new_state_dict[k.replace(".block", ".mbconv.block")] = v - else: - new_state_dict[k] = v - model.load_state_dict( - new_state_dict, - strict=False, - ) - - self.model = model.to(device) - self.preprocess = weights.transforms(antialias=True) if weights else lambda x: x - - self.conv1x1 = nn.Conv2d( - in_channels=self.model.features[-1].out_channels, - out_channels=embedding_dim, - kernel_size=(1, 1), - stride=(1, 1), - padding="same", - bias=False, - device=device, - ) - nn.init.kaiming_normal_(self.conv1x1.weight) - self.film_layer = FilmConditioning(embedding_dim, embedding_dim).to(device) - self.include_top = include_top - self.embedding_dim = embedding_dim - - def forward( - self, image: torch.Tensor, context: Optional[torch.Tensor] = None - ) -> torch.Tensor: - if len(image.shape) == 3: - # Add batch dimension - image = image.unsqueeze(0) - assert len(image.shape) == 4, f"Unexpected image shape: {image.shape}" - if image.shape[-1] == 3: - # (B, H, W, C) -> (B, C, H, W) - image = image.permute(0, 3, 1, 2) - if torch.max(image) >= 1.0: - # Normalize to [0, 1] - image = image / 255.0 - assert torch.min(image) >= 0.0 and torch.max(image) <= 1.0 - image = self.preprocess(image) - - if context is not None and self.include_top: - raise ValueError("Context cannot be passed in if include_top=True") - elif context is None: - context = torch.zeros( - image.shape[0], self.embedding_dim, device=image.device - ) - - features = self.model(image, context) - if not self.include_top: - features = self.conv1x1(features) - features = self.film_layer(features, context) - return features - - -def decode_predictions(preds: torch.Tensor, top=5): - preds = preds.detach().cpu().numpy() - results = [] - for pred in preds: - top_indices = pred.argsort()[-top:][::-1] - result = [(_IMAGENET_CATEGORIES[i], pred[i]) for i in top_indices] - results.append(result) - return results \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/rt1_model.py b/models/main_models/rt1/rt1_pytorch/rt1_model.py deleted file mode 100644 index 30388f638..000000000 --- a/models/main_models/rt1/rt1_pytorch/rt1_model.py +++ /dev/null @@ -1,217 +0,0 @@ -from typing import Optional - -import torch -from einops import rearrange -from torch import nn - -from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer - - -def posemb_sincos_1d(seq, dim, temperature=10000, device=None, dtype=torch.float32): - """ - Generate positional embeddings using sine and cosine functions for a 1-dimensional sequence. - - Parameters: - seq (int): The length of the sequence. - dim (int): The dimension of the positional embeddings. - temperature (float, optional): The temperature parameter for the sine function. Defaults to 10000. - device (torch.device, optional): The device for tensor operations. Defaults to None. - dtype (torch.dtype, optional): The data type of the positional embeddings. Defaults to torch.float32. - - Returns: - torch.Tensor: The positional embeddings of shape (seq, dim), with each element computed as the concatenation of the sine and cosine values. - - """ - n = torch.arange(seq, device=device) - omega = torch.arange(dim // 2, device=device) / (dim // 2 - 1) - omega = 1.0 / (temperature**omega) - - n = n[:, None] * omega[None, :] - pos_emb = torch.cat((n.sin(), n.cos()), dim=1) - return pos_emb.type(dtype) - - -# Robotic Transformer -class RT1Model(nn.Module): - def __init__( - self, - arch: str = "efficientnet_b3", - tokens_per_action=11, - action_bins=256, - num_layers=4, - num_heads=8, - feed_forward_size=512, - dropout_rate=0.1, - time_sequence_length=6, - embedding_dim=512, - use_token_learner=True, - token_learner_bottleneck_dim=64, - token_learner_num_output_tokens=8, - device="cuda", - ): - """ - Initializes the RT1Model. - - Parameters: - arch (str): The efficientnet variant to use. Default is "efficientnet_b3". - tokens_per_action (int): The number of tokens per action. Default is 11. - action_bins (int): The number of action bins. Default is 256. - num_layers (int): The number of transformer layers. Default is 6. - num_heads (int): The number of attention heads. Default is 8. - feed_forward_size (int): The size of the feed-forward layer. Default is 512. - dropout_rate (float): The dropout rate. Default is 0.1. - time_sequence_length (int): The length of the time sequence. Default is 6. - embedding_dim (int): The dimension of the embedding. Default is 512. - use_token_learner (bool): Whether to use token learner. Default is True. - token_learner_bottleneck_dim (int): The dimension of the token learner bottleneck. Default is 64. - token_learner_num_output_tokens (int): The number of output tokens of the token learner. Default is 8. - device (torch.device, optional): The device for tensor operations. Defaults to "cuda". - - Returns: - None - """ - super().__init__() - self.time_sequence_length = time_sequence_length - self.action_encoder = nn.Linear(action_bins, embedding_dim, device=device) - self.image_tokenizer = RT1ImageTokenizer( - arch=arch, - embedding_dim=embedding_dim, - use_token_learner=use_token_learner, - token_learner_bottleneck_dim=token_learner_bottleneck_dim, - token_learner_num_output_tokens=token_learner_num_output_tokens, - dropout_rate=dropout_rate, - device=device, - ) - - self.num_tokens = self.image_tokenizer.num_output_tokens - - self.transformer = nn.Transformer( - d_model=embedding_dim, - nhead=num_heads, - num_encoder_layers=num_layers, - num_decoder_layers=num_layers, - dim_feedforward=feed_forward_size, - dropout=dropout_rate, - activation="gelu", - batch_first=True, - device=device, - ) - - self.to_logits = nn.Sequential( - nn.LayerNorm(embedding_dim), - nn.Linear(embedding_dim, action_bins), - ).to(device) - - self.tokens_per_action = tokens_per_action - self.action_bins = action_bins - self.embedding_dim = embedding_dim - self.device = device - - def forward( - self, - videos: torch.Tensor, - texts: Optional[torch.Tensor] = None, - action_logits: Optional[torch.Tensor] = None, - ): - """ - Forward pass of the model. - - Args: - videos (torch.Tensor): The input videos. - Shape is (b, f, h, w, c) or (b, f, c, h, w). - texts (Optional[torch.Tensor]): The input text embedding. - Shape is (b, f, embedding_dim). - action_logits (Optional[torch.Tensor]): The input action_logits. - Shape is (b, f, tokens_per_action, action_bins). - - Returns: - torch.Tensor: The output logits. - Shape is (b, f, tokens_per_action, action_bins). - """ - b, f, *_ = videos.shape - assert ( - f == self.time_sequence_length - ), f"Expected {self.time_sequence_length} frames, got videos.shape[1] = {f}" - - if texts is None: - texts = torch.zeros((b, f, self.embedding_dim), device=self.device) - if action_logits is None: - action_logits = torch.zeros( - (b, f, self.tokens_per_action, self.action_bins), device=self.device - ) - elif action_logits.shape != (b, f, self.tokens_per_action, self.action_bins): - raise ValueError( - f"""Expected action_logits.shape = (b, f, tokens_per_action, action_bins), - got {action_logits.shape}; did you pass in raw actions instead?""" - ) - - # pack time dimension into batch dimension - videos = rearrange(videos, "b f ... -> (b f) ...") - texts = rearrange(texts, "b f d -> (b f) d") - - # tokenize images and texts - tokens = self.image_tokenizer(videos, texts) - - # unpack time dimension from batch dimension - tokens = rearrange(tokens, "(b f) c n -> b f c n", b=b, f=f) - - # pack time dimension into token dimension - tokens = rearrange(tokens, "b f c n -> b (f n) c") - action_logits = rearrange(action_logits, "b f a d -> b (f a) d") - - # sinusoidal positional embedding - pos_emb = posemb_sincos_1d(tokens.shape[1], tokens.shape[2], device=self.device) - tokens = tokens + pos_emb - - # causal mask for tokens - token_mask = torch.ones( - tokens.shape[1], tokens.shape[1], dtype=torch.bool - ).tril(0) - token_mask = ~token_mask - token_mask = token_mask.to(self.device) - - # encode action_logits to have the same embedding dimension as tokens - action_tokens = self.action_encoder(action_logits) - - pos_emb = posemb_sincos_1d( - action_tokens.shape[1], action_tokens.shape[2], device=self.device - ) - action_tokens = action_tokens + pos_emb - - # action mask: do not let action_logits attend to previous action_logits, - # a_t is independent of a_{t-1} given pi and s_t - action_mask = torch.ones( - self.time_sequence_length, self.time_sequence_length, dtype=torch.bool - ).tril(0) - action_mask = torch.kron( - torch.eye(self.tokens_per_action, self.tokens_per_action, dtype=torch.bool), - action_mask, - ) - action_mask = ~action_mask - action_mask = action_mask.to(self.device) - - # causal mask between tokens and action_logits; - # a_t attends to s_t' for all t'<=t - memory_mask = torch.ones( - self.time_sequence_length, self.time_sequence_length, dtype=torch.bool - ).tril(0) - memory_mask = torch.kron( - memory_mask, - torch.ones(self.tokens_per_action, self.num_tokens, dtype=torch.bool), - ) - memory_mask = ~memory_mask - memory_mask = memory_mask.to(self.device) - - attended_tokens = self.transformer( - src=tokens, - src_mask=token_mask, - tgt=action_tokens, - tgt_mask=action_mask, - memory_mask=memory_mask, - ) - - # unpack time dimension from token dimension - attended_tokens = rearrange(attended_tokens, "b (f n) c -> b f n c", b=b, f=f) - - logits = self.to_logits(attended_tokens) - return logits \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/rt1_policy.py b/models/main_models/rt1/rt1_pytorch/rt1_policy.py deleted file mode 100644 index f68155a56..000000000 --- a/models/main_models/rt1/rt1_pytorch/rt1_policy.py +++ /dev/null @@ -1,234 +0,0 @@ -from typing import Dict, List, Optional, Tuple, Union - -import gymnasium as gym -import numpy as np -import torch -import tree -from einops import rearrange -from torch.nn import functional as F -import pdb - -from rt1_pytorch.rt1_model import RT1Model -from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer - - -class RT1Policy: - def __init__( - self, - observation_space: gym.spaces.Dict, - action_space: gym.spaces.Dict, - arch: str = "efficientnet_b3", - action_bins=256, - num_layers=4, - num_heads=8, - feed_forward_size=256, - dropout_rate=0.1, - time_sequence_length=6, - embedding_dim=512, - use_token_learner=True, - token_learner_bottleneck_dim=64, - token_learner_num_output_tokens=8, - device="cuda", - checkpoint_path: Optional[str] = None, - ): - """ - Initializes an instance of the class. - - Args: - observation_space (gym.spaces.Dict): The observation space of the environment. - action_space (gym.spaces.Dict): The action space of the environment. - arch (str, optional): The architecture of the model. Defaults to "efficientnet_b3". - action_bins (int, optional): The number of bins for discretizing continuous action spaces. Defaults to 256. - num_layers (int, optional): The number of transformer layers in the model. Defaults to 8. - num_heads (int, optional): The number of attention heads in each transformer layer. Defaults to 8. - feed_forward_size (int, optional): The size of the feed-forward layer in the transformer. Defaults to 256. - dropout_rate (float, optional): The dropout rate for the transformer layers. Defaults to 0.1. - time_sequence_length (int, optional): The length of the time sequence for the model. Defaults to 6. - embedding_dim (int, optional): The dimensionality of the input embeddings. Defaults to 512. - use_token_learner (bool, optional): Whether to use the token learner module. Defaults to True. - token_learner_bottleneck_dim (int, optional): The dimensionality of the bottleneck layer in the token learner. Defaults to 64. - token_learner_num_output_tokens (int, optional): The number of output tokens from the token learner. Defaults to 8. - device (str, optional): The device to use for the model. Defaults to "cuda". - checkpoint_path (str, optional): load checkpoint from path. Defaults to None. - - Returns: - None - """ - self.observation_space = observation_space - self.action_space = action_space - self.action_bins = action_bins - self.action_tokenizer = RT1ActionTokenizer( - action_space=action_space, - action_bins=action_bins, - action_order=list(action_space.keys()), - ) - - self.model = RT1Model( - arch=arch, - tokens_per_action=self.action_tokenizer.tokens_per_action, - action_bins=action_bins, - num_layers=num_layers, - num_heads=num_heads, - feed_forward_size=feed_forward_size, - dropout_rate=dropout_rate, - time_sequence_length=time_sequence_length, - embedding_dim=embedding_dim, - use_token_learner=use_token_learner, - token_learner_bottleneck_dim=token_learner_bottleneck_dim, - token_learner_num_output_tokens=token_learner_num_output_tokens, - device=device, - ) - - self.embedding_dim = embedding_dim - - for action_space in self.action_space.values(): - if ( - isinstance(action_space, gym.spaces.Discrete) - and action_space.n == time_sequence_length - ): - raise ValueError( - f"""stupid hack:Time sequence length ({time_sequence_length}) - must be different from action space length ({action_space.n}).""" - ) - - self.device = device - if checkpoint_path is not None: - print(f"Loading checkpoint from {checkpoint_path}...") - self.model.load_state_dict(torch.load(checkpoint_path)) - - def preprocess( - self, - videos: Union[np.ndarray, List[np.ndarray]], - texts: Union[np.ndarray, List[np.ndarray]], - actions: Optional[Dict] = None, - ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: - """ - Preprocesses the given videos, texts, and actions. - - Args: - videos (Union[np.ndarray, List[np.ndarray]]): The input videos to preprocess. - shape: (b, t, c, h, w) or (b, t, h, w, c) - texts (Union[np.ndarray, List[np.ndarray]]): The input texts to preprocess. - shape: (b, t, d) - actions (Optional[Dict]): The input actions to preprocess. Defaults to None. - shape: (b, t, a) - - Returns: - Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: A tuple containing the preprocessed videos, texts, and actions. - """ - if isinstance(videos, torch.Tensor): - videos = videos.to(self.device) - elif not isinstance(videos, np.ndarray): - videos = np.stack(videos, axis=0) - - if not isinstance(videos, torch.Tensor): - videos = torch.tensor(videos, device=self.device, dtype=torch.float32) - - if isinstance(texts, torch.Tensor): - texts = texts.to(self.device) - elif not isinstance(texts, np.ndarray): - texts = np.stack(texts, axis=0) - if not isinstance(texts, torch.Tensor): - texts = torch.tensor(texts, device=self.device, dtype=torch.float32) - - - if actions is not None: - actions = { - k: np.stack(v, axis=0) if not (isinstance(v, np.ndarray)) else v - for k, v in actions.items() - } - - - actions = tree.map_structure( - lambda a: rearrange(a, "b f ... -> (b f) ..."), actions - ) - actions = self.action_tokenizer.tokenize(actions) - actions = torch.tensor(actions, device=self.device, dtype=torch.long) - actions = rearrange(actions, "(b f) ... -> b f ...", b=videos.shape[0]) - - return videos, texts, actions - - def forward( - self, - videos: torch.Tensor, - texts: torch.Tensor, - action_logits: Optional[torch.Tensor] = None, - ) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Forward pass through the model. - - Args: - videos (torch.Tensor): Input videos. - texts (torch.Tensor): input contexts. - action_logits (Optional[torch.Tensor]): Optional input action logits. - - Returns: - action_logits (Tuple[torch.Tensor, torch.Tensor]): - A tuple containing the sampled actions and the action logits. - """ - action_logits = self.model(videos, texts, action_logits) - actions = torch.distributions.Categorical(logits=action_logits) - actions = actions.sample() - return actions, action_logits - - def loss(self, observations: Dict, target_actions: Dict) -> torch.Tensor: - """ - Calculates the loss function for the given inputs. - - Args: - observations (Dict): A dictionary containing the observations. - It should have the following keys: - - "image" (np.ndarray): The video observations. - - "context" (np.ndarray): The context. - target_actions (Dict): A dictionary containing the target actions. - - Returns: - torch.Tensor: The calculated loss value. - - Raises: - None - """ - videos = observations["image"] - texts = observations["context"] - videos, texts, target_actions = self.preprocess( - videos, - texts, - target_actions, - ) - _, action_logits = self.forward(videos, texts) - - action_logits = rearrange(action_logits, "b f a d -> (b f a) d") - target_actions = rearrange(target_actions, "b f a -> (b f a)") - loss = F.cross_entropy(action_logits, target_actions, reduction="sum") - loss = loss / videos.shape[0] - - - dummy_loss = F.cross_entropy(action_logits, target_actions, reduction="none") - loss_std = torch.std(dummy_loss) - - return loss, loss_std - - def act(self, observations: Dict) -> Dict[str, np.ndarray]: - """ - Performs an action based on the given observations. - Note that this takes in observations of shape (b,t, ...) - but only returns the last action for each trajectory of shape (b, ...). - - Args: - observations (Dict): A dictionary containing the observations. It should have the following keys: - - "image" (np.ndarray): The video observations. - - "context" (np.ndarray): The context. - - Returns: - Dict[str, np.ndarray]: A dictionary containing the actions. It has the following keys: - - "actions" (np.ndarray): The actions performed based on the observations. - """ - videos = observations["image"] - texts = observations["context"] - videos, texts, _ = self.preprocess(videos, texts) - with torch.no_grad(): - actions, _ = self.forward(videos, texts) - actions = actions.detach().cpu().numpy() - actions = self.action_tokenizer.detokenize(actions) - actions = tree.map_structure(lambda a: a[:, -1], actions) - return actions diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py b/models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py b/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py deleted file mode 100644 index 542aa6ec3..000000000 --- a/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py +++ /dev/null @@ -1,184 +0,0 @@ -"""A simple action tokenizer used with Robotics Transformer 1. - -As an example, if an action is: -{ - 'base_displacement_vector': - , - 'base_displacement_vertical_rotation': - , - 'gripper_closedness_action': - , - 'rotation_delta': - , - 'terminate_episode': - , - 'world_vector': - -} - -Then we build a sequence of tokens of length 11 [one for each dimension]. -The int32 type action dimensions are already tokenized, -the float dimensions are bucketed according to the spaces min and max. Each -dimension has 'action_bins' buckets. - -Currently, this tokenizer assumes one action space and it is highly recommended -to spaceify the 'action_order', i.e. the order of keys in the dict. -Since after tokenization you lose that information, this -will be useful for debugging. Actions may also be subselected for prediction, -since not all actions are needed in the action_order. -""" -from typing import Dict, Optional - -import gymnasium as gym -import numpy as np -from gymnasium.spaces import Box, Discrete -import pdb - -class RT1ActionTokenizer: - """Tokenizes based on vocab size.""" - - def __init__( - self, - action_space: gym.spaces.Dict, - action_bins: int, - action_order: Optional[list[str]] = None, - ): - """Instantiates an RT1ActionTokenizer. - - Args: - action_bins: Number of buckets to discretize action to. - action_order: Order of the action names, used to discern the order of - tokenized actions to detokenize and assemble back to action tensor - """ - self._action_bins = action_bins - - # filter the action keys - lanmp_keys = ['terminate_episode', 'pickup_release', 'body_position_delta', 'body_yaw_delta','body_pitch_delta','arm_position_delta','control_mode'] - bridge_keys = ['terminate_episode','world_vector', 'open_gripper', "rotation_delta"] - jaco_keys = ['terminate_episode','world_vector', 'gripper_closedness_action'] - - #NOTE: change both lines below to the specific dataset keys - action_order = lanmp_keys #bridge_keys #jaco_keys - action_space = {key: action_space[key] for key in lanmp_keys if key in set(action_space.keys())} - self._action_space = action_space - if action_order is None: - self._action_order = list(action_space.keys()) - else: - for action in action_order: - assert ( - action in action_space.keys() - ), f"action: {action} not in action_space: {action_space.keys()}" - self._action_order = action_order - self._tokens_per_action = 0 - for action in self._action_order: - action_shape = action_space[action].shape - if isinstance(action_space, gym.spaces.Box) and len(action_shape) != 1: - raise ValueError( - f"Only action shapes with single dimension supported, got {action_shape}" - ) - if isinstance(action_space[action], Discrete): - # Int32 actions are already assumed to be tokens. - self._tokens_per_action += 1 - elif isinstance(action_space[action], Box): - if len(action_shape) != 1: - raise ValueError( - f"Only action shapes with single dimension supported, got {action_shape}" - ) - self._tokens_per_action += action_shape[0] - else: - raise ValueError( - f"Unsupported action space: {type(action_space[action])}" - ) - - # We measure # of action tokens in two different way. One is by checking - # from action_order (above) and the other is by looping through the - # action space (below). We aseert the # of action tokens are the same - # calculated by these two ways. This will assure action_order is correctly - # configured, otherwise, it will throw an error in the assert. - num_action_token = 0 - for space in action_space.values(): - if space.dtype == np.int_: - num_action_token += 1 - else: - num_action_token += space.shape[-1] - assert ( - self._tokens_per_action == num_action_token - ), f"{self._tokens_per_action} != {num_action_token}" - - @property - def tokens_per_action(self) -> int: - return self._tokens_per_action - - @property - def action_space(self) -> gym.spaces.Dict: - return self._action_space - - @property - def action_order(self) -> list[str]: - return self._action_order - - def tokenize(self, action: Dict) -> np.ndarray: - """Tokenizes an action.""" - - action_tokens = [] - for k in self._action_order: - #print("k equals " + str(k)) - #print(action.keys()) - #print(action) - act = action[k] # a is [batch, (time), action_size] - space = self._action_space[k] - if isinstance(space, gym.spaces.Discrete): - # Int32 actions are already assumed to be tokens - if not (isinstance(act, np.ndarray)): - act = np.array(act, dtype=np.int32) - act = np.expand_dims(act, axis=-1) - if not np.all(act < space.n): - raise ValueError(f"Invalid action: {act} >= {space.n}") - token = act - elif isinstance(space, gym.spaces.Box): - low = space.low[0] - high = space.high[0] - act = np.clip(act, low, high) - # Normalize the action [batch, actions_size] - token = (act - low) / (high - low) - # Bucket and discretize the action to action_bins, [batch, actions_size] - token = (token * (self._action_bins - 1)).astype(np.int32) - #TODO: bridge - if k == 'open_gripper': - token = token[:,None] - action_tokens.append(token) - #print(k, token.shape) - # Append all actions, [batch, (time), all_actions_size] - action_tokens = np.concatenate(action_tokens, axis=-1) - return action_tokens - - def detokenize(self, action_tokens: np.ndarray) -> Dict: - """Detokenizes an action.""" - action = {} - token_index = 0 - if not action_tokens.shape[-1] == self._tokens_per_action: - action_tokens = action_tokens.reshape( - *action_tokens.shape[:-1], self._tokens_per_action - ) - for k in self._action_order: - space = self._action_space[k] - if isinstance(space, gym.spaces.Discrete): - # Int32 actions are already assumed to be tokens. - action[k] = action_tokens[..., token_index] - # A poor model may output tokens outside the allowed range, in that case - # set them to a default value, the 0 token in this case. - action[k] = np.where( - action[k] >= space.n, np.zeros_like(action[k]), action[k] - ) - token_index += 1 - elif isinstance(space, gym.spaces.Box): - actions = [] - for _ in range(space.shape[0]): - a = action_tokens[..., token_index : token_index + 1] - a = a.astype(np.float32) - a = a / (self._action_bins - 1) - a = (a * (space.high[0] - space.low[0])) + space.low[0] - actions.append(a) - token_index += 1 - action[k] = np.concatenate(actions, axis=-1) - return action diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py b/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py deleted file mode 100644 index 9cf4cdcb0..000000000 --- a/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py +++ /dev/null @@ -1,77 +0,0 @@ -"""The image tokenizer combining the FiLMEfficientNet and TokenLearner from RT1. -""" -import torch -from torch import nn - -from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning -from rt1_pytorch.film_efficientnet.film_efficientnet import FilmEfficientNet -from rt1_pytorch.tokenizers.token_learner import TokenLearner - - -class RT1ImageTokenizer(nn.Module): - """Tokenizes based on vocab size.""" - - def __init__( - self, - arch: str = "efficientnet_b3", - embedding_dim: int = 512, - use_token_learner=True, - token_learner_bottleneck_dim=64, - token_learner_num_output_tokens=8, - dropout_rate=0.1, - device="cuda", - ): - """Instantiates a RT1ImageTokenizer. - - Args: - arch: The efficientnet variant to use. - embedding_dim: The embedding size of the tokens. - use_token_learner: Whether to use token learner. See - https://arxiv.org/abs/2106.11297 - num_tokens: Relevant only for token learner - the number of learned - tokens. - token_learner_bottleneck_dim: Relevant only for token learner - the - dimension of the bottleneck layer. - token_learner_num_output_tokens: Relevant only for token learner - - the number of output tokens. - dropout_rate: Relevant only for token learner - the dropout rate. - device: The device to place the model on. - """ - super().__init__() - - self.film_efficientnet = FilmEfficientNet( - arch=arch, embedding_dim=embedding_dim, device=device - ) - self.num_output_tokens = self.film_efficientnet.output_hw**2 - - self._use_token_learner = use_token_learner - if self._use_token_learner: - self._token_learner = TokenLearner( - embedding_dim=embedding_dim, - num_tokens=token_learner_num_output_tokens, - bottleneck_dim=token_learner_bottleneck_dim, - dropout_rate=dropout_rate, - device=device, - ) - self.num_output_tokens = token_learner_num_output_tokens - - def forward(self, image: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - """Gets image tokens. - - Args: - image: Images of shape (b, h, w, 3) to tokenize. - context: A context vector (e.g., a natural language embedding). - Expected to have shape (b, embedding_dim). - - Returns: - tokens: has shape (batch, num_tokens_per_timestep, embedding_dim) - """ - assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" - - tokens = self.film_efficientnet(image, context) - if len(tokens.shape) == 4: - # (b, c, h, w) -> (b, c, h*w) - tokens = tokens.reshape(tokens.shape[0], tokens.shape[1], -1) - if self._use_token_learner: - tokens = self._token_learner(tokens) - return tokens \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py b/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py deleted file mode 100644 index 8e04a4c30..000000000 --- a/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py +++ /dev/null @@ -1,89 +0,0 @@ -"""Pytorch implementation of TokenLearner(Ryoo et al 2021).""" - -import torch -from torch import nn - - -class MlpBlock(nn.Module): - """Transformer MLP / feed-forward block.""" - - def __init__( - self, - input_dim: int, - mlp_dim: int, - out_dim: int, - dropout_rate: float = 0.1, - device="cuda", - ): - """Initializer for the MLP Block. - - This computes outer_dense(gelu(hidden_dense(input))), with dropout - applied as necessary. - - Args: - input_dim: The dimension of the input. - mlp_dim: The dimension of the inner representation (output of hidden - layer). Usually larger than the input/output dim. - out_dim: The output dimension of the block. - dropout_rate: Dropout rate to be applied after dense ( & activation) - layers. - device: The device to place the model on. - """ - super().__init__() - self._hidden_dropout = nn.Dropout(dropout_rate) - self._output_dropout = nn.Dropout(dropout_rate) - self._hidden_layer = nn.Linear(input_dim, mlp_dim, device=device) - self._output_layer = nn.Linear(mlp_dim, out_dim, device=device) - nn.init.xavier_uniform_(self._hidden_layer.weight) - nn.init.xavier_uniform_(self._output_layer.weight) - nn.init.normal_(self._hidden_layer.bias, std=1e-6) - nn.init.normal_(self._output_layer.bias, std=1e-6) - - def forward(self, inputs: torch.Tensor) -> torch.Tensor: - """Applies Transformer MlpBlock module.""" - x = self._hidden_layer(inputs) - x = nn.functional.gelu(x) - x = self._hidden_dropout(x) - x = self._output_layer(x) - x = self._output_dropout(x) - return x - - -class TokenLearner(nn.Module): - """TokenLearner module V1.1 (https://arxiv.org/abs/2106.11297).""" - - def __init__( - self, - embedding_dim: int, - num_tokens: int, - bottleneck_dim: int = 64, - dropout_rate: float = 0.0, - device="cuda", - ): - super().__init__() - - self.layernorm = nn.LayerNorm(embedding_dim, eps=1e-6, device=device) - self.mlp = MlpBlock( - input_dim=embedding_dim, - mlp_dim=bottleneck_dim, - out_dim=num_tokens, - dropout_rate=dropout_rate, - device=device, - ) - - def forward(self, inputs: torch.Tensor) -> torch.Tensor: - if len(inputs.shape) == 4: - bs, c, h, w = inputs.shape - inputs = torch.reshape(inputs, [bs, c, h * w]) - inputs = inputs.permute(0, 2, 1) # Shape: [bs, h*w, c] - - selected = self.layernorm(inputs) - - selected = self.mlp(selected) # Shape: [bs, h*w, n_token]. - selected = nn.functional.softmax(selected, dim=-1) - selected = selected.permute(0, 2, 1) # Shape: [bs, n_token, h*w] - - feat = torch.einsum("...si,...id->...sd", selected, inputs) - feat = feat.permute(0, 2, 1) - - return feat # Shape: [bs, c, n_token] \ No newline at end of file diff --git a/models/main_models/rt1/setup.py b/models/main_models/rt1/setup.py deleted file mode 100644 index 4c3290111..000000000 --- a/models/main_models/rt1/setup.py +++ /dev/null @@ -1,44 +0,0 @@ -from setuptools import find_packages, setup - -setup( - name="rt1-pytorch", - packages=find_packages(exclude=[]), - version="0.1.0", - license="MIT", - description="PyTorch implementation of the RT-1.", - author="Rohan Potdar", - author_email="rohanpotdar138@gmail.com", - long_description_content_type="text/markdown", - url="https://github.com/Rohan138/rt1-pytorch", - keywords=[ - "artificial intelligence", - "deep learning", - "transformers", - "attention mechanism", - "robotics", - ], - install_requires=[ - "torch>=1.9", - "scikit-image", - "sentence-transformers", - "tensorflow", - "tensorflow_datasets", - "transformers", - "gymnasium[mujoco]", - "dm-reverb", - "dm-control", - "rlds", - "einops", - "dmc2gymnasium@git+https://github.com/imgeorgiev/dmc2gymnasium.git", - "h5py", - "wandb", - "tqdm", - ], - classifiers=[ - "Development Status :: 4 - Beta", - "Intended Audience :: Developers", - "Topic :: Scientific/Engineering :: Artificial Intelligence", - "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3.6", - ], -) \ No newline at end of file diff --git a/models/main_models/rt1/tests/action_tokenizer_test.py b/models/main_models/rt1/tests/action_tokenizer_test.py deleted file mode 100644 index 6b082840b..000000000 --- a/models/main_models/rt1/tests/action_tokenizer_test.py +++ /dev/null @@ -1,166 +0,0 @@ -"""Tests for action_tokenizer.""" -import unittest - -import numpy as np -from gymnasium.spaces import Box, Dict, Discrete - -from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer - - -class ActionTokenizerTest(unittest.TestCase): - def testTokenize_int32(self): - action_space = Dict(terminate_episode=Discrete(2)) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(1, tokenizer.tokens_per_action) - action = dict(terminate_episode=np.array([1], dtype=np.int32)) - action_tokens = tokenizer.tokenize(action) - self.assertEqual(action["terminate_episode"], action_tokens) - - def testTokenize_int32_out_of_bounds(self): - action_space = Dict(terminate_episode=Discrete(2)) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(1, tokenizer.tokens_per_action) - action = dict(terminate_episode=np.array([3], dtype=np.int32)) - with self.assertRaises(ValueError): - tokenizer.tokenize(action) - - def testDetokenize_int32(self): - action_space = Dict(terminate_episode=Discrete(2)) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - action = tokenizer.detokenize(np.array([0], dtype=np.int32)) - self.assertEqual(action["terminate_episode"], np.array([0])) - # OOV 3 token should become a default one hot: [1, 0] - action = tokenizer.detokenize(np.array([3], dtype=np.int32)) - self.assertEqual(action["terminate_episode"], np.array([0])) - - def testTokenize_float(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) - ) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(3, tokenizer.tokens_per_action) - action = dict(world_vector=[0.1, 0.5, -0.8]) - action_tokens = tokenizer.tokenize(action) - self.assertSequenceEqual([4, 6, 0], list(action_tokens.tolist())) - - def testTokenize_float_with_time_dimension(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) - ) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(3, tokenizer.tokens_per_action) - batch_size = 2 - time_dimension = 3 - action = dict( - world_vector=np.array( - [ - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - ], - ).reshape((batch_size, time_dimension, 3)), - ) - action_tokens = tokenizer.tokenize(action) - self.assertSequenceEqual( - [batch_size, time_dimension, tokenizer.tokens_per_action], - action_tokens.shape, - ) - - def testTokenize_float_at_limits(self): - minimum = -1.0 - maximum = 1.0 - action_bins = 10 - action_space = Dict( - world_vector=Box(low=minimum, high=maximum, shape=(2,), dtype=np.float32) - ) - tokenizer = RT1ActionTokenizer(action_space, action_bins=action_bins) - self.assertEqual(2, tokenizer.tokens_per_action) - action = dict(world_vector=[minimum, maximum]) - action_tokens = tokenizer.tokenize(action) - # Minimum value will go to 0 - # Maximum value witll go to action_bins-1 - self.assertSequenceEqual([0, action_bins - 1], action_tokens.tolist()) - - def testTokenize_invalid_action_space_shape(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(2, 2), dtype=np.float32) - ) - with self.assertRaises(ValueError): - RT1ActionTokenizer(action_space, action_bins=10) - - def testTokenizeAndDetokenizeIsEqual(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), - rotation_delta=Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 - ), - gripper_closedness_action=Box( - low=-1.0, high=1.0, shape=(1,), dtype=np.float32 - ), - terminate_episode=Discrete(3), - ) - - tokenizer = RT1ActionTokenizer( - action_space, - action_bins=256, - action_order=[ - "terminate_episode", - "world_vector", - "rotation_delta", - "gripper_closedness_action", - ], - ) - self.assertEqual(8, tokenizer.tokens_per_action) - - # Repeat the following test N times with fuzzy inputs. - n_repeat = 10 - for _ in range(n_repeat): - action = dict( - world_vector=np.random.uniform(low=-1.0, high=1.0, size=3), - rotation_delta=np.random.uniform( - low=-np.pi / 2.0, high=np.pi / 2.0, size=3 - ), - gripper_closedness_action=np.random.uniform(low=0.0, high=1.0, size=1), - terminate_episode=np.array(0, dtype=np.int32), - ) - action_tokens = tokenizer.tokenize(action) - policy_action = tokenizer.detokenize(action_tokens) - - for k in action: - self.assertTrue( - np.allclose(action[k], policy_action[k], atol=1e-1), - f"Failed at {k} with {action[k]} != {policy_action[k]}.", - ) - - # Repeat the test with batched actions - batched_action = dict( - world_vector=[ - np.random.uniform(low=-1.0, high=1.0, size=3), - np.random.uniform(low=-1.0, high=1.0, size=3), - ], - rotation_delta=[ - np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), - np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), - ], - gripper_closedness_action=[ - np.random.uniform(low=0.0, high=1.0, size=1), - np.random.uniform(low=0.0, high=1.0, size=1), - ], - terminate_episode=[0, 1], - ) - action_tokens = tokenizer.tokenize(batched_action) - policy_action = tokenizer.detokenize(action_tokens) - - for k in batched_action: - for a, policy_a in zip(batched_action[k], policy_action[k]): - self.assertTrue( - np.allclose(a, policy_a, atol=1e-1), - f"Failed at {k} with {a} != {policy_a}.", - ) - - -if __name__ == "__main__": - unittest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/film_conditioning_layer_test.py b/models/main_models/rt1/tests/film_conditioning_layer_test.py deleted file mode 100644 index 0cefd44b0..000000000 --- a/models/main_models/rt1/tests/film_conditioning_layer_test.py +++ /dev/null @@ -1,27 +0,0 @@ -"""Tests for film_conditioning_layer.""" -import torch -from absl.testing import absltest, parameterized - -from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning - - -class FilmConditioningLayerTest(parameterized.TestCase): - @parameterized.parameters([2, 4]) - def test_film_conditioning_rank_two_and_four(self, conv_rank): - batch = 2 - num_channels = 3 - embedding_dim = 512 - if conv_rank == 2: - conv_layer = torch.randn(size=(batch, num_channels)) - elif conv_rank == 4: - conv_layer = torch.randn(size=(batch, 1, 1, num_channels)) - else: - raise ValueError(f"Unexpected conv rank: {conv_rank}") - context = torch.rand(batch, embedding_dim) - film_layer = FilmConditioning(embedding_dim, num_channels) - out = film_layer(conv_layer, context) - assert len(out.shape) == conv_rank - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/film_efficientnet_test.py b/models/main_models/rt1/tests/film_efficientnet_test.py deleted file mode 100644 index 8fa2944cc..000000000 --- a/models/main_models/rt1/tests/film_efficientnet_test.py +++ /dev/null @@ -1,57 +0,0 @@ -"""Tests for pretrained_efficientnet_encoder.""" - -import torch -from absl.testing import absltest, parameterized -from skimage import data - -from rt1_pytorch.film_efficientnet.film_efficientnet import ( - FilmEfficientNet, - decode_predictions, -) - -MODELS = [ - "efficientnet_b0", - "efficientnet_b1", - "efficientnet_b2", - "efficientnet_b3", - # "efficientnet_b4", - # "efficientnet_b5", - # "efficientnet_b6", - # "efficientnet_b7", - "efficientnet_v2_s", - # "efficientnet_v2_m", - # "efficientnet_v2_l", -] - - -class FilmEfficientNetTest(parameterized.TestCase): - @parameterized.parameters(MODELS) - def test_encoding(self, model_name): - """Test that we get a correctly shaped encoding.""" - embedding_dim = 512 - batch_size = 4 - device = "cuda" if torch.cuda.is_available() else "cpu" - image = torch.tensor(data.chelsea()).repeat(batch_size, 1, 1, 1) - context = torch.FloatTensor(size=(batch_size, embedding_dim)).uniform_(-1, 1) - model = FilmEfficientNet(model_name, device=device).eval() - image = image.to(device) - context = context.to(device) - preds = model(image, context) - self.assertEqual( - preds.shape, (batch_size, 512, model.output_hw, model.output_hw) - ) - - @parameterized.parameters(MODELS) - def test_imagenet_classification(self, model_name): - """Test that we can correctly classify an image of a cat.""" - device = "cuda" if torch.cuda.is_available() else "cpu" - image = torch.tensor(data.chelsea()) - model = FilmEfficientNet(model_name, include_top=True, device=device).eval() - image = image.to(device) - preds = model(image) - predicted_names = [n[0] for n in decode_predictions(preds, top=3)[0]] - self.assertIn("tabby", predicted_names) - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/image_tokenizer_test.py b/models/main_models/rt1/tests/image_tokenizer_test.py deleted file mode 100644 index 3b1dbd0e0..000000000 --- a/models/main_models/rt1/tests/image_tokenizer_test.py +++ /dev/null @@ -1,53 +0,0 @@ - -"""Tests for image_tokenizer.""" -import unittest - -import torch -from absl.testing import parameterized - -from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer - -MODELS = [ - "efficientnet_b0", - "efficientnet_b1", - "efficientnet_b2", - "efficientnet_b3", - # "efficientnet_b4", - # "efficientnet_b5", - # "efficientnet_b6", - # "efficientnet_b7", - "efficientnet_v2_s", - # "efficientnet_v2_m", - # "efficientnet_v2_l", -] - - -class ImageTokenizerTest(parameterized.TestCase): - @parameterized.named_parameters( - *[(f"sample_image_{m}", m, 512, 224, False, 8) for m in MODELS], - *[(f"sample_image_token_learner_{m}", m, 512, 224, True, 8) for m in MODELS], - ) - def testTokenize( - self, arch, embedding_dim, image_resolution, use_token_learner, num_tokens - ): - batch = 4 - device = "cuda" - tokenizer = RT1ImageTokenizer( - arch=arch, - embedding_dim=embedding_dim, - use_token_learner=use_token_learner, - token_learner_num_output_tokens=num_tokens, - device=device, - ) - - image = torch.randn((batch, image_resolution, image_resolution, 3)) - image = torch.clip(image, 0.0, 1.0) - image = image.to(device) - context_vector = torch.FloatTensor(size=(batch, 512)).uniform_() - context_vector = context_vector.to(device) - image_tokens = tokenizer(image, context_vector) - self.assertEqual(image_tokens.shape, (batch, 512, tokenizer.num_output_tokens)) - - -if __name__ == "__main__": - unittest.main() diff --git a/models/main_models/rt1/tests/rt1_model_test.py b/models/main_models/rt1/tests/rt1_model_test.py deleted file mode 100644 index 6ac8b07dd..000000000 --- a/models/main_models/rt1/tests/rt1_model_test.py +++ /dev/null @@ -1,54 +0,0 @@ -import torch -from absl.testing import absltest, parameterized - -from rt1_pytorch.rt1_model import RT1Model - - -class RT1ModelTest(parameterized.TestCase): - @parameterized.parameters(["cpu", "cuda"]) - def test_videos(self, device): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - logits = model(videos) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - @parameterized.parameters(["cpu", "cuda"]) - def test_videos_and_texts(self, device="cpu"): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - texts = torch.rand(batch_size, 6, 512, device=device) - logits = model(videos, texts) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - @parameterized.parameters(["cpu", "cuda"]) - def test_videos_and_action_logits(self, device="cpu"): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - action_logits = torch.rand(batch_size, 6, 11, 256, device=device) - logits = model(videos, action_logits=action_logits) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - @parameterized.parameters(["cpu", "cuda"]) - def test_videos_and_texts_and_action_logits(self, device="cpu"): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - texts = torch.rand(batch_size, 6, 512, device=device) - action_logits = torch.rand(batch_size, 6, 11, 256, device=device) - logits = model(videos, texts, action_logits) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/rt1_policy_test.py b/models/main_models/rt1/tests/rt1_policy_test.py deleted file mode 100644 index 2d861dc58..000000000 --- a/models/main_models/rt1/tests/rt1_policy_test.py +++ /dev/null @@ -1,64 +0,0 @@ -import numpy as np -from absl.testing import absltest, parameterized -from gymnasium.spaces import Box, Dict, Discrete -from skimage import data - -from rt1_pytorch.rt1_policy import RT1Policy - - -class RT1PolicyTest(parameterized.TestCase): - @parameterized.parameters(["cpu", "cuda"]) - def test_policy_act_and_loss(self, device="cpu"): - observation_space = Dict( - image=Box(low=0, high=255, shape=(300, 451, 3), dtype=np.uint8), - context=Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), - base_displacement_vertical_rotation=Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 - ), - gripper_closedness_action=Box( - low=-1.0, high=1.0, shape=(1,), dtype=np.float32 - ), - terminate_episode=Discrete(3), - base_displacement_vector=Box( - low=-1.0, - high=1.0, - shape=(3,), - dtype=np.float32, - ), - rotation_delta=Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 - ), - ) - policy = RT1Policy(observation_space, action_space, device=device) - - image = data.chelsea() - videos = np.reshape(image, (1, 1, *image.shape)).repeat(6, axis=1) - # videos (b, f, h, w, c) = (1, 6, 300, 451, 3) - context = np.random.rand(1, 6, 512).astype(np.float32) - # context (b, f, d) = (1, 6, 512) - observations = {"image": videos, "context": context} - actions = policy.act(observations) - - action_tokens = policy.action_tokenizer.tokenize(actions) - - self.assertEqual(action_tokens.shape, (1, 12)) - obs = {k: v[0][0] for k, v in observations.items()} - act = {k: v[0] for k, v in actions.items()} - self.assertTrue(observation_space.contains(obs)) - self.assertTrue(action_space.contains(act)) - - target_actions = { - k: np.expand_dims(v, axis=1).repeat(6, axis=1) for k, v in actions.items() - } - - loss = policy.loss(observations=observations, target_actions=target_actions) - self.assertGreater(loss, 0) - - # TODO (Rohan138): Add more tests - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/token_learner_test.py b/models/main_models/rt1/tests/token_learner_test.py deleted file mode 100644 index a856b256d..000000000 --- a/models/main_models/rt1/tests/token_learner_test.py +++ /dev/null @@ -1,40 +0,0 @@ -"""Tests for token_learner.""" -import unittest - -import torch - -from rt1_pytorch.tokenizers.token_learner import TokenLearner - - -class TokenLearnerTest(unittest.TestCase): - def testTokenLearner_h_w_split(self): - batch = 5 - embedding_dim = 512 - num_tokens = 8 - device = "cuda" if torch.cuda.is_available() else "cpu" - token_learner_layer = TokenLearner( - embedding_dim=embedding_dim, num_tokens=num_tokens, device=device - ) - - inputvec = torch.randn((batch, embedding_dim, 10, 10), device=device) - - learnedtokens = token_learner_layer(inputvec) - self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) - - def testTokenLearner_hw(self): - batch = 5 - embedding_dim = 512 - num_tokens = 8 - device = "cuda" if torch.cuda.is_available() else "cpu" - token_learner_layer = TokenLearner( - embedding_dim=embedding_dim, num_tokens=num_tokens, device=device - ) - - inputvec = torch.randn((batch, embedding_dim, 100), device=device) - - learnedtokens = token_learner_layer(inputvec) - self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) - - -if __name__ == "__main__": - unittest.main() \ No newline at end of file diff --git a/models/main_models/rt1/vd4rl_main.py b/models/main_models/rt1/vd4rl_main.py deleted file mode 100644 index bd7a6dc06..000000000 --- a/models/main_models/rt1/vd4rl_main.py +++ /dev/null @@ -1,389 +0,0 @@ -import argparse -import os -from typing import Dict, Iterable - -import gymnasium as gym -import h5py -import numpy as np -import requests -import torch -import tqdm -import wandb -from dmc2gymnasium import DMCGym -from sentence_transformers import SentenceTransformer -from torch.optim import Adam - -from rt1_pytorch.rt1_policy import RT1Policy - -DATASET_URL = "https://huggingface.co/datasets/conglu/vd4rl/resolve/main/vd4rl/main/{domain}_{task}/expert/84px/{index}_{domain}_{task}_expert.hdf5" -ACTION_REPEAT = 2 - - -class VD4RLEnv(gym.Env): - def __init__( - self, - env_id: str, - embedding: np.ndarray, - embedding_dim: int, - num_frames: int, - dataset_dir: str, - ): - super().__init__() - self.domain, self.task = env_id.split("-") - self.env = DMCGym(self.domain, self.task) - self.embedding = embedding - self.embedding_dim = embedding_dim - self.num_frames = num_frames - self._load_dataset(dataset_dir) - - @property - def observation_space(self): - return gym.spaces.Dict( - { - "image": gym.spaces.Box( - low=0, high=255, shape=(84, 84, 3), dtype=np.uint8 - ), - "embedding": gym.spaces.Box( - low=-1.0, high=1.0, shape=(self.embedding_dim,), dtype=np.float32 - ), - } - ) - - @property - def action_space(self): - return gym.spaces.Dict({"action_key": self.env.action_space}) - - def reset(self): - _, info = self.env.reset() - obs = self.env.render(84, 84) - return ({"image": obs, "embedding": self.embedding}, info) - - def step(self, action): - action = action["action_key"] - term = False - trunc = False - for _ in range(ACTION_REPEAT): - _, r, term, trunc, info = self.env.step(action) - if term or trunc: - break - o = self.env.render(84, 84) - return ({"image": o, "embedding": self.embedding}, r, term, trunc, info) - - def _load_dataset(self, dataset_dir: str): - os.makedirs(dataset_dir, exist_ok=True) - observations = [] - actions = [] - for index in tqdm.trange(4): - file = f"{index}_{self.domain}_{self.task}_expert.hdf5" - path = os.path.join(dataset_dir, file) - if not os.path.exists(path): - url = DATASET_URL.format( - domain=self.domain, - task=self.task, - index=index, - ) - if self.domain == "humanoid" and self.task == "walk": - url = url.rsplit("/")[0] + f"/{index}_expert.hdf5" - response = requests.get(url) - if response.status_code == 200: - with open(path, "wb") as f: - f.write(response.content) - with h5py.File(path, "r") as f: - observations.append(f["observation"][:]) - actions.append(f["action"][:]) - self.observations = np.concatenate(observations) - self.actions = np.concatenate(actions) - - def get_dataset(self, batch_size: int) -> Iterable[Dict]: - # We expect self.num_frames trajectories per episode - num_episodes = np.ceil(batch_size / self.num_frames).astype(int) - # Leftover trajectories from last episode - prev_obs = None - prev_act = None - for idx in range(0, self.actions.shape[0], num_episodes * 501): - # Get `batch_size` number of episodes - obs = self.observations[idx : idx + num_episodes * 501] - act = self.actions[idx : idx + num_episodes * 501] - - # Convert to (b, t, ...) - obs = np.reshape(obs, (num_episodes, 501, *obs.shape[1:])) - act = np.reshape(act, (num_episodes, 501, *act.shape[1:])) - - # drop the last timestep and action from each episode - obs = obs[:, :-1] - act = act[:, :-1] - - # frame-stack by rolling self.num_frames times over t - num_traj = 500 - self.num_frames + 1 - indices = np.stack( - [np.arange(s, s + num_traj) for s in range(self.num_frames)], - axis=-1, - ) - - # (b, t, ...) -> (b, t - f + 1, f, ...) - obs = np.take(obs, indices, axis=1) - act = np.take(act, indices, axis=1) - - # (b, t - f + 1, f, ...) -> (b * (t - f + 1), f, ...) - obs = np.reshape(obs, (num_episodes * num_traj, *obs.shape[2:])) - act = np.reshape(act, (num_episodes * num_traj, *act.shape[2:])) - - # Concatenate with leftover trajectories from last episode - if prev_obs is not None: - obs = np.concatenate([prev_obs, obs], axis=0) - act = np.concatenate([prev_act, act], axis=0) - - for batch in range(0, obs.shape[0], batch_size): - if batch + batch_size > obs.shape[0]: - # Save leftover trajectories and break - prev_obs = obs[batch:] - prev_act = act[batch:] - break - - yield { - "observation": { - "image": obs[batch : batch + batch_size], - "embedding": np.tile( - np.expand_dims(self.embedding, (0, 1)), - (batch_size, self.num_frames, 1), - ), - }, - "action": {"action_key": act[batch : batch + batch_size]}, - } - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--env", - type=str, - default="walker-walk", - help="name of the environment", - choices=[ - "walker-walk", - "cheetah-run", - "humanoid-walk", - ], - ) - parser.add_argument( - "--context", - type=str, - default="""Move forward by walking upright on two legs, - while maintaining balance and stability""", - ) - # cheetah-run: """Run forward rapidly on all four legs, - # coordinating movements for speed and efficiency""" - parser.add_argument( - "--epochs", - type=int, - default=10, - help="number of training epochs", - ) - parser.add_argument( - "--lr", - type=float, - default=1e-4, - help="learning rate", - ) - parser.add_argument( - "--batch-size", - type=int, - default=32, - help="batch size in number of trajectories", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=4, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default="all-MiniLM-L6-v2", - help="SentenceTransformer to use for text embedding", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--eval-freq", - type=int, - default=None, - help="eval frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-freq", - type=int, - default=None, - help="checkpoint frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-dir", - type=str, - default="checkpoints/vd4rl", - help="directory to save checkpoints", - ) - parser.add_argument( - "--load-checkpoint", - type=str, - default=None, - help="checkpoint to load from; defaults to None", - ) - parser.add_argument( - "--dataset-dir", - type=str, - default="datasets", - help="local directory for datasets", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - if args.wandb: - wandb.init(project="rt1-vd4rl", config=vars(args)) - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - text_embedding_model = SentenceTransformer(args.sentence_transformer) - embedding_dim = text_embedding_model.get_sentence_embedding_dimension() - embedding = text_embedding_model.encode(args.context) - - print("Loading dataset...") - env = VD4RLEnv( - env_id=args.env, - embedding=embedding, - embedding_dim=embedding_dim, - num_frames=args.trajectory_length, - dataset_dir=args.dataset_dir, - ) - - print("Building policy...") - policy = RT1Policy( - observation_space=env.observation_space, - action_space=env.action_space, - arch="efficientnet_b0", - action_bins=512, - num_layers=4, - num_heads=4, - feed_forward_size=512, - dropout_rate=0.01, - time_sequence_length=args.trajectory_length, - embedding_dim=embedding_dim, - use_token_learner=True, - token_learner_bottleneck_dim=32, - token_learner_num_output_tokens=8, - device=args.device, - checkpoint_path=args.load_checkpoint, - ) - policy.model.train() - optimizer = Adam(policy.model.parameters(), lr=args.lr) - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - def get_text_embedding(observation: Dict): - return observation["embedding"] - - print("Training...") - num_batches = 0 - for epoch in range(1, args.epochs + 1): - train_dataset = env.get_dataset(batch_size=args.batch_size) - for batch in train_dataset: - policy.model.train() - num_batches += 1 - observations = { - "image": batch["observation"]["image"], - "context": get_text_embedding(batch["observation"]), - } - actions = batch["action"] - loss = policy.loss(observations, actions) - if args.wandb: - wandb.log( - {"train_loss": loss.item()}, - step=num_batches * args.batch_size, - ) - else: - print(f"Batch {num_batches} train loss: {loss.item()}") - optimizer.zero_grad() - loss.backward() - optimizer.step() - if args.eval_freq and num_batches % args.eval_freq == 0: - print("Evaluating...") - policy.model.eval() - obs, _ = env.reset() - obs_stacked = { - k: np.stack([v for _ in range(args.trajectory_length)]) - for k, v in obs.items() - } - observations = {"image": [], "context": []} - actions = {"action_key": []} - term = False - trunc = False - reward = 0.0 - ts = 0 - while not (term or trunc): - cur_obs = { - "image": obs_stacked["image"], - "context": get_text_embedding(obs_stacked), - } - - # add batch dimension - cur_obs["image"] = np.expand_dims(cur_obs["image"], axis=0) - cur_obs["context"] = np.expand_dims(cur_obs["context"], axis=0) - - act = policy.act(cur_obs) - - # remove batch dimension - act = {k: v[0] for k, v in act.items()} - new_obs, rew, term, trunc, info = env.step(act) - obs_stacked = { - k: np.concatenate( - [ - obs_stacked[k][1:], - np.expand_dims(new_obs[k], axis=0), - ] - ) - for k in new_obs.keys() - } - observations["image"].append(obs_stacked["image"]) - observations["context"].append(get_text_embedding(obs_stacked)) - actions["action_key"].append(act["action_key"]) - reward += rew * (info["discount"] ** ts) - ts += 1 - if args.wandb: - wandb.log( - {"eval_return": reward}, - step=num_batches * args.batch_size, - ) - else: - print(f"Batch {num_batches} eval return: {reward}") - if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: - checkpoint_path = ( - f"{args.checkpoint_dir}/checkpoint_" - + f"{num_batches * args.batch_size * epoch}" - + f"_loss_{loss.item():.3f}.pt" - ) - torch.save(policy.model.state_dict(), checkpoint_path) - print(f"Saved checkpoint to {checkpoint_path}") - - -if __name__ == "__main__": - main() \ No newline at end of file From 6fc446d60108cf21e024b9b58305d6a6cd63e766 Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 18:52:08 -0400 Subject: [PATCH 09/12] reformatting codebase for merging --- models/main_models/rt1/LICENSE | 21 + .../rt1/Open_X_Embodiment_Datasets.ipynb | 2303 ++++++++++ models/main_models/rt1/README.md | 66 + models/main_models/rt1/ai2thor_env.py | 641 +++ models/main_models/rt1/data.py | 536 +++ models/main_models/rt1/figures/rt1.png | Bin 0 -> 135877 bytes models/main_models/rt1/gen/README.md | 77 + models/main_models/rt1/gen/__init__.py | 0 .../main_models/rt1/gen/agents/agent_base.py | 60 + .../gen/agents/deterministic_planner_agent.py | 26 + .../main_models/rt1/gen/agents/plan_agent.py | 94 + .../gen/agents/semantic_map_planner_agent.py | 72 + models/main_models/rt1/gen/constants.py | 1221 ++++++ .../main_models/rt1/gen/ff_planner/README.md | 13 + .../rt1/gen/ff_planner/expressions.c | 2623 +++++++++++ .../rt1/gen/ff_planner/expressions.h | 106 + models/main_models/rt1/gen/ff_planner/ff.h | 2044 +++++++++ .../rt1/gen/ff_planner/inst_easy.c | 1220 ++++++ .../rt1/gen/ff_planner/inst_easy.h | 73 + .../rt1/gen/ff_planner/inst_final.c | 2797 ++++++++++++ .../rt1/gen/ff_planner/inst_final.h | 69 + .../rt1/gen/ff_planner/inst_hard.c | 1306 ++++++ .../rt1/gen/ff_planner/inst_hard.h | 71 + .../main_models/rt1/gen/ff_planner/inst_pre.c | 3854 +++++++++++++++++ .../main_models/rt1/gen/ff_planner/inst_pre.h | 123 + .../rt1/gen/ff_planner/lex-fct_pddl.l | 139 + .../rt1/gen/ff_planner/lex-ops_pddl.l | 151 + models/main_models/rt1/gen/ff_planner/main.c | 1230 ++++++ .../main_models/rt1/gen/ff_planner/makefile | 89 + .../main_models/rt1/gen/ff_planner/memory.c | 1278 ++++++ .../main_models/rt1/gen/ff_planner/memory.h | 109 + .../main_models/rt1/gen/ff_planner/output.c | 1482 +++++++ .../main_models/rt1/gen/ff_planner/output.h | 68 + models/main_models/rt1/gen/ff_planner/parse.c | 1339 ++++++ models/main_models/rt1/gen/ff_planner/parse.h | 63 + models/main_models/rt1/gen/ff_planner/relax.c | 2756 ++++++++++++ models/main_models/rt1/gen/ff_planner/relax.h | 93 + .../rt1/gen/ff_planner/run_sample.sh | 2 + .../ff_planner/samples/PutTask_domain.pddl | 152 + .../gen/ff_planner/samples/problem_0_0.pddl | 390 ++ .../rt1/gen/ff_planner/scan-fct_pddl.y | 918 ++++ .../rt1/gen/ff_planner/scan-ops_pddl.y | 1086 +++++ .../main_models/rt1/gen/ff_planner/search.c | 2372 ++++++++++ .../main_models/rt1/gen/ff_planner/search.h | 105 + .../rt1/gen/game_states/__init__.py | 0 .../rt1/gen/game_states/game_state_base.py | 935 ++++ .../rt1/gen/game_states/planned_game_state.py | 490 +++ .../rt1/gen/game_states/task_game_state.py | 368 ++ .../task_game_state_full_knowledge.py | 444 ++ models/main_models/rt1/gen/goal_library.py | 682 +++ models/main_models/rt1/gen/graph/__init__.py | 0 models/main_models/rt1/gen/graph/graph_obj.py | 426 ++ .../rt1/gen/layouts/FloorPlan1-layout.npy | Bin 0 -> 2064 bytes .../rt1/gen/layouts/FloorPlan1-objects.json | 51 + .../rt1/gen/layouts/FloorPlan1-openable.json | 146 + .../rt1/gen/layouts/FloorPlan10-layout.npy | Bin 0 -> 3488 bytes .../rt1/gen/layouts/FloorPlan10-objects.json | 49 + .../rt1/gen/layouts/FloorPlan10-openable.json | 110 + .../rt1/gen/layouts/FloorPlan11-layout.npy | Bin 0 -> 1104 bytes .../rt1/gen/layouts/FloorPlan11-objects.json | 43 + .../rt1/gen/layouts/FloorPlan11-openable.json | 128 + .../rt1/gen/layouts/FloorPlan12-layout.npy | Bin 0 -> 1808 bytes .../rt1/gen/layouts/FloorPlan12-objects.json | 40 + .../rt1/gen/layouts/FloorPlan12-openable.json | 218 + .../rt1/gen/layouts/FloorPlan13-layout.npy | Bin 0 -> 3008 bytes .../rt1/gen/layouts/FloorPlan13-objects.json | 43 + .../rt1/gen/layouts/FloorPlan13-openable.json | 224 + .../rt1/gen/layouts/FloorPlan14-layout.npy | Bin 0 -> 1968 bytes .../rt1/gen/layouts/FloorPlan14-objects.json | 40 + .../rt1/gen/layouts/FloorPlan14-openable.json | 68 + .../rt1/gen/layouts/FloorPlan15-layout.npy | Bin 0 -> 1616 bytes .../rt1/gen/layouts/FloorPlan15-objects.json | 45 + .../rt1/gen/layouts/FloorPlan15-openable.json | 92 + .../rt1/gen/layouts/FloorPlan16-layout.npy | Bin 0 -> 3312 bytes .../rt1/gen/layouts/FloorPlan16-objects.json | 46 + .../rt1/gen/layouts/FloorPlan16-openable.json | 200 + .../rt1/gen/layouts/FloorPlan17-layout.npy | Bin 0 -> 1168 bytes .../rt1/gen/layouts/FloorPlan17-objects.json | 47 + .../rt1/gen/layouts/FloorPlan17-openable.json | 140 + .../rt1/gen/layouts/FloorPlan18-layout.npy | Bin 0 -> 3600 bytes .../rt1/gen/layouts/FloorPlan18-objects.json | 48 + .../rt1/gen/layouts/FloorPlan18-openable.json | 146 + .../rt1/gen/layouts/FloorPlan19-layout.npy | Bin 0 -> 1184 bytes .../rt1/gen/layouts/FloorPlan19-objects.json | 40 + .../rt1/gen/layouts/FloorPlan19-openable.json | 182 + .../rt1/gen/layouts/FloorPlan2-layout.npy | Bin 0 -> 1968 bytes .../rt1/gen/layouts/FloorPlan2-objects.json | 43 + .../rt1/gen/layouts/FloorPlan2-openable.json | 164 + .../rt1/gen/layouts/FloorPlan20-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan20-objects.json | 46 + .../rt1/gen/layouts/FloorPlan20-openable.json | 116 + .../rt1/gen/layouts/FloorPlan201-layout.npy | Bin 0 -> 3232 bytes .../rt1/gen/layouts/FloorPlan201-objects.json | 37 + .../gen/layouts/FloorPlan201-openable.json | 86 + .../rt1/gen/layouts/FloorPlan202-layout.npy | Bin 0 -> 2496 bytes .../rt1/gen/layouts/FloorPlan202-objects.json | 26 + .../gen/layouts/FloorPlan202-openable.json | 44 + .../rt1/gen/layouts/FloorPlan203-layout.npy | Bin 0 -> 8512 bytes .../rt1/gen/layouts/FloorPlan203-objects.json | 35 + .../gen/layouts/FloorPlan203-openable.json | 86 + .../rt1/gen/layouts/FloorPlan204-layout.npy | Bin 0 -> 2960 bytes .../rt1/gen/layouts/FloorPlan204-objects.json | 31 + .../gen/layouts/FloorPlan204-openable.json | 146 + .../rt1/gen/layouts/FloorPlan205-layout.npy | Bin 0 -> 4112 bytes .../rt1/gen/layouts/FloorPlan205-objects.json | 29 + .../gen/layouts/FloorPlan205-openable.json | 80 + .../rt1/gen/layouts/FloorPlan206-layout.npy | Bin 0 -> 1904 bytes .../rt1/gen/layouts/FloorPlan206-objects.json | 26 + .../gen/layouts/FloorPlan206-openable.json | 122 + .../rt1/gen/layouts/FloorPlan207-layout.npy | Bin 0 -> 2352 bytes .../rt1/gen/layouts/FloorPlan207-objects.json | 27 + .../gen/layouts/FloorPlan207-openable.json | 98 + .../rt1/gen/layouts/FloorPlan208-layout.npy | Bin 0 -> 3376 bytes .../rt1/gen/layouts/FloorPlan208-objects.json | 26 + .../gen/layouts/FloorPlan208-openable.json | 98 + .../rt1/gen/layouts/FloorPlan209-layout.npy | Bin 0 -> 4816 bytes .../rt1/gen/layouts/FloorPlan209-objects.json | 31 + .../gen/layouts/FloorPlan209-openable.json | 62 + .../rt1/gen/layouts/FloorPlan21-layout.npy | Bin 0 -> 1584 bytes .../rt1/gen/layouts/FloorPlan21-objects.json | 47 + .../rt1/gen/layouts/FloorPlan21-openable.json | 86 + .../rt1/gen/layouts/FloorPlan210-layout.npy | Bin 0 -> 4160 bytes .../rt1/gen/layouts/FloorPlan210-objects.json | 30 + .../gen/layouts/FloorPlan210-openable.json | 98 + .../rt1/gen/layouts/FloorPlan211-layout.npy | Bin 0 -> 2240 bytes .../rt1/gen/layouts/FloorPlan211-objects.json | 30 + .../gen/layouts/FloorPlan211-openable.json | 74 + .../rt1/gen/layouts/FloorPlan212-layout.npy | Bin 0 -> 1856 bytes .../rt1/gen/layouts/FloorPlan212-objects.json | 30 + .../gen/layouts/FloorPlan212-openable.json | 80 + .../rt1/gen/layouts/FloorPlan213-layout.npy | Bin 0 -> 4736 bytes .../rt1/gen/layouts/FloorPlan213-objects.json | 27 + .../gen/layouts/FloorPlan213-openable.json | 146 + .../rt1/gen/layouts/FloorPlan214-layout.npy | Bin 0 -> 3024 bytes .../rt1/gen/layouts/FloorPlan214-objects.json | 29 + .../gen/layouts/FloorPlan214-openable.json | 56 + .../rt1/gen/layouts/FloorPlan215-layout.npy | Bin 0 -> 6208 bytes .../rt1/gen/layouts/FloorPlan215-objects.json | 30 + .../gen/layouts/FloorPlan215-openable.json | 92 + .../rt1/gen/layouts/FloorPlan216-layout.npy | Bin 0 -> 2560 bytes .../rt1/gen/layouts/FloorPlan216-objects.json | 28 + .../gen/layouts/FloorPlan216-openable.json | 68 + .../rt1/gen/layouts/FloorPlan217-layout.npy | Bin 0 -> 2240 bytes .../rt1/gen/layouts/FloorPlan217-objects.json | 29 + .../gen/layouts/FloorPlan217-openable.json | 92 + .../rt1/gen/layouts/FloorPlan218-layout.npy | Bin 0 -> 6400 bytes .../rt1/gen/layouts/FloorPlan218-objects.json | 30 + .../gen/layouts/FloorPlan218-openable.json | 68 + .../rt1/gen/layouts/FloorPlan219-layout.npy | Bin 0 -> 3552 bytes .../rt1/gen/layouts/FloorPlan219-objects.json | 31 + .../gen/layouts/FloorPlan219-openable.json | 158 + .../rt1/gen/layouts/FloorPlan22-layout.npy | Bin 0 -> 2256 bytes .../rt1/gen/layouts/FloorPlan22-objects.json | 42 + .../rt1/gen/layouts/FloorPlan22-openable.json | 176 + .../rt1/gen/layouts/FloorPlan220-layout.npy | Bin 0 -> 3712 bytes .../rt1/gen/layouts/FloorPlan220-objects.json | 30 + .../gen/layouts/FloorPlan220-openable.json | 92 + .../rt1/gen/layouts/FloorPlan221-layout.npy | Bin 0 -> 1904 bytes .../rt1/gen/layouts/FloorPlan221-objects.json | 29 + .../gen/layouts/FloorPlan221-openable.json | 44 + .../rt1/gen/layouts/FloorPlan222-layout.npy | Bin 0 -> 1648 bytes .../rt1/gen/layouts/FloorPlan222-objects.json | 26 + .../gen/layouts/FloorPlan222-openable.json | 86 + .../rt1/gen/layouts/FloorPlan223-layout.npy | Bin 0 -> 3344 bytes .../rt1/gen/layouts/FloorPlan223-objects.json | 28 + .../gen/layouts/FloorPlan223-openable.json | 50 + .../rt1/gen/layouts/FloorPlan224-layout.npy | Bin 0 -> 4688 bytes .../rt1/gen/layouts/FloorPlan224-objects.json | 32 + .../gen/layouts/FloorPlan224-openable.json | 182 + .../rt1/gen/layouts/FloorPlan225-layout.npy | Bin 0 -> 2576 bytes .../rt1/gen/layouts/FloorPlan225-objects.json | 31 + .../gen/layouts/FloorPlan225-openable.json | 86 + .../rt1/gen/layouts/FloorPlan226-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan226-objects.json | 25 + .../gen/layouts/FloorPlan226-openable.json | 68 + .../rt1/gen/layouts/FloorPlan227-layout.npy | Bin 0 -> 3232 bytes .../rt1/gen/layouts/FloorPlan227-objects.json | 28 + .../gen/layouts/FloorPlan227-openable.json | 206 + .../rt1/gen/layouts/FloorPlan228-layout.npy | Bin 0 -> 2576 bytes .../rt1/gen/layouts/FloorPlan228-objects.json | 27 + .../gen/layouts/FloorPlan228-openable.json | 62 + .../rt1/gen/layouts/FloorPlan229-layout.npy | Bin 0 -> 3088 bytes .../rt1/gen/layouts/FloorPlan229-objects.json | 32 + .../gen/layouts/FloorPlan229-openable.json | 68 + .../rt1/gen/layouts/FloorPlan23-layout.npy | Bin 0 -> 1648 bytes .../rt1/gen/layouts/FloorPlan23-objects.json | 47 + .../rt1/gen/layouts/FloorPlan23-openable.json | 98 + .../rt1/gen/layouts/FloorPlan230-layout.npy | Bin 0 -> 6448 bytes .../rt1/gen/layouts/FloorPlan230-objects.json | 32 + .../gen/layouts/FloorPlan230-openable.json | 56 + .../rt1/gen/layouts/FloorPlan24-layout.npy | Bin 0 -> 1152 bytes .../rt1/gen/layouts/FloorPlan24-objects.json | 42 + .../rt1/gen/layouts/FloorPlan24-openable.json | 176 + .../rt1/gen/layouts/FloorPlan25-layout.npy | Bin 0 -> 560 bytes .../rt1/gen/layouts/FloorPlan25-objects.json | 41 + .../rt1/gen/layouts/FloorPlan25-openable.json | 92 + .../rt1/gen/layouts/FloorPlan26-layout.npy | Bin 0 -> 1344 bytes .../rt1/gen/layouts/FloorPlan26-objects.json | 40 + .../rt1/gen/layouts/FloorPlan26-openable.json | 92 + .../rt1/gen/layouts/FloorPlan27-layout.npy | Bin 0 -> 784 bytes .../rt1/gen/layouts/FloorPlan27-objects.json | 43 + .../rt1/gen/layouts/FloorPlan27-openable.json | 128 + .../rt1/gen/layouts/FloorPlan28-layout.npy | Bin 0 -> 1712 bytes .../rt1/gen/layouts/FloorPlan28-objects.json | 43 + .../rt1/gen/layouts/FloorPlan28-openable.json | 122 + .../rt1/gen/layouts/FloorPlan29-layout.npy | Bin 0 -> 1168 bytes .../rt1/gen/layouts/FloorPlan29-objects.json | 39 + .../rt1/gen/layouts/FloorPlan29-openable.json | 80 + .../rt1/gen/layouts/FloorPlan3-layout.npy | Bin 0 -> 1856 bytes .../rt1/gen/layouts/FloorPlan3-objects.json | 45 + .../rt1/gen/layouts/FloorPlan3-openable.json | 110 + .../rt1/gen/layouts/FloorPlan30-layout.npy | Bin 0 -> 1296 bytes .../rt1/gen/layouts/FloorPlan30-objects.json | 45 + .../rt1/gen/layouts/FloorPlan30-openable.json | 218 + .../rt1/gen/layouts/FloorPlan301-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan301-objects.json | 35 + .../gen/layouts/FloorPlan301-openable.json | 122 + .../rt1/gen/layouts/FloorPlan302-layout.npy | Bin 0 -> 848 bytes .../rt1/gen/layouts/FloorPlan302-objects.json | 31 + .../gen/layouts/FloorPlan302-openable.json | 80 + .../rt1/gen/layouts/FloorPlan303-layout.npy | Bin 0 -> 1168 bytes .../rt1/gen/layouts/FloorPlan303-objects.json | 35 + .../gen/layouts/FloorPlan303-openable.json | 122 + .../rt1/gen/layouts/FloorPlan304-layout.npy | Bin 0 -> 1808 bytes .../rt1/gen/layouts/FloorPlan304-objects.json | 30 + .../gen/layouts/FloorPlan304-openable.json | 26 + .../rt1/gen/layouts/FloorPlan305-layout.npy | Bin 0 -> 1472 bytes .../rt1/gen/layouts/FloorPlan305-objects.json | 32 + .../gen/layouts/FloorPlan305-openable.json | 62 + .../rt1/gen/layouts/FloorPlan306-layout.npy | Bin 0 -> 1632 bytes .../rt1/gen/layouts/FloorPlan306-objects.json | 27 + .../gen/layouts/FloorPlan306-openable.json | 68 + .../rt1/gen/layouts/FloorPlan307-layout.npy | Bin 0 -> 1424 bytes .../rt1/gen/layouts/FloorPlan307-objects.json | 34 + .../gen/layouts/FloorPlan307-openable.json | 104 + .../rt1/gen/layouts/FloorPlan308-layout.npy | Bin 0 -> 1744 bytes .../rt1/gen/layouts/FloorPlan308-objects.json | 30 + .../gen/layouts/FloorPlan308-openable.json | 104 + .../rt1/gen/layouts/FloorPlan309-layout.npy | Bin 0 -> 5760 bytes .../rt1/gen/layouts/FloorPlan309-objects.json | 33 + .../gen/layouts/FloorPlan309-openable.json | 74 + .../rt1/gen/layouts/FloorPlan310-layout.npy | Bin 0 -> 1152 bytes .../rt1/gen/layouts/FloorPlan310-objects.json | 31 + .../gen/layouts/FloorPlan310-openable.json | 50 + .../rt1/gen/layouts/FloorPlan311-layout.npy | Bin 0 -> 3760 bytes .../rt1/gen/layouts/FloorPlan311-objects.json | 32 + .../gen/layouts/FloorPlan311-openable.json | 56 + .../rt1/gen/layouts/FloorPlan312-layout.npy | Bin 0 -> 1440 bytes .../rt1/gen/layouts/FloorPlan312-objects.json | 27 + .../gen/layouts/FloorPlan312-openable.json | 74 + .../rt1/gen/layouts/FloorPlan313-layout.npy | Bin 0 -> 880 bytes .../rt1/gen/layouts/FloorPlan313-objects.json | 34 + .../gen/layouts/FloorPlan313-openable.json | 80 + .../rt1/gen/layouts/FloorPlan314-layout.npy | Bin 0 -> 1200 bytes .../rt1/gen/layouts/FloorPlan314-objects.json | 27 + .../gen/layouts/FloorPlan314-openable.json | 50 + .../rt1/gen/layouts/FloorPlan315-layout.npy | Bin 0 -> 1712 bytes .../rt1/gen/layouts/FloorPlan315-objects.json | 28 + .../gen/layouts/FloorPlan315-openable.json | 110 + .../rt1/gen/layouts/FloorPlan316-layout.npy | Bin 0 -> 1056 bytes .../rt1/gen/layouts/FloorPlan316-objects.json | 30 + .../gen/layouts/FloorPlan316-openable.json | 44 + .../rt1/gen/layouts/FloorPlan317-layout.npy | Bin 0 -> 1680 bytes .../rt1/gen/layouts/FloorPlan317-objects.json | 30 + .../gen/layouts/FloorPlan317-openable.json | 92 + .../rt1/gen/layouts/FloorPlan318-layout.npy | Bin 0 -> 1632 bytes .../rt1/gen/layouts/FloorPlan318-objects.json | 31 + .../gen/layouts/FloorPlan318-openable.json | 158 + .../rt1/gen/layouts/FloorPlan319-layout.npy | Bin 0 -> 1680 bytes .../rt1/gen/layouts/FloorPlan319-objects.json | 30 + .../gen/layouts/FloorPlan319-openable.json | 122 + .../rt1/gen/layouts/FloorPlan320-layout.npy | Bin 0 -> 1200 bytes .../rt1/gen/layouts/FloorPlan320-objects.json | 30 + .../gen/layouts/FloorPlan320-openable.json | 50 + .../rt1/gen/layouts/FloorPlan321-layout.npy | Bin 0 -> 1600 bytes .../rt1/gen/layouts/FloorPlan321-objects.json | 27 + .../gen/layouts/FloorPlan321-openable.json | 44 + .../rt1/gen/layouts/FloorPlan322-layout.npy | Bin 0 -> 1792 bytes .../rt1/gen/layouts/FloorPlan322-objects.json | 30 + .../gen/layouts/FloorPlan322-openable.json | 122 + .../rt1/gen/layouts/FloorPlan323-layout.npy | Bin 0 -> 3184 bytes .../rt1/gen/layouts/FloorPlan323-objects.json | 30 + .../gen/layouts/FloorPlan323-openable.json | 80 + .../rt1/gen/layouts/FloorPlan324-layout.npy | Bin 0 -> 1552 bytes .../rt1/gen/layouts/FloorPlan324-objects.json | 29 + .../gen/layouts/FloorPlan324-openable.json | 110 + .../rt1/gen/layouts/FloorPlan325-layout.npy | Bin 0 -> 3040 bytes .../rt1/gen/layouts/FloorPlan325-objects.json | 28 + .../gen/layouts/FloorPlan325-openable.json | 140 + .../rt1/gen/layouts/FloorPlan326-layout.npy | Bin 0 -> 1728 bytes .../rt1/gen/layouts/FloorPlan326-objects.json | 35 + .../gen/layouts/FloorPlan326-openable.json | 128 + .../rt1/gen/layouts/FloorPlan327-layout.npy | Bin 0 -> 1392 bytes .../rt1/gen/layouts/FloorPlan327-objects.json | 29 + .../gen/layouts/FloorPlan327-openable.json | 92 + .../rt1/gen/layouts/FloorPlan328-layout.npy | Bin 0 -> 1104 bytes .../rt1/gen/layouts/FloorPlan328-objects.json | 31 + .../gen/layouts/FloorPlan328-openable.json | 44 + .../rt1/gen/layouts/FloorPlan329-layout.npy | Bin 0 -> 1536 bytes .../rt1/gen/layouts/FloorPlan329-objects.json | 28 + .../gen/layouts/FloorPlan329-openable.json | 50 + .../rt1/gen/layouts/FloorPlan330-layout.npy | Bin 0 -> 2240 bytes .../rt1/gen/layouts/FloorPlan330-objects.json | 32 + .../gen/layouts/FloorPlan330-openable.json | 122 + .../rt1/gen/layouts/FloorPlan4-layout.npy | Bin 0 -> 1232 bytes .../rt1/gen/layouts/FloorPlan4-objects.json | 42 + .../rt1/gen/layouts/FloorPlan4-openable.json | 98 + .../rt1/gen/layouts/FloorPlan401-layout.npy | Bin 0 -> 1616 bytes .../rt1/gen/layouts/FloorPlan401-objects.json | 32 + .../gen/layouts/FloorPlan401-openable.json | 56 + .../rt1/gen/layouts/FloorPlan402-layout.npy | Bin 0 -> 1584 bytes .../rt1/gen/layouts/FloorPlan402-objects.json | 33 + .../gen/layouts/FloorPlan402-openable.json | 92 + .../rt1/gen/layouts/FloorPlan403-layout.npy | Bin 0 -> 1008 bytes .../rt1/gen/layouts/FloorPlan403-objects.json | 34 + .../gen/layouts/FloorPlan403-openable.json | 50 + .../rt1/gen/layouts/FloorPlan404-layout.npy | Bin 0 -> 1008 bytes .../rt1/gen/layouts/FloorPlan404-objects.json | 29 + .../gen/layouts/FloorPlan404-openable.json | 38 + .../rt1/gen/layouts/FloorPlan405-layout.npy | Bin 0 -> 576 bytes .../rt1/gen/layouts/FloorPlan405-objects.json | 28 + .../gen/layouts/FloorPlan405-openable.json | 56 + .../rt1/gen/layouts/FloorPlan406-layout.npy | Bin 0 -> 1664 bytes .../rt1/gen/layouts/FloorPlan406-objects.json | 28 + .../gen/layouts/FloorPlan406-openable.json | 26 + .../rt1/gen/layouts/FloorPlan407-layout.npy | Bin 0 -> 672 bytes .../rt1/gen/layouts/FloorPlan407-objects.json | 32 + .../gen/layouts/FloorPlan407-openable.json | 56 + .../rt1/gen/layouts/FloorPlan408-layout.npy | Bin 0 -> 704 bytes .../rt1/gen/layouts/FloorPlan408-objects.json | 28 + .../gen/layouts/FloorPlan408-openable.json | 62 + .../rt1/gen/layouts/FloorPlan409-layout.npy | Bin 0 -> 752 bytes .../rt1/gen/layouts/FloorPlan409-objects.json | 28 + .../gen/layouts/FloorPlan409-openable.json | 62 + .../rt1/gen/layouts/FloorPlan410-layout.npy | Bin 0 -> 1408 bytes .../rt1/gen/layouts/FloorPlan410-objects.json | 29 + .../gen/layouts/FloorPlan410-openable.json | 74 + .../rt1/gen/layouts/FloorPlan411-layout.npy | Bin 0 -> 1104 bytes .../rt1/gen/layouts/FloorPlan411-objects.json | 31 + .../gen/layouts/FloorPlan411-openable.json | 62 + .../rt1/gen/layouts/FloorPlan412-layout.npy | Bin 0 -> 784 bytes .../rt1/gen/layouts/FloorPlan412-objects.json | 29 + .../gen/layouts/FloorPlan412-openable.json | 50 + .../rt1/gen/layouts/FloorPlan413-layout.npy | Bin 0 -> 1216 bytes .../rt1/gen/layouts/FloorPlan413-objects.json | 32 + .../gen/layouts/FloorPlan413-openable.json | 92 + .../rt1/gen/layouts/FloorPlan414-layout.npy | Bin 0 -> 800 bytes .../rt1/gen/layouts/FloorPlan414-objects.json | 31 + .../gen/layouts/FloorPlan414-openable.json | 92 + .../rt1/gen/layouts/FloorPlan415-layout.npy | Bin 0 -> 880 bytes .../rt1/gen/layouts/FloorPlan415-objects.json | 31 + .../gen/layouts/FloorPlan415-openable.json | 68 + .../rt1/gen/layouts/FloorPlan416-layout.npy | Bin 0 -> 992 bytes .../rt1/gen/layouts/FloorPlan416-objects.json | 28 + .../gen/layouts/FloorPlan416-openable.json | 44 + .../rt1/gen/layouts/FloorPlan417-layout.npy | Bin 0 -> 1088 bytes .../rt1/gen/layouts/FloorPlan417-objects.json | 29 + .../gen/layouts/FloorPlan417-openable.json | 44 + .../rt1/gen/layouts/FloorPlan418-layout.npy | Bin 0 -> 864 bytes .../rt1/gen/layouts/FloorPlan418-objects.json | 29 + .../gen/layouts/FloorPlan418-openable.json | 44 + .../rt1/gen/layouts/FloorPlan419-layout.npy | Bin 0 -> 608 bytes .../rt1/gen/layouts/FloorPlan419-objects.json | 30 + .../gen/layouts/FloorPlan419-openable.json | 44 + .../rt1/gen/layouts/FloorPlan420-layout.npy | Bin 0 -> 560 bytes .../rt1/gen/layouts/FloorPlan420-objects.json | 29 + .../gen/layouts/FloorPlan420-openable.json | 32 + .../rt1/gen/layouts/FloorPlan421-layout.npy | Bin 0 -> 608 bytes .../rt1/gen/layouts/FloorPlan421-objects.json | 29 + .../gen/layouts/FloorPlan421-openable.json | 68 + .../rt1/gen/layouts/FloorPlan422-layout.npy | Bin 0 -> 656 bytes .../rt1/gen/layouts/FloorPlan422-objects.json | 33 + .../gen/layouts/FloorPlan422-openable.json | 86 + .../rt1/gen/layouts/FloorPlan423-layout.npy | Bin 0 -> 1008 bytes .../rt1/gen/layouts/FloorPlan423-objects.json | 32 + .../gen/layouts/FloorPlan423-openable.json | 86 + .../rt1/gen/layouts/FloorPlan424-layout.npy | Bin 0 -> 736 bytes .../rt1/gen/layouts/FloorPlan424-objects.json | 28 + .../gen/layouts/FloorPlan424-openable.json | 56 + .../rt1/gen/layouts/FloorPlan425-layout.npy | Bin 0 -> 512 bytes .../rt1/gen/layouts/FloorPlan425-objects.json | 30 + .../gen/layouts/FloorPlan425-openable.json | 56 + .../rt1/gen/layouts/FloorPlan426-layout.npy | Bin 0 -> 912 bytes .../rt1/gen/layouts/FloorPlan426-objects.json | 31 + .../gen/layouts/FloorPlan426-openable.json | 68 + .../rt1/gen/layouts/FloorPlan427-layout.npy | Bin 0 -> 992 bytes .../rt1/gen/layouts/FloorPlan427-objects.json | 32 + .../gen/layouts/FloorPlan427-openable.json | 80 + .../rt1/gen/layouts/FloorPlan428-layout.npy | Bin 0 -> 992 bytes .../rt1/gen/layouts/FloorPlan428-objects.json | 28 + .../gen/layouts/FloorPlan428-openable.json | 50 + .../rt1/gen/layouts/FloorPlan429-layout.npy | Bin 0 -> 1152 bytes .../rt1/gen/layouts/FloorPlan429-objects.json | 29 + .../gen/layouts/FloorPlan429-openable.json | 38 + .../rt1/gen/layouts/FloorPlan430-layout.npy | Bin 0 -> 1760 bytes .../rt1/gen/layouts/FloorPlan430-objects.json | 35 + .../gen/layouts/FloorPlan430-openable.json | 50 + .../rt1/gen/layouts/FloorPlan5-layout.npy | Bin 0 -> 1680 bytes .../rt1/gen/layouts/FloorPlan5-objects.json | 47 + .../rt1/gen/layouts/FloorPlan5-openable.json | 152 + .../rt1/gen/layouts/FloorPlan6-layout.npy | Bin 0 -> 2176 bytes .../rt1/gen/layouts/FloorPlan6-objects.json | 42 + .../rt1/gen/layouts/FloorPlan6-openable.json | 164 + .../rt1/gen/layouts/FloorPlan7-layout.npy | Bin 0 -> 4352 bytes .../rt1/gen/layouts/FloorPlan7-objects.json | 50 + .../rt1/gen/layouts/FloorPlan7-openable.json | 146 + .../rt1/gen/layouts/FloorPlan8-layout.npy | Bin 0 -> 2768 bytes .../rt1/gen/layouts/FloorPlan8-objects.json | 46 + .../rt1/gen/layouts/FloorPlan8-openable.json | 170 + .../rt1/gen/layouts/FloorPlan9-layout.npy | Bin 0 -> 1360 bytes .../rt1/gen/layouts/FloorPlan9-objects.json | 42 + .../rt1/gen/layouts/FloorPlan9-openable.json | 260 ++ .../layouts/precompute_layout_locations.py | 350 ++ .../main_models/rt1/gen/planner/__init__.py | 0 .../domains/PutTaskExtended_domain.pddl | 302 ++ .../rt1/gen/planner/ff_planner_handler.py | 252 ++ models/main_models/rt1/gen/planner/pddl.pdf | Bin 0 -> 196613 bytes .../rt1/gen/scripts/augment_trajectories.py | 312 ++ .../rt1/gen/scripts/generate_trajectories.py | 752 ++++ .../rt1/gen/scripts/replay_checks.py | 217 + models/main_models/rt1/gen/utils/__init__.py | 0 models/main_models/rt1/gen/utils/bb_util.py | 139 + .../rt1/gen/utils/dataset_management_util.py | 69 + models/main_models/rt1/gen/utils/game_util.py | 363 ++ .../main_models/rt1/gen/utils/image_util.py | 57 + models/main_models/rt1/gen/utils/py_util.py | 84 + .../main_models/rt1/gen/utils/replay_json.py | 52 + .../main_models/rt1/gen/utils/video_util.py | 11 + .../lanmp_dataloader/attribute_limits.json | 1 + .../rt1/lanmp_dataloader/rt1_dataloader.py | 800 ++++ .../rt1/lanmp_dataloader/scene_to_keys.json | 1 + models/main_models/rt1/main.py | 257 ++ models/main_models/rt1/main_ft.py | 387 ++ models/main_models/rt1/main_ft_eval.py | 279 ++ models/main_models/rt1/rollout_ai2thor.py | 366 ++ .../main_models/rt1/rt1_env/bin/Activate.ps1 | 241 ++ models/main_models/rt1/rt1_env/bin/activate | 66 + .../main_models/rt1/rt1_env/bin/activate.csh | 25 + .../main_models/rt1/rt1_env/bin/activate.fish | 64 + .../main_models/rt1/rt1_env/bin/ai2thor-xorg | 267 ++ .../rt1/rt1_env/bin/convert-caffe2-to-onnx | 10 + .../rt1/rt1_env/bin/convert-onnx-to-caffe2 | 10 + models/main_models/rt1/rt1_env/bin/f2py | 10 + models/main_models/rt1/rt1_env/bin/flask | 10 + .../rt1/rt1_env/bin/huggingface-cli | 10 + .../rt1/rt1_env/bin/imageio_download_bin | 10 + .../rt1/rt1_env/bin/imageio_remove_bin | 10 + .../rt1/rt1_env/bin/import_pb_to_tensorboard | 10 + models/main_models/rt1/rt1_env/bin/isympy | 10 + models/main_models/rt1/rt1_env/bin/jp.py | 54 + models/main_models/rt1/rt1_env/bin/lsm2bin | 10 + .../main_models/rt1/rt1_env/bin/markdown-it | 10 + .../main_models/rt1/rt1_env/bin/markdown_py | 10 + models/main_models/rt1/rt1_env/bin/normalizer | 10 + models/main_models/rt1/rt1_env/bin/pip | 10 + models/main_models/rt1/rt1_env/bin/pip3 | 10 + models/main_models/rt1/rt1_env/bin/pip3.9 | 10 + .../main_models/rt1/rt1_env/bin/portserver.py | 415 ++ .../main_models/rt1/rt1_env/bin/progressbar | 10 + models/main_models/rt1/rt1_env/bin/pygmentize | 10 + models/main_models/rt1/rt1_env/bin/python | 1 + models/main_models/rt1/rt1_env/bin/python3 | 1 + models/main_models/rt1/rt1_env/bin/python3.9 | 1 + models/main_models/rt1/rt1_env/bin/pythoni | 36 + models/main_models/rt1/rt1_env/bin/pythoni1 | 17 + .../main_models/rt1/rt1_env/bin/reverb_server | 10 + .../rt1/rt1_env/bin/saved_model_cli | 10 + .../main_models/rt1/rt1_env/bin/tensorboard | 10 + .../main_models/rt1/rt1_env/bin/tf_upgrade_v2 | 10 + models/main_models/rt1/rt1_env/bin/tfds | 10 + .../rt1/rt1_env/bin/tflite_convert | 10 + .../main_models/rt1/rt1_env/bin/tiff2fsspec | 10 + .../main_models/rt1/rt1_env/bin/tiffcomment | 10 + models/main_models/rt1/rt1_env/bin/tifffile | 10 + models/main_models/rt1/rt1_env/bin/toco | 10 + .../rt1/rt1_env/bin/toco_from_protos | 10 + models/main_models/rt1/rt1_env/bin/torchrun | 10 + models/main_models/rt1/rt1_env/bin/tqdm | 10 + .../rt1/rt1_env/bin/transformers-cli | 10 + models/main_models/rt1/rt1_env/bin/tree-cli | 10 + models/main_models/rt1/rt1_env/bin/wandb | 10 + models/main_models/rt1/rt1_env/bin/wb | 10 + models/main_models/rt1/rt1_env/bin/wheel | 10 + .../site/python3.9/dm-reverb/checkpoint.proto | 77 + .../site/python3.9/dm-reverb/patterns.proto | 123 + .../python3.9/dm-reverb/reverb_config.proto | 10 + .../site/python3.9/dm-reverb/schema.proto | 289 ++ models/main_models/rt1/rt1_env/lib64 | 1 + models/main_models/rt1/rt1_env/pyvenv.cfg | 3 + .../rt1/rt1_env/share/man/man1/isympy.1 | 188 + .../main_models/rt1/rt1_pytorch/__init__.py | 0 .../rt1_pytorch/film_efficientnet/__init__.py | 0 .../film_conditioning_layer.py | 38 + .../film_efficientnet/film_efficientnet.py | 446 ++ .../main_models/rt1/rt1_pytorch/rt1_model.py | 217 + .../main_models/rt1/rt1_pytorch/rt1_policy.py | 234 + .../rt1/rt1_pytorch/tokenizers/__init__.py | 0 .../tokenizers/action_tokenizer.py | 184 + .../rt1_pytorch/tokenizers/image_tokenizer.py | 77 + .../rt1_pytorch/tokenizers/token_learner.py | 89 + models/main_models/rt1/setup.py | 44 + .../rt1/tests/action_tokenizer_test.py | 166 + .../rt1/tests/film_conditioning_layer_test.py | 27 + .../rt1/tests/film_efficientnet_test.py | 57 + .../rt1/tests/image_tokenizer_test.py | 53 + .../main_models/rt1/tests/rt1_model_test.py | 54 + .../main_models/rt1/tests/rt1_policy_test.py | 64 + .../rt1/tests/token_learner_test.py | 40 + models/main_models/rt1/vd4rl_main.py | 389 ++ 509 files changed, 61499 insertions(+) create mode 100644 models/main_models/rt1/LICENSE create mode 100644 models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb create mode 100644 models/main_models/rt1/README.md create mode 100644 models/main_models/rt1/ai2thor_env.py create mode 100644 models/main_models/rt1/data.py create mode 100644 models/main_models/rt1/figures/rt1.png create mode 100644 models/main_models/rt1/gen/README.md create mode 100644 models/main_models/rt1/gen/__init__.py create mode 100644 models/main_models/rt1/gen/agents/agent_base.py create mode 100644 models/main_models/rt1/gen/agents/deterministic_planner_agent.py create mode 100644 models/main_models/rt1/gen/agents/plan_agent.py create mode 100644 models/main_models/rt1/gen/agents/semantic_map_planner_agent.py create mode 100644 models/main_models/rt1/gen/constants.py create mode 100644 models/main_models/rt1/gen/ff_planner/README.md create mode 100644 models/main_models/rt1/gen/ff_planner/expressions.c create mode 100644 models/main_models/rt1/gen/ff_planner/expressions.h create mode 100644 models/main_models/rt1/gen/ff_planner/ff.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_easy.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_easy.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_final.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_final.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_hard.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_hard.h create mode 100644 models/main_models/rt1/gen/ff_planner/inst_pre.c create mode 100644 models/main_models/rt1/gen/ff_planner/inst_pre.h create mode 100644 models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l create mode 100644 models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l create mode 100644 models/main_models/rt1/gen/ff_planner/main.c create mode 100644 models/main_models/rt1/gen/ff_planner/makefile create mode 100644 models/main_models/rt1/gen/ff_planner/memory.c create mode 100644 models/main_models/rt1/gen/ff_planner/memory.h create mode 100644 models/main_models/rt1/gen/ff_planner/output.c create mode 100644 models/main_models/rt1/gen/ff_planner/output.h create mode 100644 models/main_models/rt1/gen/ff_planner/parse.c create mode 100644 models/main_models/rt1/gen/ff_planner/parse.h create mode 100644 models/main_models/rt1/gen/ff_planner/relax.c create mode 100644 models/main_models/rt1/gen/ff_planner/relax.h create mode 100755 models/main_models/rt1/gen/ff_planner/run_sample.sh create mode 100644 models/main_models/rt1/gen/ff_planner/samples/PutTask_domain.pddl create mode 100644 models/main_models/rt1/gen/ff_planner/samples/problem_0_0.pddl create mode 100644 models/main_models/rt1/gen/ff_planner/scan-fct_pddl.y create mode 100644 models/main_models/rt1/gen/ff_planner/scan-ops_pddl.y create mode 100644 models/main_models/rt1/gen/ff_planner/search.c create mode 100644 models/main_models/rt1/gen/ff_planner/search.h create mode 100644 models/main_models/rt1/gen/game_states/__init__.py create mode 100644 models/main_models/rt1/gen/game_states/game_state_base.py create mode 100644 models/main_models/rt1/gen/game_states/planned_game_state.py create mode 100644 models/main_models/rt1/gen/game_states/task_game_state.py create mode 100644 models/main_models/rt1/gen/game_states/task_game_state_full_knowledge.py create mode 100644 models/main_models/rt1/gen/goal_library.py create mode 100644 models/main_models/rt1/gen/graph/__init__.py create mode 100644 models/main_models/rt1/gen/graph/graph_obj.py create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan1-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan10-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan11-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan12-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan13-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan14-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan15-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan16-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan17-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan18-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan19-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan2-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan20-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan201-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan202-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan203-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan204-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan205-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan206-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan207-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan208-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan209-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan21-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan210-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan211-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan212-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan213-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan214-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan215-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan216-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan217-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan218-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan219-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan22-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan220-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan221-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan222-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan223-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan224-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan225-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan226-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan227-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan228-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan229-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan23-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan230-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan24-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan25-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan26-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan27-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan28-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan29-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan3-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan30-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan301-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan302-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan303-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan304-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan305-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan306-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan307-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan308-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan309-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan310-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan311-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan312-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan313-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan314-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan315-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan316-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan317-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan318-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan319-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan320-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan321-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan322-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan323-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan324-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan325-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan326-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan327-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan328-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan329-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan330-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan4-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan401-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan402-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan403-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan404-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan405-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan406-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan407-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan408-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan409-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan410-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan411-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan412-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan413-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan414-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan415-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan416-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan417-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan418-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan419-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan420-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan421-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan422-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan423-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan424-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan425-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan426-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan427-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan428-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan429-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan430-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan5-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan6-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan7-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan8-openable.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-objects.json create mode 100644 models/main_models/rt1/gen/layouts/FloorPlan9-openable.json create mode 100644 models/main_models/rt1/gen/layouts/precompute_layout_locations.py create mode 100644 models/main_models/rt1/gen/planner/__init__.py create mode 100644 models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl create mode 100644 models/main_models/rt1/gen/planner/ff_planner_handler.py create mode 100644 models/main_models/rt1/gen/planner/pddl.pdf create mode 100644 models/main_models/rt1/gen/scripts/augment_trajectories.py create mode 100644 models/main_models/rt1/gen/scripts/generate_trajectories.py create mode 100644 models/main_models/rt1/gen/scripts/replay_checks.py create mode 100644 models/main_models/rt1/gen/utils/__init__.py create mode 100644 models/main_models/rt1/gen/utils/bb_util.py create mode 100644 models/main_models/rt1/gen/utils/dataset_management_util.py create mode 100644 models/main_models/rt1/gen/utils/game_util.py create mode 100644 models/main_models/rt1/gen/utils/image_util.py create mode 100644 models/main_models/rt1/gen/utils/py_util.py create mode 100644 models/main_models/rt1/gen/utils/replay_json.py create mode 100644 models/main_models/rt1/gen/utils/video_util.py create mode 100644 models/main_models/rt1/lanmp_dataloader/attribute_limits.json create mode 100644 models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py create mode 100644 models/main_models/rt1/lanmp_dataloader/scene_to_keys.json create mode 100644 models/main_models/rt1/main.py create mode 100644 models/main_models/rt1/main_ft.py create mode 100644 models/main_models/rt1/main_ft_eval.py create mode 100644 models/main_models/rt1/rollout_ai2thor.py create mode 100644 models/main_models/rt1/rt1_env/bin/Activate.ps1 create mode 100644 models/main_models/rt1/rt1_env/bin/activate create mode 100644 models/main_models/rt1/rt1_env/bin/activate.csh create mode 100644 models/main_models/rt1/rt1_env/bin/activate.fish create mode 100755 models/main_models/rt1/rt1_env/bin/ai2thor-xorg create mode 100755 models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx create mode 100755 models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 create mode 100755 models/main_models/rt1/rt1_env/bin/f2py create mode 100755 models/main_models/rt1/rt1_env/bin/flask create mode 100755 models/main_models/rt1/rt1_env/bin/huggingface-cli create mode 100755 models/main_models/rt1/rt1_env/bin/imageio_download_bin create mode 100755 models/main_models/rt1/rt1_env/bin/imageio_remove_bin create mode 100755 models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard create mode 100755 models/main_models/rt1/rt1_env/bin/isympy create mode 100755 models/main_models/rt1/rt1_env/bin/jp.py create mode 100755 models/main_models/rt1/rt1_env/bin/lsm2bin create mode 100755 models/main_models/rt1/rt1_env/bin/markdown-it create mode 100755 models/main_models/rt1/rt1_env/bin/markdown_py create mode 100755 models/main_models/rt1/rt1_env/bin/normalizer create mode 100755 models/main_models/rt1/rt1_env/bin/pip create mode 100755 models/main_models/rt1/rt1_env/bin/pip3 create mode 100755 models/main_models/rt1/rt1_env/bin/pip3.9 create mode 100755 models/main_models/rt1/rt1_env/bin/portserver.py create mode 100755 models/main_models/rt1/rt1_env/bin/progressbar create mode 100755 models/main_models/rt1/rt1_env/bin/pygmentize create mode 120000 models/main_models/rt1/rt1_env/bin/python create mode 120000 models/main_models/rt1/rt1_env/bin/python3 create mode 120000 models/main_models/rt1/rt1_env/bin/python3.9 create mode 100755 models/main_models/rt1/rt1_env/bin/pythoni create mode 100755 models/main_models/rt1/rt1_env/bin/pythoni1 create mode 100755 models/main_models/rt1/rt1_env/bin/reverb_server create mode 100755 models/main_models/rt1/rt1_env/bin/saved_model_cli create mode 100755 models/main_models/rt1/rt1_env/bin/tensorboard create mode 100755 models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 create mode 100755 models/main_models/rt1/rt1_env/bin/tfds create mode 100755 models/main_models/rt1/rt1_env/bin/tflite_convert create mode 100755 models/main_models/rt1/rt1_env/bin/tiff2fsspec create mode 100755 models/main_models/rt1/rt1_env/bin/tiffcomment create mode 100755 models/main_models/rt1/rt1_env/bin/tifffile create mode 100755 models/main_models/rt1/rt1_env/bin/toco create mode 100755 models/main_models/rt1/rt1_env/bin/toco_from_protos create mode 100755 models/main_models/rt1/rt1_env/bin/torchrun create mode 100755 models/main_models/rt1/rt1_env/bin/tqdm create mode 100755 models/main_models/rt1/rt1_env/bin/transformers-cli create mode 100755 models/main_models/rt1/rt1_env/bin/tree-cli create mode 100755 models/main_models/rt1/rt1_env/bin/wandb create mode 100755 models/main_models/rt1/rt1_env/bin/wb create mode 100755 models/main_models/rt1/rt1_env/bin/wheel create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto create mode 100644 models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto create mode 120000 models/main_models/rt1/rt1_env/lib64 create mode 100644 models/main_models/rt1/rt1_env/pyvenv.cfg create mode 100644 models/main_models/rt1/rt1_env/share/man/man1/isympy.1 create mode 100644 models/main_models/rt1/rt1_pytorch/__init__.py create mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py create mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py create mode 100644 models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py create mode 100644 models/main_models/rt1/rt1_pytorch/rt1_model.py create mode 100644 models/main_models/rt1/rt1_pytorch/rt1_policy.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py create mode 100644 models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py create mode 100644 models/main_models/rt1/setup.py create mode 100644 models/main_models/rt1/tests/action_tokenizer_test.py create mode 100644 models/main_models/rt1/tests/film_conditioning_layer_test.py create mode 100644 models/main_models/rt1/tests/film_efficientnet_test.py create mode 100644 models/main_models/rt1/tests/image_tokenizer_test.py create mode 100644 models/main_models/rt1/tests/rt1_model_test.py create mode 100644 models/main_models/rt1/tests/rt1_policy_test.py create mode 100644 models/main_models/rt1/tests/token_learner_test.py create mode 100644 models/main_models/rt1/vd4rl_main.py diff --git a/models/main_models/rt1/LICENSE b/models/main_models/rt1/LICENSE new file mode 100644 index 000000000..272afdf8f --- /dev/null +++ b/models/main_models/rt1/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Phil Wang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb b/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb new file mode 100644 index 000000000..2b2235541 --- /dev/null +++ b/models/main_models/rt1/Open_X_Embodiment_Datasets.ipynb @@ -0,0 +1,2303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "EnWCKLGGaf-d" + }, + "source": [ + "# Open X-Embodiment Datasets\n", + "\n", + "![](https://robotics-transformer-x.github.io/img/overview.png)\n", + "\n", + "This colab helps you **visualize** the datasets in the Open X-Embodiment Dataset, explains how to **download** them and how to **train** with them.\n", + "\n", + "Table of Content:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "toc", + "id": "UyiiBjzmaIQu" + }, + "source": [ + ">[Open X-Embodiment Datasets](#scrollTo=EnWCKLGGaf-d)\n", + "\n", + ">[Visualize Datasets](#scrollTo=29c7oLlJbWwF)\n", + "\n", + ">[Download Datasets](#scrollTo=-WHN-2OrKqGo)\n", + "\n", + ">[Data Loader Example](#scrollTo=IyccDsRqwtMz)\n", + "\n", + ">[Interleave Multiple Datasets](#scrollTo=ekmsGRAnw3Bp)\n", + "\n", + ">[Example Dataloader to produce trajectories](#scrollTo=aew258oUbamg)\n", + "\n", + ">>[Demonstration of transformation from an episode to a trajectory](#scrollTo=BK4RRYkbLN5B)\n", + "\n", + ">>[Combination of multiple datasets](#scrollTo=Oy89HzymQyAq)\n", + "\n", + ">[Available datasets:](#scrollTo=N2Efw2aHVfSX)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "29c7oLlJbWwF" + }, + "source": [ + "# Visualize Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "l7OogZYi7qwT" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow_datasets as tfds\n", + "from PIL import Image\n", + "from IPython import display\n", + "\n", + "DATASETS = [\n", + " \"fractal20220817_data\",\n", + " \"kuka\",\n", + " \"bridge\",\n", + " \"taco_play\",\n", + " \"jaco_play\",\n", + " \"berkeley_cable_routing\",\n", + " \"roboturk\",\n", + " \"nyu_door_opening_surprising_effectiveness\",\n", + " \"viola\",\n", + " \"berkeley_autolab_ur5\",\n", + " \"toto\",\n", + " \"language_table\",\n", + " \"columbia_cairlab_pusht_real\",\n", + " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", + " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", + " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", + " \"austin_buds_dataset_converted_externally_to_rlds\",\n", + " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", + " \"maniskill_dataset_converted_externally_to_rlds\",\n", + " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", + " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", + " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", + " \"bc_z\",\n", + " \"usc_cloth_sim_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", + " \"utokyo_saytap_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", + " \"robo_net\",\n", + " \"berkeley_mvp_converted_externally_to_rlds\",\n", + " \"berkeley_rpt_converted_externally_to_rlds\",\n", + " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", + " \"stanford_mask_vit_converted_externally_to_rlds\",\n", + " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", + " \"dlr_sara_pour_converted_externally_to_rlds\",\n", + " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", + " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", + " \"asu_table_top_converted_externally_to_rlds\",\n", + " \"stanford_robocook_converted_externally_to_rlds\",\n", + " \"eth_agent_affordances\",\n", + " \"imperialcollege_sawyer_wrist_cam\",\n", + " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", + " \"uiuc_d3field\",\n", + " \"utaustin_mutex\",\n", + " \"berkeley_fanuc_manipulation\",\n", + " \"cmu_play_fusion\",\n", + " \"cmu_stretch\",\n", + " \"berkeley_gnm_recon\",\n", + " \"berkeley_gnm_cory_hall\",\n", + " \"berkeley_gnm_sac_son\",\n", + "]\n", + "\n", + "\n", + "def dataset2path(name):\n", + " if name == \"robo_net\":\n", + " version = \"1.0.0\"\n", + " elif name == \"language_table\":\n", + " version = \"0.0.1\"\n", + " else:\n", + " version = \"0.1.0\"\n", + " return f\"gs://gresearch/robotics/{name}/{version}\"\n", + "\n", + "\n", + "def as_gif(images, path=\"temp.gif\"):\n", + " # Render the images as the gif:\n", + " images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0)\n", + " gif_bytes = open(path, \"rb\").read()\n", + " return gif_bytes" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 497 + }, + "id": "Gcw4eHmxbZjx", + "outputId": "a2cc46f1-5eec-41b8-fa23-6b4797b1e1e1" + }, + "outputs": [ + { + "data": { + "image/png": "R0lGODlhQAEAAYcAAOrAoeCzlN6sh9Gqj9She8qgg8OfhcCafsqUacGUcr6TdbuUdruPbreUeraQdLiOb7KOdb6LYLiLaLeKa7aJZbSLbLSHaLSIZbSGY7GLbrGHZ7GGZrGGY7GFYa2Jb62GaKiHbriBUbGCWbCCXK+DYa6AWayDY6yAYKyBXax+UqiDaqiCZKd/ZKZ+ZKmAXal+XKh9W6d8WKSBaKR/ZqSAY6N+YqR9ZKN9YKR8Y6N7YqN7XaF+ZKF8YaB7YJ1+ZZ17YK13SKZ4T6V5WKR2UaJ6YaN5WKJ2U6F5YKB4X6B5W6B2V6B0UZ96YZ55X555Xp93X595XJ93W552XZ52XJ51X590U55xUJ16X514Xp14XZx3Xp15W5x3W511XZ11W5x1WJ10Xpx0W5xzX5xzXZxzWJxxT5t4X5p4XJp2XJt2W5p1Xpp1W5p2WZp1WZl0WZp0VptzWptyXJlzXJpxW5pyWZpwUJd2XJd0WpdzWpdzV5dyWZdxWZdwU5N1XpNyWZNxWJRvVpBvV51sSJhsS5ZsS5RtUpRpSJFtVZBqVZFsUJFnSI5rVY9pVI5qUI5oU45nTItqUotmToZoVJNiP4xiQ4hkSoheQINiSoNdQ3xfTHxbRYZYN31XPXVXQ3ZVO3xQMHFPOHZGJmpPPWdKNmdHMWFHNWREMWVDLF9DMFpDMmI/KF0/LFs+K1k+K1k8KlY+LVI9L1s6JVY6KFU6KF01G1U2IVE4KVE3JFE0IVExHE02Jkk2J0oyIkswH0svGkUvH0AvIU0oEkUpFkApGj8kEjknGjcjFTghETIgEzocCi8bDSkbDycYDDATBCcUByQWCiQRBCAWDCAUCR8TCB8RBRkRBx4OAxkOBBQNBBgKARAKAhcEAA8DAAwJAwwGAgwCAAkJBAgIAgkHAgcHAAUHAQkGAAcGAQUGAAMGAAkFAAYFAAQFAAkEAAcEAAUEAAMEAAQDAAEDAAgCAAgAAAYBAAUBAAQAAAICAAMAAAECAAEBAQEBAAABAAAAAgEAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQAZAAAACwAAAAAQAEAAQAI/wDrvBmYREMBBS90vIBRpUodQmQIETKhQxGhJDq+6KhD6QufOkaMxOhAIkYMFCNIXKCAYcSIDh04kDhBggSKGBq4xKrVaxgxa8qE1aqVy9WtUT+UGBkSQ4eOIkvKVBFiRIiQJSJNvlj4ouYJmTC2vkBh8wTME19NmKg5c6aJryfWjkVBtgOGmnbtUpCAgQOHCxf+SpCwFwPMEjGEPAJ1ihUuYbhmsWK1qvIqVJgzZ15latQoVJdBmwLlCZTp0p5JqR7VqVPmWc6sWYNG25kzZcqODQPGy1YqUaIy7Zq2LJMkScDmsdOG7ZrzatWuUaM2rbr169elad/+rLvt7szAb/+/Bn2ZKEl9+jDxcOAAhAYNPOzY4wgTJ1XNZGfb74wZ7v/KfPGGEkkk4cIBBTylRAxFKKHEG4S8UQUMdVTxRhIQ1qGEJXwoAdJJdNH1AkkkuIRSTH7VhBgMHKjgCU+9JLMNNMnkQpQrs8yShQ4xbHVCQkVUBYNJMAgZIlcysYXCWCSQRNMLRizxwgku+DiTElUoIYQJG2yAFl4w2YXBmHoR5tdfexFGAUtrjhDDEoupEstjvEg2mWWhaaYnaJWBdsoopgVq2imqkZLJIqBgVkoqv+wGzKPA/LKLLbBUmkoqpWQqyi7AiJKeJMh8ww022EQHHXTUVbedNNhZtyp33cX/Kqt21GTj3HS7oOeDDCrE5wEEwIKwxyGXaDKKL9Bsk802y/iHDIAYYqTEFxUMoEARAulQICGGKKFDC065oMMbdRjyhiKKPHiSTShw0BJMI4hoEgodXGABBijA0K4DjeTiCy/EJHNMjbjgcosruTTy4wgvcIBWYltp1SNZM4lIQlc2QSmEWGPFYEUZMFBp5UxZbrmBBn6NScEFMAF2wV0kYKCmyxIwwBeZFHQQRBmGUOKJKkQRE9kqd+JpdJ5HX0YKoKOsBkrThJpiCimmoJLp1ZoCp7XWrbWWyXk++NBHJtRo802pp7Y6zaprs6oqrLLGHet4zl2TTa3GiBKIDzPw/5DGByr8CoEHKixSiSaamNLMNkD95x9udQj0xRdJwHDAAC4kQWCBdRRCiA6bD+jUQ3xQwkcRc9GbV5jx5iuEC/VuYFi8D2RwxSm4+CJMKp20gksuBrfiiycrhAWDWibAoG++y4NJF1skcEDSC1b1yOSSVCJf0wYXT7WBBRt80CQGKxlGvmEkYrAy+SzXy5LKhCFmBCWg0BK0L65MFosqSRvNp/+EKtTSoLa0qTVNaqMQRWsUaJxMGOc4EIygJMKWnk5sgxvfIE/a1Oa2V7FKO3J7Rnjk5ra61Y0as5nFBH8AiEZEgQUqeI8HPMCERmBCE6CYBTT+g4xnQS5yAklCHf82MIAHFCgJX4gcH6IwoAtpqwgmUEIRdGAJHbigRE3yy0pW1gG6hKlJJ6BYSjjwAA+Awhe+IIYwbHGLoRRMFriIxQ2IFD0O1KUmZHFXTMpyJpi1hSYpOtMGTOCX71nAAjV5gQkmcEjujQ8mY0KfJAkTE5aNQH17WdNgcvaCxdgvFqvARf5cEYtYTKYVrcifZSiTtDuhQmoG9MzUSPFKUnBGagrshAN1+UBJLCIQfQBmeoYJAhCILRXcmIc8oFOdamDHg27LTgjBw4wRdkcaKCSPNrVht9kgQ2+LSEQi+MADFYAAPg5QgRwOpwlR2EIZzkAGM26zjAc9JHKGqEIBCuD/ICQSQiAdIohTihADipygCITYgF5etsU1dSBe9WJZvsxSIg4o4AEOuAQueiEMYvCCF74AnsFkEQw+8Igs9oremKT3l7745UszsSNNvqKSDQjSYWr5yiHBx8hGTmAC0iNTB9YUyfepb6XkS1PNCDOYhxqBE6SghSdcIwtZkLKUsSClK7bKyqLhiauusAwqBjg1U5yiaqugpSlKwcsGOhA9w4xrH8Lmg2KmpxjcSOYGOfiqa4JwmtUM7NyoUbfmXCOv2NDGfqxxi04sohGPyEMPZngAAzQAAjNAxCU2K4ph3EYZ1YycRP5ZoWo9QFsC0kEUCtGhjbigQSc5gQUmYAgX/yS1L+d7GYmgRxcOUIClF83AIfwlDGF8tBe1uEUveLGKYGBCByHrwGDc5TLcnil6bYFeHVUSvcB0KS5v4YAGNAA+LhmSkTE7aiTVSxIxwYy6LLHZJg0jBEucwheXWAQqjLLV/vp3q6hEJStaccr+ppKVnCkUKk5RGbQasJcRBCZdh0nXsEHArsvghjbmMY3pZOeZf52miEX4jO1Qw7B1+8Y85qFhbShWGaWQBCQaoQc6rKAB7TmAAzwgg0NEIhKZQEUymqEMaAhEIpFz0An26RQPEUIJiqDEgJTgAgb1aDATaMgm1wSY3+7WK01qEmCkl4DaqeAUuSiuLnix0YKJUv8YoLjBFTEwAb64jKh3SdJLw0wiC9iLA1e8QEzBy6WddskCGpiATb/yMqKCqUTxSq8fXZISCbCMoR0wws/8hcZbVPW/rkAlgAPMilCn0qpcxdNYR2GKVZyiMUSr5SgkEYhALGIRvpRwhcW2a/iAQBLPuMY35NFh6kDzVW3bjm2sKcLwWDM82JyOrVC84nmIyhsu5oY1fpGJQBwCDl5YwAIasADLDo4Jmr1EJ3rRjGb8UyoVKhcUC7ABJVDiIZRA1xsoQYgy9BsGa9oAAzigiL9oETAYEAsKaNKWvtjkpROowApoMAo1elQXBQPeLWbhi1pswQQrSUACwBQmkizcKzD/3Z7LHEZTm2yMkDAQwgkGaQJFauAtNl0vJF8WMxIQ9QKWDrPPc5YzmIxlEKBQRTCIEbDlzqKqqAZ1f6Nu4FW0QjOdYXXV9CSLWYyi1rVeRCY2ewlaB1OYcgUWBDphjWyo2BrT8XDb5L62Z6BQNnHPO96h8QxoOMPu1CGs3RSbDRfbyoTPaY41jNEJM1xBCkm4wa8cYIABGMADRHAE4lxDjCJ4HkuijZwCFPCFJz+I34rIJyGMgAKmYrkMMeCAn9N7MYXj0S4yWUtNFH2CFWCiuB5lcy9EegvdPWIFHKjZyCmtXTyeXCYmJ0GXunSmMLoABi6Iy4/AW4V8Ijos7mJf/5e3PFSmkq+SQMdke22iiKT7Ihgd7UUvcgR1qLui608HdYAr04o+rdUzfZIn++UKoGAGFSZXCJh2FwYL+5FMeZcq2vE2IBR3tAENdycbcFeBguUMd7cfheeBtiIb1yCC15BYs9EMrLAIZgAIbdAGMuAADnA5DpABKgAI6mYaRmAFH2MFg1AH/qYIS2YCVdAglGAJkbMQQoACFMAAa7ImDOACQyQB3LMBEhUiFJVFMEEXagFU4pIHuaBGH8ULveBmBZMMxHMCNcMAIUIxbBETX+IXe0QW1EcWEoBIaYFT1PcBH5B9FsABDgEDmNSEmdSEQ7UyL+Nn45d8vwWHJ9B+qv+QC/AnNJFBf/a3VVHXf32yJ5mICgCYNFbVeHVVTLtGV2ZgBn1ggKXoA8FSDG2XTCAmDSUGi9Q0TxVYixW4bP4RWM5AGxeIQvtBHh2GgdZwDdx0N8wADcKQCX4QCHuwB0yQATAIHxkAAj8QCTgkBFVQBlKhg1aQZApwAJ/3Bp7HIEIAdIPBVAxQZ4bAJSTQh3vELmzBcDZxfXzIAS9QBFygCmokfx+VC7mwXL1ADKpQAy6whArgfLzFFmcSfiTxPTa1kNGjASeDFoY0XhbwARwQXocUiGkiiOqzSbM1XUCnVIEhE4rgCVFFXG/0dJeYSqh0NJuxGXnSiUSDYLLQCp3/MFcyIIqj2JO7cll9IE/ZkFfJBljMsAzL0EMA0kM+pAzIcAzGEJVSqZROiRvIsAzQIBvSEA2sUoEkSA3S8Fm9cAmB8Ada4AbPCAK90gAyMANuEAlIGAPKYxJyKQQcUAAfEBae53nleI7naDOz5RA/kpFdEUZ0gRaGGSJVphA2BSVswAn7uFy84I9jOAzCEAxsQEgPcJDaFSaGmUXS0zKWxgFd4gLZuCU1ZwLZxwEfMF7j9QGzNUh1xD57IV98YReDkY7nuBJpuEkvRQmckHT2YyO1UH+pRjStVJMEVmqWcXW01FUEVhmywArKWFczJAPYiZ09KQO7ck4NkAnKsAx2/8MNrGKU/eGUyCCVxwCVxlAMUlkMxeATwzCfxrCex9BDxkCVHFhi0/AMu2iBzrE21OGf26AMonBrfnAHd7ADIEADHhAfNFADIHIxiHkTW/GNNecCVWYEJJAAS2UzDGAzEbcClABdDYMx8lihW6GhygMDgXETW9AIuiN/NOoLY6hGyVAJFbABD7AAYLKQDrNwYZIkPicBMkGFJ0AVipRThJSRJqABFYBoEqkWNtVQuWl+LZMm0bMBtRmiXIakUYYJpXEKO1ELsfBp95dVRLNVpRRW/oVVOGKJs7AKn5E/oracs4AKtOYDgqMCfpqd2smdYbOTD9oAogBarSiLzVZNi//qLFE5n/I5n78gDL9QqZVKqb0wqZAqqY3invkJbd4BDdKAd/15TdygLLzQbWWZCGegAivwAQuQATNwR2URRkYwJBZQABXwAidxEmkYosAKrLWjCHWgoRoAE20IZkuiPBqqoROQM5lzBqogDDQqfzbaC8YwDMlACt/To4D0kHCYRWO2W6QZU9RHSG8RF6Q5SBtQAe5KXozUJeeoVIMhMxxZh6T5F8Lqrhfwrv6WCI9QCfdBFENRnGVqpgWbsArrRmSIC6xgS1LXCrHwdX6wA4LjAWqpAoCqsYAKAg8KAe90jEP5bIFVTc3ilI/6C7zwC8t1Cy5rMC9bMGNYrfKnCzb/u7LFAJXPwmzPIIwiOA0rdqoGWmt5kAd8cAOA8wEesFtOwqJW4QIH0SUkAaIilwAMYLVXG3EVUBEuoBZJwnBLkjoLgX1o4aXiQgOeIAxoRKP/2Au6QQy5oAMW8ABPuKVE2l0rhyLx2KSDJHuDNHOFBKU99VOE62d1aAFpUme+5VuIOwG6yQDg86sh+gCUWwEwMC6PkLk4JCiCAiic+7mm4RlNkxqecX9WVYm14CmBoAaTRzh+WkwgAKg7WUwP6gPD8CzQsCxIGVhICVqBhbLZSq0t67LES4YxWzAfhQs2u2ZrNgzHQAzHAE/NFmwj2Hb6sWLywA3ZAA23cAkJygcm/6WHGYBy1ocCQmBlMcAABcAAX/GsyRes6ei4jFQBGqAILiBegJRdKYFHLBoW7dKH4rICMrq2vYBGNqpGucMDDqAADFBHKcIWhuQlTCJ90mcBa9ElVPq30ndojARUK3Um9kJes/VTFzB93yMBD5BoitbBdDu5E0C3ExBFfJC5lfAIgFAILfQI4vQIjZAIhyBOh3AIjdDDj/UHh7AIQXwIpbiMgeAJseALMOuyZroToPBLePADGfunbTkDMyC7swsBkkAMn7qLJXuUZewsULmeKmujyjWz1mrAlToMl9pRaiQMcvwL0JsM8JSVvwiCHuhi23BBgdwMMVbDUaABH5ABU/+SSMpzj0MIA0VwlwgxwsHKwMFKuBVQBYSAMjSBIhzQOiSgFmsoh+V1A0mQB7SgttaaqWkkDLcgDJBAbgN3JkH3rX9GweDlJYuEwSZcaN/zwj9FPohoAVjmrsbsrlJKXu76AO4KzBVAuQxAtwz8ABGHIYUgTqzFB2/AB9kMvtwMCEXrzeALCHiAB3pQzm4gAztwBsvoxL5AvGw0xbWgCX7QB2pgnX6qxdjZxR0LAmuns/D0WQAy0FZpn88rx/J3C2RYwL7QKHccx5TKdMWFqc77H3z8HNUgjB7YdvvBOMKgCYeQA0r7AWMRRguRGENoBFVQtgVAuI7LAAogcpf8whL/UAEER0g18ReBAY9nshZfMn0msAJRsAKeQMCZWqnPywtwRm4JsJB9mL8MtxALN3NUPcKH9FNX/VPcM8KM5JcvTbnULAEvPRgXoEjLDNbPXAHRLM0LEM0MUAEt8AaFoAjjxAcCcteTEwV3fUQFolpHgARHENg80AMq0DdnYAegUAtQ7LK2QH87gR5qYAZMoALTmMWyuyvYibEg0Arr6UMCTdD/sZ71eQzFwHQqu1wwK7PLtWYODanuKcdhKIaNcp/Pwp/bUWzFxirWMA1t1wye8AOZrQIi0qIobQVVMSUTUAAJ4LhYi7WXHJLuKkUaIGglSSJaqD2ICRgfcAI3wAc0/1AJBLyyk6rGtxALHrAATX23M4UWL9UuijR9J1C4s7VTgyvfO0XMLk24Yh2ijisBJFAB08zM9AvN0Dy5bb2rZKA5GuEgXzAtm4NaGKEDN1ADOHADOlADRJADOEAENlADrlsDVzAKabbattDYVhULflCKTMADMjBDM5SxXswrothR+clDSsmUA82eox2VxGCpvEC8sm2prb2pnLqyH9Uo+dlDzRIrjAor1bSLmeADOyDjIDAWJ50YVmEFr8MiNaPcV2u1zg2sLl25VTBe4uWkalFl2de1iAlIb5E5K+AEii2Zlrqew/AKvmAHDlABSxISIYMWIRED6809OGcBsqVoJv9saNPXSLLTR8R8jj8l1pYGdBcwAQx8zANOt5tJuaMXzbtaBQlRBU7B1wMFXVPkFC2wAivQAixgAizAAisA6ywwgx8wA1dACiO+2rqwcbJwCqV4BStuA5SdAS6exflsTjO0CMkwDPUZ2rTNlFSZG+q5ntB7DNRqo2JYwMUl5EdN5LB91Eee5FcJbbAYbaXad82gCe7xAbQuPiLCq1YB6mFhAQ2svgdxtSEa5i8dogrwzBp65hnZrENiomKhPDQhLgreA8dC55UqMMQwC8JwCXu+EFFSBGHBq9gXPWFUE2+RwSbcJVg9AbXXjhvpUkBXZyi/myqRjjCt6Wrt1gXewgL/fnM6oJpU9gEUoS1VMkUvkH2v/qofsAImoIdDH9SwWkY0RApphNq73ti1AAo7wAMs7qcekAFWX+zmBLseOzidsOyjrcdRKdpRiePpOe32KTDFpTtpj+0ra8fE4BNMNwwAKX8ObanOm+SgZRu7GBsiBA3N0AkGUACxqgEZ8AAf0EVzEXNKGjM1w9zKLdPwG/lllsLH46QiUyXQpTw8YhIWvxWXqy3f/Y/i3fDPi3GgUPhesYZU4gJ5lJFHqsuMfmj3DT41Md8bUIeAwdVYlvLt6ukWkNabCdOWPPwwP17GPLcCvsxRqvzLDIOU6/wLMIMxeADRzwT3BRkF42lVFQuX//Di0AiDVh/+L67ZW39hq/C8Zy8wBr3+7FnaxKAMTGfQdVztdUyjEz3RamSj18pRxODGHDWfAEHs2MCBxYwV+yVs1IEBByp8yJDhw4cTKF68iGFEyMUYFBhIuMBAZIEDCRIwOClSpAKVLSvA4ODChIsXMFycOAFDBwydMV7QrPlTx9AbbWrl6vVLqa9kyYj9YhVrRgUOJEh0uMABJ04UJzR81bDBxAQTFsyenZDW7AQLG9y2JbFBgoULGC5IwCthQksGD1gqeFDhwWC/exUAZsAyMcsHEz5UaCt4sGTAkgk/cJA58wIFDhYseLDAgIEDDX6QinVq1OpRokC9PgQBQv8GBw08R8TtQbduECA8QPAgwxcx4seUNSWYnODBYc2bHyM2jLjSXrhw8cJ1S/usV6lWpUIVvlTr1qI6me+UPtN69u3dS8rUp0EAkhInfsjhAgaKjEJi8OdAAgruYiCtBAoQKaW09lLpgY8q+MoEGF7QoYgibqLpBBNwcqFDCi3U4SKeWGDhFGF6kY6YZIRhsZdVcqkkA7YuIIGDrE7Q6gSZXOCAAxN+dOutts4acoMee7SKBLbgsmCCBzawwLLLKhAsooc0mEwDKjVzADMqJ4LwAy2pHJPKwCSjsoIMMMtgAc0ayIC0BhpYBBRPQNFEk0z0zPOSHrjMLCIIHJBtUAj/5pzzUAjMGE8UR9FTzz1JJ2UPvvXSwzTTR0UppZRUPn0FFlFh0WUXXn4ZxhhVkVFmmWee+eYbbrYhJhAD6FvggxU8aGGOOWiCIaMYfErSrgsomGuCAw5Iq8AFn51gLg16NGHYIpRQooihZNqqQx1rCpFDF1j4AJNcfPGFRWF8CQZdV2rx5IMNaozLKh1ROFKmsppMK8izgoTSyCO3sgqtvsqUrC/C3LQytM/OrMAzByJ+QMwyJxusy8A6U+CzA0hadlnSRr51AJPt4PMSlS+pJJJKGmFoNJlDprm0kOf8zYc+fOC5jz4kAdrS80QZ5ZVXbLFFl1NRHaYYg45hVRmp/5Vhxhmrr3YGGq23tqZrr6m5JuxssrFG7LGxwWbsWL9xJhMIDBigAAdUUEGGOOY4YqYYhNCoKwysQpYCG81iAMEJWIJWLQsi/FE/EG/a6scfOYQh8g01ZCGMU1YxZZVYVDlFFVJIAeUUUrIw4asTIDRSv65+7NHftkyQXay3qqoKBRRIIHKDvQKbTDDPPvNY5JBlHq0A5eM2uXnnmw8gegCmp75666+nXgZILtGkkktcjiT8QwwA+TNEHcAtIg8I3a03WaBzWqCmpp66aqyt1tqZZ6ShhuutofGaNagxjWlQw4AHpEYAu1aNaoQtgGG7RgOvATZZWWMUZmiAyQ7gAP8PqOAMepACDn7CEyEIoUYYQCGyQMI7s5Qkcc8yy1eO9KOfWM4E8trABybHLclp6Ecf4F4nXmMnTnQiT6NQRSTEJBYtSYADQfHhhl7YGCcpzEF8SZACDgS9AAwgetLDXhjD+MXoPW95zFNeGgswmpqJLHlxM4AHSOGJPamsEndsWSMg4CbNDAp96cuABxpQKA+AwAfKSQ4yoka/VjHDflZ7BgGn8YysIdCSCJTgNabBwGoEkJOZzEYEGRg2amSDG9AQhRlU8ADlke8AMnBDD3AwBZu4wF4YCBBeLtAkAS3oQAnYywvZApZpBahGF3DLLi+QFml9ZXEaINIEzMSG7Xn/72WNiAQkJHEJUBxCVy7QwApS5yMTVEVD5ASYWxY0mMUcRiQSwCUKD3dGk6WxnmpUIxvb6LHPcAlLDxETQCNEJWlqJk2c0UzFaJOBZTXgD7UwIihWZseX0UZimTEUIAU5yA7KIBPJUIYilWEcRi7DpCddhiNVutJX7Y8a0mjpq6QB02dEw6Y3nelMCTjTSF5SbBM0YNdG0ZsMKECNCmCBDlgAAyWU5ED4hKryEuBUZwnzmWAJSQGap8aUnEUwZmKnSJalgkNAAhJ3LEQj0roISJzCE4XQ1Y9W4II0zesETbJAWfoFJSpWsS9+dZZImlUgCzgIeIb1y/C4NCjiPcxh/136amAyExgsVSyyDuqM8MykJjbdYAVr8swBKpELT3SCjtzzXiQuEYjFEioDs8lNIBFVNxCIAhqMlBozopZSZrzKpL1tKU1jasCcSmOnxdXpNHIqSeXyD4ECLNs1yAZAayhjqLqpgAKWdSAFbOAELxCCDg6gReUtqwAmMYlTE6CYwFYVWhJIE5WapF4sSsBf67xMaA7wgUQkohGVeEQhEgGIRmyvFsIABQ1WsAIImeABWjLSBg7mV8Io5jCHeUBhWzJYBl2RJegF8YU7QzwRdywzB3CTmT4wmQ1E9kqX6QtgCOMkv5wJS13SDChqoYk7aUKInVhZHwpFKNsUSqMHkP9NcHwwC2fglmpUe+T/pKy1AyrQa2Ozcpa1fOWxkc0aAFQGKnqDXQhV4GMFUIAJdACFLfwIJYTdsEoGK9i+OOsy0YpvBTZwFwvo5VkFwgu/YEyY7B4gAwR+xH/7+4hIHOISqBCGKhJBg8d8lQNU2ZBgCktFwzJoJX2xwEdUohdAXzExJwExerXbxvKGbNUf+8tjNFAZLS0gYoJZzHr9UuILc+Yww1sABE6RCx6DohOqyEUt1nMJP0QkULCVTSDVB4JBQoBufTgGNO6XtSlT939b7vI2xC3uLpfb3Of2ctfMvQ2vQQMXPkjybB6wggVodQALYMENarAFEjgIvVh882L/VuJOgFsRYmDddcElwBct/oUBDkjEHTGBiUdU3HuXGAUxcsEJD2SgAujl0ZkWkBg5r4XkVxzsgI5FAWRd4C6kLjjwDjOmwNDG13xhizQvQDvIgNUBK65AVubCgTcDczEoXgCKx/uADDRgB7SgxZ3slAtTnEJlmvCDCjKgAt3QzeteBwHdOjiDukmiGQDUWtfSvmUFZmPcb4c7u9X+v2bUvRlNSQZ0iMEidFWnFrJwhStS0anVgMIRXO/4Cj5wg0SwQKsFWIAKbFCDGxCcqnQOeEvYq7CETUaaE4CmBj5fAYXReUELZxDMVbKAPHiPE5x4Wcu81wlhEOMUP8iABlCS/4AOfaUCoCmQYOkC82YNFi8D6kCNorX89iYoJVNlzK875usLr5cxEHOAAhD+mHfCUwLp/TQ/3UQYDxzgDsGIRbE7MQpNcE9ldtA64lXwgd10UAVhl4FE6CYDUNj97ngfCOLYO77rhQLMjlkAvFYID1QYj/JwFEzRE/dQmaCJhKCBBEdgBLMyK0nQJklYBA5chEXQAxVggY6jmw/gg0rQgXozgAcgwRbIAQ5QDBB7p+7LC7yYgAFpueELHAvgAFzigA7okWPps5bIC5cLQrz4CBs5PpF4AC6YOE7QBC6ogUTABO/RhFhIhlpQolAzCRI4AYgYDA1YuAfTEna6sAZhAP+CggzR+52WaAyVCLHxaqfDGK8Lu0MRAw3C8IzsErXvSwAUKIMXQJYS+wwDaLrMsA3zOQA/iAVSECJji8D2u4QdOJTfKBTbcK1A6qDZAAEbIKvvCZ9R1MAQNMVTRMUQbIRGcARsYrRIaEVHSARZZAT/aoRFQIRDAIRd3IM9wINfxAM5wAM00AIzYIIdkIFk7I2wqxsVmIEOmogkeIRKKASGMrQFswEioATSwwv0usFvFBCW00FwHJAgTJKrsBEdFEeXY7ms6ACs0CUm7EbAqIGJa79EKIQ3qARMyBNScApQWAEH2L2CyowyCwwfiS9T44vgQZOIUSy/UAkRy0M8bKP/fdKMzzgvkUCWBCCAIAiFULCESRAEQ1CCxHoYjAIOD/gAupkBNdCE11g/TyitPJm4PziDM7gDNECDO7iDNciDO9CDPHADNnCDPECCI1iDRDiEQgCEPdhFPoBKOqCDPNADPOhJNdACLWiCJmACJsgBG7CBGZiBFiCRBfuhGxKTDIgSNXE2QFFERFnEOalIJGvGDsqAHiiEQpjGGviMD6gBFsiBI6AFSviKBBG1j1g4xPwIlgPH46uLrKgKq+AAf8HBaIGvPIOQadGSM0yMisEETvAEjpsBPrjCSzgPYmiGWsC97NI+2oAtj0uTzbyhMvmKgPK42+SSxuoSj8sYYBs//y6ZDE7kDa9bARJpgRZIghYoIQlAAASIAEH4yE2Qzk2ITisYhDoYBEqgBEIghDfggzfIS0BgBFB4RCF6FPVoPyaYv4kQlNqAywYonmVprLmsmflEusbCz/zkJzs8nqhSo+fxogEQgALYABaQgWf8ABr4zih4BErgA4hYgRu4gSNAAmKIhUYAE5RITLz4qsTss2CyTLNwuQtowxyaiLCAkjxbS/laHNaBpokItb74gErgMdirBErgR04wzVa4BVDYAZv7I0CCkNzTgNybCBZYsOK8AR2QUB3ogSftASiAgjZwAy6g0qLMgzfQUj7Iy0LgUqj0UqgUUz7Igz/Qg6BcA/82UNMvOEok0IEWeIEToIAICIEQAAIgqFMREIEIEAEroM5NmIRPAFRFWIIyEILDWS+SsAFMuJPVeEAjar8GSCPyQR6Z+c/H+08zsjcA5dROdR4yAtVQFVVRFYAAEIAECMPg0JU8aIMaiIJCoIRKSIIIXVIpkIJm8IVOUMnhMROa2yzMzEyLqc37kBxdmYgk9SxdESdkbdIbSIIk2AkdSAI2uATQ9IQrnDju8TFcqIVTAAVOoIRHiLg7qjhxVQQB6y8vzctEEFMtfYMvgNcvgFaiYIEaKE7Fu4+J6DhnsyjfNB+5pM/xIgmTSAEgiIAIQAACaE4CYFgCCIFQ2AQRmIT/FJgEIBBJkSyBGBiCZUHBSgAF0gGFUTAiI5IEuHmeUQUjMVLZlQUAlA1VT9VUqCqJhqUAEggkFViBLWgDGqgBeO2vN5hXHcgCLmAFT9CEQMiDK4jSeCXTdcXHRCjXqC1XPJpGAMOjG8WEWJ24rcVRS7CErLWEWL1RAKs4PiCE/qqE17tWbNUEfuyEWogFiSoEKLghBVtPiDATt9RP+QzYuRyZM/PPwLWnxysJDMDThEXcxEWAQA0BQbBTQQCCTaDYi/2ECUCzCvCCOxmdIcqTPggAlm3ZLwrd0P3c6hlVmOXUVlojexqASiWffNKnORk5lCAAASCACGAAFto6LoAC/xqgAR2Igi+Q1iiIAmhNAi7gAlRwhdT41qyN1YpL10LIg+l1gzRwgh6oAR5YAbHTDT96yzlxT7gcnppJHqgymdGAgEvYWjuaKE2wxAYwL9ZF3U51WVEF3fu9HgFozhBozgiwXf1F2OaEzoqdhIcF1IrdhBIwhE8YhJJwMAU4gkLgBFrIhVwIhlyQAwhgCOfRqr9dNe3i4PltXde9mUQhJPyTAZ7hGTPwGZ/xg0Bgq7NS388MTU0AzVEYnY8Mguak2BIQgtT5gC/o3RWgAX2jvL/Mtx5oAifIApFVmUbogXytv/oTlEEB2DPTp749ntfN1HraoAxoJSRLW360x/bLk/8ZgF/ygR4vAlX8deM3HiNRZVjnnGP+bVj+XVxaCIXInYRN0GM9DgVB/QRLUJ7uSqMJ+IRQoIQj4IRPYAE3YqNB4iD7UwEiIIIs6I26kYEd4GQz+AEzsAMXDoRRRkVICJ+gWZlly4RUphT2yJNXTg8fg0BTGIVT+AQRaE4EwIASAK8PwIEo8KwFK+IaoDwSSWIn4II0yISWiYREiAJxmggTTUsrWROLIp4NBpmKLN8uNpnTjZsyat1DkMI+ocT2Y4g2Fl04np76Zed2JiNODYAEyOWGzeUAbs4+BtSP/Eio0+dN+ATxGgBWIokCUIRQaGABUAAYKIkCfYTXew1PmKP/IXqN1cgUTJHEV37lPcmT9dhoV87oVm5ljJZl9NwTHN6EEbDnCBgBJp0lHQhDYUbimFbiLFgDPBg7soMIEiMxpNPivsUnEVbdmSGUO9CEUYiFo6jgCj6FQ9gomtEn17VUqH7duJlUqK4ZRDlhEEhGH/jkFobhbTJN85DJ0LzlXE7YOVZY54yAtFZrOq1TPAUCQQBUEiC5NKoCiLUCAkC1hhWACQDNjyUdmbST14CUijZsTMmETkjsw2bsTXHsR+mUTvmUVgiVXbBsy06aXkgGULCAg3XOEAgCIVACJ8iDI6AIYaYBEjniG+CBJhhaN9gD792M/ASU11TJleRZGhDL/7EsSyRFUhvo7SRdsBNcScS7bfrruEJKRjOQBIhehVVghVU4hVPQBEDYAbrxjUJC4R1Y4TOwgxdmK5e5Oh8T7CHC4c7xnFg4aqQ+F3RRF+KoPQEsDoMoDoJghpEijmCghSCoXXvu33pea3qe54VN6wjoY0OwgI/BgI+chIYlgA6AAb22gkQOBVWAOlXYBErghIk+D0d1lMiW7E8R8VG5bMsGhhNvmlVRpN9yqWkoG7TJBm3QBm6gcW6IFXmQB3zAB3vwBrdjt2AggYN1a0EQBCNgA0BIAxaQqyTNNwnl2R5wAixAAzwAhDY4gyvYgizIgiu4gqzUAibAXt+lgckLS/+x3IErQMYZ2AEeQMav8zoZYMka6IGuZAI0WIM7wIM/AIRD4HNsGkXv+a+rkzpMEexRAAXQUYVEj4r1Rmr3jm/iwLtIl/RJl3T/czL6uW+VMqncUilqsJq7owUREAD9BQIAD4EAjgAgoOc5Tli3zmUg+IQhEIRPEIIhoM5PEASGpd3zEoAT0OdEp4VgsAIKCERLyIVkODutGbcaZ/Ya/4Z5gPZol/Zppwd7sPZrx/Yd13Z++Ad/2HF7wAd/+Idutwca34ZTkICDvdM7JfIqeINE6IEVOIENQG0J1Tee5QEn0ALYLgQ134EZSMatNgM1sIM85/NFWMXwubgcHevynuj/0SGF6Q4dVVDvird4i68FuF1vRK94il/A50aFRD9qRs/4pG5vdWGR+kakvBspgrh0qam7bcsabuufl3KuB7oGbviyZqCFAFfYOt1fi8XThw2FhNVfVndOsw4Bf6bYT4hciB2BEViCE9Aq2mEIPw4FWrDwYAgFhLVdAhCBTQiGbWD2Z/+GatdxbFd7tdfxtnf7t297b5d7fuAHf7AHesB7cMcHepiHWQGFB6BTuF73IBgEMo13uRLLMccBsMzeJuACN9ADQEgEiB+dU6g66MZ8ir/4jIdbzh/5z7/4iw889WaF5TX9incFVoiKwGMFVDCF1E/vWHhuEW8F6AY8V5gF/+54hVmwBe24hetQCudwGlUhfkUSKUyPMuqyhnB7O2dfm+eH/rWZlW3oeXrm3+sPgT52XOgsegQYdYetWK9XWAIAgujchDsN1E/ogBFIZCEIAB34BE6wBKijhVOAumDYhABHgKWPAAm4BF8ACGvcuH3jBswePn8KFzJs6O8fxIgOJyrkx+8fPnv06NnrSK+gtWAbRIQAEuIkyiGDEuXpQWPFiRUzZtCwcYMIkiZOsrTRA+hQI1NChwotNZQUUlKjkJZq6rTpqKhSp0oVFVUU1qxWR2Gd2nXq01KoUO0qWxbWLlvAgBVr29bYsmXMnjmjZs0aNm3b9hKc922eX8CCA///HWzY77fEiQcyZrx3rzVozZolS0Ys2CQCAjQTQBACQecIJScBiTDp0ybNCDxP2nQSdGcEk0LRFgQEyKZNgmAcKMDAgoLgE5SEokUrlCpVn0Jo3hzhdoQAAh54aratlShu6cyJ8yZOnTt37caHV2denTl179atF0/+Hbx38ufP/+dPI0eF9uZxS0aohGi3mXQSECksYUghafCwggkmsPDBDTroQEkoj9zQA08+HbJIWB16+FQqIYqYCiwlhlgiirbAYotZa7k4zFvGGIMMjcooIxczzkBDDY+RWSOYPNzwpRiRRSomGJGDGbnYXtlYQ400zyiDTFvAnAVLKqWI0kn/J5lkIokkgfTRhw9k+uADCGmq8EACBLgpwGaryekZEK1tQtskAtAJhG0RRLDaZwTM9okgpAmyiRVwDhBAAAUkMIECBUyAwRDInULLJBHAuVkIk5AGWwKEnOLBMN+ww5047JjHDquqnvfqOrGuM9547MkX6zm5noPOOvZ1hJA/7syzjSkWIPCcgMkWaAUhfLTBxAwwfcDCDTe88QktlvQABRdu7FHIIo206CJbbrVFI41x4fjMNO1W8+4112Azb17a2Huvvd7oy0465aTDajr//tuqPOwkJg/CiiFUz34DbdOYY485GZkzNh5DzDC/9KLLK69kydWWXX4JpphimnGm/wwgeAACBC273MDLDcjcgAcvP8BAm2425+axQBwLWgS0BBMMLZ/4PJqnpP0552yb1FlaoQkkgAEDmkkwCQwFWLFJAlUUF0oKCMCp2XOezknAAZlww0547QCsTsCsvgqrrLS2Eyt9eb9zkUL34OMNN9BcIgGgyiZbgiDNuqFFDSy4sAK1SdwQBSaJQLFFG3kAkogjkdjbjTfliD46v/0GrK++ppfDzuitj/M67K/nCvs54Z1DTjjk6EqOrHjDZ8898cCzEcIK4aMNMCWWEmIpIHPp5chgSrII9YsEUj31gWiv/R6HBOIHHuHbYYYaZjCxww4yqJAmCOt78D7872cwf/8G70OQgQWEb6Yzzz2HMkkI/jSJodEmFKWpk6c2QZqSiCYCh/ofnwSkKekkoAMUcNPWBjEEIRQHUxFwk89MU6dPLM1NDjjGPNJxDrixqh3uaJWr5qaO3tlNVuvpnaz4kQ/7/C0bxGgEBUqDrAgqqwSDaFYe5NCDG7jgQTdIgg6SUAg+cCFzeShEIiIRiXxwMR7xmI8XgwcP9qzjHmY8IzzgEZ7wrKc97jiPOeIIjjmCwxzu0Mc9wqFH3a3QHXFMT3jSeDty8Eo8b3wHO4BhJhCMqZFmIJ8ftOeHPqihD5HcXiD+gMk//MEPesCDHji5h/DJoXyfRAMWemCDGcigBjP/qEENVKACFqxAliy4JQtwUAMM5QAGYRubzlbjpzqFQhAnGWAwQmEBS/zPNLlxmjFHY8xPhMJpt+mUIMYWAABIRzNLMA44j/NLAqAkBM9cGgISQApuzEMduYrbeFrlwjXSU1fnSAeteqc3+dxjH/6QRzRggYoPiOCaKLmNIAqVUEEMoQ6JKAQg9nCFatGyWlH4Qh7aYMXNNUKLFvkoSENqEX3oIyImNelF/rGPM96DpCRNIzxImpB9cDEfXzQjTNUYHlkR8h0sbUc2OlGmlJ2pqGdiQvme8AQtaIEJTGiCU39whSs4dQ1rsANWz3AGO6ihq2agKvrQx0pZynIFHzgr/1ozADla4pIFUEiCEkYgtk1xRk4RSMEmPkHN0wzNEsRJpiBoo0DcfKZTd02aSSZRqCAQIAElwECbBBCABGArnB7sX0mAcJxJzMkI2/iGPdzpr4C1wxx2C6RObacrdcxzHbmy4XxilQ94dOManTCAo1JQTtGUE6FDGEEVEpGIQwACDVCAArUm9wUdXDEPfABEIRrxiEhU4qTWPSlFGmIfiID0ut79bkQs0hB80GMeyggEHpiwvkea4QdGLZ9Tc9CCD2TgAfP7gApkQIMaVOsH7vVBWMXKSvXJUmUeoF/LHKDgBc+sAQ5w2QcqULVtShZOAYhNZwRxnHAmh5rJIJqdbv+TV2PaBgFD2NomRFOoFBCAUYwSQAIoIIQ60EYV4FyO2ELjtNn8T2fq5AY9/BEw0bXNbvOkp2pzBR752DN25HjyOPixjm8UAwS98YyfdvuaY4kgCCQgQyIaMVw9sGEL27rQFtiQhzdoDovTrUR1LyLnf8y5znT2Bz/wrOc88xnPOvxzSOksaPBeV7z4SIg/yPuNV/RhD1PIwQza61//8gB9PIilAwwwgE0PoAAGOMABGpABtK6AfQa2X4Ih4ICZgbrVrn51qGV2AAcwQAAAuPWt6coZ04SCmsH4sGXASTTbdKo4qLlN0oSQm2OGIlEJmLCLE6CATdjYxpgCTZwERUz/A3ImAcSYBz7+0S8iw6Me9ZAnktdozyW7Vnb73Bs8spGJBiigTcL0E74FEYR7xwAGb3jEIxrRiEPkgQ1QuMFxuZCHLTwXix2FcyW86EX62Epv6HjHxXmV8XVo/B3xQAfIQf7xj19c4vLJxw3pM3H5SJwf8biHP/r5j3vQw7bTS4Qe9BAISGiPepoU+Bk8YIBtAoDTmzYABECwgFrKwL1YxYMb3NCGNHAhC1vgwhag0IMa0OAltUTrWeGHXxXgdwU0MAEDYPOmTW0KAXeixYd/PZlgJAdPgqhsAYEQhF5vYgiFYjbXCDAIQ5BAapINwAQ4cZw7maR/JuGT0ZgDpzds/2MeeFYjO+bpNnNvpDx2PI+szhHH2L0OV/Y8Rzi0IQoQaKBqBJAABWIvAXxjQAIMmH0HllAHPiQi4IcgLhucsBMucCENbsiD5sL85ku8u+L0CTn0oy/96U/fpilned68yA/43CMfK90PMMAECUDg4Q8b0p73AnGISCD/AIzaNAQWMYpauMIUkJCBAzygghmsAalygPodsAEaaJVWbcEVOMEOcJ3ZrQADMuBZkZUKMCANPJELjEAQCEIK/An/jE0JCE0wUEYyTAY0QEMueAJtbJhxCFYK8Fg15QayCYIEcMYJGMInKNYgWACoGQKe+ExsyEaynISbMAAnVJ4/9EOs0P9KwbDDRmyEToHHG80Qrowe6YWerqSDPSiSDEyA1BTABUgYA3zh7eFMAsDeCBgCJShfJAhcIvCB1GlU1CEfdIUZdVUCJpwDbN2KPr0b9YEcDuGKH9pQPvDDPazDDMUHTMEHfMCDy92DO3yROgSJKEhCJEAC8vlBIqjf72VimHEBBLSaCjSDwwjJNsSCATjAg5CBEpABHeDBHWCVGhCgpP1ApdVAK3VdA4JdWZndDaxAEcRADFiBp1hBAswJAmCAJfwaMVTGZEyGNTTDKmiC4lkbLdjYJ9BgjQkWn+hGY2mGdEyKEASDJcAACRwAbZQGZwhASRBAnRzTJFgCJWhCqdj/gxGug3ggDL+c1hOWBxS6lhSSnh261jtpQybMgA5QzbNpwAZ0QO19oQTYHkN2gCFYQiW8mRZFQiIAAvJlpOb8REfNYR3+ow31IX3Ex3xonPThkK4AZB5aRBuNEUzdQxq5UMwx4juQQzp8gzGI3yJ00h0M1yH4JHFFwiNMgQOAWgHkQDMYQylIgnU0gyYcgAKQwODVwe6xoitq1SNNGg9UGk3YYi2RnSzNxH5dyC66wAsogRIowiYoQhAEQdLQRgjaSDIqY2Qkw5YYh9x92HGEwtCA0/8YGwbkFeElwAFIGzXBgAlMQK99Bl3RyXOEQGB9AiiAgiegQuXhg3wMD8K4/w0+mocamUfo9WPs/KOusAM0SAIewMAIYIAFwQAM+GIMnAAJkAAHcAAJmMAJwAAlYALE9aZFEhwcAkIcPhycYcJ50BN4vAqSHZk7EGJKxgo6PBnIPZl0SmfIrQM5BGI8sMc9JCI8wKRO3Yc9+FE3fMM2iEIfMEIm/cEd3MHvCRcWFcIVJcIHFIB9BsAALIAKLIomPGUB9IYR0AYhyCfyBeAAZkEWnIEBmpkT9EBYwdKAyYBYwlIN8EAPrMANTAESwAEfVAIngEI12ckp5EIzQIMzOINlCEMIWsM2WAMx9EJljOBkxJ0HDk0y3QnRGIKGEU0oDIICPMAGUMjbCcIHsf+dZoSAAaUAX5LCZIJCJ5TKPBgiPSBMeHAePaRWE4amOZDeONjheJCWPBhDH+CBFLyABVAAByzBEpyYFbRpFcSAEAiBElRBFewmnO3mJeTpJaQhcf2EJhInHbqToK4QoQ5qefTLq8RRrvCOxhHSHkYfOcSDDr1bGslHotlDHHnDNyjDInQPIHTSGVxRJv7kRYYBHPRGAXBa0eFnAbzfAZBAjX0CHxRC1GkU1RFfG2Bd1h1XD/RqD1xaDbQADbTADLCVLnbdE+hBI1RCJ4CCKhANJ+QVLTSDjzSjMo7gY7QoNOyFZFAGZdhoX3qgcXyCKlRGMmBCBVhCIWxCZQRDim3/4Ni43SQoaTAoxSg46ShkwzzIwxJSqU8tIT2l0RvZYa6Ipuzck+m0gzwggySUiQpogAbI2BIslCAYgiEMwiBQJSEQgiVgAiZQQsdiwiV47CVUgpi9p3DJ4Z1iwjjojsu2LMy67Gudw8HS7CBJH3Va53ROJyERUheJHMhRXBnFHDmAAztkQyo0mnD6gR2EaiE8bXwmgofqwALgVqoandEJgBX4ZShYwiPAwRpM3a1ygRdMQRREgYToQIT0gNrmwA3gQC4F6w0klw4cFyBEAiZ4AinEQi4IDS04KzGM4F04yQhCw11sa7Zyq4wuo2VcBrj+GrDpZSzYaGXQQgZyxs7o/0mn7F0wnAIqiAJlZoItEATCTCk9tAet6KPAuhNAGuw4tI7o/Ms8UMnqqUAGaECcCsHELtQRGYIiUAIlbAIneCzxFi9vpqHAiZl0eSQm5GzOxix1jsN6vFa73Wx0Vuft3A7HYVz26k50ooPEAe3F4eGswOQceQM1ZIIa0AEc5EEr5oEbPFQcRhcm0B0fKEBvbBqq2mcCCEFlbVivFQIctOGtZoEXSMHZpm2E6IDbui0OPDAOVMsCJ4GaPcIlcMLe5kIu+ALkJmOLbkM2ZANkQEM2FG61bkPhSoYyzmjcgau5Do0ymmsz0IIIwAbb7Y9nBMGzmsJVeIImZIIz/AW/8v8r6pLHGsFkPpqH674TPn2pRsyDNexCJvQBCCxwC7yAEJRBxj4XdBUCJgyv8XICNHpsJSBv8r4ZHTav8z6ZO20pOXSp6P3R3FDvHzanOyCiO6wQPdYOGa2DRXzRfAhsTCKERYADN/xCH/yBcKLsRT6UcD1CIpzCB9LdJtQBCzDABpzACxhCXnWQJ1cTGYSBHqABKV8BU1FdFjjBcaktERBBDkDwA+MSDhDBEXgBHQBCI1zw3tZCLuBCLggDtVpDNhCEYohiizZDMiajMBBDLvByMBCDMEBu4z4u5A5NLvwaNieD0ChNc9xwZ0Am3NUCKoxCJ2jCJQTCKLCTPBwaPlj/BGqFxxIa2Xu4Vs7mCnI6ITto6jYggy5IQh9AgsqojApowi3IQiTmaRoXryZ47EKXbMCJGcA9AsRdwumtEByZA3XG8R+lB3rEkQx99HHmo2utQzzYlA2l1njQQzvzQzlkgyaYgXAq8tP+3k9gkXBFAokOjSoU0J1Qk17dydd88iNIgRuggVVhgRZcQdUJX9ZJyBEcgSvjgA1MdQuwQAvkABJIAR0AhYc6ay3wMi4sM7XuRWI8jJCwKDLXgi/kgirwci0YRyzEQi3IHWVcBjE4LjXDsLleBi0QqQ17M2s8cyx8bjlfgh9IQjHsqzkgmj/kVJHRg8IiDMKkQ3PSc0b//+MaqQfNjg7gPAkziEImjMIs/MJnnTU0yMLIMjQm9Odqs/bxRjTATfQae3RHb3QciYNti4Nu27Yczw1HvwrGgRwXvcNrvdEatUNCXIQ3FAOAcZJMF8LvcdLTOgIjHEItbEMzxIJufMaxDNNpUNMn8yUooEFRkzJTMQGCMvVxQcFTR7VU28AttcARhMHm0OGHnoJcg7WKKoPh8gUzMAMKN4MwrLVxgAInUJO1XTMxLCMLt3BeSzOwhUIQoFM3x6s56TQpiII581wfdMIwy4Px4ENOxZOR2WM6QOEgPRlI0tP2edw6hIP0ukM5uIO9lEM3WKG5pYM3ZAMvZILxQmN/uv/2a6MxnF3Ck+lROICDHv2Rbje5k++2OYQDlP82SNO2okKfpMZDcSOZQvwDPKieD8yAcwsnRB3CHixyJDjCHngCiwbDJwRBAJ2Ed7Mg154CKMDvGqASUl9Beqsyr7ayK7/yVD8wEXRBfXvsfScH3/6yMurI4DpDZBzDKMSCKQRDLIDCKVyKNdM1g9e1jeK1jZLoZDAzZqDTX8crbhANk3ZJmHA4LxAEzB2aO8CUPMcNwFR29/KRHQasSq5HpOoR+KLDHNlUPqBDN2jDL3QC8Q5vkDd78fZmJeSpGuOOOCB5tSO5tT+5bks5bls5Rq9xRqt4z5LDO9gUr8jKrKsRRPj/AzssQx9IKPKdOZnLJ3H9HiIggiMsODGEAgbYGjlJVgqMEHKMq09/QkZNnVQhaCo7QRNoXa/mAMS/8ntLNQ4cgRTAweas3xd7Aijs8i8n4zEkgzIwgzI4ujUcQy8suDDgQi/IAi4kw4D7gjAs8wp/azZbxuO+sHH49dkYKQLUiSqcgg9fAiRIgh8cvRlIAjNwgzlgBD7MepHZTcDEDWU/4UVTuWcyYhyFR9EWLR0Nu03FAzhoQzFkAhiLcbNzgtqvPRiLLPFaArZvu5Rje7Zre5P3dhxddoq7rMtO5zpwUUim+978gz18QyqoSXv6BEbOKuP7JCMAgircdS4MAQFw/1ORJpAEcFCvgTdtvEEWpEEaTNVUpXITNIGv3kSgv3dVt1UL4AAP5BcN7AAW/EEjiGwmaAKXZEUnZEUp8MIxWAe3NgOVQMMw3DXGFD8xyPxdvzCoU24IfhjY4FsJbQaqA4FkHu/1iMkdMIEPpAI3iEOiPb1OkfiXTj2/6OPVY/2Sp/shgoM+9IM+FK2k6oPYa4MydMLZNzs0sj3bF2/HcjtAiBMXrltBgwfDJVSoUKA4cw/VPZRojlzFiufOXayIjmM8j+tArnMHD946fv/mSZMEAoSHO3f0/NmTh0+hQXX4JEp0qNAeUsmIBaMVaggBBEEmhRo66VPTT6dO0Qqmqv9QFi5psmT58ePKlSY9ePC4cYMIkRw4cNhQ24JF2xY2cNRQMVcFjSxnAF0xY4dvH79++pgJHEiSJlS/lEHbts3aNmbMkClTZozysGHCfBFrRixZMM+fPSdL1qzzpyARQgAJESICAgIEBMRGACTFJk+VIkEK1CeQnz8zfPRBps0ePnzukLtrt7yd8nTpmKdDHlFd9YnqMGLk9w4jyHfx/IU3Ph6fv3784MljJsoTJ0ycOGnq1Al+/frt62PS31AgwYP/FwownIYkYqi/cDIiB6OLwrGoo3hCEgk5k/yZhxcZWsrAjjvw2IMOOvggpA6c/gjkkJow8SSozz7ZJJQXP1H/KpSmQlElGNJUeQQrrLTi6oevwgLLrLPQQmutt3DIgQcVVqCBhivyyAMQNLRAww417OjDjyyu6AELNHbYwQc/JMlElFeGSSybbbLJxhpnmJHsGGLSPKYUUURb8bPRSCOGlk0EEQSIQVdjDTYBEFhtE04qaQSQRfziiwYZZBAlG3nCWw655eihxznomKuOOusgwq47cNDx6J1V3+EnPH/Is8cef/7Zxx5qSsHPPk480bXXX3uFb7+BBhTnv2MNMragcphtthyHJjKnOosWXNAictDJZ7tzzBmpOnf+weebUfrAYocV8uAQDxD5aLcQQA4xEZCa+DglFl9EU2UTGl+c/7HGqIJJhpZTMOGCizaa4GGHGq74oYcemgCyrCIpNhJJHh52gos8EmnE4489PqTjRxrRaadDAClxEUgu8aSUXoZpprHFuNkGGmicyUayYXwRphlomgk66NFGCyYUQAUFItBJJgnhNaNSoMSR3HQKpMRAfhgzE2vm8Qe95eqpJznmlnuuHHdIhUgiUUE6J8J1UkWH1Xg4eqedetaJB5x7tIGlE00uwc0RRxp5Tz/9ds0PE3P4808gZA9qqFn+oI1WHWoTTNDBePKBUJ2RkvOHHmgkwYOLHVS4Iw881m2XD0BSvpqnQqDKRRhhjN63X36V+kwVVTjZ4g2Ew2LYq4glJv+yYovfqoGGHrZgoyaTTT7EepFP1gnlKOG1vpFIyuyklFnShKaxmmuGpphSUhnGfGuA5kzoWo5meulNNpkEiNaMEsQSRCBhvZ384Q9+8MEZ/BCIVHwDH/xQDnPcEbbkPPA5ooqIRARSKox8zh0iWcd34MaRuMltHeSgGzrSsQxRZCITl4hEJBxRCfhoYlfAyg8GE1IQgXjDG5DrBuUaYpC0SeuC11LQOJCYnbzl4x0cdAd07DEPWPRBDz2YgQrY4AY86EEPNMmDH3yzhwQGIhB0OIUwiEEMYSTjaDGKkVQGJpXPwGhjXOhBDWowg61s5WFgUV4OAImDt6jFBi1oAQ3/ZtADNtCkJoVwJOyiJCUwTtIPeLiDHdaAB9jBznqIWFn4RDELXxxDZotxE5xmxhjJOONmwgBFIPigCE68SF+TMIQgREAACliCEo8iYyLeBUYf/IAvkmAGPfzRDnk8cFMTXA5GKkgqApkjO+p4TjvWIR13vAMerPImSERIjnWwAxml6EQmJOHCSGgCWMGyYX1w6Lhu8NCHQTxW5aL1ECOSI4nrUCI/4mHBdLBjHtnIhB/ycINJZTEPXPQiGPcgxgT+QQ2aOIYykNELNloiRvuSiipC4ZmhvGgoW2gDFKAAlhrs0WF9BORLA2lIQq6lBk5gwxui5Do+RKkNbXCDGwDT/we+2MEMZziDHbYYpUI04g/wWsQn05kJTYgCFbdYY2KssabF2Kwxa7LGMFqBijOORhgDm9EnCEGJTTwiXlab1xcNuIMr3KEPo+CGPeQhj+aITVMPbEc6oJmOIWowO+cA7Do4SBJ43OMein1HCEU4Dnd44xrL2IU5pQqKdm72V5yoCOPCAQ4fdkNAA1oIECUnrWiJoyL99CdGGou25wx0HsCw2sNQx9DV5QGnL9nDTr9I0UD0whnK+MVS8scUGol0pEqhBR/esAU74rErW/nKw4b0UiPNlJA8gMJNIxlJN/S0DWngAhvQe4auXMGoqvtDumJCwD9YDxL1xUNQ/bCI8P+VghdpYmWbuJENbWgDG9po0/ncBI1kCAMXpyBFexqxCKv9Abh/wIMPfMAEwQSiGPNgx3PkwVe/AvYcSCxbOfJZHbeB5ForZpVik+PPE8ajxPiwBz3mwQ1kwII9oBiFZn8FCiEP+ROe+CyxRlva0/InWRnE4ENYq6DuvPYcMP5rO9jBjU4gVGEyUMEa3PCGN2iRDmPOAx1mwof33sEMqFCGM5qRC1rYb180osWd+9W7R7zhvDeYwQwaZt0+lgWmFONuC7wLXp6a1yoGc0ITUIrSHvzAqEd1LwEvyRffdI8JemECEzCMYd5IQny2GAYrs1rgNm2V1c0QRi9WYQpPuND/ar4Jrx1kMAMbBKcPW5tHXvX6HAoCFonj+Gs6UAwRJ0/ZiOj4YEi4qdh7nAOEHwnPP/xRD3pwoxij6MSQgQxucFdkIUlW8pJRyywor5uahb2IOhYLj2N/wxhayoMTMKQCNIShp2y4w4e+4IY5zEG8UcCDJpLhDDjPmWm6g1GeayQURaB3uivtYx95QOjlpYWQhqwB9AzGhSw4ISwl5wEea3ADPGKMK2cww8uPypdQD3OPfw5T1sREgx38QDB9KJMpbnEMUt5MMTTbBjessRlfyGIUt6lEId67Bz3gNA9rmIsMeu4DWHBDHvSQBzs+XI7lqLjYZmsWlKElZc1NGR7J/1EsSe4Rj++8Y5v3oFU/+hGueXyjGbP48ZD7RQrBD54coQVHDn0IDsUf/twJmRx/niWQZ6E4idaqTrzVUY50cEMUB8xDE+YCAi14Ab1ZpAMZwhCGMcThp2H+AhckQQxWQoMY+TNEjPLcFBvJWSiUEPMW7gjolkJMSMorEncL2YIZ1KB4KP/z85+/AumvYPk12MEMeMCEsDBBC3eg1PfpwhIQqEAG11/+DZxwB98EAhGX0AQoSuEKqxLjZoxJ8GZ6gYpRcOISj0jETvUAD9Igi9bAA8ZPwzBMEqhBG/JKm8SubJ5jHB7CWZJNVCjCIhLiIj6IO6ZsA8lhO97BHxoLHv/uDu9ghR6+IRuaIRZAIRROoV+gQhWg4hQwcCBGa7SYbJ54aLaegx00T/PMph0SxNkw4tr24R7EYR6WoQ/UQAu4QArQYA3WQArCAA7gYA2q8EPwwA2iRMzegAcEwxfeZxv+BPcgjhaSARqMZigsoQq2YAucZAW2AAqSIAmO4AhOzizQIpDg4tAMaZDYoi0EcRBzzUkQSdd2wAZWrge4Dw1eYg1K7wzuQhInURLPC6c26RC+x/08ARRMgRUyYzRuhjR8oRWaThMiIRFShnW4yA3ATA5gUQ7uYA3MwAdKYRu+wR7qYTwM68O8IR2oyRyKbSD4Y21UrMQ2ArLg5h2cDR3/+OEZXyUar40f8iEf8GEeoGH/mmJRPkEV7uwbl+wGm0wcykGH7ImHfpEHP4wHr2kIsykdru0fJosbUoEJkOAJpKALpGAf8zH1uqALqtAVfWp4eioLggMVzGcxgsEMYSRGmuEUcsFoXmQTlqAKkqBJ5BAK7vAIiCAsCE27bCCQKmamAnEQCRH6UHIGBgkHiOAIuKDSjCortOJh9qgHbqAHUKph7mK+NlE+PGEUVgEX0ChPcIEVmi4TdCOitpB1pLD11iAK10ALBMMYuK48jGMdsIwdfhE7qAmJpuk6sKMcxsFaQkhB5KYZnxE9vOYZa8U4/KFzOIcbUEETMMESeEmt/7pRjmgB3ZSlIAxPtCKHHM2xP3SQHWcrHdNhB8fhIgwLHmnFH8ThG1TCB5AgH/WRHy3zH6sQDdAgDfoNvayvokSxGWihRfDnNDfBMzhBKnDvE4zACJLAST4gYpjgYbavB8oiN9NCuwztSARxLkySUlIS+mTALWwAYyKmj4AE5VCuSfDIST7uDPKAJ3vy20xhFWShFmKBFU6h6VzoEALwKTlTC6pkPLEAC7QAC34ABDohG7zBKvFhOfIK7D4HO4qt2PJJGJFI7bqjA7eJHODBHO6BH9ABW6rRH+wBHMwhHshhHoohcCjBlgzBECK04ZqC3IoFtZDsngaTWHbQMHkQHf+ZRRyQaLbK4x/4Zht2wQfMAB8xUwpcdB81kzPToEZLjwbwCBBoIWgWskUmATU/QWBScyGdixCKIAluYC6agAmAJEhwMzfPQi2Ozw8HUQVMkgWEczj/rDhZwJBwlDlXjjkP0RANkfl64AzcC14aARIqwf06oROHzBM0oVEAYRbT8zyxoAnQM08jJk9/AEOAgRvYYTzIZh1J7D6RKMVKbD8L67Xa5nMUzx2wpSLAgXPUQZm6ocCcQRMagRIMwX5uSRCCYGkmQXMSQkMPBPEe54caIiE+FESfQ0QpUPPKwx/SQRtIBwTMAEafAB97FQnu8UXJ0wlDjgvqogamgBNu5E//kus0LSEU2OgT7mwqpKISoMAJaIBJykIHdOAGuLVbxyJcVS7lwhWPOK4kr1QQvw8lcw0l36JMUe5LU855aKBJyNRJMGYLjOqn7uC9ACER6qsS2lRgI8FR8iANeuBOz3NJP41hP+3TIAACFNAbdhEf1vEcmIUHZ3VWie0+s+PYyoYd3MEcwMEeImgxUyUf7sEbsAEbkA4VGoEQRDUFgqBmazZQliY7Cs9AUjUcGAeIOtRVERNWZZUCHfMe0mEbgIEltABYXfQJgDVY97FX8RQLsuINPeADvLUQpPUTbi+5ftQSpEJ30DAic6EStoAHrugDciBcuTUGwFVcx4Jc5dY3/wXxD0tSS1OSkMj0OesVOunVEKfPXmsqK4zKDvLgDPztJRj3D17iDByGB2jgYR8WLDDGcsNiByDAAGHhG9KhPMThObilHH5RHpBtY52lYz32HECWOegh8+ThG/auG8AhH8gBH7xhMayhFnRgBERABFAjBGgWZ3G2VBMkIRRPyVoV8YI2HF71MAcqVnmIHJnFGzI2PODBG6ihEyAABJrgHmO0V3uVH8dXCpwgK7oiCz7gA1aABd6AozZhCGYEbFPzE5JCWu+sMzghCnDABFQgA1gAOuV2gAl4bmuAkJ5PLVIyTPQW+hDpXutV+iD4gSMYI3GUBvKVC3D0clvuDozqB/8WxnkuDuNMDuV2oAEaAAICgRnmYVZC9znMAQhNF3UpEFGdhVu6BW3grRq8ARmAwRgUQxvowR6+YRucIRYqgQMiIHhTY1CUhngD5Xj/srAKq2cD80A+NItD1BsyCNmstxzUAdvaARuQQQY2F3yj9gm64FfFt1enQApkMn0z4AOYJAkowRLyxymSS1otQRBwjxa8URU8IQl0wAQ+oAIkWF7p1m3j1lvB9eSYE/lmyvwS2AaGk4InGIL/LA4l2F4JtwfmgnB5gJgq7eSc5NGuC3kgpknD4gAawAMgoBRy0R/MYR198JpOl4aZxYZ3WYdF4lvKIRoywQcCIRNKARio4ej/oOESFiABjAI1gEB/nhiKo3hnMVBzMLQioGUgALMgFg8cEhMd01GcEbMiKNAcsC2KYMEHxu9pofYe0ziedQAKmuAHmGArlm9hkuARLOFTnQJGPAN/cO93ZPAU3sAETMACFGD6AHeRv/WhIbo2Ibm7wNSSw8T8UA75ZkCR4xVHy3VeoVOAUapbU+5hDAa9NiSSGNcOXO4KnOClkUeVR5gHQGAHesAOMiEbkOkeRLYedHGGETWo7/NUx0HszkEcvOYfToIa4YEeikESTOQJ1KAPOgEWjoEVaKAEQgABuDoClOZHwZZpfrRU9wkDG8SayQGDbNAgvpmc3fpVP+sHHwJW/wpqmGXAA8Q3jd8ZnoFVCo5gnp3gPD/4CrRAOisBExShDFzEX0JqKJriznJBNIIhFhKBBTSgAh4AoRmaBmxgLL41CaIgCggZonXg4kq4oo9TYRKRkCJZLfBoXG/yYcZCtj/agFNunkm6pN/QYCwtXTKtpa0rppMzOU0OBGSgB9wgEGBhHvChHtLh6+7mr4R6uikCh6FDUrfjGfMGPTjPasjgjdXAhSDhBgKlNZY4eL8aNVEzIqjlWjIQrRvkZ//ym8Hhrd3abCgihivIHBC0tnzAy/AaCTYSjZ12fL1ACqJgCtIgk+7LDhKoYy6BEyzBChabRjpDKiIyGXyhFjwjF/8wIQtWoAIYgAMQ2gXa4rY/O7RFm5DrsA5Lm3I/TWFMbsYjGfuaD+XE4rVH+OLGwklVLrZ5fLZbrtL4IuaIio92vI9SyiYfhvx6YHWMaR7KgR3k4Red+x3GEiOK7Rws6ILMwZ8y77rPAaCokR/MYZ6YQRIkIRHIQAmUoAoMoQxiYAQE5byXuFBSIL1ppCnYWyMw0Ij4kr4Xz76lV0QdImOT7Rq/oRMwrCWwQMCPoMCdlh+7AA7C4A3oYDoBwURUBhIaQYY4QRHqDPc8IwZNYRREIRY6IxY4IQ9W4LJdwAVeAAbGoiUfusVxHbRFO2LWi3Kz72F/fcaLxzYhGeXmVlz/bXK2bZL5LjfZL27JLXePugImK20rGibSkvzi8E0FeKAJ9MAPRIEbuOEXtRJt4IGKs4OIuhwkrKk5QCItyUEdtMEb6DEQIgEQ3qAIlmAJZnY17rxQViMF8nxQ7idGJkJBytqsl0zQFe++w9mtJU+u0wHHlKEPfAB1IAAL3vlXwdcyszBK9gBeOibCvkdg38MTHiEp/OWxA1kTSCEiheIUPgFtV+ADHvphuqIJ7jBqK7My9zFqAxsLeh3GYzzGL67otU+1wwRMmZ7ZmTPbV/nkWI4rpp3aA+0KsuAN5xDblVzSKCVMproPjoEbvsEbJmsk4EFUJghtJogktinaSGJV/57xHcxBG7iBGnZBEqRTeupgEAJFNVjjzlMg4AXeiZ2YVNcN4csaIwREIBi+vu37rbuhWZ4jdPeuFIbprjO+jcVXRrOQDjZJTb/nhSLhsPWjEzmhQsc6KZgLkEEBkEHqEbiAB1ZgCt7YfKdd5yO9Mm2f96UgarPAYYke2LOPEY9+B2I8c5e+6cH0xoEcJ5c8OWlyvdgLJtlrvbJe67ce27n++4ZpLzrBGr5BHOje7t5usUaQsdR/BD1i/b/jGQ1LG64hFYRKkb6g72VWEAAeNURg4A3//wECCBBBgtKVM2eO3DlyDBsyPHcuXMNw4cSJA4cxI0ZvHDt69JYuZMhy5f84hjTHbp41SWauqGgAAcuTmTOlSOnSJQwcOnQAFSp06FCjSJEqGa2ECRMnTqBAebI0SdCkqJNC0Qr1KWvWq7RUYcpzhQceOGG8RImyZQuUI0eQ2JwCF65Nm1mY2L2LNy+THnx58GDCY4ffwTsK16hROLHixYh58OULxUmTHk0kM7ny40razZuvZPn8GcpmKKRLm+arAgQIHz6YYPEBK1s5cuvy3asHL/e93ffg8f59L1+84bnf5eP37x47bcok+eDhQkmVIkvKEAwRIoJ27Cm6C/wO/ntBhA7Lm2dI0aJGjd04lixpUqRIkibZofy2q48fJiogNGgixRMBPpETTmH/8LQHIEEt0shQRyWllCegkELKUptEJZAgm2S14SYbqqJKMLRcYscdZuxBBxlfnJVEEjqw1dZcZU0hRVxSYIGFFlpgcYVdTdzVxBVNTNbDYDwgVoOROyC5ZA000HAYkoc9CaVgj1WWRZFD/ojFDz84AWaYWziRWRZXnJnFFmk6AUUTkb1JZA8qyCCDDzswYQMTfTDjDTgQpdOOO4LqBo87vgEX3DuKFvrOPsjd4002zAQiwwouxGCEEVYQlEIE2WnnKXYhhEeqQOqoQw5FDaGzkEPokDNOrLLKSlGt4HRDUjm44pprr+XcRo89COFDzzaZ/AFIGk7YZdYUUcDlhU48/9GRoIKJJNJgUZdsi4kmnEh4SiyqcPJJKFRVFcqF5YaiSizJEANKJY0gC0gecLDBmRRI7CugTXB0MRdNUmjxBBZIyGSwwUwc0QQSbDl8BBE9EFFDDjxYjEPFPOBgQ8ctzPBxyB3bgMPFF+dARMptQbwyFj2IlhbMXHDB2RZXOJEFFsv2wIRkOUv2IxNe/tBSE1mY4UMq3KTjzz/44MObP4je40/VVktdjz323KNPP//4Q082sPgAAqbV1UGIIYKIIGrboqZQKniCuLNOqw1BZDc6r0I0a9+xUuRr4L2Gs1s9gRZKTzGS3PFGGj86cVbkUUS7E4I+BXUIttpicokm3v9KSEqIsYASSroeXmiIJZ+E7kszyahyCSSNAKJHvW3QvFmA/M41F8BPsGUTTTTtCyNbRMCoMhE5LM888yM/b0MLLTyPQw7Vo5xy9irvnibuMtecVhM4Bu0j+XwJTXRmnpkhQyDLyIOPP0/7cxxy+9z/T/76N/31PVrbs4+u9cMf88hGJkCggiJkqjrWGQLbQuW2EMAtbt9ZhwXrphC8mcdvHJSV4EZSDvmMIzjwUIc7zCEOboiiD3ewF8OaILkofMELlNtJtYByLQddgnPd+lZTSFGLdwUjGKrIylJAoYpcECMZzRDGKTRRiUgcAg9nyEMe8JUvgd2kCzWxCcSE94T/fSHhd8hTWcSSp7zmMQ8HbGxjx1jAgumNjGNsXCMdc7CyfbEJZmnBHfi2RL67POYxl/HSmczAPhCIghvziN8/+AFJSOajfpGE5CMlyZtHeg0f83gGpRxwKUyVoQxLSAF2IBjBCVIQIhZ8xwXxBstYylKWuRJJO9phEJKAkH7xeIc4sPENZEiiD4DgAx0cBsMYTiFaYThQTy6HLR1eohI71ISEJjSKWiwxGckY4hCZ6DpfmAIUmphmI/DABja4oQ1YzF2AbIITgAWMX8IT4xgfhgQzRmx5KVtj8+q4PDa+MY4CFSjJ2ohQlBXPTaXpI/jSggVABm1IegkSZhCJSNX4/wAZ87CHPyAZD+GIdJKTlOQjScqbfeTPH/aYBzL6AIEFuOBSSxiEIIIgAlBFsG2qLBU50LEORblyHcURqqKCatSjXjCoFgzJLZ/qjlsC6qlM40c80AEObXAjFfqpFx1skoQYPmuZzdwJIM4KiBw+oigPwsQ1KUSKWPhim9zkJjFqMYpOdO4SkZidG7LQhHTOjDMC61fwZiLGMNoTRg473j6zZ73rIRShBzWo9KRnAzUGFKDW46cZ99jQh0I0ouKLKBO2hCPSDukKZziDHexgBgiophPcYMclSTrS4YR0kvfgxz5287+t4aOl2+iEDDLAABjEIAYKHEKndLpT7lAQCP/DQcc74PGOW2JXqPHYjVF1OxzuhldQ5L0leQVVj3oI6qPxCEc3uPGMYQbiD20Ig03EGoUa0VBaN1QrW4uSFB+CgikTikUsaiGLVZSCnJmQV4Nmh4c8ZMFJphkTmeiZ2IeF8Yxn1N4+sRfZyVqPehyL3sguC0fMBtSOdUzZ9bDXFoaKljNnGF9qVXvjISEhSK59bWw9UCdgzIN+/8DtcGzDm3rcRmrA/V89iDUPZ0gCBA9IwHKLsNwU5BS60e0pqcB7m0EpCh3D2Q14wTvJI5M0a/ZILz3S+9R20GPO7WBvOLSxDVj0oQ9/yMMadOcsFu1rLmTdCR/QmjlsrbURRtn/oVI4oZSicEITneiE56DY10K8wYptyNIMVkCDQQ6yeNnrsPE6G2J+TpZjmO2YG+V44svKenpxbEFBQ3w9F7f4YY/BGRdae6YzGbLGEb0xjscnPqNtocexla0MMpENfPzjt4hqM5vZrI+V/oal84CGJDywgALAAAZVWIJzPxXdt02XuiH9bZvv8Y4z60Mf+8AtSSVJyXywObjBfdr8eLkObVgjEz4o0R3Q8DskeMFZLRq0FGJEVjpY0YpnTbSCgvLgRzyCEHzIQyGIUhTZJYIPb6gDGaLAlyY4iQYrgMxjvKS95h0hsjQ3KMmWd9Ccx3GOHNt5rGc9vepdlmQ3P6hn/4kA0M9OZkhOELawh13aG2tBokPCUZpa2+MGOOADMuiDkKWmD6jtZs5ay9qb33y1raWXWPjxQUwP4AIUCGEJOOUyd9zmZVKV9GtVK7JwQhqPp+nvfirVX/7w949rKz696dVa1SL5DWOwps94kIMYwNCFhdMon9sbNLTSwIZfY7216nSDOif+hjccYQY0QIMe7oAHPeChvnB4w4q+sKIoJAEypemB+hqrPJJ1OI23HrGrKeux6cnaYymWY89tbWIW4PzF2NOe8hybR8qEKUifwQxrg11aHdmYoqfNURbOMLPWIvJmXLjDIjJBDXrwb39Xk5/8iDVnesxD//PovwrN8P8DNGACoRQDWmZ3EgQEorJuAoEc+dMPXsMPabZb94APhEd4h1d403Y/iudkjMd4VJM/+KBCMrADfyB7cqAGYEAFNQIXwFc8eZQFkWFIaDJ6pecGqecEh5EGedAGVkRydAAHXrAvkrN7vAcFhpQF+YQ91TN8m2V0q1ZiyQc9NhdrycdqzsdZL9Zi1Xc8+8J0YeIZZnImZxBsPmJsyFZ1WnB+aSGG3scGZxAIgQAL+2cP+cd//YeH8vAN3JAN1kANz7AMyFAMxQAMupAKLMEDJsABCkR3z4VKCriA4GEP7sA1D9gP+EZSKmWBGbgbm7gPHMhvHkg18tNtfSADM7AHeKD/iihIBSu4eS94BDogi7JIGnzRdJ5BhqSnTm/YBrfTBGH1BUogjF+QenDABVlwBFLAIkX4MqQRbEmoPMZzPDGHa1oYhVXIWZtFhc9jPXLEAjiQRjN3czQXc114BHixWjxyGcF2BWbAM6dVdakFSDiiGWwohkVyBnfgB30gCbDwC7+gC7bwCqlQCqJQaZmQCZKgkIGwZ33AGg/5kDsABYp4ATFQHUHwKY84KpEIHsvwDd4ADwKEicHhiRY4NbdRdvwWXOk1ivTQdjsAAqkoB3ewBmjQil70gvvSIjuZBHz0Ga11fjZoer3ITrqXBEUwi8MYLTWyjFDQjM54Jk4AMcTT/xbSuEZptEaVRVn/9E+sdnPQl3MkowItgHR4RHPMA1n8BCN6cQVYYBfqc0hVh1pTR3VOwBnn11p8cQV/4AcMCZE+QCd0EpE7wBo0sCSLQZg8sAVvkAQccAEdAANDEASmtB0RxJHgkQnMoA3dEG/4Blyd+Bu5oRu7IZqF44Ed6IFKRorGApgegIJqgAZnkAU6smEPwxY82SJnIRk48xkzwwVp0ItucINtgHu4pwQuAgNCMG5F0CIs6AXHmAWgBTNhIpVixGFWiZaoNmKaBVAJ5YTSI3Q4gFl0hAMqIH0kQwRhSX1t5Fg54CN7wTM8ckjBVmM6siPisyPFNj5skhajd/8GNbAFP2AHfkCgPwACHuABqoGgCKQCcxKYdGKYDyoDhpkFbKADK/ABLiAEk7llO3WZ4KFI16AN4bBbttF4ShaauSEovFGa9/BmjFd2LyqK/MBJxmCKB4qCsXmMtMkyENMiOoCbu5kFM5MGRUqUwpl6xYl7LVIETdqkDScFNASdaVIzQOMEKzNzy1OVw9dP1ZOWmsVi/hRQ0QOeNsAClZUD05MDRWdQ1BdZ2PeO8HkZOoJR7WgG9il+WoAG+XljkKMmNcgDP3AGAnoGbMAHK5ABDgABi+oAjbqoj5oBGQABCIqgkeoBH/ABL3MDK6ABJ1AG54ZKH1oqq7EL1zAOR/b/W8HybimqoqLZonNWDzIaq6mJGzTKDaXQmhmgBrBZqFugI160WLi5k6BRpMDpBsCZepuWB8n6Bm2QBlOABC4irc35BMs0pTXTJpVRnUqoUFRpfdfnWN+aRuPaT9wZPd9opraGfOp5a2nkao5lF4RkFztip3F5huIXjw1zFnhJelewA1fgA5mxBTrgAQ1wAAZwAAlrAA3AsA3rsA27ABGLqS5gAhqgARzgAnSHbuomqiC6GsWQDuEQgUimNSzqquc1KKNpKC3qonZID7cENtYQCIAJAQ6ABmqgBei3BU1AIHJBlcooBUkQrfvim8UKnMDZBm/gBnlwgxO3TmkQgzRw/wM6cANT6xbWChqkETPZijOItT1HoFjSGK7YxwQSc45HMDHYV5XWozxtFFljCUe1Bkfnqq5mWgMZ8zE2sDFmKgMsUANEcFpyGjQ9IjTBFlG7iQWA5QRquCWScQQtYjOCegZj0gMzUBg84CIZ0AAGUAADUACfawChK7qjS7oF4AAVgAKOeQEc0AHdkR1u07HhkaA+IArbQA+OEoH6YElfY3j1d3/+Nn+Gx3dV428t9Q3A0AeBcAeT4QY1mbNcQCP1ZE/vlFi9E09hkBPNVFZwMHG9yAZOCUc3sJO4J0MrIothpQNq8TJpkQb60nlUKbaOMSSENBgVpQV3sabuaRdr2v8xKlADM6ACPGADKmAD/9ugKjADNgDA/wtqThIliGG5k3G/euEjd9ojkMEmaRKDdskmdhmDUaC1fpQWTcefkQsCWrcAjZqwK5ywEbsAB+DCDPsBK1AEcdcBQuBcXBa7pLKoPtAHqbB/H8UPXcMP9zd/vutvSXw1STxcdThn8/ANxSUJfqAZOrBOanCnWqAvYGRPwzNGhhVP16u9OgEHS8uDvcgFUFC1QNoiwxgFVLvG56u1/ak7/GJP1tkWLzO/cXoXhEvBTKC/IzMDdHKgBzypc4LAHjADM8ADi8xyoPYkgYEYO8DIfkzBQ6IjEzXHgzUao5HGUMDJo2EaTskDiJr/qI0asQ3gwhELw6vMsBnwAYrYARXpQNC1w6TSAAfqw7vQf/YQP8OFh/GzxEz8NFqDh8eMh9+gzMrMh8OgH3/ABlFQA86KxTsilQGDWF8sPLwTxmKsvXAAB20gnDf4BvgyizspjLpXtS1QtWssGul3BrzDxV/ML00wNPfcx4GEF1NnFwMsA2uawCrgAQLdH7K1oBnQoB6wAjLwASoAJYs8yYnxFzuwPHmhv/CoyZsRymoBMx2NraNMGjswoSrQqIn6sI3qAAyL0ikNAZiqASbQARSAASOgw7cMHipgBgkKAn1gDN+AzHvISPOgh3uoDdqQDdcwDdEQiMZAiMCwC7YA/wupQJCiYJAIqZDyFYd5QLU68GuIdJ9OIM+IBUbw1M3evL1lPM6pF3q6t4zHSbUssAJx67c6IBpF2lpdFDwDAkY6w45DYxdnAiTktyX72zE5AMAB3R+U6gEQ0KCKCsArINAfQAODDNERLRh/YdEXnRcytgUbrbWfDdKh7ZQA6gQfEKmPitqRKqmoDQGJiqmsGwMwQAE1bdMCkQh5IAOLCgKSwAtSXZBVbdWSwJAOyRoyoBrHLVsgwNowwdq6/Vp50CI3wAKfgVFFE9a7w81lnb3fDM7g7LTNii+5x9Yu4gInYALnjd5T29m9WKhdpEVgVDB8So9huH1OgAV12iOK4f+vMpAaho3Aie0BKI2gMzDQNeABGaDTDk0DCBzRmP3Hgb0loeVHDSXaFQ4FjvEyC54Bx10nAetacQgJkkBN1uQJlKADJoACn/pAsLuRsSsIQNADK6DSf1Anj/qwN47jOf6wB8CwCdsANJAHdimLftt06ZMZMgHfY8Q7N4G9YczdZAyE3GtF6xR6WyDeLHID5o2pW24COoAWXOC9brBFen0T2PwEeIqnWDClYdKG+Z0YJMjfDarAlMqoDauoi41Aij0nTzKhjVEY6Agk6AhIobW1FD7HFf4YTukEXLBpnHAKcXVguJALvhAMwlDpwoDpwtBNoJAIF4sCMRAEGKmR2LH/w0EgCB8Abg5QA4XgsP7hsCwM6ys8urEeurBe609yAy7wAifQcj/iJT7iBPCtRe9U1t8c5ZXDExO3rOnEBkp6FjrAAiawARqwASYQ1yzg5TMT5tqLE72z5FKABuGuI+G+p2lwjIMFBWaCF4lhBv+NyIq82Iqa0opqsCrtATZAqVx3ik9ymExAyZhNdRDOdKAxpMdInaABJkManWBCdUSyBT1glz2ACblw6Zme6cRADBYfDKTAch9wAiNQAt5hmaT+oQRh6ptQsw2QB5XgAArL3CrN3DWb0jpusLROurUOapYC1yxAA3lBGdo81oe1RU2eveB87NMicUy7rOyUtMX5/+wssAEWYAEmMLXn+wXpJM7q1N1kwe0AE8Y1uafhDvbOirT4ou53ghcEvsgMOtCTuqgNm7AQcAAOcNp6Pic78NA1YBc78AOnlcmBhMl0mbjQ6ZsHPzOApfDb94WS8RhbwANskAdaAAoVLwwYf/EazwkrwAEVcAElEOoTBIkJ2OKXKQhlwAm5QIJJoQItPPcNCsCFccCxL9CKXanNzaiMutoqcM65WRd4MWjarNdjnRNcv91lNS1GP+XrxE5sYHvk+8Y3EPUf0AJJoASSY7TqhCB7oP3aD85NbhNYsKtosAY7ogVr8Ibn3otpwASI5O973yOLDMAIKgMHXrOaCxMNcP/KjRrgi42gNDDSdAIQM3782PGjCROETJos1HIQYRMtWrBwocgly8WKGC1SvHjRSRMnIRcu7OGkpJMrWALFyuWr10tfMYkJc4krF6g3LjhcGJEiCJAQQEMEBTLJqCAgSZUqTQGkKZAIISKIEILJVzJPoDRp8QDBwQGwKmSAkLFjh4wZM2SsVdHWbVsPceXOpetBRQ0iOvTqQCJyIRLAUaI8IVzYcGEpXbqEYRxmMWM4dCRLhgPHzeXLbTS/efPFcxS9J0yw0KFEiWDBaTS3YeMG0GQ6lSPHhtPYjRo1aNBoucLkSms3bdJQ1LLDzPErZq4YvzJDhXMPGVTY9eCgwVf/CGAheADbIAOEBipo2N0hdobZHTyuRGTfEGJ79hMzZplPcThHjx9DfhzZhEePknozwxNfcOmFF5h8mUmYXmqp5ZIVYEChJxEQiCCqoZYSxKijlvIwqQtFKMGSXIiB5pJGDpGjBRW+c8ABFXg46wcf1ioLPRl3SEstG1fw8ccVVPjxgxVayAHAHhZK6Agmj0AiCcEOk/IJKapUrDEsaZusts04W40zz76IIgm9WLgBSsG24IINNjTDjI4wEmNMMSrDkIyxy9bQcw00sMCiPd0kSu445ZgwzoyzZJjORRYyeNGBBcAy4IAFFnjxOgg+cC69GmgoiAcefjgjItzgI7W9/z9NjU+LQCPy08+DsBgpIUMH+qG3HfxYBZdbDOwlJmFoyiWXWAr5AIUOKESAAASI8lAQaDfsECgPpxLBklqEgYabRgBZo4sncFDhA+v+OMuHGtFTNz1Q28UR1BrirWEFGmjwkYUadEhSyZGaPEKHJAIuDAkpqzS4yjAqa0w2hhlb7eE2wBQzYL1uuEEvKNZcs8023oytiyoJ2wPO2hLWw4077sADjzv01G3PNe6Qww471CC0NzUM3QEEEBb9IIMMIj3AgEgNmPSAFyGQ7rkZPPghC7MGuuIMMyAqtT014MtNt91UZbVriV5dCFaHEFJP6itovASXWm5BEFia2PaEBv8NOqAAgxRCQGDvDJ/VcENpkQICWhE6oIQWYpj55hsu8uCDjxtqOMK6HiIRS0eCdqiBXVDrlbcGGzSPl4YdZ1joxx7yJYKIJBUKKa+9Ak6CMIIRI+xggxcreWGFG1stDeA1Y8yLKaQAjEyLoVCezY3b5MwNOz9WrIvYopdMjzyyz+OylM9QGQ+aab4jfDnkwM0MQ52DYP1Kgbb0gAIGGGDSSR1Yf327VICACSzSS3vqUWnhaqTCTdYEqAaXteprXVPgq2Alq/404Qo+sNVAzoAuUvDqFjAJli+IBYgMVGBCKUhBBCx0oaGk0FkfSsokkCKIICwBBZTIljK4MY95VCL/EV9Iwht0kAEPXKESPABBeXbAhB4opAlIWiJJeuAus2xOijSYV+SgYLHVAWgkUIhdwKJgPMAgRgqGORiVpnelxzjmSsEBXhvb0BjiGUxfGduCmijCJue9oQ0jS1htxjgb2ODBDdojZPbw4Ic//AF8K0vZynJmBjU4ZwbZaUCkIFWAAhhAfgOIVAEodYAGeOA6KrBBWXjgmzNcYWp2ICDWcGO+ArohgYHiWkR2kyo/uSqCI5kgBQfCgzP8QAaQkMUtevWrDuZCFVv4QAVIMIIglPCEUcGQCvuWlKckJQhBMEQdIoGLYRjjhvOgRyHysMMW2KAGgKgEFlRQnhr4pwmv/6IVQlSpSkKdwQ4pS+QhGhGJSmBiDWlrwl4MqhfZJQEKFwkjlQxGxodaaXpqXMyVwqAZNgWvDb0jXvGk4IQsnEGkIz0DmzijR5LR4QksaAH19rAHOEjBTnsYpPYA8Yfv9UGnO2Vk+BB1HOfoTzsOeED8PAm/AnSSUpYSpQdmUAOE7AALJNXnAQt41QLCcpZcq+XXXOVACO4ybb78QQ8GsgMfiKKYBvJFB2vBCRpkQAEY6IlULnRXFFpThdgURFOWMAla1MIXvzDGNXCIw0QkggdO0MIhPKEJOfzADH/Ywx8OsYh/XuISmNCEJjjhiayAAhSkIMUpVKGKWMSiFi3xRf8wWkuLRvgGC05IAhIOCrCAKU+VTnqCR3EnUZBJtDGKkdOc0sCxh8lmeMVzQxpEGlI3sEGkJj1pwujAggIAAAADgMAKpgAbOBQyD2wwgw+O4wOe+aAPLLMDJO+QMzWYRQbgaQD8HnCAAXgyk5lEKtEycB3prEVHTEDDGrx3B6qtIavlWxks1SCHla0hDVrgAhrSYGEtTJgLGb4lWMPaHz+VlyA/+A8PxhIIVswCQb/ooCoA4YEHKIAEJDQhXqup1xQ+JVqKCEUwjmEMZEyDnPTAIRPs8IdIgMJBpzAtalOrWgdFeVhTprIHqxwTBSUjGafIAg/a0oPVre4IW1ReHev/GDApfBGMSJiCF7yQuza7OTEWxRJkShYmPOeZNRlVTceCEzEvvYEPVRiAdg29XQ2w4HGF2EMiDnEGPrChBmLxgw8acGkIgICC4CtvHsb3Ayz0IC4gqC8m8zs0+MkPk2DpznYyMAMn8OAiqmSVSBm4pwLnCWbHrUiv2XBcXmfhPhbRj0dAEpK0mWEgvuxBW3YACmEMI5zIGIYvYpGHFcT4BUEQwV1x/O286S0CKbBEMKCxjXl4wxuL84Y23D0KU7DEyvOmci5wcW+b1PvKvZgylhVEjGBcIgcmBgET/DXmJjrBzGdGk2AMFuczxtkLdK7zwhiTZ4zjkc9+Fk6fOVMI/0Io4NDaDUACJvAAJfABEIBowh2yVy8ZqMEH4DEAprPjATToYQZpw8MVeuDzFmUnUgswACbjl1+jgeUrcdEUSPLQgyzU0nuyzLUs14AZPukJYntu3h3ZwIX7GLsJ+dmPBCv4Ayb8wNmBwAWQl8EMZyhDFGeowAMSEIMS5vXb4N6bBHhwC3TjIx3tYEc62u1uf/v7VzF5ya/0Pax765vfw/I3MYihijQQgQZjMbi/SNKEWy284VWagkdLD2c3T/wxutvdxb8gsdfD/gt73njHNONxQesgACMHQAISoAAFbIAMU9ACn9BAAxWQZeYNMFoDwDOAAARgUg1YAQ+E0wO12P+gRZAygAM0SalNnvp9HqABD2pAHy70gAspa9kaBGl1XbtBkFnHzEn1+HU8ev3XGdlPRzrykXuSLLT7gQ/wALQqBW5YnMXZhlHYgQ9gAAZIgW67sb3LMRJKAQSQAAcIhGO4IXuQB3lIh3I4PG1YvLdhvMbjBRXkt8ijshaksgRBwZnABC7QgRVQFMBAgibpD1UyMy5AjS8qPd/yLSmQOItiPSzxAoxbQs+gvY5Lgz/rknNaAADYPUMrAAUAiwcwASLYnjzYDYJYCwgwmppbH+iLvuiTnwVYASdgERZZmg+QFE/6Pkr5CvsJJR6ggSdqghqAwpTRg5UBRMzAupV5P/n/0543yJ77Ww08Yg3gAbteswj/Q7YA7A0msIsZ8IFAgIZvOKxvUAZIeEAGmMAKVCEJFIELFAEKeIAzEAZ0IycQNDx3wwZs8JXGWzyXuMVewDde7EW2yoUE+ZVfaKta+AMuqAEWCJIc3MGFQAlVygI1CRgkID0hFMIzSozU84Lh6aMw0MZu9EY4ysZsxCg8IimNc54CQMPdEwDfUwAGeIAT8II8UDhAqJG1YD4yXB8DSEMNODroU8Nx8YoFuA6l6yQy/CQYSb7mMAtAuIKYqalCgsjskchC4gxF7BJGhESwcyP88D8o2IKQUo60yR90KYXFoQd5+AZr8IQPSAAJ8La9/7vAUyShEPCJC5gBwOtEHPoGdiiHbphFbEBBxdPFFPRFogTGYBystuqEH7iiGyCSHNRBhAsJ/6MIaaTGavQtkOmCbNzG4QHHbxRHsfQCctS46ZLIGjjD6Ou9BIDACbAAFiCDNdkC7jAAEBjDfCS1QgsAC8CkLIS+KgwALHQABfiKoTEACBg6olkqCLgLGTglFcADLMADQMACl9MeiiSkzLxIQNMj+8OoSLQP4ZBE/6ujixDJH/CAnlGvPkCGb6AHevgGUfiBFWCABNA7a8ImmURFmUSBGkCFbEhAIpuHb/CGbvhJWsSGlqCJxMvFl7g3FeQFXkQQXcxFLMPFWvADJv/gohUgkoEBjP0AqY4QqRzEytKLo9yZE4oTxzDAs2+UOHEcTbCjPTYZxDyogaMTgAAgAAhkgAlgABJQAh1ggy1QgTIEAU2aH7tsgL08AAbYrujDwnRURyx8AEexlEqJlO+ICxXoAQHDgivAgzX4A0DIuZUDBC8ULxWdyO1xk8zAjId5xEiUUfTTiFlLmx8IJXTpg7Qap2LoAxmoANvUO6Z4CpkkIacgoRJQAlEIzsWxB9h0N+RMzmDpIGAhypdwm+ikTqJ0ieaMCVDwASzIghzwEQ+AqPCctYs4A8AwTzfrxvQcrjTqxvPUxjB5AzqFz46aAvkEO+Y5x0GqAaQqAHb/7E8GwAAYqBgomI67TND5aVSSmwAAEAAGyK/4CYADUADATMMKvdClSsjykAGEuANAUBlAOISVy55UXVFWRdHLwEzb27o2ug8ZnQ/gOYMsUKWBACJN84NA6INjWJxXAFINOAACiAC8yZCmQFLdXFZtioEiAIVzE057qNbjdDdtSM5Z2FZutQVufYVXkAVwDddZkAVz5VZXMFdZ2FZj6qDn9IVaCAQzqIEkARUniEqCEQmUGE82ncYiPL3Tw52Kg1M3Aww7gQP7a5ivTL3gALuS+ro6Gik8WoFBZce29D0GsIAXSMYboAGewa9/zDQIsMKiWrUBOIANgJ8AOIEJVUfB/yyAB/iZFokRUQUffzqEP9CDRkgEPVgD7HHVFNXMNNDMjtu6GK3VNiI2/8uC8HSChNDVkiiJLGCC8vKBTFCGYQgEH6gBReAABiiBCxwKmjxSEjqhECiBLwAFa9iGBGQ3cRCHn8TWWVRBXahbu61bW8hbvZ2FW+DWbvVWv52FtqoJtgGFK8gBqHKIe60dKsmPNR0pf/3XasSdrQSZbGyzKZhGbfQCIKxGsEy92zsuPIrY6WqNuOqkAoBA4GvLCdiAG1gBHFAL5kPDBuAZwFSA+AG+Azg5pEoAC0DDwERDAcgvBfiAI2gBJliDQ9DZK1ADQEiEbjkEnEVRFqVeWB1aFf+F0YfJjCccjqSNRLJDCXtKG4VTnoVYg+LoA1IYBTuYlyKwAAl4gRgYAsFJ0rw50hpLAReQVm7gBnXzBnZgB7gFh7jFVmzYUgTmhbvVBWNqYAfWW72t218Yhl/gBVtgm0iYgRw4AntaIidp0ym4CJC4gsc9g4MRwj2duMaYMyl4UzczPSUUE9Tw3CRUDK5ZAzZ5rpA6gwJzuS1oAx2wAOCrgA2ogLp7gJhdgRpgEQR11EwzgCocgBw4ugMwgQ8oKtw1AbU0NJcNgPxagA/ggZVLJB7Agp5duUO4AxI90TxYVc3czIjU3tvbSJgBm69yIBy1lfJVnozhAv45hETQARf/sOINMIEiMIIlWIJoWiGZBAILEQEU8IRtSbefBGB5GOACzlZs+AVO7mROTmBQVmBdiM5dKOVSnmBgsGBcOAUbIAKCSYiD+OA2FeF93eEzIMLzNMLhmhNv1Mbi2VyMqzOFQU9W0RPpeq7pcr81PoRHwIRHsMHuvAEc0AEWMAHp4JkxlB/ERK8zrEL9kh9WG4Bi7eLoEwD9dNkB+AAbWLk2MFg9KIRTxVlUld4TrWdWZVXunWPgWZk8seOwYQ9lu6crWLjhaOGEcYMtiIFBTjQWSAIlKIMyiKYLtN8LvJBITgb/pYfjrGR5MAcCLuDklDaRFukJ9mST/gVgGOliWGkg/0OGZZgGapiGZ2AGZegEGWAS1nmILPjOJ4iIsUkVVgmZ20mMgzmjM+rK4gmDzghmLCmZgxEgY56us8wDy1oEgMKEzyIFTJiBPKgEKeADOiCCeRqL+mo+nYIA+bFC7UpdTQXn3/ViTo3QllVLLy4AB2ABJPACOEDRE02sROonVD3Rl3opPRhsPThsPVi5PTjsQsQDQDREfs4TrIOZPVEDO+CThz3mNcgDQcoDLqCDJICBQR6NDziTL6iCJYjobSKhIIiWIMAAFLCEZNiGbLAHf+iGcvBJbfCGcgiHawVKbDAG4W5pZChuZFAGZoA7aIAGarAGa8iGbNgGtl2cw6runf/kBmXogxmwrQ1+iHt9ghx8ArJ5FfYQ6twx6ukh6iLs5SqJYaZOQtVTDNyI6hxmA1VNBEiIhEi4BE4YLVrIhVqIBVrAhEp4BHiGhEWwNEnxAUmQhATdPSssZ9wtgA34x3TML1W7VC/+R3Q+gAz46nNKLOlNpJuqZxMf7Hp+qRRHcRNP8cNm8cVG7MNGJOwhpPGhrMNuAzxIAhcY5BNoATPpgYsZgjKwAiMfgtQ2BEUwBEOIAUKIBWGwhm+wbW9IB1nUBtz+bU3Ghv7t8m9oWwUMcwWsbnmgB3vAB3zwBzX3BzTHB3bIhlQAARsgEyf5iLyQZYIJq5RwoN9Cb8Vws6P/7iPiiYI8S9iGSSP5RiDjw6NBet5/qgRNCC1VCAaAg1dS4ARMwARHqIRLUPADgIAGlwQETWsIV+sAwN269mJNSsN/pGsID17B/IAQdzRad7R5ll5ch2d4BoRCKIRD6PVf73Vhl15dF/ZCEHFhR+NfN/E1PtFEQqQ+8IOVWTk5yIIeHw3SuAEASQIjKHIrgGhCIITEMgRC4ANMiIVh4EQzVzcRjNssP05avAbDAkEQ/IZ6F3N8lwccOvM1/wd/Z/NqnQdqCAQQmAEdEAIdYJKCugEi4K0qkYifJu+i9nOKU6OBxRL35B07AxlcK7D6pGp/AqhL6ISsOIVcCIZgEAZc/4iFU8B0/V6ERZgv8JCBBs+ETJAEJmBQcl7LDRfMM9TwM+xmWFfHk2WBRHiER2gESICERmh6p3f6WpfexJp6qofencX1qQdkXNf6Q0AEW//1ZW/xP/CDQ/ADadeDRFKDLLgYeylti+mBKKgCuS/yOuCDY396JUucG6IHdctt3daGnoR3bKiGa6hWKLVuxN9J4uxEekjze8AHezhOb8AGTySGPtgBGpCdvYCCxTWM9iAUmzGDwqAC0i99MDj90x+DOEj9MQCDLnD9J5goQfeMpSaeXl49LXjYs0R7R99vrPYEUmAJYQgGYiEFUOAEHQIEOeiDu1wfSbD5TrD5TFiEUf/v4pGD6+3aR7jmcLU055ZFw/ySdf3m9EwHKKWvhKZHf6pvBJivehHvekRgBERAhK2nf8VW9kNA8bBnY0AARN5fOYDQk4fNmR8/mhD58EFFjRsuXMB48eLGlj+aSMU6VauWMGTQtnHzli4dO3bltJXzVk8bNpbXrtGjN2/et2/cQHLLeTNbtmvTrFnLZm0ePn/+7MmrhqxYsWfMkA3r5GPHjSRWk+iAAsXJkSNPvj7RIlaLmbJq1Jih8pUKFTBg2LqNO2ZMnLl251K5SzdMmC9f3vj14gUOYb580aRho/gMYzd6/hxqFKkSJk6eQJmKlctXrlqnSIHyhCkSIDyQfID/gCCjkyjWrDP18SEDwoEBAwLgDgBA9+4BuwvcDh7A9u3cBwoIwC0gee4BBTw4unQJE6ZGlyJBgjQ5UqPu3rsnCi8+PKPyiA6dP6Qe/XlAgNofArRnj/pC9u8XApQnj/v+bdz74cMVPDShwgcgrLDCBzqsoMMNbFTiiSqb5bKZMM0wYw032nhTTjrtpOONN91wiI2J1VzDzDbOLFWMMcPA+MsvvPCiiy2wpAILLLrwUo09/PBjzzfI7LILLMAA8wsqsc2wglU6QKlVE12BFZYWTTRRlhlnqcEWXHG1FZdbdMUxZhxn5nWmmnz59YZhYcBBBxxvIsaYnWewoYcegEQ2/xkmmlxGiiqDqkIKaJ5wEol9h1zBhAx9iFKKpKWIApsPqIHQwAEGFJcbbgAAYBtuog5H3KgHEJBbAZ4WANwADYBgQyOjLQJJJdnd+t0iuy4C3niJIMJIesEiUmyxwiICCCPqnTcfIuIdsmh87kXbHyB6HhLIJZ0sAoK3IKgwwww0bHHGJRPigosv6uaCyzHIWLNNS+WUI4885ZCIjTfaVGMiNrAc40wqtrxC8CyzuOIKKwi3Ukoqr7Qyiy4+AmnPPETOOIwwvnTyg7hOYpWEVk40gUSVVoqlJZdvfSmmmHPVZeaZT4BB5plz+vXFm4TN2QVfXaRxJ2NsrHEHHn/wKf9ZJJdoYhkoT0ONaCXdAaJlJq+UIokkoqTSiSSXypBapseZStwAte02XKnCOUfAcgG02pwCrQb3KhNqYLdIJNjt/V13vfqaSHflmYeeI44IS/h5yDqS7B7Khhetfe4Vckgi1QKC9LV/XBJMMriIIom2oFB30WaztCtLLBvhUqMx1kzTUjfpyGOSiRzyi001NSojTCut3HLLRqqvHgsrqKziima9UPMNP/+w840yv/jCUS6rHDJDQ07qcAQSToBfMlhjjaWlWWO4FeaY6OuFvplz0QzzmWy+adicYfjMVxr789+GG1hoAQ1rwMOe1KO0SkynaYjiBCdGc4g//EAGPsj/BC9g4QMIgEASmZBEH2LjLQiAsAEqWICriAMcUKVtbbhplduGcxzgBOCFyBlOAQ6gqUdBQmt765vfeni4SPyQEe453OHMcywiFis+57lPtdazHvfQZw94aIQfRJGM6flCGMIghhY5Q4xkBM8VvohFLFRxPOAZYxnV0IY2ZueOdpjoGmysBh3TlYtmVK8WZVTFKT7zGVB0whOBGgUz6PE8mewiE5AIxCEW8Qce0CAHLOCe98AHPq98hXxa4BJatuQ+9dXsLmoSZV3G0Ba90M8wgoHT/XjGvzS0IZZtwAIA0SBAo6HhDnfIgx/+wMjJVIIymKjErmLjA0mkIhU+8AAI/z0wAzkEooOYSg0VZLAAspntU80R1dlalZwDvNA5c+sU3GxoAANAwAw5rMQO29mdR8DTOz+cJ5+IiLgjOgKI5Ski5iyXiEJETnLu+YPmGPEHSfRiGK9wRjOI4dBjCCMXW8ziRlSRkVOoYhXtMsYzZNeOetTDG/6aYzWuAwlMBAMSPzjDDmhAgwR9QAMVWIADMvABJ/QBGN+4xz/s4Q1g2EIU4FIBQyapECR0BQlIRYIUsNQETW6Sk2f55PrcF8q5hHKU7ENl/fgymMKwEg6y9J8b1oAGTdbyB1fIwhlsuYY1+FMymLgEMY0pCUldUEEZYKYH1OAHPJgBU2oYm6YMUP/CuhWnN61aVQESUEPbvFAAoBrOOQ2QmnP6QDvsbCd3lLZDe/4wEuUBIhH3OU/TNu5y0qpcePCTOTsAonKQWEQneLELa0DjGMf4Ihe1ONFYkKKPE1JFLXzRC2RQIxve+Gg93OGvlujOAQ5oQAMSQYoPLCC7DliAAhKQAAUo4AEaWEEbFlEMbvjjH/T4RnKbgYofhGsGKliBCjKAVO8lVQoAhGpUpYo+uMAsfVfdql4GfCY58ex+X70fnMLghli6IcJnpWUTaBlAN/Qgw2rFQi7dI7ilaUITl5CEGUDQh1KMwgwekAgMWtACD3iAB26Qgxp8EIhAZIq6DZjBHjxQG7P/iQqFAWBOAl5YzlZNlrJn8wGnqOsDzkI5yu3MJ+L2BtorJ84RjbictQAROco90MPcWYQkZgGNjzhjGLpNRjK42Ftf+JEUwSAGRlHxC2VYQxvygMc96tGNE+krGg+ogE0/gAla0OADK9CABixgARJsYAMauMEbKqEJZMijKPighzy0wQxo1OIPehBLGmxgA1re9wjde+qVxsJqqP7XZe3D6oBhBrM5zCEOYWVwGOiAYLBGOMJvNetbYdmG/bVhC2zYD9LUw59E+MkynYhE2HzQiU5Y09EnUMETINAAhWQAXBzMsQ21JYlFqODHudkNCicrAAK08IWpOtWmMmUbAzRA/waLuI6UOXvlRsCTtFcuIuH2mZ5p8QmKj+tyf/YAqTPzRLfHYLNDHdrmjXSGGNcjFDGyMQ97+IMf98CHN+iIIm0s6ANviMIKQJGLPDSoBRIxgRBIQAId0CESmUAGUeCBD3vQSxvcaMYh1ICHKwyoB1hSqlKj0FTyqUGT/l1fXLRqFzVhPeu4nkOCu+7rXxMm2GIf4IOPzQUupIELy86D5g7hBv40gjKWaSAkZLCaTqjAARw4gRA+0ANwReEECvEAE5gwAxBicINai2YfGkBOT7H7bQKIbHPOCStOWd4M++bhd6yMOEbM83DfGfjnjWUsZKmnP6mXz0BXD8U/LEIYZ/92hjIqLgyKc9EXug9GLtqci4yQghXH2MbH/dHndvBrGtO4Bg6kwAcpKNUNpMjFHnJABCI03QQn8IJ1JMFzfPi80+VY7yy2hIcfmIEJO2BCE57A9ChMAQvm25JYpHqW9129lHfBNdb5f6atx0GcfN0Afl3X4cEBImCE5cGD7c/ZJcba7Qmf6MEd/IF1VIYndAIooAK3dIImyIAH3AAMKAELwEET5EAhmIAJfEAG7JUKeAAIeEAgVIrWdFAmZIIPON7avA1vgMpy7OBvnJO33Bs6BcLS9NvhBMs+lYfgfIdpEU7jmF4UJpG1IJy1ENR+zAcg+EEnCAMqpAIerYJGtBn/79VCZ5QRGcXC01ACJpDCLQzDM3yDPbxRPSRFNEjDNCABHcDfnMDBGoBCMCDCE+zBHAACHeAAEkTGJWTCMhDFUewLhzwDifmBGhhE4T3VVyiVFEwBWZiP/XFSzcRBrgVY/v1frmVdKPrfgRHgACaYryFgAkaYLPXP2uXB41gOtYBYIHnCKMyCMNzCLJRCH6gAG3wBGRxBIUQBDvDBBqTgCaTgBjxAuF2CKFTKBmVCJyheH0CAYdmGDyZHu3nK2lhWA2CeAchAEW5W53kelSHhs/hNEhrRscQjPKYHtbjetPyBHyygG9ABffhBJoDAKBBDLUDCDhRCGXHCKTgNJ1wE/0OCAicUAh+AgirIgjJAwzx4AzvQIb9IgzSQgSJQAhkUQgM9QiLQQjBQRwOpZGiMQioMRVH41DXwBCz0gR/YwZYwQQ9gwRNIAVu4nyaigSfanxzIASiKIl2QIv9tnSmWIlPGwSqyIl8I4CvqUrHBEgPCkmLsR2wJTp8gEKB4giisQi8Ig4wMgy6MgiccAhpgASBEQRTQwQewAAycAAq8wAlMwAe8YCCwRmtQIzZqjQbJADYNgAB0CnPoxto0wDYOgOX51dKkY3Zkh78V0bP8Cj2aXsHhE7IcnBN5ZiDooxvcgRxcAR7Q1vT5wiWswBtQwieEgiI8AiUEE2WUZCV8gv8lJEIwkUIzWKRylUQ6YENHhsJwYtSgxAItqEIyNAMtaIYZVsgWbQM9GIVPLQPt3SBgCZAToEEPSEEXuEUXdGdQDuVQygGZHOVSomdTmmJ6hiJhQKWc2I8bHKAu3cGwXSVWPuDbceWWTUYCXcYorEIWbdExKEMzNMMpQAITHAIfIEEhqAALFMEJ2JyEbgALwJi+dUIp6EIqtIYNXqMkiIEHcIrZvNu8CZltMFM5yoAfLAJl8JB2UGZpMcKvAAtnZmbBjdbnGRF6eOZ6BELmEBQErZ8wkU4dUIIiWMImWEId1IF9UIIn/BMfUMIbFAI8YYIq+ELAKNf4lUM1TEOFnGT/LpxkMJDpHTXDxmzMRmQRMXCDdB4FNyADMcgCE9iBFF1JFMCBFKxSGHASjakBUZ6Fn3IJUeJB1s0FejrlKaJiKgagAK4iWIWB/9DnsK3BfaYd2jEGGuCBLTqC4CAQ02RgcBXXFikD7UFDMySDK4iCIzyBg0JoDAiBEMBACn5AC+SADKiADEgCgGLNX3oNB32g4xHHD54oOWLeAfiAHywNJlyO4GjHZAocwc1oeHiHFMqjEgqLjNpoEqlHIPgSI2XLjf0AD/BAF/BBIbTBlhUBIRBCFRCCIigBIXBCIlDCuyopF+TBI4TCJ3wCLRDDMUxDG7WDPHRDNeRCmVZIhfhC/zBo0Zlx0S3gwqiyqZvOAzcsQy90wg6oARq4QRp4QRTogM7wxRp4IqCS5wEyJSme4hioAcvaDNbdBR3gAR3ogcz6WteF3RqwwdiN1bFlAdpxQRZogXw+zrJ4qnQAyihYFEcQgzKUKjQ4AzQUqC9owh+oAA3cgA5UgRUIgfbJZSLcwA081RUsgid4ocPMoDGpgQqMaGEi5m30BnFYVh8EAgJNTXdMWbQiYREBSyLM47Wi1hMW0SIgAuESLo9my2fe2FTIwApMQWzyASF8AbuWQRnUgSEogirQgiKApCUYgg4kAiF8gpKSgi8MwzLIDqdhAxoSSnEKipo2VCmYAkatwv8uVEM64MOmfcMzBOMOrMGbeMH+CNBZBZBZ3Z8agEHLyo9c6B/Mkon8xEFUCaqfniIemCyhEuX14oEbuEkbRKoX/EXOiG8UcMEU9Noe2MeHIdCfCBJmxAIuCMPEvYvTlipD4YInSAIPeIBMWYB4DdoNfMAHHoELeoAZaALXYGM0gYAP9EGmGBYMrY3cWl4D2JgfoKOUEZE+gd49IZG1FgvpOQKv7EojjfAihCsj2aMvLULCAQIfPMIncIK7vmu9ci48fUIlPIIlUMIOU4IhfAIlcIJFyUIxJBc92MMRQ01otO9lgAIpiMIovMIx/EJamgIqwEI11EPurhcz3KAK/O7/mwivWdnS8Mray+ZfreXfXfypUKpB1snBAWbvG1tvHP+pG/SF+OJxHn/BYNABH8SWfeRTMP0JoGAGK8DvQxEo/Tptm4HCD3hABlRATFnAgsTXESSICnjLBM0gB/WBGXgbOHHjvTXmBIOQiQVCrWwHlOXTlLGjPSmOFGorIyyCI8yWCNvyroBrfqSeL6XefhQCJuzwJxCCIVCCDhPCIwSTJTBQkiYpIRQzJfTRKNwCnrXpEatkAzUNAymxKYyCKMyCmvmCK6SC7cYDP/hDxSJDH+BqV8WSAInxGLfMrN3FgGVVohrd9ApqU85xHAMqHavB77aJHo/vFHgBnHydH3Nl/yB/5X+igizgwi0klDHMrzKs2THUgiaomIEomlVUhdI1CYEwkxhkgiZoDWx4G3XZ0KZUFr6VcibTbQ6lcr99lsDprWZ+MOndck6bsBPdGEGtRyK0cEQO8zBvAi1YgiIwkCcAsSoMZyhwAiUM5yNggiC5wjAog8fZAz74kXDp0eq0S0QZ1y4Yg3I6wzJoAzmY8zxswyvYnQqwcxu4s1vZUlXRmiht1SipiVLi2hwHKhz/qT7zcz/DcfauARy8wWEftkD7BUGzkkH7GuUEyyP0JyGTAiqUwirMAln+qzJI9G7t1v1Kwg7IwA8cNujuAB44QR7wAR9gsiN0AiKYgSRogv8ahBB1QcB0acqmYJC3SBDdSoJ0IFCUwSgrZ7DeyigIh7BO27J6XE7iemsVxlYOv8HlEoKSDgJyMnVr8isQMzM8cYKhrMIvwGFWH6xvbVFvfdEWsdkwFMMwEIMzWEM3vAM/4MM8WMPXEBXPRGobUGp/o0Eak1Io1sWZmKconiKNyTGhzjF6Zi8CNvhgEyU/InZiK/YqMRgfft3jADW0TUcghQYojEJDq8sWGYOLlPhuEQMukEIlnAEfKIEi8EAevAEfJIIOvOAlmAIiwJijeEDYwJgH6JimLGYm+0BZLAKgaMJcQRm0xmhoDRxqXRl2ZIdyn/KuNMJnhlls6UcjSKn/ImytERSBIQx1HSRBEVRBHYTHM89wIUTIKyBDdNrDeVfcbrUZm1FcMkjxv6ZRN4gDfX/DL/iAfHmAG/DMgw1bWRHbW0EvXhtq8zKq/PwpAQ02AjIqAurBK87HKx4gHUw4YPyFp+fMGwjGnsKJ+RZGnADC2/UJ04SYJmRgiL/vL7iIbhkDRRsoHnkCIDRBJWSBjEOBIjhB2FyCJzCBC952BmCyDPD4SQ85CPT2pUjC03Qgv8n0TBd36Ekr6UnmlOd0lS9Cc/O05WzZHjCBE0RBIrj4C5CAEnzCG6RgFRSBmVeBMicC517ulD4CJ6DCMTxDNtDDnBMoqirDneN5m/3r/7swQ5v6Az1sQyc4SmrswaVvr9gJ2y2tgaIOuKHqRf85pRw7+BsTZV7jWqZrOsknYAGClX4XNJx4wRQwtmEwdsvzsRNwwRpAhmRcgnaAKoijwoj/KzIoAzLQnoEmQy54QoL2wNlVgguqQIjtgEZXgAPkqgqk3w7A4GJK0KXQbU1ehBJzwmYx+SqDFml9lthLK44+4S2TMK+sfZj1KAvfQRvwgTAXAQxwAKzCwCYoAiEoQRUIgRUY6UeSeR1YAiFUGii4SzZwg53juUXyZp2z2cQpJ0WXKjd83DwoQx8wQQ4w03xI/AHK5/a61R24QSpeHQBqlaOjYilCuKTPscjPgf+me/wBzocUEXrXSSWksrzL8zFhEPQUSIEmCgYPKB0a6EFkXLneKCIhxwLE+sJmO0P03zqqjpEmiDYguOAOeMIl4KpNVUAFkK8z3Y1seEsHdZDW6A0TCxIn0JWUz7RxO/kqGzfaH05OH0IIq4ctZw4g3FgjNRIgAESjQwP15Pmio44iGC+KVKkTSgmMGGWqKFFUpw6lRHUs6SiEyVMtYtCyETNJTJgwYr18tfSVK5cvYa5eGQMGa9c2bvPmwZJ0CI8ZH3v26MGDx+gaPG6YMs2DZ04cqXHGVJ06tSqYMXGiSu06B2xUNXjklD1K9ihYr3OIEsXjtm1Ro27g1IVDB+//XTpwwoSx27eL371+vXip25dO0aN6AB1qBClSpUuYNHXyBGoUKle4ZJo8pkyZM9HQmiUbJemPBwgzNAHK4GDBggMOWrBgkQGCDB+6+/T20buPpEugiHvChOlSpUjLITV39Pw5I+nLl0eHHp3RdUfSpSMauGjRd/DjyUNqdH48pEXNB55vVCgKQkN1CE2q8qJKhQ0wjAhZYgUjPhIppBJMPlGFlFNySaaZWFZB5UFSEjzFk8s40aSyTkSBBZhimNlGm3my6WSRRuT4wQc9VDxrqTXWaKqNGK+iaqupuqJxK7W4CutGOcgy68e0eGTLLRbbYlEOveoa7K++AOsisMMK/yssDC+kmMINF9FY4463/vgjkEWWu+QSDC9LMBbOehHmM2ZEcwY0ZYQhxQ8P1OBEDg/YyGABCD5Q4oQ3PnhiDx9+k0SS3hL1IRJPSAHlQk6QU+6x5iDRTrtIsHOEuu0Q+ZQ7ULeDDrxDSh3PkVLNQ8/U9cIrEbxGAGkjkU8IKaO/KgapowgLYFhCiDIGsYSSSgrEhJZTOLksF2GS0cQTTZblZFlMGsEkEvAkySSVYqLRhptwv5mnGElKRAPFLslSN8s1YowxjTRonHEteneMKqwZfSxrXyCHHPIsH4/ityy89rKLLycD60IKKP06LIwpvOjLC4nzQEMNF+/Y+I4vTf+NjMwyoQUFzc18IQYZ0JhZBrRjkhFmlE5GqbORDx6wrYgi+PggjucC2RbRoM245FFPIpWMUksv3U46prPDrmnoPv2U0+im9nRq7w7J+lNTG0kE7LAFaiw8U//II4o6qrCiDABDoYUQJcrYxJBBJqHEEkskJcVAajlRJZdg9PZbUkk5vaSTUoBhBhttHC/Hm2/CFWU9QMwQKuCzmoJRRqvsvWqMG3XUscZ+CeY3XxujOn1ggZPM6+GEnXwy9oSnkNjJxBYzCg+OkWqskchAlvbMUUxp5ZZfhjEGmeaROQb6Y4Y5hhQxVfhAig9YSCIKJD6VRJRUROkkk/IX6cNRoyX/xcTYpC11mruoN8X0ua259g6R7qYeCJD+GxsIgAE8xB/2MJBA/OEQjKEDHyhBCUNYgRCfCIUiDEGIOgxiEIYg1iMegQlqedASIFEFLTaBt02s70KiqMk15oEPf4wjHOgYxzi6EblhgCcQdviBGZigBrOUZWNLccO7mDIjq9QIK6GjClc+RxUfEkwNUYziVqriuXmV5YkCI8vD+rKkJvmlixDzixSe0DC97AEpKsrDGvPABja44XeOMRUkJEO8ToBCFKVAXi+GUYxjEEMZxygGMowBml6M4g9Y6AILVFCDGVzBEYj6BS9KUclRZKIPfijOhUJGqcegymlMo592GOEd/0BMDRBkUQMVmCCH/snBh3vwHyBk2RhAfOkP/svlLG9JQEAI6BOWqOCtLNJAQmxCERa0xCc4AYpPUIIWocBbM2lBrAJJRhSyUAY3xmUPf/yDH+94xznIgY53fGMbnehD74Tig1YCSQ4bY8q72sCUG+HIilJRYhKRiJUoYlGKUsSn56oIy39qMUl3WVJeBiOYvcCuiwwzI154V5Cm5GFzL5LlHfzwBzGRSRNluqPxWHGLW5yMGJ9RhjGg4YxmNEMYoPjDDnYggx0sIhPg0wUs8liKUVzCD5C4jNEw1L5InEc94IlfqPInP0c09VO0jMtU32JLNL6FKP0jypf8sNUV4f+hf2f7Uh60yge6YTCZCTEEJTaBTGLx4RFt3cSBJJW3T5xCPZLoBCyQkY15yMMegMXHYPHhzXvkIx71mAcy+iCHF6FoB+/cV8bu4CJ6FhF0VOynVzK72aoEFLRTHAMYSHvEgh70h697aF7+4kWDNTQMgekiRdmI0Ta8oY1sKIzD3HCFM9jBD+tBFCSEU5kzyeKkKYGeMqBhDdKUxheu0IQffJCJTnTCFr+oZB47YS6QVAhDIYVMJC5VtkVMTX/3K2VT9RdAXvovq7TkF1bdYhQV3Xd3G1sjR1VUCITgTRGWUIQDAZwITKgiFMRqIN4MARKQnGJDxrDGN+xxj3isgxz/74DHYO1hD3zAYx/3qAc7vpEKH1BBD2z4wQ+agIP5whIN7XLX5uYFurX8S5/5pFFoQUtaKvxYK2oYgxrA4MMswrIsLkrYYWRrF7rQJQ8Hi63D7IKHxNT2DTF6Q7wMczA37GDFZ8hDIMLkhzBF4hKZgBYpTLGKWqjkM9CQMzTilAxi1OK6oshjKlIBi0pmgo5DDW9yxpsqAOJvqeu9X9YEeAhexheNWZUikPBgBzuksS16uIMc7HCHPPzhDoeQJR/4oIQ6aDCYFKwgJSSEiVCE4hObEOZa58pMUIyLJx72Rz74wY98+KMe6ZBHO3q9j3KAyxmJurQQ4SAVOcTh2c+e/xccxtBsHc3oK/maA0GZuCN9GpnHatBCQPHAJTdUNogb01hlX8S5GNmWKWxoAxtqO8R4vSsN9RwiRt1Q7zTedw+1XSMCzzM8aF2GZKuIRbM8EyfQlMbOvRDf+Hoqikv8IRKaKE4nQnoJ5iwHEYk46ijdc1T0kKdrA8ElWeIQUDM0oQk8pOkMZCADHOTABjY11Ax2YChD0VQGPN+BFvTghim8YQUmUAItmG6JRDyiEJTIBS0UEWBZa7CteTshJTyMD3qwox3wgIc//HGPe3j9r/jYR2CzYQ1b9EZzdGk2P62YTx3fGF+e08pAsxJuHsthSy4SPJfYzSUXZSELXOBCvv/7DW9+O2WNm6MnvTEaeYH/W0UBFzhZ2wMyyhgXM22uBS5w8YuUHiNlgUxGMlrGCz9XshSaEM60MOTx5mTLMV/7GiPc03vyftI8qwKP1gzoaBU1xg9n0UNRMGbQKMbBDVr4AROobwY1WN8OarDDGtCABSxwnw5TIMMKDnCCTQRDFRq0RCU6yAlFJALWlqjDJNaKt7xR4h7vKMf+09F/wtqDJwLwG74BGnbhFSTBB1hEiNags+qun6pInz5n26iotLKCtC7Q73gMDQJvAzdw8ATvDjrQA+FIiJiC+wLvAwvPRY4C8jbPBZ8ijTANeECGTCjDMkChzUzBFWyBj4jBGKL/B3qaJ06kZxhwwRSiheM6jrya44ByLxEagTzAoznSIz2eED2QylKCRyAQaBFy6RDC5kvILBAAoRASYY3ewATXANTOhg3O4AecIA/2AA1soAV0gAUKgAGEoK1izRDWChMegVoaKNUIjBICzBLW4RzOwR3cIR26oRvkQR68QR7mgRuugRmQYRiUYRhmYRTUIAFL0A3cSNqMqIqQKCoIqkauTS2qqAJH6wK1Ytz8TgtiUQs88AQ78APNrV1QsF2yBA20AAtEEBdzcQ3eyI3c6AXZqHfuC7/0AIEOgVOUo44wBDNEYRRKIRVsgReUxwePwRi+UQgDiRhuoRTIJwnJZAkP/+GA/uAJnzAKlQYewwMyek8el1AgHGM9zgNsACEPDKgLPY0f+eANvsALjqAHtuQP3KAHakAFVuAKZgAiZeA2CmAQ6EYRJoFuCIEQDOERFAETKGEjLaGE2ErAAiwexEkdvMERvYGbuCEbmKEYbKEUJukX1kQTgg4U88AOzkANSPECreiesKKJSpEVweDHqIC0ZjEWpWjclNIpFy8NFE/x7g1eYkQYr1JLNjBewqAN4MANuBIs08AL2oAr5ylGGm+NmFGNOgqXzsZ3OspUPkYyRCrPrhEVZGEbh6GPiuEbmQcZikEXxqd8ztH23MPRwmRVek8xwUYf7/ELAWgd15Hdvv/kDs4gKq/gCn6g5wyl5nig5lagCQoBEWjJDGDJDHZSC+5guKBFUjyBFp5JEQbhIjeohAwhwNgKN6sOb/IBHsyBHeSBxFxSGozBAFPBFWaBGFYvGXLBDGpuiGLEjeyADYSsFF+xtITyKsBis3KMKEfrKL9TKcXNKWcR5p5SKhNPKuNFPdPgKm1RS4ARCySmyw5mYmanLmLEXWYMozBt+ZyRq9gS1NKNY9SgY9YDzUIqQ/SsFFAhG5WnGPiSeYzhF15hfDRBzSw0OUyu9xJhPRJTMbXwPBLIKLrEKP7pD9rJB3ZABTzAA2oOBDwgA1oUBGa05nzgB+wAzTK0EjQuQUz/4RRUAUgX7iV8IRhy4RQqgQ/yJoPKwDYpgQ+CaT6soIHyJhRKqK3KIR3YgR1cchqYYRqQARiURyWI4aXsrBNaVE+OUU2pszpdUStKkZ/wiTst8AKP8gnuFE+R0iiPUgtgzk+bYDy9bzxr8Re14DnbYD3NkgucgFGlsisPQwrCQEsEb0syxlLdQIuQ4ijMLBD8wMwok6P8wNLO4Axs1Aw65hAgg7iK6wZJARVYgQf76AeNYRNFIaS2hdDCgx/biB071VOTL4jwwFM5yg4uZzd2o+ZcFARkICgMZUZp7gcgoUz8BjNGgc0UbvRqYRZqgVtrIRe89SW+FSZkQia49RQA/+E93gAhqqAMiOUTPiEYTkGDMMgK6iaaCGHAwuUliwEYgGEY+nV5/sgkSkMYYmE3WPQM1NSN3AACM6sVwYCzjLIC35RG3nRPqeAJvhNj89TH8FQLqA/mmABQvc/7YA4LZlFQNxAYo1IqoZKeojLfuOAMtIA9ydIWhXENngi1KG1TO8pTcWljRvVy3HDFdujS/gC4EFOkQm8VZiEvj0EYegEVyEcSIkESICEQgoIJasCRVGAHKs3nwjZslZU3FuFqi4sySGYUVsEVIKQWYsFbccFbv3X0SK8XWKIleoEXeEFucUFcc8FvYeJv4RYUBuQRyCAJTsAEYKAKChFfg4EWbP8zNsuAEABkShXBGjRxkobh9F7Kc4+hF76VQvzgDMzgCohxDWoEAicQTnMsDiSWdT3LOn1MY5Gyir4TDJ5gUDkQBWPMDX5RZXtgC3qgB7gACoQXImmAa5dXBkBABVSg5p7XeVVgRmeUep3XepcVepO1pnyABzQTzH6AB3iABsj3eam3eV90WZv3epPVB8ygD4jLuqxxQUdBFDCpeSEAAgygAQ4AAjzAAQ7AAxrAAAS4e/sgTBAlza5LQ6zRFCDEFY5TFra1FmShgmXhFV5BFmShFVphFmbhFTo4FVABFTL4FfgsFU74F37BF+Q2F2JBQkihQiqEE6CuEN4AE3QgCXb/pW0GgUmBRTaVgBImCCMGAUBss27WSm95ISWS86WsoTSIgRVGwRPuCBQiYWN+4AraEw2KshVbd15GK3S684heESl/LGPROGM7Nk+fAFCdcg3gc0u6T2WdMgsSdgucYAugAAq4gHh7gAf+mAeoD2R7oAmwILLGlwnEVzNpYAZoYAcgEiK/l6ZqqqYi8nw/IANewwE2uQE++ZMdAAJAmZQbQH9n1AcCYYGt8X77wFB84zf6IM08LmQqw3hImEFbwYQ/2IR32RZ+GRYyuBVQGIVhARb4zJiTOZmBYRf6tRiWhy/59iWCARPYIA3OgwyTYAUQIgaEQAiUQAgmwRKWwAjq/7UMhMAIDOET6kAIMEIJlGBtKIJdy6AMFEEXpodByjQZgqEWVAFSathROOFimOAKasApNzCKzFhPydgB57Tu6hR3jRJPJ/oJjsCiKxpky1NQ4fNkC5UD40XxFrbfEvaNyIoN2YgPvoAP8iBGnIAHauB7z6AGoOAGbmAGPgAiVUB5hQ6TWZRFIeAADqCUg9oACvgAihqpkdp/QeA3AmF+sfGETfg4XaEVZCGCb8EVunX0bmEWbOEWfjmDgTmYe5mY+0yZf3kXmtmZ+RIZlsGtn+EZpIEaqCEb6rrt2o5WSS8WaIETVuAGkkAHqsAh6sAIXgBYFgKDloBJY8AKqoBYDP+hXePGCjJIsAWbnq2AbcogeqL4W2MBFIxjmQQRFAqBL7zPoJUSoYnMOhk6K7CT7vTpJ2dXon/MFdU4Y934jcnzkIHxkG+2FleWC9pgjfjxjbIkD5yxIPJgIN+gDsjgDeIjCgD7BmiABm6ABVYARjPgAz4ARvX3f1VDf01Zf1Wjf/+3emWACchMWheYgUWBFFZhgz/Yq/eWvneBvn8Zv/H7FXRBF2whmf3bmHchwNOawNeaeZTBraOBGZghrqeBGrThG9jBGybccSjccbABw7XBG7Shrq2hGGCBJeTWEz7gBGAAnAEFBtBZCF5gxYVgECjBCIwABqxAbobYEEyNxpX/oAjURsfZ9YLoeRBWTxhygRWIQ0I44V1FcsA24XDJ4Ep44I1FEEq+WLNckRU1iztfsSiJUqFn104BtQmYYBZFVg2YwAbE/GNxTmTVnAl4ACJtgAeuQAuuIJFlAHzRmwY+wAT2fLs/AAJwQ38doAFEObwdwANedJQhQAVOEw88SlorAzNwEFtHD2/vVhhkQi9XuBdWmNP3Nq3pmxd2QRcIfBcAnNT7da0Hqa0TvBqqQcO/ARIncRIDUB7oYcMdp8I9rMLuYRG7Add//cKvYRuI0xbCFRNq4AUkgHGVAIOEAAYyiD+8mV29uSHeWSMrgiJ2JUobV7EJgV0VoQx8wbOl/+U4jkOCZI0SXtwSCoEMokAKaqAJdkAEXaQvqjO2tdzKyRjfrdzGXPd1IfrHwBzNRdYGnncGbMAGIjKnWVR9qdcDzhcERtmUxZu8BT2o/de7PWAGGH0REAfS33sVWGHhLn1MPSOlkkFgT0Ll9fJBH/RfUR3m0xrmW17Vm2cZomEaruEaGgfW/4oefh7o6cGFht4fiJ7oyW6w6gFybj0dXOib8iH/6sEd2GH/fF0byqFxskEZSl0XvlUTZiAJOIADMMAKSKAKFIIEVhwGUAAGUlwI2IYQYEARqkAI6L4O2EawbVMjhQmD2gazUYgTKMGDkry5FSHwE+EL+pgNeuAMaP9ABLmsCyx2T2V7yyGQtRsadGg7K+6UkLUgBw4+5yJrBqQ3439a4gVd4sU70Zk6laU1E+iyE0A+5G8Bb2UiJUpeLzn3G4kBQh+0L1u+L4Of5r9R1d2aGaIhGnY+GqqB52c9AOmhwzgs+geL7Krf+smOH/wh+7P/H77J+/8B/IveHkiMwr3B6asfHyBRS9mh/4RNcqjhF3ShJmPBE3YACqqgA0ggD1/ABVzABNQeIJbEECIERpVBg5SQEKKojpIyhJZYEWKljCVFFcsgLGNlyRJOmCxh2mSJk0hLjx4VwsTpTaItW7L02ELjhxYtaNCkSZNTjc+fPqkIpQLGpxw5RpH/qsED9OeYOGOexoE6pmhRKk1y2GDC1cYMFWBBqPAAgSyEsg0aeADBNqwKH2rs/IG06BImTZ5AjTplKlatXLh8+RIm7Neww8KOHTt8uNiwYsaKOZZMGZhlYI8rU5aMrPOyZcykWbumjdu3b/NSp6bHmrU9fP5i+8NHu3bsf/xyy87Nuzdv3L7/CR8unN+/2fbksWPnzRu717KRt7ZXj7W8eduK8eLVCxepSlx0kJDAgMKSKkpMfKBUx0UVI4bKaDRkxYqhSRVDbaq/RNEkIRApYR9HhkRUxiebfPIJJ6GEYsknoXxiySYRWgLFCjLIMAMNK9Cg4QwgepjhiDvsoCFY/yiOyJZYbnmwFgguxgiji2dBkNZZaeWY41kvqiCDDz70EQgkkmTSyZGijGIKKqi04uQss9wiS5S34FKllbfYoqUuXGrppZewfLnLmGSOeRllnoEWTTTVVIONNtp4U0456bRTz53u5HnnnvXYc8+ff8aWz6C97UPcoIT6xg+ijOZjHHHDOZobo/z4U4832LhJWjXp4AMPPPyooxxzb2qDTWrKAMPLL7eMUogihMRwAgwoFGFFHXUoYgklnxBCCyW31kFJfC/AZ8UgtHxSHyEISVTRsYMYQklDdSyo4IMScsKJgptsMu0NK8ygIYc0+KgChhn6OOK6bamwYoYrxquuDP9hiZXhDED68MMPZgi5CJGXZJIJXnqNYvCSqKyySiuytOKKKw5D+crEsMBCccUVv4LxxhxjTKZlaCLz2ZrRTOMmnHA251w68tAjD555ttOOO5/eE08877xz882MAvrnPoZCKvQ/QEvqWz7xIJp00rkNrWhv/qRjapuZdlMPPPHwc4879kjdTTemzkPNMIb5MsoVN1RhRRVVLCGEEkVQQoslg1hiha/JWKJEHYNo5BHbVRDyRh32KTLIJIRUZMgghFBiiSF1ELLttgpq2y1J21rCxw00mDjDDjXU8DmIIK67LorqzpsvE2ao0Ycf/0oSsCZIGlwKwgs/CaUtUroiy5T/UM6SysTEF0+8xakkr3zyHH8MMmQiL8Mm1SjHKWedMbezTs7w3PPO9jfnrHOe5JPfffg545z+zvkA7T7Qx/nss2yB+gPp0/jn/1ul8HSDTab/64Y77mGcfFiqHXNC2TUkMwxhmMIOKjABDOJThSIQZBC5UsLbXmCFJGwLV3db3HkGUZ8kvGFtwtrEEsqgCEpMYldlyJUiEFS5bW3CJCSp0Bt68IN87csMQGLCD1tnhzv4IRCB+FckZteJvBzMFApjhSxqMcVaWNGKuMjFLbi0RV2AKUwb+2KYbAFGjGmpYrZw3vOix4ySUa96KmtOOcZBx3GQgxzn2N733oGOPqJD/3zoCJ8f+chHngGKfn9CGs6WtjP2Ced9wonNIeV3SH/cA5JECxpx9Pe0SPqjHV/rhje+5g6j/WOA8EBZNJAxDGIQgxV+UIEOdACDIpCgDEJwiBJgUAeCsC1yOiAEIQwBK/rIxxJVqMPg5DOIbtVtEEJAgRUUUSBFKGJboTDJhLRpCUtEiBKFOEQkKnEJTZjTE03UCylOoYpY+OUvuciFL4IhmHoSRhi9yKc+t7MdLvnTi14CqJfKVKbLACNkIouGNKZxjVKV5hvyiKhEr2MP6ryGOvW4RztqBih4+PGj6LhjHxtJDnOY4xzuWMdJufcOeLRUfOtbZD4yGbRG/WZo7v8bDvwweRxL3gOR0bmN0ZpGtD9171PvIAc4zKEOcYSyG+Lwhjn2sajc3CMf5ohTNQ5qjFdGwgMSdMELXtA2I+gHBkqwmxKqwEJr7mpvhthVC4cZCvbgKleUiBYKCnAACwjBEAWKq7YmtKAJ7YpyvMpFMOQZDGG48rGQjaxkhcGYyv7isr+wzC54YRnMbscymTGGZ9o4DWtkIxtxgmhE50EP1tLDHq99LWyCGptK2Za2tX2U0BqJNKTxo5E7A9oljdo9St5Dj0yb1KPgBxxFDa04VMXNPuKBG6H51GfwKN+nPkWOdXjXu+IrqUlNCg54mNQd6agTAtPBVKr+Jh7m6Eb/NZCxi67iIhIzYIEFOHACI9SyCLzcRB0M8Qlo4jWtnyhEfKwwLAZP63GFIARH+HZMDnAAIsSkhDCnpYgEkWQQLTQc5CwRDFeWWLIojuwxiPEYY7j4xS7uTPQWWo1rZGMb2zjtabmhGtdU9Me0mY2QZ1tbf9iWqPerrm6f+1zjOFnJvBmqkqXb5N48krmRalSiopyoq3r5pdvNblPBQWZxmJnMaCazN8ARjju6+Y7qMIc4TKqOdIiDHuxoRzrK0Y6I6ulPurXkpaLhYmUQ4xI7yIEJyIOCGAjTCBjchCKU8IK1VssSb9BB4OpwEGYdaBPEBCzg2MpCBDVucQOGXK6E/yksaUVObVbYmydoEYwTs7gxlEmxK6FhDdPeeBumUU2PX1tR1gzbNUE28pN5Y2T7Obs4U14yk6dN7SpzUtrNvSmWi6NlRoXPu+eIszjSTO5Rfo3cZp7zeE3KDnWcAx3niPc6yFdn7CmnNRF97aha5o56xAYffZKHNrLR62b4YhFMYAEDGCABI3TACEuADyXQE7gqvK2COkhCEdRGiMilGrDUBGziWsg4DFIC1Bpu9YMgB9gJNQQjfHtDHg7BiXUKg9fMeMY0pCGNYjhjFyy+J2WLwYxscOOhPLaeyupEwJbiQ77YuAbVvPEyPwGKyP8Wsp9me5zj6MN+PquNbWTzXP/mHvLKwvF20pTGM0Vm7dq+oe2icuYOc4QDHGa+e5rDkW6m0sxn7phZnoo7+K2RT2b99jJS80SbH9tjHtdRTUSXA3nmeANl3OCG1KWhDGPwohSdqEQPPkACDJyAhDAwQgyM8J6Nl0EJAlKC4zrOt1tByHCRs6auNgFiyA2zISd/3EGO9Qlq7spugdsEIdRWBxpwwQuMgMQsTvONYGvjGttABi8QMxiyAYMZcdIGar6hDVGOUhzqKOWi8nEPcLipTW5qmT0s2fXoNP7Hd6ron7D+j5/af8hCVm3RITSTQin5Iyls9w5ztw7xZg7iZVLjRmbdQGbhUIF813fpRz7v4A7/cTZeg/cpeuIOLYVU91AP5MMnKBh4ypEOzYEy/9Mm0xCDO8cmMshza9Jr0vAMzGAMulAKowAKmgAILHACFiABqxcDAvEeQlBBMIBhdeBNjsM2SkAIn0ALBYJhjaNhywdiHddyeSVMi+Mfg4AgJCQEEgFNbKUEX0AJZEAHgfAKmQds88AO3cAO3LAN1qAM9+QLl7UL3yd+zjEPcBJK7OUOzOUOUAd/3SAPfgJtSxZUlURJ/9BtzWZbl5RtnTQclrRlQ8Vsd0IP1VEd9PA1KvNUphhK6TYnqjgO6VUOX0MnMiMze0ZH3QU+vbV2+VAzfBIz7EAP7cAOc3J5pZIp1TAN/yRzjNHADKDBDMzYRm30DDrYjMxIDdDgDMjwC7NQCqIACp2gCZgQBm9QBBfwAkIQA2UwEC+wBHVgEHzTOCRUBlXQEBAROAVCCJJmTYNwELByNw5hj18oYdOEEIMQhWUgEbhUEcLEB1FQCIvwC3coGRAlStyQh80gDPV0Wbzgh9HwDZdnD+UnSuLADnmyD/dwHOLwglRTDn5CVVumW5ZIkvvgDyT5M5d0NC1pZZxEHIjEfvmQUhwIgVHVgtWjdHFUDk4VSqPkDVG1lKOkinuminNSJ/KQDuyQDuClR9/jXekwDnPSDa7ogigJf8WIjGsiDWS5JtAojdKYlp/BDMqADP/OoAzDoAupoI1N1Akg8SqKQAIoMFaqZwR/pQgnADcw8AKDYEFGEDd0Qwh7wzYOZghGYAQoMAiqQAlKQBIhVwfzYThsJREPAhHHwhES1nG0xAeRkAyZ9xnKEVXbcAy3YJGB0Qu+wAu6MCbFIA3c0Bzm5w11kl1EExv+A0Bu0g4EhBsGWIDS1T7sFw9XVV39Z1yI9CfU9UjEtUfrgEcmZYrgMIFzdIrptXStSJVVmV7iuRzLwZu8aZ7LQZXpZZ7h+Z3lICdgKZzGeJb2SZZtYpYkExpmqYP+CY0ACqDM4AzP4AwGqgyKMQy9MAurQAqi0Anc6Amc8AgmsAIc8AIxEAP/fVkQAFKYF/Qe8BEt7AE3ajMtj8Z6EAFq1DRMmikfZWAIvFcgjBOafTMIRmAFkyAfypRLmNAMPGZ08zBKE/kLq+AJkuAJgpFFW+SHt8mRclQOeeZSuOEP/ROW2DBAQ9WSjhJtz4Uc1NEa6tCBEbidZDqBoURu2ylKUDlHcyIOUfmd4Ome8vCL5KmedhpHKgOMXwMnYVkN92mfzQioa6KMbfkMyZhzAMpzAbqoiAqNBnqgK0YYC4oKD3oJlyChmIAJoPAGH2ACJ0ACJHABJzCqJ8ABJPACJ/BXFhcDfcNLsKc2AiItimAr71EgVZAgefV6D2EfoLYf/5ERVgBxZQUg/zfgqUqwCL3AY/NwGphyh8lACodQCXkBCn9RC1GSkcVQDdzglVF5PryhDlOjiBnViY+SG8I1k/dQXNmVJxCom6H0kWh2itsZDt0QDmzKiuewpnU0Duewr+bglOmlZ+SpPelwDgVrsPJwGplXPf8jdWP5pxB7ltJIlmvJqNHIqNLYlsz4GRzLjMhgDMPAC7bgMJS6jaCATqeQsqoACknwAWXgAh1wAaB6ARiAAbICAyfwAjAgBEbwAiQAAzGgA0pwAnUwN2wlYTCwNrlUBkWwcdbkEO3ILMvXXzfqEd1iCM5SHx+gAWiVCKBwDDiGY+KXDdCQDKBQCY3QCJ4ACZ1QC/+xIAu3sCrAgAykISfloA46wzT+oA7B+T/YUA748FPWJUmf0g5imqZgc4pPFUdllm5uuqZQSZ4Auw4Fi5XfI7DluWfmxqd9+rARa58LpZ8K9bnRYKile7oCqowZ24zLyIzOwIzKELsy9rHFYFBjgjw+qCSoMAqoYAoGMwq5QAuxcAqcqgE6cAEWhqokUKo/ewIdwJckEAMYagQkYAImoAhV8CAPQQlFIBCACZiRg1acJi0IQQmUsAQkAGl9szbecqIToQOaqQSJUHO5kAzQAA0Elwy+UAueUAmP0AigcAqcAAq5gE8sJhlF9w3lcA5VZRxeWlHJNhtYB3Cg6Iv04A7/czqnVckOEvUNHMwa2MUa7QCKIThAlFRc6ZqufHLBedaKXZm4Q2kqnOu3NPw/nMuwNGwqNNxQUXcNUncNo+HDQuywQtxr1kAN1NBrSWzETHzE1egMTxy7CAqyZEObtjALr5AKqFAKXNzFXswkTOIKscAKvvMw7kQLxLu1K2ACFsZfJMA4MQCqtNKEPgsDS2AIshKPhOACTTiGgFmO8nEQkPN6dSBpfTMJm7CEHrF8kSkQg7AEpzcIrAorN7oJJ+sLBpcMwhAL64QJiUAJmqoKnOAJqlALwsALQ9cZ17CV50Ao/4APj8ca6AWC2TPCItwy1oHBodga+HYdF6wndxJR/473Y7JlUaK4gqOkw25CjGLZzG0yxNAMzc/swzW8wz18WtGsY9kAxE1sxEn8zUdMjUl8v6/rlm/pYo7xC9txRhNTl6WwxV4cz1xsCggDxvY8xhDjMK7ACrSgConAAtarAyeAAjJLKxEXAzBAAg8HWJKJAkKQqlUAWIbgAkWwfGPFEBEX0RHRmBKNEItDCJF5o3WwBO7xHmwVCoqwBHYMIHGVF6qACzD9FxL6CJ9sCaDACdJ6CdRKGMMgWsCwDH+7DuiwpfiAb3sGD+CGUtuVroEXi9ojglBdPqFYbMY2eerpDZm3sH4Lgztng8i4UDM4umAtgybT1WA91jEIf9Hsw/861sPRjMTTQA3c7M28Zg33e9cGas6RcRj95EVYnMV1Cc9dvMWE/c69awqkMAqJPQpeTM9Lsgr2DManEAur4DuowAruhAm0ZAI6WwREONBvvAQosBAScAEZ+lcNTY4EoQQJ0bMxQB+RGU1VYI6zB2vrixD/1UJtY3EYBB9lQI6AuWE2DQqk4LbBQAujXAgM8giVUAiUwAmNUAm14AuuNAzIIBnL0A358EfGAQ8hOZVz1K/mMA4nlVJW2dQnuIsy44vjGZ9g6bDF6LkkY5ai+ww8d985yHNkvd87B41nXZYxONZoLdfUEIMFvlBwHbpIjMThTM55LbvXnc5WbAvFkzz/TKLFTPLOt3PYjk3PTNLhII7YpDDiIR7Z9rwK7uQKkN27pKDcm2BBlHACFXABhGBLpl0GklkGHUABGjoCbmOYS0COErRx/gUDRm7kKCAB0SstjLmEgnws+GGjFWEEnFmQiBktZjgJIFYSoEDcp3DTu0IG5ssHnhAKmPDcAzwKvXAMEB4N2HAO7AMPYbqV/OpdmDsneQaMqiiMNAx/xii6+3mozGioAYrfhp6D9r2ogD7fXn3fCnXfZH3oCE4N+R2gGyvFH7vXqrILXZIxy/PpqbAKGO7YpLAkJZ6yfOHYqqAwKRviIF7q9Zwwka0wq/A7CoMKKVsJGdC00RIDFVAB/xJQjjiLAjDQAUbeAX0pvWP1AoaQtP7lSzxbEAPBxzlbBEYAe3wT0X0DETFQEQcBmPkYmYOQekKQVwOBEJPgOCABEo/ABw8BK9ZEC7RACJZAC49wBWagCcoQtqbBDvXgPiaoHPGZQPPJzMfIsRqL8Bor6Isajc3Y8Gn58IkO6TZYg4aq3wEe6WYd8ay7DJnOQJq1C2SEMYAN6qXgzlwMxvLMxSSe2K7+8qQO4qge87Fuz7GuMA/jCqqwsokABcDO4y/QAenRxijgvChA0M/LAUru0GPl0BQBjw6B4+XoXy9g7UROhZbAaZ2pEYDpEW6ThOfxokJQaU3IswmiIL8itP9VALRG8Al1cAp1JbWUoANrgAeLUArQgIdHHINrMg0K//ccmyaAj/CEOviGD/hqKfEcj6iNmnOKmrqf8ZazKxkGZbsizzHDk/nEA+oYLtgr78W/G/qibzAjXvojrtimf/r0TOKOjeqobuK0vgpSpAqnQAqAsAAPsAEx2wEdwAEZagJ1MAEcMO6jzQFA67OjTewODaKP0xCGsNuznZgvUCsxZAkEAZkxcBDQVLV9YwQH0hAXkVYWZ3GG8E2wogRJUJgqTWAnRwkQgUEvoAOVQAqu4AsullnPQ/lnshmSAWMxNrsAgQyZsmUFDR5EmFAhM4UGmT1kWDBiQWUCBRorVgz/2EZguzza2mULFixbID3+AvaLl8eQI0e+ghnzVapUrVqlQpVzFc6cPXOWAlpq1FCiRUUdRXq0aFFSTUkxdRrV1NRTp3z2XJWVlatTqkhhYvNgggQMFCQwuCDEiIsXRU68EHIChpEXKGKQ6IBCyF66KFxQsvSiShVDgKvshXHCRRFDdRQNqhOjTBFKiqxYMSJk0KRBg6psolSHkhJDoeq8IW0JNCFDZcpYUsS6jCFDjwkpMsTa8adTtYQNAz4s4zBjyIobQ57c4nJlzZ0/b74sOkRn1R9WfwbN2bNn2KtDA6/dGfjqzpg9vzj813pevHS9f1/Sli759efrYslL5bD1/x1XxtflllkGtGVAA2dxxaZWZHGlwQRZaSXBrCa8KqepLJwqQw01RGXDCzv88JQLNVzFlVhWiSUWVlRMMZZKbuCjiAsYkOACs2LgQAIONiijChI4ECIGGC6AIQa9NKOLkioUW8KIE4qooogyPrFkLULqeEGJGIpQxJJQKLGCkCrKMCKzzMoYpDUyi4CyjDpOI621OsqwQgnHaLMizUE2qaOKJfZaogpKusLFF2KMAS6jjJJj9BhHl7OoIuaaGwg6ZahjprxMz7uUU0qRKwY49tyLTz6XSDqQwFsKtOUWV+0rCUBd2vuFP/7ao6+kVwtMdUBZGEzQpgaFtYlCnVa5yv9DZTW0ikNkO4S2qmVd0WoVVlZMsRIobjChDAkk6IACBu7i4IITNtggsSJRQOEFEkgo464lDHkBBizLEIIEGASjZBAr/qRkE0KUUCQGRVTZRJFQFDlsCXyNWGIJQi7zrAo7Q2lNCTKUIOSNwZSwk8w62LSijj3rsCJfF+pQghJSTomll9+CS1Q4RxnF2VGdd0bmmJ6fO0aZoJvb2RhihhFGmF964eXVA2GaRSaZWpH6FV9dkWUW+QxsdVf74HuP1uBwfc9Vs1ftdZZffxX2QQgnfFannj5UVsRlN5z7bryvrUqVrlSpZIUPXvgWXArMHeSFGJx8Ia8fYfiEEncXN2L/EBSaLBMGF06IQYgXOPikYCuqIATjIpSoQjVKDFnCMyNgwDcGuJpsUi0lPgllkL10sISTJPosYwnMhKhiEEvorGJOQ+4iXRFQVFGlUGGODg4j4YjBPnvsjzl0Z++NBi7p9XphumkBDXxFQQgdHFbBCNlnX5YI18661/pWNftr+HDVT79fiCnGqJrWtfwRKFX0A9b6WAG3uGHIFA7Um4ecEkFl8c1vpPDKIz5gAh28wEYSGAQMvvWuGMTgXEvwIAc6sLgXuCtimVGXCyxRBBgIoUgnOIFn9qKWPBGCEDP00iaEQAkyGaEKRVoCDGBQBCGtbDRFgAslwKSETUxmeJlR/00dCAGYy4yuNo/AYCxuQT5i1GppSfOFL5K2xjWOj3ztMd/T1Ac3VCyQgShyBYSuZa1YyCIW7VuQgYBVPwO96hUkgVUidYULXpDPkb9QGvVstR6VNJIXuFhVSWZxPkEy6FfDcpAdjQVBDZGilFJZVlMoSJVTsKIqp3gZKRohOLlQAAMoGAEhjCCBCrzrXSfAQBlIcAES4PAEKCCBBRJDAhvKDgaKWIIzCYMCJcCgeGspghAUIYQi6MAQn9gEDY3QubnAMAYugB2bpHiC2KhGEYZRSwxaV7lNgNMShBgElYyXCEyoYiuyIJ8werG0RjoSkwICFiAbWCGGNvRYd5zQtf+u5b4EJYh+qXoFrHL1tfk0cj3iY+MxhuE/momKoKVy1YHWpraEmkiUWfHJhqIywZnS1BSmXCWz+ua3U4AiERn4wAkyg4EOwGASJBiXBjbAAQpw4JgkkAAKOGABuazFXpvznJNckLl4TaxH1jSEn4xQGIK5gHQ2jJIRrOACQ6xlEIpIWI+MuBdCbEIyuSFTFcYZzRgQghaquJLJAhaKUPAzFrVwlS9y4QtcHHSTCM0a/FohUTo61LJXgellUZGKrLQiK5y1SUyipjat8UprZ3OVLjDJyPUEp1bBwd4vuDcMSVKykihVqSxcVYtQWmuPMI1bhlRZ05uqsrjDlemyXrn/XOhVBRSFcMADNuACDpBgBCW4QAc4oAFC6AAFTyVmB8z1VKe6gJn66kwZNEdDQ9DCEGqRy5tgcE/CCNESSijCm5ZACULIE3ap28QgCAuxkWVzEGCay5jM9IIhqKUMoanCG0QjJtgUwgmgWGwa09gLVx3UVfVLqG8hOsqGPhBaFgIKiEphiqCkmKETAi3VpJY1Qp4WtWabVWtNyp/1DO0YZnRj+Taa0gOZLaGe3YqEjlWh45oSp1NB5YZK8ZMWn3K5VSEFKDzxhgUs4AEVqNFZCneBF9QBd+NEAQY4UJdBLAGHRaoDCZYAxTJVIWVCeo3smFjDbM5ZSS2cDH5JRyYh/1iBiYIinSXqBAMrfMJIYyrMn4RAJnk2yQrxMuImLIEy/S7xDaAIRjCSRowN+6IXpvYFQjc5IAf9MY8SXeAC1TfRPN5RlLWG9WQpCj+s9Qp/rSotAQV049TeZxelws9KhqEMaBQDFiHJqExoMm2aULnFLR5KT4IyCqAsJSlIIYoohiJub5MbKCNJBUxagaBC1aIWlchDHpKggxsI7gMV0AAHygVVGlGgqRTYwLxO4FR/o6ADk1iCXUhQlxpyAAZSRcG+SMAuuTycmzHQARRfwDoUUOIThCiCWUtGQ72eEwad4Zg18XVyK8COEuUcQgzajJvX2bDRp3gTZErIpipgWP/UwmBsGjNciyL7am28fjWE3KfHl1bL6RPVo02UHiEFuaKQ9ssksW+xP0yCDWyx2sVKjBGejuAHVVGrGkyojYprt73b34Z73JHSYprAAj8bKQYypHGNa1DDGtlQBiRJfQkV3PsBVP3ABr7MAROcwBJCIOYFmGoEQqBAAkUghAlyNAJ/4+WYHiTBXaQqlwugWaoc8AwhekQ63QUJBWE1hBLYCmHHKAKZkjnMN+GiRCPU4eTVNELw1LKJJcgXdjlUhSVKszrPtKUIb6hELkRdKEySr1CbdDdLiX50pDO9QbC2tR1zXfVdy29+adPkfGzsdfa3n39h+0UzrDF/ZAyDJfD/yV9J0k7tVLR9KaOQu6Mohbp7NrxDhmVghmmwhmvQhgbkhm9gB3qwhwmUh2+4hmLYBezJhML7AA1gAKc6gbiYqg7YuGUiJglYOLwggSJQIQnwNxRaOBSQvBPwPNkRAup6F2SaOBKwBEuIgSogrDJ4khhQAhPYgDrQgVAIBpbBnSqwC/+qpyNyjH1hNJZhEzKxiywZGC2yk9uogndKk9aQkghjg0pQhWDIBVfJhV5oLA5rLFwguuxjKbfpPlj7Psqylglxn/fZNay5qAORj0wKxNRqv7CZFThCxPawBeKgpFQgDmNQhmEwxABRpJJAN1jgv1Q4FZcwCbwrDmV4Bmmg/4ZryIZtMEVuQMVUfMByYMVySIdzMAd14Id7gId2qAZkAAbaAgUZUIEb8MALQJcNyDcUhKoJ8Bzx+qAL+JalajxlvIDsyguDe0ahWrMWkoulcpdi4gAjoAQroYQ5w683OYEq0IFPSAZFaBnHqBceAg38sqF6aY0Y+KYteqtAEZiWiQ0tqoNJK74ueSduEg02AARQOCx3uwVcYMMOg0N3k0P6gZ8UaZASQbqk26M9dJC2cZCE+pXHsrGsMxtcUK1ZCZtEVC1GSsT5SIZh6ARR8CxXQAVRcCQ48jqWoEmP4IiMOMBliIZoqAZsQMVvmIegFMqgpAd5MEp6QEqkNMp2YP9Kd3BKcVCHdlCHczgHdYiHe7iHemgHbIiG7hCGRVABKFACpPpANasuC9ALGiTLF/C3GsmuYqKuDyQBCkg4faGhHzkiIKmXMlAEuVDLeuEr2tgdyviEOmABFngDKvkCPiADH+ycLamcKmihtYISzcgFWiAdK6AE4vEhPogcdPS9SXuTx+jBkKuDTSgEPmCDS1CFXHC3NlRIhpRNo2sp9nmfYZmoyQI/YiEW+PGkjNStg1SVrHtDD5vEkUzE5AQOXRiGYxAoBNGaHOMIYFCUgoiGaSDFBxxKoZTACcQHe8CH8BTP8STP8vSHe/CH87yHdEiHbuiGBsQGbIDPamAGZCj/hlkAhUWYgRXYgMLpAAzAAM+xAB0hgQ24gEGYSw5AAbOorgmwgHz7oA4wgsepIRTaHBiYONwYBKcSwXwhAd3ZnLfoJh2oghsgg0SYN8JSBHDal8tJGdCgISgRkypQhWQ4BY7Rq8ewkzfgA497k86Zjc+4EmFSucG4ARqIhFNwTYRErYVkSASC0onkTViryGChOuAEsZUiNvkoyca6Ma8jFbCRSV2olbADDl6AhV8ARWaghmxoQG8AynlAygmk0zoFz/LEh33I0/Tk0z7dhzpVSnnwBm+Az/iMz2uohmrgO2pQQGtwBqH5hVXwhEvQlgqoAA5ggA88ARMwr2HSEQOt/wMFtZwPLBd92653yS4cYibNGARurAIOkKE6MC9CiAvFQSYjKJgX2KJNeC/ZM4HA4gRL+LjC0At5CqHgqyZd3QTSoQXTGJMyIITQQR3MUwXTaDMhaK/jeY3XIQEj0iEluIGBrIU29DAPczcoRVdgobrblLql20P3gZpOqh8upY9cQTavmw+a5IWbLIbiKIhQtAa/k4b6PMBr2IZvkIfuxNPwBM+G/U489c7wrAd3YMp2SAdWdM/3bMCN1QZu4FiOJcVsENn5mz/tIAZcGAVKbQRA4IMPOAsGSAA1MwEjnADJS4yl0je1bCoc4gDYSEEKqJcToBJjEoJNcJKA2bjVEf8SDAg+tQgSwPiEYBgYHGoejEkCJbCEKhCSGtohcmKTPmGZdJTHSXANJRACrA2Fe3ovbgyFy4CrrA0+iGmzJbCTRPA5DXOkvLW+N8yFJbuKKdMsVEAWZNEjwV0FGYuJadvETfSIZ9sFvMPJA7zO7OQGb2AHy5XA7lTKoYzYPuVThqXTzLUHOZ2HdmCHi/UGjeVYQy1UQ8UGvhNZ2M0GvuM7kg3Y2i1Z7ag/W0AFULiESKiESkBRCzCLD9wAC/iAD8jUX7KACUhQZgo+Qxi4rF24SXsLh6sSCaDBlCEBE9CczoELd+kMZnqBS4s4WqCEmuWcuFgiG+JaJarQKDkiHVD/AvqNEsw7jDJpEiUqM5MJhSoaBDTZS8do1T+RjOAZhCux28UqFDbM2+JESFyQBcPVigZhMaCYihXjNre74BRLt0xkXJagzrw7QGaIhmuQz47lBnYwyqNM2HkAT3/Ah/TkB3+o4VnEynug03qAB6d0h3UgB3EQh4zVhvhsXWxI1CJ2XdkV2dll4iaG4iiWYtu1Xe0QGklEhVEABU24BE7AhEr4Ag2YgKZSvAq4Nwsw1RxB4+rSl8jBkePFiwAtAwv4kQ04AQs4wiWokRdwASVAJvOKuIhJuIeTnXrJDAZ4AWOCiycpks4ptMzAHFpFnZFxgYzrHLWiHbOtl8sgos6A/xiQOdtlxSe4sALBDD4+wASCzAXXrIWE5LBhO59a+K3DZYW5gZYVmzK3CwpqGwmbHGHJlYaeVOFvQNh5kIegrAcehgd4QM/zXOZ3uIca9genlAeLPYdyGAdxCAeNZV3Xjc9Efd3Xpd1EJWdFNedyTtRxDthpaFMnvoYF/LtsoOJ5nj95zt1mcJSRcgWh0DJO6ClS4AMNYIsfmYB7q4BqmgCIGcFwmbh86YCBwyEMkLwCfRdMFQI7fjgOkJ1hEgKn+i58CT3JUZcV7Oh6SeS5mLR1LJMeKSGu/cL6tSazzYxJmAS9gAw34SaHKZNJkyKGgasHm9sXoB006Ri7VYVaWP/SNzybjZyFtkGfTOS/kcjXX0ZAUQzZbVBFy2WHrR5Ub5CHrW7hhP1hqjyHdTDrcxgHcMjYbkhh+fTmt/ZmFB5nviPnaUDnu56GaZCGndRracjrvv5rdqYG8LCG8AiP8iAaRAmVlHAPW1AQZBEuDAKcDDABCUgAbbKAFdCAB6gnBpi4EcqRDhCCo3rogSMBNXuXAU0eU3Ve2SlVC1ArLAySVm2rcyIevcJQbuycy7ChH+oTvSqTIpBbKeKYrBWC1kGTJrGzgcmTfmmSgNE0dHQdrW2SVr0MP6kCz/Ti55HNWFCFw0qRWjiRjZSPx4XcnGQGRc2GBzxmY27vhJ3AOQ3/XXlgz1ZMXfdU4m9G4rvmb9rlu0NFYUMNcHEWcEWlawNHVLzO672WBr/u68HmjoeQDkoxjlDhMV4QiZmgiWsbCmwjCs/KiadoClXwBM3eAM82mHOpgAl4CxOSADw2i7OgAGGigAngAAxwwR/RrgnYEyLZkRf4hEHQkYfTFyGwhM00Kyhpi74yAS0CudP8jDoIQTFRhDXxk38xIokJDYJhmcsQvgTWgR9Sgjxpsz1RtCMijM6ws1ZVEhgIFBw1hDf4gjboJ1qgBfFOkebqijUcKGNgBmvAajkV3e70Toclz2TGB3e4WCIuYv7eSQXP63L2b0Sdv0mn3UN15/+OXdrd//S5roYF3+tniIgK14iNYAmX2HAOH7ekAEC4+79ss5CmgCVO0CA8PoEOQMGZnYAJ2AAKiDg0fkYdyREXpAB+u3EPQgEfYeO38KBSpugNmEsUUARFWDgOKJ264MvQ6BMoOiKQKcLKUIvDEG61cloYII3kMZnBSJ7GqIMvOBhFqANDqBJBuRLU8Qya08zD6BP6lRKQQcIvKARO4ARQ8OJHeIRGeIRIiARPyIXfyDtqIEruJF2kNOZ0OF0W/tiNBfABn/QCD/BxRnBLp12SxV26Fnn/rgZGlYbueAgKx4hS74jG3USo7j+3+78AFAVQAIX/0/kHypCeugQP8IDBoZOzoP9jG7KACygLyZsqpmKAGC/2sWAAOs5xoYKBdMFQEaJBNfOgpkKiDfguoY0BE1CY4E0ERbiBFoicFeCDrN2i1anyQDkwQyiCiAuYfSwDUF6C2AhzPjh74tba/HqNKviET/imbkwefBkEfzdbpxWC0fT7RKgEMsgNPngDOogEUCCGoFkGadAGQj3iAydnkw95UnxiKRbZBkT9bUBh1Pfv2ZXn2h3FvsvrCDcIi8gIjlCJY9uoxcVETKT5adPlUniKVxc3pACFnE9+LdZ55jcFWHIKTFABFTABDTCBFwDQBJCq450ADJhLCVgqZcyRCyDe5kVBIcBxtMCAEzCEqz9etYT/ARViACN3F9F2EmKiwQmjhU8QeFrXAE4ACFVFilCyVEWJIkufCFUpYoVQGRcwqkAkZKVOlSpGjFg5WKeOIoZChCyBUURHHVqKNllS9ImSEkN1ygxSNGhmmTJLyliSeVMRUEUgKREy9KgSKGLIlipjxkzaM2lSpVGjdm1aVWtVqWmttnUaWK7WxmrdmpUs2mvZrqnNttZtNrLToD5zuuzuUmPGig0D5pfvsGLF/ALbxcvwL16KFetqvKsxZF22JtuC9eoy5lerUHE2VarUKFKjRosqbRoUatSeOpleFWsVbNexatWKFUvVowwONpiwYGECBxITJmwYPlyChAm/iV+Y/3BBg3ITxDdg2MBBAgwhF0ig0H4h+AvuKGAQigGDu6IY4jEYUkXpEylOqk7RImQiY5EvIetsMjRoiRFVvGCEEDEUQdMgZcxkxCCDCKFEHVYYQkkdBhlhXk1v8GHJG2RY0lJPnDCkCCU57YQgJRNWAVQdhvRUFFCEPALKL4IZc8wxyCiz4109MgMNNM4ECaRZYm2F1lhisYVkWc84ycxdyuS11zB9EXalX79oueUvwFQZGGDAaKnYmIxFBpktjU02C5uzXCZLK3G2shlnnZliCimijbYnn3yWBhsrq5gS6Cq11YZJBgpYUJwFJPxGQnEM/LbBCcYZZ8IGvvlmQm/Fwf9AyaIuoEACAyTA8B0MMaBgRHdChAeDdTG8wMELsp4AgxI66KAEeZ/UYQIMdShBFCVV9FQFgNllNMhChiiiYBlWdGSEs4ZsQokioRgykhABvvAJLVVQUp8QMpUhRE5lIGtEGUYsIcQglmxCyCb9FUTIJDIB9QgpvdRYzI1LCSzwjgXvyIwzzjgpJJANO5wwMwPrJViVWIopJpcZc5kll8NsiTExw+xVzJa9mGyymbrcsjLLt8ziMpuyuDKzzDO70kqghMYG250995ynnqGRsvMqqqxySiy5xFLJCg9UoJxyxU1AgqPDMTD1cJpCHbUQLmR6AgkvLEGCBCdcwEAHHXD/AEMHKMQQgyEbkdBBeGvPPXe35p1wqxInKCEECgNZQgnhhlgBrxJVDLJREUYQTsiLVRi+UU0ghfJRHZ9s+8JI2YZSLCVLDBThRtHKVIVOOX3o7OMk5ksIiQmRMgsvXxJzTDE56j4wMnodcyPwE3/J8S+7GG/8YpAZthjzvGj8vMb+avlllb8LBljGvfAC2cq4tPwyzLPIUnPNM8+5ys1xzkx0bKj4fKf7Pd+mCtC3XQJCBRVIkKlvsPbft3Ea5ZsNEPA3D9CACZTQmwn4zQIcmEDbJECBF2znBR2IgXZIQKu2nYBSHEBBcLiDwRcMIgZVUM8LXoCCE1orBmX4xLmq/7AgK5TBEO0qAiEIsYQG1QFbCFLcs74VCiukKkBGgMFOlmATF7rLQdK6lk52Yi0bAsUQRSGKIhJBItipIha4EIYwiBFG6lVpS4eRzGRgYRnMuEIWbWITZSijMpZBhnnSgx4euSSML9lIL737BZjKWLLFeA8X3mPZG9tUM5yxopGBQkUq6iRJVJwifpO0ZJ1GcYpNngIUnsDNBzLwAQ0kRzkW0AiplKAE4SxqA5DS1Ak4wIEDAidrDJwABjS4HRJQgJcMoEAMRtABDFwgbST4jhA+2K4UcuAEL4BBCtUDg3PVwVUvKMMLqjCSHErOEBrRiBUYdC5oEaJBDfFIqt6Wqv9uEWgkVlDEEqTFrUHEDSMakeIkypBDoKRoQoqoBLYMwQla0GZlvDjkZDKTioUytKGRlCSg1NeKV7gCfC1jmSFx0Twy5fF51Lve9Ub2pewpRnu3yOjKKBMzmcnJoZwpxUJhylBUfOYzo6ipTFPRCvG1AhWy0MQlGtGGHkCBBRlYwAIYwIDv8I+EL7DACzZwNVu+kgQdLM4GNMAbCzjTgRLoANusMAgKwIACEiAmMDGAgWFiIDhGCM8LQncCF8yVOx0oEOBWCIMTFMESGBJCvSS0kW5BREEtipBFaKgTJQzCCkXo1glc9S50MYhd7ZwnDR9Ek832kBL0JBy2FPGIQjz/IiSWQBqcXsGmVqTvFRNtRSpWMVNIOjS26mMFa2/mWsy8UY5n0sVGEZMY5+XRSn+pkjKcoQyPDZd5jdle92ohvvGNz2Y3Y0Vta/sKNU4GMYFBxjKY8QxoWCMb29iGNZrRDGH8oAENOMACDuCACjxAARVQKgPO46hwdnA4UvvN3qwqNeBgSjoksMIGdilBDAjBChy4wAUkyJ2vYgAFF6CAM7/TtlnFwAhUOwEKOBfiIwoBJb4K5xI8C4NwjmRFDHmhQcrJkSXsRBGq2EStkOXOJSDrcBgM52UHUaKDHIgisJuXs/gZlEc8gnCDAwUr3JSKNTL0FVVm6GeyyxnYoAK3/3LKjGrf+ArKwIIy21OeLpaHvMTg0WK/cIY1lIGx46XZeGhik0JTYWU9b3e7xusSwHSUMPKadxvcMDQ3Eq3oQ8dlLEHCRScg4YEGLEABB7DvAxLAAAUkIAFCoNoGYHCeASqHah+mlHK0GmoOWMcChFjlCQCEAgpcwIKqujAFOiBMDEgAws2U5XZGBThTceCCgyBBHaCZhDrogCXRcpB/NCKElXiTEKGgBUZsyM6RUCIUivibDkkSoCIkDlf0soLovBlYFUkodlYkHIlS1LqEvCQSnrDFLmABDOcdr9+HQV5hjIfThW65Tg0FM2bSWGY12UKj2msecJnXXOYF3Hiw0P9FM4BEsn6XeRfdNR5hbATep1DDvIn+xjcWrfLzntct5b0GNcIyDbWMRbnH4IUrRqEJLXigvgyQgAs4oOleX20DUV1UKy1wNeG4EsAWgJUJOHARrUJ1ViigcXi4wx0YtPUFuaTaCIJTQw26IGxzy+Z4oEmgebFgXKrgg69G558V8sQSPPSsPrflrp0cRAhVuEgNHbSEcv4NIYRDlkaMUE6aGMRFLlHEQx43IUNUC96USEQjFlEKYPQRpCC1mF88Dosqz+nLl3HTLOIYRzUu3ONpeu5vHdPv2YfeFjUCZMUoBgw/hlca5c2GolE+j3l8g/gp18ZarpGkuThpKlIJi1j/xtIWuNTcGLrgjCc80YgMTIDTFkCOAzu4KAGfYFHT4eqnMzWcByxKAxawiQUQ+LUYnCDXwUGBBJZabFZtJzsjAGEZhEutPRaIYVDgaBPnxIAOmAAfUEIyqEIi1EERuMBHZIS7FAHqDMI5LQFjiRq6ONaKfMJFUJ7dKYgqXYS85ASEqEtG1IERbIIqOAvs+MeE9IRYuQQtWIIqfIIiVMEngIIm6JtgIIPnCUbIXYkRFoZklJktpJ5KpVGbrN7rxV6dzZ4V9lvIGQNTFEMqdMLowVQxsJzKaQM2uIXyacU0RMOTOAUbipca1oV4SYPMOd/yVcWQQIMyHMMw8AIqiIIn/2HCI0SBAnDaBGzaQSiVKUEKpBTH3jSK1DQdA3yNBgxOdPgGCZQBCuRSB1AABXCAEAyTBKCAKAaHrlUYB1RBLJmACZ1Hi33EC7hADMTLGxRCFoBCMlhCEpiACxiCEvBEZSnORkwEj/2NNpnQQVAIIYhgPA0CIZAbhLRED5ZBL3pTtChRaAmFQliRPylItqjCtX2CQnwCJmhCZXBeEl7JFR6P6k3GLcRRSq1jZFjhv4EclojcXTwDVrTFoqUcNQxDmXlMmhnDWICFNESDQR6kVKyhU8BhGzbkXbShkyyMM8QFkEDMjughL9xCK4wGnpwCJ7TABGiaUikAqF3NoxDQC/+YUqb8l6MsSqUUGAdEHaaUH9VgQC/xEgkADgm5SnDkGgWkmBB8gC5iIAqIyqpQwiYkzkDIRA89AiBgQhQMJSFkTiggS9xYYGNxoLSwy9/ZhAS+Ry+KlRUUnhUYREfkhFj9UNwUwU1YQjCoRLzBmyVwQiVwQrcFg3skAiSoEcetEcJtV2WUWRSq1El1j0ZJhuwJl1+AyVLcRTTMHDZogzYU3/BVJsp9gzd4g2SSIRleQxk+AxHmDjIASfMV5EEe5Br6iI9ASXj1iGsuQ8H0jjGMVGLowizoFJ3clGiQAtKQwhf43AGI5NL9nKPwDwwsx29YYqaw37TBQKpNAAJZQPr/XUARvIAEcIB6XBB2ltAgWFCtcMQm6EAKmYC1lQEGmUodqAInUF4olEcRRMEb5MAK3EBG+F0RKMK2SAiA7ESxBEi7dEQV1MtKfIS0MJYhTIKDKIEVwES7UN7ilQE8pQ62uGWz4GcViRZpPQIn5IK3KcIflAJfGgaYpY/6tAlmsN5kRMZiTI8WKsMyPMPvIdplUmZlzoM8oFyibeZmYgOPRiYZ8mhnTh95QcNWXIVBRiRDLmRDQsmOyCaV9EXx6IIaYUYk4RRojIIo9MmekMJt6MB9LRUDHIBS9RoGKBUBZY0rmVIATUohjqULdIoJFIGBNUp1dgAJCJlOxEAzlctb/7mQFbxAERhCKCQB5CxEdmjHC8xliXxCdRZBIlBCk+VK49RBOU0lQyyOf4xEPAFoR3zIJryEZymoWD1oTTQWhDLjf+xQuiUEpArF5FFe7CRCIhSCkjFjI4hCvh0PE9pCZuyUm4wZcP1FMYwcjLaFoRXfjJ7cZXKDjjYrXGjDGCpaswKpZGLDklCDHM6cNbDFVYDFNDSMMziFlPTOYFRcZVxGdhGcJHkGTmFpaWhpaJxCInwAfS0VBTCApmka15mkSRKH0klKcv5GqQyQCwiBCTzACXzCp3FVo1jVBITircSA12DnNH3C2GigJajEF/jKM9XQCVCqImAgJRjBQHwCD+h+SHUOwX4MQi9mhA39Rwzs0N+hC+aYLIlghIRYhLrURICg22blhBMhyybYGIfkUE/Qk0KERIxo0YQMAiZkAl+GnpRWWRMuxjAogzXI6Iwuq7RqQzVwq2fyaDWMLbWSoVtYaxkin2QmWmQeGss162a+hTXMxdhGQzUYJJTIpu7NXmD6JZU61GfQSWdUUp1cKZ+AwiigRuICAr1qwNV0Gr4qlaaRAAZYTXFCjaRYSgCd6QlwigZUAaw4yt58h4UBh1VRTTPdShGcR0NQwinwwQ28gRKsLklkkyHQJ4NMQhHwxyfoCuWVREAAACH5BABkAAAALAAAAABAAQABh+vAoeCzk92siNKqj9She8qgg8OfhMGafciVbb+UdLyVd7yQbrmTd7iPcLOReL+MYLqMaLmMabiMa7eKZrWMbrWLaLWIaLWJZbWHZLKMb7KIabKHZLKGY66KcK6GaamIb7mCUbODWbKDXLCFYrCBWa6EY66CYa6CXq5/U6mEaqqDZKmBZKh/ZauBXap/Xap+XKl9W6l8VKWCaKWAZ6WBZKR/ZKV+ZaR+YKV9ZKR8Y6R8XqJ/ZaJ9YqF8YaB/ZaB8YZx+Za94SKh5UqZ6WaV4VKN7YqR6WqN3VKJ6YaF5YKF6XaJ4YaJ3WKF1U6B7Yp96YJ96X6B4YKB6XKB4XJ92X593XKB0VJ9zUJ56YZ57X555X555Xp14YJ15XJ53WZ52XZ52XJ12V551X511XJ10Xp11W550U51xUJx5YJt5XZt3Xpx3XJt2X5t2XJt5Wpt3Wpt2Wpt1Xpp0XZt0W5xzXZt0Wpt0V5txUZl3XZh1W5h0WphzW5hyVZZ0WpJ0XpRxWJNwV51uSpltTJhtTZRuV5VtTpFuV5FsV5BrVpFuU49rUZdpR5BqUo5pUpRmRI5mSZNeOotpUIZoVYlkSYJjToVfRohePoBeRnpeSoJaPHtZQYFSMXlTOHRVP25UQnFPN2lOO3VJK2lJM2ZINGZEMGJINmBGM2FFMmJEMF1DMWZBKV5ALWk5G147JVtAL1s/K1o9KVo4IlZAMFY9LFU7KlU6J085KVM3J1Q3Ik03J1I0IE40IlExG0wxHkkzI0kvHUMwIk4pE0UpF0EqG0AlEzsnGTclGDkhETEgEjkcCy4bDSgaDicYCywWByQWCigTBSgNASAWCx8UCR4TCB8RBBkRBh4OAhkNAxYNBBEMAxcJARUDAA4IAg4CAAsIAQwHAgsEAQkJAQgIAQkHAggHAAkGAAcGAQYHAQUGAAQHAAoFAQgFAAYFAAcEAAQFAAUEAAIEAAgCAAYCAAgAAAQCAAQAAAICAAIBAAMAAAECAAEBAgEBAAABAAAAAwEAAAAAAAj/AM2YueNFh4YBDVzocLFC4MA7hcKsMFLojo4bZlYUehSmEJ8jRF6cGHHihAsTGypU2GBi5IkNI0ZwIAmjAp9WsXb9OqZN2S9cunTVwgWqBpMjR4wsPNLkTJMhQ2DAAEmECIwTMGKMHGGCgwkYLkqaMCGT69iYZ0e0aFGyxYaSJ1rAYBszJoeZIzZMmLABAwcMFwBDGAxhwswXUyOJUrUKl7Bbr1atiix5FarLmC+vGgUKFCrJqVaR+qSp06dPnE6LIiVKFChMnVadKjULGjRrz6g5Y6YMGbJiw4D5spUKlCdPwJwhwyRJErB53bJhq0Z9mvXr2KdRozZNmndpzq6D/3dG3tmz8+OZMRt/LVq1ZaAk+cHjo8OBAw4OMOggYwyjSZeQkow1BGqzjXrNKJNMMs00IxATXhjhQgEFMGGEUkyEYUYYd9zBxA1heGGGDmYUYocUldgxxR1HXLVWWxtcMNNYJ8wEU0wvuOCWCp/ocssvyWzzDDG64IILLLXAooQRL8jVwldDEDEEYlJJ+cKVVLbAVQl3tXTWWS4w9YIJLjQ5kglEIEVEjTCVVNebG8DEwQUTBPYXnYNhMEFhe2HVhCKfqBILL4/VIhllkmWm6GWnVBYaKp90YtpplLYmCiWSfILKbKkEB8ynvoRqyyyylJpKKagalwswmPjhhyTLaP/TzXTUVZOdNNlZN953uHpXnjPUnPcredOEd00110xjjS2SAOGDDykw8EEHDjDgQApIEHLJJZ/0As02BKqnzLjkhsiEFGGE0QBCRmiogw4cFlKQQkascIMUJZoxCR9eeHEVSSPN1OVacmkVowUYvFhBBpPwohOQxxzDi5G4vMILIGGtVQKZUDVp5pVdmXBlXBxoufELIJ150hBWXDFmmU/OBEMTLd61AQdxxngzzjnHFGNgdF4AwQIQ/DUBBhiMQMQVgkzyCU64EIOLoYgm+llllmmGdaKiVNr1J5aOMoooY6MySqqdGeeJ2scdhwkmbnviBxCuYiIrONNNY+ut3kX/4912u/I6XnnBPjOsM+Adqzg11hwjNxApZPFDCh5Q60AHM/wRySWajJKMNj35Rq5vdwzkRRhS3EChQmG8q2EhhcArRYZhuOBChxsVFBdbNl/gu1clvRCDWxcgjFYFDKTRimO/pILJLEFNnQovmagQVQsbtxW8x2QlLRJJXo2QPVRTXsmVC1ylLxNMLRwxRIw+85xznHfV9fMIgM1Ep9F7XiDXEY/4RCx0wQti9KIWr6ja1iqDma1FBhWkYI2lwGap1pACFGTjTNwwganmePCDzXnVB4BAQk8YqBt7y1V3+vYdagzOV4c7nHrWgyvFTeMa1mDcM5jlrEQkYgorSEEG/6z1ASw0ghKX6AQsnjE6ZCiDNw4phBS8YAcKDIACUpCCEbzQoTCsyAhMYIIOLKSCdxmhEjpQAUny4ru9qOQtNbpLjdIivoWlQBXC+MUviDEUIwXFYqpwgZRgIL6SnYAs3QtMWQ7JARGUpX5cmZPA1tiV9cVJJlqKQARuZpe7IE2Rd/EknWTil7zshU8QiAAENuCCSYgiFq2wTJJgkcBXwOKWtVygLq0GwbGdhjWkQMVqIGg2T7ztmMzxoKuW6Sq6+eEDDiChLLrRjXmkMFe88hviYBhD9exmhuAEDzWOhY0bauMa6KSGMeRmCEA8ohA1SIF9FOCAIm7uEp6gxTHGJf8uZYSBCRApnRQphLp2VYRD/xzRQpjgAhU0lIsamFOdLlABTaqEA27CWfBQsr4FNMABmtDFHoWxC53oYhdTG1SEpJIXCQDGTqSUUV1MIAJHviUmc+TkCCiKF/HJBGccUIlQJXABUn7Sd34JmsBASacKDIZoe4LABUzAhEq8UhOaaIwtb8nVBNJygZTJZQI1YzZLQTCCwVwNKUahCUq4VRJvlQ8zl0lCEn7gA64yRje20Q0V6iqb4OGmDGe4m2WAkzzSQCc2FMeNxnIDnc/IBSUioQhF8KEGdzWAAayVgj+4lRKe+MUzEsQbgQ5iEGbg17oy8K4NwasiFjJDCy4EA4f/akADjyhBjCpwgZ/5TqYzGYkISpKSOF0gAQ3IgCJ4wYs99mIXEwNKxYIxiRXMhQMWkMCdfksnpNlFfVwZie8umZdLYi99xoVJb+MUgd5y96UvlWmNMHAjnCF1MBYtqhEyoQpeUAIRo3jFLWaJy8m8whUI1qUtvfqK0FhGbK0ZxWfMdhmxgaKDIJxbXTe84Xri1RkGmod1tvNXwcXwxIcFJzOABaxrjBOd1ZjHPMChjWxwA3TNKIUkDKGIRGwhBQo4gGb3M4NDNCISlBjFMUbrIIig1iJeUMEACqCEFbxuCpOYhBnECIML2a4BDaDAPyXAW5X4rmgAg8t87yKjmyUg/wEUqEErCEVSoPAieq0IxidW4ALdahIwe6kTYMqCv/DhZSQrYQmbyOIVE2yMZ70N6hvVcjOkhlKOL/oLfUOZlr2MFyZM4ER/m9uLqRH4q6twRS1zuYqu0vLADr4MMB9sNbJ1Qj6GcBUiENFMGchghBwmoQPqKQkQU3PELhTcd07cTRUf1ljaoAayjiXjboAjOo0F1y9aBYg/6IEBCmCAkA1wuSUcwq2auIUynlEIMzRBIHc4LRM0UAAPMOER937EO+9giUIsQhBnMAGZNSCBEhRCZxvYJNIIRheSiKB+JUCLBSpgL1UQ4+IlPWkvilQLXsSiByq4QATe/CakBfdLbv/iKEosoDNHc2BjX0FfCaDSguBe5UaVpp9d1ouz9kaALyyxSwUm6peWuGAQocjzxZPxi17Q4tSzmAUtuEr1qoc1FVg/xSnKtihU3PITy+Q1pt4617IP2wGgoIas5rEdEmtHGi5sO+F0A6zt1L3thTuP3rdjjWuADnQ3TtZ2akUdbRDIGJrAAxqywPgODNEAU85ADrRVmlMQ40JMgHe8B3KABEDEBQNZxCIqYoYzHEHgFZAAmDVQCBhglyVtIphIyBJHmEScKxWwQAtuoImLE6OkvQh+kXDBi2AAQgV6WUACWnLIn76J+WTBqQtSwt3emmAtLoCBo1ugo7GcYRFHgMn/EIj32xhNQCV12un5eVtp37VXqqEcwQsckfRgBEMYv98FLabO1ajXYv9VZ3WggXWpsHWc0XVetwqdQEIy4AMygAfLxAZowAZlp2HD9gG20HfbIGIkBkOA40JzR3d3lxt5R1pPxAwkeE5/d07pxB2Mg043pkOvYAhA8AdpgAfRIm4DcAAZMAN7QAml0QlHcAVnUIRnEG+D4AgacACgB0b61iEvECUtEAELQFEqIQFDcAcpUQEjwFtp1nzgA3EloAIqoF2zlQj3R1LBt3FBUSTJcAkrUAIToHzMB4aEZhb4EyctsQEsVzIpYQEvp1vpA1Q4oxYz0RQw4Dtm1lRmFgE7/9Ve62WFE+BzdtJbLuAIgVJ8+IdStXBqB/ZqW6MoWncKWad1YiNhi3IKtKQJQPBrd+UDJPQswcZhF2gM47QN4KAdIMhsM6R3vviL59Eg49IMe0cgbQdj0lANeMc42oAs1oCCw9AJftAHfZAHPdABDJCN+GFPnDMEV+Bu72YFR7hlb0YiJBIGs9UkF7AACxABEhABqScBEvAIKvBykQZHzXdojkQwtmMBJeACTOAGrSAMwrCGzxUUJXUMqlADLVABdKhm0fcml9YXbNZmI8ByurVeaoE+82NcatGFvOVpFAWPbcQBk7iI71gnmpRKR2N9mCgozCUMHNeJXOUKraZAWf+zKAQYGQa4QFgHC6vQKpDzirEIi87ia0jJgMPmB8jADNZATXA3OOThbMvQG77hRFZpDFcZMcdgDMXwlcZwDFfpRKIDd9QQDX6zHSnoYuXBG79ACYbwB1ygBzyQASmQgykwA3KwB1gBA1FYPlIxBBJwABwAFlIxFe+zABJQGOzIju4oEB7QAoCYFy3BFoikZtznAjegAxYgf1v0CQRpkAf5MMHQBXLIjnX4JgDDaJDEh7lXPBvQAk1hBCXAfWOhW6/pO3mRezNiXxQlj5oUATaTegvAW2RmARbQmJo0XifgCJkgarFAfEaCJF21S2DFapPxYFeDNT+5CpTgBzOQApf/kwK+9iyyOAMOiJR3NWyYMC5qtw0wNEOGpR7zmZVg2ZXGEJYRMwwXNwz+OQzFQAxc2ZVi6UTMwB3jQYJ8l0NtuQ3NAAqI8AdqoAdwQAMZQAMdQE++5pdw8SRjARYt0Hkt8AIMZSEbkACKGZzsKAGK6QKWoBDYoyVmgUg0wnCaeQMSsJFSMAn3F3yhIny7UAy9kAyKoAEXIAEJMAKOpGnxl4/10z25FycWYAJD0CIlsDFPIj6O5pq/NQLoYwFWWFHAWVFslHBE9RIjII+O+XNBYwKOYAmWkBqCciQBiEur9mp1iiQERmEJhDU2WQuowGu/doF3iZQNaKi+tp4OUArj//IM1rANv8IMyzCplFqVvZGfwPGf/vkLm6pHnuqpwqCpnwKgWtmUiLUbiGN3MCQN2wAuu/Cdf9AHieAGKlA5GfABKfACD4cWaxGFMDAEC1AAF9AkKqB9DtmYKNqY7Mh6ZqACKKFzdbExJCEXOnIDfNYAFVAyRgAHAxl8erSGu3AMQPIJRqp8dmFyfpGuSOMXhZgXgbhTgTgW18czMfGbx4mcyIkB8HiFwFlcZVZRF4CmatqOqZRKEWABR3gHijAJnYAKRhILEBuxENuJtRCdFHOxFDN8bSgarYanB9ZqYOcHO0AtDHCXJpsCH+CKKHtX01JPt7BPjnog9Dmp42Kp4/+CDF75C6ESKrmwf7fwsz8LFBmHkCW1C7eQC0gLDMVAoMqAOM4wqdHAODmEd9TUqsoACoaQB3rAB3xwAxogTx9QaFtxSFciFS1QAAlQAhWgJYqpfG+mfCyaACqhATpAj7rFSWcBc5UpFTqyAivgmApBA6DZC566hjvBn7GwAhuAmrXXU3rBpjZjF9dnAtanW4WIEjYSj8hJnBKAr7xlr/K4hb2FrezokEd6rCiKou4oAVJhBo+wsJfACalBKbQrKbZLu7ibNqCgGhhUpzbZCtLYB1hAsh3QAbhqssfLsi0bTQK6btbQEzZLLtJ7qcDxC0W7C/83YLeAsX50UkWLtOD/mwvDoJ/IsAzOgJbRcEM51Hd9Bx3zsA3aAA24QAlaawd3oAIZkL9eMq1rUaXjB6wF0ABuMXFHyqKNqaYspwEN8AjTxxJXihZiUaOZ+SSduTEXwaOf6qm+ABy9wAsyQAENkKQxwmlk8Zslk6VbQZkzsqUbIK0w4ZoaYAG3dVseMAIeoAF9QSfuWAE4nDNCpRIWMAESsBfK2raKaQIdsRGTYFmJAAiJoAiAUFk95kOAUMU+5EOKoAeEAMVV/ANq0Ad/YAhK1AtAS7FJEgud8Ad/IAeTs7KFiqh39WvG6wCSgJ8NwkS8Mb3kkiDH8JUR46lFcgvRowuE23SfSpD/eXEE/6lHwyCWjYpOkOx3K9gNBtKqrfoMoBAJkWAHd1m8MaMWZtsi7vMCFYC2bsGiBqx8RSyPZDYQLbwxOhNebhJxlXlICVxGUpAIhJLBenQMw7ALwvAHDPBmt7UBGpB7kTQnvHWbcbFGI8FydhFRjqYBFDDDFADCt3XN2gycrKyYPEzD1MzKajrOyLqiEsAEfLARHpHOXNvO7swHdaAHW6sHdsC1VATPbVAHKVADWpAHf9AJtfALQPt0NNkKl7AHfaAGPCBPxmuyhroD6mm8HQAKXYmVCaLH0svHxyCgvkxSJQULQOG9hZxHn6qpw7DIveAL/Ck6jopDbdd36CQrKmh42v/wDLGQCD1AOXdFFybxq1XKFEMwFglQACqxoqmbrObszSWwCPSDEpE2UzjzwPLaWxpQAivQBTQgCk1HuIW8E8RwC8KgCcOcADlTPC83JxtzpbapI17BAS+QXZ0L18gpAdVcAh4Awtqc13gtzvIIZhTQuWrkkMk6sIoZt8oqATfABOo8ECESBnZwOllERV6QRV3QBUogBVOwJO+iBDyw0HmJBWzwCT8y0AB4S42AB3mABjvA0MV7vEiJnok6LR9wC18pOs0wlhhNvcWQnzm7C881FD97vbegEyetqdWbC7aQC75QUo0cMaY6LH/Td8WCG9YADZ/wBDXgAZUTmWtxmFD/cQSCEBVjIgFo2wCqjNSHDdfyaAYwYKTl1VMtcaVS3RLF4wEroAN8QAOXwAsGSdIRE3yrkAHKR14wp9YmozFhQUonkF25h69zTc3abM157dfyqM1gFmYSoAEXyY4NII9XaN6qp6woWgFdliFadC6nM9lSoAQ6gNlKcQM3QAP28i4XgQM6wAI1kAEekAI7gAWioAuP8bP/x1WkoHho8AOrXbxKfrwO7Wso2wFAQAwA6sjKUKBjiZXj0se7jalfCQy7sNxA+zC8zKmiqrPLvdxk7tzlWx6T6gw5NA1+swzNkAxibd87ngEdABdU8t1NUCYuoBJD/WaCrsqH3c0LMALh/9dbGCmv2cdwu8ORDnUvVz0oYv4LwrCftNALP2De/9MiY9E+Q9DA8n0mMmECyAlUMhHDMqwBNwzO2u0BJQDhEG7h8jhx8vi2rMyv7Jisb1ucMMAEUmEhFzJGSvEutjMENG6tfrsCKtACZHgDZMgAtyoDaDAKhHKQMxkLorADTvADNVADLOAB+bvkd3lX5X5XHSAJyUAMS4sMC6Kfai46ur3bOLu04roLw2C9wz3mXU3mnlpSW60T7a6V5vsrgCOpytAMmKBZeK7kKVCjZfLd2WfqhV0AnYfU6N22qbwA2meR19erRnCYIh/U/6gDStAvSkAK/H3I+ykLwhAJDMC6Vf96BaHev+N3pbdJe2dRP5zEh8ipARPxAq3e6tmM13N7zBk+Akh/wI1p3kVc6BVQm7VpBG5RAjcgIbazECswFn5bqx6gArEuPmNYqwyQXB2ABSpPJNGDCxDbCpwwAzsQnneZvw3f2so7LZYDCr5n730M71y5lV9Z2/nZxxvNy9dLuPjne/yZ70WbwYTb3KJjHuRBIM+Y8KMAedI+7vzBvyMKA1ay4EYc6L3+9KisrLEp9tdnO90dFb/q3U1iO8O+ApWw8p+aDL483J2QAdrlFfyIPfIt3/U1EjrXF8aMr3Vt19ot67NOZnx9hd5s6Ee969LfmBNXAR1u/WDGwxHe13T/feEXrnzezwAGcADhpgb9JQwPC7Gw0AqtEAlK3gDZmPmar+T0f4G1sNEcbfsXN6D875WB/xsAcUzgQGHCiB0jVlBYL4a/fiks6NAhw14Ge+HalVHYMI7FPBY7ZmwYsF+mGAQYcIBChwwdPNw40SImjCFDXrh4sWCBBQkJdBY4kMCnTgkLiupEilRCixYmTDB14YJpCxhVq0KFMdWIERc6+PDqtcvXw1/Jjg3zRQuVCgklnI64wKFECaYmSmzQsGGDiRESRlgAvAEDBp4SAEvw4KGEBgoaPDDWEJnCZAkaKkiQ0CBpggYVGnymAHrBUKE6hfo0LKEC3s+tOS9oMPQz/wMFDGjH9qmgtoICQBnsIdVqFShQn4x3Qt7GwXLbtjM8b9lBeocPH6Q76OBD2ECBZol9P4gwfDGO5cs/JBZ2F65bt2rVggUrVSpTpewTxw/K0/79mPz7pyTAADEZ8L8AgXBggAAKUGCyDDyQwo0ToqJpCBdOeIGDCg5D6oACkjIKs6QwU+2CCkoYogUjmNDBhRWieqqFqKaiqaoXWngBhq5UIeaXYQ76riBfUuElEQ0ukGCDEjiwgCm36rJLgxGc4mAwwQDDUq/ItvRAhRI8mMyxxyhIEsnMNDOqgcYoyECDDFQIDbTJRovtM8wWM6yEycLcM7TJQIMugz8ZmC0DA/8MqK0RTjT55JJLKNGEEkcnocG2BpprzVIGlqvtgOWW80M//v4DkBJJTqWEQAElSVVVAQX8jz9ZPcHPPlNSkUWWWWixxZZccvEFmGGKMUYZZJh5BtlnrNmmm22SoYSBAQYwoIHHPJiCDyNGgOEEml4gAga+OLgSMw4aCIrEEIsiscQLNpArRybmbTGquWLECoabmsKxhRIy4WWXhwziJZiwVsGlkrxMYNKuGMeda7HBCMNghBHIJcwCDcgV81ovFdtyT9UqiKACz3Sqk7ZNHcjgUt1Aa6A2NT+zjLE/W7vUtQQO4NkAoHg+4FCfDy0ApWnlmKSSR0+VJBKnATFggN7/pi7gUKAP6NQAnhn4wAEg/PDja7BRbXW/Ukzp1RZfghX2I4GQUaYZZeJu5hm7n2mm7rufoaZva/4G3JprAv9bG8O30eYaw7vpBhpQdlBg2gMkW8IOHXSgaogKm4prg8s2rOACDRL48Ch1MQOdg7j4MuGFy+tdwS6Ln4QKyhFisisRUlBZ5ZVVWiFFlVFG+USVT5S4S68LLFByRn+T10uwDSzmAGN4GY4sMcdUUGHMxhjTTDN1hdJNt6CFFprqaddnv/0A3g8AgPgBoL9+++/Hn/4dDJE0EkqcbkQA/+AzrGGtfA0I1HWWI50PyAAXAgFJd+Y2t7xVsIJ7w5ve7EYN/2v0zYMfBOHfQDhCDv7tGoo74TX81g1rgOIPNogctQzAgBzYIQcrUEJTLDSEI3BgBKHDAIksYCLPHcAoJjudySywGgv40IcjcJEKVuCluYxALxGbilNKMKUTmKBLSkOOcRbVCf+IQhWK8MBqTKDEDVzFLkpqAZaWiMTLYOYzpsGZy3ZWgPXBz4/5AyQg/fi+9vVmWlTzUNWApoCrne9QUjOADFThqEcJCICGcEBtbnMpBrAJOixZGXU+gAazcIc7yICbsebGDFa2kpV7c4Y0PigNWk7DlrSspS2pYctpVGOWthRcCrGRjWz00pbasMYoZGADDxxAanxswBRwwAIl9P/ASW9RnbvqWLLL8Iwo7SKRyTZkonc1AC8aWyLzMFMy5V2AnCZCogYawAenTeISk4iEIvDZCEp8Qg+K6V4JVpAYhk1vi25ZErzcsoHCFOU0PiEUBR4jGdLxcX1UwyhGrXY13TAAaAzIgMzkCRl5JmYyetrTbBDoMgW0hjEgNV8iYqEJTXSikgF6WsswpdKWPQeUm6KODzBhLFSicoJFRSpRJ6gMVipjGctgpTOkOlWp0tIZ0cBqVmmZVV5iNZe8nEY2sIENaWCVGsoABRBSkIIOJBIo1krBDH7wA6Bl1K6NbJcFJsBN1cyRJxUYHfuoNhRxqqsBRxkNz2iQCEXoMxL/jGVEIxQRCVRogg9z6ZILVKABzFjAKfBkkmGqZ4EGNBRlEojTzOTUpziFZjSw4cxsMEWb8hEqZrZhk5omY1vJNEBPqtVMbBEYJ8lowAgrQKAmLzHTTjSqf/+jRB92+pmeflI6tXHAB1Igg1JAY25GXeoEmQFVVkKVvK2kanqriktppFca06jqNHZp1VxWw77ExAY1ZMkMT8iArc+ZmYcMkIEayEAGWzhNb4A2GqHw7KEhqgBRSBaBcIqzjqQF2mmMopMIKK+wJGpABBbAMxUUorGReAQfCkGIyV6iYJxYwZcio6fIXOAumFleZkDMYNOgJo84u1lwGfxgDQ/5oT5B/3JpNLOBM9lMMxRYzB1dA1vVoqYyMWsAcz4RC+TYtLmdEJAc8oipQPnUU9iRARB60YxUhveCe9Pg3UJIODp3sISA8xvh7mzCEyKTGnhLhQym0wEHrGAFHpJaA1ZggxzkgC6v3YlP0AQi07ErRCNSDeoMw9lMt8so3KSwiGADG8zsTAMqfoQ+E1GIRziNEqgQhir4QIM5RXgxGrDL5w4r6sOCyCikTa1ryfSZh+KmwUkOys7qquCrAcU0noswzfyEMyIf2dpCoQ12VBGLSzRXE63QRSskFd3n2BaB1bXuyrbrBw3mDYPPgEa85T1vaNS5cPYmnOEMh+9871vev0ADdv9Yhh0PsMCiBbDWCnCABCYPuSd0QkqSizyUiPt616rRGaSVgtiIIxk2+rTnJZyWanuKIhm8qIQHWtbgFnhgZh4PX0pjSxQLHFGcSyxRZohycV8Lhck9AV8CFECab2ZGAyVwJ8w+A1jMcLaJPHboaRhw5JD+gBetqClydCEKUQgIDdbxgHQ8wNbErDXscdVuCnaQAkrQ2+3y5ve9Cff2eFuwGcnAe5CE8Yuw6EIXuIDPK1xRn1IQxziKWCtLOrBWLxTCA3wcsBRvgAOhGJsoRvG4xn0t6qJLgJuXQVnowWmyESmFTomoxCRomurUa+ISoDCIKHaQgRLsLAFRGdOGQbP/pQjD5uKVDp3FflhH8SF24kEJ7mt0c+3XLP0yLW1NkkSMlAiIeGc9TgBtL0WBBLjpAIkIhioY1QlGVUJS5v/64q3jkk+GnToyyEAKGiiDT+Dd/t7Re0T63h74rOIU/x8e4tiPLqOpUnmVVYkEpjkVp2FAAEIERGgEQ0AERvgDPaCBxXOJxFCCSSiEG/CQyZGiyxkdJEu2yyMKCoMACYCACFjBFqyACZgwCHgXDICX6IEnxCIRbnqXCPM8k6k+62uAN7iESqCpLegBfTI/TcAFYtCFSOgADUisEuielmkAzoKNvCiK5KM4TPM0SstCBnOw0pC4ZFM2a1MAKsuZ14KA/wlAgAUggiuAAcKwvWRjpAxoDkIpoAP4g1YQhZr6BJuSlHuaBBnYlJb4lJWxrg94kA6YgRTgn0Z4wAc8BEOgxEq0RAmcxEPQxEOYQEVABEVgBFBsrMZKhFIkBBYrxUQAhD/ogzxwRTzAgzSQxTTogR7ggRmYAQMju+dggRQYuwy8AT54hBRrAETpkhu4nEfoiZo7DRGjsOmLgAuAABlUHXe6gAnAxml0p+oRvotxJxj8wRcUp3eZHiQJHXgCPc6gAUqaBEXQg0SYBNXThFVIBmLohA7gvtEAMOoCn7ZogcswEcSaNFIDLM7atR7TvTsaOkZqKfMZukbiGQXQmo9Smf+gGYppRAACuAJWCAVIWISPNIM6yT4KACmx84AVWKsUkIOsoxXkoKRKqAQ9cAM3eAM9eIM20IOc1IM50IM6oAMyoIMeUII64INE+IM9QMo9oIOl/EkyiIM12IIteAIncIJGswFcbMSUTIytjAxBEZQ+sSPZWpk7fBnaYqQP7I0EYIFeJLsV4AM78IJ4XIGWCsEbUAJVeAR5gjRpBBFo3CsO+8FwJKInIpd3aSjU+RwLAywtiYyT4YwUuARN4IRL6AAZSIQhdD1RIIZmwIXZixkFeA6W0S3iKgHAKk3L2JOQOTedIhSV6agxoy1LySMH8SnpWCsDk4Ed2IEaQAIWcIH/I0CBB0AABHgASAiFUNgESICETThOSxCEMziDYeRAPuCDKbCDQuADOmiET+DDTsCPLgs5GvBFluAk2oLIifyoswSajYJIAyqfs3zP+Cyf9kwkn8Go9mEfAdBPASCABfAiDJQBO3gDGoCDR6gEO3iQGkDGG5CC8OODo4uwBJi+ywungOw0xTSZvFASGbs1CqiAyagjDy3IguSSx6iTFLAnmpoEA1UaR1FCWNAEQQspBXA/lgiTa0kM7jnJFagBHlUCHaiBWuwBKIjKqFyDOjhSPYCDnKROJgUE6gSEJyUEPphS6mxSpHzFWcyCufqBFGCBFhCBB3gAEACBIEABEAgB/zEVUyFgzkxwhE3IBI98ziHoiT0yABuITO/Ujz/EBJqKBN6wq0C9KPXBz0I1VEKalkFSVEW1n0V11ADgTwSYkrOTgTXoAhqggS5QsQ5cgRtARiXwgmbghUl4QtzQMXHSrd1LzY7hSsWQQu7pnu7pEu6ZonuRIkPzVGTUASmQAiWoCh14AyLkBE6AydTDzE6oBVxohUZZUVYbxkcohGgthFJkhESgzkSYUjt4yzqwgzIAgzZQAyzAAifggXKVARqQgaxkK7aSjn0kS7M0H/psNp4hziAIAjHNyOEkgH0lABQIBUcgAUgIAUhAAeWEhEA4AR7iGQ/gg0owjuMgvz6NhP+o6aNHfZ9AwtiMvR+LNVT8DNTe4FcEmEZ/oY4UeII3UAEaUIIbeANNlYJa1AElANVVsKkKfB0zCAMzwM472NRoHcVnBdqgfdZ4jMdiLdZMsASYTFqYJFqhvQOfnYRh1QSlSRoX7YSr44RJAIQe2KyB2kowSa07tI3dyEP1PE+h+cCeIZreWNuPFdRDIoAxPdN8JQB9zcji3AQQgAQQCIRACAKBdQRHCITlHDE1qQNO4DquO45LwIL5wdhFlR/4adRH7diONaRDmpa1faaqQc+IdABCiTB+FYIY4AATcJMDg4IUUAFPFUolqIFqklkp8IIpOIVXgAVRIL/UG8bGqlb/QnhSO4CDln3ZGuCBlGQJKsyU5tCk2hrbs+TcqbFPn3kmA+iAFnWU1IPJQNyBzw0aQq3cQ7VYRtXY8QUkASBO4RTO/STO4UQA4+xbge1ISBBcSBCBNz2CAkiA2lMA6+SEWIiFgomFgHOmQkLbRYqh720f9Clg2/iU6dAuA/MBIJBgNGADsKFERDiVRoiEpJFaqf3DTxCFUMgEFDhfIXiBITCCLpmCG+AeTMXUGqABKaIB4n0CIgWFSImEF/raQZsO6JAt9WTbzpXXnskoqRGsA0AgyPMU1aOkl5SUFPAo6WUf8SXfKrbiQFJUBTFffTVfEMjIffXi9mWFTfjb5WSF/zM+zuTcBEf4wA0AigIoAU4IBUZggUzghGaSyI0SOC/1UhwoAqecvx3wAR/4ATRAAzXAA7Dxg0qMRAV0ZFY5wEh+FVL5D0r6Q+TABPLThBC2BAzA1wfAABg4rhvwAh2QIhmOYUNz4RvgASjogjX4H6dJhClIAVb92udIqc8oH4r9mfZs26lxn0U9JEQ1gERwPdcLREehhKgZpCsWpPCF5miGH/eZFvZ9AH6t2/VlX+VUYzRG400A503gAGdqgKlJAOO0AmeSABPgGQvwgEewY074BHmW54f9BFAYhUzWBP+gKTKi5H82kFah5Eg2QIEG6FjBhP7o0094BE9W0wcgAf8i6FUvUAKGkcJONTQF5dEb6IEn2IIlXTzxrOXyfM+InE9fzsP2rBrvtVzoHZoDYIAOMGZSiAW/44Wb5gVR6IMOGNuzVWC3BWrOLeCPamBR2q4JTmRDaJoC2Q/8MI5MEE593Vd9FVMQuGZrfmgyHdPBDQQTwI2fWYSOHAL8HTF+FQALqOdQEKNh5YTmGkBMzuSEPmhKHhWAnpVZqRX7sA9ckQVfyQVgYBtfyIWLsAQ2HFMyDYJAGAIvqM7YOQHJMzSM5lGh/Gg94IOWYQ6zFNs7VJPncAwNuNVb7VRPpYEVKO3IptXSTsnVNruv3Urs0C4fwANE6ARSWIXbXgVUEIX/S/iDHfCv9asO7ZqBHXACQ+6DPvgDQ9BgAXHRrHtYURgF3rFdWHgPXNAFioCI7AYP8EAIUxKIuREIYggGVhgB/oxqa8ZqbGbfqf5i4RzYNbaAAyAAETjORSiAfS0ADoCBug0E5gwFVThjVUDaTFDre84PUNBrWdjrXGHwtAEWYIDwtjEGY0Cqp7qqXrqGargGbNCGbOCGDweHEO8GEQeHeTDxbtCGbXiGS5iAMbXXxA6CJmACPtADHHALKIrsFbicG+jUIpgCMCBKQHCDLsiCLhjyLf2BLNjSHqgBGH5hTMVFGrDFXKQBHqiBRtRF1j5XHnACccWCN3iDPNCDP4hS/8aarHqKR30awm77MuTwhDAqHlUQjt6xXf+1bpwOBoPg7u64vz73c/tThmQI9D8Pr0I39D+7u2RgBQjQTwIIguGsaquu6iAI2Xy9W6tm3yDYhBBYhE0Qgv4e40AggA9JAP48gAAgAo4MhTM+YyEQThGwBF5IhmaIN2bZhltnnFzXdRPn9V739V6vh2APdnwgdnzYB384dn9Q9mJX9n/wB3yYB2dJBkVIgAd48WsngjsghDhgAVedIslGxhrQgSQAcm0lhNzURQPbASCgYFf8AzI/sQ0u2siUTLa2ZxDmOlIQheBpBd/5nVhohYAXeID334L3X1Xg94FHBenObd4J+P9YqG5csG6/o4iBKYjv8G4+9/NAp6C4maA3eze+kSr9kq/AGRzEiTdWuOZIJVPiLFNICAIQQAGO3Ffz3ddPtmYQAGchWE42BWcMeIGuLgABcAEN4KNN4EhWD4ZQuOaphvVgwHVnMXFuMHFhr4d5sPqst/pix4et53plV3Z+4IdlJ3Z/4Id/cPard5ZQqNeYJ9MyRYEmGAQ+4AIemCIXkezRtksgJ0pCYITEJQVSGIV9v+3phoWHN/jEV/xYwAWIj4/3gA/qfg9YMPz4sHzLf4XM7x3bzm3DF7z5SAVX6B1YcIVZMP1cmYVe+RVgWRth6YgJh30KB6+lYoY4Cxx9u/X/qNf13ef9XL91VfjiupV0BHj5TQgEvj1jLiYAvcX0SEWAIEhjmP/bn38B5mSCAWACEc4EVgfwM4aEpnd0gV2ASOgFaGgWZ8kFrAf79Wf/9vcHZ3/2rud6fGD/sa//s/eHq98GXXgEEihTtwcIEAJBkDhTiNCWGjZWqFhxY8UKKYUKSVEiBUwdO3wSKRrl8eOoU6dGlSoJ8qSojylXggTlEtSolzJn0nxZ8iZOU6Z8+crly1auXLaAAStm7KgxZMiWLWPmjBo1a9q4dataFdy8rFq3ctVq9SvYr9u6bStbVhu0Z82SHSPWi1cgAnIFEEDwAAECAg9ABIEUBASkUJAE/wi4CxiSQLl5H0BixWpTkMiQIJ0xUaBAggUJDhyQMCSU41CqHoMgQFivwAcBBDTIlGybJ1DdwLFDd85cuXLjzPFW53uc7+Dmdrd7V/zdO3rK6clrzpwev+jS99Wb90yTBAR8I3PnLmRRITtgbqgo33CFjkKxVNnh8WTLHD2EGDXCaf/+TZ3696dKJes/gADaMiBQPgEzDIIIFmNUUkohowxTTTHzjDPSTBOVNd1kVZVZXYXVFYhcgbWNNtZAtYwyyBgzDDA9/ZdKKaB4ggkmktgoiR9+AAEEGzv4IEMHHXzQQQJyzUWXXXfh9UBfm2zyWFwEbIfYAw/UBUJejfnlV/8QmwgRwAADBBAAAQtgwJkFGDSxyWisBPIAYXQdVppiZ2jyATKz1XYOO+usYw47gfrpZ3CFqoMccoEGqlxzjULHjz/+tFMPVsQAAoFe3XHpHXh8lKEDQ+WtwMINUmTCSR09QLGGHn8k0kgkQflCFK0LMtigUhFG40w00/haDTXVXHMNNtkYmw03ySqbLDjNOutsPPG006hz8sSTFbUekjWiWdtY8y00zSijTFvD/PLLLre4AmNMnXSiCSaUUGKjITnmiAYQMnzwgQP9+vsvwAwwkEEG/SrAwAJGHlmXdkHYtRgrwQTzGApS9jWZX0ouGdiWIDC2CAEJcLAAYRA4YsL/AIFAQsAZoaGAwGmZTmZlXQQYgMlYfiq6DjuAsmNcO4Qa6huiigaKXDtJKx0pPtXNsw0vLkBgGHeBdBcECkQUkggfdUhRA0MQ1fDQRnVssUZ880USSbLeuO12OW+/nVs55KxTzjrk0K03337iPWjddtctTm4/m0NObT8j5w48jTtuzzvy2GOPPu/oQw8+WWGTy3+lpGJKjDLOSOO8N0pyyCGIGLJ66oi4bkgisQMCyB+1/9EHHniogcYPO+wwQwrBC7/vkEEGSXADBHuQQQMWJEyXwgwzycpfVUIi8SahhIICYxhPJtBfHkPipNV/RQaBAKshQAKmBASyySJENAEa/yuQ5EWAw4wF4cgmeN3vwTHmoQ7cqANvPVMU0JI2NN/Qo2gITKDS8JG5eUjjF624AJMGwh1IqCwQgVjEFQKxNULwwQs6ABsLVlADKdxgCnXgwxrqoAdAcCQSk5BOPibXuEjdo4c9nJw97mEP5SRnOQ0sGqKQw5txMHE3ybFHE32GDnSIo4riOAcW33HFc6QDi1iUxzy6kYsdAeEDfmADG9CgRi6w4Q/1OiMb/PCHHNmuD7UDBCEIsYeu1aEOtrtdHvCAhjy0QQ1Y4EENZjCDGtBgBjIQXvBGxQIW2AAHN1BCFnCgAxLk5TRIWlKTAiGQ6wVjExN40iIOM5kgiJIvfv9BQfY2BZggQC8AAFgNYQLhGMdMLBRYkpP5NjE+/9UlFhrizTe+UUDeGCeJSuQNNHljNAQKalB+8kfmpOGHA+BlIN7cTmQ+SAQYbC0RhLCDEnJQg3W20At20IgM/zAfWN1QOtL5Bz7x6Y9/RIoeQYwUQAMaUCBOTh+Xuxw9DKoPfPjjHjkEYuNy2Dh3uOMd9ngoPPLRuOR0QxuY2JG+fEBGHzgBCybFQklN6oQcPKEHP3CCFrRg0ja0YQ5zaMMa1qCG3anRCT74HQ948LtHQtIDHjBeByQpyRT+QAk6MAHM4nSahz1ACE4KxSYcEQqJOeIMWw3F+wSzCJXdpS8hEAL/JBaBGMCoTAh1EYEIOhmABdBvl6xYBM3ywhddChMvcrnDNubhD3Oso1nrOE7SEqWoaEZzmg60pp/w8Y1ulMIBB7gS+FAQvhDYBQQoEAIMSlAIRTCCa15AQg5uoAMdKMGdfOCDHvhAQ0XYcBL5vK1AGcrQfd62t721Jz/yKVCA/iO4vj0upIjLzzAeww974MEMPnBSlDqhulzQwhNaOoMONKC7yfNACmRAg3X6zgfmNe9QiSq84xGsYN79l8Di294OaKBItrRl+j5ZF13alRWqUMWTkjGx8flFZX4BQSBeJoQrCHMvKgsBAcY0JgEgAANCEIRo7LqJX16Jg42pn5EO/4CKbuCDH4WdzXESSCjGMtaxyeEN3ehWj3ggAwgHKIBcHiACDHAAAxhAwQcxsCQMwEAHtH2EIgrhKSgooclKmEIZYitbjjRiElbOZ3CTyzQJStAf0SkumLMc5uICF7hePjOZ7Xlc4QZUn2EEhXOnYIMU/KDOL/2BUGvQgxp0QAEFCFOYLmOAAwwMqcQrXgcKFjAGKEABnHk0pCN9gEYrwAEKEAAAMp3pOM2lLoFhUzAEnIxkxIKXbpKMY4Sp2bQ6Aq1rDYwQKJywMd2SM0/yr2MC0UnFWK0xGz5NA5Qxj+Kq4yrmuE05mpM0nfWMxT6D5tFgHGN1zOMafujXAQizgP9tS2DbEOAADCaAgSqJ4AxheAS6kaxkOEyBtVMAAxhiS4jY0dbKk2DcRPHduCNW1KLwcEc6JpqOgQMc4I47+MAD/u904Dsf/NDowd2Rj4lTfHL/uCg/MK6PeUyjRoggxB/ykIg/zI6GJFdEItLQgQJoGtADMIABHPABBqSgkU7IAxb6kIc8wAEOa+jCFLrghSafECLmMSrSk470htRABQu435GkSmFIjEbAoW4GNILxX+05YhF1xWoQhIBVL6l1lIKpyyIWcQLNRFgAEsgEK8b+F8UgYIMHNo0AIrGNekQHHFd5BzrKoY6g+ekdgXK2NA+PwAYqDW/xYAYm+sWAGxf/wAIWgMAEJgABzGdmaiKAgSNGm2R0FwIQefh5F3IKBz3oIXaJoE9t9U3RfFM0ifY4+L/1TfuIMzzgFJ194x4O8cYp/HGT06jDJ74PeszDFjZiBCD00IeRl3x2iQCEItJggFuG6QOUWAUsaoEKQ/jAASnwgArKUARAxEcPfYRDF7bQhSpIAQlKuAHYIBIqFSjdqCk4jxK4QAsIgdXchZFwmhBETKiNGjQ0IDTwAidoT39pDySQwPhoTyasUl/oWn6ZwCII0yI4ggVwRiFQoMMwDAJsSvXIxQJ0QmDhU7REC+D5RjwMymIh3jQpjuEd1qCAgy98wPk1QAJgxgaMAAZo/x7mmYBmIAAEYAARWMIkpFu6jVwd+BwcyJC8vR49Wdnv/V5yHE0RIYcRjSERKRY9wAM9VJQaOtNyTBw//FvjoAMakuHkZNzt0UM8eJQkRIIimF4f0I6rWB/2AUIXNICjFQAXQMNYdAsqxNwKuAATMIEXyNDOEZIaaMEWaMEPuBQiNdIkQYTwIJ3wjMoNeMANGAEMXIEjOMIV+I//hIAlhBoxjFoyrEUDNgMpaAInOEYs9OJohMIHhgZWFdgmxMXzjAkEWIAJ8IIjDMEIao8QwAn0JEZf/AUkOIIlWAImFMM8MJS1xIM8IEdu1CCzNRtjYdEDGd7REJ6fdIMp7MAKbP+Aj52ABbzAEAwBDLyACHBAj2EAXGHAEWSjvdkbH8IW60nZRtSQvVXCO7gDOzik4oBhA9Xec4RjOzBHM7VDn/zM703RQ4Ih0rwDPEQHHKahGC6HPNCDP9gDP1BUOfjdMPjBHtKOzpXc9WGfHpBWGUzejdFBMxyDJ0hCAyaDJBiAAmjAIDzCO2GhHOTBJZqUJrrUOiWSIjVSUQXPJFFSD0iBClySFEzBI2TCIsTAFWCMaNTiWtBiLQ6lJnRCL4YaNBDDxPBSMPBCqQHjVm0CBGQC/JzAEGaG9riABXAAaeAdkvBFBi0CK3ACY15CKgQWPigNEUXLsvHMDUYTOubgOgL/DjeAAhBswRS8wAicAAwcQRM0wRWkJhGMkz3e4yJkQiXYmyXE5iTw4fXJFh5xhCLUm5VVAs/8pjUpzbIFSkXBQ0Me5xo6JDokXMIt5xR14XEmH0Xdnu0NEebQwz0gU0d5gh983B70QU2ak3gywhyUVgNwxp8NQAOkgJhoAiUYwABwxh1oDyPoEevNgc/F3xaAgRQkgRQUQQ+k1jp1Ig3IwCPRwHix0w20QAt4QRnYASFUQiZojyVg45MEQ1pYw1oQgzAcA9Y1oFsw4FBanQJKTDAIRsTclS710iAkQPM8QijAHStEo2FOI2SAwFaJgid8AidoAjFkxXGgpDws23Ec/x40eRGfNNbhvcPd4M04cEMp+AEewIERnAAJiABqnsEZeFDaBYKWaukj0GYljOmY2lsjxM68xQ4jMAJvTgJD5qA5KNZiPSdFTZGdokOdThFzchFzElydBtzEAV8XQg5y1IM/vYM5gMM2NBfI7cEf7MEexJY55ZE58cEYTAHlpSeYgEkBjMkAFAAROIYqcEIezUEdlAGqgkEVVIEXSIGrOlkPuNQmMhKC0iqC0oBqrZYX8IEiTIImfIIqTEwmTCgrNMO3gAstOmADboOyOmAtWp2J8oICRgxo0GIlUEAmFMImjFr90IxUKcYqBatLfMInXAIoWMM8SEsDGdGQJlaiYP+mF7HYzwQKO97NNQADLfiBDKxACbRADJjmFQiCIKTdIKRd6D3CJWgCmWYjmcambaqpFg7kvdnGOUwRFlkskl7sc2LsndppnzYnnnbhcgIqPDCcPfwe7R2fPZhDR5UCG5CQQbIeDbleHk1CJuSAn33qnwmAy4mJACimMFrCHZTBGBStqnZB6m2B0jZZrNqZUDXSItEqRORqF/xBJFwCJ4hCK/ACL9TlJ7RCMjTgsVpDAz5Ds3YLsyprWpoo27LtqAVDLyaDXIYaK3DWAcaMlFiNKhDDSJArJ1CCLcwGOKYkPEwOPShN0fBGxt4GtB2NoFTmOmzIMHAnGsiADqAiDDD/gRncwSCYQSHcwURMwiWM7pjOZiWM7iXQZiPsJuvWlr19bBcN3BVtkcbiqW2IQ8h25Mh+bBfm6cBlVMmiw8mibO1JTj6cw5M+gySwQWzpwerlQeu5niLk0SVonRdsRnoWQKYuwPzYFWhkax0U7RdUwRQo7Roo7Ra0VFA57Q7Q6oDeAA+olhKsASBcbSdoLS/oQl2O2ix6C4loQ4k0qwA366ilJS1KjNUdcDDMoqiNmi/dD2Hg0mEGwt7GCI9qwiVgAjOgWBEV7uEW3rsq7rE1rg4aHm74CROtQz2s8DxwAzUAQye4yh+kgQ/8QBr0QSeswie45yW8y+gO67BqghCn/66VRQKsNMIW9iYWXZHF4i46kEPF3mk62Kk70Cm+/Z4XUXEVPyeiMA4XTdzADd8cHm494MPETdYsoMEdAcJGzNtrzRYfBquAsUImCIIJWEAJvEATLIIlZM8EhoIl1MEX3NQa4BQmKm1MPQEUVJcTIFINBNXvONIM8MAPZMEauMrVaoLW4oIu1IIuCIOxasNYcAuzyi0tCkNdxkLXzi0tEsPc1mXb1iUvNDAsF2CNxkk3BcICx8IpiEInXEIk+EEpdEM8qKQ9ABS1KJufNAc6rIM7aKQ5dCwYUhM7NFCTxkNHIcMzyIIkUAIopAIwBFY3XAMz/AImRELDoi4Gj25tsv/umtLHI9hbxt4uOdSzPdczF9VuFIdsx95pnnpkoOApF2XU7/opEbXDPPBdPsiDNSzvGr9WHikZIBjC6kZCMDRDXe7SVTkJR9/aBCYC2rQB+sZUJmZXdlVXDziy70TyDOzAD2CBGrSeDf3qKsQCJ+PCLxBDKI+yNpCFt4BoLMCtKqhyL7aCUevCLK7tK8eyiaqlXLqJAd4ykvSFxLTCKOzwJUyCTCLDPCTUbuGDsgnnMsuDnyQNOtTGnTrQNP2e3bRDOTALN1wDAPd0VqwDN2gDMngCJaTzD6MuEfPhbjYCusnzOVxRPVuROBw2YlsRFtVzP2PsPkM24x6bbRQfc9b/HtKU8T/swzwAgww4gR3VzhvPjhsZAuvyAjQkQytYwhVgSZIwyWR4tF1BYCGLdExh10kzshPIKiSvtO/wABa0wR/QViX86lDbtC70gjCspVSMhTMwgzaoxS/ALdcypmgMtS6scjNgnVpCK1PPMv+GWigIgSuahmFmyiZUtS9ntSLUiydoAzi0Qz/8gwSFtXBOC+GZNVpLs2b+DD1Mkd+8NVZYBTdkRTy85DLodeqqsxADcSYQsb0Ntr0tthWFA2KHA4YzdmPfs2RnsZ0i6ZFi0e8Sn58iCuZ4IzdgggzswB+Nth2tzm7+wScwaykJgcekxl4Fxi71EmhwQm1nIiaa/7Ru7zb7rnSdBfdw92bW/lcrqPInH0MtPsMzHCszkC0xfG2wjiopqEIrBIMuZHcBY912v21TL7XEpLaAda0jaEwnfWvdXU8siEK5UoIiuEqO+EI3fIM+0Hc92Pd95/c6oMOxLa7PGI3hIcoUBU3SxIM3fEOzfMMK48NbO8OMMHjCaoKDY3CZRqHEXjiGZ7g4hMPbUDjh0E1ik4OGzzPGQhMV5XM6aFTCYXZyMA2N5YsMgKcdvRYfgNwdvV4iRMKzcgKcBIB2rIZk+PHEZI+TcEIZ5NQakDRM4TZKx2pQVXsiTaUTbMEMjdzVJuwnkEIr4AIvCAMxQHkyKIO4NIPZWv9DMnRoMwjDL/TCLehCMnTtuJM7lBuwK8vl2y51K0trELD5rk3V/qiCKGAwJUQCIgAiEEiCM3DDO/zDCqdkER2uotfrWT924rmYM32DOIwDOVARhu/Wk04DKGCCX69zgzs46tKmm47pp8d8qH/63MQ8htONN1x4qns4FkkTxcYu8JY4ovBTPXQDKOxLCuQBeP6BrsvW7QDCRJReLIwaL7gVABSGaWCMhY2d9ojGJpjN2TyBE7TUScdqSj/yVCKSIgmPgUbtBxioDPyA1dYmJWSwu3TCjHiC3oPCLXhoWZAtuRzDMwgD4XMovp+LK7cyUyOw1W1PlXiMXy1M3QnBqTj/7OoYAus5ARA85jhgU5+P4ZBC1qBEcz9v/AMpzhGxwzlQVBUVtnScwzdMQylgwhALse1nuu1resNWgs2LetzIDfAHf9zEmIUj9uIiqcUyZ0blw50azT/cwzwwgx/sSwcofa43/WslQiEMwiDwgSjIbS+RNwKoTGhoFUeLRteGAh9k4hq01G7vdrWr9EpPpSIpkgwo0jpBUg1kQR78gRrhAUD4ESgQDxogf9D4QURpVa9kz7Zt06btWTNlypAVG3Zs2LBfv5IlI0YsWMlgJEuGhJYs2CYUD4IEAfHgAQICBATkRAACRaZOkyI1+jNUD58ZO/wg44aPKT1676A6pbeO/2q7dlXNZdXKjp05rl+5unOHTmxZfvn4nU17Nl/bcdhmaeqkiW5dupk4cbJb91LfSpXCiQs3OFy5ctwQe/NWTnFjx44Nexs8LrC4c5cxi9N8Gd25dJ/TwWs79vJXc//wdcv14UOHDnr67OlTlE/t2nYKFbpTSNMnYrxMbtoUilUo48WHq1IVjKUqRmueQOfhpAf1Htd78ND+4wePGt9rzBAvnsf1FOdrZEmjB1Aa92jQ4OmTx4kTLE54/NjhQyElT66AUeYZaySyxppnLsqIGGFEQqWTkERCiblkViJGlU2CCCQmmUCYCScBdupJk0kMAWSoPP5YY4YUZABFm3jw8f/HnqfYiYqeq9axKsd2vALLxxrf6aossdAhKy200tqHrXzgGYcbXzz5RK+9NMmLrrw46WQuui75i7BwHgtzsXLUUSfMyBYTZ5w12WRTK63EAQ00ePgZC0iu3vGnnm488UONH2SAbY89aCskkUT4yE1RQgxZBRZeWApluOGKM844VXghJplYQnlkizbWcOK7GZ54wjrqtEvVO/BYLS+7/NzgIxFFaK3VVkUYyVURRPkwEZBZKelkFFuGUQYabSKKyBpomtkGGWWE4UWYZqCpdiWVkmmGl1AgCUTDDANZZJEHbiIAASEeaSSoEgEx8Q8eEsLEmnnw+WdGeuyZESodqer/F0+ovlqzR6jeKdJgzIZkB5134EmHyXPEiceZUjDR5JJIMKa1ry4vsZjKLifRTDAxxfzmmzMZM6wcNd/MSuA3xUFHztD4gQcdc96h8R185lFGkj7WqCFQPfTIgzZZa1O0EEAiESWVW4QpSTjhLK0auGC2VaWSJ9p4YtUaSrXuuhpS3YHVs8HTLgs4ZJ310LcTaTfudtu1jY8/6E4kEkn8K4WWYbIlMKJutoGmmFJcEQaaZasNidpmOIVkEUe8dQQSyWW6CQFILJlVkV/d/cOHLPAwZJZu6vnHKYJzfscqHP310eWs/h3L4M7OIcsdgGukB56G4TmnnW6UoZgSTCjB/ziSKz2ecq9MKhFZnDAR48ab6k3+JrHGVF6ZHHFadllgzMg32B177nkHZ3lwrGeeVPDQYwsZZMjDaKJpG8ruu/9Y5ZdhfhMMVkDCOJQSIHFMUhxWcEILetBCD0blBFNh51XaMRvawjMDFtSABj1ww9F4ZTc9DOUPfTDhCe1ntD/0ihCHMgTGKKEJUNDiF8dohuC0Ua0bJmslzRgQNITxidw8ghPKaUUmHEE5EiDgApZ4xB8QUaLa/EE2QABCFvIgiWbMwx/toAf7drQj2FGlHP160zho95UigQZ3uuOXVeThDodBjB7gWAYwjEeJSUxCLlXiBF78aKU/ZuJ7mmGMY/+ql0humGx7iumeOL6Hxpa5iXyYuZ07/EGPGsljHWWchzUo8Qc4cJAGeLgf0exgB9jYhoRx6AQxmhFAbkmKgKwIhnJKwgpdEicUTuia175DQQruID8/yA7axGMDG4DtDXBwpgjh8IY3GC2FfcADHtIAH1Pir4Uj/JUhEtEIvh3PE6eoBYMeYg1k8ZBAE7HGL2CxilcwqBnRUkUoOBGKQljCEoowhCH0xwfY+MGKWeiDH0rRjXnEA47su4pD+2WYiGrlZT3iimc+Yz6xwM4q5Yhjw87hDnasAxzYWIYvQNExLXWCE1LCC5ZgyolCCgZM1EskI63HvZVJz00UHZ/BIEn/DoPV6B720FEZ4zEPX/gBEFCQgXimSU09pLIOeqgq/hBiCBs2QxfbspzlqBaKXFaKOKyYwxy2sIVRuUqY3OHO11ilTGXyYAtwqAMciHabaLrBDdLkK1+7oAQl9KALdRBoHuQwKLwB4p+KaEQjBhVZRDCiEpoYhS6EYcNjTUQb3MgGN9ypzm0Y6BksiUUrRPGJSvyThAItmh9k4AP34MEPxVioOsrRDoc6NEhdyUq/OqmyNRnmTW003+3EqI54sMMzv0MHPfzBs248wxaesO4npISl7LYUS+Qo5GDElJhF4hQyO9VMONrkUzTmrkiQvB2eZoSjeMRjG5gwZRaEloI1/zgTr1a1w1X1sAejpTIPqfBhM25puUVAYmplRY5xeMGLROihDVrIYHWuUx7v1IcHF0SbXG3AAyjs9w1EgwNgu5AFFa/4B0q4wQ2kIIVmVlU2BzXlCfFGCAmuYQpVQEIOngCfF2ICccNoBjWocY1rYEMbOIzIROqpC1SIYkSNAOgf8KcH2tIPCAlBAya0sdAw6tYqpvktGYXLpnIUlzPHvaRV4iGPd4glHWLhxz/6oad5OCsVUdpuPrEbCuxi17vnrSkiG9mYnDqGMIJJr/jWC1ShCnVh6ovvOubbDWD4oQ9uyMIOWLOGNUjTfnUIw39TmAdTm8END/Lhpi63CKpNqv+AxmkFL1oBCC1sQVTfsY6rvPNWD4MHxCxgQQehAIUsdCHFFdTOd27AKmKqJw0q3kIapCme/bgVUDLYgQzQEFsf0C8LWmCDHw6BCVDUghg2rIhokYWsihCjF7AQBSeAMmGr1mEObLhmCj4AboEAIRfbmG88qqIjrlC0e21Ss8rMYdyDtVks7HjKPvKRDnSQYx3+wHM/+oGaedRzFaIQxT0tpRxVmFwU3v0eeBtzskQiOkxfQu9wzbHmnvbIvd4F0jig+w5Mg6O+QEgDHAD1gRR0wQtvcIMp65BKOFzTfnYwgxmkQAl319MSkHBEg2ttywjfshBlqMMTzJaCDAPbO8T/fHZ4viNXY7MgBWRLFQdnQIMU0IB+55HBCp46nh0MvpjLhgPf6ScDgMugAwBnkQ+A4AMa/EAKa4jDHv5giON9YhSruMUviLG4Jje5tMLQxSo+MaJdEY3f/VYDHjoQcCAURAaSoAY3EO7RqaxjpJ10WZrHYbLhSpQqzGUvZy5DjtyV5R3nyIc9Ki0Pj4Mc5P/Y0zZ00Ztaq0KXqmiFcjQzDnJQ5mTl94b5D0kybwjGkOX4xjhwi9v3v38cEvUu8a1SD+juwxzx6MYxgEAN0oDZ3kDUvOAAnWm/skwPnCkMwkAK0gARFMdAtmGAhqNqjIM5oCEYeAkSmEAJfoDv1K4I/+rDCbrjVXIgBXFgBZWJBeeu2DRI8WSABTRoRVJgPHBQ8MjmCaDgU+ynDdQgCLVAAN3jPdQDDuzAtTBPbyahYz6BFGChFzSFWpjlGE4PFDrhYhKBKPBnDtrgC78wCNEAC4AgFbbhGzrOH9RQYToJt3KHTMqkHNjk/SRKZVxO+c4hK7xrHSrtd9LiH/hhH5giRvyB+vJsHrohGbJQEzLBEhzBEojjakoi/OYweyzxZNKvvAxDesrkG8rkEy2xTKji/nCrKuoBH9LiHbhhG0DBCbaA2abgAA8wFr0ADvarDuxHmhzQ6X4gC/ygFqolIjjQUiZlOJKBFErCUjzQC2pg7/9SIAdI0AmIqQduIAVVcAWxERuViQVywAXp7jzAMRwTLwdzsAaqIwiFUAvuAwvug9u0oweUQAq4Qz3YAxEaYRIqqxNAYRVwAfSS4RiI4fREoRMq4XNmwwvBMCFBJa3U0Q+UgRvIwePWEB0MAxzUwSvgELccrnsM43aKRGFUZmHMQi2iSw3/4ST/IbrcxxpAQRIuYRIcMYksgVJ0iRV4qk0ukTJI5pFEJhQ/sRM/cRTJgUwkqh2Y4s7MgRuYwQ98AAqYTQpocQqk0gvWoAtILA3+6q9oIJs0gVoKhxWE43LEchNKohIijBiZwAt6gAb07gaKYO2osQiKwBqzURvlCgf/tvEbw3EvwTHx/NLvZuA7iok7TLBsBm/w+I4tEY9s1MCb7DESKMEJOw8WKHMVSCH1JkER/sB+1iCtPLMzO1MLRPMJsOADPOEauEH6mALNRHEdfjIOOVJl1uEO71AzvMtg0qG58qX53KEt0OId5IHoeiESYDImxWURvGXBGOwyKBEns2dNHCkT04+mxOESX9MTg9IchlI2jdIf+MEeECMVZMAVu2ALYmwKYgwqp4DZ1qAIs5KvUkDFEoEXqqUlNmEsL2cTkkEVMiEYYiGfdOkOdGAtz6MHBlRVeEAu57Ib8RIvQUzujI0v95LuxhEH/RIHD9PtNPQwZ+CpFJN+aqA7/7SgDUYo8xABMiNTLlZqLl5SM9+gDbZANLWgVJ5gNEvQVFgDGLphHQbxqKhCFF8zNnmSNr/Hu3JHTrKBK77BHMbhHM7CZhBDG4rhEh7hESbHW74lJioHEsjH0ZjU4aBzTEhmMDTjEs0UO92QIuEwR0wyKZ3BDz5g17YACqBSCgRLPZmtC4pwALvADZhNBVSAsDiBOcByEyyHwS4nFJJBOHTploCjEIxAClagQKnxxXBAO6yRQVvwQYtt7iI0HOeOHEW1HDGIVTqULTuUfmjAO9QjqkqUsRRBeYAiY7AsDX5gRmn0VOqDgpzgAxyAEqwBdZhivshIHcABDV8TNmNTD/9vs0iMdI0+IxvCQR6CUx3erx/Qoh2arBkuwQyE4FtRAAWCQFwrJ4ksB3eYE43ANEzVb/1sc7zM1Fp/shyKxDBEUfpk5Bu6wRZYY9eg4AnU807R8xWZzdoIltk8wANWQAceIRR4YRNkTSwvxxJ4wQI3gRWSIVNiQRG8QAlWYAU8gC0/NtrIpgVZ0AZYgFNNFmU/1VM9dVRhFmbBQzzqjgY61O9oIESvzT0aUwBTLQ/6AMsqLFVo4AmuY1ffce00rAMc4ANkoRvi4RSVNfi4IVmVlSPF7w6dlb3Y6LOioRq6IWy5Qf+yYbSEQRMagAMeIATCVUuxNFzExREqaTMsgzn/pYemYM4xRIYc4NUngxQj3U8d2NQfVDEaJKFpebBU4tFOF1cK0qo8VywLPLMLOsADVGAFzAASLSEQwtLrGKwlGOxiWaEVMrYSlMAFSkAFMkBkXcAFViDubCAbTbYul2lmY/Z2cbdDRXXvEs/vFC9nXeUH3GAGUqUX00oP3qDaCM8cscNoERRBGYABHMAPmGEe6sEf1gS3mNRkrBa3hNQ2t7McnlVO0CEbbIFvTAEYmEEbFGobhsEPGuAmHgAENkRD3jY5xQUzcnMz5tY28VYc0EQxGu1M0XReMfJ6vGFw14EbhsFXO6AHeBAKBGuCY0wJenBOV6w80yoLKldhmYCf/+5zai7HEYjDEWRNgVQhFlRBE5RAB0rAAzLgY1egBVx3mWIXB+gShzPVGjEoMHP3hwMzg8jRL/0S8RQzZ3sgBVSALb1NO5J3C/QjZ2vgXynoecvGAbDYAUxhG7goey8yI61WSI30/qgCXcmnHJiBEoCAoNBAEjxhGJhFERbAJsyFfoPgULvlfr2lSytDZOzW0GxOb8/rTK0VOycq57wBHMqo43hmHkpB8TzgX3swPRlXsJIt2SiIO+6DeL1DCR7BEgaBgMKKLHkhExjsUr7vnrzgBSyAAhhAiVXABExgBZYJG6ERCXA5lxVULl/FVGdWiC30qYS4VImZVXLWZlf1xf8oKJjisQuaSZpGqGjyAJuqTXIvuVSuAwog+FWyQ+mcgA0kIczwYSrkAR/u4YvqT0i/V3o2URzWgh/QgR14xhgEAhD0wA0OhY8swQgCYSZogiboNz8lVmK79G4L+o9pSpDLlIAL+BNzrnt4dCUlQeky4JLp9E4n2IIvGB7j8drUoA1+AAtesQ4eoRIegXMl5QIPiFEjTFNwrRBMoAQaoAFSwANSd5Y3CId3GQmSgKdxuQh+2tneDoM4FAeLGW16WTBVRTCpkYKi7TqaWU/dw36ouZp/gEaF6V9L5R15IOB2gAv8YBasl30Yqh2CRDvVOTbRgZ1F5s7+QRDl4RtYsUT/3sDqzkBczAAGmmBc/nl+OyQmDnVqwrJuIWYz+lh6EPpLBLgnGTp7gjK4uqeRcwEIdiAFKlqSMzqje5DZmnkNjCZog/ZXGGESoOcMilE4WAI4gIMluso/K8EIVIACFCBhU3cFbuBSbxkJ5BIJoiAJfDuXdbsH3Ko+3up5hS1Dg/iomRquENTtmho7XuwGhPuqL3lnrwmbVoytKEgKoJqCWMQGzk0SlmEeFllwmw8emnXjZkpr17qwvcsczgEQU1Jf5wEZJCESFAEJzaAJrkAIYgADwhWgO2TA7ThD8nNqDvocDvtu75YwBHgw3K+xuVdwIyoO1cF9im4HXEOrJZiC/9OTPeHA7IgGb8Dpnx6TjzJhEGYyrFgitVSBFEABFEiXGFrBEgpBdSkAUEdWB5TgCYD6t3m6t317yJNAgu6jBLmtO4q3O4hJ2JS7VL+mbJJWmKQ7O666VJJtZ9MAm8YwCyZYmMAcBBVvBrBAIBIKMdDQK9AhHzxSvdMbN3OTvTrjD+WhbKmhFDhthfhAEALhCsI1BPyZwP96Q9x2LMnnZV6mzS7jsAM55iR8wuNwO8tkHubhGPzACQDOAbCARjN6KqnyFkf8V2YlEjxnjyqLEx5BlAWbFWJBhTWBFMZOOThBEbJABTzgBnQg15EgxrYAuIdcyH+9yE0FybvDrZbc7f/yY6mV+jsyFLkP04IID8ylnZufYHGXTaqr2SmfspLDvAcSzwfUQCCOQWzfYRzYAR6gr82LZEjKIqOGhE7ywR/8Dxkwwehi7A4GQVwCAQUEfcAJ/d/rd3IOXZIoiWvTocGlxzEefcIx8aGNFRFBgQ1yIAWYFgsw+06hEgEBjD08hziJswk7Ji+QaKAJqCR44bTuiRWUIxQU4Q1uYAW8oAqk8nG7oKdxOQmiIOeJXOeJ2x2Nm8OKqcO4WtmbnfCK3oLIRpgGi6Ohmjt4cILztAjnVNu3vYK7O8NS4Nt8YAyBQF664RvUB7p+Z+zJXix+pyzI/neYhE744R2y4c4DTgr/zCAMzOAOwmXf+73AAf7fvcUrwsfh4FtmPsNuw2Gm0GThuddk1mwoH34ZDIENkGAFsFgLLvk8vUAKZLGqesVEDOHE9wgfQ76lNMESkPNyAgESdum0a1Jr+kAKdCCVyuALYpTZeHrne/v2o4AKoqAEed8ETXC47cPnudruVsXoi/74ycaYsGPpOToee7ELKrlg8zQL7JSS0zMem1+wboBFZAAIQno/ZEEb1OEy6OGcfydf0N8eQiPtRWPs20I00mIcwIEaMKE1XOAI8P8M7n4m8j5cxXXvASKIwEDoCp4zdxDdOHHjxpkzxw7duYnnxFkUR+4iOXLlvHn8Vu6bN5Dc/0aGDKnuG8iH5VLOk4VmDg4NHRxogQJli5QpU7z0tFNHjx4+hBIZQtQo0qSlkypVysSJkyhRmjJBgiQwSCBImzZx3ZRpEytVwVRF6sNHyh2ga7RgkSIFSZIoSepGoRIl7128SJ5geaIl8BMng3v8cIIY8Y8ePHj8aFwjcg3IkXfUsDzjsubGlnc07qFESY/RokkrgQsaihIkOpBI+ZElduzRW7rohCIFN5QeT6T0fsIjRQofMmQ4Ge6H2beG4tixc+cOHjx70qPDy3c9Xz5+2qVr186Pn71syCR9yOACxpEmVwIFEvIAxIP4IOqDQBEEf9b9+8NNTHcOgOmIQ9FDG/9VZNFEF1kUTjgXNehNOBFOKE45FVZYDj3yyENPO+3IA442ksjBhxdSOJFFF1PsxBMYLpZRR4xEJQJIIoooolRTlVxyiSacfKJKLKqE5VUgi0ASSiibWLJJkqq0kkwwn0SSyB928MGHHWtssUVOddmlFxVijilmElpEoQUVW6CJhBNtvulmD0XI2UMONuCAZw45FFGEnjXgUAMLMwhqQw2FFgpoDjzsGZoSNzQKqRI4PQEFpU9koUYaaGSBRhpabOFEpVA40QNhTxTGWGOwZbEqpzLI0k074f3jz3f57HNrPvbsmus/vtqqKz2++hOPLUDIUMJ6VyzrHgrxzWefffn/8UdtIOlciy1FCmJUDjnabksgggo6yGCDC2pEDj70rNuOOuDMA4wfefARhhSsdgEXi2CUse8cdWBZVI035uhUj1F9IkorZQEZilVdObJIJqE8GUwzxJBSiSJVDmXHG7Z1+YReIuNF8l5UzJWXmHR9+SUSLvNZBBJ94pADnnnWbLMNOrPAM88622xzDjooocMNRuswdGi+nRpY02pogUbUm/7w6RZanIp1YqMZBtthsqHhgx/OgDNrrbfug/Y+/6Tta9v+/GOrhv74gw83nnyQAgVXNMHeGe/JNx990UpLbVYEoeOOQeRIhCCBixdk0LffarRgRucuvo89/tCzzjfc/2iDiR9o2WHvDyry1NO+/cpIlMA4LlVJUwZ/grAuyRATDC+qRMVJJp/EwkswyUQpSuyR/KHHG1l2wbxtIYu8F/R6ySVyEnKx7PLLfL68J8406wk0njv7fKf4khmNPvpJK4EYYE27hYVsrFLdNNZZJ+bED61mkYamH8gACnAI61fgCY8BDxgef9QDH+G5x7roMbd6zAMUPsiAAoagrEBcAQWAE9zg6lO4/SDOHe+ADnRKCDnIWQceiUthCyWCkYJsZCPomOEMC7IPf9zjHZ7rRjH84AdA6MEOtumBF3yCuiqAQYljYB0hamSj18XOKT76kShGgQti3A53XExGM4bHC/9SdOISS0lEHuDgBjvAoXlbggL0xiS9vKCMZdiT2fZgxic95TFo3cOZzmzQs/LRDAc3qEH6Dom01ZTKfU3DQvyiJhv7SXKST1gVl/qXhg98wA/GmAc+3oar7SDwgNpx4Cf5UY8Hzm0eP/yAAy5IBCI04T0hCJwHPxjCrLDjHRraEIfWJR1sRWdX1YEO4lgYncSZsIXLXKZ0wmOPc3CDG9vwBBD/AAc4TIonUmhUEmH0r9YlIoo5gt3srpiwYGhxeOwURi2oEgmnTEIRfFhDF3rgMS5x6Wooi6NeviRHl7Use3bcU5/05L2c3cyPPSPfzfKIUD3daU8CTcJoGBkYNaj/QWpSY9r73ifJ2DCvf5nSpAw80Y144ANu3+EOsLSzK3vcwx/hSSU97PEPfMwjFcfKQAKYQAQYxEAIzgrcB6OVy6zw0pfy8NA7eCmdqEqHOlIdJq90NZ2orlCqUw1PPqSZDWX4gQ1/yMMa2tClFUWKJ0mYAhicCAjXRUIpStlRFT/RCdqJQhWvgAUsVjEKT2DiEpEwRCIioQjk6aEHNKgBXHBSKcTQkY7a257MEIrHg+IMfDn7mfjKN76G+ix8mo2oHmN2vfZVTaMahaRsrPbRJ+zzaljj0kjTsNEOaBIIxZhHPVgKLKreNKb2sNU98KEPfaCyG6XwQQcUcAAjHGFv/zGoJbQGFwSkJjUIMr3HPXa1rl9KVVfEjel0eGXA7xBzvcQ8b3j0Ic1r8FQOe5BDG9SwhbbCJTRy4YlclMg6PvwBigN7nex6dIlMKEUTDNYEgudJCDtciQ/MU8IKaHCDrVVSfz/IbGY5GzTxibizgPyjif/42dCKlgWeBRr6IprZ7CXGfRp1ZGz0FxvY1k+2Om5aGmpjG9yiwQEOKA4mtjEPf+zKu94NrzziAeUN0QM718EHcvXhj3lYoxM1aMABDuACI5xhg7bEpXaTOtO3+WMf3rXHA71zq6u6tLjkfSl5i0vnO4sSHuPIhjQkAYQ86CEPbLgaEqqw39VcL2ZJUP8ijPQQlAHHdZwDHueNBpYILCViEnOdp8ayZAcvhGY0haxBCkbDA649xrTg22P4BvlZEov2xORbMYtNfOvOEvIGOsDjRFFbl60RJqNe46in3mc1HiN7C/3rwo+3kCkFOKADMmCDLzy5rnpoux5P5vY85gHleMijuNPJNj10+os0rEACBygADIRaXaMiFQTZJVxS+fGrf+D7H0y+B65m1baApy1zaPtHedmr3l3NCh/xAAYQgPAHPuhBDmzYQhWq4F879sl6bUVd8z7eBXs6W9BCycMb8hCcGnhBwkIZIqThYKJ8dbObo96a/mBmJxzEDI8RBZqJOQtI8gWdxSzAQdD/VfxHFqd4obzutUD12N+Lm4pUTsCCFtSAhf1lQZJN07E+9elsLmUKNnDQgyEwcQ1Pzm3tVrbytt+ODwl+e+7dSEUeqvCCFZhgCEQgqnVvCUJ6bzcr9BBPePpRtrXre99tY5uvHD9KaCb8VgmsRzc8AYQdSHziFb84xq2ncZkR1GVKyAJkbXvJNJz8DW/AQx5+IIMbTCEMYcCShOvQRpnTHDSl4c0PnoAEg9JM46wOH4pTLHTPtlh8RD9xiYGG0BdbNnt14Yn9CONIt3Dqax79qPdvItIfayENrIrNHwxhi7mrf/3z6MbnrkENajADGcYYBjB8IYtZYOINOuCABkbA/x5EVWa4NHj7gQ/rcA5epVxslmaL13hosysDZw8FZ2d3FlOUl1PzIFY+kAKQNgd5gFY88Xmilz1FkDRIsz6S8nXOpnqslweulwY/oANSwARMQHthYAeQpgZdoAQrkmhbo2GnQoICVVoJ9WqCtHSwVjPLF1q0xmIGhUfSh1rU9yWD0T5+gRhYEDU4dmyB8XU75j5QIBuYlAY8QANdoAd/4AeSIAu2YAuyYAqlAAqeIFiYIAl3CER+8HB7+HAy8HBZIAUtsAEjUAJEcARC0EFHVYD8EQ3g4A3iIEr8gDba5m/6cDYQeHDElTlUdV53NlW7QivtJwvHkgJ1AAdt0AZrgP9xU/B5MENQkXIaM/d1a7AGrOeCyZMHaYAvRjAEQ/ACLwADSuAFcGBPO5Evo3YqvIE1UMBxoJcEPFd838NHrGZaN2N0o3ViRnd0FHVZ0ldZU9gmVHcqVld1NwYbaYBR3+dRtsWC/VMDpqMHeKCGxyIDPkAcxYGPxWGPPmAZN2CPNEADxfEDbsAHZgADJlACIyBUReVBHCR4i5gVmDAN2cAN6GBAk0gP/oZnmUhc68KRbZaJGagNlOADmoSKtLiKFzcFGscnRJOCkiIqqEeLxNg/b5BNcPAGR8QEvTgE7zY0+cJNUtAlOMElkKUbBHVa39hzPfc91LhZp7WEE8V8Ujn/dN1jdJFxA00JPtzYF/hTdU8DNZsSG2jASF6nT13XPJjkBm5whv3jen+ABh/QAboll7olHHepSR9AAxdWHABJAyqATzqwAi7gAnwXbw0JkYXzAaWADdxQDu4ATW4GTNQRU/32XTHlkZiZmRyJUzr1Q86VAfdVGymJcQTVkokEKaeSEyFHi625Bi0IBx3jBmFgIkxgBDVoBEqzE0gklF+nTzgBFxyHBHjCaKBnRwUFhTWDWQgljTSTRzinjXdSYhF1dJ+FPtNInNmDKozxA1YXP9sXNV03W775Kc2TeszTAzsQNXiQBVtQB67EAETGAPNJZPXpABnQARmAn/mZARRA/wElgDQroAIlsHdHwJD2gQIJmpj88QFAAAzXEA/soG/U0VQl9Ing9UDDJZk39VQd+kAbmqEKdHnE0QEMoFGj2ZufZ5xIAIunQSm1sS83eZM2mU0dI2HNExoomEhd4HlT8HWxAZw0FwVyEXxFUEcEZT3T1ycetqQH9ZwQhQOBFEg5M1raiD4/Az46w41PwBioxgNVlz/ygwbiCVuzJZ62ATX94wZZMBxA4AM/0E0l+mUHYAB1+mUKgKfQdQAKEJ/ymQAJoJAuUAIaYAEcQAIoYF0ImqD6saAC4Up+gAzcIA9e5WZPtULr0qFPlaH0wEucCg/08KmfelP04By79FQ6Rf8NejiXDnCiPCoFdbGKA5UEq6EEs1oXlBJyLrIG2TSTpiijQuEGtqEEhtR0p4EvUrCKRWmUMhcFTlAEzuoESRCtwOcm1ZoET/CsfYEEclKtbyJQ2pMDNSCtB6WNKcAzwkF0s4YnLGBIgVJ0RXCN79oXWsAYhOGVrdIplPIpn3IqPeaFs9Upa+kYPuCmNKADLuBlBVAAAzAACuuwD1sAdSqxBqCwFVACJVABFTACMYCo11UfCtqo+8EADQoK3VAP+3BAAbd4o7R2Lfs2+AazKksrc6NT82ALQJQHwHGKtLhErDgFKzN6ljVHJiMmX0AFX/AFZTAGcOAvcGByNhmsRbP/AsUqBfhiIi3aKMzjBvljGKqFhaSyGKlmeovxe6n2e2frBFrABViAPzmwA2CKGDYwAzaQApORGXcZGSkgAzMwAz2wtzUAkKUGHJCRGTwwGI/hGByGY/JjekJpG7nxdae3T2WZBe/jSLghGh6QAQ0wn3o6p3PKAAfQufPJABngASWwARhAAoEQA/KWFYwaskEQnzLgB7LgWwbUD7k7sy7Ldm3nu58EvHTTdm83d6ADRD/gKLpqcZ73TwBFR2GCtEhbtNH7BWNgvW1QB2f0BrRnIkUzg3DBPN2LmpFStcH6fVjnSOnrSKuiuI/RvlW3tl6ZGDuwA3I7tynQASkwAymQ/wF4c5f6mxmmBpCGRAOFSxmpVkmNkbj64xiMiy8fly+RmxP+SltgqBg14AEOMJ8N4GWfm6d7mqekm78bsAEiIAIkMIAPGbtZoQAeoFt+AAy+9bIGRLO/63Zvp23sp8Pf1g3doA2/AERDdAMscHFNgzor87wrA73Ue7TRa71PjL3aG5u0STRSEHPHKrW7ZjSnMQVa2wWsBcZg6X2y4UiJoT9Vx7ZZmMb4w7Z8qzP3O5f5e591yb93KQPCIQOAy7c0oMB93Mft6xmLGxtV2zwR/Jur6T5cR1tZY4Y/kAL0SbqRTJ8aHMn3ebojcMIX8AAIIDjTssJZ4QFUMJebhAxzl//D3/Yu4NDD7qcN2nAN1SANy7AM9GcMwAAMufCGcFgKdIgJvXyHkgBEhgAIcGBhOuCjTQMFPCFHK9q8KGO0ZEK91TsGc0DN2ct62XREMRdzUmA0K+DN3qwCKlADM9jFXeAGXRjGjaS+6BsYiAE/VucWaswF8Ys/9Cu3MmC/+Iu/+zmXCpC/eou/HkADwjEZk0EZk8Fh+dO++3OszJMvH6OsXMJIVpi2koQYgJsFNcCfJWqfRJYB9jmf+pk3JdACRxAIGCBv9IYf9xGy7hEEiYAHruQAHyAJvyALqSCHvGyHeKiHfZiXmtTRQS3UH4AGeqAiL6ADKuCjjkQps7rMSQz/UNFzF0g7Bk5svdSMk9f8BsG6zft1AwJ6sR4g1uKsA0D2ml34Phqlzo60BY7EBRXcY1gzz/OcxvS7A1iwA3eZA/srA/mpW/VZE3esv359lzSwAzLQWHb9pYkRPxzGuFuwlrFoyBNslFuQyBRthaVCKozFKluQ19Omj5ySB33wB3NFCZdgV5PgBRqgARfwAkRVVNGy0rC7iO7hHlnwAXzqAH/QoPV5AA7wZQYgyaDLAHmqp/Mpusatp557ADuQB0rAiybgAiuQBFDA1KpRq1DdvFP9zFb9xE88B1mdTc3T1d10AwPK2hrgASowtUpg1iTFWk4T3xmlBnPNBeTphU1j/99sS79OIAOHfZd8mwJ1WZ/0mQH82wE0QNh4XAN5bNf0exhoLD+K256RLXMQbZSQddkzttmIgWqskgZ5wAmt0AqxgAu8gOK/EAzCQAwtLgzCEAytUAkqwNomAAMkIARBAHgcRNuD5x5C4AiscB58KgOJwKeiW9yf+7kTy+RNzuTBTad22ljebAImoAI3cCpXyF/X009dPhdUUNVUbb1fECN1QM1n7qux6TFdsEZBKZgewNrrzd685t7OZouoqAb3FcZ7TotcclapuCVb0OdWU8bz+7YArb/Csb8fXRO6zad4Om0KPpd47OAPbtfqO+EUzmwTvIK2QZRFKRjXhypa0/8YWKAGP3AJKB4MK/7iL97ixNDqwcAJUqABEiABIyAEOV5vhPOxIFuA7uEIZAHcDsAHj8AABqAAyC6fpFvgkky6eKrkwe3kdirn4HwDNJDlv+dNcUQ9AAXm3v0FZ47mQpFNQ4STsQlzPiEFgqkBFaABV140jVIbLfgGqNgGeQCCGgWCes5agr4la0DNf27vgV7ohZ7X9Csc/quf8klkkM6nGx3HepvHgHsZYEo/gZHp7dnp5mmeq+npoS4Y9joapK4/apAHaPAJq87qre7qwvALwhALk2AEGcsBJyAEgSB40mLb+cHSBSgER+AIrdDiMwAFTvFcd6oAAz7g9SjY/4v/v3G80ULd7Pp54DhwgjqgjITBjDQHJk/d9U1MvVc9zdR81XqAk2u5ljSa1Svy1XDuATdgBGrFRraYBkKhWGmoB9QM6Gj1BCJHiyFHjCHXBW+gB/3jSGighXDrBDOwt/j7AZ/N6H16nwVeE5WfAodNA3jz3/njGfPDKT/2A1uQY6Lfnn//MThhT+zIPCAf6h7Oxo6hhVkACMDDC7rQC7ffC79wDLDeC7ygCTSwATXfAoepXe5xFY4QCPxxH/QWLQ8QAhhwBKrAC8JwDFGRCVtQE6ELXXdpj8cSkPjo9D9dl1Dv13OJnwfeGHyCaiOv9YnW9U89MtEs5tUr7v5Si7bo/wbXjJMqsu41MKAqABA6lEiZMqXLwTVp3rxJA+iPHogR50Rcs6aNnjpwKnaB8gSKHjhwuihMkwaLGjZOnGDBsgOLkx0yZqTokKFDB5oMHDA4kOGAApsHfmZwoEAGjw8peMiQucMpDzVopKJJg2bLlpJZsx7kenXLGq5ht2h5osWs2Scq1Trp8WMHDydZfqDpxEtXr7u9fvU6RkwY3koqKnAQQYIEAgIIQIAI0tjxIkiRIwdqvLhy5QcPjoTiJeyYtUqNEuVhmqGBAgUeVqxI4cPpax+xXcdkWpvGbaYpdMtIQUN3iho8egz/wePH8R5OPA6cogRJkiRRpE+XTmU6Ff8qX76MGbOd+xzw4eusWVi+5BqNa6ZIUaJj9Q0l8aVwLRkypJ42FdvMya9lzUQ9+JujDgIz6uKqkhhKI4+S0FADCzRYUkkNmHbQ7YMMbFIhAwYa4FCoAwo4rUMGiPKAN+NqoGGH4lhMIwutYEwDq5Jo9GqjsHI86KqzzkprLbZYhEuuHf54xa689iLGr15U0SODBSa4wDDEEHjAMSwXcSwQyCJrDAUsgwiBCM5+GYaaeRjhA4s3fpChAw9OuwMHD2hwSzY8ZXvtNR765KEGFVW8rbcVeuDhCUONU2u4Hp4YiL3noKPuOkqz424M8DDNlLsyyDPvPI26WC8+HW6AL77/sOqrww44wluDxycgamO//TAiEKI68mBwwTwgyqMNNh6Uw0GWHnRipg9uuilD1IRSQCgDDFCgwww9+O2DF2vYIQuW0MiCqqxkhPGNLWT8qiKwdMyRxx7J+nFRuIbMIrZLdMElyV+WFEYXTTyoIIIRQhAYASsfWOzgMBMOBJLGKLviCjJ56QUYZ7qZhw8+AAHEDRq64DCLQqy9wU4eTDXZ1NtSBjTllFe4rU/fXuYBiUSTe+KJHHIoIr74oPOZUuqis87SS4vuTjsw0FtIq4VEkoK9+ExVAootRmLaPgDxmzW/WvnzNSJfe9UVDzzyIFuOPshGow82IEQjJpoc4FAB/w+bLaCAAYQqYFoKHPAbpxQccEKNPrH4QUZwtUpDjTbyUEMLNSJHt6KqccxRi7HavXnzH42D67g0fgBCFFzu7UUvYYQJBpdINKhgARGECOGBgjMz+OCDwQwTBcqE8P2IRz7h5RdglrG4nkkU+YMHPX7IMItKYqahhh9u6EGH669Xoojh/Oyzhhv+VHkGGsg/9E8kishBOEZzvkEgKaCAwmdJo7AuaPur027/7PZHOiQ3uCFB5dHIetgjBfhVTUFZsQ8cHrIf/mzhCf8BWwUtqIc/9EGDedDgH8bWhwexAQ0zkIkDflIUn9zNAAMYgIii9ZOfdOAADlDKDBQVOaksSP9xWVGDrtrAuB9OTojq0tzN0IIWlfzAB0mci5siEYvS7eIXv0hdMFTBhzgdgAOyo53tMoM7MIIABboLwhhjEIhQhKIVwZiYMbYxj3nUQ01qypkNEjEJJ8jAQj1IX1ue8IM/tqUtK8EC5CL3hl5B5A+AiEQkJjGJNmgBCzPTgQ6KUIT0VVKTSOjIE6JAv+h8sn5Cqw52sPOF/nlnDGXIyBsEqBACrqEKVVgPR6BgtTws8A1wsEMv57CdORRBN1HAWB24Uwc+ROQhGOyD2fLwhz3IQQ548IMHywbCCLUNbiacoYfwVgAD3G1vISoAAxTggA4woAMz2IFKdqCFse1QK2X/09Wvtka5r7QhPUTEHFqMaESyJHGJP3CCcdzkg09AUS/5EgYvKnGD1yWgBSjwYkW/GEYxYkkIV8hEMJJBDOIZQxtwhCMjFEEFJNCBEZ+4xB52IAc2/IEQhEBEIx9ZiUtcQhOd4MQnPiEKUZBCFa0gaixiwQteBEOpwYhFInKABS4UQSBKgA6pKumcTkqHflqFzhSi4NUqRKEKVBgrGLizv6KVgVVwcAN54LDLkKwBDGBYD1jQoxA95DJBvGRVGQaUggEAAAADoAALqlAgY9aBmbKSChaAIIMPfMAHaPADB9FANjXsAA1OsEFOniWiA7QwnCEiJziBghoazoCdM/gB/w7JlpV6tiENjctrPX+Vhzm8qgvosaunFrIjr2ghC0/IAuaeMJYsOOE47RSSD5bygUTAAhe7kOIUdZGIFbxuATEQge1A8MWLYnQxYFoYJEIRDGIkQxnGWMZISVoPNvTBEJRIaCxIgYpVvAIWrTAqFHXxXwAjSRdIJXAvCFzgJSUjFEjobApycFWeRdg5z5lCpL5aEAzTUsNToCUYvEDXKpRBxHMVsYh76QU4eOENKvZCiz9c4rc2bZd2KA9c34qxMARWsDsugAZwwAc7ECLIHXQDa2Tghw/4DZ0fkIEPDMGgHzxkDkhAQg5u4oHPflNvLGxhAQ5ggC+X6CY0UM4T1P+gODxEjg1siANK5BCHOEhTmnFog4He4Ns3qCuAaehCFvz8Z0DL5TiDPk4WcLKDTwijGMUwRjGOUYtI6EACCYCAELp4O/GCNzMCm51mYgENa1iMG+AgNTe4kY1siAIVrTiwgV3939IBWNaz/u/pdmHgAvdiScGYBBJwoBupSniqBenqFH6GYQ5X4WkEQbaLp9DiEZdYxC6mdrVJHBICznitfO2lHfhwgB3vOAAJaEADwlDMKDTzDTwQJhsiawAHwNtvBuhAGv4gA+XYoQo5MHYKTANDBYwWb10GZ08OAKfejGUOW2iDgqo2Wzi/ec1siKacpVnnBtqnxjUOYAAB7Yb/gwQaCgQldBZUoJs//AIZykBGy13RhxVYYAIQ6K6VxAvGL4YABAJ7wAJSgAtraAMc9ShHO+KhDlOjOten28vpekHd/wpY1rGe9a1znS9ikCIJvtbNgyMM4Z4lgdihRPYsC/I0ZD+b2nMFg7Q9XG24sx09Adxl03oZkm7boRA3CEC4BZsAwDfAA1MwK+TSUIOkkDDe0fJbaAMQAHAyoAg2IBASblODN2VAAXtb4U+43MJp8SQDNHhCDbTAHydYRFeIDJDFJb6Hist5QN2OcYw37sqO99nPIA90FnQvF+CnwAM7AEIqumExOB6jETrgAAQyY/Obg5HTKBAjBCrwiWaE/7oe+FhHO9TxjVOj2ulOpyJ1zW9+vNBa/eh3NeqEUQkoKIE1KQi2sKdabOoYGzpmNyCyCbJ2EpM2uIs7tmMrN6gxXmqgbisEcOu7HSOABDiABJCAFZgCQNAVOHgCHnAKGTAhxvObAXg8EQyAAWCAFEiCzqoBmtANzQOREMmbn3iWDlGAFHgC0gOUHtiCrMklPZCD2IO9OIA9OYumicg7jauxLliIjltC3gu0kPOzw/EzD+gA4jMEaDg+i9kGVLgBCRCB2ok+MBojMUSBDOiEZ9CGbYiH7WuHdUA6VEO1W7iLXdCFW3O685vDOaQ69au1OiS/XhCGVcADOHAPFkgBKv87RJ85xEgpiPxLu1kyOynwgv77sLZjuwBsO2kbMUu8NtxjQgTkJS8IQREEAAEAvAVYAApUAjhAgx+ogyQgoQ78sg80AMEiLMd7PBaiQX9jAHMyJ2nhiRfyMtTIgJNTChkoJEBgHGWqLR98Mx+EPWiMxiLMu7W6O45jwgB6Qj/jCinovZtIASAAglI4PjjyhUhYAQxYAAIILzAcLxTwnRh4gUtoBm3Qhm+oB3rwh3Yoh/DLBmzAhl/Aw/H7L/Ojwzs8PzoEsDrsw/ETBkr4gS24gflLxEgRu62jsp8RJUd8RFqKxP4jPEycqyoIyUzUREsUsbfyxAO0MV5aAVEUQYL/gYBTHAEd8AI74BafMIAki5YPdIC+CwANwBuhCEHBgrxpOUpZLIppkZYDoBYV0JYfwIIU0AN4chxdwaBlgkZp0spohD2IeCtuM0LbU0KQO4glzJEs6MZAuwmZAAI/UAaLkQZJkAEPkADEeACdwx3qc0cxdMcYiAEYyIRm2IZuAAd1wAd/8Idy8IY39EdsIL+ma7o7zIuDPEhbGz+mgwU/UA4WKEQPACVQojKeCSXpKAiOPM1H5LBNZLuRrMTVFMlZorZQ4S1YQiTbsgMV4DIBCAACWAAISIAIkIARYIL52IIOKIC/YaEVUjIdA7zBejwvK4ARhLwDEDxepABfBIoM/8EJzJOJyHGcP8ig8AzP2upK8xRCOfhK9IADxMqIBiIPPMgKBJHPcvG93vMzv2kNNAACUCDMXNhMDUgAAljHvGQMMLEMMOnLMQoCIYCBS0gGwowjxPSHffCGfnRMYRiGKdrQpnu68atMOzw/zCS/TogNLJgB1vAAjATNrkpNrjJN1ETNSmzN1SyDWbJE1HQxVrErbLs9RLKDFRCnAijFU4QACbAA4jQVxEuBneQyeou3WmyAwVKALmMhCRQAABDBFqrOcjOnnzDB8mEKqOiVh9gDQ+iDRRpPDIqm89TKOAMbAmFPW7kVjMglsolPrbiKP7uK3wO0JaMsP/CDY9gGT//wAygwAwlIDBHYSywhoy+hvjESAiZ40G54o3q4VH/AB3y4UMesBU/9VFANVVgYVVIl1VmgBVRNVVoQhinKQ11oBT94GwhhCyootgzTP7HDMNIszdNMtg6DzbYLsSpAAh14timwUQ5jpTIIwAJpsfW0vRmhEViCAw8Ip7spxQQ4RcDzABVYARVgAcTrgBXCxcjyySxdgC7rvKCUzheQziwVQQHwsgXwAA2IkxP8gC14iD9IhH3VA+XpAzlIpLyCiIqLxiBEz2iyiDjl0fSYHMVBkPr8s5IbNCgcjuRyAiBAA0oAhRFagTPAgAgwgRgQgi/BqL38rsyIAEU4Bovphm//WId4iIdy+AYLTbrGNL9csAVcsIVa0NlcKJ3SCVVVHdpbuIVa2FDqugVe0IQKWQmV8CRcNU3ooDBdnZSRlFEwoNFLzNokUAK1g80SC0m2c9a4qk2vyIqFuAEKeJYQaYAFALwDWAAKWA0a6KwOfEkHSJbACoAFuBu66bEEECdUHMXpFIAtVVEWQAIqSIQ9mAR4cohEAAREMIQ9QNNlItiufLM9gKZoxI+FrYj3TJeHjVav0FNBKzm5UIK2+IGq8AE8kIMUUAEKKIERMAEYMIImuIIyYowgECMUCAFIRQErgYBEIAbkA4dvUAeYXYeabcw3vMzK3IXpKp2ird7qRVVb/8jeXNheM/mFXDDaWPgDG8gBtWCJHoiCJdi6YrvIXGXEr9Kwq+VItvOfS+xItfuwL2C7TMza+7WI/ACiSDIkxukVJPCCHFjbA5hdCqAADaAAD1GB8mHSFeIyEMzSARiCgSsAFtCAvg2REhjBopxOEtybz2QEQkAmJOgCPdgCjRmNRXIIfeXczIU9Gd6DCnJP9wyVh5MniNVT+Xna1QW+w2Hd0OEBG1gBE7AADDCBFbgBKTCDKxACMXzUMQLeIHgACLgDYdgGS/0G8PuGUssGTvXHDT0dXzhj6uoFXxi/7W1jNz5jX3DjYRgGYIjjXhAFGyiCJHgXLECCJUhf+olaZP/DDv6L0dbUjuxwzayNRGpL5GVtuzoQQBfz362ZlcgZYAzSGEZ4hElgBBuwlhRYARa4gRxgjZv4AAaIlgHQSSBwgJeEvLsZAAEAEQEIShF+PAHA0hFkIQ9gAT44YbEbA41ZJEUAhMiF4TSt4WhUZj3AGIxooDg9kJF4g9ciiR3yirLYAijIgqr5s5KAEQbRARPgABMwARd4SiVggiPwHQYVwxh4GJL9LiKIhewrzHpIXlPjBvCz2Tf8xzmmY2AIaA2t4zqG4zMOaIQWaEYzhpZbhmiQBmlYBmVIBkqgv/XRlpVIgj/+40BOu4IwJeywH5AeaVQ6pfwdyfWwSRfTDu7/ILE6wMQyoDaGA49KjpyL6ANjVgRFeKRL+KlKmAE+mIQ5YASUYoEtSAEZkEV4C1RXfrxwK4C3leUBIDdcxEXphOVbJkHCWoEkIBA+aANCAIRi1hhkRmYZhqbw7MoKCo+sEZCwwYPG8aF6oulZ4Q99yhUF4aCy0YPDU4ESMIEWcAEa+JMbMAIiaIJAiOLfWQTGXoRAeAHOOAb3uudyWExu8AbkdV5sqIZqWLSFNgbQbjllWAZmeIZnoAZqsAZruIZ65GLkIynYngdw2IZjYIMUaA/rUQlM8uM/jtrUHGSSHmlTKun+ydqOrDZVKkn+nWQIqmnaMmabqgRN+KmjigWi/6qETk4EQoiEQ/ABDzQAIJAEP+CynyxKUiQnDcDFEGyhELwb9X7lETSADJgCPthXnSZrGCbrmdpv/iaEtIY9siZPRQrwTB7m8TzwA78gZdKVDHqmPIhIF2gBGGhiHpgeHRgCIngYDT+DQRiEQmDsRxAFXSCGUIujcVgH5jU1MObnza4GLnZtLIzxGAcHkooHcIjZONo+Td1xTQWHawCFpNABI5iatFAf3t5on0E2r4XRsUol/0HkJ89f477fFjur71jWR6Yl5uYPm/4hDrJvnp5uUWA1YggGpCIFTaiER+DkuQTGD5AE8f6ACXZqpy7KBBBF6WRvrV5v+A5hESwAD/8w5kRIBJ1WhEE/dO0mhEM4hP5udER/dEhH9BZ+9JkiawzCGIwJTzT1g4rzbzzoARpYAR1wgfApGSEfAiYwAzOwgjMQBEEohEcgdE1YhVYQBnqch30QB3Igh5rVZzdEtRYnNWEHBywktZgV9sIc9nighwn1B37gh0zV1HoAB2dAshSoJCOwpEsqgj+msvT9quf4qiSvgi74gi2ggnOPcu948lUqAw6DO2MCpjmw0QCMaRGjlTWw6V/JZEVwpEnQhOlWhaRSKutG80qoBEZAhO5WsvCWBErABElo5ZfcTRDWaouHPFF8yXfd+OnMmxVIhEYK+UJXBEYo+ZJXeIU/BET/WPlFNymXVwREMPlDSISZJ4REMISbz3mcx3mbD2v/DmuzRmuLsyY96AKJvAE34YEHMwImaDEwCAMruINCqASfIgVciAVdsHVtiAd82PVdZ0xTi4dvAPYWj22zj20ab9k4cnZo94dwyAZwwAaS6gZgCMcZaA9NEohD3GgsWAItWIIn8Huz4BE14AKoQgMu4II4mDg2SHw2UCVLbLYWs4Ow9Z/v+CWzyq1ZSYgE4XdHwqmdGvPOCAZdUAVS+ARNmIREyKt76wC/kQRMiH3Z9wNxDUGKr3NxI8oW2mUSzGV4JcEAuH0SPAAP4IPonoRKcKRI2OlJcCRDJ/TnN4STT/hF/1d0hW90Q2B0mZopRt9vtN6DmYI9DULPZ4wmqciCG+A9LcAJbvXWFLABJJACPrgEgY8F0teFWCAGZWCGyy4HeZAHgCgn0Bs3b+uyVcOmsNq8ht3mddsmMaLEbRGvUctobdo8f/z40cNXDVkxY86WGRuGCYgMGUiU6DCiZOYTJEuWRMHCZedOnWh+osECVOjPOGyOsuFydAzTMWCegplSxQvVqmWulvmitemcMVvnrFnTZk2aNG/y5PmTSFGkSZc0afpECpYuXrpiqRL1iVMlRX/6NPLx4QMQT4YPrwSSwsGBAgMCQA4AYAAAAAEoBzDwePPlAQMEQBZQwHFo0AFMF//o0KgS60qT2k5i+1oR7dqJEiHKfWj3IUKHEPUmJFz47uHCgQ/f88f4n+aA/uyJ3md6nz9o+jzPE8nQjg4dUnigMaPGjDWPVPHiFQvXr/S/fjVjNg0ct3LfytErV59bQWwJEzqzDTPIGFNMMcAMU8wwvjCYSy6yQDiLg9l45E898RiTiy20DAOML6UAAcQMKSChg4k09ZAETlHwxJNPaqgB1E9EoWEUUkfF0ZRTUCVRRh1lVOUFVlltpaNWX4wRVlhl5aHHG3oAslZbl1zCiVyrtJIlKZ/slckjz/0BhBMy+FGKmaWAAgomfgAx2GIGkAbZY5BV5pmckdk5ZwGNRVb/QGQBjOaZAhmwwEglkaz1WiSL1taoIrrxtptuyBECXG7AFXcpIoQo51twgIAKiHJ/gPmHIc3pwUciovCyiiRs9jEJqJFwooouuMTSS124pKcLMchYow02BXlTTjvqcJMNNvQl5B8tyCjjCi20zCJtLbCsAsu1rpSSSiqv0JILhfzc0xAyvvyiizDC/IKJDDvUQKKJOsz0Qw823aRTizuhAWOMMAYF1I1I5dgUVGAkAcaPQQ555Bhd6ehVWG208cZZeaTRZHNSTgkXl5/oxQknmcT2XFJAYEILKJJQ4okra/rRUgcOzNwYZ54NsCdml3WG82WjoeannAkEKqcDTsjB/xZbizLKaG2aQq2pb41E3ZumvSlXnHPNOQfIqaTmkQgffAByiTDQNCNMLbgEY1ddwbxXiy6v6NJKLK3Ydcsx1EyDjTcExVMPN9Vkk803CPnXyyxpr/JKLdfebXfkpLyySiy8/FINO/zgM88256onTKvczTAiEqcjAQUUTzxxU7778vuTvzH+tFNSSt3Y1BdQVYFEFWWAUQUYVJUxxlVQ+fjjVT+CQTEccFhscVlm6UGqIhxPUslbnMCViSaHGrLHmD5g8osrQDjwgSSYUOIHm4M5ED8DHjDgGM45U1aZZT1DNhppAzSmAKAJoAB/pgAGHOADfmCaopgWCdpEohESnP8g1aiGCKoJx4KWyk2lckO13iyHEFwDU6gMUao/8OFJgMADKI5xjFz8YhjCIAYNRUcMtV2LF1lSRStWgQpcFGMZ0sBGNuoTj3gshD/+qYYu6gINXrwiFq9ohSpUQQpShGIvcBGZKEqxDHxYCCK2oMSpEKGIPpSuBisgEeqesDotuG4J+0IKFurYL3/1Cym2y11TgBe8KYBhSEJiyvGekrzkKc950HvD9KanBrToYQ1waFJ1bgOb7LkGOGyYgQ8kkQoQzSx+QPDDIdjUpsF0QAwpCOD97CSZzcwJgEU7QABFQzTT9I+WBjCAA9DAQAc6kIITvOAFMVgpCUYNmVcTjnP/DGFCE4LqmX94EtlEJQkGpaIZyrghDXX1C2H0QhjY4qEVW0G3XRRDGtfAxjraMQ7B+WdY3JhGNSYxiT9oIhiJyAIadiCeFZTAAxqowAEpoIEs+MEY37hH57gBDFt44gMd8IAMaFADGXQgA05wAhKK4NEkRCEKN2FRi5ASFKGwIQ42SulKB6aj4wkvkHVQXh0eBrEvLO9HM1XeHObwPOk1Mg1b2AKMeqCELKRBDW1oUpRog8lJHGKTQDiEmdDHAg94J33u+wMWZjAYNnwAgQo4AJxa6TPJ/Gw0gGrMAQQgSz9V5jK7NIAMHGCAA/gAEYtqYDCFWUEKSsqvwoRacQjh/7XnODNUzwGEk8bGiEb4AROy8IU1qGEMGtYwnOuCBSxEIYoq6rCJu0AGNa7BDXm040LciOdqq9EABjBAAYoghfwUcMAE4DYBB0iABFawBkMgIxv4wIfgqmGNZozCCSmIF3i8s9GOfrQKcYTdTvDIUhypdGBIgZjxgPe7p/yoClWoQ097Ssic7vRHPZ1pHqSXhS0INQtZUEMaemDfH2BBC0q9TaK0dwkyssQPpgAFEDwAgxfogJPOlcNRpuqHmcGWATMgxAc000oB6O9PAiAa0PZ0AAJkGH8OkMFcHeCDvQKzr4KN4F+HqcxhTgo5zYkONLlGqlTdhhG5MYQvnmGNbf88w4XJOAYNv/kLYsTiiqIgRTCCIYpVrGIXyrhGNtSBD3vQYx1LzEY3ptEADWQgAx3QRCtSMFENeMACFdgAByRgARiE4RGaQAY46OEPfKyjHNpQxjNi8UgtYEENMuDBEzbKUSQkIQn4WoK+uFDH6gIMdzeS9I3igKSHnTemQyreHGaKlZ0i8kd6mCkcZmoxtAC1LF0Igx34oJZEMFZVj3CLJjqhCUlg1A+ewEQKFIABDLhgBT1wwPzAnAIZtO8DxD6AAxBBCUkg4gMHcKVk4pphARCAAAMEGp7mSmLP8DKvlEjxogSrqRcXM2pVo5QIbRydd1cHEGMb2x7wMIpn+Nj/Gi48RjKI0e8b9jsWAucFMXiBiirCghjWaAgY/UGP1q4TGxpYgQf48AQZfCIWa5BBElawAheUAOQbMEEZHkEJZMwDHwzFBzn0vA1i/EEOatjBRnfAOtYlOtFxbHSLAIYGShNMpXGYHVPKa7w6GDK95O200pu+0+eVug7t1YMe0DI9N7yB1XYgFaypzgdF0NrWmog2yjDxgQaYYAQv8MANwDMFFQTUA1hwwgxC6YNnS+JVbHLAnEITGctYBjSiKYC2u83LD+CMl37QKzDZ4tdLWVCZ6lZ3pIIDnejMGPNdm/fY9JCIs2lTGcPgpr9pyIu2NZkX/cZFKz4Li2Nooxv1/8AHPegRj8FJYxrXwIES+DAFJDiBDqyiAwtwkIMpTEEHJVjBEggxiZOn/M73yIY3uqENVGCBDeLzARZo7gSc53xFJJ0jHrkghvNXeqX+YoqnsSLT9NqhvEoPdR3sMNM5oCX/bai61cuCdTvYAdVxXR1AScfYGiiQAiasTyfIQAbAwBAwwQrYgRSsQCGsgAnEnQekwGCoz67lnR+sDyWgz2YIQAmahv4AQAkOAAH8SQHs0mCAGy/p1bi1BTDBGKZA3l9N3qUUFm84U+bZmI09R6rwQauRTSf8AiiUQjL8AiqIQiwkQzBczt3gBRVV0V64xSfAwjA4AzjUQzvQQz2AA/82REM0TMMU2MEUJIFXiMEeDF8R7AEd8EEdrEAR8AEhVAImMEP04cM4UF83IIMkZB8eoIEPOEEdYQH4TUFIUUEjUtfAnJ8YkIHQCd2NyIEcsJ/yDInTyR+oKR0AUl0oVl3FRA8jlcUbBKCrNRXZgJ32dMIrggIu9MIt3IIpxIwdhIEXKAEh2IEO8IEHqIAKtEAJmIAHhFkKUAIo7JoCSoIHSgL6WNhnlCALVlsK/klnGICyxaAMGEINMo3jlZvk/UYyUd7VRMqOfU0QCuEfUN1MtRqoUMIHoAIxwIIhyAAfqEIoZMInVAn3XIIoaEKVaIJwcAIq1AJpgQM4tEM8MEv/7tlBIUzCHWZCX0RCLAQDJmUCJ1DJXoiCKyzccBVXNmhDKgCBHOCBE6gBFvQAFHRBFwxVFDTiF1DB+VEB7uzRUTAYG5DBTpIBHdDBJWYXG1ziJdoUdxVdeclfJ+rUTgEgKIqiHszBWIhFG8BBWEBPADrHWkhJ9rxFJ2ghL7DLuuzCKHDCH+jXH3SBF9iBB3hcC7jlC0gAVqVAZCkjJpSCYeQdy1CCDNiMZ5RgaaCVZeBM/GjGLjmAH/xBJBzKN7JYON5gcWQKYXUQD/IGphjHcAghqLBjp9kBHKSB12jCKFzOJNQARNbKI6BmbGQPokwCJ0wCI9gTKTRDMjiDNnwD/zjEwzdgwzRMQyj4ZhVlSXAmQzNkSXrgSnoEAzFsQ8o11DIswzE84x2pwQ+oTli0ZExGIvodBRdkV0vtpE/65FCK51AiJcSUJ1IuHdPllI80pRf0VBuUF8XIJ1WuQRfUJxxUD6isBSOAHVfWGijAAlgSA78lAzQkAypIAhoYgh5AASHMAAvoQAucwAm8gAVooHeQiV3mAppgggJigidIAht0QDSaoFpVY2fMzFzR1R8ggls4jYpR0DJVJqRAJmGNo2USB2Y2h2HBWh/sQSjuQJBGwiVUAl/wQSEUgiVkgiUgaSGAXSYQQiHwwSRAyVpUQiv8wjE4w7Csw+2RYXpcDv9yNlmTQQM0NFnBNRFYHoPs0Z7nKEMxrIIPoAVVQoESBEnwbAFSSCIZiEFK4cifHoUa9KRP7iQlatcY7FTEnOfSsd+n1UGQUMV8yudU9lRV2mdLPkl1GAIjbKUrdsIorALbzJAyKEMzPEMzHAMsdEIj7F8KpAAOwAARxMALxB0LKIGrykAkkMIquEKaHEbesUQHKIBnCNBfVmOd2FVhMgAa/EEjuAV/rYXjvZgFjaOkLJOn3OjVVI2nXKZhaWbX/ECQOsEeEIIZLEIhmMEgnAETDMIgMEEhZEIhPAIfPALJ1MEfKEIWcUIs/Eo0DEs8yMPgjGl6EOyYBkOZsgss4IL/LgSDMKzp7HXONijDL+ylFqyBFtjnGiAfVozBwMTBJAZlpbEUePJkyPrpJYZFknzBGqzsGMAnUkJlG7is8RiPegKPj4yi84RFp3VaVYbFUG1BHkRHpfAnbHTlJ6BCK6jLMZTqqeJbMzQDL2DCHsjADMiADjTBFQxBCQQUDtyBDiDB8UUBIXSCt5SCLOya+6CBDOxBB9iPNOLJKyVeNjYrJbjGAy1N02hQ1BBHbxyCIRwCIGAr1ESeZBaHIRAC4hICrHmNCanFDlRtCkTBJFjCHZzBEAyCIDCBGVjBIJxHLMjrIzDpE8jbyEwCqwwDM2gDN3xDPKwDNwRnFckuKVSR/y7AgjCkTSkcXJbsAjXEAxjVQzc4gyms7cfSQVfIJCPKZCNSQVL8HFDwhE7upBzw5PlV7572aZ9OIhuoAfd6b/d2r1AKpRzEgRzsAfm2QRzMwY9G5VdUTJPkwSTJ7xu4Qf26wRpAQRJQQRvc6+ImAiPMmn965VwsbTIYcKlCLdTiQidQQndkgARUgARwQANQwBqZmQ4YYwqggV2mggfGjA/4wQcoQKD0XSuVmAMAgTMxHl8xzeOl29U4Uwzv2LntrabE8A3XWKiMkFoIrh48wsicgSAIsSMIwiIswiPAK2paQiWgJhJ7SSZkCSwUgzNwwzzUw+x9zF5YCZdYiSikCf8tHMMvjEIniAIq2MI1gINH1MM8LAOuzcDHVm8j0iTz1iT3zs4eReJOYm9P8qQe7ykZBOrswIj3iu8l4iSDXeL5DuWg+tTFLBLU0a/9ukEVUMEXdNq8EQIjAPCsaU+tIS1dzNCAMi2pQq0y9FsnYEFGodkGxCULuCoOGIEKsIB3pAAbtAwzug/6IBArgVsMxk/8gLAKXxK5sZhgSR467mCMWisi4HAMK9YJoYq8JcIkoGYmDLElOILn2lNrLulEVgJEWsIkkIIXH6Q1VPHssQaRdjJcvOKnKqEsDEMY10IqnHE7/MM/rPEwsEQK+HEkUgGfyrEY1LG/aNdRWO8fkyz/Hehx9QZy+GoXIuckjpivIl8ieDYyJGNdKWJd/T7Fw6TX2PzvYwXwW4DMKqyNLDrsMUCLMhxDMRAZLmgCGnyHB3iADiDfCnjBDdhADrAAFTiBd0QWJQi1CDIGbB0AAqnoXaXPB8gAYfiBIVwQbKAYjJrbDiazbiTupTSzM3/rxjhHEY5N5p7BIlgCK1jCIIiMa3ICK4SCKnwCyeSj6FpJLQyDMizn7G3JFZFClgjcwoZTODFIMfDZMwTXOfDDP3hOKXzADHiAQucxn/JpdtYkF/iLSgFldv1xZPMxH1svoQaqJRry+I7naFO0RUMPJL8BHGR09HA0GFxaUdbB2Czu/2M5ayeDzCmAai30wpHtmwu5NDEscCNA7hqwmgtYoB48QRckgh24aiR0giFwwfpwwS8T28yMVYlxYIgoqF7aEzEb83cf8wtXzd9q9VZD07dqJqjM26w1wRk4whlg8yKwQhVxgpJmwibUayYsKWp28SoAwzKw6emtSygnwwzxGw0lAzIAQ0oUwzNcgzfAQz4gtjPgmpk5tiQSanYKtBgYRfda9mWTr0pFtvXyJB2QuGfbyGirOFpEB1BqX4ib9sW0l9UBlfQET0yBAabNFCbDmmx05St6Qm7rwjcliDEYQ0sTGTHogihEghPwgRcUwg34nhc8QhF0wAf84x4Mhld9wP8GegeE7fJSEwYQoAEQIAJcUAkLtzB4GzPh1vDkmTdUJwKppPdfzHlz1AGSPoIgHIEVEMEQCMIdmEEheMEUGMHmIik1IzFqTukn0IIxaIMVhzINJbm/GTDTqvQxIAgxGMMyeEM6cM482AIaOIGyEeqg+iT2bnh3UiKDUWIcbLiGS+KekuwkDmX+ocUl5vqtv1uIn6+I+6Sp5d9Z6IFZmKLFrIEfQcXDIAl68sH+AYKPUwlJl7HChhOlGwMyHEMC/8Jzb8EkSIEU2AESTEIRuGoldEKpQ1gDbKAMjEkoMdtSy8AohYgkcAmae/d3F9NgWbWLwRhU4/ClzPm3JhasseP/E/SADhTCHQzBCYzAEWyCFZSACnytETRBE1gCk8rrQzqCGcjZPC7DNcwDZg0Zn0ELMqA8tGz7viWDMjCDN+RDPtSDNmBC6cxMi49nJRKMipPvZdtIHkeiiQ/qd/7kUL4bzpM2zn94RftkzwIg1EGdkkgSHBzMp0mFVjTiwzjBFsyBWsiGj8fFkunCtfMbykPtMxhoL3QCIjxBEdjBEjCCd8xAQLbEB2RAA7C7DGhw98FP+oTIKJWSH1wCl3QC93Q3BElrm8doeLu5VQd8bhg8qTSH4+pwG2wBH2zCIAzBC2zA5sOAl9wBEzxgez8ClXuBDtyBJSxCEzzCJ/QCMsSe/wEPJzEogzWUKktrO4EO52wqgzOoQzt0DjL4QVfFz9GL569fV0qRtvmGuNABPYZjuEIP6vErMkWH+ES3uGUfvfRzZtRbpaXa5/OI1+98WhJMQSOGlCXzgBNYLJQYgl90Y9h9gt3UhYEj8Nk/AxPGgibIgA1Q2AcAxA5Ok2Sk6NAhAwUpWzrM+IFmhowPH/xU9CNJEiJKnT596qTpUqVJkRQpinSyUUqVK1ciQpTSpUqXMxvNdHnokCGdiHT29Pmnzx9AQnsmGiqUj50pLgY5MuHiCJNBm4zAGHLlChFHZvg8SsRnEoxBmTjhEvZMWzJia4Wt7fXr11tdvHgJq1WL2P8wWcCylZs3z5QkQ3PizNhz+HCcOHLYNFb8+LEcyYclV1bMhkxmMnQ4d/bMuTJixJVDUxa9R86ez3X02HFdpw4cOGtor4ETG06ZKmDK8K7TuwxsMLtZ6zG+h6jJSZMuXdLEqSOpVbh6tSV2DJmyZs2ePWt2DJSkPh0c8LgEyAEDBgcOMFihQgWFDjIiArFo3w8QSZo6fgwpkqSSFEnkJZgKZImmmmyK6aabCHkQQkN4knDBRCxMxCdDSjIkkZISKeSGKe4QhMRFhoABBg0qOJGIK0i0gw8LJ8lkE1ZCIYWXY5qJZZUeV0FFFFVQ6YRIkC7pBBNQ9hrGmW/AmecaTBD/SSQPLJzoQzQ5FoNMMckimww10i7L7LPPNCPjNNLUPC1LyT6bow7X7IANttlok2023XgrIzgw/OSziimqKGOONgxlI48+gtIwkuUqcY4jUVBphbpf2jpGO2ae0S6ZX0Tx44M+NFHjgzwyUKADD4xwwQ4NqvjDB/swuqgiIDbqDySRRhKwJJliamnBmTKU8JBgEYkwwwl1utAnDHXiFRAlCgnFjDOOGMKKQQaBoYIWBGkxEEsscbSSWFSxhBNOYhEmGeec4yQTsiZJRCQJJaGklGKW0SYbcNR5EhgNqfQBC8TyqKyxhBNWjIzFSrMsDjbi0KxMzs7czLMzK05TMokX/9NsjjLkhI1PPv3084svhgsuuDpOPnm3Mgw9VA488EiUUUcpgfQTSVuBhTphsNNOmeyOSUYYUHrG44NGOmAAhxV0gMEOFeqIRJKLMMl6ViAwwTWk5SJphJEBLYQJp5eM/VXBngpcEKadDAGEbkAytPtCZoGye1njvDDiDDOsOOMOVVgZxIwrMlkkEEfEnbGSUNCNlxNVeAmGOXjjRbcSRSahBJNSgGEGG25MN/1fbTyRRJE/3nDChzwoY0MyNRJWA3fcM+tSTS0vk+PiioWng+LOzvSSd8YeA1lk10wuuWQwUv6TTpeHi7ll44zL42Cb8VhUuUgo2fm5nkWRrpbqrv8zpuhj3F8LPEQOmSEFJEpQwQsliuBJklJcAQUTW6NERTjyEZAsZyRky9tM0gYsY7HEboRIm0sk6BKf1A2DQ8kg3YASlKP8wThl4EMhHiGIbIViE45wxCLMwDhBjOsRk7DE5jYhrkxYrhLjiteMNKEJUcjCGNcARz3wUQ91mEMc5zAHOLoBDD80wnVaQEPs9nAw2slBDR1TGGY0w6XHXBF4wSOe8M4kBjMSjwxmVOPFNCMGMmlmDM3zAnBaBpsxjCFlZfCC80hWBT/6BjZz0J72uGeoPOhBKBiShPjI18NIraIWu7jUdY5RDGOwTxm/8IQh2FAFFqwgBTNgAyN/cYv/UpwSgBXpSA81oasEls1CFLpJsdQ2S2PN7Q86IURi2MAFJ8iBEH+IWGr+8IdgIqaYyUymopZZzCrqgQ984IQlBnGHQTCBCYtYhCPGYglB3MESm8hEKCTHi1DkcJyxqAQjYvg5T8xCGdv4Sz38wQ9+mIMe6UjHOejRjW1gwg9/gMMWeIAFH8jBirdjDBtyZ7szeTF5crBY8dx4sYqqkQoZTWNGM2rGMnq0omgkQxy9UFI+kYxOd4yjHp3Xst7siU6CHOQcCsk97iGyIn9ABCMvQb5OgGIUkJQkJbGDDGpwpxnC+AQierCDHWDBEJSQhCd+IQtQlAIU4fFDJAp4QASO/21KFypWTQ4hQVra0iY6+cMe4sAm0zzIracppnGKmYebFbMPsqsiIPRQB7AUopqOuANgt0mjQohrEY8QVzjPJa5KVK4RhpiqLJChjXjgAx/rwIc/OOsPIqYDHunARzeKwYY9hMELW9iBDw6qMNzdrqFq+OjCGoOwMrZRjWbUKEapEAUqiIGjHPVoGtdY0cyIgQ1rAENJ5xi9Mqj0CystqR2m64XfnLR62YVNF7oQ2zZkIQ3fsxclEHEvTGjip6N4hSSFwa5kKAMa8X1GMo4hDFhoIj+YQNItcnFKrHpCfpUokldPEglGTIluiTgrTsq6YAkOqycRXKszTTO7yJxmkP96sKlNEVrFoEBTCXZwXCEmMYhHnDixhaiEKiSnwsc9gixkUYUngGgNcNADHvkIbY7/wdkitiMf+VhHN7oBCh9EwQ5SgMIOYLdQLdmOdhKznRoYhlsucOFLEpMYcanABeQ2DLldjoJvgytc4Ja5o2d2o3HNyIUtrKELXnhDGZTbhSqsYQxtGMMavpCbOdsBDHOGAxiUm5vbaJdOslmDGrbAaDX84AdYUAPOEOEHQ2DNp0F9hS5+cZ1kyNc7ykiGWmqBCU9k1RSykEUqTimJQzjHIz3UFSPGxggOJfhBDJZfBWdJCAjrhG67lOtQRLOw0SBqkEHJQxrQgCjZ9UEPfLX/wx2mkK1wWqIQgx3EJFhsCXLW0BLaVGyMQ/GkeciDHvewBz+CnA9258Me9MAsPuLhz2b4QWLGqcMcUrMYOkhUonGgAmbi8GWMsdGNdJgY8CRmGS0rT8sRO3OZlxDcMqbsjimjgsaju+c1uOENb4CDyNMwcjjkoQ55gEMa6vCGNqShDW9Y9MzUsAZDzSFkddw3nfra80EWs0ON2hmkONKzVcSC05d6bzOUoZ2jHaOqoPDEqVEpmEjwpxOcyNVIAkSSsiliJoxgyUoYIXazGSInOglKFdk6cCxgAQ1ocIITrOTUiMxgBzaYgd5nwIMf7MAhsHPq4Gegh5HvsQQbOAMr/3jBCmw/4g6P4EUsIr/YRdjQEjAWFz38oe7Ow8Md9mQ3PNDRDnrUox7z6IY2oOEKIOBhMXrAOc4Pflzj2p6NxsPYRJPXmCnH1stopkLF0WzGlB1/48fvOHe56wbnhzwPIX8D90I+M5pPupCG7Otvqtdz1nw/w3QFRNAn8Sjn9LBn0kF60t2XHWW4D1PKMAYwZHFKU5wCE400EoAEdKGyM8slxK4mEqFsygYRzIYAD+Eo5gZLsMRguAcxbifu2MCM5s7v1KAN1CAN4K4x0MBKsGALYkMKpkADDqAELMFGFiGHTiyHSAiFvMnFBmGxHuEd3mEdymEd1sEc3qGe1K2I6v/tL7qBGnxhFvJDMmKO+tpgYmwPuHbvuMjgt0JqojKGDBKmY9QADXIn7uKOC4TPCzeOozSOCvyIDP2Eu7YADdMgDaTvDdSw+jRwDaXPDTfsplojTsIPD+1Ae4oj2i5N6CqhkThCOk7hFW5hF4bhOpAB/tqv6d6vGIQBF0ihE9ylpyjhJBQBl8bPQ/KmQzaxE/vvExWhbEjiEx8El4qpJ5QpmYIpKeZENvRgDQ4DDXzJCdRAD36AB2igBlagACjACmYoXlJsEgphh2BMhVbIcRxBsdjBHeRBHtphHLhBHeIhHsoBHJjoGpxhGYwBGfTCE4AACBCKDfHA5RAO4XLLojb/443EIGJgKwtxJ+7ergs5agnqkfiGzx7vscymgB//aDjWQA0DMuQCMiBxRw0BEiBPbg1ETuXegE5cAw5cAw8nMsMWpRFQQnyagz9E4dRMwRUi6ReKYRgs6ZK4ERmWARm6sRZAYRKNZHwuMRFQ8ULMhlc+sRND0UN4pcCG4hAagVcG5IPwKlEAYQ6qIAn4MQd6oA62QA+4QO9SIAV2ACpDaQYcoAAOS1vEpZpO7MTCrRAub7EsQYUUC/TYoR3KQR2+gciI7BqUYRhsIRWAwRd8AS4ooSDmYDbYMA3W4BzRcbjM0aK+qDGujAsGkzC5IAryUTEXMwr40TEfU1DKEM6Y/+8M34w2tkALMvPN8owz5+AL9Aw0xwBPRpMPwY8Pf+4PBAkxKkhCeEq/0OvUTuEjdwEYhmEkS5IbL8kWWDL/XNISAyRDfLLsBLAmbE1CDqwoLASDLIQogGIP2kBR3uDNugAKsiALfoC1CoI+cgAqu8BCjIMLUCPK1OAP7mU/tO6xWKGGHOEMXOwRDivctslxxGWFwNIe2AEHr7EbuEEbnKEYcmHVXGEWjoEYRi0WfGAGZgBPQs759pIJcysK10iMfou4NuoyeukwCfPtsIALFtND7TEJjnIKRPQxA8Ux0RANK7M21gAzn+AJfGsM4GQO8KjjaDTP2gAOcBRHZ49O9v+gDvaAruYKkTRMD9iEdnSKp0AHNq8qFVzBFnzBNi0pJUUyFXhz6F6SFC8yEubGJMAuABHhwGjC1v5AMuowD3BHDvrAB2QAQSXCAToAKg/iIGSgAyZiB4AADfDgDyLhUUTisYJEFQK1FQY1FugiGOjCnB7BDMSSREhkxCSnmq6APr0theLlG5xk9a5hGpiBGroRGCylLaBh1IjhEuC0A/yEud6Au74gt1o1Cp+wVTMjQjGKobAwQ7lgQzf0Q/OxCOwRCUIUWJVACpSAWKVgWIUVCpIVCragC1J0MrfAOrFACwoTYbDsQh2DDdogW7OVNNhEKPAqmQ5pewxFDWIFDfr/ABBMIiMw7bw4YhRkkxagtBiK4RiGQRheAUnGp6dOAhEAwQGRIyjz6maCQlFsBg2yYE1lQCqhsiA+IAVkYA/YYIrs1AlG6fzQK/1QYRVeoRZuAReARhdwQRdGdi54YWRF1lDpYi5EYYQE5wiO4AwkNZxCIRhUQQYFwUUEYRFUYRO0yRFWrz+NQSRr0zavA35GjRdUYQfkdDeYqx9n9aNACqPITLdaVQwKEx41FFfnbkOd4ENzAGzBtgiKAAnIFgnOFgmElViVYAqOdQqS1UWXFUXREAogLQsaTQ24AMrigMpsZxabjaGuqLa0BEwO4w/yAK+CophuZtm0AHe0wAnA/zFPERcQEDeXxKddPyGoQFJofmEXhuQSGuUkDKEP1MBKbCAFPmAH9qAPgGC1wJG1YgUIElYG2BQN9nSRhg5jRyGoYGEVYCEWgvdkTVZkcQEXdmEXekF5ewF5jdd4S3ZkJ28udCF4B5UToukRrGBVKoAItGIRIo8uFqEpBOEMYlZnHWcQoKFe5RIRC3Q7tOM7eoF6VeESzhQKeGBFaaNZOyrN1BEdxwgKx2xWaZWhPPBWD5NDKa7iliAH6rFXe4sKtmBZm7ULBmqgnoC7lrUHpKAHeuAGekAJeqB2U6AGalcGamAqo1I7HdYgJgIqJwKGp7IgHrZ2nQrSeIAHeiAXc/+RBrSTYWHYhOPUYWsXCNjAD8oLdKiO1TyBEtBgIhzAAQxgPeo0ij8gihmgA2LX0pA4gDph6rKqFE4hFV4BFl7BFWDhFu4CF2rBFdrYjV9hFmqBFnw3FU7hFEzBjFNBFjzSFVIBLnZBF2CBF1qhIz5B62TtK/zqEaZgCALHWhr1WgTBEZjAEULhDu7gDAShCRp1ERx1ea1DR5oBGuYrGV5hFCaxIyJBDZ5Ah7sgDVxZDWsuCoULt/7yQYGLt7osYgw4V+URV7EgMe1xbMeWgRe44qLgCyR4WeEsWWdDgnV4C2qgg49VCm7gOmlAh7OAB3bA77T5Op0gC3YAF8X570r/WBdr4O52QGEHb/BowJ17GCo9IAMyAIqhWAEYID3qWT0cQAEUoJ7ftE59QGu8WOoGCE8NIT/swxCaI3QfZSM6QRR65BVeQdVmwaIv+qJVraJlwaLdOBX0WKNDOqRnwRZswTZHkl6NARGRdy6CIRLeoAoKoRCiyQhUwAisQAdaYAiYYAgc52Vd5Awa2RE2wQxgIJusoAnMQKmvIGZdZBHo8miSYTtGLRhigRQ+wTkigRNC4RL0AA3nTgOlCA1ieR6Dy2rP2vb4l6OuLB4PmDDHTDGHOQdwAAcYOAfMtgtY9AmUNa+5i0W1YCGbdTL1IA22wA3TQHveIAz4ICL10A5G/46VOxgKuoAHbqAG4PlhH5YGZqAGAI9+5PQgHIA9GKCfSZs9DAC1U1u1UfsA5sOIJcHURsEUUsGizfgVaOEuYOEuauFjjTeNeVu3ceEWaEGki1vVPhqkVa2kcyEXgMG5pTQll2EZmMEZokEapmEatEG7tcEatIEajCEugledVGAFmAAGzKAJsAIGTqAJXmAIXsAKTCQQBKGRj8Bx7sAM2LMJjoBEzGAImmAIquWnryCqpZoYTJaQ4aUSMiHzDJkQpgAM7pcH1HALwysNgi+jyCzNztpVc7mXtpAwMVRDBRgfHbhXibkI7noJimCyqXOvmZU6oSAzn8AJ1gAKnuBO9P/gDWzRONqArqhruvgkCXAgbG2ABVggB0BJnjPAAzwAIegZoP8ZoA/ing/iA0z4dnvSpzrCEySFjNH4LgyReefSF5ibuYebFoabpEm6pGeBo9ncFnJhuXOBzH3huU1SGZahupmBuq+bGrihG8DhUk+HG7LB0LEB0UuHP7WbGophFnrBZNVJA0oABgC8CVoABo6ACI5Ap3W6PYngva+g0oeahQKnCZoABmL2CJK6CTI5Zs+AvoRBF1Yh60QhFMgihcTSETLhEQKlCnoA0ggyINvAy4BrzEi8+NbMzGpZywL3gI/dt3a1V1c8B5AgCnigBpwAcmuA253gCXhg73IAnfH/LjOllQecgAcUdp3B3QOmst2XvAEaID3w2QHkHZ/h1IqhOAVMC5jKi2dEARSkA3ijVxjgwuDhYhg89+DhoszjvM7NHOIh3rknHhhI0hikexmiIRqqIRu44Rrj4S9C/i+osd4MPRsQ/RvQjR6esRzKwRtMx+Rj/hpm3hhkgRYOlRcmYQVcQAIyfQgCIRBCXRDcewiGgAj2+ypahL/NAJsGp3w7Ob23IpNbfRGa4BdW4RN6yDkWfKvpc5uwbQq8gJXT4AfmNiD5TLd669iF76I6io12px2bfYuq1gun3R6JnAVS94TvLkE/eyKsvE4/QE7Tw5/3mTzweT2k+J9Vl3b2/6ARHgW9zocUyLhQgyEY2uJSCPTp3mct4OekUXpoKX7i7dy5T3peuTHPpZsZpiHRPR7kQX7kQ36zZt8faJ/2ax/14uEbTicbNKuz7oEe2uEGv+HlCb3jrwEZ5HwXJm8SVEAHNIADMOAKOKAJHGEITuBE1tu9XeDoy/cEFiGomWBwWv3Ut8lROzlmT/0KNCETuF6GyEJy7iAMYOw9u0AKusA60/1u0dBY+ZFVdQsgokShQrAgwShiyIgRQzChwoVkIrJho6ZinIts4rBJyFBgwSVFiuQogoMki5MsZuSYkSJFBwcwX8JkQJOmA5swY35wguZPI0pAMXUaOgrVqlWvav/p6sVUGLGnwpwSGzbsKbFixZ4WG5YV6zBjWMEaG1ts7FhkyIyhXbYsGjZs2aS95QYu3ry7eOvVw6dXL76//gILHuyPX2F//xArTvwvMd958cBJ5vatHmF8eCNL/vaNWzdmvmz9wtXq0owuOkxYWHDkhYsVHnSoWBHmSAsmQ4YIOtNkwxVBd5gMEtSk+JkrlhyZaXKmuaArzDNZmi5903RLhQrxyZSpTqIu4LP82AFly5Yq6NMvnMilffuDUdyvMd8QIhsuGeVo1EjxvnsuAoGEAw5IIEESSy21JFNOC3bwQUsypCADGmiw8QcijVxCySWdfCIKKaS8EosuuvDCSy//v/wizDArPkXVi1RhtVWMXL0IDDA1vliWWWs5w4w011zjWTfg4GXkPH3h488+SwYGWGD8RMlPYlA2JuWVUzam5ZZc/jMlX/XMIxk4dO01GGZHRmaXNsP4sksvsXxSiRc3lNDAAhIwoacHHlRSCG1MPGJGIYIscsURgjiCKCubWMFEE4ssQsQZxDXH3CLENSFdKJtkokoolnASCifTjTqJEirIoCoNKaywggqtQqiqhKqqukOCCUb4wYO4ftDBr7/6CuxLwM40kwIK3HQAAzk5sOuuMviAhyGSSEKJJkN5OEpRSMHibS3ewlLLuLXcMi4ttNyi7i3o0mKLu7bYMost/7LIEq8tueDry438hrUWW9FMUw1c3ND1zZiSxSOPPPbYc8/DDzcsscT5VIylllFWnE/GG/OjMZZRdrnlxf7QI8832Aw8MDaVQWkyON94w002NN+FDDC7CKNLJ3csYsYILgxhwhBmWBEpdY8EY8kdTDuCaQtDGHoHo2aYMQjTVlhxBW+7LZLc1pxksol1nHKXCSdhZ/LIIyukQEOEEbKA69y8ztrrs3g/C2zez8owg60+BI6FhYcgEglQlAj1ySegiCLKKKegkkoqR71i+SvezjKLK7PU67ksmoP+uej1hl5vvLnse+OO/0YjTTUDZ1NwwQevU0488ayzTjvy0EPPxP8Ny8M7PfDAo7HGWu6jvPLHX9k8yFJaDL3IGJOMTzvZwL4yN/Lc47E97dRTDjfeZAPXPMwMo+IvovzgwaRnHDGEnkxYwoolgyxiRCGqJFOJDoMYBHOKM4QjWIFpdgjUHfJ3h904woGYuhp3xraJUHDnOpUIlSXs8La3yWAHM6jBDEb4t1rNLUHPSgG0ZACEwPEED3LwAyKqZS1MaEITngDFtkpxilS8whWuwBy5aqG5WbQLXZNLYiqAuDkgusJzkzPF5EZnL3zlgl/AOAvApCEwuMiuYN4oRznaQcbdvcMdaHzHGYvHxnTAo2G+s0c+7GG8OQKPjcCbmO9+N7GKKa//S8sL5D4atrzk7QN6iJRSycr3Frh8gx3e29g7TFYORmrjGlghBi9EwRITTKoJViCCKJk2CBgQzQVMUEKomMaEQgWiCcJxlBHuYIUz3GE6tXSELnX5G6d1qmwUNJslQhGKSdiBBzz4QeAEN4MdOHMHPsACGga3hz74wRCNONyGbtghHaLCKKsIV7nWdYtd7AIXucjXvWhhRHQVURbu9Jy7qBiv06Xzivz6ilrYIg0uruyLsyPfN9QhRnKgAx0GRaM7DoqOdDjUHcVLhzvc6FA3srF4Cz0HOopHR4hy1GJyzKMg93GPfXRMSl5K6ZTy8UfqAdJLiYReYGzXGfKN4xwZ/4vSO+zhjoJlwxnGqMovVAEHDzChBTAggguaAANBHIEJMLCCEYwwvzsUQgmF6BmmFsGcQTiCCY64QxiYYIVBcGcRDzSBJwsliABaooLSuY5cOfUIPgBCEdrcJrY69CFVrKIVsQgsLkxE2BSliCmHZYo5d2HFe97rXfCK17zU6VjVrY51yFiGM6LhFmxoY3bdsAtkICPav5gWMJO0h+/eSMeLVjQd54jtOdgoDnOY4xzmQMcZFeoOOvIUePnwHvBIatKTJtJLx0tucqNEUog17B6ECUxLGzPIkPoWo+cQRzjEMY5xlO8b3RXHIUFqD3PILho4SoYwVJEIDQDNBSM4Qf8TDAiqIVjBElC1ghkcUYhHWOIRTOjZdBIVqVAUYhBnuJouKcWBAxygApBahFvHNp2xxdURmaBrKEpkomBExSogDjGIo/JhGAHjFzeyrC9Ut+IW34grZ8ksM5whDWto47OhJW1ekISkJO1lL6dVkmBiCr2PKTcfxsNjcIG3xzw+zI73CC5x75GY8YLsyMZFpMaYFBjnlte2YLZtbM/4DnTIVhxo5m533SFbc7CjHeXo7k0PeSV7sKMc0zBGFokBi0TcwAQcwIAnYfCC3GiqZ5kYBBPMYIlFeOERBh5ELp8zHa9JODj6vQOlLDGCEVwhUpFa4C7FlpxC6XKBtwzGU1T/DZUVcUXEsA4LWcyiFrQoQ7MBu8aNd10wyRzpSH4xrT+EbJhiE5ljHyOyS6fEbJXmVKVeKuSW9mGlf+Qj2nO8NrOzfGWNDbsvffHdwtqhu3XI+dycOfe504zm7oYZzOdYKDvcoTtyl4Mcqc0pP+5BD25EQy3NIAYleKCDEUAAASY4gdOIsJtMEAcG8z2DdZhgBEedwQqCyLggpIPWR1wtwHpqTqd0eWmvNm04BH4gcbI2S07EIhisnoqOvBLiDx8DGtSwhq61sY1tdOPXQAd2sKNLdMZAm9lY4vaxU+rSplvpuFwq8vSidBjB3AOOanwHO2oa0K4HVN22lXOY2fGO/3HUFrfsSPs4yLEOdNy77WfsHRlxp451+K4d9PCHPZZEj29k4xrWeEYzdKGIH6hgAQuAABFGkBtEKeoIiGrNEWBpBBfAgKwNzLjTAuiItQXQCv4dTnMskYnN3+GBb+2a1zKxiDM4opa25EMiLiGKVQjjGc9gizN2X4xn2KIqxIiKioahDJ9r4+c/73rt6LGPd4SPGypLWTXAoQ564IMe9XgYPu7h43r8rneLKWnDqMu8lEpPSoScLmIeJph/FPek1zZkwzx25GNniXpXl8ed45zucXDm/wBYd7izDrijJrjTO7/jO5NkMuO2MHZnDwwjbgj4Y/SgMPUgPOWWMJvhU/+yYz7T4AzKUAy5UAqaQAmGNwIYIALEUWii1ARDAANmcAUQZwZHMB0BRFZmcAbElGBm0DNe5QiWkHFXw3mnN2CUkmCbgHpe0wSfZgm8cXErYCCEgAi10A3d4HNWmD3agAy5wCIqIgy/QBXM8EVEMg8B9Q1iZA4VIzHQJ33TgA11YRlCNhh+AW564TAQY3UQQ21OxyVEFxjul2weIzIeQ2R2tEdaZw7qtojdBV7gNQ5xJkblUG/rsDAYaDuTSEbtcIDxwEeq5Q5ktDB79BfYx4DxsIliJDM000jVMA2c9YqwGIspQw3OgAzDkAupMAqfoAl/oAKAhgFDQATBaEq5cQb/psRWrhcKQHhArZQJrLAId2AGEuZVmOJU+WNLC1RqlJJxoWZBx0EEkycIwegogVIFdWAIVXiF2wAZ2WCF22ANxyB8KeILV+QMs5M7YBQON9VQSCZJ2eOG3NCJVIYYfgg8eegP7DdkiqSH0GV1fRh1iEQY90CKJkNu69B1NJORGul1nEEZ7HAO5MBu4sBQJMlQaHRdEqNGErNH4qYwtkNTPvUWsCMNschZbNEWN5mTr+gMObkMtKgMxuALrzAKnuAJnaAJl2AHAjQBJwADEOeUL9AcQxBxiXIck2co2BhAbvUITiOOZ7A0PZM1g5AczREp0ohgiWIJBsQcVzCVlJJV/0zAB3/wC1c4FtRXMO+oDOqFIr+wCyuWC8UgDXQhRtwQDoY5kmjUj/xgXioDO94gDwTZdIpRbIURZZZ5ZM9FdMqjD3zoUuN1dXDkDlnHDmE3Dl53mmeImrPTGd/AbhplZuIgWw2VDugwUa+FUAelXYbpDby5ijM5DVw0Da5Yk8T5igDTk2zBDMi5DMrQnMWwC7kICthiQ5fABwc2Ai1geUTglE3lCFAzlS5wKAVUg5ZwBcExCDloBQuGGyagg68nHVrZQA2EKRjHG2+FcWzZBM8BHDqgA3wQCcmwDdzAFvGgDjKzDceAC8LAC0uxC32ZOldEDQVDDoV5mPHmDkgWJf/jIH3asw72sG3J9UfNhn7JJojOEz3JZm2+JZpmFlstOg7h4Ij+538A+H+8KYnlUHfqsKM8Sn1iVG66w6MCuIntQA4adZsOBZu6mZEyCTvAWZxQGqXRoHvRsHs+ons+opzKqVm7xwzMoAxpsRW7MJSgcJS7eEOP4AElwAEmgFQnADVBcwQuUGhNJYNN4Ai9ZAZ6EgY64HmKFkqb5lVDeHFMcAZmIAibcKjVeIRc9YSLUEvRqANgQAnN8HPbkA3zsA7taA29sAqdEAmfYCK9oAvlkk7GMA3kU6HhkFvFg37Zoz3VkA3t4D3IdX4iGjImimxr2FrwEJvnoG7fEA6FqZH/wWqYxhqsq/l/jAiJOJqjOrqjQSpG6KCJA1iAupOjqSgzM0MzsCqlNQkwUKpZPTljM2alVuql5Xqu6LquXgqmM7ILsIAKu0gJkXBDl3AJnGAHHnABJjACHHAB8dVp/WoCQbMIkHcCWxOVTWAEwlE1p+cILpA1UdNwSRiNFncGi8B6TrgI87M1xWEFkNcERGAGK1ACJgAGkdAL63gXZNKO25AMn4BXmrA4scALsQALfpkLxgAXvOkN4jBvciQl7GA+rTgw3pB39gBT95cYS7skcISIaaeIcsZ1lNEZGyms4eANWbu1h8lu2yUO5BC25FCa5xa2JKk7wqOJ9pat29pI/xzait4Ki/30rcm5pType+TqpcugtzOmWeyKt2zRnM25roKrDF+aFm2yObJQCqAACp8wFJ3QCqQgCqrACTegAYNgAhsQAf66ARsQX9mJnTBwAkPwAq4BA23qAlODXz1IP/IDHVBlBJGSNRiXcZTCBByAGyBrBdKRKaBkBhqgASYwBYrgCcjAcz1nhdoADcnACY+gCIqgCZOgCboQC61QTvuCDF8URmQnRxvjD+NgPtKXDXaHD3vnhxCTde8gteE7M7PTgQBVtf33f82Ko7y5XWGLZmLLduiwDuRwb283rWWEiaq4ik0qME/qrTQZt8RpruqapXu7pRGst4FbuDlZuP9gihbHcAxbkWLqNAupUAqMCwqmYAqlMAqOIwqfEFixIApS4AHCWwEbcAEwMAJqxaaoOwIXcAKMZ7pEYAIm+wh34F89qJa5sZ2QJxzzQ3FoRSm6dAQjAD+8QQSltxuilBsvcAVSVQgzqwvKAA3PYA3waLPOWwiK4CGXEKrBwAsrghXOoA3gsDvQFTJUAibgdlqC8bQOCKTroA7jUIADWBdpq7bCg4CiuDA7NUk75TCq5TAkpVrygImSGEa8yYEa2Uj/6LZeZMBvoQ2epcluGyTYoGtBAnjUcMrUUMrXAKtiLMaofMrWkHOv7MrUgHuC1wzN0JzIwMFb8Qv0+C6y4Ar/qVDCIlzMImwKp4DM3wQL3YI5rwBYsRAKYbABwjsCG8ABn8sBGdcCHHACL9CUZ/ACLYCwgoC6n7YILRCVi7AJRwwDhqobu+GCZ8B6DmQJ9lUcxEEE0DEEZ/DDzfECieJU8/y4wtAMTiEMkgsqguBfodAKN9QKrRAMvdDGapENMAOZG9MYCMmAvCMPp2iReMeAlijSLFmBlgjIKF2A4HbS3qcXlhjJ6mC14gurTiqcAkPTsCqcsBPK2qPKPf0W19BIN6bKRF3KrRwkrUzLqKzUsfwM7arLHDwMwPDLnVMvwmzCxlzM27LVW30KXu3V3/RNlYMKsJAKtbAKsaAKhVAC/502BC7QAgA7BCcQA3RNBBzAAQwnKSdgAqjrztUYNPHzAjAQAwZ7BL/hVEdgqG2FYAlGKAXEHLzhAoldQDposMO4aWizCqPBoLEQNoXgNZXACZUQCZwwCZ+gC8EQhsVwM8uQDeBFD1qiD/SwvtfaDqC4ULUpmlm3UKKp2+qrWizp0QYoWiwrGd3wvqu4yq24wAxck/303P2k08Fp0zotMEVtytRQDWJM1LGcc60sy65sy7acy2AKFlThJu+iOUCEzMlszMSc1aeg1Vy9LaewLWGNCmAd1s78CmKtCqowCVPF10FzAhswzhwQCFfAwy0AARjgw4JABCcQ4elcaMfRBP9DI47FAQNBk8WW5ihlFY0ZZ0owgFbMcQRNdQa6wVRHIIyYAoSLQwqBFQyxUAmbYFahsDaEMAmZEAmTUCLCcAxjkUXLwA3sQG368A/6EHbl1qxLXm4dvUcvHYr2ZqA+xQ2e7KSuw9xVmq4OTGOus3tzC93RzdxWGoubVaXQLZz9dA3UYNPSsHun7AyvPOe1LN65jBZkIdV/CczBLMzDLEVfzUP2HdajACJeTcwlnMxefcLb8jiQQ+j3DdarINawMJSrQAryuh2ZYEqOcAIRoM01zAEwcAXbeQUYgAGE1pQQLilvDTXyIz/ePATZWQIyPAQL9oJZs0CX8hv63M8PlNj/InsERpBxBeQIGEt6Ly4KFrQ2QyzEovJfmYAtoiAMyYAWa4EN3gMPGfMOaMcOmHitqXitPauKoFwNc2ucWJru5Armb+7A7d7lNHburpPlOwnmYC6cbU4N7T7m7+7AT53BeG7eU61O8lIvw5xEJVzCS+TnXk3f940KIFLoIAIi950KD1/o20IK843pFI/fD7/MRzHppKAKipABOjDq4SwBEVABLyjXBBtfL2DDCSfZb43hV2B5U0mMhKbhQuMCRnB5YZAdRhBApOTObXkoDAd5upFUYNXPk5IoQEh6GfQIZ1Coa7M2vKAKd5AJraAITuAHmBCgydsN62AmJfMOYmSg/9rKgW87nFO6nHCfnF06rlqKrl1KwVza5TS5WVzUT5sV78D57s9grui6tzdp7Xmu5x9MRX9+zAkfReyN1cY831sd8Vsd1hM/6Pdt35afwo8O8Zju8R9f6UdBCp+QBjdAASrvAvB1BNh81/0aXyYAsP6KnTDvAk1JNIfCNSbuAkQg2PJjXzAAaUKsJ1ZANCg+lcVBBCoOHRjrlEwQlbnxVmPDCo+gBBR3BCbQBJxQCKOCP1dz/VowLakADe8oxq7IRW8P95ll7Wth7cvwL3E//8spuHF/9xK8rnff5VuqywHvFQAxbBgwgr5y5bJlS9ZChq5SOUwVUWJEUxVNlcJYav9UxoyjNnr0CEqkqFGiTIoCddIkyJIqVbIkFRPVTFQxSdGkuWrmKlgxP71p0GDDiAoTLmwYMuTElQUjBLkwMWKEixZST5h44cIFjCtDzFhyJOjMICNnzDBhMgSGVitmzDzSwaSQERhWBFkhcqTJEUFdz2xaJMjSIiuWrAxpMsRRqE2OFhWK62LIERiLMlXK9MjMnUF3bkipJGpVL2LHgA0EVqzYsGIEBaqGrdrYbNrIbBuzbVvZMt7KfPte9hs4b+K9ewsvnpzZ8uLMhCu7vRo1MIMIE86aJQt7Ql/dqVu3lX1hdlcQH5qnKPHUKYocMY4SGV/kJ/qgPtnHL1++y5P/LF96tAmnU1BZpUBUXlFlFVEisSOBBhaoAIIIFrhALRO4OuEEGC4cYoQTiNjgAg1hmAwrExZxRDIrULTEDBJbcKGEIQp5q5A7XLhjCBTPuOKIIa4I6y6w7nCkslDuOGsRSzJxZJBFzhBskcDOeKwQGx0TpDNFPlElll+IIYY12Iw5hrZjzkSzttyg0+05N5dZLk45nXHmmTrrpMbOZ/bk8xlmmvnTt9uMUU2gX37pDryEbKGlUUZpYXTRhA7KxRfqBhqmOoQavaXRRrGbhRZQsXvFlVlKLS9VVVVVb71TRpmJlFFuklVWWFEZMFabZMIpQF15faWWV16BpdhVWoml/xVFbrCDiQoWWCCCCyQ4AQMKOdirhQ1ggEFbDVsgcREiYHCkCXATMyExJv6yZIgXBGECBiZc8OIRSzix5I4z1tWLCH+hJOyMw4awQl8kjbDSDLPaMkNKscQqJN8juvJKiUlIaQUXYcB8TbYzyUQTzdxsO2bkM0keuU3hAGW5GZfdROZj2AbqrrqERAV1oU9D9ZSWWmpp9GegPb3lloOM3mUXX37B9LubeR56VKlLRXVVViVCJRWd1kNl1l1l8pWmr2/CSdeZTiGbJlgMRGXtY1WJpIsVNGAKAg4miOCFoyY44YIRYNgARslG4MCErkwYQpATXDijhStc4ACGFwoTZP8ItCzZ5A65XJiElUwKCWURtCb20Swemzijib3+WuQsM8IoxI4wvGDCiit6PAOGI5i44w5LBjHjCBNOMMOL0F7BRZeNBRITtjJlIzQ2kWMOORlkkhG0+pCPIaYYYoQR5pdeks6l06mrXlVqqIuFRWj3hb7l56Lnv2WXopPe5dBhEAWv5/hxVl95XkGqqp1nIjRJRa/GtkBegaRsM7nVKNZzq1jthECxEoUqVKGIFKjABBWIUAQiYIELNOEFSWnBCTw0AhO4gElX0R3qWrCXI1CmKu6KCmCGsC8zhIIsvLOEJSbxiLacwV2JGQLiKGPEyTSBMXcwghF0sCQd3CEMZmn/wrgS16LeIekpI2jCIArBpVfoohfgY15sCsW8jnWvTG88E5i8J5DwHWp8SSvazsoDi2G9YhWu+GOpCjTIPvaRfYYsVtBqAQufvQ9+RasF/eqHx12M71Ddo06iJNkpUe2MgAM81bDKo7U/AjKBZWNgKlnikbKtUoKvqsmuCKSTmoiCFJ/goAqgwgEIQKBIIDQBBySDgaVoawMbkMwQqnIGIiQliVmxBBGSyS0TmMFdQ4iiEQbxiG1OURWWMIIjrpAXK0jmCCckkQtecAZHMMEIJmBCEM+SCSP2qAVDIEIQrTQJS9wudYIoxCNEQaDkge9QB93fL8BXx4Meyhe98MUu/yjFyVM5BJBs28kgBzlLQhZrWKv4KLHYN9L2OdKTnIqUp2wByVvgAhdJ60VM83dJpk0nU/iTKCSD1rOprUqjGhXbrlw5VJa4iqgwGduBYmnLT/DBAxpQQQsuQEwYGFECDbDACjmwFAwcJUNXCVGMsKKWrZQLBhrSEYkI5gi1zIssQ3DBIjZhCclNJonWTMpauDIuR6QoMEt6hL0OQ4QXNMGfSwqiWDJhCcEUQhMJgoVLz9gL8cF0fLrARfxmcbWJpGI9FXEV17iWk6DGBKMW1Oiw1ibAYfGsZ57CjkqNdouV0oK2kHxpJRuqUPAdYxiVOg3zDnpH++k0tqACWkVT5f/Hn9IyljE5qkdIEt2jppKWpFDFJ+xAARWUwAxEmAAGXuCIEUjABRrYQFEwUJURRECFFZhKt1qQO8TpDivNhEHlBGFYHzVBEG5hgr2YMAgXbOaeNDTXIJjQAkE4AixMzJ2OLLHOwAxWLVc4wbtYoQokQSmIoThSJZDVvpjeEReO9OhqS9XZs7kKVzRxcdciWJNYusoUrvLsenK8nlFazVTqA9Vr8zi/XOSWsrsNnzBY84vZSMdQh8Jf+ToltJFmdpHMBWlzTwtdkpiEFPyZ7nRXKWNXLpCVqFCFKDjBBwY0QAMl2AAHOCACDlygAiWADFQ2BAERccBDUQmcCypkAhP/iOUKWenWIlhROaXAAHVDyBcTlKQYJhwBSmYIi+5gELwgnoEVofBKV7jFzis4emJaFMFegaS5dTmmCUwaBBw+EQteUPaMLv0Zrn/Gxz5edKO5eiCMQ9s1MrPEPcd2z41NERGrAZln87OtJCUK09021BdnUoYxCJLJ7kQZ2u5jJJX5CNI+/nSWOAGJLcdWkui6KiOn0AhIxmaST3AiE1JQQAISIAELRGsBEopABeQVClZwS6pWWUQTPHRhw6nlhEQ4zFqa4Ih7KpNERyhwPM0wlX1NxgpY3HRSJu5fxvroCpuAwQj4oqRmGpYIMdCL6kqNGLAED3WJMYIdOBGMhRLD/9aVjCkvTkxSkpZblL7WctKVTm5yo88VsJgF1GsR9VlMfadBi99sV1q+zJZvUhI9yKRsYZBiKIMZxVBIdrLTWWZbpCLIfk8pJsgSkYQEFPCZT3xQoh++xycjDMFO0crIC120IhJw4MMKbrCCEniAAg2oAAcsUOcLiBBvR6kAEQQh+RFMgG8cWIRSXHCVE4CLAyn02wuqEkysdOsFRnCBEZQ53ybA4BGbGMRavNC7BX9X9TEQC18cbUQX7BcGdwh9YsbVl0VQbFxN2EQo3HKGM7xAd0ywwyd4sdBe4IKyZuRFLOK3yEUSvZAe9SOWl75+Qp4fFq4YYCLbF+6fNdJ9Rf9bVNhtQSn+H01SYS8GaLCGZ0AIhJCF8MgZ8mC7VLgIZLu7B+Q7T/AEkZhAUJBACdQPjniIWQCuYcANa7gGaxBBa1CGLyEGXoiEp3KzO4MzEJIKGGiX8OoqDiCCKzCBBVAMOauAC5iqYBKRETimlCOcEZAqIhieF4iz1HkSgnESuEqihBuEMFiBQpiEOygYsNCW/EoMR9iEFkCnxCk0Kdo0ymgCS0CdiDsCBlOFSgAdxziDc4qiMJgEXuC55NEFXdgFyYIkcGOfiiqkciuQj2K/9PvDQiQWYRkV2HqtaIuk+dk/SXlErnupSbIf+8mF/GkGbbAGakCGYtCURRQVhlj/iFRpwFJ4O/eQjwm8wAwshYXYv9PAjWVwhmm4Bm3ghlvsBnCIh3ngRV7sBmoohlwghmCohA4qAQpYgBIogXvSm8njAPqKigtoimoZAfG6mwmAgA0wwhaoisojHPhSiyHAgK2aAA8pHBNwMMsBscbhFibQAA+wAx1ghWCwAy/ghE1wEW7BuEyQvnVyBERrgjuYAikwAjOovaz4ON5xnTt4hDAILCcJDEtzizeYBFUIBsxKHpzaw1igMlBRLffjNV5LLS2jGkM0JGIBINcamkacH5bEP0iclEvEqZmkhY05slQYhmMoBt/yBaNRFEbBDu0QxaGkiKF0RUs5jWLADWWI/wZpqAZswAZc5IZuoMqqBId1KIesJAdyMIdx8Ad/kAdwqAZtAwZi+AQZSIEV2IAFkIA620E78zMOwICzugDPqzzLwwAPeQFeioAJCBFuDJELwBYg1JCpKBwhHAELmDgmMIFBmARr2p3eUYEwuIGda8hHYEhwmYwzYJLaI6u4OgMXKIRM8J2GQQvSDLCA6h0+0IF6RD7HKJIhYMgp4INZwyxYuIU72sOf4UhxC8mRaoWRCilBbC6rKZCni7+oAyX2cSRJkh+XArv+m6iZxJ/6SYZfkECteYVXkSmfhMSfnJRtmw3bWIZoiIZqyIZc7MX17MV6oAd8wAd6sAd6cAd2YP+Hd3gHeqCHd3AHcSCHdVgHdEAHergHf7gHefiGapgGZ2iGX0gEGtCBjUsACrmArNqArIKBcZyAaDkBvMFLqZA8CtmACTCDYNo0wOGAJNKQDxGERZgKD2kBE7gnbpGStTCCAMuExPuMxQoDK6oE69PHHTIXeak43uEFVkAYhjQCKxgE4NmERyiEMDADHVACPuADhhyEIFKmM8iXO/CCSyijWpjEXqCfWoiFM42FoUM/ouM1Q9QoH4M/pxuVHxsp+ZGfTWopl5JO/rOFmUyUX9iF8AlU7ukFXjOabQsupYzFaKBFbdgGqmRPXqwH+KRUSvUHfPjKTPWHfcCHffBUT7X/h1AVVXt4B2/wBm7IhlRNVVTFhmlYBmQYhln4hAeFs2gRTMF0FwmQAGKSy0AwAWkZAQqZABPAgPDigIAziiS6gBdAnEPbEBUaL7G4ABMAkQsgggo4EXcpAcSJos9QAi+wAym4ARCbBHvrlg/pCrBQi00zIiZQhWQIhYJ0iybdDN4pV7dwgSoqBC/IBHoVponZixeogUggBaGbxOIqGpfChTMtv6Jr06b7w6RbrkKKU/W5Op+hn5jE0/IpQD7dP/7TlILwhdbwBVoABmRwhmW4BmzIhlvUxUhtz3qQ2UqV2Zq12Umd1Epdz3jgWXBA1VSFSqi8hmkgWmqghmmQhmug/wZnYAZk8AVT6IRLeAQ30AAJWMsE2KqoAEIMGCFpuQJiwrAFIKapOlYLMAE72wBCU8yJqZyE24BovQq2+hsV+pHQQ8cgeoQb1QEVsJIwsLd+RZERQZ0Yoox3yYQjuINPi0IkGYQntQIr4B1VkL6DcQRWyJevgKsR2EzKUAIaSATbxMPich80PVM2bVNC/Ej1GyRAYt1eAyWLhRRHgUmxe8n8yz/vEM+llEWjVVpnyI1lsIZHldScrVR8qId5sNnipVn2jAdw+AbnvcVbTFVtcNRtoN7rxd7rrUVtCMERFMFmKIZbAAVKiIREAIRCeLwF0Df4kgqu9bwY7arOk4rO+//BEWgMYeIAgUuiuTrbEjiCw+WAIIorV1MhvXABHyECB9uEYMhbXZIL0CELdsodydGicHSmesImRyinBqO+cLSEUMBMQfCRxXjcR1is0tGL1GGCMLCDz6XDI6MsoBOfXiC8O9QFXhAQXHE3jrgI9mAxC5KIAmE2hkiFoQxK7RCPWci/bVNK8nQGp7RFdVgHno0HeZCH44XZ4YVPTf1KSr1ZenDPdaCHdigHb/gG6cUG7L2GNabeNXbjWnRj75Vj7+1eo92TZlCGYaAFVIjaRpiESUgEHagAXV0ADtgACfAbaGlfvCnWvESMK9g8DmCrqABDEwgcujLb+iIcZrU+yVD/IShBnBk6g78JBUdYALNtgXc6MBcgLHfRzB6ZDG4hLL1Qi/2aDL04gnGpps1gjDMIBOobNeTLkVzeIYFh0juoTV6otV7Aw8tiZsxKU5eKBY4ipVXwCLkLrXjbiI5ItmWbiKHMvw5sYjhJWpZt2Vzk2SuuByuWB3rwB37I1Hu4B3twT/eUh3S24nYIUHToynHoSm9oWVUFWpbFBvQMWqishmp44zfmXjduaIa+3jkeQaOlhk18hmbwLVpAm06ohErQhD/2AgrQ1cmTABCSgAggx2ONgGrMyxcADBi4mwgIphHIC8GcvA+qgDcsaa1Q0b28kCvYi29RJg/hlgTgRkKT/wwvfIETioEaTIxc5otbtibNFLk3JILEqCvVaT5BCIRmOoNsyoQmCAwSgZLKicxM4IQ0xaxaWGtdEJq1PtOkg7GiWiWMAAX3KGJXzAWCGOemRE9ueN5y0EWe5cV2aGf5DNV8cAd4sId8cGx+4Ad6uGdddN4zjt5sCNqBRuin3OyE5mzPBu3QJtprCO2EXmjSpoY3FkGjleiJvmOd/IVccIVTEAlN0IQM+gQviKoSkIoKSK8NqD0c/Nq8jN8TUKYJeIFypF8VmtYPWgDA+RtLZtbEhIFpVaGuSFGKg2llmgwLeIGraKG9sIIMy+UapAy4ujhHGBdTyytHgIQPmRIXsf80qyaCQOgrwnCwMkwd4ckiwxIEK9qSLtGFaMY14VzTFJuFBZSFZUNiWgCu1IjFWWRjXMzFq9TndWiHeGiHDW/ne9bwdXCHdnAHASWHczgHcQiHcBDog95sFnfxoC1tBSVa0JYGoq1xGZeGaHAG8+TxGpeGGifaIKdoiuaTZvAT6Ige1DAIoCyPZYOlL2sFVXgEx4MQdLSAEhjkTNgEseUAW8Ub5HaEaSXClfabvgEhSI4zCwDHE4iz9EKdcSKRqtK8pLC+Gy0RIIkhZjqBHekXZ/IKdmqnLLUm/4KSHsGd2gGS/XaETFisQhgwvRh0xNULQz+CHloSTuiSVhgxnmD/nzNVrfrbP6SEcGTgjWl4SpflxV2E2XU+bMl+Xug9428Q6GwQ7RiP8dPGddJe2c629YS28R//9R9/4h9fWjpZjt+IjulY8rVbtlK0a21miVR4Bc9ChU+wJVXIBBUQ6QXYlkU4W13dqg0xCqOYEGlpgmId9wnYVT8zAQlosBeVgCHIhEWws24BR3VVuSMoJ7p4hBWAHTNY0hbZhCRiMCDpkZij5b1oMM1ZhDt4cx4p5vyyhHUJPkFgkrOI0EEAZkubuMdRncTZDDOQAjuoBFVAlmSJcg1SBVJYhTvMn7IL3m5YdeStWeO9WZvFystO1dImWh5nVEathh8HdlPvddYe/8FcV1CFxoZcX2MZD3JpMHZm4I1k3zbrIGJnz4i+03qTGImTIJtZySBR+JwS2NUT0FUMUFs1l+l2P1bPk5a+7Mv2SoC8rLMWABHCbCFB8y9LhjMT4BsU8bMRUDQYKAErCCwrWrDju6ePa4HBMLV2ZAIziL22cvQOqyEioJLewTRVKISCaSfDR+YpMAMFAwvDEidHs0EfqaFKNwIp4ANG54RLqAQotRJFUIROUB5hKAZkoAaZz+JdbF5dXAdwAIeDXnHPPujQXvqC3nXSVmiiB+2C9mymd/5erwaKhnpjD45BkQ6nQUBRnIhT5Ai66zv66ITzrw8MtA9rR4lPYKWSuP+lSaCAC6W9CJj7ULYAC3BflK7LDS33ugSICBMkTLhgEAOMISY2uHDRosWGESMmVGhxIcKFFy+ObDhhokQmFyYeqXr0qFAhHTdCWVpRaJKZO5YeCXJ0h4kVM44WiXThyNJNM0fMDDkiSBCMO3cKmXRk5AgMI3zCTLKzadOiTI6ONBF0xeiQJk2GDIEBNemdR3ZQPrIiaNCZO3YifSJ2DJkyadq6ceOm7Ro2wNiwVStcbdq0wtcMV7vm+DHkv5G1/aVsmTJkx5gfU7NmjTM1x9SmSYvmbBlqZKqRGSs2DBgwX7Jz5bJla9YsWbp3u+rtKhXwVKaGDxduqhTyUcqVixL/Beo5dFCfPkn/1KnT9OzaP41qLoqUKEUqSoyo0PEChgUmOFiwIKFC+gUcJkSIgKFgQYERRsDAIAHCBRKYIMgJE1UwAgcbwCCRBENYMsQJFwxxxQgYbPDRIJYMEgwnnGTCySQUZKKKDi5MYgkTXhRiySaCiGXUGQ8dsYhbZ5zRxBFhWdEEEzYuctMQLgSpgxKFsLJiJo9wMggTi5hxRk02nnHFlIJY4uQZgyxSyCKLnLGII0ctMkldx9yF12nMOOMMNW22KQ1piMmJGJzTjHanm3nq6VmennmWGWhrnoZaaqy15tprwygKzKKxzZaLL734sgttldZm2y20aKrpLK/4/9ZbcKmcYsopzHnnHHTXdeLJqtap+okqrazyyiqzwlJLLLG0okokDSTAwQnwTYCBCfUZW98Cxk4wAQf1MUtQse0xOywMMHCAwQswXACBCCcUOEILMFzxwhDA8nQCeRcswsojm3BiiSqq8FKIB1KEwQQTKNmRySCD4BgkWRuZcYUgUhp1ExN3mLHII2c4YgUT2aalRBiV2GHHJJU8MklWBYN5hhVEUGmjJTVd0aUgYC5ScCCLDFLIJ70MU0wxxhizGl7K6IyaoD07I400egrtZ2d+Ek3NM0kzs7TOqtlMs6KvwTb11LLJRnXUiL42m9W7eE1ppbeILfamsMDyytmvqP/d2yqpoILKKaWaOkp00aEKinPTrUIKrajUugouuaoyCQMMSDAfBhVGcK0EEtR3geL0LSsRBpULaEJ7CxDhSAQStGDCfdiC7u0JTZxwRLYnvBARDCdM0MIQEBlhhAtGmHHDHZyEsQLuZpz0iBccc1UWDGKdEUrKi+Dk4hlHHKHlIFo5EsodOZrFhAubsOI7K4sMUfAZQ5wRyFdfjTXWGZaUnEkmNYUZ5peOPCJKLlnbfP+Zqimzms7KLL30mpKWtDYlzRn/6x8yjnGoRjnKar6gWtUc+EAIMsoXv4DNL2Y2jNZsrYFWywWlKGWbEdqiFiY0odnOljZa0epvLlwFKpb/MzflPEcUzPEbDFXxHVLoqhWR6EADNCCBCyzgAhxwHAdARx8kzmdYF8mPEY8Auv2YwARSjIAJRoCRCp0AWzF4wSJioJAkcuAC3rrAQorXAoe0wAhNKAHt4MgE6VmiEHfQQfNu5LyxOCJMQAFfE67wvR9N7w5ZahFZhmCER4QiFI9ISxNccITm5WiSi7iCyIynvvg5ol87eWRNGEYKWvQig4qqmc0UaKZVrrI1ZrofzRAVQV/UxlIg/BouvSZBB/6il778ZS8tmEFTnvIYsYxaBx9Fm12I7YTOrEUK05ZCtb1wVi3829tIoc0Yxk1u20TFrlShTVHsahIdyEADJGCB/wtQywL3IZd/HIefCVBuWUXEQBMwUB8TXEEClWNWBBZwAg5wwFoniAEGCPqtEUDOIwQdgQnCJT6zrM4FMLAiDKIHAyts4o5UukITbFQwJmRUeVa4wyD6CKU7nNQpMNhEKKzwAhcQgSstCGkTHHEGcRnvBSDVCkhD2jGHdTKUJmHKSSahCljsIoPCEIYGF3VBZdqCFri5am6oiTZawGIWm6KF13AhVlzk0mu9KCUveyk1CA7jl8AgpmtoZgwFMqpmsoSNbHCJi2aakBa14CraUmhNtV2zVm87bDa1qdhtlsqGoyBFd+KlHVUQIgMZ8IAGjiiQCTSBCP4ZgmeZxQEENf+LWVnkwAIs4KzNlpE934rQRIr4gtFOZLQG2QCERoCjF3hrjS44gUVNAIPwCWII/EGdImFwlK64CEdGuIMRrHCGhIHMS4JgQnQTZtFEVpIIYpmQk6hUlkFO0kZcSZlO0Qumt5jkEVcqRCZaEQsTjnUXVpWFb4BDnP2aQjjBGexg14a2v9IXF7UQqy52QVZd7tKBEBTm1JB5ypktkIF4ndTXxnaLv2pqmp76Tai6KeIRy3A5pwiOK14xC1fUqhWXiIQiulCDFdSgAQxIQAMasIANsHMCLxBEC7A1gWQpq3IWQBAGLLCAxKERAy14gX1Ei4EjUEiLGElcCyCAgQvwuAL/VqziCxxxhYaMwAUSGQEREjKCE1zBWmZ4UFLmaIkakaUJcMkJShMmCCtM0gw8Yin2IEQEF3zFuzOiMk2rleajCHIIZgDfkyyh0z5SeicpXRm8WiErW8HihcEZFXKOE2r9BudtHv6wV73KKa+a0Ba3sIWlcNlgB+OVgoxSlDKegQwP3tJrudDwhjml4rWBWL/ECXV/dyOLWdjmasU4hs6a8YzOaGMb27BGM5oRjCwcgAEHUEC3dbyABSRAAgvILQYEOQLVDutxxJrtbB23n9Hq0wRnOMHiirU47y5Ln1s0CJcNAq4NRMQEL5DQEBhighOEC7hQMYIOzNBRouQUKY0O/0snc7KJOduoKEJZWChCUryxTJIrOyJL8bxLBCKIzxJXACmVm9ClnySP0jNHbx8t8YlWwMI3s2pbqIxTHOCUYr/AoWYq/paKT/lGxVhVNS0wdYtlVmrWu6xabPCqDGsow1G0gfWlbGPVqyq77MtmNqTqepdcP8Mz1bY23ONu7b9Yo03OUIYuOqGIDyhAAQk4QLklkIDBD/4FCb1AtSwwLMmtebQmmMAJVFs5DrzgzBhYBBEgGshiEWsEL2jBsubTAg5UIKCQG8EG2uNkDgQJXJD73gmK2wImDEIH7AuDdIfgpSYkZBGbYNIgQsEK6cIlRyifnvK+x/Id5aizZFmEy//57KJMWAJKW5nRzD25E0mDqWSU3sQjFNEJrzablpYyvy2/jpz1k4pUIu4vcHjjirPjJuq2ibXVP/hB2jzQalXNRTNAwzMMAy3dHwndX9rV1c0sA5tYw9t1QzfMwzxAIAXC3WXwSd0hzQAZzTMoQzHkwit8wiW8gQb4SgIQywYMXjyhB+hNAOc1S7KYAHqMQOOAzugR1BUEAnq8ToGcThOMnkR4hOFR3n6g0cGNQE04ngm4wGjBABFEFAwIyRC0jwtYQiywgh1wwh24QBikjCC8QCCpj1KkxSBYQb+kWXk1gRXYjnQ5THERTCCQxYz8RCDhiFF4hZUYhaSFAo2kVJj/qMxOgEkfnUQiIEIpKOChTI1r2Bps3IYs+FeoMF1vLNtXVSJukNDUpd/XgR36VYotyMb9EUNTSQ2i0Iz+MAO17QUFriIFbsZhtAlpREM0lEbP2Emd2EkqboM2WEMHDkMumMIofIImJAIFkFvg+RNEYQB8YMBABdnk3YfBbdm1jJsFYE4EhAl6jBbklUsEtAdBBdSwcIAUJU61rJkJNAErHEGZFQ9Elc4LGAFJiUS1qIAdPEIytEIh2IEOeMCL1NlQmJfzWEHubcR02U70xMQgWAkeBmRNVN+NAOTLOUj3rIzLoFQfXVJNaA+8cMIjcUInYIIswAYsxRLNMCLV+MJt/9TfV3HY2EHd2G3KCOWCprwa2NnSAfIf1aCSMhhTKXhCLrhCKchCMajiKvqFNhCGYZCGoDADoagJavzPUzqDLAKNLMriaAANmwxQBx7DMOyCKYBCJ2jCJTyCEhBeBCTAAkCMuVXA5HBAkNFHFnVefVROeghEgUjaAtDT4lwAhSSUvxXUlvkYuLggQaFRuJiABjSEFPGHWAzCFlaLlawFFHBCMkzCDZQADDhCSFlCSOXIjcQO8zVfkAikEWjIIGzCwECJIARk+vSRGh6BW1jBy+mEzaXP7/mhTjlMKKiC8LHPh1wCJtgGMMTSBAGDJ8YkctqGqk2dppyQqx0gCVlKTf9yYnHCBoXpz8+ExjVUGwTCHTUMgyzYAgHSBjJYQ1We53n6zFISSlMyJXsSis9IQwYKkM4cAzF05S24wnOAhyhkQgkM3rip4BGNW0EwlJPNpX+wG+RUjucxy5ElDkHFZZLRhzZSnkbs1LVcywZUQBNYQguUQAmowHNF1G85SCZ4gRm4QFdYQRg8QiT8wSR4QQmYABHcBEyJxSIMRWetJleAlPg0wR3o1B1k5iYwAY4AZMuBDGyCjFsIwsBshRHAhSUEAytoSc5RWiZMQiZEQigEw+AkgiSEJ6x9otnpxiTmxrKlJKd8lYb92i7UJKT0n3XWjGrwzDQAxl5I4DzEw57/SiA4QGBfcMNgaINiXAMzPI0xKAMsxiJ6RoOauCeh+E//MM0yKEOl9g8COc1d0ZJV+Vfc2JAofIIoxEoo6ICvHACqjtsCHE7jnN6yGB59BJRAIEisZiYMyJt9yKBGFAQRvIAFFNRADQG2NAEYVZ5wiUVIMEEJuEDwpegQlEALCIIqJEnwnUHtSMEW/AANRNwZxMAa7kRYuIj4XIFOiYX53IglaEX1KQyfCSJSiM9WfAXKtKFX+IvvQF8wdFRKqVcnhV8hcAIvOFIiGAIo2EJ40pKZptiHrcKn4EbZXSICXg2j3AwyqAm1Wdsq6qnGxgM4xEOgZgPIguxgYIPIDkY1/wxqaPAJ0thdYaSnAUHqMjCNMjTD/qiGAi0QXtWGmerX+iFH3TCHdoyqKqwABZhbCgLeqroTWhpRfahe50iOQPib4OXIC3AejZZRQbAekjmM8/QH5XlPQhRXFDKSEaxIR6lAWSSRli5CE2TCkDzCWFaCFxTPFYSBUgyCGfiLIBCBl4DWy6khETDBm6UrVvxITvTIyuRtkL7cyRzFjRAM76XUTDyCTl0aRQZizV2JIBRCJHjC/cVGVbUkbriCw6LdBKESMsTsNHwGd0YgK7JiX4QsNlzGZcQd7QbqyJJsNmBGBjrDNViDNFyDnVwDVgbQM7inpirKbCjnbgTd0I3YqP8cB93UDd7U0KjygQdUwNIOmTEuQAuMQLIMWTcShLkRBLLcx+EsDjkWSwtsgrUkUeJAVH0IYQsM1AjEThNsQuzgrSXMixnoDu1QSUYxRcSxbY5wwic8QiVYAhGcgBA8wiDYLe2JheOeD/k4zxjeQShswk/chBUk7hksTI5SGRHYCOQ2j1iYQZKwwpwpRckcBYtUWpi4z0uAZLMZZ1UBZSm4glXdgmwMw9ZtQwRqrAS+Ll9ARu6ebO6C7GVohi5SxtxBsTYEKjeAbBVXxme8CWlIw9JUavJuTQGOkMNOYtAJ3XCcGGLBTTeVAg3VjXWAZR54AAUIUfcOnuAtQHkQGTRBjm/4PlGy+BNADVSENHDlmBHoYEt6JNFARejnlUUbLVIoFAIchQHthIUJmEEhKIFQBIIjJEUmhAINSEFKXQEKBAQAIfkEAGQAAAAsAAAAAEABAAGH7cOk4raW36+L1KyR2KR9zKKFxaGGw5yAy5ZuwpZ3v5Z5vpJyu5V4t5R6u5BwtZF2wYxguo1ruI5tuItqto1utoprtopntolls4xws4hps4hls4dksItwsIhpqolxvINTtYNXsoResYVjsIJbroVmroNgroFhrn9TqoVsq4RlqoFlqYBkq4Fdqn9dqX1cqX1VpoNppYFnpYBlpn9lpn5gpX1kpHxjpXxdooBmon5jon1jonxgnn9nn3xir3hKqHlSpnpZpXdTo3tipHpbo3dUonphoXlgoXpdoXhhondYoXVTn3tin3pgn3pfoHhfoHpcoHhcoHZgn3dcn3RXn3NQnnphnnpfnnlenXhfnXlcnndannZdnXZYnnVfnXVcnnRenXRgnXRenXNdnXVbnXVWnnJRm3lgm3hcnHddnHZfm3Vem3Zcm3dam3ZamnVZnHRamnRdnHNdm3Nam3Jcm3JVm29OmXZemHZZmHRZmHJamHFUlnRaknRelHFYlXBWkW9Xn2xHmW1Ll2xMlWxQlWlIkm1Wkm1SkmpSkmhGj2xVj2pUj2tQjmhSjmhNjGpRjGdPh2hSlGM/jWJDiWRMimBBhWJLhV9DfmFMfl1HiFo4f1o/eVlGelg+gFMzdVM7fE0teUUjblI/ak04akozY0k2aUYuZUUxY0UxYUUyXUUzZUEqX0EtXUEvXT4rWkAwWj8rWj0qVj8wVj0sYDkgWDomVzonUzorUzkmUjYjUjMeTzkpTzUjSjYoTTIhTTEcRjEiUisUSCwZRC0dRCgVPysdPyUUOScaNyMVQCAMNiAQMR8QLB0QMRoKKRkNLBYHLhECJRgNJBYKIBcMIxQIHhQIIhEEHhEFGhAGFhAHHwwBGAwCEwwDEQkCGQUAEgQADgYBDgEACwkDCggCCgcBCAgBCAcBBQcACQYBBwYBBQYACgUACAUABgUABAUABQQAAwQACgIACgAABgIABgAABAIABAEABAAAAwAAAgMAAAIAAgEAAAECAAEAAAADAQAAAAAACP8AydChQ2YIiQILWrQAUkJJmTqBygiq46IFIUFDhhChQceSHkN6iBB5IaIECxcsWIjQwLJECxEbQogoGcJkhyyqcPnqhSwbM2G0cuWqdWtVliFUiAC5AQQIlTpKmgJxIVJqyoozS2woMbWFi5IsSpQsYaKsWbMiTKRNa5LFiBEh4oaIOXfDhQsbNojAa9dCBAsT8IZg8YKIoVKlWuUa1qvWq1aQW61aheoUqsqWKZsSJerU5MmnRHHiJMqTaVGIS40aNRq0LGfZYmerVs0Zs2THjBHjpStVqFCbeFlrdgkSpF/x4HHTdq05NWrWokuPfu159OfWn0+jNq1792jgwUP/gyatvPNlpBLxMZPDw4EDDxo88JAjD6NKmmb1jO1N27RmzDhjGzPMkKFHRknQkEABNwwhlRJKPFWGEiw4pMQNSRBCBheW4OEHHSO1wEILJr2kVwltiTBXViIC0YEMnuDSC0/dPJOML0LdUgstd9DQ1VVAKOWCVEqJGNZJL6EIVlhimWQSEUq4YIILVLZQFhBJZKlWBjTJ5WVecWlgwQUa7GVXBIFZMOYFFoTwghKNjKIKLb4E0wsusLzymGSgfYaKn6d49tlko5zGmSijqDaKKZgk4okpq5zCijDEUEpMpb/wZkssnMaSCimkhKILMaHwwQckysCjDjfYNFedddJh/2cNdrRi592t04QXzXjkPVfdNdZUowskfPAAAwrzeRAfBzFEcQgmmogyTDbdVNuMbcoQSKAWBUGRpQgDJACEEnU0RUQdiEQ5lQs3tJAEunQ00sgYZNyA4ohZZTWiCy+8wAJeFmyQEgsdPJBILrsEM0wyDOeCyy24vOLLIzQYCdaQIlZZEYr3puTSWC0o1XEJLlBBhZReYSWCCxMCAROXMLFEV15gjrDBmDiz6UAEd/UswgtUBNKIJ7PQicxQsCQd2aB8DrrK0k+vstrUq3myqCqLmmLKKIGS8imopBwqym9kl71JqTzwwMcl03ADzzauvgrddbXaiit43kVza3jjbf/H3DXaaFONNseUagYOOmQRw7EPPIBCDItYgskmqDDTjU/KLNNMM8soo4weApGRpQsJDEDCuOZKJAgQQ0Q1RBlJsMCFIHo0IoUWKB050wYanJjSQizQfAHHEjyQQyu1KOzKJqzohAsurPjiyQoKJclV7hV5rG9Y+Za0UFPZ33uWWiullWXveu0uM810hWAzmSwFHELPdl3A8whUWUI0ncP4UkvSAFwaZCbTtFY8hoCS0drWEDM1Bp5iM6Z44NiAA5ziXKI4xsmgBiGRNlNtohve+MbfgKUdutVNO7nSlQr3titoROM5gfubNqwhOFlw0Ax+MEQbZAADDjSAAx44gyP/JhcKXDyDGZnrnOY+J5CBcIEOJAjXELKUBDrogSBTmEK9iHCDG7BgCDS4ASW4QAKO6SV+Y9qKSvQSl5LMhEQW4AAHRhEMhQ1DFrvAhcP8d4tZ7OAGVBKLwJrkpBL0Li1lmUn3mrSS9I1FLSQQQQYmCRMWmEACFciAI9l3FxXBBCZqgskF4tIzntmPZysb2ixyQYtVPA+AsISlnvQkGQPWUk+R8ozWRsGZUyzqgaMAzSmAs4libuKCxlGPqZbJTA94IG2p8EY84hG3WZ2wVnlToTZ11Qy8RSdwcLsGNwA3m2SE4g+JeMQi8MAEGfhQPjDoQyUwgQlR7CIZzlBGNzmn/4WBDGIQdCAEHQ5QgCQoYQh0qIM/RVeHJLTgBlwkwQ1oQINBpGAlGiCTmtR0AbDEbDAuMSQLNJAACjygEjopBmN8gaPn4YIWwDDEELAiJt6lMWaHRORaRMA9scAkfTcrkwlIMNRJajKTFajABJJqAuH1jC9qiklQ93KXCPzFqn6xAE+JYIlRzMITm1iFjmhB1liaNU8GnOUsmwZMREVQapAKVARDccG6IpOZeE0bD55pKmJ4Q5q/ApYJayUNXGVTPONR4eb0Ng0aMieG33jbci5ni01AwhGP8EMOUICC9zCAAzMoxDwvEQphOGMZy4hGMwTyzyuCrgMDcEBGCHIDLv8MAnRTHBIRqMSCCkhAEC5gCUsa2ZeY5AukWrGAmBbAAAz0gRZ23EUehYKwVwyDExVTiZrmghf0kUmRiiQfeHc3Xp4OtagZqMAGIsmlSVaAqk+N78zyIsib4cWqWNULECxRilw0ihSwwEUtdqQ0AKr1wK/Ik54UzApWRGpruhTmKhRYnERAwsLGKZYZzMCDDa+Hw2lzpgf4oIy/xgNW2UFh3lKoKxZDY3OJ7eauurkda2wjhoGbJjy+sZz+MEMUl02EDlPAAAW8x3E4wPAlWMGMajRjGnq4wT+tCAUotICgNJhiHQShBURQQnRJoFKQWGABCjggKhVQrnJ719GYqMT/JDOpCXhLsAAHYAAFqgiGL4axizv54nmNCUYpZBCWDUwgYD0bU03DOxO1cEwEanbjicQyVBIYVb3pTa9e1JLRuwA1JiNwi11W4lMvpREveAGCJlSRC5aydMAEliWCFwzrpDlmrRPWWisE9ZmtAfkPwEbnH0ylV72CWK8NaIAHINEMbYDjxCmmFQtZrCtevbgZMeZbNKSznBvneJrq4DE3uNGfX1ziD4bAgx4ewIAiG0ABGPCAGRRRiUqEohcCoh0ZmrjlJJigAB0gAyLoIAhKDEISdJAEIspAiDK4QE0acIAGCGHIvIgJL0bymJJaIpYyZoAEKciBtIpRjBlN12G3//AFMLKQghJMYAEJ8JIinRTesmjFJDfj3VhmXhG1uKsF6zWBlTJQlvTJRJGjhkkIctY7sdSEL54GSx2IBgxkICMZdrqFLGAx4KTJ4utgD3vYEXwZVIiCFIHyTNlRQVZRDHvYibhgvSHxdrwuU9keCEU2tDFN6Qh2OtboTuC3Dfjo0KYas6GNYaOz93FzYxvjDmfcABe4bBRjExtGgyHcAAMPcIABBjgADNYwCSKuIhgISoJAtvwQmE9BEEkYQu0GcZEMUWipEahABCQwoUMasgSD+R2TxDJcFJWxAhpIAQ0sYccZ9WIXQnl+L4bxiJa/fAEcU9JYyCJ0tWyFpy8J2P/6ljSioT7USiZQwsIzWZH1OZV+G4Wf0w3Npo5yjAWCKMUs9lwMZOzkFjoCQGI3gF/3Cq7gCqwwS6yAGWfXJ39yGWQVCiAGAzDATHZgB3bXTM4UC3snTdZkTd4RHYZVDcEyDdVggoeneOCxOYvVWI6lDZDnbc1hDZP3eMHiDK/wB2aATnvAAxzQOAXwABwgA4WACZxQCX0AJQ9RB0soCIjQAgVAAgUxBF5GcCYAUSJQAQ4AGGoSAfinARnQOwGzAW+hcSVBMxyTAilQAWU0BH6wGIzhfK22EzwhCjJQAhdQZ9m3h5SWSOkDZ72jAS+RVCWhhikQSS8zSWXBJeTiAn3/sWaAcWjKtRcZVSZislFapWhoiAifwGrRhQuyYAv/8wpg13UGlmCv0GCquIoPuBqScRl+siMSuFco8EzFZmy3yGHJ5gHEMDjeAA7cYViGpVqKd4KHh4InOA0Cwjma4wyMtXfZ8IKvMh3RGEOBVw3EYFnBZgafxwCNc2ecxVlBUgZlYDIQwoRKAHMIIjpgBAQvMQESgCaAgSYTQAg0oAEkoAGGtH17OBYpMVEtoFUuQAY4gQxxOCNz2AvCUAy0kANAp4d8+GhI91Mosmg/tTskAHIqYEmTtAGaJgJElYWIRiYXMAH0OIlswoUTcGgroSaH9heHhAieoH/AoDAzwnWw/1aASUNLrbCKPtlgqehgZjcKAzQoqLAjnlAsx2KLt9iUyNYAPKAM0aANvxiM35E3ixUNneM5SYREXIlEDMMwxzCWx5AMnqNEqLUMLigrh7d3MxSMzaAMvbAJwGYHPQADD4ABBFUABXAAFEACXiEVRLIQIhCFYTQETAElgBGPJolffpEEekACI+VTEWlJA9NFEyWQSfAEnDAMdjIjOEKHxKAweEACG+AA2MeH20N8OaUBaXZGLPAUSaACKbACamibl7Ze6aUB3odRYrKSwBmIK7kzGyUmEYCaVtVRIEkImtCJq/RnO0JWZfUYpwg1TzNLCtaTCeQZkSEZDUYLsIAJff/AAyggRxQIAzjglHrVeckGCczQDNbwV9+hNy0UHpuzlcqAG2HJMMVAliRXDJdyKcVgDGTpOcdwltumYiboWNVRWN3hDc4AZH1wBSpwAANwoReqAB9XJQNzJF2RAAmQAuySEkSgAXV2aDvjAA6wkhGgApKAIWLhAhGJIiYwIg+FmVzCAjegBYuwZ87najNiDMKADJWAfBKwAG70SZ9USGgoFimJhuNCA4ZIA7aZAomUSZSUSBjlklYlienzm2VyM415nGmkc4IgCZTACXLCStJ5VklTVrEknWUFa60UQZChNJFBC6dAd5slR+F4nhSYnmlDgc6UbKHgDE8mn9W2WCz/yDnKMJa6cSnCQCmTWqmVGgzCgKkCGqCXQqCegze3Ah20wljg4A3ZgAuQgAMGEAAXyqoF4AAdgAFKkn0kOhUWcAASEEgMEXELUGe+qqIOIAEZAFA0UAIWsI+PxjE16hVdRFEV0FFflAWmcJCuthPHMKSlkI8S4ACKNFzdI1x/qBUTuV6HqHwtcIgd0AEk0AFJhUlJxSU3k2aRGJxrdom5Z5orcZwrulS+hUnkIgiNIAmrFhRySlZCIZ0ulbAK61IOgwu7tgqxZECrQAuj8Ad9oAM/6DicBajHQoHG0nkeIB+yoE/VAEIz1qj7pDmckxuT+guT2gsAeAt5NLPSJV3O/+d8usALOvsLBHqgmqM3zyENwAI40wEO4HA5q9AAGBoArHoA3sgBgkSrKDEkpHMA+SgWKQqivmpVO5NJNIAIKuBT/NgWA5MyLEBRxHm2MsAJeoap1eoLyUAMw5ALR6ABEiABG7cVSnIzEHdGM2dJL2MCKvBxlZaR6UoBwppeiLuSSHWJh6ZUfOuSE7Az8Jhm+tqrwRqsErAQUyAvk8AJpmE1heIJiDK6pCs2YkM1q8EZU9MKcKo0EysKfPAHaMABGCCEnOVMKACoHytiyiYMx7AMiNcNLJiWqNWot5EbxSAMv/ALz4cLefQ8MQsxNnuzz7cLvDAjv0AMY5kMqbUd5v8hWG7pbEc7DH9AUK0aAAdQAbeLAWfRFt8zRS1QAQUgAaYpARugVNsKrLuHSSSQSYRwAxw3c21xLwrBLiQCaSJAUUdgCHVSRw9cJySXMFbwAKipFY5kEvmoXFvxEuSzaflIVET1cSSgAhm5ru5FAR2QaUY1SWBoAbo3AYG4EhmQe0mVVEtlASpaZ8C6oiQAmZ7bCH5QCETcCItgCEZsCEqsxIvQxIZwxDl0xOhUBWawB+i0CUHhUm0KC7kgConQB3uABeG4sTAQA+mJAzgAqM70AHzQn8fQDCeIsiyIqAKSvGV5rZkqfXocwXXUx3Y0DIAMyMIwDMWQnwEyOIHzV1T/WS3e0A3a0A3JgAkcoAAFYAAFMAAFYAJ1kAEvYiUzwQLgowRclCUkcAAJEDzbeqTbirnAKgEUkAESkASCgI+FFq6z2qFhISYlTANPgAez0LYs1bbJUAy7MAyQ0AAwN4mQplUZybfQikgibAIsbGmTlJGcvMIUQAHvysJJhbgUAJzb+sotnAFmdrfHebeZ26s87AAVcAN0MAhGrAd64Ad+oAe3Jc+udUUeQs/qpgdcYCB4sAZ7AAM6gAVWjMV/9jwDBp6wQAubAMZwsATl+afnKaiLQ6jKsgljmTnO4GT3qbIsSCD5CaljSQzO6z+ABpp15Jl+HMiBnKnNSwzJgERN/xYbMUQtl0MtzMAJOpABCWBkBhAudUAIgrsChQTK5gIlu8UCElAA2pzKvrrOwYq4vqUBiDCZhlR8HJORfJgXh8jLawvBmFqpwzx9ooDMCfBTYlJejSYlQjfC0qzNSMXN6pqRvsXOcl0BZqa5aNKv7iqIJdABPbx7rbzKPFxnK0AGg4AIAOXPT/TPZKAFkk0HXKAFWXDZT/AEVYaYR7ADObBZMpADZmAHnABd0guA/9PQlbAHF9gDE03RHssDOBADMVCLzuQKG00g+aRESZSWIk2W/ikMveALM2tyfXa9lfqfJIcpzdvcxiCWakmDs4I3tSEKVYACWmhkFroAhEAFIv+wAjtQIlQyJE0BIUAQFreaAMD6q4ftAHKNzq0Thlk9aYVEmRW5AWp4A2SQA5NQJyzlsnU0zMLASiiAmjMHFmIBuGnxEkOniOT8rkj1rtk81+l1w3p9t3mte3e7rRVQAhmAmpqbZui8vz0crC0wBUPABVxwBJL9RC2eeknQrDlAUc1KUTQQ2hyAAiFnBqKQC8Fw2rbwdbDQCn1gB2ZQBTpQnnIERLvLsRRo2zywkLntlVx5lmn5qGSJGwIq3DtRs7tQJ5lqqcRAcgS6vMybKc095mWZOdbgQpzjDMdACjwQAzPwyu1moRJACIEABDSQA0dC3uYSFSfhFwtwAL6q3qz/3Mrtuq0ZUAaWFsIdo6Micn8pMRMp0AJh1OfQpb1kPczJYwfBSjJQct4mESQv0WjQ/OjuVc2rfs0ofM11rbgToM2MK49qAssq6q4SoCYjXuIqWgEVEkb1cgNPMARTmBGIyTqISaUrQAMqUBYrEO0yIAMY0AEogANmMAo+btwAKIqnsGFIrgMzgAIYgAFy5AFjPMYilggkV5a/bZZVHu+50b1iiRtte7294LJhvu+VWimW2rxnvpAMozkupDnmZAbo3gHZ3G4KsABAQAmEsBFuwDFeEZhRgRIRp8N9qc473MP7+/GbO1JhWEZluxTtcsBDgiIqMARPoOI7IAp6lu+V/8oMx1AMthAMmMAAE8AvRJAUKLEQRHDqZpGRZUHNqk7NWKp8N7AC7DrO3cy4wMmSGsC1ub6imltnJJ7r8bihJpEgIJdlE8UuXpQS0X6IIAdJ5UqbeZnjOlAKe0aHu9DttSAKOqADacxZtmvu5x6OIuZ587EJzEByYRn4wJ3lBqq8bowbxSDgmArBzet8g6zcy+280jcM/74wNK9PNC/nOW67FNBuGPDhIjDUDUUG5Pc9560SKqrDC1AAIJoAC4DOvo6adRYBGSCjZWQSvKWjmMkUU9EVN5oRMjAJrSbzk8oMyEDMuDAKGIC35EclPCW2M3HC6IX0mfauJUzNH5fh2f+8VFFv66tvARt+pKgJ+yDOv/GoJr6VSWb2ytqMuOmVe66czcBKAVivoo3jWcZTCjUpFAotnQBRyQMHDhgeHMSQEANBFCg8PHx40AMrZsWKJcNY0WKxYx2PYUx2rJgxiyExfrQ4bBjHlMOC+QoWc2UxlSpjwgxmc9euXr5QCvPFicOBBwwoGHyAoUOCAwt+RCJUR08JFlVdECHiQuuEBRq4RnBQoOkCB2QlSHCQVm3asxVcsGhh9caNqixu0HBxQ2vct29vDJmbZZavXr+ECRvGLFmxXqtoyahQgmoJESIol3BBWYQFziYyVCCRgUSFDJ8rUPicmgSJDhk6tC4d+zT/hQoTItwuW3bBggkO0J4l6yAB2d1pd5OdICKC6ApsKTAwjtY4WQbVoStQ4KD6wQIGFDzQUWqWqlGjRJ33lL4QwqLVCyYkyAHiQw4P5AdbDFIxMmQbP4IMyRiSNqLJosN+2WmnXnrZ5ZZaYHnlFVZYSSUVVEgh5bxQRAmlw00+BHETTC7hwYACsivLPRQoWKAABH7IJJJAqCDBhRaAIAIIIFjIjDMNLMAtgQLWWkCCCaRjS4LaKrBABK1uSAIwrapqoQUaaKhSqyEAayGvu1IoJSaL+KMpJlR8qaQDHy3TYDIWqKpqgw1WWy022UizMzY6R8uTAtQqOGut3miTgDYK/0ZL608WiftNgg1EcG202TKgjbRCKSgUPgoc8JPTgxrAwIADFGigEE848QQTVTlRFZNKljgoVrKQivXTBm6t7wEzMDyPQw8/vCTYYDcRtlhjj70kRBA7ZDYUDCtMxRVXdOmFl18MI4YYZZJBxpMGRlXAz4RQ0CEGDhIgAIETMukkkkjgdAFHIDKTbAPOJpjgtAMOCPRI6c5SkkkLHnXyBiKUiFKvKlVQYYW4uvQyLrhoWCGFSnwhTCVkbuoFFlw8SUGDyiqTDM6RNTONtDrxFC000FbrgAQTTKBTNrQ+qxTJ4KrzszkGFIDuKO2qSzS01Jrj1M8F/FwUOwYOEOtpBf/2PUDUqgcYwAADlqhE1Uq+niTsSRaBWmutCxCLanCfHvWABjxogAe55eajbj4ggWTYDkmJJRZbdOHF2sOEIUbAjpRBnBlmnHGmGcYff7wayavJpnLJs+kmG2242WYbbbzxJhcYquaZAg5QgAGGhoQkIIRIOomxhBt13LGER0u4IIIJLthAtLB8883I3/z8TAOCReDxr7uqrIoEEWRu+Mor34SzhBWuKGUVVGDhfhVVTDHPlFKySKGDNjMQGfm3qIctz9DqFI1mo1+TGf7PWmP6LD/Rgs66qatWm9lMhDYCYg1tWEMg1gKwwAUCAAABcGAEJTjBCaIgEXmDRCUg8Qj/Dj7CECZqG3awwx74NCApBHkILBZTuI4kQzEuVNziIOeMaTBuGjfE4eR0uEMeVsMa1rhcNiSXOW1o44fWqNwwzGAiEY4rBjAYCAlaRIAFROITmcgEVWgHBMkY7wK22d0GKkCaBCTAAYDKl/5OM0YNpI9gVapSyZwnJxGkIHorWEHJ5JiCSWDCExtKDyc+hIlR0GIS9COBBpgkAh29qTJ2vNMYJakWJPmmUwsYjpAKkEAEMpCCnwTlAxkYAE4O4ICmNKVYCAjCqv2vambLmgEeUApOJKsSlwDbJDxIq6XFaiHvIYgJ7fMQHlzEIy3ECOKUwYxlNLOZjouGM6KBw2lO/6OaPfThEW/4Q2p084hHLOI1rkGNaFRjGIn41r5+dronooADr1kA1BIQhExccX2WYYGcLICve+kOUBVgygIApaQjSXKMG2ijnD7TOzv96CwTsMBrXpMn0/gpC474GiYs0cFJOOISolgEClKwggxUbGQjS8FqVGA0O83GOGXM5NLs9ByoJZCAN8XpKtW2NuyMSjuc6kChYuanmLVmNPlLy0IwsACikaUgSdlXA/pAiw95Ilhfq0TYDLFU69QqKQZRyK3sgwIeQMKFylym4tDqTLY2w61vdWs05DpXa9J1rneV6zSoIY1u9vUa2ogGNdzqjF1A4gGvJNUDUMAwgkhUOP9ou4AVMwFTqBFQbTdVWwIemq8lrXFgnOFMBiSAQJzuRgIRpdSlAGacfcHgD4t4RFYNsYhFOMIRiTgFJwwx0g40zAUWkEAENmC91HhGZS4z1HQKVZZCAYxpSWMapoqjG6aqRWjVAVrQGEAW1DQXSRXoAFE3xbTi8M8BGCAeoDIgBRoYpAHVeUQuTmXVS7jqEpOohCHaUyuF9DeYDFAsFEPxDLUmrsDMgGszntmMvNa1mtTEYYQl3OC+dlOv3PhhNJZBWD6g4AFmA9oDKtaBd0r0OWhLABU68YlMUo0pMGXKAcooqAwEb4wAKxSTOEsaCry4jEX6TQXmpMj8rVY4B0D/gSEM8YhGNOIQh5ht3nDhC0/kIAUpKI0JJKDIJpEgvWuZznGGc0a0lDc30V3UcdSMyR8vQAFlfHOc1TIcs0hABIOiFPAk8Jrlbko31i1zoCiVFAA3gBPy9YQoKrEJUXgiq5XoA3ofQAGv9hc+33mAB2LAA1gQmJnLcBzjZPg4CWOTctn4ZuVUvepVG/GHldOG5oqYjRriIg0mrOwmGdBbEnDANaVpDgWgdgARWHFmutGdA24T3LTghi3PdgC+nLOkCHCGZUoS7XLPUm2cPTd4ZynjA/ywiCY7+RCLmEQiLnGKYahiETJAL8A2M6cUYCrbY7RucIxzxuD55jRL61RZ/xRAnEzC2Mc7dXEZ92XGCCxAjBZIVAcqYBROpQU7Y14zm3eTgJ9ZB8DiQZUnNtGKXNACbJHGwHa+qhBgokCYqLMDMp5hQ8kx7hkzd8YzKLdDVvccc5XrRtAz5/Of+zzWlOsFGBpAlsoO4ADblSgKJkoBBXCAAVpL8SdEIIGN03m61F3zvr8OZv1Ft5JcB55vwBKd41B3EVi1RCMmIfeviaIYQZF6BGBKmaSpmS2kac7XCXraH4FWYEf6trJvUxyw7IYzDU9j26drJExZIJ9AkoBRnhNUJbGU67tpPEzd7IAD+MYgMJhFLkJ+aFOY4paY6IM73YmBhhS1AylQXUMG8v9EHCji5qe2HNF7LnTis3roPpfczUX9Qv7YJBe+aEUhCIJei4PLAR1wJ/albjo7KkAsGpCEcCRQcH1TNzeNTxKOrbtGlt347MG9jQUGmhakRVs3eLCEJTTBiSaHzVWb8AVkWAUrwAAN0LsEsJLXWBRlSxTA+5fxko4IYJL0KQF8sQ2AWbuyoDPh+DEN3I2faTNMMjPasA0z8hMGqACvsA2wOA3SMyPyCzGKcwAOUIA1AIZZ8KNTGYWMchU7kD0UoL2CkKgUaAjUOZ2GmAFPuDlPYwb+cML+sImbyIVcwAUHeZAIYYULyRAN+RURIZZiwZswxBvbegRFSIQ8kIGCeI//K/M+saAA7SvC+phBFQCoAkiAIRABzdLADbwNsNAd3bFA0LKAC2ijfYIoCzCek9oMQwzE24CoCxABe+lDe9kniCOLLLAETNAETZADIVgES+gjTKgFZMiFSkiBCmCzK1NAJYE4B2AO4JG8fds2C+wNIuE37XgzgyuOH4MxEXIa6/izsoiAMluAhlsAFqiDFhgjjmMAOtuXByAVsXovUrGDViiFTfgjQXq9rsGBB2iA+hAmYVq50/klFUCBPtCgSQhDRlCEdjTDRIBHeLyteKTHRGhHRsDHfMRHRWDHdrQtJSuEQviDPhjIPMgDOXiDNXCDHqiCGPAAqUsIEqCBDjgA/1NqCjhkmA74KRKgQ6ihAEogAQfQADZLgD7EF5PkpwtQyQsQRNtARIKRjMpAKJYURJp8ycooPN65F64wIxnYRE2whEFYhDHIREzYBFJowlGAgQfQwKNIikn7jLQggRKAwDKjpLUwFEwBFPPzM6bErqkRoZ/pKXDZqf8BmpeSsWIEkgUggBcABVCghEioA0HQAkwSDuhAiCCUvRgwA0wIhT9qtFAYpK/pAzPogTVAgyqwgzVoAzxwTDxASDnIgybYATkwhEPwAz/Igz4wyDyYgzkQgy+Yg8dsAyywAiZggipYgh7QARxwzRmYAYZhmCKUug6wNOpLi6IoCl/cl+9QKv+FIIEhIIE2NAqMVIHwwg4KYBgXnAVLCC+1q7Y+9EPcqDYgqTZaPMQfOZ5INJ4fqYBhlED5YxKBmUARKDzgyo0OsAROYM/TGQRN6BpMEIVheAZfsAMOcADsSIivesOjeEPbvL3XUAiJIrGFIDFKcwCvdBqvipWuqhUA45T4iI+HRAESGCmGWYEbuJEXgAAEQAAIAIS3hB12ectMqIMTFQRJkIRByEw9ULJFyING8ARaMAVO2BBmYRVXqYI4pBVvvBWxVABRmZqn+RmEK0tfRNIkVVIRMtKcctIHeI0Sy4AkqIMbkIB9OS8LvbKMpLpRyQAaUAHSQ4ZZaAQOOEXhQDz/4VESsGDFYTSoPCGNmIEZieo2PKkU2rCT0KCfGksLDpiE/eOEsLGEStCEVXmFj8EBg3CP6VOINywxDrDQ27syirmSHLDUHdiBIzgCTG0DN2gDNmgDPdADN8jMUvUDOpADPRgEPfADVhVVUX3MPugDP2iDNuCCW32CITiCDN2REIAAEPgAH/CBEwCBYoWAEQCEFWuXT+gEFa2DQEgCFhnLGtg/TzAPXxERV2mAAeqOs3HSTQLXmyqlcSXXck2gUULXdG0gUQKAAviqiaIBQRCEKciA5MSAK9vS4+zSpiCBGzABB3iGYOCEhigKgEON8EKzNzSN0iDQhtVSfIXYkaKY/yurmBWgVBqYiyO4gSc4Aox9AjZYT1TRhD/FL1XxhCpchVEY2UEYhHIjt0YghEZg2Sdj2VV9VVFFVTxwgztggyzwWY69EhkQWhUgQqlj1P2ktPbIrq9EUhlTOBnblw89AUD4gA5NFwS4WgL4AFDIBAiIhKcIAkJwF0AYARdQAqYgAT2oBGvtFcH8EEgwgFJSV08Kpbq120+a2wUy11Iyo7KgDRNIAjJgWRogi9cYKTzCIy8bywXo1xV4hVDAhEToAyuQgSegAzIgA1f1A0Ng2Uagrf4rt9Cdu/4T1PwzXdPdxNM93UkwXbmbBFVdBENYT03wBP1j3VY5NFpwND+4Av/WaKcAPYoebdDsUtLeBEsjDSABOpsBUt5vzakEQAAQOIEPwNrqtV4EiARQ+ABA8AEQiAQfyISpjQQqsKIMKL0MGANrLYVeEQUR+QMIgqC6HSVRml8HyttR2ltOOqVSAlcDQpuzGQABIIDcSAsTGIIUgAI9kAQueFTEtVgaUNzK4pcMTYUIGYVTAcrRjV0lMwQ6oAMu0AIo4Ngc2IHci4+nZNBb+VEGECbsSl7ljdtu5QAeHNSMyigz8MapwSlUyl+5FYAfFoD7Xde7DaX4naAAEIAPpV4IgAACIIAk7lAPDdHv7VqujYRMgBFk/QRBkDFKUYAVGARPyAVgIONcSIT/w7IprLGazFKAHtZfGFYbFRYr+aDQGHBNHVgCM0gDO/ia2MoooOyETqgDC/DQ4TqNDsDYiaQBLfhgGkipR6ZYCO5Sy2Lc9sUlR+iB7JMoCT1aSsOun0Eb5DXestwXbxXXUIZSrXnGSshRjXKV14OBbzERuVVXIrblW7bbuU1iD3ViBKBeJ9ZaKX5L8L3iWQCFWfgEUGDWT5AEeTIBsTCjTigFSkAC2l0BtlHlZ7SP02GYGqgBHZCPhoABHGjNHliCKjADO9iDPeADWf0De2QEMcQb/MIqXLLn1yuWVgnM9JivUsiEIOjQE/iBEBCBN7yS1cAjGthUGbgyhn5gjF2B/w6Ip1wrPQ1ShNjNgpWaqIaVpIDzn7i1SN7cKVPeJE5S11TS26zpA04oVPvKqEuoSAVqoCE2YvkV4pvG6bklVw/9UGC+2ihm4iv+hOw95mM25rdk1imoyKcJZUIABUJIgAFwABcQEtAghE6gXX7m5wvuFWxkT/ZMj0FSlWxtlbI2SrMekWBpFRBBa5P9o0HiBEuQhBHw0F91Ac8gAYstH0m1I4aRgRiQgejB1E1VgZT7H7FQAA+Agd99DqZiKiBdUpHuKVfaqR0e15K2rFcSlW/sA00QBVqYwin0hVxwNw9rAMo2Uhgm6f81kdZW7WymGhU+CBR6SBjggTw2g7p5Z/+MWrRN2JBNYM9OAAGextqrrWsmNm4IqFpgFdZgBYQY2QDmSpspuKIymDF0QRsBcIAVK4VRKAWtTo9mETllIe/yBpFh+RDBbJb1ZpZewZDtcYUKQYVRqIMLYGImvgATUAETuJLyiVSIVQGhlQGLzdQn0AIuOIIUMOw4Fqb99DiV86UBjZnFmoEamIEVUIEaoIEacOAV4PCGuXCiFakKJXESMFoS075MU+wesANH2ARTWIVVaIUYN4VN+AMcSJ2BeAhxHucc6AGGPIM92O1HoOexDrlEE4XyOAUZhwVaoAVcwAXRxomYkIma2AgyKYYnzAjFoAkyDgInZmLijuIPbWL/YCZu475a780EQjDfBMiAZCYEtCGABJiZOaenZFaFWRiPZl0x8+iQtiWFVMCQQQ/0VOgbv/kbwAmcX8iWwhEQYzgGZWgmaIAGvrIGcSqibeAG0AGdzGEGToDe+waBvKCBIVgB1ogZfJXNFZABGsgBGrABI5CCLUhVPXgCBRfLfYEDMzhnK/jxHkBNJlgCHbBUGdgBYhfaGABsZFd2AU+d3EOdZ192JjhNNGBMPMjMQpgtcmMyenYEIs9EVGlfkWvvUFAFVWiFVkD3dHfyKH8+Kh+GJ5R3J4yherf3e8d3fGecDXucuKIcZ2hCYBiBH9baDr3vqr1vHzBzrB3zquVp/xD4hCAI0SAAgkxQZqguAEya8wQQgBA46jyfBWAAhAtAgBHIBGBghiUEOk5neW8AB3CIh5iX+Zmn+Zifh5vH+Zy3h53f+XmI+Zd/Bk2A3g8IVh8AhCAYAi5wZALV0gAfcGPfASEoAil4g1StWS1YAQzAxQPYtCcaZ7kxg3RW5z0gSHn04/j8aq1O8vIoj1IohXM/93TX87mn+7kHbSenhVlQd7qnBViIcVZ4hVVYcsd4clqohSq8BSnHmCqfiSznDwCBfP3Id8UhNciZhsm5IZ5Dtb/yhsx5BmAIATMneiX2ge8N1rc0czA3eKD+gHp6ik8AX1DohBHYgCBogU1agf8K2CRKMObxCHlQGO5eDoFMQIZucHlw8Aaa13meZ/7md357uIfol35/oP7q94d7sId4AAdk0APSN3ru/QElIIOUkqg9odhWP4InuAIraIPNNYT+GwQuiOjnUAC2b73WO4V05x7uwfsnh/L+BwhcuGgRLGiQYC1atRIepAULVkGID2G1krjqYsWJrF65SuXKFatWr2rJKikrlq6Uunbt6vXrl7CYxIgZO2bTprKcOZcta+bM57Rp1YZmK9qtm7Zu3pYuBef0KdSoT711AxaBAFYEHyB80OoDUCZAX0GBgoAAKwEIkXyYzYrAB9lPYX1E+tQphIlOoKYMWPFJU6ZZglX/zQIGrFNbrZkgTJgULJu3p7/izbNn7949f/4wc+7subM/fqI1i/5nWrO9eeCeTVrA9QNsH7J/lBmiggTu3CRS8E4hY8eTLGjW5DG0qNGkSZYkNdJDIwUGDKZOTT9l/RSpU6iua0flHRWp8KS+iy8v6vx58+LRpy/vXjyqVKnCy//F674uW7xszaRprOYxPTUDTVDWZKMNN0xF9lQ8DTr4IIQRxiMVhQp2U9QzzjCTzDDAZIJWVl0RgABXdPnwQV0fpqVVJJmceBaMkZAFCiAf+JBJWEAkUIADGSyQQAIVJAGKYGTN8gkIBAiAFQSyQbAkBZww040soUR2zjnrrKOO/zpYeullOeiw486YZI5zTjvvqNkOPZqdds888VQzyiQugCDbibB9cIISShxBQgcd5JYCbimsQEMOOeyQxRVr4OGHIchVMukki+CRAwwevLcpfaTI9ymoHrkSC6mlxmKLLSrdx8sv/fX330068dQMrdFEMw011hiozYNOdeOUhMH2GpWDUS2FlDXVTBPNMscYQ8xL+8UyXyihbHLJJZBAkggf3ZphBg88eDAuChQcAOKSJCKwrlctZkJWJFjZaCIEZml1low0ArJvWEoSEIAABSxQQQIHOLBBEDPOspgADRPwASBrnUVAAoOM4oEw3sCjzjrncKnOOCF7qSU6YpJZZv877aSTjjnmpFOOZpvF6U0xeCSwAAj7yqbnBz9QQcYOKgQ6KA1F0wBcFkmj8aghijwySSWWYGKJJZMYggcW973U6kz/wSrrrNCIDY2uZVujDdpoc7P2Umuv/c034MCtzjdcarmOPHnrnTc88ORND9/zxBlnPFQ51RQ4TB1VVDbVaKjMMcUME4wvvXAE3nmheLLJtdlu+4e34Y477gOll94A6g08kDrqHJjeAAM/outWk+qmVRgwoHwCyMN0RbxWV/WSKKOLkWwV8bobLNDwBIi4UEAZlCQw5Cyg+ICAw2nRFYm9ZxUAya/wnLPxOFyeiaWW7LAjpvrtp/mOOx5zTI7/Pv7YM2E2qrRwVpN4+n8CbbhQhBV0gDe7ocEgOoGIIywqC2zQAx76UIhFPC1qVNMEBi3xCENwA251+xgIQ6iOvpGQhFwq4QdBWD4Rqq9kJWuHO2IoQ3eo6R30uGENY3iP1HzjF6QiRUdIIYpqWatzntuWthKRiD/8QYlKLAQUC+EHPzCxD3uwAxa/ZYYq9AAHMYABCsIYRg9woIxm5EB00hidB1AgAtgDEe3gwr2uRAIYyIgLICAAFncBL0961MtaavQVCPxLAAgIwQUOUAAlZKIOSQBCJwSzGKywRS1f+YS9RrSAYsSjSxujG8jQd7f2qW+GKoOfPDZ2jnLo437e/3iGJS5QrxL5D08nCEIZuLCFFewGNyqgASEUeIQjtKENd/CDBCkItUpgAhMYfCbV9CFNaQKOHfaoxzXrQY96yOOG3pShN29oSnfAsJzkIIcL0fEOfJSjHOdEx8rScc4wlbId6DgnOtNRMnrcjxh8CBcPumUHM2ARi3zoQx8E2i2EdisPe8hDHhBqxYfmAQ4SvWJB8eAGNGBhCTqQAQxwIFIcwKCkJoVBDGQggxooSgs3cMELCAlHEtWLLp0wHsTsCIoNyMh47nKRWGy0LxB8AhRr2VkkeIcVAQQAYEpSAu5wB4qtyCs2OEIMuxDgCXDM4xzoCCH6spQlLcUzHSkrZ/863JE3d6ZjHd6IRSX04IB66ekrSRXLbKhQBzqM4Tm8OVQKhqAFKTwBCm14lB8KYYinQU1qz3ysJkwj2X9o5obS1Exm/iEafuSjs53dLGjxIdrRkla0asKHPvBBD3ysKWWi/WYMW/s+tcKjG6EQnQcAGq4lLKEK36oCcKvgUeHqoApYSANysWCGNGjxW3a4w0C52IPp5gCkYAzjdVEwOg6cNAbejcETbgCEE5wle1mZ5Qky8Yn1AqIThqFEwnIHCLJkYi2Z6ApdQHCCSPD3REldy4hGEIIFKCkACfiEYAojGO65Raj0zSoQshGPe5RjHHMb4VjvdreynlVlJitZOuT/wY1f8OABCbDXa2LzlX1RAZd75QINVrACQ8WYBjc4gha0cFhITbCCzGwmBjmhCU4QebIx24xnLsPZJeeDyU4GLZQ3O1nNRnmzR86MNOuBGX9Q9n7NgAQfsABSLU63zFv0aA2EhoHSRQe7McBBDnSQKBzwQKQy8K5JUVBS7ZoRA64z3elSB+gHcKACV2mqAADQsHTBaL4JBsYsCFNUZEDaXbJRb432hQCf4YgrEfNBgRe9gA0AoQyfUIUqIF09qo4IAkCFF4i2Og9/eOyDI1sHKdVXVrOqbBy4Rkea2vGNZUCiAw5Y14hAAJsTgAAEEAgBAF/gAiXsVQ83MNqhnsAF/ygcAQp0mGKkjFNBSzyTyOYuMj80q9krc0bJTX63k+Ht2XhHOTRLrvKVY8YZLvsjTrH4AxycsAIYBLfMPcgBnHWAAgYYYAAOH0ABDHCAAzTAzxwYHcbPuGbVrQ52ClDAAUAO8omTvOQfV8ADGJDoAACg5YsGkVpAoRc7IqPmj57FUGV0pE/I5r9AUK+NZAQIQxK4qQADkiYSvODyjggBYskXqLGSgGFM+B8g9Grf7Ibr9r2snWZd2Tjk8Y6WvUMc2ggFCjLgRgIUIC31AsEPfjCBCCxAAyVwQR0GoQc9cOHa16bBE7rNBTroAVLHaYSkLijkc3PCE5xYZw3XpCZ6uP/jhtqkIT1sWM7Mcx5+72stOUNfecDRg7PrNG3kaxjOmNWDsvPwxiYgoQg/4AEPTfxDH5bYB0MY5wwoOADLA/BwiB/gAQtHAaZycIY73EGjY2jDFrLghCZIIQtGEEINVqCC7acgjCRAQaDC30sUqGAGJEjAxJa66EUjQOeGseMzngFpVZTCqIBAMKTJAogf6C4TSYgYbBDPuuyLCABJAQCMA0SSzPHcB7gFntzfiSzVEXRDPGgGPIADx5RM3+CNPKhP+rQTCIKgPohGOGADNkyDKKAABjiAAyyACy6ABUSADG7ABkRAC0qACdwAGQwCD/YdtmWbFryBHBheIxzHMpH/myY0kzMloSU83unJ1jukzOiFkziB0xTiUA512FnpjTtwFmuxVhSqXjillj9QUz3UwzwQg7Y4AkLtQRP1wR8Ywh9AiiP4ARswQFM5HAckwii0Ai2UwiQsAaGlgApAQRY0X+21wRqsARpsgRVsARY4wRLYgAyoQAysgAzwBgqkQKCAHwp8HyHOgIyZQBBQAVukn5IsSQgUxjAwQ/y9ovxxwiggWFTR1w/UxSeUAo64iO9cgL+YACF8giTUQR1kwMQRQv+RV9O1n2wElUwtACZQYGZknTzE0AaS0t2EYAguWQlqgy7gAAdkQAW4IAvKoDnaoAvi4BTsHQ8OAh24lI0V/80OQEEQDqFxIJ6kRA0GKSGQYVDKyJYWTuHnRaEWFqRBSuEMVV4+sFaa0AM7eNPedBMVrgM8eEMoJEIlOMIe9MEdyGEh/MFHJtYiLEIWYIACFMABcAAzHAtVdAMtGMADrIAJlIESlAEZ4AEcFFQaYIFxAZdHeVFK4Vl2iVFJxcAM1EAK0EAN0EAZIEJSERK7QMAFUALN1Zwrxl82PIMqNJ5gAEMuJNju6AWqrRdQdQIgIEAChFoEiIALeIgLZMCB0YhMVRUB0EUAIgIlWMImCANl3EPfSGQqwcPWeaCWaGM7mYNnsQM3ZEMopEAJmIAIVABuXMAGXMAF2KAMkuMKtP/jSDYHGTzBDoTmMLEBG3CBHgzCIeBjcljQMy1hP5pDO7QMbKYMr6VV5ZGTQa5MQe5aPCHkDNFDPugD/NjQQ1Ke+uyNDRnnCB2DtkDCImxkR0pRFBVCHzSCIbzBAkxcAczAMxwDKUBCMnTDM2zCATAACQgCIpRBGdABTmJRcvXkEvSADujADKSUSt1ZdhVlSinKDqSAUS5BG0hCfb3AD+xLMJYCMjwDMzBDzSGDKxYFMlhLVyYopVUPKLxfYRjVhX6CCKhXIJhAwbigXgCB2ukOCDDdiNiIHkGMzHnC5qACBdoDlqBDDLHDNaYPO3SMYZYDYjYZPXxDNEBCDIhXEiD/QRG8VNy9wAkImGVuQAYkASEUIeJNQiMMAhcM0xEkTRu4AeGlpmoqB9WQmxLuIwaxDIe5A/uwj/rIpm7SJm/O5kGqTJu2Q3AO5zvwGgyB0xne0DnETTeIAh84QiJI1O4ZwiDwHu9N0SF0gHY6nPEVAAA000lO3BDkImrSniIyYiM+IhYYARMYwSTmwAyslKhW4vbJgCjOQNFcWwogQRz0QR5MgiYUVSYIaGAAwys6Q80Ng4M+w1EUQy/UHCxSGqQZBrGCwrsYRiTUgYKBwiAsgAOIgCQgK5HkEfa83MNYzwdcaCmIgot6Al/OQ5dk2AhVo/rQZjl8CZjgQ7rVgzpM/8Ml8MAd3MANFIENJIESBMG+AEKLSZsLuEBTTmlyFKEejEHSkOZh6cE9NgJzSIIkhCnV/JgzcUIz8ebKwBM7mIOaogObWizLtAyH7WabrtNCph5B/uM7lCHljQ84MAOYEeqjtCOkJOoYkMFJFsDDAcAACB/O7mwBiACRHEkhHIIcyMEbjMEWbIEUSIHSOoETGIERFIEQGE3RyJjVXq2NHYoX5IEiVELjpdosAAaCYSWGMGgyNM7iXIhRlO0zEGvNGUZUAQOCJegzaAIFUIIgZMLbLkb6ZU/7ZcIJgAIyjIIQaY4oVEMnfQyWrI8pxZO6ekm7wQM3GEMshAIf9MAWHP8pEABBIAQCIXwuIQSCEiRBHURpI1DNwB6CHrhBMW2pwh7eJEhC7D4sxPLjmMom7rKpy6zM+rhQC6np7wIvO/Smm5pVGHYWQZ7sQOrDaqFpbbmCHRDqHTwQD/LeIvBeI3DCDSxAAXTvw+FszzocVOUfsg6CHGhUG6ABGijN+l5BEzABE+xA/IbmDiSKDFSXStGADNBAlmaBH5yuLM5CLuSCYZQCgj5DUVRD47wihhxF2l6IAg9rgxKrsVJag35lVVLaD8xlKqIFxPjAJyDDKrCCt3rCJdiCU2SdOvAosMmQnKbD42KJZcQDPHwDN9CNNcQCJNhBD+xA0eCrIAhCIAj/AiEEMSI4LJjGbnIsAu25gRvgwetOqezKLsRGrBJygrfGZu5uscuYA5mUTPACLxhzncimVQ3hw0K6lsm+lj7kQzqwwzdUwyWYQe0xH/Od5qEaB6RYAqTRwY90b8B0b/cmABB8Atxa6CeYL+uqb/uqL6O8b/zO7w7I2f3eZ2gqSnD8ryV4Qimogi98Mq8yKDJ4QzY4sNpiCAMzDgKX7VW27QRb8CvT7QTPwomixfqFyHwBwyqgx+ZcgjOAAwnhGsuwCeW5g27GsDqkBihtwzaMQ5xkwy9swj8d3A40ARqwAaT0wf9OsSXkZZhWyhTtXRQjR3KsZhX/GCfkwjC0Ash+/+w5DW/GokOYpOkYZ+zuxlOuaZg+l9Kd0ik/9DPKgqE7XEZnlQM4/EL0TpFCQ8ppzuxIjgKFzkInBEJkioAIcK56Ba1GIysdvEEeLCIaLAEWYAGjXIEVPEHg7YAQCIENtHQNzMAMbN9RCoERbAEdNmEf0oIv3MIuBAMzGIVUtGRWNiiDDsMAq7PkhPIEv18FU/ArKytbqF8HpwXEzAIy0MIqjAInxF4ikILGyMMOZQY/5GhCkklbbZ2WyMPH4JqWjFDiTIN9bEJJBdQlyIIuWMslUE0jROkgUILsUint+YE4oybsTsqkfDPUeIIvIAMueAI55K7vppP6gKDvDq/FZv9Yx2A2jsbQyqAxPqgMyqoeQedDOGjDJvCANi/0FOldYhmHI+RC25LvAq5XJ8hFUSlM7oBCI3gBHqgvT4500lzBFWRBSkutS780TMO0DRTBFhSHI3itKLSCQOQCLgRDMThDKUdGPGiDr5Ry2xLwVw5wgrVCK+RCMMgyrzZoVTJ1BldojSCbv2QPV9TRVZ+CKFDsJPABJByDYII1Z2hJWROmhnXgYOKaWp9QZEQDTBwDdkcGN1QDLnDCciDeInQzEl8v77Gjl5KzYX9zJYTCeZ8CJ6hCy5RMO4mDOJj4PJeMOFB2ZadTy2B2WIkSgBtzOrxDk+EDnnaYO4g1P6iDMYT/Sx/oQWqDW+Ep1vUWwiyI58IAwonOUpO0yG0XSfXIbTFx1EjzZElfAUozkHHXAJgnN0wzdx4cAtRogiioAi1Q9wAPQzIwgwIrhTdEQzN0QzU8Q4cIsNzWdicLBgELq4I6qCizN3sv9R2dInxLdZPoLTC0wih4AiZUAiSATiggiDxg1j3g2gyV0skMeI62D67dQ954kAcliFN8A95wQy8IWdUkB8RWApUeQjsKAj4yLBLTriU0giaYQi2IwibAAjLMEwiiuDyj+LC3kwudeO+6kMaK0sjcWvqU1TtwVm3ympq4CRzfFg5AMUItdASB5CEcgh9wAoR+AhVshYo2ScTg/7aF6g4eKCKWd5RwW4EVDFNoGrcNhPlRLrcX6EFqToosdjJB+II6C7ozKPCBYHfbrkIrgC0n9Llh/HkrvyIydEh6q/f7xd/bAgP3dA+6pMuNeKUq+PolOAITdQsveIM61M8OVeOmlwmZaJgHCvhxbok63LA4nIOF+Q3gbAMvbMLUTAIkOEIVVw0+EvGU2rrsWlCrY8sm1AIy+EI4oHiLU3Y5oHjIjEM4hEPWX704hEM6yXM7iYzOi8z5iNI9ySaduvGuvQ9l+QM8LMM/wQDzbeRCR5Q2t6MiFEPbfkIIOMwHMFXQrdeFHole1DYdbGkbzHsP0Du927tKr7RLi7kNGP+BF9ijHzzCxHLywA9DMSDDmzODM4w+dmdDMlg3MwxD5dTCLjBDMBjG5KQ3xcdyxTM1xgODtWaVLYM8IKCakCUR7vWBGUBCM3gDOvyDZeTNy8tQjmZ28+faDfla+XD91m89PHz9N3TDz0c6pWRQFUsCIoR/+MtuPnb400DC0zN2KAw71VP91Fc//E/914O92Icg2Wd91qtr2sumaYWsmnQZQMSL5cEDijt39uzJ44ehnz57DA0SJEhPK2TIgAUhACAABAIBImWKdCEIqE+dPn0CZVJPljZtrMTs0cPKzB03dwjRaYPnjBkqgAKdYUMHihg5cpjpk6hSpUubQkWVKpX/FK5kz7p1y5bNGbNjz4oNEyu2WLFgwy6mRSY2WDBgb4FdfIYRlA8IED5AQICAQF8BAggg8OGjk6emiv4k+tPHTxUeqbyF02fPnjx59Oi507zZHbt150B7ZjcaHbrR+sqxO7eOHT1y5MKJsyxvXrdfoTZVYvTokSbfmiwFDy5JEiJExCclV9606aNNtIKh2tSqdLly4sSF076de/ft48ZZt459HOhz4NGXN3+uHDlz7821w4fPXDr7mum9++dvXjRIHjjwAKGEGvJDD4ciqkMQOkpBC5hZPjlhLx8iAWUWUDJJqROUVHlLlUGyyAINmWqaqQcddLhJCJ5sqKEGn3wK/0qFGWSAAQUYYMjhCjT6MMMMO/gIMsiHqrDDjMQ2YcUXZrLJqslqumJGmWOMMYYYYdpChpmLgBlLrLfkwuiTHyAY7IO89iLgr8B8OCETwyZx5A8++rgDjxlw4EOZb+y55x7LMNuMnXba6ay00NjRjB106jNnPn1GoweffPLhhx9//NFHnm9u4wQT5X4L1TfhLEmu1OWamqQRTWjx5ZRQLMIOO/HQ8U67cWwF7zpZxUkP13DAW++89uB7b9L37tvsn3vi+QUGgjjYAyE8GNLjQIbw0KOOMvSwxBOM4MLwkwtVWqmTlWYBZq5ZGkFDxCuuoMnEHnZIMacWXYRxRqFqsP9BCBxhkMEKOwtBw0cfgbRjiSKq0IEJLGbqA5JLQpFFGGeqaVKrbKppZpkpy9qSlVDUOuutZ1C+aJZMAAFkMB/OzKuvwD4AgRJPJllEsYfsXCEGD0LxBp57/Knnssw6Y+edQhdFB9HNGE2HUEr1wZRSSi219B54iCHFE+AkmUTUsYWbhDhJmGNObFE8wWSVYWjZdbzYwLPVu2BBE6+cdT4771f0QGPNnWLfe4efdtJJtGl2/rEHnFT4WKIHg/boAw9qD7TWED0G6XwQOvowBZZcLhK33JXKLaVLZGZRxRI22NBjJqSuKHEHJm4qYkUXec/XRX+NyMFhNKg1ZJHjjzf/JJHlFznE+UMMid6PQox35BJPSNmlGGea9MZ7raDshhlmzBrmmWxQTp+Z9IHB0OXBWgYkkg9mRgAESRqJU7E//nBoCaUuMY143OMf6KCHPFqzKHdgJjPosA46WIO40tTHPhW0DwXTURp02EcdxwjFJSrRCAVJwhLEGY4lRmWJVE0iE6VKFQonocJNrMIXsAjFosSTnezYrTu+Cs8DheW38qhnNewgnDkMh492jEZR7OBPNSDBByzU6CCXu5y1qmUtLTZCFaPoxTDe8olMoAR1p0uXh1ShiSzADilIKVEPmBBHJqyIJ73rnU/6JbwmtIEh0UueIQoRyOgZokDSa4gf/x8xsVCQ4hbDYEbGuuE9cHQDLKRwxTC2gr65jA9lucBQJCJBiJaJJBIw4wsCAEEJQzgiEdHrXx/60AOl/CEW4LDHP+RxnnUg0IAMdIcGTTOoDDIKgxZMB2fy844DUkMXoQhh50glHE1wghMpLBXaEgkJSCwHE6OgxSlEsQocjgc7POzh335YDqcF0TxEPAc63BMf+8hHH/QYzWg+Y4946IIPduiBDGTABjvh4Q7WwgMstWhQO4xiGGVByyzIqJJ0XeiMb2ndJ9jgBjbcBCnzkuMcdULHFs2gXy+aUQ1ksIMsuAGLg8QWtRwCy4TMdA9wOGgflbe8RChSFLYIRjK4l/+VbkBpGRrTCjMwtpVhiGJziNCEKkqhik6EEhASigAlLPGHQvCPkDGdiR3sAAlmzONP6lAHPpkYqEXdU3HpEE8FCZWO+ozmaPOhhzriUQ1dbAISjijE2HxDTWqm0CmbEIUoNgFCTGCiEpjYBCdMMQwHkrOc5szVOMQhHneyczWsiScG24GZRbFmHeqYhzYuwYc04AAHMRDo5Q5CBjwkJFt6mO0e7HCJZDAjGb5AhukylC5VgAIus6CoKtjQhiw0YQc4kIFHbwfSIugOXyTNFx5z0AQ2XDGheHDDS9xwEPGCFWEKsZwfDGkIRThCEdq8xFNCgYovji9j2hDqUI2aDWH/vGIVqgiGloKRi1KU4iSCQEQmHsG//kkPljzgwY/4IApvzMOslhnHOuiBjgVmhq1MZIdbrTNPQo04cRt+x4nvGg9vRKOZ1xNsqAT7Yk2EghfN2Eoz9toUxlaCE6MYxWvUeR3L2u2HsyoH4Nq5Hr6xhnCJa80BS2tWvBojSFjIQQxgYAfxHkQObaDt5fZwuR78oRdQ8sWDDgzKlKgkLsZdiYVmoYc2sCELO5ABDuaFE5CGdKQvsi6MbPAEN3DXtm747kteAjvYnSEL8BIoLPMABzjkgTHVc8Sl+ymknTo2Fb0ohjKqUY2seEMb3ODGNrhh32yoGn1ryUUrRuEJS+yv/w8JTQgMeFAkPvzBGPH4xjf4thp7Jipp91zyko2Z7BG348T68cefVByNX5AiFJ7wRDV9Y+1rU9Pau6iGir0BDmagYseMXWwl3qPBHQ65h+S0jg/Bc2xkNzmt9jTrOuABjlDwYQ89wAGO1rDlO7zhDeE9CG2tZQdSPPIZaGZZJDYk0be82ULAaMRL6oyDHMiEXjjpF4vy1efrBroNhrZiiFAeois84QlNcPkV1vja2+YhDwJFCCz/YIgeJOV/VfD5g/8AiU2kwhbESKo2toHq73mDG97IijOQ4YtWqELWrFyMFm+L6wcH6RLZiMe9PcMaYjOxM+ZBdrLhSqgTj/gfbf9/tj3mAY5jxCIq1vbNhrStbatorBrCIAUIdazjYgkZWL9idzjcXY5b4a2zwioHspCFT9HeGx7KCFK/sYyCNczZ4G8YAxe4IF43cIEMQHjCJoBajYZLIhKAyFAZy/iJDrFLC1pgbgwEZiLc1YtFdXzR7vwMIyGkPAtPaKPwUHR8jc/ECmdgNMwzyoYczOtgMGAtD2ZiBn/LEqx8mBgpalEMoGZjGqJ2Oji8h75i+IIWpeCEJRzRVTrQQQ8DApgZ+skDW3hDHaX1v+CSxh0sw+yWzDxCrII2wzKWzE8wBVPuQZ+WQRe8xhMibs0ssBRmgRZ2YRdq4RQMQxN27L0u4TX/gExW0OPwYsPIaoU8zG6IzE6u4qo+lugcLMMdSivfQuFHfA4HCGLz5iyjPG8KuKANDoINSK8MuAAStgdKkEETWOZc3kxDKop1JIEL3CALrCAH8Gwm5KheQoqOeAdGfmJfauAmUiQHZADLYmAN2VANAYq1nEsHuHCN2iAGWgtgcAQFCAJHNE7jrKAJKqcPEoPHPOEUagEXhuEq8qsayCcXYCHWLKERDOFy6IAMNAohCiIGeMAOHCMRouEbKGwcFFBRWEMeNEPJ+sbxEocGBVAe8A0e+qQB324e4qEbikEV1swkPmHABkz2SiHvrE04dqwpxIMEyQOzxOHXvmHdvqMZ/2eFHNKDHMrBPhyIHOxDGtvhPZaNUBjwH9rhHOKhGfrJDLAADcpxDbZgC8agDdBgDN5ADkAvvOZv/nbACv4gGEStSXIhQ07nzWbhfH7rQjKBDJ4gC3oAR2LiCHBiJpZgJ0Duz8SQpEbqJ1ZABWJADIVCBmiERgBKB5BCB4TACJwADdwgzPYgvNbgDLCAHM8ADVQSC16rIQTREWJoEzxBFE4BOophfVDGGZIhGGgh1j7FEBjDD6yIoAYNDtQArIzEDFJBG2BRHvzkHjxDyt7JHdCDBKHxHKSs/46JaNzuASmDaBxwHswy7obh2jJhLSXKuIwLqkrBxz7B7ixhxyahEv8moRhfA7OQMRnBQ4fWzfC0I7Pagy/HQRofqD2usRyyMT4asz785B8OZxzAwRV4YAkexhzTcTPT0Qu8oOBewgot0Q2aIClWYSsiCRlSQhdN4lyeQRV8q1w6gQq4IAcABo6O4AZuYudAsvd+B1/87HeCbwxlpDiFIiJhpAZCEgvKEQ2ckzmxoAqWYAmkU3JuoglgDuX24A9osrFschRWARf+a0uQIRdeQSghYTG8q+S8y9DaYA2c0xytoAr44BiAjWj8BIKsUjPAQytfoyu9sh0i01KWZSz9YT/u4SzjQRlEwRIooThCouLgAhhywS2hKtam6dyawhz88zV4hVdSkIf/CBMae+UwEbM9rDEdsBFZLug9IrOA1GEaIOEyrQALrIAJRDIdnaAzvWALftAIQY8LnssOMGF9tgJCOmEtlbQT4kITcgEYyuUTlKA2rwwFcHMhhUek6sj3ritfZoQ4jTNMi1MMbWA64ygm4mgJUGRNkQKgZOD4ciB2/mARLu0RGosTRMEUWoEWcIEWWuEUhNKvvMtd0ADR2NEcodMKzABoSk0enu0e1qP/+NNEtRJA10FqKMMf+CEfyMEdziEW+2EflEke4iEbUCGEEKH1QGmM2vJBVmLAfCzWOGETNmGxMIFDO/QvP1RWemg7RtQwtRJFF7MxQQxZGpAexoEbeOHB/5gTTXdURznTORltjYL0Ta2gD/6x4U5CJJQ0Q1hHE8JoXIBhEJ5gB3IABVAAJ9R1B3TnC1ukuoYzRsQ0KMDUOCOyBpBPB6ZzOtkUDd30X99UpR5NELnTEZwCEzgBGD0hNxzBD77LXYgPOm00JqrgWX7hPv1E3tJhl/pTK8ehK99JaoymacRBHbYBFmtlO76hG24BExqBEFovfqiACuSHVcXoQS2hx2ZBwERBsDbhPfzTHKzDQ3eIV7mjbmJjaA0zPYRVRRnzPcohb6SmAc/hG2TUA8zgRpmgRnX0WZ1gRyGW+LJgBVIgB7KAE9osSVd1LStENTvBuB4kXarwCGggBf9UwAztRUV6b0uBczj9bF6RM3Aj0k3hFKDaCKBwLw0TNwfMFebO4OBwjk7ttDkm4REElTTd5QpcbnMx86OYoAoIAhKq4Rukkio9wz7CrmP38mOtcoPawR8OaFO+YRuuIR7gYR3GIem+IRuCYRKA4AVAIHhB4GXiR35ACZQQgRAawRJGYRZa4Ret7WeB9rOKEbMGs7KOdjCVtkSZ9jWGFWoDJ7QwRR/U4RuIoSCqICZqFA22wAly9Gu/FgvENkQ6IAVo4AkG4ROgNBI+4XhDIhPSJUPOBSMwQhLogG7JlgbM9U0ZNwd6x/e49F7l9TgDl4LjFUYANoP9NQ0RN3EZGDv/s+AM2EDLHnegZEqmzqAm7Exzu/B21vSFe+ABCKKWhsYfEChRCqW0VBcaWbf/RkNq8MEGr+EXYuEXmiEewMHUtGEabpELLCAC7gIvTgB+ird4Q4ISGqERdFYVDsvajmjwUNRDyaFovwNXZIWHGQ804s1pGzNqy+OY9oMevsEaNuEBUKBGJxYLnKAIRBJ+v9YKsrN2ADkL6td+6SATMOQHxIiUQmJ/V9O4mAEYNEELbqAESKADaGAFCJcGaOCB8cU3/YyBM3iUSbmUS7lNR3kN3zRgF/IKApYmBhkP6GznnCsGmuCjboIJXlhf5bABHuAB/iAa4sEe/GHJBsUG1YFS/9MD7DqDUDSMa/6DByBBF7gnG5ABExwgMBDgA16GeKu4ignhODIhqnIhF9qvFE7hizlUaIdWK4sWnVJQh5CsnS6MjeXqyMpjHdxhP9aBG46BBziAAzDTCswUfo3goL/2oAM5JuCFAzpABmhACyiBEpJ0Q5JUJPSXElwPXdySE7RgCFhgAzKgIlU5BziZd/ZWCKZLSz2ScP0VlUtZlTnYlE2ZDREXoFLgpmnHbt+wo+7g+XYOKTbX5XCHCdR0TY+6ARogQFLBlvxBNUDDND7DY9HDrMhuM9TBGkLBRjzgAbxPFGbBEiKALwIDL3ygZaj4m6s4EBBB9nJhS/Z0Fab3s/8Gzz+xd4gMTxxgg3t9iD1CzD3wOTT2Q59sgQfQ1XNx1H1F8qCnqwiY4AlkwufMQONM+gkQwRJSNRdT4i0qeiVU4bMHjA5MQAQsYAFUIAVgIAZWYAVOul9UurFX2l37FU5ReQ03WIOPzyORD053uaX/lXFv4ggUEil24AhCBHaq6KCkhQ1S2AqyADqN2kxZGHdSZHJgwAbgoOvmAXbloR4q4zLWIa7SwTzUwR4w7IDYgSppcRk24Q52oG654BAGgQh+wJT24i4+oGbZ1n/5+3gB4QWUQBI+uxVWIRjmGmjBmFjYuZzSw1evA96Y9q8BO6rZgR8S1BsuIbU7YGu1lgn/EvqgQVwkHzsmVtIMzqAHqgAL2gAPllcSAgEKV/NBHhlMMGIWBqEFREACJIAEeBwGVIC1aYAndAK2jQC227W3kbyNkg9gaTv5ePuFPxJF6mW2hXtdd6AgY07girC50TS6p3O6FxIFcMAGwICWhpkdLAMeutueLCgVLWNkywMekFgWIKERboAESkAJiOAFQgAEziSK8Zub9btb+/t4TwDAF4ETwvMZ5KpYXgNqg9YYd+gEr5dojzEa9VJoKdwf9IkYeAAHUECg5Wg6RZKPQfxZs/MM1mC2HkIQo0dsLKEMEFkXP0Fl3gItggEX4gIYLOEJUqADFoDHUyAFWFtFXtvU/0McxKdrX/d1JnqbIU9EyZE8+Xp7X6l9TddVyq18B5gv1Znb5pg7Jpj9qHVAc6NrN41iBrrA+5aBwoINHoyGHlC3M4LtaD7jY5E4GTDhD/RgCIAACKgAeAEdL2ImZs76fzWEkfl7MKgAETzhFZKhG1oUPuKpQ4P1yArPjFPQQwczPbADyK5jwjsrQfXt0wN61Ek9xL92CzyTPamFehaBfxLBERZBbDThwCxQf4EBqlRhFQ6LFlSmE/Rg2Cngx4H8yp8g2ftY5d3XqH0uOqtTckxEDntgOk9kTad+XoJ6l8m9t7cdJ4RbIbm92x1XhJmby9PU2nWAuVIkjrg9BlBAB/+qAA4iDBx+LRxAA4HsqVDonTXqyVPX4Ruy+hcuoQ+ygAaAgAiAoA5+wM+juOA/YIq7uWVCAiXUlr/jJxNgsxvAodHZWW9A3z1IUG88XlZC/nr7Uq+BDMg2Vsr0SRyr4Gc4YGLlqI+fleXf8XJwahEeoXoe4S4TNlVRBxRQwi1nQRNK4Ukf5BcbIQtQAJNv4AaG4AiwPNn92H39OLp9rjqrvtmvfl6w/uqp/kQYWLelfZeZoMrXlQmIevdMBJChL+ZCWH2btcsxs15uZzf5MCmC5BjsfhsAgt05d/TouTvojp3CdO/y0Vu3jhu4Y5fMsLkBJAkQIoFOgPgAIeSHkSf/fJg8iRJQpEwsWUZ6GQmQSk60qsWLZ84cOXPlepYj57MnuZ1DgZYTJ26c0nFIxR0VNxSp0qZFgY47Vy6dOnXw4M2Ll8pMlRgcHmDBYsUKEyZO2m7Z4uWNHDl5/Ng1ZGjRo0l7K1nCpMmTJ02IYGZ6CQqY4lmzVH1qrKrUpDs5ZGi5DOVJls1MjHhuCzp0Wys6eiw5vaSHatSqVZd2rSO2jhy0Zde2TTvHbBm6dez4/Xut8CbEm6xt0trKlStZ2DBvfuaM8rTU1a4F/js2ChgweJgxw2NTNnjh2KGj56+g+oLv3uHLh+/cOG7eeCXaQcOEixYbAZ0YGRIEI31QEkoG//og00uZdMIgSzJJMkoy4Mxzj1BG/RTUT1VF1dRSTCH1lFQejhPVUOVshdVWXc2TDSRmOKHCAw2gZR1bb8E1Vx56+IFXXo00MkmQfmmiCSeejOIJJQnGFAkos4DyySedSPlkY5bscUYOZNBBxhSXcfZZaFuA9pYTVqCGZppottaDbLHl9iYOvdk222xyvpnDb8YVR9xxxF2x1hGabZbFE5qxQSigTFA3nHBM7KAdDB7wsBoPsXAzjjkM1SMPQevh814+75DDzTfQkGJGCimwAAQQSgTxw0ciDUjSgSnJpNJKC3aikiS0ZBPPPfywY6GG6aST4U858dQTOk6NE2I54f+Eg9RQJJK4YTnjqHOOfNzCEw8vfPQhBAccNDDdFcrB5cQWcul4l49ATmJJvZYUeWQpRB4GiEmAZCIlwJ0A3Bgys0zyxxlZ6MElF1pksdwSRrhVZsVlOsFEFRlbgcXGGn/MRMdVpFZnm3DqVlluMsh5m204+LbDEY/+dkUTei5XMxOCGjroZoY+l9ZZap0mnFo97NADCtvxEEMPOfDARzPfkJOOO/LUg46m79DTnnv4tJMOfb8kAkMKJbDAKhEvnBCggLQSWKCtCOK65GGZlIIMOPH4w89OmqaTk9/Lbkg44dUWjvjW8tgjDzv0wOPNJXzgsZkZOVzxhBRPOAHFFmP/eD4XHTsOUoiPfdWLCWBGltKYJlMy2SQoA0/5CevIICPKJIvggYcfepDxsLo9sNXujcXfOKYRW2CxhRVmmmmE80sIsUQROhTBhBBMFPFEETvY8H34QuxQQw4zyHB++ernUIMONly/gxBCHHEEfvTfv3NbUuwf2uZtXeGEK6AmY1UYWQFTwybVVCE54EmFN+Thj3/wLVSg2ho9+IFBf3xDG7LgwxBa4IIhJIEKJARB295WK1vRbYUv+QEgOgGMZwSrHzk5FuCWhUOdCG5DgUOcD6vCD33IQx4FWUc8jMEHO/jhDupSDhSeCAUtcIEL7grd6PxQukUAyS+VUF2+VAEM/8eoYhYDW1AkCAEw1uXiGchYBSYcYQg/4EEPenCDc4RHMeSR6WLGC41njFAEIRRhkJ4ZJP3w8xsaKHKRNWikIxs5g0fWwAZCsIEl51c/GvwGf4aSgmicMLFPYkw4B1zCyGjTmhwokIEwiBo87vGPWOYDg/nIhz7soY9/ZDAe0xCFFdDGghsQoQ5UYFuAUDgguc1thbg6wQ8CoYlgeMMe/WgH2Gx4rBwGTpvcLAo3dYjDodiSHuyQxzrU4Y1QJNF3TcwCZqI4xTHIRQ6i88Mg7JLFvlSii0bKFy5uB4xcOEZKlOjELIAxDGQ8YxilwARfCoEHNOgBD23IQnXyeKNQiv/mYm35DCAHWYQ/4i+T+FkkIy2JUhvUYAaRdKQla7BI4Jh0pJ7UH//411HPpGUtpVxgbFKpGisE1Qpm8IAHQgEOeERQghH0hz/scY97RJAf7uCGuFAATP5QIVYnRCaBlNkvf9ENBD9QgiFeMc1+tMeaNmxHTqyJw2zG1YY9FNyysInXdPDDIfQ4xzbgsQxIjCsPbljODqKoBShexnPzpGO8FqGXSVRCsoARjChGMQpcJPR2wxgGQm/HDGYM4xSicKju8OAGNKAWUTizAvL0aLw/+vGPWwDkxAhZhPrFTLcmPWlKVVoDFUQypZXsbW93Sz9QTkwKW9gfTv8YPbVwDAv/BRxZaxY41KFWwag8OEY87NFUp97SHlCdKj22kQoedIAFLmgvEH7gkWN69avKFOtYf1CGSvACHNSs4DusudZ2tMe//7WmgQUc4Gzi1cAFPhaAMYiPdIQDG94Iy7jasAbORDEzhnqiE5grl3rySF5Bkuy9jDSKUpRiFAe9HWiZgYxh5GIUmOiiJXTnBzY04QhtaAMaCHWWMe3xtZ/8I0idQEgkC7KSvwVuI186SSizdMpRRqn8mmxlQn40pM79cE3DtNOMUbe6PV2gcpBD1CpwwKib8MYrdWlLfchZzhjkhzyqEQoYPOBsLiACEbg6K6/Grb7MdKYeRNGM7/ajlqBq/zQ+uuaeWooK0l1z9KMH3GhIE9hrtCTHNrwRDRfxYQ9weMMWlvOEJz5hZ5tj7hjo6Vi8aHFejxhSP5GE61bA4ha1eAUqQlHjSSiiEItwBESZWJnN1Ew5I7MCdEP57I8WUn7UzjKTUSrJbD9ZpVPudpSZfGVqD/KSggypbJ3ryZqCEjRhLqUpqXuaHph52Wl+wAMmRYxg/YPRoJI0Bu/xjV/wgQMMKMHZgBAEY86qQP+BW31vRbcTUMESxZjQPRYtaUlbOlTwebSlM97xTXeN3/3OB5xJ5Q1bmMEOLLdDF5zQBMxpYdX0M5T+Xl3Pespai4sQ0r2KdK9GVIITReLEJv82UeNHyHFHlFt1ZWQQs+SYpnogBSm1q03JaztyuE6egQ0Yqe1HthSS3R5uJSepyPgRcpLlhi5ocJrT5Uqh3WSuewHTspy0iKUBD+AACi6hDXvsu9Eh58dTtUEKDzRgAVmN76weDnlAUIFuL0DELLJhcYxnXB8aL3nIa1nn0PN79CAv/b75kY5tWOMSPGD5GsxQhChgAXOGup+hPiOFV89lLnaJV+/z8ghH/GgRhtCDIR6BfOQvwi50RFQP6Pd0GdAvOQXUwdWZHMhqbxu4VH4pSx0J9rB7W+wrNbtKv65IQXrmyeYupJah7fb90Wi6ZzlLFep/d+U0USwHaIDfefD/C/PgD/zmNfjwVPCQDaHgAQpwACXgAi/wAiMgXx8AeQ8neZN3gaXADN3QDRSyVKHHD/s2Z3wzZ3ImXiWoD/4wZ+jhVOL1eRUEKnCWD/BgDDywBH3AO24QBl0wJrVHUkcgWx/2FmjABmhghEd4BmxwB3fAO7zDhEegAiuwBXLwBnkwF7zDBlmYhYRSe1GXQBJTBCp1fVrnUuU3XGI3ZSughmg4dmZYdix1dmcXSJp0BIMkPzVQbiH1YTkVGp6kUW2BBvOHf9aFJkLVBE+gd1WAH0/QBnwAePZQZ/5wD+RlD/PwFcqwCUtAAiQgAi4AKyYUaD5AXxUoNyREBYIQGKEg/wra4IGxxA/9sA8ZpA/1UA9SpYIoKGf0YIIniItcU4AwiA+ueA/gIAowoANO6AZqEAbN5QQ0t0l1CFJhYijFsRyEkoRLuIRs0AZPIAM1MIWiQ0cTdQeE0hxbWD/0Ux1CBUjiFkh2SIbY9mRkR2UzEH7aNgMrUHaQ9G2BZANhqEnxQ0ntKG1tUXVVp1ygMTFhxlP3NzJpgncWRVRWkAM0MARowAd8oAvxYIlfcRMdGQ/dIAt/IAQqkAEt0AJrM4EUWBKDRooo8QNUUAd6YAd/AAmQQArcQCHnQA//0A89aXizGFUtmIvroYsoKF7i9SkbF4yGNw/VwAfcsVpssAZr8P8WmnM/u3V9IIU/TPAnmxEdWqiNbzAG3vMElzFFXLAlbrAZgiJFa7kDa5GOziOQW4Z1LwVl8Th+jbRIUHaXbkhlW4eHVwc+vyGGW/Z+CBkmSXaQQWN/BdSYZKZ/TZQWlXEEeLAHZgAJtkAMv8ALthALqUAKpBAKoXAJf8AEK5ABG/BejicgLNmSpVgHg4AHiZAIkIAJl6AL3bAM6hAO9IAPPiln5BWUt6gP61GCBVGCLZiUGydB9gAOvMADPIACbtAG0WGEVUlz+FOQIMUzT/AnVxAdSaiES9gGePAGMzcE6XkD6wkFZwlPM5cFh7QWPVAdTYBk5taO7nhtV+Zkk/T/SNi2l3Zpj97GbcIlbsWlSZdkdepnW0amh3rYUR9Gf/U3iNWlHIRCHVlAGztwBzPJB9FpVJJiVJPCAziwAzdQAhOwAS8AX6A4Eq8JeVRACJSgCfuECUY3mr1wCdHwDdzgDvqAQcFZD+RFZ3sFH513aY2GnMWJnEqJD0zZDZvAA5KyBm2QhWfAPEL2UdQ2UvcTczhDKEbYYz3mBneQhW3gMEkwBK0CBBiRBFOUBQ6TWIUyjd9ZHNAVhv1YddWmn+D2W9SWSE1GdlFmhoQqXFaGdopkZVeHnw5qbrPVLvTHmGhRNFxJjmmxGdInb3awBx/qAebCARiAAWu2HRTJAiGg/wEbMAKOl0wwqkxUgAgAIwqaoDqasAmesAlHpQ3ccA65xA/4cEu06JtAmnGWRmkWRJT64KT8cA/xkAwg+gBrQISEEgVRkDxbikm2pxlNcKFZ8JVjSqZuUKZscAZoygUaoaYZ8aaXwa5agCibwSd8EhphKASGaXXZJz8LSm5cSpjhdmWFWqgo9X2Ein40IG6UFJARqlxa1mW4V3/VQSNwqRZNcKmbwQY7gAOqYQY9YAZ94AEPwAAKwAAjywAeQAHrFQIXoAEi8AIhEGgn4JquiiCUUDujIAp/YaOS9QiTogvaoA6++h5M6ptKeawBRpTqoWkVxKzgQArdoXhroDDBE/8FSMCMRpatnMStzPGV2giubtCEq2Wl8XkE68lqicWu71ozXTmNxTOQ7Yen7Kife5pb9FNt5VZJUyZc4+d1M3Co4KeoAcmXD5p9WScEfqSHFDp/YUYdhwgxRLUZWtAEMNADlHI0O6B4B4C5B2AABtAADOAADrAADpABJSCBC+cDMQujgIAInbBigjEJjuAIiTAue+AHH9td3xAOEDaUXlOAAYZpXOMO7QC8B2EQ7rBWA9Ye/sAikMADn/oAaKAwyuYEVKtu0gaE1+sZWau1RyimbeC1X2umCiORG0o/GwZFPYMzz7EZE2ME+ep2omEETVAE1dMZ1UO/0eMZ6md17mP/ffzYSNuhAgGMtzbAt14HSfhIZWHIPuhzPdzaBEvABBCMPe+nUwT0sIuiFuqiwT+TFtG7AzkQAziQsfjxAJpbAAUwACmcuQmwAAugAAsQAcdkEqj7ms9Eo0SXOn/QB38wLnaAB2uAAZOCVALIkz1pxP3giqHXgi0oVVKFQbEUS0ssxfcALgI3LlDnYz+WBfujpXSph7KlPMwjxjfiBXHxBm/gBeWJjdQZnzmwAv94BPCEljM3KDtAp8zBHEZwBONjBE+gx82ox4HsncvGBMNjMjqgJmvhJjlQBWagA+0TAzFQAzBQGTAgAzJgybyBAny7AiAcAzKgA7wBwrOhMjnA/wRXAG9tEhumZAUgUwUTG3N9csrVeIjMQXM48wRpe3/Uxa3fgQIMQAH29gAYQAEZwInstQEI8LL/QcMGAgLPDLPR/ANkMAiG8AfXrMN7oM19wM19EMw4wAepQCEheMQtCIKGx8RRpc62qM6U6M7k9RVRes1WkAU3kMVoAb/RhpAYRcZl7M9mLK5mygbiOnOIVHOZIQVQcAOKdAO1NyhGmAVokBk154NdKijLgRxf6G6mlCZtsgSlsQQ1EMkowAHcQdJ+BwNKE4U08HSW/MkyEAOk/MEbmkCrsUDvVl2Lkr7x2p09zTOxXBzCkRpZAAPEDLIOQAEYkAEZIAKuonAk8f+iLQnN0vwDLHAE3noGLafVLLdy90aiv4BLUzycS7zO71yJHonWaA0O3UAMF9kHbXAENFCEWCAWaZHPYSImr/UW//zPbxDQWSiuDqOtqRbHQ7BI67nQD/1jEq1YqmbRgqJsNT0dU5cmhKgDMQADkRwDMyApJI0Cw6w0SuN3MqACMqA0mQzTopwbv+E0qkTZHy1v1XUa+gcxGM0n3Umn3vknfLIW8ZYWKWBvGDDMxFwBE8CyxkQrJUGBpPgRK/kCLnADKRDCOBCd33GRf1CblXAJmIACZ8BdfGAMG7mR8dAV5A0P39Cj26De10AN0LAMymAMxrCZvKALnxmao3l0l1D/kxfJB9d8sW+Myt9hobEVhHn9Wnzd1167xm7ABaqmaoZSUmoo4W/80JuBBqn2RIn14D59qXEpPHZ3QGyiAzOA2SEcAyiAASft2Z9d0tLt2Zp9ySK8oazNJiFOZgNE28qGM8RBjnSaBXySvo4iVGfwBKHadynQARVgARcQAjD7Ns0MeT+ACJyAa5h1CqsAC7Sg5beAC7iwC74QDHGkZ0YFCb1g36IZCptwCfoNCbL7odEpoiM6osIsIw3wsXRubx5gBntQKPihAk0g29U1Wx5l4Afe12fs12VKnhXlTue7ajSwAiZgAqpC6TswKNGRBW3gZejG6ej2HDUDpjsec41J/9cLJMI6UAU6ENqTvB2f6rzDHKqnbdqjKus6YMm5kSc1buN2N7HVmCjUaMvwattfuhyOEh3LIQMpgAEdQAIdEAERsAHOBAKimEIrCeUG8i9ghAzBMAzB4O3f3u3f/u1H8NkM0AB90B321gDrzu7tvu6Y6+4NoAAKEO/rTrIkS+84YAdXUFKlzTECLhZVAKEFXjzt4gV6XcaIrvABvYTUiSjsymFxrQImIAIiQOkrcNXW2BxVyenI4+k6rr6izhxjdkAivAQhnNJK88ko8KmiWufmnuJ+lwOhitKZ/Mm4jjQKVHenUXd+4us/vicxVyjCnrbxauxXMJ6B0Qg0kAJMPv8CzwwSyYQrrvovs5BQxdBZw1AMW7/13p71nVUMMFAWD6ACg2Du9U7v7565a5+5m4u5mwv3BsD2cn8AnxyFJEADJPCWjRzwGjPwE/MWgD8mcIE8/7x7VHjG34sHdyCuVtpjDlN7NNABS70BqqKGduyVXzkGm7/5VenxzhXRWhz6op+2VyAWPN8mGYsCmj0DSpMDJD3MILvuIst3olrU5rL6mf3JLIPrsd33N213s/fzjUufrZW+x99a1JFaZmoFllAKS68BFjACF4AA1S8gKQETYXUSqEsFmdBiycAMXC/+4y/+Y88Fk/AABaAAnIvnfKfu9c7uIcv2cw/3mIsCAaz/AimghjKwGqa0Fp8BEFu2ODHiZKARIwINemHY0MubN3IkQoyIx+KdO200tnHjhgsXKFB2rMhQ0gSNGyiPZGHJ5o7LMWMgynkTU4pAnFKkbGyDRmNHoGiyXLmSpsqSKkl79MCBIgYMFFGjPuDA4QGDBw0YKLiqAAWGqiiqwoAhI0cOHDhyLO2xtooZM0nlzk2KBQtLvEOHWrmClyhRloD/ZrFrN4ubMy7xTOKiYcKEEBAQEEDwwcdlzIA0A4oECPOJE5gv/6CSaRYwZMiSJSvW2vVr18eOJetxxpKlDgoOHGjwAAXZtDjIwkghNaoHD1U5YGD+wPlz5xieM4dRpMgR/+xHijSR26QJ9icIxY93YhCnQIcNKU580wbPS5d3Om5ko+UJDRokMohoMWTIkyPYYOMMAguk40A56NBDDzpqOm8gNHzqKQs03IgwQgHPuKKHt6roASm5nopBLBSasoqq6FB8DgUUOUBBh7KcgkEtpnqISy644EoKRDOwQIPAwAAL0goiWRLqCu/+YmJJIq1Agw2WmhgpBRY2CAEEyRCA4APLRPMss82w5BK0E0qbJZdcfFEzGGF+cdNNYXy5ZZdednnzF09G4QQPEhigYKsDyPIABh5wiEHEQ8kyTirkGlXuUeVQmEGI67JjooklvAPwiCGgGK+g8kAt78H0vJDoVP+aNBIwvp/caKM+KI64YQUTTLgBCi3sy7BAAg9EUCI6Yjq1oZ4izKKJSzcSikA0kErDjCWi1SGNJQ59KjmxkuutgQM4OECBqnRjwKoGUMjhNyZgiMGss3CwES477DAqqRzTsLfHvPrK94om9/2LXyb6dVWoLI5YoQQRQhgBSwS03JLLD0ITDUwfQPgABBDKNC1NOoPxWBiQ2/wF5Ft66eXOajiZZBAtViDJAec8qIKsQoOzWS20grN2OJ6jUlTSGoSgdEmimbAOO/88Fa+8UJkeFb1S14PIizWejA+++diAYlMaWqDBvye0WNWnVdn4KCa039hCpy3eeEiOYjlCo7D/C9eoWq5n5cLBjip0eAoqFGWQzjluFTDAgKx6i85FFGTYAQezllqrqHtvpBcueyvndfMm+SLYr3/5teKuM/C6TwUNLrgSAslYZx1i2Ce+7GKMRyBCk9N8MbmXYHzpPWSQfd9l+JF/iQacQbjQgo5YOejgAQXwaIpQGM6yvl3Jr7c+rXaFKysGFVSwQWghdjB/ySYoRTpp8pwOtSCoH6Jo/qm3wPBqAVXN4olNU6LhCP6VTSMYkQ8XyCCHMUihPFKgiUwaIgegWESCaFgDUOIVr3tV4VlLMEoPRoSC5GBALN7SjQEYsJvDHQA6PhuRG7KAMyvUBgs5whHfdPQWzW2O/3NE+lyQ/lWYLLyEJU+4AcI2gDHXuQ52S4yYaDD2gkh8ohSzUJPJ3NQL3wEveMEw2S7atAxwgGNBg9DDE2RwBAwoYAeG+A0OeNAW88XRfGeRQR3rmAP85DGPT9gBDVKAkhvcQI460MGlsnNIJ1hnae5DiHnip56ZTC1COhRQRva3KVntAEAUupBPgOIGMiyICzJxkEwk8pA8XEQ+EozXHuxghlbm4YKw5FtSDAUDq3CgAQpgjgoNUIACDACFB2gOWH6DggbIAAtr4dASXolDDOYoXjmCyxkuqEMdzq0wWCDSNukGn4LRoAQKO0ESlchE2GXMB56hAiE+AQxgeExNvv/4xclCdqc3ncxNx/gGPOZxiENAIQuGyAKLdmCJv9GoB9mRYw+akL2zmI8GO8gBRSlKAxmkZAgpOQITzKeDHRjykKBSZCOb5rQHkYoiDZkkr1aVEa1tin9PECgnOdkqNzDoIzRZGx0QOAY55CGVEryDBPEg1D0ktQ+u3AMckmoHV3KwCiJKI1Z4abgCHGAAAyjACQ2ggK1c1TcwImQPClMFAmWucvC64CvNgJG2EmhXvPKmXUZX1yxAaX/52cAGFnbO10HsYUsEwWUi0QlVwDMYw0DGPOEkMny6iRe8+AUxtDEPedyjEQA1RA7MYghLPMFl63ohW2K4lNO+JUdyxYj/Uv/giEdMwhJYQBYThubRHVQqO0tbJNNE5UhHpvRBZNvV1V4Vkq3hBUoSihBOQfkRMhxBBTNgIKr0kAf3SLAPS01qd/nwXag+dZo54JtwWLSb6BiAqwX4ZQEUYDgVMgAsDeBAWXKggxxgoYJ2oaW8pPnKtk4Trhcc0FwL5KML0S1CQAyigLJwAxYoDEvnRCeXAosxjP3ANPFsTWOrGFkQu8ka4JjHPfwBUDdY4Q6T8IQm/IADjPgBD4uA7SQqcRtN5NgTOxbFKEZRilK0ohW0oAWa1gTPXCSiCnYR2nasY75DFqGRojoPqFJ6E1Kl1AuvasMZftSGouLBVWMYJRfa/5DXnrjBIhzpiFG5cKAVFAAAABiAA1TABZpEJJVhlrEbzMADuPAAOTyww1LdCheztgWXDdilAdLI1QOwN6uRPty4GDAuda0rBj2wUNXuYAYvo8EObnAqHO5gh1O3Ml5usIOo1/CSxAxocwhecCcT3BIBaWEILRjBCJJYYdgNFsMgoEInTjOM1iQDn5T9BbMjS4xoxGMe8bCHPfCwhz9UYhRoWkW3iUxkXOAiF+JGU7mNrCYjp8kX5/ZFMVJTiiLYACpCuMEh7b1bhERB3/vmN78HAgUpaGELAh/DFmJSk4O/wQ1jaAPVqGZw+Y3BCwYfeK608BEDYvyAY1gQHQYwZ/+QA6AAJFjBggzhh0XImAxcyIEHUMAHHjC6AYM2Q1LNkIP33CEHV9ABtk4Y6QEYYDdAF6bQTXgArIAlBuZrwl8Skxih+GgNXmYDmMH8HquXjkJeZgnXh+IdCgXGO00nDJGWVAU8JIYLu45M64DNJYw1TEsTPoEkVDFuXRCDGMbgu2yW8fe/Q0Ma1KCGNgzvDW/EIx7w+AY3tjEKVRTZd/Ok/LrHTe7LmxtNu9B8udVUjGEAwxLxHhG9A1nve2enPP3mdxdc73qBWFz2BkdbwiEicYY8MvcxUV6uNK68nXJ8EAoI+ZwDkAAHMIDjQq1CG/yghxukIAZ/ZrQBGO2BB3T/Cwt4iEEM3fAEKaXLKt9CeqSBDkxg6oYCxOyAU5iQBTxcAcwOzquFJLSR+fCEI3Erlq2HcoUL+Trv6CS7soI1EJBZEYELaJ3BqrC4cx0QCIEfIATUcAZliIZ+god1kIfFgwcPZLxvAIdvyMAP9MAR5AZuqLx5MpnOa0EX7AXNmydkUwU06KMRsYHTy0HUGyknYL19ez3Xm7iLkz2Cq720WamJa4j4oT0yuzgDWjmBu71BoIEAKD4ASIAEWAAHIAE58II0cIMqyIIRoZkHOBxGy4oBCICgQzrHIYMnEIIVmAEVEIurODphUgCu2qqvwgoVWjoZgD80qA0Ccgk9cJWf/9gIMTNENsMpjbA1Y8kCZfk/AHRELHCJLPCjC4iACNCSt6OdcmKdCFQCRMgFZ6gGZ4CGb8gsf1hFe6gHeViHdVAHWfwGWaxFeJAHdTjBbdgGy8sFk/Gd3YFBFxxGX1Q3NPnFxdKEB3MZFMiOeju91CsIfUMCHwTCtSHCszFCmag9h6ifLZAfg4OI3sO4s6EIPWCAAKhCkCMALEyAClCBGsgDOEC7O+gBHfiN7DPD3khDNUzHrVKAFHgCG+iAOXQRqBg69wom3QArrmA0GNiBGGAC/MqBMyAgVbKINktEjMxIo9pIRWzE5gJJgtkmCoqQjjAYExCBCVgACMCYi4EdMv+JSQsDgdtZhWyoBm2Ahm2wB3rAh3/4B3ygB3pwB3RAB1wcB1qUxQ18RXVASsfbBswbni6ikzoJN6u8ynDbBauUSmFEN2SkhT1gAxpYgRRIgdQ7AuRKy9VDArZkvS7Qty5YG1zxvW3URrfxgtqbn4ILR7VBm95zwo+ICHEsgHRMRwAQACzUQgdYASd4gyWwCA/CxwM4HOsrQ3+sgGDqx38kARW4ijPcDUCZtN14rwdoChToARggpD7wETUjqjDrSNiMzY2UoPxTFkq0i05qAy7wo5S0gAgIgZg8gTERzuCEOyXghFVwBnDIyWtQh3CgB3T4B3+gB1g8h3AIhw1ch3P/WAd2YAd5+M51GAdxQMFd7J1xmyeu1J15wgWtzMqs1Mr0XLcqQsZN6IH7yA8VyI60jBX9DIm1pEYf3LfYkz1tFIiYYIi8RLi91EYy+0uMmx8aKAABKMzjWwBNlIAKoAGBiBYP4BZkokzr69CPCwDMLIAE0Koq9Eeu6Iqhw4ATOiFxkQ4OoJErgIFm6QgsaE0JkjGj8gMe7ciM5AmO3Eg2U8SqqRpH3JoV0I8M2AAReIEgoIIfIBMfCE4yuZhiawVmUDxqkAZaPAd60Ad9qAd22M5zEAdx2M50WNPu1M5XHM9d3EUVnNPNGx47tdNixKLKUzc9pYU+WKix7IAU+BTf/yqp9wHQABVQtDmPvRQILMM9h4gJJlxUBZVU2hNMU1KBYBoAARAAAlgAUI0ABzCBlpGDK0AB65s59aJMEQWAADgAB1DDTjVRCaVQ92qOFX2vA+gAsHARGDkUoqgaP+gDPOiDYSVWHZUgobIIoRoqPMgujTAqofJRaXVW2ZQgLoi+DigJETABIAiCIJhSKw1OEACET6CFYgAHafNSeFCHVryHe3jFDXTF73QHfMiHoBRKdwjPcHjKXRwGjwnYgJ3TO6VKqvxF9UQ3ygsGT3ijK8iBsuwA93ECnTipUEFUt3zLKIhLvLRUS10btiGlqZk4AyUlSeWpgyu49Si4MSADGv+INGBCTAeIgAmIgAz4monagWzxAPXSQ+QwgDkTgAqgswWANAEYACzkR380UQqgABfdCqwgi3NJzSt4zT4oBGPdrkIY1qPyg1TKAx8FWx8N21Qi27E9W7RNW7X1UUOgAz/SD0H1ViAgAioIV3Ed1yAABWDohcRTPG5QvMWbBxOkRXhoRXnoznzgh3ylh3QIB3HoV3/FhVuoBVuwBVmQBVuohVq4XFiABc19BdD1XM3dXNC93MutBYUlN1r4AzP4kB7YAZNCiJIyKaaRAkRty4xNqYK7iYK7jotrG4pgWQZd0CN8A4rVCd7lAhJIAGAiAMTMwgVAvgxYgbGkgXPxAK3/2qoBQI4HKEwHQD+tOgARiDQBaAHCpNAAEICscgBeFYvqQYEqwC4/MIST6wNDwNpi3S79Nda0Fdu03dqzLQQBHmACHmC0BWC0dVsS6AAGFtQUKIEScAFwDYIXiEDSANcfCIRSAIZbWIZ4AAfCuwZr0AZp0IZruIbGG8F1qAd/4Ad+cAcYFkp2GAcaPkF/rZOC3YVb2GEe7mEfnlzK7WFcWM9eEDdRaF0dUAodEIJPEQ9DXb1E9cEHadS1MYKwUR69TNDaM1AFhQi2wQkyuwEKONETFdXozUIKSAGypAGyaAD1SseZ8wB+ZF73koACqAAHgFl3RN/CPNr0SwEhkAEd/zCDP9iDRwii+TWERXiERTBgrb1fAh5b+p1kSq5kS4bkQrDkrRXgtKWDIVABEgjlsgwfFnABIFACcB2BFwCCMiiDOnCnYegFYoiHxouGaqiGm2wGaFiGEbaGbaBFeWjhF3aH7iTmM3VKf+XFYNydW7jKH95hO91hXdCFyq1cj/kFrSQyRZgBHQCRJdAB6whntiwPcYbiKP5B2GNUlt0C/oGCj9CCLN7G2+O9+Ek4ioW4mXiCbO2A6K2ADGjaCsAAChBUjAKhnt0q7ANaNQSCTT0AGsDj3SgAE5hQw3RVCp1QrlKADjACrP2DPrAC55vfRWjkTFaERDCEPxjpRdBklf9WZJVWBEW4ZEomYJiGaU6+37TVAy6wgTkcZeqlASAYAiJQAiVwgSQAAjKoAzpohFLwBWGIhmvQBmuohmdwBmdghmRQBmM4BmVQhmbQBm8o3FVEh3Moa+50zsZDQX8VBjaBrHpa5qkcnsmaa7qea71zE13ABVOIgRowAibgkL6JArYc7NVzgnE+542Fyy4IgzCIS3U2OCm44gelH4iY1DHQAij4RgSdCZ0wJTnouEFoBEqYwvD5IxW4gRpIgapwuTJkr+0VtDTkR5jdKizUKg04AD5Ox07V7QlVXxVYo0U4g54Q6Ux+hExmBEZQ6Zau5OV+aUVYaUuGbpq26ZvGZEn/9oMxsAGXcRn8uAH/SIIkUIIVuAEtGITb2DaQqSy+K4bewYUi7oVbeAVbsJNjqAZuAOZw2E5YZAd1uG+1fkpt0CLgCbE30TsD57ut7uplmAZrgIZoUAZm2AQYEAIn+OZoWQIjGOxxnljEBkLGZmxSYVkpcGdynBr6YcJ3FriGICU5MFCJmN9DaATZ0oQ8sQQUeINJkINBeAMhmIE1aOPJtL7vaoCtUsc5KwAKKNqtOoAMUEN+BKZ0hHLdplCu4oAc0IIFYdtFaITmhi3l/nIwXwTkZoSaHmmXNnP6remaFmCYnulMPrk1WAKKkoE8AiAntAEpaARPmCJfGIbKigVi/ziGX0iFVRgFTxCFHhuFHjsFVugFZcgGb/iGdcDOMh2Hc2jK/yZPbUBw2VAGrlbwZmiGabjlarCGbNCGbkA8bwgjwJ0HV391ePAGZjCDGBCCIxCCbjaaIigPwu5Bwu7wtwRCx4aavRxxcuSCu5SfUuI9jJOfjp3niNADQ4hxG6PxKcqFWch2S5gERjgEPzDpmNONA+ABSOCDnjXMFKWzE5Xo2CbMPIS0NOzUeEdfYeqALRgEP2iER2Bk5XYELw/zL+dyMR9z5FbuRhD4kUZuNYdpMofuSU4EMt9aPECDJqjzi3sDPNi+SSiFxBoGkDkGY+CFYriFVcAFIPMxVUh5Rf8nhVoohmkI63btTusch1n8723AhmtQ9RCEB3DgeZ/veaAH3MUL3GqDV6M3+lhPBZfLJCaIFiMoAg1Hgv90mn7T2MUW9tf7RmJfm4E79mSfZ4M7di5w9m88OImQdmrXBE7Ik1YAhtBDEz2pBG6vBEgI9wPwAEjIe54tcgoFueNzd8B/8tjW3inn4wJIgdDe8n1f/Efwd4M/+C2H/IPncoIn+Mn/coVf+IJHc0NQBH8/aQAGCScYA2b1A1TzA01QBWQoBpCfjWDABVhYhVeghVNA9FNQhdoXBVJwhV9QBhRWh3NoU/GkYaeMU2zABqEH3A8Mo54vQeeXB3rwBxNbxVX/hFd7iIdq4IOlV4nxMQJKsY4NjwIoZhp03tjFbmzXY2zYy72HWNBjpwlIwssHCV6JE16g+uxpl/FKWHvI6/NhGAaAwKVKFSdMkxQlSsTjwYMGPCBBunQJEg8FAwJgFIBxI8YBFwtcDACyY8aNADh2HFBAAY1GkyY9iinzUaOaNGvWZLSI0U1GPn/6xLlo6NCfio4aVWRIaaFCjBAmampoqp+qfvr4KbTHTp5KwJAJIyaMWbJguXK9yhVslShRo1aVWrUKlatfyqhxW6funDx558SFC7duHLdt2A5ju2dv3rx48eAxdiyZMTx4kuPNu+dPn2J13L5xaxwPHDEzPHTs/zhy5MaNIkWEwEYiezbtKLZv4+7SJYzuMGHi+N4ifMuYN2/kONnChYsWLVyKx5kTJ86bMF66bPHiZfj251yEF5eTx9AhRpMqYeLkaVSrXMCA5WpVypOmR4sK2bEDg+GDiJc2bfLfHx4YEBJKAJx0kkcAqETSRQMIoFFGAhAQgEYSDpDACoa8VEklllhyHkyVjOiII4yc6EhRPiH1yE9ELWLIIkcdVUgfTeGI440J/dFHH3/0+Mceefi4xx59LFHFHo7ggowyv8SiTDLCBBMMLrn4gkstt1zZii+5bEmMMtNwA4869sizjj2ejTOOPIYhdg1j4IzmDTh23tmNN3tyo/+NNdVkk4018GiWzz3zXHOMMcZMs4wyxWzCQw4o7MAaa0cYUYQNQtBWG26f2qabqLv5FoZx2o1R3BvJLdfqGF74Nl2psQLn2xtjtNpceHqQZx56nIhSyixY5jJLKaOM4oklj/gBhyJLeOABD6FQG8omoVzCBw/7HQCSgQAIgGAAA5xUQAHjjuuRRxFa2C27Eb6rEgqPYPJhiI+QuIiIPpnY74ksKsKTTzQRNRWNNRZCY1OK4JhQIkDy6OOPPfq4hB0/bjKMM8bEcgwzxxSDzDDDiOxLML7QcuWVvfyyTDPafPONOuqsY2abhKkD52HNdONMMooeE5ZYvRC9iy6xIK3/Cy+8XGMPP/zcA88xSsdCzC+/oGLapKsJ4ZoRX3PaKRKgkp3bqLoZ94YXqabqhKqtvrHFrHNPBxx1yi0H3nF08HqIS5Zgsl4pqswyiyrHikLfI4VkhUUVMfAhCimkpCJ5tttG20C3BmKoYEjqgg6hSO5idMBGApjr0QMo5NBIiCa+FBNMj/hrYlIBP0XwUAbj/tTBCjeVCELBFxIkkBT/UQUcefyRCCzPVKOMo8cMU0wx1Z985VlnZdnLz9loww03NNMMj/jbqPMNYtjYUowzrshiCy6w1EILLK/QT0srqbjySi24MM1p/PDHPJbBC2H0Yhgn20QPcBCDGazGBkX4/xoTmhC22dhGNrcZldlE5ZveWEc7a2Ob24zTKjl4oW61IpUKrYO37xAnVceRA69cgi9MaEI9bhlF4jihiUrE6A9pGOIlYkEKPkAiFK7YhLYwF60HKMBboSvAAciVrtBdRADu0oi5NpKh1KnrAUuAwyMm4Qh8zW4m/QJK73jSiKlMZSdIecrCDmajhCHkeMgDksT6kB879OgSxQjUMoxBjOshoxgnG0aWckG4VugPF7i4RTIEtY1vjEMd8oCH+rZxSW4gRpLPKMYtZAELLWmpfriw3ylWQQta+MIX2VDH0+ihjmX8Ihe4qFIr/oADGcQgBa8RghGcwIQKXlCDUVBmFP/ONqoPkgqEw4mhcZJjnFRxwTgtpJUK47CdaYJHCsTZmx8MUYhFlNFeOeSEDzWxLBuZAQY8uASUFoICRWAiW9qCwROhyIEHSNEjIEHQSVISEnOBRAAD6FZCGZpQlShAcyj4AyTOU4lHQAQitDsjUIASk0bszhCN8B3wAga8QiSkeH8o3o9Y2sc0rAEPPuIDKchii6uJ5XpVQgYy7PdIVbRCLquoRTGacQ1PanKTnsTGZ+D0pVw8wxewyIX9YLGKU5TiWJ5gpyfWQ4pozMMf+PAHPHQxkT5EJQ/AzMEKUgCbCTbhmEwoQm10UzZn7oZUs/KmCGX4BnGyDVdqmxs36+b/QnAKRwri1BsesBBTH2WlEC85D4gmwYhENBESqUgFDzzwT2nZwUZ26OwTl4ACBWwudChRl0gSkDqRIFQlrhUdRgqgOQMc4AFmqGgZMwqJjcZkYC7iyUdpYk45ImWObEzYw1rqsIj9yEdowIJMfQSJXOyCFMc4xtWqZBZfDAMXvmgFJFuBVaviohfHqIY20NcXe3zDMDAD5TZeYghLDMMRPUCDDnIgAxmkgAQZyAADHtCBDvSAD8b4xj304Y9v8MIWofAsB1AghBqsoAMY6FoRlrADJjzhCnSt6127EKrePLNU3PFrDP36KsLq1bDZCWyqtqBYKOAYClpgAxOscIUr/2SBDW7AgzllhC9LVOIPTUzE5BaiAhJg4J8cgEMh8FAF0oLBAw1QAGpTCyHQSQi25kLdAqjokQSQriMGWDMPGmAAhyTiJRmdSXCJS1zZvSRGjRiuR+vMosuqNEdN4aOP/oCGK7ABD3nwQxo2kYpYNGMZwuBFL8BbJZMNoxXIOlYpcNEeLCmDvd+QRz3usY7CHLUw2KDAAhjAAEOUggMNeICrGbCAWy8gARTIQArw8AdjcEMz9/gGNbqRjFXooAYzQIEKUsABDhCTCTrQAROyIIXYYNDEHYQmrewKQuxMU4aBPY42DcubLkgnOnOQjqluRWPh5BjHbMhBD3wMZCygwf9GhogJeuoFiXjyIRWkMEMHVgCEFaigBs8+QhvaMFo+8EHLDZh4DPLggSpikaATEgCa3VUANJ+roANYs0MO8GaH9HbOMxHunWN3Ezq7yM+4m3lK+3g8iRWiB2c4g6L9kAeaHsMZ00jGL06m01jukhZZHUUpRvaWVfiCGdZA3z3oIY+cHeaS15CAhinAAU3MAgcoSEEHSCBgEYhAAySggR4esQllgMMe7DiUN7qxDGfQAg14WIMO0CADaldB2pvaAQ2coEG7jm2DePUgcEDom29qBzzDofFvZFX5dWNeVmorzhjGacLlNKcNQb4DHvBgFdMr4obq2QRFPGAGa6GAARn/2IAJVLAEhnTg2SjAASQiPvEDNCARlTjKxVkbgAQdX1wEGHMADuD8c2lkoRNv88gPIC1FVEKjwT2jnz2KE5zI5CfhJylCoBIVivVRYhSzis8jVw32aiMZyeApT0dGsmG88izDAMZAgjpIzGiGP9xDzhjGNnBDCtAACegBE8CAKOTCHeQAG6zACtCACtxACZQADezbJShDPNiDYswDOICDNnQDMhQCHLgBE/QAvSXJEizBBKmG4TETBn3KuX0QYamQ2mTHdnBe2vhgN00H5mXedMiBcRRhqhThG+QKF7hBG9wB6ZleVZSeHzDCr2wVJiQCCsDAtXjAA4iACbgACjAB/wqggBOogAqgAAcMEQ504QPAwERABMRR3+nAy/EdH7xQ0WtZCBW9GQ+sGW65niNkHyTY2cp1VFB830h1VJ39TsCkFPqln4+oFFVcxR4kwjBkQzUwAzMEg/WEDDOQzMnAB3w8AzIUziiYwi0cQzd4YIPdAzuEAzZQwzVcAw0cAR1AQRQ4gR2MQi70gREgQRFAgRRoAQI+QSNUAge24mJwgwh6wyv8ERq4IA5UwRIggRNg4zDK4Axu27fRTeYdIduQ2wzJQTnKARCum7qlIxGaYxKmDeg5RxM+4RSWEx60QR8IYnp4wiaIgilsQiIACA9gAA0AwRCsAB5kgRAMAgp0gP8KPFtDkqEHJAK2xCEfBMgcrgu8hEtBKRTzjcsf8tPIrZkH/AEaTVbMhR+NAEUiKmKfAczBPEXNqZ8eDdofVIUeVAXGDAMpuAIz+MIpnEIr8BR8DIvhGOUsJAvghMItEMM0wAOa3EM9qAM2SIM0WIMTyAGO0cEbYMEejAIw+MEWDIIcVIUMZIEfLEIlbEIzeGA92AM8MNU3NAMk2MEemIEZ5ECSVEEVjM0WYKMUlJhufMFgfoEN2qAKraM7pk07MmYQpls6CmHdkOM1vSM8Ntw8VgUlFoLqdZUDZoktHBEK4AoXNIEhcAEN0AGznaHZVUAFVNglUItERESAxOEDGAD/SBRAhBBAhWCEgrDLR/ahm63ZAfBAIpQRnd0Zn3XUInzfTixiR9FIIqAIVOiRHs3kHtzBkF3Fw1yCB4hCTzkCDvjBQFRCKeQQfViCeWrCVhmCH3jCKcgCM1RDPIxaPcgDN1CDNFADHTQCJejBILjTnrmHJWhCgfoQsKyHK2RDW76lNJBgLPDBH2GBDsgAE6CBFdiGXyZHM+EVYQ6mGIgBYdFKYSVhORqhD/5gN60jEE4mZfqgcLQBGrAB6WXmfaSeh+ijKLCCyQhDWOBCsviBY/mBc8gBCtQADbRAC7iACVhAB6AASfKjtVQLHE5ERdymuhCARl6IgoBEA1wcybne/x9MgkGkEcwJTJ3ByIocIhsdhXRGZ/BERfHYiI88TOld5h2YAR84wiaYgns8AgrIQSN4Qik0wiFIwiTUBCUMwiBIgidMAodUgik8AzNEw/isAz2swzZcgzRk1eAQTuEUDjI8Q+G8B1XpXzF4Q2b4Qz18g8s4A0Xc5R5UgRVI23Rl6HAIpofqKoiCaLpZnuVV3nQspjsypjkCYXQcK3WYow/6VdxsARrI6B1YhYyknkUFTiiIwiuYjPUoAzNM6io4ghn0gR5IwUJa4JKCoQiQgENyAAz8wSaQAi+kgrVIBGz+GwcwFJYun4SInAF0ocn1oR1gH5nCXMEGV5rOyEuqZP9SCE90Ptf54UjztKcf6IEePGEPNNAkgIiyVCwiSIImUAIh0AEdMKolLKoeTEJmTgLYBUMyVMP4sAM9jMM2UEOpvsd77N97PMMzKBAjnQUwDEMypKo//IM8tGoxwAIP2AEKnsEOZMFfCYe2dUEa5OoXVO2H8qoY+Gqt1EqwCqsREmuxniM6AqGtmKiquBvn2Ri0BlkUnpNT4IsVsgctBEP1JIMzeKvPwIInMIITDAIF3oALAAEQuMC6ksAM1EAMwAAOTIIpsIIrkEK1sF4ixBMGMEBsUQi7aJxtASzwAdINxWm1plGffRRIEUUjKpdRNGybJgRUCNrx+MGiTizGzoD/EOiBHLSBIehBGYysEtRBGSTBIJisJCwCgFJCFtxBI4xCJ3hCLhTDXXCDYLCDOGDDzf7sKI5MMDxDNlwPl7hH9XhDPNwDP+gDPCxDMGACDpgBCl4BHoiYcFRHb6hBb1it4yWr3eyVY2qeG3hBG6gNig5rHMDBHMBBss6KF5zKOAVWG2yBtaFBFgDZkJneVCSMta4HUKlFMjCDM1SDM3jwBvsCJuwBDMjADQyBEihBEpBA7dHAINDADdDAFoCBIijRZsUCtmCWaeQBClSRuWSpQrEW6LwZCvDBjWLCcJURTHDfmjKC6fIO+aUuwLDR6gqaJNok+/3B3zEbFDSCJNBB/x34LhiXgRIIAiEQzqJSQiYsQhP85yd0giSMgi8Iw8twg5uwAzeA6qcOxOF4CS0MA8+iwikAVSv0QjbEnQDCAzOgAg/EwNLCwRpMUzR5UBRgQRRUARZgwRCpwSZzshrAQal07bH6hhqsgRrYwSbDARykASfTChyc8imjciqnMiiLUP82XEzZ4xro8hpMlxUIhxzQQeweAnNSVo6eAiwFLVlo8AZ7sDPcwiZMQg4cGAVYwASIAAVQAA2ggAxwQBGkoQfwwSXwJG1GHA/4Xr4alLr84azxAJAowoiQyEkmscGOH+v+i3B1n8IexSEgTBVjhY60Z8U2widkQhmUQR0Qgv8kEIIgeGwjdAIlCIIlSMJES8IgvHEnEM4tFMPLzoM9eHRXJUtXgbQnuIUohMIrJIMvkMJ6sIItzOcH2kM8MAMmoEAMpPImn9u3edAQYfIQpYEZ+HRQ24Hj7YYob/If5cdNy3LdpDJSO7Isf3Ks1HLDtcEaVDW07jIaDMcM4eQgDLNLaKwmpIconMIp1W0xHMMyN0Mz4G0yFIMnVAEHYACvbUAFdIA2w0AM1IAKrMCTgjNsTq4cahlqrZk6r/PEPYC08EFCOMJkObZMyDM9o4jvrNGdrakiHAI/Z/Y+CxrDBImO9MGi/SclIAIiZIIgMDRpE8Ig1IQkdIImZEImSML/8FICJQzOKOwCM2TDN3S0PdRLgeIQO6lHV6GCwKWCMKR0LcQC06zDPRwKOBwDH8AACtw01d5gTsvvT6fBHwV1d3uQBxVWGBx1fnQyVDO1Kyc1HHgyVM9KdhgHVV81VvMyFrh3O/LNovpNTeCoerxFyuwCeKX1Mru1W+PCJphBu5YdDWjBEawAFBBTDdQAFuTAP9kBJrBeRJiBxG3ZbeEWySW2B/BTnv5B6plkZNMzzJ1RZTPxUzxFZrt4whyCoA0aZAUaZOkBF1QsQteBIGTCLEB0J7z2x6oCKJTCJ2iCJKjCJ8x2V/lxM4TvB5oC0w3ELOQf9wTDLoTFLxhD3i5D//T+wz3EQze4AuZUt15Bk6iogU87dX4M0R+pgWFGEzeJtymTdywv9XQ0dXqv91JLNblRtVXvsi5Pl3aQW3i8Ad/0zSHQznmM9SgA5SvcQi8IwzCk9XZ5YjHggickguJeARmc5iDYgBwUwRhUBRo+AidQLiRgQoYzxMTJ2u8534dLi9JSlId4CGSvnCEm53ClyMLezsFktowL+1VEYmhDFhfQgSBIghKUASEEQiZAtOEkuSUA+SdQgjuBLCIIKrK0whzH3T3U7chYT/2FjPwVAzMYUrpPgzaMwztATTxUQ+txQHSksiard5r79CZnsidz8k33u3rvVaywUN148lNDdf8eIDzmQfXCm7dkmmNV6zLEZzUaiFDa/hVXZ2Yh7JsVhgJJjwIr1MIunPV2kTzIhNcoPEIV0AEXNAJqInsjOIEWRmoiRAsje8CTckDmTNzOR4u03KUZAKQnYEK9FKwjJCJRHD1yPazwOEw/CzuO+BzCY0UfIXweGEkf4EETaoEeMHQgMDsRAAFDL7QeJMENoDBq17YkMPQkHMIkeIIsCG1Hkwz9yZ/8eQxZpPXHTLoxHMMyhIO72wM4/AIjowAG0Pu9yzK+r/Imr3J173knbzLXykoon7fBp3IeyLIQVj3CXz5UP2Y73jK0in6gh5sMlVB4kKVM7Rujb8LQX0t/71L/9ZR80DnDMwQDJ/QBFkyCFJBBVkpCDUx3JXiCabVhu2rhEsDAP/E8iPNAnvLAQ/SQWMeE7bwIcyLs9TsM8ayUjN8I41hF1VdFHmAekQwJ5+eHkRgJG6ABDazAEAhCHQCBCYgAEHSCEpgdHbQAEFABFaQxaq/2IAAEojGHNp061kzbPGQLkyVj5syhMmYTmTkchqyhMmjh8umb120TjxgwHswxaTIOHJVq0rRU89JOTDsv1ahcSbMmTTg6bfb0qTJPz5Nx8hQt6rPoyTlv5Mh548ZNGzRTqaJp42ZL1i1juI4xklXKFi9e8DDBsqZPoUWTJjmaVAkTp1CjTuUKdtFh/0Nnzp49Y9ZrU6IeV9o0mYQCBQxOmnDE6NCBggMUOGCkqYIDhYcGHnh05sMnkR0+mEZ54rR40qNFhlivXvSadWzZsv8UKvSndqE+u3nzNvrbZNKTR2uqjHlnj509d+40oUGmUx0XLUQAsZ4JUZ0kQ4AoqSMpCSEySfRQGiRmUqheybrFY8isGLNsFOMnW8gMmV9myqLVw3cvnmT4qCIGDjDIQ6k5dtrJJZ1k+ummnBpkKQ0If/rNJqVsOmpD4eZw6o0QoZKqjRKpagMPrbYIkauvpHDCiaza0KGHKtbAQ61H/kjkEbg28SSUVmixa5hiHNoLSWeYCYYWTERKJLMcPP+xBIYCO6igAiGu4EAGJtLozAMPPvsMEkgSgYQTUUxDTTXbbvtDNttmM8Q2P/zoAzc8bettt9/8HE4po+yoEI6i9tjtjj7uwAOPNrgggwZBJDGhBSCSEOSTJCqlogwiEPEOEUHosOSGQTThBJdiqslmIWSKCaaYYnzxZRhfgvElF2B8ocWWYoiJ5RduzpkHHFkg+aMPM3KA46SeitvpJThkmqm4ap+lsFoLta0pjm7jMKnQoAoVao44wojDqaZCfAOPEUs0EQ2xxmLqjTGcsleOsVBkFI8+/DBkEUceeQuTUz3xZBRTWsGF1liTkciZaSSGSBRI+uCAgx408YODBx7/YEABB1ZQYQUMMIihMx4+U3lMSCo5mBNMMKkktdVww82PQuh0U07WCrHzTj75/DPB4P4stM/d9shjtzz99UMPGoaog5BAAiFkCBaUqGCCSomgIpA6ytBjkEEk0USTWUoZxReHaFkF7lPWVqWUg02TOZRLRImFGGKg4UadeLLZRJFE9jCjBwTB1dY4mZ61KVqaXFqJcW2LNgpClLptCkSm2m33XamyyMqLEO8dI6sxvJBxDaig6tePHR1xqxK4OPFElFFWgYXhu45RphlnoolmGSWFIeUPD+zwBA8U8MCAAQw60IIEOlDYoo8leDCjzDH54AES3D3RBBNL2HqETmTx/8z555x99hnooIXusyje5jBqOD+NujP+pptG1k6GeMIgOpEEJVDBUoKowxAm4AIqfI0QlJCEJBBBCU3kYhaW4MQo7IKM2xlME53ohCQMYYlK/KFMl0iFMZrBjW+oQx3wiAcx/qCIP9ihCjxQnIKc9axpxQRCNAlDS9LwQyM6jicd2qGCOHQTm4ThXE3hQlRcd5V3sYENWRidvFgEFhWR5Srtch2jYscjgl0CEz/K3SlgwTtY/Y4ZzWiGRBoSDFHMhQ8eeIQHHkADFSThBnTogBcYcSxIXKJM3TPDJWAmM5o9An2GUN8f2GcnncWpfYVIxJt4s4dEfHKTbjqEm/zgJ/+g8QyVAfxfbQyBBz/QQQ91qIMSvAOKWQgCCGXIBCF4KYlMnE0TpdDEJ9DGCVXkyhIhRJsmLNEJS8zuEpsQxS+goY1vcIMb4QjHN8DRjVCAJlk5ZNbiFlROaRXxQZCL0BDVYERp/XBC0fqJt1ICoTREC4pxCNEUr8iG0LUBi2wgXelYhLqtlK4p/GLU69yAh0MlQmCVcBkab5c7USjsFr0oUkYa0pBiXIQUfHDESKSQAhVwQQgzeEThROGKUGziEjH9jPjIR7Pz2exml5TTa3ja08KBUhE/xY0m3aSIQ4wSlUnlmSJ49i/czKYPi8ADFBCRnTIQ4hOgQAQhBGG1MgT/ghISREQyNZEJZ57qmGGVRCeYeSppxuIY2lDHPfzBDnLclR3r+IY3iMEHZNlhCeJEiRNtMih0IjEnQuwWTH74TneaC4rnmgMUu1DZyHorn5ClZ7fesAUufFYLWvjsaEnLBbG8gaAh2oIUwsKUhCoUD8xhzuv89ckyVQKNmzgN7nRXi4Y57BjGSMYxlNSLb5oBDTNQAQpmAAdFHFIYvSDFdEWxCTv8QU2L0YRNU8MIRayGNUEVr3gZUV7zljeo6GVqIYJqm6CwBAxzcO/9lGqbwgUVfgBzBFATwdRFNMKZ2ZllEqoqiTr8UmyUIOYnPkGJWXzCEpKwRCky2AgJT+IS/6GwhTK8EY950JUf/CAHPt7xDnOswxsg+YwdsqADHSzhW4uTp0rSYIbDxoSIOFHDuep5RDs4VibdoqxkK1vkImM2sl3IrJBXV9pHOfmzqR2Da73oWnbBVrZ3WAMaWtevQ/3BES6Di49wh9FewKqjylBGNvaypFAUAgeUwUEiYhqKX7iUFKkgBST4EL41MbN2qXHEd12jiPOilxGQhOShH+Fd3aSlvocoL1KPWumlijc2OdovRJm6X9ZYQoFlCJUgCmxWQkyQ1CGkRCdmkQlKWIISnlCFI1AYCrhqw8P2qAc97tFrf+CDHyVuxzy8UQw+SOsMWRCCDWygIWgVx7A3jv92tMzlrcb5+IeRDYNlt92FKBS5Jeca8ra1DUU1TOVdpBWtkxFar3VthSsI7ZwcFDoVLU7lRlY4gx36AFGXhZnMF4XFLoJxl4c5Y1XVUBIyfNGKTXwvw5uwBTH0PN3AMAITdotZ7QYGydnxNNGKXrTISV7yRh/6vOJFqigrHVRQAsw1AetveT+pmkaQYRAVPDWpSU0JRJhKFZ/4ZQXFala0lcLWx7DGN+YhD3mgAx3tyIc/ek1XeuwaHuDwBim2dwcrZMEISKhBjBUUOeO0E+0/hlZPNnttbM8kDdw2cmWj8G0jU1bJSxbyuUsUWtA+AQrrniIX3N25em3l8F5Qlxv/rlxFqaAhKmu4ww6aoO8vOwJPz81tKEjBioFvlBnVULiSKpKMYsBiE5wXRSpSEYuKI7ISG4TZdmn2SEi+xhEhZ0tqILn73vP+9+dbtHmHf2iWjxeoi2DEIpi6I0bkPuSNWMQg6EAHQayaEoLgqqQYPGFQdMLVoQKmCEsBD3g0XR71uIc+/OEPfuSjI/SgB9XtAY8UMwMSah+RSsqVz5NEdsfUICXCYMfoidw2Sw2OwnHuSccs6wu64AsisLIkcAK/4Fsi5CUYECfa4PBSB3UgD3TYwHWoCCpQp17CSKEWJbayjDn4BWjIyJIEZmDgIi6AJHdWYUjuwkgcgiIqAj7u/+yOQkEUSAEVKqYQKkETRiG7yMeEKmERBibkgm/32CLQfA/4ptC8foqpLKkPmGY34AAP0MAInOALxAAMzCAm9kAND6UPcKwK0NAO1MIQyIYEVqAMZgEYZsE8CEEPJAEYgCHnMuGXJCGsOkGC2IoS5KHX9EH+6MEd2q/9GrEe7GEeiCUbquEV0FAl3mUmymWzIEvvQFHblAwBg2JaWAInuq3I7I7u5g4CLVByNBAVhWi1nCAspmwM+MUNZEsE/6kr3qWhGIUFh9GVXMkPYMsYAaZHaieNbgdhFKYWdqEXhGEYjuFhJiLNlOEYfiEWposUTmETfsRu7mZm2OIJGyHkEv9tCqfQ9tZxChdtdjyNp9iLvRztX2IDqe5EJdRwfroQDuRED/TgBhLABDIBGEAhgjRhgizBEn7uEwzxOxCBgiQowuxBHtThHNAhHdqhHfAhEtfB/M5PhrKBF4yFB34MD54i8rplKPCOxwywyLRNyKytcTKQiFqC7upOJ3NSJ3fSFWPS2/Kusr6odMiiUdZgDdpgDbLgDAIKi/6JDbJsBBsqIPklIAPyGHmDUfYHomaQGWvwolYBFWAho4ShGKzxYZQhLZdhGbTRGIphF1ahutbEkXgvYJ5Q5NjxLdyRL3evdv6SZvCy0QbmHUEukuokZxZBLRShlEqkNvYgDdagCGj/oAA6QAnMCvxIrYIQIYQqyBCrihAqiBApYR3WwenoIR3uyh0uUobAQRugYRmMQRmMIRZCwQ5OEg+c4iqQUrL6b9z0rtvE7SUz69oY8CbToCd90sjqDgmaUzlX0dvsjrLGYqDGAimpYsuwoCkBChivqA1ky11e5yphCZb0QH52A2i80L46jmDSCHdEQRROwRVugeBi5RjuEz+VgS2HqxdeQRTkwhPCsRxvTxlXqi+Fz+ME5h3ZkWZmZx0VrTVeQ/oMIREYoRCuEg+yAAtQ5BiZIAdgQAbMoApggAdwYAk4oAAGgRK4ajO1T1JEk2oEkRAHsYLcwR0cER20aRy4yRuy/6EZiEEXSEEYfuEXhCEYMAEGYIAD32C0pCLvQBEUua3cPlGzUgLtJgQLshQLkrPuVlEnmxNMufRLk3MoVURe8G0qshQNriALxqANugJO22ALrOKfRtAF+6c39oRPamOTFMEr4+JHhPAUWKEshcEYDjW4ZHM2fyEVqiv1OGET6rIRpA/3HPRAS64SZPARJrVSZycR4OQej1EO8mBO2yDZzmAJcGAGXEwGZKAN/ssQ/AAOulA5gqIPbisuNEHBZmGEeKnnqmoQT40SXM3neCms3iEd0OEcYOgbvkEbqsEYeMH1YqFXimEhcMEMUEAGpqxJpUI6Mwvv5C4UkUzcrvQmtf90S8e0J50TTNs1TNf126LAObvATLWCy5ASC5jACrDAFuGtK9ZFdZRSYNeADQjWihgFPffEafKkX/pgDdVQOfqtkMbMPYXQFFbBFWzhF/oGUe+TGHbhjiIVUiV1UhuhLdwiNfpS5Cx0qIaqlL4Mh6qgCnoABjhAW2UAMRAjBnI2BnCgB9JgD97iLy0BYUahFEpBFZJWFWhhVnLlD0uhEeogrLSvDiRSEvQA/MpAayVoWIVurTphHML2mp61GapBGYhUGMxyGPxiITDBAxBjDEDLKqaiS0lRyFRRKPNW3O6WsowTXWVWZpnTOQXXXd2VcJFATHVyTtFAi67AcaviCpj/gAmuYF+x4F6nQg3aAA7W4Nwi0w7WwA72LQ1rlQ1542ZuxmGVRg3vwA7MwHUfKsz8jcxCARVQIWOL1Bis8RiGAWRfKo0w4RJqhjXs5AnjcdNACZRQF4eWYAl0oDFqYCRgQAfa0Ax4IDF61gwcQWZO43ZGwWh3hxbCV3xxgXxzwXzP93x9QVeAAYNKgQwWQRCSwAWUoAyUoBA/4SB3rgzq4GqCLjQpwRu8QRua4Rj6hhiK1Cx3N1bwIw9x4G05YN3YYCrOAA26dDjvLsmULDqfVBS7gCawAHBDuArkNUy9rV2FQAhOOIWbswhauHB10gkcV4tmmIaz4AqaoAmuAF2p/+I4Xdd1cczGfiw5lIMf+xFRloN1Wbd1EeeHd+MzcMMRfEQIUeEVypIYkmEYgqEWfPcv92sP3EANJBMGquA2kmNMZGLFqjdlzACFIIERJkFm3DNhTmEV6FhIhiQX8BiPy3dWZgUXdoF8yxd9B9l8Z2EWPMEQykYJhqAFNsAFiICCviMPQ1MQBOGr9lcife4ZkiG6itRh2owZnkFW2lcT/IkJmiALrEKCkXINWpGyouCyRrFu604mQdEms1Rm0wALBjc535WEfxmWdRkLznWYLaMKdHkHduAJniCZmTkGnlkGoBkzPGBnKaNKEAMGMsMDsjlnuzlJk/SZe9ZE4wwHsv8gB845B1pVBr55Z7G5MZI0TK7XDPagjaNJCEnBFVCBFAKjRMOkAR6gAWKAjw4ABR7AABoABbaHjRPpkMIxFB76nlGhFdqojWpBfGsBFlyBFVxBFl6BozuaFUK6dlGhFkI6FTaaFWQhbXuhfFvBe+vmNNCmEeZQD0hlCPRgf7+KaixF1EQNFCy5DgTBO0Kzak6tFzLqLobhIZ4hG9iWFv5TExBmEaYiB3Yglc+AglnZlbft28otXFVRFLstClgClwEXhLm0cFEYCVKYhBFXmNEVC9QgS3VZZq3gCo7gCbIAr7PgCZhgB1yM8nbgnK3ACnKgBwy7BxI7B+JMsVt1BtL/OQZkwMV6wHlnAAdoBAda9ZmzuQMMxGNMBqAbQLQ9RrQb4ABK+585IExUBhIw4aEtLhG8p3X9Co0wgRH+MlDpGBVC2hVeQRZ+WxZsQbhlIRZcwbiFOxaKmxVYzxVYr/WKO7mj+7eFm0gRmBiKwSx1AZBpARkqAQuuoBECchBoYAWe4wZWQH6BoIKAgAiuJhC6A6uSoDssmZa8gwrARpYQoRd2kC8mAhmCYRZUYUo4YRIQRhPQgA2+rnLnGsd+8ie/+gCllO7IGoTNWkvX1V2XjdlsoDlRuAgAV0QB15hv0t6yQIK/M4uiUgX7oFH0gAvoACr0IEMTvPKaoAeUzQZq/6AGRkYFZiAxHtsGciB6EcMDMKBjDkABGEDJG0ABDuAADADKo9wAnjzKT5sz2DjDhjAVflujWaEWvvzLb+EVvhwXwLwWbsEWZAHNZcG4XSG6k9u5jfvNo1u4dYEXeGFjieFQc5ctlwEaomEarMEatEEbuKFHtSEbXmUXwjcXLCEGpIYF6pd/p0MJgKAF5jcQiIB/iYCWJijB6uCBqiYJkoAIuqMMqOCAqGCB/TsYMMg0mOkzD8YQEJywcwBdiwgnHVzXMTjvyo1B3lqXWyJdu7StC7ddo6AKmPcNQfwNRdR1sQAPJDgYmeMMVFCh3IAL/O6zjsAGiiCdhRwGdmBkUP/AyN82TDDgATBG3T0m3dMdAxRAAR4gnhOjCvoN4KIpQAV1omsBF8iSPnsB4H9hFwZ+4HXht3VBuNM8uNM8Y22BWm0B4SP+zu+cSPU8d38HGjI+4wGdGqypWZsVm7hhG0ae5LdB5LeB0KFVu3FlFjShA1RgfoNACUzABayDCFwA513gO2qevbtDEj7BkqmgDjg9l7SW04VelsBmIoah303DaJvJEIdOExrhKvQNBxbccrdsCywrOllx1726loVM13vyAYudXVcYcavAxQJL7dde7Vd1CWogmiW7CkCYeRf7nBlbBjogBVBABToAMYz8swGa3Qnf3AkfBZZAOUBDESr/IRzfU3dgAY/tYlYKruCocUgRGG0nHs9/Ac8n3s55wc51IfQnvuIRdRnkCBqk4RpM/htCUoYqUfbNr1lL/vUt0unWAYbUYRywieR9/xq0QRls4RaGwXwtYQVWwAG64wcAoQ6CAAiopgUqHQhQvdSVQNOJQBCoYNQ55atCrQwkQegJYajrwBdW4dVPhSE7ocEkoZIlzA+ggnIJG67jZeu9tG4f/LKqDezLLSb9HyC6COzyRWAUJEIOJkRio8gMGChi1KgRo2JFFBw8YNSIAgUMiB4aiBz5gMMDBQ9EHmiQUqQHHEuq2ElUCROmTaJMnWoFC1ewYUCHFRuarBiyo0OT/ypVaqzpr6dQiRHjxSuqVGLGji3bugwatWvatnGDF6/svLNoz9qzd4/tvbf+7sWN29bePHXf8uZlW48ePXbrwoUbx62w4W/ctCnjZQtXrlyWUtzIYGICFRFUCLlo4aIzEBZAQpepE8gEIipAlCSpU4cKFSWEJLGWRIj1a9eaNFni5MmSJU2dOlnSUwdRJ0mLyDzRkmWHFRhZzqDBsqX6loFRsmvfPrBLmDDe48Tx/l389/PnB8ZB3wVLFIMKbdiogaSGiokqZhSJ0RHjg5IcmCTSfyylROCAKODAAx+OVFIJJDdtsskop6xiYS27+BLMhkIN81MxQXU41DHHFFPiMf9NpagiiSmS6CJX0EjzlTbSYCPWN+CYldZaPLollz9ABgnkW3D9COQ//iCJZFx2wQPOk3sRSaRd8qyjzjjjfKMOXtb8okswudCiiQw5PLHBBAuEZkILJtBwAw2oufCZa3UQIQJsggARSB1KEKHEaJkgwloZo7Xm2m+U5GaJcJZQ0kgjg+SmxyBPtHHEDlnI0EMWaExn3XVptBeFe1ggUUUUp2LRRRppqMFqGnCEgUWrcNRaK3jogYdddkjoUINCFH0EkX8BlvRfSR4k25FGPMjURyKKOIgJJ6KMYooprTiWi4YbbghiMEMJI+4wwmBVDFbGXCVVuVel2y66WZG4VYz/11zDDY7wkBVPWvP0KKW/cB25pD/8FGzwwfz8M7CSCivcz8MPMzlPPPkipo6PU65Vjzwcy3OWN8bo0osvuYxiyRM0kCBBBBMooQQQGYggiR4pkDFaoYiUoQQihFBRByiZ8JkZIkCUIQgRZQTiGiKBEEFFJ5p8AnUppVjySSnCRS0cDSp8dJEMKKggdgwwVCSsRTGAPexHHvXXEUgZJauRBwHWjcGxBR440oAsyZ2gGXz84Qgkl2zCSSih5HRKhavwREsttNxSCy63VE75LbbYUrkuumRuS+efdx5LLJxzTtXpVD2F7jHKzCsjNdjYeO84W66zTse4d+yXXz3So48+/0D+DnyQDSssPMLIF9xwwsU3r3Bc8oQT+/TbnEOPP/rQ4w49WxJWGDZlLfMUmJ7oISgLoJlARJ2ECEIJJZkQAowkdMwmqJw51zHLJ4TuWcdqSCOCoAhBidrUwRO8EY7UfgMcqGliEpLIAQxkwLaw9UdYGBSWR2DAEbcNS1nLmpvclCUsHizBhCa0w7MSAYlKXOIS00JctaxFClSgghWseMUrZMHDHvpwdKOTBRCHGAvPjc4WQDQd6qSSldYtoxkyssY1sKGNe+kFL7VjhzzYwUUtymN7uwujGPGRD3zgw3fCo4fzFIaP3zUveXBM3hobBiR7nGMb07NROOThjzLmg/8e9TgHN7K0jW3EwxrEEEYwfCEKLLTAaS8jAhBQk4lZ0AYRsJkFMiSxGkKMRjVE8FNtdNa+4pDGlFSQhCT818DgfOI3sEyUcPQgQbLBAAc50IEMZIA2s7nNgxVMEA+GuQQzwCEPffiDIiDRwpscThTQrKENdbhDz93iFbCohTYxZwtWuMIVseAhEYmYinKWk4ifQ90vmJgV131FLIP8xmBsV7t1sKMd7mhHOt7Bz36245/vcAc73AFG3/klH2U04xn9Irx88AOhvwve7xCKUDP6kaIUFZ5G9dFGfTTsd8nLxxz/wQ9/uEN6sSvkHglG0jKy4xyEKaQ2ElmMYJiiCij/yAAQeoaa0ARiZ6JpQRK4sChBEIoQnkyCEgThMiDUoVDvcxkipioJSpSBEDyD2ic+0UDgMHCr9LNCD8aayx7oAAc60MFYq2AGM9jhrcmEFjNrsglPJM5aOmlcK2jBV1zgAnJ+zUXlBrsLznkuc0csImIPCzrD6oJ0ujid6uDlOmnUy0bw1IuWtLSOdHjWHOQIbTrM0Q5+enaf/kxtP99BRnrIQ4y7syhGZYtQgznUeCAtGEYpejCRjtR5cJxjwbAXmMEIJhzsQFg68BmOb2xDGuk6RjBggQUU3MAFoGFBGXYaGiAkITU3WA2lBFEcnhFCCbNJwp5cZrRMxE8SgmBB/wlgEwieCQI4XG0UojQhCUtgbWZ+WMQjHFQTTvDGE9UqhSr2ytfH+EJDD+ZWtyL84F5Y2Ba76MUuCnsLXGSuc6ULMerUyc6maKUr0qgRPO/1pLK42Cyv3V09Zhzjg9LjHeYg7WrbkWPS/vOfoEWHOU6L2tXyk6BcJChAWdvRie6WjA+t7UPd6DwqF2+j2btekDS6W4oqFB/+ZEc5xFEOwdzruOV4R0vzwdpybOMb1JBKUWhRCBKI4DMsaEFqiPCJTLRgCJlIggtWg4hBIIISmKyD+yghCKQiAhRMOyUiJHFVESTgABdYqiAa/RsHSi0379MaJT4BjFID4ydBOQoyjP+i6lYnJURDSaS4oDLrqkAFKrYu8byiMSNt5CVf++KXWnpEbB5JSS5xRBibyTjb2X65ogrlJ7S//A6GAq9gGi1el7tsMDoqKUnglujwgrc7gqLj3OgmsrrTgW50hFag5UDHOc7RvXOgoxxq/IdDH8oOblDDGLwoCi4SUQMTWOACIpATEDpTh6ARohM6K8NUyYCITxBCaWWQTR0oQZsCrvdPT934Bi5QB6QiVdGS4FkmOpEJStQh5fYlhCWA0epVLyUpqjbKUI4iFBOjyEUkcmIzeE0Na2jj6Efnhje+AQ+0FNstc5GL1IVkMCFZnXjLS7YcE8b133p9jdnOum6lzNv/KI8dePfQhz0ASY+1b6xK8z6u3MMhjrrX/bihzTs5ysH3vvudi+uYtz1t10V6IEwf9fgGNLLCjGFcIgc0sEAEIpDwi6O3DJ1gagtcpoRPcFKphBoNeevQiQLS5qmuoUISBBGIPqc8EHvCKnkRsemXT3X0f0qCHjyRixCpi50gAhGsi1GNbBhfG97wBjj05WJhn0VHw/6R1gkGboYxL7hi1zpJD/bbq3/9+2L/h/CCZNswEnTecZ+7+uled7+3+/3mEDK62XHucwAGMPbkmJW0yP/boZFg7yAP8JAY2VANzOALf7AEKrAADjABQXBnfRIbfQIEeXIDSkAGU3Bd3lUo/0/VPo3maLC3M7Ixei03VXsCX5TQCZ6EVfCTMzkzGnpwB4agCaWwCsNQDdXQDEM3DctgDM2gCx3SLULhDN3gDd2QI013GFqiDlqkD/dUD9KzDVM0RerAMVeHPcPzO25HD2lXDxu1bWaHMGR0hQzzUfqwW8zzPMQThlLGfXI0R0zyF4GHJXM3DnUoeLZjOx2Tf9WmZPkUY1zEMezgF6+lOzNmD/WAiBxjDwIogFaiDvDwiFkSDm/GDdtgDdPQDMawC6iwCZOwAySgARcwAj8FGqlRBpLkGqc4BO9zSiG3VeRVP1MVG5kQCKXUPjwjCS23J/6TeYdGQDrTcExVBnQgA/9Z8ASGkAi3kCPKlyOx0w3KsAuKhGrlIgxEmHz5MoBWJA7jgA7sQEasRQ9RWC9UKA/1gIXhJiRvQWyHOG7MpnVVJyQRhXXFgzzFIyQkpQ9w9Du7U0bvoE/uJg50N5DnVmZ1iCVYQm9bUoWuJYh5eH+4M1Cr1ZCB6BeH2BYNWSVbghh4lEfXQA3UkGKvA5IhmWL1gonNUAy6wArQpAl+QAIsIAITAARE4AI1KUlFs3CkURuSAGmZ4DRUIAidMAubVj/kRRsXRwSNZjSN9nqBMHpYZRwqKCcgVzRlkARaMAlTgAeJYAvgkHzeMDHgAw7dkA3IsCEjIwy9wAvCAA3ecC//8CAPVvQN3HhuZlQw7tCR2DBF28CQ4idSaSh+/BhGEoWFWQZbwvNtHgV+CtN1XDdcQQIXWSZQ9Gd363eZAsl+4hB450AO4+CZ5HAO6dBZ6FcO5DBk+BRQ7sBPN0aI5tgXe1iFj4gXhaGXJSmSIgkNuqmbXbGb0rCbMaKbzYCSx/ALskAKohAKnIAJlsAFdAAEF1ACnUEFcuICPnOKKPdTLuNJPhOUiuY+k8Y06wNfRnNUmbBKSEVe7TMaiEYol2eVgrAIeqB7iSAMb9kUWtJc3pANzPAMwZAhi9QLXkIM0WBFeJEXCbk9d+kP46CXsbNHvhOGyrN92PZH+NBHZ4ih//MoUf9ndYw5MEDCDxyFZPSHfpepfvI0kOqXmXJnmqHldy9aDkT2Yz/GDulgozCFJeKQF5aYR7ETkreJm0KKm8BZpNCgg7+pg1zxRMpADCuZnHWlKIPQCIggAiXAGTipJ4KweTTpVN4VGqr0J6NBB3QwBapUBzTpAj9Dae9TG56EM4OyGim4aaunM0wlCHRAA05VCczwllsBD+pAb92QDLgwDA62LbtwC2tJDNYADjyKGAnqOxfqDyiVR+dwhmu2byFVUQmlqfxgbYV5hcqTDxylPQTlDuzGbuxwopjZd/eWDnynd1hCT1ZiJfRWq+pQq+XQY7z6DqPVY+SQmQ76o/9BOqTGipvF+pu5KZzNsJvR8KzQ8KzS6gzNwAxNKgy7AAunIAqegBMGpgmNQAIpkAFX6gIlYIpOwxk+RQWidFWUlhpJMARTpWh9sj7uIwi0V3LoRQWwFwiZMBpTxZRLlXsSVwZ6oAd0QARJwKc5UkXxoA7NlQ29sAqe4AiiQDK+8FeFxQvGYA1aci+DNA7nsJok5Q/iOD18yQ76OHZtiDxl11v5cHW/025+x6o2a4fHhZA4O5CZKQ7kYKOdFbTnQKt5eDt5uJBX4pnh0KM+GjtDGiPHmmLAmZtSq5u/CbUiOQ1aK63REK1cK606uIPT4AzOUBTCMAy9AAuoIAqbUAn/k+AJuqEJnqAFHUACJXC3GnC3JSACVipfLnBeC0deakqT60OmL0cILVAGqIFUZbBy8JUEqWg0x/GviPBdoZcEmKsaQ0AHK6ACQpUIveAN8ZAjefFm3cAMovAIj0AtnkALuYALsKALv8CxvsYN3Ciy7MBaBpOXsTNF2BAOETp2Ezqhz5Nlh/kXBRmsNouZmhmsoBkOoKl3dtd3CXmrTNgx7JCr2ks7V4IYllhIHvkVyRq1xmqk5hucOribzdqsW9u1YXukYdsMTxS/9LsMypAMxPALtvBNyJmcBsYJqkA1qtAJNJABZSACGpC3JaABG7ABflsCocECRCBfoaFn2mVJ/1NQP2VgnZLEeUMwBO0Dcpu2J0xlAoN2lUrgXkylGk+VATBJBIYQCslQhEWofN3wDMwwCpUgYJzgCJwQJrVwC1VBDMtQRd8gsqsJZQ9lDpRIPePghSx1j8Jjbuhwd8fFDVd8meQgd3onqzpbveh3DuUgtILXRWa8kN5rGA76kSRJvuWLteWrrFUbrV4LnO7brPCrg9GgpPQbttSqpMvADNaaDCiSLsLwFLygC7LgCqlACshpQ6dwLaMwyY8xC6XwBB2gASxgAQksXyIgX9JZAhugwAsnJ3crAjmTgkOgBJIQGgonSUZDAzYDG4JSXklgAklQKK9xnrVBuEAwBJ8UKf+j4Av9WXzZkAzkMwmNYAieUAqYIAq99xPo0gz3siWGp1sGcw8e0y/HNiR1sTFaNLT6N2+5ug6RCKiROFAkmn8xhjtJjA/55A5mxGT9tEVVYrQLiZBqXJvDqg2xExaFFNACHdBHd1k2og1ggXRIVy8LvdAnKUXaYA0SPdEUPdHFh4MYXQ1aS7aDXCKz1gudI0SMnAo2VNKOXNKQTE2wQAsrDQuzkAulwAWhaAIbYAEiYAF3Sxp7KwItcK5U8AIhYAKsAQR6RnvYxRqd0KVqioqK9j+rET8nGGicxyd+8jJ8UgKj4QL42jRlILeeMAzPMAzIMAytMAqqYAmC0AiaYNb/BrZX3XIuWrENgHqOFCqicsgxGYl/VZI7uMOIi8gx8dCIcZk7GckjHbMWbQHO9EQ7MQW+vcvGtwmS9SLZ5EiOCo3QH1nZmH3ZnN3Zl30N2XB0FW3ROFiAxqzRzsAMgXy/Hv0LGmZYsVBOjtzIjlzbth3Ji3MKJc0KFmJDtLAKvw0LwN0KlmwIK7ACEOzJCVcCkrQZIhACmUEIQRDUrpxKJfdIddIZN4AIobRUfJLLTDl6tujU6oWmm7ddf/IJ3O0CVi1zvEELvgDfj8EJlrAIMie3busJleAJPkEurPMLy9CX1vMP+CB+AcWZI9sOZpxPf9FFeVgPAViIrxWIeL0W//OQjfmCtBupF45Njm0stcoKkkNKkpFN4iAp0SZO2eQ40QtN0QWdDaNtDcYH46eN0dOA2sxAyMcgFYgc0rHgCjhE0rYt27WN0jZk27V9LXm1CotjIUxeIa3g5ExOC7NQCZCXAujzGTid00Rwt0DgABbwAi8QBNLNt55hnXyiBHJyXqi4GUSQuIdmVKsh3lsaGoIgCT7zMuS1U9TZXZuGCJbgCc0cJsAwC4sSKZ/QCJNgCJPACYswCbnwIVmBFdIQDgOuMO+AbqWpd2M8mkV7f/fwdnuokd2ztJZY0B4u4kJqvl0LrdEwDb9J4ilWknZMtdE6DUVnDSY+0bke4xn96/84uNHUar/KUMiHTBWcI07fNNLmRNJGjgq6rdur8OwlHe2mQAqjQAq5HcnXUiFN/uSrgE1RvgoKJgp+kBvfJQklYNOBAASjPEldfhkb8AIjEAI/oJM1qWfs7SfVSdSfUQGVB19D0AJ8Qq9POdRDzTToFUl6QgipIRuH5tUBzFWIRgeqxAXNbAmToAm8MQrBkAzK4ETQgA19oWb64KvLJVD2h3/krJAbmSXOhUcBvZeqTrVXW6S/2epTKw1c66xeC+smLg2wDuvRwPOvMw2vPg0TrbVKr+vUoPRM377PqqQhH/KEbMizm8iIFdupAOTNXk5AzgomDcnQvu1Szu2mIOX/qPDk2744OqHkcM/2cp9NOxHAqtAIGBBepOECE2ABFuDK5ypf6LMBd8sCLvADeebwf/LKXfpnGphw36VU7TMEjfadRfM/7AobfuKlobRKcrInk8ZAviEbLoOvktAIha4HmjALiyATm9Cntct0iO1agWc7CsmjM48NH76b86K+84vH6luk6Xu+0uqsSL+1TA+SRU/iuJ7rTx/1TP+1exy2xM4i6YLIWg9E3/T13G9OJl3buX3tSQ73kwz35t/2jBP+kkwhuN3tuW0hTc4TqyDcpTAKbrADFFABEyBfGkAEDbwBACGiRAmBLUQIFGGhRAgWLja0cEGECpUyE8sQceHi/8aQFkSAEFEChFAnSWWUJFGSMhAQlEoueiRSR0kdREBueCwDREmmT50+zWp0hEwSIC3KdKpT6hMlQYMGIYKCZQ+fVNW8abN27Ro1rtCWfQUbVqwysV/JLmuWVu1atGjZgoWWVuzatdGgRcMbbVreZnejNcsbWC5YZcqOHTNmjNjiX4x/8eKly1YsypVjucKMOdVmzqhQkQId+nPo0KdCi0ItatTq1ahZv2ZdyhTs1aZs3z51ypRu3J5R5V61qhWtVqpG+XHggIQIDRpEbHBhsI6EDXVcsCjIgkWJ7doz4syEiFCgQCnLJNlYlIXOMpRuJBGUxEWZQHWStAyU8yiiQP+UCCmRJKSQCOlJEkQGuY+Gj0TqBJEGyRikjjpoOGKSUVrxpRhjGhOmscU+BJEYxRIj8bDDDDsGxbPKUuurZsoCSy66ZqTrLxpfLMywxIjp8DHIIrMlyFhs0eXHX46MTBfJJrMsMydZYYWzKDlLxTPSSEstSy1DCcU1LVOrjTVRbrNtFDJlI9M3VIILDhZVVCllEi0kkMACCyLA8wIggDDhIxYgKiGiP4FIqIQ9P4LIBEQoWa8MRBApSb4/1/sPEUGUuCEn8STck6Y66gsvEEmAQASUMsiYQhBKMpGkDkHq0CMTQggRJBBaaRXkUVfraMQTVWgJRkQRNTTGxMOSMdb/2ByXLcwtFml0JtrA9JqmWmurubaaaLdlhhllkEVssR5/VFLJIM+VrFx1I+PlyF+EgfexX8w9N0hZ7pXFXnxleeUVWGCBEjNW+iUYSoMPZuW33HJTeGGHH8YN4tx24203U/7FmBZaYKFlllkm2YGOJO50wIILIuAugg1ECImFDfZ0SLtBCQHCBUSUMMGoojyioo5OMknChEtb4Ag+ST5BpAxBgJCJKI9s/c8kAWWqQ2Raq646CT0ere9TVeuQCIgh6NBCklJawSWYYtZmu9hkwU0m7mSYNUxuunNsqxln9N62b7/N0lGxeH/pZZdy67VXX8QXv4VIIpXcxXBdeunl/114x1U3yMbr3XdfV15xJWDQCz54FVZMRyXhhn9r2OGGbXN4FYgtXhj2U2pJneBVOP74CBpSoALPEi5wwKESNCihAhEIhQhQEVqgAghDA4mujPlcMMEFINq7qIwhKEFqCEFaoEQVWZHGCWymlXg1ppSUCATpk8iAkA4oprjv0pRYUrqOTAQxCXfoQAZLjEIVuUhbMUCkGBEdZm2ISczb5lYYu33rW3LDoNxMVIxhDCMYwqBc5G7ROHxRhl8EA13nVHgvzuWrXiOE4S1wEbnIhfByPSpX42J4i1r0cIX4Ap2TXtEKhJ1Odado3cR0s0SJ2e5htUti7IYYnNy8qREqSP/BCjIwgQlcwIvVaQgRWmAChASKVQP5SM9cEBKQjDF7fNIA0rY3E1DEByWrkgQhylCRPYWkKDqZIxFA8olP1GEINsmEJu43hSm4pI+qokMkJUQ9EVCBEIPw1Spw4YsODmMxJCIG20SZGLaZCIMaQiWP4OULyhVuFzC0V7/+hUJ/1RIzr5AFLGqBMV3W4oeLY5wtdijDGe6icDYUxtqOVDldvBIXMewhLH4IRNCx4nOtICKUPEPF2ZHJm7WzGMUiBsUonkI4r6BiKYzTiA6sYAgEwVMgRmCng+xJBCZQAgua8zKPGGR/VLhOC1qQCTEeSjt1qBlHTOIoQUjie6CgRBL/EIHQNoJkPXuCSB0kQRQTJIESlDhPJ0SWk4gA4aN6GIQkKFGHMsikKZNQJyw2GYxh3NBywghGTnPKysv5gnDH1AUJZRGLoYZOm6pjk3BawSZsDtFfHMMYNlvxrx7uEmOyqMUINXeLfLmwXul6XFCJaUzKsdIX8CoGvFQJr8r9VIRa1aot7mVVWfbrlthM6ppWkURv3gZNfQUNOMc5sb7uLjelMOBxUlABGrTAAgJhwUrstIENDGRlZWBOZblDEA24QCAZwV4LEEEFNyaBEIZiWnxWcIMVIGIIN7jBSDJxqI+sEWZFmY9HJCEJFlgqE7JaVE48MhOmZaITlmBKIDqx/1JKDEITqlhFVnGRi2D4IhghbCUutMvD0ZFuM6mrEirC65mHvc6cTF1qUpNqxIERDGM+nCswv2qudClJhsb0hXU/6MEOHoMYunjX2tbKVlc+U6v4ompVYdHd9AbnNw4W7Gy8idjaRIwUS+wrE/tqm+K0ohSIxQMGUsCCnGigspKwwARcMAETT2ADZBTBBAjy2PUEKhCDykjOtOcCQxKCCo5kn8imACkySEIF7GuBTpQQtkAQgQU0oYQkmsy0IQxhUS4IRK5QkgSMKCEidQCGKgahBz30JxOg+IQeLEGLZ6atutvV4Qh5OcUGq1dNd8YzeRfGujyrTrzi3QwrmorCBP+vUL71bSZ+dcpftYayMcYQ5eV+6koYVjWaI9xlwYbYYM9oU02k2PBtKmy7UJf6TMX5sCf0wAAKVHZlA3GOBViwtOtwxwLIe7VltaMBQkWWpdirWSBmYUg+6cSQlBggISxxA0oMIVUyYYqfWLqqQKA5JtHbUxlKssaZwAQi0dOoHuhHE0IEQVaDaIMopptf6xoYzrXQGC+lWmfZyQ6JC/PznZ947z2T4jN57rTBWkFLqu4LmI2bIS4Sjd+z2jRecXPGMeLVo1YWbpiVtvQr2juwBaOTTQD/psNI87ALI9FKoMGNX9X54VRzggsMcMACJmCnCJRsAhGowBo/AYo9seD/AgNhwX8EAgQSlyAl68EJbh2V5BtojyWZSsJGb0ADLQwFJQAcLkYcpQRCZAJsPO6E9GJCCETAhAow2SMRcsISS0iCDi6Ridi44AlgdHIYvWB3fnPhC+1qTMEaw+u8pdqvpgpe8OhF4VKnKpyAZcaaT+2lpbMaQ2EKE4baVTgNbwE5svLCFpABMC+IwYyIF0kXlXGSZqjEmStdaTStx9KXZI+a09CeNJRxxWVqgYtW5ML3rXgEG/RAgx3IIAUd6EAE6LkBDdy8i13UwAW4XoKVacACBil79kyw/Yx05+e1dlkLZIbRmxzUy0cTBA1uAAUJHZIofyQE1VpAXCyHRKMR/yFCEIBQnokSJSN1+IRSoIOWso6IGAIyGAVO6iC98z1fQCDtkjyO2RjDGziCoUCpEo6kEjwLFLxbgoXPuSrJq6qL26FioqHIgRzQq6/IOAZnyAZnABJzsYwmyYzvej3Xi73U6JId5EEu4RJR6BJRAA3OICoAEwZiOAxr0AZtqIZsyAZmoKlhAAZHgIEOcAAKyIAVIAENqJODYAFJIALnuACTmQkWcAAiQISVMZkNmICD0IDts4A+IYiDOB6M2CwLuJQ6oIL8abIa0yPV2i2RoQlE2L4W0ENS6YQ+0R4iCIQWCAT0kIjhygT4KQMauJ46UAVKQIRPiAT+UAKiuQE3qP8E6goGBIqcGbI4YtKYVYw3jHmqC4RFWPwXqZpFbNIlQ0OcGFKXddmFJOEFZyomVzImsvoFF2zCZCCGxzi4ILErgYGSzhjCVLgS2vPBarS9VKCMInm0Y1iGaLCGbNAGbvCGbyBHeJiHc5yHb/CGbNgQZBiGSkABFOiACpAAyCqKDbCADYgs6RGBn1MIIDCx57G+DYgAltEOOHSOGHsjQoE17BgIEfgonQOFT4wOMkA+OhiCUgAGOpiCnigDgYIZn6gDQ6yJJOuZJHitnDAUErMPAHKJQEAEMoCUOpiVJqsD+mGDSVCFYUCgWxhGXOgFzMMFVqyqjeElWLBFpJy3Woz/xaUaIqR8Sl7yJWnCF83Zqh2iIc6LnF/8EWGsOKBKJmMShlhIpmJIhg7pRa5cknMpoaFKhdSbQcvQxm0ki2iQBiUMR2/Qy3H8BnDwS3D4BnUQTME8h3W4h3qwB3jYhmNoDGTwBByAARqwQpXZp4Q4CDuJjoQ4mQjgonwkCIewkws4iDFKCA1IMjJKMu5YmRaYQw0AECdrKC8TJDKggxXgAhr4BGQghKhTmugAiaMIkNrKiIkCAkFACkqASSWggv8pslyRED1IAj2kCQMZlbGRBC0whFGgBQSqhV3wBWPaLnhbxayKpqM8yqk6SsJzqoFrBccLHRAkmM5JsFqwPBIc/6ETREHOa5de8En8HMZeSIZh4BKPMw3r6oUiSUslUUHTM5JHM4azkAZpwIZt4AZ1MEdzREd0XAd5sId7sId6oAd6WIcRZQd5kAd2YIfBVIcRNdHDlAd40Aa8cAZf+AMYyAE62IAFKMgLSMh/dEMHiIAW2IAxXMOHrICCZEMl+EyPYL58MpQ+ocmc2Q7umD/tsRTtgS3woQMaoDpN0IQp4MjZOpSnEaM1SrKQCARgmAX40CggoIKJIoPlupQyeA8J8ZSPIroyyAQ9IBtMwJD73LtdMDBWxDSjpKrzhDxXdEZrEpjU+5wTwqV9mU/7nKGx8k+tNJwaqrgaqqlbGAYOCv8GWngFn5xLDxERY/gKaJCGa9AGbwCHeIiHDD3He/AHWrXVWsXVW/UHfeDVXu1VfMAHXgVRwfyGcOCGbcAGbOAGbsAGamgGZTAGWfCEPzC+FJC5NuTRorgTgXCOOkgIhYgAL9Knx2KOMRQBIjgeonPTonie5xEPzNKedBWIlWDNhtgTGoCCIeCCQYCCG1CKo6GEjDC66GEVmKGC+FCCWUAGVYjOs4s/MqgaOgCfQ2Sa/8gE8oBXl1iyG4iBSjggU6QhoRzKrGrFfynZBUNPV+RAIjIqQXNZa5omeBtBGYohFHSm/vRPyNjKIvmRnoUMHmkXYxCGXbAFYVAGvLAGCg3/THjAUFmdB3vo0HugVX+g2lr10Kvt0KzFWqnlWhNdB3Ugx2XdhrFFVmzQCq3gCmuwhmlwhrNEhU3AhEm4AgyokwhYgAtATTecuQqojgt4MjOsLHoi18xSzT2pDyIQBCqwABeQsnsiBIECPyVAhOhoqPBwgSSgARJoCjLw0k4QhFwJFGP7iK9zxE6Aj1koBXEbQOO8mSQgAz1A3U85O0SYhZJoj5ohgdH1CC2QgT8YhenyvVMUSlZkRY6BN/OcJVraNGccIkEjGFeI2avcnF3cxQVVUMhwl096ULSAhrVVwmlYhsJohmzwhlh92qidWqvlWq6tWqrlh/f1B3uQVaaF/wewDdtlxV9u+Ib8xd8lDEdt2Ab/1QYnzAZtIYZbEIVKqARDMAQ/yAAK0NEEeCwYq4DmED9y/Tnkib6DEAFWEQEXsL6aKYFMYBTkIYJMwCxJyAQXIAQDIQIT2AC1oy2V6gRg2E0VaIFUQYTUpYEpcLuacTraqpkkOI/zgIKS2L+VOg8XeKhWKY8gkISJfFOSQMn3kQn60YPspC7ryq9g8M78wjvK0S7fszcHWxN/uzNSGC9A0zM26ZfUaTzMGCrLEBI6ZtB2cVCy6ItpUEJuGIdzkAd6MFGodVpZjdr2pdr1XV97MFF5uAcRHYdxEAdj5QYBtuRLHtsl1AoBVlu1df/CJcwGa2jCatAWZfgvVBCFS3CESbCERRgCCuAiJK2ADMiAmFuOEpgACcDlf5SI0xIBMCQIRuQO06QEIKAxJl2eN+oTEyiB+jAUoyiDQJkFRHCADCiB91ABd+IIdYUI7VkypgGt+/AyGogPJVNOsaEBjhSEnoAfTokJTyHimmGpPRIEOtBiBwRjoGQlzIO3vlOv4GgF1kHjkxMN0MCz1dsMzKCMILleDykWZeiLaADgZS1H+rXoeLAHfXhffuDVEJVae6CHejDREvVadkAHciCHciCHSRZbCm3pZIXpmDbbS6bpmvbfbtCGbiBgAh5gJ9SWiCMGW/iNUMAETOAES5j/hCfIgDpZmQigZSwkARbIx5nj4OdpEBd4LFxjgRegAudYGRbg2z2qkzF64Q8mIx4TpFq7Du3wiAWYUhIgmsaKjvf7MZDwCIQyCfnoE9oCG4mQlCGQCT0aj6RjCWQbBDrQniFbCZfQA03whFnwPe3iu1vgzx66BVb8OL1qItMADSGEPSLMxnY5VbKABmpgVb7sS3iIB9WOh0AO6XrQh13VhxCl7RCVhxFdh/oVzPwl294u25g+2+DWimQdblbVik6mBm0Q7qywZFa95FD+xp2W7gKOFmQZ2lcgBdXwBE74sFEgA7iew1mugA4ggxtwADe1zEJpnuVpwxK4NVvDDg04/+/HcoF0heHFvScRYIElM5SaAIINuIES4DLokBkWwAkWUD9BkgnQ+gj2GeKQGALt2a1zjT9O2R6Z4BlISRoVpoNWuQ98clMJEQQyyE5VgOxVxIXjbUXiAOiCk4VACzTVe8tY0MbRXobS3uRW3Uu/VG2L1m0VXdEVXYd0GPJ0MAdyCIckV3JmlelkJVttMFvhlnLh5gq05Yor54q8qBZriNAIxXIs52O1JeUxH/No8ZZwUSXCeSWAISLZUSc4QV1JQD4KKB5JqIDFkgDjWgD9zmV8dAA9iQTLJAjqe54UswD2aY7mW8nL1IAf08Mk257ixAibIGKiYBlJiAjlfKeGAv+bbza7OtDE6ASpIYjO+vgxR78PbWsyIpCEn/GPSr8PF8AfvI6enCCDT7AETRgFyJ4F4iVe9HQhnhXtxAALraBQcFDteWDa1V5teEhMH2dacpR2ae9tmN6KrTDt4c724KYGbLBpTT5bS47yKbdyMF/bagkMdLcRFwnfw2AgtJQMWdAMgs7u1psNbKqi1VAnTUiBFMgAtxatEiABetRv6Zm5FJu5mSOUNmSxm6O+gXCAFl5cynKBTggEGht0FwgPogOJfMoIQVCBVPEePU0C02WBG6hnPRquPQqJH+N00zoPqqGCIOiZJJ4JCWkpVok7mnSV/DEtAVkyPaxnLuACSzD/cY/xmDeBk7PxvcoxhvHVS/PNUPmFWqj1UPmdeqgl1paGcm7nCi8v9y//8uPOiuVWW6xQ7rS/5GvoZP81e2uxixcJXx1xDNBjks2Avc7WwdnTEtYIDpUrBU1gJwoYiAp47xawvm3FanysuZtTvpvTgApwAOTB5SQTCM2KjguwpBC4PufQgN5CBA4uleggFbcbCoGC8PtIAQO5CTb6zQWZPx9jKZa669HSQ0lQhUshhGLWKAlBifLIo5m4GZ0gCqJYMh47wDrIdU/QhElYhEFYhEaYhEnwhLQ5QmWwBqmfh1jVfqa10NxWTN+eUGTNcXAnd29XbnKX8k4ue/UX7gHu/2S4lwsU2REe8REZpAyEZr28z+4vCUK+BwhRAgWeQnXK1CiEkzBgIEGjTJkJDjSUANJiggULETBu2CBCQwSNCyaIsCBRg4aMG1go6ejCRQkWFkKEuGDBhUkRLliWELEyUwsWkkohEjRI0A0anySRIESJjB5JjQghKqNESR1JhCwCkZSJChGwSsIiCkSkTh1BhCRJIkIEyI06ZSSV+fSJUKe2WMvcEAQkydWXRFq4QEuIziA9VQUJokMHzyRRxZItWxaN2zdu3Lxp69z5GujQokdf01baM+rU2ratTs1N9bZtoq1lq33NGu7c1KhNiwatWeVlx44ZM0aM2K/kvJbr0v9lK9bzWNKnS3eV6jr2VKi0o0JF6jt4UqPCDywvMBT6UAPVDyTFipSpU6MqwSBBokIGFh0XsBDxMcIFImBkQUchbTRgBBKIAARIGEXAQh36XTCBfjGFIEIEQADlHxBU+OefCYIUBUwnnWjSCSIVdKLKDStIQgkXZAySSSeEKJFEEoSU0UILQBCCFhV1XEWEEhCdVQchgSgBBJNw3TDILIJoQgkinyCSYx10iCiIXGUIWUYmOqZFCJlcUsUYIZFNNpwyyzQTzZvRTDONbrtRkxtteOq5pzW36dlZNniqVhtu1VQzJ5zNALeMMsMVdxykkR73y3LLKVdpc5g2Z4stzTn/Jwuor4jKCqmkevddQqOMYp4o6bnqaiuwwNIKrbDUggsutNCiyiMYMNCBCRNUMEEGIgxbwbESbRRBBBtYgFJGFVhQgkoZlWRCECJc8BKGG9AkAgs81uECECWUQAgL5pawASKgSGKXJqqUAoweKUyB4xRG6VGjkkQk8RcQLgBWRyBIUrEXEV4qgQhdkhxMbh2IcEGHJHpQbAkiVNZIB8MQFellHZSolSMiSIocCMpkNhLKL8UZw6YyMQenaJzR2DynoTnrbChttRGam8/Z5NwbzZU1StyjxAiTHNNNNy3M0ktHCvXSlCbXC9a97MKLLrzsssstYYdtyy221FILLKKK/9rKKqZ2h4opcSM03nes2r3KKbSuQssrsOByCy2tVPKAAxlkQKxPJG2w0bEbZJBRRhGs66wGCq4rggNKRMKsCyVdsEEL2u7EgocB98SgTjKxAES6PQ4xBBcrDNIJGSW4ABEhgyBCBiWEHAzwwHeRidXBYBFxZiYMfyLIWED4O0Qns5RByCxbcVkHEGUEUgaOSZQBcMiZCJJJmAxTVTAijUwyii6QFjfcMcnIHzP9MrvZjDPOyHmoznPOmX8zmMGMmDnKOEqrmtMSqECmUQ1qDISacYxDtV9g7WpY25oudoGrv/2tFmE7G9rSFqtZsW0VtKKVqFahwlOw8CAHmZuqVP9FChbSShWqiM8qckWLSXCAAhnwYeEWNwGPbGBYG/GJRmyyAAGRRARE6I8GTCCCFhDBWcGKQElEsK6XsIAQQVCCFkMHLmr1x3ksYAFMbsAFFQxhBSX4VyYkwTC0FAYrN+qeHENGJirY6GBICkS7hESIT2CvRzkChSqqQgkmnaV5VKBCVbxXpKxIAkkvEhEiCMEYxizCEqOQxS+EcRyXxS8Zw5Hf/EwJv1Ui7TgTvFQGM/i1Wc4ya1l7mjBs2QtfVBCXDYRUMoxRDFc6kGlZm+UGxQbCs8mKhM0kod5OqDcVrkIV1MRb3Fr4Qry1woalKMUoZjGLSqAAAw6QwBAzsAH/F+AnAwLLALOINawJTC4lDuiIhzJiAioQaALN8qd/LpAtFvxgAxcIQYVKQJEp+mcDtnsLFYCgBBOQ4AY3aMG/AtGJG0yhE2P52MHKIAju5chGEMlKVQoWJEQooQWfAEUdeBSWgFGhDFSgBPaKh706UKFGVsEKIcJUhkwapiiNGMQgJLGISaziFb0IZTGGMbUGUoprzuFULGQRC1dw1RWkAlUzQXgLDuLia2X9mi4X2MC1shVSxXgZXENJjKg20Be8pKUGxWYLUPGVr7CQxahQ2ApWXHOFNjzsC+PDwmy+cBTeBKcnVGEIDjSkWIzLwJIW95ciGs4jwbrAtrQoAQ1g/8Sf1prA53BSEQuUZCOdM4GzAmSBAMGkBGGBiRZXVxHWtWBJgXiB7ZJgUbegTAkFK9JfluQxtEwPLR8t0g1YYoImLWlJQCCYTesQBCYFwkZCulGRRIQVJCEik+UdRCOkMghNzKIVZRur2LTa1ezQl76oKBXbpAkLWoRQrGM9K1576Uu2ttV9pCSGBKnWC2H4goJ4BVvZOCVhUHWVq6RKBSvepuHuLJaFp+oOhkn1ClmQkBaVmMQi2kCDFdCAAg5YwDmb5Th31sEEGTBBBZbFuI6QRKEaqMAGUFISHk0gJR4RwVVANyGSWIAFQ1SotpBcxraEKybgCsFLWMeSzs2lR/9C6gQltPe9v4xULkowaZdCmgS5/Ctg5CoDkZZECCI5r0mFeeRfmCsXlAKSYZmkyiDKZIlSqIIWsGDFYPtWqkWHuL7Y2XArXlFCSb+iFrIwG6YjfAtPdc1rtqwUL9TKQKX9QmmQUoYzklG1Sl1tlrqA79j4KioLlyrErMgOV6fDKV0kB8HHUIaiqlGbbhA7G89gRjCq0AAGHEABCZCAi8+5gAg4AAhSzAD3YCusDOCnIzr5do5ZqwGfRMAEZQiWRyaA2g6ZZEIC0laRPSI5ICiOMAtiUAtKMIIemcAFRHjBDZJAh07QYSxEkIQgbrekGwy1Dt4D85qxRyQvEUIVnZj/rnWBYBabRpRcBmdkIByGo+yJVESZQBKZ1kIVTVKFLY0YRdtYwVVRYefWt64vKRxta1a8grBqk3lfgy7hTnG606BmtdUWyDSlOSMbzGDa0Zlz1U9Vp8LU2fWCfU2ZaQg7G8T2BtjBDo6xg50b3RCaoabBDFxwIhEcWPYCDrAACUggAS9OwAKA4B93uqCz3L4xbE0gRRNYyyN6/9BWBD8Wwl9AiuQKiU/8M9tneftZWlxQ6EJn20CYIKYsOMsQNGEJ79XheGZhEiJO7iVQzCIJ15PoW1wgCVAwb81vgTN4/0WE1FvleD09uSAogaOVZ1JECGdLyCnRZ0osZRGeAFWn/5LTtUxFHdS6SMV3rvOdDXeHVBV2BV+lM/ROmbWWWjtmL6pfKWGE2lO8cIah2M8cq3LaUqX2dZu4ng1tdMMbY/8/2fkfOHgDsRWgz6Qd0PiMMzDDMeACLIgCJ7gBBzgA3mlA6MAYhliA4bRAEQkIj0VABYhAsTgLSWiAC3QEC3hJCFpAvomACRBJ4IGIC9AWPXlEhXSXBpzRGVGEv9kO6zjPybFAJgDDLHABwTnPH7FEGVACTnlJJSmBIAQCI3XJEAAGYDRchxQMIzEMJRTJRxWMSAnf+CACiohUeVkSmXSXHLGFISwCJJBCy/iapEhKAu1VLGAHrcmcK/SNLIAf9P9FWFZB366RzS1sjatNX/2p3y9kSjE8FakZEP4tAzTQSWcIIAD+H9h1g2dYg51QgzRIA2/MiTVUwyjyDG50RgFqg9AwQyOSAipAoCGgAAUsQAKomwOE4EeM2wYEnkfcmLr1m+OQ4BGRFplUAEpsAD1ZG2p1hBB9jhOVAG2Vi0LVwSwogQUChrmsDgvgCA3wCJOUABkgAjLMwiBwgd55zL+MhZdYhURxD/a8WfeQIe4EAk6hBY4Yl1dAxEnplIZUD2MURVowzEhRRfRQgipogiDogSdwwiXEwv09StJMyhwmhwPpgnQE3aVNmCBGWEbu2qYQXfUVHauFWqm9zDEMkDH/kEIoPEfOEUP/WaI3aAZr5Alu9MZv0AxO2qTN3Awo2sknRkNNzkkoVsMCJgMx7AIqqAcnYEIjPMEC0KIFnJNVTMC0GY5PwBYyStEuMpE6ZcAtNlkJyFFITI4IUAEHBohNLIhNsCC40BM0TtEZKVRwpcsU6sENDEFhZIJIaYEnIIMk0IBOEIL3UAIRmMVZ+IsL3Aj3vEXAXEUS4JQgeBRWoAyOQETytAWcUcFI6WN5lZeOMN8/ypGXtIu8zIKJaIInWMImdE3LFEfTWJ/1feT43UJHjo2EFR1uKmKvjZIxtIkkUmIlhh0BVsMvdMrSNMcxZIOcfKI0QANzNudO7mQz/yBKoihKdeJkM0BDdMrJKPZGoiwDAw6DL+DCKwiEKYATJ6TAUzrAiy1RSdDdsPjELqpbsRgOCHrEj81nkH0IlH2E5wzRu/FIC2BP5HVLVqSLuQxBGZwRTBABJXTCEwzBQ9jIwTUCZDxBClTESL2UEmhmOxKPv9iUxiVMUXzPu0gSWrhFwqhewmQXwfDUlQABl1DCOJIJJbBFeUlCJ1iCJizCvKiCJRgCJLiCLYBadOQaV/WhK1ydVl3aLYjVBm3QLlCf/fUaKR1DdoLiNWzDZsSDl36pl36DmGZGbGjDa1zD/jXD0Zzk0EwDc0IDnMapzdykogTH/dSpnc4MozTKo/840JQC1h5m2EGoCqGpwijswCwmgKKypwNgUeHNWN8Ji0T43eFUABAgAo6BRAX0hAme4AZYBIG4gOOtUxm4ACG8FpMoQSYEXArQwCCUwrgQwRQJgipwAsKBQqkSwRBowRXsAA3QARW8wJJkkkQFglgA0iNdhbKCich0QpcARp9JYcJIQpHsXiBsJsHUVJEUBSWQSECmHJkgVSM0QicAw10sQiKIAqj9QlbNnKxImsy9gtXlmoSJzS5UkCj9mmUYyv71HwB+6TwEbDzAA8FmhmbIZJl2RmzExpaahjWoItoh4DW46SfG6U3GadHUacyoUtJUFdVxlXaEBymUB6rEkCj/hJMqyAAF0N0F0CKMSYAxPmW6RYA6YQixqFs7gaBELEm+YcSCZNEQyWpGZIVbHJ6pBkz2LElYgsIQCIIlOCsNMIlDUQJCkkEmcAUiWMIkWIIUOA8V0AFalJlxmZ6/eUyHEIlXlIj5XGEaBkkdRMIj8dGLdqiQXFfqaQUi6IEgIByaaEWSoEnvaJIjhEKnUQqngEosjFjP9VWnWIqvuQlQ9qvYxQM4fCkAjinCxsbBLuw2jOk3xORmxKSZrsY2YMPBbqI10MkpgoY2hKL/2IzGEsekeM2nfJ912Bf3GUTd2M3JOhYepIBXOsCEPCXeTUDoNGqOqRvNRsBI5NhGIONo/5GE4ZhLBLhAJwABCpqLC/7idAWFf+xET8mqXFhCLgwCGXQCF7wOFQSCC/zjENDBnLmFXTSCJViCEoTAD/wIViRMhzIGO/qIiIJMXaAIXeDOnq3vVnRoWCgJWuRUkaCIKjxFWohMFD6oeaUhIP2IasYCawpDc2zVdfjhWQkDM3hd5YIp5QYg6HIDa2ADNpCuNriwDHMpC5euC2vuwh6sZnRG6MbkNniD6V5DN+DGbdCJJ4IiNBhNn8LSVWXVVnXVot0aiGHHKuSu7o4sq6iHJ/RBCviQBLQn89qd3QUZs2CRLzovsWxAoyaIPBVRf5QEFUjItPTEt2HROjWUCQSFRSmwwBDcwLsMwgpoARdwQdQqAUsIwhOQgetFwgtQQSZ8wg4cge7UwQ8EBAAh+QQAZAAAACwAAAAAQAEAAYfqv6DespPcqoXQp4zSnXXHnH+/mn+8lXrIkWe+kXC7j3C4kHO4jGuzkHe0jm+1i2yvi3G9h1q2iGO0iGayiGiyhWOxiGqxhWSwhGGuiGuuhGOug2Gugl+rhmqrg2OohGukhG2zflCtf1msgV+rgF2rfFWogGOpf12pf1uofFyoelSkf2akfmOje2Klfl2kfFyke1ujel+keFqkeVejeFSgfmWgfF+fe2Cfel+geWCfeVugeF+fd16fd1mbe2KbeV+deF2aeF2cd1yYd1ypckihdFGfc1Kedl2ddledclGcdVubc1qbdVebc1abcVGcbkyadVyZdVqZdFmaclmadFaZclaZcVmZcFqZcVWabk2YdVqYc1qYdFeXcliYcFaYcVOYb1mXbliXb1OXbEuVdFqVclmVcViVclWVcVWVcFaUcFeVbleVb1KWbVeVbFaVbVCVa0+VaUiScVeSb1WSblSSbVWSbE+PblWPa1CKbVePaVGNaVCRaUqRaEaMaE6HaFKXYz6RZUSPZESMZUqMYUCJZU2JZEmIYUeIXj6EZE6FYkmEYEiDXkmEXkGBYEl8YE2AXEV8XEaKWTiCWTx/WkB9WkJ9Vz56WEN0V0V6Vj13Vj19UzV3UztyUj5zUTh7TS5xTjZ2RCRrTz1oSjVnRzBfRjRmQipgQi1cQS9XQTFiPiVcPipaPixaPCdXPCxWOydRPCxdNh1VNyRUNyRTOCZSNCFQNyhQNiNPMiBMNyhLNCRLMiJLMCFLMBtIMyNEMiVEMCBMLRhFLRtNJQ5EJhJALB4/KRk/JhQ/IQ07KBo1Jho5IhEyIRQ3HQwwHQ8tGw4nGg4uFwgkFgooEwYoDQEfFQofEwgeEgceEAQeCQEZEggXDgUWDAMWCgERCQITBgATAgAMCQIHCAEJBwEFBwEIBgEFBgADBgAIBQAEBQACBQAKAwAHAwAFAwADAwEDBAAEAwADAgACAwABAwABAgAMAAAIAAAGAAAEAAADAAACAQACAAIBAAAAAAIAAQAAAAAI/wCzOEnipIeMAwVeIOkBw0iWMRDHxIHRYwwfJzqcUOkx6QsbNklooCBBAgWKFCgqVNiAAYUKDhI4yPRwIkUKDS481Qom7Bg4as144cJ161WvO1Fo0FCh4sUMJ1mMzDBC1YkRJEpnzJABw+SJEyhgzKDhAgYMFybLzkChFSWJFG3Xohhx0iQJDiQxcNArE4OElXv1+o0pga8IpUg4mWrV69gxW64iv5ocGRWry5dXaT51alWrVp5bkQJFetQoUKRInVI96s+jzqxQHZs2zdm0Z8+cMVt2zFixYrlgpSolqtQzaaVclwK37ps3btuiS9cmHds1bNu0ab/G/Zq179a6X/+rBr68tPDWoFOvlupRnjtnXDgQcgMECBxSkFhYwN+BAwsZeNDBByzYAIQUbNgBVVVOUDAABT28QRAMWWQRxxhG0JCEDEic0AMffDAhiCBsfFGECiXNRdcIFeBFlwooiMBBBRfQpJUGFwxSCy7CLENNNNEEMxQuRkFyg1gwnuACVTPAkNVVa4GVggxruWBlWWJ9ZZKTYwRShFZgmlREHH2MkQJLd8m0l5qBYeBmBW7GOZice4lghEWcqFJLY8fwMtmff7LiyiuSBbrKn6280soppo2SmqOqRdqJKJrFZosuttiSy6a52JLKp5+WIipxpaQiSh55PJJLPfV444100VH/pw1221iHDTbaaSOed991Zw155ZV3HTfQbcMNNsVgQgYZXOBARxA/rABBBg7wt4B/AHbgwQcm2KCDEl3QgYcTYziBxEA9GFCACUaYKwO5ffQhgww6ZGQuEl+ASAgTX8g10ggcbCBwiijQUAQNItCowQgnkEDBAzbE0oswxgjDijBD3UJkMKOw4BSKDI81A1xgpnDCCHSl8AJaXrHlkFVNmjUWDW3ZVFIKB6ewomB0ximTCCSoJLSbEsREpwpPxCGIJ7HIEoxju9BCyyuyAGr11VMjugpnqXXN2deqcYYKKqWMIsrZmKQtStpst502qnArU49zxcaaK3bWcZe3d7wG/wseecCWRx50xBrLTTbOjJLHEEM4MscQK1B77bX/ZaCtCSYUKAQXbODhB0QgjtFDgwM8gEQSPSCBhEDlOvHFRgu9EOEXh7DhQookCFzBBCphMAJJLpXg5ggeMMwBBRR0AMrExwiDCSqzDPnKLLUAQeVLG5zQFlsjpyATwzapqCUKanWl5FknpVASSQGTMEMSSaRwwQV0keBmm3zhBXTRAeslggj3I1oF3jIDPoBCFcEIBjKMETVFJWoyWbuaBCejma1xLWxf44xmyIY2TKztESB8xB/+kAgRjvAPqPKBCvPwB2nUYx11s5t2apW3vfUtWNI4z3mqIY3Afaca1+iG4f+40Y1jZWMauXgEGfbgCDywAAL8OQC2LOcBFljRBptDg7j8MJCHOMEJfKBCAQqAL4/wQRBvKFGEGHK6HpTFBW8QxMLcxJIJ2NGOGCjJjPLIAZv8DgUcYAAFMqCIBC5jGcIQRi+GVBRi+KEHS+HA/EiCspIA7HsEQ0HDSPAVEvwOZV/hwMJsRhJPamADMtnABU4ZMEDyLIAYaNEeUbmmvRStMBLgXR8FAYpY1OIUpaAFLqYmi2K+QmoTTCZoLLgaDGqwM6tgRSkw0Qm3gfCELIQb3FTogzxg4hvgqAesZDirXd3Qb9/JoQ57WI12AtEa2hBiEbnxjW8U8VbKEMUj8AD/hA70h3IW0FaBbGADHDDhDFs0xBvAKIgx9GEQfLDAgwpyro3w4Qtf0IhZUGeWEWiADzNgyZvuaMcWjcRNJDHZ/GSSAAZkQA486YkwbiGUReKiFcTghA60Yr8JAEykArvf78BCPpNx8itg4cDv7rKBm9VkJKrcwAhQiaMJXKCpcpITnFokoxkBLJZCK1oF/oIXGgyCFLFozcVucYtiFlNqcI2gBJE5NVcss5md+VoFV4GKUWAihIDVpmBRRQYQdDMPqQCnOKeTq+2YE53mUac1ctjOHoYHO8TKLDjpto1sUOMVP/hPtfjzAAB5IHPewiLnxDUIQ3zxjGNYqBvH2IMe/7BhDF/oASH6wAcYOEFmSJjBCC7AAIdcFQN43N3QpIoywKjyqiNo6QNqcApiGKNPu+iFTXExi2CoQgcw8B5y+0fHwODFJOhFWV0kSb9SctKTJkOJKC+gVKpuQAN6jOX99gIn4AGyfUC7S15UQtYNwKARpAjGKjAxClrw4hZxnZqEkXlMucL1mIay4F41s8xVdMKEJbxmHpZFBrjJgcSFtY8PfhHOxUbnVjXkFXciO9kcplOd60znOw03T27YY27rMFY3mhGJDjjgAQp4AH8yYLnMxUAHTIByuDw3iEOgMQt8iC1EXPCAB6UOdH2YhJbPlQQkkIABF5jABsZwAQpYdf9+dvxjKeeipt/dlwMJeAAFTKCJYFj3FrsYElFw0QticAEGLCKuSGOJyjy6N5Mm8Sh0Iy3Vk8DAk0tlJZxJcgKp0sl+52WfYFApApOUGqUYaCoHaGAJU8SCGM1ohjCiFmHKIHNQEZYahCn8isygojOgSVSiULG1SKDwhNjkJoq56QP7gIAMzFDsi2FsHfT0qm84lmyNJWvjyQLxGtx41XOIVY8f2/MbzMAEBI78AAYoYAHTEuiTmcAFeqfBDnuo8iEkdBVynZFcB0gAEhARRoITwglidmgWRnBHBjAAQxqYb6o5kD6TyAQFz6X4yVj0FRtAghjIOMYueKFd7dYUGY3/MAGOGJCAR19yJJlU33mHu7CUZg8uNDPZDKIyEhiMIQuAbFhfXLQBlWxAzUGbQCwnuT44qSmlKXDCAf3cjGg0D9C3yBRbbcHWrnM965kKu64JJahX6HWvl5mFov6wLDnIgYSJiDsKWThCwTo7D9L4BquMRUNq32rGvfI7Nqwh+Ft1+zq3ouc31tGcVtnj8XNLRh4acAD+KCDJAKJigXAABCUoQQpa9JwhDqG6L2ZhoW+IowkK4AHRwYAPBBdEFpAwBhocnaQMmEEfcES/C6Q6kzIhAe85gNQT0M8FNvBDL0I+cpL3ghe8yC4yRuGCE0yA5ei1i3srvv21CCx7SgWf/yZHBrCjoiAJcTCCgbOQhKkanSVCM7p+U7lHlBYGLzcbw9SJAfKKbV3rWqcLWQd2YZcpcFUornAZGuQZHJaAtTALq5AHPlADNQACQ4BibScHg5UHzoYJ2NAN4VQdeRMegAcef6c3hTd42DANOEZ4H2hP3RCD9gR54JAMf0B51sIApdUBPHhaBfItUSAFXZAGCXUIUBEHSIiE8XJwB2A6MnAnfcB+JLMBDPBmdiRIffACFCAwvCNVpXQyeBFVdIFe9KMQZ2AKxNAnzvd80FdotSAELkBcDGASNoES2Yc7KNM+mpRK3hNxPjUCLtBUJvN9V3UXI6AhMHBVvSM0vKNfRf+nZnHidG4CXezDAfrnaiCHDLO2awVoC7QAC6AIiq4AC5HBCqDyKZeRgAoIbIQyKA44C6cggRRoWD/gAz/AOBd4gRiYYiCQCi9oD4j3d72CQzhGG8Z4jLQBJLjxDNAQDdIwDZNFbdkQg6xSDzbYAAbQH9hyOT7oLUIgBVwwhEV4CEqRBBkCP+QyEBpgAB5wOr+VBDCQBDNwfbgnSBTgEBpgfAujVF/oSQ3DMGFhFjCQjzBABVKgCfzXhiUHfRVDDHSgcu6WfRKJXpjGVDKhAayEAhfgPuHlUSUxMndGX6h0Eh6ZO2+yO7yzEgCDkvOjEniRZlVoVak0BpnQSwlEDNr/RVe0EBmRQYo9yZM/OYo8mYqsAEwP9CcOWAuk8AdDUAMr8AG2+AO3OAQ/QAbMxmwQYB/AYA0gaA8uWG3DmG3QkBvO4Ay4UZZoWZbMsJaHtAzMYJa4EQ1jiRu0gQ3gAA7GMHkHkI0KMEWnhTnIhwNCQG9o0AUJkm+j1whaQTMiQzJSYQAK4EYxkyEVoABX6HAOhzwn0AdnwUne416dlCJYIpD56AJIQAV+4GcKaXLAsAzLRwkeoAEUoAASSUkjQDLqU0kkcXRXdV8n4FBJYCViYSX/NVWfdEooY2enlGYklY8BowFW9SZucn0xST8owweTwAmkoAqxICQ7AmGzMAsX/0YoVoNruQYoy2RMSOkK1CMKTAkCH9ABK3ADV4mLVImVhrUM05ANeodDYalOc6kba7mWztCWu9GWCEqgzhANZ1mWz7CfvKCXB7CXU9QBmBMDLvACgkmYbECEoncIh9AI4WWHdjgWGUIBBXABTtEkNIABCuBw1ImZ7WYBcDAGLzCQJ8CPnrR9KSAWAvkCGlA8MEBvqkAMidQLwcCaiIQMpmACyDOH/3hJMlETnoRJFgddTXUBNgEDJqAkLzA+U5VmqJQ94SUw81NVdgSd+IWRHKB0pYRcd4QBp8R7TkAIIcoJvVQLehqefCoL0aOngBqoetp1GrMjQyELnBGeFxYZxf90CSMGAh0AAStQA/TJTUOgQrdYixPYAA3wCNEwDR9YDzfWgjg2ls6gDMlgDKr6G6wqDMXgqhSzqqqaDLRaq6m6DM2wDK8wBBO6l+riAPHGLS0QA082mFxwBmxAB+KCmCHaCCpyXi7BmDPgAgVwALfDATOAXCyXAJfncO2mZxbwAoLwpVuoo0PFMDWhFTDwAuxqARSAE0iAA5kQU8KQQInUmsdADMEgBLLJAF+RnMnJPhegkgJGZydRX0pyApjzApokMJLGnHcEZ7yHphMgSXMKZxuJF20ao7j3FHAwCI3ACKDQCrjgp+FZTHrqVrIQqIImaNtVC7KgGTCrqHWldo7/kAdlAAIQIKksQKlXeZUV2AAQIApA8oHgIJbQAKDQYKrMkKqsCgy7oAu8AAxTywuJdLWx+huuagzAAAw9YQyosAK+qi4DUADBugIssAM9gANQFo4eigcfugiN0AgCRjAkQzM0wAAF8AD0MwEt5bct1VIO96IYqQGC4AL5yKZfOD4k86NHFqQ6YAN4MDFXG1OtuaR44AEP4xXJiVS543tHlSIoYxOohK7FY2BEp0p2pEo0QiMYQF+npLppel9zijwDa1Wqi5kxeX0jQBFvMAh+sAiMoAiOEAnGa7yXcAmQAAmMsLyRUAnJewnQG72XUE2YkLydMAokWwu5VgutgEJ3/1ADPPgBKzCpNfCz3FSBWUkLDPqC0rC0ObS08ru0uMEMysAMx/CqUKsLutB80Ee1Vnu1XvsbXuu1wsALogACBtCrY1QAA2A5wpoDPIAEOoAEhLmseICYcksJlGAXJ9EW5TgDHVKtKaASl8lyLwqjdkQBFiADfPCu/yowOnpUYOGjcxGkGaoDZ9AKFDMxfpZIvIELwbAI1WIBLmCc3/MVOALDcOE+JpE9c0GHJhN86qNqjQgYwcderys0FFAjHuACHhDGGfCuesF7u1OFumtVtsUHVTYIepDB+bYHfnAIwOsHdmzHhWAIhtBae5DHhZDHZYAqcecIJAt9uxBogNoLq//gCH8wB2pQvmhLqZXqA0EALVE5gYbVI7YBqklbjM94jLlBoMugqhVDuVerqsfwqdGQlp/6I9HQDKMgtpVXedeSeU3GAi3AtvWiBEtQBV5gB3CrwYsACZQgFzhHM0ZAEKrjAgqQojB5fS/Kre6mwixsAn3QaXqkAam2VLmTnHUhfEGaOTogBKBwpDcJxH0SDKAARQ6AkSizSreJMvcFkCcwnGdxxFeVShPHIgEUpycZSyW1iMgjm6XJwnpGUsjzMLoLoy6QL63FB3ZgB29gB3ygB3Zg0XwAtxqt0XIc0XhgB3RgB1UpB3IcCbLAhr7Qvw8oC7iwlHegBmbAAuRbviz/cAOa+gNBMAQ5rUIVmAfHsAwLShvMyIxA4ozHuMoKekgVg7WnrKrTUNTO0AxlSRtAMQo10AALQMu1HFA8mDm5XMGp08te8Aae4wetdQjDTAmWkD42oRXt0i5JoEcFkAAXkMIKwK2CO812VFoW8AZGUDwnULhShVQAyzAkcUqn5QJMgAOFoF1M3SOIVLIfwB/o6lEMM7pfcaPSiq4vQAJWhZEDO4lKN1IjRVKm3ZJpOgEasBWr9DB822YWUFoK/QC0Tdse4ASpxwclUiJfkEZfUAVUIAZskEZigFEY9RHF/RFfkAZAAAVRYAZzAAknDX38y1YoCwpyMAdlAAU4IJ+Q/zyp3JTT94nJonBIZsmCyzi/Yym/zzCgB8obVwt9hmy1vICrsfbKuEoNQEEKV42D/WEBFhDGYYzLT2bBvFwFYrCsg3DWw0zMltDWYEIDVIEhWqGRCVAAl3fXGb7Qd+TaJ+AEC+NR7qwlLKNJRIUCGJnYVGADQ8DDz3fKSk0LwSAHRzbYLrCl6bpxI/ACgChcGKlJq/R9Zjra8ZdVMqFcNJJmKMmSGlABaDzQsRnbevYAR+YfR+YCGkEFr4MvxY1RVVAFTMAEVDDmVMAEFhzmFmzBYsAEVdACNyCYZqAJtXDAUct1ntioZCAHUPADN/CU3w3emKqpPM0KP22WQAKXy/+Y6Gdpv+7dllybSPIdq7naDMgAcsTgNK1wCSvAqaN1ZBYQpH+Jy2zbA2I+Bb5M1nKsx4Ygtw6eCeGzmEpRBPAIF8R1AdV619Kcwhyug7RNAycz4uRTPgybFmZxMkqSETpwA6BADIecSKqq1LcgDJfgABQwFg8hjzbhECNzMjDwFV2hPncRcQPjSUsnVTozP/QzMMOF7ktcUmHYpjBaAbKZ0CwM4LVN28izJFxRZqnTA1SwEKlDwU0w8KoT8AsB8E2QOqcVA0AQBTphpIa8C2w1C7JQCMvC3S1gA0/5ATNNgT5wAxQY8s/WE0Bd1G+Zlg66jGupDMqAlqJcDEvt7Kj/fF3EUAuabgCcOqFRJEUPECCJ7QIsEAMbelBo4AVesKxmrcdo3QgcnAmZcDMfHOs2E6MXngBW/6J2vdBJVuM+XmkroxbBJRawHjM0cC5MIASFxAu+AAyvagy5egy+cAuk0AEU8BVTIa1wYTImsONaoj3eQ3w5WrrPRT9TIj+9h+4Q+2aIDzC803BnTNu8Ttvu+jBdvDAoEMYvoHKnZRYr8wLgxa5ffyWZn6FBT6wAgjktAAq1gAzPJ/FsRQuy0Apy8PF9PiDxafuQ7JQhvwL28Qchd0jK6N4nn5a7wfIt795RPcrX5Ri9cbW9QAorMAABAAADkI29OqGm9fMvIPTG/8oFaMAGXnCYfqDHi7D0rZ4JvRszJjoDRXBmV3h5Y8Stur7QDifNtG0+XVoWnQ8D9SIyiykWAPFiBg0aSHScadULGLBiwog1W7YMmCtZOii4OHECxcYUKU50PDHCw8iMHDxy4HCCBAcNF1xWqDBhw4gRGy7MdJlzwoQLFS7sBFqBAYMHE0ZMKDqBgdKhTZc23XlBAwUKGh44ePCAKoWsGTJYABsWbIarXjN06LBggYMMLEjFClaLFq1XrlqtWgWKxYcPGSCoRcuX7wrChVeAQNyp2bGIzaJBjBg5ojPKkCc3a+YMM+ZjjDEjA30M2SgQAwIAAFCgwAHWBlij9WDCBf8MHbWFMOFyBg0bOr3x+Blk6FCjRYsaUaJkKRMnFC5m0zBCA8UMFENjMlDAIEGBBNizOwWvQOuDEzNenIcBYwaM8y5eqIeB4oR78wJn9JDhAlQvXr6KGXsIImFQCUaPC0bQ6AQOEPwohRk8MmEkElDYgIMNSNhgAg027AkDDHyqaQMRR/jJJRFzcgkophSggCgPHrAgxRbFe2ConcDbsCqrtLKAK7BgBBJGsTooywIHOsiAtQUyuIEUJ0URpRMppdQEkg+QzKCBv9AKzDDDEAOBlcWW2cyyZTrrzBg1hVnIF1+E2SVOXXbRxRVXWEEFz1P2XEWUGgowLYAAVjvANdb/DhhJNtqQYOI2LnZjww48JN0juOEgMQ455TjxBAUYXIBuhgdTIOFDoJ7iDrwboeJJKg02eEGGHoxAIr1Pm3OhufcGik5U9t7zoBFieimmM2SIIUYYXmiphRQPKBhBgxFQ0ACkFF4w4VMTpK2JxA1eddXEaE0ckYSacrJpJw4wUJGCHsHqwIIMTOhAtgyw2nAqBiwoqigRTQDLAw3C2hBeLB9A66yEkbSggys/OEBLCLQYpRNRLokkkkswvoQROiBwwIEGHFBrrZAhgEDLBlaWGAIQEknkD5nzoLlmm/945BFMduYZSp99zgWYOG2h5RZcRPFh5QMATcDIkNlSODYW/2ywQQghdHB0Nzwm/W0QS4lrBJLklmNOVOh6HYGElWKCaYIKtlNVKbl5+nbE93pAAokezMvVBI3ee8E58+SbLfATvGgFF116CYYYXB6nhZVWTOkhWhE1yIgEUU/wAEGR8m2JppDy9ZzcmTpK4cScsnIbpp9qfGCtLCPW8l61TrZALfEcUEAsB5wuOfhCCzAAUEEHQD555U8T1ABHNHYkEUccKaT6RSAYgPjitXdtAZZTRhmCDxDLoxOeMYFylFJKSQUWW3RhKJnIKHMmGvujmSb//OsBJxv/qcnGMfLwgQYsYGmIcpq8AiO1FtgAa0yA4KPSQIet7QE4wrlUI8JGCf+ydWoGRaBBEYwwg1JVKCY7MeEECqAApjxlKTvxybdosoH5yAo/GMlIiBCEAoGkh1QTColIKjEKIpLCFKAAxSiiNApVHGIkI9nKCGBAA1G5Zz4zDF20TmCTm5wLRTcpkVIUoIAElNGMCWCNatQIqEAJyo2nQU0cAQBH1NBxjnLEYx7jKCg9AgAEl9BZJByhiEUoghGKMATEUPY0B0AgA4IRDAQc1gEQ1AAEorCfM55xP05Ow375w5/+RIkNUl7jGtawRj2+0T//FSMPINCSA4pnARoMrGH1MoEJWMCCGODAUVzITRp4szU/XPAQh8jUccbGCU6ZzWwowMAGTAXDD1X/AANwu1E2YaihV31rJIFzjnw0MsOZaASH8iFBRkLiATxorBOcqkQlBOkITaiCEx44AQVi0xINDORTTzxBSy5AlYESxTtkPOMYDUrGA7TxjX2EqB7dmDw1LsA1BijZAUimltwdoGT8WssiFynLlUGAFKeIBCY0BglIMGIRh2xBI0nWyAU4ki9nuZIkB2NJXESDMs94hjPI9FOgQkMa0oCGKPMnDVRa46jVqIY1uvEN/2UjGXmQmJEOkAASuGBgZ/HALlsQgxjooAe40c0ZeEMpPxQiOMIxjtg01UFPdOtULWzKGPW6ne68UEVA4Sc/L/AAvSrUKTyZgI9gRJUaMUAt/zXYg/QgUYnqFQJmieCEIW4AThNIMaCvGoHhnEOTEbjHq6DjigOGMsai/ASxCDVjYcdYxtvdrpHhw22WSnovrPDrdxYAmAYE9gAPdMADvl2AkMASsrG4ZyQGbIAPZEEKi22sEpNl6SJw4L3comxhOUXZB2pQgyEgw6f0IypQiwoNaDyDvUY9anzjC19SUoMauiCDAQyAMiBtIDrRShQvdYADs6KVDWwQJlsLYQgGKyJsYrNEhDPRQVCsUXlrxPDSuvNXDreqJVtRXvaIt+ELsGSgU9EKV8ZYqA5U1hGLKGZbC+GIU9QiEy0YrXsGWpUNuIArD5iKu7YSpKxgpSjYif9bjRDb2KE0NitrARJbnPY0IK3FAsf1SlaMFKQIFXnLQCoYwK6cAQ9QgQoe+Ipf5hAMUoiCFBjLxHUrsYhErKCmIpWkwrjUgZU90pKPsJ96g6pJQbP3qEY1dKLle9RpYMO+tCiNAQaAsh6REQMkSMEIZCNgvTGqCpCyAx0kVczgKMLUGoTwhMnGKSQ+BaFIXm0Zv5PNw86Nw1uhio10bSMZMVbL/LIAayBQPUIugpiF8EMiTkEMVbAhBj7ukY6Ee1wLFIxfWblKyEqGFQogBdZIzgpRakQjhbLWO1lRwAJgq9caJYC1UolWVo573Kwk7CvAHvd4rEJQIVeFLQ5QRDD/lDiKS4zCFKrAmCD70gHcOtIr9iag+MQLglFQI5TSUOooSdno/JFy4432eH2p8QrsiZgtHaBAGTnwhFGlB29UYAIVviAGNrxBUniwoKWKo0FlKmfCzPRE0JGoEu105wLgQfpqV7UqG2WToANNyq6bnlgfqZjbHl3AGQxhahjj3BCWFUUwYpEJGxw3it+K0GDdJaQfxy7K3H6hjQgb99nqdasKYA3e0XjGrZqx73vv61AORNgFgGVJ2Ea3ucXo699VnSp+8QQxiDgKTeAlGKDQ2B9W4JfwYenhfcnACsL7gR/8oBb2Dbl9UR9y/4Xc49lwfVWzEYzSqAZ5CnPAVlde/4QZyEBWMTczGmhuB7ZaCpkshUTPf85MTgXdE6DQwHf+7u7ZntHdsT2obOPmQuzIusnY/jF20N0d8WSdpZXIxHCEA4lIdKJxqrhBB45exhO8QF7hNigDKPAtqnCbK0OmAKmQpmjykOsAClyrkQBMrQPhCqlokal7obapgBHgAKQwEt56lp2YilcZNwUYKEbiqAWgioaBAFOQvFF4M1loBYLTmES4gcFwmBXApVyiQRYwgRVogRuoATVoBgCSPR+UvSAUwmxQvSKkBlmogewxmSt7gHvRvSdgORiIgR3gAbMCpt3wjQoyvp3ToLFRNeZrPk94gAOYrdWgvnXTjuzQq/+myArGwo4OOxX8azKiSCxvG4puq5ELcLcF4IJ4Wg48kALiWIRKuIRXaIZeKAQPmL8DgAEkyKWr0L8mc4khI4q2czIK8AkPaTrwyysyki0YWcPqU0N3Y0MVOYAmfJr9kwAJkAmbGMPsuIB0C5kMWBImRJgGuIFgQAZRQEEpgZmNuYRCqIEPIIxIciTjyiVeMoHQswEWKIRhQJZk4QVewIVaqIW6uBNUOIX1KQVSICIomZKdSTjq+YDiwSgIaBh+ARnWwAAo5D0dOAIlYIIvyA008A0LMibjOA6WmitmWrUwZIK5Y4C++47D8qtWcS0OsyYRYcgPc8Opg4kCtJHraIr/BFgAFpisP6SDHaCESmCESziFY/EEEyAsMtKnhsEKqVgKaWmRq0Ao2Roj1TKoflko/etAvnO3DsS7uyMjtcA621K3YAsZ8WCAt0GAJ5AEQqCBFGisn6QdlokdAzoAENCEU+DFiukETcCETriEStgDhoOkviBGwqiBFaiBHzDLHyADLbiDQrgDmYHLPygEuKysusTHypKZt/yDO9gDPYiCpSGeBYiXa/uLpWGAJwCEJzCCHlACKaACNIDMe/QDBoOrLkSOfgTDMAw6UvgCrPDEBOCwqfuiFAEKDOCAEiOtEBGoHQvAC2DFmPgQVpQAa5oAViw6tlgETcgES8ABNFgC/0oYxEgQBWRohlgIggdAowIwPLezuivjl3ubKSOLnd5ywxlBqOQaI+E5FJ88lO7sTkNhjZFZC4vaMAaQAAQgACIIhVCQhPaUhElIAgY4MROIAQ8gsLzBgiZwgzpYhFFABSIqBV6UEo3JhEXQgwPVgzqogzWYAzWYAzk4AzMoAzIwgx8Igh/QAt2Igi6AAigoPR7IgR3IgRYg0RXgi8Cwt7EAH/BxQtUwAAd4ESMrTO4oAkCIgydogirogi/YDbaaTAZDJsu0hLn6R80MumEAhSjgF6VLOqR4gEkcD1x7umkbiQ0RmIEKi9ZMEdK8CS76CfGDAENoPi5ggUGQsILrqf9gwAOyMCDO460LhBrvMguQacJ4aaS3Mxkq864949MVYAE/bUaMmEIRBYIoiAItAKbcOAMu6AI0cIIseAIMQIBJBYRP+ARJAIT2/IRQuNRAkAREkIRPCIQ4yIIeMFUsMIEcYIRT6BMUBEdR0ISNMYMCkspCKRT9wlX9ctHWyFX98s5D6VVdxbDt0aiGAcwEAJJrIxnAFAFAAIQxcAKa641RW7CtK45FQL7kGFIJAzpPYD7nCzpqIAZP+IBnwY4fk1J0dZd3CUArLZiqeKKRSJhri7YUk9Jpm7bBEo8O2IPl8IQhnQTkqIRYfYVV0IQ5sIFlNAEcwIEbYFggqA0gwAH/ILCaKOACIVDUM/iCN3gDLkgDYaIDjiU+myM+O9CDUAu1NxA1OuANOoBMNOiCRM3PHuCBHSDRFrDBXCoutHAkCjjPCCCCEAiBCJjUokUACSiBTc3UTwAEQrDRMSiCMiyADygEi3GSydvKjVkBDAMUNgqxr82eEHujsSVbPtqjOdIoK9sOMqxErvBJ1ZCATA2EMXgDNtganFswrrtWfpQwn+tWb/1W5zsGXOgEEOgL5pIXeYUNZKzBXZqaBiIrsiIwHcgbRqGCKsDc4WODL/iCA6s5juWD0BVdPqBbOxgESgDcRthWS7guT3gFYegFU+AESjAEPGAwP7AgPDiwM+Bd/969WF+CWB2gGhegwSvxioYDmeBR3lr9Tl4NVl+9VWGd1BAABKJFTwK4XuxFAEuNAEkoARtFykyFWklIAY0CAj/wBIPjxSiRkks4gLGNqPiVX/kNgAEATwXoWhrpkY1aANVIgDFoz7l9A9y1IAzCVuSDMJ9bPk5hYDB0PlrQxlHgBEs4pkkI2CHVFJ/rWwxGDg06pmMyBK8R4REGDq85BBEupkmJFDbYDTQAptnAGjTIhKDrYEiwBEjQhEhoFkcggxroAJIJn/HUTu/01WDlWjUS1u05Yttj4rAF2+U5HuwVWqIlgCrGXu1FAEAIBSIABCIoAUkgAklQAaQsAkkIhf8UKIAHoBdKMKKDY1WCKwSHKts3Qp7jqd86nuOyheKJIh41IsP87QrbUYviOQAaaE9C6AM+GIQfRaa4ooQE/sIFzszA9YT1GQVPgIRCsIMvgCCJtQGc/VMTTZhFYhlgDVYiBs9bVaMnJh7kIZ4DIKTrQmBGYARI8IMfSJnhWeUnFts8nt9fBmY8CoBJtd4IIAABEAACsN4sZs8wFoH1tNRKjQNBCIU4IMMIUc4OGIRY4OZYGAZI6ICGoigXTWUlGWew5R5c3U4HYFQ5GAIfgOct4AKSfACQ6YAY0ADV8CjmckKsW5oJiINPDQRBGI4LYrC9naxKUOBJZujmE4VHgBn/PACC4tKzhTnekfKe1kie54XeXt1lXl6NDOha/dqDKoknlooERsiYctxjsw3ml4bpPDqe5Lnj7CHmY1ZmY0bPSU3PWAiFTOVUnx6G9eTUUNgEBciefPbfTQiFQViAHbAEE0jb8DHLG1hUCsLdBYMENdCDO3hL6aGeRFCEy4KZnHmESEBgUzCFyUMiTzgEG0BHR1LGpYEyeennjFKAMv5URNCgLUS+eFJoVZPkhga6PJCDOaCDLqjPe/uRbANB7tTo7Ilej7a9ln6oPL7jGlAOTegET5AScPwAmsbs0Sbt0sZsXkae5z0ABqDi7MViBDDmEODipSVqaIbmMUBqA1Kj/zFgzwTIHu3gDgUwgU1AIiMy7uM+Bazcyp0ZUGA8H51RKY25BEzwRigBBU9ABCRAkpDpAECNKY1yOK/Ive7JvQPAgEDYhE341EZo5A0C7AjzOU3gBE2g7/ombE/Qkpy6il815XJWEuEBcP6e7Fz9VeFpgNBbAS1wBE/AhWhElmCQBUWQQQjob4520TXiaHV+SokBAbKE5yEgAzmomcs6a+a2mCQyIlZ9BaPBBRVUBVUgAuyl4iouWqI1ZhqH7RqPAKKVbUBQASNQAA9QoxRgzyJQDRZKgGReDUT4hIMzBVLwBCcBhTaDkuXemZ8xH/NBnyvvGfRRIl4EBT5ggAKggP976QAWQJJPvpexQJIfHp7xXG0jCNX0noSdS2D4Fmxmqm/7JmzB8JI/dVwbnBqqeVggAAIlQFQtkIIu2AJD1YIhCIJIN3SGvQEbqPRivEEPEIziEowueSSH8YEhuIOMmZIpiQS3DHE5UHURlxmYeZ5IoO9OSCIULIU9kZxXmIVaqEZrxAXGCQZh+HWHcPBoRJNiN/YzMZZip4xlOJZhiAUOQOZlJmajDQErxmKdbm3YrlRJiIOBZABolgDu4I4ZkAACEIFNDQVTiAVViAVRDYRJcBInQQVUaJ/2yYV7v/dfiJ9i4PdiUAZmeAZmEPgeDIYmKAACSAA0axhalCSFNxj/tCAZFx3PBOCASrXUTeA5bZ0wCcsE+dbzPefzv+UENYgCQ/8BHayBG1D58WIBEmWB8VL5mD/5Gyi90gsCMsD5nC8DOcC5tlIE5Jswjxe655vyeCcFJELBU7iLVZg8ozcFWaiFXMcFFvf1YGgcZAGNrC+Tref6rUevr0evTPr6TSK0+2GvbJCGx0AGVZAAZFbmECBmoCWCHQ8BSbhenjbaCID7SSUCpsWAn0ZKTn2CtcU71QgAAiDqF+dmQLjeCtiEYQBCcACHerCHyq+Hy6/8e7gHzL8HfMCHze+fWICBg3c3fTquk2PshokNenGA7dDnoZyAJ2BqTr1MDlI1Bfb4//kGefp24KDjhMoytelxhOneSqIv+hTnk1a4i1aQBRV0/uaHemuU/unX9V2n/lpo/ulf/rto/rvQRm3kE123xluYhVu4hV5A/2A3BjRBhsgoE/pRL/QStE3ipE9atKNCpdh7vW6Yqm/gn9AHiAgEBBBAEIEIAgQhQkgiQiTEp2ECCRIgECFCwowGJYWSxBEQoFChijAghEhDgANwUhwQpCqUKlWxZoZAMLAgBknDsoEDV6+ePW/r7Nm7dw9fvnxG8fHjh68euGymMGRM8OCEhgULHkBQ8OCBBQsaPJgw0cJEBgUHChQwsMCBAwYiAH0SuSmTpUx6OXHSq4kvYE2CB/8LBszXkydOrRYzfvXqVi1cuGpRpiz5Mq5emXvVunW5cuVZokXfmlWaFurUqV+tdvwKFWxXrFw5RuUqFW5Wr1jRcmXLFizguXz5AmYcWDFjyZItY8bM2bNn0KBJq24NG/Zs2bpx//atp8+f4seTL2/+Z09VDCpWDHFRocNPgByKJHLToiRA7gVQDCGy40N0hQJIAkaEsskBD0wyySYzxRLTTKEIVBECDSFwgR6yUNNTPalsY9RSTSUl4j3gUDOJBBG4F8EED1zwgAMPeGWBAxRocGNZMezQwgcOHGAAWwcsYMEEFTyxiUifbLKJYU0aRthffO11WGKnnFJKKbChkqX/llhiqSVsXoo5JplliolbKqWguWYqsMDiCiy5yCnnL8woY6cydyYznTTWWHMNNtx45114QBF1KFFGEUXeoeeRB15P2mlHDTXTPNNMM8scIwwuvcEmiidFsEcRRjbBN18EIYWCgAAJpfoJERgVZBMR/81HhEdFVJCAAAWsVcAABSTwxCcxhRJLKCEM1N9D/A1ggSnU4EIGN/ngA2I7/pD4EzI9GBSCQ0TQgAIFMX4VVgbnduABCzrywMIDaw0wb4IejDBDIMWG8sknfQ2m15R9GTYllIBhySaabio8J8PE/fKwccVIPPFyyeR553PS8dnndYBiwx3I3Xgz6DfhrAPe/1L32AOVoy2fB8432mFjjTTQPGNnMhL/kgssaYqCCSaPPPJHHkWT4YMPNSgNAtMgrAAB0w1I3YAC7C1LYUYFRcDRsZ9I0p5DqAqkkE3+hULErSAREEABAgQgwARFYHAAAyowEIhIsXwSAn/8IYArQgMhUGAGotijj7X3rJMPPInXk00rTkiwEOVEqKCBA2/FGJa67MZwhBJV9GCCA0DOa4ADHrwAgxOT/PdJYpkU1mTAfWXC11+z8zUd79JUU801gG6zDTfFe3O8N+Eov3w444yDDvTrSL8OOuyw04717WivveLTD1WU9de3gw/518szTzz42MNOUtdC1Q1PkWZD6f800WRqjDDC8AKcK1uWMooofgY0oSUiEX8gWh7kQIYhII2BSWsa0yAgwQlScIINgEAHLPgABiTAajdxlX5khYBQDGMYegPE3wCRH4/ox1UGCQmsUIUrCRCAARhQAFtm8ASrEIKDMDkbqygCn09cpCADgUA27mGt6TXvHlARRhQK8DeHUE4ELjABjcCiLgtkwHM64EIa7MAGJphgAUAKkgVk0IMe9AFJ//EEk/yiO07kThMAo2PBOFGO6oVPe+Hr4zvMIchBCvIdhjRkOhJJSHKQQxziYCQjz6EOdbwjHvFwBya1h0lM6qOTnTyfOuYhynjAoyn3+EYqfvYIoGEiEgT/TMQrDVi0A9JyD4UohB/2oIc94KGXvbzDHeRQBjIQswxbgEIOWLCCDzCzmRmQ4DMzIM1pWsADHngmkW5CEYJkpFZEdA8gStiRAR1khfkJELjAJZKG3CpWbgOAABKAAV4xYEmAINZMiDiQhSAAJLgqVUUKIIt6HGUoyPvG40aRgYochIohEMEMYOCBB7zlAV205rrapQMmoIEOfvADHrhAuh8Z4AAOeEETmvAGQbhxX7CT42Bw9y+ACeYSlyCMPuiRU33Igx49/Sk9dEqPQ75DHj0d6jvckdSlJrKpTYWkOTCp00Y+cpDqeCQkGSmOc5wjkupgZDsUlwxiIq1oZp0l/y3vMIc5AFMPd6hDHe6gBz3g4aO8xAMf+PBLYArTDGZQgxmOKQQc4OAGN2gBC1iA2MS2KwaOfSwSkMCDHqQgiH1rlUEOosK0DQMZoSBBEZCVqo7EMFZo0w9HzhkuFMZzIAF4bQAqcCwHIStwBDnIaCWhLJsQoBHgsEc+9CG9bWgDG7k4hSEowACMgCtcIhCBEWTggbCIpQeCsIMLyBIDHSihC3TAgyEOcQg/pOEGHWjAAYTUASSw4Q1vaON/9sUkTnSivnaUHZQEg19N2FQw/vgvgP/7D38MuMD/8KlRj/oPTzL4Hwl+cIINuUmlyiMdRp1HUIvqDgzPwx3nm8ckRf+JYX7YAxyi8AEUarACYhJzCC4eAl/lIIc5ABYKQgCCELaQBi94QQxsYAMaznAGLmhhmMTUwhCgoOQb4wCxK1jBYVlQFmaWhbGKdawO1kgCy152VgpRVSwksYkSfiILJIyFgOSjQoQwJAIieMKaU+XPijCgAhwEVgEkIRPaSgIjrbKIOveVkIpIIBr1YIpSiNeNXNTgAAlIUWabazkVyCAFJ6CuBnrABzZckQU4QAIX2FDXRjSCEo04BB6UsAKpDSkGbLCDHcRAiLq8RCSJ6QRh9pvfwdhUL//4NbB/zY9/DLvYwT42spOtbGD/lx/aerazo62tplC72uqbRgKBkFj/Fi/QxdzmQhBYAAGTbq4DVSasEIIQBKT54Ac/KGwNlPmBZTIzgxWEwNTuPU17rScA8OwybwlAhAfBZBjBeNBLSjgMFjrEIw1BGwJU8ARJwApcDVmbvwEAAAIkoAgTz1uEauI3AoCELmG2GhvAcQ9+KGUdMTNGHhydWY2UQAVFQEEKijADElwgLBowwQte4IJ2CQGMdTUEJCyhdEtAohBz+EAGM7CCKNjBD3SwAyLqIhJTfAIUdAzMru9LU8EUmMDTrna1y652s6992ch+toDZfnYRJSUf20qFHLagBGUGwd3uNuwNfgAEG3TgAAOAbQDmFawDXDADzITgMqf5TAdQ/3BqjJ8aetOL+Xx3gAIFeK3b3safitwWhqZABjKaEQ1qlNBB90QbCUUCCBWIeRNwPlsIQiIJm4ig36AvgBFmUuvdf5AAza3P6AtAikPzgx2nBAcz8tCADlIoAcJKAAMUMAEOzMAIKRgBBapZltXpAAcb7agfDGGIvEyJEorYwg2g/oEbpCGXV8+6TGrtdbDnF2Bj10RQBdWDIVglxUNOnQ89cBiIiVICJqAoyYM6PBgDJuCHzYM8CJgDclhQdRg9uAM9HNiIuEM/7MM9dAMmGNAeqMEc7AELsuBc6cFHWUEHFIDGJd7plFQDfMACQIAJsMANQMEdkAGQVQEXLAETKP8BExihEvTADsRACyyWCayACchfB3xAFD7ZCrBADsjABkhAwBHEZQUAAUjCTKBeMDQDpVBDLJjCS3jNbCHLgBDLvsRBHDRE7u0LBhAABhDCE6gAB+BQrxhILGwCrExIQTRXnPXNAkwDUFxLiUVDIhjAAMRTAlRiJV5ABSgA9nHfDMgAC2iAz1VZC2xXd80BHhSCISjCIkACJShdJVTCIviBGQDBk+GAGdiVH1ACKcSEscDOYbwiMEICJMDiIjACJDACI1wCJggghBmVIcEDPMQDBIaSiEGgiF3jAyaYBVogAW4jPfhDAk5SKIUSBXKYP8wDP+jDgfUDP9xDMTwCCqr/VQu+IF0NwhrYwQIkHrAMwSmoXjQggyzswQFkgAl0QBMwAdX9mBecwRQUYRQsQRQoARAAQWHZQAwwVllMYUaWRRa2gBSagBEEAqpYTd+IAAkNA6ZEg0pSSjSAAih8Am3B4Uioil08HEhIQN8QgAh4xBhIQhwwQAEogF0gBEUIHLjMh3sgQAFYwB4sA1AYBVT4AgjMiwBooiUmgAJkJQNwAA0gARVEAQ5YkzWZgAvEgPn1ABjRgS2pojC24tIxXSHgwRYI3hbY0i0tQiaAAhv2oifohSsC4ysaozBCQiR0wigQ1TNGIzRuDzQ64yE9GGIWlTwQlTTCgzzEwztYpjRi/xg9iKM4ilIEns+HBWAH4oOJ/UEixGUdqEFdtSALgtcheEEZscUKxE/8gEM0GIABlMUXvMEXMEEaoIEZnEEXcEEURIGNUWRhGZZjbaRz9mC77MiOmEAP1KEklEBmXUQJEAJKol7qqWQ0zA8xcIIlQEgwmNBMZN2DmIIpyJ7uVaIEfB7b+FAopIAMFEAgoFkEXNbfJASqAMIk8EUnsIJPHIVpisK4sYUESEAFSED2YWUCTMAMJEETsMEcRIGUlYULuAAO9MBGpcF3pd8irOIwVsJbVgIkLEIhBJMc7IEhMIIjJIIi5CUbrqdL2o5e2JRNDaMwGiaWRCY0Bun2aE9lZv9mJV2mkcKDkRapklpmO1TSkhrVN4KYZ4Lmh4WYAKZDOdiDM+TBHyiC1dGBGeABL7FgLoGXIbBBvFjfAdSCMGBCA+xCNhCDIujmBQjCJHyBGKXBGZhBFxSnktkYDvgdcy5WhmbklbkLYrWAEixBE7TRJvTBExACIaiKP9oPMhyD6qVhK2TCTKAkNTQDeqqCwh1cmOmEKjzBE8zhBmClAiTBJ8TBBTBAXWAnwKUTfYACKYyCrjrlPewDP6yDKIBABjhAAthnEaiACHDAgjIACSQBHLyBHdABF9jAFW0oDGwUE1RBiKbiiA4mMFoCYEKCIhSCXTpCJESCIyQdKMBETJj/AimAAmLg0WC8YiaMwpWIQiloT5AK6fb0kU95mMBymMDKQ8EerMEmrIcFlQfqQ4dN44Mt7DtkIzmMg8uVghx8FB7QARt4gS/10mvSgSG0gK983ryYUQD8wBZIIpAYiCpsgqgFJxE2pBJEwRREpBDk7I1RZA4clqEq1hPeAA4Mng0IQRTQwSA0AiEiCyEsCQmlYaU0g6au3qQQw6amoagigwkpnAnVBZkVQUR0rQU8gAnEgLuimU1clt94DUMMgyqQQrx6Qikk0T70Az4wQynkgQSZQPep6hMUAQmcgAyIAR/A2qb1gNC5QJZ5JRWIgVoOgiGM6CI0gjACpoleAjA6/4IibO662hSKUsIm6OW7sicpIEZ9YYImFCa+YkkuMENTHVI6MGaQXo+HNaPtQqDthuYkJRg9GCAzhqZRLewF+oM+uMMe1UM0/MEdgNRa/RjI3tVrssECsEWwHB5szctrHcAMRIgpDIIeiMEXVAEVUAETlG/5IkEPHIH68sDOAoHPPiH8wq8OvIAOREEdDMIicAIpfCopTAJMNoOkpOFKUsNtUoqkzA9LNoPWci3XliGmmAIPNIIpTEJnDYM+LUuXMQSuuC0pwKsndAIwMJ9SgMMu5AEI7EAPJEEcBEIg9IETGAETsMEgzLAg8AEVIO7ibquPVV14SS7llmi4Yi5gCv/mK7riMNIohKwnKYhCfQUQKVxJKhTDNdQDOXCVFZ9DOpiDU8VuOoRmNkagZ4bm675DU0mSOpjxGU/mO2xgGEegKL2DU+wDO0jPN8ACGdDVHMgYGogayPZS+pGCIXTAGVGl4ikefsbCMLxOHIhBkHGBIx9nRCrB+u4ACuuAJePAYznWKI7iDlgyG9RBIUCCJ7BhMJSy25oCMRDwAU8KAq9yAEMtpi7wApeQ1qKewnmnLQOCIaptQRDBpCLDep7CKGCCKGADQZGPyymDKOTBuyGBEYxBINQwH0SueBGCILwBFSABE4xvFfzYG+gB5B4CqU3uYAKx5XruK1KCOlvCJaT/6zBygl7OxHkGg2ZkRi2wAirQgjEYcz2g8Rl3FSRh8VNV8SQB9BVzlSEJ0hZ38T+L4znIgxYH1Rl7piRZ4DuQzz6UwxxnwyNAwRqooALNwXf5cS8VwiKUkCf0AAPIC1uwRQJcQByQKnrCoSB8wZA5snEOgRRIQSQfAQ/wwCVbciY/liX3AKiRaSV4wii0Qi+UMjGsnv3AjHdwxypTw+pBbaVgLRqqpALLMi1jyi0rsKiKaqyQHn/8G0MRwZg9iDCrki38BFI8RT1cQzKIgiPMARBsq6gNgjiLMyIcghiN7xdQQW++mh9A7uRSAjmXMyToqGOjszpTwiu6cySYqCfs/2ItBMN32k8v3IIt+IIyfINRgJgVN5VCj3FkElU6GJI8KGk6XLFDS9JDgzE5TPQ5nsM1HlI0ks9/WawwyMFbAdPH4lVe+cGKnp4t74sgQHMgIIL/ah3IJUkfUIGQDVkQRIEWaAFyCoESKEHOWnL5EZZjMZaOHMEUeAEdhLL+tkItcEYvHEN4dkOhjEek/CMyWC3q4YIs1AIvCAMxCAMy2E8zEMMs03KB2zLXbsJDYPBZc9NBhAIy4MIqAJAmxGgiPEM9VA/5QOU3LEMnFM0jiIIqZIKpHcIg8NIg4MFvajMTcIEYwAE4h5c4GwIqLoIjXEIntLMonEInOAK6LgKK8v8oMjJCJehoJUTCTXWCKDyxbizGKABQKjDD4vBDQZ8DIWmxImE5GS80IqXDYiYSV7Ux8CYYbnOVAFqgGgvpUYAjO5jgEPzSx+6SHRQ3LqlCqAaDKniNOTmcR8RXhAyiTTuydmc3kunszq7RJWOyJscADzSqGOCBIkCCJiw1ZfRCLwjDMkTDx4THd0AFAiNDU+NCjTqILLC31VIKpuAyA4d1qitcn/GW2jo4IMQCMtTChIvCJTjCAaXCN6zDOLQPPoRDiWUHNmRDNJiCJZCaItD4IhiCHXwBTnfBG8A45IZXIxTC5kaCLAQDALUCMrRCJ5BCK3hCW0LCug7m0r2ijqb/K9AY5pMDTSkoAzewg7NZMTkMUhZfuULrO5YnkvYotD8X9ETvboVBIG47oGMKKVL81zoowxAEwXfdAR7YQS/tkimeOAuSwvz0wia0kEUwlwrxi58jsipAu6Bn93UPwUSuPBB4aHgr+hPuQOjI8CFAQl7KRGX0gtVSrXzXAzdAw/xEQyk7iLyK7sGd59VaNVff96qXkGYLeOvFAUAxODflXgnJwikwcSTI0h8oA/UA+6KIh3dQQylUAuVubqQvwiCI0RmUwRngAQzekiqqqCJ4QjAQQ9bjAt53Qi0QQ7zGa+qqK7o2NjCue7raFCY0MSaUQjKINlP8wxXj+70L0uQv/xIjnbYg/bsWHzTnS5JRWVgag+NRGZUlQeOI4MM3nNgP0AEd1MHVUTweqFXF70EdOMLqNYMpxMq3MBfs/UeE/McbcMGQZffDP/zK6yx4Y7Kix0AO8MASeIEeGEIj4GUHm6feq940TAM1YEc3FLuxy4IqmILB7aIqrMI8a/bVQrUCE8Mw4DeCl5BKmqEFvwes3+qsB4MpjEInbD0t5QEmYANArGvHLx8+fPbsrVvHDt26Z6U0ZYKkSFGhSpQaGcLDZg4dPHr2FEqUaBGjRZli9RI1ihgxUqN6zRJFKlgrUKA6XYq0M9KlSj8v6eQZtFNRUaJ+XVuYLx8/cuTOkTM3Nf/dU3PisE4tt7Xc1HbtpoY11y6dOajn0KZVi1Zdunfv0smj50/evHny3sHTO7BgPWlkaqyY05EOHTt48NSpc2ePnkJ29OCKFi1WEQEABES4HCIOIEmEQg0LBcqTqk2f7HA5wyWKliCvgwCRDUSIEB23ccTIHSNGixY5jkzxQqcLHkOLIFkCZWpVrWDEji1b1mx6M2fTslGL1mxaNGPCdvFq1jKYMGHHqDeb3AxZ+/bsiQ2TP6x9NGSxhgEKgYA/fwICABSAAAKIAOQTVUDRBJJE/mjwDzLy+OWbdQjKZ5xy2GmnnHDG8eahTixxRMREKrEEI0P2QAyPPfwoRKRFFin/BBJNHGGpl1FgmmWUU4I5ZZRgcDmlE0ww2SmonyqBZKdHjOzkqFJSYcYbdvBhKp+nsMQyLKyy4qqrsTT80quyssQSrafSasutd9SZhy511HlLL73+4ceeemABYYUP1CDMjsMSqyOPPVKEww5SkIlPEs0E8M/AT0goIpRPNjGFFFNiUQWPKLjgIogoYIttNtlu02E33lhgwQQTWPDNhg5WWKGGH7a4o5A7/hiJySWXxESUXJLJJhtwsuuOGumiWyZZYXghJlH12hvmOWTme4/aWJ6IIIIQtPUvQAGJICIQUDKhhBEGG9xjiCEekcaedpoixx124HHHnXjWYWaUiCAR/9GRiEzMyI/G/BikEEMUKamQPxw5hRhZRGmFmFVGmSWYl3AJcpVZTikyqCMr4alJJ0VJRZlt8omHn5WvJEccLLm8isuZYzYnnazMkqosqna2eed01izLLbf8oQdoOeGJRx5/+LkHmz/05HMwOtz40w5D77hjozH48IS+YTIFRIQQiDhQFVU+CSWU00LB7z5DpJCCCyFAFbU2U3HAoVTe+PYtVd90++CDFVjAYYgt1GhNCzLKIIMMOR53/PE8EhEFFWCcGVZz7Z55hpllPjdGdGK2i0++lqqNRjtkVJGE7HC5jQCB/wAkIIQQxsVIEQf3uCOIIXyA5Rt2mvLHn6b++f8nH4dQ6YSTTGBcRBOAMTrEkEGwP0R77Q2BZBVihKwFGVRGqaWXUkp5+BRcHiblFFKCiujjnhhhJBIiMSnlF20Gcif5lZ/yMpjRLCsEFIfMpqIloC2QgUI72lvIERebGe8tSIPHO5hmD2AEZgUdkIMcBlMHw9jhDXaYg9bsEIc4IMIQwQiGc8CWNrWpTRWTCsXZhkGN+zSCNayJAhDsdjdTlepUvfGNb3KwAyDESlZB6MIcNrWFxZWBinLQwg98UAYfYPEHd8jDHx4hClcIwxnUEBY4upENbEzjGc5YhjEmkwpRBGMyiTLdZLbTjGCEAhB9hB3saEeAbRHiE42oyB7/8pCHrGHRB4mAhj3wsTJ+VIllTrOFKDDhk0Y0YnqZyETAGpG97WmvEqTABSlE0Qvw/QgXo3AFMVoBk2Csgke16MT0IpKJj13CfvfzVS6qEcl/GM8fyROLWV62Ja6MY2ZiaabPFhgWofHsaHqJCz3eUjS85OUrGMxHPUqRhyDgoAYfDKFh+PAnFeGBD3HowyBAIQvx3UcSn5Ch2mRoimAgoxmxMEUmmLAaIdgAByyoDW1qYxse8GAHOeCbQ/nGGxwI4QY/CIIW0IAHP7Roox0lVEUK0dGN2sEjLEpEJDpRilscQ3XDAgcahSWsZ0SjFrVYhrCokVPVGYt1n+jjE/rY/0dJEGF2A4oAIQghMBf9gVBakAMYgVGPezCFHfdARzz0oY911MMZpcAEU/nAB0uYaBJl3WQjDjGwgzGCEsi5RCdqOopWvHAUtBAGK07Rix65oiankMUpYlQIRTDCEfXL1SPCuD/i8aOYxPTHMV12wKmIw0sGlGzNxCIVaEKzmvBwC17SYbxt7qUd/sCHNRJxBy7coJxyQMPUrEZSxNghrHAwRStwcYxgiKae97yh2nbrwlhMSjVcAIINWHtQhNpmB82FaEShi9wfDKELJdVoitZJKOzOloRsYIOK/KCIkURCFKWgBUvN+NJ61AMbz7CFLZIxjZcKazI51aFpxkCIQP8Eop6SkAQgiBCBARFBEn04REhd1Bg9NO4OicBENu6Bj3bcgx3EMwc8JgwOZ6TiEX+gbSMsMYlGlJUSGIlRrhJR2BRfohWyGMUqZikK5+yoFy6uxV15ZBPBlqSXjxgJJmAhpSpldS7D7Ec/EojMmXlpHBcqh2WxkqXLHhBoX7HylTEMD3kAbS7YzMte8nGPXMihDBRtLRo+WBiSFmaEf1oCKJARnd3GQhL4bBvY2kYt+bTNFF3gghRwcIMb2AAIOCCVbXTQXOdCt28tsAGhpXAGj6yTDnNAAxrYwObBzOGDZigDCNkMKMaMJBGPyN8Yl4GdlxILGy4lVjSeYQ1hNaP/FZAYhB84kSl/TgKpcZBAApKKh0Fot3dZG4IccPUHW0iVHfxARzn4cWF83OMe67jGLzCxh0GEuKwkTpIjOoEKV3jVx5DgxE3mSrGYvBgX5LsFL0qBil4ISUEwUtIliPSIUiQDG+uIJD/oQQ99NPbIOVMyl7xUWShr9iqTpQqYrmxlDLcDLnHR5pcxfI9uYCIPWhB0Oc9w6cFk+oQdIakd7rCFPxxjGs6Y86PqqYpMhUY+M28bG+RWaBvUYFQ6QPRCF9pQvhWxNzYQQqTPQJhKo+EMXegCptOQhjN4WnKPy1pHVlTSFpFaRPezXC2OkYxnZKMbqyYW2VcdjRo7Zz3B/8iUKkyxCUJsQhED04OKsnaHYw8GjI8cx7zK0Y6kGWQd9rjHNrBdCIx0exJjbVgzhoUNX2BiJOKVKylIUYtViMKvpzhFLW5Rilfcwkej6EQk7IdvX6WiGNKoh0Likbxhrix5RTN4ZCWLDt03ZB1NvpABjxl8r0T8KxWeCoY/y7R4fAUe7LAHM/JgxR/UoAZnsL7IvfvajniXDncgwxBckVNkBKN1n+lt2mo+XBoOwxBOj00NWBAbISxXB0AP+nMZPVHVYNq7bGC69a2PC6iACpigAJmgNbgADSqN0xaDMXonJEJq05AtJE6qvFbqOsyoG7rBGzbwG9LIpXBqGpChFv9aAUEsQbvwwDAQw9jIwKlwpRTAocm+whyWb9oijCG0YfIqYRI2YRN4cBM8IRNO4RioAY2SQRQSQbwgoV9AoRZ85PNeYhZeQaVmoRRabBSEQvX2LRsmZB3QQR9kLwyTRx/oIclwDyu8RPd878kkS/h0Rvj04vjgwRzQASwuzLPggh74QR+Yjx3AQRQcJwp+QFa64PouLfumhvvmAHhEoRmwgRrAxjM8w55kCD9m6BPwoxHcDwd2TjYSCtEUTdHwL7qEYP8ubTUM0ACFoAd6oFSEgAmoQDVCriM4zXGQbZ0QcAt0cQumbwggxMFKQReSIRquYRu4QQO/4Rtequy+ITv/lqEXWoEUQIESUERrDKMwjE0LhIDTnioZXk8gyiEe3MEGqwQf1oEbjsEUPOE07GkTSMMTMu87WIHyROJcIMETgmIVXmFHNK9iovEUVuH0IsHUfgkbmE3waE8MZU8f4gGy0HArfK/JOKTJtoJmwiKAhO8O5ZAO7VDwFkgP9WFO1sEZ8oAMziAKakBPCrEQrc8LxODS0EANxEAMvCANnCoRWG4aING/AIFtZmhS7OnOgoESOgUKOJHQlgsUGyoHmPK5AIc3fAMHekAVB+rR8oY3kEvQbiBvfkcJvDLSsi8IfmC6QGUIroi1bsAHtmgIamCLtODTKAcTUEEYmSEapgE7/5oRBEWQGGpBHSnhEIqt/7rvDnwgNk4IQjDBICekHewFHqatHO8kGv6JB9MmbTBvFDxBE5znEgTLRRyhIlBKM0mBlkpB897KEyIBEhiBIKNEqvJhmOaCaRLyyIppkvDBIRFOHCJyN9nwmWTmgMRkIzXSHN7BKyqOBvlBHJdvHUTBB0wyCvbkA7igCpyuJb3gC/7PC7ST6YbgDnphGh4xGj7hv3xLbUAhFq4FbCYhAbeAtVbAExHtNmSDKRcNKgHHb2IgB3DAoR4tVfzzP1sF/gQt0PIGCHSgB6gADbZy0OCPBWpAcAZHVgJjurQg5JDtsDBhFErBFXiBCM1IjbLDPv+CQRb80hD8IGv6b9NYCwi24IN8QA584aX8rRzK0EqmzR6ygRX8gA+Qqs7OJlOk8SZuIkYSZrD65Q96oig6YRREwRFUkxEgAbHCSBdc7x4Yqx8ca/ZoD0uTpyB6RkugjGbKgSJ3TxzQIR0icmYW6C0a6MLkAS/ggSn44R/04SCmIQ/KYAu4wOm6wAysQDudzgzMIA36r1DZAAiObRY+FByGISh/ErhUpxl+axPY4AyAIDA+4DVWkRV1QDZ+IG9ANdBu4IiOqFVawIh8g3BM1W9KlVSPKImOYAmqYFDTwAz4dAuiYBd3EQo4RdIGc9QcIUlHARVmQRjUw76aQRhkQRr/occPUlDNSIowvKsj7oDTHkyqIiwfiqlODgIcVsEPnOAJnqAz6iwWzDVTTMEUbqIRFsEQQuoPok8OEmleE2lywCiMooQb7KHC/qEf6KH2iIkgqsR/ao8fgCaBuCSAwpSyyFT3ygEd2CFNa6ZNgQYdtGwe8sIg5nRe8GQIeHULrGAKRHYKrKBkA5VWL+0LVBYNgIgMOiG9wAEZ7Ayf7EkyW0FS8YkNqAAIWCBWNPVAe4AHJmo2QjXQXPVoS/U/kXZpf4MHYnVkRXYJvHJqj6BqC22ihAA2jm1FCqHrNGEmcMtZ2gMapfESFKF36MD/YHJtRc7S5DUXwGG9pKoc76Ee/8ChFw6hBESgBPi2BFTgCQiJZoM0E5IERkQCXdDFQeT1ixJLKe5B8MCQTvFh4AJODwtCmPZhmLYsHc7EZcpkYblk9x4WHZiJgKQpmsqiDt8BTuX0H8phHZ7mB6BAF6N2CUQ2ZLeAT62vEFVWZXEgCMjgD5DBjKghFuzJv5BXEvAj12SWhsagAG2ABTJ1NhZqVIDgU4t2VJfWP5mIiUwVQFvVVYGjao+AaoGuKVtA0Agq0JALB1yQRVpEERzhrXZkFVqhFWgJMyvhbC1tNQDwf0PuFM1ADiLhGFABE3ghG+Q2G4IBFFBAAvhDW24nXAAhDgjhMwThECzBFFSBFDQBSf+gNHqWsF8i4YvAqBSUgRv8zRzKYfCYAh/igR7mocsM4jUz1x3aQRzIpHM/F3Qpa/fUEPgaKJrMgV4qiPbioRy84Rd84HBw1XanAIpFVlf5tFOoQGULZwvqwBRURzTGM3nr6T42AT9A4c4QoRVtoAVWQAnmz3rHcixBdUEFjWlboGdVNVa+l47Flz6dlqFEkVQfLZBrQNAu6tO0xgEFqxI0sxM8gZE1wRLaFQ+sjwzkplMsWRapiIq8bw/IYAXkAIGzgRjsIAEIAAG2ZYIpGBDEdVwDgRAyuFJMATM54YM9yUQqQSgiAYwwAZi80GcCLkMMoh1iODYFbmXcoR9cdxz/oKFMmHmAfJgOx3Q3mwziBO+CdoZeLgiDkqcd1sEaHgEEdDEKoEAJlkBqy7mcqdjPLvkMWMDouKARgqGfTkOokHcTkMGeZE5a8GMSlEAH6pgFWhFviOiN80Yrj2iOt1dV/VOP9TiJcuA3HLopYyCQH83RtpJTZNEMqHVF4hekQgoP5qALhKAF10ULtCAKUDpuuMCktUAXoaADLuABYIUOGmEMGGBASjkCwmWng0qVWRkREGESLoUUbkkTQOYSNCGT8CfIviHC4sEf7gKb6hAfKkzLiPlf+/UfwqEctCEXeLiZs+Q3oYwOdVOaxyEsruxgi1jwyEL2uDkZqA8K5BoK/2xXar0SnZ1OijpFC1SaC0zABnTDDs4zFOLgi+kZP+rphuZjGPi5B17ABDogoh5NB9o3jhHaNy77aBeaoTmboY+yoqnvBsxSCyy5CzilEC/NnFZjCPKGsodAa2GjNlAapdelgy7gAhggAR5gAhhAdnC6lMmmp3uaCFa5JzlYFUwPE4oCf3ylFGyhGJiBG6gtkownKogz4x7Xqokpq5LHHcIB8VIBTr4arHPGmZsJK0q3rClSTL4iHdyBhSE2Q9JhDK0NE/SkNni1nKd2anMVVyt5pU2aCzrABFoAB95gEuzpCSgxqCShUQ2kbcyVWjYBCWTABTzAA+yTorVywwucQP8LelQze7PnGECV1lUzm6EHLZD/c30TKgra2ec4BVTO4KSr8tFeO1RChW5QujYgwAESIAFym5R/+7e3pUCEO5XHlZBUwVmOoRiSgRmSQRmeQRqwoRvqwfAMgpK62x2Wxh/mMB4uSC5i03jotB3CQRlSIbyjIkvWPKwTSMpMV6zV+0LQupve+2ErLEP+JxyYwQcg4AOgAL+VoHyjWL9nOwrkZjUAnAs+gMBjoAcIgQfPD3k/gbEfHMLPhhTeAAZOwAM0IAVSwFVSfCtDVdCst2iN1qAx+8RRfI+ZNsUpOnr70yqBgFX8k6BsYKX/7LhsHMdz/BN14AAOoACAfAJmp3b/SrmoTDm4eTKoiHuV564XilBur3y6CyJlJCkh3cFozEEu3gFjVzfgsrSIqyEV0Ado1qLNwdqynMnNg8/KqiId2oEdvJBeuNUecsEHQKAD5Fqc93u/59orCzAK1mVdfoA2gEAJBoESBCEQKnOG8INSNgHide0NXMAFHuABTmBVWOVUdYOgPVE2UD2OP1xUNxwHOvyfVx3ECxqikygUYX4HeEB9AzlvEoqybeA2XrGSrw8AG4elR9s1fucty+DPOkUHXmAEMKACSGAGaGA/kl2Cb0fqCyR5hRsQiuANOmEZmvoG2cFe3EGzjkbevwKHKY5zzwFO3MRN/iE2Q9Ic0fzc/9GeLdQhLZo5TH/T3Y/pytwhHZpPIYSZIO4BHB4B/gAdpcf5rgGeV6VACQpwpRnHisqgT+jgEDKhEbLAtyp9GC7lzuijGcCmEXTABCzgAS58VVhAonBgLOHzoAwN4Uf+w7Uye1e9w2ffaOmzuewv6BRt/nDjKG++tX2Obv67C1jacVj6d9blNYJ+tplAB04AAzCAA1CABlRAdvpD6m9n+1MZeYW7CA6hFrJhHZAH7MX7HOR9TsreHSpIHuCkTehBHch8mOrE+Z4hFWChFIxBmtJ9vBVWgACCnEBy4gqKG0jOnMKF5RS2Q2euHbx27Naxa4cvH756yXz4+PABikghSv9KmiwZJcqWLkuonEGDhs4dPHf27PFTaJElS282hfr5cxiyYMGGCcVVK9hQUExMdHDgwYOJEy5eyNABBAcQIVy5QhECZCvXsGR//AiLI61asz9w3MDR9sYNs2vbtmiRY4deHnz7+iULRIdgwV11qNUaZMiQKFrIaHlMJrLiH0EqV1YcmQsXJkxemNjAQYQKFSIQmEYQIXWI1axXEyECCJCk2ZJiA3pi6Vi2cO/80Uv3Tp1wdRTZXYQH7508eeqWL38HXd08efT+ufvHr909bLBSpSqWbaG5c+TLn0OIPr1Ag+UQilfYUCE6dBfbFbef7149UT6AfOjwFVcnKbFEgSv/mZGGF2ywQQceeNy0RyESKqITJ41IAtRPsQxjCimqkDIKKbI0M0wsnPghhAcWuFAVDFf10ENXMgoRoIxhdQVYWGytldZZaukIl4546ZVDXjzotVdfgOkwY2GCpQXEZY9NGRkZiiU2xGWKPRYFE0joYMIFG2yAAg0lRHBaaqq1FsJrbr4m22yxxQFKM9+w4xs956TDpzrpTGScRMvNM1xz0CU3z3Tu6POPPvis080v3uViDTjvmSPQee5hqt575Xwq3qegijrffOxAVJxx+NgzTR5BtLBCB1GIBAWBS0xxqxVWdJFGGnQwaIeDOE2YEySVaAIKJYR8Esonzm6iSiyx/6gCiilFBROLKaAcwgQLJgwGY0lN0ghFSrSS6xVYbJVFF1xBZgVXu/HigFdeReZFpJF8jUWWEEzO+KRWYV3GhRSMTamFZgg/VrCXPbzgAQUWXFBmCGmqyaZrb7oZG22EmDKNN/D45o+p7QAH6EXxUJdoovS8TE888dBDjj/8xMOPO/h8k4x3sEBTzz188qmQenumo15Cl3oqqjmklrrOOhAZV5F+qQyxRQsfQLDFrLXeOsUUVnjhRa8NNogHToZQSOEilViSiSegeNKIbbR9smGJqpgSirSmqNJIGke0oBkVVCChREozQrFF1ynNSu656rJFOeVAaiUvW3fdq+8ORf8iuUOOXTEx7sCWJZbSllNKwcXCWpzBBRVevjACBRqMgMKZF0eQMWsbv9mxKshks447/vijT9T3xOPOO8i1IzN1MM/zsj7W6/ObPtpskw9G6yhTSiqlKPMNPvwoNPTQmiakfnmbLs2QqPKbapzU5tS/zj3cPEIGFy1A0ADHRYFAYpsC2dZAB7Q9SG2LaIQDKUGJTHCCE6AYRScoUZvYwCYUfHMWsz6xN2lRYg1LUAIazvCFL8juMTIqV+Me5zVaSQ4IZ6Fh5Wp4w7b0iIZ32dy9jvQ5JLkFMZbJUmWiNLArja4rUTBYE1PiOs3MzgMXeAAKVKA706iJd73T2O9gIwn/vEVjHf/oBz/yYQ974GMfhGIO9ehxvTjyo1Ewe0c7lKGMcODjHtUohR+BkQ177KMfRStPcNShKfUVCj3vsU+o5EeqVJ3qfvWrRzHysIcjsOADAeTCFrhQoLGNDYEOetBNCmGIRSwCEpBoxE4mWC1TcMISm9AgGJ0Vxk+EURWqKNEi7OCFKdjBDmxQIROiMITFMU4l5SoXjZ75la+IBSxoqeGP4JWWt+iwh9xsARA7J4QghHOc4iznOKNkma2oUwiLSWYQkHkwhBWuBy6oIgM4gEU0oYaLXWzNF2EDiDF4ohje0IcZ0ahGftCDUNKZx/EaxY8zRvQfefLHOLbhDWgo/yNqzBBFKlwxjaD1ox/mIU+hyCOQdJzHfUlbSNKURo72KIQd+YCHPuJRjvx8AxN3oIMYlgCFIHShClOgwhSqUAUvVEEMbGCqHfSwh7ShkkLGqkQmLIGsUZhCWqDwySc6xqxNhPEnW20GMkaxCD/8iphsgB0yxVmSEtYqClOIwhK2MAUoHIEktaoVSf6qBCHwAAh7DewOcHDYxCJ2sXzhXDd7qC8eIBYIgT0CDioLBB4IYa8jkdE73TkEx2DpcVJgAhdgQoWHbeACEpCACPS5pn76kwisGY0KXvMESAijG+j4B3bwkRGFwixP9IioRiI6x+O9LBzV0AYziqEMaTADFv+lMMY0ttEOffijUMJhjnnIsSeTCqel5iDa0pS2ED7xA3vwoIc7tMOMP9yhqV4AQhfOUAXDIfULYvACU9nwhqdGdVgUcgQrrUrBEPUyGLyMxSc2sYlPECIQPonWMKiBDFNUwhBqpQMx09AFLSBzCLY6ya3iOqAUn+QIfTmCi/mCpBwcCXT4yte9fLiDvhBpB0dQAouT1GNxKVMkihnCY7aUEs6YFrU60MAEJoCB18JWthl7TW3fNAZSOOMbIzse9vhB3OpQ1GbInWijfCOOalRDGsXwaCqAUQpfJEMZ0GDHzU56juCUZzgofal40gdopKUXOO9Yrz7e8d511KMUecD/gx3EMAUhdAENSN2vGPr73wBDdYFTNfAqjyW3ELUCGaTWm7Y8YS1iICMa0QiGhhVRiD3QoQsLQkPrRlygEsa1QCrudUlezBcW65hIQMxxjDl3483R+F403ouLXdykkUDhyEZWnYilYLjTUgEGTobya7VI5SrTtk0ci0NuuBEOd4zUH9KD2fXKDO+IZiQdzk1FHkQhimWkQhSlmHMqfqHHfLRMHe/gE3SWMxzvnoO7wwl0oKFT3qEd/GbsJkc41gGNPzTaDmswYRBSmF8qVCGFZPOvpqN6yrWt0sBWDTUpSDELYjTDrKQmdTOiMfNgkMITlXCEItSKBimwwdZS4BKJ/3O9a12b2CQvfrbTdazjIOZgSDN27GNrfGxk4+sv00TXtLWgOiM/RgrYPu0ZOuPkCnzbNOFmk5u8+ARAfCIY2PhGOOaxbnnE0XrA1cccYSbmiN6DHd7QhjIw8YhU5MIZxxBFLphRjV8oAx0ZgZk84gEPmWGvZZwH/PHy5JzQi370oY+oP9IRjnDUw96NpkMaojCHIeRXyUzQL9nEcHJOqxwSn5YgKF4OolP0QtU0N2swWjGKSziiEpAwRCHw0AUhmJYLUBTxAFHs6wEJ2y/D9pznpl4vbmod/N0MIvdBxwNm57jH0S7XiMU+Jc3I/wxt1YEHJlCBKE9ZtuMm99vJDf8IfbAJyEAN9bAO5TBI+8APwAVc93AP9nAPa6RdL5MoDxUPhKcN1WANubB4yZAMsPAL1RAO9uEOyPV5cBQP1rNe8sB5b/Qyn0cyyjU9LQN4LrNQLaNcFrcO1vAIeTATaWAGZrAShkN7IodU/gVgdoByaqMIbOM2maAJoeYJUzgKp7AKqMAKpTAKmHAJkZAINuEHQIcGSmADNsAZXFFkQeBiKRZkz3YkMAY634dsj0WHdXh1WzdjORZswuZs7KdMs2JtkMEFZ0CIhXgGTYZ/GLB//+d2/6QxceAJxAAOBlgO+jBIZ8SAe5RGELgP2kVc/eAP/5AP67ANGvUM0PBcyuD/C5SyDvngWxElDzEIR3pnPSvTgtSzd76li8iFPZ4ngzL4Mr41Dxb3DblABnnQIHMQhJJGhEpmOGGTVP6lQGkThn7gfKnESnCTCRDkfJCgCZcAjl34c3jgK2jABtGHAzFQhvxyRJnlhlDnF3JIfldnh/Voj0H0fX34dHvYFbQSQ2IndpphiIXIBS/gZBggAVrEO2/if//EkG0SB5lgDOBwD/mQDozyivyAHM9DERAYgYziGw5FD/lRisqQC8XwDMqQDLkAC8xAkRV5RjVFMo3ybtZTPZ+nizmpk2VGUT0Zisjzkz2pizflDduACWSgBnagBmrQOF0QBc2IBEpWIAZU/3K/Mgdog5UKhBM3wQd20AVzMCzOF1UJxAbUFxhCQC8swAKcEVjpFI/MBodHYo8+NJd1CX5YV2M84HRbt4aB5RUyhIZHFn+DaIhsQAUn8AASgJDg5pCNaWVE8ASTIIn3AGbHE5P5kA/HAQ/4EzXroEbA1Q6ZeQ/fwAzKUAyp4AvLUAy+kArGsAzZAA6dGTX58A6+RTL0EIoRhT0wiJE7GW8TNUfBiR3vRpO6OIrKYCV4kEBzIAdm0AVDNXtIEJVMkGu5NgVdwDoKwzCDCBNocJWulwZCwAItIHRnsJxzMAdqYAZo0AXNyAQ9YBiEQRZqGHV62H07UC9F0kOeU5d3yP9N/IkX3qQXP7Z9evls69eXgdVZYWEulYEwZlAGL2GIdkAFJjABrZUm4uaYHEMEkhAM2RA0mJkfD5hGDmiiDmgP9fAN4NANLcoN2GANqPgMxQAL3QELtrALwAALwnAKmIAJouCjPqoMDhhRuDlSuDmcniiUOpmkcrR377ZevIiR/KAfpeADP4AHb0AH6emc7Sk7XjKdKlZCMBRP91WI3tkrUpAWXCAGX/AGC7KcXbMEtIcEMOJZifFr3BeP+eJD5Aeg/QlZ5TePnwNjBbqHzzYgM8Kg1YcwkXFfhEkFb/ACF4ABGJChs7WhGyMJsRAN2ZAN2MANa/YMzJAMxQAMkuL/HeLDbz76CH+gcXkAq7D6CD+KeKPACrhwC7vwCo6ASXegCH+QCLMKDRCID4syUqDoWyoYitjxm7oJpXLEi1JqPdiBRtiQBz5wA3TgBmmgBoT4nFApnUzga2TKOqzznJOGBtyqBk6JBFTgBEkAr1TAICA2QHTaJEo2QCz2jt1ndX6qn3SYbAG6OQMbqP+5h+vnF22YqIoqEvEkdo4qf4djkBMgAmvXO5m6MUkgBnUQq39QJVaCJTXgEUPgET5ABjUQWlYSq3kwq/jGb6NwC7dAC70wCnmQCIVgjZAQCT5aCtjwC96ADu1QRshKk2bmrNAabyoIb353tIxCpZZ0pSyg/629cgbnWlS0x5YqRnZbm52n1Z3pmgaEaGtUkARGQAMzMAMy0ANUwJ6bQXsxMiO052P7uK97IY9TZ2PJNn6D+qctgJ94MZ592H184WPBZhLPhCNRQCNT8rBksAVawBn0RAFP5loY04gY+xolcAIm8AEr8ANRwAVF5i86kBgie6WJcAqj4EelgAqngAqvWwqiwLKra6u3MAq0gAyn0IWXUAkI1glAam/kU1BltKw8OZyAh7zIm4JPqoK1OK06hQnY+gFrsAZpABNVO1S4onRKgLVKxrUCKbYLIr61lkJNYLY0YLYz0ANGYDiyQwWacX1+KX1yy3TrN7cF+mPNFod5q/914neXd+F9OTCeP2Qv6mdshOpi05QVQEAr8IcZWtA1myEDG8AADOBaq8FPmJqpWEQBGdAB/2ECMIAENuADZWgDcxEEIqsYjhAMwiAMvJAKutALt8AKwvAKGvcI/MZvsACkWCgKoyAKnaAJncAJv/u7mAACjwAN33CAFAWln2eT9LAcyQt4MrO8zHtTz2sPz3CtILEGCHJCZ9CUuDIg3csZW8sF6Pq15ji+Q2dM0mkE0okERmAETdAE2VYwj1MS3XsSb+h0+AtjexqH+NK/QdRNf4ufeiF+icw5y1YkeqkEOMAVayEEXbMwKZswVNAEMHABFiwBW+RFGvpPJSACVeT/ABDgwRqgyiDByh8AAq8MAisgsppAC7rwCD7gCrfgCqXQCaMAAnmACSz7o6LwCDA7C6tgQZ3QhZHAzJHgc68sCtgwgr4FR37Hm/pAetkceoC3zcGYD6vnER+QAUFoBinkSSuhvSdhxkxAdqfVK0N3vfRXawtivbCzGTACI9Jpx++7tSmROF2CtUznx0y3ffuql/uLj/xrL9zEAgLMAvg5df7ap5uTfn6ql+pUF6kDf1ogB45xzyNwoQlJAATARXACCFbmO/+ERRxwARawAC/tADGNyjEt0xBg0w2Ayh7QAWTwCJGQw7TACqn7CCj7CI8wBDWQCKJABphQC7XQIZ7Q/4WO4AjA6qoNAsuw8A32kA95sps9iT2jBx1hHdbuIA/NQ9ZSLMXO8TI4cw/dcK01sDVq8MVKdc5doL28RiDUqdcFYq5ge0LxLL5+XbVnoAVSYANpIRg9EJWwwzpdElgAjbUl9GL2u2LP9leDNViHhdlAEIdVt9DchAMrsAKwsgI4MJ6jzQKjPaig3QI3cBcs8BZboQQLLARt0RVBMG1bQAZlkDBMIAMnUAEMkAAMgAAjHQEbYxsordIlwAESYwEHAN0HsADRbQDVHd3QbQDSfcoQQAajAMSnkLogogk264UgoAmjcN6nwHzMBwmOkAiuWhNRhQcZILKPIA0QWJkxqP+LOOmbyDVmMJiR8JYflgSrc9BEvQKE7NkFXGAFYVOdD26dlVZpIFdpJacgtYYGX8AFX1KGOgAjnFE476nYYMoZi+HPwnYEiIMER9ADKM5iCqwVMQ4YadEXjlXRNRCgoa2WLIADcL0CLGADnfvjoX0XNgDkLeAWb4EDNlADNwAEyURNUJIVf+k46Hl2PUACF6pP4NaQJv2YbzIaKFABFOAADzDd1/3SaU7TNG3TGeDmEFADd+DesXYHdyAHchAEcnAHPkgGeV7nphSGe1DndY5JNgESNUAGotANEZjfFGV6nxdvIoqZpodcIpqJDKgf4CC7d7AFbIADMNGlz0lUdw3/4XdtQCmE6hQ+chbOxhluTINRp1HZru+pAzAAA4ndA2ypx3Mrx3WKz0HWJAu8wOJkQy+2tzju4+Kc2h3gwR2wAv/x42p5A6mtlkAA5Cec5HJhFlwhGDM+TQ1biNvWyZ+8OykNPIwYAkVQBEZAAQuQAaf80g3QAGlO72tO0zidATb9HzZt0x3g7xAAAiAByz6AGXd+53Z+8HsOqxkgyx6RCkGTEZYegflQ6ZKuEZlooptYDxvP8fUADt/QDdjwDMIAq3KABkyAA+caGZ/EBQ4+lWED8y5/6ql+afv1BRYe2DDxxpwhxzrwnjLwAi9g67auA1EJQ+oMptIZLkJWOugU/wRZ8QMspnVHkAOiXQM1sAI3ECvi3AGo7O//zvBC7uwsAASyLBdnPxc/oORSDi/fXi5iywTAjaEKabletDG2RQM0IJ0v8O75Lu9/z++BL/j8/sEQ0AGwjPiJP/BXmrLHCKvA2tOXMMRxPgQggOiw0PEcDw4f7w3csA3XsGaoiEfF8Au/wJLiE7tAinhF/ap5EBk+AKt7MAdf8AI68JxVMnYxr/sxnysSjuptmkL9VXLjq/PuqfS1/gIswiImYAK1b/S7ntd0Kp33e0xNcjpPHxZ65RdzWPUfANuc+/X//h84/eyi7cEfoPUn3ORoPxeDQU20/Vfud0JUoAMbUAHkTv/3a8JPj7katlUESQAQX3ScYZGhQwcIBxFmMAjBYQeDH0BIXAFiRQ0fGX0MIZMnz58/iRxFutSpk6hRo0idWtWK1q1euHrN7BUsmLBDhlZAADFETilRnTA9evTHYx4yQzLWANHUqVOeT5tGlQqiBhk5Xb406aGDCxcyYbVokTLF7NklS6ycPbu2ytu3XuTOpZsmDRs2aM58pUKFCxMkSHrgcHFixOENGjzA6MGEiRTIXJRMXuLYMmAkSo5svtxZyGfQSqD8+AFl9I0aNW78QP2hA4sbH2Q7MOiggQParju0gHiQhQkbNljYAAIkOI4goIVMFgJkOXPTUbqcYeKiggT/CQi0R+AeIUSI7t6/hyBCRMUTQoTivEHi90yQHxYzcpRzZ0+hRIpGavIEyr9Kllp5ZRaZaKrJJmGIUXBBBok5xphjhBHGGAiPsRAJHTJwAAI8fvBhKodCFNGhBko08UQUU0TxBjmo06EHGJCQYouxtCDjK7bSSosts6zwYgq44qKLLjHQuAuvvbj44ouvHMMwhRE22OAwE0zoobHHpOCiiyl0vIwKwJiYbDIpOrtszDFHI4211H6oYYUVPoCzhRp0o62BA/A8YEMIMrBBoQ5MGE44G3AwrtAgdAhtzM+UiAI0Kc5ggwoYNpCAge3GGy887r4rL45AEEEEDy7YOAMN/zrm0CSWWGxylUFkiIl1VmRqrVXBWBe0FRkLd63VQguXEXYZYIs9RgeEHOACjxLzhMDEZ1VU8YA8qbXWAAOspRbbA24oVIcXkGgBhyjKLXcLyJbgsct1fYRrSLzEEAMvvOyi9wx80dDrLyZ6eMGDCy7QwAQXXHihByQci4yLKs7qy7EqxEyLMsgqhszcKKSIIk3WSLsBtR/gFPmDDFbwADeHqNWT2j5JPkhOFmoIzoaPWbshiOIaZfSzcsnEiwkYOMgOgU41BY9T8UqgwQgq0JhjDhu1uEMOR3qR1ddbYf2V12N4vdVYY4cV9hixhy1WbJIzOKQRBwxYwG2GRFQog/8RSTxRW22x1Ztb4Qx2IQYdchDCNNOUAKxHKxJPvN0h6aL38XrtQuOrU/WljgkdXAD4AhNgkKErLJnI+KuGzXoLzIiVmJjMir/SeGEuHh284zXdvChO2WSDYEM98TRAz2dpg8g1Flb4OLWbg4DvuY0djSLnjMvlAg2BSBgaAaM37e67TkWYwYkzypBDDi3mGH8POTRhENisG3RfwQSJid9BsM0ue9hmmsG/GTnI4KSSDyzgAAsQ4AqKdwMfeGhmNkjNm3CXO4gwhG4jakCf6FYDzDgmTYSTQmWooDp1oSVHU3BX40worzTo5QzTyVeSwAQuE1BAA4wJneiioAXXseH/DW+AnBiqkJYq/OgIjtIYEb/SBecNgQtDII2aanAaKIgsggbEDe8qeJvdlQgCB+hABWUDhDhd5GYdC03GIDO5KHBhC1tIw3R04IEJYIpo2TtaeLgnAhU4YXI2kkMZtKCXsNzBFAi6iYSMYSBEJlKRvRAGIyX0SEgakkIwAcaEhAEMY4CCFJUwA28gQEAu4sB4G/GQRnyQmpilsgYsYEHuXNkB2ShENjdQQmDQJJrCVaYJTVCdWXa0LhKacC7ygpwK8XXMvPClX+DywAkQxgQwOeaGW+pCF4hEryp8YS490hIXpMAcIEihC1rSwhC2MBrCdewGULgBnOqEkOF1wAF5/zJA25x1gAKUqAMH+EDxPhCE4dTsZlqopr4kZyS80EGheKADF3RggjgyQAJ0pOh3ljYvM4ivj2MhQxn8GAmbzIQXhuTFIhFZUpPOJJIrldAubnFJYRQDGNOohCH8YIcdtMAEDrDAAjxAEBuQQXkeIk0CfwCEo/4ABx/72AJZ+VThGBAHQugZaApHmSXssgkh7JK61tIjxAnTC/Mq5jHNmsK9RBNGBksYE7wJGRxWE19sEINcvhAxJlSBCkBaixXWQE01buFRUDhnFNZ4ziBogbBrWidrwviBK7Jgn7fxHT4JSMAKMoRmQOjCEBJbBjJo4QxzUGhpTYsH1KLWD3Towf8JNHABiYqgBBXNHg2ewMNUzQGQseNCRn8gB1LEpBcjlVCBUhoT4y6SpSytpDGAUYxngGMQDKUrEkwQA9zgIQorEOoQygkFcwo2CoSDAmhwVhz0FudbT80BD8qlHCg0Ly1a3Wq7EPdVElohiI0jphi+YDmz5mtfThIMDHRwYLd684hyPQOQGmYZJLDhh/v1URfQUE0zmKELhz1sGcywhbAs1jQ/KAObdGfBlG3rAAYoQAGo5YAHDM9bohztDfOVqoWmNrV72MOO0wCDC1AgYCRQQZFnS1sVFGEMcbCDQkk7hxVeuJprHMIfZFELXAiDuMk1KS68XCCUInK5EiKGMS7/+dxiMAMc9fCDH3oMheJkoAFzMESbOKI8IQzhMp85MJ8VJQSc4UDQ5JICDlgQgyEuoXm3XEJgmmAZX3oVv/nFr+LEetcqBJia1ZzOXwJzpR6AJsHT7PRXxlrXy5huSF3IMKczvAUz9DEsYRGfFsoAhTJsoTS228kV8zTPBrB4AANwsYtp45CStaAFGRACHkCc4TngYQ851jEe2sxjN3chhhbQwAhSUAQa0EAFJTiypsitgiSMgQ98QK1p52CGd39YOmT4gSdqgeWRGgMXvOCFl8OM3C/j4ha7IPgu+A0MhFeyksul0CWLkeZv2MMehygEHqJthjjdoRIeCoIPwtKF/yMm6StvvdhnlAcf0gAhOTdojhJ2wAPDjWljgNmlZXa0o8VJenFhvfSSALzgKOuFwM90zMjLhUOz+nAKY8UrXb1QBR+toY0ZzrAarG718c3hDqAdH1Y8qmvCtnMnKmtWAQZggGEPQIAuHiAXt9iCKNxgC11Qwx127IdqS7vHbR5E3/cwBQ9QgAIjOEEKZkCDIiS+POZRQQhKoAIaZIEPfsc7Q0s7BzVo2AyE1YIP5LAK4U7I4AGnScC/XHCCHzzhMJVQJYsBSZkW4xfK6MY9bH+IQwwCDUKQ+yIgoQWmltiPHfVoRzMsh6c9TaF78AN+9AMJSGgiE5zwhLOpGhgzIf+hCdHUWBS4yhbFLS78PqLLfr2wpC+cKsAC1ktfwBS6bo6zm9lckoSDiKzdLH0ua2jDGsxg9eQbnz4CrY7qqPHxKNDaghu4tdsJtjxpgAwwO2ITtrWjFguAgA9IiBswgyigAyFQAx7rMdTSAxLUgxDENj/ou0HwAy8wAcU4gYJ5gRlIgieoQRuMg/J4AnUbBPxovspDrTrAPDXYgiGkEdSohFlQKWHAhYL7slswPYG7BV2YQl3wBSu0woRbvYR7OC78hYerhnvAh3zghzYzAzrAA0swBU7YgztQhEV4w0qoBE0wCf8AhZRYCVVoBT28N1cJBl2ZlWAwhHIxA+wzk77/cB0t2AKv6hIlWLrxSxwv0C/9urS30AtLPBULsxz3AxO/GLkuaCOQ0wr0e7oqMIEBAAAACAAu6oH9kzoA1C1dywgyYIqm8AnQ4oghKLEfEII3iRZ8wpNhYzEWazFiXAAL0KLiaAHBMgNpkzY3czMTbL5CmMZBMAQV7Ds8eAEXIBgYeAEYmIEioME4iANAIARJAIQ+6ANBOARFSIREoMY2Q607AEAi3DAF3IhT6IWXEgZdKDgqzAUqnEKXuoVbAMgpvMJfSEiF/AU048JkSAZliEgwvId8GEOQYIROaAWbuDcsQ6RgWKQ+DKmPdBUysxVV6IK4YwEhWJ0l8KYoSLCR/9OCJbgCHbkCm7xJnHQwIREreaEeNMi003kLTHsLB/Ml9wuS/XoDOMCCU0RFpxQAC2ABL6CDacODeTwDKtABiSADHzgRqwgCn9CCFaCDDfsYHEibYJPAAhDGAggAYhsAy6KWiMCBhnqyaNM7EXTGa5tGviyEQWADGPAAgqkSGVwaI3CCMVBHQRAEa/QDEuSxaqODNFAoNSi+DfuAm8GEY3hIZYAFz4QFW8gFWMiFXPgF0vRMWqAFVyDN0lSGYohIZoAG2awG2qRNbdiGbeAGb1gH3rSHdWAHdAiHcLiyA1mQSLqJ4zIpkhSGZagVSuACIHgTKGDJ7uummJxJmsRJ7f8EAzCQiyDRJrEaK/RDyiVBSqI0i74wz7d4gz5QAKd0SlWkgAXQgUEwQ8LqAjYQDozoSr0xkd/BgTJgARyoATYIgpuxATjRk2wZRrVEOwvkIgOKAjSwA4aCTIaqA+ZzswxtM77k0EIwhD3gAuFgAYP5nGeiAjawgz2oxsbcsR7Ly9JSA1mrphvAAc+jBWeAhmcoBohkBh99BmioBmmoBmhwhmlohlRIhmeYBmi4Bm/AB3bQB37QB33IByhdh3EYB95kB3YIQ3ywPXZYh3DwBm/wQwWxiTMNSUWCQi9LpJCSkGVohliYAyZYqhWYziWgmHKRgrG4Tu380yvgTu98l7n/EBJIPL/xhAv0G0q4mAJOpILyBE+5eIMmCID3RMUCSIAEWAATOIJz2jAhCBk58QEI6E9gDAC3dLEPsIEloANRuoEWcA3cKIAFMDtqSbuzc5tShQAgiJ05WK0yoEoRvI82K9Zi7VBp/NDVElFWggEceBEmmEprq8a+czPUGta8bDLz6aMMoxmwFIVuqId64M11QAdzbQd8+NJ16AZ2NU1p4AbaRIcxTAd/oAd71Yd4aIcwRYdyKAd2aAd9tdJ7YIdxEM4yJckFuYk+pIl/m4l92zfleqTmzIQyETQWCKEdcR0+xaGRmwJA/dPuPD9CLVS5ONREFcqTDRJHhSZIvStJ//0CO7AAVH1PAUiAA0iABzCBHWCDD1sjN0mNUsWWKxoAVC1atzQAC9iBVmqBFSgZE/gAtxFGtMuWttsQB1iBLtCCKBiC9zhD5pvGDTXWZO3LaTSERVAEP2AD2WlJL2ADaytba6xWDb3WbLXKbc284CCNPFgGcUUHcvjbv02HdGiHcNiG3exMaPAGeA0HfaCHc6hXeqjXdCgHc9DXdfDXdqhIMYTS4BxTb6iJmhizRhoufitd01UkllqGWtCtrlA2jDULja2Rjv3YPyXF8mscSFTPli3PRiXKRz3KuPiCNzAAo01FTVUABngAF6CCNPgBLaCDnwUB3xHaYCvaBzgAov9F1WAMlHkCJWyZpxUrtmypoBU4y3MaAjNQBDnQOz8whEJAwWMlW7g1BEWoXze0KWvz0Pr90GtcwWINwWq7gzswH6ujkxvgCFHIhnoYB3JQh3k4B3WwV2/Yhm5YB2lIBWXQTWjQBnpoh3eQB3ulB3mAh3IIh3HgUnNFBy7lUoAtYYP1BtE9KZgCBtPlBWBIpOUihk6YuyNQ2hbgkSWwmD7lghXy2D/Fzpvszp0c2SHRXfo7HSpomNLZxPR8FzHogQEQAKPNVAZgAAW4gK44A13bIgMAgaAVWultygtoy2Kz1FQkNhgTIGqhVQEKNjzRog/YAiFYoxuwOGuzDw+dxvj/ld+yrV9HcAT7fcOzPVv7fUe/7F+5tVYdE+ABxrwWYIEfmLVcqAd2kId5mAcHbgdvgAZrqAdrgIVi+IZ10AZtKAd4kFJ/MId4gAeABVgWrmV8ANhcZgcX9lwzk5DXE90ZvqReuOFGOmYlXKlZyINc62ET+OEcgZ0F4xLaTWIlLtSdDE9SFJLzlGIojuIoHsqx0gEJ1GIBUIAE8OIHcKaEiQKo1SK0C8YSMYBUzNQAMLtUxedUdMsDeAALeIAq2hZYwsA7RQ1cKwOr3ANFuA9kLYSxnUZF6Et3dMdDPuREtl+MTgRDcF/5vbY9KMEXtdtUkRMS64hHwAaKHEN+yIdV/4aGbwCHZMgFbqgHb6iGcYDSiqxIdE3XdLUHLoWHeMDXWY4HczCHghXOMaUQCuFC51q4SMpCpz6zqI4kYyCGUQiCNTqCGNCptmiYLRk5oAPZQLVmMDjUIBlUbbZdUjSdIKnicG6YJQiiHsCnFhOAAujiCmCACTBRQ6mIpojns3MIegYAAZgA4x22BCBaF2tK7XUxY8SNtykRFoCC/YSCukPBiI7oD+Vo+d1fjG7HRIiEih5tN1RkRcZozu5LDT1Bq7wDhSpfEjsKW6gH27sHe7iHbyBlcHiGXLgGca0Gb7iHdZA421uH3fTSdA1DfljuKY2HeBgHcUBqMvWGgJxC0v+0BSnUBYKUwu3u7u6eQoLchYbTspGqhT8gA8KqgskoWfzyxGpaMOzkTjD42JDl5v2qq/WWCyDB5kY9C6TkEcoAEgdjAXwatppNAHTWVA/QRhfQgZgBAbTTXp6AADdOALNrMWIbAQy/gAMw2qIlNgXQAAswAQhYAYzrAj+YA4iGaEdIhDv4A/xQbUIuBNCe6In+bBzXbPtN7Q7lsccUQcxbqMwzH47IA2WQBmyQBmiQBiaPBt52BnHdhmrQBt2sBm7gBm2Y7nVI15weaiqlZaOObqQWToTbBV+wYV5AvYLz7uyubvCWQmCm4ZIiBfTe4ymYjPxCnFDkND6vZpys7/3/iguiVJ2SNb9tVs//3pEA9+8j6AA5LgAFiHSbVQALWAwTcPAaCLbsNQCecOPFJqBMpQBiLIALKNp9/nBiKwAT0AwgYEY/WIT/uw/6PWQbD2RCrl8bz4/8+GxGxmiIrt+NJmSPjkerrAN3m5qwkANRmAZmjwZmWNIdLYY1y+1tsIZuSHJpeAZpuHZVDsOK5AfnfmUqbYdyEIejHnMJcaTRLV0DqWHUE0gzv0IKQTjtroVEEBzx2gJvYou34PNNAzk/t0lB9U6C/5Gu8pFDZe+dCz9+L53V6aVg4qwl2KkDGPF/tgB5ygABRVAIHza35Al6RlUTaEtiq5Jaxd4NyF43//Zw7YXLDtiBamxfIUiDHiuEN9wDd6xxGs91nheJijZt00btjabf/Z3x9/3aH7RbrRvgAySDPyAGaqCGZjCGZYiGZAAGbLjya6j2Zn8GZxCWZ1AGaMAGVRbDfKjldnDuMD/36VZqYSbv0vWFhJN7YFjIX3hIHj3zVfiBI1i68Zq7svDvKuA091YjkJ1vsg5ZktXvuGZvumD4Q/0qdenvHwIiuXADCsWDQWiEQVACyWKlFtCBS46IDATsBviQ7H1jwIZLtGOABGB5S3VLli8AC1ACOxgEO2CDNHhbGl8E50PkXc/1iqbo0XYEoD9+YKdfRmAE+zV6HnNobPtoAdaDqf9BPlmLBGJohpkgG2N4OGCASGWwQoKchVuYBVR4BVv4BWawBm8IB3bAB8rtV3OgZehmezJ9SPzHfx7F+/1/OPyHTYBg5uzZM2jSrFnb1m0bt2nURN1YMmVKFChbuHCZqNHKli1dunj8CBIMmCsmSZY0eQUlGC8uX760MgUmTSs2b+LUOAVnlSpLJHpZQ0ePHzyGIFnyRCqTEDON0tjBg0MIlxsrGhgwMKCBjzwgBgwIAGAsgAEKFBQIMKCAhgBq3a5VWyAsXLd2ByyI4UWMnj2DChlapEhRosKFHRlO5GgxYsaOGS9itGgyo8qSByuqjHlwoc6eP/sJ7WePnr53Ttf/maNGzhAykE6daiXsGDBluZI9M4YK1ShRpEaR+j2qFCtfzraBW3cPXbt25cq1e5duXLjq4bx540awYEFoBq1dwya+W7dv5sGhr6feHvt77t/fqwduWp6ITZZI6YhR58SOHUWKRJJKKgnIUks20eTFRAnGhJODOHlh00RVLLiGHXoMchQkmYBiSizBxBJiJoHtgUchfwzRwAFZ+fBHHlrZRZZYARRQowZhgaVWjjXS9ZZddxXQgRd2DLIIJIQRZthiSj7WpGORWeYIJJAsNhmUm2H5GWijlbbHaafRocYcNfhABiikzIKLL8kowwwwy9CySiunjFKnKneSIkopsCQj/8039rDDTjzxmDOOOOakY1112HGzjqOOtrcOe5Pacw+l7eGTaT758NMpP5vmE843sNTwQxNILMFFR1JkNIVE/f0H4EcoDbiSgSRFaEWCCMKka4MP3uSShBPdZCFRhhxSiSagjKJKMMQQE0wtqmRCCSRFPuKDigY0kMcf2WpFFwBuyVhjWXTlqGNdPf5oVwEZGKXIIoc5Wa+9j0USyWOWMbJZv5hpWcggou1Bmml0zJHGHD6Q+YcovQhTDDPMPFOML6/IiQudo5yC53Cp/MIMN+iw0w488bRD3TjolGMdo9zgc0+ggUL6qM03V4qPp/z4488/n2ZqDzZ/1FDDFPcpAf+F0lL89CpHsZohkhm23hqG1SzlymCCO/26kU659jdFF16kQQcefgxyCCOaKHXKs9BOa4onkCxiyB2J+ABBAw2A8EgejwC+BgTstjsWunTNVVfh7cJVgAErHMXvvU3q6wgjj01JZZT8XjbYv4oEXIhooZFWsGpq0EFHDSCsQMYpxACTS8jPJKMLLq30QgwrpQB3pyqtoAJLyNV4gw5zzaFT3TjtJI9ddtuAmul77cHnXqXr6dxzPuwsuo096tVzDBlD4KBE0xVtEYVEA8baURlmlLHFSQWG0YbVV9/KkhJXhFESGP33byUEstWAwOAf/5hBDWYw2x78EJhKZEIprXj/VjCCoQpTgIITkCgEHsqQhxpAAAQN+AMmHlFCTGDiDyCA0Y/GRZZxhaUsBlhXjnoElgIIIAACwNEADPABPUxJWZrQBJUWUQlHGPGIToIS5yDBucpYSTCd2YwhAlawgpVGD3VIYB3WsIY5/CAIc7gDKpbhjGKkYiDFOIYwhIGLXvTiFbe4RS9kEQxc3EIXxnCGNbyxDubcI1PrCAf3nMONQx7SPcqxBzjkgx5wmMc83bjGQaSBjWusg2f+cI82lOFJaDxjGcbAxBCGAISmKSEKUejIT1SyhFiVIZZmgB+BUHK//uXPQCsJoIB4OUBaneSA/zHDHOhQMD8oAhKV8ATH/1qBiwpOixSg8AQlDIGHO6AIBCCoASZE4c1uYiIPDIPAARIXowGMRS1jSRyOdDSAHLqFR3ARQA7BspYPHCITlsgEEak0GCMuol5PHKhmFnGIyRyiiobYjBWxWJo6QBSiXqzDDxR4t15MwzbKmIYzlrGMYxwjGsIghjB6MYtaPLMWEIvGNLDxjXCQzD34cE44xtEyRHIDGt3AhjKSkQxjAMMYxigGMHbxC1/kAhawyEUufFEMbeSjZzGDxi+KcRuhviIPWvjBKZeghFSucgutNMkrQwK/WdJyfrlcK0mW8D+W8M9/A6yVSfQjBS1ogQtdQEPq8LCHQhhJWWc6xSruZP8KaYIiE4oo0R3mAIXW6akUkhVFOH2gTRBAICuEO+fheGhPtZQTcfBcy1zw0oEaFCITlzOSE58URSZmRjOWKUxmBnOI2yqiioD5jMH+WgiDPTSiwoVCF8pwhzyMYhrZ8E5HjbEMZEBXGMHohUpVakeILeMZLvUGIWWWqUWNYxze2EZ2dJEMavjCFrbYhXrxSItb8AIXtmCFLeaIC2BAVXv3gEYxjCGMjxKjE0EQAhBY8BPzhVWstTIrWtFaIAFRja3/C8P+SHK/twrwJPNj30W4gFeM6FVMd/jrQh1RiUtwAhRnUvE0M7HBa27hCFBIBCxSkYc8iCIVohCnZTGrt9D/2hAsWhmXO+2JuNKCFi5mKQCQBwABKMghEf06DJb8lSTMJAJgWkqoQq2oxTr8FYvCrcOXI9oFLqzmD4noRTayMQ2ferQZyIAW3HCxClm0QhazuIUwdLEMbDBkHIFS5HX8GA5E6jEa0dAFfOHYC1xAerp4lkUtahEMYcCMHv7YxzqkYYw7SksVhQCCEJAQg6+a74ADklUC0aoGNeDyrbnEny2ttr9dXs2XGoarST4CYhDntQtnELFfG1gIeSkzE/rcpyUUUZohrMAHj7AFLLQFgb/5jQyWhQC39cbt0hoZnTJyZzzlOYAmHyABoZVLAz4Aga4wibZYKkzAEvGZ0nRG/7eh60xvgyvc4H55C2kY9nEx0Yxm+AIYPwUpMdiIjGbUohWtqHSeV/EKVNgiu9rg7vHwUWhviHcb26BuLaKBjFbMohWrOMVhf5PBSlSCEhwShTPw0TN+3OMXj8CbGjoiBB3EgAWnNl9Z/6OSBneh1bN8da0BSOtbXhiYvNZ1hiF8BbGd+ddaiEJeVZV0OZDhfXOYQx1OY4izHwIpkPDDaVaXh1TAggwi5HYNyJCHO2j7slypwYrCna63pOvcNUoLk3lUALTgEC7c2hvfhvCHx6vZ3vvWEugKYe8unT1gZ8+8Z4Cbxb44lDRb1MIZUreHP6xCGKKgmFONcQyS9uIYFf/E8ypqsYrbv4IXCu8jyPGxKepgpzoiH40Z8BCMRZTqBjVgAQtM4AENaMABD8iACaRwh2LY4+bjUEYxaEGGFbQgBzyIgQ5Y4IGmNW0Kwky61Fz96pPgL+pNl/+tdilXDWfYJFbwtdaHwPWthxWpDYEWxIrZ+JWGLMKNMUweSFaKmIAJZEAGcBsU3EEZ/MDqgIDcHcAGZgW4eRa5yAWPDEACDN65baANGcCKDMHctUgi/MHkGcZnIAkj2NtfTQZmnJ28aBlvXVHB8FsP6sEcaEEZpM5qOAIqpEJLJUMx8ILrLUMvGAMxIIMsnAIpwIbbzMKjAQMzYEM3LE+ntMM6ZAf/d41XBjyABTSAFKhCFDgAt53hAygAA0yAAlzACSDB6RWDN/AMP4TDNnzDNODCHuRAC/BAC9hA81HIFKCaRByQSHhEg72aGdTaJBoI1MWaWl1Y/k1YrLUE/2WdFvifKpUS1+EAEADBgAlBFHSBAfpBITDCiTnCH/hAV0iWHGTAC6QADLTAD0jgCmwBGWzBD5CBCm3L49TBVfhdDKXTDgVAApBgaT1Auv1ID3ELGWRW4/0BYmTZvFXZsQ2UE1kGZUCRFDEUv+Fb512RFsxBGeBB6tRBGYwCS2GDNBCVMTTDR0FM7vRCK5DCykmhxb3CLjhDN4RDOejDzyTPIYXDOnDD/wM4nweYgCHEAh6sAA6wgAu4QAqcQApoJBLYgSJ0AjNk0j/kAz44CjRkAzIMQtSkARcAQSqlTxSYzxRUwfqBBNSgVaxdmCXWD09yooWFwYbh2q1YQdTsFRoI2xn8mod1GBfwlQHiwQLhwSAogrJwAifgDQj4gDfxnQV4AAt8wBbsTQdI4Ad8QCHoAQisCLf8jQvy3d+RywuFYFqkWzm5xQ4dwN5Y1uKBgBxkY5ZFEUEJZuZAkWQYiWbEFmI2lOeNWIngAR7UgRxgQjSQRzZEw8EdHHRpZjP0wocEAzIEg8T9zjJkQz3ozD/8DDuMF3l5AwzogA6wARvggCUEAyWwwP8ZIIEMyIAR0AAM9AAV7IEiYIJIckpJhoM9eAM4REMh1AEenFkU4ECC/QSs/IcXGWXSzZIXWSJb+eQttcF3tkH+/GT/eIEZoMF5nucZqOcZ+BoBghgasEFfReUC+YERZUInXIImqBA3iQIIUR8LdEAOfMAKLMEDfkAHRCcI6U3fPMLj5cH4NAC70FMOuZAO7dDgJR5Y7M27YcUBhJCaRUJkIJFgWkbmmKiJkijnVN5v+dYVdUkPit5x3YJ4TMNlNoMUZuacVVC0BMPB1UIsmIIqzMJArgOn/Aw+jMM2aINCyMAbwEETKGIVbEJtHkETYAEWOIETyEAMcIEhRMIjKMP/PRSnx7HDOtQDLZSBGtwBXm2BRWwBf6hfLL2PGqxB1GSnF3nR/4BnrvHkd27n/YCnn24nS1hNeaLBerInop4ZAWZdF6RB2TxmGiwQYEFQJ3SCnohCIphQ3rAAFZSfFxyBCcBBCzygBXilB3SANskBZTXojaEQGURokcHTC11o4snFipTJ4nFFYVyCZExJZfwqOPLLiRLriaboimpJD/7Bl5TGachBJAjDKKRCNBADbMQCdEWLpcWCKoQIt2JQI3BILSSDNdhDPrTDp6imNlTDNmCBk+4FHLyBGGzCMDSCF2AIH+iBEtCBIjjCJWDCM2QSP+AD91yHNDwCGdyBHJgB/xlAgSp2wYNg5/vMEnbiKZ7qaaBibMb66Z72qf3Uj8fyaaGmwaGm53qKBEaw3xnApwGWiNkcRSWkWCeMQi30mS2gwgcFgVIegRg0gRK0wQOmgAucwAh4QFn+QW+g0N+IAuD4jVomI4XCUOBlRQOs4OJBgOP1a7FWAmF+Y7F6rbCqaOUh6xX91h0IFzb9DQiMAmgmwg+gwZ1kAilcZYthkCVM0yAMAii0wis4AyatQ6aE4TYkBBwcwiQcArhyAiU0giogAygkhYp5AihU4SrYAjbcA8/gAzocUjfkAsLi3Rx0gRREwchGCNUk0KuhrgJVLJ5mrBu4wXe67uvCrsa6bv+gWo3tdmdLPOrunmcaNKqsoAGk+tVoOJCRXEIngEInuAIcCZUx9MIpgAIemKIdfEEPeEHzyUAu5iIFfEAGgEAZdJM3TVYKAQ4mlAFWeKAOfRaQGACHbmhf/sGGwBzMBdH8Zs7Wcq2Jzi/+FitBcQZnoKPlFcWjKhDC/kEnkAIuDIMl2AAbNIInqMJtNcIEF+4g8MEhgEIjIMtrKBo2+FHJeJw2aMOdhEiIVJC0DAM1DIOlZWsFIcMyfIPNkWQ4VIM0RMPBysH7nIEUICUbpIFLTFidpq6Y0OnqelHsym4bvC4Sayx4MnETe6eg4srIoudHICXKfsR/BC8rhkZgGO//pY4CK8TeRy1DNFBDNMhCJEDByDKBHTRfD2gkRxKtCbhbX2JCKVBbKbDqIyytV4QWuImgWETtNqnI3gxBHiQCit3v/jLyJVwCiuov/X4tOHKtbAHwZ1RRUVzTmgYBFOxBJjQCJ2QCH/CBIEzwJgzCG5AyInwCH1hwI+zB5lmCbCyDNXhhO2QuN2jDMAQDL1fQMCDDMESLGc8ZG+WOMDwcONicP4QKNDCD9ylsHdABGlBBFYgBG4iBS1Ts6Q6xER9x7O6pEoMz7n6sOIMs7CYxyMpfeSYqgCClI3oERhBT2Z1NKyKbsiDwKdiRcz2DotVoM9zCKDhCEOAB8/WAbh70/xybAA+swIAWwiisgitMljc1qLatwAKU4Fowo4wMwAfsDbeAACI7AifMTf068iXs70lrrSRPsteGbcDg7ehslavAASn3QR+MwRjwwRsIgh2o8iYgAiLc1iY0QvEdgilgUC00Ax+BXHOUAzdAyy9TEJ0RAzVkQzMcwy08U8MtAzhc7j+YpKd1QkWtQR28KRswQbxmcxtsM5269UQZcR3ULjiXM8dC3RqwtRusQRhIIl6vgRvUQV4H9hqAgRnwdWGDgcKQLHqi58imj8Dd1RaYwRcNbyuy1iUwE2HR7DI0A0tNw2crmjF0wh7UwA3cAA/0ABzIwAakAETCAQ/wwA4oov8aeAIquALcLa2LkEEN3MEKhEsN8ZCSpSAE1EAeRAIkeAInpHQmoHRKO/KJbW1012/9Rvf+Wkv/OlFkXDLo4O3AhIYQCEEMtEATEAIi8EEcJEEcjAEciAEpC4KHHMIgNILhbgHabMInNAIpBIMx6FR14PI41IIsyMK2/o7EyYmjdfbFyYkr+AI2KEfM2IM1wEIeDIFcfyeevsSEAeVeS6Jhe+w5K3HGhkHtYuzqvvWJrwGKozgkqsF6RqKjPup1moEqLUEXCEVptKIhMEIQ3Wcz4cJ/LfVAePZn94JAD8GBWsAFPMAGPAAF6MAHtEAGHIH5fcAQPEIpuAJlucgCXkX/OSFZuGXF1GqlmvVrJVjCmVvCiT03I0MQ/Uo3/yrTdBPrdWfOa+WWbmUy6TRQaDymKn/CJsSBegsCIggCIQgCsmyC4U7CJEwwoeO3JaiCLNhCMlzDN8gUPtSJy6nYKDCLcOzJMSzDK3AM3FUDfNTDNZASDli4oPbkx9IfUNp1d9Z1oFbsENv6reM66rq4AskKgBBLUNABmYVG2qjNKx6vj8+GRw0EQSiaoiHDKHwfWQ4tBWhAD5hAC7DA9b4AHWslH5eQizyoCG0LuIU5t4SQNsGbI0SCsqG5JVwCcze3ssm7Jigbm+uvMjEyncP5iQrGYHTZ6ByTY+KBHUwCIRDC/ycQQhwgwiT0ASGkTSNg8Cbc96KX9yRYgimsAh47QzY8OD4MESdoQopF7pnUCSugwp4Uw0fFzi9sQzmUZHw4gzjlQO3KOv1dGKtDnaDqfInnes/7/KuR7OmYgX9gZxdEwa/jqRvYwYWgTdpIRiQsSz/KAqQF1TIIRD/f48H1QifIgVk+oAswARPgAA78wA/YgA0AgRmYJRQ4siM8QiSUgbgz3lqGeQOcu2XZXSLkCwShubwz95n7vd+jOZsTPiPHeeYwRhFREWiQ7Wg8Jh34tCDgdCBMgip8Ahx8QuY3wicAqSqEwicgwgUdwuO+gjFEw5+Iqcq1ArfigqWdMEgZw/8SSswztBQ0hEM8fAojVVvRkDg5d6efgkE6f/g4k/gTpziuj93Y/fytn2fy8/pHmIGkggTXwMQ3Z1ErHhsksA1wnDwq0AIvJHtH3SOoc+YoJMIQ3MAQOGUPDMIP3AFBX8gKgIAegML5J/Id+NiGzv0G3v0sekskAEQnTZo4WTKY6VLCSwYtZXL48KGlShMpVmLIsCJFSBshOfLYcVFIRSMNlSzkx8+ePShT4qFjZxCiMXH6BJqESJCqWKpMTdr06ZPPTZsmNRrkiZQpWsak1cOXjxgxZFOnNqsabdmxaM2UJVPmzNq2cO3+5bOX7ZGPGivcuGnTpm3bt3Ppvo3bJoz/W7ty9/aFyzfMGsGD19QpXAcx4jVzGDNW87hx5Mh06MxhkwYNGsyZM1ep4gU06DWi3bzU4wePH0OOKmnyJErUKFKsXuESZuzYMt3LkmVt1utUJDNouBzCgScKTC8rVjAyVejDihstQKwAcR1EA+0HtIOoUcMHGTlyEskeBcrTRYMTD0J0n0l9fIMJK0qcyBH/opGKShoq9P8klVbaAw882MCDD0IEySKLJGjogw9B+OAjCSSygGMQPopqRBBCJsFjEVFeYeabe/CpqpllmllxxWhcbHG3ZZyRxht9yqrHmDJ+qOGDuHx0iy+4/vpxSCLp+tHHtwgTLLEmE5vjScmk/6SMSsvS6IKzLrpIgw0vPgvNi9HAXOMlM+bAoxBFIGntEk06ie2UVmoRJrfdnFkmmmmmIWaUP8pQJA077ODBEDRYAIERUNT4wAQIHPUOPB9AgEC7BiCAlIw85CDDkVNWIYUUUOCzyD6LIOIEVU4ySfW9h1RFdaCBItIIP0j048+QQ/wDkFeUCJSCCST6GMMJGVJIYhNBXHiBjx6ScCILRDaJEJEEqz2EE1aWkYabe1jcKhpqnnnGRWe2amYaFaMx15p18PkHn25E2YKHFT6oA8kh+0ISSH758tfHOuZ4zMmCDTZ4MCrTWJjLLLFc2MsvQ/uyCivCXCOKLcygw480Hf8pxBFILnmTlFNsw01GZ5zRkxpqouEzESGUoGOKRlr4oAY3g6iBhQ4ygGCF76AgQ61JvfMhvDwS+eOPTlpp5RRTSFGVPYkeijXVrLXO2hNPOOnaa1g1gW+9SjYye6NbFVmE17b3OMkPOtB4I9keZkgBBiOMQASRPpxwIokLCcHwjSzGSFaMQ0DhxZlu6nkR3Gz0XBfyZlyc5nJ3+bnnmTzOwMFexIi8q8gk9/L3dL2KRKyxg103zHWFGeZyM80yA01i0KbwrIopRBNCCCi6oCM1Q1ZKhJFI3ARFllt6oVPGPDGfxuVojukFlC1q2IO5Gjy5RC0PTOiggyigwPkHMoj/vi6P9vN4BJNELiFFFqh58kSTqq/mmhP0ugbFf2AT4ADFRjZacWQRaVsbgHZliJGkCSUnwcMXesAHRKRAb2PoQyjGMAMjjGEMSUAEHMbAIQ0lgQ9fw8UysNENq0wFN9cTxvOEgYteECMYtHDFMY5hi19wox35uEcuEuGHN8jBB/gC2BKZqLrS/cgwUHrd6w5TMIVdZmFs0GIazpCZNIhBDF4AYxjFKEYyioENlGEM8TqWpgROZHklk1MvjGGny1FvGs1wxdJW0IEfaGIPH3DUAg7QgRgcEgIZiJQP3Ne+P7xPE6eQxSlIcZ5OdAIhEGnT1gYYtq19rWsCUcgl7oMf/0ZwhBGMuJVI9vOfVrrSEIPgAhIiNJM+ZAEGThjBBmZAgyQ8IRBxGAMfBiGIRvxkJ6bAheWg5qlVUDJqABRFJCKBiU5gohSwSAYzrrEOd3lDFIkYBBs2Jbomos5IfymdOeMyRXcqxmBX5JIWt4iGOdwONGPMJ5hCs7DHqGEOd8DDHd62tgRCohOekM0qZGFD6JlLT9OzXiv+UAMygEIPK0iDCRwAARM0AQZYiIEUxhOeRzzyD0vLQyRG8TRKnscTmHQPQVLVSZuCDZShFMhALuEQUtZqI6lM5SKGysr9HJUkeDhK4aCVhUAIIgkjoMEYjOBUvhVlEpaIRSxWRYpaEP+jGZ0ABUFAsQlPgIIShliEI5j2CFHAghnWAMc31hGOcNxDGSn1wxnIMITEjG50qcuXYJcYpdct8UhIWgM92aCZe3LmDF/SZxn5KYaFqTEyeCjoQSPRpk7IJk5yolMzzCWNZ0CDXM04Bis6cYo/gMAQMbDAIZHgBDiYAA2FWFoiMHHSRDzipJh4xSRfip5OcCJWWBMgAG8KQP9x4pLRla6sMjERUqKtVqdEpSoTqAg3KiIRikAJgt4whgaNIRSxCASDNkEI90piE43IBCVMkQnmgiIWwRgGJew7lE9sAq1rjYQoUpGMa3hjHd7wRjjQ4c16iCKleigDGX7wV4C9JS//5+wXE5UksMdUsWByCdJcRPwjwTB2YZzJzBnyyQYyTkyMWnwDZQpUIDrcgTEELSgkEhGyS/TPPHG6xW1kxIxnqExGumkGKv6wiB2kQKQv+AIWoqDbP4wCFbDp7SOWNopeEHcUMD0ucgeC3JyeFT3OVfOanSvd6NJUVdU12wGBCgnu2sqg+gnJIgyhVEEsKBCfCAUiCBFMQcQhEJtARCMaQQlVda0hm8gvUaQVX0tAFxW+eEaJnjKOcbSjHewoBzrsoYw8/GEPathCX9nJr8Q2kcSkIyzrGMMkxQgGL2Eo0r423JbBgJGelVExi5ckGCscO0ylsQPx7ICHZtuYSsR7/9sf0sSISrTJa58VMjCMoQxmpIwZ3sYcMUhRCDDKoAU7wIEaFpGISAhDGKUoRSpK0YnfruLLzwzzedADXTe5ec37FvjAQXFJAF7yEpHwSCJEdomz+ZQ+ayplfg5qZ484Qk2HaEQoJiGIPvQhDk5w7yT4oOhA9GES/5XaJGJhikYcYhPpbW8jJNJaXkwDHPUwET/+8Q95yIMc8AB1OMAhCjkgxgxQGAIUlIi6WGt4w3VJXRQFNhjDDCYMWdeXvkrs61+jMY1qpCcait0WZCebxs4W1LOjnfaA6qEQByXlyODkClrYoo4qcsaRsYENakwDGc/ZAhRq8IM/XMKtuoCFKP/kXQpM5OESs6jFK6AmcOYCfOCyAdXmT0FJUIW54G6+ZKzOir+EjG2U1v0pxSWOykyoib/ujdbJ3VtpQiBiEoSA+SYs8YlYTMInx1RFIn5bil9AAxz3uEc+2IEPfvAjH/yghz+Ejg582KNzd/BCGsoABe83/S6yfmLXXS11qQvmn2swA2HAkHWty0XXQlKnOgkDbC1ShrFkH4wbBhOaNbTlJdZOAPFgjaIND8igDOQgNcLLEYivs95kFErBFpxHGJChGcYFG7IBGyaHGGahE+5gCNzqrZKB3uRNFB7BEUYBF26BFlrhUwhOzfZt80Cl82rQBmcw8/hNp95ME0bJByv/os7wI2QyARIooZgEIfdwAidur282QRVCQdE8BPekpaw2wRSMDxocZ+fcwR1s5B+gL/r0IR/wYR3qoR5SgQz+bwtWbQuiYLBMxy/gb/z+pfzaQP3Sb0nAQA/1MC/qwA4Dww7dAF/WwA7bIA3qTwwoQzPyDw3owEfExP/WIA1e4g3eQFACcNnarkDI4AzKAA00i2lOrcceUBQ6TxaCIRiOwVyyQQOxgVyeYUVw4bPkLRVSARZq0fEeobV6ARdq4ZlOIcwqCfQEbgZrsGRs8AY/DwaNawd3ygcTIhIyQuIswVZqxSIggdH4YAwEQRI4rm8IYRAawRRUIRNMwRT+6yaQ/9CsQOETTGEdlM8e7OEpeO4f/MEe6UEezAH67mEdvgEcqCER5AAyaI1f4k9I3q/r1ClJRux05iIw1uCfPkz91iAM+LAt0mAOqgQjMZIy0kANOJIOsGiLwg6zMnJ2UsyLuEQTC0QAn63GNKvGVqJjRmJNsO08RiFOZoEXHopcIiqPtsIYbKEUYIPx6I3LWisYeqEWZOGZNm/girHznmkVVuFpqnIqzdEYlTH0eLAHrQttGhB5GKHHwJL4eqzd/mMP9OBtGOHlcqUJesAJYmEYYiFZwPEQ5PLlfCL3gG8ohGISnmIM82EM3aHneo4fxBAf8EH56sHvaGE8ICMy9GIhTf9H1sgv/JzI/LIO/SKSMLKu/ewQIzPSMaSkMVRMJUmyMtboJE/y/gzwJV/zJVXiNVkiTSRuVb4GtFrBeXihjphh717xyPbOGYohFxqv8VhB8uqnKYcxGD9vBk0BGWtwKjsPOj1PGc9DFC4pO6OLVZ4RGiFhJBxhqLgrJP5jEPYsHN/AAXpgE+YS927imOJr44JCEK7KQ4KPH+KhHczBHNLBP6dvDO/BDOvBHsoQG34BFhJhCNTAMKJtDqCOdBDL/DDM/fZw/SJSDdRv/Twz68zAIzH0n8wAoFIToBiGsehpds6gi1QsM1ozAKlk2WCzQGSyJTRLQDTLjU7JutwkzE7/wRVQgRZ2gciM7DfHBRqO9BmY4duMQRh0wRVm4RWWcxREwX8A6CmLkfOis/NmsJJAAfS086wSKoBiqgcTohNoJZXOBs9Qojz1wCXQYAEywAmGYiieykMG4SduLwr/DPcIoREmIR7wUR7aoRzKwRz008HAIRuOdJuSoTjzoMLajjIuTCEldEJVx/0q0kIh0gxEVA3MoAs2dA/10CM7tVMj0lMlw0QvY4vSwFQ3AzNiFQ0aK41qte0ERUZTIyUEhCVQQ7NmMpUUwREe8LMqqRRQwRVugTeXQUmb1ciQ9MiSQRhsATmj9KWoFBSg66xiIwe7tTmdMhj3reC89H+8xhMo/6JNepCaHM5WdCUlCkGtDEEPVG0L9EAPEHDCbuAAxCBZ6jP3FETj/pTQBGEocE/RcGIS9mEf3KEd0MFh66oMu+EZisEWUqEYiiEZcgMT1CIkg21S67AuMJMhGRIv9JBC+VBDy8BTOzVUweAKXpZUWdR2GCYlRfRVIQYSrUBLPHT7erZLvsjFgjYzCpDZcnVGe1VAVKJtEohYIfBYk5UXisEYtslZnUFJjUEXbMEVWKEVWOEUSiHMshN/QOlNRAHN2Axs0qzgOim55Mxs5AxXcLQQmOYOxkMOBmYN/AASqFG8vGsP/sBeQSYSdBE9LAG/gqIP3EsKDwH4+MZgfYLQ3v/zH/SzHQq0HvzxGpThF3LBFnThFlrkN8jgBqBAi+yPMkK2X+hC1yQz1p7OiTT1CjzzZa8ADEC1DFTWZkG1C2aXdsEAM7AEDR5GM373YR7DVTsVZ8XECtbQYi6m/8RgDaAXeulADewp2lzSRlXCV3oVNQZEQPSgDgjKYzqrmiCQFJCVFnThNrzCN63WGIBBa732a8N2p8isBy8JE5JLbBSiujri4kIG4xIh7gpBD+4AMbYgaH5AC26gBhiYaJDGB4aADO7gDyrhIXoKFMyxFVThabbqFFERFYdBFRpBQ5YwEG6P5P6LD+AADhp3EkLhE6TlE8ahwfqRG6xBGqTBGZL/IRmMoY6awWWsQhOCZgXsjyRzjdfsItdYd3Wd6C4q1GVpl3dfVktu11RBdQt29wqWYHZ1V0u+mGW/OFQB6rE4A0ysYAqmQGc7tdgO0Y3JhIwzknhek1e5lyV0lUBqLAHvgILHkviG1Zpi42l3AWO9zWql9Ra8ln47gV3XJIESjpoU7n/BkmkeqW7VZwgyGQp2BDw0pQyG4DuQpgzkJ7lE4RipshVkQZVroRZsqBdBGBV7oRdQEYdwqBZUIVe0sari4AlwT9DmEgkPLQ46JBZCofbAARy6QRq6goebWUVUxHKaIRhaYQiY4wPGyEXpEEgmVOsqMi8o1CE9Uw9nd5x5/xdUr7gMtGQNX5aLqbgLsngN1xCLs5hls/gMtMSLQAONl2AJpiBUTzVEP+xTM3QO7nY81qjG7FUtk3Z7x0slqISP7Tag/rYQ7uDU/mBY3SQ2kNUWfGFqdYNJX0EYES4SBHgl5gAI5MAjmGZpHqmRHlgtkqYsh1UhOgFUqLLzUrmhWJkXWxkXcGEXeIEXZjkYhJoXepGVk5IXZRkVawEVt4oUDAEmssAJUoAEaCBaCMGChmEYTHgbNQiFCSEbnMEYLjbvwkWikCEYcGEnNCEjuSAKZnWL1sgv8OJI5q9kP5NCdY1Do3icR7WLPfV2MzRUt+BlNTUM6OAkKcNDFdtDF/8mCrRAsrmAspkAB2wgB3JACG4AB4BgLdbiBkL7O6TDXrrnO067gW/gB4IgtFd7CCY7Cl6bsrkAeIIAB0JbtUf7BoaAtXdmBdTiBhBQD3qM7ubNFVLhRzvhpO6ADEAAae4AClagAW7gAwygAXxADtoHuICrmjCBKCPwWGmDFsZblctbFl7hFezOFsZ7AmdhvLcWFVLBFmzhFlnBFezOGHjzp3GhmaQGgFSFbVDCEqqACuCAD4QJ5AghCYwgDhAhWgZtDIIpC+JAcYcZEXgBGIjMclomG6jBKj4lW0FFEegAVOOaduKYECdUibfOL7QOwzDMZaO4Qmf3nTv1dstg8Mz/wLB7t/0WxkNvlmHC+J65QAtm+wzgegmUgAuUIGOCQLJfW7K1IAiCILIjWwiCYLWDgLdVm7e1ILZ5+weGAAiCQAiA4LZtwAY+wGc64AMEyVHe3M0dxVIcpc2vg5Hg503mzfGWBgV/i8sUIhHu4zVGgRXs+75fYbzHGxYWndFhYb4XXYfu+74bfdFtkdFtIRcyPReAwazzLjfymxeRgRPIYAtUgw72AA1iAAnYgAl6oAmawAg8xLwQzW8i/BPGAAlAKIQMh6rNayYEwYctJ0/OhRhuOVvjK4M5QW64oMYxtNYy1fxYV8VdvGTFeQ+n+GU15lNvfPDWUAm4uJ1PElRd/1VLgtwM7rkLzkAl5WYS06jGAuUl2GDZ7CBQuoALpEAKuAANogDfo+CybUAIbKCzqZy1f+AGmMOaO6BSFv4ADsAADKDhHx7iHf7hG8A71OcPBuxp6ZvRb2EFa2O8VxCpe3EF7+7RKb3SGd3Sb7HRM/0XfuFilUHmlfRIoUEarMEarkEbvoEb/DEbumGs8xupQQEHcOAt+UAM4CAOaGAGssCDZmAbk0CYGJzCO44PJCEODCdxGYRBNGgm4iAO8MRFokGtg6EWmKv3+CZUDEHYoiAKAhqgMhTaHVJ1c43a44/a26D9rF1T/7p2ORXHcXwNtZh321BjdBd5TbWw1UBFmf8N/15ijgvkDcKInrwECNBACYDHBm4ACGygBfqIzRMeAthczTPAzdu8zbWjA4LmO36gDFgakGODZGiDlVfQ4zEcGHJf94HBF3ZhF3RBF3LBFzi3c7N20TUd+XPh5Zcf5r3CkJ+hGqohh3P4Gq7hG8ahrsJhHOzKm/rRG7gB/MNBwbyhG7CBGXJhhnAhGDzBBUwAq2nACWZgBpKgCJ6ABozg/in8CfSmQbKAEEIBIASNiRMnSRInBLMkyTJmTKAxWeJEa0asVixSoECp4oSR0qZGjT6ysYOmy5YtalKaQcNSzZo2MNuEmUkTZs2ZMN3ElBlmZ0+bYILSDBrUjNEySMv/dFna5YpTp0vMQIFycsvUIyanUhXyA8ePKEu3CIEiBMgPH2ih5DBhggULEytWQOgAAUKGunghNIDwYcUHvCvIzLmT50+iSJ06jSJF6tQqWbVw9RJGTJgwY8cyLztmrLPnYsKAif4FrJjpX6hT+0rNGnUxZbCZPZMGrVo1bd6+rdtt757ve/h8t2O37ptxb9zCtcP3bvk9duGiS4/uLRw3bt2e/bJlLFgwTz1mbJgRxwjBIkWeBKJhJEn6J0+MKMzyRFCcN28GxgnUJ07DSQ4JEhEicQSzyiieeJIJKJlswpglkxxCyCSTDMLGGVwooUYUKaV0BktpeOHTUDSFAcZP/zuNuJNQNvVUIk1rmNGhSmYs9RRUR7SwQg5HHMEDDzXkUENcffXlV1xDftDAkkzypReTBuyF1wc+kCHHHYdhokknpKyySiuQBUMMMccgs8wyzaSp5prNnOnmm7AlY1oydNL5i2nFJAPbnszIBo001lizzTbe8HbPOr8lik8+jObDj6OO8iOpP5Lyow9x69SzTjjoOEopPviwc89w6KAznTfedAMNMLn4EgwumtyAxAgojPAECU8QQsMMRdBQBK+9LkTQDAQuhEQf+jlEYCCIEJJQQ2NoouCCk2RiiSekZMKHHYd8MgkhYojxBRpSaIHDh2igy0aIL85EFInt+pQiUf9t6FRvTG7oFIZRMppRhlVUQXHEDjnsQDAUOvpFF19/1SXlXk06DAEIP5CRx2GROHJJYp2cwsorH9cymWXCHLMZZpuZ/ObKZzKzjMt9xizzzM9AY/Nt2mzDTc7V7eZbb8CBKjSojFZqtKSQGk3pP/z84/Q//jj9qT31VL1bpIyCag+mu0W3jjfgYFOMLqDh0okWUThxwggTGLGrDCnsOkMWTsyQBHvIOjGCEYL04QR/WQQe0SaEQNTffnE8McYmEDaYibeZZHJII3x88okgg3zBBRtccAEEF+ie0UW6Lu1r1BqovxtGjKi37vrrrdfxUh1urAGGGbdf0RQUPORwEhT/P9wwZA1J/vWB8XX1RfzyNUAhRxl5FJIIJJdIS4opjsmCi3eUVYZyZmkuY8zJZzpzZp175ol+nHvG5kzNNltzDTbYZVpPoooKffT+Tztd6dP+CKAA+yep/vVPgAh8FD6qZrVFIS0fQsOfPSb4DWWQRhi8OEUl0MAEF1BgAhOgmxFOAANE9CEFdBMQQQTiBEE4Kwuq+AS0CEEIhBAiIoHwDyICEZFPbOIToNiEKkzxQ1N4axNE3AQVXnCDJuLABjjAwQ1a0MQb+KAGV2yiD37ARRa0wC1UbOIKauCWMQ4JBGgEwRlXgMbjubFheFmSw/ZivOWhxWJ/cEQkMNEJUYxi/xQeW8UrXkELWtTiFpHBBS54oUhF3mIXuNiFJCVpC1vkIhe6yKQuLsnJXLQmNa+JjZ9qow2eVScc41gHO1YZtKENTR+wjEc8hKYPBELNgAiMmtRyiUB6+PKAAvSlPnDpD32gwxuDGpQ3xqEPfvgyHuhox6bCgRxv3MMe0CgGMITRi1P44RB8gMEMjJACI4zhDX2Y0CQuN4xJwIEgNBzDDFpIkFiEoiF9QxZBBhKIQEyIEH3og+Ust4lQ+HATPzwoSJBgAy7e4Ik4yEEOwmjF5TWReStgQUaZR7y4mFGNHEUSWrYIBTKUwaR3MEwi9HiJjflxMadAxSpcMUhazOIWOP/FaSUruclKwgIWO93pTy3ZyaJe0jWm4RMzblaNa+SMG6ia5m5WKap2yBKWWIUHPK7aTGfSA6tYdRpWK8XLsgaQHrn0JVrLCsxgDhOY/GhHOJKJqnDEgx/+eCY8zCEdVN1jG8oohjGIcQo5NIE8Y6CBExb7BkTEYhKCmEQW+qCKZkziC3G4YRwEt1hB8AGfghDEDseQzhwSYod9EARCBxoKhLp2Ej/cxCCYEISz/CAIQAgCWqpoxSti0bcd5SgWh0CG4l4pDxdzxCMisbE+wtQxgrSpTRO5SFrkFJE4dQUtgkpUo/70u+A9qieRyiebQaOUOqvrONZbDnSwAx7toEf/Ot7xDq1u9R3yoK881CqP/YEVlkb76n+76t+wGvDACE4wANXqywC+FYABhAc1kVlXeDTtrPRNx4Rzo4xkHIMYrTDDB04QkYgkYZwNQYQTzDmDN1BhnX1gSDo328IxLJYPMkbEJkh7WkRIQhJx6EOzfGjQgcYWoaYwxSTYoAUtTKW4Jh3CEKCgheKWQQ7H/YNKGcHcLfmxMY4BE2RqQd1F9uLMvGDkI3eRyVxU8pJE1SQnN4lJXbRmvOTVkzL6ZDNAoReq6uWUKldpjkIXOh2Ifoc6Fi0PdchjHvNQxzvmQY95PBrSjw6mPOwbjwFLCpZfDbU+BOw/phlYwQaEJaoP/xzMBhezf7WMmj/aUarptGOYrdYwNbXBjGScSRZ+aEETYJAEt8nTbyt2QuCQIOMv8IEPhAitfQaCiCwIIj8ECcQPAyGJ9cwgV6GlYRERCtvXTmKIiBhEIRbB0ur18cunEHMivSMmYtSbTJwxBsn2jcHQiCbNvFiNLlaTmqOyphig1LPMblZKqOpmN4gC2m/sAapHWRyW8HiHO74qNUhjetHnIMc5Fr1oSJODHIZOhzvk4Q6Nq3Xj/wDr01RtwErbfB4IHHUtxbrqtpo1l7tksNDp4Q53nBzl4yhHOcJRjvXGF2p5Ras4UKmN2ERDFoowwQloIDf5xMGHC5nEigcC0P9GNCsihJDEt2iICFOY0D9CRoQgAjGDBCTgArmKNiLW6cNPGHQTsIVta9sejGGICRmIb4aZFo+MNCG+8Y9HfMo2QyfPfCYZd8KTNoFxJ4XDj5Q6e7jPgEP6oUHQlY1KfaMKSMyyqjWvUfe47CEdQEvFgx6ddken9bGP3g8Y1XmltPBdbcueE5PB8shvhhGNaF9aOvnQZ3nRjU4Od6ij5e2ALztKZQ6r7tIf89Awr3/hsmAkAgg94AAJZjDOJ8yABovbzycC4YQxIAIRbzhEKAC6WRMuTu6bEFpwR1rIgggjQAJjQEM0lFp6F1s7dH+BEFp8MAnDEHnhwzIXyCZt0jL/MfMMzvCBnycNg9INuQEOJtgND3c/vxEcrkRWePWCZWU0xtd6P3dLP2dLsnZLCBZrN9hqOqdLB0ZzB1Z0vjR91Hd0SJiEKHdyhpZy6dAOUNgOhfYO8/UO3Udrq5R9d3Vh9NBf4VANfRINy9AJQaADJyABErAr/hQRkVVDC9FDk/AG9acfiNMHCHV/0RYHc9gfgWBQp0UIphVtQsZ/zWJC/cEQWWAHnlALkXcm7QMbK6MZaEIN2YCCJggOVUM1E5Q/wfEzEhc0RbM/OGiDUDdAEHaDCJaDOTiDp8hWNNiD/uNflQIq7NAOSSgOuJiLupiLTHho6eCLVdiETdgcUKhV/7UYD/ulDxk3HLWID1CoD5HCD6GyDt2ADdlADcSQCFHgAhUgARjgfk+QBA5ROIvlN0awWEZgBEjQA29AEH2QQzvkQgroLOkkd/zRB5KwCcwSUA/4Cc4iWghlHwRCEG9AB35gCV1yDNmQDdIggtoAhtbwC752MpoxDd0ADt/AQPbwDeEAcar0jPoQD+wwDshxHYSyDvgAD0IIa0xjarfXNE0jVrhmVms1QKIIgy/4D/2wkzv5ekAYc5U2e85Xk6Y4g6cXhcTBDkuHSus1DsCochvnS/k1XwImS5wmS1a5VVwVkrsnjcuRNe1gKfrgjKQSKuNQKuPgNdaxDdYgDcwADP+sIAqOoAUuQAIkIAL+QQMHITgLMQbyYWN7xx/JEgqh0E8BpYCwlVp90zcmpGOT8BACQgiXo2OCIAnIElkxNgZ8IARpYAd+kAi3wECasg5QBQ7PAAxnghmcQSfSkJGYaA+bsl7o0F7Zh0DwQJKDwg3bEA7soA/yoEu8xDRHQ2BiqWrEV4PCuT/8w5M7CXQ0yGAORg//EGoCRnRGp4tMiHLRwV7l4JHdSVVQSF/iSYUth4zx8A6dhpVcxQ+7F0uyZCn5QA/ZB4Xbhw5pOWGDUkr6mTP7qZ/XUY3SsAy+gAqoMAqaYAgvYAIHmB6+QgMKUX9uI232Fwo6VmICFQsE4hD/6URDodVCheNCooVai+lCgWA5D3EQBNGXTiAGjQAHbPAHtFA1GTkqvFkP4JAN0ZAZlnEMCJcMrTma98CUpcIOuhdzUCNhyJRMynF7pZhLYQWdAqQ0bKWKrIhqD3ZA8IWUq9R023mfXdqUSad0Yqp0V2gOTad0UQiF3FeMWvmeFpcP0NgooJKmy0GWs5mWqKKb29CfD2kbfvqngAqo2IAN0uAMY1OgowAKnmAJaAARHKACXDcGBzE3BYGIzLJPGjpZk5VZfTAJeEh/9tcHfCAQkzUJQIY4oYosPxZkESGpA9E3fOAEfKAIwlAP3QAb4ZAPaVkP2eAM06Bvl2EZolEM/9KgKeGAD0lXKu7VaUbKD9BBKEnKTMZJlDgYdUJXe63GX2ZVpdiKV6O2jL9opsm6Du3VlPYpm+iwDmEKpmParuWAcoXGhOGafVqlhfFAp8vBjMSBltSBKsmUTHxaSrfhp6VkDYEaqIFSDQ3ZkNAwDc+wDMDgCqUwCqIgCpqgCZngB6HFAe+nl0XgNswyN8omA5sVOE4wIaQ1EIh4f5t1YmOgCoiwON8SgQ8RBy5EgJ+1TjYbEZslIIHAB01AA3awCM1QD99gG0wHHd/wDLNADJPhHZPhC5yXDNewG02pdO5VpMLJDhSWpOhQQNYKhAE0fA02dA02VsopltKZrfOQhP9Flw7jIA5xu15dGg5yK7dh2q7mMKRZWIurpKxUxbe12A70dQ6Gu2iKRoVVGK73iSqOu6d9SrD6+acC+5ABO7kG+6fSUA2Deg3XYLANGSii25APq2+3wAqkMAqK0QkJ0ggu4AIn8H5FgALAEjjvB7JjUARJ4CynJamBs7v2CBHiaIei5VmCAAcNsUKbMKqjepkp6x9ZUG1ZAAdw4ARvAAnRAA72AA7e0BuF0g3C0Aqd4AijQG/B8EiroQxVy15DulVvVUzlgEy6iRvsEJNRF0D9c5w3aHtYWa9QWGhKl5a5OB27iItxKw7osLfiUA4LvMB7mw6DG4WFFoX2RZ+0hq//ERy46PCLuDgd1AS5AUu5B+unBis/2pC5JCywtlGwTSW6CVsNLuzCnzsN01CoyoAZwnC6pCAKl+AIncAJlkAJoGAHsDsDKIAC6zcDKTACKYACcUMDhJAET0ADPFQEBfGXmxUHnmpO8hSBb/BDJlS9falahLAJ0WtOBEEQynYQSRAHMiADNCAGe9AL3SCa1MSr0UAKiwAJnvBHtfAqt6ALosEM2mCf4jBf8CAPPOgP7/DBSnpr34e/wplgt1d0WdoOAUy3aQmmXlrABsydZDrB8/qEwmgO5CCe4Xpy0Fdf4Rq4jeu4esqnlLufOHO5B4vCJBwon4vC8vO5nvu5trGw/8I8zMP8DL3GKkDFChNbsT/cCkmmCqTwBR4QBzPAARggArVSK+zHfuVkN10nA06QAnEQC5uAEMj2u4HjYl8QbdQbZH0TZE5AbCW2OPoILX5jAimAQoUwCsuQDRiZkUZLDdEACpCwbprgCJqAC7NwSKWRDMyQHO2FnmvVYBr2uN7ADnAakwb0ae4AD+6AyU23yR48HaCct2N6dE2YDqF8hdlXX82RDhm3jPQahaxswCM9VwBrubV8uSq80wUbsNcAwydsGzEsuiQcujFMzMRsM9HwDE7tDMzQYabBeZcEC6lQCqXACgSKCqfAGKeACxahCmxgAhqABBygfjRwxDNAAv8p8CtLrMRGME5xzdY3BFvKJlnsUWxOMLw9ML0ttCz3NwYn8ASomgWE00/nWGxI8E5OMAgcwQvRQA3WmA0UgQug0AiHMAjXownlWxnH4NDM0JqDhlc4qEBEk3rKSZZZmKaiEhxUZQ9WJZWrrJ4U3IXJ90zxkHH1NaftEJ+Eyw4QvKVNedOwDGiOW5LGfdzKXU2OS4LH3Q3Q/Z/QnSrXId3Q3Q3Vnd3XTT/csJDZMKjgTcNNDdXLICfA4As9BQuukArsnQqo4N5bjQqsMN+vIAutoNCvUAthogp84AEe8AKwq80o4BA0kAIkIDdZkNYzMAaCMAMwkIANvuACZRBuA73/9yipcUA4ApGP8MFPY/AEv7tZ4hwHPZBamwUHmYARxEANx0ARzqwKlGAIh2AJpqAKnsAJq9ALZGIMvuYM0MANqoQPF+ZgIcmMQnOv8JWlrgQqYzmnzhg0vsGCtzdgSz4qn2aVf3unfZXTPI1e/6ozuglV2J3dYK6ngObcyz3dxvENqXLdbu7meroN9JMN3ADe4V3DTe2ByyDVwJBJtvBd7O0KrADfqIDV8U2grCDo873orPAYYNIKtJDfrVALqnAIOmACLkAFLvACtEIDLkA3vrLWVEwI7gfH7JcF/wjOeug2NCAggdNPDJFt+5FDc3dDwhII8cEQBzEG++cEDtrG/6qVEa3QCyLTC8EACpZwCIZACZYACpSwCKBQCaAwGSbTJ8rw4+yAD2/VD/4wffoKhTDt0v2b5FulyFzZTEJ+euoup669Sh65G4/7r7Q8wgOrwvoJwvv55QD75dhBgmMu3agS3brJ3djR3dYI3d793dhAww5L3je8eZv0U64w8YueCoPe3owu3/N96ATqJR7fCiDv8Y0OJvXNCrPwGLHQCOvoAjLQA07gAuPRxDykxEVQARzgNm1sBDIQu+xxjiU7TvS3xvMkH3snEB7uEHS3EGmnskZQOEnwEInNNy40CaCwGJFheM1exqZwCItgCHxcCJUgJi3zDLBRDeUwalBDdP8nVw5/C9yEG9MuDQ8Q3Bxb+EBZM6dbumElmZ89Te9EDcMwbA2l5FT9Cfh/Csx/GijasMv8eQ3XgQ2L77nWYOeUX/nzgw3WMA3Q4NTGXN7GoE3oLVTfpeiJPvGmf/qLTvEZn/FcLd8e//qvD/KuIGaz0Aqr4BikYAie8AkHQQgucAEkUBAowAFFABEOSgIjoOBZoPObpfPvt1i+LtfvNwPAzzeQVWwQwR/wdB4pukMlBh+EHcVPsEMT4iCjoArQ/BGEwAeI0AiKqAqW0AiKyhHBEA3mVRtMh1Zo1bYTfMHhCdwAwc4cu3bs0K1Dh25cOG8NG3Lbpk2ixGoVLV6spu3/WjVrFjt+5Gjto8iQ165N1MbRY0VrJl1iw7YNZkts11peq2lTJEyd0nxCexbUGTNlypIVAwbsl65cuWDBSuVK6lSqU1mhQmWV1dWtq1a1Ahv21SuprVh5RYv2VFq0rdiGrVWr1atVp1Q1yoDESZZARjRc4EDDSJEUM2YUJoyCRhHDM2T0MZIliwwjTpxUpjHDiOHMM5Ik2dunT5Y+gUgTojEmzpM4SbK0zpIkjpHPiOLEHhNIEqJJnDhZytSIj2RBhBo1ChbLT6ZYg9yQwRSt27dwCAnm4xfPn7x26QgmdOgQoraIKStCw3g+vU+MJNOHdM9SpE6RLTWiTOkSJ8yZ/yax7eypGp+kAWqoopI5CqlffGnKqaeeSiUVqCKkMCqpsMLqKgw3zHDDr9g6JcS0wlKLLRNNBGsVXFaZBSxV8PhCgxE2MIyEJEbgYAQUUkABBcM2ICEFHAszTIYZaHBtDCfGeO0yI490zTUjBPlkkj72ikM12CRTcgzasuyDECNoyGLJyDYJ5ZNQYmlkCjaacIKGOD4RxBRTJuFjED4IEWOKPfJAJZtuBpUpImu0gSZRRRdltFFGB7RoQEnZq0gaASfFNFOfrBmwo/daIonTARMVyhmjEEzGqGJW/aXVBh18MNZYKZSqQlS20pBDVEIspVcMee01RGGHrWvYtUw89v/EEb16pUW78MjggRFIqIAEFEbwbIQxJtDWMB9TyGzHwoyUoUwnJhFEkNySYPKyJMZMwYg3skCkBycE2Yy0MVzLYow+bpuTkD4mISQOSfZ9l5A0CeaDCiZ6iGzKTSbZBBE7ROsDiSYoMUUWY5ZxppgEUy2qZJNNZiZllYdyxpmgnklUU5lnJpBmTKeZ5iegnmmZKARXVXBBpnLRxZdWgQE6aAZfbcqWB52W1RUJpcIVV12xOqVXrbcmpWtSsvbaa2OF9WpsEZX9KsVZXmnFFErO0IACDKitYILAkjiSMRpoSKEIxo5MgQTPjIgsBRhoIGSSGZYkhBBEsiDcSBjufYP/EHWNiONe2zKnIczSDEYkzCwECSXLeyf5JHRC4OCD4OLGKO4Q0RpPl49DQGmll2NAXqZ3lZlpOfjfe245qJ1hhobAmG3elCb+noceJpynnyaaAlMuyhhjVlXK6KV1GRp88Yv2pXyjgTkKVaSS8gX88sW3Jf5dhm46fvtpwR//+B8cq//+waKa1W5FIrQVkERVo0UtEliLV9RCFnHpRSWEwIYscIABEuAAByYwA2qRgAOSmQEHCEeDEXRmb4FIQgoIkYUTwGA2KbDMayYWpywhCWKJCwUi/CUZyfArTIGIQ5ZAoxp/OQEOguBDEN8wBjHAARECg10cWteHMewrMm9o/4QqatGLjzWjd8tgBhiBt7LgOSMaL0NjGtWIvORJI2fUgyP1ohGNMqbsZ+tbUPmYRjTxNWV84NtFIOc3PvOVLynFMAaCticM9pHPF4H8I1PsN8n45U9/tIAFWfw3l7CYpWq4WsVZ3GJAtIUFV664xVhoMYsWtUIWsVjEGXSAgjhUQAIiwIAEOCikFHCgMOA6zGGw5SXPzEYGXsoCDGBgBBhkoWC3SQIhNhGIeyGBEKqoWA4vI5nI3OZfqnlNEvoQCkJUcQxvUNe8lgjO2RjBX3zYxGiMUJg4fIESqmgFLoSxO1SdrIxD+R3wisez4KHxjDxbY8/CmAztLRIY5dsFJf/39zSJVtQWkQTkLnghSEHywqO8SEpStLcM7THyfeYT5B8bVFFLVpIWmuxfVVzRFa6E0qZnQUvVZsqKnfK0p16RqStYmTav1GIRNXDBDDBgSxJgAAMpiINmnvDLGZyABDBIHQ1QUBknxCEFkHONDFJgpHmeIIeRIY0qxLQkik2CiEqaAcL2lqQnuNMJoQgFZGKDun45gQ9VzMLiBLGJKvLBsILQ6hMEcQhSgIUXxOBnUZahDDBO9mSS7Z0zmvHPZoTxiw0VRmjZ90jwTfKStrhk/u5n0YpiVBeD5GhsPxpaXnBvpCRd30NRmtLXDlKSLKWFSzXpirEEsCtewUoBQ8n/lU82F6fNpYUsXFmXVqhCESuwARJmgIKl9oEGE5gACUjgt8AFlgMbOMHgtsvNy4xVBpNIgmBmkMwTxOYylXmNIPqAiHOZYhPOhFxkBDMGwSShCDSQQRwIYRl7IeJgTthE5sbwhBk8YQyTwJMgGuFWcAbiEI0wxVz0uc+GltgYx0DxMUxsjNAycrSljZ8q8Vdc4vbPki99xY11nL9b9JjHPQbyLeZni1wQ2Y/ui2QgZ9tiYZz4YwxlaIm5F1KUopQpQQbyjnHsihQpNy3J8kpzb3Wr5ipLLl4xhSpMYQgbmKAHNMAAB1SgAtNc4AIoIIEK8ExL7irGRz3CAN/iRRkZ/8hAh5JzZ1znaxoZJMGaRkACEqi0CSQQrkx6CfBmirAvJyACETBAxGA34Ti3clM2pNnEJzbRCNGoOhCbOAQnXCnk0CKjpEwWxkd5cQvUzpgqTzGuTueyClcQm5Nso0uNaSwVG884x6fFco9tcQtdGPnI7Wuf+9qnUV6E1sQp9qIvEPlFRYKWylbORY8DeQstO3sso1TW2cx2Cucy95Or8FDapKsKNReiAyZ4QRaK4EEVSOIEF+jBtHBkrcJcgEdPXcyR+nAYxsyz0XhTkiBuE6d77WV0jyMEDGDnhB5IKQs0EEQyw1QxJS3pM4N1TXEgF5vUFMEIgYiFWkUTCESgKf8Ug8jEA3HR7WDkuhcbxUXSa9FjVs7Y3f4jS0/rPXWdTuUVp6SKKseSSVhEm9eUrDbRSMvtXZSvyQ1Vcdp3F7JkfHEZqNLelB/q0XUDeaPsxt8sbrxJAh63gMlFW7JQAaK3VFcVpPBDBjKALSCpoAQYGMEITMAH7aZgzpFHgS95lAIacTAJgovDaMT6rj7EIg4ycEK8gpgEK8FuE6x3QhLUlQVJUDMLSKgixfqgilAsSUl64YMOIyMbJxQhvrR5zSQytyREAHETSOwCKbbY4mPw4ui9wH7ScQFkvefvfzEttlfcwlOukLn8udLQVq6Goa0QV1awmCSQJ/lHsn+07Ej/W/FIj9IyOr49kdsDGpOCKEgan7q7he6zJP/hsmKrGhMRM/OzGvLTFb9LC34zBVIABTZwAAd4gAvYgAmQAAnAAPDSgB4Yg09QhTiBsyCZAdPYrgMbgxR4gvh6F9nYjMVRHMIxjMiYgdnQIWVquX6ZvdQADXrxl3hygrj6BCMol9KQhNjYtDiRjCzxEteYBESAg9eQpyZgA1AYBmRAsWXYJ2IILWIIhmDQvqXDO1aShTZ0QzfsH1novmdzOhyjwzm8w1XqPgSUKF4LMlzwrUB8LV3zKEMKqdHyBaQBhmXAGWf4hVz4BViAlfd7vwqhEPZbP1QoBU3cmk70xE/cRAp5/5Ais4VdeIVeOMNagAQ8sAMmQIIeeAEX8AAK8AAP4IAT2IAPBIwLUDi+2LMNwIDt4i/A8ZEZKAIUUAEOGgHCGIEUcMYjORIj6IGSMwxBcAIYIIRP6IMm6AE4YJ3L2AskWCYg4gsyiQMEoyLZEJMkeIInoAHTEJjYG4wTVAU48Jc+8BvLYANSCAZigKxcCy3sQ0Pt2z4gi4tZeEM3REiF3LFmQUBLmsMZY6WJnEhKKjJdwLJdwIXeeq2OLDtCLEREfJ9cQJpWYYZpyIZpUIpWeUSm+bqmqERLjJBcAUWtGYWa1JoKeQpILAZlSBlr4IlsSMndQQZigAQb8IALoEUYkP9FCtAAE2hGSbiRyIuzrpqBCYim84K8EcCAHhGcXkKBgesRFRCSvTGMHLkNcnQCKtqMzEg5/uoBx4GDJnoiF1im1kiCngOXd7HKK6ENJqmwScgCPoCDSgusQFAFgiEnQkAhGnACJkgDR+jH6ju6XeiFpBMGgkzDWzhIimTDhITI6JJDLfNMvStNVrK2I0sy89G2QnLN13RNRSyGaPiGbMAGU0EKcXufohmkiZooWNgpq8AQnOzECJFEniwKZkiea9iGhviGdYDOdbiH6byHeqgHblCGYmgGYtCEFTABE6CAOzOczTgvDmjBFIq8EbgAY4yzE5gnrpyADUg9Hsm8uYn/PGg8xh3BFl86DE9bnFBQhTHQDHuRRThoAlMYBjtgg08whTfIDDKhATQJrDhABLyZLz5wAirAnPg6sMFsIoCh0DHwtDCJxyx5gzRYhFYghl7QKOxzUc3EhbhYOjU8wIlMSDn0zDZstrzTw4ncsSCLnwbxSAIMJNg00kQ8RCorBnF7O2AwBlgwhqGIhmQ4RNd0rSKjRFlpkFbpSZ9MlJPYBm6YDnAgU+ush3WwToTwDnQoh3JAB3bIB3y4h3XYBmhAkGYgBR9YAR3wgAnQAA/yIBS4gBM4AQy4gMzwIA6wMzuDPBJoxhnZAB0hAUS9AGspAg5QjGNUKsGZgWbkgE4L/yxBeJzKeIMl6YE36IFQQIZGYANCsB1j/IwTHNX4MoyCkb1PaJ0xIATj2wQ+EIMnclUkogImUbAnQgQk4YNG+AI9IAVZwL5b6IWA9CiCrAWCDLJZOEgZPc1tbbp2i7/XirZ1iy2NKrtCSopfUIpz8wWPStIlBQY6KgVMsAXicoVS2Cdh0IVDRNdzZcl+XZXkdIZEqQht4AZvgM45tQd8UNiFXdg4XViCIIh40Ad9iId2gAd2wFh2gAd4yIc4pVORiAZk+IMaEII3OIEJYIBEddSuJAzOY4AN0iBGzaCvTFkOqIDPExzCEa8U6hvVCwQYoM8d6cExsRyN6YEmaIRPsP8DHdCBN6gSKngDNpiEMTG+LokqMtGM2OiD5PiCf3mce+SD1OmDN+CDz8CY0JkYvImDXoUDL6gEWQiGLTo6Y5hWGFW6IJPRuDhAHjtNO5SxlmKtcN0FIeM2+ytEQzQfRAQGF0Ma7knEtxO3ZlAxWnAFW2ifpCGZlIEZS9GGbgAHM6XO6cQH7OCH0jVdfujY1O3Y02Vd0/WH1+UHg1CIcGAIb2AIioAGZsiFUdgDHDABF5iAunFUDsCbERSvDeCAOBDUZpwADKCRDeDFC3Deavm8wCgwwwAXbGHMOCghrVKMIDlHw1CmJmgCHRCDHviCQXAYOzkEVXvQJcmCURMMzBn/jSxQhWZo0CxMAiAKoi9onVDggzcgHAV7g3j6l755jTLpASBQBFUIBhc9uo+y27yV0SBrN7+lsR4FXIsMMo7qrUJSMkI8UiRN0sY1hqRAlUdMhmfglGvoBtsdB3ZY2NBlWNU9Xdg13dRlWDm9hx2+h4RIiIWgXYYIU24wYogQU274j2d4UlG4BEoQgg74iwpgAM3bLhSAXg7AgBOIA1+KKrvhrmbMxRHApQ3YkUmVExQihCSgkdDxkas9nCB5AtSQk8Tpgx443xfogwBWtU+wHEQwxsggsHDCm8EijVgwBT8Qg38JhNRhErLNOT5IR0IYBkT4q0mIExhijbr6AiHY/wPpg2AJhlEKruAs0zJ63Ts93GD7WU3YzKNHKh+WjGWWPCSRSYaUURSgZM5uwIadqYZr+IZ6sIceHt3SfV1/KN3UZV1kPubX7dgdtgd7iM51+Ibw8IZvwGZrtuYX/oZB8WbbxIZl8IVSiIRIKIQ90INZZAAGSAAOEBxr4RYaERIz9iXxct5r2QBJIIRJXSqz/ARJCKEUSIL/IoGem4H9whcS2jTCoY2e+4Rh8NVCuxdBUAXIeAMdOrDFYOgC+0vZ+IIvaAQ4cAJCkIQgckck2IQ76QNBcA1ECAVvpBLB7CrJqF+/8gN+NENh8EcyxLXQemBU7KSZypBcwZCeqopji/86q8sf+AvS1NwjSOTSf1UG5JEGnJiOdRiHGLZYeqCHiXVYHh5dG27d053YstaHrtYHfICHdDAHcRiHa8bmbH5hb/DmbT5ib8brboAIvDZi6YkGY9AFV3DiRYAESDgEJNCAD5yAE1BPQn0ABrCqFLiACUiBe0a+PnDGJxQcOQGXCjACSSiCyKsvI9CRJNSM06alQNiq+RoDGJiBWEAEXoSBStubShuTxdgbwSgTKcGMvSC5lDOCdnyCk3O00SGdCAOTHkAC1onHCSuCQKAi0WADQ8DpM3zggBSGaOWFas0+sIA6WhCgDlk/XImKLIW/4/TXzN3caghTh4BOaV6HaH7/7x4m3Wamh9elh2QmXYqNh41tB3Mwh3IQ4iEe4odoTm0W07welGpWcGzG625W8EE5YjG1zWlwhhPWRFKIhErwhOBgA/CM1BHw04MDDBIAksTWYjOegazCxacSr86pgGZ08QuQjA6UARhIIT87ATIBoczYjBYqkwRooRlIqs1IgsOpwdiIEtnDr33RjCb4gi+JjeGeAXspE9sAos8wl4HWVUHQjNzoi37hA0oA5QfGhTPUpx6jVgdim7mQKaJeP5kcRS5NFeVED/JoiHBIiIxtB4UliHYA9Ikda9RlB3vI2IxtU9oND0Uv4m0IU0dv9CKecCP2hiOGdEl3dIl4dEef/3AJn/RBEcpQF5RuAOdpeAZmMAZfsIUM9wRPODxSsAMTcEYSOAEZuQAN0K4JCG4NmABAKwy8Mc9K5TwzbipnHEEaWE9lnAGg3QAaaCEeGYMicM99poFJFeh5OoxiHCJojNV3aUvXWGPdzoImIBz/fALoTsd7uQ3IKVYsHKwLGw0CWw0LiwMkGgRS0KJekNGkO8BbwIWFdCBWkrbfzFKxQ9fMRY9DWfC4hs5xKAeCuAdAfwd2SAeLhYd4wHhAb4eJB3C3zmoCr11tFo9Jh4hLl3RLJw+Tz/SJ0I+TYHlNlwnoIfXowZkz6hn/QwpeqDb4o9yzCBFTyDlKgEoNYAAjIP8EDWjKVGOAhuv1DahixGmq7ZqWGJ+BXMQAzHFeEtig0HZUEU/gjF4SxMEbm8MvvnEmxwyizOC5CcuCGeRL1fC001ESviBHyfCrMvmhtu+5iVmw+p052WDHKsqcBd0ETiCFWIjbav33vE06gec19/mFLk3ORJGIgp3v6BxmOdV8hj306BxwAveGlZ+I8lB5R/f0Ca90I+brCT95Ti/5kscPbXgenYj5mhCVnQGoAznh9oEVqUkFrPCVXTEWZGsFYeE3T7ABKY7PIiCEFPgLCkgvDpoAD5zsycaAMVDPQd2AuqnsDUgBBhgYa8HFFQ8E52UMX/psRJgnJfeMdzwm1Tj/k/htbeKzjRlkDWhikv3KnNnLkiDatNEACD6TvowJJKjgJ0ljshjJQihOHCdZIiJiuDDLQUFiqtCxpCpWsFqxRrYquaoVLmHCiiWLlg0cuHv4ZMrEZzMfvnw6cdrs2ZPdunHhhobzpu3o0W1KkS5FmlRpU21QlXKrarVqt27ctGLdmpXr1qvctmHTSvbaNWvS1kJ75oyZMmXJkhUD9utXLlh6U/HlW+ovYMCjBgf+e+owqcOnWr1i1WrVqVWmPB1yMUJDihkVUnDWcOHCZhoYNlzAUHrCBNMXSExgsGFDCgwpnIwYQSLzjBQnkgiKTWIDCtmEEKVAMaJPqBm7BQma/+jEiJExDaHLQETIyJMnRRpmkf6chhNBTvjAiZMlSZI4hMbwaTJJ1cHhT7JM6hMxSx+HhJ6MqYgEDkNZODGGE+N98QUfm2wCCieWHKKIIYoo4ggovRxzTDLMYFPPPR16+OE97djDDonrrOMNikWh6E1V21SFYjdTUXVVVmONNaNVLoo1lVg97ogNNmilJU1bzzBzpFzF1HWXL7k4qReUe/WVCiqolFJllVcGNtgopXD55V+kiAnYKa9EBtkplWTggQcvmNeabEbQABoGFVSAwW+mTXABA3tygBoDI6TAgAYokJAEDBzMMAMKM+AZGwYqbFDBBjQUkUVtmW1CgwyEhP+CCCJ9CCLDC58Q0oMgkzQhECGBPJTFRIgIQsMMRiAySUQEnodRIE3AwQcfh4CaRBaXxtHfGJ+EEsgniBB7bBJ9GCERQ0k8hwSwg7xhyCCH2CHIIHjgcYcioyzjzDPQWOONid98s6I3XMmYo45YfVXjVvGi6K67+vbrzTdewesNVfeCZRWQQVpjTTXQONwWknMpaReTTloMpS2wZBxllK64wgqVqLCCJZaFmSwml6R4mfJgrDimWCU4sGCCByTMQEIFDMwwAgZ1bsBaaRxsMMEIFYBWGgN4GjE0aJj1MQMHGEyQQm00cIDCBDQgcjMGRThxAtUopIBfHMN8sskkmxD/4sEnsfRg60BiDDLJJ801dBAMRiTxEEQLSTfGGG90xwdzAs6QBXioxtKHgoKY6kQg5rkah32AA75JIGNQLgghnfcx3CDdVmKuM6VDIw3DQl6DDVTXSMUj61ABSdbsrCd147z3WmVwVmcNuRaRbb11JFxyxXW8MkrWtXxdwADjy11M+jK9Lr7ssosuudhiyy3b00ILLB5/PLJiqJxi5cpfqs/lK7PI8v4rt9zSCy69yBILJBk4YMIMnmlAAgdAMzQ7TaACBSzgnexUgT9VAGdCqxNrUlCEESiqCD37WQo4kAIYzCAORaCBzQhBA7GhYAOEiIWnTGGJWKgiGH1wgYCM/yCGQ/DBDptgjhi+UKDvpAciccgcfvpQoD68gRCTQFYSaEAD9YgBDoiAwxsQsQlQEeKGcRBERfqQBM39UBKdw0irsCiIK37uEIUghTAyxIy3oCtdDgMe6lYXpIQlLBt2pCMeaYdHbNxRYcBzmFuId7y5SEx5hlQeIecSF0Iyz3mOfB70IGk97Omikt3rHi289wrxuUxkJCtZYMSUmFOIkhSyaMUpUfmKV9SvFrWwBAQscAEUXECDGpja0A7YQAOixk4ArFPPbhO1rBHiTjSIzQQaBcAUHJNWeoOBC4rwM1qRgARKPJS1qGAHHQzCFGNwQQedgAg+NIINkxDEGwoEnf+GxKFuX/wh4AQkxikiIhTmQc8WndC2PiAiFuKJnHTg+YQ4DHRXcZDEJhhXN0lIIhANjYN1GmGKXhgjGcpYxjKOVLo2PqOj6DqdNKYhUtRZY48JS8vCiOTR4SXykC59KfOUZ4yZsqSidMGoMxg5sUfy9HnX++lP5XeLWdBCft/73iqTusmlsmIVTn0qmhRzplW875QnaYUra7EID1iAAqnZwGhuCRuc8RKAdsIAAxWoqBSQAE+KegLO6rTAqIHQmjMIRBGSUM2djeBmJBCbEYqwqBnkrQkmaIIOZmCpSViHEOjE1hj6sBBq3YqfBulbHJLgKj4gwhR8eEMfTDWDJED/RxCmUMU4j8hOWEVHPYAzj+YQyk9QucqLreInIRqhiloIY6bHwOi5Nirc4QqXeEfCqDEM2VNJ+gIYwnCk8oAB05lSt7rWTYYx5LKMZJxrjdzFLnaV67zpAYMXk7yeUIVqi+8J9ahKPepRSyLfpx4GqpC56ilVoQpTjKQSH8gABQL1Gg7QQAMaUJQRRtAn1PAMT221U9I48IQUoGYGT5gAB+ykgpxlkAQqsJlmYsOo4oy1hMFBQV5pUCwnzMAEMoABCsZQhNBi6xNjIBascizZArl2IrMtSEQ4x5BPqEI6KgbcEgmEiBtPBHBbTNZ6FqKeG46hc61qLHOGcwhKqEIW/8G4EHDBjKHqjtcX2XPS9vQC3/TKr5Ju3gUveuFclTxXJclVkk1fit0749m32zVu6ZhRUWdsd7vULUadnccLXuiCkpXcHqQhfdTweWyTrlCqK+Rrksc8tZNNdepi9msKManiEB3wgAkokAKjYWAEDBnBBPTGGg7Yhmp3uhoHWNMzDDBggROIq2zsFBycFVAFhtp1cKbJ1iIIFmrMpIEKVECDvMWhg0ZY1Bhm8Bwn9CE/gpCsrgTUHcv9sNsFgtXTaAAdFavYCdZKz0M0hx4jBCIQE8mslIcDEc4Nx1VabkQjBOGJkdSifvSrX5o5NqVUuILhLmPFpVdJC8ZI/Khv3v8FLn7ai0U777nQNSRdWNLS6nKXGRaNi3G5u925JJemiS6zm7N35oRvTHycrNLIPD2yT1KJ4a5AKio1sYhycgEJOvDAAx4QYKKhVTZPm8AMNkAo1JCGA1G7DVoxPNepOepODgZcpM5aJ6j1TIGHulkR9gPiv6JA2upuVBJTkIStzUCInziivUnLm/EATjx9sHeTbwytdcvpbwQSRHQakoRLGaFy3AE3RECFWyqOs1uHGIRuY1GLihPV5jZPBcge7jG9eOzhrFglUeG7vVzIPObTa+4jf/FxmPa5GDZlpEWT8YxpPCMZ0m3eThX9ejOfGc0JJ334Fi6+SOcCeixZY7r/RGrH6U8jGsSQAwQgcIAFJEDpD2DA0rNmGw6cZ2cMpvosoQa1XuY6178eQ1zbWkAaPGGYErC6CNBqdQ5IAAU0+HVfwcAJ0MoJzEC0URMNkJYR/McnvIHgZIF1GEFEkFaVNUeyIMJ4mIcTHItDqMImyICKMcRApcdCQAeOSQRpcc6xSATgBAI/JRQWDUdjIULoABzAkQJjQAktjJ7NhZ7ywQJfIF+lVVwmRRrzOYmbDR95yZ7zxZRLzRTusYSSuMQ00IXvyR7FMEn2TM/F6EVewILFOElziRz0iRQf2RFMpCE41AMbpmE3TB81TIMwiMIffEADPIACHIACXIACJAAD/yRAHx7TCGxAEm2ABozAZwgK1dgMBmjGrcmG/mGAB93G4s3A/DUiCqiVCERNBdzfb7SV1cGANdEAbFxN3aVAtuXNG+gA2qSTEEWOgPDGJ0iWacWC4IyRtbibrcCHRGRWdNzYu01LIGxCRIRHFpyNeiyZfgwHIXwOYyGCF0nCOYEKInxCI5QLGObCLyxJ9HSj7EXPkiycp+GczXEMpIUhEjbf8yyXdP1e8/RUyBVDc/nCNGRDFRaDN+bjNiqJRR3JM6AOH3UDTLAhQRZkG8KEu9wLkFyDUmSFHfHeMvgCLZCCJpQB0ilA0kCNAjzABdySaTjK/3TkCfDJLL0GrP2azf9YHQloTobJxs2M1oQBUK5lBp5s2CaKQP7FWByQAGacAIw1yrUpFnjMQELBwCSwEBuAQjpNBOccWdqgE2flR6gEyAoKiHl0ByIEgoodBD5hESJARHeEh304FH6oTSish1fWlmN1jqxYxyAUwiOkQjGgnDMgj12yRJIoSfYIIQ9GmsbYQhhWEjq+HuuR13hVjz7qo5LcBTAsAzAkUvH0Y7oA5FakoUESZBp+w71sw1GkhZCwTovwSDe8Czh8QzZgQzQ45umNAij4QQckXQLUyZ4IigYYos0YxwVswCBeANfxzEmihtVVwLEYUDXJxjEtEFqxRoSRQBGUAFpJmwjYRhz/xEIWEFgCbpDcpcC0LEoCGoEL8AElIIMq+AEbGAEMTFaBMBm0wIrfyEl3WEtBbILmPIQk+BCT9YE0ruCxSFkfIMEm+FNbRo4MRg7ntM17NEuCgEIn5MJcKgOS2CWEIk94ER/rcY8tuBk6VhJhNt/rMUn0OE9iJiZe+uMzKEMqiIIvACEsKMM3DGQ9mMg6qIhXxIjCVMPCVAMc2SjDWIOQOIU2fKbCyJE1nOY0OMMx8AIrDAYoXEIjnIEDJEACGBADEAgFUEAtbQCtGcctnQAKcECi8CaW5kwwcYAkIEJq7Br5BQcBLVAGoYaIkUAJVJMGkQCmnIAL9EC2+Z+7UQ4S/8yADPTHeHABKDRDI/SAC9BAc8TBJEhgd5iHewrIcwgIDThZfTgOFwlCIOBYIFCjc/hQd2AEFT0E3WCqEfENInzER9zdJISCJWiCLmzj8RxSiN4F62UP99yCLuAqUFGPhg7frN6FS6EcM7iRNKzOVrToOtTDGmKDMjhJckGPM/SOj2pDNdioZy7MjeIoHG0rt5IUj15DVgCJNYhUNERDMyyDMODCK3jJKexXJvQARvYJAyjACYwA0lGA1ADQX83mCWDYnlwABd1JJuJMW4GiSq6a1HQpho3QpI7Q/mEYb9DACJgADOCpC7wAB9nKJiCBE3AsQDXCIPiBJaCBC7iAEf8cRCiEwoAEQkP4jXkMVGbB1npIC90MSEFBqqJqTqPiR5VRjrOEB0QNwzBwDqiUKSFIwt1tgkQNQywggiE4Aix0IzCgGcZszDlqj/ZsT3oBVSXtwvQwpjvy48kdicNUg1Rwg7vYA4yqrT2oLYyaiDeoSDfEizWU6LBGAx9961FUK9/qqLayBRw9DEhtq0hVXyDBhcQ8j/bAwg6ygmIkxkeYwhngYQIcgB8mHQP065X+xgjAAGncSa810KSkBg0EAoUZ0J20FWfMH4V5GM4UgaJk2xgUh81Exwf2wAm8AB+oLMcWYCB4YKiEwhOoGxVwQRTcgBKkk9ckAWM1ROT0YkX/NBmsmMckTEIVRVZ+gGozult/5JisfFsQxVOVMY7ZXFEYWRkWhQspDEMogEsioILUQlr3aNKlrdfoGSESVk8k2V4/OsPpYMOxrqFB2sOHuG2MEsXAJHDcwshX8BGQdMM1VEXfVsM18C22YusfFUmgIS5dOI/FbMzCFcbjihJ/mQIdZABvVoACFIACKICVagADMEA1oYYGnABrTMAApQbqtsbwdqnX0QByWl0StORBkVZdzcB1KBbguIAs6kAfjOoLyEnnPuUxDq8RCMQhNAIVIEESPAEc/AofRNYGOsFDLB7gzIe1KCrdNMurHMsV2dsP8U2V9Sys2Bv20tND8BOm/3KOJDCHIBgCyFoCpvLBIpQCOAIDYKaZESpyEwrr6fBoWXzDZdaDPbChAZ8IvHxDu6zI264DvwxFAmMyA3NDBMeIjUxFkKCUWqhUZE4MXnghx5Ce+PQFKvBFlvxFl5RSYpBCqXWABlBAAsTGH/5h1vAaDu8JavAmA4AGLxHQ0KAVTU6ACmwKhgXTbRQQZ1hKh+VGFmxCEowAgTTC0LJBAyIBDPXBVjbCFiGeEoUCKCyCJTRCE8xAEQgCFPHBgHSHC2ZWFsAse/pQKJjKV8LKGPWNkE3ERERO5ODbFk2RKhxRZNVHbZlK5zSCIRgCvwlCJXRC1G5jMvyCL2RMKvylLafsgvMYg0t0wyQbJIyyyIvAi4sMjIoMzLugSLLyyzcg8MCcyFZkAwRbA2dyA7VSa8MYiYMyg/J045PEMlNDySqVHsS5AsmcQpiMAikMBim0Js3cUmsoQGvEMEaWEGqkRi0hcy9JTWugRp38SXH0zBM4Sp0YitUFhwzLaTXdhtzBAAwkARJI1CCwABuwARLkjRPEWB/ogFUiQhGMwSaEAg6kwSBoUREEBAAh+QQAZAAAACwAAAAAQAEAAYfrwKHfs5Pcq4jRqY3UoXvKoIPEn4TCm3/Ml27Dl3fAlnjAlHC9lnq9knK3lXu3knbFjl69j2y8kG67j266jmm5j3C5jG24jGi2j3K1jG62i2e2imayjnOyimuvjHKrjHS9hla2h2O1iGW0h2Wzh2aziGKyhWOviGyvh2SvhWSvg2SwhWCvg1+ugmCugV2rh22rhGqrhmarhGWqg2SqgmmpgWiqgmGnhWqng2engmamgWWogWGlg2ekgWWhg2yyfVWsf1yrflupf2SqflupfFmogGeofmaof2Goe1inf2anfWWnf2Gne1ilgGWmfmSmfGSmf2ClfF6le2Wle2Ome1yleVakf2Wkf2KjfWOkemSkemKjemSjfmCjfF6je1+jeWOjeWGkeVqjd1ShfmShfWKhfmGhfGKhfl+hfV+hfF+hemCieGChelyffWKee1+eel6eeV2cel+XemWcd12ed1ecdVibclegdVKeclCccE6YdVuYc1qYdFeXcVaVc1mUcFaQcVufa0aZbEqWa0uTbVSTaEqQbFSQa1CPaE+PZUiMaVGMZ06LZk2LZE2LZEeGZ1OHZEyGY0uPYD+IYEWFYUmFXUSCX0eBXER8XUiHWDp9WUB4WER5Vj1/UzR0Ujt7SSlvUz9tTjptTDZnTDlrSTNpSTRnSTVhSTdqRS5lRC9jRTFjQi5gRDJgQS5bQzFiPyldPytiOyFbPyxbOyVZPy1ZPSpZOSVWPSxWOyhVOidVOCZVNyBROilNOSpONSRXMRlPMR5LMiBLLRlGLx9FKRc/LR8+KBhIJA87IxI1IxQzHxE2HQwtHA8xGQoyEwMnGw8mGQ0mGAwmFgohFgokEgUgEgYdEQcYEAceDQMVDAMbBwATBgEOCgMOCAEOBgAPAQAKCgAKCQELCAELBwEHCQAICAAHBwEFBwAJBgEFBgAKBAAIBAAHBAAGAwAEBQAEAwADBAACAwAKAQAIAAAFAQAGAAADAgAEAAIEAAADAAABAgACAQAAAgAAAQABAAAAAAAI/wCZVAkzZEaFAQdsqACSYgiTO3eqiKGCYgeeOzaGhLGRJ08UOlSGtCghokSJFStMbKBA4QIJEyUubBBB0wSLFRrYoLK1C9gybc6I7dqlC5YuUVxsMAEyZEWLIWKYUKFCZAgRJliBtGgBRKuJr19daG3BwgWLEiyAuHCxde3WFmJdgDWhYivKuSNGiPgq4oKIESREbBjMcrDJDStcEKnTidQrW8J8yWpFeZVlVapKpdrMeVXmUqoot3qVShSn0548cfIkqrUoTHIeqUplqhWxZcuQKUuGzJixYcOC+bp169QoUJtOKSv2CBAgV9u+ZbtmzVq169inTcteTbt37dLCi/8P/03eN23YqKk3VgvWMWfOfnkqhCjRpEiUJllyNGmSo///NSIgIgQWSOAhhCRISBVM7LADFCgUMEAHIQFhQ0ZiRDTVEDaggAIVeNARxSB0sEFFCyiZpGJLGpTwVWB9XeBXWkBocMIltugCDDLYNIPMULnIUssqb9igllyJMTFEV0wNsaQLKZXVFQs3haWWCSOsUBYSeOCxJJNstZAhHmIMYcJeKJHwElh51bSBXzQNthIFJRi2QQguVHHHIJygEssuQuUiWiurVLaZZYgWulkrsBhKSmqsiZIaKaSIUkoomIRiCm2mEEeLK7e4wgorxo1iKijHgYLcKaA84oMcgBT/s80201V33Xfe3YoreNJEE8140nxzHnrUNOOKHB84EIcnu8RCiiOJ8GdJfpb01x+Ajgio7baNGHjIIVg5SYUNDSCU0UZM4ZEHE2pemFFIIZIYBRVgkVCnBvhqUNJLLRCxwkoyhrBCCRNg8AdPwACjiy7C4EIULq3Y8kcKKK2Q1wpdsRWXXV9pudVc/VZRBRJBqFVWEESoBRdbX7WABBMt5PUVYCKoiWVeF7MwwgX4ykgYnXWGEEIJQYiRRyKcxPLnMcDYMqhoiUZt2dOWleJaa6F4UmkoloZSCmiqhILcJmRj8ggmaD+i9tps++A2rMpEh4113e06jTR2h/drr3tL/wMNNNoETo0zzYDygQGIG/AADnwgiAh/lVhSySWVVGLttQFyu62BGdIx0REtSJiBkysYKZAYIg/EYYdU0EGHRyjUrOabLPlcQmAkjKQBzxuoWDAPqOwijDCyYKJKLsDsUosqu3BiZBAotmwXXCiu8BILZOFlQmIZU0nl9izMNbMJQVRBxAgbjK/m+jJ3bLGMevU+cO9By4gWEYV08iegTT9dmf//Ew0sBtiKzZSCUqLIGiq+ZimrmaIUpkAO2tLWHOcAAlbOkYMGNfiBtz2iGtrYhq3qtqvwlHA8vkrh37CBDWn4KBIOSFwBDMAABjzgBEU4hH8mQTnKWe5yQMyc5v8EFIYwVAEkURDDBBAyhKnc4SJMIAhTWtAQDqHgQnmggkx2JyMKRCAChfnKm/ziIr2chGAY8AAnekIMYvgieUPZBSxsgQojAcFifdkeTPRYkpKU5SZ3wQv6hPYVF8llLjWhiSJpooLtpYgkKhKM0O40ApickXYsackGRgCEQnhCaQmc4wAbRZlGEZBRp2RUKUfpmc8k0Gua+VpmMhNBClIwgxvMJQc7KIdRhFCE2Tkh3rwDLBQygxnAIgYgDDAAhCRAAQ3AAAY4cIMbEMJalbtEf35YuUl0E3P8ESIRw3CHPLguD0OQUAocRIUq7IAKYViKki40Lg9pwAZVwFcmu7j/z5oJRn7v08AGNPBMDFCiJ8JwY0+GogtbwOIXfHBSzPoSp5mYpCQmqVggnRI+sNykBEITWAvYRBO96EUwMsJSJGlSJ4wObGjpq9MYNwDG2oXABFVwhCh+QQlDwGIWDh2lUIU6qKkNtVGrSAUDufa1pqrCFE81xSbYtrYL6jKXr+rgq3oRwm/cioR34xUKU0hWvTEjhc1oRjDkwMwBBCABcG3ACXgwhjjMwRCQ8GY2K8fXbvIViD/0j7YGAhGBjEsBA1AAPVE3hDzggQpaqUtbLtAAC4iBBCyZwD4vAEZ9qemff5npBhLQgAfM4RXDi0wcGfrQSVzoXxeYgGAEOhOM/4LFRRrV0plKmpK9bI9lM1ukGP/Cl0WqKH2JgZJJKpkSFa1AJgCbyRAm4SdSZAoWuDgqLCYDwFXW4ru14C4rMGOKUIRmM1DFzFNLQQkLAkJtuHTbq+YrXwd84ANyMEZXcVXMsUbjb3/rG99cmNZW+ICZAUgwAQpA2gzwQA94hURe9epDH/b1whcG4h3IeYeHTIUEBSjAFY14BzEMIg9GrIKThuCCC0jAAg14CgUmoNl9uggmM3lJS0+qJtI2IAakAMbwdOGLOC5sFsIQxQxs8C8LUEAvtLUobmGCkirpdjCVDB+atjdSksbJL3ghSUk2ehcV5eUkH33unXq3vSpkwv9Px4gzMHDxXaFyF5VDpYyQZLHnyYz3qZqaTSpCQ95SgEIRsMJgfOXL6PraFxDK2O93UthfaPgKGs8IsK96FZ60LsMUN2hrggEwgAIcgAEYuIEeIMEJTVyiWhe+hKwtjOFaV45BVWHCmJggggI04A6FAFEeBCEGPAyixHgAAgUksAAJSOACeBiBQCkwbea+iCaBGag/X2IBDchgB56IsxuLbGRbJK9IKJhAAxIAlpRY0pF/DCT20Efcm2RZMV5BghiCUEki4KEKeZHLXypJUpOe9J/ITYlf6KfRPOjvF3FGRmRwQfGK1+IWFM+FxivOcYqHtxaiIa8o1EtyU8CiFqH/kMMYVq5oC141l/b9ACakgY3oYKca/eV0r9Sjnmr03Dzb0IZ6lrEJBxzAAAdIugIUcGoMnAALfaAEAjVhiUg0YhGIiLWt/frX/jAFK1gRWYfhaoM77KCxJyaTQFqggWbTeAIXqIILLKBZDVBgoCfBEoxI8CbP2oxn67QExMe92oUJ+RAzQIEGmA3I3FbMe4GEy259m2WyYKzLmBeDGIBggiFUIQg3w9lAKSCY0G4SZ+ibiQZMIBPfpqUQn3jFL4QhZ1/kgs7gJU4tOu5xPvteFq6QBSso89QEkpzkJwfFGHxwX602+uW7/MAoqIENbXxjO93JuaV3rp7wYEdYQccG/zEewQEGID3pp2bAqTMAAzX8oRKoeMUrTGMJRixiEbTeuv4FApH+dykPBJUBUQAFRwBFnFcXE7AAbjcBEjABKyAGIjABoycCT1ZIPDZQveMhJpAC3fYUhLALxzBuvkBuIwiCnJADKLABDbAA3gNIZeF4MCEz4UNwOgNaJtACe7EVbbJJYIEEcicCuyNQCDcYLwGEcqJ6fyFQrYczJjAInYAKEBeCvqALdNZntEALsjBKgzIqo4IZo9IKf2YKpmAprXR8J+cJcuADL/ABHnADjeYDy/eGPuAA9sUL6mF9eDNWehMNZ8WHaaU30nBMgZMewgAIRoc46FdDD2BDJ4ADXf/QB9Q1C7swC6XACdMSCbKWTZmofxgmFk7SFVeBFS1AdkcABRLVFSNAAQrYbMzmbBRwBykwE9QGP5aUF2tyEk7RAiqgArLVAq2DCscQGW9Egm9EDKtQBorXAA0Aby6YW++2g65XSSrDejcoFzPBen9RE7u1W3pxAdQmUNvDdzIiUPiSF5wlAdR2UiowCJkgCrHwC0JGFNu1XX6GSpTxZ8dHcl9IfK1RGYWiXpQBG8zHAdTkA9Ukh41Ghz5QDM1ADSEkHv8FYHxzTMekDMqADLphkcmgDNSwDM6ACweWdOdXQzbEAQ/gdDnABnagU0gmDLugChI0a5fgarPGiX1FJWv/USU3iD0NUAAXkAIz0BZEwAKt6Gyr6HZhQAcpgIMkwISox1xawgLuYgMWUElM0AWXMDwj+EZDMYLD8wt6oHgS0ABQ6W4osRUd1TF8ISOK5ALqAjNcMRZnUkm+dSbiI3q1IyMkkBLimI3kOGPoqAE40wKFUAmcIAqoMAtN81PaJUCp1Jh41goQREohpwqwsAqUoAcD+QAv0JkvcJAImSwOAAjI0JAPqTfQ0Ie+QpHMsBu40RsY6RsYKQovgDgSonSKKE0PkAEnsANsUAeFwAlIhgxu5AqhsAma4GrJKZM1aWuZ6G5sIo1aAVckEJQpwBYSkABHeZTOhgKD0BX/EnqC/8GEVeYCU2kBMwEEUXAI/BMMCZMwI0gMwHAMi9ABGmABCxBI66NRoec+3Ohb1CM+NzhSMVJSN4glA0Vb+KJ6G7A+QCgC9jYnLDJQPDMCHTEIjqAJnvAKs9ChWjhA4FULQGULttChJkqiKJqikpkKRNUKmAELpWAIacgBdOgBngmab3hfdIgJytCQNfcrfMiaQrobyeAbxQAcwZEwm/AABiAhzXQAS6cANlQBHVABGRADS6CSg3AJqPWawSALodBqMylryymTfcWcsnYYFrU9nMQUPdkA66MSzLYA2rmdymgBG4YCmPUmO0ieyeUuLdAAEXABLDAEb4AK8hkM7vmevv9gDLTnCTFAAurWAh6ipy/Bl0+JJSBjlwLaZWDRF3IiIxYAJ7VFoTJiPbJDEzxjAnuJWYA5AXQHqxagJ3dACI1ACaLwGCYqfyM6VCeaorvAEyNKoq9QCquQZ5RRC6UACHpgBTTqADbqmZ3phoy2hsnyAaeAG9SnDULarcrQmkV6pMDhnruwCoBwACHWTAkGpUtHYxZAAhbQATIgBCpJCJSACj7hacRQC5KSnP5apsw5OWhaUbZ1E1sBYgcwARogqXUKV3TabAr4YhVgEeujL5XUPo60FiqjENpJAaWDA5wgDMCwqAmjqMZADMcwC2fQAd1Zqe6DqjwYSGCxFTmoqWH/cW0kcAGj2hcWsEgz0SY9cwGs6qBBqAEKm7PLtoCw2gA20AJHUAcJ8i2KoAiMAAn2J2FWO7VUK2GRYLWLULWQEAmRMC2Q8AiWsAme8FN1RpkoJwd+0AYe8AAOwAEeULc3Kl/WqqM+4Au6cYff2q0UqZGy+RvkigpxwEwSkmAJtnTKWAGjagIdgAIzIARrYAd/0AiisAvIsAzq0QzEAKOq0WoAi6akqyK4mBIusCQUoQC+9lwNOJYKWKcK2ADOVgEVgAc24Bc6pki2qCYV4xYqMRg7YANcsAjw+J4lGwwnOxRjgAHKWKko8BUp0EgmgC83OBZakQIjMFL8MlKAURcq/7A+HWAB3bY+4itQgCFtGtABaqICHaIm9om+gyECsdqAbxevYVAHefAtfdC/e/AHhPAHABzAAizACkIIhnDACuIGceAHgKAIlgALCrMwDdUec7QJfqAHcTAGdWu300qtjHYDOgoIw2AMyrAMDQm4yCQezYAby5AezrAMx7AKRZA46MeuUdoAVMq+HRADMrAEXTAHfXAIlmAKO+Kj1DAM/NpqluMItEYJAku683MSbkEEInMhGsBgFOhsKxi7q6iMjVsButagajKOxGW+JqFHJSBQJACUXFAHqIW8IxsMxMkwhMAACpAA0KsvS9nGNuMUJJC9b4E7Dro+5KsmsToBJP8wvh0wvuT7yJDMvjWjAinQAbAahHT3yOqmjDRmu1FQB30wCITQB3ZgB3VQyqjcv/2LyqnMynVQB3OgA2gwB3oACJhQC1O4MLhgC+3BKJYwB3HgBlbwAh5wAnV7Ah8cwnmLCbJ5ws1gkdDMmtJQLGmFkeoRw6nwAiGGiEonpYxrpZGLAicQAzMABb85xIoACrlwGw6pDcuwr6PACZTDQ6NrCaR7Cc6lJWKhYktxJgkwAEa5inAlu8robBJQASJwB9UbGGZsvlKWxjHRoCgAxFcQsu+pqIraG74gDJzgAOumgb6riwO6FQ7RFSO1iy1AAvmSL4pEvuz7yI6sye7abUD/yEXo06Y5a3d3d5+ZbAFj2QA01oBHQAdPZAcl4jpwQAevTAdwAAd88Mqv3NRRDQevPAdzAAc5wAVmYFebYG66jHukpAhxEAdmwAMvQJB068E4egN5ewq+YQy40QwbCc0n3KN/W6TGgAzwsQyi4AGIU2qmdgDPFKXQRKUkgAIy4MMPQtXovAmwIAylSX3FQgy6UAqe4GqnIabL+a//imZmURYOAZctQHcMJtADDcaz28lA3RWKLCey40jrk8YooS9XFAVsMAPsmbzBABwYGQy7kAonUAEN4CFvcbBTFNLXG765A68q7VlA+NKQbL6GTL4ZkAH5orPYnYTkyzMuwdBv/0djYCzUdBAGrcMGts0G6J3eXQAFcPAGaeDeaIAG8P3eb9DUahADMVADarAswrMwt2fBBfS2bTAGN4ADHCBNaS2tB8nW97W3xOAbLpwMEo6RGGnXgnuyMbwJHNCkIZZ0cMW4DVDYGRC5MjAD5AwFXcDYh/AHuAooKEzNPvKSx5kap+GvM8nZyZlR+rwWpDNSL5YApU2nDrudzqZuC9AAGlAjMyETl5oYIlE9GqUmFUEFXRAFcBDHvqCovE2ctbALblABE+AQhdUVUFEmKAIXKAEl1pMSCyvd7Ls+yj2+0g3JPMPSBEe/LyaYi9zIF5ABjnvQtnun9zQuO0DeUABPYf9g3vNC3mzQBY6+3uYM6Y/eBVxwAicAA1iwLJCRMA9jwaIgzFaQAzBQAxkgTdNUzNLqmc0HCG0E4ZtL4bCuG3LdGyXsqJAQQxJymx8OTTqswyOOAjFwIT9sznXAB39wCHuwCJwAC3Rs181AOMgwDLdgCpUCKaL7r5nNCbWFixq7PSKggBMA5Aw20NtZ7hE7vX7hF7kIF1+yFhqjFSvQEPPCBlzgCSI7gooK2VwODIuAARRgAy4gECKRuuB5llCOMWmSAi/i0CSgAqBjvo3cyJG80oKpAtI2qpFsu7ZrARrP8bbLM4etp1eEAuy7ZDMgAw5/BDZw8iUuAy7v8ilQ4kv/JgQGwZsnYAakMHsMRWcD9AqawANsfQIckAEnaep0i8wewIZs6AEcIHPEKZub+9Z5TeEaGe1t1Ap6cHTN5KS7Hsbg3MMz8CDl3AW/aeyHYAeHcAnB8+AZmVYtbAzBoAur0BqqoQnZfvclgAKPl7o063baKe7kbu6x62MWwJRt7C5LaQPDmzE87hZPMRU7wAg9ge/Dg5GU3TwdkAEG3xZQUj3Qy5coEhg3w3dkfJ8ND6/vCq9v/sjV3fqsL9wSSAIZQL5gDuYTUAE/nfuwWufdVqWN2/ojXt2OC8kbv/Ej3sgJYEMPoAakIIl1VkCccQhM/wCLqH6mjuDFnNZ1S5Af/2AKxMn2sA71FW6RjkoMtFlqgN1MA/BMXt/6YG8DUAAFQMwGdGAHfUAIiEAHURcKsxAMD84bAKFsWTNmzJQhEzYrlShPnBw+hFiiBIoVLlywWLGCxAIJEhYsSJCgQIGQCTxO6PhRZYMEExpMUNEiZgsbNW3QrNmixQoTK1pYdEHCBhUbO+jsAuYLWDBhwpYtIwbsFaorGSi2MCGCREadOlegALtTq9YNI0SM2GBBA4m0JNyS6ODWwty3czPcvVthwt69FfBm6NBh7oQKFvS+RNlAQgQLJDRkgFvBbwbJlfPOxWyYcmULdw8ceMBhjydPoTZtwpQakyVKcx68fs2AAf8G2rQ5eMCdmwOHDz50ISNGzNhwYsOEBQs2TLnyYL5q1dLkYMD0AQWoD1CgoIHkvx1QzLABpUsX8Wzq9OlDCBEbO4w8rdIVjBgy+snsF2wGFRisUqRJQ3SIooqGcCEjES6ggAKPOJrgAJJAmoDBBT9CiYILLLhAqKGoGMIGFFJIAQUTZuoKCCKG2KkFIFpAAQpRhAEGGGKOOYaYpnRZZZZFOtDgQBN6WgHFrmpKYauM3PqRBBFE0GCtt+J6K0oo4aLrL806uOsEwGA4QQgSKAMsMMkM04stuALDsgIs78IysAzm8qtNvLhb8wAGXvuDE0w2iSQSSBhRBJJIDHlBNtn/PjM0UdkMMABRDhz4ABBA5KC00tQekTTTPTexpA0GRhqp0c+yS0C7ChqgLUwUZJhhBvHKq+M8Qg5RjxJPWolvGF+UK2a4ZJSRpplmEMpllf4a4kQTZS+hyAUggChwBbM0oAAlCawlKcIFrP3o2gkSpKDJtWqiotwdbErhxxRIhHYnn561QYZLZrFFF2Ca2oVeW1J5xZIZSEg3K64I5AkssKLcSoUUltyABBVUcAzhh90SDLO91gyMzAoewCAD2V7D4AEGFLiTtgqy2w6xyhrYDuXsFPjMwZEGCACAAK6jLgCdAeAZAA4OgcQSRQBRRBFD/NhDj+lABZXRmD+WzQEH/3j74BHUNgEFlFFGOaXXYYITZr5lnBEmkgeYFvUAlFmWrOMwvWt1iS7YGA+OOuxIj9ZDKOGklFmU0sUXX5IrpphfmRF2GWOAqWUhZJctoSIgCFTSwmolsPCCJkVagIJuF9wLXAoaduu7I44g0oS3liRhRJ+6+nEFhUmgw6FQQiGFFP842QQVUeiAEoUmRQhyCOPPrQlhEH80awTn0bIg47gqdolllkoKKWamraNZZ+9r7jl88cEXv3zzeyZ//DgYWeRPo/8wJH4/GADtY5FnO0HLDHZzILTbemuFM56iDAI+BRsHdIYAbaEJQ/yhCQ+QWQFipjYGpGwygMlfDGIgA/8dLEE8cGADHOaAt1npDRKaEEUrcKGLW+CCF7zoxa4Mp4yCPCUqtniF43iniRVghAUXOdC3LmehtLjkM966Vkf2EgFw9ahJgZmBwpbXE3G1LmCt44kVQzSD9lnCEsqixCUo0SdPvIIQKMhQiJA0hBWxCCwpaNIFNKeBC0zAAhJgGUgSsIC17aUBChBJ98C3s/MVcnw6W1oBDCDBCcZGAadK2Z1ksxvYhAw2r0FUD1DBiUgIDRJFi58h9uAxRX3MkhzjAAP69z85zAcZxqBPLKVBjQQSQxE0G0DaJqg2kj2gMnHqwAk0GIMZ6IALczOP3Uh4iEMgYlaMuIQnTCGLWrj/gha0uAUMexEMY9jnV6+MkS1mkUPdccItGwAXSlSyzo8kgCUFWGdHFpMgBMnxAhl4jAQgmcd4Zq5afAHoHxVAB0Ioon2DOoQhFPEHRXhCDzpAQbxaBAThuSUm60Kdh1CgE4i5xSwXUKL1MhO9CQASew1opzvZ9sdLcqxjtelYJTvAsbukCksYCGaW8tIAl2LgBCHDwG0w4IEr6OAEHniA1P4QC01Qgk+AMqjR9pBK2Zyypf6LGgde8AJFxBIZyfAqfZaxCyuArzoOYpQieakAl2bAbcHU4Aw4yAU0sIENc6jDCO1ACPUgohHNZIQlOCEKVsiCFayw5i2yKUNY0icq/zHaxS5sAQtjgWoAAsCsAApAAAJsdjoEcNBnFgBSjlwuAqetJ4I6Y4EG6EwAiTzAR8K1ATpSYKTVC8kS/tDMRSwiPQpVhCVmgQpCgAcsN6HjBUSQrjpWgAQXwqcG7rgXCyRGAnOxHkCpmxk7DqYvp5oMUDuwsu3Q5jUNyID+3Fqbu3AsBeMFr182VlPAZCmYXNBBMGFjiV1w4hKcoERwi8YIQ+hBZCCzX1A5YF4IqtIDL/ABKPLzVWXYR6zI2MUYaMYzUB1gkRJcW6rYBFdi7mAHVzhDCOlwt7vlDRGJSIR6FkEJTYTCFKrgGmKvmc1eDKNXxAlGjIARWcnOQiXY2/8jklVi3QVhjgIR6AgT01kYyliPZfJkkOYuVF3CVMaOf5TBH2bVW74e4g9/sIS9ONGFGLiJWo5xUmDgAqbB4JGfmJNu9V7CsoC6RJ5JVGJiUra27LIMZWrqwHvZNKcw/WU7J5MMejvw6Dm9lGOeYKomAFxGUUSiaHpYMFBLdtWg2ukBL+gNLpyRn4LgR1gZXiT4tvcZA5hqMsEkMXigEAW6smHF5+nDMhHx4hgjYhGRuAQobLy1U5wCsa5Y7NeIAyMiE9kWI7hAAg5gEnZ2G6XdUolHojwBBHmLMJobUwWQKE9webcjfLaAtjOQN2b2gQ+HWESgVCEMVPRBBpQJFwX/3Bii6pKpu9Rd97dYW91rVfclDje0do4ckiNrB5Ck0va2sacdl0SPBOCtcgbQa2VTWRmSrPXLdmrKgRO8gqmc8IQmcmgLoUViDgsWmW1gur+geuBOD3hwKxMoLGkEK4G70AP9uqfZWR+A0hgcJqt2UB672g3YhHCxsRPhCN4GbRO3UzazD2tNXiQnOI/dhS7yNQu2p/QzSMaeHkty5HWWao/xxPICrrfOPF6LI+AO9wIyQAhGBO0SXEcEoCwRimMAgxLC9BxIPLSZwnjLAhs4iwbw6F05FlwtTmKSdDOzZe9enrUTGIEJLnSmkzucMXMJDBzlWBjOdIDcggmMng/T/wBJxgZVSFVDLGLhEE/MixSaiMQjIiGHF3jgBC+4jZacn7+jOn9/J4DBCx6RQGp0P4ECnMUNPLxtAiwgBAlo1Mu082hgBlOYM9iBB+maBhG2OD2zGjYjGuEI/jsijJoojVAQO1ewJmiTD7ABBl2YhVZYhVRwwFTAHlChuJTqNrx7t75TItGJkDtTjD+rlnBLkGu5AJCogD7wk0vQhFhBBEdQhEgABWE4BlQ4gw4wgQjYIyCAAg2iDAwpLdqiI5TQLpfYrh5ZkpHCEM2zMr37I73DrpeAJELrQH2qgI5xOIbjiAPBENLZAJQyCQuwOI95ALcarwc4AQfYA2F4uYa4BP+i6RNKkIPcaD7cUDCWg8OeezBGqDZYUAVVKIVHcACncZAEuIANyLiRYRvuUBUUiKupG48ueAMR0gMSKjPeYoT+479J+CKYux0BdLaxu4XBCRtqo6xUQIVSyB0KoLiQeJB1Oq1WlDJ6Sie+kCMN2IBajCMEqZYru5YI+JZBRCcmsicou5bsQANLuIRLgIQ64II6YIRIoARMgAUMUwQs0aM5w4smITfnUZAJ8TZ4s5YOzC7WIrmL4zNDYwn1Uz+B4inYqAB3WgApO78IKIRMwIMgaIEGyLY9EqiTCRme4ilVugGYgzlPOA1M0ARL8BMe8IDbiEPcyB8YiAEYgAEaSAL/GMABLHCDOdADP4gDjdzIMTiA6nCaTyEABEBFO6kgwrgS71BEuYK/+fM1jeQD9JjEZkq8SrTESQijTfCErAk7U+jExWKKpNAFWEgFUygFUbidQtiAdwQJkAAXV3RFe9KcxTA3e6JFEUCBEhAXXAwdXLSQHnEMcrOnJ5OAUqmAHQgjSzgENoCCPsDEZ1QFGvGEE5i0PXIrkHkTIeyRC2mSOzrESHu4vRS0P2IZcbQedIw4jMuOp3man3sNQOocJkKAypSEWPiETMgESdhMIJCAEaAAEdAJGzgCu2KDO7CDOTiES/Cd0wCFgsQESoAESiCEP+CDPdiDOdDNR4QDOHgD/yxwgifAAonEASsYAzPAgTHAAhzAvgeYjlGhn81CgAjgo9egsjbxjhIzsSugq0eMFT2YSTHDv2EzNpzMSUqwhNPAmqzhxGZzBV4YnCDTBV3ABcoqhVAgDVQYBJBiiQocNygLwSTSrrmYI7cQFx75C7y4pwuRo7A0UHHRuwyYARo7SBnoAkLQSUvAhFBwildoAgyApPWqDcuorwS1qZtKlX5EFfMSMepzUReFSBzIgQ5agiVIAzMoAzV4A94UIbxaMTq4gzyoAgiAAAQAAUnohM0MBEmQhE/4hE6QBEEQBCaVhEIQgzAQgiNoASqQgSKABN/hBJ98zdW4BEY4gZGJGf9GUdO04p5EQpuYuSxGghnrIIAICAE84hhEgwth2iAd4E4uSDGrm8mZLCGbHDYYu8RJ6L9JcMZNWc+wOwWuoQXB8YXACQ5jSAhRcIgYZAPAqADZspYLBMLB+KXuwBg0WZPNUFVEHDHAqCLHoACWiQFoUpZJsNVKMMb0bIVQsLklKJIOgAIo4IKiWoIj8CDuRIM0eET6ixW74YM6oAM+kNaZRI8/QI9qRQ9q1dZpfdY5gAM3SAP6UwMysAIduAGJ3Kr8+Qu/OC0j/YF3LdLKlNcICATNxAMoDYQ8EANByAMTaKeRgIFDEKxNVE8vWoRPYRqcUdjvYdjqKIAAYDptk6D/zVqAFaCAC2LJYXrJM6grX4sVQqW3Q4UxRHUEW1VU/hsj9EwN12RPZnOFXJhP+XAGBAKGUvAvfvODhXyA7CBRnZIzu3S/DOISidQgVvGgYJ2b8aCDpa0DuvE1po2Vu7EDvMmDPLiDIB2ESkBBTeC/SpxNS/AEpJiFmJuEQRiEQhgEWkmPqeUDPfBWN4BbMigDMsACK2iCHJBIGYgBoK0pEWOw87ofkjkU+qGfXTLcz2CkkUiAkoQAeK3MkkSAkuSsH/iEQACBQAgBSfgBSQiEJa0CPJCECXCnJWgE/8gaT1gNS/gDQTKk1gWA16qZABgJxA3JOnWBErgANAERl9wB/y7otd5csfAUT/xbhEYw3uNN1JMVlDbU0JVdz9sZBVZYIV8ghmXAhm3QhmawheKjBFLAz0vorUMYhJHNyeQ1WZPtWkZgBPJkpvYtoVnhK0QoBPflK6yb2qmFVjo4AvHgAkKohGSxVUeAhKDR0LE1hDmQgRPgDgbDAO0oJcI9XFFxmg/bngq24DZVWIUVgO/BLASAABAA4cgV4cosUhDQzCO93M6VhBAIBDHAA81cgALwCxqohNx5hVVABVIQhUXgAYb14R/24Q2+LIalXcyKAIvAPLAgJhvYWBVj2vCsSd7av/3LyQA23j5xRi9SDZZVNlWABVsIBmRoBm3YBmwwBv9TuIRJaISkbIhIIAQ+oAO6CdaiwoEbECa77Nv7cYA0PdwJ0iU2xeDrsKyz8oDZ9JMBVt8/gQRCKEM0HeQMxhkgJiTXpeRKLh+I9WAShgACwCwCAAESzoTK7VzKfdLNzIQqQFIVKBUS0DYLUIFMEL5X+IVYWAMIwpkPa5S0gRlD8TAJLBXuAUTEFYAFQAIgoC0SyCANwoHerSu7cdZqLVTyRF5LpGZnTFmVVU+fDAVR8GJdcApqwIbsrYXiq4RKCLAGeoOfginb2I3aOC9edpClmWAPm+A1BeRAvmUGyADrkKAHgCYvWt7CowRG+MM2/WFLRuiENp/vgWTIjVwB8OD/eM1kBLjMytXMT8BMzHTSTviEO3jYA5gAUFGBTugEKigAOigE+sEABuASGmgCK8hIQtirRDA2R4gEZbGESpiEJwitkKCZic04BxGABCCCKmABgNFYP+214K0D4Y3mRWAf/qNiau4/a6aEq9bibGZPU1gFWPBmMUaGW3jNY7wEPTDrOkCDGKA8toGNcYQZ7ZkOXaJnQI5kSfZhm4lrPfAi/0LBS9gETlAEA8gZuybswjZshv5hSB6A8WPsA4gAEuZkziJhTX5XFQ7lUM7MTCBpSSCBkFQAh42AUBaDyBYJkmiAI8iEwRIFHRaF1iYNpWxt11YEDlikO/ns6gjqia0O/yC4AyJYgRSYgRmFAu5U1meG5vEsT/2T6uOdagEeYCx2xk5yXqw5jVAohVRohS+uBVUIhdfchGMMjRPAOZhpTD9mJMN9GQpCSXj247RapEVq7KcR3I9hORxAM1L4haY4hqb4BVHQgxcImUPZJXsm8AJfUzuRmv7xnw94gRvwAR8YgzaQg40EBIV6hEd4xj3R5tVGBX6BhRXy5nyJhU6Q1yKV7Hgl0k0+cYkmUg9OYWf5I1ARhE9Y4ZLMtsguAAsg6U7QYeJrCNJgT9K4BCtgFNmgDMXN7YktABbAAzFwgaLoAUBNVu8kVPFkJvJMbuZmbvNshOceo+hWWUd1TVHocP8HVAWl9O7UsA3q84AOcBsMyiBW0VujFdZG7AI16IIzOAPuvIIyKIMr6IEe0AEdyAEcgMgXiIEXoD5Ef9GteoHQ8IAbGIM4AITU8En1ZIQ/0E2zNuszm5VA+dpNYU9RKAVTuLHs1pf5RIoYaYpWD5uzg/VYl/VLNYazGw6BAA4Y7ITI/mR5nWjIluzJZtwRhoBA6AQrDQkXcNJAiFxOXoAgiAACqIIn/QRUeIWpkAQXzgRP4OZSuPZLwAF6LoDZaIBALJUIkpkL6FwkaAFADaG5iZU+ELP2vXLy7K17P97i1fLjnc2rvuo2nO5sLgVUIHjvJUjUSA0zQIO65QEcqOP/QSd0Q5dIi3R44hz0HJjRu20CMuB4jm8DN4iDOOADP9ite58xrD5GZdG0gWSIH3dtUkiF+xQFZbsdUrD2V6CXWZAsImP1poj14QiroBd6sXqKokeGZRCIokd6AmL6pm/6gqAGZniKY9h1TAaBIiVSEPgBENb6QAj2yDVxro/oQPiEEJj2HzB2GncBzioJzAqAEKB2VMDoWAgBBBAAAhiBTjiGBOqEDNCecY9MUpnTs3KQBbiDQMADJngDN4CDOF4xeY9mLC9ek8d3fXfuATbefvd3a95ihMea2G4I2NyUjfSDjSSEBlIEgTZGZfFxbm9tgif4B1yFa6d9nB8ntsP9/9yPhdzn/dwnxdmnfT00dVVYBT5MBd7XBVuwBZ4XslcXjsYKK6dnesRpNcQRlusvCGgouu3f/u6rhu8/IG0QfzLehm/4Bm1wBkng5Lv/4E8G4SW1XFJudsm+eg92aBDg6HrNhM2l8QgwgUwAiEIJApBIJEJCp08KUcWK9QkCAQECCEAIIQlJggQXGhwoUEABAwYHQo7sOGBAgQQpf0gKdKcOnDoy6/TpQ+gQopw6Fy1q1IgnUJ4/fTqCZBSST6ORIlGiBGmpJUxSMUXCtAmUJ0+cNHHFFPWqqVWpUr1qtaoVrFq1ZrFt29YWXFts4c6SW9ctXlh696rd6xet3laCW/+ZaqWqcCtWik+5OnVKMStZrWjRumWZly/MvnwFGzasmDFjyUYrU8bsdDRp1FZja41NG2xt27Z9q237Nu7cum1rcyaJAHCKICBAQADiR6BMgUAEUogAAXAELH+AQCCRgHSFyn8g75TJRYQ8nfIcoJIoU6aGsVAxjBUI+kQIgSAiWLDiQkaPIfeHfKCgwAACDJBRAiUEIkkedszBR0023YQII43kBJRPP/EU4VA9VVihURw2pRQlUUlVlVVSXXKJJZZQggkoo5zCyyijhBJKjDGaciOON46Soyk1+ljjjEECOeOPLp4So2NJKukKk5RZZlkvoiVTDJVUPnNlNNFMY83/a7PV5s038swzJplljikPmmiSmSaau922DWzYrNZMM8ogYwwyxATDiyusmCKKJ5JAMFFwCBT3HATHBcJdJp8EIhFxLC0HAnD0SaLdoskFEsICBQRAqEQFLFDIJ6goFIugEUn03HMXlLDBAhkdMOusCozEgH8ADhBAAQcQEMEdkghCRx+HHNLHH4Q8qBMiFzLy7CLQUrhhI4444hMj0TJylCKGGKLII+EaAgggj3y7LSTbsnhKL8xsU6SRSzLJGJNNutILvvni25lnn1EZmpSlmcZMNNBIo1o11XDpWmyzOTzbPPXMI09tbFp8MZsTsxlmbXBiUw010TyjTDLGFDNM/76NjQLKJpuE+wi5csjhA800f3DzBy94cLMDDjxQAXCgYocoq9kppNCjxgWy9A/FCQddc5kgx92ioQbwqQtidGqCCRFc+ol71kk0kaEggLACBQTSekACCijQQAVxH3DSSSkl4IIkwuaBk7I34cSss9A+m61Q11JrISNLHfWtIuC+TG65kYRb1Saj9JJMNvLUIyVpp2Gp5TQJX5MN6aRvww033aiuujett64O7LHLvg7sYp45Jj3t0FMP77zjs04779hDD+755DPxN7Rp801s2sjpzDLL5KknL5bRwoqMoYACyoiPQy6zzDXbfDMHHODMwQPl91w++g+47wH8HGCQwf8CEQVXKATIDQcdCLEc88snOlEd5LQkEy0ZDnGM06hMNW1pwInABhIwERcgoQAtyAMBkAC2ThRnbMIxWwlKECu11UoBD5hfBzrQAF2hJCMUwIMBB1EIRBjrb0KZUFCmZSENHQ4oR3lK4ppiiRNdwnHhsgoo2MWMbKgDH/l4hzfUEcUows51slMHOsxhjnRwMR1b7KIWy1EOd5CRi1o0BzvYoUUukhEd6zjjGckoxznCo476sMc73uGP4ymDZZh4RPde1rjGjQtygPDWHxL5B0Qq8g972IMe9BCHSU6yDXFogxmsUAQawOAFntQZB+KHAQ5kIAOkLOUJUogCEURAVYT/wk5x5OOoSH3iGMf4WgPz1pJJLYo6zelEpo4jBgQEAAAACMACWhmAIHxCOZdyyHuug53jUCcEIhjhR9z2tgrM7wQxkEEHGKCrlCxgAXgzYCISYaxmaWuHOSwctjBELUVki54gagpThqiJS1DiiC26RTGgkQ10eNEd//gHPuwRvIW6Y6F5fGg84lHHMqYjohaNB0W7mA41phGN7HCH8M6oUS+a4xzn6CI8THoOc8gxjfP4BijC5wM/RLKmfvCDIRJ500je9KaPfKQfEtkHPvABknP4A00jOYc4uGGpbjADFqyQAxxQtQYwuGoNZGAEIXBVCEs4whKiEIUwVCEEYnul/6ESdaCWMMqWmbiAJFAFAvQYUH/HkQR3vNNLqv1gIgkgQDGPKQAxlEo9v+iEWWFJHGqCIASw0uYJhOC+CmSgAyeQwRK6AIUOmKRX5dRAHtAjCUcYK1qOeJa1DCchnSSiWtbakIaAogiePIUSkUBKIyAhok0g8RS0KEY0toGPcqTDHfDgx0H3cdDlLlcfzt0HP/jRj37so7rKba5zs+tcMtaxjnm0Bx7fQUbhdbe7XCxvdyPaXeGBtx3yYIYcxjAGnbXBDW1og3zvO8k3wGEObiCDFd6QSSyY4Q1zmEN/EewGN5TBDAu+L37HYAUzkKEJOLhqJy/cyROcAAYdlgEMZP9Ag65CIQxEuIArPZhA45zqE5f6xS8KkQgYOwppS5PEAOeDnKWZbWlV+1UE6heRBHRCPQ35xDARhUDu/GAFJtBAAxrwNhVIlrKWlQEU2ECHOiwBAx3xyNsmMARJeEcSE2KEtdAsLWY1IhGpLQokeLihbG2LKR+CxIpY5CJX+EIZ2YgYPvxhDnjEI7r6mC6iE63oRSeauY7+x3Qh/Wh/ULrS/ujHpS/NaExT2nj4+LTxKHYLOcxBCZ0kAxnuK9/8ngENZ8jBCR7gAFx1k8MnoCoPetCDmt0ABze4wSdt7QH2ta9nPXMfsk84yvJ1YAQLkMinPnUdpyEgrg7xX0NeATb/W7qHrclRDnN+gAAk4CFvPcYxtI35qQUg4Q6NAltDJBEB6FBksSGgQAREoIIMRNltky0lCrDMBpoQgg9X4MABDGCABDRgAiQQRCe844h0Dm5ba9ZJhRyxlNtG63AgGmLLtteiexVjieqoB6j9cdB+rLzSm345oyXN8pk3+tH/sDTOc15p4+Xj0yh3Ij7moQ1MyCEONHgBB3Lta1//mqoveACArnY1uvXKZ+WD37BDWb5k+8x9sxbJAWZdElqFxNjI7sCzryYAtUtTAIb6mv+O4Yy5N4TGd/iBGNIDwE/gXbREkEQm7uoo7PwgAmu/GnDiuvdOBCE4bn9OCC6wgAu0/0AFFqiAlBuAASujYAaZpYMdZIiIPjQB4QqvQAc0wIRLdWK06TRtugZ3uGptPBLy3BCeL9Gyq4CC5M+4xsmdmPObrzzRcxQv8kGq/HfAo7hyRG93jdv8OkoU+uWNxz8wGlEyxkMfFs0jGYeHD3oY7x5BLwa5DDGHPcwBWZD8aSLn0AUGBDYAdFP4AULpgA7IQAY4eEMZ8BccsEEadAEacAEUcAECQsES9F8MYJiH2ZqtYRgN1IAWqMAFzNtz2M/YrEqR/YIz2NLchaCpaEd6HFkzBQIeBFAm4AGPMYejQAdy4IELhIAECUAC5IFCSEIhhEAEREAC0BsCZEQDdEAKzP+ACr1NlMVNZaGADUTBwDkIIczBDTyASDyAEaaAu5VZOtEQDRFOx/lEs8TTs7yBgfkBISRLs0DCEZ3CMCxRNwBPO+jOd1UXPdBDoCWUPVwUP8yRHDmfH0rfRD1f9AViedFRefWDemGUcUmURD3UO2CaE73DPvhDO8DUIQGCHxxYH/jBHvRUTfxBH0CBp6BEATwCLkTPMgDDJowBFlYWG+xAHaQBHAzgG3RBAaIBFqCBE1xBE+QADOCADDzgVUlgh1FgDXCSDdwBjzmNqmCHGPyCCC7DCM7dL2hCQhiZQ7gYSyREM9XV1ADW2hGACWSCIMAQFagECQRQFZjAvQXZCGX/xAXYAD2iAOZFWQOUUgc4YZYRXA1NIQ4g3P5BwREMQSFEHDrNUE40zoVUi1EIBVI8yxz4lCGEiCUckSuY3DpInxdRoj/cgz3sg0LN4R2CFx8GYkEF4kOp5DvMoUt+VCD6IfK9g3NJFHdZH/NNlz78QzroA/EwA7kogh/0AYIhix7o1B/wASH0gQ5kAEgYACXIBmwkjzaIQgE8AAyoQBiwARsIIBy4gRo0WBlEVRP0gBVQ1Q3kwDDGAFtOIFv2nw4sgecNYxgIQkvEEnGEABJ0gi1Fj9yNYG/MwhAZ1i8c2TNtYzMhx+D54OERQAFMAKq0AAkUQKP8AAVcQOQ5FgWU/9MCoEAC7oAMZMDmUVYT2kCWEYuy5MQhKMIh6IEVyM8JZNkRhEEmIOQkJIJs0VO0HMUiPIXtoYu3GEIk8NYfYcItLJE3bGQ/NGIjiuQd3mE7wCRE7UNNFlcXuYMXXeccpdE6pJE7fNQcplF4wmRLsQMgjtd3TRc8SN9Nrhc8KGI/NJ85cMM3nIIcIBIf1AGx9IEe9NQf1MEhEEIXVIACqIQWCEMtyEwzOMMsjMHCqUAiFAIb1GItvgFYlgGqkaWu8QBVqeU3DSOHfagw6kASQAFb6gAZpAEdFIIBiYGPZQIqvEI12tIxUCM1aEMzZEVh/uX/rMcnSCOMAVBzAJBFuP8YHmyElIUWFTRAC7gYREAAZoYAC7iAC4SQCzABG3TBDpxAKVXWPppmF4BesuBEDS2CIfhBGQDbFciEF4SWbeLmT1gcuvyQUhiFIlCOVIxCMAiUFKGDPUzXOXBX92GUS0bn8cVDdX3kPYyUGZnRFznqFpHnd6bRR6URo7KRH05UJdoDSL2DpMpRJB6aF3GDNzDDIwTVUM2EHQxVg/RBTNRBA+RH3TAAShzCCdRNA3xNH0DSAHKlAXIBGnQBFyzBFXCBL+pADiTrVEEgVTVrDlwBFOzAGdQBH/yBI3hj66EHKsjdalDDMtgSMqwGbEjP3N0oNoSgLQVpujYTtklCEPj/D4wNQj5mQB60xydUR3RUxA8ggRhUQRWIwR3cAR2cAQ6kUgeQwBEeQZgSnN/UUA39wRyYgRnoASHYQR0MQm16xyS8VlE0ArpY3FMYRZ7x1iOAQi9MwzyIQziEgztQJyVaVHrZA6WKF/VFVEgq6qJy0Up5EXF50Uqdg3leqtAOrXlFHzvYgz/gETy8w3nOkT+IpDuEQzd8gyvIwarygR7o55Y1iCgyCFd6hEdA29oJiNotQFwpRCfQBFf6ahe0bdtCAdwugdwmQRPULTBiGFo2nQ7YQBfAAR8cgiVwgiigQmEa0I86g2s8T7neaPO8hjasxozS6P/A2OTGgjSGYCcI/0Ez1dIxxMIdwAfZ5A/e4YEglG4e6CcXxACHpYANHAEVaNmq3sSyeCEjKIKyeCIh5FQdnEfESVw6JcVRJM5t6VbLSMUmZKTm5AOhxQPL3VzSVhd43ewc5lHNOldIVuI93MMZlcP2kpQ5ZFEWqZT4mtSlatH4Bmo6nG86wIP3TVSgxiQeuoM5iIM3UMMjzEEdQNIk9Re1iqIo9sEkZMIO/AfY0o0B42AnFObRnOOEcqWrnUGrIaDcLoEOxOUE68AM9J8GN6sOFCsa6MEiXAInkMIrwAWMkfAxxIlrQK7zUIPjNu5rVOO3Si4NS+7lSm4sQMR1TNtxMGMhFMIgiOIcWP9B/82A64YB6NmEIQSoDQUFIS0Sa9YBIVwr2mbCxroZUjyCbz7FJWiFVJyCMWhDPeTDdDFvpC0XSJFfz30aPYRX9IakPWRXROmDGInRF53ROORxHosROZRDH9dxOYxv+prv+apvI6rXTfphOuChP3DDOGzDMMjBF9TBUl0S/vZBHSSl/3LCMbzCIIxARtQN2CpAC+gdCjYTHtCBA7uaAqbBATIgBcvtDMxABaulMOLADORAB3NBge2BIlCC4JawLQADMMwdNTZM4/ZGNVLDMhvzX4bgDEvu3NWw5HIQ6DZmoiBHOhWCsfTBG8jlDEBBF2iZPyLCEpfWszQOIwRncB7/CyFMgjc208Z2rBYbRRd7glSAwjBIg5iQcaJlGqeJpO6M3x3mg0jaA0iCZNLuYXqRbxetA0Sjg0TnsUQHsqMWlznYMUlp1EmxkRl19Ha+Jzyw1Hqy0UQZzz/wwzhoQysqyBzUFB/YwZbVQVAZi/98q0NkQh7UZR6waMQdTYu5WBV0pSu7wRlcAQSXwRhgAVNbQRM4NbJO1VT5GgzwgBWQwRscpSFAgiaQ8F0AAzE0Q2zoBmxAD40uAzEIg2EJgzDUqFnbMA1TLg03hBgMhytJHdkEC+B1MxzsAD3OwBlMKBzsgSimIRQv0rd4i1AiFU0ZgrIcAjyXSgBVgiPYllPo/4ERHa80fIM6TO/SPhQ7tGRLviQ76E6huuQdftqn4VGnmhQg6zFs6zH3wtEWZfRsrxFtP+pGY6p3el/TzlE+XBo/qEMyyAEWUPJL7wFRyXT/JksjyF3nsiAP6pIuvRtQK0QeEDUauBpSl4FSLzVZQvVUM90L3EAPkIEbUKxwaoIovMIs7AJ8EwMyNEOX1IZsMI/zOIMwzMIvvMLgGtkrvMIuuLVZR3Nb06hcO/P/IJnTdODYYkewoEezHAIfsEG0ZhkaUOtRKssfcMIuaIIheEIqaAI9sbNWf4uxUHFDoIIoaEIkdPHLPMIoJMM2zMM6UK93jXZpF+qO73h0PieQq/82G7ukba9sOOSxOCR5bO9xHYeRHec2bYPRGl1nGnXfeqJkOlQipr3LB+jAgb20HuSnfsJBJBX2L2jDMqAKdSBKpCSHd1j3qUhCF7yBK59BGVxBGViBnu953W5os/45D5TBghzCU7B3e7w3WNvoa9RGNDDD4y7DLhRmQ2SCJnhCe1gugVcjuh54XIPgNEtjJ4gbq9z1pyBAHkjCJFRCF1K4K2/3ls2BHSiLIaCCMIRCJKQCMIiCJayCKNRuGqZhOy9xI1SCKFjuL+yCLcCCKkgOJvQCNXyDjQcPea1XdPq4eIpneAo5QePhtkNnORh5OJTDOKBDkouDHpe7yn47IK//e25r1KPqNhmxA/MyonFRlDtQ2j/UAzQAArDV4ksTlUwcWJn/pycw8y/gWHGYjaEQUEJkI9o2ExekgSt79xVcgRXoWg/UbRPogJ//OVX1QFMVy7ZUOinEKH/vAjEsw4I6gwu/hguHYCqwR39bOntMrjRSo6Z/64FHM4KPYOf+Ah4UzTVLGwLY5SRowsQlAiIQgh68gRoMXB2sqh34gSW0OCbYwi5YwibswipU+iU4NjszziF4SyNcgijMQlsTgy2wzCkoA7TXAz10KvNRO6WOZ7W/pLZre2oTNDiAw8qq7Mr2PboP/uDDth3f9hl1FG13lPO9pz5g6nVGoj/ggzz0/8IH3MAJ+HuYz0R/RRKD9AEjQHcmREAxGQoADNZaFYLlbu6bewEuokHF33kP8EAF174ub/x4d9ILwIAOTFh/vYFSIgIkdDEprMIwCwMxEAOe4AkyHDP0UGPyC4MuFDNbV798N79fSi7Pa79+A1DTGMqoi63bJcfRJ30jHALEwgEdhEHU14QfaKInAEMqREIp7MImaMIsvAI/dQsUh31w3ilAYAI1cBOoYdvq0fPXz507dg3dwXP3jl1Fi+zatauYUSM9j/hAgsyHzyO9kOFQpgS3Elw3cS9hxow5bpy4cOXM4TS3k2dPnzjTNdTH0F06o0Yn/vNXb9ujDxw4wHkzZ/9OHatW4cTRY6eOHT6zhB2LhYRAAAEQCCDIlClQBEmfOnX6NDdWJjZc8F7R24MHjxw6AOcQLBgHDMMwXpw48eKFYRweFr/AgWUOIT1+/hhS9IhzZ86hfCHTNhobNWfLqBkjZox162DCiIVdduyYsF/Cwh779evYMme6O4GAAEE4BAQEBCRPjiCQpEyaJjmSvuhQHztrutbpQ4iQolTANmHaNcuSqF+iNM0itchQ+/aEMhsCpAdQ/c6YNvWaNo/eUIbs1nkoooYADPAijTCih6N2PgqJJI5KAkcllrqp0MILLZypJnHGQWeccHzqCUSeQCzHKHPg6SeeoowS0J1/8pn/xxgfXnjggTfegAMOOuiwio864NDDOh5RoU2YWD75gbhA5JorE7gy6QSVWHj7pA4ursDyCr76GowwHMAs7DDGyDxMMcVyIMONOcwYY4w23pTDzTbiaKMNOeQAZBNWiFkGm9G2KU0aZpRJxhhDiYltmdloa9RRZyBd5pdOAoHghx9AEA6B45RD4IdAopREkugcYeQQQrLj4485DkHFFks4maUUTFrZZZNSbCGFk1U4cY87Q/4AxA/67Hskkvy0mUeehfohqqKGzjnHnXWoNRAjBBlU0J533rHHnn3A9XZbbr1laSVu0K0QXW4qFAfDmWDq8MMQSRzRnHDSAcocd/rR/6chpIoy5x98vtnkgxNsdMMNHXm0isc54HA4j0M8EWaX3Y7p5Mm5mvzkySmPceaXT+zAEo0rdOgBhy4HCzPMw8Y0LIcmmjgzBjKo0sONOe2MI44xrCjCCit6uIEHPfKMBJRW+qRmtKepaaYZZZAxphliWAElZEYbhfQ0sSQJROxLyQYBOQHS+sE5R0YllRFE/thDDz0yI4QRSEKZxRPxZsHEFmBCCWUXUjTRpJFTDSHEDz/qq88QzjZxBRtl8WG2H3gk+jfadNZBBx1rMdqoJG/J/RZcf/wJF1xzV8Kwm3Qr9CamdmmqvUN6zfG82s7RAQqpePSBZ9+NxmFnKWoe2f+DCxlewHHHhuvosY6q7LjjjkIMSQUW3n5ZK665OKaLt2NQ+YQQLrqAQoccwBya5sDYd/nlw7z864yI+VC1jz/479//PgBoHR/xzxDHGkUukOGMP23jG98gzTakIQ1lwGIXfsKG1zDojF14LGxiE5WoQIAAtCGgComQDqkmkUJLWAITnMCEsIYlildQwhPAKMUmgGGLTawCGJ4QBTBQoYg98G8PRYzDC3zgA/uAIhneUIc61tGOfwUFIlREBzsURC0sbgRC9ADXF78oLtOBKyUpaZe6YOcNb1xIQxyiCe469DneocMcJzpHOuChj3iYgyLj6Nw68DEPXwDiDVDAwQn/3PAGHi0yelapSh2slwhUUHA3dfGek+gSC9rsZi6DWEL6vuS+JsBPfvODWZh0gAY45I+VfBiWHly5uFfywQ615FHE6sCH7TyOEpsYBS6apo0GNhAbxvCFL4zhtNFErRnUcOYuOhG2DjqHLYH4gQiZI4k/HGIRJhSVIyiRCmdowxmtUIQeFGGJSIjCVpsQRiowMQtYbEIVtgiFJzjBCPhwZ39WSKIcHrGJg0CRWhmBVhV3okVsZYSLGfEIGCEqRtKVoxxlFAc33PU6drlkjWx0l0zeSC+aeI6k46jjiYLiLXNUpHjrUMc8toEJPaTBkC9IwxvYsMhbUgUOOeXRH2yR/6gjHeMTb/HYJ3gTCyrphpOxSMQnDRm/HvRglKQspZjE5BgcXEGVVZnbVSA2PT3MIQ481ZFUcjY3PuihiIx7HCQwMQpaBAMZ0tAGA7WBjT99YxujaYYC82oMTxxiEIn4hFLrUghBWBMBISgEIebwB0IUIhGiSqE4+0oMTPDPD5pYRXnaaQtRbAIWrdhEKvrWHkUYAhGNQMQXxpCnTRQjG94IUBTnIUV3SGu36cidHD93LeGKDh/2iMdxIQouPR4XHhVdCUpel1HYZdSjMnGjvXpSO5J67qRHeYg92PE5jajDG/IwhhxmmoMb2NSnOmJDVsp6VjrAoQ2gUEYzLDYpSf9o7C1KPewmwReLTnySC3+JAQ4Ak+CWrQwH8SuMKWWggzOgwXlwgJiOcnRWDLuhDGQgg5vKSpU5sJUqQ/wD4wChiM3g5xS3IAYymrFABz7tadhABm7CAqkjvaJ8RZVEIdagBjbYoRAfHBUnfmgMUwhriMASxSwu4YldeGITswgFJmBRCkuolhGRaMQiKJGnR5xCGd+Yhx8LxFAqsohzc7wiQ4fLIOXqQx9f1Mc/7ExnfaBkJTDZqEa7QRPXZQikZSyjdrfruaP41hwM8hw9xtENeWwDFHKYAxnIxAZNsyFH7/WZhnXkBkAkgxnN2EVdmtMc72lSLEiiyyfY0IUu6OX/wAle34K75LLD0IDXEeaCpm+Kozck0g1oQIOmveAFWePlDGdwg89CTFa2zk2Wf9CDVtBbrE2YIhd9UuCfnpaNvZLGNL/5BY89UYlD2GEKNhiCGFTdiUpcIhKcOWcczDA3Q0BCETLUhCdmwQlPvEIUnghFJADxOM+MWRnbmMc8SEKtNTM6WjtJBzvMEccAcaShGbGH5fCc3OMCj6IomR2GBD1odlnX0ClBdKKPwhN05CO86xiHN+ahDEDEoQw9IBMaZM3pnsLh2RrWdJBuEUFJfSLVztHYYTn5vV+ggg5Q6AIXdnDg+n0pTA7OKgxoAIMDc+HYN+Uw0PSCFy5AQQhC/1gCFLjQ7DO8Ib4QI+sYoH0ZzEx1DDggmhXGcAO8++ERcb1FAp1ZjWoAyoF6NbcwXkEKT2SiEHhoQQgwzwIxGLUTl4DEifegBq0Maw+U4IQlSPGKW6neE6jQhOM6E7lkbEMe36iHSLhrlGhVnCdHKYfuNt4OA0Ho483qxz9Cjnw865HOO6monzHarpdEetDSj0kZszvSRJO0J+JQ0BPlMelTvIkMPLjBB17QBSpQoQtqwCkb1JDI9/Y0DGFggyeWIY1mLOMViwVVXOSiSeJiSqauDqxuCWZABmJgMG7N6+QHZg4jBmJgB6AA7rjACthH7HBgBjhwBrou7bCkDIzN2P9uCgdUZmV64ArK4AVuAEyKhgd87gZ64NnwJKBUYReI4b4Ghcao4RXOYBKUChUyIQ+U5Dg2BQEshfOewxEIoQ+ywg+0gj4swRMoQRREARIg4RJWqz04AxNOIRnM7PYcBB/UgY52b3N+CynOIRy077a0SHS8BXjq7IuUbx/0rB/q6F5eYl3YZUPc5c/epdDKiKLK4eV0h/t2QryErxvm4RugARB4YAzO4AZugAM8QP3Yz/1iTQ3UIA2Ejg3qjw0uAcak5hc6KEo6Bi64h0o+4Q6ioAt0YAMX0Na4DkxgQH5oQAbETuxigANl4GUS4wRiQAElkDE0MEyuABnPIA3SAEz/JFACFeMBPMASGWO9YLAMzqCs6KOAMMETTKEVfGEYFMgZqEEY6iADUAAPNGYDCKAdjRAJQeAH4C2aBkESHKG1rG0OhiVYgEURGAFYGifFHgcUjMHhbi8fUCcfRgIfOicddg9aMs6kooUcCpEm1sEhOKdAKsKL3uG47kz56GzkgOcfyIEi+azPoI9d/myjxqEPa+clCLGiUoKieKKiWoqOVopaEFIpxoGBTsEHJPEMysBNsDHoZE3WNPEoNW0JxsAQiMGZ/iQW9ut7wOcTaENkwEcQwgAKnAAGFkMv1ifBroABfTEBZeAsz/IZh5EYJZAX0TIGdtExeG0uea0GlkAL/+ZPKpiRGUcQDfgSDeZOeuaGbggBzCxhE0IhFXBwNjRhBhJgASgA80QoLYgjHslGDMTgB5BADPDgLUShEprwxIYlDvYABpKgCGILT+oDE1yBGWhPHqJIigrkiUjKIUtyImnSHKKFu3biju4IJ9iBWziSzo5P+VKnWVLEH+6BIksuHFDyotYFQ2An0GwHJmJSJnOTEM0BiuioQNYBdXjyG6gBEICyDMzzPJvtKIOOE9WTGceAB+JgFy5oNJAEAOMiEyRBkzoBOOaiEIYgCmoAMTwALG9NB1AGMK5gBzrQLGXAF9XyQdUyLiFwQg2jBpLACdTzKNduCTi0Q1EGBOPuDP/mJjP8kRL+LRVQ4RJ2oAIWoEU3pR3TAgEs8zIz8wfwIA/2S1cSAT4MYUQN4QWsIA5Usz6+UJi2AecUhB2Mglpok/to8hxKkhy6bxwo6gwrbiLeYTj17ItQpx/4gc7oQR0oqiRlMhxiIl2oD40sxHZe8jrdtKJwQncAhKTAcx+6YRt6ASjHAD2FMu5krQK7gA08bC/TwNjahxMgBRuWgYNEpTn2Sywq4UiaJBOYgApiYDEGdAe8BDB2gFMV1BfRMlSHEULV8gQo9FR3TQc69O2ggEMBg0Fz4BfDZAGvYGEug38O4RAqoRLq4AQqQAIogAKOgzKNAx7FJhAw8w4u5Q7/8IBJUKETqEMzthAQUjNP5AATegEbtuFIy+v2dqdz1CGOuIsQo5Q5m3NMo3RzIOJbusUOtxQhvTQe4GEcoAFdm9MPX8J1otN2qJNKS+5N/zXjuIukvtMfYMQbqsEpiFIFm60M8OJPra4LsIAMSLBQ0QAGdKAJCGEXIEXAOqjprFJjyEculEoMjiABFaNTN9XWdGBBGbRBX5ZU25IXUZVCz3IGAGMJWrYDQxXBcODAfjYHrmBPQwyW+sAR+KADGqACIlNY23E4oBYJP+VYa/RSmCQWUOEe+c0zAhJbpWFbudWJTIJatos2Ryon0JVMz7VKoZQcNoeKusXjQtJbdpIo/6yhF86hHNS2TGUCo1LSuqavOVsOJ7BTXEfqO/vBH25uGHzgA4ZmqlQQSx72T9EHCywXC8jO2DqgF9lgP4mqUR21OagkSkAGqWLhDthPBjKgAxZULDfQS64qTER1Zg3jQU21ZmFmGF02ARcULX8WaGuNB9REYaaiDvKACjRgASIgMtGCMjOlOIZjapGVbC4FRxPhEDIDE7QXPwJqFHohGmivHrLBQtQhi+aoQ8yWQ5qzXNcWJdLVbdWVW6KoI+V1IuCVH+AhG4rhFOyVEE3uTPvWbwG3jCRkENH2JthUd1DHTrUBEyzxcVPQYbNk7SJW7S4XL4wtA04ABWagEA4rbP+i6Vib4xekMi40KanyoAqGoANYOFTPUjDOMnZLaXbhkhcfFHdhBi3N0kFhlkF/93eBdgw4rAxyhA6YoAQoADJDoHmRsDIzBWrj8Vip91KIYAgWYwwQtRmkARusARvM7OHwIR82BB0uauZ4R7tsLnBTgn1bDhzKtVyD4h3cISPeAXMk4uMMFh7CIRlOYRRicm9nks8Ad5AJefpsh45qxxvo1B/aQR2SwQccgAOGRi8il5L1ogIrUO244DzLgAM2+ATuYL8EIQ+i6WM74RfEpkmUyhlioRBswAZQAAUywDBSYFTBBGZ9t8HqR4YlUHafEYdv8ZZdOC11OC2B9xlxoAX/b43szoAEFuAxKcA4RghqK5Oao1iKycYFgKADWBAQnKGB5qEexFmcw3gfgmJF2iHizLZ27gUlZLKAm7OAzeWN3VZKISIjRPJbDPYfwuEZegEU+Hf3StL5sFMmC/mg3agm2HQd7oUmyrAMFVL8HMBGmiAF9UKCLZlVLRAvyoCSp/EEOiAMikxU1gI/w+awxGZjkCTyKoEKhgAFNKACSGCDUwBmdaCHG5R9EJSSG9ABXSZUgfnB3nIthzktNRCZcUAyxIQDY6ABHhMBFoBTmhiKi+N5LRObf8AFbEACe2AMTuEb5AHiFlIk9uG4PiKLxqEMPcR/b8K54PkkJeS5wqFc/9244uC2jjHHW/ahX95Bf0cBFPz4Td05nt/ZXASYkGkiXjYkpNB3pPKhHmDqERgDAyZZLD+UQFV1B3ZgL3pgaG5AMGYgCgorlJ8OLvZTKp1jLlCBx8rnpTVAAhpgpjsABdbypjmwUw3Uki1ZaAs0Fq9KAb/OMBojmMEEtDtQs5H7U29bU7vuL3SgDIoNZRCQBBqgAZbXOIiVmqnaqq/Zmn6gimm7B9rgEaghrBUCHdI5imwOHZ7ooZ2IO9HWXHPzgJ1znst1IuF398zh+PiBH/ZhJPwBHsgBH57BFVzhFHwBYNuasAv7XBCaQzREuxy6SQPJvOTgBjzgASb5QMGSkv87FAooEC/GgAzMwA2sgAzcrw4SYRLygJThAnyISpXHRzdQAQ9WIKYVgIU7gARou4c1O7c/1LJzmxblRzACI7hhYOuMe7l3YAma/FORu6cTzDyx5O1QwAIUIAEiYImfVru1m7szRXrvAAlW2GjaABC+eh7UoR0+R80bub3hvEl1M1oEd7DL1L7TFTd3jyYvhx/iwR/y4R78AUqtgRcOvBeYAW0BVnAb/FzQRSZc4qMgPMLZtEnrofZAwQcqEQOawAow+7IpGS+gIAqOLUfmRiv2YH9WvBDE4EkuSWR2gzeIARZeIakKAQqUVgFWd7ZTYEGbfAlCnacNlGimaqrgZ2X/9SJ2+2LZeaDBfP3XZyC5n5xlAaMHyAALOtQGNKC6IRO74RF6vRzMrxkPqgDXW1BIR00evKFDOie34ry9Xapz5txKzwF36FxvY3JzdMIn0sFL++Ee0OEe9sEdxGEYTsHAkyEbanLRsROuHd26Ij3SYYJ22HTCPacRm0FOXgAqaObTLZns+HL+RgwzMEOy7KYSWHxjvkcs4EIUBM4UdoHGHYENYiADYpsEet0GkPvDP163+aLYe4AWWVYvmj1Miv7omd3Hof3Zqb3Yr/3tjgAFJuAxl9cIndjLt9uqyeYOqqALGIMH6EQOQEEb1kgcwktZ5CHOq+UhdE+/9XvhezNv/03ESvOwuyCCX+LhHwBeQbqBj12BFWhrHhb+OneiXOm7vgeZOvs1TRd/TeNIHWqPFXygDTb+AaiKQD+eC5gxR3LEq1SFf7gjVyOhcOqxpFdNqXSl1oMQLvpABlj4lW3gCDhUL6K9yXWbkommL6aKaJreoone6I8e+Ju9dROMZxsUMGqgCHa6s82ADCpwBrY9ARIgmp3Xqokj3MU9HsWgCriABY0mNQ/CG7hhJ9rh4aBoIyyiio7i7tn/ItgscyJCIuQfHkRyRcg40O0hiqDhFPi/F6phWQDCXLmBBAuaI4eQnMCB4RqGEwcxIsRu48Z1o1jx4sWKGb15q4hO3bdv2P8ejWnygoODHk2uXNHh8goXLmjSpHkDZ05OPnz6/DF0iNChRY0gTdLEKZGgQEwlMf3061esWKg6fUKFldMhNSdiUKESJQoUKC5nzNixRObMmFfGWOkBt8fbHjp09MhRtwdbHjxw4ODrt0dfv4TNGj6sY4YMGTPq1qiB1yVcM2SgHCEhIcECChAQEIAAIrTo0SAggCY9+geRITs83HhxY0wbH4+ieQtXzpy7dfjauXsH3F26c+6KF4eHPDk84PbsAQeOPJ704vH0Sbd+XZ91e+2yPeNG7127abdAjaL1TJ6/fhULui+XkBxBh+DASZSIcaNFjRohegQZkjff+CLHHDT/vPCAA1Y4sUSDadFk00056UGhH38INRQijjgySSWXdNJJJoUwRaIkn3wSYiYhWvVJLKIQogUXOtDBRhddQLHEWDugBQVNaKDBxRVWjEHkkHJZMRdcddW1F1+ABTbYX34dpthijVVp2GN4wQSXGmQsYUMHCWjWGQEIoIbaaWiG5oILO3b1Ag49jOGDD6dYIw5C8LBTjzvJ+Qmon9FNZ9xvwRV6XDzwuKPPP/vs4+ijksZjjzrXFJMMN++EUwwm5hnjzXr9vDeQfPDF555DD90nTn6uuirOOBBVZI45ImmDyRhw5OCBAw5gwaCDXET4Bk4T8uGHT0Ahwggjk3SIlCei/0wiiVOB/ABCIJJkUm0m3loVyy+i9AFHGlzQeKODOAqLBhZckIHFkPE2gWS9bzXRAxZXNMGlS03woAPAPOSAw78EB6xDDjXMUIMMNDgsw8INP0wDDJAtuaSXYF4w5gKenblmyGi6QEQXO8TQVQxx8uCDHMp0w0047rCzTqHKKQqPdDrrrM+j6z3qXM7a9aNoP//848/RjxrdTz/7XDONNcV8N00voIDiCzb1NN3POafGl1CpuYEdX33ghGM2q7PKujY69OTTzjr7mLPON8jI4UYaQLq1oBNOWIEFGZSZ4YYbb8zBkx49XTgUJIxQQsklnHhCClWSgFjiJ9xueyIqsf84s8slh+yhhxt10KH3WA0m4Xfrrv/tBLBNwA7sggvKnkQTudeAA2RFKIzD77zzXkTxRdRAQ8UwwJC88s1HxmNacKhx4wYLeEyAmSJvzyYQQ/R4hV5llEEkGbONso06XPdjXXLS8ZMzP1zzo08/ompn3frs2wNP+/DYs498JO0f8egHPOQHj2dAgxm96MUwkjEMULACGdK4RgH/cY4MajCDCMngQGoFNrMhRFUNURvbYsWRcViHHvRgBzvUsQ1QFAgOcDjDGHLgOsAJTnCF2wkf5rAHnwiFKIuIhCUkJ61XHAMVV/lEt6x1Oc8dwxm/0IQiCEE605WLC2PBEeteB0b/v30xjGJMQvGSgMYioNGMNTCj8c74GOQ1b47J01IO8IKWBumADGlgwxEkgIBAmklN3FuTC77HBfKNjwxkOIMjy3ADOSRDPUb7Rz/4sbP64Y9rjvKHqCz5D/k5DX/O2cd27EEPfAywH+m4ZD+u8YxkJONqo3CFK0ZBDF8M4xnjyMc+0gHMdJhDg+Ug5gc7uMFzIGQ+uBkHOp4JTXSsjSPi0I4/7PEQdTADEHLQAxsKZ4UmYAFYsQvc4NRQrDnMQQ/rXNwhmHWIRkSOE5MjxS6Ogc9fMHFFqPgFPpexjFhoghGH+KEazPAGvV2hi0sgIxjRWEbWQdQJa6xoRYvXRjee/zEJcexoDZZXRy3hAI8uSVgarjADDSwgAh8jJAiwVUg2HRKRZUCDIxnpyDOQ4QUf2ET6BviPngENgP6QlM+Kug9PAvVoSN0HPezRVElV8h9QpQc3ntGLR8gBE64YxigecYphWK0Y+EBHPowTTGCeYzgaBCE5MshWr52jVgKpVTTRwZG7PnMcSfUHO8LBjW+4Qg4FYoMjeTCGcfptnIwUHDpxok4g9kGI7zTEIiBhiWiJQhS7IMYxloHP0C7DGaC1BScs4bg/8EEPgLNJkBj6OnKGcYxjdJ1F04hR5L3xjTXgLfKYR4M40gAHddmBS3YAkyvEIAMJCGQgXfrSmIJgBf9BGAIVujCTMuQUpzf1wAd8UAx5qDJSj6JHO9rBwvSmsh75AGBfl9pUfKjSqPoQJQH9QY9uWAMap3gEJm4RDGS4AhTDUMYzijGN8/oDOOf1DaIeXKh0sMMc7IhwcdaxDhfSbB3ocCGGP8wOAfbDHNzYhjS0Ggc3wOENZEASFtbFFh9JSJ116AllD2EIRECCEprd7CuAgU9iIAMZxBDGLkqxCUgYghGLIAQ730Bcvb1WdQ51aEUpmsY1YvR4Hu2yl5PHvMcY72IxSZhMljsmBHTGNKEh5A/eDFM0/QAIQWDCdc9gU0eioZHbJcMDPvCBR2jDG/mgKgvxYd4Gnze980j/pSm5Zs2iNgeVT7XHPazDj0y70h3jgKUymOEKYxDDGLcYRTKu0Q514KMe7UjapLlzqOMoR1A5o5RznoNrReu6HRpusC+7do1t9KJl6oRDGRhpBdWlJcbDguwc6lDjGxNCx5GLliaQIgpSqEIVpggFKDABCUX8gZ2r1QkXcBCDGLDFQUu4bZZxe8bd5tajwf1yvR9DxzkCt7fGY1JJY3KCBjTXudDFFpzjTJo5I6EK2LUpGtxgU+46sg1tcIB3fTAM8V4Tlahc9KJZ2A55oPfR7NNOc4IjHha6N9Oall8+sgGNYgzDGMnwBTFwEepttLAeq8bHPkpu8lvzusLvsId0/4JZnKK/mtKJjtuuny5AfpjjGtF4hA/ioE43wIuR6/J3TKxABjXQkIbQ5olP/uCTdzIiEpSYhCMK0YdDOIISlrBEJCLBCELwAV1w4EKDZJDuE2zpjoT3MvKE2zzE1xHM+r534+kI3Dni+97Fu2P4mHSyClzPMwL4zEvfHBrQHxw1PwgCEsLAhjSMj+J4RoMZzODIwrmh4hxwzSOwMY9rxuMdlMq1ojOsdEk15+np9fnP10ePccSyF12FYDBO4QtmyGMe9ajHPKh/SUgdLVLOaTAAh1ZySXlSUvJFdD4QrV5dN12A8AhHNorhgxvIfgxmeMsYcJSYLSUXcGZQg/8lRP9DkTUhpGMhk1UHbBAFdUAIfUAIC3g6bACBUaAYOrAYMNABMaB/BHNH/MZlveV4zRN5FQOCIOU8I7g8JwhmIIWCwdWBHWV5CdMDXCADHbAAzUUAAiAAoPFmTAF6oQdnCUcEVSAGqVcGFGeEP6IGaRB7s9cGB2BxN+ADtyBe73AcuJZhHkYzWYheIBc36yBy8gCG8xCG1zcP6LVq83BgzAcKvRAMvKAKuOALxVBB0/AMdSgP9MAPR+NKTYM0+9AO84U/+qBU+9Acj4IP+XB+5idfh3aI6qVeIpYP3zAKH3AD6hQHbTBOSLIuVTJSbNEE9GIFbOESDWJO/WcsNjKDKRD/BTUCgTXiBa94I10EBTtgFovhF4SnA/WmPG3EgSkYeSvoiycYgownjCpIgmD2W8VDA02ABoalAzvABTFQAZrhGYP0eT9AIj04MkFABF+BZ+YjG+bjSEm4hBQ3BmWAE3rwCNIwD6okQIiIiOXXc9VHhvUohvcIhvJAEtggDczADMlgDDLXQKdwCuZRS7iQC6qwC5AACI8ACA/ZkMwwD+3FNOvjKKlUVP6gHbZ2cpPmiIdYfo4okm+DiPVQDYDwAi9AQ4VjBoFTGQ1Si3eEMfr3Ev7WIDrkWAdlEzoQAzMQBV1ABWxAB0NZI2SBIwyVGGYhk8k1ZmLGW/oGXMfoi4wH/3mTF1wiuILLo0bx1ltccAZ6sQM2oFKCNEhsdo3YGAhrUnpEYGddcAZFSCRjwF1aoIRnwIRtABdoAAd6IAeu8A3TV48jsQ3ZgA10+I/JUAwCeQuuQJDfhgmY8AiR+ZBywE1yUCeEJQf+pZmbYAq7YArAoAltMAdtcIlx8JCboA2Nxg3uIEp86FSHmFT3IB23ZiiEWHzxGJIjqV7+kA/1IA/DdgMesGJucFBY4BZjcQV3NFL6lzC4uJTqMhNc8HpmcGxv6RJj8T1Q0AVsAAduUAajiJRJuSUx8Ubwllv1JpX5FlKR11FTKZX4hoLHs5VShlIdMAEe01KmYZYHdy0I9/9SQBAFQemWEzc+x9ZYXaA3Z2CEbUBcNTEHlHk1jimZk4mZdFInF4qhgHahmMmhlPmQDvmYm3A1oZALrQALsGAIFKJafIBjkfAIrpAN16AO4mAOFulUqYQP9yCbtkaFwFFejJgPupl+Dcab87ANVvcCHmA4b6AGWjBOV5AjL0F4zIkxSwKlOdIjNtIF/acGbpBTZ8AFYRmWKWADUZBnbrBQ4YkxbFGebqRR7SlchidmIeVb9cZldBRHIGVGsZME+oJcKGABm5c9+kmop3Fw2AIaLvADVUAFUPCTdamgbbBIjWUTOmWOYwAwVwAHccCX8XcDn/oaoJqSMBADI+Ukp8r/Az0AGzcQB5aQCqRgCqrgCq3QCqVQCqqwCVr1CBEaCt2GCcBgC5igCJFwCEPBIZYAmbdwCtmwDdzADlxDiB/nHDqzHEp3KBrGDg2WrVvIhYrmD/jwDcpgmR/wAOOTBjYSOGiQI0tAi4aBMWfkBJGxUNHZIzMRIXqTZ2cQlkAABDZgA2MxE0CyFmU2iuzWblrWWxrVlB1lPBwlpxw4b3IUXMXYW4/BPPLpBDXgpyilARGwANlzJoWqn6IRZyvgAqZXBWygk285Po4Ul431I2QQl0SCAydBBm7AqXGQpB7Aszx7Ai+QbumWkqtKGH7BAy+gqmNACb+wC7tQkLkgC6ug/wqzEAots6vfdjWPsAml4AmbYESU4Dhsx3aWYHUw2qzucDTDt61UuChJp3SFomHrYF7Yumsa5g7f+g2nEH+9UjjYxUXusq7I5a5LokZ+k1zRORP1OiwRAoFaOotDwBpHIIsPEiRqERMG21BiJGZYdlEVy29fZHi+NXkWS4K/RQNbyWUbVQQJdQYmYz35CRoiu5/YKAl3UAV4UAfd6Z2PpF0yO7OJxQW/e0NNgKmk6aUnoBIPoLy+8gAc4LzK27y117MecALIewIe8AJjwAmkkAo+AAiyoAqhkKuG8AEP6b1a25ClsAur0LUuagiG8Ad+8L568AcfIAfFkA3egA5HU/90Q9cOVFgc6SAoAOy2xjF02LqtcZth/lAP2AAIn6oSfSsWS9ASMnFcyKUDetRurRMTM2EjHqyl27mdNWIjR2kWNnAEKZzCUAAkLjGwV8pureOmEaVlbLRRDhtH8sZba0RRZ3S6GAtG/ud/xdIFYvmx1miWpSG7PyAG1ZIHdFBuxSJ7Rlgk9eIWQjKzZeAEMIBYguGoHMAABiDGY3wAZWzGDMAAB4DGDOArDvAAacwAzdsGw/oIoQALpiAKnhAHLRMJeuADgaYIbSAKs0AKmnAJ4Ra/etAGepBidRAGgPYIzLANrfYP/XtewbEoAuwnE1YrCGy3xVG3GPZM+CAPBOL/A71yAK/HRTiCJEHCbnWRBAd7ZVfgBFyABV2gBbisy7lMPSNcI0uQwYuxGCjcIFAAplD6bzDsIBG1WMwMUQorPDnwO7nDOp9LzbOjO69jMXuKBVoQO97sBP6nBQcFB2yAAgtQAIMKXbILASEgBrhbY37gB4pTbCnWBmbQBr9rL1ZsBcUDG3xxMmE8AANN0AVd0GOM0GTMxg/gB10LCqHgCfRkRX4ACIqgyI9JCZwgOsVKCONWOnGQYmVAB2HQvD7gCtMnQEylVJ6kP1yz0vC4VEjjSfBI0/XwDTFEWOFkBdQTFjMRL35jBEEt1EGtBEog1ErwBE7wBE8wBU3d1Fqg/wVgINVrQD1607hgIgMpIAP+KrmO6tWSu67LphZcEE539Ik6QFxVyiRLQngjRVwsMTCfSDBGmwM8EC/jRDDjBAM4gAXihAMwcEdWoJxYUH9YkAYz0AECZ41pIrIUAARVAG2RhXWRxZKC4xYswRKA42KNddfG2VgthgMeEMdunMZmbNprjNpxvLxu/AKkeYmCAao30AN4+RovMCRlUDhvUDj2bIRLqryRNAzt6Enbx1QuvdK8CY/lh4jInYjV59zUJ4bfYAyV2QanqwVe0NNQEC9FbdRD7d1GUNRO7dRQTd7lPc591LiWYQMzgMIp3CBRkMLsfQRngRYd7NPhRC/xEv8Xn8jfFYwxqeokgmG0/L3PVsAXbkEwe80BZpCS2AvYccLXLQkHaKADGaAAHRMCaCK7IcACVQDFpMNOkaUTuv16xTkvLmEv4xQvBV4vOHACbxzHpW3ap53aZ7zGCdLGOd7G0Ft7sPEXAc4Xc0IkFMcA2Ou9yiDcTcNymTbTNJ2I8vXc15ePYDgSVX7T26ANyxAKmGkGSUADUzC5SMLdRX3U3U3US83UTx3V5S3VYDDECVXC6n0EWDqLR6ACKoACKTADMcAYxhUk0aniLukWM7vioVhS/ZKqcdEXPEDg9gLay+nXSZqStQcD1wsDHAADWJAD/PLiCqAAKxUC/kkaphH/AkAgBnRQYxRCzxQigEzKpJRRufvC4vvM3zgAG6KtvKm9xg6w6zq+4zju6zrevN6VklA4BiCtB36gCIqAWdc2OSfABRwAydgAmNfXDtIkDurgDYNpDdYwDdHADMqAmMXQQMzHmKNwNZsAmROKmS3DTXFwA8sTLA5iBUkw5mb+3UiN5moOBuTd5lT9WG8Q55axBGKBIzOgAiSAAguPAl1xFoj7I4z12b+biVYQ65IRPnCRJEjS6EiCA/XSBH5hBjmABRwwtNTr4A4geOEEAxnAAArQABJwARugqNpIGixABGIAbaRTYzxRB6oe4iu2Yq+HBjEBivjd359oL37xFh7A/wHQC/XQy7xu7LxPX3sfsKqIRZp6AAiGsOxGhAnREgrcmwqrcKKzMAu7YAu7oAtN6/Z9gAMJAmiYwAvpvu4Uapl1Amh7H+x9z7zR6wP53AZIAgMvIFGx3CBOcO9Dfe9ovtRqzuZt/uYCv8qqEwUNsgMyQAIisPkd4PkoMANLEJ0/IrAF2rKmzxYzay+i6BKBvs88AHZ9UfhYYOuhLb3KK71WANhmEAMd8AAN0AAWQAEXEAI1P3ovlfN4YAc7zxPN/0MirhM09AawbvQgb9ZJX+vJKeBIOwY4S79AwexGhETSIgqlUPav8ApoPwu2sPZu37TAAP/AsAvxT//x7wvAcP//9H8CGBDGDhAH3wUQDhwcMFCw4AGCBw8iNJCwoUGEESUa5GGlh5UbL3C8SOLE4xKQS4yMVFJSCUmTSp5MedJyyhQtMdfMBFMTjBqcb9504dLFJ5QoUUDuiEFCw9EOSVPsWMIFDZo0T5+eKVO1DNUzWbNy4TLGKxkyY7Bg4XrFrFkuY8eSsWIFB1uMMHDAwNLkxQkOHB48cMCAgQMPODzAMAMjRgYMGTJcuLCBRZAfVe6IQfIj8p08hPrs4cynDx/QfPSMHj1nDhw4b9SYQcPlCpe2Vpo0yZEDx2zatXPo0HHlDBw+nGLF+vVL2HHkyZMDU34c2HPmyJlHb9482HX/YdeDeWBg4MGcGwYYIBzfkKFB9OkLFlhvoECBAQPcr2d/IONGGBpPzE6SBKQQkVBKKaWVtHgJpphkmmnBNXJSzScIIYQCChtQ0MCCCzQgAQUUbFgCCqfQcGNEqdDISqqoSkSDDKuqAivF1sqKDQuv2tqIBx5yaAIGGHJ4wQEOPHiAgb0E+osDGMg4IYYOMuiAhA40XMGFIKrAIw88xBDjSkL+8HIPP0AbjTMyOSvttNRWe2qstmazDbfcdnMtqzEoMa46PPOELk9i+vTzuD6FIQZQP4kpBiEHEEnjvQMKOKCvA/z6SyBKJXJIPffe0zS+Adjz4ARQOXjBA9tyKKKI/xlmEEKIkYwYcMACEUxQJpvAWDC1ByPsgo0uJqzQggkuIGEGG2w4YsIQR3TjDWVHhPEMFZW1ygwz0rA2Kq5gk60JK8Ygw4yNcMgovxdgeODHIh9AiC/APPDghRk6wCCpDjpswQUghpDsyj76OOQQQgw5xA+CCR6zTDPPRE2NNMhQKzba4MTNCh1co2MONzy5szno9hSmY5A7zlPQQks25mSUjYFhj0v6GI+gSG/w4AaaMxrVXZzzymsvnintS1IjBfo01VR306EJ3orwb4lVXT3JaZRaKjDBWrWolaabcFqN4TQi9DWGCyzoQIUjjvgQWRHdKIOMOeqo4zS367g2Df8SVwzrKxatjRGqNHRgs62v3BqDXA/seiAvDxw4/HAhFXf3BAxOyOCEDmLgMIUUbIiCDTjA7OMPPv74/A8/SPPDc4T1MA3N1Mz4Vi0srKgNztmt4GKHM64Iy49XdtnFll069t0W4omfxfjibTmeeN930eX55psHJvrnfJelFlx80d4XYzjR5BAa9nr5gSVfeAFHms03/wSc29+ZZ/j10pmDG2DQwYYdduBttqSXXhXWJxDIJbMioE0YlDXV4MRaEvKVDEjwwGNNCEJSURsZUMM61OgENXCQlhnWNgaL8GBuepuNWmpkBTeQ4QY4mIu7gjQqIg3kAQ0RVaQe4AEMPOD/NYpJCgpksAMosKEOmwHEHwzxhy55yUt+AAQgCNav1K0ug1szw8Mklhtu6WAHXNDBGHrQBk38jnq/S57ylpe8WaRRjcmD3hh9B53gYQ8XvOgF97DBiD+oIQk0OEEDhnQALsDgXeKiGQxuEANC2kx96otBI2NwlyWBCi8cYKEOZpA/3oDkVEr7D6sEaBKpreQls7KJ1WxFEy1oTWuuuxYaJrSEGcggBTIw24e6EC21iehaOwkiV9Lwhg3mRA0pBKG3wFKGCmKBWlgACwhTyEK5eEAvJ6jBCYikLvEURHw5BNVbsABMX8KhDnvoAyGaCIgjJlGJ51Si6Pq1GTOZZopu/8BJFWPTJiw2AQc66EEPyNBPPaSCjG/UhfHUeFCDprEWa7TF83KRC100T3tvnF7zspe9XgwDG9tAjRPWYITJYeAAGODDCco1FxamVKUoTSmPGpnSRi6pkeWyjSUvmcklbNJ/rGqV00AZSlkZcA01WRAYYqJKM6yGDK2cEBRgKYNLggQKt2zNU5SlkzekgStO5dUvcYUrYEoLmWpD5hswRk9qjYgMbvCKYGAwSQ5gYDx+iZSjCsIAHHLgBL1RAxZg8Jk6iNMzo/NSlwgRMCOys51KfOdmVMc6ZqH1YfjETQ6u0Ju7jeERtoDFLJznu4OG9qC1IO1C1+hQiEZ0e9qDjv8vgBEMXeTCFxmlxja+8bY+RAEGQsiAX/owBnfRTAc4yMEMciCD4s6AR8tlLkwN48gYnEAuiNSN0XizqlXpICQ9hZrTAqgSUcbEgLWqyVEh9C1qJVWrIVmCJWWg3deoSEQ6WRZqIMSrXaGGbmDFarPa0AY3xGFEpmFWHARsBra6ZVSK88vOuhOfAIinAAzAAAb0Ohgs4IADehDNHELnpXQK7BCGMETASPyHIpL4sIf1Ur9Et4fHoom+VYTdtnDDGxx0qwde9IEoOsu83+ECF6UlMpFhceQi4yK1z1ttk7dHx170ghnfoHIf4PAhL8AgAw/ggx/Ut0Kk8UYHtRHzmEv/RVxCxuCQh8RBDOQCTeOWagZixq4QMpmE7prEuyWR2oHEa1Ty2koNPuECepPKMFd+KCTwDdFT9KasOmQVDrz6EB3wm4YNYhWYqeFggOMwmji0YXWrY+uIVoiDGTJYXZ0ywAAiPMMJ29CaHLDCG8ogGj4ErEuGUASJRzxiEgdb2CVesTpbHE95Mms1y4wdxPTJQotcpAcvMMQrfuw8Wwi5yLU4cre7TWQlo1YXTnYylJlh23nIgxB0oEMXZNABLvzrBR94Ac2I2y0QWuSeXvEWggEchznoobCHWAQlGGEGK9SABiktrg6OYKwjZPdoSXiVAEPZZwQZ1ZREbRCE0msG/52sZqsgylaIojJCa3Ewq/E6ARRQw6tNv4ENnNtgajxt4DjIAeDynEMcEO7zFf6oIdeMD3vgMwAGOKoAe/nUA3JgYNPooQ8C2/W//mViXv9LEVs3BDpVvOJ2QhHGq6MvFf/WJhbiCAc86Ge9NbEKWABPF9ourSxk4W28w6K04RayknnxZF7Qcbbai3IytiGPetQDH4EFCR0c4QlDjMHAevADiBWxCEZEghKWuIQmOOEJT4hCFKRIxSpeocZdFMc4xiFFGoqQ4ZTWoAY6EIKqsKvTlECNz0B1ySitZrWiCroLaoiJGbRABq3FpAtYgAIW5gaVNzh6hGjYCQYCAAAABP+gASfYVRd+6dUNsgENWODBGHww7w/4QA4EbtZa3YIDgcBaXQF4j3wGcIBOsecBGVDcC5hpBtX5nGA7BEWwOkTgtaxbBK3rNQQkNrBrMXiKsf6qp7OTjbSjmR5goRfggDlIBb2DKCKjBRG0OxK8O1iQhVawOxEUwVtowRaMMhj0hWEYhmIoBmNIBmNQBmyYBx5sB3rQiT64BFQYDlR4BSM8PdFKo+KJHiZswl0ghmM4Bkc4ghlgH9m7wlapgVY5Fe7iLj7zPQORlY0Lw40rL6shPgIKQyxwAtjRAvW6Fq1JAzagAxm4Puy7wwI4ARnoAjuYA85Qg0ljg8N4gS34AJ//oTeA+y8e2IOeAwsscJcXSLqjMwj4CICiIwh1CZL8mIPKWywjKkBgExhEGEWtQwRFQIRQfEDGciwpSg2woBawgI3L4qcewBFbRDX64YRgoMFiYAVZYAVWcAVhFMbAowVXaIVWUAVWCLxeCIYbZAZofIZomAZrsIZpqIZryAZt3AZvsC15kAd16EZtJIVV8Kzm+YXoQaPiUUIySh7fgajo0R4ojIU6WIIU0LIrvMJTkb1NKgIvLAmSwLiXmBqqMcNZGSqNI0MCeok2TCWusRat2RUqGIA7vEMBSAAFqAAvgIM5WAMp6Dk4cLMTkAIfcICC8Jml24M2WDsAdIPYIYNR/1EXBTCABsA//Cu6+gAMBiAuLHCDwkKiE/vEUURFRFiERRjKfyFFq/s6FltFMpEnOHAdWGwNs+iNtqhFtuMBHQCVF/ADX1AGaLzBZBhLaZQGbNAGamgGaXAGXhiFZGAGaVCGbABHHqxLcAxHb8jLvFQHvvxGeRDHbLgGJ2we4CkeXECj42nHMoJHifIFQbkEpnkrDqABGsjHGigCfuRCAXkVgWSJAwmqUipIjfOzNJwCtXDDakG5NBi0OrCAirxDjDwABTgCHegCL1CDNwCud7kBQzxJgTCAAAhO+dArMrADLUgCGLCCchGSRnkA+HgwV+sUChuPE3AD1fEDQyAYI/8KtssbylE0yqJERasbz6tTRbFDNjhYNtdxmLqYDbPop35iu7y4AR8wBSoDR3RoB3RQh3pYB3mYh2/YKG1QhlMoBmmohmeYBnSgh3ygBwdth3ZQh3EYB3Twhm7oBr3cS7zUxmsQzCYEBoeKLRE9TIMqozKKqHh0zFnYAyeQgbeipszkwsv0x83cvQDCuAQJL6opQ/H6M1IykB4VQ2pRzdXsAjqgSDvEvgJIACatgBlYAkvjiTigz3kzSd90gOsLzuyjPwaAAS1wghMoglEpF2ySj6S7vwMYEgrbMizAmJ4zsE8cNmEbT/EMRQdkscaCJxhTmDRZNkeMjfeET97Ii43/AARq+AZ5GAdwIIdzSAd4cIcI1cZsqAZX6AVruIZpeAZ0cAdz6Id+8Id9aAd2QAduGIdwvNAM5cu8lNQOfR5XdVVfcJ5Xnbu+q9W+W0JXTVFh2ASHoUxQ0UyU2CQB6cKRwNGYAENTgolAU9arMSpmBdL1LBHVZIM61NLru0gmTQAnnbmpYoN584EPMAj5EAiKBIABaIACCE5LtMQuNRdJ6Q4iaYj6cBS/wAAokAszkDw9MATKQ6LDKjF/VaJiMzZ3ylM+2APQ2NNRwyBmUQ1YVIurMAsv6gEdYJwX8IFRoLJxSIdzMIdwMAd26AZqxAZs6IVTgIZsgAZm4AZ0eId0/3CHftgHd0CHceAGm+0GvPQGvtxZC2VVa0jRWY2tXBAyoX2oh7JVeGwjiQIGXNAD2SkCUPGAVhmQnsq9qrXR3kNWU/qzqgm0hNxaLWAmsOAbImWDDBAAdQ3ObG2ABCCBFoiCLqBCDPBN+zOA38xSEoiPBMA/O7TEkfIL8/COlxGPSEmME0gDHkghK4g60gCTdgITMnmngkWYsdMDhA2NhFnYUcs0hwWLrKgKr6BYi1U/ZPgGb3gHc0hdelCHaWCGatCGZDiFc8sGZriGdRgHd/CHd9gHdBAHbsDQC8VZveTLCT1VDr2Gn4Uj1fKdoBVRo31eo81V6nkOUPABHoABqP91F820WhrVMwC6uM8UQx/l2jI0SPJlJunTG5RjgwYYAAF43wAggAVg0gVogBYYgiOggi5wzknhlAGgFDtsAAIAALSlv0bpWy6VlyEZEvFggPl5Adu4gcR904LpxNMhEz/IU0+EovN0MYONXMc6k9NQNmoxkWaaWCKZmTGQA1DQhv+sBx6sh2x4S2yQhgL9ywT1S3XIhwbdWb8c3p1dB3VAh27ghuPt0OwIGeZFLegVMuh9qFd1QkM4NRzAC2oC1i3EYp8Cr+/qvWNFEN8zyNDkUdC8CWUaoehTzQyoP/dNgAV4Ywm4ABUoFhuQAWniAAeITvkwxHIdgAQw1wSgv3T/FYAltVa//VsKMw8H4JEbmDYzYFzKy85OFFh/NazDslMWG9hMLrYWYywyURhl86/McuCZkQP1M4ZvsK1U3gZsgIZoKNlh+IZ5yIZn2AZbzgZunAd1wOW9/Ma9FGK+7N0LPWJrOEFjPkFZcAUSREZkBEZlVAVmbmZWQEa7+xhgyIVdqAVbEIV+4g0ywzNiFVbv5eLv2mLwIs0fVYlTAj6sSciMUyCyhYpsgYoVQQMMOLr3TYACmF8m1YAUUAGTMp8PgDBL/IBwxb4AkABLfI8AUAASYOghQNIs9dsCqIAmoRy6eAFOnOTtJB3tFNg7LTYRq1Nh0+SvAxgkUqLMHWG0/6KWNjghb7ECMsARH6hpQDAGaGQGZXjLZFiGYHCFQ92GBI0GaqCGZ8CGaZiGbMyGvIxhfAhiCbVZSWXVa3heuts2EzwyZtbqFCxBWXAtXxiyXZgFQiCu3TCaJiDWf8TaUCJnUdLaHFWCKTDDUzLDdhY0RGulp+AKqfgWa2qU92DbbFWACcgcuZi3VstSBzDEACZkBWiUClAARxkAC/hjBFbXTpHNGYADK1CDOfASRnCDPdg1o2TAOT0E71RKo1zt1Q5P8lxKq3vAC35KlnaD/+I3YzqhNvAB+jyFZnCGZkCGk1mGYbiFZtCGb5AGZogGZgDusTQGaqgGasDlbeBPxf/bWeI14qkOzA6NVeZ1nqG11SHztushLVlYwRW8Be3IBVmYBVRYoTLbH7V+Gu+SGi4eyKz9zDQEA88E2zEu35roK72hZ76GCmoBJtuRgQxACAuwgAZ48MjuAK7cQE4xV3LNvgFQAVdzFBmwAMl+jw5IW4RO24U+gMrJNYAhBDgop09kwK3bOqNkBBlvBBpvBKOs8RqHBEiocdb2zn8hNmL7EoRJNgNrg7Ryg/WsEa/ggRsABGSgBuIeBmNAhmDwhWYAS7hUBmRYBmTok2AghhlMBmnQBtsi3nHohgmt2aWmamsIGWBYrealVSELPF5wQRecwSq/BVyABA64qfie75P/YOvd+0wdRWeqaQlbIar/rppjZaYBtxa+hkiO3AM4kLpEsAMYqJcMUAEYiAJQkfAbymNOST8stdZOgbBGwb+8JfG0LWAB4BQGSAM9+BeE/RyCY4TSxjxIiARepwRK4PUdz3Ed33XN+3Ve53HWPspfQ0WAJZ0yeSzUMLBmQXKwaAO2GAMz6AEf2ITgOUFiMAbtoQUZDIZcaIVUIAXSe4VSCAVkrAXo3iidRfMilvft5m5rwPMq157Aa7Lr2J7rmEFeFEssN0tpSEtikIMTKBrb0MoZWGuLA69BP5Dw0u+FXAmsuetASxDTZBE3gBZIdwqQm3QkYoRDcARN8IRDOAF//9GCOlAD2cMCxC6IAfgAOZCDxH7NApiABIBfBVAA4QxOhj514dTj93iAGOiXS/4XRjC4zNs8S+C8SqgEY+/1Xfd1q7/6SNBxHKdxXGftEWOxyiOYT46xnhuR2zawsPgnmokEUfCEVfCdXXSFPoGFUBAF7/Getv+80NMFHUQ3bvCGmrVZcRCH7UZea6hBGxTLZMDyaFDLoiZZbYh8W77Pb6xLHvzGVL4FerOkGtANYK04G3Xrtw5fQ89Riwe04KPrWWFID3ID6XM0YAq4cjKESLAETiCF4YiFV0AFRDisOrADQtCDF3AIOQAEH3A1LX3Ni+yUELfE6KzEoPdfCMu/Lv9VA0JABEjw9V5/+kvofu+X+qsPf0sIf6vP+vLPehxfhJJuSrGz3MfCuVALsPVUTg+Yg0vwBFvAHikfBtc6d1Roe4Dw5IkUKlSeLoVqFYyatm3yuqlT140bt27jsmHMdu2aNWvbvH0M6e0bSXnfTJI8KW/lynr48sHM5y8fvnr1vlUD5OCFESFFciRpUsQIUaJKjiI9+mQp06ZLtUCdInUqVDBgoGqZ8mSKVatr1nS9mhXr1Cla1JRJe+YMmjRq3sCZs6cPoUORLnES9eqXsF+/YnmiFGlRXUAfGBgw8AEQIDkOBgwIIBnAZACWFQiQHBnyZsgBOG+WLBrygRNzDlH/qlTJ0qXWmjS5bn3JkiVKtinRzq079+3egiFBarTo0CFEhwwhJ0ToT58+e/zs0TNn+nQ9cdq0IWPmTRkPHDz8IWULVzBj5nnJUkXq1ayDnkQJFChKFa9kHud5izgxW7f+GDd2ZE1EA0bkjYEGrqSOgeokuBI9/vQToT8T+lPTPN8U88EHHvRkRBEf1kDDh0MZgdQTSW2lVYpSPUUWVVqEhVVVX4EFVldZPSGWVFihpVYZbcE1Bx9/EIJII5do4skqfPUVCyqiWDJcH38A4oEDDhggB2OPPCKHDwZEJppolFkWpmcBFKDZaGJKltlnAxRQmh2UvFannXW2VtturM0m/5ufvN0GSSSRNIIIIsMZQpwhyzE3V3Rz6CHdHHFMOsYYZphBBgffjTHLLrycEkwyxfjiCiypzDILfO89mQopoajiSzHSfLSgN9xgZFE3GnHUET411TOPsPOwxJKw8oB0krD47MNPPPEYiBGx8mwzig8vvFCDED7V0O2HRY1olBJOmZhiVjvKaFVUVZkVoxY0qhuvuliZgQYaa51Rhhtw6TGlIY1EYskmevH1yyxPckIJIX3U4UYcH3BwJZePYDKxYwWEOaZlG38WAAADGKDmZgK4KQBkaUJmMpwPqEEJJ5y8997LdybsG224sXYzbrYNGgkjizDys3HKEc2oc3rssf/HHHAwDccbbmCBhXZYOEHGCzeMMUcrxCjjyinJGAOMMMDYUgswsLyyyytrq/1KLcIgw0xD3ozDoES7ZnMRgNZMI6w3Jm3zjTbfbFP4Ntpog8000jBeDTbz1OMPP/y480wxlzMDNi+AXHvCttt+mEMT4H6rRIlKOcXUjmbJWFXrWIHx1Y3wwn7juU7Ua+9a+sY1V12N0OlJKZ7+souTonBySSOEzOGGIS9sKgcom2yCCfVd+uABYhl7TCZlHgcAZsegDeDmAAkkUEBmnqk8AANzJPke8q8lD7Mme/op256CRQIJI5A4QmjEIQ7R/sAHPjgnaXuow3TgoIYHQlANZnj/QQ+wEAdFEGMZxeiFMZZBjGMQQxjCIAYwdrELW6wiVWrbBTCa0QxsNAQdBprH3XLFkV7JjRnFMM8wgjGMYfgiiLy4xS1O4Yoj8qIY34hcP/zhjWLwIorB8IUuNuEDHsCAA0I4Auh+MrqiiAtFqTNXul4Hu6jETnZXcReM5nU7Muhud25QQ+/+YIhFQCJ4oihIQeDDCU1M4hB2iA4PaPACQIACFKMYxfSwpyEriQ98YipTxjpTPpIFgAAJIADJ4NTJARzgACA7gRn+oAlRaAITmpjZKmmDCUzkiU/4yxPPIiGYRvxsEcYxTnKas7Dm7MEODJzDGhrYNDVgzQpqkIMq/5yBDRcaQ4TCOIYIT5jCWawtbbN4GzIYkg1v9Eced9uIN7JhDQD1ohnGcAUt2lkLXMCiFa2AxSxgAYtRuEIVsKBFMLZRD5nkwxvGCIYuckEMYuwCEDy4wQs8x0UdhC4HJEqKEVLHoqW8yIyti91VthKWj4qljSGFitTwtbsyaMcNkKLLIRTBiIDhJWYzC6Qd+jCHMajBB5hwBSjk8AhQnAITcvCShjZ1ADBFJjPtA9P3yOeZ83EyMwVIUwAEUIAKJECUkDHADf7wCOrh5Y+wuQT1xpq/s+ZpUDvrHy6Ho8viHII5RGpUHeo6nboO02ljsIIF9WAIYmCDGsboITGQEf/CEh4DGNhcDypeMTxZyMIY1KjGNSoCEXVwYyPZ2IY5OaILXzhjF6yoRS5aUQt7zsIWtnjFKlKxCvbsYhgnoQk+thE2xRpMFGZowgl6uy0dQFQHOcABGJOiIoyapSzoyqjt0tjRdoF0Xu5Sl9TIYF3r2ktqZngLpPigBz7U5RCMcMQkKnGJSthmEcyZww1u4INN+GIUH3CADyjWJTloyAHzdQADMqBV0GBsY0090wGmirECKGCqJmtAVjFGmgdETA6U2MTLXkY9Clc4wxleJZ76Rxv0UiI4uVwEiYc2V+fU1A4pVrEwp2MGKzgQDnoABTKCcQpf+NAXYwMGMECIilX/oCIWr0AFKVJRClPUwhjMmEZGxoEsAPGHI9PYxSyO4YxZuPZgBSGFHwHpCCR54hTbmEc+6FGPbYACEG0wg4txEIPedmBbS1hCE4SbhKN4aChbWQrqlFuWc7GuKmJx7hqj21w2TqG614UjGvgaNe28ZQy8q84eiHYIQcX1D2Ng6CNYAQoNPYABHPBBGzjnAx/klwNb8ECByTem0YQpTlMtX/pmfYAGFNh8B3jAlej7iPjAJxTCjo8nQkFsT7wM2TOzjWxUw7+eQYLEPztE0YhGF+Y0R8V7eLEapuMHQNjC082AYi5MaO6+CIOPRN7jKmyxC2NIAxv8icg8tnFDzk7D/xoLm4MoYtEDHODgBm/uQAYyYIEKHEABFehAqakhD5jM4xq98MUmHOCB3sqgtxnAwJyTkIQPJcEJSDHKVsq1InRp9Iwi7YrsVm47l8tIO5jClL2uYHObc8G6wMU5GujIh6T94RAkNsQf2vACHwCCkT54gAo6gIErvWALQ/XBDT4QdUgmBqln4kz30GRgNCngAAmADIPHPpqs41cxhhBeKETh9rfD3djxgZlAXuaa1+hPT7UcVKEMlShqE6lo2JYgGQ4IKUuE4hbMUIYveFFCEZINGL8giPxQYTD26CIZ1MCGN9axDnzIQyPntLc1GqCA07fmAAxIuALQ5/pbN0AFcP94BDWyARN8XAMb2EDGJl4ggxh0oLcY4PgSPl6DIoS8COPi87iWf3KNvlzlgm6uGt1Y6LCoQQszpzkabs6F78MR4Dm4uRXIEKkpEWIRtlGEHtybdCti4AgqUAENYOAADtBgDVgYA9Id44BQOkASrIEHOBhodM+ADQCutRqCtZ6YFEBifIAcJIZ+AUIolMIFXiApaKAGwt2x1d2G4V3e3Ub/2JJwGAfgVZty/IEb7AvDDNIc1MIyKINg+cIuTNPYsNAsCMMrcJkokEJfeAIqlMIuKEM1ZIM6/Eo9eEOvbNY0LEAGKNwJoIImOF0HdIAFkMAFRIAJTIAFqMAdLAIoYMP/w81EPnTDNSiDM4hCDrwBGWCBFTQBDADXHC6BEORZuDifiqiIi7iIn4HFyrURjKgRjRAiIRYaBGWKvbRFGjBiGuALGnDBGbABHOBVHbzBHNDFItxFwgDCCziAHFQPlmxABajACfDA6mHAxsFADSjCGHBA1jkAIDwCY3xAJFUGx1BGnIxdAqJPmphMAfSaY0xgBGJCKpiCKVwg3HGg3BEbCLKSWc1GLflPI/QdIiyKtTVHNvrBHzAHAtnBHIzC5gUWMhxDOZajNB3DX8TCLvzCMThJQbwCYMnDPLwEPayDNwSIvHUACqBAF8DAEsQCKcxADKCADJBAC7RAFh4kHRzC/yZoAxn6gz2Ygzhkwze0QhlYgRWMAcDBYRN4JHBtS3H1mZ/xYcq9i40YYhoV4krWiLychQSZQSPKpCOuxb2gwSRSYl3RkR78gSJAApLQhh58gE5RAgcwAAl0QMblQG8tQQdUAAacgBtYwQ1EjK9tydSJkpiQTGaQyVYWQPqMXScZwJUMJSwuhiWUQmupgipkICmUQg964AfSj1id1c0MSh6ZoDWmIKPYEV/2wSApQjBIw+Itg9iI0DEswzT5xWK241+gAsysAjJgwxLhg5mVE984zgxEARTAgRPQABzEgigUgRPAwBYdQRQE3xEQAiNgAja0g0z0gzmAAzh8AzZgwv+ltMFe8QAOZKQTJAFwcVFSoMifjYUZGZpX1IjssCS8ICehqUsEzaRN5gujsUEaME0dIM12zEFP3kUqgYInWAIgYEIkcAAGQEENTMEMdEEXHMEdIKUFFFzwcYCGAMImzGJjiOcj+MBjfMZWugnHwEn66NpYegks1hcmzJM8rSUyYqDbMeOxVdiFhaAljJVd2hIlOEKhUFt4VZsd/YEfTMlffhso0EKnLcMr/BEqpKOQ8aBBoEInfEInVMIk9MEieAIsCKY/qQM9KMg1TEM0VMMReIEXyIAg2oGT1EDs6GQMnEFzKAIobAM9yIQ/UAQ4eEMv+IAV5OYNlB8P9KYTLIH/DnDRiaCOUhAn9B0nR61RcrIkSK2kVUCnTEonSpFBGqABXNTVHvBB7xgCI1ACWW1CKLBQPIHCtdTBE2QFHYTBEbBBB6QACSDlBnTAAzzAC/xUxcyifc2iMGIMAXCSp1YGmpiMZhxVBNbiWH7iV5WNPa2CKjBoMorCgzajhm0CnuCdztzGJGSooRTHCW4oIRCdHxwQH9TBHlCJl6jCMbxCFtWBQEyCJiBCJWjCIThCJzhCtVaCiiWJLDRDNHxDfuDHNizONIRBIeQBHthBJhRCH0yCOxaCrkorayCbKOACmcFEPWRWNlDDI1yKdngkHDpBwILpEkABFGiFmbLIiwya/5u2KY0IWkoi55tW31VE0Ho2IhqkBRmMgXWxRZB8VzbekZ8iCSjAwi+IDTEEAyx4giZIgRSswaFSgRc4qg2ogAmYQAvAZ6XW5/RgQiJhKpcowgu02iWljMmsz5tA4H5OINI9QimQTT216quWwtt5oIaBYF32xiRMAiVQI4mVmN8hR9j2QaRIR6QwwikJ2SEcQR4MQid0Al3QxSAUQiHUAR3kQSWsa12QwjJ0U0MMyDVUQzR8AioMrpPEgpDFgjO4IzsWT9r8QmHZK+hdwzM8gy/4wBi4ARlI0BsmQdREzfd1QVRoxXKly8RG18TSjkoyp+qabutAkBasp70wYsZaCv8ZlMEZqFR3yVXIbqIn7MUIFdYy8G0oAIIV1IEWPIEdnAAMyF/NtoCknsB3HNImnAIvMBKmvlKXcMACcsZXYhJlbBWqYcmVaAkm6GA9wULUYiCsxiozWi0roZXOWIKzUWP96pKhWCNyEIdcOQebvQFy/MEk5IEYiEEe5MHchgEb0MEdJIIj3EFNFYIX1FUhOMIrAAMyxNsRGgjfLGYsFA9j/oIzOINfHAMuqJYNLgOZ4cOFYAPY9B4WYErAQkEXDKkXfN/MtU6gBZoghoWNhNR0oe6bqu6N3MgOr+f3cQEjZgrtWorNkUGQOEofGIJLbWKR6eBBKYMLOYMHqcIm6MH/F8zB8h6BDQzBELjABsxfCtSAB8AAD0CCKbQCT02Pfc7iqRklnBzYVh5g+Ozn+H6AHiiCJ/DYaSnogq5vD67K3GkYniAJNNbGec1o/dov/i5KolyjCsLBerJBH7BBFCwwE9xBFQzBHUQBFbQt2+LBIDhCHuhAHSQCKmSCJsxCYTFZRaiDOYGwXzDuNFGDM4hNK6jW4yKDPPyKsGRDMuDCFryAFjiBFmCBGnBBwQ4pFHABDFONDq8OVXxU9U3fy8lL9cFLIbLcHwoaFlTzOWtfdWXKG2JBE/SAFejLJWajHbkUhQZh2giDMShDFjeDM7hQM9TCI7jBC+SADBxBGIgB/xDMHwkcgR3IgA7gwBpsgSGAAiucwkXbZ2N4iR94AJg42PpsHZiMrw8YwiakwtjYAvq2QmuZgpG9JVy6nSKD4J0wMp+AGKEExyRb49AkB5GYQRcswREswSAMAhUQAQsgQUIDAQEPQkFUwSDkQSLQwRIoaiZcqyfEFjNgRH7cspARmbrx0S+8AmIKw1sWRCsMg0O8xE0oAybcgAeoQaHhiFREQV1Hc4o4RXItF+tchTZP1w//oQ/3cA9PLFn0NVWowRQ8ENV4rhNcARSkAb8g0JQIncgmSSnAgi7ADd8igzIswz8vQytgQtB6AAZYwARQgAZMQFL2FgcYwQlgwAvMAf8mXHTFNMap4df/GYCDvQlnwKJ+yYEiYEIKmZBqpXQ8pUIqqBsiU61MzzQj09IIAofQ8GoKciPRZVtNdUIiVAEeVMEdCAIe4MG54sEqH3AhELUg5IEkFEIlxEIqwAIxxNs8vkSF2ckf0Z1A7MIy2MLLiMIo9MJDygQ+fIMxyMHFfcFIrU5dM3gUXNTJodyZolH0Afb1qSlHtdHqjpRGKReOOAEXrCfTQIqeEglxvBQlYILwrIIuAMNBIUNn83Mz8K0wWMINPEAGdABSLtwM1MAqwsCPdwAHHJL1YAJjaIn/MQBiONgDmqWG0CfFwIK5pXQ9tYIqJDcfcWBzy/Rc0rT/I49g//jPiB3HcSjHJXMjkTDMIIC3JNwBHgiCJIQ3UcttJmSCJNR5IeBBIlAwzISCLSwDNozZS/gPeTmCec0lJ7RCKODTQe1CHA+DN4hDE52ZK7yAB3iAjGTUZja4n0l4h6sLV8i160xfhmv4w66By/W1oAEaRuGIEpjzer4BXMTFSl13S21iKMC3LuhCMIzQiwvvixtWK0QCD+wEBnRAFHjBEcAAG9QAFsjADnRBDniHHPysfvYaf61e1g2jhqCalvxachsZc8uqsi1yl5u7l0s3mAeNAF1jTwMrNxJC3bZ5FVTBeqPCIOBBJ2TCdmcC4cboJBQCLA9CIsCMDv45/z3mw9sVhJCpkAlNEY7xAjIsgzNkjjqYQz/kwzxgwyNgywP0IYxAhaYzeEaJLh/69RrNiA/XTqExp2DHSHTx9WEj71Yg77iYM4gr8VuIONKc+RRvoihMrSrUwq4XFjKYhzEQA9LDAiboARyqARvYQUPjwBxwARvEOwy8wJFEik+iWlU6AKUmOQA6+an5QPnGKieEAidQj4WV1bmHIFrdXfzias/cZdCU2HGEbSUbQoj+5SAIAhMwgRiAN3jHwid8groWgiRIQh6QlwCrdyx7gikMg7e6BJMc5geJUGElvdH/UHnUHjhECIEb+Ft7vI60S1Y0+GbusBmh3OtUuPURcf/LQ+yFf5T06bVUjIszI3HOP5Csj7hc9CQjUGj1BKopZLbYDMPRG0MxGJYwqKwhNAEddEEe5AAdWH8hQAEbW4Io6IEHvIAVVPoLQMymXDtZ4vZQ+ZRrOeidwH37x9JuvP+e1IZv2IaI2f1bKULeL8oh0EVddfcdAASQFkDE5BnCZIhAFUCIDOozKNGgO4kEhSG0CZeybPPqCTt2jBgxZCKRIVuGzJgxk8SEiUw2rR05f/O+gRrzgsMDNWDAaPGpBcyUKVGiePFC9CfPnj99CvWpVIvTpUCnJlUKZk1WpVm5asV6FWzVpkKnPHkyBYwTKGvRpDGj5q0auW7mzKGr54//IUaRKEGihGmTJ1OtZgELKdKYMmTNmi3bRckPnENw4ODpMkkGjBuWNPF44eEBgwcvSNe4wcFB6tQfPviQI8c1JluzUqUSpemSJUu5LVHS/bu3b+DDiRcnTgl5ckiNmDNqtGgRIkWGqE8/dMhOHzhRmORhAkTEBReShmhIUUWFC4KTCt25I8Z9IjGELqlCxmzjx48mT5b0f3IZYgJERpln6HEHH3mage0D1NRY4yqmijLKKKssZArDpJ6CEEOwuMLKq64g5GnEsMQqSyizyHJiiSW4MANGM7AgwwwyaFTjDR2sMCMOvKjLS5FILOHEE1Fm2aWlkhRjrBlnkKkFEz+s/4CCDjYKOeEFK3Kz4oUTOMBgNBhg2PEG1hxozQfX5ABkzU1msaUVUkjBLbk67aREyOLuRC643/jcM7lIIoEEEucWuU6R6QxBBBFDDvnjjzrowEOSgUy4gIURhpBEkCGGcKEFF4bwbhAiiLhDkjDYIISTYJLRZpuP+mtymWb8MwlXZ5ZZRhlq5qGHJlpgA42BByMESguiKPRiiqeWQktDp8hCdsMQnSUxRK2A6mqrEqmiaioUn1DirCmUYBGKLuSSqwkrsJgxLhhw4GEMuvz4o8c/FIGEM05eeRMYYUpikmDHXomEByv0+KwNTxS5gbQMMsDACRw8eAELK3xgTc01Af955JFIRNkFllZWQUUTSwYVlFDkBH2ZL77uFPTPQPeEeeVAB13u0EMSTRSRRRwVmhBC7GhhBIlMEBUISlvYoIU7iKgiDyCqEASPOwYhoZBLNKmFGGewOcYjYQIGZhdg0EYbSWBauQUZX1wpxht15NEmkj3icIMHHnYakSkwlq2QLJ6iyjAqpxL3qUTDqRIRQm4h5/bYZr9KvFnMU/xpXbjiWpeyN95ww4035tCDjz8IOWSRvfr1hJRVjmyJpFqbkYaaZojZxBA9OOBgC0v0eCC0AxhgQIcTTsCAgxc27vi11yIBBZZdXkmFFE844SS3SipJzns7vf8euUlkrpPmvhj/IRSSSBYhlLn2cd55r0YYYWSRn6GL7jpEiqaDCmKoAh6CIIZQtUACEmDBClxQhTvgAT7uKUQnKoEKT3jCI81IRSlqkz1PpMITl+CEJmSGCUyM4hbFKIY11GE3YyhiD3twgxVw8DewAGVwXrCKiX6iuA6ZaHKRC6KIbhg4DfWwXGVxghOw4BPP0ShGZngDHEhXxdLBYQ57UJ0hFLG+fokCFa+whdqEoZJlMIMxyVDGMoABCjl8QA+XGIMH4OABBnAgA16QQRc4gIU5pGlNrwHEIOXwiFDMYharKIUotJcy9CmnfXi60yQc4bLl2I9QkcDf/dZ3yecsgjmhvOT97Hc//+gkqhHXiQ4i+seGREgCCEAIQtTyIIgVaIAFUhMDHgoxiF46IhOx+MQiLuGJWXgkOJdQZiY0UYg+IOIPehgkJlzxkm5csxvqqMke+jAHNIyhhjwU3ODQoq2vVA5x6dSCV8IyxGOpUyqLK8tZzLJEKMbIRm1JQxqmOEXKwGF0V9RDHwjBRUWE7IuxI4xhSsIrZSQjGSVp4yZE4YMX/CEnT6DBEdjAhhPM4Q9s+tggB/kIQGwCFoksRSgaeYm+NOKS7StU6+AXykY4whGNsOQnQTmo9XGSEs8J5f5CyUlT7g+pRWMUdQzRh0KwgQphoEIQhoAHYYoBCHmQRBXEEIhXCv/CEYnghFgnMQlNoCIWx2CEJipRVkdMohKrM8QjMHGKYkgjG+jgBjfKIY5ufCMaj9CDHdiwBCvoYCdbuUoOLTeVsDTFWeq8kLPY2a0bksWHTVHRtDCrRCzASC4wehcX9vlPytRlDqETnem0yFSQCUkTRILdKnDhizKiJKL+IcYwjLEJQBjiBTBYAwxkwIYZYCGahgAFKDaBCZCZFBCigNMiG0knTzqHUPhrXXPwZ1NR2pR10OHkJ5lDVKTuz5SJQmojHPWc/jGKEHQYxCDEMARBdCIihRBgHu6Qh0IkohD/vYQj2orTs/6CU4XIRFhdesJbKGMbHMlHOMpBDnJQ2Bv/2xiFHPRQBzZAQQfhBFdPeJLDyUpWLOnM3A8z9CGoZPZwPUFRszLX2XdpYV0+WQsUuNAFNpi2DkE2LUDfEIfT+cEPg9wXbL1WJFXUAkmIKUkxkJEMZiQDF5uIzBRocAIdwCAOivjYMHgBilEsFxO/ld0GGekJTTjSk/HjGVGF6l2Y2m+VhjoEIf7Qhz7UgRCH6vPqkKo//KmXf9EB5c8U8QdGEAKYg8ADEwxIhDzUUhCZyAN8EpGJTHyirb/IBIAn8YlYCMKXjjhoKHhBjW3IYx748Ic//gGPcLjDwuj4hjLkMAZvnmEJOKBB4JbSk6Msq9gvVuezVqxisphlLIrT/9a3Gus4aj/lLJD1yY2dKJcufNvHPx7yuCkTByPP4TV68AMXF+E+fgVGFKmAhS4YWhKISkMautqFJvaAhSZkyQ8gA4UvTrEJM4NikJGABSxqw8gR5ual5bUpdBhFXpuyz72GWB0rHXUIRxECEY1g1P5Gnj/1MuJnjLrOIUIutJ9FguWIKAQE7yCI/uYBD5lOhFYlkQeIFGISmeiELwHcCVT8Yd2bePCr58EReuQD6vnwhzv2YY54aNMVPqjXFa5QA69n4VsaGlwUeLhsZmvu2WMxy2ZTlO0e1viIh+vhT9we2Rh1G9w+pgwd+D7kOaxWdKWbAxna0IZ8/fa3CA1MKP9aMcaW7KpXuMsdG0tBiTH4IBLNvYUvzmzmND/CE7C43kpH+Bufate7qzRvyc/butZTfOVB89/Kfcbon3k85rBvnSJax6g+0EEQhfDvAwcR/P5KAhWfYE8vhV8ISXQi6KgABS+UgY1vzEMe7UDHPdwx66dHfR3rQIc8sPEIH1iBDD1wQg2SQIMt5DhDXhhn5qByLWuDS9tof0Li1k5j/mf72eAO7WpMWsil2cAAR0IL78Cto+CgSujAtOoidCLQRsjADYxM3Tgs8SjhEjYhFEphFcZIJJaBGkqQMQDkGEwh80AhFE7BFU7hFM4MZCzhkK6HpbjH9I4KlECpvFqPUVj/j6g2SdF6hpVirn9Up6AMiqkShTpYZ8+Kht0OgRJAyREGIQzC4A6ErucKQgwkQZgSoRNA7ZUuTRI6LRMqSB5grR7qgR7wQersYdbeQQ7DYdYS5Bu2gRfkYAu+ILGaonPkQgvMIBAzBAy+wBCzABG/QAoQkRG/wNgERwvkT4cmMRJTBMbaLp7SSV26QAu6gAuWoEJ0iAuwYBS5oBPVIA1CC7TewHNY8S1Ex+9OB7VmUQ9iiA/0QN2Q7F6AZH04UBPgTd50gXZMgmAaAyUIjrkwgQXPbJA2gRRm4XpIgZE2ATd6Y2dyys6ycag+ifd4j+VWjs+QDlL+IDsgBRf1oC5i/2gPTmcPclEXcXEdcRGk/KdohEAFrOoXYmEQfG4ifuET8IBSIiIPXikT/mvUCoEd2KEd3IEh3wEOZy0f2hAf2iEf8GEetoEalAETfGAPleIocMyKVPHufsIQD5ERs6AkGbHEcogoWrIlOwsmp0UL3oUml8gJeuzbuKDHoKBF1gIn864L3mCfUnEV14UV1SACZ/F05BG1anEP/OAcczEXedF1XkcUVGHebIsk1ghAlMErjaEXXGG5RqHzTCEVTkYatYc3MikSJG5/GI1ngmaotCvlZO8JuYipNM7jVGcct4gQ/GwPUgdS7mUX/YAPDrNo/KwPjqABTMALhw7Agk8ShP9vED6hDPFgHwXB5/5rENZBHbpBHMxBNM3B+1qo6b5BHr5h13hhFCyqDeLCJ2AkJD0nijonEU8SJb8AN32CJVtyx4giJucJJmekAkmRtIayLdCAC2ySiZoIx2YSx9QgEM2gDMrAiqwIi/5JUuggyLozyPggMA8TPNXRD2IIKlvLUYLmfXZDE4qkFLDSFrRSSR4KorzyoVKiGIJBF2TBLEnhBlOGL/CHffhipkyO0aBj4rSrdQR0kxwBEqYjUVaOkwy0CZ+waP6AD/oAUvisD9ARLwjBDPTADJbABgrAAqqAIHcOa8jQEfxLEvbR5wTS+VpIHdABHcwhHLjBM+1GHrb/oRqYQRmKQRl8QRYgwQduIIqoswyStDb/UC5OUjdv8ySloFmMwiWJYsd+c+22dJ629FyIswLRQJ/ElEzR4Cdo8sZuTDp9ggzOwDrdAA1Kh3T8idzgwDvrQDwPsw/IUxfL8yk31FG4aC84MDA44QOfTCuLQSVSAqLU6D6HYT9NQRWoq/TwxEB5r90KBRLeMkIpjpVK6dB4b0I9Tn/y5zr+MhwNYUMPoQ/swFXrgDJiqJv8bV7coA1uIGGaIAMKACJsrpcgSDNjFCDzIBMmMyLmK/jMgSHHYa+6IcO2YRuwIRl4AQZ9gd7QJg48wANiM4rGQEmXFJ8qkCkWMRFTMguk/4Bcs6BKj8I3d6wn10IJlMAIjCBe1y5e53VelwhNjVMnue4KdHIU34UMuI1zoFMNuOAM0oAN3oANFFZhww0OFhYWKaMOZNEpUecw+RTp+hTJNhRSDIoRONASNsHg3hPKgmEYUlZRGTUl9LMVVOEqV6qRggNPVmZn7OxnQK5ROA4KmcrjknAw1S2aUGt04gBG2sAKbiAH3KUIlgDQ/nIP4EAe0XEO/OCgFMFrLgEMP6EThA8Paqnnfi4Rcq4MB+FFBUEQXlRZ26GFvOFZmSEYaIEVVIEVYEE/jkEUPuMEaHJgyWAMKhBwaQRwaVIL0jU3oxRKg+IostRdW6RF4hVyyf/FLO61CCo3X60AczHXXzf3XwMWTTMEC/RVTDuKdEu3dAEKdbGIFmuxFju2YweTY/30yLboffbFEgDDyVhh81A2JfBzGHxBbk0hFESBpahRZVyGZeQnzpjjZxalqfZUMf1Ui/zADcZgDDD3ND7gBm5AWznAA2BAW7X3BqygDeaAdSLBERjBEThBTtoXFVLhFV6BbXZhF35h6MRA+B7IgVDtviRNDMSg+MwWFV60WLthHNQhw7BBGtDIGIKBjELCGXTlF+bgAXKCLPa1AsdAYIuTYKd0ERH3JIOi7SY3cu/VCLZ0XEy4clfYCJbIcV/4XZeAx8SUC9AAcLctdG0yDc7/IE4Dyg3SgDKGMvBIx9xWFxeh8nV3EXaRLipJZ3ap41646N2WUXd9gbcgyhiGIRhugRVMgQXdLDcKJaeCplAS5RFQjgnx8l7UTQ/GIA6QFl2lwDRuIAn0pg144ANegAd8oA0MQUguoRJEiHhFgYPiF5HeZDZiIRZm4Rd24U0QiX4bOR9joRPYwDuAYAUYQgxG7dOOoRO06n8fKA8sE20FAVqxIUhTVouDwSOI4RiQ4RiW4Rh+wRN+h3g2K4edgDoD954EkSQPUQqUACXjmJi1gJ7GZXLpFXLxtYSNYIWfeYWTIAlg+IXXoie5TidtBLS0oDn1tQzOoE2/uTpLZ3TM/0BOSacNLrAu9AADj5hjhdYcoZJq66Lw1DkXza1HAGFfAIMFqzgYqKwYdos/RSEZ+2IRioYQpsAJ6kA6DOG3xAwQkFgPokfrrPe3qiOSOjAUPnCDQHAVYMEWZiOkH/lNdIF+0SYXcAEXagGRQno2DlmRFfkVwkgT2IAO7iAhRkA8gkAQxIAJBiEf3cPmuOp/CyH4BMFJgsEXfCEYjEEYdmUZdCVA6Nc2DqF6dUAHlqiztKACwXVdYmRNsUAJ4lhe6ZWYz1UKyoWEl5lex2Vek3mZNYpei8AAn2AtsLRZlCAolGBzdKAMdOAK0MBfYSC4ZEAGYiAGcoA0FpuxGVtb9f+2sV8AB0jjBuaFXnjgDDIbDcqA63qgB3gAB7Z3e0njBMY3aS2GseklDhKPn0cBBucWFCJBzNrgBa43DrCAAxigCB6gABgAzDSwOmbQhEh2uUJBUlUBuVsBFlZBuUumFVgBuqPbFaLbFEyBLF/wFFhhFFghu5UaGER6FTjB4TSBEibBf+yA7wZBBVoAD6qACbhq02LpDgrBvjqBqLFqWNubl3bBFtLGlaM6gp2BbFKBE3Rje/igB6wgB3Agl5sTTMGVSXOMmM8ardG1XklYmeWVrfnaree1CGpACWjghE8Y2nhShqMAmaOCw5VAC7guBwB7c7G6RXRgCa4AB6wXxxP/vG9wYF4yt7KxesF1AAtwwF0w13qtYAw+Wwd4IAcI2wN+x5YfwAGkXDVUgwGqPDUeoDXkYK6UcaOT0YwdmjqQo9FYRxF0YxPecxRMIbuh2xXePLrjHM6hGwbr3M7vfM5d4RZ6wYr/mbeaOqX7WxgIwd8IwcOMSwVUgApUQAQGggWKz1O40GoyDQgSIr7FgAgwfWq4ShAC5pWjelfI5hXcjJJYhRMOgQzQDwfGBHNJkUyrk5crUBAB8VzHGhGD+daJ2QDLQsMhN5mVucOduQaKQMTnVcNJ3NdVpF7jFQv26Tj7qS3kYopSC4iJzE7hACnVwF3yCQ3OAMQMWwZ0QAau/yBj2qUJcEAHSFtbMeB4jkfKGeAA4t0ADOAA5t3e7/1MAEkRWlu6n7sVXrZksJIwDvmjnfvNX5u7XRC77xwG3/zNaeEW9rwXhkGFFFWNmAHjoyEacAcbtMHjtQEbqKGBdUH0YoEQTiDRbYAKbOAOmEAETAAJTKAFWAA+XAA+WIAJmCAREsE9JG0IiACCqoAhXIDSTEWA/gOW6xcVOKEScGoyJ2gSsJ0MmgAGdMTINZsLqtN6Y31gZxILcn0Rcb3CGVHtUthLjZ2tPVwJ6LrXn+Cty5qvaYyEdVknhxIO+OmfZjFiTbcLaHwJZkAGZkAHoCAGYOAEJEZ5tJV4POAEnv/clr0Xyq+8ghf7BsZAkMxYN1rbFFjh35XbFnRhqUNfF3IhpSMe4mkB9VkB4uHc4d/8FvQ84iW+F2af4i3eyp4BSJlB46chG9y2G6B1G7JB+K8BG4r/Gq4h+LOh+KVhGGgBbWzB5DtgAohgIJhgBEyA5l0gBFhgaR5IPVyAqoZgggTIvQnCBaTGVDLdPe6Aq05CGHahFEaIa5+vWCcTrOxgCfoeq3XgepEc6zMbIM6cIUOwIEEsCLFk+cIwi5QsEB1KeQhRy5QnT6ZcVLIRI0aNGp8oUWKkpBGSSp4UUeKkCI0iTpzUgAGjRpIaNJLcpAmjSRMsaprkwEGUKA8sMDr/nEghQ2mHDBiiYnjwAIODBw4YOPDggQNWBy94WBkTRw8gRZEsbeK0KZQoVKtgwbIFbJcuYMCCBRsWzJffv3518cLFi5evwrxuKV7cy9WtXpAj9ypG2VgyZpifTbuWbZs3dfLkzRtNGvS2bNqyqe7WLl+7dqG/efN2WvU1zqqtYTPmGNivV4dIXIhggokLPHiAlBBzh4WLFiyIBAECBAmRKkCSDwFS5U4V5niI5CnU/Q4RMXjE7DKFiRKlSZMcSerUqVAiQfgTsTnCRccVKziMISAWaKDBBRcFFmjGgmZgURBCWqjx0BcQTUjhRBFJEdIUWoBhkUUcguEhiCF5VMRJ/yc9UcNMJ5xQEw080XQCV115MGOLL7zgwVc8euDAAQwwcIABQAbJAAcv3HCDFXoYosgjkWziiSeilJLKXLsAI8yWxHRJzDFehunlMGRSRtlfZKYpWS9lmplMMsoow8w01tS5jWekiTZPPXvWgw8++QCajz+D+mOooYHiIw9td3YjDj3+7EMPPaF95k033aimKWrJ8EILLrvMckgMKogQwQUslHAHEya0EIIJLIjgnAlEICEGEyIIQoQLTBBh3h1AiJGHIHeIIUh6SDBhXRWXxKdJJonEl0kniYQRRiGZDHIHFF0YOEMMOViRUExQQIGGQGcUeNCDWESIoUMRxZuhRv9a1GvvvRZhlJJIJhlRRBEz0TBTTTrOiNUDXXHAQVZZaRWkAxAL6QCSPJjR5B9+KKIIJJFw4pYooqgCyyy26OJLMHlp2eVewqSZJmVkikmMmTRXZszNll32DDTT9LxZZ97oSdqff9ZjNNH5JK30oEszbeg//vwj9dSE4jOPPHc2CmnVo4kmjzqzhf2NNtT0cosvs6wCCQw7CLfAAkC4gIINIrTQgglDDEHrCEN4R8QGYqDnqxjYXUeEJHlUgcR3yBFeRSKSRBt5JoU4kggeg9gBbRd07MCFDFdcAa64CHnkhBX/XZEQQuwipIa9W3yxxRYTSTG7Fll8+DoWMSU0Be//ANcQ004w5JijVw94pXBWyVPFFcJJ3kDWHH/8YUgkl3DCiSelxEWyLVnepWUwK+/l8swup7mXXum/bObNb8opTTXYdOZZaKT16Seg+zRdqD/9CGAACXWofkztgFQ71NOmJkADVo1PYdtGN+qhNHwYzWhX61rQ5KGNYeRCF7p4BSccwQUVWCABC6AAE4aAAhKgIBF3IEEYhpA4YeWBCETAQyFcIIhYSGJZ+HEB4YJQBTx051hVqIIkprVEVHTCEZ34RCYcMYlOTKIQKOgAjZxyoxadQEcvwJHxbkAjD+Toiwor4/MUxgEPSAUDyPtKwxxmACLVkUhDOgDEIMaBD/hg/wxykAMgHvEISmBiE6AARShGYQpVsOKRrZBLLWZRC1jIohaVlIUma0ELV9Dik6C8hStGOUrGrCkyw6jMm5jxjJ3RiTOemQ1oQCOPekxqUu24JT3a8Y5e2mMf+gimMINpwH80kB/GlNo++MGPBjoTgdBE4D7ssQ5u3Oaa2VjHpKY5DrBdSlPXCE0ygoELYcxCE13IwxBaMAIgtJMJeLhc5CL3i0QMoYjEEgOt1CkIVEiCcYTLobKKeIdCFAIP3unEfBTaCWhlIhOSkER8CNGHDigljF7MqBZplMYWcYWNbaTRB9T40Y+yUY0fSOkHcnQDM8RhDmYBxFkscUhEJnKRpv9oJCtawVNN0kIWnSSlUF3xSFYM9aikXMxjUOmmZLQSGtF4pf3Cpo6qWjU08niNVnnZS3e8Ax5gdYdYwRpWd8AjHvH4BzMD2Mx+8AOtbXVrXN0aQLTGY67RzOs+DEUPcWTjmrfpxjb18Q51tMMb2ciUauQRjWH4ghjA2AQOUMAdJrSACNxR4ifygBwm3AEVxxgE4ZhDOCYE4TqBY0J38jCIPIhhCILIQ7E4e4faRvSh9IEc5CRRiCUWIgoxKF6OiBKDHMHAi8ZLro64slwaKfcGRbCCFcqiBz8YwhCLiIQmNLGWj4UiFeBdRSQvKRdYYBKTsnikUD85yp16sr2sOIX/fE+BVMcslU2UiV8rpdoZTInjM4ZthzvQOlZ4mJWsYnUHO9bBDnb0spd2jUdZvfpgX07THhjGcDDtOsx/7OPDINZHPDYc4QAe8MN5jSah8lEPeVgTsNloh6Bc0w51jCNTnKEGZSDriRd04AK+Og917smEPKwACETAGxQm8c9i3UEQVeBVeIDAhNGKIRHkEVZsCwFlPLB2Wg196BIhGtFPdGIQR9iBDnjAA6L0oAcviFFNeHADHghoDG2AqVmcBAlKWEITUxIFKVCRilWs4hVy+R74dmELW+QiF7jAxXk5CVRQBtWTtBDlUBWTacTwIjK+SGXO5LRfa+BGghK8lDfE/4GOVqNDHOGItTnMUQ5ylKMc5zgHOchxjgNLmKxgtSs8fGkPEUcYrcCOhz3iAcx99AOAzdYHMPshTGAG08Mg/rA+nCnAYO4jxeD+MIv5pA5uZIMb1syGOihYKHSsYx2aekYxgmEMYJCiBzGgWwtcYAIxsCAPSL4s3oAwBIRCAaH4adwdWFsFQfQKnniA6B0SUQUKRCCHC+fsQucZ0UR4XBJStEMU0DCHPVTPeotgBCQskT0qCbrQr3gFyXaRpSzhRUs2v3lgAOMLk0X654jJtFJPiV+arfKpr4Rl2PB3tazSg4L4wKWD6WEPqi8b1+dIh9bT4Y5a8zrXYs212HU99v8Dw6PXW+3qV5ddbGBKWMTLjDs/5P7hfmQ7w3jfq6Ey/OFDffiXevfHMIU5Yn3Y4x0KnnU40D0Oc68G3eh4xwER79dsTGMyyBBGKvSAARRowAUXoFWwFDqCO0iCOp4VRBggZx7mSEK0xBrEJ+6QHjEQIbbdWUABChABJNBe40scM5k9nolPRO4TsUj+LGy+JS4d4/nQjz6YusQlYrhML9jviy/WBJi9vA9OcoKGNOgEtA1m8IJ8Yrf/+k7A/ymwgQcUYDPnr4+3kjXCZQ12PMJuYAMn+B0Ypm1sp2zSRmJ3xUxzZ0AKKDUK1ICRkm16d3cA+A7sMGsWyA5blw4WqHj/sRZr3GAOizcOIjiC3DAO5gAPxoRM/vAOfjUNxdALxkAMq6AHM9ABE0ABFzBkJsArkuBlkvBaeNCDYTAImRA4geNaplcIrCVbTFBljpMHkiACQPBkx+Ja44EfD5UIg6BDShg4gtAJwvB8YTh9MtMlZEiGYYIzxmAzOXMZrMQz1UA/1IAN2KAN24A/QtMnfxIoS0NADhh/AnRAUeOAhgJ/0PRsiAhAUQNu3OZAUGNM8oeAIgZ3c2dtg6cPioiIfceHf3JLr/Fu64AO4yAO6FaKpniKHZiKHWiK4tCKFXhrIyiCrGZWAYSJ+UAP8PYMlrEMwgAINyADJ7QAI7ACC3cc/0EoBi1AZUMgBpkgCEDQAn0TOEbEHNDiZcSiOPfEOJ0gCJIAZbSHe16GHJiDHzVUZVRgB6/wC2LYJcWQPl4iDO8Ij8jQDM0gDdIwh3V4J9+AVUKDQV2jJ0dDNIJSQISYiI+4iPGHQITYgAY5iAe5kA0IbhEpV3MFfwr4bOy3D0Tjie0Qio13iiAZkq1Ygq0ogqI4DuFggSbYagt2kiPIDu3ADicpijbGDpMSD5Fyi/OgDtmADdRADcswC3oAAxnwNhEQBFLYAkGQBwDHHWIwZNTxjCuwjEf4ZOmRcJyVHlxWe0/GZYLAHIVgeplQW3jAjT9oLN/xHXTACJ4gc8SwDP/UoAxw8gzJUAzJkAvE0Hx7QQzGQA12uA3fQBqYomqzMQ6Tok308Fe3USfXUIEidlaF91bMtpGTUnVVdw+YeQ/2YCggdnjuoHeUuVUwSQ/7wEu8RHVUt0zDhFbGNmLaBoHVhmEKBImNKEDQppG7tGAfGZKsGIutFoquxmALBpMxiQ6v0WDIaZO7tA4Btg6vsUtZlUH/aFXeNBuKZRvTEA3KUAy4MAqWYAhNMRwmcAdBcGSol4wBRwQrFDkLp1rMYWZcaY29hR7FUpbHYlD5VFuCMJZBKAgUZyz/VGVhAAMyMAV2AAjE8A36iDXXsA3aYAzBsCXmsxfGgA138hnrgA//3IApjjKCkeIOuHgNplYn1pBN7BBMkCltcdc/FRR1k5KZmNkO2YaapWkPSBMoujQpnUgPNwpAjWhs+pBMz/aAeKc0PPoaAGhgHJiS5iCKvGmKsSiCNqYOvwmKVfpuw/lu6jCaW/WcT7dLn2hVYYMptnENdOIz0wANPIOm0NBKcUgN0ZAMw3ALoxAKnAAJXZABJGBxLBA3+0YEl4UdLvBkieNbUFYFt1d8ZIke+PGVRohQgWN6xIJQsiUIXEYtrwUERESet9ICdGAHRwBTwvANCroN8+ANDeqgzgBZwpAX2mcM1XAp4gCT4AAOJdlq5hApk6IOi0mi3GBY+OAPOooP/+wHeBfWSwLposs2Yvs3Vop4YYe3kMbKkH7Hfgo0Tbn5buhQVaaoKU/KmyiZitzAaq02Dq4mpdRZVVrKnFY1DzXGrurAnMx5Y45XptbQM5rRM23aSvzar0/Fr/v6DD/JDMbgC64QCpuACZpQCY0QBXcwBAuwAiJwHkdmAojKAg9Xlog6BOJBOMWCHsLSjdrCBFMIQ8ISqYgjLPp5jfGUOIhqHoNaBVtIB55qCMvwDdhgl4HZDbQBlMtQF1pyMpBhDNmwaqJYkibZYNP0J93Qq6b2GX6yYokSeI8IgRrpD8RKrMRkeMoWD2tHgH0HYpwZeNWKKJLyDu1ATU1qDrAWkv/nFpISxJs8iykb2g3j4HXkEGvlAIK3trfpEIrpuq3sOqa1UabXNKJomrhr2qZqyrhqykr++gzR0KaYwQxxwgzIMAy4cAqgkLCaYAmR4Ah00Ad3YAEjMIzQ8YyxtQE45AJCRHCYxVu3klpicC3h0SsmIAizJwavx5RIiB41tCpBKAmexRzXgQdDMAhRMAMtEAaR4AyAmQzQ8DVF20F0sWg0BwyE0QvJULQl2KFJe6L9gw+KSaLXwGAICTULJDXUxg/1V1cF2Gz7QGzESg/vQJpZq5Gd+UsY9g4bGIvfCpKy2IriIILgK4KfUcDnOoLi0A0bWsDigLe0NmtaR2soSYr/4ARY96qvabq4+8ozIJymisu4TxUN0fCvkmvCJhywk1u5yoAMxjAMuiALpuAJm2AJnHAJlVAJhJABFnABI+ACElsCK3BkQswCdnNDVPaVT6aeK0QFYRlbHOsC4vGViUBbYoAEtoIEXwgeumJETpY3THm8KqACYcAJ2LCPF5op20ANuCAKkWAInlBzuyALufAY3WuddiuCDeYOA5SYvToN2eBVz8RAx8Rt0KaiSbOHtxiTLVmuAfy2AVy3mMLABIy0SDuCVOpuDcacgjuTrxYO4IBuhnsbPkPC/cozkQuwO7MzIByw/KrCiWuPk9u4UKXCKix+0hANlpsMECrDrTAK/55gCYpgCJZACVTECVFQAT98ARSwASKwAStAASJAASNgAkAAcEQwAknUAk24Ag13BGGQBxTnAlVgWulheq/3lNLxHVDYjVUAcC5wQ4sjHdNxHimQASZgA4aQoPKwj9/ADXeiDcSgCX+gCNszx7tgXoLRC8zQX3uMDl4FDwKUDte0GdPQDcwWiNE0QBiJYV7FSwz2bqQIkpsyybx5ySpdkgQ8gq1mY+jqajI9iqScwSKauPpqy7a8wraMppHbuLXsuGrqykOt089QuUhdubyc1JXryzJMC480Com0CZugCZeACiDjRCaEByNQAgtwARtAARSgASugAbFSxBUrAiPAAv8msAImkAexMAhUQAWpNQRBgLFJlAI0FB4fW1vMMQQkQAT3dB7beAfLkkQNYAEbMASHIArNkDVZow3OcAyXcAh8QAiU0Ni78AqtgAvbNwzMkGrdJNFgVVfmUL63sQ6D4my2+WzSZg9iVZwljdLoNtsiWdsQHKWjCNMmKYqOItNVFYt6XMqmPMIAe8o9w9O3HA27zNy7DNQ87cq13Mo6bcvMAA1Mnd2YESfcnQww3I7alxhEZQqhoEg5NQogEwpTknyx0AlU8MNhLdYuIAIlUAIXIAIrMALULAIa4E5VwE7QnAhMYB8Flwh3k4zm3ALCAo2CPSyulwdMMAG+UixJlAn/TImM2AEE/YZZg3DVwACXfkkNyPALsZAteXAIU0IJqPALv6AlwmAZ1bANVjUoDEQouKRN+2OkpGm/AgaKpNhNMG1VQK6uyCmawrlgSJpgSh4PXopLr2FVnqzHZLopgCWiJGpq14QNdUKHt0HlPVk/Vq4bdEiHW07mY44NcRiH1pDmb0oNbN7m1fCTck4N9kiPlgvDMcgXvnDHnfRI5z0KgI7eICMKOVUKrZAKqnDoPPUKyYcKVWAB1IyDGhDWJSBbIgDWJbCDd1ACIQDO2GGxX9lOCCUJUzkEKwBwpPVaBYc4iQM5Q1Bl8LQd34wH/BY4K4Ac52x6ncAJx+AMwrAM/7uQCoKmLYPgCKjwCpSgCemYJeyYDNNwh/H6bQx4i/BKpTAtuOYqgqAYplqqrulK5CPNDvHapbn0dPWwVfJqY3RrG1eO0zi9wT1z5fJ+r2ou72du5mMu5vdOh3HI72n+k3E+53T+k/YoDc3ADM3g3Tej54dxC0F1CoAO8YEO6KFQCoNeChif8RqP8amAaIluCq/Q8ahABxogAiJQntV8AW4NBCzQ8vadQ3ngAqkixOB8LMi4jK4bN3iABK9O4fDkzh+LHtjBsYFTBdFhe9nRCfJMcMLyUJwwC1AfKrFwCY5QloVQCQu7CJqACCuOF8NgGcUADd1ApZIHNaW5Dr65tv8maILskHgNZg7uoIHuBoqgGK/OuVXR2Q7uGq9U6g3j8E3svsG2/NMfDN1Rhaa47O4+k+ZrHoebseX2juYB7+b9Pud0OOf2uN1yiTN6secOH19+bgoUz0iiP/E5Jfql/zEgY/FVYiUcr/GvsArdYyWDhgqTYAMtUMTXPOn1rQGGfQFE/NUlwAJIEPMbQMRuXRy2RwQr0ALJIR35HTd3MAhhiR0gS3uWRXCDIAhBQLLZYXsA16cugATIES27jgqz8ArHYPs92FCFMAh1cAiawAeU8AvwGMN1WQzTMA7uEKRQ4w4AgU7cuG7jxg0chw6dwYELEypk127dxInq0FUc563/28Zt27Jlu3bNmrVpJaE9O/kMpUqWz6K9hAntpEyYL6dFS6kyJ06U0aRNk1az5NCbQ6VJo1aNGlJqS5s2PXqUmTJlyZAZMzZsmK9et7zecuWK1alTo0aZOmtKlVpTpdy+bWtK7ty0b0XdfVvqLilSb1PlXfXqbym+nvhMSjQESZ4LEi7kWSHiwgomLlgQ0SDCxGYXlvMMccGZCJAWLViQXrHCxIIRLQQNElNaTJU7s+/gqVLFhZjZkpgwETOaiOs7QKoIuiMoUSZOnlB56jSp0CAiiQpR6fQp0fJJmlIRQ4Ys2fhn3N7p69dPX7pw4Qyii7hO3Xx1FeWPUyeOW7eP/yFBiiTJpJyeYUYlnHA66qUEWZrpJZkefNDBaEqSMCVoJPQJqJ9ogumoaZYKqsMDmZmqqquK0YqrXni5hZawyIIxRhnTmisuvfriK0e+UlGlx7XyektHIUv5q69U/joSllZSWYUvVOpoYAgbqhBjBQoWiICFFVwowYQSNjDBysm0dGFL3XJjobPRqtisBSDCNMGFIdbEAw8m8sBDjDvyAKI2Iu4gwgU8XCCCiNiAACIRJoboE4/XJKnEEUkLme1OQfKQ5JdP7ugklj56aCMUZ7TRxqNs0Gknn330oaedhbyBNdaO+hNJJJNawrVAXFsisVdff4WQQBJRgtAnnC4s6f+oC6MCMaqoavqVmfHGM6YYa7fqJVuwXDlFLBhH+dasssCly6y0RhElFHVDEcWtu9jdS0i+gKSXlHh1dGswIo9McklUnluigwwkWGCIFSIggoILLtigBA1KgJgCERy+4MswRRBBztx4y400F1qIczQTKhukE0F+Y4KI3Ph0AYkqiGCiCiCQiFkMPldgtIoWxMik509ioYMNKuYcQQxJ8kAlk0EEIeLSGKzoAZBgsNmGVGysweY/laL9tapkqALb62S4JptsYcsedleWeiWWxJpe8pWqaau1FsVhggmmF668CqtvVv7+m6zAZTwFLXPNKgVdeNNdt3HH1b0rcslFsTf/3ciFpHxIevPlF5ZUSPGEiwYW2GCDCBS+4GMWqiAdj8gmXoEFETRIbYUSLmMCCKMFwWPPKoBL2QQgRjBBDCZuU4E2navII3fdXQYUj0zuuEOS2pieE4hBPlEaNhtKa6GyQjIZn+nbxFChi0VEMWWXq4LRapi67Z7fWqzuN2Za/fVXhsSw0QYg1/rXvwCKLRlYsVswVMSir4SFFl7hRbZ84QsG9s1vgBvL4P6mChiVi316YdzjPDFCT4DChCccobpISEJ4QU4Unqjc5PCVlyNxrhSvQEUqPIEIKCRgAQu4QAQW4JjUhMAFbNpMnLgUOxFQoASgGcIQNDOCRAjCBHO6/5SiEGUC4rXgDlVIRB50JoYhDCIPxhtOHpBDPUkgRxAukEQnqhAG5klCEpRqntHEwLs65WEQ1CvEGfNwh0F4IhW7EAYxiDEMYiDQGFfBSnjuF57w8C9sy8AkVdD2thA5CylHeQoopdGMUY6yGXKzCt3uNkFeMNArtHCRK2D5wBbR8isSxBveKJiLWtICF7WgRS1kIQtYyAKWw5RFK5Q5zFawYhWrUMUqlOkjavpoc3jBEWGAJK8duYWb83rLKmAhzVe04hWBecUr/iADOgDhSgugwOlMcAEgbmBRENPSCkoXu8vcYUuFGEJriKAamMVMaZ1pnpxaUMZCdKIQtCHCEP9+hyhD4UGML6sMlZiAhyOE4VLGo83x1BicMwqCUmJAwuqYQAVHoOIVtkikIhU5SUhSspJWsWlOw7MMSk4rbJpsBimdFVSiMuOUcoOkVhRIQQbG0oJ/s+AspTrVWX6lRbjgxQThp8BWWhUXt/jlMIt5TGQq06ysUKY0WwFNH8mFmvX6Zl+CxM28fDMvsIjmM5GEw0NwIQUiIAKWQkABCrhAAiSoWMVMsAEtMcF2G6AMEJ4ImRVUYQRMGAFjV0AESXSsCpLIBMzwoAJJaCcPmcjDcKg0GuDgRqO/w0MncAOcMNyBClUYghh0BwTgACG3YsBDZ+/AghJUNgqVEEUqZqH/i0TGT372wx8Ci4E/nepUGctQRk4zSUmsyPRuS9VFWGUhFrM2E4MWtGB5kbneYdLCmMH8ZS1wMV/5zlcXvoDfVrr6Sq/UQpjIlOp6W5FMs1azRzVC8FzjOsPN0ete4CTSKkrxL1L8qw4dQAEKKCCB08XzAmIYwWi69CWHrcBkEAPCEcVwGTWxgIstcEHGOhGbIRxvUzoL7nbEGJyBiqEzblrUywpVhU7M2LctIJ9Ef0MlN/0pEbqj3vFsR4RBFBIVq7AFIhe5yOc+d8uOjO4jbXo/RSpVlxPURS6+2qKwwEJJynSmNKGp1rSWd8AEvjOc0doKV7TCvX9+Lyz9O19C/+civLpAtC7wtshgtNLRYL0FMNcb4LLiuRU9ujQ1ETyXui4YwiCUnIPl5Ra9fo5ynuhDB2xgAxJoAEuFYEEEJDACEWypBCJYsQYuoAEWpAlii3JBEJa4Akm8KXbuLF6hENUCQ/1REC0o7ZMFUWPfRnGgzDa2H5nQAhUwYTuGkkSNq7SC8NlxT4kYhJ1yg4dBIOJfykWkMIAhjFx+Nxj0zmW+z4xmNdeyz86sZo0MTE2zvtnObnaznZdZVle0F5avnGqk64sLQ0/QF/cFRjCI4YsU4dfiemMqxP3730or0+Br7RFbDyyXvLQLhO6SXI6uGepOz7BJhQHdHDLQgR00sf8EZcLDCCRggQlcYGK0rsIGJLCBFpBgM4RdgQaI5wLJruCNIwDCCoBL9aKNdggq0F0VbJACQWRCEFlfKGlyZxoXjIBQw5EEHoCAJ9CqMROMiuIXgRDcSSDGZmbPQyAvIRgs72LewED8fX0BjIvbwvEJpwWc27rpGsE8LzZqSymiySNqStPAfzt4Mv+23oYP04FU7S/FEb14xCNeGK9HRjBugd9hZMXeCtQFL3gZTP+yVxa1MLha2bqKI6mCRw6G+eSU73KXg5rmoybMv+7CiTk8gAQi0M3CXCAICWgACEXfgMJGMAJXb0AEExDBaUbAAhCbgAhp4nWK7/TbI8KsNi//k8QgmKcC3pQGtxIdgkHxIkE4mkNhgu8phELwIkehOtAIgSpggTv5hU7IgzCoEztChU6oA01IJ1hwPMPbBVugL/96s3Raqw3ykeLjvB7xJrlyl5ZzucyDi1KICwRbixukJlZQBT3bs4UbJv/qJYkjtNXLuNe7NyNUpFzgsvjJt4sLr6/qPWRys1mYhTebs7XiFxU0BcyRIXmZHJjLEeVrQXlJBVTgC05ggwNgABHYgIX5kiCaABIoDiAggdRYOhMQgesbPwrYDO8zujrRDYOBo0+QGZAJH0DpLCZ4jSEQBBsIQN54qLTrjSqKhUzYGUYpjddggghUGSIIghQLNkNJ/4TZoAJC4o2joYM+QIVdYMXWs4VZsAVd8K8qTKdaTKtSK0MKm7B/mTBtajAgcbkYihwQghcamQvBwSDQawWEA7CRmzj7mqCMyzdgSJFlMIZmQIbbs7g0WzOJ+z1nJEGzEj7iS4W2UAVv8kXlgzAZsovmOxy8uBEnMcO78AROqAQoOIADUAB4EqIfioAIuAA5/IROcBNdowDGmjZ9sgwmGJmBAoIIrAwX2yMTMA2sgzETkJkno8g7OIJt4xi1o7rjIIJCSIQ5DK6mEylBELY/2ZKUOR5ECQIxcIRBCAPgmMO5Q4VfeL1EAgbD60lW3AUqBD6EM6d0eqajPEomwcWkPP8SpkTKpyy1oyw4s/K9hKPKSeu9QasFx+MlsFK9NFMzXpogYliGZjCGFtkWscCgGKG8w2kc5mucE5JLEyIhUFAXuXycULBLdTELWeqb32uFWmDFVyAENqiCFDgCGRCYBmiACrCAhWkMeFqAorsACwhAEbCAESCseXqj9HuY9HOBySiBipEdjHmYrAsTJiCBFBiCzZCZIQCt2LABKuANRhGZERiCL6ISrZOZFbiDymBAJCiU3GwaMRiZYCOyGaOChAKCNIoFeXs9oGRFx3tFKpyFoaxFo4TKZzqn7WxKcuSX7dQrpFS4O/M9AHsvqxJCQmNPiqO4XMgFYUI0NUMGZ8D/hmSwqllCL6jCIB9xy1HgS8aZywElUAIFF7J4IL2pvWT4CWxwUGxYBl9QpFnogwygJwmIQxKwgAaYAF2DIyCwAA2wAKL7E6W7Ew2IJ8KSGF2znQgYMcmotQsYAi2ZGAr4zUSQmSoIpBUAghDwzQAsDeu4LTUahC7SLSCwIy5SuzswgTz4mN8Ajc/KLd1ggSFoAaQpBDz4BEcJDjdJATbQBJ0UBkT7JV3YhfCyTut0s+ysRfGEyiyE0zhFSlVQxvI8z0B7OPXsRvX0yvkytERLNF9ohqfIiryZPf6SOGFSy7UkHADVy7nchEiV1E04oQMNi1t4rvxhBmmwhmvIBljZ/wZvkId5qIdSlYdvoIatIAZgMIQX6IALuBKMER4VsIDNFIMpWrpZ24ARTR2GIawNwIwwWZiDNB0RAA3iMgHCurVaE4HXkJOBRIIN6IzQJAE6sIFfiAWO/ARJoIJauywg6Jk3qZM3UbEousQtcYHjMRSQ8qMjCCOLEgTdYoIw6AI4uIRZEIbrNNNYTLM0rcIp/Nc2DQw3Zco45RcfeSY7pcpiQiaSAyZa4r2Rg7Svek/4/Er4NDRckEUJTaRgcIVgoCS8uYVWUjP2hDgLIhwZQS8Jkp/8UQZomIZqGImP6IhQ9YaO0IhxIAdzKIf3WAd/2Ad68IZrSIZeGAZh0IQXiP8BDYMnWB3RCZiA0qlMIlCBCRhRxpyAocuM8QsBLBlWFwNIJ0o6DYiTWqMdfZKMErAZg9G21WmBPOmAMLCBT/gFOqCDQRoEEWjO46FA3AICKrAAGxAEnRmESQgDR2CeGsuEKqCCQiAkC/TI3BKEyR0EN0lFOFBFx6NCETQ0Z6TCV0hThCsnNu1OO4OmpjRY4yNPqVzGhCOm14UF4HtYcGTPiStZQ7PYisVYXbgFXVgGYtgETDAF5mO88HK043Ulr8iW5X2uaXmGaejUbNiGb5CH6p2H68XedWiHVtnedmCHcZgIdhBfdkiHdDiHcjCHi1gHc3AHd6AHdbCGo1AGW2j/gxu4gjAQAR9SGA0IvwuIkxEYUR8yAasdOgnoPhEgv6bdgKRLPzZpooAqgeEhgt5Jv8WCGCUigjNqAZxpgeUIAxSwgTDIhESIAtuaBNIwDUYxHhIAgiNgTSqYO02BgjxRQOahDdnCgzCgAhirDT/iGUFYARIYBEfoAjaAA06YhV3wwDTzhfm6Tn+lQoSDhXNi04Q13byKU+PLq7VaEmgyufIqptgFx0jzClygTurUXYx9T91DXhbRBWIIhloAWWGwBTp1BaxSEY57rmL4GmaAWWwolW+g3uq13nrAh0NG5ERW5Hzwh3xw5Ed2ZHqQZEl2lYXoBm74iGzgBm64hmmQ/5ZiYIVNmAMY6IAJwBLUwTorQR2pu4MRMLrGuMMRdQyAXBggmJ3NMI7/vbUhwBPMKC4vYQFew4MkUqIhQIEdOAK7PQIqyMCSmQQT6DWVqYLpeZMWqK3cioVj6AQbmI2m+SLeCINJqASh4eEvkoS19RJDYYIjOAIcsATQdTyNZU8olmKjbFMuVrhnwmKl9BHAKTBlLCvzlFivIjQ09lP2xNhcaOMIWt5dyiVecIVeSIZoeF5P/VRRxd6MrgdSNWR8gORDLtWQFumRDumMngd5gJVMzuSRGIlqcOlqiFlokBZfGAVMgIQ/QIMMaABXS4CGgZg21ACAJLoqsIANMM4ECP/RyszMhTEdChi/EcAtP2keXivJMAFiL4k6QhmU7UsEClwUErAB6jktSXAEm8mD2ymeKglAK1UBkiyjWOgEoQEUQZCtl5k7uO4COvDERIiFeAWjqIvgPmGTKIiBQ0CFzT1oXLBOW5DiNc1OKy6vzhu4HFRGqJKlWTLPH6wFPuVs9XS0htYK+/maZwAlaogGalGGapheUj1kSHbkRYZkf5Dt2c6Hjc5oeZgPWVFplSYVbfgIB+1tbXjQ4aYGbKAGs6QFUHgEQ/ADPYCDCiCYBUiAXdOMIFIYLroA9Ctqst1pE8hM1EqdeHpIEyAfowuxcBOBO7I63gmCeUIpOaG66ej/hF/4TRIggTAArhmzAToYBCrYEhYQNsuguib7nd8Jg0HYtsnlDRTOBO2ggztglNL6nUEgHzlBApdBKYnqAsP+hdbz8NYDyiyjTl4ERndhF7OQC2OsC7VYOVNAxmT0Z6e6bL65Beatm7FBCejNho0QB4WYj1G93o3GbSAvVY+e7UbOB0TuaJCWiO4VCHHQj90e7imn8ip3UKVIiqtx6VDCxmCQBVPYBEggBEVghD6IgQyAWvSDWhIYogXQNQ2QgJ0uOhHYmSrAg8wshLa7ACTAAwTWgA7egK1NsQvAuvUzNtUQo3yqAiTAuk1xczpvgVrbrC1xkzIJSUZZNjcho9L4/4zVufD3Iw3eiC3f0BM26ZM9QSkiQIIgoJKVoYI6eIVf+AWgRDRW3NfNtU5SgNMeEUNTWJfDMQu+PJyUJQsLGtlsaVlN/YnoDVVCxl5Cbod2cN94sAd7mGR8mORrr4doF19zaA9xuGRM3u3/CIly79SQwJoHtQaZtfJ2p/KkaGksPyVjCAZaQJdNUARKuIRFcAQ20GkDhtUJoICs3QAAhnMLkIyiRrI8aAFCp0yKJIKlUzoRkAAbHYKK56LWHIHIKIGY1I2fg+bRFJ4RSAAvKQHi8ZjUgDGVWXUkkKjhKijV0BLhQKkgQALUnBMqsxkIfzsVgM0MrhLjCISbD4I7oP8D5IqFEIRFEdcFhMPO7iRHcpS5UAt2YT+hUBAXGHGFGjdaPk4GlZgGT8VZb6APeagHdYj2djDkemiVSd5eejh7daje+RDkjsBkiyb3cu9kc2/pTmXpkSgJloZpEPn7dY9ZdV93l57yLa+GKW8K44YKaaF3XGCFURghS7gETxCFTjgDDFMBFTg/OF/gFUgA4xFRq7UAp2uBghc6/5U1MDlIFF2AFmANLrmA9s5uF3iYxfr4MpoMt3O/hKkdaF4UIgixOWH1QMk6qstgHsWZbUuxKrr9eCUjQvnNKDoi5TiZQvANx1V13zQODOdvUkinKLZO2VWSNWWS4lumwnHxGMn/+kudvZbtY2hg96yR3lClj4VQCO/V3lYBCHfr1KlDN24cOoMGxXFrmO0axIgRrV2zZvEiRYkWIV6s5vHitGnRRkaTZvKktGghV4b06LIatZgwUZZspkxZMmPFhg0L5qsXL1quWLE6pcpUqFKkRKFCRSgDiQYLWgi6oEHChEySFlywIMGCBgsNJLgQFFbEiLAbLqyQIOGCmDsULlxYsGLIigsUNoio4rfKCiIu8LjIAwTIihZAqhwWIWYQCyRMxAAxIUiQGCJIiAQB4mIIkzuJ8BARVIgzEjF4xEgmUuWOXzyC8AxBkkiSpNFDKNceQsQ1ECZEgNwhQqdTokqiXsV6/zXrFfRV0J3DStUKlixZtGjd6uW9V7FiyZIxm2Yx2zZv8uapk7d+Hvx67t/Pk9cuoThx4cKBA+cw20MQsWSeRSxhdCA2CV6koEXYZINNRQceSKB5K0kzzUwnlWRSNNAww8xNOBmjE0/D/HSLUKeoeMooLbroYigxxqhKK6qUUkooopDyiiMddNBAAyMURkIEdWnAAhAkXDABVkBOsMEQE1jg1ZQSiKCXCAtcpoEJE4gwRCZMWGWCCReYAIQkgiA2xGIssFAWCa8xsVshYmTiwggt4MHEIJv9JtxvVQwxyGmliREEbKy5IIagdwwCBBGqAYFHmkxQoYIYmInhwmtVDP/CGKeuhXbHEXhUwlxzzUGXSlPO2aKLL8UoQw0228B3a3zz1LMrr/Xg8yuwv6ozTjcOaTRhSNaspOyAyzb70ksJSouNNdVYo6BL0nb0kUchSQONhyCOp1MxwfgE1C2uuLIiiy6C8i688cLrCb31eiJjUqkoVQpTnjiSRwcVkNDCWBeU0JYIFCxgQlgXfOWWBAs8rAGQFmywAQUstPAklyMAMQIFcYkgggZWZVwIHhtoIIIkn6CVqSB3MMGECruZ4AIRTJgwGqRBmNCCX2IADUQLQ+QxGaNIILHbalW00DJsl6VWpxhDhFEFEoXkMUQVggxXxWeeZZYzEGHkkUknmkz/UgkhgxByCCGLeGKLMMOIhw19uOoNn3vffAMg4IBzJCHhGFpUjeEtES4htI1bu61H1KAkjbjj5RSeiejekq667LL74ij4vhsjvJuYLi8npttrr1KkLEWKJ4dgQIIFKYjBxAILkFxFCRT4LkHJYU3ApARSLeDVBQ1YcEEEEVCwghgbTDAEmVfSRdcKIhQpwmcrbDCwJC20kMgneQySRx4q2NDJICSYRsUdWsuWWRWZ3qGCx5IUAigSLiyaB2Xiggc8FEIQilkBcR4Thk9kQhCSyINrSMMEPBBtZiZA4GHuoBo69MEOdhBDXOrABi4oQhTEQEYylDGN9HhDcBkBiYGu/4WtalGLhtPChja0IS0dJoiHN/whEGEiE5dILhrP+NBNxoW5n/yEF5tDkbqi2LlTEMVzRjmFKbLYolC8SHTyehe9TCdGTnBidfRSiih0JApCnCADIpgACUZgAQokwGAUaN5cIoCVrjTAYcMbXgOe5AIN6NF3QAOZBCgwAr644EoUGIIkSlACDcxJAyUgmfsGIYhfZKKTnciDBTrRCRWMLxFQoMMdJJGJOwzBBROsQp5eo0G/BAFsTKjCLe9whzwUpwVEKBoQbDAIVNwhE4UYRCcoiAe/CAKAt3tmFRIBGw02Ew8AzEPMxFAIRohiGTf5UHlKMo0LvaRZGIoJNV6CTv8hSk4aMkFnOtOZoJhMqxrSsqcQOYTEJI6LXDzBHOaC0QtfMJGgvtAFL3LhRIUqFBdP3Nx2ZDGUoRBFFRbNYozSKAoZvUuMHv2o6VYhnVWkIhWqgEUtbMEcVPQBSCPzne8wlkgJOI94zqPAW9zivOZpby5zmZILWhAW8XnFBCMjgQhWsII7uIAEJFhBHlZQAhOoTBCfEEQnLjGJT6AiFlTQANeGQIVB0IEOmRjgb4gwhCGIL2eJuoPSNAgamQniU5hpgQl2I4go5KEQVIimJAZxvkzEpa+TiZRf+mpNIqDvDqbR5QCbSYhSnHA83wQnM0gyknFOzp3w/CxoQwtPkzT/oxngxElORlSinvjEoAY1ly9ga65g2G0nPPEJL2JLUF3wFhe+zYVvcVGL4dYiO7KARSuSq1yLHsUUGr3RjTYaClDgKxT08mIqXtGU7JL0ObNwSgXGsoG3BA9jCyAeBUo2gZ1GwJG/GxldFqAaiuFPeQMTgQVIkIIWMIEEeCGBCZR0wRIYjHoXIJoNoNAFFRSTCSJowR2oUAg6DELCMmPTYXxzh048Rmb1u6VaZUOpPEiCw0zwH2ha0AlUACERsbgDEHgpBhZUYTWucU0QWpAa3OBBK9gchGN1eZlEoAIYyECGMY6cwhApA7PgbMZJ2unZ0OrztMlAsjFKBFvX+oIX/wMtKJe5PNsxszY8WWbtQQ3K21ywGRdtFm5xZVFcWNAZucptBUlLqueSHgW6rnOdRmUkXVHcqKRNcR0qXrGLVBwiAwrQAAUmsAANjEBiFDABTnP3FoXtxXc7pYAIiIBpCpRgAywgggbgeJUNgGUEIlBBUGFMhEuuQAMbKHXJSvAbF5hABShIMAkq4zEXZEKTWmMro6qQs5m5IBGjATIAlV21XYrmE/XLA4dX4D8XFOIT5RMN0SK1mBYwShAzYwISXpOIQuxy3dhsJgBlkwdHpEIXwiDGCY8coiUzWRnL+PeRkbGMgI8Iczz5iXd4ofCFM5zNueAtb8W8ZTG/1iez7f9JiUZEottO3OG/9S1xjVvnOyuXpKooqUhTLlJDNwW60YXuc3eEilS8LhakOAQHMiCxt0yAAi7wKRCGUJdE6iWmF2veAvZSBeaRGgkS2MACSKABianAAiMYwc1MYIE3EliSpObSxTbgAm3vZgc2UMEG8DoCIrCAUkCwk9BAeMv6rYYJLUCfsoXsNTzIzHyt7MQnhsACE8wMUruxnwuUlm7N2CkPgqqxA3k5CL5bE315kM1sJvEKWwTjhMbw/IiIYdueEFThEKUFUVLPCnVlJ4rbocVwgwtcNuvi4REPc8XHrHvWDkMY9743MTRO289r2Se72MWaHQ7c4Rq3+XdeBXP/o99nl5MCFX/W0Y2WolFCE9r6S/EEJ0TBhwxUoANvcZhVKjmBwyxpLhqgtO/MJILx4rR5Rer08hjWAjmOoHgWMIGrzRGpzQX3SBIISRICJgYJuEAJLIoL3MH+YUoKsMlg3A4vFR5ovF3e+YUuVY2ogMrP3MViuEAQBMH/5MyhIAnfpYayoaBsIMEdWNNlVJ75aBK2NUctwIpw6UItqEvqeQ7oZJEQZpH0EYUrKFd2EJebuZny8VZuVZxr6R6Z0RYxAF/waVwxbJxsERTy1Z7H4cLrhaEPph5zDaEZmsIomEJ0pREXjUL0tYIsJNcqoMIiLAIfsAEUdIAMVIACKEDu/xSdrenJlawAk+AU0V3MBYRACOjFW6wFxrDACkTAWXQFCP2f/4WFHF3ArWHMCjhYAwoC7yjVrQFYCTJgYJhABzhK0bBGsYnB0bBVaORSjYUGLvnFZITGcLRAEAjJYviG0uBBEAiGZwzjZCAB0MSF3GkTZpgGvMWMNU2eJLRKjVgU9F3UGYJOEA6h9DEXEsKhdnDHQ5kewy3cd5RjbEmhiVwcTyBDMyBDa5UeQb0ZyDFf60XRD1LRRakCi6jIKFCRumxHd/iC3RhDk5UEreSQNlBDMzjDK/CAAxzAASTAASiA8SxAAkjMECTMBdCGkrjFkjzJBZBAqeWFTvFFwkhACf+IQQhEQFp0hQXgTFhUyflpYgRsQHv93MUw4AYgARDcWlKtACTizF2QAB50AhUwChEkgtM4zS9VAS/5hTERRxV0Rv08xidIwgggCWC8XaQsTRCwQAl2RmfEmOMNR850jTZJwi7NRuS9GwEJ1iSIgkmZgvRZUbtgo+ecYRESRXJJURgCJIo81C2Mo5d5x2tB4Zj5QjNQgzIIVC8M5mA6kWC+XhStiBT9o8IJZBYigzJA2UHm0DaEpmiOpg6hkzQsgyxsgh48AAMkQAIUQAJMgGvmjmu2gNSxRQvoRarpxVNpwAos4grEH13kJl9sQB7gyQhQhgm8hQpoAJ5YgJdswAj/6AUeYcyV2JpUQWJSYYxfDAaZUIEdyIAx5VKMCcdnFIIkgBAefEIsuIbj+RLRQNInFIfi4cxUQgoQnBqJLQ0R4AESaIVTFgLXNFNdoU9dXcZlFALKaFKJ5cEfiIIqCMUtEFQ4MtxjdsdjugI2puGLDKHqGeFE/eUtBBcueCFC8QKsnKiFDhRQBMPCoQguOAM1OMMwPOaFCuYTecc/iQd5uBMOacM2+I2Q+g1pImSCRM5KeIS0KOQyEMMtqIInUEIZOJprPo8GXOR49Rxb6MV42VrEkJomjldNip0mrt0dWMnzGNUICAfDSCdatIAEYN0FDOLFjEAzvd8FbSebmEAK/2gbEASBJFRBCkxCc7BBJoSBK2UKE0CKGOTGNEnTEGAG0UzK7XANZTAB+ojBCtQYZXRiDUrGVCJB3WFTfyYCVq2GWyJozFzGj+FBHzzCKWhmFoaHbdFqjZajd0zRipgCFVUUX66eX9JC8yUhGIJjhZre5hBmYSbchAqDLnRelumEQBmDZTGDj9ZKkA6pkIZmDmEDPmXI5HxWtPwoD1FDk95CjHCCJoyfbB6AWyiPdE6JygjY+1GAkrBFXtCFwixATWrP5M2FJkrAmYyAlKxFligPpVHPk+Rn72zAHXyCUKUApNAa9dAMUOYVEGQAGzjCMaCCHQAGlGyK3YEG0swMYv+JgccAx24MgiQMQQw6Cmmw0mLET6DOye0oTWiwQCZ8gohJ01pOXtdgVSx0myTgQRhowiVggit4B602La1+h9PuhIuiSHLZ2chhx7AOKy04FEQ9EWHi6EN9R22NyHgMQyhswlCAgisYA5COZmg+iLdGjkmEi5N9SIeAyzPk7TN0VkpUC0uYhOQoAzIMAy6YAiioKyT8gQ24ZgIoTANkRsQsz5yaCV1wjMFcxabdnyKxDB7wa8KAWhVIz5z20QWgWh8B4HRap5mQgAp0gAj8GhE81Vq9RhgEE1RNWB5AQSccgx2kAPcYhmxMysxUzZowRivl56YKSnoKQiYojQAFHQz/mqog7AbXkIagIAEzXoYYJEIyOcr5hIZVeVssZEIiTIImNAImYOjT4qp3YOhD/WNEHdcs1BmdMd9wvR7YJqsTsa/YZqHlZJY02FPbjqY0BIMr0IKLLm0yxIRmQcMzOPAzkIQDMwPdRoOT0W3djgRKmKYFg4jgmkgtqEKMaF8l6NxFWmQCzF/xNIDvkIxvDs/RFd3kFgkLACxdoMVeXM9aPB2rmcnPCE1aLI9NOooKkEAG1AwdbMAFnQlurBXQ5MEOhMEg9EEdDMIRvF8sMtBiUNC5+cXXBKMtDgIImYAqLYZawRikVEEhSEZwbAZrOF6m8JfjSULHWlMiaFJdDYIx/01CHnzCL3xCIfSBIrgChmboUKjIh4KoFCVXdiQX88HeExmrwrGoQA4ktTbZMxgOgHxDtg6p2wZONsgQMyRDFhJkTEhDJuutKqvyPjUZZrly3fbbkWlhl6EIKzAXv2yUJzDFK3DCEjSAa8LmAgBJH7nFxUDaBbQATs1F0hmMTJnJIGhk80xnmtIFr1kMEKAFEVgAprisCozMWjWqChxBCqQAtgmHULFAH2eC+XQCE0DBEUQBFOzADNjALRXNEGgNuR0NLmnTb7CGZkyG/vRYpwABEmATAOli1yxGEMwGAEVKsoFGzNCxIwiZgcKbB2HbL3TCHdSBHoyCunxHIifXUf/QSCsocur94wFH5kANZApZK63gkJDOR97Mx9uCskRoBIDIkLf6qORQQ0iAi1Df7QNPMDhZMGqlVkCdCOcc8l2GDum8iy7bC1OgQgxUwJe+5kUWzEXOqaS5X+7cUfPQBdJFgDEa1R0dmEaCGhGsxUZC0C8hlTmLz8zcwQqQgCN0wgywLGEFxs+Nz7+EQcuqD8sSClv5RmjERf0QR4wxRmRM5XAIR2B1UqYKR409JQiB4rWpBmuAEKPY8fmg6mxEFspEFvqMRjMZwiikS8LZ40i7HoaOrTJosAAHqTx8A00LqTd4wzYATm8DyE0DNyijx3BDRILAbdwijktUi0t0FhL/XY7UAoUTCcW62GVzCWGLqGHogAK9lJG95EgawUEGZAAwpxptXuQKVFrSWdpMNfMdJV39+U6ZLJIEtMCd+M50lokINIAGqACs2eb77QAKFNPYMUomvBgdSILdLdUdlMDl0QamhkELhEEnFFuaUE8LfIotBlAMUkYGbcbbefZVFtChqMY0uSxpmDEIadBqvB1xpMknDEIYhIFo6FL8NJBbyuDlMYLSLm0vuCguHDKNxKGbTegyyLS2Jvk3eAM3BEhOTwRFAMg1AMi0SPlwXzmA6BAPMbdIsMQEo9bGJZxkNnUVIXJFYZEQXvf0ZdGN4Iu9eLcmiDdWR8xs1vmkKUzEQJRM/xniWPMre/sUACaMg+nFBSzSnHZJA0gnUo3Mr/2aC2zAonZbFaDAnJwYziDJHdgAaAwQ13QSCgyBbHRGQAAAIfkEAGQAAAAsAAAAAEABAAGH6L6g26+P1qeFzKSJzp57xZx/wJuAvpd7xpNtvpNzu5J1u5BuuJJ1uI5vtJB0sJB3vopguIxrt4tqtoxstYpntYhns4xus4lrs4lms4dns4ZjsItusIhosIZlsIVhrYlvrYVmqodtpodwt4JWsINhr4NhroNirYJerYBfq4NlrIJeq4Beq31cp4Nqp4Jmpn9mqIFgp39fp35dpn1gp3tcpntYo4Fnon5ko35go3xionxdo3tionpgonpcnn5mnnxhoHtfnXtgn3pfn3pdnHpfpXlXp3VQondXoXlfoXVWoHhfoHlcoHVWn3lin3den3dbn3RWnnhgnnlennZdnnhbnnZbnnRXnXhfnXhdnHdcnXVdnHhanXVZnXRenHNdnHRZnXFPmndfm3dcmnZbmnVdmXVbmndZmXVZmXRYm3Nam3JcmXNcmXNZmnJTmXFWmnBOmW1MlnVclnNZlnJXlXFWlHBVlG1Ulm1NlWpKkHFbkG1UkGtRjGtTmGZDkmdGkGZHjWhPjWNEimdPimZLiWNKiV9AhmRNhWFJhF9JhF9DgGFMgF5If11Hh1o7gFpCfltDflg/e1lCdlhEeVY+dFVAfVI2d1M7clI+c1E4eE4zcU43dkcpa088aks3akkzYkg2ZkUvYkQwYEQyW0QzY0AqX0AsXEAuXD0pWT4sWTwqVj4tUj0vXTkhWDkmVzkmVjooVTYiUzkpUzgkUjYjUjMeTzgoTzUjTzQhTjIgSzYnSzIgRjMlUS0XSi4bRi4eRikWQS0fQScWOykdOSUXQSEOOCERMSAULxwPMBkKJxgMKRUIKg8DIBYLHhQKHhIIHhAFGBAGHA0CFwwDFAwDDgsDFwYAEQUBDQcBDQEACggCCQYACgQACgAABwgABwcCBwcABgYBBAcABQYAAwYABwUABAUAAgUABwMABwIABQQABAMABQIAAwQAAwIAAgMAAQMAAQIAAAIABwAABQEABAAAAwAAAQEBAgEAAQEAAgABAQACAQAAAAECAAEAAAACAAAACP8AmbQ5QhBEgQIwjshIQZDJnSN32siQcedODRlMehwJhAbNwBoqPHhQoeLECQoYNFDQgAIDBQ8kMmggcUIFBhyaaN36VazasmKwaMGS9UrWliM1ihSBMRHMGzBFjigFY6RIjatYS5g0sYLGRRkrSqpYQZaFWRRn0bJAiwIFTbMsTJ4gQVckXZUzSWjYq3LlSpEnkrbBROoUrV+/YqE6xTjVKVOjRJmaTBlVZFGSVb1KVQoUJkyaNHnC5MkTKNOX+CgqNRlVsWXLlClLduyYsWLDhAEDtmvVqE+cPiVL9kn1KGzypk2TBg2aNGnRrEmX5uwZMk5yzlAZogMHDhgxYLj/cJECRIgPHDhs2GChfYP2Fho0cOCAAYP59vPrP8DfwIGDAA4goIACFBhAAAIh1YMOCQjQgUIE1UDQG20wIaEMF+kQUQ+J3GEGF2DJBZgHK+lFAgoiYVCBTGjV0MEGh9CCiy7ERKMMMr0IJUsqtOiBIQsyqJCCDEUwYRVWRlwFF1ZkrWCSDDTIUMJYZGEEh1VoYYlCEWDAAcZaJ8pFl1wneKCBSHyl2ZeZe5l5ghFv3DEJKEIR48ssqeSZymaoVIbKn4D2aUqgp4TSyaGmlQbKaaF4IsklpZxiWS275FKLpbnksooqo3Ta6SegfjLKKpzkkYciu3CDjXLNMQeddNZQ/8dMMIzMgYYZ23Xn3QwziFdeCCCAkN567V0AX3zzyUeffvvx5+x/ARYwYIECBECQglaAMEABGkkEQw9W4NFGCikwJSFBbbyBBx5LtAGDVia16UFKJ2jFQg0saLDiTCZNsIEcp9zSyy++5BIMLULZYgoukMRAgwoymAACDFjdW7FccMVF1lgSWlhDlGTVYOSSbrWlFAsn0nXXXjTNNeZcFVSgpgQRqOlBDU79gQkrsPRCTDC2vPJKK0TzGSljjAGqZ56o5NnZolCbtmgohlLNmiigcqI1JZJQcgnXkoQtttim+mCqMNasOk1zzUUTnTXVQNOMMq/wQYetuFLRnQ7d8f/q63jlCasesfAlK9989NXHgOIM8KeAAs4aAKC00wpAYYVWZJRAABP0sKBGmd9hxUdXwWCCFW9wEQgXKZhQgkjzYiB7SnmdwIJNGJhYJgUWtODJYb/cIokoQd0yy8KkzIDvwx2Y8KMKSsZFpln1ktnVVWBtTNJabNGFQg1JJMGCzGHOxbJeZMK8UptlqokSCSzQgEcmrNDCC2K3uOIK0a2ckidjRHMM05q2tM2YgmqhAEUCPUGKqSGwFFQDDifCNkFFWFARfOCDITKYBw7mwQcgPBUzsMGNtbHNbW+rxjOccYxP6KEOdaCDG86whe1QgQoL0oHfcPAC8pQnPem5gLH/jlW4wyWOcfZ5XOQkFyACMeEIo7MCFGOwLc+Nrg1tGN0RdMAEpshAISkIT0RA0IG9qKgCFKCABChQAQ+cQCUYAEyZSrACDzRgAg6IRC96EQxi6OIWQsEFLmLhCl6cgQZFYEEJOoABMpGkTIChUlhKQiatnEkrJcikCtrSFpWpTF95aZnL9JKXNJHPRCQwEwUi4BcJVAB+f4AELVhRCk+kYhb841+echnApRXQMacoBQRP4wkIQvCBERyb2BSxQVM585kfFIGpOFENbKjthG6DG3WUUQxK0EEPL7zbrbZghhpuBwje8Y54yCOsYAluiEIkorKWxSwlPgtalBuAQOJ0/4c4teEAAQDBEqxohSdk8QhQUAiGFiKDGIDgDh3IgIrWWAGXUNQDJSClG+Miu70cYAIW4AMtBhaMP+YIF7OIxSt+cQgihaQDL4GdTCPZJCeZZAW3ixcmzTQlTrrlkymrgCs9yTI1zeR88dpLGlmZRpkF5g850YQeToFS/bkCFrzkpS/zJDQ+OUaYCxSmWMFKNU5c8KyKgKZa8yACs+VhFdYsoQmj8YxsVmMaz1AGMBaxhj349YVzaENHxnlOdKrTV+Qil+CAGE8iIuuIjIPcPZtYoThBoQ1Q6IG2CjADHRj0CTi4Ax6sIIMeOA9KMsjABBbwBhnELI2wVWMaU4JRM/9hVAMd1UACFuCAH5yCpIJE2C1uYYtU/MITOqjBXFxiM73IsSZkqV5SNTClemGUJG0xC19SVtRPbpeUonSZBkyiMpPIrKkzYUEgPMELUiiiE6m4hSxkoT9dFnAzvuyq0AjIGqqBYqzBDCYEJbHBDF6QD3kIg4LzEAdTKdgHYRCBhH2wC2vKA5t1jc5dnaGMXBhCDoMYBCD2EE463G2G5dzOELijKxjAILE/BCIHGutYZL0HPwxQQBIlG6A3HEFdUKDQEWCQgAFMrAdYbMMfAnHFqyDlBBGYQAM6AAYJWBmNEVjjJV9HgtehCaNl9MBHNxACTdwvGLLQhSxgMQtc2CL/Fr1gBRVkMBeasWm7MpXLI7WyghLsJZNkyeQJwoIy7ho1oxkFKnnDayLYpW99fNlSIUDBCmJY+hezqC///Kcn/Xpavzt6RZ+CSTXGHC0UhWoUBjuYwVYnGIRxUHAcQAhCETxAmsaQDjfYBg26PuMZ1lhOM5KhCkHMgRAhHvEeYAhDGRLWDOVkMQ565WLFupOxQ6zxsRpgH3ry+CBgeCJBgoyHhBagAVz4Qxb/IForBKINTkmCCWgmgQVEAA4ryAAFMhAznpKJp2aKowlM0IEOTKADLobEL342I1wA0s2yGJgdYsDvBCSATC+jJE4nWS+c+rkDryuJCcZCpLOArwhu/2EBGJKQURQgmi6ZTOVMYDe7io7XJCRiE01OhAIwZIIUvLA0Mko6C1ukNBazIEoslj5fWcwipU1futCI0qemHXOsYN1fKRIcBlNp0BCGEAQHPfhMCYtAEc6opjxcJY1f15Ub8pDHNaThC0kgAhCCGDE4mz2HOZwhb0PYwha4c9hqx1jGM9a2jRGHxMYdgIkF6BhmoXDZI+BhAgWIQRt0EIM7/GFdbcCZi2iW5QhE4AhMcEkG+J0SUfqZumb0wMCbR4EOqAAHgwh6MAQZXFrYwha4IAYk3oWBBSSgLDa96U1ZEJYTZBdMBT+B6wbdpLSsJZNcKoIGVH6ELts24Oelrv8HZFbbOx+VX5x8w8/vt/Bf9GK+Kn2F1KO+9Pp7Ok+mYNpkrCZWU5cCq6HwQS0gYQpWgA22VqZidpwQDdVgDRfmNr8Ggda0DW0XC2AXYiL2V3XwQnUwByhGTtHGN7sSHonlTos1ROtBOI6VOPkROQeBUG8QgzIIB4HQAwXAAUcwA08QgwnlPCugAQuwAPRGMxlwByBQexjQAeQHLx/3OnsxcORiEyN3BGfACojRC7yHCzJyC8GXPD8YAQuAfNFVXTVREjF3IivgFq8TMQWXAW60AieiSBnQATGRAZxUBOJzJmlyRszlZ2ykh7KDJrh1PnShfpS2cMTQC2/2afKnXwP/RBmQSBmYgTWiECiAYgr0BQofZAMT9gM/QGsFGIphEGu3JgKrwIAOCIHOsIqrWA0QqAymIAiCcAiHgGx551d+xWweOFiExWLd4WKGFziINyzsUWOQZR/9YQDnIhVHED5gcAQ9kAAFkAIzgFCes1AUYG+sBIak1wY9UHsSJRMtk0mv4zqaBB4xEAMY4DxMMASYQAzul4Uyogu+8Au8IAUU1wAKUIYkYYb9SBLkSFTUNSWyNxErYAIZYAJssXoksCIM6Rbks4cxQ35sggFrlBJxNC9WpiLbBQeQoAmswAv3g4VCsyepUHV/EomDIiiDspKVYQqgQkCBgomy0Al5EARm/2cDtAZCQRAGO7mTt+YDwuAM0mBNdbVCrHiUv4YMoiAIenAIiUCLyDYIe6Bse2AHdhBDJkYHHZFiNaQr4QGM1tZOgqOCFpCCx+Jt/KECcLFxgcECRaAC59YDMBAlGFIENCOEpgeGeykDeBBGBGeOLlcCbTFwKFAT4DFtOBBHK1AES0AIiKELgoSF8zgMNLIHKYAB+jhyZggvY0E99UKYhxk7KbIC6nIEKsAUNNAWi0QXGRBzc9hJqVSRsEVbt4USFWlREtBR3oMHiVAJnsAKISkUsGBVXeUKJbkZytlpJvkKjbEnp4AZvpSSstAKlBBNH/AALdACOvmT3ukDD/AAef9gDMoQDdZUHazIDLIBG7KBDKVgCHvwCIkQlYRgi4Nwi7hoByRmB+KEBlswToOnKziQjr4SLIETLCEQAhvwAQuaginIgo7XJJR0U1FCAwowjRTjPDSAARZnekH4oQswARzwBwqhAh1QL13mPShgmGORjtMWAxegARDDBHPQCu6nCzjKe7pgmcRgCRyAARPAAP1Ijpj0SDAnmgfphiaAUSXgRY+kSDxHAhElAXOYAfDDAmXEF7KTRriFAeQ4iKFJIlaGEt8FBn8ACInwkTwDC8XZCnmiP/O1P3DqCvS1ZrPAZmxmPE+XaZhRkkuDCrBwCoyQYOfxAC5gAzZwA4j6nbX/Fp6KgAzKAGzY8GvM8AzMkAzKABtDxxOtIGKP8KlRKZX1mWyAMGLKlpV0IFhYBKC+eFjjwU4g4AIImqAfUKsM6qAsqAAZxSYwYTs1sAI1UAIEoAAxoALb5wE0Y3FBuFsfOgETsAXukgI/mjuJRpgDxxUr0FDfAQMTsBIq0ANBoAnu1ws5uke6UAwLxwowgAEWIKQksaTTF3NtojIoIHJjIWj9OHIHCXMooIQx40oTuSIVNTuzUwJz+DqMhBJLqgIloEamt5sWKVQ0kC5LlgjBSQtZ5XRs2gps2rEe67EIE7KuIEyvgJxdlSeBKggJlp0OEALbaQPc2Z0g9ImN+gCd/wCpz1BNeVWpl2odvaAIjmoJgrAHjvAIkOAIi4AISkufU4mBGehXd1AHqDoH0CZ4grcEIuiqryqrs3oetnqrG5A4qdRliAZdF7EC0phGJcChYGh8Fses9oYBHJACf1AujGSlrNkWY2ECQNJQ6RgDQUgBEIMDh7BHezSZ5FoMwTAwZtAB8ZGvIycXr9N65HitXNGvHZCGlksDCmmw/EalSgiwDlmlEuUSSQhmSQikKDEBSbhUQWhlpWcCMzCxIyaVi8AIjLAIt4u7i6AIiKC7uMsIkRAJn/oIw/sIkjC8YUMJ8EWnJluSsBCADNYCYZug23m9iwpCiMqJtxYLkMqA2P8QqbORDNaRCi0wAAcyAAcQAnUACe4LCZ+6CIngCPMpqk1bqlCbix2IN21QTgPFNwK6rYCjWAl6HrT6oA5gjjTRJB8DJT1wAQNwcUu1SssKt1m2RhMQbrJDEm1SuQzbFtl6ETZRAiNXWm5wGLhguIYLj7LwC3RQHwtQJh3gAc0DjAXHmGRhAgQaLJbLFbNnAuDFFxJAiHoRURGVARcgARfAAQUHAwXHSFB8txkAu3v5sBlwBG3geWd6lRuobFZJYnqwB3xQqso2xmYcBnIgBxnECKnAe79ndIREC6GgsnHwAy1gvTHLqLQmTcXwvdVQDaoCN9GADJcAUOgbAANgAHT/6wiQkAifygjyWb/12bRPS2LLFkNzwAY0RAWCJ22FJx4meG3EWIxHtKKGORFQQhCllQIHMS8e+qHK+qGmRwETIANvYKIjEXDUJX1+BnPUdwIp0Tyl9QSgMK4q7DPBsBOR4AAKsABzuKRMXC6KVXCRm47k4mImcAEgQHBG3DwysRdCFbB8MZFCdAGrV85QnJouMQHlXM7s3LZB2ABRNgNWIFrshpUwdAdYGbX6yWz+3GzMZmI5gAVnAE6M0ApYqKcpJTSzYJNxEAdB0AIfcMcuK7O05ol7rAh9HKm/hg2CHAx8MCADUgAMMAODwMhFS7zFO5+hWotTSca4qAdZ2YFo/3AGXSl4uZK1LjbA1pYewoKrDrCiKFAlNEADSGEkKzoBArAAHOq2sSzLVuasFAAGLrKOjJSEIzd7mcSk9fLEzpODicALWHjMP0OupbABDLAAM8zNOgwDIBCWE1EENMAr1xwDJsDO52zOq+dKRyUzAYtGaiQB7HwBs6NGspMBGLKlzqrY3UrL8uGszpoCo+NPX+AGbvAFHcEFmu0RglXTZ/DZHQHaaJAGYpADQCAFZRAHB90Lw2V0RLEZsCAJDBYFTfACZIbH2QtCTdAEe/wJuGEMmLoMfxwNr+ADBiDSBXAADAACaEAIaeq+kxAJ8OsI1M3SLT2qpKpsHGhiu/h35v90Q4blHWFZgiAQY4SzotmKykZtIdnaAQ1wEG8b3yCaZbB1RzCQes2D1deampILLzI8ckY9A3PQMzPiC76wR8WArq+ACz7gAA0wcKmZmi/2LS82cAdpzeXdOkK0eqs3pfzGRjFjVAGrxAQb2Bgwhx1wwWl0w7QM2Q0Qz84KAwW1BJmzBF9w45qt2U/wBFyQYlIgBEIwBDdEBUvgBFUwBUrgAjDwAkAQBpMAC78gSHCMX61gCKN4AzfwAgZcwNt5A97ZnbpgG7VxDMgwyJTwACMtIModAlgwCPM5CZMACZYQ5+97tNXN0rRYi05rleCEzyf2dzWNK0MABIS+IDNAguT/AqvnsR6mnK12GRUy0BbOugAEcACx/LbzvZf2JgE1QMPp3I8UAxb9qD0kgSEZAQSgYK70iOCKqwq9IAgOUMs1EGRMYJcIRQMH6TwmEEYvVh4ER0bbPHBI7En8FlHEzm+lS7AnjqKkB7qDDdkX4KyHc0cXkBDpmBE6MFBPMFA9sARLgAMEse05BMB80+1KgARz6wI30ASW0DPmCnHzdQp60ARhcAMu8AIpcKsf4LIxu70wK2F5MAzHkOB9jCN8cNwivS0KYAEvsAeTYAlGC+dzDgl07r6feud4Xot6TqpVqYH7ezd4I3hY8JW60kPr1NPNk4ZD7RVH0CRgmAHSWADx//3UIGp8H0pHUTxyXqQDRa3eIpze54IDkTBSOHrgvYAbaIYLlOAAFgAW4POrQJ/rup7hJCgxEtMB23zErxQ/KGCl3RxRE1niJ45RrpRlUsbO9nb2kM3OZ7/E5VLeMyCtb80r6dhZ6LjTr9rrKaDkL/ACDbCgIWADmHAYMuJmSVeyoEAGiSrRDrqg+94CLgD5kX/HEvaoitvHwdAJH4C+BCIgMt8ALoAFh2Aa0f2+dA7ndW7nGB+VkkzJT7t3220rf+fdhLcrvTLAwsIULuYwX9EBefm2B2Hpu7VbrwzLNj8BK+BOdR0DE1HURY09XzERSbFFdcAKM0KP7ocMiqsLrv9ACgpqOqlJ1NnqJJarWK0TLM1zxByO7K75SiUwukK1kbC1kRYZogkZ7dIu7fIRz/tP7enBzgDBoYGCBg0uWEBogUNChgg3WGhg4aHEAwoYbGjhCVYvV65avTplqlSpSS42bHDAoKLEDR9ahnDRQmYImh9EdEJWTCcuQwYCDAAaQGiAAgwu4GCTiBQtT5QmTYIEdZIlS0+fQsKK1dHWRIkcdU106BAhsoQGAQK0R61aPXXczplDZ84ZM1SoAMELZMYMGC5SpADxN4WMIzRMoFgRYUGECAkWJCgwIMHkx4sXXMaMOcKEFTJgpIARQ3RoGTFknPYMA/XqGjFcLMWlq9f/r146g/UqRYsIBxAmVKjw4OHECuIyVpgw0aFDjBS8QWToAEJ5hgsXMlCfToJEBxIZKkDv4F2ChAwUJkiYwFhxQQsXIloA0d4CwQkF7V9uMKEDhwv7Cx6ECCGDGoKIPQfec+iAAxj4wAZPQPHkkksooUQSCyMRxKWUVLrooZY+oClEmkQgERZkiCEGFB+CEkoAF4VKoIENcJgjkVOIcaUTqqaqiqqqrLoqK0i20uqrrg4Ja6xBlgTkrLXaqqMtudAwYwu7qNBBh71ccAEEEEzroYfOUDAhAwkiOHOBBhIQIEbLxlNMsQXOlAADDC4wgYYYaDhCB9FigEEF0FQrTYYa/w41DrW+IKHtl19QdLSXXk6hxZIQOFCuA+Q6G+4441JQDrkyo7uuOui8fC486LTr7jrtzIwgvPEumAChhThYaAMv/QoQhAv4U8C9+qwzIYVffTUI119548+9k1o6iYMNcg3BghAMYMABB8LAJBJKFllEEUYUUQQRQ8pgIF0F1l1QXYvSdeABeecVIZJLIjHEAaD2LaDfAyZbcIMX5iDEE2J+OaVbRhIhC0iroipyKyPBEmussgYRBK202IKyDrnoqtKuIYDAoS/AQPCMhh5koEEG6Mo8kzH0DiiggcvUuxlNCurEADzVejhiZT9hgCEw0ABdbYXfiCMaEFhowQUXSf9pgWUWWEphRRMcpENOOeJqoIFME1YALLrkXpbuOk1NeM4E7bhDIe7trhNPgurudq8gBhCC1wG+F9QWoXbtu3uCCdxbtwEGAKaZ5sgGAOCnffcdCgDLAXjAEEMWMYQPQwQBnQ8+DpB88n4NUFDBbEP4AEQRPtCjE0H07Reofv2taKAGOKBxEIOR6SUUSiJhBJFDHIYqquQjlpjiJJXEGOON11LLY7jQOIOuu3Dgyy8YeuDzCOL6C09m6DJYgIAFMGhMPTQloGDnDnpO7kuWSwO06+iMVoHoQJH7jQpAgINJaKITnYCQJgzIiUt4ghR6QBUMMBA/FdCgCDSoAdECI6r/5/TGg7gKzHO+450MbKcCFYiZYiazwn+l7naRGUoMhXI5GtawhgGwYQ51mEMRcO4RoAOiIES3AWwx4F0WccCHTsI6mdigdRmhxQ4MYACgEOB0qKuI3yIywDkAAhO/QAYycPGJ4S0CEUDa0Y+CJKQhccUrFBPLxZYEOrSwxS11iIsbzmClvMggBT1QzRGmIx40fcduGIAMmmQms/jtzE7n443/iJaC/mXKS5QMoAp8E8AOpGAQh2CEJCIxCUaAC1yUYEUiuoQrStqpM0qLIHXwJiy9rUsBK8zZYyAjgBnu0Je/FMoABGA7xxUgAbesyDEJkjrAaStbFthQtrD4AU94/8IQirimID4XuhZYZF3pSpdEoAktEIWgBeWkA+1eWIApKsgiEtkiUvYwCVogYxnImEUnKvSIp/jIR1N5GMTYSKTmgeVIFiMLk+q4Bzs0lA56DFkHUNCBC4wHPTbLDGV0SQDH5Ox98KOAne6EK8PdJzNqOs8FdgYnnTFmAQrAAh+0aYhDoEWIfNADJgDBJUCCQDUnMEFwTMCcvxxHVMfJAK6UpTiCqEkCJ0RhBhpzuxVWFWC2VIDqnJmSlCBEW9qqVkRodbf9MEshvzqcfcS5N4bMAAcbCEG7fpA1RmCCXJqbqSBaAM6vchUlSXTJB7QFog0wYAAvpNkAUodEicRnA/8uAMIc9vCIUhRjGcsgxis6IaFL+NOz/+znj9iYlYIatGJxXJKT1uKWh6LhsARwUWwJMFsCmO52c4JTbi06wZBWRyBDGaYVjbmAw12HAu/7qAoL0AJAiG4setiD6K5ZClIcwgUahAENdhYBDHggBs2iqOHuxp4CMSA/cmqA+z4Kp/zUpyAvvYx584OQgzTgQOYVUEQ2kAKJ8CetBilIcxBSUsPVZyHwOSuudLAEuDpTD7zwRCQ0gc1HaO5zfPgAOC0Ar2d1GCUngebjDovYijBWVynQFWTpsAdEGOyyyygGKjYrIapgAhOfxfGOpDJaR0TMoAc1S5POsjE71GExa/r/l0aterPjUkAzLJVZnUBKgepUBjNncgz87JQeKKsnAQfYQHT5MBaO8UERoPgFKMxw3epM0ANoO0h4aFVg9zL1nRWNAEZditz05tmlHSUuZgpiVcc4piDfNMgFmnO4/SinIPwR0IAvo4D6wCcih/MtSwp7CFpgYhKYYEQDPVHhz33Aq9DM1leh1RIGWSCx/LpdOy0SEd78hQMpeMEQ6rCHQ2jiF8pYRjSWEQzNckITNkb2jW2c48/yaLQDLe1YUKvaw+ASfSfN6GUSMJ7HuHQxaJoABgxnnv7Ux3CLiZlF4Wc4nDHZmA6Yg0yXZAe1gM4QnPgFK6y7gXAvgALJwQBg/9xzgTwfztw2s0/CFbkYFKrJ27isqoJYmGQWFqBxjDsAwqtjAvceRAECca83GVDS/OiuILWyyEGS6ABN8KIqmljESHiBIUUIIgQPYetJkujh1jkgsbV9nMWxpSD2/OovMOCAC3Cg6z0YwhK9sOcynqGMYsjiE51Q4LGTjWxm+3PZaUzeGtvoRoqZZUkQ0aUxCb12thMaP4xJr82smvD2WsYylOmoHcTilUGYPVyXcJQmLoW+yShtAhww980Wkxw0OTzP1TlPzzTQgcm/eYIpPE+BZYYBCVwGAx3YmXXcg9JzR2CEhwvqAqhz8gR4wMm+uoCXJnAZds/em4eGSGBZ4f/yS8AcFqG4BCM2xwcnXsparHtACJIoOAcogIqwvp071YXfWn9mBjrYAhvsMIhHhOIXxUDGM6IRDWTEQhScuHFWPAsVS9zYn1PBRDU9YYlHYKUSy9OKjw16sSYt7paQ4SjMqCor0yVAS6/MOA/GOA+Wwjb7GLc0yTL16Dw1cQMkcYRJoAM0SBJDkIRZKIZToIMQ6ABdkoEeAAyISEA0uQ4MQKEoa7fN6xkzUbfNmD010SUBpL2Owipb0rMC+xX4cYwLIIgKoAAPOCHy6AAJQLI5GQgF2LDAUYgGUD4b4IVfeITeEyWZUoRFYIQ8aAG48hXW+YAH0JY1sR0RWyd3mjX/taq+klkwLqADOwCERfAEXAgGZFAG8YuGYbCFT0C/qnAETDi29uuRr0sjTzgFWJCFUvA0SNAxsSOtiTmSsoABvEuAAMS2OGGk+BmP+CkwLROpTPHE+sAPOgkpDdCA4yokBvwyHEiER3iEQ6iDMdgCsdjCG/mFSDC1Fbo1XLGAw+O8CNAAFcizCdQobXu7LpM7h7sPQrOZCbDEY0odDjGiVFscDMi4yhBGBEAAMAgEPCgCFjAIBSiAW8oqVDMiV1OdFpgEUKAEzpIERigeRECEPBCs9riAkxjDlCiAYLIti5O4xEEQhQgMGMCBHsCBJTCDOdg1QDgETDiF2sBD8aM6/10whRmzBE3wBK1TtmTzEUxYil+4DVCAikqohEfEPx6TxEqIAQVojMdAgEbarsvYrpASKU7crVAMjvm5yZXSsvixE1RcqRPixMaIEReARUh4hB+YAw18RUbohGAgBlK4gYGYDIn4KklbHxOIHw+wkzyzGUVSANIjxUH7smMaCHD6P8iQuBaCDNzBIixqpmwhR0DjRgIwgk3YhEYohEbwS3EkDwkAgVvjgR7YiydAgzLIA0PABFCQEE6QBAohHkb4ITmYAzfATDdgAzmgAxegIsmJjNNJHWXCL9+alsCIgYPkgh6gAjSgA+hyyEgIhY0YhmNQhttUBmT4hVS4Ok6Qv/+s27plE8RW+L6cSJhP+yyTVM5ni0RagARjsTs5yZl14xnDEbcF7MQJChWAowCe9ESgbCR1+w5UzAChVBML+IBD4CdI+AEX0IMjWQROwAVkoAU5gIiskhZtAbGE8MVw27ICw5R87DBU+6q+0TSXeJYPAIEQSAEGDYwZwLUZ2IEboNAgIAIi2IIMzVA0QAMmAAMj0ABuhIA+MEm/7ING0MtNKIQ+YFG/9AMogAI+oYEncIEgOARSKAVK2CwGGp5xUYQmWJASO4B2oiIXOUPcwaqiA6FLigEd6IEtQAMonQN6a5JDoMNWmAVfqM1jOAY8zAlfeIVPgBBPwDqtU6Ct0wT/XCgGYMMnTWg/rrME5ZTTOa0ENkIGXhiEweSAx7hOg9uM69yyBjAPoFSOzzscpVIOZYE88ZqzsTIVulEbgYiIEBiESKiKsOgKRHiESJCEUggFRhiDFzCWFMiBF3gBG7iB60pNLcEBJ+2BJeACLrACK/gCzOQCObBMuKCDKLkjKKGDXf3VX83MNCDWLPiCMfiCKlACJGDWHcgBCpWJFlglDhCsiqIACIAAIxiBEYAABOhWbvTWvKyEE20EFoUDOOgDFHCMx6FUe/EEBpIQSngERtDFyeEXA4ChdQLINVRSo/mLGHhVLkCDNnCDONyDJiGEsbCEUGgFW/AFYSgGLsXD/2WoSFcoBQgpU0HMumPTSKgLNmWwBU54068zyUwwWZOlUzlllFY4hJvbMLZSCFw5TRACjCU9OsEgGtHYiyx51SdgAiawgjZ4Ay54AlmV1TYI2jYQ2je4g6YV2j3Qg+N5CkKAhEFwhEc4JVfoBVogSUcAhO1rErVoKDvATGJNgylwAidY1mXdgRl4AS7hEtbxMK8qUHfJKmZipinSW3ydIn19IQLw1hEwgm8VgLukLQjYyxHoA8U1AhY1gkYAgyJoBBOomRzYA0EkUwYSpUhYBAOInMsBzQLgKA2IvhKTr35NARfgi1bdAjNAA4aMQ+jqO0JIBEGYBE8ohVeohV0QBv9j8F3bvCxlIAZcaIWLraaN3VhPgLpoqAZlkIUyzQSti9NKONnqtV5/KoVqsgSGaZKuoF1M7Yoek8SuKIRCCITzDYQ/UN/1VV88WF88cN++Sy20aNo7KLI6cAM0yN/UHIIt2AOs2F4kSQREkMdIaAVPGIQzwIFqyblsmT4hzdvUaSe/peARWyfbOSx7tdfYehEZCgDAFdxuBdzCBVduRFEW6AMjQOHHVdwUboRKqIByVDRHqCZQIIVQqKZHWAPIoaGfuJ02iQDhMl2xuhveuK5WZd2BrQN627WD/SQkmSyNNIVayAXeHYZhMAbbfIZnwKxeuIVTGNNO2EiNVCBPoAX/y6oGZEAF39RYrbPeN65eH/kEMsWERNiDOMxQIggCILgBU5UJwHBZaBJS1NnbuJRLvO1bDbbX2rEdB/ikJAmLhCUX4nsAlXg1RR4AD9bkXvqlTvZkYPLWb4UA2BIAAhgBEe2DTXBhEtDLSijXSgCDVAYDYzKBBqiZFyAEWqCF3eMFR/gAxzmATD4sfHURBIAMaRziiBArI8aBZtaB/nVdhlxiJyYLJLndUkCFWKjiKn7YYZjYnCCG27BYUMBhMjXTTriRYtCFzVKg6PXIN6aK66UKSeAcPqCDBdY0JUJQulUXBelHH+Zbdoq+vsXXF8LkfcEWC+AXBgAERzgER6DH/0WwxUP4gOfL5Bj65IzW6I0Opo4uZcAd5VL+VgQgABHuA1ZQ5VSuBJRG6VZW0X6sGaBTAOr9gwNAAkiIq2wJZoDuFxepKqwqzYMwuiMegmeG0oKlN+jagyVJWLGABATC5lioBanOhYcFv9wshnD+BVyYBVc4BeMtU42sJj+8BEGM3jMVREyAY0uA40zIA1ydgyrYGgBBkANxJrVkpqAj6AvWYE2+ocjpJcnhAUS4wEnY1KcYHsPa5MVm7MZ27MeWIaCYIsm2nRKmrdkSUXBtYXLdhEpIUc/ubChIgABIrH6BAxUd7QFYgMiwiGAeptvJZAFQIbqUr/ZQqsBQOiDo3/8NZUh6WwuE3Tv1jL9QEAVTeAVTMIVYcNjaDKNiCIZgoA0vphowTqD4UyAGOtOzRl5NMFk4rbGtewAQMbWBwFsJ1tvyhmDpQ+8hLWgKLl1EXh0XYANE0ARacJT75oVTAAQbcCYFMeS9dW99LWTUSZd5sQkRaAEbsAEf8IEwiIM8gHDpIpdQshBKMLYaLoVUeAVXoIVWIAWUHgGQJmnMzuwQJ/GRxlZuHAEwaAQWoAEnHDEaUFEWmK3HcBGLC7rQjG0I6LyIyJZl9tdmBgIqcN2BNVi1SAuETdgjeQRLEONPKG4oz+ZcCIaIde5f8IVe0IVbmAWqaYVTIIUE+s3euzH/7QbOrOvujgzO1qEJZoErmpAJuOWSG8ABOq9QLBADMZACIsACLBCCkQGCHMCLIcgBHCh0OucSaQ2BBWX0cqKJBf1Cl0jwK9ADLpyQCaEQQ9ADMnDwMPD0OOBMPZA3K6VXb+k9MX6QUCiFU2iFVoAFRexyWpCUWZ+N+3aU58b1XJdKqSSGYrjiK8Z1bzaGrH4UUogAF+HWEh5pBDBx2CrhwhVhVN5LOEikTNjLIIatBCDd2nltDP5gDaiACBAn2zYag8SBId+CM4iLuPBtJwbuvXPoRZiESzggKO8EKa8FLb1yLceFW5CFVGh1VmCFU/hqUghzc0bz7d7uTLCxNE+2/zDQ4x/IgWd9AQpF1RuwATlHVQWnUAr9gY//+CC4AiIY+SsQgzEog7hoyNkFix5THvhrYzOFEBsGhQPihANC9VNghVdvBVmQhVifdVvndRQh+l7XiaNH+qRP+jDiUokNo5xo+qiXei5NBmdIBnAmhQUIgFJO9sDVVgjY1j5AAJEmcRU/5XCtBCNg5XNF0UYwApKeDNjyF2GG7dhGRbvxFZqFgetrVSqQUl6lUiEzi6ZueSu1l5u3+XsfBVXQhWAYhtvQhS3vaoJfdYIXeIE3eIxtZzNV+Hau3q0THT5AckAQBLHgwlGqsTKuYRs2eFIgeNcn+NjX+ctnhVbY+drn+f9X1/1XH/hWb3VPXfUP/3IIUfWLBQVQaHVYcIVX8HlZuIWokZqgf26iV/qoj9gu7VIvvc1kSIbt537ux8083OLxFz89rIbzP39uwIZqWIZNGPti3lavZ9Ft3QReCOliTvG7FFEUPdFNaFy9BAgSCwoFWhBgAMICBwQIKOAQ4QCGI1hUAOGCAwgQKWDg0EFlyBYzaOjU2WNyz6CUhA4dWnkoEUyYiBAxknTpEidONzl9MlXLVzBfum7dmiWrValSoUAxJXWKFdRWp0B5qmpVE9asWrVmyoSpKyZMp8aSHQvLlStZsNayZUtrLa23a1u1OuuKbqu7evPyfeU3ld+/p17/nUKVKpVhUaJMiSoc6hTjUaMWmzKFCpUqVas2x6pVK9euXb6AkRY2bFgxY8dWr06mTNmzZ9Fmz65m25o1bLp38+7t+/dua9U2ISAggACCEQggJDfSZ1OfEUY2bRphnACBEX2iQwhwPDt16Ea0V9oEJgGYTH4gIlSQ8CFChiRqaEiRQmOKGDh6hBQ5p44eewAy4CCEGMhSIgjC5AiDMy0SCSWU3CSJhJ2IEotovRQliyyunLKUJ51U1ZRTp5TySSedYOIJU1RhhclWW4X1IiaKifIJjp/YuKMoofjoI46K5TgkjimmiGKOnRC5pGSfSPbkKJpttopnnp1m2pXCHJMM/5fMOOPMM9Lghk1uuslzJpppnskNm2zK0yacbAKnm3C2zbaMMsgcUwwxxPSSSy2rTKZJJTVgd91yCBSXnHbjPdeIcRBAoF0jIzAnQHEEPEddH0YY0UgjLGiAwHELJPCQAQc4tGpEDAlQQRIorCBDBxrBMIMOS1AR0kgACriHICq59NJLMTGyyCKPRDLJTc1y0skosejiyy8aFuXXKZ7oBKMmLFalU4SXUCKJiJqEhYkl6E4CiSMJHmLJJPFaAq8lTEIpmZRSTtmZZ7n4G9oupAksDMGnDWOMaq11yYyXztA2mzTVRFwNbrjZxs2a3OymsW5xeuxmnNjIWWdszHB5jP8xBAOzSy6bfZLTuIoowkceeYThA84+iLCzCA/Y8MHODwjtwAHGHceQopIqqugIjYQHHabSbWeEpMgpJ8AI1Dnn6XYEeHfcqQ8ptKpDAnwtgARg1MBCERtxlGsVaaDhBh12BMgHIMEWuBJMLBWbCCPHJrushOLiZOErteDSyy/B8IlLtppcIm+3oOTU7E09iaJTTp1fIkkkkTyCbFjzymsJwgov3MyXsUEjzTSxT0ONNdfUfs1u22xzjTa6n4MO8MHPMzzx88hjvPH0HL+88s3DA889xstDTz3K62YbNrZVc+cyehYzTFC21JLZZDjmJIkkMitiiCB80FxzHDfnrHP/0ELbfz/+DzjAgAUO+M9AAxZwHewwBDnJ4c6iNsELXrCiEn04YCO2E0HlJAoBj9oaBJwDAUwRIAFFI9uqVFUAswkgIuhRWxL045EtoOE/dbODSfKWkgIpyF3FChwOGaGsSUSIQjjpSeJ8UQxldI8WpNAEvOKFiRTpBCc5CQUsaCEu9O3kSZ/4XOAewa1zzct35/jiF734RXScQxzpaEc60gEOcJAjjWAkxznWWI5ypFGNa7yjN9LYDjTWERzeAMceAxnIfOAjHu+IRzzskY9/7IMe0HhZ+tAnCUaoj33sa5/7MskHPXBSk5z8pB7kEIdRjpIMYTDlFX7wAhe0oJUh//gALDewAQtYQJa2pCVGPnABElDAawVElKSmUylLNaJPToNOBiMIqk5pRzoQ6EN5OjUeT3UHUwtYAAgVcoADeHCEAQgAdtDjBzCAQQf88Q+AYCggYfmthn5LBCIA5wjBMSISkpTksz6BClkEAxnLiAYyXOEJSzwCEpOwhCae1QmcXAKKsCjF5jr3iVUIwxnSSIYwVvEySkQiK1y0BD5CKtKR4uN5z3MHO9xxUnawlKXqeGkg2VjHdIijpjZdYzvgscZxjMMcPnUHOMYRVJ/6NKg8Jao5ynEObKwiDzhrQc2iGlX36SEPcahZKOWgVa3SQQ92qwNYwdrVOmw1DqYsQ/8ZxpDKH9ygrS54qwteINe5ynUGO8jBEIaggxqcgFSuQtpyMtiHCHKNF8TYBArAwIrqOA1UnqLa1pq2iUZMUzojOI6kJFCAAYBwmwdQgKoG8E0CKKQIhcADGJbAK5KchEA0bOffYjITRCyCEY5AVm2Vhb6a2ORZoXhFMJYh3F5cMXQHfdHlOGGKWZwiRzyhaDO2Qb194EMe0TDGLlAhik5oZV6W6Ad4wwteRNojkYnERztU2o/nhfR5grzHPl6qjkCiFLzwQCk7corUd/D3He74L4D5+9/+vsOn/UCHNBQRhia0IARXIAKEI0wEUo6yDGIIghR4wAMpZKEMZ2ADG+b/wAY0mGELJi5DGIgQhBU34QZB+AFbbcDKFsDVBSAIQUbsk4K4viAHOQCCOftKwr8G9oDhaUQlFlgJxTJwUxEcrBEOOIIRgGGwU54yBIyznAhgk2zbVIACGMAABRhAtAfZJgsacVp0lgQQg3Dz3hDUzpjI1kE6pG1tA4c+mVFIQp4oxS2KgYxfbG5c4QrL4UKBmBs5iaLJsMb09vGPfsSjH43kRjWOEYxXhIK75prXP0It6lFLutSjPjWqQy3eVbO61a62dPXqIelJ92Md8hhGHtawg7euuNe9vsIVsiCFHKTAAgq4ZgMsgJG33gDGMJ7fDWwgbRk3OASv/MAG/Kft//2JmQHbdoAtQ8CBBZgNAN88twGR04fFUmeBrCAFKRRIDF4MVpqVIKynEMCCT1WKOQZMlKnG1gAPHkDMyTb2Zr2TgARgIBCVCMQbfLVOQqjknTaM7WzxrMNE4DbPlFQEbytUClSYohMwq0nhLtGJUsgCFTkaRS6OYQ2MTZfWiGSk8rhhDYyq4mXnmjTQ+zHpfRC96ERPNdJp7eqgM13oTh+60fdRvZqDlx7Y4EQemrDrEDzbB21tq1xdYIEyn/ubCSk4uGGp9gfE8tvbFrNn4e7ZgjOA7t0OgQUEAABzf9NVBCTAMzeRCVL0iRjCpQVUoCJNp/FCa00DVRLgUJ1FSf+KOQhYuDZjcIGFOwCXILCAqhSegAjg4d53iKGwDpSgmMyZ9XbGIccXgQhF5Fl9erZEQ5XEiXGhfFycEEUqTIEjmBtDGjSvh6yVLl5GSl15OwdGyS+BCfymlPosBfA97mFSk5b0eYj8fjzcQeBDhl/8/h0wpf3LX3u0wx74sAc82I/GdhRdH/7oxz3kkQxFCEIPdaCDHNTB+1TVJ9XBFDhAAOzdQRzEAKTKA7QAA2xADvQYsJEBG5xBFVCBE2ggFWSgEOTADawSXO3YfdyYtYVAK9HYC/DAC2TAAigKAbkKujUCKxhWn/hT97DC4Ame00BFeHQKdVSCG0BBEfwScrz/YAJ0mUJ4UAKAFv9sgEZYQAF8UwEs3AqoGR6cnpsBAkrAlpy90yHMFm7lUODUFrKoj8wYAshFwiWgofosAu1dgpM8lzEwAzacyTzQA3WVF/iFl6iFl9RtgzMMgyp0AiVQ33+1VEv91x7JlyPmF4BFYkrdFyWil0q9Q3q1wzuk34DBQzu0l3vtkSHhwz/4gz/8Az1wwypkklXJASflwSt2Uh0AwQFQ4QDkwScQAzIUwy94QhgwwCulwA6kgROwgRugwReYQRVsARZIQTMKwQ+A4FvNAAzoWAleowqGYAikQJVxB3IYx2gZAeHponCV4zIQA1bsIAOxWyU4B3WQQiXc/0ECmM2hHOEENIAIcVMTNgD/hIALzEAPuAADJMQCSAAGFEIlFMIMCQLFDYIXeqFM4JnHPcIjMEgZnmElDQ4lqKEhGAKyBI4TccIoCEN0Dc85wNE99EMhVRqlIRJ4zdp4GVJ+nUM1JMMufIIi/tdLpYMjzlc7gBFQpsM58CRP9mQj+qQ6sENSLqU7VFr4VV/1AZhSskOBHZJ/sYM8PIMi5EH7tCInAQgoAcsVtMA2FcAYRINwREP2VEMvpMoOpAAUMMETuMEcyMEZjIEYqBWwvRiMRZsN4EA16liO2QeP+ZgLqBII0IAfFEIf9FXlSUcxIUPh4eA/LQMvRIIjkEINuv/buwXCJvggKVjBoSxc0STABGQAPm7Twi3AwXGAC+AAFcyBGbyACDUACFwAGFTCwxUIDTnkQ7oLPGWcg3TcRwoOsnAkyKHPRjqIPT0LT8TczKFDOxjSf8HDeqlXTB4SPszaPxjSIfWDO6gDOmADNBgDS5XD9fVkTwIlGKnDUJ6De8oXT8KnfLXDUk6lOvwXeKFUIiqifLFDPJiDIZkDOCzVLuQBVcGP/4UlHQgIFhCNqoTAL+CCIohAMSxDL/CBARhAB/xBIUBBG3DBBaZVFogBsF0BX7JVWwGmC8CAC1jjNILgj+FAXEVBFyhB6TUCHsBBIajZJpACZfKJoPlTNCz/gyhQwlqQIzH8AgPJ27xlQgesZgQs3Gne5sKtZgNcAAdwQArgwBCggUnQQQhsEwPYSiNkQiMEgoEcyEMSS0QKp0QSZ8fRXm1JEiUETnM2GjAwgzVsQzbooTv0lFXqZ3jBAyJtIiOpGjzw1/eVgzd4g5/OlCMCDxgBjzrUkXzypH1u6h6hZ1LO0XnyZ0qxVDsw0j0g5aRa6nr9wzv8kXVJAizqAR3EgSgtKFjtgR2wgR3YgRSOEEMUgAJMYR00wWYpBBhQRyC0gRt8wRgs4wZKAYcRgRAEATTmQDTiwA3ggAi+1Qt8XVsBgQzIQA+kgRvYASFUQiYslsOVxy8sg2wI/xcx9NM/2cYyBBdldk+fLFDh8UImeMACkAAJmIAEdIAJWOnCAZCyacQMUAEa1AEgUNwYhID/bEAPpMAddEUjuAQhXBxLzETHztYhyCkOiSwjqGFyKudOTJQwMMM2zMPv+GRT8hc/HKo7WNo+PA/5CZ2oZZ/3bWI/oNFLzZE4gOql7qRQpgM6XGod8dEZCVJ6uQN6Xp/5/ZQ5uEPVohQ+3AN6baojDiXwIN8++NE3bAOu5QEduEEdjJIrAkgdwNCuWsETqEoMlp2ZBUACGEHiZQIe2MEXZOAT/O0SqBYVfMQQAIHhOhtbydXXzZUNvAAOyIAOPIHDJgJCQUXj9SAy0P/GM5hjkUaD9mwPvZojvO5rJZSABpxAEawADKAADHTANQGQluYHQJYrSsAEINBBg1GsDuiA0yTkxhILbHlsGNJWnErkRQ7nGdYpPkFLLhjDNMiDrHGfeAlVU+5nza5XSYWUqIUUfB2dS/bDO9jDP/BUOPDUOMwR+tKR+g4tqLJD+iKVT7Ev+qYUevrUUV1tzd5XOVifOtDROeDhOXRDNkjDJ4SBG7hBG9RlGbgiSYClHgzCJrBBA8CH0ZTQDNbgkcEBF4zBGGRBM0JrMw5u4RouCQMBDswACqMwDKwwDszoFjww5XoCK8TFAsFbu9LG5/6T54Lu53au6Epm4RUK6tb/AA3QQA3IwD02ABTmRw/0ABeUhEMySEvMARG8gBCkAQ/4QSZsAiRwrBeKoZxmHMkGDu2hnEhSlB1Ol9PprKr9LPQ8rVMiEvdm3xzfQz4c3akRHVL1lPmWg02hb02lryCf7/mWAzjYVCC7LzvYb09VbdVSmjmMw/m11BydA8bMgxpdQzLwARmMwR3Ipl3OwR7MgToBiCMwqSPAgALM4wBgh0McgAl45gI9TSX4wQZz8DMKARaEsBAAgY/5cg7gwA608AzkQDELsw4ggROIQR0IQgzP8AL1gj/pSZ18bg4rQ5GKbjkiA2UC8ZO+QREcQRI8wRHUAAfg0o7NABNYgSgX/0giOEIXw4QedDAdoIEVOE0mQMLvXhycIksYfqTsGa+e3ROFiGQuDMMz3KGstVrTicNQ5hSlid/NZR89ZJ9F5wNG54M+JKrRkW84CO3QHvIf76/7oqc72GcdlUNSpoMf9zH69ud57q9PWeUi2qd8/S89TFo3WIMqBIH/hRUn2cEb3MEdqJMdEJ5kXq4fQAEc+IEfHNPTfGYQQkEVeHAWqJiKnSi1kvAO8MBd9dgEzlUO8AASaEG5CgIiTIIMRxEs4EI/ee6cZE+93uCSvsUM/wJe66I3L6lh8QLfPgE1bgAHzNIGbOML6AAQmMEZTJwjtMQhCEIdcPAcbEEblAeatv9LSnSkZgtCRwoCZ2v2KNUMHxjC7JmsJDxXLgDDMCSDmIgMN1R0JA7Y+PGX1CIS92Wt0d0DPew29fC2bus2b5tvIc/RNxT3HclvIs9UG9VRTbl0+yqy+hIV+SXiSXct9FLaOTiDIgRBWDUwWLVBUZuEHgACL5wjLfAgqKhZeiNZVFMHKwRCVe8yFhDBfGt1LxtuV/OAj+13WO+AEkyBGwjIIUCCJzxFXNDCLwwRXLNJmdjJMvwCLfACLICCZiYeVCA4Du514R2WHXCBDgAmDIBAYbfAC+yAEwDBHHTVHqwpISDCY3Mh27qBZwoeu7CEZnckIhjCIWh2GsaBHoz2+vD/gSJIwkgewzNUQ8dgjDyQ0VDeA0xbLfzCr/md339ZdPY1Em9nOfJtOW+HQzggMnEb93GnAzmwURuRA5qneZof8pcLsiC3VPlW7SbCw/W51EudA/WsFzrsAs7QgZ/7uR2AVQC6IiAEyClUwzLQAiSMR9IsB6UgWXpLdeM9QQc743wTwV5uNX5r2F3dVQ50uhOkgR0AwktMgiZUeBT1Qj/BxoJDQzJsDzK4GwNlAkJROA2Tozn604b3CSnYAQIvAQ5IgQ2goA3cwBCcARpsQR0Mgh4IAkswgrOX7IAAS9tCQhA6woHIHo7ruBrC4YPwwey5jyKMpDNcw5KfQx6a0RxV/+339ed/3W+U36+A8aeVw1ceIt/wUA/yZflue8OXi0Nxf4M4gIOYGzeam/nBJ/yai8O/g3n6wvk4WO2cR61LNWLyncM0KIIP2ECK/3lYSRUf7AEdMAK8bgKjT5mjD9Ym6GZ7Z4IZdLAuY8EP+NoPlHB+e/oE+piJ6yqpH4KpU7hm8gKCCxoR4bDn5iC8Cf2pk0Ip8AKEG9a9Cpdk/kKfnGMm7EEbhKgSuIEUvIAN/JgZyGaA6MEhIBFLTMIieHawPCwg2AEeWPvKx4TstUSOd3s92QT/8YEkrMIxTIM2EHw2ZIM3XO+U81ckX2X1RfIem2/59hR1p1T27RF87fa+3/87vxNPNwh8cXdD5n8D529+5t+R6Ju5SNdU6SMyOLj5HMU5uwcoxTsi0dEDOgzDxtuAHNRlin98VJWEgLQrMYDCCCRgdiSgp0A6BqPrZGUCGmRBFkyrzM88X/L3p+M8XfWYMqfBHIjBA68EJGgChcMC4zhOMYz/aiADNnfPNAdDMPSCNC9p46j/+HMzN2/4OT7cHbTBF6TBHrBBEzQBElA2QNzRo4dPJF6/MGGidWqRokeCBkEUBGjPn0qkQFmClOhQIo6HDIVcROkSJUmKJNVihm3evn7evIGD1w5cTHA1wYkrt9OdO3bszAUdN1TouHBHwxE197Mcu3ZP293bR4//alWrVufN+/ZNnLit3cCG/Qb2m82bZ8nd7LqW7dqcbbsmDeouXrx3TX+q06vu31RsnESECHFmjpw5dOjUUZwnDx89e/bUCfWLGC84CAIAQICAQKNKlWhU2vR50yZSrEjRwYJFShAiP2DHzpHjxo3Zt1/k1r37RggXv2+IqbNHDh8+hhQlV56cEadYxapFrxZtGbJlxYYNw669WLBfwYgRQxY+fCZCePC8+TJoj5s0Vdq8uVNHkCFWpyjBQtbqUitQhw7hgxBB+IAIkEMywUgTSAAEcEBDHjFJEUYuyUUZbuShx6WX0nlqnQ/b2eceddJJZ6+efgrKnKFYRAoppdhx/6cpqKLap56q6smRnhx5vJGerYD8CixttAmrm2yQJDIbs9Raa6cn4WKrnBfNceedeHZip5y9+NpHnmPiaCGEDc6Qw7DDFFNMjuHuuKMNTyj7hZdNwNBghD4qYUXP0jLx7LTwWNlDiiyy+OG12GCrrbbbZtvN0Rd6E6yFG7AYYw4iwogj0zg43TSMT/MwhBJTfkEmmuisqeYZZZJJ5hhjjskumGCKGU88ZGiBZJA/7nAjEEL2sMMN+e4ARI/6KAmvk09+gUUTTR4yZCJBCCFkkEQs0TOjRQ5BZJFIwGUEpVycwSbDejbs5591+9rH3XbUQeecec8h5ycWWRTKxRdZjP/xp6fuCfgeqnQkGMcejRQSrGy0QdLhh5Fk0q0nKdbJySzxnasfnXbi8p96sFHFhxY2ILNMOdhwY4425tBDDjPabHMQR3ihhRdeiNmkkdJ4ZmU001jhZRliWBlk0DF+COKHGxBV9IYdGH0haqlz2AGIFrCm1NI6xOh60059+CEMQ2FjjA9FLlEFmGOWkS66aJRR5phiaj1mFU6IWWYZWBIJto5ACgkEDzvuwAOy404hxhVOeiHmk05oaeUhAgWpHMBBDsGEFF5g8WSSSD5vSJJcnjFXHnTdTb0fdftJfR8a13kqHS3xPaooo1zE11+nohJ4Hh7pmWdH4a+ipxsgxSL/UnmIH/aGnOefp/imb8DZKqdyLra4nBXHMeedfuBhBx54TFyHHC+xkUSOLIBw4YyT2ThM2MQUa/ONPwgB5RRawtOZ5/83oSec4QoUiVhNoRSlNNgAgTY3UAIPpsao29jmB1g4Ax0eQxHIHI4PgDCOBoNlBxE+pkAjCcUtiKGMU1UDGy1ElaqUMYxg6I0hh3BEm/7whz0YSxDHAgUtLtGJYOBCEq/oxSX6c4nKhQQQmBtEgSLhCf4R4xegQM4lhlENebTkKerISlbagaKfjNEnP5mdlu41lKQYBV8tOkr33tGTnkjFXVKxSo/uyCOueGUsx1OekpgXsbSA43ld2Yk4/5oEjkMikmOHbEr3qhSPfvikHCaaVz3kUQw+yGEIOHDf+1A2hzm4gZT0a8Mp90CKUuBCTnMiDZ8CKMDK8IIUpIDEGM6AtNq4AFEMrA0PdgC1HFBNgoz6wRbQgMEN7kEPaRrIYwYiQhGW0g4ZfKIhGEGJT8jCF2xjYQuxEY1kZKcY15EEgNqAHo9EghKKKBA2S/GLZf1iFpQ4hTwn0U5DAMgxfBhESBQRxVOkohQlAQYLz+EO8LUDHV/MCpdIlI4tjXGMeGmRGtuoxjfOxSfuEFjApnKwgu2oR2tR2B8ByTznweQm0BukWt6CyOs9iRyNLEdPwJcOctALHfLgxifiUP+GIfxGDLhEWcrcEL80tcENdZgDKIhBK5z572c4oyUrwnMz1GQiC2PIQm1swMvY+HI2OwDmbYSZG0bdYAhbOENT04QYUc61DohBjJniYKY5pKkOzTycIJIjiU/EwhfllI4Lq7GMUgwCEHiAAx4G0YllREMXhuDDIk5xCkm4IhifuAQuZMGIUvSiEw1RhEQIYhxpTUgSnJDEKphhjWvUAx7ueAo6GjoPeciLp/JKBzr0UqISNaUctdvXUeKy0aWUkUZ2FOmNeqRH5IUFkEQ6kkpf2tLnnYW73LXpcJ8UlPGRaB3n2MY25KEMQ+QhC0MNzhjKcFRSokEOp2TqYYIQiWL/KKMY/NtEIDJRiUZkImh/0qrPUHMGQsHGBjZAVAOrxgMknLVqxbwNFc6ABjSIkpRu0PCHVVaY98Wha5xaE2Ieo8w9VK4+AG3tYH2BDGVMJxrIwIRj8eCHP3hiGeHkBB2wSQlc4OISoghGKC7Ri1bY8xSRCElEjGOc+jBHEruAhjWmgY51uGsv58DtbuUVZt4CN6LgAO9x14i75K5xKWPcS43yGF3g/ShIfRyLw2DSPJg4r7toIVJarHcWjo2jksLN0k/gQaJ6bQMd3FhFHugQhBs0eAyVLtMoPbyyU6qMDmPIgy7i1os59aERpBZNALO6pwDyog5dhY0LmCabRQWT/9bCtPBsqKBhN8hVw+/7MBqsEOwtDHsLZjBDmehgJgz2FTIe7KCZ9JCHNRwLsJwIhc0yEYMiPBYOgXhEKZCBjEisWBCeCAUlenELSYSCtJy4BX4iwQgAWTbKx8HmJYAhjWtcgxvbuMaOzlEicaRjXrhVR8ADng4zM+Vi2FuLi+DCrzbnRS9wfi5JfUQVPgbJSHj2hsdhkt2zeOOP1aOeTAddaPD+RKH3ILiXuRENRcTBDENogQ1CUFRLI3XDomRDyuZghjh0Im7L4AUr+lAIU/fsZv8L2h4IJWlYP3jWaLX1MNV64WOjQWVoIPbXt9CDHgxhCDpoq7FBmRi8Gqavj/8RVBm00AIHXGAGO+DCGerQBhgkIAELuFMhCuERSUjCMS1G97lBa09ccIJZnWDEIvZ5CAIdRxGLOEkwsHEN9MqD8/Q4hzq6IlwTBVe45JCoRGt6PT6uORwR5xdF3+xcgs25eBtX2MLwDPKVkhylfwxSV2ZKaIKDN0vweB3MsbGLvGLB5mIi1Bbg+1Y3WAENZ4jDGjLchiOgQRH71RsvAuGHpQMwE0A7OiCygAVJ2yDWC6RNhW/9qBfgAAhUsD/ZcZB//e9f/0AYAhEAkAjEgDDk4AyIQIGSRgzMAAiAIAUOYAAKYAJQoAIIQAAs8AIJYAR2ZhMgwREcYcXeKRIeoRP/5IlxUIETZuEWKKEhuOUQqsXZDAHyfEARtGgbuOF30KEecGteDMkchGvgxIFexCEtiJArgKQr6qzOcmccmIIduCQq4sxHaM8rOi4bqjAbwEH3yCHPGEZ5oOccpkeRLiYcysH0Ru9JOqQf7sHLsKEaFMEHxGALgCBSrsAJoG8M0CANvsAKzqAMyIAM3ueUsMAQgkEZ9IYYICEQ8ASASsOqtOoPzmALhmCXGAhRlobCikk3sO4FYOAGGBAHduk3RPE3QNEF2M82FiUHGJAKcElRluYGPGkDOKABCsACCeAWAyAAbnEzEAACRsAI8oRPAMGD/kkQFsETLmG0PuETeqEU/zqhyRBB3hxkh4YxDprABnxgF0wHXXIEt3gLHLonHYIwCL/webSBHJSneo7HCI2kHZeQKbbkCQUmH2wkuurxRsJhz7gwkJKk94gkCbcrJ85iKwwJSmoqLUqEHOoBH/ohHv4hG7ABGHzgClZjNa7gCqogI9/nCzjy7t7n5zTs/z4tGkiyGnhhwBhxE3BmaHimEY6A7GwAa3iAB4DAEoFgJoNJgh5FJ1/gN3LjBnQD1oASUmyDaqSGB5RgCoSDDvaKDqrPDZYgBRYgATbjFjEQAozgF3/RCJLODwIBEiYBEh7BtJKjE2ChE1qBFzqhFGhBEyJhEeCSERBhLgGBDsjgCv+a4AZ8gA+UARu2TB9yhF7mpabKUDDPaxuy4TDPcae0YSCtZx2nq5EMiR2cxB3GJ3zcwR70wR7gRR1Sp13c5ShuQh/5cd/8URsAUuSqpyChpCsQskRyZHW8YRuqgRJ8QAoqEgsIJSN5kzcrDZd67QxgIw5CYbKiY05+RjRIAxk0wb9KoxGgwAw8yQVaYCZ5oJduktZuzcLkbzdcoDs3sWqQQAp87X0icQk4YCoXAAIQwBarEgG40gjkUz7BAA68EhQwwREAKiTEhRI8QVwugREYwQMdgVsGhA7WIAuuQAqEQAqIwAdGwRq2YR8A0/MEM+Eu9DA1dDHRcZCSEDLHQtD/rkdLOKYnausn3oEf7AEf7iFE9uEf+qEdWuccXIS79vHjHgalGEYstuJ5gGQgWXMnWm8I5wU2X/Qf0uEajCEMfEAIVgM3CcUJpLQ3qyALumYMjM3YaiMIFiFvEms0GkHp+mBMK+FmIKHpym8T2mALdMAUQ6DCavITdWBOdSD/5pT/ZmAGcMM7c8Mng7I7HYU2hMAMtgALik0HUqAB+g4C2FMACKAX2bMXx3Q+6bMPAMwTLKEhQkJa9mlTkeMRHAERAEQQ6CAKpOBUFxRVRSAPjGEbficwvUxeamoIt4FeDnMwzfEfk3C6OO4IdUJLniRGekIv6EJdBuZF+4EfJgkd/6ihRm1UH73hurpweYqELHoU0KgnJwjSpoZ0p4ArHdxlXWiTE1rAVE8VN1lDCZRgSjOSULomDokN1q5AD1jh+wSs1EiN1DIhZxrhZsovaPAAB3QABn6DAVWRAYFAYO90//K0YRu2UQA1YsFTFZnP/4YgBSZgARYgAhr1URl1BEaAPe+kDyi1PgPBNPIT8qQFEUICJLApBuUSEMggmEz1Ii9SCISgCURABCShGraBpAxzG6BHQ29VaNFReXZVYerMK7KHYygqdqwkHlhUQ2BUWb1BSZ31WQeyHddxWlEKW0/OVxmJDAVTL1ziH9rhGpIhDETgCu7P/qhgCHpgCZbgCf/s7wmw4CJzc9hAgP7O4EyJxjPGNF/7YBOIgTSwKmjAb25hIAVcQGD3b2FxoGH5L/8eliflbxMzV4KAgE4H9gL4jmMhoAIh1RdB9mMHl1L7gMDwM95UFvIOAfIUQVShrkGFQFBxNndz9gNEwAeEwVzQxVa14byOlmgVE6USZrq41kjQTCncYV6C4h3e4R7Q5R/igR+uNhlWAXdaT0TRIi24ditOk0im5+QgE/gMybzoJR3UBR/IwRpG4QFCAAvidgjgVm7n9gn0127zdm+3AAR+QwfuIE8qAQ50Bl8t9eg8I08qozIC4Ql6wHFDQP8clgcctnIpOE+5k5iGCWInllH/yu5OQWAqIZV0GfVjTdcXuXJS6RMPKiHAxPIRHm8uQQIkNkkKamMOa0MIDBYITjUIHuABRIAGM2Qf5uW8hheJk9h4ey95b295u8FFvEHi3EEvICkePpMfsBcaVuET3GhIgS+mwGF5x+IbTrPOxvhHm6SStkEbinRd0pYZ8kB+paB+7df+xI5u6dZuHRQLAnA1QgAEUmAG2qAQdAYMwHRwy7TUfkZPKsMReiAGUiAF+hYHYuCSHTZPMRhPuTP+NHFPOTgHQhhRFTUBGJUzCOCETRdkWRkrU1c+awAM2mA4/klaKseD9IAImOZggfI7c5cBf9gB5NcHfAEb6KEfwMG8/5BYif+ImZG2j6z1iZe3eYniLoDCexySXRRpGoSBE0bBuNiiSRAJiv1IR1HzK5JQLbCnktCRXtzlHKwhF0TgASzgjofA/+yPbsUuf5/AQQEwCFwDCz4gBGYgBXogEBohoT8joRmZFRRxA1GjliqBC3pgBTiAA2AABi4ZkzVZYevUo3VA7OY0J7ezpPe0UWaDTmMAdAughFM5ZFOYlWV6hSm1Bo6ACqAvDMjgU5qAwW7uBxoIFV1AFXkYCHA2CBiAARxgiKNBHvYhmXN1eI9WeZz5H8eYR6UZLI4iio8rY6rESq5EktYlRrXBGJaRE/RFNN9CSJHiQ9fxjNH4Rw3JG/8GDh2FFh1sxKc4ISY54P7IjuyoYJ8FWwfilgEBGgCZpnOf4A8KIccY8WYE7NROI6K/IAU6YAIUQAVUIKMv2XLtlE57wHNDek6BSTvhr5ig5pOJyayEyQ224AliQD03wwJ7sZVhepVZeYX7AAyM4AiOgFCx4FOEewzEAKCL+1xPlYd1N3evoAVukwz4ABhOB+NCZDB7b6qr1Xp2lZzDAs3kYiikd5JgdHVCRB6mYRdGwZu5BylcLx/rrB3hGppN7uSkBBz+7BxuRB6SIQ9icgP82mKpwHP32ez8bzWKqgyCQAzKIGUQ+g/e4NR4pjLSFKvCAxl+gRX+wLIztgNMoMP/M1r/RFuwQ3tuQ7vWTPzEcRK1q8asgIkHtsAKeqAD+K4qBaC2bVuVTze3BxcMfHvYiMBmr6Br/Ng1GpRBixy5jVwIiKDBrkAO8kASpCFD0EEb1GGSPM+lsNy6yGK+35uMgSR3+AW838Ec0BZGsQQdsEEYRkEVRmEYhsLh2uImXIS7jcT3oBlEuWtWCel58NunRAbnNuCv7xmf93mPn2AJiC3t6iAOVIwQIKEQwEA5I3yWcIYYTgEW+IcXIIEGQKABFoDDTQAFYiD/GDDE83gJTr0HSts6cbLWrBMJbC0naY3VeaAHuAAGZLs9X1qmTxfHeX2FebwG7jlpriAILhIA//14CIqJgZYbZ4ng5oIgDhhjFbgBG+aFGuChHM5hHgJyIMt3W5N2u9E3LjJKRcYhjtShHcrhStpBv0fh3YHhGYYCLuDcRTgOq4Hkj/AcjbUL+KCHHuShGgwhCFzgAz5ACP6aAe3X0KmACxxe1+jnmQhiGB0dEvxgA3nmZjzBE0hBEzoBFGCBimzpDmKg01fg5GNgBuiv1AU81QV7wiRswpAA5kt71mve1WXdrHpgBjKg7xZA13Gb10+Y13UcDGoAcplGaf55CPzYhxkUYXH2YI3a2Z37BjKlMfrSGs4BCw+uHgopjN9ijcuhz5AwStqiuJSCo6SXzL3hHsaHHc7BGf9W4d13gRm2Ac5lSpEcDuJsL5rrzLrUOAmRNs/RixuAIQzWoAUMPgiWGzfX1Qky8gvSIMTop9mo8Z8QwRIsIfwkXcD0BDUs4RQ4Z08yYRBwgJJpgAZ0gAd0QOE7N6QFW49RHdV7QAlm/vZjfuZbncVPnLWtbglwnSpROeiJfpWD3gjAgAnodA5jA6D9r1CN/SKRXOpx1kGx0QeIQFPy4BOswRqooR28QR3q4fOAVfTg8dC6KLgohqLYn/2jti7COkbA4anhRRumIRc+YRRWIRkmFM65q94BIpzAcuIKfvvWLaHChdq0LVR4ENzBhtq+gQsnDhy5bfKsSQojpcWHB0H/hJg0KQWLEydVqnxh48YNnTp19OwBJIiQoEGEFjF6hEmTpUB9ijYqmokVL16sSG3KRCqqJ0J0YMBg8mTJkiFDqFDRAbaHWK1LnmQli0QJkrRIeLhd6zZu3B106ebYwWNHjr17Z5hIgAABAQEIRhg+jDjxCAgQELOocQQskB+UKwPhigULESAnhUjpjFKKlCA2fPj4ESVKmDzDsF3Ldu5cvXbt3LFjp452u9u8eetWB/y2u+HEe7MjPvxdvH794sV75y4dvWbQ2qU7d03YJ1Gjhk3b1y9dOnLkyxc8fzEcwYIKwy08OLEiwvcWKZJr6A3jeI7G8sjJIdIDV3yGEhZZ/7T0RRow0WEHTXvcxFMihxySiCOQTKKJJpAUUlRRRvSxSYiVjDhiiKywMggdQwDhBhpcbOEVFUu8tZYSSqzkhI03qqVWWj22JVeQbtW1l118vZDCBIANhkBjij1pGGOJsdADDkAAccMNP9xw5WVcBUGEFKlFIcUVA4qGpmiklWbDD1c04YMiymBDzTbn0ANPOschh9xx70CnWzu5DQdPoYW6A507uhkKDz7/MNdcPPDMc40xwlCzTzbMcMJJJ75EI08//IhXTqmmmnreQAYhhJA4GJ1XEDgSwXdQNxFJRB5+3pQznjbYfBIGHTO08ICAonkmRRZjtKRgTHY8axMgPP9RSGEikFiCiSegRJLIUUYYMUIfjVTSyLjlQsUKMaQMUocZW9DRohlUcKUDD2ultVIVOfKYo4837qujjvdeKcSQRubwwgt7uXABYAgIQICUUD4psWE11KDDZVhSxuWVK04WBJoojYysmjewGcQLTpS2ijXZwHZOO6XuaRvNiP6pKG337AwPpD4zB8/O4P1DNNE/73MNNNNYqs00w3zSCSrKcFOPqAWNM4455mBNkEYSCQR22GF7Q3Y44NgKn0Kr0trPPvXQ087O8ijDRxxnuIEFZVJ4lRUVX3zBbEwMQhstIYcggogjFlqiCSgnQtLIJkeJG2IjhVSSySaksIIMMZb/CLJHHXOIfsYWWHAFRMBOTLES6yup3voUsrveb1pXRBHED5ytmMMZRIwhRQ5DgKAAAcYH5uTEUEr8mFhddslV9McCQSBoWFQvmmZEbE/EFluIIQIfoO7zzz77wLNcpM4p51zRQd/DqNGR4kN/oZDukw/5j/rzczPMNCMMYeTCGMNAxSeCoQxoaGMf/mBHObCmNazJChwZEZsFLxiOb5yHVrCC1XLqMQ90qOMc3FhFHshwhtIRoQlY4NsTqOCSv6VBcM+CFoQOlzhHTCIoniAFMXixOVKQi1x98EPkSEELYizjF504hCD0cIYxwEteqPsB7FqHo4DZKIta7JESzESE/yAEIXpAkMMYsJADIMTAAgkgDPKUB0fDNC9jGoNejKhwLCHMK3p4TEn1PHOF7Ylhe94TA8uwUY+i4aMfj2pkP9C3SEfyjDlFg1TRiOYO+90jf//gHyMd1Q9NHcMYu5BELkZRC07oAhi7MIY26LEP3mANax1MzyzHgcFXwUqDa+OlOEzVs3qs4z7aiIYiwjCHObiLCD9oIRXMAsMYNksmDbJDtAYxIUIgghHX4uEpiAFOpjwlE1DhBTiRgQxadGIRhgDEHMYwBjSUbo9ixNe+Vvc6G9VIi/fy0b2UMJrcPQ8IYhADZ3DAgQQYbzAEKEwcJ8YCGohFCNCDXvSGEJqLpv/JJAQ7CREKKsiChkAEeUiGPPT3KPCotB/wu4f5Xrozl16yaC81X9xcar6Zuq0e54CGMTiRB0l8YhiqUAQndqGdXJBDNr0RjzocuB6BRPCWVOXaqc6DKqyeijn7UEc2roGNXeQhD3WgwzJ/ACOzmKUlLdFCsxhUB2tCyHCGS9wONeGJULjiF+Ds6znRSQxaaGIS7ByEHt5JBDO4iwqZCeO/cITPHO3LX/wMmI+kUMfnbQ8IS0hBAgpgvAAQxjDgemhiLqYDKwEhjQNtLWek0BWulKwzeUzJIEP6gRaI4BPYoMej8CG0fcR0uDVV6UyJVtycovRRjGzbPLYxjWYMQxL/klhFLI7hC04MkBnCMAY58AGO2wAnNucIjs2KY5zh9KZPNDNOb87Xj3J8NRofyQMdzqDYLQxhC2cpC0vYmiBqziRa0iIENis0CcZ5ohOcKEUv/ArOYNAiFJRQhCAW4cTQjeFKd9yeGAH2rx1Z9kf/JDFcPDaEjOHASpuNwQIWKoDRfutDpX3oxWSwYo7x5XmsXW0aPeMV0NA2M6L54m3DIIYwPEAENsjDMU7aD3vAwx74yMcm73HT4IInfZTsB/2GuzNHMocfy4mHO+6Bjugm4xm72MUxguGLUQCjGee4BziY4xxDtWMd81jHOmrzp0AHGjmMIjSjDm2oPsFXHNdw/1oe4lAHM+LXdDLqgVZ6cCN9Bc4NdhidHR4krUEAwnAWSjAmIoGJSVzCE3ldMCckoQhD8EEOddiDHiI9hh+4wEpcoULuKKMWutgLSELKS13wYrAi7eUGOABLaleMgx8MYQYNMx7EmkRaGtdYeahNrZYow5cec4aiqyVYkDtDPTRlxkw3GmQY4hCGMDjgA6XhBNUeOeUpVxnLOotpzyBV6Jzp5h5ixjOk6rENnwpjGMoQhi+AsYpcOAMd7WBuP8bB5X3QY+P1gF/64kHlQtGPfoocOcmJZnKSm/xQ4OmHN67xDE74wD9yOEMZsmC6rOigB/3cl0uaNYeZyPVBN6xWIv+OrgdAPGIRPpmQqEOXBi6w4QzBywEOXuCC522JMsYOt16K9PVwi33sOWA2tFecpSulYAGCiXFDJTbjb3HbCEnowffCKG00hvtKrN3L80omMgKlZN0rua0Y4hAHBmwgBDcIw5P7gaibxQMffMpkoZzjnC/zex6c53zcgHtJ5tyDpwpfBTAIKIyIt0Ye9RCH28jXjz9Nfmew/Bkj/+Go4+r+uLmf6cjJFw9vTCMZeWhCHMRgxisgIQvP7AFYgMQWJLBEhmdAAxuSGfQ6sOH6NLGJXNEgBDmAGhChqwManvmVI2E961fCQZa0RCSy32XsCau/1+lygzTqrjI/MEMPMLD/JBDDGAOYbTP2JCxAd23gBmIwBkkmBmawGcsmf2kUPYCXGVgwZJlhZNsTb4mnePXGek8lHMgRKDcVKBu3cZ03D/KwgpyHDpwnDzEYg+jADdIwDKyESsKwC6swCg93DNEQDc7ADMwgD+iwD85xe+XzD/ZzPy+1e7wHhSlHP7C3D9iwCj7QBKSzBmTgBVmgEv0SJPuEI0RWWwaiLGOQQjeXay3gAmagTDERE/JkBlygVkvgPKq1bJXBA3fxdfYSf8I2gWBnFykhRgyIBWNABUdAAYFhPAPoiBUzAts2AjVgBFCABnOwBnJQBmUwBt2jXxxVdlmydyaBOpxBhiJTINcj/wUfxYrcgwVzEAd5IAzyAEvJtVP1gItvI4O7GIPc0IvygA01GITJcAzHMAzCwErAcEqj8Amj8AqqoAuqkF18IAiyZgiKoAi74ItI2A/+4A8odzROiHuXdHIqJ4W5J4Xm0w/0UA2K4AM3kExrsIVd4IVgaGzINmwDM1AFkgX9OAZlwIBjEATMtgVWwAVtgJAxYQYYaGlksRUDxX9f14ddF4hiJ2z2IgRXUFD/WFClYwKL2IiP+IhQUgNg8AaXSAdyIAdzIAdoUEhEcD1CsGyi6Hfl9jx5hCyhQWRXsG5Jxkzdg3xhoAjV4IvywA1HiQ3YUA3VMIyjZCnIuIM8OAqcQv9d2IiNfDBWeRBveTBzecAH1AVrnCAKtxALt/AJWOkfeqAHfICNxoAN7eAN/xAP/sAP/MNcMVVTeAlT6Nh7I1dyUlg+9SAPxuADNvAC2yePZHAFWQQkwkYXzuZsPoZiMZIZZ6gsgxQEXnEEm7mZBrmQUiAWodkDvON3/LeHfIgXxxZ/8lcX9mIjZhIGZRBF8GQGSaJQEbMYIumIURKJCGiSdXAGtDYTdICQs0kEWTAgFBWKe9dannESaSIajGUm62YmYqAlQeA7jyYJnEAJksAIsYaWiBcGpkGe5UmeIoCeptGBXZmVXmkIhrCdQsUppnALo6ALl+CVNrEHg4A4iiD/CcggDOeQDeIgKvzQXGDmUsQVU+0AD0Qjcih3cks4cobiKPsAjJ9QmCGQQluomJJljwYDmWBBbnp0R1vgj/AET15IBVuwBDcmAzJQA0uwomZAFqEJBDiwY2IUBECABHhBbPe4mmOHj/ayOllABv84BlmQQj2gJI24GIehm07CAuLiB3DQBsmkkmQlOggpT2sQBmQgBjE5ds+DUUL2GdDJWB+1bmVyBT+QO3GgkuNpA2w4py1gpy6Apy5gA+9nnqbxA6VhGnxQCqFQCqOgCq9gCqZQCqXAnXFgCJzwCZxiqJLwCsTQCYqwCEdXITpECYzACYqQDNNADe5gSSxFD/PQ/w5TiKAMSijwQCj81m9YtjOBUqHYEA184AMiQQZkAJDIuUUfygOQKZqCFyPeo1hmgIZR9AVc8CIycjE0AK00cARloVZeMT3k9lqi0RZpcZEUyRdhVyT5iC9TIAabeEZYgAY9kFCfhQAasDyPqAFG4Ad/8AZukEw0kZKjMwdoIE8s+aUAiVk12VoY1VHjFhqUqRlYYCaBlDc/EG9ycHxyYAMhEAItEAIfQLF5mqdWsafv934tUBo/YAi00Au98AqdoAq38AqfMAuogHj++QmXAKmwJgoxywmTEAmM8BOPEAn+qQgiIAnPMA3pYA7LAVwpyKDv8D4LyqqWRygluKqL8v8P9cANu5ChG8CFBcWTW6QWQSKsoXkSWGCs7nKsyToGzNqsQ+B8R3AxnGmHZeEVF0gg44YmNAJ2yYaaeiFs/bRFslOuUbQFXGAFKaAABZAAC+CuE/OIJwAGd3AHekBrojM6NEE6KeSvUycGV+BjOYCtf9dRJBOdCEsEC7s9QuCmYUAEZnSjH+AADrABreu6GyC7s7t4FWuxtkuxIWAajFAKqYCrqoAKNeufJKUIXskHnMAIjzoLruAJl3AJkcBO71mNfGAI6DkK0HANz+Fl90APfIYcsCqCNaNexxGrsFqCtTG11uCOPsC6u6oFXviFkyUXziaaPVAgxnoGM6pYKXT/Bn8zBt4TRjfabKI5BFqhbtfjpp2BRz1qL3shJMd2j67pRaszBVrAgHOAX1ZwBBxwAIaLuAioPIzBuHfwIId1a2fABgNGB4gXB2SwkmcwB2xwcwHLua5FMNBJinwUIxnJPUSwfKURBkGwBWYQAg5gAEeMxAegxErMAE18AE3cxLB7AA7wAB/wAT5gCIwgCZeQCqUgvD4QB3zAB2EQPpQQB5EAC6SgCanGCIIgCGipB/flBugpAsCwDdkANPCwKCToDiJ4HCMoHAyaqvyWG8BhyMAhmP0RBC3wur2aGVSQL5PVTzy3BEpQyQCVPS2UBQu5BWOArPzLBl8AT2cgBmN0/3UzMAMrpgNDAE0YNQRIcMOquMCOaS9Bopp9KARIkMuAlAV/e4nuggY6wEYJkAARQAEkYIBQ8i1tUBNrGXQrKTpysMIsHAZrQAdBNwcAKQZZIJMB+3d+55zhfFFdgUc8zIo9WpinMQQ44AAMYAADAM/xLM8DUAAFgMT3fABH/MTFEgSa0Amr1ryccAmS4JWx5gORMAmPgC2HoBNuLMZqOVZ0cIkb0AJxIg2s9yj8UJdJ6EhPGHqNRFMvlYv0kJSj4B8DggRVsM0FxXz6Yo900U8+QsGzUwVToGlaUAVpoNNuBTierF86EAMwEAMDbIdPEJph4Xw7Z79CECY9ehdx8f+je5tGrPUDQrCjYFJQG4nB+aUDHKAACtAAEWDMHvAYkjgCJ0B3R2A6ZVAHRMCrdCAGKSmPECueLpxMaHBGolFuoLicXdK543xuTdAEUbCwhH07uCMabVrErbsBDLDEj/3EUBzFsEvFxRICRPBocYB3pmEDzOQDpNECYQBPspmldM3CKikHDKC7cWBvGO2NjLRTtpiLs52Lt4iLKMiLwHgMxSsHVWCHVaCwPEkEz8SYMS2Gs4PcskPBWuBWacDTLcGsRo0DqTwWb9sDMxAD2T0DqaXUnrE9TsDA0GcwUC1uQ6CjWJ3Vycq/ZgADDeDeEyABEqABJ0CJcnfWF8MEYGH/BqgdaV8aBiqZiagtBwGeTFPXj1mAWc65uflnwygmW0Ig2KlR2GNC4TcwkKwrxY/91VAc2VEMxZRdLCEu4lVsxSJgxXtaGU2goz4Qby3+bhQtAjM3Cr5ID7ed2zeO40Z5lDuOlEz5DMqQDNqRB3pQBlnBA8AdSNvjFa4jMNuqIxQ807GD3M2tBfKEtnRoh0gtFjunAzJgFUKNyjhgaaLx3SbWtXvrFmQ6BBcotse6v/yqWOkKAhZgARKAARpAAiWA1jNWAyuwAl6+Yrt2BkEgBmRwA1cgzXOdkgK+kneNohjoRxwlmQP7MRUI4RRO2Jg+JjZgA0HgApTt2JIt2Q9Q/9kjbuqnXsVLRsdzCsSxaLzXqMVbzAkvQAc2gJ55AAzckJRJaQ1LuZTR8OPJgHpQmQurIJVUCWuKIMZZGW/liXiiswQ6kAKm08MwyUVw4Zr3NAU3otyrw9xaIDtUnkJoW2n163wzYBUpoO7rDgNivgRkjgX+UiPAmuZecoHeM8RufgbXjMHVxwU6AAIXcAEZYAInoOcrUANQAAZH4OUxkAJfsQEugF9ncAV76sJkEOB0kJKLLs3XzK9RZIbImUc2PM4PTuGDPSYRPiZtmjsu8Lqv67rFArsh/gEbYMUXKwIgWxpB0IFjRY3XqAhaTAmX0AmfEAqEegqv4AqycAu40P/0JQv1vQAIP/ABBxDjefAJyR6e42kadOz1pi4Cp+71VvwBMR4Hc8BfPeDlVNDDYiQFlkVs0qft3O46U6DTzl3BO82/k1bUDakVQJ0CICD4gw8C222tgyfBMi0wUB0a+D7E+Gu5ksuScjB1VJACHMABIAADKCADKXDkO+AC6u4CFpCx+K4HFW8DqfHfdGDNGl9WcqCWDVLgpGyuSaqKAzXO+3jpUSDYKN/7Fd6mWGCdW0IEcLqW1XgIjBAJkXAJmNAJ2gIKSH8KsED9tIAL148LUR/1v/AL2h/1uuD9vjCxTfwBfICeqC7iou7YkM3+kL3+SqwlQPAEEuXl5n3eJSH/rnybTzgyO63T3M4NEFq0pNFyxqBBM1SecHnScMkSHTBSgOjQAQSIFCl09KBCRYoULFiQKHGixKTJkShTfgy5ZYsZmC8PGqSDRk6dOWN01hmCA0YMHUCR3HARIsSHDRscMHDg4ocLG3V+3LhxJcwaOXLW0KFzs2udPXv01KEzh43BMgbHYAE5xO1bt0DkzpUrpMndu1Gi4NXbd4wYIgYTseJVmNcvxIkVL2bMOFiwxY8h/5Jc2fLjEA4OOBjzY7OBAwwYHCAduvQBA6lLp2ZNmvVr1a1xAMERMQYOHEKC7CYSRAgS4CZLniTuxMkU5MmnCEzTnCDzg2PMuKTO8KGO/xQcMFywmBGGjiUdQ4ZUgrykceLFQ2bROQahQTRozsSfc0ZO2TN/6YgZ03HL7DNuCKGFFpD6oAUHEtwghBvmsKGJG8IgI6usyJJDDz3uC0ssO3Caw6z4zshixCzYkkIIFFOkK0W++mqxCb2C+AGL/QQhhRdiiKHsMcQuqyyyyHjs8bEcfbxsmGCGSdCBROZA7YACNluKqSWXFO3K0VaDzYACuvTSywNckAgEHFJwAYcf0gyCiCF6WEI449AbjqTjtFBuuYEGYuM5PeXLYgsqXILJOohSuAADDlKQgQYdNgqPCjEixcIJgaY4boryhkNPCSxGbG8++j6MD42y5uCqDv+yxgiMLSpuAOIGG1o4aoMPMmPggwRfcKGFB224oYkJM6zjPj74wHDDsMbi6kOz8lOrxBNR/CjFj6TAC8YrrtgLxm1h/KEMIsao75HDEvuxMXR76aWxy4hJchh44S1mXnqLgTeIPTABRLPSFDAqBBsCJpDAf/9N6mClqhStSgU3cIEuutQUQoqH3kwvvTjjxDNP5pxzTr4xRsTCP+q26AkGEDjoQIYeWl5iiI6owCJSMdhwY0+b3UjD0uUIsjQL/v7CQlz56iPV1DFukqO+U+u4YowrpmrBpYKTauHWECxYStYmBoziPjnCkCMOOjCkgw9AxNLDjg6XZaOMtJxdazz/Ieo6ka5ss9Xrrrz7viKIp39YKw5PeKEFF1zU9aUXXG5x/PHHZ5FcclogdxxxzBHXpRddOvelc10Wl2UWWUIPHRhNJgEkhxA2sIA0BT4QkNeAaw/YBdx3lfXfD3o/OMHWFzSqhdnkymEuIdJE8aEjLD4ppTmNS06gjjv2OI32Qs6io5hc6qlMjFhu+QmYxYs0i4GuZyNPntNQq72QxJ2DLDpwouOM+cuisA49xHhaDKLg4Ew6UIoLGLCBhaWAAQZwAIEeILav6SEO98EQWdAGCAymzQ71K1WzspCf8WChbhO7W4r61hcUplBGMsICEYhgCFocrnGhY1zjHDe5W0gu/4eTw+HlGpe5zXEOdDTshS2MaAtf7MIXzxjEHuYghR24wAJaO4CMePUDH9guYFS5wQu8+MXchTFgOJBVURgEhBykEQjKE8LxeIAE5i0hJUoIDklOIj3kUO96BPGYFrCwBfZoDwtnmI73dICDGMAABjhoGUdg9sdOjchnlVoOEi6VvqC5Jz864U9W5meqm6AKbHHA0Bn8J4ZYFQUNOEgKrhygANJwoAEW6N2AbhA2PagNQ8bSwwUxqLYOkeVDbxNDfkTGlokhU1pSyFsKnamXqK2JCGJYkyYqpzl1QY6H2+Rm5S5ni1toLojqIic5HRe6XQAjGdZICxbQgAQYvACBH/+oA+3S9INrNWE3dEljDn5AG9zggCq+uoEAXeCq4smFjXJ5o5seMseLwck8G2tO+vhIkCr8MZAiIySgqDCEQ85ApLXRQUdg5pJOhWx9cULCDnJQ0Ty6Tyf2mQOFdJKV+qGKf/VT2oWyMgZf7c4FIPgAlZhyAFgi9QILakGEvmaDXlJID2XDUFVRxbY6dMgsbOAqV0FWokgis1rN3Bu3nJmtmU1TDD/IQylgIQvGce6G3KQrDyEHTlyAToigW5y6jKgLYOziGNiwhh3QYAczAIEKINDaHsywq3v6gCpTUVNALXtZLt5gTUB4gWUhVhceNKqRPYDoHeuYsUttrHqVqsL/n84HVp14FKSNalTxAvVH6sBkDNSzk6XOk76B5MQ+Y6NQccvGlQqOZar3gdoVXoAgpRzAKAc0wACsG5ooWaCVIXhBVT6whjqsIQ5kI6Ue5ofVUtlhbfRDFbPOArcynO8j2WKmtspqVhRGrTeRmmYQWhCJVrjCceqanCwMbGDJjY50ozuwDo94iyFGOHS+oLAu0rkLY1iDG9wwrxSmY8awGNQHu5Fmb1zYGxKnOE1crB1VOvsCubgFRRATbcuGgCI4mTY4caLTnXhGSS24xwxCG0/IZDvbHsQ4UCUTFEx0VtHh7GwKaeCqTIc7QbCBjaf1G4tOTZkVLn7AAAyApWas/1uAM49mAKAJDa4Y8KsoSOhCGLoQH9S73vrdOVkYYlvbhnkWU5IoC2R9Zl+ytaYfBIG/RLBBGEDhClmEsxcFPjCDK33p0T0OrxLeBad3sYthTEMeowaEHdzgBKrIgRCDyB1VrmBimo2hDHE4yNJ0WixBGOIQj3gEJDCBCU1gYg5YoM1o4bIRG5NYChE9rZx8zLM8CkTIkhoPe6hjUo8kMyRiYHJM7GQneX7gpTsrD5XzU4bijo0ME4xDGMZLv67UR1X26SKCUqMAB2zAumtmSghcoBnQJAhBLQDWTciQy2Lt8pfISlsG0yYWDgmTWfWBrxgG7Te9dQua0XQhYIJgA/8RKOIUo0vcEQ0cC0wb+BWyeMXKD3xEW+QiF0P8dM2VGNhdCAMa8phHPerxISlkoQ6TAMUjejmIQzBiEbyexCQsAWxPeAIUpKA6K1gRQ1oYply/yFGOWMEGIGRBChvZCFwaOYQULzuixdHYs6fnM52AlQgfaY9LYib2oIOV2y9p8haq8PcLBAAAgz/ABZRQBUoRJC3jpfUYguCDH4TBByJogQ/CwBU6uMc9/AnCDXKAwNEUYIHWbWAWMCiIPdzAAA8IQb+zRYat6EEQgMj1IfggCEEMYhCEWDXuCWGIQcw+g3tG1bL0h5YskAHjV2iCXZwfBWbeIFKa7Q2BbNAJV7z/onOyqEX3vV+LWIQf/C0nf/hj8X2Z58LmnwaGMIQBL2PEf+fyoIfP88CHQ2DiFDGEBdb9/38ADMAYMpzE6YWug4Qe0IEbaIGWaZQYGwIggBm0WxO24DGSmALoyRjzuCQtUIKBKImNEYMpuAInIEFK2cA4+buSeAJA8agnoAIu6AgucIMv6AHBGzwcFIALcIEvcIMNGpasCBCAyQMfeIAHEAER8AFgGQs5wBdTMQgpeIGMcIB9WzMhSARIYIRDQIRDIIQmGLMDoBUXeIEyAIRcAoTbyz1D0DXgG4Q1XEM3DD7aMxa10amuWBY52CSasbgriJaJIaEU4Y0TI4IrGBAf/2CEXmg/YVAFVVgFR3xEmauFXFAFW3AFU0gFW6g5YTCGY0gGZmCGZnAGZ4CGaIAGaZgGa0jFa8AGbpAHbkCHbbgGariGVug/w8g6rEMcAeQ/AUQcdaEFcsoRXgAEiMAdJGgkuoALQRwJZ+tAOmk7H/u23qIk5YBGFMyYhuiIhnjBmJlBNygAHMTBADiACbiAJTA1NsiC/aCDHyAjyTNCI0TCq3mBOgAEFDmDPUADrnKDHPgACxiALmkgPXCESXiEpUMERhgEG1CKF0CCKXADOiCEQxAEiTyEQ1jDRbBIjdzIi8Q93EMbPtCl4uOKrIgDuEELi6uWY5oWIQiJEwOcK/9oqggxBWVIhmQYhvgzBk9khmeQBp9MhmdYhmH4hGJQhmc4BmngBm2gB3SYB6d0xQ27Bqnchm14RaecB1iUxVQkpwDMHMvJoVuAhVnwpmuSoQIkJ13IEU2ogicwKDh6iLeIwLhINBeCngvsQNRKrWicnkrBo+TQwA1Ugm3cRoXIRoWAwTZIgRsMxwJYgARogBR4giVAgyBwjyAwxCJ8gNU7Qs28LgZIgS9IA7aZAxeQgjHAHdEYgBDYA0ZoOl6LBF6DhEG4ggP4ADYYBD0AhEPAIENAhEXIyEWIhN8czow8hN+8SN0LvuCbvZDsMjukEK46gzK4uCtYyWlxCRfajWz/GRAbOMRqYEVs2AZ5QIdzWIdzmIfxhAZUfIZV2AVmkIZmYAZ0gId9gId+6Id92AfzPIdzoEpt0IZtOAfydMqspAZqmAZd9MVf9MqvbNBwEqdxAp1f4IU9qIIemAEvestHwTa34I0gKK28tEYfkx478cs70ZiMEUxt3MYl4MbD5II2OIBwHDwCQIACSIALgIEnoAM2aA8f+FEb0MzUOEIRMIAAONI0e4E0uBlXWcB+FLMWWISmw4RIiIRJgM0qPYSqGAQ6MENAqAPjZIRHqNIx5TUzVbqlM0iNXMMu1L2PzKU6lLhmiS9qG49q2YIWQrFsaQGokLxdIKxr8IZ0GFR3/4AHeKiHa5gGRd2FVWgGa4CGZNAGeGCH++wHd3CHe2gHcgAHdCBPqhRQrHTKc5DFA0VQXcirzMkccHJQxHGcVY0wdRmnX/AEIfgCHhhDF5iTaqkWaukN4PhVOOEx6THRDVwO39qYEw1R41BB1Po7xKsCLliCAQAAwatWBEgAx7yAGFgCk9mCOfg4kBPSNTNCIw2AAeAABajCATgADsABJbAV1niA1rSE1LnSprtXPggDM6wDQXgEXStTK73SKoXNMjVTgyxOi/y95XQ44sO8rYoOQQqhPHWh7XyuJvABRYgGbDiHdlCHdPAGb3gHdoCGZpiGajCGUUiGA00GaGgHcf/4h3T4B3hIB3Dgz2zIBm3oVPLs1HmgB/PcBgMtVQlDVcxZVQc92s4pJ3ISBCFQgh7wohZQQSXYVV6dmLn71TlCLeE41hPFExKtqN5CQYxxAmbNGGclWy5wAQE40iMFAAS41ghYgAzoASuwgkARMwMQgQdYM+vizBucgAEQgBu1rsELgALQrhTAW9BAhKdLHUyYUkt4OkaQPT1gBENgBMsd0yq9V87lXIJ9BKWzSC40BI+cvdnbkAqSU0Bjg68yEZc8se0ckBaQvFEIz5ptyn1oh2kwhmeohmRYBWGIRWaABnpoh3vYh3u4B/IUUP5sXnRYh3VYXv4kB1JV1GmgMOz//RzQCSfLwZwHxQUj+t4ZyivOISdQmCYgUAKoZVaW5NWYkQJglSjf6jFiNY5KIQneoiQ5sUCSeIgnMNtlfVYqSAEBKOC1FYAFSOAIkAAU6AGGQAN9g8cqzNu9HbwoAYABQNIoWVu2HQB8q5UPSAR69YRJADZg0wQU1oRFuNxFYIRIoIQXjtzOleHOHVjQRQQc7sI2LF00bE48c68ziM4yCJn4+QvAIMQrsBrLi4M8UIZWHLVR2wZmOIZqiAb1qwZugAZm2AampIf6q4dsCNCmvMrz9OKOTQd1OAdtCFrrzV7tBR0GvZzHQRy8SlVYVZdF+AEiEAncaYGMMZGqjRkq/9gUOikP8+ixHlMOQ6YjY422EnWCDNyUJXCTZ0S8ZV3WFEAzAiCAAECACIiACoiADKiBlpkBHSgKva0uc6XgaaXWBaDWBBCAAYhlw12ADGZbw42dRNAEqcMEekVhT+iETtCES3Bhzb0EZC5hTYhcX/41X5ZhS2i6KkVTg+RC3tvhDGrOZPGzrpoJtdBDmtkAAgmDMMiDMPgEVuQGwrIG302GaBiGXMBia1gnbFjFa+hUeZjFquxZekjjMT5jctCGbGBjRa2FSiM/A3MFhVboVEiFllvolmvoljO/V0CMpO0FWiiFteDVoCtbJ6BakNgeKmC2YEUt38KjDtyBHaAUk/+eKB9DvG0MYDrCGBBAMwNOAJx2zAQAgRn4iRlYwCJt2wHw28FLgDNDswLogAMgAAEwgQTAZQ2+gETIhEzgZV6mulM4hanrBEq4BEy4BElgBEmYBEqIZiulBLRG6yvVXNhUOkRgQzj8yI/kJf754T+TTpqBm6A54hPaFnLehaPsxGMQ7GFYhWTABmyIT2eIhmhoBi12Bp+0hvBEh3roB5hF43Zoh3TYVGoYaIJ21VuwhQWjtAXLPvI77dNmRFXwhWD4nFiwBVrIYxLaVUuOE5YkoZEZZK19xpZGweRQgjdqZLe7RuOIaZaqI5OoghewAAXoEgJI4ANIAHK8gBS40Kf/bYG9vcG8FYEbTAAC8ODmVoAM8JIEyACoZltZLoAGcIJEwASpAwVQyGr41oSuRuG0hmF7tYRLuG8YDlgyBd3f5ELkLN03PZawCKayWJaJq6mxMckhFoMhJucwuIswUIRjMEpjwMljgOdhkGxpSIZmUAYRH2xOjIZniAZrEM/KvmzMVgdwGGjPNlBFjVXOsaGvrJxZEG1ZMD/wE7/ukzlg8AVgyAWDboUwyIEhmK8rYAtLYYmQ4GhBjqgU1Ziw/UtLCY6/1EvinpMWfYLajt/j+IIccIIc4AAGwFETyIAG4IAL0K4ZSKMWKNJbHuoKPlIU4GSAzIgGII0BMAEOPu8j/y1ggGyBQdAEqqM6906dSAA2SUDr/X50ZI70tG50ShDY/wbw0X1D4BOEYvGltKmqqsIqnZJTregKxiMDcs6DW1iGZYCMYECGYNAFEbdJEUcGW5+X1h4GYBiGZJAGbJiH/AQHcPAGcFCHdgCHziZVGb/ez8HeoQ3tmEu/9NsFaZe5TxsG9wtyXaCEEACCN9GNJceCJg8rqo3ysT1pwPTL4ziPY8UjFM1ylOhyZr2jv7OZM6hHQtiDHZDCjECCGUCCF9iBd/2AzuzbybtlagXIW46SAxiACzgAqObgAg50WQbIHdhlTyCFE/YEYkZmTuCEYB5mkR/mjo/0S6DhGuY1pf9D04x8Q43sPYdbOIizKgvBkDwoyQkiA0WAhUmDK2LonFrIuWHQBVRAhVAohaMvhU/4BFGIBWFQhu/kT2IXdnIQB3DohmxQ9lJ1v2wHBq8P8q8Pe65/Pw3vRE90hmeAhlSsBmmIBmXgAxtwWiTQjR9oSTnxaOOomCWY8nWvxim3cpMwVi2fnmQ1CXm3ZJL4OyrDKkAYhESYBE9whBzYg0QQgw2iFDqYPNTo23J+ALYNRwGYgAQogCMtgMAzVw0+0tE34Fuu+AJwgUPQhKkDBRSeulC4/VCIOviOOt4XZt8neRQ+YV+W5oElU5bP4YTdPZj/JZDUJVC/eZySkUGQulL/AEZdCIZaAIZi0IVQoP0UDnlk/gRbKIZn0LB50IZB9Yab/QZwEOjqlQZoGGybtElmQPsTrwb8x/9URGzEbsUnhmKAkCdQIDZrvkTYUNIDCZYrQYRIUaLECcUqFC86ebLkyROKUzBOCSlSJEiSEqdoGaly5UeKSjh2xOikSho3dOwAGnQoEiZPrGixCuoopx07hPj4eGBgqY88eQwMCBAAAFUAUwMUyGpCaoCoA6BiPSC1wICoXLkOYMDGEqlTbU/BLXUKVCm5oe6GAgXKE9++fDVp6gRYEyZLliYZnjQpUqRHjxwxQiQZ0aHKlQkRGiQIkKDOgPjs4cNHj2g9dejQ/5lDxIccSJhg9dLlq1ixXb9MkWIFSrAmUr49UepkytexatzknVPXjhw1at3EZct2jdq0adCgceOGTTu27dm/gwc/UB49evXq7Ut/vt62aopE3FCyREnDK0KQQLxyBWOV/hk3PjFRSE5M5ARLKbF0EUopGdhSgw7KlBFHMtHkRlE5MfLIJL3x8ssvvOj2GCKAHGKIDw4cYMADTuUhQllSUQVjjAcUYJVZZEn1oo5n8RjAAYCA0hYsrbRySpFFnlKXknnt5ZeTvGESJWGJLcZYJI4sMpmWl2E2iGabcSaIaKPpYVodNvjwgx6Y8ILLLsIYM8wusszFCi+gYHKJJ3r1Jf9KLsY4cw0656STDnTUZNONNtk0Zx000gy6DTrZCbSNpd9Jaml3ks5jXnqf7lNPefJwY4wPIrSQkRI8CIEFFTpAJAUWEhVI0axDSGQggx4hKJIWaWjxa7AhITjTFFVMoYQWyDI7IIG0XsTRfAVWcYYbddixh06RWNIJKB16CAspnliCCCGA1IHUAw4Y4IMieSiiiCBhMBCVVVNZlS8AZr3YFb9dXRXwWWUZsMEgoMBCC5GwuAKXw0mWcpdeTTbp12CDRXnYYoo1xggjjjzmcSKSWUaIIV5+2RmZe+yhhw9B2EDGKbGt8qcxc8ISFC+hdNKJJ6SAMtcnfg7DzDTakPP/jTjLNXcNOYxS96g05403HqUDdZc1N/Ts008/+6TTKHbcjeKDDy4o1EMPSkhBBRU9zDetrFjQXbd+EV7Uhd57d7Hgsv1ZNBMVVQz+RBVcEJ7RTHg7kQXdUkBExRZjyFGHHnsAQggij1jiySkd8kIL0JhAcsgedqyRhw0PsM5HvJJIoogkLYLFY1Ux2juAWACXNYAABAQggABlFSB87wMU0IAdmvw0Sy+49OIKLHCZksorr9zlV8/b80YYYVEqVqWVjCyyCPnkT2aIIJSp35n7o7Fcph5xyKEHIJ4Ec8wunBhTjIe/9EIWv3CFK2YxpFPQYhavkIUviiaNbZzjHOsQ/9U5LHWNc1BnGtLYIEG6Y41qVOOD1YjGM5zhDGYcwxgqREYyttG1fpyHGcLYxS6GMQxgxAIpP3jBEtQ2n7a9bQlCFOLjpEAEIujnbjLhGxP7JhLABc5tUqQCF6roNpgA7iIS0Q8WpOBFyVHOcnsQxCEWwRPPwSJ0uvEEYRIBCDqsASkhEIEPJMGJO8JOEWHwQQsecACzcEVf+QoAWI7XO+EJbwEJKN7wDKm7NXyLFtAb0pBSUQpZpAIvn9hLzzzBvcF07zCHoQQlYBcJj2XoEegrkSEmw8ov8YEzgGAZH+ogB8wp4hXKkJMwkEGMX/wyGL/8BS1ocQpYJAwXs9CFMv+S8QxrXEMb55hHp+ZxjeloozrWkYYxqqG/XQDDF7nQhS5qEYtamHMVo1DnKmqxi2ns4x/7oIc8ZriLWAQjGL7gRByC4AIeLmQiXZTCEOfjhCIeMYlX6AJGmsjEB0GRWlLkwkSvaDgoPsuLX5TiFs4wB8vl5BCJcM2efAM0NmJiKHagQx2aAAQb5IETn/jEKO74rlOJQAR+LECPZNQvR/pOAAEgwALIMrxFBlUBDCiAAUIgB0OEghalKJJcHIaXvPDFZ578ZPcKY5hLkJISVWJEx1a5uVUaIq2d8ZJn0FUHzvCBE8qIRjKUUYx8EiOfAFRYwkiRM2QKMBjLqMY0qAH/wXPQw5rUuWZ1rmOLYigjF6qIhS1eMQsDWnYWrniFKFTxili4CZ7pIVUygBEMXOS1F4a4wQ1ckIIeIoE+WDjiEGNSN7qJIbe55ZsTHMrbJwIutv2pKBWeQEUrVsQ/FNEoEN22hcl5tA6Y44NOHsEtwHiiMJNIBCFaVgf9uGsVn8gDHygxitmZLaesUwqO0FKWP94LqMFbJAF8VwCkIi8FCkARwXxgCErUpRWvSJIrloTVPWmvk9vThGHydIkHi5Ux4ntElhDRmEWwMq2DMMQh2LoZ+YnGELGIRjSMIQxfCDOvxCQGMRCYm9ywohWzkEUvlNEMaVBDG5JCxzYadU1o/1jnFrdARjFqIYtb8FUWrihmUOTSCle4SRrzCJV2jJGLV5RCXJ5YQw66PAMlICG2XaTttGxFtyzoVgxjGMPeKOLbvY0EisIFHBWv6DbEZVEmA20uFeqm5jOwVLqYI+MirAuJQzsiEYOwQx6a0AJ3STYpInDdu/JwqgfolHUfcACOfIe8AdwuR/06wCLJMgAFHOCPA2iAAxSgAOIp4AM2EEFMS+GKVMiiqnWR2MT4tNWtCgasDx52hCVcJQpriX3qM0SXPDMaPtBBD4LIAyOCIYyaAePEvfgfMHMGY1b45i6t8AWgqqMNdKCDHteUxjSu0VhjugIZvWCSJlA6CUgk4v8QZcrJIyhxDHSISjuj0KMImrADIABhBy8AAdrCjAQvEoGgBrWVrNCs2zW/2aFxBtxEoHjnKQ4Ooxhx3EbdhvAgBOEKYijDGYJAhJWvQQ4yB0ROdMJd0sTBbHmgaVLWa4MwOCUMNpg168yWIkcKdSpe0dEiaXRqBSQgAcjjgAKMOrxYZ9oHjKjeK1Jxa4jhpddZ1WrPNCFss0M4fOFrzIWVndaTmUwzstyDHPJQuWeLwhaSMMYxcuELXfQi8LcA4C904xu9kCIUvJgFMJKxwWtQkx7bcDc0fjyNKmThBmegRR1C4IIQhOADG7BAAyLQgAMwoAEfCEIehrENUcnDGsb/SEYu4hCCF3QZ9ynYAJjDLAQhuO1ZF+kiFiyuHzUz0QvK9+3Goej850Mfio4DORUQ/oMfuBwLYrgBEFqF5jKUATWXy9whpp3zpszUBxtYuAU28IAPhGF+Pph1C8IgglSn2gCmFp6/ADnUrPxRAVzAfZFFA1jAq6GFArDOHmEaH4QCkVDVrl0Vk2TV2JkdJVwC2qWd2jWGY5gPhi3b250MmHyGzOUBS+kBHRjCJ8QCCwHDLgBePukC9PyCWyAYKfzC9OBCLQzDXFHDOYiKNVkDkFEeA1gA6o0BKbwAAzgAAzgh1EVABCjABaRAD+yBIRyDNZiHPABZNCgDLugBDyjc/wu8gAt8QO/hB/DFRHJ1URZkwRjklsqxWcb9FnD1xxdA30xE3/O5oeRsgdsMQSCi3BEd0QvgwA10GRBIwRXMwRyMXystgiEgBa19QieEwQbAAA3AAO6xzgucARnsURy0iB+lmg3YQQiomiHhi40QgABAXdQhzwU0gAIETAGkyIpkHR90AthNYNg1iYKV3SVgggaCFQcyBoWlUmSoVc2xFc0BQt3lwenswWlwAjIgwzMkgy8E3l0F3orRwsR4Ai38AiiEgii8QjFEw9GgRz3MAzVcR7tBwwa4gAV83iFwXgvcAMOBAAiogAqkAAfogB0MAiUow9ach2I5wzL8whqsgf8YSMEPSMENREEUCAEQhJkQ0UqBDFRDpJkY0CETBUtIpoHz4eEePp8V+eFzqeRzSZEbdtEQdBQbNGIjjgEbSNcgbA5jCMKp1JEktMAUZkAKpAAQPAADjN4GhEALGALt3GIeqA8f2ICq2Y7AEIAtFo+ruZrxFACmrUjPPUBTMAKT6MVViV1ffNLFAMYlGMZhWEnHlI/HIMLbaUYzztJ0jcnp2IEeMAIykFg0HEMxsFhgCmbOhA4x8IJcBM0vRAM2yAN63EM9yMM2VQcMwEAP1EEW/AAk8AIg2AAbwMAMzAAM6AAMVOEdDAIjJAM3rOM+fMM5dEcvyEEUyMEaXN8PTCT/REgERkLLQZ1ZR86hQy0f3/wKsPxKSd7hF5QkcppkFXHBSjrnH7rN4zjXGbCBTLLUG87BFW7OYjCCIKCJJFCCCDBABqDADKSAELRAC1SBCaQACHxAFDTB6rCODSiCJPKBUyTFWSCSUA2S8WDlAQjVV7AOra3XV7oOgjlJgm4PsKWlMBKGWlLJsZFPoUVGiXjGyXyJM8JVXZ4OH4iCMuySQgIQi/nSh/DCiZ4oi4kOX4CCYmKDeTwmPWSDo0jDDFCBG/CAGEZBJPDCICBBFcyAFXCBDnheFZAIIxQkeqQHNYjDNkSDJIRBFIDiDzRBE0wkRkyIHvaHG7qhmq0Zximf/xfsTZgun5h2QXEiZ5oqJ3KmAR6mwZv+jXISznE1pxnY6Z2umeN0Ech1FBpYZx2s2S1pTiRQAiNcAihQAh/Ajg18wAz0AA24ABo4QQ7YQXuCwAXsIwiE3qRRgiLcp1PATlJ4xX7KiFQIgC0CaI4cwALmQYH61yJ4kln+2lkGRvcARpQ4WIQemypliMdkyQjGHV3SHGiwzOnogSKgQlwhwy9oQiR4gmH+RG742p4cWuZgwinsQjJoYafQAzpQgzM0QzQ4gRv8qBtYSBhYwmYiAV7qwRXIQU4gAiU4Q2OmRztAgzZgAzDEQRjIQT9dQRTcgH44S/S9YZd6KRx2AZkqrP8akGkXvGmbqinEqilNPOzEzilzbsGd4ukY6CkWrKTknIGfzgFLNeJblRGhBgdsoJMo5EELsIEbVEFAfkEPVGoKrMAKnIAJZMAFOMAHGAInxM7syE68LOX9lUUrIhKMiFrSfYWKWFqBhoEhMAL3UO2CoeXVRsmDZYza7apj8CqGmUywegnNfViZFIUdiMZOcgIx1QEI6EAlbMKh4VsmJEIiZAK+VUIm4IEdQIInmAIyKIM1QBA1bYM0OMMzZA4kEEIiaMKhLQIrEIMnbAgoDIZvsMItVAPXhMo2NMM0RAMlhMEakMEahMEVeFFI9E2DIMiwTIHF5daalQGYkqkaMKz/F9Tu8j1s7uouce4uxPYHc1aRGTzXl8KhGJxZFqzky40BdX6UHYiRTpAVJXCCKODCL8hGMNwCnshBGYjBHnAEHaTADNCADKwAC6xABXDABtCaHQHtTMUOpTFCGDjd8PwOIvlO8OTIUohAGCjFgJKXs/7F1WLtlKzlYQybWnItx3SgY8AlZVQGho5tTnzYabDUGuhBHkwCKNjJJDwBHgRCJZBCIPwBHnhwIBQCHtzBHzSCCP8BIWACbSiDNFxDpgyhMwTFT6DoidICMSxD6PCCYdLCif5CMWCDks7DNCTDMfhCGDDxFXBs8VVBsOgNsfQu+FnxFZdBwtpumKqBFitf/+32ru6K5HBWLOAALxcI7xZ0pPFyKUtSQRBgwfKObLZkS0hF7yVk2S/kE20swzKcgiL8gBywwRfYQQs4KvmyAAuYAMN9wAe0QB5IwifUwih8QuzES6fmASoSDyIRQKriS1e0S1KoyFc6JSXgScZkrdYOYyrrqmJYwgYmsJV4rSqRDJegDNl+ScvkJRmIQf0Mgh4omhu0wR2IcCPcwRvcAR6oMB68wR8UQhvYgWk6Aij0QjE43gzz2DQ0Qw4H8f+cKDIsAzH0AjEUkzgSwzFwQzztQ+wdQzBcQsyQwRygQRU8AeJ8QRrwDRmQwe5isRUv7xffrphyMe16QcWGMbCEsf+c3lkVZawZ5BZusXEfOlfKqVnMSVcd64QZUcLP2IkeF4M1KsNf2kInGEIU7IELzMARqPQR1IBQpsALIEF6toAgeAIqoMIn3BHQ1uce/eQh1S9/4g7RLcUDhAEfLEJPcO0rXwJiHDApJXD4kJKxRQLXHuMxIlstH0KXRDCYjIkciAEVDPMdvOwdELIdfEEboMEwb0IhjPAfVMIf2AQh6AUknEIwFE27bYM1TcMvcTO4ANMyRMOyygIu0EJsDINqjpY1HIMt6IENrEETxC6B5C6Z6nNIhqRu9fMZ0C5BJ99mM2waoEEalMHDDicZI/Roj7bEfsEZm8EZOLSfRXQWOJf/GQiBfqCZR+VltgyC5mgIJgQJK/RCMAAuiBL3ss6ODdwADuBAG4ABE5gAac6AHfTAEODAGESBHlzCKGj3KnBCpe0RHbwAVAwAAbSie0nFUOsvvESCYDz1VD8118otoVYJx1B1W7bdlmR1ZtzyZ4wJGWRBD/XAHySCHSxBkL6BFSC4G+BBJrDCH9hBIIgwENSBG4zUIGCCOPJlu1HTOZgU4gXJnlTVLFjjKIiCJ5SCKeTCA6UHPR0DJ/jAC6wB7ZL2FKSBPtu4PjNsE4UpGXQBjyesFwv0mFL2GNw4Q+pz8q0c+K1ZyJ6Ba5sBxja0c9qpnRWXEtwHjZvrTWD0ISCC/yNwy8/ARjDQRjEcwzEQ9xdegiL4QAhwAAd0QAWUQARwAA8wHO+lQCOHASN8gip0933OX8sqhf7piCEN9QLygSAwAiVYQsaspSsXsCu/t30bmzHK8tciwq+ajPpo6CwNK4dmCyQ4wh34ARjggR+Y+h3cQeaIMIT/wR8Egh04QiBAQlDMzFwdh3kcBibcW6MfhtlNbz7x+UytwryuODckg+q0gGdz9o3feHCOqRfzjZkGp7RTNiiGgT5fu40rLBlc8ZI3uZND+XOqJJU/QUv8SnXaRFFgzm6L1BllWXDbNZkPd0jfFSeQAZu7eQlkAAf0gAu0VhWQYQuEXp6XUqXlQf8c6FT+mVrTFjqm5ZRTGsIjDGMBU4nGtHIsS3rGtyUDo0+WZJhnDMKmxxJozFIdODgeNIIfwIEfNAIJF0LmAEImbEIjVEIjFMId4BshdA4muEIxLIM1kEc9OAYkRAIkLHrnsGgroIIo1AIw0IY4CcM0nIPXxN4unEqyqwGzXwGz27jeTHsXh6mQA/mPK6wXcD2zAzm3xy7LfXuTr1m4P2dKWlG5h4TumuvZYk5IaYgmBI0syML1kvkxEJmYF8MtUIIceF4KuAAMfAGBOMENRGQOSEEWDDwjxEu8IPyq+hGKLEXnD2hO7S95MYIkIMZ7m359a3zqu2X5XLrbQbDIi0n/sWKLGxxzErxBI7BCy8v8JlRCIWzCJpBCJvT+7w9CIliCJoRCLxxDNAQ9XNwwigbxtgXDOPtCtkEWNl6DO1D9k/JRCJCB2d/41p+91yvs2H8xQJ9/2Rc5Qxr599su7a5Bk4Nf26PBtzOn8N6pSuK/azMnFYgExAJEGjZs3BR0YwfhHkGHGEW61MnTJ1GvbPkKNqxYxmHBihHDxcnQDxtS3KThsQdLHSl07Oxp0ULPJUE++EjKI+JBzgcfHDBgcMCAgQciiPqwkYfPIk2aJlma9PRpJKlSoU6lOslqVq1aHz1itAgsorCGyBoiNGgQILWA+CjkA2jPHj12ABVqAwcP/xg/cOBsIpUpU6BCjRr9CQSpUKA/dxxNwhQq1zFr8ur9skwMc2bMyIIFQ1YMGDCLyqCd89Zvn7xjeWzY+EAGNuw1sWnH9nLbixo1uHnj3p17t27hum/DDhOGzBrly4erWcPmTHQ0089QP/PlCxcz27l3j36GS3guU8hrwZ6m5MCBbljOscNnEMNIlCQ9FJVqli7LnYttLNb5Fk8UIYOOLwDZwQ0u6GKjhRsMAUWQD0RoTYQWRAjhgw90OuCAoYo6LgxBQCnFE0802eoRSFRckcUWreoKRhgj6YoRRmiscRFEDkkkER0PIQTIIAcRZC22iIyLDTvawOONJGqogQm7ev+w4okVjqDhiDsGwUMwPP4oxA1AJDHFmGrkoecXzYjJiE1k3NRoo2GOSeYadv6hh5tRjMJpuT5nq02534TzoovbiOOti0J9a0432vyUYw1G2ZBDPTams3S6NNII77tOz+hOvC/S0EILTQUqSSD12MviDDr0AMQQRBgxZJH5OgHllFZw4S8jY4pRRhlkfqGEjzUOGQMhLgg544UWDNEkjgsfcMCBl2xowrWcOPTQBx/iOE6RUmAJBRRPsJoxRkfUVVHddt1VVyqvapyX3nnlxVFHRPQ9hN9+gRySyCLh2mMMKnoI5A0oashAhkKg6AGGNpI4Aow3BrvjjoTv+OOgSEL/8SyabTL7DJll3DyG5GLcXNNNZJjRpp165HmGDx9u0DA5P5eLjTlGDR0Ut0R5Y1S3PuU4uk9JK610OjQ0xa7pqM8Y47sqRNWU1FQLMtXUgqS4oow56lBIED0EMUSR+TTxBJZeeuH1V2BN7gWkMcZgYwxCXGjBh0gmwfaFDSywoIXWrojCBwtz6rbbPBw3hJJTaDmlFFAooSSSGml8l/N36/0KrNBFz1GsHPvd199DDBGE9daH3GNgOlpt5A4aZDChBhlqGOyNImpggYke/mACj9rfaASPL/SQ5JZiosGm5c+UiQaZYFWOvuVijmEGnXrwzCUObHNKjufZlHNUDuCI/yO6t96Idu5PnSNVgw3hBppjjqWbfvoLTNHAtDoDQcN5sHYqg5SKa2yYgxCucAUxhE0PeohDHfiwkEc0hRSs0FUvMlI9YCljGcH6BS0uEQcb8MEGfMMEJG7wghCk4AIX4AEWQuCCH5ChW0RxXBgcpwhDMKITsJgc5TCBua/gqHPuqpG6HhG6eoVOX1HUUax81C8rAukQaQFE61g3pEHATi522EIM7tAI3R3hCEwwo+7AAAYm/MEKVvASFAIxgz1gAhOp6MX0fsGLX/QCF72YxStwAQtDnuIUvKDFJz7xC2GMAhjU2IY8sCEJPtQBDU3wgfzWAKk+weZ97/tZKIvWyf+jIa2T8xsO/uYQHfVkaiCacgOm/IepNFzNVJUqCEHWM8s0zIEOwQxmHeqgh7jAil+MgIQlMOEJUrTiFm/jiMrkZjJkiEIRfGjBB34wCUCEgFoKOIAFXKADF1hgA63pFg+P47g8KIIS4qJciYoYr0c4ghFJhATn7gW60UnRR2T5ESEOUUV+BYkQZVkd68iiFrTEhQ5W+MMb8gIHNMogAxI4IxTwcoc2YOwPgPEEKDRBC2IgoxOauMRSLucJTCAic2VRhCJGsYthMGMa20AHN4yhCD3UwQ1B2KT8ULkzUg4nN6MkpSlP6cmjNUeB+HOlAJ2WQEudgapoiA52uPqFUvX/cpaz5KWmgEkH/MlBmHQoploWkghHLFMTI3IFLnRhEWoCC2WcKYU242AJPbRgDS1ggAVSYIUUuMEFSpBDGLrFBz64s4edaAUsWlE5E10CXV5ZRBI597nRfSWK/DKdWRCKxYEOAkgKBRjrtngkQBATEndAYxGO8IdGQMEEMvBDEsDApUA04reVYAUpVKQJVvCCGF1JBCSeAolEAGIOZevhJ4DhjGlcYxvXuAY3sDGKtmAyCE3gpJ9ypr5DmddQ5l2qKeVXP/spkJZXpU7/2CCQM5QBq9Apw373a6qsgbW+p6ovG9QqTGLWwcDGBARqD7GIC2LiVqUohSt0MU2UHQPD/58JRiko4Qk+iEAQLdhADnjAhCO0AQRaMBtSZooUPigiD4w4BSxcUYpQXBazNMqREpPIiEQsYl5h0ReQQRvF0R7UiwhFi0K7KIi0vIV1bxkbG5bwBjDcgQlwYAUr/pAEOCAPDIIpxJcSkYm3VqISjvAELXhxCEs417mOsAQhHCsJSCbjuuSgRjaooY1tYEMZPt1DHbYAhB/ITzbnkw1SFzWo9R21aIBKWnB0k99LUWe+s/xCdPA7EE+dgWuaWlqA0VMQlhw4ghE8cDGPueQGP1gTEY4FLuzKpv6ojCOieHFrqjCDGFihCkiQCx8u8QlOSGKm2SQ2LSZ345ReAnM6Rv9Eu3yciHzi89o+JvLnCoo6hRritGdBy1mcnNCFcvHJW3SsIN4yF8PcAS+EMQweklCIvHzJuYmohL737YhKeIIVifiDmyFRK0lwohbDkMaZ+tEPb5TDG+LwhjasYY1RTJAOaACCEIBwvp2ZT9GBAlqjBYXeUNYG5ULDTagT2DVUhZqXow6wLl9OEJbYQa12UHUxV12Hlgz7bK+WCiXsk4qKBGNNGukgMnzxCT7EgQ3mvMEOQnS2ujKSkZTIgyBC0YtbnMLZKrVEvGpkbXUxwshAFp1n9UVF1fEh1XSooCDkAju0eLGL524dW9XiWMcq2A6bKMQb+AIGKNyBS35oRCH/QIpmT2SiELwQfCPKHPCE1ogStThGNbhxpn30Ix7xMIc5wvEOdXBXGXwIgxzMIIYfSEEI5M2Z/BjdvqEBrTm3SRTKayO037A8lzOvLwJzKVZVbU3U66GDLwmCEDv4XC6oXvUw9SCHPOhh7g2O1SMowYlO3GcWvSAGR5BxDGN8UBnB8MQeroAtH7xTEZKoxSo4wchO2EQRepRFKm6s0ks4ZUaqbdtIRyxwBMjwSXQQQe+4iIvIghD2jq1Wq3Xeou9gh0j8zmwEgS72APHA4A+K5wNtqxLwoBAqIRDsgEcCoRI2YfEKAxJIgd0kYRXKRB5qsAbpAQfpoR7qYR/c4R6y/wEbrCEWfCAM4oAIiKAJkvCTEg3keuY3fGNRlEqpDqULYgNEkCM2EkULu+CWvqAKEIj4TAW/wjBVkq8g8CfADEINDcL5nO+niOn5EKLnkiMOrm/uKohWGIHoOiEVXqGupkkZniEangFYhKUVJEEPfCD+JEEVgGEU6u8TLsGHOuEWcGH/QqEToM0SnAIBSQeKpAhfPlEUo4gsWufczkItjmmL1sLv/I4tsA8uMBAW98AOquBLbnFj/sAP8AAPGoEUNiETBM7euKQRAKMSQCEXysQaOq975iEfugcHb7Ae2gFPsKEaFMEHyOAKfiAJk3D2eAZQQOk3VO7RynE3yMA50v8xUtbAC7QxDK4AC2GjgbYwUW5pVKagVMhQDMTgDMgQ5owvfxTIDeZgIAXS5pyv53zO5+YCDu3gT6wvgp7u+s6mViihE0KhFAKJ/KJhGToyeoqhFbqv/kaBJEfhE+7PECLBE7zOFVKhXMQOK/CpR2TFn6RIyNLuyFSnLBiKydbii+ICKP+uFR0rFVMN+yoI7mhRYtqgEjKhEhajeAphywIhEzahEhDDMASjEdCsEmwQB+eBHvZBLMWyHtBhG7ZhB+kBG6zRF/IgDNYAq5QDq8wRvchAvcpRvXZm9hSNDOLRLsmAHunRUNJg93KG98rgqqrDOuArOo7GrCYFDeWAlfL/B5gQTK2KKdXkwiiNCe6MKSJNsaAewW9WyhNC4RSiiT9a5oNUphh8YRWMjRNGkhOyKRJAoRdoARZOgRRMRBMwwSn26a0cYSsigV2Ac5/Qbsii6GxWpxXnIoJYIpiO5ltW70+OIw6uMw7IIDuPIwqaIAquwKzwxw16IAOg4Lh4oTBCMIOKhzDsrRAGIzEIIxDaYSzDsgf/4R9Qox7mQR7QwQatIRmKQRKQAy5B7TtyD9Jw7330kveuUPcEk1BULqkIBRx5TwzGIAvG4H8sBb4m5WjO4EMpRUSBiZUu8zIxczM3s+48cw+gLOiEbhIeYkRaYRZs4W2WThkwLMOMARhq/wHrTvIiW4EWWuEUXtI3saIr1MXaboTIHKyJmsjBhszHFJDJGAoQXgUowcgogynV6kAOtDMOIDIPHJMOIKUMMCkLsoALZuAAMuAPflHM3jMRAkEwmrIR/OAPdNEwBiMQ6GEe0AEd1CEdxKEcGm4fzoEbEhUbuKEaAPQ1GYsMpOM7yqALBqVQEvQJ36dBrfAKA9NTPZX3amMfHwi/oiN/vkO/oiMN/iesBpI9CiIhfU7nEMKYaLElarVWNfMtBqEs+EVW5oMTSvMTUCE/LkJ7jMEYdFRZNSIYdEEWUCEVwO6yMGdGwKIrgEyzFAERtNWHVGdbxaJfEqHbfGQRVOfu0P+CdVr07rioM/ngVudisSAlmM5ADIRACL6DCHDgBWCgABggBuoUEuxgMQiBBDNhY4ALT8WMThthHtIhHdqhHb4hG7KhHc7BP60xGYRBGGzKF2JBErpFMbXKbsZADICDUO6y9m6P0VDuODi1ZT8VZrWwgWa2gfrSOEj1vkpVv/hrv6qAC9CgIKZjDdWwrA5M54zS+eouSzVTFbdodcANyID1IULBFPzQIoYBa7EWWZMVw0DDFl6hasHu2SSBRlSnX6DIbJmsFFcHyVDLEHiVX87tbd+WSMoGM/+OmPSAJeiVXq9ADsbAS4PgBlrAhoKgcGooBAYABjYBKhVjY7zEMD7/EA7QTDAEI08L4R36wR28IRvI4RywyxqVQRhigSR9wRd+IRh+QZtc4NOmpgxsL1Nrj9LUhzdQrmZjg2a7wAl2l3d3Vwl+F3iVYAtplmaN4x2vADb2i9OUtwz2sQxEZdQuhSAMQoHSCkVVVEU1MzOhzGnJQhEaYj4e4hOq1hbqShiGAVm11hg2dhVUwRREARVKwdigbUaqVbTA4or+BS0WjEiAZIvSIig7M9XkYIL01m7O4AqOMAh+4AeMwgZuoIVcIAdaYg7K4ArO4B378grWQBC2bhH2aUeAsTCK57cYDxICwQ/8gE7f8z3xdPHiATXO4c+soRqq4Rh2oX1jIZre/4QYQKFBXIBTvsMMxuB1fS9oFAUK1etneIMvtZF4abZ3ozh4gXd4nxh5+/J4k5dnS1UMGkh58yuqQLRDSxSt0KrAXCVFjdKxlHYzi8nvKJJWHqE+IEIUTCEWdCE00BdZ2ZckRaE0O4ETLkESMqdWQid/xW1I4EKRB20OyLQO5mANjoMOGKtbbCAEMOQlPmADNuADtilDXsIHmoAM6mAhxO0R1gYUUpkUVpkVmI3NeIEXAm5JAgFjeNEPxswq4YCj9DQQWCETejETzjIIpcEZdHQY8jgjiMGaeEEPPuAFPiA8uGNqiDhCJ3QLg+YJk3jkqtOKiRd4fXeKp9gJaDYKyv+5m7PAefeLajplDKQAC0g1UplKnkH0aMY0D8LU+qzv+tK4LeJCgLuUDsLUcbCPdQg6jruvE8b3ji8CI5rVFlBBFIA0kCVhEZ4WEQCBEMo1yvQ2O7UzDIgglBnHWlrgkl8CQz4gDDTJBoiiQn5AD+RDKpqpREYkVwzJpg3JlWE5p2EZloWIFNTiDY5gBYqACcCAMFaQGFhB8fAADnoLD5xShfGAhpVhGHZhF3ShroDBWPsD6X6BFTDBBUIAnaiACrZgC4aYZO1SQh80vY74mhntfI6jm2k2nH+XB3ggeHmgCcZ5rolXCL7mgRTzDNIUQ92Z08igDPoEOzs6TBf7OiH/C7KwLzN1VdWESTqvEyIjKEzdWBAq8hI8oRRe4Rau1hdsYRZSAUgFmRGyyXzI4AWioPqIoIH3JENwYkNyQgTeLyLBTVYm4VYwUsJmTIiYTZGECKcDyW0AyRZs4RZc2bmdmxUMqZU1ARDsAMuYoAZOoAYopqnf4Lj+AA52sakrBoXplDOw2iLIrxCXgRh64RRYoVwIgR/tdWTrewzYUQvZ+rxmVwvVAIkjtDa6WR6vQPecIHidAK+74Hdllnxqdma1UR5/AAt+4AbGwF6HwAVwQMNzAIKx4AZC4AYeOMRTKMRfwlpaI4VQ3AYqecW9MwrCgGQdaAyIIAgWmMJd4IFb/8NaGCdxCqc1bkCUt+57u4+RYjOQlS0PKtkHROADDABDDOAAPuAGltw6eejFGEESspzI6xgVXuEV+tAVwhwWvvwVUEEVYuHMvfzLTeF9RSEWTIEkTcF9VcF0fWEWZIGyUrlcNnESEiEt6qANACF4OvAIeNGiiuB4OOpOK+YNsowXmeQN/EAXbOEXOqgjPbKPPMESEuERnGIPLhQIcoCw67tkI1RRKpXRkMr3/rtQjPd4b9ebddfAp3gHlGDWE8UJcBfWkZd4xaDG25msh4AKgAAI0tRegWALpGAIpIDZsyAH7DUIEpiBb4AbBReCudHFu7H9apzCSzxDvn0DqMUBdP+C3H2C3Hcit4Ucy7NcEugj2aIsD2glEgSh7dQmFDDSFFAh370cFVAhFv4dzVVB4GNh/gTefeVcFdp3FRZ+FUZB4Bl+FWohNHYBGDS2P4bBF25BFmaBGDChDKTAPaybC1JABkwsBmTgCGpAhcGgBsAAL1hA0aGAYvDADygGDJKgqKHA5fEAGK7HI4nBq0nKucZsbRKBXokAC95ZDNB5H2HjU2k3aNz6ZNna1YvXiedR1sHZrneg1rn+d3P96mf2O2ljH9s5OjR0DsbglFbNDPaAC9qADQuiCqgAC7bgbuxVCLr9BSD4Bp49CoBgB5qghUw6BDbgJ3xi3BkAyoOC8Rv/v/GHonEM4eDqj8tVocxfQRa8fONnwRVuIRVozBVgQRZk4RZmYRYQfhX+feFJ0uAhnuFrAfZzgeIrXhi2FsOSIRmUgRmc4RmqQRqkwRqiQRqqwRjsHBda4atxAAasoAeCh2JqQAV8RwaKAA4C4Qh4CwyOoAgK4ZehYBePQOfbiLd4q6mhIGGihxhimRa++ipLMDH6/AyIQA5c7wf2kenFwOmv+UHze//pkQpbHSDWkAkThgyZKwgRHrzSxUmXhk6USJxIUWLCi1EuKrxy5gwWOnLozJEzRs6ck3Tq1HHjhgsall+q8EDCA0iOFy9uvmjxIUSIFj4/POj54YMDoUOL/35gwOBBCBE2oobJk4ePIEOLJFGidMlTqFKvXMFy9UoWLl1nde3KxTZWrVxu39ZaVcttrFV069aai/ftrr/AhAkeZqxwMmbMDiN2Ng3bNcePp1mbbG2aZcmSpUmLZizXL1qgIbkAUeMIjSQsUCQB86YGlBVHoMApcoTFmyJg/FSCAyZJEihMwMBhAqVIcDh4eMNBFoxWKU+TLFXKBGlTpkKNCv2BBGiMGDFBfhARM6b8dy1avDzs4sWLGvXr47dvr+a9e/vzyQg0yP+gQYYQrefEgA4pQeCATTRxxQ43ZNTEDhA2EQWDEt5goQtSBIEFET8EYeENPoDoYQguuNBCCv8mbqCiig60+MCLTT0lwosPtNBEHHJUxYcikUhySSedeFLKKaeIRUsvuPTSyy9M/hKML1BGGeVfVP7F1pW5rLUWW1QCs4tghRmTzGHNQAPNNNdcs82a26DDjTxwzoPONtdMZtk18tBTzzrn0ENnmtRQcxma00hTzTG51NILaI7gYIIGJ7xBgx9+1MBCEnCgQAMNscWG6RFghNpbbLy9QSkTeDQCx6q4+QHHKdAlAokjs1YCSiaJBPJHIIUM0tEY4wVBRHnmiaHFFPGxNx988t1XX33LPrvGfv3pxx970MLnEHtNRNSERAm+4NMLFuJkLlA/9QRUCyUC5UBTNCZlwAP/DBxgALwvfmBDE2HEseMijEjSSShfndIKLUk2GQwxDDNcDDHFFBNMMcMEY/HFFgsGjC/AdOxxloAJJnJhx4yZjDPOSDMZNm++CefL9OhZz8z71FPzPjjnXHM987CZpjbz2HyPOu2ccw6b2qSptDXVJLNLLbbgQsskQDDRwQkSFKEBbjSswEJpmm4Kaqga4PEGGEUk4Ydsq8FB6Rurws2bb7MmMsl1hciaCSF3tBFIJYXgQcXgOXB4w3fkiZHF4smu157jDy1LH37OVsvftGRE/riAD+7w4IM47YBTE+L6tEGLRZ3eYosMsO4AjQfUyG8cgihiCFaSREJJJ6CU4vvB/7gE34vFv/hysfEYJz/M8sMIw7zzzUPPfJjHlHyYM9BIc6Y1j7n8cp4xhw/+zDbrbH7O/+yT/j/st59+PX5iI7+a6NCMM8/yyHm0NtqgU2c0wKiFL3ABC038AAgx6EAEFlCDJNAgAzM4ggxkcIQipI0GRTAbFEBlNlexpghnA0N2QmU2uPUGDpCYFXYakYlApPAPf8BDJSrRhjYsYQlPEIIQfvCDxSFODAQhgxgs958hlqEMYjgiGcpwuf5gzlpQhCJCnAC6BDXhBjtpgRZ5kpShxKsnP2mBCFrgg4JURRCLSKMlMOEJUJCiFAdDmJKWREcnPal4UAJGMKInMmEExv9jHRNZIPtIGMOM6RnRqMbKvPe98OlpZ+SLJM76QUnztY+SmMSk+zb5j0z243304MY25LeNeQStfDijB/joYUp5vMkanUELLUAxiTrggAMUWAAGoLApFMCAVzDwwxHwgKm31eANgaghKzYBBijkxg/BeUPbhOMHPLCGOtapziYKkQnrYKcSjQgEDEaDIhO5ACclsoEPohKVD32IXeyygTm16JN2haAoIsinCJTCz6LEC0ZNqVfsaLTPfJIxDnkQRO20cglOeKUUpjBFKl5BUYrKAhazuIVGbSGLWLwiFm6xhS1ASlKQ1gUvfXkLlroUGGGEaUzMKJM00KQ0NbXpZab/zGnM4MfKnM7jHvvox/nUd0lK4sN9mIyHJ5dKSaQmFR/7oAc6sjENM5lpGuSoxz3gYY+ibSNpgrKMK52mi0V5Ag3OlIEKJCgDKKQKO9j5AzE24Uw4BGJVpSnVJhrBGjicza2isiavkvOGGWbCsOBsRCNmCM5A4KFEkI2sibRoA8pusQWVXZdPwpjZzW5Rn6DdYlR8QFof8GsqerCKIRCxCN01NEifIBhETYGKiVIUpLLoaCxUwVtV4OUuKOXtb1FKXJRy6S8iKyRMm+GMZ8x0Mo9Z0znQMQ96rMOR7cjuPbS73ex69x7gDW932xFeTjo1k0qlZDzWy1SmcjKT9nif//+qetVsqAMenYSHOuihDWokTTLyeIYfg/ELUIxBBRkEwxGYcIQ3QCEQm8BDG/4ggztUghiZAJVyRiWqELrND4E4Gx760AdT+eEOKD7sdDJBncRCohDTacQdcIADLNoARFgkFzvZednLZla0N+DhD8KwBoSqVhEA6xGQPBFbiNY2FamQxSykPAtXWNnKs5hFLJ6sit12GaS/3QtKR0FmMhcXZLsYZCGNEdMybU9p/NuG0eZ8jnXYOR3pYIc79swOdrzjHexQhzr6rGd3wOPQlDy0ouGBj0Y7+tFHhXSj2Tdp81r60uw7n3n30Y5shNUy1EjHJ/uh1HuQg3+CmkzzCP9MCjK44AS0wVQRaFADBeNhBcZZQQ2Y0AYZI8dtcDvC2pJAqmb+jQluwwMeBvsGPPxhhtlcbAohEU5SZOIPXABCh5pAWmHdIAdCJgJB+hUHOughtVdJ8iUwoYk2+u4UrGBFK2BB71kgTHjBw8UtRMpvvZSULSfdi8BT+ha6HHeQLjVG9ZLRDDdvD7o2ZRM5yPGNb4BDHHjmc5/NYQ5x6Lkd7mhHn8fhDnP8OR7vYK9QFU3JPRua5ZJ2tPtkPupOdhIf8cBHzf/BaEhj+pPtU5/QZ57pe5wjG9cAazbAgV9S90PP6giUNZhhDOcF4xR6CIEVYF2DFRQnEL2hAROYIHb/KNzBbBN2FR788AYTg6EQvBFOqiqRKjBoQALHdFsMF7vXQhSC2uFUrDe5kNpBHEIRighYJNYYpILFGzSg4cUveMGLJTXpF0maYy90gRbOe57zwdOFLVSKpZWCrKUjM8xingtdbLgJTqqcR/6u21NWSrW64cUZPuDRjnS4vOQc3zM/+OEOcIDjHOlAfjrKIfLms0PkRJuHd7O7D/DirLxLXW961avU9ab8+yhnb3rTN1Tz3QPn7+A+PPrhDkC73Bzj8Ib8vZENTye9/uBoh84p+Y7iU2Mb0CAYEeMKg+ACHKACLEACLFBBSTBDrlEJULBrbxBDgdAIeNBgcIAdzeZY/5vwByYEBmu3KieQAARAAs/kgX+XHZWwCY1VCBUIOIFACpRHeUyyMA1zgziYg8nzJBuDPILBMYC0MWkWGIW0cNeTSIrEMt/TSHkyPnoiM/ajM+4zVO1jD1ZIatqXVNq3XvzwDuQnXvggaGKoDnhGNOQFVDljfdUHXjiHXtvHVFsofnH4D+I1feCAZ3iIZ+LAcR0nDuJQDn44f/NXDuWQDupwDvyjDeSQDdpgiEeFSewADgBoDLswDMUgC4JwAzCQARKga7G2KRZoV9L0Vm4lY8SUG3AABdkBYq4iTawhYhlWBJRSTX7wB23gbHiAHYEQCHegK33TBhb2Czi4RxdDMf8Pk4MNczHMQxhrZoQoEw2GQhmKZA1K6ISRJEk2k42TFFQ6o43oY15NhWngaHM1p0nvJY7tE2mHpnPrh4Xbp3KJpmg140imhA7oQGdGI4j1lw30J4jzx4inpg1LN3GJqIinhoeHeDRyRg7nQF4400n90A7rgA3NUBjIUAyScAMucAELsAAkgALJUQRuc1cM2BuVIEw9MDZyU4qNMIvWJCqloli8AmwgdnaFcAdwMGG5iJNtkIpQ0AaewAvJ6DyEtDwXwzAWEzHLEA1IuEjc8JSMtIRLqCeN1l6jxo3nCHTlZ2mZhI5eWVTt9V7tpXLwuFSH5g7sQIjGt4/1FyjUwJb/nvaW/OiP4ECX3qCI03U0DHkOE7cNe2k063CIdrYO9ThdUNgOqYQO1rAZy7AMuKAINpACE5AAGJAEKMACNFBXpjFMDpQENXBBFCQcz3RiZzeL1QQFf1AIzUZNLamaIfgH1wYGuhJOglVXVrAFewAJoHAKwaAM0XAyz+AMVPcMHHMxxbM8y1AN2KCcTykP8vOc0kUP94BxfmIZ2gMN1EAO5NVU4Vh09NAO85AP4okz+WAPQreG4CWO9tCdQUdU7hOH2sdy8Uhqf3Zy6WeVXQmRmbR+hqYO4vCP/wiXeGk01GWP9oiP0zeGZkhn61A06tCg4kUP87hTPKM/dMImdOKW/9cgKM/ADMowDLogCpJgCFcQAhxQAhgQKl9zBEfgGw2UNkcAB0nAQmsHBb/xBpvACn/QNxO4dhVYQii2bMjUkqtiTX9ggYp1mjGqmr8BBi+ABmiQWrHAMthgDaK0MtFAMU+CMcKgDMqJDdvwJhgqZ+egDonmDlFnJtdJDX3ykBDZno5ED/mwD+I5nmmID+dXafZwVJvEnuwDVJwEn+sln5i0f+11li7He+lgfHRZl94ADnMpf+mADsmXfIiYiORQhvg4mJwqht8FD98JmFDIU3xyDuAwcW1pGVbVcKzqZq3acJoRDc+ADMNgC6PgCZ0wCXuAAymAARmAa6dxGrQBB/8NtHauEgiZAGLNJBuFEGHKpmyUcldQYHZ3IDd+kB3IoWyyuWzg5AfNtBpJAEJgwAR2MAhWwAZ5UAtVOlNwUifLWQ3F4CRS8iXMQI1qIg9pwibT1Q76mQ7UcCbXeQ3V5aaZVn7mJ17nh59Y+GdLJZZ+uknX113VxUp8KZD1V1NuCZcaa7EAialfhY8HCg7hMA4c9w6I+ntoCaqlOmf3+FVg9WnX2XCIMbM0W7M2ixhjEg3OoAzF4Auv8AmccAmSwAiHQAcxRAGYWWsYVGtgUAO1lgTI1BvDqhyy8QY1FE6UAgY0UFh4YAW8CAUmtipu41d+sBrYekJoEyoeyAXkqgf/vsA0gSFn2cAN1vAMlvgLdKQLvpAlwtAMYLoN+GpTBKp/nbQP5BBW11lKNgOxUjh0jgtU4fVyi7ZoCvte2tdo7aBf7UA0ZOio8rePa1JToqs0jLgNcOmXfsmXX0WQ5CBn+kpnctZ+8DcO41AO48AO4yAO3bC7uxuXn0Zfq/qqMosYw3uziQFTx2sy1aMMxwCipvAJl3AJW/EIkLAHXNAGJoACKIBrLFAENZCBuIY2MAoqR4AdzvSTbWB2biO1ILQJybSLxupXq+KtyAE3f2MqHRYIYHsHPVADbYAIyYkN2GOP1DAZwPAKsxAKpzBHuKBSwiANjkEn2iBd5/BTRedp/8A7DedQPuxjjrrXDzqHc/CQXu1YSddIPnEaM/eQjorWDsbHqI8aoBqrsW/JsXH2unN2iOJADqd6qt+gDT3MP/iokHPiM4ASKINCX8K7xK9KvNCAMqyKMlLcDDiLvDNrMh6qDFqcDNUzDL6gC7IgCp1ACT5yCY/gCIMAAx3QASqwKSWga23MAl7zmdW0ax70B75BbEywK39QtqsxTMnkgmdno6yRG5kwtmBXyCHkG8PBGhVkBYaADFZapfKwDdPADdGgC53ACHyACZHXC7LgF8LwDPITZ4PLp/0QdapqJmy6VZ2kcn1Kju1VfTGTUwdqNBzrlrq8yzM8wwUpxH/Jl/8Tt5cMeY9DTGfWNWfD/FWAchnBy8RNTLPQ3GbS3GbC6wzMxQzCObPKkMUe2lxafJHDoEe38ApiLAmKIAiYsAiJ4AiVcAcXcAIlMM8YsAIrMM8l4AE0cAIrQKxHoAJhtxor8HbV6jd4QAO98b0Opot30Btts3ZHiioL1nYFbbVj9wYmkAG4IQepUA3NmSaNUQ3L0AlWYTeeTAu5pRa5YAzVkHSKKA5lSriUJA5IbFXZwHvrt4VJ1Y5BtVXatblkmA48TMO7rMu9vI/0Z3wWt9Q83NSnOnEvzMPiYHx+iHE7PMxxxj9H7MzBCw3QfM1LHFPGO9YoM7NlbbzKYDLJoMX/aa3WyoAMxyAxuhALtPUJnRC00ksJpOBGpLAJbTABcHACGEABHuABGGDYX2PPCOh1K8DPR7AC2gsGrFAJR9AGzVQENpo2PykDMXB2JJStZ6NWxxQcTHBYfmDZPXkEE1ACKlADhHAJvrCUhqJIz/AwlrAHgAAIkJAIntwKU5YlwHAM3PPSeZbTM+2W0xAo4FB9mJRyRgUPaClopqoN9LePb3kNSBco9aeP/jh/YzqmBjlnQHwOMG00wTzEAdmWv7uq2EzFM/vVDWcmzPXEr4rN1hzWY02zY7LF+73Fac3WW1w91WMMy9MxvvAXdaEKoyAKds3gn+AJEA4k9MYKoOAG/xnwKBlAARpQA6zN4RpAAyqgASXAAm9cGmBQAiRAAnDXiz9ZCd77NQ3UQH+wQb+RtRkYCEkw0MJB2tUkHJxCG8J2B7wGCZ5wCsSwDMiA5MEAC6cACYMQCIOQo0ROC7+gC0Q4DMpAjXLmjp90PzMzquUjVDjTe+pgzEczZxRsj9zgJugwfeS1udYHXt5FXaYUPpxKD5hr3hWr1VqN3ElsVYB+JqpqnUmMGUlcGYV+GZqx6INynYvOlJAe6ZIe6c9Q6c/QmG8d1wW+MbqQ4Aq+4J8gCqI+6qQu6kRyClDmCq1wCrDACqRQBxxw4SSAASgqz81G4iTQNSJZAwq4Gt5rYv8qIANmUwgYlLbN5FfSFKNEmhuNsBrSxHa1dgTfWwM0UAh+wAJ+xRoWhgmT0AvLMDy98ByakAhnNx2bAAmWAApHAoSWKNzccNPaB0oxs7l5Weadqw71SF21bHt6Uue1nD+zN5hPuA4obGdGo0pxYuYZGlaA3t7MhT1SLMWBblUzdZ2BrhmAnuiNrhmKvugeH6ubgUiTXulMGZxpPeAEHgwb0xZ3wVtkJgqgHuoOHuqhTjA2Xwo2L1ut8DunHm+kMAg4AAImwKI0IAElQAMaEK5fgwIagO0y+tg10NrC0WwW1LQrQGxPTwN4QMiuwhvJIXfCVBqmIu0V1BuFJaNixwT/bVcIk4AJu0lvlJdCuZgJizUIg4AJjODJw7NHVZcM2SkO6RcP6aNK94hnQB1ohBZyQC2GDbkO8NCgd257+X6PRTymNRXoDp/fNLvNZh3xnv/5KGPpIs+Um0H60MiU1eDxk776og/gcE0xfrQLupAoXvbppQ7zZTbqn7Dgpf4JsSUKOf8VOC/8BeMKp+A7X0EKp6AJdAACMZAEI+4BKnACJ0ACbcf0RS8BNNC9s/HGc6xrwfHYNODPnkkC1H7jqfgbqzL1vpEbYEdMagMHDaZgTEBs1RQIiZAJEB5vvEAKkPDOANGokp09gBwl2gOJ1q9gxYYZEyaMGbly5vr127fO/9u5c968kUsnjhy4kOnAqRPJUeW6dSo5kpt3bpu2mdeoTcM5TRo0ns6cNWvGTCgzn0CZBR169KhRoE2VJoUKtVnRoECfRcMa7ZlPZ8+2etWq1evYZ8rMKkuG7Jgxh8KAAduVq1atVarsmjI1ahRevKL8+g0VWHApUXr/Hj786ZNgxo1LlQqcqtWpU6VAkQKl5xCkNmACeYiQAc8REyRQFIFSA84KDSxQoKhRhEUgMDVYsEiSpMZuEzSO3EYhIQMNOIGgFCkCBgwcOFCYMy9yJMkRP3COFMmNPJCf637w4PmTaJImT5gq/fmDp02gRHVI8SJUCBSkQZh6FUOmzFgyZv/U2MWLByN1VEqnHHdeIoccbRY8R8EFH8QJmpx4msqoqKD6aSikkuLvQmaSSaYpp4Ta8KmhuvLKp6S4YkYZZ85SpkUQj1nLGBuHGcatuOSia5W69OIryFRS4euvvggL7DElSQmMlFKCNAWwxgQDhbHHQlEyS1coO+UyUA6xgIMYpFsBAwkwWEGGGl5bgQTTNGjtNhpYWOGIGpSrQYYimDgiNdtksw2K6Y64IxA8kvgOjDfgoEHRIt4A4wgwsFsuOz+S4BMMPwppBJJNCiEkvdGSKASPRBJhpRIuPG2DiiAkWaaaarC5Zptz6MEHH3rmQWcbXx+k5qacpoGmKA5BRPb/Q2STFarDDz2EalkPfdrqqK0yPPGrFMt6sUVll6Xxxoje2iWuuXz8US911103SMQYU2zKT0Cp0kpSmJwySchCobfeeq3Ut5RTUtnyXk3qCIEDDtCsoYQiSsAA4hJKgA0FN1koIQOKWTiBTunAwOMN7t6oYQXkaMBuzujw2CRk6abD804wkkiuCDgUDaSQ64qg4Y0+K9mkkkpI+aMHKJiQgQU8ziMlEzfauAOKNnrgQg8+UImmmmh8ikYoZz6kca0awybbxhnD3m9Ztddmu2232242mRhBFArGZdWqESK33uK7XHPRBdwuwVXZ6668DPNLMcQWD0WxeB1XzBNPAgNF/3LL+8U8c8xDwZdKLAMuZUvOQdlDgQU6wIACCiKg4M4VwMCgAziK0GAF12qgwbQVSrDNNxqYKIQ2TUGGg+bdaOgAijuYuEOGI/CAQlLmZj5CZEjf2CQQOBoBeROfpftjk0b+CCRT35hIAo5KAvnjDjzucP+IJxzxpBWGjNmFb2FydCuiiHAE4ENsNMBwGWNsNHpbAhV4DLchEFkFxNG44FKuXPDoXHSpRS78NsEK1iIWPorFBwdnCrugwoSoyAtfRiGKIi3OcZ2AYQxlOMMZSk5zkuNX5jxxGSxdKWCUeUwrSsEKUCQCDReYwALMJAEJdGxir6NBCegUHYo1LAO4Yf9BDd5QAhnIAA9+WMFuvliI2dGABitIU/EKUQg/0CB6fvCDc3SjKTjEcTsgo04jbsaEQOTsfSHDQyO24wfrtU9keABZGwChCVK4giHDCEYAizFJSlZygAQkW9jQogwGMnBZdoORWXxiFrKQBUVokVtawgXAiPhiRxacSyxjGQtZzqWCFSyXL96iS11kkJaysIUshBnCV7wihMQsZjJfkYoTmmJIJzShKUyYpX3ly5pKGgw28+VDLLXCm9/8JixYQYgXtAEKFFgABTQQgSaaKQMaOMIRVnCCGqigTGlS06N0czMV1CAJMqBBDaCgnEYUwjch61lA/fCHTDRiUX2i2Z7/EAWHN0AKfcS5GRysYAX3bbQNnVEOHooHyEbArwi4mw4hQHGKWfQiksF4aSQrOdNiZNKmNw0bMnQqt1D29Cx4Y0sEyUVBuXwQcHUZ3DE9eExaLlWptbCFLaCqC6rq0qpy0UUubBGLqA4zFsWUBVOTOSSylpWZ0JQmCrWpTWu2la1tFcwpJvMYyoSCFawYBBBmcIEaqA4DqQODBybGAhKYQAYlUIEMIqWCE7yuYSvAQxEUWycZdKCLNajEaLATiE1E6g0rKESqoDA+5FRvUmBggnKUA4U3FCG0gUhOG8DDBTdwwWeKgpTM3gCFQijnNqpxAySq5ApbRNJ/wogkjiY5/wyaOoSSNqLRJKNbU7IVA7prcUgEYeoLX+gimGJ9xeDEqwpUDK6YsVBFKpTJVKbO5ZizgG9U5YuLquoSLlmt4Fa7GtavvoK/x1RmMc2ailOgkC/U3Ndb4Tqlai44SUA8xb0iPAgQpKAHFJDAAk4QARJoIAlhPAIJNmaCDoC2ELtTE8hiU4N41jOgDTNBqdyIKdJKqhF4WKPPIutP5GSxxbVJwhsyQRuU9aCgVrADF1gLhjDWIBCV+Oh3mFMDD4BskU6yhS5gGgzkbhmmkPwymJs7Uxxtl7vdxa8s0UVesirzmSYkKyrUu8wBD9iY5/3vUz0IVfnegr707S53zdxdrf/iAhe2gO8sjpnn/iJzmXJuBYFPEaQsOdjSl25MZUqBGXp5AhAc0EEMYqe63i7gTBo46WvAgLGJGVYGJyiBbgBqRns2Agpp8o0MMDAp5AAUNYWAAh5oEL5GMAGR18EU+mKDMhnUyTuKPcL63tCGTLQBO8iZmR8CcYc/BO8OImMOHlQaulvowqVn9kUvfvELlwZj3e/+BZqp6l351kIW4UUrlNLaTGcOiUuUcYUrWvGKgbdC4AF3BZ2XGWBXyGLOeA6hLGQZVT7boty9wHgvuMuQYPii43wDRlXnfei5CNPk9/YvygVc1n9XGtMvb4zmunkvUnii5ntIgQpgUAMNeID/xzRQXQlMkAEPmOYIFcAA0c+4AhV4QAYeaKxtStAzO3GMCdxBaSD+KdnW2ukOwZtTbE4aqZJF7wg3czIeZABHHOfsD9GrDaQQtYlNQKJUd8hE8DI7CVYI7BXlZjd3qYpxXZx85W/WdwtZSBjGs1CaUGLhwP7NzMmrd2CvSPhYlXnvkzO6vRS3BX0xvm51r/ultXjL/gYteF0cWr6GT3l/ySp5LpnC5ZamF+VgLvNN05wUmKCDBVRggngiVgN+SN0bKJB0CZjAYiTIANObT4Nmn4DJKkgCbuw5nSRwz2cszo2imMBbWxcCBc7BnXKkUwP4HaERfsgElKPXgyMYuxF3/6JoG/pkGyPEBg6sqLY2MAP0wANSGIhHYAVYoIVb6AVc6AX46jxZaLh787dJa6Zm8osDazwkYSEj6cAM7AsjSTy+iKa0Iq/BeTj+kgVFW8GwqoVZkKos27h3M7PtYq4y27IzoyrQm4UIRLRZoDOWAyJqwj3NoZfEkZLAWAwlNEJ6IQVWwAxNaIMGUKITwAAP6DkPoAAPMAFFgQPiO4EKqACL8QA06oAOgAEa8IAiMAHruxnZKIIT8ANW4LUwQpQj6C1FEbY/uA4mWBTtYQE78ZlK8A7RIhTukIE3EKlIIRT0QQ5KqSgrEMBtg573sQM08ARaoIWMa0BEu4VbEKZZQP84zHMFSeMSBCPCSnsMUwgFUWjFV1wcJEQMINmLIFEFvBCvVOiv/wqrRINBissFXTizePsFYLAqYKgptdglY9TBHZSvYAqrUBSmhCsrb5I0VHiSbGRFJIGr3BOMv/gExIAcx8khzJEcS7AER1gCBTiABoiA1FkAU4sAJeonuqsn1nAT0IICw9qNW+MTM7qNVTuj5GCBgOon29gN6gADE1CNSRm/gToCGsiN3aio5agN1WiEsQMZ7uGT1moURZmZPWGCRmgEa1uOkzoCM9AEXjC9YFC3BsQ4Pzu5UQy4IBwSAROwf+OSyaAMU0SFgamzOGuzIEymr3I0Y4qFHow4aYz/r1+UKlu6JR7hkV0QBmRIBmPgEaQaHL0QHHZZF8QoknEUy0+gobKMIbKEIcgZBR9xr1zAhb/rBVpghT3AARiAgRiQgRTggAmQgA7AwhPQABJgogzYQog5ASgAuhKQAA2AGJKRohLrADPCgMD0AJ9TAQ2ANd6RLGarEzphAhYrhEx4AxnogY/ymeQ4I4m8GTwIBH/6jSI4FEm5g/rTje6DAu9AGckCg00ghTZYqOJJyDZYSdPDOEMztLiEBVjowWmUwMwrKzczRVPUyekESrOSs6FUuPNir6X0qpN7xu+MSljKIA3KhWFYhmhQBlzKhVVwqjXTSq9cobEcyxjihE7g/4T6tM/71M/7VAyuXAUNyh8cMSBpsAZrqAYDVQZfKAaX5IMQcAEqjJgTGLrF1ADMAoN3NIG/eh4ViAAa8IOhE0PGxMyJUYHY0bXcKYEV8IDbuA0KKAEwkIHtuJOCSgIVuI02cJ4jiAGBgAIo+INKOLGAqg0wWCOAmpTfeZ4jcJ7OcJ6bAYOjSQLUYhlua5nqIJkj0AEqSISFCIZbmAUH9DNc8NJES05YQDhvCribXLnrHBiepM43rU6gVKbMAyuTi4UIFKZagkpb0Coe+U4+zQVfCMYK8oXz9IpjGIYJ8oVaOiZVQC/xgk9RkM/95IRxXEsNAoaIMJtmkJACtQZsAP9VbOAGeaCHepiHbcCGZ0jUYuiFRQgBEAABDKtMemIBOMkYlSnRDGgiXc3QFdAYDVhMJjiBzPwriJnMP9EAFVCdE1ABxPKAN2hNFciETfgNJT0CGAABK1gCViCGN2CChjqC0/Cn3cyE1FiULurRzwQDqImnk5oyilpXRTSD74BW7XlSqBmDPSCFX1hA+ApTXPDFMi3Tg6NG6BzK2YNTnZw9NdU8pNzOzvtTPutTPq048AzGWlBQQdWFUaBKYDgGYXglrXrGWDqqki3ZWvAb/3kIBmIGaZCGAy3Qa6CVWpmJByEHjvAVXzmHe7iHfagHa9CbYriEFnCBHuiABFg+DUj/HXVSgWatgDZJOl1VotjJABNQ0b9KHSy8jQw4gSaCAxWoADqpnWblmBLoABO4un/Csdq4DvDI1hSABGJ4u9G4v0CsP9qIyOuok2MDmvWA1uQQJDAQJEKati14A476okBoBD25g0Zwgz3ABFhYQSB0wB+ErzJthYEFJ28KsOe0SemkTut8uPXaTvZyyqiCQS/9U9SdL6qqIF1AhmLgBEl4BVM4BUmdt0DVhZC9Jb8pl0zdH7MRCp6ghlpBB3lA3uRNXnq42XVIB3VQh3a4h3SgXuhth+sFh5s9B3SYh3lYh33IiGuAhq1Qhl6ggxfQgRnIgAWIADjxgKa9wjkhgQp4/0crTJ37PQG/VNYzedESqB0oaLbIHCwWqNc4SdF5UpPUYgJcq56SnIGNWpppA4/d2I3pMJQ04bV4CgRiYIUluAM4wIPUmp03KBU/aIM30AEdUI+vg1Y/4JnRggIrqIJDOAVaaClckIVeiCovFVjN3dzRVS+G9bcKDN2ygjMAW7jSDaFYsrhPvIXVheJ58xsNAtlcaAhi6AX1igVMTb3gpZGucNkDxYZtUF7kpYdS9dk0rgc1ZuN9uIhcgeN6oAeWYAmOyIZsCJYJuQloaIarBIZRoAQ9aAEQuAAmWgA4OYGTul8NiL4PpQA0wlAPYL4OqAClpQAWuEyPwYPYkCLemf8ZnltRFGgsn1sNGlABvTUjGtABSXzgTCCFpakEFl0UFmCjz3wUnQEDXiCGTJDEHmUjkASDab2DqamBNiipQFDEBd6NmYmeHAAEUKAF5dSFJ5avy03OHjzTzfWmy4Ozzz2rE6q8Z0oFVXDYrxo47oxGKK63Pg1PuQhP380fkKVK7soFYUgGr/hUXxnVMl7eMy7Velhj8PVZOSboUjXogvZnXvEVULWGaZAVl3VZnpDoniiWFzEGXfgESUCERPiCvcSAeExWwMzCydSACqgBNFnIM8mAs40+xoIYzKzVQxnN28SD1iioqestFDgjFVgZ21Dc+HOjFTABRcSeQviDN/j/tizyp8+kzS4S3OqpBMflKE2pBCdNgjmsthDGQ14oBEnknt35mNpYAhyoA01QQD+jZjJNtOYUODT9JrkKYjhjpjg7QfL6yZ58s3J+2DyNwahiZ3e+pfEE0PwB3pXlj2aQhqx52WdIBgSKhk8lVYAWaIGWY38G6Mu+bMqmhzLulWvw7M8OlgLFCVkxUFkxbdOWBpxw2azQCmQIhli4BEMQBD3QgzqwAAuIxwRw36ZjHQ3InQrQmL4sw+ZrGA/IngodrCNQAYEwgVnlHg0oDhoQqeJBAQ/TDZX5okbghdFAoyOAGlv7HaxDyNj4p91AjvHTvx4ohKl5gz9IguiJjScj/59CYLGvo79uM47kSAIjKB4mOOGyXghOZDdObEDjpAVcQMVQiJK/IAzHO5xa1LcSNCHxMtmjGs8N0tS04VQCzWd5mIczhod7eGOAPuN+Duh/QPF/wIiB9uddQYcXRweV0AbPFpacqIaXDeMbh+gdh2is2HHWXm2sGAtO8gVVEIXZFYRFOIQ9eAIOuIDUKdEtZKImCkzhoICVtiztgQMP6IB/ErGrxswrxIN7MuV5ao3XcA0a0GmKyqLXSQIMUIGWSYAOYNYzQgHnUROUYYGTSg4mYAI4SMj5o4EZ0D/fkBSyC6iKiuo6uhkzmo7qUI6xA2HnaAM7WEleMM7jLE4xbf/iaG65J2HFwAAMWWSXwoDPdTmqwS5sDX+G1LYGmj1e5d3seYjsgO4HAHkHALmIe2iHc2iJczAJj7hjYQ8WYSn2YcGJhh4WHufx0zbt0k7sl0XtHmdtsTCLBY0FV7wERViESTiVNlCYM6QA1Bl3CcBC05CAChAsE2haPWo6EsNCNOorNBl31IGULVwB2Mj33DmNmbmNFZiTxjKsFVgAe3I+gDcj3PGnO6EZpgaDj7QTnkkCM7pNmrEOeTqOs0ufhz/0P68Ez4gsSUEkLQKDOxiELeWFaP5SLwXYUBS45LS9tJprV2xFV0RC+VQXdAHQTBWgo4AGV4f15KV1WfdwDz//4w9HeoX+FW2442KvcWSHegn5+Z2YkIlW7Z3QCmfYcZ54hqmn9lb3cWaPBmoX8mVQhtgNhsJDhVDoBE+4BEu4DE9oA7tMARiQgQYAgTNclAiYmflVgQ5YPp45Q11DrKCbmNZYpzKRgImRgBoAzMZHI9aIJ4Ba3HnKk/pj95IpQ0Fh6pcJSfOOUuhxo6j5nSQgHxR4HkUc0u/IjasmyUB4nkK4OuXIvvALsmlLBEwgBQUs02gOp8yFBYO7ya1kFxJSBbbMhS4WXq2fhpgN1VDdBhh/8e6NcZfoFV/5bOx3+mJX9qpHdp5wWWKZ6J8f/60Y/4p2hvG9irGglmtp/1Ii/4ufCpvs0pG4kCr0ihK1CoUdqhwopDAQAIgGFmQUSgFigoRGhSRIyJChgocIETAQPOGhhAkJJzCQqEEhggQwgTJ4kIDhBJwiGDSSSALmZY0iNeDUgFLjSJEjNcAcOaICTKMjeJIUYbLiTaM3b6AkacokCRMohRpBQRo1iVKmYJhCAcPkTaA3UBs1CgQHDhQ8RZLg9IrnpditbSoFImSJFCtWsPbmhdUX1qlTr2LVyrVrFzBhwowZS8bMmbNp1rBh4ybvMubM89ChmzfvMrdt10aPpkZt2jRoqldDgwyZNezV0mbTpo162uxo0m7jhiYN9uzYrV07e2bcmTJlyJUla/9+7BjjYcKAATu8K1ctVapMjRr16Tv4Tp1Egf8UKpT5UqDWe1pPatKNDRYmUGwDg36FCBWIapCwgAIFK5UggwQUdCDBgRRUQMEJNGCQBB4YDEjBCpW8gQEGLJxAgQcnFFLICiXUhAcNMtTwRwxQ3NFGD0n8cUQhR8gAwx1KgdFUEWC8odMRTClVxFlJoHUjFHC8QYMfm7zBhEhdNYJWEjMI6YcfcDGBBxNtHQEHXD2gkQheebGyHnuenNJLL74EU4wy1VCWGT1x0gOnnJmhs80552hzzWm3qeZMM6810wwzg6o2KKCvsRYocLXZFo1uuUFa26SORjPcccw01xxjxkj/N11119WyyirddVcequKJx4mqrXbiiSeqwupJKaWQAsqtpHgySBsgcGAiBvSZIEMHHlAgAQkaVIBCCR8xtEAEJElk0goaaKACCxpQoEENJ0xIwxslYOCBBiuh9EYHK2DwBisrnABWISu2EcMRYNBAQ1UwFBLIEUlAgVNVNzIhgwlgvfHSSznh4ccRSvlBlx8LJ9FGIW/g0cMfhSRRiB/+/mEvT0ww0QYUOfbUxh2FJALJIYPYgccegOyhRySwBBPMMMY8g01mPYPGDTakXWMNb7XJRlujv/mmtHBNHy0ppFFDatwzvz0DmabJMPecp4qBeh12pIptanfcjSIKeaiW/+dqJ5y4/fYll7jNtnhkgtKeJoJswMEFPxURwQIqdFCDCRNpsAAGFVgbIIYYIC6BB40f2x8LeLBAgQoryKCCBiUkSyELGGjAgojjlqACHjIU8QcrdwRyx8UmbFKJCSm38cQfgQTyJMK6EwyF7jY25VKQZy2MBx4x1dADE3ds0sYmmwSSSSNNwcHWHVkyFVO9R9yhohV32BFIG3/g0YYbcwzCSTHIIOOYNNVUs5vRrQkndaTS5O+o/LRVY42j4jc/R6HmN/iLGtWu5oxNcS06w5BOqA6TC+zUooKriIXYSKWdVWiHbKMwBQhNgTa0naeEn5gVrNj2thW+rW2rCoXdPP+hhxCAwAQkMZYHFpABFZikQNpS3EMaMpEemksGGWAIhk5QhBBloHEnYAEJSiABFjSCBiXgFhyuiBEMBKISfuDFJjIRvUqAYHo0mMEdGtGG8E3lejgRiwxW0DAdgWFITfFKV84ChiLIQEYNewL07vAH81UCD28ohJF0h4chHQwpfogLlcxnMTzADhCE8EQxivGcYyjjGcp4DHGOo0DWIPAZpTxg/lCpSt1Eg2oLdE4Du6YY6lBnOl4DVXWq4wtg+MI6YJugLShYwVrEopixUAUqkIkKVIBQFOf5zqxctcK4yY2FlyhFYAKDzVO4AjCsIMUeHMAAFWxEXBRqFoAkUIH//DAEJBXICEOOOEV1NmQFJilCETgELAmQ84rc6qPmTHACMNSgQ1cEQyb88KHpZYIXd+iADHhiBUrOZZFEkUlPZGDIN5yFkSkBgyEDgchKwKENNaiBxbiAB0iEj3p4KAQensQEKnXFJQdLgh90B4YPwQEPgVgk8iI2CE/0ohiMOYb7mJOcpSYnlAl8KlSlZsqpPTU5yUBGLB/oNVrS8jBc9QVYw7rLxGx1OmDVhVh1sQtdTHCCurCFLYZpC1kYUzuvWOYyQVirUpyHPSeMFd1aNatStAIU2KzVKVqxF1IAwgENEB2HIte5Y7WTAsmqQEMYYsMKOOSdGclABIDXgQhs/zFaWzwdC8DAAp+ooLXFUoEHYlsE0p3ABCvogQ5g0IZAMEFEb6BYG/AglLeIrCdHmOkmFhaWOjYFClDIqR8yEYiHYakGNKjJETbBCvMlVwYcHR6XiMQT4inkYY3wQ8YWdpbpEoIUuHjgMDa5Sfe9T2taY2pyntpKqi3Dqps0RiaDQcuw6qLABgbrYdTay8OIdcENFitZ4QvBXTbYwHC9cFyJGQtbFHMwxnzFK1yRilOYYq8m3isMQZHiMqEQVts8ha2w6RfGygcDAdpWCSJAARGVALMgKZdmJdCAdQ7ZBGBAQT1ZkIEarEQFErGhB2QwuhqUQLU1gK0MPJCBEkTOIv+rrcEKkjCsI8CgBymQIw0aYaEP7fElNY2KikD6JIuFd0pviC4YCEIKP9wLKjH1okjw2SM49MslHNuKjuCgEOX6AQ5/oFLEFuYHMM0CZ8PIpDGQSl/6IvU5mfw0fLfKS+u0NRdwvQWqb2FgXeACF7pAUy/Q+uBZ0xqswLjZA48hYWHcjJcELjCGM2zMucYCxMqMhStCnOxWJJbZ2dwrKaJtt7u1h0yhUM83b3W3b+6BhhOYQAcCJIEiSJECNEgCCQqkuMS90yEOaYA6aXCgCJiABZgtF2gj0IEMdEBcNLicuGLbARPsmJwrIJcHaKA5e5VocEZpyhECAQUmPGktS1n/JEd5ErCncCmni9yjxcQyFT7ikycsWMtOh/ISlxRhKE/qypZ25zDkHc+nyPtpIvTSizXdLMAC9rUvdFHBDqcir9sxhXbsCuLByGIWtphFqk+t6len6cC2ps7Vxwr0Bt8sGMJ4YDEuPYzEiJ3Xt/7FWVltC7VfWBZ0NWYxVfGKEJoCr3SneyiiHW0Ynoevz/yEiqetCUxYQhNmkA8HOCDuJjKpJDWQwUoaN3CE2LYDHZjABSSQeQlMwN0kIMEJKnDSBZDAnSeYLIbKZaArK1G4oWPBCkxAAhbIoPZMYAEcYK+CNsjg3EXQXVrEwpYbbemm4UXYS3qyxN4/Hp8QvxGh/4V00iL04S0uQZjD7gyHnE43p4PIWCD+UAlasCLZc236XbUTQg+eje55pXsq4i//VLzC7faXBVzxbwtXG9g6V/f1LvwfhN3aMHjd10mH2H2KWf2aLtwCXOGCA86C233YKySddjAT2aDN2YzQCJUQB34QKgzG/uGCLdACLAhCHPyAC2zA3nCAAjRAAyQAhuBQB+QZRUjAEOnYuJjABZiACSAE5mWADUkAChzBBUSAspxejkARDkqAtlxOuZAL5hzBRaAUmLGACpwOCqCACqiOCtQAUZDASzHBTiQBWdQRT+ALHhQJkxRCEXyXc7kZlRAOE/TZHd3IjVwUGLbFS9BAw/+8hZHAwb7cWSSh1x/cwR4c4vSQAonV3YiVwt2xnwd9giiUTQjhFV7F3wTC3TBVUKmVmi8tGGIM2AD+XGLQEjIswzEA4HVIEDCZ2izMQrEtXSrIwisUHTOBkCQmHWEYxi49kDEgQydBivxYg/xUQzQsAzLAQhw4wAE84wHAYAMswDQmwAIwwQlsxFJIkUk0EQbsW5TZVgZ8G7gdCA/WTgd4y+kdCwskwbY4zuSYxDsSIQpAFgtki054y+zhkweA4Wz5YSb8Vo5wFBiyRQ0gz/UEAikEgpAIH1TsFCtUggx0BVMACY7g001cD1EQ1FS8wR3g4SSJ1J1Nl0gZIh7kzof/FIIlhILZgKAkvmTZdIcGul/dYaIFkooxdeIwtZUv9eSD0RIuAZ0yRAMysOInttXQiU3SrcJOehUwPscwHqM1TCVVUsZUHqP+PAMzdJIyHAMqRAIfhAADKEACHMACdEAMLkACrKW38FsJlEAHjMtKUIAJwNYJOMQKXMC+IQhO7OWNYMBRJIE9VcDnrQALmIS1nB6GFAgKaIBDdI5FGGYJQFEGrEDuBUINoAAckE8gQEJU7MhPrQWMFJJIRM+WcElT1AATFAEUNIJ4CV+O7NFGdpFYMIGR7AtIVUK/cMx5wQ506Q50nWTuVMIfAIIkqMIqGAZ19CRz9uSpyKQGks0l/xZd/A2GhxFGJ7rVqvlCLrBVKK6VYZDaqJkaXCnDMizD2H1iT9bSYhyDYzhDNPzPZFQGZdSnVV6l/EiVKT1DoEzVMUaDMiBDMMSCKXDCJNQBB8RgApAEBlgjv00ERcSlFNmQ42AAD23Zt/HbCuBlT2SeXtYlCpxcslSLBnSIRvRYid7jSXTRhtZeQSnREdBeiehEIRxZIPCCQ1kIDbTcW8gAk0zXW3DUoA1FRv7LG8gAbw2XH+SIIfUEGCjU8T0F8m1mSZKmT/1BT00XWVDpIQ7CIBjCKESYMdwSmdYSV01QdnTHBTJTMiHnLSYbiE3gdXqiMIHiUU5Qc/pSdw4Dh/9xZy7kDGNojSnFz1TyjDxwA6Le51T2BmQECnE8KlSJUqREjSoO6AlpQiToQQpIwAEkQBP23hFtmRCmS1wySOR8obhgwDgG4YHsSwPoZQZcwAUcAQoci+JUwH8oiAckAblM2edpgAxsAuF0IRPAVgkUq1dszk2ImRW0wS84lBXIAApM3FeMjB/CQXFhRb38m0ywRQ/sjkiEFPK42ZNOxcoZicgoxVxswh002qMp10/VUZLwQiXwQibkTiZggiSsAmIsxpiSaVDm0nIGHYct3S0u03XWH9xxok4Wxp3eqVeJ6XMkwzMsgzB8AifsQqmMgjC4iXxepTQokKMCCjOUrMn/nuygnGzJuoYrOQPUUA2AKkMx+EIsYCwnUMIkJEIPJADg4GAC3MsFQAuANJEKNBFpwaWxgMRdjmMDTMCGYglI7GUfkUDiLA63XBYJeIA9RQQJYA7B6KWLyoCG5AjJHEEP9EDKvMEfbMEk/MIggMBkMmQXNUwb1AtB9VESLOv2YAUU/EHfbkK9EA8+FQkidYzGnU+N7JZSmA8cVAIrRIzuwNRmhtF6iFEmQIIgKEJhzFIEldqoNOyoFJPbPZ3bLd3ocphOoqnD8qR1cJViAGpzQMZs/I99ToYxOoMwJKcwHIYwUKymDAqhqKxrmKwzlCxzbAryJq9jfJLJdpInbU10/wCDLshCKpiCeKSYI4CAWi4AtMjgvkUAfQghvxlR4xQIglAAaHVAEYZqQwycQxROBHQthmCWBKzA7CUPiibLujSCCXAACMDAEfiBCtTbCRCEkliBDgSXHxbnEGyBDuDACfjLEWRCJhxBcP3LS1QJ8tVL84TFHURc9dRRT+3RGxaCczUMlywFWtxZlihFISBD6/gU93Gfl+oBKBADKwSCHgjCKPArnmbQdoRgJh6TKmwY3NlfsIFi6wKlvzZHMzwDNEjGZCRqotYuVRJNagDQ0izQUTlvcUTDyW7Kym7lpuDXUtnXxGYVBFXH0CGTCH2CKZxHe8SKJ+CFJaRAWhaANf8uAA6iZQTElrZQwOUwRBNWQLWAb+cFwgpgXtPyGxHKwAV4ABgYC7ckgepUZhGoAJ+JjkvUAJ+9QQrEAB4oieqcAAqAwew8GitY1xEsAReYARHgwFIUxZUsyW+1AZOcRZa4xGoezFRMz/lMXMP8FJQYTAZHTCMdDJMcEnptAkxRSVBFDOzsASGASVLYgR5wAp4eRtKB2IgFRnVW4AZlEFO24i/CbjLAJ+1SBqIi6qFmBtBgMVXyxm1YQ5/QM264bMhGA3xKA3xGA/Aab37h11VdFXSE3SyRWi4cE/uBR9qoCiegkHjAiq64gAVIxAlIwFpybwOgQAQkQIkCiLbYmH7/YBYfJ07QLkCJ+GDmHUUHXEDnQZS1lMCWHEHDUcgb3IRwPV4HFAIp6EBMqZEKEEUGyEAafTDDmAANdNHKvAEM3Eji+u2StAFIJY/dskW64itxhkVNibAI3xRIcVQyuwTF/EFZHIwgIaQfnBdQ3QHsbN8dCMK+JicbE3Ey4WIykcootqdjmFIxzmc72+d97gY+X7FhHzbRzHM9Y8M0PANq7Fcr6fNsKNAZJwN0hNp4tnEHeRDahBAHOpMcuwod100nGJ4FWIB/4OD2cq9FAA4F/AcG6FgTKggO5kcjnyWpXgAKNEIRiK8H1GVsO6HmZM6OWUQNBAUG1EghsMLFBAXB72AFDSyMjDCBxOFLGKHBICTCEUymW8NZlgQXtqpF8d1IyLUBBXcmoYlEIKwclVwfXKxcm41MJTRCDsOBW3PMIjVCQvUBNEdMH/QBGBCCIiQnvwJDYawCxn4CKhBTdyaGMgA20NDnVV4xajQKbOBzAUkxYs+nYUuGh+NGaqysY1g2dHQNV/1SJ1pg0tXdil8iKphY35UQKEy0eFST2zBCfCQetKjlR1vjWpqvjZHL5XyERADIf0BLQzzowO3bClweuG1EFtLACSDOW2qZCQzICnRhF9KIzoIAvWTJCtAACnhX3fbEkvZtI8DAEOzWkgYEACH5BABkAAAALAAAAABAAQABh+e9ntywkdutjdWrj9enhdGlicukiMmghM6cd8WbfcGafsCVdruYfrqUebyTc7aSeMGOZruPbrmPb7mMa7iPcLeLaraOcraMarWJaLOOc7OLa7OJaLOIZLCMcauMc7CJaquIbrqDVLOGZLKGZLGFY6+GZ6+EYa+DYa+BYKuGa6qDZ6yDYauBX6uAX6t9Xqp+W6eEa6aCaKaCZKaAZaZ/YKV9ZKV9YaZ9W6GCaaF/ZKF+Y6F9YZ19ZKJ8YJ58Yad7WaN7YKJ6YaJ7Xah3U6R4V6J4V6J1VKB7YqB7YKF5YKB7XaB5XaB4YKB4W6B1VJ96YJ96X595Yp95W593Xp93XJ92Xp9zUp56YZ56X555Xp14X515XJ53WZ52XJ12WJ51X550Xp10Xp11Wp1zWJ1xUZt5YJx5XZt3Xpt3XJt2Xpp2XJt3Wpp2Wpp1WZxzXZp0XZtyXJtzWptzVJpwVZpvTZh2XJh0WphzWZZ0WpJ1YJZyWZZyVJJxWJRwVpRuVpZuT5JvVJFtU45uVppqR5ZqSZNpSpBrUZBmR41qUo1pToxmTY1iQoloT4llTIlkTIVmUIVjS4ZhS4dhRYJhSYldPYNeQ4JeRYFdRHxcR31bQXtZQX5WOnlVPXVVP3ZUOnhRNnRROHhLLW9UQG5POm9NN2lNOWxJMmhJNGVINF9INmhDK2REL2NDLmFDMGFBLV5CMF4/LFpBMFVBMWM7IFw8KFo8KFk9Klg6JlY8LFY7J1U3JFI7K1I4J1E2JE04KUs2JlA1Iko0JFMxGk0xHksyIEouGkYwIUYsGUAuID4qHEYnEj8mFDomFzQkGDogDjAfEjEbCzAVBicaDiUXCyIVCyMTBxwTCiAPBBoOBBcOBRMNBBoIABMIARAIAQ8CAAsIAgsGAQsBAAgIAQcHAQgGAQQHAAQGAAcFAQUFAQQFAAIFAAgEAAUEAAQDAAMEAAIDAAEDAAcCAAcAAAUBAAQAAAMCAAMAAAECAAIBAAIAAgEAAAACAAABAgABAAAAAgAAAAj/AOU4IePkxoYCDmjcePHCiRMrdOQQIsPixsQbNIrI+NNoi6E9RYi8MHGixYsWJ0RgqFCBBAsOME+MEIECxYsNbWbpGlZs2TZox4ANAxarFyofXJwQ+XFDSBGIVogsveHkx9IXLrC2IDFC5gmsDEmQQHGCpImaJsSaZXGCLckWNl+wQGGirl0RImDCxKuXAwaYGESYYGHVySFTrmoNW0aMly1btGDBshUr1ivJmCW3QoXq1WNbuWCdAkXKlGlTqFixgtXKFapSuWzhCnZtm21u3LBVozbt2bNmyZD5kpUqVTNv20rhUKDgwIEE0KM7T+DcuYECBQxox15ggPfvAgKI/xcgYAD58965cx+QoAYkTI8ECYIBQoedRJo6iUKlrPY2buF4c8011RRY4DUOFVGEEDccYABGN7BAhENO/CFQQwTdUAQdXHAhCRtteCFSTXOh0MIIHIwgFgoskGACB2KR0AILL6kAijDDHAPNNtdAAwwvvQB5Sx09LORCWzf8UMQPL/zA1JI3zNhCVi+YeMKVU6KkYlqEiSQXQ2ydoKQRP6wwQld14XUXXoK9eEGKecFUwV97wSShFYogttMyw/RiSy210FLLY7FkZugrsfz5GKCrlGbaKqucUssqiWEiiKSx8eLMb8102mlwxoQazC++7CKLLMls80seDzDQ3HPRxf8qXXUGOLgddt95R9545p2H3nfrDaCADpB0Al8ZM6QQQxl6MKLJKKXgAo031Hpj4LXTKCiEEE7IcQFCQgikkBBkFOKEQhWtoKEcf3iRyB9scMFCWiSdaUJeXbFg0kgrBRbXBh0kstNi0TjjzFC88ILLMIjQwAJWJKjr5JcngemiiS2gtFVJLixFYk0/WEGGXA+/cAIJXzn0AleCkZBXm/fuVRcHb2Jgs80TVKBXXigYQQchkoBCizDFOENML7XckvSgn0U22WdQM51LLa2cYjWkkVLKmmSuTDYZLrjEcurYxBVn9tmyxCKIBw80QB2sssZdHa3qdaerr7uG5yuw6xX/MOwknGjShw9YwNBBDnUgMsko0BJzjTfcUFPgNNMUGI0cmIdbBA0HFLCCUzQ4JREdCmpIVeheWJjIHDSsYBfLfAnWVpP82izCCCZI4IAOQytzTCqixLLTj7EMw4lCWLW1Apgl0zjvxWSdLBPKHV8F1wk1fVUXW2fKqNQIG4iF4s5x2kWXXjbD+CIH63NQgQgvEGGFJKYIg6MzxfCStNKAfgYooLkAW9RqkYupwcIVCETgKlSzmgN2DRaRecVrSpGKUogCExfEhAYxuMENPgIGD2gbdA7AnBIyJwEKkNvbOlc38PhKPDDcW64GgB0DMCAHjvAEJBTBBjSwIQYw0MEZ/xiBCWi9ghk8qsY0JKfEanRLDmRQkBw+MAAH3EAKN0idHLxQBDmYbls3KMG2aCCJ1qWFBIC5GQa6IhMYoZGNZzHBBT7QAVMUI0fLsEUvhhKkXADDFTsowg2OtAIOtOVKNDqjWLB3MpSh7ExXQkGccFeXspxxfCoyWQXedDs2xQkmaRGBi2gGoy21T2fumwD7fnAYXbhyjwW8hdJkWUACgg0XBbwlLh4Dtth8hmurQEViDgjBYtICFaMQhShKYcELTuKZj4hmNOUTHx5koG1ug84CtslNE6ZQbg6qG67wBsMAhCeGuQpAegygABUYohKSqEQi7LAHH8QABDjgQ7GgFf8LZkyDQNUYULaKQAYLscsLDiqCF4SQOi9sUQ7cwkjowtg6IfxhA+C7wAZWMqc5tYlmG6BRxkgQGA4sgAIPyIQwjrGMYwzjpUL5US2E0YYbDBJ8G6hLjFC0RhWh7EonGwFKsNfJM52JAyIoC1nEgr6NXoCjJvDpJ/siSpiID30smcBfdGaCFjihEqoQRjJfsUdXyvIWrixgLnEZQAHKJmFsHRQCWSHMyCTGabC4jDI3uFf4THOa8smDIHgQwgw0wAHadAA3F7vNE4IznOohQK92Zc5ylrM83hFPehQQA0NkohLw7IMd7PCADHgAB36YxLNEwQtoAPQa2BAIIehgoSj/UmAAFNiWQ4XABQtxwSkSYsoKVrABDRSiBRzYwAb0slw6uYgrShXLRsWygAtkQA9EYylMX9mLWyjjEjJwAQo2sEmcLpepPl3klUTJSJmMoKd7GcG82hJVvXAFRjTDAEn9Qif+ItVF9HquivSSswqo8ixFyERYowmLhLlSF2hNq1onrEtcJOzCtXRaK14xtVfUAoK3gIVlNBjNDsZHsPIRRB5WnIcysK1tCuBmAhxA4wbYmLHelJV1nKMeF1r2x+XR7HfY2YNEgNYSlmBEHQyXgQ7AoAyIwISxSnGMamwDG7Fl1x8Gsq0VOEghXGCXFA5xCDksqCLClcBKFDSBC1wg/2fJnUD4FpmWk0UVjfilsQVU4IpiKEMZMQWGoIHhXVKowEwj2CQab5Yi/e70Sl1BgSMDo98WvOinV9LpBp56po3+xUVH/XSa2FeT8yXXLHZ5iWDYdAIncKLPL+WjLnphVrX2kq1rtfCFFQaaqUWmFZMZlC6W9opXpMKv0pwmi1es4hWXAQfYXIBiY6wAC1iAxjW28Y0XYEIdz+06uNLVjy2LWQVk4NwNuI4C2iCJS1gCEpOABAjmfc362MFZ+nnFMwZEBys4QYp/+EMRNnCADYzZomQuhBcW8Qc69PsFbuaAnAnR6Avo7ALydZ4i72XK4V6gBCuggSn+vIxBC3oouv8ohi58oIIRTECxXAGwvUqylbHMt5GeHItXsOcCtpDgBkQ441fQOFzcjU+nejkjBmqGUZ2eQL9WJQlD6ECKWSjDYNE4RmMSVkBeqBXDudg1hi28y1+2AtiS+WUteAGMVyT7ER2cxNvjIwg+5KAD56aA3ilggQZcW9uAbwC3czwruoVb3OOurAAW8AdFSCITmtBEI2AgrCOYQhWgKMUpJoGIOpSBB2zrwBWiTArOHOMaNiWCFB2OuW1y4RBScGghZr/lKK5gkxGIQM7o8APlwmjOGctYi1yUl/DZZQUSiBgNMkFymJ4cGHtUhiFUUIIJRGABJfI5qFGWPRRxfys2m4n/UVHWgh/MSEY/mJcJrEAIJ/wlSimy6qKX/pcX/WXpblQR1JFKFpsswhSz4GdXRwzHIHYGyHUGqEu+VCivcHZQ8xiwUAs/UgrLJlh0l2KCIE2IIAh4EAMd8IF7Z20imG2BJ3iEJx0r1DeIN24CUAAWoAiXwAmgUD/CwAkHwB7YpQylMAqTgAmQYHc44AENkAJXgAeLcwqc8QMDQQZM6HBkcAglcAAlAFFCcAiLgDktoCEvUAERYGBzMgEvcFHKNQIYl3E04jozgwHhM1zDNQHDdQN7IAx/BlOxNmjQwAkyUAJc6AClNhdARReDMS8qcjsl8XT6lRKEGFQ0Ymd3hhIY/7B+dHAD4GMzyrV0Flde/ZIiPKUzOaWG7FMWL/B/syCHylByP8J1Yed1YacLEzY1TGMLT/OArNEKBQQagwIorjQKeVAHPMADMFCBecAHKBZYZeCBH/ABGqABH3huIhhCIVSCDcAAjdVtsWIdPdYrl2VO5aEAc1AJn2AKtEALoJAG3VErb1AM0VAL0AQJguADOTADHQACPFAHjOAJpOAKIeNvVrCPZOBwRbBNoaNQC5IkN5F7E1BgORMBhUBcyqVcLgJUaIhoEXOGLLBGLKBQqjCHQxFrL1U0rlADK4ABEeAAf1hqLBJg9jITt6OSXWE7gTETLoFca/QXF7BI4AcTDf+5dJvkZhiFATmjhpt2Xm4mZ/VXEofwCWH1Z8rwUmDXirUEQA/4GbERG4OyYU6pNK5ECoJwBr2IA2XgeXVQB8DYYjwQAyqgAilwjHSEd8zYjM6ITYE3jSU0Ky30QjEUHuyhLPTxAM0xZApQBsVwDcCACfGGCJDgB2eABzyAT3UACJLgCeXHJEmSJEUQPySQABugECJBBEnicgdpYLkXAW/WLSXwEgAGVCfgOsNFFjRCA655AxgnIVLAfMpwRxz5UsdwDMWgBSqwATSGmkBlk5aGIkYlAizRSTRhBGRABEPVVS8APiSgXCXgJuwTc/elkwZWk4vGhVr1PnhxkKKpUSj/E4rfOIr2I2i8IGG5wIr/054EBEBn1YrD5hltFXYBtJ660AmIcAU4AERHYAZacAZnkAZ4sGyeV5ZmeZYloJYdoIwi+KAj6ADQOHiO9Ta3Yjd2SVmWlVnqpE61EgXDsA3OMAqPMAmRcKJgSR85YAaJwBAzwgIrgEhMwQIJsAAlgC4aMgILMJLWZ30O0KMqcAihIxMsQElqYQLD5TwYIQSuqTMPIwWJ4Ge2yZHEwCfOoAgfsAEjeSVc4VMqYiJ00aVstBIrKVRScSIlMVzTcwINiVEoc2c5eYmb5GhIRaaIaGAFVl4owgKL8HjfODTCwIpOKaiD+mCGOmtAAgxUYwuq/wh2vUALnFeMINABOvAET3AFV1AGaSCWu5gHaXAFOjADrikDZ5kCaXmMytgBEPqg2FaCC2CC3/Rt43QePwYAtnqrGzoAtQIDxcAjuUCYGjQJglAGnwcCQdRIEKkvUHIBB0ABCyF8LzeS10djuecAEaABFtI64TNndlEXK6CkrumaElABJvACN7AGrlCbU/pSxOAMx+AMplACWuoA4oMXO8Uyf6EibGSvXKFfpYYlM2N0m6ZRfjFnK+Fml2hx75Vc92czXmGcueeFyvUmDtd4jwmouiBotGZyHGs/9nObHVkMd6QLHHaAftQK8rGYHtABOJADOdCLMEusYfkGZ3AENf/QAwziMCtQqmqZjKqqqqv6ltBYoSPEQt1hl+JxqwCQtAFgq0KmHWkQotuwDKVAYpDACHjgA/aUAZKEJoPBECvAFJxjo2fCArp3fdskrTy6aTdQCCBnAjnlrWwYo23RmjQgAytgrRjwMDLACeq6ru26DMogDDZQAhIgAVyaiCeDF54oPmrBImjkEogoSieCRmmRM83FEk9Ff5V4iaokZ06le1qlVSvhowapURugIU94CJLACaZgNZwBu5BiNVeDNbbLCgkkGbh7QK2wa70QJBeGCoEFAh6QATCAAy0Lszwgs3XwBmqQBT0gBVKQszJAqjyLjMros6tqAQ9gbTUmoTb/NpezAm4EgLRK67S4qk7f8QA80Au1UQ2+IArRBAmQAAhHsAM5kGo0whBOYlM0wKwSEFWqtBKhyaPWR5PGZRBv66UoA6NI+q3m2gJmglEVoQKJsFIim8HFwFJBUQw5kAHWGp1zhjIrQAJzslwPw4YlIK8rsMIgdzIlMAIvHEo38z7xJX4qolwacAEasAHyuq1PtVHv1VHgqXtvFgEb8ALswrqSoAiBAAiGoAiJkAiG2QhTnAiGMMWMsMWN0AiI0AhX28V4wAeI8AiQMAq3oHXEsMbQ97vDUAp0dwY5oANzrAM+UAZnEJbEWgZ40Ad9sAdrML1MSqppiZYM+oHLmAEQ/0oB2Aa+4EuNRQtu45R444FZNNRjBgADvbAN1HINsqBMkQcJbKAFzzMYThKZGiIEJVCjLCAC1lcB1qq2BSyaGrAhOVV048dIW5KkroMiIBc6dxCAIpubulk0JacMgvAANLbCJFACaog7bOpUg6HC1NfCH+DCP1wCLqOvHDUnasRRPJyMO8zDK+zDxaUBXXiQWqWl1letP8rDXfQHtLcHT2wIgWAIUGwIhhBwe+AHfhAI9RwIfQDFgFDQmYoH8iEKuqAMa9zQv5uxnSAffJAGMxADM+Cyd7zHe6wHBQ0Ie9Ah02sD1suzp4rIePege8d33wu+rkKN1jjJlMwrl8wdAf+QHTiwC9WiKhtEv4Ggpm0xMUriECXsAAYwlLq3TYoVmtZqfW5WAoRAXEjqeypSFl16mifzFznFAk0gA6AgsjyxwSLrDCV3DJ1wWAsgnQ7Zy+lVEWdYAtVcAsmYpefcw3gxEyzBEt+cVQX2VHjaLzB6xIdbARQgARrgABfAyNI22BRwATTALrSHOQ4lB3vQBm3ABnewB1vkBXGw2ZstBmKwBiCCBmugA1egBnqgB6QADIBGDL/wC8DLdpPABxz4BsnishettRqtBX2Az4AQCHfQBh2iBDYQrtVbqmlZ0kBrAcmodyN4beAbjdTmWA4STiuYeJacHh56ADgQC5xsG8z/IL+PsMUQzL9P4m9lQgLM+qONvKOxfLqbJAEUEBI+/MMzl5poWEllscuNLQONQDTsmps9YTTDUAsdwMjajKQkrBZcmi400AIuvAIfQAHirMM93C+2MxPdDJpdiLClmzMScAEyEbGHjYx65wAawMgOUOIUkJlm5lBNwAVeEOMO5QVrsAVe4BBNsARJsONL0AVKwAVLsARsQAVooAIxIER2UD9LucbBEAzAewt1hwdpcAY6kALVa9EuewRloAM8cAV9gMVZ7NFbxAVKIAQ4y6R3W6poaarYK87JuL3PrW2NNULUAW69Yh7WPUPqWyseUAq1MSDQEAvzC6MPkyROYgRG/3ADYUteiCVtSd3eoanOil0CRfDDPvzA3xohc/utL5EiIcekSkALxQAMxGAMxGwwx5ALx1AGg10RpbMCJuIkJYw78yLBLtybPdymbbqSORcjKmEzc4KweL1cb0ZjB8nDE6t3FwDfy+4AH34BVNEUTuAUClLtL74tCtIhSwAEQLAEw70tQNAE2/IBKjADO5AGScmuxODkCQMLeIAHdaAGWqAFMgADMBADMmDROnAEM7DvX64IjeAI+rwHk80GW7AFUrAEStADOzAD1Wu9KbCgatnm22ttNvZ3JliNLJQr58SC39G06lQAB5ABmIBE2GAbyVAKnQCjbWESVlGZ6TcCSP8cAc9Brbm3o5Heo7pzuA1uzhGTpOaKESK1L2xREUTAWzNACndU6qZuzMmAC8cACRYA7RoSFWAh6/YNoyC3Ag4ur9j8wxoQGCfgAi3w67bDuHe9SZrLaeBTxNl52Hu37PA99zypLuqyOTTiFOD+WwzSFEBgAzMwA8Mdcq759zagAW6tAmqgCkUjsg0NfbpwCl9ZBk8wxzFgqilw7/2+AzEQAzsQCAEvCU2MxYGwB7/NBjEuBQvfA8Rd3Ct8zaj65hXfvRgveNxWtIc3ADGNWU4b8gNwAHmADP6xDdGQC0kqJf37MCSQexegWDWK1LNskO5MY6mLzVxP6DYlUa5prs7/0yQawt84wvQbDA1iTWukUOAlvDzBpzFdkf4m4MIOLp3lPNdkmjHiR1KBoRJ3PZR5umkRIAEAsWEDhQsXIhx04ABhBIUTHFYYUULDBYEXKGjYIHGDhhIfNHwA6VHDRw0UKIj0qKCBhQ52VAlTNkwmsF69dOm6FEMniA4dMsCAAQJEihkzVDxgkMKQJKaSGilKZCjQnj139szxwmXLEiU9vNKgIUPF2BIdRY5Ea0Ht2rUN3DZYsEBBggMGDBTAO2BAAL59/QYQAEBwX70McKRyBg0arlIsWLR4cYMIkReVJ0TYgGHBwQMJ4jI8GFqhQtASNNBYkXoFCxovHLO4ATZ2/wvIkB3fuCGEBhpdMokZK3YMmrNlxWDRikFhxYkVJkaQQHGCxYvnJC6UXSGx7MYSAtGiFSGCxIjwIjBUwBD+fIUKFyocvBzhsgQJFiWYlBDhgoPNCRuCnqCCDS7gaCAHLKLgPgdMosACBtnSICEGNbBAAZUe0MOVW25ZpZVVUDklRFMM6QmEDE7MIIWghkqhQr4YAISpSipxCqqoAAHkjz/mGKMNNtbYIkgldAtLhhVUKMsskL5bqwO2LHDLAbjmOqAuvAoYQIC//gpMMAD4EsyuB8oQBBNRUoEtsh9wm86E9jgwyKEECkhIPvkqiC+0ANvb4ITYbijiBsheUG2FFv9oaGE63H744YVBaVBBFWWOWaZS4oo75hVhGkFrgxU2GEE6Elg4oYXUylLhVIG6E6jV7UaAFVYSxkMvvMwcGhC/++oziUKSPr3gvo32O4g+BzaYoAQVPjpBgo0wqmCkDyyQ9qMUUvigA5I00DaDDxRg4IEMEDFFlFEwQVeTdDOxowOhrhVqrLE0aOCAAQQrIA5JMsmEE0eeiioQQKiqyscgl+Cqhx3CGis7s0ailsInLchALSnfkotKu/Laa0su9QI55AMawGGUY45ZoTLJ1mzBBBPG2wDPC85LIIEL8ozPIYdmBnUDEsAqwolAbyA0NdbAgozoyl5LVAVJhBmmGEv/gyummFp04QSEDz71eTnaWIDVhBVIMMvV7TZatbv0RNhAhBNQIKG8EW6dwCOKSmLQJAsSkpYC/hyg1iO/L3Lgo7IKpA/PCiSYwOK9E2pAJSj5U0Autxiwy0I+MJmkE0gmmcSSSCBpBJEHDmDAQtXfUuAALAsIAIAB4qikX08kIR0qqQAx5A+q7mhjDSC3GhIspI98eEmIm2RLyostpKvKu7L0+OOQQS7gAAVgmISUyIhg9AfHODjBhPXS89mBAxzSE772MMBgAw5IEMhQIYT4k4VTyVZtOsdeNoFjUqMEVbiiFbaoRS1c4YoPjWIVpjgCtjjCAViVyjX6+5SSQFKC/xOcrSwdLEGoTvAcFKDgOZkRCAYmYBq0TMsk/rFA6lLXgNSpTntVqgsOc1iAu2BJL33xUhCFOMQheuARoPscIyDhCNIZokqXewuUWnclA+ilAGO4RCY8AQpLTIJ0jUhEVAyxuz7oYQ9tQCMbDtYDGwDBBjYwSpLKojxucasnJ2LL5aBHl+l1TEvVux7sAjCA7I2sBo5Z05pIYD7zPCQ98LuAZyKgwgBdZgIFgZ9A5uYzEiRKNQCUY2pacIPUAPAEp9xACiCRiU50YhSk6IQmYjkJU9AiESngyAowQJERMMpU2TFUSL4zAQ2skD7HDA18QLOAKhWAAAIQwA/BRERqVv/TS3zZixWvR8i62CVzNbQhDqtoABCwQhOT0MTnlhgJRzjilhlwUlsakIAe9nAABjiAHC7BCVCAIhOX6GLuwihGgRGMKmgE0hKaIAQ3wlFeSJqjR0LSk3iu5Xl7dB2WoPlHj2UJZNDkZpUU4JhEQWZu6GHPeRyiwg0sIAEOsOTNHvK+zHBAfjGjX6syubNVVYSCcHofgbKAiEccURJRYcQjBEHLPqRABTLATgXHQ4KxlSA7Ev1AR9BirLgsoE4RYE98mOlMkHIsZD2koje1pzoG1DBcbrHABy6S1ZIoCyTLQkuDPrIkvX5EBdlKQbgywAddqKsToOuiJRoBiUSA4En/DlBAPfHZGQMkoAF7qMQWScEvgDKlEY34FxjDKJXdEcxHYxBDExZqA+MhCnlJwhZIKNoTtTzgARjT2JWoV72NBhKHXaVL9Go23CoNd7jwuaTiUhq/mWHAphG4El7w6RmFRKsk9TGInRhSMxD0ARCMeIof/CAVQQhiFZloA1kMBbYAcUBsz8JrVpF0kWIaiz4L0dkEzpPMYl1XAv6RkN8A14HbvmXAcKXWWiLktyVZQCL0LcmCejWSuXpEBXJQwgcyYNsHTEIYo3Al57wIukkI4kROcgA9CYkXHdZsAR9IRCX4aQpNaIKzNGrKF2002tJShUdj4MJC7weE4z00ttnq/wCS13JbKMmlZhnVaPUAA01svg4vL2VmZ1wcF+NuRk8YkM+e9sSembWnIBuQwHC7mswK2HRYA0ocniJQsxTgaLRz+EMfBJHUWwiDEzNwKkhW0NxY0WcjeXshgBMigcX9lzT+OeZ9vRqXvyWE0pZWAH+66lUHSIDT9ZmAgT6C6I40iCCJZrR1LYKWv3agRRQDhTBkOYrOeSKdoOMDbVuHPRZrOS4UkEElNjFjTnCixje2RLKZ8kWAjTYQgdDRHOYgByBzIcgLJXKRZCCWa4Gk29lC0Ymk5ORm+pCjUiaMXsTmaZhi4D/JZF+Y451fS4bVPQKqyC4fkt+wJijSoalAzf86cIdAGEIRh9CRIRIRiEesQhmuAMQMPlCQ98ztOYNGT0EmkqBT72rRaM7PQeRcSYZY2tOTprRLa2YhLXcZuC+dgAPgJFcHLKlwFzHJpDvN6QXUh9ODW0mTXjJrTMBCGLfgHCQA4VgF5MXKk01Aph3QgR70kxOkMIUnPFFsG/+Ts5fA8bI/K1qF905HV5GDHLyQFdUylEjbHotTVQCvO2ZLLXB5MpR3i+6/SOS/nyFNBPLjH07XqdKKLtYxC1KfYyo60oyPNKS9SoFALNYSlTC4IRYLCVIoQxiZ0BYFXLoA5zCoP4qvyH8Zx5D2yGdm7hnQJVXYPuSCBiELyNUk30P/aYQ05DwUWQGcLKIWk5TAJCABFQmOSYEKmHwBouePWlyggjJUrRSlOAUrlKGLW3Din3OYYnSlO13JOSADMgCFKrRIik1owtj/xMQl5D+jpoy92WMc41Sosva1B+l+sQELsUCSkEAyn1CLEymw1Hmy6Tk3KeO1vRE93kumOok5Owk85Ao5sCqIMxuQxXu8DwyWx1u0ktsD3LkETZCEpUgESUCnYnCGVXiCDnA3l4oNm0u8+ki9TqOAFVohwcOuDRCbFWiPeZtASjs5LzNCTSs8I+yViaMPvUoQgWi0PUkzBcAb6FuABCsJC1iBDhAEZwAGUSgFrNMFUKixS6CCyHod/7WCugtxkg7wAU8QBlPghKzbOlvLhPj7OrALO2YDGETIP4M6ozZgOyGQgvthmLmLO2y5I5/YsNtSnejRqI2Ssmiyom8JlhSrmQtErgBZD/YAxbBiD4HgAAqCFQ7YJTyptw2kCApixYooiJLbgkqYhH+CAhX4A6aYBEygBTBEBBCIkLhIDY9wkIKYsLzxD/zwDx8ExfkQvEVrtL/btJ6zNE3zDC6rnMpZgLd4gEUDMP2YgLg4AStwARXiuUqbloRIMC60gEAoBlvoBFDwBFLwhCz6RSuRLh0qLpVYiWn5gCzoBM8bBTu8Q+/LhK7jl3+SP0toCtz5ooHKP4HpA7QbA//+2wqFmQEZSMRuc5c72jDcoguny5IG5AtL1ItD+IADUcI7UcV90y9UhB/4EUXnMsVZmZURsKlUDJDXo4jkQ5Yz07eSowAVqIQsigTeEQJJuIRdLAVncAZSUAEBKxwNwCOMSMmhZIEtfKHCA7CIoRD6cpDou0K/mUYs5LKoUx1wSUu3sK0KqZkw4wAIIIAXCIVQWIRBIAMyIIII6LnJ88pl2SAbeANMGAVR4CdQ+IRLeAIGuKe7mKziogsLgasOKIG48gFNSIxaWIV43LpiO8j3S8jQBKhkAx1JiIQa0R38ezbfIRjgUaOuEAIbqAGjmLsPoDsDtBgus5KN0YuN+iP/kxyAWZCEEpApvhw5enM9mVKhsPJEVMwIEygBsmkVVnSPe6tOxeEAtpFJofyAfeEESxiKOagERcjDUlCGaNAFLMgA0bNCRzyRkkAyDeuA2nxDa9EwteCWJ3mLBngAikERC7gtBoAr/1iJBQm32XqXuGsYoolLBFiAIQiFWdgEStiETVAFVaAEI7ACMqADSjgEQviDQtgDg1MEpjAFXTAFS0gEQFCEO3gAb8pHHEpLAQ06ynSwK8CE83SGXBCFLbrDGutMrgvNhFzIzpKEdlKEJE1SHlPN3wkeNVoCr8jIh1qSimqyuVjAPhpJ34QmZ5gFQ+CI7HoPebsT6jTT79ir/znqiGFB02KiuA3Et/jZpP86iUboF05IhCRVyqXUhKshhRxwEK/yyJ6gkBKJLWx5qLEwihmIgRmogR2A1B2AAiiQ1CyAgi3IAjVCAzTSAz1ogzsA1auQtjkgmD4oIz3ggzpggx9ZA2ujgiCYgkaJSwgIgUEYhCHA1RAIARcgg7q0y1CYUEqgAzooAgq5rW1Ug0wwHb2okm3CoaijUX5UiyRbFhVQg0kohmvYBmYoBVGQR60rNq0DV67juhpDyH+qBIY8UqZop6eAChsZo4FxUiDpCtYSwNgiCRSbEizFx4/i0mhQBk6QgRT4G46DRQKZsBYiQALElmu5lrgrgRSIWP95+QB5EYtt2zbj8Qr9oYEesFP3u4SmiIRd1IRb0IVV8IRMOIQ9kAMxwr8QxT9DIBh5nQM/GFXgCZ4g0dke6AqF2TYYmAGgSAGeoK0NgxJufIu2UtrUiQssVTNaHYIQgAAEoNqqpVoRCAVKCAFKGAKuHYRFWARCWAEZkAIamrsDqDJo8iG9WDlw2U/+ZAnbnAENsFZIAIZo2IZt2IVSGAV5/FZxDVJOCFxjq7FN+Lpkm5E+XKzP4rFnk1fg2Qoh6AEaoE2HZUSLYR0qiS5/FQBaoDVA0AIl0Mis4II2SDs5+AOriFmD47GBigrXTdJGaEgZoT8cCzunYAqoaIQ9+IP/qIAEY+OESLAERyBNdBKGMrwEQ2gDISgBG5ABnfgrAjyxirk720rapk3L7M3etdLH6BEn6emmyfImtOIhBIDaEKhaArBaqh2EUBiCW33frn1fSiCERQiFGeCj2OlNAVjbQWIrpJ1W21QBG/iAHdACR7iFaLgGb3iGWBjDfvJRwJXgwa1QG+u6LFJIsENcGnlIiDSEgQGerKhXAeQ2JcNccsNHZxrJVjiOVTDDkHUKMIrZO9AD10SDLIDUopgBnjAR9wy32rqttrReGtpeGe0m7emA0SGxSFisSDiiS7iCDKAheoJR3dqmK+a7vxgMa+LiLgYAATBfqYUACBCAZzJf//OFgPblWkrAWgoV1k1wAfsthCxD20K6kmdtW7fdz/5MshQYWBnQAkZgBWeohrxlhlcAMRuTMXN1P+8rtkd+v8QtStDxurBT19EZu8aVVyDhgih13tq8Fo8MYrdguRzqoz86hcN6BD+IIIcVCqFIslh2RABFilJuHe1lK7UMJ3HamHqyrA7IoZFphHMiseKdBByoZSsBmS3x4mZ25mceIjAeYwQgAFqlZmpG3zSeBfelhEWghFmYBWHY5lD4hE2Yg2elk7FqMbRcHQBmCaeaARt4Ki0gF2WAhmvA52RABRD7TEgmV382NkmoHfkjUn4pSg1WNkjQMYDpsT0YgzXwZP8BnDuizaPIoRJJnMRJeARGcARDoILoPdSJGgkrjZIE2IsDkIuUTkvjih606s2Oqixswqc7+CckgoRHgARMgATGnCZo9ukgymKPGYzY+ZJBWmaiptppVt8znlo0poS6tF9wBmdhiNCsxQAWowsBEIEFKADhGq5spFG4nVZXUwFHhYIY0IEzMARQGAZCnoZqqIZlQIVW0oR+kkd/FldIrh1+AQUQ6YSDHNIsWsjZrRFn++AzUiM22gFGvU3aKrCVLrcB8AAY0AlsmRwChYuUyxgL2WzOxmWMkh6zsiKRvGO70J4GyAA1uARSgIUNuQlg0IVT6IMOEFBwKuLWkZ7x1e3/3eZttQpmcFla28oADwABoMABHOCBMqgDVBUEREAXTDgsL9oE9D3jpU7qMZbLqR1jXdXV+CWDH0gAAiCAZhJvEUCAllOzuOBGPu4JAa4BGwgCNJABJWADQ+AEYFgGxYAGuF6GVgAxUgBwCAbcT5DghAQFV5AJV4glTqhQwwXsPSxKHHtI3ZmKnN2KxY6BiQ7leNpPlbOSDcMjSzMwAGvLiikRATaKDG/UjLzYp5rSsZBoeXGqGVcBFoGXDBCKGDgCNWCETlgFWriaWqAFBfeDHAAKD0CRV1YRGDjuHEjuOsADPigvRCCqI3ruVnIlUjgFVEAFFrYFkwWGMAeGqAkO/2VQhmU480pRc6dkczZ/hmmYBmioFDMfBPGe5qptajQWb/G2WvXN8zIWbwN4pgWYWnbWxm2MogB+2LIGgiSggjbIASWwA0QoWRdkBmiIhrd2BlvAvlMAcFL42wgW10sYthNdBmdQhlF45AqGZHMVTfpzCoH6YD2wAzTaAiVYbCPzCAOsGFKOnjMogzJAgzXSWVzfgRxA9mTPgaLIgSPQAR1I9mfXiWmfdhVpVB3YAR/YgSu4Ai04AzWwAz0wVUDog4IzuEYouESABOGVJUyoMSwHMVMwBVVgBVaAhXunBVowWWEQhqopBjM381Nv8zbX74I3eIOPhoRX+GhQjIVP+P9pkAZomIZMrwY4x+eER/UhgCYEkNrrFuMxHoI9p9pqvuaq1RLx5l8CCIBpjou2aoBFe5I+lhdHtYEl6II46IMdwAI8MIRMMDpKSQzFqAZoAIZWAJEA91u7VnrbYYViuOdoOIW8Lsi8/ucLTlzcYWhyPyN6haPZHIuJsrsrVYDjxgGgaFQdT+4ySAMox4MpZ4S3x+nQwQRWwvItAoVPl3dTOIVVYAVXuPfjyPfA13d9N9kN2RBXUAVwzvdbGPIFegUPcQXC14VaMNlcuAVg4HeZIPNjSHM1F/iBH/iDd/hogOvSL/1rOH18Vn1sYH1syFtv2AZ8VoYXEHldTepajdr/EKhLlKfmapbL3ieAL9GSlBeAMe6qt3gQRR+L935vJMiCT90DQNiBLegDRJiEVbiFYTgGp2wGia+GaDgGYIAFVDAFpFd6uxbcTnCFZdDWa2gFrSPwTxBcpZ/gzkRIsPMseJ2KO2CDQ5TcjQSIFAI7dLBgoUEDVKhOMTy1apUrWLBo0apV8RZGXRozbtTFUaNHjLVqYbw18iTKkxVhjbRFCxYriBEp1nr1KtZNnK9s5bIVCxeuWLt4EQUWLBgxY8aQJWvK7CmzZs2eUa1KFZo0adOmVat27eu1bWLFcuPm7ezZcGrXovXG9uw2YRwIEECAIASEEHdDDAo1KMSQWbMg/yAQUBfCIBQEChQ4IABAgMgBChiGAGHBAgsPHligQEEDaA0fUqiYYQNIkiBU0LTZ0weQoSBoACGCZAqWrmHLmkqF5tXZMFirTpEqTgoU8uScPHWC5Wybt22vOnkC9QkUp+vJt2/3xOk7J02ZLlWSJKnReUWGAO1pw4bNFiE9bMhQYV9Fig8aDFpo5f8hgKis4p9/CimUCoIJpmIggwqdUgqEEUo44YSoUFiKhRYqmIovHcoiyy4hIjMiiclIRVVWW1FjTTZllYWWWvLIKONaNdp4I441thWdWNdEE40zzoSCAF103WUXAnmF4BdfoQxJgGUhULJJBI0dsEABizE2QP8BAUB5mQMPKNCAAw5QYEEHoH3wgX002NBDD0pI4UUcc8zhx52BJGIJKKyw1Asxxzz1jG/VQLOMLQsxZMpxyH3yCSegdHLKMWFVU4oonYDiiSeQVoccp6FyCp4m4mWSSSXlmadIIuv1cYcaZmSBxXz1rZnfBx1kkMEDDWz4K7AJypLKsMXG8iGyyYa4rC+/BLNUick8JdWJVWm1FVdgxehWdG7lmKM83+Z4FjdjXVONNM80w0wyyBjjIYKYioIJJo88kge++PKAAw4xwKDBAkYSYFiSSN41BCWUhCLYInWFwNciKBxwQGMJMEZxAVx6iVcEFGRApgSfrflBCW3SIIT/FFwswYUXcuRpiB+BGKLIJKCYwoortvDyrLRTSQPkMcDQomhxjj666Si2RLONM6Nkuml1oUItNajgfbfJqammumqrgPCBhx3wKdHDDPfhl+uuGfyyNonRUlvtM1mlWI01dF+DDd7ZaLP33t34/bff4IATDjjrrBOP4fHMszjj88z4eDzxPC4PXDtabm410UADTZDLeA4ML0G9ksqDndBbr72PCMKHvjjAAIIHscvuwWa1b9YAA7RvxgCZdgksgAB2QTBEwVDOoowws4RCPF+UDEI8YwUYMHFjjE1mWAgcRKBBB5ypSZp9MrwppxdjtHHHHoDAZkirMzdiiSemLNTK/087G2Pi5sscU4wwt7y0SqOs84nqkGIUulAGLagDqqhxijtGe9QmlkOqU12igpaIhCMYgQhBCEJ9eljDFpRgAzfRwD4pAAFBvqHCbwiuhS4s3DpaaLgZ0rCG47ghDnOYQ3ac4xzoQMc7fijEIf5wce3IBxLxUQ970CNczehQKnYhi1jESxTzOl3q7IWIDa6Og1zkQyAC4Yc+cPBrdahDGcpwhjJc4Qg6yIG/XgeCOdKxA3MkiK4ygMcMVGACRCrSwOqSpCEwyTKDUIYyBLM8BCBsEcTT0gGmN7FIDmAyWQoBCiYgGguIpmQycNP4WDaGOeyhlDJjnyIakYhEoMcSnP8wxYNQ0YpX4GIowUhGkI4hDGEAQxfC0AUtXGEKUyTnE0UDxTEdlZxPcedRznSmdyaYCfFcYhKQYIQGV8meNqxhCUpQghBsMIMYCAQE/ThnP/5xj3u8Q534eMc93PEOd+CjnvasZz3y2Y59toMd/PxnO8ZBjoGS4xztwEc6EirPebrjh+mQJ0RxKER5smMd3kAGvnDggXzlgQdl4Gi+PoovPJCUpHzoA0r1oNI3vMEOdqjDG9iQBjWo4Qx2UIMWnqCDGsQgBjoYZ0+DGtQZELUGMzgCFmrggh9AIJBFSlKU+vIXvggjkSRYxCwGMbwhWEZLBpBkAhJASUsSADAc2ID/CkimAhacbAlb2MIazpc+mZ1ylYpwhCQScVdJuJIUphgFhlBxk1oSw3PF6CVGdtlLWrCCUcZEDqOK80zkjMKBxXymMxdotfBoAhOWmEQjGgEJVQaiD3pwDxvWMDb62Ocf6Xyta2ML23/Qtra2vS1t71lPJOqjt0jMR2/Z+Y7huiOhwz1ucdPRD+HeAx7ucIfjvCEKfsEABjy4Lnavy8YrpPEKbdRCG4/wBO8+QQtaOMMa06jGM5iXvG786TjxkwIYCOSEdgSBUIs6Ayj0QAgvaCrwBkYwywxPYQrrCyIp4YKFkUEvglwMlwYwsbBarJISJoAIrIACEtigZCdLWRtC/4y+9a1Sr6nEq3kagWJXIrMTowBsKVJxk2HsLyQUAQaOgQkTVSTHOMf5RCiOVsDKWlaAk+WOqL5Dzc9a4jxdK2V7vODNHcxABvr4x5WzjOUtZ7m3Xv4ymL3s2nPiFrfoPDOa0fzl2DZxGvcqAzmzy4Mc0DmnOtiBOFOQAYMQhDQxkAGddfDGHPCLqEGlLwjqi8K08YdXm3F07XaFpg9UAAEAuDSmveQ7AgRGMJ5WZCiEMYSnLgBjFisAhTFzAAsnIEnPewERTIMyL0B5roZAZSNSCQnz8LXJ5qmEJTThCVJoohOdEAVgZVkLHJvkJbjxiHBWoYppM4qYkbJOo4ozCv/jvHjbySyyA0cVnvGMxxKOUOV6ANGH9mxhCT3YQZjj/eV+6IPe9q43vu2dZtnyG7b+HnOa1+yPf9AjHL4QRB3cGAMzlMEHDvfBEdy4AyCowAIKoBiXDpAABTBAj/dNdB3xmEdI404BJj85yhmQ8pI3YAGPwTSmCUYXCGAVyMqIhjKckchFCrLUFDtACSiWAMyUadUDGECrEUMHIjgBCELgQmvmChu7ivY8u9aaJS7Ba2BnYjmYKNWxRQEhW0DbFa7wU0mEiZzimEIVq2DUpnxcNG7LHZk9TmYA7Q61cYfnEk1G9623CZ8lPPe4x2XncwsPT3i8g/HqcMfjH894x6v/o/LmMEfkIa/5x7ujH86FB+hBr3l47IP08MAHOv/hjoHTQ7qPQAQg7KAH9anvNbRPBBdSkIAAXDpjRzcAAzqQggeAgKc6MIMaXIpaNGwhC87PgrvpI4P6lKD6JcsPrsxWmhMs4I90AR74L42ARajieMo4BjR+NAsM+I73pZbeJCc89AUk4OiTscsgBkEEK5wMrq15jcyUWGhBwmg5QiT0WpMBmyVknbAZm4vBGCrUAk+8gtnRwi1MhCowincQ0CmwQkwQR6lsliZcwqlkAgNqgnIYGzNdx9FgByecygiWR7lFgiq1T2ndAXzASeIZnjusk+GtU+gFoRCGXuVlnhG6/8PkNV4/lN4QPhfoMeFyLWHp9QM+yEMyvB4i6AEf8AHtoRTtGcIdjIECQEYADAADlIEmPMQoCEIOPEAH2IcYdMEZ3MEdhA0bqAEaaEEWnAEamAEW7EAOGFWVaR/42EdPEZUNuMAL0AEd4AVh2MVjBIAAhMDxOMOPRIOPRIMjYIaABUCpfZXGpdoCOIAEOADFTEZYWQEl0IEVNEFcldL64NoA8toBLqCvKWDWdZ0DHhtgncIrwIJCQAQsnN20kcILXgIKgsK2AdaLGVukHNO4weAINsqnjMKwWQc2LtMEVUKp+J0knFuJrcceDJ4/AVQ75FM97FM+NdcQtqNzPVc7uP9DPMZjPbxDPd7jcC3XPBnePiKXPtzDEqrDPtyDRZWCILyeHZBUF9peH+iJGFjcxDyAM1gOMBzAA6hACTTBKNHhS71UepUBwzncoOXAOBmafFVXUOWADsjADdAADdBBwtABYTwiAogAJdwckPyIj1zDIzyAA2AJl/ic/BGdBGhA9ZliUC5AC2zCIdCBHIzY1OlVaDkCJNSir9niJDSZLeZiqYCdsUEgKgDD+cHCKbSdKXiC1jEgJ3Rb2L0YKwBTBp4lJ7iYJ4QgMg0TMa3dj2mH3Y2KJ2CNkpVbAaIbIJzWGpTjPyEmP+VT4SXh5DXmcyXUPLoDO6QDPuLjO5zTO7T/gz3Ko2fOYzvoAz7cwz483jqEgzSoDiMYQkLWQRfSnh60ykNe3AHEgObswiNAwzZcwyioXAmMQSFspEudEXqpVxnwgA/wwEhWWZX5CznBQAyQpEr6gBCwgA3YQA0EwSEw5RAMQf71hSpcouak39JEQydkgASElQHQnyiSIgWwiQ00gQpgiQG03AhsAiUQAilFZSqpWFWax1YG6CQgYAWVYGcVGy+OQisAwzH8iC6UpSl8gtZJAgl+xy4imyvoQi0Qx7Y9SCk4jdiNwqT42HZIljEdByyhAilEzXJ4x5JFwgUR5h7cwQyxQ0VFDo7maDp+Jo9WZjxWZjpwXmQKqTw9/+Y5TV487eMOvsPiANE7nEM4eEMq5IEglFZJ0R6Wzp4hqEBYGV0GRIEBAEAkjEIGGIACJEALhIIq/MEcAEIdqsEanIEZaAHyzSkWXAEWHMEO3BmeDaIMFNWe3pkQ3MAKBMEXwAEcOEIlqCl+OsksCAMmfgWQLMNzeIMy/AsFLIACsOemjqLIqEAPeMEfeEHQHUADdMAFGNgf3BoriVYkvGokZGWAbuUkyGrWVdDp5KpXnkIxWGI0wMIoEFMm8FXXWehXnoIr1AIqWJEVxViMpUIwMAMyDEsqQAhx4F3ekUKGAsOGriiLvqAJToI3OoJ6BAIg2Ci6pqu6luNnpoOPuv8rvFZm4s0rvc6rOsDDEiLhO9Ir49mDPfwQQXpDNTyCHviBH9zBlWIp7bHBHTTAxBzdAACA/RmA/SXABCyMKoTCHwTCHITYe6AByLIBGjxfFkABEnzTahEVKLmkS14ndoaBHiBCJKCgKiTPo4Ta0pjLeEKHN8BCChwEmWwcZoSMBqiADChBGwCCIhSCHJhiA6iABtBBKDDlKqGHeUxCrNrqrG5tBfmdLeYqvWjCKEDqNQwDcWDHeHQlJnRCsZVCRKDCKHRWs8aYL0jDNqzFNjyDL1QrhBzHNcqdX4mlzt3CKXRHYJLguKqHIVxeQiXU5T1u4zauOaTD5FYu5V5u5cL/g+Vd3uZybhGS3j4wIRJq3g7egz3gg+aqg0XtQh4UbByoQR0oJJa+RiJkghI4rAFED10MwFdVkgC8wKMKhipQwh/IwRh4AfJygfJygRR40zcJgRI479i8G55dJw0Q1Q7saRr4QSJIwieYwqNWlTCUnzOExVjs5rnAxTZYApo0QKaOogRcQNHugBLYASB0b3m0QJh80g04ySKc264BqNZurS167QJa0GfVqgIToCVMikR0Wwmeyul0QingDNwaG7NyiDR4gzzQg7/6axOFwzMEA986jbexXXGsAk5GwzKsQmUdk4uWYOImQjnUsA2bQzlgLuRhLuU+budiXuVpLg7X//DjFjEQgx5Alt69gh5xyVM9zAM7lOY4gMM2YEIa3EEc2AEasIFLqRvt7cHMJE8c0F/GBE+XalyaBq/yKA/TeoEYuDEXUIEUiEEcL4EdJ4Ed7wCc7PEOuEl/wYkSYMEbxOwlxE/NFkMx5ByQQEN0lEu59Ij6qkJacVKZfIaHbUHSzowkZMImzMEMZIAMyMEKbMIsUEIlQMIkpMoC1ioBbyUCH3DXvqoCp87XGRsmZIrpeNZnfd0oWMgVHVsp7AIyTAMHd/CVjZlr6YM9UM40kDCEIJtxMMopwAI0nMs2/GplwV3VFGsMfmMjGHG8hnNl1oM8Rm46IJ47HPG88mByPf9UZFJmZr7DOcvTOilRO6yDB+8DP5BDODBDHnjhurkGe3zhIfwBKdycMgyvFXzAAlTACJyAKi5M8iyM8kztHJiPGnBxHm6BFmwBFnB0FjwBEmQBEgCBSQMBdhZVENixGGihzL4SLQjDYdFYzkKHjbTFjzgDIghEBnzATzoAJxktqCLvHiiCInxjH9QHqRIBkEmCqnwjgG5lJfidKvNV12JCBE/TNT0CJLxeGSHCI2CTBnkRWGNCM9bLLXNIM1yDW3QwPYwmaaLZOukDO8RDNzSDLGCKA5YKJkxCKZjvNU/HdgyQklGTquRaEdtoD6FrDy32Ptlo5CYe5QZx49KrORf/nj8ZVD/I80LBkz7hsz2E7jdwgyhcAUqhVCmdNu0FwqrOAs4lUvk5iWzP9mwLbygcQhfc4RnUlHmZFxb8NhY8wREsQRKcNErXgFHVgA0kQRfMQSDURiaQAm4o1jEsQ856i7eYxW4CiTPMAhLIwBzJgAY4QJp8wCddpxTsgVQ2QiRAQh/sACZrACXMwiZsjXlAwqxONV9pjSpnAlZnNSp3tQaBtVdv0UGqziNMwi3TiyhEETNQg1mEA+LMQz0BIeiGrhTuw2bXQzx4QzbgNS6zrX//NVw4Qykk06NE07iRh3k4wg1dXg8NVGPP+IwrNuNedjub840/1HA9VEIBZHEZ/1467pM91Ns/iHBHrRtqu4ZpbaEgwB4g0MI168Im/AWBKckgKEwoJIyWP2ooxMF7sBd79TZwB/cTpIZxY2dyAwEV3MHMQEJ0q8It7BIvLUP6me9ZWLOPLAMiIc8mIDd+KAHUkswK0IAURO+raHICQ8Kt7YEXcMG0oQqv4bcCu7IBd60Br/IkOIIlEKA11apYZ5G9MHgwNwM1bINZpIU8xAM76FPh9eA96Bbq0ds8nKY3WEMzpEKmKJkoRANcBEMpOFCKTxCLS8KLmwNBJbuyy3hjg7M5P3sPVzZEJVdm3kM6NPE55lNv/QOUpgIO5ICSQ5n64MEWwkYg6AEmhIWQWP8BXjxMVGl5wjhq+akCmNuBmGsBFuC7mT8Bv6P5SWPnaSRBnRgCXkXCK6kCRfhSVTlD+nnFbm6DV1yDM7TCnDuDMEjCFKCGDcgBDVRfoT8dF5PRJaBypauSIvyBEJDyJ/xaVGstpr+8f3st1lZleyvwJGgCV3e1gmfwL0iDWYCDPHSDWwwOPdDDPPATOyyUE9fDPQHkcNWDCg1OPFCDMZSCpkjKMLD1M1QrkV3WBn5H1pTHOJhDDg1U2ROUQDE7sxsx20Mujvs4OnTePcR94mV7PaSTPsTDNOSB6+CBHtTaa+jBa6xbaSFCgzqDKZAAAQDAXSx+CFjBIjjqRDvJJoT/gh6cwR2eV2+D1xXwe+cnATjtsfXaAMqMwR6sKiA0Qtchkyr4UiL7ajR0RVc8vDOgH5CMguy1gRSMKg20gAvcABfIQfpAwgH1NSlMwnhoXa61wSEwalVXOqZnHb10rSWMR62+qiNkPyIwAleDbdipNTV0QzxIOBNF/UDFA9Pjwztn+zk2zjqiLjyw0z1/gz7Qw13HgoiSQinwAjHo+q7nHUB88jTQEydOmTJdqmTO3DiH48ide+iQXMWHFTFGZNjw4UZz6UCGFBnSHch7/UqCdNeuXb13/f7Zk7cLBwwYdvDs2TNnzp4/OvcA0tMnEB9YypQJI0MAAAAITOlQ2rTp/9MsVaGwWlXVR8uZM12vaLky9knZJ1iC9Ohhgy1bGTPg0rAhBEoMHD6uqAHE6BImTaJGlTqFijDhVLGOQbvmzds2Z5js/Plz6I8TIUSKeNkTiJGwY51KIcU0KRIkSZAcNTJESZWpTI4sWZo0e5KlS7dj57Z9KSFt2pEe0caESZSoUrGMSdsWTp48evbs6ZOu7xy6cy3bobvn7l33evjqsYwXb175evX+9esHzx33e//00ZNX7VepUcWLj+rUSRMpUP//+0RAgQzSBCGOIMJoIorIAcdBcBaMsCOGQqJwpHTM4U4dePp5hySW2nEHJnmweQQGEECow4479LjjDp/okP8jKED66OMOUpBSZpZNRCAAgRcGmUVIIUOhSpVZhNERka6+0uKJsaA0ywcg1mpLLrZoiMsGHWLoMgYdtMADkDrw4IOPPMzkQ5A80MzjEeISu2YbYe5woohDKBtDjDHuACQRRCbRpJhobhnlllswkQ0SRSRRpJFPVCHlEtt0u+22hGLjDSGELpktkk9hm0SUV2T5JZlnFguHueboeS66f2BNL9ZYuXvHnfPCA7Gd8VhKD559gOUQ1vjk2SaZVETZj7/9MCHFWf8ABEXAgQziZKJzzrFIwgYdFEfCh9Dx1iGPNiLJnYa4y7Cfe1RaiR12zulHH3mY4QHFDOywow0XX9z/gww6dOpjqD0swTHJpEKRisghNwnlSGWiceaWRrxq8ggoySrLhyCEUKstG2gImS21elChyxy0sIOoOsw4Aw880OSjjCjKqLkMHvIYTpRTaPnjByIKkaQRofoAhDNLboFGF1FscQaYUU4ZzRKhK2H0SFMsze3ShC4t8BJIGklEEDzOKOOKmnloZRvGVm3O7VZdnQ5WmGZFqb102GGppJV2jYclfNIDdh/1ZsWHnm6eSUWT/ThZ1tloo522IGvHYShbciD6RvOKNs+InHXWGUcccR1CZ1wLMfQopHLKMUcdd9R5abt322FnHXb6sSecWPKwI4eb7NijxZ522qPGGoFC/4NnYaKJZhZKsHKYyFCETDIaZVTRRIs71LhCBx1QxviKJ6b0+OPzbehhiR12yCJ4QAxJRP75GUGEkUkcicQRRv8URBBEEBEJP8yBDHwyBCDKBChG6EIXoFnGMkpRimIAYxKCYEQjAtGI/V0CSdmTxKQ61QiwZYIToOBEbBIRtjGVwQct9AGKePCIVMnDHvWQznjs0aryjIcdfmMH3nTVDvDYqj3ccQc87vEOlpwHH/gQHLDw0RIn7gMe7VhHNXyRrERN4hEA8kSAPhEgahnkdNoih+Y21zkHYSR031IdSD4CRwqxznWwc8c9kkg7K65jXtt4BB7YkIMYqGgPLOrXHP+GMpQ+AMUUpwBGMZKUsOjNIivVy5FVOLE9J+ngCUcQC8bIR6Uqoe9jPdDBDsxwh6LFD4CIMEQgAmEIRDSCEYrYnyIUYQhF9KGWiTgEAb1gCD1kAimimIT9NCGMYpyiFMeA4Ch0gQkLpvCDH0TSLE4Ym0nchhMFQWEiFMEGPbDhCi5kXwdwwAMeyGJV+LhjPdCBD320ZB7jAR3o8saSd73rPEX0Jzy6s8R64BEeBS3oPaQYrCrGAxvGEIUmMAGJZj0OQNCSHBm3hUaNPmiNFVmH5zBXuXJhCI6pI9fr0sEdfYRnn++iRziMkYc37IBLa2DDvlwkBxbhQQ94QN4e6nD/CmcuAynPi97DhCEkpCTpamfgyhO+NwPxjQULohwlKdmyAyWgQZWAgB8sA0GjogECgIFIhB6SIJRAIEJ+hfgDGQjhBDkYQhOLiYYmBOGJYqgCE8BwBi5EMQxloCKi9ktNJCwRCU7MIimSysTiPJEo06QgA4oAxBbEsAWq+kCrH5ABDnCQB2k0pzzzqB0e02GrXd3zdu9i7Tr0+cOUnmtD6phtrQranXeE5zsKRWI8uJEMUQxnEs96FuQAZBCGiO4iZ9Toc78BDs9JV0EitRC5KrSR1xVRH1F81zx6KA9uiIIPavhSDGzaBpzKoQ04eZkegFKGSTgDGs5I0iwWgRXo/zHWKksdkpDOcActaOEIR8jBk6JUFo51jGRXtZL61sAi+B5PYC7SCSyF8oEFqKAJcpDDH+hABxSg4AVEIMMfICGMa1xDmpGYBCiUAQxR5MJpnciFMjDxCPuBLRKdyoQqdJGUVZBCE5/6oifYcISzrkEMaNCCGWqGBSXIIAXp5EEpvCEPcMSDHqYNkRFrNx57vhaf+wyJOlyH0tv6k2/t0O07DLoPd9jDG8woBSY6MYpRGBdakCvIcknHOeh+Y3SFfsjoIkQuj1ROJBZqj62aWM91iDkczzATFmYAA/TetL12iEMc8nWHfOnEDmbggy+qEY1jJHUQlKDEIRpGvSQldf9hwhinGs7wPR0UuCwFLnAQgB0EIAwbCB+rwbFroIQt7EsPzRZYi+6g3n3NYQxcKEECCrAADixAAAjwto8QAAFCEOIQlmikNAWRiVt0AhXLOMYoXrGMXHSCFZ24ICMuCAkXTwITpxAGMFaRrFUIQxiqAIUmEtGHLFAhC2Op2RXMkIIUxCAHOEtGOMABuh1yuZ4+DIntyFxm2bbLzOlQx8m3y5LZ6q2ghKOHNxJnHMHYh6J+9gSGJoKRQRO60KRjrui8peiGcOQjd2udSrqzEnxIejzh8EYqyqCHI8wABDFgA6fz9el82eHq0m5DGVAhjVQXfBCLKPtUHDZrq0hPGeH/ZAMWdAAXXnfS18EWNrFtgGy9K1u9LKrR1ddg06t7oQklmEACCJB4BAQAAAH4tuIHUaShQQISrZzELYqBimYeoxSoUEY0EeEIADbCfqXhIiYiOApXIEUXsJBUwhcOhSeokwdh+cAHVDADdWJiG/KIB+jsKWaP2xZbIW/tu9KBDnO0lB0leSPyP8IOdISIQ/6AT3OmIQv7QE3P//FPn0HhieVC5CI753nPgQ4RB42Djosm+mxJai68Ge73TZeGINSwhyOcCASB9z8b4kAM4uDq2EAN2sALvKAIoAATnqEariEahGERzA56okd6sOJICM4RzuDtTmnXfM3XdgDYiA3v//JO72pAfbYgvQpwfHbAB5ZgCdRCww7gABCAAAJAAARA8SBgByEgBEKAEmbhEybFEvjAfjLBPoBhsFDhGIZhFFBBF47pER6hfqRQCodjOJoGGo6hFlZhFCahRZCA4a6A9mqvAzTgA2zAB9TJF7hBVTLu90RO+t6lOrDFtV4LXrDlHO7pHGSLIdAMJH6oXPLmO4ZFH3JoHrjhF1AhMPis5v5j/EIqc9AIHDSq5ywxQSyidRYN54ouddKhHeIPXubBHjouHsIhFXhgDbZAC/gPDbgADdAg8D6tC9SgFg1wDHBxCwQhGRywGpxhEyih1SpwkgjuviRBDNoACr4nBnrNLP+OYAdG8GOKzQSPrQeUQAmQAAqOAHxm4C1ARgZUwAFmcAEWgCkEAAK+zQd9cAjYcREOoUg0ARE4AxEg4RZqQRSKYRk07xiAIccYoQqn8BEo7wp5oXmcYRhyIWogAQ+0QAeQAAlmT52i4AosoANKgAZ0ALQEoRqyzEFup3bQAeRaK/mSr/heKw89CnT4MHVYp/38MPraYR7oYTpoUryMIYJKgc+QyxzKYSIsURwoUXO8Bbo4JyXX4SdHR+jwxna+jCVaRR/+IR/iQR6uIQ/O4AjQgA20AAvUoAvEoAvOABbVgA24rusOMBl1IA+IYRvYck6kYhizIhocQ0hUYRMsYwv/ciDTygIKRJB97o4Eka0Ej+172EctdKAGzuAJkKAHhEAIWEACEiABwg0BcrAHQwAdIWAQBmEIQoAdB4EQFmETMqESKiFTJiE0bkGolGEVXMELr3CLZsMvOgEYmidihuEVRkETIGFsYHELoAALsIAsHjIItLGTeOAV2rDLoMMesmMdMm4dTG4p8TBb+JD5QM50xgEd0MGf0IwhasUd8uk7wGOJIk28kuHOFOISSihZGIcTWMcnLTEoIWQcvsG5OoeNQAcpxUHRABGfQqR2njIq1yEcfIEHgPMMpiAJkqALpqALHNQrxrIAs1K9rq7i8qAUVmxtnAEuoycaaGFQKKku/8mAC3ZAkJjRB5BA2NgHCZJABIct70pQMLeEMHeALWYACY6g2GiABTbAASQTHbvNMn1wB39wM4dgEKxgEYJmFjJBEiTBEhohUDRhFZyhC4sBUfhtOBACE24Dz06hGJwhTGPMFUpBNwXBDtBgC5bgGl8QCtxU9uhuB3CmGbphHaIDOkDnQdYBHWxrOjEiDwEV5MBFO1XCpJZPj3DlPASqiQyxG+yMSwsGFO6jE74IFFqyJw0N0URn/RbkPo1SP7GrP0EHRNjhOaASHcDhGh4BB57gKxSUCWC1QcGSSbwCFv1vDWTAB8rgERSDLYWhSFwtWClBGJzhE25BGSrQCrhgCf9yQOJWtAfYZwdS9C+n0dhqwAaAQNdKNGRkQFprIGQ2gBwRYAFqkACEVB0vs9U0kx2TFAg3oRIcIV4hQQo7IcfwDBJmoy82pVMGshNOwRVqgYFc4RRGIROGhg2yYE3V4hpXFEc/kAc8QBTWxlXswTk9ch3oEFs8B1A5tnS0841a0hyqc4mCqCXEs7terhlSYThGARRIwRT+44t48j0NzSc7aiI89XPyEylDdSnviXagY6W+oRuQIZ2A8wmYYAoSNAmStgsGbMBqNRZTcA0oTgf0gBai4RqQNWHKTgIp4RN0ZBMiSdb+YAmSYAZSQAWiFVrZZ0pGsNjOJzCjFWRChgb/oLUGZqAEfHRcy/Vc0bUH1dVI6SAUfvU0LqF+HCE4+E0gKU+iFIX0xArfJiETOsFlO4ETNOEShsYOElYJGixa2ecD9w8GkMEbwMFVyAykOPZyMkIiPNZQZ7Z19EhXwpOJpkNewOEZZAH1TIEUPiEUBEL8GKIn4dMhCk1jq6soU1I/J+K69PBn2UE6/qFBsAETYGB8yiJpmeBVk3bAgPPJ0MAMzCALtmALUuAt2KASIEYYpkIzy44S8mtDN0GplGoRmmAKZkAFVMAaGXZt28J80EcuaGpb6xZabUAFIFMyy9Fc/xZd1VFd2XEI3pGS+HU2HGES8HU2GuFrIIERAKHU/7CghdAg6lyJESKBEeRHERKuDbJAfRqMbU8JdHfgCDzgAWTIdJ+DzDrKKD8KpCJiQZZrI0K2Dq1ToL5DOvoBWO4hHqhBFlKhFEzBFCRHiBcNPsUBeUGqc3b2J5s3jqyDtd5lOsghHJgBB0BgfLBAC5Z2aWEVOIET4rIgjqVsC3BPBWzgDwhXFSLP7DTTHRmLAmcBApOCEqgACGqgBEqAwaL1lBwMq7KqRHMgB2ggkteCBjRAMh/Pbx1YHYcgGDfTCobACgqhEhIiEyJBERRFg0UoEM7ADEp0BiI5B7CgBeM4wPqA69YgC3YAb/f3hWWYpnTtATzAA3ZBVZ5jjULHYv9ZC6Q4SroSbeiGl47+lA/1yYgZNYkHRx/CIRuQIRVGQYq7SXhjdyPGJeeqC2fvk3kXZPrS4XnLDD7qARywQRQ8AATKIo23l2kVVEHdOIT72Y07IG1lQA6+dhOGQL/cd1hDIfKoR0gg8BOSoAZUoAQ+oG5DJgd0wJH/13xA93somQbC1dvKFQE2eUg3eQj4mB2JgAVkwAzWChKm5jRSw7JiQOI0TQZkIAfYYn9rdH1qIAvaYAt0uRtx+nN/uaMZ4AEeIA+gIRyeI7osQplBByOamaPIwefYryff81Ipog5LNlGxWR3gQz7CQWXtI2aFuBzEhVweAourC40wQp0HFRT/RXJU4eMcEAdiQQA4nzEIFNSv9/kssCALrnGwzQCgQUAFZEAIFkEqHBsYg3FYI7uSCO4TuiAJEFkDLDpkjq2UPMZz06djRgaGMfpaWyACRJoAuq2kWdsHIXgIXmAFVCAFUCQHlgAN7GCctIC2O6ADugQcFRun9RenZ2CXdQANsgAKkICoZYB/lSBakeCod4ABGiADMiAVvCEc9KF1lZmqq9qqI2SrHeJSK2JkSXUQFVU9snk5ZeIZYsE+vuhSqxjoEM3nvEUcfPiqv2UiTAdzQM4j0SM+wiEYzNiez+IJgI1pEzwJeA0KrvEaXegKYBkugKAQKIEQGLoCGQuyJ0kr//pABT7AAihgBXC6bq91ZBozxZXgBT3XYxBQqI/gCaJgB2ZgBcj12zS5tdFVXUGZBnDaS/Q3BmBA4roELmyUqENmYZdgC7Ly6mARDfwZCx4SuqWbfapuB87gEXpvnsgBvOqBHebhczJCuiy2Im5WUzX1IS51Okd2n3RFRAYnJp4yd8p6EYdDvoWuXKyLIsjPIeB6v/kbO5/XI+fBEOXBGzABBFKgAwQbC/a5RQH7GY8ACvh3CbBAfM8AL7rCDhShEg4hKoYxKX5XepLEvnRBEfKXAhxgBUi8xI8NCFT8wV8wxVO8DbhgC8xAC6IgCoQNtcnVR3Rcx4/U7IjgBmh8Bv9iAKffQga8JNll4MhL3G4XFgrKFxbFF8rNCXSn/CGjG3QnzgbYgA9kgYba4RzmARzexXR62MzFXGen+XTKOa1ZZw6J2M0Fylb24R2kMjpO4uXsTD80oWfjaCTY+ls0B9AHFSIGPeNG8aWeIQ+GvANivCz+OtgUtMFXfGrd6738IIOalAwoMHqKKimUwRmUQbCSIhOAYKIpoARYnQVa4EpoXQhWfAmkQAk6RgheUAq84Naz4AiAzQY24PFIOtiFfRHo4AfkAi6UHS6cnum9EerfIpZPyQegIAtCOAsOu4WAmUYHeAd82SZ2QA12dbQ88huuI0M4NiLYPFCv6yM8Ys3/57ClzFtv1GEfohId/AEd/mEe5iMWXoEwRgF1KiS7xg8+83u/sTM7+1tngW8UD70UeEAHQCADPtDu/LqNmaQLvIDZ+oAPAMF/1mqWEMLCQ11HWsMVWqEUjsIZsCkQZqAiVYAF6hYIgO3BZd3mlyDFX3AJuEAVl6DYSiACMBnYjT7Yh4AOiKAFmP633+LpSenpYTmSYxgJOGuwQ5izjroGCPNzhfzAYKYUMK4byvuH7mF1+bA6OdYTGy2OPIL5zhtEzuMd1IEftDMf+KEf0mEetsEXUiEVAOIXtGDpCho0aC5huYUMxzkUB9GhxHHfvk28OG4duXUcNW7kGC8kPXnV/wTliAHigZYnT44kScKECcwpU86oYcMmThw9e/oACmQoECJEjRpF4vTp0KFQTJvOejqLEylhypTNUhUqEJsZH4R49apkSZIlZMtSoVL25csla7aQFXJiAQEEdBGEuIs3r969eFGgcCJExowZMgoXHowYcY3FjGvMyAEZso4ePZRUXuIj8w4knDlDQbKjx47QlEXHwJEDR5k8eZ556/btHDl27eqdu83u9jl2tNvx/u2uoLvg6YIPPz68nfLa9Zo7xwcd3z14+0ai46funbdkqVLtkuaN28HxCc0xZJhwIrn17NdjfCgOHLiP6+Sv4z0vpLxwu/IciZHBA1ewdEQQM/8xMUUXXdxkxx1xzOGTIYgkwggijDQyiSWXcALKJot8uAgllCwSijAmQmXKU6qYIkkbM8TARYxNLLFFFlmURdZZaJ0l1ktIsBGWFCc4gMBcdEHAV5JJioDCCTfQgJhhUiZmww466FDDlVpGpkMOk1VGmRI7aNaZZ5+VhuYOMMCAGg9l8IDJNeHExk49+uCznHK01cMcn8rV84477ww66D2EvrNPovs8F12j+jyqTz/wuKONPPGgo447z3SXSjPdyEMPOugclFBB5qRTnkILpTeObq6e89448slHH63sxJNfOPJs80gZWczwgIAsPfFSggkq2KAeevTRB1CJKNKII43/SKJhJkiBwgklg2zLLVRNMXXVU5ewgUYWd9zhBRc0ZoHFjWbpyCNZSSCBhlsyRFCXAAIQgKSS/kKApAksQAnlDC1IKYMKgtnA8JaSbanlaDb04JUNloFZ5mZQQHExmj2ksCYPPPhwBA67bEOOOOnUYw89gBIq6KEyG3pPzTX3U+g9/ezcj6OQ4gMppP2I800z1IRDzj7SdFeKMdrYEymsqSbkjjrmqIO1eaqmOo45r5LTddjlqJcROhzRGlKu8iSTRxkfe8DAFVjMHZOCx8Zxx7J9+OGHUIkUBYkjlVxi7SemmKJJJdoOMkQIg1CySSiUhLJJ5VdZBckea2Cxxx5j/3CxRY3tLkHFFqWX3oVbWZSexA5bsCHEBgsUSUAA/IYwBOP+8oUkBy+80IIKMxSMsGA17NDYDjnU4KWWV46mww4TC8GwaKLtsPFnoyFxZmhIiLkDCKeh9kQMR+QhTTfatIprOzEfF6jMOdt8M8334MOzzUH/w3///zyKDm1gAxnWiIc2kCGKVPhCTpHqBzpOZZCsMQRr56lgQ+AzDoiIY2xjy2BEwjaOdrSMHvpQDj28IYo6tKENSrgCD55AOrGQTkFi0Mkd5jAHQDTLEIb4myMkEYlqcUgVV8lE5BY3iKZAjimqUIUynKGKRgQCEGzowx7u0IZ6ZQEKoQsdGtZALv82rKENbKjRFuolhxUQqUgCQACShpC7QexuLxwwQQuAlzAVCO9FMehjDAbTGEBiaZDHc8xiggAERCIykUFoJGMaCclGMlKRSMhMGcogtyyUAQep4EY89PE/fTAKOnb6GT6cUw/oPMp/POvHP/qhqFe6kmf+6Ect/6cNaljjGcigBjaYkYpSMOMa3bDHKwsiqlGlA2vqKAczzWNBC5pDItEsxzS7BsF04GMeoGoHnuQhDUHwpC1XOIIW4HWWLtTQhjjUYSCcFS0gakgTniCFKVxRjFl8ookigtwiBrGIfc5CGNFwBi0skYhA3KEneyBjjbbYxTOuYQ1oMMMazJAFNKD/AQtKkMIKJlCXuQDsLnGU4xzvIrCB0SCPe/RjHwWjGMcAsjE0jaRNIXnIm+r0CD7AwiXn5lMctCYcxuQf/fzHSps1qlH8g+XOXrkP6rSSlrDk3zekUQ1s7EIWskAGMkrxC2Y8QxrrqMc/iOO1gmSKmVZDVTVXVZ6uVXBqqSqIPlo2j3PUgxzhkAUPrEjRcqJBCjnSkRjW+aAc+uSdz5qWI4JIT1CQ4hS3cEZVhIGVykFOFcIohjOioQxXZKIRCb3DGvSAxXJlL6Ia1ahFseCD0FWGCyRYwOxECrB+xbFx/mLS727wJCjZwDF/dGkf9bjHxMyApjW1aQ10Cl1IvuQJ/3P7KRbMUAYYeEAU3AgHKGGpqH1MdbxI5Z94xwveqeLjlfxj2Tqy0QxZJDAVxihFKVLBjGDIohnroEc8hlMQ2rxvmQZxB12zlk2E0DXBEHQH0OxxG1lZ4xF56IOysKsDdxWWhuu8ISD0AIifNBYSkKCWtSR7ilPoYhmWrUoxquKMz4LWFaSwRFEM0Yc7ZGGFZbSRjSJqhiCbwQ7lcksPlsCFInAAAkVy411yS9Lc8ZYvKHgBEbjQBCkoASxi0kFipjSD5IY5Mcx9JE5zGl0DNfIlMqGuT8sg5DJ4AAY8aAaoInVe6uhZUuF9KlLRC+id3YN/d5rHOrphjWBg4hHegf+GLzCxi2bEtxmGtgdbB9Uc6dTDHX96Bzw+DeqaBep9gmIrW0k9nHfcQ5TnqIg3fJEHcdrBDmUg2Y0Im6MunKXDEFpsD/8WuCBuqJ6mOAUpalEMFse4oDEexio0kaFIKMIQgGjDFlvbRYyGTsitvcPrYNcELgjhAvi63ZNzq1s4TjkvLxiCE+RgBzascKLl8sEOjnCELkGGMMrt93LL/NzoJgG6MlHLS47whCsE+ZKXzAAIYIAJbxD1H9Bh7z7wsQ/2Unyp6/Vfo27Gs6by7FH04CaiqSENUciCGcl4xi6CAR5Ea6OpV1MHPDCdylMy6h5Rpc4+6KdqQ6ka1ETPDsz/BKUzigcQHNjARB7wMOtLPiELYSHLmnNdwxv25Ce/hpYifngJTXCIFJyQyilooYtc6AIWsCgFtB2BCKHoUA9ogIIOYsC9jW1xbkpQAlBtZIYyilEKXpCCBhJQpH6dG92KXzfuhkAGOsjhDnbgSUPbcFEzoEELV8iMvpdL5sXEtMzQRfNNDa6WICBc4djFbhkeMGccICMcJEwlKMu7cY7jXuTkDXk/7DGPcGBDGs+YxjSawQxmcLUaEreHP2q5M6In6n71oIf1M/0PUQddZ/1QKnS4H95Ebb9QruQfOr7RDWTkoQ5psMMZ3KTwvm9ZCD0w0Fq6oJM5oJZZXO+6UYSo/wmZ4AiOoAmagAmd0AmacAmTQFo6BAhdZAMyYAMqMBoVaIEX2Hc0omXidngJQAALwDvothcmUGVWQAd/8AedwywWNmtipAbupwXsYm9YIlMzVYMAh2aH1FyRhHoGl3BXkAVx9noOBwOPsA3yYA+4Mg+q9CikNA9POA85x3FLtUo7ww88ww9X6ErtkA3S0AzIgHzGgAy+4AvP0F2g8krowDOK8lT3Qw9Q03Eix32tpDN3AjSAxn0042f9QA5MJwpu0gd2cAWdpwU+sATzJwRK8BJXh394wwbJwn+BsAchBggSkgiJwEPVFgiO8HWNgAhBsVB7wAaHSBphJgMX6DwV+P88O6AEW+AVXFACCnAACbAAivdkizdSjZM7L1AEe5CCKhhiPaEHeIAHd8AGanATalBRWTCDjDF6NvhcpGd6azZw1KgWMYGNnAdnQtgADdABMcADvwAqvBEPe9IcvhEPHYEf9fCEJVdyUPiE7FgPftY/0dcPV/WFXcVLv6CP3CBxljIP+pAOs7Qz5xVKQHN75VdeQbM/HheHHjdohBYOz5AHOHAudvAGZ3AGMUhY9McwDDMWZtEFrVVRQhZkX4QTDRJvbOADfbQEcSAG5zJvONEWXUQWlnGBqmhvktF3YNRRNLAABnAACzABKKAkjAcBQ7AIm/AHoWhhqBWKUDdrdaD/kRpJLjbiAzqABM4oemNmSAEHcDgVBNPIZjFRjQbCBFgwiIDHcFewA1LQBnmACdiAhP0QKX/GkPagl9bHl31pfSMkD4EZmPpRH93whb9gDL6AmMYQC8aAC6UQC1zVHbLADYH5KO9gS1oYSg1UVbhHhauEVBXXP0zFP/bQVzxgkbP2BmlwBkGmZfRHGQwzSYmUBJ+RGbf5dye5BmpgE2rgA4OxBGLABWMweVd0lRGFa9dTgbd5gT7Qd69DWCogi7Q4ASbwAkcJZUNggm3QLCvILJ3TBsNoB8RoB7x5E66FBWMSSKH3SDh4UwHHg2xWjWyGBVrgK673U5WxBXyQB7Kg/yuCCaABCqDhEB7YcA3UMA3PIGlfiAy/4AuSWQqiIKGYQKEJNKGlYAvAAAy2kAsUxhqxJgiPIAsS94Tk8A/Pd4WE1kCJ8j9TyISQEpqimXuiqQ/ygA2PgAMx0ILI2JpmcIiwiSZCgEg2AARAsBkWiAQ0si5B6Fo2kQVA0ANSkGQxwgVyMAY9VhZbQFigUYHfI39d5gM+lgU4QRYt4AC0GAER4DtwlCQAwwFFEHlyoEPMoiwriAd1IJ6Vd6dnUAcaRS4YlQVnBo04WFM6CJ/QdZZJ8AQm2ZbRIwRtwJ+PYAzQkHzJYAzB4Au4wDQSKgoU+giPIAihKggfSqqkygMfev+qsfYImCCho9AJowALazcMTscHgoAIgsAIn/oIv+ANzeAN4MAO7/B85fcoBZlxduii+8NxEUlxNVNxd7U2qAkDb3CMvKkF2rZlHpOIklSkm3GbG8NaGkVvOIEGSyAFXyEENwAE4SYFXVBGbuEWSwAancExX2ol7TI3O7YGSsCBDuAAFTAB1dlujocX2vmLk8gsfjAHe1CnesAHw1gHdUCMd1oHmmcHE3VRxOJINPVvhFqoh6pTi7hmWyCEcDYZSLAGdcAaqIkDLYsDa8ImLosDIjOzDBexEesmZ5AHiNCqomBf9oUKqBChj+CzqHAKqNAKuvAKw6AMnTAJj8AIF2L/CZOAgJhwDI/wDN3QDeRgS8QaKdyXe0pFP47Ccbanc9inDyckCi8LAm/wBryJFuyyBYj4FRTjFYwEGpmBBRG1BRj7RRSFsVj2A4P7Ay7gAjfQBE3wOqFDFjbyGRtzk/bKiunpA5pXL22wBClgARRwARWAARzAAj/ApngxsHRABw3FUD/hB79Ypw+bpxNrB4FnB3VwjFqABdXYlezZsV+pg2JpU6kHEwX3EhxzXZcUZDKglmZQB3zAB2UAAh4AvdHrASDwcDDLJjkgMtn7JjN7qqKwDMpQDMdwDMRwDLmgobEAqpiQCrFQCqhgC52aC7lQCgmYCZhggBTaCRS6XdUA/w7foIY906LSIV7I6qzSQT/eh5DISkqo9A/2IA/TIAgwAAIZQJVn0AVVsARzM7fo6hUUs2VrBgVj0i5867df9LdekC5NIAQ/QATAJQRZJgVSwLhLAAU+xhmR+6V9ZyWVS0YZJQUT+AESsAEksAIr0G5WYAVDUIKme7qTuAeGsAdTFMV/AAgMW6fMAnV6k6c4cQZXoAVMIKiOIWY2OFPOBbIGZ3+o13dvVgahozxvMjJnwAYe8AAMYMd3nAF5nAEdsMcdAL3UW71rgr1ClbTHgAmC8Au8wAupkAuo4AFyuao+KwqTUAq58AqjMAoFmAmTAAmT8LRP6wE4IAvY8A3t8P9KjQIo1HEnByx04/cOUojKqHSOd8UfPAADHfAAaVAGZ0AFSdAEGky39JeIfZeItYkEe9u3GKvMYDRRZISxWwAFQVAaHBw6jqt3N3yIHaVl8ifCZoBFZyQGXZAEMqABG1ACerQCN2CCZMDOKIiCviiJgdAHQRFiU1TFyqI3WfyUfYAHbBCxG3kGUwDGGyvGYhZI0giy1Pi7jSQEGcxwZrAFLam9WtoBDaAACsAAF43Rd2zH3fgAeqzHuLzHIIADiKAJpSAIoqCpwZQHp/qpM7uqcmm+rmAKoJAJj3CrgsC8eMAHeEDHOJAM3bAOoITKg5IPBnzA8jMoSKdqmXaOzqH/HA7MDZjwsrh8Sec0BU0ABe2iBEEgpEJaf4oopJCEzRG1zDghb2JEUWaQnjMwXNXjFREFBTRM1zQyt/IXOkpwzF20Qm2gTnGwBCrwAR+gMDJAA3B6gn/AQ/T8ToGQCJX4E/YcYszyiFKpLFDHz2gwnrRrwWCcg2GmR7t70IMUPdFTAzagSNIlXWrR0H5XBhylBDngAy7r1jSQAQpgALmt27stlAcwixoN3BfNAB/tAYwwCj77Cq1wCqUwChSWq3ngAZhQCo+wCrDQCZlAYhXCn6xRB2WAB1iQAWwiCkdIQrb0fM9Xha0kcgxJXioKmg28H80wqnVwBDvAm2eABmcR/zqpF7I8WHUxHCMKIuAKggZiRJNGxm80QDFkISNNMH/bbBlhMbeHODFHloHmCuBcUHhS0AOEYQOEJwedI+KL9RPdGWKMLc+TzSx2oENssCx6sJFsoAV9oAVIYG1auQMzYCWglwJ7tONf9hg5GRpDrtdF/j3fM9dh8pzQzC6DqAUxmAVbkAMg0ADB0o3CbccY3Y1VHiwfncd83AHPywOZcL+eDAlRywdQOxTMywihGmKCEGI9TbETiwd5PLOpoCvGZN75kA96eXv9EzR6KeicaZd3NUJ/qZf74Q2pkAd8oAVKYAMa9eQ2QhbCi8bWyARoQRYZzgUDLuAFDkZftAUqTP8DpQ4WDK7CQmDqXyF/GYwFP1p1m77pKIzCfS1GbQCeDOudlDhFvR7ZP/FheNAHV5ADfaAGWhADLbGRA3IFdnCtXHQ9XrYZ0bMDhyEDXqZchZEDOYkm8gcmldHqOLKkW7Qxc0NdoyEDfGwBD9AAd9yN/uoAHt3lefwAHQDm9u6ya0K90bvvzxvKDHdJ/wzwAO9wHnCqvhCYgg6Yb5iXgu6XIyGg+xEOEy+Y4cANz0BhfHAHSyADofPkWFCvPSiyacwEXYDhUhojXpBOAi4GNDlRoZNlHBwWUarqMtACLVDqNJCINLzVHLXpMQzgAO4FYzAGXiBv55I3ynIuPeGdJN7/2MAesVgMCL5Za3cXAzpwBF4SA2zwBPgNBZQROkgQPVyK7fyGGJAhAzEgA9tuJaVdGt7+7X0H7jOcPXUPBQSSlaOhAl7e5cEC0vOeAdEb+H+879JL+NNr+BIcsy2bvW7CGrXKCB3ABs8rVMnwn4E58RQv8QSqtdyQDdaAcgraDMmADMbgoBDKqYv2qaIqCGigBKVuIx//6ktQcL87cPNJOkCP8lxABQN+WDQpRjAfw+iKkyuVMEWsAitg2GFRwzay85xOpRpO9GOwQudieSOu4j4B7E//Tg7YB2yAB4FgBmoAA8j+BHd3BFfgcGpQ3zugMD0g9tQOPR8ZU/smGGy//4pvn8NKHiZlodebARBIoAyEcsTgkxxYlCgBkcFhBw8QI3ag6MEiCIwgLHoAAcMjDpAgc+Tg4aNOHT6CEDGCNAkTpk6jRpU6harVK1i1aunSBWzPnhgPPOAQ5EtWKqSiRL181FRQnjw8QuKAsdGqxQdZr26EwSOPmTU0ZMiAguXKlSdPkqxNEsTtW7Zrg6xdUlfK3S55u4jhyxcNmjVt2KxZI0VJk7uGlfSwoWJFiRWRS5SQQUPJEihZzJiZu4TK5715+4qJc6eNnTt6+qzuA8j169eGAsmWDah1IkB30JjZA0iNmjopZsyIASIGjBlYdGhZg0SF8OE7oOygvkOHjv8dPa6P5D4jB3br1bP3WFje/OKF5JGsr75+vcEjV3Sw2WHmCIgHHTDCEFnSRxk8UmLkkUkK1MQTUEapaZVWcrqlp2GEEaYYCos55kIMM7zQwgylKKGBrPjoCqsHGDDxRAZKRHFFFltcEYcyysCCBhpVwMIsHwwKAgi55lqLCbaYADIJJuqySwrRRuOrCzbYaEOwwpZoYkrEDKPhsQ0m05IGIerKzAw0PhOTir3I7Ks0PdhAbTXXWmPTtUACASROQ2TrQzU9AGEDC7BsizGHGFIAoYMMHhD0iBnm60EFGaobaAckqsOuB+p04I478MQbz7y6zktPiYHcExWJI9K6wgf/M7BAQw1HQPFElVVcoaWWByWcsEJlctV112V21fUYX5fpVVhihc1w1xI0cMCBFAJpoIEUVXSRRQWqtfaAAxTIVlsGrsVWgRhiyIEGRmWYwYcnfMjxCCB4jIvIIYn8cYoxydzrzDj6cvJJwrbwdwsuElOChhI2wCDLyFawoQcvNUNDL72W5CsOiu/Yw+LW5oyzTdjkBGQPQ1y74w4971zjDjN80AMLEFKAIYUHMoihUIo6UKENGRgNzzodsLDOhx2+k3S7kTLVlD2Bsgh1VIGWFkjUtJ64QosrNrvCkgl91XrrYI/duliwwwZbgwYckEMSCw5o4IBos3L77WcfePZZ/xQV6NbaarHVe1sQaniOhhRUmCEtdI9AQggh3g3yXSamgPjefCemON8noVzDX8K8SEwIGQzGYIQVaKTBhi4x08wMJfGd/I45VOu4ztpm8/hjO2y7s487jlgDDR94T8gjQR/KoIEOGsggBeTHGmuGHW7cIQt1U8VOXeqrE/rop6nLLFQoRCWoe0idjlrqzepokhSuc/VaGQ0vVGaYCis8hsMLl8FQbPx1OKKRS2JgAFoQtYw/IPEI8FqGvBR8QIEKJJRDHJiVBzowBTWwARCEsCPqRO0KA0GcjxTXFrcQyXGP6wIVJicGL3BBhX9hIRow96+79IBgG9jACoCAmCYgrv9pWeBhvirGujmccHKnscNPjPgxPaRGD6phw2/OoAY74AmKPssBDAaFnYboR3gN7IChMvABiqRgJDuIwXV0kAXl+ICHPhhj0IimA3WBZ1SQ4uF66pgZpXVvIDwcX6nStRktaAEQupDQMOBXIUMaEhiLTOQiHQmMYTAykZGcJDGIMQxLZpIYFMoFMHoBDEsegxiaAAUnzgADtzVAASC4wgC5A5LjFBCBsxRUB8AIxprZ0pYfqMFb5hIE60TNB+tZiAfjYszGPW5J9yKNF5zphRb+5XKX89ddhHAlyHAJcU1YCB41swXSRI5iYtjL5OLQhdM0aTC7Q4OalthEO9ihalD/dB0gDGEHGYirOB2QQQrCVbwMMAAEz+pACrrlEBU8QAY5yEIO2CC1QPqsPmtYJxqgB0eg7aB6TKNO0va4hT3mkSB8jJof1TU1LZRBE8KAZCKLQclIPlKmMp1kTW1qyE1WCBidDAYxgmEMaFwiEX3oQuBSACIGwKCKOMjBVERyKafiYCwxyGc+w+WR4rhMByD00c46epklhJCrYp1XF6ZwVtFA7JnP3AI7WQgWalqTBi1YQQsQ1wMhgNSb/wJrEqhATs9Irgtx2MO+Kre7JqVGiXYwQx3ypBJEJEIRiuiDFiwlA5t1YA85+OIHCqUAVVLEAhnQT8vqoAMz4EENZ6iD/2rLYAY1JNEOTQwk1agmTHSlBT7weQIW0hLRPX7Pm1DQrXx8oIMnBJIHfIBFTC2JyV58cqYyle5MFZnITGI3p8WI7i+MEYxgPGMbgZhDEvJlgw+koAMMsIMPYBCDMlwKqjzggXwxJd8ZWBU5MziCL91yBE2BNQvGhAvjzopWZu5lrSr0Vws3068tGAZxohNCD8iDmZDyMAtS8Mxn1mJCc1IsiUds08X20Bo79SEQK2FEIyARiUtYAhFnOIKlQJCznDXAAg9QQEBVCSL9PAdVeMDDGWRD5D7gIYp4wF082XAGLahBC1Cm2hWw4APfjq+3vfXtjbSABW9qWGka1mAO0P9V2yuUYRLAuEUvMGnJ6Ma5utSdsyMVqUlNvjmnvbDkd5vBjXCQYQxzGENjZGCBBqigEYHbAQy8Kp7l2UDSNtiBpGswHHOZSzuCkwEF2/WW8GXnMgMB8wfnEq95jTBJeVFhYqTwry1sZjN/8dcSlIA4SdOAUkm7EQ9hvVYx/PUOk5uDH/owhz70xmOzqQ0iELFiZ7e4JQWyhCUycW1I9CF5KijoDtTL4wMYQAEOAC2jlOpQH7ABBHVghO2I7Jolumm2aprtaqn85SxzWd/6vlG/++3HJ/C2PpqBgg/OkOZTPKilw5BzdKdL3UXOuafg/SmejXFx8BrDF8nghjziQQj/OhRBCHLgggossANJIKFvMYBCDSi1g4VoysIzfznPzJio4dSAgr3cERA6ugTyjLosaGnLB4UErykI6cAj/Iyr7wJrWYPJhVuoC+IWY2Ek9JqHUlcnoZ05TirMQezFjlMgVAy7yCaiEWpnRItbXKBLXOLa1/YEJzihCUvogFD4kQEI7maAAhjgAxZIgAUa6APkMbkOZa8TnGbXpnjf6Q7zdmJE/e3vqF3+RloOuNSu3GsoHDwGjKAVhBje8OnGOeIy1STFjZHJi8cevL5ABjbkQQ96/KEQhCaODAAhiSe8FwY6qEG6qEc9jGIZC1sP5BPZkJo+SFYRkmBDlLEAhJnD/3whiEPcQM7yBLEOyUdCatwU4EX+DlPhLioMGNRlTesIJ8ZLWjeDwyhauTE4cw5e6EEQSuMHP0C2PvAD2zAEZ4ssRmA7SGgElmgKl8AETYhAu0MQT9AESQiKDACBHZABBTCAA5CbBDiAwVMAC7AA5EEDccED2TA7RGgEF0yEOkGE2oANyJOtJqk8fMuyzeOyLttBLQOzG4Gj54ECMygDkOiEWugkQ+IFXpAznogznohCT3I4RyIGUMqknoK92DMG7zIGari9f+gHQ/ACNkACLUiEu6uDNDsDPtADPgiEtmuEApk7BAEFUjAFVchDWaGFWrmVXBGGRjg4Lag0Ubs67v9TAiTwgbPoLx9ZArn4EaVLuqWjlxIiEy7ogkuUghaKtVhjg6nzl4WoCzHbDIcxrCfxgjEQAgUAAAAQPCEoNj8ou9k4wERIhEAQBEGAhEcQBEZABAKBQAnkhE4gBVBwFU/QAv1ggMDBlrT5MVWqFhXYQBDIAXuik0SAhAV0QVpMhAMMmTZhDT2gPHsLJKlJLizIwczzLYBLCzCDAiVonhzIoCvAARBgrp6wJCZkwujKR36MQl1QvV74BfD6BYIMBoI8yJ+6OGRABvCSBm+QB3vQh34oAzXAA0YgBZ5wBVaQFZ14EJ4Ahp5YJJYShkmqkAmxlQpxBpWcBS0AFBhgFwz/ipT2gAJbuzJ3rIskUIIguCCc9KvPUDqIUTUS0osp0AImwIID0wsxcUSa3IK/8ETRoJg26A05WEVWZMUASAAaYANAqMVEmISmiKw20AEeeAqqwAGvEIRJ6IQDIYU7dMs7NAVOEAQQsBYPtADQCjcD6JYS6aKCsgMtsANGgMNePMADnB3WWI0lwoM6OIMyqK3HLINFrJ6Mcg/wgRT3aA8lUAzqSbOOyIFROIZlSAZmkIVdwAVZwAVciAXT3AVfOM1YiIVceIVcUE1f+AVfMIaFTIZkaAbfbIZneAZpGE5qsIZs4IZuCIdwAAdw6IZuIIVVoAVbOcmbiinrgqlJIkmX/3KGXOEEyzoORgwCUcFMd1QCUDSS8+gUvyqh8hNKoSTKETor8ptEtKICIxETcoIcirGnEgiAq8RKChACGwAZybpFXqwDNNCBMsgDDyiRB7AierwCTrBDtzSFVahQUpiEKyieByhBttFLu1GALoqBDsiC5NIDR5gEaXPBwkzAZ9sY2FgNImPMevsNNSjCGEmV4/semWQaYiqPMvAB+roCMSIKXmAG37zNn1pIZEiG4ERSZngGZkgFY2AGaBBO5HROb1DOcIiH5XRO5mTOeKCHeaCHeIiH5uwGbnipWzGkl2qkhbPORQpJO7su7SKGZXAGYdCDJNCBQNmBEBrPr1qILf8AK1srjyW4i7qwl/ZEsKQMSvqcz6VjgnoRk4gxJ0BYgwP4T1aMgMlIASkwOz/QA0NghDoQFxjxgBPZCAUYAANoABAIBE0wBVOoUFoFBTzACIF6AAN4gA/Qy71sAOHogBgIBElou0nIBGnDxjhkQMO8xWcDBD6Y1ja8kxm1g9VyoiK0sssDsB1YR91CAiW4kRiRTJaZAbQshW3wBm/ghiz9BnBYhzGNh27QBnf9hV2QhmvABmkAh3iwh3mwB4Gdh3lgh3VYhzBlzoNdB9ybh3VwTue0KQqpzkfyx5aK04Xrs2FQBmcAhesbixQA1LUQ1B8NxU6xOkO9T7OaxKGET/r/fNkiqReIkZz9/IAAuNmrRAASqIALWIFXlA1EsJg1qAOpUFUTEQpVHYABCACl3UsdmAQ7pFBSuIQ+QIP8MJH1UpusmBkdgIEMeAJIMEAX44NJqDZLmARsRNsFbLsW7cU4wcXXSEwlIzI7qIPVAgwbhTLN67e02Lpy5ZPlIYpoYNcuZQd3KIdyUAd1gIdv0IbjfIZUkIZsyAZp0IZ2uId0uId+uId6qId2GIdxONgwXQeCnYd4EF3ndFddaKTrejjXrVOc0rNLUgZhCAQssIGxUIG4GKnvMY8kcEQQYgsjGd7yg9SXPV6YTVSnCxgu+LrJ2QMFuFnpFQARmACEkQM5/zAEPdiDQPgDNjBCozURrBgAAAgAC1gAA3BVwFOAGrgEBDEFTXiCb1OB4eGxDCjBlomBPjCEOriEXmQETSiQl3gJsy2QSIAER3CERlAEBVaEBOTGboQdOPnGJapg2Zq3GzwDDd7gM9iMHF2DwJkB+ioFwl2HdFBcFBYHx/UGaZCFZMCGbijOe3CHfeiHfviHe0CHdogHciAHeUVYH2YHgxVihK1XbdCGl4rTm4Kk14Vd2bWkYlCGUSgDJAACckmB3cWjkfJdxQFez/DiR80L+mxZ5I1Zp0uM5vWCyck/AxCAmxUAAFgADhiBEyCBFpgDObiYPuiBDlglGOiWcENaA/9gRQeIgANYlgMg35tVgCmohE8AhT74nwbQAfVKAQWAmYKKAS1QBAZsBD14CU3ohAfUhLvLhLiLO7M9WwOOBFZGYAR24MmqRUWoRRlcwbhVTAuevHiygzdIgxipAzNoq/TKgTLwCmZ4yHmwYXio4XGQBmvgBmy4zW3gBmuQhoJ1B3XAB3zA4XbY4YU13YUl4oIFh28wYm3os2N4vUuywiZeJHauQpvKpJdChCtAAhsgmA8IXuEiCC7uyeH1DMPwjDHuAklFMJeNVCBRvzNWIXxJRcArAAIgAAEgAQxogQpYgTFwgjH4gz/YAbbJAA8wAJEeAAawCAYo3wGoAAAoAKX/PeQEWFqmfVUq8IM1AIIPUAEVSC8LuIMbia1I6MVJ0ARgjImYkIlR8AS2tLu7i0Cm1oS5i7FqKxBszEYEXuBYhsE6kcWMweUKrts6mC3CSJ4YyQNR2IbbE1jcC4dsoIZpToZdwIZwYOFuIFN86Ad9uGt9QGvcowd2CNiIvGt8WAdyKOcjds5jSIZ03kI8s8J3dmdLYr3nwi74OYZVCFIsyK/0ChINGy7z9Be6+Gf7BOjL4IKBPt6DTjryOzq/4rBEZT+GPhM5sIEQLIADIIAEOIETeIETcIGNRqHN4g9VTV+RFgoG8M8AcICbXYBEZukBWAAHKACmHYACIMEZQMUK/7IlwZGsSXC2oB5Go16FUziFWnVLmaBQVylGTqi7pXZqucsEVS6QSWjlBHbByYpl2Ck727kTPCGycByMjoCvac0DZggHeSjwAvcGaqiGbbgGX5AGAqeGbChwehBYexBiv6bwwPZrwK4H5vwGwj5iXtgFER/x08QFEceF2swFW1jxFc8FF39xGM+F+XlTNwMGSOCBM2oaKGgcINFi7mkrzz4mt7DPzlDoERISMWaCvHALJQ/jpEsC+YzPtQArKVAhLxiTcpoDFehAwBMACRgBFHCBgrmBMcC+nzBCBlBapkVa8o3jBRiABHjuBbACCUiAAigYpmXaAqBtB9AALigEAP+8A1llhEwAhU4whVMA70S/UO8eBVIYhZgoRqTuhE64O6WOQExIZfhWW2yk71lGBEXoxrIDQGOz4CRSMl6mNzZIg5NY0EeQhm3ABmuwBmqgBmmAhmjYhWMOB20wzmnOBm2o14f9BtKNyH/4B3aoB23Gh3pgB3IQB3HwcIjthoE8yCZswn3MxxjPBSbkdl6oTRTPhUSCQlbAAzgyg47acfITs++BtQ/63X+u8iNXcrNqnKJzHCeXRNQuv6Zz7eb1jKgsDSHQAAVIAIOHjBYQ8xJQARvA497gAQ9IZFY8ABwI6Zs95AKwAAdIgAmYgAVIgAVYgB9Q2qUdAAHYcw9cAA3/UAFJcG+hvlBY6ARQUHRXgAVXCO9TIG8FcctiNPS7o/RKL2VMyAQCfm/4rmoHdoRYdjbGixMAZI09WKJdnvpWr4M8SIVpyPpnAM4rDYZk2IZwiGFrUHBsmIZrmAZs4IZg79J5kMh+UPbO7Vx2GAdol3bn1IYnBqU6WyR+xHZ85UdfuM1iMAZR+iRduIQa0IEtyAKN0hF4yQJ/GTMe6myqK5L7pILf/Qy7IG35TCb5ZHIxFuNJLD8gaRz7rPKAkQIyAfjVuYMa4AKb5jEZgP0ZIB0VCAJ06oM3wAEGSN81V1WsdIGXrpbGKAEJcIADaIGXPvmlFQABkG6UT4AHiANF/8gEV1gF7CflU1CQ6ycFnA/vmaCJnDdqSi9vQwd6Ssf0TNf0qnYEVlb6TzdM2Xh6CtYDInsD+2+txiyDR1iGa4gGgGC2zJmzZL+ueeOGjRq2atWiOYPGDNq0Z9W4eYtHT5++dvXasfN47htJkt26adN2bOWxYsSGFYs57CXNYL9++fJ181ewnjt1IjMW1BewWlF0JMmyw0eWIzuCJEnCJMuWLVmgZLmqpOoWJkyWUAkbFmxYKWa5MJkyxavaKV2YSO3StovcuV2kqk37NckSKVz+0qXSRUycOHfuzDEcqFEiH2faTCHsZ46fOIb0wPBgYPMABjxwGAgQAICABAsKDP8Y4MBCggMSNAhInRq1gAIFAhQ4UGAzAz+eTNECRaqTqVWwVq1yhQpVclSnnkM/RYrUqFHTqY8CBcrT9k6dNGnKhAmTeEuTIKGPpN4Re0WKEiVChMhQoEB+DAHK76dPHz7+9eCBB4B18HCKM9EUM8wxzhgjFDLNPPMMM8fANMwwwNjCiy/GPHNNN+CsMw857JDITj0jlfTNSSkdg0yLDcIYo4zI0JiMjcjY2AyEEVZDDTXVQBMNKjgEscQOPWCBhVNQRZXVVVlBAQVXSkiVlliCiWWWWW2pRRddbMnFhJdcfulVWnJFBdZghMUxWGGFIWZHIIpMosl2gSSyyX2J2IH/iCWCZMbAAQYwgEMeMKQ2GgCLHrCBAwcM0FoJtxmAmgELpKZAA7rtNsBuBiiQQRqcgGJKcauc4gotsLTSiiuotoLcKs5F99x11eEKinffgQdeJuZNMokl5qm3niPuvSefIYjUFwh99gHiHx96UKtHGldkoopxCgaDjCzIOHPMK6WM0ol1pJxi3SmvGAPNNh/G88057JxDzjnojFPSSdxok00zzOioY4TQSCPNNNM4dM012GzTMEbehBOxPBNTPHE43lzzSAxQ9aBEFj488QSTSWAVJZRSVqWEmVNcKQYVS/SlJZdu0RVVWnbVReYUNofZF11isAl0F3D24YcijVjS/wkptAhzC9OgXJIJI5F4gkkZDzDAgAGG5qH1AIouOloBDiQwgAoHBBDpAAZsOoACD+h2QAIJ2Obp2qDC4Ignq7ACi9OwwOIKq8a5UjhytUI3Ha64erKrd5yANx4ml1A+SbHFsnfse/HNZ8izgfgHSB/U2oFDDICQYkotM+EY1DK5CC4ddaaaAsoop+CSzDTeyEPPOu20Q44444zzjr7d8JuNN914A3HEFz8ffcXT00OPPddjf3083hiDAwxBBNGDFErsIPLIJmMF5ZRstRVWF1nKPLNbPHtZ15hr5YWXWu6vWdjQcPrBWY6whCZG4YpiKCOBTQMF5JJmNaxlLQ95EP8EaAyQKNEsKmwLWIBoIDWAAyggNYO622Zwc5uv1e0AHYCEqm5RixfCoha2mCHgAhcr5swqOqWYDrlwJYrGOQ5y4clEJi5hOcthrj2KkA8TPdes/vABD2/QwxtggAMcIAIUwhhGMAD2jJu8gm+uwBVyVEGdUrziF8/IxjpCAjx2iOMb4wgeOFTEr37RYx7x2GM8wgGOcPSxjxEDh8XCMbE8Yo8jirwePcKxDUx4gEhCsIESlNADKNSASUF4QhawkAVOetKTWdEZy1gWGJgtwX5y+VKXBkMXUwYGLnzJi5l+BrQ23EEPcbBDLvuAJ0VcghN70wUCnVEMYQjDFJ64hCb/JvEIHHggax4QRB4egQlB8OABXxONAETjTdGsLQCgypQF17Y22nxNAAeojQgV0IEraIIWtXCaDGlYQ1fESla0ek4p+rnDxXXncb4iohEjEawkuoeJTaQPffhjrSlW0Yp1WMUxcvGLZOgoGbzQxSqEoQxUkLE4p0DFK4LRDGt8Yx7rOAfw1vGN4a2DHN9ISb+ygT16TC+nFpPH8+RhD45UDxwg0kYhoZEHHsQgCUIQQiUriYS1mCkIRzhCFJ5wBS1gFatM+AJXv2CmtHzhlVC92ZXUJAUqeEEMXOjCWrlABSmg8qz864Ia6mqHNrChDXrAZR8AEQhENCJYmljaMBKo/4xj6oIVnLCcI/iAgwxgLQ+YsKbkAKW1tHkzgwBQ1KDE2QALDmpQrTkAAWxzgAMswACnVa0CGKADS6hCF8IABkyAkQsX1qIVNXTODm8F0MYJsxNCvMSwgBUJRiCXPcdVKBPr44fnPpeK1ZriEbCAB0HYIiLGkIU0mpGMlhTjFheqBSyYBgth6KIWvEiGRTKikTz6TqgpRUlNs0ExQ0KvefpNiEKwobBrbCMc9uiHPnCqjYD5SBrMEMVndqCEpTJVCUuAQpXMFIULR+EKGr5CGcqw1a6COMRctYtYkvDWvvxFSymGa8zMIhi6qCENamADje2gh14CQhCAnQQmOnEKpv8Zthi6oIUrSHGJSDQCETzwgAdggAlRQBnKmJDgYxVgQcyORlG4EU1rbbOZ04bWtBGIgANUO1owKwAEkaAFTBKUXlvUonB9g05vq4Od7AB3V0OkHCaCZblHAHo9yGViQplln+hWi4p3UMIa8MCHSRwDGshIBTOiMZBlKMgZbW4aLXQBDF3wwhgIw0Y4vhGPecyDHvFYxzrquI5+1VQaCnkGhJhhIxvBKBi+kAWvdfILawy4H/aIxzN04gsaGcMWebhCDFJgyR3sAAlIUAISgvBVJmA4wxvu8IdFHOIwhKF+9QsClvzCBS2hG67ofjFd60pjNtgYx4AwBCMgUadRrKL/08gsSuFMoQlHMAIRR72iKFJh8FSUYsp5wAEIPJABBoTQm9v8GgA+aMFKVWpQu0HNASYQgQRUqgEKWO0C4NaAM0xCFK4Yhi1qqFvlREdx1sGV4zoBXF9dQnJ9duYjLucIROgYWc09NHRJZwYl2JgPrXAINJ5BkGMsI+rGHIZsdSFbZA6jF86YxjX4BaJTq7SO2ggHSu7oi0rjYhex2AUv2p4LW+SCF29PRSxwkYte7IIa9OiHsOUhjWAkIxjL+G4peHCEGsxACD2AtrR9UO1rZ1vDHe4wiM3k7S+EAWd0KRJdzH3udIOe3XWdcY3vwIZe9lXHiHjEvYtTOFeoQhWm/+DEsQRRhzLwIA+xSAWgCy4Kal4xMx54gJVRgxq7geoAm7X4oDZj/AWQbTMJsMACQqsCC1hg5K3lQSdEAbhXAC45hztFP6+DHV0B0RONG6J4dP7ng0bi5/IRuqGf69zo2qEOPkCDHvjwiGVcg0MIBNQ5wzLExDEAwy3oQnnRAi0oIDGo0TZgw4eAwzwMGzikxIegBEq0HUTYXS9YnS7kQi14mi7cQt+40DAYwzWAA9+1mjS4iC4cli40wgzMgA2oQBAAQbRdgeM93ldl2+RN3uVdnuZ1QZFcyV9cyRIyIRVowRmgQRSuAY1NIS8dhh70gR0AAiLUGwFxgtKQgnZwgv8kJAIgEAgOCIIv7EIePAAOWNMjUJnwMdkDdADczMZujNxmVdw5qVamUIACtIYBWIADbIoBUIAGLIAEgBwIRZIbjsIrCM5xvAqq0JnsVIeudIJ2qB8nTE4mRM54+Bn8xZ98HIuhHdpfER21lAEeYEEu4cEoQEM16JqLRN0ytARBKKArCIOq9E0tpFEzTEM2dMM3kAOqxUNKCCMGpkQxfFo0KMM83ULgsMIqyF7tcIIwcYIplMIzyAPf2UM4IMNkCcI49kEOzAANqEAKBEG0IUHISBv4WF5WaUGHncEZcBsRipi4vQ8V8IVYsJUXiJs/7uOVYIEWVIUZRGEUmgFC1qP/GtjBFZzBG9SBo+mYvZkHM1kC0OHBZ+RBKqzh8D2AB+QeNS0cNA0fD0QB1jRfpWyT2IgTZxyAA2yQAowNBTRAAySAApSAInpQATBAwzEZDohCq7zeJB5OKSQOdehKGGpHJ0xOr2gCKPoZsQjaEplifcgH0fmBHhxBHWgBG+xBHwgCMAADpSVDgygIAhaWbLECkZ0gcsCCLpjURQiVRtiDMmoDOHSDNWgDYwBCIygDJPhAGeSADBimCnyABmiAAzhAB6TAEfBAMLSgsGkDMvhCKTAcCMSADcgAYqYAEkzVE0AbVFwbE2BVFMyjEHrYV+FjWOljYLCbK3nJlcwmiy0B/1VYRRagwRpwhZNkAULWALRZVUTKiXwkQiNIgiQkmWPlXimkAhumwAxkwHSCQBoAgh18BpMdStZAXGvUzWx4EDihlmkMygZA38g1AAU8igDEhk82QKFkkwc8QimwQn3WJ3LsU+JUh9Joh66EhyZ4R1TqHCgilFU2V1ZC11ZGAQ+cAVg+JCbYwjZOAzIQQ4IoA4UgkDLcAqqYgiq05TzFRIdwAzjEAz7YwzygRDZwA31ZwANgzRqoAgy4aAMw5gZBXwK8hgq0QR4ggzbog7CFQzZsQzTgAg/IwAyoQJJ+QAaEzBWI5g6YWGkG4eRpmLeFweXVD9Bo6UDOFZdSgRicEv8q4eZv7iZXICQamMFvzkAN6MAOPOEb2IEg8AG9HackWAJyXVFHPicIpEATqAAMxEAHdMAO3MEb4B4PCMLwMcB7wsAbgABNpobz3UbYrE3ZUEAEbNBpYR+mbJY4CQoD5EE0haQglIKsjB/inF9/6so1fiGvSA6P7RxjrYdVOlez2Ae1+EEORMEZ8EEd3EEcpMEoJIM0VEMzGEOCLMNh1VYxHAftJJDg1EKkYQM40AM+mOirZaA3ZIMDfMAhfkAjzMIWfIAKaMAHbMAIjMAGVEAJ3MAeJAImNEM4ABVPeQOxDsN1ssEW7ADiHYEWXMGSqIVUgI+1RV6HSV63teYX0Mz/KgVG/TShP7JbWPzFFkQhxaLBFqxBxmqsxkpJXt3BHuRHXxlCI0SCJWQCJz5TJEEZDzCABZTADKRAGjxAAygmCIAADMgpCHDnA+RBJDyCZclGZmUQN6HWAtDNAgyiAxgf22gnDmTNA8BAGUwCqlAi4thKrmQiEDmOgO4cJlBl/DnCKCJoABUdrgJIFOFBG8TBG4hCAGIDNkADQRCELdoiNCjDkA3ZYdFCcuSCM/DORnDEXdYUv5RAko5BFtRAJgiDIciAEqDjCqxAC7TACsiAu04CM/hUgclDXmJENDTCG5wBFkBBmz4BVh0BEBTJWHnFF5xmFKhmGVzelWKe7Ibb/2vO1ZbOpmC4DGy+FRdQbFVcbFVsbEKigW62AS6BLCDcQV8BliScrCdSEA48WTZpQAvYQAo8AQyogA2UQAoIahnUQQ7UYUgCGqBJ0JK1JAEIgPp2k2gQAN2MTQNUX9qsDWSJ5M56QDWhKlKa3+JcYkC1KtcGi9ciUeaU4tgm6Fb2n7TwQR/cgRukAR8QwzYoTAE6g2FBQ7ImEDAgkzA4o9MARy9Aw9/qAz5YzzdYQwpnQw1o6RHMADwJgx9EQRDUQBVUwRSoQOMagiQ8QjP4lD0Y2DpszzHgQRp4pRbogA6ULhaIDF8kwRR41YelQRqgZhnU4xW3Jrh1lS2tye7akv/Q5K4+qhjFLmQU6ubG8iZXTCEuYeF16sG81Zsn9tgoTNn0goAKFIEQzEAc0LAh1EAKqICgakA6pkD+ioI4StB4OK0FoQYBODJ7alYBzA3I0e8BYA0acicDyOckWIcp+Na55Ip2ZEd/au13SI55ELCxhK3mMEsCFx0fSBAe2Jge5J9kHcMvyIIz1gLTQIQxEdPVzQIyyZ4nlgIxNMM19A6qCa41MEQSbGku3YEnxHAUwMFhxMEMbAGe8Bg3MtLmrkM3XEMn8ECA/KsO9KsWJElUPHEXhJg8XnE9pkEWy25YFQaYbqmW4vNr5vNf/AUasIEUomlCCm/GCm9eIe/o+NL/cU7CyQIoMeXC7gFKEoxBEyRBIIyBEFwzIKsA5K7ABTgmI5SCKFhTNR2y+XpA8enG+qpv2OCGbohGAbQWzzotd7ohJpzLndnZ+akfdzTOTguXq56y11KlcrUHgt4fosFyHaQBXUmkBE0CDIiCMgDDJOCBIcyCLmTLdpDCJmxCKHB1JWSC6IACLOACNJAate4ROGRDCjvBIizCH+xwJXjOLChDJVxCJXA1M4WhKbxCNWRuI1kDN3BDMuTBKtbBFUTbDlwsOnuSmrQzVqXBGUS2ZKeBG1i2ZYcBZoObZoeb/4ibZ3uJZ2tpHGwpP3OBP0fhP1vsQFOh8LYBL4GsyB7N/0KTyirogoJ8Vy+MAidUxhkAghdwQR8g3gzcwAtM7rp+AAzwgSiENJSlwiELQvk6LafYRgGob9oUQGyIBqEcQP5GkzSVgSBggidPh+34r6r2566wqiYIEdcWl59BwiMYsIFmZSrqgZxS0Re4rhAKghYpAyN8AA1IwiaYAiAowiFIwiEcAiUcQiFUwidIgiFAAiagQjRAwzVkQzisg6ppQwqrQijE3iyIuDCIuDJEQzB38C0gkzIswzbIA0f0kcFUA4OlgRWfwQ5M2D/Lo2Bw1TxP8Y9P9hRfthuAW2YXOWf/jz6+yZKLNu52npasdsUmJBqn8Rq89seKzl81gr2dbP8ndBQCDcSBRIMrMAIPTMsOBEIMqIAUFMELvAARnEDhgkAGoGHB7VpIj8cjiHSojpyn1I1pEAAGVRyo4MCScSfOIsLelLcnVIcohLIm1hyrtreAFhew/Jl8g22h1TdSiw4V1fgZ4MAM6IAiQI4pXIIX/IGCb0Il/MEfkEEhFMIm0IEc7MEhJG8iSIIMXrg2sBo7rMNaK0MHd/BhHdOBBNmwO4OL8908hIOCBYMEWUsaMAEQVIEXWLs/q0FDzu6VhgGQe3saFLkWazHmYTZX/Q+YviaTixsYP7lZWOyZWqxA96YZYCyNvTHzMkJg6fUpEBOLQ0OQWPgyvIJI1wEgHIn/ENwAERTBDaxAkqpADcCAFUECKuCCLCBclJkvDnTAplS3bcSGZgWAAvCAjH4qok5C6qjfroiCdwRUzfEKeFwjVBIwj4ViJMQ35mg6AvPHzlMLHtRBDMCsCuzBHLRBIcxBE3DBHHBBIchB0hfCH1DCHxRCcu6Au37CJmjRMkADNQzjOthDN2QDAgk7MiFQTETDNhjTLXAwmHND5n79NCTDKPBAGaTBG7jBFFRBF1QBab9btqvBZsvuFL/B4AP54Id7PIM7uNs9uHd2m7zmZ+sjuvNuF6A2alMBGlw+5UvBFmx+J52xPyP0X3WhnaTKLRQDQURD6qs+NBwDJgTCDOTA/w5IgRz8gRMUbgvMgB8AARLsQIfpeSxYvMVPFpW9QQpwit1M3DZJ02bwLCJogqnEfKsG0U9/4RdC5fVHZXFJpShmes4bAnT11ehUiyyDwAx8QAnQAKw3AR3cwB9YwRjA/xz8gSrMgtQ7uCJUfSKEQihIgikcg+4AhDZw5NbN03aLFixXtGapcqgKlq5axaA5e4VqFa1Xvq6Fk/dRnrRdeXK8eeMmTJguXaas7JLyS0yZMrXUTHMmTRqTb3L29ImTZ88vVWSCMVrU6NGYSYcyIVoFahWXU7tQERNHjJQmXsRQqanljBo1duzo6RMIUaJGkS5h6mTKla5iy5w5g3Y3Wv/eaL00McqR4kOJEhJWTNBQQ0UMEDoUw8gjKlUqUZgE5cEBg0+MBwoOHBgwIMBnA6IZMHjAwAMOQZAwgXINypPrTrNnc+rECTcnTbt17/atKdMl4cMtWZoUCXkkR8sbMUqESNHzQNP99DHU544ePWT1sLmDhsuYQp8okTF/6BCdQoUOSQpVqRAlSYcSSfqzqVIlU7R0McPWTR579OnHNVJA4cST2EjhBJRTShnllWWOeUUUVF6RhRqPPgqHGlF4iOEklGCaicQSf/IpDS1QXDEnnEhUaqmk3EiKqZnAkMmNqKoQQ4ypuPiRRzHOAIqssso6yxC1IJkEE1FOiauYY5b/oQuvvCpappQzQPjgAxlU4NIGFbSA4Q4ZzEzBg8dKweSRPNzMA4TTSjtgtAE6M8AA1DzYM01EHtGEFAM9QdAT2nI7FNHfLskkuOGEK+645JBbjhFELJVuukAA2bQP7bYjK7s72vBijk02OWQRQuggZJFDCvmjEEkkoYTWVu2T1RFVaDmll2i2CUfAfi6ZhNFKMskNFFFGQQWVUmIxxplibJHFF2vouVYeb6axDIYQU4IpjBK/YILEn4Y8t4whUTRpxTBorPELMGZ8F8Yb473RKKhWCrLHfflVI40iuSvLLD/QQoQR1johJSNdgIlyGWaeucsZupzRBZMyPIghhRRm/9iDBiWWqEkJGnp4AgQPeMCEzUcmycMDOUtjgLOZUYMBBhxU5gORSToBhZRBcbvNNkR7+w24RR0tjmnjIk1uOUUsnRoRQ6yeDpBO9biDLJ7YOAONNsaQQo6yF6GDjkVUWeSP/DK5T5VQQvkEvrlj3c2WZaDphh57+lHFlIdmmeUWh4EZphhijgkmGGaguaYaabo5Rx97sjUGBxxAcINzzr8dUaZwY/r2xHV3YjcoFN2lV8Z5YYzxqHel6iLIMWzn8far1HhD4CI97aMPg/1ABBJLNOmkFFROecWWXuay2BlmplymF1EEKSOHHQwZw4s/ntDDCznGSESxNzpp8xFMYP9+gP0HOshAZtNyxoEHx/iYZJRRAk1Uk9yQZtQ3jVqa0ybhNKgtxxGKkBrVqmYIrGWtU3bgnQTtwIY23MELS+jeIchQhFWFghKEeIgq3CO3SmxCEqY6hCE+YYpT5IIZGeqbMIqhjBoqQxnOwKHFjlEXZCQDiNPAxjfE0Q99yIMbmLgMCOAAh86J6HOfG50bUueT051OJ1jcSU7u1brONdF1rJsX54ziBtrhDndYuYoa4wCwK97hDZ76nR2skzDjdaJJpWhF857HDGZEz4/JWIYtSgEJC4pHDHPgwh/+4IecIYIVjwABDMrAAw/AIGUeiBP7SvOAS9IvDzzIgyBGQYv/VZjCFLU5GtKAwyhXMko4mWha054mKQQqolJUc+CmINgprnVtSFvIwhK2sARG/oEQRSCDFTy4CEqgxwlFcAIdYEWJVv3hENGxxChi0QxuyCMex1DGMsZpMSrZpSI+9OMzpvENdxgxJNzywBua6MQnQvFznIMDu7J4xS3mxJ//LOMY7ekGMBr0nvOq50HhsMY42C53YoDoGOIQh9PdITtx9FR2/BAwPaCFEZGYBGs0IYpSrCIixBCkH5vxjGZUIy/H8AQi7iCJRI5hDofwQw1g8AhS8AFnGRBqzubngQx4oDSfxMGbcPAIVujiFq5YxW0C+EqrCtBRl5hlLSEBCQTe/zI6DayapnjJKa1JMA1iCVsb2EADFXCBDmRwggtG8INNjGEFJaBBC25QhB8cghKwOgQjJcEFPViiFc+oxjfr0lhnRKMu6UwnZOsyMWloAx//sIc3UsEDzc2znk+0ZxT9CdCAmu60aTCoE8tY0C8u9KCrDa1BK1rbh46BXxKt7U6yo5039NZTfgiLd86CMJ65rKSkQMXDpOQ4aDxDGnm5RjSA0QlGRKGJepCEDnCGPzzEQAYfgB8IcBCDK7yhfjF7AP2WOso8lAETrrgFQlhBVVfG8r7EYZpWmTYJ/yLHq131qiMaocAERgdTVyMrp7aGUTuIRQtsQAMbkICEHdhACP+bIMQNWtACFFjBCYUQjxNuQAQy0IESciCEHMLHtjhEYhTAcMY2vEHZijwuGnf5410oluOJTSMc9NAHPa5xPcVk4A4L1ScYv8W5gJbWtE/2p5LlFdsvyku2r21ilSvq0IdKFLdXsd0+dSLHLGLUUzUJS1kAIQg88EEQjGBSSfnTi2P00C7RgKleojEMWHQiCjlARA5gkIPZXAEGMljBBzpwBJTB4App8Owl35SHRzyCD26JSy1o4YoDZQITxHnlAAsIqUg5QlIDZo4CGZHARLx6rJkiK/D6YIchiWUs28ECGqCwhS30QAl7aIITCHECFLigCIUIxRj6agUjGIEOToD/VdkoUQQ5OOISunDGNbZRsSndeRnMHcYxDhclXuACiLL4RTbAQQ95IEMQgnhDFHiQZNjCISX4DAOUT4uTfj45J0vW8hhXq2V7wtYNteXRbSnKRtstGaMRBy5HzQqI6VgNYY1Y0iU04QlSPCkX446YMyam52pMFxqpiDMmYdCXFHTAAg5owANUIISXZyAGmQNlpS0NKFf8nBWnCFors8pfS2hVv8aRFNQUEbXoKHCB07GUAxVcHe1obWsVVIN37sCGNXh9DVtQdBEWYQUyJLMFZCjBBlxABLfHVQjYVI8zG8IKYEAjGqZshVSVx4qpjgKPLMNjKWTxw2l0wyPhKIUg/2jKAx5s7d73DIOTpcxv3sLRn7K1ckILnmXN19O2taXoRCs6Bog30d4YRT2tWd+HrFncUoxoBLEYZIqGDWMYdPnxNKrBY2O0Aqhl6AQiQNAGFVggAyoYQwvEoIIZlKGSo6yM9C3diSdJ9ZSg6IQmQm10SIl0qyKNBCQOiMBJhfVSz0GErDNVHaxv1HcVZIP82ZCFGUhhEycmAjPJQIQVXGAFfoAIjIAQCmER1gNVBsdUOEEYlAEaMIETOA4UTOUTJAEQLAES4k0QMCEVmkEauMEbvKEbvEEepuERBMEPtMDxGgzhOqfJTEKCeKLyomyL/mnysmygOC/ydLChQu92Sv8Pol5iyeBA9WDrDoCHl2iNlwIhSZTEEeYMFGwPFmDBeXQPGqZBGiamLpThFDABFSABBhphB5IvCZqgCP5ABdjAUtzk0k7w0ixtFFhBqk7BFEhh+zDB1JDjv8hPpPZQwFBNOVzNUqDu1QoxrK7GD6ojEYFHjjxFYPRADSLMDtYADerAB7LABv5ArpzAxDZBFQrhBuwKbQgBsKxpE+YmFEzFE1ShhiQhEz5hE2iFEipQES6NA5FhGrKhG3ZxF8HBG8JBFhjvDp6gkuxttp7oW2SQLGiQn5jxinwiJQbKizonKY6RjHKQc2gHCG2HdsKMGyEOzVIPoxbR4hbMHJNE9vz/RKT6JwpPAaV4wRgi5hnm0S4aKxmcIRbygBGOoAaYAAhsoAi4oAYMId5Mak3a8AQx4UlW4RSEDvA0wYCWbsD4cPy+CtW+ysASQYHU7zkKMRGqbhG1Buvs4Je84wwkEQ3MgA204AkwEZnQhgxUYRYIQVVgkhCsyQALIRYpIRYlwRNoQRhqxVTyg/tQQRaaARvkQcjYQRzWwSnXIRy8QRpO0A9Wsgx0wBhHq/MmTxntwBllcIIATrWcaHWuURrtJSYOikYMrqFyq8vcMg4WCs0gjwg5yg+WUNYgaFMMwVIYz08K6FiOZ1lggRcUhy4sRmKgKxqIoRTeCw6YwPmO4Aou/00QduEYIqMUSqETBIEPOmEVGNIhRWH7LGFSLNLpTBM1HaEjp0ZTgOcO1OCjAqE7jpA6rO7q3k/+BKYO1OAMrsAOoGAPNqFV1COu0IODrIkO5GARQmERPoE5VaECU4gUZuGZ8mNJRoEXoOEXlXJA+sEc3KEd3qEpozIV8kA7tOAIeOAIspLz8m0nYjCLvjKg4CjgUKKL0PIL5iUmyCU/r/E+BS7h3jL0gqS25JKj6qm3ErGsynFBLY4v+QDO4swRlmRJ3GIUnsRhekj35vEaOjQaimEU+EAH+JEH3mAS0ucXfgEyXqEVOgHOLrQhTwHw7nCkCKwRGsEioS5Hc/QjE/+x/SBIOwDBavQyEYtUJN+Pa9hAO+ygDpj0DMrADNRgCaypJuVqVQDrVEgRVjYBFjdhFkKhPSThE1SBERhPFHbhGbghyOzBHvBBH95UH+6hH8aBHezB3ahB3uAgDq4gB3JgPZVM8pJRLHuiGa1oJ0CHRJhAUflzPxeVRpCCdcCs4d5y4RbOQEMF9bRDERW0rJRwUwwGQiGUEUb1BBnBZSz0FGDhFmpI96KhQ3svx4phFSZBD5pqMp5FFjKzFEThBC3h4xrSDu8QE2q0OVotR5vOwHS06ZxO/dKCLwvRahSsl4InERuRJCPOO/BALJy0DOrgDNpg2IzzbFplEZyJDjz/8RNcRRIWYVbiIxY98UyfgcbkYR7+YRzQAR764R/wgU3f1B7igR5+0Rh4IApUogyuQAdqoAXD4KDyjYqe8d/4iXeezD4ZdSYUdVwydj9HZ2O/wF3cJV7cRY28bCpCr6LkssE46jaNNGsCAQnZDw9ilmcqhREiNKQswS1QoRWAci7sokM9lGKc4RbcIjNlARdkIRWSZ/giAVDo8BRog2WOw6uKlcAUAUfBalmT1ekUCDqiI1od6Dl2iZd+ZxG3wxHJAjsebM0ezDu2YAy4oAisoFWEsxDUo5pMxSFOhW2q6RNgMRQ0RCnnQR/+oR8Ktx/woR7mgRze1N1GcBvUJ6Du/61h9UmfkuwNwmAsI49hQwRApag/RSd00uALRJd0MXd0980N0gBzV1d11eCC2IqtLMiCLkhU5s8O2uBaG6wRW08RAaFIfTRT+LJqYm9UBcy/jMc2LlS+gEFK9KZKeM8uloEYYmFXTQozMxARNEEVXAFw7JD7WEbpZKV4Ss1pjg789HDpIkESlGNU189gpgN4/KDB3uBrsuAIdGAHtOALjqBPccBP+TcHeCAHYgAGYoCAYyAIMMwFhAADRuAGZHIWFmEO/mAPDqEBDdBUnkkWhdNUNoFN54Ed4mEe6uEdCLdw9QEfrgVbwmEbruEY3AQGTyfLNo/zRMTzGKqGoyhcEP81JnLCJlgEiHtCDcwg7Lbg67yDDebPwUiyDZoYuBrRLFivdwPhd9/34q4G4zJuSfbreEChFEDucKQEnfCuHp+LGYIhV1OBWfDoEkjBIepQ+1hmWCVypASsqyIBAwGMDxGowDTSEdqXNa3Dd+VXfoFnD+QvVL4C+q4A+njADB45C3agBmrABiqZBm6gBA4ABT5BGKizPQbrFAcLFjmoVSiBPWjlEOqhHuLBKeMhHtrhTdthHlZYHsIhHK7BGHyhE0SpSeVPLCaPLCcvXArOYXWwhl0QXETnW8QlJr7iK7godEB3dPJNwiiRiNdgLJLYdpV4dttgD/bgDvZAjvYACVn/r0E3hf3YL4tDKjlGas46YVlcYY96QaV2zC7msaXm8RmSIRiMoRdqQeg+0xQAb1iX5BFarTluVMBu1GoZWuMIjDlkT30h4UY1rlhz6SMdiAmd9dV2yQ8cCDswig1u4gxIkg22AAqCgArO4H5noAZKIAEWIMPIYxPWQxLgI4V48hNSZe4OsFzJAZbtYR5YmRxmOR5qmRu2IXJaihl24RVCqZfJQptVy3PyqaqB2RqPGRk5lplLpCaiAKyjoCa6Oponb+so0eu2DtfYYK3X4OuaGJzjGs2+WZzp2vUWVNY0Op3jbRCXIxJaTaQwIblGIXlioTClJBlYqhnyGboqohda/+GLV6FZCPp4GyHjHkHjKJqhR9VqObtSEkH2nCMtNrKrDppqQNs5Xs1l0RkRAEEP+CAQwnkO5qALkuAJwGYNzGCAUyAycebmCuAD1sOZTPlV1PUTituZyrVVThkf8CEfzoEcyAEcphsckloakmEXUsEYfsEYpGQUyot+tTmJd8cFkVGHG/YGb9CY7dNjE9ViZ+KrwxqsG/W9vZo3tUAszoCtxYKtT1K/2UAMaHcO7iAO2qDA4yAcf8ec0TmdMwUFi9Qv27fVyG/O3MKkWsGw+xmImGGxF3sek+EXLiIzGRLwOGFYj6MRUPtqbXSzR7VZYw9hOroQNVAQAIEP9AAPXP9zd+btCM7gkc1AgAP4CWogBnSgC9roCXTgCXygTw04B8qAfvjAYJJAEmZBw0ixAI3TOElxEYTzmcQVH+6hHVg5HqKSG66hGYJhF2whF3LBsY5BDwy4SJL469aAqlFiqz22PfXpBl1L8rh6XBZVXJhAC+Q7rBdV0LsaLNTMv3HtvrFACwgUwTHKZCvqiWltUxuc/aQcwmn8sv3rVDUhfyyEWowBiJLBw9NcMgzSQUQTIpWDNMfvoi/axYc3LRCBM29cEB5IWwOBD+oA+rBnBgptBkDA2Dvg5jKgA/iEktIgiv0gEZgWWQqEFmqhcIShkzPhEGKRJtHGlO+DEuKKDlD/xRQPkCfBYR3AyRu0wRp4DxqS4c5wSBn0QhlIoYBToJvdWsJUV5mjyGPVG5k9x7zxiZkR3avl+wgSPuERneENvplP8isgPYnRICWzwOKnoCWOvLYS7t64xmxpjQ/6gNN9dNcZfDr4YFNCFULfDM4Q5hGw99KYBJ5RIRViYRfq+Y+SARhgoVlIgbBFc1hTXC3UwrJzHcd94mDLIA0WmdD8l4ALGAZSAASuYIn2RKhAoAxa3lKYlh0/DqWmkBbCnj+wnezJvhhoiOxnQRIKYQ7GwAlObFUIARYbQj2ILe7pHrBCkBumoRmQ4Yf8XpAcC7KE4RbsAAQyAAQmjM4p/iRJ/ySZmwzfhHkm0rvJpDnQS8ThxwXhFV7ho4AJPB/0P1/09ZcltQALIN30tYDifS0LTj8LUh+/tfnJeieKtQNC/QAFaxyvV5sPYtb3h6QO3oyvQ5XxkAuel4cX7ExKjuGfW8EhCRoSEKEO+HcHdEAL8AC9dA4G+MSo2uc0PAkEeKCSyuC14awRZoOw8+cU5LBwrr1wHAb3ECdK4n8Yyt7+718YVKESYIWZTmAE2g4gKFEiREmZsEOLCJEhQ4chwoHXoCUzRizZMmbPqkXbGM1ZMWG0VHm6o+ZIli1ozqhcmeZLmDBfXLp5OfNlGDdw3NS0qbOnT5sxgwoNqiWNFi1Rkv9GQbqUaZo0Z6BKvaKlTFUtUdOYzAKlK9cZMWbI0DEjR44YMGKghSFDhtoUaEGATQtWbdkcOHLw2MvjiposgNdgybKDsI4cYOuqzeHDTBkeefXyKIOHj6BHjzCJKoUKValRnTRhmsRI0GMcMDo8UADigQEFGUB4eODBAwgQMHDksXw5cyfOrV7ZggWr1q3juXLhWs6cFy/ltmK9eoUrlnXh1o8ZK9ZLly6QrmixUqXKlKpNmSRJCiXHyxg6VhgSIWNlPnxKsxY5IUTHCR1ChBxCB0LHEFPMMcs4A81G10QDjTO1lNLJJaCAAokaWuywwxZbHLWSGjHBFOJMJN70k03/NPWE4ktDtcjEi0rFKGNSRalUxhU4lqFSjjdShUVXUAB2kg8+YKEDFj5k4YMSTDaJxQ457ICFGVpgcYUPR+hwhA9PcNmYGVde4VgZT2CBpA856BDDbR10AEKbGWTwQAZt1lnbnbblxkMemWHSyZ+dYCLoJI8gkkceZfCBiCN3+GFIIIxEookpp6wSXHC2JMeLLbg45+kuuIDKHKfLyWLqqaiiussvvvwSTDDHIBgMMLoAo4wqffSRSCKA/OEFEDQ0QcMKQhThAkJkzHcIIUTs90myDfXnhBVOTNsfGYQMo4wzznD0YDG6rDKhJolMqokeaFBJ1VEengHiUDTx5NNO//OuyGKL+H6xlIxHHJFUv0rxiGOOOZ5Rho4/QoESG2usYcYabKBhxx17tCFHG2140cYeFd9xRxtLQLEEEm1suMUSNYwFxQxJYoEGGldkuQNaKaSg2gM4z/kAAzwrwDMDCvgc9AEHMPAACKjp9kgnm3WGSiqx2CI1qbk8Bwwtx9WqSy/AhBrqLmD7Anaqqu6Sqi+t/mIMMmwn00wzzzwjjTTTUHPNNdvcHdEywAxziy6zJLGEEE38IUdDL7xA7QvzNfvfD/QVQkh8lNBRRBGPO1GEFVZs7h8dCnJkEEikcJJeeopUmEgWbGTxxBHseqjGu0LFy1OK86qI4hczuSRivv9fFMXUv0oBHMURAx+MI/IDN3/GFlmggTEbDLNhhx167NFH9l507157NkixBBBB1FDDEjbUoELNKqwPgs0dpADD+7fR6aacRmfgwfz775WoIIhgxCQm4adRoCI4sNAUMIgBjGAQ41Wv+oUEg4E2sclCbLz42i7QtotgbLCCEgzh2pDhtre9LW50m0Y2uNGNFrrwhdzQhgy7kY1ucGMb23jGLxj4HVXMoAQnKMINnHCDHxjhBy9A4g9QYIRNEMEIT3SCEQ6hikMwxHKb49y0NscfI8SnI8fQBS1I4QlQqCITn/iEQBZxiEpIog1rQAMUnrAurKzkDPj6ne9wl7ud3G7/d7zTY0zYNSN+HaEMR0hTv/oVA+QdRgeHCUsMdEBHHB0GB4cxyxVikAIViIV9FviA/XKmswY8wE2teUADMpCDLEWhDHkQRCQIiAlNdMIUq2AFcWoBjL4NoxgHihUxiGGMYhpzghAsZgRZhTZmtsoXEPwF29ZmQrjNjRrWwIY2WOiNcHhTHuCMhzdsyI0YgiMe9JjHOs5BDnKAAxzf+MYLW6iNbGyjGh4EpjBUIYcVcMAFZJgWEX7wAyssQnEFTRYRFvqDhQaoc0aggxH8Y4X+wKeiFZ3cMMaYiUxY4hKSqMQnQkEJNhJiEZQwhMaggAQt1PGOeGxRGJhQO9ztTif2/+rdTUSEUxPB5ClABSrxjtevHMBAfjEwy2KMepum1uypKUglKWmTgQYYDWgKaIApFXA0EJilDL3JzChIMdZT0EIYaC2GMta6jLYm6K1ubatFlpGMutZ1hGzLq6uM8aq85rWEKJyGNbJBWG6MMxzgTKxiF0uPxjr2sfEAhzfG+Q1wzEMf+uhHP/6hj3nMIx7rgGc8uwGOcl4jGa0ahjBMsQUabAADJLDCCciwiB+YYKBJRAHjjEAGIxBiP3RY6Obm4xABkWEgDIEifTZRiUpsYhOS6OgmQrGJPXghEdAtBBeaIIUkIAEJM2DXGV6GBtoBTyg9BYq9djoiQbKXCcIr3v8idVCDGJivkZxkkyrhJCetqhJnPDPlzzKQmyu84TKCuMwANTGKU5yiFK0wTi8NFKsKxyquCHKrXS3C4boy48PMSAaImVHNE8pNGtRAcTZr2M1uLhacjrWHjO2B2Rrb+MY2/oeOdawPGdMjHt58p2X1sWPONlYe8wjHOpYMZG9soxlqG8YwTmEHGUjBBBtwwAtWsIIWqKAFK2DBQlmARMVJdAIRpQ+2ertQ2grIPwxZiBWaKJA6b4ISlcjEHxLxB+fKoRBCkIIQlrADJOxAJUdBSXmL8oWWPCUqagDqUdLwhkpXOqiYrnTvKP2GoAYPKWpa3lnWAoP5xckDqpkNzvT/ZxvZ4AYHk8GDHgTBiEdMohOjaPAqYOEdYAgDmL+scIIsfIwNG7uuyChm25LxVxIaG25yq1s2tWnYbyo2xjOW8Y37kVkc/2Oz39asuDVb5HKHW9yc7bE637lkGhdZH/RYbDzmAc5wSMNVwKSFJXRAgxJsIAITuFwTPqCBPcjBBC/grRfjbAX+TO7OnCPCf3y7CCJU1Iv8sbgaQ6FGVZB0pGqc7icqIYS2uAUtarFLytOS8pS7pdQsh/n8anZU2bS61G9q6ps6EKec4Y9nOwM6zmy+P1jvBoAEtKWuLQULW9QiOcnZWi97QfVeeIoXXNvF1XnBQbCFrYJgh6ZfS2hN/xUPdoUuZPc86LEOdsyjHuxgRzvwgQ8bi9vu4r4HPr7Nd3P73e90p/s/9r5jwusYH+SQYT210Q1y1AOz+GgHaNchz24wHpzYSAasNuoISvyBBj/oMuSqRYY/SOJZVbzisujQ0EVwbhazsCgZClGEaVWLDrhfPRk+sYk0UoLjlHhu75+7iEXQwOQtZ/nKS41ytaRFflF9n8xLLb/pT/82ucEBrPnyv7DaWhOiyPUpUGGpVrii6bUwji54sX6sP0eDXvf6cuJftq+DfYSAPTE1sDlYxndjst4ADuEAZPTmWQboWfXQDu3gDgv4Dg7ogPcQgREYeIEngfewDxi4D5qVgf8Z2A/7gA/7wHchuFmb9YF/d4KadQ/oIEOERVjasA5EpmNuxw6jFUPywA3MYAzJMAy5EAigRwZF8AJO8AM3cAOLoAqUgBB/UAjCoAyHMB/8oVDT4mZywAV/cAhywB8ZxR8opRB0IHxpRF13Vme/RwmFYANl4RbapyYtt3zW94bap308EAVpUAeV0RuQUEudQAqlcAqtEBzCMTVXBwzOYXVU5xyxwByKyByg4nVkU38bpDZ/dULXZA2DxUItxG5uNw/jgA7ooIDvgA/94A4P+A7w8A734A7pwA7pQIoWKIH74ID4UA+0WHcUeIuiOG7gVmSBp4G+6IHA+IvwoIG4KHj/fpd336B4igeDO7aK50B5/ucNz0BCxyAMiAADK/ADGYdEmHNcdHAD3+gEYxAKqlBR9GFFZDB61EIGcrAQhVA5RXBSbCQgdFAIhXBnoSCGIVdn+UgJcgBJkMR9ZiEZfVEGdVAHu2EZAeQIk3AJSseHfwgLtIA13lErveRLw3CRwFB1wbB1YSN/8VdB8fdBrRIMxtQ2lFiJlpgN29RCAfiS4NB2cRcPNBkP5HAOnpiT6GAO6sCTPKkOQBmU8DCUwwgP7uAOw4iBpIiKKah3+DAP+EBj9oAP9ECVPXaVmTVuh1eMQ8mBXsmB/WB4J3h4wKgPlFdZosUOOpZ36dAOycgN/9kgDcjADHwzCXLhAkX0A8GVLERIBkU0hFbgBU1QCAMCIA0RH1bUH3IgB04gB8H3H4fQOQSBe/b4XCRlZ3W2CPm4CH9gCInACJBgCYJiS7hGCqegSxT5HWmlDMAETMQWK61ZDMNkTMU0TFL2QBBEQRPEKq7SKnnVDGRXdvtnidiADdXmTYi1WGtHD/bAnDJ2DpInefUAlemQDujQlgnYDjiJDu9wlPzgDuVQDuZgDulAnuLZk0EJlENZihN4Y3RHZPDJWYMnePCpD8VYjJB3D02pi/zZn015Dw5Iiuggd5TXTvH0DePwDt+mgaM4Du+kDc3wYc4wDJmQAh9wAy3gAv+JYwRGIBBFoI1WQFABUghXmJgIsQiQeY+H8AcNUQiHUDmH8AMLkAAB9x//EXxq9HvPtUY6ugifgFa/xlbO4FbcUqRGqgxtNaRxpWHHxmx+NU3KJmImFG3VcDc4FIDWlpwvtqWP1VjZhmOY9XdaaW4fmJQSGKDVeZTuoA5repRdyaA7hmPGOJZxCqZ2amO4SIt6Cndq2qfVWZ2eOA7igA7jcJPksGQF2k7psKDw0A/vQA7JKJfM4BGacAUyUAEn4AIaOlBEcAib4B+hwHpX9GehYEXTgizFRwihwJmGQwdZeEUR4ADgCCAAcoX2GHwlNSCHQJgNsQhNuFZC2lYgZqT/Q6qk3CKsH3ZC0IZCdFOchVVON1RO3pBY8Vat2HaVUomtd7qtYUqn/gmm8kmna8l3G8iBXel3DOqB6cqf85mneqqAnnioSyZk7SRaQvYN7XQO+rqv7dSv5DAO46CACth26tR2oMif89AN1hChz+AMpYAYGjABDiACKIAtR9Sh+lFQ1UJd1UIILMoQWhh8hCA5k6M5AYUtJIUttFqrtroQy5IQh1ktcpAJswCsSLphI0aXS3oRVYpDhtVNWspYR/Zi2oZua4luuhifMSiu5eYPTOufmtVt3Da1S/u05QqMUPt3xfgO7RB3+tpOAHugYhtPYUu29Vqoz7ivcbe27HAO/3HXDm23Du0AlfagTjO4ZOxQD++ZWVEJZNyAN9ewDJPAAx8gAQ4QAT9AAhMlcShaBBLnuEVAH0UgBDcQuXG2H/Y4siOLew23egCyCJuwsotQCD56CE7gomtkBYWwEHQwBm0ACJJgCq6gDHdTN9eADdTQDNPwCxkWV8wADdswWVoqZOy2ZJnFgPOQeIsnQ+CwgPrZDxHIgekGeVVJD1gJeecmbuu6lRH4n/xJd77IoB8IvfAAgqK4oPy5rlBrtLo4vZHntfIaWvcqDgCbr277tjPZDqXYnUcJoKJYD6E4d3Ubd57ldjK2ds2ZwI71WeuQTqAVd6HFdjaEDRHBDMBQCv+ToAUqQAKwJVG75UUDVVEf2jn16B9ysIROILIKQQa7Srowugggu6svaoYNsRCfgLrI4h/wyI4ycDJ+IAiv0GJAa3ncMA3EgCBIbFfSwA3yMIDMSbxLdg6L2g/wcA/1kIz15ILr4IDsi241lm0+Zr0UiIHlug9duYuDt75Ii7Xjpr5G+20SqIsA+g4y9r5te5PnALB6LA5j+06QSrwxibdyp4BxR4tzW8DsgJSo+LwA6g6i+J7TqcAK/GOArIyEtZKWmMmWCJcUPA3PYAyyICGY0AcqsAKvVVAvoKFQNFEY+jkGpQooVS1OQAahcBDRgnvzeAiY44X8gRD0OLIuegj/vDc5l9NwPzDLRSAHktAFcQDEk2VY8kB5kuUNDbIMwaQdwYAM0tANoPV4aMlk+nu+/3DFWeyC8SCWRaZZ9wl5tjiLO5aCXExuhafG9Nyfa0l3hqyA4rDP/Dxa9KQNYuvH+grBSwapBzqTiBpaiMq2m+hZjeVZE2jFXDt37zAP98AO8/pO/6zJlrh/Hv3RIB3SeiMNzBAMtoAKD6YJkcAGNrACGHACiWMFLkAEM90fkUurNop7wYXLKEoHZrirKxyFrvpnAuFwhCAHu4rLlRNQnOM5JLoHY/DDvOAN3NAMyBAO9CBP4dAg0aAMFXbEfSUN4ZC881C86xAP7aC3m6UP//GweC34DejstE47pjxWd3p31/gQivhwpt0Zx0XWgfRMruT6p9bpiewkqGOb2PEkZN0Q0O7Ur/CU0O1U0AmNqJNX2Qy8DkoWk/daeZbXghwd2qId0qQ9DXMzN9cwDTmIC6kAGqFxCZmQCIqwCRvwAplqBS2ARNgiZgMVj50joq6nZrNMByhVCE5ABC1QBKtqBXdGB0vYEDj9Z5wDuhjVHw3nBH/wB0IgBHOACMtA1dTwDOHwDevwf9CQCwbxS1I2DL0gQclgDd4kv0p21grIY2apjINFDln5xoOHgY0qbua7Dxc44PoJpoGXWXEMva9I2ISN2OPwDXzMzxK+zzipx//92rbstA79WtkJPQ7rMKAg7onw+onwyuHy69k0lA2iveKZPJyDxdH8N5wePQ3VUA0zTg00buPTsOOm/Qw5yAuvgAqgIQqgwAmaoAhfVgIr8AItwAItQASKcwi5PcLp2I0EUR+NeboKQQjHzFtfKCD2uKK37NN/9twVtR8i7ASm2o5CQAWQ4Awtlg3hAA7/tw3G0AqgwAiaAKTCUCuv8t5BJoDgrKCchQ9YXE/W8IL6sL3pbMbpCoLZe3eQl8/ZyQ6B+uCKrdh8rNj0OtmH3a/3S9DxwA6g1Yk5Ca8EbIAEbaAHasksDuOv3tGkzeKkXeO2zuO2Xg3TAA0+ngzcEQv/EkIooNCQHzUHJQBELMACJHACTX4CI8DsiWO6BCUg3Vh7Q6TmxfehUDQgPv0JMKw5s8wQnrcJ2GKyC1EtnUMEtcdlLQAEemAL2xAOLUZa8rAN0cAKAeQJpXMLfV4rrtIM1xCAgSx39/Df/+CWLEhY3VAPbNzF8tyu7SDRp/61mJ7pEI7YEQ7hleWvkA0OHF+ooD7QGC3IBM1kNCm3hCpaL5TwLx7rsQ7So+3R1kDa1GDj+2fjOp5CPL7zPC4NNb7rz6B5GxQLngEamOAIplAh5fEHGkBEHPD0I7ABzj4CN3ACK2ACViCELZBEP5DcJKDc+nE4llMfaYY5wWzT/gEg/0BoAo5re881OddiBSYARE2QCJ2wDNsArZOVN9FgCpKwK5mgCJYwC8fBC8SQbM0QvDGZtxeYrgj/2QCdWeFWbnQ3x+igrxXf6smo6RO+z/VLr5Rt4pNX8iNv4oAMT5aX8C2o4i3u8q7v+i7e4jeO4zuv6zy/43Nj2rkPDbz/DBH6YRPhC9WRCqnwCqmA0qVACsrvHbAnCSrQ9CQwAhVAAi8Q/SOAAl1/AiTg5FDeAt6v/f0xXR1be0aUcBNFByTQjv6xegJiBSNgLfSRwjDMLM3yl5bzB5dwCsDgDDV+N9DwEQABqlEhQ59UaeIE7FixZcmYMZvGrVs4evr6XcSoz/8ePY707H3UF1JkPZLtTLJjdy7eynjrVrqEGY9du5LtUJrEWW9ePZo85/0E2tFjx3g/Wa5bB06p0m5NtT3Vli1bVKlPpXKDmlUbN65dJXbDKjEsVqllvZLNtk3tNmxt3b6Fi+3aXLrV7FabJu3ZM2bJkiEzFuwXL1yxDMd61SrV4sWJYdmqBQtWrVq0dOkSVklFiRMYKpDA0ALFDysuRKBwMcLFD9QorBD60cIFoUM/nFgpEspJixcurBj5QYcQHSdF6Cw6RHwRpSJFrFihg9sJcDpGTgh3IZwQGTqVQHkqFu2YM2W0VqmSVEhSJVOqQGVyVUtZsWMOmz3jJm+dvn//GP+F7OineuIZkJ142tmJwJ1+EooeoxwEap6i5sGnQnxEqjDCnz6yZx6ijALHKarKsqZEE08skUQTy5LKLRZf1Gabs7yScUZu1upqLbfYiouuue6aBpq9HvILsMEKO+yVV1JRDBUnnWwlSimlVLIVya58rJbLMpFBhQ1eOAEFz0wzgo4fXCCBhB8IKcQIFGS74cxFaHPhBjroIOKHNY1wgrvobiPDCkrYvPMQQpz4gQjuivjBCEeJsCKUQ4xowQoinPiDEk88YeUyYT71ZJND1Kvkk0sU4WQST3RRpiFmnkFGmmxcymeffv75B58BW1qnHnfa+TUddtyp551igUUH/x2TaiJpwXvswYfDDjWchx2kkmIKKhKpMZEab7/lFtxuUSS3XGuo8dGaueLaUS12sWGLx7Xmlesau4Lcq5m+AAvGl13+lSVJxhaLUklUpFwl4VUOnrKVVaZUUsnHbHkMlvh0ySQLJUpYoQXrSBDBBdeIIAEFFERQkwgjyEATtRuIuJQMR88087k8rXDCCULmhI0OP19r4Ycidr7NihfuJCI6mIsggrZDvCPFFMuUEeaSTw6hRBVDHPHDEU0aSYTVZZhppuxmpPmmnnwuytUmXtchZ5y4zxmHHXTsthsndKhFqcNryfnmGxGtyoZcb0sEN3HFva2GmmqsabzxxRU/l/9xyX1M117MN8f8XmmgEVLfvwITzF9cZAkYMSVVj7iViB2D5RVXEF6FFVYSPuWUgxObcnYqI7YleFhasX0VTjTJhAYa6HjhMyJcwEDN31wgQoQJRHaBDCfqzFO2Rpu7gXpGiXgBgxPsRI6MHwIlg5DXhsMTOiKSK4IMMvIcmpAX5hdukVJBUYUqQiEJSVDCCoeQxBwyoYpKOGITm/AEKHrhjNBJQxrWcEc/3GGrfbgjJee4FkquhRRrwY0c5ACH4LSiIsRNzoKTg+HiWthCyp3rLo+rxjWm4bgb2uuGP5xGXiwIjc/la1/GCMwvTIe6wyQpSa+DYpRc8YrYucKKV5z/nSsk4wrbdVFhCYsSGLUopSleKRdXWgUsVOGJD8jhD0OzggkmMAEjWIE1JBAZCkiGgTOdAHuHYtpqLpWoM+XxBSI4wfpws0jhWIE7L3DkbRylPaHZkWmEIATMoLOI5WyiEpWQxCIKcRtMilIYs/CDJGZxCC6g4RHOUAs3lLIOe1ikHzxBylJCFKKmYEUb1ihc5ahhQWJ664XF/JY0grhDagSxmctc5jOhmZdoSi5xwhQX4u7yo2nccJnVGGK+yoYMcibRF/5CXTpjkYrDNKYxS4Kn61oXpScx7EkOox0rrJgYLK7Cigq7nRh91zDXXakWt7AYLVRxCUB84AMa4A0H/0hgggpgQAQ/cJ4ITnMCkJWMeqghAZ/UV4ScMS18RYCkyojgHEoMijv2s1+iHGUpo/WpT4dgGhFugCgnUCIUnwjFLCQhhOLEhgibIEQoBvgHN7JSDngQRCmiwY11YSNF1iBmVrVqwb08Y6tezWoQlSnErW51mVqFZlinSdaxPhNcO2Tr54T0jLL1xS9/4ZcSAZZOvqozdU+MWGOkVE9U5M6whnXSYXXXCsI2NrEKQwVkT5GwLt4OYljShSvOI4kUWGADEsXAC0bwgheQgAgVzVPITnCak5XMZC44Qc7etwjoACdRQdPpDV5Qv02YyUx5ChTMprOd22yCtoMqAiXUh/+bpH5ClGRoDg1I8wJCGJcShZDDdpgnBEWQohYMYYYxyImMZDTjrue1K9nMtt6utresY1Xme+U7XyHGNa16Eaddy2nOc/5rF774RYCRyN8l9hUXB+arYVL3CsPMk7GEPWwpJFyKU0x4whW+cIXridiFNfaLX4SiQa/oiTZoQAIYkGMFJsBHK+jxBySwox/PdCYUcLRONygCalywiE3slDvIQVQRbrCCF+jMCdFxjhOSdgj73YzJ7qMEkw+RtFDIIWc7o8Qi/lCIHxtqOGwqxB/IYCjh0MEQnlCFLo6xDDaP7SFke4Yz5OyMh9ynvV0VEujCWlZqTvNe3dzm5n7oTXz/GbEvx0AiMQQT4HPywr+O9u9/AXzOXwQDiaMzRqUp/V9I88LTuNjFgXNxYFKTuhbBQ3WqsWQxLE6xSgWLncSUNEUrOqx2xfuwPq1oWYdNhhaToYyWbiEMT+xhDzcYwQQigAHPvGAFEzjN9PCYJzy6wNooIIQRZpNjF/QJNYqiAyU2QSntdSxPWPuE+7SrZJglDZOOtNQNHOlGS23Zfm7sEybdRwemVmI7doSkEw5hCljoohjOaLObmeGMOM9ZznG+817miueIgw4aaw1iNKoRDY6vFXRDenMykFi6/vqX1LlA+cl5gXJPe7oXj+bFOX0R80pf2hgiD0bOldhynrN8/xeeHnWpcZFqolMMS63e5xSlSMWIHX3Xur7iF/Wpa1ZMaTKrpgUthAGKPdDgBoSoQEWZPQIUj0BMiSTBCUhmsjCpTI/bW1MLmIZHpsksOcGZ05GTtomWSirIVsCxc+xXP+eQVFIkzdkfvMAFLlhZe30SGqb+0FtLvaBSXkiEKVyhC2C0qj7oXTidH17nOttZ4hR/hsVVb3GHM6PNx1gIMWQ/mE8LXeixsD2og4fyXPDc97/vRS+AAQxeAKMXsicG7BHdL73S/vc8/xfvg1504cUidlUkYxYHKsWCafGKlf1+QCkb0OJV3UqokIw/9TkLUOyABkKggNhBa6YX/MCPJf+zMdYwsBptl8Z9LgAOa7u2FgiFTaCe9pmFRbgBMriBQ1CFTdCZQlipoiICFtCT4siTlQIqOriBOBG3JpiDJtAe9WmUcJMDOfCCPcgu+zMCNskEWmCFXCiGVnGVu3qIhFM4Ogu9h2M4HaSzhlC+Y0A+YjC+XgC6A6OYJMS9A8M9Wxi6oXPC4CG1VBM66WO55+O54AMG2dvCXjAG2VuzZVg+weCFYMDCTnM0oJs+6jO6K7kigmoY8Zs68bu12rFDOhw/MLKS9Aso9qOBFFiBGyCBEYiAOAq7F2CBS1mtMwEZDBizPIIZPLG255HEOnkxFMAT/KEDLruTTSiCQwgFBaT/LaERsul6mRcYsjFzgg68AU6igyLYBCtTMtIgguUgg0KwRe6IwMz7NYNbM/pANPEKwmFMBtgrhgGTPTL0l1DLhTZctWeUDOujQtuTQt47teC5hWZ0wqCzvZ+DOd8TvuEbwmCAPb+ojwEbuZzTueB7PpYrNZSjjKJbtVpzGDz8sPGzrA+LrHvMwy+CBfNgBVVoj0ywgQ+ggSKQgEbEJAzggNBYARNoARJQHwyoMRHYPxeogD46k+fZMUIYjdUgA7lbwFUcslYEHzr4qeYQGiJogUHSk/rDmRvARRIoBCw7BKyRA6bZH0uhg034hEpwKb4rhE34A0kIIMvQhWEQwiGU/71hGL7LIAxRS7UmaqKI0T4sagWkm5hYCJ7DsAXD6EqwhIx4pIxsRDVS+7QsREOe20LkM0blazMvvLm/KBKR+8KcM0J2rD1c6LlcoAwoRDWn+z5+/KLJ+iLaWZiEeRLCVBjzCKAAugQZKAESqD8SqIAWoAQxGYELMAESuIATUA3TCLu2MxkSoAM0sbYbaLs8sbb2yRkUELhVhC5CKAI5oIHXADwcu5SvcwIWoA2+w5mVMoIF3ATSKLMOtIIWGIL6I4NZmAVOPA5JCAVVSARVugxgUEpjGD4jbLnLuIXvTDnqe4zXkYx5kh3ue0PigRgoWp3VocomQjXDeEdbGDWW4//OLASGYCAGJArCu2qzmwu58wKMuxwMvVw5lCvClbvG76SMecQie2RMwsS1CJU6VxBIU8iEFKCADTC7FgiZ0xiBDTiEFjCBDUC2NEEk2DqZkLE/a7sOPEEBHEMBMlCFKUvOkaxF4gBFWGwCwvvEV9SpnBE3GtWNI0MUSJkUlcoZPcGtOmKynBkz7KqEQ9iDJciETxmGYqCP7Qy+LvXObLzGysi6X5vHLVqF15kSwqQnOCSoiGkwBuNKJhQ16dMFXqhT7uzS4ctPSxvGzytGhgMdZiCvv7C0dAywXzDQljNClCO6eHzGgUpMfCKoeyQoLaonfrQdLnrM9pCEDnAACpj/gBFQsVGdAA54ATLwqVUsnzShHiI4AdnwDbWzvEaJqZYkAt1YjdG4lKThNzIQgp2SgxtwvDspstw6BJ1ZhFckjVBgyTIJNztaHyfYH+1Zmf3pqUN4I+4AvCJogitVhm9VhizV0mEg12G4jHPlve9k0GtMtWAby2AbU3g1KCz5tVO7xlEjOis80N47Q3AMvl/YQkStNP3MOV8gBl8oVGOIhml4BpkLtVBjwoBhIvZcp4FhjCpJhQ2TMAyzMAmrp44tBcLy2FQohYptjFhoBWC4BWDQBU9ohEYAhEC4Ay6ggRJQNgzYgOgZVWbbgA04gUKghBUgARaInogclBX4gRcw/4GkZVL7MwFGMYETILJEsrzcugEW+Do6WAFULYT384LaLALq0S2sDZSh2S06YIEW8BlIgY1GQRR1gw3qSZRPmIU/EA71yRMn8AJNEAZwzVKnLAandEqWRddc+NLvlEJcODVaCLbGFVPGpQwyvZIxlQx7DR52HTp9VUN+5YX7VEuX+9dKa8tFq7RdqLQAYwa6KNhGyz2IPZ0mSoXAslgnAdnatd2OHRjUMV0kKhuwqgZoOAZlIA9SiIEO0AAKKIHkLYGcZS1LwYAQvQAMaI4VwICmGUSLFFUWABOhZQHKLC0OMIHujZMTKC0TeI6SEq4fwNpTpYNPKI4i+AO7rR8yYP8BE0gaaT2ETag/lFrAFVBW2+jNWoyk1bAjK1AFSviDUByO4WwBIWgDRqCFb9XTciXXpzzXC7ZCe72FyvhHx42Myv1grGvXVGPUWhi1XcgFFPa9FH4+mXNhFz7USlO0gaXhwGCGtWiGAQ2GLk3U3CsMODUMdmISxkCFxZgwUUDiJBYFCWMMWfgv8SovC0qRrvCGcJCHK/YGb+CGZzCGZVCGVcgBEHioCygBFtBey2S2HSMDstuAFpiArV0BDnWCFSC7UK1AE4haEuAAE90A+7VAjnoBDvgBiapAHmsBJ1AqMqDaOd4AORCCShCGPRACnyIEM46TH9iEUDCaA4oN0oD/rg6Erh/QLePItys7BDnAReEwlPqRgzlYg0RQhcDVU+ys4F644Fu2QshY16zz4Mho0FVjQ1TjPVwIOt7rV+6cNCViNEo71JxLRhpeNBv0BWOIM/GYZhqOYYeNtFDrq25Op/+qNPKCM6/KIXjhiqZAZ10CB2xZ53igh3AIB2+QBsBwBl0oAxCQAQ1wgAkwgREYARM4JDGJHrWDHrJTsQvoWRLYANAQAQ4YAREYgTMegbQ7gROwQJLp3gvQXhbojFosghWoLjMBnzl2AiH4BGc4hDFYDiFbGkE5Vv5FxTuRyVD4g2RdhOYYlPk5hDlwIwYMFGTFRSIQgjGQhDvQA06g/wWnzAVgCFyn9NJbPld1PSh13WDIddx3DeYRdsLvhEITNubnE77OBdjTJd2BFYxgaMsh/AVFo7NSeISMRQVbKAWlJAZc0LkYzuYX/gUoHucXAiaJCIeVkAcGcZAGgZAIIYl6CCFemYeNkIdw4AZqeIYgYQQcgAE5WIEIWDGLtMgI8BiFJoEISMic3QAJ6NmJ5o0VYzb7CxPWPgH1eVXZqCPybYGBDg6WpA1GeZn8XTwZkINZ2IQm+INatEA9qTv6Mxohg99Tajw5OFYjIwNROQQv+FoaeKnkMOQWkINNGIM9UAJGQAVhMFda1lNbhurDleqDatyxzOpgxlwk9GrDrf9TLMxTYABYdcRv0u0FsxaMTPsFZjgGXuhiZzgGivG0gUWi8fKL3lUmdcEGbshieJbwKxYKDhEJi7CljLjwDf8IengbuAEHenAKx4GGZIAFRMgBHbDZOUo7QVbaNJ7oF7sAhTZtNs5Zi9ps64joPDkkMLG8E6CNRaixoCFflFEyI7C8FuhAIUjpFuBpISjATFkE0mKBPkmu2jiT9mkOVXAGVTjBnDGU8x2zUCgELwDJY6WEOyGDFdCpVyxpGUAEUzhXcs3T4Ltlqha2DXbX9hYeyQhmbjw5lJvvRB0MACtC4zM+0j3rADvrRu+XnBO5vR6dXbi5yZ4GYMqGbgCHeLj/4k6nB3n49AofCsPmCGkBiVq6cA4BkaUAi67QlqlQl99lBmAoBUxAhDewAA0IuwVIOxJoAX9+3pytAA7EgFWcgITEWRIoVfOxnhrbv+twH5mZ6Pb5dZb8cTSZHyMIqV6NExK4gTkoBCCYPFVAjk2wwBcoExy7jRs4ZE80YFPYA+HmDlG5DUWZBVWYgz8oDkKYBUrImUXYHm9PGqORAhqwA0/4lKQswqe+c6rOZaK7ElWLxj8vNRQm5iv0NBjG62VeZplj9ARf8L2IrxzSi96dBmzwBgqXlg1n+ZDAiIz49E73dAeJBwkPEcHRJXTW+VafkbW4hhJ/hU7ABEgQhEDQ/9AIWAAE4ABTTbvPih40CdEVQBOe7dlhpwMRKJ/LBBPkKK0iowTW4LHX5qQfbxSb+QEe2wRh4I5XFYI/cEBJkAOVVh/SYtq6FzLZagIhCDP04Q4eXwRJ2UTgAEXtmTx/F846MgJW3gNQEAb6CNxxTT4tbWpy/RTN0iIqip3BKuKMZU/ytL73XMLTMbBtjjQYFi/yYnBp4JZskIilCGyZ73SW8BAL13BTt/0LqZB7qAd0OAcU8oadd3UboREZiQp3aQsekYt6wQtmCAZcKIVJeARIcAREqAENwADNZug4vgDT9vY5OoELmPGPtpO0ExUZ0xMi4AAycN8QvQ4rwKOQ5P8TIyAfEbiToJE7wLOCfo9jtXMCGshJrwMIJy9etPhh0IiTIlZ+rChCROEPIX/k3CDyw8qQHxadOCH0aZMVOiJv3JBDRqQRK0ZeiKRD5JCcPZyEFRtWrOawnMOA8dSlC5hPWrBq1YIFy5atVkpboWrKtCnUpammpnr1KhbWrLK2ct3l6+svZMiSNWv2TNo0a9aycesGDly8uPHmxaMnj549fXr14qu3V19ee4Lt4evbLl06d+3irXvbze23b4+7adP22DLlypq1ZeuMjRvobaJHkwZt+rRobNuwsb52bRo0ZsFitSqF6RGmS47iaJiAAQOKCREwlLhAYcWICRU2MN//cGIFpUVOTmwgQeIEBiKEmK+o8IIEhoQbMJwYcYOgCxItXJAxQqjFjRULV9wgRGjBiRMkaLC4wUKICywQMaBKRBhhERk/JFTEDy7c4IIQN/zgUkoGtvCCE+6F5JJGRTC4CRn2DRTSIBeRIUcloMwiDFDAFANML8P0oksvPQVl1FFIwfLKUk8x9RRUVAmZylZe+WLMWGWdRc1abXnjTThyxSMPO/PMI5g+hWVZzz369JOlYPSISdc65LwV2TeYXbZZZZ25iY2bccrZ2VpyspYNa6ytpic3o+Xpp56kufZabMHs8koppHSCCSmgkPJHCSuYAN4FJFxwwQo0XOACESNg/9DcCS1Y0WkLlZY3ggk3cDDCCyZc8MIFCpIwwgpEvDBCfvq9YEURqVrBQgsmELECfbS+8BwLDgnU0IGjGuTCCw8VUoSEHFV0wyGUnKCdSO0ZSEeGu1JCySFFFALiInQYsdJCdJBxUkymqKKLMD8Bw2IvudyyL7+00GILLgEHHMtVsmiVSixFgiWWktJQQw1rbT0GpTdvhRNOY3DNNQ89VlrZDjvorINOO+2MIw7KKafJJsstt/zmnXjiqRbN1mBTs2c125znoK615lo11wRdzTTSSAPNM844w0wyxhDDyy68xGLLK6ecYooprqjyiQoqlBBBC4RUUEIJGiyyiQMjEP8hQgQrbDDBBi3Qwd0IJKywqqsccJDsBiyMcMEGkq7wW3YpBXtRES1Q8sML/XnoBAsssDSsFWQU8cJJZFhR4IBOhESIdHRQwqsR3fJaBEdkOEHGIoQ4dDa5hzhBh0OjZuhSgVY4wcUnmaQ47y0+6RK88EDVEjwvUIOFJDJlmSWNzZZBGY48F8tzvZj0zDXYYBd7H45jmbWZDc5zyuky+pydv9mbMrOms1rVUDN0NfXbT3TRSD/TDDNMI2PML3zBi4FZ5RWpKMVUoAIVWChlFatQBQRnQQo0aEADFOgbJWjAnAj8gAwtQMFw4FYBCQCOECcAHAkqgIEJcOAGG0iOFTb/oZ+/vaB1GBgBsE7wgyIcQnYkcMkNnCAEIVCkCH/woBM24QRK/EEID1mi5gykuQMpiA6yw5YciqA61SmEDh1U4kkOsbnotOcG7nkXQsC1iIUQQSWq+4MXmrAGScyrXrqYBR5noYpVwEIYNjFGMqSxjSdd7y6GzB5eEolIvAxmHmUCB5ooMyf4qYV8O8vTzdRyJ9WYLxvji5Nm3ASaNo0PG6VUy8OKZrRnsJJ/yUjG/wK4C67IYkgHLEUpRiEKXPISl6M4BSpOUQqrWc0VsGCFAyGoClNIIgXFKYEJAqdBwFWAgz+YgAgwIAEJbKACvrmACCOwAb1dgANO4AAJerWC/xbohxCHIAEH9HPDExCCEiRgiBVC8YIVCOEQf3DCH27AIMu5rggjIEQhCHQQz7VRcjx8Fx0qZxAyTGsOYyiEKg5BCCtQwkDpIkMbxbiIcjlBjDdQnUAfQoaS3IALf6jEJnoniUIUwhCJSIQhOiEMZSyDGc+4BvUKKdShak8ukzlqN7ihPraABk6gXKqd3MQ+mOVJZnPCpGioeg1sCA1/0mBlK5khFmMEg6y+2MUssWKwrMTClkKCCi9HMYpcylWuothlL4dJilM00IGr4EQMaBCp1V2Amyxwwg9EoNgKiGAEL8QA4CTggOV0swIOuAB2MGCCFnyQAy9wAQpegAERHP+rArPiwAZM8ANCsCCaN1BFEUrwh0308A+EABBMaCCHQ9SndYVIF0LI0MMbwCdbtEuIE04qEi94QQ5/oOkiHNI51pHhE6EgxCY6Ojsr3OAPHtIdEa7VQTL8obx/EKN95jCHNiDCE8uABjSkUQ1uVOw0o4QqKDvzydCQRjT2fYx9QZPUAPfJT/7FJM9aUz9VrnJ/TIOlMcgawLN+ZZa03ApbrYIVqwjJgG9VYF7zKtcQ8xIVrTjFKqwGCjR4zbEM4YADWsAB5PjmBMpZjggqMAIHMEcC2vzUDTBQzd+QgBBE4AB5rkMCFJygmhOaFAn6M4K6rSBZAJ0FbX8rBwp8Yhb/QGjCIaJbhEUs4hO0s0hE4UMEd0WUi7ySA0fkYEXa7dAg1KLDLAoxrkKEYlp/YPMh6LDRyo1xoydxJ03pUAiNIlQS7tWf0Zj0MCZdUpMItnRruNqzQVX1TwhGcGoCpeBJT6NoYHVwMh7cjFT7D0nBeHWEXx2MX9Ba1rT+yleSx4tc8DoXuLAFWwnGo1QspSm9rKso6qrsUdDCFbS4hVGOB5Th0eITH6DACFpAOMVmM8dC9qZybryBCyxHyBMYgWlRMNpPkeAGJ5iU3yDLAhSYgAXPkc4N1HOIVrEAOXTIqCqwnMc/0OAQTaDBGBbxBy60TnUDCi8RWlAEk5zoiEUY/wlA5aDldNmKJeUqgiT+0AQyh/lcGwVdRGf3Ltb1sKSB/q2g7UMIOigCFMToHzOUxEqj8dxo05hf0AYF9K3ybKub/jSCgVY/noO1LP17JSzFIvUIU13qYmHag6NOVqrHWtZeF6Cud93rXNiC10gBtrB51COoCPPYJIZFs40JC1e0Ytq0AIUKHDABbWMAPBhogbd9M1okT+DGk4LsBaac2QqggA5/CyLchAUeE7TqBSiwFWe/w4IfBKveVZ55EwxR3kXM4hCZ+sMYUF+uTRTCCQ+JkEL+EIoeFsK5mwOpufyZXT4TArEa4W6Xz1v6G3TrIu7KEEcecvFxiW4T7lxEIf9mbsVCNIIUwDhG/5bhjFOfOr7wjW+pp3G/oAutZ/czGnxbyb+sT53r7h9r1aV+jPkfI8JST8YyevpK+Lv/1b/wejCAna7twtidnQHiCAIahSssIDL5lQMFEzGhmAMdEysckysMjy6Qwgxc1tsQjgcKWQQUHgmIQOFhAAewUDeNR36AB3a8ACHUjY6Z4AjszZJFS4kwTqjMinpYhw4VQXmsUwtECBEkV3wgFJmdhEJ4Dq8IwRjk3h8oHB2MgRipjhU9lyoQ1Oy9wA+QxCGEQihEV3TtELg0ixXYh+pwhBUsAiU8X7rQXiGIxCEUgiKYAi8EwzHgn9KA1fZxHx/uz/r/4Rz7UR0A+p8vvBoxBMMhHqL7GcP8UR39MSKS0J8kjkWqad/SLAPUjQXXEcMheh2M9ELYjR2v1cIoEoUtGMXZ1cLZxR0D+lVTOKADGRMrLOAqYI0u3J0MWAAFaMAFEI4L+AZpJVbhYVM23RC6XUoErAoZvEA3oYATTMAJ6E3dQOOsfEdB1BsKtEDk+A0LRNlpFcRDLISHrJPkcGEojAEdbIIXeY7qhAR5OYRIOIEcmESYsdnqHMJKUUIoLOMLIMRKrFkaEoKCpIQXqQu5JMShOV8aapQVxWEPhdkfOIIq5ML15V/+OUNPYeIrudqs4dpXCAxIygJajSRJ8kIv1Agn/3IiIqYkJy4i84jF/t3fHc4f/rFazvmUM9whMyxNTEYYS/IEUIJiKJqdKiagAi7FAroCjzyQKjQgLDogMqHCAi4T1qgC3mkAcwDOb4jAgZDguqibkCkWeChWeZCAOF0KOFVAPIGHNHJAOYEl44nWBPAgc+zNsUjONtIH5hEES4iKD6LOCbgLETzX6kyEhyhEG/HKSXRERPGKYkqIQUTLD6zLwxmB7BhBgljEIAxC6egOrwhaIXyORjHaQ5LZH0jCLCBPjAAl1AiMVgQbbE4NsAGMwIxk2OlajfAES8qaSy7i1NWfTtok1jlDqhXnWP3PTwalUIbir50djhQQdPYIsf8pEDEFU1RYRSssICloQiUogiHcASCoQAOQ0HBsmwu+wARYHuFgU9+RZQtMWTLiyt/oB5LN4A+kCiHMijcNXrDATWrd0A/YmxXg43M8xwdpYeQQRBG4QAm4AIcYxCYo0R9wl7SciDy23uxwxOrojmBqIQoYAQrkjna0kRYeBEtoTrTEY7eQWUOSnBvGIR3Rgi4gRa8hBVag3YZBp44WkFG8Qo4YIG0GTEnyAljQ2v8NYlmV1fu131hYHdRBA2zw3y9ImP/9wnLuAkiCZFYAWwHZUgGplUj6wpSOhU9BQzQEXTXAlzLgQQZ8gAI0gAI4gAU5wGUtAAb8gHVwJRGkR+H/gRsJigDgucAJgZN1VAd5WEHdrIpvXN59YkAI/kZr9V0FmIBmGcEMbsBD3NN9jgAKdCrnicAWOsgYgEgX+RMRCQG1DCi4kEEoUMLF0U7lKEQhzMInrMBFPBzuOEu0jMpCHMggLILqNEvmZIt9lKY79RDojJQkgMK/4AJW8FqwXQXBTAV0wqaNAunZ/VqW4oJt4hqR1prXkZWS9qb9Td1YQQM2VMP/iKuYGumE4RpaXZi8iqRX/B8gJcMzwJf4XYNoPIm//qs3FNg2CM0ylAIigEADUMACxCkFSJYELIADLECDgMe6pBBj+Z26kcALiIALEM6q4Ip1YAC4cIBqfYcK/61NpxIOus2gW/6GCTgWPH1HeGksCVAeHYjAnvITELjAJqzR5hBBIXiXhxTCJ7gOn82CFYzBRhmBQxgEIcyeQG3OZCIEYiVXEdQTuHTEElHCSbhqSS0aQ4ZZsoJOyPUQJXyCJOSULXhFMMSSkXpdrW3drNXSkOyohsXCtnJr1BjJhIGrSvImMYjrIsKauAYgL0CDayRDR76rR4JFWd2fT6FF0KgGfU3P93jPk0xGaGgaJrnGNETDMxhDLpACJryBBVgAnWLADewYCe0ncJDAXG7lCo2WCFyHCulHC8DTCJTUpWqEZ4XErWST5PzAaAXLlN0QPBnElL0svw1E5DCO6/9RAh20AJ+FAhfs4xDO3B+4wMSZ5rvgIzrS2YSojka0o8w548x5iHaM1ObYjkhUDteKziLMXhnWI+gglCKcVw8pnCEIQio0j1n4IdQNsNVJXQBdmLNOjcDkwlAOIEk2Lri6qwT/3wRPaZViYk89A879D5k+z75uA2g8yeWGw5PY12pcA83MjM3MDJ78SQj3yTVEQ06e4ihwgiF0gAUswAL4hmRVB5L1XXqEbJ5GgA5lE3j456qEBx2UBwvoDeXNCgo0VgtUABVbR/CKQDZ+hwlYwSzQwd/h4PNq4UCsR+l8wGw5Q5+VCxHIwekUwRgQ0btQi0IIQYIYxKh0kRJJ3xr/NibqPCHXao7m8MrqEAElzAJCIdQbLtoaluG5CEMlqAJtkcEmkK4sIImSkMWqOSlMwmQmnhVagaSuMTAD32byGGmRtqsEQ/D/FenjdnDOPQMuYMIv1JIsJAMIWy4JB+xp0MnDWMOk/XIqhd/D1M8wE7POcC7RxIYx4EIugcIkJEIQ5PACqFAFKAi6qdC6fVBYTrHGUnFjFZ6nmIAJnA0LYQALMIdAoJPfqVAK3ekJsAAW5+45j4B0REoQfUc/YohLrJMRLNwYbEEoRAMl+McJRNdsXZwXcIHlOAH3JkR4jYp88Err0ME+eo5gVtFItZ7udMS7eA6ytpw+Rl+Y4SNF/4XCLJh0dn3CJ0QCJngFABdwhAVQ33pkvZ6VSYLiSeb0SfKCKU9wuLprK8NkzjlPpG0VCFfuk2BDMojkMhjDVzTDalgSKgEzVVND0YQfVjOYzwFdqQVNn2ga0ciXBh8DMOQCKvwSKZCCJwQBxIZgBCwAfUiAcKzQCF4HCQLHetKukM2nZ9mbOVuHxlJHpZygsFTed8ATCnCACKxARHGAPZ9H5rlHuZCEdgStJOCUKkhCpPxAQFlXE3BBIXCBG5vE6XCEQoQEPtKBC3ThFr2vgpAB1yZESKhc74WIEYzvIiiDMEAXmY3U2UhCd5qCMpReIDxCwohpIX6yLOTtSFYYlv/etK4pJzAgKZLYH6uVxVbbjJOIsPVUz/f462RkwzZQgysxAzTUDzZQ2lSTGv5kdfj1HHzzHIOd2tP55C9ADcGsQlOYwimwgh4pggZErA5HwGRBFuyOVsiyk2/0qV6f22q9QAWU0wXUGwcEy3jcQDTtDXL4zWqtC+BFWUWEQnywAA0UAYgISLsRApZNi/QSgRB4QRvsgQyoQBM8SBZFXxN4wcK58XmNARFwUTuejcm9i0ZYUfqijs9erX1EVLe4hHA9oTB8gm2RZhwGbdBugjD0mR/wQSngGq1h6QI3Z5Byq97qLVqBhSJSIlmcxb5iA8BarlBRz3cj1YDdVzd4UlP/icbQcNUKr7dVi5/9lJrPCfr36Y8rRV1HxmstAYkv4VWipDUpmAIeJQIFgBOBJ8A0R0AEJIcD9F0JqptvDIc3KdZoRUAFqE7NltPH1g12JI7flBTq5NsH4eMHETmvbIJAdeEiCNStvMDZAqsqEEIQNVcbNBGqzs48FsIYzME8NsEbCpQWmXZIUcImpHGbXdzMbc6cRdTMDYK6hMSBhAjJ1Z47yRzoMNpz/Vag/QEiiMLCGMPegjlINverwWTD1I9R05ecB9X1XK431Pm/Dlg3vHnAA5jEDHxSfYbQ3Mk1iHfRjV9YI82h/08AfnICp12X+gij91LbCVNaz0IlpABz/yyACGxABCQAnU7AOWu6uYXb7JKgqXMAFcu83UgOYXcUaoHHYWNKcmlECxCLrRgBJUwHYpHeIngBbRXBYdFBuxVCyF2trdzA/FaCJAz05QUtF8wBF8gBF4A2s1PEmpEvm1mBdWXLGWa75ljRurgRkwvmusD2IcwCJciZ6AQa6HxC6/SQokXfIuwBJGCCLIjpWMxaWmFFvf5fMkDDLefyv2IulIBDUn0SKWkGwp+GNgjYxGTuZBT8UbGFamwDzajPVH+Vg7UaISo6V2TFjmYn3bWCA7r+U/TSWc/VKKS1JchACWyTptOpphM4BriNcAjeaAU/MJagOOnYDNLsQXUKOiyZwAy5yqavwLuRR2id6AiExKxSAgvUntJPyEkdAheUuDshhBduvey4gAsEBAAh+QQAZAAAACwAAAAAQAEAAYfnvZ/bsJHZq4zTqo7UpYTOo4fLooXGoIXLmnbDmXu/mHy+k3O6lny4kne6kHK0kHXBjGG6jWu4jGy3jm+2imi0jXG0i2m0iGe0h2ezh2SxjG+xiWqxh2axhmKti3KsiG2shmq4gVCxhGGwhGKuhGOvg2CugWCshGWtgmGsgV6sf16og2qogmOof2Cofl6ne12nfFmmelijgWijf2SifmOifWKifF2efmaffGGge2Cde2CgemCeeV+jeVmfeVydel+ceVyaeWCkd1ahd1med1uhdVOhcU6ec1adeF2ddl2ddlqdc1ecd16cd1ucdFqcc1yccFCbeF2bdV2bdlmbclybc1ibb0+ad12ad1uZdVyZdlmadVmZdFmacV2acVuZcF2ZcFqZcVWZbk6Xdl2YdVqXdVmXc1qXdFeXc1eWclmWcVeWcVWYb1uYb1mWcFmWcFSXblaWbFKXbUyWakqTcliTcFWTblaTblGRb1aRbVONb1mRa1OPa1ORa02Oa1GKa1SWZ0WRZ0ePZkmNaE+OY0SLZ1CKZ0uKY0mKYECHZk6GYkqFYEyGYESAY06BYEmCX0Z9XkiJWzqDW0CAW0N+XER+WUF5W0Z4V0R6WD94Vj58VDh2UztzUz5zUjl2TzVxTzh0TDF3RSVsUT5sTjlrTThsSzVlSzhnSDRoRi5iRjJcRjZkQSpfQS1eQC1bQC5bPitYPy1TPzBgOh9ZOiZXOiZWOyhVOCVTOipTOSVTNiNQOipQNiVQNSRPMyFLNyhJNCVLMiFFMiVRLxpLLxxJLx5ILBlELyBEKxo/LSA9KhxFJhE+JRQ6JRc0JBk8Hgs0HQ4vHRAuFwgnGQ4jFQojEwcbEwogDwQaDwUWDgUSDQQaCAAUCAERCQIQAwAMCAILBgEMAQAICAIHBwEIBgEEBwAFBgADBgAHBQAEBQACBQAGBAADBAACBAAGAgAEAwADAgACAwABAgAAAgAIAAAGAAAEAAADAAACAQABAQACAAEBAAIBAAAAAQIAAQAAAAIAAAAI/wCtWBFz5MWGAhpsDHnxAsqRInKgBIJC4kggKz16HHERqM+aNW+KCIGRAoUKFy5MjMCAIYOJFCU6dCg5IoWKFCfqzOJF7NizbtGO5RLWqxYvUjR6FIkBA0bGIlCExBDyNAZTGC5OwiCBomuKpi5IpkhB4qvNFC9VqF2rdoQJEyqw3nxbooSJmCVQcLgwoq/MmBlEZMhQ96uQIodQrbI1bBmworUiR4blqtWry69q0aLVKhWrV7Yi25p1atSp06gtfz4FiVSuyMCoWdNmrTa1adGgQWPGG1mwWKpUMdMWbQwDBQoMHFieoHkC5s8NSC9QQDqB6wMECMiuvXuA7uC3D/8YT718hTiPMFFK9AfHhxU46jCi1MkUrGfatnXbT9saNdm1WXHEEUMM4cIBBgzRg4IDQjUHFEUUMaCBYQRyBBSMnPHGFEW4UJNab42QgVtwwdTBYB2U4EIMPZwwwynDEENMNEA508uNuOzyig5NMZVCWIf1yJRULowVF1ZjeYVSkWWNFQMUVsgFlk1FGGElDCUQNlYJfdXF5V968TXCiYMNJsKZMIkAQxFWHFLKLIw5wwtkkk2WWWR34glaaJrNksppqKSyCiqsFHrZKJawEtktuySTDDLIPAppML/84oulvugSy6bILNMIAw0w8NwBzpVaKoLSpUrdddoRwF14sIr/Nx55BgyA0B70bUJJEGOs8AEOUeDhyCiipHKMNvt1U5t//skWBoFHLHHEBANsMEQYYdjwAkSBGNgDCi8o2AMUfVjBSB9V+FDkWX315ZJaQKbQwQUZdPBSChZUAMmNxSzjr425BFzLMHS08FWRKDQlpcIuoNBXXFmNNZYLSi215FcRwqBWUzBRWYQKI3BZ15j1thtyCSXtJVOZGVBA2JkliKBCEXMQIgkqswhTjDPEAEOLLbbQUqdmQWsmtGhAJ03LK6x41korrJwyC9SZKXonLMAFB5wpwaliCtdef22KKKY08kADDSgwKnJsq23qqKhOh52rsdatHXm2FjDAARrs/5HJJp0kosMYP7yHQxmKZHLafd2AM8001fxXWzRyiCGHFdK2IJ0NNhyxoINyFFHggBvBEIYcfQhCRAsjnCTvXhxkgIFbdYUFWL0o6/WAGbP0ckwxrlxSSy/CDIOLK8VQ0kJTrh+5cVYgj9CVWhKXhMJXPRa5LvRvodVXCk8KIfvIdclkvr3dpzDCBRyMKUL5M8UsgsuGMYKKMDo7UwwuSQe9GdFA+9n/asEnpc2CaZ9BINNaoZlaXM0VYhvbJSxhiQlaohEUvGAjNviHFTTgbGl7TtuQ8zZToWpV16Gb3QQQgBbebVbjMUABDgCCQVTiE5SgxB/GEAUayGAGUcjDI/84QYpU/GIa1pgGNa7BLGo4BErSCgO1NuADH1xLDFDIIoHC0IMWKMWLGUFEC06Agi9xYC8SoAAF4mc+lHkPLiWwgAZWwIpe9OsYunhMLm40vFUkJQY3GRNNpOewEbTvetbriiIXWciuEPItKpFJyFyyvsG0zi6RbOOYpLc+DnwJZSeaX70GU4I12U8YS2MFL3hhi1wEcDM/wwUubkFLWtailreQ5S1CgxkEsmIWv3yFZV4hNFikQhTITKYoNLjBZv5BD8+8AQgdkDYFHOA4I2RbCZsznQKk0FWv0k4Lx+nCF9qKPDPsWyUeAQlIOMIPZIjCDDywgiD84RKjIIUqdAH/jWZJLotymEMc4iCIJSgnDFYMA0GgIIYwDKEgL8jIt1xwgiOIYQMoaFm9LqBGCvBFBZHMwMFMULIOOKACD9hE8ZThDGAQYxi54EUucDEUH9ggBh66AF/OJ5P29cUrjkRkklDQAUJ2oH0gVQuX3BUyEWWAXiYoKsnKRKYOOKyoX1rZYNSoUZkV4WbCsAQn9kjTgPXPFrKcJS5zmdZd7IJ/fHJgoVhhC8y0UmivgAUpLGgJZE6wEX8ILAehqYcgPABUFUgbNtEWKmy2bZsJUBUKVShOcloWhi2c1QE+UIhPWBASiqADGj7wAA/IIAuJGwUnRGEMAGnDiVCYQ0SgsIQh/0yRc9hSyhz6QKAhaIt5JZDACOQQJgrEjqs6Laokpcoleo1pASj1gx1/14s53ai6r1DGIMKignld4Khn1OkZTabIjiVpTDJx5PdIcpOrSrIv7POpVuvFU5TFJGRb8lKWWkYBEfwICpqQRVghkQqjrDJgZkVrWtV6i1vKcherfCsuIjPhp22GmAO8TPAg0UwKDlYP0HwmiHvFABCCKm0fBCHaGAAqx5LQhKmSG92yY9nLiicA5DnADD+wiVV0whGQoAQk8OArDzwAPnVwhCUywQlVPKM21xjIHAYihwKdwAAJ8EELphCGPkABEYFwqLd6IIQSUEACEThCDDzKUTZT4P976rOLX9rVPg444AEawMEshlEMZQDjz9cFRi2UsQkaqG9eazzjXuJLyEaaV31ntKoKGnm9SReSA1ZFQXIt7RcUhehDSl1Z9STWgfelaCZW0MQqlMFqx8jUlUmj8IJnSWtcRNitsqyTK1xhNP8RsBad4XAzGyFsPYwBxMgeAx2keWIHHKfEKX6AihnL4myeKsYyxM54alzjAijgAR+owQxA0IDlrKAUwkBFO9uJgxX4qrQy0IGwVmuKX0RDG1gknRjmMIchkMAAJ7ACInpAiIIHQg6IkG1ERqBGjnJgDiTYywgkIKaToCQmKhFRpknAlQ1sgAU4WIUzWAro6/ICF8r/mEUOWEeBBSyAMF3qC1yUWoK1ZDx6kmzvWnoAg64EyUkjMYm8frpIQxJVfXz5rkxUYN9Tp+hHTQkEKmTBUmc44xjHiHBb3erWVXrd1l/PES9sGZnKXGZow+tFKgLLdkhcYoLCbiZ7/hCED1Tg7neXtt6lzdjGulibpyIVgqgDQxZy+zvbcUAVJoGJTXgCFJ5YQwMK0IBPREMZp0hFKh6hiDqMQQcfCJUO6OAIIpriFcsYXRahBAU5HCEBDiCXRmrWETEMYQ5C6EAa1SiBh7tgvJp+2Fq4BLIMYJoritwAB1gwg0y0+s+PudHJ+ZwHFjA8AguwOdNPNnMQhQwuMDCk/08LaROITSxiKrAC7ilQgqWYzC+LVjqjTySvmMwEd+WPASKm3meWFgMYt8Z1AjiAOSJharULtgQLDtQKRzNAw2MLpjAGYxAEQXADyIZsbNcI7IEH7qEBHuiBefcAKKV3fbdi1lZCg6c3s2J43CYABTABYaAJoKAYwkBoH7A3D/AJtYELqeAIj/AIflCBpPUBMjAGiZAJpXAaUCEGliMHARUIc8ABCeACvRUIhGBRJzAE4YdmHUUBFjAuyrcBlTQTEsMlGZdeKMACargBJ+ACNDAIfbYMPRN91bVKzkAJLJBREeAAbAFSdrFUdOEXKNNd6SUv7ENIJ3ACLNACKMBxjv/YiC6QRS7QU5h2VDqFXkSldCcyL+ezRvj1I/snC/0nh70wa7pkimQnGbCwiqtYC6zYGWgXGb2QC6RQWDdwA0VIBxIogReoB7o4biDwAcLoAR6gAXdnjHu3d9T2bNbmNidEeONRWeTkggkAAoyACTMICozAAgpgKwfwAJwwG8egQYmQCMuGiysgAziAB5SQCagAFRGiRWIgED0AewoxBFAgUQtxARHAexGQRhNgAYGQiCTwZnD2EmZIPj9iAyjBhi7gA2cwC8ogh9AXfX/mDKgwAyqQAQ7gAG/BFnBxF+9nf0W1U9IjaQ5zAiRwAi0wRhwQcRzQiC85FuN1VGOiUyb/mYkedSKXeCLIVRM2gQgzqDPFUAwxIoC61GBD04qxODSukAoMJGtqNYujsEO3WIS7KIG6OGJjcAU4oIYrAALBKIwfaIwhqIwlGCrZ5IwyVB7RKI2Itx0FIIJngyo6hmPfKArW0A3PUDYb5AiJIIFlIAO/QgeKUAkKAwNMERZN0QMWkAAo8FtNQRUSgGYRcJmXeWYS8CwsyQGHVnOQBJolEhacYwMWwJI90ASgwGpz+FLD4FJYJww6QAIcyYehOTKtQ3MyF1UtAzsmwVA9wAJL4gJjtJIwyXEd0CQ0UVQc0FEc5TD1okYtgSL8lUbfpRYvgAgyKAtDMQw3kmBAI0tn/6U0P9M/tkZhvOBAacVWadULtnAJiVCB7nYDOsArWcmVWbADaigD7haWwuhxZYl3eNeRacliBqpNzwiN3HF45IRZmgWONGINt3BBjpBDhoAFdBAE6XgDdAAWEAMvMMAQsNcCYcFzQjABC+AAlnmZDvCPFpCdESUW6qM+JJJUIMqQLiABZeECNvAIxXAMLuVSwzCkxJAMxOAMeXABGDABHukl7TIi3tcuNTcmibZJUzFGakicinQCZ+SIyMcVi7YXDdech2YCOpUBTJclXOgyozQCLlBwjCCDq0A8swhrQBNTCJanCHZdfDonQ3o8RjFTOdKetQBYQUCY8PEDOnAFE/+YlWmQBlngAzXQAuLGn2Eplh63AR94jAPakdTUdwbqWKMSY9AIlwzaQgCQWeMBjtTQDdrQl41wCZDwCI5QBkFgBjfwATfgh1wiMTAwEkLgAAlgAQ3TATCgew7gcnuYosk6AROwAYIwBCeQAuxTVDQKUtMDL2HRkhPwXSlgA2kgkTFiDK4ZI8xgDM7QCRywpA6AAmciGO/zroLREqa2fZx0PV3BAmTUkiiQiP26FxZAcV1KFhbAZjiZXDsVnRKApm6RAZYpnQ7LF63XB4fACJnwCkOhp3zKp0PqnTfSsSDbsXUFdl0nYWoXWL0ijDNQA/RJgRQogWagBltABJyzAzX/QAMzwJ+JKJaYqqkBOoIk+EEliE3NsRxx400LalmpGgAAsLRMu7R50wCmMBu0sQseRmx/UJ8z8AEqUSI/ohVN0QIJsABHdwEO0HIul6wquocUJwG3p5LtYhLC95EWhxItuYcUQKI0UArKwGfHICMxQgzMcAzOMAstwAFMynTvMyIqkSUsYSZZknE/YkiIyAEnoAKMKJM42T4cZQHsMxiVuGhqFCY3yVESgAELOxiWqaJnpqQx8AJHIAiGcAiUgAlMxgm4ywmdwAmfkLu5+wmfQCyrNQrES7ykQAqiQAqZhwt1OCcnt0enEFhE5is/JAP0WZ/2OQZpgAZKYFNEwAM5/3Czaji+J4CpHuizZimgyQiqL+YcJ0RZ5NS08ju/UEt4MkAK96YN2gANftkIgFkGNPAD1cMWh9EDEbUABhABKuCcF7AAmImZaYQBakQILYABMZlxPoVJbuQ8mnYBJMACNpADjGCUxPCjxVDCxLAMQNoLLMCkDrBUZYQCLzEmGGABGNACL2ACJKACj/iSkNQVHBc9dfFUaiRV+GVGHLABFmABG+CILUACyue5EjcvHIBmzioBARsBF6ACS3AHgnAIh2AIe7AHfjAIZjwIhmAIZ3zGhlAIhZAIZlyOcmwGIZYIpOA7MlKRH0sKf5AIeZAGOLCyNcADV8CoEmifdZAHa/8QBlNgU+I2A/oKAu42lmWZvnqHUgVabe27HN20gqeKeDCUN3rDAJBAI+AwD/OADKaAu4x3oUXiFivSFBFSBBnBAQWgwC2DmQ6srA/cjxeQRbMzAhFnwW6xfSRQGGV4RopoA01wB7lglEVJDMZwws6wDHZUBw/gck8lphcgt8J8Rl3BAVlhEju8EnRGzJOkU25GJmXSZkv8zkx8Asqnr0rsufaMxV4YAROwh75sAUdwB6kjCH1wB35wB3eQB2M8xn7gB3tw0AldxnlgBwk9xkyQBXgQWHf8t3/2C9G3R5cgvWOAAzJQAzWAA4pqn7xSBnmQB3VwB3CgBDRrAyQNySz/MMmU/AGbOoJnmckuNqrloYIs2IKygk57wwCN8BOnDA7QsEyNoAictxaMqZhCEBVF0IgIjAH82KLYt9VcjWZphAJRqGjihXxXxXFltCXihQI1MAUzgArQ3DPTfKTLsAvKgAnZvAAm4DASRxMmAS8vsDxMBzIgk0ZbRQEtgdWEUQIS3HANZ7q7d7CNfQEac2YTgMVntMRYbAFMWtmVaQE2YAVyINDYEgZVUAWjXdphcAekPdrY8gasjS1VMAM7cAV1gAeo0BjQ9wt1CDSOAGK62G7iRgM40LJBsKhqsNAIrchosAVTQAQ+EL44OwMrwAI8K5Zkmb7qO20rpslsqSrR/+hCQh3KA9BCBWDUSL0N20ANscBhfbwxVtGY8KgCL4ACE2AADszP+P3AXdiPHWIBital5ZUkJPCJfcGSPlAFLDAJxSMjxkCuO9NSwLAKGpCsmEZIY5Gbk/aSkBg9DAuxLEMvHHWmTvW4/NVmONlRFCc9F1CZmd1T8OysAesA3TouA7IEPjAFS1DapT0FSqAEU1AFMM3jzt3jREDkPk4EgnwFdLAKfTaHun1yo+HbXckDK5Cz1XsDPxAEJq0GZlzGBX0Ha7DcTfDcOwDdND3d1E3Jm2qWych3fbfJKfjdpjpOQz3es8IAf3AMrpof14AMotDH2qOYTBEDERIWMRABI/+wAAiQtsnKy/q94i0KLv+t4dcTFihREuXXXS/ZAgrBAmfwzONKrj5xdbcgDDRQ2YoJFT1wEykgEhpj1iQAR4VxPiezMjFnSU3VVByF1SfuUeGFrL7MAf59AUsckAEpAVfs31PhAg+1INBSINBuA7X1UL61IJzjA0RABNQOAoq4A3QgkcogI3NYXb2wCsoGqVfQQ/3pbjSwA+CbA2uQxrNrCH0w0GHOBc2d7T6wAzbQAuOrr+Vr3cJIlgJ6lmdDoERbtNPxlnNeTrPSoAdwA7tADdpwDdiwv64gCkaiFVNR1RrD4hGAAIvucrx83xC8hyraMPG1w9CjmGCBEgozaTj/DO05wOQxEgyi/gwqDAvFwAcNIAEmQeg8xzCTxhWT1jozR1JyZj7trAJSUUlO5S4hHn+X6DD+2LqajezOuvVcL8XkTDFjdAKlOfMG8gIuwBAtSaL+3pJnb/YbAALMlwZMrgwn3DN1mAuf8ANMwAQ4gLPr7m4zEL5VXgeHoAiKwAiKoMYD/Qb3Xtow7chpT77Vbd1mid06XQGfSkJsSXjecXgv1LQ4Nh55SSPbkB/R8AqVDvNCAKwlsOIUoKIJgABja/K9jJkt2pHi/JJcQaJZERYvwDkM8QJTggKcviAJXjzAgPO/Y3XHcAu9kAkaAPSV3pI3sRYO40ghsn3BvBJK/8oS9AJzI8Ilhj0YvK7OarTEHqfZz6rEIG/FLqz1LP5maMTETMrEANrESZyp+u9xFaAB+68AANGggoY6s4op65WQVy5bDRetgPjBgwYNEC2uAFFBQYUqjBg9AqnIkKFBfe7cefNmDRouW5r48GFDZosWLGyeOAFC5waKPXtWGFjhwQMHDRgoOJogwQEDBZwOGCAgwFSqVQUMAJAVQIABXD38uWVMFyxTnFK4QBujiBAXMFRIgEshgoMFBhIsWBAhbwS+ePn+nXuhhQoUNNG6UKHCxQuZL1wMVuEWBQrGNlqsEdYL2OZjxZ45WwZs1ioQE05MJsGBxOTEKlKM6NCBg/+LERlUZMA9AkMGDBQu4KYwYoSJ2sIz/K6N4cLyCxQkWLAgYcIEBw4mQJewwUJz6Q7gUoerN4KECxyWc+AgwQHP6ROeW5igAShQikEHUuSJ9IEGPKtesSrFFFJGIXCUT/L4IMEP5KsII4w0UKCAAAzY4aNJKqnkEUVEIsmkPfa4o46VXCKCiJgsq+mmnEDYoMUWffoJqKIaKEoBBZZq6qmoquLxKq22ouoABr6yhJNUbEkhhhRgKMItt0ZYzjm+JECAAPHk8k2uv+CCrjzKXBjiiB4OcwEFFgwz7IUYYoABLRja9GEVZYg5ZhlnnFGmmGKGYSWXPEBAD70WSFgShRT/WlOBBAtGmGwEDhzFAAMOIn1Ut0pXU8GE1CrVDS4SeAJqugo2GJWnDU7YYFANJji1xfbce061FjRo1UUXQUCVJ1o3wFUDED4AgSIWfWWAgQc8UKQUTka5xBJnm73EESQSpGhBa4Nt4ACoplrhkEkm2QSTDUnyIw+U6qjjDZZc8sHEHGpI8QSbdNIJRp/mG+qBBvY1ysYDmHKqgB15JBgqgw8eQIEP+JjFmWLO6mEtGGJIrITajqOAAhGoTCDjv7SMIGPf0COBhBNeeCHMIRxrEwWcaEpTMcJQUMwFFjTJbBg9lRGmmMxYsWWSUzlAITUSYIAshckmqzRSDEYgQbdI/6FGQTfhhCMhsdQo7Q0uW9mzLr4KFrAuKKMcwK8o6zaYjoMN3HZ7ggrEto5svI5SQFsD8l7q33+b4gqqMRKBJBNIIGnEkUUUL0QBu/w9wMa8DxB42wBWYOTCTTIJaaSS7vgQpTXW4GKKLaZ4SSZ4Z5jBJhZ0UlBBGIEaat+i8MbRgKYGJpgqAa46uPICDGDgikxSgbiHGHqAoeramvONNwzqkkDL6vkSeWSiTyChBRd66MGxxybD6TSbvPfeNZoV4+COUk5JhRVWXkEFlVNO4YQVVHJAlYMToCPamxDjGqOhR1IlK9mkVJNAqF3NBChQjW4uAJewvao6C2iA5PqmO//dVc5yU/kgwX40QhKWsIR0aMThHLHCRCwiEYngw1FqNx8H5C1guoMK5iaRiU10ghKU0JDnBjEIP5QrDyIa3YimYKIT1YAGrisfvV60oPoI5QFC2VdSDqCU3XWld7773e8GICGoFCByHhgDDJiXJCEIhwMdwBgFMiA1CtwlZCHTUvbKs0D/keAxMFuayUx2msKYaWmNMpMjIGGJTHRiE5ugBCYON4pV5OFtC9TO0dwyM5pRIFIigwsG1HNBvOClOuOhywISQACp8MiEr4QlVaDCQQNEbnJ8U8ACJMcAfhmrAfrqZeQYEIRZZMISlzjcIxyhIUUUgopA+YBGEpCj4dX/8l8sUEQlevgJTGACiIzgkOeKaK6TiA4NJEJdE12nopzwilpVpF0WNThNHfEOjGEUI/DM+C8GvGlQh6JAerIEl7jAJQEI2Mv18JilQLWIAxNITYuwAx/3WMA8EoXOdrijnjq8cJki8YMiEvGHRpCCDDhhwWlcwL0TkMxoRcOaCYgTKeiN0jvj2aNyMOCAadJSKT/96Y0SYCO89ItfAqnAL6ejgbWdgFb+Y1tKW/Q6Fm1gPWhzKn121YIVDYUBhehFJi7BCUhQwhFmZVw0g7IAyt1wi0O10Q4OgQlPfIKbmKgEJSbBzA0dQoh+6INJzMmFM5xBC+mUiQ1qAEWc0Oud/zGakQIymLcOGqyVBMOnGMvot58agAAE0B0CaMlBBPx0ARKIwAUWKrLjmOcCFmiRAwKgz1reZQHXee10ogMr1PI0ATgooiEOUQg7DLEQJH1FJtYgL5d5bwNwuUDRXmsBEojyAsIRZfUo6IDxzMU7BCUPQT05we+8ijqiao92rFMd3YbNou+VznRwwqrXuWpuDhiVT1q0kxOEwQY5ydcmhMGJZVGirIpMHB8mUoEaGqCM1XwrBh+ABkZUwhOl+EQmMtHNb4EEJOA8hF89F1jBpkQlhp0CTGCiWJqsEyOw+8CL5MPg6vQLRzq6bI/CCMIbFoCUSlFlKlVpW1RWb3rj8f/YxyiQUeiwrZTsnQ53LYoeJoNXOkNdQR78MJJDxAGwfiCpMIShiZSiiroS+NQeodub8YQHMKUMWXytQ0Hefme9qayOekxJnVLatoLV8c5yUAAXKu+2Vd9p8tocyraB6IQFttLAB1AhjE18glmfQEUnEAcJPSQoWx50iu6APIEHfGAQG75wKR65Obz+8IcfBrGIR0zik7zBsFpA8Ypt4IIatM4mL5YiPBmcwdzhGLM7BuHBDMXT1FKAu1MaJSq5C148drd6S36PRZ+LnfeglkvRIegEIiDu6l1AKR/QMkkKEYc7DMIQhWhEK5SxijWwoAIWuGP/ihYdfF/b287uLpL/VRseCYjSO84RMilLuXDbAtXhQD0tXdAzgsCwjVXXcc8F/xyf6jA4qdR50QNWIAthjHUUnLBFZhxhiUbgoQIMyNEY3TrUBkR6BowoRSY+UYpMO5LV3ezmqz/8CI8wIsQjMYQgAlvrlKzBsEpYcQ7e5evyNfZX97pgZ42t4xz7zslDnsuehWzKJ5sS0Gd/lZX5bPazf6c7QtbLbQ2xoUdMwt3uVqQpnCGMRyyIAqVMVHwmYDf2kocD8LltfLez5gvsRjlvBDdB27yl6zkASqh1W1Jp1B4HRO84F1ABHNnGE+8oajsQxAAKLECX7HB8X3LLcwVsAII08GxA8XOGLVax/+FEfKCLoebgvyTb6BkoYveU2ISqN7dhTGTih3v1MDg3pAgRE7EkJQ7DErZwupfkQLG7hiK9qlqf/WBxsltsqz2PDTyoEAAvzl4AQskGaFPq5dnPbk958+ycJb+WvOIuPHGbEvI6pfC4KbK5A0V4hG7yA3dThBUiBWVwBlTAAe4pJRh4AVQZPPUYt2yjqDqTDoJCjhIwgSzBNosCwIUTsunAC+rIogYguy1pmwwYN1KpANSCowwYr+OojgSYoPVKKrThlQoAAR8AAUVwhl4QBVO4H1ZgpEpwg08LmOHxmy3SD185geITBla4hJ3bBE94JOYDOgz5Fugjur5Cug4pMf+VWInSMRGok4nHSKky24nZ0RcNApioQLZjM5gCsAC/UEHAEMSMubbsASXtkY1NMQ9u+7aRSY1+843Xeo5SQoNJoIRKmAQ0qAE/YAQDs4RcWIZcKARa0YsEgCr5mAAMWL0p2y0+q6DpQK2FUii+gMWHoj9TyqXzmj+lkByyc0Urog4HWD08ygAEiAArAAQhUIES8A68GKUFIBUN2A8N2JdfyYNZwJ9RIAVUCJdHWIG2cqt/WYqh4iUixIjiO4hUIIVT+EJN0IRwaT4NA7puwkQzlL5xmTUjOiKnOwPSWSKYqIGAZJ15iZ2eACajUIo8JAA9/B2rYL8BIAT4QC28MEb/Q6weHcyAHMQNOIKe30hEBCIB2VhEJpuu7eiABNqOw8soCSCbBgCCvJqEQ/CDLagDScCER7gEVogGZ+iEBUklnsgXX6EOiyKBkgzG84oy7orEjNktQLu484LBXMqlGsogYsslXZIcpDiKX9IXurAjvoCA+JsDWQiFSIgERCCEOXA2uZgAtwEBFmgdGoiCH1iDPlCETziFTuiETwCFTUgDBhiewNSdt4IrpBAIX1mBD5iBROiFaCiGVEiFT/AEdwxDDbPMeaTHMvSwMzw6dyMJIsqDIzKX0TmnJmCiqWMBB4Gd+sAvuhCqpmiKhdTD2cosqFgFQXguwHCO6diSj/k3/ysrt/IASZJxGyZzESYDIPRYtD8sihmYhOarhIoYhI+ghEs4BQnMBRxYlVySjysaCIvblRbBia/BCQ64j5+gkaTipaGYj/sQCqGAkYnYFRC4CBlgnRnAAR3QgRxAAhuIASMoAgiAAASAgEgIhbI0SwMNBU0gBDEABEIwS0I4gpSIgzRgtz4ABVkoBT4wgzUYBA2gplATR7g6inKklRVggQ/YgT+ghWiIBmBIhb30BDBcvlVbvm6SR3rERFf7sOmbPnEioj04InXhgpbovl6DS4LEusnqG4CpnMzCJ2eQhTvQgBZAPEnUjukgRN9AzpT8mrepOrfRDopqsjFFThcJFP8OCBtswtGP8Ja8EitbcEIZwBYiTBDxwxV5WScWqIHHkAklUAIbaAItcIktYIkmQAOVQIM1yAM7qIMQedTQzIM9SJc1qAM1WIM0CAM4CIMqqAInUIIkUIKAJFUaoIHWAQEVEAEBDYEQAIQQENBYhQAhMFBNAAQEJQRkFAMKUIAaSYAk2AMP6IoBaKvdEZgRtZEXxC9e4VMQ2AE9eIVnsIZo2AVRkFEbxdYwtFHmqwR61CszDAl8rL5ySReUOKcUexckpSoWGZZhm6cOelIodYZc6D2KuK1V2RV81Y63+dKq04ny2VPXoQmZ8IHzcYHEgokhANQlYNgp6IEpmII1AJf/RtKQDnsESBiFXOiFWSgFTGAEpfMrv7q+PkiJcnqDTuVUT3WCKYA6HtABHDBV1pEBi6BPibiXeDrIYrERnc1KoXq4cSTQEDACAUWAojXaohWCUAAEFYiEEIiEGIgEQiAERCiCIxADCdgIBZgKARAYDzIYXjRMgUhPXlmBGtiBFdgBOkgFZ7AGbYgGVhAFu7JRn8tWbN2wHM0rV/tWkHAERfAI6iOXIgIRlXBDH0DN1HzLqwMKfrGRGwsYqMAnVuCES0gEPzinuiSxIeoDQTgEzjU6jziEortH6guxEBPd0/UISRDd0hWE1m1dEjsCKAgRRgiXTsgQoltASOCELaSE/0FoAoyw0wWxj3g6qsnCG6To2XmyQuF7uCp03loarSl8igJgpQEggKAdWqMlgAE1WgjQhFBwWlcFBCOIBKYFBEDQBFDYgH/Bim15sDG6ip3ll/YkWz4lgh1gAj74hGWgBm3oBmJIBW20K0fSS72cUUc64Lq9UbzSUUwECYsFMaQropMgndIxXHVFVcW9Il/tKadYSHxqhVZgBXaMSXIJTRGpApZlol6b2cSkCGDipV4qlmLpF63k2SaFTYCB3jH6lw8ACbMyqwdcoUZoBBl4ALxhCmrqQ4Q5mC/qHViC4ig2oQAg0AEV0M+6XisuUKUl3xg40LIkBFCAWlAYgoQUmP/Rqi2Hk1+uBAqyNdsZQAI84IRiiAZt0AZq+AVTEAVOwCtwqUwctVsNK8NJUCRI8CYytFgPA9zPBE0RKQMtsOAcQNUPwAgqqh190aIk3p2GDABOYLlFqIMZgLGCzNfulCcbSmOwTd6e/RvYnMIy2oj1NSMF0IAF/OGyggQE+4DJERiucCUpBuZgFmYQkqUAyOKiFQACPdoQKNpIIMukNVBhIDmyPFBCWIB9YgoJqKbBDKpdsp35oBX6nIEaIIIZAII6wIRekFZtmNY83mO8UmAFvpBu1bBIwpB7LsN67NFFBs0jEhEueInFStLVbM99aVz0i009TIRCGKI3sIH6+hr/WqEIuYG9GskbrrDCxk1IHMYhgxEhHoGKrOBhP9iwZlkkZ2E5bZkKYY4lJwYSJ4ZpmCbWmTYYZYYALO7eoh1QQEjQLz5QataEF3AKHBGABbgAUSNMEpWsfbmiSPMVca4BH5iCGpiCOqAEW1iGaLAGarAGaNiFsticnRvgVZtRGl21StAETPiE+Dm55ktrzMzMRI7gIfIDSj0nIniXdyFIazHlyRIqJy0ASp6BF9OIo8LKnlVjfynM45Uc501i6d1m581KgfgAPKAEVOiFntmZYVgFMwABTObZxnZsx0bj0fabnV3PofAAD6BkGZCBGwiC2B6DNNADPSApIl6kseIE/1KATFZYhfrRBO4d0Ovt3lg9WlmFABgQAgyIAQkggALo4AAwt9KCuKLiF/waCGChT7iMaiVYAxvQgjowPs+IBmjQ6hcN4E4oBQwb4E4o67JeNR7aBFbohWKwBVJYNXe0zMvEK3yGPg4RWUpdA5dIMRauZILO2ddsiqGAp3zxTq0KZ/rUU7PdAR7ggV6rgXcxVRogVSc61cFmARlITWD7ldgBlhW4Ig9YARwwAz7gBPiBTPgZhUZIAxyYAdfG8Ru4AR0IgtmmAzzwg0JIhAcsq3jkhE8ghVKAzPh5hVqgBY1NiF4YhikvhmPoDGXAcmVYhi3nci6/k2Vghi5nBmaIhv9neIZlwPJVoAAB2F5l1unixuk3P+YqEQDdeW4274DSUiWimr8ao48Th4hxzoEmMNQ7sIGqVoRJWwYzjwZqoAbHZIV1XG/23ku7am+95CFSoAVl+IxW4IQCVuAclUcH1hCi86tyuYM1eAOA9gEnmlnEvboZU88b+Rc6GIMrwIIdyIEdQAIm8PUfmLr7FHbWoQEeoIEVwPFTxXEcZ50a4IErIAMyMIM0CM09KCLPnDsL0atKUARDRr6dKwVREPdREIVRKIVRmIVXmIV1p4Unz4VcEDOdyfI7ofd6r3czx/d81/dnKO8yd9F/d9FnMG+AL29p+HdpQHhrmNadlIUFmAr/BIDVKoYAWGVVI/isoj1m4v6s2WIlNqfiYrwLo+Al9qJfnUDRZud1LrDUPfABmjSEUrCFYthyRnfRZcAFVkiF+2FvS7d0UDeSYeBfa+iFT3fvAnZvT9DLyvzjeuwwDqE10mmCHXAiJH0xvnbXG4nt2P6BKxgDH6/tBhwJD4ukeNzLSV/v+kH7VVD7tV+FdXd7W2AIW5gFuW+IXHD7dc8F31b3u2eFEH4FEV4FoGmIwX93KZ9ynbHyY9ByL9/3fSf4x2/0aZgGaph8R+dqhcd8zLfjzd+GbegGO7aGUKDz621V7I0EI2jVA/2sZP6s4b74rJAKqSCAj5e/CbCd63CR/3A+ebN1dkKvg9D0AyTggjx4+VnIBZlfdDN39GcYBlrI+VMw+/XmeUtPBTq242OwVqO3K1Dg/gTuIboVw7w6Q6T7HKjngfs18F8pcfm4Hflx/75vBXZvd3Z/9/qv/16o/8HX/8GfBVq4+/8HiFkCZ9Wq9eoVrYO0DNZixSoVq1YGD8JS5eriq1avCsbqqOujr5C/fhkzhiwZs5TNVjaD5lIaTGnRplGjZu2mtpw6t3XrCe4n0KBCfQ7tpi0UAgJKEYSAAIFpiEihAIUAFAopAgEEmAJaoNRAAQABAggYSyBAhAwLFkxo0OBBBQ0bNoCoe4JFixo7mjRB0mQLmjx+/P8MasKlzqBPq2b1KrbsMbNn0ahFW9brFStUpTZzLvXpc6lRp45Zy3lMVKfPqj+Bau169adOm2Zn2pQJU6VJjxgpUmTI0KA9ddBw2dLER44aM1YwXwHigwYNFRykqm79Ovbs2k1xN1X9lCnw4buTL99dVXlV6qurtwgLlslg8uezXOkSmrRp1q7l3MYT3DwBCjgggQUKKBSC4PjUU086aWNNNM88s8wxxcwiixFKEaCVUwgkBUEIURmhglSRfAiBEZoIgUABBiSQwAAFyEjAAGWltZYDDzDQwAQTRDcXCCec0EILOfhAxJGA1ZGHYIIZwkgnq7xiCy29EHNMSpLV9Mz/MK+ggsopYI4yimqldDIKKbyUpg0uonDCSSdxxvmJJ3V6Imecs9mGCZ+V5EbJI70dYogfwq1RBhZaAOGDcizUVdcG0lXgVnuVWlqpK7FkmmlHnXoKUkgi/TLfSSilxAxL98WUH0023XQNrDkBOA+ADM4aIFAH5mogrkEx2M02D1IDEzQrIROMLx2hZ4oolljSSCN6SKvHGEHccEMQMmjrAbcaeKXVhgJ4+JSHCKB4VSiyTLVVCEYAYoRXYCVwgIxgaRgAiBFEEJcDPW7wgV13tWCDDU1MscUWXKyxJGGDEPbkJqiwohAvwByDkmQRKjNMLl6mcsopm8XWSSmkfJKK/zIQsuImJyPPSaedndhZp2x79lkJoI8EeojDeQy3xhmKMsoC0SfUBV0FDyCzdDL1taRqTNNMUw01sF6DDdb++ccN19x44803YYsdNlDttENPPWnXY7babdNDTzv12GNP2m/TgytRPzEY7E2URTghhcT0gkstsKTCrJuXWAIJtH/8Ie0YkQdhrbYfcHv55Q884IHmmrsVHecNVDBBUhoKoJWH7TqlFASyKKOMukZwFQm8BBgA1gG3316AAAMYIAAEMOgbaQUVbHDCCngRaYMPBiu8xhsMPwycIYcwksmXD2l0Sy/AGBPZM84oU4wwucyC2ceesebJJ5utYr76sMk/8v/Mdepp2204U6JboMD5waTPzrAFIiSnBi1ggdGeo4Gxje0c43BgO84RwW+M44HnkOA51KFBDV6wgxys4DjUAUIQhqMc5VjHOtKhwhWyUIXwYAc7+AEPecAjHvuoBz2wEQv0iII7ohDFJS7BOGg17nHTOiIf/lCIP/Chif/DAxTxQIc0mCFyWbgCE3Awg+WAQAbN+QAYwyhGDXzgeHPhQATOspSljMsIU3EKBCIhvnSFQgUooh0EbAcWAxzgAPMCC1l+h6IMSABSQWLBDGrwgh0UbApngN4d7pCHPUzvEL6x3iMwUYownaI6rrjFLkiyDPENQxi9EAYqzbeKkLEGFa//2YxmRiGy+M3vM/XbRJ7whxvc6IYRg/rNIPpwhzUM8Eg2qAELmPOcf/TjH/HARw2jGY8aruMd67gHNveBzXi8Ix7cfAc4wakOd7jjHeTU4ANDOM533CMc4hCHCdGhQhOacB3oeAc70mGOfaaDHypURz3AEYsxXEsG1QpC5BI6LTpEjg54cIMb7IAHieKBD3a4aB3WoAY1pIFJdeCoGciQBS5koS8+2MEOalADbXmRpVt86RZroIQewKAIMMjK6TQEx3ZZxQghisTrQhGBSMgCECBanVLq9aIXGeAsAWjqAoyQggsQDQR4IdiRqjAFNKwhkn0gTMN+owhGPMIQitBZ/yU+ATI0eccVsLgFL46xjGL0Ihe2yEUuUNkLW8xiFa5sjSs1o5lZtk99Y6olzGg2svtlIn+A6o0ieOaHYXJhCpVFjnKY04/NcpaZnm1mM52JD3z8o7TMhCY8UjtDfIQznOQsZ2vvgY9pphaFMKSham3bwhiy4x7z0MYfrLWCD0yuuMU1wxWvgMUfoBSlTHjuFbIghSxQV7nKvWIUmPADHuAABzxIKQ2S6Zwtaqs5zJFBTJvrgx4UIQVZIcvpOLRTqVzFKsoQBiGMIAtNqCArW9GQjAqw1BcNYCy5i6oQSpCXqzZvCmGAQ1fv0Ic+/KbCljyrznqjM0p0ghSk4IQoRv/BHYvcghjF4BhfBYLXXNBCIKtYRSm+NEvOFLYzY7rxYcmE2M/IJk+3ydluBhWcjL6BmE3gQQ1oMAPTmnYf/3AylJ+8jylTecpPZrJpOavlzmJ5y17ecmmpbNp6zIMZY6ADE7yogzWzec1YRCkyNzA6CWgABMmbAQ5o0N0aFFQG3aWBkr3YnKOFsXjF6xyi4aIBD1QABCNIIwAiLRazPGUrgJAFpl2XaXSVjgALQIC8EtCiF61F1AEYQAI8ZAQrwOAFRCDYFLRwhjfEQZh9GMRvLMkbRpB1w5Tg9SQmQYlNfGIUlwBxD02hClj0Yq+1GMgs8NrXL6HixTD2cIhl2Zn/bXu429uOHylE1hpPbAIUd8IfznKzM0LtYQ/DREMxc8DkKtO7yv3Yx73zje/PMvPLXM6yvzfLbynPzR5QDqgp9EAHJCxncmz+s55n8IEFGGAANfJdHxXQgOiQMYzc8nh0knZotzCAAQooeQNMfvKSs3xHbtnAAgQg6UiPRVwbIkAcQ+GJVTij59FwRlE/7SFPt8gAG5hAi9ayAAcsoAAWfxEC3FWEHoSBCI7s6q0HgevqjfUR/PM1JX59VmFnomVBfNMPvYMLFmdkYq8YyGA5AxFWnOLDnPg23vMe7hqXYtyeaM1ib3ObXgq5ZxnlwnG8WUPaMl611GTHC2cYDxpC/77yjoch5l8I+dTKo/P9iGE/Y9j50Xfem/jYx9zuEeZ6TKMRifhfGujQJDwAsElE2EBYxFKAUxfgAAx4wAceYNVjYiEKwyGOcfhimAGmdAZEK9oKkHcX5yQvmTKogQ9a4IChbyW+Mh8LAjQhC2GITxnROP8gEnA7NYq6RX5cqtJFfXH1qyC/QhADEf4y6ztQUuu57nqv6cwjhJ3OBBslYMKbJGCItRVetV0rCMTEwFjNtE+YQEQqhMYlUMKxcUImKE5j8QkmWMIlZAJoxMZqpIa5uUYnNFYm+AklKALO6IZvOIzDUNZx5IDjwQMK5WAOYh7mqZAPwlA6qBY7rEMRbv9ebalWP+AW55HebHlTPISZk42Wb8XCHzTC/9ABHQxG7TGJIeTBFhwAAPjOAMgAJ9RCLwyDKyTCDTQAC2wACxCBEqyBFqBBSImUdV0RE/BAcigZkTxf0SBQ9bEADfQhDADCuzRFuXwfAliBMCiDM5xfNNyELTwAU9mOgN1OH8Hf0vWI/KFaAmQAIgCCFcjBVkVYJfUGr3mdAApg2AWbAWJC2SUgiIlYKthCdSAEZvQVjG3CLpHgJpUMmYzCm7TPjcGJ4HVg2YWG/JjJuJnb3/kYJuhG/shghRHKcFQWEejgOtRWN8KWOZUTDxqhD6aWEHbjO8BDOrpDNcEDO77jOsT/Qz9AUzo+4TSB02tt1uihwznUwzU0whXCXh38T7vV3mDQgAYogAIkQB5ow6/0RCocgAYgUxiEwRqsARWZgUaOgXUFwZrhQJLRgAERjfOZV/Ul0g6sAA7YQAsYASJEglGZCxwJgSb0XCRG4vn1AqMtQALo0bxsogKsRY9YAAmcgAaoH6ot3UvOwRxEj2Bs3YUFIAG24obBorAdIAtuoCiQQniwQi+MUjF8jF99Qm5MQiVgQmqoxpxUm0CcwieQwimQScu8ybF1Bmj03fqwxl3Gxmzkxp5Ugs7smmTlwRugQRlwoze6Iz6+ljntIBEaIWQWYTe64zrAIzuqAzqoQzu+/8O9uSM83MNnftNrucPowdA4fAM4BIMeYKEf1AEZ1MEeTNIe2EG7qYHWocEDKKQBJEE0HIMl6EFpLEMjKCQIEEIfVMEbnEHsbeRBXYFHfqRyKAdMidcWiaRe5AAOyAANNAEUQAEiaAIilGIkvOQqyIIk/pwzSIY1KAMTwBxPukjGaVy/WMAGkICr1UAFiFoCTIADAIImEEIg3EEqqmIrEiCQDeD+wGLYjWAQnV0tmkIuFIMzWIMzXKBbTuMk8Aku4YlaRdsqeVgnpcIP9VCI/RBchsxmgEInvEaZrMJDmMkKouVfBttu+BJwCAcajKaOuoPZ9Kg7aBBjruM6YCZmsv8jPKTDOpiDPKUQOiipOaRQbTWTOtYQO+CDPNxjNa0DZ6XDaYKDNvxmIUyUG6TBkhhkHqSBH8RBA/iR07nIBzgdJPwBvSzkHMgCKAzZFJlBGYhUFEQBGVxBdj3XDoBkDhSqdMaUStWAoSaSFDRBVzGCJoDCKmhCJESq69zETYRPeubEJUSfBPDkUimkAxjPXdiAEtDaDlSAi0hHD4TCeN7a/ymCI/Qa/9CoVd6qAVKCJWACJDhLg77JKPQCTuYCmoxCJpglC3JgAt7iLLDCjXFlssVCM1ADNARDe3AHyKjP34FC38ndMJzYK5DCKNjGueWPuu3GDPoMOqwru67rOJ3/07sC6WhW5pCWwzmgg5Hm0woFYTmygzz0Q+S9UOcRYRHO4z+swzgoCDNICx7sAR2YgR101P/IJpMgQRVc4lkAQFnEyFgEQAIUQaZpgiQBTRmUrBYgTPLxBRIgAQ/owA8AARD0oaIWKqAVYnLsgBnkgSFMAsmsgjDIQp2ggjBEQ06UBoScX09EQyHMRQUsgMotHam2gA8g5yAcQh/4gEICzAmAgquK1ViRVc7gqlmW5a26oK4ujrOkrbNwwitEYjEwy5u0YG0o45ucwkGcQohdwoiaQiwkwzTcipc2gy+gB1eaTPuwRmecAi3cZFiSgmy4zF/yEm/4jzmQAzns0+Uq/ym7xlO7ohAKPWk6NGmTphAM7ZPpthALdaPiYR5uQR6SrsM+vMNsoaY2iMIY1EEd4EHJ4kFgCJOAMokibAILNMDtqB+AOV2BGQAh/Ky6yEIkzEEYEAcXTC/KqizLftcPZO8P6ABIKmqiqlQOIIkS5EEiQMLJzAIq3RcqyIIz6MSaYGqDOMMOGOUDNEBQTkCjrUANEAEaSJgh6IwhbIADaEAOnAAi2OkqPoIkXGUBlq2fOLCf+IklUAIk9OriOIIjQEJqdJKbJA5unKUscsIpOAQpjOgPqULfVgM40IPBTRnd3E03CC561J0JbhsrDMNkQEi4vgxf7sngZdhv6NMKmf9u5louOZRDu6IDCqkQPw2xOZSu6TZxOuirPhVhDckDDBEsN7qDPbRDN31DN1ADtQwHHZSs7EmYhA3CQGKCMqwCHORnxRWAhyyVBchBKDAvumhCIITBGXBBGXCBFvAF9aosD/DAdq3Z9hZqAe3AdyHBFoTBHRwCJXBCKszCMAzD+JynUfBEsOhE/DpBMklHAwxwkMwAEXQVrilChlZCE1gOGtgAFKgLWVnlK+Lqn9hyBLtgBe+yIzTCIjhCAjaoCELCJWCCBoowKzCLCJ5wMDTDNcwD2hhcvwkc6pHZNkDDLyyL4XaGKyxDaWyDNeSC4xYWKPTwB57roDCx5XKuEu//IAqxq+e+czurFurWcwtdbucVYTxMpju+ltxsljd0AyyMQRQJhh/wQR7IgRy8AawOwipAItB5AiG4AAmogBBAASGkC6ahi7qEgiYkJxWRwZ9iAaJgAV/ALBDoABMgwQ5gZ8vm2QzQgA4AQROcgWBIcsQwxjDwwjAsA9Fqwzb8hK40CIWiwjHNAFw4bVyAwAwwjxIQwUA+CSMYwhmsABBowQlIhSZIAleTlSNgmFXqDyQIICxqgibsUoMSEUA2USHowR8kAlzDdSHMdSNYQokqTg/FAjJIQ1DPQ9qI2T/8K2dd6b1ZczPEAhBZQibIBrAagzYoiDXcgih8QiYAXs3c/0afZFgiFAITmwM7JzFoxzNor6s9l7Y+DWw3omM48ug/y8M8UEMiXEEeFDQARZKAap0imN99oYtH87ZvX8VGr4IhmEEa7OmfXgEWFJ/yofRzfVchcy+g4cAPyNodDMJZ5fQpXfIxPAM1AHU3BEhQK0jRlt8hIIlzCPADkNEKMI8PnMFAWveTlJVhXu0SfIkkMIIksCJYw6Iu92rY+QkIRrCzNMIQJQIfFIIjOI7jJMKCJ4Jdc4II8m0yQMM1dAOAyA04PdNolRY+aNno9UM8qEM7gEM1IIMqsEwCjgIxKAg4RIMqhFu54eVln7NuLIIiYO4R09O60hM9ZdAGbdAFIf/xjpdDZ1eu5e4TkU/xbpXeFuuowfXDO4DDL9yADsw2FM02ANGBWxeCwxSDNkSD8/qUTDqFEUSCmbvqmaeLMGgCce+pcmEBckfBcsNsc+/Aw0V3FJzBHcR3JpTC++DVt/q0TchKN8CKUUSDifWcLMBBS88AekWKVUlt0OAuHhTCInidDOZBHwiCD0gC0N43K4Ldf2tg2oYdJejPA+tMLw8RJGAwJRRCXEMLJHBCEImCKgSDNGRD3nxD3OwDOaVWOI0WaQU26W2WiIPDNkxDMJiC3horJ/SCQ3YDMohCKdQJt5ZzzdBGC56rER/xO4kDOpjQt8NTB5W7A50D5y6xPhn/+ZGbw76WLhPDA4g3+WhSWTtoQyPcQA1Q+pXH5hHNtR2MwoMUgyb4FIg0BYqUObpIRUevAiicQcn+KRkUX3KfNMxuVyHb+fbiwJoBQRlI2CEIW8QsRrSd2DJoCU7kRHdbwzNUMvnJwh5kAczSwBS0gFW9gA0cwRsI6GpeQiKEerBVTyStryYwwiTMMoKOeiWo7anzibMcqCMsQqsTeK9ewiLIOrKhcDJUQzeETT+Cg9e3g8GFE7CTvbBbKenJQzmEA9lwAzQgdradAtFCA+HOxrXDTLZXo86M+7iXA9/D0wiVewVdEDwnsY6vazyzg7vvEztsFjeiEGy5gwuX2bXQ/wAd5O6VM4mWS0seOIwi3CQoRIDMmctYGIHCqznQtkaknoFITzwZaMEPKDdK/0AOZLydc2+e6Vmeo3Id/PwBKkbJQ6KESGJNdLc2DP96JkIa2EEVVMEdDEELuMAQFAEUSFIinMIynIIjfEYmBZkiCEIViB8odPWfQIKpn/rSP/35T/BYt+JmX31dH9ux9dCtSwM3SFA7iDgO0UPYhMMDuQNAxMMHD547g+7avSN4TyA8eQ/lsWMXb504cfvsYUOmStSoUalumRJF6lOnTaBKgQLliWXLTZowVZo0SVw5mzfLWdSpc1zPcz+BnutZ0yY6o0ZvGl23Dt3SdeTMmSOXTv9ePHhMl7p7Z/DfPnrgRMlYsYJOHTx48qTNg0dPWzx+BuXJpcyZsBgEAASAQIBApEihNIWSFcpTKMGyQK0hs/gKFiw6ogCRLPnHDx48duTAsRmHDBkzZtCokePHChk3blzBk8hRI0eWLnHiJIo2p0uiTO16Fq1bN23C/viJI0bQnSFDjoS508fQqWKmRg1ztooSpUePJjFiJIgRKMTaZ1KCVL16pUqXLpGvbsnSeEqYYk56tMgRJNi4Xf1iRq0bvXr7+vmnK3vqoYeecd4RKJ531mFwHXfUibAdg+B5J8F44pGnn4fYSYcqDfupZx5oOBqlIxNH6aSTTEpJSaWWXMr/JJOYdrLIJou++WanHHvqUagedzrqJhuPOmqdqMiZyiF5ijzIna7mkWaMsTygg46z6qhDLbb08KOPO8JYhS5lBisCAQgAiUSWNddcCZRVZFGGzD20wEKLKKLA4ofIJgOisst04GwzGggtVDPTPNOBjDTwMGMMOtqKVA86xuAD0kQ44WWZaKKp5A0rrAhEkDeqgGM5QxRJBJJalinmFFaKGcURR6xT5BBGKlllFU8qwW49S8wLlpJJ3pMxE/EgceQR7Rg5ZJFFTgEGGWiu2QacefyzB0ABMSLQwH3+wQdEAZeK0Fx13KnQQnis0jAiiEDcR8RpgqmtJBU32aTFFj/5/4SllTzJdxMZa9QpnHByPDgcbxjO0eGeFLaxHKRysiiciSk2Siqo0mFHwyYNUucfe8CJRawVNLCSjjTUeOMOMOvwg448+pCjD0ZQqUtOZUAJbLDDEDvMmWickWWQM7AoIzI9seCTshx24CFQQQslFAfJPJtB0Sv9MMPrMcxoi9IrkEb6iiDYs6SUSZYQAopACPGjDjvy8IO1VZwZxpRUnFHmlFNGgWSRR6yTb5M1PZGEWErYCzbYTAS2bpFELB0jih+A4IGJIFrR5lr/6rFH233AJb3belAH958ABfznKgjPXcrC2ePpx3Z4bW/dHnquQcYU2Top6RMW91XJTYBNyv/3xhq/6ekbbxyOvvlxziEKp3Ki2jhJ7bPv3hwP2YGnn3IjRMgdr8Cig4sdWEjDfTrWcPmOOOBIazk54uhjj1doKYZowAxzGMOwqRjKiIYwUMGIM5ThDJLBAWT8VBkJRlAHmckB1CyYAx/4AAg4+MEVzBAzQ4zQEIdIRCESkSpFYEc7hDiEIfwQQ0UMQg5imIPNBsGlRDSiE8UgxSWk44pT9EIZo2hEIk5YCEes0DuyQMUmrsMeSMznEZtgSSauowg/VO4KZ8OcaYLQCGtgi0AEqkc70Civ2TkJXe54kJO0Mrt1seONaFTHOiQSviUJBB+5awc4SCSbTPTKEaXolyH/+/UJgHkieZtY3o6cBz3p8Yh6EtMJ9rS3PSQlCSrZ85CHxEc+dKHRHiP6gx24QCg0qGwNdXgZHOBAt5e9TBCreAUwlFFAwIAigLxkkzB2BqdJlAENDQSCDnRAGQlWhoIZvGANRnPBHeAgCllQQ93gQsJB7AEufniErRhBCBcO4hAzHIQhAjEHdQriELNwxisaYYlEUGIWymiFKIDxjFdwohesQGIhUDi4R5RCGMJYRSXE8xpIZMIkMxGEHWCYhzqYoYtBCMKeVjCDIIxBFfMIHepAakbUrdEgaJwQHLXipHXAQ48mndA6rOIQfOCDjw/pBzza8Q1pcOQS7tlXIg25/0hG5qtgznNe9Ho0vaEUTByZ7OQmNYkVpjSFIuswl0m/ooox1KEJqkSDGtYQv5fNDQ7ye9keZnEMZixDGM4IxV8IIwtgGrStchLGmjQxhTVswYFXW+YEK1PBC+YAmoUt7NXK0Eq1DMIPe5ColvJgiHMOYgtoaOwgGGsIRshhDoCwmSGKoQ1tpAISiciFMDDxCmcAwxS1cAYtRsGJPyBxVtcZaFtlcaxLjIIUllBWJQTBgAcwFgtouNMVxhCEKFyBBTLQQRD0IA3/GGge7RiHf9qhj3zkw0IlVYdJJXRSg1iIKR1aikvdSJCZXmimBHkIhuZxDV/Y5hKVKMUp9oXIRP+2xCRDwpFSoydJpS71keXgpCYz6UmnLKUp7IoH7Ew6D2s0Qg9l0MwMzoCGr7bsDW8oCyxdmaUxcIJTzBiGMt5qmL8UdE12ZZMTp4CGKfRVmXhipp8EO1gdP/MHWMiwYtPiyju8IX4x88MdfNCADfhgCWGwoRyEQAETGIGzhiiFM7SRC9c4AhO2eI4plnEMU7BCGa/4wxEVoazrUOITswAmLVhxCfZwYhWo8ARcGLEGYtaJDGMYQ2NowIIbWFQU/aFHOwo0DkSD7owhC287vmvHgzSIQVFBx1XRtVJ1WYiPLF0SPOR1jXrFJr/8+mm/WNIJdNxoHApLqsO8obBw+ET/KOe4nn8xhg6iNMUpEHKKUjD0DgnRYx7g8AUd/PCDGeCABmioQhjQENb4rYEObyhrluoQxv1EYxjCCEWaEBEJlcCJLndd02HWgAYuTMEHF8TTuy+XzMls8II2sMGOc4CEyrZyltiug4bFGgYbSIAACKDAXviCgIIvYAFGIEQgDoGJU7SnEIqoMyeGsQxTgPkYomBFKxLxB0WoEBIlt8QmZmGLWqRi4wVcUykqoUWyaWExf25MRlEzBj0gYx4/cUeB2jEPoVe3ugeB9LkiZJMILdgooxTvUuj4IDwS5CrhA9HPt1EvTpjiby0axSdOjWpPIEUcrT7Yq3PEMFfT+hwU/5vYja5XE6U4JUK8Vgq7hP3deoBDG5B4FBBocIMZcKEKVZD2tKXthlbWAVK3iIY1nnHXcKfJeHKV089CUdA+cGEN7HY3vOPdpw3uYAf21jHpebCFxWP7DK0/wxa4oOEWbMABCeALX/JS8NsjQASBkYQhUpgqJJZCGazI1DJUYYpiCENWjRD+5BpR8kRYYjamUMWmlJGLOlcih1fQgha6GP4rgIBQN0iuGOehDuqh8Rufw6479OFopCtdHbyeqrkMspRPzh18S3Gv7frBK7ohGVSBt7rO1PglkT6BYnpkHAAs7WStYIYE7ijw1m4C/xiMqu4BIQ6tG5BhDMpACzpILP+yoPAALqw0zH3YgA3ASs9E4RmowRrqghAiIU0CKIB+psWMRvWaoN1qQDLg7QfkzU/oLQdMj7CkKd9g7wy+TwQnA3N4oAZqLwESAAEEIAAEIAsJAAJCAAK4MAQAwTA0gRGuA6AwhRNYYRlegRSIYRlS4RSE4RMUAaAmpxDoQ1XiyRKuD/KW74keoWvGYDEYI/w+wDQGLQhu4Ba64Yy+AY3OYStQyiDQ4SeSznpybRIp0VzQ4Xs+qRM/SdNqJ0DkRUSkARZIgbdIgRRKTb8WcNXKISge8BsicBzKThzCoRZpcSj8yxIv8NLKJwPd4R724R3YbxssIQjIQARxYAU+QAr/lGAKuCDDNKyYzCANvgAMWvAMIMEZqIEaokEZIoEQwvAGA2iu6EIWBEEJ1sAHhJAGJogydKAydsAH5lGa7q2wnglq2FGCCEs0oIkFNoAKEWABECAAAuBMFO4LQ8AIjAAGAIEGYQITBuGE9IATckEUVCskhiFWlGXkEuEOVQUS5CwVnsEaomEZemEWSmETZA4HyKAMyoAMsqCLosADPkAGhBA19GAaumEeGtEdwsH+jK7uXvEnJObWkO6OjqRjJMJDyuGTzGEpMKR1ugIjouQWRgG/RmEV9SvumGonzq5HZo16fuQnbm3unCIdNpEp7sghCkJ0wOUdvoIZNuolBZEM/2JvGqMt3QAuDMIgrD7oD5bBGrSBMGUBrsgxFAxIBs8NEcKACEZQBqKgCYigMvcRCS4janwAM0ivMzsTmjTIB+5xC3gACYig9E5gAqqQIAlAABAgBGATAl4TEACBIRkSEAJBEnhlEnqlOi6hF1ylF96JFVgBNthDzpCF+tDQGazBG52hn0YBiwahDkLw9bSgCZoA9rhgC6RACpiACX7gBlRhG75hH+KhKoeyfNQhEyMEKMxlApWCYsjBSDrme8zLwQjiHe5hP+9BROQLPTBhPBJJRVTkE27tKy0GYY5qen7CRyzQ/vCoQ77HHNqSjsohdaziG7pBFILgCrIgC74PJv+5YERHFOBO0C/D6pjoIBesgTC7AcUS0zCiQUxgFDCgYMZo4DOQwDSHgAg2M2oyM2o8c0g7s95soAZoAAmaYB5tIDVXcwESDjal1AvTpDYZUg4QgRBQARQkgQwJBxI4wRKyTxT6ZxTa4xIwQUYwgTxuA1boom9ygRVKAYvkhgm1YAqmADv1tAm+s083ihnAYRz8IQDtwbvOoe7WMxODoj1tLSmK5FGbwkM4MR1AcSH4cz/xQcJ+IUwvoZDADpFW8hIfqWBk7WAoqUF9AickBkKPIh0oNELXoRzg8h/c4RugIbnyxDGacAt4lVdL1PXOgETR4IGCgMQIMxoGwy+UNRL/NEFOMEEZvM0wQOEIiIAHOmMFdtQyR+8yOJMziRT1MsOwfpAIaqAFWEACGG4grfBMpHRKQ8AvrNQI5gARvKNZJkERFiH6HIETZuUTLME1xqMS4AOhHsERpo8TSiEVUm4WWAEVPgETtGiv8JQyK3NHlZQJvPM7g0AGLGEbuOEdqjIpEzUoUJVkbcI9Rbb+lIITzaHBqI5d+LN27mEetMEYREEkVZFfggcURDUnRtUiGtBUvYHWGlBVd43pNKZllZIpSKcrvIEbVGHQHENX6wRPe1U7m1ALtmAKeJUGdIAJ+EAYOEUYeqYGlxUUpqNZyfYw+kAJjnQGsBUJNmhuNwgz/7n1W4c0BwilBuytCXKACFxgAxbAABZANl2zXREXAoygBuM1EBDnOugjXwEWEo6oPiBhTb+pEB6rblgDEzahkTJhEg7BDzoPTyuzMi9DSTN2RzdWBoKhukaHUWWXZH0EKMbhZEk2d4tiE7OnwfwvP/XTKv5BRLYBGUThEkyhRVQikbrH7SpmJ4J27VC1J4xW7uITKSyt7pqiac+BG6ZBD2SgMfDETr4PT622Vx1jMbKWBWpgB5rAE85RExh3WfFGJSxProThEKrgSFmABTYImegWSL0Vb0lPM3BAM/p2g06AIBGggQsOcSF4IWvQNhfXiaBoVuijPjq1IwtWEQwhD//IADyZIArIIEv8oBAmkoQk6w72ygcok24xozR3lFt/wAM84A+sARz+4x8uTVEPlXbZThcb8CgPNHvm89ecwlJbpz+/oRmSrxS2dHk5oXldcReBVixdzXaBZBcxJgNvIh3U4QLXwXTOoRt8wQMk893I907Nt1fBrzGSsQlBYAZaoAYEARTIlhDeinHTpKDgqq3myhCUYAhegAVO4II2IzTpkYCJFJEfaDNsAAiagAQioIFZk10jGHGrFBBiwAisABAYYRLSFBM6khIUIVnKMA0uQ1AwJweaoIvIoBrLIA1CMArorQZO1zK5NXVpGI09QBWuBUBiNXfXswFrF0jKDpn/L2lUNzFJ7M5IVmo/BcR2MEKnfCF57awTTMRVjfipMimZzS6LG5RHrOeSjMTtwBj/QHYY54EaGsEDVkCS9bQJ9zRrgWBqwy8K5rgFWiAO/iIS5EDF4LVZNWEc2eSAKmGQWwAFTgCaaOCAjfBIv/VuiTSwElk00bWB11Uhp5SjpTRNjKA2hQAGWIAGoMsOs8iUYag0QMA0QsMfaWAGfACakCBPosC4IiORcfl07XaXLRYJfuABHsAD9CAa5uEd+gF3f4R6KiapyJIWJfB5q1ccmvmIp+ruHAxAbCcfCETCgiF5DWmbuVmTuPmbIUbWyFIoHKacieRRbYIcyqE90Wid/3MKGVbAJokAOyWjCb6vCfa6r/n6+5oGT8avpVtgCRBBfv8iMJQ188SxHOVqFTahCoZgoTegBV663l4AXD2zp4O0CJGpgnyAAxxAo7Mwk7nQo2ETpBkSBlpgLDyjBngghBZDBwrxAz4ANDyDBUIjBzJKBmiAsK6GCZuGM2rAB3h6l7l1hoN6qD/AFBbxH8RBi6mXJ4yqQXfCAnlRJzapHBhswaguFEXRjOiheN8wtkjBmzlpQg/sYrK7QUtWKIjCkpASHeAavhOiK0TEFG5ABkCgMpsgT7FTBPd0MvIUCJfrCjwIB3aACA5BEuY1MaHVL3BQFmZBV6pgoTlgAjA7NP+gyd7aN2p+OglIvMTlVgtaTwS/EwlaQAIGci9eM5NlXIKtVAhcoPwEDzRmIGtAI6bFNZpKEzvtxAzUIA3MYBCvIAqC3GKxU4YvA2Oj4DN4gA7EiB72YT2/6x6+60cQdJkNTCfIQRzCHK7JnHc5adcmZsHKS0Mwwj/2YR3wARyC4essARMQbL09ZHuSpGJusezCkmhthL6vJ+mKcv3+o5Ss4Q8847/zWsD5eq/9uk/8ugmwQBBJOAtYhhEkQRwD4waLBgeByRn6Rhb64AVQ4AIkwJA/Ywb41gZQDwlMvMRlnQjeIAy+DwiQwBlRoAoVLsZnXMYXtzaL4Ehj2sNrQMf/X/rH8TEHgjxPsuAuyYAmf0CAZfind/Q7o2AFGDxsYsGjHPEcyEe+s7tGbuLAzB3BvAeuiySJneJdLlR0+ggevuGrh2cTisR7JNWIf7bsULU9B8zWLDET05oS26GrfQE1VgAEKHNPHx0ICFtXAxzFV8ksGAUP+IAPHqESGEEMOj2A+qag2soZigE4oVUShuAENmACTuAEeHs07M0HYF3Wk8AJZD4JaH0NwuAMpkAJiOAFSlvhtvDXfx0QEMEIhIDYC8Whk36wQJOwDuuBmImwBTHJ4xFqpKkzexozkYAJMioHyoDKocEnrSso12Ec3KFRi1J3b6J71tt7smd3IVXN/1dKQ+ABH0B2fHRKFVLhDTnh3t2e7ZcHJ576UNfz3332JtyTqYuSlOahGxohCHAABD4AO/O6wCmd5hio9aLtDtIihvjghE/oETJBEwKh4w0DWutMV94wF0ZdE+7ABVCeBeo4NCuz5kmc5mW+CWz9DI7AbTGAgflCtYUecWNADoqgB24cpvdW2fHNkR8oHitD/PBEuYJUSJn9gkrzMqIAbnUACyDFFLahGxjmdifxHYokKQ/13iXVm//+UeU+iQkCHTKkHyRiHdoBG2JBFVShGJwBFyzwegCCnMCB5QoaHHfu3Lhw48Z9+9awYUKJCSuqQ1gwYbt29eY9GxNExgoPUf+amDypJQoWMmXOoKFDZ02dOnn2DDJkyE+hRIoUPdrkiRCiUERDaQIlK+mqSquKFRMmaxUoQzlYsLDhw8cQIieTeP3qJOzXr0jWTJlyxMYFBAQQuIUQIq7cuXTrxk2RIkYRGzVo1Pjb1y9gwDkKG86BI7FiHT8aAwHChEmUKFeuRGaCBAlmHjx27EDSJHMUGjNw/BhDRw+zbt+yFVy3Lh662bRnr6MN+zY7dul6p9sNnF3udfBywzsuL7ny5PjUudv3zxw7cva4+VKlylc0cNdmGzSIzuBAcwLFiStoHqHCiBAjSow4Uf23c+rKKdxID5wokDI+kDxpkhZaYKFFGS//zZRHgnn4cdMhiuz0yCOTVNIJKJoQEkmGGQ4lTIdQrYJKUrKAcggaO8ywxFlnbSHgWEmEJZaLTaChxRFDdJAAAW25ZVePPpYAAwx8/UXaDDPQQBqShB1mmGKLOcaYZJRFcdllUkSGBGeZZQnEkTfoEARIllgDjjfloBNPP/EQd1ybw7FZHDzB7QZPcm3eeWc88vSjXD9+yoPPPedU40084sTDTTKiwBILNN3QY886Z9bm3aQFoTMQOeiJQ99F6lHkHnzrJTRffe2M084880ijxxhMzODBAyUBWGAZBtIxEx41MTjIIA4ywoiElWhyVCmYMAJIsslGklQooDjriSey/4QS1SN1MMFDGGFAkSKLWbgIY4xfMdGEFkqcsABbBAjQlo/uziVCXi7MQGQLLRh55JGE1WDYX4npgENhWQ3sQw4+IDEZEI1phiWWmWkZ2g8szCBDEDpEdkMs24wjDprx4HknnHnGQ3LJJpd8zz3wlLxccn7+KU882TQjDTg2N2MKds10U88+/txW6WuaVoopQd6dd44449i3tH1KP730RAmpU6o6p6YKTix64FHDSA0AYdIUAZ5R4Bm41qErHwzidEiwwmLiySeooJKJJJEka4QRgERCbCQW+p2UMqsYkkcaWNzxRhhLKCG2SUQoEa4UXGRBeRZOJDHjGzY44BYBAf8IgEBceb9rF1wpBEkaDoIRaSS/TO7QWQ414KBD7fwSTDAPje0OBJVRaIbED8CDZpLEMnwpAw843KDHNN+EAx46wg2HDpsf17nny9qfTPLKaWoP/svxhJMNNshM0402yORsjDX0+OyPOeRlSo456QgEHv30l0OOeWeaB8AAAvBS5ahHO+xhj3rUYxzz0EYj6JCHMDQhCEHIwha2UK4znMFWLjnbghZ0E0P4JEKVqEQmPlGKVeRiFZI4yt32RpQMPQsVq5CFM5TxiUQMAg91QBwattC4JqhoC1zgAhrOsAYNogENXCBiE16AgXQhgF0QgEveAGEE0sErBSpwwQvulS//fBmJNIVxnexulxXHAIFgj3nMD3p3hSmp8TFxvELvHhOZKUUhCJK5AhbGcANVcOMdftqHPY5TMkQiUk0k60fK7gGdf0gyfJT00z/C9499VOMa1WgGMpoRDWZghxnWyAYC7SG/TMnPN/gryPxUWb9X1i9oBjlP9GKTwHokMFXI0AMd7oCGKVDQghisVUtkkqsPrk2EEnpEJTBxwlKgYhaCQ4pRNESIvYEiRMKIhjNW4YhCDGImd0iiFoIooAsS0VZHdEkZtNAEItgABW5RVxXhEgK9YZF0IhBBCU7nAheAUYxjXN2ShsSkN7Kxd1GgY2Uqk7DHYAELD42j76YURylI/+EKZACkHqShjkLa4x3ca2T49oHSSE5Se3aq5CX7kY5+XDIb0pBGNWKhilj44haiOAYzaLaRSAHNNr/hTTr4NxtZCkR+spRfbb5jy/DYBqX3eEc9vgGObVhiDHgAJkUrWEQWtcQlyETbgvywzBEqYkInRCEqcuGMGwoDFaDwBLGQIoy43hAVjlBEIvKwhjKswZxnCZAW1MkFW5UBCy3BQhS2oIQeRCBdOronPkOgLNKVQAUw6IENbHDGwBBUX4MZDL3M+EaB+eCNbmTtZF4r0YpWlDIQfWgWyNDRG6xAFN+oRz9QSjLm4IM5L3WpJI97XHzgIx4pfeQ9vsendfSjHP+dNMUfcpYMU1hCFcwIhiqaocB9uElS6qjenHaTDqaqN73qdSqlvPPedTR3HNnoRjP0oIc81AENX81CWGu1QbIi6KwhbFuEJjEJTHTCranIhTL0qowIPzga3ixGKjZBiZ6Mk0bmPGfj0qlODjL2DCVBSwwm2xa4WFYu+nQXDPSyBHgCiAg/cBKSblzav4DRjDn4gWp390YgTyaObaStH2Vb28p0dAxjWMHxmjEPe0gyHsMFVJWpnD3xlUy5ykXucVNqj3vUI2X4uGRMYZONaviiEZaIhTGg4QtRvFkawZDGmPeRsne8ox3uUIc63uG9NskDZHcCznGm9ybjFIdNllz/hze4sQ1TjGFraUhDZZgghQsaVkAcVINZz4oTEQJLQpjYhFtPcQpbFEOv3oyrMmxRCks4IkKJ8ANgsaADAZlkohMN24oKNNgkEpEILUAxAi5rWXzmbXR0gYEQigCFO9QhJkncYEp+EIUfAKyMBjXtXw7j4xx4pjG1ayge+9jGIr92yLL9I5OZ7AEZyMAS3QDHPvhEyT5tr6TveGRK96EPf+gjk5PMXky9UY2aqgIZzGBGMlSRjGqAox16nuQj9fwOd7iDzFW2k6D7tBw+DRqR12tTyVcmU3mEwxvggEarfGkGNWShMgDaNYHKloZPozWEimCEgU1o6lJ8YsGoeEUu/3IxC1akohOYoMRf82CIcaphDaOhQboZam6uCJFASDxDE7gQBhdMgC2ho8uKWZxFuTjbCHKQwx0UNJPBavCdFAVyGQfTr28bxsc+gJ2QFQaZxpg73etmd2UoxxJbmcEMHvDADW6AjCjzqcz/4LIkLV95fJwUz2Lu/Jj/4Q9/HNcf/SB9JgcFjWZAYxrMWMbDg4GNedSD8i/lMpWdS+bk8GPk3jMpJblncu75iR0r34YqbgCTNCw+C1HIAoAms+ljzoQmBA61IYI1IUxgohKT8AklKrGJTWg/wzm5g7R/2AQeGMlgqwU8kBvDAyRo/QxTIMIUxJ6At9Ql2cgOQQpEAP8DRWAFctAHffB2e7AHM0EHS4QGlYZbDdUYiUEkpYVj/EI7heEZjLE7tQMZnMEEVzcZWIB1SpYFUpAFilUGi/cAHrACN9AI2lAP/4BxGKdACrQRN0hx/fZINtgO9NCDPThmXCaEmdSD1QANyBAMzdAMzHAMsPALNSN79vAcKVVmlKdcVfVIHWcylVRJ3YNylZQO48AN0/AHQUAHlWYGloEEUmASmdE7TQAEvIZzUzdgCWJrZ8UghYAT47QGg6AIIvSHtvYGa8BE6bcDocUCWdFa2lY7teMZWSEgRLAFPjABCZAACxABItAjyYZ2MCAG5vd21LcH+jV9C1gGZEAHdJf/bRKYY4GhJDlgO99GOxuoA4H3A1KybhPFUBTFUWRAGYq1ZA/wAC0YBL8QZTiIHz6IjBvhZ8uoKs+oKhxRg7qUSx2BDc2QDN7FcMZwC65wDM+gDdsADtjQDY9iQJPEDi+TSSn1MvKQechlhV6WXEP4jsdlSfYwD8FwA0FQB2qQBnRgBpTjBE0UGopIeBNVIJxGd4zFWC2RBmrgj/6IAytQA1lwRIO4RAG2RFOgBETgkQvViNpGbuLmA02gQWJzAglgAAaQiSqwiZxoBBkCBW/gBzTBQ9MHWAv4EmWgZKfoR0BQi4pxYzemGPziGTXQGbGziJdxiw0VgoXXR714BWNg/yu3RTmUYTZ60AjXACmGdEpfCZbVWA/0QJb0AI3QaDPlqA3XcA3WUFPS4Au6EAu1AAu7wAvE8ArDQAqNwAmXYAmW0AiicA2yBx1pwg/8YEmcdw8vQ3vyKI+NWY+Zx2UytQ/zsA2i8Hhr4I/KJ5AYFBpE4ANXp26OAYFxqBICQgZmwJlZoH47sAVVEAZvIJtvoAZkEEfx9Dj1VzAGyTvkpgPxZxIadAY+sAGWiIkd8GI+YlkwYARzIAdv0AfUpyukiEwLeIa4ZSu4dW1AmRhDSQNOIm6eIW7h2WONqDtM0Bgf+Bi5WHgPxWSnSDkmGAVjcAZkgF+xAA5nqZ/zAA7dsP8N2HAN1CANqZcMSOgLsYCg2KEKogCYjdAI+AWhWikKfgkJpJAKxVALvZAK+IUHPJQHiRCY2xBlSdMPh2lJVdVv30N7mAeZkVmPQthlhjQPLncDMqCZq2k5GCSa6fZ+rJUZ9gcaF1Q2ZjAGafgDPOCRR6AESwCbaWCbv+ORHQma7OcDRHB1Ikk8GYRBJ6AACuAAEUABJRADMVA69xQDUBBtb3AHhmCAbwd3njZtaDBtwFgGaUA2kxEZNdYXs+MkRomB/2IaADOLu7MZb/RaIvhaD2WbY7ASljNzUaADjIVfjRALuiCXqmAKpsCgDtoIf/AHEMpkFCSqISFvj2eqQfD/eGESBJPKZqLgqqZACr3QC3lpCXSgK3fQB4dQCJAACbqwDdUwD94wDln2D/GgZ8+VHPPYZV12eZfXmDAKo5mUH7FQoyvgBsoXkAJpEjvaRqy1i1hwEmJTRFxQNmigmmawBfL0Aj3wAi9gA4+zBSzRBFIKmruZFVrXrW8EIGRDRC5QAQ4wARdAARSQAkIgBDDQI2wnbeYHnW1qfgnSoQoop9NWBzyJimSzWHGELU7CivzybTtAOxxYYxp4pNiWGd6qEiOoZFNJBlpQOVfQGFcAE/iFqqYqb6V6s6ZaOxybGKVRMY6AaqdACq/ACq2QCkerXXpwCaKQM6kAC69ACsWg/wyXAAmz9giMMAmZcAlbG2fXwA3Cqo7x8Eh6Ag+Vt2XRuly3h3tr61wy6kC69QFoSAaVw4ahIX8eWa9Vmhnb2jvgehJEVETlegZFVAVKMAQ9gLiIuxX2xwWFFRqcAblVGk9uBARbQjzCiQY2AAIasAEXkAEdcDpCkDcIq4kxwHZz4KYI4gegaH4dqis0UQdlVQdOioqKxYvoqTw4MDt7Wlo7YEacATvxl5TDwzCFZ2SVQVGVM1E4UBmoARNBsAIfIL3TK70g4GQEZapfQjvHcwNjcAnK4BTAAAvEwAu5UAvA4AqTmjOZmgqWAAmv0AqcIL+UwKuQoLWWwAmWEEjXAP8O31BmMhUoizlcZZu2VLZcMEoyAYxxKUNVF6dn+1AP4JAMqOofaHhYW1CCJ3G3oIm3RLAlcNi3iDUFgNsSDEi4hjsENjAEK8zCQ6AEQlRYlrvBVgp4JgExGbkGW1ADJ9C5HfBPKmC6clAEQSIEVuCc0QmxdcAgdtgHtuahcAe7PJR8G7RYj4q7RWlQsuO7Z3SIkJslsDM8kpFHD3W8E1VREyVuVxAmRaoGK1ABDSCMcawBc0zHGuAB1Cu9KxC9erwCQWAKtbAL+LULuMAKo2AKnOABWvkHrcoJjcAKs5oK8nsJjeAInOoIiZAI+xgM4tgOzspxzHFyIFNyeXaskET/yjO4D/RwmTXqH4tHBpDVBFKgEo5VEh/ZwR5pEtAHuEZERAzIgElEiI1zGAOzwkKkwQ9ztwNjpSdxw2ggWG9QBZqLARxwAijQAgGIpgM4B30gCIOwum/nxAmiNmilIIiTIDKhX6SYiktUxVd5pIyhPEoii7qrux7bGcHrGfGXGQ3TnhD1WhTEZFiABDVgMWHSBDmwAg/QpQutAAzg0A4Nx28Mx3EsjHB8xyugB5DQyKagC66QqXrAPJbwB8fTCJcQBKRgC7MgtJtwyYnwqZ+KK1kgAx4wBo6iS2abwJqnJiuzaGwCG/DwXM61wJA0gzSIj9agB9AbK1lgBmTwfFvg/7fxhAQHU3M1t8tNZES+jAaEOFgICQSEgRUuDERTkCX6zBl5yxVa98Ezsl8ugQZVQATUzAL20gI2cARhgKu9EkJ+0AferDZ/gAd/YGt+sAdo5Qdo8Aazi5M5RweoWLG2eZXKowOrWCT0ArKqEzDiVgOHGJ6eEbygcRlUEtoW1QSRQUFTKdBJYKo04JEawAAHcAAGANuzTduwbYldmgALfQANzQAr+AekwLSukAqnMAqj4Ah6AKIjvWCWcAqfcAmOcMmGUAh+kBowcYpvwII3YAr52TOgF3rrGEna828oZQ+GhFKO+W+nFMHz4Av4RQegwQVzWxmA+8JKIKVJ4MH5nf8ESJAEkMORU1AFAQ7gAR7gYVAFGalBBOkD9uICWFGSZ8E4HFylyqx1U+DZktsEnnlBLaEGbyBEPkBGSnAGsemmdnhWfMAHeaAr3swgfqArfkAGe2AHEGQHTGAHdpAGL2sHV8B8QaYYPEAkTpYYh5hjnm0YsLMDD263WVraon0ll1EZT26C8SkZEymMGvAADfDQW+6lDuDlwlgBcyyMHoDlNACiLu1L1m2GMIEHQYADZwgTttqhcU7nMNF43asL4AApl/Td5r1ShQRmYSno00iWz6gNloBfzmcDTTRz882R9q0EY5EZLqIEAj7gBI7pAW5EwtlEU5AVnzUwJqEEn17/165zrxXewY6b4UWUmp6GREnEBWtgfmvwBgqChyiO67bmzWeFB7bKBDpgB5QjA4yRBUxgGarppFmgMG+kGEwggUeiOq1IGOKJgafuA8B5ElWi7dquUd0eGTpAAx+gAWH+AA/dAOd+7g5w7hRdARQdx40H7/F+x/J+AyEL0O+G7+/WACPRvVDWMzL1UihFmeP9lTVolvtpMwmf8NpgDO7NBZ9VRFkwBjMn6pDuIhcfFipy6Zmu6YmV4I07r1mxuKAZWTYgUHpnMHhrzCahTkLKQYuXc4I1E4ktbYldEwi4ICiOhzuXB2fY6xBU7FdgGjIwA43hFzNgGRUZBbO49LTj/+wSqLutU1qtQ55aPDBaIsP7vO3b3u0blRgSI4zi7u5j/wBhLuZk3nj+Ie9rH+8fkLOpGiap8Qc8AQmWkAkrYAYf0IJ/AA3PWJZmmZ+A/w3dwA3cAKAJl3rYaAzBEJc4hamu+pcO+qkQmgdoIE+LTjljQHNN4AQWv9/8jfFnUQUqwvEEzkSc3rgcqRVS6gOfZS9WAfv8onVC5JkZvsscdAaLB5ETS06gmCAIOIpoNc4tPth3iAdpUBNp4Oy1QwM/IAMwG28zx5qlgQOjoYG5W5StOANHjoFJfvV7m/Vaz/Vb/wNXAIcgIL1sn/7wjsd5rMfcm6qTpgdznwiO8JfyK/8KpHAKqcAKrvAKtAAQuHL16jWs4LBhg8rceODhRiNjrlSpMiVKlKVGGf/oGRPkxkcZMlas8FDSpMkHDU+alDEmDZcqPY60aHKFSRAmUZo0ceJEyU8iQYP+JFplShWkSZUqRdP0zBkuXLY0UTJkiJKdPmy0QIHixFcQIGrkQNIkShQtZYBEwYJFS9ozb8vMTUOnzt27efTu4ctXrx/AfgYNHuTnryE/arJc4cskDRMaMnCs+BBSxhUdOurUkDGDhg4aOH6I/sEDx2keNVSPXb3D9WseSHz4iF12JxLcuXEzYSJFCm/gwYHrOJNDi44ZIGR8vBFkDB08eQolUgSJEqb/TZ0+jSqFihWrV7QEHkQ4rJj5YumVHWPPPn169Onb61jBICWf5iVTMuDPoMGDBgLsT8AG+uMvQAIRFPBAGtTYoqoWerDBrCBw0qmJJJIgasOfeuqpCiWWSioMEpNaA4011oBKqimW+GmKrFxogYSvamQhBx/KaistttySKy640qirDjXUqEOvPPjyQ8nAChNsMMPqMCyPNKLIIos87GDiB85E+qCkD1bQQYYazKBhBs9O0wEI0ZgwTTUecpBzzhxUy2EHHvLME8fYbtMtt+B8E27QLeO6o45NZJlloIPUU+ZRSJVxRlJIJ4300kuX0bS9YzTdtD1Pl1lBgwc0iCKP///+229AA1s1UAFYY1XgAFoZkJVWBVRjwQUXemihBgqDOIuqDDPsicNjnahCWRFJLBEpFFNccYst0NhiiimC2uqECzigkQUWWsBRR7fKKLeMp9Cd66m67Doyj8AC2yNewPryC8ksikSjjjKiSOOHkUbyoLKUBq7MDM9mwIEGINZcs7TSUOPBtYl3qPNOPfOk2LYm/kQCuN8IJRQLIJ4CohJhMFU500hDXY+9TUOVeeaZmWHGg5T8MKQBBRpIoIEKKkipYJyHNjqlBV2VFVZcGZjhV3B/rYG3CqNAIqhiPSRqqKJEHPHZKqJVMSqprL1WWxY2sIADFFqwoQYbZiuLrf+3sED3qafQwBsNu+igY4+9mqQ3MCQL3yMNHszIQocodBCtspFUAvCD/0YKMzIcZmj8B7Z++GGxPDvGTeM78Zw44zw5Fh3Q3kIWWTggSj4yjVKKaXnlS9l79Bhl3iuG05hpFn4Zm22mgQxKHqnvAf8asOyjMS2TPuCwPrB+paIbUsl6GTpOfbcocOLtaiKKTWIon5Tg+sNmlXIWDS6e0oLaLaKidgr1t+XgBBdmi9sHIqzlLGc5wxrw8i69ncFvcylDkQyYF73UwV1+q8MVyDAXI9mBDmkwQxROYznIfMkDK2jIl65XEpKMagU0+AENokAD0+jgCh78wW8qpifXXAz/h7bBzU52QihBARFkFzoDFrKAB1vAhxi+QwhByvNEKPYCGMMAxhSfWEViZFGLW0QILnbBC2AQ4xfISMYnPpEJJlgPQP5ZDnM+ciY0zSAk4KIjuKi3AhBYT496VM4PRseEj1FNBz/gTROwViwOqY8ISvCQ16rgLLDF7ynUIptUHkQEG2yLBf8jgiGJcJa2tGVve2tK3xhoBjM4hYF88xsdnHKFMtQhOoDhgyHqIAPP0SCPcKyBfhjwAf9Qhj8VUCMNtPCZMjDhCsucYRTIUMksSAEJOwhkbibWQx9iM5C+4WY3A9XNLPwgdlow4hg4UYyChDE9xDCIE5sIxfJIsYpW/ywPFrd4T/PgghdgNAYykGGNRwyiEE+oQXKE5jQchMQjzMFBZhx3mtBAlAYTnWgcQ7ICNK3gRjzgzQ9wUiGclAYJ5wvKSDOUyA1NwQlhWJaywLAsMBRJDWB4aRUqycAycAF+l9RKC3yqFRt0Ejc98lEZ3qKFdJkLCxe8YBrqcIZoufIpE5RSHtBQBjz4oRDTSQR1EmFBz80Acm4gSZiKpgAG6Md6I8EBFvylBiHVJQ1keE6ROMiFkEnhSr9BwjVV17HbNKGbgw1i67rJgyv84C1k0IEeXkHFXmTxGMQgSGUte9nLVhEh8wzjPd9TnmLss4r9nEY3BlEH3ziBBXisQP8DBoE5xjlUtqTJjOd+MNvTLGxhvPTBDjynA5BWaHzkO+RJUToUlTYyKTQtEk2RYr8t4FSnXMgWEYDqNqCW1Cw+OupcjirKUlIQL38BTOH0YggnGUIR61WEIx5BCUokIgs0qMGZVihHVSnAAwZ6QJhWIAMdaOGpTECMBPGCBzzcZQ13rSReg+NDCEeYm98cbOt4k1gyKFYLaLhCECDRC1vwYouYJTGJOTvPey5xnexEJzB+YYxgSKMb3ajDGu5wBy3kgAcaaMAZ8rDCHOCATbId5Ghye2SJwnEGQODSDMaSI9sKJzedFKwUzIdSRXbIQ+xTrocsuYW0zKV+Z7OuVp7/3CckDIuSUWkCiqyl02i9K4JJgpdgtgqYRBiiEHqmjiPgCwnrUCITmMCEIupAgxWScAY7CBMDaDUAAT3gv/SlwRXUcIUV1MEQeUAwgvnghzrYgS92WHAa7Kq4LERFr3vVKxei6c1vGnZQHR6DM+1Who6kIhcDGUYWS/zrfcqzivJMcbGBAeNgQAMc4JiHIfpQnDUAwXpaYETm6IsEJoszdtvOtm15oINvI3lhOaCBnJrgAx0TMjhTpnI0nYDIrS0ypVumd72rQD8wH5V+1Z0Nuvl0G7Y0oX5wrnFTUgS/COalXk1Sr1fZ+wjqwJfQhM5EJjqRnU0Yggb9JaEM9nsA/wYUoAAHIKF9wPSDMGVhD1KycyH88Gl6ZanGobZDjeGKSlQ6WAp4JWwQfZ5XbmahQhZsCxnIcINE0CIXvOg1ZSsbbGDvYheWRfEWjVFsYyC7Gd2YR9fv8IY7rKEJS/aDIsYwURlgAQdkYOYyBzjAZV6JrmWwC4Lhtd5HPOItUcCYNa8GQLlJ4QpWhrf6gEIUbCVhy4qv94fwfVS5XEt9Q/DB6oDgFrrVrylNYekjmzCWfdH5L4OY11apo4iuJsIRfV7EIijOCdjDvhSjuLghSKiBFdRgBwooQM94pt8KBDP3WbgMvAax6dOjXqvoLYy9RF9zuMbV1asGZxa28HPeTP8YnEOfYVswcwNR0ILpvn661PfJC8vuU+pS/8UuflHFX7x/tFmnP/2REYxgIAMb86hHPexBeingATIwhE/ABDzQATPwNNNrL4mrODPqDlRAhVVYhVeYBVnIBWEQBkdRBmHIA7TAAh7IkdH5O+vKE+DIDcY7n/TpkJ8wn8ajt4GjlvnJKfvBFvWhpC1AC6N6Czg7Ec4LgxY4AAAAAAMAARsIgyYhPYHaMz3jAz1IBEjYiD8oBEfAhEyIvdgrhVIwo01ANA1gABb4gN7jGTLkGf5YgR34Lx7YA8TAs0dwhPZCvUQ4BEOoQ8KQlyzJklLLOVd7Nd+4kqkImWjqjVfLvt//WCbG4RwtOIsfkAHHGohjYz9fWD9KVL/10wVd8AVN9IVf2ET8+8Rg6Cd/IqNkKMVrmAd68L99uCA8cARU2DXwmAVZtIVd27VeyEBczEVhgCdcfA9n+EVU4IIcwKiRypMM8avgWCY9MR9mpDekcMZn5LJlWZYtcAKqUIKjMIoXOSps2Qn6gbM0QIM8uIMlKIAhPMcAWIAaeIPBUIRDeIStOr4tAK4/GIMRag49+INLgL1P0MII1EItxAQ0mAEzNAD7sI8DMAADQKsvJKEVwIEZygNF0Kqtqsh4dBI+4IM9iI4EIxJXQgMzIIMruZJmaoso4LYfWp2P8Zg0y4mz6D6R/xiDUTgGZkgGZriFW4iFWMBEndxEXYgFnIQFWLiFTMy/ZGgGpIQGaZCGaWjKpqwGbMCGbdiGbmC2eQCHb8hKbygFVsgFhHiPXUQIXRzLsHSnJwrLXjuGX1QGRaCNGVgBJkgC1zhGjhIOm2DGDHmCYnkCvnwC9mmpv3xBemMkbMEfbJwCbsSWgYsKMxCSfemDBTjHcySADViCF3gDRdAzO8jMQXgDNKABPQiCorlHGXgAM6iET0CF7oBACSyFQcCBCuAxEKiABKiAWQE5W/kSHfiAMrigsss7RQDORCgEPugq9CIcPOADTsMLCro5VBLJMHOrAYKwvgod6rQNt2Kmtv/AqCv4g15gBmiABjJCyqRUSmqgBmiIBmpIBlVgBvWEBm3ASlTsv3pIxXqYh6y0SmajB/tsh2/wBm/gBib6SngyCF2sLGEgiAQ1yydaomVwhlXggt6So7g0RhMUGbxMAr3UUCroUL/ksi2LRsHUGg6Zgi3wERMdM0pqzHC8Ax8QAHQEgAAYARTAABZ4g9KbEi2QAR6okP3ijxHygAMYgAJogA+Ig0pYTYA8BU4Yg/9SABI6ABDQAFrpvbSSgY0LAuooBEWAr/VyBEdYhK5ir666M616Ob3otIQjEiFpzJAcySuIsNyYigjbCSxYpiC4grZggdAIAleoynmoSnBoB0L/bYf6nAep3IZriIVgmIZtmIZq+AZ72Id96Id/6Id+uAd3UId2OIdx+IZCJVR6IFR1+M8APY+vLAZiOIYTi6fLWlDLMggqoidiMIZiWIZieAQuIIIWiAweOMYkuFC7jMsMzcsnoIK+BNERFUygkDclyDctSFF844LGVAMbc4AACADJdAAUsAALaIEleIM2HIQ8IIM0+IgfTauSOIAAEIABCICRU4AkmIR+BMhPSAQ/mIwv7K8HOIAPqIDqMQ0ZwAPUYy8/eC/4ogRIAFPglMMxHc5CgJInqZc8OCA2tauDgx9L+jI6pZbFaDss8AwaCAI9oIZl69RxGAdxKAd0QAd8//CGqdyGYIiFauCGa5CGb3iHdcBUeYAHeegHeDiHcmgHdfhUdbBPe1AHpT0HU+UG9KMnLOIszAIGKWqiWEWIFDMG3pkFNeACG3iBt/zVYqlLu1wmvOxLtO1LxRPRKlikwfQQDWGkFeQQO4W8MEMXU7sLLjCAbM1WIjQBChgBFXiBJbiD06qzIACudL1SBshWAhiBBTAAkRM5BcABTKjXRMDSB6gAHPAAoSmVzf2vGpgXPIBHLs2ER7CEirOES8AESwi0vHMvhoXD9aIOQ0g9iB0ceEkSv6i5FFmD6GMwnMuCMSjeLNACjJIB51AFrlOHdIiHdTgHdIgHeMiGaqBKaP+IBWnghmyQhmxoh3uAB3joB3ZgB3iIB3cIh284B0/9hnA4B3doB3fY1E8F0GzIhl6jWikihjCap1g9MQCup6qrVfawBCY4txcAFw01H5BpO7M1n7RNWypoPBBhlqSot0Q6lp/QEbnAKXYxkjrIgQEQABIWgADIgAsYgRcYgSEIA7CToI1jgBsQUkc7AA/wuAGQUQxIgARwgAkY0mwdAAVggknYhExYAaHRgMmojAbII8kQwEdYBDDlg4nLBEuAvYrjhIqrOEKrBC+uhISFr7x7Q9plLzOuQzu8wyUZtZpTsBRxg7h6TjIYiRkgWT14BnB4B3jYh3og1HLo3mt41Fj/aAZu8IZqqIZRfQegBVrz1dRPPQdCnV93eId7eAd1EAcADdD7XVX20KLJ4l8oAuCqBeVQ3qL0oAU6OGAfaAGMWuBi6Y3ecOArYEa+1NAI/lBntOAPabzDk1uisA1K8q67ERIjmYEBIABkFgADMIER6AASUIEjcOE78AMaOACVoJVa8TghDIAeDgADGIABOAAHUIB3DQAidQAbUII3QIIVqBM8WoE9sLQxyAM4pEIjhr1ROAXuKAVSIAXa6wSABmjY2wQj3uJBC+M3HGMyLmPjrMOIJQx72QM7mOiJdgM4btMwAS6OEIVuoId7OFT8rAYZ0wZfCAZtQNRq6Lo+ntR+/1iHSe4//qQHdZjkd6BpdziHTA5QbuAGTmkPVc0iAQbgqNUsKFqiY3gPTpChLCiotzxWBs4+WaZlvTzWDvVQXH63wDQ8LdvlXqZbH6ofBsqbvK0DFkhIA0AAAogAFUiBFxhcKCARnYoMbQbncC4JBhjCAqgAABiACRC5BDjnvjbnATCABdCAGXgDOOCCJgABjMKBRwhO1LtCLeSOU2CFVDgFzFbNUdhsgBwFM9IOgCboQbNCTADjhFXoMS5jOozHiNXIiEawicaDDVIDjLqBMdAD3GYGVOy6ZdsGabCGbmgGkwYH3+Y6/OQ/e6gHpTVUe0hu5b4HSr2HSt5UAN1p7v/NBqnzIlzYbu7u7u2uhe+uBfDGBfH2bl7oHVbVrFzAgyvYgd7AjS3AS1hWppFcDFuW6lpWWwp2gjJbJCLY5WTZEGXpCY65W8jLgsZcgxNIgAIwAAIQABQgAV7BABIYgiW4tzVwgyCQAQYA5wCw4ZIoZwwwAJBrgCINAwVIAAM4AgcQgGQWuQNogA2YAkEQjLLbhELghNlbhVSw7MpOBVLghFMghVI4hU/gRzPCQiUfNEtocktQ2IUFUykPU9TjUnfUs4ceBNfuCzvAg9jeoFaiAzOgA44Yg0aAhmpoyqWcBmmAhmbQ3mU75GsIZKiMykL2BlCd1ElVWnf46E5l2kz/tm5uEOphI4h9EghE924vym7tbg9fE4ZOcJNAyj75Dpm4+1hjveW0DdELVh8AWlZG2mqsoB8DD7Nq3Qzb5OEEsIFNaoETaIEXqAI4MAM40HAhzeEAuNJyXgAVB9gi3AAF4PUJcAEXb1cCAGfJ7WENYIFK0IRJuNxVQIVZyARSsGxWmIVWaIVTuGzMpux+9uwj7wROCGhx1+LRvoQmh3IxlvJFMOPVjtiL1HK+8PJOgw7ZbqUy1wNVsIbzdPPwFO5mYDbf5ndrsIalhIZAxgZuGNR2mNR92NSZJtT2DXTrvif/JYgTQ79gmyde+KKnraJkWIZkMAb95YMZ4IGQiYLf/8DLbopqW+ZLq85LD2W8wRSK/14WmsdgFiSCP8yCc3ELqBprHmhbEAiQGtgCuNkBJ2iBHTA1O5CC+vBwEBdCACgAKPjmBFCAIegBDFgAB0iAHvhmIh1hdyVSkTOA2syCROiECfSOcT+FUkiFV3iFbbdsbkcFzMZsft5svgd3JTd3TLiES0BoMF2EMV6vQ9gqLM/yQeg0L+/yTtMDMqeD4m2EZeD3Z7CZaEiGYLCGOacGfo8G0X+GzH8GN5eGbfgG5O7jP5d4ihf0nrZVTjE2ziL5+Iu/T7RJzv+FYjgF3SsfkCG8DX2Clr+wK8iCtC0WZJX5WjaWLWtWwkwuZg11Iv8gxOO9G7hAAxCugzRYgz04hEHYAjLIAzOogyeIAziIA60yg9LEZhu+ARl413LmYckdgAWYgAU4gBNYAHMW7MltcIAoMMAAwQMP7HxatapUqU6nWEF89QoixFSnLKbKeGojw1MMSY0a9emTyE+dOGVKiQlTJUqUHjlyNGnSo0eKbho6dMhQoUKDfvIJyifPnqF58OjRQyepnjGknC3rBWzZMWTJgiFr1gzZL2C4cvHCVSsVLF3BoF3b9q2dvXHn2rVT1+6ct2/euOHlli1bsr5++xoLjCywMWSG/ybTqhiatMbWrl2bRi0aJBpEiCBBwmQzkyRJnnh+ImW0lCumr2T/yULlCWvQnld/bp3ECW0nVW5XUaLbyZTeU2oDB+7ZiWcmWbiYOXMGzZkyy9HQqYMnT55BiiptKpXJj6JNgw4NslPokh4ZDxgcOMBgjB4PAwYEACA/QAIMFwgQMLCAhYACB94r0MAABVSggAEJ+DfAAQYcoIAGa2DSCSqoKATRLK+0kmFGFFWk0UYflgLSKCKaxAlKKanUEiWVzERTTTfByFNPMxbih418/IFUjnjgMcYYVzjySiqsHHMMMMj4kswzv5hiCimcjLjRiKa4ctY13cxTz1tzuaXOOXZ5c5de2CjWDDRnntmYZNRY06Y228C5TTdYzlOnnfPQk+c83Twz/4YMRPSwQxKlbeaZoVSQVhpqqalGhaOtPfEopLMBh5tuStjmWxXBCTecZ8eZkdxyyqGBxhrS2ZiIIpNImIswwri6SSWVOELJJ5DccB4DDNzwhx7/vRfffAEQEMECCbhQQAAFJKAgegUoUMEBzDY44HsDGqCADIp8QuEsttBSyyuuuMKKRBi2QlFGHn5ICikhhmTSSZ3QuwmKLM3aoosvKqKTIYnM+JMfOOqIBx10mIHDD3x8UkouvezCDDPPGLMMLK7Qkoq7CVH4CSem3MLMNFjCVc9cdb0FppjZYDMnOC+/PA/M4NxZc5b14GyPPfvw3PM+9Gxjigx/9uCZFJ0Zev/oaEyUxmhqjkId9WpRP8HpbU4oMQVuuHFKHHGUEodcqKGWWmp0efgxiCGPYJLdLMU4o0wxyszySSaVZDKKJTc0sKsHevzxhwfAwgeAAMICEIADCQQwQLMFoDeggQqmR/h7BWDunweOoDJLLuC+Uovoop+LobrsbkSKR/CWNFK9KGbCkr4z8duvjD0JnEfgvqaRRh15DK3DH6MQ80syzDTDjDG91GIuLhqPQuEqo1zkyi/QYHOOye64o0443ohTjjpg4rWXzXXCdf6X34BDzz0+//NPP/HzbM880+ixwgxEDEEcDzwgIQk8SBqiNjMaRo1GaqtpjdS8EByu0WZrm/L/WqeGU5uxhcp3dSjV76pjCEVQohOjWIUwlOEMZxTjVahIySUg0QgZeOA8MmiEHiwBiUQEgQHBCgAPE8dDHmKOcgASyEAYZIBrBUAABBgI5RTggRtU4hWfA9ctxFI6053OQ6UAEetc1wl7qQQTlKCJi2jiCEUsQhE0wl1P8iAUg9nBDmm4wdD08Ipi/EIXyTjTMXZRC1z0ohisUF0pVoGKibACFmepBjfa4RZ3vOMc4QiHOLS0MvPhKU/0wJmebEaPO+2jH/3Yh87EEY52ZOOTMjNGEG6wg8tcJglMQMIABZi0pElBNKBhDdV4uUCqhcYJVKBg1yZ1S1+KzQxpUAMz/8/mh0Ko6hGW4MQp3mZCucEKFZughCMSUZ4PPOABjbBEI0QhCkuQxwMKUFbjfigsHipIWQcQ0EAql4ADFcAAzErAAhiUgMoxgAaUWEUvCgoMYBCDFr2YRStoEa6xWIQjIfoISERhoouiqCUtgQQ3F7EIR3h0EYkQaU8SwROgvNENdsCDG1rKhCCk4Q+1cEY0ghELaTwjGccoRi9yMYyv2MIWwrjjV3CxDLSoRR05s8dc6NIOb+xlL9ewE832RNU5YRUbkNGGNq5hD1Hugy3VkIZWJBONZFhiDEHYHyyJ0IRCHdM1oXmUAulqVyp4YWpe2KsXPiMp1uTVmIaC1BNAFf8qNdQhsdNBWyJqhYlPpIIWw1AGZXlqC1Z8ghKKSEQibuCBJ5oztKIgTys9ELkdAmAA81HWABrwnwUtKAH/JIh/MCCBfh7InglgwAocMYthECO4tpiF5yYSLtRNNEQVvajHUIKvS9gQEpAA6UdBCtKSmtQnPRHKHuywh+6qVApfWIoljhENZuiiGdF4xgmpErdh8NRzvRjGfIkRjWho4xvfkAtb6qGOcdhlHCwb08ioIY0zNcMvgwlMMGwai1jowhfB4EYo/2GyZgTDF0lCxjFSQYcg1OBPsNRMFKJwy9jU0q9/DY0vJeWovL4YxjyI1AIjFVjZxIawVDCsMn+nWLT/ffARlMgOK2ghjGEMIxcXagUqMIFGPozhBjcYgylUYeUq01DKMvDsaeGJxMYBa1pihq1AErCBYx1IAwpYkAEqcJ4HBCERl2jFMJacIYmwYl1c9Ii7RmFRTriOE/bCBAuh6xKQcjMmiyhpGm9XCD4UJSjdjeMYQpWUV7DpvtBgxjI6XdkUvuphuSjGw5zxDG1wwxvjkEs9mFqXbNglqtn4xX0f7Ate3GIXu7gFr3Fxi4vFAha+NkY37PEPfNiDHtAIRjKIQZVj7A0HSKhBW0kchRSz2K8tJiwDewm1bc94r1P7K6TquuNkIrYO6Z5O2nhSq0x84iGtMJ0hM7FZKPuo/xGxUMUfLCGKWJBHD61cgQcIjp4jXksg6jlA4+K5ZtgOZALHWtACNrDmbLVAAxpggAIUwIAgQGIU8573uToU0S3yOSTm9OKgN4GSSxh6uokGKcAKkcadbFcoj/5uHHuXBaRAYhlcPSunl3HCYswNVsJghZKHmwtg7OIZkKnLONphMrvgxS7Y0AsxdkGNZfDaFrkYe1AfNlxWEPdVx7iGOuJXj29IwxgplNss+ICDHPCABbGUJRNKjG1tf9vcUIPxjb9N470OkNyEnavUWJOFLWyBC8tZQ9nWYPnEUgeaing3oEcykkw8ohB4kPINLGGMWHh2hpegYZRlQPDPNmAFGv+YVubSYwD5JA5b6XmPAxywgIefeQHp2cAGJjABMcf+BitIhCnO1bx0dehDHOlzSeq1Epe/3BIu4SglphvSQmyWRoPgw0/G/93uciENyuSDHk7xjGdIuC/HWAZlKesMWlyop68gLitcsYtmSMPWeYP22EM93AWsfUNU0VcxRMNCDZdCQOCEaEcmeMImoEIqTEM9xI/9+AIk5EhQ0MEP8EANsIDeEUFx9B3SDNZdxdjgwRhexRhgBR5e9RWNNR5rJA23VY0UNEEPOkcZaEEZAKEWBOEZrEEUkEEa0AGP8AE0CZmQYcIjAIxa3UAj3IIreFYMPRHgfEEruR7BdcEMPMD/xdHeDgXAES1ImVnc4hjABFSAA0hAtrAAG2LOPH3AB3zWDVwCuYwc9OlZRE1fSFRf7GSCiWQCzGkfJRhaTECCR62R+I0fpO1BHUCeMh1FITydKWxaYBAD0gFD0hUDcRFXhdACMFwPNWwDN3xDq9nDN+RFmGBDNnTTH2SCMvDBFSDBDuxAiK0ACIAAOFXABoBAFOhBM7TD/NgDNyDJKKzACtCADNRANPYiZ8wS02RBDtJYuYmbuRGeF8ig4LkgMA0Wt8lSiWFBEAJhD6pj5J0BDigMaiiTHTShqijCixTCh/WKlQWBB8zACuDhA3iAGyjFwMkAHchA33Bc5AiEQNAW/3wkET/xU7aAAEQmwAVgwOJciwEwQAM8wBeYhwf8QTVxSJ5pBLvAC0MwxCfYC/ahCHShk/ZNl6KFn/j5BPlJoh1oQRNggRrYgRsEwSWkgioYWDIYAzHM307BlzJkzCkYEgm9QkEZAzRYg1q0wz0wFV6kYgJmg8Y9QAMoQimAUwOIpVgugANMgAJMwAbYgBn8gTRQ2D+0IjZsQzSkwg3kQA3swAzQgD9So2ZEXlxxWziGo4154+FtY+PdIA6qmOFlARNgwWOeoxD2YORxARdAnjsqjHH0Dh7MY2O5RCMUQivpgSqYwhh8wAugZoh9Fg+EimgKjq7wihusgA5hDoMIxP87CcBsbYDvRcCBcIAETIA7qQcD/I1pFVxI+uG6YAQgngJIvEtKftEmNJeJuOQldJ/3edQjpNGMQJpPlN/5AcFj1kEcfYEbtMIzTIM1QIMxFAlUIB1PKYMtrMIpUAhlmQssmNc1eENVktI5ZINeqCI2CKMGgMAKdIIs1EAz+uIJnAAHNOgJ2MAdKMIlTEM71I+WcIM0UMMsXEEakAFq0AATmAZc7d1gsVikaONhegEYsOgLPkFg0WCNgeNf0WhqEOGNQh4acEHZVCYaNEHkocHv8FwT1iPe2EtneUAQmJMMMAAIkIAN1AAZeEADfIAvDs0iuIFp7coD/IEH/gGTEpH/Q8bHmD7kAiwAAhTABEiA712LQeBh/vjNDejBJeTZRignc65On5GEvJyEIbJQInofdYVUzQ1CUZjfpB0FdeRBT7KBG5CCNXCVNrAXe7VX3JzQ57yKMwyVRNQCM2hDluwMKWnl1nHDCbRAhNrAD6yCLFyBDDSBDbhAD5xqCdZAHigCJGQgPpCSPYhDO3BDNzhDj5hBY9ZAalwB08yGbhzTa4zbo/DVC67os4ajtNLgsx4m1ZCbjd5oGVSmZVIm5HHBj+7oGhDFospjIjzCJEQIdH3pDZiT7LXAC/QAC/zADOwPC/jjB3SBR2qhDLhQI9BQU7jHDylRwSYOAOQHASSA/8Qdy7U4UcGNwa4wwAOsQJdehPRhbJ6GRCkIoklsAkvCHMy5RPcpmkfRHO6QH1Cc3x6gjR8cRRy5QRrowTFogzXcl9EZHU2dEDZRljBEgzPkgiEx3TNsAzi0Gim1QwJqFTa8wBKEgRJsQRnoAAllQQ44gQ0MwRIkAQvUABYMggtNAz3oqquVw564ghmMQRr8CBP8gGmQRhP8hhPgoGxEDV9VK7S2qLVGKxjord4angL50nEIoRA+h7dGHpA2wbi+QQclFh+gK9t8wiVQjyX8wSWIAgzZgNPmACXagCC0QAmCgDD6YzP+wTk1gq/ogSg0wg0oZAHgBwEIgAAMyz4lAP8BNA7kTCx7SCwDzJAloOTvdgTrlATH7ul0vlzIJmKihRRI4cT4DYJ3CoUfFAUe1AEdqFRPzukxUEk0FAOT5cIJwZeryMKqykL5NgQIjULIWEOWWJ3JcEM1VMM1PAEYPG0TpEEepAEJpQEX7EEbxAEVRKnuQIIlVIPOFOA41AU4SMMfBAEemEEQBEFjpsbbbgFtAG7d8m3f7hWL5u2LcbAGu+AL3u3grYaoKEfhdquOlgqQrsHiepcdoE09TgK8fcx87Voq5A8YVEEYJMEghEEP9AHXtkALMCgHbIAHfAAkmMJoWYIelBM50ZA6EYQBvK4BHA4P9Yc+wcdw/g2TSmz/EDTCJVCUu7jLR7TOSJxxiWBUyFrn9gmqoKrRT+BOJEovjyCMMvVOUjSCB7DC/f0BDvjB+GLCCmkCKFSCJDRZJajk+JUCK+ACNFCDzMDFU8HvNcSBIDBCHxxCJdiEIrzKI+BN7FhCJpQCJ6RCLGyDAZvM1m2DKviIGwyrNSLQcVRmFdjttW5w3rYoB/OytX4wX/0y4fFy3sLoo2BQZZIBGaQGGYRKMpMBEZrK4qKNHTwTus7wx7CCMBRDkSyDLZTCJrgBGDDBHjxBGMQBC7RAD6DmC6gABvxixYqCKpgTaaouwDYCJEgBA9wT5uRH7PZH7LLWcMpAEMDm3yQCJ6DC/+8KYsd6XkP3qSF+rL1cwqysiIoIanU1mncChfR+V1ComxlwQRb4yFJkwinkgjI8wgzcwSF0wioYgiEwwiEwwkwbQh8YgicwwiAwgiKwwn1ZgypOMjdAxoSgQvkadfnSlJJpM6aW0DMY7T7gDNxVAzQwcKhkwf4eh9OEyhmECjGL27N+8DCDQRuINS+TdQaPNVn78jAfpi89wdh0azIvczMnMxEqLjXvwSBEk7pCyStMVqc9w31FAyp0Fh+0wRMMwgy0wBLIqgsIAQmgAAsUaK/E8y/EwhJbAjmp7heYlj65Ln4ciEPmnnpEmZZ+3B80wiewQik0NEkwtBfRiyFeVP9EH+L2TbQbL69HvfTtCMz5DUweqFsaCKEO0AANXMcjeIIkiEEgCIIkzIQhvMEd3AEjeMIdDEIfMMId2LQhTMLbPAMqbkkCVsOrkHcJ1Z8yWAM1yM0y0FcvNPVTQ/U3QMMzvAJM9SQXSMEOh8FtIEfvjE0wAzPfpjVbr2hZizVfnfVXAzO1wpgNwjUym0EyYxAza8E5PkcddDT4LQLbUFORFcMyTMx9TcYzwIIoJIIZ3EEN2IAP9MARFEEPuIALnGpebpkjpAKv0bM5AWyUfYBr6RNoX/HBBsDHxZDEjkEi+C4q0Au9tPZFObmTF6KJfOwhqogiVrmilexO7LZG28j/by/qHSRWHdCADsxADcDBGzSBIMgBFPTBG6yBH8RBFcSBJqiNJtPEGaz0KoCCJ+TCM0BDNaiaOqgDVPVseZfQ3KC3NdAfL/TU3DhDN9DDztRDN0gDMTiCDpiBFPgObYCBE6gBGPQOM6mfGfzyLp91WrdBqmcwXqm6gdstFSR4gHt1LufVBmPQreO6GWwBFiRuqZBrR6vKIgzZKJhLIPm5YFPDZEQDMVhCHtAADuzAFIiBGBRBDLjAC9hAH/zPDmR6IvzbvsWC6vpKlNnBCkyLFsPHtaS736TH3zhCJkxIdD658T758cIcC1W5lY8sdVGXTfCEv5TfIEiv9JorcBvk/wxI9g7I9BuIgRD0wR1swR2YsyCsqiFYhyQMQhP0gSCAgiYwAioUQzJMQ1bGhTcc9Sysasq/Aqwow9e5Qirs3ywAgzaAg87QQzdQAyvcgA6kQaqTtS2PNd86ShaEyrW2oLWeut22urS++opyYwi/mF1F66ubQRukgReQejibgRI0gW2EARyAfRzkdSEcwqoo4iikwiz0wvy9n59DQzQoOy6sHh0VcQaowAWcABGsQA18ABKM7hhwgiqEO+XqgZSVxxj+k7pnjrNMLEDGWSNgAmvHi+cteWxjX70X2qxo/uazSE3EhHZ61E0cQiGcVG/DMMuGuR3Uge+kwX5zvCbIgf8VzEEgEIIg2L4gbLIkNHdM73QfaAIiaIIsjB0zWAOWbFI9/C69gEInjMQWkYIp4MIzEEMqiMIptIIufOrO0AM4RMPe0IAbtLqAd/CCY7Av57JXn3ov9y2AT/0G+y0NEnjQTw0H24Z+v0HYi/1PlL2QZQIpwHwgAcSyZc+eQYsGTRq1aM+WcQqyAsSJFi5InPBRA8kOIjNmrFghQ88lUZca/dGjJ4iHBgwYKDhgYMABmTIZePCwwsONMY0gbSpV6lPQT52IFt10dBMnpUs5Zbr0tNKkSVGlVor6yFFWR48WLVL09VAhQ4UGlR3kZ0/aPHXstE1jxkwaNWjqSCIUyNP/nDmIEBESJOgQI0aeKkmqxEhSH0SSGK1axQpYNG3g5tWrh4kSJkyVMm3q/IkTKVepTOlitmxYrVvBsKn796/evGRjbshwAwZ37txeePfG7YUKbzBtwPjW/bu3l+O6gSv/3YY48uTThRenvts68OBgqnQPEwbOGzjj49hJW/ZQIkiYOpViRasXL2LJmBE0+Ky+s1yXxnyYcYKFIcJQwoYqdtiChxyYkAInOp5qhKcxPHiAwgYeaEABllh64CYZblhhDD0SsUQopjhBCsWlMlmxKaeeuoQqqWSUCitHuuLKq0MOGSsss85Cay227KCDSDrUmKuJN+SQQ685IpEFEbw0/wGFEU1kQWUVUA5bJRRCJOlkFFyWmaabyuxZBUvHZFlTGGFs6aUYYo4x5hdmorHmoG/C6ecferpR5YYP3SDOueWyk2646JZT9FDcGCW00EKzo864RHdTDrrcqEg0uirA+G488cYbr63z/EjEEUoyGeUUVlJxpZZejlmmvlpPWyYXUf4Iggcu7ujjiD58uKOJOvoYZAYZEuHkj50sSckmCj+4cCWWPJDBwyBuEPESUk75qROmPOts3BVdvMRFS9SFUcZHHpnk3RptXGReRXTkkawf0dojyLaITOMtM9bgogpBEIFCDL0iIYSQNWUJpUpPqNREEop19AQVVGphZhpw6v+xp5hilBnZGWVKNjkaZwZaJplkjnnGGmu+6YfPeaZppLYPMnWU0UsN/Xk4oKHr+bpFc3t06KGDThq6TZPGTQ1QRyUvjjhI5dePQhR55BJOPln1lFZiJYZWZmwVaBlbSlGEjDCWOISIO8K445AwPnpklUI+WCEIGT76wCbAJ6SQw0CDGAPxRlKZhZVTUFHK3MhdXPHFFy2hBHNK2tWK864898resQoZfRA++FBLrTqKpCMNOswgAw00mrgjEEKsgAKKHqBoUg4rhhAiDCv+EuyQPgLzQxFOboFmG3rqUWYZZ6SXniBnFnKGIIJuhVnPfuyZ5xfaZPCAaaWFNv/Rn3f/Np9nRZHOtPz45Yef0OGOlJo8qkfdw4w68hgkEYqghCUcYQlOsIoVr5AVrfCTvWg8sBic8IMaGOGrPnDhEWvYwQwoUQozrABwFfgAtm6gLRB6gAEc8pBOUBKERrwiF7NwDOTQtSJMVA6H6soc5tzVw3nR64efU0QiRDeIfJmOD2gBkuoAViSAyY4GNejBHMQwBIoUQRNQIIELoPACIRzBCpHQhCD6IIg7AAYOhsjEK55BjeZND3sPdGD2rDeQ7E3jG/vYBz20cYkgdEQD5eNUz+ZHnKc1ajjOeVohBclIR2ZKOG2Aw6emVjX9waFqWTCDGuqwBwAqohCJWAQkMvGJ/1KkAk6zwh5BFHKnaPSCWWk4wxrQ8Ai/6aCUTPDbCTZQAQ/JIAhMqM0KCheoEDXrD5d4hS1sIUPQZEIzmqnEUyzxIqvsEHOQgIS8svI5b3olEYkYXb58dLq08KsOTGwdXLKghixkgQc2EIMmAtEDF6jAnjFYmBiKIAQhIAwRRxDEG5QQh8RU4RCfIAbz5pGyVUrmgdAYiEMX8sCDUMN5sXkGSmqwgkAeklNHkyQcHhmd5CBnkDtrH/pKmjSSzq99VQDPG6pWNTXkjzxZ4EJcOukHP+CBD1qDRNdGMQtbCKMY0XvGA1sZDYUcwxaZ0NYfahOET1QCBzVgAS83oAQkgP9gBleQggm3dRI9QOgPlhjFK2bRVlaMohOZsMpmBqiuy1FCm3jNija18s3PhbMrARQn6XxUFnOis3X/ogMe0pCFOlwBdluwQRheIAdEuOAFQ4ACIbLYAyHcrgiEgIIcDrEHOEjCB4LQRCd6sQxraENlApnVMogRMtsOY2S7ME0yYoEMboxjHuBQhR74AAcm8AA6L2VkSleqNEk9MqXLjS7TlOtIONxUf1aLwx60e05+5SGJWQslvTKzCVOiAobDmG1BmBozajzDFCXxGxM2sYcPTKsBDahADbSqgZxoq6xmPYkjOHGKV7RiFan4VlyjWYm67jCvmZtENzv3zXBeeJz/QSXdEdPSljzkAQ8h/pfqWBcwNEzBB0MQAyH6MAdCFCEGULgAB4TQz4SJQQzHukOVrISmYliPFrVoxStekQr0rmITRMlENUdxCVXoAhnNqMY35jEPa1giEXt4yw8GVV2YTpdpumnpmMlcUjWAAbuWHJWay8MvDyNRvAHcCia81qpZ5GIYZCNINKZBDWpA46mp0MMK8PAJPnwgDSuogAZYUIXJrkAKbtDWTkzyB5MEARKjSCAr0ASUTWAmc4/IHF/3qk1IdNOvfx3nqkd3OtOVbg+H/S6I8bA61hlJDWkgAxdsEAdQ4BgKR4BCIOYAhRHAAHdiAEQkEKEjwwhDFpKQ/5gwTKYZcmliSpIYxCMUoYc/NMISsWjGNLbRDXB8g8rGEJEeEKeDQZUUU4U8TiEjCVIwl1mlSgszGCppNaq9gabm+e538ZCHrAUQiJAwIALbusA9TwMa93nGMUwhClYMOhHj20ENjnCEOKxADaH0tiVKAqFG6AESrWJF44DCYB6WmnOdC+JfByvKcK46nGMxrHfPaZ4P58EO6RR6Gsoglzq8hQdEIEIV+iCG28lhTXMYghzoCQhCLKZikkBFJTyBbStRm8eVwLa0te0IhasCGdPARje6wQ1veIMy2tDVH2odhCC8G9/xEzNMq6M+nq30aJZqX0gHmdIjYfKS4anpOf99ikQ+hNjgo1PEIhLRCLNnwmuoOEUqaiEfO2YP9MmA77ex1YYa2GAJTnCCOBMhClWY4hKWgERJ/sCJx2i+FKM4USZ4iBUgenPmqfYcq4lPWFnvoVRAb4vQ00mHMhQ912/hwrD64BcrBAIUXbrLHIi9l2YfQuxer5gnViGMhUWi65LAxIpKw1DLzOMc8YeHO4Kr7j8QaQx2x3ve993cRe6sUnymOAIPaO6tkC6pasRjprarD/bApx7Qp84pvEbnD8KJJywBEzzjgFIhvVRpIMwGGppBIX5BFPTADcxgg3KgBqSg8hphTlQBBk3BErxtFG7vW0Dj0yjBXWxk8oTPByn/b3QGiw/agg2+4Avs4HTcQAmR0JzawuecEA+YaHUABmCioAzQ4A5AQRL+othCqy/iwBMQQQ4MChQ0ARWoRBa00DBQAUoI4RDgxRFG4RaioUwqQ4/2YRzsIR3SgRzcoRu0wRLGwA5e5wr075D0zgBBin3yDVIoRTtOSvBUKhEL6fD8rabiAOCqhvEg0Kf0BQIt7Q9CKSsowezY45SWaRiSyj4izs/w5BhGAQ+Y4AdkQAcKYfZEwRh0wRRUYTRmcBFKAU00T/eaAjOwYvJ68Af9qtXSwvGQKNaWkRm9S+CUzw6i0PnooA5CbEje4ui24A0YoQ/CMRCILRAMBtu8BBGq/8/rPCHaJMEdQUEWEuHbREEXGMp52sEe8jEf62Ef0oEd5AEfwIEZjJA7tkAHCtEODlGQJlHf2Ic5HDE5qOAJnoAKKnI7DEWR8q4SqeYSt+ucwjEtIDAPHLDx/CAbgerCGsECLQHzSCEV4KMYZmXPtMG9IIgVLoEObsASRkIXkuH1YFAUGqEQLgFLcA800KUYv+IrklH4LgzDWu3VDOt0BI7nvmv5ms/WSowM0sB/iCAMru7qXAwwGKF4KuFhNIFhFkNHNKHryI8em+Eaqqwd9sEd3iEe9uEe9HEf+kEe5CEdvqEbTCEIuqA7uGAHroAJEnJo4u2QvECQHLORHNK5tv8DYOACLgAmC6RAM99Jk5yjOgKwONpADUSTNKFGktpgDeCgDuAgNe1ANS0J4GhquzpyJB8wJCEwDdbAf4wonE7i2wooEzohFcTG4e6EJvHEopxhFkQCBlUhFp7z9bDMETYhTU5hGGGEh4YIsJjSc0Rp8kSJ8gar+MzCdJyw55zww4IuxGoNceICG+uAltagCpagDwIBEUAhEgIhHAWBETJG67KE2YZH2kDBE0JhHCzDMvLxDhd0H+KBZvohNsABGpolDdyAk+og15RQQ90AYDZ0QxexIaNDIQXwLajQDN7pRDkTRd/CU47kzIBGDdYgDdAgN+ciN9fgDdZAR3UTPtn/Yi3WwAk9jOeUiA8GQQKNiHQMQUmV9Cuy4hEgYYAw74BaBT7WyyAsSo6YARhioeJEYRdfryQWYRMco9OGEZquIl6kghIcbBIwR0Y0RwdxhF68oitCqRCC6vEeTw/wwA6osLGyIAhwAAeYIAuYQAduQAfsLlEXNVCSZQVmAAmIgECWAANQAApkAdoioYx2rE3OyB0XRhPEyB3Hbh3i4R5OdR/ywR0W9B7e4R3uYR/wgR7AgSZhYQxKjAqPxEM5tEI9tEJb6t4QJWAsE3HGwAyK1VhPlAucoDt0o1l1g+ie7wzQAEffIHZwlPl0lPmEDj1t09UcMIlizQGR9EcGYUmX//Qr3AVzpslrTqkV3gQYZJK9FmIVmyEYYiEGU4ETLsEnHAMVcm9fL6EYe4hgCXYrfGgrskIptWKI7BQqC8HSwnXW2oJD7SAPWKcQryALivVwDmcMfiAHeKAJdsAHfIAIUCABVCAShGEVvIQxEEMTGEEQUMETIoH7+MJl7WIe6KEdzmEc1GEd3uEf7tAe3q/KwMEaguEWdoUN/FQu1GBXlbBDPXR95C26LqU3iBVZjbVY4WIMdIoLwvYyh9VP1cAy48JFd1Rt12CWtjWdfu7DHnAkf44T/aAsyOIBC8uIFOFgdxASOCM0UoEViJNsPi/iDlcapAEazOYYeuEVTqFVvv9F9y4hr2wE1bbGcuf0myhMKX1IKY+RiC7MEMzVEA7BpyI2iX4kD2Q0bEv0WK/gB3jgnZiAI1bgBApgAnpA/P5CELYQ23pXEiJBEO6CL/hCEtrBeezhHcYhHM6hHZA3uLoBG6phGpIhGpJhF0Yh/6TWaaPWe99t8PSuMT1TO6jAa7eWa7dWk8wgbMX2bMeWK6NPLgAmR2kpds4Af7VV6FZX6O7g52YNbiFQbzuRPPe2B7mNvKrpE0iBVVoBFuRjVurjcBFXcZmBF1wBcltBwSa3csHTc2bO5pzS5hQ2nBbWRsTJDwxBO4lISZXIDyxtPfkgDax1WZGAB8jgnQLVbx7/FVtASAYqoADCQBKYJBKEt3b8AjFkNhAoBhGKuC+8hB/4gR3g4R3U4RzAgTL+cBqYwRdiIRmMYRmSChL8JjfCIHZo1GnTuFeVsGoX8u8mpTcskgo0SUXr+J2uQGPfSQue7/m0YI/LAH8Duegs008JOfqmlVrfIJ0UOUZV8zUtdiS9i0jz1ojKlTyTaJwCaLxqxICIyhQ4MBfkhD6YoRlCsJShIRl04fU+2VVKQRT2lRRJEZws74e+AjxvbpzqlIWV9G5f+PHW88OO7khy2O60xUN0QFBngAkc0J1+4ArGoBB54AeywDcdoRLsxUrws3Zqh9k4yy8MZjGauC8CQRIQ/0Ee+CEdXLUewKEbtoEamuEXdOEWagEXrEd6eqFvdgA3zPiMz0CNu1dD5YfwHAVrecMiJ/IJpMCO6xgxmUBjrwAL/PiPy2Ci+bgM3rcy48JEyYAMzCAMKElUpmZUgg5uIznWwouA7XaczgLOWLoQHFBrJi9VeIKoXNIVYMEXjIE+moGnF/cXVtkUWAVgYQQrXm4RICQ8Q0k8WQ0KgcoP1gJg8CD/ivlDPkIG7ssD9sYmrDpbgkqczLUSzitj0kQWUpHaRmYVwLGJx9EKrg4RBKEMwxEKijcSQkETEAHb1AF52XkbrKHPFvcYZssZFEJ6LOEjVmBGzxgN8PefAXr/Av/PIbFWjhF6IhV6oe+YCTLbofEYj9+Jo/OYo0N7WOHijHV0sSlap9DWDdZAQym2tdMgSC12D4CqGc+CnMzCp+C24IgkDypQzkLJ8qopNDYPFnaBbMyGGY5hF0YjFVKBFBh4XyEBlFRYzuTxJBhrYxGnmKdaB1YIW3rYI1bADIz5vj4CB/hgEURtTQ/IWwR3mXKBmXKhTeY7ZOa7TWxLGdpEFvzgEOQgDGoMx5hNYpQhFOyT2ORgHGXBE9ISi7dhGpqhZUa5PugoZZThFXTAIz6gnwM5YJw2Lgi5VznFN/atDSLyCZIgCSQSoVF8M+84j7OgofE4s/E4Cmo8jzs7tDn/un01WrHvN5CzoKMrVMjdwA449AvMwA2IJEgLLk+bsW7t9iyChMRWBw8srdVAsfJIKXBhCBhikrZ6QcggdxR0j4D4QAp2AM1z4ArsQHx62CbenHBqIquDgA58E1VSJRMgd3AHt62OShjkWxh6QdB7ARiGIRVDhhgMfRjsm9Hp+8+FARUGoYzC4AhegARiLD/lgBDaZJvnYEmY5OoWRhue4YuRQfSY4Uot6hlSMRdSIROIhKM/HC6KrgzWt8Md2w16gziCg6Ua8aBTvCInksXZyY4JFcazIGC4YH1bV5Nu3QyaAA24oAm2gAu2YAtyIAd0QAd+AAe2HQdm4NsFlQa+/50GaKA2ZIAGsGUGyt3cu13bE3W7r+AMyOAMtOAMogALfiAKuB0Hyh0H1B0HgqAQdWAGAsVwzMDbaJoTTOGTSeGVOUH25JE2qvoBGEAGHuAAGGCExqeESmgMvk2bDEgUvMUVaAEXTj4XUj7l4+MWWn4XXn4XWr4WZh4WXMEVWv45YUHmv7hx5VuGgnEotOQRDMFuK0EJPM7prMDTAyF3XKytC5xJio37tm8vEP0YqMfPtIEapIcWUgGuOiHS6YAMriAKLJOjaf0yQdxPefU2eANSCMk6fuOgtUPYk6DFORMx875Q87ixpIALpG+nLLN9pT1st2Daq70JmgALahzfsf9AB5pACyAfCKIACMgAC2DXmSFLFqU5Cjh77PG4PcuADDp/UHGAB2gAIspbcCYkq1f/zQPHqoPgrISbKUZC9kriJEaEEvggEbCia0hhcF/B5mGBnneBF3rB+HlBt3SB+X3BF5h/nnX+Fp6T+p8T+m+B+Zk/GIIBGbqfcZehcQXdGTaBo5XU4CTLB8KACGxgCIagBwghEqCgCJhEDoqgrUEh2BLmdqzA6aDACv4fIOYEKrbsWbSDB50py7XqE6ZJhjSBqhQmiZMsSMiYKUNmjJmPaUJ+NBNSZMk0bsB48dKmDRgwLl96ealypkoqOHM+eZLTjJQsQLNcYUL0B5OhRK//ZHFSpYoTi06iMm1aRQ0aNGvWYH3z5szVNXXy5Kmz5s6dN3fW9HmzBc2bq2iYoGmyhUuTHDV+YMHBJAsZoT9q4JgxY8UKEB8eKFbsoQEDxwwiMzigILICygw8yAhyQ08iS6JMmUqlyhWsW7h28eKluhevXr1yCYM9DDawXbtu3dLFu3es3sB1+eLtq7ivYMiSJ2vGHBo0adKmUaN2bZu2bdusabP2bBmwXrOEbcphI4yNOGLmyHkBA0qPGC/EACoyZ74VK4gQzYESSQ4UKAIVUQQUR0Ahxn8GOmNQQsMII0spm2AiiSaMMAKKJ3HA8cRTPGhERkcjlRSiSCSlUSJN/y29FBNNMq20EhU8eYETTzitZKJQV+SoVI5AESUFElAlEaRUUmVhRl1awVVHHWqIlQceedwRRhhVUAmHE0RUQUQNO9RQgxNdsgDCCoSNiZhhMhjmwZoreNDmA5l9sIIMdAYRxBd6/JFII5BYcgknoqTSyiu05IIaL8AQo+gxxgBjzC+/+AJpcZHeotptt0gaqS7BGBfMp58mhwxzpEIHnXTUbfPNqqt2s003sHKzDTbYZNMNN7JuB40vx/QiTC6brMDCEEMU6EIMAxYRgxBCxDAHIkIUIQQUAyISSiAGiiFgEWL4V4QVBgbi3xzRKAReKZ+sgooknoASSST5aSJIGP9HRMWDFBqZ8WEZ/IY40r8kphFTSyumyGJNL1JBk4w5UWGiFBBHLLEURBHFww73UrzDDkRt3HEOOOAQhV9CMcEDDVHooAMOV9Swgpc1sMDCChqsUIEHiS22ZgMPqPlAAw18cIOdQejhmSWWcDIKJ6SkwsorttiSyzDDFGP1MccsswyjxGBtjDHHKAoMqMEYA6qkknZ6HKiiIrNcM89NA1011WDDDTjz4D3P3vTQM0877XwT6zbceNNOPesATs85q3qDK67eZPMNdtvs6ovVwmRSgwscxGAFffN5DogQRjBrhRGl30cttkd8261AcsghRiRQyBEIt4SIUUwro2SCSSX/mTBSCSigSCJJIIQQIkkcYUyhxA5ZRJFvvh959O/1JJoBE8Eoco+iSi0e3GKJN07MBMREzZDmDBtvzGUN6qdp2Pzq+9yAB4wlxsDPDFTmGJw9W0EQdJCGQixiEY7gRClOkQpBTc1qytCa1pyxDGdQUIIX1FoylsGMDiaDGcZom6jIJqpkuK05z5EG3apDOLz1zW8vpEc97GGPfdTwhjbMYQ1tWI+8weob7djHPvohRBrWA3CM84bjvsENV0kjGLoAhjAyVwMfoAAFGYDCCOrzgmUtSwgwYJYQXhcDQnzuc3MQgxju8yw5PCsQ6vnPfTTxu0yA4hGV0ES7JPGGMDDC/xOSEMQapvCGJmiBDDjg1xnKAJfrmcF6IwLJ9lakIoOpaCUwQZhNakIFI5khCxTjAQ/OxwQudSkv8WsTmz6wpsX8DH88+xkANXMDM+ihEIn4QyMc4QhIiIKBqTjFK3JhC9hg7Zhay5oEt8bBDjrzmc78IDRJRSrnRGeFdbPbN8ChtxjGsB4ypKEQx0lOcv5jH+dMJzrXWcQecpOb33gHO+1Rj3ruDRyrwhusroGMXxiDGL3YBBOQMAUWcEAC0nJBD1rgghe8wApibE+3oKACK8xhDkUABCD+wy0xaIIQcrCCG+vjHytowngT+qPwAikIQZz0Dn0Awhm0AIQy6OAK/P/iFxfQ4MgxeMRE2HMDStxASTAQNSUo+iRK0mAkI3kBlCbbwU+kEBg6WbVNH2BlKx/gpqwaRk43uIEOxoAHOiTirEnrRClK0YpZEHOKVeva1pSJTKw1MxnSxKsJS6hXt7ntbdV0zjSsMQ0WvmpvfJtH38BZT3HicIflNOc/+kHZylL2H5jNrGY3m1khuhOf36AHZG1oRHD2DbHz6EYz/NmrVUyiCTY4gQQkwIEBDeEELECEIFrwnzSqBxFWEEMgEAEgWWgiuGJI3oCwlZ5uEWKjYvCERDShCXVJAhSoAKQmssuIHKhvBjQgDA3GK97w3gB+MghrWAnD3vLOSQbspZP/nOY3v/muIKtZXdNWFQO0WHKVlXJKbxDGYLREQOJPoWmgoFzxilrk4sEPho2EXbOaCvPCUrjBjaSCY5y1kQ05gIXbqehWKyV+4xznaAc9DlfPFrsYh0MsJxGJmE7O4gMfmLWsjikrD87+48Y43mw87nGPcWTjyLXixjnqcY93vMMd6igH4x6XDb9JIxlgGwYqBgFSF7igCCoQArgCEQjjeYIQwpBEGNKDCDgiy4xzkEUo2HjR4N7HCuIiRCTgGF09gmK61KUuICVRofDSAAfjhVl4wUuDG1g1veq9AX2t6mj5TZpOl450WHUg1iDQIU962tOBOaE0YDqNwQ7WDS5S/8OaDAfn1b0pjm9i8RvhdBg5J0ThiOvWxB++U7EsbvE99vGOe9xYs0QeNpFvHA8g73iy0O5HPOSBj35Eu7LyyHa2d3xZHx97s5Tdhzoilw1aZcNw97D2P+DRj3Z4g4nZ4AY9rtEMZBxDGajgwguKELtoHaF1kZAFIvqAiCUIQhbOQAS9YAcFcBVIPSEFKSH0c9HnyiE/6plDoNtVvJOiVCKVuAOiccBplYXsBomuQVjptHKWv/fRmrZTF2z5Bz3xyU+jIIUpGMiKVriiFrSwBS5ysYteAIMXuXgNhS+cG93oYjdP342sdUHrqlv9N55i26iaM+Jr2K1wqwIc4I44w/8jtuMeQx62ENHeD3W44+3uKPY9fPwPuSebyPFoNj60zXdt96PvfOf23wHfYxt/W7N/78c7vkHuI3vDHXOfLDvi4Q7GHXlVzGHGMVhxBRCggD4GKkIPhDAHPAvhCGJoQRiIQF03Onc/APLPEfwTO0REIj0Ttz0i3IgIQkg3FH/2hHQ9LglUgIIRXIjCDwZsJ5+qjGhX8KlP6UB9UO/JEX4CVNOc1tZZRC0XE6aa+IdBDGCY/+iriRSlirOLDrv//R/GNWDjRrds4opV+AdiO+AOd3Ss4//vwA7pkA7+Bw8GCA/Ttg7sAA/ywIDZBg92p3ZANoH4kHdoF2M/dmODR3j/HJht/MCBgkd3dHdZisc43zAO4TAO61Bt/cBu6RAP76BE3FANzfBBy0ALeLACS7BvQmACGCUHRTAEyXIEQ7BmfUAEfSAIyUNmsUdcdSY7GqcJgKAfMaACwiUQhFBmoBAKxKcJ72I8qwAKhHAHeMAHiaAIjXBzloAJnPAJC7QKqzAL3gd+wlA1VlMMWKMMWYOHWGM1ikIMX/NPf2h+5Wd+ZQMpkPJhyBAqf1VNIzYNdRNv3jAOK6Y4jWUPh0NDmrgP/Bd37xAP6+B/CniA7FCKBsgO/LCAROZkb4cO7rAOceeJ74CABph3erd3gUeC18ZjfcdtudhtIhiMGUiBtsgO/+JQDuiAguGQgim4gjzWgvFwDu+GDTUIDc9gC4oAAizAHjDQHgTChdNCO8WSXEooCYRQO4HwLsiTPKFACL4lBhgXCC+wAAlQW1n4LBMSaH/mhfCiCaHgCYiAClMkDMWgDAZJQRaUkAq5kBa0THfFDHolTX/lV24TQnoVWNBBHdWBK92wTTA0D4wlQzNEToJnWSNYkti2gfCwgKjIDrNobOtUd8mWDzSZDxUYD+qGeDomDyjJk34njJpFgUDmZERJlLaYd0T5f0pZDkwZD+ngZCimDlI5DucADyzYguumDuNAg6PCDLmQCOSBAh0QRqMnBEMgB/0RCJowB0cwB4EUBv+IAAqCsB/wmEbwko4glUYHIjtoSQIjIFxZ6I7DlTx6BC/P0ma2MweeoAwLWUEV9AyQ+QwMqZAdRE2W6RwpRA3WsJnXoA2eyULfoFgi+WKQ9VhCNGNDVJLghpKsmZI6NlkmaW2yGYyWxZM7SVk3eZQ4OZt/hw+RRU5N9mRvJw7EWZzGeZzigA7KuZzKyZRMiWLnUA6sWHnq0A7VGXe2aG3kNA7SADflYgmBwQEUEAEw4ALJEwPC9VFHMC214y5HEAYGwpfiIgfuso7i8i21c1GhsGeIeXF5SXFvtHtpVCBHEAcCmZBaM03NwAwOKUHPoJnW0Jmv0g3vxE2odaGIFU7/9qCBsRmCORZtnVVO6rSardmaIDpZtsltPiZ4fieb5SROa9dkbzcONDoOjGdijaNESrSMxemczcmUzCmK//eKr1iUrChPZmd2Y1dsnlVPgWMd21EMf7ADLRABEZABYNQDuEMI0gIg7vEtRUCEQxCfF0VmZnqm2JIfZBY76iigbRYJniAucBQJmhAIySVSaVQHhuAJq2ALy2AN1BAd0QENzTANwcCgEpQ1z2ANr6I3eFOhFtpY9vQN5XZkR3YOTrYPRIZOsKmdMbp2+ACT57QPM6SJ4lQPORSjJ2lZeceLKbqi8sAO2VaKpfiLswmU/1BaldgONZp/NYpiSORiY1cP/9PZicX2dk+GqUbaDu+woaZKT5pYT5X4N0iURPg0K9cwDdCADLDACYvAAy1wAiOgArGjpRwlIOdqBUMAL7azRrEDfGQmXGQ2cZEgEHKKPHOgZ/0RO+kBCmQGL8SVXPVqIHGQA1qABoPQCMTATRSKN7hSOcaQTFkDkc1gDeDQkYh1YmIHOMUmbfdQD41XboYzWkK0Wb8Zo8p2D9FaT8fqZGpXspvFoa/5jKx6eJi1ktumov2QmzC4Ds7pnEq5Dlppo77KqzS6se7ArKhqDx9Lqh/7DsS6f8x6dqgatVAbDxs6tWK3q+2QRI7DDUiGDfV3DddQf9VAtthxDYTVDMGgCv+pMAqYYAcyMwIjgCxkSS1GQC09YDvniAirgAiSEFxHoJYClx4VN3EXBSBwJBBzYJhlKhBt9mfYEqb0USBQsARooAhhsAZ60AvdkFqf2w7ZwLDa8AxZgzXMsIjNcA0NuzcnJpXWOYt+5w7kRivY4A0z9LLjlFkTeHe/mW7YlqK1mbMmiau8i1knS6pHNJU2SrQ7uozQm4I1Or1UCZ1SqQ4pBjjYK5XnoA7ooA7rMIuzSKTwkG77gA+lJa2Ho2JHdKMyCLblZrtmWw3TUL/1a7aQSL/2C6HUAA3JoAuuYAqk8Amb8AhVcAdHwAFhNC3LAgMWRTrdMlxpxC3zKTtwNKf/egZHBoKY6oFnmqAfZppcjAsv/6FG1CJSLXUHQ9AHibAM4LANzAGSgAMO2nAQx8CHXfMpq/tO9dC9bveKC5iz4xa2ksO0uru7H7qa5jtjHEirgPeawhiT50uUUFajOuq+77YqKNY40UmcNAqdYAydPvq91nu9sAh5EBi+EEiLP0uc7gu/lmqp8zvHdFx/9is3KjQd9puR0cAMvwALpiAKpHYJmTAJg9BSKNCNMQAF0SIEgEAIMCAgzDIH7HkEtmdRauQf/IEIB1IELxBnnOyFEwdHbrSmtkMfdNot6fEfgWAFgqDCRdAHjhANFAod83CCk/MMvaAMxRBXivILOnwN//i0OD78f0Fsm0ZGxO1QQyJIs8PLgLspvLzoqi2KbUiplE72f8v4DeHgDd3czatCtF8MxtcblRvrw9dbnV0bxii2DgM4gP+nnPGMDshYDt2sozqKZPMrtnRctmPrddhAtmdLx/ZrttNx0AhNDQfxDMlADLjgCm/LNJzQCZjACHMbA2HkAmEWLYyMLEUwuUWwexMnB//2b/HILUYgXPxpp7aTn7ajCXIgcVYACLGDLYycXAbSB/B5BJVADRSKHbc8utpgDK/QCY1ACldDDLwgKcawurcclW+HgCkaD41HK4aDTpUFbr2oY9NGWa0qbXkHD6EobWJNz9Ebvc971stIvf9UOc7ojL3n8KvonLRJK5Vwt7G6WonlUJz3XNX8XMeAHdh0k7/zS7aGTbaAqscRSjfUsL+JrdA12NC7EMCcAAmN0AmcQAmP4Alh4JcqUAIm0AEm4AIwoAImoALl2QPnWAQwoB4wcCBjuh+1x6X/IQR8pkeIaQVHYFFqaXvPIiBpVMLU0jpyYAMscHqJcAyf27DgwA2pFQ2noAiO8AmnQApV0wu3AAyLCA3b8G7dG755l6LvAMe08g1oZ5vC26LQhlk3GYvvMJVq3dferKM86sU0utZUCdfVC9fcy85iLM/iCw9EKrTnQODjoKO4ErZiK7+C3eAO3uAJjdB3vL8ULjf/0JC6vhALvgDRpjAKn5AJmfAKqIAKsoAKQ0ACgOACJSACKpACHTACHVCFGE2WrN0DMNADOO4CYiALkTC4soM6jCw7XZo8tZMe4pIeVtCNDcctXlhScgQCJ6ACUHAIpwAN2gArDZsd0fAJjzAIjtAJiWDd4Gd+biMN+Od2n7ib+yC6SHZk6rAPXa1tGThtSFnF0MvN843P+Oyr03tiUiZlcV29Udnf5UCk5RBl7XDo6mydgOOcxZnPcUwrDz7plE7QkJi/E37HEd7Y0hAN0oCZhNpXxjAcseAKqlAabttAqHAKqCAbwrAKd3ACGAADHSACY6nRKp4CQtDiKKDRNV4E/ynwAuZ5cZrwH5GgLNGSLLbTA6gHBYiLlsRFAvyml1DwUYEwOv8xBDagRkcgCJiQCsUQDZvpmc9QDMLgCYwwCIpQCqvACadQkARREDu8N8vMqchLTz00kuNUWeSUpNm7sQB/ODLErEfKpOPkYkx2iTSUbMCZvkeUYoxDlVgsg3FsqQkeb0eW4I+z8Rzf8ZTz8YY1KwFtWJ6pDWTrmdZx2CX/mWq7mQcdDc7xDB2EDI9C6rEAC66Q86ZeGjqv87Xw80AXdFLjIH5gUBqNAiUwrioARzBw2lXowOXpwIHQAy/g7PIoBG4ECtKiLLIDBWTmcHJQp61sewPyHxtV9vRhBf/kOgc9sKYGIhGfsAzUUBDKYAuosAqMQAiHMAlxmAmf4Fa83EzR4dz08A5JrLxi14nImrQbK5L4Lq0ID/kI/6wOH/m7ir03aqkMDti2a7tehx2dH9Ch3/kfLysb//GoTzklD6WGvfKbOe6v/9gwb40QaUI1zxs3r/OnvvtOo2Cs0POv0PM5XwtQQwtBVwvhsQqGEK6fpwIuQAIq0AMqIC3voQIj4MhcWtpgNEZm+gKkdwQxoKWtvFyabMFkplGAIC7EAiD7MS0HUjvtSC3/4UZ61AmzMAzAYO65IF0tJQmYQNEA4agUpVO9lB1jBg1aM2ne3r2T14+fv3743qnDqO7/Hrx1HT3Guxfy3rt67tq9O5mSJMp79vbZs1dP5sx5NW2C+5aTG7dsPbNhw1ZN6FCiRY0erXZNaVGl14A+xeZU2zaqVa1W1XZN21auXbtaA2uN2rRoCp8xS4bM2C9fumLFuhULliu6qlzNpZsXb6tUff32ZdUqr+BXr+gWtvWKVuJXs2Y9akKkhQ0YPVyMcAFDxRwoLlwIuTAihpAic4q4UAEDhpAeRzhDifEiEJQjRU4XGSImUKRAYo7ImSNGzJw5Q3r0CISoNBTkUKDM7lGEdKA5hCqVQoUqVy5lwip5EuQJFCNDhh5tGkRJmDJnzJotbFZN3b9+9f3Ji3fx3H53/+jOlVNnnf7UcafAekhqJ6Z22pkpwQXbwWicb3aicJuomkJqqGmmydCoa4TaMEQOqxmxww+baiossFBUsUWxqJEmmrIUagYtZIIJ5he2dHHrLbzyAjLIH4PMi5W/BEOyFcFcUbKwwxKjpRVWZlkFFUMy0USJIRCBIbRAikhhBCHkKAIGKFQwAYbMjIACBkCKiCGGz4qAoogXemAtBs0uUAE5RDjrQQwoqoMCkDmskAMK4Ir40wjTbCsikC8ZDYQQSTQp5RNZqqxEEkTikOSQO0BZpZJHNMGkFFaOeQYaaaRhyBt34sGnn3jiKRBCjNpxh8CUTFpQHQjbOYfCnXxCiv/DEkMksVllmwVxLGqqGYvZDjfUEFoMhZq222rAooaaF1/c8NVXFVrIRmNy9KWtt96FVy5Y5h0SSClZKaywVl7ZtzBY8nWFXyXvZaXggu/d915996WlYVrwXeUREJRQAlHQKMhAOiE8iyEFGIpAIQUhOlbNzSKssGI0IaAgjTUhRu6hhRdIc06OPo4g5NA5AhliDjLFMKKIN+uUg7QiIrGCZTmSY0QSTJ6ehJE7xAhDEEIIYUQYWe7wRBZDrtCDE2q26qabb+apB6aY6qFnQQm/edsbuXn6KSiiRMT71bzx5rvvvsMF3BqilnKWRMFfBDzcaRQX0Vwam4E8rXWDabf/rR7fdeUtveaaty4imfRLSilTMbj0wBA+LN98CTb9YIJXf8WWhhtDZRAiNtiAgx46hqKEEkwwAbUUUhtBBRQ4yAA1IdSEIQY6fUt0jiOEmFnPOoWwojRQJBE06ehfds4KI6wgTVA5CIFTaTo1AUUTVGRhZAn5jwhUE0JQ2Z4QKK72gQw6/oCFNroxlaw45UMhMpfeEJhABjKwbw2UxgIVKEEJRrBxE9yQ4qTBuAs67nGQQ0takHEjdvHIhDyK17s61zlX2CVISeLLX2Q4w9L9xXR+aV0OWzcwJdGiF6yokh80MAEWpIADIwgTaVQgBwqUYA4bG17zYIAC4S0vBnWC/0IkrqabIySNZUXowQtGA4U4IKIHS+DZCwZFppM5Snxi0EQgAMEbKyCiTtkLRChAcTVBDGEIdwIjITwhSDueTw422IIiTvEKYjzjGcgIIeQilwwQSlKS6MJkJl2lNwhOI4KfhGAoO6lAc2VwcZ7EJAhthCMcsaVy7WKlMSano3ad8BYohMUtdBkXXdKLXp8bnQxPMUxinsIUpiimX4p5ihkCRoc65KG+HEOlSjRhAxagwAgyQIFs2qZ5RlCNEERWptWggAQtwBNpXKAnQkTCBUfYHyLsKJ2YuSBSYkCEIMLQA+cQIhAoA6Mc/mQo+wlUCIgIRaKOEIhLMaIPgpCDHP+0uLPqXI06iJBjIORwCFDMohfLYEZIQwq5TLbKkZqERjReJSOWstSBIeJg4sLlIpoirlrnQleNkpGMY6xLR67k0St18Upf0NIXwTCGWnaqlrXkSBds2UVUo3qLXfhiF7iQKi5ugQut1sKrXwXrv1Q3VtXlxTCGocvAVnewwrhOdDq0hS1mEddZ5KKu23mED8JwBA5IAGMZyAAMRnCBDqRADFaAgQlGFoMR7E6MyFmeHU0Qg6KpYHqK0oQmTgMd+h1BEJLY43CKkKjsSWcOgACEFQ6LRTlYARC+8Wcf3nCHMEBBDP6kDnH6oInWJm20S2AEKjzKqmcsA6QjNUszHLn/XJSmFJMtRVcCVSoimcp0QzLKZAhH2EqiWm6Xu+SRVMW7i6FW1bxF/aksd5oMWeoIGOjlRXx5IdVejFerXMUFWPVbC7HWgqxkDRjAAsykhQVGdQN7ZsESM00Gww8LSlDjNkuwzRj4rngl8JjHVqMmFKgACsYpzfLqJAYV2FONiGhtnRDB2+f0ABGy8FQo9BcDQa3MORpFFBSSNoc9Jk04spVfGJYQHNU6r2py4C2ZNCOGJVRiFa/oxTBAuoxkiDSky8WyI5WLZYXMKJMtBbOXoeFI41K5p7IEBi3Jq4tb2vK7b76FV3cp1flGVb51nm9806xnYADjGAg580/bBYxe/9w5vvWNb1Txy9U4fzW/jeYvLPj7X34xydL8MrDAeNik1QXsrUoyXSscE5hZ4At+NWiBCzjAzQ6UQAQpkIPzTgODFNQ6NZqIxBTpVAQxmMk2UHjBC1wQ7A6DIhArW1ooOHMEONrvn4ICdtFchsU60SkUyj7CEYaQ2Sm8IQxx8O3J5iCJMLyhD30ADu8C0QdSQXkYyjCuleU9b2acJcsmPUuNmFHmP5+ZGH2mJZu5agv9avW7tYgznHXJaEgvGqt2zvOddyHfPgPj330+BjH+DNIzGyPNvuhzoeW7C0TXeaoMbzTDvTqvSY9106BmHcI27VYmEYx1pJ6FqF+BClaggv8RIHDBEFiAgm0CAgYYE6zzTJACxHYAiR9bngqSRho56SkSYHyZEEyggtSOTI2/8ScihhCJUERiSx+mE54Q+zE79UCg2T4xInzjiaRlz3lZ5J4gEBEJOQznOYII7io8WoxjLMMYO/0z4o3b7/XytONoNqp3wfoKlkf6q/+ixSxqoXla1MIWuPh86D0PetLH1RbbQX0uePHd8Y730L2ouMU1nvGNLwPQxjhzxyte6ImP/KqLvkVcvcrVywN4MAkO9fFdl8Ob6xyIqKiSIVpwAsqMAMMuSG0HLoACKnbYBFZIQQZKICfNqIADanLB7oSgghfY8U5qDIQK4GQF9B0nBoT/oN8QAgEKs79g19GRjg1bmemRpxfwp0iwH0SQhGpDtkGRBE/QBEmgDk+IhHETBE2QhcawhWEohoNwPNzLOGIQQWAwuasKK0mLNBYaq9Q5q1fwKhfMPP/Kl/0qDEcLvdIjPa5qvUSbuB48tD4TwX7rN+NyhmXohcOrMp5arz/zuD7jhV4QuavSpUQDPeEjuM6TwbKqOeSDppvjQoNpjFUQw9oBgRNoAZZ5ukhIAQpgrBEYgQ5AAc1YQxVQgQ5QgZfJjDlADY2ZrKwTAyE4lCMwgulwjoXCP0J4ATEgEwAcgg8LhCOwgergDTLJjSHwLLOTFP2xjUGEkyIgBK3xmZ1B/8Br6wNMkIXT64ViILwR5L1dyAVceMWvijOHwcIXFLAA08JbTKvP8aUfYTlJA8ZcUripar3eozjYC8LEMwYqKzNmMAZ5W0ImrLhfIDT5ekVcEDleML24apjNIysv3KFnAjUD+0KDoRLoqx0P0AA6xLASUAELS4FA6IHU6JjQcIGQoUMVyIA4yYD1o6y+CyPWIARZEAN+usNF4bs60oQjiARt4wyJIhPmEBQEDARZCIUh6Ds/6hm546fRMpq7G61IEI6k+RMxiAREkK1VEAZVJLxiIAYoJDQo7AXU+7xYXAzZmQVK00kn2cXP6YvP0Qu66MV5gbOosoUdlC+YBEIhPP+GKmtK9nKkskgLyZElNIu9aoRCXtgOKjQ9z+vGnDywmyMdtnKSg2GSwEgrwtA0HGodMRzDUgCFN6iACnAACtC+C7BLbhoBGBCDUJAFMHqBN1SBGHiTKRoZxKoTtjsZwIQCRBiNYDsOOBEDT+wMfqqNmvGN1jiCREQEIWgnzhgTUOiBj9kZ/Skf6XAOHYOCQRQDSSCERFFEK+iBIbgDVFAGeFs8lmTJYZDJ+oqqXNjGbbxJ/aLFWci846TF5PQqh/EqzqvF78IvqjK4rDJGQ3vC3uwF9yIGWaIcj/sFWWKGcIEGWBoqX4gFE3qXW/AloFQFF0orI2mmvkAmZBqmvzD/Bb84pvZsz77QT1WIi/OUNF54hWHgzVx4hDy4Ay6oAslggRPInRNIAd/JAAnIgNDgABMggecwpzq0QxVQjjjJsJfxGBeotTgpnnxUE9IQoyFQk0NxAUQAhTnoARtYAuFYgtaAE8UKjkGJAUQpk9kISTP5Is54TY05GVBAhanxGekogiO4g1XoQOMqBg6cUgLlTZlUtNQzvYbZxlrovORkMMcgTlpcTjJ1ToTbqkXLKqwqwZ+ixquUSV74BdhLM0H7zj57BnGJhnXpLjfTpRRkobpoz8FopmMy1ENF1PzsT1U4z6I6PMhZnJnShmggQmWgBBYAgWsiARdoARbIHe5T/4FIEIIRMCcS4ADbcgEJ8ETuE78OKKxaUw0OGEx29JgR6IzMsL4vkR46IY44iQEVmA1CCAMDRIRvwydCGMwxIZ8Vu0MwGi0YkJ7WqLYseg4xsAF+wh4YEwRQwCjOiIEhmII1qIQOVAbeBAbeJFDshMLUA84t5UbZKc4wzUmwbAwvpQUctMGv+rw5OyHzGq92cdOADdgfrLgRfFNiiAaugAZkYK+jctM4FS8e6aXPWVT9TFRD1c930QWGJanFuYZtKJuyAQdwmAd6oId5GFltaIZlVIZMkAGgy53h+YwYQAFSNcB5NIHioYBhIwHjoVnCIiwjQA3UcLpa67DRhCI0yf9HOty76Lg2EjuNITgBFggDIpAFYXiDJQAFULiDcLIN9mkTgRrNHkCUJfCBGgWj47DRPiiO4UCEJSCEP4lbzhCUBJ2E9ZBJK01XdfXNgQvObXSMhjHOadq8wtW85cQvggOrrUrTXZizNdOFqrIqqaocgbXcN7W4guWFlyy8wluGjZ0R9mqvNAs5V6qlE0KhFIIXHsGREaIkV+EQpcAGkA3Z2h3Zb2gHcNiP/VCHmKCHCZEGSHKGVMCBGbABEpiA7eM+OMwAOswADBgZE+AADBisC6BeDqCiHigBV0Wi8btHwSyCvVyNEoAB39EME0CBDtifIXCBObAjIci2MBjWMGj/AVRwBqkhhDvog9EgHzHwhHnCjWt9zSFgtzeQhJ2pE94KA4c6hDhIlCGIg56JW3m6o2IVhFXIhQI9V2Aoht5MPWts19P7W+N0GBLmUua0Vy/Vr4SzhVsAToPTwWLsvey8StL9qdiTSSD8t5dspGUQhUuAhVQojFT4sz4zBmLIkZ9ipSVmpRG6pAgSCmzghm4g2ZqQCbWxB2G5YrVhkJmQiWEhlpNwh3d4iXr4hm0gkWhQBjyYgSaAAhTwKzdEovS9w3tEgQi4gBe4gOnFAA4gAe4jgRGQgJylADCJwzJxAfU1nvUDxPj71RJLDdjwRJ6Z0SVABE+4g8l4A0+QBCUI/4M70ITleRnWbBN+egF4OoI+0Jop0Kiroz85eIPxEIQjiIPjmIM4qI7dyDVA5DtY3oRZEIZciDICjcmZ3A4PDuHgTM5lJtOvcsEV/lNdctxd0sFDE6+krOFsruEdjj1iMK5fOIYiLAb+uoV/+84R4liSgt1qmF0qLtktXht43od53od+oI97pud81ud5tocFyYlxGAe5kRuggJFnAIZTyAMdGDoKiIBscsPT6AAKQN9AJjHqVYFsklVT/eM3FL8zEY3V6LUpEmlCAAQ5SJMiyNlRxb4Y6IEUuBM/soEwqIEw6AMisAFZAIVD4OQN07EisJ+X4SfpgQJZcAZUUALfeP8OzpCtPmAEUIiDYc2NOQgD7nFRGLCC14gBGpiEqxVmAv03vjXmZN5SLCTTWtwv/0phOZOzNyO9XJg4KKQzOutNgHtTN22lgC0qpNquX1gqZPAFY4CGsbCGj+UGbwAHepAJk1VsxIZnlyhjL8ZimJjnfuBntfHi/cgJb6AQqICKbbgG8TwGWBgFS3iEH8CdEWDoDsuwFOBeEiABK9hUOVABCRiBFvBj8zui7cVe82PpQJyNwBJJz5gDPdGTvXyO5UkOCbREG3ABQZAtTvaEh2KE1biilFEU6bCBQFjIQBCGJF0ClOExQqAaJegDWUAFXP6wFyvWLGJR+VsOIViCGhj/BAwe5mHASplk1/xuYTmDV7M+6+UUPjRF0zaL3NYrqspli8tNcB1h4mBwYpKyIHHRhmmgEWmohm6wCZNNG8eu7Mj2cMtWbCtmG7c5h2+QG5ww8do1ltoF2avYhqywBmgAhlSwBEdIhDwYhBOQgAhwgAVwOhUYHrvcS9w2P+BRAQzYVHOynzs8njhpAU1ABFAVgqvzUE1wgeQghJFBgcV0VgUEBWWQnmBL5fsRBB94A0Z4g6zLOo3xI2bLDSETBJaZA5EElCOQhFD4E9NwsVB46kOIwOl5I6GmZUNABXI9hpYkhpac0t1MxSxEKyDxi7wYVCChNHoZcAI/IcsZqqCC/6XWTef3gGKggJtzGON76PB4buzI1ufI9uKZoAcU94Zv6AZjsYqdcPFbf3Gv4AqtUAqwgAZm8AVXMAVISARHeIRB8AEO4IALUN4/RoEJiIAUQAHbtoDj4YAWsMTnaAEUaEg6BMTU0B2z2+3pIdXl+RgpUgFFXA0XOKz0kwVEiIBpb40wssQXsMTFIo1wOw5tEw5LjPOVCRrmYI6r3j9NQJSIGgIi6IM4cO6ejgGfKZQ5WIL53s1hEEFi0NuZjDIo/K9aYM/+FMpUIBJ6iRcTqpwmRgYID3VsyAZ3tokMT5v6kHmZv2fK3ueR0I8HKXETF2jN9omft3WqmPWgf3Gr6P8KXKcKXfcKsaBwZvgFVWAFU7AESsgEUzkDErCA0EiBPeYAC/DjMEEBr3ftDouBQeoBU8Xe3xmT0GiBnt3jpLGAwPoYaV+/O0zN1OiTKZK1BfCMFmiByrD3P8ITXqO2QZHWMLABbDeOl5GDgG+TGEDl16SObHuDIfABItCEMNCoO9ENQBACI5CDO6gEVBCGlYTCdB2GOhO5Xujv5fQvIvGLipV9Rm3U1n1dvWHnbZhisxnZmmibLt7wD4eJeniQYVEHgJaQnpebn2f+n6ibY2n+ugEK2e0JzsaKo096pVf6sKCGaHiGZAAGXVCFVCgFTsgE/EnS85ui43HQDO0BCzj/mePhvgvwjCHgPttONdRODT45OgoY1VkFCAwxUqgYAWOEioRWiqSAgQhGDBVCYAhhCLEhDChFoKjoIcRIkYVCJvaAAiXQkSFDwoQpUhFRJBUn58iRU3LOnCJFeoghxIjQG0aarCCSY/KFFZBicN4xhEpWLmG5bOXK1SsXrlq8ctGaassWrrC4cu2CFess2rS6dPn6FQxZsmbNoEmbRu3aNWzbtnXrBu7vvHng2g2m165dvcT0DB9u3E7duXHfJlP25o0b5svesnHu7JkzNtDYRpMeLRovarzVqqVGvTq1tdiyZ8umZjtaNGjPnjHrnewYMWC6YNVyZZzVqlVPZUk6/4GCQwQhhDi04GBBkyYJKFxY0M5BAgfpJLY/V9GhYYcLI4oAGsFhxAUXEwuiGGHF6MgeMeQICQRlIgwbFQGDC0U8VIQYRqkQCCFGQWFERUMUcYQciBAyhCCSLDEEFDglpVMRc7BU4RwmIYIdIoIsIccRJgkohhAmQSHGEWGAgokmT0lVlTBUUdULkGDhsssua/1iDDJJykVXXdXoxc034AjWDj2JWWmlPfY41tg5XZ7zjWWXdbbaaqZlU1ppnoXm2TafZbMXmp2hOWdr11hjGzXWVJNnbHhKkxs0zTCTDKHGBPOLL7rcEgssxqnyqCmpqJIKpZXOQssryKGCyiqybP/CwgnQleCQCydscIEK8qVgwQYkcHCBdRxY4aoFHLwagQsZlOACBXJEYhAKHQihiRwUZBBRBioUEQkhQqQgoAtDvBAICjWJwWEkUHhyRAs9lIiIFSaFa1KLVhCCiBhLEJJTiXMstNQRc0gShhVzAAKFHJqgu8QRcQRSE4JGocuhTiUK8oYSdVQiizAN5yLLLBHP0sosvQxDjDHMRGONNt3MU0+VIV9pTz0kZ3kyyu18Oc444kgmWmlkklbmaHhhk1dqaX62F89tnqkXz0D3vI3ONV+z2jTTSCMNNIE2QygyhiaKlqOPWm0K1lmTQkrWWVda6aavZIpccqh0YkgLzsH/kMIF27nw3ggUpNADB6FKIMEFd3fXdncjlJBCBvIhhEIKKMBQEBSEFFRCsskGgkgKKYxAyCouuACFIIQsYYUVKokR4BFHvIBIICUdEUOMnPdghRAvHKFiHAmKoZMc/sUxhCSy9FE7IgiiO0eLwDMbErglDXGEGD3ohG+NfWjiCSiZYHII9Yow4sgnwyyzDDPQXBNYYPTMIz75i1U5vmDe9LV+X9x05j5mba6JGTdm9pwXaUEHPSf/Zv6sjTZacyelLa1pTktGkoIRDF8wUBdpOYsrGnUcV1itgqnomim2hsGtcQ1rp/jgB1khQrKh4hEgAAELYCAHMVAgAggZUAYy/yCCDtjqBCS4IawsoEMUSMACE+BACSjQgV1xZAQ96EGqLmACE8TwIBfIAESKMILCuUATPXABIVBBCEL0QRAssAEoENGCPjAiDH2wEIPGVaHSvWAIkdAEjcLgop4ALw596CIiENEiIQxhDmJAhI1AEQh9QcEKgZhdII6nkZ0IwSM06UNT+nCIpQgiDnBYQyJO4YxnLK0afunGN/qyF25so35p4t/QUlnKUtKPlKN0pSr3og2eAXCWPSuNaqqRtKUxzWlPSxIyFHioRCVqLcaMxVrSAotGLdMVrWBFK5wpwq9Rs2sdzKAGT5E1EJYiFZlKBStQQQkasIAFHCBBDEpQAv8JqAAF9bnAEDMAK1qR4AI6vIA9LYCCIcSNAk9UwRxi4B4OqECdMViiBIQQCRiYoAQ6KcgI3ElHYWDneYQ4AShk0QMbSAIRS1iC8zwxB36dxArdOsIh/UgjKAzBCrObkRgEUSI+DqEHR8Ci7jwhCUIIEqX1YhBNjCIGzkUiEDjpYuZkmtQ5COIRpXiGAZeWtKSxpk45sypWccY/nNnSlrSsJQDt1KddFtCXgoqLXOQCl2AaKhjGeOtbFeiWQyGKgW1BlDHXcota1EJsfh0hK76GtVGMgoNbIywpEDsKWjCWFhGbCpCEMQtZPEIDE9iOrS4QOfh0IIYZaKGx8PmeV9H/0AIYQAEF3vNEE2CAIhkYgeCMpYIUnAcGMAgoDFCgAkIwNCEjCIQsEAEKUGhCFgzrAwvkeDxBHEwTgujDRzcUOpvehyb+wdccOFSix8mBEFA4nRBi+oY3SOIOS2BER1OkiUOe6z5HqC4gIgEIQhzhXHM4V0rvK4hBoOIYzNgNVJnES17axTa0kY1VAwjW1oA1gLWhBi8N2DTfEApqwLzwhSvMDLlUGK4ehitdgQGMX9T1rom6hViywtdXOLMVLh4hNVNxChmD8IM0/uDEIkaxVryiKraQxSQ0wCr3RBQFmmWbPIVoAhEkOYbtpOF3TFAQEkjAQBQQSEEuMKoRJEsI/xKRT0RSIFCJpOBvMRiIS3qwhDDY4A6geMMXjUII5lZBEoIIw0dV8l45gIKpKEmQjIoAVH0Jt0Qg+m5xKySLRBrVCjzxo0mEsBDaRSISc8AOgxAxh6KYSxCMQAUwktGb3gRYwkxq2oCXhqcDP3iquDF1hS0MzA9juNZwQWCsRU0oUg8qGUiK2oeNIWIRA4kXvCDSLngRlq98hbFf6euK/cpiV7zimYCdJjVH6FixiXAWUREGJUCggQ1klgNGpoBuuUwBvHUgPa+N2wjS0wESXJEEpyVBgYKFAnlyuQQqMIHlYBCIipQAtvE+SG0rYlsXwMCm0eoBClJS6TwGIgxH6P9DGMSAZ34dASaPC4QgljKjEBHij6Ewyhz6rJ+KECIUsih5JE6HLwkZYUbeLWRIxBAJ0j2OdBQnhFG3yIhV5IIYx9jeJndj6qUvHcCC6jUCk2Sot474FyMWcbDfCkyoHUPrx0DG18F+jLGTPdZP182ooT5rYxCj7cMGUi+Onexd4ILZtqAFX/MuNmjnvRawkHa1YQzOET5TbLNYxeGVY1wTgsA6JOjAwds9gorAJ4bt7uwS5XmBCMwbCs/BgAmggIEUvEoFeYNBCUzQWyFY3jxlJqhuh3genYQ3I0LYzgtacIQeDBJBoGCpGMRQyBn5saZzQEkh74sI7J7Eu0IARSj/rBCDjLBuI/fR9EaSL2krrNco8RqkUdF4fPxmOkOrsIXRl+GM9W9v1LF+K4nrqgu6p3iveUU2kaw+7Lbzn+1a17qt3VqFjV2spV33LMkziJr7VRiwud2wVR2iIBuK1R1f3cItLJPfNZNxiI0riJCLrcK1vVhgEZ43vcKmoEJGKQIInAALXJY/ndMRFAFq6QR8wJM6sU27FU4KSEB6XAAFGEsGMNF7LA4MtFsGRAAUpYAJPFG7Mc566JZO2JaZUQTDSYQV3NYVlURJuAROzAS5tMh7CZ8f1QtNfJdJ2EQMuERGlET1GUF3DZUcgAR7lIiDnOEWdch9bRGDnAsf9oEn/8iCLRibxVjMMBSJojyQWUiQKkSQX+WditXCBIYFL8CdIPaCiDkgxrgVXN1aAIqdho1aWi2JAUad1LFdcAADMcRfifmCBbbiKywTLBqHcUiQLDpTjEmKLDZKLagYLVjCIxhCHTRBDtjABjiAA5yKetgKB7xAQHFAEfrTDzZhvElZREnACMTbc1gOBryWv5UA5xyLD7bbBcCA5V0eCgzI5JXcruQWQsiHbU3fgDxLJPTAbRWBJkSCGPiHngGPS8WUGZVI8JFLiUDBCxQB6sTAS2kEISAI7WlEDEBaSSxFTdREHimfhdjXHnoaxNgCJELiI8JiLDJTBIEkSL5CLdxd3/9V4FrgX/6p4lxpogL9mq3lGlwMigASCjRYQzTgWrBBoC+MGJHkVSvuFQbWotU80FkYyZHEBarZBcfUEjVEgzKMwQM8AAMswAJMwAZMwARIwALczQuggKsoCGqpBz7FmwqgHupBY320k2Z9jnoADgWsRxFAXgQokRJ1gLEwTuDkVrAw3OQNxGwxnJcFSIS4mYsYAenwREq8QOIMpE6tyECOCyKEgia4QEn8RxHIAecU0kgsD4iESFFoRIucRIUUVSDsIemcCx4hAiM8AirMggUyigWSZEjWYi6CJF/BYt8N5Uoa4i7YlXCS2NRpoodFzdaRItTgWpJMgzZMg68FUzD/AENcrWIDORBaYKdaEGdNNk005EktsY9fgAP7yBIA3ckwfMIffEAFTIADJIADcMAEfOUCOMACRISr1JR7GJmtpCVsFSE5wtM1HoQ7ccAcQNzlFIELPNFB2FY4doAJtBsSQl59dEB9HMREdAAMmNtmwgDrwMARvIEPaIIkhIscYAiNqIQgEMtSuFzG/UtFMFJlLmS8QIgRfIhJKM8g0UgR0JcnwNHjfBeDPM4W4dfOBYIkMIIkEYIkeAIjKAIpFIkvxORLCpOVKpB0PgoExUJuMtMyncUt6JWirIVwMpD+YQzGAFvWfZhbAduh6MIvbIw1+NoCKdBdIYqVJglayUXS/1zDLPWFlIDPX/zFJ3XDVwWQnaBGLd1JNDwDMNjCKWTCFYjbAiChQEUAeGDAC77Aq6BArUCeA1CAeZxHehQcgaJAgrwHBRDIdoRLQRCEvxWhQeTl30QOToxH4QhUQygoZtqeJsyBC0iCMMjCHXhC8oREyTkmFHRUINQLIkBXgywPoGUfvlQIIMQIIOREjDwOPo4LHkJBfHUIswhSPlIckQrCIaArc6WIISSCK8DFXISivD7NchIKAyGlb+aVmLKFiZmpnbrkS7rkleapMSBKxhiDqD3NqCHDhjUlXvAFoA6qYPxFKNHPzeTSayQYauyFoXbDeUaDMxBDB5ZCJhgCCP905QIkGQYgxHvckAuQQHXc0DvZVpFtnj+907/gkzt1QFqqwLtd4w/CkwkUARMZhLNMURHIwhCg00hEToDAwPHQ40jEAAvcgSQ4g+7cgRDoHo2Ejte6CxiGS/LEiPC1yCCZhFFFghx0YcBEgiQEH/J05n0sy8tpGtB1Vx6V3Hz94dDpixhoQidwgi7Aq1nRa641AycWyi8UCbKJxS7AHf7dqV2p4pQOrOUO7IUhIDQwQyyIwi/EgirEAjNwbGAQKiyF1QDZxVStLjWsLpm8xutewzYcTVXFhjboJDQsAzC4gimMwic8giLYwHwuAAZIwARYwRFIwA/aili+zX6+6g7/zuUIYMATcQBt7VwEwE1EicGCxtsTHQuXoUoH5MpsQV7hDEELjEeBrE0aboRNUITOicEdaAEoOAMj+EALwAB9bRpKtUiKug7yLpJLMI+mBQIorJC9AI9JzMHOeZdQjSHa5u2/YFqmlVx3dcpT6JQmgIIkcAIDIUNaXdjlWun8LS6RWGLcCeKwASyJWa50YmlyhmJTsoZerA/EzimcLsMxuEUzaAM2vO7rJo1trC4RF7FUEZBTDtBdnCeeRGWj6vAw1IKMKccqVIIPGCOmOsBlPYcE3KW5ndML4JOFniU+AY6TaVZ9IMQURVRExZB6wFtEuADrKCHjdFbiHMEJnEAL/3CI0yrLiShBSpyExjGCIeRBJWwBC7RAEdxZKIAC8igw53BO6ACMUZhLTbgRKAhBDAICi8SgzrlUIQlf8B1ShegEJ0eCMgjDusJEHr2RJGjC0CmDLBByIujClRaTogwlmIapvp5wL+zCAz7gwMpkhS2JVLEGxw5qoArqoIaSoZqnNQTKf32nNRzNDwOxLhmxNLTu6qZaXUxDNPwJoOgGbwxKwS6u33GbpmwKBq+BBdRnAlTqummHBcBKgXKAQD1R0OqKCazbsfCWEFFArVTHFeHTRLzWQKSAEGioFaiAHLiAlMWARmjCC/QAC7iAHERfvt2WLGgC0IVC8vjAFFTBDv+0gA0sksWlSI1cV4foEfJoRE1AgduuqOyEy8dl12Yun/DxnFGsLSh31yApgyZ0EdAVqR4CnScoAygIgiH8gSowkDDlsgXuwlC2YjLpq5kS568l7FzUhe3yhTKDj1iLNWV8A2ZkQyulNSx9FcfYzDW/LjcTsTeb2tPRKV7VpnFIyqNQiinYWCqgwimUwilsiiyswhYIWT1HQDxHQGp9xwTckA7ZCnz4kw9e2REWLwU42qjC7NroEwd0AEMIUXdpxEGI2cBBxIzYFk/ZABmJVID0AM++siAcASgUgQ20GSN42obohBj0QRyEXBxQSH2xSETGoPtKwhuBwhYpcIcYVfD/bdoKdZccZKsRiAEgLMR8NTAh3EHmpCaDoOYe+gQX9YEjmELlRo1dSXW+3pWeGrNT+ilYS6xYByo4gIlliGc3cAP7lHXFQqx4kuf9VNVo7IUA9Unr9tLm2qSw3TUiNpMGRpMsUoo2bU2NCfYHrYIhbMAJ3A2Xzad7UoAQjEAP5Y0F6KUPRsA2/uAPioAEyFMGLGNYSkALXOY5VUfkmB6qSMThXGMMXI4mFEEJyEERCKsgKAEoOFpGzMFt3ReHEMIUDIGRO2lHKWgMNIgZDQGLkGHXxotLuW9NhIIn5JGDrMvansR19TRNBJX16RwhyEIkvMEd9IEk4ISvKPdFzpkgr4BcH1DCJfAroZDY1MQCL7dwMkQDAI2nMic6oea3K7USaWRDmMTPXqC1fmeGfasPfue3Wa8SnNDuxR4NATUNhyWQXJ3YXmXgl6KFBsYihEO4K1QKN31QYZ3CKPgBC4DABvhQBHyle76zdoi4Dj1eCqRW3ujzDzI23mQAD7kACoQKFGwo8wLOeXxWRPmlbiWEQdIl5dxBC0yBxRWIgp6EmuELIgzBG2xwRQcCIBhkQAAAIfkEAGQAAAAsAAAAAEABAAGH6L6g3LCR2qyM1KqO1aaFz6SHyqOHyKCDyp1+zJdwxJp8wJl9v5R1upd9upR4uZJ2upFxtJB2vIxnt4xsto1ttYlos41vs4lps4dns4dksItvsIhpsIZmsIViq4tyq4dtq4VpsoNgr4NiroNjrYJgsIFcs3xLq4Nkq4Fhq4Feq35dp4NppoBmp4Bfp35dqHxbpX1fpXpcpntYpXhXooFoon5joX1ioXtioXtdoXpfoHheoXlYoXdWnH1knHpgnHlenHhdmXhfnHdcmXdconVTn3VXnnVYnXVZm3Vdm3RXmnVdmnRdmnVZmXRYn3FOnHFQm3Jbm3BPmnFbmnJUmm5OmXJhmXBamXFTmW5NmHVbmHVYl3JamHNYl3JWmG9Zl29Tl25Xl2xMlXRblnJZlXNXlXFYlXJVlHFVlXBYlHBWk29XlG9VlG9Tlm1WlG5XlW1Uk25TlW1OlWxQlWlNlGlJkXFZkW9VkW5UkW1TkGxTkGpTkGpMjG5XjGtSjGpRjWlQiWhQlGVEkGVFjmRFjGZPjGJDiWVOiGVJiGFFiF0+hGRPhWNIhGBIg15JhF5BgGBJe2BOgF1EfFxGhFk7fllBfVpCfFc/elhCdVdEeFY9elM3dVI6clI9clE4dU41cE43c0sydUUla1A+a0w4bEo0Zko2aUcwZEUxYUUyW0U1ZUAnX0ArXT8sXEAuWz0qWT8tWT0qVD4uXDggVjklVTooVTckUjkqUjgkUTYkUTMfTjgoTjUkTTIjTTIeSTUnSDMkRzIjRzEhTi4ZSi4cRi8eRisZQi4fQioaPSseRCYSPSUVOSUXNCQZOSAQOBsJMB4SLxgJKRsQJhcMIxUKIxMHGxMJIQ8EGg8FFw4FEw0FGwgAFQgBEgkCEQQADQgCDAUBDAEABwcCBwYBBQYAAwYABwUBBAUAAgUACAQABQQABAQCBAQAAwQAAgQABwMABAMAAwIAAgMAAQIAAAIACAAABgAABQAABAAAAwAAAQEAAgABAQAAAAEDAAEAAAACAAAACP8Ar2C5csXICQUKYhQpAqNIFCx0ruyJE2PHHjpFdjzZccURmzVfnhCRkSKFDBkqVGTI0AEDiRcdOqQgQSKlihccbJzqNayYMm3QmuXK1QtXrFlZkjghMsMFDx5Poj7dwSPJQh4xYrjI2gJF1xQ7TpJM8aJkSRdozZp0UTaFCBVnX7hAMaLuCBF48XLAIGIECREdQnTIUCFEhhAlSsiYQSQOKFWzeikrxovWrMu0aMWCxcoVLFiuXF12hQqVq8y0as06NWqUqdemTq0KzYqVqFKwbtnSBU2bb23XrFGbNk3as2fLkBmLlSqVr27dUH04cMBAAQTYsVMvQN16ge8DCBD/GEB+gAAB5dObRz/gO/gCBhr0cOW7WSlMkRwd2pKFRoQPPfxwCCWZjAKLM9pAB0432ljjIDTUCHdFEVPsYEQSDxTQQhI7LFTEE3HsgcUUOEw4RQw80BHHDh6tIccTM7wgY0ovkJDBWzWpIEIKHfxFggwvyHDCCZXkwksxzWhDDTTC5ILLLrYM80cMQY71Ag8ZzbDDlk9lhVZWMaDgQgstpIDWXCOYadITUfAAZJUl8UBEVDKIkEEKKNBlV116cSACBnz5GVMHFWRQQgiIHfoCEVTs8Vhkyhyzy2WYoQbLZZ9RSktoqKU2yyqvnSKqbK6cwgospSgyCi230GLLMcwg/4MMM7TGagwwuALjiy+2xBILMNrQ0kMDCxzwXXbIUtede9+Nlx576q2X3ncBDGBAfD2cYg1QqGAiSSWVANJDDx98UEMPZzwyym3EWKOgg9TEK+8VcVCYhBEtFKAAhXLsgMMOcQgSBw4EV0QViCEOwsUVKJFV444+0jjDDDLEtFJKLlxgQRa19HSMMso002Quu7wyTCZsycijCxNTCeYMMXQlJphieuWCDFFtGdbNc4YlVo0pzCASSTr2NQIHHOyZFwko7BXoShlIIAFiiIagAhF0CJKIJrIII0wzklJaKS2wdGp2p7bgUgtpq7TdtqmdrYJp2bDE0msqvjan9958p/9SShANEFvddQgpkJ2y3XnnXrSMM05AANUasEADH4iSpDW/YAKJJJcsIoYY5NJAQxCKYDJKKa80sw040wwnTetLxoGF7FdMkQQFA3BwbxJTTBFHiLxfmEQSPKSQxB5JTJIEDi6kNBMJg3YgAk01USz9SmZlsMEKqwhTTDG9QNJKLcIUFcswquBAcfM7epkyWjKLCT+ZeabQAlU7l3mmC2r9BZdIJKgAxOqSNKXhBQU6ApQIOHAjHhkqMYbJgAoWkwhQdO1rytjFLW4hNtTMolO1OFstbGGLWoDGFXFbxSlQ6IpWeIYVZHvFK5ojChpi4oY3hAQOIcFDHlYhAhFwQLH/EKCvwiEEWQhQluKaFS30nOeJ0CIP5L5zgAUswAOAKMa2npEKHl7iEoCoA+g+QIMeqKERnSjFKXYBIeK4sXW0w8IXjDAFGBhAAUbYQRJ+FweCJOEIV8gKVWSgsz3I4QRmiQlgKlCoHumIJWZpiwwCuAENZMJ7INtFL3pBFCjRQhhdoEpbOqACPeVpTyNAYClPWb+ZuCUvzzOTX57Xo7e4wE4Y6JGeCJi0Pi0QA34CDMQQJQGoFUYFMxiEKbpmwlvwAhe3qEUtbqG2aeqGhNjMpjYtBRpWoAIWrbgUaD74mVaI4pzoFIXmethDRfCBD+LyQAMeIETDHUABCzBi4bSz/yxmicdZUHwi5AIQUMgRgIpVNEAdiEGNBgVDFJKQRCYkwQcxBIEGHliBD/5giU6MAhWxeMY1plENakiDGkXo4x4mUog5PGAAMDBRH78Qhz9apSJE2MGZWrAHFACGJRYjDCThEhOykAV6ZWEABSxwCO8lQxnD4MUwNsmLyiTjEDhw018qwEsCHq0ueVIlXUqpglu6hSYzkV5ZzeSCvwQTA4xsyY14iTRgAgqYesHLX6DG1wiW4GqIMEUuSCEJWEQVF4hNLDTTps3G4iKbmfmMK1YRznLSIhef+Uy31HlDdfJQEZAALQ/fyYcfEssBDmCA4RTAAAZY0Yr6PJwBjNWsf/+OJ6ACGCjkBPpE9xggAAeoQjB80w1oxOKGEzVEFnywAgtogAVZMEQmOIEJURgjQtcYaR8FQYcohOFCKCgAAywkkCQIwZBX0MEXWuCCkZBlBBS4Ag9+Kj1FAnV6M5meCv4ymBKkAAJLHYIsivHUqHLSSFY1xb/aygGuLjCYfkIlApsXVujVsiR5EUFaxtQBpE2PJhlocI/qCkyk7cVPNSEB0jJAk8CEgAQlWAkjWYxMS5hCGKMARCloMYxdIJaaP25sY3XhY1zowhatIhs4W4EaXFAqs6JgZw7dSVoqv7MOH5gcsfSJWtS+9rVHTKIS3WPb2wqUoAU9z27TcwA+FCP/QeDQBjLUuQlKHIINKwCBBjLaAzEoQhI3TEUzrJFdOkwha3GISBJgwIACnAAHSbiCIK5wCEfM8URPGUkFMDCBGISBkYXiq1pS4LwevRKtAN7ejZ/Ki00OgyjPfDUQYOCXC1xALyVGGipTSRe68A+oJODfjuAywTypGC/XywAGXEmCowGK13YRAQLdKj0SkJrYiIEeoq5mCVXkgsDNKMYufLzBcrtKF0ce8rh18aQjQzOy4SSnamZxi3JqTrTt5EMdxEhafQ8rnwAv3ALo2eUvg9lw/FRcmaG424LqdqADqNYC6qCMboBjQdBohSQiwQhH/GAFIPeAB2jgAzwsIhPV//WFNKzR3StEgQpUCBiHFACBJBTid46IgyOSkAhBRIEOYXgBYTh9ATrMJdlIBRJcfGS0UXcYBTXIxFOV0YtWb7LquxhGMvDQAgZCAAIZznCOpI0WVqrgaDHxn7VNoiU8aaRO1naTfqFXwD0ljQNNsyug7pS9HnXAvyZRARYsmAxnGF4ZxNgFL4o87luMexfofrzkH29kdpONbKcqmwdpUXVahFYRoMeht0LbTkX0oQZBfIDqVd/l1gvxy0akjna8I54C/JO3an44Qb8z2wN4eQERAMRPLr4NawyDE5z4xCEOATr/BM4GWljEJlqTCmUspHcuj0If6XABBVgkI3EYxP8gVroDQRTBBQwsVAUu8AQsHA3Zw1b60s+ONETiKQUX+BEMDkFgql+dqq3WDJnAAieQARQAATNSSjTxYTdRdrzGFk2TdnplbTIiA/ojFyXxBHTwBHhBMSngVc52AXflNB6GFysxGBbmPC+gAnSwTMKQDIV3DIk3bk9Cg7sxeZSXWBtEQkq2ZJqXGZQSVa1QUUFQBT3wToAACEgICJ8VRisARF8HAauHWgTXegZXOAcgW8zCRGmme+RRAA1QA1ywBk0gBE8YAYpQcdDhG9TwCpzwCKDHBz1AAx9AOSsABIdwCZzQGkTgXWEAEXQQiIVQBAqgOx0iCDcXByiwAzEwAhX/MAFD94gjIAgtkH8WQxMJSBM6wgEd4BX0UwEmsQNaUAvJcAw8MQxT5Wq90AyrUAMtYIAQYBM2gQJMgxcpYTR1sVZ5oSMC9BYlYTM+hWzWJj1YQwQdBih1dQGbhgEXcDQVsBcdNhjXQygstnYqIAiP8YLJ0AzEMAzohm46qFg6eDaZ5UGzUBtAeBkcFBm9gAoVNS59tm+fs2918E59wAc+8AERYAH8CET+6I9VaIUHF2ZiloVkRh4O93ADcAAgoAeMEAmZ0AmX0AfypAjHoA3bkJHboA3GcG+KoFwsEJLm0gN18AiXYApzQgVREQUsGQYsSQEMUBFWsTwdsgMoMAEz/wZqEzABYTAFHHAC0gMYOUJqmkg9ZgIDMNB1IvACU6AFpJAM4IOKUskTHyMMQIB+X5cnsqiVTKdr75dhHdBW0xOUeMJeXSc9gGJq+7USzoY0yviMusYBtgZqhTI9hBFqLDYTgqAJLkhgqGhkOlhuG5QZ2HQ2hLl5rdAKYlNus0AUqKAIdTAuNPA5lEmP+iZGNvABGrCZm9mP/whEq8d6qEUssEeQYsZECHlmA4UeBmABcBAJEGkKs2AKPXAADVAF7WIN29AN3tAN0lAKn2UIf2ADQzAEdEgDWXAIkXAST0ExMsIDL1AELaAAG8ADTiEDRfAUI7CTd/mIjNRplMg/av9yE8Qmiw34L1lxFylQFYxQDKY4DMEwlcGwDMTQDH/QNAe4lbR4QDNiF3lyAhywASbGAS3wc1cwF/IzF70UTNJYEs1mYnC1k4xUV3I5ARhwl92Jk4WiiXvpCd7mPZukWIKJGR8kmBv0YydqGdRUb7CgNqhRbkSRKnUgOisQBDZKmWJQj/JYA3m2AT7KmRrAj/wYhVL4AEVKcAaXT/vUT+RhZgy3mq2ZAz6gBvu2AtVxLT2gC9RwDdjADd8QZ8CACaBnCItACD4gBvm4An0WIzIyIzICMztAAQjQAgbTAj4JARq6k3qKkycwCBnhAiMAF6Q2EymRI1UiAziQAzHAFyb/kQRnkAvJgIrxKZXzSQzOsAkAmp/G9hd5gQIruEueOAICOiR4tyVhQiZjQj8jMBgVEJQ1MRNOAyiPOAEXMAF1NQLKeCN7tacnWFR0UAiIoAmPMRRFIaK4kAtAdqxOklhE8X/P1GrDgAufgaLvdgtDgQlhRAMg5wPcOgQ2GgQ5um9aYAMrcAIgcK4goJmcKaQWQKRRKJqo5VqwtU9JtDjisR6qSVBfaC3lUQBSNABZSmgWRw8L8gzAqQiPwAiHEAQ+0B9kBDRrRxYy4CZEgAIHAAFUIgIzoGIT8HU7iacdi5MccAVzoBXB5KA5YqhigQNIOQF/dyVC8JTFMAzdKJXE/8AMx9AMsoB+F0AB+yl2eHE0Xrl2TeMVJ4ACRxtW9BNWTUOXrRo9tiaCc/mMubYXOKlXhKKncQVXHIA1c1AIjqAJH6qsiNWs/3e2pyiVMyuV0XopRRaYvVALj+CEHmAuNnAD3GqjVaAEYkAGWoADLTAkIYmu6VpJnTmkECCkoAmvqTWQSUR7zpKaunUe5VEtEQc5AwAAAGAAYjAMxAUOBBtnviCmj7AIkZAHeItRaFUSKxgkLzAxOwABhdgBLyACEPCIEMAAIMurF9ACheAVtGht5mkTrisDSOkCGgoWOBAJ31MMNdsTxYAcBMYEckkBS7c0+zmgqTQ901MzSZMnXf+XJ3PxgSu2aXsBaiyhbCT2lueLNLSap636nSBLl07xBIUArB3VCZ/QGp+wv6/Rv/17OqUwwARMwKeACgZ8CuOzeE/yTBvUC7OQhHxAA+nKAjVwwT3ArT4wBGPgt0KAAywAAkkZknl2rj5quOyquBEQmlXYWkqKcLQFHpKLZgIwHge1HpYbAAAQOXyQJANLDwTbDcyQKnB4CIawBGpqJsQGJPXLJSOAABDQVnGVAXsqoTPWjFRQsTJxVrymSmWFFoSkFXehYf5iBi/YE6j4PcMANriQDGoQAXjKI66aPXbCATfTVm7BbNRTqPi1gD9FGBZTbSCWjLb2k3h3whsgghf/umlUrLWz6hK+MwiIoB+HkAd/QAiHQAiGoLCHAAiGIJyAcAiLcAigBwigh7CQyQd98MmY0DFRVVVWxxOuMLd9EJk2YAN5qwTgalFDoAVk8AM/kAM1MLjnqq7ragGgubih6QBVeIVKdC2LYx40nFtr1qQH9R6SEwGNgCAW1w1ADMTg8FAR9cl2sAIyIJ4vsCU4AxUbQQKtxSM6WQEeu6eMZGsyIAji+0pgVWH1U1allDQncD87MAWqEKk0SwzN2wzKcCSSAMe2miYWhhdn1RIo8IE/cotrmWEssVfpS5eDwVegFrUirWtD0rPzi5O1Wqsha8UAswfLt1J7gAd4sAd5/2DJeaAHf/AHeYAHlpzThPAHfvAHfdAHQg2uauAHfpAJ3/bKsDxuwmAKgDDUdVADNHDLGcy3n5MFvUwGTDAEQHADSEnM6Vou6wpEnrnCLCyQYNYdTIpbDRdF19wevafNPwEd3vzN22CwoOcHapAHGHgzXAIVUaBTKTABBwCJenq782zFm3YBHCAILtCJzeafYVUXEXtKI3C09wMDiyAMqIjQx/A9zcCNvbAKGvB1fgE9DeRKg+oCOiUjKcaLUANXLEHbY4mhyiars6qh32mhm4YWOEkBE0ABtjbcxD3cHivcE1CgASMIIhIHX0Av0X0FSfAFcsAGZmAGbLDd200G2f/t3WQwBj4gBEvgBmiwCZAKn7C8eJrECfVYBmVArj5wyzaQwdyaBVpwBnDQBVwgBD+gAzhwA8McwoSrrvwYpMj8jwmO1mqNEPekAIPjr8+CW+pRAOwhObYJCBeJkeDwDUCckdYQC1bGFoSkM3KCBU9ASBWDEPLssburtSthaxSgEXXRAjEBVjZRJmqBQGDVAiWyA2yw1MRgDKGNJGBjC8JQAwBW0Q46qEb1gSPQVjHSIzXxJ4wM0nC1jDeCS8s4q07r5SKLASDbswLasxRw5mcehcKNM0UQaVNAIQRBELZzBLzzR01wBEIgBExQhlygBU1ABk3QBTVwAzcABWNACr3/kAzEEAxNzW61IAl1YAdBsFwrcMEXfAP2LQRkgAd/sN9ccOdHoAM5IOAhSYDoasyH64/sCprMjKTz6uARbnupSeGVWy3cUSzyYQsOsjoezg3dsJHHgK180KaLMQNPMTQnERMTQHO5i6cvztvrN9zslwIcQO2phKpZcc7stT9dwV44YAQwUAOrMLPBQAyhnbNgQwvFYAgWcAFkMSfQiRZEMBL8QwIt8BcvQIsQtkAZBo1BuRJCyXQtEdLMCGpIQwJa+77AVKtojuYARqvYyQMasSVvbhUdYgRGAGnDcy9bkkc4oANCAPI6cAQgwAIwIARZYApaJ4PBwOhVNSl+UAdl/6AEQCAE5ApyFny3N5ADXYDTeoAHcODpTCAEQIADNoCUMBCS5goCiAykzoXg/fgArP578/q40TzrUFS5AuBb1zIAHpAKEZIg3vAN37CG0IAKkHATxC4nIyEjVPyIDIAAE6C7zl7FEtqzw20mHZZK+2MwPhPGWvEldJQEQJAJkmrux3AMzqDQuNALnaABF8AWUNH2VVLvavIWCJRhwdgnDEQCE6MSysZXd0mrimxrLCECOFnFFwBgDd/6FMDInugCRWCBAq0zW4IDYBIDSQkDBNMCSEkwH68BP9kCPmAKSOK88QnLubAKyzUEQnDBJAxyK2DBNwAEcEAI2P/TeQAHbP/QBU0w9MCPlC1g6oT7o0B6uMiMzFPYZfJqT7GO9U+k9bYOHgAwAA0gCr2xm+AMDiB+C2ay9gBBhMcMFyImVKgwgQICBhAcToAwQeJEiQ8rXNjRAgWKFi5iuHABA8cOkiVjnEQ5cgeOPrmGEQt2TKazZsqGzXK1wkILEilcqFABUsULFyREpBAhQoUIDi+WckjKlAMGDlMrdADaIYMIEhUwZMiAAeHFCwglXsCAAQIFqhQobIBIweHahwopHMQwYsPbvW4vbPi7YQMHwYIJB95gwUJhECAYPFh8Q1WxZMOG9eLFKxcuXJ9YrACtQTSLE41Nf2DB5tDqQ4b+/MED54z/GS1MhBzRgQMHjBakT/w+/UG4aOKKjUN4kDy5AwcLFig4EN1AgQIDBgjALiDAduwBtHu3PgAAgAALJCWDJm2atGjRlh2DhSnoixcyBMpwISNhBQ4RKUCHgAGIJDKLookwmAA/Fzo6CSSQZChJBgUbdEE3I3KwQRbLhpGpGJqUKQaWXIbY4ISekDoKqKFS6KkqElDgqiqoZBSrqqui6qADEkj4CiyxEMLgAonccqshv9a6iwIhkXTorrkOKuyEvva6QMkqASOSSMUSg8ACDRbTwLkINBhClVlYQSXNUkoZpU1GhPtAtAgsKK2xDx44YIAHhDgEEdYOIeSPPPBgw4wu/7RIIgnccoOh0d5YMC044opTbC7klnNOAegOoC687rYDNdRQxyPPABowQcWWWFKJRRRIRDklBRlmeIEIIuiTgQSwMtjPrQIgSIhAXoMV9isOUDhphyKShQE/nyTEL1mSPhIJBxY2SYYyZZppJplsi3FFmE1AGKyqFDqQFSinVNgIKq6kqooqGZOqSiqujErLXbEmGIGDKqvMUoPENiAXhBMsoIBOwBAm8oILRvhNsBMIk/ECwiYuTOLGBCNXg8Y0WIE50ew4hZNPMOEEE5UxuQQTQiL9gGCOLVCgugAGAOEPQg5hZBFGXovtDDK00OKIRXfjrYXeSitsONGMUywCqf8jUO4B5px7DjoDpqvOuu9E9U4AAsbuugADDnDADmG06aZtZY6BxhkX6LuPCBlSwJuEDsSSlwEFgh2LQITC6gCqE5CNoYgpiiCp2RZS6EhCj2LY4aMFRYKBhTxy6WUYypIRpvNcZqnFlBVAQAHinnYkisUR2B2B3nqTytddEaiKigR2RYBxqh/J+stfhzRwyALmHhhTA6sdKF754REGrCrBAHbYLYceCNABBhY4QIHmsFbAuQMWGOBsUy+RJJNGJGFfkkceeXOBBhrIVAG/OQ3POhAM6dORSCIBlKAIZQZDNUFRuNFNo3hTJ5jF6UuUmtqlmPO950inU+EBW9jElj//6iBgfD1YhTW6oQxbNMMZxXABCmZgq1u9AF0p4MDgMjACBCHgIIIbi1eqkqMUoOAEDOJB5RzUw40ojUGWM+KCUGADUpjiFKtYhStO4cQ2mUIVcCAXB1rwF67Upz4oUMEJYie7qJBxR2Wsl1HilZaEIClLyGlOA5oTHTpKZ2sGyF8e8wgqUvXRj38E5Hg88D5JNMKQjFCEIhhhiAgs4HrXUwAeB0Cd6hSABYfwHyUsQYlFHAIQQIMDG0LZBS40wTZCyEEOcJCDGrDAla4EjZ0mVZypUW15V6vgAbjWtQxmR48F0OUCVvCIWbRiGM3gBS1AcisePAFdHaBdBTKQo3r5/y2Hv5Nh4V40giIqzUELEiM3OdKRBSntcEojmCEkwQmTfSITmbgE+jghC0rUYDAoWOMMaOWCEXDTBfJKy772VZcA1QUiDVEAAgjwNT4G0qGBFNUkq2OAhEYHAQjQVNaw5gDj3VKO8otOAz6wClOkrxGRYEQlHoFSRtzAS5VawNaoc0c63uAQkdBkJijRM9b8YQ94+IMeRknKJpjSNqusQQ0w1MpY2slpD/xSBK63nOZsSqa8DFV2BGCdm1FSl9ERpiJggQtYoKIFOygKizjQgRzmcAJlYQACInKQtlLlAoWTkV6kRBW34kVGh0GLV/ZlgR8AQhErjQQhCOEHQPRBEf+fMAQIWoADjsAIb1FpwW9QcEauwCigAzUoBpjCtwkklJIFwOhFLxodTbXWOfST3wSRd7wuGWdgHOPAb6riw4lxwLbk2ouXBOZKELDAARqIQBBmQYpLcEISlYgE+xB5CBZUygGRlCgwWcsAB/ApEu98J3R71slD/MEQgdJDbNiwhvWSUghA0A2jMgfLpj6VUhaYE9W+V8fpeMo7WR3Adqxjtv6WrwE9UIQoRtFahVLnAKq9KGov2lpgjSUsQOpR4eTlrwJstQAEeLD9IiKvf7mFIgFCwAf60IdFtPg1hDCsIkxhikNs5IcxkAGC+CMCF/hrAySI4Y51XKC5VuBJBJr/CIYTAjDrTTVhXfoSciLAUeNABgIHS4wFaluiKmX2L9VLGMIExrGNncBo5MKvAwBRjFJwoqTxZN8iGsEIECCnZuHZGmtFrAE2LCISmwD0JiwB3f8xYjV+CqAABwWHNXTBlLdBICuTSl+nwum+WrZapirINa8xNFQcNACoDLwCQMiFAn5jQKotleqGzJUtSQZLWy2GFsNUqdVFvsvDxBi9sgQOIgr4ACAM28k97GGxhl1FMlSRBI78ZQQTyEC9TlAlGxkIIpYacUUmYtBt0wXbcikoBR7wmHGzmkkMkAsHKPBsL4FAA9V7mL+E5DAMNMxh/lKSYS72lg9kQhij4MQo/9a5JvY1Qg8061p4zPbgBTQEZIygBCU20YlPdOKdl4h4JBzBCI6Tt7yvAdoAuzCFA753lTewQSuJ20AHPg3TzamqLjul1QzeLDykErABGoCsC6DbK9ZOMpJuuB9ijYXe9/bXBKYygX2dhSqAARhFpGm/CJjhECw+RLH/IGxFjCIZskBEDUCAFgpUgHbtokAG6Fp0oCOIIkt667Ud0mpW1z3VDfdb+DSF6lTv/dph6QsFqgIBKinJUtc2dc9NvfgqeYkUyQB4m1eRi2JcIhJu+ACnKDnJSYa4IYthgSUEPfFPfALQ79zk/yjxP0d4nDWBgg0cQvmFK0zBNkAAwg9ycP8Dlb8yUiD4wMairJyYa77TNReweHBuc3fLhdWIV8hDbo1t6vvnLmsPFriPfCBrN2RAEGADxyNhidV08hGSEIW3PkGuCwSIAZCDAMDmGhFpamVASd6XxarSr3y53UBVapKJYAB5U5IoMyi/kDesSAGlu5IukZIdSgoVOIgRW5K1UDe3SAwWqIEbyAVnYBNTeDxZkIWWUoDwIABKMh/WcgDIAAEf2ARTqIRKED2Jg6dLiMH/YakW6yRDOK/X0IM8CCU7MBQrUJTc+wEfuIH5OoEVAI7CgCr8kppb2rSE87Ss2ipQyzOqATcR67aHmKv7Uwgks4skQ4sgEZKJMLGhAxL/qQOcuWCC/7mETAAUR7ipR8CEXnCGWaiDiZk7F9iB3wDAiriKsGg6qcu1exsBEhgBh3GYJHsjumu1CTC3cmu1U+sSv5AmAJw3t1hEr5Cm26mAVDM8U+uSwrAAEBCCFViDZHCGUXAiUlAFTQCCByifXVq4B+se+4GMDWABH+iEXPgESRi904snGyS0Qhuv10MvPOgDIHyDK0gCJtCCLBgCIdCBHICBVlqa09AAp4FC5Mk07tklrgIb7cAODjKbBQABGMCeiFC1LxQc7PPEHtkVHcqRfhqBHCkcRjyQDLCYHNEVCxsWI2sIHIjBdyqDHOCC1WMfVjihSxg799MiwbCA/+CRiwuYNiL5NnDDoQLZtrfSSLtDt7UQSb5TNeWwHidpv6ELEBkIBCIwCrqAjOUhlzGxgA9gDuBbA1kQhk+YsU7IAwfglDyRqLOZsIx6DAjwGBYYgk5IhllAmUzwhEADL0uApxg8Ro5LxtUgBNf4AzkAyzMQS0NRFB3QvQR6lNM5HeB7mjHRL/qxqq75juwAFV8qygfQAU2ogfg7KAaQpoEcnL/UiliLtcHpgEREAbzZrHycCka8N8LRESC7gF0ZlmuzgBWIBBmMhC4whDeEw1EwoVWoLuf7C8XYRYA5FoeZHu3TyFzDEiuxHuzRSOTgru1ZgOV4gNu0n7q7mu9hHv8tCxARqwAJkIC4KoFQCIVJSIRAKAQ6OAGlVErFsBPQsAEWaAI2+IPvyoRNOISQsaNatCjXarjfLJEaIINMSAZlQAVRIAVPcE9A4wTwqkpKqITVWz2N2zgd7CRCKLaf6oPYeANSYoIhYAIEQqpXOh37wq9wfA4EKLAr/BS7pCQF0ABhqCeEmQi1s7ZgiTV5HByp+I0QzS0pmZ7A+IvaQYu1wqsgATcNWITtzASxkwP6rARJGIVigAZhsAMNODUH2IAHSh7bItE6eSCCET5TLJ4FRR7FiCr8gsI58RK3FA0jDb7GWAFX2sDdqwEdqBwicIIMSAAJSIBAQM7knARNCIX/WCwEKhAEQTjTRNiDOPipPPCpPZCDMGmAMGEtmZqO8HQO7lqAFVTK4sqBMbgE9DCGUiCF9nTPTji97dyEqrSESd2kjGMpnuopr/zBUDqDNWi0JhACIfiBG0il6mwq4Bq+CeIe48sfmku+STKAHKUEJtwLCEAQJZG3pNM/x0xRGemAKAlRpqHILfkX1Zyev+KAfnKLmzQE8FoESsikSGguWLgFTvCB4HMISAGBtTSNKyWNFsgcpFElHTACHdAB3GOComoCUuqCMuACLvDUNFg0PKBXOOiCPMBXOMADIAylQiGDf/3X9zLXa7yBG1AaFskACTCBEDCBhi2BECBOCSCC/0JAzkRA00SYBDoIhDBovxWEjgCzufIZSmDKM4z60xUU1MWQLB1gg0vAUWnwhVIwBVBo1E5w1ECLVPmU1Iy7wY3jKY+DvWZMLzbogi44JVHlPViqkx/FNDiawgu6jk/hjvCAhmLgBBr4AKohvB9F1YzZGDIL1t8ADVcC16Qp20bBgWtEAQXCgRjAASMwgkRJlCmYAh5Igik4A0bI2dVbBEvIzJapBWGYBVPIBEcYhEFwBETrz8UFy8aNgyuAXLpVlCQIVd3jvaSatFgSjh+lFOK7peWZn/nBmucY3axhAIUNhBAIgQQggARw3deVgFDQhBKYBCIIhNtNhEIohBiAAf8GsBmb844PK5+Z6p6TTQ7kKMXDiYEjyANJ2IVnsAZowIVTIAVQAIXSu9mbxVlIzdlM2KR3us9CK7QWWw3++bhBEZqiZQIg0FIWyBxhfaCXyyXNI4BO+5orfIVSEIVLMIQ+mI3+/BM/QYQBRgRHMOADRuDEJeACNmAGVmAGXmACLoTDpeBim4IriAM8OIR32gT7TCn0yYTR4U4ysIGDSdAxg5q5OF6rEcnSdeHSba0YZq0Zlg5duqOrOi3qGBvXZVgTkIDWbd3XdV0ynYEwuJVEIAJNIIIwKIQZiKv6DdnrGLATJDDnWEHsqRSVXdsdSAI5qIRbaAZq0IZmgIVFvd7/igO0itNeQJvKmwWv0xu0iKvP8B0vTA0UIATCNeCC9cUBG2AU0gCujrGA5Kif6NDhhTJHumwFWGCFU9iESOgkoGkvKIhGUS3Vz1gB0fgAKJygTvZkT747TaEjmvrOszmACBA/HIyE82NlH/CACKAfO7LFhNOjVv0v5HuoXNblPwqAMF1d4hwbAUgAEwjTMZWF2p1d5DxTIngCBuhTBCiACoBmzYOwjCrdlIUyg2EBHDgCIfiDVlAGadiGMS4F7DXGRsDZdH5j1LvBRXgfSMZPn+0k8nKNQVGvoUEl3mOlz2DLtpwy0X1aWw6VUcCE9/GDH9BcOFHolkMuqbma6hif/xeW6FW14TvK4QO4skganwj4A838n/ZhHxr4Hkkix+3Y5ZNG6ZQmD1EDlSAW09YlZth1XSeQhVAIhDOdBGEQwURQgRP0oDxBgAzwIAlTLWveqCuGGoJxXy5m3lIghme4hm7Qhl1gE1KAp0z4s3TW6kcdtGJErIgL30sl30SDDaIFVSB4rxzgZ+FgS06+mooaR/sNAEUABD/4AzgQAm0Fvs2lyC+pFKrKTYh+LdgaXVmGWuRLvvG4GQPIAquEp/ZRGUmIgFADWZXuowAgj8xG7M3mbLApHz0SYtYVYjF93ZsOBYsNhZoGBSLw3e5x0A4TEKKO4d1kDjk6Xi/5UaUWCf8muIIj0INR4IVlEOdugIZeYJNPiM9MsNk13uruHYVTOAVMkASrpFQ5xsrxBdrYMwMycDQh6GN+PuGokqoA2bSr8hQB8IAVaCXg66hPpqAXxqVADV2AFh/+uuH7ruHwGV0HiIAPyIJI+ITAFQZhKIZiEFxDYAGHdgD6oW+sqSP7rmhSfnA6kp/QnRoP8IAPoIENp4EeCIIgEIM64IM+MCxCUhlRWBNUmCJSCAUZcN2XDm3ijOkXh9gQKIFUU6iEOsGFkoCEwqjWsjvc3LJIWWreZgMdcINPuIVlgF5tiF6qbpN2wt7lBjQqDzSKW4XOaQVOADRN0ATUK8ZNykqUIi//ASIUo/Xu6mSqfn4ap4WOn968AUieSXFS4ljoKr1Spdq9HDDL3UPCgrWBgr0BH7CBQk+5z6Av0KgvONnW/t5WHwgCP5CET4BuFT+FUbiEPCD0HuBwGqgBG/ABSBeDMaiDPmAsRXBn9onDTAi4NTmFNGkFVqCFWbgFXOiFW7eMAv8cb+H1beGWXwf2YH8GaZCGZ1AGbxEGJxgb0pZpmQZi170oAoBmaYfmDxObHkdKkSyeOZlSbT4B99UBJpgCNogDIYADTngFY3gGarCGdoeGYECFUSAFeSeF0rN3m733QKP0XEiGZhgGgNsEL9eEnF11dsZK8TK0HixrR2Pf9v1a//ZOs9GNywKwAzLIAibIAlEFgg8PglAndFAv2KTi8A0Mecw1dJMPdB/4ASUYgzRYAzvAV1M3L9ZgBFXOuIL3yTbjBFFQsFFQVFdwBVmYhaEnnVzIhQEn8F3nFmdg+qZvemiAemeA+qmn+qq3+qun+vYg9q2XBm24BmmIG2F4gezw4RdXWDGVgBAIhLEJYoWSdihm+4UKAAQQ07tbnqRci5cSGG1WIBgI93GXUy64A0xoBV44hnVvd22AhmNohQ8EwXq398jXXlJwhWJoBmhohlYYhSq32dPbXp0dNJY6hP0UFDbYY1D17swqjdMRDOQivkz5aRDPgtkXg9rngxGPsf/3OT9JiEN2orgmmrEZeyIoWgVVgCKgF8HkF0GjN/paqAVZqIVceH7llwVXgCLlrwVWYAWgZwXid37pr/Vax/Vc13VvAXaacHqst3ppoIb2d//3h392b3druIZr0Ib714Zt2AZwwP9kKIFgBogEIUwkkGDCRKJAB0PJSkBAQAIEAggQKFAgwIABBSgSCFCQAQMIDB6QfADBggUNG0CsBMECxg0dRnQcYdKFTZw9e4SMuYTKVjBlzqhZK2pNGaxVp06ZMkXq6aeoUjtRNTVLGTRr0Fqd6uTpK9WwYjeR7bQpUyZLlSKxdbTokKE/eNiwMTPlCA4YLU7UYLECBAgNGlD/RnjggMECBQpWMV7lypXjWbNqUb51KxfmzLgo5+qVCxdmyqJH15Js+jRqWLAkq37sChaqVaxmz1L9qlWsVK1g7YZFy1YsW8B16drF61ewYMaMIWu+bFmzZ9KnP4sm7bo0akSNauuubdu2buLBkS9v/rz5bum7CcvAMYEJCRLgmwgUSqEJhiUSBOAoQEABA2CU0QD/BSBBCCGF9IAFEaC0AYQgnOASCzEJkcRdTZgBBx46HaIFGZeU8souyWC1XVHOzMLYUk099aJUUZmCSzPWaLNVKZ+AEiOPUYXl41mZUFIJJZRE4ggihxDyxx97yPHFETrkhYMNfbEA2AcfDAaB/2ELLMBYbI2hMiaZY7ZSJpppolIKm226uWabqbgZZymp2CnnnXe+smcsyACzHDC+GAMMM4UyI1000WhnzTWNbsPNN+7QMymllVp6KaaVokeeeOJ5p41WzjjTjDLDCDMJAhT9B18CrRpkwiQKJRJKKA4hwAACFhVwgAG6WgSgRxmANJIDJEEAAQUXbPABYCe8BAMOOgghhE1ncMjkH4ZkcoortxRTzDHKNAMNUaAOM0uLTX1CylRkbUIKKs7Y6AybYXlCVVliheUuWpZcQqQjjLy1ZB564LFGE3jppRcKE24g2GCFOeCAl3lafPGdsWi8McfC2aKLLyGH/AswfzLn3P8yhk6XqHXXTfMyUY12t413k9ZTDz3dhLfpeZnSg97P5+l8jTXUSBPNM4X66YsuuaUiCtSQSK0IH3zUUUUPPQQRRA8rZKnlA6mqClFB87maH62yyBIKAQgooKtGuvYaIIACSFCCSCYxSAEFE2zAAQgrsPAsDtR2cXgXHObxByFwHZKJKavAgksvvIQ7LlHUNDNMLas45eIo60a1oyml9GLjMKPkKBVYVPm471dkoSWkJUYG/JYhhhCSBxtdMCHlDnnthSUIWjYYgQMNNGeooSyzfF010VfTKDbYcHM99tx4s/3233j/PTrhuzP+PeWbf/4797yz/vrm20PpPfjgcw//zuOB06mn3RVFDTTQPEPqMYgxDF7cghZjKgXUMIEJqUFCEVSrWh3qIAau0YAGHrggBjEYAQ1GoIMOAEFKPFAYkYgtAf8hWwmcYDYCJEAWyUjGqWSAgAQooCIHKMDcDoCAG/4nVRKQQQWQhRKV/A0FKGiBDXJgIZuwgUOKY9IhomiIRViCFKdYBS0KuItgHGMZ/YNGM5JRjF5A5hRWdBG7okKKUoyiM2xM41R69LpP4Et2s1MLWxihRyXJ5QxcYEISjiAEKg1OcH8xXmG+p0h0fEN843NHPcIXvnFQspKWpOT60qHJTYpDHOEIByXNYQ51kLKUpJxHPNQRj3i0Qx3t/5jHPPLxj3zoo5b72Ac+0OELO4lCTlAThQIZ6EAHVq2YVeuDHvxACED4oZnMzEMe+KAGNURQDEsQQxaU4AMf3KAGNFjBCr75tRVA7Gsf2MAFOKAlDUzAhBRxCNkK4oRQTKIE8wmEMGhVgrYlgAEWsaFFdIiAXPWQAAwgQggmoCwIneAELXABtISABCEcoQtmYINO9oCtxh1iEYyIoiU+ETlX0KIVv+EFMZYxqmIM41u96JwpTlGKpqCRFKYYBU5zCkcefcUTrHsdvjIRJDyyJRIf5eMdzsCGKzSBCUDIQQ2iWkgIoSQfVoUH+95h1VtaNR+33MdV4SFWeLCDrPCIh/885GFKU4ajHKaURz5AqY5xqGOU7PjkJ+caDnWQgxx4xSsu3cGMKnCtB1UQQxUOKwYxRLCYdVCDMd2gBz0ULA9uuMMd7HAHPNwhDZi1AxrKMIbRqqEMTEDCU7upxBvcYHBRrQFrYSBb2e4gCTrQQQwk8BCOsLBsTpjEfew5Tyy0ylZvK8AOD8ArtzG3AD2cIRFeUAEONNSh0NpBTbhQBi6sAQ4F42gUo6jHPDIipFZcxZla8QpaWI5UAuyFZ0JTxs/RtCmhw+mLoBKjnspxX+6SXe2ItJaPGsIPevgD77rQBCHkoMFVYoHDNPCPCU+4H/+wMIYvPOGvcngfae0qhTv//FWvzlIe8IDrKuPBjhWLsh9pTauKX4nKtMLSqujoRil6IAYafGBrW9vm1rYg5CUQGQk3QMIPbuADJCgBtdpNQxnKQIYpCzmbW1OCNn2gRCuxoC+BAwxgXsKCFrRAtoUDwhFeYMIATOSExZXAb2l1Hyfsx1UDVcAAdDgBCOhQMSB523MZ4AQniGAEZcYBDnZQhCTc5A558C7jGreISXuUEWwpkh4p0YmnLEV1qDDpMI5xjGHA9zOZyUUtXMEUp4jUFCJl1yjyCyMdgWJHcqSjvsxix7QMeBG5U5LB1sCFaQkBCFQaHghErOyvUrjZzm52P6It7WlrGMPTvja2o/0P/2ZvGx/0kIYiJmgDGvg4CD4wtw+yCYQf6CAHLECnskCAAmjl4Af29kHWsuaDdd+gSlwGZ/HWCbEGCcZBHYyAYFLygQsgAAAACMDDA9CfVlEkEKqQhSroOZ8ZtqoAeM6zAfbsNj+L5AAEGMCtBE0HGbggWkdIQhKuwIYOMY5xUfRoUYtaJEwzohKb+ITqTsEJnH4aFwO8xS5MLZpTYwbjtX616GSdX6e8SKdwvFeM6ghgtjzCo3zkHRm08MdB5gXC++jH2dOOdmVrO8Nur3a24y7tatM9wyG+5T/8sY970MMXfBDDU1eQBR/f2wc2+EEOVgCBBRigQBo5wAIa4KAsBf8OnOE8ZJYiBjEPTswwyWsA6EMPegd08AGDIYDDUy8AibNwVYGQRa1lwYFjFZcBignQDgeKgAWMBFkUUIDJU+4EQRChtkeYwkVzsgfwHmK8kShSJCoh/Z1TwtKVyEQngF4KTHBCFKNAxeRokUXTlEZtkHFMLXIhC1a7Tkb1pW99SZHTWKdxR7Om4yZix2tJ5DGKCIaDUimYEEiJbOVDLB2gAb5YiqHViqGVArISK7XDObQDBVagBaZYO0BgPPQDLKFSikUbLE1YPsiDhVEYP+jdPXSDKCiCIXSWHfRBH/ABDM4gkzTBCihA6jVeABgA5GnACkQACMhWDmjBGhRh73T/ARc0gRIqIRM4VQ482OD4heVZXhQ+Swy0E8WZ0AlJHAAggCaoTTLIwgIMlEj0E2L4Sp/x3kmgxAIECMopQAcEQhTEwA58QRxY1MwtDiEYQnjpkaXlXFFJH5EIleuMgvepDixQxiwU0Ga4hiqogqs9hSlcnNrIwipY3VPUGtZtgiYIlR3hVI+4i38FiZFEQqV91B9QFhuQgRlogRD8AA70xQl0oAem2DzIwwLiYjycWD7s4gKm2IqxQzsIIzG2gwHSIixFWy/ClYl1VVeJ1T/EA4XJUj7QAzNAAiC0oB3UwQx2ox8YAh7owQM8XEZ8ACTAQi+cyyWIAcKxAAq83BfQ/8UZnIEZkEEXaAGIaEET8lsSvVYhUWEU1gAMxMALvIATBAKdmY0JORwBEIEsiIozJIMqfMACTIB8TMADMN6u3JkaWsAGNJQFHJcCMEAFFAIdxFxOcIhGcdQp5txaAKIgUoJQcUIncIJN5hT4qcZusAJjPKJTdAJaZF9TNEan4RQnrItNudrosIvrbJr8hY5U5AtV3IsnyM6AMYKRfNSS4AGH9A4TDJJewBIGNiAwssMqiZU9wENausM7jFVWrQ87vENczuUIvphd9kM+lFU+wEM6jNVYsWU/sMM89EMGwoM7gIMo8IEi/MEdSNAMQlMfQJPuCMEH2J4CgIAz4I82dP9DMixABMDACSTBF7zBTdgBPU5ZFmjBGAyBvf0ANyWRv/UFQL5WDuBACyDaDjxBImhCIYRA2RRECSQCRI5KMuiBA6BABmRABVjAAujQASjGApiEBrhEDjCBDVgArywABUCAIExCGNDBHgyCRmVLR/nhHwai9LFFTErfJWSCTb7nTZYJK8DCUjAFVGRCJVjCJmTfGsmUIRolKfikTV0RTUld1U1F+6kR/p0F9fUaH/2fGQxbg0HgMAajhQZjW6olVq3Phr4lXMoliJaVL54ViaJdPGRoX2roWr6Dhw3mOaQDOoBDNCgCICwmGURQHxhYwRjYHfDhG2iA7RWABYhKKVT/QTNogzOMQgMsAAvIASK8gRwA4DzWIxlkgZWypmu+pg1Uib/5RZdFVRLhABAkQQ3YwFcawSBowiREARZMwiTMiipkBZKKSy20lgukAAZsgAM8p58xyHS2gBA0QV3AQEYuwAZAwBPwpiAMAiKwJM4BInoK4vQVySW0p3vapAINHZu4Qi8kQzPUgn2yyyWoJ/YBXU6xkSiUwipghqqxSX3GnyTmF359gk+tS0wxhlKeRe1YQu0YFe4cAoIdzLAJQYi+wzoYayalQ1adlVyS5S8C4zmwQ7ROq7RWa7QO4zxEo1mJKInGpVZ52C7GaDekAh8Awu4wVh2k4mStq2TpAQs8/6dEeBxFAoAeXEIDFEBixEAoqMIhuIEfTGk93iMT4OM+AgG/sRZr+ZsNJOzC+sAPlCkSeMEb7AEiWAIoyIInTIInfKEw2AioQIMyKMMptFYMoMAGZKQCLIADIMtHmunMMQ4b/GADsEQLZGwhIIIjdNSjPp+k9mxMUgKvsufsKJAkcF/3oUIujIs1CMNNsUsl6JEkXMJ+At0hfl8iogsCpeoBHZCrsouBkkL22Sor5EIxCMMssBpayGRalCKl8REepAE+rgM7yK3cGusmKWsmWWgFRqAFSmBf/e3fSqDgTiAFbuA8tNIrndiLiVVb7sM8qINhggM1AEId6IEblFYdkP9BKhbMuuoBFOiBBSBXRQgAAAjIDgrIACgABzDEIxKCHsSjGZjB4TTVEjYVsRmswXITwibsDeBAvf3AECwBGhBCI1iCKciCMAgDKXiCKeSCM3yKVkCDM5jCDbjADJyABWTkSFDABrwEE2CUeCHCGrAAELYAB0wCKLhpwJwnkQzJ9Pms9PEqr/5LJVTqJRCtAnHfKQhDVkDDLIBiJihC9M3ke+LUKdACLsAGAp0q1KRCLITM07DJ17ILKDwFKuBCMohKMbQCTsmOu9SOkXjUwPQRGVhrtbKYKAWjKJ0DC7fw37YwDBNu385wBmYgBw6jPJiDWbIY+8jDPPCDOtyYLoj/gRvgARqMQRlkLmUtDmVliyeAQQQol65URNwICAE4AfLSiipowiB8AeIcTiAF0hGM8QACwbQYLOI1WG3WJqIl2g50QbZUQiccb/LCkCqswvPqTDd8ijY0Ax7owBTowAhwCcueAA587x4cgiM4wvMxwhrUwArsQAvsQShkrCUwciACrfv6S88CrfzOr/1WKiY8wiNIgilzQi30zzAgECdkgiQ0Qv0a7U1yiyuggiFCDU79Uir4AjNsw89MgzHEwprYFDG/SAXbFCwUQ/9YgzPAQimALVmAQlWmBVEJDFz4QR7YgQuzcF+xQwpbqDmQQ7W+8DmQQzm3MA3LGDLCEgVG/5uK5bAKm4MmrYM5wFI4eIM2SMISrEEarEEW3Kgd6IEcHFge4MEfLELyIsIG4EqB3JnbCFooCEMlylkgXIGCLWEYj7FGD2CxtWaD9S6i3Va0JMGGLIIkcMIpIO8LZfAX2Y+n7PEpjIEcTMEU5ABKeOQJwIAQdEEiL0Ip8iojpEENaEGiZZwmaIJ6Tp/8Fsn8xuQng7IgmvIlPIIDPQL3jcIpcDBOYYIkkHLU3u/QccspjIIC/RLU1AkwRIM2gAM9xA/f0cM1IEMstMnUIeUp3EKN2Ig14AJT4B8pgIKu8VpWEtiSUOCFenMo7TCGzqViFyMFlrM5s3A6F+6KkSAqzf/DimXV+ODD2fWDN3SDMtSBHeABNC1xHsiBHCzfHgACHphCBjvD2gRCDJwACuRmIWgCQ6yNnNGKJsyBFXhxF0CBcEOBEAg3sXH0ALbbR0dVTIxxE6xBHxhCJaD0LJBtOmLFzLD1pHDKHkuCD7ABTefAB2SvBnxATk8BRv1BFCmCwCxCHgABE8ABEFjCFk/CIrtk9MGvJ89Opc5OJoTyMCnCI+RnANNogFf1SbMJJyyQ1ORvnSBDNGwDeVAKZ9+DPZTPN2QDMjwNMEXt9WHfKKTyd2yDNLSCKUgzWegfr5air34dC4sSjMe4DvMw+2jSYa/YY8cwDM+wN5tDPIjlKnn/6/q4AzpwdrSBwzaIQhCMNh50CDRx7uL4ASD8gSxYwwtlHG/vdijgtpZr8SRYwewON3Eb93EL0m2p8Uc3dxPIASEIeCaQgivkgjCw1DE0AzV8h3rQAzeQB80gaR9s1hckgRCQU3mvgA0IgRl4CCCwhSF8FCPIxR90wSBAoiYs8pBEKntWqiX0y5CI8lejxb9IQgM5kCTkJyUYwoFLjSQkEAM1eC/xcjXkOT3Ugz3Ijzt41QhSIzrcQzUAw9Nw9UkjZSp3yjKgwl9X5c+ZBadD3+0A6x/0lYxHO4wnqyZ984yzGODCcGTLcDtc+48f7iplVfgY+T+AwzOYG5NzCB5E/2Yd8EEe9AEgROYqgEouaIITEETZGIR9AFdC2AdDMC3iNIGYFzdxExtNDCCao3mgsrmlQc4q1IIwyPkwCIWcbiY4XMM0dAc1KEMvNIIegAFqB7Ll1QAQpLchAMLTLnrP7ZGSfAEoqIInaHJ+Rx8Ie/JT+4v9LvgllLr0SUKNCjiAkzIkFG2qMrir98kzXIN6oIM7cHY8mMM41PMt3pKL+TDaicMv6wIwXfVTwAI0iIc12IIZnfjULig192ojWDMhQLuMg5IliRK1l0MowbgKZ7uOc7uFbiBhhjv7EPnZ/YM74FgP+IBmYZbi5EG7Vw0gAIIaSMK8hMK9y0d86PusbP85l2fcI5Lm4ZD5cB+3tCQ3mt9WoE4sIrCFw7uCLEC8MLD0dniHxz6DLdDCJcABITjJHrxBDdzmwLJB43zC6ptyJ6jnHjECxT7iig8JHuH8U1/Cpv93pZoy9LMF/3V1Kd8v0ZoyJvxSWceCMTzDNGBDN2iP94jDOGwgOVAgOw/mtLGSWaZDLn3DNjBDKmQ/m8TU6WiDMaCCGT3dpgFJkKwtQFCKxGjRIXMHEaZLJ07cuHEMGyosN5GiwnEH2R0kt/Fcx44bN7YT2c4cu4zx+vWLt/Jdy3fu3O37tw8dNT49bKRZY8cOHDx68tzhk4coIT19kkFzpkoFAQAJTDg14aT/UKhQqoTJCgUqlKZQb6B06ZIkyRGzZ4Wk1aFWRw63N+DmENLki5w/eQ5VyrSJ1KlZuYQla+bMGTTD1KhZ06YNmrJkmw5FPrRHC4wdSeD8OdQo1yxMp5IJu1SpEiPTjhztASULlCZLlihRqhTp0qVMt3Hfrr37kiTfviMFV6ToESZJmDCJSl5KlKhUxqJd60bvXnV8+NChY8iu3zx18Ua2O0eO3UqU81b2+8cO371v36oBS9W81KhSsG6hKkWKFKhPnzoh5b9PPNlkk70ygU0g0xxqcByKymEonAnDgdDCci5CyByPPgIJJA4zNKedeORZiR2XXnpnJnzo0YUGGlgo/2MNNXjCw8Y92MDjDzj0uOuUZppJho4EAgBAAiIDmaQrJbeyShZVVNkjrLGO0OEss9haS4e23qrBSy9z0AEIFmrwwYcs7jAkkkeO44ST5uCkz5ZmFBMGkEMQmWyPJMzoAo5FIiFEklOUcaYVTjqbjZGBIkFNFdYUlK0S23LTjbfdkKuNNNIaYaSR45JzLhVfntGGnlPruee6fWT6J5x39lHvn1nzKVEeefqJtcQR45lnnpTU2+c6956JRRT7RhmFE/s+6Q/AZgf0pEADD3xNIEcchKihh8ShMBxttXXQIY08JEdDDR0sySQSTWoJJndU3KeebSD5YAUQykhDjX3duP8xjp/ekGMOOT5xJplkngwkAQmcmESWhx/tCpRHD5YFESig4AJjK4XAUogtQd7SrZG7vMGtL2v4gQw1/Bijjjr4iDnmPOyIGRA+IMEkF1kY2WMPQQTB0Yw7DllEkVUIa0WUXZKB5ZRPGF2UEkY8efITSjSt7TbkuMYkt0tv4+Q22LZOJRZfmKmGm1PpqSfVelZlldXr8JGbVXXgyWef6uyBRx5eeUUppVln3cceaXypL9llS2kWFE/+4+8/aQucNkEFvfX2oQkh+rZzCsUNZxx2yjVXXZMyQugiE1Fq9yWY4qVnmR5WWEGDfMuoAw03Ao4jDjbgCHiOOBzJJLSDkwn/RclHH33Sk9VkSYYwWRzRWGMo5Or4iI9FDjnMLWsw2a0tx2TBBh/GsCMPQFzeV408gHrjii622EKM+xmh5JA56KAjkD0YkQlJEEdnqxAFL5oxDFG0Ihm5eERwIjEbgZjiYZt4jSQwxQlMuIkTnahWcExjCED0IWZ9AAoe3FAHTFijG+Bom3VURbe6yU2GNWxPPu5hD1Xd4x3saIevelWif6gHWOpJxz26sQxUKGtZo+CPtB7HH/6A4nHPk5aBLpeRbDVEW98ahze0kx0ubqtB50JX6k5njouU5yQqOdHr3HGPvdEjFXwQww1qkC/34UEOcsADUeygB4HRYQ9wMMVf/6bHpKs8aZGyEAZhhKEKTUABDFA4wlvSkknurYV7OcDBJ3EwPk7+YAhZMMP6IrMo0yzCEIzAEx0GMQhE5IkQX+AfFgIBy0HMQhvWOMVvUKGMXogCFckYxihOUYveSCISiyBIJVSRC1d0IhOc2IRpPrVBTlyiUYmggwtggAgdnSEL5RwCEJTwgRpUgQ/PcGEM7fGOuuUtHzjMoT3qoUN77PMd8PAnPOLxz3rKw1eD+0c9EVrPIarnHfToBjNSkZwO/odalpBitCh3oLFZQosNYki2OAdGcYiRW+LCCOpMYkbUIYSN5bkVO9IBR3nWQxuQEMMWfhAjfe0reG8QCh/s4P8GOfhuD6Y4RS9C4wzleeUqjcQK8pxHSSh8LExo0aSWRAbKUIoSCD4YAhns4AdAGEJNiygInvBUBAiMQBDeLEQiwjCDELzgCWGgwyF42Q1n+AYVuGjOwU4ximIUAxWckMQjHuHMRZBmFaExRQeDU03jKGIRjqBDBwQggBQUwo9mKKcYyqmFGtAgCHUQBTjg5g544CMf+thHPv65z33W4x3xhF1LAGoe86BnHrdC6D/z5jeCpgQf7uhGNGxxrE4M6BMHkqKAPvG4KlIrQQfZokPE+I2RipSkEHEQSlN6LoW0RCEnRR2u2FGOdOwTJvWgBzDqIAYg4HEMOpnRGtrQBjX/vCyofYyDGUihDGU0oxjOkIUiQxG9SEbveE9SBRcq2RaTXSktZuFkyHSg1fH9AAdfvUMf/hBiyfzBZ19IAgQUAAEVEEECEsjAkRIAgQyEoRCGEEUvqNGMAR5nGMlAhSh6fKheDMM3jyhrby6ximI0kBSZ0MRhIZGzSByCDk1BAB0EkQQ2mEELWiCDGLrspR6UFhnUuQdM+KaqffrTXe/KjkJiapLwmKdEAYXHPu8JXJTEIx8vAQfiSmGK6ArITc+l4qEfR60DqTFb3BopRNDBXe04mozmVV2GYoqi1KF0zwpxhz1g4lBM8KEMcKnBGPKVBp28AQxo2Jcd1vAGOMAh/wiKaAY1nrFkWSTCKpNYDcKeGhqtPKySXEhLVa3qsQpj+JMj+8EPvGwHPPTBD374AyFIHAccnAACC0CAAo4kAAIkgADlJgACZDAJT2iQE4hFbCmYAwtl/JgXTRuFK4o8nEn5ZhS5GIwpMpGzVPCCFq4wxeMEEYZJ7IEJZjADGb4MWtHaYMx1gMQ2TtVeNONjzfDALTxgkh10wLmHPvShSPy5En/ChJ/AhYdK+sGPcKjDHddYxiv284nFPbc/iM6ogTayRYhEiCHlECmGxuhdlobXuuNFUQ9ZipFbefxd7qAHM4aShRv0gAZj6FMXVs3qNLDhDGz4AhzYcL9dJKYYWf8RhCYSwWurqEJ6WYGYIwkBBjBsb8JXsmqFzwKyUIJMCFowA/B+8gegfCEOO0AxAhiQAASYOwELM0GLJaACh5liagNhxCMUMYqmYYIWx3iFKHDRNMQOkDjuPs4oVuGKHyOjG720RjN2ZgpNMMIOXn+4FsqZBdHWYMxiqEMswNENq9cDJhwH7q3kAfKqixwdLTlRSl2Hoky3RLcp4YfMveHQYsF7FMfiueQkByBqBd2j3JpIt7519IdQmowhurTTyZsOM6pLHvuQPkzAoRTEYA2Q4AZeZAzIQCzMINZY7QvOoOzYgA3SQAmCoBSgITEQphAmIUlCwRMWKTC0wkmSwRH/9K5K4EJ7roSTAA/DMEwImMBPbCQGzaDxJkABCqDyEkAAAmBhKk8CTOAHpyIQnqc1EME0DkERjgMVioEWROEVmmEWSiEXTmE4FMEQqND1QgUZFqMbuuH2dkYVOuERAEEMIA74QksLWIAFzCQIxIAPpIEe7OEbPg0dPu35SOT/3Ezktu+knu4d0uH6dKsdVOL71CEc3MG9kIs5ROH8eG5APKgTPMQhGgJC4K9bIuT9HE1cNPFBJiLT9HDTNs0c+i8f3gUcnsGOygAJamAFaED4FPAMvuALrAAMHvAMVK0MhGAJJOHWrAEahGESEiFJmMoqEmzuFMwRKGl72sLv0AJk/8xiB6BxB1gQB4SgCxzO4cigCY5gB2oQARCg8jLL8kyg8qbCCZwgEM4xl4ARNY5QEUgPE4rpFvqtGVwBExoB9KxwOIpDEiBBEkqhGbRhGwRyG6ihgVYB4BShD+5nIUOLCUCgBVImCIKgB0SBG9wBjPBBvYDr6bbPDyUCztAIzvSPpc6hPMCjV+ZBEPtBHWYlV9pjGmKhFE6hE0zBFBgRuv5juSJx/oru/STkEiNkISZx/tIlIdKhE4+SIkCxJOIhHfQGtqwOHFKhB8qAC4BgtD4gC5qgCcRiDcSCC8rADM6ADNKgDLoADJCgDo7BGhLDGTRhA4kxLhMsNB7pwLrgDf+a4AdyoAbOggkATy20xwiiEWRI5gdckAkQUwiAAAg2gAG8ERx30Ad/8EgkIBDQ0RzPsX/e8hDyEfRwIRdGARaSoRZOwRTczTRa7xEuQZuSwhpcs5egoYGephIWIb7I8H6yALQckgVWoKsmsg6Y4RvwQRzwZh/Sgc1cAl5GMqUkQr1GUo0O4jkPoiNG4hzAo6BkpYj2php0oTlskhFBIf2iq0McYkJEUiQv5BLFIULQoROdsxPVCLxS5xzawSTUYTzM4ToO6qDowSZAqwzKoJzGQAu4QAEPzyvX4AHFogvWAAjYkBcWQxu6IRk0gSvkMsGgwRoMTCs04QqmAAh+wAb/WCCThqBEExMIFFOT0mIxSQYImAAIjqAIYmAHhMAGVsACIKAHCUAAxBEIL88EgNEyc6kQCgFKEiQTuCkTPoET2q7fkmEVMAgTeGNSDqQTjkp6MrQXnWEYZuEUDCshxQBAcTP4yGAMymkLsmAiMaEbvKEcZuU6qg4m8O88XUIkTeIczIEcPIJX1kW3SGS3Cup1psEXRIETKMpNpJSKmItAyHMcMidz0vNC2hMp4XN0Ti48RIId4OE+zUU/uwMdwMEWQCsLtsBMEfMrC3RBr9EMpmAK5icH2LAUFENClepCrcLAhgEaVMEqQCEKPhQHasAGkEAIzumcEBMISnQI/FJF/xVzMdEpCzpmB2YUB2zAAhgA3CRgR3vUR02gBJJESM9xEozUQCyhNCYlE4rDS9tkN5CUNLgpEjJhFFChFpaMMHDPaTphgPqgDEArWZPVnIZACbKAAsXgF8ChHPLhH+A0TtNhHM7zYc8zTz+kI+RT5QJRJGAOHsCoGhLHUJlIbBRV50aBUccDJLwFXLpl6CgiO8phUisiKZcTjdSFPu90I9iBVYZoHL7hGiDBBwRW+LpsCLogVRe0CyAO4sSiVW/AB5ZAEZxBMaxBK4BxEoAxERzGGapmKXY1FKggCV7US9JiCDLpWF0UMZd1RZ3VWf0ywz6pBSgAAhiAAcINKrjVR/9LwASsFlwdRhZMoRMuYVEGohEuAQml9DaoFIQM4dqubRFUkxNKYRVmoRZmYRVOgRQ2IRIAAQ/MdAgksnODIFmDQGCVQAloQBGsARzsYW7czB1GrmWp73VftxwkFiT2j9PAYyQEpx8WAtSwwRjmY0DEZoou6hM6JOjCITrP03PWc2UntSffs7xqlx3osyXytCRxVh7CgRuMYcxINQuYoMu0YCuLVizAVwvEgixsAFbVQBagQRuS5y0DIW/VzcA0ITBUgYKEoRDKAlhZwGz91y/LNjE1aTGfjZTSApRa4ALgVm7JjW7rllsbZgMvMxGexINKA4SKDIN2A3P5tQzGoL7/1mAN8MAPWgmDOmi5PCgTGOEP1sCcPHcNSzR0R1cJuC4WpkOOjJN16bB1YbeH32x2N2L/TudSRaJX+oEdxiEfxMEb7AEdIOpYPiETAqQRibd4x2X/JBUd3uM9vIUOj1Iki1L/RIK81EVWjI5nW7HLEFON04IJxJd8yaDLtnIrWSAHfkAJLKEuNQHu4jfuEgEUlEoTHgZhAmMSrsAIcKAFWsDvjOAIzvZ/ybaAoe2cPgkGLiBuGXjcHniTkyQRzBELiOAK/gBeL4c0IgE4ZsMQ7OAGViBY0el7E5AMtiCQxKpoHkEyDEEP1sDYBnZ0JdJMfCB0PTcIPsAD6kAaXEgm/xSC+o4Sdhmihxu2KBntikvCQ+hzJf4BHthIIvrBHaIhFpIlcqiYQ9hPiCW1HN7j/SjEi53TDyfkivXPdRxiHdiBcLR4dlqRCYagfP0SMee4Cco3fOcYBGDALVQjYZQn7uI3EKKHSVTBYA6GEvZXkdMiGqVRBZm1WdNWC16Uw7hNAXhQkzeZkzfQHGWgBcgkCPTgEBhFIAbCD4KABkDgXtTJBwoYCJrAKg2vLFXtDOygTKFVL3PAl4c5mIvaA5C6FKZDmdOBmV1X5LQFdjGkjC7N/oD4mufhH9QBV0qiH8bhV+ohEZPFiRqRnMnBIeTTJCaEIiQEZYvuI2MqKV/WHP+0+SWyo4doBR2uQRQ8gAaUgFi/V40DO6D5maOZ4ANYoAVw4At8zROIoNeEdBKSJxCcxJEMxhOSIAZi4AROwKI/iXxUdDFLNG1Fm4BxgAMiDxwdeKTvllst0xyJoAVqZ7ZvANXSgAy0brY/YLdrhwW0CgioFQcWE7CZYMs4WqiHWiKJepg9NwKQOgiaARzw4R+WuT2buoejmvqm2qRMilyCmCnTozvoE1j2Zhq6M1kYUU8bNa3ZQXTYOmWHbuhEkrzYuhPfAW/egQ5hZ1Y09hl6wANWIGyRlY0HO6D32WyHwF5qIMMSYY8nwSvecgPrdxKcgKmEIRcwHBS+QLNRgAP/PgkaceCi29h/Dxwx/fVYP+kCvjEHV3ukJdNH09EJZMAFcoAVV4AFZnqmZ/vGQWCmPwAE0jDIa+CThNxkni2OuwwI7PiOZ5gCg8CogblzGyACNOADRKEbUre61UuHXxfSXjeaN7G7IxEjSORWiqiI8AEbEoesec5DTsq6xsFDUocTfVJliQ5lkdLT7pvq3gUeZuIe6MEXuG4F/New1dhE1/h7/dJfgTkHjmAQJkEQKLsriDEwQIFqjdHB5gAGUAADLkCxQzwGcIB8/Begu4zLDI+ju0B8jQC1yY1HRzrWgfBbZyAGbCBETc0GghUudB1lbMAGtsqTQOkwjVYsbbEs/8cATctJdJtcmJ09mGlgBewHEN6wPVzitbAjPZf3QuL8uw/indVFjUrWXN7IJFLOV+YhH7rDV9ZhG5BhiUbBFA7kQNwcpRDCza3rzu982916Pc8TJtSB5kDV6lKXRboBEnpgFQs90REdfBXdy8qUDD4X1dYAESwBEcJgGK3C0ucuMAijgRAhBkbgAj5dkWFA1LfkMJvAjbsMyVPdjd+gC1gAxSpPpGVd1gMBC2odB27ABuCi53896H99ZLSq6IX7MFu+TD/YTAe2l5282TsXmFegB3JADfigFFCrHtDhHoJrH9yhOZNy2yHkImj3XNYopeqd+/70OudhH8IhJeeBHf/sYRt892lIoRM8CPuG+N4ndjzKU3mLThLd2jnTIU5DDhwIfo6YoQcGHZKV9ZyQ9QzNt8t82g76AGb6ABD+gBFgQ+Hksu6SKjaFITCEQROOAAZOwAIUuQVgYNS3xwW3snxRnaOboCymAAYgYMXJ8eZlvQSIwAlm4JOGHi4KWuiJvtmM/pNs+geQNbCDD02VQGxtGpiDufqp30xoIHzKIGaWgR7A4RviyZ/qKf8gViRLoni9/Vy+Wz6L+CS5ox/UPRzSoR7AYRlaYSb/YxSYLuq8W707QugAQly5cubMiTuI8GC5dAzdOXwIkZ49fPXAieoRZMUHLUw6dhzikYmWkWT/SrI5w+ZOnz6A/AAytOgQo0yaBk0KhROnsGSqeq4qVaqWs2SyPMnBceIEDBxMdXRswqSJ1JEjzZTUIiTJlCIxIDBgkCABAQkmypo9izatWRkziOyAkcOGjRs5YMCQizeH3r05mPr1e8PHjx9AQDLJghixkiFKkCAJ4iOy5MhBKlfuQcOHEj51MGnr9g2dOnXy4OV7xzDdu3fw4KVWvZrdudnkatdmhxt3QXO3c/tuFy94vHn9+rkrB0+ePHTgrOEC+mlUKXa7zY0rqJu37dmzrY/7Dv57wXDky5MfyBAdOogR692jR41PEBo0PHAMKZJkSTJn7JzBg0cefvzxkiEG/0aC4CaeOFJITqFoAoossuSiCien7CSMLKqYgkgTLJyggw5CMDFiE13kp0UWW4wxhlUnHjGFES1AEFYCAgiQAFlq7YhWCSWwtUOQcvlQgw123YWXDYAFJhmTNwQW2GCDFcbEEFYqgaUSS2yJRJZBKFEZmJbR0ANGY4ghhi/dgFNOOOrMw04/1eEWnG++ndNOnnoCN9w888STZ27CDepnPvn8808/4txzzzf7yPNON8yk0gpQoky3G3jmZEebbbWFVxB45o163kDlqLfeQ+s4VI979MQShBg0rGAffvqZ0Z8dd+Rxhx5//GHIITIdsggjkVRiSSefdDJIIYEEMskkif+EIky1GW6oYU+OnCEEDkkk0UUXI3EhLlUqsniGGV00MUUSLVCgQFgEEJCAWU44weOOPsrA7w5M3TBXDUfalaSSOERJmJQKRyYlEFQOUViWWm65hMRYfmnZfGX2MIQYQSgiDTjuhNNOP/H0w86gwgk66J57DlecnyorJ4+ffhaHqKHp3JPNN/iohs40sbwSCzGxlCJKdq/pJts5tXHHnXjeiUpqqemth7U746xHT6vaQIJmDR7U+lQTWuzHnx26ruSHS8QaaywllmSyCSikdOLIs3oH0lNOnoASYSgSWsKGEDp88cYa5VKVImJjkDEGG2aYmAQMFDCAgFhj6ejEs/n/qvXjDDPI4JdcNQiMw5F4FTmXZD8IAYTCQAgx5ewjdiRE7roLQbFjFXuZcRCYlekDYj2kUg064ZxjM3A2qyzc89AHR1w/Ns/zzz6G3mx99Yhqf4890URTTjz5VBNLLLYYY401wKQST3bYUbdp0+TMpuc51c2PW9XhLPQad6QKHeNIB6vogQw+9MEHLBjbfaJiNjPgKldrc0mwFlEsSkTCEnPbxCdMoYpMWGISnjMBtDShiZugUBOqkAVRInEHNnBBDomzChk40jjHlaQMZGhCEnaAAbDYaHP2eha+PreWtvDAXzD4wel8sAKDMSUuNmBdDnxwxRzc4AdY7CJhckAY/4ftDnZCQELugNClinUJS1kA02KGEIQhkIl4NhCCD+rADG+QB09O49P05lGzmhWne9cbpJ8Qlb18KKd63PvePtCRDW8wIxrv+MYzYqGLYFgDHODQBjLUYQ515OkcoxkNAOsHqvpNbVPW+dR3bBMq8ayGUa3phzz2cQ+L1AEPXRhCHX6gBS5IZUVlSEMx1barlfyKEMRaBIIiIbdMdIIULZQFCkNBwkBMC5uJ0AROeuIMZ5iCEYDoAxvwAId0leswWSBXuFhkhz7gwQxPkIC8clQWCXDuXkf8HFtkAAO6AKyKp2MBC06H0NPZoC9N+QsOwKgD20V0jEKAAhRyZ0bHhP+JMXG0UvDiiJghIIYjWeiBKLhxqH4gKmaApJkiX2qofOwDkTSlaUzl8Y+YKlIeg+xpP/bBjWpkQxrIeAY1LlmKZVjjGvSgxzdKOUo8jaY178jN/lTpHVaOw1PbieV1cLMP0yjnH/qgxzMUcQc4vKGXJeGCW4mZhrgiU0B/yMOvhOVMBMltE6QAoQtzAUJVpDBazpoEKFooDGg4QxaVMMQf8HAHdKaLcYhx6xSm0IUxqAElU1CBPemlIwmEwEdl4Wc/1QKkIMVuMJExXQ0O6toaPOkGS3GoX0KEW9w6Zre85W1lPNpR4FoGMWgSg7nKxAx3zBRR18NeTZ+70kRJt6b/hvqeofaBs0Hm46fokEY1rmGMVMQCGMQoRTCWwYxpeMMe+8gNnvjUGni0o2nvbQfU7Os0/HFnT9zZX27Cqkh16MMd4EhFHf4ABziU4Qcl6cJbx1CGYsZ1DXagq68IESxjPfMSHiQFKU4xi3AmgyimAAUKI7QTEauiEhj8wxnIAAfJlctsleXCt7pgBjvw5wRgwVEIzFICE5RAR6UNxGmF/CMiOOEJT/hWEj4yBNb6gKAJPd0NBGYXpgxsiri9QYh6C2bHiMlKZBbub7OgBTQlRgyYgcQ26jFTQvp0zvzoafWsN2d5HCp7++jzcr93D3y4AxvR0AUkUpHUVIgiFctA/0YqknuPfdQpZe2gGaD4iD+XaRo4mx4lnVbGjj6bTB3h+MY0IMEHBKdhC2RgsIO5sIUVQTjCaahwH371B2bKRMPHkuYnPgziZIRzKCMWtmKdUYxVkOISjFiEIe5gFXVSZZhbCNdlu7CGyK6AAgig14/RMloim6BzR9wXEZ6AhS9cAbMSVNdVshDlKScpobQdmL0f2mUv6yDMvR1zcMucMSUcprhook8PjEGPeyRqznZmafcYrtKc6bkf/oDu996BDm5cgxmQOHQsoIEMTMQiGtLwBTMm8o48CUfP8ghOO/ykp+YyMnp/ot71BkWzlsejzy0Phze6EYs69CEPeCgDq/9/MAa3mo0qZJDgGeCAB2Xm2kDFaraxOPzBU5jiFLUoRjKaMWwR5+IUmHiEJBjBiEPc4YZDCJdU3CpMxDSBC1O4whrWwIYaOMArCfi2WvQp7rLwywlYwIIc5NCGu7Nh8YtP11WizEUfzPZJsp38bK2sl9zqlt+7FdO/RZoYeAdhpPsRAxk+QB9IaIMe04WuSh1enD3XVHs6lfmd+/EOd3jjGtWwhvqewYxl6MIY0vjGyMIh0328HJA3BdTyZc5w2+eZZsWh2UzjAY+eXQMSQrcDHtAwBiUEU5hQyU9JzMAGqOehD3oYkIHeBpNIXEKaHvYgJ0zhilncAhasQIUoMCH/CY/QNo7FK1oQZXWEHyTSRkLgQ1cQLj8QAQugAKIVZDuiTyHgd0q2ZGGwB3sgB3rgBrqSYGwQByfheGy3Wlx0eVcmW3xReZmneWG2b7zleWUGemrGGIixH3WAJh6wAmTiC/SAXT9Fe8n3KNtlSzz1D/OgSIniZ7R3D/mAD4RkM3hWHKsyVM8gDUe1DMvgC74wDfSAD/LgDxXXZzZzS4bSci/3fM0lZ3Z2ez5FfdWHU/8QD+rwc8BQB3VwB3ewBkYnBK/WESPFdCgBdQBiV7mma8KiYZQgQpRACYcQCZlwCZeACZZ4CY9wCI91TmZggD9wAzhQR2Q0RlYCQVKhAQ+g/wAMUAEhIAM8ok9DlgEy4ASTIAh0EAcdqAd2BVl9iE6L5x8SdEMcATFSIm8sSBd78SR6gQOa92W89YydZzEWkxhZgmamRwZoEgEawAI9oAjacA/9oFOMgg/4EIVRmA+tkQ+FRByWhn3mI0g9JV3clQ3TwAzAwAzPgAzI8AuxwAzd0DV/FmjLR4SK5IbRxz0sdWdzmITKIY+JUmrYgAlBoAZ5kAZZ4DHk4laDiGaMwx/pBwd3FyB64Ct1hQclGSyH0IF/wAVrgEGLoInlhAds8AVswATGCDA1cEa7MzuGERIWsAAPMAETkAE/ci9/p0+zGAZ0sAcJ5it2RQh+MHR5QP90d6ArwWgVVFElqyV5lJeMerGMfZFvubVbujWDv0ONiqEEiLEFa3k2JaGNGgACPxAEqSCG8IB9phFo5mgP9sAofblT1qc9reEOuccaevmXjBJojMIN0cAMyBALxvCYv/AKysAMnwEO39A17nAP7sA9fbZScsZchgRxN1NdiKRTzFWFKrUP9MAMPFiVaqAGZQB3XMAESpA7psg4JDF3StebTXcGwckGaxBjayAEc6EFuNKHdhBtisM45ac7YXRGZZY7TNAFLAABEDCU+kSLoFMCGCgDT1CCd6AGd9eHvmiVflhMRZcGLLIFKpIFQtBGswOKWNSCydiCOaB5+tllZTn/gzTIlorRRhIDn1mANnsocLjCB4oQDUIYcXy2D+UooROqmPfQKhfaNV3TKk3FSd3godiADd91j76gC7rAC8FgNOGFCaJwKSwqCmFYD8XRDv9QhqFpS8WxXBDHcDlzmjUFe/9gDwVWGXnwBm4gm7QJd7eZm6aYgCOyO1GhH00nQeEiBHShBeGSYDH2Yk1wOyOBO7qzWrNTJWT2FF0AAxZAARdQARUgWkRABGlhblEQB3igNnagBroCIL7Yi2tgTGnApxE2Bu9ZjUoABJGhRXpxn1+ZW/zpjNEojdNIjbI2ErFmevDGBHbAGakADgnHKBvaVJ/KoeCwDdpwDdMgDdEA/3zI8IW+kD6poGiYgAkdh2qKwAcdx6KxKgqt0Au7uguKsId7uKCQIArbQA/HkRxl6A+vR4SguXA6Ko9F6KMNlz30YA2Q0AM+gAdFqgbGBGtuFVI2WGZfejtlYyLhYq5mUAZaIKZMoBV1t3hmkAUkEhI7eUZi5BEiRRVdcAQgwAEbgAEdkAEdIAMaiGRJ5gRxMKfn6YtUeZ5Et3gzSQZxFVeAmgVlEHpW8kWIWgN8waiN6oyO8Z+c5ztbogRjYC4YOQZkZgd1wAd8EJnG8Au6EAuuijSx2nG02rIty4OXYXAbgxFlIjxlUgdBUKuYgDRAUQq00Au0QAyY0LKAkAd6cP8IihCrsbANzKAe4kCGdWZdMmWjzjpIfRZT0Uqa//AeyCA8NQAHbYAGaRAuseat8QquZBoVIVGu5hou7RacPZQERrADRRAkOGAEZiMV+FGvFCUEI9GR+YoDLcABHHACKKACKkCLdOAE/KJkWICwdycgABIgVEmVKzGT6TeTfMqnfloGEKaDjTM7OgCW+bkXHvtlZIkEITuyXHK7FUNZKPsDIkUGLDu0c4QZ9CG8Pgu0GWMl14oRilAK0lEKqPC8qCC9/scHK4oKqYAKuooKvdAMpdBxkhAJjFAJmYAJnIAJhhYN3OAN8EBxrMkoBtlwMfNwVnhdfpZTNlqF+1AP3XD/ET2wAmiABl4ABg4Gt7YpcGOEH0vHOOfabg2sLu3it0UAuDGwA0bABEdQfh/hMBtMJbhDWSBxpV1QOSAAAijQAi6QAuGJBVEQBWFABYenfm2jB54btVQplVTZi1WJB3yKB356BjqYGK/jugJleaHYjDCoA08CsraLBBTjxE9MMUowFaGXBT+AkWLwq7IyNh7wAWODeisAxj/Ys8Y7PD0gBpJQDGl8DLZwDLywC7owDK/AfZBQCoomXqIACa8AC6MwCpyQCX+8CZwgyObrAZhQDesbDjiDS1FYM3fGPTLTXDllhEW4jm7YmtHABz1QAx+ABlvgBV0wBU2wBHB7myRS/512OxUL7MAOjGPtkgRHYARG8MpFcAROFhLhygSxQyVemh+6iX5fkASpAwMo4AIysANTkIsdiE5QV5JPSZW+0jZt8yt+kJ680sNpUHQUtrcpEmVm5LohApYsuBQh4mWT56hhBsVQzK5JcMU4WBkeY7F3YAMfEAHbqAH1rAH5rM8fwM/9HMY08AFi3AOl0AvDADaxsAtHI70eUAeQoAiQsKJ4XAq3MAuoMArlC4CZKAmSoAiKQB+pgA3f4D2LjJc2w6M6pRypqVMrXcmF1JqpUCa0EqhWAMpJMMqB+p4JqNMe2XRog21rkC7q5GBHcASapzu3bIpW4jAdsZuNczYx9v8FcjCcXAAEMEK6Uesru1iSuMbVuNY2gNASfcAH3ofNEZbNFaZjJZEFaGQ4uKWfWnQ645xvT5LEmyeyTQzFFsXOVxxSPnAZZTAEOLACEbgADbAAh+0Aia3Y9czY9pzP9eyDK1AHj8AJwjo0qHAKmRwEj/AIwqMIotAZs9ALq3AKnZAJj6AIgMAH5RRZcFAfBycyEUd7LWfSOZXSK32/qMnS60hI23UP22CtNAACGoDTIvxksZZ0HiFwOg2lXEAGXBBMzx1MXVAG1I1jJ1ESbSkE/NkXtzOuPGkYhrFO8UoSUNeBMYZOnht1Nrx+ikgI793VXh3WfSCVVjkG7GmRa2f/32q91oajn3StRQYlMHphOHTxzV6mF2HkMLy1BLvVO74DBUS9GMUVqD5wrZExO6m4AAfA4R3u4QoA4oct4g1A4gdA4hEwNnzQvKIACz9hCqZQCav9CH3wAUYLCfiXCSzG2WCts3UgQWwAxkGgek2FDzSKrDUKtsv6evOIM8+FS67ZsmqQuICadHAHBQ3uGFCABBZ1UVzO5UwgBVxgBWLOBV5QBmM+5mZeBuj63FxQ1MKsAxXcEcL0ykQdIkdwwdWJZqaMJStiQ03HBnWqsH0Iuus3IAPyB9EM1rh2CI6V6PRNzVSpNnkQqHdQBhKjBj8ARnoBBBvr6a+1AiywF5p+/6hZFEYK4+BY3uAPviUWVTHVOMposgVLwARcsJYssI0WYAERkNgk3gAO8ADBHuwRoOu6TuwWoAFjQwOHEICoLZVqIwYrsRIeI+0tK9Y9/qtqwwca8AE9UAfDmnCJwg/8UIbMSlNP2GcTig8Ryu4UWqH1QA/827JBwAVCYBVoEqjCJAVenuVavuVeLgUBL/ABbwVeYPAHjwYRlrrh8sr+Irix3BF2nmX8SdRHIHCI0REC51YRth+4UqeCvisMm0zSDCwtcegrAdZt0wdWaQdZUAOzqQQrEBmxVjxKoAbviQQ5AAQ3sPPLeHmytbF+wVA4IJ0QEztlhM64m85QPOtbsv/WVqIBFrABuv4AwB4Bwi7sjc3Y94ziXszPWwz2W9zFHkADluExxRUrxfWrZE8maZJwQ5g95hho6K7ucm+hoIr39MBJe98N2rAMgMCycNAtIyHrW6DvA+/vu8XlBG8FAy/wVlDwBm8FW1BMEcbwsFzBsWzBtRwkdhEDMcAUO0DUTM0RcBdhEgRhHq8rg17ohI7o0/zV79foLkYGu3IHfqAGlOED9BEZgUEDSiB5QSAEOnkDwP8khUp5lfeVUIIwCvM6d53qSw/FuBllNaDrH8D1Wr/ru67P3N71Xuz1YQ/+Yk+8G/POWLzaHW12NDC0HtADfAAMTYWh4OChHNoN3LD/DdhQqtOAqszwmMYAEL50xYqVKpUoUZgwQYKkiM/DKg/73GkCQwgXLWLEbNnChIkVKSGlICGJBAoUKSelWPFixeVKlzFZttySJk2ZMl26JDmSxIgRn0aO4MABA0YLFEhbwMBx5AiTJlq0eOTCBacZM1fP2LGDB8+dPGHFiu3jx88ftGbNAkL756yfsHbE3OkjJgsNJTVu3FixxceHvkGC+GBxo4aQvT5++Nhbw8beHJFzKPZhQ/EPzJlLbl6y2fMS0J1Djw6tZIgPMjU0rPbQ2vWHDxpcv/7gYQWNFbd70OjRQ7CYOnz6AFL06NGlTJxEjSqFCtUrWLOk48rVa9iw/2J79qxo3YNPwYMJGUIC9LCO4N40aNSe3d59expB1JRJssMIjqhZ9GdhwiXlSShIAhClAKGQKSYvEkxwJi/QsAmnLrhoggmekghKCBxa0BAFDkdAAYcdPGoiKjKgaqKqLnAaowwytrLjjju8CksPGvX4g8a2/iAkxx31yOOOPwzRowz98ihDoyFWYGw93GrwIYgbxriBhdwM+wEIyzK74bHIfLjshxsyA2KIH4YYwjOSOkOzJNA4Ey00JISQSosfbABMvd5+q6OPPgxZJBLkkuPkE1NOWeXQWW6pDrtiimG00WQilVQZSimNtJhkGi3mGCF+0MCCCPLwoYfZIjD1VP9UTV0tVVZbjcABByLwoYwmjtjhVhu0yMJM/fo7yaQCAQypQJBCQtALMJJNMFk31rgppwkptPDCDDm0NikQPYJKCzJGPLGqFXE6w0Ww8JgxR3R13BEtQtr18Y8Yx9BvCzzsEEy93D6IQAPAfFjhsBqodNIGzAjW0rLIMlMYszHNPBNNNdlsc03SQFOiTC3GpUQVVWSppRdhsJN0ZJKTacbkZlJuRpmVSa40ZWWSqVSZZSodudIaQAD1hz/2NdUDV1NtYGiiiy56gQWGRnrpBmyIjKgdmBpi16n5Y2JArFEaVoqWjl02WbDBQMNZCCXkQicLndIBhhM44MBDpGDQ4Sn/j7TgCEWdujDjjDLScPFFsXDMEUc/aDxLDxjxWKOMLfTIYowtstgCTDF6gG0FfTVY4VWgYcuCBRacXJjMyy4D4vQrF2bYTIojrvj1ipWQaogzslhEmJtL1t1kSVMeWeWTJwV+5eFZHr6ZzTX4IxINFojA+dWil+09V40+emmkG6ghhxZY0KEGHG4QwrSqPRL2PwJFWgkMBcFWsP0Ex8YpJxTN2ImnoVoYIQMOUHAhBqLMrW5agNzZ8rYGNsBBXOPiCljGEhavyCgPdlBDBcswhjE8iHE2EAKWwGQDy+VrX0BzgL4igLkP1ECFNqgBmbQwhBcygQxaOB0TpMIE1Inp/3QNg53retjDupGBDXhIwyZwJ7OZBW93uoPU7mC2skotoxnLkOLxmiGYTFxCXw04lZJo4AMnpYcGKlQPvvIFm9ZMrzX7il5sUigEOMJxCEzIgmmUcEdpAagkAxoWSrwgEpa4L2zsc9AFx0AGMkgob7UaSobcBoMi7KApQIAjEvazhTVkcoh5wAMcanKGFiHyDNzqG07ScIcVoaGCDYTRHexQhjtKDpZYmhILlBAEFGKOX4DhpQZq4AEbrAAEiyHDEAjmg6ohM3JKiGMHOwgEzJjpB2mKGBJ+yBE4vY4LMJyKvNTgCmE4ihiQctR1zHlOdF5HU+scxjjXqaljxFOeu//oxS6IYQxjHMMYnxjFJcZAAw98IFba68EKevCk3iTUSz0gYxnV8wEQQFSigIkobEBQgx9Ucgh3VEIWgrBRjlpoQALio0q6tpJltQRZyFIWFzB4SPvlDW1H0MHaOBQDI9T0CJW05H4MuAadmIENWziki0R5hjSQDYNrgBEF6QIIPwDCEFB9ZRbysAYgZIFIKvTBF//CLweswAGaqwHnPkADDfggC2olw+P2Y6aXvjQLnRrfHR0GBGqq6YdLwOZeqcYEjojhEiErhjuPUU50Wied1yFGYx372MY2yrDyjOcu7BkMzBoDGpdohB7QYBgWrGoFd7GMlwbjJdSmtjKlRS3/Qx1DxhqsgAUE4+gQBPNRjoY0CVnD2tYUNBOwMYilXqgKUcNFvxE5haYx0BAOaqoDIZDkjqHBW972hpMWNXUiMvIRBRuYh6gaQhGLIC95DdEHNZgFlRkEggo/gIclfAB0JoxAA3QpTPXYYAxDsAMi/dvWLJCBbDhZ5n7qeMfo7hU02ORIX3u4KyBIRV51WIV1euFOxJqzFxs+J4fbCVliBAPEkZUnMeLZCxHrExnR2IYe1MCFNHDhCBfVQAT+MAQnncZMphHCEHrM4yFAczGoHTJlUOuYK9X1tjvO7dV421uRvG+Qw/0tuOI6Bp1MSG06ACBTdHC6St6xwVwAqkyl/+KVBr7oRuxqF1TDEl5GNKIRkaBznRnhp7P8Ya5k2oth2FjCgZrqNlwNsB188AdAcMUOE+kDBJ31rAsyro77UfCCG3xpB4/GNPyRCiLFoAjq7OJR19lwqU19ahRjVtWYHfGIjyHiYODzGd0Ah3b2wIYj5EAIIIjAEA7BVbUy7EqUTF0OFPalxeDABzggEwtvgIMw51Y/uVVCVZbw5PMZC6VT/m3Xzga5S99EQjul6XPBjARmdnQLVoFQJnWSQDYwFSx+KAtbEA0IQBzCEPtWRHEeIQlJXKISl7hEwAleCX3D5QyrDW1hAFPfAxiAi7ACNjIRCQI7HGIiZ3Aln8Li8f87OIsraQA3BjMNO0xj+nUeFYNUzKAFM4ghCKOoTi7KyYsN80LnqOb5qVt9T3wG3RghNgYwmMENetDjEHvQghDwkISIasESlTmoD8bArTllnQkOM9OYju2l09xAMZQEAhOofXbAcgTbKgEkSmSyoLcT99uYvuC4leuUZkquo48zZRryAIcEAn5caAnLvQ8RpEMkvrz9Lo7BA54JyEc+E3/yQxn8MATYwIYFAl3AAyJ+gM01YDWw6SoIyACX4Rgi8YZAC+vT0uivvOgrmbxJylGe8gZXjCNDsEsWztAFRPqAD7PIRXUcpXPk47znPGc1ZAsrdKHHGhjIwEY97oGPpXv/xdhAWN4W0uMDJSDTwAY+JBnqcH471IEr9T7EnyJhiUzcgSOM3GlJ7j6+0WQbfeqzgtYA+ce4QxGT44iXsjun0BYb6rQ5IYMu0CQ26AI2yIMuMDYzwIO0yJF8Ky9GMA4ODDiFwARB4QQRHMFHgIs/UI0UugEkaAAD6LwHWADQ0wAuAowaEAMaAI6pMoQ7aL9HWIRDkKp9M4tGy4MhFIs7UAM0SMIkxD0mtL3RCKz9eDmpGBVMID7rKIbky0LL2oXkM7Vf+AVVG7FYgz5j+AVkQIZpoIfr2wftQKQyWART2IQ8EIOHIA5FaIRKiLxN6IRP+ARSKJRDcQVZkIXiEwZD/zyikTmEyNkCIdip6DKJJGjESrKYa2M7kbBEY3kJY+maA7GC+RkDLli3cKkKKJgWb8mbFlnABgy8BNIBBwiAADCAFXA6RNs3xSMvRmCERQCE4SiP4FAETOgETugEPuzDUSAFSWAEQLgL3HAAEFgBGLSABnjBB3gALmoAGvgB3SgLPsG3SODARxCvfRtHqCoLehsLV3IDJUSDJry0J9yC0Ug7MfiBtjKTLtACFqKw6giGY8hCXrAsXxAIXeDCLbSsX/CFgwzIXwAGhmTIonNIYzhDiUzDesCHffgH9fODSlgFQ6yFWlCU4is+kDlEYRhJQzSnDDtERmkGZ3AGVeCCOv+pAWbyjOgKEGBpE635lWBRH56MCZRKkExsCSnYgqEcSrfDGoyQihORqbNJqky6kT1YAACYSgAIgAFwACbAg8TLRUtYBF1chIULAj6oAw/Ak09Ljj88BUNRBVLIxTvIAi3QF6Q5gAWQxucxAIkTvQbgtdwQA9RYhNTDN8GUKno7RzsYC66ogyMZQI4Yvzq6rYmJk+gyO46aTP1wmP1YARAShWNYBmZgBl3QBVuIBVsQzVjwBWAISNKkhVt4hV0IzelDhs/8zGeIBtu0TWmohmq4BmzgBm74BnCgh3pwB3EIh3BYBeIzxHdqlMU6tcUyp5BhLGPwHUpogvaigWpCk5H/ApZLPB+ZAKQDWZCgLBb1cbuUCIklCEX9qK68cco10AND0IAAoEpYLAAUiAPu80pEyINFUIRD4IogCI418oD0+IAgsARTMAWO4ZhMYITD04IbWA0L2IDmsQAYpMv6ig07mRox6IM/6UEOVAR888+pwrfCPMc84IPEhBHaY5H/IgONmJcGY4KS8Ag8iiM6ygKN6D3LEEtbYIZneIaIlE3ajAZpuM1nkIZmeAVlgAZrkIZp+AZ0cAcqTbqkc4dv8AZv+AbgDE56cId6eId3QIdw0NLlZCdS67BSUz4Pe07HYhlZOIMOsgEaWBPthLL9g4mZyMS448SZIM9i8T+tWQI6/5IKA5KpVcwkQniDAqhKWAQAAUiBDMkBOdCRxCMEQKiDLwoCGyQa11iAATCAEtKDSFBQtvzKOzAmFrAvDTAACwCBBcDLAxgrzYwAGgCESPCDOKsE8QpRRZCE8tK3Et03E1ULtWi0pmolrqggNXADZ1XHdbOKqqgKbeGWMdhR/QgdwRAFWqMHLv3WKXUHfKiHb/DNbRCIadiGa5AGdFiHfRiHfuiHfdiHe6BSKg1XMK2HerAHexjOLDXTcxqnY2is5uy5dCJYRsEnltkELhACY6sBYLHJzZBYQc1J/zuWTNxEuHufk9JEnhwWwOIWRD0gOIADPCCEDYBFlQUACJCBE/84ARzoAkJAhEFIvLqogyqogg+4xghojQYYAKscgAJowRughARdhPOaCz1IA9iYweeJgNjYvMmIj0oAhFxshD6ohIGDvIK7hDqLBDkzDrA1DvIiW/IS1nGcKmPtgxqhkU4yWThoUezyL43AoMd4Ej6ABnAAh3cwh3Eoh3Ewh3RIh3fwhmzwBnBghliQhmzghmnwBnlgh3aI13mQB3mAh8GFh3EQh28QhynV13uwB3dAh3/1BsW6DhH7uVXjhWBI09NlrHW6p2NQhlx4JR2IjBogEJvUSd5dCfTxP/DUROH1ST1liWLx2I+VgqrwL6wwAzLAijNIIK+QAwUIAAGwXgD/IIAUwIClgAE5mINB0A48yNScrS9PBSigLYAR8LyhHdoFuIF28ZcV4Isa85d9KSGoDR0fgE8+kIRIuENOQA5iHEZO2IRNGEHJIzgF1tpK8F87y8Wv9MG0bRcKxhG39Yq4zaQzOL/zQyS98A0x4Fa+5QfLJYd2yId7MFwtlYZYYIbDjYZqeNd+CId++IfLhQd3KIdySAd4eIfBfQd7CN1+BYd/5QZvIAZzMrGhC7FVa2JVQ6fWbV3HkiwTO4ZkEIUgkLHvYYHutFgo00lt478DCV7i1dPkxUQoWF5Eat69GRc2YIMYsYICEIABEIDrnQARWAoU0AE5+II9qFQt8ABs/xTkBjiABihLDzCA+cQABkAACLiAiIPFAViAFTA2MIINDciLKYmAG0hBJcgDgIM8QOiETCCFT8gEPzRGUjDlUfgEYnzlEeQErj24Svjar83F8pJgQ6DgdkELGuEkr3AlDh6XgBGM4DgGcLiHedgHeTiHeLAHb4gGbPiGa/AFZJDSbKgGdEiHf8iHf1CHfcgHeAjd0eXheDhneEDhe/BXLfVNbtiUwyIxEGOsn6vnxjqsXOiDORICHQAd5E3eLma7Mj6WTvzT4OVJ3fXdlJhWA1pjN37jGNGBApjoOiYAERABFBiBGLiCL5iDOSAEIFiAgPqAWMXLQxbkqjQADIjFAv8YAAWggAdo6QEQ2gUAgTX4gzK4ASZw2NjSAwrKg19thOMYlFE4xlUoFLVM0FVe5aLmpz7swwGW5VleYElg4FuWM11E212m4BvRA7gIC1fiCirh1ODABG2ghyC+Pnygh2uIhm7YBmbwBWwAB2+YBnewB3ywyHkN3Xvo6yAWZ2/+h3mdV3Qg3Xb2TXlSBsqa5wuz51aLp0Y5hSBIJIf154M+aIEW405kn4IWT5X4Z5QgCYVm6Gl16OiV3jzQARgsAAUYAAaYARWYgRiIAT+WAzDQgyDojZ01gJk+6QaYzwBI2QCggANg7QI4AAq4AAQI2gJYAA2I2T3oAiaILcaQM0n/EOpBIYVTQGpWOJRVUMvtTlBTYOqiLu9WdmVZ7oRNkLws0lparjM5a4SsFlZebgshBGs7KAwfEIPy4ANj8FLhpAdwmAZr6AZq0AVq8NZqQLp9Tet6BV21zofAFmxxhgfO1dLDpicNrycOp6cNK0gQf80Q34V4wqfIEgZFEINqAxD/QF5M7CPgzTa3A9Tf4horEG2VEsrP5qOV4AIlgAq98S+XO4NMwgM9yAEHOICIG4ALQIEYKAIOAQM5UCA/UIPKiQDejsWyXAFFBgAKcICrfABRTQILUIACmAEOIAA1n+njfoAN+IJDIATWU4RNaAROOIVRWAVXOAVWOAVXYAVU/xAFVADvUhgFPDfvVh6UT4hlWZbqLFrgBobvOMNq89o3Xu5lw3wRV3IxNEg/4ACEZ7iGapiGaYDSaTBSX2CG4MSG3cSGbrgGbsiGayjXbwhii4xXeICHeZVweCiHb8Vwb+CGdkInJNawNfXHXvBHncsnY8Cs6zgFWFrxNJ5x8hyJiwWJF09ej3WJjrVJhQ5UL95EMICKs2FjUYJjsNAzXkMaBXDy2TYKHegCC4RPsjwAoA0AbKSBA4DFBWCAAuA1B9gAEHhBCGCAHWhpAhgANZ9oBEAAN2cBR/CEShDGQ6kFThiF7mYFV6gFWHCOViiFUygFkN9ukUf08n5qWJZqBf+mZf+N7/jGZV2+dBTNAx/xEbBIv+AoBWrY+WhghiONBmumtW3YTWvQhmsgdWmA9d4EB3d4h32IVyHO9R7m3NJtZ8h2bGIABmXnwi9cSMyiGWQwBl/ghWF4BB+4CC4ADVJU6O4M3mzvyW33SZAQkH/+XYFGlmnVGzfemzWIIPAigzzIghWosRswAijQASgAAygoAyI8LxpgQd4eAJ+V5BhYgDaf7RF4ZARIAnun6IomgIk2ACWPACVYhExwBe8eRjxfBVjo+FZAhdf/budwDrUU+UK3/UI37z5EYBB8dK21ZZePM12cYLXNM7fgkyJMP0VIBmuwhmdAhmeAhjOkBm3/MHpqsIadh4boD1Ltl4ZtAAfrm1d7pdJ7eAfjLFNg9wYqksigY//oa+LGGsOGZMhlkEhgCIZZ8AFgodH05ALzZDuAgCJFChSBVgYiJFjw4EArDh9CPGgFChIoER8OLJhQykMuXT6aYcMGzhk2d/DgyZPHT5Y1fyIRErJFj5Q2bfYQWqmoTw8PBwwA9VClh4EAA4wqYICggAEGF5RyuCBgAFWgBQZYBfrTQAQ1n1SpMmVqlKlVrly1ogWr1VpWrdyuaoUK1am6dk+ZKlWK1Ki+fT9xChw4U6ZLlypVokSpUqRGjh83YrTIEGVDgAD5+aP5jx8/KvP0yaOmDqdmzY4R/zv2DBkyY8aWMVtGrFiuYb2G7aKla5cxZtS4fXOHD5274u7svQun3Ns3b869sY6+bHr06tZhM8vO7Fm0aNKkTbuGDdu1adRG1ShYcMkS9Rs3CuTI8P38iw69eGG4EGL++e8TcuFRFyXBAccaa5ykUh+ZGaJIJZyY8gkhkXjCyCGN/MFIJ4r01EADBjRQBR80UBUAACcCgMAEEyAwgAIKwFDVVQs4cBUEEBhwgI5M/bSABVtY8pUqrpgFSy1qwUJLK2+xAgsrTy4511x15aWXXnyNAphggW1S2CWZWGKJYpREUuZjjFhYGWWEENKZH6F9dscdY2RxyVywpAYMMrocc//aK6iUwkkpo+hFaCmtAPPMNd3QQw9x77hTTjrvlLPcN81xk80zm3bX6TSfUmPNNddo042pp4KTaqOr1tNqq/R0Yw0fPRB0BBRocAFFExrFp1BG8tmHX0L83YefQxo51JB/8m3UURkHsoESHnKm1MeCbBoSSSemzCKMMLkIQ4olmzRyCSmciBGBhw30wIciDWAVgIknyksAAxAcEIMBAxTw0wENLFDAAhH4e8ACWFGFVQEKrHDIJ6e4UksuuMyi1ixswZIxLK64FaVcd5lyil6mYJnlX51skjJhYIqpWJmNRZammoRw1hmcedhhxx0/2GAHKabgUkwwyDyzTDDK9NL/yi0i63WKWaWIgootyEzDKD3vvHNPcuFMOk44zHmTaTbfpFp2o2WDs6rajbp6zz344LOP3HO/8802utDgg0UF4aprQUhUNFDgCNlnBX5eKKssf/kNC9GvHDVrOBhgpLGGgXfkoUfmevTxByCVRULJJqTMUkwzyaA+CymfEPYJJlWo6yEfkEBCw74lyjsvAAEwwIBRB8x48AALHICVv1UZxe++B3hgyCmz1IILLkfWAsss12v8ypJLriLlXXVd6dfJKHdJWJhjhg5zZGquWTMg1qpkBxx2+FCDD4CM0kswwcT2jDG9aKwWqCCU01yhF1SkwhfPwMY3kAOPfMBDHOEY/8c40CEO53AjU9xYldnWprbiEIce9rAHPPbxjxOecG74uAc9tqEIGtRACF6giBKUIARbUcQgBGkID4EVER/68If8AQPjCHcQg9xncm1YA0rggIfNbOZzhlgEI0Q3ilMMIxmmKcYwhLEKlV3iETT4gLpoAInZYUIRsNuXUQRgotzJqwBXMdhVPlSVAfyEKgKYylWukqOBBUESrshFLmoRPYpVDEkZQ4tcpvQ9kZUsS53gRMpUZr4xJcZMjpEM+yqDGZzpTA93oEEPaCAGWBwDGL4gWtF6kQtY5CIZcimF01bRJFS8IlHV4IY90FGOfOxja+J4xwXDlg1sbMNt96iHB/+bmba00SNuJ5THPtzBnGxwsBliEIMPlJCEJjSBCeJkgnoC5zgjXgQ/kyPi4Yz1QyRypD/LkkI71ekFBKVEJXrQDCEqcwhGRKISm+DWMJTRDGUUoxi9mMUnMgmIHnzAAxGYHSQwgYmKvrABBTCKvNw4rzcuoCgGeMC+tGKwphAAeAhAAANylCMdLYAFjFBFbYYxjITeYmJqqQX0okQXpomFFJEcBSc+MUlOeMkwh2nMyyKBpkVAlZNsYpMfCKEHO+ghq26wwxDGAJpXNEMayEiFNKBxDGUkoxe4sA0tZpGLhaZ1F7wg2m/QgY4V2gMf+ShHpfLxjWxoMBuvOhs4upH/qlOZahvlMY82ruGOffSjH//ARzWQkR1pROMZx8BED3zgA3CCU5xa0IJA3AO5/wDrcFaYXD3d6Th4Qi5ZzKJnO8HQBjTgM5/7rKo/AXqJh80ii6fjYi5Ud4lGNEgMK4ioKJorCkw8lw9D8QDxcCevAdCrKAEAGFZcqoADKMAAcizAihigo/PqyAAL0IAhXJFQLvaCFtSzXi2291ORiYVkf/lElowqmJUVBjFlkoQkyiSZQ1yIk4Zgkx6smtUH64EJeCgDHyQRDGgwQxfMgAY0lOEM1DmDi8kQxixwcRubHgMa0tiGo4jzNq1J0Bvo8AZgs5GNaMSqf8tAxlmPEYxf/6hSF7EYsi6AAQxsQDYe/7hHNHxhDF/s+Bi44EMQavADLoRTtKMtrUYyEh+MyKedhlNt4ZJlEdfOM561vW2BTqLbff4BW1SMRCZIAbG3unIWRDKFJZALCDXcwAc9EEUqCl2KVJyxDqWkgQe4e5Tk4c6l3TXpS12EAQgsxQAWIF6OHkAwB/hAEZhgRTGqRwtcJKkWjFzSI/Xb3/5qaTArM0yBEcMYpy4iwTKjGT9p9uAtzI8PgEAFNbSB2U31yTTN6CIhv/Ut2hQUGtboRnPu+jZ8XHBsNLZxNqBsjV/owha8sAUudoEL+e5iF7Z4hS1oIW5fXAMfkf2HPaJhDNQoA/+to/BBEG5Qg9AyYbRb7hVCvtzOMLdWnmWWAhJoe873kBk/XEjDGdJg8QPJSU76/ANlGHGJTXwiZKsYeV1IcQlGGMIPS0BCFSARC0RDQhSxEIUiZtUTD0S0AXkc7xx1ft2C+UuOEFAKUxSwaX+BwAIRIN6/eiAJTryCFkhKy/Za0Wqhiu8TWj/qf71UCUnY2sC53uQh1kSzqf7hwWvwqhr6AIliaEMb1pjOMprhDLQWY8TgGiRPCTkMXizDGtgYG3HgNmPnzDgbNN7FhZ0RC7nyYhe92EX0CDmLjEmsGMS4hj0iK49vSOMYtBmxKw4BBCDoIAdMUEIWWp8FLTBhcIr/e4iYF1d720OkIrJNs+IAxAWBj3YLYxj+GMpQfCY+cYoAzcQmOrE6o2YiEofwwxiC0ANI+EIXVfDACkQNCUUomtErkGgEPgAC4CnPYAdAkVFMepQFPGABnLbAA8x7AAvQH9NMWYAHGK2IUqCCWiAJI3XP9+yF+PgFYGTCliSVYYSdUzGCY0yG2U3VVGUVGpTBFthBHvABJzjDMwCDMbBGvqEOiOWCLMiCIbmCLJxFK/TCMkgDNjjHN6wDPLzDNV0Ktw1DTlFDMpTYLLACkeBFhGyCYRBGXzxDPfTDOfSDPQDD94lI8QmBDvibDdSQ671eE8gewimc4SwOOwULmsGT/38cEa8ohEaIVsCNFhZmwRZsQRaMQRq0YRmgAVb1kyI0QkCdjyIAgs3xQSxoX0SVXw/UAR/wgaL1wAqMX79pgANshXhZV0kBBR5RAAPEnwE4QP4ZzAY8gI4QgBw5gCBGAA1IwpJszMZwz33ZhauNApYoIAMqVSwKmFNFRtmpSdlVYNptARpkgRpoDiDQwjGIwnaEYDEgVDEIQzN4Sy2woCzUUnD9gm9kEA0+0IxNozcMniEcgh0AQjI8Qg9Ynw3UQA2wAAhsAAhEgAZowAoEQR0YAzjswzz0wzcwgzHEQhXQQN7kwA3oQA2sABOwITgRHBL9kA8dDhEVDpktHLDsUP9CqAcUaBnwaYHrjcEbbkEZ/MAPCIESBIgbuEGcGQKalIki1FwPiEihVYEGsAALaIAH4JwY9IEdDAUNrEAd0IC6OADAAA8kylHxPJoAIMCLOECObEDvfBcERIB55Y7AeEgP9EADeAAfAODIUeUqPBL4+IWrbYmseYnXzeL6zAwF+poYFF8Z4MEa1MEjtAJZUcMyGMNs4F3eJcMtdA9VCsMt4ML+PMNv0CAw4UNzANZfZYMG4F8EkIEs1IA6RgD+WQAEUMAFPAAIgEAOcOAydIO85QM6bIM2UMMu8MENZGQN2AALrAAbMoFAQg6ymFPttdY5FUvEbUR/xNMR9d5DqiH/8AFk67mhbnqWDwgBE3ABGqBBVhFC2VVRJZDkUPBBKqACH4BADOgADIxjRN0AG5RBFWAnH0hUA0TAKKLBB9jRpG0UvQhAvxQABQwdjtyfBfjO7gTAvxxABNRBo0WAB9RBKVDlVd7FXvCFq2lJrIFRgM2iJk2Gr1Ugm3BGFSyBGOTBGcCBGohBKYSVNUjDvfXJMSrUXLICKlilFjUJLVyYNsgYZFVTjQFHNmwACkjmCiBCLpjBSq4ADKAACrgACpzACggBHCwCJjxDNMmNPdADOESDNiRDHpRBGbSeEvjAG9aQEjRBEiQBGMiWeyAL7d0H7XWhF3oBa8nm7jGEbDFk/w9BZBNgGWgFSDgFSIBsQcCRQbRkTtrF2SEEVCZ0QhqV0qCJQg84AAegAAywwBlIlDmCwArQQM01mofI5/dl1O3AEfvJywEY5QA8AP09AFUwRX0KBQ0gKg1UgSQ4jX6uYlAhYKzJ2pcQhgO+DEBFRq4tGNpB2JvwQWjggYHUASYU2zZswzM4gzPYnbJ5WDP0gsTEUjFkDCvQQjNoAz3cgwn9wz7UAzdgQwZxAwzAAA7IQRfcgCUIAyHkQBLkgA7EgAvEwA2wABL8wSJAAjOAw7KuUNp8QzdAgyGogR28YRAEARaeZhJMxBmqR7Jc6Ziplpi500GCYbEYLJgFEURAQf+aMqxHcAFwBghAagEZtKluucE+hWQkWAInWFQf5CN09UAEnAAO4AALaEE+7gAKsEBEVYGikZ8ZfV+ibd+jBYAAEMAeCQAAuNEnfqIFOMACKEDCGIBECUXs1CcfPAKoriLWtSLTkipSxaID3trLgCWC5mJW2Yy1pMSDAgIuyJ01UINBKRs08CrqCEMy0AbZCkMtqMIqzMIzsJg07cM9/NV4bIMOfMG1KgEQbEEmCIMhbAESCIGUWkGgoQEgPEK6+ijcZMNh8YIY1IEaZMEQ+MDktmEWKAET6CuXJUTCESw7cWnCcelr1pNreqHBBshHqO7qOqyaTmybOlHmrEEecNz/8nHsKKCCKPABdAXBB7TAERgBDrCBFgjBIMAACJSj+a3scvHBc32fIVbUGmEFAVDvzeYsvSzMAjDARlEFd7ILH6xLA3SfJPxMflkJf5aM1iFgf8GiLDLGY8DMBGJLLnJGHxiiHUiLHczOMbwcNDQDkeTCro6Yt6AgCqqCLKgCKNBZ/iwDNUSTX1pTNVTDNljBF8xBF3CBHuDBGHhCMhgCGrRBg73BDSxBg0gCJkSDj+5DOcjYN1gDJLQLH4hBFthrFoiBG55mE2ypQr7mOhGRErXBOgXxOtkTEXtua5bZQ5TB6rJu63LBGLwugeCBKIFkI0jCAnKCKNxCMfCCLrzC/4hkQRo0wRHsQRfogBz4KQzEAAucwAZYwAd03yg810XFHO2cEXXJ0VJUb84uJfphhYdE5VOuSw8owiU0rVCRgpUMldYxMiNvJdRG7fs6Bswo2IFCkbXYQRlwQRmkAYXVgSJ4wCg0QzEowg/AAQpmgilogiaAAihQgil0giV4giccAiF8AizYwjNUAzi4g9vUAzhgQ3jIASI4wh4ggiVogoXIgjNoApiAgidsAiecAimsgi5cQz2QaDhkA64CQx0U4vAxKfGNgYB0gQ/78Of6sE0MsW2tszqZsz2JbsIVzpEOHz3TSRuC8/CNlhkQCO3eAcctghVfQhazgjAUwzEg9P8wnAIn9AEaQIEeQAEYvME45sAOxEAMvAAGgMAH0EDzQg10pYIo2DHtVEEDfJcc8WzNylEAbNR7AvJ8IqoHiAEgpDIiD9WoMjLXIVX7yqL6nAmrtiqvacY+9cEdpAEXLIENB4EYVNgpeEsm1IAROIImyMIhDIIjIEIiEHMxIwIoOMI/eSo0hAo3uEM9vEM9eEM1XAMCo+AJygIhLbM1eMvZ0oa3aFE33MO8fcM0eAckiEgdkCUcxqHxFV8ahK45I3Y624QQB3EQo3Niu/MOI/HuXeSRWrY4F584Tyw/j8Q+YSxAScJAj8IqGHS+OYO0QcMrqJEf0IQhiKMR7IAKvMD/DNgoafYfIBCaL7yc89ZxHayAzjEFHg0AS7X0ifyxUx5qBLSLInzCKjwfI2edI3NCJ+g0YfyXUlWC1Pr0JgG12W2GHmTGH+SBG5TBNvWA/eTBJkQCKGjCHMxBITgCMg9CHNDBHkz1IexBHDhCHhwCVFWCez2DNXCDXUFKNlTDAM91CY6YMxBp3g0DuOTdM+B1P8zDP6CDNCzD4zKoHaxBGTRBFxxIh9OhcKKBO5uzOis2irNzO0sOEUM2a7FT6boTR1T2ZQ+fxVkcYWuygKxBtMApIeBhJAx0yNRC3ikDh0mbNDwDLYyCIiiBH9zADVj0EzwBba9xDUQ5KT1CANpC/6E5F+3Y5Ac4IkrLUYnQSwAsQCIeaogAAvmeAvlEcyNTt04zIIBlgkVdAtjZ2tdttwTaonenHWiERlbZwWjQgL/VwBzIQebQARbEQRyYwSHIwRXsgSYcAiJcuiZMwhncwSGIBSgEsKLIWC+jAzeU4FzbdQlCgzZ8WC/0wtnedV5H1l4rAyf0gBocqRh3wRdcQYivgRuQuDqvMxALe7EPsYojZIsTERqAgRuAAbOXeImvVm3VExpYwRZYAQZa9hMfX4h3cvGBExeQQReYwezeAXgTQgRm9xW5whY3w15SQ7xTA4clAyb0gWdpgQ7Q9xO8QAzAwA0cQg78ABBUnyLI3P+QzdzzKpoe0EDAAMXtJMyjIaqORGUjpPKbV9Ij1/msRa1SEVh2H8ZXQsaBVcaBak7a3YFH3sFo+GMNtAAMFAIj7EEYEAEdCAIbxIEc7MEgqIIwIBgiTEIhRPohtLIjmIIxrtg3oIPboEMBy8IqsCBVuoIrFcOu0gIquMLlwZuy5kM+uEM16EIdKEGBsMEbmP0XfIE6r0FiT045p/0XgAHcv8Fio3gRG7EXkLhw0uGIk/iIyxN+uCGJV2RFBj7e433e671lk4EWbAEZlMEZ6MxKUMacVUImfAIqwELQKMOmbIpYxzs09IIoPIIPrAAL8CkHuMAFgEA/3sAHMMFy1ST/JqRCwoNfKY2IuuhIxD/8H3uvBwQBICiCJPBXIzsydVdSxtt5LH48YhCYnhcYZDiGIrCPrz2YSkwLHhT6HZTBHaxBFzTBHrA3HYRBGBRCIgjCIAwCIiCCJ1DCIUzCJCSCVheCJkw1TeVC4HVDPSzrPqxOhMw5IwNEKYGoXik79moUqlS2qoG7hw8fumuYgtx4c/HNF41f2rQB8xFkyI1fMI784gWkFy9WUILpGBJNTDRlaNaUKVOlFZZe0GyJWbPmR5Ufb/4sgyYNGTNkzjRVcydPHz+ADB1iFEkSplGnXOEqpkxZs2fQoEkzC81Zs1FiVqwA0QIFBxZJWNy4YQaH/w0aKz6IwSQKEyQ+depU8RChQeIDBgoYWLDgQIMIHjzQsFxH0SNOn0Z98vyZUyfRojeV3sQpU+pMl1hfqiQJtqRIjWJHmt0IdyNFuw31NkQIuB7hwvPcWWMHuZ00abqs+SJnkqNCmgqFSXR90B5H20FZ0qQp0aRBiCZRUiXrVC9o2hzu+8datehPnTiPatUqVSxj0JTt8mUMG3v22ececKKpo4cb2ihpozc8CgmMLkyasIsKT2opJytc6uhBMGQCyiY1RIxJpRJ5+tAmNEwsqqctaJqpDDPOYGONNe7AAyo9/PDjj94UkeQSTkppZZZddiHmmGXEIquZZtLqhRO2bv+oywY4mGCiCybI+OEHIJj4wIMqMJEEkjLrOCyCNCNwoIEFEpOsMhp6oCGIPn78bLTRODGNz9Q2UW211ip5DTbcbMsNUd58A45RP4bLQ4870kBuuTLS4KKMLo54bo9BwhgkEVk02cMTTzRxxBNVQlFVE0RUUcURSjwhxZVjpOmmHnz2WYVXV2TJJRdhgh2mmGO+MsaYZaCxhppouEnnn33qAceWHnpgYcGLNLroJQgtZHDCLz7iEEIOH2zjJqBiElENmSD0EMWjYhLqxJi2uBcNEcsYo4wZabQxDzugKi4PHglRpJEgt2qFoFuIDSutJpsJaxhRFAnChx/wOGOKPZj/yEMIOTqtgQY+RlGkCkU44YMyyiL4QIM034yzhyp64AMQSUYhZZRR+CwtE9MAbQ0+1gYdFLZDG7kNUdwUWZRR4Bx9NNJJlaNpjTTKeKOJLkCNgwpBBNFEvPNkUWUSUNR2hOzvEBlEE1NWocVWh/ApJpmwwHImLYgnduaZZQRfhppt0Hmnn33o0QaSKvbKFqMFyQXpXMkn39Ajc80dt9s23HCDxc8/vwlzmURvl3QwRB/9phEtbepfPIqTXY88IP3jDj8MWSSSIDnhZGFaevnqmImbXAasZnZB5RGB2UDkiD06HkSOFWhQZBVF5PRhTsvAXAFNNS2joQrC6gCElFlW/zHFFKD/BFQ1S+Qn2uijJWka/9wU7S3qqam+oyhZuBQTysCFkHWqEE8Iww6eMIhCDEIQg4hCEYoQhz0YYjuJEAQiErGHSIzCFs/oBj3ukTcnNSlizSALWlTYDGSI5RnT+IY4EkePZVQhCDT4AEZ46CBuUY5D3OqIgzDHOc1l7oirMx3rYvI5c63uc8hhV7s8p0R7uSgmaVgDG2ZkoxutQXa2s50e0OAGPfToKpd4hCQy8YlSrGIWXile4J5RR2qQJRmj6MMZItGFPcjhCoiQQw5o0AhS8GEvGgCTZXrgAx+AyQNwYmQV+GCzR6yiFuo7xZ/od4lMyM8SgjraKF/DtP/8OW03T4Oa1IZjRtvZwXUCy4PWLnUDHBhBEGHgAQ9iMANNxKEFLohDDKaABSqwbRAOpAOoLpgJWDzDGiPk2zShQY06kuUZKmSSM6BRR2lwAx/9wEc3RFEFH9TgA3joIQ+75RJ2viRynUPiETXnBilasYlQ1OfqpNgufcrkXj5BQ41gBwc8HDQNNzrojfSAKTD6gRC784MiGJGVTpDiFLkoVli6+QxqfNQa0CjGycqwBjCkgRE+kFMbl2CDGpxgAxqgwQ1qoIQtqJQGlKlZzfigCMJgghWzqIUrVtEJToiyEpSgBCkHZRunOjV/qZSqIVTJv/4Nhzh2yJdWy2AHfmX/oYBc+IENjkCdJOwABRS8wiQKQYco8IAIFkREHAYRhyvQYRJ72AMjPjGMZrCHms6ghjaoIQ1oKGuFZLmjYh2Sj3pIgw9luIEO1dnDbGkODO+E5w8thznNOagjbsARcvC5T9N+boqmLePq1JA1M5iBDQc9qI0WylCaaNEOZySEGvJgiDRu4hOzmIVG51jNO1IjpNA4Ri44YU4/DIFOn+BERVoAgxN8QAlLqEsWxhCE7vFhMHwo0484gUlXEFW6gkpaUivh1KYaypT4k2pVrSo1iO4Iq8JRQxmeMpM7qMEOZcADFzDFhSR8wQhzSEQvi0AFOoRigU/AQhii0FY6PDAO/45Iwh4ywQlcKMMa2pCYQcBCjGIUYxjD6EUvhpEMWsRCGcuIBTC44Q580EMXiiAEHsQQhMoO8Z0YkYNmIQfaIwqRnqDLl0JFe1olK1F0q1WylD+HhymLaA1wYAMbDCrGg0KqdrL7w3B21CPd8Q4rltjERVEBC1wM4xjJUyxymdWMVuxGh0HIhCHQuQELOEADOcgBC2DGPWtRspLgFS8mTsGrVZyCFNINVFNH+VRLR4IRp0SYbnxT30bpwb7C+RykitNPNNwBgGVA9Rm6oAMczKEQgrhwFJ7whBZ0QAZEeELY6ODg7LBNE2dbRS8Eq77zProUpzgFJyKNiTFxAhMLQf8GM64BDnTcg5xUYYMYxFDZdYL220a2rDzpWU97CszKTlbtaakc5XxheYtcDqNs6U27R91OKlSh6tKC9Am5Dfdh2pTGR6NhWGXAApFiIIUfVmCGFiiyBl7QARhYAIUx9DhliuipxlPGCa482hSkMKpr2jub9pb80rZhxMpRqSj6dpp/joIoIfCbX0cV579o6GeNtLaGkIEiDHPAQhSikMsnjIAHWCBCGMIwieggwhKUkIUwSkMKYSSjGZfYhNZBYapT/SESjwCEIiAhilhEYxrdAAc9vuEOejBDEYAgRBm47e14Fjnc3yYXZj3LIdSKaMr6rGI/7TA6JhqedYcX3XL/5O3lPOABDpH/cn4h5Yc+SKU3i8j0GhUmN1cM9ysCj8boodGMZLQCqICgwSFs8IEb6OALG2aBFAjRiJ6Od7x8eMQoHG2KUowCNa855cqv4lTis7zlvUElzOtb8/zqaMw4h2UeZgLgpthBC03QgRzmIPQwxOE8CcTCJBIRiEKEh22WIMUmSqUJT0zdGWwDxXfIBgpHMEIRf0kFtbmBDm9k4xvQwR3cARxSIe70gNuCwA3GDcjyLnLeqe9egu9QK3SgCF3cYETyJfCWSMpMJ59GR4tiC8zEKPK67IzG7A9SsMwsbyqqQvMygzaCxt/kxs2IIcbq6JpOSBmg4c4e4Zyg/0AHhOAI3gAKDib/WkEUACP3GE3ZTqFnficT2it/jq/4qDDT8of5svA3aM75hINHasd2/ksP9sv6zuAO2IAMmkAOzm8QsGAQQEEVCiHW6IAOA8HpHAERKOFP3I8SLOH9hMHpEoEPU4MTXkEXRKge7iEf0CEc3gEezKEc3A7uAGEMlaDHFvDuiowk8g5yys0TQwsDK3BeiCJdbmKf1oVd/g6KsqzLxEgPIM8EU1AW/4AQUrAWZ5EWDQEQqEIRIqEStK7DEgIWbiEYigeFmsSOpCEYSgEQ8sANdKAGkOAGgmA3IKEYUwEbSwETAIEPPqEJnRD4MgETpHAKrZAKE0WVeP+DEEQtJkDND0DHjHakC1MQDIvjKZIDH8kADyQEFNjKwuLg/CZhbCYhEJpu/l7FEc4mOuJGFiYhD6MQE0rhF6xh7UhoH/zBH/LBHMahH8xBHtyBnPhAD9ygu4JADNwAyILIATULyS7rE0GRRYqiRIpCXvLJJmUiFTFQDfRJ8mTLdnxyjIYDF29RBQ0mKqaCohqhEtYIE4SkzW6hF7DOSbBpGqwhpJLBFPrAnHwgCPiATEThF3wBG1MB9XpqK5oQ+KDNNeIrNzDNHIkvUX4D1Bql5iJKLr0w1IRDFqVPRMIwOcjADrpIPHLJwh4IbjRhEJxuPL5jEoKNbKIuVSCB7ET/ARikwW50JR0GxD0GBB7ygR2kJRr4QA0yawuCwDTxYIiOaBP17iXLzYg8gkXwxScyxApocl1isiim6N12ssq+TQ6G7A1+Uzh/cw9mkRDGaMx0a2AmajfELjOyAnhOAeBMiCxCLKRC6hjKMgjKzuyQIRbG0mL6QBIw6tE6A9ow4RIk4REa4QoRxS3fEv+aZr46zS6hxgvlUShT8PEezw1Q7Q7wsQ6chw1gLzyuQxASISATgQ4c4VVaxRECMTxMJRNUIRUqkxsEJB7mIR7UoR/+IVo0cx8g4h7cLhWqYAveoAu0IAuGwAf0ICUX5CNWMyOA08gyh1tq9F0wayU8EF9I/2QldMIKBOpF8gU31SANkKK1WusoAE+0XhEP5CAP3uBJ80AOphRKizM5T5AWcdEWAdMO8mAXx44P+mDs1qjDGg0WiGUqrZNZVsgZekH/sDEWbOE7UwETFCFIlG19nvAS0FM22BN/nuotT8lptHALg+M+pwa/XFE4AqxfZCkPzEDL5CDB9iARTEUQYI0OEgEOLeFV+pGtDtT9TMETTOEdIGJAOtRDV/Uf+qEjo+Ue0OEbwIEaIKEOngIO/hM5DqoEJS/etgxYV5IB+Q6I2oAn6AUlaHMocLMolGyLeK5G/kWhbuTx6K1aHY/UkPMP5HEWDYYQwjTzNM9QYiMT6GMrhv9xeJBxzj4Km4zhO5OwFLJREgChETjh2NbnE4BmNZJKqfpQqeTnX0Ep6qKuEq7QlKpqR2pRRBzlKUREDLagx0xyC7KAK4NACUxzCUzTNLmnBmzgBrQAS27JupJg6hrywugAEYRBGN6mMdnK6b4D2ChBHlQ1Hzy0Zj20H/IBHjQTH+phcaxhF8wHOf4T1Uow3iIPWJOWDXwz3OhpQ8DARIaiRHTiR4F0J3BToJpoJrigQipky7SMRvxToeqtJw9KS/Xg8qSCR7o1YWuRRyCq0zbNNoCkw4TkFFihFlisuBQrsboJGWxhLFEBMJiNV07BFPJ1NQgWqlLuqZbGF1WuPYn/72koyjfuSx4BYUeiIg/60lHu4AyyIAu4jdsIQ3SzAGOAwAyu5AhgQAFgYBJkQRauQzFlJZnURkER9A7vsB7ewR7egR3MoR0y1FVDtB581mfB4RqMwRYgIQhuVWBqBDlKEFiRVst6FQ6ElchcYlyg9keHgl6oFkij1kVAZAz4RV7apYC61lJqhH3Z16Ai7w2ud2mvFw5ERmSKU1u5NGrcdltpkeYiqj0N5Rc3I9lgoRVogRdscEmeIRpwcPSkIRqYYRmOgRhoARUaTdmAb0wkQQqVJuxg4xFCuBHWc1yxAtMeAStkA4UhlxEWwYV3YxEOwYUP4RA6bRerIg+y1A22/2C//pMMxGAIlKAMyCALbOAHaiAHDgACdMD93G8PDtQSHMEPw4Ns5FAOr+NBB1BAPHMcwqEf4EEc3A4ctgGCmSFwxJIPxADAjAN67cB631hptUVGm3bvICRqMaRqrRZI7wVE9qV8+eVD2nc5tGiQofV6h1Mj5OA5hlNkqpV29JdRbHF/63PT2JMROK8pfw8VWgEWjiRJlgEHQ7ngpKEZgOEVUAEVWOEUfu93jIYR9g03Kko9HwH5dGM3coMR2usRXHgRVhjTajjzdjmGaXgX880Q/ABSjjMP1oDAhEAI0iAL7IAMfEAvaMAHlGAFaqAtPsAAWMASOiU85DCZEAHqOv+oEAKxZROBPPYBHtRBHdLBHQRwVsc4GpDBF2IBGYwBGYoHE6yljLKMoM4g8tpXkAd5ObAXI542JO5YJ6TAaqXAoa0AoidaCu7lj/94C8bAoocUKJajRiyFkG9ri964bL/sJ8MI+rh0W2euf+4rongj01K4KZtyFEqBIHABSQSHGcx4p+sIGXThlFGZFVCBlf00E2Z5jdRzNs4R/3xkN155hquiN3ZRHpH58sZUYOxgRUF3CXrMkbJACc4JCYRjJiyxxzK2B5q3DuykYA/BEmQBFBIhmZLJ6chDOs65MQWRrWQ3H/LBHuyhHggQHLrBGpgBGHxBF3zhF8aCb4bBZnz/ICbYNw2aopAJ2qAHGaGJSHtTgmp/lKIbeqIlGgpGGwogOqBOu3wnNqPNt48vO2sIjAsmmxUlrycl7/H8c4z6oH+rmgt7+1t1hLcpESkpao2YkhNEwaZfIRb+I8aWwYwDhxhiQSAEohWcML1gIz1hoznZszdWTgunJnemwvLsQAw2N2NNs3ushS8+4APQib2thwZqwAfUAG57oxI+gRRM4RsbLViC5epkwRK+gGySSWwSwRFIRRMEIQ7Gj/wmIRTAw/3ajh7YbhuqQRqmIXCQQXCaJKTSghOsZwWQokZ+4gwmm7Ir27XLrSUrh7MhGkghurQfmqJJe7Qr+l6WYAlO/xvHT3t8aeK1Xqt9u4ALmgBTzkDnAEyKkmONAwY5+CAPnDxtWRBzq/pyAeHyduTyouIpyHR3QjiV1uh3EqIVYkEXbFBJAucXYuEVGKam01I9YdgQlibudvEO6K4mgHgIhgB0vauRekCb26ItaAANlMDPAf0DaAAzHqGpMqFnyNMVagFYIj3SVZbSKT0ZLj0ZVFYWyHkQEOz7xu9SQUEYZCExZY0OBeFsNnUSwOEbsCGCNXwZYP2EpskZkkEWlGAvVsCgYaTEYceyLzsNNgckhCgkJmclpKC0Q7uhX5zGaRwJnn0LcFzaczzaqT3atwC2uUApZKRru70Lhrhf2IW/9P+FJhr2Vp0c3RUtbaPc8vLNytedMO6ADAjDDsaUKsaUTJ/zL4RxF4oxSSh4Fwz4gjVY7OrANFl0CfLA4A1Nh1qmZdTEA1agB+ogvDbtES4hv1dBleGoFvK2F/zbv1PsxEZe5Ieh0k/+5IFFFRCBEOpqCmKgBYggCsKjU1T2ik8dCy6sQLXhGZQhn0F5LNiVLJxhGHIBPTZBUjKafc+gDOg9DYBVkAm6RjaHCzLrsl7zQYAUasM3jxu6xpEACqxgtMOXe4dCCpK1JQZdC0B27a/kB/ICCHAg7oXApW7AiIHAYz22Y2uASvRisuT7BhyJe7hSCbKLu1R7DLJAC7iES2z/wPEdvwY6dggSH7qsxbtMEmd+5C9smqhHIQnH5BF8Cod6AHwaIKciI04+IK1NUwx6KjY2P5Vn4RZwgfZxYRdsnxdo3xZowRZq30hunxZg4RVggRfm1BZewRaS3yCOoehzYahkAeQOlxQsgREOgRA04Qqm4Au6zw3DIIGe4MLWKhQSIQxkLecFQQ4LfBiQJCxUiFm0ocNdYdk2Ib8Xoc6VQIBMXGiboouyprLbFyDgtBnYBgwYgm8KGjy40IuVh14cWpFCUUrEhxMpWkEixQoUi1baOIzoUAoYL1KgfJTChQsZLTBjMoFppkkXJji1NNGphYsWJEx8+kQiJIcSJlmQ//wIkmVLmTJDlojZsiVLFiVCgADxUWPFBw8ePnzVQFaDWLBow4pdQYNGjzqKJGHiJKpuXU6YJEFSxIdPXEl9Hj1SdAnTKFesYL16BYsWrl2QeUnepcuWLl2+Ll+2xblzrFiWO4u2DAyZMWSoly1rRoxYr1rOSKkpc4gRHj1ddOi4YmSHkSRFEk2i8+RJIeJYBIWas4MOnTBRnoTBQp06nUHHlEHbbg2aM2fJZKn6ZEnTIk+mNJ05w6SMEjJnyJCpQ7/O+vv479uxo0aNG4IEHQTgQgZ5cRJGEEmEEUUqIeEgFA8+CCEUCBpYkRUXtWSGFvCdYYYdZ9xxBoh55LEHG/97fBGHHHDsgYccbHwhxBFdJIFHElzoIIQQPwhxww1AINHUFkjc8EMNNbCwglcRNBkBWRE04EADVFZpZZUeuBUEXJiIUkoqqbTySiy3PIbLmbzs0ksuveDSy5tr8jJML7xohllmlY1mmZ2+9OkLMKehxsygzzwTTTTSTFPNNds06ug20SzjWi25qDLjETrI8cYcdBSxAxXAxYBFIFTQEQgRdGCRSCKCYDGJINIJMggWUVBBRRjP2UpHM9tt14wwwshCiieaTOLJJI6AAgohbMChxRhCrCdfGXWU0WF+2J5RBhpoDCRgQQB6y1CBFV4E0UklpdTgRyqplKAUEVp0kRT/S6RhBnx4wDHiGXjc0ccdfuSRLxtTsAHjF1wI0UQSP+iQQw1M1HCDkiCAwAILNHzFlldnqSVWlGG1tWQPYojBByCKPCLXXKOg0kpjZz42DDHBBGNMzTX/8gswwPzZpy19/oLZZX727GefgKImKKHSND3N09VUsw033Xxj9dXddMPN1tlk8w033nDTaDTAHFNMLsKYUkMLOzwxBRUxzPAEEU/wYDcRYUxCRBQz0EEEFcolgkUY0BVHOBbSUZEcHVHQsd0xuMwyyiemqKKJspNosqomiMCBxxhpCJHFU0/BlwYZZqR+r3ysT/sUtwF6Ky6Bs49UYLpWoIvgRu0yiMQS/z/cgARVSyi1BPBGOvgjkGOMkcUQPgThA/Q+RP8DCzXYgCT2GoBg1gcaNAlW+BosuYKTH/QQRBUm+yUXJ5ObskpiubBZzDDFFJOdMvwfcwwx/gtga2rGM2MYg2c8Q5rR/pQ0ngnKUIg6lKKwwY1vgAMc9MggPeqxQXR48BthA9s36GEPe7zDHelAx9VA6I0WegOEjZqGMX6Rv7QJIQYikIHfksM3JySCB3MrDhWi4AToQEcQxLnVcwTBxOlMAleDKFUi6DAMWJSCE5mwhCfKA4pQTGIShSiEcP6whjVYZQxbEMNT1JiGNJQBRNhqHelgJ7sBEWhctzOIQghEEnNNxP8jHIGXUpJ0g+ot70ddWYGSLnYxJNFgBWCJgAfEB8kGNKlKTmpAlmoQhC0BQhIq4wQpTnEKVswiF/jLXzKS0YxWutKVymhlLPmnDNXYUmm4RAagDLi0pTHjUNGY4Na6gUFwcHCD90gmPvaxzGbu45nQhCY+pnnCq6GjHtN8Zj/2cQ8TumMc4ghHC9EhNmogwxfBKIYwSHGDJKQgBSTAQgyoUAgevIAIM7gbEfaZqkDM4DhUmMIUnpOqMAiCVYIoBBPpMETqaEITXKSEJcpjCkvsQQ6I8IQjDvGG9pQhC2jwwRhIR9L9wPE+rpsjGgSkxwDd8Y4RoV1BRkISQEboBrr/+VHwHukVsIjlLE56UlAnaUkP9IBkJ1MEIB6RF8OcYhVQdQUu2IS/AO5PGfvzXyxlOctl1LKWzbClagZF1kIVSoKKqgY21JoNsKFjgxusxz3kKtd74MOudp3mMvfRj3/49a/7+EdgA/vXwgr2rvZwh2IVm9dnHhav6xiHB9EBjm5oYxm/MNswSEEGHExBBhmYAA9mEAMcsCAGOwBiakdbque44AmCmI5zblUrOkwiEbI1VSCmE4Zi+dZYE9XEIRzxB0144g+EaEIaqjIGIIyOW2XgAunSsJ7VsW6kJC2DGrjFXTS4obvdbcNKuUUV8G6heD5wkFJ+1BaR/fSnaDHf/8ZWoL4gjIEPfnhEIyRxCcqREha3eJMq81cMrB6jlWbrH1b5t4zsLAMZD86lhJFBVkJBcBrXUCvVLphBDtbjw8lUZjb3Gs0Sl7ivf+2Hilds2BSvmMXMnGY9FivXbP71rnqd5lzp0Q2yEUOdrsiEGY7QggtwoAJPANXFCjEIFFyBCpxaIkMT+hzLpYoKgyjEE64TBVwprolYIFYoQKEJVajCWKogsyUwZwQc3IAGhZTYIX9kyEJW784SQ5IN9twDkdHAkY9sb1suJl+OfSUtQRVffNniFqSijKmc+EQpUIEKV8ACFrOoxVTXBCc4DUMyadoFL3QWasjsok92utPRjP/mwAr/MphRw0bXRIiOxbqjHvYIsa7zQWITDzYfwG6xsP364mILO9iGzYc8nlmOFnYtG95AxzLlIY9/vOMdKgSh1zh4DdP8eBXD3UMLYlAEFxQhDKUqxBdBIQhhaEIOe1AVE/eJRDqI5zm4Ig7hboVEdRciEHQAhScErolQEOuhCNeEIxCxgxwctQc+AJINbpBnGxz1Bnx+uA1WkCSMteWoghY0yPvc3odHr5NBEEMdkpoySchF0qU4BaVd1hha3OLmuODFmUxdalNTJtWqxpNmjqZAX0IwUYuiYNWsVmvF5jrEegX2O+AB7KrnY9hYP/bVs/6PYhub64VdMTvC8ez/rn0DHsT+Bzzw4Y6rhY3HzGhwMlxhBxzsAIlFoEKSn5AIWbwqEYCThTM0cQRZJecJXX5CcuYwh+QcJxGDwNVx6KBu5wSCzAPv4kO/WKxJkHkPQsCByX+wlTub/uGo7zOSAH1UlKt85ShTBCTeJ0pSPvXSmY4ZqIfxGFCDOjS6+DlnNrOnPH3mM8Uneml8eSiks7WFVlOsXHPtjqnDAx7ruD61qR2P7svj2te3umP/WvXClr/F+ZiH+tXfD/YX2/1ej38/rE7/+uej/fKIhzieDf13+NUf8wBs+wAPLOQN4BB3XpULfMACLcADqRIFRVAE0hEGifAEO4AFO/AFU+B5/3swHbISCNEBK1RwBXsQB8+RCJoAHauyKsORUIVAZmNGLAcHUZNgZo6wB00ABEtQBVWQcmKAcj5YMmJgB33BciozF/ATc63gCrOQaWxCVcMQhfczhVFYhcTge1g4apnhJ7+AakSnQAYUKISCKGmlVrImQlcDDoqFDtf2DumQDuUQDuGgDtfXDupgh+pgDubADufAh+zQDusXiPOwbL52fshmfluXbF4niILYffAnfygGdsTWV/NXDuJwieJQDv73D/7AD/MnD/AgDmGTDdKwGs2QC4uwAjoQA3UTA53SKU9QBNFRHIMjCFMQB4OwBwo1CF02CPUWB3GQb553UIJABP8vEAWDMAiUNwiXYzm3hXBfVIOqkAh7sAePBkqXkAmRNgoxtwpMSCnAAiyrVAzJoEq0pD9W9T/G4D/raAwDRDM4wzM7ozMIZAx/EigUVmESFDVR0zUvhGslVEI6lld5lU3loA5Tl4iOWGzq0JDzwA8POYj5AA/x8A7mkA7msH3yUH8aSW1W51eHOGznp2Lup36OOA+QmJKRmGz2R4fqMA7lAIfecImaeHX+cJOVKA7ogA2E0gy9IAk1gAI7sAMvAESKR2ayOEWIs4zqBnhhoG6T4Iuv4kVxMAcmOAjDMQgzwAAMgAGwpVDqRizGQnDROAmhoDmmIAzJoJar1AzO8Er/3xGXcvmWr9RKYqUaDPZg+IhLgbIMzHBWZJh025A1HKZBHvZhdHUPJvZik6highVNLfZi7IeS60eS8xAP6scPDUmHVHd1U2d9oLh9IXlsWPeRjamS8meS7bCa7dB98dCR23d9simbwCYPdMhN7hCT11Zt/YCT1rZ/0UBhzVAMkjAEOXABKRADPJBaEkgFmsBEoUAHDihGcVAIoaBQcaAqkbcqggBGTCQHJugceYMCIwBFYUQHCZWMxqU5CQV51bgHk5AM3yGfdQmX3+FKdBlWZrWfZtV8TXMN14ANg5k1BFo1yCRiOZagesVMkBlYXhd2Xzds8td1FEqJFcqYFpqh/xQqieh3fogIbCrGVyUGbNfnhukwDiiaonKIouGQonq4mTAaow2ph7Jpfe7AhvcwkdVWWMz0DdUQDc8ADc0wCj3wAycwARmgAi8gRklmW4kQBTIwOFFwlnFwBcFoggaFK5eTnoIQjI0TB7IicIOQCJM3ps6BUHFApmT6HCoyBXIACmxJl2NVVvXZDLH0DNagDY1CoIWpQYb5YX5aV3l1fxOadYz5mNo0WBzqYhhaoV0Xf4+Kmo65qCA5miAJivDwhnB4id9QDit0NeEgDik6qqOqh+zADh3JDvCAqhXJDu+gqlRHdc/EWO+QTAIYTfVAWdugDdpgDc4ACUFQAxtQAf8YgAUqsE+Ag1t0UwhRcIHRkQRJwANdhp6xFUZhkGXY6hxYuQeCMAd7gIJjGltqCgrMOqaZUwgUSDh08AV5sAiWoAqzoAx5+p9RwwzUYAyrQUsMRg3ENEL0UEwXpIbugEz4UKv38A1tlbDRhg/5QFj/QH++Nn6GlaAMqpgmJqH9IA8rtpEk+X7sF3brx5qAWJksRqkq9n1tWA4qu7I0eZDv0JDX9nTdpFjvwFcqNpGd+UxVp7MN62vOdA/vkGPd9GG5lqu1hg7e0HbdsFbU8AzIYAulIAlZEJQooAK4MgNO4AR6Nze4sjcq+ETOEZ5dtFCUd1DCkYy7GK4oGJXoea3/msBkzyk4pTIcihcHOdAEXHAIgPAKAXtB9eAN2AAO0oAMtNQM/qMa00BMGJRB3+BBi2UP8MBXGrsP++cN/OcOEjtsigqZLGmxEQtNWPeg7YeShepXj+h13BcPlwqKMsqZYyeHoZqJMampbZiQPEui+VCQywQPG+mzDOpMPwu0a1iAZZcNa2WGiwKgGcYNAnoN0/AMxBALrTAKnPAHNoACKEACdLNPchMFUYAFROCAlEcHiTCNk2ArRSAImiALuGVQshJGCjUFWYaL3PpFuYhETMRkZMaLiIcFnXIrV/AFiBAHetAHfFtZGOQO4WBBliWkyqA/ymBAzDANxdRBjusO/7xLuioWD2Rnuf5Ys4QVfyjpqImYdv8QD63Jmid5uiJMmZTKozqWWDf6qaAKuza8spqqsm34huVwwbZWfXvomq7pkT6rYwNZDyfkQaLoQs8ma8fLj1AcxVH8NNOgDdfQHcjwC6+ACqVwRZGAB1U6AjIgA3izT39TjFuGnqxCHNdBUNfqi935RQr1vQplUHMAOF/ERL74lEhEgZMwOBO4Ze4LjHugCMOQNcyADPRwDzoJDtqwHQ9cYOxoDMxQDRf0DffAhtZHdZTZfubgwR4sDnuVdpEIieqXfhprmYwYiO2nyiy8kv+wkRsZDxT5qhiZhyo7Wbq8QpRFWYoFhyursv9vWH3EDMyze0LYdsFtqJHK1syzmcSc6kLOVrxRjA3WbM2LIsXaXA1UTA3UQMXWUIrRiwp1MQqZcM6HcAiJcAI8QMZRYMbkywNUQDcOGERXgJUm2DiEQ4FTVByfMo1UIMeysgfemmX5hm6ZY1CCjAW8SAd7sAN48wjOQEzTIA1/e0LdIA24UAy9QGDFQAw7Q8nXcMnooJsJqcHzIE5lt7DZtLmOtcowfZmtqcEsZqFY15CyuZkqi4kLHKo9bYlWg4mYqMuOe7SL5cOXWNQ3amsX/GFMjQ6XKE7SXHbbXNX8eM3YkGFRA6BSrLxQjGFX7M3UIA1AilW8AAuoQL2T0wn/mUAJNtACLiADMzADL0DGdBMGPEA36RsGc3McB0UHAvUFSSBG14E4aRyVvugcjMcpBpWVspIqggA4/qt4hYAFcVCCpRIJzlBM3bBBLbQNxgALnfAIooA/yUAn98gM2EAPQa2JCTmJ8iDV/AfCmetXgcWI8kdtjpmhq6oOwByq3iBOwh3cNmzD3yDUx62TktXDKaTJN6rLa/jU0C19iOnUa6hCTFy8x/vEVl3VWt3dyavN3zwNYj3e1GAN1uDN0PAMXlUMZ31FLvcJ2UgJnrAHJ4ACLvAC7zTGKeACKVDXMrCkECi+zdEp4DkHcjAHqyKteG14l8MqdzwFg1MImsCM/1igZV02OLSCeHMTBzjQAjIQBX+AC52NQWnYDdBwCovwCJxwCqOQCxydcwb0DNgQ1LVmDw0bqfnQQtzwbOGQypIJf8NGbbV7bcXtQnJoNdL8DQucibLrw0c9Dtf2hlNuDuVwkRfZw+gwDuvQ5eDXhjU6VzOc3V1zzcYL3si71Vjd3d/t3cqr1eUt1k8T592s3s9wDL9gC78QC1xcCtSbCatQOWYmBxxABzKQAh3w3yTw33I91zFABKw4AzJAbjswBS1wBbKgCbf4HEkWBnhDHW4TRrYCRX0cBSNAi9/7UJGtrlFwAjDwAkVwCKKwDNpAoBbUq9BACpGwCIuQCY+QCf/CQFXHgBrRUEGOi+MOumzvwOPQ5g3jQNOCuGLXhpDqEIdH3kKwm9xCjYmNq8Q66cM+PGM3ug7usA5bjg7ZBw+bfG1Hq8TEW7xn3t3YzN3g/eb86NVevdXbTMX8HufoHedNQ9bPgIB6KTTSCyZb7DKoYHv1Ix72LcYk0AEkMMYqcOgqYE8qQAIvcE928wQvMG6DoOCe8GR/zAMSuDeKJwiVHgbyO0XkW4GvZVCTfVvOUTdUUAQ4sAeAvQeZUAq9AA3ojevqpFGIcAjyAz/kmAy1NPCJu8i16rCPBXXRVGzQFH7qDn4livVXD8JWp2ten0wlpqAxjFfddELPDdUFyEL/XAPvWzNMPd72w6Q1WhP33jD3bZ81cJ/3W9Moe/8oVjw1jmLNjLKrvGrF19CrYi0N683eenlAeW4Lx7cYr9AKlD/5ld+EsDBVpwSOsoAILIDfJCACL5BDx1gIM6ACKTDGM4AFMqCkDG1PsDUIyvkcoVAc4Us4jcNEtNJbx/GUmkCLpcLXtk8cLyArOoQIUSQHmkAKnZAM1qAM4OEKq2A5e+AIlKAKstAJnOAKuaD0S48o3JBrhOqYz3RXQPuZWw/mbWhXhRhNJJr1ISazX5+gcyXu2B1CZb5WGZZhgg/FWI3VAJFN4EBsBQ1uM8hN4UKF3Rgu7BZx4TaK27hR1Hbt/xpGbR2tWct47aM1atSkSYv2jNkyZMiC/dKly1asWK9spmqVU2crVDpZsYIF61VQoa9mHZ1Fa1YtV7VkUcLRAgWRGTJIpOChggoRqipUEKFTCIsMGTzMYikUtggPOmHKPhFEhUqUQXSoYKGDZdBeOoL8Cory5EnfJ0SoCI4SJVQiIkWeFAlDx5GnT6569RImrNgnTYgGTaLkKdMiUpk4CUum7NlqZtO8pZMXb968frPzwXuXG168d+zYxQP+Ox7udO/g3UOe/B6+5PicO79nz149eu6sV0eX/dt2hgINVgMfXvx48uA1jsemUX14g+2xPfResWJ6+Rw73r//cRrK1f/Plik7hphffJHJFgNpeiUnm3RKsBWbGtxpJ1eIgsWVCYNyhZZbkKpwllwyIYOJE3Z44QkZUiBhBhXCwOKFFIjIQASunKDDxBZ22IEHx/J6wqxBnggjsBgewyKRScSiIgy/sPDLLCoGSYTFMIjwC6wpA3tir0IsAeWTU3LJJZlcLPFkEE1UGcSRPyLJ5JBIUGummWeiYSaaasKp7ZzZ2lFHHnnY2W2ccMQZJ53h4ikuN+Nyw0e66B5Frh7r0PnGG0u7+648TTddb1PxpinvvGoKusY89TRyD7+ORBrJJJRSUoklZIABxhdbZaIJwQeJenDXohxsxZVgWXHlp1WOXSX/wpwsZJbCW5SChZVVXFGFEU08MWKKRGaogAQ6okhBBBmCHDeFDmR44YXAdsiriBhwfOKwHWbgiocZZsAABR6gFGQKyPDKa5BCBJkysicSEQRILASDa5AiqCgkkDQtMYUUVVQxxRJHEJnDEUf28EQWjT3phJNSioHmVTu9ySeedvrpZzh4cFt0HXfWMc6dcXLLrudKFfKGG4Kw8bRoTamphpppSlIaVKM1Va8kU00tlWmkm97vJGmgYU1WY4AZMCaaZsq17Fx7DWpBnZhle0KlaGnbQmNXkbaVY38i9icKYaEFF1hmgWUVWVTJZIUdrqCCDh5EyKCDGXpMd4YXykr3/4V7ZdhBBjoMw2KGtaJwzKy1XuDBhSGfSOKKPfbAS5A56Ng8CrtYHEwwsAwjYuAnnFAykUQ00cSSTChBZI8n5kCkkEkQEUaWPTSRhZEygsAEGm0iAgccd5bLp/t3rHPHZ0vHJ+hTaaZB3+n90ncaPPbfZ78a9K0uaX6rSUL6afBGapWaj+pP30miAStmrKQlX7MVgQpkNgbWpCa96pVOUNETZbUib8X6SbHiFje8dTCDGNybUjbkisExogkgOAEHMucCIlhFBedyQQrQRQISeEUEkcsc5p4QhSBhwYegg9fjBHOYPYBiEnuYA14SVyMiLAwLgTFMW8JSmCfEIA5FiP/CJELhCVA8hQlf8BcPsACKQ6giFI5wXRwG0YUg8IEPqbieNiiSKQFGQ2sDxGMe7YjHV53kffKDXyAF6UdBBhKQhUSf1u5IwAIuw5GOPCDYCGSLAhmIbGRr4AMbFMGdTNCTnwQlKlhhN554soPJyomxPHhKVF5ob7O4hStWUa0PWKAFLRDBuUggAyKoAAsZSAEWiOACFZCFLOmSoVl2sLAnTAJKTHpivHbwGB7EwAhyuEIikpAEQRRhR8zEwpN6uJgwHOkJmghDEqhQhEKEAhSJKMQetomDIgjTTI6YRJT6QocdCCESp6BFMeTUEmQU0KAFNahKDJrQOa0GVnw8X9b/Ivo+Qp5vouxTZEYJGcD1BVCA/WnkAY3xNUkSKIG+oNVIXfKLsMUkJpa05Esxaba0QaiCnzwFKE9Ripzi1JPIQuWypIUsnqxyb0GhRVCYMotVZIINJ9hABRjXgQlghQgvIIITLFcVXsqAXuHCao+w4ILJfcYFQKKD79ZZhBe8ywiCkEM8rxhOQUQpDGGYAVoE0ZZ8TpEOoaADNuuaT0EMIjL5HMReBfaxuiZ2EHs4BClm0QtlLKMZj2RofzS7WYgOUKMapd/SSoI/a1SDJNbQCP9Uiz9puAqkBjxgMMAGEwW69KQJZCmBgmGMYyADksdAKTFsxYtdFJcXx92FLoq7/wviJle5u8CFJWtRC1pU17rWPWqFiBKsoBBrQhMiFt+6e1Rh+cS7zGoFLJeCi1rcohZg+hATuhAHEkygAh3oQAaskgESiEAuJyKCWcTFA17yIGEyKEQYXDADubzAMTwEXhTYxc8dFOEKn1nMHBLGo8DIri+RAWde6LCHKeyhEHGIgxzmEJnC/mXEmthDHKb0hDhMgRGqmOwx4uTIOG3Wx8+ARpCFPGQgD9nIKXMV/ZRsta0R8JEipVUCXSqT58ZkuVZeLnN3YSuWslS2v6AVMY6hDAAdwxjBeAlLj7vm5ma5uC7dBUyvm5TrZle73T3vKuO2N7lhMIMVYtaGaqHUv//lQmRMAAIMojBV/FrlBbusoYqMiS4ZBqYsguDBCwTxAirwYAQ8eAJa7hoGdmqCDnEoBDdVUabFLCwKCzNM4sIQairU+K+JmMIVvoDqL+g6DleIAw/psBY57EEOMK7R5MIgB0rguBfDUEYzKvtIRzLjxz7m2pGDXGRtb/sZcdpxmYkhW2C02bkwhWmBpqwLXLQbF8aFbpbXbNw1o5kXaB73McZs5jODmVb+/oW8zQ3nSl7XQHWm0IKY9cGF401udDuv3DLoQaIwC3BBmYUsZ/EUG9QABxsgQbdymQK8CmZyKVAByl8wiUm8oJidxjSWTM4DIsTABRxYDA9eHQdVFGL/B1P4wu8mIQgshGGtzJSBYHgwayxeIRShEMTPdzAJTRiBxCiu0dLNFOPV9UVyUSjEIEAxoV4Ug8zTpnba0w5uOa0myGyPE5n1XQxjEOPMwUBucnFxC773ne/t9jstbNG3W+BCQ4XXEOH37m5bRNe5zGVz3tkcjHGjOUD6tmxsv4bmLw/IVv8eeHEbb0nrHry6e1tQhRz+wQ5KnG5+9qCfLQToCR3lb7OkFiU8ngSpZGACgSBCBSpwIpqnIJgzEMFVkk4Vda3zCTjCUSLGEuAnuAAFTH/CFKYQhjhwLBHZDIUmxImYaWKhwkVIAo7SeoX0aysR3/KEHJIQByoe7Ihp/5oE7ALRF0E4AsceKoZkaAZ9662W0LezkztkIEAzoztiqLzmigm+G7ykIorrSrzD47ujUAp3Kzz3Kjx3W7wPBMG9Uy7l8oXc4rIuO0HIwzcxW8AxAxCWgCRkMAYFHKnOA7PLyLt4A8G/s0DsqqmcwJBgsRAJKa+8OSU9W6UOOgpZOoWLOQQYOAEU2IETcAEX4IFAwAIS4AARUIEZqCEVoAMVEAGsmJwrFIEYsLkcITADowN04aWYayI6mIIdSIIYEAT22wFB8ARN6BHbWaYeSYK14IE5uIIi8J0YeD+q8538u4LCwIJAiAJB0ARQsARn4sOh04RCOBNXwIVcGAZoI//AkSJFvEMul+I7C+QbCkSbohgKpDq97SKKi/sbpUAKD4Sl9lq8EXQ3waMyE8StLusyyiOGYjhAGCQzaUMz3/qP/5A7Mxs3sOGFXpg3eoOudtMQw1NFCvyV8qogZaEboII4iPMgcYS4JrwYUziEFYABF7gCIhCBGGq5DOAB4xOBEfAKr9Cvm/sKsnABQWiBGKjD6nOBrQALuPiWAFOSb5kC5QG7HaACTHOMwgiDHagLduHESTDEKYiDbTKTpfOLWYuXGYiCx6GD5kEi2DGSUFCFPagEWQCTskuGYuiFYLiMm+wFEKSuH0S4mnqQCnpFtWmFhLMJpEqbtOFJwYOpWzD/kHd7N3hbs1/gBS8DBsojQLmLtsqKE2NYhm9zRgApswAxxchbrmfjBcAbPFxAiqSoOLaZG2RRpaG6m7pJlmQBinCUS7kURxK6GFU4BBDQgBGQAQ6YHBJwgeTTtBmoJrICphOZnHQRAR7YgRYoAtOJA9jBHHuhA1kohMdJOthpplOjxCSYhCRgi1MbusfROSygus0MhSuQAzq4gp+jg/zboVeLgqyil8AIg0RAsS+YA4RhzXgyA1PQjGJAzmTASZxst1rgQPeyLlcoSgxJKmZZkKIUym/ciQRRm+u0ibFBN3Rzt3iLvHqTLcrjrQWsLAJsBiFjCQBRwFEkBrApN2o0/zct40C1XMukosDvqhC7aT3aM8IJYZCg+Ma3PJa+NAVT2AMLsAAKuK8UmIAMyIAK4IBKY8kesYqr0LQokIGv0LkhKUmGmRJ6aSbqm5wAa6IrSLAY0Ll1QrFRI4IdEiOCEYT88yYs8ITnK7obLQwnCCcZ4CGjCwNQiwKN2YMrUKIiOAI2AIVkgNJoC0DkRM5hoElqvEZeZK/2ysClmC4vrYW1pC46+8G11MCl8MC9o6RKei43c1PII67jerZQTDMw2y00Qylg+BquLIln+DxdqK3wZCAIgqD/lKBQ8qRSUFREnaBUcNRUCCVHHZsC2QVaGIZny4VKgAM9OIJ5aoETuP+AETC+q+gAqcKvqxCBSZQBFCBDXSoED72qDwW1dPnQEbiqfCwmewE1eJmcQHiCGRC7QTCCw4mMKdjVFgKLgJmmioyBvMi1VNsdYRKLQEgYIXqCLlodgtGRK7gCODBOKG2GYrBSca1SHcxSXvS7vpuuL/1SpAhTDSxTd3XXDUFTA5myN7XG5SpPaqxJNKMVzqOVWgmGWTGGZqAGbbCGkaqVWlk3lwrPA9EkRwWWUkIFSIXUCVLUjNXYRy2FR33USf2FGiygadAI/9EGaog2Z0iGS7CBD7gAChgB00GBDrhQEniBRHACFDEXEqCSF8AAKkEBEsCvGPGKR8vHGUgBl1P/gRiQkScoJhQRsRoZDEGgCl46tUKYzT2YhGAThEIoBHRhi634HXgBtTB4ATr4gm2aC67QJ0EYxDhgC1WwBEFYjMQSRCYwgzeB0jm10ku9VPsEE3cLXMBzL8Bb1zB9V3k1U3hNCljKwHSVwDV9LnOLyvK03OMitxZ0wPmsypGyno7wD4I1Bn+bLZZaN5hqIJ3w2FTQ2IxdXZqwlZYooGiYBtTiBm/ohm8AB3SgB0epB3Cgh214hoJthk+gARZgAQ7AABUwHckcgeSbAUHQKp3tANLR2ScQ1VxKVcmRnFzKx11qDOaF3pRLF05cJlBQhSLVkSk4gRa4giMwhWQYhC/Q/4RQmAOyKAwi8IRQwCsqSATJhIyOPAKO7BGuiEiOHAQlDQtUe7+uBQzugwM7eARZSIZQvIxQtOA1g68NJtwPPNwPRtx2pTOkqK7GhdwRhDN91dfjUrPLLU98I8bNDYZj2K0BHDNdMAb/8A+SAlhhPEHPA1R0Mxt7BVSUqsGCcihQuQZsoIiI6IbsAQfdzZ5yMIdxGIdyGAdzMIeYgQd78AY6WQZncIUgqAEYaAEK6ACvGAEUGAFRdQH8oopwEdoOCLkYUTmhZRwa+kIVENovdLkZiAHSQUyXewEROBgPrU0sEKMdkANBQIE4gAFNcAZHuAI0KgSuuE1NIDpvsheLxP+0QjCFz5giKtCEBPaYQpiDQbC1yFAe5bGwPaAEMvgDUwDFnCy7YSAG+5zGDYavvfu7LT1cX05XeE3KbLQuEWy3Ns1X5uqycpPTYBgGeys3zqNmyovhlwgGaGgGUcAEWsgJWngFMbvT3bq73QrYcz7iZSigOaFd8MgGbvgGepCUeqBnepYOR3kO5HAHe4CH7smHfdgH3dgN4JiNftgHd+AG+ZGGZvADG8CBOUiBCuAvMixkL2yhQp5QGWCcxinDGIohDEjjDniCR5MBJyCCGipJrCqLMBiEx1SByOmRGQi7KXCBJJgCupUDHDiCKwCeL8AmR6AXXtoK2DkLHvCXm87/DCNoi0IQDCQCGc+QgxpbushYxNLEgTjQBBTrgkhwBWG45V44Bh3khQ2+jF7+ZedEa8eF3GK2BerSRaa013dTrvFcYWZu5pvEYGquyr3WXLtzQHwbwBmOk2PgG10g5yP2LYMaIFB5jyemh8eGbHnGB4CmbMr+h3247Muu7M0GaJjx7H2YDusQh28IB28o7WzABvR5BmA4BUMYAhhAAQyYUD4mASdg2uV9AToeQzp+AQpNgZvjAA7or5Fz2hShis4BQxV5AYGhg6RtIRlJ2s2xObdKAhyYgk6Vgy/AAYwZhPCjFyKQHRnIp7WAjFSjAllwBlW4TMHYCxRDsUQIhRib/9EF1uS6oMwpOLUwMIIfWARV8Oo55Vd+jcleFlzDfdx0TUrTEzzFuwUqezN2e0p9beaANUW9Pud/9dcLP+eW0NMZ9IWCspNrAJpvQIfpUI4Tb47lcA7Ofo59mOwXf44Yjw5K2Y7x4Qb3wAbUVgiRgAZlsIVSqIRIOIMN6ELfe+l0iSFzCZcUaO6zfYEJIFUXIAEUSD6NzoCXlpHTXCIOiAGvje4WqgpiQouaSyvf2YE4iAEYMDGengRPKB6gvhcgcQJaKwJ2Eb/NVO8kUZJNPB7VGRwNW5hCEIatLacoqCYe0HMLA4JZBkULvkk57QUO/kQCX2sytcDBMz2m/LsGx/+yx7PcfwMz0j3nZp5wxFZsO1qaa5Aja8ijanjielBxFo/xWV9xGKf1R7GHSaHx7eD1bwAa3M3d7XDi+tiGjqCG4UUFTJCESMgDQkjeCpgABuBt5o0RcZEB3talna0hEcinl1aBDJgBJ1ABllMBFMCqSaACFOBEsEiEQaAKnj2MevkdTUgGrFVDqxsENMm1I6KK755Rz1nfYPs1bdmcQLCrIqhD+B46ps6SUJADORgET9jaHZKLvPAhOZhl1JjSuTPGY6hSKhXXtfTJBsEJB+mVs6EQhEO3Soqphr0tU7c2VB8VhciO7VFx5lCO6bCH5uhsmPkHzYYOFD/x76FxYJf/iIZw4oc4eou4iPqQI/lYFZGQhmXgBVooBUlohEiIBEQ4Ag5AAQsNlw6wvguoKhmq0BdK2sDAi0ebhDB4abC4Fw6YgUmAxxviChRIARNRTM+MAbxwgR2IgbtyMFWYBAyIWVBzUR6waTukCpoD78MoUm+aArkYxLbIKt7pNHf5gsjYojAYGH5KguxOLLmgisig6in4A1KYyXENxY8fBl6w4FDEuIsTvG9c3VbACULNpFhY05OiFYSak/OpBqb3hu1AB+uoh3ve+cnuh39o/ufnbICe7H1oGd8wB99Ih13n9fGxlGzgfht/CIiIiPoY9m6oCPOH+qcvdo+wBv8IBlpY/wVTuIRK2IRKcIQ8AAEKIMMUCO7g5m0SAIgMGTqkSNHhxQtNiXioIMEhhYoUM+h0yMBDxAsOIrBQqcAB4RMZMogg5PHkSZQYM14UifEixhMiFVy6qJkkBg8eRYrExBLlCZUnRejwiILlShGdRIg4IRLIiZMwJ2PswIJFEJ2sU5Jc6XpF01VBM4iEKRSILJ04lEAJa9trWLFhvIrd2tWrV65cvXDdmkXrL+BXsAS3Ktzq1SvDhlMxjuU4li5bunwBM4aMGbNo0aZVw8bN27fQ7urVs2f63rt39/Dh25cv377Ysve9M13PHW53oUN74/bZG3Bv2YYT5zac2zbfxJf79v+N7Tk24tCfO99m/Tr2bdq0Wd/enbt2bdaoQXu2zNiuVqhOfdpkSpUpPTBgxEDR4iEGEksrkFWBUcVBY72gwgwdoPBCRSr4p8ILIkzAAwcqxBADBysBKANGL7gQRRQoxJDICyvtgFMUKbgwgwou8BAUFhPyRFYUOu2gEx2CCFXEFVQQEVMhk7xAhCBYhRHFUGEMWcQckyj0RSGaUJHIHFRQIQMVTtDxRI17/GHKKrkIk9cwd/VyCy544ZJXLbPMQiYuuuzy2GO22BLnZL8Acxkzz2xWzTXWdfNnN+CAgw46uRF6KDrpuKOoO+/gVqg7hIozqTi89dZbc5k2l42myx3/Z9xz23g63HOdPXdNNXyees2q20x3DazbaXONNbXWSo005T1j3jLLHGNMML/sIuecibGyyiqyqEIJCyhwMMEOiYzgAgoXTBJKBSLMkEEFKYggEA+JqJBBiig01EGBGYgApAjt5kdSQw5FQQcWSZkUxg6DPLHDDDqhxMMLTyRCRBRhBLUDHZMY7NNJKIWBRSKJRCEIWCjREQi9HFn1xRd0FFLIExBrMkkig0xx5RRREBGUIENyRMcUX4RiiSWmyPLll7nUsnMteuVyC5m77OKLnZYhg2c00kzDajaggUMPPfXcM7U9U7M29Wr43FOPoF13/U2m0mHDKqvTmR3dcZwm/5cpdpt6Cmp0cJtd9qqwwkrNNHlLs7c00ezKTK/LIAOsL5E9lhhjjBWGCiqtIIsKLGrCcuwqqsjiCQ4gnLDBCEQUAiEHGaQw0gsVdCBCB6m3i4V/JKQwAgndpkCCDBhQMUmF7cagCR3f8oChCkREXAQKUVBxxQ5TxCDIDkkkEkcRt2OhSRhU7RFHIQajZFVQJnlMRxGD2EjHvCqHAT4dmlyB5SAcKYTFFEVclRVQdHiu40lXxXF9EmtQIkte8iKLAbpiFa6YhTCKcYxjLEMa2ggUPbYmQamtpoJaY81sXJOPdYyDUuEAznKmkypTQYdusDrVdK7DKd+0DTvc8QzbrP+TKc+4SlRjg1Wq9Oa3Z2DmaMYwBjB+Ubg5PSZxRmRMKZKoxCUybj2neOIpXAELV1DOFar4hCPucwIXpEB0MnDBCE6HgeAR5Fum68AEUtetZ2WABC8g1xNEQAIFhWgGIqCCIF7guoJk4AWCSISHRkAHWfDgBFQoxCDmEAfozQALOzhJFFpQCESkDHo4ikIcplCvqrSMDlTAgv2I4DEqeLIQqkBEHP4IlEQEKWSCgFgiPpmIK6FMDpUswh6MIIc9WEITn8gEJRBBCEMsghGH4MQwlKGMZTzjGk+DWj2iJk2o2YMe1bwNOoKDKeV8qjloKw6oVugq47yNnKMCp3GcE6r/7LhqbLYazzQ08zfA+RAY9vTFEIkIJ8cYERWJY1wqmqjEUSyxoKWA4ilMEcUCImsVp8jECk7QgqpgAY1zJAIPKtBGbpHgdB39Frc2yi2ImC4FPyrQDFA0g4+ggARjJEEbSfIEarkgITvYgSBU4QhEDGIQO8CBQnaQpF06whGDmCUV4kCHRHwOJomYxJWkEpMaCeKTc9gDInrEkyckQakKC0UoKDYJKswrDEWw0RTkEIUpVGUne3irHAxBCETIoadyyMMfFjGKZkBjb9bgBjhC0w22SSeEpMpGchKbHU0x1jd/4kY3wJapxzaWG9HBRjtLWI28TWNvmvEbPY82OHsC/wOf+NQFaiNDrDkNBhawoEUsBIOYwiTGME287RKhaNCDmqK3vW1o5U5xCR+woAUnSMEOSOCg1nFAIy6tCAlgKt0MaESjKSiCCDT6LRnQAUMi4IC5SDCDOVZgBpOQQUNmQAUUvM4+YZilMEChiflO4gSakIURojWJruxhEqDYwxeSkISWxaAIJztfGKLEIUzG4Qv7K8QckrDV6O1gD7Lo0SQGAYpCXGEQWQnELF+J4DBMInt0wOogPuaxkmE1EqNQxg77So1qUGPGfLLbCW9INxTiOMfWwWwK28lOGTYHO3fDW2f7tkMeYqbJTu6VaH9oNCnb84ekDSIvgii0LfPFFv+AcS0sCkM59TDOoAQd6CjS7Io0pWkWtSgTXmohi0howAL2SR3sOsqB0+25AxXAQAgE0gHlakQEGAAvBtwlghRgACYjOFARRtDcA6HABTJA2Ax2cKBBrAQhKBhkIkChCksoSxiIaMEUgvKEFMtBE4PYgy23ohOe0GEOtq71E4IUs+sVIhFymMQcdoKwQixyErucxCQQ4YgmtS9idHiYkS5WskJgodc9nUSQBPGxQRziFMTIUzPCraek8Y2z1BjPO63RY1mxu93YkJXdZgWr8eDts0tuMpRFq+8o67tXmMm3Dy0jZSkHo+BX5sUueIHwXeCi4Q7/8mBc4QrFkPm26zn/KBRvW4sDziJyrkVTLizxgeZ21HUOKcihO4CBQbcrAyGoCBepy4ERjECP3w3XBUYQAxdwAAMuqM+0eKCiF/BgBy34+QhkMAMZ9JEIRt9JEZKABRzs4b8tKEpZPCaHkmWyK0boKh1C0VMIP5sKQ5rCJMU6iFDM4SdP0KQMQCGLnsoiEUbAChaegGBV5/0kCdMExTzRa1bOcg69XoQpiLGMcIt7V7vSDN8+y7ca1zjd6aY8rj7reMABPOAD/+G+kbHA0ItWcFDGDK8ENziBfz4YxAhGmHqBcDjnpeFAA9pfgOZlwPAezK1gBeVWcSyLt4LjBzQgLLyUC0awQAMU2EBz/wli3YJURKPRha50Df26J7zAWeZSAevAiwIMOGsEMzAXD2YgCJPMjlrTmp0ei3LpHYyEBzi4ggt2kBRk//GVRVikHDQYV1xBjyTJIDzMKx3FUu2BKc3BFwyCKuiLvyRCKKjCJMRBLH2dkZzEwxRCyxiJlCDbUUXM2PVajTAVIqhCLxCDMjGe473grugKDMIg5x1DlA3c6xWcDgbDDxHDDy0QEAahEA4hEPbb4i1DnjxDuPWKMtjgDQJLwRHDMEzhXexCLjic7QENX+TeLfAeLXiZl0XOLEgc8CELxRmGxI0hQ5lCLshCJtCABmzABXjfCOxAu2jLE8QOBqgL6oiAgv+kDgdkS/HwHAYEjM9dAHhdwASoAApUGgrcFAfwnAyYVEbUBEIURIgQQVftgMqMzogkAQ+kz8qAAsws0hzIwRdc1R4kwRSkkiLtgeElwvnQyxxAyQ5oQlilFErEiN4tFVGQz/noHYklAkecT5NgxbbRASLwlPhEjCBMgizcQi8oQzNQY7gtExOK3uAEixClljfKCWptWWrh0w66HjG83jn6oDEskJTtW+cdTeDEo78x0wsiw+Itoa80YQ+eozkW3MIxHBY6nF/8hZr4xWsVJC1MUUNREfCxwsQphvAdi8SpAnx8wpyBwAZokUfM3EmMwAXwBArQnAg0IoC0kR6pwMr/HVoFaFQHjAt4vcC0uIAKjAAG/NnOOcvpeAsJ6NwX7QgRTCKD8MsLiAQRYAF3PYFEhMEM8ET4DEIqXU+AXYEcXMEiSSW9YIUnAYXZJQWR8ABTYEFR+oTw0ItUiVIhzIuUSEWNeJggpFivaVvEIAJTDcJ99YyY3EUwrNY+7aVjeCEXNlxqCc1dKtwvmGM6nmM7kp47KoM9Bg7gPGaTmUfqIYMyrCM78qMOatmWLRxqEctfgJlrydZgHAZiAN9iMAZivEIseOYs5EImPMIisAETAAEQ1BkFUMAFtNF91JwgxID59RwG1GRzyZHoIEgXyRFB9NG2iICk8RwWhEGj9Zyk/zXaCLQLoaHATKUAD5zlUL7EHNURSZiE0PHAJLSEVMwXHpmVgA3CLjlYIlxBGLSMVTwMHpHPUo7FRHAgHllFTMTEUjxbGOxIjYDSs5HMikWMtaFYf1lOLvyFl0WGg34hbA1GalYoaLoWQQ6kg9oCLggNYf4CiNpTOerg5wnc4Jwo6amePEKDNUCD6v0QDxIcN2KZ0KiWaukTX8IJsaCWL/CgPeZJ0kyDNXiHdrRoMtRBBERAA0CAA1jABmwAblLABFTADlALB+Rd9x2apBUa7YyOHmYLRIyLCoQBgkRIdtVhFNBccEoaSp7ORqEADxSECsgAD3TAUmCEDNAOSYwFEf+w1RWEwiLlnQfKzxRMAQ5gD4DFAShMQhLQD32WhSyAQk6Qz8pIhVXsiFfmXYCqzFE9jE88JzJCFVwiaCEY1VFNQlGRwiw4xpzICV9W6OFYKJj55Wp54ziaFojmqohGYYkmZuipnj0ODjVogzSIVmVUhpUFkWmdlmqt5o5OBmVYBhKO27l5B6AEStdg6zf8iayMxzCMgiLQQARYAAQwAARcAAVAQLpCAAS4hKThhKRt6QgoiB82BNO1S0sOSISQwJAwSEygZIWYHyFiwLx+i59lAM2NixzlKRGgSIMEDx2ogP28QBLMwQ4oidmBTyF4UvxoGHsKQijIgiK1T8PsRCH/hALIgNJJBAVZAYVJUMzDREH7zNdVTELBlMy0jeDgleokYJWygYIjKMIo2AI+/cI62ok9FU2yDhwwpEIsNEZswWqcrJZkeOOyUgYwmKNlrh7odW2Jep4x+IIxnJs1CA4QVQY+3RPSilaTacY0UEOf/MnTeA3d/kl2cIe83VA3dCs1PAMx3MIpcAIZgIAGMAAFcIBvTgAETGdzUcijEaykTWmDRNceGgQR7BGWoE4GyMCAwAT3mUsjngjNUciCeAv4CUJEaAhCDKUTEJ1INAW2qUAi3IwceMIecCIdeBhMQEzPzsEf7UGHvZKAShWWzMv3zMD5tN1J9Agxxmx9XsUs/w0CyWwYHpFgig3CMmavsh2CIShCKuDJPDlZD5HeaU1trXrjlgnN1S6rneygOl7ZlVEZaU2Z2KqoeeQJEmZGkMKtdQgK1PwvPXjNYKmTjvVYj/1Yn2xDN2wDOBQpNDRDMQjGKXTCIoCAlDJAok3AtDTizDliSNIczUUID0QXSq4kvnZAjWQABphUtxCBs9xhduUcwVKBbybd0rVLFMhCGHAAnZLE6JDEUvzkDDgBD8CAHDhCMgjDLiWBCxiJJj1x8k4BD9jaJ+WEKHGghoGSIASCJgRCIMyBVOARsmXFcy7MFLQdNPbUH3nYCB5gIBQCW0AjKCDCIXgCKWCCLVhGEv+KLzMczfg2WbACUeHY6tDkqpuk72ldLdLOr/yWKNYaDfhC3jPEgij8gi44LTNoAzjIbWANsGVdx9jkUN6MUKpYninbiqugyo0NqTVIg3kQAywkUSZswiEcwQUwwARgwARMAMEoopaG5ExKWqVtsAl31AS41AukQMQcWhd5CxU0iLuA1w6EcEiSLoD4IdG1wNHtwJRIBMFkxe/IQCAY2x4IgSc4gybgAH0UAhXMgSYMxRQ8wRykmoFJiVAE6IpIBSutnaVeDFmBUonF0sK8kicZ3sew0jOibE+VzPkkguWogjB4giWAgidEgiRQBp70MdeSFmWsryKDKC/kqq4Gka7//hDSDhwyICsk+3Fkuq2qQJagcLI2MAPRLIMyVMYzcMcIqTIp9zSf1BhnTR6Scdbbku2tTMN20MqtkAc0NGEv0AIqlIIBqYIn5AC77rLiulHPeQT5vWRzzRzB9hwHdJS3pECElNHsuA4MG1p0VYDO7ZwjfTBbC4zRVRonzsDo/EgiaEIc6IiVhMEXOMIh/AElwIF9YAkViJomDQIVaBIpoUTIWKoxxmcRnGwvYkzezYvCSMX5ECiAgozZPWMSp1jEIOheO4ImpGAyyIJgK0IsLGvYDrJqDQuxJDI4HrLCZZk/FmYwxC8k5y/quTSrwPQ3dA0AP41ufAOmgA2ndMM1/4DWM0hDrZwQKXPGZlW30hC1dm+33ijZPOljsAzLa4VZ4zCOASlLF2gAuyqAuU6pBusyCZ8Ohqgwt6zcuSSaDAgCEexhIJ41QmgEETjuDIDRDNRcStBBfbhAEGvChLQADMRBKNCBCzzBnNIBVXtYhBdB8zRBFvwADMxB/lR2IUTPlfhd9kQBiAPFwyjJXmcFvWCJiq0sMfrExwhJGBygkUDMUUV0jSCStn3MHnhY+giD2O0BIKSCaf2QapFJF74W0KSWZNx2nYTobyfhZvCvAtPt/0ZTNEETOlhKb6zQbwSHmCPHAm/HkNKNT/N0qgw13nh3+NZTaXVmEbVCQN3WKf8wDkI9kbIAgRxmywS0NwfM4S77IX1TrumocKIDOgTknYnkJBGYtRyJwBM4y5UmglD45s/RwU1w11K4wB6EghHEgX8NAp2OsAugtsRoQusmwR5EAiM4whdwohPsj+/6Lh5NQZBsFX1G9lNpgicw1bN50ht3krZlRdbh3VUERS2WtlMeVZAEwjOmWLb1iPgIwiKIgmkNjmnV6LPKidjqcXDnTQLDNACfewAHlnIrB2Q91p/sBrzHu3IDBzeEBmQhh3XAbZ9glmWtylK/uSvzig8FyyC76l5WKGKMJp5nnMWtwiHUAAhcAARUxC5f9YBMKRoFZ+rUpLpwi0egEeqYNZz/jt8IaEKkj/VIVtoFVECK3NRMPqILXAEoULhRJIIwOIIReEIc3NS8yAAWYFUSRMFZ8kASeIIpKNskPMEQC8IekNIZa1L2GEwRlFXeIXvYoSy2cYQHdvYfWcXLuDj9cESSQCNU1UiGBcm1eGCNB0mNRwIm6II92eM9xdZq7oIuFKYxLAM1ZDm6Q82gFLe6c5NvhDlxgAZvePK1yu21CspuMH5oqA2QsUo1WNYIdRZohdbZ3hOUG7yz/oVjYGhCgqYrIMbErYITPZFB+cEKgMCgY8BVT4CUQsAEtMtKJpoc7eFK0vdK5v6hqUAkMiIHRIEMOBe96twIaPC0jEAL2DVVIqBXTkDgILTA/00BnXJfrhmBFL8xEZC6KQDBEezBK81AQAAAIfkEAGQAAAAsAAAAAEABAAGH6L6g3LCS2qyN1auP16iJ1KeJz6aM0KWGzqKEzp58x5+Dxpp8wZyAv5h8vZZ6w5JtvpN0vJJyu5J0uo5tuJJ1uI5vuIxsuItotZB0tY1utYtrtYpnso90ro52soprrYpwuoVXtYditIhlsohnsodjsoVisYdnsIVisINhrYhurodorIRoroZjroRiroNhrYJhrIFgrIBdqYZtqIVoqINnqIJmp4Fmp39lqYBeqH5co4Rro4Fno4Blon9ko35ioH5jq3xYp3xapntapHxjpXtaonxionxgonphontdo3pboXxjoH1hoHtioHxfoXpcpHlXonleoXlhoXldoHhfoHlbpHZToXZXoHdeoHRTn3xhn3pgnnten3pennlfn3dfn3hbn3ZgnnVfnnZbnnRVnnFRnHthnXlfnHhfnHpcnHhcnXdgnHZfm3ddm3Zcm3dYnHRemnRdm3VYnHJVm3BOmHddmHVamHRZmHNYlHVdlHJYlXBYlHBVmG9PlG9Tkm9Vjm9YmmxKlmtLlGtNkWxUkWtNjmxTjGlSjGlOkmZGj2ZLi2ZMiGVOiGVKi2JGhmJKil0+hGRNhGFIhF9Gf2JOgF9HgV1FglxBf1xDe1xGf1k+e1lAfVY6elY9eFc/eFQ7dVU/cVVCfFAwdVA4clA4bE88bU02b0oxaEk1aUYva0ElYkk4Y0YyY0UxY0MvX0MxYEIvYEEqXz0nWUIyWT8tWD4tWT0rWDsqWTslVjspUTsrVjgnUzgnUjcmVjcgUDcmUDUiSzYoUjMeTTMhTjEdTywVRzIjRy8eRywaRicRQS4gPiocPScXPSQTOyEPNSETLyATMxsKKxoNJRgNIxYLJhQHJhADIBMIIA8EHBMJGxAGGw4EFg4FGgsBFAsCFgcADgoDDQgCDgcBCgcBCQYACAgBBwcBBwYBBAYADQQACAQABgUABQQABgMAAwQABAMAAgQADAEACAAABgIABwAABAIAAgEABAAAAwAAAQIAAQEAAAECAAEAAQACAQAAAAACAAAACP8ArYx5YoUIEQ0HRuTIASPHnDEPITKcE2gMkSRUcDTq46aPlSc5WpyIQTJGCBEiLpBwUQLlShIscMTIoKJRr2DHkFWrBm3Yr1++Xg1b5IMKkRwxYMDAgqWKECFPoEYNEiRpjBwuWmh1gWNhDhwwkrZwgRQHDhdcleYIgoLkyxgys2o9gUIEiRMkUm7QSuIuiRCAQ2ygiyLIEySWUMHqhYzZL1y4bNm6VavyK1ixYMGqbJnVq1mSbWUuNapUKVOlUJ1qtapVK1CTTsWaRUvYTmq4qUWL5szZMt/JgOWSpUrVM2/KQIEipS3et2/dum3TRr26tmzZtm3Dzp27NWvYwof//34t27Xv36ehz+YtWzdssv7gKfODBoUUHChQ+KADTqFLmsACjTcEerPTgdTs9MRASSQxRgsINJCDFQUd9cQccjyhIRFWmDUGIVYQosgdVIAUA1ookrBBCCWU4MKJLoiwAQkjtPAVCxpQEQtOzPAEzTG/8PJLLcGMwoNZOZxQo4ZCLBTEWk3C8IJSMVQFg1wwmMUCCy2EFcOFWHy1FkMkYUEGGUGc4AIKaOF11wl09SWnCCHI2dcFFwCGQosilCAEFnxIgspNyDTzWGSTcYYZZ4zWshlnk8VySimnoGKppa+wwhpsl73yCi7GGFNMMcAAQ6pwuaAqy6qrlgrbJKrA/4NOdNJJd5113F3XHXbWZAOeeONZcx5661nDjTe0dpPMJGXQV4MPMsjQAQYdyKDEIpVgQsoxxxp4TW4JUkMhSA4SEcEAGjhoRQ4O8iEIQzC08AQR81rBhxyNyCHHWSy86OZfIah5VRBAoLDBwSS0wIIFFXhgCjHHRIzLMMP0ggsvuNxySxM1yKTiCVRVtdBVDMHpgpconpwDQU886VUQWIDkFQ5drmxiDCdc0AKNI9i5gV0r5aySSyrmGRiLMZABCB+bpNILMcw0M4zGVFNWWWhYQxpaxrG0woqlraDCiqatwdKKZrB46kpxqhBHyttww63c3JPI98cfshQoHXbaZf+33a7XfecdsYQXvp570W0TDjfaPKMKHj9kYcgdPNCQAgUccKCEHpJ48skqA1IjDbjRVDPGGGeOQYUVLRSwALtP4KDhGPeebhFINloRByGExLslC3gdLOOMKJhsUp13KTxBBhlEEgzEx2iLyy/CYAwLMYPgUFWMJJREElIn4qXmC2vOdUKX2hMBFkktoKBUlgrvrKYQVcRwcGEu0GhnXygUTxLCeeneCfS0p5SIICx8sEQqnlcoYehCF1XTGNZsARlb1GKCtoBgZsx2NrFpamytWM3Z0qaKty3nVZNIoQpVaAhDyAcPeLibMgjEOF35rW/cuUZ5fGU4wqmnh3yj1Tb/jsUNblgDGMxaxCEI0QUb7KADHMCADcSQCE54ghS7cIbopiGNaOhmDA6SAxjF6IACsEAOAnHXGORAhSRoCAf0ekJMWmAFRLygZ3mREZ7wNBgYnEBGLHqRSMYSgQpkIA1Pa4wwfuGTIPGiFsTghOxwtoELwEl8+fvXWLKipkGKZEsj6JlIRuCirLhgSzvzS4xUMqMXyA8vQAteCeqyv/4J5gIr2oAFNtAWPmQiFcSIBSsm1osHQpBqkEkmojCYQas5SjOoaM1lNPOKWlTTU6SY29wwsUIV3u2bZYDhHyYhDVllw4a7SqcOCTcsYaHnh8T6YTawkaxueAMd4aiVM1Sx/whIKIIRfZhBtDCAAQ8MoQ+SqIQmJiGLZ4jOGtSwBhnSyAd3BaJ1DgCjFRyUAz6cTkMMOYqYMjCHJ/xseAfb42CykpcQtCUGKhoBCxYAAQ3UIBYQW8YwhLHTRQ4JGa3wQexIcIEJAOxnKgognMbygqaOJSyuVBjw3HS+s8AvqXjZGUpm9K++oGSrGyjBAFsylhIE5mArMmAvPRGLWBjiFEDqRTGNaUzI6GKZE8SFMa22Qc9Q01OXqYwrXAEKbk4CE4hN4Tf/0MLFvvBuoOAGPLzBjb9VJ505XCd6NNtDwmEDO7WKDjyik097XoMZoDDEIQoxiDN8AIoOwMAKhmCISP8sYhKgSAZurjGNMQhEELX7ygIOwAIq2A4H7uLDhIjQkCadQAMTwMEcRpBSXKIVlwHcGYuKF1MWQCACNPEExJDhi5848he6GAYx7sAQok7grCya0ZtM1tQrnSx/fblkX+ZCM6Wc4GDn6wt18+tVoNkJBS8gCZxc6oITlOAvZrVuWN0nCFPEoheQAEUthsELXuziw3W1qzKxhosP70IXu7hgZdK2ikdJpjKzeIUrTtFNb94thjeGYbN00AEdlAEU1yDQNa6jw+5sVodIZmdnrfFDeSIuWfGYh6zQQWVvwOMas5iEIQqRhzxAkQMO2E8KhgAHQ0BiEq6AxnkEgcZ76Wv/DDlQwQEckATk0o4PjSBEEvigIZAEQQMWmMAE5kCCQFsAT4fuiwtecBcYkGCW+2vBAsDrgUNA7ye88ImQeMEYRuCABe49q13kyyatzGWQLMXjybI6JbAoTE12GnALXAmnvJzgSgFG8Jr6ItZZnogkZoVTn9rSCAsjo1DMqF6HQaxMvd61xCXeRbQ/fLHKUEYzrYjFMy9oC0/NghSQaKEhJgGJcr8QD3BQgrQcwIB2D8AACnAAHkhhC2Y4IxpIrkaSyYPkdrqTWMOaBjyZLHBraIOe9ZzHPOIBj3CEg8oM98YyMHHjHXyAAx+gAAMcwIEUHKEPkcBtMajxkD4/QQ6C/6BdBRbAAkEgggiNwPMYEMEHMgRiDjkYgaAFHQRCz2gDGhhMU0kSr5WYdTA7MwELNlCjJuQhGM04hk99+pNgIGMUNThYBBbQv/79q38na2qb1ORHAZssYd0zDM5yELN4vcAKWHC0Uux0Pq0qVXhbHUlbUNKSFzX1BU/4JTEKBQ1oGMO8QvKFL3bR4U033sSPdzYuZjGLWsS4xZavPOUbCYpvGqITn/iEJigBiTzsQOMGGIDqV/9uBMQ7BWWABFwHBI/ay6pA6Kj9ec6pDR1SZ8g1/P06fV/Ebjj8+LOKDjfsGVpuXMMZpIAhHc7gWgo4QAEGyMAKpnCIbH2CFPMiyP/pBCKHQCRhARlgIwzkgAhElJ9eWLBfoKFr1It+TEW8fNGVdtaCo79pSxtgAjBgBG0AC8cmDItEdYyEDLHgAyqwAREQAQlGEmsCdiiwSXLRYA3BaKFUa+NDPgyhFRRIFnNABi0wAkJgBTC1PzLSgn2BMP8yGHdhVv2TYIDXNInUDFGHaR62C4rXeEAYJCZWQbWgV5MHWGOjeTA2C8MQDL2ACfTxAz+gRFu2Bh/AAKkXAFoYAALQhQKghasHbw3QAWvQCcJADVbWLQViTkc2ZL1XHcOSG9IgDcJSRAVyT6XVDUXEOKSVT9rADdXwC4ZAB3kAQzpAUA2AAR1HA3rgCI7/8AlMMQeSOImAgAiCEAESggQ5MAY3JzMx8AKBNgGHFopkkATURV0wSD4NNgJuYhd11wIaEBNOgAaacIAIuFPmdQyDVwcqMAIRiBZi13X9Y2oi4Rcj8QItoib/RV1yYQJdcoIjYALRaAImoAJEwAdWYAJf9VUn5RIxYgHcCGAvSGrF8wSbYAq3MHjNwAwchmkmdmLHJEEWxBmUV4/2eHnVZAuVZ0G24BO3gAl08AM7MAN7sAdtkAIKMABbqIVdyJBfKACsl3rwhgFqgAm/AA0JAnzaEB0A12/9Bi664UUZ6YZDViDVUUTasA3Gp5LdICzV0AykIB95gAZbcDk0EEUp/7ADYDAIi7AWTNJnZsI6C1ABSWAzK7MQLRABhrZzoggDgqB0I6AB+TVrpYZ2cMIlZgEDG8ACL+AEaXAIONFTFONTOtUMkTADJlABELBoNvh3bCJ2VJVffNd1syYSJvACdwkWoSSNoVSX0mgCc7JVMuJVL8hHCFMXF3BoMuImVmAJooBT4zUMJeZhyVQLGsMo9dgoKoaZr7AKoMGPoeETtYAJeLADOkCQNdAAqad6AcB6A+CFWwiRBVAAA1AABmAArocBcNAJs0cNbpgNz7AbwhkNwTmcz3CcvdEbxzmcwjkN1+B8xEcdiiMdjINk3GAMpFkHeVAHW8ADptkB1SIDev9gFWFRFa0GA0IAAQrQJcy1EELwAhAwAYg2ARFoARYwAi8XEyYgF1TZJq50MmrxFdHIAkiQBnVwPQjIUz0lDOzYDKYwAx6QARCAgcR4AhPYYGJ1PvmDS1uFAlawNEKgFTgwJXjpjNVIjUpHojsTSgcDaBoQdHIyAruUFyelSxNwUkuFBY9wjhc2DMfghHIVYpdpmZepMclEQXglGTFWhJEBGZXxE68ACXSgAzKQcQnJmq6Zpaw3mwUAka2nAInYAYYwC80gh7vxDM5QnMj5DNCApsnpDPaWnGxanMLpm5rFe9tAWQBHINCwCvLhB3ngB1mgAzsgAxwQLeTjSghWgyT/AyEQ0BBYwRDxuXMRGIGClgFjIAgvkAOAiWpi1WBoARdZshA4MKA44ARLIF47RTFjKQxRhwy9wAPMEwFzsT8rISV/JFYrQUki8Ed1kWA44IxmoRVORY0eUI0qwCUKQyNoBXQWUGgbgF/4hxZ3olL78wSI0AidY2HB8AtyZTXOFqRyJa69AIQddl7VMwurIHknBhkIeAqGoAdKgAHYx3oNyaVcyppeqHqzuZCqB28BoAA6AArHgJG80RvL8BsJu7DLoAwO+7AOy7AQ+xvL6Zy7hx3a8B3UMU/WwHDwwA3CUDd+wFp+MJAWxwHFgwJKNSUL8QI4sAAKsJ8iEAOwSJ80/xUB30Wfl6oChBASHrCVd7EnyhiqZtEVZvGizugDPGAIwRAqrNpT6zgMyOAHzFMBU8JJS3U+e7KXKvuMLvICe1ICXRIvLUAzLeCMeAl0UfmiHjCgzdqsqVRraFVrLlBJ9nmfB2OfLwAoidAIlTAKt1Ax4zquwQCkg3u4hRsMrKq4PtFty8Z4vPBAFPMJf5AHHGAAAPCaDXmvs0kA+DoAnksAouu5AFC6ALCQpzsAFLAIwVB4zLCwDhsqsju7sxsxxzC7o5IMyqCc0UCH5XEee+h8vBcPHgsP0EAKLjSyfVAEMzCQf5RfDXaBDPEVGoAAEYBUEFBT2ftdORsBN8oC6f+XjclaI4vGJjCga0phtGBRARWgASrgAz6QBbEwDMbwtAiog656CSlQAROAFsWooVnREkzXSXX3lnXxlqz4jGcbSoC2ASogjRpwrNSIR9T1oky3M/L1ohogAqJYtzaqlHdrVDiQBHKQCIwQCZdQCQCiCSwMep/QCSysCS4cejRcw9/3Nt93Cq7Ag8uWab3wCXnABArgkLCphQVwAEiMr6MruqBbAKb7xE88AA4AB62AbA2rDLdLu8JgDFlMu7I7KqJSDMmwDG4aDcJinXaILN1AvBHnDdcQsn/gB32wB25gOWoitEQnJgsBA+qJF6L4xzibszuXmLGICB9DPvpDjbP/9jujChYq8MAr8Cw+MAoQs8W2ewzMwAy+IAykQAES0L+oxALCekcv+CI4gGAxoLL/8iKpnDxFRwLSeDAyJVUKQ40PbAIe0LZ8KVW5PCM9c4q6xL4WAGjDPAIkzAd9qwi8Qwh9QAhLpAiHsFqrVQjiplrTvAiL0EJ6kAeMhc2tELiLdHjU8ws/+gl+QAEDcAABgMTs3M4HgK/wzKWiG89cagAHoAAMgAF6UArIUHj3liDVcMkRw7DL8LqZHDUH/brKkAzMUJzU0C1qeE/4RGUUjQ4EUg2uEG6FYAd9YASf6GCQ+iVRgTsjgAAToHMWUKkT8F0qLZ+BNgIlNSMugIoJ/2Nqv6OstawCHqACK4ADPsAIlWzJEZPJwuALtfABnyzKoRRKKjAlKoAXNeJKI8iWXKWy+WXVCWMCL7rUSx3LEZzLubzVMuWMolwB9umsxKwBFeC9OmsBK2AviZAIhCAIwFVRwEUI7sI7c7wHfdAHg+DXexCofqAHflAGbJAH1GwIi4GLRb1IvEAMweAIH6AAByAABIAAmJ3ZCHAAmJ3E9PzZn2ubrqcAFDAEn1CwhQfQAq0MC3vQrV3QmbwMx/CwZLwbvhm8zJcsd1gg1zkJOoYGWPsiCzHSQRAWG7AAC5DS9Jm9OCtolopoZt1Rfcl0oaSsyUqNqKQVMvXIKoAEOP+wBb0wlqEy1MxwDBNTBg5wvTKV3UwFVV+CFDmAYOQTAxLGRyixSzK1thpQwWgFaBlgwXm7S7tEFiQAaInZoi4aioMcgPYSCHPtZvriZmtUUXFQ4RV+BxiO4XVQB21gB1lgBmawB36g2GOpeD74YcMQC0rAAJQtupr94pnNzkf8zqCNr5adzpv9epfQuoVXeFgsu8mQDLN9u6zdG3EKp8oQxrlLxsHpuxurHX9zTrx3LMbiDKAwH2UQqiUBJRoCFzgQaAnAvZWavZQqn4nJvhpggvmN3TgtVb+jFcnK0zXgBEgwA6UgdVvMxcewjspAC8dACRRgAW2OPjYCFn3xa5//iIwloJXbyI2wrEv7LcosUN2TrsE/298CjnQT0L6AFo3OOswMw778OwF0tFG2I0b68mbG5QZuIAZfcAVTcAROIAZpUOtd0AVskAY8kAU9QAd1cAi3cLvCMCqlwnjBQAkYwG5JnAAJoADOrgAw3tnuTOP0vMT/ytnQngGK0As9Dg2xGyq6y9oEXdAJG9sLbQxBLsZMfpx0KDjzBCzi4R7hQFnUEB9lQLaQ6iRPUBLEjNw4O+YtzZSFFAFdwdUsICUuS6pkO2tk29On+gU1ANTUUwx6zue+wAutkAIakDsluO8vEAQfERIxkagn8qkZShh/FICKfLYouvJR+bbNKifO/22fURlKHqABzJPzGSDM7rtRE2IFxuUgqkMhG0UhX3D0UGAERkAFSND0SOAEV5AGNMADPIAGZsAIwX67xK54vsAKMuAADQDtnI3cyP3sZg/t0i7jnz26lu259ozEAVAAEDAIsYCRvtGwWRyxWDyxsPvjYrzQo7K7xBmcdjpk7i6dikNlengNywAK88XKOSAEJwKLlRoBCMDcLE2fbL35A68BOTDp0Vi2YNEVBvEVSPIVU+L0X9AEddAL1CMMEWPFxjALveADFZC+QhAEMiEmUoI+5yvfUwInXtciAsx0MHAUJqDye7m2qNisrigjoL7VGvzfL2pIOR/pJjCix58DL/8QEw2SAwZRlKSKAzdwAzVwAz5g/udf/kOw0zTgAzQQCYyRxYtUXrbwB9bH4plN9mR/9s6e9gBx4EABggULEkAoQACBggYOAAgwoIGeWM2gLcPIbNkxZcqOfVzWzJmzZiU1GiuW0pgyjMZWLhvpLBq1atds3uSWk1s8eOjgwcsJjYQLHDCIBgkiBMaLDRMsRIC6IAGECAugTsA64eoEqhEqWGgBgwWLsDiKvoCRQ+1atWbVEkmSpAmPUsGECfuIrJnGY6+CFcrA4oQLGEvTxijcQrEKFiheDI6BogQKyidEiCiR2YSKFi9MbBgBY8QG0Bs0nB4x2rQG0k0nbGBx2oP/hQoVtlZwakFrhAkaNlfIYMKDhgwaUmsYzmL4iOEeMjz34DxD9AwpHEjAkCKFpVvEgv3ipUuXLVufPlBw0KABAgUHFixQz4DBe/oKFCDAj1/gfoEHERJQKEABBhgAAAMHYACPWaApqcEGQcIoI2Ym3OgjC5Fh5pi78FpGI2acgSbEmDTCKJponFnGI2FIGYEFF44KIocTgtiAN6yggsA9qriycbcbbYuAtRwKM4vIosxCEocXysoBhxySyMGHFCixC6+PStqolmAuUUGFE1o4gYQvXUBryBZYMAHMGEQ4gSkRULhMhNZEGEEDztBM8zPQRjBhNN/qtCDQrHibDrjT/057agLcePsKN6c26FMx4p4r7rkKTNCggkmfwwADSytwLrv0KMhghUxQaaWUU0hhdZRPmMAAPQfew6+B9NRrgD5d7bMvP18HIug/AANQiFiFDAzAAAUoMISVY4aBdhhhgAHGl11omUUWbV2RRRVvvSUFFHHFxaRcTCZBd5Jz010XXUxAUaVbUlSZxBBQTCDLhRyIyKGFGFrY4AJBs3pPq0SdyuoCrCw4DdK0iCDiCSJewIGIM8MqDAa3mszYrBnoCCavkiw8JphbbmkiuEghi+EFtBJTwYTBTpCZ5j5BMyHn0cbKWbEW+uQzZ9O6PJS404qLLrqYX/CgNuEw9ao22v9yXkEFD7q82oMVlDZhaz6TxlppD7TjYAYHHKAgBRlEcfWTTzop9xJDUqBAgrMhmBW++OTTdQFe7/t1P/8AFDBAhhTggI06epChBzwM+aQUVXBJSZlvL49XW1py4TwXaoFJKRmWYnomGmmoscYmbbTRyZufXKdmXl/IchJipMREgYSAL7gAtAgSiKDGrIbnHTU+WdAY4ickbtJnl1928qyXYajBBlSCiRaZYLYPppdYehkk5j7FfIGopVwgS7GcT7CZfZr5dJ/PxUzIGIaf/QwUudSEsy3T2iqQAKmmg4GzUcBTHpBAAJ8jAd8IJ2m1KQ4AK3Cds81KAQYYgAIaYB//BnDwghEZgLIW4YhyUWISjnDEIsTAqQRCAG+2whWu3pOr+rAHcPnpTwESUjjDEYABKdCDIhjhiEG84RCwgEY1uPETeFTDiU68yTV0MkUq5qQbV8TiFcOxxXCgw4td5AlQZEGKXLgCeRWDWA5isAER6A4rvduA7t7zlB4trHesadFYyBKxJpmFYl1Kn88K47LOuGxsjFAVqloxilKUwlWjuIUmZhCzFqhAAxYYgVqQoiT15axPNXvM+tjXJxbEbATqO84ldTOBAFKAArWx260a0EED1PKCtSTQAAKwy13qkpe/3KWBhDlMYhbTmAAYACQggQlKmBASjjDEEKgDQAng/62CFYyhenblN17hEFiE46FCBlCABWCgBnEQRBxW4AA93EKJroPHTVY3z2xkY5735EYWr7gNfXYjHN3whj+3CNDXAYMUuKgFKcripCDAoI1y4h3vSHPJCSwAAhtYZVYs0DuGBc2TZ7Sfz0yZmrJ0ZinOi04aJIGJTojCE5eAaTMx0QpTLKEGzllBnUjQpJZVkgWh7BNrVKkbqETAhV3hDW1wtIACCCCYwTxmVKPKyxAqy4Ya7CADZmlRGKrHAbFKoAFdeTYFMOBskbgFM81FiUj4wQZYy4BtWpjAa6YHmzTsm99+FaxwBqgAAmHPexSAIAVRwxveQIdN6pkNa2RjG/+r20Zk+dkNx0q2n1n8Z0AFClDXLYMUu+jF29jnJ9IM70ZFvUoCFnAwQW1UYMZLTWryBxXb/I9hFM1NoGqjlQZwYBCHOIQjJDGIQRSiEIYoBEt5UIMm4OAGKvDMl75kv58ahWYnWIonaYZRqPhvf0DTAATyerZclbeuZ4sl2lyJAQ5kIIEYGA5wqGM1GFhtBVurmteEGh3huNIDJsiACnCgghTEigMdQEUvOjGKEkZiEXngwSStRpwEthI9dnNhXbWpzfp085sECucuxTnOhwRAAWWQBTSkaA1rTMPF08BGNrAxYxrTeLH1lOxkI3vFw2Jxi66Lhipm8YtSfEITv2L/yAECJxDV0md4Gw2Uaw81UdAgYJcEOYAC3kMVSPWJYbr5ilJzRYE9AFcRRDyuIRYBuVuIogs0eKsKcjACp2iABDAAcAZOAKgGaiC3Re0NbcN8W9owbDXDUWrUEghB6GQgVuuNa6f+OxxMNe05eTakc5qmqNowZ9L/LaUT5LA1A3JABrG4ReRKSIlF1KEINKBB1agTq065soUQSO95OSxYwAFLhwPgIS/FSYACQeTEr1DxNVqMOmWzuLH11MaN7zltKx62x1n0xjVk4QphnOITo4iEjcRrUQjsxqgu1ApWyu1njSZMYPlrmGmMqqir0EZqQ82ooOBDATcU4hCKUEQf//owCD8gFxTI6AUjeOAD51xyBLo75QiKgynd1oa2OPKKcZ6TKYYZbKjpNvdVigpLDDsA1wksDlVqw5o0geq/XXrOhIGTgdsKzDQWgNRXTMOcAFPAAxxoQi96wTaWjgIVlDCDTX1wgxpM+DkceHSFpU7Xu2Gzb70+SLB/OaBiI3MisUgiTnQyTyqurorWRjvatXhYYKjiGLogxSkq4Yc0bUC8EVjlVgDNG777yLQajTJrekPUdP+PNTdf2G5wvuUt+OHfihhEHwhBCEgUghK9IMYozECDCoyANyRggfxGoCkNdBfMpVdU6ldenEuCRlGIQq1WXGhUcov3ml2loa1uJf8B3OAcTQCUjnNApamjBmrkT7Ht6nlPgUEQIxadKAX0u+PmLhgBCUa4gayf8wEOQL1T2MHA1NGb3l3rFQG+1jowAyDMZLETFk6kojfiL/+0W7t19q/iNapBCw2xKhaGwIPh4I1xs4qjOqpzM8AELCqq2JF2O61zQy3aUqrhMaoKjIAaiARHoIRLYARGECJGWARMuAVoiIU88JRxM4EcoBSRWxjMGIELKDe8043R6I0RaCPpIgHdQRSc28GFUSXcgIFMyZq4Sira4L3oMA7sko2mASDhOA3LeAyJg4DpqBNNwbsRYBgSyCQfUAFPaAZYIIVScIRSQAVRsARCEDgk8IH/GpgB6aCUR6sb8dO1vZmPXjm/rCsWYxEQAsGy80MAClCCVmiGJ3qiEDEJvjgGlAAPXLCFWpiFV3CFb2GVcaFEUliFW3iFU3gFUsADSGCBBjgqqbCKCjxAC7TAv0s311oNdnvAkeu9vMM7heGNB/AKFYiEDbwERbADgHOESICEU4CGY9CEFFABCxAvFkgCGrAa21glC8AMOWkKeLuthcE5MdGdVQwUjEq3c2Olo/K8sKqb2fMKXMMACBIqEvgfCWiaOOKdE7gAODk5CDABCYCKDPC8zrskDbACHEgBVICGVgjDQeABT7mDyeuDL6ACH7ABWUsaR4NDV6obWZlDrZIP/14BrIEAJz0MkAFACCwTCA1KgUJQl3IBhRJKl0lQppRUSUhYhJZsSZZcs+NaBEiYBE0YhVY4mVaABVTQBEpQhAwIRdWixb6rI97JxkDpnQvQADhqoxzMwdSYKHsLs8Pjk9KagMsQmAuoQAw4BErQBE3Ygz3wgUpwMEoABWZohlbgAdvIFQ1YgQ9gQt/QDd9oCq8gRd6jR0cxNETJCiA5jW3Em2rCtXGkxwQ0wAAKqwTyigZQx3KbgAsIgQcIAUBAhKWwALqawgaIFbqBugyoG/iaAU8gBjFcg8FKlhUYBEI4hDtwAy4wAhtQRhVgyE+pjVqrG7TJNa/am7+5w6ZyKv8eyqUCIJBaqqUGSAE1GISXXDNDYM5CIC6C84M8qIM2YIMz6ILqZAImUIIe2IEdmAEZkAHtkIEZsAEl2INLgIVe8ARFOIRUIASLEy8IMEqFURiEeY3d2R2lbBg5acqx0MLSyMeGEVA+Ia2AKS0X6pRD+EpNMINDWIIzuwRKwIRhgAZiGATbgIAGiI5am4661ADlQA4VeA5XmrkMoC3k8J9LkitcAw4Juk0JsJU4ZEwJmCEN0z20oaZxe6MLeIAEeIBQSIVQeIRHQAREsALe+58UKJX7SgEaqAEx2ANCGIQ7SIENujIDWAEhOoQ+YM0vmItYs4EaqBqr0TRLsU1buz3/8oqPDrtDYtuhwiG2qjIA/NAgCuCAD9AO7Zi1TqEUh+yUPwXUh1wvDkiBGeCBQcgERiAERUAGWMiDDyhMCBgYx3wN2tjB20KU4tgADzgentkfnjuaOpmyOtmf0GsROqsA9qoDTbgEsJSBO5CEWKWETqgFaEAGTXiOCHAATnE0SyGOq5kO6vgAT9EO7WtIQI1IPu3TO+0+qPuAZ8XTD5DNFYA1GpgBGuCBG7iBIRgCKLgCKIACKrCCKsCCGODRBwABIBXSIVXXRwCEQECERxBSPpADPeiDONiDO9iDOKAADBongmCPGxgiIuJS1mwCH0DYG4DNMR2bFJCO2kzVOKQr//KLj626jxwCpwAhFoYoCCXDD/iooL6pSAVIADvUjwMgzpRV2VviIAxgAj0ohGpIyx5oL0GTwYCpONaLK6TxNOpAms0IGzekFENBjuGQDU/ijJn7ADP4Sk+QBEuAWkuQhGZihVgYhULAGgoIU/JcgRpwmRqAMx7gASPggiYwgi/wgTRwgy+QAzFogzqIgzuQ2z3gUoGj28iTPCkVuMgLyzvIg7/12zuQgziIgzqozjOwTm41giHQ1udagaFAgQsAgcmtgskFAd6RzCoIhXVd10YIBEFAArthAATwJREjgAAgAARYgCFgBEmohENAw3xd2ya4vqVbWCYlU9pM1aiTOv81TQ/BOr9v6isBIIhxUggCQFkCWb/1Qxb166VcklM6lQ/50D0GoIAOkIEf8INL6IVnOQU64L6zmS8kDFal6ZLzpVZYu6+urYEbwAEfQILrsz4q+IIvEIM4+AIokAIx4F8xYFs5kAM+oNcAHoMx4IM+OARO+MpKqIRYjYRK8EpYGIZbgAVRkIRESIRGYATgEgRC4ANBELg+AGAAjoP7tV83SAIqQIImONjlctJYi7U8zYD2ekOwqjD00E1cod413RUNeg90BQQgAIEeTQAfLeIiBoRUqIIqQIQqeAQg2ATKRIHziwj1I17VPQJFiFUPNMg7iAM3AGMVNgLbFVMmdVj/n/2fQL3N28sVO8TIjHUqYiGQ0/2lXJrTq5reGCogA7LNTjmwDugAaJWBQJaBHcCDPzCEUpAFWliFUriESIBdSWgERWiESm4EqY3aR4DaWLXkTq5kDAZlDJ48USaEDA5lUZa8PqBbVZaDuADjPagET3BaSXhkCIbgVlDPPHCDSaoA7ejTG7abXCMvNp4lrcqV6UXm6S2rDuLNbuoVlc2hguBDAfDRCwCCyj1iI/ZRdBVSEHiEC3iEOSjSikKAYSGWrYuIA3AANziEp7WESYZdVZZbLxYDMV46plvf823IuNrdWpNDGuoV4f1NEQsQYuqlOdWqCrpeQH5W8NSBHfiB/zKQaDrAgzz4gz+QSWVKl3GxxFVQhTCMPkXtAzdIAy5YAsbVVvVdAV92NIl0gDyuWJiG6VnqJgRQWYdgjwJwiLKqg0jw6Z/WQGVaBD8I3w1iD5tWWehVauV1XmCSqqeG6qjy0clFVyImAKoGASBIhVQAgkcgAzJQYhFIAB0Slo78K/YIIevtA0awhERlT+fMVzuwgzogadds3IUNG6vhlEeDQ2xS05HtFR0qljysYzsmTgVwgCFoBFOABVRz7FsQul4YhlOg7MpehVNopMwOw1NYhc52hc/+bFLABEg4BD9AgxmA1jt91j6NtApY4/Tw16xK5tlW5me+aQJBAAfwAP8GmNOy6oFLqISY2kATogQ8oAD7wCD1i+rlZu7mbt4q5iUE8NHIRAiqLuKqBoGtDgXNZWIUSIADMGuOTTIlQ+6y4gBJyIS29ukNPoRCUOW+7dLrOwLGDdP7ks2w4RTve7Tx++v50KuB+E2NFTboJc4QagDUFAVYwETQngXysAVWgfB5+egIl3DM+ZZCyAO5jgMqaLra9FM4rLC7Wo+09u9k9rADyCXnLSZegogQwoBFuASWMhdMeBs68Nem/qXnxvEdd97S5XEcD6Egh94FeIAiJ+LrRtcE4FEQAAQygFdAsACmMmuD2A86LStlYYAP4ARTuIRZjgQPZM/U5Ns7sAP/MBaDbz0C7AvT+g5a6fA+iIRIEe+gOxynjNTI4BTOcUIACbgBRRCFT4i7Ch8jcalwC9cWWeCczwGdZGCvaPXMDM0mvpkPY84mGJpDOqztv/mbikzo+PiqD8BWQ0DPYTgGZDB17fmELJgBDsBhHTZxTYf1WF/mhC4g9uq+QP6Ah4boicaDQ0ZkQ9DoVgX0eflsVWhkVAhSIweBbO5RIy9iJaMVBPgr/iAIhwAsG9IqAzCrGRCFWxiFUQhusnQED/w32B3zeS7hL3ACI2B3NY+185Vh/T5TNv5vgdbI4yUIp0JeBPghOzAEUvgFtByJZ3CGZzB4E5GGZ8uGfNIigeIi/y+CVu2QzTwdzxlIXye1gYwXWx8ogi3ggi1AA+rMgi3weLNl4S1A2JRXSGudgZbPUwLL05dX7Q/YgTLQA5ocdlYpBUxYBDygA4kGejqog7/1g4y+xVbthG8DdFVZhVbQyVo4GaHbnmgh9VI/9au/+gnRegrpkK2XiZFgBlMnhlB4gACoaiMucm1OAIZIgDsUAP7wFV/hoITmdwrggVFwvlIIbuCWhAzsQIAz972VZy8m6TTw0oNVyBpQfGuFeWjd64iUFW0KaN8kaAFBiI39Kwe4gT2Ag0l4hWOoBniCh3hIB3SIh9Ofh3iQB3mwh9anh3t4fXqQfXaQB3aggzPIAv8m6IHd5wEl2E4e2IFqbXlY2wGx5YEe8H3f3/0eYIIsyIIlWIItMAM0qIM60Fd/Y88husW914RM4ARZBn+XailHQoXyD8MIx2zIhuxeiPqpHwZigP9TnxAHaZAQsX+LsP/81//95//8N5H/B4hoAqVpyxatGTRkoQgIEPAAyIMHFyImqEgAAYECCQgEyFhAwAAEIhWQVICg5AIGDRxAUNAAw5BSzZC10qTp0qVKkiRFkuSIEVBFhwgNHdTn6J47d+K4SUPFiREfUX3YqEFjhQqsKjx4yJABAwcMGCg4cNBgAVqRBRg2FBAgQFu3bQssuCFIjyFImFQBe8YNXbzA9gb/3+tn+PC/xIoX/2lsqFAhQ3khUcJkk5MnT6NGlSplChVoVK1awSod6zTq07dU3+rl+nWvW7Jlu57dupfpW7BiyW7FitWrV6NhzY5NO9iw5MOOMUeGbBmz6M2mO6tu3Rm07Nq1C4xG7Ts1geDHW7N27fy1bNiyaePmnps3dOiqcYP2aKOABA8v6H+AkcABB4gUwVpyCXDAgSKNlABaCqi0kgQRLOCABUOMkt0xn3Ri002VeKgTT0CJKNRQhBx1lFJuuIFGU1w0ERUPNdhgAw0zpJBCVyl8EBYFFEjA0lkmHVCgW2+1BQAAcIGkQI8epICBAx38Qcoy1cATzzz29LPP/z6LefklLMGdthtvusB2JpqvmWkmbba5OVsts+FiWy1x3lJLLLuRtgostczi5yuuyCLoLIXWmQsutOCyqC++/CKMMMZIqgyly1T3DKbPdBeNNOBVU8157nkzKqnwmHoqqqmquqo31QBS0UYggEBRAmtdlABGCYggl5JwLYgAg2ipxJIEFVSwAAQeRDFKM9VAU8ool92EE046RfJTJJGIyMgh3RJiIlJKLaXiFy++SNVVK6SgbgpeZSBBhBCctQCutsb1FpJv6bvvAAYYwKQSmAATjTdYFrbllwmvsvDCp5zCMMQMu+JKxKpYfDHGGatCysYae2zxxLKIPKjItNCSC//KyyRDaTItJ4PpptJMg56oo8IzzzyB6YwzzjrrfOWqQbM6KjfnVUNNdssoc4wxZoZyAQFsJQAEf7BeVAACBzD0QK0CKvh1SWE7uJID8CrgQAZKjIIMqL+Q8okm2SpSCCV1U5JtI438xIgiiiTy7R572GFHHeSquOJTU/lwQw1YceUuBvCW9WODWRdweUP76huXAAUE+PW/DsjwhyzQeHNzYV1yufphh3k8Muwjm3wyyrXnAgzuuBezu8uUVrqMpTBvOg01xJunTXvw1dxNNzZfGQ9g6Jj6s9DTU/98YKbKR2rR00STqTPKJANMLiJvDAoomEwySWN/4IFHGWXoMP//DjLY3wH+HtAbNUcOcX0Arg40pCFFjWsKSoDYwoYWYUGIAhXIwAIk4AEtjOIY1OBGM16hoUxIQhGMuAQmQkiJnezkWozIW98g44c95EFcKEqRU75AhagwLl3q6koFfBQ5eVVOJFpri5I41znPBchr/3JQB/BACmNw42b2KMxiWmeYTHVHGjKbRnnWk41sMK+LXQwHGMMhH/loDx3pOOMY05gO6J1xjfKIxxvlkaXB2CNngZEHHgPDM5zBAx1NPBX3PhWN7DhDaUwThi8SNTFSMBJ9IZwEJCBhiMa87310KMMO5ieDD3wAf578JAd41KMPYGBHYokQrPAjAALgClYF/+iIRz6in1QGq0EOYgBaVkI2CWDAKx6AAAZScIZRDAMa16jGMlzxCU5YwhGSuEmHPuQhEvokKIy41iEGUYihFAJc4rpDG9IABSQMoZw3sIHj3JVDCUCAh5Ub0gCE2JYBXO5yRRxAvxwUpTJMAhcEw5KW2NGOduSDS/RwhzgSOo4zLrSNZ2QHOxzq0IZKVKLruKg6MqpRdZzjHO5wx0BDao6PkpSk9KgHSvmhUn704x73mIcySIG+maZPfeuD5CIk074/QAYykpFMTwsxiEH4wQ9/yANS66DUOqxBC0rYAQ1kMIMZ2E9HH7DqB9zFFQ9spSsWeAD/WMk/WiZglWuxp/8AFsC1Wi4wJQ9aCQTYCa8HclUFEtDACtowil4w42jUOMYplqmJSnCCQ9SiliUSawme8EQTpjCFJjzYt24VZah9SEoc4iCGK2z2CEOg0Va2kgFjRaCdZWlQgOrJlrbE0p4HoOe/GKASsshAicm4xs2+AQ5wkGOk/cjHP/BRD3zkQ7jvKG4+3lEP5baDHs5FKUrpsY6SktQc1jXHRq2r0YsO9BzlKEd3vfvdjna0Hd+97nXrQQ95YGMS8tOB+yr5vjzwFDJ6KGoh9NCYovphqJEZxB9WeNmiIjWpdchDHeCwhjNogQlK6AGEMykDHQzhBha+8A1ykIQcWCEJQghBWcX/GjVY+bAiAvSc5/z3gLY2oMUtLkvZeGksX6ogKzWQYA30qgtkQCMa14CGME4xClFkwhOcKCyHNJGJTCg2sZWwCSpaU5NKOKLKI5rsIYS6Bz3cgctxuAISjHADGlxlKxoYrQR8BAEH9HBIl+PfAMJaz84J6JYM6JcBGqADQ8jCGQTpxjfEQY9+4OMfqjM0og/dpXzkw6UHa6mjI92P6B7UHRd1rnNJ2o53vOMcnH7HQD8N6lBzGrrQ3Qc94AEMHbw3fvFTgxrOUIbBtaHWbZhCEdaghi50AQ1pSAMb4CBspdpBKUqlA7LZcIZll8HBO4CqDJTAAzLbz34ruPYKamDh/yE8gQg4CALU3hJWWA0RawhA8eUGoDWJrHiBMJ5cmjFAVw3UNds48EEGVHCDO4ziFsNoRjQ+BY1fCNkTohBFZmyyISUvueGZ6EQpYBEMZAQjWh8i4bWyFZRDGGIQhDDKUsQAlag0TgUm6AoOfzSvBQjJzQXAp5xtZc+TKEBf+DRAB8qAiVxEo4nxeGI//hH0oQu96ERPGNINvTouJV3pS3/60/GxD0jzIzEvRQco4hdVWbta1lmo9a/FMIUbqCADGtDACFhwbx8woe0/+MEOftCDMmQhC3LnwbOhStUb7WhHYRlLj8QCeLHkmwUjWMC+GtIfrRVxSHTGSEMCNIGJtP+z8vCigOAzwJUa29jCRkACFbJyhD6IIhYThwY1BP6LVYzCFENGOCc0xIlN0H7JNvHEKXrBY2QE1iaHzUm1dFJlD3LLRElRURrEDFrOdyVyZQmSSSxnq7ByBC4MsT6S8nVzBXzAEKpwxh+lKP7WKTrR5lcd1Jt+fkOPn3X9UKk//nGPeDzDfVqg0dvfHr+384AJRZgBBjDAa8EF1ugTBXDAVX1AtckA33GS34WSKL3b8w0LjJFNj2jeAsTFLK3VWWXE1RTR9QnIBYTAA1ReBBTLA/lSCtiYtt0bEjjBF7iBHNRADVyBIYgCLPTCMTiDd6jeKaCCKUALwo3CJ2RGZtD/3pGVAioEAzRUA+9FS5JFYSYEHwk5glAYRVLcgRiEGeOsQJnhkJqxWZtNX9QUieYEQPbli83hnBIpwzWQGqfBYUiV1zvgQx3eoR3m4R2KGqfhAz5sWh36oSD6YR/6YUnVw0cN1NTlgz/ogz7sgz3EQy5MQn4RTiHsVH0dgh/0AQ80ABoCgL8EgAGoRAfIgANQgA3wwBdwQRvoQeDcgR00xeE0RbmI2TldxQysQC5iGy964eexGbDox6wwSIjJ3FmdGxp2BAJMQAhMwALAVVxhXi9pXr2twAt4Huh9gRF8gRgcgii0Qiz0gjAoA0KAyl+5wil0xpB5giYYGe3VniaI/0IpFJMTvs0lTOHvUcs0lRDffNxlGVsaNMG01dgN8ciPqBzLZU1qlWHmzNMqrVIRKUjYDIuUYIKohdSmYSRGXiQfjhogduSnZWQeDmIfKhdKKRdKOpehOaI+tMM8cAMo5JQfIFtP1ZdQOcImqsAAiCLO/QEsHAMyHEMrQEIDZEANtMAX8EEcuKK4MMWv1cGvmQEXLIEP8ECF0aBVYEUv0qCF6Q+9wArX0AsBIQAEvJbnKIi+CIgFxMAFtFMERABdody6eKEN3AAO5IAROAEViEEcyMEXKIUiiAIqEAcujCPAmaMwzAK0bMYoGBzCeQISxuMn3MKn9EInwA3DOVzDBf9fJSzWTwgFuBwfF6ALjdzQV2AeO4lh9FkOQ8oTPdmTAXjNSJAEA0RJplnaReVmblLXbZpUb4LUHJLXQIEUcW6a1NmhRmLkR9FDqHnaH8ZDMvxBTuUBHtQBZGjTUA3VISjCHtxYgwTD6YTnqJSBAqwADhCBHMhBUuTB4ChVG7CBsmlB3TFBD/BAEVTYOTUOL9KAtt1AOWXAacEKBDDIucnSApybSJCbryTABVRBCMCl2dWbVNUAD9zA5zmBXvKlUuxBH9wBhzrCKIjGafTCMFhKwCHTL7wCED6WKLjewWUGJ3SCKHzCPBJDKVxmFCLZkRXWZjpZNZFIIXQoVDaBD1D/Zcl1hbv4iFm0lQ+9HD49KUjgUz1djr8cgAGcZdh8FEZdFG7qJpe6gzyAqTuww5iWKZmSaXEWZ3J213F2WnJq6TocVDt42j6sQzp4AygYwiLowVJlJ38NFSEwgiCoAATQiwKUAjTgQhmQQqvoAgc0QAUEwSMEghz0QXu653vGZxYwQRY8GITVJw/QCJnRQF1u2xFEwQ2YAARMwIAiS6EqgNZgzecoQFsxRAHQaoPGgAXQG0FqWyoWQRPsJV/2ZaUexbf0QWRIQogOJmkU5jEwQ3YwgzH0Qiys6GNd6+tpxihcJtwU4Y5+K7giWcNZgrXwTT8OQlKkQRekARd8Fg3U/9hWjZaSmgX0SZ+TPmmcEcCTTunnnIRsyQNEtRFE4REeQRQ7cBdIrcM5KCzDLqzDnkOoZSQfhhSo1YOh1UM7uEOlfRTBykM63AMi5oM7SI8z/MEk4QHhsIHHnYixfssYnEWtXMSPBAAGdIIOHFEEZEIqbEIfDIJSZJaKtIEb1EE4ocEZmIF85t8P8ECopiIP+ADU+sAQIMEXfIEQbEAJNOMCRIAz4goreQ2tIstbDhCyTAAZVMEI2Fgq+kATLAEXpEEbKAXLfgtRpNB2XsKytsIpkIYuCMMxNAMzLMMxDAO1hsa1Hi5jaogmyCiM7mjjgqtNjGtO+EQ1FYXgLEW5dP9hVnTVV8ALOzUALrWcm0UNvj6pnMkmSYQpO6hDOqjDwcrDOhxs66aDOZQXeZXXnNouxH4kSHJkQYmsO+ADpg0vPdhDPYgsPYADOngDKeDBH/ApG6wBHLAsy+6BHKxA9HVOkrzFkwYAsjxCL6RCKmQCIaQnU4iBGKiIU/4ar3FB3b0vVUKt4jytEaQvGeRACZSAC0zABEgIrgALAC0QBDyQBiRk2ZIBIMDANbJtE6SBG7RBHXhoH9AtISRCIvSNB1mhIjiCJrQeaChhK8yCLfwCcxiDclBrKxju4T4WZzCmkRkhDMNwuB7ZZlbC5GpLNiFFHKQBEiyOjHzhaPWS883/S/Sllr045EN6hGwqLEc1scM2cTmYQznc7u1yWkdZMRWTV++KGiHGYUiBFD28wz60Az6cQzqEAzxAQ/uwpxmoARwYBVLsQVGJgiSsgACKhAe+HDIKwAWEAjGIr/gighxkVvoezq+pKxckMheYAdJuQRYsQRFMhRHQENu6wR3wwRzkwAm8gLwWKrCIBFqUTQV4gNpVQAO4RAVMQBUgwhMkAdVa8h1cFod6XN+cUN44Qk9IApXhcjw+FirQ6MO8wgj/gmsEgzH3Qi2QRgqv8GIeHOw5cwzLsOMambhmgpLlBA7TbYeKwQz5gGehk2niyFesWVv97+iSrjyZVQEYwHe1/3MWvzN5ufM7h1cVdxoVc7E93y7Fzuk+nIM6wIM3yMJ8RTCwaQEcs6wfxAIyeMIQsNnLCUhCQgAQhAIgV/QjjAH6yuIhhxO7JrIZbIF81t0SQHIRFMFIH8HndUEeDEUjCAIRrICxVIAEsFxJNEBcVYAK1AASuAELUMBKaMAEYMEjkMEYyOCJACpRnNBONAIJeQhOZEskxKNnmMInfMIonAIr9EkOvslqwAJoYGsneMIniMJmHFxZOzNaP2Y0U/Pt8aglaEvf/M1lxcEXOMEVQMFVqosK3EjzpebK4cpCkm48GUhcDEB4jVc7bJRGjRd55SZ2ZVTDwjPu4m7uEiI9U/+xYewDPrgDPFTDJOQBfyHFJp6IIPDBHkgCMiDEH09qEHgYGSDCIwByKFC0bAtyBLfB0baBFrBBrSlbI3+0I8+ntDEtE2jButrBdvKEJwgCV8i0A5gEdLsEMHkADTRBEyCBCcx0aYlAIARCEoyBHMCiH+iBNnVL3+TNNeFyLjd1JshjEHKGKeztbpTGauQJmdxGnowGKnjGYr4etrawETouJ2QCEiKZ7y1WIjSCBRPFxwmOujZB5h6pB3CSVyipizFAEaPbarnmANwuY2dUO6vDOIyDFHdURjFUG6lDbkp2Y3Np7gbiZd9uZuNDOaADMOBBHsgxh5r2CuWBUfCBIBD/giZUQzP88WwfOZInOW2LrynIAW/jthYwGHwuG9JqgRaYARoE9w88WN4VdxrYwR5kyyV4gikcguN4wLHUtANEAAaoAA8YQRschRSowJpbwAUgQiOQAR/wwVH41CGIiCM0Qk9kS1ODSCUUWQv3N1azwt6msH6TRiqIaC8YMzFUei+0Qik85sF9houuY2YgXFhD5pEt3E1YQsNJArfwTQ7fAdE2BRJYWA1w3l6bElmoXOh+DQFtuBDFc4irQzmQAzmIw4iLA3pZ14iPuHZpFIt3lG52l3HmcxbPuDhowyToQI7nuCvKMX0FWJ9TAn0ggykAgqwI4wOAACA8wmw/AiAA/wIi0DYxCMIZ9PaVR/nRVnndAfemKsGDlbQSdEHcBuoldMKy9oFV0KAHOMCDrHm+4UAT1MEEE4IgUEFX7G8gZAIiBPnf1HKV4TI1jZA0GfolcAJZE6FVl4LDdIbJ/+CKKuEoHJk8imgsLDO0eMJlEiF8v54zV3URPu5lcIIpRDonUMI1AcVQ/CMsugEXIAEOME5W3shXiMW8rlyGh5UQTXE7Azs5fBewJ1RCtfN1DTuJJ3vtLntuclTukjG0Y7ahcXYylMEPFBi2B45RHdUm5kEhHMOPxQIiyEq5zwoIVAG6hwK6x3ZFJ8KTs4GVR3mVW3ndbUFwt13bKYHbpkEsK/9CVJM5LIwCGsjI591ABcSY5pknnA/CBnsQISCBChCBCcyB4FtwI2QwVJMQuVYCJXy8Tjh1WCOczr8Nja6Cb6TjZmQ6O+ryJbRjY3KGOm7GJ6BPVTszC5s1EYq1NAvmpN9CKWBCJJSrIvjjP7oBFSCB0kOtVey1L8krQi5QhqtWWGk91rc/178//HM9iUexFNM/eim2imNU/qt4psFzYuwDQLDzBkrHDjt58tzJs2dPnz0I8wwi9PAUNGjEECUAIODBAwAJAAEKlSpUL2IkSZpixKYNGy1ZsjA5Y0ZLzZdZtDBhomRJzyU+gDZJc6fhIUaSLEW64wSJFStUVFSokMH/g4caRsQMOnSoUqVMlQg1oZKDSqhQjdA2iiSJLduulixVokSp66VLXSvZ1eSJr6ZOnz6RWtXrGLJbp0aJSswpkiNHkSLl/Ttq1CfKo0i5woXr1N9PnhSXKpXY01++njih5mTKJDJkrTpRugRXkiNFhwoRGtTnzh03X5pwaeKDB40ZKVKoqJqhgoQIECA4aLBggQIE1xEcKLCdAAFy38uF//5dXPny4MynNx++nDn27M3FVzef/rp16szVd0eP3jn///37559+4nmmDBl0sENBhYjig4+HGOqDjz4uIca1UCYQ4KMHAgghlEc2GSkVU1IpMZZYJGHpjJpiMoMmm2DS/+KInYqoESjigDKiCR2bQAMNN3x7Yo4hiTDBAxNWuMEHPRxiJK9KNNHEkkHuiAOJTUzZ5BG41sKrErjikmuuvO6q6xK/OukEkzUx+aSVY6CpppfLPKnEEUMWWSSSM/maDLBSYOmll1VIAYWUT9IEzLLRFKNMlNP4erMZi275JMpMMrGkNkU4PUQ33twINQ0ujOChhhlmWEEF5TRgLgIJJIiOOgUUSCCB7LTbbjzwyFMPnF+B/TU98co5p734kJ0vv/n+my+dZ+1zpx5mATxnn3/u6UYVGbito447FMyDjyEfhNDBRnpBhpiTQrngARAQGUnQEs1KJRYLieGkJTZmiv+RxZh0ymmnJX7oCageeOChB+KaaMIJh0MdIxBAAiEDhxeU/KKLPQZZhLIoo/REEkUIceMRkjINs0wyLSmTLrvKhPnMKGWjJBJNWkGmGmRQ8WQUTzS5cxFHZAPZr09KaaWXW1YZJdFPQInaUKktM+UyUR7l6xNcmqmmGmhiyZoTTjKtJBJGzr5tt956a6OLn2yo4YYaVGU1g7ubi266Wa87QLtdd1VPnGCDHbYccoo9B1n51FlnWXUAfDYddu5bZ1rIqx3QHmv++ECGD7y1ow4F5RhyDoUQGrcRQmAJJhh1e/mwxBIFNYXEey0iRhQ7WGLDDCZwYnEnJZioCfgslmj/2IeefvgheCicMAKJL0qfI5BAEAnECiKmb6OQQzhBphlUkB5FE7LtTASREjexJJPZZLarZbvIjB9mkB1zjJJRWjlMUZshMya5XKITo0AFLGBxik+sKU1R6oTUQKGKZDjDGKoAxWUc9SjA7AIa3OAGNHomNk2UDSm1YYSn+pBC3tQhDU0oAg+M4AMb0EBVRlpOBmDlAOnMyjrZAdx40lM484xjHIMjYngeFx8k0udx1JJcOqK1n8q1o3L9uMc8nPGHM/xABt7qDemG1Ic8/OEPC5nDGPjgiFik6yKPMIuIejE7e4kPGiO6QxvacAYl7IAHZShDFvzoR5hsgZAEc563/1gCPDhoYQpxGEofCOEgIhDBQXwAkh/YUAc/aKIyORvGKCJBCUkwIhGESMQmUrGJRsDlEm3piltApheavcwuczHEIPwwCEM8xhFdoaVdPAGYUZgCFrGARSk00SZFfWIReJrEJDABCmBMAx3x6EY0gKGKaPqFMYyAhCFWsQxvVCMYo+DEJjJxqZVBhhG3KYQfFnIHFnLhJwmzQd1umAEMYIACEpDO3nrot/cEzjxC9BURk6Us9zCOPkz0zzokZx/71MMdEq3cFeFBijKkYQkz8CK4GiQHhZBxIXL4QiZQQRgL9cKN9ZJjidS1rhLtoSVZ4AEfBQkTnep0CTutAx3aUP8HlzBBDFWqg0RWxwcYPAELE0JIIfLgB0N04hbNQMYxjXmJSFgiEYlAy4jcJzMvkcmBnDBalGCGCUoc4pZ4cgwkZhY/UQAKFqgoxQIp4Zc2PRAUi4DEJEAhC2doAx7zsAc4xmHNaBSjUGvSBCUgAYlS/AIayGBFJ1KTGtSMkH6SSBtucukQO6ShC01IngxpqBwPICcDHOCnP/XGQwSoQzy7AlZBwYGOcKAHt+Jwz7HMgdAmNvQ95aiPRPlznyfaIx7T+IMaumCDGQQVXKOTg0gVggc8IOQOWvCDa5rRDAu11CwWQkaJ8KUueykCj1pQQsIC+cedbqFhO0WDGdDQhS7/rAADNbhCHPZACEGoLxAwCEIOCOEHSnQCEngoRCkMcwpWuMZ/Z2tEIiTRCFOETRKvvN/90AqyTsjSaJXw7MvOGiVOGBAVVuvEAGu5pgUaShXAeEY2vFHYeNijHz2mhzzgEY5n5CJqmKCZaE5BijSN7TRjw9T7Wnm2E+ZmN3u4I2lHNZwZqkpVKfhAa/nZz38ygFa1ta2wzgOOcOyWt7f9LXuO2MTHASg887GPnd3hDnVMjh3pmAc8aIGHMxRnBmloQxzcoKA4VHd0CBmdEsqAC2rszELxemMq1JuudcUxFb2QhB3aoIUe7IAGfjRDTgmZ6i1k4Qc9wO8XjLCCBigg/wJJGIMc+CCIQDwBBjHIQQ7cwIhmcGMYhjDEglfhmlms4hbEaIXNHgMZS5yIbJo4U/ysXVazoilKRvZLio+WpmGaok6tdIQkZGO2SODJEH/Awym8wY01iyMez7rHPfpBD3awQx7ySEc80OEMWYBCxoxSVCea7OQn38WzZzuE2hwizzQgGjhGmNsK6LYC5Hz5bq/d4QJ+2CvcqpnNhBNHEctDxCEOl1r+Sdw5JNq4/Txr3//mxiTwwAQe2EAGhg4VkOxQpThg11t0aB4o4gSNYGDkEY+wNO1gJ8d83VHUpI6vTgmJBkLChGD0XYEHHOC3BLjLbwt4gK0WcIGmHoIY3v/wxicM8Ylg/OIUrnCNLk4BC1MMjRHnvgRrwpbtFGPNUajBLGhEAZgGsgkTfyEFKUbjiUs4Ik+R6NQgcKmHPJwBkHTYwR+ggY7DfcMcPbaiPe5hD3nERx72mEc8tJEMC5bvZ4DxS8KdTLYyeZYR7cTN2oLuG+A04QbF37LGvexlfYq5AWYGYhB/VXKDDlE9yzLHnTFXLZhblD81T0c1i4EHPZxhBzP4gM+BFAdFD10OovvpDn5gCGZU4xridToiLC2idZ1kdsgwhZXNAGF2YKfmS+tWDXmywAhUYDpsJQG6Q0M2QgACQAAEIAGqIBAIARXCCxMM4RJGgRWOgRlegRX/hgEZ5uQSKOEx4gKlgqEXRKETQCY1RiHyzOouUMxnMIivIEjx1oQSFqEQBsEleGJhisAHekAA/WgHVAEd0oEe+qEdBGRA5GEeqNAe9q3HMCoaaOHxCu9nEA73xsas3icu2MI2boMQHCLiQuULkMAIjmAIbmDLkEMFUmA5mkMCBgpw0iz6CAfNBoe3/jDl0iE+7qPltG/78ow//C0d4GEg1gAOmOA4UiAN3IAS3UD94EAMxADRvMVbjMAI8OAXqOEavmYT8I+84GhEYiEVLMQU7simioMAsY6+TKsnYi0C0O7sAiACCSABOqIBq8AsJKFN9CQSSqEXXsHukIEXTqHZ/0qhGCevEkQhFpChnCwDFU5hNBroLizP2ChBFAJlGFrwFl4hGV2hFn5hGNTxFloBmRZBD+CgC4rQCIYAKBKGBnqgecpAB8ogGgBuHvBNQPqhHu4N9ZxwH66lH17vGhhLmDZLE7Im4VQDU2bjS0zInfwADXlDdNJgCqbgCN4wDmdABlBlVTyAOSrA+c7stvrwV1QOPYhoHABxHNKBtpQl+w7RPvaNHfiDEeFBGfAADtqACXZABjjgC76AEscgDvDIEt0gqLwFCZAADUqB/rzGFB4BEMiLXjbMqszLFe/gDBBmBg4QkAIpCxom1XzgBiCAATtCQwjgXc4OBOiyLk+G3P9GYRHs5BJOwUJmYRaEgRlq4RRa4RNCSS/vYhRuQV1iQRv/QhNGyRD8QA9EJw8M4WaSpjUswmuscmeCoRVG4RLecZFwZOd2jgZsgAfM8gd0gBTgobB4zPSs6N7uoR4QEiGt6PW8QfbahC/MCmsgBVLEcAwz5SIPQSsIAQ2trA40UQymAArecIZMBZ/uxlh45TtQbg+/YTu3E1gQ6j3cAzyMKx1icj7C46EK8aFaj8f2oR7kAeBA4QfO4AzqoA3MoA1+TgzcYBNHJ1TwCI/c4CrQYBToz+2g4Y0QFCW6phpkyhTkIA6YQLpmQOu44Cb+yA5+zgncAAciwDp88QEIIAD/EqAuQeBdQqIKUFQrsWQtkEITSmEVSBAZauEVfuEYYEGt7gcGRyEWJqUXSkHyLsEPSKsLDK0+v2UQFKGXPMEUlOYYJoUzK6sXWOETRFMP6pMN9KsLaMIMZqIMXOTUfgAPjAEdYvPe9kMR6eEd8KEd2sEd+q3f4gEenkEW1qQSGkER/kIMN2FPVYOzwERT0KKrSmk39KBKxOAKxIAK2jAOa4AGUku1XMtY2GM8svMPwYE7b+vkxuHN2uNwEGc8i2gczDNx7oMmIWcd1rMf/iEfmCsa8OAHhCoNzCANaDUNmlMTf87Q2qA5bcAH0AASoCHexokkEPSNLOQVGHR2AsEJ/4qgB2ggBbggWm8CJr7l51rgORbgQwmgAt+FREGgChChCgChCsgAEBABRNjCfSoBFYKBFWqhBF9hMFZBrfDCgdxEUG7BE/KgB2bA+G5gCOrRB5qgDjjGKPYEaVqHjsSrF1BhFCrBEKwUS23CJrrUS09tHyfBGsIB3+6NHurBHvgjTd/hHUK23/iDuaRh4CbBERjB9vYCNTLBNxUuZTIsULvqUwo1DnRWDL4getbSBuLwUU/S5czMV77jGzI15VQOPsajzp7l5MyzcdbhHNSBiKSWHVBPVdthHNBBFXSADnzHR7AsDZDyC3A1VHxkPmm1BpbADOigF+iPG4jBLJqubv9Ppo5OQU5mBxGoYAiMYwaCwwmEA3maIFSowAlwQAMgIFs7IkRHlESrwC4RISRCAhE0bBM6TBLOhBSO4Rheodl64RQwARLWAjLyQq2QBpn8gAZIslFpoAZgtwZSswu+pSF0ya80gRQO6BZuIRZagdwq4RD0II/ci3h06l8E6UBkIBeqiTbt4Xn5IxHz7E3f9B7e0xqITK1AIzEQThRedk/F8BJoNsPaSRFKSSP3QA/24EETtQ1jqPgyDjn+Y1LJQXC+I2kFh2nFc8/IU1QbamqNpSbXIc/uTVW/oRuo4Q/KoA6yYFZptQuSsmzN9ue+1Az0awV8AJA8Ydjq6ENOsen/SgIZphEaOG1ukYAKeIAkG0YqkaBhCjdUiEBxGRdEK9Bb6TJyvzUrKfdcSaIRGCET5gJpVuEYboEVGhMTeOkx5qLxzKcQfsBRUYWGVkCKUcUGioALDE0h9sAPCmGXoMQyPmPEHKEQ7iANVkQJikAnlEAJAOZ4WO0DOgAPqGHH8I165YHf+s1N7Rhk2QEdrgEYCI5RKMNS9uKcNmHbnow2ataHb3Y3VIh9e1Yq3/f46MxTQ+5T3yMQDadpY5I8JYc9MKccJCfPeiwf6OGAaYEfX6IOiBSLqeCVy/YKKNFH7utLVaAGfGALCiEWLoJuzbVuQ0FdRsK8LCQV3MAJZCgF/5IHCbjHfUMFCTQgW7WVI2yYLoEACOjyXClXJGJHU5IiEtTKaTChFWBh8nqJTGCMEvxACRz1WVMAVeCZW2aABnigCJaASNOAhdqAKHTJKAxhKwZhD+xgCoagC5igRpTgCHtgeNZYCZqnA+BYFQoL39ghHuLB3/psHrwPHvisHvLN5hiLFKxGMahUs5pshDAFTNgiLdrpfCUCDXujEiPYhYijUSuZWJyvuMpBiH6ltsIjJjs5Hd7DP/iXHUg538ThG67hD2SA82Z1CUalC14Zlr9Almm5ll0kBVagV9MgE05EKz34FINZdjANGqwqFeTACOImBYrACH4tB4jgE1+ZBf8aIAHMzgHjsi6v2VuxGQSAoOl2uNPap8MqYREgK7KaqRjz4n3m4k7KYCRRRQaQo53/Fp55wAeuOFrToAiCo1bxiCPpaS1pAI0VurRN+wgdoAPi2B/xzRzitN7+bR6eiAkHsR/yocf8LBwErhRIgTRQQzjJ5slSRlPaAi3M93yTM+IQTVRCe+deTqfzcFdqiyV5SzzJIyZ1mqgjah32Id/AYRuAgVt8h56KoCOhxwk8Mr2/wEe2oILN4ANSgAZ8gAoaAZWqoKWyEv9YEaw7zULqyA2owAeS4wZw4K1z4BOdIAeiuQEDIK/9GkWruS61knLBdRMeRVMgI0+IJtoc4RL/OCEpDiEP2IAHkKPEP+ADThKeI3sFZkAFMA5oc2SKgfYGjGAJyvttatpRm7UHmjVhSjuhEYYHGCC1O0AVvGEe+mFy/u01dazPJIdyVHVA6oEeWnXgIg9otAZRgntPE/lPV5qUEuEMq8zKqou0aPo8JdW4dPqH3sMPzeM66xflPpU+jMUcnoi78y0crGESOiAFXM20hOMIpsAJnAAK0nsKvmALtM69OUAG5NsIBEEStOSN7DaOzHUkqHHpUOEQkKAFlIPAC/zXgIIKcECaQ5QArBlFVT3CszkryRUIcuALFAFM1mIuIsPE7mQPzOCmPmfjvOwDOIADUlzFo9jFV+DY/1/3BqpiVV7cBrJsOBp1BhB6jX1cYdb4CBNmyDHgA8rAGXbs+nzyNS/ajvktygfk9OLBGoCBC/kCOD/DkPcUnVLafYqzZhWh98Q8Da0M1EZlCYh2oOhXza27fsNDPSq1PDhZcsbhPNXBydPBHbq7VfdRBbhAv4RjCaQHJKEAChomWsXCtABG1C7bB4xADh6hEQAhRBL0vD4EjoahdyXBB1jAA2rNCp7gCSYJDiugAbf1cVk9wsEVEcigCoAAB2C3CfqAEdwnDC1BEfagC3ggiuc5NWcoblw3dqPYUWVXdhkVdmn8E1sYi2sVDWSVYGy8RtCe2n382ouDns8ADyTasP/6wR50DPXy44meRR4qKor2Yx6sgRbWRKuABq1mIxPkvcsVOS0Swfc+xSEYQuLIO80B3qfXPJM1VeWUduHBgyYV3lkcPh1yEx68Njmi1eObQCo1HgqEo+KNwAmOoOJdpA0IiRLvgBAs4RHIABVHohlsB73EpxqYgRhGAQmMJAKE4MB8LQdUAAKyw1ao+ed/fsKr4AlwgDhsoFe3oA5uyQ4itJ3nuZ2v//rtKfxPM3ZhN26AFmi9vvhI3oUrngsUfQvMfo3RvgiuvaFLe557gA7w4A+WYccAwl06e/Pm3XO3LmG6hezYyZPnzl3DhP/KocuWCxQmSpo8edIE8lKlTST/M5nMZMmkJUksGzVyxEjRIUKEBvW5uedOnTRcmpT7CTSo0HNEf5IjV87cT3NMmZYTJ26c1HFGy41biFWdOqxY+9mLd+2PjhQfuPRsYtYJkiZozXbpkgbKlClp2tixo6dOnj2FCB2yZEkQoFCECfeCRiwxMmjNhh1rhgxVnxsjKuS4HCQHCQgICCT4/ACE6NGkS5sGUQURoipBYNh4XaOGDR6vbdSgQSM2jde4Zdf+zYM2btixZwcPDnt2keVL2DbJsiXLj+nHqwfvgf26khkzetDBUwaUN3hY4dmrh4/ouYQJ2zl8KI9d+3/0LhbTWMqTKFEfNXXyWNJJJwG2UiOR/0TCSEyHFDIIg3vktBMa5ain1U9aaaVehuUclRRQTSk11VQb/nQVVyZidc888ADzAw0ycGBWT2k5gdZbcLHRhhhxxHGHHnv4MYgfhRRyiCKKWLKJJIEURlgqzcRiSiqpoLJKLYwFY0ojSJiwAQ45CBGECAt8RmYCp515GhAgkBHIE0TgYJsPPhjhQw3V1XYbb8XxEFufr9H2J22yVecDDzcYd5wPRbC1xBJZLPFDD5FiR2l21vWgBA3dlVEHeMWgE8444AxEzz7tnIpqOxI5RE+rEeXzjzvkyNONMqSQckp+onyCyX+ekMQJJyZtMiBgLEmCoEwLLliIH3vYUUcbGf9eWM6F6mio3ohCAUUOVN6Kw2E5J2aFFTspeoNJiylwgNYXZ7UFVxo41nHXHXfs0ccggxwyiCGHMOJIJJeIYgkiTDYZSy+xjDJKL8ggEwwspljiBg4mJGFFDiI8QKYAARAQWmlAjIwmaWoCQUYSSNggZ8vBzVkobjLjOShxgf7ZspyEFopooos20Sik0ymhxHJEE93DcT0YLcMOTttxxg+TUOPNN+NA1E8/72y9NaoRtVpPq/T0Uyo+5fQTjjO5kFKKKaN8wuuvJM2dSYAoEViJJDAZWeRMNuVkx09EqQNUhROeA1S2SG1r1LdQBTXuQlul09BXz+CxBQ0dcJAFF+7/suV5vGnQe0ceefgo5CFF+stIJJJcoskonjSiGiCPPILII7EkRozCqCgsZSZyUOFDHGO0AMFnBAggQAKhVQFIFSePTHLJIAARQwxJGNEEyy3PVicPOiM3c5+AFvcb+Dmv77KiSxTRshFGMBc00cvdX0TR2OWff9M78NCDLijhB6rwRjfEsY56ZM0dqUIV2OoBwVbdox/7wIcF6ZEObqztFG/7REc8AsK5BYhAgMkbghKkoJr0ISdFKRy1roW4w8UwKR9Syoa69S2qEG5y45ocO+KhIlWUoQkz6IADOvcFd3kuDUwcnR1Kh7rUFSlBAbvEJTjhCVN4IhO4A4QXByOl/4NJKRW9EEUfmrAFO9RAAmNangBCBoIvVkE01FOT9UYmBCcoIQvf69NubKMp7uxAU77x022GY4PdDCpnk6pUD+S0KPnNSX6UZEsRsoDJLBytaPhjmg5oUIQZaIEHO8CDMrrxDXP84x72iMipuPYOCMoSPfi4xz0qaMF99GMe3CgG20ahCU7wB4QAkhux7nY3E6IwhTbpQ4YGt55nIq4dLSyKOc4BQ6MshCpUqVa11LGOyHGFl3+gQxHW1QAtxOgLaXCDG5jYhjpA8UcN8pciAOa6SoBEFKVAxSi4+IjoAaEKtwvFI5gkpcRsYoVuuEMGxpSAALyRNNALqMnsiKaRPf9hDG7QwhmaYAQ+6YYGKlgBd046A0LCBpEzQ6RxCvXIpCUqZ0UYgg+GYIQjzE9RTYAfE5hgv/stLahFYMIMdiADls1gCTvQwSSuEY5ytOMe9ICIO2AZy1nmAx/5yBouc3kuZaiCFLIbJjGx6AlO2E0lxoIJTBTEID+8I1uMkyZSikKOFk4oKEfp6+IspBVzbMUepHLHV4CBB9MpATtccAIVHkuFL4hhsjuyF77oaU98VgJ2/zFFwkxxUIOqpjAFjVIsFhOLTPRBDnLAQfIS0Dw4jgZ6gMCo9VBQhTnwgQ/22kkbeNKEQh1yNrfRjQ2cJjPuyGy5/zuUDW5gqOgOoQf/Q1jOEYaA3ewO4QjcLcIRvFvT6ma3k+HFbhEw9dMsoHELM9CBMuBxy3/0ox72OM8ss/aPf+QDVvvQBz6++t9//NAbySAFJoRlkpBQghKc6ESwjnm3lSBrmTIxRLPkyjVpPpOaMVRPXjscFLoKTsP7COc86FGOqqILD3uggxrgB1nISnayOurRZYFEJEUELGD61E8/EzPGVBQ0oIjYRJSCUY1qBEMTh0gEHzbQxuadaaDRG41tTVYFMvBBEITow73y8MSddGEJwp2NbXxDg0Eud83MPbNsbuDc58LZvNodbxS4293lmLeT1S3vnpmAyS0IegYfmIR58vuPWSqwH4j+/8c+HO3o/+7j0ZPO5TrC4Y1lGNiDwYKdJiLxCQcHS0DJRNaBElThIW0tQ6ciCofPsWr1rFqGIqb1iKW5j3qkQx7pIAc94KEMPPzBD2c4AxOKAFknOFayV6CsjVcIpH7d0xEBk0RHRDEKU7QCGZDpXSpMEYpMhCIWwVgMNKDRC09EQhF9GMECDsA8M5WsCvTGaPWul+Ut04QQezDdgyCUhjEXimd/SqTTDn5wTbF5pL5JpG/mrN3yWvd+dLZunumc3RvQL9BbkMEHdJAMgzDagrmU9KQriPKTZw2/J99HfdDxjLGSItSc0MQlMuGRYNWc1JewRN5YEom3VhiWrH4lVv+PnmFYz7XoRefwqfDRj3uMYx3kGIc3SIEHP+SBDpgsQhIfu2waO9tHesCx6u65CB5jURSmKEUsHtOMuD+M2+eGBjJi0QqbO6IPHlgAAhJwANnOW3pWjgEQnjCHQCBi3838970AzoX3wY82yLETKZGLG+WmeWZulrOfIA7x8fY5vOTFX3W/G/GgNQqTKZCBU71hkH+QnOQpB7Auw0aP+lJQH7w3WzrCMY1iqAIUM9eESdKqc5sLqOc/B/reVIcPrjHwVNNvhwW3NvvsY3/27UC691d+jnZ8IxzP+MMf8hDPHzDBB5GNcWTn0mwe+ehe9ZzitHvM9lKUYhW6QAYz4t7/DOeGDL2ACp8gMJcQCYZQAwqAAAewAA8QAtYzZVWABVuWCDRBJHGlL32gB18GLWlgBo8SKeeTJ4mUXCnFUrhxKJ93Ayx4A0MAZy8oehR3eqVXU+ClZ0PQHGi0g1qAAR+nA8AQD/YwX/iAHugBaYi2X/JFX/BxHv/gD7znX+YgDvFAYGMVaiKUcyBhfCbBfMeCLEJ3CNknNuswfbSUfWmYSwCmhiTHNVDXD/jQDkiBDqqAB3fxW2UgHTGmbI4FBXJRY/NXdkBiT//iCPokTGXlCaPQCq/gCrPwCqcQapoACX7gB4xwCH5gBxRwAASAABBIRxJoZVkGCH6hOkPiL3Hl/wcr1IH9Bi1tgAaPAikyVVxstma18Ue28RtxJmcyCIPjdV11tmekp2c4qGfNIWhswQRaQAEdoAM78FTzUF8QtHLVeA/0RV9ZQ1/1ZUsUhA+8dw5dJQ72AA/PIAug8Alq9SsglHxeWEKSsBJBh2qH0HKz5w6t8g5bRXL7xY+w0o/51Y8BKZD7pUCOJn7sIA3lVBdpsAUhuARgpxZIgAROcAR/GH/2Ui97gWP98i/51HMIcggCowmUgAmYEAmLwC83QQh5cAc8wAAKcAAJMAEXYHj4dibP40WJt3iEwCCFYAg/aQiWaIl70IFfdgcfaAaCJosEZ4tN2Xm9uIu+GHriJf+Mo4c/39VdfXYE69UE3KUFWuAAHPABTZULQFRfZ4mW9iAPVcWW+gVBtjRBjIZo2Shf8WCOMzcwZjU3oxZhliASYYhqLTdpjlaN+TVp9QArjaaEAJkP9aCYj9loXWWQ5RAOuVAGZ7AjPbEETPCQakFJElmRU3AFzdYGceBEpXM6HWg6ZacvDHITDTUIilAIi2Bh89cHceAGaBBcFIAACiCTExAC9XZvo3EBEJgaiHATQ6KcPgmUlqgvzpITpoOREZKUjAIoJ9iUw9EbvdiC2xmD35lx2OWLN+hdeGaeqFeeXMldUaAFDUABHLADZWAI1BAPa5l7aAkf+SkPsteYcCn/QVljS/ZwS7sED9RAC5+gH8OkhTsXYVakTAkimIOpjSz3aJBpoRbKj0oomZP2Dd0wCT9gBzvSBrlpBloABUhASZRUkX8oF6MZcDZiI01UF/TSBvGUOTTQBDVqB3DAo6TjTnXRBCoQARAwAUM6ASgwnMQZAihgBWNwY0MplFEapQ/Ckiz5ir+FBrEoU8KxG4E0AzIgA5qHKHDGnS1YpjAYg1VZZ/dznndGjFuJBFvQldzFBGVQBlkKHqpgHtW4cnDpp/dAmFGXlmhZEAURD/AAD9BgC6UwCvthZPuBfMKSEplQCY6wCLTpL/8yae/QX/ogoYvGaBV6oaN6ofsVqu8Q/w/KUAY7UAciSqJmMAXKhqJGAJrnCQVbCTQ7WCNvAU81WhdbQBtNMJr2Mp25+aNfYAMeUAEVMAEzGQIDRXijYXiIhy9S6ix94Jz6oq1CSaUPUpR28FuwuAXvI1xdioJfulyIkj4xWBuHMmcv+K6+KIw2mJWnB6dySqdM8ANLkKV28B3OAESFWqjxQLAFS7Cg0g3aYA3SEA3R4AzKkAzJUAzAIAuyMHygMAkZawiL8AmNagqOKgrtaBKVEAmQMAm98mmHgA1j4w6dug+NmY1y+ZgZSqoaqpiJuUroAArPWAfRMqJpgAaw6pkpimfYhWeNQj/w0qtYmqWPAgVS8LSO5f8G0MIGWYoGcMEFODACFqABG0ACIRAD9DZHIGB4VTAGfLBCDxJtzaSSGMgg2vqcU6oHYFajZzCuhUJ5Jphc6XocNFOmafqL3wmv8jqMNIhnFreVNNIEdwZoPSCnaPAdP4AJEGsMwpALsuAKMqcRGQsJ5ocHn2undqoDQKgDpasDHdABMoC6zlgGi9AJjRqy+6Fzy0eSpMAKsAALo0AJk4ANA+FonuqWRCizkTmQiVm8ECSQ+ZUi0oAHPOurYvAFXbAFJzqrKnqe3MUojbKrvRot74QGTDQFf5gEOYADOJAEVIAGbLAT78RETvACHgC/LHACLhADiPcE9KZbaWuJebD/itq6b//Lk8s5JA0SJM7SgXphBwwpeedFPrwRSLvRt8RRHIIrg4Mbg362Z4XLptfbBDTCBV+pBVvgA2iUvpH7AzrgeijscabLwjpwec/oNDwApk5TBpDwCRrxCbeiw7nSCY7QseyoViVhRZ+wCrxgDMcQMaPQAaqgDejADo5WodQYqseLmP+oaLK0crNED/JFjrmAwh+wBnSwBmnwBVTABVnwh9dLqxI5kWrhHKCTRO3kTnPMROxLBX8oBE+QGUSQBE7wBXOcpWlABUjgAytQUjCAyEQwBmMgB7sFbVFqE5H8vwKsnMyinAXsB3M7t3VgbJzEBJjCA7ihZpqHXMXB/3AS3ItoCrhVeZVF28qJyxZfKWjYgQY/QAdsYKc78AEYwAG93MsfAMwpkAIodVKuZ8ylKwN4AAuNMYAOEwy9MAzD8Al4YAiYADf/8WAl4R+sYAwBCA3MMAyn4IzA4A3p4JgVOl/1cHL6JZBXTJBXDM8QJF/z4A2TMBYcQAeXmQZXQAVAw6LnucYSKatvvETvRMc/yr6C7ARJwNBEwMcqgwSRxUTfO8eDLCdE4AZjwCP3skJ7MQh7ALf6UhMirTolbdLMYmEXZol6MLc6YWxJA1SfjBuhnHkoqCkrkBu6Ycozk6bs+lxqirh5Zp5RcGdvHMKCRmZl8ANlwAY80AY88P8BDkABDkDVUk0BGEABWc3LvtzLq/vLYPoHq9ALvbADndALtxALpdALf8AAf7BgmCAKlwAgwKIJnzAM0JBk11ANzQALqIsHzhAOY8POEER7bohV1/eGYqPY9BAR90gPsjTPy1AGM7AudnoGaHAFUMAWt6rGbOzZtKpskTVZMyZ2bhAtTQRZciI/TSDQ7FSjc3wHPDLHOHEHQALAK6StqNiaP3nSJg2UFratg9hvbXAGWqAETABAPJBSNO2lJ7UCOC0zhfTcu9HTz/UaqxxxpSfUUQAF8nMEgAYdcspU01EG3f0BHPCSCqDeCsAA7e3eDNAAVS3fDsAAUi3VOlAIJfn/B6eAC7CwCp3QVH8ACn9QBpGAVsYULKTADNzgDdXADdfQDLPwAR3wAYZgDfEwNvyIvPnwstHXNU9n2O8gh6qiKo2t2I3tDl4BDzsrA1gdumZABYpLkZ3t2SgqkVBABVPwBVew42I3WTXKtLlJBZan2kiQBO8UT7iJ0I/3bz/yIIOwb/nSIJTMnEB5CLzt2ykdJP3mLHTLBm+B3MGx3MQcpik1A9BtUr1BA9P9ZuJJwVNZZ+a5XdmFZ979HOHdBNchKfKT1QpgAH9uAAMA6INuAAdg6IT+5+zdAAzwAZBgYLMAC6/ACqvwCeY3CZAwHXq5CWnVCaXQDN7gDdFwbsdw/woZMAM/gAe5AA+x5w+tLl8TBMUVGqErR2lJ2GiC6RXzcA2TgAd1wAZFwAbFhgZfF+Oy+pmfDdp/OBei6QVX4AWT1WyT1UQJHeM+0ILl29puAL2hXcaT5QY8EmY9K08/Ap3kPsAhna253ZpAIpR5YTpUG4JEYwY7oATBoSkpwCcpoAIpgBvCzB3D/KUzoNxmPszJjRwFpz6qTSeqDVJz4hyV9MbrJWjjmkmYdNw8gNVTTQHr/d4dD9+LHt9UPdUYUAYLBgmQYAjmV050UAgqfwZ+ABgoQbIk+QvV0ODQwAuk0AkZkALx+QfJMISx/uqwzqd9+qcThPRwKaBLz0pfAf8PufC5dKAoQBu0ZoAGxd6HNl7jbOwEyz4FXgD2YvD1YP/sYlDHQMtEMY4E2C7QjqX2XmLkTqDtYvBEpUOlGrnSaiskb2utUNr3avss9AJmvp4Fy4hUNMADZPGDw6wC+77vLgKmAA/ws8EdlncngfIyC7/wk5SibCw/ExnxXDDxE1/xxm0DKqDVFNAAq7/6DsD6rD/fVT3VYdnLGIDVsh+WWc0BFCADgxAJmXAJC7ZgoHALx/ALrMArmgDMpVsGf/AM9qCPuSSoBCGw1S+wBmuw8HCo6OAND24NzrAMvI4HZlAEPNAFZpCUggZ2xb71Nd71y072XjAXZC/tTfS9Zaz/FnLC9RGdBERAvpcBEEh8OPkixs4dO3kULtyjR88dhXv2+KHoR+JCjHkuRnS4Z2GdPHXK/MjC5McWMzx4yJDx4QOHGSlkprAxQ0VMmTNi6lSp0waPGjaEquQxlIcPpEmRGmHqw0iTp02gRpUqdcvVLU2wZuGa5UePHks4UKDgoMFZB2nTNlDrgCwFtm45jMXw1m5du2Q76KBz6JKmS5Qofer06RMmxJRS1MGzV8ckbvHmpRuHzrI3b9yuTYv2zJmyZMmAAcslS5YqUqBUT2Jt6M8fPLHLlNFRJjaeOlyQrODCRUvXJk6EC0dSHImR4k6MQ5nSvLkX6FO8iKFOnU0a/+zZqSg3btwHDhwvxI+/gYRgmzp17NBJr/4gQowTKUr0mFE+fYt+Bkm0ONEOyDa2QEOP32So4QMZUpjhgxUycCCFFVKg4SUEc6pJpxoyDIooDolSaqmnmAqxKqhItCqrE7foyqsltvBhQQo4wACDuWqU0cYaaeSggw5c8lEGHXTYoYcfykADDz8MOQQSSDohpZRP/tJEk1Gm7EQTTLDsow8edtxhB9YmeQ022oI0UwYeW+JxTTbbdDPNMvIwgwrwbpBqRamggOIIPvvsc88j9HRuUOmqg06M67LD7ovgkOsOBxhaUEEFFiZVoQYfmuAiuzroYC+9gyKaj6JBSh2kkP9CBtFP1VILMUTJQwo5JFZU/bBjvjqyWAKNO9hQQgkaUkBwRpk+sIEGGmrIgIMULM0Qw2Mx7RApD51aKimqTJSKqSW69fbbblf0QUA00JhhLgSBFJKkLNjzQ1ZGIhFME088GcUUVGCJ5ZZbevllGIABPgaZgZFhhhlkbimlE07q5aThKadsYoW5MGBCjw5irLgssvBqi6y2QjYrrrfUOmuGM5pAIonwblhCCSZg7rYJP2sO9E/mCG2uOp4TVfQLLpQjrrjwWDDBBEtXKK+JL7BDrz338tBDP1RPfRVWRRSZdWuus2Zk66wL2eMQQwrxo4402rDDoSx2iOklkDGYgYb/DIIStlme5haqhmR/opaHInyo1ginCE9KW23BVXyJrq5CY1c30uDElFb05beXYAAmZnNikPH8c9CbMfhg0hH2/OBmUmdmGWaaGQaVhj3ZJJNMHgZMJwwc4GEQDhxQgAG3GmAA+LjOGp544Y9Xfnnmh5+BBxpueEFpl2GOeYkjjPBTTz715D5Q6aAT/1Ax2ug5u3LR+GJ9LtavCgcVNtBgBBVayNAHJNZH76CoRT3VVax5zRGOYEQBBzjAAi5iEY5Q4CIKGCtGlO0QqrpDGhrSA5YIiwIapMCMOFAUFawAWi8iilBqcpQipHAJgVPJtaxVOMSZKFy6UlwWsOI4NLgB/w15GEXnQPdDIAYxiKQzWDNalzrWHQwZw4CFKC6RiUtYQopS/ACNziCJDyjAd8Cb0Vt0VBe3lGxkzFNAGc14xjI2qwYhTBYNfsWE6zEFUIHiXnO4x5wrjE+PhrJOG9qQBjSYAQ1pWF/TgAaVG3hAAx5gAQ5yYBwqNE09d9BDQjRCKlTB6hCKMGAkJPHJT1YClJUQ5SflFQlHoNIRkojEqw5REQDJwAw1SAEGOJgBCnzgXMGa2/OQ8gPo2YBIPVBJEZowsxUGrnAiQlxvtiWV9s2QhtO0IVbQsAU3uIENdfBDLIRYsB8W7BjgHGc5hXjE1q0OYUy8hCQqYYlPwpMJbP+QhCVq0AAJmIUBzGKJkHTyzwQVy0cU0pGM8BKjusgolzA0QhG6BUeYeW9PEvVezQQ1KPGJIXznS58ZPGoG9nFBKt9ZgQlG8AIiWEE4m3ra2vagqne5MlZgM2AnQSmJS5BSp5WgRCQWEQl5KbCnkVDEu/Jwhx6wYRBaSJAMaICBl3ggA1W0pS0/QIGW8AAnMpiBUGjQVZUc6yclHKtKwPIDtKI1LEtIq1p/sDiuqIgrWkFDE9yAlTJUYhiZC0Y5jxGMYPwisL8Q7L9+IYx/CWOvAWPsMPz6WHOOcxWfGKoiCJGITIyCEXG4QQYykE8t/gBBQ/qnTr76z2YVS6A+Qhf/B3wkkxpsy6HdKkJJlEAzJFD0e3Sko3MyyrON8qwLH/3oFhbFPqhEqgU4SAIVnPsFN6jtIBPJw7tQBUBYxQuoQA2lTt15CfBWAryXWOAlgJpKT15CEXl4ZRt4cActwKxLM4IqAzJgAw4ooAG2jNHznge9uRGFmG9lKzDLChYEt5XABVYwu7ryrRVlga5NeJyKeJCHVmTuF8dw7DEI+2EQh/iwgs1cYwXmV2M8VhkcfkUnBMOIRijCEoW4gxt4gIMaUMADMTIXD3pQ1g4Rcwc2GDKy/vklJPdgBlx1CQ14oKsfWO9XxxwCn3I7R4tS9Dm/pQ75hDtcj1pzkITUjRHA/4OD5FAhcm6YJH9WpR9YyYqTnqTEeMcbsTpHbEqXQAyWBHMJSPxlk2RLDxtkkIdB0AAmtSyLAlxLXx/xYAk8+A1YukKSM7CBDWfw6G8izBUt3PAqXFkc41YE4blq5Spa0YoZSAKJYPRiGMLgsIdFfOtbC0OxujZGr32dYr8m4xgrxgUoJlFnRuiwgk7wgQo664At1IGrP14cSX4lZSUIWCVIpsEOtDqDr7AVLNZbApUdZRycSTTdvp0OzwwFHewEMszkWlSZBQJJ6GZTPfTpQ6pMdapNMiKVoQSMlKYEMSsRphOFwdKUshSJiL3SDnuYpxLSwIOrJtQtZqHRTGyQhv8swPdWCqGIqCziED1g5A518KN6oPbHQHb0hp9ekaizIupAZqEUvegFLzosYl6AOOi4PqyudV2MXwO716EBTTKU4QtSYGISnZBD1cVQ5SikgAIzWIQOZLADGZyhB0jxlloRfHYfg+UoKmmRDYJiA6SkUO6zzd65u5Oc4QynO1CIArvbLQbxOQc7XQBz+sYMtOIws33Z1Pcd9rClPsCZa7MS+Hf/8heGMaxen/CEYQwzCtB/fhSdGMUnqhSJSixCJD+4w9yyoIQE+e53M3KAU5+8TcfzoAyLoFUmeb/JrJVtEGVLVUX6c5H/uDw9MEfDGThNXDPYfNRlyMI1d2UGHfz/YV+BNcYwQswL8Ac9/EQ3+tGT7utxKkP9yViGMoAhC1Bggg98uAIUrjCEFXwgC44owwd2oIOvqCZRo7ksQLCiOBYaIBIaoBZuKTfaWgIRSY6qyDvuuLvuOIIoyECM8gJC8QLC6w2UGKRByiZC0rvFy6Yas4OEeLxSUZKr2Rr0wik9ix17KQVTKAUcHIVSQIVTIIVTOAUeDELQKwVRWARNOIQ6+ABp6wE7wAAGoIDfMQBb4gAGYIkPOAM7kAE/YARZEQwvFIxK2C5UWoSsyRoyJBviuy5VoY89uAOESL70oAM26Kji2orZyAJBwor/6wTM4b7vCz9ADEQQKz+kO79e/xun0FgGRUyGZ6iGYgCFLZEDRuGBHyiESPgBfzqruBIkNNC0T8EIikCVQ3CEOrsETxAFURiFSECDLEghEXlFKDAOJ5jAvLNACuSTDMzFvtOZKSC8LmifLxDBNGC8Qmoap6kDN3yPx+uDQSAECVIEQ6CIQ2AE8ZKShzGMU9RBHEQFHvxBVFiFVWgFcQRCVkAFHWwFUaizQgA7JQAJGvgdhDKAD7iBhOoBGvCDPGCCPbgEUnSEStCEhQMMSgAMnhqqoTovBiJDrZmVNISpklMIFYxDT9E0w7sKM6A+AdEhNKABGcADVrgF7/O+X/AXnitJntMFXShJ8PMFliy6oysGmP9cumQ4P0VchmfwBnjgBmVAAzsYJDZgBFQoBd4TuHaaknrRQXzhRliwnH7BHM3hnB8iBk7IAi1AA2xBDqZIPCS4Ey44AiTwyiNwAigQSyeYAiowy+aIAi3oxV5USw9My77rgp8JxnIZRsajjrR5GmRECMdjQUIgm0LQmhlQAANggBrQA0ewhL9omM/DQSKkLNaAhNeYBFJ4hcrxRiAshVOoEkeggx+gAw7oAS7AAAUAo95JgQYgixTINB44A0sEqnkJPcIASCspuPEqyIOMhAfiGuErPvpIuTdMPj8CJHnzKAnLCnNZMkq4BV0wBsQKRPDbBemcTumMTl/IBV8YDe3/1E6Y7E6YZDpneIZo8IZ4QId4gIfqOoROaIU+7EPAek/4jE/5lM+ASZ1mCAY7UIIle6sQcYqq8BZo8pMo6JMoyJlB0QItGK4ucL4zUFAGdT7iHKQPJLzsiJw/yo6WAxX/GYQBsicA+FAQHYAb6ANNSEUc3ExPyIRIsIMxCRKWKANDwISlbAXNhAVzTMVL8IND2IMuYgAFUAEHqIsyYotaEpYP+AE8WIQ8AK9SNDjatDOd8sLtWiDeuxpXehV/w8f5eAgVjMjhTAPCi77ZoD4bkpAs+IMNaz9aWNNaqIVZsAVZyAU5lQVamAU7dQVaiNNcAIbQcDr1U4ZnCNRnkAZC/50GbNAGbfCGbkAHeIAHdAiHcOgX+AyY+YTP9qxUgHnP+kSYUVCDb0MRqUCmcCGRFMJAXcTFXexFBP0oBmXVB/0oNPBFX1SUtMHQ9oAP+rCaRaiEPRgAEAVRBFgBMVAEfCk9TEC2WcEDQwgSHjGTI+2EWBi9T+DGUaiXTnCEPGgCDJgUG6AACcgA/TIADmgAmUjAHVDSQqAXUdAETlC4hAvIiLm8nJIXwUBIBdKahey9VZGIZGyDN/zSePOoOywDndiBMsCEmgSGYuhTp7NJ8XwGZXAGaPAFWXAGZ+gMbVhUy2jUdIgHeWAHSLWMjW1UeEgHywiHb/gGp2QsYpjPwv8CLKIDLJEULMYyImIYBGD5qlULVQc0NVJF1VxEVefoAgTVAuJ6PjNwPl+0SDOQVblUFD/KUBXUCDcbvqyxhEzIgF/90ALwAA+4gT2wBJ86SLMphD/QATbxug4wgMKUgSxYhEsYhaCcklFIpSVoA9fiAuChAdkrTQwYkv/TA00gjFEQhU6wF9k0vdLzvCuJV54KL1I6LwVihDLcGjVsiGR0Q4Two+uIHOcb0y0o2DL4g2Zo1G7oBkgNB3RIB3m4h3sYh3DoBm+gBlVQBkSdhm2wh9Z1XXtwXXpgB8oI2UdV3XiIB5NN3W7IVMZ6TxIbLMTStZgFmA/TtYDxHFRggij/OJYZWLWsQCbgqAqgHVBT3cVcLFqjhb6kbVAEZVpazUtQUUE3jIiXMhU5G6BNSIQC2NoAqAD+TQEqIARLsE1HMIRFwIMy4JHhcVEFCIABGAC2rUJFsMHU4wSyuQRGgJ66WDIFoIAaCM0USKoZYAJHuJJLoKwSdUwULgXQW9xPeBhP4ATbvE1WOiDKzVcsLRWJQDnNtYOorQNtYgM6KAOPKooeMFhSwEl0UAd3UIdywId2OId3KIdt2IZwyAZZKIZs2AZswIZxqAd6WId+8GIvXodxGIfjVd3VLc+TRd4QU6yAQSyiIz+jK7ph6L4lWgQmOIIboAEVEClN8WOeBVCa/xlf8dVFXTTfBPXFRCZaBOWC4arLWtVL+JUa+aCaTDqEBfKkTICCAAiAX12Ab72BG5CDRBDbPHMESFjWDnCA4dkLGWAABnYAcDUABzYABUiBQ6gERmCCM6gDIvkAHjADBHEAnFiCHTCDQagEQ4iYShiFU/gEzfzBH0ThFV7hTxAFT2hcKQmv3CygrEFDQzAVitCDHE7G5HMDT/GUcgkwg8WDZYCHcDAHdziHcmgHfKiHdMCGbegGbni/aegGbJCGcViHc9iHf6AHd2AHeUgHcAAHcUgHynBoiKaMM47dbZhjwio/OM7oOBYxjXZjZICFM9CCIaiBFehjaALkQC63Jv8oAgINWgEdUEQuWkYmPJrugjFrOUmGCPxYFQCivIGrhKwdgE72ZAIwgQoQjxUQhEaAp9Sjgw6QgR9Int8JEgfoZAO4AQT4VgcwgKKWwjbQAzX4kqsiCYP9II5EA/ZQz0X4BEjQhFMohVbwwXIEx2nOQW2s5s6D14LDTfMCKm82BK15FXHug99MRqhRZ0N7nh0IYsiIB3ZQh3qoB3e4B3sgVG7wBmeQhfHcBmnYhi92h37oB3qQB3mIB3EQB4lmB+BlXYqG3dg93eRtrO776F173qIbsYym3lkrvxQbBkpQgi64ARuYlF/8Y8QBDpce3+Z46fKd6UROUDNY1ac9Rpb/AxWermSrecFMpgTxsgQJKIABEABPhgAN0IAWWAEoSISmxikZaIAgYQBbZts1IWoA8ABapmUFgAAI8OoGtuUP2IM6GIQeyII6mIEs4AD2OptDgLi21sZTYIVWCEdxbAVWAEfNTGG8ZmF4hdw6G6qEFOzB/rdxRrkubQ91RgMF2YEiMeBciAfdtex5mIduiIZrmN2KtYwtngd56F16sGx7sIcZnwePHQclZu3WVu2Ule1uQLEU87Xe5u05ht7yM7EqP4ZYoAMzaIIhuAEV8AAwdeTjJhEuuKHwHRRDjgKbLlom0AL1Ndrzre60gRplnAhWkZVZaSBS9O6/sARwVYAD/yAAAThvIXgBGBiDRpAEQmAEJTWENVjbWl4Trw6AMgKABXCAATiAAiiABqiABSZqW/6gNhiELtAD6Om2Q9AEB4eEUiAFWGCFV1iFW7CFWHiFGV0FVgBCHszwFJZNUfiEPbMzSphhBhJxNBRnPzBxOEDG5EtxXaIBJpiNH5gEbxhyIo+HbJCGzF5YeIiHbZiG4p1xegjyymBUybAHiF4Hd/Bi1qaHhl7ybthnXqjOXZj3erd36kRJfdd3XND3e9cFgfE+xQoGTSgDJuiNNKiyD+yN43YmYFSRQu47DZyCXBzamm5QoiXamHHzRInaDEVGcl4Vq8HkBRog1AOvwRUFTv8YgjI6AAFAgAsQgSA4miNIBEVwBCiihEKQAVoOgMKMb08egBoYgNIsI5ZZgAWAgEA4gAEQ7wFAgMJMgSGw+T74GirpBGnmF36pBV6wBVJwBctsBWkee8d8klYnBQ7X5sA4SAYiG+ALZ1NBuUpSwWX/j4k8A8MT2B/4P1m4hkKdBmuwhotNhlzghkYF/BvPhmwAaNkOh3QIctddB8mXfHUoY3BI2W9g8ln7PqALv3qnTlwIfdEPfccyOl4IBljQgx6QS2MaAjFY+N7ggiUAZBDcggwk5JqZePNd0DePLyVw8zOwVToPeUuWs+6WF8yrwVJwhBTwUQVYgA0QARSwABX/gAI4EKVM8IRlZQD7NoC96ICg3wAEYAAPSAsVgIAGiAAFwIEGaHoBIIAGfnotyoAUSAROwOYd5JdXKIVZaNNf0AWA4LVqFqxWrVihOojw1KlSpUg5LDVq1KeKnTpp0nTpEqWOkSI5WqTokKGRhgah9KNHpZ6WduzUgUmHDZszaG6iMWOmTBklO/4Yo0Yt2jNn0ZwpA3YNHrxp065RgyptqDZu3bqFS2fvXj93Xr22GycO3LeyV68aG6bW2LG0v34JE/Z2rq+6vHbhzZvLF7C+xowV87XLlq5PSnpw4bIkixImUaJo0cKlC5cmlZs02aK5SZQjnh97LuL58+PHTLR0/+ly5kxkLafPtGmTZnadmHfu5FmJspChQ4oUMXIUqdIljZo4eRpVyhSqUqhEDcqgAAIMGCNWGPGixhAkTZTgdDBgYECADuYHAAAAQcMABQ4w4HiRwYECDSYECCAwAL+AAf7FK8CADY5cgsott8Ti0CqsvKLLLrW48sorBrFySkILOUTKKBBpWJGHn2R0SSWUREKiIycuQtJvhpyEkh6DsORSTDOxgRMaaeTUmhI7fgJNNdAswwyQxSjDzTXcWCOUj9A40wwzR0VzjTfxzLNVOlems0475XxDlllnKdPWX2OOWUxcwhTTFzDFsMmmmm8Co0wyyqT5Sy96MHFZFlsw0f/DEZBJlhpllXGhmWaldTbaFFMgimhkqa2WGmpstFFbbDHZgdsee/iBUm+H+BbcR8RlpIknoiiHSnMGxYJKHyrcMEQSYnhaCCWdwKGDA+INYEAZOjAQAAABBKCABAcYgMACKixA3woH9OdfAf4NgGyv4hnAgAycwNJtJwzBcgsstcwSoYQFqXoQQxFB9BBFH36CkUYkjvhRSCr+RlJKfsSohx1w3FFHbLPNdpMZrUVWwxu9QIMML8c0kwyRcyqzzDLHDPNWML+QO4svykSjTTfopAPOOGKVo0455JT15VUUKxNzzMnQXLPMFS/jjDPPPBNNNNI4hU0223hTtDfXVCP/TE9TYJbFEqf9+VhkiVFdqKGNjuaF1ouWtuiiggqqBWyY2raHpjDuBipwvjkiCamldpKcQ6Y4B0ssvfRiyh19WJKIIo6QRMkkO3TQgALi6fBHGQoEgF56AAggQQULCKBAASsw3qt/DSBQ7K4DIDDefwxQMIQkniSUECyv2FLL6hOywgqFqKwb0UMavvuuvByJ2FFIIjHCSL6FoM1vSy7pkQdMA6eh08GuMcGEDR+kMUosr/hyTDHJ5CKLxbOoQkpFE0m04Sq7LEONN0yZLJY44pzs5TdnbeOzU9NQY80111TFjdHoABAdTGFKPAo4jwPaI4EHnAc80OENTMhACU5A/4ITtvA0LUTtCI3BjGUSY6gtYO0xXuOaCLcmqEh1gQ2YeskdNrUpPxCvELxRm/CCI4lRcaQjxCmOJkTBnITEAkGxCAYqKqEJSThCE6AwRAcYwIBs4WES4SGWsB4XAAEsIAIDgIAHGqcA/zCgAeJxgBgRoIAv+odY/8EAHESRkF4cqHWrO4hBZle7DDmEIhOxSIh2KCKQLMIRwTMJ8VCSkuPJSGCyaZ5OXLMjJXwgBTOIRClgIQxjAMNixWjLK2R3CvKpahSYIIUrgOEMbgAwHONIh1jAAb+xfGkb24BHPGhZwFvWcoAExOUtq7SVfuwjmPcY5jjQ4Qwd7EALRqCgZv+UMITPHEE0HOzgB0UImq5hbVFe8NpqzqCaNrwEU7fBTR5eyC9+DUKGMJThbgpxTn7NMBOZ+MQpWqGLYxwDGcTohSg4kYlIaAITf+BAA5yYuEng4XDkoWIV01MA9nixVwzwT4D8EzoDqJGKaWxPGDzRilgE0RYijUW3JmRH20VkFKJIjkUwspGXVgKQghQeSdhpyH7BoQ5wgEMbatLNgzHBmUUwTwd+AIlYGMMXc1qGxGjRSViwonyogAUqlKMKWSRjGuFAh1hOJo6ymOyr85PlNnJJQF0OMIBoLaA8uNKPtwZzH/dIYDzQQYoO6OAIyzSCD5og1NEcAQpQ6MIRmuD/hKp1AVGkiQKjtACZIzimC1OQrGrSQJkUKtJSl4pJZjVbhxvFJrR10MkZVPiiQ1zCE54oRSyGgQxkDCMYsWiFJy6BRIR+AANOLEMUJ/EHJUxxWMIaLkMxOoAnBsAAaPzPQhlKHuEawAEyKARruwVSkpqUQg0pxR0l8ok9xksjxekdIBcxSJKwiEXEw+lO4WCHntJkNVpQQhGGUAQOfMA8kxiGMXKRC50pQzCvqMUxbvGQ5TSnQqvIBci2oUpXsrJlYimLLLORjQUekJe9PKAuDXiPeryVHWSR5Txq6Y1o/AGZnlkmEjADBb0GNrBQcIIUqDBjJziBCowqDRjAEBk1/wDZDGoQshm6sIVCdQEne/qgTiS7Y8dqwQvdnHIX0kCFL1ChymmIjR30sIdCAEcSl/gEKnrxWmQE4xatMAUnJMEIQ+ABD+ZxgA4mYec7T0IHYiSWAKj4OOG2h1iGu5YBDoAsBBQg0YZWwAEKYOhEI4ACgxDF3W7Ri2CkWVzdWh0s7jiRd/ExoOOlxA0XYWpTq3c3fzgeHtq70zf0+A1vCIMWhmBrWxdhBjv4QRkWgYxmLEMVyijKJoehi7fMohYHsnQwerGLXzQjZOHYKgDnUbJxgMNk2xiaLG3pwKL5r2j7s8Y0pMGznRFlG1z5Rz/sgQ2aZZKpxiBFGXpggxWzuP8JSBAsv/vtbylcAVE9BjKQV+M8naBhCzZKuMJz4rwRjlBrEtfaFaZAhYtffApXEIMY2tDCQSSCEZLQxCha0QtioFzNqDCFKC6hiEL84Q8yMM8fQGFzm/v2V4UbD0OH9bg0GmDPoQsdow1QgD4nAAIQKAABCIDoRIunAUMQBd7wdotXhGvTrfA0qMMbUExspF4zRXWq/0C8mCev1Xq4AxxkPeseg+EIt7bvDngQPT2QohnOkAUwngEkZjADYrANxjDg2IvYEl5I1MDKVtNBJXmQ5avd4PY2hs0NiSWjL3zxRS5o4V9ayCL0ns/FM+zRj3/UQx7YaFPgjfELQ/yABzz/0KsRWOwZf+Oe3wBHFMF7P+SDL/wmmjGY8xgL8R03SrAYp4ITBKtxMcRhb4T4W2pNES68dYtupsiEIuD8hx/oQAeYUAX5SWHzFOtg5oU7nHP9nNwvYgtbvUIAAQqg9AQk2j0IOECv6KOADxSCJpzC1U3IKqyCQayC7YBXqIXdRpBIJADPIqSXIZwdSqyaHrTaGrQE27kd3IGG3CkBDfCAEpwBHvzBMVwDlCxDxSAD4GFM1VnapTXbMUADNFgF44UDlYSDg2FFN5DVXlTDMuACLtgCXvwCL4iULuiCLbiCLODCsQnDM8wDMLWbNSQDWzDDa7VCGezADNBAE9QeEiDB/2jkHhRIwRmiIcB5ARg8hu8R3MGZQfChQWYonBkYyvGRUPJBwfLp2BRAwRRwnMe9iB8YAoGQnEOoikTU1suZIK/hwVUJFCiEzx/gQfgRFQWIEbU0DrWcEbGMR/zxSuUswALw3wE4wK6MkQeQ0RkpAAf8wSgxxCowxHblEby4VO+QFwQewiJAggSm1yDEHDC2RKupQZfpQduFQRi8QRR4oGdIjw3wgBasQRmQQjVUAzUwFeAxQzPgEzEgg6VdF0hZ2i0EhTVkA+PBQ4n54FXsoCwJAy8MQzWoxaVVXT0SIEhtjDLEAzCpwzhoQzHgQtahgiP0QA/QQA1ME2Dh3hl+wf8XpKEagoHvaUHvIQwcOs9ibAEcNkrX5GEUCBaO5ZiOXcEfXsEVaI3H2cEeDIJvRMJGHIco9JMmVIIh5MEf7Boe0AIwSFEH4AEm5JwlXuJ7IMAATItEMYAVac7hfKIDjGKjNQt9KFcGQIAENECvKAAGzFxP3g4tlk9L7Q4u1kskdF8hkt16pROMtAQcrEF7wRrcuWWiHEEN2EAN9AATlAEdMMwx0IKZ4BM3HgMxQINskdR1tQIsrEItCIMzTMNVfAPJxAM4kFU4+OA2tMItlBk0tEIeeUKISEIjKEIe5AFKMMIkyAI60MM+0IM8RINvRdAOpEAP+AANrMAKJKRC6t7/GQrWQ5pkRFIkwSFMFmjBwRnKnsBhGiyW8Y1Qafwh8+XYF5Sk83mNF7BBEWSBGVQKaBKiITACSEiCJBjCi/iEDqiCTnYABzgAXsVZnKWf+n2AGqQAAwyd6BBLemxioRFlszSLAiCABJziE0mOAiwA1BkABXTAeXbAH3yC+HzXp4VaiPQOJZAX4MhQWdrUvqSlrIUBGCQj3G1oZ9jXbNqADSiBGRjVMKhCLkTDmAzDMTQbbFkaEMGCKRjELOxC32nDNoxMOswDOpAVVsgSD9jADHyAJsCCDHzAB3AABmRABTBpBTTAe2RADfwAKYTDPexDP4yDuVEDKOhACtCAEtiA/wysgAeIoWfsiGO8mIw9p4xBQUmW5BS44US6oaBY1qCATRc05BekQaPgoXJa3MW9qdf8odekgez9wBIoHE2g00oGxyIAoxKoQRmAgixMAgakQApgQJJ2QBnogRooQfrhla40gOGc0UaRR6MdHbEUwCgaTgE0AFVyjrFAAKKpkXswgAOUgXmUwSTAC4iEiIOOCIlQgth1XyFQ6G7ACE61pTJm6FvK3RCA6AzIHg/sAD0FxTIUA1vgk1pgzDDI4g9V5isMAy6AjDZkhTzYAzy0I476oANQAAXcKieIAge8qwQoXQREwARAQAV4wA3swR+oQjeYXrttAzdQgzOUwmHMwP/CjmmZRlMRnIa/jWS/ualgRUGc/ljveRPB2OlspAbVfMHxiRAe/qlzVlyb+mG/dQE08kAP/EBGqhCnrCRLmto0SiqlcoAKHMENzIAMYGoNaMenJo6oFpQDKIEMTNR/PF1DBQABLAACIMAGMOUCRBcGOEABaBQDBIgO4MGTFhUkxMtFOChMdYRHDMcDpoghlGWynoTxYOAGwkEYJMoQuCUbfugK2IAIyt4M5MEvQAM1VAObGMMycGNcZEwvtIKqDCA01MIqwAIuLEM1cENW3IM8xMM3YIMsSWYFtEAGSOsMpAIqxGYN1MAInIAItIAK1MALfAEhREJp2gM7zFU4wEP/NgDuJ6zlGTSBDdwAYC1BE2QBE8jY7T2nm07si8mpGrSGG6qBaqRGnQoK1WjZniZnCWmTxG2cGFTcohgvx5VkGnwBTtRBOe1BTHzZ3xiR4NCBDNSZKvwBA0jACqjACvCA1WqABmQAXpVBijmRE33AIsScnsnnfP6ZsBwABCwABBwAAlTAVNJfrzQABnSADOSqge5AHmDCRcjL2IpIJXTnR4AEipyaL8qQOsVIq7Hl20XB3M3dEVTG7y7BEviAEpRBL1SDlFSDkOhwFgJeM/RCEGHaN2ZmLPwCNaBDlcyVPcTD5LGrCryAGN6BDfRALKQCF0CBD6wADOAADMzmDYiB/yIsQmnGwzDdgzjUFTx4QyfgwUwUQawMb2FFBpsKVvEa7x9O5BqsAfP63hlYlsdqGZ2mgRukgcRxDR5ir/dqXEl6r/eWZPiClqZcJ6OKGSZggiH8yiSQwh+8aw1kwAoUQQ04MQyogARzrQ4U6CmqgW/FXCVOEZ/hB0M1bQIgABZVAFP22XgYaPidonkkDkCN7YiE3Q2dyDCPcIr4IgUmq9uiMMC03dvJXY956K0VCmbIsOz9hI9YY5OcGTQ0w68RQzCgnJkFZizQDSwYw+RWiTzIAzrsIDYIjRFAQRxQQQ1Qpx1QMQZdwRBIgRHYgCffASNAgix4AxLbwzawEjw4A/8l0sEaKEGs9JsLH1kiB5zxUrRJqsEZ4LEeA1kyioEXuCn3di/HfQEhQ9zWTFz2uinHqbRIf4EYcAGOBPI4pcH4EuIiiBkkdEIpgMIfYPIipIAHiMEN+AASGIEQzAERyK8HZGoKcIB5yMAk+CQlmiAmlMGe+Ud+EMAVVVHTjuIo1uou/0ETEVUZGEJLkm1HfPDvFPMIo1eqqYQytxfbIWPc0S0bPqt9xTBm+MBeKwH4nYIvqMIyQIMuFOav6dPJ3U0q9IJip4IpWMLIsYIxQMNAk0w6sDM2TIM16LMcHIEY3EYbaAExwIIY6EEfyIEe8AAcmFpH5EI6bgU7YAMAeYP/KvAWHpwBEwzBDbTpSLpwZUh0RVO0GKgBHuexHq8BR6v09kq0SjdkR2/N9XqBc0e3RzPySotBS+fpdc+GG7hBHHBWHahkIRoRJnyCuP4CLlDqDtRAG9zAFMgBFSTBF+CACZhAC5yAfWAAgUoqKER1b9mZnD2R0TFdfhSAFTkt1hJLgNBZWJ/neeJBIQ6rB9tL2wjzWp8aqEwgBbrTObHaTq3dq2UoM36gMzrNXvsAD/jAD+zADtCBDpTBMDTDJ6SBD3hCMKiWY29CKDxCjmfCju9BHzDC6hxDNHhDjlr2NmB2IiTCJkiCJfiQPGWCPm3CqTSH6sTCLjhDPNgDPdxD/zoIjTckNG8xNBPUV6AO6m4DN0WHgRgQd3G7YTIqo3MzckqLdMZNwcSZdJ5Ht/Yab8lid0NywU0EchxkSh3cQU07ghF9yy1wK8acAicsQmTcgRRYQRwYwQq8AAzEgAigAL82dU+aHyhMgiqIOk9PAiSoAX2ETv3VX59hdZ8lV//+CgMQlQyEZqJL+ITfUAirtamZRIZr+DvFyL/ALYZuKBt6qBJsQRPIcN7KpQzIwA6UwSfcAjK0ggrgQB80QipYgiAgQiMgQiA0wiMIAh/0eCIMQkvGY5SMTABtwzTgzd00G8p98y3UIDh7Y+G5VjNIwxj3gzx4ec/QG5CtQVA1Rv9yb5ybwrnxwnkYlOSat3mb9x6cv4HEVXf2snTIQvc2MRbHe03C9znG5emVZcZNdHempOQgqG2ia0JOt9ZrbaOPDMMklEFMHEEe8IAK5EAOxAAKxMAGqIDPfvooyQItkPqdnZ8MiFGhJZoArGoCXFF6tIcCHKgM7PIH4EEeGEIH7zoIT7i9jPBYAnuyroTb+gscFLuxN2uiMEEWOI0R5HaI4tcH7IAiRAJMzgEW8EEiWMImlDsWAMIcZAIiWAEZCIIc9AEhKP4ouBY0XMO0oUM8hAM20Ps3B3Hl/wgxsCimeSMzWMMU7oM6oIM2LMMw/IEaqCUcqEFQLcHArDRyN3z/7D+8GLxBxK/BGwCZhiajrFl8R9P5dV/cSG8TSXf8joF0xX20yGMZySMqGnC3oXeZyqstJRwiLARDCzpDDdYgM9gCKEACHeRBFtjAFgNBELxAC8xmDdCAkM6AIZTCLBh9qJc6HgDXrjjaARCAofUZUmJ9gd4q1wLEn0WaHDladLCgo0gJCzJidHCRokOGKFY05Aejn0Eb9XTUY8cjHDhvSIZ5EyYMmChRtGTJsuQIFCM+fHygwCGFEUFy+JAhM6bPljuJrIxBlIhPIzmNGsVBIyeTqU2mkC2Lti1cuHTpuhFDRiwYMbBhxSJDVq0as169hoU9Nm1ev3390F1TdoqJ/5qUYJRo6WKmTRs2YgiLCXMF5WHEXgqL8cJYzJo1as5IXvNGcmKTb8QMZuNlSmgvV0aHnnKFMGjTU6I8Zh36SmzYYq5MEfMF9xcqu7ksWcIlTZrAde7oGVRoUaRKnka1ihWMGTRo1KhHiwaNGahCPWT4yPFkjhUXOFbM+OIGh48jPPCAUiVLVfxJk/CU0dGjBwMDAwYg4B8AwAEANMCBDhhowIEf/jAkkksKQmihhCCKSJEKJbLoIIoG0WijDj368I6RSBpRDJWOYMKMLI4YwogWm7gpAwo8GAMpLJ5Igg83vpCDDDk26SUTORJJpBEk3CCkkVQasSSWY5ahxptuxP+RJ51WULHSFFRQMYVLVGC5ZZVjoPFllVNYYUUWZ+CZ55577NGmmD9oKEmzM8IoEYw89dwzTy3AWCMMy9RQIzNANTtUDS0oW3TQLhY94zHCYpsUikljkwKKTC3dlLbcCouCiSOisK2NkeDQww9DFHGEEkw6KaWVW4ZZpplmnHEGGuuogUaYTwwpY4YRKjhhAhY0qKCGGWrgwAcZUvjgh0lIgW+SP/D44QPJDFRAAQMC4G8AA/YLl4FyO5BhDYGUu4SSdiuRhKFFHGFkXkYsrHCiigrpkF+OOgLp3zvsECywNtI4gwsmltCiCd+WKOKHH3jowYeZjLAklECsmEMQRAT/CSQQQRKxZBNBmGoESZMzaWSTWGAZBhpuvGHzH0400YSTSy6xmRNOPvmZlGmbEaaUU1ZRRc157LlHnm5k+cEGOhMDY2o++RyUUMkqW+MMq/UsKc9B12CDbMsmw3rPTTeVgm0pcJs0MUmvcLuxKfJM7A1TQRpE1YIw+aQUVmoZ5phjlGEGV+uuY6YZWOpIQYUMTDDh2BtSaDYOG2ZIQYYOdpAWk2rrw0OHDhoot1v+DOBWAQY6eP11BZHT+ZJK2qVEEngVYoghh+ytUMN++f2wozzsOD6wOwILrovemm94iYh/yOIHmmhCEpFHGiEjqUYC4SMRkx/J5BHtGwkf5ZZF/4HlrJn7+ScTnTXJJBNR7C/6lFhqeQWXXHBl5hjFiAY67tGPe8TjGpP4QNROohmqOdBqWMvaZLbWtbtVzSR7AQOhyMYGzEhGgmlT29roBrfGTKoxjqHaiPKWtzrkAVV8M8QiKKGJUZwCFrjQxS+Mcbhb/ZAZzBjGKOgwAyPWQAVfwIEVVCAH9dxABZbrgA4MMQmKQIJ0pkMQAxzArXKZ61w6kIEO6LAgSFxCE5WwXbtyp5AI8S4hvwOeRYQ3COIZD3ltENjy0tC8Ljwvej/wDcUqdgMnxGEMgZjDHBARilAkZRMrQ0QqUhEKU4QiEY9IhSVGZolS9KIZ14CHPfrRi/9Y3GItZAnGMIhxDGYYo3DJUEYzoFENamBjHHKhxzyUUYYPyEBqh4LgnswmqDNU5gxqWGEwNbhByhxTgmIzFEo4pTa2vS1uKdSmF8DAwha+oQ7HgyFGCnEI5QDuFKVYxSx4QTjGOWMZ8VwGAEuxiCzMwAdyQIIcxiCHIYhBDklIxBF+OZ8yYuIPnXPAQgu00AacrkA6kCgZ8fCHSnTiZre73RvhWC85WsgiFemXR/yghzzsUY8D42MfARm9JUysN0gwgiEf4ZM58AERmQjEI3philRs4hGOXFkoxpcIJHnCFLAQhjO4oTRkHMMsyAgiM6S6DGg0g3HQWIYylmEMZ1D/oxvj2Mc+7AEPUIjxAyPCmzeFycLLvJUyxRwRCDEzqAcOKpnRJBQLU6IY1NBmhF/Q5mBT6E042MGFx7MDDPd2CBpq4hOuIsUqYKELwjlpnszgKuN+UQpK9MEJchBtHMTABxqtQAZqIMUnxPiDMsigc7DrgEMRFEYdlOEHeMADJEphClF4QqOUiMRwO+rRj94rpIYY6UYwYlKBnfQOdRBMcI75x5YwQWG/KUIRlmADJ/ABZGOwwhOsQAZENEIQghjDGHAwBu5l7xE4TYQcDHGJVShDlPEwC+MYVytn0PKqV8VqEG/1jG2IY6zzkAYeYPsBEXmTr2sViVtJYratmW1Q/3XVy0n+VEyzqfWCKJEbCgmbQhITpg0nGdFhE2uHcObhDG3Igx/KmRxITOJvN3zF4AqX2Vvt6qqn8IMdBiGHPQBUDIngQWo/QQkZfIADHKAAbGFbutlC1Lb12QEeNKElVIyidu0aLkd5Ry/j3ksRyV3uhvywBz0816QDY0NwBHOGv5ihJS95WBGasAI/L9IKQTjBCM7bAhPgIAlEeAJ4MoEIo/BBDo6ugyNKYYxocAMdtaIlLW0pHWjcKsChdsYzuCGPucRDFhKFct4mvOKRyFUkrX7wXM/mYamVpMJy5evdCHMnE5dYmyc2zGYOi1gXiiScWogxSGhsCOMYwhGV+P/EDWPxC6gS2BnXoUY1oDGMUyyCbFPQQx/y8KxCfKIQMpjBBzCAgRTQYIxK2IGVXzfRitJBQZ/wsik0wa4xk7mj9nIImtMc0jp2xM0nLZ7ApMsGweDZDBG/7g+2wGcaQK4Rj7ACDiYnBCvg1LRLDAIWEDEHnhABC4LggxgOgYlXMANK0gFwLbldjZlvuhm7yrY24vKmScwbymyI9YMnPBnJuHrorB4RG842wbeqFdcf/HCFN8OZEv8V2CdsTAPzVhw9kKSDQreDEpjQhRgXxw9wyMOCHtsJWJwyGK6kJTWsMx3pHAMWo2BwHc7wgR0sYhR6gJwHPJCBFRThlzsgu5X/daDbitKnEJAYxZW05Ik0LoS4bmxImRUxcAqBVM3D08MeEh7nO+TBeIE5QxaYkAUtQFwL0+PBw2yAAypYIQeIyAEMYJAEKwAVBkQQAhaKojGVP8HRSVBEJVqBjJgFA/rEWMstYNGLL8WiFdnXxSqmpQxZyGIa8bDHPJ7h7DswYQdJJwkcLqP0Dxo26WWbOqst401dz7qBvs5m1vlPGBaKBCTsAA7CycXCyesEpjg2hG9WJRIoAY1EwRScw9qqAnFyhTqq4Tpw4Q/+AFs+wBA0gQYwQAIgSgWoYAU4AAN+yd5GR7cWRBNKobdKYRQ8oRMuAeAeBCIk5CCQK7mUa6Q8/wL1nOsOhvB46qAOyOaYIs4MjumYtMBhmsAJamAFkABkwAsLcOAJcsACXOAFnkAIeoL4QAYQmMIUYgEVYsH5PkEUMIoTPKFnPKEShmsRCuEPbmxalkEatAEewmEe4kEV/kAP4EDe1C/XlG7+3E8k5E+a2g8z1Aol3M/DDsXqgA3r+q8w/g8Ah66DDFBg7OD0SEqGZqhBOOGGvuQXhMFJEicaqOEZnkGrZqEQxKhVbIAGaqACGkAGkMAJfGAKUkAJ5K3xrKWi/qAM9GAROiFLtqQULC8OO2pCnhEieNAHfdBDjIO5XOz0hhD1OlG6BIPpuGYJ2eAMlHALssAHnEAFGv/B0YgPC8hgDp5gAzYgC8Fjp0AmEBqJGDZhE0QBFbxCISohEywhICVh3PjGWhYBFIBhGrohHOABHcIBHeaBG6pFD6YAP+pg6OAACcemg7gma1yt/YrO6VhIDUZET6oOhBZxmkSMsCzFEnsNbzJSE8eGOE4qCI0HhmKIIg4CEmoIcK7kS4ZBqlTxGW6Fql4BdHRAD8QAAzLAkKjAn2hADwyhPqxoAwUCD/TgEvgxnWTwE9LIIHKwIcQSGtEseAxOeNrMzYaQLQuwYAQDHMURz7Yg4l7CCGgAB3jiCWxEkzYBC3Kvpu4x4zLOkRzJEiyhDINhSQ7TEhpBEThBERbhDyb/QRWAIRq6oRvA4RvAARzSARzQAR6AYQMFUQl+ACNncmvkrzIwkf3sjyMhjBGJKSWxRlBESG5uszBiwxJj4xFlUiN/84VycvRKCo/G6TgMge16ErJGgRRO4RVuARVp5Yf+C6to5Rc28A5SYAXCwAaKYA944A4GYUFAgRRCZz6crRCYAxVgcBRGAaMqISwr5CDsBSHiZQcd6/N6kF8O4Tj3xQ/yYC0VS7GM8Ajl8uFcYgsS9J64oAb4oGN8QpMeARAUySdw6hEQ4bweAaiAanzKcBPUMRM2gV0wARRyYRm0QfzuwR3KgRzIYR3KYRzGAR6ogT70QA2ohwcSUeiY7sKK/ynsyCZvgFTqOFJIIWxqUIJPMqiZokBtUIJJ9U83s04z/o/VXk3oCNATgxAItRRV/OAqZ0g5LwpwBIeHjqFWCCyIosEZjmEVDAEO8kQGdqAHeGAq/4AUjgE+SAEUQMHZFgEG0+kU2vM954VCoLE+w9JQC46O7Kgj1uBU/nMA66C5UI9ST+p4RKLOkJAczQANuMAHEqHRAgEQ5iCRHgFkEGETfCIQQmETLCmoUoF8NFRJHJMRSJQWosEb4kFp7uEfxuoczqEc3KEe2CEe4IEW8EAkSlNOf5RHv9Fswu7DgDRaOwjCIozDknRPViIKqGmEEgMxXtL/4M9KI/V4sjEI3f+MeFAF9TZwJw3CESTrFFqhFn7BnWzlx+gOGpABFf4A/XRgB8qAJ1VBGeIjPkihEPQAE07hFFAhnUbhK2unICzkIQwVB5/RINLsB4cuhjIiI4oH9YJTYDTSCM2ADYyQDtgADVIkC7ogDfjAVMeAkcYAp3ZqEzDUe3ZKQzeBkrQHVE1hEQwBE2ThGXJ1V9ukTexhadxEHuwhHeJhIktSDYCxB8gmEbXGwzzsmIhUSCWjIw/xULxGT7RVC5h0hEaoUwjL1y6x6tZvJKjWCNkSbkmvXCt1D+jAbrOSXdkOxzoBcOR1AgGsGrhh26QDGVgBoZSAyyiBFIQhFwhWFRDKEET/YWEVdrUwCmLlyMwqVl40d3MzRLkU1SLSrBAMwT+3lFJB1sXaIJxizG5PNmXLwA58gAuk4AbmQB0x9B4x1FRX9afOK3ss4bwygahCwX+4AR50tYD+oR7cwYDGT2nGT1eLtZeY4A2KALd2YAfGpuiulnsvg+k8iNYsI6/ExiTBlk9W4ghOhAlCAwpEgzVGxTVMAzdO6DSitDDWKjJSTDBO84U8sRPh9hMpVQ8crmTX7g8KgQ4qShT/BlZawRaEMjrQgjqArFaGIXSChhRy4fsK9iAu4YYYthRW6xNqBz7lqLh2Rwc5dwcNLl+msRCIs1IrNUQM8HhOlg1smC7bwA2Q/2AMkiAQMq7RbgpkgqpVK0l7BIEQsqdVg2oemnhX36dXx+of+oFKkHYeQBMeuAEU6MBRCdRuW+2b/sSwSgJQqpVO5mpKwcZ8szUK7uaYggOO45h5/qgLBOs2zkMM2kAM0kAMCLQbOygw5qzhhIMAVdd/Ry/hcpJjObYQGrkiDqJBllOdaqGdnCQ6pENxZE4Y4GNPgyY+EKoQKsFLsK8UfuZmakcSiIsRckcS1MiVdUaNLsES1MgRWhle2uhnJUIRPASGAFG3YIwOykBOf7E0/fUHsFcJ8KMHdmAGqEwGeoAGZqIGbHEFQmEtQgERHJQPqOKRxkd7ymd8Mg6o+qEf6v8BaeuBHt7hH6IYndNBHpq4WNX0GPDAbgumg/Dv1oxUEtlqbRuom+hkja0GJbzgDNDgLw7aDNIADdLADA66C5wAop3gC4Qjjt/SoglUdbvxbcsVbjviE7t0kTNCAUfXsRTCAZfTaNipTG3F06SjwJyhGPKUFFShPDFBFFoBFrbEYdnFdsasXoYrlceMlVt5loM6QsxsQiaCb0ZXPAHRS4kzI/MgmMtgHPHM9cqgDFxCYnpgCZrAB2jAB3DAASBAk4jhQtWRSMjHZEzhZndKHcsHEd6hHdphHdRBHdaBed0kHvYaHo6XG7LhGoCBFjCBjOCgYIIDfE1SSR+Rn/c5nx3/8YGsRltXYo1Zowum4LK5AAq4ALM7m7OnIH3Tt1IoOg1+tA0WOg3cQLVXm7VdzBNF6w7iYAj3YLb3oA8Wmc2ai0N2EkIckG8DhxUqKzppqcBa0bidQRmKwRiEYRZWAadbIZ0+oRMwoSchwVAtFoUTogEdARI0jychwbp/tgcdayIOoZFfeMbaLLqG0GDqAA26sQ2WgHqyWnNqgAIUwAP4AJuxGUMliUOBChG+54cz9B0K3B3WYRw0s2n7Gh68QRqUIbmLQRl8wRbwQAkczqL1eNcy6IH0+RGrbq38ObIDOltVYrJjIlOmIFOgICZMI8VBe8VPI46R8AzIhlPlOLVZ/9uP40AO4sDH47YPbJtj+0UjOGR0I0JVkqMSJGsU1OkVbMHa4ulWpLwVpyEaijIZcMEVVuEVoHu1NAET2gUSdhK8rVtC4kVzKSG8ebvMIWInJ6KRD8G8aayROTYPCqEP7EAMNvtgzCAP0ICZU+Bfd6DBUoACDIAPwCsQGo0MJrRjtAensidD1fEel9ccxAHT0QE00UFwl0GDZUGWDqcZTuE+zoCPxWC1+Zix9+JaV32xow7Wq2aN9UoLaj1RmIDsQmXFd33Fr4DXf52Oa1wc7czOcFyP+ViPkz0NwskI/XcIhzOkMaJDcHt0RxdMuxsTXOUTmtOBf6EYZGkZfijcsf9cg1eBy6HbPdmljQouB6/bUMHbcz2XDjdQDyQVI/bgY7OgZPkuqyPGDJagFr3gDrqgB8wAe7F3yWYAe3XgB07WB2yAS7wnwDP0vG73h7FZe3y3EdxZHvr6Ib1BG67B02nB2oShpZHhDxQ+OAhDtVe+r/wZSUNsM6Z0bR+xw1MiCo4gbCe71nve52udmMkOxX+dxUNbtFk8U07EL5jQznre7Er71AkLw6XL2bV0D6J92qW9pFClS63dEKy7J/+mOVdBFnBBuWVpOpWhceMjXk+hci8hld3IUOWc7g3BsXaSdEnX2vdFD7IyD3QrgY9pB3iAB9btl55MtjigAz6ABlD/5AzeACS+HhIwgacr4QWz7+2CwQw7JhMAARFGFUNxKmP4YA4GXEMzppEYnNOn4biTYZ7mqRnQohmQ4RRgKwWCo+Xh2DAiO+YFWo1XSJj6ampy3sSNXn2ZoOexC/lxPeiPAAlkygiQ4OiNfwiKPuljggu44Oex6/Uq43vHRjLuBjNOlg4G0LXrAA8E+A9weyOuPiMo9Qx++UvZdRHCnjxVwRVwITrD3RmMgRdkASBcrVp1itSnTpgiLTrESNEiSJAMSfzzJw+ePBjxlMHDUeOOH2V+7NhBg4YMGWVC7ujQAQMHCjLW+MHox48jSI4udfo0ChWqVrBg+YQVq1evYEiT/xIjNizYUVONBI15UgULmTmPMmVKRQxRoEBz+AQiEyrVo0CIvHGj5qwYsGLJiilTxqxuM2bNkN1CReeD3y6Au6RBk4bNGjCIEYd5k7gxmDeQwzR+E6ay5ceUE0eJgnjzkc9HtIgWzYSJEiWlT/dYfQSJkddGPk+B8hkK7SGgc09ZsgT1aNFlzJg5w0bNmTVr1ChXs+bNmuPE69ixyDGPHox5amr3M2jQnj01M+YpQ4dOxzx/OlI0NAnTJ1KnXNXiZexYs2XHhPGqxaqgQUyOFOLHHoPUcYYfhaRHR0g6nCSDXyxR4ABLHexAxw9KnAFHR5Ro0skonexUylCx3HJLL/8nJjXMikut2JSKLyaFFDFI9WJKIoSQYUUMKLgQRCBnIZIKMqGgBRYZgJCBCCKPIALNMsUUU98yzkBDTTXQQNPMMbG0goopnPgh3A9pDHbGmWeuYdmakoGxJmOVOZbYYpTF2dlnnIGxmWdDaLEcaakxoUVpajAh2BdNcCFYGokCxsWjXbzmgw+SNkHDDDTYYENJNsxwkqczhCpDCjLM8AGpo34aakkj0fDRD6sFt4VwWZiRxRa89cADDyONpIMOO5S2gwy9ArsRHuxhAgopq7iiyiqqqEIKJphMYkh6eCjRAwUf3MAAAx80KEMHMvwa7rF4/GEIJJMsu8or78ZClIn/t9RSiy645KuvLbbQMossstQyiysAzyLwMcb8wksvttBrIixeoiKKJ5lI4okkX3zBBxZYzIFFIFg88fEYfKQSihVzAOJxIIB41XKUxuCVZTU0Q4PMMKdoorMmpjDCRBtbbDGYcGieoYacbkr2pmJtJs1m05pxtueeRwwhKGmnpabEoEyooQUXiDZRJqSONmF2E0i4ZoTaRviwqw9FxL3EalkswcMSP/jwAw8/ZKGrrjxoyoOumvZg2mlZaFGGEnb/sDcPl6bAAQd+TY6BSxRygAEFFLjEAYXl0pEsKMuSYjoo1U4SER6FLOIIHHAMoocf635yyu0DufJKLfzybgsu/7vskm8utOTLL7+0AKw8Lcw3r7wsuUSfCzC+ABNzwr3EEgwxlPgRCSOHeGfbF1bggIMQQmDxyBxBYAEIICHPkQkiQjxBMhkcW4U/GUjOBQ3NWMpLL1pRCk1YwhKJsEQqLrGHOvzADD04E9HQdDQ5xemCbWJTZNaEND0hLQpHEJTXDmeawZ0GNUwowqMe1YQlcCFRXHMUEr5gBCq4IQ1tSIOiFtWGOtQhDW64ww3j4IYiuiFsiRLDEIwwmxvQ4AZHWAEPQqiFM2hBCbvC1AxSIDkHSKhzGHCAAxrwLTIqQAHfOmMZO/ABcpXBEMoihSpcQcdZ/MuOtcDFvXShi1qYSP8Xv1BYIHfRPFxI75CHhJ70kqc86QHjkXBJxlyc4YxnPGMa06DGNTZ5DWpAYxgo0l4leICEGshBDlYIhBBg8AQrCOEFT5hDLOFXlUA0gg9jaAQiONayKlCFY/jLXzOy1IxmECMW2itFJjZhiUw0ohGZsMQhlpCFNPSgVsIZDposeBk7Pc0ydXIMYxqzGcd4xk9eG9Rprrg105SmCGbjTRGWkAYXqjM1Q3BCPtMgGC6UqQ0A9WEd4kAFKnyBCgR1gg+cgIQhDIEGK7BBDbaYglNxsaKT+8Co2tiBz3GUAwyggEfb+AFd/WANeNBDISLyEPeUghWwsJctePELYdjUF4H/tGlNizG9Q/rCF4cEBiKjJ9RHQjJKknSGMpRaSUtGYxra6IZUw9GNcFiVqlKdala5wY1rLMMYTcneITyggqk8IQgxCAIQqoBWtFYBEWQAQhCC4MsxhGITHPPYE0TGvypU5SpIwkJegtEKMGWCE6OwhChM8YhH6NISjSBiGnyQhQdO8ExsaAybkPbNyzDtMXLKU2f2pKdygvAIUXAoCB1ahBTa4G5NWI0NelAEwGURcjyIGxZZ1asdBC4FZOWiB1Yg0s1tzgHGlRBy/aJcDhBrJORJ1yIiQS1MjKIUp3gFUZxyFBcd4xguqg/ChAEMmwpDSsYwhlHXC8n1ugUYyYiv/ySX2tSnWiMb2tCGN9DBX3TAIx7xmAc8rJrVbsBjHvKwhzzSkY5xjEMc4PiGhKsqVbVYwxm5qE/2GKECDVhgDjm4ShDOioizmhh/I66CFZ5ABpCtuGNImoPH3neVlc0BFqPQhCSiqZVNmIKxiNDlIxIhCCc0oQtF6Js2i3aGOXGwg0yDTGaY5lk3ORnK5Ewtbhzq0MjNYFclCfNG/WLRMn9AjGgW4+bI6IAzKqABYmxAA9hYrh2wrhAr/RBPSvGKEwXyu8dAhqDrgoy6LIMZy0AGfo6x6Lk4OhnGmG8yjBolpMrX0cqwpDSkYQ1sZKMb3uiGfwEc4HmUeh6oTrU95v9hj1a3+h73sEd/w4GOcMgD1riGNT3o0WBwgOOqUuWGM4R6DKcwwgYe0MAFsBADIDRCCOYLQg6ekIO0TptjIguEFfIXzCcsaSxLmsNY8tpMSzwiFEOG5iaiIgdBbMKxRaSCD7iQBR6YgTD87MIUvIBlC0bZTk4DuGMEnlrNVI3LDt3UDW6wgiHYYAUVPa7mjivnMXqx4g2gAAMyHq4dqEEP6flDRCBBifeUAruw4BcghbEi8QL65crAD6ZjroxjxHwZy5g5pnEec0s6ddPSmEY2tlFV/oYjHQBm9apVbY9cOx3W/bhHP6ZO9X/04x9YtzqsVw2P/qLj1lKfeqxdLY//eKRj1OjwRjQmXYxj3GISPKgBDiowgRfEAAY5GEELVrCCvVZb2h2rQgxeEIgxWMEKG8OfEJS0virAT8ZzqAJZGtHYxqK7EaF4piAaYQpB8OELSGgCogZ37zIFpgvKAcNyVl/BxDgHObBnDuydA7XVj3YzTIBcD04DOQed5AOam1xxvUjmU/nluUyAA8gXYQhH6Oy6p2jFibo7DJYjQ7zMeDmgl3FpZcgXqZGUr/jn62hKPiManMYvN0ANj/+emumubjquqU5/+mf9/vjP/z/2wf/+70PrsTZr6JAOTUd/8YdqZmdq8MANygBf4IUKedADKiABExABI0YEJuABSJAI/yqQBEQgBx7TMbKkMoHwBJsQCnwgMlgAV0/QCFhQBSHIMhxzV6GAbqFgClpxg8vETI1gBTBwKSWxApcSKpjiK2HWW8PiezKwAg6iUQ4iOcVXOZTjUZbDOWrmAAwQZyHlRRgAIX6hAxvxB61DXTtBCqXQCmi4O7bAR7fAR0YRSArDC7ywC7qwC3KIC7+jL4fEPIo0VJQWX+V3fps2DZ5GdFdFawyGdPEnD4xoD7tGD4woD/RQD5RYD/jgf/2nf1iHiZyoiZ5YD+6QDuCwDURHiuBAD/1AD+3AawsmDhD2Dd1gaugwbFLSC56QCImABCtgPiGGMmiBCKEgCD+GSi2GCP+A8AQx8BVEYAq9gAhWwD9JYhXxcxVNImObcI2hkAk1+G6Z8AjXuG6PkANCSBIPx4RKeI4n8Su+d1FOSGa/l47n+CvA8hFKsANlgFJ4ti6T0B6fYHKnwAqs0Aq6o4a4wEcGWYfGQwu/8zvE0zy0gEgO2YdEdVSA2FTPMIiFOFW0xl/tFw+RyIjs8IiTWA9TVw+7Ron04A7ucJKT6GpXl3Wc2H/4MJM0yYk0eYkz6Yme2A/uMIqkSIrfkA790H88mQ6vCIsCFg1Scgy/0Alf8AK4dHhEkANWMAYmIweNEBah0AwnYwXRSAZ+JQRhIQhz4ItzYIxzcBXvAwhNAhbYWIP/poBum6AVlheMNeAq8jiPJBFm6lgu4tKXvvcr9FgGGnIR6vIQ1OUh8HE7rOAKBjMLtpBHckhTa2iQckhI/IKHeMg8xINIz/M8fghJFflz0pCRVfVrDpYOkngO7fAO79AO58CasRmbrfma68AOKqmSk/iI70CT78CSu7aSlUiSVJcPxpkPlGic97cPNJl/+aCT0Lmc/FcP4/ANQLkN32AO9bCJ73AO66AOEYaU0iBJxTYKO7ACMMAHKTgGOUAEZbk+OMAHOGAFSNAIqcAH+/MVviRjVpAEY8Btj5AkSrIk64MkgTCXcfluc/lujlUWjzAGRuA4IgEr9bgDu4cahGke/+ixHoswCZSACWWIXQFJFCViFL3wCzDSFNVXUzWlH74QPEDlU0NFVEHlXpY2Fz+HSZ42dIZIaz5aa4mYDt+pDuowm0Z6pN3pmkq6pK+5a7/5DpZID096k1SKD1JqiViKD0N5nFzapf73D1xaiVj3nNGpify3f+7wihAmDtrpfzPZDhIWDtuADXPBDMNQCjNQA0mAA0RABCxWle05FX26V4KQBKlEBo2gMiKICCSDSvoDjF6BCILnbcZojJb3bpRXeY21CWbBB4RwCIcACdTSj3tGIiZiFMHAIuA1DNqXXt+1IuZ1XsUQq/pxU5Q2PewVJW8RSZPkcxfJadhAikUHYP/pwA4fmWCS2HTKeg/GKpLysA7lUA6s6Zpv2g612Zv4QJuyCZusaa3Yig8ruWvy4A7JepLEOZRumg/4oK7suq7GaZL10KX6V3/0Wn+e2KWUiA+v6Z3qAGG+Rg7m4A774A/6wH/Z6ordMA0xl32o0AMZkAM4AANEwEreFgpjEJ+I0J5niQhyEG5PgBYB+osnuG3QeBZpGQELAAEwkDIqwySO9Qhx2VhB5rIHSgyCZrOCVmjFlBfIUEx18bPMUGiCJnOOFmnpFWlzMX5xcaPL4HPRgH7TcA365Q1dhw6kpmqslrUFKHVhN3X7MJRgW69TZ6YxabBUaq3ugK38V5vW2pr/VjqS5yqSLUkPzDmTZtuJWNcPlAid+VB/8GqSuZmb6xC4udkO5nC4iIu45ACw5vBg4DAORNoO/acP+noO4wAOCntzrJAFOAABJCAEEGsFRIADT/AI+LkJJUYyiDAHduWCagkWQGJLjfAVz/iMSYIIMRABKPA+S7K6VyEWTeIyxqgjZCAIsZCzg4ZoOAe0zNu8zoBoTWWRUNtpQwdq/eUN+xUOpeZqSgd1XBt14Au2Xzu+4juUMLl/6Fum0RmTZUp1/3d/x3l/V3d1dXuJBiuTM2mJbuqbvxmcQ4q45UAO4EAOAexrBsy45kCkRArAiVsOudmsjDgOIamSm9h/9DAO/90QDZnWDLtABz5gAhEQASTwAkFQYtsGJHuFAzpybmRAlSijI4HAB2dZJOFGBiwmjWTAwsYIP+9zS9X4MWy5S6x7eFbwCLGAs4V2czi3xMtraIe2DNVwDdyAvR1JaleLatybalh8D8bZiWX7vuj7f2Bsr+pbxvJLr2C8k15rv+yLf9PptyYJiYwIrQG8uHa8uNG6uBF2wNEarebgx+NQrOyQwES6DkOqwLfpDuwgyHIciarpiPQQdvx3DwvWDV11DdVQChI4ARAQAVjgIyGjJGQwYh4DuiETBKukgjLWYl8hbmhBY1jxPjIGCKgbbl7BB++WMpUHV8NLBmOQBHGgCP+icAq6EMVRbA1c9Qza4AzGEHOMZnN1McVUW2pex1/Fiorr8A79IA7W+ZPbUA6q2A5Vt39nCriP6A5Xt53zG3W41mq75nSvhq4Gq5z6V6XU6pveqq5V+sX8jIm6BpINZpSuaMDicMeLm8CHqw6GbMjuwND+qw70wA4SHdFyW9GP6IithqxWfGoZzWD3wGvh0FVsUQyrgAl+sAImcAEikJYjVj97RVchkwNzsHiPAGNWMQecN7tp6RUgy7sqI25eIbOBxQfBGwpe4UtWYIxYsGItIAdx0AaFAApUO81nZ2Bqp7xfNRfF4Az7hQ5YvJEDWKwCuw+9uQ/k4M3YmQ6T+LX/45y3enuuenuS9Dd2r6asde1q+pyJnli2dnu3yinG/Ed1cewO7TCT+3oOdVwOiUukBuxrrvjYrogO4jCA69C27ZCblRicQtrQCz2JHy2Si8wOH43R9IDRjHh24nCIUkWK2dDa2YANsB3bcmoNmRQNy+ALrjAth0ADJkACExADZyVtQuBLWJBi4mYVUPEIOhIyj5AKm3AVY7C63yapa8mybCnLsxzUTYI/+5kDi5eCjyAHV2AIUg0P2iANYQ0O/uUN1YAwyPBdxgAXz0C1VmsPYM1guIl19bAP9dDNPxmUk0ivWTecgl2SJUmSgz2u7wy+30vObayT9VqJgt3QjB2e/xJ24RiO4QYsYRH2nYebx+Ag0UHKYAttyCNerOWqa86a0afda78Giz/Z2rGNSdMAdEBH4zhO4/jVScyMCwNhEJcwCIdHAigQA8Ad3EEACMYNCCzDP/iTlmMA1J73bTK4ginDPyjTCJuwlvADWN62CSEoY0Hgy16JBUnAB3rQCt5wDdIgC99wD+JQdgwIDUHLqsNgDOcFDPP9X/Nw32Kdzv3ADt3cDaYoiXDd1lk3v1ZHvvigv2ZLk/tdvoCNv2kMpmS6znrLDuuQDh/e2Bn+DY1N0ODgr6AeYQ7mYJD9x32s2IgbyEG6axIt4qq5YF53uaQuYWg9p7G967wO24SI4/82Pog0vmlPSw3R4AzJkAurQAqgcBCakAmHIAaPYAJolVbSNmKIgFZnFQNWMWIxgBUdMwZjQOZAAldVkAM5cFctFrIpc9Nw9TFpSctnmZYcA1f/SQY4QAWFMAzY6w3bgA7jIA8G9gy00AsD0QugNAy8IKvR4F8D5ur4jYp62w/pMOikOA7mu9eZKMZ5vb9V+vH4kHXvSokJnbjmEOq+BuocHuoE3MeLKw6pyWCpacgKven9Wg6Qm5pFeqRGWuKbnvIZHuO9PvRDL+OvjQ2dFtu0TeNLj+PW8PSZRA1S/7Rb8guzUBCYUAqfoAmVIAlO4AEtcAIxkAMv8AI5MFejbG3/HTNXK6g+HBMEhscHq6tteyVLjWWgNAZYZ6k+ShJ5LIY/exVLrXR4QiAFejALUx0O84AOouYNzvAKlPAHkYCqw7ALv+AWySANVBsOEG+sxEmJPkmKwaoOZ1rpWGe/l7h/6lrBzBmThr3qq/7psv+KBA3ZDwbzqP5gJh/zDCYPixzQiRjroL3I7VCkdYzhaE30M57jhKj8OY4NzU+9Mo70TR+1UI9Jm/b0Um/sz4BoCVMLp/AJmAAJIVIJjgBZZPUCJ+ACRO4CKHACG8D+L+ACaXn27gPcZSkEqJTUS7LcQKAkAIHlUahGgbBYsYKlCiBEAp8oDIJlDkMyWJ5cHIOD/wUMKGxAQfMGDx66cN3geat269AiR5cqtQp2i5evYsWSWUMnblw6dvLc0cv37189d9+2HT36rd0+pviYPsUXVajQfv/oucOKdZ05ruS8kgMH7ttYsmXDnkUbVhw4cW3FeS0XV526dOrG0S3XdtzOdDzlyevbF166wegMh0M8FilSbNi2NYYcufE0yZWnXcaMWfJlbJkvWwMd2trn0Z6lnUadOtozZ8qK5RI2SxWpT50wOTJVSpQnU5lUWHkS4sKFEyFEoEDhogQQF0BiPInh4oWQGEFc4AgV6gnwQEQeAiFTpcp2ilbIkJk4B0sOERfnjB8YSL2VMUQ0qMCBZBAlV//OqFnjxhtvroEGGVMc6WMQSySRpJVeevlFmGSSWQanndhx5516guqnH3aMMqqbbcTp56l9nJoqqne24socccqCkayz3KKRr3T02msvcQLjMZ29euQpMHbYCSxHxMIZS0Sksslms9Moq8wyKEcDrTFrJANtGtFAy+ZKzEozTZppxKSmzDKnMZOaaNZk8xnWnFlGGTmLASaXWWRRxZVVTjmlFD9L6eWWWGIRpQYNYCDhAhJOiKG44pw7YYNGY8jhhCdeUA4LQPgIhYwgECGDiByeACIIMnJARIgcsJAIEUAmQiSIIMSbg4yLsAjEijlyyEEIUQXhA4sxGvGkFGGgaQb/mmqQueUWURpJJJFNYjElkl6GQeaYZZZx5hlt0ImHHRP/6ecec89Ft8N+6rnHHnrokWdIeOWJJzB57PlLsHjikeeqrOZ9lx578L0X3YAFHjjhv+IdMt4c3RLrm24mnnixo7LZBuOLF1OSYo8/BnlibkbmRhuST0aZZJNH1iYbbV7W5pqYY76m5muqKXNN1uJUxphihMklF1pkIdqVPF1BehU9XYGlFqdrsaWWW3qJyRQjPNjghOFEeMFSQJ4goYTolnuiBBc+FQKGiBCBQQiEHglE7RiqsGiiQJ5wGxFEDAJkkzlMrUK9i57IwdYTAnkkCCLuRg8RUTiJBZpjjhmm/xdTRLGED0IaCQUVTy4ZBZbJj2GGmdaw6escp/YhN+GA3RmSnYOJTGfhhedd2B5+941nHt/7Dbjdgf+yx/d5hrf9r5FIMuriJqWcDMoomdTG+SaZpL7lo0IGOUABU0b55ZRtpvmaNHV2Bs5lkvG5zlyIlgVpPVdRpX77V1Fafv1deWXQWmCBxSxmAYtAoSIOKmjBCV4Qg0TFwIFkcCAJJMWQOTQKBm0LQiD4EAgh4GAMc3gCEVoQrIeQ4WtEmMMYcLU39PStCs95AqiC8IQZkkEIj0BEDmCAA1ZhARGN2IQpWgGLYQTDQJkgBCFM0QhREKIPmtCEI25xDGRwyxnJeP8G6tyxOnL9zic/uco65jIXdyQvXulox7vkBS+EDa938+DdvghjmMMcqXnPg5JnMpMaMekRTKTZEpWwYQ3sYY+QLivkykr2smxcA3wrc+TIbIYzNblJfcpIBp2CRgta3Klo+sPf/eiHP1KWkpSseEUqX9EKVr4CFql8JSwFtQcjmAAGJXhCC0hAgug8YQ4uOAEQhBODEgSuCjA4AQxewCshjMEKRAjCCOZgBSFgIQgO3M4c9AbCMbRQU3/z5SMWMgchzOFuD/GlFXIQCFc9whKmGMWgehELSWwCEYQIBR/6QIgFHYIRvSAGMkwXJyx+ox9R2Uc+6OGivoxxjH0ZUl//4tUvd92DHkSaKJF2Mg6SIKZiS2ISZPaYGj2WVEt/NOmYSFrSQLYUNDaDaUxxtiZoQCN9zCBoTYDhPk7CT36v+KkqhZrKn/KvFaxA6ipYwSekHhV/qBxqK28BQFgcdYijkIQokECEWF1gA08gQwMfggLoXAAIKHBgFU5gq0u1AAZEGEMIcYADIuAABjEQwQZeQAa4WQEGPQRE4MLztVuZc3B4EwIgGuGeQDDkEZnYhChMsYlGbFMQlhhDKIixiT6kwhSHgAQsbEqNZ5xmG+c4EevqQbt1iBFIPipSTpAkMYs9L3p85KNJs5RSMfXxSyjd425J89svoQlN1JCGmaTB/6Y2pY+gmaQTT+E3XaR9Un9RbYVQWclKqA51ldttBSpQwQpUKJUVTx1iK1XZtFrEoqqwEG8TbCCHJCBkAxaYQAuEEIQLIpME18yaA4FwwYMEYQz89VXbrPCCub4gCC9g8Ax9KSwTAkIiLogBCC0yOCFMeD0pBM4TAPGIx4ZCFHwQRCJslYNGbM4SqcinIJaIhjL84RfeE4k4gOKOfBCJJGhJkpKchFvVENnIRg5Tb59k3JNqRrjDtUaapIwa5lrSueubUHSDFjRZDG261t1f0vI3P/yd4pRIbSp41Zxd7G6XvKxQM5zBK1QA/m+IsMhEH1RQgRGwAAe8jIGiNuACXf/moAUiEAEJEH2CEqDggi7IAQ4S8gRn2mqHvKoODVl1Q7hVGgvoIRzdbuVLg8zhEcDxVVytMJBQPGKJRCACDICDhVAgIhSmkIMc+ODMHGwhD4YgRTO4oVyVSsNNx0Z2spX9DJ0xOxp8ZC5zcfts1bCJytK+9pqOXOzlVvlNcJLThMSdyZ3ylJM9/TJ196cKUoKSlHyCN7xLGW8z09vM8+YTd8krXn5zt5VyZnMqpcZKWHiCCxLwAAs0cIEYbIAEYKuCBMfTArf2V2uMcoEL2nYRPuxtDHwgA0JiLSshtICHOXgEGXBA2CdU4TyDa8Qc3vMIv8GN1o/wji9DYc9AJCH/B/QZVUQe0Qg+bJAMjXUbI1BBxG35zCbJkBMmoR71bSljW1ZMX7fehOw2OTvaXwd72MU+9jddXerR3emWhbblcgNDp2o/d9wFOAtO3ulOSJv7dU35bnj/yU+kAHzgSfF3wZPC3nwqpXjz7WY0B9yVrwRgeE2RCBVkYAIimMAGJmCBFkAnB1XIeMkpFYQcOPACECY94dw6Bpw3cwx6C0SvYKBDGKSQDCSc9CPUM54gWPhVtZK50KdJhY4HIhDoOY/e9qZNFAtCDo1FPh88gYpbYIsZVr861rPejGZk3fvPgMbYw26mNZUpuVJO083Mh36a1vTKmPwZMHwxf7XX3/5b//ZFLtzu9p5BN+2+wIVdCJpd2AVcMEBcsIUDtIUFNMAFjJpZgJqnmTsBAiBVUq8w2x/8cQX1mrNXQLOmajx985/2WsBYmJpbMIU+QAI50LwJ8CpFcQGvspRd+S9eOQFeuqsMw4K1CgS3IgIsaIEcCAL6QIRNWA8RmytKWbVWkwhdwYLqqILeA4SKsIggEAIyQARdkYMxGINckYOKCIJaAYSv2RQrsKcDKz0a4gNTIKBhwKltwanSKR1n4L465D738748TJ+aqinw8zrxU5Ouy7qqU4ZjcDr32SS5mzunOcBaaMADLEBc2DICBMD5+wW3MwZj6Jnooj9fIMBPNEACPP9ABHTAUoTABayFCRygWEqlC0SaVtjAWIRFoPquNWtFOPvANRsip6EqV2oWVBiEGjCBsLoAETiBCSABF9glBsJBRomBHHSBDntGi5A1VXkCE6C4Jyi6D4qITcgVCyOC7BAEJlwPhYDCEJu1hEiFTbgIK5CDRxiDL0iCh/i0VZkhYbGCbXxCGLi9PhCiWwgG0jmGqcu+0sm+gzSdrMND7+NDm0qf7ntIg1yG0TEGYRCGX/DEA4w7p6k7u6OFp/nIp2FEXHBEklTAACzAT9wFXmDJXfiFmbBIY5icmhCG/LNJT1TJnBzFBkzAVITAWugkVZwF79quVtRFC8RFq8ou8Er/qjQ7KjhbJaNkJRRsAhpAAg3QPMwrRvGAgYhrFBLQpRYAhFA4AQx7gtr7Oei4CBgwgSCwqw0oQrqKq+ygKysQhE3wxjkIlqCboeoYlYsQQjNEhIvAAW3chI/bQvNIw7EUBF1BBJCrFCwoOksAIIDUlmOguoPUzDdMSGcwHYnkmcnJRIu8SFA0QKeBwNScu6jxSagpRdYUydgESqjZyQQcRZVkSZa0xJokTW1xjfaRv/nzBV7ISeI0TQW0TQFizaCcQO2qxaXUxThzSuk8L1xsvP5phVNgpaUzBTeogbkagQuYAPQYjl1yAehoD7DZpROgxodTiCdIprTBFZNTGxPY/wASCrppEoRh+bidW5wVwxt0Kr1nXCYs5JVhySciwKFeeQIUEA+G6DgcMidEmANBEIQ+EIXKDAaZLAaZ9NDREc1hGIaY/Jn4yz9JxIW4k4W58y5YehqqYi+oaZYIdBpbuAXWRMUaRUVT5KSdlMSg+dFPnIlfiBCLFNFM1BZNzMQlLVGLxMj5c8mXNM5HRMDTdE3UVEWpfM7oFC+k4rfx2rentM4PDMFY2E5TEC9O+AIVMIEn2ICsGRVA2DwJig4X+CoguLy7IgFEEQGNExsbrD0+uKAXqD1VkTUVwrRd8znW6xQc6DD+Aiu16SFQw4JGiIGOWyG9saEolAggoLVeGP86+RiIRAiFzREvWLiFCDkGI3VSEdUFltQF2BRKMLsuomzRx4NRXB1B2aTRHC3FUUxA21Q7AiROXihSmTREEC0dXxAGmYwTEB3Ni7REKRXFACTORrxSLB1Ko3TKL/VWb0WqUzgv86rOpAJTMoUz+AIg8dIEH0CgHBiDDWiBCcghhtulRLMAB8KrPd0AERDCICABlfNXtUE9/jqwD/pBR+WDCjqPR0gCPgCOXVMb6LACF6iIJ4CbTUiF2FOnHIArvzGVgyAc6ACCkq2CUEiFiqgVDbq1CzWFB7mWTJw/XsAFXbgFXbDZG31ACoRRVrzVVEKzpwI4buWfoh0qo21OoJL/hdn8yI+chWBFQF2AxOL0hWMF0cmBQ2YwxGZYBpyKOkP0GWEIzl+AWV6QWlwwVpqFTdn0WeqENy/t0nHdO6VqBVM6hfHiNzTjt1hABTS1BB7IABNgARYYgV1StBeYgL+BAUJrOBEogX5dXLzSOF7KgQ3AFehgsMI0hUcozAviwsUZTCsIhVUbgxz4wicIhEaQlV7xoUd4AhibNVDplTG0CFqhIeewlYqoNIbIlaLjAyRohFgIhiM1BinFBZh9kFuQGuWFQPfq2eeNPMcDqnH9wLm1Xg3kH1XCOwGKu4/E2QM8W13AzSGNSSSlSNFchpqiBqnLxA51OrG1xNxsyQLM/0hO4tVtbVu5FVp9C9q5RZpXsNvEkzN+M4UCboQZcIAIyDzxbMHMgwGMTQVAUBtF4SVWQZTSwwIc+LwLiogojDQYcF0hvKBREYJqOjoNNt36og8wnCGSW4iHEMIYwoIHrgjdU5XxeI7zgIgZAiI+SIJyoqEOI4ReyBZtEdEjFtFgeJCcbZYmbpaosdGoiQWR3FXUfKWnGRQAEkrV9MmfdJopfhoc3UkBNMBcEECVHM7hpEThLLegkb+aKAZnWBNE7DJ0oy6fwsD7ETP6OQX7obdSGDzAK4W+gzfAqx94s5/6mS67mwWyfRBP6IM4+AI5UCcYYIEM4LO86tcIEIGt8f+q3gsCY3xTO9Wm/7JT1GsBtLrBxb3BEdC4HFgm0nsrTJGIGOArRIg106UvUZmUh1AP18WBF7LlcizHKIwB3dMm6iA5jd2gR5hC58CCJFAEWAgoyjniXxjeyukFJm6WQHliHY3NQQFjLFWlL6YqoeRVkXTAGiXFmsXZlaw/UERjKBVO4Vy7cvMFY6iGargGTULE+ktRu1vRL0ua+smfRK4fUpiNwmNowUNoVSAaWtA/m1AGbSsTnJlIZkCGUtiBDJCACtAAsNyAEdCAwi0BCi3GYhQBW8ZTFEAEILCAfs2rPVXGstyAHNhTRFO08/TXXSohEHomT9HX5DsVFqPkMQD/Fgd64Isgsej4GkctHCuYqxmC5YcQtYfoxkbILPmQj17JgTi4A1MgBmKgGiIdhl/QBWGAVW524hnlVXEWZ16EXgCCa9l84h310bO9TV4w413ASSFdyU8UTiIlTbGVv2Y1hmW4GW6IBtegk9foa5W0BVqY7HObhXXLk4dO6IZWaPshmomGum6RBkLaBooJB3BJmHlAh26QhmJghmZAhSz4gAzQgAgogRHYoSfQ6RJgFbTq12IEghfYgAsoGxSwgOGAjg1AJpJ2OIcbPWCi010iVIGwgiB4hFRABAZ7gUvRACFIAkQghkZIgkRIBT7IuFWB4FMRsUpBJxSaMFkJQw4y/yeVBSG91CZN/TQ++II92IRgUGIi5QURzU2cdWICdGIdtdFmEWdBaa8XpWL3quu1dU28HkXxndp5/mu/Fk4Nr9rCJk1mZdaJFAZmCJptgQZmAAbSBIYnpb/7s+N0gx83djuo45bSogwm2QZvQAw6oiMguQt3YIqLAgdpwKRm6IU6SAEVYIEIsIDHvS8JWhTxVBtEQzQXzLwSKEZlFAEL0GlIG+mRviaGYyBlTMa7OoF8BZW2eYQqHJU5aIFnQoRmGF1BaIQQe47EwoISjgFDNSEhQIRgMD4s/JvKGpZMkI+PW5XzGMNA2AR1SoJN4AM5ULpUfZAIMYbhNFsm7oVdOP/wp2nrBFdwLE7nRdxZuptwKM5rnFX1V+Xwwa5n+UvxqiXSWY8QY+W+U8CEUwDgWyAFXlhVZoXjndKptiu3p5MTrRMTx+iGcICHeGj2fTEee5CdgzGXvmitdXCHdjiHa18HDMGKDrkHdggHbIgGaoCGS9iBGRiDFoAATn5Tx3W4a0KBC7AACECBErCA46Z3FFhprenXm2aPzjO0h4uBIHQgTXGgF9AAEXCrSmaIs5Q0WgMEt3yBTAiFLfy4xeWVixixjQu6dQoo85CIDTuIgmiELcSBGbIw2EucDks5LKACOiiFbi4iKYVV5H0QTlfe5e30ThfJCdRWL07Fj3zNknT/ZwOU2lV/1Zmo2g6vSTbeKeH08GJgVmHQll8YBu47Bl14BVzwBWCArgmRkxo/DdL2BnCJI2i3h3Zhe3Q5l3LpkHzoB7nPh3uo+3zAe7w/kXUYBxoRi7Xohi6RBmcwBlhgBB+oAQ+o98vrV9LTPEV7U2u6PBSYgAkogRLoZK8abkTjLxwknAgqeBLQFEBouOpoAUITfSsIwtLbbkqhoXxsgUzA7kzIhNJTm1gxJ2vyIHh8XWRIhYNQCERIuVAZFuwGDk/FIY+rDyHsoTEwgiy4BKqhmmGY2UzXhW3eZra+BZ6UcNncYl4l+l+9cNMkVt2sZ4y8RGJX/2LfP6iriU3M/4VkcAZpuIZsmJjTfiPj0f+E4f/+P57jAQh7AgfauzdwHkKE8eKhaxjuYbeI2yZO1JbNIrVo0JjtIqVJ0h0PGSJMWCDiBAoSKERcaMkySBARVYBYsCCixIYNIkhsIHFigggXInLAAGRlDhZAJEiQeQQDRZUnT2MsfQIIS4wqgQI9wvEkRwsyiF40ehTqkaBGLoLEEPLkSZC3MWAQaTRmTFk5SOcg6hvVCplUqeSQeUumV6gnTefkiBH3CZYgSXxsiRQrWLBhv3zx4qXrM2hdt0aTHo3rNC5bqmvVmjWLNWvXs2TJeg3bNi5atVTzxpVr1y5fvoADz2VceC5gxoExZ/+evDnzYsmSKVPm7NkzadKsZcvGjdu1adGeRbPmDR5CgffW9+u3/j189/Lvub+XcGG8efgdPuz/0BuAAQoI4HcFGshNNdAc4womkRyyByE2RBDBAgtcsEFKKFigUwkxXHDTBSuJIMIGJZQgAiCPuNCCCxa4IIQIiISSwwknxPAIGTHMEUoMZATSyBMxDIXFW0LAgMgmjxDzyBM4uJADH3yY8sgYdQmSQxAuxIBlEDnkIESXRBAxBxE4BIIIDlUAAtlXT8yxCSJcESkWmCk+MscTVmCRA1JuCuKGJLEQMwyhwhhjqDHHELooZsG0AgukkLq2iiuVvlIppZVqqukrr8D/ItssrtDmGi2llgqqqaUat1x001WHXTTSYDPRQ+mkI488BAmUEK/psdcesOvpShA99tAjj63igPPfgNx40w033TwrbbTeFKiNNgZqc82B4F3zbTXRLOPLK6dQsgglhxySRgYVWBABTxaMIMKEH6JwwQQluAREFUGMhSIiKGiZYw49NYLFCCfAEAQWLYgQxAswxSBVC08EAoOXbsIAQyihaDDCCDkEiQMROeAghFeO9VsFkYDgABMRT5RZMlw5YIEFEDB59cQYj2xCxlWAxCUyIIEo9lVSa1YxRxyW9LLoL4Ue+kswv/TSC2a9xBJppJ26woorq4g9NtmYhr2KKqLS/7Y227KwKh11y1wXqzXWRPRQQ/DgNxA9780333v0HJurQPSsYw455KijzjjKLhtORJHf/Y3kknfr7OXNfkegtZeDVw010CwDjCyrlILJIpdcwsgeKkhQEwkTbCD7hSeQ6NKJKJSAZAwvjHgBCSLoSIIFS20QgwUwzCHCBC6s9QIKJmuAAxlBMBaDCzAIYQIOOIzxcQ4mgAXDC0KYHFcQS8MEMRZCYFEYUV+9/MQjMQAxR/VivkXkGGR8ScYcWAanMwXBfEBTExnkQAhCoCIYWHuaZn7hGdGQpheRigVrOgU2VpANbar44Ck+KMIPru050qnOdaQxDWxoYxvdCAc64P+ht4XYYx7D4ht76qHDfrDDVukYR+PE8Y0hEnGIE+kGRSiCxCS6UCJKXKJFutOdbVxEit7xHBaxeA3QRcMZyigGLlRxilJ8QhOoGMUoDqECFbTABC34mLy8giEy6Ot2wotBDEpAkw4RbwMuyImQJvACC7QAeyJAAfaWQgItkYBhJHjBmnDQAhyYzAoeaAELXtCCFljBLU7KARmwEBXHiMx6c5jDxAJhBZm5CRFwwcIpCzMmV+LAClyBEywbsbQ5jOErq6zCLudACFF4Amu3cGAvflGaXpAGg7CxBS520Ta20SI5xTBGdaxDnmlYQxvS8gbe8iZD/OAHHrgSnLGQ5UP/W6FjHEUsYuSYmMQlNtGJTLRid1oYRSnWrZ91wwY2/Fk3K36rbtj61reoodCMdNEZy1hGdZJRDGH4IheyoMVsXHGKU6ACFZASxQ1UoAEImKARLQBZBAIRCnwFAV+3+1DAJiCkEF3IQySKASB6Ers7LuVCQphDXGCQFSyYaZVbykES5CBJIgjiCUJYZWSegIj33exmbnnC0jbBBys0ojCA6VMVvGqFoyDCKHXJRCMAsSb85SkInURELxmDFK42IhGKQIXWrlaaWDCTNLqIpi+EUYxivGqb2MjG3WI4wxnqBz+NJSdD0NEfyR1xIgC97GWnSEV8MpEbR4TWtbIFrW1g/0uz8jysFQ2K0Gv0k7XWmAZsoyFb7DjDoRCdTjGUY1HahG2Evt3oRsf2io52FBamSAMFNBCB5M3BCu6qwAbYEoQJXMAC1J3ABCwQpA+RaAMWuECL7pWDTbQABiMSwSMakROhkqAFQUjREyY5hhyICQdysAIO+DCHJODgEXxoRCDKBJlA3OxL7iMS+m52FDJ81U0tC0JgXIkFRDS3L1aowsTmkKI9BYLBc7iqYtbEhyQgoQ+m0FosYoEKU7DYFKNoYGaOwQxqnEdv6bEhjmuo414tZJzh+IY8u4NZIQOUyNvAbJGzwR0pYitbWQwttrDoxGxtq27TkIZsx/MMh0ZUov/O2a0sfOtbUpC5zGYu8xhJUYo1l+IVrHgzRzsqCkWsYAUjgIEJsvuCNXpgdkMBSnW/yzzsys66E+DJIYNgu0e2AAVBIEEMEBEEQuqkePQr7wiIkIo5hEwQiLDCfSkpByKMlQgtOJNb8LQ/pJjvBE9Iq2L0FJcJr1IvmZCTK4mwlTFggQ+bmPBUxYJKLKyyl8AcmpsS0QhLMEIRUeoDIfZQB0e0AhkQdYY0vJGfXjUWHuloiGR//M1pSUSKVHShPCtykYlM0dymJW2Tm0yRFk7RIqXtDjcOylrYUkM8Wq5tl3Or21XRYpqycIWYxQhc4JYZFKA4c5nZzGYyr4KDq4j/MydmoIJLKsYCEBiBBkTmLg34+USDJjTtrkuC6gIPLiV6AiI3cIKlRCAHKz9BDlxghZOyoAV3esEYTKFsT5v6EV2xApUm/AiVIiKUanoEjXLwIzKQAZhvqQIfCpNAYQPCS3GJmSkQ8YhUyIhJWGWZKt1UJDZhYQxzkIMc/ouFrfAhDnUYBCbkJltpeDPd7LYiu6OcxShXLnLVkhbiPyu5eFOZGxe5dzYCemUsY4e2EFWGRAcr8C+valW0KfhseNu23qpibAtfOMRTv2Yyj6IUZD7FxeOciSXQwAMiDeQEQOYBDWwozyx3qUuoW5MLxOAnEdjAh6o3Ipuc4Hg++RCQ/3YCA4S1kQUskKoVBPMIS5RFA4LoBR+OdKcgBIIPd2qrXHZWGEBUHYBYhaqGjRqEhfXSCqGIU1kf0XREdHUOS7/KKcHS0gWQj3haILAfIvBBIAgC3hmDQ10HeWCZdsAWN73WP1lDQGXDam3gt2wLQllRvOUb40FZk1lDv2kHQ1VebT3UMlAHdWTTQ2GedAwWMGhebgmDMNQgdACDcFRULpyGbuACqMzCpZje6UEcKHwCKThcEn7Cw73C1lyQLejVLcRCJqiAA6gAC2wAyGmACYwAdtVETRDad1HX7HwIdd2LzIXIBGgACTwBCYBMEIyATQjFCRRSWDSJC4wAIAhBe/+dVPZlwiPEQiMIxpJUjBWUjCA0lf7JwZ4UUA6MgY50WCDgz81Q3VMBwhxwBRncn2M8FR+MQRKEgiDYXygAG4VVAYWFkmKI0tyJ3SYuXVNsxRzwASAgAiFcgi8ow0MxQzNAIKxkWTRMHr9NAzVUAzIiI0JVAwc2Y0ItlDBumW1dXpdNhzVeIzZeIy9eHm4NljF8Yw7i4C80Rw/2IC/sQmrARmy4Rqe4WQed3hhJXCkAl+uRAiw8Siu0wta0wi1cTSx4wgpEQAWA3AZ8oQaclHXVhBcin3XNTgk0H/Ihn3nhiwsgQvORAA5ogBvCgFCQAFEEQQt4yQvgAAycgJYgDwz/dM8I1FIOuAEViIEYnAUm8RIh8EEijEECdhIWiInIzAHZnQlSrElhWExZnYX/UViQ5MBYbcKSYAHZwYCerBJkwFJUDOX7GF2KwInY3WLR3CIiiIIuYBMvMgNZ1pZZOgM0pKVaZtlCtSUytqUwmiUzXN4xfOM32iBeap5d7qUxeKM1HkNdvmDcLAMzRBRfgqM4liNndMYuhAYu3MJqsAZGDWE7woIGvRkrdBScwWPFQUo+fqYD/eMMUEAG5IRGgpwFfOEJWBdJjMAZomFLUNcFPIEL4IRJMgVPLIW8zMvMaQmf9IuQFN9S2I5QuEBkbAwL4EASqMALfGQOiJ0cLB2R/+iJ+xQbYFwl/lTiJlJdJXbihyFCKtTPxLhJWUwVgX3FKb0FZPCf1lGd0YlFXxxgX5TVmfSFKNTCLxzDWJJlM/Rnf/qiM/yiL5IlWbKgYWreDvbgLyzoL4gjDuLgMNzlNR0mhRpDMhxmdbCg3NRWgVbHN9bloeCgcDCoBHUGaDymLdTCp/wVLqyjbdhGbHiKZ7bCm3WQcOUjpHSUKWyNJ9BAu8gOyW0ADLxR8jyBCfCe7IzAhcgcS+DLh2BYS5AAFgCPTsGOC1wAjbwITxTSzMHABrTAIu2ET2AJKMlMEmgSxghBv4TCiKWXW7AiGfRPlRBBVV0iV8LpJkLYI1QBIv/ZDBGshfUQ0FVMZSj1BZxyhSYWzQHe4lbU55mgQizwQqIgAzIcQ6UeSl/yIDDswqrkRqmsjWu0xiyghm9wai50Bi+Q6II+qDBEaF9OqF5eqKx+4zXa5TZu41le060qA2DW5YOu6oIKB3DwAqmq4zp2TTt+ZmZ+Zit01EbVqI2ewj2y2Ch4QipswgdQgAeAoXfJSxCMARgKARG45gaQ3AjwxIXAQHtllwXw3oZMQAvkBPAsBQr0xBm+gAs034ZcaQgQHxCEwNCcJM41RknCgP8A08ZYAZZEhZzoV2Q8VfuEErGFEtW9j6zBRZdsyWMkwf5c5804FYSdJ7G9D3duolf/Lh3+iV1fNEKKQSYuUNAtYFRt8Nam1KwrtCPOwkap1EKpoAZwKCiJPqheTqiEvirR9uU3ZlOGsqAzMMM0KgPS9iWrNuhmDAdxAGGq1ILXaAoH3Syz1mjCVUqonoaK9kInqIsbcEEN3EAGUIBAQkDvfcwG8AEOjMBJZZe7umHzBQUXtiG5tlcQ6JRMHU8goMALxM6FhMjKiUAIhIBOBAkJHAkqYU/xFd8LSAUevcVQBMJ8iRKSuEkniUyU+A/SzQlWwdIqlQXEvMXCPNXRfBhRgclbpA+rQUai4k96icVWPELRJOAiCkIgZEIq3EKo7obWXora2OymZMrNymikyAbP//qG9K6KD/bgDuZlXmajq2STCyaDMygU0tIgDQrDZnQGZ6AjqXpq6IkezbZNNS3HYFHH3CgUtwQIglRDM/wBBVAAAzjAAkBAu0BAA1DIBBBFC1QAscGARrarufaEJFGFGMYhmNrEHMCAdcUAdgkPGfCE7DDP860cTnikzNlI4GbFInnkUJDPEwABmZIiVjUXkbSV9cCVLYWnmwRCXFSByARCKoSCwsZwrLnVnsCAVeQJm8gI/hjFDcdi78ZJI8znIjZCWTSCJKACqVwULhhcpWixzXrKEKJKqrzv+y7Hqlwv9sbvhdJq90KtA37LF23eDnaecXzq56nK28TN3EQDM/9ujjcolgzJELgRyDJSgzGQgiHsAAVIgP8K5IREAARAwAIMqQmYQEqCTE6Uq926kcMISU64pvMshQjA0iNBmIccj8DkgEvl5odUl0+wBCDZSJbyBE45WhWshcLKSMUmBZPYjEoRGB8Ib9sBQlTM2ld02Fu4Xfu4D1CpJ6KuElKwZ1P0Ul/o3ybOZ3zSHSIkAiFsQiLsASS4Qqtkng5KlDjXoOaFmQiVjc2CMWocR3Aopi80qNDm5Q42xww6hy9AAzI6Q24J3HPYM9xoUwTWL4D8sd4YdN40S5N1R918S4FcQ0YsQzHwAhn5wQdkwABrwB46crnWxJce6ZGWq3J9jBf/Eg+V+qHMWcUfCami4VGOjPAhxYBOCMUhLdKHSNVSvAC+3iGWxAAl0cVzIoILBMKJyYElEILMENhQHkUtWgGv5Qn+6DBkMAYZCEHT6RpfAJMmXhWi3gzLEKoVmB9XiN0jHIUUqxX+3R//+RchJMIfqAJhcS/3aq815lYuFByoDqGp4MZpAEc7RxOnlmM9DzYc16A4E5Yx+IKFYhMLRiA3EbQfI3RDAAi0RJFAccdlW4NrXQQfW0u48PPBlUInMMIKSAABZxfI2C3JacALjMAkp/aRhqQJXDK+cGFOTBgdrghQNAaVXsBP2CsJRAXyneRNBEEqqJcJuI9PvCF9xVdK/8YFJyECMRBDTRJBEOiX9bhVEhABgxHJgQUJKT0Vd+NIV4nFLb7PgBndXAEQy4gSTpJdAiIC8PIF78ISIDBlKPRCKiRCImyCKVACLQADdWDHXNP1NRZDRdnCzu5GitZC+pKqHB/Hlw02hWueqywDecgWNTCDLIBCRX1QMnADOvSxQxieZvsTBU6edmBZW674djT0idtNvimZCVIDRHeRMgiDLKjZJ1ACI3xBBfwvvtTcHGzAcvHeF25SuX7px7yABgwkB89OC7yA/3EhKEvpC+REdzWPSaOAjaTECZQAmE5S+KSk+WxMXIyBICRBDlwuhfEBEigCNJhC9+DAp/Fwlf+MgZ700s7sD2TEBVOH4qYBE8u4BWDECVIQ24K5X1eNAVBmQjA0Ah+orHyGQg+ngieYQipYQiIUwiwY9nRAh11HeOedhmr09Wn81V/xgg+WMYUDNDaiEKzAFnc4C4nDQwwRiDIwh4UOljNcgzbQeorTOooLu4pruDBmmQoZY1s+o0LJ1kZA7S7MgiqQQrOigickAQQ48oRAwEHyXgQE6Rd6abseKcm16wnMiwgMaU4MpxsGz4jMHPDcy1DgUWTYzk5cgAbcSHwxJwyMAfmQj9RlghwgAX1VIk4mgh0ctfXlFxHIyFiVImT4yFxh1dnxRS3mCZWspybGhViEkvsQGFX/Ud2IJUECBUIzBMOkW7M1E0IfZAIy9AKA7YEq/DMwmEqLtkaKvoan3jUtPDguMKhgw7o18uLcqBAGNpE4SbZDSFZEdEc4UFG0XFltQUM0KBQ3ZQMFTiAxwpaLa0esrHjYJ3uGbxk1gmNFFRymxN48SquK9YEEPHKFTMgEDKR3eaFrT4+5560J6OvmYkGSyku6b4lOsIXMsdejtcDE+mF7zYELbAJ+TdIoCvUT2IhThkIi+Boi0BcVOMERHMEKrBKE5clWjRUf3Az7JXMAna6MqJSkV4libAUiRMWEWSLGpz77hbUcPLEgGGWcNDHd9cEhMIIpbAL+7AEo/HMx3PUs/6jGLdTC1rxC84fxGJvQCckNrKhQttTYDC2Efny/fuA6f0COExWeREzZd6xWgVjgsFfga2EZ2Zs9N4ozmK1N2ijcRqFZPKLRmsVCKsQBQFTQAMHChAUQIETQcCKCwhEaLFgYMSLiBIgWTVicECEIFhgvNmwg8WSEiA0nNmDJcUFEkEdYsAQ5MXMOlhhPyGAZ02KMqTlWHm1CFCPIE5GINjVK8igQjidjEhHqI8ZpFTl85ARKwmdMEjKBEAkRmxPLkypz5gTaZApsICxVYGJBS2YuXLRzAGGhayWJFUSCNj2SY6VtIECIHiECxEdQnz6E+CCakwiTrFzAiiXLtZkWrf9Zn3HNwrUZWLJkzp49izbNmjZu6GDDgxePtmzZsL2F67a72zbev3+HEw6buHBvx3lv0+27W2tu2bK55rZNmzXr1LBH057a2bJlypIVAwbMF2dZ58+7crVq1Wf16tmvOjV/PilSp0iV0r8/VSIVGSwgSIQJEGrohBgmqKAgCwS6yAINNJggogssMImEC2NAkIRHyDjhQhJEyAGGAWMggagXSHBBxCcemWMEK9Ii5pEkNuHjiRyCQASIJ8CSgwhEyAgih0dCaaSRR6w4AYgx5EiCySSIIKymQITg8a2zACEDkEdSQSSUQKx4ArE5qnhiS5zIeKKmOcioIk2drAjMlEzgBBFkDkTwvDMUPAMJRJBDCMGTDEEgkWU80y7LhRRQSJlll118yUyZaLyxzVLZhPtG0962wSY6bbYJdRvoPN1GU92ACw7V3Y5rNTfhutEtm264qc46a6aRRlfuvgOvGPHGI48zzz5L75VXZjlWWVheaaWVY51thRX56LvPPlJGyVaUQlTwwIMKIoBggY0SCpeEDSKwIAITNGhBA3QlfHBBCS0cgQQYTrDgiSBE6JeEFloQoQUYJhihhQM/zMGFolzAAQsrUnmkhSTkeIKoJ4DIkYooyUAEp0ZMkeIGLauIISAAIfkEAGQAAAAsAAAAAEABAAGH6r+g3rOV3a6P162R2amK1qmK06iKz6eM0aSF0KB+yqGEyZ1+xJ+Ew5t/xJl6vpl9xZRwv5R0vpR0vZBuu5R3u5Bvu45tuo5quJN3uJByuI5uuI1suIxotI9ztIxtsY50rY54u4hbt4pmtolmtYlmtIlptIhks4Zls4ZhsYptsIdqsYhksYZjsYVjr4RhsINisINfrYlvq4ZtrIdorIVnq4RorYNhrIJkrYJeqYVqpYVupoNop4JnqIFio4Fnrn9Zq39cqn5dqIBmqH5mqH1bp39mp31lp39hp3xapn5lpnxmpnxkpn5hpH9lo35kpH9jpX1kpHxjpH9hpH1fpHxgqXpWpnpXpXtlpXtjpXtipXlWpHtlpHpkpHpipHpgpHhVo3tio3lio3pdo3dUoX5loX1ioX1goHxhoXpioXpgoX1eoXtdoHpdoXlgoHhfoHhboHdYoXVUoHRRnXxinXpenXlenXddnXZYmXlimXZcmHVbmnNZmHNZnHJRl3JXk3JZnW9MmW5MmG1NlW9UlWpKkm9Wkm5TkW5RkWtRkmhHjmxSjmlPjGpQiGpWi2ZOi2VJhWVOjmFBiWFGh2FIhmJJhV9FgWFLgF5Jg15EgF5Dg1s/f1tBfFtEfVo/f1c7elc9fVEydVhEdVQ8dVE4b1E8cE43cEwya0w3Zkw6bkkwakgyaUgyaEcyZUg0ZEQwYUY0XUY0ZkEoYUEsX0ArXUEwXUArXD4qXDslWT8uWT0rWTwqVj0sUj0uVjkoVzkiUDkpWDUeUjUhUDUjTzEdTDQiRzMkSy8dRC8gSysVRCoYQCkZOigaPiMRNiMUNx8ONhoILh8RLRwOKxoNKxkLJRgNKRYIJRYJIhUKHxULJREDIBAEHREGHA0DGA8FGAsCEgwEDAoCGQYAEQUADggCDgIACwgCCwQACggBCQYBCQMABwgBBwcBBwYCCAUABgYABwMABwIABwAABAYABAUABAQAAwMABAIAAgEAAQEAAAIAAAEABAAAAwAAAgACAQAAAAAACP8A4SCxAqdHDwcIVhCxofDLFzlaxvRxYaMPIC044EzpIenOmztWgLhYwcKFyRYXOIy4QMIFCQ4mSMiUueKCB0/AgA1Llu0ZM1++evWiNaxQDy1EgrCwgcPKFytJgxDRApUIEBwwYOA40aLFiRcwrmYdmxXHD61kcYjFigJFWbZt48YVwUFEXBMmRFy4IKJv3B9ExHhKFcsXsmRDaSmeJcuVY1eNHctqvOoU5MmTVYn6JErUKFGlRpkaPQpSI1KuWrUylm2aa9fOmClTdqxYMV6wUIXa3UwbrEaNQnkj561bt23Ht2HbxnzbtWvYrjHHFv35NWvYs2uvpt2aNGvPp3P/i4YKzxwfOj4w+IDhAYYPMdL4kVQp1rNw3MKFy1btmf9n1UyDxIA9TCGGBgZUQMSASSGhBSBxIBEEEmq1EEQcgiAxyCB7vHEVCyucwAILJ5BwwQgnoMgQCnRxQEJJNmywgSC36JRMf84MA9RQwVDSAxE4bLWCQhIGCQQQRAAJg1taEfHCk1y9UGELbcHwwxiAVPGDWUBUkZUWcgAiBxBLMilXW3iZgGZdaeZ1wQR1oaCmmlVIpIkpQCWDGC641ELLLIw1htmgkckSKKCukNLZKKGZUkoqpUTKySWrsNIKKrsQ88umv/DCCy60vILKK7mhggopoaDCS3l4NAKLOOIU/5fcdM05B11z1XWnK3bcaUcNeNdww802wmbDyx866CBDDDqAEMMDD3zQQROLPIKJKMjkF041AU7jn2tEQBUEHGvcoIABKiABB5AOBtIHDi3YwMKEUsEhyB2JUMHGiGjKNMIILo7oglo4mMABBxuQEFMFGtAQi07DEKOLMcHsSEswpvQQpEsxBREEDkxdFaRXLJAVZQsvdPkFEiL/8EOdV7m85VgP/YCXnGiqeRfOS/Y1Ql9u8tWXCGr+ECYhmsRSYzLM9GKLLbVEDShmgRIK6KGzuHJKpKWcsnUpjp5S2SmseG0qqqGgvdtul1wSyiWWxN2IJXjgoUPdv5AjjnHTUf9XnXWAW7erNdwWbni32EnHjazCarNMKOj5kMcZOeTwLAYYCLGHI5lc0soz2gQYDWzOPANHHHDAcYeBGgwgwYAeh6tFH3Ig8YUWQHxswxFi3EHIHTe0+RIHKR2sMAkrYBWTwchzMIEGGXyikzHEWIKKLcFkT0uNbPzokkwbtxCkDQyR5EJWcnJ1QpRqkVkWWWPFZaUWXqoZv844y9WzXXnN6ReLdDFBVgKRtJwwAxnCyMXTnlaLqzkwUJCZGqFYQUFVqOJrqujaBSuzilacYm1uMw1wRjjCP5iwbiBIVt2aASu++Y06gYvhdXRFjW5Nw4avmUbiiMUNvnVDG6GjBbL/CqEIP0hhBx9wDwZSAAVDbCIToeiFMqIRDWi85hlvQMIbBCKGOLzhXD3IYhz6EIjUSWhALcidUoJAgz4IQgUkANjBiGcBC/AFBS5JiQlGUBITrKAFJohABTKwCJ0go2nZq1gwdDELZCyiB0iwwRxHhJcRrU9hJmBBC0zigq6szyvrG4EJupIXFLClTPlD09AEKJc27dF/RJOTKN00Ab4QTwRaCUQlakRBW/higbpg4CwWGLUGZs2BUkOUY1iRQbGVzWvQpOAp4Aa3t1kCOCbMZt22aTcVNoIbsOqhcmAoHRkKbnCHy6E0XIMdHiKnG+Pwhjcal4xQKOIPhzgEHXYQ/4P2vEcGdnAEJSwBiV44wzWji4YYkNCHPthLEH3YgAAyIIZ6IWEKDtUCUphihXjhgAYaEAQODrYXkl7AjkRjQV5I0JZOvkQmDpCABthwi2EYIxnCEEYwhpHIRoqiBx8zwUlFCTB/ycSPQ9qkDbyCMhi8wJNdAaT93tczvBAtL3GSkytfKcqcjQBN/2qR0O6IA0GYIhar+IMrhtELXejiFnANZi0WCDWoFbOYDHxaZFzxTApWihXLLBsprgkcSBi2EX/gpmLxQAYQgKBuqAiHOMhRK+WER4a+ooZms1PD13ArhzoEj7CYYxxYwYpY3sjGMCyRTz3ogQfseQADliiDzf8VIjisac00BBKHMnrxCDdAgAJuMIUp3OEORyCjFqTSAhYcaakbqICD9kLdOc5RBJhcwSyHp7CYZmAGqUDGYXKayGAI4xbIuAUbgmADoU4ALz/7179IIKIRjeiPXXnqHlHkSa545UlYSREHvuKV+HIFvl1Nk/zKZILzadWqxYMJHhNhilvEAhKk8KVQ3OrWuuZCgcTM64fpihnHVIavFAQsX70WCsT+gYSJJYOMuSljMjQrhTqAhWQp2xxzPqc709Csaz4L2s8iDjzaWFwPjaM3WH3jG/IURzVOcc882EEK/oQWBjpQgzYMohCQaAUzWtMHdZXxdG+gQQYGkIEpHEH/dW6MRB+sEAggICFcLpCA8zjQBztSt3j2kxNJbhaTo67AAQxTwSaGcZheCEMoibxFMJDhhx6swETvxWpYUXTfP3Yyv0/92SideoJRayWqpEzRzwaclRNo9avoEyBZ5OQCFlRpLKVkkZpwEIlUAOOQzqDYht2qwKjZ4sMjpmsudPHhYEJtMo4RG7Qfs+JVXOIPesimNtGjgznUmNvNekAKj6EfHjMHcNk5Z2ZBm0McvgZY25CVPMmRDr09eRzjgJU3iAGJPNChDjPoAOYawIAHUCADN9gDIhrBCWE8I0JVmR0hphAHByzgCIkocyLkkAgrJAJCgPiCCyZQgQpEYAJy/7CCSoQKkxGQxQV4gTldSKKwFmhgBTPowSIOg0CdlrcXwWDGJGiwAg5EwAFnSlOtNUk+k6wPSiKYZQtgEKUjIQEGaRyDFbAOBK079QUHxp+CE/yvlZ5vSSuXNZO04IlYDIMZzPAJW4VC913Y/e67EAre7Z4LPi1bMiZWTWpa4ZhWPLsRM27VCAtxwsWi0LF4iIZk01HZbWjjnNnIBuGskXnNa94a2sh86LHDH8NlA4jCkqc3TMucYb0z3sTKhjEuQYYy2N4J7XnAAAbQAQ8IYRCOsAQnQmGVgZwudfZSwQJKAIcjVIQQhAjEGHAQoaLXMroTwAEhVOIig00VBjDPJP9WTbA+kmxgBTboAR9+jQzzljeRzEiFpZ0XganDDwXN9WgnNYkyHLwgji63RygDFjAAJF0xFmohJqM0Bl9Ada70MwEkJ1e1An4UR6XEJmQhB6DwMOLFDMlgDHRXd3s3gnzHJ6CSC1HTGB5EeNTmGLdgC65QCMmiAzEgY3PgeIvlWCDQCNWweukgHT2GbptHepm3eafXeZkXIO7GHaeneqrnesyhDaQlK6H3DK7wBz6ABmTgBOohWw2AAR5QA3agCJDACVYAJg1FO2RECHDgABEQO2T0FAMDBCYwAXa4FxYwARYQCC6wAXN0ATeTFSrlR3ukMObjAhyAflJAB6YgXub/5XOPeFPAYAaXNgERcD5BghWfln8g8kdPh3XrYwKh1gIikF8kICVUF0pfwRVWEAdBgBcz4S9ylEnDs10rNwJxpDClFhNxAAq+dkjMIGwhqAt8h2zIBiqKkYzKmBomtgotGBlP4wqNwG0x4APWeI0yZo3ZWGPiBgKokA3gRA7PcXk/lh3udkOHk46vQUXsiI7VcHqiNU/UYXlAJIWysg2gVw3JwAmMRQZNwAPtkQIU8AAdEANOUAiLoBZJEjtIEAdaIAYboAAlkCRfYBU2cGcVYId1ZIccGQQRNTyvNBa1RhIoMCRLkYlDYgNToAaY4Ig5BYnCgFPMUAgzUAKWuEki/xlVJ2GSoFRgKEJgUwcWLzBKKfMCfZEi2IWLUPIiheYvLsJfe3RLQ9MWHGBHB7NdfaAJo+B2jDYMw8BhxtgnyjiWZKkYtYAZXkMo0KgLq9AIc0CDIHCN2ihjM1iXOtCNvHB6kyWE1kANQ9YtVdQMzbAMzQAN0CCYiImYhDkbs0GYzvCYh2mY36EN1BF6nacNxXFuoTcN2aAL0+gEdqAGMxADMZBE77EDeZAWIBMvTGEDDuAAm6QWNgAEVmABJ/cmHFlLFaACiXADJYF+LFUmgthcMEA+NuAxQVAC6DcFbOAHv/aIwuCVxEAMzCAMzLAJKlACJsdJ+2dfTIEVS/IVT//FXS/xAnIQCHLwVEfyJP9HAl5xiv83AgPYAhQoEwhTPMhTn90Xi29iAcZTX4CgCYOhNF4JFL4QVxzmbHS1oLbAYVDjbLVAeFIjC1GjGG9FCoUwBzIAAh9QOTuwA3JJBtZol9CiA8pQDdoQDuI4Q0LmWd1ymNEwmMqAmLMhG7LBmHqiJ8oAd8yQmM4ADdEgDdbBLZc5LNegWb+iH8wQCoyVBnbABssiAx9AAQWJPihAIiAyL0AgSQlQAQTTAkRAAm5ohxFQppZYch7QUDcABCWgUjsDA/ZVnOSTiefHAkewBmUQC+03ncQgndRpDMzgCjMgI5fYFZ2oSSUBfncxgCn/Ql+neIpa8RVZ8SSTegJ9URcnUKlN+RJ7MRNDcmkJs38mclIqgUkxMQaJkAiS4AmlUCMHClcI+qqwOqu3YKAGGgy9AFcHmhpyNVd+sj26EAp/oKEf0KE58KEfKpfXmCwgAC14cFDZMBy+Ig3U+hrrFJjLQBvHsK3HQD3G8K186q3E8K3kagzcegzKQJjQ8CtDCB47dKTXoDf7gQvYlgd5wAdnQJrsQQFoggIAwxUucCQmsQALoEmZVBMT8JplenKWSHIbQAOEcAM2oAGGaGv2o0nnwxQGQT4VkIgq2QQtKZ1eGTHUqSfDoAYyIgGGSiIiElX+GksocDKSaqmZ+nXs/wl26vMvfAEwfPESuDgTc0SBQwKLfggizbUB/ZkScrQBF9IHqkoJraojBlqrvlAxtnq1QPF+ilQxs9AKCPo0ffJLlqAHeBADAhcDMiADHlqXHzqDzfoAlvAM0QCO4iBk1NqO0sCOh5mt3TqdjxaCIYirLzm4jiYMvyAM6LoMhHlDffkr11CPoMcc5BAP5KCkl1A3dfAGazADxfoBeCFhmXQCtZY7OBABCFABgBhIJ6ewZmqb/lkCHiAIllYCLZCI6JMVGUs+yMmxFXB+TMAE62dTxjCy0ykb1rkIKaABKruySjW0XZUVUcUVNpCKT0dfabSKuChHJ0A8dUFfoXg8w/9TaidwaSRQAn5YlTBBPBy5F6hbAfNyBHewCItACZhwCZmQCZvACZnACZzwCZ1jv/wbwALcv7uhNqFgGUGRoE/jC7MACXqQBzlQrGhbOZWTLMi6A8kSA83qjY+ZDfrBjiBsRXlLRXvrgX77C4CbwkD3fnSXU79ADEyTrtBQDUdKDdoAesKiZPFAuZW7LbVAtnRwXFJgtm2CX/EyIc7lAgQ7UlWJmxMAARDAsCRnARtgAUAQCAezSWliX/elVLMZJDExIjTABGoQC+VarrLRC8iQCRggARXQAjJxqOQzJDIRMuhnA0v3AhhrA081gE91SWHlvU/XXyVQvgjjniRwAyv/QAOwe2klUCIcUAIIIyMyUkcbUAJi0AeDkAjyawiFwAd+gAiDYAiLcAiGYAiijMqIIL+IgAinzMqMYK+FwAiMAAmsULXZo1O2eguQkFjnEQMUfMHKOoMaDAK70AwH9Y7WOsKjU63T4AyICXfe+mh/+5LlehjkmqPa/K3KUDrOgKKL84RO6IT6oR/P0GJ/UAd1MAUpAKfk9504gJxWkJwTgAAukpGWCAFPvLAnVwFUnDCB0ALKCXMVOyIkY9AOFhNDQlxS0AnIcMbfasLDoAoYQAEVUMgkUgLKKS8rMBINhnWtOT4s4CIisj7+9S/rY11RJ19xJAKUfMmUfAIloAIq/8DIHqABMqLRByMjGlBy+EzFN3AHfUAIiHAIfjAIfnDUSX0IG7IhSY3UTY3USe0He+AHZ0AH2VYIjiALXmledKerrnBPejAHSLQDOaC2IJqsy8qsj3UMhDk61QDCIDwNeTsNMRrNskE9PicUOiUMEF2u2/ytEcM0zkBF1cANqDdPiO0NSYbYixMO3jCvbrkDPFADh0oRCrkgVrBUJIAADmB0CwvF+myJJ2fJ0TUGSIDRM+FHBk1fQlsyKJCfK9ADa9ADfhAMf53XVSsDFCAB+RkTmI1+mYgkasQQFIGIhVy+uLg+Gs0VGp3T5vvSVXy+LyEjMxHPkVzFcCLJL52HJP/nzxugAmNECIIwCKpzXOh9B3DmB3ewB3twXO793u+tB3uQBzygBljNB48wC7n8tx0WDKdwQmXQBMCcthR8rMN8Y5AgG81g2Ib54EBKwkAKzYormLORDMRAXiGoU0JxuDeVDMoA4iF+DCe8KcQwo4IZDd3xuJdlHcwxT9lwDI2gAz4gAwIzPjiQJFZAIZvEARbHzxEg2mRKcnvR0+4bB0flqQaNx81FEvZ3sLvzBkfQBLIwvOP6gYAa4rmADH+AARXQshRBPksBJDCXPCwQzyxQyOQTyTJh0ikS3eb7yF6h0XQuI3OUvdb1IixAxdk907CrAR5w0yX33RVgA3DwBlv/BAe9c97ojXwe8QZ1oAZrwAZssAaIzgZ24G88IAVNcAZ1QAk19Ygo3Fa2cAuiUDdl4ANOkLaszuoYTOPg1iyk4IGPGQ3VkJgQDuGCSZgWfuHG8MJ/62gZfsbEcAza3Ld8muEnrpgq3pfYgaTUUMOKI0/aAA2okCydODCZGC7iM3J6SLBALtpS7M8+LV02YMgvwklq4TEgYxJBshTiwzsb8Ql7ms1whxjD8Am9N5sPMQZA0hSojQMjggMUcRV43EkDRiKeFOe0i7Nurj50/pR47uYlR8UeoAIekAIpEOiArgEenwEgvwEecJFJESGBsUVZ5CDIRy6TbiBrsAaSDvNs/6C5M8ADPJAGZ4AJtzC8w2C4dPdWlDAHenAGqn7WpDnBFTyDaavBOiBF3Vw605CYPvqYFJ6uimnh42oMOeVo3kquEQPRfisM45rhiEuYFc6ZmvdjzxEdy/GEoUcMjdAmZx4kC1Fr9GeJCcC6+xzFuXmmEiABJRAE9umexqmQQXAkiE8hVzEhYiAGTMAI0vmtegJ3yiAMuiALMaAB5BMuIUEwBk8SBG+chx8imwRKzK3RLyAVYEfnj3z6JZC9LI0ykTz7l5y8gZ4B0JP7Hu/xM30CTbfZXnEESHAERyAVdxbPBtEDN3ADyd/8xJ/xM8Dpm2AYXvmSbfVWitAEdeAEZ/+99Edv4MnC6sWMByKOzM/gDLwu9VKfrSiuuIqb18T+aDv14TqqJ9RD9leOU37dzcywDN+MhABhzVo2bdsMkhMnLtzCbMRIsHAREQcQiitgWIhwIUKECQsWONg4geMEkiVFSpBQoYKNFS1X2IAJcyJFIhSB1KQYhAgSIlPUxBomzJixZMmYMVNmjJYvOhpgtrAxE4hMFydYnDiBw8UKHDZMsLDRgkUJsmXJtmhB9oWNsidKbNhQYkQJDnU5xC2RsgSNDRroWuirUuWEChZIWrjAgQWJDRZKVNDQ18Pkshs8vL3swXIJzWVTqMBAIcPnT7eQ+UKtS5etWbJSnYmRI8X/BwwdPsuIkVvGDhm9cccAAaIRs2TKmDl79uzocubNlSlz1qzZ0enEix4tmgyZsWHdhxJNNrT7sGDdkSELdgu1L/BEjSNNdqzY/GLNlh0j1ktWLUgkVrBgYSKtcMBBo5I2cgABkDaCYALDQiIJJQn6WiGImKICoquoJgqiq4gy7EqnII6YYRTyiDHmPGeIU2oYRlJYIaIW/mvBhakyrBGrqFwA8D8STiDBLLNOaAErrNpyy6y7NhCsgr400EyFyzh4qzALrrzAsMMsIIExIvuyzIPI+iJrAw4iE1MDv5iMqy8VHmhgtBpGSSUVUTi5xBI9L9kEkxxUiME2DDKoAdAY/3zL4VDfgAOBFKSgS045555TpqjviDrGGBSTIUYYYXYBlRZRaWmlFVROISVVUkJhtdVQLuFET0sgaaRWW22FJFdZ9WQVFl9RQaVWUVZ4CAciCIzIhAuWvcAkBUdysFnCSFIJrstWuOGII96wosOYIJKKJiI6xCGIDGdYZLvrmDlvqF58SaWHa0uYsQUCo8LXBv9csIGFr6rqkiwjkzSyhRdeKLKEI+Fya7I0J4NSyhQ+uyEIzTQ4YYOMnbTgLg6KpEGFzyaeTGIVSpiBLA9GVqEGD1S44WQVRKahBhlmmIEJSe6oAYMHGAD6AQxGXnnmmSeeOIYUDsWgaQw++CA4SP8syVNPWm+9VddZp961a15ZVRVYsYH1FRZceEH7F7WLOabtY5RZphlooolmGoG0wZsbbrzxRhxvyAFcnGNCeYWWlggEEQcRTCChLsMuMDOCBExykNpqzSwL2yPE4IkIIvp9yYaI+JVKw5lseCOWYMo7bxhgfOnFlltisWMGlzggAaoMRa9RdBZa2uqrfgkuEqviDT64+CThKmtmDzLI4PnoKRg0AygpwF6D0VLA3no2RYYyBe2t1140ByhwIP0GFBhgAAUUYKCBBd5//4D3G/h5gfYD4L//AAYwgP3i9wACYg97g+rAB6jXNKiBQAdYawTVWkUKVLzCbL8gBjGOUZT/50jHGR+s2zREOI1qlLCE2UBhCgmCQrzljRva0FsM97Y3vvHtGzXsW0L8lg7ARYNwtCBF7kD0uRbgjgNZctAI6rKBBDigJIixHGDMRAITWAUtSAhCD24AE7Dg7l8xudcLAISWFagAE6coxSlYEYtSlCJVojhFLCYxsxKwZAUcMAEQsIiEfJUALMSKCkSOhzC3HOkEhHQLXLQkgQhkwIAUIGADJLm+A1TSkgfY3wD8979NbhIAnwRlKEU5ylH6TwCdNOUAELCACHTANjWAJSx58AHdHEoHlnjGB3WZHLqFkIQmBGYwBcLCFhYTb9e4RgsNskxmMpMb2yhIDHE4zWki/yQbr0BFLU7BCRbYKyxAYFxdssSsu3QsAqy8gAiWZRgrbQByuAuYwlpwgxsAyJ6M80/v0IKWbtZoBSUYRCY48YlPiKISmLhEQjkxi1HMIGYqoMFbVkARLv6OJWQhVuPgwqQKiGQjH43AlTzqgAQQ4JQBAED/SLlSlqa0fQM4AAIUIL/54Q9O2CsgThfYAQS6MjQEVIAB2lcAAZj0pKgMgAAGUIBVOqADLZPBzGQAtUPFQAc6cEUum/FBD24VhCGk2wiFKRBrILOszVxmQdDazG4sU4bP3AYNqVlDboRDIbsgRS9YEasuNa4CHCgM5TwK0iaOBImISUxi7LIkNTFJAv+E6ShJFLukK1X2ShGQQA0OoQhIUGISiEDEIhQx2k9Qggc9OIIWYfKQffYLLHaMCY8AFKTGXKm2GiPYBiKQPt4uyLcOQEkEIGnA0ITGkdBzJAVsAzGIpcADNHgZRJ/rvBREr2hK68DLJkODGVCgkgYgqkmJKgDylveo5n2pAkTzmZm58gO78YEPkKFVDzojGnKDRn6jod9e+nKEIiyhNahBVmQikxoHHjCCC4yNazAYGw5upt66MeEJz9UbCyFGKHTBilc5AgEJSAACCjBipiLAxCf+sAM8AhJpLctBWFrsEjdgAPKOeJUfCelDTsCBjilSSxNQcQcOcQhGPOIRfhj/xGYZAQlV3CITUqDBQ4nAggpcoAQkwMFbNtCSt3ysiBvdwBPDzBHAXKlMUtyoltVUAeRaz7rOLZ/2VqY9KEGXLHBWkwqsR0/mQslhSJNYyGhAA+8C0ACHLgABEk0Ao5q3k0r93wEa8FQZ9CwDh/KBDv5wHGfkN78fnFtYR9hLAAfThGRFNVmzUdYCt9rVBUarXC3Mt3BwYxmkoIUuSMEJSjAipCJJ325ByluONCsjUJyAiwXTsSWBWbcS0IAFCtNRGFO2SVW+QPoyoGQjDyLJSj4FMm5xCBr0QEqPMYEJrjwWv/AlMlpadmQTIwIeX+mIDuIAvRNrW8GQhKNuzoAE/yjAyI2kRE0RqFZd0MIwIzmpBCdTmZrE5KSIXYYsFXCAUEU8AEY32qimRCr/YNoACqSgBraBrw5C8QwR0k0a//3lqVU48xS2UG82j2Exb/5CYxpTb96Y4VsXwje5hqMaqKBFME7xCVUYQg8Kk0CwOYBZlBCGkSSB1oEqRxjEINbZbApzYA8z2cb0W7LpkwAbhqyII/tByYwIBTKA8Qk1iA8uHFhBWn73mBKoSU2AkXFjJLusIyJmBCIgieOwPhIJgXS3EvotsYPtAJV0jF5lh0sF3gIlJ0kgA06CDEcf8+6Mj3ipRTVv6kPeSZiqVwW2SUEO4iuLamTDhLavfe1nrv8NFRaz5gSBoQxr/da6LsT4x19I8fVmfBn+XhvV4H3tl/GKYcgiFKMwxRnyoIGqe6SwBd+tAyAQbMeXv+CPvbZgCA7SJ/74QCHBrBoo8YiDPmIR9ncEJC4xDGbQzgNT3y0bCAIoUZNp6agNQIu6eLHG2IDGSaevuIqBeQs0YzYGlDEJqCPMoAHxuRxp07x/ujIcaAESEAEGZJIda5yqKIEbEJ/oqa7q6gANiAAFOLESQ7QRU7RES73y4p8dVDQDUADgWpoi0AH5orkjFD7i05sjPMISipQPOornCI9OEYZeyIVcwAVaeAVTaQVVYRU8yRNayRX9C4VTmAVSEAVWgAT/MmCEDOgtEFsQBIGABjE/jmiSCUCJKxmTjbo2PBQ72wqzkhC8ysEsKaiESsiETTCEPTAySqCarBqGR5gBFgAyB2ABJIgyD1AJxzETDvi/euuxjmmWZVmcfgq8yHiMaZGQCmCkCWEShDOg4JqADTA45sGjuoiAKmmMEzABDsgYIrkBNZEAD3ClDMCA51ExGkQxBDg08CIxRtvBaDQvRVslCUiBHdA0ZFiR5bAU7iAPYQgG2ImdWpAFVyiVU/HCVgFDWRnDXMGaQoDHeIzHP6DHeoTHesTHP9CDPNCDPygERaAEThiFWGCFVFiFT3CEP2ADN+SIBWgiCOAICKGWyloW/47qusrDnH8Cwc0LjGqpSHhikllsNozArBmgv0zohEG4gzWYBEdwhEs4haMohRnQAGDbi8uIDLxTCa5YgcxjRYTrqI5iFsXqizOBDDbjGFb8yTiMDJVAuIKrAGFDCejJnvHxgFzsKHHigAT4gUhIhCB4ATZxgA3IgAjQAO5RsflZRhQjMdMbAGmEywJwH0JBAzyAhNHCS3hsBH+Ux7yMR7wETLxEBEUwBEPwtkHwAz/gAz5ITMVczD3IgzyoAzZAgzKAgiYoAzIgAx/IgRzojc78DajpAGN0GtHoACFwg0qIhVRYBMQ0hTdAiTmcw3Vyv3V6JzMZyo+kEpfgsn8yk/+NWqK6oKJePKIuubuoPJ8UcIQ+yYQoGAQqeIRJyARLCIVkeAZg0APu262VqZ4xYcU66owygQwN+CsmQZOygBiqFA01+TzyJDi0W7/w8y0CKqAHEI3jooCPmADEuwAISIAQAIVYAAVNiIRI0IQxAIyKy0+PmB8FaNC1FDESax+43EGicp8U4IN59APIzAM7mAM0QIM2KIMycIImaAIeKAIhUFFY6g2jORqkcS6HIcYMcKXRLC5jPKDQyFEdPSCcok84samc2h47wIRBSANDQAZRcIKrm02PIrhky80oJafM4TKzABNr2QyHwYuWuBZN9LwOQIROENPa6QNMqISADAX/X3gGZKAEqnwAKEmg7PKzyXAulIkozriW3/mzyTBGGiVN91oZGE0B2IuBGciNkKEnWTJRHrBMMIiCLnCDSHWDO+AWQPgB2QQEUNDUAtUEUEiFAQUEQoiEPkBOB6ApB/UI+llGZ1y0jmu0aDSp/4Efp/lRIJ2kH+2t3iKgXOUtCpBP9YmkSZIf+WEA+jHW90EAS1KAS2LWZq0k+GkAGbADR1jTT4iBx9iIC5hKsrw2PhSMTvREzLA4o5kMbm0sMEkTLFWZh8uL49oDlPwEM9UEScCETMCEUHAFWfiEQoiq5+mBHuCBE/3Xf5WCglUDNShYNoCDN4ADOIiDPoCDO9iD/4lVzMY8zMN0u0MwhMT0tsaUWIq9g4i1gzqggw+1zCIwAhUVghrggZk5gcODgB8IgR+oghAIgXRqkBDIVFAoUFBAAlaMOlOlKQb1PgUIMRNjVVeFRrjsH/eZpO8Cr5eS2qmd0KNavatFKqqdWmalH6AZoAIiufdCA0bIhFswhl4IBR3gHpSwSudyJYdxUaOJMnqKskG7gX89AiaYgikQgzVYAzZ4gzvoA0oN3DcIXMHtgz4YBMX1todFskcgqE2oP0zABEqAlVkYhtkRBUxIhEGQBPtDhCETBMTc0Ik13Tug1IUVAzFgAiZIgpW1md7IDaWZGFdyW9J8JAOq1R8VVv8Vk6T4kR/xgwCdDYE5BDH/TADZjARQ+IFACIQWIM+Bs9X0Idr5cUi2bNWOo1CRW4AUwAAFQKmWEl9RQiWqddZnhR+vBd5bJSCncd/3TSCokd8izINGwLVWWAWDsr9D+FwjMzJJkIRKAOBDFGAABmD/NbJFUOBFAK3QamAGHoTQsj8FbuBDQDKPRd0eEIMpeAM+wASCwoRJqFyEyoRLYI1L0IMykJLosY0adSQeHS5I4l36FNbfteEbFlavfZ9iRdb6sZ9lPYAbHDGh4jgCSN4QqAKZBbHjTd45lANQSIQqSAQSCEtHkoDppd7qvV6kfUZXlUb/WYAeWNgMCCX+SSn/1tNamDrfNd5h9WWAWm2a+J1dGShCzZyDOcADPOhHesTLJcsVWBGFVDmFQT4FUaCEQ+ADOlADM5CCJ9CikHnRyYhBX30AB6jkBljfGtbkSeJhIHZW+AliBHjjQQjhSaAESmhHS2CEOaANCpAfVbUkZkzjqb3a8bXlW/6kADjiOSxeECMAmbVZQBDQH9CEH8CBKpZhTGYAUyXa91HLE3NG7aXQ8gKgOKmBI6AABbDP7ZEB9f2ZN35joWGg4AgOq7oqHSADPM5jfqTHf8SVduSaWTlly0UoheKEe4YVfL5nTpigQFYVUjgFVAiFu1SEP2iCGPgAF4YSaxmfWLzkBTCA/wAwADfe5BumH2YNIGUtuWWdqQbIg0wQ4XmWlUwggwcAYk1CJVxW6ZVuKQJIqpc6gAD4sOGFACO2Wdm86R+IhViIhEwFBCTAAfH5qUniLS1+UKRFtKWd5pfO6AFggBpYhIL6BFNghPwTQ0uoFXjW6q2G511JZa+ZFbD2moSiGoVylX9WFT0g2TpIAx6oLhyFnqAUOBmm4acdOQZYgPjBa6CBZSLeH08646Zt2gOQAUrYhH3e50/ghBzAJE1CaayFbP9x7E2a5b9u2r82Xx+uJAaQTeM9Xl7+TwioggLt2UiIgyAQmeQCUt6SpOo1VhQDL2mmUKkVKkmLgk4whVRQhf+EmpqECsOx/mqr6Wqs3upG4Op43pVLcJUJoiCygQW04YW1mQ/lGtSmcWVJ6i2P2OSv3V26ttUadmOg0eT6hJPaiIEdoANKKI3zYG+5o4QdCBSh4V1lDu/6tu+gad84pipbKkJ1jsx25iyugZWCSqNTcIVayIVaUHBX4OkmRt4lDu0QKKkmFj8g0IIjCJnn8dFcpam0TFVlrEGl3cEeJK+X+h+n5oFNMAVSoM6EWu4Xh/FQWJWwEZuy8RXohu5foA+3OYa4wa/8kgYEo4YGM4huoKFwsKFv0CFxSGiSQRo6xZkoVwGcKTeCNYNFPlg1WAMpMAMzKAMpcAIwl4ImeAL/HjBzM+cNQ1Xzm5nd3FgaGcCA2TXRQnBEUbBzOyeFS2CEPMjjPscDxiwERKjqzjqoTSioUWijU1CFVXAFV5iFWriFSEeN1RkP82hvZMiOdWmO5XgO5rCP+4KGoziPSEgAAbhp40X1/ywp7SWAF4iDKRCCDdTw8/vVonbtoxUxL55mzHYfGcAEXwiGtWmbZSB2YsevIIeGA3uwbaiwHEqIwBGHcTAHc0iHao+Ha792eIgHbd92ePB2eHgHb7eHceeHcn8He/h2cP92e3iHdgd3OiCDRY2lM9+BHIjyHcD3eu/MHCjzJmhkEz0DJyCDET2DOaiDOlhMP/jHqnaEU0bE/0QU00449FGg+FIQhU8oBd1OhVhYhTRKlTRahVNQD0lfD2CodPZuDl1S+ZVf+eRADpaH+Zjfr2iQhpebhgPzhmuQhhVBBjkgLwKYWZy+6SV+VQEogBaAg9btgRlwroATLsjj1Sz2PlxPtFYd8dTL5daLgluwK3EgB2y/9n3A9n0g+7I3e7Lnh31I+7X3h7Z3+7eH+7jXh7mn+7rXh3/4h7i3h3vA+77/h378y9Ga50wQKIKa+FLI7VRgBVVYo53eaVmAfMifhVmQHdkheV+I9MzX/M2PdFvI11iQhcxnhUaXhdYoR/VQjV7QhV7ohUofhu/Q9KOI+Q96hv7qL7Eytf8AEwhkMqa4kiYkR4iFYIYqWPX/vNThnYBehkaTOmMBQIAp2IM1qAMzEAKmJ082S67gAgleJdolZkullsaUIq8AUgAZ6AVuAJyxV/uzL/f2d39+8Af4l/+4h/v3t3+59wd9yH+8t/v+p/taAAhXrmQNnDXrFkKEuhIyTOjrIUKIDHXpsmXxYkWLtS5y5Fjro61WrmoNrCXLVi1atGDBovVx1y5cvGDy4vXrlzBixI7xVKZsWbOgzaBBiyZt2jRq1qxl06aNG9RwUqWKq0ruKtasWrdyFYcMRwICBBKECAEBQoK0YsUKaCsAgIAABRZMubPnzhsmN2ik8KDhb4bAFCj/SIhg2AHixA4WMF6QAMFjBAbYuo0bIEBbAJcFFCiAgIEOVNXIpYsXbx+/1Pz2sVbtOrW/2LJn09Yn+zVu2rX18e7t+zeq4MKHB29l/Lhx4sqXMyf+qtXzV69gTWe5kiUumTZ/NVvmfdmxZcqgSaNmntq1a9y8TQ0njpzpeOlKx5c/v378+fr1c93anls22VTzjDPMJGPMMMHYYoohDlCWwFlrSThhAZcVYIADYgyCyBtiHHGDCn0FlgEGhEWAmASKNcBAY4wpoAACMcZoQAEEVNbWZZu5RUBnBhzAQCPOkHZaaqzFt08778DzTjvtzDOPO/MwiQ467LRDz5PuyCOP/5bzbLkOO+ucMyaVZVLZzplNXrnllk9++aSX89BDD3Es2XnnndlpV9NNNxXzJ6A8hfedd0ERZZQ0SzHlFKNQQeUNpOxVJU588MRDjnuk7bcpffWlg1V+V4kTDqRQXTNNNNB0B96fvLAUXCixWmJJI7U28gceuZJBhg86+BpDBxg8AOMABTy2VlhrCTAhjxdihoACGdyxyCJ+4HVEDzTEkAK3HQhG2GApPvBAAw0g1uKLL8rYmY1u5YjZjs0OcEADehgjDn2s6Xtaku/4C+eTU5bZjjsFa8kml+6sow6V55j58MMFI4wwwHLSQxTG512DzcbbeNwNyN58M/Kk45hsDv/KKKPT5MBqqunvfObsZyl+pqWjJDw5xwMPaqtdGg43okoFoICodqfMMcXctItKrwRHSqyhcHLJrLb+gWuuuvaqQwwx+AoC2CDE8EHXMsjQNbBjd/AAAwe4rYABAzjWLrPNdtaZjMsi0EANizwiCSKD9PHGFEfUMAMNNITo14jfUjDuiYg10OIC6kpGY4046lgZj5f9GFo25IhjTs+r7bOyv3NiKY+c7qCZJsEGb2lwweusk+bADZspMcXzrENxPfWY6bLDsLvMcpMG27687V82z3zz8tDjDjvVszNn8PXQYz072s9pTz/B+3MPP+n8gkool0Q9tSWQuO++rfEXMv///IrYX4gh+Bfyx/xX6+EHH/SgBzzMgQxO4IEQeCCDHOSABzlIQYhqAEEZcCsFj3NA2wagwQHE7UXLspFn7hajCxnAADKKkQAMoIAGvMETktDEIgLXhzusgQk9OIIQ9rI4D/BQA44rzGEcUK5yuQhGMqJRu27UFgIMIAAa/BEIGkEMaYjsG/BYDT/OsQ6DqU51rnudypJXO9op7HYrO97rWIaOg01MHsxj3ZzGdw970DF7dswe9rrovS7O6Xe9s131CoYlLzUPTupQByDlwQ5Fcm977PCHPeAhjUaQwVd4+IMeMHk1/vVvk578JP4GIcpR4u8PAAygAPOgSjuggQth/zjDGZ6gFxoc4UM9SMIBMcCAE0pGRgtwwAng1hnOrIuXJ1TAAgqATAogIhaY6MQjHrGIQVjrDWtggxim0INszUAF3uwLDxs3mMGMa1xDZMCLKjejzClxWTma1wEeoAMywKIa3BBHzuzhx0DOyV/+UpOZ5qOmcyDyYAobU/EalsbXGVR2bOJi8P4h0YlStKL6oEc97JFROmr0jnTEB0i1B6fgdRSj9cBHPeLkJdY9SXv5qEc+XprRfuDjHvXwx6dg4YNKxmAOPv2pT/nAB1Xq4S5sqEMafJqHouZhD05VJVRTSYepUrWAZEBgDWpQhiccAQg4+AEOXGCDEOnyABo05v/dIBABDuLNmMdMF2Pm0gAMUAIYo/hEJSYhzcDd5Q54WcMUbJi4xHUTnB7wFonGOU5zTq4xkWFXOzXzTrcBgAF/4IU14AMPd8yJev1iUr/UiI79JGlMW5ydOxBqpoSaKUxsbBPrIEoP3dA2Nr35hz5wq9vc8jY2Fa0obW0jXH8Mt7i2UQ1x/bGPeGgDEng4gwKBSoY5nKEMdagDG85gQxV4wAIa8EAKZtBAIQihCU7YFXrLYAY1SGGbO8jBDt57tsVRIAJniVBcJAsAyVrmXQEgAATEYkLPuDVdyGQMYhCwgAd0YBPIsOsmMJFXaR5ilDPESzYDiy0dVpCHiB2RBCT/QM4HRM5F60xiZvbrXxU/ABLHCBpp/HUm0DZJP2d8mYzRsUWJuWN4r0MHmYBcpd+5iaVZEmQca6ub39z2txPl7W5xq+Qp0wa5tpFPMf5ghzeoIAbo/bIPfNAEHsSAAgwwQFxSeAAFMOABFOgA2WTAtRicbVsV/ACcP4DnEi0AAZbZL6BzpGLNALrQAEiAg5pFI8hEJgEGbkxiFtAACsTgE8xghio4sYlMYEIS0qQWIgQhyhm+4a/ZZIIQsqq4DvfQhxkYZ2EirU4E1CiJhr71AKKIimZkihwou1kaY7aygn32HVRanpZ63DKIDYzIXiojH4OHJdXdcY+DnEdMsx3T/+DNw47d/nbwXuolagcvtzatxz3OXe3gpfse/ui2Py6FikY8YhB7sMP+PDm//OlBBgwIgGbMOq82d0AGD0gBD6QwVQACsK9+tYMf9lAHD1WAMWk5C4TKghZar8XP8NrRxt1aYLiayzMN+IClnwEMSFCi5TFcxB0QcYgKWwsvbyCcDXtwOBq0WgOF0UAFKgBExJCLiEY0YgE0l6MbdeZHFJABHhpBCmJk4z2mQc1tlrsPfOgjo+Obk8sUVrCHAbRJoPXXjo+8Y+xlD058VF3FWEcxuY/bYm6nth7lNA/e4AOjfteeTQN/Unz4A6Vyskc8oEGrCtvhkvnmZCEC5wcPeP9OATu4hC+Y8QxmuMIRFMhAD1LABmud0ql9bapTxeABxzgGAmV5fQiSlfQP2ogyYkFLWkaezgMj2AERWPMDZCAKZmTDGaK4BCX0ughDHMIRMZw5NWsOBzawgQo2ZELivKmCv5SgBBsAegUUO65zNQZGk2mLBpXIxCf+aEUg+EMrnmH105QuNa1zR/bs4TLbEVu0Qr6x2fFflBwZuQVPG7GJSsUdAq5UlGAPlBTM3QHMO0jJnOTDRdmdHuWfPdSUSc0HLDSCIhSCH+SB40FeIQwCtdwBDVDAYlAAM0zFqIRDNsQAAwhBD5TaHQxCAKGSHthBHegBHdiBGmhAYy3GWVz/AMYhAAgxEe0N07JACO7FiAI4Gu9Rjrn4ngRkwApRgA+UAjJUQzbcgihwGiV8ml45H7VUmChF3F24gRta3zb1gDfZQAsozuJ817ekiKyZX2cMgBJtUAmVEAK8DQbMQSgkQzgMSTzwgz/gFiLpGJRcDzsYTMv8mGodj79wEdsVYPAkG5d8Ij18YrLhn7V1osRM2/S4juvQwzvQA8FcyTvUQyzKgwWmlN5JGx7Rwxx1W0Z9ijVAAv0sVR5wkh+MUjHWmwaQ3y0wQyvowCuEwzOoAgU0gATEgSb0QR8MQiqlUh3QAR9MFRvcwAacyARAwAJgnFowkVwwkVhA1hOiY7ok/0CLKEZiRICIVUAGLFghnsIwPEM2cJ7U5BUlOAIm6FU0fRqojdIe+IEhIIIh3AEbvEEtTUHhfIgdLk4H+FCIxdpi9Nm6rJ8fwsvdDNiFAJ8PNAIqKEMiXlFsjAM4fMM4lMMa2UMgKdvKMBsAmt0EWowdsR0eveIqtqJQqiLBXFuR9Q7CeKJS8mQo3pQ9dBFH5UzOvIM98MO0nYPo9AL/6CAd+EEdFOMoidIeDIIgHMFihMWFTCMAyAAkfMCPKEAJaEIseIIfIEJR+dXD0YFT+ZUVvMAFTEA5niVkrEUItePdtEsBOAASll/vKYZhhNhgZIAGbIAHTFoH6MEqBAPxZf8DMpyCKHRCQVICJkjYJJTmQT4CGjokImzCKIzCJPiBH7wBG/jV9ImBFGBLD+hQiPyFDxEG+TnGjGxQE5YkIKZLAxwACFjCL1iDOJjMpIyOP9Wk7RhP2bVMJpqUtPmkHVVJlQDlOxClKr6W7ajDAfoRmyzPnMAJwtADSKGiHcGDLPqLVT5JOZBDNljC/wzCdeUBHYSlMfpVCSCTElaIZQjcACCABUQCKKRCKkSCIOAlXtoBxA3CHcBBHBDBCYgACnAABDiAPPpZjSTABBBAMc0eiULAYkraFSKGYdhj0H2eZHpACXiTA2RAChjCKvhCMvhjNQQDKXxmJlBCJnDaaOb/VWkeaTQ5wiOYAkKYQgxR03/+FTYVTraEyG6+mh6eCx/6YRNqkBNpkIApgGYMgGXxAjRcQ6/JDDzQ5CSWEZX4E0ABoD995yYWzLrVwyEd0o65kdht0Y7VzniSpzwI6qCqA+0IYHo+1MHAVD0YmdtZDD3YQz4oEjqQQzHggem5gR3QQQ7Cpn+awiOUQJ+ZEMfRWgktCwyAgqqCQiykAiHEAYTegYQK1ZbBgRYAAQr8AAxwaJ8dJgIEGC8lHQdl3FkIkbk8pgTg41/4hYx6Ew3cwA1kYQ04Aiv0gjE4gz8+wy2Uwl1lQid0wiZsGpEWaSUYKSbIwjAgwy1Uwqeh4cwZ/wI1YWOFEk5u1sCqecCrmUhHPgYSbZAfDkChvUugkSkekEIzoKlVmMM7VM/s3A4aVeKctuImamdH1QMZtUmeHpLYASoi8V+ebomeMs9rHeCWGKCRvd090MOksoM5hEMokEFTSWg32oHgZCOUHgIwIAMoEEEELACNpIU8LsAEAAKrruqqRgKsxqpd7OUbaIEVwAAOAMEJnAthtuMJHYsJZZxZnMjnBd1kUia3aN+z3sANHQFl9kAluMItGIPmgSEzyEIpiMIn3NW3fmuE2W24jmYn3AIyMMMwdEIZPsIkeFo0LYIiHEKoCYK84hyqzUBfIBYGcKRj9GH6pditBZoTff/OJRRDNSSir1VJsrHDTQ6MweBYJlZbHZFUHdED8+hpGTEPTrYp/xXZA/If3a0UAm6J390dVDKiBdZnM2CSUMEm8d6B4gaCIBDCHWhC36pcKngCIXyBHMgBIESCJ8QC9oJCJERC9SooIcDBXsoqG9BBHsgqbcKBFeAADmRAuShhE5IqZMRIscQIWSBhi9qjiAXGsvJQ2KrAs2YLDawBJqSCLKztpT3DMxhDK5DCKdBthElYJZBruVZCJizjMwxDkCrpQTqfIiDC4VLTXdTBFDxBe60alpKTlkKLZLDTsvyr3cgIXFVO8FkCMWgDfJyGbsCGbeEWknmRSMnJRqUnwBT/6sKoA0G1LkIVjxrVZJs2FO2Q7HmuwzyEFMDoke/qwziEAyqQgR7wgekR7x7M0CAEQiAMwiiEg9/Ggqp6goJqwvYaLfcCghwTLSjIqoT64FTx51TdnDUhgQ1kALkoIWFKYRVKxhQ6AAyYxQQERgXsb/866/8eAUUeARPkwSYQsC0EgzEkg+YlcCt4ZmvK7QOPJikL5C34IzBwQvJNgpFOwkA6QmquIUTWgRpYZAq4WmKZE4uoExLRHmESGAwzBrTMlQ40wi5Iww33jG48GbGRkXrC0Tw8peqwCUFlLCIdUhKPSTkklBaBCRNPogDyziiy0fJ0mz70He/OCSPaBjlI/8Mf+EBRmZ5TjaAqRZ8fbEKA6CwgmMVZmEUIVMEbA0IVVAEdx8It1JwPdiNVLTQbrIEWsMCrDcuiETIDsGiINcCBOcAP/AAHcAAPlcAKeBPi1IANxiETTME1lRob0OwnpIIrzEIvWCsnI3AwrEIpcOsoiIIogyspS9glrII/uoJobsIklLIrtxzhxhC8wuYevAEVHMGqcUtvPs4DkN86HabdBKKMONrbNMC4yMAfpGQ4lAbWgQM4dE9N3RSVmMOZ8E4bXVujbsmYXHOeZjNCgUM5bHNem5Y3hwmYdKyfOtTBEJIbSQ9IVbHfzRZxoYM48IIO5ED52oE8D9VSmVIh6P9BIRAfM8TCPruexoVA9R6tgjJoKsQCItiBKin0Qk9VGqQBGyDBCAgGRjOaij5AslbQNPoeBPyAHMBAC+wFtJb0SVPBNUUkDi6kvfnBIoxCKrDCSeiCMGyy5jGDLaiCKeB0Tn+CKIeruIoCK7gCJ3ACp0VwT0MwaRbuIiDuIVSTNu2F4uBrvkrurK3w3VwICcHw27TZYASLDkACZt3wyHzDWeuiP/zYGeEuFCPMXNf1XZs1OIyJg0d4Xm8z87CDNefpxSJM80gbAnZRbJSPNjRC10go6pneNuoBNeWBLCAwMMhBAsBF7AEAaNMxq7YqqzLoIrCBHuSBQs8BVVFfG7T/wRsggQmUAL5SQJ9JmgNQAAZkwIxK8hTQAAbYYwQQNBHYQC1JMhWkgaZK9heDZUMGjiFQwiiYgiq4AkpksnQnwzDEgiqkwnXrdGvO+Sd8Qrh+QiZcAiZEWFFzd96Oa0EapN84Al9BJEXqhePCt0YGUWMcUX0Dc4ysGTKxaARACwOAAB6gwjI8SnOWwzsQV+nqZDoDjLfZ9TlEOKqnOl6bdTdr0YVnbMEYqnj+DkbhQ/TEljvExnIdA9ekwB3ngWT71R4slRfzQcR9QroigydcAAEEwFkIAECPNvZOOzDEAjA8who83BnQwbZT3xp8+xq8wRfAgAucAL4uBmJ8ngeo/8ANBMEdFKMKZkAFXAASRIIcEIEYHPdCgjki9DsiUIsGL4IjVMIolIIpDMQqbIQvIAMyDMMwAMMsvDmcY/ec57TcfsK37rmE1a2fbwK4PvCEVYKnPWnNEY7hLM5uBh1HdqQR0VqPnJCPHICCJUZcwBNoNIIwNMM9kcYG0s6cDpJR2t2TVI9dq7qDm4zJSPhe2041v7o1I5vsmPPvkBE9/EO8cUMogICeuUEd3LEdWCis7oEXl+8dSELOPpgai8AF/MAbs2q1l7a1MzwyaMJs3tw1qQG4r4EY7L0Y9EEQYAtfnIiIaUAK0EAPiEEOCjzMqUAJtAAQREIiyIHNHkKYA//8aQpuaUZwNGHCTTe3K5xCQUCELwyDL8jCKqSCdRs8xc85aNat3nJ83cZ+3lZChLGr8wWO4Bh6lWbfLWfARpbYrGGOVi9LfZuQZMHTj2DAH7wCM2gDvsxHlbRpFyE2H1EPOxT90Se9WSO9Szr4OSy9mDS907vun7IJPegDaglSPfwDPySeDnwABmDA+E5V11soNpJ4HvSBHCTCINwCMJw9QADzBIpgpFTAgKU6CAzZs2cC39x584YNmylrMIqZMkXMGkEZkfSoUCGDhhQ0mLDZM+iRpEmYHq3pcQSHp0iEcD5y9IjnJJ8+K1XCNBTTpk08MY0aZYoVq1WnWNWS5Ur/1qxbwHzJSmXKVCmupbyWGiXq09hPnzpt6nQW7dpOa9m+3YTpLSafjxYZQjSoj8QpPYQIuUFDRQoPGkZKiBDBgYMFCxBENjA5cgABAixfHgCAc4ABAwwgOKDgAZlQx7SRE2fO3Dl269jRY8dOnrx5t+vRo/cO3rt3s88FPwdOODhw45AjP558XDnjwoOXC+5OXfXq69apw74duzp3tb/Tw5fbXfny9PTxi/cLT5kmKerUsRPfzp0+ffzoyZNHj304giq55ZaGgImEIFBiQSiWBWMZkBlkFBpkkDvsaOMMNfbwY487/PCjj0PysGMNOPrQ4oQSFnAgAg1Q0mOPRRZx/wQmO2Y4ogVCNBFEEER0csRHnij5KUigfipKFK9SUWUVqmaRhRVVYnHFqltiYWUrsZQCS6lRzlIqrrfANArMtIbKBC9KKHlkEzMPGWQPEaWoYQYaZijMgwwwoKACCSRo7DEFFJDMgAIILbSAyCIDFNAFGmigsQgewAAE04rJhpx04uFHn03/6bTTTfWpZx566oHHVHigM07V5Zhr1TlwyokVunOssy6767hb5zvwbKPnHnrc0Y2dYP3ZR5xG8HBiBxnia7a+O+7gQw/98rBPC08SREbbWCIxkCAGF2RIWypj2cNcO85w4oxz8+CDjz34oEMNaOGI44sW9lThhpT4MP8EzUkeqeQRO6Y4QhBQIkmEp0f+nSSohyHGJKiXNhFlFCRLWeVJsExJpSlWqqJSFa5IJplLsiwmyxSz2morzEzMTHMSUVRhpZNF9vLjDjaY6MHnGuzMoCQNMqCAMcf+lMzQAihDNNHHUkyxgQcooAADHRrZpRpy4tnHn3/8CRvUTUfNjVR42glOneJUHYfVVpWDNda51Va7Vlptta62vcu7J7d63mmnnXf2iWcZPPR4QoYY6KCjjsbtgAPaO/az41kpHkEmmQe19RaUg7aNRVuGgGnwkA7reKKJJuo4Iz7I7SBDCimQkAOQPo7woAYaqPDDkE9cKeUSmOdaZMI9TLH/KSiJlyfK+eeDqjjLr04p5ZMjS1GIq1QWJFcVhRT6fkHrry9FFIu9fMtluY7C5BJOUpnFF1N0WqTNPepQgw0xepAzBcMMcycK9KkxSAsUAkIzGUJNxgAHSNSiFqCoqVGAapL6AyqgwbV4pMMe73DHPOqRj3yAcB7rmAc+fmW34Kyqbc35RqtWNTfpQOc6tcJVd9SxN3m4Yx318OFufPOOeJAjFHiYw7Jk0Dgl1mEiEamc5e7QBDwEoxrP0BYyEkEQTYAOGKYQV+nC9YgNrWF2M8AABnaQhzpUxAk9kIINgDCG+9yBB+vSCyaqooqLdYISQoGRH0BhCk1oYk3PI8pc/55XSOll6UjnO9JSLtaVLS2Few1CCEKoZD6lnG+TkyTL+uZCCUyI4hbDQIYs0uQI+7mJXlRgghAIkwIVBC0DfFKMnxaQAKcxkDIORICigKkARk3wAQ8AAR5CUQxueOMb3zCHPUiFGx3KYx0qHA4LjYOcF7LwVbCald1uZZ3ygKc6u9pheexhj3agwzfmiIc18NCeHcQgiUpkwxvc4IY3SI5ClrNDE8iAimpkgxmlA0S3DJIghDykdGBEhiagJQUaeKABv9SAGJAQBCLgAAcmQMEPiCAHCc0BD4qIUSdK4SBflAJmmQjKIjQRC1BUgkxDMcpNb3rINWViE2VRysrGIv8lZNwiFVg6XycwQYmdTEIt6IukxlZBivORQiyfnORZwJTUTJhiGMx4hi3QVL82dUhnFukfDdBqJ6JRoGi3NOABnRaZA8x1rqJxoAIc5ajRNIoBxmwEKpahDW+sZh/vOMc6bFOP2swDb2u7JjaZo6q5SfabeAunrswpj3LyDZ3qZOc7zEEOXJAhD2jIQQxicAY2rHEi+RRDRPppOR74wBLMyAZBC5SwLYbrig1NEDNA0Yc3qMABCjgUAiDAgQlAQAQhcEACIBCCKmhhEKUIBikaQQlVaMsWspBFKVmKyEnENBWaIBNOxYTemxKvS15Siy+8OgwuxWUSedFLjCiRiev/XQwspDiFK2wRDFaEwqdbAmpcKPEJTsjCq89wxVAmkUpEHKJNfXnDGnrmMzoFcGhtPRrUEgBXQTEwropaQAE+MxpA+fUVytBGOC7VG3aogx64uRvb4hY3bBpnhsLpsXVohdlxatY75tENqToouHaYwxqNmMMZioDa1KahDWxYAxvyWeXGUVmfR1jDH4YxUIIidCDgUlCDBoQMT8DhBhFAVAIIAGcBAEAABLAMdH9gBT8EIxzcIAUnRHEKWQQjGcnQhXdFUQmjYGK3oGCfmMKklrSgFy5syUQnLKEKZjCDFfPtRH31shNFs4WTpPAvgH0RDFew4hSnmO8kN3kWTijY/xXPCIczVsGJTEgslTBaZV/WMAU1/IVOdvLAsYs2wKMhTZeI4qUCQyPXygSA2p8pwAEewIM//PUY1hCHOOLxDnTU2Du0WuFwziEduO14Vel29wzvph1dzfuc1zlPEJOcDnLAQgd1SAIUcvCBDpwhDWnACBva0IY0sGHLVGZDSOZQCzE/A2FZ/JaZn1FQbYECBxN4bgKgS4DL1Bm6CbgMAX5AiEGMwta3CAUrmDEMWwQYGcNYKcyQqglQlO4skgYTVtnSMrUEPS2phARckBrhIAll6KS+2H9tISBZnMLUrT4FV14N65adwhnZ8MWfC5lUnfDk1zu7sBqk0IM6yVKtQv8boFsf02wGMm1QhlIgZzpjGWofgAI5iGcjYNEMbqTDHIFrhz3YtmO4wU2GMiROrXRVK3RUUx2v6Q5s2rGPffDDH+54Rzq40YgzNIENZzCDGtSAEdWvoeDzYeI+J9IDKZ4iG9zgRjiA+zkzM+QZt0VIKgBhAQgsAALFT4BlCBDd6IYgBMUPgYESUQlRUGLWqpiF5oQhC1v44hadyER+K4EtZKjieuhDWYFhDRavrAwtheTpWTjJX/VHUhVS8gUwbjELVpu66qrw/ypUIdEO4RE6YSm2x0tEwRT0CGaGohIApn5wZhA05A2oYH96JpY8wDA6wO2qxq0cQ1EEZWnormn/HgiCUsQBiklSkEkZwiEeXHAfqindHK+FFm/xGg/I7Max0AEdgmM2Jk872CHzNs8f7GEcyKEY5oAHpIAOzEAKMAL1Ug8jCq4iruyeKqIGAMoSbC0cxOEZYiEVEORAFuQZkoEYHiIW5OACim8NE4DOlo/5IOAH5LAKqgAQwHBHKMYVfIEVbIEYjEHVXMEUMsEn3qIUGMIUREGqfKosamZB/E97ViYsuOTnys+nHEn9QKYqnKR6zicUHMli1E8sOsER/sAO9MAQ1ET+5ivoEMkB74Ls9oKV7gAOxOACC6MwDIMDPQyXkkZpEOjZog1RgAlqhikFdcASfkEbMAU7goMZ/yfrbWpw8YgjO84NB3cw3V5jB2EjCDfvHojwG8LBEnZACqCwHKGQClZvDVBP9cQAC50gD4bhtrIBGAriQAgCGJ7hFnzBCwFhuRyADevsDauA+UIAEOhQDmwnEjzBEV4iExYMGXxBKgLs5vpo6EQHGUaBqjpGIbIHEjfye7ZiLFLmk+CPk5CEQYpqFYNuJT+hqkShEx6hEPRAieygECihAK/qZYjCFQFGlSZMAicQw86q2P7nTkrC7TzQgCTD2epuBJ0mmCBIAfpKUhqBFp6BGQ8rBtMtm6KxOaTxsBwryKojOK6x8tZhB9FhWNyBHzjPHtBBHJaBDMhADZoQ9WanHP/R8QmhUAz4UgxmoAbOoAxYjqAOxHM+pyFSoavGAAIaAyATgCCZTw6ZLxIAoTIBQQ4CIREkQRLyC9BOQReGoRdc4RRmARg+Yen0qxNi4UFm4SusKn0QqRMSEOuIDi5+ymS4ZC5wLtI2gRN6sxM44WUoQREKoRDygA7OIDnrwF96imXaApEa8CfwAmfaRAIlItgAQwh2Z5YC6DA4kDE+LGngqil5yWnqKphEgzSsJgbwAIfGMgZncMe6qfGiQ1bO4RrJkgcrLwjXCR3KI2z+gR3GwRtCYVLQ7gns0hypYEGnoAwuhC5PTw1kiQmYYBFu4SEMpFvsMRXOEA0hg/iKjwD/kg8yI3MgpYsyKzMRVDQVBOb7LKFJWiHApqKoIMERROnSRGE1kSEWuuQTBGYR/IANmoAHckAGeMAJXoQunG5LyCKnDMmQdq0SlApGFKFKF0ERDIEPHocJy6BxHDQPbFI204d9GvBhehJnDCFNWYkNmvAJNGwGZuB/inID26oDG6MBiJEpFWgEJ4OufgkEF6UB2CoDYMM6pAMrZZDdYoXH6FMG7RM60NI1gjAd0kFw6CFs/KEcvqEZyAAEfGB2yPEuyRH1NoJCpcAMUBVUpcADVIAGegAOYioWAAFhEAoUsOUZFCIS4Cz5IADOHlO6foBE6XAyUfSgYsou0AQSXtQX/1btu2ZBFHzERi9BwT5hFa6CR/2ASFPgAz4gBWLgfz4Atbw1B5rAFPUCEdDVEPzAXdwFXvxAQt5VQiRQWqalXkOkDipHXtoUVcvAQZFz9OpgEXByEuVi15zHAesHEajTOtkA9ZrwTesEFz2ATjmQgHDpgOZOBElMGEkQagrVhhB1K+XmVRZ1ZOnGUU9WOK4RO9qBUiv1Uv2hH8ZhG1ABBGIAQe1ydqZACnZWCij0Z5kgVUG1A2bpBpAgEQaiCrwlYSJBE7QliwDh5OTsV4FVMkNgDuVwVhPBdmaVHn1CqSCBE1JKFmpmFCiBEZRKRjgB0I7EFDqhDr5Vlory2I5NTv/lNAbgdJbgtAbkRMqk7H/+km9rgAd64AlOtQorgg3m40CbYHYa9wl4YAeawAmcYHXKwA8SzEuec6cYEGFVyScNYRD4gEIoRB3TrgdoYDsltgMmdq08EGowtilFkO6mzTNQ7FBew4bKIWSdYwZL1mSJY1ZkxT5Xdh0olTXeAWbh4RuoAQ8wIAVA1Y1ydmeH7Wc3QmhnpwP+5wZ6gBCa1jC7RROASw5CYFdHjmqDtQokUw5/gA7lMBGKNRG4RxMkgSccQVkvwRK44jRtFE2G4nxKgRP+YFli4AMykO1wUU5VIHDrJG8XuE7wFoL9NgXgNGL/snBP9fQOTvWkgAc8+IP/VWdII9eDnQBz98tlFi2nEPYRAAZNJdBcNqRhZwcwdidi7RbZdvFiR8xQRLTORhAAqC2Iqa0ZwwkHSzYsU+U5HqtkHY94d5A60IHwCs8dwqZwjkEHvrUcVVVVgfYIjmB2Knd1dsCDKbQPJMF7w1AMY2EEehXkRI5qrzZY2ZdE2fegIsF26lAhPUETfGJtGZCnKq29RmES8qBIc8CD+ZZ7b2CRF9lnHPmRIflndocGGJl7H9mSUfXK6KOfoMUOrEwd5cUck/MMGkcPHqHA0OJ6PqFzI8x+HQFLXzgPYhjt0i515URi6dYoq8ZownM8605ERdTuGsiXTIyIbQiJK6s4/5IYHMyBZCfLif3zPqU4cPxBPdKhQGPAA7R4i2cHaE3VDEZ59JLTcg6hEiQBaWWqMDcA5Ng5ziBzfa2WRK9WaRMGEMYACG4ADhJBEzxBTJZ0S9CiEhjhD5pgB3JgjA+ZByy5BxY6kt3IobOzoRv6kWdHgzXZ9ebjk80RCkcZOemADxbBk9jCKKI0rNAEdNe1Q0oX7Qq3B3gAaBJYA3XxdXtxT2e3PN8sV4r4htQheJP5mpK4iXvsPtMmipEXHfihcKQBD3SAW7lZVQ2XCaYgCqhgI/THctplDvSAD4pzEYZiEQxTDtoY5Hr1DSNTjuWZIOfQjgEBCYigZ9nAECShLP8k6SUzYREKoQ7CuKB5YHU++KUh2qG9OLAD+wge2Xo3QrXYYAoLjuAmt3IrGlTVoHHGeRE2AZLmy0kdsI9O2oXhdUPqINja9KUhmDs1kGKV7U7xNIJGTHaXhgR1mqe3A5mFw7FUJahnKGWDo6iXrPDQoXDIARV0wAcE7qlV1QymgAqobCLqY6v9QCaL06RkpBMkwXOqYKxNrs7kmX3nOK3btwrgNxHiAA4aFu2ooA0MwUfwWg/KYAckd3WGdIwnlweM1KVrYKILm7B9ZrAfmb97wJuZwEEbOw1GmcCTswxQFXsnOznpoAwGISnGdL2cp5V9El3HSmfIO7QflrT5dgb/4rYDQBwplw1pWFtPZxeYCYAHc8XysmO2qWMsa1uZ6yY6fOxRWSMdiNoc0kHcCkcbGsEHFgcDnCDBQfX0UFUNuMyfZPld0/QPCkERGIFhLtsTLO4HfHVqf9VE43h901qt8zgS8GNdd4YKouCQC9q9DfqxIZdw+0c7a8C+ecBV9XvOHdm/BfuLVRXJwzmcKRsKT+8uKTtdkHQSIGlzdXMn02Q6F1ZDJucONDztPviWizIX8aRqHmDZ/gQElaZQUFxEtXE7ZqNWZuM1iAyJadvcaHyFbJw1zME/o/jzXJAY5sAJZOADhPxU81z1sEzJXYTJTerJbVQoCpBWYaCdSY4g/+sQEORYfeO5y6WrDhNBEAbhD9ZVjaJAjItUyv4akWsgMISgCCCXby+ZzvX7CAAcaH3muNWgXx20o8PZHBOclAPTg5vAlBdxc4mnkF5xOmNRQxjdk2nZTUlbBeJWpisW0zPdaXgYxdEyLUcd1B/+xYHsmB3L1FVdOlid1V19cNxJHCxhDszAjErDCdS9IuTDcuDFXXxHYWPER17CvD7BFGyVEC5AzgBgRCOTaweSu7u7y9sXEBJhEIrzD/RjPri9SBeYb/UWrWbAzQX3pSP9rwd326n+gx/ZcFWVcuHbuJuwosuRwZWocYwcnA9cBoRgSOvAEVC5/dJLvB4wYXPms/8dHUIhfeBxmWJzmBcVQO6a8jMGYBtnAzYEnzvKieLz5sZmXG7OIeNZY+PhwZ2aoRRpIAUwgAH61evXcbVQPkP8wMkNQbp3ImBg3hRkagwmYAHszDLMWroqUw7Ud57j2NnlMBBwQuj/4Pb1wA7SoA7MQOBlIG9tGBdrIAeEgAf+EupfWnCVPweGv/mr3uqxvgmewAn6da9JfosNl+SHHMHZvd0vJA3U4EIEvfoTenXoYBHufX0mLTq/FhYH4ScZfY1MV+B3R9Jl2js7EOF78RdR7DN4+jsAQp1AdfIEnhuIMCHCcwwbOnyIzly6e/Xs7YMXjxwqPHa8LPHho4waKlP/oqRpk+akGzss9/Dh42eQIUSMHEHahBOTJ02jTBFxgCABAQIQQhg9erSKUqM/kDo1iuKHnECJEh1apMiQoUJ/9OTRU4eOGjVSmvB48qRHDx5s2e7g8bZtjrk8atQQgleIXRky6PLIsSPw2yZ5iyRJUiRxEiiMGUd53PhxlDNgykyuDMWy5suUy4A5gybNGTVn6JjWU2jTqE6ePrUelSlnpUmTKNmG5GiRoUGDDg3ysydPHdFgohTRO0NFiuQpUnjokCF6BgrUHzxo8MBBgwUKuiP4jsCAgQIEBsg7jz49wYIJ2StUdxB+Q3T00TGsT78dPHj07rl7F0861TSSxxtu/yxBRkhUkBQFGCm1sVJLe/hBYW+K1ERJJp3gpAkontywQAIJBFXUU0hVAUgVJiL1QxVTVZXIIo4oQuNWXMHklR10mCEFWmm1BaRgceXQll141WWXXXMtyWRcNfBgGGKJGRYZZJJJBkZxDWqZZZdechlaGqTNcUYZc9ThxyOffDJKm59skgkmcmJCWyW2UZIbIogc4htwedjBhhttRJFED0LQMEMNNCjn3HPQYUAdBdZZp9123Xn33XgFzDMPPZymd55A8rjjTnqkuiMQqQnZdx867bRzDn752WPPO/Www8476fBCBh93uAGFE02cscYaVDT4YIR27DFhhYZc6IhtmP9sopMnUyxgAAILQHDBik6h2JSJP4wBSCCEwLjII48wwkiNW/3xGx9/qsGjFD2aBSRcgRGZ7114JZnkvkvuMNcOAPOQF1tCUAkFoY5dueVjWW6JBhpdWjxxg6GxocYcpnlMRxN6OMJmm6Ns8smGmmgym5x2UvLIIjIvcshuwN2BM8c86mUXc406Fx2kkFaXnXYLHM0deAicx+k88jT9KdNRP32eO01XvY47+L36zjuuvgp2O7Ta0w6u5nADSR587FGHsE2kUSwVWZ6kEkvLwhSTVtDaKacmj1iqQAQieOtUi+Ee7qK5MCIis7qPOMJuu1kVYrMeOtJLb49ruSXYkn//LQlwknz1xSRggoVe5JNRLnZYwxBj+WXsFWOMBkplmFGaaaY10YQdlIjSUymdvLnJyphogkkls9mW2+M09znhHnfUsQaPPTyh16KMNvdc0BgMTUEEDmhndIgKfNcpPZ6qX0/69ORTT/vxq68+p+zXw36tXe/Pf//v+OMPsoEDHOYoBh4KwRI6lKEJSXjMFB5IhTWwIYJseAPOmkUhvcnINpMo3iIo0AAGOCACHPiBCQl3lBO2aAxUScTjYiajxzlihjRklyL4VDM/WE4sahCL9doSmNCFjgahG93omhQYHwiBLU9C2BIRNqXDtG5Lsaui7NpQuzagZDQ9pMMZRsMD/2HZQRWsEMUqRvGmTqzMeC5jXrRgyCfe/CZHO7KXFNaiKBXokXuOkg74rjO+8p0vfvOjhz3wRw9Cxs99iowfPh6Jj3rc4x5jGxv/aLW/euhDH+6oBzjG4Q1L4CEPeaADmaTAhOI8EILFkqAF7xA9ZzFuhrSZBCYekYEHSEACEbiA4VAYgipEIhFTIcS5XKguSsiMhsycYeRw6Bt5maaHmcNjDeZSgxloM1E926Y2jVi60gUGSHhJTGGkCIUpUhFjGdNYxbL0ztlpMUy6q2cOeEeGUCTDFqQQBfA+scZKIK+Nd4IZHOPoB3nZYSxrIAv2FDUDRDHKA32UTqR4GUik5f9joxt15NjmR8hJivQej/wHAEe6j5SqlFbwqKQ9WvqPf8QPHOJYBh7wQIdSnoEMZkjllaAwBWNR8JXSu4MeYiKTq6iLcYeYjgQ0cIFuKUVFK+oWIDQRiXPNLF2Og1zkmulVRkBzEAoVCw975BZverObetSjEUkXTtMlSWELK4xipLgY2EkMS7PraxvA4NfQcHEsamADG655BjyQARnZoAUpQuFP1nhCoJqAU5yStzx15YlmlQtLHTiGSkPdJZt7bI5zOgCd6FxUfJXa5CY3ukl8UNIeJdVHSf8ByZia9KST5Idvf+vblAY3pff4hz7+wQ5zeAMVISklHcjgBDNMoTj/jUkCE1a5IFfijCVfeYkffOMSNthhChnwwAY4IIKouOiET5FKIrRKsxg6Dk8zlCEN7duumkWTlGYdC4/MYrBsstWbbZ1BDN7Kl4EJhgcysIsTF9aWhd0VnXt1THEAC9h41q6vWUwDG+pJh8/OYC5zmIMlwhEOYTyWFKtR48pwctk52UmzMnreHPNwBztQbwpMUItoJbq9iloUo+N7rWtdiw9a3eO4uwWgP0Tq5Cj7Y7gq3YdFVOpbf8RUH/5IhzTw4AP+moaLWoJCj9Vy3VVOYUGEXYNozpCSlIjXDmuYgnk3QAITmCAqcjicCcllLmM+D4dbhVwNa2JfZ7brNwnV/wMPzVAvuGxTBTFIQQwuHYNJ6/GbfZHBgRM8sNTdxZwJQ1gDwUClKDTGdetkZxYt9k7AajENYTGNYdlQvS/iQQ94yAWKmdGKU6jCFKZocSeOTS1MNK7GjItZzRztxek1tEd6yR6iuNcc1Fo0A0OzTgMa8Np86EPcrh0bSfHBWyifNMr3oHKV351SLf+DH7vSgQ8SSAdcj2ViZj4zE/4N8H/b0QxlcEIZvvhFWut4DTTgAAfynN4WVcGEWpBDufrAG2hCc5kyckSiwQq5GjG6rIQty+e02VY9ZlqtbgUnqAs2zicBDMJQWkw68Ypz2H1JY1h8dcW02IYP2xrX0zblTf8b8QxxkOMZtShFKlKxmpR1IhNUv6V8HTGJTpzMEb4ByxmkB6g13LEHZ6aBRE2bAtSmNmhEa8A3NMkOI29ytoesx5MpOUneQvKR9nA3vCvp5H14oxE6yEGt8109M/A74IwHeI/sKAUzYE4NEqxDHd4ghh6YnQYlOIENgDAGOfQhEILogx8w3putGEK/7Cr0ujz+8cjRaHKF0CEpLe9FAAdYwCjPplpnMLoD5+CtpnuLzGvQYCjlpZytkxLD8hqxVmtRUD3PIkokKHTDkuUMebgpHkjxC2LgghScAB4aU4aT4m1Cs7TJRClicYtYbIIRhvCDcH4D9jqn+Qg9uAGiksP/KB/wAajVPdMhKQ+ACt0ADvZAbq5FSRURP3eXd5NkD+f2SJMEb1ZWZYA3ZfGwDD6gAzGgO9pHcIvXeADHY5AXeZRHea3EBpb3BnAgBkcgBEdgg0fwQBbkEnIkE4Xgg4pQCBdCIzJzITPDTJFjQ7M3OY2mB02oI2XiBE6gOamDJNt0TcQXfDEAGIDBYEJ0F0gyanilGA1jcxJTHBwGIdSHRUDXBpaHe/mGa1JwBl6BB39ABjoAAiBgb4qAMmh0bBvCGo9QGxliCr6ADMgADKPgCPW3B3oAPXsQdmsgBjzWf2ZnF8pRaQJIUR6gWtQBArzgDeVQXK9VEYdEW+g2Ug+Y/0iNVA8bODYp5VL2AEAZQQo6IAMdEBYe1lBl4BnUFXA+RnYPxASQJ3kSRHlE92G4ljMqIYlTcARrkGN68Bumx2iUQzl6Y0Mah0NK6C5AaCMUgjdN+CeHdwZRqHv74mmdpo4J5mnCtyRGBDAN9iTLtzCIgRcN9DBXgmF+5Qb96I/++AZvaBqQpiOO1n06gAEggAEP8AF0sAhsIgpS5wme8AizkQmi4AvM8AzMYAynYAliBRxxhH86BgdsMIk9dgM3kCR7FAMfwD2p5Yl4sAzikA6apA8UoUh8V0mFtIqElGSxCJS0YlLxcA1/oAMfgAFzEBrFoga8WGa/iGZpNgUDx/9QHFMshlVrdwAHOPMGbSBBYrAGMYgzblAHF8QHegATteeDPviNckQheaMVNrKW1kg5PPiWZymOXgSFvMM7BJOO6Xhp7IhgCOaFUJQE9VgEClMEr/MYHCZP//iPAXl4dCAFlideXqQHPrCQFIAB2MEDajIKojA8rqE8lfAJruAM2aCawGYJkEB/fvA8NlNUd/AGJumMNMgzMkBplfaSQZOHjSAN4vAOx0UR9NNItLJI7mOc+LAfLcVSzQmd8KBJXcYLIYiUSgkGLOiUqtZv/0Z2/6ZmdjQSV8lQa6A7r7RdDbUGQUAEQRAEQfUGtVkH3MUseEMhf4Cf+DkItVchMrH/ejUTl9zICIuACDTCJ7vBaLYXFmXCi8JCMMMXmBFqRIE5fITJRKNTA0UABVNyJAiTj5LhV/NUO/2YhoJya/VkBuM1QS8ohSqwHdnxbU2gCKP5T8lzkbaQDSgWDspwCpxgCY6ACINwUIzWBzhDm3U2Bel0HHuRaRPFiRmAlCAQCtwAD++AW/fQNImUP4mknPXTKYQUnfvRP+3gDv6wD+QACSHYARRQMVEgeVLgBA3CndZFpyc4jJEXQXAzGnuqO0ZqWGGnFuyJBGIgBm8ABlhpB7AkPROynz8Yl1pRoFixVTNTE4Z2X84jM/plM/JSa+XIl3CBaREamO04F56mArqJ/6qig3zzaI8SdhyJ0TAZczEQ8lcj+o92oEUv6IaWpwZT0ANTwAaj0RwgpAAL4AAMQAE7cAiq4SbTMjy1gGLa8Ay9EAqckAlAegiYuie8cXp+KlSqtqTDl02mVYAyoAN4cAzxEA/+sEm65a7HxWTuKq+6FWXAZa/8oK7N0AglpgY9gBIpMRILkgVYgAVLYLAGawQJq7BGAH2ScXAHh3C5Q3RMORbAOAViUEEWFJ8W1AextJ+KkBuHgAgzwXGTSkPLBHK5kRW/cSNe1wQ7wKBwkQMjJqpp1wHLgVoDKAOaWGm8mQI5QGnApwI5sDl1kQPX1Ba8Y3DCIjEPEmdAlyxs2P+GK/GPQCd0PFAd1NEdDyAFj+Csm7AhmPAJwLCRq+CjtqEuNcZZ8UIh0kM9PEIFZ5ZHKVBa3fM9AliH0BAP+8CuMQVAWSZlU3avwKVS6mq4h2u4GrFrZdBjxvJFjxG3XkCwB4uwRlC5BstqDcKLvBixCeeCDUUWaiEFGBuDcFCSkriVHbsHMtFsjuO6HFRLdWInk1AJcyIng4gnuvEs9fcSXreg+JJpMoABHTCA1DG8GZCzHXBpaecczdGkT5IcMpcv+aK0UegEsRpnDyK1JCqiJeqPUJuZZ/ABD7CZDPBtGNC1o3lsb8ImKSMnmTAbXRWyNsOtYMcxEyS3i3J2p9X/ARgQAyDoA5CwDXvLD4WLuAeMwOqaDgtMDg3cwOHgDdqQDdMQDcdADI2AB3VgBjfQAwtSJpDLBANbsJSbsJS7BFgAMZWxuZ0LZ9j3WUwpXaRruoY1iUgglssyCLPkOLFbu7Y7LemHCbGRftYaJy/jPO2yFQklHH5QBy/bl3CxsxiAlJzZv0gpxQPIvMtBaXrEFtFbF9MLJNUbhdibBg5yEmz4vdWXRWk8a2fQBHTgBP0LKdhhHR1wBmqyJmvyh1QXG3SCtsyTqbuhFfiXY2X5BnHbYwDjM88xA3lABnqoA6EQDulADuIgDhDMDdqgDdYgDdDQDMtwDMdQDL/AC7wA/wuogMqhEAqXYAmN4Mp/cFNkkCA6QMu0vGsmeQMqMAUEZxlQYLCTW7klbMIorI+bC7GlkXBYaZlMCZYxGJ+TuEqDWqh7YAiN8wgwQ7tzQnXphxOA+Iff3AmcQMSZJUNIvJYJxRJnsAPDos4f4Gk36wGWZh3teIvN0TNN5GBsUbQ8wDtJa72c6zoOwoZPK7Xby8ZYlAYKdAY88D0LebfEe8fMKprD84ebUJq1MYi58Tx6YjN+YKRHSolCIFqL7AdvEAPfc66t3AiwfFMgWMt4mIcxLdPfI9Mx7b8CiNNIGQNn4gT8ZwM3MIzm2ASMcbALK8yUS8wWZszH/EW6qmOG1f9KrhSfbHCD7kkED3QHfqDDPPzD6QfOeQzW/uRPehzOVXcJZ8087eJMf5AHc8AHhlAHeXAGw0cwHXBEdcADbOAEo8MWw1JwTVAGaSAsacC5myssUXhwbQZwFIRrE3trBQ3ZIhoFa5CoeZADMaC8WrgDZDAHesAIGlIyKSN1cAIndqI8aKvRMjOyjMYsXIm/ZDfSjKIcnPkAeeADIEC+3zMpu83bve3b38YAvP1tDRADZRCoNtACNMAEfMk7i2HUCTsElouwvywZjsG5LBxiu3prGRuftEnVN2ADNoADRFCod5DDMWRL2eysf7gmYj0KpfDepVAKxPZ0wybf8B2aqVD/CuYnCpxwCf5NCa5JI9FSf3nQBE7AYJf2ATywQDnwJ+aIlXL9FXbwJ3P2Jzr2WW/2RW3GY0zA2Ni33WyQhkAnTwWdBhtbB3xwCKYAf7fgC8AwDIeIDL7gCv7kJihT0T6cWbmh0avN2q4dtyGdRyowAx1gHWfgB8iqAMF9HQzA5E4O5VEu5VN+KVHeHU6uAjWQkidwAipwA2XB3M793NI93Scspw7L1F9UT26Ila/k5m/QA+FtA0SgBXfQsSKbLpRgS7ULtqPZ3vFtCqqwCqzgCrJg6LNgC7YwC7LgCo3uCqywCq5gCveNRpxQCv7NypTQLnjCB3p5aXRQoYBxBoVQ/0o6dpYwkQdzBI7exYReIZC2RtCR7b3cu4aQrbFG5QexIOPIwAy9LuPDsAopAzxa1xob0seXZcSOo9r027ZcKUFx+2MzsJAdwBvDjQAK4ABE49vCHUJWfikHAO4KAO7jrgBopxxExNy8Q3ZHbcLDHH1RsMLIjHCmsavz+dFc+QbgPecVh3qzVEtyArZ/3ibybQqDXuiygOi3oPC+wPC3kOizsOiNzgqqQPH3felUF+C4sYhHVY4yUAY7EANNcGBO0DZgYTkw8Z+HkFCHAIS1pxVqCY5NKI6kpCzU5wZnjMaQyca0TpuwJC+MAAwybgzIkAxFPwzJMAyy8AmZ0N6tIf91nVAJOZE8tCGINKa7fXIztBmfiNwDdqEGdqAJi+ABlXKsGdAcBnbZCt6SOd3QbR8pB/gAnCkpDZ0CwOhj/BzmNrgE7P7cv1wlKnzdaj5mTf1ZugohUz0FubwCRBAHfYB65x0ttQva5mcKUFcKpHAKj74KkV7oiJ7otqDwumALtZDossAKp7AKp3AKooD5otCjlnAJkPAHhWAbfFBwOSUDC+1FTkAwc31wO3CWiFAIL4HySUwjXOGDCVV7Z/kVXgGJdiMo3Ju9aUDr36vzbkCo06MjeSAKw2AM31/0RW8Mw0D+s/AJmNAJETmRbCT1ylNL2oqgjZZjROdQeDQDmkD/kUygAhtQAeKjABQAED06xMiRQ4aMGAkVJvzQsGEHDx0kTsQwsUMKiCp6bHxSpMlHkE2SJDnCxMjJJSmXnDQyZAjKJVCizAQDpszNMmfO0OFZR+dONnWE2iFq587RN0duHIHTR9CgQ4YQLXL0aBImTJ20fhI1qpRXU6VOqWIla5YstGZr1Zrl65YtXbfk1mJ1atapU6ROiWXFydKnS4r+GCLsaNCOHDF45PjAg8+OB4r1yODhCJEhRZkRIVJEODMjR4w6F/JTqNAgP6n96NnTuqib127azG7jRjZt27l1u2Ej5s0anmQU3UIWDNmwZMmNGRs2LJitUllHfdLkyVOl/0qdNm3CihX7pEePHC26bAg1nz137NSxw0aNFCk9eNRYdEeM0hseJEhokEEKwh124GEjAgmk4UAEaZhhQQYXpCGFGFJIwQMVaviIh5CacAKkJJjw8CUjUgpxJZZGXGImmmz6aSc6hKojJ56CKsqOPPSwUY87pphCjDsGGUSQRTBjBBJKMNkOE046+YQrr0pRZSxWXEHLlVlssfIWXWxZS5csrdTSlVpcWWWVvFwhRRRRLOHEEUUWKWOTTpzYIY8ydmjogTN2kKGMHHyYgw9GCmEEtEEJVQQ0SCAJLTPPCDPtDz/Qa22PGWfc7TbcbMPNjjXWYGMNociYgxPnmEMmmf/lUA1mGGNuKYWTJanTRJPstNqOu+4qmQS8RXq97Lz00vvUjPh4eOMNJpBVgQYVKHjAjyZiCHCHHuKDz9oejiBQ22qf8Fa+HWY4sIYKKxTiIx98aELdkIrwkIklQCQxxBJVignFmm5asUWedGqRPTv0oPHGSe+AA44eD1nkEaqK3ITJUboqJayJy5JFyiptmWWWWmyRqxdfvLSyl16snGUVW1xpxRW8WObkEtAG88MQPnggyKEPKMDgAx92ECqPzCgxBJNMKiGSEkqOpsQRpgc9VDRDTDsNtdRcm7TSS2/TdLbc1AiqjhbtmCMPVobxhdXliEl71WGAkaWTTKabVSv/um090jvwwhsvSB/9QE29YaXYo403ehBiihgwaKAMPxSalsABI5evB2p5sDzAyy1/Qgpya6BBiBqekM9yDJsQgsCRRgKx3hJNhOJ1mnDKicWeXBzYRj4izb3v1BS2CqtMYO3KlFRWiTIW5GPZWK631LplrVt88YVkXaivvhddgsE+y1buqouUUDhhZI4/FJGhDj7O4POBBxhoIIYPHmgijzNqLEQRR8jQA+6kkfb//0eIpmmdIQxhfISaSV3NDrmpzaUypSk28CQPYLMDHXwACV8EIxipWs7a2DYLUcBqOnCKFd3gdDddUWJX4iEPYQ7Rt/TUgQ2Do0IdmFCDxJ3B/xEy+MAOpOUDbwUxiOl6QrqIiJiC5GAGMihIE3LAAyEIIQk9EJ18moChKp6uCFssQuu8aK8lJAF2UbAJTljkojwQpUa589sgzAOVQyhiMwuThJG2IopSOIkVyJsF8+TiFrdET3qBzKD0NAgyYQjjkNnrRTCudwsxsaIUlxCFIwoRAz34jA8YeAAGGKCAAzDxAxhIDCb/kINCOOISlAgeJ1yZCSQRrWhLY1otFyXHX8EwgZRaYNa21kDZpIEnakijUOjQBDKUwjloSxtzmjMMZCDjFqLIxCdGoaRYLWkrn9AOd7CDiRSysFeLeCEC79AaNySBXEnolQ8R0oQdfMQJTv/QF08kWCMblQYzjqBEJTKhpFGMwhSLOIMTC7StAm1RJF6ECRjDCLua/CQNtstDRVuTO9MYIo69Ak1VqlJHEkbMK2Shklz6CIxYlAKPtwAGMAapQZga8pC2wEX1rpfIXtCiFr0Qk5RKUU1G6MkJeVjEDhTQyYYwgDIYwEAM6iADRdDPEZ1gJSSquSROZCITm9AqJijxCKQpqpaiaVMuEbhLovgSU7Rpw07mMAc6rCcoehrOqpbzzGEQ45nIMAYygPHTh6Epm9zMZjeNBEtMTOKreutVVFDThTZEIQ1uqEQsPsEZR+zKjmgK6MRUoQpXIE8uLW1pc6J5WtRSQkNlIJD/hwgURS2ORAnzYsnqGvo6mYABDWeYKHsqqgc+oGd3hZBKm6gSHv9NohJwUtLEKoax6DEvFnYIAAAOkIRJpIKlvgCG2WDqHFeEwhKJasQf8GAJVJCsF6/QhZQupopSfIISdBhbB8pQBwwoIHEP6MDO+PuAHAjFB3QAayZYWU00ieITWc2qVmH5v7Eywldv5J0fFNjLX9amDWjg8IbdSoczqEENZrCDhXLwCV8IwxioIoba0ubi5QTjp3GL2JIUPFhubsdWsKwE0vLGwhfyIZWfiEVLo0daJCeZtNxNsiGR3BxmMEOaURACQoTgkii6ZAiwdQlLSKTlk7zEoUmg5+x4/6uToVT0t8D12yHc3KaqqNCfzOWKZ1kRJejeom15AECf/XyAO0wiFqdtTi1OEQpHQKIR5dUBCByNh0aEgha9uEUo5MIyUZiCE6n0wyg52YAcUCAFFFAAA9gXgw4kRgZzEFQhQuhKWMf6ZZhY5f++GhrRtLDCqZFURdPKwA6zdcNoYEME7UkHNsygB02AhDGU0Yxl8GIXvODFL36xi18UI9vWhk4mHmGrS1iCEZRYknW42U1cfWex44FaIY685EHGW97zprcig1HaFksZGZo4Ag5jcGUtaznLtgUzTMRsr5nkJA0LDwpvfZuHPQRXNW50c6+qotxK2DFWAjWFKT6LZ/9XuEIumxiAn/3sABUUoRLHucUoLGGJS7Bp0X9otKN1cHMQ+MDSeRQFWsISMUjooQkfKAh+K9KABjCgAw/wIRleRIk/QIIraCLFmRYc60tk3da0dFoLDaiaSO1Bzb+WDRpqImy2GvvY8qkDHkixjGY04xjHWEbd4w4NauQdGtCoxjNaYQlHwIoTSHMEjuuG2MSqEGniEc0hpLfkVWUwGPSW3h8pn2KYwpQYyfCrHXpAg4RcuSW1BTjBu2yvhmIBCxFlOMDSnAc2poa4mKEKVfipXKLp2MZ59PjH77zHWHyguiZfQAlKkAI/fKISC6OEuP/wh0LQ3NE21wEGDnAABnz/gAyM+AQrbpGKT2zimpDggx4+QBAGYKAJ7cN+U893EEWIQitV50SCX331TGgdgLjOjNd9JFz08DWh2BqzI6PZ4DAEbINiOzaemIEaOIM5aIRpIAcKJAdzuMB3gAd74Ad7gIdv8AZxWAZYUAZSCLdXqgTB0iYlMaFcwQrFCo9ecQ5gyDwavLzL06BEyrwW4zxRYAKlmIEUsK0wKziGgonU6wI0WLg0KDY1ohGI2x1DmBnOaBj/MRIS6gqw8Cyy+L0tZAVg8IQBGL4+I4AJmIANoIE2GATNCitFw4OaewAQwLnrG4ADoMMG+ABHEKit+oSoM7B4+oAO+AAZUDoeSIEz/4iBodKBP4ill1ET+7uxV6o1/xErp2GUA4oU4ArA9RhA2jA73fLEFEnCNdCJtxIxGpAPUaEFCkyHd7AHe6gHWKwHfSgHcPiGdKAGXoAGcbgGVHi5+qs/G7uxEuqmrsKbxXqp76LBzLM3ZUTGYMhBzds8X+CDKTgdFUiB2kKJlugyhpKXlVAJLIAs2fgaomANiGsjqSCP41KhrQopsEgFeIzHVGAFVYDHzyKpItuDANhHP4uACNiAE7iBN0AEXUkhRaM5DAABBmAAm6vDAFABDXgAUAIlpTOESkCE9bADMsiBDrADJ4gBGcAAGQjEMuCBM+ADTCiES4CElRSF8BGFM/8RrE5wJf3bv0JpE8fqm+AKLoFxkWHjsJqoiZmQCTICg5/QF1OcAR7YAUhzBnKAB3boB6nsh3zIB3WoRXHoBl4ohm+Ih2+4hmIQL06osWAcrLq5G3B6QRpUJGJ4RmVMJMzTIMmbPGXUQWgShQ3xHAkRkdFLCSGsrdNTvSVQvXAMA9soihrZg4lLx4VRrKtwx4AiHnyUx45LBYrpOMyExwoYgAIQgOpCgAvggBMgAQ/og0QID/EgLx1on4WMQx1ggH10gBtAAAfYAAdQgOoaAAXAgDrYgzIYOh/AgB3IkybAACegjCY4yamCBE5QhF+cpATLpqyqybBiPLJShKhQjZ3/DK5iqoM0GDahJEoUSZGjzAkRu8YcaAI8IANSIId9wId+2AcNxId1oIZuEAdxKAZe6AZ44IeuJAdlEK9Q6IobE6zorBt0S8tJyKsWY5W8SiQIhdDMize5lKm51KBn8gVF+IgaAEJs5Eu+bKghFDPV64Jw7IIwaCA1irjU8BHGvLhvusKA6izisUfMnNHpKCHu2JVKcAADKAAC2Ed/5AALaIEbeIrN4CdLwoMHwD7sm759DIAXEAACQIACQAB/XIB9pEMF6Ei/KQMnqAPF+IDcqRFDUBRFCLcQojqYjBgF0wqtok6x4r8CIo2dzEQB9M4NC0/cwi18MSP1MQMz0IAU/9iTOcADPFCGeOCHfYgHR/VKagBBaeAFaoiHdBiHRrXUZhAvJinLGS2sczsSXXGxFivVCI3QC61BC6XBZzoFMoinHlABFeiAETFCh/LLgzvRLkBRFS1HNnLROToujMMKHbOVbYqVdPMxShin8jAgCVgABLDSAoiACWiBE9gAMYiDPugRznBD67u+A5i+MAyACCgAAIiABSAAaB2ABcgABwiAAYhXBqCAGjADP5ioaGEiQyC80HBJlVIp+IrJiNGK6ay1RLElsqpT3bnTNNrE7wRF2BmJPo2C36QnnSgD+MiAClHP9QwFcnhURyUHbciGcNCGYpCGeDCHbgDZeCCHaf/oxU4IKCzEUWEcxruxhVzIWS3pmFrIBV3IhbXoGJERGbYQWrjQhWeSy3tjhCsqKMspApUQUamFiRLl1Uyxg4iTOL8hjMtIDanYjKkgD7AF2wIyoEu8xEhpUTd6A1JDAAMgAAfgANHcAAs4gj5AmF4pBDxQSHg9gAe4OQYAgABQABUYAAdAVwU4ghJYgAWoADiQ1ngFpQbwACHYg74xhMGzBDQpBXpcBT16FTy6sZmMxLCyJTqNGtLAxBsRGKLwCdngUxTxU4oFU4s9A2IRMTXQCVEhA17gBmzAhmughpGNhmwohmUQh3gQB2zoBhDkBm/wBm6ohlewBErQDnCqphr/e1MdTTeYUi/vVS8u2R6f5RIuyQUtwQX0xQVbyNDJu4VVqIMn+k2QACPCDNER4UYTGUwUTVHYqBQnbN2FYw+Aad2vYQMlXLgYcRGAaVgauSg/uAMaoACkUwAHKIENKIEI0IBTHIQ+GAREyIPXHFeGBIEH2EcD0AADkAANcAAJuIFnrQAFgAMFKIACGIAftWEEoOAM6IBB4Cpy0wtWUDCxKAUycQWYVKlzG12tm9MII6DUxUR8algZOoOfBIMoeB2hHM+coF16ElTcvVgyIINGWIZquIZraIZpiAZnmLtwaNlI1QZtCAdrqIZqyAZuyAZbWKV/0g43tTGzvBuYUiRB//7e6fneXtiFQ86FXVhkRLY2Y2ixRY4LSsiBGpCCK9qQJqDa+gVRXK2XbxzMqg1KUSajKxbPKJgCKhBU+BBUM5Cdi1W4JQQYh3NC1jCDFqEBd92AGzC+E2CCG6ABNuiRPPABEJjDAYBSwbUAFFYABUiBLFCB/VgAFciAeA0AA4DXeDUAt8U+BuABQ3CEUmAZUvgnJuk4BYtOWQu3pAkNhIUaRYi+3OFOPRDANNCJKi7l8UQRJ1CfeVplVl6RMiADPGiFbMgGaFgGvluGYtBF572GkS3oZ3AGZ2CGanCGZwgGsZS/rwgoa5qOHA3VTOggUz3VCLU2kz5plLY2ZZi7Yv9osVsgAx5wrdJJAm+8VdTLX5tOiTGK3StOAlImIx3xYhFbAxGr5xWhp9YjillWIz2gA6hYGDGogSHwSzG4qEOQPgaYQwZwwwOI0gCgTVAyAAVw1wZwgBOIV7S+5gLQ5m0GV6ZbBGvqhEuYyQRD4hKCpVYKt4PtqPFglPt5FN2xEQau5+/sxFI25deZpzIjFn82M/XhAT0YBmdAlWOQO7qju7hbab1alWDIhV74BWVwBmMgBeb8ipmVWZlVwU2YO9Y+hmJ47daeO2WoO9q2O2iIBmmghmvYBt7GT3Eo2WxwhR04HCsSCShYnRB1KBMhTCxwKMKEAg/RER2hginYCCb/oG5UZgLpxt0R++KfqN0lLLbWYw89WA1DAKtOMIVRGIQ90ATLWAQ9GARLarSFvD4d4Gp4NbkBiIAKcIABcFsaUIB4rcMBILUBmFcFMIADAKXrKzUA8wOr6KYFixVY0yrSpcRaWgQnlpo/2M7yq5H2YINeGrbYRewNWWwpEFRXvtgaQKVVWAtiUAbjzbZoUIZXQIW8qLq6wAtFNoZnYIZWkDo8EikiT+1zmwZqQHJrcGg45gbnfd5w8G1xqMB0sFSWvXJx0IZG+IAkqMYe2JAk6KKGAlHBXAnmNtEyH/MoeJfo1pF3mQLtxu6gVuUUFzGA5q3xlqg6yIM2qwpMMIUi/2spZEiFq2CYrMMDTspqEIA0EIBXfuyz6hIABViAAtgACYBXAR+ApKNDxdFNZqZDG7bhBceAMuCnrFBBB6O1/NPrscpwv+bw7VRdBl6gPQ1KfEER2XEC+FCDUZSdMhBUCZGBTFCFWjCG14a2YlAGY6gFX5CFHQ+5WSgLXRAGZciGasCFl8k00/YKHM0mckgHKk8HcR/3C7zACqRAc6jyeNiHfeAHfvAHf3B3Rk2H/Lw5KKhuJgBzIZiXlFC9Me/3qkVzMGqJfffBIzh41zKcg0p4DwmJedIX2qVdnUgDfQlmyz3v6h0FVwAGfUMGXxCF7XCE/PuDRGeA+24EJnVIr//2M2uOgH1c8MFlgAHP9AbnzBoOABo2ADrs5giHG64KHgOjhKxbJQzfG6dB3UeBFO28kYYtO1Ee5YQD02up85sI44+Aj4Zwqk7wBWOHNrkThjBxBV+QJCKmElZwC+RghnDghmJ4mU84BfXuLBytsXKve3OowLofB3KYcnRPh/6Ud3h3d3Z31HCwBBCQASHQFiZ4AiHIAiEEZS+71U3WZBI5AiOw/CNYAiYYgh7gfM/vgSnSoiJIgibwCNLXEHmaJ3ly5Tq4A79BBEp4mFLwhWhihrb5vk4AD0dA+ZwxNURdtEYgg2KOUs+EdH4MgK4+8DDEvpenQ52vZgLozOe/vgb/6IA0qF64SXVayzrqbRqm0fCjf2epMY2lr5GmB8+aAMqhfB2QkAJdT32HN4OdOb9PQAZhyLa4W4Zf6GzarwUyOQWAcCXLFbJhxpg9yyZOXLJQlkSVKmVK4qiKFkfFy5gx3UaNHsktJEeO4z57/uKZ+9YN27Z46cSFa4ZHR44kTJj0yNljyBAjS7AsCQp0iZGiPn9iSSo0KdOmQYVmCdoTS9SnQ7MMjbIkCpYoXr2CAeO1DNkyZ87Y0cNnEKJFlDKJUuULGd1hsVSVyvTIkSI8eEBgeKDDUiPCkAjreHAgQAABjAMAiAwA8oDFARocqHzgAAIFCBYYQGAgAQIHCk4j/0jdAEOdR51EffokSlSmTpcwVaJECZMjR4wUAQdeaHihP3/4IPejJw/zOmnsuGnTBgyUJFDAToHCJEmSJmSb8ODRxHv4Jk7Ol5nhwwkZS8ycLUMFDZqyZMmM+TI2TJevW8N8ATNML8Eo00w23oDkDCmQcNJJJ5VUBFsosonCEUjehBOONtxwmI01H0rTzDLLNOMMNN3s489J8VDzSzG/LKPMMcJw4sMOO2h3001HGNHTUz4N9dRSTC3VRRdECmWVUj4Z2ZRSQSLlJBbXjUXWWXSktRYijkzSySis+DfMMLeoYoopokyyiCKF/AUCCI2EEmeclvilAwgPKDDAY5BBFv+ZngEcwEBmmxEqWgGHOhCBBAqEtkBqpzHwwA6OjAIbbJlkwslumVACiW+/AWeIcMYdx4cffvChxx551FFHdNKl8ZVXVExxU05lmfedE+OZd54TOezQxBx/oBJNM7AcM80zzDBzH7PIGINMMGEaZMwz02Ao0jSoNHJJg6XMBhEpnIiS7DQv/vJLL72oiwsuu+yCCyyw0EILLrxIk6I+77D4CzG/KKPfLX+QkYMKOm5XXRI+ChmklEgm1SSUQznJpMREDgUkUEja5BV6aaTBRh1p+WHIIm55mUoss8ziSpmljIIJIoXooYcOdoaCCik6x/mHnXbeqYBljf3J52YBaKb/2WYIFGCABItu1oAEnR2wQAcMNNCBHYU4Igonl4CNiW6VQOKpb8IJVxwfxp2K3B521JEHdG7QnUZYUYRFXRK3loXreGShV8YOOTRhBx6NOKNNNdFE0yyzzw4TTIC+/FfQMMxMk0042WYDS2GcmJKKKZWSQsonuwiTjTG76NJL6/3Zckt/tbRCS+y+CCNNPP7osw+LxSQzjH3IlLKDDDUcrJN11R3VcJQPOzwkxQ/7CPHG0VsVlHZVnhWyyCPrcaohjrz1ySgSpQLzKJssYggfefhABh6vwGLJH5eQEkojMwF9J56Z6WkAAzDAABTAAMoQajOVGeACIuAoAyiAAngS/40HNJABCjAggx/QgyIswQlL3EY3IuwNqIIzHFK1DTlwk5sdWggd6cAwVlDogRCcYJYy7Go8PLBh4JzQgxo84QxzwIMrsmHEGD2OGXRBBjMAdAvZ3QIYlBNGMrKhjXAsJBy/sIQlTrEKM50pf77QBTKy4TooPjGNTxRILKLYi2jE4x76sIc5WlQLV7RsFIvgQQ1qQAMmHOEJUjAPFKAgJOld7HnXa55THiaEISTpR4e0HlCiMIVLqkENZ+leGs7CBjt8Mnzj21QnYtOJTUjCEIXIgw58gAda/KIRD3gAHiDRiD/wz00YCMwDMCA0AQrwNJJhzKAyEwAFOHABjJplA/8ExQAVVKACDkBAoD6ggxgc7hJcBJsIO/UpRoBzTSccTtuck4c9oLOFdFtndOxWnVzlkFfn+duuwlODHgjxD8ZwRjF4cQzgQQ4hY3pif24xi1vQwhfJqAY3FiIObywjFJwoRSpEVylRyEIWpRjGM04RilJwYhOZwMQkHnEyO5xzEI5oRDHIwbt3mOMYkMBDDIwnAyEIgQYeSMERpPCEJ4ynkIdEipGOpJSfSAwp0rveUZNSlKH26KlHcVhSsgCGS05hDWs4Aw7NsskzpKE8ZYgbchChiEfsZRKSWIQf/uCDm6EiloDZJQjkVyddPgAESsCAoCpjgMw4hjICVGABIhD/AQc4wAALkCAGD5ABDSzggdWMAQjs9AcPfvASudENCUmYtj8YQpWF8APc7IDOt7nQhXSTTljqKZ552rAM45mnCmowgx5IgQ5k4IQxSHGMaBTjGMa4T+SgNa1ZyMIXAnHFLYIxjGY0FCUcgQYqJio6cImCjymIQaVi0IEOYCADFzSsBBrwAAp4QAhk4AU58IEPfsBDGtNwBiRkEIMc1CAFKdhpT6UwyCI0b5JFdVJRjQo9pk5vkkGJqk+eOkmqWNIMZsikGszg3wlz1Sx9FCtYkTOIDy9CEo8YDhnkRwpa/AEDH4gBBeiqAz2Q4WZustMDMtiAXwoQaQFAQI4nQ4DI/zpgAYU9rGIY4IHDIkAAAlxNZRtxs8N5kJu6MVtvziZOQyAitIN4n6rSqVp1vgpksi0Pr3pV5ibEwLY8wC0P5rCzZVTjGMQgxnCT4Vxk2NkVq2AFK5gbu+FGA4vp2Ac84mENWHzUTKQQhaIoYN5RSIKxEjCsYSfgAA2UAAd9KMQvwsEPffDDHN3wxjSScQkh5EAGMtBvB/zrX+78ZMEOXsLFmFJgKQ1YStIbKq+XaiSbSHjCmbSwFMyAw/PMYAY5KI8TnhO+QZjsEZRghCNirINQvKIRGEhBFlKg6g9gQAVg2IK1/+C/DGLADjFoQI4HaIAC9GkyAkgABDmAWEGFN/8CSRZAAQYwS1qau7LZlPKUHVG2TwlHVFk2xCBQdarToladsLIb4MATHh7sQDwWH08MajoDNeB2B40wRjSyEQ3hHsQ+zg0GMnzBii+qAhjPyKgxlFENcZgDHr5LRzh4EQpSlOIUp4iACjTgAdvGwhN+pEEJTkACEbSgBCXogRgQQYmWlgS+6RgHNbLxDEegwQ5j5oGrpXAToxjlwQbGQoFv3faHKQmpR6L12ttuVCNBwQkTpgLf13BJvtPqkjeZAhXWYIc77IGsbOHSJnhDhspaghR/MO8GWpACIUiwAhZUMR58VuNIxeCWnjcmn+I9GQB8BgLTRIAHMKBvAjTtAZT/daWbBP4HSBC84J5NOMM/jCqIo5ZuLwRZ3qJQyCQUoQhCuLgQlN98XgnS1WXAwzCMGI75LqtZyXicM3wxC2Dcgi4sY4UuksENcsRjH76Lhzd8DkJOnKAHR3gDFWoABmCY4p5HuMELXhAEFaRAD9wBIjACMZDDPvCD+o1DOoBENkDCHKABGoBHDpTd2RFFgClJk9jdBt6akwjF3Q1YrkVMrXVFd/jX4AUeVmEVExBe4dXBHdxBKPnBlkjCJlDCJTgZCEQeHjyABLxACWiAEKiACvCfB2QABsgAGsgAL4HA4RjHXRWNYwjAFDIGABAA7BHAYSXKAEzhAVCAm8xE7elA/+fh3iVMGZXt3posXO853GmB2fDZjViIRXUoHx81X/LhYRMECxkI2yCRASQkRDVUA7MkAxNlH10AAzIAAzAIFJnEQi0wQzign/pxBDf8wiUwyA3cgBcIQR9BARjEQio80oIJQQfUgBT4wSOwVPol4D58AzqYgzgYAx6UGBnYyA5UICA1TCMVWBiEwQgWlS+C4JGEQa5xoJEUIwlKifH1SiHhjfEhDAuyIOCxwRvcgbPNIONZQiicAik0ApykWAcQgSaKgSb2wQ1sQAl4gARkgAd8lzVp0/74BZz8xWII0BUSQGMMkwAAGQIQDQMEhg40Qu25yR8owmFolghBQqd4Cv+oDIcirGHDrYUfuCF0zA2siAUazGESLF8N4GHy4VQTxI8P+ICr2eIc2AspOAMz3MIqzAITIeIigt8txAIwxIIpTAImiEItJMM0iAMrmgM5aEMxhAIkbOIeLEEbtFAb7AEwjEIYoNMg7AEa1MEhKIIjWMIypAM/+IPvfMM4iIM2XIIr0aLFEZvZAZIRHBgydoEv/uIIumUysmVbyqUIGuMGOoX25B1ZfMUcsqAKTqNWrcEbvMEn7cEgLMIjVIJthIIrDIMw9AItWEIM8MAe4NYdUIEYlKPUceYGVAAFfAAZzIk86s83/oViHEDTDMChEIBkAEABCBljDECkPAAZBNz/jP1BIRyGJZxh2RScQ6qJKvneRAJfag0fGGikV9AhTjEnc/JAGdgIfoXHW5WYDtLFA+5AKtxCJ5TCJ5SSJ1SC+WiCJozCIQxCJtwCKzzDzZnDPqRDLGqDMqBCIhCCJjyCJngCKGiCJHgCMwCDJoCCmYiCysSCL/iC7vAOP4wDS3DDMeDBEM0BGThBeEiYfwmVItlaXNJl27llMAojMF6MCLIdXiLJEhQSeoiFV0QF3ojFJRWbGgjmC9aBKCVmJXACJ5yCLTjXcBlDK4iCIvjAsJQBGLRBTp1ACyBpC2ge522jnKBCaX4jnfgSAMHeFAoAAewbMWUQLSVGXjWhHlzW/0h1k29OAiWg1V6cTJYRx6n4XnGmlhuATATejfFxZHPiFA/YiD3VQA7kQE3pQCF0wlyMwgeYwSJUQiwkZmISAiGI2CEcwifIjKGOwjNcize4RDyQgzdcAzTUZE3KpCIuIqUuIl0ASCIyg6XqQ+/UUTM8w1hGKFlwZIRJGIt6AQdqaFHBUId66IeOqDAeyTFy4DLmnQ2laBRkQRbgjd3wnYVNmFa9oB1oSWJSAidw4ywMA54pA0I8wzDQSR7ggRMMAg+owBHgQAuQwAuko35hQBNG3rw8KWHACZ3IAGoS0GrOmz8KgJ9sBgiYm5fqgHEwQkiJTTdRwiQYbJmaaW8sgv+aEkebelnEDZ90JOfxcQdI3ml4NCcP5MB3xcATFGxs3MGHJcJ49kHJxkF9EkLJPgJFIsIgPIIpMNE1iMNIoEQ3bAOoRlGAKOLOel1M+gcTaUM8pKp7WoMyBEOEzgEdsAEUFEXhUcFXlQEa6Gov+qqRSMfUsp2vjihdVu3UkigJeowN9eWxsmjenMeLqgEb3IFplQy1TesnnAJzDYMyOIMzUOozOIMwLAge+IG4aiIRBMENSF1tIY8HxEAeiMIr0MKTyon94IEPdAC9GoAAIEA+xhvSfIAPBMaMgSklfMIZdpPB6gZaOcIilO7CilbvNRzwQSw7RcfcxVpR8ERIPkH/xvrAB3TATvVAH/jBHfTBG8BBH0yBIPQBEcBBJAiCIBDCIGhCJciNH1TEJ8hCT2oDOZhDe7piTAbIIg5DItKF1yUDFImJ+e3OHInDNBjDJ+TAGTRBHXDkEngBE7DBGnRSFJSBV3QBVugvVXRBrQJrCBajrQFrMvaq1o4gxiwBGDjB8tAqst5NWEBBExSbhK3BHSieIjDCDc7GKSTXPl3LtUQDpTIDKRQCn/LRFGjmCTRdCRDm/nmBDMyBJaACLKBCDZtmjNlIX9lrYPVYoMwSGBYCI2AKwXbTmZJulS3sGmqZRO4BH5wWC6nTG9BNGGCFFwAF2g1BEazZI91pE2AA/3h5gArcwSPcARxYgRXEARyIQfD2ASgAwyP0QSKImBTkwSFgQipIwicEgzNMg6BxpT9UlOiAkZlIxCzwmbXoQkSkgivggjQcYAKaAzfswhwIgcSGgRdgciZ7QRTQSiZTQRZ8MhVoshdkgSbjJV4+TwfmGt1FTF3CLhYYARSM6FDc3ca0QY4wQdq6UEphGfl4ECmwQi1Q0eM0QzNEwzQoS29ZAhl8QApQwAZEQAlUQATcQBhjwBGkQAdYE5zQMGGE4ePylQLJZtJUxpYK3FVWgkhlghnqhsEa8REjMSK07AmhituohRMvBxS/QRvQ7xpEAROAARMUQQ8MdCfqRBePh/8UbPEbeIIn9IEcyEEgEELyKm8igKcgPEIk0OcjMG8lYMIoPJExaM6g+cM/qDMmoDQmiJR3ykbp2EITBV0rwAI0mEP6uac2kMLx5OookzIoA54XAJ4o851misEo21pTVC2uBeMwsh0WfGhbvp0kRRJSCbAXQMElrQEbaHUa0AEd5IGpmIzBeQspuGR+DBczlAjjRMNKMoMs/EEMtGMJeKYEYHMNdAAc5NcH6LVAOoQ8+sWdZJCgANBmCE2kECQZFMJVboI6gw3YGGwlHKwkiNheVFnpyvPMjFY9m0o9L0cL3QFhzu8aAF6t6AgN6UQPrNl49MAT4FZOEAJ9RgIhjAH/IWg08QpCW+BnJGhCIlQCITxCIiyCKdyCKNyCMyhEPHBlJSg3SpeS+ZiCKpzCLNiCK9gCLthtMhBDMWADPPBDApKDNJhbDHToKB+rT1MBEwS1UIuyZmZyVcwyiBpYlHjoMVatiGbMg2GMLy6BTVDB92y1yKDUWqhSBpNL3NaCLfQCMSRDtpbIStrHMJTCW3tX0WVBDWSBCqSBSObAx8XANtvSH+yP/3xejQVKYK9rZQlcI5DPJ2xCYzc2ZCu3wUo2WrkzZS+smohTZmd2quSzxIHMj8+hwhQBa6P2xV2cIPUADYhByRJCHARCIqSCQ/OnJhBCJaQCKFSUJxACKMSC/yQkQimtAslxQ0bwQyy00RMFiJgEQ7QED7QoOEIY0Tacgz/wA6YWgw7IQAdwQVGR97Fi8nn/9J//9CeTstzd3Vu+9/T0KjIG8P8edVMJcKz9RDGaKOFplX9/z8icE5he5Vh3Iyq8Qi4IQ83VBzPUB54ZwylAgg+omhsMgRe8QR2chR1MASHUQAYMBiTIj/3oEi/xUmB7aWWNIQeRi3e6uGNPgnJL9mQbscLeOKiEFnHseM2ck4+DTBvYjfEVEhSwtpF7+xYfARwkghWMgRwAQiREQiCAwi2ojCQAKChEgruPpyDI8SisgiwQQx9nREEskfY5zrJsn/YdQzI0gzV0A/84/MNJiIMlXFMHxCVP+zlQM0F5a3JUlHLFy92j61qRcC2vDiNbAuOTbC3sPo8XgAHgZdKPiwwbpEGrlBYfGAIjlKEHcaMr5MKa19mC28f2+cIpXAIfgIEY7IEZ3EEZ7MEdCMJ2bUEpXAIIfMDgdJwugdssBbYYzgQe6IElPHelHPslPDZkH6zBVvbYp6k8M9wSP1yXuRCs1E2QQ4F//RRQefs9MQENTEEfKG8cxAERWAHeJwLevwESIEEc+H0iIO9rzyAn1IIyaANH0AUhJtF7MMtKZt/2NQM0eAM60Hk8yIQOgJvU+iJPazLfRXx7iz5WGGNdQg+ja2jECHDWBuv/yC8JrcEy/F61pdNvGpTBj4NVq3hHGuSBHwQxX2AltQKzjgqPfRSIMtwtM0R4HSCCHfjBc4SsCiShKDiCXgcGBXR4x3n+LpnzjPmFD+TBJ7iCy4DUsX892Id9jY/96S7cwvleG3qZ8LVTsVYY3Mt9sIRHTgxhCgBEHyREXpxoEYnQhhJEgtiw8oWQJkF9EsmheIcPpFPJpnEjxwykM2bPsj0z+YyZM5EiU6qM5i0dv3jkSOmQ8QEDmjA7vfT06SULFaFAs/wE+pNKzyxdmHbB0hQqFqlTpTLdCRWr1TBPwzTtmpXp1CVjyWLxkoSJFDNp2LR1cibNGbhthQhJcqZO/x4/hfL8UeSI0qVPpWTd8pWMmTJlzapNO4nsFKMzUYTY8cMmxYdCofLESJFBAoUPMmLI8EEaxIMHIHS0xvMHzxxFpVixcqXqE6dLuylN8v0b+O9HjogXJ75oESLliAwZGjTIT3Q/e/bYsX7dTZs0acCAUWPmyRMeTXiUF9+DR48ZKWhEimQDB4cXDBMFCmQFCBArcQj18Y8DjkQEoQIRTnpRJptwTHLmGQZLMmkklUYaCSVnXooHw2z+2CGGDx5Ao40Q2zAKKCaGygLFn4oCagkThXKKqhixivGpsLj6aqcw2tgKi6+66KrGq2CUagmpjDDiKSyiSEuKudJ4Ky64tv+rS4ginEjDjjzw0sMQRijBZBNVZJlFl2CSUekZx05yJplbTMlDBj2aKM2RT+aIoQMPPlPBidFy8MEHHUBgDY9C/2jkD0c4oc2VRkXR7RJKevutkkqDm+SR4RzRtDjkkFOuOeiio+66Ut04Vbu4pCBvvCZcfaIG9NDjgQYxbkAiERtOsEELLUDpwwYgtBhDC4vGICSOOBIR441JMpklmWq4CYbaYG65JZZYsMXWFNtqQYWUX4qBhZdtyMHwmD/2aIOMHEBsowsSkUoKxRWVSrEnKpigsSksxuJXyB6dgrFIIX/sSkQfr5oKxn6pAqOMMuAKcbvuQrS4jjrYWGONOuz/0EMPPwZRZBHAAvtklFNk8SUYYxBDc5pqqjGpl0YKuekDRjCJAQMKHmCAghSY6KCDB2KIQVAd8CBD6UILgeQTVaQupRRRcotU0kkvBU4STUt2JDlEwmZOVD742OPU7NBww46020ADjCiicMLVusmruzzzZjgiBSSQ7YMQImwggoQJXIBBvz7iQCIO//qI5JFsTbEFmWdC0Y2TTTbBxBNNMqVEkUKehgQVXpqxJhxxzIlHnFD+8MOLHHZIWF6fhLJXRdyFourfHr+qauAZh6Qqx+K7yhEqIKuicaoooHDCiTLSSJW7KLqTGwyNN+aYjTroqCPkQQz5yxFLOBmMlVlY/3Y5pWiimcZ9NnVpRIcYMqHkgx1yUC2GHnqYogcx8AHTmlao17zmEqOoDStOUbWrZU1rW/NN1zgFNk95imzSoQ6p0tbB7EBMLmWAXt3KUDcpPKEHKJyBCiTRhy8E4QtfsEIfcHABEmgBCGOQAyEiIQhBJCIRqQCGJDyxiVsgAxmAecQkKiWJFt5BD3zBQyNIcYxtcEMc4iDHONIRj2ggyg5dkF0bshOG2uWLCUshke52ZyPgXeVfUaFKwxrGFToCz0Zu9BdZikQkKBShCdEDw3YqNgWhTGEKa+hextqynTN8Tw98GMQhFvEXSFQCZd1yRS18YQxlMKMZzmhGNJrRjP9P1sISp7gECOrgBAxgoAiIvEMNcuCXQjUCUYdCVCFEcYoFnoIUVsPEJCAInEwx0TeZomCmhjM2Q2CwOc1BxHQ22La2naptbSgDG0IoQld5027kWeEN4BAHOWghCKC4RSSCQASEyEEQhEhEJObpCXuCohKYSMUthrEIJ3ZtU5kwRCH+YAlYHKMaqRsHOMDxjXKkQ4uw+IMewhAF/dHujC+Kl1HsJZTd4VGPfCSYSAfGO94VKY563OO/eudHKEhMSoQEgyGFsoY3dO86GfMeHejwMZENtBCK8FImOjEKUdBGFr0gxjGUsYxmOPWTinFGzQpxhhioYAg1EMIdeJCHQuD/ARKkIMUlLNEISCAKEqZQBStW0UCrdWKYxfTNpoLzCCcyU1IVtGBynPMcRDwHOhuszjVPlTE6yOUM3jwD3eoGvfL04AaAC8QX5KCJVEQiEH0Yg+ICwUNCfDYSmgitEy17C018VhOboIQlQkGKYkDDG/HYxz7acY5ynOMc7rAtOaABGztwIQlj3JEZz9gTH6nIdh5l3h5POtIjIYmPZaFRdKliBOoOaUhQiAJiuzM9oTCBpmy46RvIm1M7eM9jWdJDX/5QCEY84kuUyMQnSHEKV+hiGMlQjGKW0d9oVMMYrSiEHcKwhBTkoAm1VMQfSJGMV4ArFK77wyUW2IpTAFMU/3AlpqYkyDVlSgoSISbOX5CjCEP44WxosMwg7EBGN1QzbTqtQ5QiFr0aQ88JOyhDD9qD2cwujiKJeFwkvtDZzoEiFUFMhSQSwblYSKJklIBEKH4RDXHIlh/+0Mc//kEPdJRjHuqgxzvIgQoyuAENReBBDngwXOIWV3nIzZdHVYrSIoWljytdgnWPRF3p6rml1p3j8JoXBZharA2HRCQVFEle8nosY+f9nk7tMIdCRVGojviL+egrplu0TL+lZMw0YoYMVShCCTuQwQ7mwAhcvsIYpEDFrEMRVFE0yhUWFusnOrGJShAzxB1mYiW6JgkmgtgRjAjdcgaK4rPt4TnUtP+DYKvjBkjP2JFnaAJME8tYJ/DgDRRxYR8EAYeJ8FATiZAnuTWhCUloIhagSIQyTYHLUPDCyhjaR5b94Q9+8GMfGILHPtbRjnhQ4w9zcAMVeKC/2eWouD3pF1NqJ5TfiYVILI3uc4ewZ+tG1+N9BvlYRM6wLvCx0IceZBryZUhFilcMIeogYtMg4wGSYQ7sLQSmyyeYUrgiqflNSTOykY2ZmQQZsuDEH3wwYdYSAxeyBldZISEmWeT6FKJ46+Z8E+wOV+rXw4YgJYjDTOOA7a+AHQS1B5tTnaIBDdFLrMRKSIZt/88GgECIkAkRz3lSBMmnBaJnQ+tuU7w2dfFIx77/+9H4f/g74BiKx+rMQY5f+EAJQWnCDi56PDPGC/Q+QVGNhuSF0HMUC1lIvb/M4q8+Y+G5RxrCEIQQ8tgbIQlGKMIQirCEKOB+CVDAAhR0D3wo/CsLsV+C6rMAhjN0B/pgSIpHX74xtrShDm5YpIw9tm0ykAEPIEt4+IMKmE1QjRW66MUwUlL0xkyDQSAJRigsIVZUwAIXtJg1KRphiU8AfRZc4cKCidd8jZiIQ4J+DewWcOwgqJku6FPUbg+erZrW67wyJm3oQIS4LXqkYA2mAIYowj36wD4ARxNAIRKQDAV7yIciwRNAQRM8QfL0bd/67R/qwR7soR3QIfLSgRzI/yEcIIEMtiAM4C6EilAndAREtgAMuCBusOcKduIKroALuAALruBgwmKjgoILqYALmcAImKB3bM/jhuD2DA0NnSAJnGBukqAJnmduoMAMoEAK0CIKpuAO75ALiwIMaqcoxAAQ2YAt2OB7Jk3G1CuSQCaSzGYvgirT5GsT6Mu+yoR9YIbUGMQZjAEXIKy1Zu0S/gASROFabEEAS4EUPqEAM6ESyO4SwA4TMKFSXnET2o0WNSGfYHE3VnFTHiE5PkV0/gAY82C94M4JiqAIlEAJioDzZEAGWkMHciAHSONoOiQGZqAJaEAFaKAEIuAEQAEYYkETyI3cYgEZesg99i606P8pHfchB+0BHt7RHvqt3+zhHepR8shBGpSBGJYG7sKAC+YOCY2HC3KkCgdyIP2RCrkgIQtSIc1izvTFRfTlCJiAIvdI+VCOLOYmerwNx6AnYkrohMJDCsDLo0rSC+ulXowCEJllDeiAEAkx0kolD4QRZGZSERmxvTINEuSLE45qFWRBF3xB6FwiGiQklJzhGH5h1vavvgqDFFXBgTghEzBBykBMa1zxFWVxKl/RUiqBrLIGU5oJERxRdMpyovhADyptbexAYtCADJQAUL6PDAClCXwAGqFRCrDxBhZAAuAtFtQNiB7HExIBDjzBFAghEARk8NwjEdIhHdABHdqhHun/oR7wAR/swTEVjxy4QRuqgRdoARJ0gAzgLmIQSyd04iCNxx8FsiAXsjUd0qMokiKF4ghqszbJ4vbKguSMAAqSIAl60xh98zehgDjlxm4oEpGSEw+dpzeJszjlhju6a3reoPra4g3q4A1kcg/Waya7U7D4oCwRgWQcARIuoSfry75sQRhcRhlWQiVKCRqiARqW4RiOIRmGQRdkwRZkgYFI4XI4AVIaUECxJmsuYSojhawswRKwBr44hRGK40HBRhEmFKiiAy07iAsihqcSiweEwFWcgM30pAEQoAISwRNcMBB+SPBAQZ5OtLM6CzAjoR7rcQfLARzeoR3MwQe5ARrq/1NciqEXamEu4Q4NEOsI/ZEhk7QKd6IKFzIKFXIKG9ILSlI2ZfMI/OdKbe/2ZG/2hkA4gdMYq0Q4f9N5RMgJqrRKfZM40QIKmCAP8RBOpQ8MOIZ72kK8yksmvXODZnICn60QxlI8ydM8I6y+WsEWlCoZ9Iu/RK0Z4rMZkoEYeiEX8lPX/vN+QgxTJcUSVitrNrUqrVJTMTXEpvLXIIERTrU4JlTTmqMsCcrZqmNHlqAI1jAuQNQzBKhDcKIDGEABUjSeMIsQtABwIgIxVZSe5gkxI0Ee5GEdbKsczMEcsogbpkEZPvMVikEZ7JMZRIEZuQANuqA7hOL5DHILynULGP+yXFszSgsSIaP0ClIvNq2UIq/Uf3pgS43ADPGV9uqiS/mM9va1S83QOXtTOGfVNwHJVYqgByZyCrxADKhgCsBLYmmKCtSAY7ajLdLrvLIkS2iyO7vTbEAGPCVJdCxJQc2zl1phFnrhF4hhv/prGaChlI6hGH5hF2hBF2jBwkThcswTxMpTQQUU2XYSEuBrJ8kOU5PtVJWNoLikOaKDxfDCsOYAUKKHB2SgBtrADtAAClyF8/RHBv6EaXyAD+yACd4AHH3MPv4OIT4rEEKLh9pWnuRhHnA0WsXBG7zBGo6BF3AhF4JhGNZkGOaANDbKduSmCs01XQtycRGSIZGUId//NSggUjYXll79Rwj6VV8Dlkoyd/Y4bvb4VXMNNglm1RjX1A1ZZWERCRCV03WpwAzUwEhhktI+9ibPhg+8Ey1nMi/ygA9yUtMYoTzP8xRoARdalqn6q5SUoRj6Nv9oIdeCCUB5I1IAwxJENWnJ0zgmlHu7d+dCJ3cLZQ7IgPPmpAM+4ANy9QMGZX0FKOf0gDoM4REyQXM2oRNQURTSpzCAgX9/5e/6Qw6ACA7arQ/gYIfUsXMCIQbHofK8oTNltr/qUzFA4kGQ4RNydY20C+7k8vuI1C1Hk0mpcApd8zVRBDdlT/Y8l0oCFmCpRKs8t0tVWHRjmPcUlgn8RwpWxVXy/8Z/0FQ2X/cjuW0O5uB78KBjaVIRk9gm1ytj3gIvfLe9+mJCIWFBCfUVcuEXPGkZnGEZlMEYiEEYcuEVXqEVgikUMiFSKsERJoEqj5Y4lI17d04PgFEPxpcMyoAuN4809IAO2kV98yeoxAYRHKETAPSoTmEVGmUW9jNbtIV/H5l/h2EYgAEZgOEWgIFF+0ALiMAK5MAKWlQT+DcxFcci5AAUYqGzCCEctCEakrJliYEYEhUkPgkkkMEVUsEHdDUKegIQq2c0N1guPbiDUXMKlWAIlCBKmVQhnSILdlNzW3iG91WGV7hzM9cIOjd0+dUY67UHchhveNhuRiicts0J7v+4NIcYnS2tUD52iderJg/re57ADMhAan2XDOjAJt0LEjihtVqBFhB1lr1YGHSBFLPucsiOOLIEMOC4aQ3o+2JgUCJaB+YANl6DexlB60qhgUihFKzuWgzjkn2BZSRZko3BGIZBGKgFkleapeON3MYgCFqABEyACHgInmIBGBDix/pADvjjbQmBTXxBGNazPZ+hGh6EGYbhNkzBFDChDpogCorgpYxULjzYqq8aDSIXGRNyhK9ACZCkmfEVhTeXSpx5X5fgc5/L9/5ITbXrj6QaCuoCCmrgBmqABmoAr2sgBfZ6Go8GfdOXGvFEfTvgaAjbr6eRGY/mLmVnB8yDB8T/o+HweoWOZgZm4GhWTdUA+2h2YIBeo/84QdZgARaMFxZQ4XLKiqAIag4eAPMagAFiAPyAUbaBEZeoznw68RUAcJFt4aN3uxZsoRYmNRf89nlfARdw4RVEG/9o4YuHoRduYRawpZFTIRVMYRQ6wd0ewRME4QiQQHG0ABCsIBCQwAqENQ4C4bKKLFm0gBAAoSIAIRB6IRiQATGM2iSqwRkqeRSmUrs/4RHaIAqSgAds7JzPwKqDGasjd12htJiVwCJBN5uphEulmcJnL/jGVE1NtzyEgAe0ql5vGK87HK8Xm8RlJxpNXHaYMRqZkcWhkfMYmwfK4C5nIAcqG0864JVy/9xnVCPHeVw1fhwD1lc0QfESOnH/QmE3rre2d2OOGaEQHME8f64VxniMacF48++4h/u4j3sXjtvKayH/lFu5j1vMlZsXYOEX0hyWj4EZItUXKAcYHCEPyOYO7uAGjkAMIOsGcAAHHicOiOALAAEQcICyfsUGxuALFgfRtSAOvgDRA10ZzuQkUAIZbiEVPKES3EMQDBMT7CCQvslM5e4MOJjUS50MFJyruxoZdxPCzZCFq1kIXniFzRBhd7hVxDlimkAImGDXIzZicxhKCFEDpaDG4AKcoLHhQDRWeEAF9lqvsbZDc0AFpLFDiKZnGuDHVYMBtp3befUAtv0Awp0BVv9jUJSmEUAbFVphtK3cyv12FyQ1F1zBFgh63nuhF9SvF252y7ec3fvdynnhzMUcFwAe4IvB4I8BZp0KGuJTG7SBGxyYM6uBGez9WoBhEFTgCG5ADOAACQCBCEzACpAAB1qg4zvZ43VI7+JgDDALCZAggEP+C4hAh4RFDr4AE0HiG7Olc0TLPQghn/ZACurgDHxgBzbSIyPG1JP+1Lt6hBm8q0FOrGMvX/csraUZ1tWsVVilsbQeCqZg19eACdaACjySkOAiYtFUPe5aBlSg2WsgVzGAaOK+Z+D+A6w9x+H+lcY9yA/7++Ygigqh/xS0JzV6yl1hkdVvqIUhzRU/zRv//xcAnsu7vN37luArn+B/tBiSF2bhExqkgRquQRy+4RuyiPSz6Bu8oRtSfxzGIW+9gRuq4RiMIRh84RvhQAVK4IWQwAZe4AdwoApgAAeAHyKqID9iHgYCQd6sQIfwIwjGANGJAAhiqOblYAyYodKt2xZPsBJAQd4eQd0wYRHWwAzOgLPtjsDlBgqUvtSdwOmbnumnULo8jtWlvuorPNbxmhl3AG9cfM1UPAXYHiBq8BiYI4eMgzJixJChokOHFB4ydPBAAQOFiw8yYsjY4AGGDx8yepThgwwZPHr+OKLEidMnUadWsZI1y5avm8GGGdtpTJhPn8SC9hra6yexX0h5/yldurTYL15IixU7tmxZM2hYqVHD1u2buK/kyMUbCw9eOnPiwnlb+y3ePnj7zJEbN84c3W94737r5i3bsV3CggGLdcdDBRZygsiJA+SHlkRAgCAB8kWLFiKRrRCR0+eLFSRxQgP6EscKoS+AAMkZE0hOrE+ZHmF6VEmSJlOgEglKRCgSoTtq1EjZ4WNHEydlkkeJAsWk8+fQyTThcuUKl+vYq1enfgXLkiVYvBtZ0sU7ePND0htJn14IeyHwayRUuDDGB/oxOmDYj8GhRIcdPNDAgAww8MBFDTCQYIEiNfCRDDz4gEchkFTICSmnZMjKLL4M46ExyISITDIjJmPiif8mGnPMiiweQ4xUMEqFVFQxrlhVM1dBsxU223jTlljxpDPWkPsUWSQ/SCaJpD/+IAkPWl+J8w0/TCK5TzxlvXNWOXSBg5c32iwD1TCD+THDBhdEMMYJpgEBAwo4uIlDnDiMoUUfOLRGBBFBWGFFHJcFQgggYxASyBhfyFGFFWM88ogkj3jCWySaaEJIH3EkoolvcEwxxRNP7JCDE6SSWgap0flQEhmrmjTdFUpYt111sWrX3RJGhIcreeZ9N4QQ4+EaXw3EMpSCCimkIEMKHUhk0YEYCdiRSAwemNEHJKHBhyKNdGvJJZeEcgorrcx0y029BMMTT8Ssu24yxpx4jIn/LdarDItV5WtVVlpt1ZU45qQDsDlDFuzWkUkyqXDCCjf8z8MP69NkkOREOc47/kjMT5FjpXNWOuigE7A43jSDlDC+yKJIDD2sMEEELJzQwg0e3MACC0EE8QIOMBARhxxWkMBCIFpY0YccSBSNxBeEJCLH04k+PcYYliYSidWSRuIJIYNGAkocfUzBBBM9PDEQck40cVxyTqTKaquskqHE3FtscUXdW9CNNxZGGLEcFEkwl8SvQvCQELHyxZACSCBZVNFFz/Z3X30x+IAGGnkUUggjl1CSySijqJKKKxwC4wswwxAjzLvKGNNuuzslM9Xsx8hYzIsx1jiVvjjqeM02/z2CZbDB+yhpfMMaL8mkPsw3z/zDyzsvvfT+vCVXxQE3vPGVQ5olZJDVOEXMML6I4oQUJUSgPhJBHBERHIKUAIQVQAP6NBCABNKHFaBoIsdlY0gEowKBhM18YQyqqcIXPKEJUIDCaw9sYAQ3FQkxzOCCCzkIfjJIOQ7ah3Ef/CAIHbIfAPGnIh7ZCAUaRK0W8mdyOtDBHCakCEhYwiWiKIUqWOEKV8iiFrawxS2GSMSb3EIXSNRFLpSoi13g4olQfCIsaAGLKsKCKUz5BYyocqOsYOOL2/hXXcxBRo/Bwx5oTKM93vEONarxHnCM4z0a1jA4QuyOeMzjP6bXvHzgw/8f9ijHXrpByG6Mwx77gGM9zNGOd9BlHF0ZSziO4RNjzOIRhBBEC1gAhBEQoWhgE4TX4hALT9CvUISIw5wCUZpYxOJ/TxsNojxzNEDw5mmb0gQD+xeJXlJKl1ejQQpmkIMO0idZG6TPfT4AAsYxDgTNdGYHnAnCDBKnVTP8A7cYYYkbtoQUpSiFTHjYQ1fU4py2QGI6kZiLXNgCF7SIZxTjSc94WvGeV1wKjbi4L2lohUd8iRI5yFhGc7wjS2xk4zzoQY96ONQe9WCoRCfKUIfWAx8YvccfJaaPe/zDH//QqEb/kY976IOk+NAHPvyYDz1CjI/Uowc4CknIi+0DpPX/WGM7zsGlSJJjGbdDxi0m0QPEyCEyqiRNLDTRBwEGIhXP0MQUfhaHMWiGUajBlBbkQAg5JAIQfdBCIFQTiEjEAayVYqAnQOEJX/aygZ7owwUNksFiHjOZCgFJM/GDEB2oigxuyMMf/rA5G14Ch6XIUCt8eE506qIXj+1FLdSZRF3I04lRzKwUYfEKzuIzi1q00b50tCO+fOOR5kBHO1b7jnZIdB7ykMc8Zkvb2cpjohbNaW4r6sbeohGO+KhHPoQr3JXeg6Ur3aM+8sHc5S6Xuc2FqXT7iI97nGMv2P0GOkD6sHmwgx3vuO5X4gGNFSXDF5SIwQZwIIcvYOYFQdBC/6a+AARV4iAIXutMovSHGaQh4b+WYU0kBpiIAkdiDHLIX6XY+tZK9ZIQuElEHGqQgx3sQAcWvjBx1jaHDtchJYWooQ1bEoocnkIVPqQJEYd4kxajiyi92IWMcyHjGjNlF7zAMY6xyGMtTgVf+4qGNK7BFUJ6I0pIJug5lhwydKxjHe6IbWzdoY4qq0PK8shHlqHL5YhGFKL2oEeYG5pb39ojjr8FLpfzMb01u/m5XI7YdPm4x3pwaRzfAAc4yoEPkp4UH+6gB57F0Q1qHEMZzAjGJz5AAyC4wE2gKZoVXoCEOeXsTlPtQyCcNhrOsHJ/iGpvIjyRv0BYgQUILHVZvf9GwbdazWumiEQfEMEISBz2JaQQBYZU4cohAuPXqPuQh4Y97GAExtg/SfYvfoLEGs8IKjOikVT42Tto+BOMPvJKXYT0vYKlo42INJI9ykLunNoDyrIlcz2wzG7bxnYd6ngyu29Lj3fU+94QNfdvzewPNJ9ZoxiFGEYD/o+BOw+j0mVSSpnH3D5nVI71+C471FGOc+hZz+Moh0fZfFJ6sIMu3pDGipgxjE6oIAM2YIEJYIADKwBBl5FxWgE5I4imEgIJrOkNWA31QC1MLcGRyF8QHLCACOBANQnuzdW81lbeTErWmgCGiEKUDGZUnRnMCJHVpz6iqccLXjuRyouC8iL/H+fux1TBipCpYQ1tcCMc4RDHQM0BDywNzy1uoRIdkZexjEGPjnfsc3PZPNx6zLbwuY34QtVteDJXFNANTSOT9pFGyv9bjnHcu8I+ynmRcr7v/e63G+FRD3jU+6ARly1s5cEOj0v89RIvx3ctXnHZ10PO/6CHyL5haGU0Axml4IEKJsCBR7sAMy3QgqzHQGoi0C8QX+gDKGpuBbGSNRF90ASnkYCpOJCGEGmCQWoMBX0E5y8Rm0761LQQ/VgMY+pWT4Yy5i9/FF0dRcyYfzPy1bu1X0MbbndkcvcVcfcV3UYkxUMlCtgkDKh3y5MxMPVSe+RSeeQ8e9R3nEeBeoRR/4B3cAPnD/hgD9VVXXOkeSXIJJnHgImERlRCee/ADiFTDjFYDjTIJeAwDjfYJeVgZVUme99VgyHzeiHDUzKoWgyVUtDDD/BADt3QDMfQDM7QCj4QAyWwABAwAibQJlZlNVqAA0QwNQz0X19wQKWhGlbgNYGQhn1gVWNQQGDTQAHUB5iiaa0RdIiSGpFAQEBjGUjwCKkgdSUif/kyf8pgfyfCDNnwdnEXFnfXiMTDDwgXPdOFgdx1Uso1PRqYic/zUZqneRpIR9JVcH32UpiHZmgWUfRQg6r4SBnHinumiuUADkRIg+cQhOsQW+ywDhI3hKqVDo10UG9hRmTERu1gD/+AxA/2EA9oASZv5wyikAMe4AAQAAFAYAItBwRexRjiZwU4gASfEQQ20I1/8jRyoIaqBgjeFweyBjaZogmCQlatoX2PAQiWshoy9z9iYAZ60Ami0AvcwA3X8I/hwA3NwA3H8AuFGC87kX/aABZCEhcEFZH2Fmj2AEndwCNcUQ4WdWaV2HC+lUiJJFL3UCS91W9whEYPdWZpdJJqdFEDN3Bx9DByhEYkxXHNtXASI4nMg5POU0cQRQ/u8GTrsGQ0qGe1p4ohs1rtoFpKiQ6Nt3hAuVDz8GSztQ7mZm6tNW5w4RbpQG7k5jEE8yQExSVnQTLcYA3RoAy9QAqQQAcqwAH/FnABT9MCceJyQOCFR4UERwUIB7aGYxAaaAh95dgHXJOHmiaHhKlpvQQIWsCYcpCHo3Yok6EFhDAG8xMEHvAGbKAHenAKYSEO3HZk5BAOznAisQMvy8ANX3FG/mAOtSgyvkgP9xBRIThThZSRYPZbClddHwVHCFN5clQkZwQXJBluCKMwpXiCELiJgTdwfxdcJiWKOSl6bEQPtMV6Nfh6NXhxr1hxQ7lkT8YO7lCM49ZaTaaUCTWRi+dlETVb6nYP4HZQZdFIBIVneEFT2/BFXJGf+vlF3QA81jANzVAMuIAKpGAJg6ACHsABRkcEcfJokWGZKGAngFAFT2U1BbQ0/5oQC5HwNGCjaeQXBOyYmE1TS+SYP4RgKYACBF8oGaSBBJLwBmnwB60Qd9dADQM1aGmRDWCHDDrhE8vgDamVU+UwlkYIZvD5DUX2Rd+QDhxpJCgIXCSYnCz5byB5D2gUpViapZ0IeJc4nXRkivnmcbp4cXhxpmiapmf6SBWnDkR5cavVZER5DvEGZbTFUOtpUViKpQm1RuZ5cXpBSP35Rf1SqIZ6qFrBDdpQDWlJDLRwCrnGCZPgB1NgA0JzAjjwBXSCjZMRS2NVP3FANKGRmE2FfmPlJ2MFNloAGr30NKy0VWNQBUjQG4CCc/RlGZxxBFOwB3pgC+JAkLxAd+Mgd/9+8QwkkhPIihTQ8A3nwEYRiQ4yWIz1MEfooKSCig3f0EYlmCRxxJMgWIq5CUfIKUcmKK5dyoEmmUb10A7u4GTb6SV4Aa9oyopdgoP2mnE1aA5Fqq9GSYOu+a8FZVDzwK7vMA/v4A4F2w7rgA5ueg44eIP3SVP/OagUq5+Geg3WUKjS4E9asbHSEA3QwKjL4KioEAqcYLKQMAmLcAeRoAE4cAKPRpc4IFZxIhkwoCiSgQN9EAncx32VEapfVUDwlQoH1kt9kBqL8TOBUAVSA3SUaVVJ0xp2QgQ3IAaMgAxf4Q3dMFAVEw7LQAu2UAqscDrk4wu9oEXQMDAR6TFstDD/5UBTXHExZwY9csSTKuVHL8mTpWeclLc9RlIkWLpbrgd7sWimaOol8sqdezaLNbhkTLawkOu4TJZa/8pkq8VIlBuRXaKm11qxnvu5+nkNonuo1hCg1DANpYu6AToNrPuxzdA6veAKpyAKnEC7nUAJi9ADHrACJNACMHAC1vhocgADdAkD9BMZ5ah8nhEEe6Jp5bgnXzgGQYeYUpMooZEIAZRgbYgofeInSyOrBWQDVOAHwRAOFQOaeDaaynAKlPAHlHALsWA66RQV0WC+4jBG30Z6ClORt8kV5yCCeQRS0rVwEPiBSJJGxLiUhSuvappnDqy49nqDrxjBR1lxkuu4/02GDq/5mhp8Dkp5ua7psPZ5poTEnxS7I4OKwtjQL6LbwqN7sdhwoy7cwoVqDdlQutXAutMgDTicw9HwurAru6FgCYrACZRACY8iCBuwoCYwAhxwAifAASRwASMAsy2gGnNSVZKRGEkDKPkTCeKos6bmNYYCB5/BKLYkvXoJA+yDQKcxGVWAKCdQAi9ABHVACtkQFuebFuGQDaaACIiwCJigCKYADEK0C0FRDNUQd0WqWu/gUAhHD4Okn98wD3b7PNB1RywZUQcrcevAnQ3cwNwZwTjYuLJYe26qDgw7p7FYcZTrMd92FhFZn4EKt56rwikcwy9MDTdaqC3suTTswv+GmrH94rEeGw3IbMzS0LrQ4IS/gAu7AAsGarKW4AimIAqfMAqmIAkaAAcwIAITcAEccAHiTALAawKY6oUw4AKe5AIpBwSpoAnxNTWSQQT/ZQWegQSCIoZbtRhI0AITQBmfQQS6JLVxjAQWsAEnYAODYAm14Aw3/HbckA3OgAyjQAh74AeY4AiQYApBNBRBoQzZcL9MGWgrxTySfJ94cQ7Libd7hA/0wHozGIuhHK+KK4s4bXEXTJT5OsuMdMHnuZRNeQ5kVDEj3L8pjKi4DLpfNMNO3ctaMcMrHNVaQcyGasw6rMMbi8zIPA3R4AzOsH/LcC9OwQtVhAqo0AoZAqn/pDAKojBErqQJKqABNjDOF2ACJsABJiDOQHACTgy8d3kCfW3O9ugJWgAEAhQExuuFmtEHQCCi3HcpCRYIceJ8/0MEcawocoACMFAFLKc/QQAHktAJp2AMzwDW2WAMssChXNMHoxALm1AJtxBs8eJ7DZlaVNKTG9M99pAkowcPbASWBBUy3xYwBGVGjxxRgcbJ6dlav9ina2Rm++DctPxIgySx+Qk8+gk83M3d3cANRobdYSSxRrYW3vCP6M0N5p3e7L0N3ODe7v2PADjf9K0N2XDf2VANjIoVOHIvriMMv5ALtUALr9AKrfAKr5DWaI3WBt5DskA6t+BDROQJJVAC/+JsASQwAS1AAtznAhzAATYgM0jwAlhIBIHQ1zbAVScQBF+ABKDwBTBAvOwHBGOgaUFAGXm4GmVVBQKNYI3hJvQFA2X1aH3gfNILCplwC8+QE8MQC6bQVuWYCKBgCp2ACZ0QCx1S2/t3DQPVDhD4Ubtdd8Dd3Gz0lQdYMGbxDlgCyx9zRn6aRl6JUOMWy+2gudddsYcK1bz81Nz9y6Kr3b/T3d3NF1r7n+593mvB3omO3vOtqPUNgPhtDfrt1c081isSFE/hRFVU4Axu4Aa+1qDu6aK+WDMhC4vVQ0P0CegjAjAwAiuwASXgAiWQMzhgAy3wxFxlBTJDvDAABIdCCP888zRzIn6rmiiAwD6lwTT6IxqREBkzSwhVECc/AARVUAV5eJd4WY6RkM2sMNvvpwmVkD+5oQmDoNGToAi38H7J8ITFsAzYYFDKaT12UQ4QNbBLuWQJxbZaAstwgUjlSW7yiebeIxdRcqbaHcNTrbEei6gcq/D9UrpsV7oSX7qiaw2iqw0tvA3aoPEcv/HpDYAa/+j0jd/4PelfHdavWztH8czwREWc1QppXeAwv+CeDuo2v9arME6ssPM87wo89OAOfgum8ARTsAEk0Osk8OEsUAI+xwIbEAQWYAEwAF9H1cRTHxlE0OJE8LtygAMKhAMtIBn0Y6qUsT+d5nLiRwj/P0Aoaw8IkXHYq8peY0UppvDarhQLtpGGnnAHfrAHjjIIi5DuI8IMy1A7zdAN6PAOcxRmMBgy+rrAS+aavjj5+24WZdQOIBOnd3ZahXTwTa3UoL+xxdzwxgyyWAENyUwNysx2ql/VVR2gE5/DOTzxpUvyN6zfOezVX40j+QcvqvMLMeZE8YTgxF/8Mj/qrjDqqxATrZDzy4/zz58hOt/zO+9DPr/zq5AKn1AJoHADQEAIKBDOYxAEJLABLvAZLWAFcPkCUOx8JnBUL8Dq8+MZLSDYdxnjCc0CO0tANmAZYIONACFnzJgqQAoCkgMECQ4gQILIIdRQjpw+hBJJ0vRp/5QnQn0ExekTSYwpYJIGpfLkh9EqZs6mQYNGrds5e/782aOHDl27dunS8dzJ09xQc+OMjvv2rdvSbU2xPcVGTepUqlWtUpOWVau0adasYd16leo0sl2nUStrrZq1rtXQkl1brezcadKiRYMJzVmzZsuWHStW7NcvXrxw0YKV+NVixoxduWoVWbLkVataPXbFSrNmzLIet2LVatXmVapYnTqlCrUq06xNc3Y1y7MrVaU/paAhBkkcIBw4VHABxAYJFixIkADSYkSLFidgtDAhp0qVMSZwMMTx4wcM7idwsFiBI4iVIGPiEOnT54ucOCZ+TNcy3SAOJF+sEHkBaAwOLf9EAEWKRJNUKkkvDiReACKR/ySJxZM3+gClDzWemCOYcC4kZ6h49oEHnqKOSkqppbrZBqqnpsorRRVTjCaru/Bqcaut7pJxK7K4KksarKrCMUe6bszxLmju4quvZZQ5RpliiBmsMFyeTCzKV1BpDJVWrHxlMi1ZqQw11Co77UvXxjQNzMpG24xL1VIjU7MxR3tMllkei2XAOzLQoAIOWrAABhIsIGEDEjjYoIVBfbNggxNOeAEGFFCA4YcvCLKCOiC2Q+GHFhTC4QskkNBEQU+tWC+O7eKrAof9JhrjvyCAwKEFA4nQBBRQIgGFkBuCsKGhMTwJxFYi4JjVhiNUIsX/mWzIugsrmPxapshmoJG2Wr5WHFJFu4TEC1sVX6Rx2xRnBDfcacotdy9p/ToGsMDeFYwww6KkN0rEYGksyyyvRKVfLb0E2MtSBC6FFFIGDnjgVQBGuMuAyWSNTdY2c0VOV1ZJBRMVJCBBAgtGGMGCTTn4YoIJrMBh0EVfUI6DEVhoAQYcqvgiQUASsSIQJN77AgYiGjLBBvI0WUgOJBSyQgs53quCEIG0uHWMSMaAWmfxgtUkkD6QaEELIF74ogUrIgkEoT4EAsSGIB4xZZZhjFGGGLkDa9fduttFsl1o9143WmzLZVHIFbv1FiZ0U3RGXb+UQfLdweTd5UnEniys/7DBmHQSl8QOo6XzxO5FLF/GtJQs4FMMRl0U1FdnffVSED7l9S8TNsVL19hMk5WKWZFFlVEG0WCCCDgweYILRiDCuyBOcMGGE1hg+YUXThiBhBauq6IFluXQ5Lox5EiEkC/oA+86QEr9IggktLAikTgIAgIGQLQI5HuBEvpiaiKOEKT/PrT4XxzCp7U4aK1AcgBEFeTwhT4I6BbBSEYEI8g4xjFDGczAIOOiBa1qqStxievWtAyHrrv4qBonRGEKU3iuF6mLgu0qhjB+0YtdRO5JN+Rc52iBQ1zUkIa7+IUwhEGMwMgNiDfcRS5waIsb7lBynctFLXQoC1nosHOv0P8hZCYTmi1d7ExnYgXEXlOa0kwMYqdYRZwqNic53eIWolDDEaxQgQhAwHgTQAHxXBaEL9hgA8LBAQdOAATvtGBrLUDICF5ABK7BQH1IAJAVxKaF6wknJJ5IhBbiwD4tZOdS+vmCFrTgqRbIIRBA8JQYNAkHKyCBPJpkDw4A8T5PJPAHkBLOHkzBCltA0BjGkCAFL8iMCWIwWtZiRjPUpUxlftCZJJzLXT7YzGZYMG+/JIYMf1FDK+oQFt3U4ZNsYQsrPkmJN8xFLnw4RLkZQ4iDqWEPk4gLJY4Th+XMhRWp2M3FXPEzkglNaCoTmYCCBjRhDKNr0uQaUzQ0FalgTWn/0PgY3WlmFqyYRSxKYYcbrIAIHIAABy6AxwscT5CK5IALXEACRgmSCEFowUO+ZgWfAUEECPKPfsYABDlEog9BSBuEgAWKRCDhVT3DwQuqICkkVAEJPwNELCJBhJfG4RFweOT6rMCppz61fmP4gQhEMIY++GEUp7BFL4DZrgiyNRnETEYFjyRMDDJzLxh05gcxuFdrMi6CxhiGEHsx2F7cE5yHRawVZ1GLcTa2senMhS4kq4te5IKwQiTGL9/5wxruorLnhGw6dXhOK1astI7BDGQ2IxowuYmMqmhFaxBaG9KMZmGoMQVEK0Pbio5GFaVQxS06wQMa0KACFQjpBXyz/1WGLMcCizpOIjTBUhxY4QV9ABsSYGDURXHHBBzQxHTJE4dUFBUHRBDEreJghT5YITiwit/1ZPY1IGgBWAdaZCAicYStMRJlwYGQgQq4wFtWQQt3mIRp0gpMY9ztGMk4BjAl2FZhXnCYFpTgLwE7jGEEwxe98IUubFGLWuBCirQgMRVVTMVarJjFLCZxij1DiypWsXMlPjFjc+FYW+gCspIl7GWFKGF3CoOGRx6sj38sWdDmE8W1yKeKs4hagGrmi2UM02pc88Uv3RaNDsvtm3T3GNeUIhWjkIIKVMACDlggAksz2QVM4AL8cMAGL2izneNgA+YQ4T5IWNR1AkHJ+P+ljGRPDcILzEM/qQWBELciQiCsgLKGzCx+MPgaQ7RAiBEoJEByCIIn1vszFADBCgjsX/halUBABOIOo1CFK2zhi2EkI7Nya2dmNRxYIW52sElMp4mzmNo0pbYzxo7TLJRNxTjFWMYtfnKMyVlOcwY7tJMVcjaFYYzMJmPb2eR2NoNo5F8ncbJKrueIGVuLiqkY2ZlxkxkjxqaHBawVALvtve+NmlSYYkwVVcWZc4uJHmSgBIHkgAlEMJELWOC5KwgUB8bwgg3sqQQpPcEETmADDjQqVhwoW/TkhwNME2EMvNpUH4gQK/t6olewwsEJSGUCmXdSDlsdAyEQKT5CBML/IonODnVwEAdQxCIRidBZgAjhiT4k4qGsqIUvgmGMYASZsDuuhWyqiEVaIJt0l8ld2BEKm3cj28UwdjaKw3mYaod2yZTtRTB0zW0NKyMZQPzlXzWsbXJ7lsmQxYVk1d3irMsG2ZupzZhSA7B5l6J2poM8wHLb0C3T5qEPrQQNLq6+CCg3ESiwwHdHoMfmjGB4fyJB815Agj60gANJJYIJWpCqEewUgQ15ARJmKSstJAIHfTivga5ztANZ4eSaAIStvPazTUktVV+oWSuJACmSEx0UYvBzqyEUoTuYwo0P7HCIlZxEda+47MSuLWlqU8b1g9EykTnT1yOD7Fe4IrHd/2R7ZPVPWSAPce8aJjJiWIa2+qUI4zZtmqFeODcRSysFjDFZeMDZ0KI0KaOHIROHaijTmTfTaSh/Y6gweihTqAQVcIAK+C4OgAETUC6X6QMYYAETMAEWsICTsp7jECTXYw5ZkQMtkB6ZkYNUOKUqwLQvKIhE2Jo+8AQiiIQgoKqTAwRAwD2HiARCsIJUiISFGIOiMgH0mJ+tmjRYkZkfIAJPeSo46INAEIQg6AM4gAMaWIRUAIYOC4ZhcKMF1AVnc7HDoyix4xLfYr81iTzU2LeAeb/IYIwruj96qjYg+7VeCCJca6e9S4a9iAbAwCZIlCGrU8Bzs6xeULcba7HUuv+MzDAoxhMjiTETLauNQKS8gOu3ECQqDXCACBieOjIZWpQzUEmFL3ABGCgp6xkDJDAOG2CBMYgpK/AOr0mI7MABTUiVpMK0glCa9+GzIIADsUECspKDFviZ6xjDm9Ou6koEQkqaMdCE8TE1JFiBVlI5IKAzHAgQOLABJJCD63AIQbiFYUAGY0CGYPDHf/SwOhynwls28zu7gzy/hEytfXKFtHuybjoxJ0Ineoqsc6shXgCiGZqhHnqcXyAGZ4gGZyCMJ/ImelkMfJmSyPCXfmFJlYwMgGmdmDSYglkd1JDJV0DJxYAMX7gFnuyEPYCDKXiDKaCBG9gACZCADSgp4pn/AIcbKZEiAkI4ATmbABFgAREIBDl4PReQPUyDAecQARSEARFAARgspE2BAQQxARg4NRaIg6zBgXkEoCDANBQYAROogqTJn/nyDqOpry/4mYKARyvoiObhDiIoOjgIhERYoMPEgUOIBQ7rR4D0BVoTSHVTtszUuoPkTIVUSClTsYjUIWdjInOip86iSF3wrMEijM5yzW3iBRkihhPKBsEojF2QSMPyJsZgyd7sF5hsnVAQTtQRzuIcTtTpzc3pBWFoF7yYBrnIhmrIu2EQhRnIADragBUogQ04Lg8YlEGzgJISAQsAgv2YABgIBBOYAA4QgV98QRMYgQsgS/hEATlb/8sqWEvlGqVJoardwAET0C6KcJ/zEoRJo8dAgBQU+JneiwTmAL7gsIFgtAE6qwIUEBv1oSr1qS6OIDqK2EFMs4Ep6D5gQIZe4kl/rEw3aqzMvAXN1LqC5EwqioUZpdFYkAUbrZgc9YzZWLEIjLHO4SHAsyF5ihwl8rEf0kTC8qxeY4ZsyAZtqEQmCSLX7CwnA6eWlAzfRAVS6BfjLE5SGM5+SQzLKQa/gAZpuIZt8IY1vRBxIId4gFNzIIdwWIZfYAZkMIUcwBM6Ys/wwIHw3BM5iD0VVEERQAKRugAgAJmRuoAqeM8VECmXkU9MCysY3BOxorn/8LRYkAMXSBlCqv+A/dEEYOgDMYiEVNAC+MxLHPCEVEgOKwAE60EaIoiDIDgPIRy684ADgaDV86BHBIqE+clGOJACOtiEWwAGN6pMf/y+77OF73NRKnLRzOzMG93Rzji7OIFAKXI2Z8Oha3M7/vOsyPKsXYC7wSK3qus1zTIGKWKcZ1AGjezIcnVNHKqXe6UXXOCFwSiGJImWaKCGa8CGbeiGNfUGcUBYhB0HciiHcxgKcRgHc0AHeOCHdgAHcaCGfmWGWSCDDlCBDRCesLyAirMAsWrKmFHB9WzKppTU7wrLERABiMOB8RSBtUQBEZAZnFVBRYJZDgCCQEgeqRG++0geK7iBSHiGRDj/AovYqfnCAaNZuethgfKsx0e4BSRgTELwmkhIw0cwwvXijUlbr7LpHjrTBDZ4A0TwPmAYJ6njyWaF2xZdsWWLVoT0zGNbIymSk8xkLHtqOztkxEYMMrj7sA8LBl0IhlxIhmdAhUa4jFOYBVGghWxyxI58nH3FXMv5BbrxC76QioE9WHIQ3dEV3XSIh3Swh33gh32wh9Zth3eA3XfgiXc4h9odineAh3fgB36A3W+ghrt4BkaQAQ94AxZwgJASqfaUsx+AQQuAAAjwRTtqyo+pWdNTLvJ0AQ6Y2kC6AJRJvbU8NedogfXsuISQH0BYniBQQ1BAAhu4ATEABU0QAzGw/wJBMAELpTMX0C8YcIGjEQ4g6ANkAAb6hVWkCQIxeISKeANkPIE4WK9IEFDvaB8xgAMhSANRUNbKfNu4bVbZ0EwVe9EWM7+7xVsbozFpJTFbiCx0SifAPVfO6qwgS8AgygVhYAZiwIVhwKBhmLZd2FciuhszjYlr0AZuCAeEJV3RhdN9YOImdmI4XWJ+8Acp3t0qtuIq5olzAJFvKAel8AZriIZmEIZTKAQZUAEPsMVIBQLQq0oVlDgUWE8UiIDwHL31dDgLWE8kIIEYxDRYYbNYQaRACATl6A4Y0LhO4o4X4DPraiUcEIM+oAFbaaBEQJBBCgT5SQh3HJufiQVkAP+FKchGICCESDC+pxKQO9gqGMgf7TsPG5iv+rgBGpACTIgFntTgDYbbcZrWGHW3HH23XsaMw5ITaQu2J6HSc1PA1dTEbbrIyulIIpKbCMPhMkXTa1hTcRgKeIDibd7mfeDmDbniK37ib4ZTckjYpBgRpnCKNN0Ga5AGZ0iGXBCFS0AEO8iADIiACXCAhLtfhSOehmtUGOAAITSZlBWB+Ay9kTqBQXEBFkAIANKCCzgBU1qOn3mBg1ZV6dguQOiI3KO49OiBRMAVQnjL5UCQ8+pfd2QBIsAZJUyEO1jgOPgPQUWZOIgFULgDOPgkYFjCsekjEwACquJB9+2BR4gFYLj/ZWflMVvITF2uVmbz5XxpNwm0PyfqpsZCIirFSM7CyMrx6n0djLrp3DOlhm0oYm4AY2qJiXB40yVW3XC2CXzwB7m2CZsQ5yaGh9bNXXQohy3+hoNFWDY12MEmbG4wbMPWhmxwBmI4BUiAhEKoAz7YmAhwgAWYwZ5dTxFgjvCEY4EOywkYgYwT5BhsOO8gAQDhuEG6QhJYulJCOu4QgaCWjxeQrkhABkCwrhawgfSwQvV1HxbAgdAmufhqCKoCgj2jAUHoAxaA1R/wmrhsIEEY5Z1pn/btKVKeGe2YlOM2kEdIhWGIQ4D0RzmkTF8gszHystk5hSwlnX+SjMawl5K8/xd9pRyv3tx+FeKA3QZuCN0MSQd4eOvdZWJybmIprmsBD/Aqbt0Ff4d0MIe+NooQIWyDNewJP+zD1oYM13Bu0PDETuxqgOdeeAVSeGxHOARDOIIMcDPjabNAoWzlOgE3Y88ZhBXdE+hgpTkYMEYgsAB4/ChBYp9BQcafwbSL1gJAkB6Z40UciAVNCE/gJgI6IwIbUBtY8VT48hpAiMvzghUbuA7sWKrtiBUcOIK3nJpBiwPp4ZX0iA+SU6ClWaVKQNZbBrHw0+Ce5Mk9HDNZCA0v8TItBXQqYQx8JVPO9Rtq0AaCTQpsNgfT9YlHN90mXvB78Ad9sHR/uIfWZeIOkf9dnViHT1eHcujrECH1Uk/nERnsC1f1VVf1C3H1C89wDo/OaXCGeH2F06EERcCER1gEONCAOQZtCzguN3su9oyzGYTBKQSCE/yuqdVK5bqAFiipbDQeFxgkGOi0ixYbBboe7QECFnABBhoe+EwZGygBKocvtuyk62CBsPmCWm2B4NgUhfg8VSmI4CCPmmEfhoC+MbACTUCgQCA5HV8qfwegQ4BDPJe6wboFHnMjivJlVwhE1NhSLtXSKNlXQ28G/S5YN5VT04VTbe4QAE/wBW/deqgHexiKoxgHUY9wdF4KmD/1U2+KmScRb+gGbmiKEsEGdd75/cbwDFfTNUXsDj//aw7PcCd10moI42MQBlqoeE7IhFGg+kHQvBMglA3YgAioAC+PgBb4AuJRXgvVAoH2xYQDaBZQLkOeABu4gBX4yj35ymgXK+Y4Gs2WA+7wWT+VPRg0FPtQR+YBTJTBNAg1JS2wAf8wqqAGH+3ewWDko62BFf3SBEIgAoi4fMBEgvfaqU1CgqX7hGZ9Vl/w4IZ36hmzon2B72/S183Vm0NPU/72hiNOWNElio938HTAXU5/B3PQYlGvXXRAilIXEZs3/uP/+Zr/eWy4huZ3/ua3hudPU+n3CiL28MT2ChSKTrm4K79qFybBzc65mNh5nRnthBnwgA1wgBZIhEQpAQlY/7r19MUJSNkJeAE5UC7R4xNBKqkLeNoLAAgSJCawcEFixAUTE4iMqQKkBRAkY2AkAgLEhY0gQL60MAEkkI2ISKzgQELIChErSLR8wYEDZaBIcZBE+oIEyBg5VXCwJLLSxphEcoAQiRSJUJw4OPoQIWoRSSCLWnCMWRkpEaFBpoDFuuU1Fliws2bJkmUr165fv4oVW7asGTRp1K5t8ybuLrl08eLBg7dv396+6dKZMzc4HTpy4xYv/vatW7dtkLthq4ztmuXK27Zp3iw5sufN3LiJ7sbNdOTUoVdL5pyZ7rXYsa1Rs2atGm5p0aJNi+as2TJlyo4RJ/aL1y5asF61Qv/lHNUpUtKhn6p+ihV2V6qqm4o1Sk2GChEIAgqyQYIEEiFbQJgw4YL7CRbknJjAgYP8CSNMXMCPRBMHLnBwwQmRBHLBBSjAIAIMRARSEURaAPECEjbIYYMWfYzhUiRjyBRECyslcpNFEZGEAxFBSBREUkR8IQdVVVhxYR+pBMJTIl8QkUgfSBBxQhB99EEIEjgEogUSQxHRlBVxpGRDD3d0B1Yqpoxy5SifpOKLL8IYo0w14ZBDzl5lmnnmXvvwsw887xBmzjiPTQZZZnXaeZlseeq5DWmhaaMNn6NxA+hqo4Vm6GrebDYbbdFAA00zwAXHVjHH8YKLcss995x00oX/8qkon4IqiijSnVKKdKWUgh0rqphiiiqljHKICh5sQAJ+G7DAwQYbWBDBCEDod4EF73EAwXj2TTDefRfAAMQIJ7RAAgssmDCCFoG4YAEHJuAnAiCRcNDCCESkQsQINvQhCBFaWKHRF0A4+WMghKA4RhBLJmkFECxgm4iT7lYBww9jAKJSHHB40kciWgAChJFyzNRHJDuehEQfcdwwxRRBqPhUv0jEIYggkiByCBxx3NHHHWkwwgoyySizzDTi6IVmYWOOeddd3szZjc+bYbPZZHSxZtlqRrO2NGt//rn00LPhZs000kAqaXDHsKWWpZjC8jXYXze3KXWdmi0q2qOS/1oqKaJcKQqsVZaSyimbpHB3CSxN4EBCRODwnkLviYDgsfFZAN8EEBB4AbAsQHyBDTiQgMMFBcGHwoAimPACfSaQcIInX1jQByhYrfsCCQa6EEciRLAuCCGa9GHFF1bU28IKLzyoxRgo/fBDFQeLDAccgiQFAw4v4GADEqDEAUoqgHgSyUtI5NsjUH7jENFGTVoBxx0jBtKHFmKowYclxjDjDDTTaOMzaHMuitnSgvZpP/7eeMON/vuP1r/+8Mc/RYmGT03Thm2mUTWrXS1SbiEOW4xjKV5cChe4CNvXMvUK5rSiFcvp4NhO4RzrVMds0lkbCkn1iVCk8G1ze9WrMv/RBBWUYAMcWAEHRhABHPKKWBw43A9FYB8EwadYh4MB4g5Hgj7gYEACwaFBBkIRFIigI0i4gAg4IIITaEEOX4gFKK6SCEFsIBLACIINEhEJ6xHiQXEgCvOQUC2faCEpY8AJk1L0haSg5AQXkRfzQNEHQAhJE4D4QiIAkROhyKGONvHQwazgMDkEQg5yAAQh+zAIP3BCGMwQTqR2Iw252MY217CGnmLzp1LKBpXZeCUsnSZLbWRjln8ajS1PSTUGPipSkiIOMIMJTEpV6hfEOKYwuKZMteyimc20IC2iGc3lbJCDJIxOp9L2KU58YoWc4MSnZOEKVpTFFWO5hS9uAZb/SmRAAhwgwQbkcwGEHM49xVoWfHyIn/64RyECsY8FNuDHEQikie5xwQlK0AIUoCAQSHDBCFpwo2rhqkaJAEUsKnGLVACjDypgSogE0YcgJFIl2/MbESSasUaO4QtaeGlEFBmTMYBiKP3aY5Nk8oUwfoEQgAAYEgipBYcMVUZ92N2DFJlITFqyD3noRC+OIbNPvsWXj4LGbnijwK1W45W2yUYpSwnLscZyrLfpTS8d6JbhQJCYbi3GMSNIKeKwFYLHvCsxkpnMXvC1r7voRTNzYcFa1EKatHCFK0DYimtax4SdulKqUEUKxGrHFbLAzldioQkNSCACJCDWCH6Iq/jI//OH9pyACUxwOB/uqli6g6cfN+DZF9ynBTaYnONwcAITBCFaOCDX5GxQAtq5Lg5TEIQpBEGDEsQhW3EgUiTkgBIttGB7VqjRUQNRu6HUrovjA4VPj0IfFwAhkMCQSSr6ECIrkKR7d9yIRSSZCKEYBRAPkgMhXjS+RHxCF16S2cyq6stI/aYZzjgwgnejQNwwGDe9QbADhTMcuEYQr8K4qzAyjNcN49UYHjbGXbVWjKkOE5nITOYv+qpiZwoWU4aVZmEPm9hWUHbGrFiFdUyhKlVFtjqscAWVVBELIXslEylo5wYQNxD7eOue9sHPfUTALQ5U4Ic4YIGvInoCQFTgVv8W+HJopyWtpTQFBSaAwQgsYK1unRkJ07LBCmxghRWg6AYYIUQbIzG7kehICz6ZyUysIBM59MGSgEhSJfvgiTG4gBCpSATyiDIkAwXVChmpnUVSgmeHdNcoXwgEqC8ZCED41L71GoUseuFhAEtYGcx49fpgzYxk0JrWykiGXVGsFr46s5m9UGZafq2WDF+Yw8QutrEv/OFjSNgtn7w1cYzhpbzqWsW90EUuWgzNF8fYFcx5BWXLIs5xYkcV5jaFdVbBinRjR92rqJIpNpqJGVBAAhWowHsuQDkEbS/N7rmPsQZkAfHcygot+PILRMeBE9xqBBM4wUFeMIIXAOGdJID/gZlPsHATtEDjzvJREOJVpBXYlgV0BIW7PEEIIARBkkmKwxiasiQktSsOlLTkTSwpBxeEC1qOI4IN/Ngu+/LEKUAYSiJ9tJFw2ZySgDA0JjE5PkGkQha3GMYwjIGMD4MYxXy1oIsP+woMwpiwtjiLYLPd677+4tga5jDciQHirHO91sJxi1uIwexbc73rwvCFtXWBbVsQlrDRdIWMa0xZVrEChOo2t7lJuIrJM9YV77aSljDhAQ144N5UrsAFfDIQovBqQBa/DwestYIhbuDe8qnPQE6Q5tAOpFgnsEGa74OChIzABTAwwZJgAAOIk9clv4eBHFjwxmdpgQUs+Ugi/2Y0ExyoiF/uinlzc2KTJZUIoRDZXr40ooUgVAUJSEAeDr5waBxUwSdI+MKLDJbdpYKaYYTowyPEIotZ2GIWtbDFBn1NNXGQYhVgK2wQ4lmWuBleNOFCtuUCr1lbhnFN3BHTMWFd3bEaWwXHrbGVtPnd3/WV4OnC2RVeLcxC4lGWAa5gK+DYNaHC2LSCNL3C/nHCIyzCHbzBDawBZzXAvUUAtwSUCfSBC1zAtExAr1TA4ZhAFi3cfUSADd0KgdjAlFnAbTmIQH0Zr1hAx3FLQvCHS4yAFRCCHMBAC8CAC5gAQ7kEEPweSbQACxyaC7CXUVgIv7xAkHTRS0RCRMjBTf+IjJPMl7RYAQsMn76ohBz4hAvgwLMQAQx8QcyRVxc1SRwgEhke1U9RkpBsoiB4QirMAmKJmywM4AaRjSnCoGIpXijKwouBXa/1GtfoWttpGLJ1mNyJmNZAUDNUwzQQA1xJUF7tGmCNYAkaHmGxImUxxyke4Cs0IC6kxVowG1xEA268EjeEQzZUwzMggx48AAY0gAM4QAR0lgSEozjCGQlYgI6wQDq+x8BdQJUNHwyk45cJhAmwwAWQQBwc3Lh82QYAgRZonHyElseJgEE+nBW80wi4BAcwIgl4zhoy1PkRweqAwh3VjiSlSBDgoX3FHCHEAiEQAc65CIoQAjB4wkX/vBEQWEHMvUR5hchQPBRKqJHE2FROPJdQgNqDgBoh8AjsqNEiPAI5VRMtjB3YlKIpVtNzKNaPIVbjJWMAGhYsOKMr/lWKWeUE6lUt+qIvFkMuUgoxOMMr+aJa8ALXmCVgPdO2YRDYgJ1aeKU0OsM0dFU2XGM48MzO8MxdhIPTZKMxiEIhxEADRIADLIADiIc4EqYDXBmvoIgT2VA+GoQJCEgRXsCt3BA8rcAIjIEWRIuPvMAEqAcJtABtvV639AcQCUQ+csCCuAQJoAAJiAAOAIIJOAQL5EsLRIImsCS+4FmFIEEiLExQaQIoMIROyJxFkFTMtVztbM9LbQ9RxIR0/1VBI83Xi0SCiiRCTARCHBxVqflUIuFXIHQiIugBJKACBUXjMlHKWZ4lLJjiKXRQUlbTVH4N2N0nL7CdLMriMq0n1+yCWYplNihDpZglBR1oeq4FXLoFXEyDNWiDXYqDzkyoXopDOFyo/0CoNigNLmlDNURDMwiDLZDCJegBBpRjBBghB5RjryChxUnhfeCbBcCTCaxePqYLrqzAddUQB7zAC5wAhcTBj45AtNhWmtEWrmgOB6CAvJRA6jmLtTwLClxZ+uGAnklUKqSCGNQU8wiCu0ROEBBaJPHLjAzFs3hRSeDASQRBJQUCv5CPSISLdNGORUBi74TLTwWCJhAJfv+R4SWRmiaA2nzFwSAUgh6gAlvgnTAN01sVAwWJTTUx49i9GFW62H0+owU1U4L253GU5YEeh6Om5zEYR3EIB3Esw6NIw4OOhphMKIXupf/MzzVQA63uiWc8DZ/0TzhwQzZMAzMQA3OQQiYYQudFwAK8RwRU2TsFFAcIFzydXj5KTn8UUWjaUIbY0MJxoY8G4cIN5AmcQErxCsH8HgfEQSwEQoD4jRqiQJEwjwvQ2UYskSYwQywIyUPFASKSn0v0TlOMBFFcGUUuSZDIRI4g0iVJkiT9VHTF3BhUBUs4RCTEwiUdVaENiU9Bop4igyYAgyANgieMgiXQQjQ+UDA1KjH/GdMvJEfZZQqlXiotZKqmIgeAIugEIeinztUxoOqjOMMywIIlANZ7FsNd3iXPhMP+gIZrzCqtWs0o0arTygWtstIpzQY1bOhs6BItTUMzJAOwtg0nTMIiHIGxOsCyREAQaIF4VFkFpGMLOOna7goJCEho4seUbYAJqJESBeEYtIDFfZkFyJ576BZtpRYVvRMTCQRD/F5JEAHxNAUMVAEh1BENaMIzaEIPVEsiBAEhgIKKwN9KXASJ/Cu/uEgcBMIYPA97qcR7sdf96YSOVJoc3FHDjMFRyYEmnOtRYYUlXRQoQI8n9K4kGEIj0AIveKVX2uyB4gLy8gIsYKoDZlsD/6rdpWbqr5llf1ovMZ0qg8aFNNAP/+DFXoqDNhyD8h4D1ywDAqESZjgt+zotbTjoAo2SKI2S/EaDNHBVNZTSoIAVL/bGM8yaMPRCLUQHK4yCKVguYUaAAjsAF1ZAZ3UZB5RACeAKt6jWfSTZChBRaHnLCqyAtyxckQLuQWxAsNgAUOjWO/GHR2QuCZTA7fkNC+AAeYWLGqQIEGASHGDFIIxCH6zA5ChFJIDCSoxUShgMRr5fSiQJkbyRHEQCeyWJxDzLGLLXS/QIvkKi+qHRHhECvYoanrURIfzkHYACMtwCIuzBoSpvekYTUYqdZcWYMxrW/wletj2jM1mvMeFsVf89Sq3yD9G6qs7o5TfAT9AMijVIw1s4AzXmLyq1b/tWzW6kalZNclbpBiUXGAdqjXHsQi4UJS10kHWUAqzEgincQTk6QAIkZrL+UEBpHDxNi6/k04x+VmguhXn4yq20wAa8ABVOwEW8UxcCgbT0wdEF3cVBTHG2wA0cARxwKRJMTo1oQiKMQaBS3xuwQQ/QAA2QyBeEXI9cj7vE7lPYxEoCZ+mAAne+i0S0ESAsyRj2znVVUuzOiEs1rJ6RjkyAmtT5VHfeASEsQipogsroQSjQLBvTgv+N2xvDcaZMJS1YZdvp3cxMY1fZ5V1O6GDEg17oRV6Kg2M4xs/0j5zMiTf/QCivZuOfZAOfzEX73u9t9G9v9IZvqJWparJaQFOkbgo2tc2pnJDblAJY9IG9jcfYJmuXKXAO2RPEkRZ8JHU8TUDtjGYENyuuECkJfEHQcQAiZWRE6Q514UAcHFogHcEbbC4hkBfutYAkeMI01xRRwMEgxPUf7lEjjVSgfcFRlUjM+UhQHRVxrosX+UTvwFxONBJA1qR0QWJ5jUEbSTOSaGKhhQsZjg+hDVIg3IEhXMLXFK+j7oLXRBMcW9DIvkVcrKpdArKr3gXQwE83PAYA9Y+FCvI3iMNrszZt10VJO801bKhnMAqDyTSkkOwxleUFsSUBFuAqyCd0ZJPZkIoo/6fCI3Ter+CHYo5HRyiwEdnTPX0ZPv1K7kFcEMATCWgCEtDeCLAjC1RAufhoSn1rEOyhFpgASxDCLTyCGOyppVkBILgAEoQPvh5JeQWxJDxC9KHAD6SMipgf8zydflsEIEiIi0hMHGiCKRDCor3fg/ROkrTOE0uSSyUJT4yEUaTCPcuBdg5SJKicT42PfdmXFTBCI8ACBbEFBdECKoQCKbxCJ/fCMR1DmIzJXrwqbbM2AYUGnXxGaztG/wgKAPGMN8w20YavavtMhtaGNWxDbFBDWmUNBHkqBYEdWwpgpIJQYrFKcoOyCZFK2+D4JxxCCmhAPC1w2Sawt7gHsNwHd0DLhwU4XHywssYVBK44iUAV6TsxXARISwtMS9xixB3BAO0IQiwkwg30ARxUiLy4QE91TFARQhV8AYVzDBkyYkAAACH5BABkAAAALAAAAABAAQABh+vBouC1l92vj9auktqriteqi9Spi9CpjdWlgtCkhc2khsyggMeih8aegsecfsGcgMaZeMeVbsGXd8CWd7+ScL2Web2Scb2Qb7yQa7qVerqSdLmQcLSTe7SQdLmPb7mOarWOcLGOdbuNaLiNaruIWreMaraJZbSMbbWJZrSHZ7SHYrKLcLKKaLKHZrKHYrKGZLKEZLKFYa+Lca2Ibq6IaK6GZa2EZ6+EYq+EYa+DX6qIb6qGaKqFaqqEZqaGb6eEZ6mDZqaDZrKBWq6BXq2BXqyBYquBaaqAaKqBY6t/XKmBaKl/aal/Z6mAZKeBaKaBZqaBZad/ZqeBZKaCYaaAYqd/Yap+Wqh+aKh+Zqh+Yad9Z6d9Zad9Yap7Vad7WKZ+ZKZ8ZKV9X6V6WKOAZqOAYqJ+Y6J8YqN/YKN9X6J8YKJ7W6B9ZJ99X6B7YZ96Xp58YZ16Xpp8ZZ95Xpx4XqN4VZ54WaF1VZ11WKB0UZ1zUJp4XZp2Wpp0W5pzVJh0WpdyV5R0XJ1vTJhuTpVwVpVrTJJvV5JuUpFrUJFnSI5sVI5qUIprVoxoTYdnUYplTYtlSIZlTYxhQYZhR4RhR4NeRH9fS4FeQ39cRIJaPn5aQX1ZQXpZRHtZP31WPHhWPnpRNHNWQ3NSPHRQOG5RPHFOOXJONG1OOWlOPG5MNW1JMWlKNWlHMWZKNmZGMmNINV9HN2dELWJEMGdAJWFBK19DMl5DLV9BLl9AK149JltBL1s9KFg+LVM+L1g6KFk6I1I6KFo3H1Q2IlI2I1A1Iko0Jk8vGkcvHkkrGEcnEj8rHDwmFjoiETIhEzUeDS8dDiwcDigcEC8ZCSoYCigYCiQYDCMVCSUTBSASBiIOAhoQBhUMAxUKAg8LAhQIAQ4IAREDAAsKAQwJAQkJAAsIAQoHAAgJAAcIAggIAAcIAAcHAAUHAAsFAAgGAAUGAAYFAAMFAAoEAAcEAAsBAAcBAAUEAAQDAAUCAAYAAAQAAAIEAAICAAIBAAABAAMAAAEAAAAAAAj/AL0kCRMGSQ0HCmrUMDhFjUM6dsLUqGIHTxIcdMQkeYSmDhorRGKoePEiBg4UHz6UGIEihgkRJlDIfFHjBgoWmIABK4YMWzRkwYL58jUr2J8qYqxYyXEjiRcxXpRaeZo0idUkU29ovYGDSBIiXIvguFGjyNccRNIS6erV6osbL4gMkRujrl0YdV+kSIGCpAsXKkwINhFYhWGnajiVKlrsWC9btmpJjkW5leXLl1WpYmXZlWVSnC5l4sRJkydOpEKF2qQnTihTpEYNa7ZsmbLbyYwZI0aMF69Xr06BqgRKmTRQcRaB2vZNW7Zr16pJny6dmvXr07Jnf8a9e3dp3KWB/+fu7Nk0adWiX3t2ClAcHzo6POCQocH8DkrkIEIkqie2/9JE08yAzUQTjRdeFFEEQRsYoEEVBE2BQ0N2iFFQFS3U0EISdAhihSCChFFHDjj89YJMKIzwQV99xeCCSyOw9AIOOGBQAiE68SQgULro0sstxUgCRRI5DJHDjAheJdVZaKV10Vo0emXFWDUR4YUdggiUllI55HAlHnRYReNdeNUFw5lm8uUXYCKIYFhhLuRABx59dJIKLr4g41gukU1WGWWxtAJooJYN2goqoXiiqKKieJJoopVUQooppoziCi3AAXfKK6ycItwowoEiqqinVBJHHIC88s022TwXHXXTXf+HnXbe1frMeOJ1V1520KVnjTW/LAKfDjLwwEEHGTyQQQY09EGIIpfoEs1/zhgoIIFEiDFFGGpItMABNWw7RbhqCEJHES0UUYNSVlqRRx+CcBFGC3+5INNKKJSA4gtDWDGECR+MoO8LLFiwAQuw7FTML6b4IpRQsQQjihRFdOnCCxt+1ZaYN7hAY5dM4UAiEVaIQUdUanmFcspcZRtmCxj3pRdJaKaA5hAuoUiYCm0aJpIKLgxBRx6CdCKLw8gg00suudxyyyyzSCbooJVNTWgssKiSmmqiiKLa14+qNkoooGwSaaSNpJ32Imsv4rbb7/lwKjHdsPpqddRkV8001Vj/p9004Yk3nq2EOyPNNNZAp/g11iiDHHx6mLHCCvItu0IahjAyySjF+OQMM9USqIYYatChBhJqbDDABEhUMUVD3eKBRB9VqHFDWjVkGwYidbDQAoolpPQBBgGzaEJdIrCEQoYseDDCBp8U09gwlbTiYy++3OILLnJU4UUOF6OQVpREdOnXxzRuRVJXRGo1/u0fk3hxU1GdFFdIMLxwpl544RxD+YIhiQpikIOfvUkwKkBL0WQBjGAc4xjBYJrToFaLWcQCMlSjWqFisQpVoAI2pPCaKEixNbHFZjhoq8QiAMFCFqLKPaeKoQ9meKpndOMbvcJb3v62Q1oFjnDPqBZ5/5xBRGfwylXqqQY2pJELQPhgD3+4AxBkgKz5hIAHfGCEIy7RCmMsoxlEFN22uhWGPoRBAQpAQh24lYc8OEQNU6iDWHAwpdu1oFwnkInwhEe8EQzwJX4cYAyWVwMWTMACGlCETo4BlGEMIyjC6MUsinEIpCTBXiUoiYvqUq/50Sh9WwnlWN6CsRbcIGRbgRlJbDKTFxTQLm/qUmBEcjxNxsklLxFM8o5HBELkBBeoQIUufNEjXUwQak67BWQwaIsMWrAVmqHU10i4tdRQahSgaATbtuk2GMbwm6fyQQjktghs3BBWPczOrATXnWhIo4hEjEYR5QnP8hzuP9d4jnMUZ/+NZICiEIP4wx/koAP6KCsDlxvEIRwBCFYco0DxFMjQ6tCHPtRhAwXYQBimgITXVaEOdeiWGmpilRbggAUbEMQNgrfHlKhoBDtDIAFdECMWsEACEtiAGxR2jGEIIyjBeOQskNEJKnzFBSXAgAkAMxgU2MuTn9SKyMpHI1Vi7C3jIxFJ+nKDFvzudzIx4JvGKsgBogAHtBxMm3IZg34R4hO4SAUgikLMHiXzaclcpl4pAxmoEUozqKgmNSc1qVGMYhMrTGw3wclYH3CAA3I7RTfOSZ10qtNvtxqcgeo5T3oW8VaIwwZ0nrMNbZj2Gv+JxjEm8Qc/vKENPKjcAx6gAR7/pGEQfABEI3RRoAEhyA55EAPpekADNNKAW3eow+wQoYYF1YBIJBseBpyiooClpE0YUGq9VABTw5igBCXwHQQkAIIdlEJ6PfXpI4MhDF0UQxZoEEu+MODdwRDGRG/5pH5PNBOTxIAkdYkSDvjryphd9QVktQsB+5UEIxVwCEaySw4Kk8sUDAERpQAGLi6BilpEshd2NWYt9AoZyZj4xJNxhWc8mBpUeDCaHyRhJWDYQveMYYY+uLHccOzYx/qAF5P9Bqz29re/DS6InOUsGOFpnmksDjre8MY26paN/3QjGqNgIRza8AMNJKsB9kGoEebAh0KAwhgGqpAY8kAHOoS0/wYaMMAGJnKHO1SUuXboQxKgkgQUUOADFCgBHvaY3YC5YKkumal3XdBV8VrgBDOwBHp7IYxf/OKn7Q1GMfwgoXx9oL6EEYzH4JLfG9TFfK2k0fqMRIS3cAUHXj3R78Yy4AH6rEsELJL/8lKSIoFMJD8joBceAQtcIKM2jukFiJ1mTFqQOBcoTqaJY6Fiy6iCUqvooCqg2QpTqKYRjD3VjXWgAx7z+LGQTUaQ0WlkdnonyUpe8mezI9r0QGcd66hbaYO8DWwYoxFrGMMTQLCsZDGAAQ+owAm+4IdCQMIWyoiKkrBURgc4IAyEWKMgiKYGPOfBCyjILgYuQAE8eIEF4P+NEU0lnDMXCcarqvwAC2pABkYw8hjCyLnOKx0MZEhiByi/AARy/UoX/eV2aYHLf3EwBAIT8L8wkFL7OCSGIeAgCYHAw4DL14Izlem/Jsgfr18QExToOgcxxXUSYkCHT8iCJ8dGhk9/oWxl7+LueM+73pnGNFrEgjPRJIWLg+lBU9jCMk6c4Rhq7M1wxwHdcXiGOYU8nSKfJzu5wnxmxWMN8WBePNZy5+F+9Z9smNa09pZOPvNZZWsgYxMC78EOjPUABgxgABXQAA3mcIhEOGITKhOucN0sCBYsgAXNRUIeEAGvbnmBCCWwwAUKTYEk5GFF+oLp8RQcE7ILDOY1eMH/B0w6BT/g4oE7z7mle16KINQg+hIA2a9zPVWmzIiAayHw+mAAYa+0ekYk4iUmJz5gEhIkoT8pEEAmkAIxAAML6F/gAzQJFBggQyR44HaNkTTIsDB0V3d354F5x3d9Rwu04AqAAk2VYgqa8WLXFiimoAfEEgLjZG5jUINjIG4xhG6NIA2TRw3VUWTgkStBpHmCIw2ddzieRSADYh6k9x/YUFrqAR2/MlqM8yvNUAuAwANO4AQ8EAIPoAAM0AC5BwJf8AeF4AhWAhFtVhF5EAh0IAGsUwRV0EZJkQJaEX3TJ3IUgAF5UAMqkSIrIkjhIxOC0RcZMhYl0AJTgAZsgAp6/5JzjrRzw3AMwEAGPcACFEABugZhuNYl6XOAAFZAJJECSQADKMAXewEDJvUVedEXBeQlYvB/CbgXg0F2MJADDmgCJYFgiPYXhPFfu3iBqQAMjPSIercLIpgLJLiMfqdizsgKgLeCqjAK0iiNzWQKTiQDj0Vu5WZu3ugD88EBp8CDN/Q34QE4SFZEzAA68URPoScgtWEbt/FFS5Yr0oBa2KAd1lANU4gNiWMN5hENybAJa+AEY8ADNFAfGlABytIBMzAHfuBKanEVAmEFJbAAJ1AFVuIVZlEDF/CRephdF+Au4wdeMiFIwLgmXHEDRbAWvlMEauAGlnAMxSAMjnSTjv9Ek8jgB0BHcvL3kyQySqBIEgGkPyVAR6V4AzDQMifBIvtyJDDzX3uRgLX4dDCQAvqCAoJRF55WdjQTCJjgdgpTDMPQI8gIGSQIbbRQC36XQZRRbZnRbaOwCpbRQdDICrYwC6GQjdvYjd9obuHIC0ZYjj50K0P0OeuYDIqZDLihDIyJG7mRG7phDIvJmPK4DMzwDNZwHkz4K9bgj/uoN4jTC4vAhUBQBSygASAgHw/QASFwBvf3X/9ldjNyAwsAAe6TBDfwfB5AAdNHcpl4ASOAASxACEUAF2eFAkCDXyXxajhgFhexPDdQO4OwEzh5k8KgDMKADJNAAyxAcqAUSgv/hmtLpxUvMDAzggN4EAh2wHR0lHT6A4wD1hdpUUD5oxffBV5hdxfgFQPICV7B00olEQiRgAmlUGxkORS+sGy3wCeSERmRwVd7dUGUoUytMAuaUTWYEQuzsAmA4AQhQB8yMAPc6JffOB8+kAzR8JnfUJjvhpjMcBvKoBvJcAzGYKM3OpmTeZM3egyK6Zgy+kWb53mI8yvcAQ3QQA3/sQyg8AZPcARcsAUrwAEhkCwaoAEnUoj3whZE8AELsAFNMTIkJwGZWKaZaAGPBlynpC+AARgjMROvpiBIsBYr0gJEoAZpAAtkeZ0+pQzDgAyrsAMnAJ6kNpQiU0D1AgNMd5Vv/3GVKDAXRBB1SYd084meXXEkU0mL4JWLZqIXZmd/KZdJTmkCYkAIhPAIliAKszAUymZMd1VMsNojyrag10NMINYj1+ZXGvo0laAHY4AsGSADI8qNf6kDXsgBcfBFn9kN26Er7AijjqkbNulIvxAMddeBvYCt1apelpatw0Cjy2A4g3M43ZEdSDpZ/qgLhbAGadCuUUA5rBkYMYJAFzMXWrEADtAXJpADH3ABHyAB4wUBwZmJGHACNUAIcGGStSQz+iNVRKAga2EBKlEDaEAFlJBefDqj0sMGg0oBZAGK5mlqhZEXS3kmi6oVS4my+fNVVzkYJrkvg0GLgnEkmpQ/Kf9QEqZ0EkllI1mpL0kAXPshCaqqYdtTTK2KC0ibtEi7PUyroD0yFLfQbU+DQYByC7EAbmNQpRkQAsJKoiXqlzE4H5XwRdNgTroCo6DTDOtoG8ZArdmqC5MxYiPmNLVwC7Laqq5aC7nQC9/qo8oQruXRZHwDOIhTDd/wDXWDDQO5BmXwBQSxArmXAYBkX7p4VmNBAQkwfS5wAWRKARAgsBJAcsApMDcCfcujL3lBQGhFI2aRMhQgsS0QBlSwBwozDHvqSMsgd8hgCDQwAhfwsfklMlpBS3EyBFuRP6r2qDcwBHYIA+iCAzaLlShwlXyRiPc5M1S5n8DYgMDjVQDqPCz/sRIlcDtJ0AeHcAiMwAiK4AiQ0L7u676OEL/tOwnvKwmTcL+QUAntq7+ksApOs0yAoguxkAhx8AYzgCwyKKwy8LUzRG4ycKyn8EU8uA3suI4WvI60YRu5QZORZEwcCjUgDMJ35TS4kLc9srfDoAw+Gq7lqnr+iDjyIA+I229XCAhl8ARU0AQ0sAEVADwJVCJfISYvoAAOUCPDMzyZGAFmKnLDUwSCAF41gSJW9Rbhxz5Gcp5vsSBq8HY9VQy6YbtJ0wvFUAkZoAEeMGAk4VUtAzMyATL8dzv5cyZcYa80UwTUm6k2c5Ve1wI2M5XglQKwZrzHaYdqzMc3sRIfAL4C/5MCYXAHgkAIh2AIhjAIlDzJhnAIlDwIkpzJklwIhiBQlGyGa/AGDVcIiaAKw7Sgt8pssbAIevAGPzADIbACXTus3/jAj/ULf0tE1gBPFxxGtCGjx6DCPtULkgGrdjsUQAVU0tPM0qNexxCPzcCDTljNT9gqVfaENJxlb/AFUmADeYQicdIlShEVNTEBC5ASGLCHZarEZZqHxMMCglBIGZIv6PlfMOdqXLk86RIGVdAJt+vFYIxzwmAKHaABFrA8JDEwWlEDaOyJ9tp/MJBJ+7MXRpnHKeABHgCgf7wXHF0CWKkvXWVK6CK+II2VKHcCK6HRGi0wNkBRpioIFRVQAv9lZ3ZmCBV1B1AkUAK1B3vgBz69B2OwBnCgB3qQCK0gFLRqV3aLjQUcyx0gA7Q8rORmbjGIrJSpDGB0LUrIDEoYzA/kmDb6Ya4aYsocFNfZzI60zDxRGwXimYkjWlGIj9UcDbVQCDwwA3otEy+Cf1bgFCBBEiOQABAAaGZKAUoMnNMnXRhwMjbVAgDKsKWUz/u8PDCJBH9wu7ohPSpsDL0QDDqA0Kr0O/BzP06iJaV4JmChLx590iHtx639xwBKuqdozzcbdVYAMyoRXi1gUyVwAijH0h6QEjVgB3aW032QXHWWXGpAURYFUtBdB24w3W7ABtbNA2NQBnAwB40QC6z/2gt3xye24AueMAdrsAZQPTkK7LU85sAhWgk2+rcGEo+YecEEosHD/EDGUJN21UwX9Kq6EFS2Kz1fTHe7ULcBbgzIMI8FMh58o0PaoUT/8W/EIgNhJX8kIxBokS8SsACZ2Llm+pF5ODwXkNB08NhZeYCnBLwANkgYM51qQAVUMEnTut/FkLvGkAvHAAhmrBVo0RVbBxIj3WpXdybNe4qZqhcgDaB4jMeRLRMejeT6M9EzQUi+DdwnMAItfQIZaQcOAVJqkFzRrQZo8EYgxQZncAZs4AZpjubWnQY7AAQ7UAZtAAm4MAysqgvIyCe6UAkBx4UzQDmTo94LXG6GXuHi/2ij9NgMMvq3f1sbzKDBkxmtN1oMC0pMkJHMDgNU6YedBn6rvzAMjKmY4Xpkz4CkSZo36fEf1tAMowAf4gwySEkEF/ObC7AAOIVTFADiwQmcaFp9hYRyphSU/necp6QWM5I73KIGUsAJxSDg+z3MM7oLw6AJZuwVc0IHIOEyQt4UcFE+YAEXpoQxNaCKWJmKdtzkRr7kKDKV/NLaNrLQXnXIv83lWQ7cLIADSWEFFWLmb/TvX07mZQ5HZ4AGBW/wNGADNnAGZTAJuPDs7GXgu+A0iXDeT5DXKwACq9kBUy2s3PjAMugDv7DC9NjoJl8blD7qiqkbEPRhP+Ijy8xekv9YzJa2C5QmDHf3rYupDOJqmNwxDTsk4f7oE8KwCFlZL2hhBXGCAhYgARbguYSd67t+2GXq9JnIAklgU8tzqUn/107y10FsFst+Borw7I4U7beBc7oACzIApvSz7SxjSkTOFFQlVSPNx1PpvFlQBKmY96+diFB+s1xR2x7NFyuiEoj/AcAdPLzt0AphBQqxEBuFBB1VBUUwBeqCA5TfAzXA+Qqv8D1gAxsA3FDwA5bw8EHRgWd5C1nIhSGgmhvfAa6pwAosg48VBzf3t8Fs8rwvmcbgmCvPSGQ5rT+1oMmsaY3xQBxcd8Nku8OgbMJwo4/Z4AESDdkB199gTv3mj73/sCL1wj60DjCiS6a3Pl68TvWd+5E4oCEKwRZNchXwD/8kYwUEcQaTFFTJbxs95d1tAAKk9jEAQSRJjhxEbrR40QIFkRwtcLy4ceNFwhQVU5TAaNEijBIaMXZkkREFihcjLpRgAeMixhElPHgY8dLDiRIxW5ao0QKlThAnTrD4CZSFh5AvfZ4gegJEz6MTKmjoIIMTrmC6dN2yZStWq1aknoQIoaHCgwodlnZAu0LG2rVgOXBohAzZMWXLmi1Tllfv3rzH/BrLOxeZsrnFhhXze8xwMMaNhw1r3KuXL8q4cAEDhmtWrFizegWj/FgY4167ctFCPUzYLlqxTIEChMLF/+wcA2fjuEDhAwYKvSEkgCCh93DixTFcaJEEB5EiRJwzxIGjOfToAg0KrDKFhqdiwYQN87uscKxgh2bUqBE94Y3lOJIYfBgxx4uHCUe2WFmxY0UYKlP41+iiFEJqyaaXRmChhRNaSDAFmjaoKSaWDiyhBZ1yOuqnmZDyCaaPMPIAxA1nquApGXgIBZVQNmFxk0perASStTrIIIMSVwABLbNWWCEEtsACy5RlwquLsMSOMSbJJFX75Rdhvtslyl10yeUUVk4x5ZRRRgGlS1BchDHMFyFppJFFzFykEDUXAaTNRd48s0w5YaQll1dYGQWQRDwp4QUXCiJoNhRE+GA33v8usAA4CnJb9DjiMPhgBEkrdC8JOqxgjyGIIqpOICuseG86JGhQpBhT5ULG1Md08SWVGU6YjYUc/nxPPeeKYEGiiCZKyMIAf+0PwP70w+9DmpRigYZkd9iBCiSUAsEGZWnQwKeMWqihiBpYsOGoZINSNsOKTuiWXBxXmAHdBzLoIIQyQqnkEjIhmReSRP6o0cYSybIx3woyWPeBBzjI4C1A3jyYTUDiYLhhhhOGM+I45SyzEi9B2XKUUzZmhRVXXKElyiYfI0ZJY5KpixlmnIkmGmmmsQYbmWXepmZ5vvmmm2EqOaUWFFpw4dMccMhhJBNEwCBpESSVYIGke7sg6kX/L4D0A4zuu4EIK7yw4jn2IFrOuaGdi469IrStYxZfGivGF1ys6gyWOliYzQW6CfqUiPpySsi+TROqEIYbAOTv7CIIB3E/izzoaYOeNICqAx7RgoqpDTSYyQMLBgTqp8s12GCDpyZwoPTSFTAggAAMOKB11weAHQDVAWBAkUQqSXORRArZvRAZDlCAAQWGD76BBsgqcSx+C+ZgjDLfbOTFTbrUGORdePml5JNR1msZ7+1qpmXxx2/ZGmmsQT/9mWVG/5r1188mfm1qnr9m+2/+Rhmec9mEpIKSUI4LPoACE4wgaR8wgdU+sAAJOIpquaFa1UowEqwB8Dl9uxpCzPYc/xxE5AboocEkQhEKU5giFZ4Y4YpCMYtHoIcF20JBCVygta2RzSA18NtBiPCCkQhOJftR3EdegqgJSEACRQwOBBxgPAYY7wCwg+IAVDc7AFSxilPEYhatuEUucpGKXczAJBIBiTclwoyHOIQhjLCuEtXoXxoAAY7iuAJ2qcVHIahEM+7iPT1GQ49/DJ/4pDFIQQ5yGodE3yBfhkhrHNKRjkxfJNvnPve9Lxv100Ym47dJbeAsGl2qBSggQbQd1sYFKCiUCAhVKAWWAAILoMBxHhi1pEHqahREAXs66MGDpABr7EEPenj1gm35gV6X2AQnJjEJMjXiErDoBA1w8EIcuP9AhkKbz0QOwoIYTrAEFygUoogzgQlYwAIXGKIFfiOALH6xi+98p+oGMLwDGM8BFTiiBJ6igQl8Do4asJGOVqCjHNEILetilydWQa9GQIJ3jDAEIwYRhX/uE3KSW0HkaMSBqMhAByGgxR6/9z1mANIZzgjfSV22yEc+shrTqEb6rlENmtbUpjS9Rk5nWg2d5hQbPd2k/LKBDflt4xvYcAUoYkGKSSzCgBiwQG+EUxwKGNGqTZOA1GRZy0JN6iMjsAA5i3jEIpYzRCXYgAU+8BJDOWoCPzAjvR5hCEOYUXeZcMQZphAGbWUNBxYiSREicrYPpsc5CrGQTjyATnNaQHH/+rGABIJDTgo01pzk9EDoQLCBtKAlRzk6AQ16spQanGADNICWT2zAgmR1q1uohRYIYCvaFdAAXVM4ww5mULAO8AAWqajEJsikO3s54hBfyADkxMIuyJ1FcjTSAAdO5IMxHGOPKgOfylR2Uu521xkr4+4zWvYMaTzDvOQ15DMcCQ1oUMO97r1pTXuq0/hdI6jbuC82uvELULRiFZVIhCISsIAFGKAABSCAAQa8gAQgAAEJSIADlAiB4RynUFuN1Agi9VUDF2DBEi7nAF3I2pDUpJZGXIEhFMEIRjxiEHSNayqA0Ykw0AA9zbGlhXCAVg8w6EPf9MBao4ZOqyEKnTI5/2tGXAITJIdIJkfpyQxA0FymLKUnpU1Q53wCWyA8iwUb0HJPaDBmadGgBzvoQR3q0APbyiAEbQAGKi7hCTLGyHYBdoJyp8wuz8qRR0+Jig90AIjwNUO7JUVpolX6DPCat7zPYNlKDanIRdK0pYd8aUxfClOczvenMtPpzLaBDfuNOhn9vYW8JOEHC4AVAsGpKnGMOBxGfYBR4LT1kKsGKa+WwJy2tgBMzLmBs36A2MT2wHEwMAIjasAPAW5xH+haV0WgAhmyMIQUgGDaDI6ktAtSkE/WutghRxWcNSH3SRZ71nW/BCOhM/II4N0SzYXVnIhytzmJkiBM+aQGNq5BT/+SxdqfIMUlLcnyTxgUlGRtYKCGAEYq5gyJS5hCFTFqhCJ4sBQ+AxSjPUpLHXUwclCIzxnkFS+lJblylqMPGzF7OcyvoT6Yv/x97Lt5zt+HX5lFYxS06IUoUdGGNihEssLhzXAaS9XeJH3Iuq4lBoLckgtsIJyMDd1ZS/ySpCEKA66UgAbqcIgVS1TaKm7EJooBDEtQweBUi0iFGHQSYxOlBBs+p6QO6BIQjeAi6MQIosxZ2WFfoIiDP+JlwyoBCVPYqkVc9wRvABQwmxa2HNoAt9ldoBL4pHOsle0KJlEMOYcCEqiIRTE80dBE/GByBR2o5NoSghnQCAQz+MEYbhH/DZbH3OU3r7nOhT984s8M5i5H3/hO2gxjqKIXqpgzJ2bwhMhWlcALCE4+X7197lu1qlOVKnGevtjhgH9qR2YsOBkFNQnUgRH0ssQj5M/iRVRiGMiABRtA0AIKQCACMUiCDxgKRikBqZsghfA1ItswvkuBF4CBFoCBF6gQAvmxkCiUBDkBeSuBIvCJFAiXAxkJmEgB/KiIHIgBknAQB9mAEcsJJECCyeuIbVKWZOkBIAACKkADI0CXVEAGUkChSlCFWIAXSGAxMqABHtgBGZgBHpiBJpwBGrCBJjQCZbGBKHCCMUCG4Cs+4Vs58gEkvJgLxVAV0OiFq9iKjjGFUQgF/y8BE4wzEzWBwzOpBFFIhVBAoUQYg0JgvO0jsFe7qlkzP/ObJahhK1a6uqiaAPGLmkiRGlyrmt6YADWQBEqghEwYhDRABBajhEqIhWYIBkaggRbAgAiAABywghq4AVuzGqgaoBi6uiBjKw+IJatBCIi4iQ9hAVaqNwtIK31LgWELnV4EpxEAnaXwgIrgIRSgABRIAc0ZAYcogRv4GRuwgcSKiH+jxjG7wTAIAypgwhnABWTwhE0YhRcxk4ZyBEOAAhrYAR5QwhkIAR5BFxqQwhU4gSZ0gkIohjAcQzIsQ6zYCldQBVZIwzVskTZsJolJEzhUkzZxSEDgg4eUSD9oE/8/0IM5wMiMnAOiawM5mAM/MARHoARUEAVRKIVJKARAsIMNoDAM6EOmk6VY4iqqYSVeuwluwkmMuLBkq5qb+BkU2DtDYZQJ2AFHmARLsIQXQwNJeARFqIRRkAtR2AFZNCKUAIEvCxFUEsDJYyt7ayzNiboLqxqZOKe7M5SoqiwjgsWo8QBygpwKcAqAgooaWYrQKYEJWDIEUgEMgIAuiIRIEAO+OpyKYAHCTBYolJbai4pnYpEVqYSKmQRHSISBUgs3A5K1WEIe4IEnmAEdGIMyGAM9SEmGZMg2+QNAOM3UdMiURM0/cM3XdE0/kM09oE3axEg4eAM44EgzKAPQhIL/IPiB4NTMb0wXecwR5XKjf6mRDpiBMjiEUigFQ2gDPiiFOkhEyYqABoo6rrIws2yrAxoglEgQBiExC9RFDbvFGNKwCdKw3TCiCVgBRjhKSviBP1CDR5DPSfAE6wKGPQABdYIApfinDvk11tqJXAxGBWLLm9Cwl2gsswrGXrwsCdAccjqi0nGKNsqXfKGcE9AACTino0GaCBCCT5CFv/zLPEgBxjMdCOgncgmDOtgDOACERvCEVvCELmGRS8A4SFCE15RNPpiDPdCDi4SDOYADN9CDMRiDN3BSP3gDJIUDNqDSNCiDL8BSJlACI9BMJ2xCHlkKn7Cy0FEu5UqeDU3O/+RR0zVV06sSGAd4AOMxHoERmOVsgz8gOj4oBlFIgw/1DbQ8pwoDT15UIFa6yfJEVKCQFEkpsQrMsvJEFIdTBEvQBE7YAyo4BEpYJv3UhWYoBkNYiiJSiqgwiwwpOIZTCs8DPSvbLD3rgMrhkRkcMxJDLRtgM20DgibQVd5k0jJggzZwg2DdAzWrgzu4gzwIBCFQJRIIhE/4hL9EhCFwJQMQgGoVgAEQAA9bgM3JgjQYgzmotlvYhFDgEhYZk0oABMpxIzoVmOOJ0wdggCaiU3d9AO4rHSN6AKuq1zc1nX71136VUyaK13glHuEhHtdB2IR9oihi2IQNHgWoAB5wA/9DiIZiyAR73IAJgADBs7p1G7dCkYms67yjcBxVJTgxDZ0OQbYNYTgSm7uZWIE/qEROoERJsFlIsAROjIVLMIQ06IETqIEzENoyoAIqqIIwQIOkRQM1UDOmVTNj7QOo/YM+mNo/GIRBsFqsvVrXHIQ+8Nqv9VpjvQOPlIM0kAM0MANeZVIg2AFqLLONowECMgEMEIK67QIRiIC8dTB2CoBqbae+VTDhaYAQYARNQCFTWENQ4NF4WQM5JViFBZ7IdVjUMYAOOzCGhZ1qxda/5dzO9dwsaliFHdh4ddc2IgvJ+YE9mARgKIZYqAQdmAGxyLylILGf2JYxCyYzq8GidRb/JKiCo01aNRDepxXbsBXbOwBbrxWEPhCE5lXekOyES7iEZXqESWSmS5iFtkmFTogEQugDRkijq+3aPhjWOpCDYHUDpeXGJkCCJqDGb5THc9GRVy1TyPGX5EEespAAds1XybLXByidBYgAERCCQCABvYUABCCABbZWv+XcbJ2nCjACPkghO1RcGNEBKcIieOLgDvbgeOJczB0AhH3Y0ZVX/q1TNM2Xt+AtHZEuHhgDOCiETKAFV7gFU8gESngERKCESJhESqQES4gESkRRH5a/HQbfQ4AouhLfq/1aQ3hiQhCEQVjer70DYlWDNEgDNUAP3HKDIPYEppwESRhjS5gE/1xIBUVwAyhQigo4i+QSi7dk07HYl/6FUzpdouOR0zwO2D5WgAb4Y+IRZIRVMAQjgMvF1gIQYBKo27yNgAVwsAJAgALIVgKw1s5lJwEwgAbQgEP4BFRIhVJAhVIIBU5oBAbY4ACQHdlpJw2WIihiZdAV4VleWCiCXNcx4YFl1xVGCx9RQh3ggStcg2GO0iIFhEFQkwCTTKOUXhQKhVP4kkpQhEutAiA4szGDsrqUY+WJ0z725nadU3A2WAVQ2OFpItRhAIExBGZyBEiQBEdQBHqxlyAIgQwwogUYZIUV4c9V5Q/253/eIgLI2wOOgANmMAg7sAKwXEtu4Ia21sp1AP8NwIJHYN1TKYU1kAEGgB1cDmfGO7qNfh2EZYDWGekDGF16RSjmka61GDkfcGkfuMKGKVKKBAQ4DDAzUoSya+d2lmdI2FQxAeoXQSYWceY1ND2FuVTTghzOcpyzqF/8hdeN9uapdtxxbp3KHYDKrVyIPQF8rqcH8ANNNWOfZiZIoAQdAOTW0eB2Aui2dusuwiKsZp2NJrCCjgAHw1sGU4AE0OrKTWiGZmCHrlaFVgAIQIJP6AQl+IJP+AMNWAGyEIsVMIIjsIGkdQMZ3YM/MISNLGaJ5AM4rGmb5h27UsjSNu3TnhiKUe0yYag5CWoYYZGL8ZI4WIMxMAMqsIFWVS7/scpQfLqqBoDTkv5jdhXYfF5YfpanKTLpGTDrORvqcfUEHtDoKAqAWa5uV4YdeZrl7ebu7rZljs7lEdVbBHg1fB4eBXswvk7ov7Zkhm5ohU6ACciCDVAwyHGACdAAG4gETHDWT4BOkywFOlQRSDhXMSFwAo+enl7t54mTM2lw1IZwiVHt15ZtUNiYV8DwXOCFDd9wYiCGFuYnIwLufw3Yft3ff5ljNkVhPBYYN9WnfQIYyWnHN6A4XECMY5CLY8AFSRiDEKARgEFhxxVyge3jXVZpsPAol2bSNWAYPWgT3oEeepGeTUAhUkCFVWiFWLiFYJCMXoAFWJAFQnDkRy5v//OGsAY7c8td7wVm82ptbwODMCWSxd/gawUgBGdNhVRA7E8oSVHwhEuAFzHpkuACE1B47UMH6grvko25cAx/BQ6HdA/38GSgdJQ5NGZ4BvZ6L2qohqDKpE/vhlDvBm/wUrcdMzTrgR5wWxsEAiiQAiogA6E9g2BlgzOg0ls/AzLQdV2HguAMTmZ5wmCnR3r00iZMwl/+gTUohDKJ7S8RrkSQTUAwZkCgtnZeJkvIBBQySVBeBViYhVnABcoAhsZgjMMwlRs/ksRAFblQhnQ/BpThHvHQi5IijH0EBjxQYBIgAf8jxevD5zMHeL9eczZ378FeYAibZAjwghLIKkwohf9UkIWIl4VPQIQh9m9SCIUrcXQMh3QOzx5J355Kt3SV0fT34ilPr5lQ94aVX4d1gAd4kAd5mIeZp/mZf3mYr/mYl3mav4d4qId6cId4oAd6YIehH3qgdwd3sFInYJYeYMLh7NKoH84fcIIn6NU2KANgZQM3OFI92AM/sFq6WrFH2FRszwRO6ARP8ARRSHsAh85UKMmH7/ZuH4U0rHtTWIVVsAzKmAzQWJtgOHd1X3dkGKnCL/w/+p67EKnDv65DMzSTOrlrmIZoEA9g6AJLRgAROGC+VKIAJjCAT3OBPzCCb2A2p2QCQGgCgAAE+wSIj3jMwAQTIMUhwIRiaIb1+Qb/nY/53I/5muf5ebgH4L+H4ceH4Tf+e8CH5Fd+fOiH5nf+53d+f5D+6af+fvAH64d+58cHf8gHfvB+7/cHftiHfNCH7/f+smMxnm4RZzbJPHf/VMj7LwfziMcFWQD3+/92y9D//a8M/Qf3/QcIXAJxwYI1a5bBg6pYuWKlahVEXL10UawY7OKwYcU2HjuG7OOykCKbLWtm8qRJZyqjsYwm7SVMadNm0pxW7ea1nDmx8cS2bZu8bdi6FROC4GgEEl1MfKDgAAJUBw4WKFCw4GqCrAkMcC3g9WsBAWIFBBAb4KyABQ4kLLAiK1UqWbKAAetCIgJSFZGQYfv2TR7ged3m/xGedw8fvnuKFSdujBhfv8eSIferbNmfv8qULXPmjJmfP9CgMZMuHbp0v8yqT/MzmPBgrIoVB9KubftWxVu6bx3cXcvWrVq7dQuvZdx4rOQLWcVyVSsWLVqvpruiFasWrV25cu3i1f0X+GHEjJFPlkyZsmXMmKmEOc0a/J4+t3Xr5ve+X8D69/Pnj/8/MDEcdRQJJIggwgUWSAAVBE9NdRWEWiWAQFdgjXVhAACcVVYCHggyl1xzASPLXQhEEEEkgURQwiPA9OVXMswQxphmh032WGSR3bjZZaR15llqQX7GD5FFmlbaaJj9WJopppAyCpSjNHkKladEWSWWWVoZJf+XXWbpyimsMMTQdGVOt912vKjJyy/EELMeM8qYh94z1FCDUzbZ0PdfYPoVNk9//RHW33+FftNNT9aw5IycxhDTyy4EpYIIBAQgQAABEQhhoAglUDBBg1JBaNUCEnI1oQFfYVoAARdeWIABCpwQhhiIfBIiXZFEgCmBQhhFwAIpfIJNNHEoA5g38qxjTzzzwPMsPOtI+6y01UrLDjvkaDsOOemkc8453oI7brjpsJOOOeqYg0665ohjzjnmlLOuOu2go069+Nb7zr78ukMPwPTUUw898dCDpZlm0oJmmmuC5ybE4xljHsXnoacMnM88M1M18F2DTZ4/iVwfyd14483/fYUBdl+gLQc6qDyHCoXNx9Jo/Eyc5rn5Cy+vnAIK0JVU0sgiRQNydBxJJ+0D0z7oIMMMM3wAwYAICGAipyp8YIEFE0gglagQUiVhVhVaKECrrsIKgQ1cwFACISICE4jVV0fQxScq4hUBBnjIAQg2ysKj7DzNQhuttYmTsw622Wrb7bfkijOut5Gjc3k596JTDriX31tvOZl7rq++7Zj+TsADE0wPNK3PdGc1eeapDe3alGzyybnr7o210MoDTzzNznjP4dAGP/xhxMPjjjvBAwZZYvLU9yKiPFkjDUmNGjPML9q90hCVQQsNSSNEF70I0nGkH8cYTLffdNM6MM3D/w8/6HA/009DfYIFC1TdqomuIoIYjOAEG9BABRYENrWErVRkM5tXMJW2sYTFAAuAQNckgIm5fKILVkOKUiJRoBPhJQPJUNY6BgePexgOWolTHOMe9zhygUscNpyc5Dwnus3Z8HKk0xy+2lE607XjHUZMXcDosTsZPq5xjSOHE88lLnB5K3jMc6I5iEhE1NHjXwFrh8DqoQ97qE5g78jHGcWoJHjwQmiLEFolyGe+8y2iEHYsBB3zmAhFKMIQhjiEHw0xiD8c7Wh6gMMbEjmG+o0hCI7kASRnwIMZgOAENKCBEyCpA0nygAb9q9pRLHUpAmDgBiygAQg0oAGvhQpsC/8Um6nMJsEJfuVUCViAHW4VCBII4G53S1EkukBCBCygEr8zRwr/wixnufCF1VocE8cxDhqeQxzgoGYPPafDyflQHfcyXRCFiC8jmi4faOziv4JnsIEFzIjvON0ZzZkPdHoRYOa45z2Z5w5qXm5d6WqHOfWBzyy+U133NCg+SfeOe+6jHutgxtLGUMij3bEQhijEIAdJSIpWdI99/IMhCCEIQQ5ikHyYQxv+8Ac/7GEOiXxDG9AQBiTQYAUrAAGoriKBFoQBDFgwwgxWoIEHKKAA/vsf2ghgABZUAQg0oOQGMiiBBTHIlQzEStm2EsFZioUAsOKKAAqQAAfEIBBC2FX/UroghEB8IpgkjIAVrCGPcbAjHuv4y/EO58xnrkOG0pxmNSdnw2sG1oad06bnvhW6zOWLiN4CZzvckY7I1qMd6jRY8Oixj81ulh/74Ic8zUkkzu5DH/pg52b7oQ/OnlZ1AzOnFk8XWjQW1IizzUc93BnPevjDHt84xdJCEIdErqG4iZwDcpHbUjnIwQxreMMc+OAHlQ7SD37oQx/oUAc10MEOdMBDILyrXTaUYQxOgKoFIKCAVA3AAGi75VMg0ID1GmAA9i3ApRDglbCmKlZAcIMUdtCDE4Agqhb4lAQmoGAFuvJBZNMvq2Y5wQEUIABhsdveTtQFvMniEyIgoQiA//GNe2BLWr8bhz2YSa299rWvj/trDXFow2/dEIfe9GFi07HYcuCrm489HfMiy7yCGSyJphFNkZKs5CUf6R9OfjKUo+xkI4nmSKXZbGj+kZl5SGMRbwjCD2TwUuMmEg6HLAMVerCCDVzgAhsAwQpmYAMkVIENL33CCk7ggKotAC9HXcBUD7ChswCg0BnSUFgGrWi0dJVVjj5AA6TgBjKQYQo0YMEJPGDgCXBtwVSNSthuqRUIh0WCF9IQWghANbwEotW3+sSJTHQCueLDrin8HTwApVcWu9ivgMVhYLVV48l5k7Ha3DFi71UuIQ/MHZYF2GUza+XQLLnaTEZykaSsbf9+/MNIpulRZlLjZH/gQx68AEQboMADGTQSzPWj3w/AvIIKKGAAaCnAARTAAAyC4KlPe8AAzHLoQhO84AUn9MErrCFDL7ospQ7rVxXwACnIgQ11mEINLp1pD6iSa1KdKlVfiVWtRhhDAiB4qk2EABK4em4DWkAjvjGPfgwOMNi6xzpwvWIWM3GGhh2XOKQ5bHEUW4ebC502SaeOH+uzHpJlR8GwFTypk7OIVYenOfmlDq2PU7e05ZdubWvErp+RSFl/Rz1wmw994HZ1msGHP3jbj3t8AxSLUMQeTlrSlfph7xadwwwYYOgD2JcBD8hAv0vAAjWcwQZQiUCfRXCXpJT/KJRoE4CExKpfBDTFKxSOsATB4tWvHoUrDqACGtAwhR7UANMcR2AFuubpBj+oKg4kuald9SrN91kpgYhEJIxyFAkYQx6HqXlmAbPrFO78mdv6KznAIVgZR46Gn0u6YndYDnCgo3KTbR606xoP8Y8/HvbAhz3IqdsibvGdsQ27bb/uToW+s/7uNDttsy7PtA/stJE57T6kWDIUTSKclB7snUr9wSAdwh/MQQcEwABUxRh4QjGYBDLggiSAQA2EQRJYwQWQUJ9RnhDYBV6UXunByubxCgQsgFelilccBVjU0oBIyAmoQR1sl+rVQAuwAAh0gCpFlQbIHsgx2INESFaI/57uiYV9tVeqQIDvBQIJRgAF7MEJzQM+qJA6/Y5+IA7zceEzOY4MlQsVfUv1kYv2IZ1ifU7pONuPhR9mRZHB2AM9DJHpTFY72GEd5qE+gdGQtZM7adE7OFs90UPZgZbYudNt5QNiuIMYxYM8nAIgNEIi6AF0KSACqtQf3YENaMAKakAz+MWLfAM2zIAEJMEN0EEXfBgGQMCJFMimRADVaIUB1E1SSRBUtGACfBVXcAUClI0BkM1VOIAaCAJ29UEdhEEVFEHG3VQHnECmHdAqKdiCgVoDZZULJqEALCEvmsiGrRUiIAImZIIrdIM8MJM66ZryFU/zXcsTaUvjeJ/30f+QOIjOjWEO0pXON5lO87xhXQEMHEIb6dRhuVROO7BDQZqLuRxk4+jTvzBkPfUhZrlD2eXD1h3ibPEDwdhDicnDMxBgIcDBHMBBAl6iH/WBnklFA8SCMYCCD9BCNyyDJ2TABKCAF3yXEJiACGAACd0F1ZAar3RVq/AK5FnKVuziAdgS2WiFVawFIkRCHxACIRijGsyUUwWVxhkQNKpSBUyjg1SjLLKK7i3h5+FXK2KCWYqCJ4DCMpTjtRzPfqjjOjJOOzZRGYphjInD6CDWGW7O0n1fkY1fPxYMkWVW8HhfQYKhEzFOOqiDO6gDOxwUO6hLQA5UbFkdITrbGbFdEZn/0+qUkWbpQ13Bwzj4xSsAQiGo1B6AZAIqYAL6ERI8xQJ4xQEMVQDoQCJkwAFIhQkgAh7gAR34yuQd1SgBpVddHuhd0Az+YlZUhQIk5S1ByFpoQCekgiEwwiMoAnZtVxWk2Q7YgA5iGoG9WYEhkNckmNdY1dgUZcmNhVgmFTFFAB0QQiZogid4gisETl9hS83xx4rF5bmQizSBCxOBy43tWIxRDtIdXeg4ltSVH2DGg9OtDsCoTjqgwxhSDhhqyznUixAdFEJJZr5wqDiJKCDKkzsRjGt1Zm/FAzygDDYswhzsgR/owR60wRz8QR9M12ruQR2wwO0ZAACQRQAQnn0t/wAGfGOrQaFaicAKehWm1GLaPCnoweIMKiVzPqfYBCNUVAAPwAIwTAIjSIIkHAIx3oEaoMEZVAEyKuNVEth4BuEEkGfIvdJXTlA2CmlS/aJ6OUEiXEIogIIw+AXzyUOzOOJb8ho5SI40fYtfEWixLRaN4ZC37NiO2aG5FFmD1tWQuQM7eJEYZQ6lLtZdUs4UncPoBOSP3eFiJh3ZZZ065J/+mdM++MP43dUvxAEfyEFqwkEbpJSOrpQClgIieMBUzCKELYALUpgJAB8U/p6SdsEK4heUdlVSXZ6lnIj/lIoDZWkwNkADgA0EJFgH6IEsHEMqUMIkWAIjMIJI9cEdbP/XdoXBTPWADVzSDIBngWVlBeyrBDwANWKFfj3pWGyIWHyVABhABuiB0GyCNdiH8UCb7/xOtagjO1DTOWALFGXLNC1mj0FqNY2hjoUqOkzOZEGdPxqkkAkitkikO9ljqIbODRUWyX5sN+kL54RLHYZsgt4L2BFJ151dPOHWPpjDOMDDNlTCGCAXHMBBGehBSuFoH/zBHfSBIQADMnxCGFAA1YgSAjzFBxCCLiXp70VCb9IBBpRKqYnSqrTKfl2Nka4gVmgr7TVYuCaYBciAIeACMgRDKFxCJkjCIyACVBqCu96BHeBgFSABEACBDdQrvoLAm2rlNIYKVoGlWKCaEtr/V1kcQAcAwiI0gi3Uh6CuQzvUQ/DsZ7TAJTy8Y/XdYbdU7Mbmy9HJLLkcHWKJw2PVVRRZlummQzxwqsDo0zlwTjnMYw2Ny19Jkzu+47jUrNL1WEA2Vr2sHRrpS9jlw5CMpjLEAY3uwR7kqHXxAdRi1x1gwkcgw4hgAiHQAfsGAjiGSIpsWKsxqyDgAFu4V1ddBdtOkMOxov+IGrdC51Sg5FqIayLAQjEcgylcgrqKFDGylBzc4JmGwRQwLguwgAecwAh4gKbp61YmGINtq1YJHDYaQL41QAV0AA+MgSs0Azla4Wm8XWLcA6DEg2JAW68l6j11KGSSYeXcJbCBi4GO/0vGsgPwsOjpsgPjBA/jAE/j0APQAdvkPJ80hQP0zVDzPq/SfU5l7ouJwp8RzSqRjEM3gMIYeK/33sEdSJd0FWMfCEIpYAP6lgLwRUJTtlpT1rHYjm2K2AELrCD+hgWseEWqCKyeMqnYzC241q15VoAGyIAltEIw7G0odMIjXDIikBTUvisOogG9Nm4KWJIzOmMqaaWcUq6ojPDluYpScUW+KUADPAAHAMIpMIPMWeGOXGGuFY7wFPG5YNE9keoUaSgNTaqoiksRHzGL9mfxLDPwDJb0DZsVV3E4VHM1c8u2JGrzqmHSOW9jbaY+8AMYG9Fn+AM8QJQP6EFyqXHeRf/XHgxCMWYCTxRD3kzeTnZBHjfr730CP9dvepWKWLggrMiiASiVVVCACcBiqDDIEE6VNKrSD74ZD3jCKugCMizDLISCJQDuJR8CIPmRRqFxGFBBGKBBE8hBH4RBD+zAJY0y5I7nxykQVexi2yYVhe1irOibLMcBKCRD4ATGYVgGXUXsOlTo5XhLYuZntgwzFsesEENq5HALHDLftKQuXIIDVmP1YFmTNVczN3S1FT8fsHVTsjEW9LZDFgnRO4Qz15EoZvxDPPyWD/BAcs1BHazxSfGBdE3tO/PFMqQCHkyeYINXJPAzJjQlP/NzIIzAVDlALioVMGIVLDsABcSA1pr/pzTGacdZgAYc0AZsgAdA7gmsgByIgirowjE0wzGogidYAiUALiPwUWx/9N7dYB3IwSBQgic8ghucwRRUcA/Q6yVhWglomgVEFStNhVWoZ4TdtHImgAIcwAEYHgeMQSX0QjJUg6BaoUaOQzhwA8r8halmDrhIkxFLiwz9Z9Bhc2Bp9eQMsQ3RVRQpceJ44eHEQ1ZrdX5zA3ifzFdbs+5c8zjUmMuKjln7UDucwx0quKuSqBGBRj/IQzXEQQjMAHPJwRxE8BpH1xzoAV/vwSw0A/riAQIEKQmUOMuxVYgkdirwsxhQAIwX63MrALiKylpMwAUIgQhQAGd39nF3Nmhz/3AGZ7AzXvApDYJp60IxlMQwhIIodMJGSwIkhCkkOEJsKwIggdQgUUIq4EIqDAKPyoEbuIFMISMSIIHjjjJyE6EDCbQuKmd/TXcDZID8NMIvSIN9fAPvnK6tKUvyAtZhMtG5kMMVC5t7D+9i1Vi4PBFdvZAXdiE85HdWcwNW87elg7dX97c3WPOA19jLkrUPWSpAmRMdPji5zQMv6EAHkPaFM9cNJhcfpHEfcIJHFEMkiECJm4gAdAHwhQhcvIVcfMIQtNkFrGBWCHC4eo3X7KsFYIAVqAAGELmbjrKRV/slNa4NUAEjlIIqzMIwIEM0NMMskIIndEImTIKYTgK6c//0IzCCIfCRIoTCLBQDMDjCISDgu3LyVCKBMtZA62VaNJ4nVrm5LTlcNmZFAwQAA8wyLTQDfZgMfwPPClkLtjwWUj9RxRI69AldVtsQzDr1omOsNKXQxDYTpEs6OPB3OHjDpbe8pufONEuTe0uxxeKhPq4WQ+rjO3jWPWjDIoRACHRAGoy5G7h6HYSkHswoHNQBHrTIRozIJxQICSD2J1hth90KXchCJwxBCZTACGhtVjyFNFqAB5TACWCaD25ACdCBFZjAKdFAxtUrtgc3ECBBDyABFWwn6u0BJZRCKkhyakcDMmS0KHzCuVuCa6Prul+nIzyCJKBCMCwDMkyClfP/0UeXpLvi4Jr+ewev0tdMBXODBcqx54YcAAfEwSkow4t4A12pQz24UMWvaveZy1xq/F9Zk3t//M/BI1KrozNDeqRLOsuvvMsXP8wnbzhEs+TUJbl4n2YBTJCZDj2Axjwkgw9wQAdkQBq0ARsUvV2/qzofkh5kFyJ8CF0AQzHIAiYUdlvJAjJ0WFxYrYjLghXAQAp4PVsUcGefvb8XgUoTGECcSIGHTo4aQKZModKEShWHYcKgkahGTR05cu4Y4lRqFaxexZRFi1ZslahPnTpx4qQpkyVKkyhJevTo5Spk1pZZkrTzEaOeiBgRIiSoT587d+qEqVKkBYsTJzxsmCBB/4KDBQkMZC1AgEABAF8BBBAb4GsAAQcOcIgDili1buvWsau3bhzdcePOnUuXLi87dubMkRM8+K5gcYfFlVO8GLG4venaRW6XDl48y5fjwdNc2fI8cJ9BcxPtzZto06ZLcyO92lu4cYYbi8v7mHZtyO7q0WMXmVw8eub49ZOXK86aGSvkwHEDB46cOs/r6JG+p08eOoIkzcKFDJksTJ/AyyoGTBYwYMWQNcM2khARIk0tOGigwIGDCRM8lEASRg2aExU0mCAJPIg4qIcpegACCCmkaCgiiSRKw6I7FBGllFRgucUXkJqJBhhRUMokk5UyiUmmmR7ZaZJisPGFEUccef/EEUYUOYTGQwwZxKjn0KACCBtOAGGDDTQIUL75rFJAqwEGyMrJrBJYQMoFGqjygQzG2IQYbOSRZx58+glTzDHFtAefwch5bRzXxmnsM8UQy0svyCZLxx13LptHT8vggWsdzjwD7bPSVjvN0NFYa62ww8CJTc5H53ysHdz0cWfSePxix597sFkkjjF4mIGNUZmDA7ropNPjKDU6gWVD9GQBLzxZyjOvmGa4QwYYTKxIoogaNqhAggfsA8GDGiCqo6gzVgDhAysI8aKKM/qLMA033Dj1uaOKGuQRC1FZJZZbhDmmQ2RmEcUTTzJBiZOWYkLxkUkmQUUXTyCBRF4ZZ2L/5BAcdTSqPyp6oMEpIQOsqgEIksTqyYcNUEDiKalkoIEHfKiEF2m+meeee/AJOUww8fnYZHL8Eizlu2JLrJzEZMsrsr30ckc3zC7bDNB4BE3Um262MU2boQ9VbbW71mTzNTSZJkfOvSZ1R5+bdfsTn3mIieONH3gI4YwzSHXDOYrgmEOPPZ4jA5Jjci2mmO9iTQU9YD6RJVdkiok1CSK8SKKGIDXoAAQbuFDjjj4ImckQKFZAwYpI8niujzqQ8uOPy/8YRHPNDTHkX0UsAReVVmLRJZhjlkEGF1TWRcn1TjLBhBITY5rkEkjonWQnnk6cscbOdbxDjjSqAKLgID2w/4CqqRheQGK0nCxAegPQkljiKBOw+EodGnFlmW269BhMwET70092BssUNtngREwxdNBRR5125J/fHXY0w3mzePaMR5zQUPOzoIlGG0VDFGnuEg4FLq1pTLMNZOhRD79g6k/z+MYmPhUqGXxtVG/AlhqwJYc5zOE5ciiDHoYRjWa4rRiIAA8m7AaMSEzADm4jD61kQYQb9A0HNAjSDICQBjnw4Q+ISNFODOEGKxABE4joA/By1DnP/esQNVIEI7DoE02IQhSkCFcrZtGL0wUDF7IoRSe4aJIQxQ4TbXQJvSyRu9zJRHe989e/DNGHP+xBDRGpgg0MRiQLFIl5SVJAAv8cJr0CoOUA14sSlBpQAQDNYAyV+IU1vtGle5imLuvoWFzSxEDBPAp+cSoH/OCnjnes8h2RwVnO8tc/RoWDgNooTTe6UUuiFe1oCvQl0grTNHbQbE6Z0kc8xqGZP8nDGYB4wxh+IIMNoiENo2IDttrghjYkpzlyGMMYRhENa+hKFoGIxDmbSAQHIGABiMAhrYBBBxUQIQlhmMIZdgAFPfyBD5aA3SQsEVBF8MEOVjhJ4rJ4xRfFCEUMRZEkOOGJUHgxFavQji98AYtZAAMWICrFR9XluhF5IiWeYAm9Zkevncxud5KAke8AhrbnhAEJPoxKVAhZlfpcBZFLapKTepr/gIk1wAEaOAADOACIUyjjGt0o4NC80SV5+Oku60DTbNIhv5idI35dnR8rW5knPfWvM2NlFDiEdstcDo2tbCXgAZP2S2AKkx2Pus399GEPdqyDT/I4RRzaUIauhYAN1EzDtS7SBsViS2xycIIPIKEMa4wTGIiIRCC6gAEEbJYACCDBJyJBq08gIgYmcAER6KAGMsBhD4MoBCVwAYxVjEhEl3AEIcSAiVJIYhIpmklLgQvcSXRCol1ERUVhAQtUhMKis1iFJ7gI0lCsi6Qk5QRxRdSSN6L0JXPcXU9qVMVDTE4NU6iBUw5GJA1IAALN46lWFFkAKMkXSlJywFgOgLFK/xBDGtoAGvj05Kfzoc9pj5kfVuUXP3Wg8qt4Eque7jFWj33srLQUDS63sda27vI0vVRaMAkTzLrOJjJ3kgs+6PGnzDwDEGs4gxJkEAKvQcRah02DYt/Ahm0ywQyAGIY0JouMSCCiCxFYwGaRvFkBRIAEC+hsBExABDX04RF/AAQjIMGJVGw0b56w3SUe0QcYduIlb5zdmc8Mk5ecmbihcPNHUxHndZlCFbCQRSpKkcYuhoKL07UuSkiaEnhRwiVoRmkdZ2KJkzCiKGpYSg1ucN4SRMUC92HvTg+JlfhmZSwCGID0BlCWAAwgvyFoBC3Uk8k+CRgu6PMLbSITqfpFZv/B8WvHKjEj4QjPg38TZpQ4FKga0QStrQY0GgLXlECkCQaYwaQZndoxwTDtFR7feMU30/CEGXAgA1SgwoNsbAYzlKENo2pDGrgAhDfcQpzWiEYnXkABCEgJAhFAgADAYhYBCKCzUfZCKaxxjHyhwm3BAAYucAELk16CEo8IbSkuEVCXSJziE7e4JUwqUT5/tBTs2oQXL5TcVIiCz2kEqbqyC+h1vaviKQXomSVhiVKUkRKd6wNFpuCr80JlA4NMGMMawFNNK3IsRSdLWZh0VAaEQKnKwEYmWW0XTPFFL7c+x/zoJ7+Z0ekd86OHb+gRdglfhh56OisAhVZAXpImgAj/ZPbSlmZXqqOMftEOmT/8kRt5WKPFPxhDYMdQBsGL2wxoMMO1FmtNNwziD4VYhUiwgYw7UKW9EbA8AsyCAMsz+d4EiEAgxNAJa2BDFY3YiKuCEYxbzIITk3CEJHwSZ0oogrfB3V0dVUqJTEhUoqgQBes8cQnonhxDeKYudNNYXOqqZEQRNWl2Z2cJRSiCJpQIxUZxkQnN3bwKNUBCDXxIpApMoNKXTpKUhr7v+E7PAEJVgJSq1AAGbG8R3uuGPEwmMjKJaR9al8w5XuPVvuod8qEACVAfdi1k9MEf9oEe8OHs0I4b1M7Y2M5nfAkcwuHtDgOr8mIc2EF+0oEd7o4f//JhHOThF74p8MYgCALvC76gDMTtCyTCDQ7LDfrjmvZJDyZBnIphENhr80ggAgQgADyPBIzwCIOQBMzpEAjudkQBGGYBFmJhFjBKFSABRhhBEurmE35Ld1SqpVJKRSzhEkjOzUhhulABFnAhuvKsDeMszvLM5DAkCrnIE1TiXSjBuhguoFzv9SSBEkoBPYrhEhTBEP6gDsqrCqgAkIKESJLH0oCuPq7HANZv0xBJqKbEARRAeziA6UCBGe4PwvRv/7IK62YGZYYJMsDKAPPBHiZsH/iBH/bhYwRFUCzM2A7FZ47NNUIJaZ7mZcbBHBbsHESwH/yBH+iBG7ahEXwgCP/I4Bmh0dvI4GvOICLS4GvQoFrQQA/g4A/0oIx44ATqLQJEwN72TfNIQAi64AjXUQjc8ZwGARAaYRIgIRVwAaNWryM4wRFshBFgCBZKBCaEK3dcjtAwjvcWbjuQoaPqEEQ4wSUy4RPeMLko0vdIgRRI7g7f5RI0waRcAvZSxHZQIT2QwfUKkbwQsXgYEQQaUQPGj70uzXmUJHrWr/0ucUokZv4eYHsaYRei4f68ZJPGATfwDkwGA9rUQRjVQVJaCazewR7s4R7iIR/0oR0ywxtqETSCDRdzkTV8aYGU7S6eBh3E4TWoLh3CJO/YoRuMwQe+KQic8QzIIAi8jQqgMQz/0gANsFEiOKgMxmAODIEGNIACIgADyvHe0JEdhcAIMasLukAI8AA7CgHLJkEUYGEVbiEYfMG5PAGLUCQQUyGlAqog1ezMLuESmg8P6WUWVgh2rssTdIIfq+hF5iW7IioUSgEjjUtdNKE3VQI1M0F3jggQ1cMX8sVf8uhw7qCPkIARfegEhiRA7mMCGMYqLrGnNg1KEEliqGcTryQDMkAG3qARVMEYpOH+skHtxiEe7KEfWi2rJMMcJANqLMUp66EeGJAEzQEevKEasvIzvpKXTOMWVSMcSINNwDLZgkkvyFJlZgPv/sEcvCEbKiEExoAMoAAuoWAKyCAhEoIa9ZIa/0X0DKggLzeg8jaP35gMCdPxMUmgCyLBMbsgEPIgEq4IEiRBEzRKFcYF4WBhEmjEpTLhPERhEjahNzXB+ZYvSVeC+S6BXmbEEBwhE2YkpR7BEMJLEV4PoCYhNXuTulQBGHwhFfjMpJgU+m6PE9DDE17qX4oiOesADaqgB2wAkJwCKoqEkAppSq4TYmxyOzfRSirgqB6AA3RgLYjBGa4hw7zhS/oBHvzCUm6tlehBUiOjKVmpAPOBH/6BH9qhLq4hGSAQQF0j2LYSFxPlK5FGaUbpHACDHKwKFfHOH8ahG5TBB2RgBaFgV4PgnqTgQ0V0GkVUL6dATktg3hbA8rgCHf8dczHT8UXXEUYDYVoDgRAiARMMQUYcQUdnQRdiIQ1hgRNehBFgQhTcBhYu8iL1rOTSiBNO8yMhYfoMwQ/8YBCw8IrmhdCyK+IygSXGkBMmSg1xQRV+DxUw0g5VgiWCc7smgV1wR0ZqRBAE4V90BBGVogqakwWcIioQ5iXrY6fQr6cgxmEiRgHiTyySbv6Y7hSSIRsyCf84o1InJey+TlJXaVJXyQBjMR/cYR20IRleYTHgBDQQoxZFAwPXju0GtFQTdJQAQ5Q0Je+84RpOoRODQEF+1UMZ5J7OAFiF9QyI9QQsgAKOjLNU1AjVUUYXM23X0ZyoNRC+41+wyBFIoRX/7jEKU8ETpo8yNYEUuIMh9Uxd9CwO7bAlcI+3DNISgpMSTrNxUxNgf68jYGHkJEpdUaEUUMESBsEQunTiYqK7HAF3TmT6bKQQ84i8+ohgaOA5n0K9XnIqPjZko4cSDUAACkBkE+AAwgJlU1YtQMEYrgHqOCMezCFTLuNSnTJTd3YtmYEXglZoy+EzzmpUMZBAEeVUuWGB5AqYzKEsYRVWzQHv4mEbnCEOwHNBpABrGWRrv8ZDofGeaKoGIKAAEKCzjs6znrVF1dYdZRRGL2ta4+wRqigRFOES0nAWolDh9jZfKIETSMFt4NCkYsIRSFdLdw/lHhJeLEFhyawlMoEj/4vrQt5wFUZuujZhEzSuuEhuEvQgCMrADfyAJibOXVHqD1PEJ6iPRmwOKRBRTn/EYO5USAQpYWJSJhNJevYtibvCK3bXdkmN1PIrY4gBk+RBZzIFf9jhTiY1H1ZxU/nBHfqTGE7hFVzGfaL3P23Reo3GULY3aeBumATDqtYhfP0BH+SBGHwgBE5Aa9X3niCEL+vgELMRB+QNyeztyVj0CJ01kYXAbbsAD1yIzLQVEiohFUjBolCBEnCHXoTPzVBBO0TBEOCgDJ6Aa3hgB075B87ADxQBjeIwuuQQQyjyMuMMFSyS5I4P+Uguz/RWDwKvlMmADQYBoogL5b5QJmhEh/8Zbw/Qpj8wdiWfAmGkExJB1nmOeInjCwHcj0ribyd3EjxDIA4g4ReeIZPEJy2NcVZjcZ1JkATfQR/wYR2e4RVe4RSE1n3QOI27Umnb2I2ZLTDiuNX8oR8sqEJloAP4GH2pEVinwA+gowbkrWwNOZEpmqKl1TEjExFYKnQp2XZMipMJjSNDwWBDQRH0wAl44Ae4ZgdUWqV34KV/QA7sNRNE5w3f8HIthONOrs/cjF2TDxL+4JnGYA2gcRr3AHSOL454wqF02BD3CClSt2BWN72KBECIuDqtwpqHrhK1eWICVf4uRpIqIANCwAcWgRacwZxBRkzwLhb1oZ1JUFPxAR7/qIEXcuEVfkFOzu5/pLdoa/EWFcgrv3KwF+jtBoOq+sGOmSEOYkwDPHQK4PKxPZQaL0INbkDe5u3eMm9F0dYdK1qRX9Rt8SAQBGFzs5BeKuE0aws4NaGYP4oSBgGaUjoIfgCmWRouabulneAL2uAPbCRGYq5dXFuniTtw3WX2/OANyOAHnLGodzWY/+AROIGLGC53fksmKBhgMKeHzwAIdqBOnxNh1OvnHKA6hS4BEIASt0KRtBMTnaebd3KsOUAGlCoZwCcowaRTv9gc6CEfAIME62EetoEYXiEXfqEZYmZ6i9ZN/pqWBpvtCJuw1SSYqOpqvuEUfEAHOqADelWy/z2cGg8HB37wyPhN85jMRdPRsz9bkbsAEQLBshABYAyBXC/B+dxVRF7iCmekENrgB6AAGmk7snO7w6cACpzgCXb1CZ7gyJ8g8NpgDyxnc7X0D8dwDCOOXq6QEeZ1lC8UGuWyuYX1GfWggBcuDFUEu38HeHaEWJ95dYMEBOA8Oi1tT88bAWqyvbEnE735mzvgUNlCsrrhG/hKH/7BA9mhv1eJGLuhee2aGbKhr+MkK9snKyOclhLlLrxhHI4GLijcTyLMGhbBB2YgBDIgCDIUt3/8a/cyDLzABMYRMTmbWj3bHRf5s9XRnDAhEm4kR1wrESCBRgZhD0b5B8qAtpc8pf8vVC4hm8gfGy5b+tmb3Nl5YLafYNqZW8mbPPAE75ueIAjMQAqYGxpT/Rm/5hnh8hnJbRC6FHbiSI5O5EbwqCiaWSLCwEcY8SkaUfwkqZCyWnbVm/2STJujRP4shuAvhqy/ab+m4S3gwhvgAlLVIa+8oa5zgReS4RrgAdI3UFAOY9IbnLB9BtMxPdPlONNh1dPlgRfiwAm27QHGYFczNNUPC0L6IwxQYN7MsQjZcUYxa21VfMWNEEY7ARPAi2L9QDrg4A3WYAy63dpNeQZmgAfKvUMhm7k9fApg2qWZWwag/qVZ+gegPuzFXux3YAZeugdMvbZZeuq/hgrwKdy/iQ3//MARMI7d+VA4e4JGfmeZEbGH23x1w1u9LKDS+D2rL/FJslmb01uoGGD+ujMnL+aoQmARcsHRA91ntSGC2oEcqsF5c6Et4EEfgollzqFlOv5l+JpUEyjCka2TNH1pHD6g4ULAK4HpZyADXB7VZd7G0iAMaAAEFmCdCEAAEpPFp7VZUxzo0RYPIgElXqInDmFz/EDY2yAFg4ClUfmUX9p4euBX0zdB0nf7FWQHAB/wy54GZqD8nzP9yT5UoB79zb7sp33+Be8LnsAFoaAMnh0KzqAMoOCoAYJSp06cMlmiRGmSJEmPHDlipOiQIUN/9ty5WEdNFSQ9bNigQYMFCBAd/zp42GDBwgQJEhy4dLBgQYKZBgrYLGCgps2cM2cG+DngwICgQBlwAHQqmbVv0JJp6xeOG7FTvH4967bvnbl06c6REwf2nNhzYMGBK1eurFmw4saJCwc3nNu44+qOI7dunFxy5LzdZcdu3bpv85IBemOkQ4YHY8iQCQLFMZk0lNGgsTFBQUwECCKQ+Az6s5AugQJ1EUJCCOrQrEUHwvTpk6eEkhwpMjQot589cNqUKdMYSo8dO3iABEK8B5AezIFIkeKcipQeNGbMAGmdxortK1iApHHixHftM3jwIE4cOw/r5a3/+A2ljJkvX4j/cBwkyJc0ew5R4uRJJ5pccpBCDP890hAjh0j0xx999HFHHWhsBMRyH2030kgnqbQSSy7FNBMCN+GU0wAjcpYAAAD8xOIALR5g1Big/MJMjdvIAw1VryjTzTz55GNOkOaIgxY66KCF1lpIogVWWmuJYxY4REYJTjjgzCWlOGKxQw899nw5jzzfjBKHHHJE8QQPjTk2xhi/1eGGGpdBMFNMEYjQWmujrbYaa6oJgUgpwAAjyycEFURJbYoUUghuf/ihBxxstCHpGWRMAR0QU2zK6aZkQAEqZKHmFwSnpZLaaaYVrooqp1Q8EUUU9NEHq6yzflGGpWSwwWuvZ7QxCCWeiCJKQZYYuNBDEQ3yBx98PBjhhNP/eQRSeBtocK0GGlRQQUstfShTTzmNSK4BKCqg2QIMrNtAAw48AC+8HPhQSS7GRLMNNsoQo8w38tzjzz/qDKyOkQQbeWRa5yzZJJJEMrlkWlBm2STC9dTjjj1B3iOPM4XAsYcZUThxn2Rt/mZmRjXAFBMEGOSZZxdd5CmCCS7QgYks0USDDDCwiOJJ0JkkalsiEzm6R6RwwMnGGWdMUaGnkkk2aqtTlLopqfl1iumqFUph9RRkRMFE2bGSzUSst/7mWK+8knEGG3MUMsmwngw9Sd7JKntIbg4+mBEam1IBxEfgnTBSSdpWMEHjK0EA7gIK0KTTuDuh2BO66cb00rvt/84LyCbCNGOMMdZYs808+PhDsDpiGdlOwQkbiaRZ5SCMe5EMs8V7kejUo0879YyzDjzfvDLGHnuk8cUTQUx9chkpq1EDBAtAAMGdqcHMPQkYYIACHZLAUkwzOyNTzCypiNKJJZ3gDYltisyPtB72z+EGG2lIJ8XU/ncaNgBuLVWqWhVzsOYpJShQCWVrYNps9QUzrMltTTtDGdrgBj84QhOe4MQlEoKshyiob0cDnJycdoZpheQEGOqAtjQwAcY1TgKQewmIEpCTHOrQAD3pYQI0F5MFtKsBDGjAAzIQgjE0AhTHIB0z/tWPgcWuK7CLXcFah8V2xE6LA0NHFw3GFf+xcKUrS9KHPurRDnaMoxvVWEQc/GCmL4zhB05j08nMJCckaIAlNPSMzLpHgpmhJgZWQEQnZIGMZZhvGccoBjBmAYtUlKKDmsCbJOKnCEZABDe72UMn4ZSGp/nvUmLjGtcGqDWuZaqAykEgGahANgU+MAoMfCB9gCMZCpKhDG7Inx8UMQkAZSJvIXzIggxxTMBl5IRQs0ENqoMhkrxwWzPEHvbA5UPK8TCbPtzcARTAgCNmAIkceMMmcsGLbshjHu9o5zu0qMV35MOd7VRHO3+Ez3d0qR5dosfFtOiOgAa0HQKFpxb94Y98uGMc3ugGL+IACD1MagxPoOMZvgCFNrX/CQ5xUoMaWLCBCVBgpKk5TZ9a04VIfCJnyGiGIl3KyGHoAheRnOTQKHEQEF7SEZg8RCEexYdO6gGUTzMlpp6D1OcYsDnMaWpzViWFrlVIOc6J6hRg2cCzoc1stpogr+IGtwuyAQ5zmMMgHJGJTBAoUQtpCN82yaxPBu5pPXgmNFcAgg3oNVszlMBKXtKAIIYrmzvk5g81p4B2wesAMNLBInjhjG7IE5+U/dFk51lZywLvjJvl7MU+647PXkygCBUeN7yBjUbEQQ9zgIObnhAZMmD0CU9oU/7QoIY7TIEFFsBAzUwQyD/GTKWyAEYxkIG+YQRDF7qYxSpWgQqgccIS/5LQ5EKuWxue8q0Qg/CDUOXgBkupUqleW9UOmIMepw4nOctRjlKb+jWrSmGravuCVm/l1V455je/aYN/+aCI/wyIrW6FSCY36Sg/QGiZgpsCR+6KuJHodXEx7GvnWDZYbZKosNrUXLtaZJQ4gCKzPwLePih72Xx8lh5m5GyLWyzafn62xfzgB8a40Y1kxGEOb4DDG9oEBSrMCgq0rS0beskGCe12AyVAgQlUYIUu4CE0owkEIjCBiU5gohSpgAUkYRHJVaRCkp7QxLEgERFDOGTNa46fJiPC3bjuAX+UsRQVpAOF56gXPXzuc1PTm971OrVCoIICfelz31n9xmkUtP/UE37TJt+UYQ4BTqsls6tJhyA4N4NQppym8DTkVCs8EXbhNGXYoRqyDF091Am5NiyAWNvERAZYEVAY+4B81HjX+zDjPnqtj1/rg7Iv/vU+TNxrY8N4xr7+dY3/scZsgGIMPf7xGn6QZ/qAqshjOEP+zuBRNeyWBeRuQQ6kfBopWxkRkUAEIgjRB0VYwhIcDNBABvKJScRPWbdhBJvXvFNl4UYifttDHcDrhlDyL1Po7TNxzuNwPq9X4vAlNBSyaqtYlu1WX4Bb3JrGhsiMIQhj8I2bNnqISWhCE4hqqyMe4WaISKSEC5bTp5Gzg5CEBK/SxNYLZchHVd+QJq8mF4v/fiKAAAhARS0Kyj/+setnIxQfX9oHQhFqbKv7Q9nBBrawrX7srjdbH0/3Bz6+4Yw4jGEOcvDxG+SDq9k6wQn58R8KN1WDvNeACFagg9/xkIc8PAhwYQhDHyYyv/n5G0Ei1OSbF5R4xRuCfowyRCEIzqw5c7Rpn/pBn9kD+tCLPvTmOc8M2KucPEOhlvdVQsZv+QUUNq0MbLjgb97whjW8wb+U0sMgJMEJlg9TEgipbuKPOYhe1oEy4Z2C4HCuHe6QxNQZoHBfPeSAIQ5dJwJw9U0IcJMcshqx4GQAQqEO9RojtB9Ux0c/tp71rG892AgVO/3DLuxgm/Ef/ujHPL5B/ws+8ANs53a/EXdENnf5UWhQwCmkBDUVUgXhJgZ0UAcHtwdyUIFVUAV38CCDYAiCgEwLsiCJAHlpNgiVxyiJEBEimAgqGHkE513KUymfAhlB4Hk7MHqgF3EPB2gVt4Bmw1X2xXHzkSsoZEG+IWm412O813uFwAhpdQkEkjeUoGkrKBEXcQd7kHBp4AYS8jTTsR7WEU0ulC3U5Dh/1TlBRDkkMiKythM51EOTozncwGLuwA9Pxw9W1w/3cA/4QHXMNmPApn/6dzGE+GKbVQ/8hw/ygA2LoAM6AF7+xV/aRltzV2haM0BZE2Qe5zRo4Aa8twYYVAZpIAccOHggeDQTcf8IVjhzq+iCBqZ4b8ZmaYYbcoY/vNIGlmKDnneDO9CLEXeDvMiLw9EDeSYFoOJAZsNxa0MZacBftdcGutcrveFf1DgHADYJllYgjMdviuCBfzAIigBzFUFU04EeYshzI3FqE2CG32JD4bJDNxFrQzEiO2QAjIUur7AN3BAP+3CH+RBs+MCHVOdZolWQK+YPLtZrnXVGnMV/HJMMPqADMsB7RThklegEl4iJWJMftdUmRuhfuqd7cMBRcmARHaiKInhgjmcbmcZTkCAJBkJMeZNTRAOLSJM0rPVtjhEqP+CTwfiT9mGDvuiTNhgE61VVx+hArIdoEEQfzchfbnBBuDf/jbxHViRJkoYwCZcAhQqBIIynSatoCJIgCmLmCA4CSmQAHVCAHOsRTRI2TS80Qy5xTTBBWK5GjyZSLjnxTQrgA+nEDeyQfsBjD11iRiRmRhfjT6LFD/h0iIVIWf/gf98AChLZAZJYhLGybXOXkQsIBT/5AzUYBB7ZbU7TBrhHVqulB0kzB6YIjsgUeYzwlY+AXZNACVF4CSzHcgACIJSkVmdWhQkWgzo5KZDmPD5pHshZesv5A+ZhlMs5mrRlBLJUS2nTQBwXShb0G7XHBlTJK9TYe6w1B2UAB4MACVzJlbTxlQ+xZqIwC76AC5yQeRcYSo5BBcKBgzPAHeEBlxO2/y3d4lc09CHoMliW42rg92o6xAFxwAzdMA77AHXyxE/0UFnupGJntE+KCTyOWYiiNU/txA/+Jw1xoAMhkAFrsAZlADdTgCZE9gRz9wMWVzWiAhnRY5qnCQf2o6OdxIHg6IGr6G8vd122OW+ZwHJB4wmhoKSioKRJKl2VdAkKAZMCZ3kn2F27ESn5Y3Jt4jzJqZzlwZw88JOl95NGMJ0LxEAaZyvzoXD04SZt0J099p1WSVathYR+wAiUkFYtN5sLwQm4cFzHQAoT0SAX2EuUoZbDkR0zwAL8mVd5lS3cwi2PEznbZzkFQACZSgACQI/hFwIcsAjU4A3xUGPyZKE/0v8O9ORO9BBQ/tRPlIUxi+kO/jRPqRqi8sALPiAD46RRZ6CBReY8u7gqntmRkEEFkmEpH3dkdWBwc7Cau+EHj5IbsLl4tIkQlpBW2KoJnZCkS1oKpUAs4cqkQWMsCCGlIpRJ8zNzcTWcOpk/vQIcpGmDFEVbFOWcQcADaIqmtMSUuJIGaummJRenkoKLlIKVJGl7ZaAHwGQJHXRpCzEJqYAMO7MMgzoRmVeB4PWvUEMchrNCiIM4/rkt2jKX2Zd9gcVqOWQT4LepQ+GyLNsBHMABoLAN8VAP/GCq91SrKfahBPUO9fAO7nCq9MAOoUUPBMVPBOUOe/gNjRACJsoYY/D/BVRQBbBUZCTTnEbQA1prBECgBEBgiU4gBWeQnftDtmygBl1YgczqXdEqrT+qCIjwlcSHrdmaCdwarqRQCqjAt6iQCqoAXahgCuAaCkFTuORaSUb6m/OmN3uzSbcRZ3FFknqwe5/YBiUXr79BW2WjBGaqQLR0pgwUe/8qZGbAX7+xBl9Ve2ZAp651Qf41B/7Bcu9zLDF5ELhgDdiADcjgCbQ4n8ojB6EkVR0BEo1KahKWLZHaLQ/wLifLAKy2hjfhskOhqRqQRICQDKoTddvLvd27a08Hvrt2dVfHfvIgD8oACHHQBj0gBaFEH68UK5xrpkZwBEpQv/U7nWcqBXdG/x9mQIRowIVmgoFzoDyeVKivSa2ZZK11i1OXACCiQAp9iwqAGwsV3Aqx0ArPtQqqoAp8SwqkwKRNiqScsAlROGAJIT9TqggtWAiJwCyGMJxtkDQltwZrR1u48gPNI6ZfIKZpMgPYVkd39kr7OxmTYrms2wZm4l8CLMBwwAd/QHx3+z4sp6epEA3YcAyboK5IAyfghQZhsBEdYTj6mY49pwEZUAFozC3x8gDal7LROyKZGmuxVgEdIANxsAjToDoBU3b91w/vN76BTL5/zH6F7Id+yId8OA9hQpmrVQZU0ANgvIBY0EBHYMnza6aWfASZHAV3JmT9G0GWwYW9VFbK4/9dDYLAC+JvsrnAd5tWHCQKeztmz+Vlt2DLtVALFQxmsNAKGfxcHMy3pvDBpCDChbsJxxyl53lmaNbCg7AG3aUHZTADvFRWlLIGZJVwZvAE8/FoplsGnxkfTyAZQvxKjkEZTIjESczES2wm13hW2MqtZdYJttllmuAI1YVghao8GQHGSDBV2MFzYzhN47TGbDxEiCUu42I5ciwAFSADj0gvqTMPfXgPi2zRF43RF22+G83RG/0N3YAN1zANz5AMxOBGbUAFzvSrRcYEmuzSmEy/m2zJSrC/njwrZiDKvYSBzLoHqNwgP3oIjOBuQi23koBl98at39plqwBms4ALT23/y7cwC1O9yxVs1b3cChys1abA1ahAzEpqzB6EZvGTCDDZtnpgcntAe9RGuWUlH2YwB8zDur30zZQhzvZ5rOU8Gc1IGf7LewL813KQxGz3S5MwEAFim5QACZPgCPqGIDLnKPPpBpZBtVWwHCCxHWScOAOtxhXAxm1MRJuT0Dh0oAQgA3CgA/PiA6DQDd/g2h/dDflyDdUgDc7ADMmQDMZADMTAC7zwCq9wCqcACqBQCZXQCIuwCOkbB8u93D7g3MutB2lQBeRWBWATBHPXuS69yTB9yfT7tTVduqEcwBVYwD7KaaqoSe5GCIRQ1JSQZYcdy2O2y04N1bY81V8GZlZ9/9UXjNW9rAqmEMxffbhCE6WMMAmWwAiGMAYKHilsoAd+wAMyYD9rMAegAtdtYAZuEImfmAam24woVM5ky9cd7teDzXbqzMSCHbuScLdlFoW2CQm1yxCPdzTMEiHgJSdgfNnfIdCKM06d7dnwMkTuooY+dKmDcAYy8ACqXQnIrdzODeUl+rQyS+VVvuRVTuVTjuUhEIpPgAR6hwSf+ZMK1N0wbebTCd5hYAZyPd48rTzmPa2TR9SMQAiCIAhyGwnv/QmxrNTzTd9Qfd/4PQv6jcEXXOgWjNUb3MHE3K2zARFbqSwE3AZ+EAQXxGN+MAcNQmRQkHBuMGftHNcZbiYc3v/huOK/I+6/SAzYf11Wc3BkbmBWj5AJvPlBCSGFXvkIMndMjhIhBpdwZyAdU5Vzh5MhL6TGnS3k7uIS7SI5d1kAIoHGD6AHPhAC4vTZ147t2Y7tRNQuMvADSvDlLdACLAAEyskDZ47u8xsF4B3elJEy5G3APx3nCuxughB4d+7eA8HnY7bUTX0LT40L9i3VUx0LtmwLB3/wsYDwFWwLGHwLsbAKrQALq0AKnoAKhcsJ+rbYmTA/fgAHvzEDMhDhT2A/YxCtqQ5eBEzAc8Z2Gl5WCJfNp37O/lXiKM6EbdDqYjVWf5CnmUBJlhCFOYXruU7jnXYHFWGowrsp0AceLRT/l2dc0PDSOYFV5D20AhrwABUwBXBgRDCyLl8P9mEv9mBffmP/vOCknz2ABOHhHcWxnOmO7kew7p5MBalOijt9ET3tB+cdgovXVvbeB4QQCZ3wCUrN77PcZbUM8ANv31PNXLeAy5F/C7oA+bUA+QVf6FlNzKuApMmcCPPmB2/gB23wAzMAB/jKA/i64MvDdgVMwBWx8q0u+5E44r108wI8B0ts4uMJN0i2B1ppEO8zCY9w4Dl1IF8J2Zw2n6CUnRyLHZo9fT4O5B0CWJU6E4tRAczyADDyTUak7aA95GGPWIxF/uX/TR1AEhsgEjSwnKUH92Z+BExA054MwO4uB615/xHyjniK8HLWimVYBhCEBEb6VCoVrIOwVq1KhSrhrFu4cOnShevWRYwUNW7U1cujxlu6bsWK1UrVQlWbOHma1BKSpEF+EpV5wmPMGBljZswYA8fJnDZz5MzxM+jP0T1Ek+5h2nTOHDdppEp1U7VNGzlZswIdOvTpnDFkzrBhU9XNH0mWMnXKROlRJkyWKFGSVLfuI0eMFB06ZMiQ0T976sipiubMFCk9dvDYucIxCBArQHTQoCHD5coTNE+Q0BmCA9ALFiQY08bSoAwPGqxWkGFGhhUyQsiA3MG27QyVLV/OUOHBb+APKvR+cLkCCB49lNvYsZjHcx5GlBihXt269f8j2bEoAQKFyhczadqExzpnz5+Yg9QbUsSo7iRKmdZ2whQJ0aNOB2XthzUL1ywAcQHGl2AKHGaYYHrxhSJfbqnFwZBE0igYjTzqRaRYbmnFJFRMCgWVSy6BBBJAIJmkEDjagGMOHth4AqwyZuAhRjPMmGGowIB6ig8/mPqjx6+Eymo8M9qoSquvtnoKyaf0gONJKOEYRJJMPhFFlE/giouSSe7KSy9F/PLLKKYIIywNKhLbgYbGJJvMNt14660COjmTwIE7HWhANAUUmMQTQ5xYoQIN9GzggRlC6EAGRhm9DQQZbpNU0srkvExSGZNTDjpOpbPBhutCNQKLLbD44gv/scRzY6hVzUNvkL/Ya++RtOTjpJMrP/mEPkxKgeVXWQD0TyJcCCzwWAQJBKkjjRYUqRaPjvXlQldc0aWVWExRRZVWVgkFklAuSaQQRg4JU48xeJAhCMZ+8OOHB0LgoQ0enAjMD3x59IOPp5jCtyk5ygsYKzO30sqrIOfQQ+En66jjKzj+cGQtUUphS66W4JMEr7z2MrcvQ5BqKqrDgOhhOsZmeKw2OC2zrE7NOsvTAdEWOOQMNYCwgQYN6GzghB0Y1UGHnYo2egZGi0766J0YrW2FTDmVmodPPxX1CCOyY2ILMMCoMY1WzevxKFjN1YsRRySBLxNPPLmy4lLi5hXu/1QW6o9YiRS00Be+mbXwlwspCnyjwD+qhaJaXPFwllXaDlGRRAKdhBM2eJijpkUfSLcDxpzg4Yk/5PDjKB754JeoH3tkSkihzCKM4IMT/koP2mlX2Paq/FDEErfZykSuubi0C6+zFQlTvaOQOpOK76DwPGWkZXCM0krnpLOCzkBbDY0qqFCjihNooOG3PWboYGjnoCv6uaifa+59NosOmoYVmvthaqmrDvUIJvrHggksdA0MVJGDv5BXtvagjVZqs8QlNNE2t72tExPExFrcZhBUrKI/w5qIgqbFIL5ZqBeAk5axFqS3XhRIIw9yRS1mYYpWIIQTk3CEImA1CEWwCP9pHTCfDC4TAhn94Alm+MMcDjEHHP7oVehJ3uqWlBWzROUqsZNdk/SwB9sFaWFu4IMiKMGJ+fzOEmOcS5e8RLy9/EU9ZNqDG9CAhjSY4QtPuB9jUia9FdhmMrqpzPViBhoHqEENaFjOoB5AhjqEAIg8WJP4HEmDxRTNkTOA5Pt2MIMd/CAIKhNfc0yGP/1JZzrV4R8WTLkFVNYoPGkYynnWA6v2OMIRC2wJJRrItpVAcIL0sWUmOCEKUqDiJBCRCN+MFYwB+QIYyUTWMIRxrGMpKBjCAJwwqGlNCo3kFtxChSdCcSIeHWIMZZCDGTxXgUM9YDIPuJ8TysBKN/hhBk//OERMRheY1P1rDwEzmFnEQ7ApColJVlzYV9zAhhXBQQ+GkMQXOwHGTGgiE5cAXkves7GOgewvfbjDHeqwqqiUAQp05FSbVkaZSvURe8CpAxfCQAUg8AAEGWDDH5C2yPcpR6dAcM77mGPJ6MkAkztZ06d0yqkeVA1USmBq1rRGqlIJcJVZqcMeRlc2s6WtoXO5ZS7fVoq3XWmXV3KIBomJN2UW05gFOuY0nxkMBE2zGM60pjCc2Qu6FuhCsTiJKCahCUXwIQRzmKccVhCcA/BQAw1wVBm+0IGm7CFWgEEPvva1pFVpJYpX4azADuaVKD3pKZxNURv0oLvJ7dITEhUj/xknYQkzPgJMadxoR5MSsDSI9AlPcIIRoAe1k/KxZ9eTgBrkEAbxrcAJfwkCD2XwHMX8QLqavMlNymCkFbkKlowwUXwmOAiY0kCnSTWqUqXjBCX0z39cA8MWvqYVPlgVPexhRH3T1kuvhuJKpXBIKvzbEFTETcB1s9t/DbwQs84CrLAARjGOVQwI23UYcz3QMAD3C2v+QsNzFUbgWqEtXHxTE4XQQQeesIdBzEABDRhOBQ6wk+JoII9y+MEM2pCe8/zlKKPLF+taF0WrdFbIU9RsaBVahje8YQ1JfkMZkPgWXXKCtfIZI0Vj+yW9gKwPffhRUuDABjOUQaRMZR8lVf/mpsnsUaUVIJUSomAGR6SCEqNjj2wZaKsLGkQ/xVxmnxsM4WNAuBiMqBcVlGMy5RhBZ1YTJQD/d8qumQG+ppsve9LWErW0rWIG5jRDOO1fsIb1ShAk9dtQIQo+HCAADfiDJ/wzIGQhSxem2EQlbL2IRYDCFR0WRguxtS1VeIISjrBuB3YAhQwcoGcP0EBxWPyADkhBXTOI5yDm8KNB9EU9PdJXUlhHGLN0tkhDJnJWsjuHKK1hnElew5JVJLFLdMJtnngoJyCqlt8Jb2OPIF65xtRlPYC7DWn4ghSUYAMeTNIxaAbBBvhYgTbs4RCagAXf8EYsixtTrcUqFt+W6fH/ZBIIGSOXRRTUxTlRkdJ/AUTlAA/W0fma7RGvVYu8v6rn/8ZN1G+j9wSpTMa5qC14+IabHAIAAKQHYNV/mMQqBqQLX/yncY0ABCAWAQgfZN0HcahEKCQUCpKYwhOc+OZC15CbDDSAASdgdgYYwIDfpKYDHOBhGdC1Rmzvy3RASpIbgFKkgJFnKv+8ypEOVlA4MPncRl7RlH4pwV1OsKJ34ViW1TiIPghGDmgIQ/eqIAWTLUbh0+vABkyvGzoNK5kcj3rUi3lx2EPdmLPnW4FGjgxJGCFR8ko5dUrZ8q6xUg4dvUPMD8EIfjdULbeK4H51Loq2gbGiXYLEbMMkJr/s/8V4saxLvA9hAKSHHwANWAEPErEQUrBkRI0Y1yIKEQcfKDLrY9BBHEwxi1CEYhOrKMVqJwEJQ3gDMqiADmCT4XC7t0u7EMgAoZoBOBgnHCoECSyEmOCDK+K7JBkSIgmzGjGSqogjVcksORCtJ2GyN2C8xDtBFGME3qkYUYi8i3EtM9oYMLm8P+gDhxkkzqsCxFCMSmoayegAyGg4h6uMjfO42asIipgIjuAI2puW2iuQY0AGYEgD3XOM3ssaRxMg4ZODOig+sjEEvji+WaKVWoKt4CmjSeC3+tI2vPO2fvEXfGGiNco246kLDRA/pFuAhdsDGkqERGgPQGwESFiEOP8IAQ7gAK3jAAY4gAdwAj1QhEsIhcbhEsDygzIIggzgnEOZAbU7AAZoANhAGg64sQlUBECQwB3rtoQJmNEqgyJZpakYuFkEMigxQVxUPMVTqN2hmJ7zOfkQIy4RHtkyHjEBDM07kzOgAij4gR1Qk4RTGRA4gRNouJYJhtnDxic0Jg8KIRHamycsEGoqhmPQBJSJlFHan/USoAHqQof5QuIrPsuax32hx/iCQ6igCjegxX8SrdqxqjkMw0N4hD4wAKU7OgAIgAmogBUwgjC4A0MIRL1IhBExxERMxKzTAQYYgAE4gAM4lCdwhIdiBEOYhD0oBEWwqdcYjg5QAGhzDdf/yCMZAEg/AIQ38ANVLITUQYoqEorO2sdZvIp/ssUTzEWjVLIThAM3QDFHoARceUEY/Lkxgi0a3L7jYSPBIJkzaMYebCTHYAFqfBPK6AiPiMJu3EZvFCEQoj1xFIZi8IU9mA6V6QAmwJqreaotUC9S6RpUQiVTMqUogILquondeoLq2q2bGCkoOBXGFLMvEDPyKAs3gJKvkMNXQYQUEAABOEgAWEgZswE1IITK465KWAQfSMQHYAAOCAEf2MgBgI0GAEUFYADYwCEWsQl1cQ0farYOuIzXmCc/WAN8sUkJTMUJLISA3Bd8DBIz8UDNAhsgq4oUNMHpxMV2MxJ0U8o9/9idx9uVyAvGnyPG+rI8o/iXOvgyNiAD7wA98qIBFkiuhbONEQKcskyQX0jLs5w9EdrGY7GmY/CE53GTusxC37PLAs3C6UrQ+6kjTpkuJ+CtJ4ACCY3QxXzMqyAL12mVPdCXPyAECdDMABAAAFC2CqCkE7ADQSCEPyBDqjvNt1NNRXyAAQiABbABBdAAEHgABeDIAWCAFSgDJcjNDngAoeqAQVkBDeCh8ouYN/iDN9CDQgBE45zAe8qXe3Si1cms6IwiKLKKXKxOE0SyNriuqmCDIJCSR3i8XPnOYHStjZGE6jNGvOuRj2KDMzgDMgA9k9mZnVEZRlGkunqmuvKF+/+cFnCMQg3bz3Csq2HwhULggRpzk+yY1P0h0N7DHzuCHkx9jgR90N36AgkVM1gcN7/rlz+4AwcQAAPQTACQAAvYAA9IgRawAzoQiDBJBKxjxBe9SI4MgBMwgAEA1gWwgAlQgADoSJfsgDL4ASiQDDd5xDJ4jjFQmCcthFRkBEAExCgdFwrcMSs1HXzcihQRszaQTLOIEnJL1zEVVXJtgyB4ghuThF8KNe+st4cSxouChI7BPjYCtzTA0ypAgqqJn0aRAQmjqwz7BbYyJg1rWIfVMGrSMALhm7oqEFSgPyjgAcnQgEntn+wo0Lq0y0k10EvFn52AnqMps/ZJ0JGK0Mb/VCUPnIM7kAMJSIACSAABKAALsIAU8AAPSAI16AM1qIOYgD9G7MgDWE0OmNEAeIAEAAAHgIBgLQAFmAAQaAAedcQO+BQqmMvKCIGI0wMlWwMJhIRsHZHt49Y69NZ69APmfBKyiNu4lU4jU9d2ZdcyIEwh+oExQIuVeD7omyB6k74yEh59na1/Y4qHOZPOE1jliCSkmYFamFzKrVzLvVzKzYXKzYVcuAW46rBf2AUKSYTnoCMp2IEeKCUmuBr1Wt0meN3XBQIgiF3ZjV0pkFDclVAgYB7FgAIyYB4pCF7mSRPmCYMweCPOG1VV0aywYQozeIADMIACEIAFwIAPQIEL/7AAG0iDOkgDvyiENQgB1xyAB/ABjTy6BEiBA1CADViNNGgCB6jaggRWAzCABqhasHyjCcXJKDVbE4EERTARVAxEbS2KbvVW0zGdJFERpSxTDMXQJzmoulXXcq1gzoJgOPADRvAlnZu3/vMdjFGbu8iyQ0AK6JQCKgDK3xVYG3CMo9mBJqSIkMAIjLBczr3hXKAFHMaw0KVPVVgDGXEC1O2BH9BCkf1Yp1KvI4BdJm5i2A3e3MXd4JVdFE4T4R3e4TVe5A0DWQzBwhuKK9qDNjgsBhgNCSgBDEABCdgAG1AC8zCKONABGT061fSBB1A6AfAAl9wACXiAFejjCahRCf8oAI4sAENOgAVwAKs9ATdQjyhlhEm4BGxVBJcQYADW1kEoBEM44MsqHaeAmDItPAy2CigRsicRMjboLLyVTCRSBCqBGxdsm3sFnqDDqPrSsaOQA1ZKiqhoXCBgEx745RNAgj4IIUON4Y3YBWVWZhzeBRzOhWEghtDNhV24BUgIYiiwn+hwKqeiVC30WCcO59eNgiiQXXM+ZyBAYdC74izO4jcyXuM9FVgUD6lAKIVhimktg0FxgAvAARQogRJoAVAZAz6wNifggAPo1QdIxKMLgJ0NAJcEgSOYgWZTgGnUzJzN6AIwgARIAAVwAA0AAj2YEkuYoUA0Hkj+P0JkP8j/2Va1/QN+mUdwxSLaKUETRCj0TGWsELJxuwpVkop1xVvsmkwolQRNEIVUMAiwgiDpAx672LcaREakqINBulMq4A4pQIIkEARMCNS6wjBq+sZlXmZeCN1d4AW0TmtjIAa21jBb8IEZiAIlIOIf8JwD7ViRbV1xDmdyRufdpWLgTWcsHuzihWfmaUzxII8VoR0xzuC+2AKBToIiyAI1MI+nwDqN9MgezToGOMhVm4CEdkRPVA0bMEjNDNac3WiO7pP1rQAeYEFLAEBFuLSMGZERqaGThpxNpiwEjiyaZjy5nSIhg0WfDrNRbVfOErPJnMwnGQQTQeqkHjVZlg9MwIQy/7ILS6jKvbihwMjBqaACG7ACQSAIY1hrtj5v9Gbr8l7vZGhvZVAGZmCGZ3gGaqiGa7iGbchvbNjvVtABHmACTJIuOirQkR3Qb27dkAWgAlcvcmYqppJdmBJswp5wwq7i7/iCxFaVxd4DOIhSR7iEUsCEO0iDSBAE9JCDQmiEQoi/F01a+JvRARC/AZgADTDWHfXEY+XRBkgAiNaAhGbt9T2UDvgCRUg+W8qYSvg/SGC/RGgEMImcCUSe1Ikvy7IdI0syshiyGhlVIoHMqZBbOx0LsniSmxiEtsiPVJBuWb6VChLGyYEEtbgESti+erpBwVDKzQuDQKjuSIhvZnCGZ/+QBkG3BkLfb2zI727ohm9Y9G+QB3mYB0iPdEmfh0XHhkXgPRvoAZ76gekYWU/vWARP8JD1dCYgZ1OPAuEF7Jd6KQqfcAuXZ5idTLHBoaZ0tWWShWIoBUeYBEUoBEeABD3ggNRUzTgAhKWdUT0MUUUeAAjQgGPd0R7F2gPwjQHokx2t3+jtkwaYgT24tEuQj0tIciVvhEboGN0+TimnRyuHkpp+A4QamA7kwHH76cGTWzEH8yDoCfmQhE5QaugjtV2Ssokq6VCouKgLhWHTC7/og7GZgzoYb0wIBBJgdIqveIt3dEeHB3iYh3vAB4/vh37weHyYB2/oBmIYGuqwAdn/3QHf6mb++XQlbl28HvVJPXVynnB4rgKd3/mdH16et/DDhsxyVaiiYCjeSYVgGDlyxAVNkHNJrARjH/atw7qE5kylE78EKIEZ9cgAAMWtd02PvHbpVW0FAMUOcAN+l7IQCZFKlqUa0u2IpEAJLM95zKLaqelT9mkun3d6H7w0IIt7JwPBr5ybKISK8SW4WWqAHzsw2gRSSHqln4VNoEGFL0+J+wRZ+IRIwAOL7/xvSPRFV/RGl4d7uAeQP318KP17mAd5wIZK4AAdMAKj0vT7wQ6PBVmP/cv/CXUlPgKbv/ko+I7vCIMvqPB1Dl4Lv2J4dkwxQygUMwRHaCBSwAVy/0SGt8QFVKALvWiEOOAAtyvfOMA1rJtjq0+6hla1Hv16GO9IYEVtQ95oZIW2JxiES1gttk/y25Yl48lWue9WesQXgNAjcKAeOG/gtElopkwZhWbMpCnzMM2ZM2kuXmRD8QyZjmTO/OAx5gkqZLA2VfJUaqWoUJ5EwfQk09OmYdFuLjsWLBQlSZIeMVJkqJChR59kpcKEKNC8pvPkQY0qFeq3bt+uypuHz58/fPG8abt2jeq3ZXFkzDBipAfbHkB+qD1yJK7cunKZYMmLV+/evXrzAt6yBYtfJngHEzas+DBiLFu+RIkcZjKVj27q7PljiBEkS55W+Sp2rBiwWalETf9SdMiQnjUcODzwsWg27UUhGAwIoHs3gN4AdA84oJsB7uAHDiRInqCAgeQLEihYoCC6gxmGKMnc5JKTJUqOHDECr3rooEF//KD/c94PHz1z9PjR8+bg/DYLJX4pg3G//jRq1KBRBRoDolHRGQSmMUMQl3GyzDLEVFJJJqV80skllbgkSied0DSKNd1sY000x9xyCVCMoFgIIINIcpQsnwQyRA7fyFPVNt1gsw02O1ozzTTSOMOMMkM2w8w2+PDDjz33QMOLk8okQ4wwlfgwAw8htQXEW3TZZYRdhgEGGJiNCYaYYI6VmdeZh4m5mF+E5RVZZFTQSadFcmR2CCOSXCL/CmjFAApLKqVo+IghfwgkQwgcABJhJY08CogPPnCA2266/ebbALkd0IBwxx1ngKgGMOcABBYkIKp00DHQQAdy9OmSJ91NIsl3KB6yWiHlnafeeXzwsYdAwsJR7Bpr3PfQF8u2sR9F/hFI4GTTIsjDE2jUccgs0ShzCigSfvKJJ5fI2kmFnrBC4zfYWGOSiY8A1UgiiRzi4ieR4EEEDsaI+Msvu/ySyy697EILLbsUzMorr7iSSy7Q3JPkPfI0+e8xwwijix4/zCDDDx//oOUPSsTlppduhvkXmmWCcWaZW4ARM2NmnpkYX3gphkVky1IhRZ1kpOHGHH4MoucknPg5/wsus6xyGkyTHKoHIDroEEIloGD9bSVx+BCCDq8xcEBul/IGwHGbim3cccsVMIEFDpC6wATTTadBAw/woAgkk3iSySR/Q6KI4IrMW4jh5vHKXrDCEvTGGm8o1OxCXzwE0UUVpYFGGGhkPiAVm0ebxg9PUFGHG5U0gw23qkySSSehkNLSS6XIxAo2V63ryyY99QQJJI48goksw2MSiBVVqNGLMNEME8stujh/yyywKH1LK6q4UkstvfBCzT3+6PMUM8RgPFoxolTJg8cgAwEFySX7dQTKcA425sswx3x/zGDIf3/NN6cMMHKKQp3CQCegpQFP5ymE3iihCU+EAiai6P+bof4QB65N6hSnqMQiKjEKUEhqUouCTdhykxsBbMo4wAmO2tKWAAhAQFQJ0MDcjiOBE2ggAw242wwS4YhJXGISvgtcUAiXCMMRZVfoYc8e0DOQ+cBhDnKwz0UeIpGguSENHRnQRTTnOS4SyA1PCAIZ3OAGQNSCR8tYBRCRhgpUTHCCEPxFM0QkDFC0jhJ6rJUkOpEKYLwIEXbwghrqoAtfHKMZS/MFLho5vEbiAimroJ4vfgENeHDlKc/4RS1ggQtYiGIQPJjBDmgQhCCA7H1q8ZL8cIayLbApMP5zGctk5pj8pelmbwqTEuRUp1+SIT9tkIMb4DMIQ+htEpS4BCf/OEGJSTxiEG+Yw6TicLBFvCYOHMQgpV4Dmwc8QDgCEEAABkAc3+hGbGkLgAE04IAFiAoCE5BA2BQAggpUYG4KYAAHfjAGQECqEkP0XRGPiMRCqGeJThQIFAuSkIQwpCFtYIN9OBKGixjwc5/jXOc454TRfWEOc1gEMqyRjF8cQxeVuIRKBgUTQoUCFKP44CY2EcRLZOISevTj8GSBiTxgK1iwgAUqjoEMmHQiE935CSNWUwc2EI0RlSCGPPrRjxoRYxFxCIETZuDVHswABCA4ZciM8D65sPJNi3HMLmE2S//lT024RNPNWukmJgywTlLY616hAAWJXOkJY2jIG/Sw/ytFBOU7f2iPD3Tgg1PsApsZyIDXLnhBHcjgNQ8IwRIywAADsHBTmPpNOtO2AAcowAHJsQAEJIDaCoDgtAY4DgNkULUxjKGDlfgb4BwhuHkZFInmSSh6DDLNORSLDRQtgxsoah/LbS6jX+RotULyhISsARTHyIUyRuSLWVlCFKlABUtg0kxOBLFWmeBEJijhouF9AhF94IN65jDKDswgFZbIwAo04F8N4BOfDXBABTqwgzHwYh39sMc8vsEMZiTDNvidwQpWIFYtaWmV8qtLXwL4PzTlb3/6axn+aonLXBrGrky4y17mVCe/QkEKTxDsGKwUWNyWYQ9N/MMgBHcI9v84YQw+AIUrsCnWDHjTB3woQ2NfMyniNCBsaSMnp8qJKQO80wENEAAEKAAB1CpgnqpFoTlfo4MQNgolf5PE74poROH6gce8kg8c9KBj5MKhuXDQSOXS0AbN1WlAoIsW53Zg3YjOQRe0cIZJL1aKTGSCFG8kVCk4lFRLXMISk9iEJ8yVip7eqw/INMQg/PCACjygARX4xCDu9gAHwNpUE3DABE5Agz7ogRhH6sc8upEN1Q1jEaOkcFg1gAQpQAEIq1wxiwkjPw/Lcn/SNrG0T1ztua7V2c82TGT2SictxXjGgu0YWnjAAydct85EO6YjhiLkIRc5AydAwgkUxYEM0AD/DWV4NyBC8ADiMCA2lUrhpkQVAHQSYAEFSEAJYKhwCWwAAglYITgfEAds6uCfjbjQmts8uOCW+nDliY8e+MAe5Ip0Dsr1cxW7qDkpAMFng0YQKX8QBDMsywmVUIY1tiENY4wGFpcgFypgsZINdQITOZ2EZzr9aUD6lBCHeETgSg1bDYBgBkCQxSNAcIKvn8ADJSiB2GugBkFAghjf+B4+8OENb0DDGs1IxBja8AQj2IAGWmLLDgythA3fJS8c3kvN8HdtER+exImPK13B5OwB8lWvVIAx5ckgkWE2BA576PEjbJUIJ4TAB40AYcBLYIEV8CADD7CABTTAAcdODeAM/wjBIgDR7+KUzTekRYDDRWUBCaCKOQfYbOi5xoHiFyJCvfVtIn5r0F71ij12DpZ7ksuGPLdBIvf5wkWWtawoQAb83qcIGQZbuTUA4hjYuEY3orGMaCADGKTYxCgmOSgKEWqCEVyJLACZFEHoie/4liKwAAsUQRggAQ3UATB0Ag0gQQq0gA2cgA14QArYQBj0gSIYwzdshVVxAzusw7o0QhyswRiMEg00AYYBQQ+MTisFXmK0lVwZ3rXNoIgJxuK1TGCkDLfJCV9JARn0jIxBwYwlGxRYnhkM02CxweYpgiOwGSRICgcsAijEQQZUQAp4AAjQwNelQAnkUOhJiuqB0//F2d4FwcbY6MY4kRNpCQACIACXTcCXFQAKHQCSccCkJFkcANRuCdHvNEIT/qFBmYfhrEewmBz1IVdzIRdFVQ7O4Vz4RYEShJ/3cZ9yRZQZgMEXaFM0sEs0NEMzIEP8mQLsfNqghIsoEEpL9VQgNSHg/I4jGGASFEER2EAP1IFPOaANVEEY2ECFGcEdIEIiqB2ScEU2jAM8fIMxkOAYRMEo2YAKYpgTnEzO7JIOjli1vcy03SANMp6a7CBe9WDk9QwUoBsRxtgRBs1ftQEf9NgPMQJLbc0UAgIHaEAW2AASqEER3IAd2AAIrEAHZEAHgEAHdMDxdZBWXRAgLIIPWMr/AIwTARBAAAgAOgmAakHAApSTOakeo4xQCIQAIBRCI/BWHw4R8wkXIa6HQumYQBRLsTRXI6bBI0LiJHpfGFQEjplBGJiBE8TBLhDDK3wiIAFDKGZIKaTCUVIaTDzd8JRCJByCMlmCpvEREViBHbRAEoRBHaBBHxQDJlTBHdRBHciBEaSBeXCGMlQVP+wDPmQDOWzDNVDJMuKdDaQguGnJ382P44VJNm6jDQ5GX4YYNm4jmThGm4Bjt/mMXsmYuCHbDzIEROiHHPgBA+0N06WCLySMbcxAGvSAFNxBGBQBF0jgCpwA2Z2ABVQAB4xBhDRC7V1cawJCHAzcAJCKGhIA/zoVgANEZDkFXGzMozfJAEjuTXoNlAD+1kGVR+Ksh44JS8rlWUxaTiNO4s5QIhCKWxQ0wRfglqRUglFlgh/AQf/1DXYYJVK+VP/1FCZ0niYMXVRKZSAQQiTEZ9LByycgQ1JgQrhwyHjJgi5Iwzz0gz/YwzpQw68p47GMwRI0Iw/0TPsoQS+tWLbBkprwZYnVIFzhoIndT2HeTBQQ4S9FnpyQo83h5EUIzR9QJtOFQv9hjDEIgydAQiE8gX7gIxoAwQq0QArAQAmkwARsAGVpk9ZMIQfNhu35gKfU5hySUxqOE3AAHNeA0/H9UyEA0dDxlu8sn5uBHHuYB3oAC0EgV//kxCTlyCRN+hIZkKO5uYWV+EAcgEIxIIMlrMAZKEInwIIT8o1RNs1KwAIw+OmLSILSyYQmQJpSTUJPQZ2fCiX8+aloKA0iHcM1zEMmwV13UclOMsGDmhWdxFhk4IyY3FItscxg1iCJZSMOCuYNfphhfAGMBeGrUoGIolIQDFZkysEc0BcyQQIlhFf/iQYyLEMzLAMuJMLjuIEU1MEOnEAR4AAMoAAMeMAJgEBmBefVLMwG0UaEjMFtiE0BOKQAEIBqjVYAHEDAyWaUnhkgJMK4WKmj8CFJDiDh7AqvJI4frKRAiNQUJcR+lOkAyckXhEGrfpSW+KMOvAF3pMIn9IH/ICBCJHwCJhzCIEBCJxjlUMkCLihqUnCCTMDEdiiVJShq/zVqoxYD/AFKIwFDMIhGNmyFPzTYMxhDMKyBEuTPWvQAFEzejHmqXlIoiJEYFpjqNb4VqmrjYO5gq/pVEHobncjJjJ0Sjg1TG+AqiibTJpDCKuCCaChDsH7iMbhCJRTCGOzBFNRAsw4BEfCohZEb6gHCKdDCK2CNozRCbFJKCQ1AAQRAAewmOg3AHVbKA9yh7UECu/7N0EVIetWKxwmOITAueSSnly4Ovuory0nn93lqZOgMZDwBzp4BCGyABtCAG4jaIBBCHuSBIEUCIvyBIjyQJ3ya0aFnJ2hCUeZf/6exFzCQBsqiLDCERkk1QzFIjy8AwzAYQzZ8z1V1wzMMwyXMwBYYAf8YQcwBgXVCwRckhhFkW87oz8t4I13JErVlqKj2LF5BQRSUrxQQUPpGxoN66McEgWAhIRIOzSD4EJ+8BCz0wjEoQzN44ic6SDFsQiGUEhLUQBGIQRikAA0oMBVUgQIzGSBswim8ggadgmtOCloUx90uKWn1RrkSh5MBFDPpVOEarpV2HHiIx2qQWuN26RIBy+JIUQLJAXTKpL9ab2SYoxRowAacwAbQAAD2ASEIgiAQQiDkARErwqdRWoUosQS5BHlJkIZwwkoQyifgX4WUgqC0wjFEQyxE0P8qqEIuPIM33AM+PMU05EIczMCJCYYvUUETwDEWfEnO7OWHca/3dq/Pgu/PrkyJyVIUYMENVyO3hYxbOKaeGRMyOQIksJQqzEIw6C8yDAnXfmIvVAIgOIHnWoDpfcDv0UAHrEAGdMyixMHowe3cihBu6dDZXArBgQo/qWZIXgJ7Dl0tB9G7Lt/grEZytvDi2CvjhOkMmwHnoEFOAuwXUAEyK0FncioUDNYYfMRHnEEfbMgRBwIiYDMhYHOLYIIe5acsrMRRijNMhYJLdIIzPUJPdJ4kREIk6JEmaAco6AIy3AIEjQIrPMPa3cPETAMo6MAKBG1jYAEcE3QTqFiHBRD/zxbmHfcxy3yvqtKM0a4Mhd5VznRbjFWGRLHB1BZC8ynCpoUCKsyCLwyD1k6y/yrDMZDCGnSABliA2HmABvQjD6xAGlQYQYZAkHIQ3ULpv9ltCwWcNwXuIkDCxmrCUSO1LV/IHrHZrTRVrjDucC2RejCne0jRDBOaoOlVzI0jjY3RE0izGkSCUqQuHTQsImiz1LGzen4CTKCCOKcCKch1FMvEIxBC56VzN3dCx8JCK5iCLXDXMhTDLxBDNcBD293DN0hDv3XAhsLJQBe0QR/0/ATQREP0W6WJhbqVQJMq97pVYgweD+6VRyzL5c1BEw3CYXUGJ4TCKszCLfQC8erv/9ZCCTKQSCWMAX5Z2AlwQQogwQrsJBDQgJU42SLAplb5GzhBmQJ4MHEA7vFlUyEswtGwq1Jjmi3Typrdii5Hta9INbDswRzcQQw7y5h6HwHJGLrhFo2dARucgRSowR2cLnwigk8Jwlh3QsMixYaUZ3mSV/5FsSzAAqIqaspCssoOAzEYw/72SDYoWD8kNjH4gAw09obuRWQ3QUVnm4d59mZjdqlqYx2zsWPDoJsowTl2xLJUr0TVGR8MTSFwBkuRQiiYQivsgjAAXTLouI4fg05cQiEM2x00gR00ARhgZxhwwSDMQOjNhh5e8qJU3APoUJQ5d5Ld4cVpR0sgtU0pNf928+oz+QR4hMdT73JyEpch3oEcqHl5lymdiBtu4VYQGOGAqEEfRIId0EEgCELSEcIffVp+hoslmAsVEzqAwwSgiEaPG1WPA6tth6IxKPiCP4M2PHivVYJHZsAXBG2YYHhle7pAc/gdiyo32mBgtIxf5pLgOV6KKQFX00l++FV+PCYclAEcsGMiMAIQTUIl0J+NCwPxJoMxCDvQ9XgsbIIi8IERZCUXcEEW2AEXCMIKhF4oXIKixMG2ZtZkTZZyB/VrhF6bapNrExVNwDOX51SXZ1p2/8R3xKsKk5pUQ+54q/kMr7l5U+IQvu8Y0Cqa+hUQqIEQEwId5IEY0AEeIAL/WfdBH4iBIPRB51GsOE9aUooCnIZiKA5JSjvIMoRiMwS7USkDM2SDN7TdPDDDVt0bJvpPXmC4QuNxy4d6LgGm4sk8G6+MiIWqDrZSykTB0iZzGcS6dtZqkEntZOJ6R0MCr49CK9zCry+4jiuDMfBvMxzDJsyBGfxBGtRBGNhBGBiCoozBsYcAQE6WR4aADGQWtz/3HU6KD+hBKNxCI60CTaD73LcnmId5Cq9GmftKnAGLvM97vStLTJaBdp7SE4hENJ9BD+xADQgCHtgBEaTADWCCILBAC1RBEVSBGIhBw8ILJgz6UU4aFFd8xvevgyCDsG7t6H9iNujzN5xC18AG/yZuuspHNmWD+ss3NIbaIC7RIETbPP6M74ZHgZagr/gNEIyVgbn9wBe0QWYUwosnwtHT3y0Eg8rqr4N8Iv8ug+4AQssAAdbPgUcCgicAggz842Tp9rkt+Tcdn0eC+8Wpgi7gAiO5RE3V1FHbcqHi1LlH5TPVynYDhCKBhwwZGjToT8I/fBjymSMHYkQ5adK0KTMG45gnTzDu+LEjyA4aNB4hsnIjBRE6YgTlEYTHixcxeRDl6YPoUadSO1OVQvWzVLRlzZoha2aNqNCiy5gajYZMWbRt86hWA+QjBIcHX8B07boFS9gmY8mGNWsWLBYma5mcdYtlS1y5W77S9Sq3rv/Xu3HB8P0K9y9YJoKZHGmLJYoUxVG+fDGjREmUKBuhfOExYwaPJ2XkzClTZs4fRY4mXUoFCxewYsiYRiO6zLWyYaYmweHRZkyIEIk0tZkBAoQHDSt4dFhhxAlWDhx8xPHRHBCgRptU6fKFyxeqUJ42db90qXt3TZw0jSd/yRJ6SpMkSXLkiFH8gQUPHlzYkM+dhxInpoEShCONNhrjhzOgOHAHJO5QwwtCcMAhBzrySEUQHGTKg4g87MiDEEEQwaQTUXby6SdggAkGGFxwmQW102RJBZVVbhllFGGGYYWXaryZRx5jAJkDDB9kMEMvr8Qia6y3wjosrLiWZHIuu77/mrJIvZzcqy8p64IrSrCM5BKLxsQc8wvGGpOsjC8OhKKMNDrb4w9DFGHEEUks8USUVGbxJZhj/FRmqGaicW2ZWOIARIfl/qBkhgoqaABSDZrQIIMKOtAhqxCe2zSOQhbZpJVYYpllFlVM2e47Tb5bldVMWLVkkknWgwQ+RhQ55FaDFLpvjjkY2i+iNswY1ozPMsLIWI0APKOHKVgIIxI8AiHECyLwwOGDHKywQoxABLGCpptA/ISnntArLRP2KMGEkUcYOUi6RkDhJZlnsPlmx29AccgMHWYgcq8t2kIySSWZBHMtMOeqy68qq2zYSrq6ZNhJMMGMTDIzz8w448ag/6DMMYrm8OOPgw4hLRNPSlllz2CGOUYZopyJhhmmhlFFDxlCgG8FEFZ4VAMubEDChg542LQ55+JYGpBKSLmF1FliUWUUVFctrzxWNXH1O0soocRr9h6Bb05bdd2VITnaaKMziYQ1ww02LPrss7mTLYOMHliIxA5CxKADDzzEwBaHJLygY9pIBPEQkdM6+UQUEVMxxFZGJCkpEjXSYOgNPT4lhppstvmmm27WkeeZQvhogwkddOAqS7PWIrgJJdUyuC254AKMMCzuiljL4P9Scq6zDl4SMo7LlIwKKqQAovnKyCCj+erDSGPkkg0pRBFIJtFExFVY9gVmppphBtBlkP8pxpRCNoEkhDnSqCADG5pQsIcV/NDDOUAWYTo6gCBFLG6hi1vEohXa8QQnWHUJrH0nE+XhWgPPBQlbjUY+2ytEIQ6BkITg5yG9Ulsb5gAHucnNIhZBFt2g0AMaqAEPVrCDHbwQCVlEwgpEwAQhvIWISGDih+QqxScs8QmdlMJDJUEEIRgxiQ3GoRGnGEY0sKENb2iDG1b0xjq+8QpA8MEyl4GdkxKGBdrZ7ni3a5KTovSk2K2xS3jpC8LYUsaDJayOh2ECx/iYGMVIgQph+EKb0oCGMBwyDFT4QhrcEJpBAGKD3aNEyvAkI2EUA2bJAJQyYHYMYyhjF4cqQwdmAAb/G0ihDjsww/4W0YhKLAKW/mvlLXqhC13YohWm2g4Dr3aJCZonExOEYNfWE6tHjM1WidgeQepzH/w4pDN6mEPc2CC3MrDhImOgWxk+QoUq3CQQgfuELBaXB5fYQRCRiAQhEPGhToCIEnbKxCcUl05LPAISlZiXMrIhj3ngAx/x4AY42MGNcIxDHs5YxBzaEIUfiHEvTTIjwd5SMbek0WK6G0xaymg7i3kULnZkUh7X4rE1Hch5UAAkFaZHhjNQBKYUOUNj2tTIzkUnEYzwnvc2EQpVxMIXwzDGMZABlWRokhnNGEYo9GAGI2xhBTN4Ag/+UAhAbMIYrwAFKCpRiUZc/zUYwaglLlVBil1SkIKb+I5aV6XWYJ5LEuyxoCK2Nwg+lMyuDrkrCOewhz3oAQ5wcAM124DCN7xhDWsogxvIAIRHqBMPL8GDD2uizg0hgp6fSEUkSrHZR2ACRIjowyAU4cpdNKMb/rxHP/zxj3+4gxvjoEc70gGPb5wiDmv4AhB2gJkvSCktcaFdWkC6JMEs6aNkvOgd64gw2aURo2phi2Ekc9I1kUEKKm3p9F4a0zS8tFhlGNZF1vCGOUAyEYooRCLy2VNVzKIXwcCkMuibjGlIwzXBCAUfeMADGTjBCZ5axCmIsdVTnAIUsDTFMMTaC1uooqyiWCB6LlEaBz6wrf/e+Q4nOKyqSUACg4pIRCEQwhDtlfiuH3ymNAMrWDe0wQ2BPSxix7CGNlCBnXnw1kvMSYhIdGKdHXLnJzABDFk8ghKf7QQkK5ELZqSWKveQcj9Y24978Cge6SDHPKxyBTBQgQYzkMEMfrul3Z3Rdha9HVuki0aRkjSPu3vzk45XxyMYpjB7jIJ1UZpdKWyXu2cQNEUA2RhtfuYHAB7DTX8EyUXkkxOhEFUvXsaaZkgDG4MSylIboTRIuPIXvDjwVitRiEroYhjCGKsqUEEKCTMwPejqsKrAEx62boLDuc6E187FnvfUaj4I8aCK/cCH/ekBsHCYAxtaPOM3wOEzaaj/QhgIwU5EMM6HkbhJKuiZ7Uh84rGgxYQseMGMe/nzn/O4MpWpjI8ry0Me8ICHPIjhgyXs1ga9lUGZ57gWwdSuYHROmJrbMmc5s8UIeGaCEo4AGYcr/AhRUAueo5Awia/lCHS+c8LvLPGK79m6G8kuFBRJhi84D5AtFTQVzpCmQ7ch0Ykug3n1UF49rLcRk6iEJ1TRiln0iTXWwO+gmKI+X8DSwLR4xYERDAlILLgYDL7Fg1Eh4U6oKta+zFp5yGPr8CyQPFznhKtg5etfw+cQae/gQvDKED+8/dh6+Ctgnf2GMcABxmoIgxjYqc7FdYgQIMJEKlIB5Ehc+7HkwkQp/9Q9D3ioW8r4oLI94hEPdqzjyjwiHTYq4YRDf+YLY4DdG/FYx7hoYQlGuMLqtXCFJSxh9atv4xrNyITaIaaOT2DCEwDsBN0/YTLB//3uvwD8J4ReMn3hoxQSEwUqOH8yH/N9ZaDgBDUd6AkfKwMUyPD5ba5tbYGt5mDhoAdjl2y9dIoreEJhCljcok/lC9SgmqG+X7ACFJvQJygOXOpGqAIZjqEYgkEXEkhEwG5rUsVVtk4TPMEBH3CBIBACz+MSKMF7HEEgBEKD3m4P5EC8eiWbamwMgiAIMoIH/GUG/OUHSBAIaIAFNqAFPsHIIsElFgcYkOHwMIHIsg20fqgTOv8hHvCBHh7P8eKB3eghHu4BHtaBKuThG6IhGYwhDo5lTIBLdnbnLGLv9a6g9bSg9WLP9d7C3yYKSSpuLTYCDdNQDdeQDZ9ACYwgeZyvelDujxTDCaTgCfAw5KBAm6Znm74P/NrAhNhgsGKsV+TODwYhvejEESiB/VAhFnThF4RKkwKl6JgiGX5BqwyMq6TIk4bBwahmOzph7LSmPDaB1hqw6zQB13KNExyQE8SD1irsw2iFbESsEAqiEPzAV96ODxCrvA4rGBVLI5ygQKAgDXqgB4CgATygyIBhnQ4vnTarD3Tw2pZInQIPExBhHbpxHNaBHMbBHfyhH/BB3uDtG+T/IRuw4Rl4gRYqQQcwgky+gEs4ivaycPVezwv3EQxfTwwL7s7KkC3aMA0BDA17rw0dTgnqsHnq8HmAAAkACSIh8o+ej/kALdAErbCqiRDNIBCDpTPuKhcT4WRIg/0grBV2QRiGir42ib6YASaTgRh44ReIwRiMoRiMARRpgRVGIf/G7q0yLDzW6utsLdcWiK0WKAHLLlacbk4cwYIuKNhKTO78Su5+ZYTgYA0wggeo4AEagAUegZ4wIZ0Cr52A7J3W6e/aSZ26sRvZIRy4gRvkrRu/YRucwRiSgReMgRhyIRbGIB5Fr2PoEQvx6ArD4gtZrwu9UAuX4B8x7giaAAjG/2ItIMP3eg8zey/RLjMzfS8NOeaPgEAxgIA0H5I0kQA1UbN5IrIim4d6XlPQWq4iCgvGPJI/IIJtfOWu7GoQuAcqK6E7QMEUWMEWKO0mj0qTlAEmYdIZnGEZlCEZhGoYdoEWXMEU8s8TYKWBvI47vY7DMoGtFHBrHNHCYoU93CMDy6aD6sOu9uAhzMCvGGoMnKC/7E4HeGAFZKACDkANhIwsBaHafOwThEydvA0b28EcwEEcxsEbGtQbvgEb8DIXXIEVhMomkSEUQkAG+uhAlkuNpGstXG8L8xEMRdQxNQ7P7iwgm8AIWtQIfgBGY1RGZVQzYRTANpP3eu9A6pA0e/+UNJfxNHm0NCtyz4q0MsxgkIplWCrCxsCvMxhqbZ7UV0amNwVip4ATFEZBFYqTGGwSOVuyJaOQL3VSF2rBOs/KEtKj1rpzE7ijq9oKrSrQPJ0uPmoxEdJrF42NZPwA7zowkahADvSDkC6iv/prDJ7D855gBVag8GqinWgiyNip7z7hQwrUx2iLHS6vdLaBHWcyF2qBT4aCKYrhDTR0LThmI0aqo44rLEQ0H2EP9hrzRKdLRY/ARY3ABlzUMjczRgu1v2zUGGcUWI3RGH20R0MTCJTxR0XTIpUACJqP+TJmj/ZoTMCASGyzDd4gWwWxV8AP795ADuBgDLI1e9brTl3/aRNAgRRUgRVywSbz8kvriy9/4RfK9Ew9wTx4iU1t7RKAU//eNE3Dxuk+bE7mZL2QDRDewAeSw3UwRTeWIwR+QAocQw4SUU7Khk68xxNCgRRQQUVkoRQeqxNcgg7SKVp+iMd8TJ2yUQfrshuwQRqaYZPetZMIBRk4oQM6QANQFQ1Lr4yUq1X7EVaF1jFp9VaP1kVv1EZh1Fd/tVcLlUaD1Ql8FAqOdTSVcRkdTjIWTmshAw4vk/eA71gSy8bk4LDg4NmUTQ/c4A2YbVvfoARnbg70wA8KgW7Xq3suIdJGoV1/AV436SaNQRh2oRZigRWuMzzTVCi97ju6ynEbAXJH/2yDoqNXNihbXUc3QkAHokMPAKFzBSK9KoH9QiFGympdZwE7fMEXTMREiqEYWBcYYOER7qAPxMAOAoFDBAGIZEEWpiWy0IkQeLfvXtYZMnESU+0miQpmigoZCO8JMqBSMEYNzbC5VHUtEjP1WjRWRbRFIdNWkfZWecAIeOChfrVpobZ8fVVYmXYHlPVAjLUHbCBr31Ah3xBpN7P3MiIKMIJsBTFbZyyw6G7GsglG47a8xNXm6rZ7gNOnYsE4n1MZAnAYbCmXfLJfB/ZOv6dfubNfH7cRFiE6PGXEAig6IEH/3kd0N4FGCGgWbuH9UpdPwirqhCGswiqGwwp2VUOHcf8BFg5BEPogDG4ABXLACz6EnVajnQjBnPDAnNiSEJahGOLLRmBGUOhvGYIBFnriEyQhDKSgB3ZAMdZQ4ooL4WD1Vlvv9V6vewvjaFX0aJnAIBcufG9VCdaiRb32VLnW4WYAwMwXPxcVkDFjBXJ2UXO2AzLAkDkAejuAAww5Z3VDZyBZB8asaWF0By75ksVMBsZsk2XgPvtLQ12HB5yAhOYgESC3EvjWFWiBFnqBFkyhqyABhDeoENagA6JgDjKAAcbAlE8Zchshnxy3Oxw3S08BwnquFVoBFloBl0QlEm0hFmxBmmOBFlqBQlnZFVyBmnOBFoYh1WrJgHQhNT6Wd1P/QRR+sBQoYUE0JHC8IA/oAFw0BBFkARNKVkOA11ERQXVXw9I0DYp9YYsfQRsJwXl6S6WegATRkHqjS7rS2KFVz0TV2GhddOOO9lfHt79aNKPvGA7vOHnYQiEx+nwvAzN8NTN4oLdOGjPEbKX9S0NT0F/8pWnvs6RXWsxyNgM0QAMUOQMe4AGgF6h9GqihlwM01AnWQDqAcxSYzqs8JTri4OZAbAxwuTPulBNGwRQOjBVYwRVegZW9mpXDmha4WaxZORayuavL+hXWeulOQeleIRfiOhd2wXjL1BeKwRIcYWweoSAErQ7QADXDoArSiQ5kwkNiAg8+IRDcOQ/wQELo/2CGzMkOImuoYKOK1wdkMUGJ8EAHM4cHlLGASRBAeE8KmgDOOkotTJQLXS+i01jh2LhFDeN7XfRpN7pQ6djhxvdoFXIjYLQyBskgx8QMXErQpEDQ8mZNnGAHUJp8nSAINHkHKJl8C3WT83MFQuCQH6ACtBt6fdqnIYUBwpsBDoC8yZsBfrqofQAQ8on/ToGrma46kzmZozlUfI6WbEEXdoGsy1rpwpqt/xvA/zsXeIHAabJLiQE5YfIZpEEarMHBm4EAxbkYKAEIwqAI6ADDMQQH6CAMiCAJkkAMvCAQAsFabnfExYAGxaBbqOVwChuyITsQRLWoYpd3Nfvw1ikQ1P/pDpyHt2ZgBUUbDUubpF6bLVQbjV/Voe1stmVbV+EYRkUafHVbfL3W4ezYRXmvvw7EM7NPvBrDDNJgCqRgClzqeZZR36KqB2ZgkB15zR95zZdjqKH3vImaqDNXB3xgDA4lhB9Nn0xhXZlZF3phF3rhFwi9FwR9FxI90bl5rskarvV7wMN6wAn8FQq8wA/8qPISOpnBGa7B07MhG7RBdLZhG0Qd1Ed9G7LhGrDBGqJTdXFBFhiBBUrACl6ADpKACMQgh3CACHIAB1CcDojAC5JgW/CgFCKhWxybWwDHsf9GWgCHDtYHF4YoEsLNnZK4Dx5BELrYCU460UjQ9/6ILJT//M7qyKEdWgu5l9xrlaLr+KF+wKLFd3wz4w0xY95bmqQFOT9Pur9suqQvAwRCQJM3Oc572lEcRagb2bsfoAM2WXMXFqnNlb3Yr2NhQVTw+9Dj69B/QRjolePnOuM9nhd2ocBJ3tJP3tIxPcGZARqoIXRAfRu64UG/YR3g4YpIPdS1Ad6aEN5Kx+ezSBtIvdTXkRl44ZKwQxFWYANKwA5UPIeIwAoQgdh1fSWg3nC8wAqqrellyLHfOQ9EHHCWmIdKgRMkoV287RMGdHE8RBDUQDJ/wNudOwjCfTLJgt05rtyZwAjOHfYSk3tBFLVJKgriWI41WqMzQ807AAT0HZAH/1mnddaQCzm7F/6nMwBSHmC8z9unGaABHgBiQ8AJZkw6YgU8PCFGYAG+4msYXNd1V5/1XfcYvFmobvLAa//AUZ4mc58XDjwvlxMaoOHUtaEb0nHn7wGg2K0f9sEflp8c2w2g5mHmY94b7AGg3O3d4A0eyCEc49IbSB0bmOEXdmEYroMRZkADLOACxOAFaigJbuAGrAAGiAAFYsAKkmAl3jmcht0KMLzZAVQQ7AAgIhHKE8gLHTx4HiFC9AiToDyIIkUSFEZMIIF9wjDh8YMHjxlOQjpRogRIk5Momxw5YsTIypcsl8iUeaXmzJlGmOjEwrMnFp06WTIR2dJj0RkrZv8g/dhBg4YMFSo8hfqg6oMGVRtgrcqAwQMOIWY8gfNmzRxAgAo1qnTp0iZPqFbBmqWr16+7woYNy6u3rzG9xgL31UuMWODCiBEfLpyssTJmjZlBg1Ytm+Vt3brBm8f5nud7+PD1G016dOjTo/354/ev9T/V/kzfk/ftW2Zv8ETL5jxPXjxy5Mats73tGTFeemdNkiGFxQcIMVSMeJHixggYRJJgz/GCTh48FpJ8x5MnDx0v6OkIQpTHjvlACOnQEbiQUKROhAhREiTITqRPXtihEg9OfESgSCQlCERJCTboIFBRRPHFF1rcNBMTEWIRhU4kteShETPI4JFHSIEAQgf/K3SQwQMZrNhiBS1yECMHHHQQFoFjyMGHH4Y4MsklnMA11yy4ABOML8EUo2QxyCzZVzF/JYbYL8TcldgvvNxFpZTGOMYMM848Qw0112SD2Tfy8DYPaKd9xiZpsMGpWmv81Mnaa7HJ6dqeranWDz7yeLPObd7oJts99iRqTzxpyiMPNsYgNwwwpTgBxQkWSEABEUNYcYEFYdBRQhFE4EGEGN6dR0gggcwXiR1ieIFHqxeh2t6seByESSSYYILIJ59E1GtEEiGCRIoryBBCBzKs4OyzMkS7QgjJStvBtSimqGKLGWAro4wZgMvtAzBalRVXXaWbblUzhiCDE2vAwUch/4xA8qMnoohCSlytxBLLXLfgcosuBBesy8AE06JwLgwzrLDCr7zy8Cu5vMLLxRjzkpiXkkFDTWXZaHMmmuuUzE48KMfDGz0ss1xPPS6/rI8++6xmZ52q2cnnnrD1vOfNd/JTTzjaWGYZNYXi4w/MwJETDjdQa9PbN8ncFQwwnSAiSAs1vNBCEnZ4YQV5iHRiRyqReCcGIYKYSsRAXsgCjCAH2UGIGKiehxAeiAzkn0S77ipRJBFFlB8NIFS77LIdgMB4CIxfCzm219ZI+eXXhktj5MxCDrkOOoSggxNjrBGHHmkloggklbzliSehhEKKKar0G8sss9yS+y232GJLLf+1PEyLK8IX/3DDESefS8ZbdsmxxyCHvA1m3XxT8vXwZL/ZPPTMYw+iLb8sPj3il69PPujnM/P5NO9zc/oz37nP/HzW7LNrQNupDzvcZBO9NvSwWT7a4Y5zgCNqUpMHM+5SjGBoIgzd8UISkmAFIhAhD6lwyET6IAtkRMIK36GDHaxgBYPQoW92UEMfCGGHQHynhQ+xjyDEkIfA8eoTgivcrzCBBxY4S1nKClG0lOW5Ii7uiEUcog54YIQnlO4NfEidIhwBCUsEKXajoJ0qVnE7W8QiF7u4He/GeItY+G6MvqNFGmmxC4Yl741wpFjGNMaYZHypY2QKmchuYz14pKz/HQSsByDfQch3oM8dgCSgO+rxjkGqox2FLJ8kxacomJFPkvOb2fw2ab+eta9noJzTP+j3j/wJrX9Gsww7/JGPfbxDHe8w4Di4oQ2pUaMwxggGKmZwghyUhwhWwEEScvUqIgjiBl4IwydkgYdY0QE+dBibF8SghjqIMA+CiEQeZEWIvrEtEGyTCA4JN7iFCAJYgvCCDWjwEaXMwAdL9IgP5hmS0sEBDnPYUSES0QhIuGUToJBdXOQypDHiAhe+8AXCBraLhq7RYQtrGBjbKNE27mKOWmre86BnmVqKjBvdENQ6vAEO4IQDHOEIR9NWSg5xlAMd6DAHLAupjprCcqY1/y2kTvNhyDqhrx75YCQ93nG+8tlDkjN72fzQt759aDKT62sfJzfpj03q42f52x8ttQE1bpjjZvp4Bztm6dFqGIMYxygGKprVAgtSUAxWmCAOxJAEIngBmHQIg3vw0LZc5ao/dghDHcQAK0RggiCIyFUgEAGf/ETkE/RZiGTL9on+1MEPg0gEFf3JFk6EQhSoSAUshnRQXwADGEgKhmr1EoxeJNQXvYitbHuxi9nWxaK4bWiWsJQxKTUmGY+RzJg+dpnq1UYe8HCUo7InDzfdg3vxoEc83BEPdrwUkoQEpDm2u112sEOmNoUpTGuKDpuaF5A1haR6B0nI9Ln3vUzVh/90UcYye+AjqvXQ5MxQYxrSoIZmsHFqPVSzVJ5mt6az7GotudEOfuSDNfmgxyy9oQ1q/LYYqSBDBYrwghi8AAd3lYgVcoCHEZIYnLNiIV8XQrYapu2a2eSPGCjgAAmUKhAPWU/f/uMr/giim+yJxGmBsaRiHOPISE5ykotcDL8YRi/CiPIwCpNRKmUUl44J7jOmUY0y1XIbx22UmjoDGjadxlCl0U0o/bEznz7Ywe59Bz3U18hE5vSVj5wpIc2B3faeD76Adm9U+eGPltVXND2bX89Mgw9FJSplKGOHOy7JMndw99LbBccBnwY1cnBjHOD4ap3wxL9u3JIYyUDGKtb/cIIJlAAHKIiBBUuVNi98IhBEgFWJ8/CJuxlksSt2sXsI28JbUQACMLCDj9NpEPcwNhB2aCEeSEhYWShJyYExhpKXfG1tZ/u3v1WGMpYBpi13GRvbQDc20A1m5SqXzJ7BR5nlHZo/paYfObOZzlhzMzzBRmc7o1Mp++TvfeAb36a002o8CdaZXVJmmVQfzSbuVEVvstGOTpShIe3dcXg8pV0NuchHHo5xmMPk23XHd8nBjqatIxzsSIc5HpyP1/QDHt7IBjNQvYxb6GEGIJAABD6AAouAeAgREQMwp4kJAImhxAjxAiGaeZ/yTH2EhDUIrzHxTFbheCAn3Kas7JDY/xLStVOIgAWRlXSYbLudydeOhjXWTb0wu3vMvXG3o9Z0ZjX7qTSliU2+E55wfw+ezYh/DZ9CCXg2B3zN+la4P9qnj/yKpu+nsW9oHl3dsY6D0yPfauhJ7g1vpPT0Jf98OExv+pRWV3tNExQ87MGOAOpjNPNI7jamMfdojEIHINgABCCQgxLAQOknnPap7koEOsDVglYgNh68gGMfY9M8dqDDqlJMCIcIwoWIcI82n75YQqgKrughghr+kAlU9MIa0pDGM8pUDWZYo0ppZfswuoSNzKApTSFVetdDDvRFgDmXDddwDdSQDd4gaTADVIZEc9/jGZwRD/BQZvRwVPbwcP/kk1SVJ0ktgzIaWA/xUA8aKF1AxVPv5VRJ5TLvJWcDVnEB1kl/B3h/UmbPBQ/XU3resFUeFXKol1Ie53Et511GCBzXgz1+xA7rQA46WDJ+JA/s4EfVlXecgVybgVx7Fw/rgA+90Q3ZAH/NYAyuUAlwAAIfcAEYMG3YYVdx1SmEEFd0MEwzJEIIQXaYgGN2wDdfx1jrgU3VZx8CsYdJIAZa030HkQNDIHV0VUEjYAVVkAZ6MAq1EWbaUBvYoAzH8Bd+MQzKgA1hNg88OA7A4V3tVQ/40D8JeA2VMQ4yk4LqU0r6MIEUOA8qU4HR1TIal4uQVl+O5ouOtnmJ4lTxpQ//dfKBFDd5mQQz0TUav5iBs9hxn8d6PShyHnWNXNVVATiEHgccneddwUEO68CE5NiE8CCO5Nh56Kg92iMPI1V63VA0qdRlCFgN1TBcC6iA1TANzGAMucAKmwAJhUADJZCGOGBBQ/ACFGRXOZADzRcIXRAIshAR6BF9mAAMkZArIgROjHU3sxJtLNRN8MEqB1Ee2bRNFdQpLjAEXTBNhBAGVKAHpmAblSF7YPYN2BANx6AXTTYMd6EMN+koUOMNwsFy7GBI7+AP+GAZrGiP2bAOoOEP9vUn9rMPJqgoKROCkLYmtciVn6EmilJvf4J5ocE++VUPTjWWwrgokZaEpedR/6kUlx2FjdkYeqy3etzQet3IUk3jXfAwhRbIhE6YXNqzgzjXg/LIlPdIDZPRmI75mI45f9VgDc+gDMTwj6cACpfgCGlQAyVwASjwAjmQBA05BKVSQTTEKuSBfXlgBSCpNXzTN9/nfHbYHt4hETk2bdEETBdBQqciBkMgBl0QK8F0Bn6gC91gDcnAC9yQPdvwKMewDDupWnbBW8yAGTo4lEX5XWiZlPFgNE2pDReIbzQDJ/e1GlY1M4qSgSwTD4mCKPDphfbglZ4RlsLoXxi3nu0ZacExDtUYcnBJl9c4egQaeiiFUqnncUTZhFD4hCXDg97QDdywDR8ll/6DjxjKmP+MCZkcCg3P4AwgygzS4AzK4I+sAAqbsAmV4AiSYAh3EAkjEAOhWUExgANWEAiyVkG+pHRWcAMQIUIiNE12IxBwJWuQdULhh03ZRxCCUIiERUOI8HTRR0J40AW7WQNTUAjIYBv+IyiZ0Q3JYAu4IAqpYFoJpQvL8wvMYFwBWDIsZw718A/64A8HiIALyA3x4HifxGZOVSdTJXFNxYKzOKj2oA/3lXH2tYHSJY1DiHrWuGC05IN1OXoQWnLnQA7nQIpOc1Kf16ktJQ6aJg6iCg6ienqahpfxSKEUqpgZuqEe4zGtGquuOhnPAA3T8Axb5pj7iKth4gzMsAzJMAy74Ar/o6CioXAJk/AIjGADBYkCLXADL/ACN8CbOaCjYzOaJeYfxAlXSpoHdmUQXkA4ZINj7WGbd0MIXrBNwGQFdABMeGWaFfQCU6AHwVCJ2kAb2YCTx0AKijAHkiALaocLs1ALvaAxz1A9bdqEDvgaqWgZ9riA4VAPQNNmN8NJVUWoMaieJChdJ5dgCHSNc6lHPyigoteDpidyqydSJfNxKcWXfNmymjZycZmhjzmrjqmhsDomsDoZrWqr00AN0xC0HhomuFq0RvsM8RcNzQCsfxFGxQoJiXAJlOAIjMAId8ACLdACKFACGFACLQBrGIACLuACOdAqdaVsp+KtFYQeeWAf/9F3V3hgfmXzEOiRHrVCCMCEHXD1dHPYkFbQBSZAASigBk4ACtbwfxSWGdhgDaRgCH9gCJRwCKIADLBwC7WAJcQwDZhBlOjoDkRFaPZQNE25gOzgPv3WZqUkYIs6VuvwcZJaNAIqsiMbqVw1qSPHg9wAckLIjcKxg96wUvCYGRRaS6nEij3Ls8PVmLLaoTmLoUFbq7UatNJ7tLwKotZ7vSDKq0ubDMSwC79AC6agmVALCJ6QCZNgCaVACR6QBDXwARjwASxQAs0Kay7wAlbwAl6QAgmZBNN6kJAVfQfxVsGpm47lTKk5fSUwAqPpBQ7JK1VqBYuYAxHQtS3QB5BgC//NYA2VkW7YIJ2dMAh3UAePsB6iRRe9gEvTEIAsN2lvVmhMaTTaYA+ilLoC9jLuYGlj9bEja7uQynrZiLtDCaGVmnq/27qCIsQCCBwQKrzymIAY6ph31DHMi7zJS8U6W7Oy+rPPi7RIK3/Ze7Rg4qvNYL13tAzipgy/ZQy/kAu0wAqjoAqjEDug8DqcMAujJQufEAYbkAQsgAEeMALOIb8okAM3sLVayykoAAOwdgPs+h/oYbYkREHsigclkK7pun0EkQQoMEFzOGLywa4mYAI5AAMxYB454AWPYAmkEAxL2wzRUAywIAuR0AflgQmygAmPgFDBsH/GIG7V8A2CojT/bIYz/fBcvcEZYvkniTIP2JOE1+OfKiuAbmqUgjmOf2mOm2GB7KiD7bhcucdcTxih0zO8xXuPD4uPD5vOXcaKq9jOCQieZQLP7Vy8q4gN7nzP12DP+bxui2sN/vzP8CcN0aC0ZozGgiEMaxw8rrDQrMAKp3AKphDRprAKqAALrdAv/YILsoALpRAGoPkpn+k1p0IEI5DIKZAC2oECKSB1QwADyYYIwQlXn4AHOHADp9yuByEIJKR9U7c2mDBiO83ADhkDXZADJgBOKcCuneLTkoALzUBkwJAKooAJd4OHkEUJlpAKq7WJjXEN1rMOMuwahZY9zuzMhbkO7GiB2gzO/9v8l+AIHNnDG1hYMnmnd+/YDauKgMZ7xTbbobgqvT+bxdJrzvb4zky5ioedgJOZDfqcgP68bnMH2QD9z9MQfyO6tGicDIfxC21EC6/Q0A/90KMw2nE82hKtCqdtCqigCqK1ChddO61wUKlQBy3wASWwtc1aAq5JBNbxATDAV2KQAopsmkOwKoRQ04SYBDhQEPIB3HgzTX0DH7GZAy4ATK25kkkwBNodCYFg1DHQKemKCJTgCamw0URmCY9AEA7hEC/6CIqg1VDSGKh2DYJiD/vQGlbJhDw4jk2jekZY1kVIzUYImMyld45SicD8pauq2EA7DY3Jq7hKq9VrtNbrof8eSuFEa7S0Wtm4Gn+ADdj2GOL/fA2THdkl7s/TMNDR4AzNwAziptlUtsZs7AoOLdqkLdGmQNqkHTuzg+M+vtqqEOSpsApB3gqqsNqykAqG4JmhmQQvAJo48DVegAIoUMgjwClJQAdDcNI4IExJECAlRAQ4gAeLKDYgFitt60KENR6oMmI3VirAiRDajeVDEAPPFLf/0QmysNGpEBEulJFqcAcLcQccRGTHIN/EwAxPGV2jVA8dO8Sa2t+aej3V1ZcN+o5RMz2sio+Rab1F+8Uf6unMQL2hjr1EG8VfQrS+Wm5Hm+EdHn9/HbSWPdBJy+LN0OK/atBnVSWczcaeTeP/oR3sD61FqB3kqBDRpJDsyq7s+iI7yh4Kpo0Kxw7kRW7RR37sqVAKvVIDLWAHOUABJSDmn5lrXtACXlACEuDSKdB8MDBBN3AD+lu3ONDuzEcEt/3bKBQrBqFY8tGuceVL7ToEipgDMdBCAi9CykYIj0AJnbArfdAH03dCygQMj2AHDd8Hh6AKy9DiwXUN6xBA/BBW53AOLSfNvitSPIjXeQ2ei3nFk3FH0BvrpI7ho169X0yrtFrzH4qrqV7q2WvqNk/GYYzrUVzQmn1Wd8ELFBUxDC3soO30EB3Ro93j0l71ql31WI/1pJAv+rLsqn3tVR/kWxQLQZ7sqyAKUkAD/zrdTB9AARIAVzDwArf9Ao/YAtNxA4oMAylwN4uIHQvpBUNQ0zAwyC3wam0uNt7hQiKEAgwpNqM55xVkBSmAB/zLwCdkH8FC6H2QBF87EPkhC50QBnjwCXTQAjHZC+h2id2wDsiMDy2XssI7PcQ7ulUMDah++7gv9Lh/R6buq73/6a7eqxiu6qaO+y/eGLue9EufPDUe7KNg4xAd/RKt47Oj47Fz/T1uCsu+L1W/7FhfCuBfCsku7do/O1RP7Ra9CuoPC55gCBvgARYwAi6AAaHsARfwAbB2AUSA2yXtASkw7wBBJMWNFFbE0BmSxIsYL0SI3LASw4sVImKIWEEUSf8QHTp26ATCQ+TFxCE5vMSgg8eLHUJJcsRI4SVhpE+YInUSdANGChgwrGj81MmgFy84XtxAowdUM2zWrEmbNg3aVGZVlSljdhVrVq1Xq2a1uvXrWGbOyJ5Fm1atWmdtzy5jtuxqsmTGjBHDS+zXXl67cr0CDNiVK1anDB9GjHiUYVOjHDsOFVmyZE+hPFWWDMqT5smdPUcWFVoUKdGjSZ1GTcqUKVSqXMNCBatUqU5AKpyggAGDi905ShD5QOFhixYoPrzAMaJECxgohqCgszBQIEJiAiUZcjFF9ocXxWDKYyVPEiIKxVhpaCUQHfSYEGE8/ynPEBhD8NjMY8dKQZj/Vkx4QSQPlexgiI4XWuijk1R8OcaYYfbK6668IiTGLrvowrCrucRaq0O0OPRwGRHnwlBCvX7hhZdccqGFlsACW3GXvlh8cTBWbsSxsBwTc2y1xlY7bZTOPNmEk8uIvGwTJZU8kkhOjGyyyc9CIS0U0VBjDZXWVFmly1VSKcUQDSyQoITcJKDABStQSAKGEShCoQUcbiCCOBRKuGGIIbzoaYhAMEnCCjzwQCQQLwI9CgciNrLjUP3EEIMQ/azIYYjoVMKjQCK8iMQiK+ggRBD9orMuEAE7UqMPOpIYNIno6pBElFl8KaZBCzFMRhlcjcE1V63kukpEYdVqhplim2kr/1llo4lGGmefZZbZZpqJppllrJ3LwmGE+aUXv1qMxZVwByM3MHJbdIUWv3bhdq8VWaQlXVpiGXeweMkltxV9WVGFlVb81dc1gQXWEkhUfFxtFNaA9PE0LVFJLWLUQpsNS9f0XQWWjGeZBZdU/qCiiAvQvACDNM384E0xWvCACByMaqHOG1rIg09Dd0oikBRwMMiOSCLxAiIxcIg5iTwiAU8MPOjIg46XS4KUPYNEsg4GSBWyAr2KLqKjC4Q4CgMT9mIQIYYYWqhDlFRmCeaYY4qx8MJckzlm7ro1xDvvX4W1dtppq/XbWmFH1NWuYYoZJpheetGlFsfrJexff/kFWP9fy/U9t0XNW8xll172EsYveFu0BVx66cUXX8tzVCXggQleeLWDEZbdFNWATO1hLSM2jeJSUGutFVS6bD1jWVLZg4UW6Cih5AsoEOGCDzAo4YOB4jzwqOWyplMm+6z2ogQYiCJKkEA+RUQQo9uLBJFPEGFvIYdyCDS98ojAQxZCcEjCVUS8qAESXJa1hNCvf2FQw0SEIAIR7KkOnCBFLHBRq2FUsEJxu1Vd7OK2YyBDGYTbm7D0pgxk0M1wFQyG4nTRuMeRq3KtIEyObvS6163icpeLRStOFwtb9DAWt+jhCnuxrV0UcXOlM10OdxgufeVwdRdrxetM4RraNcx2t4v/2BUj9rDTlKaLoqiYanRHCi2VAhWyKIUcbFADClAATSajgBiS4AKBNAcFKUABCgQRiRK8oCI3oEMLlnYDOfJET3nEBCYSspJUROKPeUgFJrwgCEJYIVBJwAEKXoACIrBpCC94wU8EMRwiBAIRRFCDGgxiBRWoQAj3CUmq2GMCEeRADHVghJZmRcFh4AWDv9wgBzmIDGIKE3HCEEYwhOELxu0CiLWYlyssZ8NVCOxyUGyFDQNmQxq27obfxKEO6dVDWwDxFrdYoS6GOIzF9WJFnEPi6VqxuXmBk1/e7GYVtSgxfn6Rd6MJjZV8dxrWrAIVYAJjKVIhijScQHm6oUAX/2JAAemZQE0wuAByPuCB3yBiZn7kiBVukCcYqGQIeUpCClJwnUAVoQ6E6IjPxCCITpyyOkVwSUNwUJIYgBKUTGMTETJiByJEwg6ajIEJhGCpPIghDwH6FB4EhQc1YMKMs9CFL7aFTNAhM4Up3MteUshMxuninI9zoitoKLuHDSwVb/2Sl6gpV8ytTpqqu9G/7gpDHcJQXOKy3DjRmc6s+sIXwWDntnohjM8V0Vt+6eG8fOhDe0LxYq+bHe5SQ6XUePGLpblSlUQzmzCm4kulAGMqMqGGE3jgBtMzAQZS4gGKosAFLlCORaR3pw/U6QP1KcEQFLUTRBAiBW1yFUSGcP+1GjQXpt75xCcOhZ4ivCAhMWBTQ1bFqkCgIA+G+m4eCFEEGCQhBlaQqBc+ob+NiOFn96GDIBS6NlxotZ1CZBzHZuFE10lRnwsjqI8OlkXd7U5LqtjSwPLq11iwIl8AczC+UJfDzY2znOo0rGG/+rZa5AKZDtoqMhe3Cx8CcZxOlOe/sBlFKtKOFKNADZUkMzFRgKbGnQmojWsM2tCcJhWoIG0pKEEGDYyAThgQAQYQ8YIPmMk4FChBCVRKAeUo5yF3soNKYTBSglykPpaKTlHUI4YwlFl9driBFwRUp0MlAQUHwUEk/vQJilgBlIR05BAMUgSI4MAEJlCBSaLbv0//BcIO0VUDGtbLscMGoxa3qAW99AsLSsOCxVGsJsEeplky7rOfEkOYKminMB+1uJsrvuESeVhOdDY6hcKo4DDeFoxcOOgYsd5qt7zVw1vo1xZOLOcsrilX1xysYDQmxYx7l2Mb65jHz6YYaRY6G1FYIgoVmF7KaMnAEWAADzcYgW2bHG48KgcFI3hZCh6SAjsYCgfHtdT7kiCGkxJokn0Igx1KQQdEjOpQhj5UpYR6vk9EgtDXQQEO8KAf+nkZJq6UiEOyNigyR0cNNDBEKnABjFeftRb65VilLY2xt77VwBAjIxcJOmCJzfgzQgrFYyLz39XQEJzi9OGqbVGLFR6W/6u4DkYxiNmMCsJ6W3sZMTnPybFfn84WwsYnl4hHxRa/OMaRiRjMTxNzziaboF2cDGlGG+RSRFcSNHCABCSAgZHlJgK5QcFPpJuDHEjPA+VNQnEIQofthG9PdJBjnobwCTvA4CE7XZUdmhYeQFoEUnbAQx5gEAbhIscLUkNOEgTxnIm4lwh0N68JyIMQHJgtCRnxgnXpgN0b1KAPsChGMYIeDA1nGBf63WErRF5pufa+9zTM9IFP/bobWvOGg2EwX8U1r3k5zvmbexeLWOS5XfxCRM34FmFieKPDsAJhj4E510EBCoXJfPznRz8olnQJJal/E+NfEvpDoZnzx/wU4P9XWMdgIYtPGGIQdeiDOwiDKjgBDZgAC8AABMSAtYOjD/gAfssBDDAOEYgyQRCEF8CkmPEj88qBFDABPUkBFUgBmCCCGMgOGCiCOsGBPMgDFuCU8SKPlUjBIsgjFFiIiUCEHMDATWKPUMIk7ICBGGiJpoGBF4iBQMOEVBAUQ0kCFTABDJQvYJC9XvCFnsOFjbtCjqEXfaE03cMY3wPDTMu0gRE+LjHDMRyYm2uiwFI1ejmiWti5yKKnd0qXXVCXYWgGa4gGv3iFFYEmyMEXHFEFxgC/8Yu5UUg/9FuSTagE+Is/93vE8VsMVngFdeEFutAKazmc2CuFGdgABzjAC/D/AA8gE+r5ADvAgQswE+nhmYnCgUB4ASTDgOnpozxqgSYrQRH4M7IxQRNIKhMQFPQgiorAJIdQPLEhj6VZlY4IN+cwCUJAhBJ4M1B6jvMoAUXJARNQt/I4KWy0gqT5hJQ4DxOokx7YA1GYIHS6QtvDhV4Lud3TGI3xPY0xLS+BKzREsDKspn2UOjE8PnHaQh1CK3qiJySihdKBQziMkSLSBVvwnGJoCmxYBr0QHXjhtR5KHXJJjPszP0VUkkoAyZCshPc7v1MADF74hQrJFWigBmqohmzIhm34BnmgyW/ohm1gBl54G1h4Ag0YEwhQjuJAAemhnvUogRGggA+4ABtE/4FZ7KTpuQARKIrlaIGjPI4/K4lP+sAGYqCX+JPsiIRUCCRMEoMa+AAvKAJEAIY+SMtP6INNsqQYwIRPEC4rsIMXULf+uYE82BRK6SmGmDc56rxNYQjxwoP+yQErQAI1kIQr7LX68gXHdMd33L2MkSuRC8OpG756BEM1VLWBJMg5XBHCOqcisoVcMKvEaZteoAW3UQZj+IUiks3ZHJ3NEQzu476NDAxaSBFfyhVmeIZpqIZrwIaY3Ibj3IZuUE5vYE5vCIdxYId7wId5WIdtgAZi0ElgeIMO2IASQJNsk0bdYDsLACXjCI6kTMoPMI4SYKCojDKNksYRcMJAGwITgP+BDwA0FUiqsvkfQAKPIrAkQmIBKwiDSECGSAiDjAiDpAq0HDjMT9IkolmIG0AEWfCC9QgEPaEOIoDGMEu9hiCKQYkEF2ATBFWDQfCEK4QFrMqqpZsFkdsv3oNHeLRMYquhYkMwVTAt0+rHbJqmVNuheaGXSHO+DoOmDruFXCDSRzunFXq0WhC6UFiETbiMVdgEtmnIxyqizpERFXmXFAHTCPlNZmDJa4jJbviGmaRJeZgHNp2He2hTeJDTOZXTdVgHeIgHeCAHeGAHcnAHe+gH6rTOsmiGSQgBEAiDD3CACEiypNQNE8iBplxACKCl3GgjJBsBiyoZ3TCKcDOKO6H/AyIYgRh4CfQIQibbxcOMAfFqiBvIgjyQpDBogTCQhU7IglQShBhwAVK1AhfIA0FAgRhwCJe5AUEoBmBQCEuhFErh0PiaCONYCIzwAjwgBIsSKkuqgTHIBFm4PVxIJxd90RUN13iUxy6htMzEx9dJhRzlUYHpPRzaoUhzQ1pwnDh0PiU9zehznHNCJ9nsnFtzhV7oIF+AhX6JhRhByZT0TbooC2gYTjSdSTWlyXmg2Iq9B+mUTnzQ2I3l2I7tWHaIh3UgB5FlTnjgBm3IhmqQBmYwhlnwgx04geCAgNwQgQ/IAd5oI/NsQt0IDgzIVBPIjVmMSnJksvMaAuxygQ/M/wEYABVE8ECzER/7dAnyuAEUKIIsuAFCCANCEoMiSCSfIQRShdQ8cIGlMa+4IwSHkAVkwISLwA5oVAiHiAQLhROMsAN7swL2VIFLaoETAIJHgIXbGyx+BdcYtbRzzcx+HL5umrpv6hI2PB2C5KHJjSxyir7LfRfZpIVfCJ1eMBxXyAViwIpnGM5s0IZt8IZ1cNM3ZV04xQeMfd2LlV3Z1dh+wId+wF3bnV3ZnYc5XQdvUM5t0AaUhcmUfcmWfAZlOIZeCIVJGAQiQ5MIgAAGwgAT6DaImsWI+AArGAK1c4GKch7qDc9NAolp9QIMiAGloY8SzMYnhFRDUbdMYY9MAv+kPCgCPAjL4sIEFdhV8ypBl9kkDiWP4qqDrLlQ+HGJFzi0cKS3HKADWUAEnkEEMUABQMuB8tCkE7CBQyiF+rpCs5pMcQ1X3cPM3xOYezq11kDDKIKwwUCxJQrNGNacd1qRFFFYYhjTZwjOaZCGqzAGrLgGNbXYjM1d2zXi2+0Hf0jiJbbd2IVTmtTTcQgH5+SGkx1e5BzeLNbibYDJ4sQGbcCGMG6KZjCGVrgERRgEP9iDE7AACICABUAyE5ieoM2jpYytHEiy6fFZDLhQ/SwZn4JG7EpMoDEBQvgEiYBGwzNComA4RLAJYFiaA+FQO2gkSJEUunMB/aS7s8GBHOD/HxwQA7zMj7g7zF6dEzqIBDwQhBw0iUAwikipJFLNSivgHwIlhFIAhsPKsEbTZSq8witUOYLCv8YgNfDDHbaioknEke1b5nJ5ERd5hTDFC4YlU5c80ztdUzdl02ye2Nl904z1WNidB3vQ2HjoUym24iwu3nVm53YmTuLEhmtwinme56iwhmlwhmTYBVYABTQ+hD8YhB6wgOdhVKAdgQ9QO1V0ATcagU31DwdVgQ9onz9LTE46S0ywgiYzgUFRgRfAg5EA0SEogQu1rvNijyTgvzt5gcTsy4doiJegO7d1UFDqDlCKGbNxiAKqyhsoggKNhC44Hy/QJOIgEFtywiTo/wI8MAkiCINH4NbIhMysCgbSzEIt+bHZUYVD7Iz6eznH2MjEAAxaqGGUnGascAZpKN3TRVNuXlOKvdiO9eY2lYd4oOs8tdPU/V1vSGd1bud2Jl6YvIbAXud3zgYz7WIx3gYxVmzFdgppiAaW5QVXMAVPcIRBkARG6AM1aDskoyi2a6PmcR6I0sXi8o/pGQEGso9ZRMoYqJ5NmUXWNsH6gImYUA91K4gkOArxyg1prNobmJORKo/EdAkdbAFant+ZmRMj5FAVuAiRQgGI6LOsCTSt+Qn14LujIAmKWIk7SAVu7VZfmIVeiwXKhIWr5tHWgLHwm79EZO/DOEmyxsRqNv/T5ExTiYXiuiZnjb3YeKCH25XOmvwGO03Tm+Trvq6GlyzewFbwBb+G4RzOwG7JljzwwD7wB6fneWZwebaGxQ5jp2iKxrYW2KSFU7CMSXCETrAETCAEVdQNEVg7NOEJCYg7pfyAJAO0Q5FPn6UlJIvAEXgBpPzx5ZFjF9AT+/RAX0SP4Eq9+iSal+mjTIJL8tBBHABRDvTt8qiZkRoPPyKCj9DPiZiaUCKqlzgaOQOk6yCgSD1aiWIIIugDSsCE/bu9jnlREha5dsUcV1iMrzbJSqw+3xzdBzdO5azvQjd0iQ1wkSUHKQ6HcOAGR0/nvgbsws7wBK/wCafwS9f0qBD/zmrg9KjYdHu258aWhgu/Z2dhFmcQHK2oi6NzHFpgBRgLDU94K0yoAemRgBEIBBr3gECIhKQkgjY66JIxATqoWRHIVN6g3m4bgfPNo+n5RQYSDqKozz2JiEjgXmHtvOIwiSSAiOTKgZq5CIfon/IQlP+xgkr6PIXogoQgj/JIM0HwHkLQCIMA5aOlD/6RiUrRE0xKnz4ghE6gNFnYPxmVR0qLhQ6TkZSM76mghvmG2Jpk6zil0ztlTuUMXi4e7Ajn+I6PcE2v8AwX+QXH9Ew/cI/v+GmghmnQYWfR4WhR9VVXXlt5EG9hke0jZvJDRPWeItlBLYX6BDWwADKhAO8C/442jglNQhMLoKhL/eiSaeiezcbg8AJM2KQRCLdCOW0VqHagrqQLpojEdOC48wi5FYMAGdZIIY+XuSQ6eZmsqQh6+5Tm/hRC+gQ84JnrWBSiyiSFuFCBCImA20FLIo8WqIE6+IT9O56g6ITG7wR0NCxhMAamEOKKdevWZV3Lj9O7tuJ1rgaU93iWdHjQ5/gDt4aRX3CnSH0Nz/AJP/mVlwYdfoav0BUNOhE+tBGOTMQlGcmRXESS1IwjCYXheRjfQYSYTU8ou8WBRmg/oh44gihLPc8af1SRdvJPRQFq5Q39ZKCNjgRf9CNAEQGF049DcZlVqRkc+IBf5R+LqGWG+P/UZg0U6XbgQKAfhugUef/ovSQzV4mEIQAIQniGdBEjpgQRIi1eWMkRI8cQFAwFCULUR5AYK3TqhEFjqFSxYsaSPfsm7+S8kypPrvvWbZu2mNlm0pxZ7ebNazpx5tzZEyc1atWCCuXJ85rRpDqR4rRmbRpUadKeOWPGTBnWZMaIEfv1ixevXLlovXLF6hRatKPWjgLl9i1ct5vmXqp06e6mS3P3bvLk168oUqRMkUJVihONGh9aWBFDAYKHDwkxUMZAoURlCpolUKCsGQIFESYwiHgREcMLHC1wfPiAw4UIFSJmm0iSJ8WHFyY+4THhBZMgQnYC3RghyA6KJISI0CH/FChQpEBerFjBE+hFiReBBFH3QiQGESvTh3jxIiaPGC8oYqBoUSQJJjuRPkFH9NAKDhxibjB8IfEFEShYEV4RYqiBBxFd2EHEDVXUwUgwyCyzjDPYZONTNT4VlaFRTlmzlDXYiDgiNteUWKJOKGZDIjYfLpWihzF+yBNR1EBDlVVZJbMjV115xcsuYpH1CpFFlsUKkmmlNcopbIUCylpPxvUWX3lVORcoe/m1iSiheBlKKZqYcQILHmDAHgUSlDCCmRdQYMIFH1DQ2pxzWiZnZzF84CZlHwRCRAkloIDCDRgEaFkOgahgggsmEPGBCZBCZJ4swFFkhweIyOIFDoQQ/2JFEoLkQQgdNySRXIAIETFdF1YMkQSnSdywKh3lBfiCCi94QUMRmIiBBx1iIJKHFc8xF4gYdCRBHUGI2JEErMEC20UXdARrxx2OBKPMjlhZxYwzz0ADzTTPPAPVNDWiu65T03gIVbvTVCNjjC06JWKI+LYbjTPNfHsVtzsas1WPPRL8FVi/7OKVV7s4/HCQYo2VSy0Vt+KKWUiqsrEphH3pJZV83VVXJSWXfNcqqKCSsiqtqHLLLK3AUikNElyAggWafUDZBZZ1phkFboqAQc9FBy3nBzDESVkJOZjwdAwjEI1CRI26gIgYqZVAyBAjxOACCnSkgsgnskQiSyqy2P9RgyBFuEdIHzYQQqysOBCR2gt44OEFHdQNOB1DweaBNSYDoeCCeEWEEUl6mETCt3Vi5ECHHQPmwOwQdODx6ebBBkJtsNbWIcktAxtzzDHJYLW6Mt868zrs4Uo1O+3StEtvu7NHs/vr/uqo1cAFMzw88cMPc/zBwy/McC+6QCyxWBXXEgv1rViPJCsbo9IxKaOQ8rGUWV7JFyecoKLKKoOpQooqs8wCCyydsMBZCUGj4GYJbtqss9GWPT20ZTCQg55dBg/5u4EVWiOCJHzAaznIDoCI4IIc5EAidisBo17wgTwIAgmCUMPgzMaCE4QhDH1QAyGE1bdlwQAGdsMDbyL/NwQENcQKw8EDJoSDCDyI4TUoSAgmZIEIK3wCOasigglyILmGkCcGMRhCsQJBB0Ts0DqaM4gd8NAHTMRCGAMTSbdYJ8YJkbEZy2gGGnenRn6hkRkT0pHpjFG8hjHMYcXrxS/wyDBheEUYfPyjMI5HjGT0iI959EovEum8W+ziFtJ7JPWqZz2MuaIVrNieKbTXsU0KJjCi6NKX/uKJUIhCZSojRSkEAz9ZeIIGE/hZADVzgUD9jAJSq4wIOiMCAsIAg7PEAA4CMQKpDe0CJogN1HJALCJUEAcowIBEBKWCHHAKBSOoARGSwIIieMc/ecDD4AzUB+okITyZY054sGat/2BlxFrJelwL8iALQhyOgmKoSB6SIB0cXM4LDsmmdZIQA79R0QvW2ZverKg5cGJiFbc4XjGOYTrUIaOiyFAGMlAn0TgO7HjDaFgvHga9kY70YYnchR7nOEc/7jGQw9jK6U5HjK189I951AVOHXkLR0qPetOz3iSxh7HsbayoRe2YKU/5yS8JpqlITUUqSvFJ+HFiBhqYAGcuECccEA01RBgB0Eijy9EQLQKUscMQggYDK8xyBB/AjDGlFgMTqCAic3WaC1wwghYQKlAjcMEQckAEMRDhglrDjxc6IQY75HA55UlCsLzzqiOSxwt2QI9kG7Of5jhzUYF1IhSBlQNoDf/hVdQJBIJKa1Cs2ZByBknoYnmYh0+kYhbBGEZIcDsMYQTjpA4bCy1okTHsaUyoF4skLSLp01rcQhfNxakuEpnHlLbUj9b1o0ex+1KOou4X2zXG8bzL2+Y5txZisYUtghtJSg5VYxzjXlPjSwpRlKK+oAxF90LhvfiOYhWpEIUnOIGJUmCCBhqITGfc9IFlgfVy92vNB/RKmdiIJgK5lGX9YDDhDwxNBJDCwJ4eIjVIRSpSMXCmC1D8ghe4MAf8dEEM6EBBhYinBnUgBCICgQi+iWEIMEiIF2KQEVCJZ8gDsgIMfOyf9ZigIRAZ6BAyAkWnxRgP+CGCaafTNx5aB7X/WcyDHQQhRUGkAn7Wm0UkjaqKJbGFLZtEqinVrApWtEK5y63YTneKU4hRV6XXFSRM43iMmdKUpXwkb05tkYv0BhdjFyvumt/8Zv222UkgAwWl3ayKTbYiE5JQxB8G4SAQSAA0oKkMiPPwAgtgJ2g5Y1qHZWOC0Lx1Z9nR6micNkPR7AwDkWoUaUo8Ahf/UCBgGxQKnqYCJzrNCoUKWxg8GAlERCLKXoDBDTJnkMtFAss9Do93vOCpGyBkxcsmMqwouGwnCnRyVliPRsQzHecslg55kGIWF2uHX0WiFLDYmFnMoiS1MKnSBn+zyjpWVOKyAmPUc0VwI45eiPG5z8XT/+4vuDIMYghDGWj8KJBEGrFaoDeS19uYJY365iZFCUppQZIrXkGLXCxspqprnTOi4ZRomBEZgMhABhTgAAdIYAITgAAEJOAACpAbM6B6wQgUbIGllWCui9JqnCCVvxJ4AYMYGMEua2OF0eAamaQBYAms0IK3JiEHkvnqmqD2tCQCygqYuAMaCNEJWJWTCEkGZ48DMU/myBjLEBE8JnCgqyQkuSExSMIQVFBXZQV2CDHAQyT6JrmBpmdzv7psIL5pHTtclhAUOYQo5nwWjA289QM/uKQ3qXqGN9wVdg6uomn+W4o/TKUf/WjDkmGNaPwoYtCLeKOPdJbWn4UVM1+YMP9srowz6nxE3ejGN7J//e1vY0TDP0Yo/NCBBxx9ARDAKtLTzx/KXK7XmMGAoFBQAtnkoJgl+EAK4D8aO9DhAnVNglthgBX8ldv1jAgMk1hRBna0RgmwhmCNAAq0hgnQgdecygvcAAtEQiTsgSR0QhTdwI8FQnxUx3xAUd8ElmA9EbL8WHkE2eVYgROBBx5gzaToUyCIByIkhCDMoHTYWyBkkRShVrFcViTkgRwkwimQBS9kHFg0oRM+IVicwpRACeydwpqdAsyxF8QFF8VIDO9RHPT8Vi58hcNwITIMXzKAxczJHJFEXC40YcZJH7i4i4hcX/bdIR66xEt0n4gwBbv/2AvPKYMw2IInQMIcZMDRQQA0fUCp+UycBMovBaBmYAbYEM39wcBbNVkezNoHPFEnVgcR+Jqk5ABpzNUIjIYKYIALAIhbrcmggA17oICLDYhAtIAYREIn9AAmGIIlcAKxeAeoGEStWI5G9NgElccLMN4N5oAdGJQJBhmWTZEYLEtCPF55VMcOOUd0mIcV/cq9RcfmEIJB/cEagEKP8EjB9AgvEEMTckVYkAXLYWFamIIVFlcWaiElId/MkZSQkBQX0pzCiMUuFMMw9ELwFMzNgYvthMg2YF8eat8eXohPlMu5rMu8VANUBMVNiEhDdkOLRIMgssIoeAIl+MEGTMDQ/9USiEXdMGGH/AXK/V3Go8Cfm2jV/V3AENiBCWBQ/qSAE/mar6XihCVRKkZYDCyKCIiBLORBbiTBsSXHiuGAoAROCdwAJiDDJ/BiJnBCRugHDHDKqqAgtAiWrlFNNGKNIPANqdBBWFYHjk0HddBBYEGeFZBZ5Ngb/91b35AgMARREeFQJzTCK4DFIBFSOrLjOiImHH5FLpRFWeAje9VeJDWcG+qjPh7fPzphHI4EVjRDMrhCI7DeKfwCNtgh9l0fTGyDTsQLVOBIuOAIVbyOuZCLuVTkNIzLTUxD7ViDNETDMhyDMLBClkyCIhwCEpTa0nHGqoRVW8nfnozAC8CfC/9YYv3YCQaJoIJFygd4wTERE2U8zdflQKMk27JFSgkcRwmwAA5wSoRZAUNMYwtgU6kUwQlEQjNkgiJwQih8CiF8QjYNyBHJYjY93uXYjXhUjhd8Qmb12OPpEw8NgeENoxcMwQ1SDv+dTR7QQSA4B7AEwid86CdEAiZ8AiLcgR+wAmG64xM2ppG0aJFsIXvFAi1IT6NtoZDMHBeKIRwWzEiojlWcy7xgQ0fqoUcaA5HslsMYQ7uMC5My6WvGZuy8zr9Uxb9YBezUZrg4hVSwERopwzEMgy60QihsQih4QidQAhKk32NAQNJ4QJqA2FuVQAvcUnSimlvtyZ7sJAykAJz/YBCkwMAphsZoJJHTSNDTBAppoACxBIp63sBr5BURbM4U4EAN1AAd7OAJyUEqWMIkbKUX3AAhRAIC5UE2wYp0LAuovOCl2lASiAEhQEt18M0PFYt3DBQNwaV5UJB4BAIyqI3mPAew5sE3iQEmFMNSigEfjMJgNuGLaozLbEztUeYkWY9y2cItoJei5WjCdAVXcCa4iAs1XEM2NORD3uH2ReRMvIg0MEO3LEM0UKS4PEOVMgOWUum/+ItVtNEZ6esbZcVIdJTC7IJwxQLHkNIolQJU3YEFKJ35IR1nEE1nRGBr+AfPdMbXgd2c5ACCFI0xaZAJvIBWKR40Pc0HVFCi/5jH2pFngt5ADbBADcAHHZiG1+BBKmDCCQ3LarRAFdjADPBBJmjCJUyjQfXdNFYHDEIROXmBPmGCCPLfgCzLN1FesYhHdSDLkMFlOuGBHXxCCukN/x1UM2qOIIRoecjBJhAJswbcsxqVJWnMy2HMPi7Mxg1MMlBfvpDrQ66EPKyDN+yhTNREuuoE4KbrvcTLU1yDjTBpvdrrt/jLMqyOwBCMjwRJo51Fm4VMX/RFgJWPJ8BCKvTBwnIGBJgfLGkGnM7JWwVN0NzJaJQAZyRLCaTALF1AdO5kpHiBBpVAEuzYgHzA4UjRC7SAtaxKEkRCFVRBHpQCIpjGA6EAInQCIf+owScIwg/VwA1wwR0wgiQArUFYFjqtymVB6Kq4CpbtG3QUDrIkRNJmRLKUk0aUh7Lwzd0UC+YNUZR5mb2Bo97wzdd6wR0I5mB2RYsO1ykMVS5wRbfQq+0I6ZBmnzw85PX9rbjWRExUsDZsAwZj8AVnsDYALjXEhIlgg7voprz0RFDUZmx+y+MaJhkKifK1nsFVGshUiV9wgl+UQiScgAV4gCJiQNIh3ZuYwKndydfxCZ4szexikAkMAZyYwOOA2P0tGWXQAT85pQsgBAIhAh24gNIKAjBEbw69G3OYQAz0QR/kQRGQ6g2gAA5FAiF04M/aSng4WxI4LYJoLK7u2y3Z0gcm9A0RjMp4WEeUuYq8oRu07G5/avGYJVSoolZCiZ6V9UEhnAIcDuYrgEIlgEISQhzDLAM2OPAD46EGAy6NZAhTTHBNvIi4dt+4YjA2XPAGw0QHj2s2dHA1iPBTpIuN2Ii8XoVW9AjCSAxZEJeSjAI9EhyTnIIpsEX3bNJIipIn7MUlcEImMMIJaEDOSECpfQZnvEkuKVhlHHER/wyelhgM7KSVQZgJWJPv9kleRSAE3cC+ucAf94HZ0EAeqEFhrUoMeIEghMEN3ICwQtF8iMEWdUInaEJAAAAh+QQAZAAAACwAAAAAQAEAAYfovp/dsZHaq4rSq4/Xp4bTpofQpYfMpYrRo4LSnnjMoIHKoILJnH3En4TDm3/EmXu9mX/HlG6/lHS9lXe9kG+6lHm6knO6j2+5jW25jWm2kXW2jm+ykHeyjXG2jG22i2iyjG2ui3G6h1+1iWW0iGWziWqyh2SyhWGxiGqxh2OwhGOwg12uiG6uh2auhGOug2GugWGtgV6rh22rhWaqgmWrgV6ohWqkhW6mgWWigWmqf2Gnf2Krf1yof1ykf2Wkf2Cgf2StfFGofFqnfF2me1+le2Klelije2KkemKkemGjeWOjeWGje12jeVyhfWOgfGGgfGCgfF+hemGfel+he12fe12gelyfeVyleFWieGCieF+heGGjd1Whd1+lc02fd2Gfd1ufdVWfclCcemCceF6cd16ceVucd1ubdlybdVubdlicc1OZd1yZdFmVdl+Yc1mXclaUclmWcFaacE+TcFaTcFOUblKUa1CXbEqVaUiQblWQbFOQbVCPalKPakyNalGJalSTZEKMZUiJZkyJYUWGZEyGY0eFYUeFXUCCYkqCX0WCXkR9YEyAXUN7XEd+WkJ+WT14WUOAVTd5VTx3VT12UjlzUz1vUj9wTzl1TTJwTDRtTDZqTDhqSzRtSDBoSDNsQidkSzlkSDVkRzNlRTBgRTRkRDBiQy9kQytfQzBbQzJgQC1dQC5hPyddPihaPy5aPilWPi5dOyRZOyZXOyhUOitVOiVaNh5UNiJSNiNQOSlQNSNPMyBMNidMMR9GMiRNLRdHKxlDLB1DJxQ9Khw6JRY7IhEzIRQ2HQwuHA4pGw8oGQ0oGAsqFgglFgomEgUgFQoeEwcfEAQZEAYdDAIYDAITCwMNCgMXBQAQBAANBwINAQALBwELBgIKAwAICQAICAAFCAAHBwAGBwAEBwAIBgEFBgADBgAHBQAEBQACBQAIAwAHBAAFBAADBAAEAwACAwAHAgAGAgAHAAAFAQADAgAEAAADAAABAgACAQAAAgAAAQIAAQACAAEBAAAAAAAI/wDBNAkDRoeOCQZcMNHhwkiYMHPCrJlTo8acOUZ6hGHyA5GaM2u4CKnxQsWLGDxifPhAYkSKGCNGnDixwuTJDy0k3cLFK9izZsNy2dJV6xUvPVC4GBHCo4bGMEqNSI2akUcPIT1gwHhxkofXrzFKxmBasWwNq01jbIWBEmvYGG/FxjDxwQTXEylmxjwRc4VfIUbAQPJ0alawYbVYsVrFeFWqU6JKSZ6cqpQoTqJMnTq1itQmSpEoUaokutKmTZgsFQKE6RMnTr6aJWsmO9mxYsWICfvVK5aqUJciXTomTZUbQJesZbM2rfm0aNCjQ4MWPdr06c6cYc/OfRl3Z8yyM/9btgyas2jPqyW75GYMEBwgIHTgQD9Eji92ECFqhYyaf2zP/JTMgLKBEUYTQwzBRAkGXMDEEGH0cBVEawCWkREv1LAGHlbcYUcaYBjBg18lnZTCCHadgJJffJlgQgw98GBCCXPIcosvwzSDjDG+2CIUK7wkggMTMYZVgxFKXWVhRiRZVaRaKqiAUkpwtcXFHFiM1MNSJBkhRkRCqHUSXHLdlYJJKZBwgkl4nfCBTDPFuQIWXyLiyU6HJbZYY6xUVkoqfkpW2SicnaKZKZ1YYgkmjFbC6KOWJJLIJp90wskrvdSiaSyc+jZZKKACd0kovwFyXCjZZFONc9Vd5+qr2W3/9x0z4YlXK3naQTPNqtVI80wsgAABhAws2MBCCBVU0IEMXfBxyCKWBEMNNtjMRiCBTGyUbUEMGNDCgWHUIBEecxjUZVQQqeHHFWqQRNMLKZhwQksmmLQCD0IIwdcIH0iZwgcgzIAKML4UDIsvvAyVGC+d+OAUD1y5kG+MEl7VA7wqnHWWClqxJQQWYSz1FQ9IYlUxSS/wwIUYQkRpUpQp5OXymlJCbAIJ8crrpkxwziTEl3hMgoosOAb1yp6MKcYZY5ttplljTZ8yymlUo/boJp1gcpqlr13i9SWOMOJIJGGLXTYjaDPixtpr/7KNqs9VZ52rc5v33XfPgEfr3nyP/+edM9Ks2lyv0hTjSA45AKHHEzbggCx9R7RxSCOOrNLfM9cekwwyEkm0BhNglDCABU00IaEQBK1BUJISujDEGurC0QK8ec37Zkw4w3uCV/POK6UJGZSwwSS8+BIML4yIQksuvOTyiiu3nLGDiLSjddZXJUlZg5E2cYWSiF6RiVIMKL/ggklbGgFDvVrFoEK9ca75Vkp0lUQTi/fvq2IMeEDSyi28GMYwbKEYV7SCT41JoKGYtpnGmOITEOxEJ1BTtQl+4jRdK1vYAMFBDuqhg2xb2w1ukIO1HSNVzWnVq6AznQDdLVa2olUMabWMWgVOGs254U+Mo7g91MEHNpBBBf840AEbKKEPj2iEJXBRjGYwY0DMkA24CPI6MDBgATsI2RomIhErWEEqNQCMEFxQgxaswQ8uwJkJ+LWSDGTgTbvjS+3gEqWwUABgfLgFMATIvOYJxRarAMYgfpCRE9QvLPfjSswyhLIadGwrUdLdy2xSPvPBzAUuWCMJXDSiE7xgBXICZQo+iRd7+QWUI3hjS1iCEjxIwkakGAUrcOGKWtpyFYrZUy0TyDSonYIUsZzg1iR4Gq1JkBNgS1vaOBjCZoqQhG5ghDRQKDdYuSpA2OROgGjDTSf2DVfaqQavpmGNwBGOGI7Qgx72wAc14EAGHIAAB4qVBkEsQhGJsAUyavP/xANNZCLkQsEAQGAFJjjECj9QgxVCpiWT1UAHNNLBJtnILzeu5CUvQBFN6EcCnEnAAiCogiyAEYxg+GIXvPDjLgJZiS/ywHYziVfMFrlIs6wlfCehWZxM0pSKwMsEMo3ZzewSgxXk5QVxykvMVlBUeBXVkGraV0dHQIKU5SETsiCFHkYBDFrM4quzcMUsYEFWWNjSFbxcxS0ZYwpTkEKYWOtEpSAYwUQxooN4dSbbxoC4EZbwEtjIxjaqOZ25xUpWL3SGE7tJw75Nx5zirIZylrMrajwjSHrgQx3a4Lh4QkADLMCBHAjxBz1cIhjcVIYWI6K6IbhgAQv4wQ/AsEUm/9hhDmvYkoRIxoN/YcAhKwnuKmNCVZhldE0u6qgKPrqBGXiCpEHJhXSFwgtaAEMWaojRiTJAk6HiZZSRZOT2uJISQ57JfvIjSVlU0NFRuiBe7T2fTMM7ygx5hSs1K6pfYsCXlsApBn7IxC1akYhLsEIoXv1qWcv6irLmkhULfsXRAGWKUbiGUnTNsAQj4cEPAkIPaxNWDsZAYhEjjj4jVEVgs1HNXCF2Vt2MMTf5Rp7wTIcavBLnPLSRKmtUAxvTQgYn9ECHOLBhDPSpAAQ+y4IdgMEPfShEKYzRjGVEJAx42OIamuACDzTIClnc4h0EgZE5bAkrNXDjBVQghg9kAP8DwV0JzlxmLxMY1QTvJcFyM4ACFDQCGCRlnlCkuwtb8AIYcthBDUjgZprMy0Ux015YGOm+Md1sf4g0CUpqgElMuuxmo/RpTD1JPvKN7C1rOglTUDIT/qopZYQQ8B6NEYxc0IIWEYYwWRu84F6TFddKG8UoJEiKTwDzl8XmRCfUtjY9xCEOa+PrCIGAuGqPEMU3+AW1Biudw76wVn1bbIz9RkNl1HA64gzcrrwxj3ksBxvWoBaQeWGq9sCzAhqAgAPw7QEayOEPgIjELpqhOqk4ZA544MIaJjCBHfgBD2Agcx7CEIg5iAEPYlCJGzFwATFwAdSMfl9+s4dUULugBaP/3CQNfjAIAdYapSmVLk+MsQgapAkDEtjvU2dC6evhFwY8WJ+LXgB0rsAgX0YgiRCUwmlxcWF7lTzJeLlC9UjTDi4piSpTq6QySYBij8jYkS/+eOuya8oWZU972WEhYbb3SWqV6sQoYilsYaN1FYBwz9rwCmK9so0+HHBDMgLrDWkYXm6+ulvesMn4xmOTb9l5huFxHFnJOsc5hq8GNXwVDEYAYQxOmAIOOqDkAwxgAyBYQpQT4QhOXAVJUHlIGPJAAwag4HM6sAMe8oDbHijlBR+A80oowAM8lOBmL3BRvcYXFpNoEs8u4MoHUlCDH9DhFgJMqfZ5sQuUDsMTP6BB/wkuQAHmw4VEXWmK0bsCA5GTxGXjG4l4u2RxF8SAC1zogfvoG7NNcgWozUc7rSYv6ccDYpAJoKBHw2AMwzB2tvCAD1gLtKApard2DHY0uZQKFsYJxuZWpFBho4BWWjVCN2AfwkJiKOh3gMcIzzAt22B40mBYzpA33CFDiadYzRAgvsJ4tPFEA7IMOTh52CBOQ4h5MCgN1GANPmZ4yJAKcfAEU0AGQIAsENAA+LYsafAHhfAIXBAGYvAlF3EREzcBFvAgTLAha5B0LyAEKYABFlVRH4AHNVACx7cSBDgmKjBK86Jn4vUBGWIFaqAJ2Vc8CMN9u4Ajt1AFNNAC5GcWaf+RIVwxdfZDJvCXfOwVJTDgAgaRPVHiAhDzAlfCBWfSJjBzJvWyPTTlfKNkijRTaWLgddjncj3ygGknYbZ4iw8GKIDydnO3gaTgNJoxd2r1CXqQAzcgA/ZRbcqIOCbmHoAXCi2IDYO1g9+mWLQyG7SSgzL2E9w0IMegOd3kQpBFHUdoeD5WDdEwg80QDJHABk9QBoyjARXAAslSRFIgB4KwJEvyEEZQAg/QAkNQOmAgIRnxARcAZxjghm5EAUIwByWQRmqiZ3X0fvoldRUTalZwBn9GMAVTMIZoUsZQBzPQAh5QfuSjMUYCdSXiPp6UfPWiAjwQJduzf5o4BO03UzP/9QI9wGnRpwIzkYdCNSZhAV9BORdytkn89QJzAAmZ0AqABmgJg3Zlh4sYqBi66Ce7mEu/lDWmsApR01auAAudUIwlyAHLeJbGSEI3IE8cUAvNQA2p4kIzxDfeeBvF8I23YQy4YQx8iRu5oRvEUAx6iZd4mQyAYx2NFw2Ck46Sl4O0kHdkMAVjYAMhEEQaAFo0AAdnESNeQRJtUQMPMAEMISFhZAQkQAEKSQGqSQEjgAEqIAg+5Yl2USKNBBebeZFkRAVqUAd61JEeyX3GwAvIEAkygAIlUH5lUSVhcWpIVSXvs0l0YRF5IAbbwwND0AM6YD6dRkaNVBGQlIcd1VF4/0Z1mQReL8loLIGUGdI/kuAJ/wNos4ALtOhVZXVWaMUKYdlrtICft1RhUGOVqRCWlhAHw0IfMmADNoCWfUWC8nQDwpAM0hBYNdg3T+SDePmXgVkMArShwyAMwhAMH+qhgumXuFGYOZg3tDGDOPQc0FBDMwhkxhAJblAGU1AGZSADOMoBGrAsY0J1eQgjWFECC9Bv8tcDy4WaGLCaqvlmJnARFXFea4IXVFdUplYxPYAzNbADVzAGntCAvtmRPGIMrWADIHCcyUl1kZgSJ1ESVCJyMpky91URNukCMJCdmGQCLYBJR3Ix76N84SlTGXJy0Rc+7CWexgVUXCAIgoAIk/+gCa3AC7gwC7bwVWcFVpZqqV5FCw8on5a6Cp+gVknTJ6lgVjLqBCFgoAi6oH2ljCO0ZG5gDMkQjXtDHsqgDMlQqwPijbnhoQVjUtvnkTCnfR1pUr7wC78gDBmaDFHUg9phHc3qDN6xDdTyDKxgZG3wBm0ABTh6b0hlXov0FQ/FAA/gaSXxAar5ABQgAauprhhQAjSQBwyhXKNYL+bzSaZmEBKyEi1QA1QABH/2pWAqQMBgBiDgARdQFtoZiUM5E0zVoxxTPmEUdORjp3X6XkA1U5CWScqXM3ahp5zWAiiHsB0lZ35KAj1wEX5ACIugCbewE7jwsrbwspwqqTJbsy//u301C0ifUEuwwApHowqsQECJ4AammiwhgKMIagNq6VckGAJLxgjIMBvTQh7LkKtWa7W3IQyFuAsIhmuwcGubCrObKl0PqAu6cIgZqjnhIUPR4B91Ew3Z4A3Sig2dZ2RVoAZqMAPHEgI5M2oWWQNDcAEKcAF1YQLq+gESoK7qSgEZwLg4UwJ4MAT0qiZ0xEjiZZ3XWQNu6IeyxZscyZEFw5e+YAx/IAPj51Pz935RslG2qRYPRXRaUQMmcXQ6QBIaC1Qnd7GK5Gl5eDNVFTFkZLGX6JLBlwHhuRIvMAREMAeCkLKLsAiP8AiRkETRO72N0AjVGwnaO73Su72RoCja/2sJnZAKs+C1uNZgtJAKplIGNmCg23qgJBi/x/g4nGAM+zQtV5u/x4AMWVsMvmprX1tWCiapXwWBMot2PvKAOFKiysod0SB5SEgNzTEPcqsq2NAMqaAHbMAGbwAGPsACHZBUKpISTJF0PeAC4ppmwRd8SqqaB2lRGNADeHAzPJmH3WM+D6UD+LKTgtoDP6CbqFBSxiPEwcCXtjAMjtABFoABkiheP2VfRqrDOpCJWqGJBkHFQLd/MEOv3oMy29kCKJAC+5q8mkgDngZ9eEYCJeABHkCHa3x8EDFmzeshdmAHfsAHfHDHePwHfbAHe/AHfPwHftwHhLwHfTAGbhAH6v9UCKZgC1wLgfSJC3inB/D4vkmboNZ2A0p7bTdQC7gRq8/gg1dbGwOilxrKgB6JC7QgnzWbUgUDaL1aUochywWzgGH3lv5BeZQnWUroY/KGDchwCc+GBmiwBCxQA991LyOxFEniAhKwACzBcQnZwi4MZ2ysAnI4ns+ZAtHHFXmKSZZ7crOjA0PwA5AAurJcxF5KChxAfqMUFiDLnbbbFWdhEPasAyigAnSqAvnMMT4ZpfziEt81E8nVZyCLcvuKSTTAEC1wfDjTAjiDM20UfHBWAq9zB37gB3ew0XVMxx7y0XYgB3JQB0RmB3Ug0nLwBirtA2PABnSgB4WwCtyXCxT/OFZipVVxMAZkQJlBxAIHmpbLuMkcAAS+cJezQcr5m6s7ghsLOAz/K58xy8opxZHpXNXGM6z2G7XPoHmTl26CMw2T5x/V0AyvoAdA8AQ+gANT2haAERU84AIfIK6nSc1KegFvlJAYABW4myY4E33b2Wlrikn7ugMFtQegO8RFbAzCsAu4YAMWcAH1FUllYaUGNwRTXKcGUQIoALJ9ttkugCIvk1zKp3xyVgKbBF9zJjFGECUjK8bhiXLoGWc0AFAPt0W4pWWw8094i7dpsNu7nQZpUAY+AIVsEAeD4AoIswtmi3ZmZQubkMhj8ASOY8lJG9TXBgjDQAz7W5eESZib/6OXxEAM4O3UY5cwZUezEJgLvuChHNqhJ2W2ZrvARs0MNBgrdXMdmbd5vwAIJFhHPWUVqIMVMYm4DJC4iUvXL0zRGJACYRBpGYum5jKlNcDN+/oDGxEFgdSRH5rYwmBddGABGVCAPaUk6gUx2DnFVmzQgg2yL0kXIzBJnDhUYnwmzymeZAR8m5RJft0C0/cvweUBbtQDqkMhYKAGuI23D6E6YLDkVdDkVHAFV/DkSy56ad3SiTALwNB9y+21s/AIY/AGjNPTLODTPv3TmpwDm1yC9SsMWZ0Md9ndhLnUJBqYHWqIEqipMAewwtChHqq1J+ULvaALvfALGfrJMtQduP+CK9AgTpu3Hm5wA/DCnZwJGE0B1xzHAAV+4NSckGqWkBeQdKItzz2QILVbFvdFPqMOBlbgA5RwPAWz4Xw5DNY1CWVKMl8iBhnxFBHiFDt5z3SqA99cxXdKp2LiMrDLFiIHaTCjaSbBaMaLJn6dAm487W4sLlJBEAtlIATRBAYyEASx5FZABVZQOk3ABE1ABeiOAjRAA1UABY2A5cn9yF4lC4XwBGQARDhgLCA85tt6yTgaAiFwA7ZwyrdconC+v3aZ3X1JDE3dkVquCwCLMMPqqydFiIGuC79wlyVK3/XNHdehmOlmWfudkxmCdOqXAReQ8hKgAJpOzQfJcRKQ8hT/QAJCYKhwahUJcp35gnQVYwTZTgV/ALofuoAMmDCtMAMlcBZIIhJKwiS8nsP3nIlXvJ3vs4ZK8T7tF0ntVy+RRmdA1+z1Ui8uQO2ardnGSYcogEk72QMIsu4/4EUJYu4J0gM7QAQ/sAN4vwP2nPc74AGbne+PoEcp9cjMLQt64ANOgANjPuYd0PghUObvi4wA7waHYcthR6IkagzH0JcbyvkLqKFfOtOEZjzt3YAzfYgfWjCoL5j2OxuNeaJhLa3ZAGT+oQu5o14TM+EsrJoSgOktj6QUQH7kF/MSwHFvzc32dc87LxU7v/YSohRUwAatoOElFXZOnQq3MAYgMJM7/zwxpGkWV0zOmaiJmRjPvEs+ligEL+l8OX4+o81eH2Dago0CdMFowlcCqrTCx4dJdOgCZ18CANECRQmCLggeRAFCYYsSHkqggIhiwoQNLGRMusULly1bs2C5WuVKkw8WLEJomFBBYckOHSzKgCkjRAgOHBgNw2kM2U5jxor9BNqzJ06cyIQeDZaUaDBfvnjxAgaMqa+kTHk19YWLajBes2bh0lqVKM6pvcweIybMVy1WpwqZSPGiRg0jQni8EPKBAgYMFChIeIDggQS/ezFk6Ov3AoXFHy686DF3bo8hPXTo6JFZSGS5doXU6GGECRUclpxuDWZ0WLBVvAa1cCG3Rv+MF3IzZ577ggYNHbB1QNThQrjAFsVVwKD9IkYMFc2Pw1BhQoWLFiQIWrfuwQPsEsalk/DwocQHD9Y/HA4/XPjBh+wZHlQYf+AGgvEnPNAQwkYlUp8sXbLEkkgGjEQRGVjQIMGUFGqppJJkMmmmmTjxaRideDJmrLGSwmorrJiiJRdaXoHlFVZOLGWUUDi5pMVLBnzRkUgcYaTGGgvBERAddSwEEBt/ZGRAVWIRZUUdKUkhrh42q6G2FD6AErG9LlDgAcMoyCBLvi44DAMoPyAhhRqEMKLMIS6zzAXQbluyLjZ7+MGGQaQKJkNjglltmK88wcGEF1KIzTY2mWBChxn/drtshkNpaEHR4nZzAbpIYbhMB+cijc6E3QSCqDuIGlWUhh12GIIhFAxllL6DYNutVU4V7Y6h9z5tQYYZQIgoIhZsgKCC/HLAZMBEhmUkEUUSKWQPDVqqoNlmN9DA15aidbYmDkIAkpEdt+XWxxq9zdZGGV1skZNQzj23lFJUGbIWs3r5Jd5fhCGGmGKOOSYZZpp5pl9qqKkmYIG32QYbbISJpBRWTGhSiM+EiCGF6D5AzMsMPpCAAb720pKvw6AkgQQTTFAzNDMrC06yJmvgwWEm19wBBzNkecpDXHjZZRZZWlGjBcmSzKzMyObibTdHD22hVUQZbU44Fy6DQbjp/1xQgaDiipsBBe3qA2EDr3FFYQMLNlAIIg3IVmi7pHNtyKENPNhgAsAmemCBAQZowAEHFuCb7wMOCODuASroMREd//ijj0EG+UOGAxZoIHK+83agVwh6rQDzaznIoVtGHBn3klDWjcWseYXBqRihdkImmWaScb0Zfvudvd9npJGmX9yl+ZcaaaoB+N+AhRe4GmuORx55grM5xpFSXrkkLruWbFJkEs7ja4QUSMCAAQky8Mtjvi4GWbqpXzBiiDMp5aEGuNRUmeUmS66BBhke6YQTUU45ZZNNOsHEJTAhC0PM4AUu6IELkuQCI3BBaD0YVasOpYMdiIoGodLBBZsDg/+oXUZq7NGO10QotomU0AEN+NsBUPg3wQXAhS4cwAthKMMAAMCGN8RhDnWowwYsLhGIA+If/PAHGjggJc2aSIJc4iAZtCQEMrnBDRhhlAvtJBmtg13sZCc729mOi10E4+12Fw0yjjEauxvjNKYBvN4BrHgBS941jleNbGzjGaG4xCo24YgauEAIcjGCCUJ2vShdjC8kyNj4xEc+kIksSYKMDdTkckCnxSZ+tZEMdfbQCBlRghKNeMSAgiSLSvigNy14QXFA87Ia6GAIobqaqUqwgQtcgJYWWIzHPOAxCSigAAKg4Q6FOUwbBu5uBnjcAxygTAvQrYQSaGYzE7QsDYz/TWwWoBYEGgCBEFjiE8NaXCEWB8QdaKBr2JzmEhvUgWWFwCQ3CEEqdoKvY8yznljMor6Ysc8tOsOfz/hnGMVIxmhAw6DRmAZBpyENNTZ0jW+EKByNN0c6UiMWl5jFJxpRiOkQEkoeq+ViCsOYXhLGMOP70pcGSZCt7ZJLGLClQ9jTkIuNB0qMwQHiEmEIRSAOEIXQAyAooYgf4IAKP2DCDnrgM8lERgc/2EEGdxPVUF1wINoBjwekQ7WOXkACX/2qBcRqAQqMtZZjE+uyugaCDqyVBQwCgUC6Y9Ws0QAEjkoaoyByAe3kqgMb6JSoUDADX3HABqQghSMegSwcLW5x/044mxLTOZMGncSJOcBsaqyYr9flK5/7zKIy9rlPZShjGcxYhj9Vu1qDrtYZBoUtQQkKDYU2NKK3pQY2fnEJWJjiEYoohAKEi4ACFLcAwh2uAQyAAAY8gAEM2Av2LoaY6aY0ZAT5pQAEcNzmQrMEsXGBdWgqHvJg7AEgYFwhDmEIO9ThDzzyhCwgcdQfFMcIL7DaXFwAHFPlVWsHgZsHBsKX68wUTJnyFEtlSpBczUAg8Ylr1qymA0AZJFd2BcEOJDxTBn8KItRxARjCkLVpkeEWnXCEJcQ5iEK8F3E+SNAG2LksFnTAnSaxSGFZkIMbxOFC+kpGPfOpz2aMFrVG3v+na5UMUCb3y58HlW2Ua3tbbOS2eFUmxiVSMQtLPOIQfwgfYMBq0jETBqZYulKXXsrILxEEpi8NTwa2NlPtZCmlgNHAHv4wCEMIwg98+MMedLSJYciCDz+oLwoMQkm5EIcGCYHwCEU42KvOGQMCHghLMTAe8l3MBNoRMEFEeAFrynRsm1Z0cCDCqEbhysHvaYiXtvaphpTgugMJG4L0cAtSRIISiYgEJjoxLHHaoK3TWlZLbByCBtHYBjyOxBb3VWR+bVGgttsdtnHXRm77rtu+4x23w0284rmR22zERjNC8QpcBMsTdGADCV7wl6/qhTEjZUwt93Ilxpz5pYWsadv/NM3Ig5jnMBULD8agaQbG+UEQdrDDnhdHCWDcYhJmsKsLwHRA2aSgBCYYCGwyzRAQeAAEJTj5dQbyAemIB+S79Nh5+K3vWt5yrBOwADTH+tUSXBo4WxPIBlwgU1DDNNYBnqUH9uIBLomarYoAxh4tkYhNyAIYv/6pDRRC42lJSEJNtLEMMMsKbIsRjOP2dtq/vXa2c9tgbz938L4NRtkJIxW+MEWwMeEDNsD0q831XljLPJgy0xuapDYrnLVznpCK9aVb+miXLhY+LFlADYowRCMgQQhDGGIQxnIEMIyBCjaAIAV9kQBdrkOx6pLsBSo4D4O7E96Pq6A2L0DOcUYW/7LoOPJ6IdueeEjQAxOUAGkNET5CspZqRjl49hioAfAt5YJHd207DSE1LfnKJQG3oAOVAIaApm4KV+wRWYBwwmBn8BIZ2KBWNoA//GFyBB/4YAzDaPu3q5z/NoZxi6wTCrKwil2wBVqABVZIhVIQhSJhkRYZENBhBBzpER+xhE3oH0zYhEFwAkC4D7B6LsEDK7/4KnxTDC4JqQtgs4MgjzerpZhLqTfzEtaztwtggkZQBEiABD+wg/UqhERwBFhABl4wBBrogQz4qh4Ig8hogQ/QnhQYgTBJkukQj+4AIfGwPdx7gd0rPltTgfCAuUtjvE1rgV1COe0QnxLgq7JBgf9WQwELWMMvMYEYIIER+ADhwC+muwAS4CsKgBs3vICDoAENkIFbGIZg2QRgSwQWQ5Y/gIKkWb8DcRD2swEc0Dr4wwE90CwqEkAO8QUCrAVaiIVXUIUELJIVcREBeUAaGRbGmkBu0YNXdMVXlMVXpAM6iIM4qMVadINdjAM9UJxHwARS8AT/iYRBiAMwuIDBoIDnshISzJJntDOKSalohIskuZokgRJQS7gmdBI6bEI6zBLGmAFF0LxJsAM5uAJFOJZEEIWe0AQbQAG9kICkaZSBiA0oURONAzWxkjRQixUAY6mGeA/tCCmPOYi38QCdI7XDsyZcgpK3acMlBJMRMAH/IxSCQAgEiKEYDPgejuQrEXIID0iiizgFVAQdHCE2PTgJBlE2J4oJGcAB/cABJVCCLwCEWdSDPdgDWbzJnsRJnNTJnNxJodSDXDRKW7zFW4SDN2gDNmADNCCDKZiCqHwCH8ABGoC/3bABSGSJGVM2/UCDRWgFT/gDOaCDTKACXBozaKwYtkypL6EuMAmTFqiw4giT8QAB8jKBJ0yB93kSltueJwQfCQAsQ8DBR6ACPjiDRTgERUixYUCGW3iDsJGAC2iBGlsIgzC5FviBC0IaSCubkkM5D1tDSJu0q0I5aEE8ERoblMA5dBIrX3E8lmrDCeCSERiBLEmAFcgEUJAE/0TAyEDAghHYi6pBAaMZFSa4gh14Az2ghFGIBAecEUcArkSUg+vEzjR4g6RkSjRAgzaAAjMAgze4zu2Mgzd4gzRIgzJgT/b8gveUAifwAfmsP/lrvwPhyhurMWXbT2Wbpv8cIWT7T2ch0MzJHMyRFpdog0F4AzTYA2CYBCrYgHv7HpGiuWeURvHhCw+Qs48rjuGIJZI7CEH6uI8zAZYzAdi4xgwgmxbwg0mA0TTwATtYhN9KMVxAhmEwhLdqpsssiYVYw6uJMEXBz/ajRBZAASR9q/jozyWKifh70kmcRBzAAaj6ASd4gix1ginQAi2ggiYAAzUIUzVYgzmYgxXIkv8IwANJyARJCITf7M1MCIQ8mFNEgISHswM4sAMwWIPxLARUcIXoBBACOZZGoAMBzabLUdTLiRwHqIAHWNTLuY+JKNBKtVRnKaFM1dQH4FRO1ZtP/dS+kZy+SaFSNdUDGABTjZwG4AD7G4RmgFAWQMOcezOEREgMQMgQ8sdOQbmHCNGIgLCTcwi2oRWsaQFcjSs4gIRJqAQvQ4QafQTQYQVYoAQ6oNKE+IH5BIL6Q7QfoIIqMAMzUAM1MIMzGNc2IM86YEo4kAOIswM+8AM54IN35QN43YMhAjR85YM62Nc6qIM98Fd/hYOlfAM2aAMy6IIuXYIkKIIjOJQXOIETyID/IFiBIAgCEcBYjM0AEfCCNg0ERHDTQJgDPMCDIQCrBXCADhgEX/uPQQUd0AGCvGkAyFmAxzFVUi1VyFmhv0EmUxWcnwXan6WhoSVaog1aoC3VVY2cRa2WZtGPMfiDSJCFYcCFSLABFmimCYAbwALNsgnRRlGaUBmVHUAqQqGCs70CMAhTOFBbEQuDtw2DNZDbOXDXOyjTejWESpgESLjBQ1iERjiERLCEWag4VKiEzfOD9VocQfCzP6uD9mLXOoCDNoADNahctaUCQmECIhiVqzSaGbjaSDSJ+FinGfOVaWoWRd3UEuLUCBCBIAiEIHDdBEiACKDdCMDdQACFFcgD/y/Ag96VBDoVAyHIAx2oTDB4UUvAhACZTtAJgaElpuiVXumloaNNVVVVWr1RVEudJmvxXmv5upq4gRwAAjcoBExQBVH4BEpYBD+7A0JgXM7rPHWkX0SwX0TwW8YkhP2FX8b1A4f738b93wDeX/8d4Du4A4hLYHa1AisY1zqAhEqoBBv0skewYEVwBVd4hDowg6zZgBmACXdSCBnzz/+0AF+pgNfU1EytnMsxUBeGgImAAGWaAFClnBOSWb5BLgRAAGQygAIQjI21WBGo3dutXdz1AlDwAi/IgxUIBC+QhCV+4jedAwbYDhogBE3QBEzQhE1Y3kgohAaY3qGNoRaSIf/rRdpTVWPsVVrKceFm8d6ZeEn4ywEnGIMxIANe7EVY/KkeLIQacQQX+QRRyJ+hitc1UIMriAIoQDSrpMStPBBlI9DLqZxOhdRI3d5H1Ruaxdm/0VkD4Jte2QNFaExjOZZ1ZNAm0oBlwmGl9Rs1tt6ilaHppeVhCgABcN2LjQDZtd0EuFiMTeJMCAJJGGbfjGI37VhE8IsSIIIH8IAkuINWuIVbiIpKsIEKYKEBqFk3Tgkj6pW7+ZudTSEUauNteuPvvZYniqIoIl8gAII71uNXRBzHksBVtGf6bQRQitZoTcVUlBEZiYSWFSBOwARM4ISpA4Sy3AHQbAkIOzZlg5b/FK4AB0DVAwDViwbVRd2bvunkv3EADZiBulmAy5EDSDiE31pH0ImEJ6iAyEHVMo6hYKrlmabpHHKh7DIAcB4ABnBdEejl18Xdno6AJAYFjCzqab4FUACFTIhTEhAABtCBB6iSBxAEUECEIuiCTACDasrUuJIBGqA/KVCCMkgDXKzjMnADtKYDPYiDoQyqbtmRHpFAlGQsViS2VcSRYiEWvU6EcAHkl4XAv6YRwX5ZGCEXcokDNtBONSAChpA0SRurrH0AuvFkS+5UvRnVFBLaWa7emA4AFcIBRQglSiAQ5s2BbL6bzk5tGApaY0JjwXnp10bj2AbaVVUhFWoACvBp/5+m3SPGWNcd6uBkU6UmbklYajlFAQOQmyphACFoUxUgAANQge6RgA8YAkTIhErIBE9g6u32hIImaEcg7cIG7M+JhM/JlsD+kR605/a2Zxv5Y7+Wb3GhkdA5bHRZlyHRhf2Gl3i5lgM5pxW2bEt2JpzT1KzN1MuB1MrB7Oy96JQ44YnWAIvAgTIoBEqgZg3BhUYAAhsIARSuVEXV3khVWkzO5GipCXW2gfEl3zHQ47Xmkb5WaUpQ3k34hE9ghVyIhVhIhVVYhVYIBNzl7du1XYyVXSLP2J6+WC94UzFoAgmI6owhAY+lgAfAGAZAAAXgYUFgalDgbjbN7koIlhchEP/QcUCAfsAZUfPyVmnDJhDDvm90YRd22fFY0IV3kZd5qRd7oadjKC3TejIyaijk0Ybj0YZCr6NtiMRcQQGYCJVQoVIq9YEfgAIquII0EE8ySIMrqIIqoIIoiAJPr4IncAL6dGQqlVJLjL9VxwGL2Er70wMfVN6CdkBjdMpbZwNcpAM9U0THZFnw7oRPIIVTCAmvAAuwuIqooBMN0ZAAtJCj8AnVEYqfYIYgKwacAIZASAAC+O0jxl3f7m0it92grl2MXVNJwIPuoQDjzgQYYC4CoAAs+AAGOAFEIG5QuIVWkFNCYFNNUN5PEB11GZKBr4Va2HF36e9f2PN66fM/hy3/2kKoaUCebKgjb/AGiq94b5iHebB4i9/4jV+HeBB5eSB5eYgHeaCHlLeHlSf5d3D5d3AHd+AHfMiHmq+HlGeDMXgCKIiCbJ3P+ssBKr0gS4z0+pPPo99SJ4CCpYeCKRiDMmADs1xriRuEQ7B6cnwEHFxWCeZ6CaYETfCETkAsUuCE/OkEs/+EWbgFWfiKY68ZZR+Lo2Cduaf7uqf7K7L7us+i14GdLVqGZZAGaGAGowAGPNAubudlCqBdAiCAbU8ABCDycsfdIe7p3zyBosYD3S1qElAAv3gAAsByATBuT8D3aZYEn44ALMiEYWiG3PqXRF8egpH9bfj42reHebj9/5Vf+Xvg/d73fd73h3vwh+EffuE3/uBH/uMn/uVnfub/h3/gB+jnh+nnB314/utfa53UM8Rhb0YIJRiV4IL+n2BHBcRCBVRohVZA//RPf1eQhfd/f52ZZp2h/2lm+7WHf/hX/1bYGfd3hVMACFKpUp0quGoWLlu2Ei7k5dAXsGASh1EcZswYsowakSXr6PFjs5AiRT4rabKks5LSVrKURu0lNWzYsmGLicxLgpwRRIhIgEAA0KACAgANQODozqQ7eQYCJSlQpkBNQQWiICaPCgEP5HhAMARUJlC3xt7y0lNnEEnIZm5r681btnnz7NGVO3cuXXv39Oq959cf4MCCAf/z8/fv8GHDiv8tXsyPH+LIkhkHZiy5sOBWqDavWtUK1qzQokeHVrgQV0JctFbbIu2a1ixasGbPhi2btqvcuk3BSsXq92xVql6pKvXqN61YtXTVqqVcV69dvn79EiaMWLHsx459TMaMmbPwKV2+rCbzfLa26tezb+9+G01gQnLmFBEhwdGgBIoODRAAgH8ELJWAAAnsJAkoTgXiRSAIVpWHUxc8gIgkCIIiS4K3AAOKfTotGIEOkQTD1jbEKDPPPYH5lVdffrn4V4qDDfbYY/9AdqONOeJ4I4097qijPzHKCNiLnxjZiShJihKKkk0iKUonoTA5ipRVWiklJ1lyEsr/lld6yWQpopQypnBlqhILms8Rs+aav6zZkTLKLLMMNNFUU4012ejpll12ecPeW39uEyihb72nnp40yfSSSckgYwwxwvjiyyyyIHLffgTkhAABBXjaaQH7CaUfAQgwcF8EqeZBliReeFHhgiIQ8MAHEjxwqwd5hJVggnjgp2kCQQiL3wNOoEJNM24ksw0979SDDj30yCNPPNXGs8461mLLTjzytJMOuO2088477oB7rjrkqHPOOeSwuy645shrDrjjjCPvu+qoE4678OibTjvssCMPO+iwQ89e9kRLj15fhjImmWYKl+ZyulgMXS8ZU7fxdWxit91HynznDDQtlXen/0x50qSnn+ml916hgg5K6HovJwqTNM4sk8wxxbTZSyzCSXlJJIwYDQggerixtBtAAOHGGDnkcAPVMqBwX077JcCAAgh4bYCnYRcwqgD5lapAAjwFO9ZTCzYYQQD4EUWBEBg8cAEMFEx1CyhBJGCUga96gXUEIwjyBiDUzMNOO/R0a6222EJe7TrslBuuuJefm06767L7+TnpzDtvOvbeSw7q7oYTzjn6nuPOOwJPOzDDdC1M13bbxRlneND4Hg3w09yJpzXFa3P88dxwE/Nb2Dov+bTdyiNttNPT9aL1CksrD2D2zNOWTG0pWhM1z4SUkTHDBOPLLswFXdwlWV4yf/8kjjBSCNL5K730GEBMTTUAA0g1GxBQBgb0gQxscIMQGBADWPtVThQgQa8hAGwGAFvYRhWqoxzFQBmAEFVilZYgIIAEeSsAAriACAlQABEweACCbhGInhTIQEF4FU9SFYEHcIAY27BHOQYWD2lB7nnZitw6NIcOdIhrc+cyB+jahbrRjW51VrRi6lqnL9gRbFrTWtjtFKa8MS7PG0Y8YjnKscQ0LrFe41ijGpeIDja2wx12TEca06E5d3hOHfD4IyD1lY986EMf+egHPvDBD3fYYxu6CAXRiOYI+xntfvm75CAGgTT8AaIQntTkH/7Ahz/sIZSm3IMeUEmHOECtf07/A8ITcoCDWdpglrbEwQ528AMnzJIGFEAAfejDNQZwbYIVrKDYxuYpoIAqUzbMRCbwsKAbBmE/ACAABoaAgQJIAFZCQATf+hYBAYggCBFgUIPMmaoEPMAS24jHO9BBLW/Mw3FIlBwS33EucTXRifJaXepSR8V5BbSg7vqcOrg4sOmBMVp5occgB1mPidYjovmg6Du8KA9yTTRzzqqHuNIo0iW2I42kgwc+TDe60tlLXuDSl+fsqC9+1GMex1ia1PTAyqXFoaf5Q6UegroHPuyhD31AJdL0QMo++MEPRN0DVEPZVKLqYZVvYGUc2MAGNJCBDGUgQxrCKtawrsEOa1jD/xxOEEyd7HABxCSmBLtmTAQkc2wCyGDZEPCAE7gKD17IAyIyQAAGIOA/RBEABcRCFr7NED8RoGaDWqWUMFDDG5aLlhm3Ry3K4dOIjOMnaAf6T36lrqXmMN29TptaesXLieDKqOyqB8aH6khH+cCHjfzBD4vSo6L5AEw/givc4EoUoxT9ox1Rig94uAO5m0suIAv5x3csVx/4oEc2QoHTGzBtaVrV6hvCy4YxjGEKZ1ADHOpgBztAtadxgAIT0DoH9tqBDnVQ73rlAIc2oGG8Y/hqGcrwhSc8wQllQEMaygAGBKfBDmAIgxhoSB+k2OpWb41rXClI17qGzT9l0xQFTv+Ah7b98gRYIAEF9oMACC2Wb/YRkA29kIlbSMI+qRIBMLYxj37Ug4gMk8c8osdZzjqvYKDlJxVTe1AporbJ4wCHaZ+YDnOxNh0DE9jBqBdGhQ1pMCmKUWF6hJguy8hHNJoMmhFDo8BA5h3zeAYg2lDgHJC3znVWgxqu8IMZgKADHQBBC2agSyuAgQw2qIADFuA1A/FgCE0IQxjAAAYqXKEKUYiCE4DgAxwQsIAJtIEBDVjLWR6BCDGAG1GMMpQEUEACDLiVheGKYQ0nE4MF8A9RQoWACAghEHmggH8AAKAEjOAqiMgQWcyikwRIpUE0XmcEdlBZhW0WYXUpIj4jVzD/OS6RdKI7rUu/bS9wQNnJ48Aia91RZXqZa6ECWxhDG6pbMgep3mYWc5jnne8w3zvNaV7zXw5zD2/4Ig5vaIIPbODfVzqBlyiwwAIKMICJH6ABDoCABUCAAhQsYABB+Q8A9MMACpCABjigwQxawAIQbEADINBABSAAgQpooAMsYEEIQMCCGciABbiUwMeNcpRW26rCD7iwAorZNQpy+Na4LhsKHwADPEigACTIQGH9wwAJEEGxCcqEOQvUkxu+SoZsTYSO7+FFiNajHPPAdrY3G49ty7EcLX3ialX7ZHKL1hwAJQe47MhadjM3y1+kyxfX3iyUJne5dmxuPeBRj+b6/wum+gokIDPPXHi8A/OZ54c+NF95y+urkP6gh2EMaY9sXKIQf6gvG+rAh6DqtA5woEEFBhCAATTgAAeQeQWC/+cdaPPG5jRQ1oDCgBKAgQY3Z4EGJnArBSzAAAp4AAqaIOkHqyHSYLDDHLBgYx16UALmh/XRlZ5hZDa96QZ4AAbWwAUMzAEsXjjxA/S6KmBAMxBBOMtjeUEQNIj/bcoEBMMP3YO1bFQ9AJncOc+1nJHAoJY42Eu8gNs4iBuUyYtpmUNAAdQ5kM7jjaA7SMtCTc89zNbCBNKU3VHgZR4fxSAJzmAMJhRzPV7gPR7oIRcguVY6qIPp2QMiFYZNMQIg9P+BHLxBGvxBHQAVHcABGfxAA/CeBnCAG5ACRiADLljCGNgAGHDBCWTATghLOf0fgUDdAvheGkrch3mKAlDAA5SADsCACqCAB2AABViAHtrKpngNN30A0Rld+kmQ0h1T+zXdAqDAGoABBkiAEVBIJlBIINCABcAAhkgCHgDgYy2IqwjLfUhAHBQDPand9EwUPbyd3EVgBEogS0WZ6DQZB3bgaqHOFbnLuZjLLUKeZnmR9tTOwsBUCLrW43WUHsEOuRzjO/ATueAg5hzZuDjLIOEDddVDMjpjOhQSwoDUP9CDN4QC0vQBK70BH9iBU93XHtABAfmZDERCTJyHTHyCDGj/QRicgAiI4RgOoLLhhwBQXANE3ABsEAG8ITEtgARdUK2FiqdM3AAYgAeUAAZYgARIH/q9lax1jQXZWthwUH7cVQEswAR4AApIgFs9AA9gwIzdwR1gwKpIgt/UUAQEQqpME4MgAiREgihgw1yU4kU5jjekouSc0bawA2olmThUoOkU5b284rldEb8A1OaE25Q5y/ZUT7w9VLT8YGvdoj4pIzKSi7hsFON81reEznOVS7mwQzps1Dv8ljTiAzU6I+M8xvR4kTcsgxECwh4Y3BvYgeyVEh/QgRzgQAVMQAdwAB0AwywAwg0MwzO4ghuEgAcIgQDaWDl1Yk+IisQZQPUx/9NRIICrFYABLCSHGWRCKuQCzEAJeMAFQKQgTqSsURBpcthGKtMCeCQK6ID0ScAagAIigIEKgJNZiEqBnJMACqAkZIImeAImWAIy6Jg8UCMRVQu1HBEEAuUEqtTojENRVuB2biC4+R1TkgNAxaJrkYvibQ+L9OK5WCBLWVk6cJvmaCXszCcfgQ7n5KAd6VPnpQM87KBzOdG3FIY8eEO1wEUs6EEf6NRVoQEdNCgd6FQbwIEFbN0w2dwBDAAdjAEEOMCruYoApkoGlCGmiEpcEZPXdM0DjIAElIqnxGbYaFgFGYDvOYAOkICNYkAjRqREuqb6WWT7aaQyaeYEsIAczP/ABmQfr2zICtzHUBSIgFTIAN5CK3TCJmyCJYwCTtaT3PXWdEbOKj7PEg3lvNjLdmpnUYJDUQIUU66pmNILaNGOQylMetrOOJDDuRmlmaLDG8lRO6yUC25OvoDO5d3gCPqRdAGSfZ5LItlDoGzDMzBCHCDhG7BBHDDog1aVEhKBApSKACSdZnZkGioaAogAJ5oFtGGN15wNjKZqBGDdIb7o11yQZlrAELiAC6hAaq6m+e0o+qWf+rnop3DQYQnABR2AA2jABoBBJQgCMGQEKAxO8sVNTgRBJngBHgADKozCJ3TCcv6CjsmFtSSS4xyRKgJlmGInBRrldiJlOHyDeK7/6RWp1ncCzDFWpe3MKV3U6bm1lOnYXRzN0Uihw5TlnbyoSxSxy58+nr/0Z+gBIbu4ViHZw7XARS+4QRzQwaSyQXitEh2EkiEgAhM8QNe82quJLGGNTQRI01N0YqrA1QYxE6d8GAftGoxi5GzW2vWVQBMQAcqVQAlswGpawAQMLdHy6tHVJkHGaEZuJK75xz9O3ATYQbNqhCQsabS6JDoBwy2swrZywiU4wjPMjFzIwz7sw7h6qbnKEVKOwzdYUVGm0bpWYLvCa9taUSzeCxMhoy/2RS/WDl2kzupk55PZC8AGrLyUWwe6w+csWVbiorm4w2P4iz48rBPhQ36yA004/8IYvEEbZCwZvMEe1IEoxcEkbAge1AocwpoOvUqCNFuz9YQBEFOwfhjZCMB90BWn0FXtcqTYWJ8EvEAYWMEO0EALuEBqbsAG6GHRDi2scehbJW1smk3T4to/FsADrMEtaEQedEhRhNxw3lAgAIMsnIIpcAIm2E8s6Ak91RM87EMDClG5SqDaIuU31G84vG05xK04zK39WpG7zu29PJm8eBS58K0vNlReNFmZmunamhZJtQMTHRkueltWik4zKtJyWW5yeeU7pMhjlIM3FMPFyoF98cHs2cEUmIF9DYIsDAMyaK1TIEIecAEX5AFUfF3bNFuN7YcB3FWmlI1QjE2p3P8uCjFdi4YNRhoAAkiQBViBnu0ACIBAxrWc0C6vazpAotWmRZLm7gbxBUlAGIACMshQJhKIsA6nCMiYMfDCLIwCJhQN0hyDcwoGMnqRu2EZHI1U/iJl3H7D/rar/dZv3VoR4t4du7kDNZpnF8Wb2tFOAqfWupLpdq7OarERt3Hbt6zUt4UbuwVMO9RDIiHXBmdOimCjNVwCGwAmCd9Xg05BKuuBIgxDMwwD3xxn2/yV6+pwhbRKAoDmhmVKqATFP5YN8p2ohinxMX3NMRHiA7SAIcCBGVABynVAC6AAy2mA8iov86IfFmtxhr3sXe3uBSWdDiCIqf5K2RCFgZAqKKz/MSyIwtcmQtKEAjZ4A7n8g1+YpVfKDsEITB5b8hyRG5qS25mKQ/8CsiBf0TeQWwe2oDEmo0bFmwky1LSM6bqiaXeSGxuJVMBeslIKrp9GcOcl0ghyHin7Q+jJw00BgX5dLCtnKKXqwSAAwzOMcav8Xw7tBDpFVoU4hQjorhBzzVEEc0IKAAJQwH1gmFzFFUFOUFMT0wNMgBqAgh/sVxcQQQsM7wxsHMshL9Aqr47uqPO+5jIt06gclvUxAAbwgDl1iKY06ToHwi3QcitwgiU4QiEAFTFkQzcQyT18SzPKkz/DUeEuUVEutEDzsTiQW1MK8kEDsne61OPVMZat3eFR/5s8oJZAbzZnc7Rn/6sccWCS5d2URXA79KcGj/K46BY/wEN2SY17wYEc3JcekJcbBJUnNMMzGEO18kQ5pQr4NgiyPWsEeM0A4K6t4C5CShwwdQhFMoBbPTdcRfetTMAGKAIwNEIqwQEYMEF3/wAOpNzGbZwHIO8earPRHt0EgSYGCYWHFUDSXZ8OrdN+qHPaNAUwtMInWEIkyDMquYEjREM28MU9aI64LBEe/zNHnylBY7SZMrZ4OvYghwM4IHZqZeC51HE/a5RD7cXCMLgggwMZhThHK08ambhnx+KYitZ7Hrg7hHIOJqPlGMZuQYNi4kBPwYGOp1cd2HYc7AF2O//rCggAABiIsIFvDLEKBnCNAQQAMksQCkU5Bp2K1UI1N/dqr5qfBciAJgwDKRTCIPzBHKwBHKjBpP2AVs+AeB+vVwct0Z5frGWYrWkQITKAgaxTgQDFtDZIK2hCJfR3Uu3B0uiCnlxPuZjLgRvMYHs2inN2hW/2Ylc4Qks4pQfuSj0jbGHZQsXpVJIbpY+4IF+DqJcDGY1RimNn39ELnzZXIsV4wLzDYfDDPPTCDSRQT0XoG+g4HQDBGFis7LUCRgwDTAJFBBwFgyT5WIACF9iKAtwaBS3dXME3C62AGFZ3VEf18hLtA5jfBVzABkCBLLxwJBzCIfjBHNyBHZT5pDH/wQ+gOQ0QbzX7LJsH7R5GZKxxzdcsU64lE9os298ADvh6wiRAgiJwElRBDSAwwzasgz34w6G7Q6In+EaTuokntkAjNkZXOKVvfP/SS2oBDD9pemVPZadrfP2WeqmLuqijPBmpUUFX4Heu+Huq0bc0Fz9o5as/hj1UAyMYUAhoVRu0QRpEKBw4DaWSYya4sDFoLUyWUx7ssoYkeyB4QKspgO4pQFqXKIZtezllwK4OrR6GvdhD5AR0+weAwAz8AS9gxCpQQiMQgiDEvR/wpbqDgRWwey69u5pXszV7gN+Xt5tvcxbrrod52D6CjZ0nRVAEC4NkAiQsQiJoEl7Wtv+o/wI2/JDDww5oIfi2lUM3GPZFOzrGR/pCczylQ5m73J0diUtlX9nBdBG8LbZjK881sLzK1z7LNzpB4ymqm4M7ACxg96dky/g7PIZN5YAMhMDPs4EaBH2E1gEVRMEYxIEc3IEgZMKjUMSGSMVTIAgMj8UaqECtMMCtQbWVHx36s9AJBMEI5GHYezX8ezU2NyQKtEAUPAIwGEMzBMMmQAIi/D9AKDIkyA+fOWsQqgFzhQoTIj9+7KAxowUKiyhKeNhwwUJHCxMePHCgAIEAAQFQpjQwQEABAggiREBAgEACEUECZUJ0qBAgn3r0AAEyBtCxbfb8tXPXjmk7dE/RsUNXrv9ct6fjxGXNCu5bV6/fwG0Fy/Vr2a/gwIULB9ZcOnfw3r1jN1de3br06NqzR08e2q7cAAcWDPjaNW7XtGnr1m0wN6pow4obNznrOHOXLzd9ly4dPH343LmNK68eP3/bYrkh88TGmzav27yBc3BOHDd61By8NYz3MFCSMmUCBerWLVm3gMnCE0MFBgYGChgwoGDBAgYMQj7ALkFCBh4ZKEwQ/9Fj+Y4gJ3go0QKIJVu8jAX79KjRoUODCNqxA+e1woYRd4gIBItAAKGDAjfQwIIKxGtQpOoUUAA6k1IySQCaXkIApgRiCgI4SBpRpBFHSHyEDkAKYaSXbea5hx50+GL/h553yplLqqfWKQcdrCDbiqvIxPFrLLPKGudHtZA8hzO38Mnnnr3kYUceeqikci8q5fGxscEKM4ybxBRrjCofI5vMMsza0owzeODhBx533ImLnXf4sQcbQOIwAwcb2FBDjddko802PeTII5NWhjFmmFsykcRRSYgrDrlbEOEBBg8kWMAA67ILaYLzJLCAgg+CGAEDDTTYQNVVPdDIgwI1qGCD9XCAY5P3gjEGF0sgAdG+gfzQj4/94PBzISrMUMMONSZCgSIUEExQ1Y9A0u46CQuwUFsMCyhAQwYiGGGOQRZR5BBF0E0kETpOZMSRZ+aZZ50opSpHThtxvEorrXgE/zIstIIki0iwvEIynHPOCe0tNvXi6y569LrSLsjA2TKxLsHMuJvEBKPqqYArM/NMzp5a0hx12sSnnrjameueeYgZIw0obLDhjDP8fEO2hOKIQ4847mjFmKGBAeaWQICDtDijkctECB48sACCBh6YINQLNhiwhRZASNUDEryIgYQSWLioIhS2TnuGDjpwFocqDiFlllzgG2YVTCaBhL5f/cDPj4LsqEMOOOCg45BKHjnDByeg+AGHic6uCIRpGwSJAWwvJKAlbbstIEIGLOjgCTkGMVfdRHrWo6dYWORGnnXWiepFG+dCJ3aoqConq6lyp4qbfQMmCy0jCS44SXWQf/8LH3garpLKJyWu6yuLtUEs4+s5DsxjdLYK2Uw0n2rrMpT5UTkuudaZZ5tI4iDDhhxsMAOMnNtQI6E3eo6jjUqaecaYXIABijxIAhF5QETRhoNAIwjBBSCAgAM6coFXtYAGO2DCFYogg7KdAA9YqAENQAhCHVRwByUs4Q9qhoMdUOENk0CFK2jBi1wBgxSWqETeGrGIRRjiEIQYiCAGUZA9/GEQmkBFKwaBhjPUjyFMiEgFmwWtDViAIxIIyeUMgIBuDYCLJuGitxBAHQc0oAIsgAIdBpGIQrDBZ4BgBCOO4Y1scMMb6+AGlbhBO6ncDne6E4fvHOM74EGmK+CYDMX/IBMOcpDjYAhLGD6WV6Xm0eNJVZoSPQT2F8GACTDYyx5gegfKcgBGMiIDHzrakg5znANlTXqHXbyxjWa4IQ5T8EHNkoUzNrAhDb0sQxnwFwc2DMIY2HjGL1zhiUAEwgsSGMEtkFG0YRiNC0KoQQtQpSoQzAAHRQAD4fgghy487gWBwIMRktAFJliBnVe4AhjgCc8zPAEKU1jiH4y4CljkwheJ4kUnMFGJGz7iEYs4hA7tcwhDDGIQhXjEEW+xiD7UYVh1KJZC3EmFJ0quQOcRyeUkdIAunmQA0QkjdQxwgAU8oAM+iMMffKaHdoUCG9mwRh2vEY+6RKV2T9ERVIDa/ztvDLUcPQLZ8C7zPcyQw5EISx4k4WGliD1vklQiU8W2RBhPdix3ohyTmbxnDqekMh1PzYdc6hLLULiBDbaUgQ38dIZk8TINZVBi/QgXB188gxrJwMUkeCCCBAhAAWIABjJ4Y7Q5CEEIQ0DBBtBGAyqk4Q12IKIhDNGHNFChB8ucwxsGNxvCyYG0pK1DHdgAWjv0YRGeaMUpXAELGQ5tFpuoRCZuiEP6NCKH5TrEIyghC2AMAxINZejf7mAHOazBomq4AhN2QBGKlGCK4rniAg4wIW2ZJDorKWm3FlABGeQgDXLowx9SRIxtZCMb3tDGOrrxIqD6dL5QuRE6huoNwP/0qEyGTOpk0MRURyJPHQtzB8QiFjHoYWlKjAQYVhvjSU5qr6uBJCVWgDeZsS4JZeaAhz/qQRdvKMMNblADa0LAAjOseMVqqOsu0zC/hKCif81AxQ4YMNiXUAAUxkAGYkGBBx68AAYuaIEF52feQRhiEY0oaB/sEAZCSCIQd/CDlf+W5b/9oW974EMfBkGIShyRFKtghS18EQzErkITmNCEQHPbK4LulhLB/fEkmozQH2o5cGsAgxMjMgMpMsiKDlgASWiy3ZYMoELROUADDiDeN/jhD4CIBDS2YY1teCMe3cjRfGFX36fMBXb5HROQwoomQ1pmkU5lE/LYxLwEJ9j/knZZCyEP05jCSHgwo9xSOcahO2FXpilu4Yw70JEPEONoG6UYShVYI4MOsLjFNxvDGMDQBISEIQyV+LEmWPAABSSA3AhIwArwQBw8ZCADMYiBC1wwAyq0oQ52GMQjBNqrSUxCEYNYAyI8gQhC+NCHgsAsD3+1UIYe1LWtIAUqYAELW+QqmqTQxJtvm/F9y/kRmpiEJ4Yhi0ZsvFeIUMTABUEIggRrDc4FgxV+QAOubeQCEqgWSbJ1kpOkpEItSSkXI00DOegBEL1gbza2oZip2Nd2nx71fW2XX28AG8P7MgeA0QTgdLASeayMNZvw4Q9/5IPsZLeHXeryjnrU45CZ/+xKYQjTJbgH5nrWWwxjPL0OduSoG+W4XTmYko52LOkd97iHP/6BD3rMQxp6GEMUVjwFyUue2jeTw37UcFrCCeIWkHisBCiQgZgMFgAAoAkAAkCACJAABmFAwxPYoIc9DIIUsvCEIiChQ4nORicpJ8gg7IBZgx98oQdfRCU+QYpPnGIVq5gFLnjDC1JsYhNvnoRAKbFvgpZLEb5NeEIVCkRBrNwgLbcCFXwwgxlMDiTUcsBIEJBFA2w3ACYhQLeks6nqOGACICiCGxyhGbZh0+bBHg7PNPzB8Azw6XIEdhwwv/puHBYJSRYJTXIHw8IhqdpiMhaJTfRBHzwQBNlE2f/ETuz4IR/+wUyExCu8hDCySsLubjEcMAY9re/mKx1eSS8QDx+6YRt0YQyAoArMgAqowJ0kjwzIYMVwhnAIx08Ipw7CoAQwADwyQAQEq0LIjQDqLwFOQAjmwDgGAUUwwRRQ4ThI4REO6hD8AA48QRIGjskWyj4IwT7QRSDORREeARM+IflIocxcQRZ4ARdaYRABqhMwrhLqLG/kLIfqUIcYMaEObvz+JnD+5Ap8AAcsYoom5yNEIkIiRLvsr3O6S0MipDqqRgNu4BKKiQBb5PAS0PDuIZDQoS7gS+9ixxtsBx3SgRwkcJEWSZUuY+naAS0UCTPSwTKcCmVC8AM/I+z/TJAfygceRGYFvyGrWrCTPIkGZVAb+y5HtqdlDBDx2kEbqAEQcsAJqqAKiPD86unaxsAMljBZLkpPaOAC2C0CrFAEtDAAOCQfBasmggAP8GAYqEEW/iASBvHhHA4THsFcBuEOhAMRdmKHDkr3HLE+HBHfOqET9rATmq8VZAEVNKEVbsETKuHi3CygcitvNm63LFL3zAUSJXFY+AAOxqAKHqcFIGsTORE7Lif+ck4U8U86wsg6rsMBKoADxuASiAEbBhDpdMrwxG7q6GgWb6RlngIrd4R7vAcrTKky0OQYy4rAvo4Z9YHs/iEt/6Ez6uEaVJCQNEnXrhEGuZEGQw0q/6Zu1KSyHbohG4QhB4AACtTxB6gA5qKgnqZgDMgAZ/xEDcxAHWkABDAg9PIxArRQ9W7CC4LgJjZTBFbAgCQBGJDIhZxPFlwBFT5hEngIiDJBFiABEerDPvLsIutDRJysEqiP+jqhD1fBEwLKtVABoE7y4i5OoCYB3/atJXmLt3QIXQ7KXApOy/oGDqAAE2UOWqroAaxIOz4xOoTSO6ODOo5SJCCgAm6AEXThGaSBGmqqjqYElLxRStCBKbLSKeZrHHaEMkxJ68LSHWAt1tzCMz4QLaFRHwCPG6Ch7YQEkSDjBenSLh3QAefzKeqIp6RyY6iBEW6AnhqnMIkwCg5zDP8ScwquoDEdcwcu4AEigALyMQHqDx+DwAtkdDNjtEa9wJzUAMwKQQ9hCxdMExMUiqEqoSQv8hCWczkfIfeQFDc3wRIwYRMM0eMmgRIw4eFQARPqDBPcDCXhLDm99DgbEl2arPvQxYcYyhBGThMU4QwaArpkLiM4ggIsYDu5kyS06DuzqBSfQ6UaAAIgIAQAwRF6oRmooRraa2MMY+9qUe/uyxxm8XVgZ+/wpR0uI2HqExiXJEDhocDa4R0WBh4IlB/0wVGjgRgUlCyCh2IcNBu1MULzDnfqSO/k4fDeoS+L4QZCAAiigAp2VaOsAApCdPKqwE+4zQg+ICTwUbBMwib/YlRGnTUIcIKZNNMLEGEOgq8QKAEV+hC2ZGE+GGoQIIEkVbM2mwxJCYq3RAS4tNQSnNQS6oygIuFJN+ETPOEQK0FLiVMTcIvkphRM6aNcQsT7FgoSxkwWNKEO3mB+wGAIdMAF4NQDMCA7reUnNUQU81Q8SWoA+BTSOAAQYoEZamrTAgN28o5RJ/RRFdUB54IpKhXZ5tNTjy002uIt1EHwPBXWlG0f9kFU38EaiEEVDOYrbo1iqjGrvoRVE6MGtRFWuUFWxW4cpeESOIAFglCjNIowgZWeJE8LkIUKamAEJCDHRm9ZIwBanfVsNRNpmCkPBHLlDEERSMEV5NYVVoEU/yjBEArBoTThFloBRBQhEuaMoPImEnhrzigBEbUP30ihFSqhEVRSEzwhcrVUoLYUcuu1zbJvShPxOEPEJWPyECjBE5ADFYAPDurAz6BL0EoAIzTiPKoFpCqWu0wqjFAPJUpqJQKAiyDADUrhGLChpsAkVvWIdphieG/kMtxiPjsVTpgXU5l3eXE2H3ZWH87hGo5BF0LBF5GkKxwsMrhiKlb1ejYmaeErBhXjp8pBv5q2HcROHqwhGXKAAzrgB6IAIoiQMHkVRKGgCMGgB8A2x7LwJDATWpsVbWVUbc0pEBBBEsbvbSlBbmdhFlqBzXjCECBhElqBhurscA8XzhBRcP/3jYMJCl004bBuz4P3rRIuN18vzhOOCBV8ExHrDHAfIXH/tQ4pAVGGAYn6gA+GZQ3CALrgzchYd4rmlE5/sltaonMMoPRqFyV2DuggABBqgVCPbqgYNUriYYvjoSmKly7YIfDaAh6YQu3gxC3OeEneQlPZpB5Q8B/g4Rug4RdCAWi3d2DOQlWNVjHqkgYdg0ITI3bEzh68oRdyQIPodx3X8aJcrgmOldw4JAIGqx8JuJItmYCXyVkhBRL8wBDQi0rl9oVVEw8nAROgiRc+oRX2sA8j9xOiVEu3lCGPsxAqwWjQsIYhQSAGAb0a4SQjN3JRIZg9wRCh9BM2YV0jYd//MMES8iZwH6EVfswT+sDLKPG5dqAiKqJ159RqthN2cU4o8w+7qmMBxsgB/BQCOiAHEgEWksEpvaEAD08B4wUp+EEtxy4p7DN3dgRNkDdTkdcd/kEf+EEdoFHs6kHsuOEYYkEVRMFg1qIr7tgrGNRov6SPtZEbALlp1yEB5yEbNNQGQEAwrXaR4UB+wkAHPoACIHn0KPmSXZqAvYDKDphIGQq9LOEjW8ETHoGHFIESLOETcMFoHq4PtbWVYThK34wSHqEQGuoP9qAP9ICImPoPpnkPnvqyGuGCvfReobT2ZOGY8YYSIuFwtS9Erg8ZjEERiIgPCqIOFMJNIQdOO0JO/7njimAXOphYQ1LqAFRqARrg/QB7ApIyB9DzGVhknvVinumkfNIyKc7nHcp4M9BYjSc7Zj3jHEQQH97BH6hkGXQhFl7BF0TGSIZnGqlRjyPs7vi4jzHadrShadHhSbyhGNzABqRtV+sXf3/AT4CYByiApQdrWV96uM32RvFARokjEwxqEPagEC6uDyvBoM5FXT/BFYrD9ra0Sy13hXMvSM/0TDHrDgtX31hSc6l0XnGBF+r2E7S0g70URAjK44yrb9oaDtiUCZzoOqlrVTrC5joFdrtFr6WDr/m6AQwcsMsZAjjgBvSgd90Zng9vQnWkHdokZkdDsjM1w9X4LUTVM//exB/mohp+QRViQRea4S0hI+sOKY/jcjDMF0zqsrXxS6PtQX0uQShkgAPUkVchAiLUgNuEQPTGVgDIDUaJ+6VllMrwQBKKAxWiWxGYmrcOFyPRpRHO++E+QRH2gJdcY5d0Rg8UQYU9robfW6u1+kuTs0uv70n9cBU2IZiTTxOU+voUMYQnoRASwQ77hiCGBQ4WwrlStyJKYNA3or+5+YoiREP02tGya5z92sALvAKS8gbcgBFq4Rnai5LuwRoIoxzWLlPjpGUGT8M1HE7YhBz44Rr+gR84Yx18NhZioRZ896pK27RR/EfIQjBePGm5ERcpNFZrvBniAAhsgAV0PAr/0tF+qQAMfiAFhNwyidzIb3RGj9ySb9RRhis5nJw+kjQ59QaXIYFKAcoQ4qAMJk/yru0J1B0K2MAPIEFfc8uDO/he8ZWFf9kTFFJbwVo3OVIT/oAN/mARru+GCHbOvNu7g4U/DuLPJCJtCGRaPKKu65Qk8No75a86Nvavq6YCOqBPxyAUjsEaEsMa2Esb4oEexM7U4WFl5MFTv+7lYZ4c1OGg2yEfzMEd1kGhYZ0YrCEeBqnWSRvoKSZ4Nkm1LVq/0NcB58EbYmEMaIYDOMAMepV+qwAKUMACxi0BNGeAYTqTq/2SBwiaFIVvTZKgjPNcyRRdGpIOApNx9vcJqsDp/4VCKBaHDeigl385mPX+iAZxEPne74OZFOpVhtm1E6jvSSshKIDgCcyADxRh4KW0+9DQtxQOcOzgIMLACoZAIiCHQDwAa6qom68FKLvl/rqrwDWWr/fvAXL30c6zF5bhd9tzSvIBkiApH+qBHurh5UWwLD8QHlB9GqzBHtDBHfLBs0n8F6ohHvIBrLRi1UzbYNruqjrJomMQ6ekLduahGhjhJm0A6h9PHQXTCcJtATKnJjizkm9UWs3264NADAIBOX4MF1CzEzauERbqD34mDuSADoQp3QGiSpUoP374KIjDx0EoUaAohDImzqBHkzB1+kQqo0ZSnTpt+vgRU6WRlf8wYbKE0iQmSnEUAgHiBIoaPo0qTbo5qZGiRoMaLVJ0yNAgP0T5zFkTBoyRgj5ozGiBAgSIEh42XLAgQcKDrQ4WKEBgoIBYAgLEFjAQIMCAtWsPBAAQ4MCBBiEAqTqGLVu2dfbywfsLuF4+d+oKA4anTx/ixIrhjVN27Jq8cdN0qYrVC9o8xOjMjRsnLvTnceZKlx4XLnW40Z/BuQYnjptsbt1o0/bWDbfu2tzKofuNbp23ecTcxMEhgwOEMQIHmqHxYAGDBxEiiLgeJLt2L9wDedEOPnwQEdrxgAI2rBmyYLg42oTU6NCgP3roxKHzJj8bNmaAFPwP4EJQQPHEgAT/PgEEGW/E8Ucij1iiCSmooJLRJ5909JEmmohUCUqWbLLSIGPkgAMQPjjxxBRXmAGHH5DgNMkjQT3SiE9BDSKIIETZcVQYVlxBxQ84OIVCkVRtYJUFEyz5gAMMKPAVAQUQQKVZAFyZVpZwpTXAAQtAwIEblxBDzTbe0POOO2q68xc+hKWjzmH88JPYnPzgI4411kDmDTfKhBJLLXjN848+qIHzmWefkXMOOZ6F881r4KiWmqTgfPPNbOXMxmk5nsrGDj303OPPO/TMk80lbrzRRhQIjmGGGVVQEQUK0TEQQQbkiRced+B91yt3XuQhyS3DIPPMM8bwMsspn4gUoyKF/wzShx567FGHfW/wV0WszQlEhRljjEsurLGaQca4UzzxxBhsyPGHIYpUpIknnkxIob32blhJI3+wQS6BUwxMxhloqKEGHIdUkkklmlQCn41CDeXHH3bIgbAVVAQ55AxRdSDVBhpUMAEEEDD5wJNfgWWWAC6bZUDMC8zsgANbbTVBBRWEeUkx2MwzD6n8/GPnnP4M/U/SSuejtD/aQDONMsQc48wxsajySzLVeHPPP42mZppnjJ5z2mqjUZoaa655yvammrZdzj2h0oNOPfLMcwwgccBhBhVQOHEuuC1MkFWuK2i3K6++ZrdC44dn150k5yGbLDLD4OKKKc/a9Mgji/8cMu18fOxBBxz8nStrc1GgS0a65LLuOrkDDzxG62OkQccegxhyiCKdQ/KItHq8QQaBEMlOsMEIo/GGi5k8nAl8i/w0seh21AEHwmpYUdAOHoNQJAgdaDAyySg/ACWULJsFc8wIKDAzA9PdXDMEGnCQAyO6SDOcPaQmbTSlCXCA5YBGNKJxjFD8QhfEUAUDiaGMa9BjHe5Ix2nS0Q4LmuMcjSIHOcz2GUp5UFHjKEcJ4eYp4KgQHf5oRwvLwY51ZEMVOSidGa4wBsB5SyA0uAoFfkgeYPEqcdpZwQhe0IM5EEISmchEK4CBjGYk6xmWY1YrPvEwm0wCeDoJyrT+8Af/0sUhP21ggxpQh8YbrihWV2hjG6cAhSnIznizI1cZyjAG2uWxQAHr1oAGZoYzCHJWaPjDIxyWiS1O73OGaOQX+XA9OGSvb1DAwVNm8D3xkS9J50uZ+sLCvpiJEkrSkR8DHNCAVOpsZzfQQymS8bN52MMfcErHOwToj3z4o1T+qIc1oPGLS5QiFMVQRSgUWIxe9MIapFJTOp6JwXakiTAcHKFpPOhBDoZthexQoTzYAc7fgDMf5PzNNbbhDEAYJw1pGJcOU2eGH7TAAxjIgK6CIEReQc4LWPBCICSHHmQgwxhRbIZBBToMYOBiFq0gxcO2iBNIcHEnigDKF/vQh9GV/66M2hNkGt3oxjq2znZ5rJ0Z9pMGNKABXXk83vGYY4bZTQF13ZrCGewwr5EA7yeH6OmNKHa96yHsClDYAQ06hgIWiA9kSLIAVs6nMgRIVZRUjRn8SumAudTMARWwAPnw54hfQGMb87DGNa7RjVvi45b/2GU3uRG1UAizF8YwRijuIjVilAMfblqTPL6ZjnocBjBrWtNf4lTYdrSDHX9t7DfBCVnGyuNo+TBHOayRDV24YXhoaCccaXrDH1DlAyY4weHyyTjt/DMTTATF5AQq0GYYYxjB8AUuYLGKCXnioVyE0U0kGqPOdTF0YCSdHCTZBjUI0qMgbWNzrgAuKnSLpf+1c50czXDG1EUhCtM91xlGutwbVmFgZZDDIF7EOaD0FCiDaK8f+ADfOmDvjA35gVGfEhWphMypS+pvk7rilZVV1arpW4CXFuAAwklgAgtIJZjEVAxmVCMb2lhHPvaB4aH5gx7amAY0pLHAZBADGb/4xTGy4Y1yXINO+mATPN5ht7++Y8aH0Qdfb4yPxLTpxvWIsWP/ig7I/pUe9ZgTPNxxjWxIgxHGYUMb1EUG1HFXVjtogQlUkIIU8MBXj4McHlabCX1lAhWyuAUwgOGLXJSiFKLghElIQokY/QQoj5AocG9CiTxTYqfqvWh9jptc5Yr3W7PaWBWcO90DyZFcpxv/CHcFkkbYCRJhZ6CVTckwhTf0oRGT4JyNGNlIHRHlvRdrww03JiSnQCV8IGiqU5WEMptFVZRicd/7FGCA9JnSAWrpklwgUJdSHGNr8qhHhvNRD3r8UhnLkMYxinGMX/QiGWTtGj/2Mac63anH+WDHjNmUY32Qc9zjHmDSNiyqdItKsqKyR1+IBo90JPkXbnADG7YF5Vhhmo9VUMMVfqCDF7igBv0ElhfwkIdAIAISiEAETvrFaQ11YkInsUSctbhF+FT0J3imxEhMEpKTUKJzNLLofCx2MTi0IQ1nkOnADERoR9d3QAEqCBRsHvNYDWxFZ9DeD6Ig09btwRAv2qJO/3Si3uoN5Q98kEOgz8A9IWESk6tu9Qaqwl+oRhUsA0ZAWWotlwNgiS0G+HUOxvSzewgmH+j45TGIAcFiwL0XwybrZAtVNDsxrZdEJic+iGbuwCvtHoQvPOHdbfh38+Mc3dBGNSLhrjgAbAwpgkKsWirHKfQb6lbofBjEIIY5zAEPpL+D6Sv2h0IkYlp28MMiGgGJkZBcor8DLvBeBAmJ2wtfFLoQiCoR54kSl+mRZPl3XT4wR3/LBzhICPMT0vzoR/9bgcN0rLSnhh/QsWBoKAMdDEGRLQq3oj1t70/9kPLj+jtIQupY1adSlavAegI3k5/6uC5Kr5NFAGwR+9jFsv8AbdEAN8AImUFWqLIMb/cLwvBsxKALDPgM2bAN2xAP3GAPo5JtRdNWG0ZOSMM0A/SBS8M0/nMP7oZ4iFeC7sY0Q2MP3nAMbgAE+bEtrTMF6QJHT+AEMJEicHRobWQFTdAEYCCEQpgGYIAGbfAGckAHS4gGOGADaeAH7SUUvNMInTMJHkcSJaEhmtAJ9oIRpkAKFgIiehYJwQM682EtdCAHcdAGZbAuOOgETvB8NmAD0ueEdWgiQAB9zKd9P3dzBvJoApFH3jVpytVzapAGbaCIZZAGDHJIWhQ8ijA95edefFAH6jcrUucxNNACUBEySCIyFmA+/pUyKpM+63MWVDX/Mw2WSlu1FSYDAToDATfgBqpQDNJQNcUgdwQ1UHVVC5axZqogbBM4NHOSYRomKuQmeCDINIWHghdogtD4gf4wD9tAQzFYRvtRBpj2cjn4EijCLgyxXQ3BEFRQg2CQUomYhHRwLWmgEFA4CISACIRwCItAcliohVvoCReBEaRwCqcAhp8AIhZHCZEQIzqxeie3B3ugB07HTtu4LnGoEHKoEM+HA3AIEyZSIjZnIFDQHKmTR2uEOoeIMOykiJ3FBhLBae+BdOR3fkxXB4EGJFLXMZmkX0iiAaJoPlqxFaY0a6J0AFV1VaxYP1sViybDASHQSpegCk2pC74wDLNlV5dw/wmM4AiF4AiOcAnUJg/vwA+IkWFtlW71gA9MQ267hJYi+A/RSILqlm6KZw/zIA2AcAM5EGgnBZE3mIM+8BIwgSI5CI7skiIFc1L3Bgd1YAfwxTdTIAd+IAiEsAj0iAidEwmUwCFbqAmb4AlfeAqr4JmrcAph6BEDaXGREAmOoAiJoJqho5BhVB9xAJsLsi37wQatU5vjwi4vQSDgqGgpQi7pkkbcp1IHgzCmRptxwAfzknHw0VNd1F5LZwd2oHJnNBAAggOdGBWs1gHjk5PzR3//tXUDZmvvMzOt2IoOcDJNEotJ6QaOIAqwwAvGAJW1cAmRUJWJYJqWIEzP8AvacP8N7aAP18YP+VCWoiIY/0BuZ0lufIVsb1mC9OBubrl31fgLOXADT5hd1tWNfcmhcRiHBTIg4xJltClJiBlfcCAHd+CYhMCikFlnk2AJIlEv+iIhEuIKrjALOZqjruCZp9B7FYIhKlFxcRYjwdWSvQM6wwdGSyibcZAG+hZl6sIuIto6wWkwgkScCEMG97YfbzB09vhbG0c9hiAISycIkDRfQ6UxP0ADRPJ+26kBSTJ/D/Cd9vcVC0BVUjVVuVaeqeSnNUOn/1UBGtABZdAIqOAKvIAMtsAJl+BmH4IJnNCoseAGxJAN1iBYc4IP8NBjMOZ3N4Zs3OYXfAUYpnKB6vb/oPQgDwb6D/cwD9gQCRcaAmcQOIq2mwACIB5aII8WK07mZCVaB/FlByq6ovOICIuAXg6DCVx4LxPSCq2Ao7ggrdKaC9JqC7ago9k6Czy6Cq2QW6FZIRYymiCiEqX5CI6AdKsHRsVlLWM0Rm/ghtVlO28UdLNTMJTmLvqxH3RQB0Rne5I4iWRaiaMjX3SQXGbAPTtgVC1AdUm1VFa3AVkXa11xiuJJVUPZp1sFqFvhATuQkpcwC7AwCqbQCZwwCp0wCqMgCqPACTcACMtgDdyQDkRDoJ36DmV5GPUwY+2gsy72F+5QD/5jD46Vqo7lDy2YDG5wAzJQAeYiK1EQmHGI/6v/4aExAWm9WkZICAf8mpjwNWqPGZmLsHCdtqzL6gkS8qw3OgvSygttiwtt67bTKrcLpa3beqPP+qy51XviSq4ocYXRIi2FMC2FEEb08WdwMJu1qXPINzskOaK0SZv9Gn43USMBK7BC4QeGcBOLYAdDxQT2dVROMQMyoFQ36WoTMKelaIpUBTO1NlWr2ACoJBfwU4qolJRjoAePgAkXIqkqEQmWoJSOIA3aQA9J4xczBmObWljIu7PpwCbPayqq2lih8mPfdLTbUAoWGgJNKysaA7VVexBMASADwi49iC4GY5ILwo570Afr+gfmBxRgSrbMigqtIAv3ewtl9rZwy/+/ueC//gu3uFCt1RrAc4sL17qj3LoKASmQICFyZZia8jEIhLuupLO1pkNp3ChTcXQFkxalNXg6+9oT6CVRPhGwPcU7lWC/nnCmkuRvn9s9oku6+WV1r5a6ssYAqxgz7AMzYAE/VrUAvTYABRB2A9AAcxGLTzAIppmVWbkTIcABN6AKe1G8a+W87lCWg1FB0IS8GbQm6pAOwCFNO/sOQvZYcYkNgJADUNy0zSFdcOihNceRBWJoHZyIWau+1oJR7TvBvRMfsNdpDqMv9esKsrC2a8u/vqDIbbsL/5sLbtvI/rsLvLDIlKzIlxy3dGu3rgCuHmESKBEJ8aEI7ZUI7bX/rnpwmHXAKil1fLPzN05ABWvkLuKypZe3H21gSDfBkpV7CDqxCCp8ZrKwCOjHI2oABm1EBUywAx0jA/iVXxF7AfJHik2yijPjPmNRAAhQa+7zFVkixGRXADMTizbABongCIlAfkoJBICQDLJ0NBoIQHknz/AceGjpjNVYHJLnA8eTeQbiBEVQBAor0NGnsE5wBK9cINdVm53VBnGghAvJvu/LO/YYe8s6o/eCt4bsCqwwC7YwrXCbC9dqC7RACyNd0iIt0gJ8wChtC/470rAAC7YA06yQCheBsqMwhqYZCb6jmuqqO4OwtapssOo4BWlABuxyBk8QLg2BXZTmUWjA/wZn0AaSJAd9cAgwAjwkZwiFoAiYwAvHAgyGYInSeUaxHCT3BRUyIAP61QER+2pLAgFNwhUAVs2oyMM9XGDS4SQ2M9cV0AE28AdYuCEaoJRjwAjU4M64RHhoydj+YHiP7diPnYJAQ9nbkCpxQHlUsAPkK5jbdQRHANChXQQEvQNFcARagCJx9LiM2NDs2L59IIX1SBGCvHvPynuI6gqwwAqwsLb76wu84MgsLdyOHNIs7b+1UAu0kAu0oNuskLKcAIYfYXGOEAmJoAeJ8L4Aowd/0AdB/QZ88C7sNAVogGkjRUlX4G/Lpd4GUzAyOHRF91slJy2fQDnAUAikNl9ncP/MZ61qDfuJrjaKExs/XjFVtXbX2Xxr6QM/T3JKNTMBG/ADgtBpwbUBLJADFx4K2QA0bEnZHe7hHw403iDiI+4NE5gN2IAN1CANyfAL6kQGV8AENCCYfnlzU9s9Cmvap90FcWRT6oiidRDRUjgIvWyFDlMvznq/rQAKu7cK0drR+0vJ/Nu2xN3SxE3lLt3SjXytyw3TML0K/vgJKJFn1B0J70sf9+alY1AH+7HmYzQFd9QGGvxdBdLBq0OI30XeUv0GafAGdNATE057vawIqNAM2NAMqDCw0olcYJDMoNt8o0vDEJuTOtNf36mxOQwl4wlKYqGnekpKM6MADT4BJDD/Bw3nBz9QhzNABjiglDkQCxNo2RKoFyie4rgIGW9HDMIgbbFwNcdElafJCIwACOpUb/V24fUWB2YQ4zvALoBp0DZ+40cgBVrQBeiIpUlooon5vkNuj4BMEkduv/grC63gCaBAZrfwtgrVtpeMyVI+5cS9C/Fu5S6dC5Hc0tfa3KcwCqDpe5TgCHkmLW4wCGxAB2yQBvVBh/YxBm/gA09ABmlgr7NDK9J1Q4GkUt9FBkeIhHIgg3+gCEUnUZ9ThcbSCo9QCJi7I9E5X2BgBZ97c5bkzDSMk93pnTejuqB+fyzT6Z2ea6Q0HRTwODzQAheAugUvA2CSA27ACY4g7MMe/wduMCIWegNTHwJVX/UcgPVZr/Vbz/U3IKI/QAScCMcnAtACrbC4ygRUAAbao4hJmJh9UDHmR9EPZ9Gbibb4Yi+QEGatcAu3IOW+AAzBIPi/7e7vDsC8EO/yPu9WfsC6nQqj8AmjwBH+jp+WgM6FEAd6wOdO4Ib3tuaqPJHrYlONe9RRQKtXIJwYr/FJuIbb8n12Ngk99QjyIi2zrwjVA0nvhT1tcAZAkonuhwKr9syg6NaV3kmmpOB7mqdcd2sMQAHXUR0RwJMPYAPJoRxxMPVZXwEms/0cIIuwCP7hL/7cv0rgLwNkEAVUQAMuwLAeWpFmf/b/wQRpv/YJg6JyYP+iUbg79ViF6BXIFg0QnTwNJKgpUyVCkDKhknXLly9cvB4Go1jxIS9eu3JhzLURY8ZdIUVq7NjR1kmTuGjBOsXJVKdOmCJFckSJUqFCetiQGYNDhg0cTsa8AQInjQ8nTqZMIYMGCpmlS6lcMWOGzBk0Wc9sRfOmTZo2csywYUNnUCNIkxo1MnSIrSFDihYdGmRIkJ8/fvzwsSOnjRozZ8xQ+bGDxgzEM1qgQAECRAfHGzZYoDzBwgTMmB9sfsDAswLQCBAYKGDAtAEEpREoiJBhRYQEESIwWFDbRgXcUNJAqNAAwu8Gvn9DCF5cOHDjyZUbt2FjBgrELWj4oF59x/X/6z+OHJEiRYuWLmDlyLFjZ8+fP4MGFTqkqNGjR2krzcdU3z6mSvY1aaoEyQ+hSkBpiBdgMPIFmIqCGWYYii7axZePIgRppJBKMsmWXWyBhRZWUonpFPtsSqSQRyaJg40TgWrDBxlwYPEJOKZw4gknzoDqjKemgGKpHcm4Kisg0cAqjTSyeuMJNt5IcpBFIDkEkkYWMYTJRaJU5BC41FNvr77gUOMvM6pg4joaDFNsscYYi2wDDdrUwIIKMsuMM88WCE00PAvQ0wAGMhBBhAQCVWDPAzrQAIK9iIPgAAdw4w03SB11dDgIHAjOAUuXq+2AA4IDQQYQ0GyhRRepKyy7/yK4A68LMFpNA47y9jivrkMOWQS+EufTZKBNet3kvkp29QQVVDSBhBBEMgHlllsIxAWXAxVccNoFG3zoWokuygijkXKpMBcMNaQllVRMOeUTS9J1JBJFClGEDj30ICMHGZzwIQQnZJDBhyf4TcqHqNDwEQoobOzxRyDTmAKNNM4oA6ysyEjyjTf4cA+tRmqt9ZFFqtS4rinxKk8OOLw84womCiuMhsMUQ6EFNB3rYIPHJHvzsss066xOBfAUjQDVIvgTtkALAHqAAYCAwr8NKnVgggZYkCEEGW64Qd+pQ9A6hA669rprNyOtoE3cNDB0BhzS3iHtUqvz4Qe4t+tOCv9WiUxjvDv8EGQ9ReCLxBJMNvnkE1KINfzwVhJvRZaGmJUFlEwgkUTZhmSZxZVZoFXQGGOQQaZzzz+f1qJgfCHdWl68fQjcV1ZiZRRzSflkk0goaWSQPa6kg4wnBLZhChvG6MmGellwgvikzpBxxqigeMLGH4lk+KsyymjjjTiyz54O7ukwpMRJ5psEko4buRLLQrbkY486SobjDcCogMIHHMhEkzE1H/Pa5jdxk3MzB3iGNqA5DWlG84ChySYCoAHNAhoAiUoMAgoykMwEnqYBHEitORtsDtZY8EEQfvBrI/waC0AAFLa1zW0/gAITqKAFutUtLOTpg94IcatJAG7/E50oHCoU1wrEKU4WijvcQCKHCEgoRFikKJwrbCERaXGOc58zxugSdK2LgGsXH9HISVKxodeJYhSjIMUqKOEISzwCPeg5z1GIBwR92cAMIYAA1XzQgd+VQSnOe4LznPCUrXClSFlpQyEpJoc4UEx7cZADHeQwCPCJby0dW8SV4DKlQeCFD3WoA8nUcIYqQOEHTBhTyxZzP5ntj039y9kE6NSZ2igANaIpwAL8BBvZMKBnq3HgIJQUBRy0AASVaUEUZIA2HHBQmRycgXOckxhotoB4UsPBD1LoNqQkBQpUsMIVXCUeO9whb4K4oXzys6seHg4VpCBIO/cjvvFBKUqE/xBEPQkRn/Dlh4erwNyzNnKtBAUUQqn7yIVOUguEriQXsOjQKD6BCcIBbi2FiEMfpmA+6gCPBV2DwE80EAIN2oB3T+DRjqDAvEAGSUhpoFhLXbrI7L2hD42YRE37A4lHTPJK58PkXvhCsr9coQpCJUzaWuayDzpGqWBzkwb8x5nN8EyWBlgABTKAy9kswDSiMcAB3qCjwSAGBZRRw72SCQRsppU6KWRr2pDJwfphMylzfcJUAkOk65Enb3ojJw7zuZ+CaAI/lMCplQ6Bk0GsET196ANfwjmHOdjBD7RShHseQYlK9OoTDiUcKWDHClewghUMpYUtSksLWuCiI1vc0P9JbAGulYyLoaxoCSlARAn1/CEO8KLDFHDQgRBoQAZtehRIP+iDk9KoKTpiSlR8hJWEoeF6X7neSxeJyDjowRD5rClOcxqljllyS3rhS/s++ckryM+aZWqZvkKYSkPZrJVQ3ZmdGCABBAAAAAGYTVdnORoDgEENayDCdYZbgTGwQV83yEEOrrnWtkZ4g29rDtt+UIQduG1GToCbC72ZBjCApQ1wIE95wnmHGuqlD2vEy2L7sAc9yOENg7SRc63X0q+oQcdqgEMdZLVi9FD2EZG4LCXSlS778HCzq1jFKfg5CyiXFhYmqUVHaqGRKXdoFZhAhUwo8a4xMFIGT3ECDkD/QJwGOKADFXDAT+KIlHvZ4A1lsHEbmFK96gGpkHjFnnVjmsg2mAWC4ksifLwbJSxpKZN/2KT7wFQF+b1tZYjBmgxEOEKyxWkCEnAlVO/7Gv0KoDNIK8DP9DSHMDSBCU3AwQw0wIY/0KtqDQZCrW2NVrXSj21AQSGLksk2DGsYbkQgtgu70AVVHfvYYNiO3OZWHXtRp8wRZpuGmzuFLmiBCmC4whXOwFLsOZIOe1jxempV2criCsmB85XgyGiKVYy2tCd5EC+eCC5bjHYWnAgcJhKhiEGMAV824JcGGuXAQrHggm2ydAWUArAyMExgTWlDnvFcPTI8TMTTbekilZQG/zrAoQ1/oOl8KhHPJCZxLZZMdCY3yUlPAiaUVEjZ2o7q3kvXrE05s4AEOM0ZCZzgNbFZ4AD0REs9FcB9ODgMDgbBhyr8pNeSPmlS+rijMWTcSLv1cXoGcQh80gEKQKhfhk21g8LoYAhFIEIStoMdtJ9KbWUvQhFYdneWMR3vLcP7r13khCJUs8Nw21HE2xAH6cKBDnbgw2T1Uhc/6KEPJKpp7e5Tnx2SwhSmkPdrtyiR1L2iyegi3CQGoQgySO2PaehApywzgQOAQAMNmEAFHpMvFuAgDU/YPRrGM2M0RBxIF9f6xgtpSOztlixKShInm2Tyk6cl5d91jyKmdBc+ZP+/0SI/GRiskLL1QtPS7+0amyhDGZ9z2gIjCIIIFMgATpVaT0gjAAHCs/pBeEIRdVBDHfiwN0GIC7SwqWARFh9anMZhFmBYQGCYFmDog2wquwu7MLvTAQusO+rAsOs4Au04leuou7ozqrnbAWhKjL2jARugAaYTQcOgAbj5o6VoiqxLEjnwsZ+6AznQgAAAgAPAgT24lbSYBJvQIZiwhEhgBCRkBEAAhEtQhS3KBVZYBU6whEvABEp4hESggxzwARvQALRZFDbDFMxogAdoAC9kAQ1gAR/gnRicIexpg6ZQqawYJBF7Ay/Zsep6A4kZi+pqgz0QBPk4iJrqrpTDGEv/2hvHezm/0DHvI4wf0LX2+iAUsLQ12YALuIDz27QP4AH3UyAFOIABMLUCGAACEADp6oNHQAXHuQXGYRZXfEVYhMVneRZXjAheGIYqAoUkoIGp8YG1GcEdAMFgrDu4G8bAM8YPBMEiQIIkAMEkYEZoTIIlmMZplIIskIJpzAJtBA9uCwwdS5KSoQMbzAs/OAREQAQU2EH9CoAAeAAw8INKyARN6JWY6I9DcIRCWEIGYzA3cAROmIXSgrJVsIQvU6PdGoM4WZQFmIAFcIAH6KoynD2n6prquB7pOj42YBivKJKLsxvj2zM2ODyXGkm/eCQl2pVBnD74mIssYTRGYx+R/wsTNQCDKoiCR0ym5kAlEGCBEAABycDETMQMDFiB9lOgBeKUXSINPSEAVMCcZllAXsCFWpxFWryFWbgFW5iFrIQyW6BKrwyJBQEGQiiwXsSOslsbYkRGuBNGZWxLt1xGJIhLuaRGatTGbNTGLGCVLvBGHbPDcBzHPyAEQgADddQv/ZoAlhGE+XgER3AEdFuEIwQEq7GaBsuBEHADTGhFZvkEmygE3RqD4WoTEGjI2liAA4CaiQwBGygzH4CDPRA3OogpskCkrxg+j1w+rzi+PES+kXyDR3qEAuSPIISP8TEsTFq0RmuDkJQ5m6Qf+jmM+6FEEPAAD7jEy9i5GChKEf+4Kl0qzdBQygJ4lqj0Sq90ra2EMvREz658lteaRW/ZhQVpBTDQgR2wNF8sRrXRQGEsRmJ8y2RsS7kMULgM0Li8y7wEg708Azx0H3H0Pz74g0MQhAcwTMOUgBJAgR2QgwBUD0DAiX9TwhzgABGdzAroFA4Ygz/QBIYAIk8wwj5ggxywAQjoAA44AAiYvQbglN9Qza4ZA0dipD+Qg3jhHu0h0twsEhFLA7JIkj7UTeRzn/c5pD5YhGCJx+gjxMKqJCzpqfUJuZJhAzMYg5OCM5y0tEmUTp+8xDbZABXAgiCQje2cDUvxTgIyDdVSrWyJylygSvM8idPSSlzoyj21EI//EAmKaIQxQQwWKEazXEsN5M+3dEsCnVQkANC5vMtl2wo8pJiS4aQ9yD5DAIMBYEfDFAAKuADpKIK8qYtCSIREQEJACFEOgAAOsJoa5RROcQAIIINHGJZ1QpcR0QMOkIHfcKoGGJsKGC5L0wAboAMm1YMnEFJZgTF40YMfpRjeVM6Q5NQoxVZuhdJDGg872K58gqdBHJ+c2qmW2wtZaR/lJAM+shemmwFLWwyehAzJ2ABDQQE3db/tpAAAshRM0aU69RZviRCDFQlC7Qj2JE/VStiRCAZXKAMqYJkZYIH9dFS1vA66w7BIhUu6pNRJpcYCXYK8zFQF1TGOUzxOyj4//+iAUWVHdsQACigBHZiBNPAD67uSV82JGxDR36jVEADFACgBDDDNAzDNCvCBRfAEduoEdBkDDiAeramANQMu1XyCE6GDN9CDOPgDawWyP4CxIYWp5MPWPIRStR0PcBUPGZOs5zsIkztXlbsYlly0P+iDOgg5NjgZoaIR+mkORZVEmQkBFDACL3gNERgBCuC0CXCagaWN2jAACalcLvq8j7jTQdVcbtkikSCQSPCBIzAMxlDG/3RLRv1YECxZkqXUurtUujRZZQODwEjZlWXZT70DBxgAAQgAAQAABqCAESABEtCBcDKEVjUEV41V5KjVG2gAdnwAFVCACygBB1gAdv8cAAdwAkhQUVxohU+gKHrJAeECrp9wgq5lA3mBF/UQ27yNlyHtntiMKRzjTW71y5LhVLvZzXENH3nkj7mNp/gorJbLreTUMeUB3GQ6DH3Jnw8yAjxovz/JAEx83N9wyKiS3AUoHSyy3IUlVM9NnYO1XF+YhThIChJ0DNVtS0hdxrcM0NiNS9VlXWqc3b3ky+Nj0JaVgwZYyt61qhHAABcgAjjwgylBLD2Q2k6xUaCVWRUIgPl7AE4DRaS50TLQhFZgRU0YBH3hAImptTDLHj1ILEBQj/RRtLx9MfiVX49zUuoaSbWFg4dxUiJ5Az84SU+Q25OLJwFmSbhIH/JqH+7/u4Ix9QGLPZMPwoEhwAMv+JPtvICw4Q0I0BlMqQ0OxqKBQlgLea33XC2NCInKvRZMyIGkaLXShcsVPsvVrdSRhd1prNSPpeFstOFu88Y6hFJOagNLMQAFEIA+oQATUAEUIII7GLf3dYMbKFFQbAAOCAEOiNkJGAAA2AwBKA0DkIAN2N0BSNoOcAJD8IQhOoTfsoEQyK7scYM48ExFGBF3qRWcSJ/FGlv4jZftkbHjw1awsEOvwF8Sk4M0yLhCCr49e4M/AE7AAuA9Dp/uQrT2SDTyGpm/0JFo0ztKkwEmwINAaGQROIEMkD2zgZT/eQBMaQA/RS1YOGmURmlXmK1X/3iFk27pk0atldiQBYSQjuAFWdiD49kwuFlhFsaO10WCJZDhoBbqLFiC10XqoTaMYGTlGLbLk1U2qrDdjQTHBj2CEu0ZAZCADxgBFcCAEiCCvBqEPogDqW0ApLFRqzkAdmSAEtBeC2hIOECB6/WAMBjF0uAUM4QDT7gFT/gDNEhn9HCEf3uPRkiExkyEPVC011wxaiVSs9VWNx7olnofllJbirkbGUNFeRwIg/jfhM6pu2W0n/KS8VCDKrCXDmKBFnABxoAZPECEQGi/DMCACVglp9K0OankBTAJhsU310ItgEzpDTHp4o6tJ7Lp1LkFTbCXf9kw1TXGtFxdSY3dof9Oahc+XaEm0Lqc3VapCgWVHjSwau5BAxmwIF2igA/4gBKwABTAASl4TXhBZggYVQBoAKuBAHYsgBIoAMt4gAnwAAtiyCbQqgKoZqQpTRZIA0JQC0P4g0K4Qkto1fdoTJpo1TMOssSSZ2vdre5BpPzNzeO77PyN0usB1xnLKznInWDx7EwA7e4SbUXYG/XQPgeFA4EpMxtwMAukARSgAS6QhNne6A9gE52DEznRjEqGkBAGl1qwhSfvUymHcoTSBV2oBSs3HV/QhZOYhUGwgR2QAnsBgqTwadMN6kh13WVEamUk6kkFWW3sgiwAj25rFTDYiin4thNXPDJogyIYpgn/sFkU8ID3xoEjYCmuDVEqHgCg3a8AcIFobkiLvYwFQAEdRJqYFYBqVoDaUDM02INCUGjcYo9/m4RI+Ld1Riw0Rg96nmf5lTEcq+NYv2f3IRng802vsINBgCBh4Q8ATkn4MARCuKTE4oPGstavcqE++oEhMIwwCARJ8IL2O4HH0ACZscTzqwwld4Bf6HZvfwgKCYlesHJy14VeGHcrP/dz/wVhaPdf6IVcQIW0AcFoAzwzb3M3v25UHlACtdQ1F1mhpkspoIKpaJWrYIrpsUM6uBs+MIQ7aLV5DzHqsoM4yIHn5ZQBgAAGY2uZBXADGAADsAAQYACHfOtRxXTfBXnS/6iNAViACniCkmsEnFCEmhqyM3LMymJnVWcjPZjW+OUeWMfnym4DjeTn/OWzoP/BFvcEhJ5bnEIEQrAV81GESLBCRfgDOmiDbjQDlCGCNYD2CF6BFXCBjeIAE/LJn7QASPYfV3IAYmh3YfB2ue92uGd3YSAGvC+GYjgGvlcGZVgGZ3CGahh8aniGZ8AEGyiw+qn3e79UGd5uV4ZhWLbUAnXlob7UI3ChgveRpRiSsNjb9KB5T4AEljqERhoEOYBwPbiBEAgOTrkBZI5ZCjUAD7CAUVyAAUABtkaaANDeUV3IrspR3HcgNQMDQQDCmq+dmWjMdf43V1X1Def57tmDvv8YD3vmVKAasfzlTXD7ipaaAu+ZhP0Yf+jrrnMsNEogBVwIBl4ghavnAzngsZJpFULIhGgPAh6AgVEBFRlYjOnMV4DYoEFDhQoTHjw4dixZMmXLnEF8Jk0atYrVsGHLpnEbR47zPoIMie2ZGxZFhhAp4sOHkx1FXsKMKRPJkppIbtqsqXNJlps0l9x86fMlz580s9hEAvPnESpOqVyZInUKmTNo3tTh02dQo0mYZAG7BVaTokWDBi1i5IYDBAgHOLhxA2FAgAAA7gKoK0DCgwEeJtQ9MGBAgwYDDlQwfOCAgwCDBQ8w4EAGnUaQvGLCZIlSpEiNFD16pEhRokSFzqL//vOnz57WrenQkSPnzRs4cGTLsX0bzps2vmmnaUO7TfA3Y56U+QOpkiZPnjRlqiS90iRIlylZOhUMmTFjuCwlGtTHDp/ccgRlyhTICxYhOmbMaCEDPgoUIDx0yN9hoIYJ/rN1tFFHAxLYkTchzWOPPfcweI893mATyw02nMTEESsVgYNMMLk0E1I71ZSFiEjhtJNPJwJ1FIo1bVgETVJQwcRTWnQBhVRntCEHH34Y0tUmqAAzzDDBACMLJaEZQolabEHQQA5x3SBYXXblhRcADFAQ2AEBLCDlYo4JtuUBAhQgwAAFFEBYB3JM0okmmVkSZ2eROPJII5+Zdlohp6m2/xprrdkBG26y6VZob8IBV9wbaaCBxhNkTPHEHpCk55wn0U03ySSVWDLKMM800wwyvGBimh92+HEHH4ZkAookebTHBBM70NDCDDbgigILLOQXQn4DGSRBgdt4s42AAWoE4DYgKaiggwzaM8821QASAoUw7PADDj5o22FMO3gr1E8gJrGEFllogUS5PGmxRBLq6vQuiCsqJe5SR0TBRBROaTGFjVNcVccfXEFiCSq3BGlMWLJosogigxQCSA4sVAABXG4AAogbNxhmV11WfuwYmAMAcFhdg9GVsl5pHrYABB04MQgmnWSm2WZzRvKII6XteVpqfQANNKB6yBEbbYTSdv+ob8T5BikZaJThxBNPjIEGHYdk0txzmrxJXSWardIMNtRg00wul4xWSB9+CIK1LK4GwoWMsjJBwww42ACfDLuyEIKv+1ngH4IgeVO44cUee+BHCsZzjTXTVCMtR8OMkYMM4IL7A+bgctgiTEkQAfoSTIwuOhNakM5EF01owbrrRYS+UxIfplhivTcd8S8UU9sIRdVx0NHHH4Uc8ggmqOAiZFitPNfIIH70EUcOHHBQQQ6MAMKI9thz0PGUVlp5WMluPbbYAQUwUAABBSiAvgELKLDAAg1AQMMglXTyySb6d0IJZ6GFphF7OotqgvYnPcAmgXSIA2/YwIbiEKdRwVn/WhoqiKjelAENe7hfc1CBCksx52uneAZGsIEMUeyMT4tAhCRA4So8CMEITeiCFDKkAxrgwG7yYQEIOtDD/RDEP8QK0EVKWBFpPMMZymAIQ5SBjQTdAx32UMYvqniMYgiDF4zIgQ9s8APNbS5cnpMJEcpIBLrRrQlqXGMT0qjGM8rKXO0CUU5IxBQo9I53UxiDGdIgBz1spRCKoMSPEAYMXjAPOpAwRB8WuLEQcAAQkWCEIyiplhzcoHt0+V6V7kIXABzAMCg7zAEMoD71PUACEjAAK9NnAAa4rAN6wAQpSOGJT2iGMzlL2wAJ2Kc/7EEPwhzmAhv4GwoyKmm9seDS/5Qph0FAQmu29MR0LMGJYJDwGbqg0yMOcRZEtAoU6hEDF9agBjB0YQpR+OIXcxifXdnnVwSpQDGokYwq9qIXtdCFLmrhz1rE4hWhKIUqVBELXUBjHvFw0DyOoQt9/sIXvFiFG3JgAxqw8wcr0VyL6uUinyQBdmaEIxqZwMaTvtGkTaAjS0fEkyVI4Ql43J1MpcLHHO1hYIdoBCU0gYpWyKIVH+TaJA7RyDhU9AY3uEQomHqJS1zyBn5ji5SmZNW8fGmUkIkMmihAAQUYYAAPmMD7DNAADdDPCYV4RCU+cTM6dcYRpMmTzwZRwGAKszUIpENvdEMb3iQzacSp4HAEW//BPiyiEpZCRSUoASdMjOIVnLgEZ+7kzUqA4hYvDMMc5sAb4pzhCk5Zp7b0Vh8Q9JA/tfDFM3bxClrYAhawpYUrZmFbVpSCFbSABS56AQ1v3MMf9GjoL4LBiyEBgxI5wMEMUKC5lbDkB07oqLhSlATQjbSMshqpG0+qXSZcl6U7GZGIlnCEqaGXd7yr2hvo0JrhKSISjn0TdCqxyD04cgxAcEMoQoE9pkYiqVKlXpOkJICT0SWUdhklyhZAFwU8IH0FMIAFHnAAB28gwxOgHwRykAhGxAk7lIivIz6jiEOYBmK+BKYeVIPXOLS3DrnRTRvQgCjfMOoMSUtDBoWTQTn/HII5nkAFJhy7iU5sYhO5xERjj9QIUAQ1E4iYwxrwkCo75OYNajDDGcxAhXbCJz7xBKIteGEMZMDCtmqWBZvF0gpS/LQVvOCFNLzhj3/QYxvJsEVQxeKJPdAg0DQAF3ShW4QdaGhDOLlJuZiQ3UebsQjXXReL1jXpcrl0vOWtyRGkFoUoQOHTUXACqW1EhjTEgQ3t3UMgQaMpSDzCLH2ISw5yoAd/riUEbnCExjCZSepVzyBbHUxh8IJgyATAABJgACsHcBAHdOkBIJAABh5g1gaEAAg5AIQj4mQJOv1PNKTpWS9/Ccw9zIYOdpBxlnG8tAii4dQ1JkNV0DCFM5Th/w3QbI4mkoyJTfCbmtMJTSZkodlX4cHKgvCDH/ggYzj4Rg1nqMI6cWBxu+lKP2xGBTKG8QlUuEkT1LEOIg4xMEEIohGRKIY38MEPe2xDF712wkqY2wIUzCBbhfaBSzjX0RNhl6RthPSlw7uEIpiLji4t0aY5PbVPz3TUQACC1HxXBiBQjQwZZEMcWszwQRhiEHQQprbdUIpYrKV6HLhBXKAEyerZwAmJGfbH7nLsuiBkAelbgAUcMPcNXIAB7SvAASAgAxmE4AZAALElckmJSYRmNChOxCF6mRpgLtC9657NMd89WHpXxSqNesJU0rCHxM6MFJ1w03MqkR5MYSKzt//IBCHwgHIeGWLhfNh8HSCuBtFC4Yu0msGu8mMGM/gACrLwgwZswMMOZPgC0nfABC7gARy44Rfe4MfLt1GMYfBiDHubQa1mAIIN7IDm0BXjiYLS/kvXRAtzlB2lje4undANKDwhUYgybd4niBrUBZ90kRrv2IDFrQSpOYFw0EFWnEX06AEQjAF/lYIecEAIsIAGAJsTCFgmWU6TFMZiDIZeJJvI2IUAPED8KMAAVBhChFLgMIAAyOAAWMzaAYJSAcIlYIIObsb/fIaJVV5d+RJ+6YFrGI0y/cYypYHTnIFVpEEBTsXVTIImrB7NvF50RIcmyJ6rEAIhIIIh+IHD5N7/8+ze7uWGxFWBU0DB8OkKC0yAQUDAD4DCE0CAQfiHKkkABVRfCsDAGgCCMFgDP/zDPWxDRSSDL8TBAdIHCnQAS6gftzDBz3lUidQEpbFUeF3XS8BfTdBNSuyfTmRBF4gieUkBjAQgHn2RIyqgDODKAUrNExwfHNABHGxQIWyQflFgtbAAE7CADPyaD3xB5dxADsRBCLQF/XDA9GxJyqAMyAhAWGFJhAlGBVzAAxzYybQFBMTF2tmaNSlZkekSAH1GEOqJz6wGq/0Jls3GbCjNYKGBVZDB7kwBDkDh07QBNFXCkXGN66UHdHjCLQCklCECJDSCIRgCQSqCQT6P8DRc/++1gcSZQRVojt3sigWgQIbNgBzcgh2wQH3QQAmQQAqkwAeQAA9wwR0wAsvlAz/cwzxkAzYogzQMwx48wRmoHz2S2kpgzkxMolEoxaTF3/y5y6TJXxfI31ACJScyQdOJiCiOIokcgSmOVvBBHQHS3A/MFFU0ihOMARsEjyAJUCFgUg44wiWMAQRoAAj0jdyhZa/IgBsUY5M0yQ1oTBxoEieBz11AGAM8AJfcYZlMGARA0pNQT7a5QSFwApz4T87cyZ2cmBCixp8ITaCw43BEUAZV0DueAaQ8QRVcQehJ0BkMQpvEWSJZCsJoFiJ4YeTdiRgSUB/wgcPZxpZdAcVpS/+t2Af57YAaaI4g3IIgzEARzIAOwIAL6EAKmAAPhIEfFIJKsuQ8WIOxbEMz6METQI0TWJwC8pwYfVT7jQu8gIj8iadOzJ94zlG5iKcaNZ1OdIH/IYEWUEEAghqoBZ8COgFW1hRVlMHUjAEcbMVOmcYN3gAjXIIbVMAG0ADi+cCuzEAJ7AfMvMH0tAVcaAytsQXJ5AUJUkleIAABBABfRNg1Igb15IAxUg/bSVLN9GDOMOa4kdvPrM2fxMY6DgejlEEGvSOk+AsUNGGP9mgVqIFydMJPyYIHOUcrhMUtSIJ1VAcA2YnDHELYpYZsbtmWUcEa6tAMXAEY7AB0HcJv7sD/EeAAE3ApCsBAE9jBIAACywXXPdDDNGjDOmSDLoxBnT4BzeEkzb1EGfEkiqxn/5FXoNKOHI2nubDR/jGl/8mRFBxBSbETTNyndE0NVUCKE0wBHQxMIjxCIjgCJjiCGzBCgHEAC3TBDthAGfgADcgBDXQAr2hAqwLbgGJPRWHMDXYMXcigDG4oAAiAAkAYApyMA7QF27HFiQJCIUSCit7MYooGXdEVnwwM9ADKjLJjjUlQo5zBjk7B8R0faHYrHSjCjwgVKpACki6PJEwCpnBGdViHnTxmlBKQQ8pBG4TWl1kcmYLBD6RBF6SBDygCMAiCD9AGGMhBEXSBHKQpIyQD/xTdwzpEpzU4AyAAQRyMgRMAgQ/kqRMcwRGEzqJ1p/4hKu00pSiCyIg4pVGKJ8quzhrt38kK6ojIXymWFBN80cZ22hc5wb88TbaagR5AjKZGgsHggi28QgXKgMBSnRxAAQ5oQXPdXAmUAAoMhK5dQiVV6PZUVPcIRpkEAAHIoJX06jUSBv08yYTaYCJYgr/ZjLeF21y5KGRCTzruAWUq4aJkplSQAbeaQb2hwRWYwdTEQSHQ0pG1giHdAjVxDZPlEnW8WqxJnpT6wR7UwbrBwZZVAanNgSAQAttAQskVAigMQyVYhuttypHagjQw7DVEQzVQgy64wQRWLM3R1NTY7P8RvJRSjAso+t/ItqegnmwXoFNRFiUb8e5TDmpNlGLyNmpJ2Wykkp5W0qsf1SJoRMInIIwv+MIw2IIlKIIe1GkcOEEVoIHd0IALuIAKmIAFdMAFxkEkVK32QBX2ZEwc3IADnI8ArI+HTsmBiW1hdFj31CDGJIJzINk31ozN/A9ovC1qnIUfnKMdTGu1LpNvlAFVNCG9UWq22oh+AcEfbEa5PkcriJNzcE0Ju550aIqTjmPYOTDmQZy9TYELQZnBASRAAkMzFInh3gIuBAk2HIibasMSIYPEVCzv7MDpzFTt3u5RDGooGm+gaprJiiIYoBPK0ggb/e7x1g4SJG8pLu//U1jIxsqUdOlnGiyKHOQUxDhC0HYCwgSDkJyZMaSCxMQBGvgAHdiAc+2A+dYA1PbN2rXvQJVC/GbMJJWo/Z5JrqIPsFIJmHAAEMglBNAlsrbCJ3hCkmEyJitmZwQQ5Q2QlNoVa0BwBB9NbwCHj4Je6M3UGEyBBOpBIUxCI+wBq2iNJZPw1ogcCj9ek54YKDdkbhBHktYwMBDzISHDMwwDMAQDLsyCLSSMD8+Dg3hDMgzDLFisG7DBGECBo+1AE1zpv0yBFJTs8TqxUwqq7gbq75rnyqqROWvxFkelF38xFcjzeeEspZoxTqlGIVASJnBCK+DCGxdDMiCDqAxDKThC/x9IgRxgLK0MQQ+YbwvIh/OxwLZxwiuowlNpD6+9biY1wNbir/7u6gBUgDFyGF2GK/Nc8pF1AiccmQH3oA9KHvFA7jkGDaDgRhxUawX5aI8iH9U5QVWQQcWygVQcAtfUEil8wjRZytYwWWP1oLtGKeTygeTKQTGjpg3zAjEfs8LIljP38IHYAz1kwyEqAg6QARBU8BfJilFKwVSEsxRsGlIgXYioM7qMbCiWs8vSThKoM4088Z/qhPLaLBNIQczW7n3mrFb2lXtl6hpzwie4Qi4Ew5kRNEFzhy8wQiLaAMaCQRhwQQuYLw2ogZjiQDDqwSWoQn/1V8YklQ3IgCgNgP+uWtWCmY/FHKbBfBCS5c8nfEL+aHKIMWsjLALl9TJqOHALn2NrFM0RIlOODrUPYJ0TxFQV/O0UOEEXDEJzkMIpKDUqWPIHkSsJd01mjNyTNgK8Ps8f8MGQfVBTP4cnBJUrdAcrRDYqpEItSMOyfIQ3OIMqLNcXCPjJdrESGPiBK8EWILiCJ7iCb8EWGKXrlGdRjuISIPiBL8EWZAGE5/WgmifqgE4SyB/tuN/tvMgRvMQR3FtmrtrAFAKnJispwAIvVHYxdAcyIANDoJkj6EEOdIB9pMAFmMAFWAAN9KIG4EDf6FpZDnKFYtLGzF1VOYZWQQZuJwIleJBS+7ZvF7D/2jpezjQrXdmVufXJa8yoMh0Ko0CNjtZpKnfZvaFBGvxBJXjQT9V5nNlyyOWypkAecR/CInjTetcBHbArQT4Ck2oKJgStKPhCMMBC2oqCKjgDf0uLMzjCDciAgD+4gH/BgzP4hYO6pz+4gZdi66wR6Yh4/G0aqBu4qIu6/5mnGjmaSW1a+8GETiBB7Vpwo+RIEbr4h8X4jAfDG3fHMeA4jhtDMFgCEITABoBAC5SAB5TADqDAEbBAGbAi4uma+85qRY3BDRzjR6OM+YRSNrbFtjHCj7iCKZACu4/Clvv2Sn+jcNOJXPVyuV3en+DXoCChjTrNVNDbBTfKVSiHT935/0+tQi39Ni4/deMuQqypt8M9jOQdOp/jTyucAiekgi90HC/Uwi9MgzcoiEsmw8awgKZvuquz+oGPusorwWGv0YSP+Ii4es27eu8ixYfLXxqVF4p4lE0Ugc2+NcDb2G24l/AMQiIE7Sesgmztgi8IwzDY+BUNgzFUMyMAQQfIQAs8OxjMABOgNQ6Ulg9A0hjwc8ZoDJOY+2IUhv8WJm5LEpzNginQvcLDO5cXMJzICZiPY4pBjDn6CWvghtHIhhJCzWbibSrTW2bawSN0ULmOa1JruSfoOQoz6ZMm5CDwgQe1QucDJC7MGTEHQ6MHwy4MwzE/AzNMwzr4Q0tmQy1g+v/Jc/rsi/rKb0GnK0Gn1744ywrrpOzviqLNCz+E9655VvHq9L5gr0iKb6wUgLOpxfkbFM0fDQ9PzQwmiMIr2EKjV30xYFHUa68lUOxFzcFng0F8XsE5+QEOhICHFQLGqAUk1WEdVoxcIuOJcsAEOsIqzIIruEJSA4QpUp8IDiRIsNMmhZgwWaIUKdIkSI8aKTqUqNChQ4YKDfrz8U+fPXZIypFDh46cN2/apEmDBs0ZmWfIkJlSsw0cMmkGPXqkCZUnUqhQkTJ61JOnT540acpUqdKkqBMbHRrEBxiwYVu3Ggu2FRlXY8OCfUUmLVs5fv7mUQOUI0SIL3Ppzt1yF+//XSl1+drVu6SJFsFaunQZrCVLlsJ5Gd/lWxgyZDCTwRhu0iRx5iVLkGxekoUzEiRHjjBhEoUKlSpPnkC5iabNmzJt6PwZpOgRJUWRMIk6RYtXMGHDixUTRnaYKUqF2kyew2SNkTVr7rCQ4WaTorhuxoS4EYJDBQ4cIJQvP56D9xBu9HAKBowXrlGlRo0yJfBo/oMJNzGk9J+SSXxShEACNTJkEI8SDEkkkkZKaaU2JGTppTIsnOKlM9Ig44w6+FikkUk8acUToojKr6iBOtEEE6hYnEoRj7gaxpgabbQRGWPCIquYY5Kxhht/7vGGmBzg4sDCvvzKa64klcRLCi0C/zuMysQWc0zJx7qYLDLJKmuiCysLA020zjgrojPSfvgBNdVYa22Km8yAggza9vgjIzx3s6STU2DxZThiiiuuGWSQAWYSOqYQ5Ao7rAhjDj6si8OSQWQIoQINOLiBU07Dq8A89G4wEghAWNmqrFTosw+//I76RMWFGGqxEkp88qmRRhaxCMEEfQ1pj2CDTUmlN0yiECY0pohpCpmgcCIKOeqww5BKQGnFxBSNOnGpTVhsCqpJGkHwRh2fMdRQHWvMEcdksonnHnuwuQSISytAw8J8nVRS3yf1ovKwLgvL8gss7dqSMsq8FHhMz0QrAuI012QzNSqgeNaJ1i72wbUzjP/dow869MAzkUgs2QQ4X74y5phimnm5GWNscaQPJ8yoAg4/oAjBBkAseUMGGTrQoAIWbpABiDG+Gw+CTb3LgT2feZkRFlZMsc+oT+47Cj+BEFqov4b+g+jWXTfiqCOPGOyD7QdNoiOON1xyCd8yaoLpCRx+gISQHRqVJJNsBUfllKz5e7ESSGJEN0dkqEHm5WEMlbzxZooxZpls5rFnnmXccMKGDu7Vt1+CSa8LSs82C5hLyLTsouAt6ios4doVFqzLxJYIs8zVj5i4TYt/8MGJjFmjAQfilzUWjTfo6GOQRB6J5BRXbAmORsgL3R4ZXkZhZAwb3vAh6EQoecKGFkD/8KADGnwIAQcnjLxhvFFHdQMQQCIZRSsajckFFoXLzykIaAoCruIUq1iF1z6RkITMChP/mYSAKmIRjVjlV2xj0INQEoeXpKElsEmWTchghh+kZg6I2IEaEJGUwSnQRFn7hLcYMokYvQcYvtAhL2bBC1vM4haucMUscFGKUPziF6HQRTW8MY956AIQcgCD/CqUL5iUgWB82UtfwrQ63EFGMZGR3ey6ILuBzaUyCkNYwhgWJjGR6TNLSIIUKlbHilUBCqyBwhjGEKcxsCEOKLnTIAqRiN1QAhOdMMUscvGVYVwOGcl42TNiJgr20I8FCbKBBSzwAAdMAAU/YAHRbNCp//Xk4H5uYEQkXhEMlenQFrBYhVG6dh9bbs1VM+yPJXg5tkhQxCKFEKav1BYSYAnLDsSK20pYwsyYoCENarjCFawwB0FcExF+mIQmRiSLVrRiFUQpIKyKwpTEDaIOm+Clf6SCCekp4g/5YwQjLhGLYiSjGtnQHDYioYc7TDEHpMtXFrW4r4JJwTODaaPAUPcF2NHFdhFt3ULhuJki/M40VGCCHanwhOJp7GKuIUMZoBkHPQyyELhBpCdOwUiV0SgZMV2Gj4yxC0uGQAaNGAQLcNCCChStCTtgAg5kYCRUugGpSXVDITjRyFf6MICjgJVS7lPAqpKiVQZRSNgcAqBfLv/iEMK8YDFBwjaRjGRYcojDsSIkoZZE8wo/kIQg7kCdOwhimybClomqCsNPaKISOq0DgTLyCEQQAhF2IMMgAIFUQDBCF8qAhjWy4Q1trGMexQBESpYgv5FaqCZ85GNNSEsGPvLLSVtAqBcJQzsuhdF1sTMYRFsn0dx9RjGg0Z2ZkHDRI2QsCsG145vy6Jo45fEJfESDHE5qG0LiphKa+AQ4exgMlvkIu2PhBScAcYlEhEBRHehAEYhABDkkT2RuyEH+kipPWnxlOL7IBS1YcQqpzrATWC0gKQhYQFaZgiBSbYglINLLAN1KVxohJkg2KKw9oARCcmgJM2MjTSbMwQ//fiDEHO7gCWBEpUR7RcVeCegKoniiEofgQxz8gAhIIOKwLh6EHvRAz1jg0xreuIY1rsENbujzEnqQIvFygK/Qjla0SRZtlgyaBYC5tktjbExf2Hi71gosM6BRncOKIAUpXKyOwQ0unPxI2j7G6QlTKIPz7qSHPuCpEZCIbiJTcT1hDKo4YzGGcYzxCvYAgQU0AEN51UCDNOhhqRBhRP4e292vuNIXu6BF1eyLkE+MAqu27O8pBGLLo4yCP1yV4K0mQhGNpG1BazOrsFICIWauhAxqUAMYECsIPAgiE61ARIgqIZShYEuBpnBFOFFsiDq8ARGBEASMw7rKWPwCGtuA/xc9uHENcIDjG+AohzeKoQcPdqF4RbbbkY+s5CQP9AtJwlLuYAvbKzFGtnlZ45S+uKU26hbfqiuCFrwsGDpq9AemIY0WpmDcOB0c4WOoEx3eEMg+FBI3jYjEJThRCljswhdiGYag7okMXXBCD3Y7ggxo4AQf6AEQ7RFGKC7R8kgsuhR7duUu5jvswlka07TcdH9vucCjPHCXD3kEgQZxiEUsgpinJmaq24aSkzhdmXB4gxoyIYnDZljDL17ENl1IFAQKMSiUGEQc2ECIDAvTEa8gBjW24cR7+IMf/HgHOsbxDnCMQxv8dEMZwPAEHxiJtPgSrWnNTfgxDDS1Y2Q3GP/d3Zi7KKExTm4CGJrgRTaCkfGKwa1mkODlKAmmYhulgucJjnDTi/YmbBiDG9gwsgQlInqOmDgn/NTIrrCsGJQ8Fy8sQQcn4MAGUJPnK37R8lCEIhKPtcVYXJmLWPq1Ew28dH30u/OdDzvYnVhnLwdEoEX4ZFcWvCCqU33MODj4wWTXAxnsUGs8ZNMO2JxEJgzB9aIQcBazINEj/vCGMaCcEUKBGKSh7ezhHuLlAONFHuxBHuSBG+JhHpTBDb5AC8Dg70bFtD5rDFjD8MwtyZpESRYv8xAjL5TABLfABFPwLiTvMi5DMCZqTHIry7pg8zRDCjSG3+qISrqAo1LjYqL/oAqqQDXMAAiKEJBoLOXyJxFk72R+gxe0QkeS4RmmsFC6hxMSQb0AwRHo6Rdiwfg4gREKAROsK75qgRYQKGs2oRM4YfpyzoA2TYEQSIFYgQ4XSPoaKGygIlwkwtTET8GWbm3Q78EgjOHsQA0IQRICARGWbdlgzA8gYZu2pRXyrxWygw7I4AligRieQXPsgR74QR3I4R/+QUg4x4lOcRu2QRWAQAmWgAl8oAhzwLS+gAy+4AmkYAy+IBdrMRd7URcJyqEWqjA8QzFKcAuy4Bg3YwYvgwlccHewrDCiBDK0YAkQgxqtseBcIwc1igk+D3dEL/Q2KgqegAqmwGKqoAiN/9AN4iAOkIoOACH2IqETRmEVrse6kGEKqRBdhmEW5qnlSqEWVMGIWI4RLOEUaEQ4JK2+DII/OCH6ck7n4lCBDmgV6DAVdi5W+iO6wgUSOhISju6Cxm/pfgVkzmoQ92Ba7MCaEDGbMuwOCCETUIzrhkIWbqEVKmEQ2OAJgOAUGxAf/AEf4m4U84Ee5AECnWgb9OkZAEHhSAi09gWLCqYusCgq6WLKrNIqHQ8vWvEZN6MwrNGLCmOaxnIsweAKqCBgpuAK1HIKqkAL3BItr4AHBQPhkAu5+s0wPs/0bqK0zKAM2AAwA5Md6SBYSMaQIoESTmYUXAEXXkpHIglmJqcXSv+h5RzhEo7vEhbNEVwhR1yJF87w5jpBNEWzIDLNgBaorySyIi3yIrdGVgxsbEDSKpyLbUQmkPQAbuAmDtJtDJwAE9mgDthA1nYABcCgFYDhFiSBEJaTEG5hGCChEVzEE2oSFSZhEN4ACqJAHuiBO90BHurBHeLOH0rRKJ3IG7KBGZLBFkaLhEjrSYARK/tCyrSSMcIoMw7DNFqwCchymjiK36RgCoIrCFMjCM2AP6cpCNsyO58gCqBg9KigC+SyMPbSj9jzLwMzMFeCHV0P4qbHEjDhE2oP4x4pCpMBGY7hGE60GHpBFYyP5RyBEzKu+ehrINRwq9TwILgmgXZONVP/gQ5Z4SL7iyAwIWzE5iEmqBFMTZgyQm2Kyaxwkw5iw3neoA5kTQ0soAUy4RZuwcUk4cUqIRMW0RNAYf5aQRY8wRDogA2q4AcaEB3QoRzEoRzK4QA90Ty34TyxwRlq4RUK4QYOjwy6gC+ngC/wIosMZowKlT4dL8u0bDBMoxkvo2L6swcr5k3I7CamwN8I4yyDcECDhwqsoArI8mY81VPZE0OThW5gIg1M6s18ZQkRExM44WpewRYc80SxC0Vjyjh6YTiEIdLkixZeIRVEgRMGjJc+VA1Jsz5GgYBSAVqh9UdZIQ7rcEcFCGzU6UP9AyoOjCIeAawMoVc+4s3+AGQe/4wPHowN4KAKzGADJmAIJMETAEcQECvFRETOPEFENAES+qANzCAKcOAd2qEd5IEdykEbrmEevCEVt0FPW+YXiOEXaoETjIQWKwPhHire4NMu/EUrUxBktUx3kkAwXBFSm7GOzrJSU+PgLsb0/tPLzNFUhXBlZ7Zdb8YMyABD2UBV5wYmpNSkQGZkCokRZA8TLqE3UoEWRpTjUNRpY4pXJVYXdiGW6ksUjjaCTIYhHNIh57FZT6EUwjZaoXXnbAmBtgYPCaJII8irfqlAdAVB7OBO9oCQ9MD/fODQVM/vfmACJuCaEMvqJMEPFMEQEEFcCBcS+HUQ7KANpmBN4CEdxv+hHLihG7RBn7IBG56hGHRBFUQBiYTBuiIBfqZALBF0CrZItlBntoBxUUEWZEMjMZCAZDejvMoLUleWo1rWZbPR36Tgt8TMZj21jnZ3CpBM4QTKQqBpbmajDQDTeXLzTgChkBxB9mZPaXkBUIiB44rDaY9BYnshFnShaoqVE5L1IbR2VrcqwLBqPkzhIkvhat5QgLDKIGaIIZI1gnyiIwwJI1IO5YIFNgbBEIKlHbljHf9Iqcx1CuTgFjKBb2rN6hAhgrtUExphD+QADZzgB6qAHbZTHtbBcrEBG5ZBGGLhFWABF3gBXYwBF8YgaARDZYMQCqTgKrfSMQyVdRvDdUH/tnc4IwnkKAlqt3bBEXd9MKSOuDU8jzSKAFqeoAraUkHxCI/KseBOrykFKll4lg3SQPXYoHkvtIvX0c0AASMSoWg/NERVoRZ8VXsFxWmL4Rd0IRZUQRXIV2wQ05e2lUgV4tLuo31TwRRWRb8YSGs64X4bYgsLCdHiYPXGAAiMalSAwA1AIhEOQREmITGTlZc2wU+GKCuAwRNabK4W8RGzCXCyadkgYRDkIA3MMTWyIRWzoRqkIT2TwTiGgyteJiwagQNsQAOihGWPi4ZxOHZAVnYgT3ZWV1G30gQhxpmd2Uw4A4iTIIiFmAhIgzRuV6PqSBzbBImRa4mZ2KOMqzWc/6C4zDnN0qyP1vnwxk1nd3Zn/whDdRYW+UiMAcGklJAJOSEUAJKNewRFpVYgjbUh3Pb7fAJALOEStpUTOEEUpi9sS0FV7KtZpWohSKF8I0GYGos9fCIRMMIRusoSGloUoBUWZgEWXKEVXOEWeMGlXzorhkErkPMW0NQP4GANOMwOrM4TMgE5BWGuBMEP6qANzqAtqQAHRNgZ4PgXhuNzL6crwuJMfUC8NOAIomR3n+DxEvULdjiZ6eIEN3ZJHm+HleCZcUuak8CZrfmasXlNTlb0IDU7x4w1nOC4ngCbf6t4jGev67qvb5A1kszw3pkNCBueATPJcuCRk0bhGHkdTf8qHke6FF5hF4SBGHLEOHYhFThhFHgpEhwBI3xFZHaDeh1CoWfVIUNBFERBbKMVSCnakC9hFHw0FS5ztYVoFn4o/4gIF3JBh3TIM3UohX1huF8aFz75k29BE/xAEAyxCVygCVJolLMCxpbTD1iZDKggCn5gBpABWH3BV4sDH3XZK/QvKA4BE4snpEzPmB0jrLEEmds7mQ2VrMvadbPsTNaaCWx3SrpECyrGLDfqCoJrg1HjB6AAeWgAeXCAwWcgaGyABSJcBiLcOoaGBTogLqxDwmXABmzgwTs8+GyAwYFvxBkcxE/8wXMA+Dg8+HLgjyB7CUfaR1WhajIz5eIgaYD/IA7KwAk4IAeUoDy+AH+kl3onruUo7vhYO2zpGEhZ4RXoEBZe4RXoWMpfIRZigRauvMoF8hVogcpVYcqFoalpjoiAaBZkwZtGrBOmgv7UwA/uIA/wIBDkfA7mIA8I4Q4QoRUkAQ8IQRD4QMLaQA3Y9AcwTmUec5LCAhjWXFwnqA+mwKM4xqOMJ80+Ft7ijb6ZmZkhz75TUHV665nJiwgi9SuxGZgptWLEjE2CCwrWxAcmpnhwYAeK4Ad2wNaTp8R9wAdMvMNLPAf+DgdUnHiAT8RFHPhYIATES9k/RTw6gNnFAz1wysXj4LFmr6EZwYDd4JFdHOUAQcjbMQ4KgRE2/0EU5kOiq9zK092E132OTZiO3x3e413eOVcX6r0XeuEXjEMXbMEWkBOeDEERMgwOgBAOzMAKHiUMlm0OxKDPA4HhAyET/GAN8ADr/ADQW0INqGBNhkNHyHsYcIEUKvgQsim6FuEMdF3XJ53StdrxkLnlIU8+sQQFT9CrZ14JdCe/IcbWd0CIr1qJrxror/q/U8MMADYIz2At46QmZIIMJsNAq0AmrsBBzwAKXt0HrkBvfgcHZkBvRNycTQ7FJ3zCiYZoMoVozMM8GqABIEDtD8DtIaACwONPq/0SlJzlHNoUfMNHU3oWWAGlYYEW5mu+TNjKr9zwDf/dSwHeI1rx6f/4ynXh3pEoYolhV5VBGp5BGqgh86khZnQhF3BhS/3gBwZtDnI6D8JgCMJgDZjACOzczh0+D+ZAEeNcEuJ8DhCLD+zg4tPgDLb7Bx7TUIChJltBIiBh2eIcERYBDujE73BA5S+VPuV7q7l6Scba5k+wvhtGNNSamoe4vHw+SpbYd33+dwjU6HOWLzVkVdWg6A3UDJCewJPnB+IHB2hgwjWcwsWLwyc82cULPSoAIBpU4MAhBMEQNmTYyPHlixs9EAElcmSJ06hSpVTV2qWrVq+OtXT1evWqlsmOsVLWSqlKZSxdKWPqmjmzV69fOH8R20ms2LFjyZxVG4otW9FsSK3/KV2azRq2atSeCfOVCxevVm1ouFhjJAwPIVyEiBESpgcXPITChDEyh4sYQaAQ4cGTZ86aOXgE+bEjpw0aM1F+/EA2jBcqT5AeQcrUKNMkQYT0IvJjhgoUH04wO3HypPMTKUpCi96yRXRo0qQbom74BfVq16RNy1aSpfaSJUiSLNHNhIhv30d84PBxpPgRHDuK7MCB3IcN5kCAQOHMfLiP604SysCh3QYHFh3CD2ShoYOGChU6gEdfQUMIGfBz5BgTR8+fQvgdUbK06ZMpV67MMgsuBPLCyy67+OLLVArqgmCCCvpi00cfidSRSBN+9MtNOu3k0zHKLAPNNNMolc02/97Mo6KKRmHzlIsqxqNiittso4021+R4jTbWZDOUVLXwAsxVdbTgQQ9zYEEXF0aIEQgWYXDBxRx2hbFGGHfMIUged60RSB556EUIH3XA0YYZVQj2QyuaQHKIIoRAQggimVQiiCBw3OGHH2pEUQUQmOHg2RRTfAbabIhu0Zpqr63GGmyQwtbFpLVloYUWRSTxm29F+ECDQszRYAMNO+wwAwsJsQAfqgrBFx5BHAwUQgcVQFBrA7baimsIvL7nxBtsvNFHIo80Egklm6Diiiyz8IKLL8AEE8www0xLrbTTYoutMNwKkxNOxGCYYU7e8kTMTyFCE02P1WST4ooq2nPPvP/01luvPSpugxRS2sQj7z324DtPPOusg0455RysDVLUFPNRMET+4EILH8zxgpNG1ICFEUIYMYQRUlKZRxNbrmFyXXXNQUhkZJqJppqIwImIJHfOCYkgYIBxhySE3GHFD1T8AAWgnUEBhRRH6IZooq1F6ihrTUMKdWyUZoFbEVhjXWqpNOAgAwtgg1ee2Bqcx97Z6OEqqw1AlMEGGW7QoccehTxyLCWYkHJKgLY8G6GC2Pqi7eDSdmv44dya6+FPIILojLrTVGPiNtwMHPCKAd/jz+ac18v556B/Pm+++3pDjz/8bA7wivLIww7C8sxjVDI2+XLVIDb8UEMJFwjBAw//OpCgwxA6cIFFx13NNQcMYWyppfJU+qGXH2WeWQUUgiGyMmQz+7HyHVlKIkkYdggWtHM+FA2FcVKA1v77pZnmhBRTlDFFQ2WUATX+ZHzRxf7xS038hGOc63DHBqkKD3g6YBD0wIoDHTgIfGywmTLEIQ59GEQjHrGfT6yCWbdwFi6iBQxgXItw1UKct8i1Qg6R6xfeEsbiQKSMx0WjGkWpEbx2iLl/cY4fQKTX5oBIRCD+4x/+OKISl8jEJfoDX/pqSjfkwQ8l+uMe8JIXPWI3D284Y0MKwoUmxhCFGVzgAhmQkhFMUAI/3MEFUsKDGOSYBzyEIRBfWgMoMlFHLSFC/0+CqEP10IS9H0iCTofMRCYEgUhG8owQP2gBfFb1tbBNEoETRCACw6aqSYJtkqtiIK/CNisGRhBWZmMPBFbJSlYO5IEyAMIY6LOHQRSCEZGwBCY4wQlRmGIVrIBFgGbRN1xUhRe5SKYyc0ELWzjzmbYwyUpiIU1qmoSaLxHJt3bCOGUoAxrglFyPTuSNdcSjdfRIpzrtoc53yOMd+YhnPOtRj3wQ8YhGRGISm8jPIvrzn1XMRzesQaKCcsMf+MjHP+qxji5qgxs8sgaLiNELwc2iEXPpQQqM0AMjmExLc8oEHm4BibvgARFfwgIXAjGXW9wCD1rSiyAG4YeWqcEML//7ASQgIT5CiA8R2gMqUPVCgxmk6munsqQnOwlKToKNV6vqlVSnGgKm3uCqN1BI+mb5ELn9IRGK4KAuMdGJUZDCFKdYBYAENAtYNNOZ17QmNWkRE5fUlZotUQlNbJKTGdJQRNAQZ4+0gSJvGNac6bTHOtjBjna8853vcMc74FEPeOQDH/XAbELlqVAldlYfoPUnaO35jyqatrSoBeg/9eHPfKzjGgUd0TXqcc97yKMbEFWKNuaxjWPgZBi2OMQPeNAWKTXBSoJohVwQEYY8tAIZ45tDysRAJSoRYk95kd4gaGpTnKbJkJLgqSQyIdRAaM+niJiDUTV5QE26tztZnWT/VSuZSU3KZzNjsCAdAAGIQiQiEgC+xCV6KYpTpBVAbs0FW3ExC1rQIhckcbCEJUzMZ9aCJKrIMEnuqlcMgYub6AIniZayMG2UEx2MbZ1k8RFZd7gDHvrABzwo22IXw8Md6sgxPNQx43a4sx7yqIc9/BFkegg5H0PGx2aVrGR5LhGIrI0yP6QsZdWK1p9PHGhBp3GNcgARHvggcuu4saNszEMZ3AoGLhxhAxewRQxiCMMQrKSyNTRhDkwAgxok4Yk7wBQPXxKDEVI2hyzhwXuLGMQf9lCmm14haDod7yFnJlSU7jEPYBAMEHJwnfQhsDqdjo4sx+AGN1zQPoMAq7HG/9oftK5Cra6ABTEJRKBcSFMXtobFK2hRTWlO8yQgCYlNaFITvuJEhh+i4TejEbnImQgpNuJGN3DLjWonDB3YRtg40nGOdJCDHOEIxzl2nONyq+Mc6M6xPmBsbtCC1h31pGc9NEcPJNvbHvnY5z84G88mwtjdAA94aK2s2ivGI6LVvsY4SmvEhL5jR9qohjKIIQxk8IISMhhux8TChTWAYQ0uCEMTRn5nnxUaTGDCSx4IkRc7+PnQhEg0mRptBitA2qfkxWN5V5YJml3BDG+QG0Tu419jUaISmPAEKUiBila4wpnGNJBVDGQ721HdQA/K+i5sYWti9yIkFsKQuFzYof8PefNx6hLnjRZmWBnNg17pzIeRgyxvytajHe1Ihzv0/uJwkAPdgE/HOMwxeHOkIx3qMMe3z/Htv6vj8DZ+8YxhTPkZLznfSEQiv+O5uc1vPqH8DL1nnbzvy7L4HYdvBzrW4Y2168gd62YtP/BRjmpbY+I9CYYlbACCHsQgBjxokhF6DjLmdkVL0lvZGgA9VMjkoefI954h/PCHOsgBDjetQmB+MKeV/RSlhMhDIA6Jh0y0wqW3KKH6o6Utarn//YSTli9+oaCKfgsnGSK7DHvyk2SEyBnMJjlI8S48FC/1wm+oQ3ClZU9T1oBVhE8OOHDrNmOS9Q6od3h892J7lw7/NyZ5k9eBHzh5ANdZocd5/mCCoSM6T2RvRtaC9VBvFuhiLgZ5M5gOCFMO5mAOtdcN3gBR3VAOP8iARAQP5dB6y6ATxxAMlzAGIIABHyAEwCcEUjgH6TUHIsUWYLIGd7BIeHAXeIQWiJAHh7QlhzZTNQUH15d92xcGVMJ8eTQXJmMygmBCJeR+2yIM7wd/0jIM+ydD3eIhxZBs3iQi0SANhmiI1FAN21CA8xAwjuiInqM5kvg5oedPR5REmJh5BHdlVpaClCiE+dRvTyZwsldEo/U5nGWBrbOK8lAwPzht2tAN1yCL3RCLsVgO43CDuriLCIN32MZ6hvWD7BBZ+PAP/8W4b+ygDdPgW8WADKkABJEkARhAAjwwF1PCBdoTFm4hBj2nFnMQBjClJVQyXuL3JTB1B4bAXWiIfTUHaWwYCHDWXHV2JUbQFWFQCelXQoXDLTC0E2mGLew3DMnQDM3wDNJADdSQQ4XFiDyUOaFTRFekOT+EOhSpT5wjehDpiUNEkamziT/ERBq5T/fkWVakif+ED0DEZGAGD9h2MEA4bS+pIzKZI9NWkzZZk7zYi3jXDgaDba7DDvLQg9xQMOtgZO2Qb/nmD/TQRdVwkNSADJHgAyhwARRAAVxwAkKgUmixFoPGlVHiMT3wUcpzJ+W4ctOTjnzAB3SQhu1oNHMhCf9yRBcohQcrJSViAAZXwAeI4AmyEAwD+RPL4AzKUAzM0AtpJjiCIwzNcBQ1YljZQFiGdVinkw7sYA/cUCLRwGzToA30gA75IG+kFWNLeU7q9IL5cA8sKA+OmE6g6XnuxIrotEXuNJv4QIqjlVDHCIqkd0QkyHCpk4KTeILxpnrokHAzmSO82JLKuZzosJM+ZoE7qYqsyFjqtEXpdA/qRDBtx07ykE7yUJz2EA9NMQ3PkAzHwAuckAhsMAMkMAInAGcxUI9f2SRzYBaCFgiEgBciMwd8Jgh/9iXmpT3p+Ad0UCbY92hUEAVQAI7pNSdzUY9OImhrQQM/QARyoAesoC//2FAj22AizPCPfyMMzFAU73JwD8UN3tANzYmS8EYPsLVl1tAN9lAPnYd5Cwgw9LCa9GAvOPqI+IZv72Rk+JZv8iZvFtianOebRQRju2ljYNZkNZqU8nR3B0OLNzltxymTaxeLPzgO6OCl4lAO4vClKbaKedcOkpWm9fAOa1oPkpUO3qlO6CQPBFNtD3UNSlENJBINIzINmQlOIuan0eAMySAMrxAKl6AIdNACKTACGcADx2MEkIoFKjWFdOEkoDB+VsKGknALVVhHOiegg6CWa/kGagAGVmBzUTBHcpleTNIxY2EWXBAGftAEYOAGqqAveqoi14AULoIMf1N/wrAM/+5SDox1I9U2besAT5blD+xAUDBalKGDT/tWnUgqT+xUpJUVWRxpepa1m6WnZEXURKKIikipZBdYnDK5FOzarkuRI8habfJabZEplCgqrwjDDQiDYkRJlNXJit65isVJZuy6ZX8KqMuQsIAFqAwLTstADYa4DA6jCqHACZdACYYAB2FQAybwAl8RFr4zJRCKFyw1B3BWR8snXWSpPXi0J4QwoHtAB3BgqnhpBQoKjmLgFvipRjkLFmz4jUOQBnrgC09BDL+gDYp1DdjwDMNgDMEADFaHILogDM6QDfpKD/KqrD6WD+6wOVq2ZZz5DqETT/qAlJyXOmHWkZwTT0zWtv9PipJEBK5K9E9r+5lrCp0umaV4ag17y7d6qyMPFbgQNa+EG68nqq+MxQ6LtQ6teIPyuqU4oiPQarB/erANe7nQ4Ayai3YIGyLJUJ7F8AuxgKi55Ahg5QdU+AG/B6kdwwNOkpVZWY1MEkdViBc/a151oYWCcAiKtgdxMLOnegU2CwVu0RZzJAnXGGdckAdusQY6oANqMAjIUBTQoAzlxA3WsA3CQAu4oFYEAgy4QAscIQzR0HoQFYsF01jtgA9d6w/KuGXTwA32ILbkakREVJsyBrf3e7f05Hn8Ni8BE7D9ug43mKV+u65/S7g3mHfjIA4OLA7gwA0RrMC1p6/5Srj/jxu5BQu/mcmnl9vBDAvCIny5m/s4JcywzsAMKmyexSAMuZAKFksRkTAJiyAIEmMCKgADPBADKiCFbuE7HGOyG8NSeTEHx9c84ScIamEH3qMIf9AHevAGaRi8CTpHcxQlOWvEHKMkKhUWOgAGf2AM7jKAfJsN1OALm9AIcRAJtMYLtkALIkEM0aAvD6Wiw2iBs8cP9fCigjoN5XBZvMlERaS/U0bIs0ejddu/a1qlsti37uquert2dooj+lrJ8qqcuogOgicO25a4QDmdGazBSlFQfGq5mHvKqAxOHWzKKKy5zACoKbwM/weAz9AMLDwVusAKnEAJjlAIvFwIh4AI/3bQAiUAAypgAiTQsS/wAiQQAy/we8zLUTAlBF04q1eCF3NiJXfASIawaDE7xXhZBVQgflPCA3YZBnG2MZTKBcysAkTwBrCADd6gLx16Iku7CfZhdH1jC6xACzZRDO1youOApi9GROiAp6RsDeygUFBWiiOZiUlUWXf7Dnh3Dd/wDX+b0RmNwRzN0eU0wANsWDfiyNagp3sKwqmc0iq90prbsK7syioc0zLNDJtrnsTgC7GwC7p8CZYQCYnwB5uACZNQCZpgCCiwPI7ase05AivwOzuMBTDABTXgAh0FFiEHCtFVF2zoPYjQu3qwltgXvOKMBTFAAmZBqUYgPniABf+CJmgX8AEmoAN8oAjCIA0uUhRLSxiT4AdyQAePoEG3ECC5sAs3cQzV8FBfqsn/NnvlMMoGhXlA1FlVpGR3yw4u2cg50q56e9E5ctEX3dHWtov4aq8gXTDnC7kRRcrq4sHV602uLcuynC7QsLCn7MEojbmsnMomXMIqnMIxvQzJkAzMENyME4g7sSGxwAqjYBGiIAqdgAnQjQmycAut0AqQQAMeoAMfMAIjoAIxYAInkAInsMMnMAI8zFEd1QMvoAJcQidWQghXQqsx17tyUN99carhjAUkoFI5uzF1BGe/IwQ1UI1ioANroAiVsArDgAwF2QzGQN2QcGhykAmogOD/IcQLfBiIy2ANh5WAEImdKrKjnrhF/YpbrwiEKG6Ti4UOaXqmFvji8uAOrhObdIpOAdM6AcwO9KCd7GC+58uuQ2HSlRvCq1zkhkgi0jANSQ6/kRPkUIGQQd7kJe3kVJ6IVP7kCJnlh3iIz/AMztAMw83CFOctH5ESr6AKqcAKpdDco9DmZrUKTgdraoV+kLADHqACJZABKfABL7ACWJAHQgDeUBgDXMADKvACy8sFOmAEgAar3Cihd9AIvMvXMyuzbaAGZ2AGV1AFPszWICsEF8MDMDAXMcCGObsGiJAYwNAMGA4MqKAJmUAI1EUnmfAIj+AJ6acgwvAhZsYNp6Ok/3JHp/FwxxTdDpbtOuYUDzKy48pOMAVzTq3T7K0DlFvkyQELm6vY7M7eeiM9uavcsIHZ0iutyka+5YVYiNLg5NMA5U6eiFY+FBB7iFk+704Z79LQ5V1uyyxcDBSHfzCRYaqw5msuCqEwCgTf3Gx+CktnCgxvCqTgCqjwaqkgTKhA3ZlgBiUQ14eezDVwApTqO+XNA+QM6hwDFiwVCFIIUzUAMt4DCYlGPWVi6Zh+BpuOB5Lqumsdn7HLBXDp1Fk5B+YFCZ4QILzgUpCQXoFwMzdjB5BgCJQgJNPC78SgDNZAwH/MmxStuCm6DjvZnHiX9a3z7Iv1k9SeYv+a7M9OMP/KHpk1si+jzNoIG9shorCDSPd1r7AK6wx5v7kJm7mb29tb/gwdvOWEL+8IiYjzfvj3TpBhfgyByI8fMU1nngoCv+YG7+ZtLgqYb/Bs7uZntXQG5vCm0HQG9mqngAqy4Alw8AMl4LFGkAImYAIr8J5isAIrYAQf8IQxoCTsnAIr/zFsGCVY0AOBgCWpPumCBAcyj+mbvjxGgAXSxdZYQOBZqY0dNRd5MV6aUN3A0Ao+pTKSAD5rsLt1YAjpRy3nshPKMEXtoES0hzDrMG2hfW3Zhg50+uzRzg7QruP3vw52mhQAYa3atGnRCkKD5gyasmUNGzqDGHGZs4kNlTGEuOz/osWLHR1q1MiQmcOREyEyQ5kSZURnz1y+fNasGUyZyZIdw1mMmLBfv3r10lUrVixVRVMdRZpUKatTpkiNImVKKqlPVa2OwpoVKimupppKXeWqKalOpFBNqoTIiBE8LjB8EMMlBYkVcVdgMTFCCI8YRrAIESOmhw4eRsJwwWJECBcuaxBBOjTIz546b+DAaaNGzRkzV+YEFoKFC488YtYKMRJDCJ45hVnPCUQIEiRNmSTlyYMnjB1BYDLJEiQoU6NClngZQ3as2DFl09jl+6dPn7px5dCxW5ddu3Zv2uN506YtmzVr06qRJ3gQIcKQDCuatAjS2ciS7kdSXMkyI/yP/w1VngzJP5VkQkkmAm1CECfldBKGJ596EWqoV4oqpcIKKbSwwlSm4oqrU75ySioRpfpwrA6vegrFDrvyapZVUGnlE7MqmaGFMIxAbAQMMogBix54UIGHF1R7IQW++hIiBjyEWIOLxXBcjAsc/UDkkcgmqwMOOjBjY7PO+kpMShzXEi0xHnRTDAs8AolNEkIEsWOOMFDL4w4qbwGFC0JAgcOJHBhBhhpssBFvHXnsuQefd9IphxtuvNkmG0nJI2+gaC5lryNN29N0I04vSqY/kETtr6RlmNmPpVNPRVUlV5VxlRkEb8qpmGIafFCXoIYqSpVSRAmlFF9/rVAUC4FFNv9DUUThRBSrrFpRRhlX7HCUqjiktkOnuPoEK21PceVFVFDxBBIzNigBgxhe+CCGEz5Q4YMXTjCBLxJSUOHedV/oIQYV1gpDjMPE+GytJmSzcpA/KNMSjjcyU6MzHkLDAgseLMYxsDz24qEGJ7mQxDZJQMlDB8V44EEMSfDwRJI5uAisiR18YMONUZ7BhhpppKkmGmimWahTZZIBNUGcZqX1GKI7/VRop4sOlSMEPQ2Q6KmHTkkjpG1S0FZivsa1J592JYpCX88eNkNif1227ayW5SQUTuamm+5O6uZkk0864btuvvl+ttuq/u7kWW6v8laqVGA55RNPFplhghI+oPz/3Rh4SEGMDD64scgTiCRBhctrECLKMBBZU4w85FzDD0EgaSQyPvbYMsuHNesssYrxEEO0THQLJDCXT8PDNtaMIL2GwupCJI9A8oBZ4BqYGKQSU3gRpphfHPz6654a7D58YmwlX0Hzj956a1nTZ39rpRFcn/0Fvd6pp5+AilCVoYaqRZefdI1Q2SbUq14ppVilOIqySoEVZjWrgXTbBCYkiIlLVPASE8TgBOu2CQ5ygnCEq4onPBG4qIjoQ6xYBVU0YYcLYOACJKBABjb3AiOs4GIvONLEUJake+kwDD+qQR4kgRrVIQIRgnjMIq7EhyzVYUsQ64yULsY7PBghN2Go/+IcJCElLuAhD4TQzWfEAEbeiYE1rOki715mh0p8Aha+GEaDhrGT8ZGvGMYwhh3taAycIMOPf2xfMgpEIGYYyEAvmQlMXDITQzYDJVzLCdh84Yv/1SKAEnrFhPa3Sf71bxe78MUufhEUXWwyk7SgBSxeoUpTZtKVmWQFK1LBilfEMpYfWsUqvvKUUZhigaNYllaEuZWoUEVaJ6qKMadllVPoEly5DMssZFGJNvyACR+gQAxlGAMSbI4EMHsBCXpQuhS8QAjmjAH0YhCIOZhACIcxkhHMKAl6wu5KlKGD7dqQBjSc4QyKGc3LBAYzIfTACJ8JwxrkaRopzYkLcygYHv9gJonAYOEEEzPCHTyBClvAMY7BGMYc64hHkubxjiXFIzJK+sfkKCh9jYRpTZLxx/ntxEGV5KQqaplJAr7Sp5zcZFBACcpQWtKosRAKLFDpSkz69JWxTAUsbalLZ3LobcAUxTCzosxvTSVw0IKWKZw5Vlm4AhNsaMEPuIABCowAmzzIwAhMcIIT4FCcMahBkOrVOTUVdA6AMQIMzGnGO8wBEpWwp2SYmE+H7bOfZxBCDcYUhsSshTSgqOJa1qCbIRhhCEPonV8KI08jEEI0QjjBCsLQBD9oohOzsEUwGjTb2X4tpMOgXx33uEeSspSlKCVpSIMRjEn6ghe5sEUtaBH/C1iqUqpHcWotbTld6fqUlajEbippYYvt8qK4uwCgUZWLXecul7mYXK5PaSldWyalFNT6Kle7osxkFnNwgPsqMzchlbLIqBWViEILdiCBDGgTAyMQw8SEsIIYjGAFKlBBCoyYgr7MCQ8viAuUanA5IaUgE5AIw2wesQhDKJYOcqDDlh722MjWoAY+Ck1BVRaIMJizBkYcAhfjEqTVSMIweFhDYHhwgoPaARKeIIUteAFS2dJWGLcFafiE8TU9mrQYuBXucIn7XeRakhaZVOUqpjvmMcOCzGemri13at3sotIWb7YFcnMBSuKCF7z9E+9424xd5qKSua5c75jdyxWo/+SXvvXN797+lui9VWUsI9wbKirxAxDQoAYfkGGC30LXi51gBH8hQahT9qMK3+icRuBBIEbDhcu9QAV28MNhR1xiP/BBD3S49WXewM9/9sBJQqrBC17gAiG8zJw9QEQg1iKJNeiwR1bMwxrmkLowvIw1d6jEuFyRC19subjFHW63vz3uXfwkF7kgWy2hWVVcrvtDXmn3uteNQlfAwhX3xne+7y1mpu6vFq84LywEnkqlvvncn+RFwrsdDKIO9ZO6+CS6k6tcPY83Fn5+pSrI7Mx3PyVFgRNhyEXe6MGR/KuFs8qiTYEKTYj8EZQ2mTdJIDBsZiAFJ7j5CcSwApsLSf90JJBXDdxZuiHhBmWXq2IYBIGWRiiixH+wNa5PLIddowENkkW1ZPdiGiHkpgZ4ADshnKdq1MQAMfIM2REh6qY8oI4QnmgFKra9ZO/yYhe5SDgubDEL7D4VKWr7JVY/sS2wsohEJXq3UxB/ilQwnvFhEfMqYCF5VpiZvbHMJFCVq1TsxnkX3p2klplMC1344snCGLfdzz1xilucz4Amc1NKZIqshHDkjhN5yJ8Fwk9w8IP4BRy5SBHyQ+AABSXowQsy8AITBEIFFGBXClKQgc+t4AQZgDD2edAvJUX4nFwYkpRiIAbAsI4QiI3d02enB9qdeMVo6MHLehAIPNBzLT3/MCiTEHGxgKGa6BaLgTm4hUxogtUKA+cBhUxYg0GAO1eYBYWDM+6ihVmYBXyDKgRSCqTQihGZFmuxFhmBCg8UHK3iJaxovAxECqhShVnCPDCDhfPas+3arjkDt4UbrpD6pCmzqdn6BeP6pOSKwOyCM+eSrnCBJtk7BWRitN/Dr5JTNA7yvftCuRAyC5bzBERgAQ1Agbmgl+vzpjkQtptbgRGgixNQAVfjpmAzARdLGYlCGVTDA8zigTDQgTWAhA9TohIbhKjbg1ujujQAxBq4kWRbA1BQi8ZYAxfbLMHQnb+IgUdci7gIAzAAg82aA7bAAzC4gkq4hVtIOGDwhTeT/8EJrEALbK9UyKWvmL1oqZYQZLQR/IRgahtR6IRgAqZRUJsVxMCioK5X6rzOMzjQ+7Zw84WSQj3TE5tfUD10q4UgBEZbIMJYmjwUQrxtObRXzC/8GgW6STkQGj6RywRPEAQQsAAJkAAYIrBsogASeAGQyROU+YAR+Jy4ABL8CwOPAb/QgJnUWAtEKJ3BMLJJgARFOARaizo98MNdA0T864EmCQwu6JfTERKYmQNCKCi/WLAo+YvSMYIjCgMiGBMYGIImgARgGAZgAClu4wVcWEmWpEB8Ezh72zd5o8lmgqZ9s8lURIWcTEWaRLOYFDhaUqXpErifMi9aEC9gBC9dgf+40pskZLiJUkIqVagFArLKsymWWQSWUAgFUUiFBZrFZpEbupGgC7qgurGgS8AbvFHLDOlKrIBGXJgFSuADOQADOACDJhgCGNoRoBuBApOhtwC6LurCzamBEVidGEi+INm+vMKcFEgS0fmcuuqBJjAyxCLIQZCMWnMiPYiDONgnSuyBFpAs0wiDQKAhIVCBGrhEg1oD1BinVFOT1hgdIcgEUFiDavsrGDCChpyEWwAGlFzJhFMyXnhJfcs3mlRO5bTJDxkXVFiFVlhOaCJKoLTOorzOi8MuL8szXbAF72TKUqqFXvCFWtgFYWCkn0Cqo8qpouCpXvmVrtzKrRxLukn/y/vEz/zkSq4UFqTqhV9An2R4BmS4QWCwBBvoAAuwAA+4F2yiAE9TATzAArf6AKDDEZ7ruhSIx3cZgXkhASEJNSMQNnqJgQ/wmIsygczBAjFonUoQyMzcTCZCSDqIg12jRGHjAYi0IkIQNinaizloAhfwNYs5EykhUlQTg0yINiVFKMXUASoYBOAEBlzQO9iiUrmkQJmEyXuLpZucyek8QnlDszOLrpgEqliIyTaLQO/MM0vSFTuLhTnbhWGghjrVnv+BkDa9pIwDPGXZT7nJz7TkT/3RhZ4YH6KBhmiohkXFhmzYhnmAVEiphmPoBWMYhk7IARbYAA+QABNgx46h/xweucQIgxd4MQJMg8wUlaEPwAJhc7UKnYvQ2QvUCqcRSD4NbT43mYRdhVE/4Mw6cKIaTQM1AIM13D4ssA3wIxhXG5MhCANnTRKUeSgYIBiAucRpU53SeJI1oAI+QIUphYVZ0DtbqFIKLEWYtDdW2Ld8k87oBFOaTMExVTNXStNNSsoYlMA3Y9M3Ey9dQLdd6J9gWDJjsKQ/EgagYEp0Q7egEK/9ucqiCIWHRSr/2Z6vURplcAaeqYZBaVRJ8VhHaZTw0IZ1sAd/aAdu0AZl6AljaAUg6AAU8AAKuIBQpZx41JF2iQETwLQMwIC3oBwTAFoT2JwRkD4c0tlPFbqJWf9NFTCBFRiSUBsCKkGsSYBRqOMDJnIiqoMYlPkLIwieyOrNFOgB3eCBPVmD0lA2LECEuGAn3ZAexggY3ECEGuiB01EDOJgEB6RAWsCF1ds7c5UFWTBX5MS3VjDcdv1SjkO8VYjXqcolFBLT9brO7GrT8LTcoOCuCEyucxsGY7gERuAETNgvS8gFhjPPckPY8MIzy/1PKsMJhvgZ8sgGb/AGSLVdSKWHebCHeaCHePBdeQBe340HeUCHcUgHdFgHdkCHdsgHf3AHbrAGZTiGZkCGQZCBGQgDGIqhv5y+D3CnfPkACaCAeKGAnq3QCi0SCqhQDDACDZWsHpC+0XAnGBD/xDxQgb0INRLQASSChEl4BIIsBIW52qu1gzqQA61VA1e9nNUAQxfozb0IImBohSFoEjwoDC5wVtSRKOTxtWpbnefpGD0xjB8YBFS4BQekUl9ALnOVJsE9znUl3Jt0N1xCvMZ13FhyBcilTuvcs+683PA8tyD+pIebU1+IBV4YhmDABTGDhfHUlZ/4HtdljmWABmkQFEfdhm2gXd29hy724i/uYn8QYzAmYzCWB3ZgB5BF2XKglPk4Bl/4hDeQgRZgq2wiQ71QvnU8AQxIAfBbx+fDtHzZEUyjUCM4wxeQLC5wgRogAUOO0NwwARziAf1tATvY1UeYhEMohAD+A6vl/wM7sIMDvow28BcVIJhUy4OOkaw8MKhbMIZMAIM5saIqWoPPQoQ84QLlEQNVU7XeiScc4QIdmAE+8IRbgK2VRK43Y+HjbAXCPdwxRUFZOgpW0Dh5DQugjMFnhDMfZsr+Cc/VrQVhsLNjjIVeIIYpNgjZ3eLbZWd7QBQwdud4lud49uJ53t15oF2UDY9KSY/0UNSEaIZjGAZauARF+AMwsAC2yoAIoD7pA99BbuRwAj+e1VnvzV+3Ykfp6xi35Z3lW5NFNo3LMQEX2IHX6V9HSIRE4OSrrYNPNmA5uAw1OMOJwZi/cAEXOB0KzgREeM2A0aJLDOY8SECY+Ys8uAVVE//hnO0LxKiBJqCBN6gEWbgFJYvAZS4rV2hm5KTOU5yupFhBX7FhnXKqFuS87dRTPV1PpoTiih0fpcmPmyCfZZCGbLBde7bnMBZjMeYHf+CHvb7n2/WGeFgHb9Dna9AG2T1sSlHsSlnUxnZsnaHeYBAFRigEPUgDOQCBC7gABmCAuNLZFLiAzeGLA9NZdukm7FMBDGATCktt5VEBRODRm+5ILlABIaqBXQ4EiykBHVCDx5gES7AElV5pyiBgYIXpNuALI7mc5OuYH/EsiNzfMAjAJfkLFwuE2/AilMEDROis7Va20IjEiuGCMIADTgSGuvOuz8u7K2VvVOiQD+EWwLH/Fr7BiljExfs2QcZDoAxJBfgUll4BOPd0z6Ba619oa6JZBkW1hvDghnJIXnmgB3eWB+GtXUh953vI63tw57oGY3qgh3ugB3lwB3YQB3CAXo517BRX8cau00Wt053ZmReH8ZdgBmKohVS4hEHYgz/oAznYgQ0osLZa1RKgAAlwK/KtaBJADbaAMEKYgzMEDGIzUUTgApvrYy4gARMwAgfmyBrwgKhFhEqohE7ABU5gBECobDJwAh/YA8rIksuAAyFBmRxFjR8inc7SgRfQgRuJTSnBIUQ+KElYW0nUARdgAiZgjYoZsujBgtVSg0wATioN4oRryb/9W7NIQlIokb3R/5tn2YQpdJZO2M+26dP/7hV/K1QDP3BlSNRpsAYsngct1uJ5iId5WIcPx+t8aF4xzgcPB3EP9/B2QIdyIHZu6AZtuAZKQfbFtoZkV2yCUHFqSPE6bfFpl3Zqx3Zqh/H5SAZi2IVS4IRLSIQ9aIQSu4LMJmSZ/QAP6Fmd5dkMCDXsc4HbuDTKIQGiBQzK0VDwDYy3YNZgE4IUWGQjIII7wORHOIUBnWxA0IM2mIInmB18gmk42AspkazL+SHTcLEhIAx+OSgygch/UYyXCRj8a4Im6Ecsao3F+IyUERg/WIRONGZx5TtcMLNwZeEjbKYkrO/5rkVRx5s//dP/jgWKnf+y16ViV19wR3mU7jAUYJdnD4+HD/cHEJcHSP2O7jj2ZWd2gkCPflbxfhZ7g7iUsvfn9BgIsbfibI/xbGf7mLiJg40FUaggSlAETEALOGiBFvDUbvqAC6AAlAl8McA0T/0A6UMeDOCBw1eBvzTRCu2BAptkRJ4LvHKBSGbHGnCBz7qD/k0EU6CGbGiGUGD4NngDJ2hzYD0xh0GNxIgBGKBf1Kii0nlWc1qNQDCSl7nE0smw0lmD2MgDtiAEtkAMvNgLi9lHQagET5AFXHBhc9VSfMtJoXyFPlWFYCF6ijXw5QiVjJV2Rs0GBm9wdLgO5U0HdkgH4EXjEF8H5EXeRnH/lGtw9sVWerG3//vvZ7MviLJHCGng/4gAiGgCoREkKE3gQIPSnjFsyLBZs2TIjBWrSEzYr16xVMFSlWoUp02dNKFqBWkGihISauS5UMIEhUCSKHzggQGDiQ83ecwh8eHFBxM5Saj4oLOGGKIkLryooSKFUQxc5oTpUaNHE0GNGg369CxbNmSX9OhBg4bPnjp04LCFw4ULFiFGeMjlYiQPISFiEHEZwkUMXCxYjBDmImROHjFyCSHKk2fOkKpyecCdA7cwYUl+BEFCJeuzLFetXMka/RnVKlavXsWKpatXr1+/iBE7dkwZtGjVsGXbtm2et+Dzhg+PJ08eveT05Gnj/+bcuTZt1qZPn2Y9YTTr03Jfz679+vdp1caPF08+PPppCNdHK+g+mjNnzJjJn5/svu1jFjHu0lUr1iseiSJKKKFwcgknCSqY4CimjELKJ51IiEomUYDgAQUYvDAHDx9QQIEJMTglwU03UZDBB2KYcMEHPpGAQQpA5cSFJCTUQAIJL0iCh0488GCjEYEEokMThCzSSByRNMMbNsFEokcbdPSxhx50yPHGG3IYJgRlhvFQw1tzKLbGGkYYJoYRQnARRg1zSGKXGHioSQgehIGJhxhzYPHXXXMJgUUMYgwWhg5MCALKZ63IgkpJjHqCCi657OILMclQgw02vxG3KafD2f/zKaj02LNOOdpccw114bX33qq5tcqeQNIcFI2ssqZXDTXU2HqeddWkZ12t0hDkDDTOLKOMbcXQdpFsurSmiiqlSFuggQdeci22l1iSrSWYcIIJuOGSYkqE5XqSiR8ptWgCTiqQkEEGN50gBE4ZXHABBh/ge9OLGWYwwk9CkJBCCibU0NQHXODx48BQkYAHIiYQQUgjj7gByDCZYiMNL4XQEccee9ghx5VvxEGYEDG8ZZcQL7zARR5mvmVEDUbEafNdmeAhZswwi6FYnFjkISfMhHLRQw9pClFDVTU0sQZjkBwyiB13kCwHHIrI4kswwhTzlTedchoc2d5QRx2vvXb/J9Cv6rmqnXdrS6PrQcFKIzfds9bq0DPMHJtMsrRhlJEuhbe2EbTSSksgtdUuqCC2lmwrOeWUUDJ5t+F28skmIkUYiQwtlKBCGFxgQCIJRvSAQQYkZAhwvihikGG++dKUwos5Lv3BVSn0cIEK7magQk4m8BBDGCSsgcgij+gRxyvSYEPNM8icAgjIdox8ZRxx4KXnW0PfKISQYpSetFx5Hpbnzgt/mTSNYmSSSR6SBGIEFufPMZfSNdDFQ+nmAAY4qMEPTZgDVcJwBj1EYhjGuA8zqpENa5DHV3BDSHd8dTf05Go8ufogNSoowt1gwzwiBGHe7Far9sRnGfcBXOCI/yEb2cDGcId7FrRUgbholYJApeAh40JBIE5I6HHgipy2KKdEyoXLEp3onCck9AgfpKQERBlBBiQAlKh8AF5GGcEIWHQTncwOAyTogYdY9wEVzKEG7PoAwWw0ghXxIBA3UsHLSnCHRTSvEEBwhDEeggxfRAJkIrODleTgPUSIYQhDUJMRTAADI5SuTGg6Wl0IswbLHKwHL5CLDuYAijkE4jE78lme8hAGy2ABMFxABFXWhMA7rCEMOxPDGuzAwGEggxjFuM8y5kOf+LiHILCiFa1WGCyGCEuFwfqgrEDowVrFpz4uhGFF9iOMbW5zWTSETS984YuMgLNw5vRPLdKpTv8ArSaHHlHc40KCCW5JznL2tGckGHWKVZzCFK5YxSxm0YpWoAISIJgACtiFAQ9Y0QMX8IAHSjTGeLEuXig6UQr+NQKcGCUFRkgBBmIghC6u8QUjcJkL6hSDFbxAlYSAxCIU8QcfsAETuBgGTo0BDEv8oQ99qAPJ3tCGnw1BBzzQgSNhsCYu1PItQghDVYxgGbyEgZFCcEEPpjIEqIVBCIigUyDwQAjA4AEPK4PLX4ZmVsfkKRB5QmBZ+WCJXXRTWb/MzwuBuYxgzic+DXEmYJ3pEIgwAz8xFBw3Z6jYxSpWGIL7BUZgI05f7GIX4KyhOdNJi81uFhar+SwrWFGKUYj/grSi+ARqI7SgJoYrXJsAFypIEdtP9JMUsJjFoiDRAgm4BKIkKAEGSgDcey00Khk4UQaEYpQvxsAE8epBHgD2JRSRoLkn5UEKeKACHnjyBDwYAQl0oIbmKeIQhkiDDf6gCVkAAxjBAMYpBrEHtAS1DfsjzBB64Mg5ZGINeGhq6ZSGGDHsqH516kEM9DuETNwCMaAQwwtKhwUe5A8uPhrMYLgQCEK4CZZ4CMQc8CSGodUBE7bwBTd9WQzbGMMY+XkxMl4YEWZAhG/PgEgzCnsfZCDjGBRB7DZnGJuMMPYXkz0yksXJ2IsUAyODO7Jly5kLW1CZs5yFBZazHNotp+IU/172sinCTIpRpFZCnTtza0XSiVOQos2oRQVuZTGJGVhAosHFl3CHexMP6GS5+SLpB4RwgneZIEZiAGmLzEiCETwlBi7LA11aQIIVnMAEL3ABHCDxiEYU4hB/sAEQDIEJV+Ci1K44RMj4UN8wEMYIjrQLVebAYaZapqtxilMm7IIHUOTBBVwSwhokYb/DcIEub4lLVnc2M0oiwq2OeUyIhxansgpCE67IRTC4VoxhqLgiLf72t72dTW0m9puFs0UtbCGpyrK73ZXtRWV5cWR5J7neKE6xsoxBDJwGeci+6IUudkHlXEy5yrSAxcGzjOUtr6LhX3a4l/lpCtlOHEKb6//c5lL7iTbLFhWeANeiKmEDC/BWJxGFAUM98IIhABcDD41oi3zSRZqYgAsvgNcLsJCBjLorX+4awY9iYITWMfoFBBvBoHXgh0lo+hDmZYMMxjAITJDCFQKdxB/soOqSRYaSa2Cqq2XmF5vhIQ9/gdP+XoAISWj3BZRJ2STDkJi3408vWEBEnf4UYkau8pbSxlPZ5+AHULQCF+0NBk4RH+Rx8gLgukA3LNipuFKkIhWsyOFnWROLdFO581MmeLx3Ie8iFznJXeumL7sdTn5vc96VLTi6O6tw0IY2FZMfBe41vvHUeqLMntO4hDa+CUZpwhOaqIQnFgECC4iOdXsmTAn/KDAEI5AAoms0gU9QRLwU0CTRFQUpVIpCgpxk9EQxGLQXb479GMRAB4Rg+iMUkQhDDMIGIZB6JDohW0wMgg98AOqVlN1WrYEjOZKrBdjXtZL5yEWrHQwMiJRI8cBcsEyd4M/x8MDNxMWaqEmI/cy04QlilFVYzQEiDJQrWJ0t0MIs2ILtTd7iDMiA9JAojBbulYKX2V7ludMrsILCIVznqRvBrRtskN5iJRnqLQtt2BViUZY48cLrdV4tyF7m1d7kwaBpwSAWDghqFVGCNM4MSgvutcIjDIIfsMUPgMFBTcDpoAhwlYALzMELeAAMRJ+JjJFPWBp4XQCOBAUGqEAM/7QOHL0ACfzMwHgRvHwXilDXCGBBDzABIjBdIyiCIhiCIbBBB4QAEPzBI1CCJmiCp/GB9nxMsxnB1w3BJFFF18UMzuCPU+3MA/KA2+WcmUyYnPAPDMgFmKBJDFBGrAFG+ZRd4OEBLYXYHAhCJpSEKZwCK1SeaFVhgQxI4zyjFeIeKVRe5U2eamQeliUcLdTCOX3jZYVjOBkZEQ7OMUgEOTleZZlT7KWgZ4VWatTeNb4gNBZIKYTCD7nT5r0GZPnSOTIDQ+TKjSEDMMRBBWiAA0yAA0jABpAcb0kABeiACgAXq7lAy5UAzHmAH1bXUvDLwKgATojBCeycUbBI0ixahv+wywlgEYpgkfFgABhAAvwpQiOY1xvYgAZ0ABTsgSHI5CH4ASgikhxQhQ5wAQz0gA6sUpmsQSYMifmkSWHkgSxIAgy8XQ3oRZoIxi5ioBAszdJATOlsyV+M2FiplZCU3WOUnSCs5SR4meJEyxcqThBFozTi3iiwGZidguVZIzOqRmi1k+a1hjoN5msAnDgO2WLFhmL2wjFIQzMopn+g03/8h2ACSA7lozvlUDrpgjg51i8lQzM8Q65gCqaARTaQJqbkzY3xgiXQQQhUwAQ8wANIwAdIgG3a5gNcGkYiVRsylBnBwPjFAO/ES1DkSFGowAgISo4QBkh+ABq9gHCeSIv/sCTNmYALrIFMTsIkSGJ5pYEcyIAGhAAOxMEgPAL9BSXJDMHOOJIO1M/X8Rco+MUcTEZX6sWb2IWZ/FpcdCWFQQyaHIYREEIgrBIhmMnQlBJcPYZjlF0grEFYCYJmMFApHA5seOM5lZM3YhZdSmMWTl4q6GBgCiY4YtaFGqbjmVM6bl4tIANDCEMv1MKLqpN/uEbhLJY/BtMzzM1u9IZv9KhpniZpgpCsIBM05IqsNMNE7AIrYIIisEFDzmYGGJ1tRgVEzWFD5RkFeIAJMNSLJJeNhJ/C7OEDmsAKvMULYN9PZBeKCOdK/kvrYMEcKJ12TkL8HUIhDMJa8sEThEAH/+AAGwwCGdpBHagFHSBQGLiAX0BbXxDgmiiGj/ynzS2MEACe3rGM0ITVstmMXShMWdGJJFgGWkYbWpZVHvgBHvABHehBKMxGEsoQERKZbDzLW1beKPClKgTIX67GDe3qrsqohaLTN5ZohepCMOwC4jXZRWAEbdjGMjhDNFkDWPSoj4IFpkyTsLRQs/7VQuRosJAHNuDKMyRDMfDCaFHCJPCBBszOA7DOBSSX8FiRu0zkbwkXBbgAD2CkT9wEiuREnizXu2xXCowAVMCRF82REBRFBrAfeCXnLdyBIcxpnd4pJfafGeAAqGlPUAoqHeAXF+iA6nRdmkSGX8SACiRNmv9AF1+AIIgJCoaR0litDKvJjBEgwighUFjFiWNYRpxIwi1IwlQiECRUAiPEgmyoGG28KmNpBLRsGdOGFixk42fx6g0RZrA6y2aaEzgVrX4UQ4uVwtC+Aj4KQ2n+aDackK4USwspg9qu7V61rTARC9pWk6w8g1/R7UI0gzEMAy+MgraYpx/ogATI5nFRwFtgyELlmQkIVx9aZPDsGbvoIRyZQCAgQuuoQHJhgBjUAMDoBIoQTIasZFGcQBf9ywtIVdBCYnlNzcSSIQGZQR3YQcggkloEgnpKgseGwfSlySTxgCPVQFyUbl+YFR5kAgOGgaPajFvhwWAQxv6EpSqNmFn/IYLOIEYpGW8egML8gAIkCBsk/EEhxEJsuGo4nlNrkG9lvgLCJZzCbZZgDuZkWmg5FU7WKtaynmOzQoN58AaQZsMzCIMOZZs3FoOutAo0tK0yyMdeKQNf7ZXfsO18KEMyqK1eDROxOINA3hhESETe+oItrAImOJEmZAIkDIFtfggFPACORF+WmpEVuUBEaSlGjlEJAMz4Dcwa4QgO3yEWaQhIGc8LqIAYaNfonggP5EEP0IAaTEIloK7TdRr9+QEUAyUf9JTI0IEV466w7ZdfwFqarEyXrEEe1JIOQIxdbJJl+IiG7YmaAEYYtNJbLMzKBAIyNFgILmgeBMJmyEEm/wADKJShqtLoa9yqO13eMgpyKrBGrqJv+v6gutmCihbmEPajP97GAWfHjv6otJIt2lTD3EiDMxyDL7VYaMJtAbNt2xrwC51yXkXwKufV1i7hLtTC01oemT1RJ2BCJ3hCK3jCGlyAbTLAA1AAiVBAvgpX4pYAcEaUyzEUlo7ApNoEipRUwtZAjwhicZqAwAAxZajAoJkAHkmCERCBIFTCEkNCIyxCEzcxGUKx//XBHSASHQzqfhFggK3xfeUuJE2um1hG2PmXmHSlhh0bCLoSP/dFWF0viBFjiJVVntgBHCBCz4qBGsTBJfzHa+jCO1keK6xCMurlMuZggECLrspoJP97jf0662jyhrSGDXFsgze49ASdDQWJkHZQkG6QB/Vsa45WAwEHEwMLk4690Dn2mH4sS2QB3LPYHmkViILMk+S8Vmt1SyuAQi/fSxYB84mwyIeMzkIxlEJB1BjpxAh8iGIEz3JZs5fanE+IQSD8LnjFgPKugAQWmwnMQSUQgiZopzmjMyEUQiIUQiGcZzu78x2EjFp8nS2RopnY0hzAwCRl6iZBKCLcAS2xWg+swc/8hZgEBlWYj2AIylY9BiEkxlTsjJh8GAItdN/9FwPpkC5kxOHsIJepwuW9AowOmWP9I0rvqLRmcm/8KNpQKwUNNzZYQ3Ef97eSUHFPRzVAK67/GGkyTcOsEHB80FhhJYuyDI7j7RAPyWBp4R4WcoLjOHW3SM4HZ44n+AEIlIAvw8SH2OYFuIAKUIBLWIAys3eWAleG9NlSYN8L9IBPpAA4OwwcFUy+xEB2adeiOdrdCQEFyIUgtEImeIJ2bhpfH8JfD8ITb4ZPTYlh10EttZqr/QVUsYwrcWAYBJtmIEJVyN3+fHYeqIlgtJJglI5cTF+zgcLKklJqy4Ra7cyPr8EfMIIqZOgvpBPYJkgprMZt/wIyXAqP9rZvALc1tE1Nb7IFjUdyV+uOoiamTEfZVtDZOkOrJDAMGTXhmBN3d3cP0aNd2uUnkNknDEgRQTW41BMlUGACJfzBervcCZswRAqzTxBXni1UGSkzvrRrR32ACxhdBgQxIBIMVEAFMeMOUXzACaTACWBBUTiSH8xPJuj1OR8CIWB4hgMqGfrUyIhMWgQEACH5BABkAAAALAAAAABAAQABh+i9nt2xkdqsitOrj9eohdKmiNCmh8ymi9Oge86hgsuhg8qdfsefg8WafMCcgr+YfcySZsKUdL+UdbyUd7yPbrmTd7iPcbiNbriMabWRdbGRebOOcrSMbrCMc7SLbLWKZ7GKbK2KcbqGXrSIZbOHZbGIaLGHY7GEYa+IabCGY6+EYq+CYK2IbKyFaa2FY62DYa2CYa2CX6yAYKyAXamGbqiEZqeCZqmBYKh/YKh9Xqh9WqWCaKGCa6R+YqB+ZqJ9YqN8XZ58Y6x6UaZ6WaV6WqN6YaN5WKF5YKF4YaF6XKB7YZ96X6B4X595W6R3U6B3X592YJ93XKF1U6RwSp16YZ15X515Xp14X514XZ15W513W551YZ51X5x2X552XZ12W511Vp10Xp10Vp1wT5p4X5p4XJp2XZp3Wpl1WZp0WpdzWZhyWJlyVJlwUJZzWZJ0XpRxV5RwVpRvU5BvVpNtU49tU5ltTJJtTpBrUI9oTpRpSJFmRYxrUoxoTotmS4hoUIhkSoNmUZReOopgQIdhRYRhSIRcQIBgSoFfRIBcQ39ZPnxcRntYP3ZbSXZXQnhVPnhUOXJUP3pQM3JQOG9POW9MM2pPO2pLN2hJNmpJMW1HLmhHMWdHMmRGNGRFL2ZELWJDL2ZBKGs5Gl9HNV5DMGBBLVtBMF8/LFs/LV4/KVo/LFU/Lls8Klg8K1w7JFg6JVU7KVU5JlI7Kk46LFg3IVU3JFI3JE82J1A2IVQyG08yH00yH0s0JEswHkYzJEUvIEgtG0EsHkkmEUEnFT0nGDwiEDYkFzMgETMdDiscDy8ZCSgYCyUYDCQWCScUByEUCCgPAiEPAx0UCRsQBhwOAxYOBRkKARIKAwsKAwsIAxMEAA0EAQoHAgoHAAoCAAkGAAkDAQgJAAUIAAgHAgcHAAUHAQcGAQQGAAgFAAYFAAQFAAcEAAYDAAUEAAQDAAMEAAIDAAEDAAYCAAUBAAYAAAQAAAMCAAIBAAMAAAECAAEBAgEBAAABAAAAAgEAAAAAAAj/AMEIBAPkgwELN4DoyCHFiJQxUuxIUWHETpscRIzgaJOHjRwwRozMiBFjhskXKUaMMEHyhAmWLlzomKEjxZpUsXr1KgatGDBauGypwnVpiREnQ4zoyAhRipOQUhqGJIIDo5EVJrHq2EqTZowVM2eaNBlja9gTJMsuHJl2RdoTKlfIPUHXxEqVdE/MGOLkTqVQqXQNw9UKFapTpRKTIuXJEyhQjT2V4nTpUidQnTpNnuQo0qRHoCNVpkTJ0Z9DmDBdIoXMmTNlypAdM0YsWLBft26tGmWpUaNZ0YwFGu7Lm7dr06RNW/5s2rNn0aJHY/68erNmz65rv77MtbNmy8Iv/9Nu7Rk1arMCBQnCg0YFBx0eaAjBgoqcPIUmCYNmjZo1a9DEFhsysAkUkhE3LKCAUkZk5FBEDR5ohAxi6CEQIVmwAQYRbMXwwgszvGSCCmnF4FIKLrxglgk1UFKLLbsUY40ywuBiYyu1vJIFEWbFcIODIelwII853IARjzPkMINbPX5F0xBjjDGEWVuVFWWUQyw5gwwyyFViXm7BdcIKeZmAAQZ0rWTCCTo4MUYek7jiCi3FxGKLYYmVAgopkIGS2GN+luLJZXpe5gklkXg2yaKXkNboIoE4cgllneR2yyyYrjLLbqNgMgpvloTaiKaB8PBGIMZss001yS0nTXXQRf8D66zPbXcdM8w049134mk3zXnnRVNMI2/40N4GO9CQwbId9KAGIIU4cooy/834GjLYxgYSEA5eUIAHRoDRxkJStKEHgjmokMORYrTRBiEaIkjSSCqk8IIJ9tK0lUgmkDDiWB9sAIgtuABjMDDDEGxLLKfkQoeSOsQAwws5UEnExTze4EIMOCx0Q0nzPjhlVzpENSWVJekAkQ5j5uUySXOhtaSIL7mEwQdk5jWDm3oQEictCOsSi2GnIJbn0UgjTYqemzRKyWiiOe20JaqFmmgjkfim9dZbB0KsqadSo402y5VNq3XYoW2rrbuKN1521kzTH7DKmDIHDzz4YEUNNrD/sEEHGdDQBR+HHEIJMPwRmEwyAx7ThoYG3qCAAUZumBEYFkUYIQ4wgMFGG340oXFLKaTQ70v2kqRDlifau4IKJXBQRiq4DAPMKY2gUosuuAzdCyQ3rL4kDGpRWWVMNySfvFtprX4yWSV51SFaUBpBF1sqZK+Cy8yX5NIJ9cq8ggnjr7kSTU4QUsmcuRSzSyysoJJK0fQXnXSgeeL5iSebZJKJ1AB82iVC5YiuDYcPc3iDAvmgwAa+gQZ440EjxraN5CjHOWer1do2yB3XuC08aYsbsIAVDWI0Igg+kAMdvNADGwCuAyHYARwAsYhFdKIYilscgZAhEDawISRs8IAB/z4AFXG1wUBGEAMREqKRdSVhD0BAQen69QGV3GwlHjId+ciiAhCpwAMcoMEmdNELYQijFrhA4y6EootQ9OAoI7lXHF8AshdkD0TKw8EKuNQlucggBSqQiyDJMpK6oMVEJHAJCb4iSJe1LExrIsn2TGSXEaRpBG4Zgh8qkQs5YQJ+r2AFK+ZHv/kZ5pSoIIVhFmMKPEWGE6px1CVi+bSqZa0RhcPlAR3ISwW2x1SrGJs2pEHMV9XqmLDaDgh1tStnfPCD15Fb2aTZn2g4YxR8iEMc8oCHHrSABRl4QAZY4AM6AOIQjrDEMAS0DGwJpA13cJeFFKAAghAhKkZ4nBhCkv8DbhkBCJxzgRHYUAK7fIAEI/hAFQ+agpG4oGZjqZkJJMCBDTxCF7oAhjAw2gveLewVuUCDEVingg+8wCX4yh4g84WDli5JBkna0h4D+Tqa5kB1SzpBItekU7iYYAbgy54jv9eSE6QgBip4iUrMtFBLzkAKg9BELhZxiFfUIhavyKooU8FVrqpCFahEZSuJBhlPwNJpnKDMpDyRmso0Yjhw3SUvyfAGFK5HA2ALBgWLaczsZFA7vWKmd57pthCe51fTGJs1tjG3YUSCD3SIgxzSwAIWaOABFchACLiAhz+cBhUEUoYzkqEhi3wOJN7yALfEsCEwxHMq6/LYCzxQgjv/3IAECh0BQu+S0pi44HofMsEHhEvRDMwBaMIYBkZ1QbBe7IIVwiAEkujygXqJqHSA/NC8oJcVo45ppnsEi0ly0KXwhZcEKfjuFEf0oTt28STZgwFbZKYmS6JFCooIRS4ccYhLsCIWsICFVkUZVlSq8pRfVQUrSsGnTpw1rbOEJYQHeAgGzmEOgUBgXX2AQjL44MPGwtt8QvCGY4zNGxnU4Nrc5kHCEhY70RDh3LbhDW1c48bW0EY0bHGIOcBBDWmwQQWGjNkN0CAMYeDDHyLRC9EuQ0N6eFwbMvICBSwACDcIiR3AMAgLaSjLIXGBB8YsBiDcTKFVRGjqPKRdMo0o/wUkqBcFLLCBH+gXYUGBkY1sAd1J9GAm+KquFq9LohnYUb4dyikg/RjIJSmJS95dNEO1tAI74it6dhyLobNLx66UpUxekgIk9GvGwcSiFagWZfwKXGBUgxUV8WNwYyiDCbM6Jq2gGOBjHZhABbIHb8YKcQQ1QOxAOCPH2kjmdbIDHsCOhxkujvYyFve285hnbsbxxjZufA3FIiMScHBDGtYAuAxU4AHiRNYW6nCaURTDGW3ApxHGYAc7GMEFCigBl4mwBz34uw2DaEO9pZCCM30AAynQw0vi/IEUNFzTMYiJiVxCkg/doAQluMESPlHqoOBiFyBfGDBysQQgvGAEFP+gQFrs2MXosYWQKVNBIsckU5gKSQcwjYoO5FKynZtEBTKIb8WzFwMTWLpfpmsoWXh6PbPoYX3CKAYOnRuLU6P66ljHOiywnmBTqIIUnRjUpNJKdrKXIhWUeAMZ1v4GJfNBw710ILE1YIkYawPFs+Kga5hdK+9IJzrN9Hs0/NOfHF9jhNOURjWV0YliVUEJQGjBBt5zgAN0YAdm+ANVI1GLjERFCmAYg7jE0AAJVCQHRrjDHuxwhzFURAckMDgGLlACO+hAodjN9Fhu8AIX3EBEJ/jQCy6eghv0gBGl3oWNPr5GW5SRDj241wUoUDGxjMXlZAGRWlaQ3hTIhaZJEp7/Vh49Bj1IgQQzkNIIWN5emo0Iddq7F75YEsmx6CCqrsiFGd23iwBnvRUAtnVZB1ZfhQqmsBiL8RhsZRkOVnacUDSREGI0QAMcth7rQQZBQFdzRWwhsAqDNzZ5xx3jAR6B1WzOAHjSMViLkwzh4QzQQXjV4h+IpxzVcHjW8BrAcAg+oARakAUuFE4MUAEhQIF8UAjoNAQPcSX0dgd6UAIN0Dnccgd3AAZS8AIjZQIUcAFodjND0AYlMFwkEGdGBz29FwOmgxbJM3wl4ALrgge5MAzDAHLLp3y4oAvFwAg98HvTpy9coWkdAgOBlDI1BRYy12gyAAMyQF7xBYgkAIgy//AQQxB0SRcTJlBQLnBULvABl5h06CV/lgRIHjIDg/AX+pdcN/J/WEdgp4SArAh2mJFWmGAJkREZDsZVjsAeNBACHZA3EcSLFQhiIoZXwXCCY5M2zvZBi6MMLNZizgANrtE42EIg3eEa1nRt/WFB0yArgxcsN+gMyIAJdWAGVZAGSgBOGzB5gRMEbvAHhcAXT+EUbiIGbEAEDWAB/kQQSsEjZ7KPF3AzWqgHv1eIL6F9dKRdaaEvLWUCbGgEaOAKcAhyEBmRxZAKP3ADKXABF+CHhJR9MDAxXuJdezQDQJcDNQVIFfNHpRNngIiIMDACJaACD4UiplMCKDJ8D1WJYf8YhnTEVEulXXsgCZpAC7nQC8BQh1eXYK+2Sq24lAmYgJ3QKHoCKJGBGI7gYbm4i73Ii1k5bBrwBsawDNFQjMfIguKxOMcwG8ZgDGeJlsSglsdADHAZl3CZlmu5lslAja8CY7JiHueRK9Fwl46ldkhwBUrAAS1QAyGwAUNIBXXQFV0hXwtBBB7QACSQAy2FAxkxBPu4jxSwmfKYAjmgkHe0kdtFExcDBEAwhkbQBJMAhzrxmq9pO8JQBhY5fSVCEh0JmUoyMSqwdOj1XSpjb4lIXusSdCoFdIXIJRPjWymAcR+AcR8SExiHIpWoVBigEliUJIOgCH8xJ72QRlUXSqL/1AqqVp6sQICq9lWscAqHcQoLxgmS8SeAAgqpUAqH8Abt0QEaMIEQtJVbWWzYYnfOtoLhkYyyoZZyGZfBQAxwaBu2YTDBAIfEIHXFkJZumQxoQ40xJivU8Ay5sgw61gpzQAZmsATk2AI0YFn7SQN+6CHytS450AAR0JFUQQQ58AES0JmcqaMfAASDgHq8FzEk4iEl0ZH2txWoWQIgogNAUAgIA5uwWQw70QdS5AEWIAMSI3wvQDyPKXxeAT41dQIycBTkNZyHyJIyh14pgIjGiS8z+YUFZVK9dy9rmIbClVuogy8zsAd7QAiKMAmbIJQ5Ip7uKUriyQoDhqivgFWK/7qoWfUKp1Br9nM0oMAKoPAH+BkCxEYDybID/hlBuUhslhCgYiOCK8iCpzobtXEbv/ALOsELvOBcIMcLcvhxOuGqreoLvvALbamWLMgdaRMrfNcMjGUNw0KiaZAGS2ADNUADL0RJ35M9NIERFLAAH4ADGpMDBUcBERABFCABOZpyZ1JbYIADLrCGI+IhKkA8E5M8VIKatMUmQOAGqTAMUPqaPlEMlVADYnal6tpFRjoDMGA6hQYyISlIe3SmiXiIQBd0u1U6KgFIYSgiGIdxvtV7l4hx7ZqJaHZQd2oCEaEHfkAIjPAJtHCyKDsntbCyLNuyHrdnNrKyGFULqaAZo/9UNKikCpfgS5qqWSzAqTvgqe0RtHgzgfGhAbGAQ9DgHwV6qiuIDMkgG3DpqryAC7dgC1sHC1UHYFtbdS9iC2CLtbcgC7LAq3F5DN3RDLiCHdY2eM9hHGPjDHZDBmgAZN7EAiGQAT2VMxMzXuQlo7j1Ah9AAR8QARLgreIqriTgAUmgBzGBEilyEtHjI8ZjmdOHfkDQA5VgOwajE8DQC79QDMFQDLTwA2KWkWy2pUUKiKVDR6FoIknyOlihiHuUAx15iM0ZZzKnW2EISL6VsRYLuc2Zic6pkAo1e52JW2G4FGKQB37gB4XACIvACKDhCNRbvY6QvdrbGdubvZFQGtr/GwmYUArmeUqssLNq56yahaITWAPJArT8GQKaygPAgEMnaA2nGo36e6C1Ya97hmoCCMBbq7V2Era2AIBkKwu30AsSegx3qR0jdB7/oW3a1h/DsAhrl6xMUAMg0ALaswKIFgMXoxFEIAENQAEycLwK1Zkp18Kz95wesAc4UKcY20Wq6yM3kCRDMAQ2SpMqcANJsASAIAwHU8T1G4fA4AMgYAEXgLEYGzwmQbA5kCUt6qUmMTHyxXsfYjokoKSXSEe8yZwYp5C+lzwogALneq7NGaezhwFjhpEZ5zl5AAiA4Ad0oEJ1gAd63Ad4kMd1QAd53Md5HFlzUAcXVgdUcAVu/2DIjsAKQhOAW2eolOBjbhAEKcqf7hu0RNuL8qsBfDAME9oasaFD2BK1sAEbUsugPkGrtvAKYBsLK1uHHGXEBwOHnUuUOEQg91t41dLL2lAtvwwNPDYHboAGYgADGCADYqIvT3UgOlACCyABJYWR05ej4Zpy1FwCHtAuNYkSrcuuwselIwEDYegCMAAEWRAHQEPLwHAMgzEMdbABFmABKEIS9cx7hiat6bI6M1EWMbB+deS6myjGMSGTYficFVuJBQW52IpxtFVQwvWFB3dw06dQHgAGcnAHznsHGR0HdHAHd6xCHy0HcQAHcFDSkgUHa7AGPzZuPbAEZuAGb9DIvf+QGwNMnq6wCG9gBlZJH5isyTvwYRHUyY4Al2eJythyltE4INhSDHApdbYjh6yQRi8Sy2T0mrsQq7QMkQiTy2AJLIgVwdQQHb1sQmq3BNiqri+6OkfRIMMnAQmwwikHrt/awlk4e2PmAnowsCmCXeacpRebmzDwEr7XA2jQA5rAzvVbDLcwDI+QARYgAY+LPEUCIuOVFM4DA7arAzK3cBOLOmUMp29KRQZ3UP7SxcO1hkQABGv8haaDZl+IAXftATcDBPLUEfLoOWwgBl/wBWAgjxrS28LNWsKtBViwN0rwA3QVCazQCwvjf4VxCqkACDxNBT6Qi5VVWUC7yUUrvyH/0ApzGY11uZZJLRtO/dQMGtU2UnUEDMu1AAswAqFwaMvf6XGxcAsIQ5fKsGx89xx99XczMgr4uQM/MC/rosNIqBQaUwIJ4K3hStd2nYUWzcQbsoYY+7jR05EGGcVGlxBiYAOIcMtFLHU6kQoh4AEUoDzJUzHB0890FDELQSJeBEj1QuOlc5M3fokDDWdoNrFh6NA0iRK01XBreK4di9dtXAJEADls0ASeIwasBQa+/QVODgZNkARJgJpAkOWoeQRergQtYAM2oARkcAm1AAyv7H+iBApwsHZB0AM74N308bPbDaryS78LegzRaKFnSZdKrapxWQzzXZRrtLXNpRMQ/xmrv2AwnKsTNsILt8ALvOqWDjyCy4YrzAAry1FNvxAIxnKQVDJSFRMDF0ACEbAA3Qqu1hzhdz19F5AC9yaTKWJxGLEuyeO3dmQkSUAQcJALn0uUjA7VsAAMQQACH4AR5SIFW8EQUjAESiI9CwGIAmsCgh3GyKPFvafi9YJxPj6x9gID5+rGKKLGazxmtOUBGDlmJRAuQJBEl4NETXDlQAASIYHlWA4E/ZQERZAETRB5Yd4DQZAJGRUUK3tqopQJVVAFVPADQcsCMCS/2s2f8QtDcyC6bdnUfF6halkMZ+nU8z2hgi51Relcrwwju3CvRiyrNtILkB7pwaCWvmrpG//0HIUXHchgCW8AitHjPAJbUi2cADKq6nWNzdOXhVmIkUVCkx1+mUux2rG1w1kSAxhR5UnAcbcaDAaDDE4NC8PQBxzwAUuR7Bizw0pSEjcVfmWfpRquUiiCAyABAzScIoxYAv4iIv7Smy+AWxJdsebe935fAlIUPJqtER3pT6uNmjC6Li2lPL6HAzaAAy3EAYZZA0GwCWWEUVSNVa4wCT/QAz1QAyzQArrYAaTv0xI/gZqqAZFg8SB/3m153hQK1fPt8XBI4rAphwvjfAgz37asfLpw8sC+C5EODHFpDK2Rgnv3d8L0y9Zw8x0+L/w8Aw6nhSnXAKie6qye/RRAAub/StmKXzFaPvZKsRDtzu6IQMSgi/XAoPXEcAu7MAkggAG8dwPYWhUdsxZY3JsdGe36z5tdBJMA4cLFjRswXrxwUaKEwBQKSaQgoTBFCoElPnh4cQOFi4YYPGC4ANIjyA8lS6hIqLCEBw8qFYKA2VIlCJYtL7TkwAEEhwYPNmww8ylXL1qvWB09lRQQixAgNmSwUGFnhw4hQtCgYfVqiA4aQqAqRkxsMbLDzBILOwxtWbNmkZktBncYMGBt5wLTlVdXL77A+PLNi0sXrl54a72qVesvXcaMffG6dWsWsV+QVXVaNMfFixg3dAzRMWNGDAoUMJSOICHBggipJZSG/Ro2/4ULFD7IyIHjBo4cuXXjAAKECJDeokHjwEFkOBA2Q3v9CjYXmTJivlqluvFhd44bBwnm0KEjh0EZKnLMSIEehokXMFSYMJFCBUqCBDfb3+yexMOGH1x+uMkDF1AogUAXIiLpowtKEqkljtpzwYObVqqJJg5qYomDCzgowYILdtogpwcmqKACNzbZhBNKKIkkEkdefGSNDDLgYIMKZoSJKquw2sqqqnjoJS60kGHLLrsao4uvXf66BRZYWoHSFFNIGQUTTCyxpEUtI2mkSy8PATMQMcXkY8wxvUQzEktkWUXKRvhwhJKBYvgstBhmIAEDBmFrwADYaluwtj8xINQ/GP+AwMEII4jIgQgd6kPONx2IMGKI3hplFIhQhAFmrGKEuYuUXPIQSKD6GvUsPEdhcEEG5GCQDwZY55tPVoQGqo8gigaC1SIYUAABWJgKDLYGFGq4wQXuUHCQIxA+ZGmhFm6ooYVpUcAWhRawtTZYbEGwVltvd2IqBBYeeKCCDfiYZBFHwIQXEET+6CGqCiawYIIJNrBgxhk16CDdEgHugIcuwxyzzEDmeKNhhc0MBGE0J1YTS4tHwTjjVVaZZZZbfPElGJGDIcYYY45BJplllnHGmWiiocaamK2h2RptbnbGklFawQTXOkV7b78RPij0ggUaAIm2kAC9YMEP9pvIvBz/jADDCOGIyJW33iYVDwdZe3NVkVx2+QUYYYTZa5ddWKFFkRZwNShV5bq7gTtZaVXB1btrlYFVGHLtjTccNlOhhIi2fXvbnXLC1oINYGrBKag4wDann1rIyVrFFbcAJg7s1VffBhQ44IAGGDidAdVVPyCAAQ4YwIc//jgkED5m56OPOuhw4ADVFVjdgZ7QRbcCB9DNoCoN5lj4DeYj9lJNjE1ZhRdefIFOLGKO4R4Z76dTJvyWxx//5ZepeQZmatZnv32Z1685/muuqeZmbWjWZhtrRrHElFEaUcEMwgOaF0DEBCMglJ5KQgIJLKBppXkgbUqyQPZwpG7KIY4OdHOr/4wQRGvI6Rtv+raGSnQCFKRIBShSZCVLgOITWnjbQRLigkQpajjcuUHfZAWD3sDAayrwYQ5k0B7AeW0iCyncSnKyxM9FhUQVeIADHLA61pUOdgPAYhYH4LotBsCLAQBAGMU4RjKW0YxUmB0g/nC7OvSBD3WIwwQERiJ9WUAnLMAjHpNnrqvwIBZEKsYxigG+8IVvZStTBsvI54yVkc98jzRfy54xyUlGYxrtwyT83hezmVXDkzSjXzXwd7NbRAIVoIjEIUQTmvAccAQHFMkI8gQS1timaQ902gRJoIKGmEo3uUpWqYhIkB0CMYQ9QMSLIjGJSTxiEc88xCVcgYcWpP/AViVIwQsoRQTd/C0HeJNPQyKCoaZZwEMXYomHJKAAAwjgi180YzzlCQAvYrF0wFOdA+TYgOGNSF/3uhdUKtCvDJToRsZzQAV8kApGAOIQfwBEH/oAiDbSIQRQMWcT7Zgjq7BgRhtgAVbeMMhAApIs3ONeMpJxDJUd0qWKXKQkKfmy9D1yfc+4JCansVOdss+Tn7RGKGVms2FE4hWueFcgYrBUErzyAyMwDaEEFcEFLEA2S2taofzjkhJcgEArSWACnwafI3JViRtww+0KgQhESBQQtltEJuDQgxsAYTfBwdVddQM2GMjAVeWZT0MkNCEPgMAFtqqIBB7Azwg0QF//EoBsZC0ggX+a8ykfrVGwHvc4G8DkWAVCQbI28isUeG1AKPgc5baVWpiAwAYtYEELLgsHWiTiEIyIGB/UKFE6eDQDP6lRamu0gar4tgM08AEPAqEMZHQPZd5DKUtVulLpqnRl011ZM7S7Xe42I7vcpWR4JykNaezUvJq0xiVFeb+fzgwZLXQFJRBxCD6sZgEJKIABDLCaBPQ3AfpdDT8bEIHTFBgkWS2JCUoiEwtkEcBHKw0G9kMCDJHzAvpaQh0gCohC0AEPbgUELSBBB+DUFa/+oeHgNoIDFezybv55yEoWJFiZTKSXFKFVCarpkpoUaFvYGlAJaFJYYgl5IwsB/xblBBQ5ENygBR4QVk48yy1ghcsGbFgCHi+LiFwwghGPqN0hAKHGP8yhA78NUUZ1AhNz4fFGV6EBDywBje/Vubnea+l1W8rIl7JsktqlZDOeIeiZVjIa4bUkTXFq3pzSjH3xs0Y1ZraMKumiEo9o6BwiQIHGDrixFJBAaxqbmk2/Rk9XvWXTJuiBi9jksbAhlGleCRGVVJglI7LBHfrgBz8AwsMfdmgugAGJJARzIKEdiG4IdIPCyUTGTWMJtFtQICFztVQRWYlFPlIoEygImzI2Z0ZBoJALWADKBQKCSmCgkpvMJ9rR8gA6KUfuYIELJjXAYwcmQYsvg9kRmXhEIf8g6gaq/MTgwWVzVUJQAarQYAdU2AU0GFlIZThDfDEtHyQ1blOYdRySmWzf+dw3M0jXLGbaiMYqLIGLVECiEoUwgxtSYILWmHo2pZHNzSGotFSH5COtnogHPLTtsD6VaAuGNqsVoi8U3AEPvPY1Hp7eh0OkQhiuoAMQvuoC7QgEOTPksbPh7aACNaQECPEACQ4kYwlJSKoQLGe45S5Zc0bWJoVTQYCmfYGuUgiXbYd2uRfnuI2ClAahqO0jnOkKWtCiEIUAhBvy/ZPWehaP5mpBBriygx2MFBoSH9/nRf95jUNj448sefzMl3rWk9zR1IDk58fHXGSY4jCReMQn+BD/BDN4ANSd5rRrQB3ZBkTW+Menuzl7Hu7IziasehIJrCnQuT6sFRGMIESv/ZDMSxSjy9MqAWywFqyuEq3HuorWSwSCgmzGYIfuWUEMWnyCFbynVBRaCNc/oJuE5JBCOqk2bEIJisiBF9AxDsAjDbmBhpCPFpMBAKGAloi3fjE4ygOBGugAJcgFfvuyRciFTbgEMCmz13qtFrCB16oBF6iBFVzBErSBIKCBQxA98xm9jbMG1KOZ2Bu9HaQ472GLJNkFXLCFJ0EFKumEK8ESF3EEaEIYM2kESuCES3CES3gEKqiDOYAsTmsA1tg0nGu+nMvC1wAU2oAgkGCJiwCQAytD/wbRk6E5DdNgwxEoNwuQA7ZiBEh4OkJ4vEOwBGAohk1QArp6Q0WhFmYhAZPIJllJCZfAFpUwgcOKgb4xgfmIj/0wQIWoELaLj2gZJybKCWcrEIH4AM/JCfZoMcORDxJoGgkAtxCZkdjCnAvMgDkQhtrCvUWIhLcas0Iogx0wQXzrFm5hQRvogQu0gR3wgUggi2U0C8YADCGMBShBhSI8wkuwBEpIQhdpBCZswtlZIz4ARz6Yg3CsA3Ccg3E8x3M0x3OEAzhIxzkwAzVwAzhoo0N4hEnYBEqoBEr4g3bkgAd4DVFrDZ2DtedTIKIRq/0wARKADwVDyKU5yA+oIBNoQ//4YJA5XANGuL5EgIMsyIO1chdc8L5CqAGLALUXwIFqYQEUcA89UYEXOMRDFIkDS7+FkKGEaMiIMAEc8ByhKzdoqzWWgI1wO7gm6kmhGywMGIEVMA072AMpEKJP9JBymwApCxGhcxwNIANQyAR3cZFFiJhF4DAl6IAN8BGrIC4QgEVr6YEQqIEe+IEgmIMye8d0rIO7LMdwBMe71Eu89Mu/TMc4gIM4IMx2dIPDLIMyIIMroILGDIIf+IEe6IEdOMFqgS0WgAmD85ePCoEdgANICAVEIMw+IATfKw1Pi7WCFKuhGYETmCCtmrXAmrkDmqAJMoESgI8RSIEYKCCJbMj/EbCI17CAJWAERQi4PIgDOigE23KEUiCSSaiBZzE3cVHL2JKI3Zg5hKAxUAQy+9gIYGGJcfsxUjSnCoAWDfmcVCOogpqRgerJCWiAqEKgxrIDUdCEQRCEPRiEPXABDNC2ATFBG7iBJACDJFgCOPiDS7iEFrEER/hKRHg8OiBMOqCDdoSDNLBQOFiDNEiDNdACK9ACwYwDM4gDN1CDNAiDMOCCLdiCLmBMKlACJYDMyeQ8zsMKa8kjzGytsqzAHr0sH63AzSwogyqR0CEef7qR37IBPKCDM0gDQAiFPLgQ2CAwnXvDqIqw56vN/IMPhTzE2vSP2zQJi8Cm2bQx07AA/xtIhESAhERogR8ghDV9EUwoBmWghTJggc+pANgyFxoIF2xBlrchiBTUlrfsActsgRXUURyFHGvBCj/VHDxqwRqwAUr1ILj8ASUIgiqwgk6NAi2IgihIgyiQAjtwAqKBABEQBFGQhFYVBEnQBFbdg1ndA0MwBD1oAz0QAzloAzlYgzqYBFfgBAZtkRc5hEUoBDIIkZ/wFyItEeJhgOMBqCOlVn8KHTmao2vV1m3Vl2o90p7gJyoSVwYgHSsyVy26InM9gN5xABoIgjiAhGIIhTXYgBeoDQmoDXMbrMFyGjPMKqVbMGwqlYqgEFvDEJewMYpIgelL0+WEhDZFBEJAhP9EcJdFYIVSWIQgeK1gOcEaPcEekFElWIIfWIIsSIIzyIIzQIM1kAM5QIPDHEw5oFA8kAOp+7U8yAOJ0lmJwtk8+DA88FmfZVI5IEwTTYMz0AItYAIgKAIgsAEcmIEVEAEREAIRmIKqnVoRMA0heFVJ0ANX3QM70AMpyDsJsIAougIviwRszBIXOdZD0AB0CVdxLR0qUtffUVdzNYADKAAt0qJ3yqJ3EtzBJVwu8lt7MtfgkaLjIZ4SmZEOYLgQ8IE5OIRSyIVieAU+CIHPgaxyWzN+sSMpE5Zs0RbNsZYURBZIQQ7JBIIkaILgaN0kcN0mAAMwEAM2wN02aAPb3dX/RHiEh4XQRGAriqWEWtjATICE7MsDQhgzQPCDPsiD5+UDqcPLO2jZOJADOGADNVBZNDgDK1iCGI3MGe2BSq1U082WxakRgrqs9iTS0IksgNw0q50CEYAACECA+83f+xUBURAEVeXaKRCEAd4DJxgDPfAACWiBNPCDSdhHFnGEbQRLB8Ciwp2nC8ZgMxLcw0VcK8KnaF1cxhWYg3JcDTA4DUDhrqAKhcOK4+KBIHCeRcAET3CRP6BZ3L2DHHa66HVeqAMEQgDiHwZi5g1i5h2zIUbiIyYEQ0hi7fODns3hPAADNmhZQHhYSJjY4KVYR8iFT0iEPlgDJbABDjhfGogt/47iioJj1t9iT/Y0qPYcUmctUm311iha3NRZHQVQgP8qgD5OgAigWiEQAvwl5EJWVUngWiEQYAGegfzUg0HQhBJoAA9ogS9ghErIhEvIRxZZBDIYAHqSJ8LdoixqHcDlYFLO21RW5XwKYSkaYRNm4RqoUR8IAiogAzMwg4Zxx3L0xrB8pkVoBDW5hFEwIVDwhElIBOfNA+uNAzXwXi3AghiVzBOErbIsS4Oy1tAp0iLNZuKZW3L9HdRhAP06HhZYU+Flq8ebr0MohB+4qHtpgMUdVz1WZSs65cAtXC/K4H0WIwKggKnlXwRAAAJI1YJeVUEQYCFg1QH+WicYBElgA//IIoJ8wQExgIRcwGiMJrgK8J26XR3ikaPQgZ27tSIG8J0pauV0QeGVBhg4izMe8AFaDgIyoOmGOcdylKgN4zCHKgQw+eVFoNifFupfXkJ3eREH1RKLsZh3mR036KwdVTgOsOY1Nig5ouB1jaI6PlJsTR099mrS8eoJAJcGwOoOuD5FUIRzhlB2rgF0cYByvaIKHlx+puu6JqM+fh17KgAEiICCJuhBJmT7hYBVFYUpkIRXFYXEtk9NgNU9mAAFYEWraoAWaGwQMAS3mRESeYAzc8vyZYIo+AIOdccg8AEyOEyYnQM3SMfbAcfZCYQ/gJjYjpjZhpfatu3b9um3hZf/oZ6Y3u7tilFqLBFHChWDHtiWwvJEfgFdJ7pWBuhbBtDqcPVqvu1bfB7cAejbelrXPvgyRijqZ3oERODouJbrL7Luwr3ne7bnVE5vLSoA3zFpky4dP7lf/BXo/RXs+x3gw5YExVbsVmVsMZiAAgCBo3mACIDkPbivCMgBCmgAWcoDSXC5SqBwCnfgfbTG7z7WF/nlRgATD+dGeIkY3MZt2a4d2TaTD/ft3wZunZkejukYkMEekTmuasmJs6VjrQZpbLXWEfHmxdpCBliA39FjKpoi1Fksa32zHeCDRdiEXOCUsxGGLo4DGwiB9pVj4hHhI2XcVl7cIx2YFGbhl/YB/1smg4ZxntsRk2N1l3ukhEsABVRoBVQoBRfSBMDWX4Gu76zd31S136kVZKoVYEEYgq66gAFbADvQBEGQgoGMgP5qgALAAACvBMaGBEm4tEmgBEdo0BdZ8U8Hdd9u8YvJmFGgno5BdRmHDpExmVafLmaA9WcoL0abhqCaH2249W3QdV1/ihCxnPUkLqusTmv52B4ogiM4AiY4gh44giVo9iJQgiMAAmmXzGk+wcpkQWDE0UStAbNEriBIqzjhBEzghHG/hEKYgzKoAioIgnaf6ZiLA17+g55GhEX4shZZkUvIBE/whFJIBVZ4hVeghVrIi17YC8YwkrZYxoVneGNYeP/uCR9BOhtXWAEBQID85t/6TtX77vPANuRXHYQhaA0ZSGxBiIAFQIAGOIFGjwDD1gRNQLzElgT9xHRrdHEr0ZiNgfFUB5mRYXWTka5YJ69Z96T5uYab0XVv8AZ5YHp5WIenZ3p6kPp6oPqopweqr3qrv/p6oAerlwd6wAesr4d5aHo0IAMryIJAhMsYJe3ILHbJpMxi57xqp3tMVQIqWIIqwAI1SM6Z1dleU+eJVQQv87JEuMNmqoRyt5hLeHMQdIXHD3jEsAXBOHizGQaGX0ZC6kHvoTjm8nxC0vxCCv3wmS7rWgZmoAaLmw5RwIAAEAAIqFr+pdqsVeT71l/BDuT/+jbsKZgCTZgCO+hvr0V5DHj0PxaA/hWFUAiFxM6FKSD+E9ADWvi8+LEfpbd+b6AH7Jf67ef+7r96fAD/8Bf/8fcHf+CH80f/9OcH8y//9nf/94d/+P+H+af/+Z/pxKSCKxBtdUyjPaz3fgOISZQqEcyUadOmTwpBlSqV6mEqV65o0ZI4kSJGjBIzugoVUeKrV6BIoUJ1ymEqirVisbQVa1evXsBmzhw2rBjOYseQ6UTm86eyoEKDLitqtKizpEqXOnv2LFo0atSsUa1qbZs2bdBEiUDgFYIIERDAThE0RcQUUaIgICDAFqzYsXKFSNJkR5CksqIkrVixx84CATly/1BIoEiUJrWicnFliwCsHVfQsmrb5s1bNXr06uHD569zvdCcO5Mu3dkf6tSqV7Nu7dmzv3+yZ9Oejbo27n+qQTEs5TFVKVchX7EaTqsW8uTKXymPtfJVrOHSiRefzuo69uHXQb0iRepVq1awVK1aZcqUqoaqYMmSVb79rVu85v/6FSwYMWLG9hs7diwZgAAilRRUUE1FFWWUbWPZZQ062OCCD2KVVSiOPSYEWBAIIQReggiRVmNtaWiWWCJCAKIkZpUliSRCrKCIJnoYQASLkigWilq5SFIiWB5SsAYrymS14CybxSYbP/yY9hmTrzHZGpRRorZkklXy88+VWWKZW/9uqnXyZSeYYMIJmGGKWSaaaYq5JptiXuLmm2eOgsmcddI5Cp554mlKeX3id58v9f2yn3//JcPMNFJVpaCDmjmq2YMPPhqphJUlSFU00ETjzDH7DQMMLaJM4RWpImA41odTpEiXWo+JxaGHPI4liFqrqmrWEBEkEMEFEUSwQAQz2ChKKDi2CAEBX20oggAESJCHMNqQ0og23shjjzvu2DPPPPJ4K0+364A77rftZOtOO+mmg2667Li7DrvpqCtvuu2kc2865Zyjzjn98uvvvue88446Bb8TTz75wDMwPAnDs7AlEVuiJ8UVj3Iexn2u0t4sHc8yny8hB3offvz1Z6j/gMs008xTUUlVTTVWOWrZkJTafHOllFlDzTPNBNhpML7MUh6eETdydCBJv7H0G0H48IYPPPhAQwg7tEABqW25BVdcJ9almCAXTlHWWV1liACtealoFgECJBBAAAmMMAMFEfSlgyQ4iiJIVwJ4JYIgHr5FQQ6M0PBLtfR0K4+73zouruPfsnMuu/Wmo846maMzL+f24muOOeT0O3q/4pA+ejwEH6zwOw8nrPDCJJdMKMoBOuXUNIkeaJU111yzIPDAU+rtZvQQH7nj9NzDjz+OclYPPZcNGeGE2liTqTNB8URMML/wcossrawyZ8SROHL0IYckzQcfczD9BhlO8zA//w802H+//SHkH0LVNOxAdQtKEIGvaO0xGpqCXB4jCmEwJi8jChwE4xIXG5mFRIH71QlGEBgK7GEMC3CCICIgBb1hiADJQgBaytK1CDAgENWSh2YYxw7kfQty8sicuCaXLcupA18FQ8fm8CXEIeLrdEY8HcHU0TrYvQ52D+NGN6IYxW+gY4rd+EY3wLGOm6EDHF1Exze+ca56ZU6LZQQH6MZRDnfAwx3lWKM+7BHHOcLDXAd7RxzbgZp6VGN8o5hY+Y6GvqQR8g9/CMQf2McHQx4SkYxkXx/6gIc6UHIOlpwDHNxABio4zQc+2IENQhnKFpCyBqasgQ1a0INUvsAEEf84Iankgpa9xUUQwhCGjTSBIQhCcAofQgvgWFTBsZ2FAHBbQF8aQIAxSGIPY0sMLb1yFghUcEdj8QoHiGGteThqHvbYFg1tiMMb1mteBbtXD4FIxHSAToj1+le/3hHPgY1uYAVTYsMU5kTX5eOb31zYwvaRj3087B32yMc9vkm5bLWuoQt7I+jMga9xtFNe7riHRM1lr3SNo6PmGAc71ViOgQ1MH+54Bzu2MYumBYEHb4DD+5ZmyTrwoZJzUCROE1lTmu60DzWlA1DpAIdLusENZiADGbpwhaUuYQlVuAIWzKCFqZ7hDF8QgxikMAYnIMuEsYTLivgGuFtq4gO04lv/hyq4IbIJYS8q8iXbELCAAAAAAAEwoRMWwxjGiAJDf9sQrKzJFgqEYhvGc4ej8HEPfECPhjXMHDnntU5ykGOdEb3svdpxz30VjLP/wuc9W/cwePiztPeojZZSiyUrWSkeCHtdkh7mz3vQNqH+1JZtFbpR2t4WXfBwrWv3EUd/rMMagYBf1NCg3DIgFalqUIMb1FDVLJShDGdAw3Ohm8miDpWScojDdtfw3DSoAQ1I5aQnqYAEJfygB+7tgRLiq4QlWKEMWMjqGErYLAT4zVVkGdbeJJGLXAxiDAsMsFvx8iq+wcpDDR5VsGaAgQa8LQIABltXDJgqt8oFAk6whjfw/wFOedTjM/qAnvEcO050DLGi96LsvSL6OYmyk8Yv7pfoOhuwN+KTpAx7GG9La4/V6KbIsTnybFir5CUz2UpSenJqomeMN7iBCjvYQXWr21wypMEKPahBC1AgZvcuIQtRZS7TspwF6pKhDFewwhLYG99PXhl/NGAB//jHgj3v2X4ssEEORoAAutZVAAHw21jcQiu1aEIQdnBCDk4wA7ykKEVmESaHphCBsbFICIAzy6DrCrcIkEAKdtBEsRTTogzPSi97ewsEJmFYfyxOHvjoBz64GUMV43AdkvVhD2FcYxu72J2iG91mddzjH5PWHrktLZRXo9ppr7bJS462akgzJf96bMMSL9XCD2qg5U1SIb4hqIADDnAABTCAAQ94QAY2wAJUXnl+dN5BD64MSlOSsgV3DkEHOrCBDAh84Bk4+AYSvoGAh4AFILhBCRJQV1E364R+C6YdNLiAtt3VhAQAlqkWvRdO42UMePkQrfZAAFJHAG52bUAEDsPXV5voRHrJi4giMIwQ/wOG3piHPvpRDxjuOpy9thwRKRsOysrYXu2UMTpPl+x7KtHHrgvyN2t7j4KOdrQ/bh22tCVke5CWtO846W9d20TXDkzt+fiHcOOuj9noQ7h0141n/tGP5iVjfX0AL03rMIc6wAENVngAXQfQbgc8QAOOD0EqgQCEO+D/wQ19gAPm3RD4PvjhDnm4gx9Cnwc80EEOcnADGs6whjVUFQ0/UEIPfnCEJRwhC20AwwowAOsOt00AHo5AAXpvaAEQv/j7Neti9jIsTQzCEJZOGwUWYHInnIACDTi0BQxBLBb5Eta+LItZhNAWBIDBGvSITQzlqI9ubWboj8MhOOKfOc2eU4hS/3WNM1vEY5Pus6Jd2BKRVm7hltYB4P8ZoNdhi7uwA7e4y0LtUNX5WATGQ9rFA9yN3T3sgz/tQwa+nT+UGNzhgzfMQtL8QR24wRz0QR34FBzIARvUwAAMALyFQCC8Ak4MQyoAwg4kQVbZwSDkAR0AISb1ASD4QR7k/4HoHeHo3UEcrJ50WcF1nYEWxNkSFMERMEEUeMEasEEWSIEeCIIeeNqy8Fey/IrHEZ/wEd+hoSEBJAAG6AGLKAZiaMLzCQIF9B4J2IEkGIIeDEIOSAADsEGxCI4BURMxlY1XkAAiRMP5/YNm1IP6zYM3tJ/R9Zqv1Z/9nY66EFuxpcM58B/V+YsE/tg9+MOzYd0OmcsYmYtupcsDossqvlM51Uu2lF0bOds8uAO8yEM7yIM7+OK1eBM/wMM9zENCuUM9UEMj8AEinWAcjB4e/N0dsEEPgADB+UC0JIhWAIINgIGp6cEe6IEe3IEc3AEhhF7o7QHl3QE5woEapAE8Lv9XdZ2BGVTB6/3A6y1BF6DBErDBGSSBHShCipzFskCAoZmQASTAGQpADA4A3KihABSAATTACYCIHDZah/jKK9lVBHzACeiIERSBhYlKhv0VAnDIhgjCHjRfIgCDN5TYPHCGPsyk87hf5FjiOrBY0vEfZVXWsMXYZbXTJ5qOZ4UWSTEUSZViQtkWbz1M5aii50AlvdAi5cyiKy4UO2AOQ53UDt1DPeiiO+QiMP7ittgDP7zD0OXkOmyDL7wBIrXPHLhBHkRSHpRjGwDBBEzABoQALSjDK7xBI0RDMVCCEtQAETDTHnwABoyApElBOO7BY9pBG5heHJQXGsBjfZWBFWz/ZrkpwVJFFTwWXhacQRzEQRsMgjDhhR60RdwkgAF4XO81ZAxCJEMaALBIgYAxkDDszYHNgCEwnxRggK98AIxIAQyMAGL4lVeRRQpNAR1WAiQ8QicwYj0Y40zqwz0YDyW+3zrEn3fq5Iv15Oj0JDkEZYxRFGYNpelQncGIFlIOjLMtpdaRHTxoDjpYIhDZp7ywZ3uqA48pkVGe3dl1VgSqQz74wzu0g0EZVNmRHdn5gz3gAzhwwzd4QzQ0whuwD1EJnuCdARu0wQUAiwQ0wAMUwQ4cwAM8Qg88gAdcAAbYAWLMgFcs52NQAAZI2hi0QRuwwRaygRhEwVR9wRdoQRNg/2EUpIGQpsHqrUEZoAEcrCAgMMIkuEIuMN8FJIChJYBrFkDwEQCXFkAMFoDxwc0ASGQCNMACEEIu3NJeLJAwGIIdrCljDAIGUEAJ7EGbkiSyEF+piApd5EImWMIjTIIj9MIkXstMOlt1budjnVH8qVM6kCeO9aQ4lCdmhZSN3Yt6rmf/nZ0/9Vi2ZF18Okw+DFFUZtY6pMPm8Cd7nkM5GAzV+Zg9GSU87MM/0KdsCZlA8cNiyQM4eMM2EMMbXJL7YJ4i1YEcaAEOAF8CFACFsRsDOIADwBzMgZBaiFVJ8hfcHNoCSIER3AApuYAKlIAHlAC5XsAF1EAUXBWSwuPqof+B5gHCITBCJXyCnPbAAgSf22jpln4plxbfAKjhtlZcROJAKNwSwpJVLgiFJLiAJKBmMSiDMPANqfTeVwSOEGiCMHDCJVwCoUZCMlwGuHiTPWigaFQiDqkTeR4beYqDOJhnGmWqOZQDObgsUXaq2NlDALqis43q63yieH4isnmiJx5R/4XiPaULq0ZgPi1MBB4gPCTJrZoDOliDJZABHZQmTLlBHPBBH5AjIRACDkhAAiwAtUaABVTABCzAAiSACMChHJYNqniathoamhpADBoAmEYkmAaAs15AFKyekq5BC8pBHgBCIkBCJYTCmgoDJFgAhb2NArim3vprl7ZNwNr/1bY+JJlWgCIIQ1AUA+jihDLghG5GLOgKw1nMKMedEOCoijCUwiVQAu0egikwiLd4kz7kw8mibE6yGHkuHaXarETJ2EdxA3pGFM3arL/wizqwoj8FYKj2bNM2jM1er8tS1qTyJOlo72adjqZ6FknF6sPAqqwOTJIozDhsgzPEpRrEASZZkhxEUiRVAkhSQN00gARQwP5GAAWAUBzKId+AlS+VkAkxZAAMgAEcgEOuYQKfaQOUAA4kQRIAwRFYgRdEgRjIgR8kgpRqgitoQhRAbgPo7QIowORKZOVy6QFzqV1pLqFt6wA0wCCAbuhqj+jasA0XQ19dkzE9ZLIckMZ6/8IlZAKhNkIgHINl5O5BIVRodEutsQNOqqzSCa/o1GylzlhIIW9HdXE5XK8oFowqnouD5mzPHtTWkZ0Xv9Ho5J9FYeLlLC1/zmrSoss5LIzYwWJpeZ1nJEk2aIMpkMFMURIhOykbEIIrjC4dDoIe6OgYfKEwXdi1ikVYkE2JKCTeFoACNIAClOm/CkADWF/baikKQ2spozADlHJeNkADpHLZ8usKf6nxRaSXzjLxDQAKN0Ab9CU09LIvQ4MwmG4Ok0jdQiSq6MECdcclRMIiBAIfOIL5sUNqJIlXetNYTg5OSjEQUTFluWw4fPO9fPM3SyrQlo7LHu3zqqKzmcs8SP9x5rgzvEzO5LwRPdOzeQ6RsAHb1LEqwZzDVBJMHouLQuGqO/QxP6xDMwQCGcCvJd1BUJUBHMSBIeRwlWqCRadm4ASwAE/TWJQFhiwAAnCpAhiAASjACfsrKEuAmFacCX2pbAZs8RmABViABDxAKzMA2/LrlvbrStPyARffoZWpAjwADOSBK9ywL5duxIpuLgww63IconHILdGCJ1DCIiBCIcxBIATDNuCDrWLJB5LsGKWifWpOGKHDypKDOAvvOKc1pRptQ11ltizgu6wDXd81G7tqOXRxF0cUOYRRGK0sOumYETlvP2cW/SlRKlKO16EGP+yDN/ACDyz0JTk0UJH/wbAigjJAAw+TSFh8NocAWKVZml+dpKf9StuyLYWZbWqzbQSkwAIYgAC8pseJaUPastt4gAVMwIjiNNuy7eTqdCzz7UIOH/EVwAJ4gBjkgSZE7A0PBejqqQ9D5IXYkjC4AidY9SH8gSUFpjfYQzwwD2OJ9Q6hy70AURjlJBZdUU+u9VpTqhUP7zmfcz0RjEWZN07m9wLW8xvxtX+PwxR9QxX3ZNF+or70y4F71jlklDtw1tlVzrn8n9SygzU0gg/8AENTkmUjVYb2Qi/jEkFuCFgIAdxammjrgQj4CgQMUEh/KQojJJfyqwbxrURabo3buAE8wA3o9gTYNCuz8m/r/zRP++tCPqS/mq0FEEIwB4UwQEPo3pJgXZPWHFp15wItbMIkRMJ2a+gbzII2cEN4f0Zo2FZV2gsYYREYSZGAq7V7i3N7t/U4Yy/2Aug5yHU73DWe0/U8pNF/jwM3/Dk3ZEM2qPl6d8N79ySNQR294Eu66EvBxCJSPkyS+IM3GIMn7cBQya/pycEPlMHSXELoSgIGEF9Y1NUUwCFG2gjC7gXdIgCFeSmYKrBsV1yXRoAyUW4sqzBJ6y2uJ4AFAAEIcEBe2vqPA/lvnzC/cmnlwuYs37hdGUAa5ILpKgMylO4t7UHX+LDFnogeoBokIIL66FQduCUzYMOkP3FvSWV4pv+5FLW5m7u7e1/vWp+zf9Y55djDyC5OTHILv/M7n/95R/25oA/8oEuRwbc5053npSJ2vnAWK7JLpEctP9SDN1gCD+xADWAe5sXBpnf6sB6CcwuDHQwaWBAfXtChjTDGqkuCHWCNlsp2mQasRLa0xy0ABiSLlpqpkCekkCeASZcAEKAACFwATUeABPhKsRv7KMMyCy9kT2cumbbAwS45NCDDbqK4qXSNCVG5zSnCJCgCIBiSIs0BGfjAKFxDbIy3N6WiukcqOZw5YMP70sm9OMs79u7Lqy62PYgLt+Tu8zyxv39UFwu8oGOD4Qs6oCc+FLU7W1cWmxO4pnZWgqtDw8D/QwSeS9Ty3RvwgA2ggMZHtOndARBYARrMAR7kgpMXQ6iM/KfJYfItEE5U6RSktksXn7IXgGu2oXB6BSz3vO+XbQPgQBPgQAuAAE1LwG7zNrH/+LEH98s3PW4LwMQl8ARAAuj2ssSGwh6kii+VCH81i4YIwSBAAiGEfSJdEie9gTFswzx0BrcoFMSbN778NWAXehjRPd17MxgjWzlpC+T0O0DUEyhwXsF54xAm5MYtGzaHD7MtlDiRW7du4ciF00guo0aMHDmeU6fuXLlzJ9XBy5fvXct37mDa+4fP2yoeNWqAgAPHzc44cuT8OFMmTp5KxZQNGyZMmChBgqY8lSQq/5eoULmKMRUmicICAgYKhBUrIGwCsQUWiIiAAEECt2/hxnWroMEEMGCS3EDB4YIFvxMmSJAQIUIDw4YXLFAAF2xYAY8hBwgAgDKAAAUa5BEGDRqyYrlCPRWkZ4oQ0yIQECAAQYQQQ5IAAeLDZ06dOXOC8PARyZq3evjm1bM3HGY7d+3apVOejtw3584tdnMO0mN169bFiQuXPbtI7+mQw3RnMDg+8+SDC0TIbRxDhxEZZpOfLXp9+xadewSZkTm55SeRQ04kePhRpyV1jGOnHX/q8SaSN86wogc3KPQJKDR6ysMOOwbJZZiscpHENCEEmUoUqrTSSgqvLguLgK5Ue/+MABkNiIACttpKwIDF5EqARgUWaKAFNrLooQYOKmggAsAmeOCBwxBjQDG5CogRssgCuLIsBaDIhTNrlBGmKklKlEQSTUSEAAEIIBBiEEII8aOPPmabjYw3/mgkGd/8Kaieeexpxxx37CluJObQQQe656Cz77pHPcJGnHO6G4kl4wgdbqBN/5RHnt/+rCcdc8Yx5xv35kuVvvtYnW4/kJhbLp2TlEvupHdUeqeccpBjZx186DEmEDi0KLKnnuL4SQ4K3bhDD0WygOSXpSQpzbSnTswllxS3wsCsABojwCsCqoyRgAQWwOBGBBZIQIF34eXRLbIMQLeuPAhZQ4seWuD/wIIJ+vo3sCefPCyxg+Fy0UrIBmh4AAHIxYwFSqABU0wzMQ5FE00EEUJNCPQwxA9A5JyzzjfemCOQUbShBzh5fDUOuUKRO5ScRBlt9D5IeZ60u5bgecc44uwhj1M/8flznlFLPVXVp+dbiFXpnnvVv/9OOudmAUl6hx94lFtH7HXo8caSN9zIQoke1mjbQjnQ4AmOOxTJJZNgjinGFahEM1EUMf9uaogIFiggAMbeaqwAdCM4gfCDF2BAcikhX6BedB+YYINKKqEjDglRKMECFPbyl0nAJHASygYS49EAxSNz+GGIyVXAgTk2EyYUQxQJhRZacnFFEkUEsQODE3jv/wOQP+Y0mQ+U5+AjkGPoqcfTedhBh51Ai2vn0HRwznlqniHlbtIDERQPJj853TTpgtpjL7753oNavopadZUjWZXL+pxEa9a1ryVoHeDwBj2cEYg5oCEJPVACGtDQtjXAgQ1swBDa7nAHDwUDGb2oih70IJUTBW5bWzkBBhpQgAG8pV2JYUyQKDADChRmdTU0zFwaUIEMLMEVrgBEH+RwBhvo5QYuaAEKPBAwvwgsdQ8gDGIU8y63NEYAspvdY8BygANUABLC0JsrhKEMZSBDGLQIxRkNMQhIEKIPf2BeH+Q0G+jV4Q+WsAY91iGP4KwDHYEKkPfUoZxEKYpR4yPfdf/Md453jCR96mvfQNKTNPVMRFX1s5987pOzb+xPOfvTGjn+h47+ZS1oMCmgN1C5ipSpbQc/QIMY2CDBNRAJQ7XBQySUAY1ofMYpITSTJpiirRJKYgYYiIAC0AI5gx0sAhLAgA5m2MzMOYkwhHHSAyQQpLpYIASF2BYkYiOHLADhBkDowQ1qcEQQcGCdATsdYAoGpSm9LiwOu5JkAtCwA3BgEmHkDDWiwZlhBC8UlWDE8v7Ah+bR6Xkpm0NCfYHKdXwDZujA3h8FOUhCPodVEqnPITUyKe+QJDyYMhokH0mq9TQEG/KxpP2kVh+dbfJq/ZnV/hK1DkCeBB7wCBQ4yOb/DWoE4g1oOEMQfLCDV4phDRRqm1ErFAdAAEMb1oDGMHYnlalkhVuiGIK6GmAAKAkGmw14ko0wYAInYEAw/2KiYCRwOsNMIAMd6EElsOIKRBSiD3TAy10aiM4jkg4EHuDLEt9aTRq2TkdiuSJl8KlPDThiGBWr6lV1wYpSUGIRhwiEGxcqxzfAIXpzaEQzDpgNcNRjHdkL0HLCN0hN1ocbhbwIRsjXHa0BKECE0mN6UCpJgjBtpfRr6SU9Wh//yPQbsvLPJ9MxtnSMBCX5uEc78uiNbfgCZWUogw94QIOlokENbmhbFJZAhjjgIQ9woIU1ohHQrZRJEqEYRA9CoQyu/+YiCiW4QAMG4CTAWKACOsyAXy7wgQ/MYAwksMAF/LXEC0wYsRbApgU40AI8uAIrwqhEIuJ0BzbcoQ1swAsQcHCDFBuRdChYZ4T/MoF/DWaZU1ThwypjmcgyoAueKIYuoVEMYLwiFJNIxF5Bm4c8tPEPVDADaR/6BlNcgx7fWK1GxbbR58h2Uba1rUU40rPsgNIkmArPb39jHuCAKj3zUGlx3XNcmMY0OsvFzzdEGcj/7C/LoyyJPe7hDrFtwxqB8EEZzkCFpO4gDXeBoBraloQ0mGENdLA0JeDLGWWIwhCCmIEIUNgANngxl8V4Qgs88IADuJUD7CQdC45YAhOQQP8HdniBB0rg4laDoLAe8DWvQQAYDrDgB4wAHlJSAQkQ++EOSiaxGMDQhCRMG8XoNGIL1JlEBPsFrotVDFgaluMcS8YADAgBHz6hFTMaFMnMw4NCExqEMrjhDbR5QyCYsQ1vgIMd31jHPMSWHHPU9lTO4XJFNIk/i+CPOtgxHyjHwavuucNTgL6HP8zzKX/c4+JJ24hHvtGNh4xczqo6FUW48WZzrPzNCUFIdEUJSHWYhx/70Ac3vBEMMpAB0d49w88hSF5Ij/gOQPHcHBYBDW0EFBq50IMMCbOACJigi9DI5RpkkAMVeMAwzZRAq1tQA35xwAMYIIEUTmhYGLea7Rz/2MAGMmeBDfRgEqmgBTCK0YtILGJOd8CD5yyYhSUMvgfnxEkLWCD2vXjAAqn7SxPlqQBwZwlLknnMALL4gA74YRKf0EQlJgEJRuy1EIVAxOkR4caE1mkOLNvGrzCOj3WozxzoAMftgSo2cHADHLbfvURC3g1uWIcc2iE+SLIWEkWqJB/tsMc+VjKceeDDH/zgxzv+MQ96fFwjwic5N16aKucsxOUrL9XKleNyl4MnUdMNpHn+EY9ycEMbkZC3d62A6KCf4dGzBIqI5YAO3KAOiqGqikET2GAEPmCGMEAEIAADpMCLwkgOYGAGdKAEZMwvSsAFakAJlgANiqQFSuAE/+xAB05ABVKgBUCAdAarxVwMw4ZNDSrhFGhBF4qhGEDhEfgOjvogD/7OgvgvC85A8H6gB34AEBIhDUjHXy6gBAzr8eKqSVhH8sZCAPCJ8uilAF6HATLgCAgBEkRPEWIDEEqv9BCqThJKZYJhG65BHmIv4Mph5QqogG5P93Lv9xZCZ0DKapRPJAxEJewBHuJhJaxr+vwhH+IhHvgBH8DhI6zj+8DPfp6DPRCCVFiO5dJB/RLiHMCnubwnHaiPH/5hHLbhGN6ACniuDKxAC36uFYHuqdZADtgAliDIFZSBFvqgBS6AAihABFoDNdjCTNggBzBgBWYAB1zAAkCgBVSsB/+EkA7qgA7YgJxWYA/GQAdyIAd6wAa4sQdS7AbA0QZqwANQoAV6ABA2oRReoRZ6Ie84KxEKgRBiww/8AA8yiMTiIJaGkA4moRIUYQlswAVcgAMOT9f6IsKk8GCo8DEsT0a0MCzg5QFaAA4AARHosXn+IDb4oA44sk6epxGiYRvkgfpkr/fQYWzGBvdU8vYm4lTsI8yqw/hgsjr60EDeYThwJR9qzh6qjx9WQh3ooRr2A7fCAeUiEWpOjhLN7xLRTxMRghNDDh2QIx32oSezQRssgQdSsQxY0RVbMejcIIJMDAwqyPRsYAM8gBd/UU1SgwDa8kVOIAZy4AZs4Ad+wAr/4OAM1ECh6NEP2CAJcGAQ9kAK7kILksAKlqAJFHPaGNMFcKAHzuARNuETUuEVbAEYhqEUHOEREkEREAFOSIYe98AHMwgoAOETzmgNviAJasAGksCczonFRJDx/qUwCqNdzAIyVGNGyCIsdkQBGKABNkAJ0kAO8OA4PbJOOLIOGmoWtEGP/MEfbG8bqNPK7hD37JAiCi74usE/QCqkxKEPReImxUMl9qEqCSQfyiEdrsEY+LDhImXOGCIhBo7g8jApJyLiTEU6liM6/YEbtiEZ3oAHvMu7ulILfO4M0qDRMIT/KogN2gAMgEAXGdAX1cQK3ZJNZAQBRCAGzOkHqOA2/+oAEj4BEv7A9AghD9rACAbBEDakxJ4qWSpIgqaxCc6AHzNhE07BE2wBF4ABGC6BERgBEhTBM+WxL4/UD5SMEDgsF4CIDVixgoxqnAovNpGoLySg8RCjsczlSi5PC9+lARhgA4CADYxuOdGUOakgCALBGbahHqITHL6BOqlzIVhSIu6U9/CQ4BZOOrjvUbijHEKCJP4wQdwBVwbxH/7h+sahG5JhFojyaoayOp5GIqJGIQhuO43y/EIOz5TDP+lvFUKABvDPCrBAC7QAC/Lv59IADcAAqkzMCIZAB0jAmHrRFxHACgNgNX7RAR8DAYRACm6ASRdhDgrhEDoP9BgBRf/zQAwGQRJGU8mOkw6O8x7vEYLkABAqIUd3VBVegRbEhBIeAQyJVBFADE5Acx69KUz4qg/wgA36oDQrSAuaAC/m0gWuFEslYEvNQjUKIDLIooocawAUYAJa4AyAAg9sozaYsw6UABVNoWX84R9MhU63wTrzNGPzVGcswhEB9eH8ZzxHAiZaYhCtjyXQQRpmwRQiFVb6gzosFeXuB1MzFT/zc+WiQ5TSITrXYRuY4Q00oAasIAuIlgmiAAtU9VTP4AvAANp+DghgwJgKAwEogE0IYDIAgFdNw1o8BmIwYAyMgBGC7BAWwRVowWxd4RIWARESARDoYBB2J0l/aGT6Uk7//CBhE6Ef07EUPEEdtyUVJiH0wPARGMFcj+z0zLAQXAEaXMEPQGxJ5zEPig5CTayBbGCwQABLF2uKeFNXG5LyGkYLGwAElOAn0rQOdgC8AmFP8GEU55ROC0hPf08l7XT3XJJqFs5jD0k8/fAPewr6rA8e1qEagmEUVoE6/ANWXJYcjDIpI6IST45RjHIhcNYi2g/j5GG7QqADWGBoizYKUNV7z+AuxEAMJpTG2CICVCPH3HJEttZ9HZBD7UAOQkEYEoERPgFte0ht4XFkRAESDGGvyBAQ0LWA2agO/OAR9NYTMMETOIEVOKzIOCf0xpVwiTQRjuxwHyEThBTEfuj0/9BVSZ2txFZzG4vICXeRxlyoXwVAx67wChtmRxwgA2oADSxtOWnAB3wgCEZBJEdxHLKBTlkS92o3dmU3pvAs5LhhJjsCUpBvJFyiZHXyPK3PH9pzFUZhFD7iVTw2zFyOkubji2t2/Gorp8QmowZpHTCubLKSBlqAaIk2Co4WCywoDs4gCcAgB0ZAhSOATRDA8tbEfUdkCgg5KjpGCNRiBtjADNYLECYhRzMhFVLBExahEEgmDwoqTi5SeUKzbukREBghcCfhEjwhE0qhFE4hFSYzE0AP9AiXETAYgy05NtxoDD25L3swg6B0DQQPB9JJBP/lSRZAmBcSYrxURvxVC/93hAFm2AbWAI4AAQ7oaBEigRroYWL/AeMEwjx2L/dQ0g5xL3xchWeaGHlDtiT4IRF1MjrLIR/qYRp8YRVWAVKPr4uZQ4wXIlUoMX7uc/w0qbmiC89yKmm8wRnmgAd2oAPgOAuYgAmswArWwFVn0QgcBwEIA0dwhDUEWZAL2ZCnQAQoAANu4AzwQHkg4YxC4ZQ9IRJUrw80wRXKUHk4eQxpmgwVARJE+RI24RIw4RIi4REosxIUGPRwWkgX4ajXlmwPYZbHsPSSlB51OZbQYAmAYEJVcMawKXWmUEcMoHN1M5l9UwEOwHYMlqThgA/+4BAa4RYOaGL9wR4kiRG9+Zv/U/L2NEk5yFk/kM9/RoIfxiER3wHj7oEf0mEbiGGeV+EYHiUjOkL5xBgh9Hl6tTNnbm/lmsPfgKUmdCOhlwCOj+AIlsAK2MCvgGAEqklNZkQyVmOjhYBrB7mQoYKQV4AN2pYeEUETKFOSQeESDiEj+wASQONEybAMibu4hzT0AldcJ0EHQ3mSKUGUl5uChZQRjrqD4XGWiTtdR+YOoFEO4ACOxskG9qLx+mJgpnAxuvqYaSdiBOB13oUBJqADdqDeyNYRlsEbriEb1sNTWIuuv1lWlpIpzWFXCJyxNcIclGPAs8YkGCkRE7Edpg8eHHWeZ4EYrEFS9TrMkK8cMBWy/6MmZoGPjMfYyljusuuBHgotCHaABkLAe7Pgs4cWBF1ghhaALWZkNdikTVh7x0vDo+1ADyTBFRJhZAABEnA7FUqBEzjBEXwbEepXBw8hylGvuEsPEYYUEsZV9B4BEchwESZhE0pZ9HC6H597uY16uh+BcA93ytF1HuUEDxx5EvxgNcU7iVC48fYVinRkYXTTMSDyvRngAB4gBNDgD1amqqbhGhgCHORhrv1bp5JjVAQc/UJ2PW1qKnu3d72mJawLHbJXZWdhFoLhGbyhpviwkzhiV5wyftZjn8/P/Ohz5Z6jwJ2jbILhDbqgBnhAoRc6C1gRDVogm9jiVzX6tQd5x//dl5CfYgoMoX4zgfQQ4ctLARQ8wRMooRAyMm+3xaeXu4LTnHCR+n7JFcsVoR81AR77kXMqgVwDd1tZmahfWUjTnBHUHPVAODYsuRBO2hUggYJQDF/TaZ24TTAQA71d5EqSmV6AhAH0adDJYA6GIRqswRqu4YCqR6eO44+6J4AYqeM7Hn0QRONhIiV6qqda4h7MwR78+h4sqhriOdSZwRvw4VVQnZM2fNXJzykv0Sl5Dx2SrznoQRsc4Q2wwAZCQANc3Nf57wz+S0n6uDU4upCRfcefwg7uwBaFYROiHBC8HBRU+hIKwQ8KQUgvIRdeARMyIe3VHd7nPcthGR6BSRj/lnXMwVCUIWHtM0ET3t2Vp5ve571wD5cQEFcR8tfDjlMMmiDFzumItC1LaWwKXye91ds3XyeyBL0C3mAXlE4bUMk3Zm/j1ec4DnWRoBhogiaKXQJTCIXj7OEdCHElgkYdukEasiFQ7OEaileejUEb8IEfNNy5bP65OBwh4tASnaPlVl0Trffnu8EbTNENosAGNCAEEA1Vfx0NmsAD0KoBoT7ZO/p9p761n2IPFGEzkEEX1NazFuESLiETKMER+AqUH4ESMOEVWMETVDnt1Z79pVtIudxdAQJSrkp1ACU6SAgQIUiVGlaaNKmhJk2fUoXKNAnSo40cNzJShKjQwUSM/0IJKzYJEKA7bJoAaZIEB4wWIDhYuGDBgoQIDRosWKDAgAECBAQICBDAqAACBRIAQDpgwAEFDDQs+tVMG72t69p5bedOnTp4ZN+ZNavuXVqz8dq6dQvPnVx39vz5u2dvHz9++fKRTdfNWLJ1+9wZGzXKVDBr+Pjpa5duXLh06tqdK0du3Llz5CiruzxuXDlzpM19+2YutORwrFlLDk06nWx03b6lOyeOHLlt3ka9iaOkhoYOZbQY13ImDRowNy5QoIBBhHQh1KsLmYJ9ynXt1rtrnyJJUzFr0IoN03XJ0aFDjhxFUp+oUKFFjyJR4sSKVSlHixAx2hhRJg89AgkjiP/4UYcaZKDhQxluxOFHH334QeFCE4USyiefYJjKJ5lksskmD0HUESSQgJSIIowk4go0yhhYiB8sgcEGGE3kcIMLKIBQggc4SSBBTz4lQORQBCCVlFICPAXVAAUYcMABGrzRiC/UaOPNOlqu4w5Y8NhjT1lqkQXPWW31hSaaaclVl133/LNXmthUM40xzHRzDTGjkHKLM97441g5gg5ajjiblbMZbuHgJg5ruj3aWmvdTErppNxwU+mk89Szjz9qyUOPM4G8AQccWVBBRhlnrKqcGmqsAcYL0H0gAnW1CnFrd7ruSp0TetACTTTKDIMLLa5sQuIj7S2rbHuUYHQIH3P/xOGGGmZccQUZdSTSkIkmJhKSSirJJ5+44opEYEYaTXLJh5yU4oorngg4CYGQ1MvIioVUIowmhUx4hxx3gGEjEDjoaJNNFlQgwQNCDplAAUpOvNSTRCagAFUMOOCABjQccks0W9FTDz52nXzyPvt8CU8+fL1FJjx6mfXlPSXb9Q+ce+0lDTPSGBOMMcsYY4opxDhTDT56EUpoopvlRo44hnL2qG6RhkNOppN+Q+lp36CDjjsq2yOWPN7M8oYbbsBxBhlXmJFcGmakkcarchhhwgcYmGBrrrzaKsQMu+rgBCTIRIPMeaxYJGIllExCCSX2RU45JY8sAsgff/SBBx1x/6hxRRVllFGHIiNChDrqlXjLuomP5Asg5JFHggkrtLwSryul0MuI6/kaaGCFMgbMRksx3dACCjvaVMEEEzwQJMQGFEB9URNTb8DFGW/swAPeTzlKMt5sdTPKdu3jVzwvx5Nm+uyfaXM99eCcsz3/6IMNM8k0M8sos/gyC0v8ghh24sabELUZcwgqUWaR2tOcNjWmCSprXtsa104DNrCtQ2b3eEc5xuENajQibXBAwxlCdwY0qHBVKTyDHNiQhBeU4AMn6Jt0bmidGejwhiNwQQyAAIY9GEITwlCGMoARC1WcYl4OQV3kLgFFKGLiEpTgzyIOEZIIdU4NynGDCvvwiP+HdAsiI+JIJDRCoI5sJBKTw8QpWHEKTrwLXq7IBIEqoUYDhSRcgOjDHf44I5fgoAbI29EGFjYBnTTMJwu42PQkpiTsZS8oDKik97xXAQ34oBHE0Eo95gGonInSg29pC1ncpw9T3iN+q/QHnPzhjnp842ejCARi9GQJo/liFMZYByjRUpl2iOUs73CaMTejls8YM4PowGAzv8ZMdNylTOPAxjaC8YY3zKGEJ6xCClf4zTPA4YVgAIILTKCDwN1QcDHQgR0GIQg96EEQgpBEeEJBC2Ho04jFEMYrSuEJT4DiE41rCIg8UYpTpGKhqSgFJ6AoOUe8Llycw4Mf5PAgOLj/oQ+JuBdFPjERD31opCAKkUk3oaGFlgITT7xEQFPhiUVMCxCs88hICqEQQFDID3m4QxvEAJMeGKwGNOFAwn7EEyH9JAFCoZ5TnyQUpm6Pe5fMJA8CMQtqWIM36yiZPv6Rj7aQki/v+BJb9JGPd9DFHqvUhz74kbN7zGMd15CGLxrRiP8dwxeW8EUykuFXfAhWTMSERzyG+ZZinmMtxBSLY9kB2S2tgx2Slaw/+lIOa1pjhHOYgxuSYwYzqIqF31Tb2l4oBjBIoQ1ScIITxmAHPQxiEJCwpyZCIYpcnMSIvC0GMGhhEQxlCBQD1dCG4kWLXPSiF7rQBS5q8YpUgOKh/5HDFx8l1Ic6xEGjXoRDHxDBEIqUlKTkxQQmOMFSiD7xWZugRCHcQAYzLKgPvWPdSPhIiITISA5r0EITtACEHuAgeSjgwPJyMoGdJNUnQRHKIx08vewxQEgPqGT3HlCBEJABq87Yqjz04Y5smKOsLeOHPeTCDrmUuKz2yIdbX/zWf/ijrsxgxix+cQwCriIY0tjGOsbRDlHGjJh+YUti09KXw8LslJCN7GTZMY8oR1keVAZUPjK7DWNk07NqMCEWkMPC0anKtHGQAx3wgIc85GEPe5itIRRhovBMpBK3TW4ugAGMXeDivJsQEJ01cVKKhCIVrkgunoGxXOfeTrqcyP8EFTMCI5X4gQ91qPR2q2CFTFvhDAVhCEqNO9IoVq6llNvEI/5AhiCgKgijcwMgelevAikCXOXKr07xQE42fMElPbBBC36dvJrkRAIUAFJSgaIApjrYqQ5OAAMWwICoSEVjDziAA4IQPm3wRh7rQAc7/EG2fMjlK2k5ZV/6AeO38gMdPzvG/ogB71X4whreqIdb+/EP+7UvHmQBU5hKeSY0tcwv5s6HlKlM5U3Jb+HyszI2sDENSwTBs9VKwxOwgIUsnCELHOd4abcLhzjQgXN5UAghBmEIkrzuERBRBJwrkQmElqIUlyBjEw36oePSgha6ODSemRuLVyxxihCtF3//whUhSk/Li6tSoQnJAIc/JGISmaiIhjzRZyhmghLqheIkCgEHVJUhCD7wQRDQMLo5gPdesr4pIhCh354KLA5i+EISetDrXtdAeTW5AAdwokilZgzCAngqkRTQpCdFKQBROkAIGrEYLHmjG2BRBz/KDQ/HljUf+8gZul0m41kmIxi+MMYxcvy/ZPCGHiZzpT121pe9wIkuqwxr+9AE+/bZDB8ML1nvBWuyf7xjHNdIxhuCUEI3pOEKRcC4FbKg6Y6bEA1kjkOZ0SwwCuWhD+MqRH7xAIhC+GcjrfOWzWFeEVfkYhc+x7OebRELVkz3XZ4ourIQQWuVSKjS/K9DqdRW/wbUNwd/cAiMEAmXsAlYFyKO1i6UwAh/AAepUgapRgVU8ANWUAbeRH0cdS/4Ai6IMGuGkF88lWbEUzA9kAQBRlQo0CMlAAI+okiLxGDKBklPZQAAgINQUQADABUHsDEdMAeykAxYQg/zYA5hwlY2Mw9NFmW+Rz5bUQ3HADTydgy/4AurQEDWoA1buA3bIA/4YA6w91b58A+rVA+1J0oy5ibmYz6813sL14TyA0qvdDZmJwdw4Cpp4AVfhgVWsARKsARLkARJ0ASBaIhLYAV4h3eDCAQB9gNKYAVf9gVpsAM18ANxkGZ+QAgVoiL/US8RQWfp9wq40Fy4sAu7YAu4AP9/rUAKpFAKpBBQD0VFbLQRjsAIi4CLb4cIKqE5lEZp3DWBqBJabjAHfPAHgICLfeQGFagEo8VCTqdCZFYH4KUuHvF2OBUheYAHd+A5JpQFAaZ3LcACNbEBCmMBzhMk0QMUTPUkBUAU72gxGsMxDXBJlzQBmfQGloAMqzcy/diP3uAN26AN1mANzfBXwTALs3AL/8MLwSALwzAKjfAeeNUIlvAMW9F58fBie2EXC3cPrrRKH7lKbHUXIRmSbviGn6Rw9WA/OVMP2hAIZUctefgFx+GHSoCTjdiIP/CIOLkEitiIg9gEj/h8KSQGYqAENGADbEAHJZdf+UUSsGZQKBX/CoWGC6R4isvVC+8Hf7EQdLYAXa+wOKcwc6UACp7QaO3yaJHwOrmIdNk1B3VAcfBFBqhCBlVQl0FQBc04Os/odKalNtZXCLBGIiGREDpFcnK3BmcAE0oQjuNoYMJ2jkACJD2xVBfjju/IFAYwVRszYQ9TjxpwVbIAb77wC7+QkKlpCRQZCHgVCK0ZCaNgCZYQm6sADLzQC6oQCJoDCMZ4CBVJb/jQDuPgGPrQD/xwFx45kmASksyJF/4GJnAoZdIphy2JD/RgDGTAAztQcXRTk1rgBVFwBEewkz8wiOeZBIGoBOfZBAQDBsiRBmsQcmwQB0vQAjawBnngBzklElIJ/3NUSWg8t5W7oJXLhWjLRaB6doqlqIq14KBhmR+LA1BoSUXVxZa3uB44tTlKR4yepUJlYAVKQFrT53Su4kVrozZ8MHUZMQm0Vi4Ron0BswYmtHE/EI4E1ncIdo4JZpmXGTGZCVWcqTGVtAAPw0gNMAEZEAI+QIx88JpP2ghP+qTrIZGWQAqIgRi/0AuyAAyR8JrlggiLEAmNsArWIA3egA3pkA/9cJz7ED/zYJJ4IZLQSaf2IJ1NiJILZz/+QA/aMApBwAM00GVyU5MZFwVRwATkCQQ+mZ5N4KiFuARZ0J5fQDBrQDdqEHJ0cGZwYAb5qRAqFxGeQGiFljvxMoo9h/9o7TcMB6qVBIqgu+BcVymrtRALtWAL8PcKYtlQAoV1jvY49fE6idAfh6Ch/UctXhSNydp0gLk2cDAHgMBy9QISIYFTksZTARMH9IkGWeCYPVADRBVsMJgTCLYTD9NIRQJhQpEx6/oT7bpURQokFlATRbAGfBAJrxALrTAKq7AKshALsGALsGAJgYAJpMCvpsALuDAKw1AMncBGZ3QvlWAJmBAJvNAI1HAN2ECce7EP9iBl/lZkZEIzMdMX8aOScaiS1fkP+LAN0RAIPMADIYAGXLSHzsdxf4iTOeuTgchxkPhlrLIG1tdZdcAH+7mfhABnt+UKr2ALuqCVupAL8cL/UKNooMNgtcWAtcQQDD/XC6l6oKd4lXomq7IKtqrYlbmaCmSJluflaJNwof9xi9jIOXVwh/+nNtYyN9S3Qp9VBnDgBx2lEbNmmE+pU9cqBy/EBlrwh71mA74WrkY1rpTZAOp4ro6krkFxMYeXMQlQpD0hATcxuRPQAX9QCrqwqrCAoL1ALOuRS7Kwr6swm7JgC6SACZ1gCZQzm7MZCTwwCluFDfCwF2QxF2dRZMQ0sgWnhNMph1IWZfaDD95wC4BKAxowN2cQBRyXaYaIkzzJkzobqZumQvJpZnjAB8YYfolgLxHxCeqnTz7HXFCLO6+wc04LDAyLtcWADMiQtcOw/7W/4LWtugu4eYoDnJUDuqDN5Vz/CkcJZZZ99jhGxx/lon94YGkaxUV563RnUAWs5irTSH4rYpjyQbh+UIIvhAaK+4g/MEjh+oKAF4PlykiVm67M1hQY02BU0RMPMFUdQwUyFQiIhguq0AqmwAMViVe5tJq2AAy4EAu067BstAjtgYswO2+UByfxcBZicSZuoVjG+w6m5LHMe3AIF2XuwA/4oA2NALMdoAFkQAZewATfi4jQh7M5SwVVgC1ngKlucLgWRQjidxAsF4oZIlyFtnNW2Vx41r76pE9Xi7/5C8nIcAzFAG/BEAy/sLXu27XtZ6CcbKBbeav5CgvRBVC+Kv85kbAi8VEu2VVpFJeHywqJVBAEZqAGazN+wbpHiCCCtrZTcscGG6cF3NoDhYQCwfZ3OppgMMxImUskTPFUiydtUnEABtAkU7ExFeADjwAvqdAIcxAIluAIr0k7gUAKefZPn8BGjtAIh7AIu9lH0/sGx3AN7LAXWJxMa5FYDJTFawEmcwEm80BlWoJw8sCnx/AGPjC9bUwGX3C9WZBxz0fHS4DHZJAGcEAHdcB9/nEvmcAhperRfWZQFNFQqXCqwMDIwmDS+nS/WBvJ+TvJWau1ltx+M03Tqvpz71cLsLDA03UJ73E5B0EuONUHfJBdeJiHYuYGqhYEehlaaVAHg/n/Oh+hi4mwyyPsy2wAK984zDXgAjmyIzkaucYWwzIMj8yGJGcdADnYJANAFQ4QAnxQCamwmpGwmmQgqpfACq8QOQCCi+txCJmjUx2wpJYwPnqxF24FVzgDV4sNJ69kPjoDVzlzMsAnWPVAD96wCtlkBlXwAxiHBVdgHF9Qk3GDqReN0eLXO+iXCnaWC61tLA31CQoYRQ5RdQqVXL3AyK3d2ip9v8jAW8rgIpJ8DJEc01o6wAjKC7dwq7eKC7wQwLzg3ASa3LcAC7FgCvBHCqpQf5bQ05EwCfzBCPKxi5VGB3KABygqN9dyBXITX9diBqYFB3yACOR3Ii4qwhQCSGzQ/wZgIAaDeDA74gHBJpnj6jzP4zCCx46P5FRRIUmX+2xECpoPkKQ70AeQsAhuGzm2mDr3QgmOgwjEWgh/rRIV0AE88AazUG+uxA9surINx4b+QNluaDLIaRfAJz/+eNmikk1XIFQYhy1XgAWifanyedF4wH39GRGCFqA7Zyy5k6tMbmc719qbfNLCELWFplvC4MjD7dvKINzDfXpSqLVaupXNDd28sNzL7dxnvubPDX8AG8StyN2RcEVR/F7lWwh/QMF1gGsaRTdzcwVU8DbtHV/VwkVq8NT1lS8uamuAoGY9xRJtsN8peAMsaAMrWGAJYwEZ0DzOI+EH/hPJViRPZf+DUWXDlQThP5HDE4ACSkCMdXCMx/gIe4SLi9AI7Sylf/CaGRYCJk4M41MylT0yMW7jDIfjWwGQyQ6QXbiFzpDZb2BCeJdpVUDtoK0FQy5yfC4h55vadIYhWK7bd5bSKH1orW3Sup3SrR0KE0ER6peqjgzTxFAMxgBv9X7JvZCwV5nmobzcZWuK/86VtoAKoDCxPd3TUdyLxahdGnW4ZxAHadDealCBVCBfodXeoTU3akAHgABnnUit1Vq4FIJmC0EIa/CHySNgjrs8RqUwnF7gz9Oj60iDpN5smuuuqn7gEm4BLEADPvCs4vcHnTWlgfCbjeAeucsCS0ADvR7PAHn/2ZctkFgS9QQ5Dc+gP8YANKQHQPyKGLQ5plEaCHOQTWPvoQZzA4E48ZhmBUA+N/FpfdaH0eGHfyoSsVW3IYO2UB6dO6Oq9xYhCW9mInGdC6+AqlZrtfVeyfZ+mgiq76HslbGw3LLK3Kbolc8FsKigH53gsA+lHn9QCL4YB9nlA0ugXVykahSvaj8eX26M8bRcLRtFEp2oCPIRH+bSR4hQlZ/gB9t66SkYjsrDd5C76TnRPDLYo8mWrgrebOyKbJ8pJAyASR7DB5PACa0AC819C9Dtv4dm+HKQBWwsmoEAu7TpmoHAB9mknTBLA+u/9Brg/u8P//Ev/zzgxmegkzXw/4dLvdTei4hfpgV9CBBl3MSJI6cOQTp48PRhuLCPHz+AJEosVAhQRYyFECVKZNGOESl2ACmapOmTK1y7gA1jCSyYy2DDiBEL9hIYsF67eO3CZctnLKC2ggoFGssWrqCsUJV6lQoUpUiOKFF6lAgRnzp13JRBU+YMHDho4JDx4SMIlbNUfFC5coUMGTNpzMRVUxdOHUCJGD1ipMhqxot/JuXKRQuRHDRLfnxpAqQHjhsuWkxGgYIDBwsWOGywUGHC5wcSIjRosGCBggSpDRgo0Jq1gdSxUStQwMA26dMMHOyuQCMSS5bFigWbKbxY8R4bKlTQ8IaGDw3RNezeraHCA//qux9gz+5g+3fwy69/32HFSpIbOW70WKIkSJAf8eX/UFK/vg0bPZS0X6L4R4/47KNvCSrcQ6IKtuZKQw033IAjjjr4eKgPPIiYQQcp8iCEpEo+SeWVlHrB6aabgGOpppty4omoooCCpagXY3nFqFhYAQUUp0C5hBJHpJoEEUbimAOOM8oqq4qtyoBDrbXSUosKKNu6QsE0FgSrrj422osRRDKq6BBXhClGGEYOSowNMZpIwjHIboisBRRAuGzOzDybQAI8RyvNtNgSWI21AmDrMwHabGPAtEAPMLSBCvoQU5iVjDPuGEqLQSGDCSrI4ocMrlsOvO5CFTU7Qw11wNT/HvJz4QYibqhBifn+62HWWefDb1YB8dNVV1prLaI/K7DQ4gw11jD2wTjoUDaOHJo1og0/NmQEEkou8QSUU1h58ahdevGWRHBx6ukno3w6alykYkEFFlVI6WQUViLpZCpKDllkEkbg6AMON3yoAo4dAg7YhzmCKOsKH65AKwiF2VL4iirOQOOMMxpkUA06gGRk2o40OgSRRXqBJppiHvGDDjmyoCMONLTIYgkgcHjMVTjjjPMyzjrr7DMJHiBtT9pUc+1P1Qw44GjUEhBAgAEUOLqBFCTJRRM8enAjEl2KQQYZSrc+xrMK7qDjAQYqYOCBTpfrVIMM2hZPPFBDLbVU/0UfaKGGFiQD4QYbYu111iLqi29XAP+rYddb/+6hiF/NC/aMuaascg2C1oiiMSDYyCMiQEDe65FJLrkEk046AQUVVlrxCRdevk2RJ1xixyUnb2v3dpdW2EVFFVQ6iWRHqRZZJJE5AAFrhx+CCPgHGmhQ3iyDqdgByvcWhouKuazwiuIFFxwIkC0ZsSqRQ+wFRhtoDCsEDzniwOOOONZoWc01Z5YMBcrkxCwz/nn2GbfTFG01gUpNoIx2gD8FgGkDKMACKLACJ4zhA6TZDg0W4YpiKEODykCGDcyQCDxsIDwsaN4OaLCDGtSgeSxgYQtDEIINxHADbXPb2zrVthjWYP9WQHAMrgoXnx7wkHGLK8IRGFef/izBCv1JQhOdKMQjRPEITGBCFLzghS+k4QtYTIOxCiIHOSgLZWFcCOc0wpG9QCIS1eLEtbJVClW8whbdElGJgLOSYZDIRDV5yS96cQtYoIIUlojKIf7why5txQdlUKEZ6iM9FfrgOc1L2FqMRIW3vEUNE5OYgx7khorhRRGQmJb4rLKISPRiE4fggx8oJIc7yIENE3vZD9iEtxaAAARwklPOLMAZO01gOz8zTdJiQzQ/vQaBsIENAxKwAAyIAAIQiMBoFkCa3YTgDZQAhgah8YhHACI5yvnO3UzoAxSmUJ0pJGELWxjDDnRAhhv/gOEG4rlLWvWwVoXLJ+P8ybgo2ieJ/aHfE4FQRClGkQlTrOJCq2jFKnWRDXEAy4PoUAeH9OEihUAjI9Y4FUxwQqSgKEW2jLKLboULj8AhxnGIQxMUeUsVhIzEIv7Ah0L8oQ91kB6nrsDC+nSgAiEw4QZ8YIYdHHVh7zkLsRhU0bqkYSBgwQsiIKGIjXFEeOXrEiD6kIc7KARls3xZFhqDAxvgDX+8nNMGNrMz0IiGmKc5jTGP+ac/0aYACYiANKdpTdMsQDfVCcIhagENV6JBCTtgQQfa9oAfmPA56NyBDSqLOPyoU1frnEwLWDCZz+ZnPrSS1eJ6kIMhIhSgCWVt/xPox0PYxtaJUmTCmpLQmNtqQQtfEIP83PBUIWVFQhEpBCG6lAjheXQSk6jW6DyRrdQZRRe2A1dxjjMTmswERbhAxSUcEYg38AEOk+DDDqoQsBY4NgM0YMELQ1BCg7kFSvPFpFMvVhc1VKyicJgDXqY1Si4tAhGHqAghCOGHzVEID3QIi8TOUMtUHQ6XLJST/ur0Gf/975rFNCZe/3SApjVQBCJAADVLUyjb1EY3D6jADvighiWW4Qd4A0EFOuCGFpxwB4rjca8Ql6q05gdvNnCMfEgrK8Y165+sZbIUXaum2MLWtk2kIhXV5NrbNkG3vBWDxNDQoAf1tw55eAggDP+MEUSkWS+PiARzLyHSa8FxRueyBS/wiF1iGMMYeKZJHncRi1JEIhCBuKkbTsiCDNSgAhlAGz2bN1ko+WAsZMAkXBSEBkxjmkEN+jJ/KSoHPygCnHzZmIDTPBFCAAIiCmlf+1r2MlqhdcItxBn/LIBhYf5srkHr02qWCU1plrgBDKBNbWhztBV/JgNiEAMbmiCzFnRqDWdgQQ2Q54P8kJaHPeCbm9o0K8TpsAdD/tt86gO4fxYBCEgc6ECz8LIlPHlNUXaiE6tMxSM8+clb/sKwvKwGgiSrv8OFyEYrshEtgXONmRgdJzrBCWwppRWxuMUtePGLl9REJjORCU5yYgv/VHgiE4d4AxzKUgHvHOCx9FThwNTSASo0KJOWntJ969JpghikDmDBA5D48gi/cKQjZu5SqhGsELHJQX4vU8K2M9tZz+qPMxfo350ecCddm4bYxzyaAQhAgWBTMwFHO0CxFWAAFTcANG0AQxOb0AMOZIANckBhwODjNyMrLj+VFdiO01qr/DDO3EpAtz/3w+53t3ugWJ63bOvdhIUyNN/63rcWtPzvB1U0uHyQEEM0ahE/pFkji9hYVCJx+mqRrnSdIIUpWiELWdSZjr+g/TBsYotWsEIVtEhFJN7gKds4oAUizMAMjdqBEChVLg1ygxng0vwFqaFKNx9I+wpSBzTI/+EuGoPEJK6q5o5YxcCqdiWCY8kyl1me8BFOIWj1xwEP7C8zuJYrbvZUtAMUoK8QQAACIrCAD3Ma2kC7YmMA0rgDtssCG2CBJVgIE9qBFtixH4CeILCPKqAPgXIcr3CQgaMIRKiC/li/HjM8DNyPJEq8JCqoKjuCxpMyIJgtKVoiFFwCs9I3MLhBMECDNYCDpwqzrFAWPMgDOlADOaAQM0Ku4SG9NqOXamE9UkCFVlCdc5EdXCCRXRCKVgAFVniFUrgEOLAOlHsAEMAUGyOqICAqtzADNSADN5iDOWC+35I+Bdk05kOWsBALNwSfNCIlNdsIjkCE8ZOIVYsl+RGDL/9gOiB7ujipsMvgH7DBsP9pAJ/hE0JRgAUYsf77v/wbGkFZGgEwoKORn/ogA0CYBEAIAriAA2WJkD8IhEKwF9IDnUmohErIhE3wEFdwBVqgBcLIhZsQBmFwhTNQgisoLXQ7KCIKHAzkDxMsKyvIAiaAPCqyAiagxiQ4gsUBgiPQRm28Rm/sjxlcgix7shv8ghxcgwXZQf7qr4KggyhwAAAIAAawgTiYiNFLOEiAhEdYhEELhDl4g0CIBFIwF4K0BZzYBV2IBViAhVaInVIAhU0oBBrwFE95gGp7L/OaCzO4Ag4cEubDL5BkkEwDszgoA5Nswzjog2nJR33sqI3xC0D/LC5V+6pYggNZoiXFoJW0qhkQuBk6cURI/A7coA0HQgABIAAIaABAaY2hSYAAUKABiMqofIs5OIRMoAVX+ASSSoVc7MpX+MpXqIVa2EWxLMtaoMJezAVd0IXggIRZ8axk9Ke4TLciICKFKqJ7Y4InqAK+5Mslag8k8qdoLKh6G0d92y0waDbKoZxkAUI8iJY8YAAAmMx4DIAJSIM8wKrl2kxI4IhIaATw4gHR5IE3aARViIXZsSM7EgaWgIVXYIVS8IRSgAQy2I0DEKYwzAASiqwliAMzyLwvq8PfwjSK0bQeDLiAA6OE0Ivu48xECDrRm4g+4AOU+a1ZerAlALdU/6EMy5iTt+qMRQsmoRxK06AACpjMAIgApSEApmxPQanEQoE4VqAFXMgFXNhFWhjLsdzFGQnLsowFsyzLnoidXVRLXGCJXOiDt6SBuaRLB10tI5qiJ3gCvYSYvuzLJQDB/TCiImK8wpS3J7OiLzBHNjAWE23HhNgcC6BMyhQADsAPQ+AL5CKwM3IEkuOB6AiB0ewAPgCF6QIGYagjPRoGLGQFT+CETZgEH3CA5WDSCYgn+FCCMwCjPoCQOvDIBqGo4ZwYNKBDMAOL5EQIOgCf7qPFSVCEoLOKLqmImcSDOgCjm9SCnAQ3tdIlXWorC8iAOrGTYfoZn4mAExABAiCA0v8ogEFtT/dcDbNjgLPUBVw4S1zQhbLMT7ME0EoNULGkwvuE1JWoBCuIGc96UFFdsgiV0Al9Agu9UL6EmP6IoiIqTCfy0CerIiy6wS7qImMJoxQVgwFg0cmkgAtoARugAzLjg0AoH2QlORqQDtEMAQcYgAOgASoohE0gjLWknZuwBXZRClAQuUjIgANg0gxAvgzYgTZ0g53iAzHDigaZg5Xhl5sTC36BQzDNOYq6V5XczErQx76ATjUFPQp5JaXDzvrZzs6qjDvdjO9cjgwTpr4KNvM8uwJCVE40OwWInbJcy10IUFsQS0vFVEylQkeNHZUAhj6wgnGbjFFdWQ6lrSr/A8G+lBIp4cvImyLKo7xYhTwrqtWIwtXGfEwOeEoWXYALoAAVsAEmoAM+aMVkBa9lZVYaeFYGglYHyIA5mIRUqAVb0AWh2IWF5J1TAAVSIKlJ4AEaCAHdJCEyyAo35BeG6DysyAowqqjfoqj9QpYvQpmC2Fs8KARIqITl4td+1QuYBL2IML847bfGADJc4knvXFjPYLE7GQEhIDEIoIAGGEBmWspEPTvaWJ3YMZfQHZejKEhzCVnZWUtdQCmVyIQqyIIeuJsWWFnahdCXjVmZrYIrwIIrqLIoGEycvVmdtaLd6lkvIiM5WICnFNqvowASKIEWWIM88Kp+HLQ3iI7q/9CAqB2AAEgAGJAABSgARTkbMogEVqiFWGhI3EsdU9idUkiFPyihGriCN1RX/iqEOTgkndIprBArhLDb/UJO6xsjBgOjNaADQmhO7xu1jeELmAREMzswClkZY6Gl9dOVg7VTqZshPRUPChACIZgmEfi/zDW7XmPKzV0NkmVdndAJ0jVdGBbdSI3U1WXdXvgDJcBGG1DZ2h1VDkWoKLrQ3MUC3qWiJ/CCy7lZw5zVKGhi3TLeXFWWKCgATxQAADBPDFCBD8iBMPKDCOG8NyADZ6UODcDRA3jKCVIACbCA8K1MB3ADSvCEr6yFrywKVrCFV6AEg9mBIFDXm4KDnKqIz/8DhEPiPIVYMDECYM2zWy9CiLBYg/bRF0aYRcD1PpYktcIFRKMDKzidNgijU+5cRJzJGQ6ogAsQginwKwzQk7kpNqExILw6SJSqHRbWVNkpXdAV2bUk2dvxBDIgPLQK1dpFAiRIt5b1J8kTYpkl4t6d0CjAgneLZmmeZmisMi2D4ijGgb0y1KPEAAwA1hKQATHIA4Xol2Z1gKPJJg04gMlU4wDg3gFYAAs443iE1gxQg0pwBcKgBQBFTV1ghT/glzkwg6VF1i851vKRiEJmiKxgW+SkW7BoZJvEVS9SlkT4WzO15HwEp754zr9oU1aTHy2wgqZjk52EOhYKAXnaAA//8IAZmIIQHjEKwJOfORRDceVeW40ECJdvqWVb/mlNVd0arp1D8IEeOAJ1ml0HLWbGIWZiRmYpUi2FoqJUjVkixoIqOGIK1S1q7upqtjItqJIsmhzKkQMZoEQBiIAPwIAPIAEVaII20ALtowLRjFoQC1fsncwBqIB4fIACiMqnJA3ufcoBYAAW8INPwM9a6AVJdYRDGgsC2yrh6ZFFQFZCJuQ/cCUJiVuHntfKYcyC4B7GhIM14AOrouRK1mh+ldHohIgJJu0zwAIoo9P2A6320iUPOIEpSOURGwHzFI3R0LBDqauchg0XWcivXcgoXO5WUAXnVgXmfu7cUe4USV1Q/yCD/wgcAMmCImDqf/JuJJjQYo5qgFotfDuCJFLVtgBM3a0CIg4WYdEt3bpqLcACamziyyneK8KiLILkFlgAP6FiLCYBYAUCMNAy7XsDHJXKA3ivEOjVALgABjgAFrvNKJCABigAMaCAACiAdxZfBdiAPtDnXiiMV7iEP1gEUoIKNnOEQkLoQyDkpdWp6bxSN+zsj1RH0pZovLXbPngEWqwETQBcltzoBy4uiPCDBVO6NLDv/zhpFgCBz7pTGUKBFEBlafpmCrAA4JZE4U4xXhOgWyaX0G0RhVRuNGfu6YYFb+EFXriFo1gEo9aP/4gP2iXmCQViqE6oKktvVW0P+v9ob/uG7/m+amGhGCzA7/zGov0ea2MpAg6QgA3T8plGARcwxzSggzSggungXgBwgOZh5wDoGQXIABA4gM04mwaQABwYAAFQoKdkGgNggBCAg0UIhcLAF0qAhFW6l0lwcahYBEdYhIr4A4og5OnEijng7DlQ5Ig+UeQMuDasgz5IBCHPhEww0yJ3YDU1OiVnHzhIg2HBAlhJWRbY4c+KcjmpAR3QA97GgDzNADwRjT4tDTAnbj9JDdWl4bUUXYI88xiRhTOHPVmouFugvTdfBVg4BTPIjyOo8/VLN+/2J6fWc4TKyz7vjz8HzAyFGMcxjzL4eJBHdEXXsitqYi6aHCb/+AK4EyYPcAEV8ABhFVYv0II1uAIeQOeoPAANcFa9zgEDKOwHKAIX8ABJNIAiMIB3HuzlHQCjUQAH6IA54AtNyIRZXDOPmgph7xF7KZ9CqOxDGLSbmnHOY1t3XRlG3sGAI22wGAiCqPaSmIRs977A3eiOLjqQlgOA48EzsIInH7e0qow4AQI9EITKFYELWDQ9nXd671ND4bA+SREVeXMWRqnYMXjMr7g3N/hZmIWa+IU35wVHYFBlLMFhJmaFYi2Mp6IMVdX21vi2qAKR156Q18Da/90q0i0kRvn+NpY0kAM8AAQ6wIEaAAIUILI08AIl6NLIclayK2Ma6FXpx/C//y6ANc7cEpCA5V36WK9+siubOHiEId8S0NmRqTi9qNhHAdsqr8ds/S37ORArvWX7tT+We10ZOvDb5arF1NborPpDgCAEyE8fPHL60Imj5owVJT0e9rhR40aLG3YGTREh4sOGDB4tUKAgYeSECQ8eNGjAgMGClgpeJkgQbOavmr984cRp8xcvnb9mBiNGzJixY8mSMZs2jVqzZcj42ID4Y6qSIlavYrWKZOvWI0eYMPH6FSyTJ0/IVkmrNu2VKlSqXIlbxQrdumXK1M27JEoUJlG0aOHL10uaNXHk0MEDCBAiSJUI2ZBDKE2eOHTg9KGyQ4MDBwcc8HijYcCAAABOA/9Y8IFCgAEGErQI0Lr0Z9kRHgwo8HLAAd4OJnwh9KgS8UmULiG/RImSo+bNF0E/JF16IUB/rvPhUxAPHjp05MQ5LAc8nPBxyp+PU6dPIsfEi0+KDwnSI0aKGCVCJJCg4j51zqPR0BIO4QAEEDeMMYggM4hwAgYbbNDBBhxYUOEEElRQgUknNbDASi69pABRRB1j1FHJLLNMM89EEw011sCojYzbeFMjPTfieOM22gTDQws94NCDEkr80ENWRWx11VZmmSUWWU8yCRZcba3l1pBTxpWXlnnhZYUXXvDVRBNkRUHYGojl0Qcg7VXiSi6uuEJLIov1wcchf/iQwQOdhfb/Rm+lmYZaAAVIsIABMBTQ2p8M9KbABI0eoEBrkxowAAM1ADJcJZuA4gknnBwXCSWTRPLII45Alyp11VnXh6t55MGdd7N+Zx4cbrhR3hznuVEIJJNUkkkm8MkHCSP1KYJIIfsBUh1CCpVxRhZJJGEEEGAMYsgUJ8xwggcgbMACCBxQaEFJGWi4YUopgfiSNjtuE2+8NXpDI7333ktPPfXg068///pTjzfUNBJCCzn08MOQPxyplZJcNenVk2QxeVaVbF1BhRJUXGGGGXKpBfJbbcX18ZdgigkWX18YRkcefiCySCSXpCKMzcLkogkjjBRSyCGB+FDBnhq8UbQGf8oG/0DSqBUqmwKlKXCAbL0BQBppsiUq22wMZNBHJZ+UUoonnmDiySWYKLdcJM6lush01f3hh9yu9hGrrAmZ5wYaucbBN65/QDJsJp8MW0l8k8yH+M75IcJmJY8AUocccKCxhhhigCHGHooIIsQMOaCAggcXoCAuuRdYkEGFGZq0LrsttbTOOvjWK6/tt9cozzz+AuxPv/RsswwPHbDQAxBEPtTwkUcggaRYY0XxRPTRW/EEFtbPNdcVVlxRxvZVePwxlVgOuMRacV3xZZhNlOkFy5bh4QcgzVHySS43vxkKJIcUgt3wFTiABoF4QyAGyAPcaC1QpwnU1Q7AgKmZRmuASv9aAhXlgA74IBGfcEUqQCE2TpgtbZSIxNqeAx1E8K9ZixkIQeiGhzrMSg57WwMa9gaHG7pBDXVIxNcGtwliAWs+9LnPI3IxDGG4AnJ1Q4wc2MCGQUhCEVNwghFw0IIWlMADLSjduDiwgQqlLl0ocV2HFqCAfeCjHjeiV47WWCN40Uhf/arHPNZxjWtUg17bkIUPdmCDIkAEIkA4QlWsAoQiDDKRR0gCE5qwyEZGoQlWyAJgsJCFSVpyCUtgQhY4GYUsHCELUbACE6wQBSx44QpPUKUqq8AEV8KyLOoLyxGa8IXCICZ+zZJZJtxks/xVAhKFqNsc5kCDDmiAaAVcZiP/RNObCqJGaUp7WtUcYDWrFaAACRAAAQSQzQYIwACvMYACHmCDQmSCFalgxStoQQtOYAJtyxmhqlL4B1b9oU58WA8MYXjD9IQHDmpYA3rCUwdEVEITnwjFJi7xHk3U51jGYsQrlKGMYuhiEpJjwx3ikIYr0EERkhCEDnRwA4qEDgQtENe4OpKBjoiRQ2OEnQJwJKOb4hRGMGoGM5bhjGg4gx79SqM3mBGMmiTjGMboBR944IMWYOV4QyKSwgxkIGphNatJEJOYsuDVr4KVq2JtAhC46he+VCxKZiHLWNZKyyZoAZcu8wMhEvEISnjCTcDIBS0IF8xE+OEyc+ABDULA/4NGIDaxBqSBBhg1wQiiZgCnWYmiSFMpAwggswKIgAS2qc0EZPMlDghBIErhTneCAoTImSeqVNWzFLZKn9qpQx12BYfxBHQNum3ZrAARuE2ETXCPM9UjSHWJYgBVGcOgREHk4Ic7uCEOhtCEJKZQUhzg4AYuuGINVgqClkIIpiU5yUgi4LoFLMMayCDGTIDRC/fuwhbyhUUrRmEKU6ziFrzQxhyBF4xZ3EIWNekFJoIQhO5mhapTqWoSrkqtsUIYrBKmJGC0IFYgbJV9gllrxZ70vA83eKtaAMOZXNYsu1JiE6GAUyg0QRxjAYIOxaSCD0JjiRvj2IDDCwFnnlnBQP8F4JmlGfI1A5AACYAzsxFYQDYNcBIGPIAKmfoELch2ttWOkG3RcdvPrHOdPsTNP7S1jHfMo1vLwE8NagAEI4Q1uE8UxzGIe8QpoKENakCjF44oRGBdhYdEaCIUgqBig4EAJBvUANErZWlLV1eSR0tgjCm5RTGQ0QpTvKIWpXCFOk/BCk6fYhSrMEUrYMGLa/TXG8bwRS9wMYxh6OIPO/hBdwM51QUrYQnUcjCEI1zhCVfYwlzFsJgE05eydPgsEwMxsctqpsS46sSMAFac8RPjYgbBBz4IhCksEYhDOKITzeQBuQurgT0dIFGaLQBpGKW02ZAGaQPoUDYHcGQm6wb/BBlyAAMc8IAtyMxTnfAUJUA1qlK11rU9W+FAxMyHWM3KPGhODB0Mc9BJuFkTmUDc4R7hCTtrAxqsWAQiVugHQItCE3qQghTAAAayPiQqil4pCr47Lkc/+kKSvsUt8oyKVrCCFq94BZzixIpTcKIUqXgFLn5xDXbszhvaMMYvauGmvqqBQD+Syq2FlGtNfp0uWBg7FsTq1V9P2NiC8cJX1N6XtCL7LB12UlYNdIQyFYYO0a0DHtTUs/soIhGB90Md4ECGGh9iFqPggQZoIB0+vKHGPE5mBx6wgQkUQACzKYC7F6i0eMumQ6AlDZIbYABCTaABhYrUBQkbCEx0AhSx/0+OckjlHEcw4oT861nP/LBPutkt4mSO+Bng4NtgacLF8jn4K6ChDFs4AhGI6MPJDVEJUYhCEWMQQxucCAYLE8khNlB06LzrxTBaIKYnqQUregGNWiy9FJ/4hIsNV5/qJCIRk7DEM4SKD6mPwgD5QNZVQQ/YQAt0l4FYBVU4hNctgRVo0pbQhdmdHVhNkled1dqx3VllYNwpG9yBxfM0ElbZnVc8wS0pQceYQRqoQa70XbTxWW29QRDwAB/YFw9MXggEQdGQQRAUVgjw2A60QOpVitUszbsZ4QBMAAMoQKIsQOkZAANYwAM0oQDwxgMgUzIFQSTIXikMHCdkwmqREP8JRRTJHUIi9Iyy1An1tZCsdAeZhUdC3EUVxMEjZELyJV8wGUdzRIIlrA0jKAubTQL2acIesMEa3MEddJ8YfAEW0AXyjN8VXZHplAsYjddJ4AEclAEi5EIZ1ACtdVfNedEGPMAEWAAL7GAyrMPvaANOWAIQssD4oYBEgMCtMSAi2R0TRCBd7KKWkN0vaonKaKBfoEyxgaDcuZXELFIT7FoSJI9VeIUV2MAOPITCPOA/0YHfAQLkaZsNYsLw1AAIZEAyhQAZvMHh4SANBEEI7MkDrIS8wRsFcd5uEMoCNEATrkvWBJm/OYC2aQAPHAIonEIqhI2nyNM8lUp9tE3+VYf//CzG3NjNG8JhHOAFGZQBHBRCQiVU4RDHcYxQRM3JJIRCLoiCJOiBy8DKHSQEHKxBGqSBFgxIzCFgKHbRhHxR+k1ABaiOTk4AIFTCBqRLeY0EklnABeCAFvxBMqAaPsgDHqlXJ/TRASLadykM8gjJEljVIB3BgDhiXmCBFngl2VVYV9LFyZjlF7RPJHGVWXiBWyFjW0bJIu2agUDEVXhFolEjA6LBGahBYvhBzwTCHPTgG3SCJZABCOQAdu3AMWGQGVABFfCAOSZTZzyADjbWNeWGZC1QAFhhAEjAkjWAa5jEAkTQPjoA0UweD5RWp5VCp3ACcoThqJjKztBmfvDe/8LJDUHkQTZeRkIYhhXcxRmcQRn0wSTgYSgUDiVUwnLYX/6NZMoNgh7kQUP6AcRNDg0xxBIUiczRJLmQS4V4xAaAwAV8gAWAAAtMwifsgLh4QBaRwHu2pwyIgR84gjN4Az74jjx0QzUcg8j5QMf8gHZ6HfIYUlZ+nSYhqBV85S8yaCUxqFmCSV+cjGAARlvKkoWaZcWopZhclVg9T64paFzVkBWkgXr0QSEkQu79AWG9QSQ0wgF9AAnIQAv8gNBASAfQAA38wRuwY2doABlkh2gwgBFGUzQZmegFwAKMUWYVwAEkkwYEAWckU2g4AisUJDwlB0KakO7d5grRTd3cDf/e3Bau1BDfMEJCfUIqhMJCxUdxjEol0AL2ScIezI3cyEoc0FBLYgEkJtoWocAoVggHoEsFiCcIqIAK5AAYtMAObIIrPNUB4oAMyAAOqJQNREEeLIIzbAN+MiU5oEM1aAMwmEEQXAHyTBXyZKVVHWgEPiCDfmWwnUGwVRiEGhuEViiTnAwIqoxYYRUzNtiHtqoWnIFLPmAaZCNjoMohvAG5NYIj0MAGlMAJ5MCPsEAL4EDpdEAHkEEXMJ6UFlDRLCsNWJM0cabmQRY3eVOhxERmBdnQ8EBnnCYNzMEheEIqnMIHoU2WZhlt5h7JdSkLfSnElVlAkWkZeIwcINT8sRj/sAwLbLpJzhgCIUhfsxCCnb7h5OzlnkIEotUAJY7LS03iBsyAETQBGPTA4W0QEvyRDeQAETRBtRYBHhDCIQQVPvCDP4wDNqDDNlhDJAQBFZCBxvzADpyqVYUYtSBoLypoyYRP05qBq6KS+3xBhILJl3zB1VYoXGZospVJhYnJWNBSVi3BVwlrGqBBFSyBGcSBmiACqvShsjYrDgKBERhBC3xBEUSGJHrReQIh0TTCAIFrAb2r1OSGZh0hAISTASwAAcjGAMAruX1GvAbCIpQCKxxda3ZC5mKp2jTHbC5C/ikL7z1kC23HwJLHrVikRRqfSIbCiilfJSjHJuQCSUpC/7YIXuPYJiAUBN9JDksyhBJYQZH0QHet1BaxQKJ1bAckahP0wBlggRpswQaZQRGkQRu0QRPYwBJ4B31Gw33+yzhcQzeoWuQ5psIEL4IqgYOJbVgqKBY4bfiM3dPGxS9K7dRa7clcLdZO7RNYrf1C6Ml47ZgIBlhw1SV5VayeQeWkgRno0F/a1SJYQi30gip02xvsQBmUbA+kASA1AQdIIgqoAAikjgA5wt8OUCAglgEdTboZQDcRAONGEzdJEKOABg1ELpQGQiQM3StcLimAgmseJAlNwmziR37YJm7mJpjSykqSaZmiQR1AwvylAv25WIrRwuyGwn1M1LHYR+5S3//uygF2ooFXLUHM1UCixRwLqDEb7EEe3EEeKMJAAML99IwhzMfOGE4mtII2CFXAYMM0wIhhBgEZkEH4gWhYaBVXhSiDqqD4oA/6PO0veoz7uOTU5u8lX/JZXu3WnkwTzJJfPMmuPeAlCWdhCBQczAEfAMIhHMskgIIEv9cEr40b0BgdHEERoEELjJ8LwIAKkMAFeNEO8EEjuChiWYIJp7IxeQZpZB67JpC5HkA0a0AIeIaPzisn6MIOswIqcPNAfhA8zRMlEFcR51/uyvHc7C4dwNAc3EquUE4NXWQi+JCKEc5I8pUkuIfi0AeyHHHFFsR33BZ2gt1Vih/xJl/rrlj/0dFCMSiDO80uLaTCFQtDMWwDv+ADPVQDihBD5A2yGTQEiJJSI/Xaq2rBq7rv+6J0/IbP1abBJmPyJYPBJuOv/8Il/0bSAIfgWOwaSEcLLq0BHWhHs7TyKeQCMLxapSFDMVxCU71BqcbBFR3IoebAB5SAC4RAB6hmI9jXKLgoM0Vej2WTNw3KAmheZPFGtlYzaARClQKD0A1dK8A1O12up2TpnNVHipbzwjHc3LwQd9TWedxKGVRBGaABAwNCei7UBt1PLoSCJGik4RzOPndxsjTk7kpOE+0lTFJSFjRgd83uZ9PCL9kMNEADzggDLuhCLujCMCCDN1g0PVjDMRDD/zdSAQs2xFZ9QbGVkiVlgViNXUmPHSSj9HB7DBZk8ky/dEvbL0tvLf9CUl9ITCg32IDkWnCqAZ6a6C4Nxwat9jAgtTIgAzBgwiLMwQ+gQQ1gFwzkQA7AAAx8gAuMXwjsgA8cQifU1zErVuQxFm6QRmYxrgKdhpM+QDR/BhkEwiXgQlvTQiwweCzAAizEAg8TpEFuLqkQ1yMEHhqKrsnVjXbsUzGdhxIMJ2EbbB8wwiZ8guwutospFHFwZLHQh7Eki3403D/jVg3RUBkrGs589mfjDDAIA2ljVCrgAi3oAjAcg2sTlTYcAy7wwQ5wjCPe3RFEKF9UwdiZEl/s9hVgwf8jN3JxP634gHlxXwFNo5IWfMEZ3FIaqPmau/QtZWj0eEEpMQEW6CLYhi0hUQVwlkGJqlkc9B0gLMIjREImLN17VRp4I8OiF0Mt/IEb6LLxgIEU6AAJxAAJuAAb9MB8XwGQWsIogPoo/C24OlUIPE3m/XfjRlBvsDrROEIqAENbvwKDy5d81UKEv8KEj83mjgri0Ad+SB+K/uuX0laxkwFwooGamUEVwMEiVEIo0MJ8tBj9zZ+wbErhRLav20foPuR2GERCoIGAdhdCz9+0K9RI1oxygYIlhA0p3II1uLYabQMyWEIfmQEXcMFamSCTIAGeuxUUPAEUCLwZhEEXcEH/F0CBwSs8F0ABF4TBw+M7vndBF1zBxIdPXHRBmLuv+1RtmUTBJmsgFmCMXHQ52oKdgqUgA6tBefglY6TozJRCLPSCdxdDMZTIoi96KQRCHagxCHgABmDAalhAD4DAMfkAC8j3GzTCp4/6soYGDbjjAWCWBF0TgX9GCMxBJJQCatNCLdx6rTP40FnuKXRKJ7ymcpCh55phIaDQCuXTF+8Tbe2KbeXQAnuMG5h4IsQBIwQaQq8p2Fj7clg4P+eHQHT7G7pBJoKlEthAzeFzMDFCjE9C5FcCCbFCMfSCJTjCJZDCLFBDvNODNyDDYO2AwUMBV2yFwAs86rN+w3NB6jf8/+m7fsSr/sPbfsRP/MQT8u4TstOipdv9vrE1gZfLRVsk7YAs2BKoYAuWx3rIT8/IDCaUwiu8l1Hb/DHgfM0DwyLswIR4gAt8wAVY64/QKKIhPQ0oPWIVjYH5QAcIjQNEzZ84UDTDq5QGQQ6/gi3sgtd/vS3ggi0ARK1YA2O9UnWqFChOmC5RojRpUqRHjhwtWoToYiGNgP784dgHJJ86c0bOiQMHjhs1aVaqgRNnUqhPoWR6KpXq06ZNmTI1hDjp0SNGjBIhKmS0ECBAferIwRPnjJUeNVCAMEQIkVFFioY+gugJEyZTv5D1UrXK1zV6/vDR0/YrCI8QXbhAQXL3Lv8UvXj54oXChYtfu3n/AtYLJUxixXW7mCHzGPJjM5Mpf4lyGfPlL5YxN8FyBbQZ0FeqVFlSeskSJT+UKCl9ZTJLN3Ho4AHZB9AiR5Q6qbIFixcwYsSMFTtWbNgwYJ4O7cjAogWKG0By5OjR44eNGj12dAhB5lCgQHwCBdHwoIIDBw8cHGCg/oADDfNDOOjw5hCmWLh6ERxoCxdcbBlwwIJYYQUVUDxZqCGHIgqqIkYsOkSjCjn6ow8+RKqDwzk8REmNltyYIxFNZPpkplBAKUWnnTKpBEaIIHkEkqESISorRJaqAw850lhiqqo+0USTT1KhxRVXaKEll1yA0QWYXnz/IQYZaJRJZpt0+GnLmkh42IEFM8KoSy/DBuNrrzIB84tMMgsDjAvFFoOCMsfIqBNPM9LgbDPNNuszCi2wEG20QktDrTUlUqOCiipg01ON2eigIw7yDlkkkks6uWQU33YBZphiiCNGuWFKWQQOH1o4gg0xcmjDhjSSAIMNOWgI4Y1F+HiDvDdCmO+BBzRITz315qNPAzLeuCRA/lqBBZb/CJx2oFdeYUWVUhYMiyGfHgzKxhwROeSj2zLc0EPa4FCDUjfqSGSSTGiaScEWdeIJxkpkhGTGGrcqyg88mkpDiSBByEWYhEMVphhgGC4GOYh/CQaYYpShBh14tvQGmTd4/7hVzjHNFOywN90sE2U14ww5McbyfFnPNMT4c+YvxLiZzy/yNPTQ1BJtrdErGq1iskjhQAOOOv4I5NKKIrGkE1Ni+TQYYqq2mmJgOnmkDyW0SMIOHMBoAow7mmCBhj8umSMEHsjwQQMaOtCggw4qYK/YY2nY+41AYmkYGGBaaeUV/2KZlsDDB2LlFAUX5OSSBn+aUSiiEilqows7OpfDOiZ1A6U6RnxXXhTnRTEne1/UV8ZJ+BVKR6agKrgGFkBwOGKIdUcGYt55V64YY5bphhx+6vHGlLhoyIBlOAcruczFVnbeZDgBa56LxupMg3vuY+v+5vBxxhkznfEczbTU0v//WYmggW4U0irKmE1pppnWjTdUYKF6uFGRUUYZtAAEHLCABy2AAQxA2AMQWpC2R5DhVhnIQAf2RgMf0OBYxjoWD3gQhCA0omIQE9zgCkcQxJ2wIAcpRUI4ATnJyQhcNrocUgCRFD+ERCS1iYNJ+JCS+f0BEkZKBU5QV8ScaGJ1EGEdvxIRsDoQMDstsJ3uIAZAZPjuisgYhhZ5VwxkLGMb7vAHPawRCA6GoAPYOxn1rHc96VXPeixLDJ66F7Pu3bF7X+CeHvfohc1MBguBDCRo0qc+07RmCVZQpBV+lkgrlOEHP1iCGUbEhz/MwZJNowQmaAGl5OgOgAAsxikOMYf/HizhC0rIQ+1ocAhHqAoFJeBABWiwgx14cG9z00AIbsXBNywNE6FChjGIAYtWqEIVrHhFtKQ1rV0EaEDGTCZCHhe5njiIcpVbBOYsBIgb3uaJJ3lJHdBQhjKQqHQpOpERXQSjJNYIEHiggxqy0AMbtACfyuidxaJhRSp6sRjQuKIylkEPfNSDHsHwgQ94QLcwpAF7Kmujm0RmpjWuTI558t73NnrHzeBxj3rUmSAFaQYspK9nqVmkItmHSFv2wDVpcIMbKDmHpV3qEaVQ0qeE+b//ibIVnADEl+Bwqx1IaAc2QIELOLABG/SABTWoQhAYOh8O8sAHfQuEJUgRquMU/8MWrUAFKpLZimZOqxfPhGYsCMeKVKzwcZzoibcoJ6EZHqWbN+RDHEZEEtGV8wyz+cMkUkGTIdLEsKdzkSc2ka9HEKJHaFhCdmpQAxsUQxjJCRwwcPEkXeQCScDYhSpIUYxeoGUb66CHNywxhzdswQdBeKjIFjOnOBmmjWGIXstKBic5hoGOsXnZnkDKx5B+wY96qpMgDUWFlaZGpYuEriMVqYXA0qYOffDIURjhlUt4ghWdTQ4xvPhTZyhjGI54g686sINCxKEDG6jABILVAhyAwAIZqAENPnZVDmZ1EZfQxTCs9otf3CIWqhjiKVgBrWhNCxe3uAW1DIQKUniiE/8LYYhDIiGRiVRkEYegUCFGnJSQhKRzI+mQhzBZiEq4IhSpSJKSYpwQFmYiIatLBB5QQjB7wlQJnmAs5CJBiU9UIhE10silGjGKWRCHGtvwBj2WMR44MMoHsw0ZRusSp8OYCTFdbplF3ZjRNHyPMiG6o5iMC9I9tfnMwr3CZ9BXBSpEV7rTbaRqFGWFoqkhDnXQ0B+465VN6BQXPC0vQY3Bu1tEggwd8AEj4NABJaBgAhVgQRFcIAYU2IAKDOXBejsYhPU2ghSgCsYvfMELYyKkFKdIBSsGx0wCSRiFsUAQKUCR4QVJrsMQiURFRFzszH3zNhpKcec8JGhGbMIVMl7/Uo1BgaIVvfUTmZgEIuSAhjWcoWCSnEoijrIVc+eBDX54IiYbsYpkSGMb8b6GN7whC17FYQlM6IEcxWzR6LWporjd7W/nCLMQrcSjId2jYrzghTB84aHI9QIgHUWaQzEqulhQpGqgi0iOTzeRZbhubXBz00VAohKHLsUrBtzTYR5nGLpwxCEu8QYa9KEGTrVBFHDwhRbI9A2mDsR61zt0Rww4ShKGxUEcF+tTjPVZhzshgQRkC7aqwhS8VhCDGsRhR0zEIhYZV4mVUi5w+pXFIynEJGaSJMOmQkEKijZOIAGINWBBspKUihQBsRVDGGIQg1BEHkASiCYT4xnb6EY4/6rRDWzEOxqNMAm+CxZR66Xstn9pGW//MvDNhwxmL4v4cffk8IY7PDF/8sKgTkpnizNqpRq3Ap8RqUjZkzSQiTSDSwKdoY4c4kYop0QmQPGKzo6KOBEbRi+IEYlf7qAFWHiqF55ggzic2hKNEM/2A9GJ5OyCF2y18NY5YZMVQV3qU29W1cX/dGoyiBKRc9CwHTEUCYVYI0hJCob6cEMOaUhD+uoPKkGdZuKtUqFx5m4TFKEOwC0LliALtEAJaocFBkEP9kARrqIoHGEUZOEYtIEe6sEfxgEbzuEdyKEbvEEbZuENyAkMkqA1tqxNqMdk7CLMLs/L/u22pidOQq9OQv+Ge1IP4lJPTvwoj8zHpAiFNJxrpRbpCI4AkQTJCrBAC6pQ9hLlka7rDTyED2oIES6HETLFE3yjF5IjVIYhGIiJd2LBEeYgKmyABXbgB4JAQwLhFnjBEiwhEhqhEcgjFpRDQMTqwuKq/Dzh/Ggt/QZk/XCBFxpxwn5jcBgHFDDBEihh2IqMEkDMESSCIsTuUkSMxPavI0YxQ5gNEI5sEkzk7YZIxqKtEgDBDaSiCcQggWpAikLAAv1gKQ6hE4AhGrRhykSwH/oBHsrhHM5BHNBhG5whEMjADdCgCVjDB8REetpITcbMBmdQzL7MtyYqeyiDDLpAHMdRHK3HjyDO4dD/8eEYruH4CLkoY1Amg5BiT5CYAAqVYAoDKR/1UbpKg1Hu5E5AJ7t0kdB0I1NAIbzKMFSCxxic4byKoRYYQQ2s4AdsqW/+oBFuwRSeJg8b4Q0cYReWT0Dg7nG4BRMK8RCjLhEJZBda0hGt7uoubMPiLywssciEDVzC7iKMTSk2oiM0hCTmgA6M4nJScRWViRZC4RH44Ed6AAzEoAl6AJ+kyLW2yheYIRjxYR7u4R744R/+wR/C0gTBQRt4wQe2wAzOYLKCYAcgSjFUBnoQo6IwD7fcJI68sQuu4E4K5QrK0WRQr+ESIzDDIDAb7glUb/UG6VHkkR41jgmYALryETT4/5GlEiUI5jDUgoAKyAAOSOKSLMUgL4EU9qcMjQMZHNIZrKQYcGESYNEHAmERGsEUeGEU8tASHEE8OqEXGjGsSkHDui5yWqgTzq+soo7qEq0RecElb4H9rgUVZE1b4A8TI4ITdQPEQgwURSwQPIIjesRz6GANCAESCGESKiETWPEVaOEVMgER5sAMCoYNohIH7okFWMASfCEZrCEEu7Ic3qEc+AFA+YEtDgof0EEFG8EHkMAMJEkJFkpMbisvDIMwyMwaKdRkxmx6oEAv83LOugALPHTOJk6PTO8JvACi2lHiVE9FXS80KOORzEkfl+AIOg4ftWAyV6oMEmWqPKgKdv/gOpTADNBgRGrK5BwBEzrhFHTBk6rESgTqiiDGEwJhEy1hFFZhFGoz+wIhElIBGGDyFDyhIXzCIRziEk6SE1bkFBiM1h4sQMAvOXsBTlvymazuWqYprmZy/j6sE3Wy2AKh7P6ADuRgUnokD/JAEVhnJnSKFlJhEv7ADargOrQACOwJn1ggBKaMHjJVHuwhLAM0Hs4hHt6BLTJVG7SBGF5Le/6oC5qn85CgMMZETV71yzDUjboxt54ACxJTUHZVC6ZQ5M7guMxgRAFpzgLpDHi1CrXAnM6AWc1pHwlJNQ5FWqugCc3JWUuDDKzVCrJA5IS0M7Nruw6hu3YDExCyFhT/srx+ShmuaBhsYRT2sBFsMxLGwxFO4Ulq4RXgbie6Lv4uYSc44ROcTplo7RVqAUB0wU0bEU7hNNFsQSCkCe5AYRLHtMM0ETvFQzu37w/4wLVAJw7M5Q7OoAfyAGGEASJoQkkyYcfgIA3U8giKwJ5sEZ/koR7mYR78wR7agVPDEmfvwR/WAaFWKxqcwRKC4E664BwnivMkqsviKOBqi8vepLe44PS8IFkFBQuyQGuZ9QzOEQmTUB7lUVCm8Gq5lmvLQDKtgFpTY86uQG2twG2tVW7PwJywdVm3NQuFVCD5oP9qCAyL7EhbAUBAxTR9KouOgRhuAUvDgg8xIT3zVVuu/2lyyrMSIgcTNsETApbB1PTBAOQOlXNhXVJA2ApbIBcsarIhOmwiHoH+JqTYMnY7RaL/+iAO/EALKiALIAG0DrU8aWISCmGe0gALlOBl7eme8Gke2OEbyOEcyqE/BXQejofepkwFk2EWTMFjwtFDqfAzmDYbZ7B6OO96ymxp4xIKqO8JcJUKe1WQtFZr0/ccDZO5ivUKsDZZzVZuFykL8HZ/+5d/t/UM3NdsmfVFm1XjFrN7AI1H+raGLGITNaU3bKEXCPcYjuGKKhiDjYHVgmE3bYEUGkc6v251MZFML6H8zm+syMo4Y0HCEi2tdgFxjIlw3qrXOgHDuOWaHMIrav/kcm7EdQthY0uOJNQADSqgBdZAEiShEiThclAuEfpADr4NSIpXO6ZyHdQBi88hHMKBHNJBHrxhG0p1Go7BGILhGIJBFhyBg0C0fstANOjCGqWWLm21BmnrZMw3fdOXpPbRfbOACUrUj+SXzkjqWKuQWa2LbpsQAvuYkbV2kRtZgOlW5Kw19LgH0GpDQ7SLxPAnU6IGFvgDDYnDGEZ5lJPBgpEhGG5BFTpBW2bSwyRkE3djTMu0hVaEFEjBFJAp6thUTiNMwiYMFl7BrFLoljvBEoQMcmzSEitHEZZCKSziD66MDATNMdyACq7AAbBgPA1BESTB3Jq5KeAA3HqAimX/tgVyth3aARy4oRvirVStARluYRVMIRgaMXD4oJZylTL7Mo7BDMy4MeD6uU32QjDymAka0/a09o8BuWrzuOGMNYAH+Gq1wJEh2X2TQEZldPZAbpHc2AcpYzTuBNDiYIcs6Q9EzIGfphNIoRVuYWKuZpSJg4zreZU1xZUrB5YpgsNK+CSFDBRIIYVVodYOZ/2SE8EAhK1gwRQ6ISz0kP6IDWP7YA4AgYl0BIgtiWOxGjYfQUcgISkzUPAMQRIKAYqjeHjJGWZtoIpbQB7Wwa3pLYy1YRmCwUpXQRZkgYpO4YJawAuigB/LgJ9F5jDGJEK1kY4vz3zPpC8e8zGlK0YT/ykLsCAK8hh+DRN+n6CNt9ZsI7AKHXmRubd/H/MJR3v2TMPOSkNt78SN3TjOOKoMgkYv78QxakrQCO1+phQTcFkWeOGlh8MYyNgXVsGYKaESOXEotmkoKGITO4yEaZkThvOWb9kUptuuAYQRjZo5ZWEVbpkStc9+dsVDtpBpHAESXKc8P8EQJXaFSoEVoKQXEqZJIMEP/m4QruLv4omvJHA1qHit4w2MrYEaniEZlqGMr6aKrEQY5mADbOcyVooMHKUweiux2eiOS4Yw+gLDGfugp2ujVSrfNJwJLuP2SCOzNZtZGZnDqdVtqRU1OA4JloBRYpwMNnMzI2MylpVr0f8ADaj1kewMyzTTGUkiq4t0k6Jmt6vmt4mJF0jhEpgbxEosKS5FN6wzKEiYIY60E7L8p3FZhf/jc3nhFmTBFEahE0bBFFqBFByCExoHFGZt1ohaF3CBSXJBF4Rhs+48YexcGGgBYPagDe5AD8TTEPrgDuIADR7wB3pgUo1XZrUBwJMhGCLdwCKdvCBmGJRBGHJhE3YgBDYgA6LgoBfpNVwVelzVnyecGy0cw1f9CBh7oz1Oz0a71Rv79kxbWS26s6HrAYdmWqnAg5QgCNonxv+xxiNDMn4Vx8uAx6ugNYJ9BxbKaJ2RpmbKpsZ7E3O7pX+BGI5BOWDBEjuRQjZWKOv/IA66YKpDDDYdeLmJ2xLKNMtXGpene7rJShVgQRZuYRbu2pg+F9dqoRaUdBfgdLN2M+B3QUndO3AEPnDsPBdcQUcI4Q7iEwjE4A4MwQ/yQA7iYA20QDUUfVLVurJaABoaphcmpneUwUoAaBjkPBQyoRAmY7IUSVpBg9QlfFbXREIjlKDLhNRXHcOfAMRVg5GmUFGwYAns12x79Vf9jG4XeVsf8Mew46m4o5aqvpZ4iQYsNQR4qT4tFW32putryZbGfgcsSzssq7IoEG3qk5dsqZbQxpZ8YDN5ZWkwhVNIYRQwoQ+p6mN2SdI4vQJ8oD40IAjMYAtPOjaZ2xKO9ErN/9wUVgEWVkGshPqYBkfeVwHzZWEWZgHz5d0UxLzzz3wVVi1KdqEWcGHGUsETeGISGCErCgESAnUP8mAP9GC+IV4X8+AO5IANAjg1Fr2KK6slJ7h3oMH49UkYPCESXJ9f6iCSrgPkKq7mSd2f6/KO/7nUfZ4vZP1lEanPip6RtKBlZw8L0uBFFQmwqVVrn35bOU6SGJQ1VqMKIumWlCCp5DDRK0utz/7+bckGXgogduywUaNgCxYhNmRQmCFDBYcPGz6sUEGDxQ4haPCgMifQIUeRLEUKxIOGxpIhePCY8+ePGTh/WH7EROoUKVOqWulsJWvVKlk9fQo1RbQo0VGmhP8qXTrLFy9fv34RC2bsF69dtYplqgMHUKE+fuJYQYPnTJYzbNoYkqSnzR5ChO4QAtTnjhw2ZpcsAdKjB8EWNVr0AoYMmbLDxYrlSlWJESJDfSZNKlTGSpkqSqhQ0YvkChIoSD6H/gylNBQuqE2DPp06terSqUfLnn2EiRUrSnLn/qFbiZUlt4OfKbOkTBkzyNOkMYMlDZaxabSssXIGTXU0btBoYYOmexa8PbJoWfKj/I++fW2o79HCRo/zPwbWYEE/RIcNFPNTfPDAgX//DPx3wIAHOKABDSm9EUgjIY2CiSWWdCIhJp2gwsoprLDyyiu1ZFiLLbGACAtRq+g0VFL/qxSVYopGrTLLi774EsyMxhhzTDLLNPNMNNZo06M1QCITzFW25BIKFlmAAcYdbdxxBxtAtMEGGGzssYcdeuxRZR5rAeJHXXGskdde6RFUUGLIFIOMMLTQ8gkkkBgyiCKD7AFJInAoUUV8Pmim1xVXlDYaaKSRptpsXITBBWuvsbaooKERGikSTzzxnF5KAKfXb7ct4VtlwXVKRRWY6dkcFlp0l8YZrKqBhhpquOGGkl+A8UUTtzbRhF/u9YWDDS2gwEILB7WQUAj1hWBfB/dpkIF/FW3A7IE87OADGWS8UQcffPzxESUUlkIKKq3cYu65s5gri06ywNKuu7cE9dOL/z7R++K9TcX4y4zE1FjjjTg2U8012xRscMHXJKywN9ps46M1yfACDC660FKJEi0YIYYUYwwhBcd2ODGGFG4NYocdbejBxh2KVIJIH2CKmYWnQPClnpnKFNMLK58wksgkkqwlySB17mFIWWeQV55mmlVxRaWQQjrooZE62qhqqD1KNWuVMsHEE14fUZvXYBfhm15o64Ypb5mit0QVzWWmBNuZWcHeesC2kAEIfOO30N8USYsffx3QIJAPQQTxRreFHHLIIo9QcoknoJRSy4a14GKLLr30ssvnV/HCyy+32GKL6KI7xYu5ot+CL4wxNjUjVcYkkwwzzEgzzcAGe0PP7//01IMPPt44rHA39vDzjjvuoMPNN990I/303RivzTK+yAIMMLlU0gMQJgxhhxR76CGFE3bsYQTHY+hx8hhY6nEHIHP5gYcccVg3sxI194DDrwXJRSZ8lohEKMIQQiNalt6CBr2URwk+yE3TqvA1QZlmNlPb2tVeEwZFOepRiQrDF7zwBC94YYRgY4LYylaEHgTGBplSgl/KM58a5I1YZuoBQjrwt4Uk5AEV6A+0guiACjDLJEFIQxzgwIdDMIIRj4gcKFLhCg7pYhfbA8YwtiiMLWpxe8HIIjCiEoyoQCUqv5DRLVIXozYGgxj9stGNcleNOjZsG74DXvDwsQ98+MP/j/4IJD/8MchC+mMf8ihewbpBDn7kgx+Q/OM85iEPdqwDHdD7xjocFo1gzOIquZjEEsCQghmYYAwrSJ8RhuAEI4yhlR9rn5WMMAg9+IEQebAf/vTnqSTwxX/qqYEhFEEIRUDilsWEBCHEIIY9KEJLQGhCFt5THr1MsIKDwmAGX1M12GTNNB1cFGrC+U1UYQELYSuC2FrYwr4UwUwt2IA86cOC+8jTIX5zCA+LmAEkkmEObtAWH7a1iEg4ghKU4EQqUlGLWnAOGL3QhRgnqsXZhTGLMyLj7PZl0dn5q3a3u500pMG74uUxeHoMnvCGF8iWBvIfhIzpP2b6D37U9KYw/8UHPbzB04Ktwx80/WM9hqrHSdIjkdYgBi86p4tKkCE8LyABBlZphBzAQApEIEIbwMAxKWDpSlLIElwIgYc6yCE7Z8CNEpLgS1+pB4GDQKAhjmmIuOShDXGiEg6AMDcluAc4pHIaoK7gtMJ6ZrCygcJgu4AcLgz2Cl3oAhYkq9gQipMLkQVUaH6AtvMM5GYIMomyWNCQDuxQWUcUyA40A9A5eAWKj6jEJ1zhClrkonODyWIxhvFFL26RtxRFo3Db2EaN0qhGtmvGNJbbIzyeVI9DjW50hwfIlrJUkDOFpHa1S9Pu1nS7kMxpPXrq0+oKtR6/my5RvZGMW/wCGLtIBf8j3JCEG3jgAyQYQxuMAAMcGEIPOWASIVKmQDsQbQ9+MMSXzIpWtfryl7+ywQElcUBNaGIQktAEnRRBYULcQFjEoqdBAFMDk+ygBTSogWp3UBAaEEvFO2ABDehjkmQha8bIUhZqmcXDhkgEiEEEMhDxowFmZeRaL+GDRwoquUtgwhOlSIWGXtEmXFBMFxTT3IdsYeUQme7Lq4sXUGThOlnMwkWvc+Mb/yVS3Q3sGnfkqTfkIbx6TPLOk3THPOxhj3u4g8/3CLRLgerd7oL30IVO9Ez3AdN6cENhdbzGN+YhaH/Igx7rYEc3sPGNa/yOGk6BKCfysIc23IAIYNCBEez/cAcrQYLDgxAGJJykBzntwauEeAsu8UCHu2gnC75sa5lsECc4rYVOclLEAQcRlxvY8MSAIYhJUGySapvY2jXGtmgzElrR1ljG2jYJDxBHBjO8AQ5zmAMfCrEIyEUCoZfgBJSnjLlY2PtDtbC3vmMBi37328tiHrOZ0fy6p0BlzTayHTOaIQ1qUENh2oizc+csj4qzgx14prQ94MHxjr+DzyC3xz5GTnJFG3q7+Uj5oR1p8kLvI5LtwEYdZ56NeRBypvgYajfQgQ6C0cMaM9oeKOZwg7COT2NbNUQu6jQIMOwhFMpQRJWuVEsn6dp+ZuWOWYLdvzIpW9mSGBqyDWE0/2WC4dmqLciKVawSwxluxW8P99ut1adsvUHdfQDEIhwBkpBQCBSkKIUqMtSKWGgoFg1tqE78be9/7zsWQGmRT8z8OtjFiF8Jb/PuEnZHdHiD5+lQhzrcIXrRu+Md8HgH6uHB83Yw7/Sq9/jqOb76fKSe5CX/Rzx2v3uVr9ymLQ/+okfuXe3eIxszTxg27AFURv+D+e0IRzcItg1jzGgYr3gDDYpuB/0qSQx6aKYRwNCGKKGBw3lw3x7q5CS4eCkPZs2fWWbG1l/yStmVCBqH5US0QWhCEnnQA7nhAwToAz8QBAXoAz2QgASYOFRQbm4wB9uyZHsXCZPgZJRTClGmIf9tUmWaAyJeBgum03hkRmYBN2b44jqucy9rxEYc5S+2I1LLlXzUtw3gAD3mYA7pkIPj0A7tkA7pUA5CWA7nUITvcA5HiITvwHu8tzwbJ3vxAA9RqHIpBw8pd4XdhXuQdIVUeIVbmA+453zCN4bb5Q7ckA3cwA3YwA3vUFMp9w8jlw/YgA3dMA3WRwzY9wc10ASnhlVtEFZiAAZGsFVK4iR5MHXrt36DkAeAoAiIQBfwt0tnoAUz0wRtdR7qgWGV0H9xxXT+xxZNcAXmhm7qFgh/4BFO9AiTIDmZkAmfcAq11Sa1QAtX1jm7EFG6kIthdi682Ius44vpYnkHh3lsljv/bpYwByNnwDMPdWZndjZJ9uAOPvgOpbeE8aB6QyiEpScO4kCERSh6QoiE6hAPoueD5uiD6rBx97AP9wByxAeH+/BIXMiFYgiP72iP+zBo+jhoLud8I7dx6pCN5YCG4zCH2JAN45A8/aAP/cAP+6AOdHgN1ncMxbALhRAsOqADMzADIzMGmgAJVKIIWwV+g3BLcuIWzkR2hpAIhUAIWIc/a/BrSzAzNXMefRFXyUZhBzYnlUB2khAKtGVbFANRWSQMRnmUSCkMFLU9VoE6o2NGxIU6rDOMcXQMN7IMzPAMmxdnOwVde0Rd17WPhAR8LwWHNOV7jpQP8cAP8aCWbTmP/4/kSKkneudQjapXju0gerGXD6oXcnz2jnGYlofGaEBVmDAFU2LpD4HGZ6/3ej7YcZDJPEI4DuMwmdQYkObAPOkwDuZQmfqgXf0wU9FXDcbgC3BkkUqAAx9gAjMgBUOgakbABpJwB3ogCXYgBncgJ2xACJpQPgTmkozgiC5ZVjDJS1mQBTUjQ32RPiczTHWSPnugX+1TCUeZRV40O8AFXF30W7zVUbMDR3DkLwCTDDryDNSwXNPgcyklXTnXniv1Ry5VSIg2hoW2cvKIaDaVn/H5e/Z5hW2JU4v2XWiJcikXSH5UD/eAoHs2SfKwDhWXg51JmdkwoRRaoRAKhBiKof8+yDyqdw6utw6ZZkl/Bg/1eA/+UA/dIA02kjOUsAM9YAIYQAEbmSXtYwdkJwVIZwdBs1Vt0AYnUz65BEWP+Ad9EH8xOX+UODPk0RckU2pjMAblE51P+jGxGQq5cJTDkFHGdVEUNQyGoQzOsCPUYA1w5lwpdabAs1IjJ0jgtY+DlF03lZ9xOqf0Caf8GUmJyabhJaf56Uh+GpfalQ9/yWh+ap9z2Q7rAA5nWKEVapAH6agGSZk5CIQ+yJmUeo4/mA7rkA7okA72kA7ugA/z4KCjug7z4Ecm+kc6VQ/bACTREA3DwAdK4AIUgAEfIAUvsD5hNQgb0z6CSCXjN34oowf/YkUIicAIhQAIfzBQcuBrv6YFSeop59EGGDY+xEo0T6o+I8MGaQAIlRAKtAAMypAMNlI71ocMtwAMYfRe20MM0BBxDcNT9NA7PAUO6MAO/oCo9MANdbQ70nAN99qOr2cP+XBTGceMCdqO7LiwIreO64gP+gCxgMRSqaqY7ehnI3oPKreEjnSNfDZ8fKYP9tBdf2lydzpT+mgPPoihaaiGjkqhLfsNmPQN4FCz4BCi0miOQKiyoDoPF1cPGMeMQzVJYCk8XymqFdegRwWiiZoN2DCv11ANz9AMx/ALpuAIgKAEKBBVJ3AyqsY+ONoGYxCbtzlMVnIy8hMKoUAIiMCS/18SB73GBkdqFtE6N0yqoyhpYOtjYB1JBDDkBXjAB73gMBFXPNcAJFU7UVJBDNEQcdtwVPNqMPa6Du7wSO+QoDJXDeh5DQ6qmCG3jvoQsdQlXUPll395D4dZmPfgR/iQsC61mMw3aCnHe1d4j94VSIFmopVmsSCnmRBakAiZho0KqQbJDd0gfeSADsmrqSDKc5eEDkx7s+zQqXn5evBQD+4QtBcntPSwqvJASQ1aPdMXtf06UiO1XOZrvpo7DdGwDMfgC6NwCZawCHBgAzdQAuHjmk7gMU7gVUZgBAtkYKEQV1jSPpLgCoaACMjaB3zAa3QQJt1Bt8e5Nj2AtrVpCP8dowM42jFDMLZgkAdA8AVvAAwFE3FQi0fWAKtYdItpdAvE8AzawFOXdjCaRLlw6A6WNnOb+70GGl2EJrK5m7t9FsS5K4VGPIVz+qZimKfZVaiDtI+BlnMVB6JnOIeQBmmRljBvdg3YkDAw27IxO7PdED3HGw7kkKGjl73w4LNBy4yTdHHs8L0Nug5j3A1Oq8Wam77SgDu4s8d87MdZ+QzPwMfMQA2vmgzBIAum8CCR4DNo0QYfMAOq1jH/ezKxhCUmI7bx4xZyAQhPVAh+wAdwG7dzO3/ABgTlAaWvBJ0fQwQj4zFhxQZsQARi8AfD4CNUkQ3rgA0OAw1p4jmD0Tr/s0AM1lA84CAPB8MNIOoOz2cP+MCv/bpc20Bp1iU8hAaPTUxIgNaOfQaoaXmFHJcPhHQPDhlUiVlTAvtn0dgO8oCo5rCod6wwCtPF8qx89HwNE8rL3HAwi9QNxis9LUs94kt6aazG7KAOPDezZDy+M6fDevzQEC0Ng0zIfNwMFs0My7AMtuMMyKBUpCASfLcIbYsHTlJKkiwFqjYEejAIHMkxg/iH44NAWNIGjOgzX8EHdMBrd3Gkx9nTvpQbYGtgg+C/HxNWqwYGOKADYFAIyhBxt7MN8sDLQBcLvfAhuVgLuwALt+ALxlANBaNI9brMKIsPmYu+1QAO5DxTgWbN/99FoFVohbYH1xynjvkgaLmroMljfIyZqRGaz49KvFbcxXMo0IQt0NAzPYd92IU9PfTKzwZZz3UU0ZI92Q89tRMtyIJs0RY9tc3gDJ69DDlDDL0gC6RwCQY1CVGkCHlQAyjgApKsAyugA6/5Ma/ZSicziLW00iizMoTwCIpQCGVVBzott/rT06dcM++jB+szMuNzyRwzy7RcCNDwuIWbDXBGDbuACYtQB4+QC7lgZeXySV3NzzdLuSQ6SO5Avuh7DewAD9zVUm5Iu96sXXmauw3Kc99AocRrz4Etz1asMGm42NNDh4gts5k0xjeI4EzbvAk94PI8c5SdvsYY4eb7DP8SDdGCPFKa3QwVveEb/tnIYH3B0Aux8NGNcAh/8AiJgAgKHAcu4NoxsAIksJExsJEpMAQ5QD7klwMngz560ARtkEwsiQcOjD/EzSqscpwPBgTr1z4eMzK6SlXjZ18rQARxAAwx/NUGYw3I8Ah84AeQMAmV4N2vwBNPkQzW4DAFI73uYIWOlA7kqzvSkA320JbcRVNsuZbAh7IY6w5zDKJ+/dj/Tb7Kx8XE67RomA3+/M+L/jzTA8bSI7PQu+DNe9gH8+DlC9EUTeEjxccZHtEWLtGYrdkLx+GaPdGlzuFYyeF8nNGufgxTcQumQNoQEgmR0G6bUAmT8Ama8AUloAf/L/ABHxADMWACxv7aL5BVRIBVWfW/RJAEd+AKlfDbhNAHeeDAcUDc1pHkWWCJyA3b/Ls+QxMyRS0FFlACVd4HlFAMPwKv1JAzxyQHffAVmZALrsAKsbBGwcAMjrsNywzX/AAP5qDe0yAN3+AP9ymYHRuF62wOfl3P8wzYBvnF/kw9z5NJGJ9JCQ099trxG0/YmQvhnU7RzHA7JH/ymz5SoZ6+mN3yLs/ymY07OkLqHv7hzpDRMZgMVmkMU1FGVpEio+Ago9AJmFD0lyA5HRgKedACLvACJ7CaQ6ACKqADLxADOP4CLnADRfe1OUAEODAIuQknjwgzcaDTEGwdYJDk/5bIP06QAq40Mk7gBLXUfbL9mjkwMkSQB4hwCbhQDNAADdEADcPQC67wTHfgB5WgCYjwCd7dC1vUL42LRzYXXjmVc0QlD9Slj9x8hO0g6dFLszZrs+gwD8xjjo0Jx3BcD/CwcXcWxxWnUsDz583rDdWDMFGrxQXP6bpT8FrpcOfpcLujucJfR9ZQDb7v+0CS/NbgcEBy/Mjf/L/v/McfDZ5988qADMfA8z7PC7PQE6pgCqQQ/kE/9OM/CqSwUKfwChfCClRk733gAiUQVSNwAiewAjFArDpA7BqJPho5A1iySgDRhpCfPJAYIQLUpw8dPHfksGGD5ssZMWeaXExSpP/HEClOpOiRosOJEx1jnMSwMwalnjFS2hiCBEkYtF7FgJWqpGmPnT2DKoVipChVrly9hhEjdoyZNm/o8vGD6s8fPXny6M1jhw7dOq5b27Vz1y6dO3Xq3LFjJy8t13VX5c17+xYtu3l169XDV4/e3r13/VJdB87b4G3brh2ulniaNMbSmD2W9uzx42aVJzN7lvlZs8maPT+LFjrzNGqlTVObRtraamunWZsOfbp0aNrRnjnDvWwZsmPGkAb75evWLFmrTI0ydXzU8lGYlneC7gnUdOqkrJNKlT3VqVSvUtFyRahHCxdGhswYscLJDCdG2seI4YTnmBk67JccdMcPIIP/iAoppOOOOyBiA4wvtBADDC2aYOIIjewwz4gxxjBCB46GkFASO+wzb4yXFHkkFVxcwSUXVxgxRA87BoGJEDkm8SOTonoJhhhjjGFmm3nSsSeqe7iSZ51vuPnqq3SOHMued8xq5xyw7JnHHnncmeeeKeWxp5577uKLnsG+/LKwwg67RrHGHLssTTV1Y3MZNdWszLI4KWvGts9sow222mqbbc9oclOGt2N++4WXW2KBpZVWVDHFuuWuY66TSKGjtFLpqKvuOu5K4U66VFyBZI0eXNAhBh1WOEGHGWJgaYb6Pkh1iDH2kGKGHIbgKIk2FOmvED/6qKOhh9hIEEEDGTzC/0EpbtVBjz1kNY8lHSDUocJmeRpEkkkqoSUVYcJTpA1JINnjDjoAUQSPQnIBZhhkbAzGGGm+MecdfuL5xx1w9h2SG3TSWQdgsdIxB8l21BlrLra4ygstIbnhhswyqyltscg2m4yzNzeGk5llkgFZt8lAJtnNy9yMk7OUK9usMmduwy1mZ0IDFBlBfQPOF0OHKy65Rq+zrjpMp+tkOlKKJtqTTpTmhBNMOFnaE6mnvvS6Ul45hVNQPuG6EEgMSYKNPV4w4QQ9hkC1pJDoi+G8GTpq1iQdgGAjpkQK+a8PPPJwiEAFwTi2wWRZGqMkCvcwySQMh1BxCCd20oNFSCb5pP8SSAjZYw8xMgdDklAI4Q+RRTxp95jecMQGnnzshaedb7Qih5x02OEqLdq3yur1IbsxTOKJLWaMY+E7VrlNy5iZk82S2xSZeec9Vj4Z3aRPxnTrb/wtGF4MlaU443xuFPzkSGHOulJKIYVqTrM+//xT2C8FFKnln7pp+6W+n5Oq3X+llFRK2UQqPmEIEPQACBLKwQcw8IEhWGhVqrLPCVI1Eic0EEJ2sEMT7mA3/+htb32DyN8MpAXBHSEHE5KQFIxgB1zJqlpDoBWupICtQShiEH7IXEs+MojI5UITTYCEKPAQBDJcQhmsscY10IGPfewjS/NYR1O6MUUx9S4xZkL/02NANjKSbbGLX0wGM7poPMtML2Rtyk3GWuY8Nn5MetED2fV8Q4yc6WwWd/RecpizRz6SbxSS+mOlBAkd/dmvaVRDJCL1RzVDJtITizQaKUqhClacAhSpqEQfelACDJSACDH4gBRUMAIJwsdUOjBBfWKQylTZZwYSakMeADEJSCiig3j44LAK9IUEHSgKgmugFFQoK8cJ0w5nq5YOpMARRUhCEpoQRQaJYIQczGAMiriDJiShhzbMsA09UEIQ5oCLaGgDiVecBhdJpkWSmQ6Mx1ge9JwHRnrWE4xtsufy2BQom9nsetmroy/smEefjYJ8BwUa0PhYvkBCBxMPhWhE/zHhUExc4qGE7MRDLWpI+2HikZuwXyYywVH7Re1SoOAUK7b2CUBwwAIpSMEHPjACEzQwBmOgQAo25Kr7lOoFKjACe2TVBjHwahKPsGVCcJkHYUEkQb3Uwi+TVSFhTkgKY9DQiuwghUEs0zx7cKYeuJkDIuQgB8vUgyL2kKIJbfUGTejDJDCBi2IY4xfAuWswaqRXvv4GKUi5UWCtN1h45tOwh0VsF/15OjrmbGd4XIVxIrsKWdxxFre4RfciK77xJTShBlXocwZJ0UtYwrSlNW1qU4ta1V7CtRV17SU2IdKRNg2kJKXadNrHCk+U4hOKOIMHMEABEyzwAyawUNtqNf+DISjXVFKIQQpEYoQVxmCafqjEJBiRCIT4oSFMBWGCdqkFL0gVbsec0BgGsZM96ACsLQFD5FLUBsLxMCVjEGsb2sATDNohlpMIhS3aNYwa/TWwxihGgudojNMx2HS8sZkyJByoL06PeW9chjMyLDMOc3jDGv7YzXD2i0LtTBawSJQqUIEKVbTYZ5P1HmVlsb1b8OIXh7IFLFSxqEXtmBU/3rGierziFhMZFaZgsYpXjIr2tY9+85OO1Cy1NEpRjZCMrB8nbku1U1QyFT/+8XdcgYgegEEKH6AABjAwgg+kAAYUIMEKWqIDFTSwVPcZiR7sMwg7AEEMBemVr/TGVDr/yCEOaxADL0co1SNUsD1jOOZVMVSSrbYBcNxsgxEK1FYVfcQILxHmehxnBD9oIhW2MAqBCWzg3hAjwa8uBmEfvFhZz5qfyEjGhD+8T91IeLHYoyOJDUWcGG8WfEvesZJRAeYjo2IVrUgUimFxi2lvrxc7s4WiEqWoIPdYyD1usaKMjOQir5gUuj3fdBy57kRu4pH6AwVJtcyJT+APf1nrbdbel51EZAEHRNCBAldJASOogAQpmAEJ2pZKCwX1BdaskHxKZQcwsGGDvQLEr/aGh0IfukBi6CWjHT1DYaqwcHbQhB1GkqA7XAQMRjBzVZm7QjYYYkKqknMTDJEJULxi/xfDIDBw+mqjOf7V6AdGMKyt189Z91PExSAG0IEBjF5U3cQxLrfPSHHsI/tsyUheMotZoShWoOLb0oZFLGyx9l3sAhjb454sYgHtb9e9xXcPsopVnJy7o8KzQVP3uvXHNcJ/YhOHR7wnDD9vQx7+flNLRbwLnwpC1OAGN/CAAk0wAgyYwA4zIMJyVzADFcBAB5IYhAraZoSPVEsKYCAqDu5Ay4MUQql7o0PH10AsYiWovMmyszI50h5lanNZ1LRhEsTwaWFaiHGGgLml2zAGGZzACHqY/Sd6rosB89X7Rgd/+JP+6qgDfRhTr3ovdoELXKwdUUIGcpL7jndlh73sYf9HxSm6Lj75173uaY+FAIyFXbCFtpu6ncGs7kEUFBMyBvQ/IWOxrus7v/OsJ2M3qTE8xEM8kdLADjy8TLitQ/KErJmO2foETSAEFMABIDABF1CzPXCCERiBF0gBI8CBFFiBZaFBE8iB9dABGGgJ1iOCFyACIjCEOzCEo6q9hGAqQus4AiEWA5GqBnIcDvlBSpMCGZABrtIcI4AEMSCCwhEJJ1ivNriDnmgJk7CDOwAETeCUWMCFdukFqqs69Ju6O6w6EtPDX7g2bMsxHVux7IAflGqy94EfQ8wOVUgF/KMkMNOOLwOzMNO/5IgsIavEZ/u/AFw7XFi/AnQ7YNiFPvT/hT6ksbVDsRMLwAdMsb0DuxVzMuowqUfqhEZ6Ny3bQBCkrVwEQQ0EwVq0n1NQvE2ohBPsAxQoARe4ARNIpRnYEBJYM1M6ATlLARNQAVepJhr8QRiokLIigj3IA5h4BEY4BNvrA6bCpdwztDXYPaf6Aql6oftom8IZgkFoAyJQERZZEUOYpmDqiGtSBEMghDvYFT7joUQIhfN5BU4ERfXTBV1oO/ZjP1uYOyEDn7+DxUVCpKGhjvVxsiZLN0I8n/zLP1VARO54n1Y4NnILtwZshQCsBVvQhfSjuqk7P1W4BRq5Qzrsw1uQSAHctm+bu/m7Pyb7SPmhskKaxUbihEzA/4RcfC2mfChd1EXEM6RM8IRUMMFMAgEXcIHCUcYX2AMTYCBlLK5qVIEVwIAYMLjnMhU7qCYpwAEpeAEcEAM5gIRKeIRFOIRDuL1z1L11JJYv8AImYIIVAjieMATEoS4jIAIZiBxrwiDGxBWRsBA9yAVJIBBs0SY2UARXeIVXgEOHtAVcCMDPfIUw0w79OzKruY7AwzJEGiSlkU0qUxpQWBpQOLdI+jtSwL/e7LaxOzsBHM1QlEnzAzpYSDU8TD8aOxSfBMBEiYVaiAVmW7bteJ/4oQ6pAakQhCiOakqnnLeRAilcnC0OpK0Q3ARQCIVhrAQ52ICXIiUSMAFQIoESeP+BbhpCVcEAEiC9FViBGJgB5MqBGnyBHPCvMcgBmLNL7dJLcsQlv0xHwGSDNBhMJojLMTAEPhMFRTghFTIr/FoWFQoJkmCuCpKCPdC0JmgDxOEqPWCDNdAEWmC/9HvJ6KwF0/xMV3AFVrBOQ4Qf7MSUR4qy3GqaWTRSqCGkp3EoJB2khfo7sNM/1Ry7V4AFKqVS4eREmczJmoi1YsCra7M6zErA59RE4YwFvGMx6wRSdfNOiZK3joJTjHIaiPJAT5gtTagEy4mDDJgAC6AAzkuzQC2BGxgDTdCECoGBOBs9xAHQ9fi8q6IujhgDMEgCQpgEBj2EQFAqOnDCdPQ4iKD/0AZhzOtzAmcJiZLg0ASFtEGgpquqD4/wiJCgrsR8uQlpINnThFwQBmGQw4bsBV3ABWDF0R9rBdR8xEd8n/zjju1IzfXxUX0zxPbxUWZVzWVbsrG71rB7QG1Lu25tQLVbu8ySBTHlhWCwGWKQse+pyIVSjueIlEmhKI2KrdiyBEqwV0qwBHpVrdVyLdN6KEvQo59BBU+IhYR0hUKAAzQAgixIghpwAQ+4gAsogfhUIA+w2Pr0gBUaJRmQqRkwm6AaAhmoRvsAUFAyASIAAiAohEulBEcIBD7gAzgwgzTIg2ChgziAg5yFA3VEAzQ4Ay3IAiK4gWq5L/qYMxiAkBzQ/68EdZxSfRz6sCkpyAmKY4kGoiY2CAV24VWIbEhgxQVaoIUbPU0eRVZE5NFn7dFofdZpTdu1NUTfvLtt9T+0o1u0i4XuKY4aqzFiwA1luKPI6pnJElzOQo6Fag5KqajV2td9jYTGjQRLeFzVYg5ToKxb8IUakZ5mwI1oUIbkBAQa4ID35ACuLAGLVYEUyAHoK4HS/YASWCEZuACNZbMT+ACFO4EY8E8cPAmP9dhUaYIkmJxH4IRewIRAmIM3iIMzwIM6YF45MDQ3gAM34Fmf1YIbIJUxOI+1qsagkhAV0AOUDUMnyEFauSqAIwk7CAVuSjmWOAkiqAE0YAR2AYaIDP9NXADNgh1WVtjR1OSOs0Xb7XAftxXg66xWkZQ/vGNJaZvbuoWF7pG2ceXJ0SRXXkAG2iAGncksccVbWBDcydI6w32OfzUtxyVhyDUt5liFWRCoeDGGzJ2GatCGGNaGbeiSbdAGarjg81sEGmABFLgAD4CpGzArmWozBDW4ElCBC4CBFCiB+swBElABmRoB+liBUqFd0lO49ghQ6wUCRdAuUIAGaDAFmJ2DNMClOrjZm1WD6HUDNehZnyWVF3KmoMKgauIIMDigGzAPnnKJksi0q/pePsMvFpWCiziDRKAFYfjM0VS79gNNHIVkstUOY2XWY80OZ5XWJlNW3mQyZSX/MlXo4MlywAVm4O5Zu3C1BZ7EBVmwhRkLhnYBhlWAhWGItV6AYDGtrMqyLM0yNsIFn8m6I1+4qxuBJ8x4htSwBhlW5hnehm/ohm9wZm74hntwh3VAh2s4hssthkrwgRroAQ+QgAsg4tXFgBRQgRPAgLJaXYj94cwrARiQgRQggeOSwVSZgRSg3S3UARLQARwoARy4gbqBhEMYhWSOhlUwXjrwIEOLgzhYYzhQAzf22TN4Jce5Jhay2ofbKhzIFjboqmeRgnAxgj0w1ZQ4KyfAL2fZgxlIAjDIAy2Qg1AI288EVwKUSNPU0c+k5C87VpPcNzVtMpD8n30T4B874Ljl/1a77VYU00RxxayePOVTxgVYsAVkAAZHaIROoIRL8ARL4D6JFNOw5gXLIuvL4oXLZeEWZgZpeOFrYOZtABNvoAe4roq6lod9wet1CBJ0CIduIAd0UIev8AcqWYd0YgardgMWwAEjIAEKoICZsk+xdIEhZDMJoAAZKAFxhlgoRmK0PC4SUIkU4AgjMOf1eKUSSIIz1ANJUIQ/GAVqsIZtoIZVOIQ/6AM+aF7nhV6IfmMt0IL6cBULqhVmwZDr8yHZwy8M6SZxOSbWY66WQK/1woH7HAQVPQNIIJFXqAXSbL+bzlHP1GnUdESe/t/r9Mj2+R9nLclI/GQETmpUFEBNhP9qVo5gcE3lsF6782sFWygGYagF3DS7GjtrgcqreCnmY05mpoDrL9mLvPCLB4dwCMeHCafwCs8La3bmbiCTbCgTaageY5AFSnCDHkABNHPszTMBI8A84jKB+rQD2FWBJH5nGKhdmeo8GWwuGZgBGUDpHqziF7gBMzzDceEDSygnGKYGWHhZ5m3eOHADnJXon9UCVXmbwlGEDVGuDZECUSgGSSCC5VuhSgMcQ5CEBKkmSFMvSAMCGIABIrA0IsCBGkAEmaaFTRRASP5uY3UFSybgKGWfvwvJFStg+UMFSASz/+vW+Fb0B44FXNZlyxoOzCqUmxyGQlkFX2CwZTjmarj/hsKQ677oEr7QiwiH8FA3db6QhzAZE8Sohhdu9TM55mZIBmT4hVFwhD/wAyWA2OGKAFhJAa6cxhoPpTZrgzdb3dpt4mik3f88ARVQw7YaA34WKxjoATKfBD5YhGOIBtNQhk74AyavAzmIXpyd3jM4AxWwj5GoFuzNAaSFPjsQBcz8tBWShG6iLniv92EaBFEACa4iAhfwpPCtlhvog0/wTGB1P/x9BfDeUdTUUT43b9X8c6BxH5JsNrC7O7CLxLHbNrtdwAfGW7LGLBUWZr0i5pCZmWVosGawhsHoCwvHB6mQeQuX+ZrXiy4Bkyqy4cOIYd/x+cNYDdhejWiwhj8p/4ZYsITa5gM3YAMQoAAJkIAGqF0VUEbjygEVKF0mXl0YAOIlVgEbqkbaFYkZkARDkIE4cwKbO4GeuAE/iIlHAIQ/iAVkUIaYGYZF8AMmF/cnh4MXfWOKNisdMCuzqg8LCYll6kZqMlUpENrUlQTEgRAYkoQ8S0yq8gjs/TSXzlo6jMlf5b6qg0iiIAqUijJOkB+JgiiHEqSMlCSgqcjreDFKFNyyJnmTL6y1noYY9nSX34u4/nR6wIsJr3l/gPkKB/68gCJ06AZswAafR6Lnb41qeI2gP43QIA3UqA0NO4ZggAVSiIRv/wNAkAMg4CQ1s/HjcmwXMIEUuFgPQOITEv8DOyg9FK2+UhXtE5iBQRgC/GcPI4iBEQAIHS7OMJoEKZGPP6eGKWuoLFWhPoDqwFGDJg4bNmvQcESjQ8aKGUakGNEhJceMISZP5rBDJAcRHUaMyHhpRIwdSYOkjOk5I8dMO22GGBmSo6cUJ3aS3AmVKxcuXbhsRZVay+orWq9ccQLlCRTYU6U4ccJU9uyltJjWru3EqRPcuKPm0q1rahXeWbN8+QpGzNixZMueSat2Tdu2bd4We5PnjR5kyPUmR65cuR4+fPPapTM3jjM3bNiukR5N+lq11KpXG0ZtrRq12NZm065t+3bs3NSi8XamzFgwWZ0uRSoEiJFxORwwfMD/MIJ58w8mXnz4cOFDCRIwVMiQpCeHihIfZqSIMWTMhxMqUqxIkcIO+g86Zui4AecRfkZmdiA6BawYgLk80kcfdcjhxhlyyIHRRhzJNIYTQ6g0hBQrGTEDDB8NIcN5RZEEQ01F7cGTHUOIZAQRRuykxxg/ScGiSWOAAUgltORSCyuv4IJLLLio0gorrMRCS5CgiFUKkqDA5QlZZa1FFiZpXYJJJ5ZYaUldo9ylly+/BGOMMckw88w0hiGmGGP0gLMOO/Ngltk99sh5T5zuyLPOOuig8w043PgpGmqpncbaatMYWmY1hyp6qDSNFmaoNIdSU81r1uQ2zWy68WZpbrx5/8obNM4gc8wvt6iCiSWULLJIJpVMAoYLL5gwAwkelHABCSdRMFIKH5BQawo54JADCUZ4QIIM1a2wArIykICBDiesMJ8M0Z7gAh34PQJJHjVYsYgnugAjTC6ZTESHHGokuKBGHRFFUg45VCuTHTroQKFRRu2xRwo6CDXGSRSSVJIUgwzi0h6DGLHHGEWd4IQOTozUhhh4aBKKKxm/snEtqqiSSipincIKyKecggoqqqCSJctzrSKLLF1+Gdgyy0wj22yHJYYmY96sIw898tzJDjvqfEPO0eikIxrTgBL6NNSELspoo88QZjXWVjvqqNZYH/qpp86IvYwyyIwKZjDB/P/iyy2ymKLlXHBtkkkmoYRiCAoueEABDHvg6sEFhihCwQgqXIDrrSXkMAh2JWy3HgkzVDfCiySs0JwMUqxwQnou5KEtI4SwwcIZi1ySCi2ufIKIgW5YxO4aDaLRcIRG1O7EGPsOYcdOKCJFocQN42AHw0ANYsgge7TBExEp5kBSwzyNZEQTkhCiSCWop5KVKyBn/L3Jp/x4lyy37NUXmGEyE6k1iPXMGNBBCx0/ZN10s439+Z9GWmpbR5oopPwXqakhKmqpIaCiBMg1rDWDGWNqRjOe0Yya1SwZxziGMYhBDLX9ghdtW4UpSEGKUXRiLVcyoSXUggkRksITraJbKCT/gQIOXIACH8iBHlxgHQpYbggwuEB2AAe4G6agBEZ0DgZOMIKQUIB3J5CBs4ygCD0wZwY9KMQjGJFFQgCiBjQgQyEgoQlNfIIRBrLIGuLAoI6gQQpJcaPEiGKEMehBCruTAhFIAq+e6GAMhhgJT6TQBkOwSAwwkMK/nmdHPUhoBtATJBiAwIZEYCwXqUuF3TKZClfUoha8CAYyotG+x1imlKaczGTW8Y1sAIo0VHPU+hSotQFOY2tTo8bNdKNLQ61GN5yKjaQYJcEGLsOCGMxg2nzBi1ng5W11QZUlUGilSFypmle6hDUt4QkmcYJun9CEIu6QtxdQBwMlSAEMxPMB/wqsQAbm3KEHAHcrIF6AOZsbjxPYwx76RAuRMxiBC3CAiCzixw+AmMMOOkAFOhgCEpVgBB/oAAeOKAgjbJxJDmTiRpgIywh2MEIbwOBGCdnBDk4gySA0YQc26MEOz9uDGNgwEjtIYQ8fFYMejPC8kqBIp3hMQhLYoAhIQAIRicgDUvOABzw8IhfAAEYwjhENUpqyMu/b3/5uSQ1HLUoahEFgowyFy1wqylNiBSYCD8XACRbTmGDaYDD4ohdmNtOZWWrLWqSUzWlGgpqU6CtgqZkqShCWsJzwxFo2sYlKFIKGLVBBUjAQgRK4gAiSqw5zRkACI1pnh0aMpw2flZ4ZjP9hBSow0Qz++cQUYIAEaRiotgoECDeEIAQt0EIhGIEIPqiRonJoFxrOcAY9MMyNubPDdnKQsJNg9Hk9mSMiifudIQxLDG3YiSS8M8UUNYwIY8goHokwrOaxIabWjUMewLBSMIhBC3i4xDCKYbZmIEYbg1JNLRW4KF1SI1O6vA2Ab3abXPI3Np6yWjQkyIxkMNityFybMm9hPrripa5vM0UIRUgXFiopSmzJq16zWdjABrawhI3EJUqIicUWogYoUMGxLrfOFxwxtBi4jniAGE8PdPYCGVIBBoKcHpf26gOmXcEQVPACDOTAEFqMbR348IcyhCADIXBDHwrBWzmk4SL/GZHdGQxhiBIRBWAqEAl8AKZHoMzkJjglyb2qRQQgNOW6friDJExK0+j2BHfGPRhPxlDSloKhpT25gx8mEV9iXBAZYqoZBBEcjUhnzWsJBhumeUPgm2U6Gvz9FAQp2OALvhWuXvJL2pLJlwgr04MSlrCr2yYLWNCa1q1ohcpQIRZSgILX24ySlEJM4kg4ArCOKHYkShGyJI3sFbYAWSj8sIEKOK4EgMNAeC4Qz3pigAKHC7KOtX2rDwCZBCMgNwb6pYMRqJu1L4jBDaaTA88pIj+6NQ4g+gCHH9AgCGeYQx3mUFE4wCF2seMITSVGBBlkdAa46zPEx/Agj45oRDpY/8FJc9oGQjRBDITYA3HHoIieENeNgCS5HfRABD3UkXhtELSg9XCHSvQibcQoBmAAYzZlMFgZyxDb2H7uDAgC/Rmd7rSkoxH0Yo7qmMhM2y+iLvVV86LqvOALL6SO6lNjvdVVfzXYbxELWMRi7LC4Na49puskeYWbTQI2Nq9kYkpYycSn8ASSOFGKbdJie6mQ9gToiavNhsfb1yZBc6BzgfU07gLoJEEKKFDTdaIEAyaYlaxuEAOTwAQHfqg3I1aFCHznmyJuiEMd6qBGBRG84AefnRt1kAM52kETdEx4UmqXcjsoYl+SkLiJTKIDSYiiCYQQhUvhIwVHAkxC+Cqzwf/8OGY9HKyOt/dDJWxxar+kr/uNbvTOHVIzoIcN6EAvW9MzCFe1Yf3q7bf6qt8f9S4pM+pWl7oGTe11q3vQFmA3O62V3dmlndqpTCmIUCmgAgvxWgttU5NAySXMHSVcAlmAQil4xSZ8hfYAQgtUwI5RQAkYjq2kE+DUk7kxB+IdzhCVgBHAwK+oAIjQhGb1yuWZgA7Mikq0gU55niIwgg8mwugZhx8USJTxQcDJgYGoURwUHHBFz0gVxSAIGqDBx0ntDk3tgSTgkR7kWWrdyxZqQk7pgQ5kiMTZEU8UF4TgTvKU1L6kHMuxCB3tgR9swilkXTBAVf7lIZgACB/2YR7/5uH8tdqr2QIhFiKs3UKsIeLVVZ0v9EIv8IIjOmLV9ULUUeIjUuIvQBWqFYMG+YXU8V//wYz/iV2t3drZeQwqpozaLSAqIMkBIqADPiAnqFBeHZbefUIojFEluEIoAAILbIAF1FN1KI6t3JARzBN0VMev1MreYIcYWBu5SUG6tda5WZ4KzMqs3KALoFMPXI8PMgIQjh4gDGHqEWHqGQgcqBHBAVcguREi2VEffVRP5M6I9FlJnYQhSAJqjYSJQFdL4ctIScyYOQFB0tHIvQh8uGFL7Z4dAMInnMIt9AIwDMNEDkOqSV3USRjMwEKFeQyGYZgIfeRHokwrvEIrlF0h/1LFjqgkKIJiJL6kI2Lk9tncXxBD1K0fMEhkL+zCjqwkIY4d2rUCyqCM2ilgrx1lJ3iCW7iFk5iFYilWJpiFirFFk1zCJ3yTq4gRHoAAB4AA4IyACqII4KRIrXzADAIZrmxHClzHjl2Hr/gKNqbW5T2HDZpAr2CACzRBQ30jEBaCEPbBUp3jOS7IgiwhcLGIUpRIUUQM8JwHhMwjhYhBm8UAfdCHHN1LDjiBHkhMhdBHSc2RxBQkzMHHG7JhSw2CHrSBIrjCyKgCLNRCLLxCLKjCR45Qy9AFXIzCAl4gApKCKYxMSQZnK9BaShoirLUkckKiTKpNquUhqkHdL+yCJP/iwi1MhS2YnUkGCSvomgIuYFx854eFJ5XAxYfVBSmgzCmAAkQAAh58QQ/gABBwwARYgAVQAHTwmAy0gQp8wA8dzreZJeKpQHgkToB6AMMNHglcHsDMSrdJx3iMgAmUgFB9IziK4xACZpQJpoEUpmE2iCJEYcPIHhGUFEHWVIy44/TQVA5sXhfGkR19lBNwiMPNBxylRKA1TO7U0RuWZkmlHCFcTCosIMgsoG1+53eSUNx0Algoaa+RQlyIEFH+yHAOZ63FAsyE3avFGv/xxdR5ydrI5DE4wzEIYtsMogAOYJB8jMm4IpEaqVzMBYZVWPl4CaMhg885w6ZYAzSUDTD/BEEFVEADPEADSEANUQAFSAChEsF+ekDDwJi48Zi5pYAMBAsJaNviheCtQBYMfEAKmMAIUIAJnJRZmkCQJRFzpMAdQEIPgmMi+CUgjKMfxCqGDiaHuh5HFE+EbMiLGJck7IFjeshJ7YEoDMILXOZ5DAFBOkEX2tGE6EDJkUSZwUfCxBzL2RTxsOG+EMIkeMICgqRt4uZtZgkLdQKvgcVXsJBImgIqVtitwYy7lo9eYOlxLmL8geItKEM0KANfTJgszNUswEyFrYJHemtI3gVelI8d/sUxKAOeipI2PCzERqw20Aao+AYuOMIchEAFTIAEDGq3NcChRkAEOEsRwQAO/9gK4sUT5GlHCoxAshyLEYHHypZICkCWFCwZtNjgCjiHWcbAB9yAH6jqDwYhF+UbgRhh6uGB6qXjEtoqGgwBixSFch2kHmiCKJwUTYlEvmDhGKQI7tzLwERITfBOUniUE3xoHFIIyzEkcRGPTbUhyGGhHvQBJcSpXiyTv06Yv87VKozCWvhtW4Dnd6LrRwasnMKCLPjfKGKpB/Xr3koY25jPrMGCMkADNKzN3mYul/TFzCQDBIlS+2jD+ySGxNKGgcWGBJEJ6O5G2RSDLYCCqpgBB1iABEQABlyOBNgQuJXAy+6nEdXQ4mlWCqoACeSAe0BWfHwAFKXAC9iOrKjACf9Iyz+NQAzcLgkkgZMpQiL0pavKqhHygdKmXkUVputtRMqNgYQUDIucIfrCx73ECFHkgA4qhU8oxUk4ARHsy2aWLf0ikrWi5u9RHMPs3tqyoR3cQcCNAucCR6pxENTF36qBEF1kGJEOJYahDF7cmuEeLJXS2ru6K+LCjObOAt72azDE5AaZmsIGRjN4Wvtsw5n0DAxP7FgNkFelbqV5jdE9Q3/VBusOAy64RSQkQhx4ZQQ0QJDZ0OU1h3hsVjoBi3hkCOI9y+Fw6gd4QEs1zlpmCAwwhwmsh306xwkYAefwJxsQlSIgQhC66jj2wfeGbxLGgYIsSPkea0+VWYi6o8T/mUBj5u8fxZxN9RlREM9OvFHZzpGKhEJqltTLuS1NpZwk5MLxKcIBQ8IjNMIqLDADNzAEQ7D9yQJe0GYBSmkr+GbhavAGH+y7Zu4q/Csz+SuX/oXOBcMoNAIoa0kwhG7pzgZZWY0D/bIDNRgFtRWkQVAEDdNuUJrYKJ0yFAMw2EInENsiFAIeAAGi2q6hkkS37ZgRwZi1Ea8HtKy3wcAIgOUVw0AKHIwEeMB+tuzNwmVzkIAOsNYH+KzPvkCqPkIa9+XocdGF8gH4CiZh0nH5MhJxdcgcqcTsEaRKRIiNLkxNSUIeqVn61lTKVSEinZQbtW3KSUE+CsUb8kTVjlEo/yiCmEECICwCXnBuXMXfCOuFKmcw2aEiKZ9drTmu3uYFIs4VI8Zf2oDJBS1DBLkwxM5wNARDKwcDL/QrMVjDMzhQAwGzVAMzBDGDqAlGBTUYg1HQ0InNbgAd2ZhNMQBxLJQCYXlCJYCTC1BABBgqotolPGEqf16xr/CYWyJea8nAscDsgKbAMmJWglreDFBmi9xlCuQBJPwgPxeCPx9tQNPqwJWvxGUXveiRUtiOwCB0akoBDAyCInjIc6nEGBTyeRhXOyqmHYjBIAiDKLSB2yYPcRmCHxACHYSCMIRCHsDBHJjC3loYSIqkKmTwR/7IK7BCSZYdcpddv4Kd+22fLP8z2JiUyWG8D2NE7KBcQy1ZigVpkDEgg9ik7lRDNVtpNXkng9mUt3mbDTKoH9TxpC3IggLqpltgQiZcwiRkAi5OAhBcQO0uAMjWULoxcRFVB7EIkbaRGwl4m3zowckKEQnAGBS1lrL6ig7EgA1im8TZQQy4AAwQgiVXqHF0r2O7sWDSgYnTgRK6XsaVSCDN1IgIjIeoyJhRcpt5F8uhL4XsQZstpHEtD/rmznXlgiHEnEIKBRvcwR0YQi5Iwh3IwRxYQm/T5lAeCVykjAjR5nB7TAAeJ50ChmDg6Ww87M6gSWTIsH1h1dPw0jUA0258Cg6Ht1UPc1abN6mp3wZhHSj/12aS7hWKmdgkTEIlhMIn9EChrlMDtHU9mYChYsejVuq2Aa91HI4E7OCmsrOilrOvDAHifUDuEMUNcioj3YBQTUIWca9fyqob88HRniOKo7gSLuEaBJI8JjSLpASFeAiFJI8iTFFLnRyJkpyfsQh82I5kngfLDcIdhNS1vpx0CVpJ3cEAs8EfREIrkzAvrAKuoQJwxyn5nA/30YzR9RfEegOajDnpakOitMbD0oa6H8bDksa7n3mgTMM1WAOmUIPRRdBYxcYNDxNY0znaxBXe1lW4JmlcsAU2ndhg/dUEUsInsAEK7A3hdBui5u4MKLq2UQBolSCOAfjhgOVm8S4M/XgADkhCDgCo5UBekLVHahWRCeRA8w7VJPjgIhyCXxbtP6s6iadeq6ujOq6B8uHRSSCSmkUMwEQIUoxBdu1L19KRmpGISURIO/LE85xH8oTCIIhBTA1CG7j2IHgHj+6etGOyXkTde6uCbZpCK6i9hP0CMoT5YvAMuZ97oBxQVx1Ka9T7f02sLru7Lr/7aWjDzdyML2dNMFvQ060N3sI0CH0ky3yrki5JUs43BKbQiEXCX2G+I6QBV5agyEpW7rZ1OWMA4BRopMfTjXXbjVVHCnhAOsEYEWzqs2zHuSULqNqlCbgAZb3ADaTqzIeezTP2q3ovQCMtz5v4q6tjQAAAIfkEAGQAAAAsAAAAAEABAAGH6b+f4LSU3a6M1a2R2aqG1KmK0qeJzqiN1KJ8zqKDzKOEy5+AyJ+Cwp+FxZt8vpuAypVtwZZ2vpZ5vZFvupR4uZBxuY5tuY1ptJN6tJB0tI9ytY1usI1ztYxttYtor4twu4ZdtYhltIhls4losoZjsYlrsIhlsIVjsIJcroltrYZprodjrYViroRjroNgrYJhrYJerX9bqoduqoVmqYNmqoJfqYFhqoBdqX5gqX9bqH1apYNooYNupX9ioH9mpH5goH5jo31gn31hq3tVpnpao3tipHtaonthonljoXlgoXtcoXldn3thnnphnnpfn3pennpcn3lbpHhWoXhhoHhfoHdhoHhcnnhhn3denXhennddnnhaonZUnnZcnXVaoHNQpG1Gm3lfm3ddm3hamXZZmnRbmnVZmXNZmnRVmnFQl3Vbk3ZflXNYlHJXlHFXlXBTj3BYlW5Skm5TkG5UkGtRmW1Lk2xMlGhGj2hJjGxTjGlPi2dOi2ZJiGlRiGVLg2dTkWA9iGFEhWNJhV5CgWJLgmBFgV1EgFo+fV5Hd15Me1pDfFk/dllDeFY+eVU5dFU+b1RCe1AydFA3cVA4b1A6b0w1ak49a002a0s0Z0o2cUgtaUgxaEgyZEg1ZUcxaEQsY0Quaz0gYEg2X0UzX0QxX0MwXkIvX0EuYEApWkAuXD4sWT0sXT0mWTwnVjwsVjsnUzwsTzstWTghVjgkUzglUDcoUTciUzQgTjQiUTAZSzMiRjMlSC8fRy0cSCwXQCwcSCYQPyYUOyYWOyEPNSMVMh8QMRwNKhwPNxgHLBkLKRgLJRgMJBYKKRQGIhQJJg4CHhQKHRIHHA8FHA0CEgwEGAkBEAkCDAkBCgoBCwgBFQQADwQADAQBCgcCCgcACgIACAoACAkACAgBBwcBBgcABAcACQYBBwYBBgYABQYACAQACAMABQQABgMABAUABAMAAwQAAgMABwIABwAABQEABAAAAwIAAgEAAwAAAQIAAQECAQEAAAEAAAACAQAAAAAACP8ApUhBYwSHDQYOWhjJUUMKFyl1uKBJw+JGHTtGjETZEiUQmjdopOiA4QLGjRswYHgwscKEixsmSJAoucJFjRoefmiSJatXsGfJgtl6ZauWq1litggU2fBLnS9LpXzh8nBhDh1Gbt68qqNrjq8ob3S98fVqWR0nX9zYmmMtjBopYZwoeUKE3RMrZJIQEaJvX5kudBAx42gTqFm+eq06xfiUqVKkRmXyRJkyKFCcLl2afPkypUWLGolu9KhRpUmTFMHpQ2mzpV7NjCUzZqwYsV+/evGqVSuVKEuJEkEqpgzSnz+itG2jJi2ac+fQmDmL5qy6dWfMpFfPzr07s2XLuC//U3ZsGfZo0KJNIwZpjQ8eMjg84IABQ4YMMsqc8WMIFbJnz0xTTTOxFVMMbc1QlVFGFRgwghE6CGQEVWmgwYURS+Xwgx1pbMFHHGNsoUMOccXlggg1rVADQy7shWINI5qwQSC53ILLT8gg04sttLyyyi1yeMXQCzlIJZKEF474FVYLaQUDVy6U9BURTonU1Vg5cJHGF18QAYOKTr4V1wkknECmTHjJJMIFIcj0FwkwOBTHIZ/IMgswvLyiiiqMPRaZJ6CUUkpnl1kGCqCneHLJJI84Ismjk0jC6CSN/IGIZpZY4kpvscSSyqepjPKbKL9lCgkklsTS3hprxKKNNtU0//ccNNFdtx122V3nXXfghTeeMuFVJ6s00xgjyho8wPeBDPFRkAEHH/RAhx+CUALMM9VMk8xstHU7oUZGbGGDAg7goKUONXDxBYc5VFTDt0ZMZAceW6CBkolzycTCVhnlgIIIK9nEQgcboMHKLYnhUosvQ9liSyq5LGLDiDWw8AIM/eaQEVZtsfWVVis6BBURVwrU5ZVfpXQDVTq48MLFK7DAQswpuXACSTDEcKJMJoiw1wUXkOBXmTo4hYcjrMhySzC+6LlnY4JGHTWhpjhGCimJKkoJJZVUQglqkW79iGaXUGKqcJAEp/baah+XCLI8sCrMq83R6tytuHK33a/K9P/td698+32MMtxFQyyx00TTDC+EJOuDGEDIoAIHznLQgxmCGIKIKchoW5tsxgxjDBpobJHGhVtUUMAGG+tA1UQPnS6FETesMBEaHtlg81wt2mVXTTXYRCIKMtXkwgojlDADJgj7Uksio8xiCy60pGILKkH0a/EJV53EccfCd3xTlE9GKNJJKZtk0r1zUcnFCyRcTL7MMttckpQwhCDC8TPJ1WaUQvMAnG5gB0l84ha3AIYvZrGnpzUGaqVgTGdIUQpTWNAUl+EEJi6xwa+dZhJbCyEmtsa24/wBDnBgFQpTyCpWJStZf1AG3dCTHmjcale4Cpzf/qbDZBzjGNJhhjT/iGU4WRUrE2vYwRzk4IYdMKs+GpiBEOSguUfQIhiyOdBshrGFLcSrdOIiV7jqlYYOEQRD6JKQQWyQhje04Ew+24sHPHCXFo1gBSdAQUpkdhOCbWARuchFMIRii1tMbyityMUbimQEm8GpRDXj3ZPAAoMXgOwmMdPKvk5Sg7UEL2YyW8EKWkCCFniSfI4syV5s5rO5mIkkfWFTXwRoEjsgTRaYacUrWtEKVjytgal44CkqGLULStATnOBEJso2iQ6WrWyVGCEkCEHNPyTChCxsoTbd80IeJGIar6KhDbfjHevs8JzNOGfffLgtHwJROolDTzSoQY1sAYgXJ1yiHMQg/4MPYKByOyjDHgRBzVcgg1u0oVAd0sChNEigACbw4oTQEIUKKYgFTHqBEWzAAjfupS9xBFgro8SSlLSlJaKMwAZKQIdb5MIXvsCFLXIxvVfUohW+KMQPINQ7V5opSmQi3/pu4LJOerJimtxkW8AHylCeYAQzqViZgAoYmaQkXwD8qF9mCScd4KESspgEHE6RC1720pcNbOADH9OYqqliMYeizDK3tkEOJhMTXaMEI7CJzW220AeAfSGrkqMcZ9jQhrvKVXaApUN1/rBvx0jGDsOjHucMcRvSqEa2pgGUV/xhDXlggxNokIIMPOABGEgBDQQKhzw8ghcEkg3pylgvL/+2gFw2CFfpjMDQC3FhRRqrAfJGkAYjjCAEHtCf7+g4VaDyjgUmYMkKJmCBDQgBFS8NBvUM6TBcvMIXmFBCVlzQFzPpxZUlgSQkX9ACUVZsZvu6CbrWEkr6uQCqpWxB72ZC1ZKchCRzqZn98seX5IqAe4GoRC4wQQhKqMJHq+AlMNN6ClWk4jGmANWeVqEKU1QmM63BhAYxQWISb40QLFxhCgHLYhZ3kz7J2sWrtHHD74THO+pkZzt3zON29i07Q2zONKTxjW1YQ7OaFZAwGIFCN2iBBhSoz2kpoNopuGEOfwDFMJqRjNMx1HQEaUEEFGACjaAhDmnAQyCKW9wL0c7/AjJqQRrmSEeA0VK99wtlzFag0hKkQMEwdRh3HfZdWYzBCCwgrwcciSabqXd9+MokJ+NLlqSCMi8kuMHFrjpVSJ6kv+SLQUpiMBMyBVUHg6iTL4AxDOq1IsKt2NOn0jrhC6diFRw2BZ8gI1cOijiZyAQxJfqgzWy+p5vI5kF9OLAGYoBzG3nLDnh2dU4d81gZ7eyWMX4oWewM0bLR4AY3tgErAcFqG89IRR7CIAYvyOCfGHhAAySQgWidYVqPsEWXH0IVLdmBIAyogIfigAY8zIsLa2boF24wRxFYwAN1IKoH6uIzF4Dlv+nFi31xsgIb/OAQwAi5jWzkMIe9VA4//8jLBCKQXpIIdX1lIdFL2iVKPmrlKxhaixSKuxWosOBJAP7p/WYy1fMeGGcwqOrNTnCSL0gCu6xGRkxfQfWquwLXZuUl1XmJa1yD6jGU6YRmMJGJTCSz7JgAxSmQCNgwNKG1rfWrX+uDgT8049nU0RV3frxYAvn97wR6xt93rIxmAGgaiEeyZoPcnOmoZ8jNsMUfdoAEwMogAxRowAEOoIFoyYGgisDEghwiEdLVYQQOYKMRfhAHPtiBQzoorgs8ALQRWOACUlHTzm5GybncgEwmoF+iWeJxPuRC5LiQacmnF4xF9GAFDp/AUNVLlvSZFF2hvAl8YZSRm2uFCxyCy/9DqOpKFwmQTCPN6l5g4LOrmqQOBkQYMILRC+9WnepXrzrXJWzhrxcz7GWTTAJ4doxxCWEAH/HBAy3mA03QBNoUBi1Ed5Bwd9UAbdaxWOrkN39XeIYHeNiGULKRDIYXIIgnIImDeM/geM6xWQAyDAboA0hwBT4Qb/JGbzKwA06gB4VgCESgLlxSRmlQB3cgBQ7QAQvCUKezIkRwAkBDZ3PUAnVwXyH1SCVCE6JkE1rBEj8ABWzACiGXfGCIC4aEC8OACj9QA9FnEjF3L3FxL1EiJe9VEfBFPx1nAzbwApemIjGjJURwYHuhF74jAi3AXnrRInqxFycgQFHSAvplB5H/UCchFwy6MBQ+QnVdR2ttZUFSIyik4AmdgEyaAWyUQYCnQAnIwiwckGzdFFgKqGwYwAGp0AyZtQ3awQwZ+IHbQhs91k5cxi0GYiC6KFkEwgx3h3i2Uh2PNw2Blwy6QAhN8DiRE28fQAEUwAGUdwZ7cANEIBDbKBCnYwQWEAEK8S1ScAMZcQG3R2dAAzRTMQLwM2CPlhJGhT7BZwRjAAWSoEC5wAu6oAth2Au+kAtjkAMmYAHSp4YXF49veDygdAObVDF2aIc6YAOZFHxXmAOGaIhqAlV38QJ1MQICZBf8ZWci+UYtYEuVwAqBFFND0XUc9inC5BiQcTWRMQqjQEE4/3koW1MZPOkJp4AKj+Ae8WGNPLADL3RsqohaPLALyeAMr0I4tpiBuWggxCAMVmkgwjBIwWCVWRkMuIEbW8mVxDCWxHAgzPAM3XEdnJWCPxYbpgAHTcAETNAEMpAC/fRPHxBQI4I+lKQxK+AAGyCRONAVUuBwD7eO6XgBNYAHGBUzDNlJN/EWbbEWXNEVLHEDWwAFggBTudCPvMALNXIjZKgHFLkBFbBpcbFpZIES5MM+IxB8M3MDDEUQdrh6P2ADjChcTRUlYjEzooQ8HjACIAmbLXF+f/gzF8BcjOgCdXAIjqAJSVMjszALu2RWDYQK2JmdP4kKtMYnjcEnZUcoV/8zCp6AnYqQRByQARjALDe4A0apivBRHzwgDE1ZDdrgWJGFUFRZlWA5SL8AU4PUCwI6oACplVoplsUggunEgYGHloKzDNkSDITAgE2QBXT5RK8oA0TFOwMWXBXgACOAFThwA1JAAtRFexcwAej4cB7QAnhQXDqAUcejfW9xE9W3JF3xmiywhW4gC8DQmbrAj4F0I7owDI4wAybQARVQhVHyMqvpcv5FVDUXXxnBUSzgcRHJXr75m0BHAr8pSiYgnCilSTHBaXOUnHGkF2nGB4PgCJPACrNwC2bFCqzAS3WadXiKp68wC1mnCsokQYHyJ6gACoTgHvSxnsziRDcIn+//9gB/kKB3pw226E4/dCDdQpXC8Av86I8yRQuemnyeunzT04/9CIZB+gtXaQyF5ze2iCvYASzfACvN0AlrwG5icAY7sCwpEGVCNWB8yQIOEAE44JGa5gHhOAHISl0GeXsjYDo2UAMjAF0CoyL0daM/8AMjMkcdBwVhMAnAoBufCZr7OAw+wQo2YAIlsAEm0qQv4DLtupwvF1/CF5FYylF2CF3RFV2YVhL62hL5+pu+aQJ01K7Hc6ZzFF10RgRlZAd8UAiYcDA8IQu8FLF4Op0Wa7EIdAvTqbGzwAqU0SePUQrkqQqbsG4+QDkU8AEpYJeJqqjsiYqnBQmiE6ntdAy1/wGMN2sbmdoL/sgjPpJWHGZW90ed9/cKrkALuuALXkkMIShZzOAcueIMhqcc5YZPYaAGTkAGUJACH+BPaoImJdI9EVCEI9ACIhABQBMBEaCiKoqOF/CaJ2mlwMNJRtVJXLExOWABcMYCShAEm5kYuhGk48o0wEAG6LoBcPFylaSRLaA+KWFJN4ADoxSR0FWHNdBeLRCmexamB1YXl5av0fq5AuszAgScxqq3tAeST2IEcYAHdCAIhbCDiqAIhlAIs0u7moMIiHC7vDu7jMAIjcAIirC7j0AJoIBWa8UKmwAHYkCX96Gyy/Ky0juU9bEKwUAMhlcNOPuLOYuVuREMvP/gqT3CYd0Za1pXtLj2CrRwdbXQC1kpDJDaN8IyZChYZOSGeMaARGEQBmRABj2gsieQaDb3LnhrAgsQATcwAmsyAm6LrLeXnHQ0Ah1AOnc0PomWXnTbSVdyA156pUogBG3QPJ9JoMMQDLQADHOQARVgATTnAnzkSWiyJC+AA8M6iLjZAhFJAzNAA8/6hmZiaj/lcjKDpNElpjMjt/mauaMUph7QAU3cAahbZmgwL67LRG8gB3QgB2+QxW/QxV2MxXQQxlmMxUwkB02gBmKQB3NACIfRI6+mCr2ECrJwCXngBpDTTyorOe65x3t8g/GBATygC1cpgpdqqQmqbVn5CwH/CqpYd7E2Ekj7CK68QKACyo+8EAzDkMnGQIIlWILZonhINg3CAAlwwAZhAAU2UAIV415lERVG8JcRgJzomKx6q7dN2AEdkAN1AF+1g0fp9TKOaVIoIRM43ANKsAWb8K2U3AsljAu+oAgqbAFTyhLxFTz69bg5QMM0/AI0oAKMOAMzoAIqMAO4yTuBeCZw9JroGl0lUAKhKzPnKsGgK5zBebq1fAEd8ANn9npx0M9dHAf/7MUg8RFv4AZu0MVncAZucAZmcAY9IARQ4AZtQAiocAs94gqvFses8Ahq4HZAMDl1mcfuKQPJMtKoiAFw4BPwuy2/2NIHYsiJrJX156l8/6pLe1pINpJ8n+mZlbzTMoULPjEMB1KM1VGC6oE40cDJ1WAscCAEPrADNPBedosVszMVFeMBCjABI0BdyerAs5yc+NwBxPXKK0CQJjAXLwPMAtxyZWICdrgFQVAIAVnJA5rJvIALqPABFVABjjkzkFkRaHEVJEMEwzrDONAC7SzOiq0CmKZfZ6ImPiMCIBmcYcoSlY1SWJGvlF2clG3PHZCcLCAv/+YFpEPaaOAFXrAFXlAhqN1Fqo0GZrARZrAFVrAFNAAEQEAGYkDRt2CJuPY0rIAIbscEPkADGsC1edyyfHzSkOCVwiA6xkCWZOnSw5DIqPqVuuCpEIZ1RYu0uv/hEwO6Gz3yCrBQC7qAqsJQllDZK0/LDOMkHcn4DLWQByWdaHZLFlgBFTACrcHa1V19e7Y8RyOwAR7gOu51hS6zPlrRckKMAz/gBUHABi4VrgLqC5n8C6+QC0CgARZgE5V2c12hXxZn2OzVAgaR2IutAiZASr5TSoz22CQgnPpa2UbMAh5QAv86M5MNkrWstx1wA2BUOkpg2qfdRVGwEVagBEqwBEEQBEuwBH2rBFbA5EqgAjSwA0LQBIqgkrMw3rukCtjZB0wQBkCwAyrwAZ3XtSyr3NKbCl5Z3Qcilumd3mWps1+5lWDZCz0yvqugvtNjqv4YpJPMj8lXC7TAG7H/cN5cCb/AUh7g4ejfAd+ZhXjEkAjv8YYIWSTlaBJzNAEH7N96q6zr2MSoi2gAqxVisRAnseoYRxbhEgVPsAm+0I+9kBsWnpWw4At9oAEjkANUsiUk4zpUAXMvQ8OMaIfe3AI7TAM6vOKDGHQn8DKLqBf5GhN20ZoCXnP5WgId0M64vAHg7sQewEg6IFFe1EUZEQWrl+RGAOVNLl4/gANNPu8fYOU9AASNkEgaO96xhp1uwIA90M0qAO5pvuYv+wEckIq8oMiZLDpybpVVOZZWeeclLNO44I/jTQsXr3yk6pk+3algeOg+UZXpraDN0B3Aoh1Dli1c5gpw0Fwv0RVE/yAlKeoBE+AADrBy/+3APb7XFdABjckSwjMiTAIhEIIy5ogVXfQDiuAL/EjC1T09lPAB414kD0H0G2NSJGLYxt4CzK7D4AzOLQED23gDy8mIju0iXxpUKHFgwQmSwonL3P7tK+XtcLsv+7JRopRb17pTG7VGBsHsdsiIX28Dxi3SjyALvoBA07lLdLoJYeCeKoDcBKMBGgAtBt9PCc8BcOCVDJ/Jix76Eu+VBhqgAerxPTsUtGALugCQigyQPGvo3QWQvMAjlzxIQm0MfsegIygNypFk04AMpLA/LicWIzHztGeQK4fzoN7jtczVc5QVfKQxSlL0C3IlXbEgW/ADbv9wCxQuoKCfJ6iwA7ms9Vxx/uOzAmsU795s+C2Q4iuuFkkXPzqAJm+kF/5a7TOzEleaPAIr7gDRwUMHCxs8HLzgYQSJFiY6jBixYUOHhw8hmhjRocRGihRLaNAgcUOJDRIoZOCwo5KsW61aqVJ16hQoUIpkcPiQgcLOiR9AavggI8XQFByMcmA07FewYMOcMoUK1ekwpr6YUn3a1FevXlaDbeV1S2wusmR95RKbdhatW2hfrVLV6hUuXrp49frVi1ddXLVguUr1ixeuV6k6McpDwsXiGzpyuLiR48KEhBEmTHCw4DLlCRYuXLDQ2ULo0Qcj34isw3GNGjlUGzHiOLX/jsY4dBj5EQRVrrpcfSGj2itVLjIjWMC4AWMxDBiuXbNesQKHjRY0aKhokb2FCu7dW5x4ASP7ixcnWrgg34IEiRUmFJpwn1HhCBMlVoxoIQKiwREDFYJOyIOG8GuBoowiqiijjjqYiMEOKggpJJIeeIACDoCoZJNJHnmEEUYUAVEROnDiQCeeNghpgw9WXHGoD44qRaqpooLKFxv10iXHvXChBRcfaVkFMFJGIVIUUS6hhJIOO/TQQ0UQQYSQKAkh5A8rr8TSykS25DIRSCCJBZZUUoEkD0IoOeEGF3KQ4jHmThABodFCS2AzAD0ALTTKLhhBPxNYyAE2KaQwoobI/1gzNDLXjBiUNtd0wIEGQ4CxsalgKLWxlVwamWEEF1gwQU0YHM2hBiNKXeEFGmzAYbvqsHPVOu3Gs6HWE8xr4YUBW2iPvo1GuM8EFUpQ4ToccChBIxtUYIGkZC/S1dUWNtpo2GSt5chaFUZSIQWgVlTBpAwyEEMSQhSh8g9C/OhDkD2y2CnenSqoQN5xTaIAA30xkKFKLPOAI2CBBc4Sy0QI6bLLLy1h2JJMjBSFyDFTgYWWWnT8JeOMhSGmGGOSSaaZZp4heRqTq0FZm2q+2WabaUiBxDAS0nRMtRtmdoEEhC6IMwIH8CQtz8/4VGi9FVi4gdFBY1uNNUVzeJQ21P9UO1YPWeiyEZiybHlFlk1+sIEFFmo4Yc1RiSgV0RpokHZV6rRb9bpcdX3h2Ol0vRWiEVSYITpQk3V22wo+IFYFDcZt0dsKRmKwO8CTbZDBeiWQwIHKGThgAAYUUGBzzhU44IAABiA9A3bZzSP1OeaAww0JDmigAQY2Z8ABBx6gPHcKK0QJgzWshOPKLRlZuJNRKMY442CEEWYYj435GGSQRaa+epFJxt5k7aXhXhrtp/Fee5RRtqZ8aqhBmWVtdkmEFFEYGZuImmHQeWYPPPMghIMs0Ay0PUcLkN5McDQW1A02scnBDWoAqgGOzVAJRA1yUEOdIDgCE57wBCg+gQn/TCCJEptgRRxmMMAcwOcEMDACF2ADNUPZgAYzgGGtaDCd7MzQhXMjz92+Y4ITYMQDEmFQhOhVAXw9YHOhA13oMke6AQRgdE2EYhOd6EQAVNGKV8RiFrXIgT7kQRBdVB0d3CCHDFSIAvjaSQZY1KKTGEUGb4TEVDpWDGQgA3ofi570QqYMZVjPj390RjOcMchBRsOQhzSkMwzJPUR2j3vjO9/5qmGNlG1DGJDIhCoeQYix5aAFrhHBekgggs/kTz8Q8VmAEnKng1zkaCvITq2OtUDWZEdsanMac5JDHhrsQRGMeIQkHLEIEEFpEqwoRNiO1gIWiEAEt2laDXTAnRl0/wdbImHQBuYkkIGMJgILMIAApjhFLZbTnAB44gE4VzvbOWAnuYtXvez1gZOMy546eQAGKPCBTVTCD4Rolx78sAc66EEONKjnSeiVgZB8QCIramNQZMADWyCjGMTA6FSKsdE75hFkfATpH6nHDEI+g5AnjUYhFymNaECjkY585Piqgb7xmUwbyWCYLTbph+isoAOhtIAI5jSazXRmAt/cjAUQchCFvAc+99EbRIQ2GotAhKnzYaoFKuAEPbSrEIWgAx1Q14dJ+IEGP9jCD1hgAwUiqjGsyUGt5NoDG8xgVtZ6iELmpp0RWCACf/3rBIZIr8tsQJ4QOlxigaIBFzm0BP8zqFY1qVnNGbywBHWlQQlGQK/CbURCxKoV38aFgTCw4hGIYIQgvriHPcxhD26gwT3HdTiUGIVFOlHjRNcwDGMMA6NzNMZvNzrc4Xr0GMcF6TKYwYxlNHe5y+Xjc5frjOkOkqQqbeT3piFTlIFPGih7higsoYpLEEIQeVhAehVQAAMUoAALSEAC4Btf+bbzMkpVKp4C+J6LZKQAA2CvfBfgAMs85Fbx6U9/8OSBCEhABQXtgx8EoQc97MEP7ELFJ/zQAw7bADYrOMgKpNkeE9SVmnWlFkc0olkDYYQ+F8HVCejjYgWNAHDcAe0Ik0U4HP/KBkerD7E0AtkO1HUkR+7/QJCH1R0YPnYLSuiWBoyih1tMAhGNMG8h3MWuOciAoSA5CUhwskZ6nkQGO+iXHYv7PI56VI/SA2mcpRvd54qsj8+l7kmvq8hodE+736vGybpbjWbAAhKv8AQiFOGHOQTWZ4C9DGADOyfK6Cm/QwvQVfWmVcF65jOjoU8PD3TVUk5AAimQA2slbAc7FPSfrQDGJ9jQgx+oAD4jqEF0WAMfFmCLWiNJloNKcB0baxYiHeBrVE0Qp6veh0F7KwG9DEsvDXRgWNKGSAtatYLKdmckMKTPQzhiAYvA59km4FW1PpCCDAgiF49QBCUIwYhLXOKffZiDt3xSIoaihMz0zMAb/3fAg040A3rJUMabpydS6j2j4SWbRva+J/HvhW/iz/jzn2U68V9AwhWanMQiyMAG/FSAwEQtasorvaf7Bq2UFGFqRQRCEPyRez566yY3PWCCv2rgDK7mgx3kIFA9EOISwJCFIIAwgyR7gASsAVQNHIKRzlJrxSlWwQjyhp0TWPsEWZ95frlZgQkQRJuDpRcFiGgSslfgrw7pgHlq4JGNbIDpHDGsRBT8w4xMBIj00khRPjCJdzOCEogAhSxygQjUyWBF/n48mVOgAoYGxQc+uAX2qoc9znfe853PeOjFB+jxQfzinh9ZM5LxsUKb4hbwxoQgVMCEBx310ZCOtGUcbf8Zlad8qEMDWu/nhOnQ+I8zFtBAHLRsiEP4gQ988EMhzmQjTOwg63qC2s5hrnMTpAfuxNrIdvBDnvC8AD03UA8PjdZT+PzJISNgVUNegGK6b4SHO5zBD2BwqxSP4AXwYaYZqBWNmAj3kIh66YCf0IDH4oAZ2A1F4BBEYAVPuARE6ANCmAMf+AAacDzr4BsY6jYPTAEa6IEdUINh+DyMo7iS4byIS0HOo546sqMZ+Qoc4ZFXcIVVMIVR6IRMYJgv8ZBEgBJ/yYM+ACMzeYQLaoRHmAQ1aII8OCPAsh3LIDvbizSjSqqh0pM9wTT9ypOkApBSAprS0K/70SozMIRCWAT/R+ADNggE1RKER8gFZGgF2HqByZiAQamVZ0kwEmCB7DC3FCOWBBOBFXABQyEbFjiBFTiB9XABX1EQzQIiYTkQBRGJuqsqGxsgEqiAYOsPF4CBUDIP6oi2CuiPA1QRCkiBdduIGdAAJ8gFX2iEJSQELLvAf2qDHRhBGgiKVWSyaqIBXZy8YNwDYJgRG7kRH7EFWniFlziFUiCFHvTBHwRCRhDCKfGXPzDCbQSjgfHGbxQYN3ADNhDHcWSDMlCDMiBH1zKERsCESqiER/CDPFCDFpAA3msn3ruvT8O0UhJDTCvEnooOGgOaTHuPgSyl9juIy6gAJSgEQyCmNzADL3jI/ycBhWHwBUXgDj1ZgWWZgRQoAWbaubHBCIzIphUryfbwGxYgsfajjxootr47QI0oNs2iqgcZLIqgqmAzgU4UiFBCgcngAkBIAyJ4gQo4iAjwgArQqgQsAXChAJDAgB2YBFDwEEoAkSphPD8oA59YxXV7kRZ5ozPTxRnogSDogTPQA3CEg9VZnbZ0S7dMHdWJy7pkndYpx3JkgzPgyzPIgiyoAiqYgiNAAsIsAg7zQGvqFp/QAHnZCQzgABnIAkP4BEdwAzGYg0OYAbJztE/zNH9MiBAQTf3ZmYTQD4EcyKtSTacayPZzSQ9gSBuAyEVYhDF4Ay8YBEEwBMQbBmRABf8hIAnBEpZ1Gwpbgw9D8Zv2CDb7cw+MmAGxARWxqQ8DWQEcG5ZsqoCO0IAhYshpy4ANULt66UTAISLKIKUQmAAI+IJQCIVIAARAOARAuIFSIoHuYwGz/AG02gIxYIM9qEpgYpKsVC05eIMCRQO+FAMzOAMyYFAxcFAygIIwGAMyUEd0VAM1WIMwCIMmaAImeAInOAIO24ERtY4SVQGheCOi+EoOUMAWBYnBygC0o7btlKd4yZ0b3R3coZw0+gAxkIMyaAKrCQQbqMLLwMOi6kehSdJWGiCBHCAX0yxj2zkXS8mWhI/RsDtBWIRGWAQOw4NDMARDiLffyAU3AEnDWkz/4vyVERBAGOqBF6IsAQSbD4ShbinOr5w8EPxAxbQODqO1/PwBIWACIAACJggDMRiDMTADNDCDLTgDL0iDOviCoLwAEAAETYgE9wSESNCE9gSEOrgD+DwEPGA1NOACNHgDLDiDRWAFVHiES7CEaiQELRMDnKAtG8VRy4mdBqiQHPXVGwXWYBXWYaWcdjLW2UFWZP2c2eEcJXLWZ4VWJYqdB7gQNSgEZMgFP9gI2IyA0EBKMzRDboI5csvEBNMs1wyybDqyiagxTRxIAlqcx9KDNXQEQxCEQRgE5gORl1AENdiBGdgAFfDTHShBDlOCH1ACKEhYhTUDMlhUVH0DNIiD/zeQg4qtWDqQg7AqKNaisI6lsLAiKI2Vg4mVAzdog5NlgwsNAydg2SMAVBooAhxYDxAYAhQAgyEAgZzNWQhAgTvI1E11zzu4gzooSoa8HRVQw0ZIEkr4kqwkBA5oANth1s+hWgVIgCQKHdrB2mdloq712q8lnXES27EdW7BlImhdp9mZVh1NI35LCTXwA8IbBlkgBG/RgHvMJrzzO27BlsnqjhKtlfz80yAgXCWIAjOwAiVYgi1gXMZFg8d93AKNWIgtBEew3MrVTX1tBFY4i8o8hECwg0DgA3fhAz3AAzzQWDqIg4md2Dc4A9dd1ETNgg89giMgXD810ck7UaH4yv8VEYmfGC19cswb/SsCiwAIoFkwQAEQgAAEgIDmfV7kxVQUAIQhAAQwCNVQ/QIuuIMRKDsv4ANJmIQk4ZBiIgQM6NpxOqf1Zd9yEluzddbP2VVe9VUzcsx8kS17IpEXiUyj2IEmCIM1OBNSSJJFG9k0INXTxYPne75AcOAHHoQHVq0LY+DTreAFfj4L5gPRXWAFVmBW01g72ALI1YNGcARJSMMUFlNFuAVQMAQ52IIeANgl+wBrQRHGpC3aGpc0Ujt7ud8ffifK0VFjvR0KcYDZSa/44pz4ai8DMADkBYGbhV7njd7nBYRQwN6brd5IGII6+NRN1YEIsLYgGAR4xIT/fopHRMgDKbqiALCi93WisGUidCpbsI3WO5bWBoCd+a3ffNEXyBvLEb08IABgMbhQN4DLCrMwQZASKfmlJMmESO4ETpgEQ9gDO4gDRt0CLcgCJyiCH8Dd63C8nNjhndBRYoWnMzrWqfUcBYhazrkdDYi+NHxILZM+8wICGWhMCjjiZF3WZsXjJSKd//JasnXj9j2nY8aiACAAKIZiBIBmBGBe5L3U6t1iTdhUMIiEL6gDTbiDy8CBEXCwJRgExSsLQaCnI1InZNVR3DkjCsicYIadPd7V3dkXDABkNDuzy/MBJliDf/7ngJnL1DHCf6KSg6aSIYSShWZoKCmmYnLo/18iHkiI1YbZpC5ig8wiCRRREYfqCRQp5Xd+gMxhgAcgYiI+ZdxJ1laOXwfQABVwAAWwHAqgg0UQ0zRcaCnZAQqgEAUwAABLX7FF5qEm6iyaIvaK52F23kqFAAKQ5iqeZjBgTzDYVEDIBfZkT0zVhEOIAAOIgBGYQgs4hFAIhA6Ig0OILRMBCTUa0R5AgikogzIQxwxsgisIAzdYAzVwA732RoLuqq7agz4I7MG+sAvbxj/wA3VB6MVm7MZe7IOpEoRJmMkeni+xbIpmGDhIWTKIAhy4TnXlaLTr4dxxgMyR6ZNuJ2VNomImW9IRnQAInQY4AxChTUXzEHjjACX62v/3NdveZqICOADglufhTuoBcNbYmWc9ZoDPiF4qruLoper3vNRQ6FT25NRMrYMKMIAO8BnbuQNsnoACcIAT4B8LKIExWEN4lAT1loRNWMIOUjRs/BB1mRJEEELFXuwraWz8Tpf9Lpj/1hLKVhjLZhiIGQVYiIUE34UFZ3AM6MWJWDtgbadiNdbKEdYzIm2TTm3ZWWlkvZ3bSeV8UUUTFIRKuAVKAYYU9wVW8AMgeJEMEN4glgAKmfH6fYC1tXF33pejkKiJ2oHLC+CAhoMitBIqEUJgooRLiGRSSAVmjIkM44LnZd5ojl6dhV4pZ16dzVkwoOohwAGmLF4u2Gou+Kv/EIiABECABSgACTiE9u4nSaDXJWRaSLDvRLBG4hHwPBfwO79sArcEiDGS40HwBFdwBtcYjhGu42ou5YIGl2Kp7jmf8pF0a7gGb/CGa7CnFEGRCviyiaAWJuvTIPiBIqjd2g2CJ4ACVA8CIUD1J0BLPy3BF+KbWf/IEz1RGNoBDRA4AJ6DX6q3Xz+8ORADDeVQDTVkvZ6DCou+h9xSJpyEersgUEAFVmAFuZgFWxgLs0BGr/AKGZGKppiKcHceYuCjYhiGFM+FG4Dmaa5yqG5eaK5i551yKPbZT/WZEIiEUDiEC0gvBAgBIvArKTgETahu68aDQDjhSoDVHvxzURAT/zGJGEJncEPfmN8iBkVfhkFyqT6TBvQpn5bhhpDfBm74hpKfh5NH+ZSXB3mgh3pw+ZavB5anh5mH+XZwh3iIB3fQ+Z2Hh57X+XQQAycg1FfvAUL1ARIt0aQvUYIdWIJtaw4DAiFwgiZwAv682FS7MNX6qjCFSBO23GEKJkmQBEwABU5Q8iSpN07gBFaQhbaXhVlIi7LIGmAA93CXwbuvozvC+7vvqL73ez1Shjzio+aqBmcwhjrKBRIgAKfeWSgeApzdcuelYnnHcikfgki42VCoA21uz29GgNCALwcQAAcgeKwOhVy4gwuAgAtYTxR8BpXRBm1omZKnfdpP+dvH/f95qAfdd/l6wAffx4fg9wd8GP7gN/7jR37j94flZ/7md35+4Id8iP7pl/7qp/5CdtALVYMhL0IJE4SHPATaPGGxN+NN+ITzR39UUP/1n3a2d/v3h/+2p3b3lwVWkPb6Z/tWkIlSkAmZQAW3B4hZtAbSsnULVy5fCn0Fazjs4cNiEo1RpJjsIsaMF5U16+ixo7OQIqNFk2ZyGspqKrVp+7ZN27NcIAggQAABxBAIN4cAAoMzUigQCGjWBAHipk6dICJpAgQoEhhAoSINuXDnTgQBHbyUWHAnlKZQYnOFylkTAU5NyFhu2/ZtnrW38+bOq2e3Xt28ePfexVcPH2B8/gT/+yvMz9/hwooXM1b87zHkyJL/8TtsGTFiypr5gers+RQqVq1Gt2LFShbq1LJKq5412jVp06Jnl2alShXp3KRv5y5FKhVw3K1MAU9lSlUqVatcMYflHFatWrp08eLVi9evX8KIcZd47Pt3ZcuYiUSZshrL9G3bfmvv/v179vBfapN14SyEnEdxgoE6pH9QEBAFQk9HEUCATkMAFUlPPDH1xQWAaBKIAyUc4ogjYmkoSy6RHGUTgTnRMMkw6LkVizVz2SWYX3e56GJggDWGWGU12ngjjjduRlmONWKW2Iz+YDJkJkUaeaSRlyC5ZJGWWHIJlJkoWeQlTi4pSiaiaLkl/5eijPJlKs4BB0sswmT3yy7Y/VIMeOEt44w006DHlnxyzQMfnnnOF9969GlTzTTPCNqMMcSYyQsusoRyBwQ10YRUozsV2F8kQ+33lE+R6gSGWAyCERUgX8QQgQEOWBDBAg5IUIJUYn0C1hBD1ZTfEDMR4IAVslRDyx/TbDPPOuvQQ4868hgbbLDyIBusOs2i44476aQDrTjooMMOO9aiI2053XpbjrTSkjOuO+OmA2458Hw7TrfhluPOu+nCMy+99Dp5ryVa5tsll2AW51wsAQcc3S4FG7zLmdt1590xyog3kkknqWSNSujRdedLbum5sZ59pgdoNMwoc0wxhqIZcP8q+kICSSKJ/PEyHHCssYYPPPgQRs088CADzxacNdSjkCr11IKAgPjpp0YpJRSnmkT1qVMICLCAAAIYEAIRFjjgQQwkHAKULB5KTRMIUZllkwh88GBJS/Moayzcx64j97LOQistPOVquze337Y7LuDkuOs34dESPm889MazODzCOM4d5G0uM/ky0EBDUknTULM5NdZ4fs011oDODemlc2OOOsnKA5+x9Mzj+l5zvXXPPcOq6BfGLLnX1p/TOONRMsU43ksvutQCi3GjZGIJJSszgggiL/+RR8wzW+9DzjrvzLMMHHD/AfgciE9DCjxz8EEJEczqKII3+fQhBKEAQxb/VO475RQYOUEqFVRJR3XBAkKAgggQYAF1qIMDXgCIEFhAQ1+YCX7+AwhIIWABPmhGe+ZGD2PVI25vk5vc1PGscOUtHXsbBwr75rd0kEMc4gCcOMJ1Lr+pS4bQqtfiEucOeMQjH4kD3TVI540hDrFZyGoWEkVoLRQycRzjwpa2ziHFc3QDhVM8B7awBa3F2cMe+ojHF93RjnW8Ax76OOM79NGPwWwjFqKwxMri2LKWSa+Of+hDH/KQRzz2wQ990AMg9UCHOeQhD3OIGSLh0AY1iKEJ2NvBDh7JPRpQUgU0UAEmVTCDTLbAAwL6WdAgwClAKA0QwACGJlLpE1Ddb5Vl/yubJjyFNJ8QIAABQIAAJ0AAEkRiEHXgAlCmYqBalQ1qR0mKBFzRnmYNi4PN9KCy5qYsu4UrWuTQVhNV+C0WurCF3QQc4dolrh0qroeJQxzjumiPd7CzjIjjIeOyKE93nANa9oQWE6+oT3fEYx//WKG0mjgOvJEzh/aIxz/8cY1drEF7cDhkG9aASOol8qEVnWgh56BROLghoxqdgxvY4IaRnkEMWXCCE8LQBCYIoaVMAIIToPCEmT5hCU8YAxq2wAUp6BKUSSkbpmoFBmAgIxQx4JSHnoKppElQQbGcZVQihQBbCuBAMdBEasgSCjA0Ci3/4YlTjgmBCQyiJd8YFv892gE3tEIzWcwSoQxNOA5sMrEc5PBb4MblwhcGLpzvutsN6fWOdbaznfaYzI74oZl/7IN2jj0jZCOrzi7SrjDsZMc7uGgPHzIucelKHGjzwY9ygtYf9NAGJNbQhJ3FFAphEEIY1KCGMIRBDGcogxe6UAY1iJQNsv0tG9oQUTYEl7i+la0YkmvSJhwBCD0AAkuBAATsYU+60j0CSp2QBTN8QQcCquqBQpkfCYXlKac8hBTkF4qnTOVTVBnvECTYoFbWhAQoCMF3HXAIsShKLKTUFH86lRQIkAAZcqlHWjHrumfCbVlvFSHgpLVEuqKQrzC0sDdj+E2/Tita5BTsOzD/e1nM3mNGCT2xP06MWMn0qMWK5ZGLb7SYxwxmHsWQGRAgGYaZ0Za2sGXCDihJyR4E4QlQODKSZdtjIQABtj5mMnV9AEkVcK98MviA+M6XghSAz8op2IEKPDBVAAQAAFW7ZVdFqaFQ5CIXrNDQKXPRSkr15FP5qcPXVtkTCNiyzFMLwRfqAJSwaOhsOqkzUCYYKT78qh7tkUc7wGgXBkfTwUhc4lzRMVcULnGv39RrDAP3wnR8uprW7LA72NnFworYsCUOkokVK+vExjhHkKm1jwYjGBo7WhRwYGQPVNDSJr92BzKggASSTYEKbKADmJwBtGdASUhSu9qQ5B62ucyB/wxwe9sZwAAGuB1ubnMby94rQQL6TGYCVM1RaOHfJ4iKjHm3ud53yF+rxOJeQBwiDRLC93ptEgIC9jlVcQhFf9crlEch4D+c2ip+UPGNv2SQHpWhh7A22ODUOXgd6mjHCZvYaXGEI8LiElwL86pyc+3Qw/NqdYhFjC1V2+Me6DxnYPNmz3ntPOf1uvnPeYjDyvhwsvvYRxeP3kV+2AMw/dDHP+4xj2m4zJBuaIMg/KAHObzhCRqQQAEGoAAGSIACGuhBBmSwA5yiAQ1iaMNGYzYHuAtXuMclLhnGIAYnvBQIQegB4AO/A8D/vQdFYIIYoECCCQz4Z2eOH1EFhYxnsP8kJqcEBlhycfk2R6LzYMGDoOMroUiQYAFcAEQaTnABB4TdAXjoFFTgl5/8PW3hCDABBgWzjm/Igx5nXJ3GG+zBJCoR05pmIjlKLjhudpP5d+3WyqdlasSxeuYinqzN63VPct7zsoVtZ9B1uPOg04vo8Tgo+s+vfnvAgx/5kBHU8TGPXbysD3MILh/4sIc3bKEEAwDAADDAASiADKwBIeRB90DSGXgBGrjBG8iBHHwUBE6gHLQBG5yBSLnBGZTU3sXUEwSBEARBEPwA4RXBEZhgEiQeFBhBHTSIWEmNAOQHMAiKoPxJejwDh2je5c2PokiIhnRe/zhFCLCbAEzAF0T/wiHUwSBYgQQ4QAuARf3MiighTXx9yAXYQe79g1r1nj68A/B50NxI07LIQ/ExETqIAxOFg/JdmLn0lbeYiw2NHzx9H2YRlqrdgzqNmDy1Uxa9Q1q1AyAGoiACYrPYQ7Zci/f1YTuJFj+AFuOU07yI1rCwEzrIgzYkAhxMzxyoQRsEQiDEgR0sgQQYwAFIwAMQQjBMgza8BDKAgpSRQQ+8AR9AoBtMYBxw3QSG1AUSlxqUQXKFgRMk3hMIgUz93XUxARNoFxlAwRuggRL42yEAgn4YxQWgwCEgQzPQIA3OCTIoSpxpXr0F05pBhVQAQgRMwAUYgC1FwAV4wFQQARE4/8AgKNzPlM271cpVBMIhHMIr/Io/dBFabdBZtc6xkCHHGdE6mINCmsM4uBDy9dVeOVFeEU44ZFo1dRg85KEi1uE61SHtGOIhWgsUyRM7NAshEh9KXpo6sEM7uIMItUNJsqQYYVZlnFPilBFOwkMZxYNpGaQ3fIMwZGIeWSAb5B8oWkEHqIoEfMDkGUMtUN40+MIOYEAPREEg8EEc3KIc0EEcpIEdPKAcjFRIYaBs+aIY0FYWQEFMxRSTQZd2ZUEWiEHejcEYvIFdBgISXoVT7NcnTN4zzBswsEIjNMIi7CMdBMInaN68IcP85IIs7CBZmFconJ4mJGEHRMA54oEmpP9BC1hAWJhFVR0Nf/SHI0yCJCzCI+QeQNpO62yQxoXhESWRQqpDQ6LhXKmcQ0okqN1V4IQDGm6LtJSL4OikHbbazHlfzdHOQi4ncy5k8V0LFEFndFqLO7ADPLBDdWbns1hnzNnDPxaWPHihH9pDeJYYggXLN2iDJaxBIcEBcZ1BIOBBHKABDlRAqozdHkgCEwzAHwwDI8hAspXAV/hSHNCBHGRlGmQl143UG4TUSL3nbZmlGOjdEzRBE2iXGJhlGZwBGZCBSNHBHhiCJHyCLFSm50UeMqBCFTDAAATAALSoiw7AAVDAGcQbYO7g5U2F/ABDJHCB/JDFIIxABZxAHaT/Epv9F7sdyKzEHiDkAiY8giRIwiOsgja8DlpNWu+5ZkHSTbOgDhKZgzf8JjqIWm4inxquIeD4JhrCIcsV1mSFGDvBUw710N6owzmYAxWJg0J2gzco5DmgkODYU1zFYTXFA2DdUzoM1j3EnHiGJz2Q5zsUxgapQ3vcGEe5wf1d4B7QQdupQAIswAKEXQEogAQcwAfIgAIoQAQ4ABcQmnxyJYJm5RvEwazapV1aYBuM5W1t4G0pVxlIaIaWFBm4AR0IgiJIwiZwCOYBRS7M2ynIwP8BgLROK7WSmakugi8sJmPiKFFpnlgs5ifQwCAcwiAApoc0SngJwFmYTSQAAyhk/0IlOIIiJAIxvMWVTpqVvmalvZWXdmmYMpGnkZxAjcOZlty3JJ+nLR9G8qFj4eE6HVQ+RKziKOyYNqQTDew3yZDJDSrLwcPeQOfO+dANYSd3xkMZNZY9KCQ3VMMoXIEanMHVEeUe+AEdBAHYOUAC5OynJgADOAADGACoKsgP2kGBQqBdZiXS0qqtooFd8qpx4V2HRq1ZwiwbzIEfFIIiTAKJ6mBgssK80cEBlFmZVSvZklkBZIAjyBsyDMO2DsMpMSbcMmabqS1jZoqjVI2STqEpgQInXEIlPEIiWEI1uEWW3sMZIdgzzQ1KzuaX/mttepqa5mbygdO3+GY2pcO8fP/fYFFWF+VQxHJWF0VuwqZpRV5TOgzUyeVVuETY3ZDDOfANdkZL++VDtBiqHCrqPoyDOmzDM/xBGJRBSHkoG5TBHuzBJwRCCSjAqDoA82Km8ybABQCIhmjCHRTtgYLiAdWBHdSBrKZBrfLqGaDBGbwBG4gvGwhvrorUHICoIWQtKsiCL5wS2wKmHRRAANhv2ZJtn4mdCqiF5M3bQ8TtYr6ttiJDLtQKugqAnz1K2bQrKnACJVDCIxDCH/CCWQ2L4fYD4uprEnlcc4Kpbe5Vb0aubirfG1qutgRndcKcYT2sI4pWPiCdbZohwDKROYiDCDEkpmWaSGpadA5qcL7LtMD/QzpUBj+BWDu1w19Uxjlsgy6swUhRYFiG6GNWAmeWAAOkKqie4xDcQecRmlg0RR3cgR3YARcMwRcMAQrc1wRMwAmkAR7YwRa0QAVEQAVUQAd0QAlgUgmkAA1swQPOgR74gSAUwiIgKyvcQvxCxOQBAw0ogAEYQAFMMiVXctVUTQEIQCUrgAOUgSz4JQ0WMLcS1fzEHgRc8pmpq/vIjyycAhwhgh7kQa/8SmAUxqT9YUp+qXPSpkCBmm+SKTiAA246ZFwdcWENCyCuAzvUXBcxImeJLhoGrEIO0XIKlPFpGt9orOB8y92Ilg5lbhLLQ124nzpUQyKEwUgJVy1OcSXM/22bKUospdIXe56GaJWigcAFKOmBKHBVBQAM5IAFJEABRDJBT7IBpGqpaMATgCghK0IjaC0r6GAwzFs2IoMcNAAD5GwkVzJHX/IAYDIlK8ABaEAj+OWfzC+OirKcHdNQoLIql81jygIoQAIjHGAbwEEquAWCEcY9IO5JpqSXMu7xVdheqWHAkty4BLMwj4sZohr3yRwybyEzb9bnLk7BqqmaZgMRZYNWf3AI56Y+nQPKbayp9VDe1As7AeJfPMY1/ILNEFfdRTEdoMIzLCv+QA2oiOOaKVyaLc2H5O0CEIAka/ICJIAmT/JHqyoFqMAZ7IEhR+knRPTlza+gSMIDYP+0zibARg+0JFvyJR8IJZNiA9DBDArKMAQDt2prt2aKTrR0Lb10kwamJzwCIhygGqzBHxzDNsjDPSSGw5KnQS4ucw4RUbuQGgbzVZ8pySn1Ujf1+EWLzAnisFDWPcxpxGI1VrsQV2/3NWg1EVFzRT6uFemTtGRscLIQEbvDaP1cWreDjNADNUDCWwdXXNdiSTcDj+aPUew31Igjg3Qe0hjFpzicnf0M0EzypxYAuw10ASSABZyKqmiAs1GSE5wBHfiBPjrCJpjGJ3wAJ+NsZhO0Znc2RycpJb/oARyADHyC5M3vjao2j6KAWDVKKtsET7DZJkyCIhBCH7jnzAiuOuT/Q0L5xaoZSy536UJ6QzZEM+QGM8kl93EzNwkr7D3V4TtIdz1Qt01et3F793ZzNRB1t5d79zX0KREp5HhP0fGZnDXBg+Csd5VfeTsUBj58wzE01A4Ylzrnahv0gS3gtyacjYGIkg82RVT84PuMZtIYeGEbQM4WNgEkgGAX0AVEQCYLwACE9ovGqIweQAM0QCn6bCSDamHrrKMXNEcrOGjbry3JKAUYwmIG8EOordsCw3813j6r8n9EwifIayH0+MzAQROsgTB8gzu8n18kLkmGJDr0q5KX6VE/OZQXLDYYtXmTE821Q7HIQx7SzpbnQ8GKeZiDDhGJ+ZdnQ3d/N5qn//kVBc60BKrgRKztQgtmtcM7JFQ9bMMobA9vPa1dyoEaQAJqy0IdIACZNQoAIAC/RcIdtKAm1BvmkRI+30QxdZWSfqoDlHoCOEAFpUoIpKNLVw2M9tn+uijzQjLQknpma/RmlzgBTLK0cjoDdMEny7rbsu1fAoMs3MF+v2AtBQCCSFAkGIIgxHL10IwPJII04IM+AAbiRtNxTic69Kk6gGk2WC7AirBxU3tyV7u1j9oQ66SiAqKxdHt1e24+VPu4rz3bd3eYbzcRdYPcVxG7X9GYshDeuB+q1fu9+8M8MAMc8EwKkIFsXeAZtMEb4MEbEIIOhkIdnDJaQEAdIBzDP/98DtqzjCfFBRhIrlfVJGNyeB1IG+d6n10ymZH86We6A0By6zEvqK78iKc6JR8ItdqSAZTAwbl43P7lMKwXgRMTjVfNTtyBIwjCHhi9zCA9D+wCN/xFi2zQW2l7tkzROPTpNMN9mEp75E47lCesU3OkYdEcdct7PKh927O96Lj92nv33NM9u1vRGbpDDElLZagw3/9DndfCzqSABhC+4TMtQLyxY8cNKmDDgAELBQYMIE2hcoUCFClUxVwRK0YaAgLEBQgXIiBAYICAgAAmTwpQqbIkggUECBhYORNlAJs3bTqQsMCAgQIOgDpYsCBB0aI9fRZIWqBASQEAoAK4meD/hBdNw5BlxYrsWdaIgMDeATOELAgELUEMAeTIjx46eeCsWaNmxw4eiaB9w+evXj168tatUzdYHTp05xCPM7fYnDfHj8NFliyOsmRs2CRn1hxOHLl08OC5S8fOXul3pe29O436nj9++eLFi+w42zXbtq1Zu31N97Xa1xzvzpbNsbluxxcPHocYsWHn5KC7i8cvnrtz6NixU7eO7zdLa5w8mUFGjZozZ968SaPDiJcyqJBtRRZKU/1IdQABu5jQYkQwKDgCYQIHEkhKpaaYKoClkhKYgCSfemIKqQQpZEoAAySgICgGhBrKKKMmrNDClQgQUYAFJFDkGW2eaXHFZ6pB/0ahSMICC6whIBAJAhAAwYMPt+aYA44hhRgDjj9++aYef+jBhx516pHnScIKM2ycwRbzZrjHtCTOG3Ewq2wzzDgTZzLP0nEntDTtuSe1e+CMs7Q46bwnMuB+uy233Xr7LbjbhiOOsUHNWY6565xLxzM188nHHeze0U4dfOZR5g81zOhhPDLIOC+9NGpAYwk9/PAlK2RyiSQSTVQFIxT9ZKnIIoUA+U9AoYpqSgAKYeoVJgcimBCpYZeSECkFNqiAAgmCAmoooj4sMKliSRRRwQIaeKAPZLRhscVqqhnmq0gOOWQiVQHBUaQvAqHjRzmCFBKOMMJQIw9ItJmHSXn8qv+nm8HaIYwdK7FsbEvGilssMjPHDLOzMMdBMx1FP4vznTrj9EfjjTXOjM/cQMZtt5FHzoZQxrohVLlxDJtYzXsilXSweb4ZZQ0xnuhhB045ZQONn23owYlGZLllqxlXBUvWpSHKaCwSIsA1AZgSeKlECZsiYAELeJKWWGGHLYpDFTrQYNlmHWCAgWehPSpEpgYYgMIDCwgg7mzXAKaaZ5qZphoWcWmkXE1kYUWWT8g9BIwLLgBkEDqAhFeONuatd8hd5nHSHMAAo4eegKlUZ1DavDFH9MZKX0zMzC5rfeHLOCOnnIk7+wy1d2LLPZ86NY7TTMxGBnlP3nojuWTjjkv/eTHkGFMuUXegd3Pg09WZR5o/4MiiByB2GINnMn5GY4YdmhDk1FNZZbUhVSt6qCL96LuDiwsWiFokqh1QqsKYIggh2v/dZoAPKcABJegBDUqgLAkskFlAUdvaPPSht1VoJXULwAEOkC0ZwOcZfutWM3yRi1sEQyvAkAUqKmKuQ/ghD0CagxzgVTk1sCEPiYjGPOixjnoIRh4BAx1hTvaYLNHGS+P4HZki0zolhgN24SCHmhYFD9WoJnex2R3M5uSm1IQDHJHJE/FCBkbjjexL4zCjGRNjqOagg2WGyc7ASvPDdXzjG7tYAxuYUJcdiOF7Z/iZDIBwhTPcAkaoAoaq/zQyBIYAgmmvUohEhjCBBQDlfjD5moQWEAL6PatqHmLbh57FAAq8wQlMmEEKNkCBCiiwgRuCIFHaViBrHegmciMgBdbgi2ns8m/bqMY0tPG3XSYjGLc4XCUU0Qc45OGFcniDHIZErzCIYUij+AY31CGlwAxmmwVbHsJK16XfDOeIsEOiEpfoRIlB743vAE1s9hHPfWQRTqVZmDi+KLzehHGMtinjGQF6xjU6BzvZQcdpfiiPb2gjETcTQl1kMAYz8MyPZ6DBDspwBky8CBey0EStQDCW9T1kVRnRDyCgBqy2kYQA0pKlACOAggF1qJNss2koHdADR7hBDD+ggQoq0P+BZC2Lga1Mm01BVCwFqQQnuyrAAQaAgUw0A0bB7JZVg9mMYeCiFaCYBCIIkQdmwhCGQ/KBNOXyh2N8Qx7XyKY8tHm6k4HTHIGyazYYhs4kLhF2DDOTxLKjmnfGQ57/yJg/4nTPfO5Jn/30BqDEEdDlmLEbigFiodw4sHO843OBWQc3fiGXMTxUBjLIgvd49rMZAOEJZyDEMD74FbIokiEM2cgFUCCCCVDkDiGIQAQGFEtQKkABk7xAJIHlLLQ1a5LNkkAgWOEHNpghCC0YgQpKkKxVLouoRnUWJ49CoQE8RSpNlcoB4MCLZEyjqn/rVjW02otZgEIShygEH8YKQ3n/7SAMQgiDXNYAiWrMwxrY3M6B5zqobjwmUJC1DJnQGeHMgIMyngmsO+EBz338w7AYu4eZzJin2jBWN8UjGW1sM5zjoPE65xhHZU1XMDMWlI3s+ItguMHQswpBCKWVwROiMAbUmkF8NtgCGfJAC3B1RSIhre1GIBDlHDFOB5q4A9QiUAFmvXIo3wVW/4YAkglE7cvLBcpvgUUBDWgCGIuQAx3MgAMb2GAGJRCqdleprN/umczgDS/cooKTQA+AA4rgBVdgBK5hDqMXXZXEIgLxoxc+k3Jw8IEPhKCG//pgDb/YBh1TRg9zCKZ5ckUZcewKKLzmVTMRbl0XZVfh0cQs/8PxsEc8eweneMZpHOHohq+x4ZtukMzEKbYrEYmTPOYZh8UuxlLEIoYOfOzFHueYIzGaQC8hCxkKUdiCRCVKZPUMRA+q2GVXgJEu23JEyu1mHFh0IIIaRG0BCuhkTRNQXKBcIAZkdqCZHUDcofxWAj0wCCXgcIYjqGAELKhzdrdLge42iwHEdZvbCjBemjD1JHJ7agOAsIhcYKWDv3xGMHjRik9MYhGFKAQd6EDWObShDTNnQxvYoAa5MOIZ2+BGX/rSDndML3Qo0xIRH+sbb+zVda5jemTAIbtyQOeJ74AU7uyRD33coy974cdr+DFtyr5Y2cPWU7F9c1e7Ii95KP9r9jkYE7GJSXsv/9jHNbSRCUw/ge/d9va3hWwGIpNBIHZ4wyRclJBIMCRAjQ9QjkDwBUDoIAc62EAEJunvL/M5AiSQwgTGHAFmFbWoavuyBCqgB1YAYxZ9mMMYgmADJfxgBjMwAcTxTNQzfxeWEVyKUziuEo8XgIBZaMTIkUFVENoCFJiQhCIEsQc6NFMObqD59dmQfZ2vARY+z1xf1JGdwXAjOXJdsJeGs5sv5RXCTWQiEqNejnLUbujsOM1qtI6PrrsmH9SREkCTZxyuIXn6SdXSL1DKLgG74VAUYzHOYe6mzR/+4R2s4RjWwAeCgO+UoNu+bQu8LdwmymfiwF3/PkET8EAKUGAIAIQjZksF2U0ACAACYqAOhkAHbsAELAD1xmwCLMACOmAERgDPYOALPMACIi7PlEXiKOABFmgCVokGHEEWfAEYHiEP4EwJ0GALZu+AsAu7sku7JE7LKEDzgiKCcmWpNi5BDECU2GATbiEXfMEXWgEVQKESGqEQoi9esC/7+DDndI4H1Gob1mHa8IEwvIEbyM90lofBiEj9vuTB3q+J3C/qoMOJJsb+VMMd7CEe9GHauq5R+u8e5IEaXOyMVmwAj+M2uuGuVE04skEBy44Bx6F0xmHuNMawusEaRIEHhIDvnmADoyAYo6DbQHAMoAAN0gANcOAEJoAE/zoiQFoQBHLkfgRAJERiAk5AB1ZAqCpgA4DQBGjABn7gB2zg9jwgB+rgBG7vzjqgHe9sA1JJ4ixgBErADTCBFXIBGFiBEPzgDdAgDt6ADKJACYLggGyABmbAC4VKBfBsB/msDH0PDTMubjLOJxRAAlJADRABEzxhEiZBEhrBEPIwSPaQD8vjJNWAB3hAFPKFHjRmMA4xERXxOBixS1zxwTDD6dIJ1iLDM8jhHAyKHaTDHvTBc1wyHrTuHOrBGoiBAVessgjwOLyowYxHxWCx7cyhOWaRFg3jFs/BGpxhDWSACZ6AxzYQCqBACZTg7wKvBxjSAi7gGVlQGtsNAWbCV/9gkAAQIARgoAZsYAVGYAbm7AeWAHzSwAuCwPak4A50wC9ZQAUgUwVawAQiM7s0YANKQAV6wBA+gRVuoRd84REKYQ/kwC3eoA2yMC0JsgfmbAZWQAVoIAVoAB47AAkrIPSips+IwidmAm50ZVcyKAN6gA78AA/3QA+YKUjgAOdO0g/VQAygMwxkgAfWoBj0wjVEBxG5wRuWY4i4xGBqI+nSLv30iunA4Ty7iIsokTImJh2uTkroYTr4QR/04Ry64RhiwcUSY8UQo+yyYSrTj2Qa7CqZZ40agzHOoXdyMRY4QAZ4LAiC4CzVci23oEK/LQMkIAEcoC4RIEc4DiY6VMr/pNEp9PICstEIxBEKgsB70oMO8AAP3kAJbIALAOELjGAcB7MH5GzOaCA2M1Mw0aASQIEVZiEfWUERCsEP/OBH6AAgwycL1ZIcbYAJ2IAPzAAy7awE7GwDjBD0QA/NVkpBxktuyqvjBsAAFIACaMAM3sANco5yaM45ywM6xSAMskA6p1PA5mEf+EEdtHM7EcM7hYh0kk7tylOJ0DNRz5MyxKE9Wcb+5KE0kDIfygEe5AEadiEVWIzsDCWgNOOLDPAVCVR5HBDuEiZB+eIaluEPMOADgABChWBCJ5QDAU8DQsIuaSIG240FyWLdIMAkYhAEpMAIOjA95GAPWm5JIy0O/9DgCyLhDn5mDDzQC7ygQgeS73qgB35ACbZgED5hSF/hFkIIExbBEAwBD/mASWGODtLjZzzQDRahEhxBe3r0IFvAC+2sHVcJzQgkAUZEJaICKprqJz6ASq2vDaxPTueUTsWAAziAOoXhOv1UO72BeYToQMVJnP6z1VwNGxRVUakuTTwjw1BjOvIBHs6BGn5hFEZBoDh17DoVwqrSrkaVVAtlKxHRdBCLHrZhF3igVXsAQoVWLVXT2wRvDGZgAjxiV6Os8WirtmorLeyyQ4fgC9CADzQhEN5AD/RgElgBE87VEAaBD+ygDiIhEOwgDgDyDdRWPdDAH9EALccADeSgEv82YUhbgRZwARha4REawRHKFQ8jzUf4AA8Gom33QBM+ARXoQAyoYAmidEdbYHKxK1lCD1cixCQCVmDLSwDihgEyYAcQ1g3clA3OACWfEzrVAAMalAcYYcAKERG3wTGOQ3QuNpzUbjg2g+nM6WMT1Sc/I00y7B7yYR/6Lx78oQJjQRREoRQlC6Bc7FOpUtUqVtnYDitL1TEQcTD8gVK+YRdl4AMgtCxhVQiCoBfREi2fAApqAAVWkFdbcLaeDGoZYhohgASMgA9QhTgrYXFR4RMW4Tj5wB/JJT3ewGeeNHzIwBgXmA4cARMwgRNA4RReAQ5PgeUWoeV+xC24dl3X1g//FlcW9sAJzMAXg4Acfyoyh2oMgyK8hG/jWMJYFAB0e+ANYE4PjlO/5kCsxIo6qYkQiGEehJiO1oEe6gFLkofBvHOcmCiJeBdRfdf9OkN2XqNR3OEfqINJpOEXYCEVUsHFVkyN0ih6PUbpSibZRnVQ4K4xtHNS6mEepgEOSmsDyhdWyxJ90xcKtsAIYCAFoZG24vdp6TddpvEC0mAM2ExJKwETQAEUVq4QSIUO7MARNOGZ9MCG9WAg7KBJDfiZ3MAPJKESFlmCPdMXbsETGqFcF8G+om8PXPlFYU4OBAETxIU030AMfsYLBnL2eBS7atMhneWlMg6Gr0YpekKUVKAL/+hgD/hgXV8oSPJACHzgzfrAEvKFiAdDob6B7b4TYwNlMhhmd6HOdxl1iqnYZOGh//7BH9rBGoQhFrr4F8A4jGXxHMxETC6DOM64NmqWrmKS/N74G2rBB3bgA8RXaMcXCvoOCrbNe9BACnTABdNCkANZfmkLEMwCASKgBGggC7hWEO62kT1hExwBh/WADxzhE/jgON0iXQuXpd0CcvTAEDyyEi7hEjjBE1BBXFHhbzM4g89VEIR6SV2ZDwqhEpDhFmJuXTkZDcxAWpfghBHyC2vzbISCuBQAqjYOJnwTKRhAAkpgCdiWrPSrcsrADY4kSXxuAdFhjr7B1BAUjc7Ir//M6J7LmVHV8zwzo5yprhzG4WSh54qZ5BuWIRbg+Rem4TBeVrLsuUycOEBdERVrdsFS50+FWBv+gKAdFqF5LI+FrGfYQCDkAA24YCPSYiwAuaJbsCHAYBoxkg3koDgbYRPo8FsrwQ8gJxAMoadJRRBIxaX5QElxm2v9QBEkwSMpgRIgmBNQQRY24SNTuVwN4aeDWkn3AA/vcA8EAbcLN6bX1l2VgDUTMiGF6mw4pAEUwEBgMC9LZPiM+SI1QAWC4AwO1g3m4L/EwL7vpRq2YRuugWXUgY6KrlSZA40Yta4j666nODOgg3bM2VFDQ03iAR4CXBp2AZ53gRm2YXkC8Cn/u2GKw1kyUm08+XmyKbt0LPsbhGENekwGMgAIjuAImIAJnEBuP5sM2MANBOJF8aAOvsC0VVu1x+JGSMAFouANHGG7/cAQaBsUPMETyJVrC2G3P6E4XU5whXq7o0+4F2ESHmESHEESQtluJSGlJ6ERGuHRDEERFkERFOEQzFWozVW4mTm4ifo4Y24g3sAMtkBFxdEtS8BsRm/L/gwNPVfjjBlNs9oBNuAH3vaAwwAIbk6s+kAXtIEbBpCH5CH8CMqN0KE9G1xR0ERi2rPUZwwdoAc0AnvopugdusFNsEMprWEXRgEWYOEYtqEevmkxKCt5QJyLFiYctoRLBnSyuSRl/7STZiAhDBaOAzBgxmncCZxg23gmx9+scPlAEPhALEw7BYU8kBviDr7gEAgnF0TSDwShEegQFDgBEyahLaZcEnIBE4rzXK88y7Uc3RXhEb78bx0BcBch3T/hE+zwuB0BzduczdvcXJM039E9y61bD140bf1xDIDxpwJdWfY1mF0Yhj3XmONmANKUBrzgDZqThxMhGbZBHbphHeATE1UjsFJD1QM7wmu+OlY9sN+IHQarUWLDNN5hO6CBGvBhFkFLFEYhFYjBGvCBHzjcAV+M7DpjdRZm2NUuFWv2EGn3n+fhGOblCWggAzCgCaT9CZwgC6CTPG7ODd7spLNdEAphEP8C4Q6kYLVRO8gXCRDMVhZMqBK0e8nv9hM2AYINoQ8Koc1lIRcw+KdX2VxFUqgLYd/FfBEA3hD8YA8MoRL+F809MpSh283dfOHxMEmv+96VPNLSlZPfIF0z5afg0c5uUzdlCQ1xwkztRm7QVAJcVdOWqQ/gYhScgRv+JVKrA3cmfLBAQ9WTf/nfifmTv9VJ1h44bNfiyE+JgRi6gR684RiYVxR4YRrmgRNFp7Ket7Ko3mHwSdi/KBuC7RUrVlTL7tiRnRu+IRXmgs6cvezPHjrHYIZ0/M0Ago4ePoMGFTJ0KGGkSIcAOXQ4ZAgIEBErVgTjMFSuXLJYSfKjp0+lT5v/NlXCtGiPIUONHm2sBLOSJEmOGi1StHKlokeSGh0ydHCRID9+JH36VMlRTUmTYk5qpAhnzkWLgOYEWqiQoEGBuvIRGEiTJDxbltBIUaKFCQ8WJkyI4MDBggUJDBQQICCA3r0B8OodUMCAAgYHMvhQM2eOHjh/iG2j1u2cu3Hp3MGD5y7z5cyWLcfDfPkzvHj58sU7jfqdatXx9u37B/tfvnv36FmLJo0YMW7WflkSVavZtnr88ok7Hi758XHjujkXFw5c8ujgqieXHg6bdmzisIdbDn068nbt6uFTJ2/evGl/1KDZEoRJkzBj6o8hQ0YNGTZs3MwRqAcdexAlCEIK/2nSkCaRAALGEGA0WBFFKAyRQxoacXTLLag0QtQehSzSyFMg5dEHIYhQggook1AyyUyP2KTITVFFtZIghfjxSUd7CLLITDRR1YhSM03SIlQ4FWKiTllpRRRRAX4l4CGfoGIIGz3MUEIFJXSwQQURwBWXXHXdhVeZZhaApgFqJpCAAg088METdPhByB+pbDNPPf/oow8/fv7pp2ajkZbPaoYaao89+STKzjv20OaPP7ABChs+0CyzDDG76EZMKqL8wow06hSHzjjkkFMOOeKQcw5zzK1KjnXVeTfdrLbeKt6p5IyzDz301LOOOdx8s8sa7nmhhBPz2XefGmrw14Yc///pESCBQTVCEyqhHOJILqEsGImCD91RRxrmHiILR6ysi8omjRgylB8FEtKHH32USEgjl3jiSbuVUFJJi0w9RRVOQyWGCjKfyEFHIVzxYYgjNAnJ1EmYBNwIVIiYiIhUQMUb74CCVJLuIW2YAcUMHcxgQgldUvDll3LRZVcBBJiJF5qBrdkmAww4IEEHR8xBSCLGfDMPPv30Ceifg6JGaDyK3iP1ovGo9ug99jSaqHmR/vNnPPzcc80yyiwTCySjxFKLJbsI88sx3uzDTzp263rqOa0eh2o51lGXHDnTXQfOccsxV6rhro6TaDv0rHPNNtUkYuwbXkDhBBNiMJvfs2z/tOGfYk/KawhVNY20kUbAcBTKJ0p9shEwyCDjCyuokBTwTDL9qAgjjCACPCHCI/IIJZdw4gkljTBCoyEnVXKTTX7I4YYYZ8ixAxNy6NGkjY7s7iORAWPiySaTvKhIx8DXKEj78t7oByrAALMIHW+Y0YMNP9jAgglcVkCBCngJLnNh05jIBBid8Uwwg/kZBTjABjiIQhtIS9o4QvOaSCVKa6gpjQdLs4/SQI1Qo3mU1yLlJ3/4yhzQIIYo4PAbYYwCEp/6hSh2IY9HZcZudyMHOtLRt3II8VRAFBzejhiOxSEOHUws1eLs4Y/adIMa3BDGGtbAhvttwQlCYNZ9Osef/9BRiw584EOBQMQUgLFCdsAYxvxycYtZ+GIYyGhGM5CRi3aZJGAxqcQmjoIKVLCiFbN4RStKwYlLUIIToDjFKUDBCRa9ixCF8BC2jFSVPdBBDE2wnhsYRi1q+SFikoAJJjBRkqOYhEis1FhOYqQV9wmCFc/IhSDshwZkeWEL+2PBCLj0v7eASUxs0pkxA1MXNSlAAQuIiwQewAEeWKIYFJwHNbDhHHbAJlEhNA08FNVB0yRqhOMkFD8iJal/RMpX3KAGNH6RCEjAohbD0AUkNnWMTdHDUZtxBzv+iQ7MuEOIQhSoQCvjzyYCdBxNZOI/HwrRf6ITHdawRjUgcUX9jP9BDE5wQn3EAFL84OdZ0pqWgPjgh4OEqHinlB8dZwdTZCQDGcOgRSkyobtKaEKnqZwSK2Rxi1z4IhhE9YUvenELWyT1FY/0xCUe8TtCKAIkhAARTkBUFRCVDiHwcp8orxUkSfCElZsABSs2gYlJzKh0VDFEkyQBDEnsIUBveMMY0vAeJeRvBipQwZZeJoGYxYUuyazZztS0prnE5QCMbQAH/uCKZ0hDGtSwhjrs4acRvuNXiepsZx3VWXrI4x0e5AfY/vQPe7RDHu5cxjFi8TZhBAMWv1jGNrihjnec9jSXeYc6/nkZggrRHQg1KDwO9Y5/voMzWNvaapT7jkjtoxv/1thGMa7IBv2QgaNZ+GgYwiAGke4ndAIRkLwW8YhKgMIT7DoFK27RxmHQcRjB0MUrOmEJFpVSJjEp5Sd+uhGjyle+RC1qLmwxi1acwhOYkCQiaqQHlWRsJlABUVIWoZQgCSlGVMFwxloyMEyAoiOCRAWRbEKVQywiK0S5USX1EIe62iHGZIiCEmyAYyy5TIAUcIvMiJnMNNklsXNZwF8a+wAeQIIX09CGNeixj9B85mq+6uw+qMaod+RQHlx2FKHywad8mNYf+PhGC4lxjGPA7RexiIUz8LQOSRWHH7w97moug2c8F/dQiTqUQyPaKD5nlrrTEMVhsgvSjmbBCVlo/3QWNnef+/SHYXsY0IcksQlUADWOtmjXumQB6hSBAnf8FUspS6mJPwoyXUYNhnyFQeBg/KIXvdAFLmjRClN4IpGUeARUo7IxE/XEj5V4BCZOHaQi1SRjQFLKI4iUadt5AhRmZcUnJKGIS5aORjYCCh8qTQcy4gGXY4BCEIKwv77+tQMd4LEEBkvYwqopTQYEwF8GcAAFMBYDeYDFM74hD3pYJjRalkc4UWOZdxxXuaexh2v4xCcyryMax2DzL4oBt1rEgprbQBo9/MEPzHbwyon6YGn6PCh7gBZrqnnoajy7Qa119h6mjccUlfGHw9znu0x4AncdDWkySPqT3BsQS/8mUdZ1ZegWshj1e5cOalBvZOpT78hPo36LOcq3GMbQzYBl3Qte4AIXtjDkgjORSEX6mnkbI94j9vW8ksi9JKicOyADmSJMXGJfZVWRHpqQh0LQBMVZPcRBBDFXPASijDB+Axm2UO4g2IAGfi2B5f8HwHcP1oAGIMAx1QQAewcATQqwC2MfsAZRJOMb31iHOl6/2nYkdzX+rH073AF7x8mjHrznPT54L4/cCGMXo3gbL2wBC1k3WRtOtgbwSwsbFPqpNPf4PW1kfg8NXn/mtOkz1rbfZ3tEvx7E8gEPyGCG7YohC0/AXEff39EvThpAZ/yeT4PqC45UAhVBzcX8/g//gACYf0wHavhXYMEgDAlIVL/AC7ygCw1oa7YggYakCqegCqjQVJyQCZlACR3Ya8XDCZxwSgFDJB3ISmTVYB64d6j0CY8wB9vVSXIgCBIjJI4AL7E0FHjAB+P2BmwwBk/wBEHQA5TnMhuwJe72bprHAAuwTIhlTMqkAAlQZD8TJhKAARiwBpBgDNWkHrynHl8IhmGoHsxXDdpQDdUQDZeSZmw2T6lQC7agC63gC5mQCInACHUYT8fAeqThJ7GRWidnD7xXZdwXRVHUfTEHc4mocrpFZvMwOTzgA2ZgBhu1flBgBe/HBJmoaN21H28ASvKSbZKgCf8ldRyhFKCAd6n4/0fVJguzQIA/RUgGSF+wNgzEIFuz1oANGHYOSHYS6IsIVkivoAoVCAqdkAmKZDyZsGsXYzwscoIrsoIeSAkmsQh6oH5OcAZlgBiGMBOOgGGGxySCUEbjJgdvgAaSuAVPkD+Vd3ldknkUEFjwFoUHpDPLZECK1UxA80wPgAE8kAi1MA3fsA3MNw3RoAzHUAzFYIu70GaxMAqiIAqWAAl4+AcVaZGJIJGWwAiZYApklwumQAhrAAcjmQfCAwnTsA3oEA/pkA+n9Q9SYw++oh4Bt4gxFynZ133vcIieJXOexYj1MA/EsAY8sAOSuFGLBgVLkDlHwJRMqYndZQZn4AZEZ/9GpbNfgLQuMDElqFA+m6B2xXM8jaQKgzQLZZkhQuVqW2cMCZmAa6aLuxiBYyeXv+iLhqRgpEAKnmCMGxiCy7h3LAKWxqNI/9IIgsAG4VVu2+UsauAGe8At3kgVsSQvfsAHY1RXbSB0T/ADV6ICfGV5G6ABACRAgjUzhDVvh7VMy8SEC0CFEvBMV4gBPtAHdcgIfyA8FdkHFQkHIkmSuvkHI8kYFVmHNPQbmdAJtoALq8ALkNAHjNEH7UMIdzgKz0AM13AN7CA2mRWT9KAeooUo3Hd9WqOTiZiTWZMo6jQP35AK5pcCH7V+QLgET8AER3BuTXkETvAEjTYGZpBFb2D/BzoYFD1ylaoWdUBVdqZQCqRQCu4Vi/0XYK2WllxnDGupGwn4CxcadrqgoWQ3dnQpgb3oi7RQSArWVNO2ayKod5egd4JJCVPVB2oQBmrQBonZOWpgPXQgCCrWYYfQPoEwFIxHB3JQjmgQefmTY361AV3ijsIUJjPThIiFWKm5TD/zMw9gpRJAARSAATIQBnnwHwBCLX0wByT5CKxwCqlACq+gpqvwCq6QCpbwBzSUCnPaCq/gCbwQDHToOx2DXsbDCK+QCMdgDddADn+SKKJFk/aQZyW0iKBVk4qoclyziP+AD+uRczLAASDVaFAAhO0XhOcGqufWqVAQaWjgiXSg/4M2EqDY4kekKFRGBQxGJatvJKu1OlRENWDDoJAJqZDCYItwQ2tihwu21qG+WKzIKZcgananoGu89pcd+AiKQC8kkhhyoF1QAKNOsB/4wQYy2GE38TE/WpkCMaR59QNKsD+eCUxJymMxQ0Bz8aRQagBjkgA+06RViKUfoAJM4AYBkhhemgdw0AeUAAwLWAu5SFuuUJGMMApvOqdP1QqtkAmWIJFQBa1rp2TRYA3YAA9idqhcNk4Dh2eqgQ4u93KK2HKBllz/QH6/YH6Y6mhQwKmd+qmh+gM/AKpPsAUoI2mnqkkC0m2HgC2Ytmr45wsBGKu2KqsFBmsJqBsJ+avEoP+Q9FVrY0esHGq1Vnu1DTh2t4ALSVVIZupUFxtVhEAngtAHAcIfbOAEYYAfIfW2Y7AHHeaNBtGjZbQH30YHMUakUbAF6GoD6tqOoxkBTDpY8yivgjGvU+oADKBMbKJYDNAAEpACR7Af2RVBjFEKuNALv6mhtbAKmSAKPBCnf4CREckIquALtKAKnaB2e7oxWRFNsCAN19CxplFw6oBn5YBnxGUZCgVdi5pnnNEZ7uAP9aANkMADMiADGBAG7GeJ8dlzQBiq6HazogoFWyAEPTcGZ3AGnvhJAlFpBaJi30OgQPWgR2tUtNYLrwqhCNiWFdqWvvqrDKihvJisGnq/ELj/vxAIomELCsdIJNHaMWaLtnmgB9TDBiJVbqRaH48mBnTAYZKwCODoFXyweJU5Y+ZIpFCwmZTXV5WHeRXgY2BSQPJmAIARpW3SFwUwAIDxwozFWAxAASngA0AgBN+1BnGaCWpTC7WAppQTp4ywm/EEB53QC7PwSMUWPHnwB3mAwHTAAf0oDNYwDsWRGcnFDpZRDukwGvDAQ+5QsuygUHg2Zf3EGTyEDpV6DGvgAx/AARLwfkkZn0fQc0xwbpv5A/RJnz3XUUBgx07QBWXgvVkALeJLIKXDqiyIiuviinBEde47VPNLyfHblrLmgPirtbn4lmEXrLxoC7wQR61gputF/4I3sQgb0z56kBhz4AZqUB8yG4Sa4wTr1wRsUAg2QcFY4RUXjAcbXFc1ppk0MAM0QMyVl6RL+mMzwybzlsIJhEyhJ818sRcxrAAPkAE74APfhQigYAqpQIGqAAqUEJ2/wwOXYAqPYAqoQAmMUGFaUSdQnAcMwwHRBAnakDR+wid9OCl/gk7/jE5Ng1rqBNCN+A2xcEViEARHkJ+N1n5LkARFINETXQRHMNFHkARUQAVYsNFd4AWE7L1SWVefiFKBcBDlKzFNgUqoWIAPWmBqmQzJQKESOqGcsma42Iu0QAtqqtN0CaK2QAuu4AqvQHZqegqdsF4qigm+Jq1SJQisrP8HbUAHbcAfRHoG+Lmfk7hRbOAHNuGNP8EVg1BGO7i3MUbV8PEDOGAD6rZjPIaEw8TM8nZMBWBA9zgXS9ikrlnDTMAGdGAIeneMyNhriLBsTY0IRGGbRHEvfSDP8jwHFJABPJB6SIMPpzVm+IAPAI3Zm83Zmr3ZvZcnoZ2ek7ObeBwETwB/+KkEFH3RFY3RGa3RSZDRWODRXmDbtg3SbxAHDHNS7ZMVbBVWfjRtn2a0ETqhA8arFfqrtxh2ZKfTPK3TtODTcxnUrjB2hnRfvKYIT4EIAusHiPDUeoDAc9AG5jiJV13LPieJhLw9HWYTPxFL4xhuQVpXZmBjah24yKz/pDwGj67pmmHChIibuHVt10V2r1i6ATOQBSEBxYtdL/gxBmqwBjHKyvIMnBeO4RQAx5K9CxUE2l9oHp/deyPuhV/IeieO4tswkNrwDLWAXWPwAzTQUZmYiUDI2hf92lQg2zs+213QBbSNBbT90WVAyFkUBwKhg2Xk26WjFBLjR6gYi632dbj6apXM3GJXC2qq5a/Q07bww0At3b+IC4bUCRWYCaCACdm2Mc3ZB3ugGGpAB26wtvURlfKJn5AmBoRcBnKwVW0lmX4wV2MUbub4t0EAuOpqhOwKQFna30q4hPGWuDxT10V21/aKpRmQAjtABtRCIoy9zWGwzWuwH88C/5wkYpEm4juQQAkpIASYKtnEgOKst+IqbobTIA3Q4AyupRsXugsMGQueEpGQMJGJYJFXZOxwsMBBQAM9kIlC4OzbO5833gNMCds7rtEaHeTZztFCbtveW1dHrgd4EGF5223urTt9hwqzgAvve4AF9guULGuzZms7Dd3Snb/OHd2vgJw6rQoMRm2X0AhSlQeC4KUgkcNBin5BSKqZA4SNBlIgLZV+8K086j6U+W1zNWNokEv1EQXodiUmMAItU4QCRPJZ+t9NesLzKm/NTOAFZK9V+AAUoAJbwAcgwgioDgl7l2mCREgf+pZHRWu+YFdTHE1w4AoSOey6aezmxwPLy/+89QybUS/1U3+FPBCjY2DoMc4Ezu4Dzx7tEm3RFy3bsT32QX7tHK3j2O7jtm0GGn/kezvf5O6jW1G+pTQJmPAJUO6KS8cLvdBqvnChFxrvGIq/tZC/nOyAxPoKqeCmttAKl5AJj4A8vaYIA8/Kn8Mf5K0GcsBLPQCqTJAFC/0EZlAGIHUGYsAfepAQH4IVFT/Wv8y35yh059YDLLACti/yXKIBoMnfrrnMJ9zMAz7pBjQYYWLpPbAIspB/7xtrB9j87T4DGkAB/NgEMsADsGmlVvom2f8mDbD92Q/+4Z/9jA6PMa/pPaBXOEYD2wsEN+zsYQ/2FJ3jZL/Rsb3RPI7/0VSgBVRgBX7rBaYKEG/QoHHzRg4dPXsQ7uHjR1AhQ4YULWr0iBImTpw8nWLVyhYuXSB59fr1K9jJk7969eKlq6XLlTFlssSF69UqUpYgXdLIqJGfPHnUiAnjw0kYOWHUuHES5MeTIEeYPDlyxMkYMU6ylBEzhswYN4IWGVp0qJAgQX7U8uGDB48dOm/Y0OFDh4ySHzVq2LDBwkQJwB1KbNhQwTAFChEUR3DQeMHjBAkMTDZQoABlA5EzR07AwPOBAwY8S/CxB5MsYCeHIUM2zPVr2LCFCfsgwXaPLBQe7Oa9u8Fv4MGFDwfOoMGDBsYZKHiwo0cPvjNm0ABS3XqQ/yBFtG8vUjXJdyrhqYAXHz6J+e/fiwRRssTKli1erETxYuYMmzf5DR5cmNAhREUaqYgSSnjyxBNTUnmFFlxGMgmlYFSaqaSSZouQQpNaWmWUTBhh5JJH8vBjDzXCEEIOIXYAYgcfgJCjqSC2mMqJI55gggkncsxCDDHI6MoNOfZYZMhDDDkLrUDYYosOJhvBRBI/0BhDCbx+sEE6FVQoQUvCNtDAMMMmWKwxBiCTrDLL0qTsMswmG2CA0AxQgIEHKEiBjk+AYa0Y14rx009jYnuNAgkoEOgB5phD7AEJdsMAA916kxQ54oJbzjMGJFBhhk2zfM666nr44QfutKvKvP/yxvNOvPRarUpU7NqjsodYnXiiqyd2POO+/NwAko48/HMIEUQCJJCSTDwpRZUFcVnpwQhJ8gXaYGaz1lrVSuLFlkwgeaQPQvKYIwwgyFhxjE2bYKIHqGjtIccbmZBqRzGa0MorMtg4yJBDhhzrrEICSZKPPfbw45NbWFHkjTGgUCKKKq/kNEvASuigsA46sMCwMR0oU7PJ0lTTsjfVDCCANzeTUwEHMgjjEV2G+bMYY2qmuWac/ZwBCkHo2IDMRlNIgYMUdphBaKSR5uADDjRwOgOoM6AAUqopkNpqDTiYQdRRswsCVCC8zq67I7g7bzwqsBgPC7XJS5vt8cA7oj3/9+aLwgq8o4hvIPvYKIg/JhMyGK2IJppkkksuucgTUk5pZUEGe/FFtdhuNuZaYYghJvPNT/JlW1UogWMNpXyQgYwexnhiBxlk2IGGH2hQoYcbaWQiCCbEyMKJMthgQw01fG/DjTkEUWSiRsZCSy0/9JijkVt8yQUTMqAIgganoMNyS4sJcxrMw2yTgDEHIGtTZDbbTEAB9hV47LHMFnDggQzgsGW1ZJpJJv9mjNG/mWcEsBplEUQPvkSBxkhAA5tKwQyMJp2JJU2CQ2saByx4waYJ7QMp4NpztAMqWmkHO6YqGwnP8x24wU08bGNhqpJQt7zRzT16q48YzJCvNuxH/w4HEZxaHlI4ijziEZMokEZAAYpVNKtBvpgcbHCmOShGcXMWYon0PIGIMOxgaGFIgQqCIIQMPIADNKBBBsZwu9RJRStZaEITehS8NsTRd3Jwgx8WcTwBLW95fqjEapAxCTmQ4QkPc9gPekADTnGqYhfbwMXAhBgJiIl8C+DMmdCkJjRNBjTsq2T8HBABCQRBFsgABhOR0YxmsAZnyVCGNLaxBzl0QXYfgJpuHNg610FQl4jUZS99SYMuHq2BzyFmD6pzBGKKcISlIlurVqi28LCtC12A5tu+k7e7UYlKS5ih3nKFLzYMb3hzmMNCDObDQkDkjshDHCYO1LjH0eIWuf/gxeSCIRspEsNPmpuNSkZyi1aAQhFw8AEHWseBDMhgaBucDm5Sl4Us5Ep3TuBRvnx30d/tUA9kWYQjFpEWtexBEJ8I4DAWoYdAPoEMZNhCu8h4SIoFpntfOkwFCCUBMi1gOSC7JPrStz72gSZ+EUDBHWQRCjq4ThCo0NMw7umnY0zjG2UAwhGSUATZcaBQasDlDrxKg9eREazP8apzerADvozVmD1oKASLScxjenA92LkqM63aqvSo8G1YoKbaWkiFvOGNSlGIAgz1piNwXrQNciBn4PTwWB/6IZ0SCSIRL5EsUJhCFa1YVrNiQiFraW6fwoiWS3IBUE+ECAM7sCD/BjKgAYbOwCm7C8Ib3KA73ZWBKxhVbDjbwIY5FOJfEUkLWhrBGk/0gQ50NMMb2iAlKEBlVIecGGC0NBgvge+mjeEuJXmKGUxmpn0HgFMCHHABFKAgBicQHwU4EAZFoMIXw/iFMJyhDW1ooQtnwKpCdUNRg8rAdNMR60sJXGBe+tI5stvaW4mJHQ9iJzslLFVVvEMeva5wmtWkwhOg8GEQh1jEHh4DviwqPCAdhIePVdLgIELZAA2RQJe9bCdGYYok1qIWuoBJfTm3OX/WxBa0OAUoODEJOHygARpIAdQ+MJ3YPaEHR+BAFtiAWzGU4Qw8Ch5vfeeG3xZPES82UiEc/xKgPBRMDmwww3KdC90nSFd7WeKU0C7mtO/dVHzdrSRn1vTT9RkgNASAAAggcGgHJECnnjnOA3zAiFoUYxraqMYbvFCEd9GAlllwA+tc91UaPOelxHROqct66lOrwGjPMeRbISzhEVKYOxS+a9rKg1e+VlMLWRAxFLYQ4jh7+MNbKPFKyQC8L6eYSY5lMcH+IxEA+cQix7pEJxK0ilS4ghYMcpCPtaWLIeuCFq1QBSgugYkQue4DiNEABTTQgw0eIaIlNoPvdKtbLgOvy2KI42LD6YeIkCUi6SwEIdKC0jgESQ9uRoMZSuywIEAHkWRUQQoC08js2lR8tsnp+76bJv8CYGYABUDABUCAAARAIAFpCg1o3nQADiSCF8+YBhq8UFh4AwG4O/hAxV931rWWtQctAoIQjC4EcjEhDMduAznT/JAs3IiYo+oarL12TBKWrSqmSk/c8Iphae76170GcbAHSVhim3ilX96hr+IQFy2cgUkFG9xDfkgRRwhRiJSwRCZuvIp41mQkJPnFS3BBC1fgwhazWEWRPUGJTQiCCRqQmtOwl4IfZGEMuwKLHGx7Bi3/Tt9dLlE41dB0NcyBEEMyhCMaYXczF4xJfuDDwuMikIaPAWLZE3V1F0lTxGh8fN01U5suGTIDHBrlEFjAyVD2pjedDE4NwAAcPHEGLTD/QUV7cIQgmuCDJgTvDBrVw38KMZEhttMTR0QFK2Tx/nnmIhdMZMUZmNAEILD6ByOUsCGxg3XvKKEkuLAA/LoBBI9pmqYs2IIF5DUPc8DoggJboRIoiIIPK7FiE54d0o8ieICTUQAVGAM6OCe0QIvzuyNDCJegGB04SIROALxZsAUZ/AheaImaODxaqEFaeAVVKAVP4IRzY4Or6TmhoYEnGAMzMIMsGD/Po6P70LeLGj0xgKNwAi4h6RfWM4QSJBg6WJ7ao4M4eIMwHIhfUwLeI6OJua6Me6TEIB+P8ThLChk1WQBDSzlKAgDny0M8RBkF+A0MyBE2KIRNeD/2Q4X2/2MFRHw/RVzEW2hER7QFR4xEXAAGSpSE52idYuIOuZq17bAwsrGquPE6tykPaWIbLUgVKtgwLYCmF1ICX4OPG1qpXVE2O7CDOFAAAMhFPBwAClCCOIgIARGiRlAEtFCEP/gDH+ABZeSBNUiEUuC2+YIQ12ANZBCym1gFU9gIUJgEH6gTOsEADmCRHbAyMaAj3+It4DE2MpCji/IVXwkSimgER/CogStBhvjCuEADgTCDLcCLYqK469KSO7Op4Nsz7vKYj5GMyyAAAriMN3EAEDg5OwSq9pmTS8EU43iASwAFWYjEGIzEW5iFRXy/WShJGYzBGZxBkMSFYACGXNCDS//8AExzsE3sRK2zMAs7G/DoOlR0mxPCq71ixReywLQzAzT4itBLsVrcgADQxVwUgAkgoz2oxz5IM5EqhD9YAx4ARxlQRg6oPlCIHl8oJXu6J9cIiW17hVQoBcdBBU/QA/ppgAzggHgpA40iJ3L6LTjSy3RcRy+7qPvYg0OQx45ahEIoErtLiz3AAyZ5uzHcgiVQpudIQ4oZSDbkuIMsn+JDgDMpgAQwuZSDAATYjIpcgDmxSIx0gHlyRFzIBcWTwW0rSZFcRNmszRg0SUhkTWcBhkrIDhrARJrsAWYim6y7K538ybN5G/RwlQsDj79KD7x5RXrDQDI4A195AzuIggH/cEo8nADBKIE3UAiEKL8+EIQ9yAOtfBQMUEYMaAA4yQAfEIRNkD8mYiKUCIlacIVVWIVyawVWAIVG+ACqyQAXmYOmIyfiQQgDPVB2/J0T4y3rpCM36EKP6ihHMJKIGIQjIRg80APGvD0ldMDsSTBFujMNyDhI2rjMlAygkpMIqMNDC7kz6TPOwEjPiMSPaBCVjMSRlIVZCEnbREkZ1E3p0YNRmQ4Oso5MHE5ay0ny+LpoyrBb67qz0auus4JXhIIdoZfq9BvsrICTwcNcXAALmIARwJ5yZKzHKj+C+kr1VEb3hL4DaAAKYANKQIVbeImRgAUdq4VVcIVWaIVbkAVU//gENQDHDPiAMFi4OWCsNtiDNQ0Kp8tLXxGe3+ItN0g2fZlKf0megNPQQQgE2lOShQvDM0hCfpSztCpRL+mew9AzzOQuBvAY9okACBAAATg0SjKAkJsMGu0MG8XNIds2Yg1SY52FbUvJlLxBkPAFTmCCJZAYDjKm/KNW66iKG9m64nTSA+RJVAxF9AjXnkwCLcDSlpIoregKi3ouBtBDApiACbiAFqABK2ASxmoe9CwoDHCU9XyAAQiAAjiBClCAAjgABTiAB2iCR5iFw7MFXdAxxaOFkjwtQoUDCwKCPGgD55mDPCiEOaC7PegDPQgKSSUnOuo3LzuxHHpHscA7Iv/5VJAaGIXwvBx6A4fbPUOyAUS6ru8cSMT4WYNsjAfwjBeFgFxEgAjwVUD7VYy8BVtYkFuoiUZcvEasTWK9WmSlBWWdwZrgMV3IhT2gFb6ouE8BlSO4VqmQlybFybsqwFF8zm89wG8djyXwsDjb0h0BpzYIAgMYAFwVgACIAHgNgQs4AS+IgzMgAzlggq/kAQ4IjvXEgO0MgAmgJFA62FwMgAYQg0c4BYa9hWR9zV4ISVToAwFTA5Hyg0D8jz5wiBER2TyoSnExWTBr0F2xKIsCkt5p2UWQhAotEg0lOIFhC5Q6iDEkg93DC52NqZjyki8BPj0Dpd2IgBAYAtGEgAj/WADj81WmxZSovUEZfM0hlc2thU2tXdap/Qge4wVPaAJRuRKy3cRjOtu0zdYSak5Q9DrjTE6+oqa5VZVRFA9szRFbgSgeKbZ8oYE1EYAEiNcLsIALIIJ+ZBgZeIBHeVzQOI6vPIAPlACAfRMFkIB/zdwBkAAxqARUkD+nrQlf6AVcYAUsujI9EAREIIQaJhYbruERGdk+gF1Gpd1MFT02MJEwcFB9EwM6KExJ8N2yKBIMTSe0qD0PBcN9/LXdm7NNEaaZct5XpYBXvYAYMDQIqFzujUPK+NXHeAke61rxdVpILF/zRV83BomvJQTniJ0sSYHsEM4PqioLixe1bSag/0SV/Z3bKo0mUQzg77CVJyhgHTnglaIBB1CAyBCACCjTEPAAEsgBNCC2FNkBHpCBBgCNOX2UBsjFEsZDByiZD2zXPRwABegAOhjE7w2GGmSFqiyDJigERBAiRSgWRjieGiYEgzunHf5hk+XLKVQDYwueKQQ9OWi9RlhiSUiesuAXJz4LJfnQMTzKhhlRNIypDxhn7wGfw7CAGLDeMa5c7/pVd+aMP9XPVJjn/cQ2VbhnQ5xnfaZnet7PQH0F6XHhZAWFJpjJ55Cw7QAbbAVkJ23oVeGwVMGCuuKrRP6OQmahUzS7OKuddPWKGdgpA7Bkwb2ACfCAFyCsJzADMUjGB/8grwFoAA7YysmlAAZAWAk4AAr4AQlYgALAgQgIgL8VgMugAD1gBSZaCV5ohT7oXUdIHCKyiEdQhBwmZpEtPz/o4dllrLz0naFwUHXMly6zTj+YR0dYYrK+0DI7ixERzzF0ON3zx52tMw2ivA14rXbzYgoo0woggSEwNBAQk/dp5z4r40pagKsl1ldIbMVO7EBtbMcO1Hr+01VwFnF7TULwAQerDpusivllaAI8lQFcFVJUIbXROis1wADuMI3m6I6mAQSaVTItU3i1ABOIkSP8vvb81wBYTxk4AFWeZKtRgMJwjAgYAQHQbcA97gJQgAxQA0LAU2dthE+QBFQwhA//mTFOoAQP+WViRguDu+qRJafHot1L5Wp1FOJdgUd5lIRK8F2Pyma1pj3G7GYyNMNDCrWd1aAN+IATLQww2QAL8IAhQIFD++tJoqQyEWwW/dXyvdrFZuwkUuwdfPBayEFfeNhaeAVUEINQK6ZQSWipOFs/BmSLdlJRROQoZSGJPhUpndL9/Y66ja44c4J4eWQyKAItMCCcqoARUIEOGIG/MMJcMZ1RJq8DMOVd1IG+DWEcUAELaAwDaIECQJk8lL7KOAAGyAA3YO9N+IRK2IRimQRGKJBLGHMhCmZiQYSI+G5ItcrwRlCUHT0h/h0eiWbfZe8lHhJFCDiCi+JSFUOB/2iYJzCkUQHIFBjnD7AYpykMTdYBLvDrC+iYwFbwd1bjNT68Cq+Fj/iIPu10T48FUI+FwtuFXcjwR5CBDh+6teJjspGXESfxEkdtFA9KtmFxiB7X9PCOGJ9xJxACHNkRHBKDN6CLOJCdHlABG/gBNMgOHGGd9iTl9eQB3+ZgAWiMBBi5CmCMBKgAB6hy3YY+y5gM5jgDR6iET4jHR8AETEicTDgWSniE7UbBggOpkGrzSd1qro5CfdsVQZhHPJ9Hf3HiehyRD81Hh4OKQqKuiqu4wMiYDfCAHPiCGLgAipckxXCMSX9nzqhBjud4XdgFrw2Jjyd1kt8F0BKtYziGaP+QhmhghmQYhj74AFHxcFbvDvtN2zZqo0RmlUGe26rINVRU8eUM7SOo22DLEV+nqN5JsYIphEaoBEGggTfgAzSgAzbQLTcI5X39jQdgRskdYV1MgBGIgAIQ6gUoAZQhrwDA8pPxGKHODDlVAApgAuGqhC+vBCPyhMTRCUh490cYxuMxhGH+7h6uSqwWl37rst8JJzfIFzKgg7Iud7OuUH/5Fz9vCypuOGKDGEMCyJgCDA9AATAAAxC4gBAQE4t3w46j9ErCHCgCFFYCIJqbhmqoffzahm/I/XnYfd7f/W3Qhl/ggWl9jhbBtFlj2/troxxBldFWodTmeaCP6OfEq/b/MDt4yZHN+xWDMQRJGMRcQERWKIS6mD2C2tfdYMY1MPKm1MWTMYDKTYAO+FdYnr6Xa+kBYFFvf+k7efpPaD/H6wSAyHTpkiVKlCY9arRIEaKGiAoRIuSnD8U+evLkmSPHDUc2bNqAZENmJBk5hiRJqlQJpSOFi1weMlRIkB8+fPDQofPmDRo0ZKwoCdKDBlEaKo6WKHHiy50hIEBcqBBhwoQIVq06yOqAwYIFCb6CDWttrLVtZrdx+/aNG1u1btem/TZvbr269fDhrfdNWiIONH7g6CG4R5EihAsfSZyYCZMmTZxApiKZCpbKli9Lvlx5MuUunjdPxkwlCenSS5Q8/0mtGrKYM27k0Nlj6NCjSqh8AQOWKxemRYYE7fHzh4eEBw8wrEmO4cCAAQECAHgOYHqACQkCDFCAXcGB58yxF8D+fPz4AQco0NmEihUrVapMlSLVKVMmTJgmIWzESBF/hxEJVUQRRnNoxJEbbbChRhhhiKGGGG4I4gh+KknSUiOOYLiIb4VwKIhNeui0ExpmbAHUD4MVpQINUgACxlMkRCVBBTNSQIEEV0mQFVdedeVVWGwByRZaQQZpFpDfyEMPPnfh1WQ983xTDA8cpABYD0EIRdhhRRzB2GKNQRZZZlhoQSZpmWkxpmaZedZmF5zBWVoSky2xhGqrZdEabMG9VP8JKLnkBswtrHzSyG966AHHlBk8wMMfa/zxqAwNOPecANRRh51zB3zHXHTPOTedqJZqygAFOxjyiSyztOKeKaOQ4gknnFxCSUKNNMIfQ/8JQtNEAhIox0YesbFgGGogK4cfkkyi0koYspRhTDIF8iEdctgRxxtnmCEGUFj2YIMNLRhxByBDoICCCR1oQMEGFmxQQY1WSVCvVjv26GMCc/Hbr79vbePWPExCac411lAD5TfbxOLDDirYMJjEghWG2JeMOcbEmZJZQUUUWnwcRRcfd2FZZ1hQcQRllbW5MmihoVxamE4wFmaDbsyhhx+CLOLIJqwA6ksuqGxSiSN+5MT/xho8ZMABcpFCncgaHFBKKnSjRufpAVUzx1xz4QlQgNgJDCC2AQYowIAMflwyyyy23EKLLaecIismA1Gyn0O++tH3HhdllBGBICGLYILIIjvHSSp98slKFTqi4SGDVNu3H4jKwUcccrDRBBA0zECDDUTN0EIdd3wBAgkkbJBBBhRkQKON9dqrIwO37xiWwmpto402vftejfDVOHOMMs0848zA/uAz1zLE7PLLMcQIw8twD/fwg/aEgbtlEUx0yRjGTWg8mRVWRJG++upv8RkWbWKhsmbz0y/ZnDPX7IQYY7AhR85+FGIRk/gEK26Ri0E5rkKF2IMc1OAGH8iAAzxI/wQkEmHBRDyKBx/AQAO+M57oUGcA0+lgc8xTwgI0RwACyEoCwvYVs22NA3oAhQEP6J5S2I0TmHjEI/ajCJkIYiZ9swhGgDWHkBDLI4hTwxwKIYlNbKJxKKmQ5CYXCF8BRw+L+MQk+sAGMQxlCUKBWBruUAd0oWAFJdCA6zSgAdnZaHb3wl2+vJIMbRhDGL/4hTB00Yte4KIWtKDFK1whClGMIhWwqEU16uEPf+jlF7uIhSt2oQtdWMIHDlNB9rZXBCAMxmKJIV9jHPMYKqBvfVuIwvlU6SY3JeF9bnof/UxWGirgjwmQyRMZ2jCH2ASxEZLAxCdQgQrHPesQftgIHP80yYM1QMIS0oQEJIbDAx5ggAMPIGGlyDOd7JQwnAYoYQAK4IAWqvCcZmPAA7bmAz8wAhW3MEWsZOUJT9TKVj38oSF+2Cs/7CFAexDcEUFiUCW6oX+CkETjigY5DB0iojOZCXAesRtZYCIPDOoBE7LghCCgARBfmAAK0GUCFXyAAxzYQLzkVaOX1k4rDqjjAlJhjGCQYhWpMMUpWsEKVJxiPaw4RSdIQQr3MHIe/OCHXoSxC17gwhe+uEUfdvAwTkosSxXjUpeOQDNdOuExWUDl+qKwylaq75VuOoIs1VpL+50pl2DVHxnYgDNE7awQinhEs1jiGwZyRJM++IMoqmn/QUtI7Zo8kEE2OXgAFA5AAGUzTwejM4Bxdu2y2OFKAVRogAgkwGwVcIAEGKCABjTAB4iARCngUzdOgKI+teKhhvhjCEMQQhAS2RlwMOJbgiLRQHtoRCU2kZJnYcgRkwvgDxtxi2AIDRR+OAMbnICgLJgBD5G4QwxQoIMarEAFKfgAeTvQgZa+tEYxlWm+5NYMXPS0pz79KStk8VP1rOcWvJiGUvmBj20QQxe2aIUvZPEJNQBhB0bJHsWOAMojVEx8j8nfY8QgGS2kCcNdwDCHNSxLlpWsCLEsGS1rabLRSOYJTkgNFFoMBSHoMk/8a4MDf6mzXh1iEZP7zR7ooIYm/2gyEbEQBTYd9Yc8LG1KGFgyBiSgAQmMs4QHYMABRgUqTj0nAV4xQNgi0BUUOsDLDjBAAbaGgQj+wRJ0O4UqPBEr+sz2Vj5EREQoCtCc6IGIgjuQRxLKREM0y1kPPUTkagsKZDTDGMNgRSE4F4ZrsSEQkYgEGIaggxvkwAYzEG8KUpAUdrmOAi6VI2lzJFMGzKKAyJAFKFoNRU1QKHKBKMRtJWEJZSg1Hergxige1QQ36O+qNCjBD4JgMSYAAXyFAVMWTBmmPFGBw9HWgmc67GH3WWZOIMb2iU88JyrcycVPEAK5a8YgITBIDGVQg0fkACI67GwPc4DDGnzAAziMgv/ITsumD9ZwBWeq1Gk7kEFpOWXC5lztOWUOjwEk4JXOhnkBDijAZ8csAO80gMmNggSbW8FmU4DCbvnMj94Q8cMOISo4AfUtgRLqmgS5QQ/MUgmsqZghheSiGtp4BjJAIQg6JNQifIhEKCLxBS5IoQZK+AENHiaDo6igBKB2nexoRzuZOoAONC6ELJpg1aN0ugQbeOONMqCBI6yBGNxYKj6sYUlLcEAGH6BBD1Sw6Q9cCUtBCN/FxPqYZ4tBDCBLn4bbRO0Nu/XDbX2laFzGmSdAgcUtHncQgEBuGDthBz3QfA+61IQyeOQNOrsckjUJB1FkkgNRz8CSZXCFMAB5Shz/gKBxtsmdcGoK4c8xgI8EkIAJSJxst1vAxUHVAONM6QEc+EMpZvGKVnj8FCHXIa30mStF7Oe2hQAobwF6EUSxuyPIYkMeFnGflGiCisLEzy2e8TtkTOI3RwQg0TUBCC7gXwmoQRHpop5SN7rRqEnA7JhaVgygcezBIqiX1dVLBDjABFQADWRBHhyDNfiDf1HDNEzDMGSCgoEO6IzX3mVJl3zV+EBGE2SBR+nP/nTBFrjg4XmBF7jJ4XVBDKrVZ8AP/MyP+6RY5EHe5F3e5emSVWkeECQGEJjBGbiGu+1MH8BBGNwb6oXBB+DAC7SACjAWBuxAY9hbcjhN7ckAEmQA/6U0x2OhkKhEh2QJgANKnAA03DllytYcHzZl3PKpwi04X6ucAg7dkw7VyiTkCq5oCBDpVm7RhEXogRy0AXUZCLLAgSBMQtFUQvo5QkrgxyTMQjMMgypMwiJsHx2cRCgUXR2kQRp4ARpsARQwAZZEzFBsWgl8AEuNHRwtoNVRwBtlQAkcgibMwKdJXQd4gAlYgAfYABroASM4wzc8kl5wQzUUQzOgAmQ0hhDsgA8AwTVmD5Z80mI4xgl2YwquGMi44Ay2iQze4DnmILc1HhWIQSpOnou5WAkGARSkYJ4o4ROMwRvQgc4YwiIQgqI8UwXJwAOUwAjYQAr4AAY8gOvEnf8MaBTV1N4awAG9cRA5XQ0aRkcCsFAAsBDxqVACHAcGYJOZuR4kON8qvEd8eAJ93I1B7NOc2dk/9UFAgQiICIuB2BW77cETFY3jTIIkPAJKMIJDcAhFOYIohgIgSEEqmsEYRF6WiIumbdp5acAsulS9EKABUsBR0EAUhI4mfELdBYENqMALWGEwFiMdIIIzyMMytoXO5YIaMIEYeJ01kts16t3ehY+zzUw9PoEWuOAWxKANesZgEiY6vtJhnqNltKMLwiM8SqMQQF49ioEZmAETPIEZxIEeCEI/0RlAWhAH5CLYQRAH9MDYpRQQ2BuTLd8f0FuSVc14qJB0QIcAEID/G55TAnDZ7h2fSHZQHa4BIqjCKzyfKpwCyPUhJrgkDyVE9gFRRPjK3yCKTc5BI9oVG8zBFhWNQ1UCIHai5OgYh2iCLISCJtxBGlAXgpCBUwaF9vyAuEzlBpzXLMLUAt7iBtCA/hXblWgCKmyBimDJiRxFD9CBbi3DPCzjWLBFNUAC+SiINe7A5T1BXo5PN/ZlPWZBCwqmYZYjhyJmDZrjYH6oZ4yBGKSgUz4mFEgjZj5BFrRoZZrBiuXjHnQmQ0ACJfyjBWmQDQgFDUBBENCAGaQASpldpzkNB6wBBiVHcrgmDzyAcyDcbF6KqBTAV+zmZqHWNclhAziKcL4CIb2C/06ZwpiuZD4ZxEEkhG0VQkPklt/ogXTSQcvhTJ9xRCFMYnFxkSUml4ZoiCSEAnkeQh3Ywbxdyxu0QU8E5tKdyCsmhdjRZ3ppQAeIXTEawQ8EBRqMwSeEghkEQRSMSBTQwBNg5x4wQjQgqD3UAzdQQ1kIwxosCBAA2TWS250oQSlZ6C5haD22oGEeJq+CaK/yqjmOaJuUaOChKBSMgVM+wVxNZp60xhkkKxsAUz8pAiXMwi2swihYwhrIQBR4gRL0gBcsQQ88wQdAXVK0zpn1QQVFCqRgEL3R4WMlwG0SwG2iIXYU3wCgFpcuhxwOFiXYwiCB6SqgpHHGig4ZRJzpx/8P+UebWg6cthyBEIhCOYKzYIJDVSLkLAJD5UJ53oEd8MFA/c21aAtPYGqLLZ1UIoWjBqAGlEDUndcXnA5TDAIe4AEf7EYg6KxyBRCzXMIrVAOCMpU1QIM0TIMlNMGreo7lSWZq1MwTmNLf5WoKBp4YaKivFqablMHWiuivegHXyqCHomPg+WWLpaLTQsadBB7oJVT/wFtnMgIl0FAu8AIv9EIrSIIhiEESHIEX4EASlKuKtMAJEG68ZIAMwAEFWVAFvetEwsEHdNDZ1CsBBIAKUS5tcsoBHEcHmdkaEMIp9MIt2MLoDhJxhqlx4hBLXgJCNKeusKnDPiyIZAQcTKz/RpSBHByCs7zaFD3OeHbsIeDBFQlCH9BEyOpBtuzEG4zEGDzBiWyeUXBaSpmrUZBXCmjC9ZYnUv4pMiBDfckCMNiXLOSCLwyDNtTDUtEDNRxDMvxCvcFqGDCBEHzU5KlYajQbX1KmiVKt1bog1qrV1oJtYRpmGfjvDcqS/qag5IkbzRyBaqwtGxiqPgaHIChCI1CCPI0v+XLvMFBCM5UBFfTAGQzpuKwODEhqCajUvSWCJWgru0ZKIjQTBykAxYkNxXnk1ZThknEul/YBIzwXLozu6AKxwEKfcYacJ7Sk9aUpm9JEr0QnouQB7QZLQjnBGdgp43xC0UyIJoRCLsiC/yYMQkwIERBVCx7UJNC1wXrq3yo+r1E8Hd25cad5sSzQsSxI1W7kAvcKDfjKwi3cAvl+Qz3kQz60XTEIgyXwwIKIgRNcSSpGgQ/OTNQ+m7Pm79UGq1r5L7CKbcnoIGNiqAK7qIolRrmtoGu0wRvkDI0iQtyCgjz1Ah8ZgzEkwzD0QicgwgOJwQi/QA3cwA2YwAi8LA18gAwMViakQmFdEAwvDWO109mUzW5i5AFwEKVsTRgQQibkQjAEsS3gQjd3c8A+X6uUgvT54XIu8UMQQof80x7I20BJ7EeQQQru5CYQ0yd4wiZcAiYATcdGwiFIgoZwyCAWgs6G7J3NwRuwgf8XbMEYeNQRCIaCgUuKfMBF9fEt9LHQAEozNINueO/4BsM2KFU+0IM1EIMt5IEMJC1juGgP0G/kSWMkpy0l72//cmhN36DVioEX4HQXEPDXgm0ZdMFOCzXZmiiLJfBXQUbleVWelEFCtcGeAFAFw5Ys4EIwEEMxyHIyGAMxDAMt9EEYyABR2IARcMENjMAJGCSoWlVj5IElHJJbK2mSIQEHUJnYRBbChYqUBYA0rwEjqIJUCbE3d7MufDMhtYoRI7GZoqkP9ZP2/RPpYcSBIHRdnYEYzIEjZLEntDIoqIoXa4I/r4RLwIQhUI4TX06I7AS3iMGyHkEQOIFDP6+KHFP/4zQUFGECKtiXLyCDL4ACJTQOKtDCNHwDPjAPNxRDJixWClKGZLQ2KtWJnUAe5IEb4HqMx4AMyNRgYGr3FphBDLbPYFat/qpb1QJwGYx3eJ931Tpr4H3Gt8WMYiTGlXwPFYwBdZ3BG8DGjenVI2ACKLwCLwTDMAjDgF+1MRTDMIwCIbCBDFSlBVjABDw4fmrAB2TADqiUDCQpXD9Kkl2BDFBAA9welB5c5jJHA3AAHDDCKdACL8gNN+PCJQl2IBGSKuxUmZrzwjIEItwW7AbH5YBIgSgizoBEIRBTFKECoIAvtExRSyyE9tlZj12Leo6IU67iNY7BRw2FCpwXtCiX/4ZciCJMgq1AgioMwyvYSiVkgitUwzYQd6oWQx4kN8qMBmkcAWnUiRI89/lYQZ6zkioJ5nYHpncHuk6jd3iXt3mbN3pvbaFbrWjYEnxXzBFoQQwq4U7EQU7QKCFUa3//ty+8sjBcdTGI+jAEQy4gwg7EzgaMAAnAywykwMANXATFXZK+a71dATYZB4gbHKfssHEo5AMMFiOkAunCTYxfEmF388DuoayYKete30L8kCF238jGqUYMDnYKQj3vMzB8QsVe70+yhEvclkwIEaJcixuU7IgsshPEc/MahdQBVK/wQRjfFq48Qid4giWkQjAEAy2kwirsAjWowyPNwzbswv81yUAWYIGcMHwSPPdp1MmeLwFasY8Lpg+gB2sMMvralsEZHHqhL3qhy3n9jIZiVEwSHN6ke8F9v8Gl7yMhIIIFc4J8rfgvBAOoU4/N+8IpVBUGeFoJ4IARtAAcWxUxW/jsRcpE/kFC1t4DUEA77auZaRyS/kEmrILcfKnc3EKMx7ggEafHpW45K7FC8NNMQKf3mXtOEAgcIIgeYDYrbIIjoAKsXe9K4AezVIgg8hMQeV9OXMuwrOd6PsFQeNoGbGfjsAd74KEf61cv1IIwGEOiFQM1xMM/+MM8MOhifcAVzPktycnD47me63n6pFJgVvygByt5h7y6dfzWKmGihzz/ABd6yXQGiYEGnUNYnTe8ynf8fbtBHuyBpltwJlBCJ6gCLeDCKwfDHv3CH/GCKRCCGjzMEyg0DmwBDTjBD2TmGcidGiDCE+bB0u+brz99rmfckqkUBoQBHECCLXwpLhBsK8xCiwMx1wMxOKMkPU2fmfJVfjT5mgJEIUKC/BTcowehnj558sBho0eQIT1zNH36tKlSRo0ZJUly1GhRyEWHDBUiyMcPn4N03rAhw2bMkx40VJTYkCuXL1/AeAbTCWxYMKDBeP3iJazZtGvx+Pn7RmwNDw4crlChksTqVatJuCZZskTJEitRyJa1cjbKli1RxpZV+xauWjFl6JaZa7du/168dMXctdsXsJcugwdjwbK165EjRY58VRIk7JEkWgZ7KXNGjJo5evwQUsQIESNKnUq5wsWr169fwoKp7sXL06I5QaL8iGMjihIlb4J8kNGn0hoOMpjIGM4BAwbkGB48aPAgOQapPNb8oeWLFy9cpk6pavVqFi1btnCV16XLPHpbtF6pUoXqFChPmTBdolSJ0qRHj0Aq8o8IkYEKMkghhhiCQ40EBdlkE0wcbBCTSjBpMKNJPGoEw5BIMskkQQThgyU2XGJiJhU+0OAnoYIJJqhgkAlqmBiD6SUYYX5hZhxx+KnnG1F44OEDDLLIKiusrkpCsq/EKotJttzaAi2y4v+Kqwu/9tILS77uAozLMgQjzLCuxEyCMbCCgGwJybiyajAkrlDDjc38EGQPQkJ7JJPubMkutRqDMQYZZGYRpIwg6FBCrR7w6EEGGfZoxIcPOKCAguNk4EGG5JxrIDoOfvTBh0RW9KkXU0oxRZVVvguPPFzOO+817XChhb1XWoFPPk44cdC+SSbBkD//DBnIwwEXYqgNON14qBFMLmLQQQmhjbCSjjpyxBENDTlkQzrpcKMNMkikQYYThwEqxkCLKUYYYoYxBsYVYyzmmGv2wWceZ/7ANNMsDMNCCy2sEhhJybYaOOCEFaasC4QZ7sKLiCWOmK4zssTyjIwtzquvv/r/+hLMw44U8wjdTA7rsSJULgKrHnpgQowz3JDjWzk9m+SSWW7hxRcWhxHGGGOSQcaXUwhZY4cftvhBjxR8i2iHFDTooIIKfJMBVOOWu9RT6uD4wxKfdVKlFE9K6a6V72htFdZeXkMPl/HYa0UVU0C525NdK/HVV/4YUQSRYQvp0I89+ugDQTXYSHAORSZ81qJNPPFk2r05kiTDRTIvxA+W3hgjiJmc/uBFGZt5JuhifE53mEDfdYYbfL/R5QokjMNAjH8TpqILgtfUwkgiEx4sYIgdJuyMiSO2eOOL89K4eS21FIOwwrAobGSujjgzCLHMDGJlxpLYgYYdgHAiZjcy/3Mjjz0EUaSRT1Bp5RYaWRS6mKDhfYUTP3aQwQ1O88Ei/GeiEligAuUbDqh+NJUffeoPf4DEKEblE7J1wmxnS9sr1uYq1LjNbbyA2y3mpopTnAJXnojWJPKzn0b4RxGGKImHCNKHNrAhDJpZnBsEIYnIbeIi8pkctCpBoWpd61qNMETn3oAG0M1EBipQwTB6hh2dkOcWtriFLGThi1ywQhXYGcUurMGNeWgDEg4RAxB8kDsq6K53AROewKggRy14YWG7K171lBexMVQMeoEUZPQuY7EuWcZL1evCvwyTFSWdxQpi0Y0VqLCYIzzhCU7QpBhe8gaaFUQQhfCPIyrhCf9UzIJnNGpX/pKRDGP4ghFwCEMGOLADQbCBAhmQwAMcIAEpfoACGGjUA4lJnURYwhYz0s4rXsGKE57QOxsUj6vOw6dY6UJur1hFKk5ICvlkwj6U2M8j/gbDwM2whoc7HEPmMIc45cEQlbibRe5WT1BYhFoWwlwjfIUtQ9AhXGiAwg9oUFCXnWJyKvSVJyZhiEcEiBB2IoQlXHEUZnCDG98oxh/gYDFQuVF3dCRSkeoosIflsaSK7KMXzFBIQj4vkIC8TJYqo0jrIaZkYTmLkh6jhCL0gDFMEKpQnZAFTr6knXSASCEM0QhJYAIUrBhPUVYZNGIQIxi0eEQTOMAEQ4j/4QNN0GUGNGADFVhBAz0Igw9+tIaoUMetiSAFz7TDHhMmFBTP9A4Hp/mq7Py1POthpntMSIpOgDOcLXwhDGU4Q2Opk53tzIMfHiG/T3jiE/aMXD6ttbeOHEIPbRCDGWTishIpwkPb4tYh7ICGPcxhDXCAQyJEQQxlVGMb27DGNr4xitie4Qo78MEVAKYwrRQJK2v61xutx8g3Xs+mfORYlzA2U71waS7RDVkjr2JJrOz0MWfyKVCTIFRMnhcKYQgDGdogB5oZrg924idUQUE/VRKjGMRo14psARpKhAGAH8iACmhgBBxYIQVHEIMbwlAdt7qVo4zAhS/K0x5VfDMT/7q6Gwr3Os3yePCD2UFPLdizisGaghSeOOyueqUfDPUHcBGNqIcgOxE2zEEQiygiZu+Z2R9CqEIRshBo2wCFLYTuBz/owQw+oIdBHCIQgwgEHlgrhzz8gbY3qgY3rGENalAjt89IxBpEBKrhDgZhwRsZka7XSEY61zDaJYxlsAuYi22pzkbti3a5+9zu/o4t34OMYrCiSSgcGtFCEIITXtKGOTSEIX4QpVNxVl9aFKU1wmDNL0gFyzXkoVE9UIENklwEN6hhtpBIRAQ5KttOYIeZqzDF5BCLCU5MLq/R5KAtalEL84RYxOqh1dxOUYrD4k3I+9EPfxYBOAAhQiAE8f9DH/zAEMPlQRDzxayPLfIsIoIiWoaQAxmEAIUzPeEHKnBaIO5wByjzYRCGQARFi1GNb8yjHuq4RjjQoY6MasMVsQ2DGMxcBTT7GblGEhlz39zwOMt5MIDJgp479pfK7IVLFKeenPu8XDVfRdBBENN50QsFJijaCepNUGzh0L45lUQRj6AEJ05Bi9PoJCir+YUxhLEKRqzhfDQoAfl8MAfZ6qIWloDE0gnxNVX0ghbeOSGLKVH1S9iaE3lFhXs4yNdWWROEIgwse1Jh2ExA4ur2kfl9FFtO0ABoxnuQ+4AUUhBFTAKImdXsD1Fxt0oIog2giwIUciN0p9nBDnhAiR//KFGLZmjj3vPAhz/8gQ5xxCMd6rCGNprxBx+oIQxBYKMP2pyV5f75udwtvVUc/i8w2VQME5e9xvcc8bpknEuLbC50F6l6xJDMMdxL7iVJjkmTK1oIQh14E3Lo6DxwRg91ijklPHEKLfKsRvpNRjOSMQxbIEIMjJLBDtiwkETUYhTHXDpHFfGKW7QHoZ64RDjXfnVb3407qmAmMzuoCxD+HzXqSpvKDlXuqj7SruqWbT/+A0A4Zw8GhEDaIA8IoVn0DhX6rscs4gJBYRL2QA1kYgvGQAnM6pfgILYYARaKgbfmAd/qgR7woR7wAR/ywR3IoR2+QRtqgQeQwAnMLXR6/6C4COaNEs70sEC5Fq71Gm67skCTmrAJ+4KRqkTiisqoJs6m2GyRhnCkjqtglCRNCI0reOoJgkCoXAYIzhAIks8H0jCH3KDlYiu+ECHmLoEUWuE0eiFG3oX7AGUYZoES/CAq+gAREiEVkg4SLMESVq0PMGEW6AahMqHqxGmcWMg+bM0TSAFV6MbEvO40Pig13MYXXmPsmCltTuibqK7qxqkRyilwOAcC524i5sAPFkESNgEULhAXN5AVUOETZIMMQmcMaoMmfgkSYqHeeKse3qEb7OEcKA8GY9Af4gEfuGEbtCERfAAJguAHoIAGfiorFmlNEi65wuTjUq96lHCRRP+KCprACZ2ACtyxCA2jCp2AHY2qCbOgSrJQeLTiCZLAHf3FuJAEZZRgMVjGKnQDLMbwCJgADRtSCFzGfAZOcRqs5eKQES4hE0qBfnyhdZqB+5qhGEoHGDjhDxhB6URhFBBx6RLBMz5hFu6KEy5hnPgDWFjI6jgBg1ClOzax/zzRbUhF7NZjPBrRhIQoJudPElURhhRBQOaucPSADpRqThzBWeQnF1GBFVgBEwDvF3vgF23ABmagBFIgBSLvG7hhHejhHviBLf/BHszBHF7QH6ZRG6qhF9bgCq6gCkrqMLiiCv4SMP9yCgYzMAvTMA3jL8FEYQhjC7QgCgRmuVyv9WL/T+Mmri9mzwnGYAyyYAs48wmgIAug4DOzICZITjTHsPjOKwgWkgmcsDWHqjUN7dCMSnHa4J0eMCLg5xEqgeZaISd6Jkb0B16CohbOLhES4RAhgRHY7xO4qO8oBz8kwUIeQTolZP4sMdfcw8TEgzzIw/96QSd+IezUQ7Dco+864bDUjhHW8z/+Q8YIYdoWop3kQO72QKk0SRA0QROwkhVk4ZRkgRUawQ/mYAy2AJN+kCZkIAXkgR7ooR0elB3GgS2bAga/IfLm4RumoRkggQfyci8RYzCnIDBFNEQFU0QNE0X/kpHoKGHYApIoaaRarzAoTvao0AmbIDQRDdHGYEd5//Q0UxNIgwCTnCCTMkmThso1oUCTjIoM1OAlaIYzQmnSJqGUVCE8dAE4hyF/8nAYiOEXYkEUDhERWXISbhEUIGTZRMKprOU+ru7W8gqaeFIoPQg8xfOasEk85qYVig0UUiw9U3E/3q49IYogDkIQEMI+yYACtiAQIqEisHIWuOgTCkEPPgfdxtBlEjQF7iFCxUEcxsEcvIEdZHAdMOobeCu3lAEWRqEJOjQMiLQJm0AvDRMJCLMKBhMJUjRFU49IxMQLx6QcXY/hrKIdl5QJ21H2UrMJYTP5YhM2mWAMleAJpDU1dTRW61H20gdKD6Iz/OMRLiFvTuEVcKFPfqZdrv9qXfJrF3ZhmU6BEupDEhfL2eCnER7BQnxFQiZEPuA0VZjJFXqNmv5KYM/D1wRLm0yoPWYtExYWE+5Dn16o2WKscNxn2uBADtigDR5ABd7gEBzBh+QnKyfBDy6WDGQCUwtKimTgHdih38whG64hG9bB3yx0G6ThGLy0GHphFRQBU3D0WNVLk1C0VgGzRHXVMFlv4bLnK84CWJt2C7eCHZtAao21Rqlw4orvSKFVa5PvCbS2a78WMk6m+KyVHtnRCSfuCtJnDujgvQTBThhhPyghI1uBFnQh0zTtXPErf4hBF1KhE9AuKf8G7uzkM2SuXu01Xxvk1s4GbVwBFnqtFl7/ZV3XlRd24VXQ4xVcQdZOpRTKBpwSUBJEwiTkjSn7YA4Whw5kaw1yyAceIA4iIco69hN28RMUQQ/GrStPFmVlQGZD9RquwRqAN7ekgRh2IRVEoRc86BbgoFHMFgoWLeWaIESn11Zv1WhNNDCRdmQUQ028YglYpmnDtyt+r7zMlh6LtViFSjGmdQmiACyUwNx6CjK4B5MU7TOVtFiZcGqvVWqbYC5kBk4ejdokCn4o4RJGQRVsTheKYjXy9hfQT+kgIRXZU4YEwk7kcD1rEmccBBMyYXJGgRRKIRVG2BVoxdd0YXLZ9a8IVnOLbT4sQZxiLO7iaRJCQqI6Qw+e79ns/3URDEESQkETHCF2fUgS/OB2yeCJwELJaGAGVEAGLBSjMEq3qmEZvnQURCEVaMFnkAEUyoU4oPV5heBVpZd6i9Ywq1dXezUxuFcxCFJlxOSNuSJ8WIZ7h+8q+leomuBZY3NZFYN7dAMKTkaQwysIkC8NY/NV7/FYFTkLhkpq1SsMmKAJyoANKlIQ4uttH8ESOmEUXGGBVUM1NO0XXOHsMFhwoe09L/gz1pMR6jUS529hYxk9URJVthMXIneBfbIXdCHqRiETYPhvCIHVCOFb52/+TIkVWiErlbk/dSIneIIVWEvKoowPDqGHoVIOeFTJrOAxZqKJZUAbcqsup8EZjv/hGIRhXTnNJ5ohUHxhDjhAwHKK5JggCYiWemt1erFXMHe1uwqyIOcYoAM6fBRjZViTHiW5CRZSj88LSWGTex66fgtZSJ9ACM7kCIQgDTH6DBWN+dSL+ToakiFZDBRtqJBvB8zHfys5D9ZAgDPZEjJBFFaBXDnNRnTWEkDjggmhDw4CIaKSM2Ts2Qp37SgBETFSljn5bPaKg1wlPeKGVl7SPZT5O5gpPMTjFq4aJ37Ti7J6J3gCJ1jBDwYBD9IgDerADvhAExZBEFgi8MbwB8xkJoZRG7QBdWxENXYhlOWldYYhFzDBODKAAgj5oZOARKcACWr1sA87RHP1Vk/0VvH/GVcPW3vm+J8F2rLDhwkIGggUI7NZUzGcgAkOjaKRb6i2x2UKGfk0GqMVrSE3mrWTL/nCoKMfOaRTTr1Y+wzXEAhOWriAgPnUoAkSpJLjcD8OeBXqlkZ4gRY6AaL+4HAQpAzCIG2LAAnUIA+OpQ8i6ILXc+nEVJZHAbxJ4ZlIGBbK2xV2bTyuehbC48PEToTOozyy6BZwYr6z2r5z4RY+YQ8CIRDImguMwKwHYRBeS0RiInSWQBvjWoqagRje236MwSNfBBmAYYtQARP2ALRP2qIr+wgSG58b27FN1LAVG8Spd7ILmjEAmkwuO3z613z5d2rTUKIluqBoIFPLp1GM/+N/GmU4JGUqfnwqPuADyHLIhTwFcnz8ZiCKZoCJm1jdiByeo/xqjnzIc9wHmiC2rpsQGOEQO+Gm/yAMpEJTmEM5MIACZCADoGMHZDsMvuZt4falMwE9wzsVtmkVViFVRljPYSEVyrvPyxsWNLfsRsG89bzPjSJ5aSEXWqGeNuESLGQROCf6FoEM3oAP8AAP7CAQDoEPOr0Q7LMlnAiTHmOJnRybJmxFAuV0XsQXQOERBgck3CD5TvoM2VgxPFyxT7SMI/vDdx0JkERlCJrF5xioAFqhpRahzVaPS1rGx1BIf9C0lKwHensNeVu4rP2kVWAGtr1RtF3byWX8cHzbn//caTIAsDMgOShll5qDAtj9ASglmJRjgdbAIiGh6aTiUjCla+gdcRgivhSB+jCx2ER4m+rcFQ7e0BPe0MH7ikcYi/8c0GMhFiY3lPULnX0tF4BhERKkIOQgtJ4ADVpLCdDgDTj2EDIdD6IsDjwEKkPdwEk9rpkYF34hXQLlRb4IEyI9EOwAW/gACiByB05uj3E9sUW8REe8sMv4sP9Z2BnD1oedsp+1f7PWCTHJQJ+ARz8Tk7LADArUyELQyIxKMUzrtE3LBpqcJgyqRBpldDJAwB5AAuI+7pujAere7u3+APL+AJ7DU7AGDrb8EBcWEeU8hEM4mlphvRN/FviPPQL/HeJHmOHBWxQmH/JHQc8lnuJ/4arM+RiWgRmcQRqkwRpwyxqmYRuqwUvRI1IdAQieYAu8gKwR7wt0IA22AA3QgA/6O9PTgA94XhIO4VA9R9SffYkLagZqnmgk1RGgbNPbLRIGAQ2Sb9p3ILVJmglGnOgh27ENe/sjO7IJWk0sydYre9g5e4+H6gyFqvWFNOtLU8/GoOs5UzfSItB+IMFpYgZErSY0YANGR8DICiA+fODAIQOGgwcpNHggAQNBgjJ8+GiiZg2cPn3+EFL06FKmTqRMqVr1ipYtWihp1VrpqqUrWC5bpnI1E1Ysmzdj6dwZa9euX7+EERt6rGjRZc6g/1njdo3bN6fcuG3bZq2qNWpRr1WdRiyWrl62ZB3qQYMLGi5pjHD5kqaOlDRSvuAJZMdOmjto8BzSZEiQHjpv2qAZ86RwkCA9yNKYMSyYL1mfGi2qJGmQo0OB7mgehCbIkyM7EgMBIkQIEyZCgCBZzbq16ymwYVeZXWVKa9tIjujezbv3kSLAgwsfXuT06NE+dvg4vhxIcho0jpx20iO58uQ+gqgoMWMGDRXbNYgXT4GCBgoZylMgmP7Behk7lIcJc7HPRkQcK3HyBEpVq/+z3GILLrrgYsuAuCSoiy4rwbJSLQs+yBNPPlXoE1BDEVMUNNBQQ4013qwjjzz00DPiN//f1FMPN1Z5yE098tSDDz310BMVU9lco9U13nyoTTGx1OJLLrcYEoQNK7z1hWZfcFHHHXGxdUcddbRVBx548BFIIX7gARgbZBBW2BNB/JCYDTTI4klfhQQiCB+WOTIXlXfgsYVnO9AQ32imMXHEYa4FGugUs8lW222rJaHooowmQQUVixbRqKLE9VAEDTLAZ1188WWawqcpyJCCCpjKMFAGqCLEAQXuPfDAQgy5isEHmcpA0Rxz9IFII408QgkmqMjSSoC54MKLL734ouyyyvbibC+8OMvLtLzoYmGFOl174S8ZarjMMtFIQ00138xj7rnnyoiPP+v6w4+78PrDLj7/M5pzY4jtykuvijWqo4453ngjVTXH7OJgL7csEsQYLLjgwhcu3EUEEVzEJcVaaN2RGRGDYMmHIXx4+QaYUIxJZpk92GDDIIHwccghWgZyiCN8WOEFHh2j0cMPZgaxJ2m/BSfo0KvFhoRssBWNG6OPKvpo00noJmkSxBVBltU0JEZDqCmgmkEKAxVUXnrpoZeQexlk6oMYcMCxRh4Y9cERJZRc4gkqrchyyy259FJsssg++yxQvwg+rbTUUkv44kENVcwx30LeoTXblItuuvPUk7m6+crL7uf+/BP6P/yQbvo/ou8rz1PceNMNPZ7Py2+N8qyjzurfOLNLLbzYMssj/0CMoUQOIlhQsRRG3JAWWk3W8cWTUz4fiMyDhPwlGSWPeRjPKgfC8iCAAHLIXHy8EQcamG3hBfeJzdAD0MO5BhwQRah2BBJMrNZEa01MccUV+0NCEwZ4hKgd4QlZyEITjgC1IwAhMcHRGnTA8wENnIogB8lAQTIQNg5kSjlNCIMccOUHQ3BkEptABSvyxrde4KIXjvFFMIIBOMHRUHDQ4oVPrKUtCwHlJ417HLimQURtVO5y6JqdiujFRNB5Ll/8iKIUUYc6eVGRdFKMYj+2mLoaoSgq8qBX7PChRBWdSxvEKBAvbrGJQ4whCibwgAdIkAa42MAI44vCHb4AiCuBr/9K4qtDIGhmvcBg7wlC2ELJtqcyzETiEIPQRCQCEYlH4iwS1dsOqDbJyVplqlTw8aQnBfKBUIlKIATpIKoe4rWyqcdVrHJVrB6AEA16cCL0sc9GfFW3TPDnFP75jywCdItZHIgWs0DJSWjhEpjA4pkwackzeTLNnVSIcBk6CjSi4aGqTCUq5SJRidoxznaY0x70uAc97HEPe7DTH/eIp+f2YY992LOKV8ynPvWpDypKcR/wVEePPERQc8BOnvjwlzp0VBVzKeMXX7lFJd5glxrogAsXTYMdMHMZTALDEWnAwx3At0dBzgUzfKCDHEZmhjGUTAkwRRl0OupIlkFyECj/tQMaZgCeGXxKBaPa5ChLOVROmpKUpDQVUsOWVFFGhAlhWMMa3OAGPZRwbr66BCY4AQq8rRBAs3jFK8K6ipiU1RVnleZLoMlWnFBoWxl6HOScEY1pVKMaVtmGU56iDhGtQ0TyMCc92vGOwtoDHvFIrGLjAY/GLjYe+UhsPqKIunve05+mK51mM7vPfWYxivdAB0EJmo12uAt19Egoj7zRUGf84li+mMQRXvA8562FLYcIBR7sgIc34CEUyDiEHTQTvjvYIQ522BIf+KCHlQrGpU+AAhRiqhicvqyS4ptLy16Ghyh8RwWZmkGewOvU8joVbLTyZHwkEkI1wCEPetCV/yIYwctLXAIU+AXmSF6hiq+GVawjKesqBjysVgz4FbVAaypMMQpTpOLBqYDFg6uZLbgSRXJ1/ZBVsqEObijUnO5ghztC7FjF5oMdInZHYUuc2Ma6uMXsbOc73EljdzIWsfnIcT6oaM99oE7HkwVykLPYWX3084pZhEc3RkuNbrgjx/zIsT/sIVCtbKMaQXHMJoCgghY8jy0VY0tIt7CFNCghDWawjB2KCwjNxAFOXNpDcwMzmJJFIQoxNRMNrhsJ8R0CECzTUiQcEQcl9IBT6wUCohe9HIkAYYBqcC/c/EAIQzCiV5OoxCZ+2d8VzkJvYg11qAec1pgkeJps3UmDcP/yoGsCRSgammu4pjGuvE5lGwHLtTfGMQ508Hoc5AiHsMlRjmK/2NiIReyNS9xYd5TD2cpuMWJjTON4ttPaif0sj2sM5c96m7Kd9WwUT9wNHV2jG06erBSfbI+mWAMaxPjFDFFxBhps4QY6IILyuLDHtKQBDV5AQ0jxgAY44SF8gPDYIAbBpb84dzCK3EIUpouyHgwCu3cIH2YCMRdNgDQIUFUDG9hgkTxMeiOY/hV/VJg3WQyTmHuLecxR8qAHIViaNT/1hKzZk21hyHHaDBdeqaJXFFmuRkwcLDvMgQ50wMMe8TisOMiRjnSMeMTkIHaxt871cmTd61ovBzyK7Y7/pqMDxexIx2HfEfV81HjG1r4HiZQIT3nG7h51f6c/JJuPHtujs/tQ9xVrvOxzoPvwOjIHutWxri3yQx/2QEdTooGhYJxCDymwwQt04IIcpGEtmjiEEepwiH+HlOOW4cOT/IyzQxRCEH7wg0rpPIaI41kJFQe0xiGZcJFevGOR+AQqVDjMveXi+IADhvKBwaxmBS5xCVLQghjEIAm12uewNgpShE65bZjLKUgsIxPH7zlvZzaLkeV7jhfrYhd3Hcdcdwc8rj5iHN/D7W23NjvdGfd78IuM6hI7Aigv1iaA8hRPKHYOCqiATVd16bCA5/Br4jCB4tANS9cN5uAv39Bh/93gYbATOv3AD/vwDtwQDcSwC8IQDK3QBykjAiLgAhcjBTqgA18wPjhTJXoRCGhwcSHzJNODB47gCIbwenswe23QUtIlcRRnJj1wF1TyMm3Gb3vUPJGQC0Nihc2CQ4DTfMuCQ4zzarAWa8fgDGQYDWQoDdVwREhkLrNDRmK0LnDoRAPoOeGGT6FjfqizWZuVT9/2WaFzh1GmYy3Wdj5mT3VHgHgXT7NTIocIT2/HDuiwgIc3iZQ4ib9GiRAIgZF4DgrlLxmoDujwd3n4LvSwDcswFMkQDIQABEFgAhcwATkAA9EzJaVXMXVkB5iEBrpoB1eCJXbAB0Hoen5BB4DxBv91BgVkNnGHkRhO4jxfsCRP8gUXQwRGYARp8Am5oHzKMi3XEi3I4o2DYwzGkAzKcIZ2ZURGZzlrmETjR35jBDrvEo9/KDryKDr2ODr6NIcDWIf7GG4CSDrqhn47Vjo/JoDv1E4jMiK2U4nYgA2IZ27X4JDdIJHdMA6UOA7mkIkKyGsZyXSg+JHsQE7t4C8jaU6FVX7s8g3WUA3T8AzNcAtz4AMzYAETEAJS8AJSQATPcwdc4CR28Ra6iAZRIHDGpV0sYwh9sQeyt1LGaAZkVnt3RiZmkgbi84yrBwjSaAdxQQRoYAZ8IAmfwAq+MI5CUQzxtgvEUAs4NC3C8AzVoA3/6Fgu3yQVUaEOJaIO5PRu0hAu3NQO4+BO7DBjOxZZ9mBGJVIi77BOilmY94AP6oROj1kP/sd/60JjCXmZCrkO7SAP+3Bjj+VO9uRO7+B3i9WI8OQufSiPniNjkXh4DXkNTKYjEjkODGh2m9iAaYcO6SBi9pAO6KBi8PCb8SBY46QOMlIjNTJYJPJXtuMv9bAOAOMNOQIiPSINzGAMwoALncAILDgDKzACMJAGX6ADUnAxz/gWcNEWaVBJc2EXdRIKocAHJXQIw2iEXVl7ULlIZeIkpUeVmkExV2IEFMMF0BEEdNAHvbANcHlr4zINwhAtC4I4bQmXezUPlHMjCuWI/1RGDdvUodRgO/YwZe/0Y/uwL/xSImWkIuskD5BZD/4gD+/AopLZOe1kD4UVdzQCO+MWkPxgD31XOqvZf+10mOOEmJAYgeiGDdZwbjvCZAQVkdhgbt3gDeaQgezwkehgDuKgDuOApergDuOwm/M3pp0JdYklYkRqIvKgDhvIFFXhIXsZDdHAIRwyp3RKp3tJhskgDLXQCZcwCYbQBjRgAyYwAjeQk2G2FstTJ4FAepogM7yYXJEQCtPjen6gBw5HZy21BVAZBYbxAztZB33GBUSQA4fKBTlwMTagBHFgBFHABr4wFXA5D7CpoNXwDMFwLLbwFbsQC8IgDVRxDX11of91+VdThndLBg3S0KHWUC7HSXd1l5wKaU5/dZnvAA/XynY+Ci/vkg/tVIdRJk99OIBpSg//4g064qTqqq5WsaRRCpGrpWsBkw30SqUK1Zx9la9fSg/DeaXo8JEYOQ7pSlByeqcc8i0Im7AKu7B7qQzFwAup0Al08whDaAZ2wAUjkKpbKYNVoqh30aimlxm89YsbtQiGcKnEWIy66JSd+qlfljFugapfoG89WQe6eANbkAfDoA3TgJYo0g3WoA3PgAzDICC3wAu4sBKxQAxpKKzm0BRRYQ5/xQ7+8A7sAptxKqeVs0QAuETl9y5Duqa3MyIlwk5SpGM96q354A9qW0//l3VFiIh3QUpjnlhuWnEV6+qkeKu37WoV5kav9WpuAnMjHtY6hiswiOumDOWkckoNc2qnBhu50ICwzLCw38IMzsAMynAMypAMnGsMv1ALo3AJlHBpiFAIhkBRcWACN5AD5Hkx/IYHOfCMaFFHYHYZdZG7hvAysvcXKnufLSuVNUsEaQA+FGMxb6EDdWAFLQADaOAHyKAN30AMyxAVlDMNvjALueBye2NMtaATTMsiHRYVVDq1VesP9OC4y7pN0nA78ERFVjSKZ+t2NlpjNDZjoom/6bS/9mBOx3mYtVOl/zKJH5K3TLakEJkjCawj6CqvraMjh9s6uma4N7IN1zAV/+06WuICuZI7uQbLwdskpyAMDWSYsJjLDChMuWSoucpgDMUgDC7UCp5wCY+gCJOgCIuwCHgwAybAujlgBDXww69LBDQoBVOCFnShMVVSB8j1Mq+HssVojGEyBlQsXSfzZXVQxE2CqsTrFm9hAxdlCM9QOWnIItSwDc/wCpdQCHkwCTK3Cs+0C8WQhhaca1bqDlHmD+rguJBLDepgD9qGRYGYRf3Hvza6mjY6kgqleLBpwOvat1XBUFqRI66DbjpCr04LMABDyYkrMB2WuObmpngrDVl7p5a7DJP7LR5swmRIhtBQuZWLFMuAwpHbyiscy5aLws7QDM2QDC/MC79gC/+vUAqUgAgYoQiKUAiF4AhkoAIrsAImAM0uUAM34AI3QAIzKAWAsBaeVwfNaAQbBYyOAHuCIAd/EQdvIMVkMMVWfBhRWAdEnAYTQ6ozSJ5foAIbAAM6AKuVI71UccbTMAyN0AZzsAiSUAm3IAuooAoOsgvHgFeJ16UiBg9SNA7UQMp0eg2mNb/zO1lV5A+0UyIK+S+Kl6SN7MgE1SIIDJErfcnZkGuAC7h2LK8BI1DoKsoaHKemjLBGATkmDMsJm8om/ModzCHMUMutjMIp/C3K0NRO7dRM3dTJYAzxpgsS5gqZYAkTi8ygsAmf8AmS8AMlkAY10MMuwAImwAIr4Lr/OrB5EzOe1VieUrAFfCALkZDDhaAHcnbOhrTO61zFiBQE0ngC+Yaoh+A8A3oxFVACJGAEdJAJxQCXcJmGtzoMhwAYdOAXmKDQqoBgtfALyqANS8p0v4ljUYYNcEqnBoWaBDmKOVZYCwm0KI3SLX0NMX3bAcPANL3bhHu3cCrCQr0MPT3cwx05R3HKSz3LSVHCl6vLrvzKs0ynlAvLyoCwTo3CUj3VLmyWwiAMP7QLDCJho5DVH1He9kUJleBysiAJUVACad3DJqADNWBRDjOD9X0DXGCNX3ADNWAEg2AHcaLMUEwH6PwGZGAGZIAG7AwFh6EDImCepMoFh90kN0DE//yNBkagA3FgCJ5AC8jQDM8Q4sFwC6wgXG9AB5IgCYKAjcfnC8BMDNEg2t5AD1EmRfNiO7bDOflymO1gO1X60rnGFFAr5OSrDmh35HjZiSSJlyJZpDwuWOuwgV/EUC3iISy5lxyS1Mqt1K38uCT85WZYhiJMytOQtXJKymRe5mguDURU5m1OynXF5m/e5kRkhtHgkr3sy8TQ3a8VIRJmCqQwCoI+CqLQCZ0gCoVu6IZ+CqWwCsDUCqfACqwAGWbQwzDggiTgAitwA1OSPCzgukasAzDwFt7sJCETBTPTFyjL17roBepDBskYU6/7FjKYkzcw2D1ZA7xoi4MgCY8ADP/I0AtFuwmVoAmRGgiaoAmF0AioYHy+gCHMIL3m8GRRBE/M6YlKXqXa/omEC07puFfpKLZMXq5pajsogjuswyJ7C8KW69NKndyZ++7yPu9iLudmLsJ0nu9qDuf23uYh/gwt2QzM0Ayb68J7/t3hLWGpQOiIXuiZ8PCWYOgf0QmeUPEVP+ikEOjAJBKq4B/BUgl00AMtUANEDAMkwAI6kAMVU40wAAM7KY34PTF10Ht24AiN8MS+S+DG2JXqQ2YSB1NKkJP5Jp6lSgTleQOimgYpP4NogVONMEyqkNCooMNt4T2upweOsAebwDdsGW/QIKzskG1TJsAlvZG8toD/usj/VaqmlykiNEI7I4JE6fgNt4bBd4XRmZuwxC3cxN33Tw3Vy1DdTV0U8174uhzmZWjLzvAMix/iLfnveJ4M2v3C3j0t4U0TCy/oiH7oDd/wiv75oK/oFg8KFd8Jg+4JpHAKwFQKp0D6rPAJixAFLMACRgADOeACMDDfMGAXti8FF/DgcXEHyUOeE2MEBScJi/DEskeM6LyyXuDqsQ5TXOACF0UlEzODcEEEWey6OUC8HysJjrDZrAAMn+A9X4BJdZEXhcAGhdDiwcAtPwENRk7R8PAP7zDA54YO3VCBFXgOVYqBAGFOoEBu375xQ5hQIbdr1qxRo1ZNmrRo0aBddMZs/9nGZcc8LlMWUtmxkSKVdeToUeVKlsWOuWQZ0uNJjiBtchS5rNlOns1EJjNWrBgxYsJ+9eKlC1ctWK5crUplipQoUaRKjRrVKWsnq6Q8dfL0ddTXTmXLhi2bKdOlTGbDviU7yqsnUqdalSoFyhOoSm4OBUKT5g6MCyTu6KixIkeaLzrquIAh5QYMLpXvpJEiJQ2aQJIWGSq0xw8d0nHivEGDxgwaL1u2RFESu07lG1++SLnDRcoXIjok32mMWzCfQ44kfarkKNCdOlIA2dkSKRIe4oYUgfIVbBhRYsuwjYPHL18+dgK9hRPHrl27deraqzO3Tn7Chg8h3pd2EVrNY//8Wf7fSKSVRjommWRCYkYjnEoicEADD5TJowcNVIaZkAw8xhiPhBKKKGE+/IWXXWqpJZZYYIElFaxWXPEqvFj8Kkay4IILFBtBwUuvt270hBNMMFGLEyE5CUtHukhBspRTTgGFSVA2oaMEG2yg7QIPRNAhBylggKGGGnLQgQQYwJSCixyMuK2OzbYYxDPQ9BhNDzpMewO11VhzDTYldODiNi6I2E0HQP/MgYg7pNDhBi4EuyOQQQKB1I7MiKijDjsCySWS6D55Y4cwMmmmGlEd8gaffe7ZBx91vOHGG1evqc8hiCiiaL+N/sM1V5Ua1DXXCWtaRiMGZxppQgONMeb/WGQ59NCoX0LcRRcTY0ml2hWpwjZbqsoSxaxO1MqELE4yATLct4YkMiwhwU2XRrg42WSTIXe0Ea0jcVRFFVRsdISMGTowwYRESZCCBBJOcMGFE3K4wQUSIFM4B4mNuEGHLyq1ww7jPgtNDzn2mJNO1VJr7bUllLhBUd0ABTTNOnR4IUvJvjgkkkM0CQUNJYwgomEuntPkkEo1q0MFIHyAQ5dptJlGVGmqoSYaaW7t9SViYBqKu6pb4lCoXL3emiUNPQrqQKCWvZq7D43iRcRd3n6bqaasZXGUbLHq9tu2zAJ377TA1VutSwa/hBLCB+/7kh8V/7HxxiuJdxPHMUEX/91MODnrRrs82aQSMiqogIUTrLSSi0S/uOCEOojIATLfYHDhBi11QDNNRw6RxLNCCvFDTjnpRC011VqLwoolpMhBN9uISCOSOr4AxDZAEO3tDpuZQ8MGHVq4oeA7DsFjEElt46KGHvyY5BJchhGm7Wff/2UX+N9f+8OihOEu/6uR5T+oZJVNVv80NMBldc2AXSNbhoTCvw7dj21xM1FTXFEtFVEwFSjC4ASrJRW51M2DeBMFVryFlr+B63CUQGEKVYjCwq2QEpWAYQxh+LjDCUlelaMXk/aFikoEAgoVsIAFLnABC3iAS5OxGMNgcANAwUBQsEueEfoEKB0EAneOWP9EIQQxGtLQwQ6nEV7wzOCFKJxMNzmoA3C+kIZBqOkON7BeZaRQB0flZjY/S8Pz1qgmxlRqUVywgyRAMQteHKUX8Ktf/X6RSO4UIyhDcSQDBWgsY4mkJ5fE5IQKeL9nIUUXJKKFU6CSilJYhZRIMkUqLZgKp8CCKbXABS5eIUqoqKJa+VLFkk5hilVGBSq6NAVeUjnMYFqllKQw0rvQ1aPKRc6ZN6wcvIYkr72cIpe5RAUrUJFNVOjBBmiQAhEnEIIQGFEEFhDBCW7DJR1kCTJEABRujGAEPKTBCGmIQ2ccoQgt9o4OvztN8FIzxuKdDFFlulhzGmOm3WimTHZYoxT//5TQxsyGjWXaEp+MEAhNDDIX2fEFIusXDGGwD3/D2E7+OoTSYTgSkgYU4P8o+SC0KdKTS2GKUywolagIM5ilSKVPg0nMVKzCqKx0Ci1oEUulzvKoRcVlLnXZSwqaQpdL+qkxk1RKd50rms185iaYGU1MQPMtUtUhKj7Bik/IIQg2MIEUPFAYElygYGIijAvCBCbTNUwHmKnNHeZpUSXoEzRb9BhA6yS84b3GeIPiwvMayps6RCINf6rMygC1GN1Ixje2CURlchACF3DBCIOoBCdmgYteBKMXSJnfh0gKIvolsn4sLSmzGtmhkbq2F0rBhS1oMcunbHCDP8UKMYm5/0urLilfeLkqcymoCqOugrpOcQUtbIGLT6KIlk+NiiqpasGr/hQvXhlFvWj0VXhBk73pEhLlhuQ4sTJzL5ywUbxQoYk4SKkGRLwAOQP8hcjogEsxgAHCiBCJN0bGNqsz7aLm+YZFSMIRhhAEYuVQmoAytrHFy1Kh4HkbKRCBC9L5QsxucIjDYDQz3XMMIPgEzj65IARzjMNxPLFaXoQ0RIWc37OCEYz5zba3Q/6FL5TsC6QkRRe2EO4rXjHKoALVmqrAi1CtDMxUYhWow9zll8Hs3KjekrqrwK4rpOwKKLftlTlN8yirVV05r1KXSjIvXvaiI/i+V74+AtJXfyToH/+51xOo2MSTKvEJSfT3BzUYAQusBIgcWMlgRsiBmAhsMBKQiUuXLdOZzuSIzVS4EYfdg5w43GHhjfE1URAUFcFEhNil0QgtwAERACHjLwyCCFIkghN1DZw04AEPmZ1jHfigiW224ha5+K1SdKGLtvGiydVu27SnHctY1mK4xd2gk4x0I3I3Sdyai64uo2rLnfKyqu5epS3ZjUujvmIWSoUylGmRFBKRaNr9JpEEsUvnOoc73UvKC4/Y2ze1DBrQDn844+I76EI/8xOfiFclNCEJM5hgBF4qTJa+4AIRiOBhI0hYaU9gsDGl7GE5eAETMb0CKeBhCzl2kxZB1kXTsHr/oF7wQhe0AM/Nto5PggJEGtCYBkAIrVEM6xlG2XiIQeDBNkJLox0OcXFrOtsXsYQyLHFxC+0O16i2xCoHWeStb+1lRzRKZrltxKSrzl1JV52ucYdplWFaUN63rPcraHELsE/b2sHghSlcoYtrOxmnoYxzded81DtfNUduH2uQwNU4ck2OcmxpOKAVJ/ofVaKsFt8ExjXhiC10gAUrSEOYFHYHETjRSiIYwQlgR4IQcIkEsmOdZk7Hpy9tRp+LyPAW6bDhkHVYoGMUuhHqILs0AgI47TSdDe5wmIT2BnkwGAKY7pCpy0Z216E4RBoc0exWzGIWuZiFlFuxilasOxXM/004ufdyuXYJ6Stt6Zu00Bu26D//6yoa2QqtAKqrIIXkUqUyW7czEzzt4jZbaJsl8wVXsLbG27Z+EyVXaIX5ozMpewW0wrMwK4X1GpLO87wWxATQc7jJGZzGkZyKw4SLQ45D2AIKmIDamyuEIQEP8IAaSAPGYIFgS50YgAzZgYFOgxlau4FK+QLdMIItMI5G+IwM6x3m67k6WSySCbouUJlDsD70sxh4sgE0ag5FKZN20oEYiIF2+oJDMa05nMKkQ4M3+ARZkIX3y4VbkL8QDEFWwKX7CzO5KxLOeaa3AIsSYjhy4T9IHBfEeUS2KwusaMAGHAVhUjd6I7hVEDwo4/+212I8XlifYCgGxNu2bqMFEhk4NXsFEayu+dslawKm83KXcWm4yeE/0WOcy1mLy/k/wZnBx8EETYCh3PGMQeiBCKiACBCiuZqAIbqAFXCBNNAETQATGBCBhMmB6EmZEmuMKUQULcEoNDC1SWgEQuiDVOuiLwooLwTDoBuUQ7kDcHSMQHiBFyCChJKZxogB3aiMnvGNQJAUi/mTG7ABO/iEXPio7IC/WbiFibyFWRDE+pO3bdJIzbkRjdwXXWqSudMLclsSuTPJGyGF5lK36AIzoiqq6vLEViLB4XoFW6hJW9COYvgFChIFutGWblkRb3lEtQALwQEXS0DKpERKF7L/BBWCBEhIoaZUSqS0IFJQhVc4Bfe7hbYKgi3wEhbwuLkagZI7gZITohHwgBVYgQuwGBsrSw+4AcMwMB2AGN8QAYbpgBFopxugMEl4BFXohVFgx9AojTfYDDMwAzY4gzMggzNAzDF4Qxdgnj4xkz/RARzAjBeolFiTwzniDYkBFOnQjcsaEymwgThABYdUMq2kyPa7yKjyyG1Kt9jcyJA8t5PETRvJsi6LQPuzoE+kM1doChQhwQlSM1qAhWDYCWLAIBShKiTBRE2kiqFkuKR8yuvEzuzMzqTEllFwhVp4m1+4GmmYhvKshmkwBlxQMlk4gxLoAAuYRsg4Jw8oSx04/4RKW4ERGIEVWBQXsICLOYG5Sqd0SpjdcyInip0TGAEuKC07SA5FWIVqeAZYSIQ8EAQ6mIMNSw3UUEw2IAMyGIMQXRiLaaddi7ksMTHNxAHtyYzSAgTmkYITaCcXuINQyBjnmY1EUUg0cISPishYrMn4i8XXVAVW0CaPjK6NrE3b5EiUxBHdPIUsEyahioo5u6VUOLOCQyqkeoo089KZnKWlQoZneIZmiJ+laE4v1aCqQpJOyBtvmUrr1M6nREqqmBb5IYr+iIbypAZr2IZtKIh5ENR52AZtYAZeqIVgkAU94AAVMAEhKssTYB0hNJgtyYEV8AD/BEsRuJJMe0t1Wv+ihgnChKm9P7GBj2MBG8ADR2iEPnCFamCaXkiEPtADOZED1ECNxfRQEBVRAzMd6TCwSrkBSe0THMCBo1ui0ioxxtiNL7ADHMCD55HCEpOCH9iCQ5AFX5CFVrA3bqWF+LvIEFSFQdQmbToF2TxX2iw3JynJG8mLhJNSTgwzeLtSCqIze0UzNf1SL22KWdKFr0OKTEhU7VCKV2rOg2UlCmIRqlgRC4IFE4GbZyGKYlgGZ3CGiRAVbfDTP4UVWFGHcUCPcRDZbvAHfKiHb4gGYpAfX0AEGbABHLiAaQywubqAblw5D9CBAA2YITIBDyABm21CITQ5GW0YhbmBNIAMI2D/gY+rgR9ok0Vwg1F4hqWpBmFghD7wgz241ThIDTbw2l01gzEAvzJpnhztHhJwjN7Ag9CyR0A5hD+5jNVJgyXAgS2Qou1Lo8hAAzsYAztABT4MwfjTrkAkV3KlTY1ckh3yyNyUu4MDJjKLQDq7SKPiVqcKPCmjXFiUMlpYBVoYBlwgBETwBBSyhE4ILpsEuGlR3dUNT/G8mv6ABmnoU0D9hkG13Xn4BnmYB3qQB3kwCHUAXuB9D3NwlYFAB3RwB97lhmpwBmUohlnwlx8wAhGYgAngvRAoywuQTBe4kpolDBO4APA1GIUJwp+9xkrljbhkHRhQWs6ADtxRhCZghGRo/xpR+QVE0AN3fIPVaIM28FrVMAMyMLAciIER4wJ+bJjMkAI7yAVtZIw7SJ7maB5mNU0dQIMtkEJAqIOVszUuGANHYAVZYIVZsEmbHFJyZYVWONLD1SXFBYVtwk16MbeDU0nIta4sncVwJcH5awXN1dxZIpHO3TdZaq0/xAtWggVdgBv5eRZhcImK3VNt2AaDuN15qAd8wOIsNtl64OIuvmIt3uJ6ENTe7d1vcAj7kN372I9jUFlRUIQx6IGeldkQeJhhFUKfFZM64NRLHSLdC0KfzdSfDTYXkJjIygyJqYF7So1rlYRGuAI46IVmMM9naAVBqNVbTQ038F82YCwYiP8BLamM9AM+2qgDWQCGQzAx5eGNibIiRIkZNHiZ6Zm+g9kNM6mBIDiEv91WwdthFDbSw4XhxJ27W+yKsMDFJ13A3SSqTjyzlyS4qMrXD3SKV/C2g31YE/G3TyrFWnCFXSAGjXCGaejTgqAHLq7icxZjL1bnc7biepCHdTgIhLAGUZmGiaCVisBni42GjEgGYagFS0AES+6BEhCimDW5hwnCEKhZEbgAIui0LyABdCK5gzEwGMBUFpgMGNCjO2RQIzgEO6gBJWiTSmiEOfABSviFYpDkZxiGTdg5N3ADM3iDTRYeL2i5KayY2Iu5e5yjUIgEKaKsSLgNeEoDn26oKgr/hdlwjhu4EpGTjB+YgT3YQ1m4BRM+YSPFamCWTXSN0mRewK1KwXg9L6Cq0nDrJX19CqjQ1+aMBfBs3YlFEGlo3qwpBmeQ4toV1C/GB3/ga3VOZ3a+XXngBkDdhjO2D/u4D3oWlcWm5/J0bDItU2PohVSAhDzIgzZQAzPYgCCagAgIAQKdT5w1OUDuRhdInRzAEgaLDBZgAUTRgUgABIdxASl42xq4AzzIgfBpZEnwAyZYg0v4hWRphmC4BUTIAz54g8WcaQ+t6SyRHTcEE9lR4MwwgkPRge3bjZe1gZrJjcaookhAlDtoo0IpMZYxAinYAjz4W19wSIqsaoqUSD6k/2pZUKbLcZzD6cV2OUCziE5NXJEGHC8UUd3wzNP+cAapcYhrKAjdrWKDwGvb7WIw3uIGN4jBLux5ZuzzrGcNd+x6tucPB/EPL0/ILtNmMAZh0IVV8ARFuNA88IPs2QAPKKIA9YCehc8mHJ2avRIZJTaFUTqLzqMaYIFOAwTYCbFEMQEjeAFovcJCaAMf+ANQsIXXCgZfwAStlQMPXW5OxpNEAc2VkYze8A0piJk7IIIXmBQ3fIE+qSw1WqccmMIcjW45WiMd8FuH1Mqycz+LxGqsJpJk8gTGoZzGGRwUKpdLSMoAzBZu6c4LulMmft1jgAapmV3affB50F160PRN7/9dLO7i3m0P+VCHbiD1Um+I++hTxJ4ViFjseu7wV4d182xsDW/sDpcayN4JY0C8VFgLRfADPzCEPeCDH+iADpiruTrLQCbtiR4ToeZG7nUBE0hkuWIBbhzaQ3mYnB1WHOADC3OEQuADIAgDRLgEVni2XAAFQ1g+/91y4dkCQemsleECJjKxhpGYHHCwEjOdJe8NQ7kY7+4rKRiEe+KCFuCT5oiB3UiDQ6gE+d7WPZ+FbMrqbFIvt1uXxGELRI/TqWz0hyVwYjDwpxGVP0WI2j0I9yhndcbiTeddUIcPUlf1qEnjWQlxisDnibj5D5cam68InreIPXVsEX91ihjxDif/8WYACqOQpVLIBBRShEVYNEfoARtoAWmvgQnIzxFgjAlojvItORIYZELuxhu46BrAK4NB7RZgGA+4KxEggjZxhEcQBEPoFCcQBEnYhL9FhUWggzZQDU3+39QgA3hKSHyH95eRbtYp0TogGMb4AiOwARiFJ4vZvjTQNTwwFNMhghPggoBEqB/gg0rIJhE2UhFe3NrEu1TAlkywBGxpfYZ19PDEnye+2PqFVSkm+Qq39IX4hlVxld83bFS3Z3zu+ZrHeeLfeeSvCP1gfnyGBovNCIyA/oyY/urvCWVQlmIAEU/qrldIBVLoBFMAi0AvvU/QBDbIS9BZ4IApIjK8Y0tT/+gL4II7wGPfM4EVMIKxJIE0GoEEG4HaAAgiHjyQePHFUaNHjwoVEmRmhxM9hiZt2nRITps3Zty0YcMGDUg0XKRwIaLjpBSSgNIQqQPoxsgvdbjkICnlCxEiMtPk0HFnEKA7LHGm1JGTJhcdOYhIQROJzyFNrKZSRYWK6lRQoE6dSuXVVa1Yu8b+Ekas2DJn0qpV07ZtHjdu3+bRrftNHl5537ht6+vXmjVq1KQNhgYtmuHEihcbjhZNGuTIkidTnvzYMWPDzjZz3syMmbLQx4qRJiZM2K9fvHTpwkXLVSpSnTJlumT7EqXclnbnvt3JEydOoGxvQhWoRIkKFkjcSP/DooOHCx5ESDkhIvqF7CFE3CDh4cRADyNYTM9B4k4dFy9cnJAS6Yt3GAYdOZrUyJCfQnycyNjxRpAijRTyRkZjcOQRGWSANBJTXIykgxRE3HGHg3d8oUMaDpqUhhRG1HEHUzK1dAiIRNwgRYZcvECShCaexBSGaPzwxiGfyCLLVJ98goqOn0w1yyy4/GLMM23NVReSSdJVD5P1zCMPXdx0IxiVjmGW2DJZLnMYNFtqCY0zYDITZmJWdmbmZJxRNo0007jZppXSIAYNM1kqM5ppqfHCSy1hxQJLKqOIMuhuhfIGCaKIKrQoo7nlNkkluQnnCSYVbeLIHkqUMAIMN4z/MIEHK9QgXnQnuHBdeNlNQEJ2IlhwgQssnBqhCCecoMMNnYaAIQwjuODBF4c4IskjiAjihx96MPHBDmG04ccebyg4RhsdIQgSUzdAONILXODQwk0kcfFFhESkUUdKOQzyHhfo6dCug++S5O4XINbUaU9G5aSDh8IeEsggdggcRxx8THJLL7z8Qkw0RyL5DcRzRRzXNYFVQ001b7Jp5WOQcckxYs6Y6dlmYILZGcphgsyxnI5FFg1nzTQTmjHFEGPaab+MtUssf8I2iqCDCj0obYYa2ltukCjECCOMMqqoQpMQSwkmnGBCkSRvbDDCd1/cMMFyJBAxggXXSVcrqwOJ/3BB2SKIQIIF0w1EQg51wNCCDi8QcQIMtnpXg4T0NTIJIoVA60ceQvQHhBocvfF4tdYqiMaHI3GRhlAvkKBDIICklJJJXNRx4ReXT1jHDanrUDqImgxyxyF11JQGhGncsBSuLuSgrYNpGJEGGm9skeEWW0ChBybBmFUMM9VsYw1bljWmGMiVRcamm9lPw5b22q85TcfSOPOMyCNzJhqeN9+Mms47hwUL/F8FCrSg9A8tSif5z0abbfzf5qijoJa0pTXNaYvaBCYSWAlJsKEDJVjBBd4WghCsKm1xC4F0LhACtYUHO7CSwtrOdoMvuMAFJAiBC1CoA75ZQAr/igRCHv9hCEEcaw5zyINHcvgRkETuWmg4xCDQpZOZbO5yl7OJFLZFBAeJDic32FtPbICHUPwQD3g4xIVSdK7SWW5cFrqJTOpQhwzthAt20MMllLc8YxwjNKH5zGecEcczpayO40OZYzYjp/E9o4/PeJMf+7iZmSUjGcaomfrY1z6ypCY1Y9FFLSAZSVz0qZI9+xP8YOGKTbpiFV4xBSlIMYpQksIT+asNbgBICaax8hEJIaAiWOkJrWjlFJ64Cius8gk0UCACJgBPCF3wquwMcwLSiY4FXCCdEMCtVtthJgwIQpNfmeQ6OYBBCV1QgxpsYRCLQMgiGEJDaOmBDnoopw3f4Ab/jkQOJGYwwxhBV5Pb6eQL9uTQTRjEITG2K4kuqN3w7LAFLuAhEB9KAxZFdweSyEsKHxKjFNCj0BTtRA6XEFJqTnMz0pDmkDU7RjLcGBqZkbQZdSxpIMkns2fITBmFNGRpTiNT1fBiF6zRxc4eedOb7mJPjdwTayjZGkpWsqjw42QnV6EKr6TCFE4tRShN6b9LJBATtimUox4xCVXm5hGzBMUmZmlLq7DiE2+ggDGRSZDpuCo70vFOdjyAwVO5bYMxYFUILHCutfEtgiRwAQyYAwOd8IsFShiE4BZhiIYcaw90MCcdbCgHdkauDSExQ4b2BZOIvkeipWMRioQSREAc/yIpu0uJESIRCiMEIhQ0SUPpYDCupCTxC7vTSVCCBYgPCSVFY0QeLXjRi178Qo0y1aj6zlIMj740pCV9rkuTEdOc0XQ1QSVqUfuEi+1yd7s7vSkvcLEa4SqsuMPVRXi5a4v11oIW7X0FfOO7ilbQVxX2VQVX8msKrtBSK574Lyc8cZuqUjWVAKQqJnZUkU/ckhWYcIMGKEA2Y7otbh4ILNvAZjYNYtCtHogBF0jwthicIAY6EEEIYJCdaOruVidJig5MsIVDLKIRjVDEYo/Fh3NCVrKTrWxGQsLEoiTlDru1UIY4VBKZfAEQkVhiHd7TKRjooA6a0EQaMIer1Z2oJv+iO8q7miyUh2JOjHYwXRr48IlWiJcXvvBFMIx73DnHuc51/ulOKwmL977CFX1+BS0CHej12qK7hcbFULuLi0OLNxfiTdhwg5GaYPjiF8MV7nXXK+j4wpe+rbgvfvN7iv2Oer/9PbVWgsMJBCaQE7ehTVVPkWBWV6ISrKiEHFLQAeVIJ25EQBVT8ho3t12HBCdE5gVIwIW43soCz8RgCE5gbBHrILDSbsEI3uCIRdRYsQ3xw47Lic45yEEO6qzsG0LCRSZmyAhGkImDZIKeerYERDqIRCRydSLbmmReUoDJEIpCkkNwKCfnAgTrYHsuMQKP4YEoji2E++Y3DzdhQJX/5FGZ6lRTlAKqoWQqyFOxCk7DlxaAFjShtUtU7363NeDdUy98QdzizlQXvZA0TYNKaFvEd5OvUCrIu/JUqALtv0b/zX9PeYlVI7DWCQQOrC9RCdxUqhKbkIQkFiEJM1SgAiPoQIbjVpIRXABXcR2B29L21xNyGMWtmqAIUHAqLkRTxQSR9qkuMAIT4GHbNcbxt8MN2XKXW53rfFy6QTKTJnLB3atbYklmC1vbfo4LqtO3tqTQk5ss9CY6iEEOshyuCN2En19Y+OjSIDA7oCfKuWzFyF9B31eQguhAwx/+9Kc/2uRvlh3XSig7zhVQg5rkgnbvdmuh6JWzHLyXbiT0/1Nz6dVMsha2MDl8N7kKTzqVFE0FJdB0vz/aZGJ/RrvNVWkzqFGYYhWuoC8rQDEHNjCBBirYwAw00PUJRGAgySZBC6TBryjTMMXNCJwQM7GdBnkHq8QAETjbCQGWg2CYBk1HYI3ACNAAH3Db34kTuJ0Tj9EB4SGeGyCeO5HI6SVRDohOStgTutgTE72LTkhBpxABe6wgDJALiiyFtvzTDcTAZw3WuNhEu4yOGLWeHWSZGH1BIOwIKpQC/UCV0ZmS+JGfFV5hcPjXFHpCKThVV3iFKrgfJ/WZK7hXUcVCdhXVTXEXeuHUWNTULhBDMhBDJOlZn8BCn22fyHEf+I3S7f8NSifcjyioXyiNglfsWS30VFkUQzKYlJu0hTZUA0shAyrIAAY8gARIgAPsXwRUQARMwARIQdrQjgiQXQbpnQi0wF3BwAYtYNqFABCeEAygwARdwEis1ausVSn2QCBw4I0xFjmJ22ON4OOsU0YkHsKtYE/AxBd9QSSASOn0hINEVCjcAd7sS06QHhHkADfuyzJ+SMBtnkO1C4U81ISgXr3cgR0EQiWAQtCIQvjpHvkZTaFYYe9N4W/QD9B0HCl5X8h9hSYFJCKiIRpWEmtk10FCUlAlwzMUQyShIfz0zFHBBsjZjyjMjyF+BVmcxnIx5B9BojaEpEhGIltkjPjITDL/DEMpEAIbaEAGREAEOMAE7NonwmQEKFMLeMcLuIopekALtIAImFCKyVUCcoFQioDsiAAMjA4KaFBgVdsCSpsIdMAPIBa3KUI4jdMe8Fg5DWMxntsxgoQR2EG6+ATCXU4oaAJJoIu29AQRAAKWyYuJgI5RpE5LAAJKjEQkAIJCjZAY/eW5oMc5nqMY9Z0d0AElmMIowEJBukImMeafXJJkjkI9ZsJulF9t8J7u6eMohdwmpQKn+ZkZpqGfSGQlIRosmNwq0AIysFRNSSYmwSYjLY8yqAVI+oVfjCT3ZI8gecaYbAb3PENK9sIqeMJCiIEG8F8EXMAJXMAnnsCrxM0N/4iHCEwA2l2AdTbn25yNUkKTg6BYtMFA3wxBtZGAVLrAdPLNdLgADtAItxXCYjHWsZzTHDyWCJob4hmeR6RbvRgB4HDB6ygcwrUEuZzEZ8EEUlROt2SIW/IW6IRIwjmUOkbCSGCOhTDcTCSh6qXBG6hBH4zCzizMIuUUz4gFz4xFoAzNKPxXIQLNxr2oKVQk0KSC9okhUt3oJmWSREbkHa6mLwQXepWXzggDaRzDmGyPW+AmboYkW8BMZ9QJHG2GMvymHMlRHHUPSxWDL6wCJVyCgGRBCXQATPaaiHkH2pmnCGiOeIiYB6QO1wwEhYFn7EzABCnTYKkYh7FKBsmWTv/iAA7YAbcdgiHMEDCGWwgSo+G5wX6igRE0nhG8S02UTjZaTgucSBKNxB0EwrsFJhn124fw5aWWxOp4TSRowunVgR244ISQy7moFh64DocKKiK4wkaOKIne6iPVQip04X6VwimEWox+X7Aylfc5pibBxmNGJCYlq2TmVFkszzD0giUkQi1Qpij8wkiKZMbkkZPK0TLcyTGEq7geQ5aMq5bAEWh8Bps8KUoWgzDwgitYAtMoQiHswQzUpHOGYg5YANhYGC5agHWgnQcYk7G5VYqdx7JFmwa1h9oo03bszUDYygmEwAi8AB84gqAC3rcF46ESIzvl0Bn4Dua0RE7Y1u7/rGBO5AuC5kAgSMEVLdHp4USY7VYdQKo9yaCEMpwUBIIjZNnp3IQdaEKphkIg4AFi7QEiMCaJwibTTqbGhWEr5Jd9wd5S2WiOJquyNquzloVyLQMzQEObgKRINsMupAIsHGQcPgMzkKuWlCvbilS4ok+4ctRoFMO4htRnjFQzqO1L1Yy7qsYrqIIn5AYmVIIm8EEJ2CQorgrZ5GLFEsQLREcHHdN1wKIObNCxndArbgerGNt2wIAIiI55bMcIBAHPGgKNxaeOgaA5daXHVouissEZ1IERaMIh4EBmpcQ0RghRaIiFqMggDAKCwphJ1MuDlIROfNm5PFEdWMEgAIOp//LWhExI0QaCHYRCLmiCHbBBH4gCbGKkPooCFIqC9xmiYhriUu3X9m1faEJmQULSbBYpuYJtWyip/TJpNbQJNcCM+NgMahCDMchMHI0rARewARdpMhyDR9mM/7KPTfVJJ6WCJ/Ae+lUCpOzIIJQAWkXAAsgkv4KKBZTNdEhHNA0T20SbqxiTC9xBc3YYAmJTBK1QBG2jC0jBhb1ADtzBC1jACyAUxi4CvRZqCHblfeZnospuowZCGuCA6EQe5kQIgyzZ69TBIPxO6azOhMBYu+RES4wOE3VRRKHBIOQCHpzqXzJcljlFLhDcG8CBJUgmLMBox/GjKI3vH+ojQPYJTv/xwvKElDO4SUjiZsRIzDf8BfRQSWUMRmRYg5xkDzPMzDOITzR8hpa4USWPK0etD/vUlCT9yfwIzWwYzaNMglVdwiScsiRMwidIggbzKwkoJyhOByheR1r5X3SCjf9hpwUQQQywR3TkINww4Ildx7mchHnwjW05SN8tQuqKk45tpTAOI34acewaARoAz7vBRA7TxAp+DuQFDBDZAbpEHpMNgT0tFLmMDrnALIRIgR3ggThnCIbK2xid6sIBTx68cSoUJMhtHBSOkijR6J4x0lnU5h9D4jYUsv1uQ0kSBpWwBUluT0lOtGBM9ESvRf62iWdcxphARt5GVyElkp5AUsb/vSMoj5/+vBr/dFXUZFWXToIjPEEFdAC/hvDifqKxhTB2Iht2xlVPsw0xQRMG5QAgxMAEsaJUgg2s5AAwXZgLcEEgXOwhTLXqPnMI2mfhGTHksIEdLMgS6cS5ZMtsheq4aEIgrOoKLl46X4i8kAu5OEiX1cFZa8IdNCrm7ARpmdkYKeFvJcIo9Ewt8ILJBUonsN9X9MkuGMM0uEXE5Ga2asNgsIw0LAZkCAZkvAlktIVFb/ZmQ89aRAP4OIPXwlG4rs9IdzKgAEr5xmP+DM3u5Y+qqRpmppLUPAIlEBAjEMIObEAJDCy/1iRwI9OriBh41DSoDGyGRYeeSptdsQoEIpIA6JpHBICHC4yAdZxAd7Cs38WnB/IBNNunNE9zfnZEQAAAIfkEAGQAAAAsAAAAAEABAAGH6sCh4bWU3rCO1q+S2qqG1KmK0qiJzaiN1KJ8zqKDzKKEy5+AxqGGxZ2Bxpt9wJuAzJRqw5Z1wJZ2vpZ4vpFwu5V6u5Jxuo9uuo5qtpN5tZBzto9vsY50to1utoxpsIxwvIhetopmtIpotIZisoprs4llsoZjsIlssYhlsIViropvrYdrrodkrYViroRirYNfrYFgrIFdqYduqYVmqYNmqoNfqYBhqoBdqX9bpIRspIFmpH9joH9mpH5hoH5jrHxXp3tZpXxepXpXo3tjo3pko3xdon1jonphonteoHxjoHxhn3tioHxgnntfn3pgn3xdn3pdpnlVonlioXlgoXhioXlcoHhfnnlfnnlcnnhZpHdToHdgn3dep3BIoHNRnnZenXZXnXJUm3pgm3hfm3hbm3dcm3dZmnZamnRamnNTlXdelXRZlXNYlXJXlXFUkHFYlG9Vkm9VkG9Wmm9Nkm9QkW1SkGpQlmtKkmhGjW1TjWpQjGhNiWlQhGlViGZNkWE+iWJGhmRKhmBEgmJNg2FGgl9FgVs/fl9IfltCeV1Ke1pCeVc/eVY6dVU+cFZCe1E0c1E5cFA6cE01bFA8a004akw5a0s0b0kxaUk0Zkk2Z0gyakYuZkYxbD4hYko4YUY0YUUyYkQwYkMtXUMxYEIvYUEqW0EvXkAtW0AuWz0tXj4nWz0nWD4sWDwpVT0sUT0uWTkjVTkmUjkpUzgjUzYiUDUkVTIbTzIfTTUkTTEgSDQmRzAhSS4dSi0XRS0cPy0fSScRQCcVPCcXPCIQNiQWMyARMx0OLB0QMxoJKhkMJhkNJRcLKRUHKQ8CIhUJIg8DHhQJHBAGHQ4DFg4FGQsBEAoDCwoBDAkBFQUADwQADAcBDAIACwgCCgcACgYBCwEACAoACQkABwkACAgABggABwcABQcACAYBBQYACAUABwQACAMABQQABgMABAUAAwQABAMAAgMABwIABwAABQEAAwIABAAAAwAAAQICAQIAAgEAAAIAAAEAAgACAQAAAAAACP8AwQgEU8OCgQtAcNS4AUZImjRZ5lRBkeYOGBtPwMzAQ8dMGjAJa7R4cePGCxMlRHhAMRJFCRMwUqR4EaMGCzeqYtXiZQwbMl6waNFChcvRDiFaogjBIQSIFy9ahCDV4gXpUqZLW9TYegNHQiBdcdDEUTLsjRhegXyNcWMhjrdtt9Z48WJrCxQsZco0ESLECL8jZL7VYucSplKzetVCdarxKVKkQH3SxKly5VChMlGipCkUqVCiMDVSpGhRo0WoIamOdCjPoEqUJn1CxoyZsdvGiAn75QuXrFejPDlKlEiXs19q+vT5tS0btWjQo0GbDs2Z9evYnS3TvizZsu/gwTP/C69MmTPz06Yve9WHBw8dKh40yPAgAwcVV9rA4QMJWLNn0khDjW3GIHMbMsNkAcZbQrSQwAIJLdWQQ3dkEUQQRWRoQxp4PLQHFlVkoVBddNEkwkszzXVSCSiihQMLOlhCy07IYNPMMLfQMgsruIDiw1s/iOWVVBFKFdVbSAIhRElyIXmDVoPNMUdCaVHphZRevCXXlnK1wMJIL7CAl14plIABYCOkOQJTXtghiSqr3DIMK6049lgooICC2WWYYZanZ5CJwgkkpzVCKKGnRRLJIHw0stkkldQiy2+vVGpKcJ5kOsmmjnT6iiftJQcNNtlIIx101TkzXXbYhefqq+CV/1eedtBEB80zvyTiXg4qZKBCrxnYp0MZfvBxSCvMUPMMNcngZswwwyAjYhFZLHVBASI4tOQNQtxxRxA2FGFDEEsVAcZDHFmoIl0mmODCSy7U1ZUQL5QQwks01SDCB4jcMgsuvgQcDC2xxNKKK7SgcdYPMdSV1ltKKjliWF4xOS8YVSHJphdgpWXSDU5pAQRdKbjQwsknl/jCyW3dxUK7JvzVl5pppkAVHoK8acstwcwSi52fQdYnaKKEwgnRoiStNCWKQiKJaoso2oiiij46SadYE6d1IoMQN4hyifShaw45qJEINNlkIx11rGb3qndwJyP3d7XJLbes35kanTPSJP/jiRoy5DADEyvMoAIHwcqwRByBDNKIf88UY0wxlN9WzLkfSeXgAjUwxZRAc6RRxehZaLjhQ3SIO9NJ7bJ4ogkpsCxEmSiWyMIGasTZCy+fOGIKLf62MgovhNigVgw1da5QV1SK1EJXbTHJFVZULg8XDGjFEC/IHNPV8JMohz9X5zWMmUK7M6Wg5gsy0yUEIJfYAksvw8xSp2OQNUZK0aKQUkqf/ePf/kKBiQJK4mmqkUQkIBEJpjUwEpva2tfeoJw3qOGCFrygBjlAthx4ghqkWtuq2nad7njHhCa029yYocK7LUMZ0NBbdAL0jF0MgmxxoAMSVrACxPkqB2jYwyD/DoGJaE2uGMc4RjGIESKIhAgMBiFBFYKQhTTQAQxVDJGIWiAEMNyABRjCQxBIgILW9UUlHhABC1aGFxbMpGGra8EGNqADVQAvGMGoRS1uoZNasOIWl7CBVJB3F5LRpGEvWB3ykFcX5znPS18SCZccOT4ctEAE6ENkiVZ3ktWhBHYyIVmazjQz5GkhZ7YoBSdAYTBVuFJ/dnoMZGYpNFLoz2ic0AQmHEg1SThwM4pyxCCG2YevKUeDahDDBcUgBh5cMAcc5IEuskGqEZKwVXZjYTK02cJu2i1vMowGNmIYjWcYoxJqWMMa6JAGGvyqAvVZgQ7g4IchViIYyJBcMihX/zopnUuMBnBAFsJVBIicC4tLqUFCbeACEmQhDC9LCYtC4IESpHGNIsFLDIIUg3aJyQIb0AAkbnGLXuSxFrmYkaRmYYsnSEUs5msXu2RaouzJRXo2QRkLIrmQlun0ZCg4XwpMskm91AtfJCPTX0bZl3vN5JSbsMUgFFGwVqziqqqIZSpSIUtaYsaWs6yMJizBS0tYooEFhI2iDqGctlaQmc1spnvkygMOlo0YINyGqq5ZwmVw05uAVeF3+BYNadRKnM6phoCk4QtFvGENbWiDEzjwgQow4AEaWAEV2sAH17CiQHWrAhjmMJAgVEECBkABFUUXhIqkIUNFaAsQtoKCC/+gYA4ooGhF7XWiiqLgSyiDnQvKZAIvSSCkerBFL3rhi1zgQqV6ZAUw9gAyHKQgpqAEpcoWibySxGSnWnnkQnpqE/CezAXuegnM0GfIUDLyBS7AniFfcK++lKBkYWBEKWyBiEFQohWx2OpVV3EKVJiiwKlgjC1l6Rn9CS0UutxlJAq4GQozjRKN4MMbNszhC7qHBzkAsYg7aB8ZqCEZ2MCGXtsGHu7QLbAw/uYywimdbHwDG9WoxjSoMSBW9EGdZbjCCioAzwdUgAMyGAMa5MCHSfQCGVCGyBzCcC7TsiCgQahBFiLCITxUsSlgRkEHPHCBMNwAAx5o6r0wGS+VtUD/fbDz6O3maARVKLcXs8jFLG6hR1y0AhiLWEgiUYDJ86nXBCrbrvfg28Yu3VQhwA1fGRGNluHCjCY1fUtSXcDpQyLvJeotWRr0q1xg9KwVAh6wgU1hClQwhjGw3Cr+QPEZTYy1gRHmxC450UBFyAGZGhRDBwMX4g6SjT4cSIQznqHi7bAKVimMcWC/85wAmQoa28h2NqrBY25LIxiJuOAVmKABIlegAUbmAA02K4dBnCJaExJCFcIQuip0YAEuSAMgqoCHOXToDv2WkhbMhGYPpOAOJSC0wQt9FvJpZdLuguQlUbCCJ5QCGKauBS70SNJatKIXsOjBDcpkAQuojNOc/+7uWxr2PRxoLwXg3dINipBQhoQBCCcDQkNagBaStZku6EVvIu/LonaZJF4wK1kKXH4DPFwCFhiHVi5u0YqqV50VWEcF1rfOdVZs1cCjgIxkdMm0ShQQE5VIeyU0QQpFqIEHcJVDH/Lwa2UiE67uCRYHPMEMaaSNr+PxKwtrQ/jCM+MZzyh8NmuD+GXx+PHSaPypoJOeZwxjEmLQgeZn8IFyM+AAB/gADb6wh0D4oRG0AFkXFQS6KjjAAg+hIsDvQFohZInMHvAABmx7BxiIAAWcxmQJuvtFFGzlk+GzAQlYQIMeMALjedz4HvkcC170gg02aNcFLOAkTbK8JIh0gf+L0BteL0GJLEvSivTmcAchsAAHIhvu+eL8yXahF0XnQy/MYhACd7ngLEAgCJdgZ71gaiRlMFZ3dV23da7mapcyCrSWJ5mAdkxzdmmVdphxCDwgAxwYTR8Gd3BFV3mXATLwCgBCKiz2Hd1keIaXeNyEG8ewTYcXIJBnbc9gHQECHdRQDdFQG7HABzwwBj7gAzNQZAfwAB+gAkNgB4FACIjgFE/xFFLCfhfgAONSBFVAeyDROUBQAhdwAb2FAdkSBh1QRilBU3WhU5PWAjZQAzZgA2o0LntQgMGAC841fRuHC8NQCD2AXh5gAWVxFok2iDNBFuQnEjsFXG7IAuP1UyL/gQNPMXIooV4scmiJ5AHtghd4cRci0AIJp1M3AD92hnHAIBRXp3WsYGANyGqj0IoQmCefEIufkAmZEIuaUAmTEAm2VkC2lgmVkIEgpgIyYFfGRjYfVozBkgPCcHiksh3dAR7dlETHYAwySHhQZo1QdkSVIzctaG2psmyIt1jS4AyHFwyOcEFL4AM6UFkZoAH1oQI0gAZ2IAhKAmZSARVeYAMOsAGmFSJFADE1gHsYMJBoJoZ3gBci8HtCRxdbwUYwwGlu+IZwqFpVsAZQFwy5kJFT51y4oIebwAQwYAJfWBZkcRbfp0klEi/DFUkn04hfoiWJyJLAxzqT2DqHNhMm/5BGCekSKBAmaZR7n/h+gPAImwALO4NntKCAWcdqTOmKeSIZTwmVT6lrm2JrtpZLmcB2oXAIwiaMdkVsxRiWwaIG1Mhs2KCCgTWNS6QbwkAMSyQMcAktwyAMeBQMAeMLwQCXbUkMfEkMxnB41iF4hLcs42gdLIQMvcCVY7AESaADGpCEFZABH7ACXIAGJEEXZ/F/JQEEHeAALUAW6LckHkABuncBu2eauUdaLmADjGgT5IOICxED2PMWRdADQfB73AIFl2BqGpmRJAUwwdBSIfmF3rNIJQIXKuNTMYkCQsB+A2UDVaAlLQlJeNE5wxUDEscCCVmJQMUCKfFbhCYmCf+Ze7+Xc4BgCESpCkYJC7BgdQR2VbHkYF0Vn2GFCZ1hGZWRlaKgCXygBtCEOMIIlmGZAx0YLIlwG45HeCokjUlkOW0pDHhJl3gkMHbJC77ACxhqoXWpl3tZDNu0HSzYeOehDH6FDczwCW/ATD6QeR8gA+woeg3TafAVX11RAwtgAVsBFkuBARRwAWT2hUCae0GABzaQBTuVUyKRhloBAyWBAxkSBD1Qhp3TA4VQgBrJC715ocMAB+dzARugkig3XCRxdG3GJBLnJZ0jBODyhjfVFuJJWyZwFgmniYS2k524Uy8Qnm6qcL8HnoRWA3iAB+fJCE/HnqtQdQOGVVdlVVb/dagJ+KgDFgqUgAmf0SeWUQqW8GvQFCwBSqAcKKAdyAH14Qm3cXgDok3SiETSODm74Qu7gKV2qEey6i+zUAu1ynEauQsdiQu74AtwSQwxWDeC54LaUR7LAELU4AuDwExjUAZM8CsroAHtqD43mQIxABZAYAELIAJIygK7RwERQAHiegHiunsoUCFBsIks+TyIOBa0CS4+mgI10ANtAAvBgKWvmqG8IAy7MAyMcD4dcAGCqGibxpBtsTJ2oRVvuJrjsiV38VtpRKd4wSIuIVElYH7U+XvjwwK556MrgUYskAZzQAd2AAiIUJTyAwsDxp4qe1Us+7IwGxS0wLL7KQql/9A/s6QnpxAJajAGOoA4FZCEAfqpRBuqD8ABszAMf7kscpNElEM5DTo5uvELd+gzqHYKBLZVqZCABdO1AMYKrhC2tYCXv+CXKkSiNwgg1nGD1JRiyJAJa5AESXAFaLADKvABGVABnzR/3nMDMIBzCyABCdkCo7l7ERCu5fqFCdcBWXAHjNgCJtCTYvECMNACTPoCEPMWb2gBpHkDPeADmwAMu6OvGTkMvjAMqmADhLYBmVkyNEFUQoVp5dc5X8SGDMUCDGsDJyMmKEBGLtC7CKlG4GlRCdmJl8SJKgGy2ikCAWsBuZd7JIAhWUAHe6AHhVAIpJG9iFAairC925u94P9LGqihCKdBGo3gKKeQVbMWCqXQCGOwmBwgrUl4H79StKEqqjyAR8Uwg5PTv08rOVILlwFzC7IwC/bTGASWvli7CqqQCgNWdQWDdQDmCrKwC3g0DEiUDMbaeOEYIN/QHNigLLfQHleQBEowBD2kAqyDafFVjzgQBBKwAB0AA7kXAgRJrqY5kGm2k3jge7BDk20GAzBQImkKaSwRLk+ACMuVoaPLC3Z5C7agA3N0AY7EkA15XUOFA0KMA//3kMMlkTbwkDAgkTTgAitAcSgwAy2gxmpMA16iiSTwe0eaURCriX3aAXjcAcz7hR5gA2DgBnawB3ZQB3DABm7gBoRcB3H/QMhuEAeRBQdyEAdsEAdxcAZxkAdtQMlBqE5voAinQDBVlwpwcgqisApuVwZLAB9CO7QcSDatPIwykAF9MJfCAFrO4iwG4qAQGgzDwAskZT+toLIsKxTAQ1LGrK8ZmpG8AC2SM4MdLCCPF80g9AzNcAo/VgZnMBESsCImgBYl0UVLka4KsAEpAKRfKK7oTAEEqXsl8BQlMMQdxV6UO8Qp45JfEi5YYAd3pq/LNQzBUFJroAGcC17eaXwqgnI3wFDeldA38LvxxWklI8QswEMTvQInsHw8xEMXTQIc3dEdDUm6y9HkmbzMy9FeugEXgMcokAVoQLJ0cMh00AaHfMgy/03TaIAGbJDTOI0GZFAGaFAGQK0DRtAEZ7AGi2BHCCjKWWWzgzAGYtCYh/MBqwyqHHg4HMABk+DPwiA5uXzLt1wMcHnBzWXAPyPKw1zM06dHyoyhGmnAucDLSuvMN7hsplLX4chjAoILy/oeNrACrksXXoEVTfElMfyj5JrO6JzD5AkDdyBUhtYuQvyQ4mMXmjivWAC6TZwL1ne69RMMh5ABJZcyLEMW8rKZSwEWkW1dO1mn7SICJ8B8M8DRJ2DRss3ReEwCOjmeK8ESZIFGety7HkACHYDb5ozSHRAEYEAHym1QAgERWaBFaWAGWDDdV3AFWCDdWAAFT8AESsAENP9AAzrQBGLQCHFidbL2GaIgB8xkBDoQrVIt1fULllV91TJQC3gkDEr7LMz8tNo4l3VZl73RCrIQC14XylZHJzthoXcZMLmAgLMgC7yql8QwNy22V6xyg9JgDJjXQTMBfsxje0AAAziAAh6QABLQo4htzgXXsR6gBTcQAnuBPpFtEiizJcB1A6JFA0qs2Vh6l1LHC5ygAhtgAS0ZPY9IFmIcxqjNaTiAEkElf+ilRhc92ywwAxm9AhPt0XaavBelnWOWRiUgJhy9AWM+Ryi9ASIgWlsGBhnCelg0OqTzBEXABD2wAzvABEiwA0hQ50ywAz3AQzMw1JIAC1Rn3qiwP5z/IAbpqHnRSlnw/SusHKpiYJd5yczDQAyX3pduSTnEYJcRCqEBgwuxIAutgAqpgOB9Jqsah8xt/S96pAtl25cxmELKcAzGaqx8E3nM4Ar+mQMrsz1h0RQNfQNgGAEOgLgoPq5fqMPfegEpAATrlQKRjRYhsRVvyKQxRy020AbKxeMY6guU4wuxcAs+sAEdwCZpcBXwJzJ+610lqT3WhXJCDF/5x3wTvVMr8N3fzQIc3bt9upOJSOI+GrwK5wEdYO55PEe/JxUXUjrUsmWj86RMUQQYAqXjAi4WX5s20AGFowNOcAnAIxRVdbWSwANGsAM68N2dpwGODulVLQO/ctWz/1yXzMyhEt6XdPkLdonflH6vED7gBYOrxsxxt5ChxmzAHTkpsC7hsx4eFL4dMcRjADIM4eYl7jIWCfF/5WyaFLAAx47sib3sA4nDHeC3/Sft2DObEvMWF1IxyqMgVdAEpdDE3/4swfBxeaABJNAVWtAQSbJyTNruTYo8aI9y8+cu0BkELPDaNBCTGy2xjaadz/uTaGTwHmDcl//lv6UVLBAuDOUCFzIu41IWEWkD+k4DJ7CaNGD6K2ABJHACKuAEUdULIm8wCXYKipADOmDlFq0Bvn/VlAXpkA78HHBPNA8teWnzNv/f/jyh/nyluaBHVTXuy1X91e8vBUNSGSl9b//9q0sboo2XYiGMeODGEkTsFZhrArs3mlW4AIeb2D16zkB64j0ap2jPpGQhm9VV8UGgJGdBFgBRpEqRHYp68crFi5cvX8iGBZt1a9EHEjUs3riBQyNGHDFcuIDhAuMLHCFNgHSRwsRKEyhYzKBBg0XMFSROrFhxwiYKniJEkODJgsRQFkKHkuiQdEPSCx2QdvDgAUUJnk5JLLXq1CqJqEeTOt2w4SkJDQ4mVNBQZpMtW7BWrVJ1KtRcORw+cNBQQe9dDRz8flAB+K5fDjJiBUMcbNjixI0dN37I+GGwhMCA9TrI6xYtWrc850qYa7PnWLBgYaalalWrWKBBM4Ttaxf/LlyyXr0S9gtXrVaZBr1h0eLFixtAcJAsIQGDhwsUKERY4CCCcwoXLmDA0Ly69esXQsCIAQNGcSBAbsCwkTHIehswNh7HEcTGDjmYFTLs5XAYLVibZpBooYYbagjwBuI2+igk80y4wQUUTkrBBROoSgEFEmKiYYYVitJpQxZOAPEEFn7KqoOmOrDQKqM6wIrFp6zzySUUHBQrq6uQQsqDr5Qi4QILrvpRgwYeqIADNizBhJJGGllkEUUOOQSRMTLQoEq90KrSrg+2FGxLv3joJbHFGGssNoYQcg1NXBKahZVWUEGFFDlB+SSTSe50JE89E+Gzz0EG8aMPQQV9Y9BB/xP5c5A++nTkFVdGGaWPNxRppIUWMsLhhhheSKEED0JgjoLsHEgAA+dMjSq77E7sIIQQSnDvBiGEMA4j8QK0Idf0yjMuU41seEIVy4AZM5jLbhHFFjo2FCG4F1rAAQiSNhoQhZDEQyFCB3nKNqWZZgAXw6LGZaGmE2iwcCgXh1phhps0tGGGDza4SUQNnnKqqJhImKmDmkj4F2B1bbJpBbG86oBLvTLIQI9FBjlkED78AJSPQPSgoYIMrtQrr4UZzotIjb/k809D30A55UINZTnRPhIdhE89Hbnzzko8wdmTT0YxxZVXZKFtF6F/+UUYYYgp5phjkllmGWeeeYYaaf+okRobbLK52hhHKkllEuFq0Oi4j0xwNapPS7hggQg8UBU765brwCcRSlhpPCC0mLVW8WCoQdf0MDVwPBzmg4StXm6x7HBabCkFFkLADTA4sDfiVKQbWlDJhBRSEO+jlEAKyYWXwvVbpg11qtfDq5YKqwMLajzhAw2o/OAEeecFUSyhcrJJrBrDssCCCYZ34AEFBlCgAQUcaGABBZ5X4IABBjjgADHy4GOQPPKQQ4435IgDDQYOYKB8BhRgoIEhiRR5yIVVyEDllV+W+U5PRnGFNl2EZsjoo4sphjGQMUACMsOAB0Qg1J4GNQZCTRrPkEYEpxZBqlXQglar4NWacSf/UFRiEJfSiHFSUoIShAA7nyobdLJTHbddJyquCoEJYLA59/AqU51zgaVa4DfxvCBBuWIBHSQhCU5oohSlwMQmhtiIUlziCUUhUIxwMCshZMoiLfAc6LI4Iy3GhHSm0wnBLhAWMgLPAhxrgPnUWD3qTc+Nb4TjAAIQAADU0Y53xGMe8zgG7Omhe+CLAxzqgAb1VeAsHNMAl7hEJS2pIAe5GNMwAChAYwhQaclIBjOWlkkEchKBn2SGAhHoDFI+42kRbCAEIShBClqQatKoRjVciQ1qmMIRqABFxKBlkeOQ0AMlZJvZloMB6WDAhNhRldk+pbmVbC48e0sQt1jgAl2F/2Q4WmxBEQCBCEo1AhKLQMQiClGIS6iCDhpCgQ7TWR4cEKhAM0KBCHiCsK+MsYxJCZ7wFFCA6c1RjnTUY0AFOr0DFMAABihfGhuglwc8YAIOHd4EhGeBKuWlSmfkGAOIxINSSCwQfABpHvRQhzq0waILm11fvPQXjfVFBjJQw5iONgz/IQ2AAVTaJpeByUwybRnMaJrTSNm0UpLSqM+ARjSk4YykKlWC0YAqK6UB1Wm40qpUw8YuHMGKUChiYhGKZ0vchkztWKc6DljAdq6DzOWACoWvMiEwU3UBti2HKj8hgQg84JOoMGUDaNCDHvxAiIvBYQ96yEMgJLEGcBXBBv+7DJClBHQRlFAzdNwSwY5u5CGcnKADE3BAaKUjAdKWlrT5FJ5ENVDG1W6pLxpQwQk28IEV0MB2M8nJDHaAExsUpSa+I4G8qlSjC63gAzNgWAXqAItCBEIRfuAD9raXBzbILqUV7YtfVPoBjWXAkTlIhH6QZoyblpe8SrtpTtW7NGUoo2nuba97ncZTohrVvvaFRn7zC9WospIatJQaNaJBNWE4AhSwWMRH45CABSTgoA9ucAIkPOHoSCcCqFpOXbHjVrOBigICEEABCsDg0YpKbkmJCl91tAEJTIALcUBsIPxABzsEVg+DgAUkzgmuGhThBj4pAQsIhIK9qsQnHyH/8lB8YiKrtO4oQwlRulCUricfJUTt0gkZb2LcLbULJ70bCrhAtFuBIUUs6QoRiGoyAzAgAUSMXIQtFBFOP/jho9HlwxpA9lq7bFeRDCvMS0HRjEpOspLkDaAxeLpoRi9avst4dFCdcUD7mlKB+OUvfyPY31a+koLFmEQlaBEJRRRCD2xwTgREG4HplJbV06EOXT3AQg2/TZlm006sl1MdqcRzKDrq61ck8IAdwAGxe9iDG+xAUjkcAjOM6EENWBDPoEiOBR6oSAn0ule9WqeeF2gWwszslSenCpl7/Yq6yGjPM6+uAyCigQ2AwoLeGqVdKxI3lHHELZ28+wQcUIEk/2CBCG4OQhGWWIQfsKcGLfWFStkVjJbQAvAciCE/yEiGMS656E8+A5ShTGAqHShBkTNQqqg8+QQ7bcGpUYMZnpjELTihCEjoYQxnSAEGJDCd7MCaOs7J9alMpVbuDDPDKBzm29qW4a/oaJhJIQFpTwAH6e6BDm5Adh4GsQpglGINPcirCEzggRZAsQV6jac8PcVtqGQ2KeGeJ79Q4JR4MsUC1zGRdYI3xnxuwAISCJ5p704B0l7gKR95QWaDyy6nBHuMc2fyVVhERgs4xbUzaFwhwqkIVbQle3lQQ2CqdBcvbSkwAJcBI1XAAzkgoxkdN2AzZD97qMm+5Ld/YMpX2f/yll+V5Q9kIO1lf8BKeqIWp1CEIi6hBh404QKAD20ESCt955hW+qW1AOEpkH3u/xzobA06dfa+1u6Y9VQ+IsEe7FwIQvgB2XUeBCiCYQtCrCCez6EADlqAbeYsXQRl7zZl4olei5DQ0Za5KaG0k5u9SruoaBAiixfPorsSiptsaQkXkJYXsIkQ2QBLCTIUsD8Y6La4yawNGC4TvBcNMK4yaItCSL44G6I684MmkAGcwAkayAkb1EEcbBcjkIFEmD3ba6BmuL0irL0gDEIDIiBjKJZg8AWEuIVaiIVWYAVI+QRPyIRKwBNH4JOIMRmWOYRI0IRIaIRIOAQeeIM1OK3/nSux6mO16qsOOMw+7kAto1OmVTEr7vC2vWKb5kg67AieDaCDQHAuRqgDwxKEQBiESVAMS2CCGXCBoTOOsuuRuvqloognZdKrbQOybBmOF5AKuqG2bVsxbBOBDWiKunOK2CGjueI/BsScEiAYumsBFBiBlliBkzARCcgsvrOuLTkBC2iXhgEGWDiEJjmERoCuOgsEMXipGuys2tkynJgBHTguHZCBHIgE/ZiMYMgMzdiMKVyFU5ATTsjCLdyTRIASmFGUQYmu6foj7/me7pEf+VmDe1wDNrhHMRiDMViDOEgsmtsESICERtCDMliDC2A1hXw1n6MOUyk6tsowtgIy/xIiIVJkDu7gK3maiv7jQ1wLHjYYJ0QIBDQwAjsAhEI4BEW4hWGwhTw4ARGoPiHLCYqYtr2ylAX0kdcJCw/YgBTjyJ5YQKkwCqQYv7vLkabYSe7AihNZCnXpq7z6pRJIAVG5AzygFRhYDh/hjgmQna/8AIrigAwoA1GQhJVshCcZhEAgBD7QAx74C9IbDLtQAZyQAds6Fx1IgjbIg3pMmTgAzMBsAzaIx8Ksg8CEg8QEzMSEg0Bqg8dkA33ExzU4gzIYAydYgiQwAiPYAR3QAZrQwcCwruRiGIb5ABqAA0jYhECoTD+4A9dRyOe4MIkUOruCoRM6oVehinHBrKGUm/9ObIGVQMC1YxvAswAyMATN84M6wAI78AOVPIRSWAxG+I+dtImKOgEikwqLmBsW8JSe/Mi2C4qfqAq/azeCCQsNCETJa4q+M0GMqoB80oDYoYi/844QGIEQeI4/6IRL+IP//IM7MAEM2LbdmY94qwIsaII18INIIENFIDUoQYS1DITIRIM2QIMMRYMyQIPKNIMzMIMyMAMseIIPRYM1GAMNtcwv2AIqoIIrgIInYAIm6AHP9EzQVLPOEs0t6QAO6FHr0i7seriKGlIi3RiO0YvhaaglvRJG0oFAKoMrCIRLmAMWubu/ww7v07WhW6ux4kN5mra0y8RbI9MU4xZu84D/19GAHdA8cVKBHdiDQkhORdCEYUAGVdCB1Qoe+gQMEDmKouAXaZs2D2mBGfgQNQOReVEkadRRHZzG2oKJcNmBHdjMJEiCJsDUJiADMmgCLECDKvCCO9ACECBVEODPR3iEP0DVTuiEVL1KPDAEQ8CDMAiDNJgDMIADNsiDRlAFTOimJUm+QWg/HeAAMqqSI+WYJU0eJl3SZm0oQ4qoaOWYiEJSQ3KoK3koZ11S9eHWNFKj83me6hHXcWUjNyJX8jmAB5CBJIiDRei6IqCtwOPKE+mrpogKb4MKMrUKbom7HSkRfNk3aUIBv8sAHSCEJlkEQRAEQNgmglOEVeAEQlCC/x1ggR/JkGoEF3DZgfnogR0ogifogSd4AizIAjMAgzQwAw1FAzdgWZZtA8ZctjrYA5IiKTuI2UOk2cSkAzh4zDXY0MokAzHAAiyYWCOIt44g1R/4gS74gVIFAQgAgShQ1UfAg1T9AzzwAjyYAxEAvAkYkitIPghdEiZ5kkPggwx4gAZgHm81H+hxWwM4gHAtn7itHritWxHjpzjS2zeao77127/1270113P9Vo161o0hTUdSg0EoBVsABlVYgy1JUjJSitaBOnLbsnKxQX2JN7/JlfWoAjDQlSAoAoHIgiwAg5M92TRIA9RtAzpwQURghEBgP0IghEJYhEiAhba4BP9DEAQ8uANAUD9kswNko4Ora9mWRQPVTd0s+AIuOALO7EwdmF6Y4MEViC0+5VEN6ICLoqjZSa4kjdaIegAJEBUQ6IIueFoIQAAIYF/3hYAf6IQ/+AH6/QMt+M+r1IJQfb4VQINAgAQH1ZN1fIPx4VvA9VuBUuAFtqPAFVxyVSNuddZq/ZjStGBAIwwVQD0eGAM5SIRK0AQm8QM9oIPBPF4as1lk2wOGZdgVZmEVhuEYlmFkY9iFfWGbxWE7OGE6QF03YINAYARFYITmYktEgJJGsIVNIAQ9yILd6gANUYHAiC0uwa6K6phqpVZoJZJDelZs1dYlDa1u5dbzQSsFkDD/CIPapf0B+G1f+IVaVa1fELiD9P2DGAjQO0BVD3AAf0EDRoAES6AESnDQRThDOaqjvr0jBPYnc3VgwSWoc4Vkwo3gZuWY0vQLFXjGHPBMHkgCMeDHMVCDNfie6ZoYiPmTbgo1EOYETGgEQtgDHXaDNACDEXUCJTCCjt2BDMFevrAShhrfX34o8k1b9WnbuH2e9GmAuE0fGRgn22U/QkwUP7BGDSCeMf7WcI3kchVcRQYoBhaobk5kBChVqAUBBEAAAoBa9zXVTphj+m1VV30EIFDVMDBfG+iACtiBNmAEtuDnMviABxjXhDJc8R0e6slmcZ1kSrZggAOMTM4BHoDo/yUQAzWg6JTpHuwBKZCCP0X8E9slhEOATigRaSjhk7A16SWJBDypGZKMrjJYgUSal0RKGL9ITyu+kgdgAOoZErUVrZ5uqNBa0vMBV7eNHgNQAK9cgfNpgAmQAUIgOJX86IiJGBVQ1n2SHr0FXG/W6q3OozmSnuMxaANYAHV+3zWG3/U91S5I1Udg1bZ+BEO4BDyYAAWQABKosBVA1TtYAUEwhBNAC4YCNBWoRh1wgiu41MPszCSQaFCmaHxEGXq86O3J6MmebBkcFIphx8zW7M3e7D7xbM+emUnIk5oZTJ+9AhzEl69IT79Tz9RSUgYogAPY6Z4WLW6FnoOKIwSmnv8CCACCegA9CCcnOYSSVoRBAGht3uZFdmS9zdtHZqODPleDhmDzEVcFoICnLec2dmP47QJVVdW2dmtUfYQqmIAD6ACejoA/uIQ7aDAKiAFVcwo7YARDGCKCtO8yTGkz/BMvHO515GzMlpg+4IM+AHCNZseXERSYaZkvHBR2/OzPDu1JyBmeuY1X0IUL359fADjR24AKgKiIou0QLx4l/XBhbihitu1jRh/06VazGB6NaakP0IE8QARRuAXMwPFb0IQ40AENphLERdab/uIhX58uruBLxuQceGiJpuiKnh+IQcsypIRK+ARUaIVWOAVOKIVHWN+n1e6zXl91xm4QUFr/Mu9uPBBBFpEOB7gD/4yCtMKACJAwBzAAEngERriE+m4SSECERtATRXjwQC8ZQSf0dEwEPbGZnNkZU6hwC8fwDCeaoiEGpMmp9iKl/aKqaaiqWIolbfD0TwcZwsCupVAkKHuJmMiVHjiCiZ3UHVACJnj1WzYCJphU6p3UDLnYjAWXHLRBcEG9ilsDPpDyTMhCOxmENRADifZkTwZlUcYeZrxdbloEb3JQS7AEThCFUlCNVYCFWegMz7hxHA8Tb3yMyYikcz93ZkAGJrSMTsAAdA5zshZzc37fdG5fLydn7wYCVosBVv2D0EKABYABLWC1OWDrTtiEtjaE4H2EABbt/3O8GZyBFApv9EeP9F+Y9Emv9PZymkynmljKhpDfhpDPhm1Yh3WQB3kw+ZSnB3mgB3uwB3qQ+ZZP+XRw+ZmX+XZoB3jg+Z6vh5+vh3iIh3d4BzFogiXITM9s9em9WAzRZZyw0aifXqn3gSVoAn9sTJIKLPWzM7YcJ0MgOEYQe0XIXUZohGu3hJqhhDvBBEx4C9OAhViIhYjwDF4Qd8SIJALSe70XoL3n+0Pr+72vpHVvNEw6oGV4oAEahk6AgABA56YVc/VN2i6gd/cVZzE3a/R9hB+Yg07QArVu1TlwAAQIATlnMAGAgf5EeFa1BS2I8xHAA1hwvah5Bqu5mpHfhv9v0P3dn4fe9/3f9317CH6Yt4d7MP7jP36YR/578Afm94fnf35+gP7pp/7p/4d/iId8yAd+4H7u/wd++H5+2AfxX3aJLgM1GIM2kIM60AP1Y8toDyexh4QhkgRL0IRNwH9O4IRNEIX+z/YjAohSqlStgmXwoMGBBxUaLBWq1KqIsFqRqojqVKhTqmDNitUxFshbInnx6tXLV7CUw1auLGbMpbGYxpDRRJbsJk5mOnfyZLbMmbNnQqMRjQYtmjRp1JZiw5YtG7ZmnSAgqAoBBIirILr86fKjS6epCAhQRYD1KoS0EH48esTV7Z9Oj0akwONlQQEbMCgkeNTpUthOtjr/ZbUK4o4tak6hbtuGbR7kefbuUbZnTzLmy5Yt39vMmfI9f6JFg+7suXNpyv5C+/vn+jXs2KNF/2tt2zW/f/xCiQrFiZOo3gSHR5RY/DisghOPM28+0PlzjREHqgJ1ymIrVK1MmRo1ijsqVKxcuXpl3rwsXOp17dr16/0vYcSIFatf7BjOZcuYBX2WdCmATTX1VGMFGtjYNwkemOA3jTW1SVkIoJWVV3+4tVVYaREg4Q9dZbVhWmDJ1dVbj8TggiGXzGEAGI8YYkhgMf4BglUdgoABGqU0MyA2r0Cmmm2meTZkaqXNduRqlRWJpD/8OPmkk7pJmRs/SbLGZG3/VLJl/yWUbJkJJpVgkkkmXJp5JpppVpLJJG2q6Uklnsg5p5yf2Hnnd6+UBx987tV3DKDHKKMMgABWkw1RimGzTYMMOhoZpJA52iCCDB4IVVPUSCNUM8kYM0wwvvACiypeVHUqWmmB8EOHXYAQ1x8EEIBVh3/8UJhaccnVBa9/dJVCBAlIcIEDDiwQAQx+/RXWIz+MBeJXIAhAwAR2APNMJY5ks4066qwjTzrpyCPPOuWWm4654arbDjzsuOsuOu64gw695sTLTjnnwHsOOuyY86+99IpDDjkAm/OOOeSgY6+87rDjLcTl0jPxuPDIAw+dGWtM5yfeeWeKnueJ/Iosuph8sv978clnH6A56RcUUkoVKuA3kH6zLaOT6rwzpZZS6iA21ETjjDKAzveeLufJOYkjiSQySB9Rv/GGGmqIwYMaPPCQgwwy5KCCBac+q6paIbbF7B1k8crVrTSihUBccPHqlqwJCCDAAiPAEIEDI4zAVmB/QECAAFVtZWtZFNwgiAq+bLNOO+0kOC495I5Lrrnnhtvtu/UGTO/CCqNTTjnszBtwwgQDXLDB8hpsTsMPd6tO5O3YM3Hll/Mp33yBBjooNMEHT9Q01FRzPPLVaLM88wc+Xq48DK7zzfTrzCPPPPRkn708E092j/aQXTbPN00ViGnQSz3TDPvIgCqML7uox8r/KJ/AybTTiUQtNdVq9H8117wWwK4RkIAqUAEHODCDGXztAywQQQSsEiFVuaowIOgEMAbzCC1AoFe+8hDZQOCXrnjIVxGIQAk8YDcK4EELC/DCHyIQBcB04geDO9VWuJKVtCBgAn3IxjfkEbnJde9y48pcusJ1jnKArhwJA53n6EU6z9lrdQRj3b9U5w7WFSx2s6tdO3AnRnowr3nrKKO61DEO0k0RilJk47vYcY456ouOdnSXvtwFj3axY4/4+GM+4iHIP/6xH52ZBzRe4QmmLc0RjkzEIQ4xCKcNIg9ykAMf/KBJTQZiEHz4JCj5kIdRXnJqU1vDGspQhissIQlG//DBDnagg1nSYAUrkMEKFqjLGehgBSx4QQjGIkEJUbATFRQhMIChLC0c7oO2iparLGTMtfEKBAQIAN785gACeOERf/CCF2g4o6p04SokeoRaEOAADSBjG/PoB+aot47cHRGJmkvHEqfoRIMt7F9SHMc4+NnPK2LxirB7nRdpB8Yx4k40t8Pcty5Wj3rsER7vEOQ7MvoOd2i0o++IYxzpKEd41EMf5yDHOfwpr5OqNB77iIdGBRkPkq5jG56w2tZM+YY1sKENbehp1gJIAzBkwQxsQAMqxzDKpeaBDqS8JBzi4NM6xAEORyUDFprghClYYQpHmMIUhsCFK3ABC1cwa/8T1HAGMHjBhs9CFQUt5JUOJfMSI4DVq9pColVxxSt6pWZXTiUAAABgWtwMiy0SGxa3msUrr/JV2SiwCXd2z56Xs2cS1TU6NhJMHANLHcFIB9DP9XN14rCi6hCaUdkpNHJGpBw9XMMk2sSmtv/QB271kY/cVnSivs3tb/kRSJhuVF5OeqlMkVtcQcJDe8/oA05zULXprsGnM9DAAw4wgANo9wEPqAAHPqACHSyhunE4rxvcwAaptgGVaDhDGciA1SYwwQdG2IFXhxDL/Q4hCf5VwhIAPIYzhMGGsjowiLKyKmV1wkLJ/MMcMNhgZnFlRh2cUa2e+cEuICACL3gBBhb/QLgIMDhwNCJmDkdUNjBQo2bXm1w76gHPy9pTXfhUBztGB9CBeRa1bHRivEprRdeBtovu+JdGWdst1752YrNJDZagJOUpU7nKT2oSlqtU5SPVJnq/2OkVjKCD6VpNDGLwAQcOQFjuDuABOYiaGDiQAQ7IQAdKuEIZxmBmMZjBDGTIwhOe0INBx5IGC7SlDA6ogg8wWtEHLGAOdOABBAgAmwG4ZuFw9YfBCAYYgQFMMhvsq7m55SvlnBuGfeWsAAAgANh0QAi8MIdHAIbTj/gQWSBAwrAIrioRsIQ770G+yZG0HriDKETXoa5zpOONAB3HwApGjmizMaCeM2gWoZgw/4AdmWEZhQcY29Ethjr5SKG5UpatrO51O2m2SNLNar5HmnlgwxFviMMZxKxnMVTtajqYQAAGwIADyCAUw2iGTpABCx4wQAUdWAENIj6Drs1Slyw4gQpsuWgOaKDjHE+gBjIg8o+Hl9EfyMEHEIDNShuWLGO5il9AXRNkJNYWniZRXDSI6j9ooS1ficsdEECBETjA1a5egANgJKPBFS5EHdrVhhAggWHMQzTRS5A69jhGyyV72fn8cTnA4dlpi10cayzHOKQdbWyrjl4NQxjA4nXRcNeOoZa5aEblxY6PNoyjHX073mMq08EP3h2EF+Q/8vEOeCh+j7jNRz7wEfna6P8DNPVYzTyKEbU91MENccjDG+QwNTWsAQsamEADJlCBTbDPFbqgRjOQsYYKfCANgsDDHezgBjugIRCb/KQe9hAHPbA3qakcgyrLgAUsOIEJSngCFJ6wfDRUYQQYKFtVZHU3AUDAFsNARvue0ZRmZDCDcsFgMjN4NrngQa5ckQsFFjCHP0QBAxigdAEoIAhmNevETu+VqzzLGTyGbmgPjHUPxVxWuCSRN4TLZqEdQBEUQaHDOISDBabdtHnW2E0bB5KWG3FUPIDRkrXD5dDDZtDD3/ldwyzM2+2RHrlgRe1RPcAUDeJdPBieDV7UbVlUIFnU40HebukDvPlDSemD9oz/Qh8MAvHFwXq1wRvkwRqIARycgQYsgAQ4QANQASTIAQNwADBgQg5UwARYwB3IxRycYRqggR+IEimN0nm1QRyswRggnxrMYZ45QYAxwRM4wfJhgRmkgRkUgRDcwR/cwa2k07QggBccHPuwj1CMn2DYXPplkAbFyCW0Ra/cAQUQDgGMwB140x3gwQ0YSxj8RVdQhVpQU9tUBQYUAjXMQwGGjxBFTgIe0QJqTgM2249FoASGVgWGwxpdkQZKG7YF2QdyVD20Fi3ijmV4zz303dvFy7xIo8NAjxGZixG1g+lso8N0o0V9YxFSVAyOIzwI0j7sg5OgQz20wzxEQ9QEgh3Q/wEcrAETrhcduAEWWIECKEADOMADNEAFqMADaMAKPICxOEAKAMYmGMIcpEEaQEFUoZcb+BQaoEEZoMEVnAGeLYGZLYFHtpIOxNIRHEEVfAEaPIFDZsEdGII3KRhWgEDPNWLsNeL6DMMlKoskhtojcFpgwEWDnVAEEEBhUQAGwIAt/AEQwIAE+IWryIrhOIuNdMgdAIIhHMIufIM9JF49RIY8jBs9kcstKls6eAOzgR0EQpsGetaORdvYDWMWkU7BQNE0ysviwcMIKlTlmGDu0MM9cGOO/WW/SONGoUuNEaa54Fg3+qU7fGNdwgNutYsLvmBFvcM+UCY/oMM5NIYuvP9BH+hBHcBBe7EBHOgBHZRmFuxAAzAAAzzAGDrABESABPAN0sUAgz0CHmRBUcGBbvqUQ4JBGoABFkABFKwSK4mBR7qSLCWBEtyZSVakGTxBn7WBGwjCJTBk+0mTKjTD+sQeMFxCHiTBB0zABPAja5rAHVyCJNZcBsHCYMSFMsFAitAfBkQABVAArQmBDVyAXBjYgV2Fq3hFFzwCI0ACIyhCJbziPegDPozPLNYiWGaOjS0RQFXbWqYlL3YWj4kdF8Gl6Lid232bXdbOCCLgXtpDOrDDidrRHOFTSIGUi77L6SwMNfpdcXEUO+hlRBmRGF3eO/zDR2lDNjxDIrwB8cH/ARq0QUXq5h7sASNcQhqIpwUMS5RagAcUSwTcVYk1WBiAAUo65G+CARhUQRpUgRkg1XsR5xWMQR82wfM1ARn0GRu4QZ+V5pIaAiMwC0vu5MFJQ+w9ggUMAAAMwADczQAYHTYVwAMcwU4m1iTKhc0dJWKY3x1cQAeIAB6cnzGVxYEZTqntpCQ0giIswiHwgjvhlrEx1DUapo3hUzdMKNoBI1pa6NlBYDi86qyiHdj5U7+8oOyI2xd5zwnSA7/METd0Q7Fq1l/ukwfGnba1Tt8JUt+xQz0kKD1YjMWUIDMKIbPdjC/4TxvUAZIaqW7WgWdegvqFARCYAAYQJQaUwAvM/x9O8uQjeIEWaMEcgBM41au9NqQZNEEZMCEamMEZOGcfksEZ+JkZVNfA7h4gIIIkbIIqZNAlbEIn9EIjAkMZsBphGarGElaruVoBrMAjTCLJ1pUt1IQhiCwePML3HWVhHFjhkNOMYJAlREIkNMIhREI70UM8rOPE4JaDKhtYruo5tOrZPVusauCsIi1AXeDR3qquvgsfzc4XhRGwPlQ5kINoPRvoVBE6SNu2VVFqyegxysuM9t076FY9LF48xFFFjUtonIM3bIM0TIIaIGkcsgEbuJcc5MEg5KT5hcVN6lWMhFqD0cgOiY2vYYAJNCSXroAFWIAGnIAtzYAN2IAs7f9AE5yB3n6rHyDCIkhCKcwCMNxCMrEnMqzPKlQANnmsxnasx36sqxlAFaBfMrnP7Q4DMOAuo+ru7gLDrWQf4RhWYwUoMGwCJdxsIwyCKWDDN7RDRk3MHwUtYa4qWX4drYYDOGwv9wqj027ts5UDMP7Y57ioMtYOiYpRW7rq2Wmt+2YttpnDBr6Ornbt2S5XINHlavURSU3MPSyeN2CDMbzBGLTXGtwt6Z1BHFxSHxzczVGTY1VYjPQkf/JQ9rnagUUBDFiAAhhAARSAASSABxfAPhqAAjzACpyBbuYBHxACI4guLZgEMHzfTGIDLFSAoMJu7O7wxh6qsOyB9yHD7rr/z8ylH03s7vfVkKZWGjYlGFgcbyRMAqgOwiAYw+NAr/TiA/Uqmzd08VjS0S62by9m4PeK1gWK7xqNjv32kdRaLT2AUfc0o/9OWxpvFhi3ajfkiz4x0TS6kVw2DD+hLb1A3kYVV0dZzGQ4CTdggyeIARyeFx1UVRwcqRuMEi1ExeGi4uD4p67wn62cRQdR01mcCt8UwACMsAI4wAd/sAcnAEDuABw07CJAwiawp0n0QjAcnFBQwzBUgAIkgAiz8ip/MAEIqqCa8qAKACsrgA2UAvg9MzS7j+8mk83hQQAOLxM7MQapAiZEgiIUAh+8gbZ0T5KIRo6SizqkA9XiE7Nh/+9ZMq0FZhE5WCAwWmAvxp27eJTDPIyvUm233A6Odg8dL203FLSxckOxzhETTdGR+XE/uR0gB4wKvkO8xIPicZT+fps8JDI+rIMz9MES+BQcppdulsETuEEg6IEigN9RlkVaAMCslMgH+UWphQgEl9OpjLAHG8CxrLIAJAABCAsJaEAFDBUc7IHDlgJ72kIv7C77RMUbNAAwi7AB7PQIf/AxY/X2FQA2KcACVIAhAEPszRxZ424GWVj2TUulJdimAYMqUALOEgIf+M8vYOU5TAZukaARpfM6r+gDUmjT0nNApQ49X6A8Z9Fn8XFGuwvdUW3uyLE9MO04GHRBIzRCU/+20d4qGy0R60B0Hwsm2hIy2vZWaPBDPGTDK+SAD/SUSE+kG5CeG9CBHgQCLwgxOhkWBBDWD8wfOEmTYmWqf1JThCwAMP9yCC8AXhTAgRkAbO7jLy8AP7qmBTzcDqCBHQSCItAyIlRhAiB3CFt1Va/yAAzz9rHcKfcjGsCC79LESgzxESODMe0QVQzvpXHIH2RQKcD1IYgS1SSCNGTDOrRG5en1LPJ1tyhRWb5zBQa2YCfMLxY2BqbWBiq23NVluM2ONW40QNNDYVsgZVv2ZVO207oq6cwRBtbvH5ttw1j0Deadw8hgk/wDPUhDH/DADvCU3qbXRIrBGsS2HegBJMz/MDAwpP9FAa15E06a3yPcwY3QylacWFWE8FQDM3EbywJUBQVcgAEMAFVXdZdTuQh38AEMZAccJHEDs5RX9VUP8zC72imbMO0BAhIfsVjXxIPJ93zfDTbZty3AwiVMseiNnixggzfc1moQeD/PjtcpuNN2OAbSszVEujWEwzBiaGi5nbftkQhi+DwxI0BHuocb9DVcQxldAzcsD2Zn9mTPkapjEYr3C+zQZf66OP/Cg5PAwzwIAw/owAzsLU+5QRpMpHyRQRqUpiBEbDINQ4P1XOB08m970w9gACjTyIENs5oTgAEQgHJXRQhQwDAnQAGAOzGH91V7cAN0AN9Y+ZSj/7maszmbb98p7+PAfcHJtvf3sXdi4YGCISKmSQivXMIlfPMngd5O8UAfJEM12PpqjOOLvhGrG/SCP/gFFrakVzyla+D2FkwbZbqSUW25yLEJ3k7FjzrJkzrzjPryjLqIwyplI60EvjrDVDRxFVcMOok9bIMj5MAMnEDCohIbOKQbPMGbmgGwO+QM14RcnE1XRKKn9WRXjABWrOuzyIq1K3ciHpgDUMBYhDcI+3TLcbWrCYABSMAVpjtyE/eZTzXXuztXbzUIG0AALEAPqILuCjENC3F8v6RayAoGd1AU2CkhBALB71S+5YAnYIM61IY/MLyLOnzRGnSjdzjFS3o4gP96WmY8OYyWSn1Ux88O5TxUyNtDxRd0yTOP8iwP8qS8yqf6s4342W2WQ4OgvMQguzjJPBwDD+DSByTsGawBGngpoEnfH36izX2fMrUF4U5wjED7D0B9BA0vmyMYgiHA/cmKVYt9ecM7YRVqAKCeFRZLsaA9ck/52rO5oep5oRoACaDBJuAu+MXeMGwCk6/NIVbFWq/FDwgCI/gewaPSGtAAQOQQQ0ybPn/+4MGrVy8hO4cPHZYbd85bN24Xu10bt5FjOI8frYW0Fs4aOHEnxYFTeXKjOXTo3Ll751Bdu3U3b8qTR4+ePXs8fdIjGbJbxmtHqyVVqm2ptqNHi0bt1jH/3EaJ5cqhw5oV5kuY7/LFTJhQHTt+/raNyiHjxAYzZ+CiQWMmzRMsR8qQcQOmEzBkyIYBezR48J9OhxEn7vSoy48fIBwQkCygQOXKkjFLRkCBAgIECQoYqGxAQADTp00DUA1ggAMFCiREiOCA9gLbthPkNrDbcm/UqFUHOMBhEbBhyJo1Y4bMVqc/z7tEdwwCgQABEED8EMTIj5w8edaoWWNmho4cjqSt8/dvYfux8CCek+itotRuVTmO8zhyv0iSK1NSySRxWoopppnYaccmnHQC6p57fuJJHo+k0sYpC5lqiqmjMLzGvnSikm8rq8pJJ52yzHHpJXfiyec9dUyE/+cfe7ZJRA0sepiBDDPKKOOMudJIA4w20GhjjTQYaeaZZoABZrHFnntOsb6Aae6RO37AIAIEJiPAgQWsy4wA6xDAwLPcEthNTd5G222ANweYgAQLYqttATTvRHNN0SwL8zLrAB2ggAMYqMAOYJKj5hlsmLQlSjyi/OMHCAhAAIIf/thjj+/ykOONONpgYow1+njmm3vY46kd+Nhh1SGtstKGPm8wKuqcjT7Srz//8AtQQJXG+UpYhxQMyief7ukpKKAoLOopDjNMCkOnnrLQvnNsFRErEk1URx2uVgSrHofgaadbf+YRpo8ycFyBjDN6lAuNIIssY401yAgEGWqa6f/Flkf+YKyLP6JTzJYmm+wEjxFmW0A0yu4sgACJCxBgTAIi6AzNjXdLc08D3qzMghU6uEACCey8DTc9PbZszN7GDHQAAxQwYAIrbEkOG2wA68QQgJ8jDI9JCYBgYDo2lUMOUON4wwcx2njjk23s+Ucfb+nRx9WHYEVn1oq4kUpXj6jiFdcAfRUnq5jQeecdd2hSh6e5gTrWbnuafRYppfiWVqlurHW2m3MIP8dErTYi3MQTwSW3Hn3YSUfBbu35ZhI1xmBCBxnI6LHHH80gYw147xU9lmeeCaaUR/DoAoSBowv4sEcOM+QSZDrxQssIHB4tzdD4FLSABULg/c7XFNj/WHk0Q1OgARZsQGFOCyag7csF7HxNeTZ7+zNQ4GleAZZFGb1lE0EMkUQVVZozxJA/vKBghD8EoUMPOeigw4022FjDBx/OsIY8FGMe/rhHO2oCI2+d6CGEY8fX6BM2qUDFIhbhxlH4M5SSmERAagPXgeBTE3o0aG7LsseDIKQfo+itb32bFuACF6LCiWgjgzOcibDykofAAyHeUgfh1jGPZPThDWPQwRGx4LkemcEManCieNhwBjE4whjLscUlXBedgUWpMSAAAQYooAVbGCIGGDCZw0TjMT2lMQEUeIHxVIYblW0sTwtgQRWKYAMbdGAD1EOZ9VKWm5Vxr3uTsY6g/9RUgAc0ohnYoAYygEELWBwHML2ARSk6cQlA4MEQm+pU/vb3hjeIwQdYiNokqDGPdbSDHurghuQU2EDDUeRr9jFKUS5yEQyCJCQmIUcHx1GOFKHDJe8IId3uZqwTpnA/ertGC/k2Lb1NZRy2zI8NF5dDrzhEH/VAYDoMt45veEINb2iCeXSAhS98oUc7IsMTR/cWMQwiGMkZhnOyo0XXeREC/ZQNBgIWgxB4gAKuUcDwEmAb5L2GNiF4o/UaENGUxdE2EZ0AIOyQBTyugAR9pN4EQFo961FUN4nsU8wKELLKBGAAB3jDMHbmyGdQgxqObAYygkGLVWwCEoXgw3fk4P8GOoBKlGIQQxPIIMpdfENW6cjJOrq1OMWBs3C4nOBTcnnBp/BngxwU0EbI4ZIUwY0dciuh3ZQVIZ/gyhrObGG0pPksalpTP9XEZjq0iY6HPI4e5lKHPL4hjT6IYQ3n3BwWsJCFJJYhC2UYgxp2BIYswCUPtGBSkx7xui7yEwT99CwGtCCpEnjAAgZVACAdENHTUiACL3ijbBzwANSi1jbWe8AKNmEINLgBDTaYwQk6aoGPTuBks5ntynTTvUOmFE7BGQAHPqGkmMZUGswIRi1WEYpGBKIPQHVDHJomyv81gbBqKJUqvZEOeqzDG1CFkYmmSlVsXYRwUXmWLp8lEv3/dhUcVSEHOYjpEpqwsm4/MTCERtgTtrrVhRmSpoWuYY252gdX4ciWiYLJFYjoo5XrkMc6sqELJ5LhnDlQgROqUAXElgEM7BxDZMGABbo8wkmFiQ52OuvFzmLHM9j5gxZSYIIOTKABtJHNkSUwgQdY4AIY+EEMOEOBJIP0ZCdzwGyMG9sJaMAOsNhEHewAByT0gAYsIAEfPSpcKl85y3MsaWUGILM4r4alDOiDL2ha051VNxi88DIjCuEHPeTBDW6AgyhFeUQfPJEHpsAGVNubDm/Iw6lSveEMLdiN+lDrKLnM7357KaCqiCOsAY7bWc+6LJ4smIXQlFaHINxW/WCa/5rNUhw6MqzDvY7rHOvQBjX6wAM1PIEJa1EBE1KsYsY29sVZ0KgNgiCEF4yAtRHop46xTR3PWAc7P9BCDF6Agg0QNwIXMDcGPIDmM3tAC1nCAAaEG28/VrnKINWACiBhC1gEAhB7AEMVguBbjp4ZzWqWgJRj0+bbJDfOpbFOaujcUg5oYl/PkAbqcMqLVWACEp0c9P7C+4Y1yEAHT1ODUd+QjGzMI73qSG+l4XtpbOHSQ1HBUEY8/ZSP/Ie/4NjISUptjlbBQ730eByHgdLNehyLHuUIB1Sq9ZQWPmtaMdT0rGZI3xmywysvSdE5HsQP9njjG7vggVGx0AS1NwEKiP81AxZUTBc27MgG5+bntXGs435yqUueqZT8RitcCZgsAsLdwAbmdPgLSDvKH61ASJUs2yxPoAJLgAT7EKGHOpihBzuYAUcPf3gNPF7JIqXNa2i2gOQlt08PNw2gBAAnQvHAEsNAXXKCMYtTcCISiygEIToVB6WFF1T3upcTJ4GNbHjjIBAyEX0Wl46s1iqX9uEGW0Etkgj7B0AnMceBjJk1fuyDH0hfj9gN8iD91DwjnH6mUpwJ4ZtH5WvT58bWuY6Ow70E7Kj6Bze2gRoSgQeUYO2awC7aDrGSTcbYwAyegARoA+/wrlL4DvY0o1IcDgFG4AVa4AQ0gAREoAM64AT/ToAGdsAGWAC4OkALbuDd+EgDYFDeKoD0TgakPsAPMIF9NiEQ9oAOJCuPaOAERpAEPmADNMACKoBOkuwBIkqisidNkgv2pDD2ZqYAGmAJNgE5hoEXdI8SGmERECEQOmX42KAM+cf4nkgNfGEbuKEfDMgeFigdtmEbvOEc7E8qaqUo8mNXtE/nPgIlfMklDKRc4GEfDFEffOL8xK4e2Its7MpZpK5vqM79KIgbZsX+8O8lTAQiHmQ9uCEbiIEHCJAJmOAJTPEJoCAVVVHFdqTtbKAzLmYy+I4CeyzvOqs0AkAAygQFWuDzVsAGaIAGesAHmAALJAsYUWAOgMwEUGAF/05ABT7gA0SwA2KQyS7AAjRABxjBEkSBFmzB9+xAf9AACpiABmYgGJ3xBKLx8LBxuELKylILe/LkYabwkAJgUA5AA/ZAFGxhFUpBFCyhEQohEPigaYxvDdjASIwPLspADXIgEaLhG+QBhdJrDi2EVuwwD6NCI3eOD7OPbE4CQP4LJmSiLN4hHlpkIdYDH/CBHyInGvDjEaHl/aphQybRmYqi/qYP/8qBltLBIdKhE/WBG6hhEmQgCZSAFE+xFFGx7aCgCt6ODKAgC4ogBTDAs7Ay2xxjK7UIBAggFxGgtXCABo6oGKsADciADOJAf+ggDfLoDuYAB27gBoDRF1fgLv/vErhIALhWoA4igRJEARaAYRMWIRDCkQ7awAyQYDE7Lxh9kQQgswM+AAaPUPDg0bhwQzREI2YChaUOwHk4YAnYgBAYAdB4sA485SBVUw08Rw1E8RXmcJnoY1roo3AkyFYybSM7MiQ0CNQ84lcGRBwEEUFaJR/iwW3W4x/wQa+m4RfyI5gy4qqc6RqsZSbp7xIxcYYIB+sMB4XooRqOQQxUYAmUoDxPkdhKEbHU00cSqwqEIAq48jF+QJ/okz69smhAIAqy4AnGoAzgQA/gwA4KARH2QA8AQRD2wA2KAA8AAQyEQKOQQAl2oPP06IiAEQaCkQkQIRIigRNWwV96jwf/NQ8O0AAL5gILoOAJiqAxPU8HzgALPi8y+UjeqsxOcqMyYC8XQ0YBGIABDqABPgAN9sAOCq1/7qUMw8OJ4MWxxkAM1qIPmAEb5uFBZvMiow+CZqXqbOmWjCL7em4liikeaEIejPM4xa4f8OEcqoEYXqHCgmXmNlKrJlH+rM7+sko7CccSZaUOg/JBtgEbPoEDVKA8y5Mp0bMpUxQK0OBF6cIL4JMrtWg+57M+9Qkrf6AIzKAUekFEC2ETOOEQ/IAQDtQOzAAQGGEOwCBIwGBRYyzFiA0JgqAIggAJ6oARIIESNEEVbgEYSqERFAERBE3z2gCU2gAMzECxssAMmIAO/wyBEeAgR2aABaSH4ETwGulkpKLQ9XS0ABKApQTlAU4gCMwAvIwUDVmzDIyKvGRABnJgFKTUHvyBIi4S+hYHS72h6rTBlqDOS0PNq1RiOIXur+ohHgxR7JTzHJRBF0xhQPprWyRiD9tKb+iUWnDJTi3WDmfz5R7kO5dBDTjgA4iRFJUSPQ3VFN0uscBAC7TgUekTUik1OqgDAiigCNBgE5ph3xhhfURBFTgBEQyhEACBDgThEvAgf+igDuoADuDADegFDcDgaVe1EGwVV1WBFoChFyQBEsAwEHhQU4Y0HAut0NrgDArhElTBEJT1CSg0WlmABVZAekpGCVHmTvgkOP9+4zTgpAE2oAnOoAwX9V7gYgya1KjEgAM4QAbewBiyAV6x5SKj4vnsFYLyFRKhgl9FAjhXIqzYRq/g4SQJVuzwAR6g4RdMwRRI7Zeq4irqiq0oF4ao0/0sETu1Ljs1ran6dB6w4RUMVwNEtndJ9jyf4AquIHRQ1gu20mUb42Vj5wc8IwJYgAnYQBQ2oRAgoRT+sRRUQRIQAREKYQ8EoRMEAQ+81mvtoA6OVmmF6mgZoREgIRIw4RRWYVdhQRIWoREYAVj9ABD0V1PsIBx70A6q1xYkoQ7aoFjNAI+CoAd6wAZqoAXgto/q5EvSZDUo2G5NI2QaIBt/ZFHh4gwwR3D/jcpw2dUTpPQeJKgO7bAbIDdys3SCosIjecVXOmgkiQn8UDIe/uEd5MEbiGEURuET/qsjUxcrUoQcCOTp5GpasopWYpeJ7xRPfZIdDGgevsER1vUDClWBe5cUe2CLn4C8kIou2k0rs62MvWg+uYQyGoADkqAN8gARLIESMEETMAETFEEPeBAQcmsP/AAO6iAO/HhplbaAl9YN9qB+G+EvMSEUYMEWeoEwwbAQBtIPCvQw88cO9iAOCkEwISEOoujtVHQHRNnzOGpGr1WCNZMecRH2hAd4GEADaAANQEn4OOU7Fs2NE+EZplRuasIfHELmaO02tSoqxqY39+s3gRPo//7LHOJh/ApW7FqFHqJBF15hFGQhiDsyP/4rJWroKSARwrDqImRX66DYcPTKHyqHGd7gin0gKbV4i9MTsdISLhBSqNLg27BtK81YxxzDdRDgThpgBvgnDwjhEjhBEzghFEQBEvygDvYAEC7hEvYgEPRAU/Sgf8GsfDPaDgKBERCZQzGhFGChF1RBa8GQEArhZ0X0opEGkwvBLwpB80BJSN4OC9R2Bxz4zM6MThpGoVRZCuGkNwygUGjADOAAvGj5p4TtDPKgD17hG1QJgdjBHfSKHWapqmwIq29zKnKlmPsDmUVymQXRHfYhHtyBH/JBH66GGtj0FV6BGGIym7c5JP8rjIJmMpwtlpwLJ/906B7mYRtMIQc2hwP+hwn+J2RFVu3e5QyYqAxpWQ/oQBkf44yPNzuOd1Ij1QvSoGwzr6Ih4aAxgRNEQRL8oLT9IN8Gko/5gA8o+aIrmpI1RWoVoX7bN7TXh6c8mnsHVJJ/LxAoOVjjQBEkAY8t+jDbYH/mIpRnIFo56ghNrwFQr2KAGk4oA3icZwJOoAfSl1OeZgy+ow+OYR6W7ydhgh3GBSKseq/T+1a2pcLww4hRgkCsIkXM4b/Cir75j0XK2h3qIVm04RheQRZeQRiowRGLeRzmmiV0pRK5wULy2k6hWEUixx7mAdh4QAdUgLARmylLUe3/kggN1mBeCs07Krqi9RcP5iAKokA65BNSMfvHBGETbEGABW0PEEES6BgTLMESCIEH/QARvCwQCKHHuZZr+820/SAQZHsR6pdDJQETIgESJEESZvt+t5e3JZnIk/ynuBa2+RdpZ/rtimAH8ui3giuk4vF34AxO3sQ6fOc1DuABspEMjjYO/kcM5IAP+oCEt0Eb7g8d4uEctkaWZIlwtqK9OcK+7dsRFV2sV8Qd8gEdxAEl4aHXtMEZXsEVXOEXlmEeYtIiqmLngjMl+qPTckmJxdlO7fUczCErTISKfUEMlmAFDNcHDJC8jqoJsKBz0MAMt5u1TTsQ0GcwfoYxpuOy/zEbxS+hSXqBFiDBtwNhESyBji2BMEt7IDcBaw9h2w+hyH07yYVcyRnhV2e7Eb4QDBHhEjbhfkuzNK+8EA5BksMwycG9y73ca4n17cBAbWmglDWgj9ZM9dS8zWHvzUeDAbCbCdCSDB7rDfqgD4ghG9jwHNhBH9QLvTEevSkeIoip67purx+dJMEPQU7yHPShvaZBYV3hFZZBG+5hiPXwOeNbJXaOcl/XwacvgsT5a2SF1eWDIv7aEZZgB2g9A9J17dK1c34kIcPWfiY63Ld3ESAhogdjMVoW2efgEY6jF7heFbhjDwihEeRYEzShEUobpRuhkbPW3L9QEbJcyH9Pav/lncndPslJcxPWHRFsFRIgwaMVQREOgRCunHvDvcjpHdz5V38KTVV7wBkj0zJtNHi+pzeCOjQcQANWAAtGxTvkwBGegQ4Jp6/uoSHI5T1IHyIUgiHexm1Y33PHYmDzIfZj/4ZRsh7ACRq4YVzuoRp+wRNMgRWKoRr8gR/Cpr4sKMPG4XRluFmyCtVzvol5XhtY3RwMZxvmgRgwZwdoQAWM/ujFQHCTaIPbQGnhIH/4+EB/T+8ZQRI2Qe37YjEG4xLeRxDCV38NAVGQwRd44RYsqTAD4RAAQlEjSpEO+fETCBEiSbZUcZIECVIkSI0WLVKkUOGiQhwJBVoECdGehJf/NkmyyCiipIkVEXHs6LJjoJkzCRECFGjPHjt0dBoyZIcJjaEsSHS4ICGpBAcLFiQwUKCAgKkCBhQYMCCAVqsFDHit8EEMnDp63rySlo4dN3ps2bl7BzeuXLns4NWrFy9e3Lx887L7C+8dX375ChfWpy/dNGLHzrFTR8zTJ1DBqMnjh4/buHOcu3E7p/lcOHLkypEThxr1uNXdWrv21u3aNW60tXHzBjv3Ody4OZtjl27bNk9i0ARZwSGDmOVimow5c4bMGTRr2LSBE6cO2ZGCBBliBF7SJVGwgA0DhgwZMFu2Nj1ShR5Zs/nYmiEL1qsXMGClGB36n0hFgfhByH+L/zQiiSqlqKKKJpRIAhFEFmHkkkd5+LFJL7bosUch4IG3SEqQrAShJIwgspFHgXh4oiGF2EQIR90B4odOgBhSkiFn9LBDDzawgEIHG1hgQVIOMJXAU1hRRZVWU3FlAFYHPKACF3Dk0ccx2aTDTTrqcIYOOu6MGSZcb8XlDjxqBvYOm3vx9c5d9eTDT52G5fNPnvpUMw00v0Cj2C+eeFILM9/Yg9k44owTTjirkUbOOeJwY41m4FyK6aWOMuqoa7HJ5pln4XQzTjflnDMOPGzdw45j8zzTxxhfZPHEEjw0wdwYz53x3Bq+XhcHdnXYKMiLhaAIiSWl0GLeMOk562wzz/9MOx8yw/RCyyqliLLJJhE1Am4jjjiiiCKHDDLIIQJhwokmjZirELgRpVhITnbowQYkwEjSxBp65NQhJIyECJ5KEAqs0IuEJFxhIIQIMpNOethBCCOb9EcGEzroMMMKJww5QchLMaWAV1AtySQBUa1sgAIuN+BABTSgkYcr28wzjz95/qNznT7vw5c7/PgDT11q1qMPPvkg1tedgsVjmM/85OnPPdAoAw0xujBGzCijCLNMNPN4cw+kpZVjjjmT0kbbNeFcmpo4mC7a6GqNjuoaZ3WvVk4548SjjzzyrMNOO9+8okYZYGQBxRJJ6Ar5GGRMfoava7QRhxza5cEhQvX/FiJQJJaEokovwzibnrTPSPNMtcHUQgonmBAUUe2RUKJJKKesAssqomASSfCUyC7JuwbxMWAghxyIyMKFxIHGGEkYoYIOSqBBFoeBfPihwRBeUny5/3V0bCEQD1ijHoRsYsu+z2HBRA8zzPAxkUQaSXLJJ6e8clReJdmUBTwgAzLogzFuZg+d+UNneZoaYdyxD37oJR52QYw++qGnf+SjaUuz4AL94cA6weMf+piGMo4BjVd44hW6kIUndvELYiijGjhLW99uiLa0mYMc5igHOsCRGkjFbVGrYRQ5+IbDMIXpL+gAnDrkwaV1SCMRxUEDFpzgBCOIIXLL0RV0fhWH/zBmR3uFMMTCGmEJUagCFrSYhelQl7pmMMMYvZiFKULRLkxY4mAl0gQnSrGKWdyCF73gxS1m0YpVnEIVotCEJSJhvP8MAnkg2YhLcgK9NjShCWVoQx3soJ09VEw84CtRSbq1kkhc5BD1msmJ6nWQPegBEZuwViHcAAczmCELRdhBx0iwASHdb2QOaMACSnYVrvSvK/9LQFMa0IABvgEX1PgGzujRjn4scGj8gMdb8hJBDS4NcPwAWjnBuQ8L6sMe9riHO0HoQHbUgxvQEIYn+jCoX4zCEV/ThSeIsY52KjFMN9ShDtGxQ9KYA6E7TBs6ShMmgxIUhzdUImHqAQ9uVP8jG79Qgxra0AYsXGEJRtgkc7ooOelUJ4yY286KFMIISZQCFrbIzy1uoZ9gDCMY+LlFtkIxO0pgQo8lglC3FrQKWuA0P0z1aSxoAYtTABWSBzLXIPzwL0WcSBEvsshLVDQTrOrBcyA52LcaMaJIYEITqjyXTY7lIvQFAhLI6IUe9ACHNrghDWZ4Qg9owIITrMAoQ1JKyI50TJNBpX+KBWBTGPCAB3BADZ8oxjaqcVlvrEMdC4RaPtzRRKDlJR/w6CCcRouYftiDHux8Z57oVI9x9EkXiUgEC4khC0ds7RivOAar/qGmvwhXuBEdE2iN+xfQJte4zG1umJr7F3iioxr/1aCGI9TgqzJg4YpO2OQTvvsELJChi1+0zuVceiytSuJibPypGktxikY2khL0hUiyMLEJTFzilKJYEBvzgx9fFJIXufDpLWKhSE4QBJIVOYRHDuKhiAxMERapMHgqUq6LUAgRFA7XgSKhCQZxIhSWANciYpKwFRFCEYG4lxvcwBM3LO4JvrTBLzcwJCKFbALFbEqSvLJMAyRpyAkowAEOAFnJ9iERv5AGNr6xjXX8wxzxEC1c9CEnpC0wcO3oMlvY2Y8wL7CBPgOcNa52jBcSQxjCeMUvlJENelSDHf+o012Kxo656PlMc/nLnvUMl7wE+i7w1Gg2iOHRNWhXu931/+4TmABek6r0civNw0jSm5KSrBEWCsYEfFWhSAaJuhQLssUt2GMLWKh600vVKU99AWteGNKprTiF7ITK4EY07xAr8hAp91tKs14EJSACT4eTFeJScIITUGWrwE6cEY7k5F+gjINO6LDXvvagCD76pZBwrGMeI9YpTwEyM4e8AKwM4ADrZgADDpCBPuhCGtlYhzz04Y5zCC0eSEOaB93ZZXU8sR2CY+DO6oxwf6gja4xxhjB+EYxRvEJs9tBHnuJxTkHDRU1KHNM7PI5no2EUHnwpTF9O/hY8BxeE+9CoNDzBA+yeQaRKUEITIM2EnOtc500gQxkqVwY0eJJDC9MqJP8utsZUlyKNvFO1LaDqdPboBxgaerqqldoLnZ7udMJ4tS9knYtaxKLWodDEWoEXvEb8BxEOHoQiJGGJbsl92ZyQ+x5LNKJN9FcUsjP7UEltiUXU4SMD00iKaoRVOAACENeWsS552e3BnoAEwATZBCQQAcQOebH+SxIAtBKAqKxbShkwizO+sY52cOYu6sizoKGG5cD8pR3wkAc8LHhwi/vDHuuIBjF+oYtfsNkXpqjFMW5Gj3tscx/7uNMG7xyXOW1wTSLXh10KI7U6Md/5iLmLB/nxDm5oIxlvEIMapCOGLNp85zvvQQ98sEnxniHoa3BDHP5lrEWsV42w2IQlENH/CHw3VBAyEbdjCZbQdKsAaqvAO7SQdVs3DMXAdTzldbJ2U7TQRopUCmWnR3sUPLmWLHonO0MVPEV1SvllCfQlPEJFCQe4CIpGBmuwB4gAHihyYoWAEDrRHYLAeNj2YmmQBVUQBDbGAjPAAh5jFMOEeUzhFJynWADweVohFQUQAOoGWTzgCcmADfOwDenAFrTXJkbTDoUjcOrQZfLQDmyxKu7EWvYwD4sBfKOwC8KwC6xgCrxADNTwZNlQb/aAfdnHM1VzD4jRQfDQZe3gb/62TR1kcoDTffrgTvfATuwET/4wD6/AAzrgK9FxBVfQBFjwXfHjfu6nc08Qfz53Bmzg/wbb4TnqVRLccgkjMlMi1oFCxQmkcAqt8FRKdVOzQAu5wAs8NQzCMAxrJgywhoxflwvLeAu1gIHOOAtjx4CqQAoCuGDhYoCzk3YeJhHgwmCi8yCYAAl+IAZLkFJnEAd+gAiQQDBcFSOGoBM7QQfYhgZmAIp/1TEnoI+EZQEh04/ihiSbx1jNFEBH4gCRVQEZkAE84AjFkA3WNA9u6IY4Q5EVWZHCgQ3YQA3UIA3RcDXK8Auv8AquwAq4EAu8cAq8UAmJMC7jwpIUhxhSQzVsWHH9gFGHmGXqdBj6sEF50W/10Frs9GXbZA/UkAg5oANnYAbRUQaeCIqPJoo8snNKkP9z8Rd0mHMve0AgKBJTwKZpUodqGNheT3VTTDVgvOALWleMwmCMx4iMBBZ2txB2tXBTzYiBbdQ7CkgKeORIKhg8evQg2/iBHwguLSgJipAHYgB/z0E5bFAHfjAwIXIRLpKDshRjbtAG9hh5RjhYwmQ/IjNu5OaEJkNkTWGQERAyD1ABMjAI85YNGkkN0eAMy3AMa6YLIombg+KStdUHvdmbiTAJLpkJpJALSQUKb5AHb6CceZAHg+AJ1DAP9MAN7CCTkLhaNTlyazJyd0ZyfIFl3rdOkyiUarhA9zAPxCAGG2MGk+NzTXAFV8QESmAE8bMDO5BzPcAERqCfVBleQcf/BmPxSSMRI5LZlZuQdEy1H8DAU2aZH7Ima8gYDGxmjG3ZdbC2C7mAC7gwl3TZjBzqjG1EC7EgjYoUCplQCSdKXym6Egs2mMGjCH6wBmIwOabInpTTBnZgCCcWIpc0IBKjHTFmRTSmAzZgYx7zMTiWYyGTeQaZWIpFmgngMgpgmkeypKrJAWKwZH2ALr7Zm8rppW/QpV/qm7XlCIMyKJmAgalwC44ApnnABxdyCIkwCLJADcqgDXOmD3VCQqvFFv22Jn/6p3n2NN8pJ182ifQgOPBQNfOQDTCnAypQBuyJBU3gBFDgBPE5nzzSIzzSA/qpn5DWc2VwOXAgLGPlMC6S/6MFSmpJtVQKyqANCoxpGaFsRqu1SowVSmAZuqG1wKu96qu8epfRWGunQAqg0JcLNjspmHbnkpxxwAZrEB0953PQmoqp+BHlMjA20aOyNDFAagZQwARFEAS+9EuUx4+XlxRLekxPoT+KFaVSOqWmqZoZUD1LsAZ8cBB8oK9rIAfM6QjFOgqfEAuo0AqogAqmMAqTgE+SMQqgwAqtkAlpGZy1dQgctgiOEJy1kAjQQF3sQCckpA/YhIjdJyeACqjgmWVqok7ZuaiwwgMy8AFkMKmbRKlYlJ9GUJ+jmLOeOp9PAAVY8HPVMaoBugeM5weAUAghAgngUxL+hYF1yaCxSv+Bszqrtjp8FloLu8qrs/CrvcqMvYpI0bgKpOAgKtgIqlRbkzQIzKkHcbCJ0EE50IEG7FkHKIIiGNFKNSIx3ooF9thLNJCPSOiZE1Ak+NMULuOkT+oyAbQAMOOPGjBAMpAE/MqcyAmmmbBTPFULvrCMs8ALrDAIS+YJruAJpuAK49IKrFAJwdmSrTsuOfCc1XANIyRB9TCGrqcXJXs0JquyJLud3fen/2AP36ALPJADMsABY+CJ4GWz8lmf8xmVneqpOfez7/lzPid0pPpJY2EH3HEsXDki+NVfoHaXNwWMaDm1Vmu1r5ahtTAL7wu/XcurzFiXh+RTtNAKyjZUjxT/CeaiCImgLpOUB3UQRmfQBjBYBgl8Bs2xSWjwETT4Sg82EjpxmWjAV/cIuPMjuDlWWPjDhD9mbv7TMu8KpVJ6JArgbpGbBF+knH2ACrfgC725C7jQCqaACpOQA33gCGTqCZOQCLFwYKiwuhMbp3JKCH4gAzmgC9OgDTG5ccn1cXORJiE3XB57cm9iJmMivNhwlDmQHFeAReDFBEeAqdOLnzfLs5AGXlDQc0zgnj83HW0gdNcRSoyHtMcCEiqBCWrUgDcla1mnU7XKUxJKDMM4jL6wC4YEtvHbtcvoyMuYtQWGSFJldikYLpL0H4Hwpgf8YvW4ntKxSTYnqntAYRbR/zAEEgiMJ48+yFd+5UsZPFiE5Znpqq5NyHkskyRVqExdoW5GNiUZsAIzYH5qMAhlyk+4IAsI2wdqoMOJoAZvgLFvAAq8EAtSZQlWFbq9yQfZoQIZoAbEkA3e4A/4phfG9Vxo4g51IVxwIVzMlcWBIXtLZJ7HoAYv+8VhDJVkXHOeWp87wLP72SM5V3Nu/Lw6dwVl4ASe2ElwQAd20L2L5x0agVbiC2qq1mpTS4G0SgzGOIzBEGtfy8j1u4xgh6Huu4wYOHbx1Zfhkgj/ey76mgdykFduwAbR8V1k4AM6AH+btAZ1W2E8ahOLR8EOPY8XLIrkKriElWO0/MFPsUzMBP96US3VW4EVDUBAPqAGikAKnzAKJIkKoSAKkeB2izAIPqAJm9AI1DgJ74IRgbC2vZmc2kGvOeAI2RCRdYYP+OAzZJZ9Q/NBkWhwgVieVUPYi7oNo6AGbOAESrADnUizPusERzAEk93PlD3Zk30EVnAEmz0FnT0FTmAFXPAFXCDaX/AFaDDHpNq9OpHKO4jHMbVeF8NeOHU6yGAMW2cM6YEMxcDbvV0MxPBqYReNIyqiIvq+xd0KqcsKtdAKqdDcoQAKoMAu2lgQAmEQWvmYcGAHebUG0qEEZKAr6/kEMWjAhKCjhXfEOUjUBCzH2obUKvABGtCPG6AB8l0BInN5iIX/uOV2y046ZIu7AAZ5JBNQARqQlOtTCZmQCZQwCQymCFTFCPWyCAfhB4NAE4HAnBke03KgkDzAA6ZgTfdQZ3oqiB9k4uXpTuIZiZI4kRYZkVz4DIPwBmPgBD2yXTSLc5J92ZW9A5c9BFOg2Ufg2UBuBUBO2qVt2kGXvdzbvQgB0RxhdKQUdzOFU2qJ27wdgRHY28aIyGKX3Mm9CiL65V8u5qyACu/b3KgACgo+CYpAEIvwBumiCEfco9pRByBV02eAK+A9o2RQj9ZByiixCDQRjztxV3GQbaBYnzpgpMB0Ah9A3xZw3zsGkAHkMvzNTI313wVpkA9A4BqwAljAnG+K/68HsQYehV2J7Qdy8Ab9quHJiZyw/gYZ8AEckANq8As4o3yROJHttOK8zk4W+Q3DPuzCYezCwYfYwAyuoAZiEHQ7YAPftUnxSZU6vuM97uM/HuRDbgWaHdpHfuRfYAaorVfzSAdEixAO89q1IwmeFkhLBcgQaOVcx2YeHXZj9+XDrYvCOua6yAoLjouVAAqhAC5WdSFY5QdtsAcEHCz+ySvNAd66Mt7rOQbQWreMoFXNQ+irPTHYlgaLgwVFwAQ7QAOS5zEf0AH1bT//CJD6DcLm9qRJAq+H27gH6ekZwAEzQAbDsgfM6eHLgeqo7qWu3pvp0tLjUj0ykMTfTOzDnv/s2PCaG+mRs3kMtfkLwHebXjMorMubXRr0YvAG3e0jNgCqTVBzNZftlp3tQs7Znt3tRt7tR97tfTvueqVX2rvaOoEQMcIwZYUJobCXgBQLgkRIvSBgGF3vsCbcxs21XXtTXp7cCLYKoDAJ8QVJ6oIQfpAH9bIEZbDw1+EECUwGPbdFpR9e7JnAZRAH5k0hrQQw8RhjaZAGMgaKGjM/+fjoSApuLI+u40ZkMK+4i7u4xRRZnh4yJ/AEdLAQFasI4zIJmTAZuJgKZGm+fzxgbsAEGoDzOfAGrLCbYdrsxpsDx4u8HGD+yaGQ53/+6Z8c6m/rzZ4xNhAEMyDQSuADRpD/9vk/BJK92f3v9t0OEFasTCFI8EgVhFWwmGFoBk2bNnDg1KFDx46ePX4CbQxESJGiRY0iNYIUyZImUadWrWoVi9atXLx4+fIVzKYvXrty4eKJa6fPmDR55cp1K1YsU5UmOeKEaaQiPnr81IkTp40cPnLW6GmzxMkVMUrINGkixixZMmbEjDnTNk4gRYUUISJUN5AfQID24Llzx02aimaeMGGChAaNGTNWrDhBooPjDRs0WJhQubIDzAs0K0iQwMBn0AY6j+6sQHODzJgxa4BzyVYv2DaDDZNd23btGRoePMighkOO3cGFDydefHgF5MkfVNDRpMfzGi1oEPbhY8eO/yHZtW/ffuQIwSHeCQq0wsX8lO8GkSBJiAULFCgLz6B5yAbixIt64MTJw0djoEM2OgSRkBoRiRJMOCGFpVlmqkk2mnzZZUIKI7RQKF5aUaoSTTBZZBE/+OCDjSTGIkMNPdRYI48ynFgCrCbGKuusJhYSawwy1ijjjD0KQQSRuQgBRJC8AMHjyIrsqGiPPdCAgokerkuMMRIaI4GEyCazYMsJJIhANc06+6yA0EDzzAAF0kStgdEWaECBBzjQwzVghrETGTvz1HNPYYTRIDklkqjgAQaMI5QBRBNVVNFDF1W0gQYeSGyHGShdgYYemDDCiOt6GAI77rIDNb0pwvuOPP8uykt1PCuYeOJV+NwjjIn43BPsCTLIOMO+NtBYo4046sgDo2H36MjHj0KKhBJOQjllllpwcfBCnCK0qU9hgqGpNl5uMWUSTBrhYxA+1ljijDjE8EEJHpYQo44xxkgCrLXIEgMtfJtgi601xNCDkB99pEsQIo3EYw879GJkk0sKme/VKBFTbLETTvjgA8kk25KyyzJb4MwyQSuATM/SVGBkMk1WoAENfPBjkzrzLGZmO43ZcxhiiFkuAzrOaKDQQgddLjmiDT10N0cTTZOBBlhQbGIdZniO006DuC7U7QoqNT1VuZhCIK2nUGLWV18l+wn4nnwVi7TouwKLMh6KqKr/YPPIqKNDDvnoQExIOaWlWoKqbdtgsDW8cNpu8uUWWiZZJI881hpLhzN00GEMMYxwogwjllCiLH3HQAsLJprwIVe2zihjDXQD+ZHAuArWa49/CykFFlUkgWMNhp4oIuIZEGOs4osv7iAyLiWQAEwxQyPTAJRDU2AAlA9IE00DgvahEVrsnHlmY8I3BhnyjZlZBzEQqSODByJ9YAIVPlBhBRlmkEEGFfLX/wMO+tfg/wwEUIACrIAGBKiBDazgOgvcwaaolikmBCEIWBuVQY4wBLCxaiAZFAgXnOAeEIYwbbXKVdvQ4AY33KcOK7TD3Y6FrB8pa1mUOMkpVLGKWdyC/xe9eFDNjGE4w+WMGH26CWxmoYg39ItyPliDD+6XPxksITGX+1x1fEAWLLZFi2vgYht25QcgfWgRdLmLH5hECEjAwha2kEQc1kAGLDwBeCuYmMUwhsD/TaYClKEM80gDPZQ97zOlUZnJFmCanwWHA4rgBZ6QwQxmkI98zGjGM55BjUUwQg874EABIfWAE9BRBVFLzP1Mib/8Fe9i/etf8Tjwgf8V7wRSY+B1NtWpTPVggljLjnjCVhDyfG0gwvTgCNPmnhGGkG0MeQh9IiKROlwkIxohRCGsWQi9yTASkjiJJpy1ipfIpCZ2wtYQhXhObM2mF0U5xSHEoAIxzEAHRv9oAvs0YDkVGEEMPFBCWMgiOiV8Tldc5GJbymCfOOihEIuYCyMMwZGMKMISMYtEHuKABjPEsQg7QMxhFEO8DlxMMv/bmGU8FqYzjSxknylkITXDtEjJYBHDkCQlawZJZjxjG1NBA0dXYMAKNAAx+UtMUY1a1FPW76gTW8H8hkfLWjZwgRB8Di+148thanCDqDLPFd6mzGO+J21os5VD6PMQiUxkhcKaph/c6odBDAgkJCkJDTWhCU6A4m/QIspMflHOIQojZ+m0SS5msYpSRIIPS4hfBpr6vyfuYAw+GMMaRCeGsZROV1rkbI64yIY8ACyGirjLXRBhiWY0AxiEgFz/CtEARzkuUHjDI94dJzMZkzoANQ5A6UrNRJrSlMw0mnEAEC4xDFtsIhKwoE3NinEMbHwDDVdIghN0sBgOTKADZmjqFC33XfCG97tRpZQ8i8pRG9hABzuw3C2fM6seXBBr3rkqqcgTzPuahwteVSYIk/kespa1LWiFJlWCZWCpuDUQg4jrgAhkoJJEQsKUyAQoSIEKVrDCFbLgyS588dc+BVYYNfFFLWbRClBYghKRGIMKOPA/DoxSB0qgrBh2sAY2jAVHbEODFnN1hoICuQ1sWEMdXIcIgRXCrXqDxS0aMSw9UMQNbMBoHJ/E3tlSzGLHi8wGuHSZL/EWpaMpE3DJ/2xIzWDAC394RBD+pII1HKIVsxEGM7CxDfqwoQmWWwH70NCED8ggBzrIQfAkFjwdeNTQil6q5Z62g/ReZ70L5NRzikAYIyThalbN2ni0RiphWuEKWOzvf8MKtzKUQVdy2w/dVjgRhGHkrQDryI/maqBITKISmcgEKVKB4Q1Hy8OE05aEhlKLVpBCEyNxShtykAENzOADM+CUETAngzK4MdVoSDUbtt1jH/+qDTjeT2hfh+RqBmJccvCDNJVEhxQ2RKM9sMGhtaxKklbAMhNQjZg/RkjOlBlko3EABUCAAQh8KVKROkBvKhEMamBDGm5oYo10oIIMHHQGKqjfeNc7af8jiBe8S2XvChLN3gWGd6rPseWmOd3LgniHvqAWNRaw+ASwhvXU7slV3Jyp1gLXAQ52ILpUOkKIY4WRJLim8CcsfGFWAC4XHh42hXgSi1aMIhOfqAQmRKEJSejhxRqQXxIC3YQyLOGzEKFyM+mj6s16lotxgIO35eCRQhiCoUgXER/2QJVAMElJKDwhRn1H7/RKbHgfIJ7GkMOxLoEpTCZLgEpDVoDRGBwCCOA89BRwgAMMYAAHYAAPPDEMadghDW6AwmF2QHQacPxSNGCvDngQXisu4UVexZGQ5VAHPST9CiHHVJSi+hyW3xJUV+WlzJ0fHq0J5KtkwbkIw+qdr3j/lSw8nw9afdUGN6CBCVxwQzSZ9B8FA0hvIPmQgXTda7+xJBa1gAlRiIKLWtRCFtCiRStMQYpMoIRQKAVMgIQ3qIAVmLYmUKDViQM2OANgsQqIYDtu+zHWyRUcYwP7ICg9MAQPHKMyMiOE2QgmQRh4g7c0AIMqKIIgQL7y+ijGECkt8TLI6zfNOKTrWSmVSoAIAAEQgAACQAACEL3QG4AAOELQY4AcGAQwSIMdYAI0EARJ8IMl2DahayFqQpZMggRuQolSUAVVgAU1WqPXgA1gAAZYQAMjYALriKpKy5Rq0zTuoK/58iX0sEOtGTUnaAJXcYIncAIoeJu3cQInIIzs/9tDUus+iMAxN1CCBgCAAFCAFagCOkAYY1E3jTgEbEK6N+hENeABNegDRwCFUIi/VjjFWUhF/cs/WSiKloiFVDgFTlCFUhAFS2CEHOAA+5EBymmDVEOXYKGbIXOmcdOieFm1s2KdXbGDQmCEuViE0vIDjEC6uxA8i0BBMMiCFVzBjVI8LeuA49EAcPyyyggz3doM3yITzPNBCNg8ARAA0QsAIwQAIxw9RHmAtqgDRBAFW4CFLwTDVRBDgRxIWKAFW6AFhDRIMkxIhLwFh6wTYJCEklOBWrIcN1S+OvylU7nDrIq+KXCCj5wCJjgCJhgCYSqI6du+XJGPs4KIFXIDBf8AAJmExABwgB4AA0DwEYHRRKkYhD7oAzEwpRwQg0GghFOAhRyCjdiwiZrBifzrv1PwG1LgBEowwAf4gAy4nyW4nDpYg6rAsXHzymLUol8EMoLiojyzjzogBEYgEEZYBGv6kY0QwSijO8IzgyfJJfaqo9rqgDzSmH3rmAbYDNPwjMoTJOiBgB9sxwjYDBy8QUj5pAfYhDAUw4U8SIakBaSchYHUTDGchczMTIcMBmCwBTtgr/whr1pyICOwKjzMqoHYyF+azTsMta9JSbSAIzPwOWdSkg4IgJmUSQGwABToADsgGELgA8jxgzyAqz5QAxnon/vJxQx4A0poslvoBR3/Wko7iQleMDGsS4VVOIVQsIRIOIQcuB91EQM2iLIog5w8kAM1UAM2cMCzVJ2zPEu2G7I2qAM/cEZEYARIGCNFsAsSjDI7kLI2yKj4yMtEYyqQ+p8sIceOOSkyQ0wH8EEEaMd/S4A0ccyXisyXwEyHzMxUTEUx9EyBDMgUDU2EpL9bOMNLkLTUVE1KcyBOozlg2tHZBLU75Bry0D7qYxs4spWzQgM6qIIBCE5IjIALQAESyAKiawM7gBw50IM8eIOgFKD74QAGGL0MyAE+SKOXcMiZ0Bae0D9ZkIVWYIUTk0VJgIQ4UIF7WqGEak7+wNL4DEar0EAiu8+2+CwNZDv7/7ADAnHLtqwLAy1BPRi88GuIvOSo4PkoOwqpOyqpwLTB3voMB8AAEOA8CHAAM0sAHDSN4VoA0ExIh2SchExFhCRIWC1IVV1VhywK2NgkS1EgG7UlHHVNPKRNjXQ+54s+6UPEJlibImVJ+nCDCzhCmQTOBMAAB+gAFrCBKlg9OrhTOdBSDggg3rifBxC9ArDHByiDRuAEpCzTDIkFWTCxNc2hEyMFSqAEP+BFMdiDO3UjqYiKqIBPA6sK/vxTgtJANLAPOKBAOGhGAoGEtkQ3A61GooO3ZsqowUA5xSOextMYTO2Y5QETzlgADMAAUI0ABBhVD/3QU42FVHVVE+VMzv+MBYE80c9MVYakVYfsBU0wAiWgAVHaVV7dlByVOQsSWvQIVmAVD/IgxJtbm/dwj+5DgzBYAAE4QgEAAAKgAArwABFAASEIgztYPTtggzdYAh7w1t3onwcIvQI4AQuYHtI7gAfgAUW4HVhQ2VmYv/zLP6KIhVXQBEs4hDHQikCQA8I9BP/QiLfC0ka1U7pLK0LVwIH10wccsj1gBIdiWLi8JqRDOhEcPHhjAzMgg8FgOY+imMXrspGi0AmIANbVLdOgAAyQyasduFFVGc1ASJWlv1qgBZegBc6M2aM4Cpm1W4ZM1VW1VT/QgSTg2cUgL6qxpSRIgtasLzoU1h/1JVL/sd6hFdZTEYjSob6yOaYdOQMwCIKRecepjQCsFQEMQAEgCIM0yAIz0IFuzUVFyYBuNUIB6ADekgALWIADeFYGWAJF2IRSWIXgjQWYkJbvbIVT0IREaM67aINDgCt164i5dCvaWVyqSKuDHbKCUkazfMCBqgNDaEvLbctr0txA0AslGbxeodgrk9TFoNQtQ10tsQwviYD2cYAI+AEQIIAAWAAJKDPRAK5ColVVdVHfPVEntltV3F3QtNlbCAWyDbmNy6cbVb4GyrTopV7uFdr08I7Y3N7spcPuYBVaKRs2fpUiTQsaqLzPEIAEwFoPgN0bAIIqAIMnmIE4wV8GSMI//2aAIzQACgiAcS0ABZgAAwBOSByAB0iCRdiEgkzRXMCJXIBFTkgEwvWDvFGEQfgIBzsEzn0rJoFPi2pcQt2RVFsdHFuLuFkDZrRckhijuAyYQkA6Rq2IFDqDtBBdJsAyb6wt4xkpLdkSCagMChiBH9g8CpCAA8AeMandNOmM41Xi4hVeJ95mJ37KMqVV9Jwnni27amNNqvHiLzaVM77eTxOm76he2RTW+hImV2njsnEPLDIDGhhMUiUA9YVdDyiBGwCDIsgCLNABQZOBQE7CbmWAR54ASHQA6DEAIzQNIzzCAGg4OICEypyFdbqFeD0ENcimRmA/A2GoAaHGDBYRxf9NUKH74CAzyzXAorjJNjQykEZ4y2ecC2sSkrywxs+tsiuznNLVskoNRwTqgI2BXSBuRwyQgGo22SM+2c7IsAzDMAxrhZU4Ba7malToalQIawyzarFmBe28hVqYP1oohX2yyPUKZgeitC7elOhNgu6YuQt6Z5mDuZhDj+v4GjsUWnV2PlqBDzZ2FcJQyRV4E8/w53+mgAugARt4lSsYAx54tiJsuOhc0gCwgAY4gAaogAOYgCKQgAUwABu4gHqUx9F7gDYohTWCjZu9hUyIBL9VsWUZiUNYhLxhMD6YS5a2Uiulu17xFWVsZVdGy/lYgz1QBMvlQkiAhNfpaQWjHaH/i+HXiqMeIKUpWTzGuxg8IqnkwYAfaGYIwAAKcICPlepRPYpXDF6tZgWWYAmtXoWoa9OrFmtTMIUMsz/9c4lDGK+LVE3WnOcLQg/oC+N21g7A7utPky/xAETDrj6zSewa2YEPmIDBXACspQDWtQASgCAX4QEvrccHuJ8DOEIHmAAFqIAOOIAP6IDdcgAXgMeprceRUYAMcIJAUIXsLNFKUAWQUDG7ogSRYChFyBtSXun47Nc8eOkJJDLVSbWz7DFfYYM6UIQBlYRNGFAgKYRAyDsMpp0EnbIpC93Yor0H1bIYjPGR2oAJIKkYaGr0bswwuUGTBS7GYdkmTmD3PkVA/79vVxh0DRv0V5gQXZAFV2gFVQjKSXvCkGMgLr4lurZrU+lrMeZeTOfrr6nNYQpjkqxnsnqCsUlsyXlCHdAAfuuA4rwAx2A85U2CHAAO0Bu9/nFoerSB6VmZxeiAylAAG0gAeZxajJbHkSG9jCNTVYgETgAJSWgEBMkER5gECXOEkk7yuehtckkwJyfcOJADqyio5BZhbmMDOAgE6L6EAU2yasplXY6yiTjYKsM0YV4Me08l//EyBAqBLmjmg/NwMPG3PB8NokBrtDYxbo7iVFxThl/TV3h4WdCFX5j4RMeFSJAB2lsgNpR0c45eLw4UdcZ07B3j7C0Vk4RNTx8I6P8ziOwIKMJAm1cp9bIYKBUJPjhgDBc4gcPoAS74Lupc6Iab9QBe0gFogAlAGcpoAAPwddZm7akVgEQ2ANCD2zawhEt49kZYhGXRBATRhEqghK8fiZLO+mxnsAUrIyfHUgMTWIJSnfkgWDb4Ty4U0DFiKIFBt2rECEdFA/e4Ak3Bshq+d1WCJRGIgi74QRC4ANZdfMnrUM4wMwqJfES/v57QBV2gkIn/KyF6rmM4Bmn4fGdgBmPoAxmAtIw3vi6WXrr24kwLKCUg2rDxUWDNjk63TWCyAuiLzezQ2VIvRNf/Jwj8drthS0kQBBpAA0BAgzqYriRgAx6QAfa5xxxQgwz/iMfgTIAOkICR6QwSMHbRUwBCHgDeoh5FHj3Rg5QdAARE4EJLaP9m4QRNyIRly+2RQPIkV/JBAG496Lv4BHcJHDKAYIPmzMAybNaU0cMIEqOFkBQtYrRIEaJChQgF8rNHo506cNqgMYOmzBUmRnbooEFjxoqWKlSciIlCSBcQNj1YkKAzAk8HPhcAVaBgQYKiRhMQS6q0WLFjyZIxY/bsmTRqVrFhzbZt27dv876C/boNmzAeKobYsNGDSY8dbo0kSWIErpK4dpU4UXLkyJS+fq34DWwF8JTBfvcaLjw4ceG+ex8fUcJkMhMnlJk0EVNmTZw6fPwUYiQJli1YqlQR/9LTEY4eOTwyVHjwIIcaNQwG4A4AYHeAAAMiJDCwwkCAAgoGHGBwAHmDAgMMFDAAwHfvAQEOcGiDSNKmUqpOkQqVCVQkSpYsSYoEqVGjiYoUHTpECKOf+n748MmTp06c/v3bCLQGGQOi0UYZcSACiYKSMNSQRBRZhBFGe+jhkRttgHQGFnmhpENKLLV0wgonADFHTSCMcIEGFkwwgQQROCCBTz8BBdRRRWGFTTY7brVVV9vw+I2PPXo1jz33IKmPPkjSow01jnCQA1o2BMHWW3PJBVdcSyyRhBJ46cVXYI0p9tdii00h5plcGIYmmY/1VdlllDUxxmZx5KHHIIcsAv9JKb0AA0wvtmxSkR4b9cFDbA9kUJsaHCy3XG+97babBAv4ZgBuByyH3AG+OWfddLxNOsADbUjCSSmlnALeKaKEEgommlhCCSXqtefeIRYF0muv9+WnH39xfAQgFmRggcVmABKyUCOSMBhRQxNVZFEhgHDkERwfDVTSXCip1NIKM9hg4g8oeqCBuhZUUIFOEkwwI402HvXjNtrgu6NWQOrbL1fryEPPPf4Q7A+S9thDTzbLvCbDDmnZ4JbEJ2mZZVx0fSmmYG0mduaZfLXJhciEiTzFEGOmeYScShghWRMv31mHHnwQoggkotgiKDCmiaJIIHt09EYOHGTwgAxvqNH/Rx9qyPBAbpNOR6lv1nFKtXWTUlqpbqUiV4EKgWyyymmnrLIqJ6Fwgsl56bHXyHsQEiIfRhnhR2Edd2/bRp0DklEGGmyw4cezCzLYoESIIG7ItT/b0biFaKCxIRRP9OAhDS31MMcfJ47QAQfqqltBi6K3OGON9BYVluqrz6PVvt/Y4w8//NTTTjfTWNXVN9ngwoMMM0ypVltznbTDEEkMYcTxQxzBvJqGVWFFFVNMH7310mNv/RHRL8ZmmX0B5uZeU0zWBBNK+KBEZmScwUZnfARyiCKSlJLzoKVs8pAfHqHBNNGNKi2AS5OBcnBztaxtbTkAMJUBB+CcAhQgAQEQ/4AAopMAB0IwOgr4QB1GA4tY0OIWt1jFKdCGiRNqoj2JiI98AjGIQdBND/oJVh4AhJCDrGENZyjDGXR4hjpsB1qXuARDGAKRRVSEPqqRWR3QsIUtHEEHPehBWnQAohNo4Q94GAEXL2AB0K2IdC2awAN80oDTKeAoYgFSjnJkFWpI4xnKeApUliGP2fEDHvRQxi90sYtiEEMYuuhDDnSwAiqmZYo7KN4QGtnI5jnSeeAbTBUqaclLYhKTSKhCsjw2MsWEDzCPwcvLzKe+OvWwDXjyQyAQ0QhLqMIWpVHFJRjEiELoAQ45zMFLcpCIXyaiD8HkQQ5kkIECPm1U0znAbv+Q2cDoDICCAnAAUHBjAOhUsAAMqMAbOEGLb9IiFeGJFSc0oYlItOdtLDwEDIH1GfzkwT9reMMbcrgGNfAwh2iAQyEkUcshGm4RSExiRigUCD7YQRCAgMMZnvCEIhShQysIwh/+EIURmMADG9DABz6wUQ20q11jnFEDSoq6BBQDG8n4BUt1IQtc4EIWrpgpK0bhCU98whSueEU18HiPefziFTLdhS5wkQkepGQFEGvLW9wSSb44cnyNySRVOZmsq151k8liU/cIA8rE7AUv5aNTE7CQSpn5gRAJ4o4oVmXLW+oBQGpYAjF54Ii74jVRORga0R5wG67hZjfIsc6mGuj/wOI44IK4SWwGF9CA5PCAD4oQxS0+0YpTaOJVmOAEJSaBznS+BxHsbCcr68OHu/EnD3JYbT1zuCxV+mERRPQnQyIiULj9Kn6igAUnINEGM5jhWJiZ4h3wEIMY/MAEIugACU7Q0XWFVIxllFeNiiILYRgjp6YwRSpQQcJWxWIVpMjEKEjRClboohqy8wc9vkGMXfBiFr0Ixi0GUUiWLHVikXwknP7CBepVFZNYHbBWsSCykTGme97zi2XKZ74mqE8M7HNfHeSgB1YWQhEOYQSE9vARNfAgxH3wxCSUlohJJEINxZSBDPraAAWESgAOZA4zfdOpwXYqjcR5jgQSAEED/+RkAspJTg4G4YhPkIIUr+JEOTHR2c8uIp3xIQQM56aR/eSBDzLUjxwA1IY1tOEjbNDDdhZSSwc9qFoYWcQseMGLVmDCD2aggxnOcIYxYGEOhvgDBkZwAxSwgAQdiMlzw7giFpVOXtSsUStmgYxekG0Vq4CFaU5jmlJYYlWroAUuptGOfPijde+lxaZhsYkynGQlEmPqIp+appOVyZNcDdmsD2xrkfFlZAi+NZsOzJiSOBQKk3tC+jDTBDIUaJ8y20ivCHERZ6dGl0jlQR9M8YkcZEAGAQRxizPwvwrABjozHoBytDa1TgVAAQ0QdwEutQAIOiACQIFOcrLdqEm0Iv884g1PJjJRK/V8Vp1xq3Ig9DMzGsZTlXEAXN7a0CwGQSugA71IKJhRDGH4ghSEcAMd6AC4OT/iEXiIggvSwoKWsMS5H1DXR0VauniRtKS0KAUskMHbVQ3xrYgwxB4CIQhCNMIRyogdPeaxDU/0QQw5EINcPCSuKSpykcobgvEao7GNWcHXJct6rXmtawR37wu+9lhgruCEJwjbocT2Qfokc4UxwMUJZZi7neFQBztc+GdxaIMYiPkGT4yCB/+LkhgK77sWE22vD1gAdApQtast8DqSKoADhOKcBci7OQm4lAEIQEFyZ6BoRktEKiS9ilSABxTlRM+toCxa+BSiIn7/yENp4cllCgMIcGwYgx8cAq23SmSgvcAGNZgxDFDwYQ8yk0Mc6GCITjzCC1EQQhBUMoPrs0QFHe1ABz7KLjGOdEY9HEMdbEGGD4yI0N3fwAYcMAELdMAIaiCGPJDUOpZ6QgYqWEG4WvKByUiMWyhBJB3G1ZWJVdlaYYCd14nMF4gdF1zVYIydx3jVFFyBsKWdQ00GxbSdh3jIIikBFNjZ37AGhcgBiNFGJXjCa7CEunAAByzBXLEYB8iA4C1KAziTAaFbbxiAAvSgA1HAAlTeANSIAJQKA/gVizGKHGRCLLRCK3RXCZmQJjhZJATcbb0HIbDSC7mTDPXHtojZRywB/xwsghDVEvBNxPBlAzYMwyQMwh7AT/I9Xyf8gRfgQBX0AA3k4QzswPWlX0d9QAdAl8uFnwOAm2zQgSR8wBjlxLvIyAV0gA1gwRscQzUIzDxUQzRIQ3YtwUrw30v8n0lMzADyV8qAjIIBmIEd2BTYmgQ64Cu+Yhk8YBaAQRZkQQPemgR6DFZNDhM8wQbOBdspgUrQwAfuQA+QQRO0D2tkhB68ATGpQSVMghp8gA3QwMkZUwaswBHERQ7wwKOI3gN8QBJwwG3ooANVynRUUADwRDUZQLxgStR4ymwck7e9ASnEQj5CIXjEiig02a2sR9u8zXyMlmnBk7ZwC+SwQRm0Qf8/Qcsm1JKCNIQikMIwNMMwkEJ8XESvPJ8t0KEQpIElFaMOuIUnxoTKCWLoVIAFIFqisRz3CUIn9MAKkEBNisBNogD3wQAY2IEiJAPs3IM9yEM6TMMxNAMtNEEZNMESNEExst1cQB0k8ddeMI9/fcH2VFKtfQFgfB0sHtgDyiIE3iID4uLIJAsUnKVDYUHanc+X7EAIJgtwmcETkAGY1QFoFMIhyEEx+VIi5MADXEBNkgANxMYFqIgKyEBthOMD8MAJPsoD3JhupCNvJMC8CYACLJo0HQCj0GNyGA0PHIITPiEroEJ4MBkVtl7bgFZ87MkgGKTB7Qd/FAsOrQEbBAL/JDzkGRaOIgCT3MQPIQDCI3TCJRiCFljVL4ILuKTcB3BAIA6iy8nGA5QUCfTADFSBNT4CLFTBDAQBC7CADaCADZzAYPLkIPzkkQjlOXgDNWRDMJyBE4yBD3gI26WPD0AdEjwVZEySBKair31BWP7nV/4nLMrif8oiFmQBLHrlKyLYWV6VsK2lQ33JXEgGhGIBcPkiFrCBHaQVIrzQG8hAX8qABXgACqQACdhAIMLAoBFNiBlTbHCA0jiK7zjNpFCQ523NBHneAFTeNVHQdchGtikHEjbKIISCPu7jOP2jFTYClL3HOnFhF3YEsXzEwgFOGYzBHkDCP0Hk7wkUtSBO/ysVgnBC3x2AQRtcSHA5QRLsAJumxXI6V0qCVHS1SHTSwA5kgR62RXa6AQ2oxXUiwQnMgBXAgR+YJ1DawzlUwzmsYSYsgRjMFQ88pWRIxhThZ1SZ4lctBiclKIE64NwRaIF+6qfWoi06oK0p6AMOBhZcwRUMWFpOxpf4ItrF5VxiRhtcmFoNQiJEwiG8wS/lwAfQQBB053WuQBjU5AmAjgpkAHPyQDAtzTcqzV9+SjRJ0wRpzQAERwIYoW8wwLdGCaeAax4cgnk94bmmAuqRAihkgjRaYWq6DXzID2uSlpZVyLD0h/vEAULEwfzU0iZsQsQ1goNMRCFERCcgrCGAgf8bdAQdXMhItOrZtcXliIvKgZG6wMYEgBuxbhIrlgETSIItfMEUoMEXjAQNNAGG7EEiOIORBKU3TIM2ZEMxzNUYdImkCqOsMgESQMbVgQyvIWgWzB2ohiWoxiKAGujcgcHSggGDcgGDPqCtveqDOpQTNNisouWFogGylAFaqdUhOAIs3EIq2BTTJAsSzAAYFAENIAFN0iRzgZQGcMAbOAK0Js22vQYDXFPnCQABeF46FsfVeAoDGJO4zgYfNAIstIJonusTklAoaEIm2EoVBtzbwMcL+Up9UEhHpBa+6tAaBII/+VOXMkTIPQgkbALCihwdbASF0EFCQo4tRtRKJNX/iDzXymlA6KnLB2QBHuABTxoCIOzBHpCGIAiCIRwOI9SSKLQCNcwDk1QDNEyDNKxg4TGlD+yAD8Tql1CqY3wVKDWg2AXt0MpiyT5tqqbq0DJt06IvA5bBVb2MWqodZXAvXZJBnbHBMtrBRqhVI2gCabjZm0ECIijlDqTBFDnBiLhACphACoiABXxAtqlBItStMFWwGtCT0LxYBkGQEa4jAAjAMnHKA3AAZNabGgyCJtxCPspCLMhCC+sjaaaeOVEue0SZlLVQ5vqBHsjQve6dwtnJHijvEOVcyClIe1wCaXSCIdwBsxVUhYChG6QBGJDBE3xL7a6A9mnf53CAuEAk/8J2gipQ2mkMAzKUhi0MCqWhcTBkw/P+VFEmgzCA2KOOQRL4gPlIqGS0JWFQIK+Jr6mS70icr8mGqt98ahkwbaeib9SKzNzBbxOoJRZoIPd+CV0CV7K5gczkKiIsAifAQi/0gi8MQxkPAybs5Ro0ZRvsnw3AQAmEwAt4QAe8hASf2Cd4QgWbWKJwwGNdU3QQgAEsQLcKFnKE3pARrhwowir0wge5sCzUwizMwjOLJniEB2oyaSME5ES00Hz8yg7zMJ7ogX8IBEm0gSIQMcBGpIJAQifI0iUoVEZESEF1hB10nBvkLxmYnRKAi7i4xP6thAqQhizJ0qCgsS0gQzMMyv/OqDEwDMM2xM4bX1wm5EASvF0SkOSwQcFkLIETcMkVhJKsfaVYdurQliwsljSBosHTymIit6/TioyrJsvLzGpMm9KEGgETHMuEgVlnXNieREKm2QIviHIZI4Mx+EImHEIb6MAYqAANLPBxOTAJvMQMvIQO5MEk2PJdAVO0Dk0FHEAvF4DnhXA6DkBsRAoD5AAfRAItLPMTOnMtwPUtPPMsOOF3kULatJ4VHnHBxl61dPOh7EEebEt/vB2WokEhDBHAboLaRAJ3yBL0GUK1TBx97IHwTumXEUQZcEhKEKNK1C4oC7RADwooH7SgrMIZ94IwOLQ/2MM8YAMx4EIfyID/EVxBXGABE+wABkYslyyBR1Pgz4Yv+pbvIp+qSnNBgfrNSAyoLMriFSg3gsF0Kb3Mbcs0+qQPSuwAE6ClSHjZ3e1B3DQCJmyCKtCCKBsDMgyDMaj3MNCCHzAN/8HADWjBC5QACYzIGSSVRdMtid2UI/TBG/RdDaqA3hZABXWrAVXHYJmKGihCKNzCMjthLERzLchCLsi1NLeCpIFH2vwbtODKRNyWmv11ntSQHKCBGIyBGhyEH3AHwJZCKPx0QHeCg1BEmlWE8SrU8NrB3rEBSEQOh7iFMV7ODOCPYkNkYm8CLFAWMgQDKFACJ4gCKMgCNXyD/WVDMnhCMbUqFVBB/wHuhRQQwZZIwZiPORU80ZkraNYx6BZwwRa8opvD4pnD+SKT79sV9tCaXavO3RiMQcQ2Qavm85fIxVscwRX8Z4HY3f4GQtyUISeswi34QjCM8iiftzFg5CC8wQpsgGFeAAVgAAVYwAx0cQbQACCi8CR4QjCh4NLJQAXgILoVlqdUDQM0SiJgwqZN2ix8Uy3gQi7A9a/PQguTZjVXghVCmXsgTrW00zttmWrJgWrFwRvgUBswAkR2hxgDgy2owiOIhiQI1OHE868Azd7pU3D9IlP9YqqByLff0rcjUZMGXUXyQiYsAiV8witAwzbY3zcYg2zLwBdsAZdzOZiTOZgTAf8RFLwUcPkTCbycA7yco/mbO+CcA7yCPtEr2gn5avzcAfrb8TmfA7oTmN0SCDryOM8RqDnkbIt318chNKmj34KbzdcoM0UxDEMw9IIi6EAGsJ8I4AQJzICIqEAPiMgHqAAHiMGuDkK0hlgJ+5UCPB6nGK5sIGEO/CoprEJ4URo00wKv/7rXw7UTskIJUWEN2zBEUIRowZALHZTt6Yezt9YakNklAKwqBAqhLEThNAi1RMhG2k1/OOwZDIjaDQiE7QDFAgIg/JwfJLsrNal4AJ4o90IsjIIuYMPztnY2+EIxfQDDU8GYHzyZHzzCF3zDB/znK7yZQ3zEpyrFU3z6bvz/ntd5x9P+FWw0Rwu68vSsAiZ3mN1dlsnPKzFvowl1MEh6MQRDpPeCKgTCa2h6B8xAHvIfH7JEMb7gEghQooTjNpnwt34ro4Qeo1CbI5BNLJyCKkyahEfzhPM6TOEChTshP57mv33W2YuWfBSk7TW7atEThvSTGAMELEmlJEm6VFASJIWQGC1ShAgiokKEAu3RU+dinDZt0Jw50xFLkx00VqzYdLKUKlgracG6RavXLV+8cAUb1oxZsmre7tn7Rm1SDhkcthSlQkWKFCJJkxJZilTK0aJbqBiVOhXrli9buXblWpQrGjRev5QxexYt2itrx6x1e2WJE7lK6CY5chcv/14rW8Wi2SiHz6BDiiJZmpTJVKxbvII1DjYzGK9Th9bkmLHiSJUgVWZgoXHEChoVKpYcesPjzSA1HDJkqPDA9QPZDBjAzsCBdQ41jlK1ahUrFKlTqnzHmnV8Vi3luJjXmhUr1qpTwkNx0oTJUiTtkBo1cghR0aFBgwL54cPHj3k9edjHiYMGzh5GkAr5KXjpYEFI+hU2XPRfIkIo2sMPi+yogw463HCjjTJEIkkFW3rpBZgKgYnsQmSG6WWYYXzphTFknsnmHH98SkaNHHDD6qijmFIqKaiuuiqrGrX6iqwc+xIrLDTS+rGMtdRyS64i65oCiSSTvGuII6awwgouyv9AYww12sgjsMEGO4yUVmrJhRdfxPRll5l4CaWRPHbYwYY0bMhiByvCqEIDFeSI5A0OZOBBxaFu4+CBCl6rrTXchhLjDVR6qYWWWDjhJLhUevstFlmSU64W5m5xLpZWJJ2uOk0socQSSbTzzqHvJgqE1fTMY6+OOuSQo4013GOjEPx0PciSUvnzDlWIJqKovD0MjNUNNLDogaQTKLzQsQ6lHUZDZB6bkBid2vFnnm1e4fODDFhsscUXZSS3KhunypFdr8bia6wdfQSSXrOInIsuupDsoYclj9ihSb2wMGKJMdaQIw8/BslSkUYoCWWVWsL05TFhgjFGw1sGYWMHO2z/wMIKHexAYoUP3lBEDRU4qKC1oVQQqrXXZCuUgxxy4GGQXIKZ8BbrNAnuFFQmrfRS5nC5BWlOO5WOlFCvK1Wh7rx7KEBWW+VDj6xpZaOONthYYw9JTrrkJEtO2uQSXxdiqKGIClmVVQPhUJbZFU6wsENkkDGG72lt8qXDYIg5Jpt29JmHmj54kOGDCq6YCl2olooKXXUtb/fdrniEV9556/3xLSeucEKJJUxn4gglVd+B3x6GaJIJGnQw4gq/ED4YvUEapiQVxcIUxuK+rYXlEDZo2MEpOD7QQAbBclDhhA0EVUEGFXTQYSjWbhtKhpvfeGOSXhqb0DpMMHmUFOF6/4OuaOZyeR8X5Z7z9JTpRAnlae0i4Q7V8A6pujzokcMazhAHNpxhDWsgBCN0dbazaWITvuKPfxTxHWFVRA/vecJI7CatajVDbxqaVof6VoxjfIMe95iHMFIkg9Z8AXJMcZFSnlK5cVkOLDpq1xc6Jy+09OUsY0jLW9ZSOrk0IXVIqEKSqlAFG7CuB2t63QxmMLslmGUNQmQDlgSjCE6Qone5oBjfMIaxDtGCE4F4XhlKtgLxVG8DJLCABqr4gZdhT0UZsJnNUNOHRGTiQzvrBf4qUQlMaOKLkSpOcuD3Pl68Lxebmp90TiGK8pVqO1JzyEOGRZH0GNAscSgDAeOgB/9FNNCBZ8MP2iY4H/84pD4ZRMMGmzWhCfFiQrCwxUpgsYpS2GIWo/CEL2rxCV3sZB7f8MT3lsADHcDQKuWSYVWmicOs7JCHmusLD7fJTc/Ny4efWwvpisQEJDGxiUnqlzr7xQQm0IUJTUADG9oQB4ykJxD/W0QkMNGlW0woGMIYBsaQwQxrOUINY1BBBU7ghzWsTAITaABD7cayD8hgKHvsXg7EMAhHxAJEL1lF08x3SEhFahW/udQtIAnJ5sjCN6kAlXVGtb9IoGqTWhJPANGzHljVwT3uIQQkHGhJToiiFKLYBCYQopD/dAdAiCBEHvTABjIsawYnWAEmJkEJSkT/ghEMZEQgpGoePxwiEZ54xS+IEY1saGMezBjEG9bQzGdOJUbSzCu5rHlNbG5uR2TpITjFIs7QFWkJqEPnEtmpTtbRxQhG8IESRIdF9yCMD/ncHSdKAQta5IJDwygGxoRhDGHIIhJq+IAOEPFQGnxgAg84gQ06gIQP0IBP3VMDn3jQWx70IROLycUsWrEKQlLCkIiElHAW2T5ctDR+nYopqET11a/edJOK0O4hxEOeVqXHInkAaqwShgixKXUTSFWqKLCjtoVAVbuFuIgbzBA7Ks5gEITwAyEQIQhBGIIOaKiqGtTwhkS84hjQwEY2slGNbXwDF2qQQxmWYAQdYIUp/1SBirla1FeseCWHYdFR5ry5o88FqSxEHF2RnLAEJSSxiYxFAr/Y2QN35itf8SwDPeFQB/YwrBGSeNQpYhEmwRWDGMQQaDBoAYlApJYDcViBBbRqgzd9YAcF5oEY+kBgAr9BDYdQTKNakT5NVEJ/lDCfcpkLHeMcJ1MtzUX8ZCEL6NCPFKC4znWui93/bJe73r0aH6g6q1nlYahkKyp6y4YQU3HnP4XYAxzaYIYdzIAGVt4DIAwhCEB4mhF2gMMb+uCIVxBDGm+txjS6UY1sYEMaibASGpSQgwtHc4ZR4TCNbMRrHOVwXZgjMTeH6BYhmmUrKi4SkZYA43Q2VnVMeP+CXNzpTiNQdkpsiEMe3oAwPwSiEA1rRCQ4QWQxPiagYmoML4YxCQmr4ANHsFsPbECDWqnBo4noQ5dJDb5bREc4eq4EJRSiHa+uGWgppVSl4gymRzYHOZ1KRZ41cT9OYMKrkViEJgHdyfKYNQ+A8QN7/IAIop5EFIw+SXvNlp3+EKIOydogv2zAgj/gAQ+GMMQeAjGIRBhzGduYxz3owY1qjAMd4bjGq2WhhiyOYQe2xvVRJvciyvG1Ri7ycI2wSRa3BOkKQRzDGLjCBRWHrtl5wcsQpIiXKSih2nH3wdyTsIQmlMHL3UYPuLsYiUqQIha1mNCYKCaMYgzDFYpYgxP/hnCCE9BAdt97gytq4QjLJ2KubwjFLVRBip+d+avc0Z/BfxYKUahCOgo3TqaeywvXPzx+z2HFKUCRiUioGc1pPtXUKui/Q3hy72YldHnFlkoHmu9RvZLEWGtFBncWoQczIAEg5kAgPvzcF9R48Dzs4Y9/8KMe4RAHOMDRjW08Q3FiaIIPbJ2DqqDL6i/ScOTGla6t2+grwS771380di783+zObnRMZwoKUO1e53XyAu7eCceUYO7obgnEIAnEQAzUYNv0gNCyZJ8yAWJggt2Ap7SSQUNoARHKQAcwTQfGgA/kYBBcYRQsbxImQdYG4RRgIX0yIRP6TGoaIWoKA5FC/yEl1Kc4lsPhXs/15mx+WAEVhmOkNMGrSEUHOc73yiMQKAI9PqmUCGERis/4UMKS0GYR9GANrAoKniD67GZW+mASdsEZhG4e5oEe7MEe7oEO6aEe9sEd8mEdtmEXesvu+MRmlsAoZCj+osIq8irrOgyH0oURee3DvgAAuQBK+M8sxm4MnuT/JpGI5MJ0nMQA1e4IEvAuqq0B14QHHtAHkkAH/NDpuq3AuOgQ9kkTUuGzGEO0mAEXRYgWJMEPxkAG5EDfPEEXPMHyHEHf5AASSiGpOCE7gAWndhASCsMSKu5+hOMUWGEI42wXXk9MHs455kdSSMFnzCfjtgPSNgkRfv+v58bjPAgtVupgD0yu+FKOHk9PFZLKEgohDtYADcwACzboMlbAE3ZhGbDhG+ZBHvzhHOrhHOiwJ+jQH/IhH9LhG7DBEWxNFQExB5IAr2pow6aJ/rLChqxgC6yACqAESgrQJN/PEbPCCq7gJV9SLt5i7IrICWKSxVisCaitAKcAFI/ACIbgxRiwAZkgslDxFFFQByLQYCrwYBJGMLyKE4zDFnORGaYFGELB52DQE7rSEWQwDw7BEu6RGb8qVTbpqaTG4KaxOkIhFOoHG1vBUpQjF7aR8B4pF5zjJZamacQxE0alz24KvgBtENKjMLEmay6iDhaIbOhRGVNCFVRBFCT/IRAI6AzMAArsawVI4CDfEA7tQR/8gR/4wR/gAR3OoSF7Yh5ezRjUwHTewnQiBymcoup0jVwoR10iESV3M0oAcJyUbSYpsRLHrgza4gqM8wqwQDl38gma4AmUUzmTc8WMJAmSwAiqsyiVoAniqQm60zvhqTm3kzvFAIvaAGH04Nv+p2EiQRNKYRX+ySakhW9EKBhkgRgTIRFg0BH6IDUk4R4taVT45z+eam0iQRJMypJMr35WARaggxbo0i4nBi/jh8xaYTpAofYyYRIcQWoUIRG4y/e4yzxWEGHiwA/sYA/swA7KwAbsAG02ATJVghZWwZcWIQ/OwAnQIAuQYCQC/1IefvRH60FI/YFI6aEd1mEdvMEe3jAbcsITxGAJqOBxPjJyClE27c9GdDMloSTGYmw6iUQALVFMw24TnaA740k5rwo6oYBN2XTFiNIIqu0JlOAJpM1O6xRPb+wJ9vQfxXM7m+A4R+lK9IBAem4wxg0TRGEVfCc+B6pDiAHJfsE+YXASFgYRzgc7EmJq0rEQECEtuyMaD+7iEEk4UqpToANCd6FMyOSRasFSYMpTUCF9miYHy7E7tKuCHIK7Ai090LMi4BEMKqAIGKET8EMZaZQWZhQTCEGUmAAMsIBHT7Ak2IEdUNNaz4Ee6EEetkHovkHoGOwYXmEUUmQJ4IJ0qv/TCCgnr6w01wxx/lgkE1GyJ3uyS78UTJWtTJHzLc4UULFgdN7UnZ6gDPc07gKWYPn0OQ/2YKVtTwWWCarTxRBrDPwCDuQAAzFQsxC1EkKBFs9tGIQhyYAnyZLMF57rFlYBE/QHvriLWNQzV7tDO7oqEyohEz4BQ0kBFVoBG+ssU3RhF3QBaFV1F4wGF2CKFZTQFHxDVvHHfPQDqv5MVz2pVfJAI9ogA06gCuZjPy7hHhlUFRphD9bgCpgAWqNIWlcAHdDBHdwBHcbhGqpBHr6BwV7NGZJMF4phF1zBERbHxfJlCSCWXWno6nYN66hCEuXVAHtSSaqAxYiEsvCFLuL/QnRWrFyD0y28cyenk9reiWEb1nOLwHNDd09BV3Q9N18mdwCX4AvGzlZoxWIVRne8w+84oXdk4ndENslGyxiCoRZCIRIIA7u2ixAKMz1dduPGLQaRi2ZrFhRwdhRQgRVcoc5kAReA1nqFFmiL1hVcAWlHoWmckFQSIqwYoRDAbTAUYRDkwEow0MuE6AGwgBE+zRDmQ2w8ixP08QzKcInMliRW4B3YdhzCoRu6QRuqARuw4RmI4RW6cmhdrxf4gHHsomD/ljYnhwgkZ3Ko1EU2mCV38xPvwifvIkmUAGLjwnQkt8VO2HRYTIVRWC6SYAHdSXQm1wmMcggKdk+RgAls/4yHmUCHC1ZOBbZN3fSE4aKFTWd1s+gpMRB2D5USMgHwvqRMfuEXcJd3P2ESGqFhcmqnPk5hzhcRtGvj9Cd5k4sTQOETnjcVorfOiNZnVdVni1YWWMEUPoEUZpYSHCE8HqIiCsGp/GdhyoM9BqEPdOc/AoERbOER4pfTGAipIGHSyoAJdgAL9rdHV0Ad2iEd0kEbtOHVsOEYdkFcR4EVZGFaVAF7VGAUSbE6myJGmII2X3mvbhNd5vUn8UKHq7PuTniXTUeXWziF/3aFgxmG8YUJgpN0jGBNbIxhlWQIkGAIXMd1Jtkoqxnu6NQJpu0JrmAnX3OcnECXS/gKJnAM2P9A70bui3cnEzzBFGTBZ6kYZInBF1phEjxUp8bj41rFUHUqjNXS4J7Qq2g2jU0hZ3nWfYRWTHbBVVHhEzRUjzGvD9Bj4wrCQC3hqJDqMVPinyakQmyBEe5A53IOEDjtIBChDqxqJCp5xnZAWuc2G6jBGZLhGJKBGH5hVRtDb4YBGPzgNjQgdW6MhK9z15rCKWA5/j5S16TglpkkYI6AhEv4b3U5sqb6OsMZhkmYLs4Vho+5hnHsmEN4TdZk7hoQhiMrrI9SsiQLhmHY7sz0CqB0JwGVAsdgstDVByTL1k6xAl2x27ioYSahEthZFnYBnoVhF1JBBguTPNTjQOIADuL/wA5c5dvGo4s2jkMdIRJicBIyOwaXt3lJwRRY4VJYz2hqQeKIjEZTexWSlbVpAWk22pZsaWeA4Z9godPsIAzC4A52e5EvARIIgb6gIIqWaId1gAYuAxuoYRlqOmhvWlpsAhhs4RJcSAMyoJ0YcKoreCksuDZhOZYLUQoQsEkQMBTF+3WsGl2tU5mpGl0jy6rrgqojC55uDHVCcU0kCxXvWr3N+r6rExV/WYWbgAIpEHPX7wGd6Xps7Xq2TAzGYMuq5A3QA60a4TBQgXp3QRh8QRYyQRHakT3YoAy+YAmcwriXoMfMOeSwpJDRqhiLEbBnNhMO6QfzLLR1FhvfLDme/wM6XuK1kaaRcoG1/wlpYkJCbMkWbEEVJI360kAIbEC3dU4QCGEPKg0LLo24WRryZiAZbPrCcRoZQEhvegEWVGETKDOeWPraIKuqtfu7rY4KirqCk3qGqCAv2A5gxFsBHzeozbqqYfheWCwJRIeEX3gH3AmK1uQyqOi4Ia967AijLooDPkDScUNlcMPSJZ164M3RMYqKSqLTS6IkNL3SceOiqkdlRqN6lvIVC1kRJqErZbAPxMBPMqA2bOM1VCADGuABVMC3JGzF8fMrAdsT1nkUip2g6ycVUEFolHAUTGF7o3d7uRcVTKHYZaHZqd0VUMEVVhXIY2FGV+EeRWUTIP9hEd5GPugADPDgDvBgDnAOEHab0wDBDhRER5+zCvj3MugScDqkGfodGYChFzZhEQRkERiBDSbZuHdgqu/bCNhcu6fJuwnxKZjCvNvuAIfAvfl7B9Q7vXFMl8n6OpW50KOIX1hnmXVgmVla5Vn6eqqI06so0VfgMlQg1GWAijAKo2h+BUajJE5AAzRAUFgm6GUj6IteUGimZtQgDwQjP+eqT4SC0mVgDLJmDO0APQ+hEc5HE9B4oJUdFZp92q/dFMae2kcBQ4sd7dOe7Nf+FV4haOGZrTSFFoaBEsCMVbLGDIogC9ygkrMgDcLAEB7hDuYApAcfpBlBEPRAQfzR3vH/fQVwiVpCqEJgYdwRIRDkfT4CocovbXZEPrIcHvQlfuKJ2qgv3s7NG+MX/r7D+qz73DoVfq2xE56UoE2VEwqwgAlu/zmnBPezYE8zEzNzP6xlZySyHNQ9/bgDMtRV5uczgOhf4zV0nTamn/oPwPprQ0/2JDXyU7M1m2Y5gQPTh0F7ifx9Y+GmfezRX+xH4RM+oSvTHu3b3u2BlopH1oSSQRmcARqigRoOuP+pASCMCcN1axUsUU2egLHhJs0dPEKEzAET8eGdixgZMQKEZyMdOm7MYIEykkkPHTRozBiGDNmwYbZgwdq0yJAgQII+MiJExgcTHzN0GPFhpKgRIkiT/yqVojQpU6RSqDB9KqVq1SlTjmg9MmSr1yNTlIhVksTojqJJ0qpFW9ZIWrFvlRhRwoQJSSx2r2DZewYNmjJZqiCpQlgwjR4paaxYsWPGig8fOKhQEVlDBg2QOWjOwLnzAwYVMmjWLCMHjyRj1rzJw4fPIEWNJlXiFCoUqFOpZOmW5Wq3K1epUrFyxYoVquG8kb9aLmu58+e6ov+aTqw6sWLHkilbRg1btu/gw2OrRn5bte/UqB3TtevWLViSdMyoEiaMlxtAvHjRIsSLxDuCzKHfHWngAUgnguxRyB4fuYEGFk+U1MMOiSEDDCylbKJIIRoJwoghgHB0hyF0QIhFUP8zDGWUEUMM0dSLMBJh1YxWSSUFV13hOARWOnalhBNAkqXWkEnssEORRhphpA46nMXkkioFxYRcPjBJA5NYrkDCCYud8MEJGnDAmQYVhGZmmRxElgGaMjDJgxhivMGHH4MggogikERCCSackLLKKq20EgsttNySSy2yIFpLLbgsqtssizq626TPvRLdpdP9Yt0xyjgDTTTTnLdNNt/MY+qp84yKDTbpZWMqPfTcc48922hj6622dqNNNdgoo8srvPRiiyRMuIBCflpc5AUQd/wRhX5ezHHHHNTOkQYdguBBB05+2EFHG2dg0QMUUJhkQ2KqQIIIISHeZMgjjOCBB7X/d+yBxZJNCrUiiy7GGCONUQUc1RZStdgVVgj3qJUTVzTsxFhpGYWkYisEhZJKTK4w2caUqSCDDJNxdqZoGTxQZgMMgPbAyhl4XFqceeThByKNNEJJJJaIYhAstPSSS7C9AB0sL0QXncsuRxO9yy6XNv2rpZfu8osuvwhjHXbbfQoqqaWiaqo9sobtz9hkjy2rPfbMo01424Bdtj/2wEqPPN5wc0036awNzS+v4MKLLZDokAUKL5gwRwxz4AEEEPxp4Ti0FwEShCHa0mEHToHo4aBIdj1hEoUpCSJIIIJQbqAhlIORxYh4pPFED0/QwMQMMpxVlJEt+vuvwAFTYeMW/1vcuBXCU1hhBfFYBVmWkcyjhCUNRig2mZiicWBZmdivGZpnFXBQ2hJqyJHHaq0NskgkmKQfikGE0vJzLrcULb/8vtRvPy9L56+//plmWt0xnHIGp6AxDWp8p2tfAxva0rbAsDnQH/d42z8mSMEKmm1W6/jGqLKhjViNbYIQbCA91KGOdaxjG9QYCNJoQYkx6KAKNfDABSLyAhzYoAiEmYMWwMDDAuEhDFXYFoMAAaI96IEOaCCDicr1uZSEiCM4oVyILgIGRggiCwspwpWiZDvmFQVGSSDCUfa1hDKa8YxmbBhdpsSEh40FLkpi0vJQ4hgZ0E4FoxkNZ9IEmcl8QP8FOdABD66whjXIQQ+ugU0kJCEKVcjEFrbohaGA1othBMN+9gvGJX3BC/stjT1MwwXTnAbK/lmNU52KRjRahUCvzSOCZ2tgBP0xQX78w2xk44cubVnBXu6Sl728pazksUFtrMNttBSmLGdlqm+s52e3KAUimsAEFlzAAyLQDxha0IKc2CANiUucge6wrZwAAj43MeK3yPCECDGRCTs4l00eYZNLPAIPj6DnTR6RLReQ4AMy8NIJTrCxga4AZCsw6GIO+sc+TkYGmnEoZcI0msxQNEyW0V5nKmAyjnY0NBGVjGnGwIY26IEQiFhEI3CmCU6IohSq2JlMeEaoWdB0FrH/iMUsZjGpnv7mN5UKKtSoVrX/BfBT0wjVd2yVjnXI7antUEc75GYPfVQ1H1iNB1bzEY8K8mMfYAVhL9/2wX/88qv7qCA+8EFBf9SDG9VIalKr4Q17+EMf8IBHOujhjWt4Y1faMJU0osOLW3BCD62zwQ2EUAMwUEteqHsEIIBhiDnQYUQcEUIYBHEHQNhiE4QIxB7q4IY1lGGJnpsQk1DHWnr+wRCvtQkg7HAHFBAUZFzS2GQGSlA/Tka3Dm3oH6cX0ci4jLiS+VhpchDI0rxJDWogHx8CcQiV6okSlsCEJkJBilP8aWc5jUWgxluc8pp3OL1pjlChEzXqGDVroKIG/3m8A55RaWMbJpSHfmGVV3i8w7/xCLBWuRqPdwxYHwiupS73sWCwMvisvUSwPm6Z4LuedZfBtCA74irXaXCjHcn8xz3aIY90XOMa2pjGPLDxi10EKxRrYIFj5yAEHvLQELbgrCAKBIth7HhbeJjWvMgJCEKEdrRwYMMZlFiSz+1AB6WL7CP+IIg/WBkPqBMEGFhw0I8tRrkySGiXOeZbyZD5Y8w1TRLKqJo3iM8Ph0hpzfSk3VCcorvfhcUsYjre8eJmvMQhDiuE05ufssIUiHYFooWKKfcSA4DwpUaozmMrb6wjHepgxzvewQ5NvwMd7HDHpkfN6U6b2hwEFnCA3/9Rj1a7+tX1QDAtJbxVrEZYHw++MIPNyusLAzPDu3xrh6vBDXaEuB7waEc7ukGe7xDjF74IBizUoIIaSAQMaYgIGISMxTkEIQ1gyKdF8JCtMCTucn4ghB/0QFrTMpmJzNtBZGFbOitnCw/2pEMQrsRcLOkAzTNIiSAFmYQmiCE14pvTIA6hCEUukk+iEMWdvStTPdMCp+GNhXmDM5xU/DS9vHGObp4jC1L67zqQXgZSyXMeDnKQqenwhje6QfNulOPm4wgHOcTBc3GQwxxA37Q7RG1gA8fDHehAh6hV/Y6lE7jV+mg1PKAedaon+B/6yMeEsS7hrsdjH10P+9X1cWH/X/LarLuEB1xPbA1uoIPsX72lP9jRjWvElRi7EIa09aCCItwAB0LAwRyYFYYag1t1lsXDE+RlIBF1VhB2EMS61h2HNrg7QhAySQ8m9FrJyovKf/i8uIOAhegm3DULV8QiICEJS7i0FDB1JM9m0b723aL2kUJUonT/KN7z5vc9LXnTpHZySDvDU6BSaja28Y3mf2Md89gv2mCl7HOsQx7wwP7Uz3EOcyR96O4AOjp+7n10iP/n6E+60tdvfvWb+h1Rn7qEW71VAWu91gnWx9gkvH/+k/X/d6V/FrZLtZZVq+Zf4dd952A318ANDmgO8PBLZsUO15AO0/BsxTAMs7AH/yeAAjdwAy9wA1qgH5dgCPSxY1lgbhxROoBABwZCT+QmOpIweaPlBmxgBkw2Ep7zOe3SeVZmZc0yZXfwCDNVKL1whERzhErYC8GghMCghPKTC1LIC7iQC7jQKLjAHrqQhbqgG1kofFIjDFaDHdmxDM/wDNKQHt7BfK50KgskS7AiNmQjgGSTYQiWD7qUD/ugh1xldKoWD0pHdAI2dOqnfkvXdO4AD/FQdbEWgPVQgLokYW31NnRIiQgWNtMHK9cnDybUiexQiIaYdObAfdyHdN7XaZhGiugQgQTIad0wDeshhrfgB0ZgAx5QAikgBEAAeEAQBpWFT3ewbdmSBoBwCf/yQgdzEHojYhOMMHnsZoM4iHlQsIMTYm7R8lpBpgVBJiA15llPCIVEg0lKqElH+I29UD+Zgo5VI4bVgTVZIw3wmB5quA1t6DUMpECyAkH66A++1o+6lGEUdGH7p3X8kHVkx4+/NDYSCJD88HUOtof7sGlYtXX/8GqyFoBlU1VzGGvIFn/wcGncJ3N144AOSGwsB1ckmZIOyA6kSIrjcA6mlg7nkA40+V8Glg9tVQ/t4A3QQAzCgAzB0AhN4gEUQAEv4AIPoQXUQjla0IvgRE9pAE4YwXhDuBGMUAjqxm5tcIM5qIOfAwZhcAf7IQTzggf+ERFCEARVwAiwYI6dtDT/LbY0ndRJSBgswYAMzMAMz6CGa+h8rYQqzedKYJOPb+NAs6SQ/IiQ/tiPAKlgiQmAkKmQGNaYi/lLDKYPcyMPT7WZnCiT3JeSxEaSLDeaKqmSIskNLcl97ECT3EeTrDlVI+Sa3iBV7VAPZCMr9LAO2UAN0vAMzTAMeaADKGABGIABQuACjJMsf8AfXnAHQIRtPCQEWeAQVHkTOFEIzkha4EIGZGAGIgEhqSUtjzB41BJ6AqI4jlMFT8AGhCAJpdALyPAMKXcMxJAMuMBJnPQz9cMM3YEN28B83xAeHLQNNHkPUkUPHAYNSGUrmkkPVLd/cQMr0ldVFIpgsIZs8MAO/7FWdRZqkfPnag7qoIooYKT2Xxk6dY9ogAIWmbmkmBd2D/QQczQpc+QBV6MZmg6Ymq3pmqbGDuqADq1JQq5Jm8pGQiQGm081ofbAiZvIiTK3Dt5QDfOQDdVADc6wDMWwC6CgCIFgBCzQAiGQAvsRA0LgOPzRH2HAQxNROg/hEBdxCZvAEduCCIUgWkfkBtvZnSMxjXWxAxJhCF6AB38gLYuTOGeKAzNgJGfwBrGQDasSoNvAKtRgDLvASUazNMxAX82EK95Ak+wQD/ygoQiqSgpKQNqwV1GnD/2AD7NWDxFKVUu6ma3WoJtJD9M3mFXVoVKHYG9ID261VfxQf/HAkf+y1l955WpxIw9Hug4lFHMjiZKlaaM3WqMOqA1/5Q3nAGqdBmqu2a00WQ5J56M++g7tQK7vkGkkJDf6xaS1YissNw2qRKqlGg2lWq+q1JvJMBCfkAmOcAhxMAMsIAIlwDg4sIuNsx83IC0/ZAgIUlnOiU+w0IKAgJ11qk7fsmTdKRJ8ahID4gWwtSw4AHhCgB8RcS02gAWMGqnRUA3fkGLfgQ3PMAy34DM/gwuy8AvL4B3GhKAv16nrwA5ZBw/6oA7wKq/VkA5C+w/4kFa2VJDwsED14KAIhqKw1qTrCn1PhTb34H8saokCeDZQpQ7O6q4c1mHwarZydaMntrZs2w3/pDhzM8cNbktzITmj3qpsUeWtYiubzEYeSUWv9aqgzqAMhFu4hlu4y2C4Z8gMxuALsvAJkzAJjYCVWJAGWSACJlCwyxJ41NIfj/UH02JuQTaVeLAHe2AngWCnHwEuOOide7GDTKCUYykvEZEfQCCC/QEGVRAEWfAGvYAN0jAdxtRyv4kMvdA+jIILr4CzHHQN67A29+WzQLuI9+ANfzsNn3INtZlMv5Z1LcoP/Hihr0YPVnWrcXO+tnqRLPq1mPmRLBmS0nqjaVu28zut1YArtsIN1rC//BsO/jsONee2b1tzMrcNf6UrtzKaHRavgdvAgnulyxDBiXu4hXulhJsM/wB0DIyrr5PgCImwCIeAlR+BByLwAjHAi4vzEDBQphXhBWEAbmw6umlguoWwCBV7RBfrnWjgurD7OP2BZRLRH1oQBXeQH2DgAjcABnqADKtCuIE1X77gSKWwCu5BC+LVG78ADeZxK//ZVNiHVRBUDfFKr9MQWB5ES2SFa2DFh3uooqvGasPqandVVQ6KffNnrDpakvI7aX4bV6PJtmx7K93wV/gryNoQwN0wDjxHDj93czgXDtdgDXX3rgsMuKXqKYIbwZj8wMencpYMDVfayYk7wccnyhIcwcmQyskgEL6AC60AuY6gCJFwJ4awBzOAAixQAzVwAy3wAkBQYxSBlv/zoh+gS25zUB8EQkSGsAiB4AcWy7pmAAY8XBdM0JyBWqaPU7C/PAc4wB81AANZsAdM/A30FVcwWwuSEAhvsAirQCi3oAqtoBu/EA1UaisGnA7yUA+gCr75IMbyOg3Xh0yTKJlnhYe79DYFmQ/I1mktWZLxO1f268cRPa2HDMABfDeI3KkyN8gieV/WKpIbPcl+K1cODMqHa9KIe8qafHygbMqDW8rLUMotDcGjrNIxnQx5yQyrLAz1gwusAAqToAiDkAd24geBYAhuQAIswAK4TDi63AJf+nfayENAIC1CQCCORSDYUtSq+y07HM08vIOCOoIi2zgREbL9gQIe4AL/QYAGtOCf//kNSbUNz4AMjQAHecBwjeBIq3AKrYAowiBfh4yt6aBpX6dL6ODPChoq9AAPtPRVC1ZLOBlhGIqKnqm/1WANI422EK22J1YNDRjagIzINHfIh0yK3hpzpY2/lFy0pTrBFBzbiEvTpZzSLB3ToszSM43bmEzTEqzKwB3cwV0MwrALr2AKqADLsTwIg2AJkiAJm3AJYLACc9ACIiAC3IQC3IQDf6fLEeEFBQt4VRAYd2ALSG0IHyJaFtsQ3inN37mDWoADJcCLEfGxQhAFOLAsFOABKGADcKAIvpCG/QmzLoEISVYHhEDUqhB7s5CFxGBAg6ya7nDY8TAO/wkKKtdwD+ywSw+Jh/nwDg0dv/Rbvyxnd6ANyChmdydWcw44t3JL2jQnc87K0bry2WUbuINbuBmcwcqw44fL47LdyaHs26Us5Crt24cbwcqgyjoN3MfQEshQDNUhhtPBNLwxCp6Q5aCQCZVACV0eCZEAC460CRyo3SUgAiiAA72s5i0ABC/w5jjwAvHdHx94A4AwIowQeetyZDjM3mDtnUrkOUAAA4yzLIszzFpQQ9ydxF7wTYUACafAEsjQDM0gbaVgCGFJB4ywCYHACJAUSZ0kDMlAX+sQQWelD7OSm7aqtTCKmfTQDjKJzyX2mXUjc9wA0p0qo7p+aZdWK/9prf/MSqTKxpm8fmkymsCbnXyfDMqjfMktHbgMrKBjbMljrDXSoEq8CY/XHg3a3u3e/u3afobi/gx5icHGIOU8vTQ2SxymMAqf8O7vnuWekAn0Tu+k8FIUdwqnoAoLvgcrIAI1gAIi8KUv0AIXEecmsItVHQUmbKhVLS+8aweosy7NzG5xUHlnAOhZkAXg+QQFq4teEAUxsIspEAVRkALU8gLR4h+b1Yy90Ay3EAy38NyPIJZzAAiPcAmFUAiXoAq2MLO+cEosa0wErdB5K5KY5q2daEI0ua5MuvRQX+z5NTcm9J9Wj1+5ufS/vis3Xq85Htu87dKmrMkSXOSczNLTfq//8Mjt4S7u8PgMbD/uck/uOc245+6TwtBiNtsc7Q7vnzDvXF4Jk6AJmlDvmUD49P7uhN9SL1UKpNBdd8bvgbADuBznAc8COFAD/hGyb66NZqnwhRp6f4BFe7AIiDA6WVkHF88GaHAGGW8GHN9OT2Do+Q3eJIsDUaAFNR/nbv7DhoAIm8DvtBATIJI4fwAIjMAgiBAIhQALRxhtz3YM1WDAjk1BGRqSsym278t98CC2O0qTJBT+eIu36koPpvL0GRSg30HJlmzBOg7ksY1KO45KhQvchpvKNr3SRX58417kc3+GACHt2cCBzJ4xY5bsmLFixIQJ87VLlyxXrkxdHPXJ/9NGT580cvSUSWQmTCUrWUJZMpMmlqBcguIUk5OoUqRIlQoVqpQqRE1mtMARQ8sLES9qvJijpUYMIR5KRBGi5Y4WIDiERPUyZ04aQIsQEQK7R0+dOHHYsEGD5oyZLFievPUCA4iQO3eiUI2RFAfVG0Kq1r0DiBEjSatK2doEyFAYQ4vtmLEjCE0gW7d6BQtG7NcvZdrWwfsXOt85bqW9eSvNrdu5dK1bnzstjx69da5t1/bWTdu1a9Wm/Z4WTXg0aM6UHUeO/NixZAqVNYfe/Pjy5MutX8fOPPp27tqTJYSOUPx48MYYOhT2K6IuXLJkvbJoKuOn+R4/gfKI334mj/+aRorkhKSSMLGEEkpKYilBBWGS6RRScuKEJUsCWcSQIITAwwUKRLhDiBZKuCENMIR6wYSqgPBCC7rmiMIqIdLgyhBECinED7HIMusstdhy6605UtxLCxzu8AIIIau6gUgcgCByjjsEYQSRSyR5BA88frwDjywe6QQQOx4RxA9IbhmmmIaWm0Yef/Lhh5940DHnnHJgS+c0O3OzUxs9q/ENuN+Ig6a45JTJjrnnuEM00WSWYbTR7axTdBlEvVOoOe0WMtNMYtD7ZReJ3KtIvvrsI3XUjv77L6dQZIopFFEgZDVBAlPCREEFZVqVk1VuCgWTUjYh5IMZighjDhxKwMD/AyCWfeEFHJwFwoUUcFiSqiGF0EoIMLJIw5AowbJxrLLO0tEMM7DoMQYUjazKiyVvKBIHGKaqKgovrBQMEEDomEOIG6SqCxBbLsEBkE7S0CGHQZCRhhpsssnmm3nsseeedtQ5pxuN9+QTuEA/Xma6QkcuFLqRoytZUZW7W04h88zTlNNOJWrvlVdE9QgknXcOCVWP/qukkkwqGbBooxG0VZMINal1VloTjAlqVkk5ZdVSJNGjhw1IEOEoEYQowQQTSmjWhRpuEAGFGKS9YUkg2kbRyTTqGgyRQAgJJFyy2iA3rXOxgOIJarVQcVkjvcD2jhtsuAEGIXDwwpBHJO9k/w4Xlo0BBi0MuaMTQ1JMEQwbVlhDjU+awYYgaBg1brlirss09jOPaYgY2bFTiGTdd889ZUuXM+ZSTGNGDyJPdUG+Pffgk4/UnD9yPmdUhxZ6aOtFCtpAAyeZRHtKujdwwAK1Rwkl70sq38Dya91kE1tZ5QSUUzjB5BI7NJhAhBaSTcGEGoAwgRcuUII5vM1ZbasBC9oGNyD8KHKAwINgDFEIvOXtRnFoQwZ1hIZzBc4vUfkR4R6hlT+EgTFgoNYN8DC5O8whCy0QggvUlYI5cO5KXsChFkwQhD1AIhS58EUwZCERXWxmZrswYhKN+JCHbMqJTixG8GgXRUjlToq7s//O6xqixdeNDGYxY2Kn2FOzm11EVKMYxUVQUZGKsMIUqGgeGtFIKk/oJ3qkQhUmKkGJ7O3xe5OIRCAj0YhANoKQgkRkIr1HifGRb30IQonS4BcKUsRkE4h4QgcugAFkYWCAVpnWUF4AhBdcBW41QEENwKAiL9xgLorJgh0gMUG87UEs4mqDG9ywQQ4CTkV7aRKGiHSHeT1CCFUowhyspJUwgCENV9JKVrwwlaw4UAtpYMQmVnELX/iCF930xS+Y+BDMCCMY4xTGpmT3spfdrmXgoVR4yDNPhEAHGe0cZ0RwUYtaUIQVqGCFHNGIkTRixIxwZIUr+imLhbLCoXAcxT//zWgKmzjooBehWkVtslEHPUhVuYqaJlzin/+wZEC3oh8mora0ojGtaQiKiSpmogpRnOIUqlAFLAJhBCwIAQMRwEAI+IcCD4yNcDgwweNwwAJqUQsMeNDCDf5gLC24sApQMkRYbomjDOayDX4DHBT8UhUH4vBxN2imtsAQhDQ0EwhguAoYpImDpDDGSD9IgbqCgIdLaPMWmAFnNzEzDMwUVhjDQGxiE1sMxTZ2i2Z6GTKSgQzKNuee5qFsZhkyDHIGgxe7yMU+QSVRgRbUjAMFBRpTm8aBThShCU2Fe2ohWlk8FBUAva0pOkq1U9wWjhjdrUd3mxOXwCqkIvUPJlYi/6tauVRBzZXJ0Y7GklLMBCeuEoUoVOEHJvSABT7FQAqEigP9FcUEo3SWVXDQAgWm4XFguANZXyQEG3TrW4Gw5Y246tWv/g0Kb0uRigh3FbpuokNASOYdqhCEIjS4SHNZEraqgIeoxCAFKfBCFQAhCW22ghe98JSnAlvYcnZ2nLZD52HLZIzGKpbEwfBFL3iRi1rMIhaxaEUqfGtTm55Rjj6W40YratPUGnSianRoknHcilnMIhezkEUrkvxP31K0om/MrRozutGckIKiL3EJJ0Lhkk+MxKQule50B5RS8ZUvJWhWmiiYJhNVBEIGM5jBBTyAgRFQwAMYLqUW8pqCF/9IqwaM+AMOaqCtNBgrh4hDcBboULdCWHCrZXFDLnXJwXNdoSowiLBVljWHRwAiDDBYnCAAYQMwtHqVoxySIebSLxyKF3LY3AQnYEGLXvSimyIObLAFW+IUwxicvJjxLZRdC1rcuBVShiOXhcxlV5FCFLztKI+n3WVt85Zqv3Wtb1nxbHK7pxU1zgWNZXHjWPxzyre1qW+zrFtUOCi4oyAFmFlV5pGkWbpEo1VK3DzwN69ZFCrdBIcvQYgV6KAHXNskHn4Qgj9fDqkYRqoJgGKtFoTBve51HA4MkQZkyjJKlfaDHi4dh0zr0g2cLsMVxvo2HNzgBi5wgQrngGog/IH/wkKQtStjEIMWZcnjVvKCvaSSBjdI4hLahYVlbpHuWtwC2blA9tXTHdp98nOh/oQoGl0F0la16qPTFu4pSqH2U1ybx29/+453i2+IHlTeqEhFKp4diybTYha0APyM+YmLrvPTPesmt45ZkXfG6zjv9Q6uR40bE1SdhOCXR4kkGJl5SXS+fJ63hCQsgb7RZ7d+TsfaCU7AAhuIoCgvQJwnTXDhsqXhQ0w9Wws+pGgXVaVgaQhCFgABiZPnTQ/Hr8N+dfnVM6jlCo7ziwuUCuk/xOVKePhDlvAQYSNFwV6PANMNDZH9P6RBEO7bySp4TYtb1DgWgL8xLFah41G4JN93/+S3mc/83DnH6j6gIK7i+ihV4aiOgjw4gqPg6q15MwXbyrtW4LuqU7Z0QzbPAqhayLqtCy1+grIck7LG07Fn07HIswkIyQTK06OgcRrMG5/00bzMowTR+zwZFD2nwQRRaJ9LmBI7+AAWYAEwQBsUMAE8MAEPOJaxwYDzahYMqIEW8IAasIr/URz18gKgEJFYMgTi+wrjQz6uYoPlSwu1wIIGiqGpeoTq64urmJc/EIqq8pe2eYEfeIEY8AJbeARkEoJ7+YNOeIQ02INNKIWaArxmw7H5WwVVKIVErAkHwTdrmzyQMqnmOrPmkq7pGYmoWQmSADP8EAkhu49PkDwh6/+ti3i8VFg8CPw7ZVM2ZOu1XouFbzK2GcOFDTw8Vxg3EXw8VBBBm3qQIXuVlUqp0cueFhyQzTMf7ymQ0Rs9GQw9z2NGZbSEg+srSaCDDbAAIUzCEigBFnA9FOiXoAgKD2iBG2CBGjiKG0CBtmkBLQAKJzGWqwACPOBD4qs0S0O+suCbTPuqtDiDMoCBIqmSOfAcMnSXf8GDIvGXeAkKdbmLOSiCLKgCJymSgwSDHWCEnGI/9ivEVjhEVTjERLy2jcqu7JIJUYAfTsi1pJEQ9Vmf7OGjoIFJ6olJSyQz+0itAqQaEMy7cdM7vqMFfmo/CqSxYEgsX9gnwvO6dbPFWyT/tynbRbR7FbJjMz1apNEziQHxIwMhiT0qRj46HzfrqynRQeJzgwqYAAnwMwzAAArwpAsQgRsAg0voBBVJARRAgXIkkiZ8nDlQpSIhnKrKAiEgFkZ4BEZYhEIYhEHwAz6wJXHJtC9sgzUIw7XwPRZxEr7wgkR7AXuZgz94HCN5Fu+LiqYSAkHAgyKYiyJBtSIwBFsAhlZkv1sYRFqQv1WwTdu8KUVUxJHkzd7MLggxyVUhu+AcwOJEu9NirdZCBWzjsVQ4BRBchRwDqFusiFEAqMPbhSgShov4BFOgDzqyD57xhKDZiErgnuqBSZjknkhYT0BKJPbknvh0BEeIz/qM/0/66AhQPAVNaAVYgIU6Ywsb6AEamIEV0KQBEgGnCAG3TBan8AC6GBsX0MajoDCrMAooFIL0CgGmKgIotAE4kJFFsIRJOIREUASyqAM0yCUsIAO+kcy1YItniQHIyUM8SAEjKREWYYo0WBJq+QE8iAIiGboYKKVHuAQR+ZHMaZsqYARYgE2/i4Vd88/aPEQe081AHEkspQmQ9M2ZGElW+U3jLEFu26jTwjIEBCg1ujuddEopW0pZsE73YIVgQAZmMIZXkIUGRIUf+636S63ogcnyTE/z5B76lM/5RNREVdT55J6NoA9TeAVdQKJfaA5nQIhnQIZc6AVgsAU/MFALkP+ADrhLD7iAATovz/QAETAB18vDGLgADBkbD2ABFCiKo2iBGigKIZgWsjkWHCiCmrOBOoiSQ+gFZnCFREgEPhiLOmgDc2lRNliDNTiDtciCFwilZfmDP8i5qMKBKMgLD4HLKBilDoEKVPOXNHiEOwCDdE0KQVucIrADJ+2FWFiF94u/2sSpfM1XLqWJfvXN3gRTVsmJVxnJLkM75pyoNLo7Kru76ZwyniS3vautZ2OFWagFZGiGgRAG5aEIWxS3cZOP1ZqPnamE8VTPQ11URt2IUbAZ5PmFTTkGZXCGhqEGPqmGbZiHnJ2Hb9iGaPiFVwiGXkCEDyABD7CADQkbefH/gBAIAaQgUhdQVQ+YQ6coARyQUKZFAaU4mxewS2kpAXWpihfQvRoogiAQBAoahGFIHV9whDxQ1jpwgzIwl7OI1h0xg7y6gSgAAvADAs3ZOROBChsoWxRqln+Ji6RAkRcpghYCGHd5nCp4gjrYBFuoTQiMUlqwTY/UV329Un7NLi0lyZNclajMroPVqCGzKCM7U3dz2CSzxdetiL1jN3arBVaIBV9gP17wBFMYLFxAhVpgI1CpCFOct1Gho/ykjzSKVEkVJ9s5DmcQDmpwGGx4mOp9GG3QmOxNh3a4B3qQh3WYBmKQ1GCQBBlYASeMgD0TAQwQAWRBwqoliiTUMw+g/9rZcwETCIG02T0cQIGkFbQZhYEasAGm0pazzYM+UFvqFQZH4ANlhYNmNQMXfVFzmZZlEYLq8xdqyTm9AIRLCIOD3L6eiy9oCoI5AAMYQpFpugM2xIEPLgIzYIRSkL9TqNcmu82O3FxE3M3O3VLdzK5N+Fcx9SjUDcm4OwW720mHiliKXeKInV0mJqxEGIRMACRQcIRYaL9WcIXDe4/lsZkv/mKXfVnnVQZoiAZqyAaclRid1dlvoId5eGPv/d51oOM5TofsXQ3WSId7UIfvjQZlWIZi6AU1uDMw8AAK8LMSUFAMGCWxWUsPkFATaFCnMAEXeIEkHJu4cIG9AIILe/8czYEBtsKDtsEmQYgDNQgGbKCGbciGYWDgQGDWtXhMfjQXm4MBx2GSMHABuZCLvsUDYOiE+qqqZUEhMFiMOaiCDO2LFJkKPLgDrsWQKqiCHcgDUfjPZjsFzL3NHN7Xzt1NVenN4hTnLju7iirdt2M8LGu8+WvidnbiGzu8V7wFDwsGYKCFMdPiLcYF5BFjmI1ZM3aYNd7ZbxBoNqaYirmHhPaHhGbohmbo2YDodqgTjvkN3xAOZSgGYXAFR1CDGSjatQwqpg2KTdLGEDCBOUgB10MWbSyR9i0B11PVGKraZT6rTraBunCDRcMDRvADOeABU5CGh8kGauiFZOUDN2j/vlm22xiYvayAgey7ZSMhJi/oBGB4hODzC2cWgjAIAhuQnCoYEdhr5jwEgqIwHCCwARpYA0mAhVJQv+jkyBvGYW/GUiwd548S2KgkQNMtQJvKRZ2UsiVmyuC9LYeqCOGVBfYYIn1yBV0QhpiF3mmohohh48o+6Ms+6Mo26IO+B4phY3n4XlbOBpvtmOEYjkAZiGWgnV3wBEdYTCOwALX8qRAYgQuL1QG6gBDwArJpJVPlJAkNmxIJGxhIqhXRAqiaFjxIAxuwATx4KkYQBD7ggUQghqBOnWY4hcWsgzJAA13SkbUgg2lRFyH5l779R0EAgjC4BEMAA2IpFkOYgyAA/4IgCAM+zAJ3icdO6JALtloPsDkhgYEBLoOLnFJYiGscxim6Bl3Ju+tPiJ+BpSRVEdkjG7LbcrwkfijDXko2YiMw5ufNgNnmeIaZVW11cgZswNmcReiExuyKWXGHZvHKJmiehZjRJu0b5xPp1XEdp1lqkAaBeAZpSAhhaIVJGIQ8eAMxaAMSuAAKiIAIYNpY3bOmFS+T/rOoPa+xGb9NfunHcYHxg4EU6AtD0AIXAARB2CtBUPNHuBsxUINRIIZmoAbKCoZIyIMUNYPlQwvwDgpnmdEbmFEgAFsjQTXnpqv4ogpUA4QRqosZfZIlmQPTrLmoMhJ/UasmtYWMrDrAk/9NwCtw/3QfSawVAzmJk0AQrBQJSUwQlxAJm6zJ0sqIgRooMF5eECeGmJXZM4aYbZhxzc5ZedhZnaUYGLcHzS522kiH773j3eiNathx6e1xaP9x6TXtH7d2ICeIbD8IhCCGXXCFTGDgN+CDPGgDGqDfRN4zD0CBJg8bSaa49kWB1LwDafmDMh/XXRYBHPBMEZChFIGBfIehAp4cRJDuPvgEXKBTFiuFQIgDuNVztViLpqqXqygSdYFHVIOrpkr0xnEcUqs+xKEvFwiCEg6DubgBE/A+qhACtoIEW6BcKH0/T5/SVfjPXzHJkAIFlMjK7eEeUh/UkRDP5FVem3GPSfX/Z2UYjulNY4LO2RkHdoiG+qiH6HX4hnXYhtxIjdIgbcnuEz/p+uCIXh+/dpq99mcX+2i/dm1vhmawU4hwhaBphAYeBMbMglIVqhLwM1LtgBJwgaJKFiGs5BuoEv5V5P4JNBSA2pxr3x/hJCCAIZtrMPA7zEIYAx44BEuAhaDthVU4UTigAzrQ8z2vlhbxvajSgii45QWa0TwcK38xgR4tIBxi7pEfefT+kVuOgh95AcLJgifJqf+UUvWzKR3eCVWQJKVRFVJ/yaBpz/gkVOdfWUiNVCRKp+VYhjOm3l2fcYmp+nWo7KefjYMmaNGu8Y7xE+Aw7fQ3bTNW/2gA+/Vf//9AiYa0H4ix/3GCuP9sB3K2R4aM3oVaAAhTlSY1UkRIkqRHaVigaNFCxAUSHUhkuUFBi5YUHkyI8IDCBZAUKGCUcAHDQ0kXI11ABFICBhAYJoQ4LIEjCJhHjxAhKuRHhw9CkGDNogVLkh42bNy4UcoGDVQhQLQAiYEjxg0gUeZoiSGEagwgOPD8KXGD6xwhOG5gFHsjDB48c4LcwYPjjpa1JaqqFSKkyB5Gl0rBUrXq8OFSiheL0hTqMSlSo0x5qmz58qfJrmTJ2vVLGLFiyZxJi0aNGjZs2VZn2/bt27bYrr+te2173TZtundrq+a72rTg0YYTL278OPLh0Jwph/+23Nky586gL0u2bLrz59O3P3PGzNmzZ8zGj09m3lgxYcJ8sd+1C1csVqMyV85EyZIlSZs27WEB8UILeHSAAgkbGGIIBSWE4MEFKHjggQhA4IGCCTCw9IIJL7xQAoRe3JGCCRrBdIMLKL0wRxqCPAJJT4UUYscKT/jRCCeciCLJHk+50QYba6BxhhlmePGVVFIBMSRZR/4hVRReeKGFXxj5FYSHXoiFhyF43BFGEGHccMNVUlkJBJle4FBFlnsYsokqbba5mJuliCLKKamkwgorr7yiyy99EkPMMcdAY5pqrs3T2jfzKKroOo06mhtr2fwGXHDBZScddpdq6pxx0nj/Gk1pnoZ6HKekbrfdddN9Rx6r5gVqDHrECPOLe+/VIot8oNSXSSW9TvIrsJNQUgkln5DyCX6SQKIfIyds4IEEJtzFgkQXlBTSgyhh4AEGInjB0UYdYWBChiXO8YcJQLCEwyN3mBDCCym4EMQeyi4SCCKCAGKGCj68gQgjkDCS1Blw8OjjGWCYQRUQRKoVA0ZPHulFFFo0qVZbcxgi5hw4aPHHHGTCQKWTOFQMRMhXXWUlTjbQy6Yqpaiy3yU160cULbgEkwxq2yz6M9Dz2BO0PI5601ul00RzKarKOH2qM04vc91zTGfqDDTdPQMq16IOJ6rXX5e2NKfUTZ3MMWgX/yPrrL64h4ssrsg3SmUDBXu3I3nn3QjffQMbSSORAI6JJpjgZ8klkhjiBgkikIsBBSKwQG1HF7gQQ7YXXPDgBRhs+4IHFGTIEQ5AZJiChlWZ4AUeL2CAQwgh2ACIvT0FssceO6gwAxlxEFJIHVAZ3CNUCgchFg5+hUEmDil4GKXFOODwPJR3PDJHGB7eIAQeJXsIxB0hR3FHTGp9Seb2OIwMBh6AGLKHHWnIzxQbhazSCy++EANNokHPYxtsVqON1SRtOMJpDnGwtilOjW1QCuQUpqA2qOZAsDih6s6pzqa2tcmqT7vQhS70pCdTjGI+n/iEJ06YiRX2qhK8uhuw9P+WN0X0bRGL6FvfIAEJwUXCcIRLViA2sAEUsEAIXriABESAAhJBiEMLKoEJUPIgz21kWwlS0EY8hqHSWaUE8SrBBb5oA0HoUBH3ut0e6sADFezODHRwAxrWEAel+AgNYGAfHsLwFdbNIQYmuEFcpMS8rXjhBk8KQ/jCAIMYwKAFQgCDIbygkzsY4g7So4oha1C6G8DAQmsZUhiqEAYwkG8Oc8hCFbBQh0UEYxjFKIYyqEEpUy1nU8gBGy7BdhpqiIqXXivNM8AWnmEOUzunclqgjsHBP82KViDUhSz05IpXmIKEkynhCbGJwhVyUxPcJBYlwilOSvxKcDJ0BA7TqU7/vlFCE5SQRH78MIMVsKADIgAd5FIggsqJYAQYuEDsuFWCbm2LWx4ACYe6dVBLgsiLIGreCy4Qgz+cyRDKUgQiBuGHPcAhDnI4gw5m0AMztGENZ4jDwZ5yxz8IIpRBuAEYhOACFxjRiE8yIpmmBAQwpOVLndyeDdJwiTmELw2G6BhetEDUtnwFI3+QmBdMuSUthGEOUZ0DHRThC/WEphjJTIbTlJEqsU5NglADDzGHeSoMojWtwXSreMrjKvRwsJnOfKZ7fuE2EHIGmrqAG2c484rAvsIVcmPFYVGh2FNE5jGhAIU3M2EJSvBQcJOQoQ0zuwhFcNaMi5iTKDhRCtGS/+IwqhAFfzQwARRwqHP75JbnOgc5KnbAIxCCULdccAGOhECfETKdvITAoZlqCEOrC0IaAsaingAiEH7QA3T1UIc4xAEOO2oDj3YEFTNgrwhBCIINbhAEF1hVqRGbWOmsVBch/CEvKCDTHIoABkEUIQtZmoNc2gs+8kFJCFGIghDuIOAA38FJBb6qKenQiFl8JhgO/lNXX/nKr5qnwt5hFYbHA9dhtuo8sWJmn2j1wWfigsS4ODGKTwxC97itVnBL8a0CK+O44anGi2UsKRwbCk0UDhP3ORxlg8XDHFaWb5zQxJwwEYoarcIwpfCDajeHgRJwCCUioMC2tpXQC3SAy/8oQME+ITJTx12Ae/u0EBhd8AIX/HEtXXlBC2qwAzswQhKM4Ekhmvvc6OahDtO1LlOY0gaooOGUQSgCoqU3h054iCtPAjB8t1RJLPV0LYh+RCdMyWiaUuUFU4mCW8hUpric66h1MeWTwucGSLhiF77IXzDUI2sIv/JPr4QVMmCVtmRkmBlz/bCs2tPiFBMbsMU+di6SnewTv0cX7AnG205ci2lPexaziEUsWhFYw+KpFd5mBSpOUYrGiqKxjq3RkXm8wnFOlrKVFdx9MMEJeWOi3pggTCn0sAILdI5BHmCBa8Ec2ymHAAP29IA9RWBPFAgBBvusEAy8kAIMpEAjIoD/oh+tchYt3KAEKNjBHgR2Z0QQIhDOja4e+vznQAd60GioQhZi/l2/WNULf8CLk04WVQ89Agw2wMP1YPCCLyW3XeADwpegJJYYRKF7X0nvH7qnpfBJ1aqmnEPIR4GLXfCiF8F4toPDHuthDEPsYddre3KBYsIWVm6G3UwsZBH3uVs7xrU4NrXvTuxaKDsXXHebL77+9RbbStrXzra3E48nxTIex5ARxWPQzYkcL1nyPCZc4SbLQ3YTLrSaQIgkZhaID/DbAiEQFw6ylZXQ9ftBAwqzByywTzCgoAMdWJ21hnsBCgDhnjEASQxEkIIQRBEFs4PEIlhUiJKfPA8p9zN1/1ne8qhQxUlR9YshCxkx/Grhpte/wR8eYboYxAAMMEhBVrRQ4LCIWitReGrpjHiHp1411VYPAyLDUIdNcEIWueg6/vRC3+ECtSleuJ3CKZxQKEQGA0pGCTFet7FCK0igt2GbtVkbLeSd3qXYsp1YLtxC3/3fqz3bVq0HLgRe2uGC2tUCLWAb4iWenYRbuDHgKTwGKEAWjx3ZvNVbj1UCflzC4bRbvQUh5k2CJiTLnW0CHWjABrAABizItoiAWkBE6XTEg0BRCtSW8ImE7IXZwkUR8cWLhvQWt4RADFQcBozA5nTAGAXMnS2fyT2X8z0fdcEBoGGXy6HBgHFF8kiPkf8MSU1ZX/vFRIjEgIb83kvBgBCcRekgXQpE3JjkVPKYl5NUHVFJ1ZYAgpykAgI2WZuAwgmhkCdwE6/0ygp9gr1hHo/d4A064ChAIAUmHra1ggvKmAZ6IIypoLLlD3v0Invo1eC5TS7cXS1Y2wt+WyrMICkgoGORAidAFil+Uwu1kI+J0zS6UCZ8wgLmmGgNgh7EgRHoAA3YwAZMgAVYgAREYbe0wByUiAv80z/12+kpEZhBxGs5yB9dgAiEQAkMX/f1Y8FtRAikngl0DgnYgCG4oYuU3EalHHT1WR0C2nURWpYYUV5kBR/6hV0cSU75xV0UkrTcwNDFX8MUUkyExJf/vACA4cALTKJFsg5eCJiAXR3+YY/1bMJoOcachMInZEIKrZAnVELdtNBQ+iB+8JglYB4nfMINlpBTToYpKFaN1dhmzJhVcsYGql2JvcfWbZ17DEOubeCMucIETiUqVFNkgEJahmJksdA0plAKZYYpbMbWfYZX8Vp47NIzNAMy9IIPVEAFOMAEOIAEWMAGFKYFRMAF3EA9pkHzgJFCoQTxqYTDcZlHbOFBKZLj8OOCeIwTEVwMBFSD2JfILaRz7YFD0qEdruaOEE+hcRzScVJUQYkXXIJdpAHD5BQedIIhpEAjXpIfnh/5weYincgfQFr8VSIeKFX4zORMElVc2MEi/zjGDTIlKF5G3VjGQGhnC62QuvFYT2YjKJ4QKDzlUzKeYr1dVV4lVm4giu2Ce9aCMfClLNyKYYmQelZTNTnlCcVlKL4iKtRnXoGGMWjYM6BGaiSogqYGL02HeCBDLChCHHzABEiABDhABMQeYUpABDhADTyECNRADYjAlBkUufQWRzicR4DZDdCjCCxPiAwJGIII+T1hCIxACqghl9EBI/QoI5hmQ86hdFWXHRLpjqyBj3xkVoxFJEXVJWwCDoBBGkRBViCPF2yMqBlJ8iCd+hyJIeTF9LAXHgjBuXgMdB4YqgmYh3SPTD4CHZyBIoDCXMpCiYmQnd6pnXoCsPjKQP+8ZX2EYjY5pX4yniy64CxwRtzFzXpuG10GFipIIDI0QzPwwq3g6Z2CUIiBhmgwgzQgKDbIxjasxoJiw2lIw1uFB3RsR6eGRzIYgzC0gihAAiE8wQYkpmK6TgRIQJf124hiAAoUFOQ4zkZkoeWIQIuiQAqAQRiEWSdVyH+lQD+Si28SH+bkKIegAB7cGSMogmk6Fx/wAWrawcq1HI/0yBrsnAskj5YAYloIQRqYySUtYkxYCZk6SQpsBfLgAH4BIvL0l1JZ1c0d1fSo6SXil1ThQRrQQRy8gSd4xmf8Ap88E59A7DPtCQiRkChWRij6ZyiWJ1TuZwkNKiwilra1gnr/skIqVGXbTdO2sYIs+MK08QIv5MLXeYamHoMykMZpREprsEaClqp2LIMygNXUFG1boSp4dKpeNoMxBIMsEEsjFALjUECHdg4FoEQJkCiY+QdLkCiV7dYNLEgIrOE+6VP41NZI7BYORNG7EJ/meADxRcEL3KghOgSdbdYiwOFp8kF0iWtE3iEdrQHzLKK8DgmXQokWaEgjxgSWTMy5cEX74Vd7FYmRNMwNGAKjPYkp8ZSaHskcPIItCAJvhk9CHsIoYGqfSKzqri4Iwc3cjEIDRgYCnkLIRmUyWlM1SeVU4sl9Iha3uZ2eyAJefYatGYMveEIitIJAeMIvjCqp8hJx/0iH0CZToCDTrlXY1DBDWUGNqULHqjCDeLiqLzytIyzCIQRCHdjAhUYA5FwEEOyelFFZiXRESZiI53DE7u2TSkTdwnWASGgBS1CZQOFAlYFIibxAR7ShDXEr8wUpdInrdBkpSjnFGuAB+PxBxHEc9lXpWixpS1LFHQTYI2zpkWTFV3RPyCAdR/ZXgZnSmBrC9bhwzd3BJTzCJfDmgRhCHQzCNEVsCFmqKVhqyE4GKqRCKywjAoZbDJ4lE0+leuKp8A6vXd7lMgSTpyroM+iCK5iC20STMDzDaISV9Vbv9F5vhbnKMcCKMVBvoJjHMrBKePiah7kqL8wCK4DCJERCJf9AwiUIwgpEQARQgCBHQNb+EwV0DriUSLeYABVtDv5SSJjpk0h8xD5lLbeQi7XgwEyZiT5Z8gVUwZ0tcCHEoQPrAQT/LUqV6xqAARDoRPKkxVQEGJkgrldUjx7BwB0IQno5iRB88JgKAcT015HQnFVQBSAAQyfIj0xOHSDUgR2EwSYAgxKiAcPe6TWZEFMCqlOeZcieZVTqLgUq6mBxRoltJfFOmFiBCmogSqjybDY872lMAzVEA2lIgzLJWoF+x3SIMc46TYUFilcpUxrDSjEQtEC/ioSxDdqtIK7MRyaAQq+Ek7IgRCkwwhHY6gIEsiAniOdQWZWFrZTJFj/+k7H/3gFL2N7CeUAnWQswZxG0ugRbnAiGuEAN3ACPMsIiIELeMmRD9i30FSl1TbBSwNfyxJSZGBEsT4UJ4wBLhcEj6JH5qB/ksgVeSIXVIa7hSsXN3UEnAEIaFGwi3ZEpAQJvggEaqMEk3Cl5LiMpgEImVN4CNiUKZYZT3ied6kJehQavge9pqEZruIahLEo7S4pvVApyHJBwSAM0UAOHae/SQEdYUdgZz3Fdqcdd/bApZIYo+srdAE4jKAsk4BAklMIl9AC/YVkEZPQhd4sgUxkVwe3A/RM/ctkFREBeqIT+pl7CRUiV2ZxUdJxNdMzQ/UVg4DRnjbJz9fQD+1kdADV1/2GXUoQBKqUFK0OJKaVrTXnFVNTFI0wavU7Fk0QMxZiM5gIiVUScXMjFHX219RmsF7zr/bnBF8hBIoyCCOGCYgnqfKQQNgVoZ/iJaFyHp6zzbAD2YGcDNSSNYe/SLjHoz6JGg2OD0kRDcMzz10BHeJTGcij2dFRHhX3YrHwQZxgWxmLnZUTjsExjHnu2DvHNDUXCsqTBgFDtQFGAhUoABbhACaw2loUO50gZlllRmO3TDaRAgxhCi4YZEbkOgLQAS25ICXyoFiB5DQBCKOc0cm8UavbtKXdUUKcyGygroknFLkOJ9FAM4QJid98BIGBM+PjXwMafS05FVxTJzXVCHqkpq1y4cAyj2tXNwRfowSDY92DhgmHRjSNMgidUk8sKrzEgaM+686Qc0KWQDacUkHEwOIQ3eF+TanDMEqhIA3RYR9REjTL9SYiJuGBRE8ZqtolHYzTamzSWk2e7ON8gwhkUyAZ0DiBTrQTUdhL9h7VUEYPIFrdgmeZo4UEpkRSehMK5AAtkLQJbgMe1gMeJgEO0wA04uSAkJE8sAvPhzgM/8Cl/+XNjV0AAACH5BABkAAAALAAAAABAAQABh+m/oOC0k96vjdeukdqrh9aqi9Opis6pjdejfNCkhMyjhcuef8ahhsWdgMObfs6WacWXdcKZesKVc7+Xeb+TcLyWeLyScryQbryPa7mUd7SUfLiQcbSQdrmPbrmOarSOcsCJX7mLaLiLZ7eMabaJZrSMbbSKa7SKZbSHZrSGYLGMcLCJbbGJZbGHZLGFY7CDY7CFYK+DXq2Kca2IaK2GZayDY62DXqiIb6iFaqeEaaiCZaSCaamAZaeAY6yBXaqAXaWAZaOAZa5+WKl+Xqh+YKd+Zad9XaZ+ZaZ8ZaZ9YqV9XaN/ZqN+ZKJ9ZqJ+Y6R8Y6J+YKJ9YKJ8YqJ8Xql7VqV7ZKV7XaR6ZKR6YaJ7YqJ6XaZ5VaN5YqN5W6J4YaJ4XaN3V6dySp98Yp98XZ95X594WZ16X5x4XJt4XZd5Y5x1W5p1W590Upt1VZl1Wph0V5V0W5lxV5xxT5VxV5RxU5VvVZhuTpdsS5NrTZFvVpFtUZBsUpBqTo1sU41pTohqVJNjQYxkSIlmTYllSYlgQ4VkToZjSIVhR4RdQIFhSoFeRXxgTIBcQnpbRX1ZQX1YPHdYQn5UN3dUO3VUPXVROXBTQG9RPnFROXBPOGtOO3JMMm1MNmpLOGpLNG5JMWhJNGtGLXA9HGRLOWVINWRHM2VFMGBFMmNEMGRDLF5DMWFCLmBALV1BLmJAKF4/KltALls/KlY/Ll08J1k8KVc8LFc8J1k5I1U5Jlc1H1I5KFE1Ikw3KEw0I04yIE8xG0cxIk4sFkgsGUMsHUInFDwpHDolFjkhETEgEzQcDC0cDikbDigZDCsXCSUXCycUBycPAyAVCx8TCB4RBh8PAxkPBRwMARMLAw4LBA0KAhcGABAFAA0JAg0DAAwJAQsIAQsEAQkKAAkJAAcJAQgIAAYIAAoHAAcHAAYHAAkFAQkFAAkEAAYGAAcEAAUGAAUEAAQFAAMEAAgCAAYDAAgAAAYBAAQDAAUBAAQAAAMCAAECAAIBAAABAAMAAAEAAgEAAAAAAAj/AMsIVFJjQoESRHrQ+KFESZsyYORYGQHmTpmFFwO1eVjmhw8bLVzYiOGChIeTHlqkEDEChUsULXzAYOHHlixdvZBlQ+bLFq5bqnwl6mFkC5UfRoyAWbrFCJWnRp9+9OGxBYwaNWz82GoDho2uXmHI9Poxho+zH1OIjbH1h40XcF3IdfECBQkSIVPoTXGirwgRfVP4oLKFjydQrXAFuzVLleNTkEeN+lSq1CdSlUllysSJ1KnKpz45UiQJUmlJkyhhunRp0Z9GnTplYsXMGTNmyXIfK0ZM2K9dsUSJqrRo0a9mv9Kk+XOMGzdr1KRJjwYNWrTrzapDa8a9u3fvy8Lf/659e1kz89ylRZO2TJTyJjc4MGDAwUEFDiukqOEjaNOwZ89UI2BuzCBjoIFddFRDFyYY0AARRDSkBENtsGHEED+AMeEPbdihRRt8aKGEFj/AYKILIcFAwgghWQXDCSu2ZNVWI+iAii23BKMTM8Pg8hMst2yig0cxmGWDEk9h2NZRMtlA1Vlf1UDWRyZWSQUbbHjkgxBE2rAFGGyAUaJacL0gl5lyuZQmCSi40Nddf52wl5w/UAFGIJq04kovw7DSmGOPnYIZZKBBRsqhhGL2ySSOSCLJJZRIQolqm0xSyB+TbCLbKLzkkssuucQiaiymCJeJKJZUomolu6Tyh3J/RP+jDTfURKfedtZhp913vHYX3jLjlWceeutJJ80zvfyxww45qOCACh9kUEEFHxzBhSB+NGLLM9kIiNuByBiDTBdKGEFuDRUMQEOCXWylhB1Z/kDDQka04NBDgZQhYpUwuInXinN5VeIIHoxAQpUjfPAIjr0EY4wxw9iCYy2w2ALFD0V6tdBWZ3F81otiffTVyINtYZSWJW+BFpEusLWUD3ul0EILL83lQptw2cVmXzACxhfPMWwhxx2EaCKLT8PoMgsrrKzi9CqQQRZo1KCpYoopqnyy2iWZYjJJplxbsjUmm1iSSaqrFtdII8W17fYfi6Rxg3KLUJMNrepdt1121vX/+h16vwY+XuDoVSNNNdFUM80zxlgCHw44SLHCDCpkwAEHOJCRRyGFWPJfNcgcI/oxBhoD5lJKEFGCAQv0EGENDJVxhxVKkGsuQT+U0aEdRMzAgokwrujBijDBBIMQJ4QwwggnzNTCCBvo4WMwvlQCySs+3XKLKb7o4aQQH9HwlchQdmXVVyaClX6dVIzs/khVougCDEpRgULzI808c5s30/WCDTdjE0yswpeYnUAEB/MBGAjhCZ/4YhizuAUrXvG0VajiFIC6YNQ2eDXHWCY2ZMPEpDaBiRKS7RKbKFsl2Na2P7jwD3BQDhxiqJwaauAGOBRFNmaVN+rsrTp+I9yv/5RBRCISThnJUAaxpiGgxE3jic/ghbKC4IY4JGEGOODABDjwgR3EwQ+FSAQpkFGg0ZHOGEpYioasYIQIGMAEXYhQGexQhi7Y0QrtaotbfmAFPNTABCTwy/I8cIGTyKkFJ2AejGBAsypZYAM5kIUvGjYMWujiFjjSRSp6IQkaUIFLLmCBi9IHkhb8LitYycrM+DW/kNzMlSZKgVxo5soA3uVgc6FZzc50MzVVSS998cBfhJkCG7ABEaDARSs+cQqKweKZsGBFNJtWwail4prYTMUFD0WKTXDCEpa4RAlJOAkUkjATkGiha1xIwxq6Mw07uMEN0/ALbcxKb7vy23mEWP9EIiZRGePJTRHRM43DGU4a2Tjc4hqXBji8oQ5qyAHlHDCB+yxhD5xrxCiGUcZkiE5DcqDj0GpggAiUgQUNaYMSBtIFNtTAXvWiQQ1YIAcGJVKYBEPJ8NRyAg/IKQYABAwLWGCBCqgAE7YIhlJ3gZNL1oIVumgFUcCHyBPMbKgz68vvTJSVr1ilq1LqV79qqb5+uaQFbLplIGMwwJeo6SVxcdHMftZTBPrMmAzERSEawRho+jWarnBFBR3DtGsyjWkXLEVoOgFOTY2zE59I4SYysc4XsrOGTXhPGpqwA+VoQAbKSUY27mYd7ewtiEJcRj+LGNB/AmsZzlBcQQu6wx3/CmgauVgEHPIwBzIEQQUqaAADJpABFXghD3/owyJyQcZk4OZLdjhduRZgAKzgcUJlwEMbiECurQyhBi9oQQdaIIdBYmAEIghBCP4CGKsi8kU/W95QKWCBDwhCMcEYhqd00VSK+WIOHgFJIuXEM55ZZS7oS59Zd0nW+Y31fnKS2Yr+VeA2vdV/aOJXzIQZpxTEgA2PSMylRjGLWfwVmk47bGFToeJXvIIVjrnaJ7SGidh0ghOcSOEnMrGJSsCwoTPMQwyXtawmcBY+8ZSnBjTwB2fscB65AqI+X8vPIubmylhWIjOawcSCSoMa0+DGPLSRDWtYo1vMEMUM4bCGMXxg/wLCZcB9ZICGNcyhD54rEDLYYIXogqlcq4sAVhL0EDzYoQti4pgRSGCBDlxADi24QAc8gAEOh+CQzQOZXkTAFxGYUgIWyAAabqLUXPD3kvyFBTAGIb4XLY/ABc50v+THL0ae9Sv9U/As7xJhlqTI1jDCGZpecJa68I+URfIBgUmgF2NSAhXAeGAwIlhiE/uVFa44rIsn6OJXPJMV2oSxKS5Twhl/ghOUQfdmGtFOICsnyTcgMg6TvGQNVMLJpNUbao2o2oH2G4lYDngSlxGNgh5UOvNIODfseeZuCaMQaUCDGM5QgQjAmQEOsNwKyFCHzbmCjGxoSlLYIAc2KMECCv+gARsCoYRAyEG7dsBDydlAhREU8gIXMAIbWlCwno5ARWCxQV/cFBiZneB3HTDBDKAgC2AMI2mn5i9jguEJJczPAxSgQCxlpj9Sos/BJzqrSPo1sqO0jDA/UIsQVNaCIhUPJnRBUYtQ5Fa8UOlFRRfLVwDRwKc/rBe9qHa1T+xXaz/zxSzW5rjPnYkbezM2OC6FKxqx2Rq+UMjvzHy9TcHEWTXjOqDnjjOcwR1m/Gr0qEf9M0a/+tvYxrm1QX01Risg2htrPbWihmyLAYkl3AAIOtBBtCrAgAMc4AM8UIMfDtG5YFClKGAKUxtqsIANkDxDL29DyZUghx8Q8gIUIOT/Ce5wv5SsSE5VErBceMZ1q3SABTTQgSaeDvWo52IWwcDFGYiAAhGAv3y1ln5dMT9OAkCBJD8z01UeAQNANRIeNjSL5iU+IEBtFWzudQJi1zyB0TycphZAZQSEgBjA4HRQVwu1IHgldoKG51cvBm5XwwpYQwozxgmZYG7mFhuKVQjwJgM7YGQ+KAaZ9x5LdgO/ECB3E3p/Qzixl3pMaBsBJTrONXpMVHu3ZThP5GVfNnvTYBuvAAc7IAZM4AQr4AAO0AAH4AAfoAJPgFGKoAhFgSVhgiUlJwENYAQT0gWGZnI1cBYjQAHndQEEQwFyoAQmMDzLAxj8gkhZ1RdVMi8d/yBTOmAIwJBfusAL9mdqw+AHROACHtABWpdgjOQiAbN+XhEDiigS9yNKV0EDdAESeBFh/eIDWOIDLnEXtahWWVUzgVRgP6MWcvEDRdMKIzgMi6E0K/hMgfU0GqRYV3M1hzIKpGAKh/IJZlMK3DSNn6AKpaCDNyADMqAB8CZvRDaOO7BkO3AMsXU3vBIsrXUMweKEuBFQ4HIMxnAMBLKEztBlPQRFT6Q4ilMbwkB5ZuAEUqAD0lIBGdAA+HEDZrB8dWIUVmAFpwMGLLAAHZAUiIYUXIFzWEdphaR1d8A8BMMziThAoegVNoAVI8ACR0IH+NULlhh1/GUMkgA7nWgBBP9YVvGTSxGGgXB3M6o0VCzQimiFSAdjiiQgF7ZoF/ezPLy2fsFzflZ1QD1FTPMzBIQQCck0gsBgC8ZoeC5WQRZEKBiUQVaTCtIYGpbACZ+BGZnhGaRQCGKAA97IAcsyb/KGQ3qJQ0v2B7kxDTsEHr9ierehG8ZQDIj5MIeJmIxJDI4pDJApDMTAmMVQj8UgOs6wet3BegCiOMbyLcHwB02ABk/wBDSwAcCFkCqAA2pQB8WUbDGgd05Ch7CTkh5hBDEAfhiAAVnHm53oAXagEDbAAlKyVScyF13lPjWwPEcyBaBAjIDHCzHZC5U4DK0ABIhkARfAgBmzFwzYFTEDA3z/cUtqIotyYASw4xEvYIptwn5tMhIW9hLCszwsUlXLUzwkwBI5dRI4g5WIQAmt4EC2UAuyMAuyIAuBBQsUFFgMKlhimUFNcwquUAps+RmK1ZakoAqk8Co38AGX4416mZd72Y1LVgnIkAz45itDFHDhwphPh5jDAJn0p1RK9Qs2ml+80ZiVaY/OYB6EiXpXGA3cASzVwAyZsFlkQAZOQDkr8AH3sZomMjMo0hctsIckoAAX8APpaQQ2QAEQQAG6KQFZJ2kdoAV+VC+mBDJD50rvk0oFoxU68AiTGJ2AF53CMAzAMAYscAIdgJMx04sMKJ6wCDx3ERIoAAOI9lJY4QMv/zBrJcFsMNIy/VIXt0Sf9Lk/KLA8B1Z+BINeGNgSNYAHeEAIj0AJoCAxNlFiB1qgsHCgrrCqBzoLKgirBZqCp1CDULNBh+IKmyBkOKACHJABIDqixEqiGvAKZBRb2jBEAMeih/l0wtALNvoL0lmtnXJq1IkTdRqdvPALd7qjsKVa+Eh6gEN7ydIEToAGUDAFTaoCFbBFB4RAbDJLaBEBDcCSaCV0OCcB/EoB/CoBEGABFsACfEAQQ8UiGngCs1SlyokVFuABLFkDLhkMdFqnvEAMv2AMgvA8fbqwarF1dOWd4llLckEDpiQ+rMg/N/MXGGBV94kCBWOpTskCJlA8aP/FPPIDsx7ZAYPUEnIQUnwwCI9wI7iAqkeDqhJTYkiLqkXrE7igC01rC6rACargoKtQWKewCpMQcVkkLSrgjTKwl2ErthxwQxmLooApcB51ZS0ao9R6ahTzCoIHCyVGtyaoPdqjCyZIC7XAC3c6DJf5T0pEcPm4hfnoDM4xWshQCRI3BV+gBTPwAU7qAAfEbHchPy4AOyawAAM7Ai6AcxgAsBAAsH7oryexARtBA7+zpy0AQK0LA2YiU1GSkjUgAYUEAz0ABdA2SXXKu8XAC8bgCTQwAo5mVsz2scAUSHrxS2phgG3yUlZVA3F3M/SJF50aIzpzFznFIiwAYZlaMMT/w6cnkXU8G7NJkV38cQiO4AiQMAmQsL5f475r0wiQ0L7uW7/4W7+XgL/glAkMugquoKAwtgqQEHFBcDnF9bVgS6x1uWRpALjGkI/VcGVQqBtndJjCoFTUyRhMU2Le9kx1u7S1oD0pmLcP5HfJMKTKYCzP0I9hlrjV8Ay30AdLEAVYgAU8UAJc9DxJGTA+YAR7FAEKsJI2VzDg569jCqYncQE0gAdC2SJqIhdRehXpCUDMU6VKAAVyOkm+0MW9MEnD0DCwoAIlEAEU0Es2I3eJ1AJbMXb8Y2HDJj9mYmFO2RJuJZ9vIl9YNVMmYAI0ez9qRUiURjCFNAI1AAZxgAeB/+AHevAGjkwHejAHeqAHdRAHc3DJl1wHmlwHc+AGnPxQc8AEZrAGu1UJsNALJ0gLdRtYspAIbGYGOyADCjyseokDYvuNkGAMxPAwhZkMJzo64NK2fvcLOHELsFALNiELyNxUX9zFzkyjNNrFDvMwyCDB/Sgg2JzNs5cN08AMndAHbqAvSlACE1ASLSESXVEUG9IBBrCSHfDOWeevYhrPOCdpJzCIfrx+tmgzoiSlc6xVNjAFY+AH0ebMXCxtueALYpAB/DpAAyYSacI8Ueq6sGsmFCh2N9PHJkCfSafRKNDHnWqpfUyzxEkDJlACJSCzKAF+HEm8JqA7omoHdkAHdP/wBnEQB2oQB21w03HwBmuwBm4Q1FW0BmpA1GegBmegA04gBmgAB5YgC71wC7Qw1Sb2NH+ABhIXyx8AtmFry/Hm1d3ojRpgCrzxMM4VOmhNOsH8rMQAuBqsPa96oMsMeAb9zL5Ao4DHX/lFzczQwk+kHld4hdIgwYojw4IwkDowAyvQdS7wJEdBBUNwFwuwACZwAQLbr/1KzxzZAT9QXiYQQK+mP4j0xK6USCNAA0owBk7QCgfdzCdMC5lYARYAAfKZlAOIPjYwBENAFbHpPzBrMDFySzXrEsQ7Ahttqe88aTL7ap7LpSSQ3MhdMIREX5PGsw5hB3dgBxyxERwhEG3/oAZqUAZf8LhaMN5ToAVTcN7pPQM6AARAiFS+oD1UDQuChQpzYAZowARAIAMcAFwLDDnxhAM5ENZhi6PUHDr0aEaj8zC84Zi8AZ38ZW3KfMwmeMw4Ac00qgu5cAsbzuHBwJjuOCzowR361gyF+0S8x1m2bFVhoRVIsQVDAAM/0IcJ0AH/euPx3JuV1qcmwAYs0BK46CIvZUqiNBd7ypIJMgOU4MW8e9eHyQvBMAkfYAES8Gtj17rmc2AxkSYoUBcGc4vau9E8q9FkLubKvdydOjOE9M59fHQm8M7L886PxOZWIBACkSB2budagEePOwVRkAQ90ANJkAQ6AOg9MAWB/64CK4ADS2AGnqAY8r3KvCoGTSAGQBDL/Q1cCnwDYG3LdQkHEJOY4sLgiqngh+ngiHmnFKs9zmTh3MpfvCCtwfALGiydnsJU3SoMIJ4MK/or3mEdXeYMsSA3N2BKWO4kg8GlMh5+C9AAEQCw/PqlOQ6mu4lzFqC59KmKWOHiNmCyMgWVxJnaNOAHd90wNtowECMM9zcDG4ABSLEUXPoVYNAuCQhAjGRWxtZL+HnRH93Hd4zmTqlLMAumJNDHJWDwG7ABJfBICd/wJkA7P5AgDVFH+qIFtmMEtCMhEAIhPKAEge7xPPABJTADPIAGpYALwHBqrG6gkgAES+AEOQAEv/8quTQ/y1xdl40AMRDM4JQp6gxOf4BbDEBPnRs8wtq6rUdfp6fmKTDpKX6LmMRgj4MLOKX3eQjVLYvzcHlw5OlzFkMwSxcgAR0AAQnw7BHwpWI6z9MOpmL/Az+uVSipFUDsFi7+MQKzUkpwBrJAsbNO6w5TDMJAC8AgBhvgAVuBOlsx90OOPrH5EWnC5RZmizVwIZlas8P90QDPIjCgs9/XiR2wAZ/f8A3P8AdPnDPFEPNCAxbfEHbI8an0+jQwA6lfA/PySIq+BqzdI5d0CydI34og4BK1Ak1K85Jr894IrJ+VCvRXmTzf8z0P9EL/dPkVxtKcrSR8Cw0DzRB+C/z/ta29kAtPr+viMh5MCCAtzA2jxc3P4AuNcHTp9zETyJuhSwGTDQH2j8Rrn+NiSpx+DH9g5eIA8UPgwCEwbBj8oURJD0nAegX79StYMGTGhNHyNWjDhRYtYNSoYcNGyB8jYcBowcLFShsvULhwiYLETBIjbL50gUKniREmfPLsYFOoTRIoRgRt4fPohQ4XLlhwesHDCKcdPKBogeJEB58WNnQoYaJECa4dwI4duyHtBq8b1JZw4CBDhjitcAGzNUuWLFerVKGa80HFBw4VMlT4kFixChmMG8vgwGFHr2GVixnDXHlYMc6cM1cOVtmY5mGYgz0MPWyiL9atW/eCDVvX/y1dd4PhkjUrb2zUwYQJi8hLV65csYgR+7WLVSdBe1h4ROijhY0TFDBQuCBBe4IFEiBQ0E5BPHgJ48ub/cECJMmRJAfWoOHChg8b038Y6aHDD+tfvCRSHO0WWzCxyqMaUmrhQIEOZKHB6VwgIacRdNKpJpquQsElE3byicOeRvAgxBCdssCCnjpQiycQnQqxAxPNYnEEEpJq8C21zCrrArd25JEtt7yygIEG5prDE1A6mSRJSCBppBFHmIgsAw4mmEuxxQZ7TAYNZEijtM0u+4w00ibijbfTaLmFFlpeeYWVVFIhZRROMrGkEjuXZJLJRRZpZJFC/vwjUEEHLWRPQ//3ZLI4U0YJ1BFKToLBBx9Qos4DDCy9TjwFEhhPvAswuKDTqkIc4YWSFBJIpBo+Wg8kGwai79UfaBjDlmB8SW001XQ5RZYuhEKQBZE+EkmkFk5YaSUKZWK2o5mWfeGFnDqc1qwWhPIAR7JKWIHbGUr44QQQZzSBha/IyhYraU2gYYZuV/jJBHh9QovbFT4oQYV71fpggxUcmGACDgxxpJCCE/mjkISbU+GwCgwz7DCJ58rAgQYm0CBjLivp01CFB4UDDkJHDhTQQgvlExI7K8mk5UxEgVkUU1KJJRbidtklol9+I6aYY4w5JhlmmHGm6GmqQRrpbLLhZmlhKjFFlUv/DBJJUhhOuFqEEDDgeqoIFoCAKQo6ENWpSz0g4QRkBeqiCyVSXdXA9V6V9KCQbKBBB0980WWiYIABBhfYesWj3I6eg+GHu1N6LiWZnk22QqxaeBbamFD4ySYTKC+KhGzB2iCxuTjIoFsX2yrhxw1M4IoFzE3wdywLUv+xgoAjaAD3A3JXoIEGGFAg+OADOKD4Nfzwo5A++sij+ebRED56IRuIK66AGaieAxlkyAOONNIQOWFDVbZE5ldy2cW/3ywD0xhkkGEG/qHnd4booot+Jv9p9ue/f/6TBmA1rGGNpRXQGtUoIDIsYQlWcKIQJ5hPsVwwFA/EKFsOWAB2yhMV/+xwDQM2OQHj3KO4ZDGucTA5yEk68hEalMAPm9jEJ0iBClR8ohOc4AQkUBEJIpSLBTRgnbDuYwTF0QBBWSlKspSFgpOsZEM6gYm0XucTF2EHR00p0QQiZjHfMQB4XizeAQYwxgGIkYwFMMAACkDGAADAjW+EYxzlKEc35GF5dnReHuaABiEFTItalNJgEqOChpFOezJowjAq0r73NRIZyRAa/Yo2tPrdz5KXtGQ0NKlJaUyjk/2ThjSoQQ2k/S+A1SAlAgc4SgRq4xmiqIQrOtGIQlBtWDWRiqU+NRWuUKA7TIkKqDx4Ns35kAYgiU+y1OagjkjLBSjpSEdopYhEOP8CEpKABCOYlIhEeMITZaABCzrQIJ+wIFWM64iMZoKtEX0qVE8pEYm0I4EIJMAABSiAAAQQAH62cY7//Cc/z5gABSwgeHEpKBcjEIG4LPSPDnjYBBjqAIZ60QFoaMUg+vCxOzZvDXMpEcWkJJjFfEAu2rsB9xbZPvcB7ZGQhGkk6Tc/SmLSGc/YnzOi0QxobFIaPRVlUKkRyk6K8pRJI2A2BmgNUh6NF5WQRSkakYg+SKgoR2kKjDplAbItIALlwU4wLRUCD5B1KlT0SU10OaqeqAiE2EJRBt7QBz8MYhB+qIMflteHREgCCuyCzw9r8MNw0uCYhnVBR6JoFBlRJVT/2InnE3UyAgt8bQGXvaxl45K7203AeraTaMRIR7EPrEAtK5hBB77VA2+1kF3uEotavjID2KVuLKi91wooNghZHMIQjBDEH/a6PDT0KwM94oBgkisYFURMBTjYgSXih5ljvI+6x8Bu0GK6XZgqw7vMaEYzljHe8YbXvMswr3mh0dOebjIaRB3lUIcaSlQiMBtIo8bRqiEMSKxCFpMIbh4wmwACE/iyBS4wZh3wnaZ8aphnE1FZJBAANaKRO93BDi9JFJXHUoChYpgDHfTgBz7MYQ56YF4iUKGIMfzwh4pD0TjDOZbNeQ5DVJlKBaOyFKYsBUfFPIqIPvcVs/ALX7Ar/7Jb9NUvtQCRBUAZy7e6VYNuxbZEZ0GLW1Yw5TL0wLhSooQsFKEISQhCEMoTxPLMQDG3ZCAxyR1MnFUAsAxA9wa1eMZLk+FI7UJSGcxYBkzHS8maXrIZzjj0oe8HXkXrdJPtdS98U3nU+3qyGtMoBtRwMQlHKGIPcIBAqDF7WQgsdKFehcA8gekpDwbzUld00ULnGdYMf+hzVmnnBRgahBCPGK914IMf8tCIwA1iBkAUC41NcGwk02BFLHpshz/l2KrAKChYhdFTgAmVBkOFLRMozzxnZxav0PgEL+jJk1kQFq7QlixnMQFXsVqubWXZXypILihacQgyFwISmGhEoP/6IIbE7Oi4oSOpnAWmPRykwRjPmB8kaUrTS+bP4hfH6f4u7T+Oa3zjHi+lKY868mwkA2a+6AQkNpEHMaABBR0otQSu8x2wzloCodJOhzvlKR2zlasN5iCLshUVC4S1KnHBwRvowAc98CEOItZrIWrhC030oAZEPoprDUsWEzAl1z0PK9pyKRUQUUBE8OS2eCxgc+9oJ+ahpmcELADuUlvABBXMyQmyxa6xrHssKGLLz4vOFAtUwEeBb/MHciCLVijCEY+XBS5QkbA+mIGQboFzSRMjgxks/AY7+APGb4pxnJZ+GvrjeP5KOfLVB/C+Sbvv61l/adIX7X3FEAWvIDH/CU/sIA1NgLl3wKadCKTa7V+VNT2J7/Z5Nh+sTjGP87+zc/GEp+3ZsTvy7KoIPOBBD4MoRCJUYQxZ9OEDXfcOBMK1oxK1/wI1eXm0nWKTqRBFbSdYp4hANBQQ1f9z1Mm62DoXs0AbCvGJIZCJEzEtHyqBcJqBBsGiC+i6wquAtpiAjfCXDaADX2g8RnCEScCFTbgEhSkEMdiyE1wBHECtGWBBHLgBHFDBFNyBG7AE0sM4/Zq9angGHbRB0oufRsIMYygGMuEFXiCONWGFRRGFlqmTJemYRPgYQSmERrCET7gElSuEJggZ4xM+uCMPuJs18Ki+8Si68eAwd4I+6isb/1EBFfG4jgi4ADwIhEFQhEfAAzvgAzNLBE4YBmCQhGMbAQoINcX5FreAERPpvxHBNRzhqqk4ASZKLP4TChyBJyySgBe5shJ5mLZwkc+hF524FAk0i1JhnA5BgUuEACzaAMSgEnzZgBEogRnIAEMYBlQ4BEhwhESYhEAxsz9oghNMKRlYAULSFxZ8QR74gBnIgc8rhR/UFdBYDdm4hVqohVmAhSSMkzlZoElgkiYxFG76E0AROObJo3J0npBxnjkImXUMmTUQAzNYAziYA75yBE/4BErYBEfoA3lMP1ELtekLj517J1fTpUsJgYMMARHQGrLiGp3LJQ8QgRMQAR2DSP9MARW50wPfYoRBmIIeoINBMAR/84VhaIUzuLv0c4F1M8Sj4KprwarsIEPCi5HGogqr+DHWIRHzuDLCKxHzeJgMsIAMQJG22JGm2D8ZSQEICAE5uAMEfLlV5KqHqYB7OYzUCSkN6ANZuIRE2L2pCr9CSLMcGCnCUC7mEkZhVMES0AEmEIM9IEc9Mse4bJ45cJ46qAM90IM6oAO95Mu9pIM4eIM4AMw3WAM3WIM1UIPEVIMzIAMxcAImgMwlAIIcyAEYhEF3GUZBEqkqeS4/0ARP8AM0QINB2AKwSjWwUUOZ65qusUgPgkiFTJuZUMiGFKtdcsSJhDBMuYC6awNCUAT/RtADOtCCj6SmRYAFZBiGQ2AL8gA8t2A3qTgWuGq/n9O2oKAXsBjKEpGtGGs/2zE8KjGMCYA7CpwLKjkMfnGLCmiADsAAhRSBUAOEUNAEQACEOwAEO3CRrGKBezmmGdCBhSADNOgDJWkEjmkSbhoEQUCDN2DQN1CDw0SDB3UDN1jMxJwCJSgDN3iDOjgDBqVQxfyCLyADL8iCLHiCIygCHlBRFcUBFnTRE0QLfKmXsXizDdjMG42M0ZoLqfQjP5qohjJPwnACvDIDNDgEHiKbcLOOTtmg8eAaoztD/YvN/sOlUcE1IRtFcYGrS7SAHvBN4NoAHfg+Q0iERvgEzAAF/x0oAQuAgAtcLg4YwBKAxXE6tnWrvwY5gXwhpLVos7kInRIYJEES1MzcsrBAAcOyTBzIgSAIAieIgjGAVDKYgi6Qgy0QARB4ABCIT02IBECIhEjQhFAghDtgSkAghECwAztog8Qsgzgggz3QBFnYBDyZhEaABEUQhEE4BBzYFhulmD8KGOvpHT+KqOoBmB71TqlUVtDq0R6NAB81NWPdLN+hVi+yVi+KnjDS1m3l1uLxogaQATHog0cAhkj4FvSjObDylHcCOqNbRG35CRqjnaKEtWsbxaHoAO2wgBrgN0d4BD6YQ10ds0mohVJIhEItPEIdxrEwLMOagR7IGyjogf+EUIK2UQIogIJHPYONPYMP1dCni4PgxEs62EsTq4M5ONmT/cs4aIM3mNDDNIOYPQNInYIxwAEe8IEYAAEQEAIhCAMh2NmgBYEwQIRIQARPpU9SlQMwMIEJqKy48IJ+VRJLuFVFOIQ8sJgFaACDEh5sDR6vPQDpER5tNYBuLR4yQtu0HYB+Wtt+ctu3fVu1LaNt/dpvpR7qgSjD0IAclYEl4KtWAIZhAAUxSK5ndVpuOx33a863CIt4RYstc9F2ObZj6gEiaFiQqFwiUAgl0IIuKAOL5dw2QARGIF1DsCtDOITwmwRbsIVWoARG8AOow0s+YDo8INk4sIO/pIMJdVD/NWiDNiiD4N3YMcBYjM0PHUBe5GXBExQkJrNRX40YilFWz4JWhgo1ChjaMMDUB+DeB0AA7kWAMAiFnwUEIShf+gSEMIiBLWADiZqBOAgESZiES+DGA00EODCjMXJbAIBbfwKo/wVgN3JbuR0julWAa6VWYw0Y7wQkDtjbB3bgHOUAx4CMG2gCMciDScCESWCEPpiDNZCCMZiC4P3d3326VLWD7lPhFe4+2kUe2g025EGeQJBhkDzVQMBhHAZYFu6+MmgDOXiDQWCER3gE0z1dMgVBUDgEPigDKJiBZDxB513TD7hRHjXcYLUeLDa1ifrR6sFbagVjMB616NkUAkMA/wjgWe3t3u/t3kz91BQABE0NgzAABDi2T0/1MH+Jg0fQBHzEBErgxkLYAQDuX7YlI/4dYLk120UOIzA6gGu128/KmIxJru15QejagSUQg3dEg3iEg+bZqzP7yjJVmU3AoRn6BElQBEPwg+CkgzdoAwqd2eLtASDQgeUdRip2GB7t0WNdYNuZqN8BHjKOHgMwgN7RAZA8BN8yBDMT5T6QgcOwGGI+AAMgsOKTqB8lZoNC20Le3wAGZzkKgO/d2Uz1XgQgAHPe2UgY3/SlglBA2jtAhBcghEgAg1SrgUv8AjXQBFy4C2BoBcJ1AG0FnkemHocKrQJmZEi21uqZ5L3lW/9L/rwdaIKK/h52tKO9+oMzc+ZwDEduGjNuSgRFaJJGGDM+KemS3r1JqIQFcmlLoKU/YDkZUIwdsRLn3dEJwFsG8NYwvluL4aIvJmNuLYADiAB8UYBHdgAZcLxlXmawJFM/UIEuCp40WiO4HQABYKN+Cueu9mo3SqO0LQByPmdz7l4h4F52joQw6FR2DoW35lRQlYN6ogAUuLAuANU6WIFHYIQpoV7w/AAVxIEULQIvIAN5bAJNNoNNRgPvwWjhcp7lGZTJJhSPtmyTuezMtmxwRJlD8exDsVWVWRmWeRkTy4M6UAMdUIEZ5dPA2+VgVYAywh6K8mLfuayhxqduhlv/NDIACisjB/CD3+y08BPpPmCArebq/S3ktjVk5vZt/X1uApbu6X7k6i4jA8Be8EUANlbnTKXPtn7r8AZVTdAERKgBBzCADrgwCQBVMFiAAsCAFwCbF6iBQIiER6CE/Nbv/MaEBcqEqTpQkq7Vkj6URFgEkYbCzObszE4Yy55scSyZcPxsz7bV0X4ZmDGFmrEZnMGZnSEGxsjlVQSYLd4s2vZpivodvKWoYAbj6LGnsi3bMIqeFKce7BGYFQhuULAF1wgcSbA80rEdgBHyam2ApD7ggm5khobkLqIeLXrgvZXoHaBoMbjoT5bCMq3wTBgFUziFTvgEUECE7cXU7e5e/0zdWe4WWp4FWp+tzx9oCl+Cz/mkAk65gAUosAJ4gU8lb0qQhPuWhEeABKo1UD3JE5RO6Y4x9EM/dEOp8NFu6ZaJmZnR8Jrh8JyJCJ7pmew6Bu8KL6CSBk2KrwHSBmvQhm0wdW74hm+oYtD6SZFCOH1ZQWUEAlvOAf/UgRq49eR1WMOqdRf19eUtRsidgQm+gUV1gwHthFM4hVL4hE/YhNDcAUWFwRu4gUYVgzEwg451g0/eKz8wM5BUhEC/BE4ghU8ohVJwBd2wBVzQBV1gDb+ZCDGRd9EQQpYCGmZIhs9ohRBI5+0t83/fbjI3Z7JmY/PtVBKAgAUwAvm8A+4ggP8F6NkFuAA5iARQsPjWBXNAKFpKuIQFMoU5eRlTmJk3mXT04fBLP47j8Jmg4fROfy+jIiBtkHlt4Aaa5wZumIecnwec1/mez3l6mId4SPV4IPqipwd7kIekV/p6YHp8wAemrwd3WAcnoHrHnEwcgEwmuPpE5Xpp9/rLdNFLxoFZb9SYLdJO1tAQg7q6sit+8y1B+E1GkIRLwAQ8sYQkwYRLQIVW4Pt0rwVZYF1/9mfAARzc8AQ+lwRK8IRWGEnrcqTHh/zIh3yakjhAIy9paIYfBAUI0KcHCAPuDVqg3dk5FnjvHXOe9Xe2NngqoPhQiAQ24A4MgICHX4AAYINQsHj/UAgFfxYC2Y+BSAAGZthBpWGam+d5n0d+elD+5b+H5nf+54f+6Jf+6eeH6rf+6veH7Nd+7d8Hf+j+fQD/f9gH8Sf/ffh6IFgCtmy5wkRZt0SeXEXduH8ESUh8/ibvzzSS3Kchvuf7vfD//wcIWQJbybIlqxWoVgoJtjqlipWqUqgW2jIoa5ZBXBo1AgOGC9QhMjx4EFGiRYuaOoIkyRqG7CVMZMyYvUyWbCZOZs528uzJM9q0adWGVrOWjVu2as9APUDg9AEIEFBBhAEURkiYUJGcImgK9cFXsA/CRIpENpKQSKEQYaAix8eCAlbgLlALKhReYJFAcH2QAhCwatoG/2vjNk/bPHqK7zG+p3hxY8b8JlOubPkyP3+aN3Pu7Lnzv9ChN2fOvHmfP9SqO7Fu3ekTqomxJ7pq5cqVwNwVBeKW1Tt37tu4hQtf5cr4quTJfSd3JVGVKlgQa8FKZT2VKVPRYb2CRes7rVu3dGn0hcrPhwYHDihor2BChhVOyOwpZQwnz2dBiWbr778wNwEKOCCBBfanSVNPRSXVVYCYJQQgeCXYFYRCSEVAV2PhFYlVVZUVwhaaaOJDAmyUpRZeeOESCiAJjgUICBjwocsz2RRWzS7z3GOaP5NFdtlnPQpZ2pBCprYPkkkqqWSQmi3ZI2ZEEskJJ5tYuUkmWWqZJf+VW3LJiZdhZmnJmJaQWWaYZmopSiaiuDnKKG6Kkp0pv9i5C554ErNnMcUc8ydPNHWSwwEAADDAAQNwsEYif8Bxgww68NDELADOcymmA2I6T4ECDuZff0oxk8wxxQzjCy5bcKWgWCBgZRZZWnUVlYOwigUViqGEsSsggLDxwgIJSHABBAs4YEEXmuAFyl2I8CWAU65aGIAAHhCCTDaVxMKNOujUUw878YjLTjrpqNNtOuSus4477rTzbjvrnLNOvOTQe++86+orDr/ivEsOOeIEPO845pizzjj+inMOvO/Em464EUdsDz0U2xOPPFqaufGWcnrsMZ10XhcLySXHkkv/nrv8IgzLfPb5J8w2LbPMTvpJIw01RBmWaYCbdpqNMXlkMEABCzAggy01ZvPMM8igh0UOnPhXTTbQzGxTn8L8gmcsqbhZSSWLLFLIH2XnkQbaae9www07yGDBqhi22mpWyuIVRldV9XqVVFE1pRaHHUayRQAFJEBtAhiQEEEDKJAQhiZ36fqAAAJgCCEgQnAFgRyK3JAMN/GwK0+4GJPLzrnlssPOuu06DC+855ADezvn2K6vOQHzWzvAvZMzDvDmAH/OO7bTvg7EEovL2GMR52lny3vyCbMy1TdzfTPQ3EwN991b8z342Gwz/vjelFPON9+cX+65pSu2ujwXs2MP/z7128NPY4pdapinhA1WDTMWsYMVRGABEYgAI5YWjF705xmKyEAJpmAISPyBbI5CGxzgkIYmrI1tkGKbDEIoAxCGkAMc0EAIIfUBE3gAAk9BAAHkBpUwSGVWHQEGXoTwAMw5yCp9AwsI1GKVzIGgVwtYAAokQAABYAAQLzCAHQCxADtsSIeWi5be+AIWBEzAEgFiR7tWJy7SiVEdqgNju9zhMIa943W2Y1jsjBevdQCMXwCzne8Kto7csbGN7WgjIEsXD8UszzGEFNc2CMON9H3DfwI6HyTTUQ5JeqMb5ltfOgy2R+EVzGCcPBjtGvZHP/4RHvWABzz6gUp4vKNH9P+Axi5i4SaviQJsjRBbJW75hzSc4QPBWkADZPCIRGiAA8FYRRMcQAEK3IFZftBDHuaQQTS4QQ1nIIMYmtCEJeygmzvAAQ5ygIMbgLOc4wwnDmbwAhHAcFVPgUqEaBiVSHTEblHRW1kAQQWsLKhWHdpVGCQgAAAIAAI+CEECCnCHSNwBDGxIURgegKGIFlFvYkHAAnLgjEutrqNjJJ084mFGdpAuje6q3R/jKMc35mtdsgvYHV96x3XlbpSAtOk7BNm8x/CUHv7Qhz7wUY80BrV+3/pWUeu3yjaysqnvYBcgAdmvdb0DH//QpL7WJY6ssssd/drqu9zBj3lkQxRoY1v/2tKaBrOJIQc0SEAMCaCA9UxAAQ7gAAMSsAAEpABFHLIDHd7wBjcIVg1q+AIXrtAENIjBCU5gghPEwAQpSCELZPDCZcXghjaUgQ06dGeG7umgq6SlI5EIgVpouM+oYOACEnAVaU8E0KqEQQDBCgAAAkAthYZiRb3VyoUQIC3MReKiFPDFzughUna8Qx7Ofa5I07W6rKL0XSyVHUt750lz4JEc130pHNlY3dodjF4hFRc9DCkxyIimvf/Qh3tFk498IGm+9r3vfIVav/3WL6n4gG8ah+qOdRlVwO16F1NRiQ9vzCMZZ0uD27QpYQn/oQ9zmMMMLlAAAeh2AB4uQNEM/2CAGAYRL8ryFWehAIUzlEELSUhCD0YihSAEAQg50IGNHfsEJ1iWDGc4Qxs8K9EYtjNDM4yEsjQRoY70SisYWCKHOazbGC4AAjwUAg+pgAAKuIAEEjAAhylgtxRNTm7CxYpWWiQWPCCGHphSB3Pr8VznRnd16ciqHHn3RoG9sXfAK1if++w7PLJRdrDTl055ut7HNMkz+4ivex/9aNEsKUnxXRKk4+skJPlDHfOgRRrMEARwiiGbTqBxN+GABjO4IRA1SEDlDLAeAyQArgEggASqkiK1IIINXVCCDnIAhR7ooAY0mAELVqBsGaxABc6WgQqg7Wxlr6AGNggBAnCr2//KQauGD4iQinC4IURoTrcE1S26t225BfATc0IggKGmDAEUgKGZktuQVKAFT13ranOy4MaOdvYNd8BDqHOuc7n26NJ8bVd2fA70n7lLaJkaD7zWJd47TCrGnh4SvYxudGeQ9A9Jj7zkJJd0pZVk8kpnur1HGrk/6JGNRcAhDmMYpxOWwAQmLKHnS4DDHNZQh2b5AAUXaEADHAABDKQAKw4icz6F0AITmKADJhjBCDxwga1bYAMZ+PrXK+CACoD9A2bfQA08AG9zE9TMAsBVKDTRCmQY4yXAYIMLpUxQDg8g3eomwNLTooktEIACF1iAoXILAQjk6m4ShVbeIKQVvGH/aAPPmIdmvhGggRccXNAdabmwaruDeVJeMP3uJwNN8T++1LrtYGXG07jxQ3b8MYzRVzvcpfvc894dpyy4Upu6yuG/Y5X8vWnxUZkP5TMfv6vcBzxWHnNilG0PaxjshbOffTSgYQ2SwEXdh2FiEZ2oV43fNRWa7kIRYAAsi8cABX7ABisYgQYWQHrSKxCBCVigAxbYOga0HxDdClcIATC4RNMgQ9N0AVzBkAEQTQEQQAF42ABwW+WAmF5JgBxoRQi8AJIBQghIwAIIQAGggFpoQllYyDtdhd5YSFwVgjbQQ2jEA6fMgzwI1fx8XrmUy7usS0phVfAAmu6AAzh0kifF/1R2wdTslBI89GDrrE7zDJJySSFP3YMPHs8c0QsTEl9UdWHs1UNU/VGAndI+4AMqFZ8ZDt/wvReS1M8/yAM3iEKFRZMbuIH2SVMGiQGrgYIxDAMwgMKuCME+WYjTnd/kSRQMvZ1TQFkMYcAQuIAEJIABgBitJRSIFYCIJQAEUMHeNJ3fdEVfKSDTMA0y1EFC7RUBTCImqmIFWuCHGc4R1cAIBAsz5dMdONHiAQIoKNlnZUjmBOInWsAkZIMM7oObXYo8yFn82AOdgd6dbRLDIMw40NQ0CuFXGSHwAIxKMYzvINjr6Is7QCEhpZchcZwVcpUP4t4o4VTsmZQ7dhQ8kv9URz2XPejDU61jGx3VUQFVPejDOoTUPChDhfnBhXEfHWhfBqkaq1HCSwwDWniFVMxQrGxIWdAQRFKFPDVFDC2eJU7gAOgViJHghiVABEAABZgICu5TGOwTJ4bCKJKiIDhAe0hirVGiiF2iK0KgiA2AAujV4RHAAoRACIABMAACGHTABdxFLzqFCgJjrwQCIzQCMmBeGR6jc1kMM4aUM9IUd7XDJ0njJtWRwPyOxNnRdd1RO/SOHAHSgPkeuCgP8/RUY7DOndXlOtDlXbYDO8QL7MQeOnZVPMaj6oCUP9jDP4ILuLhDMi6mPPCDUK1DPcSDNXBDKsBBH+xB0HFf9iX/ZAYFgRiswR64BDKEQkTuUFPcE5Ix1B1siFVMBVYAFF9wRUKxol4lQCvGlUlSgAM0ANpRQQykABXgUyi8RAI+ggPIZE/W2ohl4k1eokdCICYmil29QENhQJVdgIgYwQsMgVakAAwR2QxRheRRwiVIAiOYQgz6w7c8BsXQw8FtJTR6JTZ2UsL0C8BY41h6V3dxo36yUVMNlT4qzzjaHvOYUbegAzrsoCTtoBmVl74oKIT+JTiCY7uswz/4g34RHMHVg37Vj2bkwzm4AzpwAzM4SjTBwRpwH9BxJhy4QRCYgRm8QSu4BDDEQIboUACoZBj8BYp0BIv0DUbuyoQc0REp/6de0ZrhjBgFQACYUSDRxNXmREAGyEAOHMEXOAB7JIB71BpNipgqOid0gtiH6ZUPRAIogIEFUB0iaIXjJeIVIYAQ6Eqc4sImQIIkUAIkGIOOuKU88NR7pkvCHSE5mEM50OefhQM4fNWgjkM4hMOfMSo2GszFlRI+JF/GHRXtRUw5Rka5JGiCKugkKSh3jaqDctWdqZTrNQwghcZ+FR8a8hc+OAk8iMM2cEMspMGKooGqocGFsagb4AAT1OEh4IJLcEhEzVCKAMKa5oW4ERFYwCZXpKKX0tok1lqRLoAIhAC3dZiUpVvl4FbiDcAkDkADLEByHimXfukEOqdHBoCHVf+iCUQCIZjAI8SBJ9gdjCwilD0Fh1BBKAADJ1gCJjyCI2RCNsxDPLglxYwR/NSZuoQlOZxP8HgSoyaqOCTqojZqwVSso3IS8NTOG+FjG7llPZTjOG5qY1BspG5X7vgOn/XnG2lhKI2XTSnY8rkqIKnhh8KDN2xDNCwCGpxBHKiBGHAfGghWQtahGziBDkzBGQiCLBygH6YZuCnZ05HZhlikayIimLHrhq1rKgIlBsAatXAblEmZBSYeAMBa3xGpuXJpuqqr1/Zd2X5kAkxAHIDCMOytS4RCL8YQh2GIcFlFKAwDmFwCJkzCIvDCIjHXO8iZPTCjR5mRdOHZOUBSoVL/LKIGDBF6l59xEjho7KOqZZ65qlviw6YSKPM0hljmpx2JQ8IkjMsqoeeGrExpI80CEj78UaUWH8blrCnxgz7kgzikgzYIQ6i1gTXpITUJlvM6Lw6MARGUgRusgS34gi/0LQriReaAG9amWQpIRQqkwAO40CRyW0hu2AUu0QIokQQSzYjFlQRSIiYWgLkJgAI8YAE4wLUGy7lK4k02J07mlrrxZAYEArHChN8miN5d0Q5lBTCQgsBegiMkQiM4Q+gU37dE7pyRi+rc2RESarlk7qEuDDl07n0aTBBC6qOOg36OEjysgyl9y3/pwxTSHjkaEmPYTsRNLPAUaia5cO4k/8yonsN20VEohWwovY4pDVi8pBFT1UNmIAk6ZMsSKC0WE9bzOu8UTK8d8IHcdQQyOOSJcIghQh1ppcCSBssEkuD8XiDRWE7hOeC0TuL8XuIropsDTMBxlusR/a9yCrDXCkAcXyAlfoAaIAIwwIQm0JCbchhBUQhgDIMtjELiGoIg5IEpGAY7YCiUHFWFXuEceVLoeeyf2ZHuAM8OhqokYW6h7pEeIRgYqQ796IPyaKpyVSEPM2qjOuo4lIM3XFKhtnDpsWxXXhxLxY43omEadZUaaXBm9EM/zMMxpIETKG2LVu8a1OEWr0EPaEEZtAEfgMIBjjEOlZ8/nTGLUEH6Uf9AkV7iAozYIBNA+QIwANex3Iop0UiABUxABOymH7+tliZnHXutc95xAShABvBAIAynXkQkAlggtYBFaQGDLHzCJDSCIhhCHhRCMiRGPYzcZIDygKUj7hhM6D2qxo5lvwQz5o4wJu1g6dELSZGOdCVjZN5yeqnuPdwnohIhOABzJVmSMAuzxLbw8CQhzOYZpcJDKLtO8jmJP8ThDehAHaboGqyBYW2zFg/WGjDBGJRBGdCBJNzHMxgDDj1dr6x1WZBZs+5KCBapl7pzJX4phoDAAhAA3MYtPjenAShACZSABViA/h2n25rrTPJ1PoNYDD0nezQAEeCFs2zRd0ZZ3kT/gh+iwidAwiIYgh/kARyIQjZ8gz34wz+M9LeEMldtV7m0cC8XzBBakiung0u7cvAg2nOtju+1S8TcMO2Vo08TYaMGczcUN1ETd20PMy//2VkioRKnJfEYVev4XvLBg8jdAzTAwQ7MwBkYbfcZlhps8xu0wRtktWONwRlYZjCQYlpzSBF1iPlBnVbcQQpggAQUi5EGC9xOIq1JgHfW5l4HeCD/9XvMwApsgGD78wHx72EnNl97bVzp8wHQGgrIARUQIJRRy2V7hCdcQiMUQib3QR7kATFog7d8cmqXdFZt1zi0tmuf8sWCQ20Hs/nItlAH822vi3TBj4F5nKKhVzn2//JPh65xBzP5GPdxe8MIu3QmKTUSvnA77A4+5EM9TDcYJl9ojNUusM0KeHfQ/hgZGJYb/Fj30RiMZtAp1Mgz4EIr9AqtwPc/0VAKxJ0cBOAa67eAi5gCREAKhMBhE6l7bOle7+YMEEENmMAKDHYFTICCH+duNvj/eulBzy8FGo4mCuBFYYiGv0gogIIkKEKj/EEeYGYaLAI0WAM6oLhqn7QK/zIkBbOQCzkR0jitV5L5tPJRl5cm3XSA+ngURsY9NCoRYsM1YIOxF7eRj09xYwOSd8P50DgkubDvkC7pOtw5wEM+4MN0P3PxoYbMFcINqMAHwCiM/tiPGZa5k3mN6f9hBjWCMSQFMrR5RPEKQFmIWCydg2yBB2SdBBTQLx12ArBHBFCAEFjnESHdn7ttexCpA5RAHJSBoddACWzABhD2oh8Qxhu2wu/3pINYuhGNJk7FRWWbvu2KiCjCIJBNH/RBHcSBGaRBLIw2PWSGgaGjyo4DrRe3cA85UCe5SxP1S0dc6Z3RUeGDj1MhkDeGsBs7sRe7+JDP+DD7shu31CN7JcX6a7d6Nvbn65lhWFWoGqHGPBCD23BABpC7GZD5GaB7up9BEOSAHroBGuSBLwzFM+iFhcyWhURkRGKAEPQaBaCACVjAATG84TdABFgACWzBkv7zPzs6QAM0wifd/tH/wSO4QYsRAQ2swMRXPGFPQAVcfMYzeJEGMmPPb7yhm+VAQAhgWQ1FtOWMBRVEAiUYwiAIgohH0xxIgRj8wTGEjmaEo511KoQ++7MPdXELO1ATYbM3v3Gfz0+LgyY9cYDVDxVO4SD19mIs/bA3/TWMzzWEf9UfezeQvyWVP1DH+s3D9sVV1e4+cVadNjdUwg2swNeVmh6iN/e1/Y+NAY45AUCYWTPHDapqz4AB0ySEoRAQIB48eDgxYoo7W1y0YLFhAgQIET5akABBQoQJGyzUYINBggQLE2DCjDCTZs2ZKyi1ohOnzRQlNGaYKFECpQWjFirInOnAwQKnChJENWCg/wCBAgUAZAUQIMBWpxRSCAnjEIEAAg8YRopkSFAft3nmvHESZEeqbPPq/XPHjm86v+j8Bi5Xzlu6wYO7dSs3blw4x+HAgUucGBu2yd0qTwYHObK5de3arXM32l09fPrs0bt3jx69ePHuvY7XWnXjyJExV962e9u1a7krW/Z2+fJjxsYZjzO33Bw5cqDbvcO3D945d+tMo2Pnj162P3Cm6Fghxkz5MWfQp09f5oyaM27IkJmShNAwYJE0RQozdmL/hwgIQECIO9gQYYQSKmAqggYWsGmmCixoQQgKPFJwKaYaYNCpBRpwoMMxbGlFjzGgmGEFE4dCKSmkJqApwwwXUP8gxqgSoKoqAXDMUUcBBjAgAQmoiCSUSIR4AAGJANGEErb88GMPP/rIwww08likmnn8+Qcfefjqix3AAhPMmzHHTKycbh67jbg1L9ssMnKYawefdUSrxzTU7MnTntX4kUdPefy0x7HbJKvMt92usWab4Cxj08xywklOUkmZU+456ODJB5936qHTHe3umeeXPNYoEQfyzFNP1TLKaOMMMrQgooYXfgDDhxhSACHXhxh6yEgABTiyIhhY2CiDCSrIwIINmO3A2Q2G+mELDCigIKkKsE2qRQcncCADQ3DxRZE5znBChx5qQJEoZo3S1qamYlQAqhoNsEqAqwbYkccCEoD/QAhAQgGkSARSwO8RQQQZxA8+9nDLDDfy+COXefj5xx5AufTryzDL8euww8Y8M03cHF3TTXDEofOzd9opDZ+X8dFzz9Vornm1yBjVzbdErVFU0d2Go4zNj4kOuePFlPPsnOjg2fS6dNhRJ555tGkEjTOgWCEH8sgYozz0zkOP1bHL+OIFCy4QwT//jCQgRwQAhJsAAhZIAYYfTPxAhRVUmKGGHoiQdYUPVgCDjRNG8IDZxdk1CllkM9igAh00wQUYT/yg44woyhgDXaBUGGrdDTJYUSYFYVyARhsLGCDfHAO4N6oFRAgDEP0gYEOTRxz5ow8++NBDjz7+QAOOOap0/4YeftiRLR6p40FHHXXQQecbwAYTjDDCxiQ05DLLNJkzcchZ+p11OLUTH3jq0dPm91cbFGdsrkGUZ2sS5W2yzNY0umhvsjcYxixnadHZx/nWASh0cGMex4ADGjw3AxyMgYJeM0MFwza2MbBKDSZYAAQiEkKIBGhucxOWRCAiN7idwAhK6IGJdMADMZznC2poQxmioIMayOEOMYABCky0AiGKLkWLE50eWmE5XCjCD29wA0/KMAUi6GAGMwDKCorILm3BxAFLeQqNatS61+WIXwlAgEe2EInbRYIRgvAdH5rUsO/A4Q0RS8U86AG96clmetSrXvUOYxjucc8bnAnHx/+CNpzwdW8ctylfdMwhJ/WtL0/wk9k98pSccOSmftvo2Sfzt5v9XYZMpSzlYIwmyMEQ8BxLo846mmc9bmgjE2nAmg5wgIMoVJA8GGQP2MbgRDW8AAJxg9sJIzIRseyHmcc8Ywy2oAQt9IAMr4rLHObAh0DYYQ1SmMIdAEEFI/wtBzUwJw2AUkUslkCIK3DCI1phC2AMAxOGyJwe6PCGG47BCUAgwufUlcVjYasjEYDXF8OYr9jhiF8+utcGAvEIRBjCEG4RXpPckobjweEPizjGPL4xvXSg4zV99OMfs+exAJIJTYcEmSJNOaZIiSMy4jjHO94xjnbUwx3SoaT7+LT/mkoK9TibpF/97vfJnu2GUWwKWmJOmUrEIK2VrXwZX9Txjak5Q0pYy+UMeNlLDI4hPhc8wxu00AWH9CciYlkmM+G6HxDA7QEY2IIcwNCGGuoBm34wxCAEEYhDDIIgeEAEG8DQBRJNwSf/7EEPeAAUGtRABzrQgydkIc9h2MIR9lwYPungqjFoQQsu1GEVgUKU0RVFAi1iiodmRBUBLJSMBQiA6xygBD8orEl6qEPDMqpROBCvEtnQ6vP0WFKTgilM2uNepBB5ykFCShzVre6lPDOapuUjH38aKj/AG17wpumoSFWqUpmas+B0g2RQjSnRBDiO8rVSHPmQx0ilpo1Y//QyCDi4gQwYOwUx9HIKYR2wGNDgBjFogQphaQgI3MqQuE44hBigwh3kEIhINMkQhwBFKzChCEMgghF+qIOGMRyHN5yhDS0eG2n/ydgxqMERoJBFLXyREE8w4hCDXRge6JBPF5ehtD0417miMAMVhE4oznKcUhgUlQLMlitVHoCVE9CAGWjhDXrYwx7yANw0iCENeXALHIShDT6WFLnSm570BMOxl6aUkDGVKcrIQdP5VvUd8PDzlmRWSfGK1zG2CY79kvoz9WYmZJOJKpngG6ny0ckc/qhH9eKhDWnkYQdQgAIQcCADFUCBsVIY8BgKTEEprHrA5YHVD4SwK17xp/8hb53wXCFAATbYARTPkIUhGOGJVrRiE5iQBCMcUeJAaAIQdwAyHYRnh520+IYsPkMc+KAJG89CF/O0hSQewYiJDiIQwRNekF2shQKr4RCMeAMNqIhOFgiFKEepwEyckgC3VZnfXHHdVEwyAzWEuQ9QWgKC85DwKmVDG99Ix/Wo97w/+vF6HxMTKlPqse/JtJCFxDNNbdrKPLcDHixzR8yGKlSauY9QjepG0IJzqN7InDdkAlopHyUy5BhmHOegU/X44Q+hf0Mb3IjFDoLAWE9DYQxKCPDTKRiFA0+96VvYAhXWKmFaN2TC+xEC3CDQgh7sARe4EAQjPoyKUnzCEYL/+Csdlk0IO8ShDm+gQx3ioOI3qME9YjgDGtZgCEpoYhOfcAUugjGMUlzCEYoQxGexiXdqd24KcxCEJDDhBx2kcwZFLB22vDgvqiiU3/u6io8UMIEZvMGv9kSY2wuRiEXEgmrxCDo/7uHwv1jvG9z4xu+5UY7f2/l/kUoTZMIhDkqZozHK8VRpTPMyTp1GH+AVOj78cQ9+kI9QJFPvznbGm22MSX8vf+qjHhOpcaRjHOSj0/WCvg99bEMb0/hDEKAQhSgsHQpK8L/TAyzqpk4MnICx/I8KsG5XlqnWaq3rjIRDMgAH8gBhHiHt1G5JHi8Qlu0R6gAP9MDcfKsO5kDv/9DgDeyOETRBEzChE0phFXxhGHABE5KNxwSBYb7Mt/KuDZzIDxShFFrhEfbPtGrgij7gA+otKRZkQxKKK3bkKgpgKhSAASZgBdQgEAYBsNzuEBKhEBYhGbQhHfxhH3Dv97Inq7RKpDTujwAJvgijqLoPHJavMZZDNEbDTqDPp/Sh+uLvNO5hG1DmDRetvMKvk8RvG4jD5RCjpRyD+dxvHaQn/vzhGrRBGJDOCfjP0/5PCfRPxqZg/5zgwJyggpSgC6yuAb2O6+JK60CgmBSgAW5gDvZgEBDBAlFhx5pEA/Ojt5pkF4FHeLApyPzgES6BEi4BEzahFGwhx36Qd3jsr/8WBnj4wAPxyQ8cIYk04Q3GYJ+mAAqMDLU6j1nuzUWgQrbE6HXw5QkTQEYqoASmgA526/UKIQ1EwRq64R3E8B64IR+/oRzUwS9UhjnMIR28QQ1ViWgaQ35oKjImJTk84zPqkKfUJx/ykE/+4YDw4RuU4Q9vAzIoI2c6SeYIsRBdzuWKAznIxxyqJx30IQz5wRqqYRFuwBIvsf/+bxMDzNOc4BMJcIZ8ogvAYAsYwsG8biwkjAHfKgaE4AeggAcHwRACgRLUzhOkUhJ28SlBQWEebxebBBqhbQ/0YBAeQRIkgRImgRI6QRVaARhwgRLCjREYQREG6wofrxf1QBAUARj/kOER3sAOykCfbugL5gNwImsFTKADkAIpDEp1psJGBsAJW+cqokJeMiQDeID1slKjiKEc7DH78lEf/aIdzsE5RHM5RkoNEekw0u8Ni6rQkkZl6hBQTIO7MEn7/iEfQiMafiH9jo8z1As4ClEkncqUdHMctgcM98EfvEEbimEHZMASc5L/iKAm9W//ttHTpI7qzqMMDAfrUNEoTZGZECESEOERHqEpCSESQKEWN0EFFQawGAEXHMEP4hKwePHL4sgQwhLcIGEsNwEVZAEVjK0tFWFA3dLH4MgP2qIVfEEQ6MAO2uDceEINyobIXIgGWIAoOgAlWiTKpAJfXIeh0DEB/xbgCRWgAmagDOhgD8ygCRpBGspB6Pih9zwzHURu0tYhTNSweqRLN2+jut7QuuYLNHDqNeTBNOBB0KjjHaiBGGJhOCHjICUjN9bkN8WPJF/u5QzyIBnD/MDQH/BhG7KhEjRABXLyOZcuOv1vOvfvElutPMwAPWzIDtiADaxuC07RO7kOEOQgPN/SEQ5hYQ5B20DBEzTBFv/qEFpBFgDrEP5KLnfxSZrkEPKTEXgHEibBEygB8zQB3Byh8RTBLeHSGRE0D/wgzPggDvDgGUGLJ9JNCYaQBYLCMFtkQxQTX3TECafCddDRAVZgCrYmDX6BG9IBvKrn9/oxHdYhkuhEkP/SoR9573rQwX8KKTVrKiF71EfJ55GGNB6ir33sgR/sQR/wARyOIRZMIf2SAw5HBjeGg38woxt+00phyn8kBePQQejQQRuOoQnGlAmAAAhk0tOiMwmm8wmiIGDzD1XKA/DWwA3cQA3iwA4CgRDCUz8erFcaAgHlIElAQRMmARIajy0eoVA9YT2psikZgRIU4lN7jFGv0FETRlLJ81MdgRkPQREooWPJUxJm0C1BlVEPAWFIFXjwAGF4UXjwCYqmwMjQ5UJRgiaaYhyvgspA1LZuCzJbsQE+YAcWwRm4QTXGJCWzinrkTPjSUEfJ5CB1U/0aqVrzzJG0tR3SQR5gpn3/tM9LvUEZdsEUzpU1mW9tH6NM1is3fvMaXE5w3YtMlgOVwtYf+EEdsiEWNOADNuBfAZb//C8JNDcJnuAJWK2CpsRh3wCb5uC3PlCbxlMtAGEs4KrWEJANHsEW1G4TJmESaFBSVdDYKKH1FKEagQEUypJT37LH2IKiFIE8H4FAGYEtrhCeQGFnxTJTk+1TB/RT2SID/eplr3Bhyg0P5m6fmq4HaOAIXSvfagR2qozKYgdrAWAAGIAD7IKBsPSPfs/NzPD3jPVY/SJs0aH51HZSEjJbA3jPogM7uIunAEXo5GFJ+ZYUAPc4ALH7MmNwe8PRWMqCQ2ZxBwkdcG8euAEm/0OHCfzVckntsTY3Cp4AC0xtYRvWYd1gdOsgzDKnDvSAByUqPFfXdgBhh9EzFPJDEzILF2bhFDABEuASaNtNEiDBswShEA5hElBhFSgBEyihiquYZ6cX2Wq2LSmKBuVT2yjBLcVyLIX3iAfUQG3wBoWHhpMWG90ACtqARGbgAxLEAbalAeSFKsKoCXHVR9KRQxxgByrBGLRhHgy5NVgDflajHztGpNAhWQHSf9eWUHy0pkTTfKaDu/xBHrRPHPCBG5ohFmjBFHJzOJPDWiMDMpoKODJDlEgpfBJ3TMQBgEqJNRooDW5gcETYcgHWCUx4OrNADIJ5ShrWBE0wyOxTEP9q2O0UQRK0LRSGRDx5OC3nKSF8QReuWRZKARNst93eckATgaLYohB6lxI+ARVQoWNVMFPBjTw7lRmd0g8oQRZ8gbAkVSzDLT+tOFPDjVEpinj/6vWcJHhAMJ9WbDz1QDxUYAIaQEOTUF7yWLaq9gmngl4UwEMCeRGIIRsYCI+0b9DCK0wcWWX+kflWU35QxrrAQTSdo6oyJR/gYR34QTXywRyoYRdo4RV2IRlS+ZQFuJJTGhyCY34Md5Wl9EqJo5T2kZDowYMzYQdwYAU4YIT/tZ+A4ISzIAuwoKwE4oXngA6+GtqaJGF262YdAROSSIlkYdhA4QWH4a2HIRiuWRf/bsEVSqETLgGLO3WvO/WbHWGKN2ETKOEQEm4QevcRBo8t+/oQNLAOHiEh3KAOEBRl8Tl6qzgFFTtUW3ZAG/XxsjJ46kAE+WBkGQEKcmAFJOcIDQqj8TiMHvP0FnMqSJQBMkQDbmAReKEaGOge/AGB6sFLV5LSAqMfSZqkF7IxnCNbRc66Qq6V2gGm94Ed+KQerIFJRfkYrAE52i+lgTqlR2bRjlpKz8+9xs8bltocvMGQmSEPmuC/OICXy9QJpnMKtrqa0OC+vTrIgqyGEbTDDIEQevcSPkEWgMEXciwhhsEYjAEZGBwZjCGue6EX6nrtBBvceOwQYm9A+XqKG0EQ/wjivtFgYedgELY4ZAVhDd5jDpZgCdBgDnYLsJqZEhxhP8d4n3m2ejW8eplke/3gA+tAEYbNE8olqjeg80qARQzKoBhEak8Ptg2gMdOxFRnAARiAATQADlKhGeZBH6jBGrABHLBjOgr4RpuVHYq7pEu650IzSKvKpvoMp6qDU+whHvykG8o1FmJBGKhhHpKbkru7WqtLlcEbXqm00Mt7HxkjvbmBFghQqjkgCESYCZ7TJrUgPshADQDPDY4Hefbgt56kKdvtZhlBEvozGQ088RLcwZEhGRq8GIIhwm3BFdD5rjFhUKn4Yz92euGyLRQuD+BgDUA8CIAADcCyLd+Sr//EoAlC3A3m4AOFBz+tuJ2tWFAxFRIYIRGqF1Qp6mXjSBIsBxTmAA1ySAXEF4tU5HGUXHWkgnWa3ABkxEMa4ADk/QAY4AYq4Rim4ZO8wR6EDqdwajT4An383d+jgzSuQzRImjR4SjRO42XkNk+0QzugAc9TYReaIR78gb7ecOPfVqi/XKijlH9qztCBpry9QTmIcx6yYRGaAAhmQAM0YAniW76frtIvHdMdNvK+TIZjlmUZARIuoRNQAcd8IRgST9VXnRka3MGHoRdwQRagfq3ROZ1BYVCLLa+xWBG28PHgApvQgAnIIwhywA2a+S2Rl3pFjLcWBplJ/LKrWCoJFRP/5J52QRYuka1AGxVBKQEZnuES9oAO0ODTYiVdUmRZkPygOtQJb2sxN8TKBoDeNWARfqEatOEutK8eSg6n7KQe+uzPYMbPNt8OX2aSXkZco2/02aEboEEduIQdbloUUiEWjoEbwjC5gRqVHQn31QQ4iIPkx08bgKb9Uv4XxoyKYH4JIt0So6Dm40MNWviYU/TLniQLezcRGmESCk8VcAzVi0HVmeH7l94+dMEW1noVVGHt0rnYAnv9L2EYxbLtBHoP4uINzCAnd1IPUNDCZzDZyBMRxnN4AeKQoYGIHD06KIkSpk2fPsn6tIkSI0WOGD1ixMjQoUGDHj1DpqjPnjdj/6C00aKkB40ZJkqU2LDBwoQJERwsuJkggYECPAcMECCAQAEDAIoGCOBzwAEZlYxl48aNnrx37d69gwfPKlZ8XLlu7Yqvnj59XMeSJVuWrLx01IgpQ1fPG7FMolIVs+ZvXz9yfMWR8wtOnGBwhAv7BRyucDdsjBl7W4xtWzfJjyVT9lbZ2zhx47hlq9SEjA4VGjQsAYKaSRQpU7JMwUImtho1b2rTua1nzx4/fgRppNhoEkNVtXT1CjbMmHJjzJA5R2ZsmC9brlZBxITpkiVLlzxt2tSpIapWpUp9ujRJEiRFhgQJ8pNnzhs3a9CgMSOGzBk+jBRikpSQJAcN6EiBBv8O+AiAlEhyySao2GJLKeNtAuBFFjHiyEaGgEKJQH7Q4UYUdLRRhhZE1EDDCi29ZIEENEVw0wIK5GSATwIcBdQARRk1AFJKMbBDJcRUw8086qSzzlVYLQlWk2CZZVaT+vhDJT/WQAMNMdB8Q80uopiSyzP07KNXYOScI9hh4hTGZpvdgJMYm9iA81hjdt6JTTf2qGNPOuPgkw43yaTRxBhjBMHEEkwcwegRSTwBaRZexEbGbG68EcccddSRW258DHKIRQxuUoortvgSTKrIDcMqq6nqMsspnXy3CSaUTIIrrglh4kkpqrgCCyyunAIReuo5wp4gIuVRxxxu3CfGEjv/ABGEGXsoIokmmnjCbbeebOudrZRQcslCvcpiiyzlmepLKZ1I4oiACFWkiHu86UHHfG+cYaIOKZbQUkwVRFBTTTfNaIABOvEkAE9DJZxTAgoswEADFmsgwx9hFklPXmT+Q6U//5C5Dzz57JOPWuzUU09aKZN58sj+pNMMNMoQswsxyRAjSizFOEPNPWT6dQ6agpEDzl+FhcN0nGzGybRi3UxNddVWs2OPPfKEY8423IjShBhnjOEEEEVA2ugRTxwh6aSyzaZGHHJvqkfdfARyCEW7ftLKqaqm6ksvutxC3SqlcJLdQtgZC+Cuva5S3OC1wMIKsdmhBwmy7fG2h3zP/5rhhBhiOBGEE2j4cQivoIDS7equl1ceKrK7i52DqnwiuyNz9IEtJRcdxB5HftR9Gx1xlJhSDTPQwEIJHcQkQQQSQFBTAzJGvJPDPCWscE4KKNBAxQ404AAHaaTizDz08ENmyP+8D3M++YQljzxa12MVPlOOrNc+INtDDWU0oxk9i0UuYiGKXwiDGM34BvvGAUEIhmMcSGvTmtq0NMI4bWlOaxqcmjYOefCDHeswhze00Yw/NAENY4hC2ZqANkZB6glZqKGk3ga3uW2KU4HQCCMScolOSAhdt1gF5UxBClJ8ghNL3EQmaseJ8nxiVrTila9m0Qtf+EJywkLFrLKDK//N+eY9e8gDHODgBjPYBz+hQ8McBPEIT7guXJcY1yXu2LjGkasTnUDFJxIBh/u84VoAMgglFLGRe9UNX3FQQxmm0AMdRJIGLemABS5pgYFVL0Y00t7DIuY9BTDAAaR0QGnSIIplzGMe9xAHyvBBMpSpLB7x4Ef9bmkPflDpff7ghz2wkaVKLKJnvxBFJWIhDC8dYx66NIczzZGOdJhjHZvxy1/80rQJRnAc2ewmNxPDtG9KEIL84Mc7sDGOa2gjFmlIA7SitYS0yVNtNLwhDucWB075AW8/jFeDcOcKWQRUFgSVRS1qASFc6EKLDPUFLtJVUAmtQha3YKjgajELV/j/MTydwEQYJyJGZeUhPvKZg3zWYAb6uKEOhniEJljnnVqNK480ndUl/IAG0+EnpX5QxEEKxIiNvIcPeiCq8Ug0BSWMISXMM8HzOmBJmdTEAQZbAI0Str3u6URiEyMf+SZQmiAVgxvbuMY1vGEOfOQFH/BomdbocY974KN+WdMlldR6j21QAxqxWEQlciEMZMQiE8I4xjF2AQ37+YMd7IhmOhjbjnasY7JWocpkL4vZzE42spEt2pmKBtqirSOX+xDHNawxjUI0wQxqFIMUmJADRhWBBzwowmxrK0MbZgE2lYpbI/OpBz8YAhGP8KcnxmMLXOCiocxtqOB08VCBumK6/6sIKC6yaNFb3EKgp/CVuzaBnlxlThGJKIR7yKiHHcbnWaI7wxvqcAhHUEJbtkrIghQkr0PAoVrtNdTo3CAIDBUXkZvbpx+M+oYyKLgkPUCRCR7sVIHNZCZVxR73upewiS3Aqwo4gPg0sINCiOIY2dAGN+IhD318RS0p7spYRMZLfajjSspIhiiKgeNfxEJL7EDHOuDxvn/ckrFEpko73FEPrLwDf5Wt7Do4C+UlZcXIUIZyOeHRDmtkQxhNSANrc8qEsjGKtjkoMw5wkAPaFiFtSdjt2yoFXLwpQhEYSgi3ViehVqwCFVLkhJ+Z6KvpThddEJIFLGyxUOcKDhcZDf+oK1Rhni/KFD2NaMSc5yyQ9/jBpCZVwxnIkFMzzEG4P/TPfR9xCD+4QXRkcwIUXA0F0YnBDHk4xICCaohBCEJ4Ro1DG379yOTRoKksyuQlX2QTnFz1whHT8AAKcIDvMaBiQMrEMYjESrZ+pR5ILotdQValbUDjGG5Jxi+KIYwdW2MeKyPZ+1oWFnfIux71Y0e350fvW9abHfuunzu0vSStaGXK9eDHPeAhDms4oxE3qA9+mrAEJ0hhzDwocw7OjGba1na2a05CFKbwhTJkAc51uJuufZgghSyIEseVHZ/N05BAzwLRxkHVFnVhnF7ofOc6H5x2ca7ddAm6FbP7Ihj/J1GgOdtLJCadzzvRAIeR9sEPe4CDGYIwrdK92gmk43roWMtaQ1jEQhriNb6KRyIGSxJFK3AJTJ53bIKRUtk6yZ5WE7CAoxyFewlQygFuUAkSzwMd7sByO+CBDySLBR/3KGcvc+mNcf8iZ8dAdyx+0YxVooMfavXHlPAhv/mVRWt0HQtXskZ6XJI+a/Jga5K5gj8nccWW+zhtMZqwA7AzIQtOYEIQZKtxMltc47ddcw+SMIUp0JDkRQ2ub3yaoKAyAhOgaIUslLvchgIDGH/rvhazyHOci18XwXAudBn6UKHzeYq1whWBM80bk6LRPtAKQg52gP+sBwEK/NeB/1FT/zqzpkZw4AdjdxF5k2uDoEh4gC9vgFRKoARE4C8z0HYA4zwx0SLUk2xWdVXbEzE7EgA5ciNI4WE30AjC8BS0pA72ww704IL0sEoxCINZgjOpsEA6hkzJkA3VoA3WYA3cEFf3EGQfAzJBGFf6wEsGdw+ot4RLmDVLWD/0Vg/2tjL2wHhz5Q7143j3wA2pIAM5cAasJTpSwHUUF3xnSHxF0ANriHzJVwa+xSlF5QeDMFxjhwgaIQnVl1zLtX2t4od/qCpapCqCcwsHZYgHVYgYNQuzkH4QAlGu0AqQxn7gdQmQMAmQ0AiGkAiJIAh/0AfxgUZuYHWsxXVBYCinWBJQEP8FhnIG9rEGKIUGhCQgkhA8ujY8Z7cvZVASkjSBbQcTMHFsNEFVMMKBoHRhGfY9GrZhFuMAE0BKGLMIKFgkMRiDRcIN2oBCx6AMu8CNBrQLvDA4vgAJi9AIi2COi5AJ1bBKnjcyMQMySuh4/hCEqGcP80iP8sBv/WY/qKdv5cQP81ANf3ADOBAbYpAFV9B7v3cEZ5hmaKhxksSGyKcFs6FDnMIH+0QIiHCHPSRfctQK1qdcvgAMfzgM3WeSJUmIBxUshzgLwQILs1BQiygLszA5wrIKkEYKpUAK7VeJjrAe5LU5utE5zrJGZzA2JYGKY2CUakR/aOAGeWAIFXIRhsD/G7xBVA2YdlAwBVDQYBToEm4nYRNWVcV4jHcnMTcxbeRDShOQARkgA3mQCbGAQKkgCplQCcLUCHf5B40ACaKwHZUwCrHQCxXVCXnwByOVB504TE+hDvqQJO7WS0Y4FnFFj/XIj/toD4ylb3R1mfXTSzD4CzewAysghmKAkGEGfMLnkDygA2q2hmv4cSFHkZlCNxcZCLd5m3rDctsCCuOBLtinfeXXfa4SDD1XiC+5iMnpksIyk4ZYiNqFUZSjCpWzRJyAHpiTdOZFlWREUrXhBkeplEYpnuLJlGhABy0FLxVBlVXJB0aVLySii1zJdiXAApUEExlQAZn0IjGibGV5/3eilJbjU0o1oQE3AAfk+AcJeo7nCAl0URekMAq9kAu30AuLkKBUxxGGgIm7kA3W8A3qcBUkM5mUeXqsp3qpx3pEtpkmqm+9NA/Z0Ag7cAMqgB+ig5BleAS3RWarqWZqGJEfpwW9pQZr4AZzU1RE1Z5zGCoFknLl0isSElB7yFAmGYi9AI4+l5yLCAsYRVA0WQuJCJ0H1ZItCWnmwQnfEV5Ip3QD4R4iQTzz8Z3iGZ7kiQb1gQZvUIAVMRHryZ5v+mttwGAosjz1GTAYmEkVoIH8OSN1d4zNlozLuIwOUAEZwAE7kAeNwAqFOAsTmgqVIGKpwAqsAAu3AAukkCqWgP+JB1EQt2IJlaBjPngN8CCi+nAP9JA19LOZ9Zar/EZkvJqPm1kP/8AP3MAMaTCjHDCGvBdmTmCGPIqGEJkExxcFUeBmZHBDQ1qk+ZJP+tRDdEhnhlQ7vembyaVF3Eelg2ic0YmcMXmIYmqIkvNop6AKZdoJdxRe62FphWBenIMvJuUG/4oG4ymnasRag0RnGEFgHKFp7vmejySBNQCxzAOWv4ifwkgwMbKo/vmf4GMxzMiWH7ACKpAGlfCl5BcLf+BXr/AKPdOpmZALdJkJmYArkGCJNNuqafALHWoPQPYPY+GCtzpXvUpkj6WZ+JgO++aruSoPwTqssbADOMABGmD/kDXUezjqrKsJrceXBFtbT2ozcvoxG2dwKfnUnnxQB7vhrQYCRAuBOyCZc+f6N4GjqS9ZUF3qpVrqpUEHk6cgr+NRCt9xOeGFLIqgnQpYN/FRG2swnkrpX6KjRmtwnhiCERkxELZ4lWdHIijRA0RwIsS2AWB5qBNAPWNpYRf2SVyVjNFGPnLHACD2B5ZACjFKs+aYCaZQCZBwC8FAC6kwCtYZHObYCJtYCDeQBsmgDdtgD/5DFvSAYksbtEJLtNArb/PGMtTLbfL2DvvAD9kgkDhQGk1QQ0/AdUsQTzl6tWloW0dwfFrLtZBSBEhAQ/lhlKxIkZvyBpqSG3OoEXnD/6QKQSoTdQvGoSrCIAwkmSqDKaYwWbdb6qXBIlAJBSGPpgqnMCzhARG1gp0TUQjJQnUk5SyLewZQYCjTOgZgF7mSOxECITwHNjy3kblT0AVG0Lle2XYf8AEb0JaXVAHIhrE0UncPAzES4yN+dwAHQMSjpAFNUAiWsAhp8AeZAAl/AAtbxLudgImE+weF4Il5oAdRuwjToA3esFbPuzLVC71DO7Tu8A7roHgsw8bcdlnu4A/zQAy49wEa0ABNAENPwARMAATka1uBjL6CzANmsyiMkgRq2Chbm8hFwLVSoJRTMAZvIze0YaQXyRF5gxGPQC7/S1HHAbeuskVhWrcEdf+IDmwqMzmTgvYJxAIeHZU4l5g5jmAIhdAe3LleAjs2UaCKhsJaKAVgGGIQFXEIKqyACohgjqRgmjtsLOCVNnyfAqNJF1uMjLoTzGYUQ5wUPuFho/SW5QUHn0AKmSALrNCqlcCX5JWgCdoH7akBlboL6uMx/UDPIUMl+2DP9uyPjjcyQRZk+Vwl88ANmdBOEJcDWSAFUsDLU5DQ5IsaD50DDy3REh0EisIEUrAEZMgEa6M2WODRWPAFlJJD21oHeFC2tnmbGTl2u2JFpqJQWZQqJNkqxRkMQKepqgws0mkKpkA5nwBp4VEKl1AKnsArl+CTl0CLdEZehUCHVKcb+eT/OWgAyUZJKflBKZWyBnh6IcBTzMe8SPlSG/MLBTrAAizQARfwYC8hzRXrjOPTsd+zbNmjPUH8qDfhVaVUPjmgBwgrCXx5lw0yK2w6EEztBw6gAsRLDMzkP/9Az/6Yz/vsj0YYj70U2UYYVwKNDH9AKE0wW67Bf/y3tYky0RE90QBIvuTbx33MdRu9Nk/w0R/9BbEd2yNdkSadpCmtkcI8Kp9QCvK6pQL8N8R5wD7HpQJlRMHCCvMqneXBRz1JCZmzB4ZAEXMm3dU9VHywB3VQpM0SB2ugH2NTkFZNKWegBpfCUj81lRrBOe3ZgJdyG2PQA/U5Ai1Qn27Xlve9w23t/9b9+cNzbZbKGCOkxIwVoAI58AZzVgiJEBy4cgl9cF7KsgeCkAHvfAN/sAxwtc+WXdmW/YIwSI0f/uFQMQ2p0E6EUgQr8ARSwH9c1wNHINoSTdqlXdGprdph1sdZ0NpJ8No7LttfADezSTecYtK4yU/xwiALAR6trAqwYFABjF2oUpyS05KCltPILaq9awl+1hCbAAmXgOC8U8vKQpWbsyntGQfmfVLkDd6yxoqfph9rMBt1MAiTW1wbYYueogdvQAeKUEd8MAYrUQINthIha8M2jN8UtknXs2wOw3egpIwa1gAcSz4VsAJnoAeDsIkKjomFwKDY8QkqEAQYcwOLoP8NIA4Vpw4V2Nih1CANNmNYxEAMvzB5B5QKpmBM42iO61zi7rQCZ8Z1r4Yaa/jiEF3aD23Rqk2GvcfaHb3jzQ7Ss/3jciPttdmeu+EbmlwgljgJ/5REprDkJZuuLbkK437cLpncpGAKrKBEnHA7l6Dg9XJetmypihDhfOAGmqLdc5ApbwDnchrecxob5P2vl3ItFVEgdq5p9yIInvCRjLCLMxCBXUmBKkDoHIDfOyx31sNJHViWoIS6ByNKHesAGTADbSAJrSCS3KcLufALMc0qbwAEHDABHGCC6UaXxiRMFpqgcEAoMnoDPy8DMlAaQ0/0RV/0xJsG0XIEODADQBD/ZkEQ7D0w7KgR48Z+GsceZsmeKGjj2s7u0Tr+2log9rGtYGXvWyStT0qqCN6qm9mRCUwkr64wc7agiKWMiNqlXYvYqTRrHpswCY1QCH1wCHOQB5+YB4zwHopQB2KbuHPwivThaWQQnuM9v3N6BkRaH7U2ERiiwvYyPI+Q8prgLJFkKEow1isxA16p1hZw6MI4dwcT18z238n4PcwYAQkQAR+QA34ACr5QksKgQLBeDMYwAyowPhxgBjLQBEM/bc0/SngN/aUk8tI/bdAfPg2wAxD3tGe2AgAI9UAg7KdR7Khx2ksw48qO7H3M0V3f7FvryIwM/zou21oA7b5lyZti/+29QYdL6pO4shDhARCnVrlyJUvWLFsJcenS1cvhw16zUnHiNIoTJEiF8vxZI8aMGDR59szJMyiOGjdv1ryJc2aNGzVnzogZI/MMGTJnxuzcmVONmpdozLwxxMjoI0WG/AwS5McPKGPIkGGas2ZnmTJjpkDpQcPrjBUlxG4gu8FChgoTIqyN4GDBWwUJ5Mo1UNeugbl0DSjgy5dBgQEHFDCosGaSrmLEiBUzFrVEhQYTkvBwkKGBA8yYGzDg3NnzZ9ChP+MgTXpFDhxAVK/u0YPJktWrYateUts2Eye5meCW4oTJkyNHniQhjgULceJFlC8vwoNHjyRKlBhPgkXLF//sP3+unFNHj545dPQ4HXSI0SFFjiBNuoSp06dSpVChKigrIcOGDn0FC+ZQ161ZTpnkj0L+gKMJOOYQYwmhxKDDkDd+gumNN1xa46abpBBDJpxk4mkKn2wSww003BjEKEYeYcQQFg0ZpJVnskFmEj/mQAMKCtvIiisddKiBBrDG+uCDDTJAqwIk1dKsgQX4musuKPGKkq8BqhRMAQcqMOOSYIrxsjEHJsjADjYWaGCzLCfILMsk13TzzM1E60yBAxhoYAUdVFhhTxVSAyKHHIDogQgejrDNNiBmS7Q22nDLLTcNewPuiCyQM+64JJhbzjlOiSCiNeSqw44MMTpcKY7/ONxwo7vv/BBkEEPMU4+9Td77BL75XJnllob4428YX331xZVNEulDjDQObGIN1OgAyY2bYnJjDZTUwCkmKaSIySabaiJVipyEQmNcN/xAUcVDYvWDkmeeQaWQptZYgw463tBRK+mI0AHIsMQaskgjM7DAgrTacoBJJ/OKsq4BBBigAIgBC6BKAwQzc4IgSmkMGWaQycEMpSa47LIKZDDZZBxWkEEFllfQc0iYyQp4ZiMryEBMDjL4YIYaOOVBBx5W260HHXpwbrnggmPuCOV42G033aDOYtLgqrvU6uoyLSLrQT0lQjoliLvuC+3e6K4OkfzYY21XXx3kbfQcceQR/0owwcQTvHFtpRRVCqql12B9BZY/VyBRJA0xOkLDCRxQ1sGNHLKNiQwNmcjpDHAnx+nymjCkllxV55hjj/QYkfsQ9BRRpJA+Ws+DjvDszWoMJVrroYYg/f0XrSMnUMtgOOGKS6+IIYZSLgXqSoCvMxcQQQ5cjAkmoWEcuWSQHD7gAM4KbpDB+x1uwOEG7/fkk2X0WdaeA/bbd1/7GWZwrrWfY1OtR/qXTlq5/Z2G+lHfOOEJkwJOcS5FHeMoBzld8xTYijM2CZmtO3mg4Nr24BS3wQp16DEKJCTBHkxsQoSZ4AR8TMGKWdTiFrx6yK+C4Yte4MIWA0LD99DAhAo44P8DUtDBCsjgBjGI4Q042dC3ZKIdD3XOJj8BXYlKtAfzKCJF51GEIODVBwt+hw5x0FFWpjCF2v0oSC4rAZEAVjPfGWxJTUpYAuxiPAMUAEoFmAtfFiABKgAiFJQgg54elAfIxY8sItPBDFQwgxyIrzSLLE38HPlISO7pA3q6nc96FBvnFI1+SuNf0jzJtP8B0FECfEIWKmW1q2ENOUWwXaiQMzayAYVcFBLdBNPmFFfBKlaoM4rc1mMJS1ziErWCjypYwQpYqDA/++lPL3RRC1eU4hI15ID32IcaIGhLJtCSyRpMJa9tbe5yHToDueQ1rRLN4URHecQhBMGipjiFD3z/0AO9ZDeGHfEILGBxmQqGxAGZ9S6Na+yLXuJYPDjKES9xgUAKUgACEVzAYBF4AxDPkIQS0MACEdjAGcBCGkCFFFCkAYIORHrSkQIqfkCKn4940LMe6QCTz6FfoZT2SZwuIZRO6E22BGjKLGDqgEOljitDZRxYSkhV03pJLevANly+apfoidt6JjGJYGKihKQ4BTJRqMz89MIXK4SmK+bzCUjAQQYcMNkSnCCTOeCkDlWpVkpWMq1tcesm5HRiiSq6VHMdxSjpYtEgcOkHem7xDWW411agsC+W8glmZjRL79ayRrgY9KBwjCNeEgABDIDgAQ+AAASatAAHYEVHOiDC/wwsMIE2KKEEK1hpDnSAA9v2CDU4iF8jIenImM7AKzWIaUxLGtPnbMqmTMMpc2/qyQGW0pSlBE5RiXpAo1rKgNgh2xlSUlGz1WGuc9DDBV2VSw1KUYqOuCpW7RbCTnD1mMjc1QpX+J9a1GIWrCgFJ1bxiU5gQhFo2AFudSoGNTDuDYB0Q6oavBKWpIpaR+SQTUq0BjS8RFUlcgPp2Lki1LnobfGsZ73q5aEpEI1okSXjWMhyFsuqsXlOklKUFErH0I6WtG8x0wLsoAYtTCEJOihSG+JAgz3hoLjGLa5tbYvb0uyWNIXsLdF0UAT7Ffc5TGtOEfbn5eY+N2nRJfOkiv+KyutiypVCNU52VPKSOKhEDeN9qnn7sJT0osh0v8zqJkrIN1aoAhaDhsUsZpHMFAaaFPExCCo2gYlJFKLATgDUGepAhlrmYa4SFF2c8QoUauVVDRlm6lLNgGE01OEQcnuEipIS4nQxRW31rGdFdSLkKKyYt/wUSwnKUpazpOV3msnsk+4ixwEYgAKifQACECAXiyUAVXFIQhBI852UqSwHOwhCbEwqUtUEIQhLGDdPPWKGDNfTD3oIQhSAMAP7HXd+PdBUvZWDBHznGwmfLDNwBsiEI5wZlQYsTnaH6oXsbGuxUSDDSbzzHTv3QRDv3CAvHdGIX4KwVlxVhSlU8fH/+aaCFa/YLyw+bgpbuEIV8dnEJRThBieswAluqIMa8kASte0BbTrftKoo9GntjNqcpnaCGUg0h6I8IhKReAQiEIE6RRB24mpLbL3U8IUpBDkJVn5kv8bi64AKW0kHY+Pw5lgACDC72YCp0gAIQICaZ4EJYugDJvawgyU0IXEgSZB5J17V9bRnE55ARStaoRBc+AIYiweFFHJQG9wGCmg/OxrSuLycfBcBCVXgfL4NdYTfTHe6A8xCb4gznCQcoeBbs9Rx1ExUhJONDFjRAQMCEIAG8KAM4q0DH3LeuonLOg9wgEMajF+I9VBC8Jx4T0VI8XyRm4LQXjW5Lmwhi1WU/0KEk3DEHJogwTXEwc5qoyDveT+Hiob6J+VcgxnQPS4MnzvDaJiDIFq9dFerN+ouiidia60GrDiDL0qCksKBr9iTXtMdgLGZgiG7stOsAliAEGi20SKA25uYhhEAj4ADQeiElBs8UJCPVjAIEkwIE8QFFEzBFGSIxPMFF/SFYYhBRugBlZEBn7lBTrE3e8O3e3uC3dApnuqNqBGO0nsa3AA4JwgOqlHCAiK9qTElLxCnk1ADAwAAKwSA25uAHmiDeWKRQ4CXptgDQRg+a/qeNPiDSdiEW1EFEjQ0FuIP+7CFFMqv/WKFVCiFT3g0TKCESYADM1gCVMMiCqIgkiBE4v8jPjeAg78aF0bUqzMIOp9TFXN5BEmgBEqQBBU5j8Lqv//TCZ2AAh7JAeHiFxcDtpphQDVxQAYQDDdKgMBQAOcBAWdrNgKQowPwrAS4hFKwDxXsxRQ0wROUIVvoRfxAQYiIQVyggx5oHBXIARy8QR3UFH3DNx8MJZ/yjd8oJSE8wkMBuE+aGgICKqCKwmuJAwe4wiscAI6aATsIBN/Lg9ahFz+goB3QAHvUgJPRADiYhFIwPFs4PFm4L7EaQVnwm0KDhVdghVPAQxGCNEYgvjyokbZxHXhcm5sTHeLDSHTKsCPalvV7RKAoNXORhErUBEpQHdU5BKZ4G8Oqp1TxLp3/GAMe6REx8joXm5mz8B3MMJPNSJgDOIAGoIAFeDta5CzPWgj80AWkVMpbwIVbOEFgRMFglCGkREGG4IVeiEFJEJSUkQFnfMYc3EEkuLd847wqeAIgxEaeGiXpEgPd8A3bACBPGj0lBKpSIseG44EAQEcslAAL6IAP0IItOpuR2AMKaoJ7tMcb0ICfPIAMWAI/cIRWCMGBGAgZQiZXGAiCmAWCWIVVUIVTIIVbEaFGmDhBkDhYkbU++AOnsEhCvDlElBdqkc2g60hwwrAOOwRKlARNeARHiLoQaxHDSiyWsLUxiAInAAKuEKMZSEB/KRILMAthy4zL6DE78gAIsMIA/4AABBCAiIESZ7ovhhgr+7IvYAxGxFNB/PCFsHqhOQACHpiBlAFLn9FBHtS8suQ80HMUR5GC/gQqt/yfnSIlfwOquhRHvIyDBrg9LLTCBJCACLCAD6ABLWgDNUCVWloDxExMe2SAtgsMwlADR9AET/gEz+wbUjAFFVUFz4SFzjxRU1i0PMSE1qmKFokVppi6nHPNizzEpVIVcAo62QyKOUjEQaDES0SX1KEqlXRHWqsXbooCKAAjoqlJBCwjM+qADshJzLisg2keCkiBZnO2BKjFhTGA8zRBpUzTNJXKYSRG/HAIrAyGS8imbLPBZ4xGzJtGfOu8I8BG3siWQAXQAP8SAyH0z9dwlDGbLiaUriwgRywogAvcSwKAAL+0ABPYQgtNgpMQA/LRAAfgjHv00ABIgBJoAAMIgAL4yQYgA0cYvBJNUY9jUc30zFU4po7zTFTohEYoBEXIg4qLuhxtita5MyyyyPFCv59jKlATUhJxonKhxN30TZRkhP0bTj2oOuPMJ6LpOpf5lxLoAIDRAN+BUDVpgAigACEQLQQoLeW5MYUygIVwynll0/wqT3wtT6ZMyrDqBTjYASBIGZaxNx7QU7LkU8+LmiB8lGwhPUPNjYeNmv8ZICIER4pFUJxYgYYJAAG4PQmgAAoIAQrI1DLQgh7AAh7gAA1YzDoRVXv/HIDbM4G4UAsDGADtZIAzcARKKNH44KqBmAVbXQVYwFWCQAVpSoRJSAQpMor9MwQwNE1cOlZN67S/ClL12w4ScT+m2gNGIMlKlARrdQSmTQrD8oNA8D8ofUQv4hEaYM5v7TVxPcUJyCHfsQAhEAIdM62KucXOUqgDaAj25BVdYE9+JSsVyld9/Q9+1Q9OuAFrE1gVCEs9Hcs91TezrIJ9A6Ag7KmGLaWIfdidypbeGLPoekKMLYHiKVUJ+NgL8IAaUAItKIMkUAEGmAB7bMwDuMcDsMK3AIAE4FjUKoArDIADmABXvQRQmI9T6Kr5clFbtYVa6BtOSIRGwDjuk5uo/wNOpzVNYt3RZE0/2tSOIXWC9ksceckD0/FaSWC1TLxWF3EKPdg0CvEQHlkxJOOTXiuLmsmALNmAFwgDZpOAJrkSY7OLF3zB8BRP+8qve80FxGUIwY1TsfoDGfgTyK3PPWWO+yTLzuM8LDDLAVpYc1tYh32UALVGAFpCRwVHKCSDEqCLBBAACABZDLiAETACk22NFbCmA7ASBrhdKyyACcDCBfDOKinV38XCiTmAD6iDR/AE+fg4Y3Lez5SFWhhaUsAIYbqESfig30TJpNhe7t1RTZurOKOQCMFapgqiU0M1+jsEr7VER8BE37RWqEuXpuADerEnN8in5WQxrxPXgP/KgA1ogTAIAx0T4L7ARYMitKFt3keeLztMBUoWuWNKyGNy5P3oBV55ylJYggLDrR5pmoLFPA2m3IPt087bPM6bGhHmKZ7KAuV4VEMNoogdJUjxDTITDool3aD6gOSJIxmeYQmAgAtAASKogR6YAibYARlYRStRWQ2wWQDogLp4iwGwgBdwAAUoACtYgNuD2YkxgAnQA1AASDlciF5YPFxg4FPghEywqvUwHEVQ2v0DQ2NtnbWZK/HqtGlxCSTqJqbSMHR6A/uzRBJtNd/8zeDM4/iNnShNzuBqMX/agC0dmAr4AIERASrA2wfAgGJeAM7oC7M7KAdm4CtOplvIL0f/bulCq4VXiOlBe4VCawhdyAUHtoU+AKnckinJVa56m8bLVeWzfAJIEV3RZa7psmVD7Y25C9DN7WUmJN1SwoIVyKG4UIALKC0IiFATqAEoAIIoWAKWpWZ7lIHdDYAIcKO0UAALqM4FmAATmJhJnZhV/YA1GIRNiMPEA4ZeqI//4oT+Yo+rggSMawSxVZ3t9YOnbc21eWj0mxZmtbAfBdJzKhedpQRN6M1WQxGqet9106Kf04kocLceud9++oBwjdtJGgEqAODRogAIPRgG4LEmoYsCIIDCXaEUKk+WduQ5pOlCowXipoVe4AVeyAVaeIVV2IEZkCn7+WlpTOWy/GDM/2Xls8wChvWp3qgN6XqCphZd37jGhQ0zMBNHMpgCGigBCziYDjABLd2AMpI5IGjmZ/7JwOhQLDSAIYijA3CAGTCLBGiABKgBialrDJQjBeAAN5AEWRBGXQDN+OAETMiESrCETMAES6iESaiEeU7sRICXpGjsO+MDnfNnCZuwcqpsdDK6adkD67kEScCE9aXWxI61eHrserkQm9gKC96nsDCBcN0AFWCB1/ZokE7FL7XO4ZGL40ZuXuBX/HBgxF0hnL7yKxeGX/iFXVDuRpABHMikQFEN6a5chN08675czjPqo+4NMXgNKRBHpPYpqEFqJ1gCqh4gL5OuKFQDLHiD8f/4gj1pTvmxgh7BLZPRgFX8yZWdZgYtgAZQgMAwAIMxABNYUAQPZ4hJtlWdgDrYhFZwBVvohE4o0UfbhExIdRLKBGASpsJObJSUOqglv4uspVSJCYIeaHkxOhuZA0WIY0rwzYW2YxzHpVqLkEcUwOT8E9TgJyEvARb4AUAAYBDAAApAi9+JgDOh7SZPgC3/9l9A7lzYBXIv9y7XBSjnhW8XBsUohmN4d2eQBmVYhmMwhjTAUx4AlPupPLG03OuuAizgAjUHeCxwwtLNAiL0AigM72vEDVv2DSDg5TKryz5PlfL6dUnQAxxQAzqYgjYgA5QlA+9R9FXUgB1Ig2mm5iv/zJIFqJIILAEMhNkD+N0BiHSK+d0lZgAGf4S78QRIS8NPgOdVz4RhshtXnwRIkBtr1d53Am3DHMTxAq+lyrBzmj8iNYRWm/FLpGOlt+PCak3YeYOwRwO3vB8qix8TiPY7AIR1rfYIQKMJ6GrgYYCEUQy7b/d3P4ZkSAZm6PtnmIZpqIZqyIZs0AZu4IZ5SHzFV3xuyIZfkIEVeCnnAIJuA5rJLUvs9uA0K3i7lK4DNSVSqWWmfngj7DeKvUsyuNA68APUcQRPwAVZSF5QmKc6iAO0gYMbwAzOuAHjw++9RMdSnYDkmeuJUYCJ8dDAcADA4FslvsDAWAFBsERJ2ATt/6MIobd+EXo0Ln51sSX2EJM1C0LWWpoDOLBsVWljdAOsruVNTSBJhVb67OU/+BUPOlAVa8mNHnisHokfG1h7ahcBgLBQIQNBCxIkRIjgYGGDBgoUJLBmTRtFbdy4Vax4cePFeR7n0bt3jx9JfiLvaaP2R8MKHjV48AAChIcOHkVu4sSJZOfOKkiqAAWKZSjRolmOIj36JGkWMWTEiJEiBSpVqE6YMHHiJMuTrke6Lj1KRk2cOnsGKXJECZUvYMN84aLEyJAfPn363HDQgIGGNH41HAgwQDCAAAEAIA4gQYFgA4YZDCg8YPDkyYgvJw5wIMMeSpcwdfokmhOnT51Cn//ehOnSJUqUJkFyJJuRIkWHDhkSJMgPbz97fuepI3wOHDfGjaNxYsYNGjRr0JjJo+iRJE2eJGF/pP0Ro+62DQ3a3VsPHeRksIyBAiVIDiNyAAESAuJEBwsbPmzYYGH/hP4L9S7wUDzqqPPNNxwZyJFFCIJkjz8P+lPSPfTMw00xN3Cggksv8ZCDDj3YlJOIOxXxExJYVFGUikYxxRQWXpABo1QzRiUGEzVqpZVUV2GV1VRjlbWHH2ldUootwCBpCyqgMBJeHXnAIQMHFTBwg19//JGGDJAVZhhmhwEwmWaUBYZYZF5+2aVgB0yAgyCYlNJJKXPGKZqdnaiGyWqTwDb/myO04aaboL3toUceh87xhqLGiQGdGc092twch7hGiSeuZaedbH9+p5sjmFBiCB10zGHGGWekp54ciMSXQgwolKBfCSV00MEFFvRXQX8K7cUAPRR+9NGvH11kkUUe0cOPP/vko0852kjk0UWi7IBDSzW8pINMOojY7U0/pZgEFuIOJa65RXHBBRbpqluUFlho8cW7U2QxBXpY0JtvvU9IkaO/UJmxxhtzCCnIIZ+2ggswcKFyKSO+xfGUDB9o0BeWi2BZSBqADWbYYWBeNiYAB0AmWGUFDOCYAAWgnMDKBRgAMwMrCEJJKajIMosstpxyimmlkPIJKpfwCUlsjdSm/0giiQyqm297BPfkHHO4ocapaqixxhpYr3EGGmq4sUYchlCiiaVmS0KJJNQZYsghtCmySCbBvAWKIG6IEcSpQOgARRvwCSFECiSYEOsHsepnQQb97aoXAw9Ji5FF2RSrTTaXZ+OM5s5MM808/Oyzjz/qNEOM6cscU8wvedxgrUs89KBtENx6m1NP5ZK7IlFaaJHuur4T9YW8vGsxhfHHI498FFE4YZVWAD86dcGHPOJJwrjY0oonmEjiSCB1RMz6BxzssIj552eJoQaQdewlmIQBwEBgkx1wsgCDCbDAAgW8TADLMR+AA30AhS12xrOeBY0Up1AFa4gGm0Y0Qja1af+boJzmmzzM4VB1mEMctOaGOLxBa6c6g8C2RhY/PAIUmrAOJR7hGkckojaMeIQiKhEMZBgjGLI4hBvMsJwxjCEKYyBEJGLwABC8qgQrWMHh8pMfglQgihNgSICikY1kECN1wviFMITBi12AkRaxEEUqUvGKWOyCG/fwBz7ooY1fxCKOvJhjJaqFgw/ABCay4xZMvNUTobiLdysi3lDYRRRxCU94vEseI4+3PH/961FumEMd/GAwtXgCFa1oBSo0gQntHAJ8a4DDDnZgpUVUIpWVwJgpb1AxB8hvMGqC3wDqV5nKxAxlAUhABFwmmAbEbDIOIdkS9qAIUMiCFKQRjQL/ObGJTWQCE5YomtEgqDRDFKJtueHNb7oZHA7GgYOK6toZ3HCqSQ7MD2op2wrV1r0/McIRk7gFM57BjGG04hB7KBUd3nCGNgRCE5Gggqts0IIlrmBWs3IiQaA4Rb00IBbOIAYZX1HGV8AiFaaAxSxYYQpRmIIUsIDFL7SRLH7M44286EUtghEMXeTBlEvMow5kB4QR6eQnuoOXIAMpSHYBrwhYSGQiG9nI5fULkjkSgyQJJqRBHCItmHrEnw6hhw6moQml/IMoKvGHRTSiEhq7wQ1kULH1xfKWgyHZmQRjsvoVQDALcNn9eGmAyRTAAg05AF8Z0IRCNCITn+BESD9x/wpOnMaZe6KmI2oT1dts05Li+c0GKTk1DloNbMdxw8DqcIjqsBM7jugeVScxjGpU4xnGQIUhwDcHOpCHECsExBa24IMa9KAHNFjiDBJaAvxsoKEZ0BVDbuELZuiCFa7gZCtksUlZyGK5ciqFLHTxC8rdIx7zyAYxdIELWQADF58QwxIQmsciyCQIN80piXS6U0Lujnjv4oIXvOC7LyCSqF8wKiORKgb1AHg9z2PqGozzBthachCG8M5tvjeHNJTyBoughShcuYM/FCIPEHblWTXggAw0QK0HUEBkQrYmMQUomAWYwFwns5AELOCuJNMABzSQh0p8ghQhHQUpgiYaPP/pSZpFa2xjJ8ibQdWlUHXQgx6G08FyhvCcIXTDINIW2tFqRxKT8EU1LjcMSOxBEHp4Q11kG4pIyMEHRlDCFJTQgxrQIM69LYEKgPtEXT0ULsBAxnNbAYo/e2KFa3ubbDoximrMY0LcyIYo/vCcOayBDDnAAQ5moKE+ykQrR9CJT3iSovcSUr4/rS+phTcU+Q6vePxF3lQCrJ4gwHqpZghC85jqnDVs8Dd8+F4c4KDVG/zBFJnYwQcyQOMmZLWUUjrrDjgAS1uKCWSGqUwAFBABBexvAAtwgP4GkAAJ7M9jA+ALWiXMY1KoQhWnoFMpBtsJxRItNn1qrKByI54kJ1n/OBsM29U4WzUynIEPj1ghC0eLnUlw4rjD6EQiwCOcQSBCE6EIBSDYAIY2+DMKuc0ttmbQ2zp/IOTBxXME/DBmAuYAClHgwQtQgAITFG4DH/6ACsSQB2dwIx704EY1aAGLQmhABUu01gpUwIHz2iQJSchpp8G1053ql771/YIXvhDfeMmLDFonylFYlAUpTCEK6hG7epwA67PT2kOyg8JUTtVZ3kBJqzvIgygsQWwamIADxpZBE8TQBLJqgO9bYoD8+HpLk4mpMAaACGMMYIGHxEx/LuvSuAlvVr78gROnWMUq0q3udQONFO/ORLwdOInGGiKGuLF3b5Lc5OGQM2tW/3MCwPWgFk2oMG1mwwRsLJGJ0yvCEFBjhMRDoQk5XPwN5jxDGZQA4NjRwONFB3lwhzsBKTpAEodwwAQUAgEILOT6C7CPDsTwh2lYI7vbfYZqG0Hp3vZ2fEWg6Yd6wPQ/AvLpQ9Wv8EhddVPzn/Bo3Xlw3dYZRRCNHYBpBdrBGqXVlEwAARMM4MCchR/0ARwswQ7AQSZYwhJ8wA+8gAmsgFlpABA4wa9lVcUQHgPIwA5wDP0kXsjEVQCwWLclgAPAGGaMG8ncwApqwB98gipwnuf1jBCeQtAoliXoyWtsSjwBir1ZUF002R6Ekz9pHXn9CBnMAfF5wiWoUKB5EiZswv80TYJt7IYm2MLEEYIc0AEfkMcbtEEZlAEQpUfs6EBvLRH1QZF9ZMAGzAAoPIIK0MoImECtdIAJWIAJ1MAZ+AEkREOioRRGTMMxMAMmMIEULAETLAEO5IBM6NGHhMi3/BFR5F9RWJ0pnuKLpEt9qYupYV0iDSAWxGIsYgFSjEHYRYEjkV0U9AtWOIEQ0eGp0N4k6YEfRFWGuVIaQMIiyIADlIAIfoAO6EV+cIAM3EAeNAFaMYADpIGGbUzJyBJmhAyMxVgAcFsCJEAA3M8BNIADaEAPzpgG7EAjuELPrNsR9kxhcQIHWgIZ9gltJMJtBMq9JZmSWVYc8NsZANwZyN7/pKyQJwAaRHqCIzRCbEgQI4DCxEXCHZSBHqBBoqiBHI6B2akHEOTAxx2OyDnUCKAADYxB38iCJsxAD7TcC7yAC4QgC+iAGuzBIniOstBDPJTDNlBDNuACeZnBDuQAE3TiTNBEDxDB0jGdTwRFKepfUdiX1HFBIu0fUQ3gV4JlUYjBLSbPLSKVv0CB8QCRMErBGRCMMTJCIWiMNZqPBmTAM9bACjgBzdXAb43Pr52VDGCJX6SBK3GJYQiAOiZmYQCAABDAysxVAvDPmsBS4PHVjKVBIpSCPW6mPZqCPkbTapBhbMjQEzrNIPAGH/zG622Q8lnNQmLNqdTBIJQNRPqZ/yd4gtEMWfXgQiiAAiHYAR7wQR7sAR3EQRu0wRmYAVOlB99UGkKp5HC9gBUQQRfoAA6cQUwmAcvxwBBMpwnQQBTQgR8sAqLpwz7cQzpcAzYsGiRkoN/tQBDggEzMX25Fpe2Ai9MVkroAVX+uIrv439RZXQAOYIBqnYFWBRCFnYLyIlrm4lqegdhpoSUdjCIYTZaYj5RAJRHMQBn0QIcuUbGF3LJpABxgDGGmAZZsCWUIgGMmprTBDMy8aOWxoAzUEskIZiKA3pzkoymogikAzWBlQiaoxmjKBlUBSqBElje9XqKQ09VYzTn5gSTgpvW0wiZoGZ9MQnXIQm9GQiD4Qf9u9MFu4IEdgBBzdE0QOQHfeBxKFlsGEAEYUOd+YQ0ueIJQfQFZEAENOMHA9AEkZAM9hM49ECV7CkMaQMUONEEQxGcEbtqHKF0S8IR7laLv/KfUkVp/lloA6leBBuinwghVMKjxPJKOqMcUBCOqjMEZVNIlKcIl7MwpmEIl/B0Z9IAWAMEYEAEPRMEHJJQJMFQGCOYyDuZX/QEcQJgD8BXMPCYBEIC0tai4kUyVAEZfARskrELP8Kis+qi6AQ1pINYmXII/QsLawNN3rN5udJNq7sEGIWSBmRC8Yk0dMAImQOSSiCvRlM31aAIhEELw5QZ4gCl5EIeiWE0Q2WH0uSn/GOCBxakBIvhBHQQCMLSCHgTCxSKCISiCJEDCJtCCNtxD6NCDNUQDNUxDI+wAVDTBEkQgEBzBxm1cEgDFKHLBp+kOplad/wEVpwpPGXSqpx6oFyRFfT1FVZDq8jCPLz6PqVwNQ75BMQpCWkgCKOACXPhCL5wCIxyCFJjgGbhZFvjqDLicyylOBlwjKp3PKmEJlETJ48BMAjxmi74oYWgGX6lgX/VFIXyCLKACKngeEdrjuvWYaYhm0WDHO9mGQAbK06SmQcYBCG2NvDaFGyTCJuDmknTCamDC9ZyZIcjGYwFKeJgcbI2KP0VoDyRB7Jzk9EXCCv3Z6yLTPe2MwjgX/y4ojDFwA+jswzxQgzIww6GubBOY3SVCaqRGQVdUpc3u54qs4v/pLIDyrM9+gRyWgaeSWoscRVTMiBQsD/JcRQTmCNOqgT8d2B6MqdSiQtX6At0YAzJ82Rqk7BP0gBosUQ20AAqQgAtYgBJxAAdcY2B9lNpeDBy4EjCxDMsIgAEswGKaSS3dLQ/mAT3iQmeqgiu4AiuwQrpxXrbao2kUKZ8crgTdRuIubuspWWWdqXFozY2IQRoUAibA7idsQikoDC5oAiKkjXZ0B6cE3yCAqRT2kxrslxZEwbZU2gzY7nfZLpIsjC88AzJU7TAUkC3c7ueIzjxUwzEMwyTcQKOIgf9MJEEUKMEYI9WMHIF+oot/AiioApXz/h//yeEXFGgW1BcdCy32gsUTdC+9PIFUMsHZQQXAka9ZjGlUWcInJIxbFEP7um8vWEIhoEEOZIHQ1YAL2AAMhGAHKBEOVOMSFEImpEJXrRLGZIkpaUADHEDMtOgMiuMBrE/9kEwT/MEk7AydqAIrjJRybXDnFaEqtBu8tYZoFVnSQNZuWFChMNlwiBOjBEHfpUHN4OaftcKRAMOZDZzZtNB2WJMi+OsgoCZ50EEcmtMtQoFJ5kB4JXESMzEwsN/CNJcttIUxWLE/bFd3ETBUSEUSHIEOHE9XzIgTnDEgBcV+Auga29fzsgv/1Sn0gCrS/sli0NZxHTPFeTDFFICFPt9EEqSXE0jFGFTNJBGnIGgswp1CdQWDMaA0Mqh0MQzDKWCjDPRWDVgBFbgAIYrgF9zhDCyBGPRBJQxpKi0CYZpSE3AAiaFM+7hVmMCgK6dBI3yCLdjCJ8xJBeeyK+xy51Vw57Xbuz2TuB6uRfKwkoLHZI1uHRhn1awBrDGVD/GBpWSSwiwMKFRHnlSK2hjNnyACISDCIaCmGxpnEKPKegSBc/mZnwEaKKSvLQwDMgSDaCC2K/AC5TzIPXCDMVRCWT3F1ynFV4DFGV/BFfzRH332Z1fBFWglF4w2zuJsV3YlUeUsqApou6zi/1Ak77qgyKQeAQRyNIFxllNZ0khvAirMQi8MgzEMwzAsskobNyf8gRmoQAbYykFcAARYAA3QXAbMwH3IQBrITSacaGFaCQegsuF1DLRdZl9xABw0giWsQj0uUHtbsFXHt1VvsLYi4WIZDVhzyuopmG70gQVCDdRUFhw8h/I1R3OswRYiNsUSkCdYLm5uQjuZ637jRni4Ifj4G6pMgXrogHZk8yNEQiS4UHVMwiXcgjHUQiVMAiaMQi5kQzwsC0oVQ5R0MVKMNhKMNmjjuI5PalDk+GcDFZDTl6baV1e+IkGrMStuZVYCFSlWZbvMbBFsGvhKhQ+hwSRlkPkKQiEowv8kzLAr6IJL0U1y45Bx+0IiyEAFWMAFFKIElEANqIAKzEBe0kD/brf5ZFhWQZiHEd5l0s9l+iDhzV0jaN4RloIG7/J8zzdWr9toiOtoQsK8fYfbsB5v3AXUYBAcaLrywSuCv4Ei6IkgMIL1OLgYOrgnuROS2kan1IVwlG5IziEUBMIgEMIhBIIiIEKuc4ckfAImiMIrDIMw1AIrpEIaecM//ANl50JZyYAYZEETNMGN7ziPTyr+AcWPm7YaZ3tBwwtXmhpR+Oen+qf+JS8SzN8RKO1ua12BddZvXBLCqULO6EIv0E1xG4Mw0E0wcEIepDlwrcBL0IAStGlLuBIHyPL/H0DJH7jgQjBAO8rPChJeh7FgiuKYYeXYZmqwfCt6fG+wt/7yB5f4kAHKBBVCeNxbH2D6ZVHNcTzHo00SJfzZg3f19iyhMDvhbVi4HvCBX4PQHBKcNDfX7NruvPdCLqA0MyRDMXhDO4QOFjdCWXHAUUB7ju/EZ1e7pyUvtgs5kTevF3Q7UbX2pyZSpl7qTiVvlPMAumeFv1T5gaNTq1roJXDCIa/CLYQ53XQRvrtUKfSBGazATGpBGbiAFczAFPSAEqgBGaiADKxBIvhFHvyB+niYO1ZAr0R8h/WFMs5JM3UCKfCoEAphortCdFkw5xWhzwyWajQQn1AVDwMsFIoH/8ofCqIYmPIhh8A4AihoD4SbOm6uEKiojSPo8AShJmoCsRuUQVu0xXEfN5IUN/MH+y/8QjE4AzVgQz7sA0odA4QZHWq3CLSDP7QfQadd+7VfgY//eLgfNKm1Ns8GIBv3p5ODS1CQyKblVuo6ARToyI8wZDllkB8ARKFEjQZa4qRqlq5ev4QJIybsV7BetzIpegNECxE5NL4oUWKnBwcZfyyJEdlEhoaUGlhqcOCAQcyWKm+k+SPLlitZqjJt4vSJFKlSqFQVXXV0lSulSFepSrrqVClSnzht2oQJE6VJkx458qoIrKFCggwJMuunzx61e/LMcev2zRw0btz4keQJlP8nTZ74evrkyerVrJIoSerKiNEhQ4oHDfKj580ZYMMoDzNm2bIxZJc1BxMWbFixZt3E7bvHzdSNGyoycOGSBXbsJrNpz65y+0ruK1W45K6im8tv4K6Ju/Zy/Ety5cuZN1d+/DhxL8SxYLmN5DoS7dqPFOnxvYcTKECYMHFyXgoZJlLmztnjx6zARpM2lVrVy1cvz8WKCUO22ZU+xACijiKeUKIHPGpYYaRGdpCBgwwmEEkGGXBYSQOZWpLhhh3SaMQXX3SZZZZMTOSkk04+KeWUU4w6SilXkopRJ6WKKuWTHDsR7BJJfJTkK0UUM6Sss/xAKy226nBrjbneQAONOQz/0QSUKj1BBUdQ/gLsqksGe+QwRRATcpA93nCDMmPU/G/NzTZTE7TMkmGnHX3mceaPG2RQYQLidJOtNtt0G7Q34AY9tDjjpksOC+ccbQ66SL3AwrXqrMuuiCKQyPQI8HpIAlQddOChCCCAcEIKHHIIQow15qgjDzfgyEOQgehzBRdfggGNP2SK+W8YUv5Io0MxoLBjBRVkEGi1EjqwYIIKO3yQgw1TUi0NmzLR1RdbcOEkEy+tUrGUcomCMUZY1IVFlltqWZcVVaLCsSpMLqFEq0kgCVJIIosU5Mg9kswjjzfWWIMuNJgQY5BH9sILFVDKLfeTHTfRC1/DugLTkcT8/5hjDWSGeZOZZ/4r5jKR1dTMTWfUweeeeXKZ7QYOKvAzN0AD/c01Qocb9DbhFFX0OEsffVTSSLmwtNLqstOOU09BTUJUHngw9dQVbsDhVDPQWEMMNODoQ5BCFHEElVZkyTVNllke5hVL+rhhhjJKUAGHRv6QYQVnLcgABxw+kIGJHfRkaQfDPfzjj0ZM2RU/XD7JxBJLxP0px6GcmtGVdWGZ5RZ3a5kFFhtx/MQqey/ZSl+vGAELLMXMEqSPPNZSq1UoDW7yjDgOoZIvLCfGsS+9BvOxsK4U8ePJy4bZ9XldQsSFellC7HwYXlIRBpty5skGEjjQICOIHLiY7oomsv8QQwz1YZsNtt1w+zm3QhElOunl1Dh6/y+8eM5//wtgAM83HadZBzvWAZXUvpME8FitCEyAwgSjIAavuSEutiPbIcQkCUyAwhW20M+uUMYyZhhDGItIwxg+kIEbJKIJEYpABBrggBWsYAMZoJC0DKcaDxWiErPwBS5koRSq2AsTgdnEis5FI6Woi0SfIx0sWFFFVZCiE/Vinb4g0Qgvnk0RiUhEIcYyuz4kiS0Ey8OSzuSGMzjhDYigBChQETGJ1bGOedGEvQrjFaxQ4hGM2IMZxNCKtOFoE5NAhSQY0TFFGGIgi8hELH5BjGZw4xvzOMYf5nAGMZTPT+7LgvtqkwX/+d3vCvYLWv0Shb+jIU055xtaAadDndtcqgrWKYIDG8hLXvYAgqc6jxOCcB4LtmcOtvMDBx1BifqEUCHBQNkxkJGMY1ymFo4IggbEAEMO4GADE8jAB3jAkQ3MoAk9zFbi1lkIUuiCiK44BSmqUjlLYGVcKxoKUmT0xM9BcYrqgspUdoREe+nLi41wZBgTYZZ/nTEtftgDrNryFiDwQRN+eESV6Ci8oaCCL10qzF0Gcwg6fLJfikDEShFxhzjgoQ5wSEMeFpEKYijDGtrQxja0MQ9RpGEOapiCDnKQyt7EZpTvqw12DkW/VaYyOq0sIHMaBUvk+K9pWY2OpYL2tE0d/wGsU3PgL612hGEWMwhphYITwuYGtwiMbAJp5hJRgSteGeMYxSCGmoZhC0UUoiQymMMKKoADFRChBlYoQRbWAIfFZQuyaVhEQmSkilJ04qCsw0oSUbSiomwuXeuqxWinODp5SiWLWcSEJVgHiS4udIyKKeORyNYWtbSlDm5AgxnWwAc+/I5KVcJjxPqSukt4YjCDcAMUdBAIQiDCuYTAAyLsAKs+LEIUv1iGNayxjW1cI6faeMYf4LAGNUQhB+YjzijVR8qlCqephXqqdKAj1fNZqjpIi059mVYpWeK3q1WAGqfE+ikH6uA7RTjCE6QwQQc7eJgXTGYy+/AHQ5xNEv+TwMQnXHGLXghjGMQoRmUoo59GzJRvWJgBDYDJAzXMtBGVWATj8kDePHBCF7Jo0RFXx8WtXOJy5LKsi2D0z1mMFsnvKl1T5FUuLG7iEqyFxFb2tdDY/Qs+EZWoWtxABy8jghGNcRheOkpHjoYUE3zRhCP0MAYg4AAQd7gDIgjBB0Jw0BKvKEY15jGPe7DjGt4ItDe4kY1XpAEOYnAzENSbM/jpbDa7QRTQ4HtKo7YyN5RamtGM9gUtaEHTm6ZOKymFywMicFOaMuswJTgeHQABCuWRghSKeZ4HrzWtbP0aomcVVyEpAhKX+MQqPKyfygijP5thxSLEsAQdrOADgWv/Qu3ykAtaWKISlYBEIWyyCltY9hNYYS0XXcs6cW1CRUFhEZE9RyJ3g85dsDAFPTNRCUtsot6TsHeUye0VR4BFjGWcHcAC1odk+gEU0JVuIBxGpeGWokp/2USVNGGIN6B3BnewQyACAZ9J5IIZ2eBGn+/hD3+swx3rEHShnSFTM5jBCTlYgvn+NJv2KRV+upnfoYTmG9z0jJWFwu/QLfXp6jQtl0cnNS5zeZtNo/oJSUDVecwzQVNFAT1OYEKt1yqetOaare2zIBwoTLtaMQISmCCFt3URp9AQ4z+bqUUjxJBeDq2BcYvIRSogUQnKkTcRqFgFvbDS2iq7dsr35GyO/9TtIlas692kJa26WDFvp5wCXCay17hbNwnYFolIA0eLH2g1COnigRAcj8ReOmrI4X2iSpLQAxqgkIMZzGFWkIjFMbQxcnqogx734Mfw+WGPdKTDe9nIxQ2awD4n4GAHRa0fe9kbqCb4pqmS9pmlVTk/pie9OmIletNzKUvikD/pXS21dp7A4FkP0wlRII8U0EP/YXadua/G2hKYwLUlhK3X4AAO/kA+IMESTgEWoqmEnIEZmGEzhqEWJqEP0okACyEWdqHesm0R8qAPFAlLroLcukih/K3cooyzMEcoHE+KSKQWQucWdEEXXHC0SkcVTEEqqAJcVIfKWufziETgBP+BcR7DywghEgAhEDaOESjhgz5quNIGEw5hDsygfGagEXZvGkZOHeRhHbYQH4Yv+PiBHWKGG7QhGxahWHIg5nBgCa4ACVKp+qwv0nhO++qH51apNwRMO7oKO24pCbBganbJUrIAC7KgCp6gCo5gEEXNOk7tNrrjCKoANsDK/d7v/kxlmGat/WYN/7Bm//ovcIDAghAtW3rtDwYiEz4BAdvOMhrwGRxwZYIhExon20TBFERBFLKtEP5AETbhA71kEhhhBF8HMbyiEcqtck7wJ1ikKFjhFdxttF4wBl3QXeKNFaBCKjihXoBsixDKi15njArBX3KxD47ED9rADu6AEDT/4fTE5IPSpo5aAR5b4RH2wA2iQFRmgBuAzx7iQR7soR6Izx7Y4fjkgR/ugR6+JxuEIQ2ab9ZmLQtwJje0IyKvrwnakA7TByORSgxGSX7gizd6QyIFrP1G8glgo/2OIAnaLzbGAAukIAtcEiaRKgtKciZHUuqSQAomsSEpkQlMZYLgb4LWoyHhzzwuUQqMBQqOSWwoLK4SARgnQdhWoRZGKDNY5k2CgRZEARIWYRGyzRIggWAOgReJC8rwxd+84hF8xNywAkU6a2KIwp9aUAafMXRGSxbU5YpGgSqgrNxEcCC8SIwC7g/QiAMBZg/4YILwABiAARcewbkMIQn1AhTi/7EVPMEQ6MCNxoC56EEe5IEd1qEe8MEd/IH47uEe4iEdDHIetGEanAESbmAjTXIkD0UiabOpSAk22Ec3HxL7rqNnnK43SPIJwGrBhBM2pGAKknMndzI2RlISdZISJ8j+qA7+qhNVlpMn6U87jSX+LMhrlnIcHSoRzkbDhq0Fja2E3kRN+iMrs63eEqEPHOFiukQS9mVMxKSRvGLK1vIq0E2f6ojdjoy0Io8u3yVeiiIqKqZLqEwEvYgrAW4sjoTgHkMNKkALHgEXEi4SIgFMACl44BEVHoF53GAMpqAHaGAeuIEbysEbxmEdzmEf8IEdygGTUtRGlyEXTKEJYNMl3f9P69jQIrNPSNdnI0VpN3UuO4KGqXbjCMqjPJYASsvDOlVSOEkSqU5ywV5SDHbywc7q674UTG+Ngn6ygipIDK5TN3WTt5JJYMxOPsqTE04hIYzNGPjDTo8BT4vhF36BF3SBFTgh2KjsixLhEMYCds5GP/fTnjhLRfTpFJLic+xyFmwhyUYndKaIFU7BFcBtRzrBE5RwpBxBocBotszC4IJKDRpgBtpgQzUhEjiOEB7BECSBSuBREwRhDjKTuWZgp74BNbsBHLrh+L7hG8ZQGpbhGIghGX7hFRZhB3DAIZdTSKf1T2QD5zayI5U0U7Z1O46A/5yUCb4VXKE0JaOuXM3/9Vyp9DnfryG7zkvBlJjiVa3Oo5gcLAqiYArwFV+lYD221ILS1Gsay3aS6Q/Kxlb6LhNM4RVyQT+IQcT06k6vqRhytBLmgxvDokgKgYPEBFH3cysqx0uSSEU6QRlVoXNKRxZSVhaQTEAjlRVGYXg6AcjuhZFexyz+Kow4aS4MTmxaBQgYgA4igQ/w4BHojBCOFszA5EoYQQ/c6AygoAdE5R3OQRzMIVgJTaeyoRqQ4RdSQRR4YRckwhfgQCScgMGiYDpNKftqc1C2Q5Tciza2Q0mrYFvrFqyiFFzDFUr3dglQMgkyZWr8NnCHU3Clzjza1Qks0dZwLTzWynGHCQh6/yBynUDqGOwlL5f+AJaQAPZryqvXmvIv/W4UWCEXeGFPHULEHlYYdkEUMqGLEArgiOQQZkcgDtXfthEqz80/ScFFKA/ykIwaTWEUOGHzEIqMInQPFOFeXoeMBhMICYaMEsERGOkQKMEWNEHhVioSVgpIzkZEMbMMNLMHaqAG4OEcxmEcyuEbyDAblkEYcnQUUuEWqrIUZOADZqD97pXVrk83atN/LRIJjgAJaCOprG8PB6xuMwWCigBvx3UJ9q9vE5g4BXeCwwpUtC7rEtdU6lVMxTRxe6BTwmokY2Mj09SEjcmEj4nsCrPCCmERYiwTSMEUYsF0G8Jh61QYYsESAP+TIL6xjEBPIMbzUIuRQSehcj72nrARKEwhXh4PFuTyXV4hXkYB23Z4EXJxMAkw2FTnYurIFeBRKXBiV3xhMYGhFRCBDo6W49BxpQYBFBxhEATBTM4kfKGWBmigG7xhfa2hGpohGZihGPo0ToLBFYEhDz6ghfSXKCsSgBs5Ih2ZgN8wbq8jgbfVakjlaoBgbzmRk4FAwRR4WyvYW/uWOFmN1TpZPH4Scjs5XPW2KGcthVN4c51vmBLn/8SGYGalxuTD7zhhhneBIUQMIlJBxhKhAmknLQiGTc2CcZjZYF8Y8fazL+3tREaBFEZBFV7hFSKVFpiRRE7LZMNYZRMCBm//IVdEBBhCBD9ChIyBIRhCpBX8wBDwwA7KoA0CAQ82dDKRoRUGYXno4gzKYIJOdAayIRumIRkeoiEYwu0oQ2R8wRNUoIUy4DvKo5jKg5HX9pEPhTZiswmWgDaW4IATeIHLKpM7mRPTKwdIpQgumVPAiglGOYIzBVzfryctkTycFKU5OQiW4OvMwzxkmX1ebqjPFEyDIHByYAdYxWvCBtE40GyKMRNGYWF5AcSC4RZGYcYYp3bEp32WIHF2QAySSQDLegDJiCsTyrXsrXJO5CdkeHRpQa7nOhem8VLhDRp7Qa/7lBcmAhfgSUT0+pzP2VtAgQ4CgQ/aoA2UoAbYQA6g/2u60rkxotCNBPo7aEAHTigYeMF0RyzuHFBkdMEWWiGj2EpUgFpvaaN/qbVt7xYObSPVLFmBWVqBIfiB30zmTOWB7a8o6+8oMXhANBinZ+CGAmcGZsCwVECioU25OQCROQC6nVu6nVu5laW6K4RDAkc1tPu4byhZqlsFoJtD9ARCsPsGlsBrOFCLLWGqd3hYaoYlXsIBxOklPqACGMABZOBZb8AMxiaIF8EA2ZsTRoHATSEVkqIak0KbU+EVUsHBtTkWaCEWJrzBTcEUJNzBUyEWNFwYeAGr4SknDKlikscQHoMPEEEN2gAP5EwO0BEQ5MAOAOER7AARKs4PcouOxf9XVGJQFUcGGUrmhIABFSYBLAzjDYhJB3DgSaM00rZjtdmWNsHqtaFUwEi6pBc4pdOL0XKbPG47pzM4XL/0VDixJ4lKpUUlyXGAB9Q8vVQlB3BgBbobB467u7N7a94cB1Rja7S7Qpo7A/78zyugAibgJQTd0B2gAmaCQnbAvwG8EhIBDmpmvMsbB9CgduKgDtRCICYhRXj3FKqoihZcm0f9FWhhwTPcwQ3cwlF9wlu91XcBmCsJ2RziF3IBBofBEaDkSN5AD85AB8ogDrRACbQADLrgueSADe4gzlqcEEABDw4bsUEmxydox4OhTYAFGGTBExzhaOsATAYBCoKA0XD/IK00mf9mI4AFuA0DeDva3SJfO6ShFIFlm95P2lRUWsu1PKfLA2tqbZjY53Cv8yi3k62IOgmygAxK8gnIAAsU7JKtJmpFxfaOG86RO6kDZ08+QKIj5CUmgNAJ/SViQuRH/gBKHr85QE+aAA5cGGEpR8AJXIYfrxZsYVJxwVKPTBdywdok3NVbPdVrURQ0PMNdHdb31GGJAU+PIRmWoRmiQRq4q7uswaCPocNvYW0kwQl6QAu6oA3KwA7swAiGgA2UwAqsQNnZ4BzRnsaL8A4igZ7xYBDo4A3i4EzOQDPz79oZ0xZAoWhTjxDkjBIQ4WmJKXDKXVxJWYAjEqzcvd3h/302oFTdKzlTYntbd9ry933rau3rdptfB34nh/rlzCBfpwAKogAKSP/V7vG4dYC4vztZNP4DqHvjq0UDojsDakiHolskOqT5+rvGKgzADcKaSSEVWIEWdN7Wj1/n5zrCXV2ura3nYyEXeh7Wqx+YURfpk37pmb4adMr7dcq7tAHquWsbsAEboL4YdqGvbcEWHmEGWGALil0OfuAHwIANwMAIwEAJwODskd0OHBsgEIHCQzAQwUF04rx54+bMGCg9dOgwNiyYrU+OHmmKRChSJECA7twhFAfIlCA5UgZZGcSJEyZAjsg8guQKEplIcuq8QrPmlZ8+dQpFUqSITqNEi//mlMmEyZIlQKJKnRqThw4eRYBIzCE1h46oOMICcQoTSA4cO9ICCYJjxYwZON6q+ECXQ4a7HCrcnVCBg98KDiZwkHEDbZMmcPL0EVSoUCJIlzZ9KqXKlixZtmzd0tWrV67Pn3mJBk0r165dvE7vAh2rdSzVu379ii2MGLFix3IrgxaNmrVu6dgJt3ev+L1587hp02ateTd2+N7hwydPnrduy7Vtw4btGnffyVb38oWLkY4aI6iw2SKSCpU7doyUKcPGjhw29e/IkRPIvp07BgXChx5zuMGQQxDpkMNFjAhiSCACdhTJHYDY8R8fYyThhA44oMRSEE3BNFNPN5G4U0//PwGV4k42DZXTFVXkVAWMVTzh0kshAgGVjju25ZZEYQU5w1wqqCDDkYQdqYJfd2Wg1wcZBOZAAww4YKWVGXyA5BJowJFYIY00Askkl3yyiiuy4KILZ8H4AkwwbwYjp5y9BNNZL7LlyYtsp+XZGmyx/VKbbbgdo0wz0iRKjTbzaMMNcpDOw48+lFK6z6WYYuoPcfF8s5w116Sjzz75XEppPfbE0yk33WDTTavWNLNaLuSZp4QLLqSwBQxs3GGEDUYYwYYRSnQBhhwU2tFFSG1YGMgdBBHCBx1zMNTQQxHlgAghgSCCSCDcIhJJIEZ0MZIdauiQxFccdsjSjU6MOGIR/z3hdMVhh6Wo775CVeEvEv7+q5O8M/FwxFk88JASDzOssMJcds31gV0V6KVXkxY34EAGKtwAhBlwrJFGHiT3ociYk0yyCSpnysLZnTDjGUyewsiZp5145qmzzsIMOigxujWzGzS+LRcpPffwo/Q99DRdnNJQRw21P1RX/c/VWP/jD9PJKefoNvf4s0/VUHM9zzflpFOONdXM1osut0ASBBBduDDCBe4pUUMNXdQg7HrrgRESG0PIARJ/BMGHhx50WOvGGNgqCAi3hISLh0FsyKHGt198kbCCQMiw1oc3MnHEU6g3Qe9MRSzRRBb4vp7FvlfAPtSKNcVYVFFOmRXWDf83KMnBB0symYFffk3sl5EydChGl4oJoogjkmACSiut2IILLr7o4oubwVTky5xzDiOMbD2f/4toqe3J52yBCiqbbUAfk0wz0SiazaORRpq0ccZRGtUy5Y+piQ1TWbta1aimNaz144EPLCA9kvMpbXwjaQtcWnGaNkHkaKMYu6gTLjqhiDMQwQQXuIAHwNCFMtCABojAQw3swAZA9IpCmZtcDXGhCQvhgRB+mJbjIAcRrWwrEtvaSCA8EkNxEQIPDqNLkVTwsCkyD0lIKswNrFikI0mReRBDHvGUhzwOaMBiE+DLBK7kAAZorI0O0IAc5TiYGzTheXn4g2MaMQlLYEL/MpQ5E5oygwtC3uKQtagFImnByEZ+hpGxeMUrYlEa11gSNvOzTW4M1QxoSMM31lgON0b5jW+oKh5NQ2UqT0kPe+AjH7CM5SthialSLbBq+kigLq+2j39kKlP/0Ac/4nENahjTmNaIx6TwoQ93xKMcqrqGNbZhDeQsY31t2sQbaEiDGlDBB1vIHIS8xZFhIEIO/yFESNQTEkDwMFrcEqIbrjWFIgLhEeLiCBK7RQhvcUsPbXCLj4q0AiR1UUlTxGIYiYdQMibPixwwUhkHg0XC7GAJYkgDHKCnx0SIaUyW4AQpKOMKQbpiFiidxS0SOQtaUJIWsEApLGDxClhA0qWW/8zpa1SDPkJt8lCeBGV2HNU1bnxDHepA5SlV1TR7uAMe9XAHPupRD3y4Uh6osqo+ZknLWpaKVLBUYAP9sUtd/vKsCuQHOqxxTGNuQx5i05o96KGOclynOfOIBjF+IadPmIEGW7iPe8LJBkSEIiR4KAMeQjEMQvxHJPChITqhZYfL/bNxa6AnFKCglX6SkyPqrFy3HsEHLawAB8ArDA5yADyHrQB4FY2txCZ2RcKodgd3JEMa5qCYPYqpEpbIxCc+QYpTqEIVroBFyy5ji1nIwhXQjSl0W0qLVzSSkanIrnZ12hrTmCZQ9Psp/pDZnG1owxsWLId615uOdqzjve9th/9805aO+rKDqviNqjvcsQ545AMe8MAHPKQznQIzUx/vAPB0Ynmpr+bjlfrIR4Qn/FWwerVUu6wU1sbGjmKSN1Riy6U/5FFfb0hTG9kghjAqUgoxqKAG4QwnGIwABvz4qgtsIMJ8xPXYkewHWfppAx8uFwg/MM5aZyjDQ6AwN3x6pJ+PqJw6AbGROvRgJWdJS1pWG6QgqWV0GH1eYvrQUUc4YkyY6MRkWLaKlmVGFodM6XWta11GwiKRjKzFdRsZC9O0pjSf4WlPi1EooH6SvM3JDje8wWhvsDcd4xiHOSZtDnKQ4xzylS+A38FpAAN4HcJ5B37x8dR6QJWqAP5vgAX/bGAJtzqWDIb1V3VJqatpmJcILOuGx6aPdHSnG9voxjXM0eBermM615AmNGwzjGGgwg0z0AINfvBNNljhDjUegrWN1QZolYEPEBpJhSb3RMdWNhCDMHLj5pnkJc8NEB4BBIQmB5LJaeIRceiBGMQAMi/BoQ/RM8QhqEcJSmDCE6BARSsww1xcbGZNEI/4ISd+SLjR4ha5YGTGM75n7wKKZj7VzTJ488lsDHWU/LsHcezBcnm8Ax3uwO+q4buOmAP4HOLIuTjOwelznGMd5zCHOLyh85xj2r31DY5w2OGO+2JVHiy3x6r9u+ACV2o6lcq61ilFNaxrfYFZl/WC87vf//0WHRzJ9k45tuENfCDwleu4hjf0SgxjGKMVfXBLDX7QghoAThOI8AEbIiEHK4DBDgGKIeL6aYfQhiJAhDhEIPaQBzegoSFlqCeTgzA5RABCXNsKyUg0Ia1IJBx7mfHeeIDB+ta73vVy8kXOOsO+2sNPNd4NdPwGVahkLANRyBRlco42jwkan4MABCA/DvjLCsOaVBGGdYIT7Ol3uLfmZadq9guMjnTUvKoGpmp1qvNKr+PDH5UqoPpviUuqcZ1SUSsOy5eOVHWgYx3tgId8fY7pRntjGwC4DeuQc5E2DuqFDd5nDu+Qa/CwDuVADcSwC8QwDLfQB0CAHiPgAlQQLP9DICyIIBKEwAaHF0NdQAiagAc0NBLPgkT9VG6R5wd7QAdukFlJpnktgSwW4i2DIxKZUx+R8HrkE4RC2Hpycj5GmD7pQz/143vN4AxO6ITTUA1E1T+Q4jT/ww9XODXLt4ULdFYI1IViw3wEtH4DFIa/xH5cV0BRc0DO53a9FExXtzX4sDTxp3waJH/sUB30hw4BuA1pJ3f/F4DJRnQ553+G6A3f4A3rYA4GSF/q1V7t8A4V5g/1wA7cAA2EhgzDkAhOQAMjQAEUgAIvIBLHYgeIYAdgsAU1dgccwUKZ8x94oDgsyC3gQgjpxjgziHlL5hLhdB829h/4MWPl0gaggAv/RHg+7oM+5PM9rBc+xoAMzMAMTSgN1WByU0iF2Og0d5g0y6eGXNiNZTg24hiGZaUp7Md+Y0M1BoSOuXaO3ihADHZWW/c/3AhA9HBKSIUO6BCIfwiAf/iPfRiAhzh0jAYOh7gN5YA26VAd6pAOSFVf5cAO9iAd6sgP9OAp1TANz+AMwQAHQbACoOgBW1ADQ6BtdgAIM9YrMwYGK9kFwmIhAHI5BRFa/WQIRjYHa3AGOqlkm+USNXRONWY4IQgGdxBOQwAGZxAIlLBwwYAMyaBJx6BixZALsfc9dlIM02ByJsc/ooRy3JAO8WAPYDkP1kA00dAb1FAO5hBgVaUPZAVL//CQKvEgD61ED+OHVfagD/dgVfhwD3rJTOi3VQY2VfKQh1B3l+NXD1gVfqYmiQ82mBFWYLDkdhLmllVTYZcShre0NCS2j4zmh/8YmmzXaJ7JaPrIX+aAf4uYmu3ADu3gfe0Fm8EhD/EAlqoSKeowD9URD/WXm53SKn4YStpgTNKgDMXAC6LQCH2gAyswAh7AK2zwAzS2BdRJY4FzHzwWCGzQLHYQCqAwZJVVbt5ik3rwBjnpBvMxBpoHBceCCPUhekdJIS05AzWgBHGQB72gHPvjKMaUDcXwC+PTJr4gKMQwDV3pQdtgVKWkj9MRc+xQltQQDURjDQrodl5HKQ+Ghf8bdI9hGXUtJ5HEcYdQRxxpOJjUUQ9+6Ur2oJhtGXay5nwPlg+4tFWKOX5Mx1/rwIfJJpCgGZqhCWyMVg7d5w3p0H1DaldCWqTpQGk01w6puXR5aA+7KRy0qQ7f4DXM0RzGJKHQ0KW8waVeiigZGQ1PmQuikAmWYAhnMAM00AEeIJ1wqooiuAXXFhJygAikRwj70QZLFAooGIvjNJ5GZp5n0AbpuZ6Zox8fMWM/MARUsAU28ANgwDdy4ANKAAfBMEomdzbTxA3V8AzDMB53chrFIA2OMkrzwHYBuKAGhg7UwBteag3pwHKbknyUwnLyVx32gFRR6qG6KqXCwY1YyHL/W3VrZBWYElaZaeiOlIJ1VlWYEMkd0qSlbVWtx9QczXENrfKP2BBp5TAO3hAOhpg27EVf35AOaGOYJJZ0wqE23tAdacdWxtSlZxmmynCv+HqvzbCv+io0yrAMGskM/xkLomAJkwAJimAIUyAHXTACkaoeP/ADPlBjf9MrgHAfNYaCOAgtscgR38IIinCLBVKo6UlEUKCS+HGxVrAFP8AGVGADW0AFcsCSE5sHw5ANKUYMpvR/2fAMyGAM3XMLshdoxVANXpOIgQiA3yAOW6U1xURyXboN6kAcWxNAApSG86iX+iCl/CClUVccUEePfglh6YeGaTgpe7mi94cO4sB2//+IrXCbrdI0rXELt8mGra/iKtgADt1gkOHwrd7QiOqFNudKuFeKpdQ0rda6pV7auLAapvsauf+ar/q6DPeaDJibDM6ADMSQC6OQCZAgJolwCIrAnSaAKzbwTY9KITCgimBABXawBTjWBduiH+jULHfwLYjnCCF7kw3RBoaqZEsGOC/ABpXDko/qHpWqLC7wAmAgCMyAs4ZyXtKUDcJQC8BASLpQC57xGkWrHN/AdqWkoOiwVfugD09LNESTDvXwhgrEQFmTddMhVug3HfrVou5nmfWLq8AqHPlYSv4YmqDio9zqKq9ywIfof9qhHMH2Ko2GwOsVwdfxKnDbVvXquP8YnMFeepYXvK9dGrn+CsIgvAzMQMLRmAzGUAzCwAuwQAqgy0eQwAiHwAcz0AEmYAM+YAMo4AISS50+8MPssR5loKcAEoxlwKcQQhKE4AiHIAgAN7LAW7JQIAaB1Ss4Jqdb8MP1cZRl4E1bYAjP8Cg4yw3FxA3PcAubYAh5cAm2ELQ25b1Gqw3d4Gil9A0w90r7UA/WAKZE0w5umGu4Vmy+BIf6O6P2UEBbq5jusLbr8H9/WLdxS8A7GpCAOMEGTK52dR3Y4GjrVcd1HMFrR00VvKV83Lgg/MEiDA0e7LgivMoaPMLK4Az7arn3ugzL4ITMkAycKyi6AAujYAmN8Af/feAIhjAIh4AIWoAeKIACJDACMBADKNACLtACNhAD78GSNiAHbaAE+KFtgYBO3YKChCDDTpwHOFmowTsGUbBvIXF4e7ceRhCzVBCxRzkDG5ACPzAHwcAoysENzWHGxsAIdbAHj1A925NcGLcLx2Byc5w26KAOTBdL58BWYHoN7xBhl5I1ZEUqBMRrt9qZ+tijj8xWcivJaQeAjcYd3HHALJ233UHH5cANCTnToBzKooytpMzKInwoHuzKGdzKPv3KqKzKptwMtkzLmHu5mfuv0XgMKvwLtJAKr2AKaFoJYaIIoOAJmgAKmkAEHWAHKDACGNACJEAC0ewDMSAEMYDD/9T2AzVABEowBFZQA3iAC4RQBj6EB4ggw37wxDkZxcK7b9GJAj9ApzQ2IS4bs9Q5ASVAAkNQB5lgDDg72dqgkcaACHHQBnowCH3QCZbhCrVgGr+gDNrByd3nDgsIS+Egr2dJDemwfPmg0TOqfY0swB9GtwNMwK2i0iotwf/XDTV9HTWtXqOUHXHLuPZKucq93PgK1JDr3JGrykDdykdd3UftDCeMuZuUG8WgYsi4GlM9Cmc6Cp/7CZxwCZiACZZhC55QBiZgAmHtASPwAyRAzS2QAj6QAicAAzYAAy/bBn2zd44FLt32CHz6CIxgk5RHqG6Qzkv2A+kRY496ivfB1v8+AGPzbAeH0Am6AI3P8KnD4AutQAjwQQeUoAmGAArkEaBAEw37s2j80EvpiIW3qSrCekvAuo/62GhI6w366MlHBdHsUKRGypsPrSr2xw40tw72pYcjyqtIda52tR3cgdPyKg183NPSzcFcnj+JwsGflChiLubGlJHTcObVkOZpfubUqOZrfuZo/uZRaOZnvpEbecI/S2jfnXGxkF2mQArkTd6iIAqB/gmjQAqrgFxtVlKukD2gQAc0UAJhTQIecAL7rR8+AAMw8MMym+ktqyxKwB93QJLQEglxgAiOkOCCcJNvoAZqMB+do55TELExOywRSwUxAAb0zZIusB8r2RH/kjAMzOALxoALn3Did9ArgaAJnnAIjIAK2/MmPXMMy5AN88C+mmKRnfKQ+tiQ+riPRUqkQ1qkSWqkSYXkhYsOc9muSbdUqnJU7NCbvXmlN23BRc2v+D7d+p7KHEyvXo7lAJ8ocg7nUUjw0oDmBK+Rdb6R2J3L3K1ifJILrfEKqWAKomAK4j3oZ5oJGk/o5E0KpDBcIG/opOAKqKAKp3AKiV4KtvCdntgCYPACdtMCP+DfEst3LbAF/8GyE1ufbBCLeDAEOs8GRxwI+FRkA1IHceDqr14GXzAFUM+yEQvPPuAeuC4HhJfDPWy845wmrrA9rfAt71mTbyAJfuAJbSwn/7dBDM2wDeZwDqUS2/hgfz3uDZMmaZIWDqtJaeMQDkuadPbFrmFJD1R6l7xZf1c6VFoqDajMr8zN3MlAudZty7Vc+dPtDNEgy5iP+V/OwU+Y8M/wDBoZ+gzP8A7v1CqMjLlQC6/ACq1f8X8e6B2f8YTOCebNCZyw8bhv6CIf8iD/+2dyXKpQCqWgcIwwBnvjAyjgAySw3zBwAveh6T/gASJA674CLD+gBIV9LN2sBUv0CJIXRHWg9GrQBk3/9FEvsTYAHzGQxYLHspUaAz+Aw/shb5QgCZqAC7IADK3QLYMXQwBBR00dRGcE4fIVbJiwYr+IQbt2Dl6+fPrWecO4bf9bN2zduoHrFq7cuJEj05Ur1+3kSZQo07FE6U2jNWvUbEaDllNnM2U8lf1Utixo0GXNlgklevSosmRIkyU79lTq1KZPfwpNBpSpVanMlnllFjasM2djwyZDhsxYMbbEhP3itStXrlh1U6UyRSovKVKn/J7iy7fU4FOjRokynPjTKE6NG2dq/EnyKMmkKgc2paqVqlOSUWnSgwhRFzCAXFwgYccGjBM+2GxxDaPFDx8xqID5cYeNESU/wGwBbqQMnkiMDgXyw6dOnDhq2qgpU+bLlClK5AD/seX1nS1UgNuOodsHFd12AiF6JAmUpkiE7twxggdPkkea+OAhNMgRqGH/w9YWI0aZa9bJZ5986kHnm3K4wQimllxiCSOOaKKQJmpw2kkroJAqqqhmjPJwqa2SElEppZjSaqqtrDpKqhXFomqqY2Y8xpj/3PoFLrlosSsvU/biy7AfE0tssMEsk+wUI5csBUjJnvykk044mdIxTqC8TLBTXOGsFE9Q8YSPD1igYQswbOiAghF8sGEIF2BwwYXVUIDBBiOouNMHObqwgw0rugMDDDa6CCSSR47zY4/lmmsOuumqcw1QKlz74QfvhPBBCECMoI0KNuy4IxBCCAmEjzvAGGILOeyIgw9gNFHikVbawEGMTJ6ZpppsqrHmG3n44cceeuL5hhtutEE2/9kKbbowJ59+OgaoGTXc0KifnopKRag21FDFr0ZMysWsVkyGmRixpbHGtoRhd5cd7brrR1MOEwUxehGrl8jDDiMlsccywTJggQeWTMpOPrEy4MAEc8WVUlBBRZI4ZujAAw9WE4EKEjwgAQWPbQB5hBNWGwEGGGLw4YcaApVDDjZc3rMNRAw9jg9FmVOj0eioU8KH8bYw4s47gX7ZBxjY3CKGLQiJpOlQ2iDiBytsQAEMQuzQ5BE72uiiDTlm0GGHNHR5Rptqzq6GWWm63VbadN+mUVxsoZIRbrpXjHtcuvWeW6ps+657RhtvfCtHw92lq0dT8MprlH5Hkbffxw2rl/8TxixH2LFMIONkc88t8XxzS0C3kpNNMsHE9E1W3wQTTDbxxBPWNzH44IFJWVIVLzWhowIJRrD4BAw8oGI1NjA4QQ4f4mxzeTld+OHO20hDhJCW8ZAjkEceYcQQ5G5mVGctqDNC6d9w2yISNtgAhA0qNk0ZhjsiQeSOPm344YUYyr8DETwCsUOgXoMCHejBEZi4xVoKxy4G/oKBwiCGWyI4QQCxpRhvu+Df8hajqMDNg1D5oAY9aMFiNPAXcplLXeryilSwUIWxoEUKVXgXGg4pMfLai2GCpEPDlK5znRPd6EaXCUtUwohHHF0lhDg612HiEpdw3SVmNzsqSQlKfJH/TCn8UopVPEwThlBCmijgAQxQAHlsSkF26gQyKkzKBlRgjQu2kB022OkHgDBNoM6TNUUgCnw5i8NzyjC+KYDBCDZY1WvYYL1VxQAQkQCDFawgh1HpRg6BQsT61gczQb1HVV2og3pm0YtgPJBdxCBhKlWZQQ+miypigWVYjgKWrzCjLLesZSzRkhYbAYhdv+gFL3SRC1oU8xWvYAUNlZmKZLbwmK8o5lykSUwesdCZrEAmK7T5TG1qk5nePIUqOCNOHP5IFU66DGWuhKSA2a4TrJNS7Kw4JStGqXaqcMUqVqG7VaCiFbJohR9ooAUweEACZiQja1AjAuDE6QcgG9kQ/34wBPJQ4Y5s+IF1htCCQS3SUIwIRKn0UIdF4Sw6XxifRfEEBpd5BzauOZ8VutCy30iyC+vTDUs9BYhUCQEGEzUCHzSBilr0oj/BKOUp20KMYRSjqalcy+CKEdXB9XKq6UpLWsoVS7FklZf/cepbeMELatLimdZcpjK92c21shWaxzRrDHUxVmpa86zHZIU+uclWZapin+EkZ+R+FJgr2pNgUSqYwSQDCns65p21e+wqPqGkU7SiFKBoRSv2oAMatMAHFKAACURAgS2I4AQnSIEI6jSb7LhJTu5TGiAsygYlYJRNP+jC9iTxCEeE1GYjZQ5zngOd8VUKOK/xjnd+IP8H9VFhCGCwjhWUQATc/MY7NnCBpxbpqRScwAXSDYQmPrEKXTgwR6acYH/6c8oIrpKEVYVvfP9z1GD4ohe60MUtbmFMZH7TmzRMpl/SepduspCtB14FLFwBC1jM4hWwKCYt9HtfasbirtzUK17PulZxAqaG5VxYOyXjiU544hMmRnHtqjhPyH4CdvI0WCk+cVlQyA6zeljBDGjggQsMj4whkEMLupMCk7XABSeAQSRMA4PnstQH3bnNQ1vbgho0jRKPUERIkwPc4LZBkCitzdGMMJ5JGWEL7EnaEGqAiEAQQQldMIIhbysHnmonUHD0wBZY9QhPlEIWuiBlUk0pDKT/IvWB6n2vBdU7jEL3wtEUzoV+jZlXcYpTn/rkDGDF2c1MD2afmfaLKf4LYP+yVZ8Na9gsbjELVe83v44eZl3fimFXXPiYsMjmX0kRr3ICiZ0ljh2KVxfsYBusMbR75+rcSaUXy452fUbFZTehifXo4QMz+MEJyIgBQPgAAyIwrc9OywYfnEBkbRoCdt1nZp9NVH1GsMKTaVCGSEhCEY7wHh/4wGXhfvkLtLHUah7aAhuw4Q5WgJ4RAAEfq3UhVbVpIx4/dQfZAocKq8IDJmYsi1uQ8tG86IXhkOoL+z7a5MGc6zBvUQtc5/qvfhEMk0rRYcr6pdJ+ZUWlOb1pbfrV/xWs+Dk2W+hMtCaTmwxucC1ugd+l4zcYsMZvrKW5X1rMAulnZTAyj3npcfJ6sLgrBRYTO0WyU9GHrKui6sr+JVDUmBKe0MQbTNBZG5ibTWyAgcU8kHfWnIAN2vasnGCAghP8oAUviN4PXDCEQOCmUmz4n6EONYhS7bukgYROdMpggy2k2wbL47wRXgAI5fVpVHawAyIeOmblskE0pGJp/egsB0SAYjCusIXH74tfqOe3FlbHZs4Dy5fBGuZJuGOnZDYBJSMtjPinMAX0I0cKVew8Mz1fBV+XeeBtPjPpS++FfUvui2H4AprlDQYwHx3rVf++5Q/GNStYPYt83jwV0P/f4ZHsmeyy999Kmzi21XGM/mMdMKkxUKAENdgAFvC7vGPAO7iAE6CCCNQ2kVGoOPEA6HkoSpGjO4EBIyANyGOp7OGte6O8feM34cq8MsiNu7uDq2GDDqyBH7ADQIABnJoon4EBOFouYIgErrEC9gGEUIiEMjgEiPknXAg//fo9WXBCV2gFLkGFDpO5sDusJ6kixIKsK5GMhJkMfUkM4sOdvyDDU+A+bGKwVUA1fYKFWlA6QAu/QCu0YJiFXyg0uIiLsVK5VbM6pFMwfaoFW6C/TzuFl2u+wUgs/iNAASw701HE2XkdsqsxuJOEN6iACjCBERAZ1BIeJGODITACEmD/EwwgMiSLk8HDnxMwAhd4gT65AyWwgS5QAjzAhUApA0TYLUVghBMcqcvDPM2zgd9ABNILBUQIRiNwkxowuOLhFFRBIyEQgh8wuC5wuE8JFEJggzJ4A0+wBVzwxvBzQycUR4DKrMzqp8GINohBxCUZGMWqHWRrjCr5ISACIs4BQx3yEb3Qi3ACrLxSw4YZR1loQ/AzOfGzL2MYBmQohmAYq4ZEobn4vflrsAZbsFmoBVn4NN0BtS0KO7GLEv8zO9PxIcnwnGNDnUgcNk1QSUqQBEaYggiIgAmwAB4DLQm4gAsYARYAA5UsHhgQARJoDUDYAuxCxjpaN+Cws8fDA9yi/73iUARFMARBsDw6CK44eIM3yLwv4JQugI/3IDdEQgQXIAEzMbg5EoKhjAEhoAIhwA38sQJACKAm4xQbaANPAIa7HDld8Ma9tAVxvLR8KkeIUUeIubkOg5hTmEJUQEwlMRLEfJjG1CItKkNVKLUzdKsD80M/lIU+tEg3dMNXYDn90oVgSAthmKHFkRd9yZd6Yc3KoccrsZLQIaIlqoRJsM0lKiIlGqLN0c3dzIS7EAW8SAVYIAVZsAVbQAU9GIMpqAEdqIEZKIEOsICK8QDC8wAKuMmKAZ7lQoERcAEMIAEYIIE7wBTngZ66s4EYSIE0UhkaoIEasIEauEXecgRF6P+DPtAD4cKCKbBKN/DPzDOCFmABaSRLHzAk7LoOF2iZz8sUPSEPMPipH9jBpjEkOSieGEi3NkAFXAAGpKoFvfTG4+zLJ7y0cmwFwUxHwVQFwVxMLTpMxSzDaFsSyprCDitMzLRMvNKmzEQ6Vvu9iJyFYoKhVKAFXbDIYbAlZJiLVIAXZYo+6cMhymFNztGc2USiI8JSI4KELdXSI9qcelmcWMiFXYAgYmiGaZgGacgVZBjNYMCFPfgAC5DTDmABFhiBmySBNUGEz7LOEZikFqAAI7CD7gyBjVGt04ITkRm4FkgBIRABcqsUMsENPEgPR2iERiiEPpiDkTqpOXgD//T/z+jomILjFDwiOMV7rhaQg/g00C2AgS2ouC1IOFXVBN3QhE+Zo9mggTNgBF8ABl+wBf2ahW4URHF0BVmAwnIUJxRl1hNl1odhVhRdEhaducK0Vr+6tLzSVmy6Kx5FuqqrOmiKsHEtJl1AhmdAV2GgKzF9pmLqQ8pcHF5rTVFoDFGQTSHK0izNhHph0l3IkQiKlmaIBl6xhmT5hnlA2HnQhmyQBmLghfIrBBX4gBOwADU5gdmoAeAZARSgghfwARTwgBOIwI05LRtAjRAwLVddLXMzshGwI9qAgXMzGhToAO1RhEyABUj4g0L4gz2IgzJQgy/w1E8N1TJwgeWxqKah/wJVraOfMhMiIIIaGMr1TIHbKDhDEhQ7yI0+kQPuAMXpioJDkAVgsIWBHFZcGNFxzCxU80dxOlETddbMelZoVUfJLENNq7R9urS95dvugz8G60MeBVdwpTqzyoVXGM1AG4VXUC9eiCFq0q/CFVIesTAnlZfWjNdYcJd/RaWAhQZpkAZqyIbRzYZkQZZjaYlt8AZ0YId7iAeEtYZj8NdhmAQZmIGMhQCcHIEOAB4PMK3tPAHe9YA0ydML8IDDi9kQ4JgTEAGf6ZjwPJMRmCjprZOH6k4UIIRHSIRaqIZiqIRF4FmcOYM6GNpPjY4TGIIhGI9IsNBKMYLCuyQbwANEKP8NI7gD72ifIcCDT1mu3pDFLXgPUHEB4cADLIgDUBjHyF21gIzCBYOFbtInuJVbFVVRu92iciLDa+XbU8unBHu/wJ1IVkM6z3RDwLVICYshCTOGXliERRiFSbCET8gEXfCFWZCmx02cF6oLd9ncMr0gZcgJaijYgz3YhE1YdXhdepiHeGDiJmZidUBijICQdGAHfrgHddAGajAKZvAFM5CBHviBEQAtDwAekN3YjwUeCeiAF7iADjBenHwBj0GBkR2BGEQBAw1QITOZ4iGUO3ABtYwBD7AaRiiEXDCWZMiEQsjUOTiDM6ADOrjKT22DMgA9S/GN4mGTFwiaIZADYPD/hBpwmTvAHzmQRvW5JCWggR8oA5biDvdAARNgg0BYmSlwhFbABdxbOV1owoAUyIbJSLnNrBWNVhiVuV7L4EyzUUvjYFhYBfjzvsz8UTe0yGmOsFqIprmIpmDQZfJzU1UgBVa4BbngYX91IGKYlmX43NHVBm4wYoSlh3uA53i24nm+h3kGlnvG52Cxh322B3kolpmoCSGuCWhQhmMQBlOABDPIgRVwY+zURFGEAQzAgBDYWBSQgzuNY+MFSuHNUxEYARJY2jXhPIw6pNVQAj5gAwiFAUypY0v9A14wFm5IBlHg2TxwAzV4ZEiW5DaAgfVULkRYVegRlBroglAYhkgg/4IuaKP1sQJDMgKmkan3XB9YFZSPHeDdUJkZMARUME6O0+UfRdZjFWsozNuMNEwVpSznWxhjtrlKSwVl3tGJ/FYYegUQnj9WI1fKpVwxHdMYIqtcCDRe0NwLSoZmsImCZed5oIfFZuzGZux4hux7eOx3pmzJhux+Zgd1SAeAthCbAF1piAYMAe1mSIZi4AVRWARB8IMg2ACcpAAI2NgWOIHuFAEM0EQLsIIWaAEwAFSO8ZiK7s6QhRMUSOn1AYM+KbyriU+hTEsUiAPthYNcWGdjMYZK+IM+cAM0yGk68LKbFkWlKZ5UqZQToDgjkAMilEWMYoN367zzjgQz6Y0h5P+O0vCBj64NoKkBIpgBPUBg4+zMcES1sS7HDv6rm4s2fuTI6cOMcuI57uOmY3qhvYahvI7wueDhcu7cpiCLZyjtCmqGakhsxYbsfK7nEqfnfGZsIy6WY9GGCnFxC3Fxm0CbGc8VNGUGYogF69ZUM3CDEqhYCIAAMj4tFDCjEKCa3TU3oDwN7xqBF4gEP/6BPEXGFxjGFiCB78okFxCV3IBL2OgAPKhPOBCFZ8iGY8mGYFiEPIADNKiDR36D7nYDlEGZk1mj26oulcGDqXkP5YIBKn9yQaGNR2qjF7yDlJkj70hfELQDUOBQXMgvpgM0EA1REZWxLoyMTDgd2bQS1nT/jE8AO8vAx3idl15jnHi9Cx3u4c4N2NC1BmzwBpRA4nZGWG442MaO7FuH53eeB3mIByTO7JPwhm6giWywhl2Z8WNPm9D17M9G02ZPU2moBjRV02cgC2ZoiFgQhUoohDzoAz94gxpwY4lmARPogOi8AAgggTy90zuVbWl8GRJogTswPI4dVBsgARsAhGyDTyvYqPN8ozGTz+xVBDj4A3PlhtFFhlG47pFy8+5Wgx9QzxhoLTthVam1ghcgAuX5qZRRPMVrauYSypSW1Tc6bsdDGqRkAyJY9EmPXDdcueOkv65WmFL4FyoFHdGRTSq1nMRgTb0QhcytizHF8GmBhmgQ/+hkCXEjtgd8YHp8eAd5kId9ZuxeV4fF7vVv+AaZKAeZ2IYWf3EhPmwKAXtqOHY0jfazb3ZkP5tcQRtnd3tqv/FfwPZMgARBEARG2INBKIM0Gd473YAOcGOxrE6cPK2NdYFIsIMXaAHgEcvP24IOcIHFt/IRuKTqNIIdVDwfeIEXGI7twfsmmARdqHZk8AVI6IM9yOk3f44zwJ/usOQ4Q7eLH4EagM82gQ1LjhOJyg1Pacug0WRCMG+847zreNX1CQRK6Mu+xD1csEhYuAsFaxhhZpKCUR1Mv9ch8s19BdN+9VeGIHpoV+dkSdhySIeo32dg4Wd+lod0oHqsZ/EYZ/+W+L8Qo//s0LZ/+//s/Adt0I2Gz6YG0AaIaNIGEiQ47eDBaggXMnzmjBkyY8N63UrFydIkRYo0aaI0hkWLGiEtsCjRAcwWCWDAjPDgYcSFFj9stBjhYwQJGy1b6EThwsWFISh46pxJYgSVFz5q1ODziBEjQ0HmXAoWcVgwTn3m0OlK542bNWh+/NjyI0YMFzZ+UJFD1sYQIzV++LgDyIMNOSupkEXJNgYVu3J8AAJk5A4YvieoCGG8BYwSPJRAyZLVqlVlV7BUsZKlCtUqV6VQkVal6lSqUaJWsxaVabWpVK9ixdr1SxixYseSLYs2rRrwbNm0cStunNs3bd++FVf/py4eu3TlynnzNr0btmvas1ujJo0a+PDfB0YrX/B8wfLOoJWH5p69wGjO5s9vZr/Ze/zuywuUdtDhfMwwkwxEERUzjDDC/MKLLrnMshkpqowySieYdOKJJqCAwgcLLFBAQQt4jGDCBhYgQggFLl3QAQoeXODBD4CMMEILLaBAAgon/PASCWzI4QFQPoExhAsipNCjHGy0kYRTUB0yhw57dHJLL77ggooibnj11RtrrAGGEUaQRRdbbNwxmByA+DDEY1uwQRYVVIBBlhx3sOEDYYgAcqYVc/4wRFlUvClEY2aBEUkghGjSii2XYTaaK62g0opoqHAGyyuv0LILp7YR/0PMMcfg991w3MxT3DypqvrNc/HQ8yo7y3GjDa3bdGNNd+Dt9x6v7PXqHnrB9ndQsOfxF8175tG37LICJvNsqMUUQ4yCCzYYyyupmGLKhJxk8m0mloRriSWYmIvJJ6iU0skm5maIyAwbuOiBoDZccC9OP7jw0osWuETCEDN2ABMJF8BwAgwteHDHHTD4EMMIP0QiB04+HOzCEIQQ4ockjihyiCA64CDIJJ/I4goqjnDV1RtgeUlFXEZsESZbW9hxh1l2zNyFEUPCwMYWNrABiBU9A80GIYgZ0cIWSd75mA92kIWnEGwYwcacZSBymWWOoqLhpLLYcosuwhjjTDXZmP+qaqr0zPPqq/fAPbfb83zjzTbX4IoreMf2iiyv+uV3H3wC7defsL4h5N80AymUHkHy0edstNQqyMsuudCWSiqtuQZuuJWIDgkkok9yOuqVYDTJJZhcQkknn3zCrieeUGJIGybgZIOLJ4xQwwkeYBDCCQqTUPCKHaToYgsvelA8jD6cMJQLMLjwwwhb3OECwiSkEDEeeATSsSGKDDLHCk7socglm3QiiR9etewG/WHaYEOcW7hghAstGOEWG+QUFyq4iQpiAoQmAsiwFxxmJT8AAxu6wLCy3MEIPgDD/ejCGLb8QAlsQMQjHmGIQNihhHaggx4kgYtgBEMYxYjG2tj/JsNUMWdW2shVeHJIkPDExyDSME/k+nOsIZKHiOkBIkGY5YxmBAhaxpBWgn7xC05pLlOcM4XnVgM60JHLEqrz4uhIJ8Yxkq4SqLvEJSbBrk18YhO248MHTGKDLVABAxIgwWJI4IEQDK8leHwJvyyAkwsQ7AQieAkM5HAwC9rAB94jwSFtcCQU2OAFH+xYIhIhCD84IQM5cIMfFCGJR8RPfmBxw82G9Bg7uYAEhAGEAcUkFyskyQePSdId7PCC+9VgJXjoQiQQcQdh+uBqFmTD9ahgsRjgyQdYw1obyqAzNmANDGPQwyWGYQxjiEptNwRONbxTxMMVsSC/8eFAqAHO/3Wyc52/cefiGGIsydlnGcpIRrSmRS0pdioXtKCNFTl3xW0RdFukYI1qRMGJhWbCW5kw1yW6KFEzkpGMZkTd6SxkrjeuoAQz6MAJgucBCojgBBgQnghEgIEXtWRGzoOJ8jBGAgxg4JDOlGRLUhBSH6QABvQihMVSsIVAhFARiSiEIPpABxxsQAVOmIMgGFFKLnVpDYRARADFZDUUvMBNWKMjm2zQs2K6SS9DqGQja0CDO4Dig3iww8SGoJem4WwLdk0MGABxNCvYQQ59pSs128CHbErLGMjgjT2XoVj7QENwknOGNJwhn8cqkT+QjSxDMqvZ/zjEWdDK56f2KcXRWv9uirmgIhVzoVp/rrYWtKkFLGKLKUylghUGJcWEZLeJh0a0i5MYYyNI5whINKK4xi0Fck+B3FWowhWymBQo9GABCbBAdyL1KU1pKjwKZPcCGEABTVuCARK0YLwhuMDxQuADKoggBGQJQQh88pMW+MAFW8ATDGwQiEg8wmOGEMQm6dCDD6yADHXgAx/qUIc4MPgNanBDksYEg7MyEIIoAZoz7/sDoPnVCjizAQrYYgcilOGXbAhEIOr0QZTUiY4ElJOZ/EqFmzUNEHLwqhzk8IZL9CJBheWmbkK1m2cJqMjMUKISHfKMaTBryUp+BoA8ewxkHOOJ06rWgniBuU5xasv/W7bNaLGMOdXuQssNWu0t0lwLWsT2QbWALStYoYptzZkUuB0FQx+KiU3weRMSXR3qKEEJQJfiE6XwBHINXRlJ4aECFCDkS0TaAhF41yUlbW92MXAk+PLRBS2iNBjuQNMYgNcDJPD0qR8GhjWhAAYwiEF+8cBfRyTCEIPYZCD08AUa6IAMcVDwguPQhjaoQQ1yiJMP7jcEQUUi1NRcicyKaSak2aXZFowBWYgQiVAM4Q6hYIPQgAYDN9HRB2WBAVm2UJgPEqJOgNAeHc+kB0zc4jbCCMYwpFUMK+/7idsMFTICTqAiI/khn43INg+UoMtp+cv9VK2ZdSHxXUicF73o/4WWpciLBf3i4iysVsPJvNpc3KIWs3jzLB4k29iuouUu/4xplItcO8tOdp3oxEI50Wc+Q7R15xoNKFDhCVAMHTOo0EMJLNABD3SgA4TEV5FW6l0S8NHUIdgjH0NAAiq0Mr5cZW8IYuAiFIQgBTyNgRBicCcf2AjW/uPDrGt9az/gAcEMVvCvg83gYYMpq0M4655inJhjm4UNdgi1JsIkh0jojyc/uEMkNHGHx89kw+tdb9PMMjM3rbtOdjC8in1UQj94YhW66MUvWDgMYuRb3/rm9zBi33qFYznLmRt5Lt685lqk+RYkJ5vEg6/liwe/+Ke/OPI3jvpefBxBWMFyp/948fuSp7z6K3eFK5gb88+g4hTeL4WdkSt+8dvcEztv157Rb6FNBL12tmuFJ/yggg1EIHktwZ6LjMDeSqf0kMfTY9aRwBZkHQpsAUntUcFgQAzE15GgRdjhyFGkQAu4gBIQAn8xgtxtEoJtYIIBG4PtXRuAyUo8BtCcFQTJyUrkEoz9jxxYwQtEQiTwD578HX2l4BbAAF8QUKAQgh3kIBikCdCcSZL4ldPUiRzgQdBRCQv5Agu1UAthnC7cHi38E7akAikY1LZoS5yxAudsISvI1snx3pv1nvGVYcNh3BlaXMOlnr0Jg/MJw8YhSBRlmcSpmcmlnGy9whfCgpzNmSn/gJ+d2dmEjMIncMLN3ZzOud/O5dxC9VkbbQIqaILtjJIm0MEHWIAJDMyjjcBiBMwFkAVMuAROgNfwHMlMuYTweFdNpRQJxIArCYHBZB0MoAB4HVJLhAAOggEIPYJR2Rqu8YEeAOOCeSCDFZuxXZjVGMHf8YX+zZFdPVMxxQVZ+E/1oIUF/YCY0JIB3Vd+UVNZmFuY/KBeUJPnGR7D2AEgfF4kXAb2yYL1xQZBDWIWIRQhjgIpnMI9noJpqMIqxJkqyBb2aQYsnNzJ+d5qlWGZNZxCLuRttOE+LZyYRVzvmRzKYYoX2hZBBeIg4hkjMmJD6RkmiMu3cMKExIYqpIJp/6CCIHAFFMyACdSABUyXBEjAi7DAwLgAuI0ACjidi7AUTmgd2fGRCOhRizATegFlAbJBKwqP1omAD5jaS4yAevlICHlMIhzC3PkBB+oBsOldHBSbMEGQFdTAC1gB0BCQEUhNAengfenFC9DXT1yeLTkTNspECpyF0MyMw7iJheUVYpRQLjGMj/gVGyDhZYCf9+GjKWjkIHYkuHRkzY3fzBlaYp4GZ7BCptBGLEwh7uEel0WfliXkgpQZmP1CMTBDMWyZatHCak6hyqkcH3KhKZgGbuHWJ3QLJ8xjbKSCZm4cbugGbzjDOwnHM0AELuBABTiAA0xAA0xAB0QABVgAdP9SwA8chQcMiQuE4ggs3VG0IgrEgEqtFNlB0gXgJFAciQekVNVw2kl5QAqEAKWxFAwowR1UpUZgpR/4AYoBox5wJTF+YBwgxhzRRQuAgc4w2x2oXdBgIwF5GyHwhAE9zBZI41kwkzIlW7LVSQ5iI1/aBTXZiWCGHsOIDyWUwilwyyhsyzyyxmtkEUcOYiDa2WLm42LSmW0J1GxoJmeuFmt25ml9ZpeRZqccwzQcQ6fEgj9NoWZiS6YEVEERFOdkymn55r4hgzMsWXAMh3BsKZdWQ2QFiDGwQiLAAQdUQAREwAJIgAdIJwRIAAREwE8ET/UwHQq0RAeQ16mlgAjAAHz/QdLWoZoHvAkKpADQgBcufqfYNeWRYMCjncALEMF+9dd9DkJ+olh+dqB/Amix/YBeyEW3IcLgaUIoENCxxYAFTRggTIwysonD8AWZ7E+aMIYQHFskvJuZsAURnomPgOiZCCbDpOoJTUJm1gYvLCltnJbmbEptaA64aNFrLBSercZGxmgWRulmbiYtzAItGOTI9aiP8uiYaQ6SWqkzmBZtUKGxnpYUfQpwLoNwbilxHAetCIc2CAc4Nc6y2Md8/MY0FCcyBEMtmMIkJIIZlEAFQAAEYIBPSQAFbKfTjQAMtIRIbWeKtMBRoIB3DaUjndpjcNoLeFoKxMkk4UgKiN13/37XCRyPTgYCIiACJUjqIdhafl4qH+yBf/7nVxroqg2BXybGtPnAjU3NY6zFEFhBWTgNYAANtkUNwzSGMs3qMyLG0EDe0YQor+ZYLtlBHLhBHojCLxDD14KtFM0hP9mG2e5CLHSOtG7kk2oLlHqhQMnGFDbpFPZo3d4tayrpknIKbehCMJxemI1tbuyGu74TrRTH4dpQvYbTD6lHPS1WM7irZM2H5PgHOGWDQjzDv85CJlwCJDDCG5TABaDpi6SIyoKUTo5AdkrsUTiMHo2A1K0iBtgYBRwPxqIAFaSApRkJTcFnAb5nK7qA051AG4BCJHQMI3yML84sgtlsV3qlGv8UbTH5gBXEBbRhHgElTJj83eMhAs+aI9DQETamCSzlD7LpICGAwucR4a7aSVssXigAQihgFRj0VyKkAph9ymiNFqfw0/5KUS/kQrbEGUp24RYKVGzALStg690aqwMbK2f2b9jqhjEEQyYsAi2YwmsQA73SyrwCxzQcS+TekzKUMAk/iwmn8DLcB37cxw/pa4A8BDIUA8BmAuk0giHQAREgbATYEQWAyQUsz/Oobkt4QAsEz1FMHXg9mlOSAO3G13htHSRp3QVoHdiVHQnwaQrckRETQRsImiMkb8xm5QY6b1dqqtTUCV32yVnhSbmJlQ24gBWYBdFAHluQKl3YlY3/3cF6NUZW0dHN5JgdGIEFUlMgu8kdZIioIgLLPoIeFAJtlCaQou0DY8sUxhke9uMrxFbdNqmmdHK6UnJtfOa6Du4xCIhwpo0He3C5mgItBAMv/FMxVAML24cKK1ZiKUMuf9az9LIvlzDk2geTFRk+VdlE3MIskIIlXEKFaAIhlICbMizCHoXTUUDT1cQI2MDACAwgzQhNucBTvkj/jedM/Z+mzRQu9tSdoIAIsPNK5VUN6MEjdIxGGILM0mzN3izefaAazIkmREJZsIEVxMkQBFC63dfM6CwYtAAgeK8zGXQe4wxf2JUQ3BUducWG5RUwfFua2AXD3AEhiE8caAIw/2iCHZxB10ZybSBw26bobmaLQGEmF6Yc3tLCJ/do9AmutISKMjRDNFBDqaxyvM4rrexNd0iDQqDmgRQDMhyZfqRwCT+LYkW1L/vykFV1L1PZE5WWlvlTttRmG+0ZGmECKLRCJMBkBEDAAkDAo30I8hyPSamX8JwUSx1PpdVFDKCX6bZXfWndD9QiFaTFD2BAVwGtK7aAwwwBIBCBolBC8iqCPVMqPgvjGfOzMp7JHFkNAZkJQmsYmABCu4Fqn1jBBeXSfc3RHQjBDwjB553lCc6Js8kvIRgy1uYYG3wgIoTCxLQBHFiCZqJt3G4LPl4hKcimKBRU3GZKBOevbjQ1lv/SK6rM0HEYdQ6Bx3fk0E97B78y2Xw8gzQ0wwvfh2JJNS7fk1VbWWmZaxWqqEJ9y59RlLkIGiWwziV8DQ1YQBB7gASsdXTeaZseT+/C50q5yIeMVypeQGCTWkq5ABUQZXo2eMGYSQ7qEU66sRDQBArgwSN0hBjbmmRrZfP25/MCKM9aGBsU9A8c3v3oXyw505607M28CR39oNVAUF21BV/KzMxs2EcnyQ/aCTkKYdN8nq7KgR5AAm+OMpM+qUvbVo7276fsxpE9d7wah1DPaw6tE+ZWA65wKZcadTZYQ5be6wv/EDSAUzTUk2c9i4GIVub8U6YsZkLNYyE2IheRy2//oRHqlMvrjEEJjMBMwi4FICxb24BJDU+KUBp8cVdK3YuL1BR6tTMtKiAiVCeQ0OKpcddPkNqNoEB9bQEiBM9KBIJ8d/g9g3g+18HNAmgctCBKRBuNJ4ZYBdB9rYRZOrOHXlCStImPrFf+2NVjgAEOPhAhBAIoAMJKDA01DY0wGWGOYS0Y+MEimEIk/8LmuMZxcyFn8gIypM1xWHkHCwffWDcPFU51n7uYp82Wpg2Ybzk7CQQ1NJZ7NIMuF/OVVUvmLOlALWZryKNrQCsh2hy75Fm7pBFGQcJvNYIYmITyDDpbt+mgq6lK8VHKxjWjOs9JPVrVFcwL3IgIcN1R0qLGIIrAHfkEjsTXC+xSClyADdSArEmCY9/nqW+giK86gAYEACH5BABkAAAALAAAAABAAQABh+e8nt6yldytjtaskNioh9SoidKniNCmiMymjNGhfsyggcifgcebfMKdg8GZfcCXesWTbr+Ucr6Uc72QbryScbuObLmTdrmPbrmNbLmNaLaRdbaNbraMa7aLZ7GPdrGMcLCLbrmIYrWJZbSIZbOJaLKHY7KFYrGJarGGY7CFYrCDYa6Jbq2Gaq6GY66EYa6DYa2CX62BYK2BXaqHb6qGaKmDZqmCZ6mCX6l/Z6eAZKt/XaiAXaWDaaWBZaWAZKV/Y6GBaqJ/ZKx9WKl9W6h+Zqh9XKd+aKd9Z6d9Zad9XqZ+ZaZ8ZqZ8ZKZ9YKN9ZaN9Y6J9YqR+YaF9YKN9Xqh7V6V7ZaV7Y6V6W6R7ZaR6ZKR6YqR6X6N7YaJ6XKZ5VaN5YaN5W6J4XqZ1TaF2Vp98Y598YJ56YJ97XZ55XZ14Xp53X553WJ91VZt5Xpt3XJt2XJt1WJl2XJl0WZV2YJlzWJZyWJZxVpZuVp1xT5lwT5htS5NwV5NvU5NsUpFtVJBrUY1tVpdoRJFoSY5qUI5lR41pT4xlSYpnT4pmS4lkSolgQodkTIJlUoViSYVhSIFgSoJeR4NeQn5eR4NaPX5bQn1aQnxYP3lZRHhXQXlXPXtUOndUPHZTPHRTPnRSOnZROHNQOXZLLW9TQG5QO25POW9ON2lNOm1LN21LM2lLNmVLOWpIM2ZHM2pHLWVGLmNGM2NEL19FNGVCK2JCLmFBLV1CMF1BLGA+Jl09KFs9KVk/Llk8KlQ/L1Q7K1Y5J1c4IVA4KFg0HFEzIE40I00uG0gxIkcrGUEuID8pGkEkEzojFDMiFDAeEDEcDSsbDSwZCiwVBiYZDiQWCiQUBx8UCCIQAx4QBRsPBRYOBRoLAREKAxcFABEEAA4KAw4JAw0HAQ4CAAoKAQwJAgkJAAcJAQsIAQgIAAYIAQsHAQoHAAcHAAUHAQsGAQkGAAoFAAcFAAYGAAYFAAUEAAMFAAkDAAcCAAkAAAYBAAQCAAQAAAICAAIBAAABAAMAAAEAAAAAAAj/AK+AuZLkRosFB2Lc2HHjxpopbMZEdHEDD54dO8Y8NITGTZcrOlyUQKHihQoUHVJmKAGjRIcSLUiQaNHiBocWoYIJI5ZsW7Vmwn4J86VLWJotXqgw3FFEopciV6JGLEJVx5ArRRo2xFgEo9cbLnZQGaJDBxUqZYeoJQv2hlWyMmLEVaHChIoYdU2UUOECRQkTIkIILvHXRAoZVLpoaiXrlzFju2rVsiW5MqtXs2C9gjVr1qtUqVh1hgXLFapMljJt8pTJk6dSoEpVmgOIVCpTpoZBa7aM9zJlyI4VKwasly5VpkRdErXMmag5jERh44YN2zVq1qhp1y6tO7Xu07pH/3PmLJo08uPRSzMvPtr48eutZbf2TNUcIEB4eHCgwYKDBx6sgAQchhhySjLVZKMgNNA808yDzTwTFUFJJEGBASQs1EUSUyTRRR5R3TAGQyhUlMcagtDh0Q59pZACYSmI0IEIfrkggwstpMQBCRTtQAIHhvwSDE8/NUPMUEQJU0gNOmDUAkVXjFGEDlFBNWVZVlH11UJRMbSVF3jokdQQVCRVFhth4kHFDTC4AANedMUgZ14m1DmCYS6iIEIGGYRQZ2EyeMFGHpa08ssvyRBDlC2MUiYZZpmR1plnrHCW2SymebLaJ6B4AsonsJXiSSOSgHZbLb1UFksstcSiCnLIJf8nyqyiqHLJHLjyAs421l233a/dBRtseuWtR6x6xrr3nnnWXCOfNdMAA0h+M6wwwwcf9KfBBzjQYUgilwiTYDYMOvjgM8xgRSEYLRygwAtRGpTEGnmwYRBYO4ABxg5X4EGHIF100RcKKaDUwQgiiDBCCm5apcMIKZEwUgsXUDBFMEMSU5wxh/oCTFGaMMkQji9ARRZVasn5AgxY6rCQV1FGNMYVGJ2V1FhjyaCzDoJSAQMMMsBAJ11ExymDCiOMUELShKVU558m6DBGHoJocotOyRjjiy26NGoLLbRMStrYl442Cy2yuFLK2qWgAkpsoZbSSSmk1J3cJXiLIgkjjDz/wvffgPONHxC4HsMNN9cknp2w3wnLnnjPRD5N5JSTVzl5mK+HXeLXZFNNNcpcgt8McaBBwwoaPGCBBkaQUYgjjaSCoIPmNsNMM2xEOXOFEgxAQYU3TNHFGv3qO9BCNIHBRheEdNHCCCj4JWMHFWSQktKEyZDCwTG1kMIIHFwAAipDGjOMJLEIoz5Rv9wyRYgGpaCWDjHMH4ObLrxQVgwua7XVFVvxCkZ2pgMYMCxQY/CCDFBgIxvVhS5PU8HR6hcDhb3gRYehU51kZAIZDEEPmpAF1rSmC13gAheMAhvYJiU2FnYmbLBYhQxRgQrY1JBtaztF3UZxiUf4bW+ACCIg/3BFxCLOYQaDm0M0tgGO7GxHWFCMIuWmeLlnYO6KzuhOszhHDWdV4xm12MMM9rAHO/gABCCwgBpn4IQ9OMIRl7CFMc5lu2YoAytgGAMYisCGHShgAUkYQxLYwIY1rGF5ItrKvlpwghvUK0cJ41MHMlCB6nWAgSWwngVbUoIXlCACF9hAJMqHjGEMIyjCGAYwcEEMOySBZjfwy8pekD9a9oWW+iugXH7Gy5/J4AWzZKAMvNQQF7ipBC4iDAMdSLQI1mUEz7TLBe0CGBmFwCUrOYwgJtG+VZwiF7/IhThzgUJG5UKF6FxhOknDClesooZvoyEq6naKUZzinqLwW+AYMf9EIxJxdEgEAiO2sQ1u/Io7URSPsKyIuchhkaFYzKI0ssG5a2CDop+rhjEwAYg91IEPdaDBB/ZjAQ/MIA1/SEQjDqEKZdCxGQJBE5rq1TsSsCsJYNiQIT+yg5ow5AU95UAenscn62UAA5TEwCVflDAT/CwFHOBACUgQAQpcgA464Ykpd+KLoeQiGZHIAVZckDSGuaBg0Ysew14gJzkFTQZYCpqL8ndWGAxBgG3CX5uYikwIPu2vdYIg0lb2p0hmIGEikCAVBPGJYIBiD7RA0jjJeUJxplOFZ6MFLtTJzneSAhTyvGcq7nlPTPAziH/r5xzIQEQyDA4IJiWcKg7HDSf/PjGh7hlWRCFquYiSZxrUoCjntEHcbFjDc9AgxiPq4Ic4tKEHI3VAA/jTrT/sARCPAEaEHDQzQgrkCjFo1wIWojwwTCEPerDXGGpClhSQ4AITwEMMOsABDGAgqkZVqoxotLTvQUyqJXgABSzQg1sQgxilHIZQuuqLXBijFVOYQk8hZsyCjaRgLpoly/i3MwPCiGUwACYwXwaWFhAsaGcl2AtkAFi/dlBnR1MBS3T2MwkCBjAviRohciILSXzzF75o8DhLSM5Gge1rKrRFLrzGGViwwpunSMUqpMyKKpNWEqoNIq5c+9ouw9akMwDG4cBBjWmYOTwJXU95osHbKfo2/6JarOg1wAGOw21DQQR9hik6Wgcz9ECND3CAoDXAgiy84bqjSEaD8MDHPJT3Ci3oHQduIBA8DEoQa1BeEcAwhCKkgAIdmEAH8nBfDlQyJRV4kQo4KRKlveR7hHnABsSnCWI8BhinFAqQfUGMYMAhCX0pAQcu6BelvYiWb2pYDHz5S7W6oCzGtMowwUKRG3zvRUpbcdD+KkEW00VndEoBXYAGYxUkVi9Co4IiDJWMZmTtF7vYxTh30bUl26KcjRJnoybDqLFVGTSreHKlrKzDQ/gTVwD1Mn480AAPAEEZ2WDimdHsuNwe66ERbYZvpREe4XLOHnXmxja0wQ1tEDQbxf9ghBnmUAYWWEB1DZiu6ljwhkEcQhK7aMZTqBIlPIBoDAuQABgEASKiCwIMipAIiFAwgQtUYAIVyMMNSqBU8F0SmEATSQlEIiOY0KQFGJjJDxxhjGQkY6vqG4pQkjEIg3SAAhGQU4iNaUy5849+K5OgDjyZghAX8DBWoQIswTSGEA/B0kLTQdCINicT3OlpSXO8wsotAheNAGgSfAEePmFgs7tbUUEO/S5CT/ogx/v09O6aLmrBmScDXIZS9qYtZsGK++CHDNft6MGL+GUPzOEZ1uAGmctMcSg69BkcDw/yJ35mBk3OipKbxucURH0FOetZnMPoNJAhCSCQQQlNsIH/BqSLgAFsiwZ0KMQiJHEJq1zBC/D3gtI5oIAW9NGRhMhDvQapAxJgYAL29X9UgAckADEQ8xIkAUwvMhIJIzFf1wI70gI/8AfBkDVol3bqkwyZUAMtUAIVEAEtQz9y9yYOcz8h5kEwkFbAlD8OQyXEdANwNQZiMgIygAeFx22OdycKUxc7mIILqGolkFhvBQN58AkiZHZZA3ql5wuo14Ql1DWqIhmawQr3FHBPZoWpsFm1NwMz4AEO52VkEIZbRkRe6AGMMA3WIHFnplDt4VBZpHzPAA1m1iBy2CCRYzvMcDuRIw3jgmfGJR/VgIbPoiDW8DnNYAtzwANc4AQ88AEx/xdzq/MBT3AHr1MmhIQmFhEmXsAAFwBAO+BzM5NLoQZ1lfR/HaAHwvYjkyQCe3FBI+EXQTgTNGFMLxE8biALFniB6jMMyXALPjB1FSMnWNJWxNhWJpECK3ZBBVNAKZYCyLMQBuE9hEGCY4AHQwBNf5U0d3IneHEndEEYxgaOC0M0KLB5rVCBZnckoteEk2VvXsN6pAGPVUaFoTGF88gKjHIK99GFX6hwCtdwHhALaJgN3JB83eEMVHRFt6NxlAMh51I7v6EMy6CHeyg5hHhmgWhmwaU4HAcNxnAJZBAEfsYC4/cB/hEgOHAHfQBXZJElRfAUVzABDNACXQEGlOYCRf8AAxNAiv8HdTvJBmBwExyAAhkAPSWBYSmGAjThP7XYBVKQCVmzi6e0i8Zga3EwdTspjCJIjHhXEjFgEt+4TCEBA1UhEltxAxJzSzWydyjwJnSijd6YgwaIPQQDMfrVVyqgB5MQCgZma+rIhKnXNfs2NvA4NoT5CrbQZHXTZK/QmK+Aj7YwCvvohTyQH5Xpj4MDkMPwDAlSkMFyRQ51O87ADBGpDKYJHMiQmsmgDMmQmsFxDLCJDKd5msswkXzIfOGBhr5CfNBQDb4ACEEQBE8QBSeALeNnAR8AAl2wMiG2gm35bC6wABHQEL8EA2OBARFQAT25kxNASTAgCC1wPyj/sDAukicqNmIBtANSFTxnUAgHtosYOAyllAyI0IHwxVYqA0x48Rb0EydyAmvJpANhMgZbMSVfSTAGhIz6+XdvmTAz8nhPczB5sjT/hTB9FQN6qQmocAu/cCSH0jHtSFknNKIkOqJhs1lfI2VnIzaPeW+YcB9eqAHWwoU8UKP+OAMNBwTIwJkEOSxu6FAQwgyn6Zqu+RhGaqTDUQyPQaSpeZrM8AxmRjkTlw3UYB6/dWehE5JIEAZhwAIfMAMl+QETmlYjkEs6MAEKMGlD8EtD0AEREAE7CafcuZMcIAhsoD8d8CLR84oEY0wv4D8NIVU1cQZucAvGAJ9pNwzKwIue/8ACJXABEQBMKlCeJXEXXUkXbMWW+YOMfXdXWvGVLPN3EEMwyFQWngSX0+N4JtB4C9OcBiOhr7gwbCAIgqAIlgAKQgJkh0JO4yRkoYcLudBgwBpkwBpO4uQLuMAKqZBOnvEKm/UI9zFSMsqFNDoDlVmjPECtDNcAgLAMUBp8B4mQWOSQy5CaSWpKpuQL6BpkuNaup4SuuIauxiCbemiHxbIeZpYedUYutrAHZKAGahAGTIAtHyBoCINY0HNAOoMCCsAAdQkDHfB/EcAAbwqnH7iTG3Be3nNJJEAwaVVh+QOoN1ABETgFP5AJR5JKB5ayyvAYvzAFPxJ3cOKfEBR5d/+RAirzbDqwVgpxA3KSBD9jSwvYAQU4VeBIoUmDWEhDTUlzSXXlAilhX9dDtCVwBYNiCG+ECrn6objwocTqCx/KtWGra1zrTidkZJ2BC7MwCG0QBB7wch+wAjNKrdlao9oac5fgUr25DVf0IHnokLwBHMWwVcPAhPk2b7lweqU3eqMHDMJQdrK5XZgjfdCCfIFIWz6RDCBpBmbQBWhgAzG6X0fbd333Jg+gAPYlbBbLAA9QsdkJdfTFAXqwA5e0NJ30AgiagjbiJV4CpxcggTUwCEeysisrDK1pvHbwIxNwjARTEiJ2EnahMj8TbTqAoF/5Ai3wAsBWQMV2MGQVMU//QqZLkzDjeBJ9pTAQ0zT0BYAcELHtS5ZJkAeDkFKOgAiOAAmQ4AiL8Aj42wiL8L+NwL/4CwmNcL+QIAkIfAkIjMCkoFnu+DX35gp7EAdm0IXbIrdzS60a3IUNVwsSCQ0KcjsinIcj/CCsmZrEoEqG6zVKFqKlJ06jx4S85prNcZAYmVHTQGe7oiCHOAdtcAZAbAPZAosjUUtdgRFoqQASAAP25ZOuK6elGD4SsSNTN54Je1YMk2Fl0RCEQQIv0ARNoAYGdqh+eSStuQtsZwESgAEG5LF9x4zXpnhFoL0Nkb3AVBM3kARs9acl9nXjWZ7itoJdPFUFyEAoEBJ9ITF//5w045kSsWtfQ0kvfSAIhlAIf8AHfNAHl9wHgzAIfvDJfsAHfvAHpEzKd3AHf+AHdfAHZtAGdRBEjQALYAuY4nRCvuAKgEDBTrACcZvB1frLXTgDvNgbnOm3QbqQEMKarcmaU2kL8uarQrETxbsTVfkYxGu8p8mj0zeIEVd93ZwNzTAKeyAHaDAFRLABIjEjh/FL+QJLLcAACgA+c+q6E/CmPHkBjsRINDG6FaZMDDO9hHECLZADYPwJxLuy8llKxLAJGkABE+CAMcFA1NYmbRk0O6DHWvECAp29DxjRxvSqcEkYS0O0MiETXreUN3AC/meAJEDSLR0+9nUB99UEcP8wyYLQB32QB3SQB3xgBz5tBz1tB3Uw1D99ynTwBkedBnEQBGXgynWwCJFVuPFWyydUCnNAwT0QzBhsrTSKrdnKhb43ry4VIX5Lwn+7kKbZpMjwGIUrDDEceoeCgdNcldessquph59jZtUAiNrBzXgGDbYACDxAAzXAAguIAitWFmdxFjTRAQcQAdgJd/Rcz9nJJxcQPniQBDIREyTAilmMVnv6dSMh0DWwBTngnupDDEp6YOn4C7jwARQgAWZlYhQxi52mP2OgA1SBxywyE749VTExVUop0hSqMA5qPUSrjSmhp51WgC+tNDIRVT8SVVF1XzcwKOilf/WSBz4NB2v/AAd0QAdwMN5w4AaG5N1rALBpgAamE5xxEAeNYAtB4Qu90Avy9jW4sAlkQMGDLaNb3dVera2X0KRBWpsGXpt4+Buu2ZqPUQyhd7jipAv03QvDMBxHagyDW9/AsAsU3qTKwAwIaUXRsIbfkZvSpyDVcAyMQK1FHDRAoxZeUEA+wgEPQLFPbM/cWT0ZcAEV4wJgsNkm7T1+akwdPTA0kQNgkANmgAu7uNpllzW5QAxlYAEUUMQB1BAGikxD4IwA1IENMRMw4XXAXdIwAdp7ijAHgz1NezASUzAXwOY3wUgksAEccAIcsAGzFkobsAOGdEiF5Od9vlOCjgZSIDxbcOiH/86lLWcDNAAFZiAJHbprU71ZtwAJYdgDPCDE2PLfAP7VXRgLyHDXJiyRB17qqNmkyVAMa+0xKzx6UmlKwIBrSTocptQLsa7hqo6aTzpF56Es5oGGweU5zSAKQDADIm0jO6MWC5QClYSmFNu6N06K1fN0VpUEnN2xLQADWoHEbaEVX5fHY9AEPlAKKVzhRmp2xqALxNAIGsABZIImUkI/1QgSwAS0L7Cm2qOAyIg/pwoTdfyKWDypVsw04LhMbBWxJM1IJ7Dwdm7neP7wCz9I+hIRytPn+rJTegQGmRZhH/FKW9AEUdAFUQACNsACPhAEldCh6tMxwnoLfkAGUNADNP9AA146Ur1cLRvMj0CQ0KY56rNpmgae1mqNmhY4uDLsMW0Nr6Z0rrEeZOhq67lO4Hb4fMgyDdmgDVQaiMUACHT5xlbBEkwH2ROrABEA7fZsz08Xp1U1ASfgIw6o7QF0xAI0MguBU6bdCOVeDMfwGCfsuKXwARtASzxzBWoxJfSOn3LnAmhxQViHjFvXxS3AFPHjSUsTPXB5+Qp6MEpFXzJB5w//8HV+5yq9lDTBIksZYVuRBC/YEDWQA9dbA7CfAzVwwTTQA5ug8roqrLggC2nQAzK/Ah5AsF646daCwbzshXMwr8Yw1nb0886fmmIdHK25muZzSu8ZZMEqFLZWdkb/iiSu7pexPgxld5rNIIfTwCDon1HcQJB35jm6wIrfDm0QSwFPV7EN+8RzGqeUbVUX0FMw0SMAcUPgDoIFDe64QbDIlR9ufgkbVszYxGbKkBXTRcvGBh0uXMgAqWMIDBk6YLRw0aJFjBcohnRE4dEFihIjStS8qbJFCRcvSJAYgWKECBFBRxwd0eFoiwsbTsQgcQJFBwwdOGDAiuEChqtYO5DYyaFECxIbNnD4yQHtiRNq3XIwe8LsWRBsLTywoGFGqVvEcuECTGvWLFmeaKz44OHugw+NE39YEVlyYg8eJCUzhkxZM87JPHtGFlqZMtDIMpNG9hmzMWLEJr4mJky2/7DYrWU/FPZLN25fuGgBvj1s4uxfvnbpQl6sGDBetUyJ2mNTZUIdKFLAmBABQ/YIExgkiPCge/cJ3MdH6I6BgkD2CRF6dI8QxnyC7a/cqNEKonCKyibO+kWOE0q4DoYUUngBBh1eKGIIlF5ogSQEUbAuJgpHSKEEoXRKCSUXkFIhBaSE6qBEqzi4AC6wOGhLqBI6qICDEqvqIAMMMsiggxJ+akEutEiA66y03lIrrg2aMusDEB5wwIIPeECllFI6wQSTS66khBJEGtNAA7weAMGxyBqLbIYZEKvsFf+SGW2zZEIL7bWJlBsGGDuH8UUYX/bcxZZYXmEF0FQGHUWUTv+ovPJKSS6RRJJHGHmUEUkBobRSSiVlxNFGG71SFGB6iSUWUwBhhBQdIyTohQNLyKACVysoLwIDxstuAljLw7UCE0lAQaAivKACoRtSgo89gq4ooj72TojENdc8gy2XYD5hQSwNZUBBBx1kUFCG+jRE0IUUekqBpqBUeCHEsVRy4QaWaLIuxKRS+glIFttiqy4aWCDIXp1ISJFGnlZiqwYW2DrhYLZY6BHfhPet62CnTviAhia7NMMTSTBpZBGPPz6EDgvyGvmukkfu0gIHmHxAg8o8uNRSQOagueY5LsU0Z50f2fQSUUQxJWhVhlYl1FhqqYWXXu4s5phj4FRmmWX/mGnmmWegmaaaaqzJpmuvs9nGHnDA2QYYUf4c4SQqvPjoBaVEoMpVGzl4gIEK0MM1VxxzVMomgbwYI9j6iGXPIxjeK/aGF+y4BTfXgnnIF1hwQWUKEm5y4SaQgDXJwxasOzAmlsq1LoZ3xyXcJBhmQsqqy2/a8UgU69qgSw1AAOGCvOBi64IUf5oY+BMoaMp34hdzwAEGFjhggAEOUOAA6Q9AoPoBAAggewsOOWSRQwA5pBA/xB9EAwQWaEAB9c9vIPmVH4B/5bwqI2PnToEuOmlglGs6tTaj5gxnnlE1aBTQgAecRtaqkUCtNTAb1rjGNbjmtQl+LRvawCAGL7gN/3BwAxzIuEQsVHGJsQhEW+WqighaNYEMwK0DE1BABFxFHr3hqEQ1AYsLCiIQcdGEV+xqT0pikrkSsMASnDjFKVDRilKAYhRUQsUtBHGCz92AKiKQwRCooEWD9ERVKHgBS1ryEwS1ZAQqyYmISuSW7URAAhSAIwUkED8GJC96zhuA9QaQvQAAwI9+7GMg+Yi9Pv7RkIc8ZCERCYAPLAIQjygEIPzwh/HtwQ8ruNjJnCSZyLCgS2MykygqspkAQiOAA6za1Q5otatZLYGvhGUsZWkNWtbSlhHEZS6vkY1ddg0bv/yl1zzYDKDZYhSMGNYOeEKFm8zoVS30ygMUMAEMuP8qVxXYW4lGQIKvkGBYMnkQGlHALmIJEXU7+kMjGpUJS0TCEZB4xCMqcYtI1IAsLXjBh0pABSpoyyMtuEGP6vUTrlwgjnCUwAR8l6KrlEeaAhjkIBc50YkGII/VW0BGJdAAJpXMAXKUgAQ2EFIJXKBLILBA7VJmuyZZwAOoWEX3ZBq+PwxiEErIiwZy2iXHfEADSuLpCsw0g12MshnMaJPUmLHUpaaSlQaURlSjMdVoRFUar6QGLV95VWp01au2rCUuecnLCGYDG17DIDCFWQ1ViMIXp3jEIWSUFVxFgAJ1RU9eIwAevNXQRlY5EVU4gFe7vjFFM6JmBbICq7tJoAf/f/jDIhzRCJseYhCA2IMnCtGDG3QhoC4Ywgs01BOTuGdY7tJBDDJEoRKIoCtauQBYaoIhEmRHPOh540HlaFDf6ZSnPwUuZDSwgQ9sgAVxYYtTQJADFjS3Bid4LllIgIGzIEwuEzvBD6JAgxp0yQNBkAUqNtYI7hVCpoPwgU53ajsPPEa4nwQCEMiQjFFKLYBKZSrVmuEMZzyDv/8FMH+j8V+qUtVq0njGVWWJ1a7qUpdf04YFu6YLUeyCFZKwrAHUZ4ACdLgACVBAAkRsAAMkgAEMUAADbGXNV2ETR1XBilqoIgAakzjFDHBjbGtClRFUUy0VgGPdTsAHPyCiEIm4/8Mdato9WtzCET+oAXMZZCIK6cBf9voKVbjSUGqWiLduoUoH4FYUuLERtkiqLu6SO5eJuWUDNwBLjzjAgrpc1wY1YNFZ2PgjOScMumxYA51/+gE5/AIVlMCEIw4BCe81AhB/sAFPfSppyHCyZR5YARBmAIgA5pczTf2v1fjLSlKT2qpRncapU31gVL+ygQq0Rldp6eBeSrhr26hGMSqMi0tUYhF7IM+Jw3Nb9MBPPBSAlQzzuuIW20grMW6oXXGFFYXS6CpbKY9is1I3EPBhEIUohCH6cAciD+IQrjCGLORAgxyAAC06EgoYgbQTe8n42RfAlY6A5Du1eIUEruWKj/+xshXfUWWhR9Kt786ygbtqRUQd4ZGfndJctgDJXlj5iYbUMtCCgWAGHhhEMEohCU4sIhOtaAV5uccCLk3aZe3tKUo1IFRNjwIapW6lKmPZQJ4rkOc/BzrQsxF0ntva6F2bIDF1kYtTXKIUcnDDUcKDHgzYNa8UWPZ5bkXDbFcTVgN3CzW3Q02FbqXfWEF2G5FNtzfCYRB8QMQf7KBkcB9iFMb4hSN6sAIQAKwDCCKBqmp7IrTIuANmf+1VhsRNr1ClPLs9aHjgeHWQSiCvDyBpXmM0AV65YN+9awuK1EI8zk933wATvYry1ZhMEKMTleCEJGQhC2JsYhGPAIQNEDP/6DCRiZMsv90MnECGX0BjgVljINGFPvSfH71rRXc+86thQaIfsGrNEEYtfnEKSXTCEjQowwUsH4ETpzg8IR02+YmtV/brNVd0xTrl75rtrduKO3dzIxwS0QhHaMkQhkCERmgETDCGZEAFHmAL7oiBIUCLZ8sAt+CVMVoAzAupB/COB2A4CzAoGRkBEygKtQi9tGgKtkARDCCBGFARFRiBuTGR30GBelkduGGKtriAzOkA1ooBGECBtWgBGliYFrCBJrABIPwBKOgBHriFZFiFVFgFSbiFW0CFShDAQwiCFbCBGWiuLNwXGuiBfcEBK7QBIsiBNEgG41M+oTvDnzsg/1PijNH4DNiAiD0xDluohVdIBVMYhUIRBUWJJ0n5Hpl5BExYhVUABU4ABT94Az+AH/I7sRMjtvVrv76KFfTAJsWyobi5qziagPmzFa6oIVvJgOyggDVwhP6rBDugA0NwhAC8hFxohl/wA4bJDgbQgSJ4AZ+4kQyICrT4HLXILQrYjqvoDg6ggLNIITE7EadYKIMiHmbcCoApxmrKG4UqxiJBGA4YgQhoQBkhkA5EFxVAAa6ggITZAJRiLhaogSZoghyogTKYgTYghmQghVFYhUvAhEdphEdwpCq0gSyMDBDoJBqggRnoARZYARYQw0KIR2hhjdi4DePQhVr4k1d4Bf9VwENDsZJEaZQ+9MM/lBlL2YOQ3AOZ8QORNMk6QMmUrIM3YMk4kIM6GIRGsIRWAIVSODQ/iIMdmKPuaMS+oqFn2ptQbDFXycUcIQoTuYpbKY9qirGj4AC5qZG9yQ4JqIFE6D9KqAM66AJH2L9HgAXMyAQ628QIIAGFOQuNA4spaAEKGD050orAu4IYUIEYgJvtaKFKVCzOqxG0iyO7ygrjCSmEyq2S0p2UYrhixMBNrJEQgAAI8IJACAQv0IERiBE4uoAHuAAWiIqEOZgwWQEe8IRb4IROGIVGYYRD4JlG2IMVwDS+Q4xKMxMekM0gmAEeCIIyKIM6KMmPrJSS9IP/krQk4AzJ3/zNPuCD4+QDO5g7VKSD5qSDN6ADOYiDOHiDNLDONDADMygDKHACH/CBH8gBHOjH5jpIvuMS2zGZkmmvJ0gEJuKDN5ADTbiB22pMCADFZgNKG8IRFsOAMRMB2DnK14oxweLApOAAvsmRVoEAu2IBR4gESoiEJ+CDNYiERGiUUaCvW4AChoMfubAdp5AxgDqLGDiSjyKBK8ADQiAEPWBRPWADypyAwwMyu6IALyueOAop4ykZ+NGk9BwZsxguJkkobJoACEgAMQiFUJgERVCEJfUCrhgBtAijJtiCdcyBKIACOyiET2iFTbiETtDIeIorP7ADPrgD55QD/zqoA+mUgzdwgzggAzIwgzSIgzpIgzqgmTbQ0zbITil4gh/wgR6wARugAUIlz39cOLUAgblgxjharx7tUfTsUWMzNvdZGfn5JCkoBDcogz8Ihkm4Aay7v/azPxYKxfLYz1ZxMTGzCR+qF7XgNzdLvd+5iX/jpuy4ABBABEqwBEowAxvog0hwp0cYBWFoBmLYAyW5C4pREiWRCzkLEoY7sZXhgOlYAR9IgjHAgzGgG7OIo9jiAB/kTMnYwn6kAR7gQh8IAigIAu/8gS6A1y4AgzVYAzRQgzBgAzzAAxWoz0BI0kmAzElI0lBQBBYlBCZlA4CZI2P7ADeghEyghErAhP9O2BRHeQQ/8ABJpVRLbZ8G8Nj4sVT3MbbFoNSSrdSNFdmQbZ+MYtmWXQD1mZ6YnR4Sqx49wiMEcB6cvSj2cYAeSANEgIZgiIQPOAHxw0w4ojb7W6gzMzsT+QqGGqghMQs0Mwu4IJK0eJ0KSJET+IOH1YQKnYRSjIRFsYVZoAQ56IEaMC5AfYIe8IEcUMcqvQIwSAISkCZA2iMECII/AIQ2gAImYAM2sAE0uINxK9w80IM8+IMkM9zktIOsZE45gLo0QIPKNQMu4IIoyIHNZUcgPAEb+DccEYIQEIPRDQHGZEwVQNJQCIQmVQEGKAA+kqgAQAAHmIE9GMBNwAROqYT/IFjZl2XZmq0e6FEA4UUA6KEe4S2AAVhePHJe55Xd6JXe6aXe7Hle5ykA48Uoj+Xe5MGLvPgAJ4GMNDgESggGY7CFRogMC8jRETwBe8GdOrOuh6mBLTQWdZyC/J0CeK3cNYADNAiDMKDXwGWDPKCDPDBgBM6DwM0DPkgEiNUSSkiESIAERAhEXCCGX2iFdhIEO/g/ROiDP+CDEE6yO0CDLniBA/Aj53GATlAGsKkGaHCFFTgBNmiCExgT3IHVaIWjkzFZkmUSS60j5RniE4MA0g2E0zXSxkyA+oQATZgEEwgBBiAAGpNd7DEki0IAD9gDR7CESohYSvAA55FeijLj/zNGY0Lio+vNWe1FH+7t3vehVJSxnTp+uZdhTQ+YAfmag0PABFhgwk1YRUP4g//7PxVlUlUsRQd1BEWwykRIBEQAQEMYBEEQhD7AZMjC5E3O5Evm5D7IgzNtTjig1zUgiC5AAzvIkk9Y5ESABEioBEn4hVVAhDrwARrwqSQBLpQZGQlggQsQgOdpAA1Ihm3YBmUw5m0gBg94gBhgUZXx2EaU5mlegOV5WRRTn2yOnpj1MDwqAAJggAwQgtJd4iZ2YgjwVy8QMRpj5+hNJOdpgA+oA0v4BEo4hAXAYkACpOjdoz2yKIsygOuRXjbOWTbW3oOuWTiG45Z6mcoYqnPlAf8nCAIyaIM4oJk6GElAqKxFyEdIUKdHOBRSOIVBIQVP4Bg+cAM4kAIpiAIfqAGDURjcOc+RAVkH8NjkWWj3ieMGyCiYldnpUYAFsLEGsABEmCxIniyO5ujNCt/kySjhlR4Sk54CYAAMWGcFMAAHoD1GQIC7OwQHgB4RCIVW0AMGaJ49Yue0hiiLKoC1VqQ05iMCmIAQGF0IEAIjFbHRHV1/DQQqJoAq/mu1DoC0lt08eoA+aIVP+IIP8NiMah+8uFSWgZ+dRegGqB6Fbp/kQZmX+YChqk0eiC/5itOaCUmN5p7T9hhJuT2ecZRX3hR4qtjYXpREscdD6YSfycNReBT/zIoDH3C54WIzINVYJlmAnHVszH5jhfZpbo7qA1gACzgBBrhsB+ADCKWERRbAR4CEFeBpnXXnRQLGCBAAAljeAnAA1mwAMnAA5yGABAiEYAgFTeiAfN7n7HHr5nUedvYwDpue5XVux/6OxmTM9lZiI1ViMbgFPPiOBAjsb65itYbwYHaeBUDHFcCB4WI5G1CCMHgDLfgCNYBOOrgDP8jOONgDlKSUEy9tSzntFj+EjnTxF8+Z09aZGhfTGrfxjRTTHY+nnvGZnwFyII+DNqDcKKgBENAAClCvg6LpSrXUBUAADbNpluXpnl6fKMej6a1v68WenC2Dd4rY2bbHSvAA/++uXut1ngcgAQZoZ4jqsAEwgMEOAAJYXYCdhAqAcuYNgMbO5oyyacu2cmkGXuB1bvUigSNmYhEz5/pkTDHQg70KsQNo6w578AiP8OdhAAzcACugZ1RYolZAhU+wSVAAhVMghUVhbU3RlB7nSB6PFBzHcVKB9Vmn9Uyh7R//GaIpmljgBaWxk/1pmmNwmcbQnYUV4hOL45A12ZINWY6tcipv9u9lkp/6zDZYBE/4hWeZCGK4BUToAZ+Kn8z+czhegJVhAQbQcwEo7xrLngzw11sg2EAA2BOgAdyhATDQVjxgUQQuBEQw6kOwgfXuc/Upd0lfABAwhGAghmAQgyZmTP9FZ2LUFTEIyHRsZl4O++tKt/TBprECgB7YPQBFCIVPkIVWiO9P0ARN4IRSwIQ9ZJRLYIROeflbXxRUV/Vbx/kgD3KhGZpQ6XVf/3XlcBqnCQ38cgaqkoYGiyBg+qUMyiBu+IZvYAfHkF8l6aTmEkjueuko29wpiAJUjtcoWOmVxlIokIJAtQEeSHuBZIF9ycK35yShgrkZCIIgqIPbs23bfoQ/iIM31dPpfMly655GgARezZIveHbiZQAJwAAV8NdQuIVggPckjfyFv4VWgHeA1QMx0PdQWPhPsIHmCQCPVwD89ucBUAAKCIVgwIMqZsxzXmK7rs9GjB6pPgAOc/D/8bb0tC6AFFMAPdCEUJCFyL+FTzhYTfgEVPAEUXgFU9j1n//5Xlia/Rl6opea61+qo6+qacgqCLo1Y+aG8B8bcLCH8jf/8y//e1D/8s+H9r+HeqgHepB/eoD/e8AH+Id/edB/fYgHfPB/fAAIeQLbnIHi46ANGj168GhI4yHEGhJr5PBho8ePjD98QJFSpozHNG7s2OHzpxCilI0cRYpEqZKlmJk+0aRZatMnUKBKtaLlahSpUUJHrVp169avX7h8Jf0lTBixqMaSJTNmDFcyYqgiCdKTJ5AiTaHGTgoVLNits2rHhhLBIEECAgICCKg7IdSdAwMK0C2gQEGBvQXm/w5g8IABCRSDE4SA4NhxiMYQMojJAIEBZgZ/FRg44NmAgQIE9sqtazoA6rp7DRCIgCeULFlnFUkeEioZtGrbqmXjxg2cPeDA7d0rbvw48uL58iW/t/w59Hz9pEvv58869uv9rPvr7v379336/PErb57fP/Tq9+zhw8fPn0GDFi16JAlmpkybPOUshep/KwHGNqAsRxl4IIJHNYVUUrfgYiAuEcriSoEHsnIhLK9c6ApSvuSyC4i7PPVUVFJVRQsx0ECT1Vm3jKVIIDGapdZZoQQCQQKPQSAZXHFNUIFnBQwmwAEK6LXXAElKwABoBsBFAGsESCnlk3Ax4Fhmm3n21/9nQnqZ5ACnoZaaaQVI0EcraonhGFwQCKFJM9vICc5w4Bz33J3R6Rnddn1+52d2/vwjKKGDfpfeeYny4x133y36qKAD0iJphLjkYulRlVaaSy4eMnVpp5qKigstuNhiqqm2qLoqq62+kiEss9gCiy2x2GprLbWoqguvvPCiCy/ACDvMMMUUc8wxyBiTC1XBhCKGEJE1lqMYgUySlrNjQdtYCGJ4W20gYkgGQQSY/WWAAppteQABCUwQF5Q9lmbavKUpMMGS5ha5pZaheRlYknUBMCbBAqD7gCCyhSIEjjlOsiYKlRCj22+8UKOcdNcx59ye03ncp5+OgjcypJB6pyj/youC1+jIpqRiCswxyzwzzS/TbMpQQ8GsM8yq+Pwz0D7fimuuvvraSy/LKIPMMsgig4wzzkQTjTTSTGONNdlkI6dvdMqp4oqTQEAAAATg2G5kZdkYCFnhPtatt4GE0GMCoCWwJQEFgHaAlSowMFjegJtWV2lkDhABBxQ8cBgDC2zG5QH+CglmwINbLoCQDoBAiI1jtwuBt0JIyYAOrVSTzBzSgEOPOPTUs8499LjDDu3o2P7OO+2oo3s7ubeTTjrtCJ8O7rwLfzzy6ZijOzrqoJM77tG/Aw/161B/PfbwzLM9Pvp47/1xQYs/NNFG84J0L8IOW6yxxzr99NPLLMMM/zNRO1P1NFdXg7XW/W+tjW8CaA/iFCc4wxngAOmkwAUGJzjZyA00brEmtCUAADmCm7Vm5Cy5PeZba3oSa7zEmrqIZkqOmdLk8jalFRKALnU5wAZIwAEJLA4zC7ih47gEmi+B6XKXOwAL0JAHRXhBLlKCANs+eEFBOEES26DHO8rxDtnVQ3bscMfvgoc7dXCxi8AL3vHAiLwxDg94ZTze9LrIxexlbx3nWMf24oiPOerjOPKbX/2iVjVpUKOPWLsGNgKpjUESUhvfOOQ32HFI2l2RdocEnjvcQY9JTrKKk4ydcjh2jwEepx4ELCA4uJENOnFDTtmoRjWe0QylPe0Yxf/ohS5mZQwVJSNc3BobuITwplBga4M8iowun6RCf0UJc1D6XFzgEjnJlXCFqikMCk5wAgpYoIaZaZyWlsnDMFXOcoFxQA3YoAfRtStHQhDDJCKTo7HNoBngeAfw3jG7Ks4Oi2g8XhfN8cXkfdGMZeynP4cnvOnBQ41rZCM81qHQOM5DH3OsRz2OI45yUNR2wKNoOWyHjn2SUR3m+ChIP3rQgqqjHOq4nkJTqtKUCkQgCpUHPvYhHu/NcTr34AYvRHEJRlziEpJgBFAZAYihEpWoc9iDH/gACqpEMBSKiBY6XWQjtWHLRYpYE2R21DC5NKlJoimhkybwFrjszUh66yr/lAxAwgNIIAktaMEGNqC4BzjgmtiEnDYBRrnBBWA0A1CAAyIwAQHoslsxmgTD2MSAUdCpeb/7Bj3uEckrChR5XDTHOPiZjnJclKMABWgWtUjSkyJUe3GEI0Mdig+IHmeOc2wpbOMh29kK5LUCoW1L8SFSeMw2euc4BzngqI+VEnelbyTuPurBjWMAoblAmAN0owtd9uyhDtGVQxzewIY8GCIYxJgKVaQq1WqNpUVStZFkQpCBCrxlhOg6awEOoLe8GWAydDOSZ/blmbvtV29/4QAYknADGV6AAhKQQF3pmpkc9ouZkzuNAARTJBy5CVrWQiybIKCHbYCDdrgrB2Rl/1fPMwYUs2XE6GYxytnPfnHF/eydQUmKPYZeL44wfWhEjfOPHf9DpjLlMZD30b3vfc+1dKQpTG8bj3fMcR4p3Z4+GPpkhlK5yvigBzdE0dwZeIAMXg4CmMHs5TGT4SM8gIIXxpCHSLjiF1RpRrbYgk620Jks4sqADBrTXgEQADP59csOnWQCHGlGATd8HKI30xnA1mANYLhCC07AgQLT0AGLUzA272okB3dzcAWoW1wqzMtQ6CgDyQAOPdgBPHRIkh0ihmJozQi8j7aYosFTsa1ZjOIX686jl8VsaWvMPdey1jgjO/bJUqYykikKyDwuD3mULW1+4MMez5iDGXpAg/8ZhDkIDGnIl7sNhBkAoQtDwIMgWvELYzQjGbKg8yTYlsGxHCVbgRCCDFSAAXMZYC8MiICiI6e3BETABFn6Cw4TfmhEM2ADaGADHNYQgxbIUK4HpuGl7brwZUoOTKkpzTETwAAZiMEsYmvTGrZBnFR/Y6OUnKQkfedZWdf61rjWdTnC0Vkx/tqjmL0saanHUNfqA6YQhegckX3saS872ShztqGU7qin58MesZhDGqSwgg80pOtd3/YMwi72sNdgB0X4RFLaXSO2XPiw9Dbvw4QwgsX9xUs63HSTGGACy2SGcRq/oQ0B/4Ac/KEPfYCDgCPNgQ0UmAIGvnSCGcfgTfP/cEyX88vIryWGHimAsc5hBzgimTtXv7x4ATWj77K4YlyvOLQUDYfONyvGXhsUs+Mwx0njIZB5mNbIAsEd0vFRZd7z3nrWE/rwk7+9lSp/x+IRzzq819DpE9k78vhHP+6RDUkAYg92UEMa6lCHOIhfDuY/fxzSH4c5kGEOcjCJJZQBQbSo7bAxun95g3EtFwUiAxM4DGf8i5R8SZHoXblshuNMnqElmpEsQB/8wRpEnICdAAhY3MXRVV01TuBlk8AFhmr40F78RYXNDVxoADTYg3TITmQVR6pJUunlDoslz/CUg/BQVA3umuq1Xu+8g8/hHvWQVhfxVjxsz425FvAF/x8+CBvvsdH2JBRqJV+NJZQUKt/27MM/EJlwUVn16cM+wFTVFYNQ+QEdqIEb1AF2md/4oaH5xQF2xQEZtEEcmAQiCANvQAMx6N8kPBU6hQsf3l+0KIKz6IEIYEAEPMCm7Rdc4JcBYEYEyMAEXIZdXRPg/d0HaMIklAQddMEU1AALnADjUYBcVROmZaANPU4HfuDl7MV+TYZkTMAhNAMK+sOVRVY9uFrsvBw9kJEu/s4MXtTq8Zovuljw/GAQ8lb27N48wNYcSc87HF2wCVv2xJFsKZlspdE5qMM5RCFvzcMQygOURRkVQhk/qJY8sIM9cMMlDNUeyIEZhF8amt8bxP8BHZzfG6xhGbRBG9hBH+wBKUDDbhBDKOThmtxftXjLuECADIyFHoxAB1TAASKgJC5ABEQABgyBQz5AIV6aRm4k5D2AGtwCKhRCIfyBHazBFPwAJ3qipG2ABbQkRy7YXXWgkKTiaiiAyGUAFYSFJ+iCnfTDO6CDq1kSJUWP8DwPUSKPzKmeL+7cZ7EeReXT7QUd9UwjbCkjMzZjPQTdSWnl9RSjEMYDPMhDPOzgksnDVhaUMYIlWHqjN8KD9FWZNwqf8H0PN7qDN4DDMhBVHeBjG5jh+f0lYMoBHEgBGriBHNyBHTSCMaASnMVbZNzfvUWGjuxIjHgBDKRAB4gVZmj/JA115gVMwAh4AQY45AQ4Xku25MWlpoG15Ac4AlpAQiM0Qh/kwRpoYg60AAt0YgVugAZYgAQYGMYxjuThlb9wU5gMRnxZiQL8QCR8QifA4j28Q+zQTiVN0lHuYOqhEQyyWD8JozAGYzmE1G4dFFWKZVWuFkRhZT3gQ+/0jmMtGfS0Jw+iVPa8wzqoZfU4YXEtlJPFlD7onljKVj3Iw3oOqPQNlyRtgyjMASBAVxvMQV+aHx1MKBxUaMRF4BpEoBScARq8AR3cAR+sQh0mQyvIDbhsC2RIi2MIAR54wRDoQApgQGdaAONtAAeQgCfeaAfEAB6MgAhwQAcsXlwN6ZBe/4CRXgBvagAUlIJ3lYIkSAIiDAIf0EFt/kAO5IANRNpKxlWB+WZwYtrkyRfl0MWUdMYBBMAAaMAhQEItqJw2TBKq0UM+4CIuRpKdYpHpddYZ/Y6tOeWuKQ9IcSVv5dZUAmh6qufRyaei/uTuLBlajhRKGddvHdd+PqH3mCd8vgOBbqp4JOM50AM4MEODRpcZ4KOETigdWGjERZwbrIEbnIEUmIEaqEEERkIzVMOKBIOJGqRkqmgyhYAXUIGwDsEIDOkHsAAN1MAPTMEW3OYLoMAQ6IEMuEAK4GZuStMJkACOZqu2kgAIgAANFEJaJAMudEIlOIIhDEIf2AEcoEEXhP/BFjTBbXYiB2yp4wEnxmXgxoVGmNAL5ngGAADAADxAFjxCMfjGIaEaO+jDFNHpnd7pDsbaLvop681aoBYU7pEWbBWq0dVD9Bwd7uCeyPrayG6lz5EDymYjWnYlF6FsymajVM7YOcwDPxCfE6plMrbUcKHDN2xDLPTlG7xBGrRBGaABYLKhYMKBGyytG6ABGpxBGXjZrKJBH+AGWgTDVRWWtDSGlAhA2fTIyHmBF+gACeRmDRBmBObBuoJBEejAGBDC2ApYRizElcbAC0iE3b7VQ6TBJ4yrMcBCJ0SCIhiCIfzBlFooGHSBvHIibkqTkBqp4x3Y4jhABnKJkMwLCQ3/QMCiaQPMACDESQCtzjokV/Q4rJ1OUntKrC6CJ8WGZ6Aa1ElJz2xl6lU27Djcrq+5LMr63O1mLHCRw+2GAzmYrDro7qQe72+llPaQA83Ow8w6mUIh3zy8QzzwwzqIgzZUAyOQgRy8QRuQQRqUgWH+ZXaZnxuIhBu0gdNCgRlI7RuAwRjABiHggRCoADCdE9cGrP7WBWoQgAp4ARuAwZU+gRS8n+EVgiEQQh84GhtMQosGcBdE8BloYhM0wRRMwRVcsLz6wB8UiDBMxS+sgiUIbiIYgiD0AR+sKx2wQW1WcAXXQONK2uNGLuRhU+TQ5OYigA57gCQs5jb4huvggzw0/2PD1qkL5mJS0tyeAhTF9q7P5d71xAPIDmjtMiNEfZE+YVY4/NpSiifuRaUT/lYPZqxXjlZBNRQ8MC+lMtR21Kw6cEMxcC/5suE8Bm093vEbkCH4qUE81kEamAEX5AAJ6IC+ZcDW8gi9rNPYCIwAhIAQpBkbUO0fvAFJGN4gCAIfoMEUsIEisMEYgEHiaiIXcEEURMFJRkET+EAp+0AZNEIpyAIuEENVsMK5NgIiFAIfyEEdsOsaOG0XREEOTAQIfAAFMl7j5auC5ZB8yRdfoWmS7I0DfAAgsAIzqBxxbId2LAcL3kMVQVQLRo9sESMXbZE+1dpH3Z54ehTw3u7wrv+R7k2xN7+cUMYz7eRa75ZzRa1YSHEROmPjpHox7KoR9ZiDWzqv8rXx9GbDIwAB0qpf+tGjHUf0rE50Hkdc4mRAB6TX2STyjpxT6CQAXQQAY1CBJ6/BezSCH8CHIZQw4f4BHNiBJggCG7ABHkAcHNjx0p4Bh3IoGpgBHVBCKbgCLggDVfgCJ1ACJCxCIUipSajwhbprE/xAFKhBDiBrtnLApFGTBTzeYSxcAFrOaoCGoTWABgCBJBRDNnASx0BH7BwxzOFOOKcR0NmnOnSn63ox7ukuOVwjEO7Oxx4dYMvz0bHe7d5uOYgDYn+DU55zYTe2Y6NzOh8U7i3fE1KZdZT/hzsgAxDwgGGq3xu4QXbVY/dK9ETP6hvAQResQRFEAN0YEbxckCN7UIyIC+G4SU3jQR8UwiEoNSjIQiYkQiKwRCQY3idEgtoaXh/cAWKShB2gKh00dx0UwiagwirQwi/IsjGsAidUAiQkwkj+wS0XHmJOaIa+ASJYAiKYASoHc+N+wAZUIDVh3MGFhmr8S5McAAI0gAPMACOg9W8ARz54xz0o0mTNznXa0/D4IDz0U2EzNjqjLDunLMoS40AVsescnWBDFEVNFEWNA+yFgzh0g4h/A2J/OOw9Noo7NkDnkzlMH6VWdndQmzaIwgxwNhyk32dXaEQHbWn3OK3CgSc7/2IyPUlHQ4sHHXmMNAxCptkkBEMrNAIkUAIotMInaEImQEJLmHAoxDQhCIKXj+Qg/IGYu4fhGe4fNKd/wEIuEHUy/AIqZIIldPchoAQiGMJIGh5JmEQm/AcfvIG7bsEULG6y0iulYWS5qIuQ7JBodIa/5HcDWAAQMIIpKMMPg0OA+4MjfYM2PI8LQmzyiFQ5A09j217vBm84jIPL/hb2SA+duk6rsw5ib7iIz3o3eIOtz3qJm3g5oLOHnzqKO3jGhlRBI2/0rsOg7AM9OMO4zUAbMG0aoG8e8zGP+/isDi0cnMEaiK0unRNUHbm3z3aMkCBC4sEktBslZEJsHIUrfP9ClLdEIryIIzgCcKcEvd+ySKYESlgCJ+zEKtjCdYfXTVgCUgd3IyQCvo9kSjgCKiBFI0hpc18orAZ6MK8kBRS6DX9Gk6iQ3hzAAliaBjQAEIgCMoxSh7EDEQ/U7HSYGR2UR3HnY/t68N4zGJPWkmH4q7c6YnN4iNM6z4t4rps4r3t4igO7yKKzaQHXpBb7oOQDOMQCl4EAPj77sy9ttFN7aX+B0ZpfxI2BFyC5tyM5ZCpRCZC0WehHhRSILHiCJFBCJDhCKLTCJLBEvM/93AM3cBe8I3xCJngCKaCCmn9wVdxCKcD5CLO9vBt8Shh8JNyCMRBDJOD7CfOBHZhhxIH/wRbcgOIR2OPFZORIiVqVSZEsAGogwAyIvDVgAzh4g4hTLzzUwyKBETYmFBcBD+0wuGPDvIeDVK/f3g/CA/DN4s3Ls67vfIirfs/Tes7DHq4NPalDdlSeVJTtNfaog7H7wz1Uwxx4wAd4ABq0wR+bQWG6gdX3+BdwQRnEAdG2QRSMwRiA/dd/C2SGu5VEwA7wQSTsPYcciAgbft8WN9tHAkBAghSJYCRHjiA5IkgJVCZOoEq5opVLWDJjv1Y1tFRJUyZKBhuFXPgLGjFLlA4mMoSo0J8/ffLkobNmy44XMVqQ4HBBwoMHDBgoUHDAQFEARwMIGDDAAIAATxHMEKUs/xs4cN7UrTsnz13Xdl/fwXunDp66r+3SpTW3dtw4c+Haxo3LNhxcc+rwqnu39x09evUAA/Y72C/gunXFJe6W2Fu3btocR5a8WFzdcpfLwYU77rBcuerGkSUHT988cufgpS777l8/cMVmzPigwUwbM7fNoEGjhjfvL76/BP/ChUuZNsfTPOlyhYoYIULEiAkUKHp169OxKxIDIUECBif6RNIEqtWvX7dk3aLFidLHT8FanWw//2PBj+0toXLoqdQqib+ICUaWVVrR6JMDPTLIEUoscQSVZFyBRJOCFHEkEUQQMUQQQWBiY4wkrtihhRN2oqCnnxYYyoABjmoRqRYDQP8AgQaAEAWZbLj55p119HnnrK/caQedr/Qqyxy11koSLnLI8SxJc9xSZy144uGrncECq+evewQrjDPEEhPnm28c08bMMycTZ7FwMLvMLbrqWkvKu/AyUjXSygqtrHbe8ScfcExpo4waVqjNjDQQ1a233n4TLjjiuOjijNuIA8ML56Cz7rnnnMOUU+kCMUEINvCIJBRNGARFFvNuuQWXVRY5yBJZgslko0xsrcSSXekTyBJPICoFFf9c/UWWVmSRBZVlN2nWVkoEaiSRWBc5pJBDEFFpJQwLEWQQmGbqookfaDhhAwoocMAnFIcqgKkC3B0A3gK6E2qBBRpowAEgTGH/Bpx78vGHH3786aeffBDO5y98SltnHHi+SseztsxpkmIox2Eyr9Sq5IuwwgADOJ97SM6HrXHCFLOxx86EbDLHKmMTszcxvvjJOqdUbZ554Lkrta/6uWcaQMjgogYQcEsUjTPCWFQ44oaDlIsttiAui6nBiG5T67TmdNNMQVVEE00IUWTXk0pJTxZccJEFpV1RIeYXSzbZSNdeIZnvV2BBGXaVVVApBaJbfnEl8MDrPtuSSBJypNpFGjnIEUMSqVxbDmFao4sufsiBxA16oiACFFM8wHQD5oXX9AOEUuBefC0go99/8zEYYZLvGWwseOaJ56x0npyLSZsrPicvssTi/yvLenBnnuQs1WkyHDW9qd6blrF3+WVxZnarrbomTlItvHyWp2ez2mGHnXvs4YUMN2qggYUyyrht6TO6aFqNR6Xuf+qqoeCEJ0ChC2PAFNcQmEDsTAIPTUBDITIRCUpoAllqu0UmEBEJS2TiFsaQhd0qMR8NQksgkKhEJjbBN1B4whObqAQnNlFBVBwIFKD4xCY0saschjAhITmIIirkCGlZaCWF6AMf7MAHOIirBiwAwQUwcAHRsat0BiDAFQlggNUhgHVDOcACHuCBOaiiGdmwxxlxlw92fAUd6UDLkNCSFuCBhmZsOQeTRnMn1cQjHiHDXRr/srx6HCYcjrHe9f+yh6aXLaZ7GOuMXNiSjnLQSU7mw8tX2PGNe2yDEXNwg/zmR78ynAF/XHCU//wXhShAgZVBCIIUpuAFKjQHbJ2qJdemowhBJKEJUZiCIyIYiU9UMFmgUEgm+BMMYrQicILbhK1ytStcbYITMGThQ0pRikpUohStuEUrSkHDwK0QV9KUz0AKQhAhOqJCKmlJHwZhhyU2IQflIkEHMDCBCIyOAT9RQHesSIACaPEAXGRdAVi3AHV9YA6MKEY1rAIOe+TjG9RDh/q8Isd0kO9JSTrHR1Gzxz3KY3l/5FJg/khIySQSe5FRk0u5V47EtImml0kLZtIyJ3PsBUjuSMc37HH/jDnE4QfxAwEZoCCFUZ6BC1pApf+eEFVWQoEMrnylL6/ghUthB4G3jE4gFAEGXuagBk9AxHw+gQpkuaISAqHEJkDhimAIaFl1XVY4D/SJGnqCExsxoSwC5J5saiKv4rzrJzpyNlstriACUae0WDIIDCHiD3CQQhRa4IKclGif/AxKAgQ6r6Ig9AADMJ0C+vkACyDAA4AARjW4AQ5tlKMr7qCHVegRpDhqdI7HO96ddsYxeZBUkCX9I14481KWsdRMLpXMTMsBM5y2o01ytOn41sKXd3QlHeDgxiXm0Ib4zWAFUHiCFKRAyqai8gnEiep7mQAFq1pVCkH4wRTGAAY9/0xCE6GYBHWqMx1QZWcMLohfDnxAgyf8QYO2+sQqSkEfS/QtPa5SVjbTatdm8iohlvhFMm6BCIUYJBEaPFA2haVWZoKCE+UcWw43Iom8qdNCGFIIYQ0BBzRMYQo32OwF9Cm6CACFAQk4wEDhJS+ELkVep2XAUwbggDnw4hk4+oaZ2GEVe+h2t2lph2/1CFye8ZGPxDWpSaFHR+otl7mLpIxiKHNd7nHPjZKsbsTS8Q4tZfIb3EBGeMvQAxp84ANSRa8Umvre9nLhCUyALxMgrYQn/OAHSVVlFDrXhCk0YQ2E4G8oFIGdUPh3EqFQZjBCoYcWTMEHgmYBDWZAAzo4Yv+DnyiFJ1DIiRYKyxUDAsUj6lAHP/DhD2fdRF1LsQmUhCRWkIgDGoo9WRFTIsPLasW1rx24Fm4ir7miz2MbQe30aEKJaNBcElqw2Q1sQIo+AYqKkDwvpySFySxyygAQYAFA8EIa2+BGjtSXWy7/zo1frlOYxTxcfODjzGfOksWmJ47GMLelaYJZnNuUsjrTtOCS/Ms7+MwNUQABqYKejQCjcGhGQ9rRUWWCpBv9ciXMnNI++IEqf0DPzvlSCnyYRKlH/fP/KmISwUhGMDRBBynQIH40EPQKaLCCD9AADXZwSSEG0QgT6nVZlaiDE5zQAx7YwOk9CEIa/CBMVDyzPY7/KIQf5GAGOcjBD374Q90HUYhEUBvbFW7VgAR3Q1xlohPPlE99HEFBZaKiEHxA4jybeAIS6ESKPXHAZ4ky2gLA6ClPgRG+G9BaXTjD3+BgRz0GTnA47iUeyEP4zna2cIbfQx9/rMfsUfolNkU8MtkzZMu64Y1vNCZM30DH8TEzZzrLcRzlQJI52gGwfvQIHfZgxhzI0AP0slIKST2097kQBSZE4QnkF7/MlZAD9duABzzowfvfXwP5i50GPliDIkLxzVP9nIKymMQaWGAFZoAHaKAAWSAAWUD+ChDWYo0GbKAHoCAN6sAO5KD9bMAHWu395MvsoMANCsESUiybAucT/wYPmk6ihxJhQTIhr1JsWfxjnPhK1wQvhApiEwArGVDBD+ygDuBgDc6gqE7gidjNRB7g8u5FKIjCXQQAi+ClKLrIdYDCARwg9BhhGCDqjALGH7TQdgDGHvziedAhHuQhHtZBK9YBj85hHWBPz/ShNGrvHvBhH/xhH2ynH74n4pSLzZor+IDPemBG4sbkGy4jZWKK+cyhjczhHKCPZARmHbyBG2IBCH4AvTDt5lRpqrzv0jSxEtWvEzMQ/noAA5lO/tqPB6TgB/JAbF5MEyYhx5QAAp2AB5AqCHqArApQ/RRwAR2Q7GygF0exBkAxA4NAvoKgDNzgEChBrewKxURwWf8KC7E6ollYyNbUahVcpRViEBOeyfDqAxNuARqSwRL+YBDkAIl8sAlqIAiDkN1ORF0YoHSSsACwSKCcsIuI7B31ZQYcyhokSmQM5mByix4QJrfqoR2ohAzLEB4SUg13Rh+Gqw354Q37QR4GhmH64R3uEDG6oS4mQ5HKBDKqZzKsp6IIEbrc5BCB50jSQfr84R2+wRnmgAcmMQpsrhJ/wKq8j9JuTidxbuZmLr5u0pW4rwykwAzo5zjawA2Ucg3oICa8pQ/+oBCwzg/2YA+oUg7cQFDki9JqMRdDEQPhzwc68Su50uy+D73iYBDULtv+RsOuia8+ga9QiJr4wz/MAxf/XOEUSKETMEHXmuXwvLEkFuEPEmEQ/uDxmOjVWMBcKu8BTuQdvSgeRWt1WmcBGMAA8CX0gIARjuEK7YElz2G70IJP6iEr1qEs9OIdyAz2WLMN27Bk+kFgduYdukH3DiNmnGuRtOGQnisQBTH5TPIy1iId2kiOECZo2EEbeGEGekCVbA69MBAD5wsKdJLScsASzw/Szgu96gcNklIplVIOkogP7M4lJEvEJOg+UOJxEGEQdBAr0cANlqa+MvATe+ABfyA6q3OViBEKzoAojbIo44DBCKtvCATbNGxY6so/kqVVIIwUSoEURqETSGHwuJFBNsEVLEEqW6IlzFFcrjPy/0pEAkykJyCzdTJvXlbnCRWgAGSkASzAA/RRFDoztjSpH/5wHPooHhQyuFajHcgsHlizIfVh9mrHH4ILG6LBNg8DOAdRMqpnTPww+BZjTJDPSXFqo47k+OTIYPaBHbxhaDyAOt/PBzAtOm2uOtWvOrGT5ZigOOoHUZIyDuZODurAKscREQ5hEfIGmfomBD0BEypBEj7CESILiXYwDuTTDLqvDMwrqnQSAy2R0jDt0tILOv3zDGgRCmxDDgoBEugGIoIFxU7hb07hVAWnEyiUFEgBFFgVFDoBcjToLynBIyBBxBpBKlfiMOWpC6YARMtlCCvP8ogsRVSkKJCVMr3Idf/0xQJmwAPIgBF0gRlwxBvq4TLkoTSGi49Y8zRdr2OEdB5k7w0RBkmbhBqOgUktYxDnbJEOKSS9ITF8kxBr6i62NC2CxGDu4XqKwQM8oEy50ubIMj8xcE13UhOl5gvMwA3eIA7o1E6TyO4GAVv41BEk4YVQARZahRYAL5tikO1IjLJ0sA7kQFFtQwoULT8p9dDQ6+bQi5RIqdWAERTbjwZksQ4OARJSCMWCRVUxARNUNWiD1hM6QRIKYQL5IIM26Fl6aLJUgrIebw00h57KhQPWbQhP5Cfe0VhTtAlPaykQyjL1ZSlmpEaQwRoAjnvioSKHdB5Os3eqREvqIfZo7zX/EQYf4OEcsAEZeCEjCUldHYMjofSQxqQkFSOmZqr5mg8dviEd8rUf6kEbpIERLOADyrTVcqAHfuByCTZNsZPHuCAM9EcN3uANgs0O9oA8x3FiMUTr8kYSLgEUVmEW2AYXbMEWaMEVWCEVUAFCby1XDIIl7g6J6oBOFTVAoQAChZJleax5p0CVmK4TM7cH5A/B3q8Y62AQgAki7qqGWKya6LKFJGEQ4oAM0iAp6S6DVnBxGqcwLeRCeLUpl2jTIu8E1nFYTRQojFXzBkqL6E0pnPAoyJZGLmEZYAsc0OEdHNIhh5Qh+UjP6kEeYI9hXNNg5GEcumEZeCEWJuZLIAlK/wiJehrjXYfvzWIqukrSTbjnG9jhcd1BG5DBAyxAAzB3/sDycqPz0n51c7ogdEv3DeSADoItdSW2EPQ0JLROVwQVE0gBFtgmF3LBF3IBd2cBFlYhFVyBmW6txZbtEAyTKkm2ZG0DDRy1+4SS+3SyeVNOF6NX/UIxCmjR7IbROPYgZ08ohVZo22ylEfzADFwpN77TDewgZy0hh0gIERpBQeDX8WCiB5nIAO3XatGFCItwa08ndZqi8wRAAJICKQJgAGDHbK+BG+iB9vBBHhhyZ06TY4K0DNdBHihYH/zBIdNBGoBBFWJBepakgw+DHAoJZoavhINvZaL0+KTUN48PHf/chDjHxB3QQV/tIRZkYwNuGBTdGE3LLwp4WDfWQHR/+A3oYAcjdhyN2IgXodkq4WcjghaeOIpzARdooYqvGBVSoVVxjYcaoT0Psw7eQCnbAA2MkhhdCf54oAY+MTqb05ecdwpYFmbPwPuoigyMQzyLLRHy+RD4QA7SwFGLEVHgwGHp1CrD7UDGxiOEiCU81A7sgA50jNXkp1xAYN00QAJo+jFPNAFQJ16UrH+f0DKj0CdCbw5m5zNjU2CMWgv3YWAGxg1dUx/44R/+oSK/YRlioao7eGJ6+TAWI0rhtautVEqFzzcL9zIYd0zY4WDsIRsYwQNmo5q/kiwNjce2eQ3/dqN06SCIk2icpRKRswUh8qYvOQEVJKKdpzie5fkUUiFCV8iFPgIS8rkl9mACw3juslI3GJUYte9M0TTlFpqhWfazt0+pHNW8WIl+coN+ALr7pCA+wTMOkBYZua0jJqTGsO6IHE+ezoDVaoCsFjOmKcAChrWSLRMJk3Cn+1eLXMengeIBFMoBxEgV/KVkaqeoXXNnlhr2InIeIjIi3cEZeGGDh8Eu3gJ8NiMjfRlMHGP4QjJNxASso3ReZyoQ0WFkggoICE0DQBEHcEB6laDliIOHu8DcpPaH6SCc72DY7M6IEdlxEIIS0vkh+sYVXAUXoHiKZ+EVWIEVTqEUUkEv/8kphNqjhxZBT7HOJeousoNNjAM6tafKlT475bpvqph3CnLb+9BrCpLKxg+NlHactRmWTt1ADhjsQFqoUB97EPLuMGcit30pCuLnftftty1gXbSWuFPnuAnKdZI7KBSgAR5AA2YAEGzEGtAoYP6BHBZjHd4hz/BBHVQ5NbSbZ7ABGL4bGJqBZjz4qs+b94Z5vZ+rvcVavtEhTC4jENnnu4Bg0Cwgvw32B/o7qv57cwS8B+EADoL4DjD9iPyAdVMwIfLmwYMFWXDBPH7BF6TYFqqYFf7GFQDHnm3lmZjWsXrosVvi7iK7ZN1AUQGaKFUbtGM8qmD8xj37xp/zs+dzx/9h1sfBM9fTTq/qBvG4xRCM6PGWZmmioJ7W8X4tYMppmp+49pJHi6BOy16QW1004AN4AAgu4aEkKmCYJDHeIXfy7BxMAx74QQzjQRuO4bt7YRm2IUmuOuBlKg/drL3fNayNr02MWZPsYRnmoAdY4AMcoGDV7ydZDtJD91e5udILvMDtINM1ndMRosEtgRNIoVT9g51zgdRJ3RfYhhZgHhZaAXAEB1hIMBMqgXEaB4nzebJagipRXA76ObVjHBNZSdE08bJwLtjT6wya/n4cmpRo/AzQAFGW3dL9oBEmjATr47HdiVcp3Qd7rAZGxH4/B11q2t24nLiRte2V1R4dc9v/Z8QDGAEYnmEb7OHNuuIz28Ec2nC49mKqeYHOqcIeQBh8OCPg44JdL87NDp5wT3gcLmpM2EcVgKAHVkADHiAUO/Enf3LRMj7AzY3jO/7j76AP+kBisSUFGYdBTN4/qpidKdw8hKH2heEX4JnV9VIud+WEFquxCZU+GvukSxzoEzUrkbfFXQnpKxHndHI7PzvqpZ+Uqj4NlJL64cB0FyETbChBImGIvv7x8qAHmdzH0i2ShbVE3e11vAhZm3CgVqcJt5wCPhnfWosXmMHfxkQg4TAc5AEbAAJbvXT06EXjhfDYtXv5ypULF+4hxHEUK1I0Z46iQ3EcO4br1i0cR5De/0p6+4Yy5TeOEcuxe8nuHjVAZHB8sOCgRw8cOHL4VAKUyZOhXMJ06YIGzRo4TOk4vQO1T58/fwohQpTIUSRKlTCBQuWKFq5cu3yZ/YX2ly9ctlyh8rSpE6dMmSxVumvJbl68dPvapURJkqNFiA4VoupnTx05b9ykQWNGChQoQSr7qBzkxw8fPjRz7uEDNGcoUkqXPnOmjJQyZtC4QZ00TRo3r1e3ob3nUCZPnzIBjqTVUSJDh/kYzwNnzZouSW7suNGixQkOG6pvoGBBwoMHDLor+H7AgIEC5MmLNxBggPoBBxQcAAAgAIL5HvbUarZtm7Z7+/jNM7fMMtjk8w01vP/Ewssw09QzDz8YPZhRRRCFU9GD4zi0EYYTilRON+J46I046JSDjjgrjQhRR+y4w449wABRRg03NbBTTz7loAQTOg71BBdcdHGGa0s1RYcddtyxx1RUWYVII1pxtQkoq7gyC1tlmbVLLrbM8koqp5BCyiaYjInJXndtUldfmWziiSegvAnKXHVREkkjjSxyiGF+8FFHHXHE4UYbaKhGWRCgVbZZDzloxuhnQXB22WSkpVYGa5XCllRSbZzmmhtvxNGIJZ94YgmdkZzqiCGIFDfIH3wgt9wUXUwBnXQnnAACCBtcQAEFEkjQnXcJhDdeeeUFgGx6AgxQAHzIFoDAAg3/eDCHKsxwQw86+oyDDTYBfsPNMqro0ksz3OTDDz/kkKPOOORsONE4E14UIbz2bnihSPo+9JA68tRzzzvtvEPPNozcNoUPPPCgIxJIEAGxwzpaoYUWX3ABm6dxyCEHHXXYsQcfflC15CFNQgKYJZmAUgoqU7ICyyyzwALLK6yc4uUopJRSiied/Az0z3BtwkmZXXHCiSeciIlJJYFBguchf4ycmJ+OWUpZDwvzYIMNNdRAQ9g05PC1TmZ3FsUUaksRRRSlVcraY7TN3akbTMHBMceFUKLJJ2hmcmojq/7Rh3F82JHcGVP8sDjYt1JXnQWSb+eAA90tAN555BFQAOfm/xnQ3nfBMuDAdttpMAMgvVQDDjjcXPO6NNlwk00xwyBTzTb3+KPuur7/vq689847fPHxUjSPPvXQU4887dhzzBytqa11ww8TIfHEFn8RhhlBzv0nxx+H7Ef5fwxilZORQBKJJVGWMuWUtNwyFlpj4YJLWvjbQgssrqwCwFLAqWiY4ATLBLi0MTkNangqxCBalRg7MGY2aTADGQrVgyf8QFFg+xrZagCpHmSmbWqbAtvctppKteZ7c6PN3V4Ihz/9gRKf+ETfgJOIRFylVVQ5XOKmcAYp/ABsLJhOrjagAQ1MjnKXc88BiLU5zxVAPKFTwAJGVzoHNMABHkhdLZ4Bjf9qVGMasVCGMqChi2EESBra6E/wyAEhjJxDHe2SVxwtJC8JUSiP48CI8CyCkeTVox3uQAc7uCEKMqzwB0FgmMMgFjGHIYEJFNMCF8qAmjPMZm5v6NjHjBSy86XPESizhJtc1gpYiAUtwiAGMdICy7Xgon+sAOAqTlEKMIHCTTvLZZzI1LSn3WkRDZzaHhSzmMbIpgyKlIJlzNaDGkATNJppmzV/gMK3rZCFLXThC2kjh0FEYhM1pJNwdHiYQhQHcWs4gxvQwDaySaeIIPgAEiW3RMth7jtOLNbnqFjFK3bHAQeQluQ8AARAiKIXotAFL55RDGDE4hjH4MUx6OGPf6z/4xwchQc81GEOdcAjHh4t6UdBGlI63tGPgPRjHOnID33g4x3ewEa4aCKoM4TGBkx4GE94QoSfRkxHXDANa5LSmjS8YameBNnICpEIOzmCEirzRMtOMaWw4G+WsGCFV22ZCi99iRSocBkAUXEKXLYMraRQmpjg0rRKSAISkHDEnQpzGMTswQ59isOnAgUZyWBmsJWxpmGjgE2jbpObcGjhN+UAKD44om+lwiE6d+gqxOENDvCMQg6iEzZc2VOJSvzVdka3T2KdZ7VPDKh3pNUAC2jAA7TlwRwW+oxmxGKiy6CoOzIqj3gItx71eIdx5YEPfMxjufPARzzkMdLnSje4/9AlqUmvi1146EMf83iHNrCxDVWQoQ1tMEMZLtODnv60az9tL0+UwJkfmEabrfFU3orEh0FcxWSNQFkl1oSJTlg1FTCrmVdZ8YpX0IxmM6OZK1RJC1rMwhW1TMVZ2bpLUvxsTJeQhCScRom6DrOBDxxEYozJVzm8k7yCMoN5V1OaKDyBNEJ8Agphk8m6OfZuKmZxHPbQiL6E2E45JIw6C2eHItWBs1Kg1Q2eTAN6fkADu/KVdh6QRQYsYJ9ObO0TQddafrrHigzYjgU+0IAGaIAHh3gFL4qxjGpkAxva6Mc/+IEP5P6LuHxO7nb/nNxA40OmgpaHofNs6ETrQ7iMZv/0Pvwxj3NogxvPwGl5uZADzjAhqDjoGnvd2+me1CDT1pyMNik4GznUgQ9VqcohnFRKSwSYrKyYRYTFkgtf/EIYvOY1WnKx1a1GeML+c4Wxz7oKtObSZwJWWl3uwpWnQWKYwjkEBA9npMX86Z2P8d6lzmDq0wQpx93sJlMG1YY/tWEPiFCZb4DTiKgauYeGWzIaztCEHUwhCjdwXD11dR1fme60l+PyAYal2tYmADzfESjp2nOANHuADKNgRn7AYY98ZJS5hE7uO4ir3D8neuSD/jOh9WHclKucz8U1bj/8oQ9yaCMbtQDCeAfFBPj2QAlB9bTP3du1r0mzUT8YCmn/LFUG16jaOHYQ2SjX9+HdkBWAWs0fK4nR618AO9j7EwtbbMG/W9NCFsb+n1kxHLROkAnEgrlTnhyIGOMsBrJzI++g4JZjuCVVNplCg2xmUwbyBirdcUBE+yorHLvqcHCsrpqKFac4focWBLcarRKzYwHTWa6J30H4as9zAAF4DuIKSM8AENAA1FOrjNkAxz12t11+7MPkH69Hyf/xj33ofvf+8Meje7/7fdyDz8a1ve2TS1yX76O72pgGI3hAhtUEwQaL+oFPP40DFmCfJ17zIKRyQM2ik+boSvWkx+zw1CY1aaruexP8soprVmbdfsEGO1vwJ+H50e8Wt4gw2Yt9/1Y8k0uksEtzYTSAQVd2RRiGoU6uckx8pW3vBBneEyR3d1R/52KxsUlS4GJmwGJtUAd7kxeWABzwNhzEoU4mdjhykBzttG9kE2W3Uk/VkURJhB1XtnlcNiya8zkC4IM/yB7Joh7RgnoNcFvLoDv2gHvpwg+49w+9l1z9gXv7kA/50A/9UIUMcYX58HpVyIWvB4b3gIVh+Hovxw/9AA7FAAQ80GJlwAVMgFg9xWmgBnSjdiOLciPYZE1JZ1+qZiRNNxWFYDJY4QikRFWa8D5ltQqyEGHBhhbBEGzABmwyc2uUKDMMNjO1BEBeAiajgAq79DOXoEAeBgmP8AjEhIpW8f9AJFM+yFQHbrBtdpeB3XaBf+cY4PMnuRgHbSAHfzBOfkOCdYVOrdII6pQIkVAISYYGajNEUUZ5uEKD+IRPTJSDmfNlxjJFoCNmW+ZwlaNFB3WE3LAPGtWEd5Z7/uBn4/gPXsiOVjiGDMGFWUiG8hiGV+gP9bANojADM0CLXGBjUSCHdAhq3Sd0d7gohgUFSTcbnUQHTWUcJCNKxvgkeZEJBrRWU8KI9GNrXtd1YkeJC8ZgXWVsX7UKYVVWqAAmPlNACiRXj9AIc1VXjrBfq8JDe4JtEgRZgDI3FQQ3fPd3adAGn6KL2+YGvegImVBOwCGTq1IIgkMJpdAKluBDLuj/A18TNkVkT0hUg9OIZVgWLAZ3jf9URQ3HjaTjANLiABZAW7clMLPHhLK3D+mIe2DYju8Ij/ewXbvXcYIWaP6AhfbwDHOwj5ChGk8AhwCJBALZXp4mdB5kkNWEWE+wGqgxG2ZQfuLzh0ZSJFNhCFlxKipDNAaECq3gCrIgC6QpC/SzVTLDmgwmYSC5YA02krXECpx4CqPQbBsWTHL1YQmogCRGFRB0TIrRMYyhTC5WQZZpi0I5lIMXB35wlJ9QKsJ4FYiwCI2ACrfwC6gwCHKAOO8kRFVJNiyQK1mplZenHTjIeeDxROZBHl42lluWZg2Alvi0AseAEuXwlrMXl/qw/3v4QIZd+IUM8XrIBWgkl2d+5pf3AA69sI8rUCmSAQVtY32JqZjrZSMGqaHY1BkzJgVn0BpJ5SkMWSSaCQd0IBV/QIhbARiVYEoCiAotMyUx05rF5pqvuZGs2WA7Ogu1hDNhtTNtsjQE5GFyFWKQ0HYLqE4NWD5Vk210sFRL5RibRBuNQXi5qGKwuDF+ECp1oZTCYZ2Z8AvEYAyy8AdycDh0AAdBJAWdEU1FBI1ZmUTZ8SumxR1fyZ7hoafEAp9kuQAIYEUL8AB1OgfIoA3aEA9MyF2IVnJ+tpeNilzJFamIhqCHhg//0A/2kA2MMAMeoAERShpt0wQ+daFAlaEaev+H2PQEQXB0RwUZaBCUG7MYSuYUdMAHUsEkWVFXW0EXltA3bCKjD8aIsmCjpgkLxBozlaijEraRMBNWBOYyX+IzSsMJcoUJ0eYIc/WbhkGTrLhXh5NMnSSltCEbLdQYsNhjsLhUfIAIVFVZ8NYIrZAM0AANsrAnmUUH73QGbuNZX0NPuAJwFyCNduqNnAefCbenVRQtW2Q6EeABjBAN3/AODcIP8tBchpY8+jCpiZagefZcfImggTZyZ2gPyAAEnfoAZMAFoRoFTTCqFnqhEIOqG9o2q9qqHWherrEx91UHtWoHU4E+h5AVhciigIGUbPIVGHlrxCqspjlsOaqjljj/bLRQm6SAVQDUVgTIMgTkopWAMjB5V9Y5OKzIdHUQpeJ6rhW0SeNKN67xBmkQB3ZQCJCgCe92KpXQCvRqDJhwPoOAZI0FT0HUBD8wnicApwF7ARdQWldmOgXHT60lHtkIZgfbHqOzj6JgDd8QD3e2qMqVsR9raKAbus91aCNnuiM3UmeISPvoAQ7gBIaJWC3bBAEZs0Rwh0BBs25zGZXRqvS1kEu1s+f3MbdaFVhBiIX4JFS1JklLdcdWdk1rmjMTtZdofxJWYTH6iZ6ACjqDQJhQFyT4G8CBincCd6s4NWlqnMY5pcq5kN0kKLcxN3UwCJCgMnlBCUnTSp5wCIQx/zh9kGSN1Viz0gQw6DgAax1zukR1eqdgGR6S+3kHUABfdgDzsQC0NQO8wA229w/yYHJ/tg7wYLEkpWfBBbrPNQ/ClWiNRrrB5Q/3MA1zwAMegBNkMBSi6rJyCEk5rMO2yxM4ogQ5YCM9oQQy9gShwUg05kwJqRpl8JMjan51cAdHEpx9q07H61/u4yaesDNpdZIuY2yMOHYbOWw0c2sF1lUoiQoCtgpabECg4L1m8ht25SSDcRgj0yrrpJnGmba0UV/dZAa04Xfkqmq+2Dd1QSoedgiF6CTo5Cp8UKuxglg+UQOHqytyenkWYGUEt2WPqzk8GLnrsR4IoAErAASM8P8MGcc7TOiEd/aWrezK5rjKT9h7frmF9mAPxTAHc0AGO2GYr/sDLvuyOtxeEGOqO4wDj4Q9OgIUFCp+R5eBsDqiTOUURxIVSoI+rTIInTm07KMyNQQKn7BWZpVsqOQKrdAKYDxLW9I/YAdhXgULO7MKX+EJlcAJpVCtH3YXdQUYhgemglMYh8NqxRGuTMUxUpoUIOpC4JQ35+opsOiLNSSdpiJi8Ta2aaqmtfEoQoeV54nACeyVWrbJj7unkWssk9taSQQEQHAJuqNxq0zLswzTtHyFM03TM82OZGjLm6rLT6AEPMUETuAESvDLL3s9OQxUOSxJkrTDk9RTQ0yhM0b/Y9+WFGpA1UtVq3QAFdWsJECrTsTRmVoxCfW7JkTjfgIEJyzjMqlgbP3TP7PUo7VECqvQCY9QrYNxCPTrYXMFGCFGSoanQ1EVb1IjiIjBVw0ZpQVNrveWFJyUvnqsk3FbCJGAlF56Kl86jI1sJIBbGpoBg+T5b9WhuNKYeUzkuOypADtI0p8HZhZQTymtCrYMjwMaoDhty7Vt27dtD66zDdmQDdWwDL2Qy2nwBNmnI07QGUPdU0UdMUuNPUoNSUytI8psTUYnKeGGGl/APWFQ1Wf7FFl9B1IB3uD9B4ZgCFqxPi2qMkizS0JakaAAJmVlbP4DC8mmxakwCqxACnKV/62DsL+QMAiLMAiPIAkuCQlQdYyJYOA5lE7JuCcQCKXRPKWQgRrmKge/G6VxoLNxUAd/cJR0YSqoUoiLdxhSkaaNFURBtEEFLIOgTVpciWU5yI1iBrmqfR40cAYrMAMpDQyt4zrcwA35kR+8PUbOECDIgAzHEFEIEQuqYAqicAmXwAhRDgi5TOUpndJz0AZlYAPaBxTxRbg5kNw6rNwRc9RITTFWEN05N908Iike+qFcgN1xrt1hEAbcowZWXatQQc1RURWdGW+kVEoriTRzkRdEIzSlcAqKGD+31AkAxAmUsAiU8N+HsAeU0Ah10AaSQEyOILfqB1X+bBjne77Z1v8YURrhFOga5fq2nEQ36Popf9AIyvvhlj2MrcJ0KuYa9yZE4xmDR7Qru3LJjFs5BRfSeapaVGQHaCDDFuDaUM4IgDDlupzSPLCPnUpb1+6pB4Xt266W2D4DFyQFTRADMXACXf4oPuATyLzDzb3UST1JVoDmaT7d1T0Z/1gaT1BJFRPncr7dLzTNRsJq6DOTusoVFNmrBT+CREOtmOAJuNQJHhbXpiQJsG4VIWgHf7AIldCuibBqTwVVeLUqe8JDN6nHaXvQqbF3P7lJfEd4jQHZ9Pu9Hy5ii1fREhQHTFEbURBNVklPuTKDoV2nOKhPxC5mXdZaK6ABWNYAbbCPlTP/n/OZeU6vRd5I9Vr09FefZlafZjMABTXQBDVAAiTAApmmE5zhE+uOA89d1O6u1JQU3fB+mDJG75PRNqUxMfC+PV9QMRaj3VRtbmqKX1wdtNYJ6AUPYnudMnfhYU3z5AMuCWRFv3swCIqRBpUBi4iwB39QCckY8EyypLYuMtemmeK6k0iF8n7Xd7FRd+T1J+caB39Av5qgCfZ7KjNfnUyKbRd9b4hFuDx/K9AI2r3SKwQ77F/JZcbOAhrQAA/gBG6gRUWI9Wn2p9M/n386H0W4Zdd//dlPwTRguL8PAjSAA2ejKDkQSdeT9ufP9klNSXDf/nC4b6YGBdRtWDny9hVz//f6TueLPTcA7J2ACBB/+vQZdAgRokaOHEFiCEmhwkaLICVctKiSREePJDVqlKnSnkF+/AQx86dHjzJu3NSJJJLPoEKFEBUyWAjmHz58/vzxw8eOHTpv5LxR6SaNGTRozCBNiiZNUqRp3Lx508Zqm6lGzcT508iSJk2ZLFGKFMlho0RoEx0sJDCnnaFpzkih+yNHjRosWNA4cQLEBsAXAGuwUPjBYQeJGSxmsGCBAsgHJD9wYKHOnQYIHCBokLhzYtCeG4wmXRrBadSpVS/YAKLvBRYgWNg4eTJHDhtEiCDhjYQIDt67ezPRLbz3ly9arDBhzjzKlChQ6Er58cR6lP8oP6L0Hs6EN3MrVrRw4SLlTFOVaKbKoWMn5507fmDKjLiwoSO1hxYhlLjIz6JBAGnkkIL2MDAOMoKoI4gZ3OCBhjjsqEOnCf34g61CLLQpp516knAoOYxK46ilkhoRvadMnOqNMq4acUSj3PgjkkzAEousshRyCL+1bBoEJ6BCdAONM6C7qwYakmTBr79aC6wwKA+T0gHGGovsABugmEQQCxpwzIEFNFjBAxBoAOEDND1Qc001NSDMsClBe8ACB+YsDATb7qKthz17uK2JHHwrTlDvfPuOuN50+y688MB7ArsprLOuuuuwk4LR5sQLTwstkPuCizdGZI+OOuAq9Sf/PkSC74+YZErEPkgoqaQSSjha6xCDAPQPpD3iqMNCMnjgIQgePjCDBjSkIBZCJ/hYyj2b3PvVwjv28JAObOkYiqilSHwxxRNfLGpcclfkyhFNPvlEE0radReiW9vi6cM4jiKSuruWTLIvwDYQbIM34URMscYeU0CyAwygRJM/ctigMCoZ+GCFiVfg4Uw0M86YzTbd9Lgwj9ecuM/abOChtj9zKE5RQ7lDgrlEFQWPUUYfxU5SKCS1ma6ZG2Vi0049DcMNOUCsow723LPQjz346MPCnWBKS8dYKWEoEQL/GOTHQQwMKY6tgogjDhrQfCCIiYOQYwYLaHiiDhveQMTC/x95YvqOX3N6Cy6q+qYqxhObMlGqoogqvG+p3ohDDj+8UjeTdsey+qy1ZrLJQ6TdgMONuaK4K8l9/QLsr48Lk+B0KSlbYLHHEP4DDjWYiE2DOR1YgYYVQBB2BtB7V1Iv4EHXawXicwfhTBBqMPnk2oQ9CQcc/mxCNxwUZdnlQoN7mWaamdg5Z+ugAN/SS3v2blOhw+BCDaKEKlooUq0VCWqtW8V1kYQauq8RRO6PCBJMVGIjYDtEHWYwgyBY7AMe0ACfPnAS65jhEHR4CU8M5Iejyc8nEtKW+/ymksAJjnCFG5ffRqQ4lfABEZTYxCfEYomxlMUsPDrIIdpyLaDA4f9ePvDT5/pyvDMNxk0WoEARJZC6OhUMMgp4AxeeEIYo8IV2D3AD8WbwoCThRYs02CKSvJhFLuJFLzQIHg1MdhJhOa8H0PuToK7nMjhq72c041R4HkUX8D0Bj1DADnaUkylNiQc5YSDkG8LgFHCdSkLW4kn9DFLDXDWiIe2qhCVoRUlLYIITngBFKToZQD/wgIEWoNgHLOCBFbCgB05wwhv+YIdByKF/dsvQ/Dz0k58cLSgfLEqKBicuw6nkgyMam0rsUIhItDAskmvXDNGClpn8yCc+ocPm5qIduyBpSX3xC5o8doELFFFgD2DM6iLwBjjAgQl4WQGdzuCGiX1AWFn/1CJefHfP37FAjHvRog2Wp0YbsDEHSlDCoA6VPexl72d1BJpybBYpSZGHPNDBTvcEySlPfYGQalhDRzuKLaGUKlUd0hpMHokI/OlIErOalSUxgYlNwHSTnOAEKEBxilWUohSZWAQZCNMAC3yAdjQ4mQ/KQBQ70MANh2Dar+IzP7vtAZc/6eD7htmtb6nkKkUZ21XGFget+gFd67qRu3L0kMpJ00NysKYUpjCFH/hAm8BjEpr6dYEhjjMCEZiACu4ABytwYQo1WIEG0MCHGYCAYmrkYW0ce5It3tOfeaEsF/35z5ME9Da3od4b49gd7yyUU6Md7UMl6sQnkKcLXYDO/0KTg1GMpi+dHk0nHLJVhz3spJFbK0hacqW/lcIwk5ugaXFt2slS4BQVOUXFJgYxAwfMYAWVUdMHoGCDFUzoV1vzkdYItLX5vWVvddBW0awqoqWYQVxo2KobrvLer0LhsGN1IQzNKkOHVK4t0pSQDs9TpOx8TpsnIJ5dOfABgL3pdBLYawaEIIZsCTgmZlKsD1bwgzPW5gdB4LAUylCGErXBV4yUiSMiAUM5QAEHNqgBbvy5xs3epnpGMEL1dsMymHXnZc2ZI2ljWx66nNY6ql3tFND3WtJmNAyr7WgXcvADNLRHbyOlG0xQitKKNOIRGlnpJTDRCTCDmZM1Pa4nWP9xilOgAhQ1/cQmcEWDyohpBW+gQQ9cqZM7FKR/PrJhSGw55Vxmy6pEIZF6QZiU94r4vWbAShykgwY7dERdyxTufWkokw3xoQ6bg8MaWNsEQG0ReMbDmFDdBM4JTCAEVBADFd5AByU8AQ2JQEUk3BChPSDiD2uJROQysQnkoqIVsrhFsX8RjGAQQ9nKNkYymh0MO9DmCZddY/RUlgPozdgIu2nOjpdTKPDsmMfiCVpsw3CGD6M2teSRAhfOQJ4wKIfcyQHaIA/ZhTU0gQEAAEABQJCDNbjHaTiRj0m7Foc5JBwIQNjDIy7xcC9/uRM1rakndboKVLCCFDr9BCg8gQr/yO1BTDyQ7goEbgetHQRriOAtrvrcSJxsUELk3VbftGJoo7DXKu5VHInakN5kSQEKZbCDI4D9uEy8sNIzTETTe4QTpLHV02/NgW3sScYV9MV4GQMnBkpAhUCIIQO+8oMlZBGMX9wCF7j4Rdvdfmy4tx3tx0Z2MIQhjF/c/e7KFkYy/B4KImDXAwHNNvR+Y/hBvRHHPAbkcug4WuQI2TqsFB8ZQFwGKJxWolPwnkQJiQY4sAEPC+B36QFwABQ0oQ8xGUQiCnEHgdBhD22YAxDYBIQ5MAITl+gEcm9KilSwghWwcIVOS4EKT9rUE56g6SYosQcgjPwocsjJSS2HtZBo/41p1jJQ90tl3m0ZhdAv+qVWpfKtby2FfW+IdLom3cJ14SgSNGQLkEIEViLBtQcnQxINWtBNDhiMwgAYEuCArwu7EIAAV7gFurM7Yng7CIzACNQ7ChSGZfM7YjCEFRsTwiu8w0O8lTmo0GK8b/MZ7vExiZIUVnKCJyADKLA8F9Q8wXqrKdA8fMuDCzC90mMADriANeiDQ+iDN7gDOriDNUiVhFOT0ViT6JKETfCE40uu5EqF4IOFTUIu4/MkT9gEMAugPagDM6CKXUOEV4Emm8A03vKzqOo+XCqvmhORwIHDp1gKOXwRNbjDO3wDP0AE99sEP9wETZCcHFGLp9M0Of9Amo6aiyDogUW8gRZ4RCYJQLsKJw4YAS9AQAiAgLqrOwnsRE+8u7yjQGXzu1aIAhtgAeLpwGw7vBBsGXEbwXEzH+5pKJ1ZQVbCmRfMo4d6qyKTqC6wgzUwAB0EAAXgqwtoAjhIA8RZg0NMQtJYkwYIgAFwAA94g0QANo+LwlVYhVEAhU7whG9cPk5KPjDjhE2ohIiAiUXAlYRQiIrAn3XEFR/ZGgvqvg2iufYZlxQBoRDSR8LBQzwUihWCPz+sL0Gcv0sDEp+YrTOAgiBwyBtwxOFxjRPggONBMBQAu0AQgkzMgAnEO08MybYDxVC8u2EgBmMwhkS4DQIDgcJbxVb//KyDWpRvm6NZZBRO0ZlalBQOEx8egxQafCt4g7QNCAAdJIAIYIAJ4IATUII3+AL24YOgIIM58IDSUMIAyEppRIAFsIFCgARNKK6aeqmX6oRRIIWNOy5v7ARNYr5MgAQC2QOJ0J+HcIT9kMeCsImo6gmZy5xBExHAzKo6dAM1MIP1ewM8HAQWUpd1AQv7kr+E7IOYs4PNMQMyMAO32oEbGLAlIYGWZAGN5EgIyIAJgEBfCElfSM3U/ESQpMCTNIZbkIIoyIszsbHOismX+awcW5SewUl5Izct0MknEB8WnDwn8Mnm6CMafA4u+Lw1ID3TCwBymoAKoAAbYAI6UAMo/5CDNkgDMsACq8yMJYxGAAgACniAAxgA9RyABWCBQfi1TAozMDtLUjgFUhgF/MxPcOSkTrgESTiERpAEd7GahcCP/aghDKmbnegDvfkQNwwmwAzMo0C/wjxM9nECNfADsJw0x6y0Zpq/HrkJBoWLoxiSIoEr5WGBR2wBMmKBIgiESRC7DMiAvWq70wRF1cxRHd3R03Q7UKzA15QEG7gNGmgNllkZ3OSOTOExb3s85fCx0SIP8ZnSnCnOJ3CCILCO5IQU1hLKz4sCA9BKoyzGCOiACsAAMFgDM1gBH+ABwpgBq0SNBlCTAeC3wzCAB5CAAyiA0huAFSgESsikL+OEb/9MLvxEy1EIM1RAS53aOEzQCEqilf3hCP6pIdbTrRGdKpp7H38El/TCqjQASIAkAycggzswOlDg0LBQOhxxhB6ZiZ3QtFBJp/zzHLx4xBsgozEghEkIhBCY0Qk4ogocSQnk0V9YzberQFGkhTdgMSQxUuFA0jdCqJlhPPCQNx9DMtLiAiqtxeOEghW0GfIxj7lAt6XoghowgAIYAAHIykysAAiYABRIgjVAg7IZjVPKDAQYgDn1AATgNwHIwQEIAAE4APQ0yvLkVxZABAD6hOXrpE4iBW88y1NIBTSzz1E4hVF4KZYSIEqQBElgCIh4xz2rG/6aKg7qIJs7tF8SIVH/LUwzcAIaM4M76IhUVdWku5EcWQtDiCaok4Mcyj+7uAEXuIHb2NVQUAQhCIEQCFYKkABlxdEePVYezdGPLEllq4SiIqy/MA7ctFYlNZ9rfVLkiC0UFE4V/NYrHc4+ioLpOINyTa8zqAEG2FMDEAACSDXqzIAYuILBagJUhNPMUE/OsEqjlE6jrFsBKICsVAAGqNOsHAAEeIAvSARLUBe1RMv7HAVWSIVVoELgO0tPCKAAkhXTDdmJeMeKwBXu+pHwco+Zc8Oh6CWn4EfBUb87tMxgKdVSrYNG0IRSYMw2C4tN0FkQNdBomiap9C+62IEdmIImYANFCIUYZdoeJAwJ/8iFXLAF7u1e7+VeWqCFWhjfWvheW9DeXUjfXeA7YUhNYsiFmH0xHhhSafUs7LGC7xBB0TpB2NKNTpHSKQ2f4RQfnZkOA6aLKBhg6ZACFqjbAiCAAGCMCYCACBgBHRjSNYACIIAuBIhcavSAOgUABnCAAHDcA1iAJqAABSgADiCBrGxXARiAAmAALbCEUEAFHF4uWAhfXBC+bfxhVljLAGKI020ISo0IvCypDsklDho0xPlUKGYKUcVdw6QKNbgDRLjcdWmhFiorpms6pgEERaKDIcG8H/iBNYCOMNADTajeDMCAwQCnHN0F7a1jO/be8uVeXdhjPubj9b07XxiG0//EBCOQX2HxgeuxXyYNj1cct0B6PE3hjf+lUir9sA8j4OE84OlIYPGhCzPIgQtggMjYqwkgpwjAgBdoAuwoA1EiTwBAgAP61wAogAgYgMMwWAoQZVGOgXYVU4JdVwdoAjq43OVyBVpYO4ut2M+tWFIAx04QoJWalXYJWfxICI64y/nQrQ26R5VFnBEB1W92iikWVcRknzqwXE1AhTb7hFJYpmZyCIc4hEcIoAVdyDbIv06DA0VoYzFg2hE4AbsCDL2z0dTcBdU0aIRWX13YhYXuY17ghV7ohWKY6IjeBVwwoNnYv6I6UpkJ20YRD/AgwZsEGkyxgsjLRUq25AAOnwP/dsiHnA5G64EpsAEKoBIK4AAMOOUe3ICAYqUZGFxpVEJ+C4ARUIAAcAwWAIwRPoATMGpfLk8BiGEDOAAHYAJaawVhkwVO0ClQqE80k1hwDKBZ4dhLgmeRjYgD/S4/k589wJs4oIo3dANwLjSYfVn2CUg1iINMAAVstKlfE4uynohUOFZc8IS66YMP0SE4yANCCIVQ2EgTSIElyboTAIxhuGzMzuzLBobUBIaI/uxeAAbRFm3QBoZjKIbTDu1UmIGAQqON5g5uWw6PnqOQrsmRBk5s9RRudcGhEx/Mw+QnYAIWXODpcGnpADFlbAM66ANBoIMl2aYXSIIksIEmUAJR//LX0+BX25Pl8mSABlhPB1BhBXgACvBlrYzqGJZh9VwAM7CEUsC4mKqEmkJL+wTr+K4EspbmIr5m/MGa77IlVZGDsTma81KvF/nUugZIwwzItyYDR0AFSwAFHC4F4vLDGwEgVjAGZDCGX3AFSCgEQXDdheSDSHDsQPACE5CBGJgrfploF8ds0R4GF59x1D4GGz8GZViGZWAGZogGaZCGbciGbLCGaYCGS5gBGXuxHkDkHTuUb+sOLaDtn6Htm4TSKDdp3S4DMrC83/7tPBLuTO5k8emwMiCmo9EJy/0ER6iBMxiENRgDMCACLXgD2wtPzpgB2xtYhOU3A9iABxjYA/8QgBMYWD0fAKdWgAVYzwPQSsl1AC5whMV8QuNDS5syR7KEuI6V5rOoD2hSa3rkCby5DLxhj9nlx29ecLu2a1aCBFCwBE7AYXG08LEohWSohmdohmTABUowBEJgi57og0kIhVaIURmAgRQAlM9ZEhDQcR1nBmdwhmjw8WmoBmoX8m24dm7IdnDYdnvodm+/B3u4h3sAB25oBiBYgdvwJxw44x5IZDiamSifcpAeaSv/I0FKDi7Qci73bZWWqE4WugV2yEcjGjvwA5qAhMu9hWCQBWJTBObug/gABCCgk8zwgISLRj3XwRlOdBJw6kUvYUJfAMY1ABk2b8m1gDdgIWD/w2GJVT5Lf6mHy3SWmpwCdVXLaRV63L67Ia9u7qWjSPWXNUwz4IE9QIXle2+dcsukswRcqAYhr4Zm0HVFIIS0YDlDUIRWuIVWUAQvEIIhqIEpkE25IqMT2Haz13Z7MHu1X3tw6HZxv4d8yId+mPu47wd22AZVGLx0tzEf8AGVCQ6DalKQlvcnrXeztfLI0/cPc0FL1jzinlKho4syB9rcwp9K2IRWCAZnQ7ZaMwSBwBUy6JLRwL2q3NfDHUZifICsNP3TMErTl8asHOqhZnQHqINN8CTk00KP4wSyhPlLGGuxnhUiPmv/7p+Xs6Uv1KW/vLncRfUpNsxVCoJDQIVb/8h9rt7C4vWFbNgGbtgGZTgFS4gERZi/hAj2YLiFx6aCImgCKDsD1jqSFmB7eph/d2B7tu/2fMAHuZf7fsiHtwcHgJg2x8MKHDkO4rDR4weThg6RQHRoxUpDLQ0pavliRUtGjh4zfgn5USRILmWkQClzEgrLllyecIEiBWWQIC1VmnFTh8+fQZIueVr1i5gxY79ktbKUqNCdPXtmeHDQwMOcOYwYzZnRYAAAAAECdO0K1uuAAAMQcB3A1evXsWHBwg2AwAGLP59QlSJFChQoTpj+Ar5UqdLfwYMpQaKEGBIkR4kQNXp86NCgP34s+7lTZ/NmOnLevHGTxkwZM2rMoP8+rcaNmjJOoJgm44RMm1vJfrESRQoVKlCfNm2iRQwaNGSqRn2apDwSJEuhggVrpcjLmjUz4VQ/E+VHjhv37tkLH/67+PLgtoHjNj5fv37gtWG7hi08OHDDgMwoeDCHjRo9fOBAhIBEIPEQgUxMlKCCE33xEUgNcvRFGF9sYcUWEoaRYYZncDHTTDJJcRJKLKkkRU01hZhTHHX4McghjVQCiizBEENMMEglZ0gfd6jRxgwaeNAAEIwActVVA6HVVlhLdqWWVwuUFaVZAhggAAECFCDAAQIEUIBaBSiwwR2WlLIKK6y4skonpXiCSSedgOKJYYdRIgljjTnSyCKLIIL/yCGFFPIHH3z44cegdsghRx120AHaG2qcloZopKGGRhplwDaaGWnw4ISirjRT3CWXlFLKJ5ZAIslfnYiCySWKRRKJY5GEckswoRDCBhtw8IoGHGicIQV3NbBgT33bbMNNNshm02w11UwTDTPTMtMMM9rc04883zlzTDHAKKPMMcMwAgQPLOBg0EH/+UAgRBE19C6CFyXI0UQOPujRFmFssUUTTfQb8BZddDHFFB7OVOKHKa10YkpovLHoH4UsIkkmp8jyC3S3oPKJJpPoeMcbcQDhAVSMXMKIJEbOUbIFULb1lVdhrYUAAmaphbNaAvCsgM8B8Hwllmc9EAcnrbji/0orpHTiJiidbNImJnNWophieOq5SCOIABroZYYeupkddtTRKKRpgJaGpaKhgQZplqYh6Wxo2LGIMNUsw4sqmHzSdyWXxNl0JptkYokliFHyyYytTKIHHIN6Bkcd2J0xRRQ51IBMNs18Owwwu3juyy6j51KLKqq8EosuvFBzDz7+5APOMsAA04u3w7xCRn7oqpuDD/+5Ky8TBSI4UUVabORR8iM1KDC//gLsPMEFI6ySwiiF+OGJUpjRxoo8HVJxJmXKglTHmlgSyR+ezWEGDzzMcIko889fLn4eeGBBAzezFbNYSUpJLQLsEgMUUJYA+GwAAhjAARhwFhr4wRGcWP+Fq9z0F+AUhmqHsVNjGuEIRyxiMoWozCAq8zU+LGpsdYgDpNyQqNC4ITRta5uk3GBDJzgBDXGIwyiqkQ1oLGMWmehbJ4DiCU9wIhNKLJzhQiGLW9xCE3rIQx4E8QeyyQGLbgDWdnQxnF3Ygha4EOMYZSHGW9CCFbZY4y56MQ179MMf/bDHMoZBDF8kwxjEkMQMZsCCFezHd7/rwYHgNTwEKW95+EKeR0TivH79y3lhmF4XzhAs7llPRCAaUU2gEIQQocENcbADH/YwCK1JwhKb8Bj6KBGJQtBBJzUBAiBUYYqryO8RLesj/vS3vwAe0GZsGeAAA3AABRTgKwVgwAH/diYBBjDTZgtYwR5Q5qo3XcIvGdSg1TjYwaW4SISVEZQdwEa2R6lBUZ5Rm6U2JZoapqEmaJBCHQAxjGZBIxmwwIReShGnI3pCiYTTxCdsdQtcCUIQjjDEOEmJKDnAwQ0Fw8UvkpGMNYqRFlC8BUVvgZRWQDEYwJAGOOJYD3AwYxi+6Cgq6mCDl54gkD74QQ8IWaACJQiR9lokSRgZIQiBJENfQFBIGiQhSgYLJ5lcCfY2aSKbpCiGOqmDU/5wCERAQlaKcMwf6iAHMgSBB4DQRS2A0IAZAOIRgNglVPIXlQc4QIELVIswl6QzsBzzAFkKAAMWgMwBLKCADDAAXadi/4E5SKKIb2oaYBrLTUnUiTGOGGGfEkGZcfKhMoPawwrfIAfPvAE1cXPnaCZVkx6goQ1zeIQymoGMYhijFpdY0ypM5YlP+KZvqJhRdBShB0PEqhEiPCGj3jAaj4KKGKdoRW8+EdBKREIRhhiUIIArCWXAUY7a4AUgdEeGHjgBpiAAwb8OMlMftIt4xVsQRe7FPKA2Eqgh0VBGhDpfpHpoqQhrCcJOBNXSBIEMqEFNDMc2qIldUQ5t6MEM5qCKWgzkAVMBQlXIoDv8RWUGPHDAAghbTCYR0wE+q9IBHqCABXjpmQYgQFsQYAGpTAVli+UEBhsLmDlRompX+1MieuynEf+W0GuF4uxnjSup0IxmtJsiTQ94gFozyGEOr0hGLZTxjGLswk286Q0o/LmJUtgqGFFMaKyYA8LJ/ImcjUpDsHpwhlvYQQMr+MAGNGBnClyAAgx4gAQ2QAMyFAMc+YhHP76BDGUAo2QgYIENVsCCE3DgB9w5iBKUcEiJsFdB7+1pI7XQLw0JFdTz5UKGOpRf0lwPYQiTNKuf8AQo0OClNWWXceFABzsguA5veB8ZTGEKMjyAzhawAJDIEAcyvA9/JWsAsxdgs5y1JZkyM4sCjqlAEyewgQrgUottZjJmkyGxi7UxuTVYNUcgYhF5kkzXAoWZPWgGUTYEjRs2pWRNvY//B0EoQxvIAAhf6AIa1UDGMXzRCU+gohXM5YuMNhYK6U7icImBRNYeE6g+MEoOD3gxA6bQChY4wAEP4LMEImByBlwAAy+Awx6QgY18yPEb19gcMOLAAkazYLwbkDRCcmBp9TpkvYv8aVHhG6F9gXpCGAI1qcNg6oQNOJOXRFgUtiPpmUqaBlqXdU0v5QY60KEPffLDHoIwAyCMwhRz0MAJcHACEKzAzjaIie4oHBVmN0ADRvAAAAW4FrEUIJl7TuAAHFBAsXjFZmflewMsQIbZvmlVjC33YCyh4w42xsd/KsSfTAjvO6jwM5OalL1RM4MmBwENKgGCKZ7hw2kgwyj+/0x4K0rVChpFRxOKQJ8lMlE1yX7wMVwjpwQ4sIELcEAPwRjDCTZAAhJgYAQd6AAHMBCDMQiCteD4Tj7soY1tRAMaxoBUGXoAhf6wOgfpIgITgrdene4UQkXvCNFDEjANSaioSU/6DN1mBksGy9SpmhREAUo8wQ8cYAGiRmmkQUrAgR30QSEkAiSoFfwAwajwQANQAAaQAAj0AFxRAAVswAc02EDgnZCslQkekFswCQAYQAIkQDKdmM/wDM/gHf4ongfQUtNADbnZ2KjQyZ3kSWRYFpABCmaQHehhUdos2YChGr+1QRsMGBkwQjP40DaESjMQQyt8QiuUT8bgXihowv8YEk4mLMYQOkafDAIfjE0LkMALgMEWnIAiBEMfoIsKoMAIoIAOdAAJxMAaDAIjLMP29UM+3IM3gAM2gEMy1AEZqMF30cBCsJqA3FTQLQhPFZ1RaWLR3d+EaMH+gWIYVMoMAaAUCOAARsEBIiABck+lpMGroUHYSSAFSkJWzMBPAIEFXMDzbUAN0BkKVB+QGIHuaIBUUEUKtkyQuMVXcNtbCM0MSptZ3OD+IEDjAcEeQB6N+aCrjIpgGMZiSFZkiFPnIeEesKFXMSGSOeGARaEZtI0ZkIEqPIsz5JP4EYMs4MUtDAV0tMIY4hZwoM/vNUYkEGGgDAoLAAwRJIQSREL/HQZIuoSBDTxaDvBBIQACdt1DPuQDPWDDN2gDN+SOE5iBE/SADaAXq/1LE1wavRSPg2xiJsKkhiBdqIEipIzigJGiJUkBF/AkFxSMwVhO1TFBpTEBAT5BaYiWq5UBHfhBITQCJTzCbGEFygAB2zVBEpxAF0gkGwAjCWwAsX0AkOjgIxBJy8wBIACCVkRJDTZjWFBJAWwJW1TjhNmMzRwWIFzQJmyjq0iCuV2NZC2CZKDZCCHhkKEjpIAGpCimO7aB9fhfG9hTLMRCPt1CK1QUx9yCjVACQfGGc3GCbySR5bmSKwUfIlTGD3RBGDQBEoQWFEQCMdyBFZiNGtAAFNTB/x8swiUww/ZpJD1cgzbIDiAAQb+R5A/YgKRVXUqqZNDNy71k4oPAZCaGYih+gU264wyhBgDqZE/65E8GZRQEnVG24qacRBrgGiI4Qp1cwi0IQy28gtp9ABGEAROwABzgAEKSAAeQwAlA2ldaAFWIAstYxZEAgQOgxQBkiZWwmF3xDFjQFQLgYA7OwSE0TY1JXmN5I9VYzRmuGyIIH2EWyh9YBmd1lqMophrEjdtYmIcIWFqKQh45widBkSaUAnOVwpb1Rqn40xERTtUcTqw4xp+wgSAQgh4IQqw8RiskgyUoQsSdyibwhiv0QjXYA3tspDTMnCqQARBYWHjxR9VV3f8PgGlOrVfyROeZSicozhf+hQSkFB2oEQxQToHTcSeYgukTOEQUkIhoxYENsYiLpOcE2QoxCIMw5AImOIIaYIEN0AEOIEEYPBoJoAAK5GefaUCDyQ8uBShWnOVT7E/gWUmD9s9YnMVZBEldOsA1PkJfcII2usm4+SCdbKgQ9litkmNPmNA50kHZfIajvBM8+hcNBJgkpAIxJEMm0AAfOIImBIMhEIIifMKNosIqUOuNlkqcJJESHQ5p8glShJQ+itkvGAM0iBnugasxJEM2ZIs/4MM3OAMzKEPLBMFr/M5Q2imYckEi6Wv9RSd06p+asmmbFhUXLB0XGEwUACWd9uT/vabiUEqaTTBgxLjQHvTEIaSnJQgFjRhrayXDKTzFG3wBDsABCMTUC4yACMSA8YHAB5gMYolCLKjCphaJWuXiAjST0GBJAigJWRTeqXrbWUJpq2LQYkUerOrl1HATYqxbh3beIACKZrHh2JANaIUGaEihhcnECmhdHFiCI6xSH/TBH+zeJBCCIExCwq0Cb6wCc22ZP9EYcBSO0jYCdNAtdNQIjSSD+NHIL2gMjSgDN9yDP/BDPXwDMyADKwABEKCGFFgaEyhnE1QdFDzBviKPIs0fvkQnddrXfH3BgK0pTx5s1c0pdz6BnbraUCrBD6CXTQiYC03sZbwIJIACKgyq/zG0VqgoAzHc0h7YABqwQA3UQAvIwAtQ6gaswPF+wArwACOYgi7EQv2wDH7oD4LKFZcIAJMEgFSghc3MQDWBAgUBxps8TdFWKGAYzvmi7+990DdJRjiB6KCEDdUmShxIoRSewaOxAA3shKEIQhX1LyEU6e6BwimsrcIpDbWegj8xHOFYHmPgnsZAsI0QRagkAzHggi/8gjAQxTYE7uB+Qx0dwgxILgIO5eNCbio+AZluRL0wD75sRL8GTJp6YkiYBMF+AXeCLhegsNO5Wg9PwUvgKRPsxyAFWBlICtosih9YbHMkHHvabjNAcRQngzAcQhskLw20wBVQgQ7sJ3+GQf8O5K+FAYIo2BIZi8JaJe4MGMEHHGgNThupnoVcoCAm3ChgbAKcEG3kYcImuComoO9fiCbiCGEaXlWfeM2gFEopLWGvRmEjgwANvF0NABcf9K8g+JaRKsLu4RZvGHCaIHCp4AUoMHDVKBzbsi1egBRHWVQq6AUssEIvWAM4CG7sOIMq4AdMEKy9lClzLkEvV0EV9HIWZIEWCPMwN0gxDzMyC3N8CUwzf9rmFlX9+RSEKAhLvgsS+FxJ+sBRoo1n7URPQEZzlIIr4IIw2K5FhUsUK0MtYEXcHR8GRAAGUMAD1IAGfIAF0MAHkKDLqkLK7JIH6A41HhDPBpMAVSMQHML/I3iCKAMHH3tCHndCq/6FNv1FhlqejlkNYPrJYI4T2ZEdie7QyNBvI7djG7iBFIQBHXhMHuiBHjxrIDyrIpRZjXayKydNmuwoAyvG4fyo1RgOJWzCbL2CHsGCKPhaLEgDPfADP3TfMzBCH+XrR9wLRQQdEvTyEvzyL2N1VnO1MFcBMlcBT3maMzfz8/RrNLswmc7L8LyLElCaTLhjDFEVoRSCn0ACHa9CORMFuobLMjDDMlgUMWACD2iALubnBWxAzuGABzCB1q4sQP8EpybusjHbs5lFXZ7FCZ7VhF7CJjB0qx6R+M5Yq5K2jRGG4eDYX4IQn+xJ03r0RxPZDu0Q/0mTNNrAQSYTgiYE8CQoAgAbQnpG6xcijSzctCvwxo7GLbp90FOeryZ8mSubQiwUgzIYgy/0wjBQg1IzNTggAxAkb1RfohUQD0VY9VVr9VafN1d/tVeHNeaONVk7M0lE8+W6VzWzZLwQAaUxAX+VQSgpClUVSiE4QiV0winAQi7sAjDAFjIkQ7jEXlGwwiHQgAXM2QewwBYw2kvZACTHmrJdxVp1V5Bodl3WJbPhTwOkapFEdCnwMScAlGi/CWnLuERjQibUePpWQiB3kLptzWUNQosUykdvhhzINm1HYb1BwQMaaUtPwkHpQd98QiRoQsJR+SooDdK0ArWGckBZgv/CPVFI1a0Gm3MxDMMxKANxOAM2lMNS58M2qAIvTW7l7hRVx0t5+zIw33lXb3Ux/7IyL/N7O3OG3J9IoGlaG899I4GAHAQT9LCrwXXciNJmmNIi3PUAj0Iq1IIvDENRxN6DF8Us6JLWsQAddEEToEHv5sAUdIEd5AcQqBUZVNNAvBizzfr+2DqG5U+DMcIoJHAp7LGMQ/SM8wWNu0m2amvvxS2HgtBGjxCIwjaJEnmRm7QcxA0cWDIetLQeKAch3J5HWQIr3YXCrW2aZHnbxkmN1EhRoCtRJEMzFIVFFcNrGUMzTMM3qMNS34M0pOU9x7lUk+m7aLV6X/XAA3Ofs3f/ViMzR8A30g06mso3WtsLnbO1Qh6EmFpdDzNM99SbTjTlU17CT3QCpvtCoRYFbHF6jZgCJviBFBgMG9TAGiTBGLDBGiRvHIDCIJhMG5QMVAxbMcLYDeI6hYlCLsxCmtixNpI2REP0HgPU2wqUtm5QOO6Jn3CNsxNKKTmFVxF5tKPGE8hBQhFCHrDBGGBf2SYU2K1BdU15KZfPAWt5qey1Rcn93Dd4g8t7g1+LOPyDP9xDouXHA+QrfNl3RAQ8V291Lx9B4u85wqv3Vyv8wguMwz88xFcu8VwzNld8q7Xaq3HPJ6WBHFDsi4QPyJPCK1xw3B8aMjSDMkzxIrhBDwxC/xOMwRUkQR6swR/VwSXIwZwNG/70UR/Vuolj2NnRki0Qwy+M0eQ1VqsqvdL/ExK9rdBC/eV9k4f+mJD9+GZB+wp5VR2cxBT07+zrwBVIUQv8ABxsARhQ0e4RVCkjzU1rOSrQfRYqQ7XUfYOjKzpfSz0UYjYwwrkAxAcHXL580XJQixWFTBg2rLIEYpWHSyRKXHIEI0WLFLNU9GgFYUGRCLWINHkSpUmSCpEwQfKyJZIcM3P8+BElSg+dPnj+eGKjx5MybuTw+VNnz6BDiyR1IpVLGDFixpIpU9asmTJoxmgdqmMjR5QpeWh8mHHokpMPIC5YeGB2hhEjMzx4aNCgbv/dGUDmzLkUVdgvXKQ6YTKMyVImw5wYc+rUCdRjUJMjT/b0GHPjTYcrWaJECRIkR4tIL0KE6FChQX8K+dnDh88e2bLjyHnjBgoPNJoUjdHhYsgYMIr0CMIzZkyePIQEKQrVqpUsV9Onr7IOLRnW7NWwNjNmNVnV7M2qPuN2L589ZWSCrLBgoWBCkAitMFyIxKLHiBYzQoR4JKIsBOxIovlK+iIMlQpKMKUGDzJopfoYQoKImGiqyaacgNJpJxZosMGHIMwgqo3a/DikEUkoceUWXKIK76qsukvGFlAO4WEFNFj4YAVHKplhhRM42EADFlgokgceZqDLg7324guQR0j/ASywUjw5zJLEDmuMssgwe8wTyzDzpDFONjMsk0o+E62RNhdJ5LTUCmnNjtdmk62OOuKIow433IBjLEWGGMILNtgIJQ8dCsWDCkKUm0STUlZxRZZKYaFOKqmE2dQWwW755ZZWfvlFFVOKGSYWXrRhxx57VJnDjjOM4GEkCBdqyKGK9iPQv141qmJAYA8S8KQwjA2jJGMbXFClkFRSCNqGYFLiBwxxisKmJ7S1ySdtn4BixDfo2MOPPwZZxBFJKvGkFFc6FcYYY5CpCqtnoCGvEzLq8ECDDwrZQwMHHnBggQY+qGEDt+hiEgggniQDEElmGTUXWlxJhTDEELNkMce+//x4TDA/PhNL0EJzBOVGSDsktUFc/uMPP2CDDc865JAjTzekOIMNQfQoDo9Cb8CgiDHwwCOQn/tQxBJQVoGuFYsrtRJMTNbNJBFIGinkj0MYYUSUWJBZxhpwvrFnGkb2kOMMJ1goKUIJcWUCQI3+07XX/oAdsCMBJcrCwWUFdzAh+aR9iVprceL2Bx90apwnH5wQyowR+dzD3EMcoSQTT1BxBZdfNqUqxqyYUWYXTILQYAZKAKZBgwYc+MAGFpoAYYUkG+6r4d4B6cTFXGyZjhRQNssyyy1B7vIxUooP87JOLuOEs848Aw1lrd2Ec845YfYDfPD3QKrmOtCQAlE9kP/D4+cxSijiuJ8hVUQRTT75BJVWKKVUFjgTiSQS9FNEHsbQBzq0YQ6AuAQvnEENbTywHKwCxhz80AYoGIEFWSCJfOTmEoYYAUAbCeFGLqK3vRFoI1UYyQZrJThnQShuHYQJETDELZxEznE98METlKAEHE4OCuCSgx2M4jIUQcISnnMFLEJHjKooYxnLQIYykmGMX1zid3vwAB9s8BbbxWANH3hCHebQMED0BY1zYAQsfOGLWbAiFae4jGGQV4nDHOZjk8HMKEYBsj6OzBObsEQlKhEa0aDMESpjGWrmtJqYDYIPSHFNnvi0szyw4Wh4CEUwCHE03jRnEpOIxCcm0Qr/VNwPFbKAjiz+QD9CKIIQhJhEH+5Qh0OIghfLyIY2vtENbPgyHd/IhiTmIAczBIEHONggtDqYK//oSj+++hWwolkFhWzwQfE50IGedU36rGRuE4KJtTIkBZ7o0Ac+gQITvOUEd05ucmZ4wxD/QC6lbC6JnCAFK3IBjGJMEaBVTAYyhmEMU5BhDzP4AA5wYIMaTGEFbiAjIy5xCUacERBnxMQvKsaKVZCij4YhJPLuiMcveakTfFSpSj92GDJtYhNp+ozJUEYaRDQCTixTDWtcc6fx1cEOdhAEIfSQBz08B5Y+U+okFMHUUdpPE6CAmiuIE4hJMMcQiZAELIoBDW7Y/wM93dBGOOAxDnOwgxvDmEMc1ECGJBkhhjJkiN8e4hG8ReSZd4UmE67pTb9C60Ex3KaBEtKQW+Gqh3N7Qg4YmoO5RcFb3oKCT6QghTKkgQ6X80Mh0EWJFGFiFKywhS+iQroqIgMZp7PFJdrgBC3siAU2sIFs5vCKYZhCFJeQxCPmsIdUCMMWr4jjY0Q6U0JeoqSG+dJKu9RcPWLiEpWQRCMoYZjdPkJdapIEm9y0skO8bBBcg1nMyMUHO2jiqj5TTnMUIYhQ+mwSodBEdCYRDFloQhOpbMXPBIGaR7wCGdXgBjjAmg9//EMf7RgHPMihDnBkgxFY+MIxZ8ADG3CBPv/RwlVLmPA3Xh2BhNLc1TM7QhG+RmshGrYPSP7qrIMQtq/MnE84G6KEHChBWwy5Fk68lc5vQUEoaSCDGdogB8ydSymPQO4oXmGL0pLOKs+QsjJyAQk14IAFFYYYIBhRC12IQhSmMMUl1PgKN7LiFKTgDGhmSolKILekH2Npc4lL3OhKAs+YYIzVCNlnNbGJTaVJTdcQ0b1BlOsPREwqG5iznFhqIhSvvCohPhGKSXwiGKjIEv5aAYg9MMJU0yAwWNGTj36cmh7oecc83gEOZGABWE5QUpKe8OJmcpjD0/xP3UTcK4no7SJLaMl9OBzO+tyKxTKOsa1BgivAsjPHDFH/AhMSyxBtRaEJU9D2tXLQA8YFkQdBENHlAFGHjDJCySl9BVSmYpVl2Ote5MGFJ/4g6z08AmyoAnNuGeGXWdgCFqzImJpMFprPqAvOJl0eZUoxmYY7tzKR2TOf+0yJ7eJZazYttE67BzN79mENr3xlHmAZwJLf4r5NDaUmIpHfU5ZCFceYxjZaVY9+yAMf8fDHqU99D5/Tgx724IYoQJiFJFWYB9riwhPCiWuGhPjXIyyhf/qz6xJiZNguqRBMuM5XxWqB6U+wgtjFroUTy1AJSEi7tdnpE2n3cCY2njYXsN2EJmDrJtdqXBTETYMkBaEMCKyDGeZgbq8pmRSpoIXo/0gHDcfHOzzGYAWXwayKWMRi3xZ9BChyMQtYpCIylXiEIUnPZkLeEWSYce4pSvFwynSi9aDwxOzJJFI/E9Li2itNoefUsvAWog+DuGRzPqEJQRy/OaGQRSlvIV+mNhXSsijFJ1rlc/T43B/Z9wc+1BGPd/i8VdnYRjPm8E4ynN+dZIACGZ4ATyccgQlLiP8TsIAFikw92Hm9SIj34ytritM+GqIJmKAJ6oMLpIALgEwBv4UBgezanmAKuGAKnkAKmAAKlg7HrE3pqK2HnoBxbGKybqKyKgsKpCCIgsgELesMzqANWvByyIVlFuER3gy0VoEWSCte6KU7yKOKdmHMLP8q8zxtEUqhRWhhFUqhMHSr9K6HEhIDpsIEpsoEMjghTEBhFJwnza6QMsjEeDYBFDhBMfhMe0LDuxaBZVjG0/IkT+QgDmQm0eAADF5gDG4hGILB+NrLEIIhGSJBltCrfu6HlO5nEvoBH94hHnBOH/RhH3YOH+6hHvIh1ewBHLjhGZpBFYDg/NRPQMyPDN7JE5eg/kIRxB6C1+wqhSbibqjOP1yC6zjMCuwOFqPAAk/QAX+MFp9gcWoiCnZmBCPrB5jgF2XxB6jFAxmHAnHCBGkxGYOoDEqwDFbwDMqAyIgCKZRiKUavutiFFXCBtKbiiZbhdKzCKo6BF3ArzEZBEiL/ZhVU6QiTEM9Gz5Aioc2yJBM2gXowwR6r8Atp7wqdpx+fh/a2cDIMQ5CMq5AyrjQE7btco1xkhg/oIA8cIAbq6xboJ5QIAb+YIxQsjb14I5QmoRDeoR3gAR7W4RzGYRz2oR/uARxachLtYRu24Rl4IRbIABMdcOnajxM78Z1AMRSxYBR9zW7u6v7wDyOOQC6OYIa2rtgI0O6iwIc80Qkk5510EherRRd5sbIga1vSyQf0bhenIO+mQCykQNuScQRHsAzWUi3XsnLMQA3UIA7uAHy6hmVSBLn2iRVgYReGoRigTBytghmkqBiAARjOjBTSrDCg6xEUaSnaxJBU5Lgw/2ExKfNLApIUWs95NpMzZW+OIKPhHi6QMMETsqTgFkFl2iQREkE1VOMQ9mCe4OA9kgBSLu34msoQ4isS4iuUFCGAmMoR7KAd1IEkxyEcwmEc2sEdXHIbomFsgAEZgOHLliSIIosJpBL9jMCdIOIn+Q+v8sZXjrKE5II8X4IIzpMpzRMWmYAIeOKdfkgqmWDHdnEreWxbxnLbxAIntI0/w1IKoqAE09Ky1rIM1PItzWDI4lKzZAMQUBMSLqEwOuEU1s2fjOEYUEsco4gZsIIZiMEXUkEUiscdM24QAGEpHIH0VKSikutLGGP2QOF5NtMzLwOknIe4lOsxOEG6MiESPP8jEhzhu0xDNAZh8PQFENqADOKgB8zgAUCAOCQtqQjBEHYzqfDrIwOID9BAHd5BHuThHcRBrLiBG7JBGpChF2ohFio0XgABSKCg7nJMKuNUmkjxV/pPxI4SKTFCLhiKT/uUT9GToWjoxuLUCbQzTntoPm/iA3uinK6FJ8RN3HgCW6ylAQ+QC8ogDMygDM7vstLAUzOxckpET+JgDwBBKZgCuzBBFE6BFWrBn47hQlELtaIItXpBFXIrpHTrEUijEb6rEK6xEeAxu5CropDrS/KR9qAwTO6RMi0Tzy7hEQ7hZNrkEEy0NerADyCBEhBhNfyADcdnT85oDuTkDf4gGD7/AZZiyb2YijcEiDf9kBDOBx/qoR3YgR2+gRti8hmKgRdqoRZ2wReyIjxwIQg+4ANwwu4ii1DfCU8zIk9NERXzBinJkzz91GIDlQj6NO4o9p3kQip9oIdsCBnx7gc4pHFuwk0pUIcg1XF2CCunTQOfgAtmdsIO1FM9df3IYFOHDEGJTJKUwkSxC0JN4RVS5VUvFIqWQRn0DboqartU5jTgBDXu8hFQBrvczI6KtVmb1h7NpGsnjljx7REeodzmQA2KNP0ahgw2aynUhTRBARVcDxRKYWJwARfq8Fzz4L2Qj6n6wH6YQw9Ujjdj5Qx4aRKzwRqcARyVoRj+kiqSAfIG/8EDLOBgr0UDF1Y7GxZA+iOE7IZz9XRPL/ZP0fM8RRcHiIBDUjd1z6kHesh1oe0/bSKHdsLbnKBxniCdbNdkvRJyqlL9dNYM0qAFh3d4gwAK1jITkSnciIxU/aC3TBTdIHQUTCEWesEvMZSKfIEVMOG6dvW7xqsP/MAaWYYRzhBdICG73qxY1zfO3BHPLorL8Gy6FqESYsoLSwEVVmEW/i0XcgEXaCF0RGdTBBheMqUONcEQBMFQ8oB9mGojiSEY3GuomoMQWmESzicK8nUaGHcY/NIvczA8QvgXWmEFNEADLIBkcaxxFnY7QfGZ7u8IcMAI8gaE9PQoQ9d0c1i2+v9UdXs4dW8MZoEx7xS1h2e3B9zJcWRLh3ogCEIkRJwACtLv/ConDQhUGonMgoIIUsUtSf6ODErki+Ogt64RQvdptNotGYghFzoBEmSwWtdGDcxg6bhACcyALvegt2YDetFNfrUWM/ZNpRLvFV5BFVSBFVghFkbLbn8BgEeFgKOig4chMBxZGIKhkkelkoMBgkFFE/pAEPIADHagBa4AD5qqOfTwqoiDOPogDwClsraig4FBXqriXu4ljXFBlUoBEUzQcYrxB5wAUlnYCSS2P4xAhoMNdDe3YnP4dDO2mfnUBv4UB95O2m4sB3Js2phOCUDE22zgB2yABlbASGhgBmj/oCxAwGBXAJ0/wITZWQP4JS/eOS88wGA/gJ6XpMLMWZ89hAaMRJ1xR53t2Sz0eQVyR8vMgE+C9hJGQRUIGR0BwWHqogEswAFM2AIa4IQL5gOUZC/6gsu+RsmQC8wYumhjYZD9FaX99fK8TBdauqVtAeAGGaZROhZ0IRYKahh8gaP8FxduAeVcoRWmj0frZxC6QDnWC2jGQA8cRRFuYRLyAPkm2A7c4AykYFPgBUYcjzuMgRhQYRNW0zPqIJ3AmXG2WJipDiPodGLROiknFoeNmZmhuaGkWe3kjiZc13XvGgda1tuSuAf8zu94ILZqx0hiq7DH2UNwp5yBpJzNOUnI/1mf95kFxNmET/iE3cIBMvsB3OIBBsYB3sMC6mIFOjp+LwHMGAEI6sKeKbougIBPJkcN3sDcGAG0xKyQi9ZfdSG3dRtNY4GmL+/yLK+QgZu4i5sXeKEXeMGf/Ck6gUEwjOEWiLQQEqEO/gAOzBJQtA0MxsC9LgkPmAOTAiEUBCE5lnq9ji8P6ICqocAbscKWragV0NUQFMFvP8ERziCdkoRDtviIWVhzrw7AL4JiB5xP4dpiS9dPa0e2ojmaceBCbowDcYzp2IkhfgDIKqsMjrgZ1zINzOAJuqALtK0L0KALuGUmeqAG+DoH+tlDxrmL/W6yC9pgT1hgOpui7wLH7/8CARCgAXbcx2VHLxJIyUShVMAspU4ByYm2yQDYbkOnjdqoF840pXm7uKu8yo9buQ0TGGA1VjWUGqbBGq7BGrIhG5whOn0hF0aFDnKgC3IADAxFD67gBpBjB3aADQKBDfQgEIZAfegnaSZBD/BgORSBDY6aleHgfIKAXsKDGHx6+XbzlYpqEgwBDWqgcfwudcVNJ4RZc224FK9uYkHXwC1WLswTwRmqwU+XoeCOJubamvt02nwAyMpAW463ww/0P8PyDKLAB3KAJ2pAn3uABU4ABIhkLXiEX3hkBQyWXyz6hO9isy2gsul5tHnACb6YfA4h3U4hFV6hFmwBYNvoMLX/vI12oaV5QRfM/clb2svQHcvfHcujXMsbF1aR4UKjCBzBnMxjMiYfiBse6IGwAeDH9Bqk4VSEIc1bIQpaoAXG4ArGQAVgwAu8wDe8YAe8oJSRwwsIiNFCgdCNioDYx2eUppWrWtGT4RdcARUoYTfRFb+GKmkGaNvAmQb2m783vWPdqdPRGq8atoZ/XoYHvIa3jnQz1gYytkJQHZyBIolr3geWvgdqp5+BAgp0op/xWb/DebQLuqDfubLf47Ip+gH6RQM8m3JH+0kQaA+WgmUkoYxPwQZpgRZyQacx2RdiuYNPJcp7QcuBYRgMU94BP7mzfLmXuxjq/RjwPRqigRqw/0HgDbdV7IEeCCxf81X8BizyJdEd8PUbOt8bAP6BroFM+VWSg6EVpqAFOgAG2EAHjmYMCEURqGDiMf44xoANjEbk2QcPlEqpSI4QDMgN0KAMguAWPiESECER5rs58EvP2ac4wMAmaqAGVHeLg4BDOtZjNXdvpg7E0PqGa1g857QpX4IJApWhkKChakeczTnG/bme0zmdd4Sd3QK035miM7vHZQfHxz4veOCLSwQgBi1qJOkSplKrZNHC9cuXsIfEjEU0JpFixGIYM2IEpnEjL2AgQxbjeKzkMWTIljGLJk0aNWzctHEDZ8/evZv5+uXM2W9fP38/g/azSe+bUW3avv/ZxJkv3z179Oi1QyfuqLZt1pB9JPZrlZsbLTJkGBNjjB4dQ2QMWcuWCh48eooQ0sOmrqA8eeAqUiRIkCJCfejAQVMGyl5Ciib1RawYjNlJhPLsSPKjRg4aM3po7uHjxw8fm51oNkK69JHTR6qoXnJkyRIjrl2jnt2ade3YR0gj2Y2ECI7fwFmwsCHcxooPyD1osPBBg3MLDx5YcADdQXTrDRo48OBhBg8yZsjM2VMH0KKCmC6BYgXrFi5fvx5CJCZsGLH79ykayyixo8aSGZl00kkpMcPMMtFEQw0111yTzTYz0XPTPU05VWE/GGaoYVBA+eMPP/78E+KIQDlFDzv/RnnzTVMYeqjTTfW8805U9oCzTTbKADMMfKvUQcMUHHQQgQ4uxIACCjfssMMYVAxBRRFm6TGGC1fMlYcgeuCBF1yTTKKHIH30YccbZUhhGCF9/aUYIZHlwcZeV7Bxww0+1ECcDT6AlqdnQfTghBN99mCEE0bgYAQRRvjghA9HMJHbEVi8dhtqsk2amxG5/SbcbzYQx8IKoCLn3KgeQGfBqBqUmuoMrPYQRBpyvPHHIZBUQoknCS30S3zC3NerMclENNFE/mk0zDAa6chRgBiZlJJKLE1jzYPccFPTUjf1pGGFOXn4IYgdesjPuPz8Y66IHoqo7rnsngtUP/Wwgw6K/96wmK4/FmKIz001gdMMSL3eYkkZOZBAwcFXeJEECRx8SYIXZrGRJZZjCNJmKKHo4aYgk8AVGZh20JGGGVIEMYkimpyMMcehQJYYXydscAILIByHHAggIPeBzaDybPMHG+j8AXfOiYpqqqOeupwFTE/ngHUOZCf11A1MJ50FHnwww59t7CFQrZh04gkpqbBHy0LuvberL/A1xDbbuuSyy9xz+6LL3bXUwosuvejCy9+AfyRSSSgts4wzCS7oIFLVguM4jU9BZVM9lFP+jj767KMPPvhkzjnmmJMLrrekl/5PuaiP2+65/OgTjzjYxC47O/1kvk887tDjTjndaIONNv81bVNML/bRgghdLbSwg/JjsJGHHntpokcwk0iMhyJ66JHwXXkEI4vGXwoCF5aE/GGHHG6cIcUUJ3eJ8sl7xY9mHiycsELOOR93Qs47H8fdzjPwnwY24Bzu/C85BlROqhJIqgMOrTs8cAJ44lCHOvhhIGDbxCZAAYpVJOQWs1gILnJBQrnR7W662AUKV7jCvPmNF3kL3N96AZJiEO5Z0HKJNWQnk5mA4xvsyF1UJOQOIQ6RHpSbkBKXeA98aK51oePHPEAHunK1a0TqwqLoRLc6c41rH+/wHTausSBt1OND/wCjVMLBxm5gwx7cKIl9cgGIGsDATUWIARvAwAZB3EL/EXlQhMRukYxJRAkuzdNSHzWWBzb5ZS4WK4Qd6pC+JjQBfl3SxGEQwxhCjIEFNMBMKHv2qZ4FsGehMqDOVJm1FbDKO0YAjxnaMAc/HOIQj5BEQToxClKQzWxns0UuRIiLYpIwmLXIRd5ycTe67aJvsYimNGuhi1jI8G8hIUlJDHc4BVnjGrFLilHAIS8ZvQMe8UinPOTBuXm4cx7xsJw5Y/QOdnJunZjj3Oc2h4917jNzVNyHQAXqD4K2bov62KJCVddFdo3LdW4ko+ze8aF9/EMf74jHPMbBxm+AQxkYMcYvAAECEgwBD1cYQxF2kFI8CGIMfFxSFyaRsbfoYS4o/80eHiSGF+hJ76blO18lf9CllsVPfoLAWB6m0AMeOPWpPGBVKGkA1R4AwapBMEMcKLgHQBxiIJIIGyhKcQoProIVxMyFL97jCxPSLW/UZOEKe0FXFPKCrnQFHF1DgiwbEshwzECcS8DJQ5kYRRyIFUc5FluOdLRDHeowh2TNoY5zrOOdmM2sO9MZD3zqY53ymEfnMKc5KpJ2c6JNLRRNy9qELnS1puViQ1lHLnWIo3dI6cY7uBjaeYSjd9hgRjGA9QtHfKAGMXiBDnRwhSvoYUlQ2gEYpvs8MFypkViyKSFcipcrseyRIEOf+ppACJryxS9/uakiQqEJQTTBDGWIw/8e5jAHQHgVrJbYIChQ0QpZ+Nc9bduVfISxqwK7zRfHAsbbfLELX+AVryh8cC8EV0O/Eo6bK2EJNaa1DQg1jiY1QWI9jojEfZn4HvJQR0Y56851rOMcMLYsPMhB4xrT+Bw3vqyL5WFOGSWRcvJoYhNbG7rYPtS1VDzyuPZJ0IIO9MlJJjJqcUzj3/auG91Q7DzIZS59kCMc6cDGMk6SDGFEAgQbuMGRXjAELwyhZc0lBBuo4Bby8UVLgTiMxQjRMo2Rz0to+gMf6hCH9ElBCpzkmCYVEYhAsEkTc9HELSYdjPjQBz+YzrR+JEIMjTzkWKAO9TCAsVe+HsvCyFAGYAX/y6Bs9BAc9KAJiJmIEwpRiFvdKp2HnmzRLicUc1OErT7e6WLMkguzLl6HPpd9YmZX8dcHhfZrp80PXFeociOekYyS7eIYM/Yc5UDsOdhI7sV2oxyQXQeX/zEPdZRDG8wAxjGUQQxI4IAEEcgACnSQghgsdwzVy0Mo8jCEmwZCYqHAEhvw0OjrYQ/SfXFe9rJnCEET2g0ki8IY3oIHxASCLs/zgsjZMAlh4cciE9m0RVRuQwsD6IY4DKw0pkFzmldjWta6ls6VaKFb6+TnGerQTz5E9IXOtou6riiIlo7G2Rb9Q1EUneb2gVB9PJ0fmquo7d6lk6YskXJRQQc6vEF2/29g+exX1kaWE4tYLIsdsW8vRzwgq450pMMd7GiHY+URD2j7Qx/16IY0xqwMZZCCBjbAQAQgkAEVwOWkY/jLGGTghbp0abo75XggtKQJSKNJ4XihgyAM0QeLF1p9GpcYG0Sel0A0zwt01sEYPhGM/HS6WMU4+cmN0YxnPGPmN6cWiK+lRJ0Tn0UbahHXNRQucY1o6apD3emmf/Qsoivp2A8R0pP+WiT7Pfnbugc92UF+cZAdy2VHihjRjv5ulJ3sYmfH2tlejnaUwxviQEc62JGOd7RDRvuHd0XhDuKHDwWFIU4BDtlQDdWQDclwCDSwARHAABEwBCKAFm7hSWshJf9DMAZj4AVXUARQYlMaMz9s4kh34RejJwiCJgenJwVRwCV4MATPw2h44AWBQGcgOAV8EAmoQAvE0AzQoBLOYCDI8Ax9xWn5AQ0QAiHX4kOOA0S5gw/t4A72oA0MwiDgFA4aNWzu5FpYR2tLlA/4og/5sA/3sA9OJlAiUlqcA2Wg0zlnOIdqeGTPJlBUdC4D5S0DlTniskXc5yFepzt45w1jZ3bo5w1q934qYhSOCERSAQ/wEFnmkA7m0GPtkInmlDvucHfpgESgOCO5M09RkTtPUUSFeA/gwA3ZYA3TwAzIYAudcAg/cAIYUAEicIMpsBYi1yTN4yQfmGfcBRd4gDH/H/c8aMIminFThmAIiCBodCBeZuIWHRMIhqQHwBgIsEcFOnACOdAEdFAHtrCKHeY42PAgz4AMGEEfwrAfxfAMHgZijwhE6HA5+BAP+FAPWEhGC4IN5uBOq0V1qmNtBOkUtAZQtrOHpFNa+nAP4PctgJh9T5YhzJaP9/QOi4V/VJF/VIFlv4MUH+l+ilh2QCQO6aB/6FAO84KKRRRE9DAO40BZkJVRPWZO7UAPAQiKQ0ROViE7/LggQCkNCcIS12AN1DANz6AMwxALpnAJiyAHJ0ACGDABbCYDVGCVVAAx3AgXUhIIrZAYC0cFeiBp2PM8X/IX8zMIjuAIg9AHfBCN/4YGBRv3FieDB8tllV4AAzrQJM6VBF/QBuMIDtYQIUhhIzgyDL1yH8PQC8cgDdXyDblDdo4oDuxwOaK1D/SADUBZRu7wDgbILRiihmJokEpUD5rDOUpEkfmwL/eAfVYniEGXdBuCayOGd/JiduonO7q5mx+pftqgkezHfyk5nOUQDjE5WZQliZJYk5jYmTJSRCdZDj0ZO5u5IEI5lNiJnYgTDc7QndFQc82ADMDAlJ3QCZaQCF3ABjrQASigApR3l2NAcF5gUx+3ehKTJRPTF+j1F5sXSIaQCIlQCGIiGHE5nx9IBY0Ge0LAJHjJBmNwBTEQBnVADDdSEt5AD0nBDf/VkAzNwI4NARKM6ZhGQQ+NCETs4GKf5RPooJmbqQ1I1JoZ0hQKuYandQ8NeRMApU/ykEQFuGy8xofeAn5edxP08A7k934gKUa66ZtJyqROqn7n1nZYxjuIxVjlAJNYCpOU9Q7qkIl2d5K+yZsNsplC6RLW2RItkZ1q6p0J0p0GwgzTEJ5LOQqXUBCPgAiN0AdwQAgY8AImYJV3yQaBoALbqAN6QGfB2DEgVxcOlyWrV4yTEKB/4JYEqj5SADFuJjGTcFKyR2czCDEpoAJg4AfNACEJog1BpA3ZgAy58Au0YAsC9gvPxAvHkA0x8UOOGETvcFlWdw++85PYUA6g4y7/6XJRoiNloPN3SAaHT7Zrp8k5KiYjMzl2WPakSfo7Zpet5ndbJep+4faliwV36PAN0imd+mcOxylZlDhZMPlbT/qT1nmmaDqU89oS1XmdaJqm3LmdasoS3ekMz1CEyoAMw6ALrzAKmCAJnSAJkIAIgsACHDACJZACMpACJbBcECMDakGDH4iDyJgHiTQGiPElDrpweaBJAFoIfMAHdgAHa3AG6mMWOCh7bfapQuAWVPCgOhADTbAHymAt3IANP3QNGuoLoNAIe1AJwVBpvmALzwQMyGANUWgU5YSi4yIPsQOs7YBG6+ZF1AYufbiGmuNPMjIViaV2aocNbhQ7V6a2/7llrUxadlJ6dnYnL9/QDd+gWJXoWHYndvOyf+OqklZWrUrKomeqptfZryyRr4ibr2nqEvPaps7AuG0aDb/ne82gDHLUC7AgCpLACIPAsI2ACIDEMCUgAqgrAilwJOwZqiqgjW6mJTKwcCe1cHqhCFfgJhVDCJHgCM+4si27BmgAs9CjA3apA9uYlUIgA/+GAhxAAkTQBrmwDTUCDupnI9DwCXTABwSxCbtiC7bgYL2wDLZKrvqnDpe1ZeOiDmPUogZoRQ71UNSXRlPXkJUjI7d5fh5ZWE36tlfGfuyHWEYxrt/wfmvHWGL3pX6bwMV5diCpmz+ZuIqbnY6rrwlSwf8VTA36+riRyxKS+68gHML/ygwgBQx8EwuiIAqX8AiLMAilkAmagAqfkAcXwAYm0AG4iAIiwAEc4ALtqQMoMATIqwMwQHkx4AUpwAa3YEjEOJde8CWOEKAqy7IuO7xn4AUu0AFowYtdcoM6OAQSMAEcgAN2IAnFUA0dlsbV0AyF5CZ24Ah+YAmuOkIIVgzKACHfoH/wwKsPZQ7UKVErMnQLiYebw3dGiojAtZv9+7bqR3bawHZsl2XhRn+L5bd5bLfz+IhMmrX8aKb9aiATjJ0YXKajjMGifMH0mrgiLMLN0MoGYjgDixKbWwuqYAqmUMu9NArlyQm4MGm3QAgnwAH/KJABIpABJaDDJTACI6ADyjwCL5ACV2mVMjACMCA+hKAJzaMIN+iBG9e7kgq8cOAGVqwDItBmsCfEHweqMRADKvACDqpHieAJtsChQggNxtDLHZMXn9AKjVAKS9uOxYAS8AgOnQmGINIP+XgT73BryIfQ+VibRRR/5McOHDmPPzTR5HcikEliUXF3LPml72A5lEOA93BEP/RDMfHAqlqURhmU9qrBZlqdWsjS1vBNDcLSN33TNW3TOZ0NPu3TN92KN+cgrbjT07LTDDgNDFgN0NDUz9DKhYcMFFEMo4Y30fQKWK0KqVDLWp0KZWMLrgALthBCvTxpihDMHdABxFwB/yYAzXoAA2k9BC9AqEPwpxJzlWPgaEPgXALXsVRwJYoQCYXwB4J2PnDwBiNjBjHQJCc1BDEgxCrABjGQi3iQAq/XgYpgCZEQDNDQjsKwCqUww2+BMq0QCT64tBORas6wDeAgrAclIvlwRI5VhbTdiZ0YRC1ZREMUROQHFTQSazTi26V4REJU3EakOyjyDbkJrxLcuKS8uDVXyjG9mTVdlDS90z/ditld1Et9c0jd3UlNc9Lge87QDCSMDABC1X1TTdGkCu5dy6YwCrY8315dNqzg1R7ECqtwC6sAC7PAHrDgCr0cCU3AARhAziXQASIgAyIAexqrwwWnjTIAA0IgxP95rQeBUAQ0KJ8iqyWC0LuD7Qcs64LiDF95oAPK9YtBjBbIqwl58AIjEAN46ReWgAqTVmCRgD3XU16BMQmFYAnB0I7GIMvMgA3ooA6ulUbxAkRmd+ROrg5HXraZ2A78p4naVqS2PYrDrXO/jatGkdLtC9MaHMptmmEi7MGIs8pDuZ0WLA1LXXM254pHCefgXefgPQ1O3QzLENXHQNWkpkJwFQuv8N7wTd+mkAqncAq+tOiJ3uj4bVaQHuCzAAusoN+ucAufcAYsQAI3UAJUkLoM7qAosIsVcODIe6gVu1xZaRZ4oFJiOQR1wQa8awiFUAh+MElyECsjUwZjwGbGi43/HxgDb9FmVwADaSEDNsUxnwAK/uU9fuEFKMMGdCB6hkAHf/ALE3EMY3YM0fAN76C+/yAPE02t4hAO5V4OlWgOV9pY/+cO6NCJCdy3eKfJYTqmQbmmgbWmZL7mbvqmI+zvq8zm5A2w3el7vjdzBj9zNNfUTh2w5l14A9vnCZZXulAL0jToqvAK91029Z3flf7xlZ7oZoXop0BW9e3Vp/DokO5BAh7gq4AKL+8IljAJc/LW+TZnItABL/CBKDAGKdABMuCeIofsDIoW3IwWIncFfMS7iIAIgyDiuI4+aIAGIGuXbVZwY7AWO+tvO6WxdOExiREKn6AY4rNxLyVpfXEy/4LwCcLAoc8SDdjQYlgXD2LnpbPNt1PB7tE5rrkJwfK65vvKr9w5+P2q5v86wQE/wv/6DIEVwgELwq3cDOX9phi25xG/ESC6N9Ik6ISe8Vhd6e6dCpRe6atQ365w+qh/+qmw8qzf6GSFCrAP+6x/VpV+Nqe/Cq3QCpTwAScwBY4hAx0wAY2XFj78AqMOxPs24RqrAnlABXWBvM3zgSHoBUVwBX1g2onwjFBfB3IQzmmABilwBVRwxF6wl0JMs/x2qOVfeY2WGPPT6ovtZ4IQDKFQJQNXAzQgCdCAxg+iDejQEwCxbx8+et8MfitXTtvChdiwXaMWkVo0is6YXWTmzP8iRowaPW7kGPLiR40ZM37MWNFZNI8mPz5zBpNkM5ohly1TlhPZzmLFhgHrxUtoLKJEVR1FmjSpKaamUj19ekrqqVSoVqFCVcqq1VVdr3JdNbXUqa5TpWrFirWrK7VdWb2lBctVq7mIplzYcKHFiBEuSlQYkQEG3xcuOoxAkSGDCRlCZDzW4YUNnjFsJo+5cmXIlTWKJilKdOjPHz526siB4yZNGhgurnjREYPKCypDvODR82IEDNkwqEzSNGlSqzwohugwMWKMojyhJrEZM8bLlRg1gsypVW1btmzWIkKkKFL8zWXMyJ8Xn758x5IlQ7pPz37kxmYib5q/qRPZsZ7//YH9DIqXWopCqigDX1EqQaZSkYoUB0kZ5UFQRpnwwVFG6eRCUk5xMMJRPCGlFFJACXGstLI6pRRQSkHrRKi8WoWVWWhhC5VEPniAhAkwwKADDGDQoYMxKhByCBRKQCEFHWAowQUVUpBhCBmiW04PQvAQBI/J2Egij0gocSSRQgYhzQ7T4IBjtStgKGIMymzTRA82FIlukjF00GEIPYLLAw8qYhhiBBOoMAGPSfSQUzrpSrjhj0xW8cWYZIbhD5hj9uMv02M25fTSnT4lTxn0MFovvvHWKzXV+0Kqr7z6LsJJmU/58wkYW3nRJdcBa+FVqF5+DUpXA4d95RUDE1zK/ykGH+xwRFBA6SRaaTvBZFpro/XkWU+27SRbZh9k8USsnoJxLVhWaUWTMy6gIIIMIqggAgxeGAJKKlB47AUY6nVBhxQ6SIEKKnQY4wU8A5lkStwIoRMMQSahJBIxC/GjtNNSQ8MML4aA4YpEvQhESz10yEMT2IpAlBDo/PRCET3wwOM2NuiIDubbrsjDklZuEcYYn43ZdKechpb106JlJVoZZmhiutSLmtFIppiihukZq62WBpqsr34GGq69rinWonsaZphfc9V111h25XVtXXPtxWxbbUW7Fl3svptXvffmuxZbaoEFlmJjKbbwt1iB5S2vUmElKqgef2pByCE3S/+qtqRai0ZXaJFFFlhoueWWSn5IYsgI3I3XBQ4m4KADL7x4oQM8dWjS3zz18AKGkEeQATrfrmAjD+HYMMQSMBMhk4/STKMjTTSK0KGIGCiLeYg7Y4iuTS9iAAM6zGCjAmY2wqdijEiuoMILE1SQIYY+PnEFF2GSSeZnY3ZKpmhk6Bc6af/z95+o1sM0pj2jGVajydUI2Ayi8aRWAUJb3gg3uGEVZW9r05st8nY3XfTiPz8Byi7yhre09Y1tvApcCmFRFMMdTnFdScUqGDRDqlBlck9BRQxj6ArKTYUrU4nRuTq3ls5VQgo1aIEM3pWBCUTgBa0DWAdEIIMSwCAFMHj/AZJScCcdUEEPHMOD9e4VGTZcaUuK0EQkwpS85dWheapJQRE2U4SN1fEFbCBOEfQYPDDcIAlDoKMOGqOCIVgvCYSwjQlCMKgbFGIsuPgFMYxBjP705FLJ+FQmNfkpTO4vgJ8c2k5+RgxiCMOUvkClCP+mtwkOi5W8msUsVBjLVwRuRrTA5SxqQQtbaLCXtthFMHfxwZ/4QpgRzFUvaWFCXq0ScMUSHAtf4cK3QEUqDKrcVB5nwxrGMCzZBCfmViGLVZQCXai4RSRocIIWSKAD7lKMCAo2hHv9awQlwKciFFGCERCMCmwg2BisJ8gocawDoVAEZ4SXxkQggo2loQNq/9zQhiKkwAVsGkIMNhaZUAiiYEti2A3GkITXjQFKMtCDIjYDnfEpUQjBs4RVciEMSRqjksWwX07v5zNN8u9ToyylKcuGSmOmzRa0iGUsbSlLFcJClwMqHDSdKrhaGsuqhIuFLnXJS1wqs6u5yMUuwmpMYQzDJ77oRa5EiExl8qpufvOl32oxTWNJk5qNS4UpKsciFqXIRFgxp1n6ytexhBOIrrjKV1oRCRawoAUkeGcE8CCDCUxgBB3YlwhE4AUZdOAwLriTX6JjmyG4IEqBYAM9fUO7PLDBYZrQBCQaSqY+lCmicnCDG67gAujx5gUxGMEV9TAGFOBJEYHIzCTAAP+oF6hACEJA1GQQlT4xhI8N70MFK2zhi56VtWymNCUpxSvUspV3bsAo6t6Umri7vkVwbyncUte7VKcm9Za4zGVS+ebM/fYSbWP9BVFRSYzyls1WZgPWWt8awV8iVam1hGoLXYhNywE2XIQlbDgxXNhTpOWaMZSFVkrxCVQgggUUIEELLuDZFLDBC+/iQAlScE8RsKEEGOCdX2Y8gsL0K09DeEHIHiMDKghCB67tjCYsAYlGOPQPtV2eHHDrBhKENgUZ9SfK8ICClwWCECnLjJS88FwvwFYRWcKDPvFAiDw4gi6u2G4ki4nKX9QZrGC1xQrXZlekPK6aXiGLDGVIFRj/sYKuh6slVaNaX1lW1b72/SUzm/lLXeyCqL8QBnfBawxhVBoYZCtwMY/pVrT9UpmNfkWEi3U4GVL4LBuGdYb9mqIUhahEfeWQ5a7SihGXAhEf4AAJoDcBwATinSrIQAdWJyi+TAAFI8BACQDVry3Ta0pV9AIVZOAnLUUHDAu1RCSaPIg+8OHJFpuyDvAQGz0ITxFe8PEVCEYI30wGDC1Y0giEwL4xBEMTYBAYyPQQCk2sARGt4GUufIHpVObCFrjIZX6ZeteulIJcXRGXi1o9Q47X0IZ4hRx8DXfoqL5Cllo96i6PamoNWlrT4KUpKX22C7P6rD9mNTBaFZwrh/cS/6wQD5wrEPdeVpflLA160KtjzeFcM4hFtsYwKszylWchQgMWiPEElO3ZHnUgD4VJAT6JlAIRIAYFKOhADGJwASMNIXhsoI0MdKCHW3zxTpV5mCYiFhpym7vcdpjyG1CgmTPjoRWTiEx0oIQyzgqsNoI0gQmeG74ioA83qW33FaYQijpj2pTBzAUuRB+6XKqQFa5AvVfoUq7EigvjtQ7RUzjMrKaY4kJNuSHjSl4sWAIOcJ/rqs+F6QtgwDy8pRwG/XLCn580v5i9CGalFWxqsNIi0defpgsHrc2kT2VDuTYsVVjRFFIwpdYtEtcnStGHBzjgAe5qYrseQIELuKDMof/wggpg0IEMiEAFftINHbijF3gdepGOMDoOKlApKiiCjlmDktE7iSmEQiCNcisN3HqDNwCyFxiDf9IDbUMBNpiEwUgfPQgEKnCB9JGBQUkfKti3KCEEQagN6xkCFbgBMNCEYJA5ThOGzguGOoM4/OKqznGFzpEF1HMFuUC9oDvCVUBC1HuzJ1RCuXAv00uhWRgcSeOvvuGgCAqmX3K5Xxk+XzArmkAGocAVVZgrokCQo0AQVlCFyKk9priQUai9OsRDUdBDPZwWUegEP7SWPRwFPcxDUTAKpGicO7sFSIgDOTiDM5iCFlAxCZCX/mOiyqqsCqgADPCCPCgBz1IMsgv/BOLyFxcoriVBgdgpASCzqBKQgZPinil4n3BzBDLxgz3YAws0EznIQBVADLcrQULKvxSIGRUIH4ORAWP8wDwwqReQAd7RhFBILT9RAcZAATD4BB0kpc77hR+EJNETQlwyQiJMwhRCQnMUurd4wnUUOtRzoaaiL2ORtHm0GxLSoGSyhbASpl1wKw+KFGiAhmbghV4goQpiw91DkDm8wz1kSIa8hEvYw4eESFGYyIY8CqLQhU87hpuIBml4hmqAhmGQJGJ4hBWwAAmQAAoINnahAMUogUCQARHIgAqYySHYsgnwosvqkf47jBQ4u8syEoBBARgQgchIgRfIABR4HZgB/wM6SAQlc4RGWASK8YM6qJgoy8AS8D9tG4JAUAQR8A1nHIISYIMrQAGN4hgYyINC4qy4G4NQwJ1QgJn06acW2IFE0MZfyMdfwIVcCDBwDEchnEIjZMfCNMz2qsIrRCqncjBeYrnHZDm48jk8azlhgj4RcjllqIbNRIa5QaYIeiVWOgqmQIqFjMiIlMiKNIWLFApLQYbyiAZqsAbuyIZt4AZ6uIfcZAduyIbO9JlM+AAN2AAKkIBgawEXcIELUIz/oyL+6wCtm7EeGQIO4AAMoEl4kzEUIBLE6IBVzJNU5IB+CjuyS6kkgANN+ITgiEpE8INBsIOr5IPTyMAR0D88gf8tI5mMmKQn2JEe2EkBFaAXNogB6CCy27gBObkN3JlBMKCBP7iFYLgFvoSkX1A40QtC0LmFo4qlzpELwizCIwy6djy9Eb2rRauloXu0FJ0RuTI1XfilXHDRFpW+faTRYPKFWtiFUvIZDVIG+kEwYAFS0JSgY1GFWFAKA/EVjdyJm3AGaZiG2dyObdgGbeCGg0AHdCiHb9CGb2CHdvAHf4gHhViGT0sGVOCBDzgBDpCAC6jOC7gADFixDqiACVhBmdTETaysHrkn/nPJe4IB7TyMeikBQZqiDkiS1uA/L/AoO7CETxAOR0AEh/KD96wY5pnPfemiUdQBF3iBFzg7ynj/AUIIBYcZAyMbAkVYNzRzuzHgrdfADRMsrjEghCMLhQi10IXzBQvFhdDh1aPiHCIcRyNsqqqiJrco0US7QqZ6tFzaJVLDx5b7TLWKPn20tC80pvq5BEYwBUwYBVboBIarBSANkABBQzT0ICVFBqVhho68hmzghncFh3i1h3ml19y8B3ugB3egB3bQV3p4h3doh3ZIh3JAhy59B3n4Un14B2yIhqVJBjlYARYAg3aBlwq4AJnMgBG4ARPgv9NJASaKAGJLNkPFAAqoABGogLHsAAKkIg4omFV0RtzwMRGQIre7gvcJjkiQwEIwk9FQHjugAzp4A9NCTjyhDFPEIt9Q/8tgkIUB9Rh6uYLKe44vooISaAEviA7cCQQ9oFkFrDwiaARZ+IVb6MuZ+rldvQVZCJ3R85xg7RzOcQVZMrTAyb6iixEXWrRkVdZYCsdeIqEYrczPPKZ9FLCiMoZhqIVIMYZfeAtgAhZbqSRPKY8mtYZrsM14xVx7sNfNzYd76Nx8AN186Id++NLRNd3QxQfRBd0rTYd0YIdy6AZtSAdtcIiGVQZgAIU3YAEOuIAIeACt86wdUDF38awKYIMRcJcSqCwRQIEdwYDWiScv4CcBTJ/W6CdXxA1PNA6ifCIUEIRI+IRP8IRGcIRIQIQy8Vk+uAOgpQO/2CxW/bLCIBg8wP+eW0iGT4iBqIWBLGmT6BFVOnrFMRguQriCOxGUKNG2F2hQdJpQXAA9C+VVcAwctw3REF1C7fMKkYuv66OvvoVMtMGFyRSrnduFyzRXce0gY4A+UIuFXtjIZXAGargGbKBScNDczcXh3Pxczw3dHu4H1TXdIP5h0L1XcPgGb2AIh3gIiJAI2ZQGj2QGY4CFSziEQsiB+YsXBuDJy6pOTZRJL+CL/IsArlO26ow2JvJJDJC7bhsuNQ6EQPA/P8Ei+tQBhwEOVMCFU1iEcRsEv+ODPVjfoJ2ixxgDGCCyJakyReCoSYjaAk6zdZMePJAFk7kTlAoGPYhaRPKsxxAYjT3/ATooBbK1M7EKPbTFL7eVhbiQQrlgL8SkJrrivb4xta+S0Wi1ZSCF3KARFY/4SGY4GmewBm7AVx3u4dA93R9GZtPdh9HtXByuB3qAZnb4hthliGp2CNrE5mxoV2y2hmrIBpBUBl8ghUUYhDpIAzrYAEpkAC3uPxHgAJPFABeQyQnA2LLbkbLjgOMyOzqtl894tiubBC9AAYSRgTz4MilRYy/4NuBYhYAUhT2mQHO7xTug6IiyoiuCgYy+IoOJDR3YLRcQhCsgxpGBjbMkhEPBjcdIqRvYgTw4sx3wDbnbqCsAAzjgvKCqsx70vM7L1YW7hXKyChZJhVKww1MwBQi5/z2FPGrxqyY/Q8jCMUiiGBA0hNxiuJT76Ehq0IZuEAeC7Vd6nVd6kNcbBl0hJmJiJuLOrQfNrYd3aF1xoOYkpmElXuIZvoZrqFy8toa95muJ4OvN3MxpmIZnWAZj2AVWwIRC2INBmNQaUE54UYxNxADf5T8TaCIRmID+Y8st4wBCGIMD3jIXCC5FoILwVEoq4IsaLKQuUqIxyIMUEB432wZwQIZLGARAkIM06IM+oGjmkYPWgIzVHoMYMBg9eoEUSAHOApJDLq4RyN8xmATPzraCaYHKowy5o6LXyR022IE1aIUf5Gme9oWzRVsYiaG3QOoIsb1CxMOkJs0EqSBz/f80q35N2JQGGa5hzKUHsL6HetAHfZCH/8aHejjr/obmeb0Hf20HdFjwK20Ih3hwupZwJdYGbb7rvd7mC8fwbAbsbKZNwAZsr1EGw04FUtgE9oTUP5iCdJ7Td9qRPOXTmbREmp2EQIgdH5GifvICHDuMESAS6NjEoaQCX9QBOs42MEgCQ5iEPziFbACHbQAGRgCE03iy3j4NOcCTjRKkjoEB2IiBEvit4zYYNnAMIdC2VTyO8ZEOLCqkHdiBhGot5LwNMSCy8nmYCB3bb6SFngs9Xkrb1JOhpka69i7EhhSF1SzSWuCF+b7qZaAIaqDhLeVSduBXaKaHeiBmfND0Td//9HzAV0uXZiSm3Qm/a4i4a4codb7WcL/u64iYBmnAa9mMCL6m9W7uZhDH9VwH8WkISGUohhs9ak8Ak0/IhEyAAxIggRLoP+uEFx1QgQjwDSaiWcC4shmDAQwggRSwTkGJthubAB3AsePOAAEku2e8KBTQthhIAkWwBD7ohGp4V2gYhT2ogzeo8vUFvDo4jo3pVNMCJATs8k0VJBPsgP8rHyrI6PGRkinxsjzYASt5eNjorGScvDEogpLZmQi2UKRCqlQ+wnLEoFhAdFV47/cmitak71120srlDindUn51h9Z1h3eY+Zn3V0uP+YSgdHbohp73+QgvdVMX+qDHa6Jv/2KJeFLvoIYndlLBZnrBhnonfeKOhPpqcPpngHpeB8itNyAG0h+bMhtdiIU8axwWWZFWWKwTcNMISAE9eF4MmICTjoApWt45FQw9kNNPjLH+U3ZiC5+twwAV8BfPktPK4CK2XI52fwRl+OZqMIZHqIM4qPI2qoMOrA25y5NsSynsUakukg4XFBh6yig2kJPH8MqtBagxGLKAKR8zL9A4mgRBIARN2Bm1DR3UM8Lbdyq90YWBXHSrbvT7hlJ5Het6/WoDLwjMfdd3RXVUhwimv++jl/5ZV3UNr/Wg7+tUr/Wjf/VqoIasd9KtB0gFaoZY2QlaARCxnyCStz1CvBBRwP9DVviKcEGFVrCEG2CXkFUBPWjeFmefEgCICBUqTCA4IQOVDgoxYOgwQaEIFBjGKBoho0MFGJPydMigA8aIFFQIEXoh40qeSZT4AALWDBo0ZbD21Bn0hw8fO3bq1PHyUQcVKkNexBhCBc8QHWy8DPFCxYsMIWO8qMAzKakXPTK8EMKjo0gKpWzYyHgqI88QEzLWsnl65cYUQrJu3ZrbSpasVqhQycL1y9ewY82qZeNm7/A9e4nvMW7s2LHie+nKeeumTRs2bNSscabmmVq0aNI2U5NmWtq0aahVo0a92Rq1aZ9lv+Zs+zZua9mu3fbMe7Y0Z8+cMVu2TBkyZMeKDQP/1ouXrlqxYqkyZV0U9uzYMXHHdIl7J/CiOnXyZN7TqvSoSpVarykPCRIcRmDsUALjwAkmYFTIkGGCQBVEUFAEDg3YwQgVjDAEfSiMMIIOMpSQVQkiIFjCfHkQwkEHKLAxiSWDxEGKMMmYKMwje9jkR0471THEUDI0NYYOQ6iQQlZNGTXEWmPoEdQQeISCx1h5fKXHGGPEMAZaeughBBV62AijDjrEECEMOqCwAxuKKDJJIobkwcYadtABRyS/EGPMMcpUA05kj0F2GD3ggHMZNpfpmdk1fV6TGWd++mlbn7B99llntqVWjWy9HdooZ9X0lhql0DzDTHHHJXfMcs7x//JpdNOpMuqo1plqinbZdTLKKOFx9513l8gqKybk2codKKfoulcpjnxAAoJTRcDAQ0MNlAFBHWWA3wTNHtRsgRj8l8ELQ6DQQZUluFBBCSZ0lMIID8nwwhjztZCSJY2Q0cgqahojTCqHrNhiHXLoEUhbTemBxwsdxKAHIUwltdZRXpA7Bht44KGHCjKk4EIRXijihSah6DHJk1JRIcMYDfOogkkywODFFWyAQaaUY11xxRR8YJKMMsosM00232CWGTaCHnpoooIKets12Qg9NNFFFxqo0JFWs7SkS1P69DTROEMcpsZtWgxzzfXyHC+1eC3ddGHH8gqpZZdq6iimsP+6tq3mkdcd3LXGjckmnHCnKyigsNcIDSeMsKwJyELwN0YHidBfBSJkUGBBAwlYAbYG+SeCVxlwkEGFIlzUQQQyKCLDgzCMgUEJLQiiUiRvvGHJKn4Jc4skgwzCYk50yBGIIkhVWcQVCCo1I1RUZJkU7yVf8QIML6Dwgg4vsBFKHnoIYpVXSHqxsBdOBUUFRW1xT+S+XiScJBt8ZGIMzMpg6kxwzkQDNfypeRb/aztbM41tTkua/9LWMP1/pYZDHOPELDnKwVoxOJXA5RQDGA504DCa45ytUXBr0NEFBqPztbG94hWs+CArUpEKU5CCFKy61atmpcJLSIISsnKFLFz/IUNXzGIWucAFLvDiiA08gAOH+48IfkiQAQEoPxPAAEEcd0SHKARyHdnKshqmuAyowFsmQMEN8HADHZQgBXpoAQd2IAhKkLEQHzADJVqBi2AEoxSF+MMf/GAHmsgBD2PgEQyypKXsiS97QsmejMZQBOldQRFX0IEIYISHJIyBELxThCDuhYeJRUkPXhCCxp6Sh01W0gs+YoMYQqkw8/3CGMYwoHFSuYz1CecZrnzlM6AhjVhSilHx+x8AUwNLqhHQgArEmgQjKExgSNCBCDzGARtYzAg+sIK7eGYGM2iLr8HiFdXsIAhHaIpTlJCbJ7SVq8BDHk+QxxWoWIUrVgGL//TgIhewkEUkLPCAh0zuPx0ZELKWZcRm0WcgSIxIRyagg0AsSwYq+I9aTBACE1SRCiagwg5a0AIddMAFMkABB5qACDJawhFGmMEeLNEKuqDiEH44KU3qcAekCAV5VhLSGBQ2Bu4JBQZB2hfGLsaGpJjESqG4BRv0ANQSzPQjQsgeJqkgBBXUyAuBwJeXFoYvPDhlX3IohS8QeErkxKyrMlMlppohVljCpKxmtdSlilPA5CBQmMV8IFyHCUG30pU5Wj0lMJkJV1/4ohfP9MUzd5ELWxA2F4Od5ixgoVhWzFCGrFjFY9Mj2b1Qdj2lKOHaQEGK9qyiFXo5Z+vo0ggQUP+AAkgsyH8mIIJ+NgtyGGjWPTuAgWhdFFkoEIEKvHC4DpigIIoLXFRU8CQq3AcFFbptBzjQhUhYgoyUkMMKeOAHSqDCFa1YhB/2kN167WGmRW1KEfIQ065QYSxmSdgV9KCJK8BAD0NCgQqyZBVN6AEGeNjYC5wihK1E6b5AGkkgfKSHPCiswAoj8CBKQQvAYO2UyfEqhJGTnGQYsMKmzFozK7g1Xexia33lK1yJSVe6znWYbjXGmkyZjFMao63NKSZf//rMXOyCsLY4LC0UW00dzzCEjZ2hZNWDilOUglWk0FUJSZGeVqyCsp/Q4QosQIEIILEjBx2ICoYw29Yeq5//SCyQCIg7EJFkwEJl/o8KRBCCi6hACBkIXAo6hFHjuoADJFhDJJxLiUKQYQVO8AMk9vYH7dKxDmUxylQE+ZXs6SimP5qKDhDmhRR8SUIlkBEimerUMaBgDD2NihACgRSjiE8RbIgpkbJCpFXvqw/V/YUwiCHrC/8SmBSEzgbFNp1XfK3XXiPsX2PMV74KQxglJmaJR5y1YTS4GMhwMDIoPAxiJKfFy3YgX2kc2FzowsbU5KAHQfhYEeqq3CKsLGV1lQp1i5DcpdDLJ1DxCU2gAhEasAAHGjKgCmBAKIurEUaWZaHDVYAD9xkBlQtOAX5PoASQy0AKgliCMiPOBAr1/w+CGtIB5ZVgB2P4AyWYS0ZE+GEGH3DCHhpRiUXEcQ8ur5eTysuGIlRJB4ekqR+dIjChDAEkIYGvDD4Co56TJSjjUoGPoCQEGHFsLJ68noH1wIY8TI8NkcDLLdppWMOCjTqlOpspShVCEbKig2Y3+3RqYeO1B3vYfO3FA+UadxMLE2ucunuLWWzKFpM4xoI1rLe9NotaYFMVqVAFK8B+qsVz87KYXbwqzP7BW0ACjmiYQg5ysAEJPCACnpftQEyAhxhUIAbO4nLiMBCShhyRIbJNgUQ6YKE4e0EMIgjcQSYeuGWBfkEjEEF4FdHcTDT3EIeIg8md0IZCmDS7L5fDJP8CUTIqxAAFOrCjUaJUFt1t7/qeRgEMUpCCF2xMqTK471pAZ9CyCEUFKsC5+ALxo+gt7MAJI5IgQoEXV7BCsbMgm9lE3uKZSru1G2SJm7h1ECz4mi1wWGD5lYZRUIhNYNwBk10xhzI8gzLolXM4BzRh0I3ZAi3U0DVV0wcVoOJZx6h0UNrVAtwxGzIZBzM8wzQQxtJAQzMQAxk4gAUsgAMwAOdJQAQ8QOdFgA6YwOE4BX0UxGs50Qj0iws4RLIgCApMwAiwwQhoXMBtRUccixVOUX+olgwYHAcUEiVYAhpSwiAcQiHEAQ/wgBPUBEq53B3UAVW9wPE0T0w1xfMEggz/5AtQGEUg3EJFGEWEbIUOQIkOpEDDUEGVNIwJ3AtTOKIOXI+PBALULcyAOYnCCEIkCUImtEI1jUrYrODXQZ51FGCQIWC4md01xYKveU00ZdCGSSDcUWDcIRszuUkzOBDXzCIG9VrYmB2psOB06MILJhAyKINYQcPSZMM2RCM3TCM3bMM0RmM2MA0O/oIkxMEHOIAEMMACPMBsMYDnMcADxMBCxIAKOAQSDcRqiQAjcoALHBEHzEe/IAgHIEVIOIXDVYAMUJEKHEuZKUtBJJdsccAYgIieyc4fNMIetEEcxMHszKFK6QCS1EgMBMIkLIWQhMIQIIzw5JFBfcgdZV+N/wDFfi3VUUyCUg0BG+iAImAiHgQCUOBB9EhdwkgdJ8qfgF1MHtjBJcRCdPACMX0KUt5iBfmiLqCKKAxgAbbbB0We2UlHr0VTBGblBEUgssFdt+3CS0xDcyAlqJAlUgKD3cUg+9Sg0FijndjJNV4jNgpN/9gSpWQjozxDMyCDL8BCJzgCFGwABaBjBbwAB3SeQzTOQGKACLje4ySIQhTEg0Thg4gPfXDAw/SjFxzcaqlF4phABXhLCYTAslwPh7hAHkRCJEBCJDiCazbCIhhfIdjEirhcShEJG8BADFBBIIjXU9yXUoyBQTWFUDSPV5xfwrwfVa2FEEgSlCRFpPmRTv8SwsXc0cKIV/3dC4E5CZPEwR6owgJtyt2NZwOhJQIBAy94nSqMDVW6YgfVwgJukDDCYjACIwaZ5adUUFI6UH4aAzHhFTIc0zIug/vUoDVYIzVyw1tW4zYkjf+khjRIjfucRvykhm4QTTXgYDL4AglhAiTwgQYIIbEISEOQAAZcgEI8iLcoRGSKACI1EYmOAAdUgMJgAIeEC/ihQH9kwAiUQGvJnkP5RxWVQBayAVBxwA2M0WqupmsmgmyuSG2+XB0UQfHEAFU8RUvtyBiMQMMARY3gTpAkjKhNRfnVJCYqFaPBCFMQQiswCapdj5O0RcJoQjAoAiFuEnMxQiz0QgL/LYNyjCcDIZCgnmfXwWKvTZMtsKDaEZYuGCoGbdij0mIvZBB0VGp+3iJaGlDMHIMpSEKjioIqHAM0Jmg1Ds2hmIaEYsr6YIrUqOrUiMZpoGo0VENprMai4KAyGIMvqIIoYMIjOIId5EA4PoCARADJTNkFvONqMQTkgObtAYh/YAAFsGgHQJJpZSF9sAEK8B60qkC4KAiPYs4UpQAHFAEGkEASCB8lsGZrOkJszuaKxJFF1oEgDJIiRBqMOCIMyIhRmERSXFpVRYkmBKL4rKQYiBoeQImMtIX27IsmSsyQBJWTeJJ7hUIotMIkfMkk+AEgxAIvLNAxUCB+ImUtZFDJ/87i2tlYNHUYMlIq1/CCBEKQ3S2jzEyNNEjKqDLoNkzDMcAic+gCLyBDNqhGaBSt0Uro1CStADWDqjZt006NK5nGomQoLIlVrgrDLrxCq7THJ0RCCwyL5w1hB5DABUzZPyEI7qkevyURfTQEto6tfTzIfSCIfySO4pRAFeWWCfyNPnXAEAhCCpzACbTAGoAIJBxuuzYCIrBhvJ6U87kcGCTBJGiCIgmFdW4P95gAH1lPeykCoiUJ9W0FIQSFlepc7TkFHmgabybDLSiMk7wuwOhBH7xBKBBDK+TBG8zBep6lrvVu2FATLNDC2tEYjTUgNJHl1jzQzKaS+2zGNUTjW/+Cg4LCJTXO5TZcAzVcQzU4g3JE20s8g6wWbdJOjdOGlVidb/kybdNqyp9iWI1d0yqUWynoDSq0QilMAQUQIQOYo+c9xBQ2ZgekWRI1zu8hC0DqgQ4wxAVcwHxgQPJAzhCkgI3Cngi8wJsJJxvsrUUE3STEQAu8QAv0QXNBwrpCgiPA5uLOZhzB0Ry6XAxcAZGQ2iQySVIYXb4qQldMwhhcwUzBQH/RSCUGApZKHVU9hRgIRVDgCyHcQsDE1FgozKmNAR3QwRJ35BrMgSiYpdh4Ddl40CuwZ+RxUAtKKjFhzYAKxzMi6PS+5WEcxoLqyc3kjM9k76DU4A3asYVeQ4T/iu/49vEMNoNX+RIwoWfXgM3ZrM03rcp5mAcnPFkr5EBpRcDiKEDnmRYHeB7r8VtD5AfDyV5BTNkdzS0JlABFcQiHEFe2CjH1Wci/MMjIbEwJsIEmEK4jaEIlkNHhuusipHC8yqttdtcOI4VPoC4ehAWW5muUcGROMYVTJMxSIIz3FAxVYdIlLcm+5I5HOuzUiZozj4keiAGR7MFQeqwDlWzXGePvbs3M1uzNEkbORm/0Vi82ZIOeNGjREI093/M9B43/LI00JIqhxOor8RJyMJDW7EKoqOfZIF67WccpWEeSvQ042QooeAIq0MEGXAC0CsgE7O8EeKtAcM47Fg7i/wzEPWWhbLkADJAABaTAJFDUg6jegxSECqDAWiQIBljcQlKBCAjSEgtCF0wC8R2uCevyu/Zyy9kmHoAB79SIURCJWYSk0ZXXVGgCxijCHR0FVTWzlAydVPNRbsHITIYCJsbf+HCkw66aJoLBIOjpp6Dlp1DHU75CdHQYnzYDNMIz9apxg8qxn/j1X+MJb1hDn7SlPkNjNObzPTONNYhGaYTGAPnpL/EnWTYqBwVgKoSQqYxdu6FCu+lKq6wKOF0CeVyCHGT0lkEA/5qjOSoOEf3TaRXEszTOtCoEB6CAg3QAezUEBjiIjG5rgbAofaioDqTZDuxAH7QCHXTBGVoCUQ6f8CLsMuPCEXU/7h4EBAAh+QQAZAAAACwAAAAAQAEAAYfqwKLhtpnfsZLZr5Taq4zWqovUqYrQqY3VpILQpIXOo4TMooXLnoDGoYfFnYHHm3zBm3/Hl3TDlnXCl3fBlHLAlXW/knC9lXe9km+9kW+9j226lHi6kHC1lHu1kHW6j266jmq0jnO9i2a5jGq4jGq3jGq3jGa2iWe1i2y1iWW0h2WxjHKyi2yxiG2yiWayh2SxhmSxhWKxhGOxhWCuinCtiG6tiGmuhWqthWStg2usg2iug2GqiG2qhmqqhWmqhGmqg2WmhW2ng2iwgV6tgV+sgmqsgWGrgmyrgWurgWmrgWOqgmiqgGqqgGiqgGSogWmogWengGapf2mpf2epf2anf2eogmSogGOnf2OsfVmyeEapfVqofmiofmaofmWofFmmfmWnfWWnfWKme1ukgWmkgGWkgGOjfWWjfWOjgGGjfmGifWCifGCkemKhemCkelqgelyheF2jd1WhdVOffGKfel+bfGeeeV2aeGCddl2ddlmadluWdl+bc1qaclidclGXc1qXclaTclucbkqXblGVb1WVa06SbleSblORbVGRalCRZ0mObFOOalCNaU+KaVOMZk+LZkqHZk+OYkOJY0iIY0mGY0qGYUeCYU2EYEmDYEWHXUSCXUSAXUaAXUKCWj9+WkGDUzJ5XEd5V0B3VT93UzxzUjx2UjdxUTxtUT5zTzdzTDFvTTZtTTltSzNqTDhqSTRnSzhjSjlpSDFqRCplRjNlRi9lQitiRTNiRC9hQS1hPyheQzFdQC1dPilaQS9ZPSpUPi5eOSBYOCNWOCNUOSZUNR9QOChQNiFPMh9OLhlIMyNGLh1ILBlBKxxBKBdAJBI5JRU0IxQ2HQ0wHQ4tHQ8sGQsoGw8mGAwlFwooEwUiEwYdEwcdEAUhDgIaDgQcCQESDQURCwMMCwIOCgIKCgEPCQEMCQEKCQEICAAGCAAPBgAKBgEIBwEIBQAGBwAGBgAGBQAEBgAQAgALAgAIAwAIAAAFAwAFAQAFAAACAwACAQAAAQADAAABAAAAAAAI/wDFvLmiZMcHAhO2xNjhYssXIl/mbCHiYsybNzDEzFHih9AYi1tmpEihQsVIEh9GkACR4oWJlypKlJgxI0YJK7SIEUs2DZw2aDqLARs2y8qOLVtk7CBCBGTTj2+QEtmxlMgWGDiy4lDCFYYLGDBU7BgzccaQIUSG0MyyJUsWkSZm7IgRVsWLFypgpDgx8oTfkTJHaNAwAoSGlyZeDNmiZ9SsXcSeIeuVK5cuXbgy46pVKxdnzp5jxepcOZctVaBAjSpVilQpVapYoep05hAsWK9qMYP2zFlvZsyWHTsWrDgvWbJSiZIV7dgjPoJ4zZv37Vu3btyyZdvGfbt279/DY/8bT368tfPZzp+vlu1atm7csS97ZOdMDhQXOISAAKGDhx51LLLIJ8poAw443mij3jTTnDeGGFxtgYMCBsRglUIwEDGHHFsYYYQSOLiAghh66PHGImLEMYYKJ5QAmEwrpaDXCzO8kAIIJIwwk1wlsADKMDtBo8000CBTjFDDCAOHCzEolddRDx3VIVI7wGAhUztshQNYOBghBlg7GCHDFnP8scVZaKk1Q0RyfKFWSXbBeZeNfOF1Agkk+FUYCBhYAIIJf/45hBx//HEKLb4Y00wywFh2WS688OLZZ6BVVmkuuFTGiimlnAKbp6qYIttsprhy2yuZIacqcqm02qoosML/mgomfARhhyDLTFcdN7xqx902340XXjbCEnvNNeQdq96y1rB3zTbXQWudM6IEEcQSLFARggce8OfBCnoYckkmtUzjDTjWaEPNNNSo95EYD16BwQAPLDUGVWT+IUcMMbjgoRgfjvGHIX8Q5JddKeSoEggumpDCEFnEAMIIKo3kAgYeFOILMcoYA0stRxpZjC7GKIIDVUaoYKFUVWEJJlVyabmVQHK84aERKDNF0840DvrFDCaYlEIJfhW9V0kvwPDCCRQHRgKgfyI28QxbyLFIKbsIkww0yRBz2ddflyb22KXpkgssrrCittqlorKp27G9AksqpMQqyiN456133oI8/2KtHYBXAw51vPa6XXfEkqfdeMeOV83jxx5bDbPqVTMetNdxA1+CuNjBQw+B6HGFDSts4MAGNNBRyCWaiEJMuu1Ss2401Igh0BhK4KxAAS9MxNREUX3xBu5c4cCCGFe8YQgOKLRYQo4aZJDBYCXY6LBLOB78ggsfbCDELsYo04wxqQBTjJHE5GLMKDhMtMMJdFG1JVVU4QUDzPxu78L+WCkhA/8yCKAMakQTvLSEakRIQdBoYhcD9kVpJRlajojmIgVODASBOswLdjAgYRiDGM0gBjDARkKzOYpslflaLWYxC1ekDRWlYgUsUNEKV5gCN69QjigwgYkd4k0QguCDEP+FCLgiduBvj/iGrgqXHV91pzyJi5wUqzHFZk3OilR0z3UyBx/uaMMZmAjCIQIRiDXYoAUb6I8HhAAIR1SiE6joRYPYZY11ecgiH5HDBwZQgTcowSJ/uEiHjJAUGBiBCCH6yh9w8DzDaACD0dPAB0pgksKMQAU1ecHzTFCCCWxgBa4whqKagYxkIMNIyPDFMHaRBuQZYXsngGAD7RKDksTgLDOwEgwCuAMZeOUEXwnLCVQwQJ6NRCQleckIrudAxCjwJc8cQV/44kg/gcACGiSCIU4hjFuMAhXAIEYvSNiLcZbwnF+zBWdws6kbyk1uaJsFbkzBQ7zxEBOPCCIRi8j/z7/ZIRXrAMc6eoW4wwGrPMminEKX9bgsbsM6muvGgbrxDWBVgxeYQAQiCKGHJXhgP/4JQRkKoQhIHEIUzKCj7JAih5ZexAgUMuRWxtCQOYzBQ1eRqQtwwAEczGEljrzgBySJIzyRoARBY9HEFDiBC2zAEhxrxjO6hgxilHKVyggEEGz3vljKUmhzgoFZaOKVYJZ1f/sriQymYswFjoQkyxTJMxFD15ZYD2FItaQ1Hxm0LUxiFcbQBB9sUYxe+OKwhy2nOdH5tXI+ijPyfAUNI3ubVtwGN6N4xCEO0bcf8oGfoAXcEQF3jOnYIzu/Cg+wElceZVGuobCdHGyP9VDs/1D0QOCoTnW2MY1XMCIQftgDGlbggQ40YAMhWEEbCiHER+ACGuehBlnmMLybGqECCLnj8IxgCEL4LkNgiUGfMGCID2SATxjAgCPVSwKSJKy9LCoBCD4AqAo4FRBaEx/6iHE+YuxCGZ7wgRWU4AI84cUkRRtmDHKZNLlUCSwuOEHzApjWktxPl3hxUS2ZxiKVvZUkdxmJXXZmkjiRpMSEARRiiLAIWghDGK6whQiBgVhfKNaxjaWMLm6sWEltRp6taMUsOGMLec5Cbq3ARBCB6Nki2gq0tupAB2gQBGfMYx3zSO2wiMVabETuigp9HDViO2ZrYOM9tr3OdA4kjup0Y/8e3kAGJvZwhzuwwQMb6JYDIHCBFizBDYAQBCaQ0SA5EEEOZOHQG1yggASwAAYXMcQcCDEHI+hrC1GJAQUkQIJ6beG86FXvJWuU4JGYQJpDs9EEKoC6WYiPlCHrry+UMYsy/CBEMlHaXQ6Wl5rYksFg+WUsveqCvCiFCOGli4hLQgJd8+WtNLIRjWpkak4ibQZCg6bDWvKFT8xCGMqAxjSQAQwa81ixlzl3Ym/MC7Ot07K2yFSRbxFZUzACcEIEYhDtYK0gkIEM1vq3taRMA0FcY3D0EE+xEJrFa8A2zLKDbZl95Y3rQJQe61iHOcTBcSzPAxzTMAUf7lCHG7BgA2n/bMCeIRACMACCEY9IxTOY8rsxtHQMKEgAB/SwCCPooVCFGsQW/vCFF2TAAhRAOgj+0KJAsSQxDFZBnl5AsTy9VQUZKAEOrHAKaDQDKKcMuwiVoQw69MAGH7CABGZAhJ3Vcmdm2UFNdrlLhqCgeSfw5VdkYIQvhAQGDglJDL4wCDm0hAi1vLpJntciksh3BEUDi42eHrQUxOAFMTDUf6Eh7kUVg7/lFkrojzR60Ze73L0ARjkzlQt4fuaysLgMLPDQ7yAMkQ94yH3u92lEKWPCQFg2aLBYu6zwWOM72ki+8pfVrvMk/1y41W2aK44dN3tjGrXgwxrMYIUy7McBBxiA/1Nb4IZDPEISmPgdUoQnB4lM4AFXgJARCGGI9r/AKliXAAUw8AEMkMDQOPJ0GJQC2FYSRKMCFAN5cKICH0ACOAAElPBqYSd2xGAMz8AIZ1cCasd2VNF2cOd2SgMWSgEDfuECVQJMI+gCU7FguWQSEIF4EXEVe/FsLYInkLc0R+V4K5En0vQn9oNJ20QL4fN1pnQkomd6p5eEqMdukRIpulALr9AKtZAZK1QLt+ELutAKtBcENLAC/vZv/xZa/CRlHZAK23Au87BlXYYNlRMeyZceypd8zCc77fJ85+IN0Icd3PAr8WEd8JF8zYAJdBAFZVAGNHABDtAAE+BJHpADgP9wCJJgFV9QM2/QUhtSAgqAAjgAIZXIFPdTAhqAdIORARRAATAwB/P1AQEIEyJGNHpyPVsCAx9wAkcRCIoiGROIDKKEDNBACmfnApvmYEshdx8IQTO4SxG2PzLQIigQTMUWQCySYB2GFDJASTNYgyoxdQlDMfHFMO8FAjUYEyfwB6vgYuIDDR+khKrHhE3IC5rxjrjAC1MIhVH4jpSChahQKzxAXLX3hQL3j6I1ZcGQDeeyDltmHmyoHnS4kLLDIOyyLtMgDdIQDRQZDdLAIOuyHtZwhuDwHduQfNwBDpiTDck3DbggCGRAB2UgBN2yLRDwSTSABoXwJFPRgUzhAg//8ABbkTtLYSEmoHYWYAF9EpQUQAKDAAMkwIAk4BItIWKl1hInkyWTRDVpQAvNQEq5eErJ8Ay+QAYsUAKlyIJu94EHtoDMiFYwYBFGAGH3swPR2GHDVBcddo05wjDtZSMrMVQqAXknkIoYBAI2ogKG8AmnkDXG0DXEYGPs1guS4mPwqBnumBmReTatgAqVQYW1oE5YOAp8QAZd6AH9CIb92G9SVmUbOTiL01qVI2YTGQ2+UZHPEJvRwBvOUJvAwQy+EZvPUJES2S7bYB4kCZIS9ZuLow3e8AyiYAdCYAZsIAQ1sAI0gHLccgVz4kB4sRAZoAAf8BVEcAJIMQJJF56l/7h//FeJKrgXQNOU7tVhYkU/VNGAbGcEnkB2ppSVi6IMePCVGCABl1edd2EWanFgG+RLzOgXmvgGfzAGWVEVAkSCJVAXIkgEy9giLbIneGJXQ8ONNZiKk9QiMQEDhjAJm3AKrnALwzAMNaaY5aSYJWRYLmpjWLhjWChPZpMpmImFndCZNMAtNcADPBBwASeapNkBfNAgBpKGxqIsV1QNdNiavaGbztAMzHCVUnqbVsoMuvkbzsCblBOcvpINj5MNB6INuSAIZ1AGdFAHZACdK3ABFxACc2U094dsD8AA8OMVVaJ241mKEtCnpegChFA/1hg00LSAC5YlWkEYBLgFhf+gKMaQlcggGdAgCV/5AfxpIyNRnQX0F8QEjcB0VlvhFV3SS7tEoEflil51J6dalzriIphaApfUSzHxAeaFI8+zEiWgPISwCJEACrcgDCiaouUmrCc6FCd6rMV6rL4AC7MwTpZxmbjgC7kgCZ25AlL2Of0GcP72hbXne+xinOCQLLHFpHQYDc8QHGF3DEa4ruazrkZ4SkZ4DMuApRQpDcxCkuchRdewZseJCXaAB3tQB3fQAytgAxtwAVDjTDYCJhmQABjgF0hJARogAQ8QARYbAZsmAUHJAdTlAs9DNJV3YuwZM1kBAxrLEkSQBrMwPslgShV4SlMFDaxgAyVgqZj/Km000RIqYAJ5Aid05wIUZlZb8hULWBIVCiN5wnhFc6uURINNB455cgK02n8UID2qOAJGYBGGYAiR4Bi7YAu3cAspdBliG7a3sAtoqwu7cBk1ZliH9bVDpqImlAu+UAuHwAd0sKMe8Dk9MJqjSQNShgvRMA3g+jhYRA3SQK6yM5FRWp+il3o0Frm+UHr8RXrmU27HgKVYmrjLgg0FdWYZNx3eYA28gHt0cAd6AATJtQIJq2InIG078AIKwAAZMIt9inQVa7FJ16f8ZwHz57FE44PLVmJWQj84oAITsH8vgAM2AAod07K6CL3QMKXDIAQokAEYcLMHNCcKFEtkBY1M/0KCO5VIO7UFeScDMZGNfoFBw1Q0KuACQ5M9dDI0MLK+RyVJ2GsBKGG1fLcDfxAIhVAIwRUIm1UIgrBZm3XAB4zAjMAImwVzerNZ52cKdLtuJlS3QoQHPLAtNVADPdADP1p72mot1koDyECR2rAN4CANCymRLOzCE/mki2IkqreObotYSmiEp0d659MbW1pmx3c4BkUP0/FxPhGIeHC6d5AGNgCnPEtJl+cvRoADUyEBCUABKoABGhCe+tenfiqUQYkBgxADs8gXTKOAcDkSbXl5DHMCD7gGiUCfLSvHzxBCylAGF5C8wLQ/RHM/LJKDmMcvvVRLVSIjVOEVTyJMCf/Gl7yWYDAyAs3IP2V1d7R6tLR6dEmXARwAAijAGANDCMDVB30AwIUACIWQCABMRqQcwIngwIfQwAn8ypDwCJ0APsmgDHPcDOIzDHYrCICAB0LQAx3cAz+QrWAopESKm4MbXQwZkXXUkE5KJMxQhO5aSnMsx69GpVVqSs0wuCxMkN7gh25GUdWBh7iFIMVwCEmcBlaAAwrUszGQFVahoEg5u4KhfxnrxV+cXuZVNeA4TFc7THBiNCY2Xz1iA1awBreAyy3b0FvZDMXQDIiQxxWgSSUQYZTUoCRhIVUhVmK1F2/lvlSXdzHQlxRzxkWTgCrhFyhx0SWgiTDAArSKq4L/QaslwAEYkHTpdV5GEAcDYwihUyIl4gdCrQdkJMp7AAiAsAeJgAhLrdR7kNSI8MqHAArgRnZY/WrEIHKCELBlUAM/IMx9q63HLHBBsAKYAA1bSkcO2dYP6ZAVOZu/ITLuej5UNce3eZXTPIHHkAzMUK/pksJ8ONjcgYffcC7MgAlnEMw+0Bd5Ec/t8xGXlwIRYADYFAESYLF+uqfphQHYSwJzQL93kmCk/ZQtsj9psAZAUAq4bM0NzRscUwobsIgXXWJLsYxrVRNMwdFJcz8JQ9p9cdIoPdwJ+JetClTcKKHy9ZfrS6sYhL07XbtGIAc/5wdxAAdFXSJw8AbYrQdw/wAHdRDeddAHerAHRZ0HfuAHopwHikCitGCYWJ0MviAJdDByaFAGfPs5IRyGZSCkKxALT4qR9QrDBG6usunDzCAySajDIdOy2nyV1NyuyCBVu0k7cnh82uBEv3JbB2INqWAHXihi/IIVUjIVstiwD5DZmr3ZpSiUnV2KTDGL8pVgTBK78PtsSYNBF30FTJwIh3mYLQscnNc1u7ACFVABJjgRweadSt4S/LIQIRa7RHNiIda+7huNAp3SRvU8K60jLDICV/s8Bsih0L3TH4BpUGE73/3dbAAHbAAv3s3mbMAGdQAHaqAGbIDnbOAEOsABEwABC7AADrBnHsAEhQAKrv8APreACGmqkmYgBDTQoz76o2U9wmRQDLI5DYMb13HtwhRZm7n5G9NMeuVkPlpZn6c+r8AR4aG3lboZDYGNHscHRQ91IAkyHzRwVHF5PzR3FyQgARrwAAiQ4pjdp5i9p0GJdPr3AUTQqjIRTMs7FUPblrELFvN8BXDwX49aStPMec2gC8pQB/nBFG8wB1/QgX6HeHeBA/yiJphnV/45NMM0BG6Z5QOtqjKR7328jILxSEfFgChQsx/AAebFAQY/PQxjFVaBaFfwIMMDL9V1EWOwBne+BmzwBraD8UDAAQ9QAAIQACAf8iJ/ABDQBpRQCn2ABlFgBlEQBVBQAzQQ6Xz/O5o8EPOCcJXPIG7ixuk8b66gPpu8EZuLAr0iY1Uh49oNTdcNngxCMeGv3iCVYw3IcmYhWc6AKAqoqjJYsj0gkM8MoAAUW+z4vKcZy6cZFnlTsT1hgjMtg3hZQgSEtAVAcArKEHa3nFJe1wvKEAn5gRdVsWBtJ8hzgad3gXgjEbuYCk0cxhQdhoBZXnWnmu8CfdIK0yKabPCYb/BT26EuvVMy3YwgslPFkxU6oAM2YAM3oAM3kPotYAEMQAAiHwAAAPIAUPu2DwACkAA3sAKr7wMw36MwH+ke3LdBMOkwj9ZBn/NEkqWvDpu26QzJr5tDT6UKbtfaXMd7bYRRpQwh/4OlmR7Yb4h8YoogCfITrXDR+7NBVRIDN7JpFIDZDzC7OYmxSUeUe9rFFPABy5iMUbmgN3NIAEFkx44YA3cQQWjFkTFjyJAlU9ZsGrRmwIap+oDhxQsYKlLAiKFiYAwXJ1y4KAEjRYodL06ciJHiZYkSL0+QOKFCxUudI3DeHBGUxNChIEiUsEDhw84PH0Y0/cAhw4cMFixwkJohg4YRJz+UQBGVA9SoKMJyCJE2rdkWLCgwKCAgQAAAc+kCwJtXb4ABBh5c8BA4RA0eNWrQoFHjBw/GjBHTeAXt2TNo0CZOplx5cmXJzpw1ayaZMmbQzSKWbsaQ2GpixYoBgw271//sXL18+coV61WsVrVwyQIuK9Xw4aKMiwJeXNIjPCVOvji448SLFBIoJI0gYUICBBQkWJdgNal1Cteta5VB0CAOGDDYu8fxnmOMgjAGvsCxRhjDh8lCUzTmll2s4KCElXb6qD2EdgDJBRReIEkFA0s46gSaZvrJppxUGIGnm4a6iSyttPoKrBNQKCmsqZoa6wMNtNIAhJ1qYoEsrKL64Ky1zDKLBQ4YIEAAueyqSy8j85qLgAUg2CAEDwyDMsrGDuMhCGCaSYaZZ0LDMhmHkDmmmDCDAeYXXnjBBRdegkvllVSOgxNOTOaks05MJMEzTzzrPG644IDj5Zdggjkmmmj/JutFElJ2KeEFF+5rD4QRQNDAqvI0eMCA8sjDoFJLKcBgRaNUEGiLLYhgj72TXIBvIIQEoo+++FZRRhljlKGsVoZmMWYRmiQ8QSWEZpghhhNkgMHBl05CwSRlUQDLUQ1zak8na4HqUMKaykKBAxR8RKEtJVTA0SxyLXBxBA14cvDbbr1lgccWekyLhXpD+NEAAwogoF9/hQQYYLsCAHiAAha4YAMPNmA4MIZDgCDiDTrowAMa+LAjY4031pgPQSSZM07iglMzUEKPQRnlZVZehhnPDI1GGmpmtqbmbLLRRpttvOHZG3B+FsecdcyZZx5wil6n6Hm8iYWUXl45KbqB/35S1yoNXrSAgQcs+E4CDMTDIGwQJB2BwhMGMlWg+E5KltVkoePoBRUg3AEHFy4R0JdhiBlml11uuYWVXUaxe7oUQMgpBvtaWpVZs9w+adn2StKJJxku3ymomyot+6mwNsDqArQuSLjJDUhHneEHJqig9Qqw4qD1CyaAYIIHHmCAgQUWOCCBAwoY4K4ADnAggQL2LYBffvsNWOCBCRbA4AQcgCBhD0JArIUeAlthBcR4kES3WGTB5RfYVG7ZmWdglmYa92empmb5c645Z/t13iZ//b3Jv+eeuwFgN3j2s599w4AGDIc4wiG0dQCtaOAIhih4UQtRPEogCEnBpChVKf+ujAADIJCAAq6TlLBZTQOd+oCkUlCCEXDEIO1xFEqasiHo2CckKoCBS0oAB06AghSmUIUqRlEKUHSiE6xwBRxc8BUXHOUDMNjCF041ORmUhFkvaVZYaEITEsRoUh1SFwi4FgEy4i53DFCAAhKgL+ANIHhHgmMcjTSXIw0MSQM4QO8OoC8DECB5/2rekKAnpH4VIAEQ8EALcvCDH+TAB0JIi2GqFIRcWMN9l8Qk/GgWP/l10ho3s9nNRHmz/I1SlPpD5c765z//BdCACjRgNw5YNGaIAhe6GAUmHhUTBmngcGO72tVAkIGvKeABoPKap07YKQ2kkEIgoJDiNhJDF0D/8yUp2IhHdLISmeDkBoiAhCUy4QlPVCISkGgEI0hBC0ScxDkwuEmjXFKSE6EELGFpylSqQoHWSaAC1rGAFyslgQcggABEeh6SiDTHuQTPjXg8QAMcQL3Zte50F8AX6d7lLYYpzEkQ2N3u1shGNgIySIGUCyEJYIDdbaAFLVhBCwzjpMQEgQx2kIihpBGz92lSk9XwpDWwMVRsmDIbqdzGKJGKSp7tzxsC5BlUvXFAbsQygNuYBzVSEQtfkAJPVcmAdyRARrJG4Ha3I6MEtFYeEn4tbBhoCghSOLYPUMB2Z8UrQEOFAQpUxQJhK49dL+CGQiCiEY5wRCAQkQhEBMIR/6XYgw1wcAW7uYAINnHBC6oYrM26QAZGkIEWofUB8SSFAh38iRjZapWpvEgrV4EdvkLAAtqyCHYoAB1WXNAifH6ABS3w1g3i1a5uiQ4r3ZpA7nanxgSscaTLAyRKA9avASAsBC24QQ+2dz0ekIEMjJiITmE2XmmUt7zVQG961Yte+WWjZkUlalGNetSl6i+AAJzqAQ8oDgP+zGfg0AZwhtGKTGSiEQlQY7/2RQAENLjBBkBAAh4w1q1hIAIa6Ktf/7oiUX1AAoU0gAK0NoHyfOAE3aQQVVyUlAzczgmFPawjEpEIGFvCGLuIBApwwAIX4GAHocpATU5QngJx4DpTif/dkS3QugxUzQJbuRqUvTgp144oA7CDnVjGopVQja0ELQLBDlJSAhzlqFso0MESy8UjHnHAdg7Yne6aO+eS+uukA5Bu9IJU3Qu8NDEeneQopqFT8xbap+utGVCB6sn5zjep9K3vNu476an+FxxSBfAvUlEMWIiiFInNAAkISp4IfGqsXeMrqDAAUGKy9TolXBEJNJwU1h55bH5N9ZNhZLsWBKIQiUCsHgIRCGBLwhfKOEUagLDbCkxli44qi1ybEraqVGBT1kHca6EcVrKpy6/D5LKuiflkDiy5AuZ+MlXcfJ0cnYAIjkJBsuL1ARfweLRkVveKKIDXM6YRwdxBwB//7QzIuQypeQVwgAdWoJgNeM+mZPCFNmamaPlxMqihvNn9NK5x/d0Plfj7uFOjykr/EdBn3nhGKpIBDFOQYhZxyIMLWvyA7GggAmLF+aYC2ylXA9QqJcwIukAA5K+JB1TE5EpGqOLXEd2OA8OecSKG7dhCSOIVzbhFIlhwgbFNSjpfoUoF6trXFJJg6OcBaz6jPAIZEAGeqg2s1+Lete9MIDz/bN0EbGd3vetd7FYhAbTLNRbCi+UCOSqzXe+KuwXkTsQMcDDyBn5SgwfSYAlvASQXzoMz8KEZ9AP9xkU/eo2T3H/aYCXqvbHxi89sGjs91DOcwQzahwkZtahFL1Ah/wpWNKIGeUBrBNBIULTiNfhmpTnNTz1WMo6wtLQWK92tXZ6vXac8VflOBr7DAUQ4IhKW8IQjFBEJ8ivqGcoYhQ1cMALmz+AFUOlrX+FqISrrcwQWMAsFTrCFPwxiEZOYhE9YhDGwgJuTAA2YgDKDJrC4ERcwArOBgQ8YioC6vycjgRHIAEmRK29xF7agrXp7lwq4nddxHQh4AAfQHZHyt+cSOALAszwTAD8asQtAAS/4gR4oA+8CL9LjQU/CpIngjC1hhmTwEtcAhtlAk1rQjVRABVI4DjpZjkeQwkMQBEHggyu8QjzQQjywA485BEkYBVeABVMwBVR4hCo0vjRCq/9Tszvmiz6csxS9CqYY2aCi844ReqsUCjp2Iy100Y4LCIRKsARNAAU0uANDUIRwEgVigIZdqAMWSIF9i4AhIAKvUIp9CrKiSDcSmLYLYAH+e4MroC0xEAM5IIQdODcjo4AbCSvWmR3R+TuoQIGwgjJv68PkkjDRYbPfepfTgYDiOR6x4wDSoZ0TTMHHQ6Pm4qMFc0EhecFAYgAl+IM4AALsyq4e6C5G8AVd2MZcUMJXaAUmbEJSGAXjMKJOqBM8kUIpZIRDOIR2dMd4lMcqpMcqBIR7xEdAyEI8wEI+0EI6AMiAJIMgCIIn8C466ANB6IRSYAVWgIQqJIEJK0DcoTn/A7zDEbqa0nqrorOasTGBjwSmjaQ+LvsgExibvxKbEkI+NdCES7gERyiEOvADR7gEkNGFaTCGS3ALCsvAYQwbMlOKk8CAc6MAELi+8iABHFgYCKCY7mkBHSAEOXCzBxiLr9mKwLIA1vkAEiyPCrDKsDorBvg3A4hBlpoArDA3xluj5HlBA0C80JkdYzwjx5szOvujh0KplaoAMSCEP1CC63KDPgCEQmCERpDHw2QERUAExWTMQnDMQvCDQPCDyczHPrBMy9SDO6gDNlADM0ADMyiDKBACIWCkHLiBGngpmOqe7nGShVGYjkKdC4iY2YyYC4ipQDiFUTiEOgCESXCB/6KUyAvLSLC6mk4BprGpvr8SJhAwAW4yybEZuqETG6iATuSszqHbtwm4gB+4hErQBEeAAjMghEgQxE6IDGhgBeCygNvBgGEknVDhJwooAR/xra94Mu/IlAXAIz7IBf8wBjeAgBt4A0N4A9LJQBbzjr5bndWxO8WrAFxMoz76FwIwJjNSo2X8I+XpFwYwgnkxi9PRuxNEQa1xPOZirjqLrulKABKlnhsIgzZwAzQogjJ4gic4giPogcN4KbNQi7TAMg5gmB9lGNLBio7aAAu4KNIx0tiMzb6jzdp50l+cqAaQqImazQuogTaoAzRohF1YhA1oHbGyFNOyjlSjClqbCv+6SqETcCYTOAETMLsSkKsuUzGyIAvn2CI5JTIbuARNGAVPQIM6MASXtARMMIVkgAZb6IELEEGqbJjTac+GWZjruZEHSAABAICDagBiICBw8AZAWNEhCIVPmAPocD/oMAIlqJsdUAIlEAMnIMUtGAMUgIsB8KMFSwB/MaY1KqTkacFe7aMHEAP2aAsgnZ3FC0vlErEFOFHoSlHosVVDOhgGoJ4oNUERnahqtdZs5daJmkvlWq66zKNxJddxfagDeKh0VddyHdcGWAAqbYANOINGKIVGvIPZ4oDVAZVLDKu/ApUzFY8ry6cng6uyeya6StMNbJGmMIsc2aJV2UoOsIH/SNAEcnJJSiBPTjAiXWgFTSiEO8ACHFCCOGCDQIUDOHiDN4DROIiDOrgDPdADOFACBqALIZmAaQCHZniEadCGR2gABUCARQiFof2EQZgDOYDZOEjZN4giU9kBIyCC0GIAPOuLXC0kF/w3f2lB5PHV49GXChiDVtUBHcioYzW+ZFVWZZQ85hGSggsYh0Iegwme56Hbharbu8VbvlDXc2XXd4VXbZ3NjqqY6+keGvCAKjmDLxyFGyMFPlgBJwEdd6m3eaEtFriB+NABHNCBK2hVMRiDMRADLPjcz13aN5iD052DP1BdQphMP1Dd1SWE2DWE2Z3dPyCERRhUTyBEcyLP/0oIp1HYhRsrhUtQBD+IA0LogzxgWaa9AjQogyX4gSiwAhugXAOoi375AGgQhjOAgE4AhN0hAA0IBQAcWjmgzeITPgcjANwhSz+y1SBhMD+SMGYcOGfVWpZCgTcQA84VxRB00tm8ndwxI2ZVW/ptW7uIwYJ5Izli4LrdW3Yd192B1wluAGuVGCZhkg6YGIoZXIWzGBqYJJsiSDvgR0HABFLIhVzQBVUgIpf0hE/YBBjehEuQ4U3YBErA2EXQYUUwhNiN3cmE2SBO2qSNAz0AYpaNAzdggyV2giZ2Ah24AR3wFhuogT0ABXKiBHNyhEq4BEvohF3QhC0NgQ2YAMB1gP+z4tZfXIDbuYAQM5gY5AAYQAHesVUBiIChnQQ8ngTdSSP1na4AaDD3Xak+KgAHQ4AW09DJszPlMYAEWAAWGF3QFa5uWbK+s+QADmC6tEuCMzjoIRg3Op4DaKi53dtShigIpmAq1VaGGdwQ8J5J8q4yOAM60EI+AARBeEdGkMI9mZNz7ITjGAVTEIVRQIVWgAVYsAVbEOY7AQQhqAEboK20cJgkJcaIyVbe2Z3eceSQ4uaQUq4C9lUF25fpWYACyCMHWAHyPKdKcIQYQyc6GGMIcNdxbSM3ip65JRi7WFEGkIu86FoJnYGhFehQ8D8EqItBYjBDdjCxRCNG1loKMKT/kVrGidaX5mIuFBADK8ACKC5WEL0d2vTWxktbcGZb6eKL41kA6nESFlA4ISgDOrADDlY4xCBIm9IYfrzCKnzHddzlPZEESwDqoC6wTMCEoZ4Toi7qAitqTEBHTBCFXzZHIwJmUvghVLDqq36EdgQENKgB1zTSi6Jm2pFSBxBlPOpmkepmR5bouyzlBdBO4DmAJWkETfBOcxJESJCESGgAdJ1bBo6jARAxI/Ej+I2AQRhogc5jEcALAUCACBABEdCCyCYjyFupiIZfO8sdBGjkAq7Lukyj3HEAFniDJVYDK4DieBnGByWd2czWTObjulwwGHRGcw7tRPgEchqFYAbH/0fIkznREzuxk99OR14G7uAm7uJGbpEhjuEYH1noAZcWAhsYY0tW0DI+QWyFM5EymMZLa2VkS3u2Iziii+fBowbIA0sAhSAqhVIAolLQhA3ga3zO24FxowOImDkSAAX4AKE97KGlhVDQAhFgMMeO7AIXgfQF5eMxnuNZnu5AADWC8DSS8AmPM635Cx0IYjhgAyyY3nkp0iEV64i5HW9Nwdc2YOmK1ohqgTvwBCIaBeZmauAWbt/WE5DBhHWscRxHbqeOE1FY7j+RBZMZlGNgmZcpNPS6hiUtYzj71jPqVm3VTigF3NkMcdamno+OGL3L8tTZACZJjB4ABElQhVsBjf+IMAZVqAMa6PJflKhU9ttUjlce6IEGEBJDGgHDpoVVmAQtyGNaEAZhGNpBeGwyguwCl+wGa6PkISkJXd8IePA0Ous4q3ALhwAWiExCkMw70PArAIJJRouynZ3aWbwR7TfvLmnniZ5QTmkrqIRRIAXi6PHlXu7m/pMzEZRBORkiZ5llMPIjr4ZruIahuhlu4Ib70i9xQHZyUPZxGIdzKAdmZ/ZzQId2cAcbsHYb0K4bsAEdAAJuz9z4sIJwNwMrSAMzKPc0YIPNXAM0SAN2LwMh8AHtkvdnfmYaqFxXdmXaUs2XqoHsemUyoAOPQWojAhlLaMfCikdGcARIiIRL6CH/Vy9DVoCFWbAFbtQbXyAGWiiFUPBzYfhvQS90jv94PJZssnpsLRgCBIC8P+IjRW9wm0Mj5Wrybz2rCdgANvgERdB5qesDPdhwIMABaPZ0Y0WdEOfWkY5tVE+paA2ABKiDWQiNmJEG9IovSQOg/gIHcViHrd96evD6r68HerCHsc+HfBh7e6iHtD/7tU/7tnf7t2eHuE/7eIiHe4CHeIAHu8f7e4iHtDcDeMfGKBF8a9euRxrNMigDNQhIl82DPXD8ewyEQ0AERiA/7/QEUACFISqFUziFVVgFV5iFz3cFWiB9WrgFV2CFWVB9AbmFVijmY24FV3AFXxCGYbD922eI/1uplVopDczYDGhYPffR3kGYARFoMALnePItfYIuKzKqFJXXUM1u+eRReRGgSNc+W+PTThZIBFr4TvJThEIIhJhVA07H3EnuxaJ/0kxmLuOhvIEBmH6ZiwOgA04tGrFf+7M3+/23h7LPh34AiH4CBforaLDgwIQKEx48qG9fQ3/48N176I8fP3ny7lW8N9GSpUuaOpEERapUKVWsXLGcNcsWrVsyb+2qucuXL5s6debEmXMn0Jk2Xcq0RfPWrFqvlsKa5eqmr17AgPkCRsyYsWRakzXr2uwZ2GjRpmmbp22asFCDIkQQIQIBAhEzJoUKtUoYXlqhJg1xy/bvAwUICP/ARWDgsIECBQwgaBvhAeTIkidPqFxhww1Oxk5RulQpkqJEgfrogaPmipgrSnDcaMECRYgQHDZcqA3hQmUIkBnwVpDAAIEBAoYHKB5guAAAAAQc4PHK2jx7+aRLz2f9OnbsDCNyj8gQI3iM3Q+GD3+Q5q5ct3Sx9+n+PXycU+P3qq8rly777Pfnz98Lfy645DIgL7HUciAvuNTCiyy4NIgLhLjwwssvwVgYzDHHIKPVMsww44xY0UhDTTXWYLONN+B4M40yew3RlggEyJUFXavQQoswN9Y1SF9+UfAYXAUwEAFcCRiZGAIPUDADW5VN8ICTUVpWgQUcWBnFKcrs4on/J5pQEokjiRDiR2lwwDGGGFgoAYQOrbUQm2y01YabZL39FpwAxeV53HDKBVDAARAccgw49NhzqHbZZafQeI2SV5543UG0D6SRFtQKpqmgkkorqXiKaStLveIpqaQuVSqqqZoaiyytukrhL7BWeGGGxyxz6zLOOFMNNtxcUw2w0nwzLDjFrrPOPMnOQw+zhh7qrD30zOONNd5oA02Og8Alghah6OgtXnnpFYoWbonwY2C/JVYAAYopNgABBjBggQiTRQYBvvhGOScHaLhizDCjSAIJJIkYQsgfpbHBRh2nWdFmC2/KVlsFkFUWGQMLKLDAAr+xi1yee+o5HAEEHLAB/xmiOANOdNL1g9B1h7LDjjv11HNPPTO7Aw/PPcfzczzwvPNOOuqo847RSQ89dNJH8zx0z0Ub3TPVHN0TTzuuvjrhhL/MamGtGeKKq65lgyiiNCNSQ6I12WiDojdxp1gs3ccem+zdy0o7T8zSOtss4IAvm+yzeK8DjjbWPAONNtook60WWuC4ilqhhHujjXpNUq5fETBw5GFGiq6YAm29EIEETs65em0buG4lBywAYsswyuTSSUiRLHLwmHfkoccdbKiRphM66MAC8ih8YEEFHDBfwZMPMLCbb8CVjJxxesJLQAIcxCEIJrE8UyiiiuZzj87ooOMOPjRTDbXQS6cjdf/TRs9Pf/1GL13/O/AEDTVHfoaNbGSDGwbsxrCGJY4FMtAcDjSH3WbGjnXMjFkSpFnNcnbBDDKrHoGjRwZtZrNmiZBZ1olWsailosZRIxrPcEaGghErB8nCU6K4ISYk8YhDCOIRrBDGNKYBDWylpS6rGMQg6qLEunxrEFlwiwUkEBjfJEABvGGAAz6ngAdIQAVZsEAGZrMB2HEATrBBAQqQFzEbJMIWvlCGMVqRiUxcQne7IwQgAhEIMukhDnEQHhuEYAUgtEZ5aESB86AHpSfx5kgJ+NieQCaAdilgAiGgAQ2CgAlmeCNZhsrHy/jhD/Wh44LtaAfUTnnK+MkPHff/S9or8wfLo6kDfz4bWjreEY8AlpIdpWyHO9zBjvvhMh0YlGD/3qHKZS6tmVBbGjzkoY92vO+U99iIPq7JEZ7tciLVyQc9pIGJRwiih49gBCN4KAg+lJMP7lynO+MJCHYCAg90yAMncKSMx9GCcjUaBF2QSBcjYm4Sg5iBBkagAUbyZpEToJOSLDAEOYygBCdIY8Rcs0YbcJSjQPhoGioxC18YoxnGQAUoOHGJLynCEIgoxEv1yMc79OEOd1gDFrCgAxwAgTWvSSQHFCk9BljxTgSQ5CRLVrIDDOAADYAADR4BDGeUZR7ruAdG2JGzUrojHv172jK9Kr90qO9+RZuf/yybVjSkofVoQRMaK622y6thrR0/O+VbufnLZYaVakqD5jjKIdh2qCOap0xmKtWBysUiTX/xsFk88EEPcKSCDGQIAg/wsAc8cNaedOBsHeggWtHuobSlzUMe9lCGOsCBEKuw0T7HpcSBRk4LSbRLKLKwoyGoQAYoqFhlJCAB2MEGNxkYARH+EIMYGAEHOvgodIFghStQFzVqUAMb9KCJkdbuGcBARSc04SUwNSIRjmipIQpRCD/4ARGOaMQe7hAHNLABTWry6SGDKlTpVQ+Sk0xquwQArwE01QEroAEmlpGNCJ5jZr3EoDAvyI5TmpWsrhzm/MpqVmfOT37669nQgv9JM5sJcx/6yGZFHsIRjbB4I1bjyIlfnM2gsRjE72hxNE8MNHnEg8c8BtrPrtlinHHEHfagBh/sEAQarKAMZihDGYQgZTKgocpnuDIa6GCGNSyMDm1wQxxqIAQ13GETOMrREidhUIPW1raD0IIGEDCHtHxBBUSAQVCrpAEQuAAHOBhkCzjwARVsYRBjMMIYrquGNXCZDWZ6NKT1UAhQvMQXyXhGM3wxCi556UuJ+NIiFqGIUSeiEqM4RSUKAQjU6qGPb0jTaliDRuc96WJEvdN/QUYAABhHwAQGwAA68IhlbAMc6wDhOc6x1WBGWMLt6DDR7jczs7pyw++odoWRFu3/rzKb2TOrFLhFWZB/kJvc+yg3utNd7nOr2yCifLekwCMQckuWF3Y4Aw084AEpS7kHPPg3wHlQg4HXoAc/CEIQCN4DGvzbDJpQBovQrMQ2t1kEf4mABZIohy+8+gZoPMELYjCGN+hhj2zAgQuI8IZJ/IHkrdZDH2LOXpn6QY96TEQkTuESSzcDGs3IBSpGkVLPOGKlX4oE0iMxChy5IhKIeCnvAtHqN4wBTavxeFAzINRbXy+pfVKOn4rjp2BLIhkpokcE2XGPd1wwgkQba4XjTsx3lEPub11at71Ns3CH+x/88Dvg//53dRM+3eC5SHde9rKLYGTe/8jHNx6BhzLw/2AFGxg4JjG5ghXou/Mh6LwHOiD6zm/gkkLAwy6C+DjKqYVbFbd4Y/4yBB594Q9y0KkOlHCFMfwhEOaNRCLggIU3zOETLCdEIQLx9EQwv/nNV8R5I6GJU6hiFrkgxld8rgtUlGIUnFCpeC9h9EpcQhW7eJwmHFGJRtiRdwlLWBzGgAUcGHJ5tv5cYo5KMrDzn/8BaOoKSMIxQAfezAwqSVAEQRsuRZuGwd39oEMy5dJX+Q9d6QyJMVs9RJM8aKBGNFPTtBgIhqBGqIMIiuCJyYM6nBgHakSPzRVG7IN1tIM/5MMylJMg3MEeuEFp2RQP9uAdhJYb1IEP1oEbuMGW+f8OIJACNFgLP5GL69WWxV0ckYiAHGTBEBCBGCgBC9iA7rlcIBRCIhTCHVjBGMiB8ZHJF36heq0hTMFU8zXCJZzCKbhCLgADMjDD4jSDLaAEKIifZxxdJECCI5TCLkCDMgRimDRCSxECIchUq7kBFhASIlmJIt1af+kfUiXVYhzAASTAAjSAgUkCMpTFJy1eP5yQPeDDLp2YPmwg0/xVtEngWPXP/8QPPIhQt4mQzVCN/+QVKyFNB8rDjd1YixGjMB5NM7kiXLGYPvCDPpCgPvSMCcZYPtRDP9TDPKSCIBwCIMRXdgFPDwohDxJhEMLBOJLjGqQBHexBHhyCLpTFNOz/AuWUS8X9hV8IQFy4RQyonPxhARvUHPM1QiOonyOUnBxswiccTCKU16g1pEAq4kMOpCagRPXpQjFwxeIowyx0X0p5gkpVwmcg3SgAkTJowmc4AtKF2qhFXR+NwRXgQMQg0tbx1yNhoiTBi2IYwAEYQBV1TAN4wCMQirNYh0BcBzu8w870Tyu+4l/N3dtB2y/2D4lJUDDZDEdImIgd0wUFjVcxFlfCAzVFky1SDSp95c80YzRqoDSCICtuRM2EEzsdQmm1QRu0WjiKYx2QYxH+YF7SgRvQpRmkwRrQVB5kQjIUC7Y4YW3NgLnA3nAURlzMwByUBk0lgiJEwkCCRCSE/yQhbMIq6E7ShWZoomRocsIokMIcuhExJIMyGOIuuMIpCN0oCJ1KeUYkdEIh7oJngGQlUAIgOoIjiFojloYaWEHxtIBM1hojKUD+KRVyEBiBLUbo/MYBLAAEBIEAnp3L+MM/jBIy9RgtNY0zNZMsPhM0PVY9ZGVV3gz6SJh7mpIyxSdjzefPsB1Ssl08dJV+5ucqRmOP3QNY8gxbsmI7sIM4zIMs2IEgdOMd0OXv5IE5/mAQ6qUbsMFoXSgdBFIakNke9EEgnAIzBJEwrAI9co5fwMVREUZhWAARbEHJFQL7fUZKeIIlZAIndMkiTMIqfMJm8qaPfgmQ+iYlVIInnP9mSsCCGw0DVuyCTMDmKKDEbIKCR2rCbLoCKIjXZ2iC+IEkIILGwZAJHPzRFXjc8lQABVRi9RwGuxwVdOIkYliPvDgABDzBI6TCyhhKPZDbOayDOZADOvjPMYrneC4g/HCTz+giBrLnPZjVMA3ThRlTgaKSYk0qYVXqpDbTfOqS/8TnXXkE+uQnMP3MRmBTW47DnlLDOtXTHtDBGbRBHvwgX4pWX2LoGbAqhkJZFIgjHFDCLojL5phLuSDAY7YFZCKABcjBHBhCmESCR5aCTIxCJ4BCJ3SJl7wWJYSfH4ZfJHiGH4rfJ4DCk5qCKrgCTQyDMCBFk8rhKUCp0IFrJ4j/n5bCq3jFa2/2JpgoQvLVnB/AgRjA5CQGVfQQlQJcolIVrHQOwGJ4IpRsQAPwQIJ1Q5+Kg90c28zcgyo5k/7sj7Z9lUZME15hIAa+2FlpGFk9YDuoT1qlVWMJajNpYM1MhDDFLAVajTw4o8eawzzwwhmklmd52avGwR0EoRvQQWhdKBpcGZZlGR2owRkIwROgAaO9wR/YyI46UWNGwGM+4VsQRlv8wSIQwifQwihoAig8xTAMgy+YQiZ4Hyfo6C58giaA37xygpbWrXjRLSjk7UmcAiu8hFOMq0zQwt+uK0qcRJQO3SZ8n0fSbfhpK2goAiIcjNRl4Q28hkxWIk02/2fBlsy7QGfCLsD/HUAHJNg2IItVSSw91EP7HBY0bezGKg0H3lWBjli3zdWizo9guRIpWZj6lIP9xBL+6E8tBa+g8kx66hhiTWDPmFj7oIM5aMMjtGrR2gEdoEEchCn2Cm0dtMEaQC0amAEaDI8YMBqjRQEUNMETmMHwEIGazUGPROFRxQXFBWtjpMAgfC0tOE7ZCsMu2EIuoC0r5K0nfMIpjGhKfZ/iSikCI7BH5m3ePqlKsIIqoETfzsKN2AIrlIIcogS7zuYofMImODCXLC4Ca+mXkKYhSB0bXMFHYR0HQBT1GMaabm4BGEebHsDYNUAAIkMnWZXdbBXrMs3+IP8j7LKY7VYlztRDkNHV/eRu75JStWmYYDWx3A3vWaVs//xpNEog7C5NPeQDPowDOazDMtiBGIyBaNkBGVSvH7VxHFRohbaBGoQvGKivGlTdGDCaGpxvERRBJG7BEGRBFsxAXwwGABDGE1Icj0ThEPzBJHxCa8rhLiipL+iCL9xCKaTUJ3xCr56CA38yKDvwJwhdtIKrHJJC9f3tSrjCLKgC9U1wKZgCKYBCJqPEJh+ulDYwKHwC467USkVCCuvBq1HuJF5ABUDPcnrMDCsV2GVPAITdAFgnggVDNrCMVbHDOagPKg3xKz4TKsWu1YjQi41qj+FuOUSxe0IxtblSLHL/8fDurgMmEzTCQzlw0/8gpTuAkp6CAyY8wR2YI2e9KhzkQRy0wRsX9Jf9JV2iQRjQ18IwWhpsKBugQRuwgRjsQCD3CFvARQTM7/xujgVEAAUQwRz8ASV8K9/egnvowixkgpaCwioYgzDQcuGaBEcKsCZw2kiQBO5IQiYIQzMogyvEcvf58iisMiu0AirI8t6ua95mct7eaC5zwiZsAiVs2iUUQh+Yxg285E8h88Vkrpo6pybm5GFsDMcswPTgiyYtA/lsp0Hsg4nZLFrqw8+wQ36Gs6JeTf9I0wYWljyYMxRDcbIl22DvboZhm/3UEsky6v7AQyumQy/yTLeBEj/s/wM9RAMZCIFdCiFrscEb06Voj7ZohwEYiNZDb6gZsKoXXAERzIAJOCYAyK9Hzy8SZcFjUMAH4IAfhLAnkIJK54IvoK0ugEImPPUuGMMuEG4pnERzO3C73jSnOQIkdIIyaIMxnAQpZELBWGYlgIIpzEJ7+IItqAJ0a3BsCnBUf19VfwK5lkIkFIIeFCe/9pQLlCnzhHXGUJHmKpW7TCdaT88DWGcHtLU3fBI+EIQ/mFgrqmA72HUwBdkGAg3NciCIBXY6CJZgFTaHFzY6cLg6PzHKlizvltWgHs2JDU1eddu89cM6pMIK1MA/F20dLAxp3zhdhoFphy/5poEZgG/1Xv+BEagAkRDARnd0idZ2bRmUxU0PC4AtJ1wpueKHT6hCJ0T5KKiCMGjkBIurKTQ3LjuwHA4d0l0CLexCKXBCJ6QTN27jIRxCdWe5Ksy5K3Ok4XowKZBEJlR1eyc3LVSCaJQGmawBC7fABwgaJe7XrdVku7iLWfNkFVkRFlXnUxW4KBxDNbRMPhjEyY4DOsRDg8NPizmNgAIZ1QRNhmt4OZADOXA4q7/6q4N4754zOpxziT9xeULN1Gzx0+DzzBBEPVyDkq3ArBbhwig0jpe2af/4dUX0j5MBlE0XEQwBIc/vECh5mwGUFqRAFszBJJzCKnBJlD/FgLDHRh73bMa0cjv/hSuwgimYArgaKSmcxGuVQpdwq0lyQiY0AjqhEyT4dLTOJkXSuSurRPdFabsicOKWQkkZwyWECSHowZiUhhgAgQugAHIe+guDdeZK55sihugMLG8sQHVCwAZ0gAcEAR+kQjR8Az2AUj+Ew8yMQ2CFJ88YzQhuoM/QVd65Q2CVgxjD+qsz0AIJPatnc4efs4bXOq5nG1u9w4kV1tsNzcz4Qz9IVjBgUgiwwRqgdkWzAbLfuI6PfR3/eGD6OJB/7xVswRfIAba/vW2t2SZMgh/0wXdzgiVQWk3kRCt/X7yTK5O6OypgyivUQiywiqu0wpzLct6Wcrt68GmehLjOeUq8/3tKzMIt8C8rCJ0n0HK7PvBRN4PjaOl5+UFoSJ1psAl+afwFYABuLOfAis7HQ/rAbkx1cowDXMAGeEADdAAfyII0HBvakUM4oAOL8QMyQhMKCuNX2cyIpScG0TzNwzoDhYP1W3/RG32ytbqHqzqtO7E6/64KFlMuVX0/2AM4PILleYCFXleVdW/Yt4GO5/jY7/j3nv2PCwG0B+baf4FtvxlAaBE4kCDBQZMWhVqEgkYdSJo6cRrFapatXbBGgeoEClSpUaoo0mI1CpYxa9q8pdQ2LVqxWqhMkZJJypSqUaVUgbppqiYrV7Mq2qJ1S9cuXbVgsVKq6tQoT54+fTp1yv/jqFfQwAmLCMlRokiREhHyA4cNFixKdLRggeIDhw8fMlSYMOEBA7sKEuRNYICvgbwKAB8QrMDugwkFNpwRhEmWM3Dr1pkjl05eZXXq3r1r1y5evMyZ4cFzV49dvXv13HG+N25cuXHkYMMWNztc7dmzY+eOfY43unLl0PkG/jt48XS/L5eTp08f5nTP07Fj5y+fPWc8VmyAgEaNGTNq1KBB04Y8+TBhupxX36ULGDBmrlyxYqVMGTr1hQgBcmXLHDkFAQxwoIMGWYUQFmpY4YxEOAFFolJOcSWnUUjJyKNSWDnFkkMEOeSRUXJhZhpw5ikRHGqY+UWWVFKRyZRReDL/RSmffgKqIldcYSWmmWI0BadTQjHkj0lC8QgUVKDRhhanKonEkUsoiUQRsfSIg6wrgMDBBRRQWAsFDiyQi666GAAsr774+iuAAQYooIA0B2jgCEYwqTMVZrKBzBx04JHnM82kY+ed0OCpx9DRTLsnntDkae032WK7LZzbKBVHN9h4O8e34jblFJ3n3vntHXXKUYc5zDJ7Trp+8plHlBU80K4+M7gLDw312kCPPfV0nQKKKKKYbz5gySCjjPz0U+KNOeYQ0FmDiDSCBR5qoIGGPjQZ5SYISSnlR1VkOgUUSAIBZA888ODjEEYkSeUXZqzxhkRvrIEmmV9iaVGUfTHZ/7eTTkQZJeAKK6SwYJp4gvCTQSxAwIJBpNLWlluacpCSRjSBUkoq9dADDjWM0NIFGFxYC8wKxHygLjPRTDOBAAIQgM2ZYT4AghaO8KADMjBBxprHBN1M6M3S+Qye01C7R+l4Kqvs0Utzs5QcqXHLLdNMPT3nN+A+Fa4cUEc1VZ9R7ynHHXekqw6cR/LQQYcV6hMPPPHOyxVXXs/rogovyogvPjPoOxbZ+ZSQ44//nnV2kFAGKZlaGmoQYo9KRqGqFFA80UTzSyyxxJFDyg1EdHPPBUQQQR7BBBVdlJlGG3BIhF0ba6yhxpll9k0Fl1piieUlmGKqvJSNLLlEE0oMmf9kiAgIQGCIST55MCPMOeHkkiYbSaSQPjq+EggbWPCSAw4uuGCuuVbGy6++3HTT5QXgX8ABBxiY37AJINhZFGbAoccee/LRD3/wg4AFLKA/EKiozjQtVOWAWqQqdZtIWe0c5Lhab4RTHOI85zKXWY4+ypEZ6ZyDHdU5Bh/qoAQbwC1uc7vVevCWN/b8KljCmg+ycGgFIIhBDnLwD4CGEEQADWJxCiECDmxgLchFjg57AMQTn7iHPEwxD06U4h704Afu6YGKU+wDhzzUCVOwLkkkKtE8TrQMZDiDGrSbhr2KQYxkGMMXp7iEIxqxLkRsYhKDmEMWIiAABMxhE56YyvT/PMGJzF3CSYpARCD8EAiPrQFLNrDBDVrApfGV7wJyIRNg1Me+N/lFLwlYAAPgVz8HGOYBENhACHi2DG/Mw3/5GGAB9dGnA3amM/BYFDyedqnaDNM24pgUBHdTwQtqkDgbfM6n0oEZePDjOfGQDmTsMQ9MnEENVmjBCqJQhiq8Z268Ys85ZdgFX0GBnUtwpxCggMP8/OAHQFDCFr6whSx8YQ5E7CO0iLQKWghDGJ/YgguQuAKFQk4IZTADHepwh4hK1A0QlegdMHoHOGyUDRu9QxziUEUnmm5dkuiE7orRjGnIy0SwO+OJqCEveuXiEU8UxTB0IQxaIKSPGIiAIaJ0/xNtIZITmmiSIxxZiEQEog93YIMYdAgEHdxgLSHgwAbGhwFPkqlMe2mZy/6iAPjNzwEQGOsFNrACPGDiGNaYBwBvOY7LvOODuYzHac42mmDqhpjFpBSkkqkpdFwtOFvjFHSK08HlvMMd56gHZOgRDTvQ4QorpEE4veAF75jFnOlU5xRA+wRgtZOdVpCnEOiZJSUoAQc64CGRQtFHf4aCtqEgqDAmYQQXuMCSK1RoDqLwHYjSQTzFFQ8dLFqHNaSBuWvwKEb3sAeIjlQQgFiXh/q1umSwcRsuLZG8YAc7azwjGcp4hhuTodNVrGIThtBEIg7hCE8MNSNPsd5RFZGI/P8y1WNquMJZgEBVFlj1LRzQKvpU1tWvglUvC2jAgx1gSgdMYAMb8IBCBSELarzVlqwJxzjeoQ8C9glp9aAHPXzzQElFUIJVs+AFL2hYDj5TsNFURzr2wY7BssMc6wBHKshAhx+wYAWX3Ztm4XOFKZwzPexZMmibEOUntNOdSwCCaYGQ5fz4wAdZwkFrdbAEKxgiFKuoLW0nkeZJ6PQPJbMkC2xQgxDQoAU/mI8Z1pDnPIMHPHn2zp//7Nw7rIEOd8BDHaI7UtEVAl3IRRdJMZEKXjAjGtRASXhhBxk0xg4c9IKGL2ixilJE4ol4SMR8EfmUjGEvEXh8pCThsAY2+Jf/tSXjElvIZ77zpe9MaEIAAtBkSgc34ADygwAnN3CABkAgCKlwhjfWcUx0sKMdIh6U0qRjKN9U8FIsjuDUpIYpcpiD3OZgDW+2Bp0bH9bG6dCHjq9JD2rwgQxPqBYNQhCFXyE5PlQA7ZKd/O8oR/md7kxtlhEuBC77wAZIvORUb5CHTZSZoGZO83o/IQYLg+/N4aNzDoRgBTOkYbn50UGWb0hPLl9Z5CTPM3KRO3I1TBSjDYXCD9iZnyIHwQ58eIQocMHGbMjrG+AQR4nW8Q3IgEMbzxjGLUbyORTWoRDZMhL1Vu0kJyXikX7wmMfekIZa77ZkbdlA+VBGl7vgxasL//ZL/OBnyvtBgE3KZjZbs/GYdZRwH/wYVGXgwVh3bJvbU5NNBG0DbsMHVhzlJse5ZfzMwRoHOvFAGzvWQQ9wxCII9eYBDWAFhSZQoYb/HXgTnnz6JKw+Ce+kJz3dlmUu96AHOfBBDXrQ2xvsPgdxgMQpbhtqhYyBBR6oQYJWAOfkyzkEK7Ak7Xsbvha0oLfVp70P6NnQ+pSBm/rxQQ6LjPsf0B618HwoHfBwCEy8IqXTOMnr5OVj8T7DGLs4BScagYg91KEMaijEJYSqvjbnK76iK5bK6zpGD8IOS74MB9TCqq7q7FLmLvQCTUbJZRSAANxEMA4gARoAAGBmAAQDAv9oABOC4Wcyrx4WpWkATx6CgzcOD9wQb1KMiQZ1o4LKzdzOzWuCIx2mTcc8JR3iIcfOoceywQ5oQAqWIEE8wAOWIMqE5b9Yb/WaIAmKIAmq0ApX7wdy4PW4MPYWjvZuwAd64PgaDgcwqQlqIAnAIA4IgRD+4AuIAAbijFo+D9+IrPlCwAOaT6GSb8BCIBAFMQTgzJLM0AZo7/oaCg0M8fhogAVooAn5EHIgxwquwLk6JpIaIRI6wSp8ARmewXVSQl5Wgv5uQRXwLxCkC7nqABAqwVuMpKiuhxKuZ+vCghBEx+vgIA0I53vUQpPGJ0zQxy4WgO34on3axwAQIAFkZmb/2qQAQHBNRPDBGoAGHiEY8oQe6oFRKiMzGqWwWgM2yM3b/upSuG0cBOsc0HHyPIVrgiNQ2KEf+oGA2sEc5oEXaKAIRg8KskwHnOAf/Wa1sMAJmsAJqIAgnaAIgCAJYs8J3IYMyRD6DDHOjs8RFYoF1ALfBpEPA9EPV2APL2wPA1ESCTF8BjF8UDIlw6f6EBERe+D7HAoN1sC4ugMLzMAssEA+WI7kNqoOEC0QEMERLKETSgEWfMEYoMF1tGElkmEXRsISGkEVJyq6AuESIGR6qIcTIoErsueRnqipPuYKdOAMf9GqLuCqyocuyAqV2s7t+uIvUql+HmB+IKAuXckD/8hAFGTpfwLolghoa7bmNXLwNszh2x4IU2DMU4QjOuCRNwKIH/ShCL1BEI5AH5sA4fzRCVbLb67gHz3TM09OquxJCb6ntyIy93qL9ipSiSqyB6zl+HiAB8gPh2ZPCMrQIosMJRUqEE1SJadvIlnSJfMjCrwADIorJ20oqoBg4RLOCtTgDvYAKBvhIUYBFWxhGJQBGqChGYghF1phFCyBEQBBovLMJ+8AESJhWzKiejihEiqBK7WnEAoBkvoLCyxRhcDnS8Znk8zHLusCfozRLUkJlOzCLugSAuhyA/QnGLahlvryHwDzaQSTHMsRatCRNy60HX8DHtnhHNbhHB5zH//WQRyOgQYq0wpDMzSzbLWUAEsQTjRf9ORWS6qwzwtR6wfgKZzKIAq0j1bYwA3q4EfvoIsSrUgzqg66IwrGD/eSyA878g+lb/qojyJrIDVTswfcJjl16OQa0OF6ywx7AM/qIA+eSDpN6iNmIRdyYRYkBDwTYTwHTc/WADrlqykUyUFqET4RgevKRQ+cKs/EIEvyMwSA8ex0TS2JsRhD6atKCZTicn6Ubdm0owOCQBKAQRveCoDywTccxYEeb9wKk8UgyMUwhTUuVB1ZgziyxkMhYx36YR/2AR/WwRseYQWWwApzIEXdxm1YlDQxM/YwczTRIj+S88/Q4Ed90qKiCxD/Fg0R9tRZE2E6ucIRuuKR5nMPJAoNzMChzIAM4+ybpg8lp3RKgzMRc08MbyD2dtVtGjA4KdIGvs872AC6nkiphHIjMEfVHKEQsFW5SC5ZIaoR5isrs45a8yu/5tPrMGqjoAqJ1CJ89NNQ0xJRC5RlWqYCSSkBAAN+iI0aj618LowPZCEa+gcceNBTTfU1dCPcDo9lX+zcUPXFVpU3WtVVYVXznIEGOqAIeDZXpWpdEW5GY/Tk1hVYT86GuNU71KDQoLOKmLUQ9rQRHAESIqESLCETOsETMKcTVg2Psmc++6BfyTMNzAC1UPNbx5Uloe8lUVMid+9tb+CS4DY4zZDL/0QOz9ggotwAOpnVWRFBPq9VufCMuVwOueyj6jiierKuABuhERCWvxIQDsSgkiypLCMQLXVtLueHAkupLd9SL8RKME5JZQyj2JYtCEThGI7hZFPWVEfVZaEmU1JWsBTzampWgPDBHMBBFFzpB3q2aIHVnn4WaB0yeP9xPv4LC8IDWSNqWZtVaiGhEoxHa3UCJ1hBFa5uka4HErqSqaKIPL3DtH6A4dw1EU+zbc9W9zDJXauvIi3pbtWgPL+DDegXoiKqDuigm7YM0JjLO+I1ECqBIxJp1aLESQxWe0SnD3Rx1hiwcqtqP/lT1yAgwcrETHrNAoOtc0+pfqSRAzeADv/QLUIj1FRpsFIOE0MDi3Y5hWZbdYDqwRykIQhcKQdoOFeBF3jTNTSxMAsP0gmwQAyMkzzcYG+rqA+eNmqht2ohgiNu4hR8wkYkxFvq618ywRIkgXv9tlyw1Q3YYA26I+V+AG7N1VyfL33bl33PmOO+7MquQAwsSQfsTOTQgIvXoGxx1AcAbfvKgAfyowwA4RII9hJqkQDxiE9FR5Kcyr+2NG5/EQUCcXwkNi0nmH4qGGOP0X36QgA0cAMFIxoD4E0KIAHGobACU4R/A3YXT/FgAx1V1oJSWLDKoQhbeB8eSxYaYAMcoIZzIIchDnh/Fgj+McqoYPTCQAzE4EfbYIj/QUqkjhgRGtcR3HN6QaFbrNcVJkYXcsEW2PR6T6FgEreKDfhrzeUOgLSLv9i0IO4GEtEl0Vht17mdbYD61MKSrkz6ng/72EAmAeeGAM076oPL8sMM9iASOMJBisqoKKFJnKQr9xRs+0sNkHOqHvYBITACJVlz167X3GST3YcACEAAmlEEAWCkYUaTDQBVO3WDIhSwAKtCzRGDOEVVZXk6/CGbJOEjL6Bna/iGe/nkPDOzqIAKvKCYkzkOlHmK9GAPjLhZo5VaqdZ4NoJgSgEVfgIWXiEpdKQUSEEjOKITqlhPwTYPglRbt1Xfxk/hULMGWqBK6bb6wjAMX5KezJXL/4DWy3AACJS2z+73funAWGtlaZGrOx4KPACBoAv6KaBCoQ3w1ToGo+qgW+1zLB+WEEeywjgpLeeyQO/iq5CxAAjgc4UtfjSbAa4mQj9FhGP3MG8QxkLYB2X5HFjFOuwAVnJal23YlxHuH3/4PIZaiN0ApH7bi/rgkAMBapO4ai+hQaa5FHqiRmYBq2GiQrjaQb7aa5NKi/dgiPNZW8vAOcV3/MrYjN164VTu+haOvH9ARV9Uy0Suz44V5vL3z5L2O/gMPPraDBAtgOuLIzKGALOH616tqZyKvnXIYVGyss8Oc/GHdD/pTPaisy8w2BwV7gbLlE97hFNWtTVcNwDzav+qgx5EwVoqjIbh9m2LFpiB2QmMWQzagMV9G6SMekyVurgBFxEUYWqlV3qV+yZUQUauGhaQ4hVaIbq1RSMywqs7hyu4Ir+cVT6xe4oyyg2Kqwxu7obOd67Pe/awnMu8cL0RDkfDyVjpW7D9efvyeHBdTg32ABIEGLGN6qgKORH4VIqOFKJ1qPpMsgktLFbODn8gYMHTJ0ANAMIHHbRDuwFC2LRNuXU3/AYfSGtgrDqsgQ+CAFY2gIbTua4bUreNuTyGWIhDqg+mSKmPGGqbWomluYmVAhZmoRZsQU21WchRgciDp6urWJAVelod92/nM3TonJy11YsBB7XO23yzfIz/X5LLXy94+xFZ2Cm4yBo8AE08/ozMR47kMGoNyiAPHKHNQSFjBhmPGskrFVajGLgfJRsQBVHP0zJzK5btzgTCk/EtDaDYFsCU8d01WjfDL2UcctCVY5e1s4kXyEAIQqADIMB3bZtnd5gKe/iHXbw8QD0PRH3Gi/tZ9UtqI8F4Uh0nfuLVdaEXfGHkfUEXtBkockRCqOLIMwHXvwISYB4+D2HmoXZ0+jWw5VtwbBPZed58cdTkYm8+sizncvQ7xnzai2tpwYNwXS7PzuAM8kBg62uRcv1JCtnJIYl7NIqS/KY0IbaqIPCyF5ySOfcYL7mzLzYB8h3f9911+/3fuY21/1kV3c6BHmiVDHogBLRD4Wv4CnPgCqlw9HT7hyW+qEOK4p1XPuVczjVeejNGE+bL423BFnSB5IHh8odhGEpem3GEKYxEEyyBkBtXEUgf5qm1cRmBEeT8b1UxuiQK5+vDtBROy3ve538e4YTlH5fg2TOrn7uDz2gS5ghXTvnv6eugETpCgBcXEhipAAE3F7vHi9dgcgX1YSEWAiusz8eEqwK07eTdfdwkpgGTlBed0c0xB80h7lkbMoRjHebhGCYLfOoyvd2GhnUa8IUZJztd4oPbixJ/TwFCUaJEjRxForRJ0yVNnkapcmXrlq5dvnwBu4jRl65ZrEyRGgWqE6dMlv8gGYyEEiWkSJcqWXppSZKkSI4aJUIUCJDOPXfq0FFjpoxQIUJ8+OiBNKlSHkl/OP1hJapULFiWQIniheqVrVfMmFEDFiiasWDp0EmDdo3aNXV6lPF6p1FDkJ44tawUieGpVaMiIRqIM5AePXAKs1FzBQgOGy0Ys3gcwoNkDxsuXJgw4YFmBgwWLEgAOoGB0aQLFCCA2nSBcqzRuUZXDp26dOjGsY6d7vbtcbzHkfv9+9w5c8SJAxeOXPi6dbDPrQMnigwaICEgOMihI4f2HEWKcC+SpEkTKlSoihHTJn16N3Ha5+nTZw+gQIEK/RWYSJHBSwkXNnwY0S0UVQSML73/6JLLLLPAwgopnYSkSSYkVVLJJRZeaKEnnnTCIScRtuRITYgUQh8gPPVkllBlEFWUUkrZkJQPLAohlVRXYHEVVlxx5VWPXqHBBhpeqXHWGmilsRZRZdCBRh2JgFIKXRZS2MkpwihziyeNbHkTfYINBsdhiS22mGMshICmZBtUhllmDjzA2QIKgEZaaaehhqduutm2G2+76dmnbcANOmhy59SDTz3u6INOPfNEY0cZalkhxHfbbdcdeOJNkdV5YrDBRhvstRdHHu/50YeXhQw0UEErVagQJ6CMUooqrCyooC261lLLK6+0AmwrqHhEykcggYJssiNJyKwlFEZiUiOI/4wYyB55WOsTGmcMRdRRNdBAw7fgjkuDDeaea+4PLDpFY4013qgGVWBh8dVaa5VlVr51rGEWGnTgIYisoHiy0CWcmOILNNAoQwqX09Knxx13FGakFUD0YIMONkCWZmSUXQZByNY54NlnoZVGgAGm4WkaoC6X49vL6eTWJ6HIBWfoPfr0w+g468wjCxlmoCVEEUgk0d2l33UX3njlYeHpeqSa+p4eflxd37R/uRpJhZUwRKutuOaiC4EFVoR2RbfcYsssrqiiyilyj3LsSB1m8ixKNXWpk4l5oLitV5QixUMNPPBgQw2KK44ujDGqS5QVZth4o7xhXa6GvfcSma9Zav/R4ZNZeARySV2gyNpJK81Mo800pYRoU5fx3QFmxUL8AITGLbSwwgpoerymZSI74EBnJc9Jp52qFTDza+iko045M08PW2zVsza99Nf3+adrt6GjT/j3oHMOPdXwQQYdgudwRBNIe4dppkk07YUTTkD9aahtkOreYIP54SX6TGtLK2GJrEpxioe4Yha2oMgwiGEMYkhwGBQskC7Y5ja4yS1KxwpJsjqhCZjgJVojKgSJdpIHn9TBDUIqAxSgUJSjIOVci6uB45DiA8ixyEaWi1cPsaC5tfzEK53TV+iYtIdKlCJZoIAFNLyhjWaAwhIhcoQiDEGIQPjBan2IWB2AYoX/xOjgBi2ATO+AF7wLDI94xDNeaJKnMtPAAx7veAc72DFH6Kmjju+Ynh/VAcjpzaaOtKGNa5r3PD+m4x37CF870BGOefDCDmbxShl+kAP3wU87N4jf/JJABfvdz1PnUY+o4lAYiQ1mD6zcA33sU5D9eGJWtbIVLGZBNl8M42y6QFDbFiQsYiEwbqXg4ChI8cEIKQQvNOHSTUyYE2ux8m91CFJQyhCFKETldkR5ilNyyK5ttiuMWLgcVc5ZziB+7iecK2Ln6oCGMgDiErQaRSdIkQxvTIMVekOJIq6YRS91sSdr+MoVLEbGMraABr5T05rSGDIHWIcznZkT8kQTx3po/9Qd7tCoouYI0pDSER7xCOk75hiPlIK0jiDd4xxZGo997IMf7QhHOLDxCEqiQQ1viUImkcbJGwi1k0pLgg6OCgRR2s9pXgiDGC5XB4n15A6snM+qENGIrjFkVrQyBSsgcou0oQ1BuchFLWDxK1SgghVsVYUpilkKY4GEQyJZJl5CFC2blBCagZhdHf4m1RWywQ1BGksLo/DCKAjFKzsqZ7wwV042BLFz7XSnWaL6FjQAohSmAAUpREGKYczCEpGwCUoW8U8sEoJEffUiG/aFmDEmlHdpooxDhSeyBxSPMwrg7ckMgI971EO4wyVuSo8rD5WS9B4lvQdzU+pcnYVPHv/y0Ad1T0pdeFB3ZzNVRzjEEQwyUJJI2bzk/II6VKEqLQdCPap7j/qd8HghKltRw2BZ6AaJXas+gfiLQb62Ic96FaxlswgwdinWXiTolq5ga1tN4VZTvJVux+ygJ2KlkLtAS2+KmJYJ+RrNVppKqncAFVnUkAYfWk5eLLZCZCUrxMq6sw5HrANR/oUJXaBiFKLAhCUYYRBFFCIli0AtFrukxYhJ9TBWOOpQeee73wHPMpbBDAQ0Ayc4MUABFw2fl70cXY2GubjRLbOZv/zl6qKZu/qoaTYwEYR8mSEKSyAKUNG73u3cwMnpbS/TqAAEqZTBsGYAUn7fA4hU1Uc/LKn/0INqtUAGkq2XBxKrLnSFQQb+UkGuaDAr4PZpYnLQWMjikCbsqpJoCcTDrM2JTuBjrcAStg2GTY9hweAFMODaC0AaCxvyJeMi0rhzQljSGfBgDIZxiCQ0sSIlKJGSmvzzmSHug8TqgIWo6GAJ7N3dGaPs0DReJjNYpqjJ9CFTmaJbH/nAh7vfrY/h6sO54duHdMXn7kY28sv7BvM9+uGP8YnDGWQIgpDM8AMmPMHOSVgvUR3OZ6G2oL3cCQ8QLg4ExV6z0IOlanzg01+C0CQSmZBV2CKdq1ymrZe5WNvadAXzTLttgQ3WIFyLaawNccJDdqXQCKXd4b2ytpUivkN7/9wwKqSzEAxooLVhfW1ZIwrbJz1YQ/rsIAptKMMUnSg5MxtxiWdDu9nSpvZ8BiomIECB2wnt3RnT9NDKVDkz5KbonPiB97z/wx/96Ec+/t5udwtXuma+x7vdrQ98JH7xwVV84/HRd3/gA2grOIJkgyIFGEIhaQ5X76WG+t7QJ9UJifVCrg3bcY8n2qqrUkRBuuYfKMnNVl9loIB2ccFLuy1XMLdFLXalIFgwKNRvLZYpKGxPUy8rJpKAhEmaD4mCAGZVXjLRTohuKj3kwQ3r4f7Tdf30sVA2c8M2Io17kgY84IEPeFAGOJThCrjOChSVoAQzo+WIREAzPnsY6BcPCv8ETtFtURZlkRF3cmdlIbMZWwYa/hA+eccPewd4f/duxFV4zuVRiHJ4G8iBfdcP9tANgrACNHB5ZcAFLwQFd5Zn6zVGoSd6F2cV2YQVhVZoQBJVVHUt8lEf9gFLjgAJFbJzs0Q3w6RAneZpttJpvDcLtaAgTThzDyZhcEMsc1VqHkISlnCFzgItsLMlH2ZC1KIT9AEffWAqcYB0eWCGSOd0oFJYB9c5a3FElyUxZuAT6ocHmOAN7zcLpwASo2AXKPEsVSQt1AJyWzQx8XIFiIVJbQdlcLcBHsABHDB3bbKActIP4KMPeucPgUeBgneBZqZRHLiBHuVufJcP9rAMQUD/AyGAFl5RBSh4XkrzcJdSBC7oghi3BFaRWCryFpnzWnfgBlGVg32welnzTyhBCbFHYaRQTHLDjMyYQLXnhLc0jcLnaaywVsMiYfbUQcgyEqeGhRHiNZWwEn9BEA7jhSSCKvCBhlSDhkpXfuz0FXQwWZaFFv+yfnjQCaVwCZHACXw4K5xQIf3YNXrTCALBWuqIdmsgJFFwO93mbeD2iJGIgBOAWwsoDfRADu2QiXjnD/vgboHniZ8YXaJ4eBn4bnxnD/MAZyvgAUMTFFDwBDCkSbI4i9pRi7b4grnIIleBTb3oi/D0i3eQg/23g/bxT4oAiP4xS55lTFxVTBD2Va4g/3yatmnCBwueNnxeJWEcxEQg9BIj4SEX0jWww4V6RSIldDXr6I5o2B49EY+cozlx+IZpUAZUtX5k0AEesAJ0QE8D4yEXBit5YxLPRC19dW3AGE9rx16zBW4hEIkcIHdUNgFXpmWPcA3fdQ//4JEgeXjzdlzR1Q4keYEeVWb1sInzYA12QAMe0AEqkk0wJATzw3krmCm3mTS4+Uk/kIu5eBXzBS9g8Vq+ll9UxUp94AcfRgirpR8hAnuc0JTdiCxDGIVTyXu6EnzCdysc0REShgpwhXyzwiGjkAmd4AmWMCXM5Jz5tyUdVgj/ZEKospZj6I5wSWOEdV+gohavRWPxqP8+aCExdsgDtlUDiHBhO7dzmrBz6Qlte2MTJ8QTf6WYLoRJi7g7LfA7kflQF1CRlhkEotAN5sAO7fAP/yBTiWJ488Zcy+Vco1maGQijYxYP/JAP84ALqtgBECAUsVlnP0CbmxQ/m4SbQ8o089ObvokV5HQ5bHAGhhZVrYScO7ic71lFjgArO8dETHRMnBVhttSEMFeNWDkspPBWCAQScsUh56mgeZFhFgJ70XeOAvFPI7KOADSfbWmfhIV0+rkGr2UvnTM0a3AHamAtZdADGwABa7ICgOAJSxSEHoKgy9SgNIGQfdV/ESoka8eYbRcCKIACkRhuk0lu4PIL3xAO9bD/D/+gomUmD85VUsoFXaRJkilFo94gCOCSozvqBBfHcLVJi5v0PuDxo7T5SUmgQ1aRa/R1TmBRBk1KB8FIlHmgB1EaCMuZNdOSCP+1EArKc1g6ncx4TGS6Vg1GjQrChFi5ILAALMV3fPVULHQznafDEKc2JW7anrFkRUKmRVhzp6YyTdS0QnsKY/XYL24wOXdgBmxwBz3AAhDAoRfgAXrwCRNLsZxAsXVBrxVikPrHXybSE/EEBoqYA7vzGJ6KAnB3WyDTAR0QBM4wD+YAcNaFgWSWUu/QDu9wXDkbmqS5sx/IDHbAAx2wAQ6gq0BQZ0JQk7SIk+DhHcT6SUVarMbq/xS+mWtQYAVZAQZXkGtC0aT3ZYal0kUA1FfzYYz5lxIH0TUDeWqc8CAPMiviOq7oilbnigqtwAqvsGOj0K7E4lnkSReBiWoK0WwH+XqOMCJqua9XA2uxdm0By4YwhmJIEhZncAbX9AMJGwVmMIKICgGY4QGB8AmnQLGf0JSnk6AFE203wTfxAU+0FrINl1AleyaRYYAVuQErEASYAA72kA/+wJkRaIr9AIHDS7wRWKIlyg/+oLzLu7w1Og+iQEkrIgReEAXkIZO9iilPq5vB6rTByjRLMD+bMgWcEgZh0AVNJQbcJypIVypgG6VeuGj/dBIHIXYIsQme8AlZ+q3MWP8rDvY2bqMrncZWXkU3qtC3EuIgMSEh54mFmeAIJOF8JdF8h3AIrtIIFNw3q/dqVGMtVMN97EFYmNNCZ8Ak34cGTOcvQHGoCOgANuAIGbYJ0KkhPKcQy9RMHhZiPeGnB3VUjFFGLHCyknmAahQyF7ACPGAHqUAPvPu7yet3+QBwHijFU9x3E2jFV7yS0CAIdmAHRNEDV+AEVNAET1Bn4Puj8qO9RYrGmuK0wioe4jsFXdAF5Vu+pjQqUzOtWJOOiJCU/1RkZ/tsCwGdyLK2dDV/4fpWEjbAEOZZpEASyCIJguAIWEjJ4egJmSAJVITJjZDJLwEJjNAI0VcTjEDBhZD/wa/WwWTowUoXwmGBBbpWBSgcfif8dGQgBCEAsZbhABdgBY6AoKDwCdBJuhibsc2EHxBKYkymGDZQJhzjAZD5MUR8u7hrB7/Au/0wU+n2d/bAzd3szd9sD/QgzvQwD+U8D+AADlBkDdQgDdFwDKlgB3hABz0gBDVQI0catUAlrGl8m8QqHsW6z2/sPpsyx3QcNVJzx9KKnPABQCY0pYVACIbQx4yWtgsBEzBRnhyyv7SCLJlQanFVEo1gCYBAwY4gCImQBy98CZN8CM2XCZ/cyc0XSxXMCKR8CKZ8yolmKqpchqx8GPPyyrom1Ewny0J9BkKgBkJwqJZRGQ6wAWYQ/wl0IzCzVBeBOZY/BzsjkmjTGjFMZjEXZy5lJGVCTGVmcAc0wLJ2sAzjvA7i8A3f4A3bkA3r3M7OsAzLEAzB8AuyIAupkAqi0GOY8AiPIAh8wMVcXHBBoIo0QAbihQZGUQMYZ7S+mc/esc9n3M9I0zT53DTu80niK8ec0lROZUpS0x56UCrTytAB9ErLeR+vRyEXHRMvISF2Qxd9GBKeIAkf8RKHYAkX3AiAoAmRkAdoMNw0gQc1TUWTXBKQINONAMo1TcGHoMF9w9NUc3RK99OIONTd7d0rwlNm0AO2tQEr6wFlEAlygywaoiEDoyHFXJB702pbFCaICICLIdaQIf/ElaEHUFDeHUAGfCAKglDYiK3Y4OKSK6vgC76yEMDgD87gNBDPQuEDjyHZGBceUdu0nL3PAa1JmtIEUyDQI07iWYE/+ZM/oDIqCks7g0GMYxiGO4itr5e2L5E3tC0hXYfJXdcJknAIvswJMdEIdUDdgVAGeUAHiJAXjQAKkQAIODFAJuGDkSAJNeF8W2LT1E3ggrATeOCO2b2+QL0V3R3LYFAFZS7Ug5YGZpHUPEADS7J+h9AJEEZhTDSxVd1zd/Wg0LRFhPHTYmAxusMCP+yIviNRHkAHNMADDh5RxNMAje7oDeDobNQAjz4ybCRRmM5G7FI4GMMCko1UQPDPnM3/2aP+2R/+xqE9vqveNOMr0PczSqSU4m4QJiRmnP7af1Z1rc3pfBFMmM4NEybxElXuCIdgQMWOB4BAwl68JMEdCJqACPNxCEBGIVm1hTURyiYh3YdA4Nze5R1chmnIfSqGBVeA5kN95t6NBmtwl3sQCcJgDPGebMqgDKIFrh1ksXfOc1OysfkRGPTNBvXNw+hC6JKxAiHjAWrQA49+AJXu8A8P8RFf6Q3v8AvQAJ5R6SVzABZfAz3gAzawAuZSA930AzmpA28ctaZerCE+0AMt4uG76jHP6iEe81SQBEqFTif+uP15g1NlnLmuaPZxjlV0tqUF3NLNCJAgyYeAVfQh/y1nsAd0UAY1sCSGQ890wKgeZhPSZxCi7Ag13evQPd0UzOUmon5t+Y7jLubnLtRsr2s/UAdmwBOAcAv0bvfN0AzKQAwNUufAPLp4Dt81YUXUYojXtgbZ9l5mgiYhEwKREAUNcAAO0PAiQ/nWIfERr/EHoPmbz/kNHwIYiiYssAI14BRFUPI5Gb7DOuK0SfMiLtCuHvOtv+ruM75dINA3L0pUYT/mcR4//bhSBa3RmoOsZ47/5CqvEn2CYNOgfAh7QOB5YMp7UAhlUAdCoThkUAPn/S1qEFXzcQcCVECfLNLin+3QneXU3Td74OXhboai0gbmZO7e7fa6BhRsUQd70P8IyZYMd4/3vuAK4AoQoEB9IljQkydOCDVdqhQpkiOIihIhCuSnTx89eu6wUXPFihUgOmy0YFGSTqFPeiA4YLCAZYgQLFawoBHCw02cHXTu3AnB58+fGy5AuHBhw4obOoAA8dHDx48fQpAUoapDR5IkTbRu3TqlCVawX8EmKTK2yZQuXMVm7dqlC5UmTuRiEVMXy10xbNi4YXMnY8Y+fgLtIbynD6A+hAEFKoQIUSNHkCRLspRJk6ZKlyA1YnToUKNGkBwHCpQHzeMoUYSgMVOjTBQ3bsz0qJGnR6AzZQoF2vw4UWRJjEJv7uxZkGdAyQERztM8TpzYsduoUXP3Lhj/7Nm1b2edZk0aNGjolFKmLJn5Zs2eKfPFalQnTpcuFfzE6bJ9hg0fQmyUaDegv+7YaA0zrBDCQJFIYiEEUDjxQwcOLuCAAQYeCKGGFS6sCSYOYcLpQw82EHFEEjf4kIakdMChB6d+eOIJJKZKQoetwtLKq7O+Koutr2rEqiu0phBySCKFdIsKKpywri4m69KLLwH/0iOw5gxbrJDdSMOyEM9Ck0QSSCS5JD5NICnOs80AeQwQNNy4o47DyqChhg2i8CAEKOrwAIIahKijhjscQaSQSBIBzRHOGIlMMtAOEQQQQSJVbg88mssDOunamI46TrfzVDs01LDCjDTMQIMM/0aGSYaYZJJJr5lW2wOlk04uGcggThLCr5KGHHmovywD60NAjgos0IoESwpEQB+AaOGCEFYSYsMaarDBBmuztYEGmmjatiRwaVhh3AxDWMGDFVqwIQerdLjhhqeOOAKJI3bUaiy2cLyXqrP0FRJIt9DqosggjXTLCyqWbNLJJ+GA400BI85DscQA2W1LxzwTLjJLOu64E0sSZQSQ0BBZblkhyughkTvm7EFcCELs4YcQfKgBijLKoKgQRBFh5OdDfma0uEchTY5SPCq9NNM2wqPOOjU+lRoMY0ulI2dQjGG11fTOS6a99zoRaGxQEEIIP4YocQjRiUgLBDEB61iDOv8zzBDCh2ttuFqINYBAQYehQthjhRp4KNwHxBNH3Aa8r13cBhzyxrYFwkkKoYUbWshhc3fh/SEHeevdEd8f1SLrR397PCtgglt3K4wwvFiYSb2efO7huOvQnbA+SLsSS8dAE/5Qjz/mJORGzdyNDvF+sNsMH3AyEYINHIj5wqjcyBIQXkFTlJHNvPfM0UcfRTrpO5xjelPrsJC6Ck9zrrtUNa7GwxatkeE6GWT0B9uTUYyCbAQpW652VQm1PaRtgwoERt7EBrkVSAg/QNxz4qAkJ0TrAoEQArp4QAMWSQ5xPZBcCfPWAhRqLgc3QAEKM5eDxFkFKpvLAVWWcEOqkE7/h2SpkY+yMqQmDIxgNzIS7LwAuzCIQVNLbENsLNgXPTgMDhmxVGAYs6VEZPFQjwjTlyrTCU2A0RKQgIhwDrEY29SANhu41rh8soAFxMwnNaBgyt5Uhx7kQTSO+ZnIgHZGSBUtaUmzFKaiwxdOUed98NNOzuiQBkjWDQ1BsIQvhrE1WPEPGcYYxiwC+MmyEXAgCpGPfHilwCxSZDl7iJjc1JCGjwBBD1QQgxN00AKY+GFwHuTB3YTwS2AKgUUsaooPhJDCGtBAmdWqAeZWuDli+qBdn6NhEW64BKqMLoej+1FZxNLD1blFiP9qncFgJ4YkMlFTTnyORhwmIDiw4SKA//EDlhijxUMx4hGU6VgmMkGrMGpijMdpBCDusIcfmAgmLfCAA+J4AIiaqAHUC1EUaHaSPRQii2Xc2B+LlhxJAYIPSdtDIQ2JyEQucjuOrBuBykAHHpSBFflrVU31p4xh2MIUARRIQcimEE2gTW2IAg0DA6GR3H3nIxcRg7taoAdF9MFczHxXEX5JhijkLGfi0V2VGIMIX1VCE54ARSlOAYo4RCEHaoTKD5QSEh088wdLEAI2s6nDe2nFm2oh4uvCME4iCkyIXUAik9S5Tgve4Z1s0IEV4OCGwPihnvbUqCKG94h9fkkSmPgnrQQCMkFwZg91aJmIPMACHThgAC5xgP8DDiAU60FgXGZYgRDMUBqTPcYRQPtZZwoB0kiFVKR4KOmllhYdjqQUO1VgbnMZmR2tloFvpUpDMhnhC2JszTw1bZUxbOEeAd5qgAfR1WUuMdRfTWQ3hvkLHL6zBjeAAQpR6MMnVhEJQPzGIZTYBCcEMgqzqsIVrpjFLW6xC18IQxjGYHB5HJweaChjF174gWpmBpV2WWVzc4UCFJaAlbuWDpw8utE3+0VY2LEuSOL0axjAYNjDuuGJbIDDDRIAAAAUAAVO0INkGXPFx1gWEYfAAx/4YAcy2EEQj6BVk8GIqOXA9CbVC8EFEnAACLikAS7RsgdwCZODHnQPJINMaIL/prEzje+jR7tUHJrjRL4kNzzLZW6HodBcL1Qhz2WwGxpSNj810oAUxCjGMpjBDJv2r1W6QAVPCcjTsh0k0ubVT3oT4TY/ZMRheggEHgRhiVLcQsG7UHCphTEMVKc61cRANatXTQwGx9oYroIGNDbhLIbSUNc5IEsOu3nXvJYYLPbiyg+HxGIUB0zZSOyCF0wVKjXUTi/Rrl0c9PAGA+BY2wBIgArE4AdFhNtQjBhMIRohCD6QYScrCAIfIOFZUgC4E5BIzhmCQIYVbBmiXHZAAgKwWixj2UQroIMQzrAlPwovzeNz1KSao4dCHtINTUMDduZchdREwQsb98IVOu6F/+jKD5IesMEPJKEMZzgjGsFgeTCO0fJjMOMXosCEQxZxEE9cBoyeOGUjKCGZSDAqi75jQxze8IYpJsITCL5krFX9dKhf8pLZnXp2sxvrVtVaGHpw17iyuetej64J2eQm6rpCbK64DtkDW3sXMP5sTiU3kdR5gx4esG0cB+ABI+CAHggxqDGr6Q59iJQddAIBndBAJzywBCcAfNZRaKIRRA5CDxQagg00oAGuhWgDsOwAEdnWDHQIjaH4wwg+YvaPDP8o7+apvkNSHAwXj0KHNd7xu1zhCnUzQ3RJRYOn0EEW1sjGNaIhDeRXAxvb6AY4vgEOZ6QCE5aIRM4FIunLRP8iM5CojCQqAYm1+eeof/mDITZxili7ehicVH/Un071qludwTVNDyic0ATKrYDsVNlcEfp/V7IbNtTBkSkQsbQbp2NjMYNZwPkyAzWYm7mbNk7RAyMQALwDAAaQgAzIACewtvRZjjrIg5EyPM1rgJ1ogAA4AAfwADdwBFAIL/vQhEhohECYCEGhgx/wgAMYgAE4AM2ToxDIg4shlOCJDIiIBMx6hN5iuIZTjop4veNimvCoODCovQ7jODDAgivAgrrRqjM4g9+jgR8gA0nwBnqwB3qohzTEh3rAh3voB3xYh2+QBlnABEwYhYMIr7LpGEkYBVzwhVQQBczgFbahiIr/CARDsC9asLqrYzBGfMRhsKT3e0T5M4b+6Z9mIIY98AL8GxckALH9+z9fOx0BJLF7McXA6pdyCiIE1AooqJu5o47akcU5mIAACIBtIwAJeAAKGIEbcAIxW4PAIwN1K0HE6wAU/Dce9MEaSAT5MK+D8JhLsAT5aIQ6iIJo2YCYQZcaeJuMKgQ60C2HICMklAQl1KfOWD1JwRLJwghLicKm0RQq9ILUoEeN073dy6qc+UI+q5YxtINgmAd6WMN90AeD1Ad+eIdwMAdwWAZR6MN4Gxv/opVYcJVnWAZciDyGgIhCRARFUMRVcDVKhL9VK4ZhKIbsKgaVVElK3CRLVDRl/zAFIQCDIqCcEPhEHRpFtiAdtPsRA0y7VFRFHEFAHEkN+Xm2Z9MLNKCxN/A3XMRFAYgABrAAC+AAIMCCPDiDHviOMiCDIEDGEtSJZAwADniAAlhGH6QBRUCgMvEEf+oEyxAb+DiEM7iJFSgDPCADkRIp4liUcYSEzMIswNQnJWS4LakIi7gIk5KOiaO4eaxHeryC1yCD5soN2qqWJHsEM7SHfehMeXgHftCHcSAHc6AHbAiGZeCFeCuFUSAITuiEUUiFZtAG2rQGZjirhQC/SuDISgCFVaCFVQgFQhtJkryklTxO5JQ/YnBJReMfQfilG8CQFdghsygdGwHFnTwLG//hq77KF38hwCHJuKNkDVOpHTeAAyUgAAG4RQvkxQjQAAogATGIAz3ZgBDoANlaAR/0vJ0YAADQO7N8gAowgAL4zxTMAcv6rFmBTYFQBdYEhUOggyA4KEDAAzoIms04BL/UD83iIsngonMcn8Nsx4tQTPVpoombQuywx4yzgpyhTObSqpqggSQLAlmYB3uoh3i4B334h30gB24ozW84BmegB284BlIABVJwTU4gBWDQBm8AB3CYh2kwhQKaxu+zBE0Yhd+khVAYBEK7RJREBuQsUzNlyexCBlhjMP1pFVS4N9oQl+nsER4hxbXIyevUTgP0in8hIiDRl7Zwiyj4CI//oxreW8o4gwMXIIACEID1JIAIeE8JoAAYGIM4uIIF0TydgKjO21RcHAALAAD1FIAEeIAFGIBb7EEHgILqe1BSKIVSeFVWMAVS8ARJAAS9hBThgIRMCBNL8D6HiATNAhPJKFbVKw57kqzENFH1gQ7HzA6Os8eQi64QqYEzsAM74ANqsId86NZupQdu2IZ5mAdnWIYzXIdsYIZXiDcCMgVgiFJr0IZ5gIYkJStOyISOAYVToAVh8NJBmAMyLYb+Sc7jBIZiAAaDPdNL7B825S5GoNEfkNMQeALuvM6sCEAQM52sMAtVHBggCaw+DVR6tALd8wIwkB8+24vwYAMXUIAE/zCABBAABqAACqDKEahULAACK5AJxWsAHuxBscw7WwwABjAAARgAASiAB5gAox2As4SAp7qEU5jaU1CFUyAFWo23TviZT2MESWgEfJXGoPtVc/ySyTDWwjwEx8gSZWXWpVmaZ604jjPKaeWzo7iBHsADbE0FHLUHNBzXbZhSa1gGcLCHdeCGdZgHZkCFUhgbVGgFaJBSb7AGYIC0e80ETvhNBVuFSZiDP/gFXghd0A1dXugF0+WFXCDd0DVd1m3dXkBYYGgG81BTk5wFMpigX0KcuSq2jT2dHBEx0jlFkAVUr6ghwkoLvkrAIdk4j3BRPkMDKyyDKWQDFHhZA1DPB/+IVAqIAAmQARxwAiAQg0laAQjgwRTcCVwEgAdggNWqgAF4ADGYAAUwABRAAUdFWh40AAcIg00wq7ICMFVQBVhwBQf1hF/tPvDhPktAlA5NQsH80D8alGQt0T5wDmeNjmddURaNgt67PZFLAzVAgzMgRjs4huK7BhTGhmygBmk4hmo4w3DgBnHwBm9IhsiLj1khhV4whlwQIPjwL1DA3FLg136dBDmQgzmA3V8ABtdt4tPthdIV3dHlhV8w3e06WFZrBKgwprt5iiVI3rXoF40Fse3kzlP0vyKYgr8SSuXlU8Ia1I84yuidQjTQgQlggAR42QkQ0F2UAA743qsEg6//RMH/bABxOYBbNACznIAJKIALuGM4WgAZIACkDYD75cEEmIAcyANbgVVTEDBXSNIXBBl/4j5JWBR+0qwP9dBVVsJwk+B2bEfYiz3HnLONo9uM473v4D0SfoRp0IZtsAZpsAZriAZmiIZxnYdr+IZvoOFpGIZIEwhRaLIXTAhJ01ci9lfPDYQzhV1vZmLT/eZfGOdv5p9lOIaDtYUauIGo6OJfQjs95ZGQFV6xK7GK7bVwMhhxKpIb8QIo+AjnzZna4+DwoAM2cIKm0kYG4AAUqAAJ+AAU4IAQwII7ewIa8DxUHQCxhEoV8LcEWIAbiJAHeAADaAGndFT2PNqzNIA4/4oCRyiFAA5gsVlQWtknPiwePlTlzCJWwHyEcFMEBvKxxNSD6HiOQ6JjuU2NVzwWgI6kLuzKMrADX6DNaHAGaaCGaFiGeNWGbNiGbcgGbbCGaYCGXRgFWyGFeEPrACKrWSkrIhaGLx0EQ8gi/iG046Rd5ITdYoA5lzsGv/7rlFuGcy4GTFiBHAACKPClCeKmrYBnM77THHnsAiyCIDKSBAyY1fkrHFkCgI4uowwPN9CdNugxQ8gDFvCyFnCBpHCCFvCCIuCBFegAiOLBBvhK/7RAmVWtASAARl4ARb6AW7Tko11PAaBkp6VkFWyD/oVVzAXiJvMYfzrgsFXlLirWnv+WjHA7TMTMtOiYZaQGA3ucr1j6CFI5yugSAkAYhmboH2aghnI1tKpmBr8OBiZOsMbVw1eFVVAa4lLjXEOIBErYLe6qqWUYcENjBsFmhpR7huOThmqohmtYPm9ovnmQXGvggxWwCv+LCiuYK1TcqzIONjNGRT0tmLZjnWTzin8m2eiyvdELQcNojEjQ10r4ATdYhDbog4nTniDYE83zwSAwPFRNXxzL5AdwVAMwAA7I6KNdrVt0CbT82QNYgA1og0gYE+eW5ukjW0kIWy4fVgd+4J/ekkJoW+OKuKaZvTlbrtcYVLkYFbtJmZBjgRYIBFfIhV5AhouMBiKdhmYo3Vr/eIVAh4VZcFBYfdDHO4UAOoVZ6O9PWARKYAgyumpqIGZLB2YallIpTWZO71u//XRQH9djyBAdkIENEwIPs06ONZ1i81NWTzuvwAoTXztmQzYqgGPJ5LM2l94QtJjH6E1VILUDE4ZICDc/yANI+UoH0FRs9dkh17ZbLIAKOFUOWIAn/7cFQGQV3MECKABE/rfg7kHB6c3/CqBpzgTK8PKcHtYGZuWfluAtsQjAgL14lEcq1CorePO6IQOBNkohGBca8ARTYBVDQ75leIZi8AWFnwVbmAVfEDVbcIVTOHSeYs19FQZl6NdPAPB7RaBImIfEpQeBHHmRL/lOH8g05NZ8/+gHlm/5fvjWb3iEDqCBUremX+qwsiudeSZxfp5nIvFOfab1wTqYjtM98zaVXpfxTHBrZZBdYxCGVTivQlAEzAoCCPhBbDW8HQxuA4X2kb7FHezBb9/6HjTf4LZktH+tPQCgF/wkUfAnfI1unP7yJLTun37lCRYWiDPq2Lv3nNk4J3BeISDGYBICnfAAPhiFZkDwaDg++QYGX9iFZtiFWWCFXNCFnDKGW5j4ADp0/jaGjF+FSP+sS9iES2AHemCHdVj9daAH1k/c13/9NORRfvCH2veHl//WeYiGwy8Cq0iCJfCBHMAmnzRFffnJPz02WCcnFRMSKmg26Bes432Lov/P9S4cPQrVKCF2hWFwMGG4BVoAhUpQhEKIlK+8+g44ssLLt1v8TwuE9k/N6K3f+nBv/6dkT2WMoxooBAD7JLi0DIDIJFCgpYKSDiKUBGkhQ0UOHSIqFCiQnz5+KubJmDEORzdu0IABU6ZMFS9eokQhI2Tljx4/VnaIueJVM2THgkmj5uwYsmHGoA2zlasXMV/GlCkTRqsUKVKgVLHahVTpJ1CjRnXy5GnTpnz57IENa48eWbJg15mbp5ZePn/8+Om7Fy4ct2z01IKLFSTICh1+/d7wsaRJksJNDiNGPGVx4sOMGzOe0mVxly5hciRZLLkyFSdUsHjxTMVLmDBeqKD/phLFJMooZcyUYXMnz55CjBxd8lSK1jBlxoTdmnXqE6RCffDg4bGhAwQ7jwQ9iv7ITocDAwJgxw5gO/cAAwYAGNDg+vfv1gsIIJC+gAECAwrAP5BgRR9OV0mVyt+pE6f+nEBpAslBDDHkiCOQOKJIIoo0oqBEgQCyRx8T9pGHR27EceFHXoABEhdQgAjFEyMewYQUTDAhBA08lEGHKNBY44wsOT0DTTO+NZMMMcQkkwwwyuRoTDK5iCLKKKzcIswuSmkSSX6kjAKKJ/2NhRc43oBzpTfaaGONNdVE40w00UwjDT1u8YNPPdIsE0wwzjiDTC98kHHEDU34BQQQOvwA/0VjhyUBmWZT/OnYoJRFtlgRm1XWxWlOOIGFpJGWZtpoJnEIxkmumYGGGxkBUkgjkFwCCpLC/LbLLKqcAgolxuWBBxkxdYCJrbdOF0QHGyxwQHbaBcDddQAc4Gt55RWgHgEEKMAAA+kRYMB3BhSwAARudFKKKVDtt58mmvSX0IALGWigQ400mAgigLC7R0UTWuhRRheiUe8ZZ5TGBRdSnIgEEvyiKEUNPQhBBx+9aEPNMc5YMw00Djfj8DPNNMMjUkAmAw0xo5Biy29aleIJKKecwlSUUjoDzjPHLANMMb0AA0wvM8fMiyyy4ILLL8GE048//nzlTDDHAMNMMsaQQv/HEy208JeeQKz0Z2FTC6pZ1ZpVRmgTmi1aWqMmQSqppGKQbSmmmKIEhWtosOHGHXsEkogjlYBSiiqz3LLLLauUDMolivixBx52BMFDEEWmkkqRua4QEwQNWJedAL8CEIB1x5r3ngDpPcAAegIosMB7BBzAwAEL1AAIJJyUAoolBGXCiSYFGYQQuQaii7uCh7Ab6rsV5hGHRhnWi0Ybx98bhr4mcqG8iWHUUEPBdmAyDThdUvOMM9BwT7GOPBp1ozLEUEzMK8RMo80uo5TyiSckm2JylMDAOPPMuvjiiy74+7KLLrDUYn/AWEY38tEPfIyFTTq6kTEOcQSmhcBpelr/SREMg5hAFWprg0oMog61tawVoQlekwzYIjW2sp3mbKvZFEpG0ik01GEPoRIVJF4HClKQDBSg4AQlAHcHPASBDEEQhCxS8QhMiCIVmCBcEGhAq8eVZ3LeMc8BKjfF65xnc836HAEeoAACFGAAE3CAA4q1gAaEADqYEEgnAtSJTNDOEgiJBB0RVC7cNYIRhQDEISJyEYzkoUJ60IOFQHKhNiRPX83DF7+qMLAfkGFwvPCGN2LkjBp1L2NASYYuhuGLohhjGL2BESWFwb5RkOwUplhlKa7iC2BMoxkz88UwdpG/W+qNFrTI2zCQ8Q179OMr85BGMHSBt1mMAg0tcEIL/1CgBCXoAAhLAJEQilDBxGTmUI/RoNU0OJlEVcZrIbTM17wgNjFgIQxiKM1pLnUSL1zhCmaYpxlAtDY21CEPbwsEIuQWiUp8S3aXiAQi9kCnwj3iF7jQVRAeIQlBMLFxtGoABByAuWoloDvYyVwADPCABCRLAJ1TQBittYAHUKtYEIgJHiQBx/0MhCBxNMjtEISuRvCuj4UoxEUoRCGMfMQNyLtX8ioVBn49QXo1IAMdziCIZkBjaM5gBlUnRjFoGEN/PDLGLvyni100A0vTaAUqUXkKVbDySbegxSymYYxRqAIr+7lEJSChiEKwAQ568IMcq8GWr4hDFoKYFQ9qcP+Dw94ABSgAghL29INpLoFqF9RmZRSzQW1SJpxhmExmvFap0IwtnaY5G9qiYAV50nMlQmjNa1ZSBk+5IYaBKEQiFuSQPvCBDnuxgyx4oauVeoAMfLADcWkgUQjQgAYQWIC0vlMA7Wxno98RwACclYAEDMAAE2gWtcZILeoO4ACO68AKGOHSbr1xILSDI00PZEdI5BQRiogIT//Y0z4QMg9Dvdd+K8WFJ9CgBjzowRnoQAZSICMV0WDTMpZBMWQgAxrJqFgtbmlMXRzFetqoBftap4oPays/pXCBDViwBmHAYQMh2MAGLuDiCkhAAgp4QAU4UAY7ROOv9liHNKxxDD7/hGAFN2hBiVnAgaflCQqDIUwGMTuorD05a41q1GaMys5LjdY0VjaNFbqM2nmqlppqG5gPXiKE19zhDnqwiEMYAQggksEOqYgFGVS84pjQgLhCdGIH+PK4BkDucuWx3Heyw6wE9KqLzvJcAhiwgAQEQIoHAHSfG9ABPqwxE+mN6etkKseFWGIhkWgEbR9C351K5Hf4tdDxWk3UooahCsbtQQ2gIIQn0CEVsqBGNpzR4AlPLBnIqJgucqELW/gCSEKCkTaSQQpMQOnDH07lKSSAgc6lYRU2gMAEuj2BBzxAAhR4AAVQgIM+PCIa6/DKjr+xDWkUgw89WAHTWBCCI3c5/8l+YrI3LYu1b2aWylVuApUbVSnNdgE1pMkyFdS5zkrFM570NEOX1WZrKJSBBTbwQZmFACJ8rtkPhWDQIQYbBDnHwg4eGHILVuCBmDzBDWcQ4smZA4HHdeAIEIgc5rqTHgMEYAHbZYB7IPCABQjAiuKZ9F4o2gHqwTSmcFQv7UC9kLrKbSHzRQTXUc1TCq2Z1YhUHlGNeobo1eAHP8gBFGhQPWpswxpUZQY0gl2TmvRCf7pQxjTw14xnaMMbz1AiJljBilVI+8MVKAEFjGwIYdwhBCVGwQhKAIITfIADOHiDIjpBDbYEMx/nEMc1vKGMApfB4z/wAZL9YkHDECqzG/9UzDcBbvAwMGrKltns7j+7cBSShmxkU4MasFB8eaphnlaAjWvK4GUssK0OdzCD9P2AiLlxAhOCMO7hRBEEB2TgAy4IgRBuzuIg02BwHQA0oINwiOHu/DrZ4Q79O8qAZgkgAZ17wLK+Q1Hk0gCgQcAKDJEodIvUcZpCKIRN5U6D2NWpTQRFgJ3wxAsi4UvzOI+J3EvqdRlhHAEfQAMlgYM1PAz3mKAJEkNv/AQ0KMktGEMzaMP1/MIrGEkp9A0neIILlIAMjIEO3AAlGEMgtMANFAEKwIAzsQAL4AAbFAImUMO6BVM9nAM7rMM8GMPM3YsQSA8UdNnTKIYFeRPAxR7/NzmZZhgVwm2ZwxmV8FWK8IkB8REfFiDfxJVBFKjNaRkf23jE8rGBHlxfJXSCJGACHtBAECARD1xABpSAC6CAEKxYM3HABXjAGRAic1gaHzwCHwyXrjTA/EWaFEWXACDA5DjLo22O5VCUpf2ZpdmBIAhipsUR1SHEpy0EuihCQ3QdqkngqgGPUF3gUCmPFDzBGYxEl3mGEJCBKHBJ+nAPkJRg91zMT7iVUriCLwBelixDkdTNVYSMC4jBGMDAkJXBJRgDIEyBDuSAE7CBDQSZFfiBIzyCNNhDW/QDO4zDOcyDN4gCGdyLStSAYIDIEkQTEGRGFxhKGGKWwInhoBwc/8JpVhq2oRu6YfGgwcTRoR1y4RXkoR6OBBrswR92AhKRgiRQj/d5gDeKwQ2IARDkgB40Uwu0GAe0QAi8nCFC1HC1oiCswHh4x+acYtJxBwEwlwIAHXVNmqWRAftZGh4cQqdx2uvQzgIKyLjYFC7m4k5J4CDBC6vhS3/F2hnAhjG6RiThQpGQICuUgitAQ1Iow5LozS2s1S3Y4CRMwimAlTVkSTIYYPzkxykowRgYgQyIAUdEAScoQyE0gR7EQR+0gQ/QwU45gihgAzD5Qz2GQ1osgx0wlRA9QQ/0wDQpWREQZEEexmQg5Gb8W+zpXu/t3u3dHkQ6nEQKH0Va5PIxH/9K4KEatI30RV8fyA0gYsIo7IIx5Mwr2AENOIEYOIEV6IEYtEAbrIBMosAHjMAITMAGrAAfiAImPIcdYFp0EM7OLUtILQtQVg57ZEd4AdoKBCD7XRojHKCnedqA2E4kvJfWmRoE+tRWCpWrvdoZ1EsUCIGeLIEQ7AUf0MAoIIUj1IAV7MYnQOgmfAJXDIeErsIkEMIn3EIuQEMMgsM0xIIokIIpsIIp/MEiTIIhTEIoTCgl0AI0lAJXsEp+zIIr7EIxgAMwBVM4YAM3bIP3zRwZjEgRQIFkVIGIYOTWlKZBBhyVeZNqQmTvWZmUSmkbtkFpyGbxhAQYSMrzaQpKAIH/FXQIHcTWHcRQqIyKJXTCKLgCqiiD0fRCJ1RCHpwBFMRBE1BBGzCNC5wADKjACNTYBtCAIBQJdyIRdwqCJvLBCjCXASDAsqiHFE2OFIXXpK3Azk1aBwgXI4BC1CEg1UWlHSUIgTxEftbXfQFPvHjE2N1LvaQeEOCAD/SA4fDAI0SFMJwCcy7CJ9DCIiyCIfiqii7CH/xBKNDlIkTCKEzDNFiDWmjDL4gCKrQCLOgSLQjDtS7JtXYoqggDUizJUTwDFPaDPYTDNbBJEBnYE1QBEyzB7oFBFVTBSNjhN5WGZOQelDGKZDTkasJmv/oe2WCB8HUISHCIpETcFbBQmA5s/5nWASDwUyLU0JrOgpsywzMsKzSgAh/wwB64QUsmoRLIwAmcwBBwAAq0QE0Sqq7JwnY+xyOIwiHMygKgR0ilB9FVTnR9xwBCDqXxgSuagqd+i6ZJXRxJpYGQaqk+BFba11ZqhIW8Gh2oQUVagWq9HA08gUPIzh/IASH46icQwhwM0q4Swh8AKyGY7T/NgjIAHl4wQyqQQipca9y66VH8hDb4RlKgylFAwzwY0LiuQzUwAymsgBAAqB1qEGnA60hUgbryXr1Oxmra62pOWZPyq7+yE6YA7Nh4wTzVITxpJMKeRIjogBVwCIBK39uEyiE0giR0AimownAqg5iQybImA/8qSMIeREEgJKEOyAARzMAJzKTJ2sAKrAAZYEIs/EIRbaetJKqfiQ6kLgt04WxM7GwDZOchZIsmsNengmpBQAId1VFDIK2ped3Xpeq8tBodqC8aFB/n0mQItIAb+MEgEYIcyMEfvMHXzgEhhMIiEIIhEAJXqNki6FIpDAOzgsNdDFMRIcVvyK0xQHDEaIOEdZUw+IQz8G0/jKs4SMOcrMBI1GEXJAGWdQEUxGvqQUHtac29LmRkZA0VTIEXOAo5eUGVTcFmLYZnpeHvmRNpuMammISYslCI5AAQQIEXlMEZuE1GwM0hMAIkZMKR0MIuIMMzkAk1TAMWOwwwHMIdrMD/Z+LAF3wBESjWEMKBFdgAD8zcI+ha4ihOohbXEXiAdSjLKXpi5lAUGbhiU8AOuGjvU3JaJQgyHdWV+BptJCRIg5QvqvaiUNFBHdAB+xLfPHWAB6gYChgCJRDCG2zB/crBGxDrH5yCMQwrXRoCHCSCIXzCKmxCKfCdN8wDWcyDNQTDKtjyKdjyLZ+CKwSHLzgMLJjCKszCKxTDNlDmV1iDKNTACrAvGKzTOqVQO6VNO1EBYlTzpUTZoKQGaoAGaDhBE3iGaIzGvjrkls2wDG9WFVQp7m0Gk60d272GbNCGw9KWI7gUKKACsk1Y3Y3JFS9rLDwCHdCAB3xABmQABWhA/wVUADs2Dg94gAfwQMquLBw7kR1cqsyGlHSRx7Eg5SE8gg71R+x4KgJawiCDr6iJ6h3pTiLo1E79UYXwp1DpYUVWpAvVCzyxAYSG8iAYQk//LyFQAiWgKF1Ggv9O6CZYKzDAIDjMA1jQwyZcguxQwrdMyX+Agoimwo3YwlO0wi9swzr4TD/QwzQs6gqok9iIDaZcs8KlxmFs82hc1jbh6WegNRaEjV17BqZU7kNKrtf0tWkuRhIQ6RIsAad4ivTJ0GzJjUuNAirMQvgwwyUt2LJCjDF0Qg1cQI2VwAdUwAfYQAsIgQeUQYDRZHYWKhwHkSUGGnkUi3UcpQAGAR8cAv8mWIV/cAJ6xRRXXMJuX0JQ+/Y/2WdK304e9dF8pRqqbsSqphkbsC9sAKgLzZNPf8IgzMGu+rQiUIIhhMIqfIKxboKvTkIr04IrHDAs08M8UgIkUIIgi8zIcMws7IItCAUyxFIysMw3sMPP5MM8HAMNhEAIhAFeR8rZVPNcb7OBv3U3aRBquHVqiA2kQDikbLPukfOUnSHkyl5pNkEOLIEVqA10R988z5bqqikpvEIuvFIxJEPFjok0RMMzTMwsMEIPqJi9sYAT3AAzQQGtDWENeMAK2IEkPEfPUodSAlprB5rTMcfT8QF8rqltp1d69Ydu6/Zu+/Z6V8JJi1od5RH/I9gWVkrgu+QXR6SZ+kYygBJjbKiBFcABHIytHAzCJNBCKMxBKk1ota5CKBjCKgiDr9ogWFEDLIOFLuUNLUGwCibD+EzMMmxP+lzDN9TDP4wrOGCCf3tAgN81gTd4gc+1Wl+zgi/GWzv4pES4hF/KQ1Z4lUqZ5OKrQRbBEhjxNLkGSpgBmebTHuC6IDxxJoCCKbRCK8RCLxQDMlQsNFwSjD+DMtTCIyRHC+RAH0BKHOgAHKijGPRBDYTAEWDC+wnCEjnO49ycUmYqrfSZHTACx0BJQHHCQGxaJkD1br+7lQe1IGc5+No7IucORKDaRVCEmGdEmkHy+jYVgLrBPKWB/x4swhz8wSCc6LDy+SrQAl2Ggp6v6CYc6yacwiz0wjI0K1gcBZBQTMhDlcOYIDMcQ2RHAzacAzoADT1Iw3Fa8tlc7miIIYK7E4PDsFxb81ubBKlHOGnJcGuiujk/ruSqptZQQYdPkBWgxGq9EBrQwR3gUx9cnyX8RyeIgimcODAgQzLA+NxFttE8GyC0wTf+gQy8gRK8wRjEQcvlgSkwQgek36w0zkrZnFLavdwzuSjkAiyUqEAELRvlNlfE+7sH9UzRDr0XMrmQr0S4tL/jeprdQSTTQYuoAR2YwRqw+cL/wRZsARGMgSForf0awRhvAdmqKIai6DuOQi9EA1PbA//I/90J1gjJP8wzUNXfVYM5oMO4zoMs8IUHQACmfJbC1byni3rOK7hbe0FioAaEo/Uzf9YZWi7v6d6gBAqhVBAVcKEVQA3TR0GfNN9roEEUwBDcyI0lrG4mZP2J+wKx/x2MvzhlDwMkxEER/IEYpL0Y/IGersAhAMQoQB46FAyxgoYHGis6QIDQAGLBDiuCVBQEa5iuWaw6acr0ESQnkJtIbrp0kuTJSiAttWxZ6SUkmZAiOVJ0U1EhnYUC+fHTp8+eoHmI3qFThw4dNXTWrPFhA8efP292gNgxaQ4OFG++7Pgyx9AnQn8IvTG0iCwoW8+sgZsHDS7cadqmQavbrK7/3WZxp1Ezhy+fPWuCgqzw4ACMF8WKqVDp8nhK5MiLKS9uLHkKlSabmzT2wrlzYypOsJRWHCZMZdRiULfu0hp2mMezIUvmnCTJ5iVAgFjx7dvHDyFQhAiJUubGjyho7uwJhGgPIEaSMokixcqXsWTMnD2L9mxa+GnNbjkqZAMLGzGFbhw81InOCsMbICCkIeQJw4YQJk4MYgdATHxJZphcbBmlE5AUHKmklC4x6ZIFXZqwkkoiuZCSmmzCCZGdevoJkD2IyuOOOkg0Cik6hGhBiUkMiYGIElTYYodFPvljiy2I+EIOQ+T4YxE43nBRj0hGIWYab+apKzy76GoyLr7q/3qGmnXssWeeY4IgYwWH0EiNMipQ60IyMj1bDDXLNosMNM6oqGwx0ko7UzTPYpPtsTtp25O2KXCLLIkfbtDhNyvMCO6HH4IbroUWkiuDjeboyAOQQxqRpJNRbtFlGGOYecY7aqaxRjxochmlkR5o2KOGEGiwpJMgFuIgBA5uWKgG/GigoaCKKrKDDz4eIWUYZTLKhZRRPFqQQZI4gRBCZi35iMIKK8kQEkc25NBDPwIR8Q4STSSRjhLpYMMMMYzYYcgZdiBCjjE+keOFHeMdSw5C0JrkjT9KOcWXZrQBZ5hOjQEGGF9sGeaWW2xxxZVdbmkllWSQieWYb6wEZxQ88P8oowcevkzTC8hmi+yxOkULDTQ2QxPtsze9gJkxmVGzWYyc8ZQtttfGnCLPMclsgkzMNovCit4K9Q2KKKKAoukyyjjuDDdMBCSQQhK5NJNOQCFFFVh8ISaZZprxTrxRxxOFjD1C2MCDRhjx4AKHFnAgBBw4uGAD+RiiyNf/HpHkFWMKnAWVZDui1pKVFGywwQinZemlCmeKhBJIcNockQ556imPPgABZESiwDW3jjuwuEKMOaSaY5AxdtjhBAtkyFGOQQaRipBADAklFFpoYcWYUUcBxRNPQNFEk1I8QcSSRg4RhA9GHkklmGjaWmcdeqI5hMQyhOhh5DSB7lMymhv/62xmKlyGGeaX66wZTZvDYG3noMd0TX88iza6CUmAwtJ8UxwDCgdqCaRaUurgnENYChIrAUUpXGGL7CAjGWgLDzWiQQ1o9AIUQZiIJQThgRt4wCEhAAIOsNAChZCBBv+xw6/sQIZDjKIXxvBFLRCnuExUjlmQK0mEMuGRaU2ocZWQCSWwFQmcFIJbOvlJIKi4ByuKCFwnusMW1WCFG8mBCFt4wyAWIYcTqOAPX/nDJCaxCBttghbC+MQnVCGMvbhxEZOgxCQu1Ac0AAIPZLCDIFKxjGxwYx3iMIc55jEPWdghfCErX2redL7aTCE0NZMfJnEzmjfFbzOiwaTKVIaF/5zpbE9CA9rPpsC/SzaBTUkowm4ImKgDGieBxCkDGchQBjQ0EBCFQAQjGAEJSXBiFKpwxS1y4Qtk7CUa0phGNMPzDGBggg+kOIQHAKGDC4SgBWJwARtyAAU88IEMQRCEIAA0yOrlghiHc4UpEGTEJGaiEid5UOQc9JEEtUQSMqmWtWYik80ponNS1MnoRndFEo1oi3RAgw108IYfWXQVwijjFj6BljxuYhKboMQqSvGJU3yiFLMwBjTy2MY2LmITftgDHyQhi2NYQ2PiCMdOzUGPeWjjEXgolxV4QL7WtM8LZcIMKUm5mU464ZOhXJ8opbo+N8mpNFjg0yWBViauYv8mlrP8jRkKaMDhNM1pUlMrL6V2hnI5pxAPLOYlPDGKU5iCFbXwxTGW4Yxo/PUZ0NgLM47BjFQM0gchYMIUiuCEOKygDXzAwyMwgYlHrPMRj+ADJgzXi1nAInH1/GHjppVPffIzWl3zyLIWZC3TXsJaB71JQh9YCKwFgqEiGpEVj+IGOBBiEn/40SdC4cZBwE4qLV1EJD6xiTmK9BRxnMQgDAFSRUTCEqMAhjOURI998IMd7BjHOMghjnWAAxfASkMafNAD8rGGMYr5X5lmlsn2iTIymnHCfjVTVccMTWaa3O+AB3w+lM0XZQdGMFc3o0CnPW0JifoBWgdoKDOYQa3/aS2DW/Owh3NWqhGRqIRIMoWKWPCiGNsBFVxA5QwO8kIUKqpCDkKwhCfQgHp8SMUxZJEKUVSWD4JohTKAkYtZvMIUyQKFSFxiLWY92Z+dkLImWvLDCkUiW+ZBhEE7pwiDcmiYDzyETqjI0BBdsYF9gMMnpisVORhBX2gB6e5s9IlVrIISu6DFJy5hUmEYghCJiASmejENt9DDHvngx6LjwQ5yuIMc6/gpOpkCBBsIoQZgANPMTjM0WEYmNVKt2WXy24QBBzA3dbINU5vAG94QGKyY2WqfioYnsObywVBYQoQn7LQKG0qtUzsOhs+ABjqQwa14CGYxi9k1Upi4F8Uw/xuL/2oNa3hQF5moQxRqUIMVnOGyj+BFMFKRClnIQhSCOEQukuELXdSiFaRQskhGe8+POA7KXUsQlbM1k0Y0AqEd8rISCzqTzcmNEYfoUJmzxpMzjy4PgSCEvnq0O0NQl7hn6SghSDKJT+yZEp+IRHTXiQleRAMcV7pSPfKRj368HB/1cEc+yOFTYGypDOy1QRAyDZswYdI2lKSTqktNYCDkpjO2aVNucJMEV7t6v7H26oEt+T+ixboJuczlEqDG9Sh4AWlWuMIVLGyG4jQNascJghCQ3WFAUO8Q08GEdVpRC2JoZy/hsYY2tEGqD3biEHRQJyYkQYpj8KLcPr5sJ/+AQQx3g5YUoABFJ+htCZXoM98gkfLmE5QJemdCn5cnaMENqjlFENNzPBEmFXELSEFQ6g5jGISLgrsI4LpRX8Irbh7zGJZTnJQWwZCGWxKND3/IQx/78Ec/Wt58enRvHuDARBCOML4e/IAHR9D0/VKTGTaBFTWZ6UJSYfnfooFGM01fEyeb3v7266AIRwcCZ2INhauvqWivRLrRoHb2BO7a17jOC8iOgMzOCvrPOMqgBnhgS+jADTqMDs7pEAanOl4BFuApg5xk76ytSZoBFg6h8ERBFoIBF3pM8TDBFIyhGBQGyUjBayjPyirkI4go8/SN8ziBE2BwBn/IJEDv8gr/iuAg4d+IKRG6LKFYz+GCaQ8IAQ5+ZBJC4RMM4Q+kcBEy6glpYRXY7Cw8zqR+T+XooR7wAR/0YdH4QR/qIbzYITCwpJGYoYbIoAqCrQy4oAvo0A67gAnyUAq4gA/3sAukYAoAERCZoAmkwBANkQlkY/2aoAjy0BHz8DaQ7tM6CZOaAOwe7GkeDOyaRjHQChOdpjJAsQyWpjgIqFCOQ2oubL0uzAzUwNgkCg2MzUTgylIcwRI0wWtKQRVmgVMyKLDSpi/gIhl+wcdEwRjLTRQ0SxJcwXB8IRdAaxSOR8qs7Mk8IgeZhfOykfM8b7QgwRICaiaI6RAq5YHWCRD4IDo8/wwQ6gAP3OoMNqwMJOUO2EArjIAWlEGOzoIQDOEeJwG4SKK65qi5iGsS8kEM6wEh3aEd/IEhz7Ae6AHRrgQcqOEZRGFLyIAL4lCt6pALDJEPO/IQP9IOQ7IjRbIj9VAKHhEJjiAlHREJXjIS1W8RYSnttM4Tc03rNBEUMZEUS9EKfJJppiYVDQXYzAANjBIWY5ENrGaLnGOYHMEbM6Gu8GoWeoEYMGgvoEGaOEiapCEaloEYj/EVklEUfMHdPiveREHKqqxxqAUkmMfzpnFBcFEbE0QuGae0psWYvtERMsuYEk7hdqIccwsPUseK6qAO4GACWGAR4sgQQmoTYGoTDP/hd07BRdwIpEKKzcILHdIwvPChH/DBHSDy+ewBHCYS8WAIIzOyCi6xD0nyED3SDkFSJGPzEFEyJV8SCfJQN1/yCFBNlopAOCXxNnYNAYdjOJ7m/3Ly6z5R68zK/wwogQiI7KqzFdcgFmOxDdyAO7lzOyklrhRBbqKyE56tFmBBF4BBxbzDO/5KGqihGqTBGY4hGI7hGICBF2rByFghyUDhhzIhoCbHLbHxyaQMB3FQyibPQEHPn0DiEpZHEzgBLqusEhpBWxIhEXIiEOJuekYHtwKBRH7pAhwAB6rrCacQuB5zFdyIzfCIjdxID+ABHt7BHdjhHMRBHNjh+XxqIp3/YT7n8xcwgQZqgDVb0wvKwAteMyRl0yPr0DYR8RFdcg9zczd18wiu9CWbTji3tAhwYzhladd2TTrPijlxTTn/T0zNSsKIAzqhwNV8Y+ziFAvUgE6zEw22szvdoA2+sw/8oFIqpZgwoTqSBRVeAReiLRl89K+iwa+kQRqqoRpE5RmSARhiYT/p6Z8sYSYkQUA1z1Nr8FMd1BI4wRMk9BIkNJ9a4hI0QYks5ELMwyeyBhEaARDoQHzOABB6CWTKoG4WgQpd5Cx89TF9FbhCoSTaiAn1QR7aAR3Ia5G4BxysgRl+QRZiYRmWgRnMRhAOAgoC7MFMEiSZYA9Bckpv80lb/zIPj0BcmWAlj8BKcyAH3BUJuJReZQleu7QIfiBM27TruO7XfONNn04HBjZRwjRMJQxhJUwHeOM3xk4xwCA7z0BiHdANkiIp3Oo7ieLtJnBwKitTTKHueoGvuMNH/SqaHPUrfwEXUgEWXiG0OoHwJCGzMos6BFXzOu8un+wkKEcSoFIIsyUSMNQRcKtzEmoP7gDiIAWKSEeohMqtNgwPaogOAOEOCIUWoPAPyGj2XKRFt5DNtNAQ1IAN0gEeapR7zAEcvqEaliEYfqEXhgFJmsQVFiIEvNVpnkA2X1Ncn1QPo9QRY5MLVLI3VxJe4/UItFQ44dVL7xU39HXXbAk5i//DOKNAaQqlN1xtYAnWOPvVcXmtYIXgcwfowcoAKWHRrZKCOyVWdSf2dINM3R5hAjGhxF6hFngBGJCBZH10mp7BGSr1FVoBFRJHFDKB8IxJEo5XEmxWQeryn46XWoLwGyEBMBNuHesAEM6gOFqACWpgIXZFPnjgDNAREBRBW2zQLnMQFT7rFoSBfVeBLHwVLchoE/5gjgwBdlpqE7JQD8SWkaLPG7KBGlAWW1cML8JDGfZgA0LgAvYLE/HjXB84JW/TJXdzb/W2N6/0Sgv3Xrm0cItAg+8VYX0AUUBXOCTXTd+0UIojUdrr+jr3cQ0WYVXYBwxoathqw9zqFS0WMW//WGLLoArSie3OwGP44BCCbAKTl+5ODBgKC22iQbCGoRZQYRQUh/AcYTyJyXgr64j0rWtAorKQN7PEcZ0EAXb54Nh4wDA8IAisCCjyAARlIhNAYYpBthZsYRbseBZ2AW7jaRiEoVOUwRiMhX1PAS3kQEfkQA7YDHjwMY90h4wI4aSuIAqEABy8wRrmExkyGXc/hYChQRl2YRQMAwImwAms4BOjIEqXFDdt82/11hEDdyV984NneUs/+Abg9ZYLV1FEWIR3+YB2I3NLuIBW2L16AF4TNgce9wdy4JaFY4TZTnygua2OMjstlg4u7B2lhpfcqyJ4SYiTLcjk7mtaIRdu//dTpiQZkGWKE0QSGIEn+oAo2sCNEW5wZDZ5Kwufvxh5j3dmAbMTRGEUfmzunm2ZbkFiDNosgWGPtaMYGpqPCwZuCyaejEEYjIGi2xfQ3kBHTgBeyIgs+lFrqesP9ncNosAHpoEZGjrFfrHvmsQYbAELTyERfIOZue4JHuwJnmA3+VAPOXJcP5KC2xUJyrUlX5I3MfgIDHeW3U9LN9iDi8ALdM1MoQZJpTpphKCshMAGWKDbVKXbQgCswzoEWABuPGADzhqt0doD1loh1joE1hohuo0GbMCra8AG5NpvvDeueYCvEcK9jsCtwpmySIF2eQEXcGEs2SmdEIKxDwOsD/+gAVYgXcP3dWl27ozRGJ+tFVohFloBFnjIFmrhsHEhF3rBtE9bFw67FmohFg61BHnBsHnBYpBhBXVhF3xBGHZBYoRnFU6hFJaHExaBDeKAEObgC3ZnEL7gKyZBDwhhRXMHuaXwDkq6Bxo6A+1iLrTBk43hFDyhJiTUD6xAB5j5OKOADHR6bw/xMU5SXOkwvfXwI6GUN2V5lus7B2r5vju4S5vAYA3oTIXgYIFABxL2B+7aBmzAB2pAhFngwBv8wFmgBVhAwid8wiM8rve622qgB+yaq+/a29Y6rc/aISBgA/ZjxOmjxF0FfIPsEawjFRJbhOSjITrAA8gAD/KABo7/gAuIFA/egxRMARVagXZXGxcMu8hhuxdgG7aLHBdEe7RL8LBlgcnPjcpl4ReuPBjaNssJawWzQxgs4RBELBF6gjSaIg2AQHb0BUeOexAQ+Q9CgRDGoF8WYQt+ZCz0oA7UoAx8gDuw26V3IQtdag5+zxCw4CcxDTrx4wlWuTb/tiURkUnRdb7bNakNF4NpOXFx+QZyuUv9NcJ0WZnDFIVNeZKXg3R9SSiFMhbLoGms7/qsAAdi3QYinMFZoAd0wAduoAfougW8jQbCmj5GvG4cwAEgwtiN/QCSPdkhgj86IAgOYaBj4RVSgRSMMXhJIRakvch7wVL1ExhMuxgQRsmv/5zclZwXqlwWzh3dz40XfiHLs/xar1VRo6EariEb7n0btsEaoiHcddsYEsEGxIAFxOANLIoIYOANjMAIcOANFsGijBuRw8J1bO8NXKfN58B1RnoNDt0u4kIY1nfPXnS6Zi8S1OAKzOAHNDzRo0DSQ7KCEdGoHV2CKXjSKX1wMZhePTiXNbhLm7lz9ZWZNT0HUFiSQRcKLsxOMUytlL4HQJd7h3RFWAAFxBqsV6Dqfz2NQfysi/3EHUIiPMA+tsQOhJiMM2EUgjdkgSHcEaYY7HPtgeHdf6Hdxw22tVzL3f3d8z7v7TPeczearCEbtqEbvoHw0/YbDJ/wvyEccLTws/+BGTK5j2lBD1jgBL4AXlRABrIgC7qCCHagzpNbR+r8C958EhC5LAw5d35kpPVgDcbHBzx5F1zhFEiCIKEQ99YoEKwAC1K+Bti0OHI6px8xNo36Nmn+vWE+5m8eqbHUN70Uv53ag/N703HZUTbd+uFVPhplwgRlwzO8qw2Dsf2Gxte6A1D8rOuGxEUcAhwAAkAc7FfgCJICD6hHECBBUKORFDx7FpoJYcgmnu4OIJIlK5YsmMFjCBMmNGjwF8NgxyBKhLhsmbOLzqRVu4YNG7du38StWzdvHr2R4FJ++7aOnj16MGGaG7lOnM2b4lZuc/YLGTFhtPyU0JBCzpA5f77/zMiyaMiWLVm+SP0i58ucL3/mjJEj549XQ4vmzFlESA8bNVZ89Jg16lKkSIs2xV0VihChP4byqgFiRUiUHjSECBbyBAqUJlOYKF4sRTGSx4qlcJkspbLlxUyQLIbM5MiRx5oxI2lCukmS00lyFCmimvWNFitCtLjxGnaLFiFCrFjhIXfuFbA9bNgAYfhwDx0gKG/A3AFz5sohdOhAowePJ3QECTrE6FEnUqpYwdKly5ex88mMKWumbD179sqYyV8mH2HF+8wiQky47Nh9ixdFE400GmWzzTbdgENSSSbZ42A+EEYooYQO0mSOSPZMmE89MLGzjjnkmHOOTeZ4E80x/8Ckt0sgOnyggQZZqPDFIDLMEMNSMwwxBBFSyTGHCoPM8YYcb3g1B1eGTEIIWGWxYUZaPURCySKUfJLXIpN8QsiQg2xiiB5WWKFDDz34UINghpWG2GaYZQYaE5JxYVllclYmmpuVIXFEm44hkQRpSbCWw6A51GYobx4Id8EFvQkX3aOPOteAA8etwAMPNARBBhlnCMKIJJI8kskoprQCSy6+pOrLMMQYUwwxyAgkq6zyJcPMrMng919FzDgjH0bODJgRgRxlk81KNq3j4LLLaqhhP/34I+20/EwrLbQQnlSTOOTgA+20/eBTz7jjssNOPihJE1ExxviSiA04vECBBP8zqHACDB+4AMMLPA6Rhb9ZybEDEYNk5ZWPR84xySZI6WGWGUKQOeUiYGWZ5CRGfrLJGG8AAcQPQtSglmFLlFwanI4tgcQTLLes8hJMsFzyEk/MaWdmne2ZM2h6ejboDT/XsNtuIQi3gdHEKXcBpMVtcMEGu1X3wxl7FHJII5mAoooqs9yyyy6+tMpqewK1p0zZuOban0IV2cdff7tiNOBG12TzkYIlufTghHtHCG0/EP497T//WGst4Yj/w8/i/CTuD7T1nLNOONzeE60/hPszobj1OEjPNssEk4wyw6hyhxUoTEABBVkQscUHLPyxCApfZPEHwoPIscUgi9xOyyr/WX2R5JGEIOUHHGpA3IMNn0wSSvN0LfLJ85MsTDELHCTa22+x/Va0b953D75u2m+P9HTIbZDccMlF55wDkj4n//zQob9CDWTQwcchj4CKSSejIAUqTDULW3gNbKpSFTAWmKpeOPCBwPgFLyY4wV9Y0IIVvCBD7AOgAWnkGhxBELJGEpOYcGhcJXTQPVbIwhXi44UvvIc+9GE4xO2DcDNEnOEwl7gezjAe4QgHN4bIjXCcQx/72Ic+4sGOk9yEchXKD0F2QYktwcAFRNjBDrgyiIpZSRmrGENWeDeHLGShYHOgBS0IIYeCeeWNfuiDG9DwJCDgQGOfaF4oqjeJuPCx/3csYAEPaqCbELBgaNxDlAeIlpujle+RkJyOJCdJyeR0YJEryJSm8rc/RjjCEpbIRCdEIcBXwAIWBbxFLsjTwF6Qhxe40AUFZ8kLDNKSghK8oEMOch+5EWgjxuLGShRUE5qUkB6dO2E97rHMFTaThc+sBz5mSE0kWlOJ2OQHNW/Yw38kUYc17CbiFrePdgSRiEWshz8atw93mGsk4fhGOF4SjWUgoxm+iMS+vOK6HTxlELSYxFi28IdQTGMVYuhKV65Sla4YqWCDwJhd/KCHOdbxjpvI4/T4WL2INu8Nh6wBDWhQAxvYYGhDG6luULrS2GjvkpfcXtR44BlO0QEPgP9gRHck8T9RiMIU4XEFKnNxQASq6hblaaUDfdELXywQGL2YIC5wAUuqTlAWWJVFLXd5EP9g5JcgtJswQzKTdZzDXOZyh1rdQS5ysYOtLbxHO9oRD3i0Ax7wkMcMZSjDavZVH9OspmAHO8N97NCw/kjitJKoWB4y9rFK/KE4hEjEcLBjH/yIrLnqcSGb0EMaFWnGMDyxAhdscQtf2EIMtqC7QWRxDjDYwhgWEYqsiOVguzuSGH0ku9r+gRAUnWNffGCDLK2ieRxdBJbo8gcjQCkIZPKBDy41SBvUgLo8CIJ2QbapM9QBD3zwFCQykbVRlCI84rGFenXxNaOm6qlMXSr/Ax8IQajq8r5cfQhFKhIgsGLDbiAZ4YfMIaKzmsvA7kQrOtTBYHXI48EQjjA81PGOvD6YsBgmrBJXqI/FEVabM9QmZJOoj7+OeLHiJBzj/CEuclDOxeKIB2YZd494nINyObkGM5bxDGOAogZA0NcWdvAGIszhKTz6AhF4JAdCjGEOQRqElI805d8WCcq0HYRd9HAHN4ChL0CwQVxCoVws9REstA3FIJxrBjrkAQ952IMg9gCIQzgiEpfoBABJYQpWuKJru/DaMAY9aGIQ+tDDAEaiFZ3oQz/10U+1oH736x/+9veDHgEJOMpqEpcg84X54Nw9YMjMcdU4HvFgYTzQ/0HXeMyVrnh9R4MbnI5aVzjW70C1rlcoj3v0Wq8Z9sc2C5thD1MzsxL6m9+w1Y/GPtavLGwHOsaBDhcH8drjaEeHPXyPc5BjHd+ohkWakYxR3GACMiBCDGAQ2y9Mb8mTkMMMtgDlu0zCEATlXR9lN4hVCPR2f4joXSh6ByeB2QdYothG78076U1iEJ9YhRoPOIzzGGN0ZmuGxjfeHvhg/GzJQIbIYyUrhSSkGCgvBgd7KaBoUCOs2/gIS0aSN2ZRyFn5+NY6GcdzxikOh4QFtmAjPFgIs3CvcU01hzVcLWkxNlrRMixjd5hYxUYIhjAc1wvJNVdXv7od5SgHOqY9jv+yT5scaE87Oc4x9nY0jsbmMsc1LBKNZrDCDCzQAAVOwK8tzCC2D5cDxqSi3DfMIRSG+MMYvtA7wWNs3wBHil3+wGXhWgEIPqC3WCIqZawM4in0XoXZMp7xjWu89Ka/Va7kw/pfyU1A0qCGNWY/e214Axx50xuzHpQhnC/7cDxM3OIUR3XMGb9wiut58aOl4hXv8Fs9b/rUq17YfOwjH4/7G7YCFy4Ydh/rpa6HucZe9rKjPRznV7vayz8O9ZODHeg4h/wlZ1YDa1vYirsHO8zBDWkwIxrPkAtkgD0R8AAnUAJQhlr89gX+whXNk1qslTBv5Dy8M2VEUiRbVnlo0Bf/P+ADVpE7UuEV8UYVUkEEb0ALo0c2aoMf8nE2pQcN0zANsmcNBnJ7uNcgu/cSMPESNrds2pds2nc5VJdiybc4xVd80fd839JNSgh9zucPMoRY03J1+IBzbsUO3iZ/5MAtW3htXuiFaRdEaldtaMd201YOZTh/8odWHtJEbegOLgQ4j5MPL/EN23B709AJPRACEhABEkAEL2AjH1g7tsOAPLJkAxOBbTQHhhBljdiIbnRvwKWBHOgDXVFbu/MHgTcjT5FaZuAIp3ALw9AMMRgsAxINzkAN9DE6tOIM2pASuEcP82APNFGLLSF+yCQOwjREHnEOWpdq26REW0cuMYR1/8ZIajPkdIxFTceYddL0QhlGTXGVfIIlhUmUc4YThNoYavhwDwkGf+2nfi+mfmq4hmilVvCHDmxoYFhYD2zFhuwwLmxFDwnGIcekN8hULuzgIObwDd2QDdQQDcjwCpawBiiQARQAAlzxAjHgOk8xBFIBka31CYw4JF0RcY2HF12EJYawJIYQCAR3FmGiAzqAFQKFJV6xBTwyCF+wWl+AAmsgBn1wCL3AILEYDiThDc8gK+RmK8xwey2hNwMmf/Hni944LpRFRN9wDmxVYoXFTdfXjKAGQxDSVi7UjEl0dEhkWNVkfdGybTwXjFLIONa0QtCCddxYYuIHjgcWf+03Dv9fGJdcWIZjV5TmCI/wh5dsyFZ8iUz0SA9o1SEe0lnx9A3oJFbZ0BHYAEJDZCzWUE+/kAqmYAl3wAIuoAEWoAJLplpQQQTydhRS1kargCViQW+TEFC3JWVl5hV2QQh3wGVnUUcliRSaKFAMaEb/EhUyoAeEoARigAfAMA/gsA3gABNbKJzeQG7KACvJ4FUzNxKcRWBqiA5XyQ5JaTcsgUzhspWL5UKAJY1xBWoQsnVSuUKNQzgjdkPHx4SIpY3G6I7u4G2TdW1FFJf2GUTsx35iV5djF3b8mQ55WZfs0A4D2lYoFI8l9CEDdiGFyQ3G0hEgFKESOqETWg0Gkg3V4Az/x8ALr/AKoAAKlAAHukMUKTADcvACQzBvuvMUPrIIPtIjSXFbXhFRfdR4csAkgbAHd1BwanAFVlAyVlE7bbQIhCgHWZBuWCEHV2AEesAHyTAP31ARLfFt86ANzQANynBxyiByEeEMLCEOTTQSZ9V22nYPOXcOh1lELpFz+DBi1/SmJMaM3Lh1zMRCbXqnmEWEhiOFTgdY+ohWMDaf93lt8/lE45h2NlEOZaeo+UkO5WCG+8mfY+cO6kigaEVgDBpEK7ESjfmgiamYIKSYi0mhIFQNpiqhploN0oAN0vAMy8ALsYAKotAJmWAJlBAIb7AIIDADKfACWZAjQyAHiyAj//3EFQ4ZUT4iRkMyW73zBUWmB30URzrKo1hgBVCwBKzFFTMyCVgBgZzorDCgAluACNNQEh5xEuwgDuDADOXBNcZQaLxgENHwDfMwEtLJdgPaDvtgOfmgi+j0DeQgTeskWOT0c5klls+GRF55fdiETVspIVinl+ygdoNasXOZdkSJDv7pbet3Dm+ZjuoooCELf2wnfyAiqIaJTiqbmKH6Xywrqi77oKA6qhtRs9dgs9gwe6lKDdQgDc6QDMBQC6kwCphACp2gCZHgCDjwASVgAoHYqzswA/3UkDFgrAR1Oy6qO3JABMoVcERyJEliCIWACH3AZWuQBlhwBVEABW00I/9ZgFpv+7ZLNgebSQQqsAOBAA0mAW4nwQ3z4A3FQAqSgAedIAzCMGi9AAzymhIfYo7pQFdJ1A/1kJRDFA7ogA88BJY8N04/B07bZ32BtUJKFw/vMFdj14UVO6jc4oU4cbF0OXZaWI6S+nWmq47ngKmGyqkqC6ERyrsTCqocsZi8C6HAS6qpWg20d7wzSHvTAIDMgAzAkAum0AmhIgqY4AiVQAl6gAIlkAIpAAIY4L0mYAIn8AEx8AI78HlfQGR0S1A8ghQ+kiSeCbaLUAh+kKNmuwZqgAVeEAWykwVz8AIqSYKuQwRSKwccYAEnQARogAvFubc0Bw7TUAqF0AeN4An/p2AMwqALURUMyyANuCciaJUO76BXj2OdRGQ34VAP2Nd8m9t06xTDwgZN9uix55e6XzhZOty6PFyG7vfDGDt/bGivuDtZuruyxQuzi2ksTMzEwiuq2RC8SqzELauYxnKzx2uqPEsNWbzFrZofvxC0rWAK1vsIh0AKo5A1quAIGHCi4AsC3wsCIMB3L8B366ZuKQADdksEJ7AFtPAJEagVQ8KIi6AIFQwIOgoH+qsGYAAFW/ACGgCRbzsEe3QVSvEFMiABL6IChJAJxfCKNggO2gAN0MAJDhMIlBAJpyAMqoRy/lENm2Zg6UBh8NBh+3BjKnsO2CgtzUdszuRO7Wef//JknzbBukCchuVIlCW7hvJni7aIuxeyqYfpu6QaqhT6xDILxdncETL7qaL6u6OKxVlsDdWwxeZMDdNAIALyDBixDMXwC7gQC6bUCqhgCqZACqTEXrdwC5xgAxxwAuCLAS+QAiZgLyUQAydQvi5AAlrkTwYdZZ/grJPwBipZJBQDkn2wB1xWB2qgBmjQyHwcFUaqI1kRFSkQAyogAy+QFERGCaBgC81gDdNgDdqgDLsQUG90CrSgCa5gDLDSDMzwDNGwDWLqDpqbWZxzQlXIfd/njWiVzPNHYLa4lhLbVuYCD6iGjmylj1ttoPY4mDNBmNKcwttwoWUdc9xwIAjSDf8f0Q1s3dZu/dYB5o8g0Q3e4A1uvRJzndd2fdd3fYd+rdZq/dfboA3acCDakA2z58UA6Cv2VAwLBEu1MNmt0KGtUNkdWkDrpQu1QB5fUwo38AEkAAIZQAIZkAIngBU7ANAyoAIw8AY7UAJ97FoCzIg7ULVz8AlFtgVvQAhwMYl6EAdu4AZtEAZecNwyYEZG9gUoOgQC3NpSpgJDwqJZognGMA2jaAy0UAqnYAgWHXGU4AmuUHHJANTsfA23uEz6oGLt9FZUDY/sKLFotQ5NFBO1aNVseI9spWtefRKE2aAOGs7X/M0hVNbeHLPGotYGotZxrdcN7g3fAA5+7dewSNj/gD3hho3hhq0Ni53OAPgM8xEREoRVsSDPr9AKqZDiKo4KA4TZHfrirmALmm0LtZALsyAMu3AKVyDaM1DHIJAvJeBPMCADJfABMBBwWwADJyAD9yJGARcDQcojMuAVVKIIkxgHWE7cYhAGXP4HQ1AjWOHcOvIvW7AJf0AEeTwDUpEkEUcLu2C4wnAJ8Uajm3C/SAsKF5crGeEM1yAOgMkOl7Mh9PchdTkOy8yGdWmG6qiX7vCXMNE5Ouhp9k0TNjHW3FC84kw3EXq81Xyz1WzFis3NC27gTSzYBzLhgm17hQ3Yhb3hHd687LxjyIAiEgRLslDiqVDZl53rKX7ZLM7i/6bQ4pc97C7+4q/wZzJeQLOw7LfgCnqAAxxABCPAx0x7gFRxAtOuARlgL0TwB1mA0uyWRdn6qzvwB7xNCKnckRSF5VjeBm0gBlsuB+k2A1B2FF+gAlmxA5jcT0eBFNLD3Wqk3ShpCJvwBiCpCI6gB4kgDOsB4vXE52AK6PEguc3MoOS4zEKcVnoJE7WIqQSWE/7ooN7cuwLe6cZbs1mc8pxus6ZKey7/8jRYextu2DJP89awxbDOzm0TERFUVbcuzyV+4i8OC7FA9LBA7EjPCq2gCvVsz8JO7MZu7Aa07LPgZ64wCprwCUawOylAARkwBltAAkYuWzJS5K19LzGSFP9ZhEWduCNSawSEIBd5se7s7u7vHgZJ8Zk6kjs4IrVTPgc5ciSyExefcAqnsAlT1u2LIAansAt2cQqTgAikoAzQgIoDcg3hsJX/oA/vsOgZP8QGZlb0PWCFasSdGs6aXs10gw2pX8XXQM6pSqqsr/Iqf/PlPM6pSs48u9jnrM4C4tg7HwwjLgu4QOKpUOIkLs+7fkrGPuwnfkqn5ArS7wqsYPXUT/3VvzWqgPRRP/SnpAvLbguq4ArbHUj+tGQgIAEUgL6rTQIwUAIgEANFfrc78OUqsLVEkohEEBVLRgRjQPAAscgQIT154hx000ahmDAptmSZIWfIEIhZiMjZEUP/xp8vRIZ8mTNo0aRQAufIkRODyKI/fxYJCzVm0So5NoSgsqYN3Ldv4dj12+dvn7547NitQ7rO3FJx4nh+68ZNajZs165Vqyat2lWsWLV2BetV2ldq1MBew2YNa9lqZruWpWb1qtW1YK3dBUvNWtm7cP1KixY42rNnzJgtO3YsWLBfv3jhwiVLcizKsV6lqtzqVatUnTu34gy6FSpUpkiXPt2K1WpWrVSpchWbtSpUslmzFp0b9CvesHznqjVLuCtNYy58oHCCiIUXJzKQ+FCixAcYJUiAsE6ixAgSMlTAUPlGzpfx42EQ2fGH0iaBBA0ajJOwDcMZM7J8gfhlBnmQ/4PAq1DphS0+CWWST2iZA4YdiHghBTkmkYOWT974Yowt0LPBBjyIAafDnXji5htu5AoLrLFORDHFr0qsKysWxULRL2pSlLFGG8s6cUbAAnvGGWcMWyZIxBRjjJfHIpMsyckqq+yVWDjzLBXQTiPNtCpNISVLU7bEMktSuOSyFDBL2xIV2sDk8rXbcOPtFd9qyWUW2Dhh4YEPMNAgAhA0AIEIErb4wIIxiJDuhBJggGGE6HZQIQUiOvpiEZZCQkmOMf7YhD1CAukjjzwKQkihMLKgCKQ57gtlkC8glOMTOWYggog/QtnkjzliZTCFLE540JA/UKLwixNgMAQUUnyBBv+aII9ZxhkhnzXsMB+nFewZwa4dC64c/8JRRW+/BVeasqY5sdoegRySSGAcM5KXxhaDtzFekowsliTtVZJJJtvMjcouvfRyFIFHEUXgggdGuBQxt8xyYTS3VPM10lZr0zdYhJtllVMIqcACCjSgIGQMUtgBBBmIcAGGE054YQdEq8NOBSJg2EJBF/6Y5LwvRFqEEEM+oWQRRQrx46A+9DgovvnweyELjv4YYpA/tphjhwffIGKLlhaZ4405voh0kDlOOumPMUyV4+s5PnFll2SaaYaZuA1zhjC77a777msDm6Zvv8WtsRq8+NpLcKzusiabxBFnfC+9HKeGXB5/ZCb/mWSKOaaYdXs5ErLIPIesXSN/0RzzeNnlJRdddOkcFyNBF70W2Wef3bfeLIZlM1Zc0Wwz0dpsTbQ1WXlNFeKNX83M1YpnTThbhMvFFltu2WWXU9YAYgsMIgjZYxNKoCCDD7J+gboddvjghB2UO2HqFFpSf4stSHjh0VY/yZQSRTbtNOmk3WCDGGYwkYiQRw73cdkW5CC/C6FEfll7CEj0M54tbGKBWTBBCoYgA0Kcom1va4Yy4hY3Z0QDGoRpxt2stbfAQIOFLBzLNPwiQ7hATkZ929FgfhQkZGRuXfJqHegi85haCBF2RuJcL3rxC2AAoxjI6OEPjaQ6JeoiF557/53rRMcL2nURdxez3WZcAQvN6EZ4qlEN8WaDvOMtT3nLK54qZnGL2MzCFc/bBS1OcQcWlGALHgOBCSiQAhOkTzsggAH9WNYcErggazCQwa1UwMAYpIAENBvEIN7ws03ojxBEKwh8EBLA+gzhQhfCVQz+QIs/ZI08UzOCEXD1kCHI7CNGMMQWvmACXm7BCIs4BStuQQwRJuMwh1kG3ZyRwsIos255G4wKnwGNvu3Nb9NoYbJOCLdmWA4ZxdAcMJTYLtDNzoi46CJk4GTOK+biirJz5+p6kQslAsMX4OxhMNYFDF5UcXXudKcWt9jPIwEnFrSLhcVeMYsw8suMo4EoKv9Ac7w4Ii+OpKloHGNjm9XcohRCYIELKCCBj4UMBPo5zwhUEB0QaGcRnyhB/CIpgwd+IQb1mwEhQWAgIxiok/sDpaf8B0ABpqBBRFDJFmD1hVR9QQU7SMFIcDAGI8gvCyNIQQwGsYktjGEOYzhgFkAwg7F9QhWw2AUx3qYMZCYzWoaB21unlTcVPvMZcbVcMqBYDGKEk3OqAw5waAccdKJzsIIVbBdlZ1hzLhagAMVFPHXRC18o0Rf27CsyknGMJvKTF5PthRUfO1DRQeadXvxi7njTLyq1lkoZNV5FMcq8NrrCjrtjhQdBYQUWsOAEI6XAqTQwXBPA4AWKQs8HlEv/AvTAAAQ76IgMbvoCGAxCDiqYAXZPQII36IESQIvE0IIKqlGy4XwLyuoLYnCo9HyhfjGYxCLkNyEZ7CCnpJqDrVoyCAUu0LodtG1ak6GMvUKRh3nVKxQ128PEgNPBTfxFEt1pC9kxFBbBAaPtLIaxWTyPwhSeHYU7jDE4PVZ6FA5oQEX72HjG0xeXbaKDi+HNzT64s01UYmhVZ8V/PrbEig2Ohd2Uu9WMJo4Qk5hrYWuKiqbpFBY1nnBYobFTrEITV+DAB16QAQuUQAX48ZgFTICd6WzBBRagTiOnQz/noodBJBDbU1WgglZqbRNAg4R4j/YpUQKQDechQk6VGpEL/2XyfVJbRCYJcb4sqIBUpgxFScT2oEngbA4zYegtfGGMZBDjmzIGJzGGIU7Ova6L+moTb26Dxtaw4hWueIWrceeK1YwRYxkmsXBkZwuAgnixRSwiix+7usn6YhjEQLanPb1Wdz3Rmwp+cI6JTex4ztOdQLawQtGomuKBiTZkslJru/0wUzw5o6yYBfFccYpTaIIFHChBrDBAAgsMggQj49MILKAB7ZTAAiS49yV38AIQyGG7GSGCUWO1gzkMIW0xGAMhPoFn8fqhIEf7HwBfsEAYsGTiqFQODFZlHwfGwL4nqOV+aBEKq+5sEKsIxRsiQQtaUM8Xnm7iiyur4wnTLv/bHN5obCxGa9xItNWqSU0Ze/fQVK+2TQeV3UGhXgtfB7bFO56sEz2tYL0aE269mLHcLJeYHkZb2tMu9jxnx+FZ25Hoa3wNuZH87YyCSWGmKAVsYZOxKlNiBRP4gAYwsO8PgMACz5EDUlX6AgmQYLsgWNkJLGDceL+gBGDFyPle8AVaDAJWOxiDgThBiTwXIqgYRwgAHUKESYiNFpPImhz+AB5ZvcoiF6rlCQb4kY7IT/aJt9UYxrAKYRSfGMYghs5fTFld3ML5J64FLKQ3nI1SP+isgQWtJ0aaKUm0td3vvkR347tU64syIYYnnORJ7ND2QutbX7Bei3HXEzKjh4j/wZzZz55jyorziuqUHdzpjc3wne0zjXFzrYk5E9NghdNAk4pahVWADSozhA1wgAmYAA0gKQmQgAiQgA/4k0+giRSYgcDDABWYgy1YGSJQgTGony2gri2wGpdBj0nwjvMZg++6hPD6pNPrMwCyr/0woEF7kJvSpQeBCFMaghEolSyIAVgZgtb7ggXRD+qSg1VQBmMQoWZItmHwQi9Eu+iZnls4MYw5sTPksDRUQ4Zaw4tZwy6yhchKMTlMLNOSLNDSMf67sXpyImBIBmp6BsZwDFl4jCXJjKXbDc64jCjxjNIAmC8xhc4ghYMBBYEJGIDxDIbJElRIBVLAjEYknl3Q/4VduAVP8AM/wAI9EAMjUAIOqIAKuBMN8JjwsQA84ROySgE+wQAQ4EVbKYEheAETYJmSgYEU4MVGSQFLOgFEgoEb0IM704RIaATT45SC0INQggM20MYZyCCwIY9BeIH6mLPEi4EteAOcyi75shX1yakhCIVVoBqO4MYYUIE3OAVlwEdleLFhMIYvHAZfmDaAej5amL4OO8OCZDvfWMOFZEja4TVheyzTSp3P8if+s0j+ewywc79mmIa9EER2UScjijpUY8SSjJIsEYWUVMmVZEmV9ETPsBdc+IVgOAYfiSFrmAZk0EJjAIUW2IAHeIAJoAAQyACS2pMTsK492TcNiP8IFaCAGfgDybOAPQGBEcCqMdMAkuGlFBgZE7CP5yqBPjFHPfADTgAFTogER0gERAgEPziaPcsDOIADANrKQCOCQZiES6qZ89g4MxOQIaDHWzGlkxmCiAgFWznMk9gCmXGBK7gEY9DC5NM5YPhHgFwdUewxMSxDW6AFhvy5W0vILwIyqjtDiAQo1hmoUmuXxogwy7qxzgq1Z9AGb/AGZ6BJfWrNHNs5AISMJeENJoGSzviXSWzJlHzJzpCFmWSWEpIGbMiGboDObzAHerAH6lyHDpGGYwihU6CBCxBKwHuOF3gBChi8ESAVXtSAERiuIZBFDRgCC1DPWlQqrEqBEdj/kxHAABOoHyJQzzEjuBMovDfYhEj4BE5AS7VkS0DogwXdM7nUxmCMlSyINAZRoO3KmpkZgxjQjzlTiQRBCSqcAyPwqi/4A1VxszG4gkgQBn1UvssaBmLzheoJSM08sc6kOZrzTOHYMB1VSF0bLHgSQ9O8Q9BqlxwbHdbUw85yvyaCIo7UnGk4Ic1Z0teUItJSkivFUnehSWZhhmgYi2rAhm3wBg8hU6VYCnI4h3MgB3RgB3zoh3pYB3G4BsR4hlkwAw9AgQ8QSuUKH+RQlOGagWCURQqYyqHkxROwT4/ZRV4iOD4xgS1QRg7lRfEE0AzAAUNQhAIFBUhoBEQoBE5h/9AGzUY2yKoFmQH+2gEZkIFEiiSbmolNkoNBGALW+4Md8JVWWiCZ0aU3aIlJUIH6kS9CoIVdEIZ9jLHKerHqcT4ZJcODlJ6aw9G1u7XUsqOF3DXom7ATM81pCy32o6wk5cPXNJIUEoVHQAVMIIVZIAUtHDUqBYaPZM13WQxmCRLmlAa0CJFvmId93Vd6oE7qtIfq9Nd6YAd6MAp6qAeCZYc0NYp0QId2uIc3jdNrEBdoOITeApQIiAAMQA7o+LdEkUWNHTNCzYCP2ZMY0Dc+GasZAAFd8RMMcCr1scI/EM/qyIATuAH1+ARPqARHUARP5ZQ9YFBQ8TMVOAEAUQmxOf8UFlwQFRgEZaAFI3gDpzmZU5qE/JKfcdSlRXC5MdsC2NsCK/CEXTCGXYCxnHuxUaSe6iHFIC1DaJWeLuLR1LKtN9y12YHI1GExtINRndNNd70xJmqGY8CFXhgwYWCoWnC/mZxXem0W5twK5wQHfu1X6syHy7WHfMjczb3czvXcz+3cfhDdfnAHo1hYNT2HoxCRbMgKZpgFPmIBCpgA7uHFD2CUkUrP4ZKDFJAArDq8QDIBLjM8C5jKJRyBBjElFoy8FMgvORizgYM8FHhGTvAETvBZoAWEPRDaPYuPbHwBo9UapGylEti8QaApWoCGT6gqUskkXYoVkrAQ6doCVVH/lTmYgRHwyixQKhxggZkTBrNFNs1JW7ZlW+eruWZ9HoOcBZ/T0WzTMDV8k8I6LBYjrc+atuXbuRwD3BsrBrBj0hAqBlmgSS9tTmwIkXBYB3ZI2IANWNB14ReGYc21h4RNCqYIh3CQChGRim3Yhm7YBsWRBmboBVGQhEBIgwvAAJJiAD5RLl7kso9xz/r8ghQw2eHKXRAMlJgiAftSzLTBgBcoUcfjuOPCWYnbhEvwBEdohLX8VO1dUPJyAzdQKRJUKpoZOIeAPTkokDdooLVJPPSYg5U7G48YBGFYhKyBvbCkY2Hh30BwheI725y7zAJ2vuebMBKrMAgest5Qw8US/6JgG60K3qJ4JWV5bdx6tZa+0YvBoBtp0Al6mAcWDl2goOV9GN1b7od8yOXOZeEZrgd/TYp1OAemaIqncIqnQOan6IYxBQfa1AZtiAZkiAVMeARAqIM74IDZZQAGwIBdFJ+QuVkVIK4MMAH8dVSrlJQUsI4TJJSRUIGWmoFJEJY/+AQ6M4RByIgMgAE5WIRSGIVOsN41Bto+2N5Qig83aBAVyKBAxa76mIEF2QIZcAFDcKosGIQsIJUUUIGf2a/6mINJWJCPXoQBCrSImNUvEINAWIWdTDbkOz5+LL6YFoZhmIXeYK3vm5LfeZLgGTLVepNaMD/J6E0sHSLG3dLH/f9StOAJcTCHYPbXgAVmpADYFn7hXN4HXc4HfNDqrE5Yo4jTpSDmYk5mnugGsobOs15mHlZrH+bhZ35mnGQGYIiFUWAEQGAEobWBC6AAD+TFodyeCBgu5wBswwOBiSDRclaV7UgP8uU3/krP+JkORmEQmnFKGNCDRXAFWhgFT2iETvVUBRXaPTDoOM6uX7UPiHiV+oiVQKVsDaKIIUiv+nmDT4CQr7Gp/UwbWMmuLBgPIngDI9ADWhCGfiQGYEA2f/TCGH2xW4g1p/ONKtENMmFETpQS0OiMpnMSWcAXodZSmkwm5rQKEy7rpJgHfzXvgMWHrMbq9M5qrcYHqE5Y817/2HoY5rBuihvG77HW76jghrJGZrSGimWmzQEncNpUa294a2qIhrh+klGABECQhGlkAwuYAEUlz5Cx4vbcN8MjpNYT1KlMn83TgAyYjhIYcQXCABJ3FEMhAl50GReIAxVVBlcABUdA0E8laII26PiYCP3NrvqAwS9QKqP6DvDIAvsVwhlQjkALq9TWpQuBkF9RVSI4CYroKkLQhOIbBlFMbl+IJ8wURYTU0bhbwC4pE+o+Tpjkbi2tSfAWb3BoaqQoWIFFWBbe6s51b3813dJFCnMQB/y+YWSWihwedKmAzkIv9LPmhmxg9OeMCh5mdLXm4UQ/a7WezQM3cAR3a5yE/wZmKIZc6MRRyARIIAVQ+ARsjo4RAB/kKOwZoAAZ+AJ9U0r9hO1kHC4VQLMMEGcNUAEMeMpAwi6sOgFjVOgGiSkYL4Rd0AZjGAVHkMaBDu1rFKo42AKKKOndVqAk7IgYeMJMGqvyQA+r+YKJcLiRqFWc2QH+ipUSeELDxhpCKAXhZttk7QVcsAUresi4zXdcoAync5LOwBfXUc569VLByQYx9ZB5YOpgXgd6kHOjcIeI/2U5F2Y1JQdy+PP8BhH91uEcfgpE5wZJ52G2bnSqKHlscM5GT/lGF/mSZ/TE0QbGGZcdIYzDQAZxiiygboUtYbfM/oQ83Z4SMIQMEB8JGP+EUCBUFehAEyBeCzhVpzTGqgRBAPWYIfiDqhQkr2wUoswAXRJyGPgAIPCDPVD2aYAFZ7/xBc1eaYcPSEEq9HggkVAg2DNs/LiPWSWCMbCaXylMvMwkjEiJGJiI2CMCUsFomvkEgTgQYVjWXZAe6hnFXegwd+onJiISerXJyA2RhreHdSjvXhZYFvZXymX4/A4HHWb0lB/0Rgf51jd0HT5rskb0subvQVdrl1f5Rn9rxJmhaqEcxMDNQrSMRYwSMiGN5qa11zgFzb6CCaiACneBqgmZoayPGNCT4QozDZjiDNiTEaeADxizXGQ9EHhnlWo9DdCyYPRKSfkAJegUZV//dkuwcTYGhPon6D2Y9imcgXJMPPWSHyEHiB1y5AyRk8XgjC9yYMwJtYXIl0FDvkwaRGTHCSID5xDROINjiiFDPhLZssXFGEq0hLHcRYvWLVquXK30VazYMmnavIGz5/MnUJ/5hub7SdQnPXrr1pkzFy4ct27cplLFZhXb1GxYuWXrym3b121ixXqlCjZq1G5SwXbbplbq1LdqyWZT+7VrV2zVqlGTJi2aM2fMli07dizYL1yyZMV6lerxY1KkRFGuXHnUKFGSN5MqRWrWLFiuTp1adQpUIA4fMJT4IIFCiROrQVAAoUICCAsUJGQAESFDBgoaMjygMOIEhhRZRmhQ/2EiRQoVI4YMUpFhBIgUGEy8WVQBSB88tqZ5gwbKUaNGhQoB2hOo/Z48eeLE2bFFhoySJneoODHmj0lbfJHFCx9JZNIfocwxR0RD7DDIG3LEIMcgWwwi0QyDELgFf0TA4GFHMBjxxiSffEJJJH8Q8oced+zByS7KNMNMNNvME1RQ9NiTlI5JiQPON0EGCaRcQlKllpByyUUVk1yN5dZcT0o55VtSaqONNdZQ01c0gAlWmGGI/cLLYowx5hhkaappiimbYWYZnJRhNucoprCCCpuqqOIJCyVwUIKAFDzwQQZG7EABBiBoYMEJIChqwaIZSKDBohbgpgEIib5AhAogFP9owgwWgGBCbjOMUBtGX0wAByJ0mNIMlrNE0ogjiBQSiHuB9LGHHvLlMcgkcgho4SAyZPCgIV88tMMQWRz0RUFvvPHHHH+oMAMMMuwwxiZvhBLKH59IlIVJM8ix6RYwxJDCC0PA8MYWwsrxBiHxzjGGEVgEMkoz00QjTTZLrSNOkEjCdReUbXlTpVhAevMNkEJKDA6QFFts8cNBerMxOBt7/HFbT+KVpTV8+fVXYM4QBmYwLY/JC5llyrxYLDXbnAqaj7WSCiqPocKZZG/GKUpmdM4Jip2o6KlKJj+g8MEHtmXwwQMlkPCBBRZgMIIEWVswgqgZRKoBBRSkMMOitWH/oMEcM2CQqAnYDaGBCRakMMkMKYCwLQZ6JIIGJsZAM40vmjgSCSKIvHcrIH30mscdwMpBRAwlEXFCChCZ9AW0XxAxQ0clKfTGCyWoUGC6Y6wyhyHUbjKHhW98MccgcnAkYBYUCVsStQvOzqDtgXTSzDPP/CtNNddgY8011+CFTVdTihy99E9GOdbH2Wcv1pUkl1yNX12mPBgz5S9jPpiGqX9TmC27/Av8vMDfC8y84IJLLbXU/AossLyCCgAByCZTDK0TnRCFATNhwE6ApoGzsEUufOGLmNBiExeYwAeuljUMkIACWsOAB0HoQQsEB1PCqdQJakM2EHwANkTA1HRO/2WBTo0AOimQww5KV4I5iGERlCjDIVgxDGUYQxWQQI+u9uAHPzQuPne4wxyyQLkO7eCGylLIFqTIORlsgSN/WMQXNvGQF6hgdgJZxEM+sQjazWERk6OWSSyXO9r9IQsXGkjtFGI7OewLGeVzhvH+cjJpbGkv1sALXq6kyEUuEntXEsvGILkNRZJsS+HzkmAGkz71cVJ9yEDG+ZihMsIgY32cvAkwgFGMVP4CGPTjRS9iqYtc5OJ++atF//r3ila0IoC+ZBMpjCbMUczEFawADStYsYtdxEQTHJDABErIQgqQAAQS6BqkMuW1RZnABMChVHOYYwHqYOoEJyDbcU5wnP8YnGAIJ5iBC7KjAg2U4AVviAQl3HAHTbhCGMZghSXSc4hdBYKJu8rDHqDYkSzEAHRE+MMq5PCHCh1EijMoyCAaMohwRTFvDg2FMCZKizmU0XMweFbotjAD0FHIjZOYBO1q9wc5fOEPNj3FMJLRjJ0ar0s+/alPpTGNLWnJe1lipPeoMQ1/RaN4mVxZKTspVcMUg6pT/SRWkxHKZ5wvqjdhHypTmUpf9IKsujjrWWlpi7U+cK1rrUVocgmLxrTCmEsboCpMUYq9loJNyUSmKmbCzF1owgYX1JrWclObEXSwbJDSAAZImBtH9UYDnALnCEbwBbCB4AS6wU5mY6CCGHD/ZAczyE4JRhAbPUxiE3sQQiFGMQthzCITjFBPe271nj3wdg9ZLEnlTDIQOQSrizT9ggyqJdFQnGsQq6jOSndAInE9dAvoyuJKI8IRImhxETLdqO3YaLuMLmIVtyCGjHhavC4Vr6fsbS98nZpJTUb1MMEARivFql9VgrWTn/wqgIuB1WOw75PJOHD5nsGMZ+j0wMuoL4HHKsEJoxWtarVF/traQLnK9RWvKGYy85rXPPVSacWchStUUYpT3MIVoKjBBB7wQRBk4AUsxMCHWlg2SolqVDS2QAQwlQXPMmoLoqIUbSSgznC2U1Ej6OaoMlCCEsQgXJwoxA/uYAlQ0GIW/51gRCIUB4j1vGdXvNVcvNK8A+k+RECzG8TsHjK7iyziE1nwVEJecLYhWEgOCZmBsyaShYp0REBzmIRCFjQQakl0vHIgxCpsMQxjyEgZ5bv0yggTYfy+kpa1vN/9Pg1qXMAylqbWb4D7y0mslrLVrDYwM5LBjJ0GpnjISMYzZkTK/6JSgsCQYC/SWotZ5uKWuPSwh/3Hil62QhXJbEUyXbGKmbBCT8m8Nrb1hGLTjAIUq7jEBi7AgeCAEAMfsI81O8JCFsaGOWLTG9cWRbasacCzi9KbBlLQG91koJvMedtka/wCGNSZE44QQg/64IhTsAIUjbBVIAJB5jLzdqJEiP/QRexzkStqhHPctVxJdLjSkKhgCyLh7hxE8oUZXMt2ghYQRAYSr/HK1KYXotYkXnJWX/wav/VTDM0Ysz9k8xLa/IPFLG45avvlQhem7kXP98vfr07Vk6+W9aUFo+AFX/rAyLjJ11cpYbMSO3/40x+yid6KXRa97bystp4CmCZkx8J/sLAFJx4OBzjgIA0ciDEFJhABRyWKBCTNgAow8BrdkDBqmNIbbbCjAeacQAa1cZTehjCHUVXq3UhW1ORPcoVNfEITlKjDCn4QCE6UwhMP1y3E3wOfl3bxIS7Ywh9kVxKLdLFZnFPpgsjIqWvxuSOaB/TZCjQEFQT6Wlj8/YX/arpRalHrDcot70uSnr9avsJm3vcwLz2cilbQNfzJnqv3ZQFqWoIaZrFkpdTFWvVjDJj+WH0wKaGh1PVJPZa8IDYtmd0teV/NFB3b8dL4dV8sLAYuQJ2AiZLxDJU17IQ3YMk0NAMeOMAFLAADMEBxTIAEPIAEREAE5E3deE6nZMAHmdsHnEB/SIduLNZxfI0cnJOj8JhIKAoF7Fs31YaoWMAHEMEHyIGJaEIlFEINrAAaNAInXMLrvUfsUdxA7AARaEsMTIuwQJRF0JRIFN8gVNAL2EcWrNTkcNcQnI25NEu7ZEiwDAjozNwXzY5NTVS1zOGFDIIhnIIrJF3N3E/3/53JY8RCmtQMzgydzRxb981V/hyiLdUCqcFS/cBS/LkPJXZSVVWVVxkGMECDNlCD+uAXfsFP/ESi/QDdzMiM/ADDMWjVgkXDUl0JT1jMPMwixcyDxUxSBU4DMoACIKyAAzzAA3hg4IkgMDJApzgKDOxACfQGcGQACZwACTxjc2DK5I2ADJyTOg1IDUHLC0CKdFyLClLjqVQKCKiWHhQhikSBB9DAHkDCrNjKrcBjxJXZDlBLFapAuGRhKKwCRETR8rmLRiBa6EDLRXlOFcpAFhzagEzIF3hXvCzC7k0Uo9EhHd6RzX3CH/gBKODCmASDYfwCJYak+xzGLzyGAgpi2v8lm4fVjLEtHcyIotTdREi2z32h2mEUQ/z0AidqwzKISTC8pCjCT8uoz/kERjUc0jbE4iwuJVPS4sV4Q1JuA/VkA1RWoFI9QzHkgihYQh1cEDBeh2s8QNpQit5wkHC0UNeMQG+IE3PMzXF00Tnl2wuAihp20+SBCnOkAKWMwNokSkTAgCF8gidowiUgjhd4gBDsQSIkQiEkznpMnOwNxBeogAxEBBx5XMyNxBAACAyky3bNYUjAzhBw1xfBThaJxLBoVxs1BOxI1ExRSExRi0XugSCkwsoERqbl5socw8ogRtCdndm5FYbdTyQ24CsBpakFpVC6jE8ihkiS5C8kQzH/8NQyCIZhiJIzRAM1IOU2UMxSMKXAUMw3yMU2WEXzYINUQg9eSOWTXEzHaMM0YGUs/Ewm9MEzBWMEhBALIdlzqBamXEemjABGgAAJVAqmOIpEOZk3gYpe1o0J7aCQdUq+dVOibAEtLEIkgAIoNCElOIIfoEEZ7AEiKMJiwuNjRlzjxNEbcBF+eE6bfQEVOge22EcXTQLu4VFGwRzuDQIaPQQXclcWDMEiCMMe2ZRE3dFBNIQwTIIwYOQfaMIoSAIv8GZ1RoNuXmluHkNi/FyoVVio5cLTkRr8iNUvxNKYppJzvo8ozmR1BkY0QMMzyAIm9AIupEIsLINSzsNSYIzI/2BD8+wFoAZq8jQPoRIq9Pip82iFei7PlVBDNDRDMcQCZmRCIxACDsQYAwCZBCSEBryG2ERNawSovnVWcIDeCPXHH0xCj4HeF4wqZeWbXhpHOebb2kgABqCEHmyChnrCJVRCJCiCrSDCYpboY5KZH/RBH1hEuFQmjCpL3lCh8T3ECQRIhQxCKJgh54hE7mwU7FQhEXDE7vyBQtjUFkzCKlDfHVHIKqxrBZHeJSDCI4BkpnFSSC6ny3CkmIxpJD6dqbnfmb6PSHokURZldvqF8yQlTzjlPHjDMtiPdMKPM0ClohYqxVYsoG5JIfFFxlYDog7qNVhDBXaPligVNDADMv8AQy2gwiiwwoptAg4AIwmSoAWQgKV0zdqMwAe8QAasDc02YwboZTmJEzY6ynPEDXNcnnDMgJ4RhDflxgi+wCLAAAvogYaCAq9GQiQ4giJkbSOQaOKY6K0sUR/A6CdcaxcRAZ9ZSKGVi5uJ6xfAQKpm0XC16kRQVEJMDucISxb8gYNwziJAA5HG1M1diCEYAhysgjLQguECwmKMZP2UiSku3S/MEi40Hb9CHZmG4lCGiWEQBiD9S/JATzd8gzgIjMAkxVI0hcVITFs46vkYz1FRrKDOrl9YEsb2xZYs1VJtCVA9QyYlQ4TRKf7AQonlCSvQwinAQYwFIwO8xmtUSgb/URYMrAYJCcd2mIC81SMRdM1e6iW7ZE0VTp4LaoAMdNZkyoEMPNkIsNwk7IASKEK3gUInZIKvaq3WKgL+AquwyuMS+YFw4ZCymFy8AEihiQ4R1BlHxRFGLcgYRoQZKhfnPEuzEMEk/IEhXKjtTCSjWV+q0sInvIEe1AEphGQpEicuHKL+xML2mV0uvGQqCixhiNK/TGBSgkNTzqKO/ATqNoU48HA4EIzEBAk3fMNUfANUJiUjHfF56kWgXkOgFlJf/IWXYFphuIz9MMbOQIYp4Ekw1YleBc0onAItrIIegKAHRUAH5qeokKCUbVAGlY0Hkc3kCcc1jaYLGocGDIHk/2XWkOlGFkBkkE6eCkyOCwapOb3BKWzCachvJlhCJUDC1uYv/iYOsepWIAgL7mnEs1BLDPhe6GjERJkI6zBI59CUQdiOsyTkHjmLQZAWtazRvEiUorXRTM1Bo81U7ewBJsCMwBYnqTniqIGkR3ruv2xn9HjnPNDDDc/iOoinkLhnEA9JxIxnNFMzkUClNkhlNkhJXmTJXmDsX/juYJTSKo2JLQFiIZok+DFb8XYxZnSGZ3SGKihCCEwABkwApIwgCUpACZjAbkjKzibKbiDK2xyZcXwNdsyAZ50AotGNk9kGpaiTDPQHc0w0Bc+NQEDaislvJ2gC/WItitwviQ5rseNG3By8gX6oVBfBzsp1nOfoERGGArCsXETAGbTQTkKoXATnzkWh7SQYwioEyxjIwSIwmrVOH/XZFIMUwiPIAi8MsyjKwvg9ogMuQzQk7DIz88A8RTjYxZKgxRCzbluMLsRIc8SAgzgAsTOvA8R0AzjgovJIZTVkwzejTGAMRvvEz/0I3fetZGP49Tq7HZ7o1V4JEygUggdcAAgJXnFEwAPELPZ2DT+3caVojQztRqWQQAaY0zlBy4GawDlllgZEQGapk6JwNhGkgAUQgRHIwSns1QLNryWgCNZirdaG2WKWdCAEBAAh+QQAZAAAACwAAAAAQAEAAYfqvp/htZbfsJDZr5ParIzWqozUqYvPqY7UpILPo4TMooXKnn/FoIXEnIDFmny/mn7GlnPClnTBlXXAlXS/lXS+kXC8lXq8k3K8kW68j267jmu5lXq5kXO5j2+5jm25jWm0knmzj3SzjXK8imW4i2i3imi1imi1h2azimy0iGWzhmSwi2+viGyxiGaxhmOwhWSwhGCvg2Gvgl6siG6sh2irhWishGmrg2SsgmqrgWqqgmmsgWKphWqog2ilhWyogmalgmiogWeogWOjgWeyfFGsf1urflyqgGqqgGiqgGWqflupgGqpf2mpf2epf2SpfFmogGeofmiofmaofmSofFmnf2anfWenfWWnf2KnfWSne1ilgGamfmSlfWSmfGamfGSlf2GlfWKmfGKle2KleVaif2ijf2Sjf2OifGSjfGKjfmCgfWChfGChe1+ee1+ieWCfeWCieVmeeVyfd12idlWgdFWfc0+cemCceF2cd1yYeGGcdVqXdFuZclqYcliZclSccU6WclmVcVWScVmcbUmXbU+VbVGTblWTak6SblSRbFSRbFCRaE6ObFSOak+OaU+MaVCHalaMZk+MZkqHZk6PY0SKYkqJYkmIY0yHYkeGYkqCYUuEYUaIXkKCXkWAXUaAXUKCWj9+WkGCUzN5XUl5WEJ6Vj50VkF1Uzx2UjdxUTtsUT9zTjdwTjhxSzNtTThtSzNqTTlpSTNmSjdiSThoRzBoQypjRTFjQStgRDNgQy1fQCxfPSZcQi9XQjJbPyxWPi5aPSpbPCVUPCtaOSJVOSRQOClRNyJUNB9ULxdOMyFNLhpIMyVGLx9ILBhAKxxEJxM+JhU6JRY0IxY8HgwyHg8uHhAtGgwpGw8oGQwnGAsjFwwqFAYjFAcfFAgeEQYhDwMcDwQeCwEVDgURDAISCwIMCwEQCgIJCgEPCQEJCQETBwANBwEKCAEKBgEHCAAHBQAEBwAEBQAQAgALAgAIAwAIAAAFAwAFAQAFAAACAwACAQAAAQADAAABAAAAAAAI/wCpCDSyowMBBzFe7DBhRIuROFTqUGkRg86fG0aoCImziA2eNkpkuDCRwoULFSkyaCChwQQMEiRKmCBpEsaHG7WIIVNGTRw3Z8WQFQs2TBcQLFSKEFSygwwZLQIFkqGiBKoRI0qUvLhxYysWLDt23ADbYuyOIjLSyigSI62RGDBUxJCLVgZcGDFiuIDBF8aJEylguEiRQkWJDzBXphgBo8iTOqls4UIGbVmxX5gx99qcK9dmXbp27dJVa5Yuzb+E1XoFS1YtWK548SI2G9cnVKB39aLGjdu1bNisTZsm7dkzZsyA+aK1ahUtbNhIRYrka968cuPChfv2zZs37t66if8Xv638+G7l02/Txh49e27asmnDVj4beHDSSJUpA2TGBgYhPNDABhywMEYdk1yCS0/iNNjbNdVQc82EVO0QgxEvLECACWERFFZEZFxF0A0t7GBHHGpMkkcbcewwEmEpmGCYYiTBkMJhH3wQWFomdNCJTjz5RA0ywgzVSzFu3NDWDi24sMNAMmSlhEAixTAlFUbcENZWO3zVlZZP1lHHE0WUWWZeZNgh5ltymaTCmyad9OabJ5QAI2ElaKBjCiSgxNhjhUSGDGXLHJOZZpsl+otojOYWDGbBCIOLLLC09houuMjGSy2lvCLaL70Yg5yoxpSqHC20dIZqc875QooesDL/Q8862XHXnXe3njdeeuipVx572nQDbHy/0VfeduGAI841uejhgw8zhCBCCCFYYAEHImRhyCSZoOKMsstCWM2442LV4UIDOBBWiwppAQgZL7TwQgxIERRHHIj8AUUbL8RIGAkfmABwCSqYtJYLAHvwgUkpYEDBHkAuo8wx0BRT5DG5KAMJDS7IwCRFIeWFlVpzqRBlWltxtQMY96oRFlgsk0FmmWmZFINTRZyggs47/zXnzy7MVYKdd+b4L58nFGEHIZWkMhtlzhwTzNSHLsro1YxitssvwYwmy9dft9JKpa7dIsstaN8yC6psr3JKc6eQIvfcdOtRhg+wTmOdduB5/+f3eeaJ196wwGYjH3uGZzMhdNtg841224EDDjfMRPIsD378sMIKFjwAAgg95DEJJ5vc0pNv1Yg77r1axMHUDgsMwFAMHcbhlBIZKQEWk2qo0cYkWLRA0kyJqaTn8IGlELDAJZmAAQc22FLMMsv8QkouQRWZMSs0GGHXCy60UHPHdsWQgl5B65XQC+xz6aWWKu8gQ19zulCEzIal//OcJ8QJgwwqgAlKCmOjodlIeRpQwf8m4TSdQCNqU4vgo7T2qUdlbVGHGo3ZZPEKVYztFSCshSxikbZbwK05pNjEJqbDwukMIhKDgNWz9hOJb6xjHtvxmw7Ds6ttCI5w8Tmc4f8Kp7jFsWcb2eHb45R1jVg4iw97+IMQNvcAz81gC4LgBCdOUYxopG5cE6oG7u4VByzEAQUHaRHL6kBGNWABDDt4gYfYd4NCqAEFM/mABvaYgQpUQDEuyJOOSGASmqTgAhfgACp2Ag1oGOMYxYik1IRBDCFQoWYqMIFe4CQnGRlsfnmJV/taIDwTyIuUFKHfX/onp7+UgGdxGmBgBngSwtSyYHz6AAZWsscTwMAIDKQNLmIRSQlGkGuZOeanIIUZYSxqg7WoxdhgcYtook0XaJvFKeJGim3KjYWDCGc4YSVDH5RBD6u44Tz6tkPyqAeIiEucPIHzmwn9Jj7eQNbjtCP/jmSBQxmUGEQi/rCHNKwgBCBggOd4MIdFUIISm/jFF7+IFTGJ6Q9x0JBCbqCGMu7gXmCAI0UIYoJ4taAOwvPALj+QgV2qhASF4VOfZpkjmDiAAhagxKCcAY1j+LQYPp3aMvxwFRnEyJN3IgmM9gJKUYZlfagsZSr/N5c69axOJyBB/wBzp64GZjAnqeWNEKMnPerIBUpoWjJQMYgiDUUYcDXmBKm2TK5R7TKiIQ0sxvYaa+IiNNhcBd3mtkJxipOc5TwnMNR5q3a6Mz3wDKLhoIMN4GDDnhM6HN+QtY7OriMcDhIGJfgQCD/A4aD/YYAFRGADPEAinKdQxoOuIRAx/1WFCmDoQAEkgIUbsMyNfwAEGN4Yr7wgrKV2aIFKV5qBDOhRTzEhGkz4pLCA3dQCaODFMpwRNUjqBJK/cIYphOA9mcYURjTZi2D2khB5JWQmpozXTORlIbzEBat7QZjPdpYCrr6JMAVLS1w4KctAPhemKjDCJXICC0qoIhhDiZQw5DrBqtlVgqLBRS1cYQpPHGIRioAEJkqBilac7RanaGEKp4PYFu+nDJ971jPUuUMf9hCeQ2RPZouI2R63B3L8tM5nx9HZBkXjFIPgAx/gMIQqPoABDNiACGaAhj4cghKy4M016EAFOkiEDnEAQwsUYICtdJSNiEAEROJwFSWYz/+PFIhBHCqAgeYaTwNe/RdMSUC8FFx3BbBAxnaHEUkiAXUXy7DFD16AEg1kIKZKtWVg1huX8M1LqvIyafvQx783wYQE6KslYNRbML6kBSUoqUlfDthfW5KhE7YgxjKgQY2JTS2ux6QwpIwpm1qIog8raMABBjCAAAzgAAp4wAwCsQlUfKKFLYTVfhD7Yh/EWA/V6Ow8dKged8ITOofL7ISs0WPMBmufQKaHdebhWXbPAxy/GMQd7uCGAFURyqqF3h4OAYlSFOMaU8EKFchQB0BQ4QUJuAAVKnGvQgACo5XQQh3ooAQT0DkDE6gAIAT2AQ+QIAMl6FOlDaNnmB61BR3/QAENemAKnnbXp0Ip9DLaQIMTYNwB/luvevmSl02q4NLzLakoaYelNz2BDk9wwQmMQAct9JxO+7OqzpQOE5lMmi8xgZEC9QIZXiSjkdRwhjIiSfaym30Yw2ik2CdJG1GkoQHFDoDc5z53YjNgBWjggyQ2kUIVrhCcho2hHmIciW6Iwzrd4I6uzjOsxYtnctwQT2/gY89gdUNy4lhHP9eBHX9CjjvamRxAfWAGIACBBxtoAAOITYEO3MAPmMDEJlaxA4EP3ClxoIMEFgAGOmjpD4X4g0SMQIYdkMCPda7zVEjgAQ/kSQN2Grl0c6RUUmLABDSowSS+/vJjDEqS0JgE/w1MoIEKROAu81v1/9Kil8LIhUnwJaUpaZeXJwAwv3hxlxZAXQctEGyVrqRVr2QYWsVVI2EnBINgfREDgYILX0dr1EN2aId2ECaBE8hdE2MxwmAKVQB3xDZ3AhCCdFd3CmABS8AHjRB4Kih4sBJjq6AsiKd4ulI4OvZDutIb3dAb2uAb12AN5GZ5DdIgnZVE33B54AA5n1WE4EANTgQEZuADQBACDfAAB9AAFIACKMAFV7YJSkAGdPCFYuJlhdACCdACTKEEdmBwaqBJO/ABEZBxGFABfXQCG+cBJtBxH2Ang/FfeDJdKoBKHWBKYIAHxPBAPgVzyPBT0NAKNZBVFf8wAUyVfvkVJ27SXzojX/MHXzOhEHIhEqv0SmFVFTHwSiEXgDGhVTsTXTNxIzKxZ5JWGIAgKA8EDcowdhRGNZmxGbUYSapBCVRYAAQAjCE4jMNIdwIwAARgAAwgAmlwB4jFByzoYjEGDIZ3Q4wHRDxWT78xW74xeWE0LtNQDeQ2RILTDZDjN5JjhP0UDsICDtegDJuwH2igOVXEAVW0AVcEB5LQFriDFbgzFTvgAOrij0yBBUaQAh6QcXSGARPQRxlgBy+AASnhASmAZ3s4GOdVEvOSF3boAlSgBq7AXYfofYl4DMrgDMSwBS1QAhQQATunc5SIajtjAidgAnYYX6b/tCXC04lXNYA6U1U6k1UBGHJ9QnUsMTRDQxg5skcBQxgvUAimEBvJsF2JiIuokYuJ0guQVAybcgcHEAAFkAAJUAACQAACEABmSYxnKXchGIwK0AAiYAZ8ACvQ6GIvFmPPcA3g0FmWR0SSNW7VQBzSMByCKQ3RIA2IGQ3RYByMiZiECY7TcA2J5w02loOXJw6Jx46X1xu3MAhQyAY3wAIhsAIg8AAbEAIzwAZx0hYwGQMmkAAZEEcJUXtGgHF0hnwTEIcVoASAgAILYQIvgpGpRol4ERY70JFKoAaZQD0jOSiJ+AwU0wcCcwEuGUs/s35x4ZSMZpM3qUkFFwcq83Q8//OThnECPodVWVVWWnUS6fkXJtCKe8SUNCkXhdAJoeAKuCAMQlEkcIVrj1JhWpMaxAALaBB3YmkACGAAwEgADJqWxciWwWgAEmoBWzBvdElt+2FtIKAHkQmD4xFPhmNPPhiYxGEciqmYJrqYz8BdzdCiKXqYijmY4ZgNwlJZk2eERQgcwdIgzrAJa+AGa3AGa7A5IbABFnCagxFpJJFgtOMAC0BfChEDGRABfmR+VEqlE3ABJgA883InsrRU6kU7XHF9LvACauAHsnaIyuCcxxANx0ANnKAw5jcnWgcn7UcYJ9A+NamJJSUW7EMRYVVVLAF9BUMnREmUejI0QfkXfP8GPpkUn03JiiZQB4WACPbJCrNBDP0ZKbfWn56qn8SAC2ZAbAAQAAmAoAnaoKpKjAGglsEoAAXQAFRmoXapoZGQOtyQeURUbj04LsXRosBaixNTiz41rMKqDMzQosfaDM+AmOMoLPLxoX2ZDULGDbegB/PmBnfAA6MZIBvwL4hBNCmgBEHjAQlAARjZAsc3ARGwABEQARBgpRl3AWLSAjHiccC5iiVRGGHKFS9AAXbYAiHlChIjrGwaDcoADbagrhVAAXSySj+TVTCxqJr2AvM1ShQBlHXyaYwaE1mFGJ8GEx9wVQGYQP/FR3+UI83XAWhYB4jACJwAC7PBC/1Js8T/oIH9SQw6qxNmMGwBUKqnKqFCOwAFsKDEJoLGeIxyNwAMQGWwMm93UG0aOgvjwg17GaI96IPkprXgKA3NgBzMoAzGAAwXNgxTY3aRZAyRNAxqy7bNcJiDeQ3x5EPpKB7fAA7zMCs8Sgn0dgZ5oAbTUqThKq6e1DEZsgAdd4cRMKUCCQHw+ogZ9wEd0AKI8AIwdYfJUxJuEmAe468RQAEYUCI0wAnLsBMTMyi1KA3OsAzJAAYmcAEVwGh4yj+S6n46Y68UYbFC5y8lwj8h10t79GlDA1MSu5Q1KRPI6wHQ53wIFIdxmAHNdwEKYQR/YAiJIAmYoAmawAmeoEWe8Ami/6BFKvQJ5PsJpnAIDVAAcgcAAJCgEgqMRfu+DToAazmCP7u0d4cGcIAG85ahzwICM2AM0lANhrcsWnvAI9q1zxANX3sMxjAMwEBhaEt2x2C2QPXAzLDAh1kN2VAfjwcOOGoP9nBDmncNs6AHbsAGbKAGNYBQmqi5JqMWLlABCeCSdfZHkOu4CokBPOwBFwAIRoAY5hMjWceHTcJzmFhSQiAEfiBox1qwDzQ9bkABF0ABpRQj5EmTAZMXAGQX/VWm/AoXqFZVqUiUPnPGWUWTIYcY8NUvpiQwMpHGJmBndIyvcVC9jPAIhmAIgtDHi7DHi5AIi+AIiSDIhcwIjDAHD/+gAAsglo7syEJbtEZLv8dIyazKlrHKjHNJbXoQAnrgDF5UDbPVq2CEWb5qmL/aDMpAaGanDBJDPdwFy9zlciz6ttQARuACLkG4y5lXZOJADafAB3iwBmAgBB2AEjTBflXhZhW3AA5QkVU6AdLsuO+6wxVwAUZQBzNxEgLDZ+c1X01iEsITMC1QA2DABrZQumt6rFG8DJRgARRAAcsjMDJiPk0SX+HDmul3GK8EgAFYJ5AasiLLUjmisgozEkKHAs1X0M1F0M1Vpc3lAWqwB4VgCIvQx4LwB3+Q0dULfHzc0R3NAg2wAAvAyGKpAI8ctO8LjMTW0paMtGhZtA1gA3r/sMnSVgYzEAkxiqvk0tOpozqJiZiqK6wWU3Ym6cq1uF2rO2uxTD3DusDkkquSc4T9BMJHCDm7fA26oAenxwIsoHVBIwP+eEmDUQEG8EdvWM3v+obSvJANDQguYIcAw8bfXH3ifIemRANtUAOgkAxrarq1CA3RYAzKAAsbIAERQEpEXBL22nO0wxRpcT5yscYiK4B6ogEdixhmBTCOphIge4fBCxMc2XzQK7Ie4FwqBbvOmwEvcMeFUAh1IAeyvQcWZVEaHUV7kNttYAENIJDOXNIkXdIpvdIEQGwM+tL1e4wF8JYzAAdK1r93Ews7nTqP6dPkIpgwqpiqPHYRNjWE/zYMkETYzvAMajfeqlwMbFsqb+uY1kA4NtYe46HL4HAMlAAtPhDGXJwVVJEXCEnS7LrWa12ldIayFIAVN8nGSyrOURUn4HwDNIem6nysiqkMwUAMM1DFM1EwZao+LmKv5yM+RnUjcRFyh9qeBR2uG0uKZlVdiHHaexTHHwe9iSswp918GAC713wBGPBR98JGcbAHckDbbOTjuf3jctAGbWAD1kIBEiCQTurbJI3Sjyy/wXjcl2xsRHsADNAAK8AFcADdZdBFoSyOhFnmw6HAxoGYGrx2kHS2R32stdiizhCsYkvYPpXBQj0N7R0flZUN8IE45pHLwIzTip0+/Fg+M/+MARGQAA7w3wCukAupmxPgAVQAX3xWqGFtIcQJA6YkL2DgMmqAC4UirKqs3bqwDHzAATuuBF5GBeijBcXXXkwiF2QslBArsbd+irkOfQHzadTnSg6pEicAsnZ22nQshx/wJEvcMihCRmREBc6O5GCAAhzAAVUsAU3u5E4a3Iws5ZFctAx65cemAMg2AA3AAl2ABs+CNzz1DD0Nt4V55oG5mDt9otEgdhPzU0AF56QerCaptsTqtgPcrOF4DTqYWdqwDd/xDdjxWZPDDIMAX7bkFrVkflNK0gC+1goJ6RlHAROgFwpDE44t1sYZFmWSPk/y6T+AChJTrC1qmM4QDMj/4AkEQko7oAVuFiVPRUqX9iYbiVUki6gmYwSBlOKkuEf4ChP0fBJ61FwfBzAYcNpyGOx0rFWnRANgQCJlUcxLLATD5fVfscQ3IALVXu1Mju3Y7uTBHdyQTOWXPAAKgAJYMAU2MGx3V3rPQgmNdJjU0PcxKtSAn5gmapiKCcr3/sqrm++RVIvcVd5s/kiuLHalogzNKtQGP3k4aLfhwG6+fA2+gM9hLRJKUAJwKM0OkADuqtZtDbnTXM0fYM+kRDsWIjLGqRbew8X+eAOC8F0m2aLUcO/HIAywQPYmtZrqYz6dXlI78wKMujNE+WkrQSd79CYrAf0N3XzYD3IOGRM1/54BFNBcFOBH2C6HVdp8JoACKUftHNABKdcB2K/QWBj/WMgBKED21W4B2H722r72JH2gQhvuACFAQIAABC7smdTJFBYDAxiI4DFjxqpo0KJFo5bx4saN0jxKi/bsGbRqF6lthOZMJTSWKpW9fLnspbOXx2oWK4ZMZrFfu34VO2YTprKgxYL5QuqLGTNgvXLFIjXIRAuqLmTESBHDxIQKXSNEmJAAQQQHECpE6Fphwlq1EyJcwFDhRYy5dGPE2EE3790YLlzEMPKXrpIdN3jwQiZU2TKM0JDdIvZDhImpLUykSKHi7w7Llk2oeFFCBYkTGjScOEHCNAnVpFGTEN36RP8J1ho8mCDhQXeGChkmYMigu4JuEx08ZJBQoUOFCxk6UEieIYMJFB5aoODAwYPxDt07VNdtXAQKGihYoBDRgYMFDhTcQ3cQX/4C+gsS3DdggAABgQMDCEiAhT3+mMOCAQY4gIEVfCgjmJRMyoglkSYUqRkLa7KJGWM2NOaXXHKhJcRZRoxlFRNPIQVFUlZkkZRNNqEkxkhmnHEQGmd8MUcWT1llmKZ6WWUQSl6pKoar/EqhhA8yiGutCSAYC4MJfEurLa4qsM2DD0zASwkqCMurBRdSaKGuu2Qw4si6bqDBlGXedKalN5epBZlMUOiAsqlMEMyFF1rI6wUPTgBNhRL/TJhNA9hYQ422ElBTIdLRYGtUtdl02y647TzA7jvyaOjgAk/xFJUD9VBAocwbyGPhuxbOS5WGP0WNVYg2hEBVPQssiA86CeRroIH46rsPvwL2E+i//gpgtoADCzhAgQ1WQCPFF1dEcRBtt7XxRm8j2aTFHU2MpdwQQ/wQKWCAGeYYZpSxsJkJo5mm3mvu5aYbcPYVp19/1xFnHoHF6eUUXW4p80wZ/oJNSQ2YrOADDehr8soqgdPggy0p61ILMHfw06+6BLvLBRUSjoGGSYgRppg5kSGGZVx4SYUGzzxTIaurbm7hBMpKeFSF2WYLOjXUIPVLM0Nr4w3T20K9gIML/0S1YIOps7PgAfY4CCGEXbPLztPusAsb7At+dSABBexTgIY4hDgvvfUkkOA9tOUbdgEFik3AgGP5E2CAgQI/sPABoJVWD1IiYXGVWXLhcZUQfWE3XpGi8ajeajav5hpu7gWdG9FHF31fcPQ1nV9w+uW333D87XeddcqhfZ1xwpFd4HmaIaUXWUpJwSojlchZ0SUrwCBjiSNIIALfpqxSOtM0ToGyFvAyYq8xU2CNMjJdgCFpzIJ/AQUwTEGlFVlkqaUVVlAxxRRXbMkDVRMENe4vJYwIzIUyhTbBoQglmtS4poBAe9RrVCMd3riFbg9E2wIYsIAGHMCCF7TggQhCEP8AbJCDGwRAB0M4QhKWkANxaEMNaMCCFYhAahSYmnvoFp+70ec+e+vb3wLnH/8QhHAWZMAMcJERaowOHJsDXRKvoQ0makN0TYRiN6Q4RSpWUYrfwGI4vhEOLmJxi1wEYzjGMcbbkZF2tBvHOgQ2jVPEgheooIRf+mIkE0iMBB+IS/JUkzz69KY3cUFeBkxjmtvghjJ/eUEi/eICPV2mBUqL1PgwYwIaLEITn/iEKUThCU5wAhOYQAUuJsGC61RGS0eyDJlCw5oPaEkDfvzKVyAwSwiAxStfcQAC/BNCDpbQl7/8ZQAKVwADJEBvCmBAAx7gAAY8QFgOkAAOizmgOGD/QQg1iBvYsnMBX0GzhvWR5t8E15/++HAA+UlQCHBhkc59bhqcs0Y8rXEvKNYziky0IhW9sU9+7tOL4fBnGG/HRTKKkYzjKMftAsaNVcRCGKzghCSSVILpJY8rFWMLBcjSPApcCQMfxVTGPMCaOwKnKxdw0gQo0BUPmIaBL+WNex5whkM0ohGYmEQiErGIQwRCEaYIhM2EYLO5fAYzmpnKC4R2NKFpgDa1aUtanErS0pCFPg5YAN5w6U1oOuBrGwArBzawtaptgAMrMCsH8GQcVF0AVahqgW5+RYDDGcABf8BrG9TwA2yutQNy4yZ0ZIi3+uitb35DVjn9AzhmHSAA/yuoBTSo0U7OVUOel8VGZjObDc5mAxuc1QZotzHabUCRtKclbT8DGkbWgpF2XIRdLlZBDFlwwhKMQEBu9bMfA+TWt75NAFYd4DwMeKA3xwGObkSqJd1cQCAEICYC6POV4dxRA8CBqVocoAAb+KGmjpjEgAQRCEg0AhewcIR5blCmHRi3ApdxgXM6oIIlZYAEJnhlldwCvf2mhTcMdOlxM3AB5sBwm+oJW6jcY4GoITg7rcITDJ/TgRZQoAMrlBpW/Xag/FCgEIYwRB7kAAYh2ABWqAJsDLuJN6waNj86TBYPn8usDs7gFtHYHDcqO0/QYeMaPvbxNbLBxM6CtolUjP/iFL0hRW948RvbWPI3wPHP1orjda/zFzeMsYpi3KIUopiEHyKAAVqWZbi1xOVXuLJSJlE3OHmU3nVt82aNcoUr0lnpSBfYm//ypjdYXYF3F+EIR+DVDz5txC6S4Yo20OAGoWKSCUZavY/W0c/SOctaYum8PXfl0qapkh/3CxYMgOU3U6ubA9ciqgxEgG4X0I0KPDC1C2RVamq9QAMU4DdmCTM/FjAEIxDxhz20gQ1YSAINVkiV6iA4sDNc5jKDZdgcJjZZG3wuAUI4gDLsoojgwBfpusENJ1YxX1JM3RRTJ47Utft07jYd7OQNO4DBThqrMIYwTlEKVrghD4eCQFn/JqCBTVdAo6RGi1so0KSudBS7gkyeB4qbGz57Oi0Ye6la/JsBrFqgD4EQxCMWsYc9HMIQgWhEK5yBi0W0qgMkoEAGVCBp7g34ONI5TlpsGb2KR4xKmHa1BCDglljGp+hkIQuLs8rirkhArgYYyDkbcIFdO0twGjxnAoA9CRALYg9yaAOJbzB2m+XK2YHNWtacSZ9wAq6HPnwuQRBUhmJwAxylg3fe483uebNu7333V7v9bjrSia6y1TBGL4oRi0+4AhQrcMMFko5VpG/a6FmlZSzRrHlTXwnTXZkA3VytUskTuDd2Bv0snwSdPUgCE5fgBCOEvYhHUOIUzlgGKlZQ/52AO8AvsO4oW75iX9WcJS0xd68HnnqZFKAFLL+iW0u30+DuTI0yxlW+ez/vlv9SQMODI2Z+9rOf8Dck6xL4AyImUYg/5EGvZ+DrDfqKp1tz824OcGawFLD/aPWNPx6Eu/44HGhhgDKAhSIyor+Dt8IbHdCpBo2oCJXAPaIwil/ohVu4BVmYhRJZhVPwwFJYkRehhBlpBG7RFkoohVeoBVVIBVcQBDdYBKOzqgXYPM3LvBv0L7UAC0FiEkFqKf1SKeYwOP9ykkDytAhwD4SYBE4QBZJjhEmYBEjYhGOgBlzAAxowgQqAgAXAi7ZaKamyLj/rOYObmuE4lAASPgkYMP+NM7gH0JqzQULggI4r+RVTo64stA/ECoBiEr9mKb/7OJy14YA/qIRJQARD8AMRawP4E4JrWiG/ghr48Co3dIAGYID9u0T/ExwPIqcdKgD+YwFN2AVhCIZfsEAMzIVb2MAS8cBWZJEcgREasalZnEUT5JZDGAQ+0EVdDIRdzIM80MU8wAM2YAM3uANgPARK+ARYcIVaYIVMSAQ+MIH4eJItFDgdvJjkGaTrwrg8+gCSui/KaCXk+iiM05gteSWM+SiDSzoh6CROuAQ/eIM5mIRHgBFdoIZl0AQRkLz4sI7qMw4PQMItyaOz2LSOeou1EKSHIUKwiAASOD7866rk4Kb/oqMbSUTItCE/ZjmnhmCW/ADJG9o1Y3IAEfiDTsgE2TMEYhMxNtAra2KT8ziP7nghCtiVXcm/ZNK1HLq6ToyxukKmB1gBOFAERTiERIAESKCE8moESJCEpCxKRdCpqUyEQxCEqxwvkPODPtiDPIADNkADYkyDMIACGzDLHuCBiJCIFlqBFgqB7BgrnNQaN5yWMpCEWjAFPugDQeiEFkCLspil67oY0/ioc9QYbhykb/zGSaKMOxpHnFMuLfnGO8qAVnqYV/I+JGSBTPAET7iENJiDNvBMTdgEVWAJWfiB9sAqrOEmDvgo62uBDsCA3MCAwLoaWhMV9/IjuukKDPgA//t7ILwRvVgKFhbDqvvgj2IqAAAByWLqm2JZGxtSAAdwqz8IhU6AQkcwBEHwg64kORQSuxpgk+ugP21SO2eqRBt6Mbryyf8YAAIwgP1TgAbgAByYgizggirQASgIArNkARb6TxZqIRFIDxfSJqy5yQRV0AR1wwaVtkoMlghlgAmlUGXSmg2wSzxAg0PghUlAAcmTpVIDizpDnq4gTORZx3J0pQ8gE3EspFbqDt1YkvBwmka6PiS8ABGYBE/YpCCgAfWDPUpAhWWgBmI4A6uRgAbQFbOJIeMQleLoDgwwFVRZga4RgbdcD/YQgV2ZGk5poYDklL8aj7dCFUdbIRtoAf8JOKwEID8E8JsFKKa92T+1qQ/5mM8HEIEaYARQCAVOyIR6XITtxCtikwM5YAMwwAKxe0T0oEn7c9D03JsXOxBy+g/oAsm1WRtvihoFddD8i1AKagAJmlBMHFX+ixYMAkkMOgDDWVXDOZBWLZxVBaIHAII74IQi9QPuoC73KC4CA6TjKsjkchoMMI6N0ZPwSDBIcw5MYSvdsB+NcqtHAAVRCIVLmIRLgD1N8IRPyMBNMIMa6BRsmgEVIqUXGKqxuwEhAIMbAAM1cFc1KFR4vQM5wAOSs9c8OLSrNDQ/+AM7qIM68NevK1Q5iINCbYM2CAMsmAIWaICO1I/eQoAE8AD/HIrOOpUPuskqC0ABLOCE+AEFT8gEa12EQAUxvBLYNgBPIZC/AF0rbkrQ+Wi7xFIWASg/A3gmDXMWANRZYOJZnQVAV1XVC0KmCnXDsnqADQiBGbgDSTCFZHAGXmiErrmA4arN3PQOTEkVMn0VZXsVUlI2R2tEIcCCsQUDMEDZOKACLBCDtUWhOHDbfyU5vHrbP5gEUODTa52ETMAETeCET0AMmgGF9asDEFtJYvtXt3Xbs9WrdlUDawqCtJyB/0QB6kCVH9iDS6BWQ0ArqQHRr4AON5y2BviV+tAPYjqWYlqAiDUBOs2qq8K/B7jIXHsADqCBNDAFW0AFUfhYeATU/0dwhEVIBJO1VxRSA7GLSUY1TwuIIL1ZT5/sDwNgABqYA5KzAQUIAJ4dIZ11VQQJ2miRTwoFX6It2rTbFbACARDomq4BgQ2YAR9AgzXQBFOYhVdQBVDIhEUohEKYPSjkX/6thP/tXygUNkQ4RMI14AMGMQLO3wUWXkIt1DjYAXVVA0HgU1H400x4hEzQBErYBF5whUXAgxtYgbMBGwsYLPw7zwhVYZ2cUGJZgAhQA0bQKUYIhVRog0vcm/qIWLV5zvwQi/tAgL/hQziFutZ13a7yKhNusF3JUzhwhUUThSjmpD/F23o8RLwq3D1I3HaFyfOoUrlpjxoyFrfDtsAxAP8LqAEssIEG8CDuldXuDVoF8N7wTSa6NF/0lYgZ4AEfAIIyQIM7uAM90EVtaQRHeIRHmIS97dtNwKRTaAX10UBVOAVRwASvq4PiJbEf+IEewKYTM9C089ShVeFRntBPndO+saDys6D9g0+1sQBH4IQqhoRHeMpGUAQe2ABL3L8XcxaOnNQBEKbC8Vlfuw/6UIFCLDY42IM+qIQ6MAIF2MTr7aDr7aUOGojcKgBjMoCC6C39oIDCKk4IfV2t4YAGYA8bwANWgAZi6CRK8FPgDTnfBV6r9LpE1Ct3/QGYLI8rLWFpK+VM1I/nak/E4cnwMyb6bAI/8ANBOARHwIRtLQX/T9iEbf2EUBAFU5CEGKEETeDbT+CEF8GkkBZpTCoFEBSXktbdTxCFki6FU0AFVWiFV2gFVVCFV9iESGiEQJCDGggVBztQBE1hXXtVOgZfSwTfOW1OXj6cBLEAERDaDVgEP9Vbjn5KSsgEEJDjVfUg7OXqEvoPEiiEgoUDUAoEC/AAMugEQjiBXRKhHgohASAA6SqsAuBmN0UAD7BY+RjfrRGB2V0BM8gDdYaGVOhMT5qE37XWehQ5eB7UrztYgi3eH1ihtvxkaZO2PPwbaxOIA9mPwhm//FAACUgCPwgFVrCF056ZN/LA9HEfVBCX14bt2JbtFmlFE7HtVdADPcAD/zgQAxuYNVqrvxi6yQaNUGgegKEVVfnM6guyOg0CQF5q4w46EAVwA0zgBFDw6JAGBU54AGCu5q4GpjY+kARAgTCICEpABm4Qh2TQNRgYhf8lhAqALmcRi9zqj9zaQt9agNPt5gUogYuNXffIjhAQgRVggRy1ATbgA1SQLGQoBZX+pHrMhJC1Vkk4ZEfQKZ4KBIVW6K7Uq03mZBZ6S/KVtkgVP7eD68QaP/ILyQXggDa4BFOABVzQhVp47ZYOl9me7Vb0wNs+F1pICnZZiqWQF5HYABDg57sZZfpoYRX21Cd30FE2amRS7ipfm1Em7g0g0DvAhFQghmVIhmXAPWSoBf9BYIGxeoBRLVXlNgALSgBVXW759F4LWAEQYIBSWB1x4AY0OAABsINRIAQiAPR5/INCIAQY0KXcGoERyG/9Dr+IRQAHOAFXgyHqM5UC/0/x/I4fcANBGFJqgIZgKOlP0NYdlWpstVZr/d2Rneer7M6WfElsWgH1GHFewapTzuwUX3G3s1TnjJYH6IFHQIVb0LdYmBxfGAZjYJcNGfIhlxdpqJdoj6fPYqLR8qcv+gaEOqN04PZ0kJ10YIdw7xquGQ8XEtO2fKsApQEVqoEe2IItOIN4NwMzgD9Ntnd75+R1n2zJbct+L3ACLXADB6sQSEs0CAQOLul9K2lI4AMzAIL/dy+DiEcDOADGQPiua73ui0aFjW8FWICFWkBtV/iDYHmAA1AEcXCGU+AGSQBmBKgEIlj0/x2FZEgGaBgFKIGAESACItBC4IrYP0SACoCBtxAVtoKVdU/XdmWBG1ADPFCEVEAGlqCGXSjpj+3Mwu6kCe8kTYhwSKjH361K7uyDVw+7G4AVF7rJSrz1att1FM82S5U7BAEBTBCGbxOHdaAHe7AHgaGHvs97vQd8va+HwSd8fDB8fCB8wr+He4AHfbgHeXh8eZAHfGB8eFh8eICHMzCDTTbLPNZjiYAVFvB8PU7L0jd9IED9h4/3M3ADfwuEnRpZ/r2ETHhHT7Dbi44f/00yhVTg/Y+HhZd2aZd+hVfABVvghePnhWAQBmJAhubXCThhieiX/giRLGowBQXoIBfPiDJ4AD1wLAEgAkKYpREghEqYeVsgBEbX+Z0fARrULT50TrnWgCJAHk9pATNN10Q9W6YHRkdAhWIACGfQqEHbVarUJ1GiQIHy5JATJ4egTKXyNInTpUuTJjlytCjRR0F+5LTBcqMGixUhOFiQ4MClgwUJEhgoQOAmAQE6dwrAeRNAgKADBhx4MGhWtXX07OVryrQp1Kb9plL1Z/UqVqz8tnLtqk/fPn7+xPK7g4cP2kCHGjWCRImSJk+gRJmqSzEVK1auYO2tZauWX1uCbf/hwkUYF6/EihcvJsY4MeBahXHt4lVr1qxbsjbLEsbL869gv0ILK4YMmbJlqp0JhAYtGuzY0agR5AEAAIEFHFz5QcNgQAABRAgRQYBgBKFRhCpBEACBCPQRRCBAcGBcpgIDMxUgWOBghJYPJlq8uHFDCBgsYNrE2bPnzx8w7QVBQiVMmWuCuFiZott/YUOeKCQKLMTAIhdEnGSiCSYbbeSRSHHEURJKK4jAEgcXwCRTAjblxJNOQQkwAAHABRVciUQ9gMYq0ihlz1NRUTXjVFj9cyOOOebozz9jYdWPP0ACGZlfke1y5C66FPbYYsJ4llhli1V2pC66IHkllrrcQmX/lV3eUosst3SpSy60lEnLLWlW2QubvrgJzDDGyKkMM8w08wye0kgzDZ/TVPMnN9c4c8Btxs3kgAUdIpDcKNERMcooMhAxAnUjSGepBhHI5F0CCniagEwOQACDHSm0cMMO6qnBXnvwCWKIIXLsIYgjlNhXzDL5QcNLK6agkkpdA07Uny3OEIPKJwwp6wlEnmSSySSPJCLIH3vIwQYWKF3YQYYSRBCTTDXhFOJOwel0m4g6ERDAUAz4QEoz4iwFI1Q00mjVVjta9Q9XWWUlZJD+qPIKwQXHcvAqBxMcS8GvHBxLwgg/DPEqFVt88cUUx4LZwbPQ8jHIZuaSi5slA4Mn/8p3PmMNy9i4rM0234ATjjjirLPOPPPQMy+M9uy8c87z+BIAAOcCBdQAEVQySiWVEJJc05VMWpxxVXcHAQIGLIBCpwocQFNu1NVhAgo01HADGGCowYYceezhhyCCTCu3W6VIJgwyy7R2zC2qoFJXgAIyVItrqJQCkSaJa5LRJZZIIokih/jhxx55qPEDDSiw1MEFFLi0AIc02UQuiOriVADqBqhugNcMhDCIL9boTG8+M9aLjzxf5a5PPPDU8zs878QTz++/43MP8vfIc48+9/QuD8YVxxIyyCOPXPKbwGgfp5zG1Pl9Myo/o2efLF9zTTbaaNMN+93ITPM6Na9Tzv/NN8+7VNA6/7w///33P0/NxAEOUgwAdQQ4GgAMoARIPY1RyoEUpJhDAKstoDoccoACGNAA0NFkARXIACCMcB75tKEN7nlb3BIBEpA4QhKYEIUsbLGL0uTNNc7QBSxS8TeFTIQuhOOGLErhkCEmqBOZsAQmJOEIFRpCEHlggxBqgIIOTJEDFHAAuDgItpx8CEQ+IQDqbFIA1W2HASDQwyqqMbsYSaUf+4DH7ob3FXi4wx3wgMfwendHeCRPHn7U3fDksafysSx96ltfN7wRjkWOYxzleCQky5GOdLCDHZOsJDvq6I5K0sMdnfTfz35Hj3qMsnj1SN498MGUntkjZ+L/CFoAwRGoakgjGs8InzKGEYxelIliqyAFMCnRCEkA4QCaQkAAbOKATthiFHaAztKYBinBQGo6WKMOdbyjANAt4AHetMACtumBDBCiDlSQ0B/ikIc/COIQKlxERzjSQkxkgkCykMxncOWaZfBCFqz4W3+AJQpUJIMbuigFD5W1LE4wyEEcEYS11CAEGtCABVP0HBaxyEFxeaiLPfkiGMGYOpoc4AAM2MC74rXG2vGIH8KTRzzeIdOZynSPeMwjTgPpx0BOsqeUtOQlL8mOdtC0qDJVB1KNelSj3lGTdbQpVO8I03j40Y/36Ec+7PENWgAzEsDcxCYoEYlGDKKsZh2E/x74cNa1DoIPgcgDHkZCARM4oFMoQIQrbFEJS0HHgYNxBQMJQSnqaAAC31qASyhgAQ6EQARXdEAJPrAcOvyhDn8oxKsWAU9HOPQRk6AnJ0TBCliQdkvBKEZqnIEMy7giFTr81d9gwQu/BSuhy2LWs57FEUP4IQ9tSI8QbsACznkOozGZiXbENS6QhjR1q8uOAUz6gBlQ4mTawBk98NEPfbxDHehQx0zlMVM93jGn5p3q8JSnvD3KA47rfcceqVpV9NJ0eME7KjyQ2o797veO91DHfmWaR3R8V8DDU+o73NFKX5TBBz6YARoiLOEI36HCFr7DGi58YbXyAQ94qFwb6v9QiToUYhS2SIYtJjVYCIwAgnmFIASJYykYaAADWKQABziwAhawIIqdM4EJ6jCKQiCiEIZghCMe8biNXCK3nwWtKFLRiinDohZbwtsyiOEZW8jCFf/My98Mpwq7mOIgPOThQyKSiUs8YhEQlQNJTMKCC10gQ8YNJ4eUy9wvjjF1fS6AdDcAgkgA4xo4S0cn3dEOOMp0qnuso/DOm8edyvErX+HKpflhad5tutOeRh4fkfcVVIp6H3PM40vNm9Oq3oOU4oiEg1UChFnPugc9AMIWcq1rM/DaDGWYMBr0oAc43CENWzADHjpBjGQwm9mVQACLjcNiCFKzmTAmDhFkoAL/D+CYiiy4gXrcwwIOoGAHcXBFJTbCCAcx7lmc6AQnJpG4iIACFf9ERSscVosZEiMYlSnMX7yMioGjwm+uJfgpaissuYSiIdBysx+qJQcwCHeKVfQcTMCF3DDu2UPOFcpQUEeoATCgDC0Cx83mIclIO7qp7oj0pNMbSN75sSs2vznOc67znF8FSFfhh6lvbmrt+rwfPnuGHsqAAxGEgAdOf/oMZgD1qEfd6VSnOg96kHWt82AGmUgGbQiSjFFcEzlLSw41p2niEzPNDk+gggmoeCosvGEOfmAEI/YwUfaMIhWVgHeTMwERwUcE8AmSC0VEUYqC5ztM/q7SZGzRWryE/9neefEbwckcis2HIljOihY8efvEbLGgolXUkAQ2pICNd3S5HR3KbdB1otgH4AA+KEUzUD6PdbBDwDXVJHyjCtXc/XHnxj8+8rdiFYD561/1ClIrV5F0HGju6lFfAfYtJILsaz8E3v9+Y7EvAhBYiBG4CDttkkEIrBHC2o+CMQRRfOJO2MEOdFBCC07Ftj0sgsmdEIQQuE0o2EIndAIocMIBpplcMEQmMMsC+kqylMIpqEK+vYKYHElkyIIpcIIpgNnA4UVeXB4ruJZr1UXn2cVCKMhGtNmbgcEPmEcLoMAUdQ7GaRxN6JlPmE4BxR4P8iC7kFwIUIIxcAPODFXwqP+DJtmUHflOU7GXPqCXqkWhFE4hFVLVHL0D88QDzT3hzMnDPkwFPuyDP+xDPmxDJLQVHsABGsAVHMCBh7XhG7ZhG86BHMQBHcIZHb6BHNDhHc7BF2QCLzgDN4Td2Kmd1DDNcsDfcCQDMUSNEcjgDUxBG/SBHywCkkVLGrjBHuBVKEDLmmECJmjC4D2LAy7gXJQZQA3cBBaDa4DJK/yTJEBCKHbgPxHGXwyGLVSZK+wiL/6HKCxIk0mLIPQBHrSBGfRADWQOnSWW6s2E6NzEToyL6YTR6qjOSGUQA5yUDwghOMyOVPyLvfhDqOkOFFZhzOFUVe2RgakaelWV7rxD7lD/lXxNFfHtzvGkkj0AQ1kFAh6gQRrMwRzAQUAOZEDCwRscZN2VUAnhoRzooUMa5BtwQR58AthxAzQMIootTTMxytMMB9MMVieM3WQJgRCY0B/4wSQ8TiZIArT4AUjsIrRMArM0y0xKxFwMiOKVQpnp5EGogiBSQy28Qq9ogiI0QgMOFF4UCWnJQpUF3C7Wwi7+DSvYQipERDAuwiH0QR7AwRmogZzNII5pSEaF0+o9I0jxxOlU4zUqQANswAw4WBlEQi9cgzeylFXog1XsgxhuhRV22hSu4/O0l/A92hIOpn8lzzs8ofBwIRz5kX9Rmh+9QzvUQzhEgh60lRqaAUBu/yZnAiRCHmQbyCEcuMFossEamCYbuAEblJAQuAEnnBizSZ5ycCQDQcekYBOLnV0lFAIdsMcfLMLjSILiQAQmxJsn8EJFXIJcfIInJAtO3qTikVl/HARYlcIyUMMyvGJ/QEJc+MqvSJmV8YJjwALBpQIvelkr/M2J8cJCFOfDSc4e4AFJUFxKrMSF2FlGbVBZcpSHoOXpjFFNAGindMAfNCBC6MEMoNEzvBJTAAk/fBd46QNX9GXzRCaCGRV53VGCJaHLPZUdfSgdhSgf7dFX6FRjOmZjPqF4SSY7zAMzXOYg5MEboIEXdKaNfuYbtAFpkuYatOFqoiYbpAEbvKAa+P+BefICYEVQAy0HtkHHNWHTCDhNOSHCHxgCIjyCgiSEKHICc1pEJtQCL8zFXCTEgPhisEgnQonCJyQOgexCeqLCQniCXeBFUyKGLbypKWwepLiWK0yZ4fACNDgDKkiECmLlMEqcRFWIDHJL52RcTOxn1rQen4URNWoHCkyCKZwYMWQCCDQACMxAJORCUjSoOZQqOuQRP1Ao8qzohRaVhtIUeLXqheJRTSWPfxUmVFkagLWoOJCCHgRCH7zBGETYHORB28AZnLUBSSgkG6xmG+ToGwRpGwgptQbp5ZCkGlTCLkqetTmN1HTkbUJbtB3HCMiAHdQBlf6BZ2nCJ5wYwSX/BG6JAi/YgkL0h3TWhU5WHsHB6ZpSwiZ8wkF8wpnWhb01pWD8k12EQgE6jR0sjXeqgiqcHzWwwk0yi0YsAm81UW+1wRncgNlY1H1agMhawANolDMmQKTumUiRCBipzgK0QB+42Qw8QAM0AAOU1AOk1DasgyONAzm0g4SmqhbqDvIQVTsAmGQirdFKJoLFqqzKanrpgzo2VfDR0T2+Q4vOA9KZhUF6gRegQbHmgbEia7KWULOywdqc7dmabbOqgduWXg1gAR2MAiOmnTMJFrhijbg2B7RBmwxY1kZAQnN+gmSchiwYjkJcAie4Aordq13oq2thnuF8Alh9AsDqZH8Q/1xfROXfbF4nOE0dwIDeEgByAEIl+EoryAI1cAN/eJ4KMoIhaJYhSFx6YMEP2ADI5liOiaxGcRPKpuxNDAXLctFNBGgClNRQHICnHIBQlBQIDAItVAPKrUM6uAM+8I5OLc9/fRf3eheBEZh3Oa3TvgM6XOj3lu/TxqPwwGNMwVfvvMPv3IM7pAMArUIZ4EGOpoEZbAHYciaOMmuzpkEapG0btK3bHrAAYx8NeOUkJAM0EINsdoKMdeQIWI0AFA0CCEB3lACJTUJDaIIoqMIyIEMwBAMyCEOvCEhC1AKK/dNrDRzEXt6+quIpHIQN1yvBhuBesEItwIJhIIIMYE1OnP9IcIwKqewiBSIDNPAHQC1EJ2jEuk0CxorEsnolSsigCGTx7macFhlHgKpsy6qO8I7xAMgeUTDAA+jBKTwDEepMPaxjVZ3v+ZaqOXwveCFVUskU+s6UHH/v054q76wvqx4Y/NYDHdHPNejBFqSBHKjBGfBaGgjkZuJotQqwJUurkIaBGgywJXcBCIiA1IHbIqQCLqBCLUTQpMgYNmUwUJgOAmjAckwCMQDlJ8DCDC2DMJyWMMCpQnwCKtjCA5NgXuxFKyCsd77CZryCKtSwDWNuKvCFXyybrjywCkDAhwTFbfQEtCGHY7wpedobsPSHwq4ZRnCEm1XLHsQBtiQB7vL/WH2yROp5iw2ujqR+1EgZABkLBe2FXOu8izJ0g1J0Eh5VVTyAr/cmFYAlNFEZlX4t1VGNb1ERWH3FFPHBnH01VVOIRTqsQy74gNh6WBx6pmfi6BiUtEmngUmbtLCm9BeEwRk8shmkARbEgSPgQjIUBmDZ5m1Sigav8gSNynLgFW1sgn0cCTIcQzEgtSoM1MCZAgsbiCrAQnqOmSRwKSvgAjFcJ22M8JHwwi2IZ7M5sDPQRn4wW6NUsEdhMIs9ygPXAgjeGwoyYEx6xCEEgrWks0ThroVYSI4Z11iunlr250f5hHNpx8l2CjctQM1q0AOAABqQwjF0I73wCL8YtEHv/xcdm8N+4fFM8RdR5XF3PS1NBc/QmpfLZfQ90IM2DIIPFKscgHQb4qhsH2RK13ZtfwFut7Tb8loYqMcfSAZiJIMrYJulUMoESYdtStsI2EEs4wXBallpJHUx6IIqIBRA8bAwyILfJFwPEwYvKPHqcsMgol9+EAQ0ODD6mXcydMJgGQeIbDMRADMEA8t3/sp/NJyC6JZHTAt81IGEYEES4EDpzdlKNOqdhZMzWqOk/ufqIMBhJzY3sWUDPICgxSUwqNFTWAWEei9mZzYdn69nezaEdhceQ3Srlmj70pSisdQ9zAMwhAAOwJkbkCYclNBsy3ZJf4Ft43aOf8EV/DgXvP90rvW2EKjBa7KCJ+SV06hYczyHTsvYjD0BIuzBIXjCJqipKggDMcwQUgtDLSAEwFruJpCCMg8cYiBDVg+EeK/5mpM1ebsG2BEiNRCDHbQ3AuBEcGwzITAbLmggRNCFDsX1TKpgLEYOtVRWHKhBFQTBDygqo9rZhoDOfgYopYpRg1fNyXpKYnfNhFM4CPjAILTIi9iDZaODh586qvNXHUPohiO0Hu9xTQlYIBtVHdUIPVRmCKxAG6wBrwfpat44SY+Bjpt0bvs4bv+4FEgBF4DBGWwBEHBBGPxAa8qrYNBfdNy5kz/509gBi6WAEggBFFzC4l05KojnLmhZkkyu5VL/LuWSwinsgj7lDW1wgyy1OUGkN1mfN/qZtaXg5p2viwYfR/sh6QZCgiIogiZ4Z7AsFEMlkSMowhRXy4RoskmYXgdcPKP6tQ0iVzVeutUcdtdokac4AM16U4WTwhDOw6qbOh371CShOh23A6rLMVKxukFDtGKO9h5ZBT7QwzP4gPeZJq8L8K8Hu20Le48f+48vfbJLQRWQZBVAQRVwwQ8AwRnkQV51ApMbB3Lr9HAMh9SMQAqUQAsY6Zcnji/jgjBg9dr7IruP+SoogzKwsQ0JRNhdQzWMN74PBJyj37IJFm7qbQZrM3SMgiuAgiYsUYcFAiSgoLA0RMNjAiRAgjmf//PYtoFXeqwMLmrGx/NYhg7Hq47VYLqhOKMWgU5GYRA2NnYjzIKpsnypunw6wPypy/yH9zHuc3ajzbpMJWGP5MM8nAIIDP8An8ElP+vR7/gVFDvTN32yN0ETQMEP/MCi64CzAwEP0EAdEIcMjMBPe32TDgdzNwoMPEElhAIsYMKgegIIm0Ir4MIr4AIsEKxAfcIpHAM3CNA1gANt1JKeSANAVHvWLFo0agepQYPmTCG0ZMkUHkzGy84IiyMgZESAQIAAAgiIECE0apIjQYH45MGDR5InVKlMmRIViqYnT5w0YaKUs+QiQ3/8/Nkjhw0YITdo0GiBAkWHDhegXqAgwf9B1QVXFyTQqnVjV68IDGwVm0AB1gUD0B5Qy6CBObfo3KZLR45uXbt05eZN57adW3PoAAeGKziwOrjq3qGLpy+eOsfq2kVu98+fPWtlQGzYcIazmTBh1LAZM5p06dFfUF9B/eXKFSmvm8SWjSRIDx5CgvCw3QPLDjIhMQoYETIkIULEiRsnVMnO8lDEDh3CpOmTJ1AyTaF6GdMTJkmUVDm7Jm5eeXHgunXTZm1atWnSClLjhjBhQoXJDs6HZovQcOIWIeCoI5CIsCOURBIJRKU83DgjD0euiykmmkKx6aZMOMlEk0lKMkSQn/6Qow2jbjiKBhaYcsopDqSiqioHzFL/gKuvwOrKgLC0uhFHrQAAIAC00vILLnPkuqsuc+zKi5y9IuOLMMDMcUywx6JM7B3GCpOsHX/6mSeXEDJ74AwzzEhDDNBEG2O11d44LTUpVmvtNSliQ2I2HWz74Qce+OxBjN+IQCAABPxDTqTjilPu0EpsSWYRONAQRBNQRMkuFVRKEUUSRfaAA4479IiElFmaqUacdcorbx1xurmmmoOuuaaYVZzhRr+G8pOIP0LsMHQEBAgQgNARAAlFEEH4cGONZdfII49DMslOQlNoAsUmTm7KkMNFFkEEkZ/2aEMNMMYVooYTmUqxAxancjHGGb3SUV4DCijgxnpv7LHHH9GC/9KvufRKEi+99OKrL8neekzhdxh+xzGG5dHH4XfgicwddvrJZx5SyihjBhE662KMNthI07QxriCNNdXUXJlO2Oq0E4otgNBztzDikOFXAgiAwNCffzaukkoeQkSQPfoQxBFOTMmUkkZQOjYQP/Lgg49BsN6EFFqMqYYb8lJdVZyxY1VmGWrGtnU+tcGhhpdRjLOjOaGJCHAjCAgpxCQ//OBjJTzOWIMPRURhBRZWQgElk0w6ucSRSTLEBJNJHvnWJ6FEHBcLE1EUoQPPOWCXKncXUEBGscC6MfV5x9LKdLOw8jeuJQMu8i6C9+LLHIT/etjhxyZu+J2IJUbMYnfysf9nmkHK4GKFEMw4o4swxBCDDTVOdvO01uJ0TbaYkQg/CCBq/mE3KKioAAEICgXa/UON44UYpJ1diY9ABrmaDz3wsHoPZ51ltas1YhCR2MQpZlGMaFQDHKhKlTiuAQxfNONrYxNHfsABjv2MYm7G6cTQjhMgAsigEn9I0B724Dc34MEMa7hDHhrhipeIAhSJy8QlMgE5nExuEozwliHAJYc4tEFcWLjBudKFAtBBhQItsgrsuKK61dHLXjdqnetetwB/kYNItDvHF79YDiPhzi9lLKNkfvewyAjvHYuBBzrU4Y52sIMd9qDHKsqABh2sQARbMAMXuACa6olhTahpWWr/WqMaOdEpfI3MwSNzgKce9EBPNbDBDV4Ag6C9b5MisUUoyMUGNygLDS7Uwx1QiUo5zEFEcHCDs+4Ahzyg0A+HUAQkNlGKWQyjGdL4GqpWBQ6wrYobXhPmNYQxiToUohO2sMXbQGiHCiyAEIjYA7JQuAc8yEEOgXMDG/QgCl7EBBWmqOElcMgJdWriEpOQBCMY4YhEHEIQfvhfHkRklB8khQUo4mMIQrcuJzqgATAqXY7CMi+FhgUBrTOdAobkl4GdoxwVrWhdcJcXM25UMgozXjvYODx5OKZi6WAHPbgxCD1sYQUt/WMYsAAGMFAvkYVcWSJxCptGNqGRSHhkbShZ/0kb2CAGT+gVJ5Fqh0qMYhR0UMNT16CswH3KhXf4JkzB4M2V3AEPQ5HDNU8iiEaMVVSroMUxCpKNUzlwHmNb1aqucQxh8AIZCEmGM13hikoAohKGqNqCVMLNNZzhm3cYRDKIcQpVqCImnVgcKKyVoXZyiHKLSEQ992DPzIHhBzU4Vz9RwMcONEV0L7LK6cSyUB3Z6IqCmZ1cLFrRcWCUjBu1LUc7ykZ5yEOO7rgYPebhizLcoQctXQEXshBTMGABC1mwaZxek0gpuEanOeipTx+pgz794IhDPUEMtHBU4oiXk0odBS9cUYhxBe6pakjDmMqUhjRwoQpC0JMaluUGVP/q929WC8Sx8HCHUnI1EI0QFdekcY0Knqoc63CgBd8KDm5Agxi4gEUqOJE/v/2Nm3JYA5nu4EJUcGMZq1CsOT2RCchGNhOWmEQ7JfEIywriDx6iGlHOIAT7eha0K1CX6CzwgKo04CqtW62N5NUVsbi2i3SJ7UXHuKTbTtkvWgKew+Chj4qxw7f0EEckygCE4oogBFVIrkzPwIUpFBKn1J3TnGbzyPBBEgd1tgElPWvJF7zABDAgg9yQOt6lwu2ZleDsGX5QLiGkGZBb+IEObnCDH+jYm6Nk1hDQgMr+oUQ3PdiCo2k2Ax/cgQ+iisUwEgyOcKwqHKdSlXkmjIxbwKL/FJTI31ZHmevoDUG/mYbGPJ4Ri1OUAsUrztYNb8ihRzjCJz7BbB7EpbnO1qCfKEpR6C7AAQtQ4EXvQh2SVWsABETULXZ5shiNZBcqT9nKD3uYPO5xMXfUYx3G6NgSihuCEEDBCcpN83RzSic3wxl8kDR4netcgyNGOtJ7jrQQwsurkADaUIToxHl5YYtRaFwNLOXBCs6VFBrYoJ/nyvMkxTwEMn3aDGzgEw9moBsxt1TUMxC1D2wu6o7pYRCbmMUxoEENBVfwrcR0iIVBMYlD+CHAuc41ENQwhDXoYQ1l2AR5pDGLU5STaaKg4bUwdMPJMptbHgIKPrlZFCx0VuRL/2nKutalbRcVFCuoTQC4w03uJJ17Lummy7rZ3Q7IIOZ36LhSxS725ZgDgQf6DoEOkOAEIWSVC3RqwpsxT93Z9BQHPvV8DhDuWaSInAZOiDQNhDA3O5DhzyMZRSU+OApXONMWxPgkGGjwzxCIoKXW5n21q21zPgm/B1WoAgtWgHzjrmADIACB42ewghn0oDNT53kjKFGKVtyiGLWqoDDbRmFcsEIUjxAEgyzNrDXwgGZryDQaysCM8lSDFqTweky8DtmbXGhxlHuEjH3CxlAIn4qIu44CKaxttEQA26bCtOpuLKZoocoIjMhhHCyKAvsuSfQCjHKnytxCSuDoMQBjjf8o5h36oR/4gR/a4RzmoRl8AAiiAAomaZKgAAqqgL6gIAiqgHvc7AouD/OaIAh+QAiFUAcs6Qht4AiBD/h8LLSS7wbAwANawAQQ4Zk0jqk6IQs7IRRcwRBoQASQj/d2j/eSr6VQoJ9sjgVmoORCbqhsMAzOAA7DwAxi6tPs0NGoD6pyjavEChKoAxVeQRiQIejUhhqQARdawRQ0QRFSAg/YIA08hWTgoGTYwFPgIA3KIBK4wcGqoRdkgRdsQnJ0AhIaQRNyiEMY4REaARIs6w/+AFm6arPsqwc+K7TILHRChwIsIMhehMgOaizupYqoqF4KYALBiKIq6ovo4hzGaAP/z0EubktKPAqO5ogET5Af/oFIxIEUZiAIclAHdMAbc9AGx7EKMA9m4IyRhFBP9OSI8uwdQ44F+Am0mMK4+snxgAAUiIEYeOGumGrjRiEOWOD3du95ls8elw/5znAJR84bbxCQqmBzJI27Iq0GaJEd9QQIpK5/+pASOEH7cIEYlqEhKqwVSkETEsFvLjEN3uAN5OslYTIN0MAHaMHB6KEbjkEX7G8TPEETIOFpbmKyUhESIIHZgChB+MCehkJcjOIoqM2fRODt2GUXJcBFDOoq7K5G5IUYZecYvXIZM5B2nLFgbGthEgMu0kFL+sEfsLEd1mEacE4HvjEcczAI7NIu/20wZi6Pp37we2iDIhkOHuHxRObxRKqN9MDw4/AgFRrlIBzCFiphDLig06LvHpUvIQ8y+ZYQDXlA4SbNvrjrHUUu5EiPBthvWTZNEBLhJz8BFVqhFnABF2oBFlBBFDAhJe/AJbvgJXczJuVrJvVAGsrDHsShGYYtU27oJ7FFncSuh1KRWxaBno7FnvDpetQA0XhMIa+NXQbqibDyirYyMNzCK7/yGTMqL8xTozjKo87SHNjBGtnyHthhHVYBBHjgLsHxLoMgHMWxCnjKTvYyNmCmTqCAHQMzzyrSsyZJ0nSMuZjrDEKDm/LgqdrgfhTBFKxQr4QCUqDN0cyH2j5rCf9zLucYMilijgZEL0HzTOTksTSTgpI4Yw3wIIAGaCc+weto6BM4wfzwYA3SoAu4oAuENEjlS0h7Mw14wAdIQRzqyB7WoRlWgdiwRRM0YUrVCZ0mYWh6glsQZDr/p8PYYHM6q5+UgilABxdbxCqvMiuM7EYIw4y80hzMc2Bo64v0go7YIXe05GAeoxrbAR7gwR/8QcvKARswYwnmzLoMzroA9D/1UkAt7z+hADQTlOEwctKyKjTaAA5mdJb6wA9UcxH+IJ4mQRNyiRMu4REsIVUPQcMasUF+4NPM5+WE7+X4RDBxdTA9qzRblAZsjgZsYwsCh1lGKTUV4VjniZ74wMP/fiAMAOlZjQ8ib3BIRUDUnsEe3CFj1kEaYgH/qPQTcmITqPSDtHQSihI6u5Rv7kkWO2uo+qmlyOxMnUhNYYdNc0RIZMcvwAhJbIe25MIr5QJPDYZ3zIFh9vQdBBUe5pMWnC8IQA8HGBX05AxAPS9RAXRAeSoIVBQeJ1LHZEpT5aBTQTURFuFxKCsTRKEUSmHriE0UcEISxqoRHkER6ikPIrFk0sAM8NA2bHVFBdNFCzMpdrVF15Bof4Az4Guw1M9T0u8MPLQGjC9qjQ8KcLAKhrQKHG8T1iEf/uEf8oEesq4UQKFKQYETNkFHF2doKuHFKKEnyO6y6klduYkphSAJ/26A5PzJxzxHoCigbxvQtK5SLN7iSfK1jP4OSeIiHcgzYPG0cQXWMeaIjkBKUN3hHLRBDzaAAx4J4bALYuUsNiBpznYKfMIHTzptBu/Qj+SLDTbVWTLrJA7BESQBE7AFFDohQhTrFWqhFVShnERhE57GO+TpEC4LJRqRKN5LVnl2RVHUszqzV0kPell0HluUBSwSI8+gBjqTkuyQbne1BmxwaqeWvh4SIh8gBFbAB5rBHvyBMuyoGrROFFBWFD4BXDlBcRxrcTaEspbNsqQTKFBos8JgCpLABgyzHkXgFtE0TQEXK2VEBMUzX6GkL2zrX+uCAx03g/8CLvBUjih3HP+MAQQewAIQDuEednMj1mL/k2IbyRtB7Q4pkXXlwFk+VRCIdxEegUMuAVsqZTte4hVkoRZuYYhr4RVq8xO8A1wlhxUVQTr7RiU8hQ3GxNE6E1efV2hJE2gNE/j4aYtflAzlUXt5wDqx0yKjNWrJV2qNzwyaT/oiQRy4lkvsyBpigRQ4AUdvAhVm01oW5xQpi3KYDUHMDnNEhIiwwPRCNG9vcUWYqF1Ip3TEc3AJF/DAEj0ZN4Ml1zHck8t8S47vSN84AGJN+OA897qui1H5sglq0A7LJIbbIGRdF2lG1hFyeHY1wRNuNDtewnCCmIhns5zAdScoAWYbQRGS9RBQIg//rEqKP4xnf9VXR9R6mZf0BnP4qtizKskisZnl0uARWZdkKLG9wuAlnxVIn5V8zWAGoI4NBoEZ7CEf1rIe7GEeriEXSEERpmNSakEQdYEn1YlyJMGdznWejgWz5paI0sApt9gJFRgXd3EXhWzIHLiMpuRJAE9On9E80xOT8bRJJMO3MsYeLhd9LUBR62xRDc5iw2c2IPU1uIBMoqebN5WbZlSW68mGE0F2X6xKPeH+UIEVWKEVYKEWhHiIb2E2WeGIqTQnhrmYEaR4YSnX1oBmGK/Thi/ntHhjnfflLHKSbIaSvJp7o+cMuvklS+Y6/yhIjXQ319pIzcAHeEAN5oAP/67OHvBhH/QBH+phHrShF8T1lkuBFwzCGU4BbSlLcgDZf9M1gOXAJSXysw6Yj8gMoELnobfNKrFCkgEDgiP4ohMXdxo3LyR3d97Tt5KHHnwh+kKgpB+2hD03dJGglC9WQLnnC2QSDUTpU1YCgO7nvy7LlnI4nXhYFF5CqFsBiI1aF5T7FmShFWBCFG5iEzZhFMcKWU+iEZ1lEseEfKiaZ2EuV3N1qIYKQSVN9EQvP2dGdcdavuDrLmswfM/5Wd96BsBgDvZAD3yBHuyaYe6BHm4yF7TmE0pBGWwlGkjhRjOEEyhBQyanf3N6xpRyhnGsCoLgHasNXhOYsiubgQ1qSv8UhnDJbd0IxjxDm2DconGT58twLjNcW5RPGqVXuqWny5DGwCVHiVMBqGru51gSwZhx+MVqF5d72HBqQRZk4RZ0YReUfBeCYReK+Llx+ROkmxIogSj/bxGMmZ7+K5nxQFmYpTOouh3Be0XFOwlTNDSn7Qbc2w7hi6zfi0ziW1qjVb5f8Afa4H8GgRvooR7uQR3iwR38u95OgRROIRi4ARyUgRQ2QXEwhHYjh0McIdID+dm+tA3m6yickgkxXMMZ0CoRpqJB3LPLSHHT818DFhqJxKTqiB6aoQw+LgQeABx1oM5kndb3U9ZjPLqoi2Vq/A1y+4V03L9UUxFK9sdxyDr/6Je4U0EVWiGIjzzJeUEYguEXmpy5jRg7MqV+s+VaNIHKi1LGstx4rabLXQkNzoC57MsdLanMxfvlgupS2ZEHHi0/9WTRrhNpkdY35auc2doMeEDM0mAO4EAPVmEd6AGk4mEf8MGO1uEZVoEUVgEauOEWqoOPNYQ5sZRyEtvs+IYPtIkoNoe5pm2hN50DGPlvm2SDQZzJRD3VndFONQotTWqeOcYGUECEe2A/EW7WaV3Ww3GlAQ41Znw0WnISdbtqAiHp/8uWFMERICG4MYRSsOOnW6HZj/oWlFwYtH7af2EXdMHaVYEVelc7ZIJSvm6dJCfGHOFY6YmenhgPXCkN/zQn3W9AB8SbBdp9u0BTx/REn7ZgzbeAXNAa39NsrXnTSF/yDP6dB1TuU4JzHthBHe5BHwQ1H5LH4Qk9FqCbUsoWQ44t2f7YKGnsJKiTKMhluWwmkW2RzJSIb6tSS54EBOHIokVdcccyHdZhL9CSjuhhGvQADWxABB7gAZYAHHHABkq41nHg5+1E17mHNFpS4LlKx5Xet4n9ESQhoD3//sgpqIdaiHWBF6JdGIhB2oPh/H/h64kaFnjXd6tjhySHyuW/KB2hERLB/q9bJWLJJdMgDKqgLgFCh42BBHkY7PEj4Q8hYBJu2fID4kIwFM+oOYNRzUUzZ7p0SQMypEePIf/DzOjhI6UbM2UibbPnLt8+fvr+/fOXb9oqUp9EhRLliROnTJxAeQqaKemkS5MmPXK0yJCgRIkE+dmTR04bNmzAYBFyo0eNGjRYmF2xQgQKFB06cOBAgYK6ue/q1jWHbi66vO/U7f2LzpzgwYQLmzvHzhy7xYvTOTanTvDiebTKpLnB4QGDJTp04MDR2XPozzqCIGnSRIpq1V/GuH4Dew6ePHn48AmEO5AgQYoWOYI0SdIkop5EiTKFHJWqVrBq1dK1S5h0YsiQFbteLNivXbpw1WqFyhRQTUI1YdKEnrxQTJQoQXLkqFFVQYH45MEzZ86bNGGqQPn/XxACGcQDQgr/CYGgQxBtgSBDYCBYkUUXPRQGSGFwgeFHI4HUBRcGpQQED2oAUYYx69TTjz/8rMjPTflss5NPyHnySVCeGIVUUkkx9cgiVPlo1VVZtbGVGlhg8UMPN5BlFgtorcWWWxxcwNdcVgKGZWCGbckll/TUg88+8LRTDz3cDIIGG2qEtQQUTeSAQw5ywokEEnDOWWdqV3zxxZ6tvfaGbHns0Ucffuy22yGJLPJIU5NgQpxxyJmCCnO14IIpL9NVZ911wgSjSy2ygCfKJ5RIAgkk7bWHSautmkdJU4/0psgh9Nk3KB5woGFGDwZBRCAPM8xAQ7HGFovQDcr+AEUVCTWI4JFn/4AxrRoUUcQFFlyAcWEYFfLn7RkslYFGGkSm4UMk4dTjj03+7OOPPPrsQw82tGwCCiidTKLIIHwclWMmlwwcXI+1VvXHH3vsIUfDbViL4JJjFcvCWmqJEMJbHFhggV19WWkXOu9gaRjJguX118mD7TVXO+7gg48875hDzzzAlGFGV0kEkQNqds75WZ145lDnaX7u6doYsL0Bxxy0LWyoH4cKcohvjQJH3o3HlUIpK7DIYot3uOyyi6bSkb3LLbXE8ooqqphSyiebbIKecaXme9QnNaKHiSSMLqJIVfXxgRUcbKRhxkMQ9eArgcceNJaSNyTUbINHXo7FtZprdC3nGP96C/oZaIyexhttxNEGED74wq67/vijD030bkMLKflOAkkjg3yCd8CZBAdJj4suslvCDDP88INgKctkxVBiHAIIIGzgcV10jZxlXnqxzLJf3XufPV1kxiwPOufMA04kPrDRBhZQBIGDz0B/JmecPxet555SXJH00m/IMZunSU1qU1mEbxYBifNwojiSQkUqvFYLWzwHbcEIxqe08wtd6OIWt+DFLrwDC/CgghWpCI/dQKE3T6QHE5CQhMEUQZ9ACAkPWjmc4hTCuCQFaywEQsgWKicEzHkFc5nTXOeshSEugC4MojNDmg5HJB6EYBAvadc/VhQ7fdwjH/YQhzFIwZP/9kAiX0YRio4E1hQXHpB4xVvYHuKAOq80aElmWUvF0hKC6IEgHvGwCzyqVxe+AHKQIPuY9dQxyHb0Ax/wiIc5yjGPZuihDHeAAxeq4Bn5fWaTm5yTJ0+zvysgYX9JUxrT4ADAQRUqalSjSm+AA6kFcuI4XYMFLF5xC7JJpxjIUIYyjgHMY2CHGLwAIXhYwQoTGgcUpVLhCvsGFUXAkGoyxIpW2gASjJghcVs4g0SSxMMCOaRZQtScEDm3OWtZ6Fsg2SYa1rAGrrRBBCmhhT3yccXYregf+shHPfKxDmacAoybwIQoemfGoQysVZKAD1SiIoiEGQ+ObbjWV25QliY5/wmP0ZOHR+EB0pDK4x76kAcf4xHSlMLjHvdYaUtT6g53gDSmMoWpO/pBUnWQoxziIAUl77CSKgQBNU1AAieP6kn7nYaoeuKTa0AiT1TOBg8BJNQAW+kb4UgiE1ozxQNVgctdBKMYx1jGMnz5y+xoJ22yYJsqlPPW8JTCbkDhBN8k0bf3GLBWtbrVfdwA2MDC8wxpwIhht6m4h2xzWpfTiLW6YkRroVMNIamsZdkAT3jCIQTD0oM17KEieWBxH/vQ5z7y8Qww8m6ZODqKGQfGo0nAx0cIi6g1k/cwJC3JBizIKApEANwQ3GOkIw1pS0k63HiM9KUuZalzn6vSkNZUpf8p0gc6xrEOaUzyDqNL3FB9dlRO3mm8RcsTU/d3ScUt1rCEZR8qUUkbQ01FEY9QIC1NAdZaiLUYaPUlMIdxnWCkTW2jaoUqSogcutbIrq9qVareowhHSDMRtpKhbS5snwDShjZUJRJX5IlNNbGvSA/j3JEoMlnLWlYMamAfPN1wB+nNwAermEc+WKSPHJOURaeVxinmesIbAcyMaHTUbBEmlas4jA1x1O1AmpcW4OZ4ytCFh47l9dwsa7ml9eiyl7/8ZXikaB/qKMc3VuEDNOyqDGXowXelYNTwxulORpXTzzz5SQH5inEGymFEtsCR9sJhNlE7BH0xUZRSlQIVr6j/RS6JQVZlmLW/whQwd2RxSwMjGDlARmHePmHX9FCiVcB7igFpSxVbHcJWMcQNrjZMm/zIOj+wqWy3vgU6y+Y6DWBocRvgeYc7bAAEM2DzNOzRD5rowx9jZtE/+mEPa6wCyHQFmGt3NJymzFYqEBVSVmooxyVJ7CxSXhFpc7wPmMEsHzn2B0unrMXn6ti56l53PvJRbzDh43X3aEc6rKEHH0C1DENoUxZS8ybx2o/OSZ1zeOVkg2Dxmc9/Xq+55JAHQ8mXvni1a08q1ZyyCYOXvfTlWYXpKQLf0hWuQCYySxieSSU4XzUq41A00ZQiP+UpUEm1ohKRm6AHwo1upLX//0CyHxXzpyQgeRj75LAGGN/hARtYAYlOYWPSMjsfKbKJTaBNj2vEgmviWeZR8KbQSyhF26fu9sIGtWSv/OCiNeAtWmzCon2eFt/1tjff8dGPv+Pj3n2Hmb4L/zqczMMYPuCBHPaDBjZXoQqogRNSLV+/zBPNTkotbxB+sKwDBfFyvU7D0zM+NUVZbTiJfqArnHOp6FAHGSfnFDKIEQy1icqWsGh5K0Q4KVRw7TieXrCoEyiJ5KdqVj4y4Krn0+rcSK0PhAqUrGOzNF1fcp29psiIibSGYLshnrYZRDPu2Y/A3zv96b+3PehBj3XwwqsPZIUpXMFMUAhlKI5ie1SkEv9RfvBtDmMkoDc5dXcWaNEuM5F3+6B++EZ4hTd4EkiBEngPrwNt4qA+MwAHkCd5blJUltdJmDdeePZJPoMEOhB6DbIQo1dEGMEGcIB6fiBfqtcoaucJlOJ6rtAcYWM22EFyuOcdoiILmBZCv8cKboMKI7SEw1cqpWJ8rTIUmYBomCArjvAUrpQIgcNqiBIkUjMHRDdrgXJ04MJ9vaYGRKKGbQBYUQdAeqAHmyAO9GAPdWiHdDgP87AO4gAO4MANyCAeXvVyQUZka/dQBiQVCvM0BPgVQfQDA9EkK4AP7VBaeddPEch1MPNSWdZcW+aJzvU6+TAP0uADM7ACXDE6aGD/Bf6hSQpHP5qHZ/eDgkGwLC7YgtFyJIBmLrPxdntAQIbmCIzACJbQCaEgc13DCq4gC452C92BKUMoKrC3e7f0CtVoYMrRhKUQN3PFO6BWHnzjCeyhCaeSfI1gjufYCIHjSqsWJL5IfdS3MHPQNPkBBx2YdPthLSiWhmpoOoAFBG5wBmvAB4OgB6dAC7OwCgNFCpsQCbrDB3AYbHoABEMwCciRCqlQdqxlbQolK6ZGYVbBB1KDFSVmEQ3RA5DIAtOQGPDQIlikD4YHJvjGUsbFXM5Fk1UWXffwbPawDrNQiiFwOGjgBVZwSSDIeeJFgnhyZ0spP5/3LCwILZezTaYn/1VUpUp+EAirZgiGwAhL0QmypDXHMUKs0AqvYEuv8HvVaJa8V4RGeJZp+XvK8WPIsVq9gx6uRR7mwR6okiqoYo7wkY6JsJVU0we2Mn2FsgdhGI9GZ31b0TlqeDhcsQYBqQZ4EAh6wAdloDopMSw8QAMUkRAh4gNDICw9kAigIHN0RUZk5AnYxhSy5SNdKCRyIGIQIxBmEQnYUA7noJMuCZOa+InBKZw62Q/oMwg+EAIbMDpdcAVSMHlVIAUhKIImeD/lJTREU1R5EgQCsp0BEgT/8ZwYwl4vhgduEEC3oRu7kQjBOAmWwBRJsUC0tIT1B3NLCFdlaUttyXuvgGlxaf+fTXhQ2shMdiUKmiA36aGXyad8f2kwiyCMq1aYh2AIhzBA74iYY5gfNeRYRKIGawBVa/ADahBsfOAGtIGcIbACKLoCvWUsnjljKCoCNOAHnDApqpkvoRAKCEUUnMAjPfeRfsAH5Rl1k/kQJ8kCM0AK37AOMmUTOYYP91AP9wCcw0mlWcYP+UAPypASG6CcZsCc0fkQUHCdn0Sm5pWdRrVU+CMgpfGdANIsVZBEYRBoGBF15WmetYEbVlFAiNCVr6l2iRZ89kkplPKfZWmWbVmEb9k2wsc1S/iEosCNxYEJnlBQssQ3rsKXLRQ8wsgIE+oHFGpAekqDGld0s+YwWzH/YoMFT2rQAwFpBub5az4AAlTHpRtAdRzApXmUR1WXRyuwB5mAmglGV3aDo72DFK95ZLdSnveBTYkjEDMAAr4QDufQD006kyAVpSDlUdvKrd3qrd16Unx0peuwCSswA7bKZlwgBUnQBEAABKZxZ3Z2nUJjptmJndGJGnBWXj6DGlOQBVkgBmKAOOMZWHBwB7NxG1ahGzboFDdIFMwkKTIXHv+pHGSplonKlrf0Vtq4aHqzjdoIhXqzCZwAanl5HubBl8IRHJLACKEKqhO6G6M6qvBoqte0FeC3Bo6VhmfAA2gwBFugEdCqGZrBAAzwAEfbAEd7tFx6ASvAASFgBpNQ/xzCOqzEmqP5sn+/w3ZVAaRAqitscAZfET0+wAzzwA7VOm/qVg8plWXEBVIsxa3hykd18Ud1AW3ToJnJ2QBDMATqmgRI8ANAQHn2amf2KjT8SlRLlRqr0QRTwFTZ2a//KgZjMLCFlQaZ9WJ3GpIXJjWK4ghb6AjCQRz5UrWBap+Gup9rCQvLsRzh8Qmm8HGf8LEGlTckG2rmwWCogoXCYQmT0LK/SzUTyo5SI0MVeh9YoR+1NmIXobNq8AMGAQRmsBC2ygAHYL3Xi73WqwAPcAEWsAEhIAIgAASXkIMZSUuSYhw/cVA2p3ZaKzy7MXS6UmIgsALpIg73pCL7tHX5kP+/ecciicdsVuQ6AMxs7Iel9EALcMhrNSAu3BSm0UmvlWedE6y4TFVeSok/i+snX1BYaJiGDrMGALQH6Zmni9IojdIU5PsTU1t2x7iEhIpMreByyPQ1PIiWyzFXqAAKqOCNpSIJlFA37QErnDBqkuAJqEIJsxK6lsCyigCAqyahFDp9goBhQZoHMogHkZkGXaAmHmwt2sIRpscVGAGttfoADYDGaZy0Snu0HGMBIuAHA1MUEMtarGVzO/KavrsI7CgIfZAH4+dNFhACPqAHNYZsV7RP6pciBFzABnxvXPfIkfzIdvh+3BAJegAHacACN3Ah3AQE/4Gv+0rBFXymFlz/NPJaXqpxBavMyvyBhk9HJG6Acb4YJLqxKFiIhY7CVQADsXQcscGXHPXpcpWijaewCZIAapAwCIkACTjHUIgmFM0sCZqAKj9MHpSwCI8SuizbssILxYZJvINjG1RFVZWkZplsOo5FEdoSpyFxBnwbArfKAWq8xmfMxm38ACGQB0SBaL5ctTgyhWvHCJ9LFVXhx+O3BrxKyL6Av3n3gJLsfpQs0fBH0fCnh+LAh9xwDc+QwNz1AzRwAxjyEJ8Mgok7yo9ryqZMr/vaBKzs0lcQBigmT3LQYrI8KO4oXz9yao+Awu4px7wMFKuJQj3xyzVKoLwjHpTQCKoSCPIxCYLg/wh88AhBkUCBcCqcwEKvMo54hQmhy6kt+81QXMu5Mc7kjAeVVI9sYDpqYmKXBKdKxEQ88M49gKscc88P4MbeW6tcOj0ikAeYgDcHVbXpi1BCcQlWqFc9ZxXWxAN3wFkgoAfM8H7u0BjlwFPi8A3bgA3WMA3P8AzMwAzG4Au+QAulnZBgFAmpfclwCIdlkBI+UAZ6cAdyYAM7gAJTUAXuygRMgNKGm8G93dujrLiqzMpfIAbZ0msf5nSyXFWDMjWtpNNYyAgKilftKxRCNmSaQCOfpjXbPY4olCqD0Ah8kAiNgAfB4QZAwAmwhAfwcSqqQsTTjHMtlHycusdRrJWsRv/WF4YHQXrW9VgupqezXoEhk5dEifPOQ0ADyZmcwzY9Du7g0pNHImCuIsADicDCg30cPoF2QTEUfbNz73sVeyAIZxDPIEDIq6DaBDlJrz0DeiQ9MT490/MAMh7jEQ4CMA7b7wR6LcACTQAFTLAEu42CiYvKpNzbqoGCE0xUqxFKq5wFVXBijsXWUcfcVzzLhTJAh/JzzmcIDiqMS/Gn+xcUWp2Xp6LdmtAIhzAI5NEIXY0GgpAHgsAGupIIksAJhwAKksAHu2FApOYqetk3CiqM/4eI3zwI4lzWZ43WAa59RHRi3jR+IYIWPBC9d5AHy/wbQDy12Pg1tcALtqBMwmr/CsZY6jgaCmcXFLCCKsGh2H/gBwuetCDAB5x11w1gtEibtGis62rc60Wb6/YM7DNAmmCgLCjAAtu5BEtwBEdwGmZ6uI/724vr5CaNuKvByk4e5SemjxqRuQBUj6mkSgvz3Kn25b/bKMJh3XaF1T/MHrmT1eZoaOcxCIKABnjwqsMyA9HrCLoBCtMUYY9AhfWVCeYRHK3CxPXdsm2X34eg6GUdbABeOknHHxgC6UciBBgBWI7AC7OXDMlgVs7gDNBA8iVP8s4Q8ihPDLBwFOmrvseB6sXaTOXRKj36kX8gArZqAWmgA0arAAyA68Au9ENP9ApwAEX78wqg9ErPAEyv//QNwANJUke9FQQ9sOzOztJFLu0V7OSrrORJ/uTN6eRTkC3crrOYa54NI+5v59xTkwifupVbySgqe9ivwgku9Ai5s2qQwBuGdgj2sdRDgAdnECI8sAbCYulnwAecsIWHgIUJlEDmcc2wZAkJz81t581svt/jHPG7otYUfyFlD+lC0AY/IAdnkAe2APIiz/qtP/Imn/LLIPLEkArrK9jHiOonZBQCg23CYytLuwhz0PTVG+x3fc9AH/TAvvTLr73ZywBPguzIzgITB6/12uRfz69Oju1if15dzyfaD+Wi3+0ditBp3zBVhRXxdVWd++VWw9PCEejngQmzstSQcAh5oP8bc04bgQAEd9ArMwAQIrasCAFkxQw3efAEEsRHUCJJmDJl0iQJEidPmjBhunTJ0qRJjEQuWmTI0CGUgVAOChSIz0s8eO7AgYMGzZs3acLs5MIFy0+gP4WAUSPHzR1IxJY5Y9rU6dNlyKQiW7YsGS9WoECZEiXK1FewoUJ17QrKE6eJaC9NerQoUaIhfET5scDAboMGBPXOENE3xN+/HARz2FB4wwPEiC0oPmx4A4seNW5MnvyjB5AfW6A44dzEs2ckTaSIHv25tGnPUlSv/txayhXYV1arnlIlKJYzas6kWbPGTUw8fvr08VP8z589f/wIYs7czyGTiRY9egRyoyb/Tps0YeeEqZEiRY6oHxJ0yE8aNyjN9ODhxsyMLUDwrDkDZIYfIIHg4Dn0iJMkRyaRhBJONKFkO48kUVASRhgk6ZAHFTmEpZZeekkhmmrCKac0erLtNjCwAAOMM85Aw4wyUJkKGWVaXOYYGGOUUUapkiHGlYw4QYssU8TqMZNJOhIJEUY8AukRCQVBBZREaBCBg7oYaCAEgkKYYYUV+sISy75EAOxLEMIkrDDBvlyBhhrSlOwHNi/7QYg3hXAiNNDoZC210U5TjbQ78RQttthWuyILLkY0VA020mCjt9/wyGOP4oTz47jjBCnuoUUEMcmQt0iqbiNMNNlkkwIx8g48/0wkKY85PMxolY9AtphhBhB6AEEE+VbYAAgz8piBD0wUeQRUBVM9UJNLMkmQkUVEGinClFziAzg8MtQQpzQ65OLD20QcaostzADiEF6QKUYqZaqacd0Ya0RGGFg2waRAsuoVBZRQOulIWUb0XQsSR8BLZA85hLjBAwoukKABIVjAkocZWJB44lkrthjLiSXGmEsOREizsh5C/gEzNtkU4mQ6m0DCztP4nG3Pl1mbDVCarxAjDDDCyFbRNthow7c78siDjzz62ONopJH+I7pEDpGOJKjFi2i77Tyx+hNPMIGkkVQFUQRSPLY4g4dF+JiBB7RZsADKkEWAGFwzHjkEkv9UIYFkQEgomXeij0JydqSTVJqwQmrvmImmmzgMw8OgThYqM3DrA+ITYoopBsYWL19XcxqnEuaVTyjZBJSyvirr3rP27aQTZScB2BE56GsDCxRa4MABDvbI8qAZbPAdB+DRZg9t4tFWkwYWIpYYeYk/viHkkIEg2WTHWzOt5dJee9ll2WDOs+YrvhD/C5x1zrYN9Ntw4zeh+RAOaTnip/QP5qR7Wrzq2Co2VFE96eqTT4gia1pThCDgwIZwxccMPAiTCB4QAgtYoAEboBIPwpWHRAhiEXnYTrGohqCPMMhZUEOJpQIxCJbAJCaGOxwadpatxVWhCkIAiuNElJkzgCv/PmiQxbs0pwx2HcNynJsRMo4Bi09s4l5dMZ0pWMGVsljNE51Ai0YENIc09AEJLECCAx+QhyEQZFYQm5ia0kSDWdEATTVQYxvbaBmJ+Y4FNrBM8dgkmRuUTAhQUNnKrKcy62lvNq6R2WhC85rYjG8Mi9zJzt6APjbQ5A6OGlrSkjaH5NDvIY6A2iLEMwlM6G07oVJiAEURQFOUAmtIeokZVoC2EKANS4dRgAKmtBgbVGEGPdiCowTRA0FoYmt2o8SBUrUgSYCHEeBBSaRa0pI+TGs/1rKJC3USwypAgYZC2WZmgCC2zCyQErwIhjCOkbkhpjOdMgJii4B4C1IAsBRQ//TKK25RC1iYIoCe0IrV1HKJObzhC1cYAwtEAAKibWkGPuBBDyhTMssMr6E9+AHa1FgxFvCABq+cgQ5woAM2CY+iP3joD4IABSisTKWg+SOetuey7fnxNeP7wiIX6UicQDKSkxRa0YwmhzkEtQ1Hq1QnofapYx5oE54Y1SdIVwqoztMUkDjEHQSxhTCJUQQNOEADFHCAA3AgBA14gAVCAAI29EAEgchgIu6mt2IS6JgKWiZ47NrMPjwzmtWaJuJsYoYu8ESGKO0Wbn4gLh6kYQuZ4QEQWEEMYRQDneqk7BDd6aJi6OIUASyFV7xSDGqEFhmoMJ1WzIKWTPgBJ1WwAf8L0uCW3Y3RdzoIQhB0aIYS9cY3v+HDIATRCEcciBNeQYUo7mCGJXQ0jxAl6WSSgITa8nGlLG3py2RDGpohMnuqUaRNx5CGDeGEDYnaqaMcRbCjteEGU2gDpSBlCEc4whAk+SSoRDmqTQAQlVA0BSooEYiY0GoDIljBFh5wAFs+gAFhlSAuQ4CGFfQgDyiBRCAaEZFi5m0tzrorSpopnEAMB0PUrGYZALu4bWVTmyezIRhGBgQenAFOP8BSInAhDGFMtrKUVUYzXATEZeziFaqcJyhUcQ1xiAMc3ChGZ7silnytDg5rkN4ePOGKSbhhk/nLBEa8YopUsIIVsKiFLXD/wQteEIMYNUpGm5fiDGhAgxdw4EEZtqCDGwTBpLX9ARJusLIcIGEJTMAeIa83s+4hEjaqCdRsumvTNLRhQ9lKVBrgwFOhBTUON1AAAABQgAsIYQ+GWFon8UcdR/SWD3ooAxoGsQlSQLUrUjWFJxoCBBCEYANTCsFXLWDLuyhAShzgSwhEIDQ/tGQQd8Ow3UTIIAkdItrmKc5w+iC0vvq1mif2kIpPFieh9GAGQOAlRYWwpVJE1hjKSOcw3P1udxdjGJZrETOYYQxmuBMYqyBFPD1RC3HMYx3cAAc0ThEWKItFD3xohClsoWY041jNE6d4xSkuFWLAaEUwijM0TMGe/xmEAAdIyIEOcnBylQI60KRpKSH3xD1Avfzlh5ypd7+7KJ/1LJI8g8McHpVJOyTA00MHQAJuIIf5hsQRAEsEIv5wCD0MQg8goFUIyjAITHS2v2J2RSqKw4Zxj9Wrwq6LgsFqFxAwAIKxzGEe7OqpR0CiOgr6ToejHWI+5NVoQZ0DHN7Q90mnoQuC78K2UBqEbc2YevEZwhC2QCIqAQESPZbGM3zxC2D4ohe+8AUwjPF5Y3QeGJnHN76fMY1pYAMb06BFJIC7CW4IvBvcWMY8p5jwsZx5zRNHhsV9//veW+4YG1dGnJOxCMsQxOQnZ75KmR/olH3Gjy6908vG1+hBYv83fN5VVG7Hu3M24CSoRC1EBYg+dAegIHcgQQR5NCiHPyhCD3qgVZgWugIQ+MB/qBBzKkTxCD+QAzrTtbJaG2ADq65SABCwAILgAdy6g0MQj1NDEk+yiO9ohO+QtpXAO+LwA6ThO7/DFsLLlsLLpiDQgW3Bgm87GTBgvCHADCFAgeQpA1qoBmvAhmeQBtSbBmu4QW8IB2/QhmzohmqghWe4hm7oBm+wB3rIBye0h21oPdczhoATB2qYBbLAPSfqPTVbkd/DsciKrMqpnCHSuMtZkRaBM1ZQAyGoASwxOZWDPpKTw+mqrpfynpqBmUZLJPG5qTQokd3gmfFCn/Hbgzr/qAMBOD8AcAAJuAAUKIo9gIPh4AM4UIk7QIMQeIDDoLq0G4ADeAAQwANJEIVUqLVDyINAYA8vYYAI+kQLQMADGLYVsAARSIPlYCtHkLbpsJu5sxsMhATwyMBDeKZAiBSj2QMQDLwX6gIT1IHBWjGTiQ/pIRkRyCgfoISAowdt1MZ6sAd7wId8qIdyWId1EIfP04Zy8AZsYId66Id98Ad/qAd6+AZfiIRIiIVhiAZouAVZczJRCAVTcAVbwLguJEiL27EyJKLhQ5c0XAZFqIIbmJiUm8PQqMOUeTmY2i6YijmZAZ+BUqRsAURF8RmSlDRMSg4PUEQCkAAHcEQbYAM5/8gDD8wDOFg1PfAiBgDFThwAniyAWLSBRRguThAEV+IBNuABULSLxfjEw+CAB8ASEFgB4TAaRUiP6cCbvLEIu/FFRdiaaWOJSHkfvuu7EHwhwTM8KKgtPmOuaRwpAhs3HxiGeZgHergHu5QHedCHe8AHdhiHcZQGWsCGdRgHbEiHftAHf+AHfviHeKQHbwCGWFMFVCAtzuo3rRNIyCLDITKXYhhDzUTIMmyXqXAnZ4AFM+ACG5DBFZjI6Zo+6pM+1Dg0RAMfRgOUgbLNLxg8QPy+QeyZNgCqOaiDBAiAABi6AICABaiADuAA9orEHuCCPLiDMiiDtLMLBgiTBxiAAP8YAAc6gAIwALBqABFwhExoAxCgoEzMi8NQsF17AChZAS7YgyBQCD/Ig0w5hEYgpq3cSgzsTwxkpmFkiGr7wKCiCQ7ZmS4ovBRTyxPEsxqIHukZKcEQAR+4OnCYB3bAS314h3fQy3H40HmwBl+YBnEoB2wYh3xwh33Yh39QzH/QB3ZIh28whlXwx9OKqoDkhTaLEc0BTR8VPtFkEXdahkYAgiDAARToiz5izTpkuSWNvtPonkTDPkFZNEb7AkXrw2zRLd7MOfTpuTkQAwIQAOIszgWAgArIgApAgTn4zRl4gBnYAAagFev8xDA5AE+TAApIgAu4AAUoAOIcAAawAT//0IHznKApOc+0gyAOcJiXfAM82AMzKI9UwU9iooT99E9f7E8JaQlL8cAPPJoCPVDCSzEoGKwTtIEHtYwIFZkQ6JgZKAMfiIV5sIcX1Qdc1QdywIZtmIdu8AVmWId52AZvoAd3qAd4yAd4/Id37Ad5XAdpOIVRGS6KiKpUsIU2q5x1YTch+tHQXBeGrApZKIMe8CiDEoGWa7k9aVI+8YxEq1IrhVfZgA0spdea+i5A3I3vizQ4SB+gsgEDKAABGFMBqAAIyAAJqIATaC81OIhYDJMFO7s7DdQOAAADGIACUACWvFji7KoQYB6xghIOaICGepjx6hWGUISm8Q6tzNRN/+VPrvQw8zhGS0rGwMMmw2tQG+CBiAoZ4lmbV6pQPagGe+gHfOiHfsgHe1DHgGMGYKjVc9gGeXRCqs2HozVaZ7WHeZCGVRgVjriErrhWYmgzW5gRIOpWb1XIIhrSZaAEhjKD1soSPZlb6zIkmnOZz3jXKxWfmuFbjgyfe00D3NrNnuHX9IGDPLABBUiAAkAAAUiACkhTDzCBHZgdGjrXEIhYT4TY4gwACSBOB0iAAQhYjZUABQjUAmgACUCBFTAotdHEDdgCNnAPIIAD5pAbYhoQTC2mlt1P3/VKmQ1LmrXZm/WQtNQB5NUB6IGen+2YHpjOMliFWvVGemCHdcAGbf9Yh2kABhSFh21Ih1oVuOm1B6pFWqQdB+1dhUigBOoASFfQ0auwhV/4hV6oX/v9hV3QBf3dX13YBf/dhfnFXwD+hWAo4GBwBmVwBiE6hmWohTIgN4oKmSC429iUGdd00uuR0r6VgpMLH0XjyL39Lt7oDTVAFDYIxO+DAzlgAQUIWAIIAEaUgAyIgAlQgR3AghqIgzcogzc9AO08gA0IkwHwNAdwgAFYgNBtgDiogAVIgBOIgYEdgIElgARwAApogd9sg8Oqlqi7sAGxiAMBRmajhO/o3ZeNWZklj/ch0IDKiQMtQS5AqcPjs+VlD+RlE2kEguk0Bm3Ahhu0hmvQhmv/2N5pIN9x8AZEHodtCIdw+IZxXAdtPFp47AcmxAb1BUYncgVisAVbSIVMcDcDDuUCDuD/3YVe0IVeCGBVnt/6XYZm+Dx3E4ZNEJ5pZBM+wmBDqpM+SteNBB/ZCI3w8eVEA8kRXoMSHi99zTkV/oELaIAEWNzIrYAY9oAdUIM2sGZcY4Ayvc4ZOIDiTAAJKAALcIAFkIAOWAAFIGcjIIAxZed2NoAqZoEwCBLwCAS70QQUcoRQopqsbIRHKBYFydT85E8ALaGp3INjDCpsEcGzrIJuS8sgWF7i8R3JyGMf8IFImAZu4IZqeIZqqAZpYIZnqFV2wAZv2IYkzAZrmAZt/1AycYBk8u0HfzBarcUGWhiERkAFTeaFTAiFAoERygJDoRaGVQ4Gd8O80QOGd7O3ezOGYbgFNGioaZSeH7hlmIpNXqY+eZ3XK0iNYPblvRWfMMiNEi5rNsCtkUQfORCRGnDKBeAAFPCADugAE0CBDsDhs56BBdPOAeBcAAgAG2CAAbAlFrBrPU2AF1gAARhYMp3i7/TJT+yBQ/AEvbGI3urP7bCbjUAm3Q1oX/TdugNQYxwOZAyobAmvnNgWnsjZNpGo5A2Cb5LGi9aFjY6GZpCGjmaGakBCbkjCa7iGj668HDy9bgg48lVaJiwHX229VZAFaEgGHeGET7gsdqEsp/+Gt2GAZdD7vGfo7qYuBRHgJXKbxi2oApfDQ4z8o9qMmXjtatG4zb6lGb/tibI26xKhtDZQYZj8g0nwAxxggSRggRsQgmueAjaYA1cCAQQcgAfwAQUHgCEW1D/FWNxJAHD2gAAg0zEV2ABgZ4wNWB9uADO4BFDQhPIYBIjY3YoQpbmKK8/+3a0UiWj71INu4zegiTbOFi64JlMFl1YtV7W8DOkBlyXQA2FYBsu57WbAnGZgigJGZV2Y31uI8mOIBm546VqlByY8B/TtBmMABmbgBmpohf9pBjM/czNnamZAc3trhu7WQdTrQez1hm8IB3Ikx9lrBBHAgSRgD+kxA83/ACQM1uo+0b54jZnXUJlg/mDAhW+a6QmyLuHeAERGwQP3gZBMEAVWuAQd6INJkANRnYNAKANds4tY9IGp48niHLoE6IBwHgALR4ECGAACkGIDWIBZL+JZL4BZx9hYfAAbkDapcR1J0Ai9CaWpiStK4OwF2U8OM2jnEMuxLMtlNDwdYpPJqK3lJe8sCQRWqIVbOIYllwbJooZlILNXOAVVOIVXiAXJtKdjkAZwEFYmpN5yGId0GAeBW4do2Kwk+mgb/O3fTkJwAIcke+k7n0uF13JvbHiHF7hmmBUkSAI9i+0gCCSs9h72zkNEf7lAkW9Hp5nFKevc6A0zwC3fkMny/1AETXAiYUAGXsCFZAAFkPCDRZCEQSgDxFgwVNcDH9bOVR+6lUwAAeiA0z1inuQqT2yAgDUAAzh6nsTYjOUANJC2R8iEs7CvAdkOZWf2F4eEv5nxErIUmj2aEAwvEtwWHVI85K1j9lArEZgBTUCFXwCiZoiGaEjgXcAFXJCFVmgFVbgnXYAFdu+FZrgGmK53e4jRcmAHb5yHZiCFUygFT1D4uaQHurR8zd9Gzj9uJzTfpM2HeRAHUgABAE+CJpDGcoVS0XBSjbcujq9NvcVNew35r94Jkpf0wV0DS3+ISRguVBhIaHCGqLAFUMgETGAETIgEnW+AnJy/QVBwVS/ToP8XAEYkzoD1RAXQzq8KAJ/k9e2U4gyP+k8EAkbQEY3ABK8dlWPfCN5FpruJ8bA/iZNQ46kk7YAyUGovvMgBg29re4DoAaQHj4I9NmwIcaeUMmXGpEFsVkxXLVzIaqk69SpWrY2zchmb9m0eu3z18plsx85dPnv0npH65KkTvZr05uEkmRNnTXbsctY8ibIfUZQo7c2z5gOECCRJkATpIRUKkiZSply92mTr1itXpHC1KmWs17Jlr17JkjatFLVlv8AVAxeuV7Jzr3QJo2bvmTNq1vRdg4dPoEOKOH0yBQvZMmjQkPGyhcqTJEmHBi19wACEHj2RIumZwWBAAAABTgP/SF0awIADAQ4cIA07wIDaBkgPEBCAgAACBGgbUPBAxBxOnjRp+rRp+SbkyDFRoiRJOiRIlatXlsRou6JFigwdCu+nD3k/e/DAQQ9n/Rs2adB0MbMFzBkwWIQE0SGVoMEfCUGEEMsyxgwDzDTTNBNMMLsEs4wusagSiy633KLLLLSEtE059hRljz3u1ONOPy2Jk8tylxzloUsq2qTiOuvMsw499uRTVD70lDPON964hFMvZcwwQ1VI6KDDD0c64UQTSjK55FZTQDmFVXWRJcVZVn4RJRZRToGEE1NkIYaYYWKRRZhimBnmF2PM1QUXfcF5RhpntDFYYYo8wokoqdiC/0wyyyTDSy2smDIJeHyEBgIID3j2maN6gHBAAadRmppqqc02QAMFtNZaAQl86hsBCCSQgAEEgIqqAsRZktwnpcCKmHHIccLJdY1UBwmujyjSa6/hHeKHsH3sQSwfe+QhxxpsrLEeG2iYEa0ZZ4TBBRRFBhHEtTbMYAMOOPCwwgxmlEFKNNU0s4o01TgDjTLHFLOMMMEIU0wxwhwDbzHNTNNNOPPUc09NLqXTzjvwsDPONcAs5+GL64gTMcTgdMONNthgA5E00VxjTT1E9YNPPtMwA8xDzySIWbhbIYGEEC8LkSSXUCaRpJJRjmWlWV598dVYZmIRtNBTJDEFFmGIif+mGGEEnaaZcs31BRdv9iVtX2wMJogikGCipysWJYMMMba4wkoqnjDix2BlhKDoJqTADTdoPszwgAKxkYbaaqyVdsBotRVQgKSBi7qAAwv4ZgACiReggAVjaFKKKLB+UqvlmkB3Xa67+vrrr4EE0sccfPTBBx954OGG6njgcYcbz0abRhpcVDF1FdnmpwMOOuSgwwo8zICGHrlcI80wz1xDjWPOtOvMMsgcI8wv0OfbTDXXgLNOOu7YVFM7BqczTjjdNEPKM+BIY4z6BSr4Sy+/ANNLLrTQT8swvoxT44j2PDOMMcCgTBmqKAPwWNCEliEBCkL4Qcy+xCUsJKFmDjT/U852dgW65AxoQhNa0cKAtKQtrWlOS1PPrlA7aaEwDWyQQx74IIhFQOISoECFKyqCC1zUwhWpSEUo0oYsNPggiKdYBRFXcYpIlCGIitJMbCjlxNJ4ija1aY2kTjUAA0DAAQnwzQIWELjGNcBvK+DDIShRik9Q4jma4ATmpJOdXPGqc74CFnlAFwjTmY51eUDdHeDgBmi9QXYerBYUtFWF22ULCjOoAQ/YUIZNVEMc3LCGNKDRruU9TxjEKAYuiCEMZNjLGdHgxjrGcY6e1AMfBTvHi8JBsWgEwxnccN8vgoGLXfBiF7fkBS5u8ZFd7KIYzAhHjfxxI5I5oxiWXAYl/2ZQkKZ8CwqFZGDNoCSzKTgQTGnyGZbe0rMKZmGDQruBE44GwkGW6WloUlPPDmm1OMmuDXfIQyAEcQhHTAIxpkAFK/qZClOgTRB+mEMZluCDQdDvM6RYBSn0EMSlLJEBeMuNFKlomk7VBja3GYACFrBFAhhAAgowQOA6IAELSFQBDAjBIBqxCTRqwhOYeE50ooMdScRRjsAKHbAEEQhhne50e0QPtNLwhkDSrnZQqF0VCqktFrCgIEO4Qy7AAY5rNKMZ0XBMNJ4HDWpokhdiFWu99sWNb4RjHT4BETvK4VaIdQOt9VLeL3YR1rHyghiRqYUNiaGMb9gDH/6oBzumAf+MXdRCUKlww5FqgAIh3EAHh9zCD7bwpJmNcJsVtODOnAZCHCAhs0ILg9PGIKYxoFZqVdgCnPaihi3A1gxpgEML8eAHrVmna54QhShA4QlLKEJtZUhiJIABjDJsYAaRIMUg9JDEGShqiRawQOAAFxwFWIo1GW1iArRoqgE4oAES1RQFGiBSwR0gITO4QySY4xzMYQI6bswOTntVmc/1oac+xeMdhZo62R7VTbWrVlKdGoQa1IAGQDADGgYhSpNltRnMc15jhCEovfISh7cIBr+2MY5ybI976yhHONIajm14Y6/cQEYrdshb33JiEowwhBzk8Ic/YGIT1qBHjW7kCyT/gsAHBanBDWggAhYsMAirBcIWqsAlM0FphFGiks446xXPJq0JUxjTmDa4zjOB8ApTMwN94gTb2KZBdT8IDBzugIc8JGIRjnjEJCwhCT8gKoh6oIUv9BCCByTEB53pzAzaBoIN+GAJDRjpAKqbt9TgRlKNdoADFKCAxpXXbgfggBatWIDNHDrIg5DES90bX/ligr44fcQj6quI0PkhEbI+hE9BV2vT5eEObAikm2SXhjD8OqlN/cEKWCAuJpuhFMc4xTOmYQxmKMN5yEAGNJaxDEHZAoewwIUuqncNcXx4JfWgh/jC8eFvjIMGYFgBHoiBB6ZwIN4cuMAFKEABw0mg/wNQuIM05tHjwl7DGHcIQbFrANUViICBWwBCIp0cJSg3wWlbghJdfGblK6szaWAeJNOEliYwgdBMU6tPnMBg8thKi4FC2EK00MAGZPXBD4dghCRe7VBBx2IWetiAuDZgAUUJb7g+aBuQNsCAo99tilPEG6UM4NEFkHQClIY6AyygRQEIoDYMeMADQlAGAOlhEzlejnNOHV9V84q+rz7EIryTCFrX06fDQhYe5hBI2SFVkLaDwhZWIK4ZbIEHQHCDKmhRDW00gxnHsLa7po0MYeSQFTVMBjGCUYzjcSMcIAYRPUppbnakwxsUeABK12CLFXCd65R2QAQo4IALeGAHe/+IxDTKYZRzfAMc1TgGH2xgg4OvgAOV3UIPdGBIKGkZyqFN0wbvQpaLZxy1Y9Cm0Qa5tChnQUqnNa2YmEZy155BCGBgedXOwAIa9OAHQFiwGVB3Wz8sojKXSaIeVhELPRzZCSwQwQoU1YP3JFEZQIpmaAYIWEGkKB3gWEoACIABJAB4uZ4DGIABWB3iUMoAHB2j+MBmzIAeUIJykB18YYIlnF12tJrazdwjOMIivB3cyd14IEse7MEcwAGvWYsH7R3fIdzvIBgNzAAlUIM1aIM1MAPjOU9DxAsxwAIsDAq1yUItbFg0ZE86sMOM2EMpuVU6pMMFmAAFtAAKGAIx7AH/C6AACpwACZQACaSACXRADMTBInzCjtEISpCbNnCDM6QBHrDBAh3JwkmFtmxF9mFf9kEZ82FBxV1cWaQJCIlBlIgBaiVNxz0N923fGIQBGLiWGsSJa/maGoifGrABG6QHHuRhH7zQJFyCJ1yCIgxduZCCDzQAB6DAC6xAGHBdB3CACIjADJjOomRgGYAGH4DA3zxadplGACSA4WyRAkgApeVGazzAoQUR14HADJTBIHyCJjRH2YmgCcqRHLldC9aaeewR6sxgDaZBFxwS7UgT7izcQPTADdjADdQAHziDVYlDNVCD8jhGPzqGWBEDMUBDoNgCLOzCPc6Dh7SEPYTP/zegVTmYQArsABXswA10QjL8AQ3gwAuowAnEQAyU4Q7EQSLoWEIehU+UwzwoAxxAy7QIxDsCwVJh30xqk8RNQdSU0AXhZFwwIiNK3zl9kPRB4k9mYlGCX9X8ABaAoiimxxmsEPwxQipegiYEwgz4ACmcgg9sgAjQwAuIwBT43Q2YgAhwQAh4gUNtADUOQiQMQnMByQM4EdbxxmowIAIYgACs3gPKRgNsQJANI6B14CDEVxvFFyWMYAnWV2WwWuc8Qji6oED1QTnKIA3aYBUEW1NlS2WtX/HJo0BswjV0A8c4xjK0yz5aG+VRnkBSw9i4givcAkJ6CD2MWzqc2DaEw/8L2McO/N4WcAIxJAIOEM0OYMEN8N8U/AEkRIIc0uE5sAPErAIaoMEamMEQCB5srR8UYN8V0GRNBg2U8Mxd6OROXlklDmXStAH3DaVQbp8Y/FpfGKUmopAQHI3sMGVftEEf4ElyYIIoqMIm6AHcLAULiIH+tcFw/sENlCFZ8p+hlQtbdgYwRsIG4kZv9AYDZhcBLIACSOBpYODRdWAGJgQfDAJyNMdMDSZixtFiyhF3fEd42BNk7kGMyihlBhsOVktTWadU6MAN3ID67dkmnAI1OAMsKAY1BAoyZBsukA3ZuIIphAIiTEIq7IIyVMM62MNatZU3ZMM2YEEc7MAOjMH/eZgBKCSDIeCAIcxBmm6BHBiCH0ACKXSDQt7IOKTDPDyDc90BGqzfQJxZU2nZFGDcx4FcCAXNdyKiWcyFlZyJejJiGyjNIyYNJIaJ9LWnXxRl1UTLGWABGNCnKKoHHggCPiWHJ6ACvvxCLtxf8MzBGCBBHbSBSH5hC5zACZgACvxcCOjBKZDCZ3jGrrJlGWgG4RRAb/DGAk5g3nQoAyQRiPLiIDRHiZ5aN5pgTnUOiy6CIYCHeMxdscQojfraII1ZGcCj79kAQXSgD5yC8yTCCgiBKdgCKIiCJ3BCKHRCJYwCvYbCKCDCH4CCLNwCNZCSWvkEO9TmH1RCJUCpk2aC/yXwAjSkQieYQio0KZ8k1jFY6e1twzeIwymUAXSKq3wgmxUc0jrehdMMKsftZMquCZvAhVBS4tIgjaNWItKg09F40K+Ba5z4RfkFDX2mR7LsgczRGWKggiwUQ0NkFTCcwifkARp4QR8szRz83gtQLa3GW3INAlbGDUOBxmcMwgyEEUmBlG/oRoXmDWwc3VIcXV+WAR+4FNlFK+ZYAgmmGn3lVHiwqCIcQrZqKwzC4AxSJjqmI+0wWBlQlu85U7jwgCSwAi4kgyncQBxMQijYwgoWwiQgAiJ0QiHUQSH0UOY+gilQw/Vkzzx0XjnsSGTkVUDyAuU17IpNmzMECjEgg/8orYP+5EM5WAOCDBd0RgvKmYEVWMHUcEEYRM0iqpP1pVbUsOxcuOxPrqclmpNp/STNetCWjBbHcYHJaaJfpIG0BA0XqBBt9YFtHUIiDO2ryAIxkKZW7SM1yMIgLIEezAET9MEMINkOdOQOeMCRtc1BLZQv0ALXKhSQMQCnFICoOB3W0SVsBJnRMUBy6cEgUIIoLMdglt3c0m3dKma1MsKvAAu2godAjce2Ai5l8lp8tOQWBEFB8ICiiIAQGIIjeEIm/EEcAELmdsIN00EdIEIoAELnMkIdYKsjcAIsRBv2vIhPjIM3JENqBuQTPzEyUAM4AMoyBCTtOkO/FVM+rIP/NTSDKszAgqHBnChZGHRBF1iBF6TxGXBBeI4nmAUN0oAnzyDqXURNWoCZ9B4NJXKczYqTjU4NfcBnX8RWIUFBF5QxbeWBKSaCI0hCcqDCtjEGNJzLNXCDkM7CJgyCAM4ADvCoEexAC3whCrAADvgdEETCLMgPQ8XNr87ABoStqAwrAWTXayjK0W2doDmrKGBOZcwUfG0wYq7aYrIosLDdtWIrrQlLMxNLmqYpe7xHS06LdQ4BCKwACnAAHfwBHPhBIdABHdhBG9xwHQDCKCAsIhRCvYpBGxiCK9iCKTQsx4iDWtFD+DxxFLNu2CSDM1QxNSCDXfECYzzD7faDP+BD/zlMgzAEwgp4gWwdEhTMThoLr5vQzneWhRhcgVwIYpjszGatRRYg4lyMiRybycuWCWnRbDiZCYERLxeoQRg0mRlwwRZAARfkRxBwQXy8Qd018gtBsieYAivIwkBb8vVUQ1LvozJEAh8EyY7GARkogQm0wLfMARTYAA9A5yCcAv2sAi3s6oNaowgoQKMl8G+UBm1git9sHWeMGm8hR3Ro43NsMAnamQl+8HbEUQi3nTKDx22RMLHMYLfmARy4h8uhQdVswRCYAQhwAAV0AApA6R9QgRGQAR3EARjUgTmPAjGA88EWghjcWCeEwiWYAjE4QzWAQz2vlSvAQmvCNmzDgv8tJNY+ysIpuLYsAEM4cIg/9IM9VENWrgB0esEXFLcXeIHwKncURAETMDdzC28USIF0S3fOYAlcCOKgpvSXmUnUWHdafIHGbZNckPcXuEUeewUXfEEXSI2YjQUCRVwapGmMmqIhLAIjWMImlEIrJFbtRsN/j25SJ7UubEIg9IAIoIAHaEAFZEAFXAAq998SIFwHLhRYO+jQhYbRwUZtVNTSoW1C6AGuvJS81oq8Yo4mXIIlpPgkSAKL09d2yBkLyho4XmuwNPPf7hGyyIEbtAFgtJwZLNjCDcHC2YcQtEEohIIdhDMgFII6/wGTTwLmHmzmVsIf1Gsn1AIxHCQ3gEP/QtKITHiCvHqCb8HrDJXCKcgCad5CKRSeL3wDPRz0b1fD14oAXCD3neP5nUf3cyt3n/t5lUnJkxCqB9Uk1HBWy4aZN7HsxVl3o4NF8j3iUc1BjMrc3laGUPP3QJOmJa+LgCvPMphCD8SbB3gAG3YADniLCMBBkCAcrmotaAwX22jG0W04FaEt1/UlCFzjqH0CmJc4G2lCJmTCJVzCwhK7BlsCizMCq61gd7idd9S4izLz3Mkg6qiOGwCG7KAQY5/Bmd0HttpBKHBuJXSCOmfuJBTCKIxCJ6x7JQDCwVZCKsCCKhRDNXSDlXoIJ8yUvIqCKeyJ2cDChMzCLxyD8jhE/zOMQz34gzHRgzIESQgYd3LrOZ4vd3NDt59jPKA/mSB25yJamfOCUE7ipJXlTFiYfJRt3xvMd3mcLyToCSq8gi4oyDE0wzNEgzSMbjTYPDTsAiUAAQiU4SxSwQvsQBIsHA/QAA/0QAh43SZQQluChi/OOgPcjUStraK0TWC61KuEeZjXCnIIuyWEfdgT+4q7OCQwe7M7wgouAjJf640LNuqwjuo0yzRnqnx0O7XoQBrsASDQARm8uy0A8ShILL0yaSqgMzxvxz7pQmqLg0kqKS4A5LTR7rQtgzK4izI8A8BazDjAAz/4gz2IAynMQPBF/Bojt58/dxREd5+v/uvbcf9HS5zHbZM37WTI237F9UxO1gWVhcUgTqLKz7ewHMIjdA2bx8IrsPIwRJsl2/wzPAPz/MInBEJB3MAfKAEZ1AEUwEGXxoEgoHIZfAJoOCukLIos+9zUt3U1tqJnwMrkgLmJg72xp/iwz22KJ3uURzkcrT2rMYJ3AISiQ4YICvJz0E+fhHzy4MHjxg2cNGzcmEGzxsyWM2fScPH4BxEZO3UAIUIEyBUvV64qdQo1ClGlUJ0qISrUKRWrWsasrbOXL9kyoc6IQnMGDRq1o9SoNWOmLFq1buXU8etnb5qeGSE4fPHyFawXK2PHRjFL1srXsmbZmpUi5cqVKXOnZLE7Nwv/FixTpNTNIgbwX8CDxXy5YlewmMSDx3xx7Dhu5CtvKTdp4mQKljCbp4gZM+ZN6D1w8ghSBEnTp1KqUc3KNUyZsmazoz17Fo2oLFOJ5LShAghLHTV16uxZMWNQK0ghZugBwhwEiA3SHzxgYB0Ecx9lfKDh8+kWLFSoPnnyxEmTJkyYLmW69P69JfnzJUlij2mSJEiQHvXv70iRABchyJBDBDHIDwQZcsiNPOCA4w6KKrJooh/SqIKNOgqpQwsjlFDiJCroiMMIKmTQoo5JJqmkkkIqYWQPRkrpRRpx7LEnGaR0jIZHaKJhipqkkHKGx2nKeYeffOihxYetLHAsLLDQ/5oyrbCoHKsJyuiqa0u83vJrsMUCcwwxwMYw80zPGnsMsskoo+yKJpBIAjPNwuhMMcdAqyKNO/gwDRJKGqFEtVNeuSUY2Zq5TRppomIKGU/8UAMRMeKIg4pC5rBhhUFMGWSFEKRjboZSZ5Bug+sYiG6G7cooYxBZiMGlllZAKS899TCxBL733ItvPkvuw0Q//vzrjxFGFFlkEZMWSeTAaAPxg48F+2gIjzvgcAMNNtBIo40t2AiChRtIoqKID2KohIwdXohDixjIqKMlQDSM449K6vgDvGeuCYceHZm6hptqgEwqyIR/pOaaddK5qptImgThASi/ghKts9Iay8q22v96Ky7EENvSLsmu+IIwzwhj0zHGPlv5McnesizLmZOgMzO9kLhrrivSwKEHM9LA489G+Bhk0E0+MTSYYpQhMhpHr6mGYGiE+WSQLcJoIw5EeBBhBkpKuWMFFkTgwAIReJihDDS2QhUEH+QuQ4+6McEFGV5oLUUUT3Jdz5Jffe0VPmEvWQ+/+iQ59hFHHG98kQATMfDAaQOplo8++Ljjjmy3hWiiibZgwYlQ7NihCBJkMIIMFuugQosnnqCjEDsK+WMHQFqsQ0ZkpAFnHiCZ4gYcarhJmCmEGeaxmnXyUZIZ7kTY4AE0vLr4erGmzF4tjz+OrEzFRP6L5cME+wx9NdH/R1n9MxEz2U03aW6Crjo3wwIH+unnqwsbeOgBCGYgTSDuoAc+JEISSitFLXBBDGQsAxrSYFg1KMiNa1DjGLLQhBlmwIevzUA1PVgBCkjIARtAIQQs2MIW5BadV9FND5HggyRQ0UBh4AIXqFjN39jTCffIZ3BAlI8kDrceFalIcf9xxH8E9KxDPFEQgZCiFKt1BzQ4BA54IA0c2CCRiYABCzGgQyVcoIQSkWEUZDiBDOpABi0Awg5aMAm9sFAIU5iCF87ghjiQUQxkIOMYwhCGLmaFC1vIAha80MUsVqEMY9DCGOtghz3mcQo+6AENPuCB9binlimdhS1kicLGrBAF/yYcAS4gQxmeAkOXyHwBfekLjF1i9hf02XIMc/mMYUwGmcrsby52CoNd1FSYNIQODd0iTR8CcYjTSCI1okBFK2rBiwcaJWoUvIY2LBiNWOgBVCBYAbFWYAELPEABDkCBDVBgzlL5IAQ+0AN35hlDTKhCb7eoxStQYYpPbCI968nEQH81n14NEXGKqw+x+hMgRTziiRGVaBQP0oc97KFaDuGcthzSEC52EYxgsBch7ACIDsUgBRN4QRG0QAaS7usPIBnFKGxhC1ggw3imKMUd+waKVHAiEZeARCIS0YhIRAKS07iGONaxDnpUIxIELAMQNskmLzxGe6X03ihL2T0msP8lS/EbXxbqAhheoixNYjLrmtQnvjPNxTNn5WVk3kQ/J9RpL3i5S5a+0AUz/NUiyUQDHPgQiEEcohGQ4AQoTJEKWOCCF8U4xqKkUQ1rXOMa0zDYMb4Zz08cggNBWMEDLIACMbxADCxYARC4A8O6gTOGC7xhLWTRCh3+828EJdxBLbHQ9SiUWPV5hEP/E7nJRUtaFcUcHzR6hzxgy6MPwoIQRgEIOhjhCS6tBBVU8AKT2sEOnaDJJEIRCl4QYxSmcAUxnEGNI06CE5mYRCf+IAdB6KGAkTgFM7wxjqY6bB7z8IUe+gCHLQBhBpyMkpQ8hhbteRWsUiCrXkemV8nwLHz/ZmITYcaHF8PA5WSTqZkUsjQ/zMzlrvSzi2WuMAawCBYNf00DHPYQCNM4IlCa8IQpWPFYXQQDGUSqrGWnodloHOMUlHhFJEAQCB2kDQc72MEfbHCFQQxCDz44KjgHEYkYymIXvLiFLPhpir7xMFi82q18iJVQhdaHEpRY3CP004gANcLOU9RzIJi5XGtpMYt50NYa1MACIdSBDnagAxlskQxEUKEOnSApIRBBEx+m4iWYNgUskuEMRGRCvC+aBCgux4dN0KIZ2RBHOlg9DnOQgx7r4IaX8SAHIfCgqlLiWPdCuWCyZNWUWeqSXyaMlwvTZax6OZlhREbsv4QBC3EB/5m0RzwzJAx7LkhQcVxAI9g3sIENaYixRUjzp0QgLVCcEAWPp4kopz2jUdKYhjSeQY1oLGoWemgED1bAhCYkAQtzYEEfDmHqU5ziqAnXwyYEuYva2tbMfgvortKs5ksEC3Hr0RUm1KNQSABoP8Wys0Akuudq9UFzebjWg/CALTesAQ9smIRNNNSJUbDIuoSgAyFY1IlKj+IloxCvepFRk5ZUYhKa2MQqjFGjedADH/hoxzvQQXVzsEPAZeADuH/Ag+5gVUraa4souVpKUpaSCSIG8cymHRe5NhvbdCV2WfNyPxDHL36VuXaX7IIEv0/hZJ/pwjHfIG5wh/sMa1iDG/+IZkB0UyI1ClQFmI/xtGf4iEeNmtowTnGHMowBB+tsQg4UcWVU02IVqyAFKSIxCFUgIxhjboUq+tm3+LpnEhUXIpszzvGNY0LO+3HEswSBh0AoohGHMKwzHRrRZlYOIdfag0XzwBBBP5cNNwfEhq5bkkoAYiYlRcRMV9KJZNjC0q6wxSQMgUCxFaN59LhRPvrhD3/A4x3qiEfV58GNQZSBDdSg67xOwXxNq8yC1zYmAcfiC0hs7WqGruAkZBDDxO7KCXzJ2QJDmKTAl0Js7SqDLmim7/yuCZZtDLhg8MRtItoA3BTPBa2ogI4GzyQhaZbmUHbBaSCIGuJNGwjmGpD/oRT4AAhwYAZwAA4aocuAwRhSbxZo4RT07RaQYRd0oVb6KeLi6z1yT/cwDnH+RriQDxLsbHIM5LASKwzxbLia74kUAVooKiFU7iAwp/q2zg/+oBAKgQ5MQncK4edc5OZuQrxSwRZC4ehMoROOhhSAoRrEQf5+4iee53nsoR7wQR7eoR3mARh8IArM4AxuwOt8IEqoxGN07exM6asYcArox03uTsTmZ2b2xzIs0ALlbmTqTi/0ggPlCmQkUC7mgmbqQk60DS5giQvC4JiOCdzA4AzUwAUVDwiGoG0cz2iQhhI2oRTaDciWgUiooRrAgRss6HiKQRUo4Q58YBBIYemY/yEXUi/1Wq8UmmYKa0unRKFvBuoSVGQLgUVYunDiurD3fivkwpD5HMqhiMpApOgg9kC5MKduGGIPsCAmIpIPWcQkKkH9RoERXuToMg0R4sAYFtGpnqcf7sEf6qEfIPFGbqQe3IEd1oEUfGAJ0oAHoKAH5GbBxE5jroQsviqUSkkuasYy3oTEakYY50fYjLLahi0vpgAzsqAKuKAKoIAL0uAKgkAKqkAKoEAKuMAx/CIVLeMrkQAKmgAKfIYLzOAsOSIN1IAtm3EN2uAHAGgI0CAGY3AQAuUTSKEVYkEXhAEZfKQavvEbpyZ5diESKCH1aMEXfAH1aIH1PgEV+mgXbv/hFVrBzEQhFDzBHu8xH99DE/ZR4/7mEv6GEjguuCQh+CABNQmSIIlqDJUPivzguQoLcwJhD+TgUsJrpmzCXirBFnjB5mzBFWbC6MqrEtRACBzxRqIOH+zPH/IBH1ayESmpqZxhnsoAsMzgVa6Kezam7BCQFLXqSq7Ae3TSFJnA35hACvxNGCmjC8LAI6ASCqSyCp7yPaEyO/+qCragCswgDM7gLOtTQOszCAo0COaTP7fgLAPoW8JtBdvgQQItD+QAIjhnDg3rmXTsE0ShFFoBzJzmKH5EmzCLKaLhkVSPFFIvFlaBEgZhE26KGPQGFlgBFegRFMzj4narPTiBR3n/1DzOIz3Mwz3MQ1c6ThJUBPkSCwkHIRFoEw7mYA+IRtAg5EE4ig3OICN6YIXYoNZ64wZMwAgaLRk6wUUKgREajREA0ecyLRQQ4Q/aAAyi7h7qgU7hgSTtLzrrgR7kjx7mYR2qIRpOwVXy0wywx5PE4ju5ygBFcavagidN8QjQM1J5Ej3Nwt+gYEDrEyoFND4PDAg+dYWyE0szYoWiMgiEAAp+4FQPdIVCFbCS6RgPL9y6CA7kgEIhAiJarlqOL7EgT4Gm6UOPAYKyiYIkSIKmwURz4RRWgRZi4RQ2AZ9ilFZsazXK4zwICjR9L0jRI1dyhUc1YTQvrvfy4xFScz/C/xD5FEGK1jCKMgoPDGg2masNvmUNbJUNsKANFsADfNMWWIRFyKsTkmUUXMHnem4S/mAPhKAG6IEd2MEdWLId4MH+9kFP+zTAxEEcqqEXYqEM2AYNuuA90+CvquR6zM5kqSQUM8Z70JNlW3ZST+llW5ZlI5UsW9Vmb/avPBVnPYJUW7UKfuAGhEBoh1ZosYALjBawNkJp3RJCbVUOsgiLsiiLCuuwTkM1MeETloaaZKEvn2Yb5W3eNMsarEEanGJRmqEYfiEYdIHMbktpJk49AiXj/qZb6xYTNgFvlU7pACrjSjPOAkrO4lY16yMRFsFAnigQEsHGDCIQtEhK3eCYhP/gARagBRBhJtq0RRih0lIhJm6OJlokDtSABlaAYdlhJdPhHMjhYdmhT8XBGmzDGJ5BGYaBFI4jmUB2M8ygC1LWO3XyShyVUmXWZY+AeItXZov3CHIgB44AQVfoB573ZrcgZ6W3Z0t1P28WC4BWCKaLaH9ge2/RVTeCGdngLdugaZ820Byi5VjuufrgsMrQPqwRFU5BFWLB3bSRssB2GsbWGoq1GYyhF9a2bVeDEz5BEyAP+OLMNH0vNE1TzqoxziJYgfFWgjHh9hSYEj7uXAEkEYbvERbBIPAgDRriQORgC3CNLnGtB0TABhrgAcjUJHwOESYhWeaLIl+iEw62DYT/QLUssR0a9hzSoSXXIRyuoRmAgRZQrRmUASkGIQRWAA244DDiswo8ycFO9uwOcJRW9jyRV1KRN3mVF4yLV3mVNwh04AecN42jN2cByGb1omin63m993lvUWhvAI+9V2hVFQj28yy5gCPCLTTeIEILGWoNWeU0x32RL34l71B+ofIWBd4apciqYd6egRmAIRcms7Zuqzwy4bdK8/cyTljeDDXjrFjONeGWtJkK93DzwA1K7ZKSSYvCwAa4wA8OoQ/m4A3kAEu9ZQmWYKP44Inm4A9sAdO8r9Jq4uaMrhL+MA6EgAZYgAXagSWx7r8yNpOBYRgqj2GYQhZmYAVEwCPq/2JToYDsOEY8f20tyq6dgXeMw7iM55mMJ1Wec0AH0HiOoTd6V8iNW3Vo4Rho5/gGgsBosQAKhCAIVFVVUbVA53NAUZDwCDlCtcWiHWKwqNSikwkOpJEGE6hQXqEWciFRJFl/HSWTe4EWxkwVToFvzuM8OAH4TLMf3UxxlOXO8CyikGYQGFJbtNRtwGYGviYEQkAERKCoN6mw/KCZGIETduyOoloVqklvkoEYiCEV6mCGedMk2jQVRqEQto9FNkQNbkC1VkCS/BQctKEaGuXeFoVHouF4qCEZ+KCoNyA+OxUKyrMsTpHsGnWrJHWeyxgHCruwxViwIzV5DRsHdGCh4/+yByJbS/mZn302VX9AoJ+3B34gn3UAU+cTCgz0jA0UgD4VVLUzsDIaQtSXtd1goyCEWz7VIuxSDwKhV62Rfu03GIyBsor13oIhF2YhFl7hFEjhE2T6EjhhEjhuEyJ4PSRY5AKkp9dX3JIJCHwACPCLO1YgOrKjB46P+SQhaz/BFKZJpGXhFnaBVmphF64aGa7avZEhGeb7vYnBFGwiDnZAROygvEYhFaCBGAqhTe+wDuIAC2gABcZ5HcChGv638iI5RKNBR5zBFkyBu83pKal4C3rgUT2mUnPSUluWLSS1UgV7sJWXscuYeOeZsRkb1/5ns9M4slcI17ZgjrcAU4n/Vgg0+3nP2LENFAo6GwdsoLB1YAmA4Mif8VWUvG0Ey7U3inMe4g5e7iJizLRZ6yI8D+YKqwZL4ZF5+xkMBjeK4RZmQRYO7p8wARIOgajyYA/sIwwjoT7OcEl7GpNeBQ3AqVqe6MoaoRROYTzuCBVcoRaqCbJilBeE4ar96I+U4RiKAdIhHb4n/Y8q/ap5wRQMoRAuhQpcoKVswg55IRlqYhJuJw7AQJoTPASowdEjmUeMh2CChBgKPRVSIRG2AAw2W2ipd1TLwnczRquIFz37+lElFQeWNweO/bDDGAeGV4ybPQqWNwqaICox1VQh+trnc8Z5oArQ2KxHiAWmOdyR/1oExvmoRSA7QmADNsACpiM6pqOoixqpjXoFjmOo1+bFe2BthrpUjqPex/k49v2J671V6JIPkqYUYoEWcqEXeuEXVO/K+GBuMGkGLKCwFYABEoxujgZp8Oww8Xb1SKEUVmG4EakWagoXdGEXJnPlVV4XdOEXekEXciEXypwWeoHmc2Hhad6RlKEYgoEX9AaH1psVUkEUQCETHCET/kAN/qCkSKIkyIAMAIG+xo++bucPTn3Ha2Caj0FYkYJhBBMarDoVAvYSQgEU9uAMwOAHamCPb/YAf11lK/WdLZWMlzd5w5h4DRuMk13ZceAIAD8KjiCfDxS0o9IjCrQ+dSDGZ//ysWuA62kA8iGfBmjgxdfG3kuFBcQZ4P2d4AP+8kNfnMVZVNbd9M+pOta9OlY/9d1dBORpECiBFJY1Fpz1ta7zVQZBPwbLog4BEjABFWQhFmZhFm7B+Gke5xue4ZW/4ZX/Fmg+iaM/56E/+pN4MYdhGIxB+xfFGNR2F5aBFxYhDx5hEgTBEfKgBsDAfG9gB9TACFqiDrKLEAjhCbQaJvDlDmNqD7T+ByqfBRYFIKhR48aNGrRktlKFqlQJEaBRqRgJEdLjxw8gGDFu2RglCpOOIK2IHCkSZEgrJjsyYZLjyJEcMF3GXPmypkwcOHHMmIGzJY4mUqQ0gYmkqNEmU6b/BNliZmOVMFyghjlDlQ0bNVjVVGWzBciWHjzC1uhBowaPGizS1lhBI6zbnStEyA3BwcIDu3cfNGjAoG/fAwcYAB7M4AEIEDPKNNp0atWtXLRoxcqVqxflyrt2CdOcWZiwYKCBXe5F+jLlyKhTp/bFGpgxZrCfyZY2bZo1a92+fQsHDpy4a9CKCeNFvM0OMTGoUKFDx8gLKkp2xLBTSQkdO2Tq0Kk0qhCgSoCYI2K0J46cNmcoomVBrZpBaMRs8bIVKlSnSp0IFeo0KY6QNj/wQMNGXjFlBhcqpaRgFCgt6NFHKkHIhEwxuSTTERNSmBNMOFQI04dINFHUFCOSiEMQ/z98tUUVaVRRBRRVbHGGGWmYQdVEE4HRVQ9gwTVDDyygIAIHHIQggpEhJInkYSBswOQGDxS2gZNTIrZTGWWgoccgXDaCCSmnvDLLLbfoEkwxwwxzjDFssgnMm3CKBswvw5DWS2vADMMannC2CVts0shWmzXYdCPOOOskmmg55axTzjjhjDMOo4+K85sxxxRDDDGuYGGCCk8YQUcMJ5BBBxlP7CDDqYRgZwQZWjzBHSJ1AGKHHXTU8ccfe7TBRno9rAfNMry4kkonnYQySiWpjIJIJYXs94caWJgRVkYarViFgxEuWNJKD64krhUZ0pRDhi/hhCGFLR3RYQ4dvpSDDv842GCDDjrYwIK9/O5rwwozrMBDD2fgG9YMPOw0AxAsiABwXA5PKTGUFlRsQQN3cQDlXhuIoLAPZdzBxyCNUELJJqWcosorstTCSzCeIaPMzMoUcwzNzCjT5jBtvrZzmm2+aQzPPf8526DYbONNpIiyQw899thTD9TzjCNOOFiXE3XU7tDDTjrpsPO1o+WQQ0454YjTjTG+3ExMLW2Y4IELdsgACCJkyPAEITA8oYUWp2pBhh1U2FFHrdrRAcjihfDqq1bqpeWKKJlMwtB9yo4yCSJ/FAItFlPcoANYPGC7IhRQLCju6h2R1OBH5YobxUsSwi4uhhG6JC4O6XKYAwv/ca1gL/ArpAXxXEc6DPGUD0D5gGEX7yUYA3z11TyTM2yBBhx5eKmJKJ+Y0kotuOAiTDHILOOM+tA440z77i+jvjLN1G//n/jD5pqf+cv2TG22Sdo2viEORc0DavZAYD4WyMAF9qOB/XhgPuzBjkU1yh4OzEcE4TE1r6XjHOQAG6O+8Yw8LQMZsMjDDVrgAQwYIQVasIMRZBADGVBBBkqIQRFMtTi6AUI7SkCEHQgRhzo0rldYAcMPgpUWhjwrFIjwXCVCUQg6xAERneCcE6ZQAx0scWFAWAIQoNCEMiYoQuiSXUlMsjpw3e5cDwqX7TyioQ0FjAUzSMu/jCSCDVRs/wMaw8vzBknIBygAYyFADBDuAAc0iGxklPhEKSaJClncAhe8OB8ykHEMmdFMfc6on/tEab9SmtKU/juabW4zjaR5YzcGfBo9GojBBjIwgrfshz8iyMsI7rKXuEzgPGLpQH/ssh5Sk6XY3OGOR0nDNcUoRi0E0YMbyC0CSqBCDExgAiPEIAZPIIMRnhDOxcWKDItj3OFy9Yc6XAVyS1xPQ56FH2ch6w+0GkUntCAGGzghCEGwQVi6sgSAQsGN4PLIQYNQUCakrgpceNESEupQCHlkom5cAkZdsgR47SQnOjmeCEBggSlVDATPK6kfTbqBEKwAYEAwgxv4wAdFPIITov8QBStcgYtbEGdTxNikzOYnv6Iqwxk0K2X+loq/+zXjaITSRm6wto4DInBrGJSgLR2oS2MCs6vGDGtY//EPsZrVrMEcpqO8Vsxd0nJrHbSGMWZGLFicYYUTiEAGlJCqE5jgWSYohBEIcbjvnMpzdbDDfBZHB0RMog7mucoZLFKD9dhHn50YhbMyh5/7IKIFQlKeXEYrWpfK5aUvnQHyXuowJikpSVWamEpXahcLUA9j1fML9fxCSCeFIDFl2FIjJIEJSZ4CFSuz5C0ys4tMesYzMPtMdIPxi+pa9xfAsNOdWrOn7u4Pf4IKoCu/Mal1hE1sT6uHevGBj3yw973sde//PfRB3/rqYx/13QdZ/bGPfZw1rL30B1kHTOAC7xcf8EgHpLzB4G+ww7342Ec93JGOdpx3UlETBzOGoQxk4IIR2mmBC6ggncE15HKIgEYqDjdEQgDiCXGIVh1s4QrGIcIQeziPGbTyg8rS4MeX1ac+8TNFhkCxDihArZJJ67DXGknJTk7SXJTEJBAkqcpYPoyUAdaDIThSD3oYGSROJslSILcVLdPFLsrEXND8grrajbOcgdHdOnuXaLEJbyvHGylGmddpYnMaPerRXnjc4x7ySPShF31o+s7X0Yy2r33J2t9K97esmD6rLnVpYALz49OfLms/8OEOcjD41OO4Rz78/7uPe9QDHuYIIaPosY5nzHUZwjgECmJACDIoZwd1IAMibFGJK4rhD6mgxiiUcCs7hMeKcVDcDzsXxRyjh8c38DEN7JNZZd3ncvVERBxagMeAIczcAQMYXJQMMdO+NnipVViW7oAHPhyiEY3QhCeMi9xXwAIWLSOTmjNTXdBQd+C7+MUu4vxmN5uGNbmwM554ZrT/BTAbDZZUowLttXZ4/OPweAc85KGPRJMcHiiXR6QlDWlGHxq+8GW0oQ9tzK3qgx83z/nNQe0PfvS800AvK3/vYY5xMFhS44BHz/fBD3h4PMEhXAc9plE/XCtiBSaIAR2eQAcSK6EOWijEDoxAhf8XgAEMghhFi4douDgwop3o/IMhDPGHPMjhV2oAgxB+kO0b0CBZmL2cZyvhilEAAgtm8YEPrtUDhX1M8T4YguQdiYd6D+IQY95E+M7MMllYsny4aO5ziQHdgjM34djNbnZJ86Y6x8kXbwIam/701GfQJoDbUFqf/Qy2QPv+48xEuTveQfx3xMP48Ui+8pcfD5Mnur73QPnKWU5fmMc3wvi4R/bxoQ/rLxDU4Me5pf0r4KAX2OfG1AeszWa2cbxj5//Yh9MT3KhvTIMZzYAGMjSxgjacQAU01ByF4Gs7oARKYARxEAe7Egd3QwgOqB/bwTmMYCuAMHd1hx4yond8dwP/HDhFy8IQIHhimlUIWLAGIsMlJNMIY6YJnyAKqMAKrQBwtWALmMQLmyJUOBhU0WQzO9iDO2hwwTAMsdcLcZInxhB7s1dxFod7DNZn6VAO55Ve+LBeUzhhzBR89aB96odyM3doXJh8xNd88RBy76AO7aAO8nB8YUhy0Sd9rkaF1ldfGWRL70Vf+GWHkmZp+dVfAIZLGtQPd0h9+iBz6lCIscZ+7GcO8hBqxlQP5nAOCjYNskENy8AJQdICMnACMDBDVKBZZDcKdGBDRgQIkwBFg0MI+FEIjjVsnaCKiLAIfpAHbVAjZ6CBHFhZIdhtleCA4FYIqUAcnoE+ylBU8uM+/9AwLOvjPvFDjPJDMzQzV7DRM2xCNLNnP0dTDYSiNLuBKOvgNAl0VRP0h18VQZbGc/81VvH3D4LoaJLmcvPVaoj2fPOFaO4IcxDGffT1hxDES/zlc/elD/xlVpXGSwv0Xup1kFZIhsVHfB5XiOrwiOZwhuhgDhHZDhR5kfDAD5TmD6SmYNiAf9KwDJuwBjRwAR7wAUVQBE9QBDFgBLv4HXbwBNRRbIjgLIQQQ/pRB8jiOZyDCDcWi7NoI+kxEbcIOLeCiuChODfpa2QwCsnQPqAESs2gjOsDSlS5jKhUe7Z3e7eBDVLVDb3RG1R1VVhVS1ulQWjpS2B1jsZkfuZ3jv/9lQ9sOZe6lHPhx456aGnGFIjjd1/c93IyJ3zuIDbnUJjnICmGSSnlcA7mgA6OeZGQ6XHmwA4V+XGW2Q7DBw85x5ELxA7eIInuoQpowAIeUAER4AInQAeEIJOoCAh5Yx1ksBBxYAR/42zOpjjcwQiTsJuMsAiCYG1nsAVaoXd7l21KSQa+ZiuVYAeCgypKEAeu8JTKSD/5I0rFWJXO8AzVcA3XwA1g6RuJMg9lOZ5YBTVn6Ute9VW7tJ49J1ab9kv8iI5BV34Ddo7jyGl06Uvht5/hR358mH6QxoWSCULsZ5iHiXSISQ4GaqC+d5HooA4TeZG+t0zsgJkUVmEWRmj/hsaRoyY17DAO30kNm9ADIhABEVABWqACNaQF5qQEWtBryWGAJLYDg3MdLuaTdMAIPrmbvmltaSCcw1mcNaA4oQAIL4qKhMAclUAFyEkFWGAIoUA+y8CdtYENVjoN3GAMzXBUoXRUz8AN4jBMVkVBgRY2T1eF9KBgp+YN48AO7pB9hlaHcXmPU9heBRlh7tVA8aWnaLlqd7hyf/loLHdo/8lf3PcPGqmOeXhWPsefd+kPg4hyZ/iQj8iYBKqgkNl7E8pM7fAOw/dx5iB8l+kOXHiFmImQshQ16iVLUOM1YvNB5fA1aNMN2SCJv1AKlHAGHfABGvABpyIDRlAEgnOA/2RwgFpQB1TAHXeTHc42CrbgYrmim7qZCILAB3cXnPBkEUuETp3wHZ1wKyqpmk8gA6jSAmIwBXNwCMUwD+zKrh9aQeAQDetzVFsqG4ZSVVJnD5paoZ06iIRWD0a3puPATPg4fvFXkAy0p3f6XlzFSwz7h/w1fv0VYJW2n3tJfl7VcxqJfmK1D+wVfaTKQSj3Dh9Hso35mATKmBepsuZghp16me2wTJx6hbBmhp4qcvLAhW54D1fITKz6NBX0KJCiG96Qe7lXtEZrtOFQtNpQq8dAC6twCprgBy1gAhWQAS0JrDBggEogTk+wOElKCMvSrdoBCJ3gCvpxN4Wgm49Arf/WOotAenYTsa3OZraVQAdaoARF4KJFQAVaYARGRAVigAfrOg/bMA6DBonzIA7gAA3DeDMzo6Xa0I1pag+QeF6YCQ/y114fuqbeQA7t8I7np5HWd30wJ6iSBn71lahz2brwiUvstZcgy0yFyX4IertIh4iMSQ4UuaAqa5EX2Q6O6ZAua6o6i3Kv5g6Zq17M9DUgxCjj8A1Ia7RWaqW3cb3YQCjVu73Zixu0Wg3NMAyS8Qql4AmdsAe1ggEpAAOrkpIwgJx8hZzUEWx+uzi1kk7hYR+72baBwAd44Cs7Ri1YoIE9MDhksEOoiJxFIEPvSwVJagQ7EAeB4AzrEA6w4ab/YbMO3OAMlJg+ynAMx+Aaz9AN84Be58WvIqd+7XUOnusNbkpfiVpglcZf1UendbifqbtzrDt+exlWlpYP3fdePau87HCpuVughUkpvls2kPg1YAOZjJkO5iDFUkyZFVqhPetxWRyzTnwO0IuguiG905u0ZJx72cC91UsoXanGt1EN03AN1WBruRC1pPAJnHAJk/AHVFAIJAADLuACRcC+MEAdMvA3Kwkrr+KSoWA4poJOdcAIkDwJjpAI/XsebGAGVwEGWFCLFsF12KGa+2SkqPKiXRsHN6ACcUAJ3FBVSyueiCIOypAZrXALyEAM0fQLQ/MM35Ao9FDCYuNxIndo/6MWsAw2QOxQD5x2XxLLcn25h/iVl8+sX/1lX4FZfMJbqSB0oIi5mONwmNnMshHJuxdppjBLmZBJkR43oVx8xTEbs08otJCCNWI8xmVcz0k7xk2bDfp8xt1rDdegxlZ6DdjAnbcBx9Ugr8oQDLegCqfwCahgx5fACKT5ASbwxyUAyDhUBDIAAxrtYirpEPObgFrgwJUgrZJ8CH7wtmkQBlcBFRuxEYpDBjcZTjukBX0rOGQHHTCgBolADeIZno8yD9yADKXgCHcgCqS3ScHQCzzzDOGgKJiLswDpDwA7z4c7aJymXwIJavYFYP6wjwvLvKb6kLg7DuRg1mZtu7671v+GKcXnHGtTPMXkXLxDPMQetA5efLtWXcZWSsZWmg25V72AvQ38jMbZoA2Ijdj7rNj8vM/6TND+nA3cWQ0HPZXH8Auy0NCU0AifgAmWMAmXUAgdwE0mkAIf8McpQAIpYAIbDQOAME4qEGwR/AfAJkS1gkW96ZuxKAdw8AZpYBVQYQbCbQYOGE59w3XXYQQHKKxkYAIXcAJKsAa9IHUHVDWJIg7UYAqHIAg3ZQqbwgvVxSbSUEDmZabIpw9l1Q7Re2rbcA6aiaiOit77Nc1VKNa0a5hlfbu6q6CIKM5vnalT3MWXy68TWuAeBzZPiKDhQLT0bM8OTr3U65UOLkBJe9j/jL29kG0NlE3Z13u9kx0o4ZsLvzALpzBJpbAJlOAKrGAKruAKhsABdsBCGPABJKABJGACMJDjf+wCMKAFMKACLxAdO3ADM9YJprK2lvAIilCtdtfbadAGs7jSXCDcT3ACJLAqfqMEywIITOq3RkABGXACMSAIn1AM3NAbisIN8soJvLIHl+AI3o1JwsAzzTANiWLexreI6nigDeYNb6qxqmtfgtkOhZnfCArPk7KYH3S5hYngjo7goJrOv4yZllngr+rFQrvgYszXaEzY+ry921C9Dz7qiJ202rANiX3Yn57GGd7hG77hABQoz1A/zHAMdUILsxALqxALr9AKraAK/6gQ7JiEC7YwCSjgASzkAR4QAzCQAi6w2n6c2s++0TuUAi3QAndrtszRCZfw5rqdY2/g21Du21JuBjIAQ1wnTkaAHb7mAt8EwbiyHJmQCrWwDAJREMtA7K3YOangCpPACsmQDMSgPvbajcfMdDz3QB+rfbkEX1Z4hYHWvIRp6W46mDJb11kcsvCg8W64qk8j8e/8xQo+z2saxq8kxia/G/KsG1jT8i7/8jAvz6/U8owbliqv6SrfG92w8zxPEJNdDdIQDbP+wUOz1LkwC0iP9LoeC7z+CkwfC+SjC7WgZuRTg5NAmnKTASWgvingbDGQAhedAuv+Qi6ATiRmRIWgif+3giyTsAjb3Qd7MAfhHu5jIAZhEAaggwUquZJbJwMb7QIrqQLgkQLwax1TFArJQA3IIPCwkAqpUAhUcDej4AqZ4AmsQAzJQPC2Zw1Sxw4kd3NffZDMRLIWavEyOzVT0zWqTw8W/7M/K2iu76puiqpTA2jvLCkk79cCJOr17Llk3GBhfPPBH/M0bynGf/wrX/NhCQ7fufPcINkGLQ0g3gzM4Calgeu5zvSrsP2roAor8wrgD/7/9m/g73m4UAtlUia64FO8EApgcOxGoAIqoAEpsE05ZAQuoAJibyt6C8gusCoAAQhQoSJGyNBBlOnRo0N++uzZM+fNxDdiwoTBMsX/iR0YMorUAVTEhRIlRZ5o6URHhosiRQ4iqmQqFSxcxJIRy1SJTqVOlSrV+RPKkalky5Y9eyaNmbVx7NrF06fPHz537Ny5a2cOHTp16tp9bXcVq1OwYMW6q+eOXr219uzRgxuXHTu4c9PdTTcuXLhv3rxtA7wN2+DB1ggfRpw4WzbCi7U9Dhw5crdvlb11u7ztWzhwnMF9Bh1a9OdupbVdq1ZNmrRozZopOzbsV69cuW7RmjUr1m7du1f9XqVK1atWrYQLf5VcOSxZsF7Jgg69Fq5btWTVqgWLF6s2LVooORFDg4kUKUzQqZNChYwKGGTI0GJHiwoXMXYYiaGEDBUt/2Qm/V+koYcikkiiNiwKQyMyPJLBDkIaNAIGQpSQgYr9noChCEDoIKSSUFJxhRdbeHGlk07s8ImMOgphhBE5LrHJGWiemYaZZ7A5Bx59+NFnH3fOmcscIYcU0qyv5gIrrbOwoseuu84pZxy99uLLm8cSw5Iww7Y07DDGGMPGGjHFRKzLwcA8U5vIHmOzzW4eKy1Obk7jpk7UUptmtWeaYYYZY4YZBhhffKkNt1miQ1QW5RbdbVHliivuOEeTY865RKfDLjtYaskkk1AsROSDCT6oQwbzYtCCChfIcMEEGFJwwSMJydjhhRjIeMIlOzqZBBNFBIRojgLfaONAMTKyg/8OLYzwSAtC6CioJBhcEMgjQMgAxKdOPhylE4HqUAJFMkZk0RVG+ihlGWqmsWaaabAZ556o+PEnra+K/Aqrdpzc1y4opaQyHL/+AgwxNBtrbLEwDUZzyzAVPqzLMc3E5pqKsVnsmmvGPLOwije2RmNrUqvG3TxZ27PPP4fxhTZaXn45N9xigTk33hRdrpXnsGsOFp8R9Zm4V1yBlBWjJ3X0Ul2s2xQWTzjwTgktTDAhgww6Wqm88lwooQQXOooQhmXRU+I+JeLgaZKFgI1oIgOLtQgLEkxySQsZnhhJBmiZBUSJJ+Dr0ENXChGIDjJUMKISQgqphJdQlEAkFTVYmIH/FG7EEWcdzdnBpx/P8alnLnbwKidKgCvbhmAtw+R4Yo4Lc53M2Gcfc2PbMcb9YMOuyYb33kXWGGSRXXdXT6T49NMYYAQdNBeYaYllFUN5261662OxOZZXhNNZaJ2/d8657iElvxWiyTe6++RwVk7p7GRh5REWOugAAxdcUM8EDFL4oASqV/oACVJQAhKoQAXqkYEKlGChOsSHDozj1docEiy3zaFYcAuDDGBABiMYoQjvscN+AEGIjtxPCzCgwihG4aFRACIGMYiVCnYFCFt04mxkUEIMWmADNughF5nrxmf64pdtmMyIR0RiEt1FOybO7ohNHFNqaFeNkE2MZCUr/5409oS8PiVPec2DmfOeN8bnZa9Rq2hU9IJzHDaioo2nOAUq3HgcOcpRFUYzmipSgQpWtKKPeOxjccSHtOjgohauuM4jOCABD5AgAxPAAAZaogItaOAD0DKBC1RQQhKYYJMfrJBBemKHOvCkE5eARID+MCCJvEFYbxODGP4mAzIQQgvKamEp4zMKlRRBCYDoFiDsgB8qxMAkKiBDJQBRBzoAIg4HOcEOGJGKWhzjGdFgBp+M0YxnZLOL2XQNOJEyzqSsxpyrmQYVR2Yyko1MikskHhKviEV3zdOeJVtNNI6HPGP8iXm9aN6gBgUMQAVqebSpTULFCLNbNHSMuckNdP+0tyg2CqeOqIBjRk9RCo5qdKNwLMVFL8o948yxfOpb1HUydUhQyOECFIhABiqgAQyQwGskENv9ZGCCkhgQgCWIUAzoQB8VAAIRLUBbKCZxiUU8QhCrfIiwXPlKY4mBDDCIgYVI+QRhkmFBKFoWFQpRiGfRgQ5U2AkhkkWHZF3LrIYTYShGpAzXuMYZzuAmyvR5zRlFIxrnRKc503nPwVYjeIcNWcZ8d43TMJZNdjrsnVTj19a8Rhn9BMZserFZhXa2NpsF7fL6OVpjBOMXwaANaHehC9bqArSczQVne9FQ2taCtodKVHSQlhyUKkcV5dstccoHC/KtFBeGPO5xQSH/hBvQAQMQqEB7KsC/CnxAAyYxwdzuV571fLBvMniWCvijhBv8oRKZmMQiFpGIQ/xhgq+U6kTGMAYxvOcJRqjDQVL1Nxcw00JxQOtZLzRewzWoPymh0AdSUIQYIMIVteCFMqBx12Xc1RnX9OuMoBENaGwYsICl7F/RmSd2zjOy91QNyvZ0V2VcthjBMO1sFEoLz9Y4tgj97Gt7AYwdj/YYfzqtjF/bWteCNse1oW1DbXuLiOaWfbz13m+L8yiSQuoVPvuecE9KPlnggjnY8bItcGGKM3jHBR6oAAkwcN0PkGeA6knBtAoiwA0aoT6AWAlHymaCHRiiU+ldryHcG1X4/1LkDfOFYYY6iEODuAARtnAhSeyACCNQyG8WIkkMmKWFHQDCCHQgYAqoYIRJsEI7wlAGXuta12s+48J+JSeGQzxrv1KDGqwJMTX+SlmkWBg2xyjGi2Ns5ITeIhetvQVrbZNkZjc72a4lMmhnc1oYF+MYsPGnjnXMWh3feLNJtk5DIYpbRFWPt1sun5T9iG52k69proCFK1hRC1tMggUouAEGPBABNdP0hDJQAqzKY4IPqKAnCKwQIGJlaSOoQNNxmEQn0OuIRAhC0H8IVqENPYYilBBDxhwJGVpohBRouhKI2EEDF3i4WBGiE084SAg1+AG9/cEU1uEFMiqsam7i1f/CPwf6hTvM4Q532MJGafExgF2MYZjWtLTRRbNZ6+xnTz3JyKYttG2z9Vv0Atpe9zprd/ELasN4GMG2Nl1//MVfLI/soOW2tuE+dezctsnlnqiW0RfI8uGx3exuWnNYIW9XZIIFLXiB/jBQAVtOgN8foBD/rqqB8ZQ8BikgwYLes5KV6CQGN6hDJkDxH4pb/A+nz/grKYLo94hkJTAs+bVQZYSeeHUU+NGgC6hQBDtsaNKeJgSuSGmIVFxHF8TQ+bWV3uIWI13pz4c+9IshDNMSWcmJwu31l1wd29oW68wmcvinrmzPpnaz4h97MIQR7KUvHzbN6CczLvunlWX27b3/ILtmz4/17TfUyUj7u3SrMnUDpOLgu+LIjsEDEVdYBBToABMQjw9gCSU4swygmgASIC34AA/wpAOCgRL4gIYLj1r5mmt5gR34g07wBElYiEUwhIvDOAJRPfkagwpZiVihAr15gl+qAxUgnFIaoTqIAQbRAi1QAjpwBVeohEKIA0AIBZ/4CU7ADl3YBWEghmWwtqVDhmIgBmGgvl0AQzBktui4u+j4GZ9BQ+YAGkSxDp7JFKoDv+8zNoWSu9YCQ7ILBvZ7vuZzhmXohWEwBrqyLGNQuj+BsRjLv9f6BTCMOu6rLZ4xQ0eJlOMwDkipqEu0RFWoozsyjjtKn1bYlMGD/4VUSIQV8AAPKAkFMwFCMIEKIAMMoAA1EyDMm64UoIA4gwEDIoMYOIEcogL62EEtKIRJCAVPwAQWXATTQz0CkcFWegMVOCslUJxReBz4QJwYAIROCDlcuZtcNBUYiANbCAUwUINnqgNCUMI6cIQRoUJkcEfqM60wxAUqbETuW6k2fB/oSMN9nLIr80dHmahGIUObgSjpcERwyw1nA7swvENqy8Kka76dKwZlOB7mmz+0g7FFZMjV2gUYWy3ukwUlg8SegTfi8qOKyqM8ukQ2mrI+siiSqjKj8Rl5SwVB2IAHaLM1w4APiCQOjAPDMYEiSIEMkECtKQ8PCI8TMIITgP/GOiiVWIEBOxBHUTBGSXAEGDw9jBOW1GulrFKCE7EDJewgKiCEF9ggUiKJItCCjtMgj7CQYoqDOAAJOvi0OqACNWAFYXDHvXwxL9wFXuCFMLTDqLtH6eAZNLyONEzCoAmaLOstgLSecZOFQ5mFg2QyOBQ7KmzIYDi76Lu2Zbi2DdM1+Guxfjo7psvI/NtIjdwFcLs+M2wO7+lET+S7iupELVOOWFAF4Nge7hGOPpI3VkiF4RQFObAAB0BODYiACFi8CKgAD2gBLRgFV2g4/ukkFQg+n7qVE1gWZnmhVFkwUgsFUMgETIAER1iErMxKZpRBirAzgLslLcCQVamErzn/KzsIBQYrAjrIRZh7Arx5jx04uWK6FRk4gRdQg1BIhmSwsGvbQmQghggFzI3UheSyhbrbvnvU0A3l0JWqjoayOhC1vmcTUSSzDR3Tv/vDv7YjqD/0BYK6ttR4BkFxnkIZN4KEqOrpDd8ADu1ZSYzKKI4S0o4CKY8y0lNYBSR9qFuIhWCoCVyYhDTAAhYQAhq4Nw6IAA+wmhPIAA2YAKuprhLIAGhUgTSbKRjQgDp4AhIQDxVgUxjon6ohAa4pOROog2LMBGSsuEMQBD/wU1aawTdIgxg4IP34NEJQgVz5AN6TASOwEJPwiCKoBN4bKvpYMBAhS0TQgq+hDyVQUKNw/wZlCDZksEJk4AVhCExGbKjkSi4RtccPfcQOlVU4rDrxiza52yz9W1GyWx63mzaDeoY6qYZAGRQc6yxDsbsdBY7fiJ4jDVKOIoVoldZpJQU4WtZZiC1g6CduwoZtKI3L4QZlqDBkcAQOWCQHuAAO9AAKiEUPKIFO0IIKIKAulQFAUIEIqFcxpSlLsqkTIIETqC4ZkMAC4tI4e6EXYIRiPEZHUISK69M/hYiIfSU4mAg2paSs8okS2KD6sLM6MAJP2r0UgI//pBAjwBA74KVCGIU6SJYi2CQXeIFL0LllWD+060JUnVAwZNV5RLbjulB6k9Wg1dA4FFFbNVo7HLv8U//a/DvEpuXMYKOGz+AGbAqUQJE7JANR2zCUHeXRZf0NaqXW33iZQTGGbKIRa8iGbsAczNGcebCHfIBbepiHcJjRPgQFEeCADljOUySBBNLSD0hKA5qpDCABEpgpDeDSwq2uTS2BE/BXDSgBSyqBlVABDUiBCjCBFpAmhbXKhhWEh52giODKiYDA/EihUYChWzog/oAhNVUJrIkPFcgvkziIHTCrXwo+k0gVIRAEW0iG6Vu/mp0+wEzV40pVrBMzC73QnwXaWe0/Jbu6ZCvaoyWy1RK7pM1Ip9XeXziG0wrVVIst0VSGXyioXv0FX9AsbysUMiIjgQLEPsmrd8kGzdj/C82x33lYh3nQX9FJB9Fxh37wB32Ah3GoEWaABlQAAhG4gQtwgOdEMw/AgAxw1y4lVKuRqZiaqcJ93OpKswJygQoA2MzjUsHlrpTbFk64hM5lL0NoCIiV2Bk0FV9qEAKFgVeJgfyKgVBwBWxJJrH5CZRwkP04ISO4pWbqEJxKJjD4g1TAhenrSKULNi8MBsA8LsFkLVxIXla1hS1m3qAVyefNuqur3iGzYkVcWhZ1Ou09RGpwhlKIBOKAjlMohmUwu/JdHmIdqDsuWxtJCnfp1m0Yh3KYB3p4C0J2i0O2CneAB0WGB3goi6v4iv4Vnbmoh35oZHf4hmzQhmqABj4I/4Ea2IF9Y07rIgHK01ibqoDlFNNSji7I1YB/1YA00wAtIIGCuyo3NVDEUcoRSoEdQITxRK9HWK9DOAQWftgB4UqK/ZqviRC1Kg9m2YEdiIFKSAZb0Jv+MAkq8JufAIQnoAITuOadIEs7wDxJ7SAwgARb6EJimL6l80IvJN4JTa7p8Fkxu1B7XCnpYMORrDvwE+Nbfa1d8Dow7IWkVVr8W540PkRAKQayC9VgOIYJE4Zko4U/fN8uGid26dbNaNtBNmS3gNuQhtt+yAfPMemT7od9SOmV7gd86JyWvodILh0pARi/aJdnyIVTwIMZEIELWM7q+oAPmBYMmIBXTjM7KP9Tf40upTbcWK5lDZCBrvGaj1iPmyoBwymCFwADYvSEYKY4YjZmF+ZKYVmPFCADO3A0Mui4F0gmR13QUMgqtVam/dzB6ZSa90imB9ICPCuBOLsbGXiBGjgEV4hQ4UW7d8ZZKvbZ44LeZstnJwvJ6ohsWHU2gDa/XF3NIFNaO+7VztZW+BuGY7AsWhgGabCYzSiH/oWLQ2btQxbp14bt2A7pQ5aLmabpyugLwMiMtO0G1JAGZYgFUoCERtiCDfDpCYAAVewfDciACLYa8eDOEyhq5i7crjHqgqvlrzoJUpJAQiCEEngBRCgET+lqZORTi2vh0I3YZtSkSE0gtdbFQsD/r5Mjg1Q5a52wGyMgBHFEK5GoBGLom50wAhD0iPtSgR1AgTxIBStkZ7SbPhiDZ8VW7I90tsK8DkSh1WSrDaOVO12VtrbbrBfV1vgz2z5GW94Gh2s4GWnQBnFw27cd6ZOWbZEmaZKGW9qOiyZJh3Pg8SgpnXWIkoAJh7UdcnGgEtEQB264BmgIBlSAhEPggzvIA72NAAhYgJ0MahJwTg1QAS4F01dWgS51gcINhe+GgVpejxPwEAI6ARjoBDL4AAc5gUKAiVAQBRRuwfNmYT9V7xcWllyElY64vBcwAlu5Dy1ogQajgrP0pRh4gRfwiUl7EFoiBBfoNMXJwb9xiQ7S/4K4TIUFTb6kUzp3TAZ3RD4Iza3rsZ7hYBRGiQWJwh6IcqjLdKiXESM6HKiLRoolml9vCIfNoQu4qIfWdot6YAuQjnEZf+23dYvVbhJ/mWnNMfL6FfKAwW3cJo0gEg05sRNpaIZfkIVSePJDUIQ9uAEOyIAImIBajsV05zfCTXfmJlyhQg8CUjh/1RDAfWUSQlyHU4ESiIANTAEsKARXSAX0ssoAMQQ/IOY/7YOHB9RXctmOQyG1PJxCN4JasRVmUQGXaAnAdrhPq70QegIV0FxslM8TMmuvgjkqiINPvwlrCzbY2MLCJl5Dso5EUXUfFQ7tUaPkUCM0UvUxynUSN/9xbcCMcBiHtoULjxZ2t3DpqL8Hl/6ce7D6S1aSr1CHIelxHzcdgNkL26ZppS/yvSByszdyzCny0MCc0dB2qVXyaFCGXoiFVjAFSmgETVgERGgDmCrlWCZqq6E8yBV8wm1cb2FKqyllWCmCNONSyrukeJ3TCcA8E8CCSTgkTpiEhG94Yu7Th4cIZIavlcAhj4izX1RTGLIVh3MBDlmw+n6hDtKbu3G9IhR5sryqaVGWDCGDOPiDSYjQwt7CPAwGMExsXvDQNpxE3zoFVdCo30DSZYWZFy1bbnoGwwCMbwhkSc7xYa+HqA9pk5b6RQ4d/j2HvKDp9Ff/ceiLa8dtX3f//8249oHxdb4QGG/4Bsqwf76ojL3oDHAAiG/gBhIsOLAbt2vVoj1TNuyWqlOmPmlilcpUHRMmSqhQMYFEhgxkyEBQoqVChhMaKpBwEYMECRUaMrggUeGDyhIwP8gAqaIEzQwRKry4wYgYLk6TJjladOiQn6eC/Pjp02cP1qxZtShRUsSFCxgylJChQ+UFlTpGZMAoYocQDBgjyTyJoaQOHSNtAVWqVGgHIEAy6DwpIuOwDDJFyFChMikULF7EhEkWZlmXrl26cHHGpetW5s+9Ys0qPYsWatS5fPkCZswYs2fSplnDtq3bt3Di1vHmzY5dveDB4bmDV8+4u+TJ2Zlj/9fu+bjo0qeHGxcu3Lfs17Pnxv7Nm7fs4LmH79Ztm3hv29aj92ZeW7b4583Tp6+tvn1t+q9ds1ZtmjQMNdMMM8cYM8wwveRCS2mxvNJKK6yw4oorjHjgAQYTuICIBx8IVUknE7BUwYgRaOACISdUcEJKHn4AwwcTaGAEISNmQMITRnwQwUdC/DFJMsiAspQjijwV1SFTVWXVVVphpcUTUeZoRAxGUEFIJUrQUckOMhhRlmFRyvAEGTGQAUgdVfYFCBlxGFHHYUW09QQdRdgpA1dUVIKIIaHUwgsuvPAiTGeCCurZL78EEwyCsD0jG23YYONNdeuwQ489+dCzqT2dbv/66ab1bMpOb+WYWg514Km3nqqtuhqeqtx1dx2ttXonq6zjqYpfN/eZx819+mnTXzXFAvgMgcww8xowCqIWSyyrSDvtKdOuogq2qsgiCyywRJhKKraEggIFGETggQp0tIDBBShV8IQMKGVAYgURkBCDBjLOW8FHGuBUAR2ExMSiC53UkQEEJWCAAhuOJOOMKZQw5dQhgUhFFZNWZTUHx4UhlqMMYWpBxg5g0mFSYSOhOAoZXxJiZSWM7ZDCl3bYMWaddigR1xMwUEGGElS0AAYjtghqCy4UugKLRbUQU8wxykRzjTjzzINpp1lnmg/XXXeND9j4iJpOOtON892rq27/ozZ77IFH39vmwRoerrkNdOt233RDUDjg5F1er/Dx59+xAyp7IDC+5LJgtNaucgrkkJdSSuSnTH455ZWjsnm3EErI9CRxdICCCy/sS9MHGmDgLwkRqGATvQ5oMLtQMur0Yrz+/kRCvDHUoQIEGVBAAxuZJAONK5pM8sgiiVR88ZJMbsyxEYUZYcTI1aegAhmIAE2FFnLK8JZcZNjRSWDme0kIGXXsUEglT1RiRxFP2PGECvAaZqcKh7mgRBwmUYlMMMIQdThgHdogB04IwxnOeMY0ujEPrWkNVFa74DxMRR1bcfBWuLKVeM5TN+6AA23joU9ucEU3+nCjhfz5D4Ck/4Gsww0jcaxRXGpoEQsdNs5x1Kqc5DA3uU+UQhRGxJwpkmiKVniLFapgBSowIYIOaMRKF3CAB0ywAxNgAAMfYEkGVuKukEQgJDciEQkwUAEMuMAOLshAR2CgkhN8EQIeIEEL5jAJXkCjFpzIxCSa97wkYSxjTdoDx/pCB7oogRCASEEJZEAIQoyMCnGik2LoYgdALDIGKgCLEegwijiMYhSECEUlDqMYt/zPTmHBU2K+RIU4xKEQb6oDV8AgCFFAgxrF0kY4NOid7bgqPd2JDq1yI45lMnOZuhHHOKBZnWYuMzvgoOZBDPKd7LwHPtiwhjWmIU5xyjBZB3pNDVmzOP/W5LCdDYLWLKAFrWtlC4iRE2Ipkjg5Ix4RiZNTRSueCEVHiAAF68riBTwQgQ+YoF1enB2JNFACeZFoXyyJwRdn9wESUEEFqcOATTgCEwiQoBJ76MMicJEMW3hCeY5wnsWeEgiMnVRjG8NSy2KwgydQ4QQqKEJj6ECH8EHJCErw0lyoEAOwnACoLyClHeoQ1U4sshKEecsiizBUMlm1emeqAyDsUJZFRvUPqHBGNKIhjdlYIxvYyIaw7NO29fCKVwLRG35KqNe+DWSZ1xSHQcDRq8GFc5wyfJThlEUgAiGLQOg80DEMhE5gAANBlKVsonqh2cXl4ha5ME08XyHaV6j/YnOoiBwpUlsKUnyitZtobWtFAYpPwKIWtd2WLG6xi93a1hAWcABDwzgvf+2rXGJcoxpJsJIwrtEFK1GdCtZoJw20pAgfwEAKSFCCD5SgBCm4wUn5YApBmQITTIGpTAOhXkP2IQ95wEMe2BSDKu1gB0ZQAZrMZxIyaEELVHCBFtjEFzKwjC14qgMY6tAJsowiZpUIzPUIUYcieEUJ1XPLJGkkYTIQQqh2EGodDFGKYzzQGdCYzTjFWaxqWIM/14iPfuraKxkXpD7AcrFC/rNWhjRWWT5+DZCDLGTFNqOxjh3GayJroGIMY1FOThSUf6FZzHzmFlYujSygJdrSbi5b/xEJIj4nt7latIJbuc3ybm9Ri0lYYAL6woAZJ0oBd2nABCtZXRc1MjsTVCC7FShBBK6k3BTwmSV6jkliVAADErDgD4JwAydqgQtTAPIR6D3EIAah3kDwIWN8cG8ezEIFI+zgBTGgAiJGUQdCiHUkh3mCEjYJiFEAAktiTYFY7OsKYgRmFHRQgVcKU6X+jqlnRQhlJSTcl02yutWBWQQsgjGgZjxQNmu9NoCyPY0V47iF3va2i1e8Y8QmdllCPje6k6wMZUR23ez2MTOKjFh3G0jJxbh3k58M5d1SmcpWrgXAAb6tV2wLFgUfrZe7bArTdlkVr6itwW/LGVscggMSqP8AhjLggRTMmQR+5tdNrvvQLj7XA3RwgZ0VrQEl7HklKfBiTcKSAjKExQMsaN4ZIBEuVFTaeU/B9Kb5wIf1WuXTeWBMYxrDmDpQgS9m+TBetAQILdghFFQwQSVscbPDGMEOijSfEVyAJ3h5yQjzC98TtLAlSk5SrI4MjFBZbQhX6KIYynBgkdW6Y7Wmte9phQbgH9Vjc6OzhpdFEOIXNQwmM/7e91ayvesdWWO0m92VV8a0kRWgaDhjQOtGUGQdz2Qn7+IXu9XM6T8DcCurWc2yEC23RmtwbnXLWxBqBSqwdfuHd8u2rpCQKWyx5ileAALuqoAMrot8KniARF78QOr/NqrcfNVZCc1nSbyer7qPQJ8EL4quckngASEEEgiHEIUreL48iv1c05vedNGFHjSyjORkVuoKT0e2yblotQ5kUAEhIEIMZJdRxUAJVFjMjMlY2AlhxAyFFYEWYAmZ2AwdfBiaSFVg1AEjuAIuCAMyLAMIOoO7sRuQjZ6UYYaV0QLrrWC/aUZmQJmT4ZvoQV7U0GDUjOC6XR7mGVmRNQNDGMPddV4z0Nu96ZuUTVlnqSCDNEiWOYiDjJZoydNo3d7vSYgqwMKDZMvtTYgrpIJFmIIr+IEFJNQFcBFKfEBjmAAFyEAMkJy/QF8XfQCh8dkHeAAFYIhEqc5GORdbRMDL/1UAdXmcGmlcG2SCIwABHmRCEgFSID2FIhgJ0L1fIMQfHyBCIbRPy5DaqJFJy1ABYYwMV0QJlSxVCqRADBTBKSKGFgyGKsnAT9kMvBSGSYCPBZ5J28kaIBRCIdRBJfAC0mRG6QUDZ6XGO8mTMYJWbq0g69WClZ1elP2CZTDZ4jFekClZukHeuk2bNg6I4A2IgTRKMSxKlGmWgnBWCpaGCsaTaWjZlr2CMUILhGhhFJaGbgXDbuGCLThCHshBDaDA6FAABThABDgABGjAhZCACfxaBqRABZSL87GORJXA7ExAHSIkBZSAc/kLSH3AYtSEucyOBkSXQXpAHHTCJGzBFv8sgieIAiMugiIEwiM+RaZJoiF1QiV4IhXsgAp0HdMNRiXEwBNMWP75lyO5AM140k4i1WB8RVu8EgxACc1B4FDV34OZT2BIWPrQAZsUQrjgAjOyni6A1jq+I1mSxixsy1cqo5VR2S70QpRRluEhXqOkG5BNXropizJIAzdUQ+ElCGZJ2RH2AmaYoxKKpVkWYywsDi0sTi8gGTdGQzVcQwtRE2BxAzUkwxY0wAMsgAM4AEBKgEBGgGgqQQtgiFmkgMipzvNhJK59kRqZgPiZgAe4ABmAhMeJXApogRep0Rrd2Qe0wB90wiXIAQ3gwSN4wiVMAiMsgiMcQkxWjCQSnVX/jMSp6VQMhFXLZJ3/+V/1WJgSVAIx/GRi9AyZeIlhqEAKlCdbyAmIUB0ZhIx7TpIt1trbBcYm9QUigALAzUISLgiD5NAqtBMtBOgSiqVp3IJpqCDrcRZnkSM5KgowBENlySXiHQiSAVmFEh46UQM4XAPl1dAwtAZl+YKDlqOAKiYttMYwKJa1RSY3/FVvxGiMioNugAO4UYMubAIfiMADdCZnCo9AOgBnEtoHUBFDXgjJlaLHSWRGmsBGUYn3YQBhaMDMacHLYRcJwIALqBH0/WEMMEInZIIf0MAZ+MElWMIk8MkjOOdzQuf7ZYzZ1Yma+FqAldKX5EWVhExiIML1/1hJmcBA9cDLfAVYJ2jBWhDGJFHB+cCAEiACX3CSzWAlqzUbfXZCIezBJ9ACXBpDMwCZa/yYawSZLzgOPB2mOqJjCi4mY2rWZUWokzEK4sElXBrehFaohf5CZVFDCz3DMdDqDbFGqCoLpESmNsDoOmAQsvJGMxGEjH2DX3WoNDjDL9wCKngCG3BAQDpABZhABggkF5XLxomfh3QIBchICrwhl2JADNyICfyMh2BXKeKaESgMbFKXC7DEy0HfU11CmC5CD/AAHCwCmjLCcj4iJEbnJAqd0C3SE7hA9YQVLgXlWPifDLhAEeDS/xgBn7qFVh6bHaziWkxSXkRJ/UBJ2v/xxSQBQijYgaI6UvuEFSF0ApYQQiH8wR8kwiDMQrxBUI8lC7z9LDMkjjupKoOuqoMGZi6QIzBE2aJUVqu2aqxeli9YaGU1wzFADbv54KPQxjUU6zXxRrLKKI3iVTfFh6QIi6/kh3n8VWVapjMEg8OVgif8AQpc0QLYIQUQGoZoBEN9gArcEXZ5AJW6QOqkUURlUQY82ARcCEOWQBEwpEa1zgSsTglQwUSdyHWGqSdkAh/0QBocAsEywvI8wiPEJMJKIldQpxZUCV30KRV0hU/BwE4aKk6xD4dVoKHSrgQaKtAoQY5kpyto5ZlE1VtI2M/YwSgkQyckQyjUAVeawib/TK2wPgORAe2P/dgwSNni+FuDImHSkmPStiqwPu2Iju8Nber0btuKOcMskEKCrEIsNMNuyOh1gMc2wAd8mK2kSAo41cb+7i+Moa2wDASwfJuNUkM0KMMvtMIQSYIhYEGQXoBoklrtZMBDcetzKddGoNFM0EsMeACa3ASfzc4TRN/2ZYCODJff+ksLMIIncAIMXwIf7IEiSILoji7BQqKbImwqVcIoYM/rNkbYHZuXeMnOfMmZNNIP4997IlWH5YURUBjT0cUTeE+ARdUoaF3AIIKErZorjEIXdoIrmMIk8EEksAa8Xaj4iuivNsu+BePp7RaUHa3UjujhVRaQ+Zjg/7HVW6FHOMjosfIGNzSDZnUqkkkDOGjDW7mVbWzD//IvOO0vOPVH/1Zy//IHXKGtjYZbNSCw1dpjLXhh7XmCQoWmaDKUB7RLGGWXBuDL7NgESIIUnPWPuHbIRt0RtxYuIE5UBmiECriRTVzXDTwGKPwRckoCJgzs6NqwDqeX+22aYYxCKAClYCAxIKQdlIxFy2ySosoAX+CMUJGBWASM7w4GYdAFFedFYpBBJVCDLdABWNHnJO1iHcyBKySDK1wqH8zC+d7QgjDoLHgWg5aogz6ZZmXWpr4Gi7JVbaxNboAtsmIQb5QDB6nHQChEi7YQfHTD/0byI1uyf1jyiq0YOf8FyAyZWw31AoJGy0p7jimwAsCFAgtQwEAiwAKIpogoFEj5S3MNogYMRZ2lTgZQJCFs6b54XwbI7uzIAORqqSlmUdgVNfT9QSbI1gvDsCZogjJLAiTYMCM0c/u9H++2DCdqCZjIBVeMJ4gQwiiI1fWoXdvZSQSm3RM4EsMG5VjPD1vvos0c0FtE1QH9ASK4QiXEwR/wwSrckDEozqoi6Ao6y2KmxvdelkLnnTS4KIzOw7FaDahgyqiUinRsxzAlE3hYh0BcU4ciBH0I1v3qLzhlAyWD03/o2GElFjoxdg7Fkw9hC+RExOYoUSqE8g1gaxlhAGeK5kIOpPdFVAZ80eT/0gtEDfUENCzK2cTMcVH06cjsxBobpsCFmADN2cUkgIIoeIInFDMnaEIyL8UkcLVXg7VMut8gzAUgaAn+hdWd1IkSVEk8S7PIZvNckNVISKX5iBWZHJuGJRtXgNUBaeWD2UxYaWUF0oEgkEKKTu1is4azKOY6+cKKxgYfF+syQTRnh21voE11oMqpmAogx6h0rAMypfjZYAcKdUM4dAPdCA4nHwtiLcuImugSksYxxpMxrgJpYcvm/JNpLZxFuAIWcIC5RIC5QAAEhKafDcVQCMVKiAhEyUi9QFQWoRwbpdKgaRdM8MsdtYAJePfG0UwlTIIoTAQozDlWX0JytndX2b/3z4F1pi0S9lhJYrRanWgVV4TSXEgzInRCmdCBo0pJrUVJJt0PpMsF9oQCItiChEXVg/Mirf01LnaYIJxxazDLMOTC46wCZ30qM1zDsXY2PViNBplNrNTK2oRHaJtNdPTG/I44ILN4dVgHpXyDfsCVpIzTSZub1DL2PxeogcrTWcpT7RHcFHIZ5exTnHPCDTRflFP5BHRmBRDkdXn5dqkEiQxFF5kIl8OZdcNEBgwgSmAXTnjAC5jAucihumuECYBBJySREc35C2uCnS+Fe0sCM+95M2taQAAAIfkEAGQAAAAsAAAAAEABAAGH6sCh37OV3K6O1qyQ2KmK1aiK0qeJzaaL0qJ/zaGDyaGEyJ1/w56Dwpp+wZh7xJVxwJR0v5RzvpNyvJR4vJJvvI9uuZR4uZFzuJBwuY5vuY5qtZF2sZF5tY1usI50u4plt4tptopntYpqtYlltIdls4tts4lmsodlsoZisItwr4htsIhnsIZksIVjr4Nir4NfrIlvq4ZtrIdpq4Vnq4Roq4NiqIZrqYRppYZup4NoqoFnqIFlq4Fgp4JopoFlpIFnrYBcsHtQqn9gqX9oqYBkqX1aqIBnqH5oqH5mqH9jqHxZp39mp31np31lp39ip31kp3tYpn5lpn9hpn1jpnxmpnxkpnxjpnpXpYBmpH9kpX1kpHxkpH5gpHxhpXtlpHtlpXtjpXthpHphpHhWo35lon5jon1iontjon5gonxgo3tfonpgonlbn31joHthn3xen3lgn3lcnXpgnXhdmXpknXddm3Zdm3Rcn3ZWoHVSnHJVnnJPmHVbmHNamHNXlnJYknNdm29OmG5TlW5WlW1RkW5Xkm5TkGxVkW1RkGtQk2lOj2lQjWlRjWlNkWVHjGVLi2dOhmhUimVLhmRMiWJMiGJHhmJIgWJLh2BGg19Gg11FhVw+gF1Ef1tBfVxDeFxJgFc6e1c+eFc/d1M6dFQ+b1RBclA5bFA8cU02bE03b0szcEYpaEs4aEk0Z0YxZkMrYko4YUY0Y0QwXkQyYUMuXEIwYEArXUAtWUAuXD0qXTwjWD0qWDomVTspVTklUTsrWTYeVDYhUjYiUDYjUDMfTTUkTDEeRzMkRi8gTCwXRywZQisbPSocQiUTOSUVPSEPPRoHMSETLh0PLhsNKBsOLBgJJxcKJBYLIBYLJhIFIhIGHxMHHg4DGxEGGw0DFw4EEQ0EGwgAFAcBEAoDEAMADQoCDQkCDQcBDQIACgoBCQkBCwgACAgACQYBCQMACQEABggABQYABQUABgQABAMAAgQABgEAAwEAAQIAAAEABgAABAAAAwAAAgABAQAAAAAACP8AxxSBcqUGiwQJePAo0oIHFCh5rozJ06LFnjxFakCpocQRHjN4lBRhYYLEiRcoTmhYCWLEiBAaXoYwYQLFCw01UOkipqxZuGzPhPEStgtXsDdqihThUaOGEDZjlAgRKeQKFKVLXQAZ6aIFixo8hDBtSrbpixcuXKBVq/BEC5MnXCjkkbZiCxcs1KJwaYKF3xMn9n4YjKLw1jF4UL2yRWzZsmG7duWaXBRXLVyTM2emNdSX52TBbC1eBcoRmxMPFiBAsGDBAxeCRiXLFi4ct2zXrFGjNi0aMmTFfsEqVQoWtW6wIkWCJY6cuG/dokffRr26devYsl/bzn279u7XqF3/w3ZNOjdnn+jQIQNjAwMPDRpw8JCDzx9LnnzRrv2zmv9p0/gHhRJhKSVBASAoROBSUOwBhRA1sLHQV3sEwoNHd3AhhAsmVDQCCXuBAAKIhe0FkwYhsPACEBpg0AgwwRjTDDfVQCOML7z4cgsxiMzAwws8sLBCDUVI5ZRYShCYllwKuVBDCyd8xZRfVPLAxh5FAKGllmhBlAdGLYxQF5V2kdTXXiNEeQJNI4DwQWEj7EUCEErkQcgorwQzzDPKQKZZZbhgplkuvBDKyy45BpMMMbm8MsodFxRAgACUUhpAAAIQYIADZ3xSi2PL/HbMMcUcE2gtsKQKyyzHwAIIIJH8/4IOOd9AJ1032F23TXa8kucdeMCGNx423njTTbHTuIrDDzF4AIMHHlhggQcpwMEIJJyw8kxt4vwXTYDVTPMUD1JwoQYLBiTQQlRFnCDEGIHoYZBBUxU5xh56EKIGGzXQVBFMbYoYp01FvDDCShrUdDAFXMDIkzHIOCNMML4IU0swoaygFpQrrBBWU3NlRZNcaUXJQlxPsSGFWGAJocYYW3JZkQtjwGwSCSSYaYLJJwdm0140idDSwRqguRcKECniCCqMCfPMY5LxInVkgkaW2S6+5BJMoYXakgwwr/jRwAGYEjBppWgLMMABDcAAyCesxF1LLKwMR9zdn5QSiXqRAP/CDDno2IrrNoP3yqs22owXLLDWMD7escVGrs0xkeCQQw5zZHFDDBs0MO0Xf1CiiSe80BauNAFK8y0berCBhxo8cAGBABWIJYRYbLiee+5OCVkEHmw4osYMJ8wUAggnaiBiCGiidPzxNcGEQQmqxKiML8vxQvGhwbyyQ5YoCGkCWPPWUPLJebngFmDsu3D7WGT51VWJgKEAxBhQnADCXRWZabJbKFnRC0IQghaYYAQtQEmcUGIi+ylBEaPYSTKa8RipWfBQkomMBhF1o67Zwha6AEYoOmAAAwxAAAVIodnQVrYCGOAADJiABX4ACVF84oafuMQllMPDyqmHDpHAhjj/AiedXVXHcNnZRuIWlxtrOLFxi9tG5Ir1jWJxIxqnoIMN/uCHQfggBjGwQAM2oII6JEITnCCFMpyROtRNQxpq4AIXgCcFPNQgXUJQCh4QszsrSYFIReqfHvCwAgKaQAMVAEEFFqk8ErQAJiFwCQsMWBMURIACF7AEMYzRk2IMgxjBEIYwerEjP2TpBSwgYEUA8xcThKB+XVkf+wCzAiF1bAUiWEFcWlCYE5DgQ4CBEgGR58iUAAZnJEiLSwoTyYqgIIFo0sAHRvCBomnFEaAABjFocYtdDOOCU4sMBjdIDKHkghYfdAUhFnCABAzAAJJyITxVeMJKvRMhBVBACvow/4kd9rBvrwIEHXBAh7eRgxznGBx2kPgdJj7RiU18KHekSMVvPEcc3riNMSJRCEQQQhBriEEKONCACWwgCYJ4BCYs8QljvFE80qAGG+YYCDzoIV6zO0ERxBIVIQDPXEHSSAvIp4FACA15CFskBSoQk+IR0yYtAAGKRrAACFygD9rk5DCEQQxieEZHybCEU4BANJqYlSaGDIEju6K+KMXyK7e8pVuXdAKXkCCSdyUBMY+JzF/ibJkoAJEj3/KSaQ7mJSBAgfscMQpgqOIQuTDGjXB0QUSNU4Oi5MUHdWGKHBzAAASQVKYEsBp4hrYAJ7xUpsxmAEwNgAE/KMQ/A/oqHP8QFBCzIMc73NENbFzHtwxlYkQf+kRqQHQ7kKvVN5zTHP5UgxaMMEQj/gCHZlmAAQ6YQAeccIdKMCISrHBGNRpnDfzlIRBKYINIToBHK0WlBoGoaYTkUjATuIACFMiDEBDGX4QhbyZ15cuJQGCCBUhgAjZ4RTJ6Uk5fUOxGuUiGKnbwo7IS0JCufMmHTNJWVp5ABLmM6/+WBCWZuOWRfv2QTODiV5ucpZd6CaxNQvCBCyu2CJVQBdgikQpcDMMzWwunBSPTiyL3AkcfHEUPAjCAFVoqACksYQoHMIBLWdnKAAAAkw/AgVcVgrYCHaht6XCM5rxDob3aFRK7Q9w2t1n/PNuhaK2eg45ZOeeg4ghHMz7Bhz4Mog49kBYDGFBSFSChDogoxCV8UY1sWAN48ELMeh1QgAzcbiJ4CIRpuKCHsCzEBRHQgARMsAcMaGCpFaAAIl0SGJoU70OuvLAJGnBgFYyCGAuu2MQo1otdEAMYbuDBS04da1mr1ZGv9mXPTgbiWjYFl259AZT+Gkn9iaitb3neYJ+pFgYa0y5neXGcfvlMIWziFcCYIJ8mi6MNForIRv7xZFyRhbWhsFJWLqFpCUDlAGT53wDP8toaQIcvB/SHOOAAQaPRHHQMrre8oo7hwONmJ/pnvMSdKEZrBY5vvOMddWbuQcmRjVkcgg9z/5hDtARN6AmkAAmD+O4plJENdikBCq7DEhQS4AAuOKJ1jtiDItTgiDzcawyHXCp+98ADERzSvwnsCklmIpOzngADuZSCJSbYDFHu2jO9wLUhViDVBziAZ3zlZWDsUhEOf1gEJ6gllJ5EX/Xdr11xiQoASwyXXqaJRG1yiUvScha8lqgFWsoDKBT8jGdAoxnG8MUwhmHkXuToq2DvhTKMsahDHIDKCAl96PVtWiqb/vQnNP0BYGgBQByihzu0LQ4ioY1wiOPMCr1OsBDH+97zPhvAd2I2es8Nb9heHMgfB0a5UXxvKLfj3sjGMCLxAzeUIQs26BwDqLyBFHQhEZaYhP8oZLHTPCpFd3noQAJYYMcaCD2+Y+CBfk2gVERSoAh7QBEBlZemuqzplceDPGeFdSswA4YADM2gDMKwVcHQgDciDM0QCjMwAhUgAQ8wSfzTM7ykWCVzM0PFAiAmAn4BYsHEA0DAVmhREVAQCGMAIgPyFsjkS21CQIGhYTcTYL+kQCQQbi8QCIqRbs3AJ8YweT+GeUboC0fWE8ngCRZwAKiVAAsgelIoZSk0Zah3ei4EQxtwB5Hwejwke6XADbZHDrpiRL7SHby3Hb/Xe8FncQFiDdpQfMhXLMhnK8zHfM7XcRgFFKXQBm0gBz/wAxxAaDDkckvQB4+gCZoABRPxJV//UiGBwAYLcAESwgXnNQZX4BZFEAL4tUhKBQJGlTD+FSdqRxOpJIB+UUtY1xRv8ArNsCgM6ICT1wy2sAMqIQEQUBhqIXWTlBIsRgIkCCUh+GEZ8GFrsjN3gYNuRwJKsAdK4BICg1giMiKBJXhmZUgjMiIm0T+BgCcIOEHJYAyV12tWkwsbFBm49go5wAAK4ISt0RpSiBD6VoWSwm+mhylqU0IJoACe8wWHcAiyVTm2hQvZwA3NsVBpOFzGJXzA52gNGXz/ASDSMF7Bd4fGFw62sg3cEIdyOA69hTjVgD10IAdtQAYxMAEMsAFixAExsAaDgAlagRVYERVqEAEKsAJi//EgRcAkooZqnliBwANiIqJX28Y+lBQlZQFiNYAGaBAKyQCLXSWLyqAMyQAHLCBquchtvNhLv7RhIGYCIeh0JBEXYOlq/CMwICCDcWFtTgWN06hWgTVM/0VgJqBIFRBJr+QXgQAKqqALTxmOXkWOGjQok3ELtwAakBAf7ZQA8fGOC6AAChCFowdPCLBvqJcp+raPDGABMWAHASV7yGANBkkO1yBxbNZExkUNqhMNrCkNquMMzsCarAmbzsAMtQmb0aA6rrmbcGgs5IE4d4iRteJbwFcNrCBQcuAGJgkDMMABFtB9RtAH3UZ40kYXTLEAEQAyaJFHiyQBqbZUEiABp//GAorQMfrjSm6REn+BPglEPjXQASJQA1yABomAawsYlaE0DI/RDIlQAhoQAVnZS+yzQG31S4ABlhmQASHIfnswBnjhLl3RAiJgEscDGMvUP65EE1KlfzsTa8oDlvonVUylAY5kEoGwCaCwCiG0KDkyToQ5KMTgCifZAAyAEA7gAPHRAI4Jj6O3Gip0NviIQvI0AJCZkjlQUGPmDKJpe2q4HRVnDb3xmrQ5pbTJDLZJQY4xpdGAm7nZaLtyDdrQkLVnLBLXOHm2USNpBnBgkiIlLSmQArzkVwd6AmMhAQmAEwXjApv4AN4pARHwABQAoEslAqYBFn3xFtWoJsioFu7/iQEmMCRcMAde01WUmp/NUAzPMAolkAG4WIMjcFbM4wLVyGqAIQLwCZZOpxA1IIINASWrFDCRtEBRNUz7txKGdIzQY0vJozwt8UshkAeO4Ago2pfAAAwtKhmTAU4XBAyMsAEbgKMKkAATcKM4qqML0Jg8ihCVWY9pkylUZkJrwwAHoAAb8Cyz9y3a4A3iAEWouZBP9EawyQygEirIADH2agwQU68QowzLwK+/8Ru2CZvjdQ3BB6bXwA2luQ2KA3LkUA1ZhHJ10Ac9kAKc4wAe0JV25S9A8Gw8N0khoD6pdqMQ8AB86qfeiQFSoAe6pDzV9kt9QUtDdRZjcQEakHVZ/yAKi0KpXbWAztATuqADHRABEeCpfHGMbcJ/wGgSJAiCO8NKJwMlsyQCK8FI02gSLDGNK5GhuAoCIlhLh5RqiSSiUiV/euAIKkWsl6esF9SAYEMGzoqjUTgB00qtOEqt2CqZCTBPZ2MpazOurmUAkMl6MKAt0pCu5OCuuwEgF3c6Wyqvv2EMnoR5RbiA97lJxFAMmIu5v1AMy4CbE/lE27GRFkk46AByeaYMkWAHcxAHwCMDb9oAMgFrpjhUCuEACYAB/+UAS3WjJFuy4VmzhLoC11hMUVImciGzTREBEkABKyAFMoAIOhu9zrAMnFcHJTABoyZ4rJZKrrQ8vwR3b/83gh3APiHIIcwGAhnAf1K1PDAhgAG4EsVjPCKyEiKQSE+Xat6JSKkmF1IQCIqgCJXQCZzgCaIgCp7gCaFQwAeMwAU8CqMACSpALdMarXJbwdQ6tzd6t/KoQpViABcQBXfwB06wAFsWuAdgAbbwDNFQkOKwG7vhmooLIACypbAZKkNYhJjndT82eZ4xDJjrGZlbDDKCm9PArsBpGwbpDR/3DuRQG9NwCijHunVwA9QyMKQ4LwTiFCKwKS4goosEARTAp4DaiUyFATWDIhZqV+zjF+CmEFEFYjNQAz7gBrrASV3FefiagBFmCNMaASwgEzTIbK6kAXQKgg8aYs2Wih3/Y0saOr87Y6DTFpYdMMkhVgO3BJ8gBowglgEVkKAJmmoKqgZ4IAiN0AiJQAh+4AeGgAiGsMqJwMqwjAiJ0AiIYAYy0AEYcAEVbMEZ3AC9fLeQmbeiNSkFcAF6UAkp+gpqkADjeq3sdACM8Axi6BwWZ3G7YQ0X1xu0GQ0JGCr36XWbhK9TOc7IMK/NQEHjzEYAYg21kVG2xy3IF8/I5xx6JgqF8Ad/MAc+0AFwMgIs4MYEwgV/tAINkAB1CbYQkNBizKeoZmouEAipBCIBmCbPREk7kxdQIiK5NAM7kAWmsCjGEM55vAzCsITTCgHu+6FR4nTnuWwiqMhx1WzCSxO4/6Q8LMu+K+HJk+zJuLTIpurJ6PvJCXoByru8nUwEo4wIiOAHgoDKTC0IUA3VhIDKgzDVSz08JVACHXABuszVu3yjGFyt1hrM+6Y2C0ADj7AJlaACDFAAn5UuC+DWDBAJxsB84tBGARLDEknDtGnDkjV5lLtJ4zyV8zqv4wwxtok6cFgb3CBF7XyR/IF8tjcNrEAHbfADZVAG60m7PCASV9AuLJABBgABp+anDzCyfFoBD3BJTKVqFIAlaCxrs2R1J1OXXFuAUpADiwAa+NrbMkK9vmALGzCt7jsTXkESeZEXc9EvQkISpgZiCAPdzSYCpha2LKG//rWhdykiYYEwGP+Au1LbIh3QIuGJX5i0AnGgB1CNB6yLB+49SO5tU4OUynfgB3eQBjkgAzKg1d89yVyty7vMy75srRtsjwWQABAwAZ83AC6EWgc+rlwGCPqRDd8Cw2+EOm4kpXxNr5DrSUQ4eZlbzgFrpdNLKpuLuREjm0UMpr91HcciDsxXDAKJAybzAmaxFUrBFCbQAa0RqBaI2iRbgeJZxhQgAS9wBShSbE3rtMsGGMfTMTOgBjlAx5br209jDDuCBdgLYFSC3DXwAnXpFiDwFWYlJPTrdEHjdC2CMNeIPAczory6of5FExTw3S3idLh8Ad+dyz7O1RESR7mjBnEw6IQeB2xg6If/Hgdz8AZvMOhZsAM6MAMrkNVZPcm53NUAbsHTSuB5G1pUNmXgyuBVaEIw1DZ0UDqxmZu7eeFvNJuxOaXLcAzAERybi6//Ws6/Ma+OO+ukUgwpLpviAbre0SvRYXzMhx4DtSYAFG5K0W1KxXMK/ae9W+TmjUhgXAFBgjzI42wg0xRsfBfq86hOwQZJkAOokAwLKMT4+gwJeAvGwAgTgAF5wYhQQBd6ehUGdBcjg1YnI4BN271gWUsr0AEYlib6gyJxzhIzsTOdqNEZUAIiMNRcfenYewEd4AJSMRVcUAQzlTty5PFqsC+HrgZocAc/xQVEMAOSfkuVngHf/d9eLbcZ/8yjJcRvU4ZaTWY2ZlMAW/YeNkAGyfAMsNl4jjcNz4DhfJ2bG/64QYzr/2oMsl7OjlGvs67upZLYrDkNw8d7UJQd0WFRByWG1YALgMDS8rMiWWJAorZIUQgBVTXtDI1fyyuoEWACPJAwBPYVZOFpc9H3QyUEUqAGuS0J6O7Dvc3uynBkprABFwAYnb2T3YYWx5gX64NKsXaNFwYCHeAxQsACHfCWsbq+V2urgKE8qKZq1D3UGODyep7LnQyf69MCG+L4UiAFClH7EFIDRJAETkADOVAHfsDegp8ENaDyKt8xWr3TL5/pc0vgJmSF9dStAnApA3cDG3AIysDuRA8Njf+H4Vr66rb5NP06lfWKuXfcE+fM7ufcJ54k2FOJuZ1LxNbwkMAHnMVSZ3nG2LuQllQiF0CwIgBBokIEChQgQEiwwAGEhQ8KSihYMMJBghh4mFixgkUNjhtrCBHCAyQPkjw4ihTChUgcXcKGFTNmLFmzZ8qG3bI14wILEyZasGDxgkeLnydOmBDRE2kNFiFCGDXhFITTEB0yrujQgYULDSC8gtBQoasGshnMihAhIYMIFhkwkIUoAUJciBQgitUgIoNavRIkYDCLAXAHtxiydsBQQo0gP3jiqOHiZEcSIjVmZCyROWvgCxMuWJjgwEGDBQsSFBgwIMBq1qsFvCYAAED/gAEHGoxO9YzmM968o0VzFjz4tODSnPVepmwZzWbJk8VUFj16M2UxjVWHHn1Yr17DjC0Dv+y4s2bNw4OvFnyZsV2sIpkwGrQIEBf1K0ioUOGBhAgLDDA8aK4KHoJoIgoiGNAjjmowiakFGeSIqAYXlKIGGVwh5iWZkuGtOlmAmWMt+E4IAYQRX3ABKrCAMvErqsDqyiurMkLLBLCk8oossDLIzy65JLgggw4uICwssBAcEL8BIUCSsLVEKCiDC6a8QDDAqKwysTgIYcwxNtSQgovIiJjhssxKOExKKkETjTQDTnutNTlfk221AQxQ4AA7ZtrtGeGcYYaZ8AQ9T5li/zIcxhfuuLvlllhiYeUUSU8pRdJSSvkE0082vSQSTz8FNdRINv1kllpgYaWUQiIhRakXihiKKBLCCutA/gxwwC+7eoyooPzGMsEkHpQogkGTgPKoPhd4KAJWBzkqwZLnkCmvmWSeM+YWYEYp4YKkkgKBKGRfYKEFG3ta4dyoYgyhpxLREiEjoE7wKgQSSACrArTccmtKxDoowTA0WcAKMIz0ooBH/ERcIV6shEQrq8xWCFjIjGZQwQ8uHXtMCiciswyzMwmbcoIJQAtttNJKS8AAAgRwzbXXZiagAJsTcsACS0whhZVYZpml0kuH1pRUozclutJJT4GlaViAxgWXX/+mLqaYY65GJlBnfpOGGmuuuYYbscPxRpxwxEGHHHLCKaaUWmoJwQUTXgCihbpBGKFEEPLDy4EFNLALyV4pyA8sE03gqIgrYCWJKWRrULYkxzuaYRBdMtwQGGB8EeYWXVQhogMROrARBBeCMhcpFo4Sgayu4FPKK9hDcDjeco0KwXUdhUyzsw48w8BkzxBLeUrDTMZSdBEEM4tKDKqUQDS/SSOtsy0J8UMPx9RQ40spkrBMhqs0e55Kk9tsgLSWUYMZZplnTm2AAt5UoIE1RJEll2GQcQZr8Y7zU3CiIY1pTKMaB6xGNhSYDWsscIHa0IbYJMgNb3iDghWs4Nkq+I3/b4jDgx8EoQfRkTZnuA0XpQgBC0gChCK04AQVyNGAYEgWCiRgP7oakK/EUoEReOUqH3EWD1LEArQ4pSflcoELTVAugolgBp5IRSpY8YpXqAIVpjiFKEzxikFkJgNYIdzceCAUoMCnYcr71glGJzoTkCApStEIiWzkuvvMpWQlCw0DbsOAA/TRj32Mn2rspBrVzMx9rJFNIhUpmwEoIA6KUAT2/HCHOsTBkmzgwvcsUybxoclKzzvfaFSmAAOwT5CtgV9q5oenDXSiGdkIRzjI0TVrNHCBtXwgBHW5Swhuw5cRnKAvfdkNYnYDgxjkYDK/AQ5wdLCDIURHNUoBi/Z8/4InPNhKEXIUFr7BEEYOSAAFapVDvBjpdUpx3O1OYC4RtGuJLRjivIyiRhkY4hKc8EQoQoEJTGTiEpfwhC46kYISrKVh+WkBisxlIhZoIE1mSZiP/MKQhUSgLhPxm8sOuZpFdtSjH53NIAuQgJYZYGUJaIACFlC/0uTJpAyIwyMeEUnG9OEOjblkJp3ghCSUiWJo8mRnUtYm05QyNRt9X2pqhpoDMIAOuaiG2AZIwANmgxvZuAYvtaqNbXBDmF8dZje+4Y1vFFOsY62gOJS5TA8604PeiCU5uAEpX7jCE5cYAb22eZ9eycWidnEAAvbzgG7qznUl0oAJ8uK6vkLEsP+E45tdDDKBHgziEJCAhCQQYQhDFMKzokiEClZApnilLiqI4wnBMhIVo8SImxOBgGTz0rqpVMBvJF1ZbkmzgPT1VjRDFZ4FNnCyk33GMwUVkmYm9sUMANVvplEpA7hQiUo8IhGb/YMftDvJOcThDWhIAxp8kIMZyEAFZwqYcR1wvpSuj30zY00q5ceaA1ggEsmoBm+cIQ0EZqNr1PAa2ASMDQJjQ8AHFvDXrvFVbGzDrMQ85lqdidZYhuMXpxgGLTzhCUm8CQEuI0CIETDiD9sMAQkpjUNkyE3DiiV3ecEAzQow4gUchAJTAYs4I5IkCKS0A4P4gyEa0QjtCsIQjGD/hCpc8QiKyYsHfIVhQymAAaQIJrEgGNxE8HOgv/oKsr/i5n38omXnlQ8xnYnABNJsPsNsBnkTSMyUKOYZOoOTfrx1wA74Wd1GLGKzhCDEILRbh+56Fw1Z2AENzIuZM4MGZX5TQElRM4A4xfc18asTbQ4QA1EQ4xkHNGA2tFHLayg4qwg+sDZOrVVhPlhsx4Q1BslWtrNxYxmn8AUvRCGKTCDiAUwqzXN/LT2FMOk+hD2QirtZTt3l+K8WHRC0cUyWaNOlxwmYgB8GgYhFEFkPgjAyI1CRDFXEoQQrGIw4c2SCgtCwLhIJUIDECTgfSQSyEo0tbOUtPYsCiKJMAhIG/xYSW7HoxV9m6cBc0BKkvTSgpG/CcwkesWdJPGIR3b6uJCfph0p+Nws+oMEMavDTIVkAjyojaSlfZsj2wS+RARBAahSQA08YAxoJFNsDJ7jzV/Pc5xi8oAThCtcKV9iDFYarNGDxC2GwQhSt+MMfQoACCBRbA/qeS7zz7RD+xHZwAwJcOXP3q2XzTXf19gt+eAsBNghis94WBCEScQhPJEMXlcjBkPZCAb2xBQNTlu1A8JP2rksAcPSecgUIvqSDPGAiv/639IitkOeurPIThaEIImBRs0AgAxC4gFwcboBSkj7YE+jAIjChCUxYQhKQkOmQMy5oQXM3DmhwwvfKe//eIQ2pM0QtagFWznJD1qnGZllAU2PwCWMkMBwKlGDRpR/LCU7f+te3vgQdiAxcGKMVpHCFKdrAh4GIxvKiCZBoHqCQB7Tf/e2HAOT9PRclyVAu8R4zkwhXEBtHzwERgDw2aARJsIRMgKRGSARGmIRPuBZViIENoID1W4B1igAM6LrNkwt1W5K/cqx2i5F6YSwdkiFbyQ/+iADmooAOyDH9s4tfMwuzAAESOAHCUIvoMQABGKmUO4CWwa31wgAZ8AOZegRJGEBCQEBEwC4/4IM+4INKioM0+J4kyAHzQpPOYJNRUilSYp+Y4cIASIASwANH2ARVUAUkqI2mSoFDsIX/Z4Al7AuHnFsgBJoGaYiGAKKOmCiGROGFXbiFWXgUVgBESrmUT/inQryETzgFWaCFVjAFV2AEPjgEABGNE/u/9HMAx2s/AHQ/LSOQieimDKC2HikQgvg6g/Cr/Ng8/XgAB1AD6rKETkgEQegzRoCET8gFaLAFPpCBE5BAFyiCzAg9/Ni8eaO3tHuIeps3qgjFFUs7TTwI9AMShtg8rOu32NIVwhkdv7gABygA15gfklKASMOZ49qBIJQp6pIpSSDCRLguQxgEd9SuO3gMLggvH7gB8+o9oVIZ3lqpAzAASiO+mYGAEmCDTRgFTLCCBYgfAzgABdiAHvAEUogiQAzE/1IghaIxxH8SlVDxrI4shEM4BI/0SEDwrMuaBE4gBVWwBVd4BbtihENgAfSTwAX4tYlqv/0Tp3ICM3LSEarQm7NTkrcAgaTIHV+hNsJ5RhVQxwKsAy5gg0x4vUlohWdIBk5IgQtgiL9Btw4gCLiIgMS6ugKRxomYxr/aIYmwKLJMkseTvP87EEuUnvT5rdCYC7L8vAgAp9UgPfpRKdNQiAggEhlAgz+oBEmoBEuwBFd0vUfos+tqx9qrpEqqx3ssAd7Tx9uAtPUZAAIASEMyqZ0QgdMwANq4kz5SAAZQAAuIATuABNeThEmYBMySTUaQvbkLyUHAzT+wKTuQg97szf82+IEcEM4cuAEbiAEYgIEUSIENYM7m9AAYyIFBCAVbWIVF+INEAIUamIv327EcwknD0p1fqZeeOIoRyBsYcR30JIt10REYGZCB6wBL4ARNsIQuUITpUsdLIIVmwEUfwEu/qRI6u4ASpICk+Lu3sEAmwUATnLJaQRC7+LcLCBzYMr8GYBL0e67b8C09ksvNgwCuRCmFvBOSwi08uw3QswofiINEGAWopE9L6KfWqzhI6LPGTMLtksfvSrREOy9QEp5R2ksQMyThm7SlirnUIL0dDMf6uQAVoAEn0IEZiAEVOK/M6CSC8j0smRLhsoAu9dIvTZmhEqXQMJkO2AAdSIT/SviDO1gEYMiEGjAITYRQi+KPXqmVe/uyscgLpRABr2gdK5kyxTIswYAXtAgLO9qARuCETtCEKOgAQWg9fxIFXoCGZPgDNfMbKRFQifiL3kOTM5sygPE9wcCjH10vz/gMLTU5Iuk9xECTFKBS5ZSBG7iBHvABH5AMJyCCBSgA0xjREsXM0ADM5poBNKiDRVgFVZCETuiETNCETMiE1itMdZzRi9ssQ0CEQFPCOXADMwivHcCYbjGf0GiplFO5EBMAdEXX0YSNvSwpYKW/CdC60Eif3DopkvKjcOyjIDWqQAqkAzhDP2KACSgDOLAEaCCGTACYtySQwdmx7mQ2DXiL/xrh0yr7JCkBDMDgFzRqmLQAzA0YhEzghFCYOEwYwte8BFfQMDdAEyZBr0/ViBW4DBmYgR2QgR3wgST4mO5xAjQArzewpDjAgzWoAzuwgyXcrj7QLj3Qg43rAya8A5u6A0qqg0pagy7ggh3QAa3VgRuIARqYANNLgBENtrm8AIJYixlIgjjwg0VQhWQwhUzwhE6YT0141tZDTGmtuD7rtiM0BCWsgzuYA8iw2U8dEva611IiUtggPlWymQK4tKV6E9JDDTmx3MvF3CONnz9qSAbwXD1yAAawgOeUA/0EhmcIBk9IAQ9IGW0k1Skxiwp4ktFBi6vo2KsQuQdJgt0NE/+n9Jje5QLuYYPhZQM8MF484B488ANIYFROeITqOkxLmARPsIVg+JxOqARC0ANIiiQu0YNA0J6gvaQ4+JIv4YIu2AEsGC+vpdIYgNXkXN3m3IAuFZ4fxcze6i3daqnT9FxKS4i9LI1gZVUiYQsi4II68INGGIVmAAZS8ARRmFu6tVtoFdm7dU1qfT0E5CxD0M06eIMsmEIq9NHJe7iWixn4crkACCnMHSR/ZciGTIAlDcfPxd/fot8vlV8P0GEO4AAYwAE6AIRLkIVYSAVT4ARIQARBwANIYschawRHgOIoluIpdoSZcuIrboQDzGJFaITqYkzupSlwEwSm1YPgdYz/PmDWTlDHSujiSZDelcwEPvABFfgdIumMKVmvtsTfBtAjz+XjJf1c1JRhQPbcQTbkPEmAPwrSx02NRB5bkyqN/ig25EmMgtKIGnBKbWOEUAAGBjaFXdMnZp3PRRXlZ80ExKRgxCTCIfOz7Lq9LIBSGQiqOrstkkrXLsRckJKTX5VhGg7WLt0ADvAA5YSBGKhVLCCDNpADOrADQCBJz2IET5mEUbmESzkFVmgFQEwFUsiERsAeS1IDLcgCREs0GqARNJGS38pf3uJjDt3jPS5kzk1Sdy3N+lkEDH49JIOESWCEH7CAP/ZH0vPX+GGNU2JhjgKphFbojlLh2Rgp/2WZ/xNYiGAFHomR2Y+ZA22DBFuYiWAoYk9YVPo0TAJE5VOWzwuWTXZMBA7mgznwuCnsljDdR1KaXI2imYAMpMe1mb3cQSV1gCFYhE4YBVRQBVMwhVZwBVmwBV7ghVRoBVVwaleQalKg6qq2aqvGolOQIopsGkJkhEK4Ax0Q1wtoztcdV3plmdRoyF4u5EAuZET2o70MpDdxgBJQgDvxXD9ATFWGzb6OgQYAJMtd6MEm7ML2qH+8kzdJAAGA5IQwgVw5CFQFmIyg2TBhAzuIOkloBWDoaFoQBbqVYEyoBGg1ZWY16QLca2rV4OyaA5d2ghlILzpDaxKVtJVDV5YLsRDT6f/5WaUgbUgL+AJGGAWWlGpauIVciBpBvGZJYYVMSZrntuZrdhqnAQQ5mIM6WAMaODMtxZL6RR/SUGvPXanokuG4To3LfbnWGIA6SY0oMOVMmIRCvCsLOCXDrpP0Puj81u9BstzONQ2SGqnSwJUQGDxUzYyanYEckAI1sCQ/cEdGIAVd4JNkKOJdi+CQ5oRM6ASp5gRSrttThlbXg4R2/GbxkuXEGOHd+m/KXSrO7Mx0zW0iXaqdplwStQ0VuANLQIWWdAVTqQWjge7onpTpngWpmZpfuJqrGV3lPNzRIA0GsNe+5Md2Th8/fud2NuR8jeFDhnLe+twJYE4ymARRkPD/a7kWYrAFRrCBLsXyt+bcN4dzOOdfGs4Z4dqAFEDOHIiBHLCBNqADICbJQ4gE2OSES4jvT/CEVngFO0DkUkqI06gAE6gAwjCMFKDZHeACH0ADBldet8NW6g0GYiiPYKCFbSaFURCFUOgEfQoFUbAFYnCFNE7jDmfWZxXxIUOEQZDHLKABFYBt3xNT9Xm4c+VMGM/tY9dtGtdtiEuIBkiBPjAFUW+G/jmGrNmaaKCG/6KGA3MwY0orEDqHcA93L0XVKWlOiTkTKqVSGWB3W82CMsACLHj3ef84H4h3LPiBHhBOrzUvdVcB5QR4gFd34XpOZP4DSOAEoz4FoyaFS/gD/yzIgR+wgYm3gR9AZjc42j94R0TIrEkQ2QcWBVIwhahOalqwBVvIBV7whWAIBmEgBmK4juiYCWXgE2WolmpZjj4pD5u3llHwgPpxgH9EMQMAARQYSoBx0h2QAjTwrjdA4LjjYkRIhExoBVvwBekghl2QBVP/ZFQfBVOwhZ4P5VXfMFan21M2TMbM9ToQrwqhmMM1VdIQR0kTvs1E9rtP9poJUpLStAkABFl4BqMTh3fQB33Yh3lA/HmwB3t4h3dwh8eHfHewB8VP/Hlwh3aAgzKw1SXQAeLU9+K0AXZn9xiIAeO0AVo9fYpP/RsYTta3+DJwAznA7Hc0hARshI7fa/8NZ1ZWx6d8+norumqRB/tXOPnitwVdQH7NIQYzv5Zq6Y3n740+6Q1ogH6umYZngAbqf36uoUNp8H5uyC/sR9g5INPbUGwBDwEgMCMZoIElMAOgxYOM1hhC4OJHqP1JMIX8gfmYR/NWSAVUAAhSpkihMmXrGTRXoxaGGhWqocOHnThl6rSp0qNGhPzEiaMmyYwVHS5MIDlhgoMGC1YmaGnAQAECMmfSrEmgwICcAwoUeBngZ84DMCIVq0YOHbl3+vj5++c0n7+oUqf6y5fPKdZ/crba4WOna6FChyJBmmTJEidOnR5CROVWlatXrua+qmv3la28unLxtaXrL+DAf/3/Do6bF28uV61azV3sKm8uyLZy8aoc7DIxYsaMKevc7PNnZ6KdPSv9TJrpaNKiTWvtulq1abBNw85mO5u23N28absNTAkEEBRWUjigYOUCBCOutOAxg0iUNXPw+BHkZ5AhRI0ePZKUfRIpV7R2CTNWbDOxYIlNmUrVylSrZNV0sUe1cJQoU/clrg3VCVMljSAyiCB6xMFFDSuU0EEHGFxgUkrItZQATDzFZFNNOmmYEwA/BaDTAQ3QcYoz4aDzjlL8MOWPilFZ9SKMMeYTl1xx0UKLLbfc0pdge+XyF2W88CXkj4Dx1ddkR+aVZC46OvlkZLS4IguVstgiCy2xaAmL/5ZzzULLLLPUMkssteCyyy69+DLMMMUccwwyyzDDzGjORHOnNNLIVo01t+HGDTfhCBqOOOQImo0yyQhzyzPkOHoUOpGi6Gg4yaDwQAUfPECBAxEukMCnJOzBQxFOcLFGHX74QUgigyCyyHaVyGpIIpCE0gqWu7BZzDDlJZNMLqkIuxgtyQDDniqmFKTsshE1JJEmASayyEZ4qJHgCgo2+OBJnar0qUsIvGQhhjJ5eG4AAHQYgAA7GTDAAQx4QFQ2Jyqlzz4tYiUjv8L6ewrAAbPCCsD+GnwKK8IGvDDDDQs8MMOwSDwxxVyGKWYtyCDzJsfI2HknntRckxuggRIKqf+kKKq8MssqR/ryy+RAk4sqo7zSiijQDLrzNdMgtMoDCGzqwITIvQRqBYEUAQUPXLzxxhyrGjJ1Io1sJwnWlVjiCSrE0lLLLWoK05kxviQmrECoqCKsKqoUBFfbBS2UFicASpKIIYX8gQcbRfCg4ILcetvAtwokcIABFMKkYbk1WdgTTy9JfrgCDHAACCzNhJPUO/s0lZVU+eAD4z+iL8wKLKijXrHEWmp5cS1m4oLLL7XX7ibHcGo8J50fq6Ynn9YIj5s2JXvjzc4mKnUiOoWiDDP0L7f8DvSPGhoON9pYQ81qvL/5i5m1XFIIIoTEUckfmjzSySSA0PE+DjjIEPT/Ax98MNynDizQKYWgQuDIGPDgtDjwwQ9TQ8S0GgGJrFVCEpaYBCeUlQpXsKIVsbjFLnyxGV+YLTKpKMiyhIWstsXtPp7wRCf+00BGMCIRgsDDGBAkg5CUwEHdQomnFGA4l1SIJ42jiQ8tJDmfwOsARmQADiKxC2ucaCkrogo+oijFeuCDd3QCWZ6kQY0tUsMa2+gGGLvxjTGSERzjOKM5zqHGNbKxHW5shzvmcQ530JGOKHKHyvShMjrawx4r0we+AImUzVlPHIfKBmymEQ3RIMMYw+jFLmoRC1iUohSfuOQlLhGJSBQCEJ58Hyh/ED8PwIAOhWgDDn7ABwscQASB/3jAA4KQhw54wAMpwEDQ7KepCiCHcJ1SwEsg4ABHKCIPbKCOILJTNUgwk4ENfGAm8tMehHGpFuQRBmWW9J5RkHAg7BmFW/SDClKMYiAOAcUmMIEJBz5CEYLowxzIgIUs7CAk27IAt3Cokm9NaIgw+eFMLjTED8WLAxxoAAMKSodSOEMc98JXvlSkDjfOYx7ykAc92KhRjdLRHOVYB0hD+sZ1sKOkJj1pSdWhUpXCIx4XvahF2/HSis6DHhbFKD1y2o8+2kNF+3jHLyj5iUpiUpOb5KQnP5lU94FyqV6hw1fssJWpyoEMVjUDGXIwBzvE4AeiqAY0LCCADwShfh9whP8jRLCCEWhKl/ajAOEu4AAIlGQBiZNABPawiT3oIZmI0A53mikJWcnKgZbIRCgEkgpSAAx1s6DM2IghC8WIIhRqa1sqzNmQcOqnnPrxzybSCaBHLMIQf9jKHN4gBSLQEAMMyidKhOmpCSmuQje5kONkEjkDHCAFfGDEJU6hij80wDgN4EASf8EMbTgKHfiyRzs8OtF41BSQ9qgjdrNbUZveFKbdfSl45UHTN7bDpfXIBzzSq970qmO98FBHPOLx3om+kR/6QAcz6IAD5L6vDW34gVXJIAc6tEEOBaaqHehAVa58RQ5f4YNXGryVNtgBDnAgAxz6cANAGGNzu7AAAYL/8AGhBcERoAjEGNoaBBHb7wEOkAALICCBC5QAAoaTgAh4AApH6EE7VsMakLOmTkwcNhOZ8IQoBCKKSjZWFrx4RjaeYQtXmCItbkkFwNqjEIiAE4SddYhFQttASBziD3z4gx9Sm4UcyKAEKihB4Lh1gQjI9lssqe3j8nzb2yYuBX/IhCmenAxKADNxlTvu5WIRjc2d0Y3trag72kGVSVPlHpa+NKZzqumcVjS8nLZoTvFRj1GPOr7xIPWpTT1q8dY0p3AkRylGyYEY2KDWMaD1DbCg6xzk4Aa+/gGwgW3VH/jXv2UgQxayYOxjkwHYOfhBD7BwAx+kIAXJEFQ16KAA/wQEAQACQABZA7GJICAA3G5FgQRe3IEKYECtF2hAAhzgghWAAhSEUMTVCstAdWZCE4dNywmTLIpPkKIUpyhFKm5RjWwkQxY4O6EEEY6jV6ACFKOo90IuC05XqOIhoEhhJibBiEO4aiN3iAManDADHczgzQvCAAYycAG8QqDOKulnD8nluJ4koAN2GAUwgFUIBwxAt5I7AEE98IljUEMc4zhHO9SxDpryK0ZZufq+oEKVqnMdKl6vCti/bhUW6csfP80GIH4QAxh4gNc5sPXafW1rGMCA1rW2wa3zfve736DXc6824DewAVb+IRypmIQnHMDtB6hLXSu2X7kjD8sKZP/AARPAsQlq8DcMdGoGM6jEKtDanbOcRWtnwUS/KZIJTpzQE6EY+CVFMXBRpOIztvigKPDDnlRM3D6YQGsg9mDiiq8CPpfBGZgpYomMPCIR5fNDHd6QBS5IoZ4u78CCMuAgkwiTnzwcF4Zi0hO61iERZNgAAxqgrnNxCCgHuBwspqENcZzDHFOfh+jyP7r9V710/o9R2HWdjFAaAUqFijDFP/iDHv0CgdFACmzADeQd3dEd4NWSBW7ABQqeBwie4FnA4HGgBYSgCE6ABTDAhyjAALxCM/SBBahEiSFA4wHAC6yYiAkAAUReBczYBGDfCrCAEFgLETjICnABHqwCKGD/RCVkwr9ZwpCl3kSsXuu53iVcEhUSHGO8R2WFAtc8xiqMwiYoDQWM1QxuwioEARmqTTI8Ay+QU/JlAhJmhPMNAkfEARtwwQ7ogAxkS7YsyLbMWffdGQ/5UG7dROKMixEtQOP9RIckIkGFCA4snTWIw4m4A6qZmiWq2qmRmiZaojyYlyWW2iVaolV0YqmRmjxo4qjdgz+oYj/kwz3oAzl8gidZWBlE2ILNAS4u2NPAQRzAwRvwoi+6wRusQRwQoxq8QRqkARqggRlwQQnMgAKoy/7oAY/N2Qt8oaaU2weAwip0YyBoCixhSgagREmswA4gwR3ogR/swAY4wAzIQCO8/wJhWUIiOJDpGVnqnQU+GtklTMIkZFImQZAnHJknUEQnAJ0uhF4ePIBMmNuKOcIe5JIjjAIvVMMzmEIK+ZslUAKswOGAQN8cxIH0sdmbMUgfngRKzhbO4daFCIBLumRA7dbkHE4C6FDl6BBypF8S4QI1HEUn/mQomlonBmU9uNRFxddRGmV4vRRSysPoFOVRoqJUrmJO5YM96AMzRIInbUUtNhgczAEcyEFYhqUbtIEbuIEviqRIPk1HPI1buqUwKqMZoIEMdEC6AEAE6M8DaAAFAMG4kVX9mGE3duO4iRgsocAJyBwGlIAOhMEa9IEfWA0apIAMvEEcvIIqBIgkcP+CA/GbJqQQyAFcFF5CJpDmJERCQWphCkWQKYSC24wbQ34bt9GgYSKAAHTAJKQCQrwCmGECJTyQA0lCRjyfqtQByu0ADciAClzf9pUESXiLhLjEhQhi48gkbxlRTdrkcUjIoXHAQh3DJaoXUroUecZXS3GiRV3iUooXq91URVFRPaynKY4aPZxiPcCDeLkDOpSCJ52WG5RBHQToHNQBWIbkHKwBHKyBGyjoG8jBWz4oXJ7lWbZBGZhBGZSBDWxAuhzABCiABGiABozBjtnPiu1BIAxmN6JTYaIAEJzACYjACfCAGtRBHxzCImANJPDBDfyBHWSCLoSCkemjkalFFLL/nuuxhX9UBEUU5FqIwlv8xwQoQuiN2EvGktAEQlmVmCNgAuLdQjLUDEN0QsiZhSVgTSPgzR8YgqrEQRpkgQ/cAMu1WZw1pz5537iMC26FH+TMZEvYZEuwhHEwgANYwKy5l6GqZzy0A35elEwNZXnJFKTKQ6TKVEy1ZxTF56pdVKaKFz6I133KwzqggzR4UiHwwX8CaICmajF2RDGugasKoxwII4SiwdOYpa2W5YWWQRbAgAXkhAPIFV/mwSoUJok6AhmiqBE6wioE3xVcQRG0wAsoARvowSEwAtZkgiScqR/8FSr8qCU8YVqk0JEiKbmuRX+IwlqAUyYsgioMggpM/wAZlpVtuiSJkSgKbIJb4Ico5AVB2AdbZJImKGGZNh8CPZ9xLiP14eH1MYjMpaRK9o/kkAt13pYQvQQC0BZt2VVNrkQDWJ6hfqx4gqx6lVcnKupP4meioqzJgpqlbddMiRd1zUMf1dQ8tANSwAIdAEIfwMEZAFiqBigdqkFHsAEbuOqruoEZuEEaIK0ZpIEZPO3SPu1czuWFJtsOYIABXAAPkEAFAMGJggIN6pKJISuyBt8e5EERFMEY6AEhNIJhoYWRWSvWvMIqACknaKGRyl5lndDr3YffdoImrMIrAIMqRIHggYEXAt0maAoBvCS9ntgH7AEw6MIrDMQl2AI08P9CfbTmRKgFRRAZRmyHgJhWHxCoR9hhcrrcy8EWShDOAugQzuVcnj2OP/Fpxu5PBKSbyO4u766XeaaXfPlufMlUyzIlU5qaO+hDfcrDOZAD2tHBzp5Bs7UBgZouHVrm9SpoFzgt1CbjXHrv0+bqMqJBspUvEaxAArDAHiiBiHYjCtCgRJLtYIJCMiyrIgSCHqztvQGZPnoCaSqhJGjCK/wo67EekgocOaGrKKiCLkwuMGBmM0ADNLyCCsABJtRBMkADMKzCiNlm47KLDQYB2AZCMuiCw5mCKFxCM3DDMJwCKdRMRvoHJ2iCJthNAzXCInwkHxhIHTqBwi7n6pJEPnn/Crh8H55SZ+RU7NEkjkv8aS+FFBRHcUiVVO+qV3uBLDuc5+9SkTwsalBSlz0UJTysgzj8wg/AQR2sgRZkwYXOgRykVmr5YmpJKNKWgYQ+6PguY9UuY/mWrxMkgQiEQSBw4wY7gqYEwR483h5wY72h6B68wCpAwyrcmzu17SOYXn5cApKlxWFRQicMLiqIQsDprUCQgidogs0QQwT/SjI0QwZDQzNMbgazcjI4QtB48E/Q62yS8ANXbgp/gqAgAyuwoX/wxwwTWSasExwawiBUy+kip+fJ6bZsnwXgEBFPyMWKi87p1uz2xEzqxExKsThD8UqtFDykgzlb8cfKVxaP/6d8yUM+dPEpDqUlwoM9zEM9qEM6nAM3RAIOrEEXqIGblgEWbMVbyrFYSujT3rEb0Oob5HGu6qqu9nEWSAEXsMGxBh0wgG3QmCEoAMEiO0IgoBU3GnL9eKMitNONSoI6mUIytAItBIPAKeGQvkIJk4IoJ9kpDIQnmIIuRLAEw7IrB7UEv3JRa7CIlRsB3KUuk5UjlLAr2IcntA8uIIUzDHNrkmuSYgLg2g1p/RUiFAgeHIgT7AByKiecmSSdWnN0JoC4RKz4zS4hfvOG5ARJjbMUvxE8UPEVGyoV927wnlqncmJSykO+5EM9zAM5LAMdoHEc4OKA1sFXgqWFPTaCKv/oGgwjHf+nhSbtWVqoVVWohZYBGlTtDDgBEWBCNwbdr6xCIoubsQ4yWtFmONaPiY5BIChCPX4rxAUDL9CCZJlCQareJYiCLrhCKgyVJWUSLRA1LLcyUbtyBkfwZxhLGZJb474kuwgNWYGCBtNCKoiCJRyCJ9ULOThDJbnFf8CtP0KCOmHEMjNzH9hBapGvD6N1DV3AWncKdBbx9wXR4xhd7fYPxiaAOqQUXovzX4usSVVxelViU/6kYfOD6LTDN3zCDxhnHLwxZVuYhbkqqxqtGoy400poREe0VSVbrrJx+e6AFNSAIAxm0EGDdX8hGZrYjtGg0NQPLAUBEFxBHqT/NCMoYQQRgyvkwqKYjSgcGT5m0icgzMFVEitAQzY4NyxLsHR/RnT/yiZcilJrdwBwdxCsQizTgil7R4LVwqNUAyVxLif74yQE7GiRVtXgTXGyqRrYoedpSxBXM0riEEsUccTCNZ/V7tEUeDknuBSrVEodeIPvdaNnMcgGb0uRGvAupYog9jk4Aw7AQDD+ooeHutGO+hqMOBcw41nmKhmceLJhQbTp2jz5gKzLgAwQARtw4yisAjBosBEmsgiH1l+Co1mZVaYE0CNkwiiUpii0gi/Qwi34wi0QAy2YAgT1oz9GwhQ++SewApQhElhhOWg8968Q9SxjKSxFng2yCwEE/2bQHTcpZAIj8IGBAUI0kEOhcEMtlAIpmLLrdQITzrDAYsQCnSkz+8EdDChZW5+blWQfPgiEEI73NfEQebOhDxHGorNKRXE5bPzGizPGl7Ojm1Q5O7hT3qcWm9o8qMg/2Gwp1JIwouWrejjMj3oX1Lypo/qpBtiqV62rv7qs//ybzlAN6AE3osL8fmEio9NsJzUsZWPTP8AYEJMqVEMyPBBy28IuyEKz5wJ4k6YmlQVAXkIpaM5tSHBpWHl1E3XQrQIKCLtSLzW9Rq6uUxknQMIgSNX7lII3QEoZV9JATEQNg2YNW0ID3bDzqamqcESen3XqpjXMneQEyNY1Y2zFV//+hKQD5qfDOnA853e+55fDx2f8OpQzO4B8X7dUFpeUPNyDGMODGwmlVNgDNdBBLbXBG5ylGIgBWi4oWoKl0sKB0iZjMjLjaCMbRbd6D/QA0AO9CtyA580AG6h2itabSCvruDnCitFP0HxbOHbtllaCCoYCCzHGLPBCK/CCKwRD5QYkWfxjcfdCbJS9lZv9Mwx1UAedSYfjl4MwuInwKogCQHBKNIiPHDl02tBBRu6dPnTkmMEqlWqUpk2aOmXkxEkTpkqYLEmC1CiRoUGG/vi5EydNlixJiMyQsaJEiQ42O2C4cGFCz54OGjRYMHRBAqMJECRVaoBpU6cGEqSTmq7/XNVy69ZZ1bq1ajp1X6VelfqVbFl18NDCO8uOXTt69eShbdcOXjx47fz546cPFwcOHtq0ceNGTJg3b9ascQMHzuA0cxqnkYwGTRnLZFxiweIyi+Yen0H38DE6RwoVMnLITOJI1SrXq0BtArXKUZDaQR4oTfogN28ljgJVeoQpEyNIk0zJkpWLFS9bvFBxujT9UqRIn4Y9m1atmbJn36GFDw++WbJk4qEBA7bnw4MP7RE8IEBAQH0EQYLsAVWpkSE/duQIrAwcIgnHnX300ecdZyQyZZRONAlFwow6uYiTTCwJiSREOCTEDz/miOMNNbhIogaZaFqBJpsy0EknniZw/wAoB4gq6iijEEjgqR3LmUorrLgKUsisrlrHLLLYYkudJOGRp5560GInrbn+8UefbiLhwIINLCvjjMLUeKOLxNboogvJGnMjDTPMoIyMNzHTTM7QQCMthztviCGFFGJQIQcVaNjkNddiA6W2QIJoL7f4PkiUtw9eKGIMQvRYRJNFIGEkElJYoYWXXGyxBZVLPPHkkk9O+cWZarKppppolmmmmWeqCa8ZaGR9przzxEtmlUAaxe+9D5KqTwAEGtWvEUQI4WOOwNq4AQccfnnnQATfkUYiUiCUcMKMNumEo0wqkeSRRtBFBKX/6ohDRC582GGGGWiQSYWabLLpRZ9kpP+xxhuP2rGpHsMSchyuxhkHHHCCxArIspJkxywm43kyyinb+Yefd5jxYMsJsiiDjC3CCIMLNcxMWQsz1lyTzTJcgrMzLHqgGbQ7cc75hp09gIFPFW5QQQU2NpHNNVVAMRS/RIlFdumlP0ABhReESEINUDqB5LjpSDmlFVJSEaXUS0gxJptwyBEnnLWlkQa8aoJphVdddeU1G2ieAeZXRKFOFAH73Ntjk/7smMOgNrKwYVpArtGHn8cVtGaWT0QJZZRRvKWQQk0ywUSSzyXZ0L8P8RARjRKJ2EEHe+/FNyedeooAgn5rHApggQ0gmCqrDk7Y94O1Srgcc8zhyuHj10n/8isl4WHLLnYqTuuuuebJZx90YKGDDBU8ePkMM09OzEyX2ZRsMjff5Ex9On8QzQc8b8B55/lvWEEKTFBZ5RX1VtkEavke8DT8BAJRL3jBCYoQiFEA43KhkM50SiWKUXjCEqTahTGmwQ1xkAMdHVzbB6VRDWU0oxrh4AY3snE3VrEKGroARSD2gJ897CEQtdHNA/ZACET8gQ98KJwc5hCDH9ABEMdoCD/2sTFyXAMWp8rERjDhEa1xJIqWKNcjzLUs//ThDis5DBrkNYPUtE5fHdjATvj1E38R5XZQ2VEBprK7qvzud0EqXsOQhxXlLSli0GsePOBil+nNxUrcKMQZ/7LgszJ0YQtdYFMXUJYyNk1ykpRBQxZklpnN2CxnooHfzj45vxXMoAugAIZ5mqG32zRNgE9zxBiAMAZHOAIUvsJEJ0QhCk54ghRiswQieniIQ1ynFLM4RjTOxsEOooMb1cCFMbWRNhNCYxopzEYzXgEKGs5wD47YhCNiKB8CfMARehBEH+xQuDcsxgY2kAMgLhGOdyRxHg5Z4i+u4wmNlAsSEOIcSD53RZKY5EN+wEPpLumDLPjAXjXpwJ460IGd8IQnEJjdGtkIMB0xpQBw9BHv6FjHcvjuHFUh3o/ymNLj+VFKFYvLINexj3cU4wtkuIEMUqAFLTiyTSmTpBm6FP9UmGFSC5r8jM16AL+k5oB+8ZtfO3eWgnndQRW6CIYuVOm3+7TyaTUMxDdNCQxB+MEQwjwOIwgCoDk4iw9/GEQhiBmLYqwKbeQgRzi0oQ1upE1t05BGNrgRjmnkIhFs6OZrRgEcROUmD4qow38MIgc1uSEGOSiDHejQi4bMwx/zsMc7xMGNY5SilxnBUCbEpQnOZagSVjQXI0piCGZ9aCXne19DVbCnFLzuAvtSI1CEYrs2GsCjCFPYwpALvJH6zqR3rIpKoZu8iwFSHnaZSzvOoQ9xfIIOTFABDDyg0y5YsgthsMJPLUPJLmVBC1GYGZ1Cc6elNpV+UL2p0FJgh1f/BMNXfMsNV1vZzVm6BhiKwIMbyHAnwxlkDoWbgxvi8KE//AEQhRjmqViBC2VAA5lrs6s0AxsOtUljF61whS7Go7dVXO6V5bQDOiO7TjjYIAc+eAMfClGNefLDHuYYxznSxiBRkCIUmTByRlS72gy5NlOJQISTCTEIP7TLXXG4pOpkkGUZCC2iOckJGicguxgBt3Y3Yoo65GgV5K6ZYSFV7lbGYhavoJmP7NAjk+oij3m0Ayvn6KAzELIEPXmAvVywpBXMywVFU8YylAGqZVwShSgsYQnwja/8dmaDps6L0x64lwxuwAes+o9Y7gEwV4HzGkGowQfthMEPgGgQN7RB/w51qIMd7tCHCQ9iMJKdw4QRMYlT4AIZtDrb2sSRbGWvTYNru1sygPEKpD1iEOk0yBvg8AaD/EDTWZgDHUpBDn24wx3tILef3xGNWZSiFGJDbYUu0hHiRLFcoUtEunb4IT7cIURv4IITYjKvLLtOXy+C0W+D8i+jGADNBVsumxfmZjo+dx1TkbPFl6QOPS4vLfTY8zlA/pBT/KANPVDBBlLAXkuiwQpW0IKiDV2ZMjB6qJ2Z9BKMYOmlMvWTmqYvp1OwgQ7QoAMz8AMm8uC3YJ26lXmYzSbY4IQdyAAGr27DOt1QBsGQoQxuAKKt66ADGuggywzNghB/AIhIFBMZrP/ihjdE7GG7bvCu2XgGMWyhilA0goeyVsys22ADGMwgC0OkAzPQ8Q506MMe7diHPRR0jcl9whOcCAXWiibvfwJUJI84l5PXRbo4sOHfSQjjDFbkOt5O1CdjJrNw4wjS40I84m6meBzn3HCpqHRJamGHnvm8DiBLAxAkL80GCJ0FynAhCy1/ORekoD6XWEZOWKC0EbCvAzrlTH7ttAGn6cfpDWygJixgAR4WG0Cmn3oVyXCEEGaQW9PYCQtk+AG3vd9Opu4JBjGIQf/1BAbaCQfogIg+IRa8o5pS6IPQRm3sjhh0QRU64RE+RLLUAGW0rg08IMvqrw1w4BPk6R1EUB//9kEvEGQbcOETPsHysKZCNI9zOidDJCEkQmdZ1CXKDMpdYA4mTmQmSoCMIsrgLsACWu8nEm4o4ohIemf2ag8cbG8rKi6OwAIseI8s0qEd5mHP3OEhWAEH7q8Hgs4CNiP6pEAKnqAKtEAKosAJliAL3Mu9NAkLfOD6sk80bka+4MfnwC/8ZgD5LmAFXAAKAmEMHkAA1C9R1m9pugna9IAFVkAGzGgDTqPqNI3GeqbqUsADNHFLLOAvesYDYgA1fuBNCrAQIOESSoEVaqEYliGFQsyEuCPaomMRBOEOLNBMMtA0YqAHyGBacMCIRPDx+OEe8kKmwuEXPuESKodCOEIT/zYiyYxsyUJiJJwMyj5k9NSA9P7tRGQiy4Cwy1ivJ2BERoIr9kwqpCJO9ohnHZnLHNbBHVXqutqBLfSoedhhH0rQH8yhHcjBGugAC26Ava5vCaLgCaKg5aogIa2gCp6gCbQADdGwvXAO+5ZgNHzACFRnBzRSBzgyB3QgB2jgBkKSBupFJjhNy6gOBlRgBVpgDAiRUYSlUYZlWBDxaYAAFKABFGhAaLRMBfzP/zStZtYLk7KAI4fgKIegB4bgTnyg6wCvDezgDwzhFD3BFFzBF4zB2FoFGvDOFDxBEgyhDyCjTLrgDMxgMNRkC8zgDM7A/iIhG8jBHYgxL+iBH7YQHf+84RiSUVwsYRLQahA65xHKpRK0RgbtjUPUhbZMR9FUh3W2DF8KTghbr1/K8aPO8XeckGHmyHfWkXjG4aSGBx5Tai6Sx86k6y7w0R/+IR7MgRxwAQd0IAq0wAh0YAm0AAmaoAlwMyGroAl4kzdzMziRAAmGwAiWQA7jRSN3ACbEjiSd8zk5zTm7MctSwAZWMg/y4FGW7mm2MwheAD/ygAIQQAMWSA86ILdwyjTk77tiQNMIciJxTuw4kiNJMk80rZPKQA7ayhAYYRI4QRRSwRaIIRm+oxmCgRa8EiztwAzWYAt0Sqe2gC23YELPwEF7ERbEYR1UUy/oAfLQQRzQ4Rv/mKEUpuMTJgESSsIiPqJcGIERluxzSMLJElMl3IUNSETq6kUGWMehbuJ19uXgyLEBcC/NNlN4yqH2OLMzQZN4ouvO6hE1+cEf8kEexoEbIiEGjCAKKNI4h5M4cTM3vzQ4dTNMu5TSkFM5N7I5SZJeSpLTZmA+23QG2mkli+AKvjMRBcgR+icETmAUKmHL4i89hWZQq649x24+6fMnf9Inv6vqHLWyssDr7IAP+oA/J6EqWyFUbEEWVOFBIOEP6iANzkALKI3SJO1BtWBCiyoF6CAazsEe8sIfOtQe7rKDouEUVPASMkESEAEjLCEaRQIkKqHezkV0UsIP4qB0bBT6/zYyR8mIRzHgRXxrzHTP4WQPeJA0YZT0pNYxj0TTSL7iztDicfxhLsThGHCgB2aTBmyTNodgON9VOLt0XsWUON/1OEcDTdOUPt3UTeN0XkKyPW9gB1gACGYowACMllZBF3QBE9gAFJ5ABeblNPBrUBsVAH/yUBXV/wb1/xy1/zTtB7rOIF5MKg8BEizBEyREnzrBEhIBRMzAQUsV+7L0VB80C1KAA0pBHOYpL+6BHsztHc5hHNxBH7ABFpLREkBCFVpBFKZjEihhOKLII67o8zhkdHLQRm9U6uRly4Qm9YIQA74MzCYALObMHIWkSD9TSa1CSd+RSbGCCh2GLfLBH//uwRzOAUs4oAfik2ajQAfedV5x016PMkzHFClxzgfc533sBE/Y9Dmfcz6NMwt6oAzMIBvRLw/2IOme5mBlqGgGRRdeYRTuwE9SQ8uCZmMXVXVZV2hC0Wt9sj1zYDPO0g3Wqdb288lMQsqchQtiE+fokGZLlSCzYAM4AAcQz3H+4R7iIQv30R7UQS+8oRZIxRJMwTxuIRkvwRIoYWrpzVwECvT+YKzuoF3WgEQUTeoELstUBDJvouAmakjRNm3piG1DszPfFm69Ih2QJ3rt1hzEgRnAqweMMz5rE3AFdwgON3DrFSmLM+cWl/scF3KdU3IJ0kwaYw7mQA8IIRAUgYD/CCiGsDMP9HRQZsM1pO0RzuAGWsIlbmAGfADUmkrTXHdRO1ZRfbInXRcGbuD+MmOhQoZN0FKyzGChQFIGLJhmJZdme6ATOaBA3oEfltfj9mwe7gEf8iEf9OEYk5EUnsHucJWKvJfehlWgbNAQxoqL6sBGl1UKYKJfZ2JFViRsL0B+ca8r7vhaQbO5trVbKw7N+jcvqPQaPmFL4FOJAbdw4VVwGZlwi1MH0JRxJVgkKVg+azMKxmQNHswPUoIQCMERhvWbFIuWUCwZdME1sOqUV6ES9s2HDsMNsCAP2wmHa9hiY5djc7gnvVFHxcgiTwPUcKYH3mvLsmyJaRNRaTbn/xigE3EAGdChBOnhHqyYH/bsH/LhH2RKHIpBBZshHLJBFiovJJJM3jyCjLMoERZBXVICneagDkIkDU4nXhzXGwdV9TDAK9DiSOzYWutXSPoYK8whXIUP5MwhL9phHKIBByzAAjiSNsfub40SgYnTKJHSKB35KGkzki0SZ0gjci95p8akDnLtQ5ysEVqrEyRkFFYBFZIGhVGJV8IjGbLpXAyBD3jXcN5gM34AfvwvaGqYYzfWYlFyUFOAnrNsBsS2JrLM/8xADnvgprYs+7KvoZMZ53qAARqgEyPBGxyn8eyBx+gyL/biHchBL38hsMC5EzxCtYrmIqJI3oYVRhthEf9KQsr8oA+mrN/eAA2iz4ih+peFBjLNVgrHYnfyOG3vl3gIWrFBjqABeaDXAS/G+hdwYAMsAJEbej4duEsLNzgdGJmV89K4rwfGzjgxWXzWoA7wWhAIQRGeDGUzQWUvxxRUoTVeg2ltARh0gRhkBRgk0HNKwqZ56MGK+Ac6A0/6JAZooE9suXVfFyXnRSSn8013QPnSazAmCWY0o1Ql7eaGt1QTyQbIoA0AYRnmCUEcJ0r5oR3sofHKTbucYdiagRQOwa4xIcnGmGpFohEYIZ1NIiX4QKTbZa+hT6Fuy6gfs+CsMI7gIc7kF7H5mLHXsbFBzkj4F7LbAYnIOhI0cQP/jnmJExkp4VWROfuzGzq068QiNcMljBOkU9vW7sAPWBsRFuFcZjC2h8wUTAEValsVXMEVfDwVMhWrgAHITaFyNEESGOHJdshZiDjrsGCn88SGFZUkM1a5X9hNsyx+xE7LSFIHFMolWKZL2OS9KNJUvZsgJQ0LpiUH5gAQPkEcEgQdII+z2vuz7GEf2qEhzoEaJOISTlQQBMGfVOutp7beRmIk/NuuaavfVo40urEbWyeilMQsGjz37Bix11bCJ5zC4bbCHU9BmAEHYGD8EFVyE9lLcVOiG7midQAjNVJxRUNOglhNTjsORBqvP4QQ0BmLhhW1QoEUTCEViN3EfvzY/12BFmwhF5jdFn48FUyBFCgIRTMFJXwosuSA+pJqym/Z/6zc2+vzpmZgfsTII9s0JONnNDZjqCwXZn4glo15Ik17zWEAB25greigGMha8dgbQRCkvRmPve0BHbBhFk5lEtI5tfzpvlULQ2gQdJpMXQZhwvzAWebgldOgDJwalHamT3Sr0r8iLeisLIYUsftYST3dYSo8phziE3DABiz7w6k61QPXXgf3SxP4XWF9B+Sw+oI4DWw3pLtIxgWd1xtBMG8JI3JcyH9cOWSh6UMFVJg9F3jhU2QhFaQ9E/yy2ifehxpMskSGDGjmw5fb/8Suysmd4+PHI+kz3HMANN59xf/d/d0JOJmT+dXVHAvqPQduTO3gchzQwRyEkcfwvB/aex4QxBuQ8Wk1pxnHORr7kgapUV0MIfQsHjLWpDOSSnE7Xv4G+2xJ/vMLxn75ODS1olvP4dMbW0GqARDAcAMaAAumOrNDvHBrfjjBtJFh3Qk4I+yFWNvmILW7qA8GQYcGgcaHAyNCAaVHYdhNjBZe4RVogRZkQdlDRReoXhh8wReq/hZcIWw44UQn4USX/L8nHp3soA4aIzEqVEuVuOzrU2ei+31OnQZ4LsWBmDM0gwxQtbsnjSIBIkqULDZg5Cgzxw4dWOS+tZPX7p4/f/Pu2Ztnzx69fhP3kTv2KaSoUKH/Omk6ifJkpkyWWlqSJKlRo0SIaBoa9IePnTl86sxxk8ZMFixYfPS4cSOGChXqmjptms5puqjqplpNV67cunXmumbN2tVcOa9fw5pbd+7cVrRp9b2b1QaLBwsNsCwxYkSHDrx6h/j9iySw4CZNBBtGYmTHDilZypQx4zhNmjdy5sypc+dOHz+DEi3y/KgSJk2dSIoyhaqVK1q2WNt6/TqXrWDCjNm27WsXLVakPGmy5IkTy5eQGEGClOgmzsx36tRZc2bLlihL9OqgQSMpUqQzbuTw4WOHdb1Ic/Q47yMLePBZhmbRAl86/PkC62eJYcPGDzRt2gBy9s467cwzUT74/9Tjzz33zNNOPg76s484zJQSEkmedGJSSioN1xJMkMwkk0058eFHT3PA4YZQZajXQw5JqbAVO02xQyNVT0F11VRbhfXVWGaRZdZWaQnJlj7eRELGEilYwAAWfOn15F+AHRbYEIYR9sQSTjghhWOPOeaGG29YZkdmfnCGyCJqPiLJaKWNIgoppqTSiiy26JKLLnruyQsvtBmjTKDGFNPLLbKkYsooocApiicrTTKJh4gYctNmfWT23BrQTVcdefjZ4F0O5oGnmA6K7eAdqYpJQQQRPkgBa3v1RTGfFrTSCh91MNyQ3w9l9IDDJ92Ukw4++fzzz4EOOljPscjSow860f+c0qgnoozUCScYprTSSh1K8uGHM036hx/lmjhHUCkO5YOLMdAIL7w4qgNPVThe1dSO6/QYJFc/CqnWWmi9gwwdcsiwJAM95GUdX0hYCbGUSBT2sF+DERaFE0tE4SVkZohZmR06bTZIZ4tAskhobi4a55yt0JLnnsD02acvxACqjG3FGDOML7zY0ooppwntaCaQdljcIojg9EcffdSBohtwwHGGrdWZh/V5LqpqqmKikmqqEzsk8Wp7Pti18axRGLExfVHEEEMONmBxA7B0/HJOOfHQQw8+ysYDTz1+O4gsP25dAwuF2JaGIYacqKSJt996OK5y5+6EIoorFuUiPJ7/VzWVVKGPnmPpVgmM+lpabRXRPPLgE08774hTChlxqEGEqEsEphcRSBChg+/CUwlYYYRV3MSsWZDxWIphhswHiZwZkkgjx0liiSacLDrKKKip4ootfvLiiy/BnE9bbYDaRgwxwpQv26HXhiIcS5DezwgjhxxSSCFN8zEHObihDEEZCuduoB4d3GAGDJQBA2nAwAe26zsTTI962AWeJWhQg/Vh2wbT1p4ytAENaEiDG3AQiW7owx//cJCxDPTCZRHuHvswEi4+cQlIHEIQd8gWJ4RjCUxgYiWYqMRLwAUuRijtJn/AyZnqEIc3TCYNXBAbBGXguSxqsV43Ap2NvJij/9SJcS0Mooc84hEPdrwjGoCQw+2IkIUeROEJgWlVq5JgxzsmwTBSolhhLObBJSzvMZApgxtCZgeRmWsQ1DMO9jJBGu55DxXh0wUvcrEL8pUvGDcLVM6M4T5jCONnsgjaSILTrVRaYhLF0Z/+DDEiO1RGgCla0atOZZ0ZYGeXNDDVeszWAywYUJhEwQKuBJKrWX2QhI5BwxukmAMc/OId+0CWs5BlTRm6MB/+4Mc4fnGJHKqJE54IjrY0UYnHCfGIMElickpGqTM1Jw70vF0VxUODLWaRXp+rF1W+6MUbmQ6gTrFHO8xYr3KgAxY46IkanEA3LViBjnmsqB2PVzG/+P+xYkjYiwYH6RjmHTJkPOHDH/5giDQlwpHZwxBJvPcyW8hGppq8Gc54Noxe7KIWpWTFKU5BClHAKRTlROUPh5NE5JCraYmUZZiCUgY0mG092xHV18DTAwuyx4DtKeYx1VafD7anMc8MSgw8AAhs6IMfLcymNmWID2Thgx/nAEkkJpEIlv1wryopYiVg8pJHyGRSKYXlE+cQB8S+AQ1SEJsOtIhGyG4RcPrUZ7wui1l4aaQegBvHOKwRCTrY4Tla6EEMJEpRi1YUo1UaAsVaOwQPDoQMtKWtIeVQmQCWdJGUWqkkRKOSN6ECfLaQhZ1ywYvaeDJnxRhGTnvGi13Ihhb/rmgFKrrXqL3WD2mtXKrIdiIHFEnGDSRUD3isil6sZnWsIXRPV7MAVuokUyAfbY8ZnvkGN3gABjiYxTtWeKy3vjWuMOTHO5iBw0mQxEK/edzjMlFElwRWsDRBxKTO5Aef+CQOVJSCYjgrjxCLWB71qMcZ0VhiE484Hq5rsTxcN+IVixiNgJNIPeCRDnCIAxd0aONPfiVHOv6uVcGzIx5bdRg/vrZKG4xCbWv7mKnh9jJ8cJq5bkKpRTTity+xRGmEOlxU0El8xEhGoJaxjE/ephjCeN8lZeEKRJ1SOKh0CRKL886mOS2RJ5raTySzIgyeBz3rESZ7CxnVsUqBC1yA/xWjF83oSDNamCR85iE34AEcAMIa72Cr3z4N6heGOh/3MFw0SnGJkYCiJJoQovaOKkTRFBEmgtWyTQYhTz/cAbFpQAN1UpxivqU4xCXGB4mBPQ96JJtvzKYHsJ897BDHYyI3Bsc5tBFa3MLBDESZo5DtWGQiJGHcSKZSYF77R9k+eaxkMMPHwgQHy1zGDn2wDGb60ERKGWIRklgJhqxlClfkIhg4Q7OgdNaz3OTCUKU0BSmIulfJESeJi6AU0/R8h9HWYSeW8fNT3Q3ykJtBMu6uZaLbA2lHN1rSkn6MZEjYBjlYINM4gMV//RHqnIN6Wcjyhz6okThVN440joucEP9j/ddHCPZDFSYEhnXN6y5o4UBUT/E8rp7sejh72XzjOrMzchFgExvaIp6IGXV8DDrQoQ1zMAMZevCeLTlBtXe0o5X4iPd048UIho7joInSnqymB/C/OhuYcjuHOwwiTaGhRCZOI4uBE2O5B8+Z+3x2C9bEOajZPSpSsQeupFXcwvsr2Ukv7jSMN3X1HLcMbuWQ3zCZgYRa6ILU6VMr+Nj+MVxAg7vb4AYLbAAGP6CDNDp9D20qSEH7aH4N98FCAzWLH9+oRSmEGgpQgGITjSs6JCFciaSzCTm3xrCJ4BCUwbnQWHzLCPQTRI/lM3v5CgJ7RepxD63rP//OdraCzN7/DuPgDZ/wA21QB273Az9AHVMwBU6AR+QmbuMmgQ8jGFJydxrVBENwF3sRTETRIt4xaBVkFII3KkRhSG3nBnWAb53xCJBACZxACqkQPsl1U7dhee5zSbdgC3HmcKdUTt5nCRzSTkNIcWriGclRWKZ3ekzjNNHTB9HDcbAnJm/QBWtge7Y3X/UBH44RBb4HfHLQABOQAj3wA6XwX/tAfxbhfvqgDxnBhvvAD/4gQxHyC9eXfaBQGgvWfY4DfpLAJjHRCErjdISAazpxIm6wTYTzD91UQ/rQfGlIf83nfvuQEXHIDxaBifaQiZg4ERCCDs5ABz9wGSjSBmWwBV0QBhPF/zt6wTvEIzEZVTz0pUFGMGi1iB6Cx15lIEzNAwezRG9nQggpgz2ccBoxlQs2YxuedBuX1ye68ApBQwqkgF2h0Cj0kyEcskqQACl3lj/58xmEpRxMw4RN2FQ6AV64lV+aYoW4p0wb025d4IUxlwVSNAeAAAjMQE2dqI8TwQ/9yA819A5nCIc1hA7k4AypEGaoQBKM033qNGuUkwg0gROFuBNBYQYBJkP/QENs6IZwmCD3MH+UOImTKInuB3YnaQ/8+A7kwFAxAEVRUwZSp4pUwoqHYYHmNjFVgBcbRIu2GIK4GEKO4W4mJG+WIT2CABqVkAmdICd0Uknkw0k2xT7EEP8MvKALO5gKiGIKW4ldilISjQNER+MSkXI9KOMZn0Epk1Iya4l60eOWAOR6YxIH6oiFUhdWbNMeWuB7ZgB87fEGIkMHnyAO/8WGhWmYhfkOBSkO4cAN10AN0RANx3AMtyAKndA9C6aHmDl0EIY0gUhY5dIHdhA1BuUP8qCIG2mYcPiPIomSremarHmSjPgO3AAIOAADcLAG4mUG8OGAeGQYNWmTU3IxE0MYeFFMWHAeHliLPuBL7EVCJTQZiHcZm2EIhBCRjVAJpCFULuMKr3AnlgQMwRCe52OV1NUKqqAKqMCV3YNdP+g49fMoQTiW7ZQ0xrEISgSO+sZEI3JSb7n/E6M1l3NphVZolxxkaGXAPI6RA1JVB3KgdrOwDMhwDMWAC7UwC4lDIZ8QCZFQCPYICGoXigmIAx6gH3MgCZ2Ah5ipogv5nn1IYeXHccdwDuAwD4RzLD53mCUJdrDpmijJoxnRTdGCDLaZArgJFJBhKw3om8DpisJ5boQBpRp0nMmJnLaYGBbUHs85cmLielRmLoJACCm1ZZagLSMhjd/Tna/gGrkQP9WFnuipnlwpNIzyldqSLfHJEhJHHI6UNBEJjha2nyclqG5ZJs3hHAIKRQQ6Hx0DZb6SBW5Qjx/6AziAA5NKqZVqqQkoKpr6NbAiAzJgAzHQB6iACnm4oiq6/4dGJ36BmBz/QwfMIA7nYJrLooZumBFe13XMdnVdh3W96qtYByGz8wkjygFA0QWRBl9KCjzWgZOtdSVQCq2y+EF7t3ezuHfCNHIgZ0KU8RPxJjL4pm/VAwnDqD152D3foxqu4ArpSapb6a6mgJ5bGSdywijBYU6c0BKpNAksQYTHwQhniZYrxQhqqW8XNyKXgilQAwfOoSnRcYqSERTR0QUI2B+JJEA2wAGY5gEekAIpAAMfC7IwAKr5EaoiKwMloAIfewjkE1TllJkr2pBGJ2HgIpGDwAGRsA3fsA5w5Zq/6rM/C7QEsg9rRAc4wAEWcAZmEGmMgQUOiGTMSiVPUP8F0NoEVTC1UGq1GGOtHESt1AolgkRAQAGxUyhA3ioyKAVPaTKumNAS5UqN5zpc6emu7Em3qEGqnCdUQmWvnkAS8Pko2MhOreSvjCATA6sc1FOw/Ok0l+IcmOEcuKmOEGsGmmJ7WZCA/QEUc2ADdDEBFuC5nSt8G3ABnjtzHsABp7sBqSu6KbBfn3ALvMAJl+CyJXGqLMqHLBE5R4RnHIADpYAN63APLXQgIKkR7Zdsx9tiWBdiV/diyIurvQohLEmsDcA8S0sUcyduzRoYUnu10PqkWYsEUVBMHEQdPLl3HkUrXWBCQxkmUyg1CUFvf4AIp1cTKVMJSgdc2vK275r/KOtZt3OSlZxHEr2xPXxbVMIBREHoLdjDXccxrh/yr4TVGYbQP/5jUnrmB4zLHI2rjpY2uWcgBmFguZhaBmwwAwmjAAzAAAqQwgzQAA2gwi7sAA7wwjX8wg6AARjgAW1wCZ9QTo3COLWrmUX3YN8CCabLAb8Qq8l3ICbWq8qGdcrWvMy7vMsbxVAsxSJmOEditBxAvVHVaFJAFEYQgVErZMH5F1dbBWAABlM7EPFVvk+iA20DH+7WGFvavs+TEOAqqNWJCIoQiPa7MkLlPXObKOx5LUPjcIv8cHz7Q6JwVOWUSnn6LXYmeuP6Eo3wr4yQlljmP6e3uIzruI8LHfcl/0VmEB0TVQbRVKk20Cp0oQAHIMsDIMu1bMu3XMspPMOeCwjWNVz0Q7u165W2y4dIg2ltEAmcVk2KuIj9KIdtxU376I8shE366MzWHJDMoHZx0QPq+5y24m11JIF1d0dJZrVTe87QWgVakM4Tc3cViBeNUQaOpgaQxgVq8AZqEAdSs7B9sJZpmQiKkDJK91srQ7ftesiHPBIk4b9wkgpENQqcoCheVhL7OgmWIAqRIgmaAAnEYUTH8QhLw280K8HwZHEnhW//Y45NNTVucAZJ627SER22ogVeAsZc4BgysAEO0LkOEMMxbMNBfcMzTMMpMAis1AgXHYREt4em2n2bsP8JR5eNjOAAwxeY3rBWLUQ43RSH0uyP/eh8X+18jfiGjsiGK1kKH/oF19F7zFQGUYAETyDXSDDOehSBSaBkWUu1WEsYeg2lh4GXjrFyLKcGasAGbEBPe8wZ/5xSniET+LsyC0a3dFstwYF9C0aMlsAI+GoJh5A/26iN+9oSW5YIlvAIWgYTf9UIbHIy/2oTWKafuGYu/QmFqzc1UbMp0nGK4AwrsOIE6lEGM7ABnTsBE+DCNUzUQj3DyE3DDbABpGsBMmAILdE4wWyqtrsJrca2xDEBJZACOLAQ/xWHy/JCXw3WY03WbhGQ652Y6ODeBUkOi1kNx/ChbaAFSyADvdf/GLQlEEkgd3V91xJItWqMzuc8tcSpzhRzdx9FQiwXaYVt2ImVSCTCSCZtYQG9JgVdri71UnAyzOVUwKskn9nCSpLACCVzn4bAPx0tCayECH6ICS0YYUkHE62tJmhZsIxkWIIaS9+VSC3tBg0rH7XS242lHjcgBTKAAaM7AUPN08VN1ETtuQ1Aw6HruQwA3TDABwrmUtVNEtpXEhfyOLkbWCugBjHAX3ez3u6QFmkxDvHtDd7QDdvgmJDJDMwgmb/wCxeKoSFxCRsaCfYIomoHCHxQBkhAA/nNbmRgK0iwJRJ4ZOLWm0nwBHvd11jr13t94BQYGIKUBWjg4IwG4Wzw/wZx4Bx2sNhsSSmEUBMC/YdL/WocPo11pkovkQmc8K98YAgmZQh2cDJtQAYtzgiS0ESljTKg91u0Nn6ByKr6mbg8PiKEKppUcwbqWDXgLHVLGysUpAKia+Weq7qh+9zgbgGnywEb+7HongO+AgiWoId5iKLat2pEdSHZoqqV4AdzsAGnC96xkKEb6qGheKkwYO4Ff7TlbvCea/Dm7gFyUIp0vQI0IL5YQFvwBdfaK9cZb+AJztdVe+lUSyUfRUgrEnImJDUmFG8qmHo8ruMA/dip3RJDFEkLGZYsNb99oI2F5QY5YQdlIEu6rtmWAAmh+QefwW8t2CaYgESUQAkOrP9Ejf3alPLJ/fmEtd3S1S7kW2ArUtfbW7IDMYAGZfAGZdCxG+CxMGAD6x5zcmBShWAckxBO1tKUqvEauhCe7ZMMrjAKfPuV8Q7m1ULz2o0JJ8wkFmAHttkAdPHTQA3DKlzDQL34i//4P20DbrAESYAdIkAES+ADCUgUGhS1gpHxcm0FVZvpbWzgG9+9GIVRGgi2Ng2xJh9v/Exll7K45ZJvaVsTMmE9MC/zGjIcA3vzfbBSuu4lOXBWPWADcoATdtAJsCS/aoI9oRF+NE4JlkAJEHnjNjEp/QPtPX7bQd6wLy11XC93irEei4UI6OmdegIMwNA+eJ8M80//ydAM94////aP/83wDM9gDK4AEKJCddLECdRBUKEUClTYyaEmTJhSbGjQ4MYfBg0UZGTQ0eNHBRtDjlRw4ACDkSZVkgzJwEcJGStWsFAhw0ePHj9wGjGCJMnPJ0GfIBFK9ImVJlWUNmFaBczTp0rBVGlKNSlTrE2QDFniRIoULVrKlDFTNk0aN3DmuHnzRk4dPn342Inrx+6fP4MGGTKEKNGiRoAbPZJUKSInxJw0acrUmNGgP33+2LFj6E+ZH1iweIiRJkaKGGawuJFk+Y+hRZIkLbKEqRLhSqotzaakGhIjwIsWJULEt1AhvMEjz6UMx/ga5MjPdGGuRYoT6Dt2lMnh400W/0Ovkm3n3n27smTKxDcTX77Z+e/nzyszZotUpk6hMimkX/+gQ06ZNFmY4AAPIgdOOskBBxrIqAELKlLQQAM/QomlA0JSaUIFOoipBAxVuAGLnHTqgScikoDuKCuEGsoopJSySsWoVsyKKhWt0goJJIzwSoootChrRzPOSssNtt6YA64+6OrDLiSD68uvRZgcTDVJGlusIMU6sQSRPuSwQw45+CCjBzJ+gCGFHFLwAIsUUsjCDzj6kAyvRiypZM7CGIvNksYsoaQ2RiAJLBFADRnkkN+Aw0sy4owzrg44kltOiy6cg84J6W4wwwc03mhjEmK8C6+Z7soTLzzwSCWmU/9SRU0ml/cK8sST+hRCCJROPFGMBi00eeQCjTiyIE0YYMAh2DQ98KCDDjZQdtkLLHD2WQsIhNaCDSxQgQYdpJPOBx+w8FCHnkSc1EQah3oijBKXqkpdFbNyNysakWjCCiN28GqsHrPo0cc55qCrLrwGsetIQf34w+C9/GpkYcIKmw0TKaXkxKFQLCnSjQ35+CMLGHL44QYVerjBDepEnuOGPsyAYy/VFnmEEUsWi1I/SyCBZE+b/eQt0EN6/u3QyO6gzI5FG1WOOea+otTem7jN4oc2UDl1amOqDiYYYbLWemthTu2amGBOrXrsqm0RBU9IJrFVFFJGGSWUUWiVjzH/hRYxogP+DFQgBRs8EHbYYAMnNk3C01z2cMQ38GADFarbwWnNfvCQp5+g+6lcc81F94l2X4xR3XeTkjGpMLq61yyygFRryC6LrEMygQXZq2CD+eILEdwZbhhPPCd2qBPfQ5HkDzl6iMEON+SYwwYYYtjABw/InCMFC27IAo4Y4FjYZdso0ZMSxhbLk5I+JXkkMN0M8dlQNyMrsjg4GE1ui7AiVVo6J7C4gVtuf2gEmGD4ImtjC6AAuXZAYVwtbGIjmzGIoQtTXGISjJgEJ0whi1y0Ij4DAV5+hgeHMoAsBf1xwAbK4Dcb2CAGK2RhCwMXg2DFQAYzlIEKbCiDFKgg/00qmMFNctAhzXDoQzwxAhEmlQQixCtzQbECjDp3lc+Bzl0yUpEVovAVLpjFDT1KS78oMwc+8MGLdsHDwO4iMELgzkm6GcxsZqOf3/1uIANhhJdygAUYGMIPoPkM3qJFgxl0gAYx6EEZ3LCIPiSiZn3CGSUao588ScJmttFNItRHKPZJpg9CI1rRlEO/HEVhUksTmdN88IMykAIYvsAaMarmC1jGMpZZg6XWrva1YbhybK5cVSomYYlLiMIY08hGM1oBKw4uRg4/OEMZfPAZ6jUADjdIQcdicIMb5ECb28RmN7OZg2t6E5s0JOcMcKJNyWVmJ0ZYQhF/8pMkGsVER//BSueW4pSpSCV0npuKFbTABYD6CEhdHNLQ7FCHOvQrDnEY2B3k0gc0OokwgIGEJNyIpzhucBQM6cQhykCGMmTBDT9QlgcmgLcJIOgCJaBBDkQqqEUYAm3e00TMGDO+2lAiZ03C3SUJdSg3JUpRjTrDGUCZI9NFZwfYzIIPmkodO7yCF7wghjCMMQxZypIXstQaK7s2DLAykGzEiOAkTtGMbHCjGsYghUB+B4o63KEOYNDBICniAz9Er3k3kKEMZvDXv9LwrzRoKTYDS0NuzXAGhP0hTnrAPx8QcQmThQ4RQpQEeZroXZ8DQ1Ja5BTPRREq/gQoF3wEB9X1q19aGpr/XPHwWthu0g5+EEQaAdUISDTsl7/MhK1e9apQiIJtbRXFKDLBhxv0wAMp1GFKW9IBAu1ABzkIqdD+QAY7aCJnOuXdRXWaM0gsome++dkfwnjeThrHDWsw6haOqoUl2GtpOrjBD3xgvTvmAAaZsIUtYEkMrGZVwFvlqtbA2sBTKSMYrvhEKZoRjnBkAxqtIMUcDyIIMSDBClbQQQcmkAVJjAmGMfghZLmVg29yMwd+vYEMbOBiGWQzBTKIAWF1MN3HQpYnk6WsEyx7uXnSU15aER2LPJtP0BaZRVARQ5PD0AWAqgEtaRmq8voll4PGFQ9xgC0e7uBQQxCCEIlQBEUf/1FRSfC2MZz47UJEYYq2bbRiZDDTCh2QEZMMYKUNOCnesoCmPlhmEXuiDU0JrSfw2gw3hyCvoc4rVNSut71aiEKloxBfbU23vi1uanJTQAZV5GKrXRMwLKd6agIT2MDDaOAuiXGLT8SiGuKIsCyK+7b46EEPdVjqDHFXJhEbT5s50UwW/pwFQw7ULf7ywyAQAZgoaaITdyjDEm58Y+m883JImGwWpKBtzA3lKjRaF4ymAhWpdJazUGF3k6HMBTUMVL3JU94X49eHOHSFDXHQgyD04CY/hBkRZR7MIx4xCYRf4hJrZrMnBCLcN5NC4mwTBSTwiAULDEABFWHAAZrFZ/8H4NANK9TeIBIxiJvRRhJ7YvltcsYImPdsEIXCSxgNOu+inoHSlW4nO+sl3bqiuMU3+MkMyuQBSNhC1F07talRjWqnezVrYjUGMqxujGIooxexlgY3moEKuL2NE6FYQx00Y4ZGoOK4XSrEoA6Rtkk0BlbFNQUqVOGKV7zCFroARt/7jqruJAILl762trIdr8le0QnwVKK5kEIjc09FdFAJAxgqD4YchSUsW4hUFzgfFjB0QQ2jj3cXFSUHOFDmy3O4gxocEAAADKADUsCDrgVx+zQK5k9/+A0g6ECHQqjtt3NnmymGC/HpeaABB2hQRxywcQZcQAeEcyhk1DcJSvz/0hJ9Slv2X36bnh1CL7+BDHrnwCU45JwMZNjCpdt5bSNcm7DYEroPZLBiGgDLFLnYxVV7sYteCEABDMBdAMACLEAC84VeGIZiaMBjeEAILIYHZIZiOIVSgAVR8ATjCy5bcYM5GIRMUAVd0IW9G0ETHMG+4wW/W8G+CxsFCoYWxBphOA9oeAUt0IExMYIhGIJ4iRce7METoZHKGaUpeLIS+SzLCwMn64InE4MuKAt8QYOQKgM06BEzQAPRizLSSw7kGBKEqgO70AMHAAAyLMMEaAE1EITzOR9JSIRGsIxDAATfwwEc4AAPwAFACCZPkDhSQIW6MwVTuLtWUAVJoIiQ/3g+BViAAzCAO6OIakmTtZADRjAEmEsbSYI7l7uNmFufthsOm7OD85MDIBFFMygDLNC8KIi/a1vFG8OWHtgmbdIBDMAAFbCEYFCGZViGWoiFWagFXMCFWPDFX/hFXJiFW8gFWiDGX5hAZmjGaIgGaqAGaZCGaLQGbXCGU4gEbdytmoEEVyhBYDgVv3vBYHg6VAMgYFBBclQgYWhAUEmGSiACHEwBHdxBe7THHpSXHhQXJ5gC6JgCgPRHdFOKMCjIJ0MaKOMRNFhIhmzIhYQ30lMDLkSOL6wDPSCEFShDjUwAECgBNlCER1AEyDgNO4Ao3+MAlOQAHDAWDiCDTHAbP/8cBYn7Q1RohVBIg2dRgATQyZLQCGeZiBwgGTf4C5irxKLsk6NkhPDDpJEMDvNTnrZ4AyjMgrC4NFVkRVaExW1aKRVog1ZoBmZwBgg8BmRwxmeMBmdghml4BlgYhmiohmmgBnFAh3NAB3RwB7x0h3NoB708B3IIB3HIhlnQxkjIhEuIEkhQx3LkhRfUqqnyha2KTMiUJXZkR2IoBmM4D11YA3kMlnrEyh2MF6ZAgh+znCTwx38MyM+qgg0rSISEMoeMTYeESDXogolcgzioSEHAAwPQSDJEAAnIgBKwArliKCwDEzigAw9ASQZISQYYAOZLgTuwhIUILreROE+QhAn/UD4D2LgJyYgNgAFlkYO8SIQ/mISeKcpDSMr0XEpDEQ7zmovzE5I3AJKx+CjNez+sBLq66iYb+KZfEZZLCAdyQAdxEIdzMIe95Et9eAdy8AbAPIZZkIZt6IZoGAd+yFB72NANnQcPdYdxsMtvOFBt+IVLiISFi5lRiEzGdMGriaUXFaCsEgYBwhoZtKWpwUxlaIZOyAIioAEdopF73EEdCE1y04ofE5EhDEiAbKLPac0wGD2k4QLZrFI0iEjmmMg4iB+EEoQVCADYK0MCiIAHgIAMEIE1+DfikIM2aIMvgIGPYM4BGIAAGAADOAkdIARL+J1X4YSzsQAP6EkFMAAG/yiQDXCA6PmVyZiDP0CENiiE9dRE9lxP92xK4bC585uDtiAZkGI/UNJPnsBKwvImbeqA6KHDZUCHd1iHdogHeZgHepCHdrAHc+iGbiCHaICFaBhRagCHe6gHevgHf7gHYp2HdmiHedAHd0CHcajLuRQHZPgEFL0EuMmqW7JRGi21WTKgrcmlqdElY1AGXpADM9ABG0qBGdmKIf1BrMjHzNoweEWKpoBXdDnIgOQCZINCfOGRHUkDKUXI2+RSPZgA2AtTAHiABaiADMgAIegCPNACH3ADO3DTlWy+lKTTALgABzCAASgAk2CAFBiExbAENssEGGgAD7CAjFCACSjUn//8ATnALjDigzqCVO5Tz01cyvWxVPchDlA8vy0iGfcKi8kioqucvxqgAXG6gZKiw0gIh3eQh3hwVXiIB3y4h1r1BnK4Blg4hm8Ah2i8h1b9h3wYVg9tB3NQ0Hd4h3Fo1roch3dAB2aQ1ksYhVWYpa0ptQTEWwTyVqqpGmUQhR7IAnNNE3hRV3wcsnQNNyayAnQpkaqAUtfsgnsVC7K4T341C3/lgte0TS7kUjY4ADAFUwBAgAd4ABBQ2H2Lgx0A1A1gAL/xiANIyQMgQweQgAKQAAhQgAIAADBVAB1ABEkaBU9ghBhwlglQ2ZSiFs4Yi+QhA41Zzz9IT5jbDZ29Xqb/HEk3kQufBcVIKwP3+lQeO1pAqgFtEidAvUM6wAFceAd+wId6uAdYxVpquAZa+4Vf+IZx+IZocId2kId8CGBjPdZ2OIe6tEt3WFsGbVB0kIZS+ARTeAUAC6thEIYKruC8zdZaQiCt+VZdSgZfAITMAFIzUVytMNIjZYoneCcT2TASceF4dVyDdDJ/nAKAYsgdwVweSYPOzdLPRSg1KICOFQABCIDTrQAIAAEX4IJ9K4EUQAk77LiPZU4yDIAMCIACIIABWIDdxdg6dQAdeISBSIQR4rMGuCZjiYE2kIMcOK/p/QNGgFRAWQTcSATs1Vnym7mefbQvmgPjSIOcaz8e/yvaVvwrbvJPZ/EbOgQEatCHfbAHfYjkd+gGaoAwZsAFa3iHc6CGcXBkfvAHf+AHDl1bu1TVd1BWfeCHdnBkfbDLbMCFU7gFcHWgqgErDS41Du5gAAPXZDAFG/iBLIAmDxgyq0BhxQ2KxXMCeD2XEnnhF45hg7SCf7zhhbTC+9RhN2iOzp1IhJKCBUgAAjAAAUCACqgADaiAEHABPGADIuACGVguDug46JzdeB7d1wuAb+7YOV2AjR3dAWgAFcCDSiAEDyuQ5O2BNv3lNpgMRpjetztK3WiS8FNK7C2UQbGM7d3eoVGt9VIOSks8wqsrQPKB872BFLKB5L3DH1hfWP8w5bWN22uwhnCohl+YBrvEhm+IW3fYB57eh3XAy7Vt0Jc+5X2YhwzdB6FGB26YhmrYhV+8BaiOaqmeaqnOhVyAaqvO6v7bpa4Bhj/AApfCiSyox3xMV6WQFyvwiW3LrGd+3MZVQjEIg3J5MipdyJDK18xdL4BFDh9GDjiIAxlYgCwmAHyGAAkAAcNegefYATx4AzI42QOg05MwlgEgQwW4gABQAAfYSTYogQUwgBJIAgEYgCKeU0YUAjyQASK4FhuYA+wChOlVz7Rp6PWEud6gaOolFDzWi7wAKp9lFPUqA4/mOUKOPxvzphQyZGx6RTqkg2W4hmuIRmmIaWmYhl//QAZyIIdvoIYK9QacttW2bVai5ullTWB7IOC2PVD1DodeUMBe4IX3RrUDLMBj1Gr6JsZfLEDMLIZfaO9gUAUz+KEsEOsP+cEjFU2sSOt3YuvGlVyDVEIIZ6KCpNI0kMK7JgvNBRK+RpoN19IkKIEGSIAEMAAIqADddYAICG02iMofqGfYa04PYADf1bMBmIAJ0OwLWICNU4AwKIACCIDRJmIDKABGzIALSII6WAM4uINC6JPozRmEq+06TgRJVU9Ivd7fEJRDCSM3kat+gYM0cJRPdT/95KaTVu4fQjEbwIFIeIZqgEtmiAZpcAYJhFpxkAZssIa0qgZriMZw6AZx/yjQd+hpe3gHoC7gcwjv9BaHbwArAdsFc+SF+T7AARRA/C0GZDgG/h6GYDDeO/KWIOoJE07Xdg0KFn5mek1C5iC9B3/cgrSCgEqDUpxCLbLPHl4DDudCGuACGtDYBbiAFegA4cSQEtiBLNAUOI3sOqVi3z2BBchsBrAhFSiQBNCBZwdyOiViAfBxAthJB1CBKJgDSsQNO+C9Jo/ySFW0Rahy3L7j8YKMjMYyP1YdozGqnRvfGzPzGTCs+XscbMoBOuCFbMiGZ1iGZyj4mhYHbuAGbbCGN19LZ0jLaXhLbpjLQd8HvDTgjEdQcRgHcPj4j29AkR8bsCr5koelSxd5/P9d+ZVnBqs7hl8YBluwARpwgiggNiwY6xRuVxNG5hEhkceVYcuzgilAyGhuzbiGddOS9WvGcH3Nkb3e6/jpgjgQhEYQhBqaARWoKymIg66HAzOAAQ9QiQFgADoU3dFNgAbg2AJwgAs4AH7ugCKu023X9izuWCI3gAagAT/ArUFwk0JQtNkGr6JUNPWs7TvmC0vd3jpwgzTgUqMBpXtXRY8p6W6SLmwpvBgwhGR4BmLwhR3FukwvS2dQBrCZTF6ghVvYhWJwhmwI9HNwBwU1YLtMdEUHeXCwukx/QAccS98ny2VoxrB0hmekxvrtBgiNsGwghRQwounSjB7Agp7YJ2L/bgKfdwJUP4oqInomZY7Ncdykh8gsyuGmH4so2IIzmMjwTf/4+bI/SIRH6ATjKgM4kIQv64MuqANDaIPllOIDwAGAoMNhQIAAAA4CMJABQoEBCQrQKBBgAMECCwgucGCA4oGNBhQomKCjzyBDiRoxOsRIEqSWjF5CmtTS5cuaKQ/hPLRoEU5Dgwb9CfqnD585RuvUgbNmzZktW7pA1RJliREfP374yJrjxo0eOb7m6LFjh4wUhlS5kkXMWDFkuH5JQ8aqFClRo0ahMjVKlKlWwpxxE4fO3bh17dadS3xu3DhxjMF96+ZscrRo0qZNs2bt2jVt3D6HCy1OHLnS6N6h/36nb/Xqd+jEVaMTg4gQHT3IYOnhAwmSJr5/9/5dpcoTK1OcTLGifHnx4VWUH3eCfMqUMFaKh8kehgt3Lma+p8kivgx58lq2nFnKtOmZ9mvq3PFjaJGlTqNeAbOFvxOkR4QGQcIIGRYwwMABHNABCAMUGYRQQQRIsAABGSxQkAITMaDAACEdEMABIFEUogEFKLDBGoYgckhMk7AkEyMrTiJTgDbRiNNOPf30R45/+MGHj3fcUcdS7Z0BVRdSTVUVVlpt9ZVXYN2wgQc2cGKKLL4M8wszzByzjDCt6KKKKXqpghYqoZhCCzLTiPOOO+u48yZjiTE2GmTddFOannui0/+nn+iQ8+dpqK22zz78IMrPPvq4Iw4uHsBAmw4+ZJHbbr9h2lsVvg0HHXXLWWGdc2CAcR11p1IXxhNPaJddd1xA9V0WZZBBRnllOOUUkbqmB58fAFLCiSiuEJNMMsQQ40onmOxESSR0EFggHQnicABBBR3UIAABLABBQQZYC1JBB1g7gLXWFmCAAAMQMMBGBziwRCOZWBIjjPbaOxONNul04yE/lZSjHwP3AWRS6iF8pFRLiCfdDjqEBVYONnB1AwcWbCBHKLwMUwwzkxXTiyypgJlKXaagZQoppsDyizPbnGOYO4eZA8445pwjDjjifBNZN4IC7Wdipv2pmqGJImr/qD7ocAMIDJEKkQTEPfSgQ3C+8fYEEk8Q14QVz7Wq3HPDceqcFV2E0YUYUFWnXBhiaCdFd0d2YUYUZWhRxnflmZH3FmmcYcYWZqwBxx1/EIJIsKKooouxzQSjnyiYPLJIIYX8wEEDDCBIRySRAILDggUJoO22BpnrobWqExQigxIJIEABpZsbUgpzVJJJizFeEqPvMs6oU00qvcRTT4cgkiNQdxQcJBzPKxXHGkZKJd5UOthGtVcxcH9DDhZwICUpxAzzVjTMuHWLK47TsnJfrqDSCiuxaEnNN+e0k/9h49jszjmQfcMb3fAGa/SRmgMikBykCRShDOWOd5yjZ99A/w2gnEGHH8jACUlIwg6M4EEjWI03SHCCcZ7gBBMaRzmYqgIYvFAFKnghhlSYYafGph0knM1IatihGoyEth9W4Ty5MsMb0vAGM6BBb2VwwxzsQJJExKRKsgiGsZKhC/iFghKJGMQd6IAD8DUAB58bI+g4YKCCoBEh2QLA6gbQAI6QyyEFSIC7CGAAAzxkROlKgAJScAdKZCITl/AEISdBrxhJwhKS2BcjeOKvfwEMKH1oHpCCJL3pDekMC1tCFK5HA+wN4Qg36N4oY5ACGPTgB6RoxvlgEQ1nIEMZyOJFMHxBi1vYwhdT5AUvelEMZ1gjHOQ4h5vcoY/FLKYdAMTTz//eoSdxhCaa4fAGN7ShDWlcZhrVoIY49MEPe9jjHdQ4Bpcqs4xiXAIHN8igBnfghCVQRYQmlE50ppOqJjCBCTOUIQxj6M8vkGo4YIDbdXKoQx+m6m1hCOhwtIBENEA0omZgIh/+YIhGJNITaeIFsoLxClWgYhSaWAQX7fADD3CAA5EoxSda+oln4eCLZ0SjQbR1rQ+F6FwHSBcBepoRBxBgj+0KlwPOYAlCEjKQLFKkJSyhL34ZDycAg+QgKNm8OlzyYEvZglTO8AUmHCGsQ7jBEMpa1op5IAY3IAMgdlENZtRiTc5oRjOSYYxn2NUYxsgFL4PBC2EM4xnT0MZocCb/NHMwxhyRWawzwjENZCDjGMX4RS+G0Ytd7OIXu5gFLGIRi1q85Rre9Ec4o/GLX+BiGcgoBi0umAIZjCUrsjUCEjYondvi9lRfm+E+edtPL3zhC14gFakUWtC3+dCHoGqVc/IW0ecu8Q1z4MMgoCgJToxCFa/QBXddAdJRdGIRQ7HDBWP6iVOUAr2lgCkOUEqg1Z0ujdvqyERyaq2HCMAAEHgAfhewgHSRyAEHYIAfVeQJmdQrRk6VBEto0sioSlWqPynYJAfmB0u+JylK0WQU2hPc4DLBrKEUcQpScIM2/OAT1ciGNCrjjGUoQxl0nSUvuMtdYvxVGdPIRjgcc44//43mfuNg5jd2YYxq9GIWudiFLXKRC1vQwha8yAUtYDELW9gis9d4hz/yMQ99mNYYxKBrMkRhgx6YUgc7kK1siUCEJEwnt6dCWwt9u08v/BbPLCSVGOAWhq1lx4c8RJt1QlXo5pbhuRB9QxYmSlGL/iERhvTEKEyBiu+GQhOPAAofLvgDQMACFp/7BCw+AQgvtjelmysXg3J6oYmQK47uGoAAMvKQdEHgvxvJwAQmsIAPKcADfzjEJC7BiExM4tgMbvCMHpmTnEyYJIMQhIWDBB+kHKyrQ8qnPsN6BLCW1Qim9J4c6MCLbKAbfcuga12LRQxdAGO7r7AFd4XRi2ZkQ/8b3xjNj9ERwZ79rxuR8UUwngENWuiixtzFso1t0Yr16SIYxMgGl/+xj3dEg+C6ePcrBsEVGqhANz7AgnjEQwTegKqgy9FOnX/bzzxTgYXa6fOfsRPoKUClVWFbThAfGtE3MLo8bpBuUeQzn0RqohOh6EQnOFGJRBAF1YBArUBgUIiXTivVKb2YBSbgOopkyEH1jWMAEuCABKCdABBwwK8NsIALOCBCBSCXBU7pOd81FZEzmdGDnw3tqt7hJ4Kgth8oWcmDoYcpX/D2t8GazyMMwQgqkIEKbjCrSDRjGpM9xjGMIeNjJeMZ+aG3Ll7xClfQQha7WEY0ttGzcSTmHT3/64ZjfKYLLEMjGa34aJn0Al5MPB0RlXhEJz7hDHR0+R7o+MWzbFCGSo1SBR5IAdVGLh4pSOHkOAyVcla1KlDxNoYf9q0/XQiGVhHUbdZBlfp13v0mREHRESV5yaObBTSkwQ1ymK4fENGIRjyCJFQCSZ3aD+AAHbSMQFhAA3DAAZ4aqqkaKk2AgRRAQ6xOgxSEu3TIADhAA/jXHOVaAyTAAVyABKQdRQTb1uFAIfTOJTRVgjGbS+xEVEUVFyEOIQwewUxSJRkMHHjYF3jYEXwBFTReWBlBCqhACuSAD5TBD6QCMZQC67WFmBFDMFCRFerHdrnCFtKCLwgDM1QDN9xP/2Lowzj4zGhgQzfMgRuUgRzogiRswA14gAd0QAdgQAlGQEZIwAXkQBscAzrwAz34gzswwzLwQhukQAnIAOVJ3wZQDRZgRRY4gRTcVnIUmvctF5710/jZWQwNFEFlh59lR8q5DajQXKFZgRbIH0SV3Hh8Bw0sIcnpjRlYWElgFCMAQuj8AB3MD7Qg4QVYAPjQQR+gGA6k1A/AwOYUiAKwGoOUCxpZRAJkyABIQAcugNtBQK4RwLpsyASEkUAgSO8YUt6xSAzWhCPNIEk9ESL8xyBYWOHtoLX5IBCmxxkwwRlQAbdB3hGW2AzkQAzAAB+0wik4QzVI1jAYg7FI3Jg5nP8peFfjSFkw/IU1eIM44A8EQYbriQOeOEAHMkAPrAIWNEBHduBIOkCuSUAGnMAdAAIziAM/+MM9nEM3hEM1BAMfyEAMgFwKeMAGYMFP0p/cUAdycJ+hhWKfiUFwld8/CZc/fWL67ZxRIuUoXofOBRoXyN+s3MosLmJXyGIZ2MEc/EqksUQhHAKK0cEpwAIgIKEVJGEMBKMRwIEctEFMAYIHNMDmNMAGfAEHaMjXEUS2TISGLEA1XqMBXADcSQSsKeMFMSAM0AEkBNIL+g6znWO/YGZ17QQ7RpI7DgwPAokP5iNYedUMgdsQTN9rzcAMoNklKEM1VEM0dN6YKYMxSFz/LiSDflyaKSQDNLSCLMiCMDyDvp1DnPgPkW0kBJRAYnaAIADDHSBhCXRABoiACIBABoAAD7CBIVwCM6DDofCDPpBDOERDNjTDH7gBHORGWGCBbGHBEowQbhWH1qycdljBnX0YJwoXFRSXn7mNKCpUgKKfoSHl2qiB/KVBgiqoGzCo3HRB4TQRH1CUSTyCJXDCJERCe+HAJ5RCGzDABYjADKSAGyzgBWRAB3gADuSiGRUIA+DAIazoglzLGq1R2bHdAtRaNkLANsoOAzagAjbgD7DgIVVmgxWP3z3bTyBPOwLMZx7eta3HV42YWUFeD2DBV9wA9tBADAACNGQDN5Cn/8HRlTIkA7s9Q+kBg+Mkw+mpgi3gGznow6GA00xuwzYIXHXWABtwgQpUAjAgQgxgjwuwwAnwAAiIAA/gASNEgnd606IIBmlUQyG0QRucQRZ8RSvCEw7BmQYVh8rpXAstpfg15X4O1FKcolX6GYAeZYEi5YE+lxEpaIJ+hxlwx4PCwRzUgR1MlFgiAiRYgiYUm9NsaIdaQAeswAqkQBYgIQ+0QAlsAAfsojESCAcAAug8oDHSFOlgy7YIAAIUAAF0JAQkQOwIwAEEYwOyKAdAJiD4qiXQC7NRggzmBIRFGCJwpmc6qcHAxx1sWD4egVeBFeSNFSRixVjowA38wCl8Kf9sNsMz1JWYthswSKwuQAM0cJd2yQJgGE07+I84bAM2YMM2nIAS6CkRyEAWYIKf6oATzIAQhAERhCgX9IGiMsM7HMrF5clr9AIZtEGtXGlWsCI8ec2mnlD3tR9Shqr4nUEMeZUX9JkamOpUFujb9Nn5od+phsEOdcegTU9yKUwXpEfhwEEdfAcc9IGK/ColeAIpXAIgXEIp0AES6qkMzAEaEEEguIAIqEAHSAkMzCG0vlQuTsvniE5FCEBP8aiDROPZZSADEIiKck5KwQAgFMLv6B0kxGvf2QiSDsIhJEIiUNVPEAxoOk9pUoGH+esR3MZV+MDDfMUuls8pQEMz0ML/+jRD7hHDxNqYvI1CJWCCKeTCMkzDYKwDnMwkNnDGC4xBEagBF8RBHEiBJiTDIxCBHsSB9dIAF/xKJFyCM9isokTQa1xDhtJBz1rK/aFBFnSS15wKCaXcqoqBqDYlcHkVEAoX3KgBqyLlGtBc1Vrt1bYKVGztDnmtD2nBeSzF8/ArHNhB5yYSJwxSLhDDLdRCLBSCB5TBHfykHzgBF7DBsVbnCnRACUyAlAACS31OLr4U6ECLAowIAmxjTwmAg6Bd6WCItNBB5DYg5U5Cgv0O5sogvSLp5ybCvYru6PLgwRCJ6eaTrVjqDaym91wFIHDAJxjLJGTBG5ieJqjC0oXC/yZgAiqAwiZsAijowR10wivQgjNoAznAHp10wzVgwxgogiMEgiKQcSUowipAwyg8AigAstKBlOppw/fuw5CFAzf8wrSULxaQAQhhZfo6qBYYSXXY58whLXDl5yY3Lf7uUKoijBjwGXH9L9UGWgEbcBdwBw+pwXikJwP3Qa5a1ItYqCiACRXFGC+QwiT8ARyQgR9kBx7MAA2wAAvk7QpcAN9aHYe6FEuZWgr3QIYYQE/NzjYGwOFORAYyowUIRIGkVBvwwSG8YIKtCCWYc7w2G+fiBOh25rQRHpBQkobVY2k2MRlkwQ/kwGrKgA2k6OSaAjAkAyesgBQ4wiasgr0mgv8j1LEjOIIgEIIfE0IiWIIpQIM2eYNioMM3hOwqrILp2ZjEAnQ2WBFAp6nElik3jJY9jAM1tBj5/gBuJIkqc0EWcEEPUbKRUC2APqX8fhhwiR+ePe0na0coi7Io85mqZgeqJNcB3/SrcEfJvbITOdEgIMIi+ConeEIrAEOxyJjBQYMsFAIZ9IEYPEEfIKEQ8IALkEAR6G0MoJSKnhcuzAIKj9ol0IEHMEBDjEjsIMB/bau5HIAHdDPn4IAdsGsnkOPvnPM5t4Sz/cvfdSYOUhuFxbMPbpjp1kqiSQEHcUVPjqgi3cUY7MEdk7Ee4AEbBEIgbEIgsIEeKAIeEAIOSsL/K5RpNXgDYxDGx4I0SFeRxOIb6OWuST9DOOiDP/yDPZyDNDBDLvxAG9ClG2jBEACaKksB/qUBrOD0qZIyqSTtT/s0FQQ1Aec0q5Jy1VLlUN6WwjD1ATt1d2TByH2HG+zr4RiCigCSKaSCLQD0MjhDNMDm7LLCJRyCWOeADghBC/BAWrPACuSkDZTYD0BCK8h1KThz4NIBDLzXNMvO7JSOgwQ2hnvzDxh2JiD2IsWEJfSOObcEOh+p331u6A5CbMd2DvrBUFAS9Fw2kegNd2BfVmzABljABagBHsQBHgQCFIi2Gph2a1eCHii0IPiudOEBKoSULjSDM1zDN7zxkBnL/25LbLEYi5c2AzHw1VYnwzIQt3H7Q3IjwyXEAK24wRksgQ6AwXCszQGnwZHQnNuUynYT11KG36gCNYHmdEA9pSgvFNaGwVBSx5F00np3QRRIgaRTOiX6gA5kwQGvgbUFnkoAkiiggivYAjEog2BVA2ac+jMQwyXYAfcggRAowRgowQms5gzcARrsAA2QgRxcXaip5Xo9ixchY0foNQFk63wNWOTSQSEwQifoToMpNjrrywz63SJ8bmeyo4zjoIXxiOFp2JD8Da1SYnWXAcYEeQkQgiPkwR5cwbozLx7ogSCsAjAIgmtjgiL4gB8oAiisQiOMAjGwXjdARnGCg+m9wv8qlEnCo8J2SdkzPEMrpALG/sI1nANM8sM7XMMskEEMMOgSC9cXiDILbUGdM9RwxNx+Anr4+RMV5KdTjkpAza8MVcHaLHoOqQHOQcV1FEcTOAfP+8b5nZ/XlAoS0NYSWIEYZFh8xPgiPMKno4Is8IIxNOyVWwZmYEYuXAIf9EAdUicFiIAESICIysAGSB6k0AGHwsJ6nVpMedF7XeDYwZE3Q+bl0AsmjPMkLDZjT7vxAMx/aHviGPHAuOMOVvZSOHoamEHJZcU9J/4S7EAcAPIY5EEe1LEeBAIhKMK+Y4IgUE4dNwIhgLFB8xUzUKRqrAbTLV3SdQIojEIooIkokAL/K8iYLIhCKpzCLGBDO1i8PljDJ+CACizxD+7ny/FWPhU/ymtiJzIl8rN88psmP/FWFaSN1+J8F4BKz/O8c7BQFfRGnctTqCB9HPiKQyvCIxhS7buCBMcY1Ve9NDh8MpDCD2xAMpfACohAB8yACryBB8BBDCjiHAIEnU+lPgECRAchDAsMGB4Y8PBAxAMMOFSsSAdQIUiZOGKylMkSJUqTRJY0CYkRo0UrFyVKRAhmTEQzCQ2yOUiQH519+tzxWadOnDVrunRxk6ZMlqQ/yuTI4aMMFzaPHDnaFCiPok2KAukhpMgqqEpbNxFyVOmRKl2pfEnLJu6dPn2WIH20xKlT/6dQoUaZchWL1axfz5T5+vULmz1/+fi9i0YHRoozXyhXpuLFCxXNVJh07ryZc2bNoi+TLj1ZNGYvlE2Xxry5Spiis2kXtXLbSpMqTXhX8d27ChLdTZ4keWIlDPIwYtbUudPHj6CajCx5ItXKFq9dw5Ata+YsWjRny541u3WJjIUUKkqoYCNjCg04ZW7smFGm4o9LkQoBikSHgwYYaIBABhQ4QAEGJqrIAxxgwCGjQy7JhBOQ7BqJJJM0hAQlllZyaaaZEgkxJkIEyckPnnxaESih1nDDDTOyMEPGMmRUagka1MAjj0D22MORVUDZYxNQQGlkk1VWUUWVslRZ5ay9bP9RZppw3onrFVdeecUWYLz0kphklCFGGWOOQeaZbKyJBpx2/vlnH3JwcdCDySqrTLXNPtssz8yYKM211li7bFDQSrtTNTBkq6225G7zbTfdIhUuON2eeMKJ48LYNDnm4ADquTv+OGSSTEQxhZVTYsHFl2KUWcaZ75rxrhleCvohBh30WI4NLNxAI444CIkBhjY4OYQOCQHkwAILGpjAWQEZsgiHahE6hBNPPOnEQpAw1BBcSjpcBBIPPQQRJptM1CnFnkK9o8U43JgjRjPcKKMMLJhKo4so2BAEkzHy2COQTTAJZBVdlKwElFFUYXiTIhXRShVXckEmGrj0SYbjjpP/aebjZqBRppnykDl5mWm0GUedf/zRh5tIcPBggzPstHky1zTrjDTVXhvN59ZAw+wLLz4LujKbi/5CjKY5XU6Mpzm1Aoyqq/6tCeGy9u1SJ5yYoqjlNmVuqObgsKOPQxiZRBNPMvmEFFZk6YUYY7yDdbxmlFFGFlEggaNpPbSYY0c8/FAhBj5SmcQDD+ggAwYYKrJgA2cXmrZaHOjQHBBPWkFlFFFCsoR0SyYJKdwNVyrX3ERYGrGmQRBZl93aewKqjk/phRFffM1IKgsj1JAukDGugKIIPSaeuIgxktcjEUwwcSSQqhSRhJRdnOHmypCb+R78Z8R/Bhrx9V5mGWai//mmHX8aQ4aOGDywAOf6zwB06KGJzuznPA09AmiZOcKfgkY0PHkBDE2LGtQWKDWqJfBqk+INEqoAhuN4bQpgExvUxgaHKJwBDn0YFSQmwYhIXAJurKBFLobxKmc4gxkvrMY0oEEMTfRBDIqIgx7U8C8/yA8QogBE45q1ARjEAIkxYNblKmIthPygEKnIhSxUYQpNjI50GUpdSTgEiUd88RHmet2IRDS7E53Idj8Bih3sIAc3wsiNaUgDjHQwgxUEAg9CcIEIhDAkEayADULgARSmUpbqEcwReCCEJ2TRjGpwgxzhE181njEN80Hje+Ur2STFcQ5+6EMcpfhBCmDQAP832M9ml9kZAfWXmaIZCjR/0lP+gFa0/RmwaFUbWwMbqAY1dCEMFYzgboKDBCQMwVKYwuAUlqOpTSFnDTTQwQdDOIhD8GGEl7BOKnYhDLt9RzzVECcleZGJQ/iAC1EQlhE8AINIiCJ+KujABiaQAhvEgAxnkJ9FGmStg9BhErLQhS1coQpPXJESpKvEFkXSRQ5RQhKS+CKHGtE6l6DrJjZhl7tW1EY5tNENbpQDGWREhhuogAubcIQeReCCIghhEwS7QhGuMAY9OEI6ewACkBzhB0uYwhfNyEY2oFE+o3KjGkXdpPgwmVTxTUNj75gGIHoAg/kp7Qv109PR+GRLVcr/0lCemWVqsoo0ROEJDLHhYKc45cuiCNM3ETTmEJBZzCQk4WvAFIMxj2OF44ghBtI0AhncgLY2yCFta+OEKGyRnWAYo2TTGOc4oSEMV3CiDTHwww2OeAlR9MAG7CnBBmLQAw/YgAw/qFYTEWKQSPhHFLQYKEFF4QksVgJ1DG0oh8A40Yp+6KJkTJdGB7FRd/WhDiG1wxzeKIcywIGkMZJCHJzABkecwAU8GMMeVpEHIDQvD0pQhB5uikdMsMEPmPBEMMpTC48FgxjCyIUvcgGMgepCF8BwBSzMFItfcAMd+njHLwpxhzWoFpX3K+Bq/ARWJgRtq0cYICtdQ5n71VJp/6qpjNPGtoYGPm0KTmia1SL1G2Pqxq9OwOsU1CAGK7j4CWIjGxzgAKNP8WRUKZHEXayDCos9dlbOeIY0xpmNajSjFXQoBAw2kAJKMCIFE7iAAxjgABXsIAXNSkG1GoQQL9MhEpMwhS1oIYvPkSIUmiBJRCVBCekxtIviQolKzoUIQ9yZJhktrkZTtKI+sNGjIp3DHGpMYzdkYQdEYMN496AIJRQBCiegwHeh0KM9jCEQihBEI0BnX1e4QhSKS4UpSF3bUYyiVJloREoucYlT4CKG2hAHXMJREAP/oAduWIP9AuUzsLbyZ7EczReAFsAF23I1G1Zg2cLg4QZ2YQojjv/gcCbImycgwWt5ddSlnmmFLpyhdzaC4xywWQi11WWxplDFK3IhDDJFVpzWIPIzhpEKO5yWE1DWQQmepQI1OIELNIDBD9pQLYO09iCR8FwuylxFUaTZEmxus27lzAg2d/G3K7HznQ1BiDzfpHZ99gkb+QDojxKaximfQxpoAAryKsF4e/AuCFxwvIFZxRGKwEQlODYKVHACE3bIgiROl4mIRSwniSgERiIRCVxEAxuzRsc50PEOZgCiJ1YAra7tR+xeG01nC4ZlhcNKwAICCpcKVDuHrQC2DJI4UlnTmjHpvkxg+pXbjzpDF35HIxqVAUZzEKHsDnEIdJ+qFa+gBS//yAQeaUwjGpCXRjOMUYpDnIIRHhiEEy5QAh0A/IdkMDdCmm6QQvwnEqmghS3MjApS1PaKlZDoI7j40No3lBEYmjMjDM8hlbjkQ4fQM47/8AeeHJ8ngLbDHWo8h9x91A1YmAEb8MCGS+cBFMBwBBCuAArqVUWlEUPFulHRiUao4a5I2kQlKgH+RPzBP594ujfGcY5xgGMc5jgHOchRCqzXYQlw5ZRQiU9aY8F8ZuyKbav2JAELkAqqJmqUA+8uJYMyCK4miO4wcAiM6WsqcNsuBTnEAA6MIuUMDUaUqw8GwRByTBIygS9IrRVoYTuQIYbCQzxiyBmU4RmS7BCMoASG/+AJiEAK6iBxDOISSoEgmq70LmH1zCwVSOH1PIETLEH2HsGhUsL25MyhMETiJMH3WmLjWkfPjE+E/mAQio+jlo/G2Ii57MAM5iAO2OCmFAEP9gAUoIR6AkEPiaQqGuERQsEUTg0R1IALWCADrkIrMOERSMcTYuEYrKHq9oEfzCH/zKEdLhEdro4P6qALdOAHcmAA7edn9gTZ8uTXFrABxUo0xGqrVkk30upSYrGvKnAK4iqteAMXcZHusA3vbiMMrk04Eog5SBDlSvAEz6YPsGmEdowTsoUUVOUWhsFuYOUZXuiFLKkXTIEPvCAMkMCeeqAHDsEgYgEZYIEVkFCIAP+BFHiBoFrhCUWhtqYQouJMC7NQC0ViEvJxElACErxQJezsDOsgBW2CJ6wpo4rPJsjw+OAFbZJR+eZgDeIAFBDRR3pkegrmKgIBE0YBFFBhFTpBFTLBD2pgBjIgAhzhK7zwElhBGbKh6vRBEv3BHy6xHNahHeZh/z6BDoYiCmwgB35AaYISNThDrF5JZ1ixAXcGFf1EwiZslTyDCSSFOGRROaAtxIADayAFF30D26jSCuiugsQgrboADgjNxorR0D7qsOyADwohERgBJSZBm0ghFSxGGPbme2zQGoYKGoIhFO4gCpIIzE4IF4qhFGAhFmCBFADhEFqBHWXBFd6xtrz/xQvtkR53SyRM53Qk4RDMDQwNISGNbxBcQvhuovAOEjTRMPkE0vj4wDXZ6M/wgCoUAQq4IisyrUhwziwapkhGYRB8QAamzAEGgQ8i4RSOIRvIIS70wR72wTn3QR+q7h32YR7swTHo4AyswAmMwAa6UygPCJbOjijDc5VGQ5Y6Q8L+BD2b0jPSEz2l0tpA8DZCzGtyEQPtszf4iq8u5cRsEQzKBkDnw15MUA5+gAwOq9zEsRDWJhO2KRYY73uq0S2MTJwq6xQmYXMA4ROO8Bhw4RROARZKYRKwZfEIKhVSAR5DgVtCojKz8DLBJR9JpzK7sDI/5EP0TM9AMyGPryHv/wBtXNP47AAPeKhgtKJ6rGIsCKESlESl2O8R9CAJgvMCGsABYAEZsiEcpNMe5EEd3Kc5oTM6rwQdxjQWfmAI9qoHfhIGQvHCUlFnVGnsVvFozrMp65Q9mYCu6KpOmyAKmmAJkCAKniBQtcAKtMAJpMAJkEMrj0kHdhEJ/lTu6C4KHhVQ/XQJtOAMiKIo0uBFXuQY4UAOQNVAyYAMPoot24APGDPMtIkVYlAXyER8hmqopmEapAGTbuGEkBAWcGEWEjNET4gUcoEdXaHUQmFbvGUeIYHiSkIz9fF0NjOi5oxDxqg0cxQhz9AMB2Eh+QA6UsQOigsPwrV6JnJ5wMJhkv/kFZqkEvRACmYAAyZgAgTkSuZVH+7BXmVyHu6BHi4RTMlh1rIhEvIpUweQTe2EMjTjThQsNVZRAb3uKceuPSdsPY9gCAZIM7bADLqgDLRgY8sgCrKAY7UgC6IgCpZgCUjWZI3ACE5WC7QgCrAgCrTAZGcWC5YAC0TWZrGADGxkZ+0lpEBVpNwI0DaxDhqyDA2h9z5CW+gSO3xhGoeMVseJfJphGEL0EwYCRE/hEgBBzOyLoFxPFPKiEzQhE6QHEyQBE8LFbN1ME97MEi5BLlttEoiuEvgREjpzNKv1D3xUpIqWudogpESqDWoMHNM0C3ogDqQADrlgBvhoFbwEFL7/YmKSARrWr0g2ARESVwZKoAMw4AIuwB5Cdx5uch7mYTHyYV9L1x7k4h3IIRumoRcIrg0SrOvuJGnOINkQsABf42CJjQkkbAGh0ik5Y8IsVjM+Fl+yQHmXl3mVN2VnlmRj1mWxgHqzYGZzlnrJYHl3FvB8B45A9WeFlo3gpWjfZfDekoSUVhTo0hVuwRfuElYij1bBIxqkQRqcoRhmoRRA1GpJYfFy4RVawRRgz0KocMcuBFzM9s0SinTkdh9l1Ap5b0ELb+MSwSYQoRC41RAQ4Q9c8zVJbg58gg9qjEbiQA3mwAfigAsSwAU2wUsUYSyq4g4rQRFOjRC4AA1mYHNL/8BzL8Ad3KEd2EEd1AEe4gF15WJM0UE5Z80afiEWIqFY6mcLbKR2bRdR+sQ0/Odgd8Y9f7dOoVJ4wbgzVhZll0Bly9hky1hlWbYLWrZkzdhkfUCOswAL6Fh5kyIp0KANfmdTjWIN4OCPy9L5QGVFCtknUrDw4BIuJyFbTsUVYnAXyIQa6dcG69cZkOFMymQXaKHMWuEU4pEjnPV0NNOhOCQfvTAzM2GhviUzZU/iSgglvLARJKGidm8REKERZqL4io9bd/k13SiE5KANcgANHMABhAATUMFIvsIRvG8TUAEt8OANdkAGZIA9ehiIixge1CEd0mEe1oHqyCEcsgE8jv+BGY6hF1gBwcxgC3CGRqx4i6kgng3Ff+C0MxyWeH/XiyuWYu2UYvnZn1d2ZlVWoK83ep+XZV3WjAnaCHRgjpnXB+64d9BgZGO2KIYiWOIAd3DHkA25IAuvEBaUElrNOkThFAJjOyALbyi5fh8vGpahGHZhFm7BCV+vQjJhH2O0WffRoaK1H7tIoroICxVKohZhkXm6ERoBEkaE9+ASNBuBEEak+OwADnp5EOzgE3ugDdrgB3wyBm5AAS6AenRuK75PK45EhUtgBnR4czvgc+dhm9PBHMyhHM5BHMSZnH9hFmChGIphGSDrEjggBsqgC5CjKH6HdkmVVJNyd8tTscn/gHojGwsKtwfy1LL19J8texfpaq42cBfNuHAZeqAJWgd0YAdOO9uCp2Ylm46rl4ozdSg+BXfOBtBURPl6uYNFSG0US5tMWm5YqDvSxxqdQRrCgxmQYRhwIRZYzx3RDCTOtov0kXTEJSWwcPdUwouscCVS4pYvanbO0BAKYQX/wBBQruRC9QzIAA58iQi4wA8GAV7gwF6SggxyQKu5Wg6KSwoEQRdGoaxzzmAqYecUgQuoea2rmXMxAAMu8RLPwa7DYZyRARd4tReEYXyegRjaIDLCpmX5rgxoN70XG2FfwwCDTZ4fe7J7gHopGxwvW08r1sXpLk+NSQc4e64aunBL/7u0Gbqhdby0d2AJnAChl6AHfECy61gpbMRe/hhUlA82e4K2SY6NhDZB71YuF4suZWEWesGvcdAGL3kYZDoWaloUphBtS8dZuai61zwlOrPw3vwmRkVb1wi6foDgIiMybqBxGKRxYkB46gCbDKEROEIvVHQvRsEVGiu/vGQUCAETQGF5qiLndo4N2PrA2aMDMr3+lDgctKEaipsw9oZkHEmpLEE9NqALfIkLtODvHltgbYYMwKqsYkk9UZEKHpvFwfEGCjdPM9vF6aq0aTzYkcDH6Q7HKXvHSVvHpUkHjKDIKTvFwVFffkBnH3urw3doS85oyY0NRWpn1zJVM9jc1v9mLk96y48Bb8RjPMLczFKFFKQQJCQBLRYxH8NMWVHizfsDENBwpNogtewc15AIumzAqpiliRDyEP6AEeB2LknBFFrBFWSBSxTPFnQhGIKBF3gBGILBS5IhTIAhGYDB+8ZLYLBC/BoGD9p1BtSarUuAcztAnLXhko/hGIzBGPAyQkXmGXThFXKgcixACrgAh5XCDFz9sdMbKqngfvTZi5m+6f9EsaO9cG9g13vgBl58CHw8T5fdx7ve650dHJ0iB0o7ZXWABs5eB27AvsER19he1+0b4O1csbd6q4NWDubgth3yvEPqsJT32031sNwIEMh9m2RhBplBGspjGYhhijz/+d3h9h8JAW3WhvcOoen6ww4QgqsdxKq6zMvsABDCvZGjkGlXT9ErPuPflxhWnxiCwReCQRh84fVdn/bBBOSJwUt0AdIdQQ+ggAdcKg8iZmIcIQ7sSAY6YK112OU7txpgehh6YdSfgbKgIRnwi0kyIfp8IAeSNwu498NDXLFhXcRZg2fwdAiMBj2TnlRzvXBTHAt+HdgvG1ARdQekwP4LPNtO+7RzQO1vIAvEHiBKCFRBkKCHDRs8KFRoAaHDhg4dLkxBMYbFGDd65PDhoweWHzlu2LABA4ZFGzFM2vjRI0bFlGTI2AF0KNKlUqdg4dq5K1apSZEOtaHThs+ZIQ6Q/9BQwEDFGaKAokqlGTTSpEufRJlKxapVK1lgadm6NetWrVq40O66xZaWrFaxzsaaNSturWLIhvXidYuXrVy2bLlypcpVqFCcMI1SxCaQ4z2BIOfJE8iRoDhxuOygIWOGDBkqBHbAECwYMWXNnj3LVi0btGbJVI2yVKlTKERYsPjIkSU3FjJlgp85E7M4GeIxqSj/4oUJEypMjhxRDt25dSYxe2j3vV17xiHgw+vQER48eR1LpDjZwZ69eifr29+Yf8PH/BygVcigYVGkjPknnVTSgDBQpEIMKsBwYAwoYTRfDxnRZxFFEW1ggQUTODDBhRhO0EADFnx4IQce4EBHIf+TfFIKK6zAwkokkQBSCCB01HgIJIxQAccdcBTCyCSmeMUiK7HQwhZZZyVZyyxJ0hXLk3XFAgssdFVZ5ZOx/DLLL1wWU8wxzfgijC+0JKMLI4MkAgkihPghhRSZOSGFGkUosskeUFSmyGSKYIIIHmo4QYNnnoEmWgfGJPMMNNBU81oywLgySieObEIIKKhwMocPWOSQg2+/BVeGcaQWVx111z3nxaqoOkcGqLlp5xEWspY3xHg6XBQDruNxxFFIvgbrQxbDcpoFGsdmoSwaZjRrhpxccOFEtE7osIMONOAaBQ03eEZQCSqkcIMOuYWUw4HhUpSCBRo6AGIDDMQrLwP/BxxAb731MtAABxbAQMchN53C5E5ExnKLLLekdUsugPHCMC++8LLLLr3sZHFaVkJJ15QcTznXL7hw+csxxyCDDDPMOONMNNFo4zI32nDDTTXNBMOLLsDo4scMc+oxWSBAFDHGGDwIQRllgVyRxx6OYEIIIYr4EYcaUrCnQ6H6hVbCoow+Y6Yur4CyCSaVbOJIIGPz0UMZWdyQA6millpqdc8p59yqTHjRqnWvvkqrrID3MIR0R4iHq61G6OArsRsJ66tHn2KBxrCSm5FFGWlYzkUSRMA3hRNE0EAEtgXpAFoKHXSg7kIJHeRBQxBZ6AADHHJguwco4UBGjTIWgiJW/yvG8tUtuwzjiy/D/JL8MMXoNUzIF/fSy8Ro7STyxSCLLDLJx6CM8srRSHONON98I8754Zx/vjfelA/OOeSzb80xxASD8ytqsGBCHkKM8QIQVwggD5TwAiUwbWhKyMMY8uCIVVhGampQg2Y4MyjQGGprYaKFKkKxCUx1EBRNc0SfEPEGZrXkbcVRltzkZjfntBBvziHcEVwonRjWMDq2ko6tdngrGiwBQhsJyQ0c1J8hpqBANrhBFkJiEl25LQYl6AC4BjKBKlbRXRnKkIgQ8iHaecAiMNAdHahylUl4ghRB+koueMEL0xDDGG8UxjCMUQw6kkxkXjqGl75UDO35kf9LxwAk97yXsmhQ4xrb6Eb5xEEOdDjykegghzi8IbNueOMd+rCHPtyBjnOM4xzwGwc4RjnKcXzDG9c4Bi7qRwxXvGEFHajBGMKgBzyMAQoMLAIUoJDAySywCHsYQyAUIQg9+GEOJbwWZzbzmfyUgBam8IQlJFG2SoEChGcbpiPwoCyN9OAHviGDsrKwQlKdqm6qak6q0Fm450TnOjWkW3RkGJ5dgQdBKfCAuIaIIHzq8yAJSQhFDoIhB7CrAQ7YwOz0RS+myAtECOGADdpgh5kw4hKZ4IQoSNGKvzCMGCBVhkibQVKSLqMZy0CNSJWxjJYuw2QmIxlM/cg9mXYvZSv/k4b4roEN83mDke94BzqCqo99GPWoR+WHUpfKj328Q5LqG8c7lmpUfbzDHVhdhzm2ao5xnI8bzOCSMYLhCjv4YAUZyAAeRMAGR9RgBUUoQtGCpgQD5kERY1BEINigB0HgQWrIutbVrlWo/GCCbJjApjUVgYcroM0ReqjaDjwiEnBiIQtLWEIUokAqy/qNDNaRJzpdSB3qgGeGNZzhPGM4T8NdhCAWUYEOVPAQByT0QlrsYhfj9SGmNCAhMPiBHORABzv47hBmFIVyTeEKWYglF8EQBjGkawxlGMNk171uSre7Upci46XfbSkzXOq9kzGDZeg1JE+x8VP1OZKo+oiv/3yNytSm7qOo9eWHP/bL3/76gx/6iCRUzzGP/jY1qFfFajva4Y53iCMc0fgF8nzhij/cgAsiAAEEhOACFdBABDyoQQ3YAIWgAdAxeDBBXhVhTD/UIQ5pQMNmaCDbqzUTNGZzhI6rWQlM6IEQeOjgGPQAHx3k4IS/UVZulnC54vzAsn/DQg2jwAQqW7nKqrWbdKiAhSFgAYc3rGcMxJyufFpoQxi6UAPQfCELWUCfJvkBGeTABz7ciBOe8ARzX2ELXUBsum80RnWbIehCC1oZ2IWpMWpaMmQwWqbMOJl5CymNQ26DG+xj5FDhK99Oe7qo9LXvPvTrj3zk4x+o/od/+/+b6la3er/7cAc5JPnJdpB6v031NIKFao3mwVEXo5gDEVhAAQpUIK5sEEEHAkGIFbChMZQRZiDGkE02VEIQxyxhFnBFg24PCmugqMQoxLYKVFQKFeHGxCbMxoIVqEsFqlNXCspMIAItRJ/qCmjrEBI7N8OOQ1ncLbwc6lB5YXFEMOhBG4pyo0lk4oxbScVXnsuwNbKRjcebmMY1bjGOp+UsF8Oe9gaJMpZRgxrYwEYizSeOT4ISqw3edVDtQfOa2/zm8q35qO17j3us2h+uDrqpTY0PfAwdH/SYRzm60Y1tYIPp49BHz+/B4AWbA5Tms2o4AjlHWlRCryxgQRFOoAT/POBBD5VxBCgCAQxM4GEPTDtbAs+mh0YMAjMlREMSROztG+M4seEW27oHX4lKiLAGJSgQRTogA3lTpCSOz+e9I8I6iQB0AxyIKOUHFIMv3kC4xJURIH708FCQAo2okHhzAxOYild8FwzbSfUslqSP1172tx95ybwHvkqrXJEsd7k71rHgdszj+Pc4/jySfvyk3/z5Np+69H3+X3/s4x76vf7UVc19oKfa1K4euvjH7495gKPpTt/GOOyh33zUo/hdNeU3nhrpOvLiEER4AdxdEEAlCHMVm1AZP/YK0LAJCxQZjpEHeqAHg4AILhYHecc5RDAD2DIDhSUDg3dNgqdj/zrWQW4HGrpCEANCEI8nb/d2ggpRbzFwZFggB3bABzJyI5DgCcolCqeQCjjYXM0FGH2xMK7HMEbCFq+3CyG3E3OhMUxye9azPbt3XibHU0z3DeDQcqB0DsXnDvNQfPAgD1wYD/IQD/VQD1w4hvKgfPRAD/UwD/IQhvQAfTq3DzWHhmE4h3N4D/hgh3bofah2akZ3avlQdEQXdIK4h/WQfOPQDU/HdOCwDvdgamEYD8TnSeeDDtHADGASDJMAAyIABXugQP6DS3lggEoQCDzwbKCgCo/BNJGBB09zTC8WgURABDWgTBbYTOs2busGCuo2NopQbns1A26DEp/yA0V0H//f9Btk0AYuyAd/UAiH8COXcAl6ZgqoUBivcI18tkYPAwwQg3HS4wsLwxYTgwtEWIQhpz0h80df0oROqF5P1z7tw3Ln0EjrUI/1uGDrAA/wEA/8CA/soI/6uIZzCIZgSIdjWA9oeA9iKA9neIb1gHT3YA/3cH0UGZETaZFFV3R0mJFG9w9Ed4cZeYZ9OH6nNohClw/71Q6iNA4sOQ7t0IhD937tYA5T+A3RcAwnFQyZAAMz4AImdkt5UARKUAR5UDRXUHaCoAZop2OOoVeE0AhtMgeYgQZUmQScM4vj8W2fUSmjwIFNgwl9onagwBhvwIzHBQmQcBWZYBujUI2ucI3/feZnwAAMpeFGIFWX9VOXEHM8wjAm3ig9O1Ex0lMxIdNHTBhT5oVelYZIlvRTkjRrm4ZJ7zAPEhmRyjd1aKiG+uiFXBiGALmP/BgP8FB87TCamxmaBamG7VCGxycP9tCGN6eGCQmSClmbhfiHGSl9/qCbu9lz++BfPjd1vfmQH4kPhdhzDXl87aAOzNmSpQQO5TAPf+h+/0APW3UONtk9z2AMnABvHOYCLQAFt3RNVyAEjrAHR8lAiqAIOiZMlRKAIuQHfcAHbxAHVIkGTpAE7ZGV3bKVIdRBOSZCaheAoKALOAMMIJUMCrqgDNqgDSpoMKVodLRHFOolzMM8X2Iy/9+zMtMwDdZwDdwAfJqGYLoWX/f1aUhFX6VGkg/pkeLHkRxJh2h4htLXkPdAhpxZiMyXnGf4fHL4kICokYBoatTHX1QFh/aQokd1c1jYpAu2j5/JnMxZDlRqDuWwnOpQDi7HVebwki6KD9XZDucADtSAk86gDJ6QBSsQASEABC7wAnLFA3twJ3mwCqTYlH2lCudJGY5wbY2QCH5QZ3CQd/ipn/vJLbUoTHBXKSKENHmgNGOACcDQoCJ1XStVUsmgDAyqUiwVXsswXhuKXid3DdcQM9wQDjHjmDKHSfM1ainaVExVfaX2c0PnavvVfd1Hkro6qyiJkj/3qyuqq0W3av+8yV89t1/HulRT93ww5w4LBkrx15LSKkrlkA5Ueq3lsFXXylXFtw7n4K3QanzzAKZgmg/24A7ngA3OgAzO8Ayn4CkiQAEPEAIkUBlCE4rnyQMLlAfjxgZvRxmLymyKAKhzMAdwYJ9U+R7tcS0hYYFjsAd7MgaOxTQKFEBjUARsAAqTqqAi5WgRajLWpakcixrV0BoxEw7pA5mrKl8yF19Jml+kZmq4Vn36FbO86qJDp4ceibOqBqz+RZI+G7SspqsfWZI9C7OihqRZWHznEK3OSUosSUpSOw5Oa6XpoA7Wmg7mUI9c6q3rMHxVV4Vgm4X2YKRORQ6oKjPPcAllMBr/D1ABUPACBeSeeQAFRRAIRTkGtsQGRSBLSBMIgvAIieCABpsGMJawb7ID8bEDuzEfkLF2jpV2waQI4jk0auAHmIAKr2AM1WANJndyzFANv4AMIXtozVAN6SMO7/VUkAlKnWQPS/sO49BTKvd0XdoONkp9d4ikN2dUEvmaEllq90APvimcqtYPyCt9vAt94wqjMKqjxOu8xjmS/DWdRAuc90Vzzmp1TitK4CCt3FqF4lua9kh8pHm+yom+DBZUnLSqQuVIzeqs54BV5+AN25AN0rAMvfATbjADIqABIzAZBSQ0RwkEk6FLdatjkAF3cHeKj9AIiFBnbpAGbxBjWbC4//FxNRY4A7gUgOwJGUoABNSWB0OpBCJgBVZwB4AwC44EVJIoDtWADNU1wzKMDNaQskOlD+JrhQyWfGVoD7P7DdswxN+wDsgnnLu5u0jaaTR3fDbXmxG5pMH7s9NHvNMnkSMpfsTpq8iKD/7gxcTac685h/Kgj8tJml26Vd4LvuB7dd9avvhoj+2ADnPcDuvADu0QD6uZvuI6D9tLmvHrSJ5kPuXDdEOccoicyD3VDddgDdPgDMcwC6dACpfQBzKwAiAAAkVwBf/zAlBwBUNTBC+At3jbi3aCt3kFCgDYCH8wB3YwB26AGTGmsPCxsBYId5SxbkEJBCI8Bi6wyUJDCP9CEAZ2cAvoMEniML9aeszhsJ1zVGi/sAzVoLrngEk7XHzDOw/34A7fYMgr1w6VWaRQLMY0t7zKd5nD24bKl7Tat7OtNn6oVmpBt2pKdVQRyXxWp6X6LLX83M8taaXXOkrlUL4EnQ4Ebb7dumBYeM7O+sd2fA7lANHg0M1Op8jXQA2VJg0ml9En19Ent5jW4MjMUAySfArKpQlpwAY8oAEo8D8XWwQivAeb7BiVgWJwR8qBgAmPsAiDwAd2YJ8G6wZmIC3rAR/52R4zcAWdODSVIZ4iTEBKoNR4MJR40AfEMEmWuH5dRQ7c0AzQYF1vhKGjew2NNFTju2DygJz80A7/TId+3QAO7XCHwJqzUGxz53zF50yZSdpz4vd9r2asd4icZ7ia8KfGUTu1pdTGUcvGTnut6ZC1jx3ZV8uc8cAOxGfZ94jH9TjQ3hq15VPIba3I2ECqiHzRHn3ap11pJzcNOqVT1iANI10Lp1AKWZEJk2AJiKAHlaABL4ACAMTLBuwIniwESiCnY+B/PKBjdyUIjSC4hnBMyFSwE8wF7/Em8MEROzADQ0PC1GaAgSA0/hdMeaDSAMQIz8BIJ2eFW70M0EUL0CVdwtALfYQM21DWLsfDq9mI2De76Pd00elzqeZfHhmkIWnFNUqH6Yyc02dfdn2+8KcOXHrY/DwO1SrZ/4+9DgZ90BpupVylpVvLnOzADurwjwAZ4lJKpYcthW2NiKJd2utFqjBO2hdNqqOK2qs9Dacd0tXQoR0qDc6wDMXQE5O8UaEgTY/wVjXQAnKLAigQV5z4AjwA0534yTSNCeNNCJUgCYPwB60c3UHdBV1A3dGiHlLgA+whTGiOQEEJBb+8ByXMAy4gBIjwDI10Pu8wSuSQDcVgCpnwB5xADG0UDBTzC8XADGQtSaCE0PEgs/RwiOi3DUVsD2Aa4KyWkeLnX/yAxDXKxzNJpf386f1cDt+b2NNqteaQtdV6x3Ecx/eIj6RZhXasVZ4utaDd4raecjwV4zB+SDRe4zZuDf+oLQ0l26EfLQ0hbQ3D/uN50Qu0cAqeMAmMIAq2bQk+VgIacAIjkO0tfQImAAIo8KbJfbGjTIqQoQbNbXdbLgcQWLCwDObR8u5yUuY7MKd3GzQWe0t2y8tjsAIY0AJFIAexIA5PdcyfhLbVgAp/YAiW0AmegDN80Qt6xAzckMxba777CIjwMNErPg7a3IcmSekT2cR+XNgSDur8jK0UXqUdLtn22OHYOtAV360afg6dBD/nQ8i1fsi3vvMuruvrhes+n+PAbuOtXfRG/9EdGg3r+gu10AuxMNuf4AmXwAimYAqhMAp6igF74AIgUAEhMAIaAAIm0AIu4AIn4O8vcAX/Sg6nLsBXjZDliDAIdlCfdcDucODuc0Itb2LmVwAEvO3kV6DLvCSeRRABGhACLmAIl4AM2oCy6sMN0PAMoUAIevAHlaDwwLBGu+ALXxIN5/PGJB4PfZgOoM105tB+7txfyLm0avzpUujPbMySL8+1XUvQUqrhBL3DoOS9pS/aNj7jPh/8MZ7Iwj/8iMzrpp3a1MDjzF/06cUyKuM9L6VHTO8ipzAkp2AKaGQKBmoLr1AJaMUDmczSLzACJkCvbnoCIXD2vNwCxc0CRIDlkpAIg9AHryyVdVD3c7AGXaAFXBDmAMHFiY8sPnwUAVFkTB4lSoAECjRmzAsXUFq4yDNG/4ieSqNsNZtWLVu2ZrxsbQqkCM+oV5ZCASNGTNkyZ8yohUOHbh29fD3z+ePHz569ee7evdu3j9+9e0uJzmsXVarUc+bOoTuXNWvOqVOJumvnDmq7efLMyouXdt7aokTJ0qM3dt3ccnXHlQP3Tdw3vt38/t22zW9gb90EF/aWWPFixou5PYbcWHE4b5Ahd0vcjVtlbY+1fdY2UnS1atKiRXPmrNkyZMWG9cJVa1Ys2rFascKdG7crWrJk2bJFy5YuXcA2lTABAoQGFBpesFAS6MUIEkBcuLgChMSIK4p4tMDzSJMkRoj+9OFTR32dNe3PbOlSRn6WLFgM8hAypkgeKP8uHLbIboQ89nBhoTyuGKMSUDghpppgmiFGFlRMcWRATFBRJRNNVAEmGWNmSi0ab9ARC5+e/vFnH3vcAauducJqJysX51pHKhZZbAedHM+58Uashlqxx6GEXJGtodaasZxxxuFLsG2wgTLKa6KkJkorowwsS2yuuSZLL//SbLFwKGNsTDMT24wxy9bsjJvQRrKGtGlMq4m1Yu78JbZYYOETt1P+PIWVVP5MpdBUcmsl0VZ4a+U3WYR7RRdbOmFDBBOKGAEFEEJ4wYQxoAACCBRCeCiQAFFwQYjwNKkEkvIG8SO99dpb470tyiCDDPrq6yEQHn4dY48i/CsCCCWgACX/EOteAAKKMRzZpBNUiAOm2k4w2SMQTKBtBJFOGtGkw9VSOyaab2qMx8R/7nnHHazMgRfeduCtsSt7YcQxLHeIavcof/3NKSdyxBHnHIL76uZKahY+bWGHH4aYmmsiXtgaa7jEOGMuA1uz4zUr8zgcyz7L5s1q5kRNNWWMIeY1XG65xbdYdGMFUJtvttlQQxXleVFXXJHlFaAjVSWLGkRggdkRln4hBIlOqG45Y5XYA4gXLuICEUwwgWQRRGDto4451IPDvS1uxVXX+rAY49ciINpPiRf2yAOIMeTO7qFsHQFlFFNseQWYVyrZBA++9SAEj0Yq8UMScZtxJhpkbBpn/5561IXKnBjhrStec2gE/V6p1mFRq3PGIZjgzAKTkuKFp5zYdWsctthhaW6fcxrZL87YGtCusdhi4K8puXjQQMvG9+TjnNM01JhZ5hg8f8lTttoS/VnRn7fnWVCadTYlfFN03rln7WlxBXtVVAmlE1C4KEIREyjQYAwgQriUvwJPYA6FFz5FQR54EB5MtGoRhgCbHcZWh7LV6mzyyZWusICFiGSnCNkJBEOgUKxQBaJqDxmQIggHCgyBwhGEiIgeHDEGUOiiEoQAxSMYQQpjPOM0DQNHukyED3l8Lio0itE6zhG6IVbldODIC1/6cqXYQSx4GgOexJoYsdnRLnjUmP+d7qpBjWl0sYvU2OLshNfFalTRYnI6WfDk1LwbpiY10EOG9KhXvVnMpjZ8ggVt+pSb7aVPezxbnyr8qKhCrS8VqEAkIsdHPlUUEns/C44sWqEKoYVCBTPQg0KuMD8N2K0ILTABC07wAh6AYATWccELUICCQEBBD5jQRCYYkQhDnOcOdqgDLucABzeYwQxlsJUWhBmFJbQACqAawxX+F6oX1K0IrLzbC66wB0dUExSVUIQg9IAHHrwtJY7QxSqK4IhV4CELOLjENMxUsHbwpCf2iJFWzIE6giXxG4Z50pYcFo3bUUMa1ODn7QRqu4UJ1KD99Oc/KabQguqudli0GBn/I0qak5GxjGT0YhdxR6eaMIMZcZQj9XChpzuyAo8n5dPMaMaK2wiKUKloBUwLhYpJks9QiDRUIAOZyETqTBWtQIUjt0eL3rjiFarARBwuIAIJXMc5IdDACJhjAhNQRAMh2JQpX7BVFLAgfpvQhAwRUcs+3DKXZOOlLx14Ni1EIQrMSmaxHKKQYCnrOidQJhQ2AYq9riIQNcDPda6AklWAYg8SkUgNbuAGOrAiGyLzjF+gVNDTOI+fN8RsZjN70IBatrIHTahBPyvag2r0oP/EXUiaJ9DMvhGOIJ0eHes4izzi8Y55vO1KcWPTU4jPFKQIn81IMVxSDMoUvSWub32r/7MJhY+nOM0pzyDpivVJogQQMEEFoNocZoUgDxoAgdyoeoKkuYAEKGjBCfznAsOBtRJeI+sdxGYHXfLSDW5wzxne01YgFOttn0JWRByxB2S1zSF7AEWyTOUC66BACR/IwyYUAREELYS8jRgFLYhBE2SA1KOTO8YxOoyMZUDPoydmRk3cGCLUfHazpr1dZ13sWRdj9rQxjnEbXTti6RUjTyMdaS2EPNI5FjlPdZSNHWuz5CXjljYtzU2hXupb4laZFKLAsiisfOUtJ1e5zn3uIVOxvkcCzY+jwEMGJCCBEFDAzRWQpv8wtdWLFCFpLzhBCE5pNSiwgXAFTMRY/3AeBv/SV4FwsC+tHChM/byAanlgyIDHEIgWIPgKRYiOIhwRkQNBwRGKoNuA8KAHiewh1GPQAyhcoYsPNUMZM1lGiVfcUVrP+jQsruw0bGxQ1VpUoqQJXrDjRFFis9GN0GNNj0UKm9jMohbNFnK0nw3kXvzCNXcaRjGqDeRZADk2MJt2kKX9siT3pje+kUX2fNaz9P3UpzdNxSJtmiibjlmngfTNzyD1iuHYIhRvSAIbKhCBB2igAnAeAQX0fIUrlPIFRcBzeZklLBMEwhGEq0QjAl3L8xj60Gk1A61sBQYwWO2Tpj4sFAT4v7vhoW14yIh+NpgRSCshI3pNpqhQAAQeEIL/kqxuxmpgHesUrxhys0Z60t1Y2ctm9GTEXqNGU+bGZSgDGcbAUy96sQtvR3u2dvy6s6MdmyF7Gxda74Uv7mSM18BmF8wGMsxuEW4gSzvJs6BFLNCd7j6qW1H31ulzoRvUQhHSpoAnMy0alT5bGPUVo0iDDGoABQ3Qr/IvAK+eQeC/EPCgUydogXP664IiEIgNinCvJLqFwI4bepeI7qXIz0ZyF/BACfa7dBEuiBG/6t7mhGCDEKSg+2MCQZnD0s8K5TYCp8VPkLzwhTGq3uFYVx/F1Sf6iZXuxmc8wxneB//3u//9oL96ZS0bhi+0vguuR/sWtPg6be4+W73vnajn//YNLeS+/1zsIhcvezut8wViMAZjmCOuQ0Cuexm5M7sgIzsh6w29wzvbiIW+GyR7AzzBw6kwiykxCypE0imdcYVUMKr1oS5d6IQckIEVkAAKeIDliCpn0rmlCYFR2oRNMIEQwLTSc7QiYIMbzDjVo6VBaD2zmoPXc4MGshX9sg4ScLT+ApX/MaE8OAEecAFoqQE8YINkGoOdA4I92ASFyCSJaA4X2INUExpekInVYA0Sw743zL4SQ7HUgMNXK8ACHIbXUD9e8L/9e7/70z9AJKo/BES5g7/8kwW9I6q9e5T7M0SYyYVcuIX+48Nd8IX0G4YPQQZr+4Wti42tYz9JnP/EBhSyuTNEdJtA2kgf7qE3DLw3DdTAmYLFntKen7m3TpiBFViBGji4CtiDF6Af5nu4pZEbqOqktgGl28M0HuACPNiaSpCER9A41kMPO+gDXFKP12MgRdOvIvgVIfiOXzGBFuCBDLoOIaimS9sENqi9rQqVasoDiFCEUqMaPRCEUVgUWwiGD7nDYSBAlrnDgCwGrLsTPFE/uCM74VjEdOM7M7O//BOO4CAq4JhI4LDI+6PIiAwOP+TIjuy/XYA+YRAGTMxEtlOGTCxITFy/XYBE9os7QoSZSLq/fEs386m3m7wpRTKFRNrJWYSuQvkZDAmkSpgBDbgU7cIqSAOBCtD/APLKQQGRqhBwgRMwAarUABcQJReoASEghE3YGkuQhI0jQvTgg7JaD7GBg23kxhNQAm80gV8pkGPyoBaYMIuDCEfYoGJBEJvrm2qim00YMEfgCEGiBUsUhpNkGV8IhpgIBl/gBT6MxPebvzpispYyH0IyH6BpyO1BN/x7SIhcyEUUO7srRY6MxJCMiUz8x6rDBeoxhqsrSKxLv62LxFB8mQWcxFyQyEbEv+wZpA40lJeSsuAClHhrLp70yZ8kwcCzBBUQgQoYFvphAUc4gQgIvRBosxBAgUypAKralIdrARYIBKriASngAgUpoEp4BLE8Dz7gA7MSG21koAaqlRbI/wMhcIEJu8ExYLAiAJU8cIQXULk9UAIGExWr+Z9wYoMrcBaLKyw8SIRX0E1eEIbE9AXHfExe0E1b2L/ekMhz87sy881FuczCSxSWYjcSfaS9q42ZRLdY6Eg/ZMlb8D+Q9AVhiImWuUPzi77qs7rXLEDXUD/2C0X/w4Xa7MOFtIW9W8VBaiTCi7fwOSSdFJ+gkjfwWaQqnRDBEyRV2ElJSIEJ0AASqIClSTioAoFAmMoaZAENYA6oCgEWSA4eOAEQSCX7DARBqIT0lARIYE+yLCv6is+0nE+RawHdA8w8KCy6GoOkmbS6actLs5rq6C9I80+b86C32QM2cIJRAIZ9JP8GD7lQ6OMF4pAUi5REjIykn8k3C/xNnjFRnCwU3ZhVFDUf2pAZdJMN/Zu7Wtg/9oMZ/wvJPCTAYpXNZWgG7zOGYwjSa5tNTyRSBRwpYAVER8m3RzK8n5RSWT2FQzEUP3mpP9HSezOFUUAFQpgAB4CAB/gAF4yANZMADWABFloFJfC8q8qUQFACqiwCT3m4KzgBIDi9G5SEaFzPsSIr9+yDhYXPBWqgLmiPYWkmldNXz9MrITiB/QBQUGkWVWqIPNA9B1MCTFCEIhACZ/kk/ACFZGDZoPtHxlxM4ojEyLTImg2OjFTIiXwF/FvIV2DIVwDaoAXaRuzMauXNW5gFQwT/Dsl0Pwb0NpecVrSDDbTbhUyEBtTIk1+QjSRjsj05qdyAhdwAlN3CmVMgrlIgBbTFsi4721IohVNw27iNWz4JlLDFjZnVBU3wAzzgAjZgAx5o03dlyqtyMw2IV/CqH0rbFDfFvBXaOTk9AQY7rxaoAUXYmmj0U68hQj/wg7IiSwU6QkQrGzZYA9JVA+1AAYVQCEozFqwkUGn6xVB5R0010J0DhVWQCEizDqthA1AI1VcjhsUM3ph4TF2Y2Ui0BeS9SI28WVoQ2qANGueN3uelXhcFTUfkyIiM0QbEhWjtXu+tBalVBpGoBpGiOyEbTSRTMpUKlLKF27h937j9BLml/99PsF/6rdtus7ZycQZpmJOTKcBkIAZOUIELgAAHULilhIB4DQESMBXtGlwgyIMWoAAlUATwKlODW6URoKqrdAHqIAEQUANoUU9pTIRAG4TNjRX3dL0jPMI4iAM2UIMZ3jwv/KoTwKvaK4ITANkWkKYiqI5Wagg6hThFVYQ8AAVQ048ReIEakIJH6JBkEAbFbMxgsGIM1dDjnVmbtUjq9WIvFsQwFuNB5MjS9EPufdpoldq0U7/0awZuyAZuYAY8Mbsi3QVnazb6Qym6rRm4BRT5td9AdltA4ZPW/IVjSLFokJhtSBNxIIej0Id3IAdyCAdm+IVmSIZRsIEL6AAKgP+ATTEBrDw45hCWGlS47gQCNyUV7DQ4DbiC7cRhNwUBEwAvUuKITVDPRvBTsdzcheUD14vPOYDhGPZbEqgOe02wYbkCSjOBk4WCGigWUFkl0hMgummWKwDZbJm0DNI9hUgCRHiFZLjiGxUGK27MDC1V482FLOZiwAla4PhioY3eMV7EnOVVcDPFB8RNp407IItW9hPA9du6XijAV8MFXwg6ZziGtFtjqo2NuuNaytQjlKojQy4GEfOoyroGbdgGb0idj55k09GKdrCHfXAH1JGGQ1YGV8gBD+gAEXAACRjlCgABClgOm16lExhcCqiAwk0O7KTpzEuapURlFCABFyD/BFjK5a7h5T/gXF+mr7Fx4WEmZjnrrwqBOOsAAR7IiCtUhXgE0P7aBALdNH3NAzyYPGeJR2rauStwhI0YBV3ghWDgQwKcYgw1VXVmZ+BQ3nZe3p2t50dhxKLF3o58Nrp7SRr9ZyJFOw0FSei7UF+4BWHghWQVhUhoBVJYFFKIPtiIbLQrMkM2souenBCRGGzYBr0gh4D5l6Owh3d47Rv5IX0pHdCpF37QB3f5Bn+ahmcwhBW8Ag1Y11500wqoDqOugAeIgDqNgF6k6VDiJMPtVw041PRy5SIIATZwBE3AhGhshFlCWCJ06s6tRkFdjxdegxm+0xYIlcNib+uw13IE/wZdEAL+qBplhAJM0AN9HQMTqAHE8qBNa5oXcIRLSwJG0EddsGJekOJRTWdTLdUNTV6/ttl69ky+G2xAdL/CvgV99ueZXeyBDkD24wU2juy2awZj2AVhwORgQLez87E7CTGMZobKkpjNcOTVzglI1oce7/GkAPIgV4qgIPKguIehuAcg14cfohElWQcm+YZrMI1hSIU5KIEVoACCe0GD046BMyWmHAMSiICoam7mqLxWNrgRgIIcrD0hGBYW2Go/80pobASvCe9Be2qyZGFsRG8ZZmLukI5Nq7NgaYEx0AVoQIWTvaBNU92RRYVj2qoxmEe8nIhMuWYgqAEZ8AMOef9MYiDnyM7QvJZZCV9eLg5sDB9sVLw/JDM35l1aSNRiEP9IqkW7kao2rVu2XzDAXiiG1hiGWfgFZOhfaujobxiHrHiHH/fxZf/xIGf2Z2d2Z4/kdzCdJVGiewIMbDAMa5AGZ1CGWhAFS0gEH7iAFqSABQjqn0ZzELgC6hiDFhjzhFOOwTXGrJrKCooIEWADTOgEsFQ9OzcE1sPzhSV4Fs5GFz7CVWKWYfEvox6DTXCWUSic24vHsV5GPCishYC4QAAGR8A0R9AO5jC+Ha6BEoiDuLbiu3bw4hV1dd5iDr0FivRZQUT1dNO7m6cNMi7FXKjIVx/FaYVaasN1I6Oei6b/8ciJBmuYBmvIhmlwLWnwhkdO9mYncqAocn5QiiEHCqvv8an38XfIiaxYktNZEtS59m9QDL3YC75Qk9BwhmFghUuYhD+YgzvAAAmIgAVAAKbEqhA4XOTGqqZUDp4GARKggE3LFBCQgIA9AcCkqrfcBCV4JU7wd41DhMsPePEm74LHpV8OZkRTpa1KJSDwYZ5jSzfngRpYIRbIlmN5Jh7gGw+SjhcIhE3AD2oC+R5UiP5SAjVYiQ4JSGOoUJbJUStmzD6SJJZS/paq1ZW6zETp2vVlMomOBTwW7RArbX5a5G4gGB1Hh9YGGHTwcSFPiqAAcqxX8ki2hx7/ihgph4/e/wtvCAdxIJPC8AvF+IuROR5tGAzkyYZqAIhoy3q1IhWp0CFDg2ZgwABBgoaIGkBIgAACxAgNFEBU0BACCJAie0iMcLQnBIoWY06cAMHDERAKIUxAYaNnUydLkhgZ6olI4aA/f/oQLXqnzpw5fOwgTQoHDhAUL14AgQLlxRgXJ4AIgSKEh8oiQKgqiQqERY0reUA5GpMHStYTQkTmKaLkBYkrY6682FNEjSpgxIIRIyZMmDFjhYP5CgZMF+RXtGRRlhUrFitWqVJl7nzqM2hWnzl3hsUKFurUqWfVwoXrF+xjyJg5iyaNGrZu3b59E3cO3Tt0wN8Rf6fvOHJ9+5LrI/9u7/m8ee2mmztnzty47OPAaQfH+zt479+9ffPGrZu39Om5seemXn37+PK10c9WbZozZL1gnSI1qZAllgwSxwURVFBBCBBshAEFGmQUUUcgTITCJjBB6FEIRYwxEUcjUEDBGGNksIIio3SSiSSQLOITUEIVZRRTdSzFVFJJUTVGEVSNldVeWr3AggstvKAWFEVcwdcJRYi1B1xjTKWkEEJscsUeeUgFRZVGjsGGIJnoAkwwvPhCjC+8CJNLLmXmwgsvutAymSu02DJZK61sxtmdoOm55ymrvfaLbLRFEw1uu/V2zm/D2RNddPbcww8/9zz3HD2VRufOdOtoak45223/Bw6ooYL3nW66vXfqed1so+o22/BWKqyxtrpee/RxYyt72WRzq672PfMMMsPU0p8onEwySiid+FFCByZIiIEGEVDAwwsPDBmRhBqQpIQLGnQ7AgkaSDBTBSOcUMEDGSW5AhGKqJJTijwZ8tMg9bpIlB9+9MHHjHb4W+McYkEBhAsvuOBCEVjyMNYV3PKAQiCOjNBXiEVidUWOWDniSCBCRFxEIBgXkeELV43hFyGhvKJLMLqw+fItaNoyM822xIwmLpeldlksO7fWC6Cz0XbbNat6Iw7SiJ6jKdNLYzpdO4zOI0878FStaTlZa511qKCO+nWsYbc6tm5jX3M2fWnT/7cNNm273fbYbF9jjTXa9Hp3NfdJE80zzjDDzDLIGDPMLrfIMkssrWiGCiqquOKKJiWUcAEELATSoAgUOLKJTC98GAIFElQAxEkOeuShuRONnodEFKxQAxGarALvIowMMm9P9g4lVL768svvv0nJgWMRUYoV0hiKOKJEHssruRfGStg1/RiB7AHS5hznwcMYC+dYZB5KiK8EX0WAokgjoKwMGWQz58K+m7bksgv9QBdzDP5/DypNq7uJI1xw3GGc5AiwOMTRh9ISeA6vkaobb8sN2+JWqlWFDT3eMJV6RhWrBrJqbNhA2zbSdrZr0GdudJuGNFA4KL/9DRnIOEYxfv+Bi1ogzjSiOUUpcojDUphiNK6okytQYQpUjEIVo/ABBiIgAQpYrluhG8FYRvAADVSAAhVYogbycIKNtG4EHCEBiDaBIQrUwBF+wIQrOKGTRSzidj8BSlCEMhQYAc9fdkiK9Hhgl7LwQAh7GYMSeJAHHF0BLmIZpAv2AIruVc9IHCveVqpUFyjkAQiBKAIKlASEugCyBk5oxPog44pXvMIVqlDFyoIhjGEsYxrcEAc5Bsgc5CynlpCCFAHdYR3tjONVsXLbBNn2tlbBLW6tcg+s2EMr+cCHgukJJjYuaDa6nXBvLHwhDGEzwxqiBjQ5/GYORSHOT4iCFKUghShySIr/dZLCFKZIRZ1aMcRTjoIQzEIQ6GbCEY1QgARAKFcVPyQu0W0kdB2JCAuEAAIShGsEI0CBCNgQB028C0WLSES93tgiOc6xD3ewQx3taAe7tMAFSggRD3hwApUoAi6FLAsQThYSkIEiEHnYQyCU4LFBYiUQUAhEIKoSMpMSjGDHK0ILhICHR2CiE5JoBCH0gAdB+GEOl9CFMpSxDGdoYzjG+WpzDOgOdIwVHefIjneQJg7wpKc3huLNqTJYwQkGkxvbYI8xj3lX+dRKbSecxgr/xowXxhA2u3ANDVVjw8zwaYfgPCc6xSlZybKzsqSAp2beaYpMpGAFIhBBHq5AgQeU/ytHERLogTSyRCt2xIoQMB3mgqSBqaBEBEJgQyVQEQqLJkIhiHij7njnhzneYV/98lfEmGQkoLogBC5Q3hiqokks5eEFg9wDTgOxMIMZaRNjAMUoAsEW5PGlLiUDQguksqMi6IENeIgDIYqQh9ByAQ2D8EQznjEoaxxtrXGFFQXLZsG4hkMc4TiwWhNs4AMXOMFxXQ98+JqqVmnDhNSQxt4C+zf8ZRM2MqwFiGch4lmgBnE9Q01pOqMZPG2mh6Yw52MjO1nKRrayp1hxKlCRiRt0IHMooeIDUHBQ0XGkQRLaSEeu+CGZAIGfGglBJcX1AYysQKKLQJZOGrEIRAzit/+5052++kBcony0Dnbc3PVyNAYoTAwrITqSksRyhZDAZQ93MRgKQlKDPKxiDxzbwyb8EjK1BMItSirkGBwRWrgEQg/YpZJNxyAIQ3hCGX6rzW2ooWlqirBoH7yG20IYQm3s9Va4smup27NM87gHVeypTzaskbf7aLiFLlxG4AbLjGLwGoa85rWHg/2LXtDvsMW+BbJvMRme/bBOLXYnO8Mpik9Q2xPWDoW1s+0KWQBx2zdT9iswcQEHZIAjB6qAuTNwbghA4ECspWKSrRgCdIMuIhQwQRE4ggLQSYsFbOACIkIRCktAAhKMOATCC6FwhbsozB69A8QhboePfnSQObr/uFjku2a1YMwtL5DvTx1xhba84AQl24MUilAJq2CCYy7HEVABqSHpVQ+oSoh5HqwnSZxS2he4dgbQByV022BYGnmjJtJJqLala6OvEq4P3e4zDcBGA+i25jD+ipEYGHL411o3BjJw7cKsF2MYvzb7MILdi7UTm35oSjayl32ZeCruTqlw54shu87JWpYUrkjF41rR7FzQQhev6EQS0V2BDIggAxK4iAQij26OiO7cITD3gRZKRQm8IBAR+VFqL39vpXJBEJrIScEPjvCEM/xeZI447COeUyXxwAVf4TNOqwSXIoWkeYBWhHjrIgQX6JEHoNAFTleRBxKsOUcxnXOc/6mioY2NYROBdoQicr5moPrBFL0wBq63CvTxB33otpnGrKthjV5Rk/3pV6HVxe5Cwnqd18O4/y/ur//C6L/XHB5GYoBd2G1V4GQdbJTd/cUQ27Wd2+VC3L3JZFDGZVRG4NEd3dkd3kFbZc2T4NmJ4NmCLtiCJZTAQ0iA41WACDzERVCe6GSAuqVWg1ARR7wACogLCYDACeTBQVFRQYFOlQmCFNTBI2QCwTGCEa7eISycHL3Iw8VexA0M7fnRzVUJ8FHSHugF6exB9YyC9OxBnwHJwShSTd0cTIXIWGiI9SQMxoycogGVTVmP9cwXUCUCKtxCL7iQVpGfHjrDr/RN3/84QzM0A238TfiNHbB52AL2gi8soi/c3yL2n9clhv7dH/8RQ/0lBjEYQ1blIW2EnQsBm/0NwyKyndslm83MSQTKwrbFgmWoYrc9TuCZ0impAuOgwt29053YYredEhG9wrukQAREAIQciAssXgUkFUWwmzFOHrxNEQgogZBVAMKkloNQAAS0wIGEgAbUgB44QhfUwSEEiMEd4eop4RK+SHE1IcTVAfNQ0h8FUsKEFiDVnFvgyE1dgQtsAigogQkUTHWdAA9AwRXYFFaABF+ID8eARJ15101VSc3l3E1ZDyGoAi3sQmIogyYuwyYKTmKUnS+sHf24xoiNJGuAmEmCWLH/1Q8jHgZLJmD9/RrWZV0ABmBWJUNW4drfOMMxgJ9GGsPZjSJI0g/cQWAqWkazWaDiZIbdpcIsqsKd2MlS5qIpNQ6yrAImbMAFdMBARV4GFE8GQEAfcUS5icBFHBQJhEAITFG8ZSMXPQhHgEAwVoAJEIIjREEX9AElUMI4qh7C1YtfxlFHGUXsAZV81cWhzUXzGZpbNAz5CEEggYALsIBK1V5IVGZQic9Y9FScKQlWVIlaZNcbwuGfbcIruE9K7sKI8YxiKdaJwQLPyAJR0kKyzYJsxgz9iAkj5uYvvKT/cZ2vdaTWbaJW4WQnBo7g3N8CnmbhJFtsSiBSJiWLqZhm/yhlKuiJirkmLNQJLWRCIiwCHrABEdRABzhAA0SAA8Tg4pGAFlUACVTAQ1zRFcHbQoFACERAtnzRuUjEC2gAlVDACEQAabGAI2BCHZSBHUCCXhohXx7CX/olRzEhE1ZIPdYeD2ihSykCD1BJwmgIxmDXwQQJWAwMjvRFSExFno2FVUBBSSmBFoZI87SFG+rcG2KXI6CSLVhGLIgYz+gMiqGYdC4W3cFiZVAGLdQC3CFbSNZPIiqiI6JdDKUdbwJnbzpDNThDYQENLgQlYtWCAz4gkeJo4mDnYv3oZZTkLsTGMgiK0elKrlQDNCSDHDTABChAAywABAQjBDgABCxABP+4AFlWAMaQgOOZ4IGoGwm0BApQRBVdBLig2xjMm0dUkQagwBWAwJLVQCVsgiGQARwwQryw0SIgYYP+ZWBCqBYWX0oN5JrxmSNoSHQlTJEogi5sgmRCQR/NHBDMmcHEFGdORcSsGRR+ZsREJFCZBFDlnPIEgiJ0wivwaI6qpo9mhg2tJmpcBiw+TmXQQpmWJLKZpGt8a0ouYG4CjbAJWwydawxFQzZMg4edKSke1jYhlo72TGtWa2scYKA4g9FVw64wGNKQA8AqWDi0x7oSgyjwgQc0wJ4mwAJURMMuwAMsgJ+CQAYczAsu3uO1AH3WYDFGyKRKiDZWEgjkWRGA0Wz/TQQLYAAXYAIoVAIctMEhSEKKHAIbISGDjqq99EFQkFlRgEyadR4oDBKfrcJJhY9YUIV1Ba30aAhIGAkUVgWg4cgmKQH1+VlMuWH25RxQKQ9OwShQnQ8feEIsuMZuHkO5nq2HmcaNiYaKWeCOpmYsgJhrwOuSKiLa3q3ZGlYt9AI02AcyFAPZytC3Bm7Z5qszTF3dcEODkYNwoAPAPi7SMFh8lJDSvZp9RAMz9MIsmMIkmEEHmOcCOAgI5CkPqtu5KJ4xtiDjhQCRjSx9hsDJlCUKnCUKkE+iSshbSgAe6CMnLMIfMMIk7AQjhGqorp69kGqpoiN2jUELaAjwtSiT/wjBfIHEJvHFFZzA9ZDOTbkAlTxtchmJ9DDPmp1MlXAMKPiF1kYkaLqhHugBHwACK+RrC3HY2MUkh80QteboLdQCLSBOiMktLoTkSQbw3LKdDN0tAg9bAOLaMRhnA6upNZCQ4hbY41awWqmH2ZhQBI8QB6tNq0nuujbDMGAGKWTCH1DOnlqRgYCACVBRuZHAZy0eCDSeBIiAC4ilu9knFbkFFakOCdCg4kGeNUZABhACKAhcJ0BCgAjvwdVsX+Js8r7IXGhIhupR+BRJwtiuP2kSECjCJvwUjdqUXigBlmxMIekFjpDxnDnCKsSc9ZyMsjLJTYECMGDCKtSUIGxCKP9cQi0ACm2w0GDZryDDEC6ImEke6fyAGLINbmtkKbGtXQAj8OD+SWzkzyA+QzPIwifkTJ8cQ4GFA+Qa2DJVmKZdWNFlWimncilv8NnQDX0gHd3EWjU8gzL4QiuUgihcgiUQghTsacOy21xQwHlSLLrdoLot1As7nrnF4ERszIG0p0aMQQ3Cm7xRQASsgCOAQieEgihkAhHGy/DaLM4C5oMWRasGwiZwT/dAwV2YFBcPDAkYSREoQvWAAhCQsRmSse/ZGTszz/OB8RtCwSagAnZFTKFVzyqowiq8wiawrKZGQh9jXQILWyPTEJcuJ5pkNLzuArF960RXMv4ITW0Qiiv/Ky4skQMsiUM2KMMs8IIyEM4vMMOtcLAqqzKGTYOmodAp73TRbRrSVQOvyJrURUMzKAMx7IIs9MfdoQImrEAE2OmdvlYLK9GBNB4yi44IwKcMn5uQNdRFnM5EQGq5WKoGaGwHsAEmCJzAebMlBK/BFa+oQjFHnWNdgMI+ioT4wNzzYOFeQGRWoHORfGb5NI9euNlJcdxAgsReOAI0AEPXAh/HKM/G6MEqJMMqCEIfAAIszEKwhdi2PmuOAjANsQbczc9tssnaleu5Gq5tUAOoocdJNy7jCkcoiwN5fIMFaUOVKkMz1Ib6WYNrpzIqlzJPF/cpT50KVd34AY7gFMNH/+5CLbCis2lW4/jiGzy1AywAxLIbRCzRWLpgSxhju7mguc1WINQgfC4UewoZBUSFkVmqC1CACBCCHqs1EQYIJYAzXN/sOCOvUNhFlvxRVeRcWcgzr6JZTR1JkVQPdknPyMGZTXnmYs6USchq9uWe1lZJhDsCMJwvHthBKRBujiLOLEigK7CibJrYaDfy3NZP0CBD0E1D4pr0bAOQV9E2SqtVb7wKXL0Hbg9YrnCDrqhNK6sycOt0Ck0dhq0Q0Imdrw2bSPbMDXnTZ5zTLb7YKIyCKVh3B0TeaGl3u3UEu83weEOeVsuw6DzEnHnRRHjLfYbAFUBzoqUU49G3WnczW//nd+rxZX/L9R+ESCPhSIhYj1S4qpKcVMSAwiYo61uMgR855HxdYZ2dzFtoiF3kAWTbFB7knoabBHZBZBziwR98gogBCuDKqyGHttxWck5Gg4zThzeA8mwDbOM6bo6vFW8omIGVh64b2FpF7oHFejcgTak0XeWamghFnZILnd8sw5NDuYhFK4olpYrZHWigEzu9WDuNwioQAgYUyAJkxANErJ6eQFpCwFdeUZiHuXtiLLvTpwuMALptAhC8JYIs1BKdQD+eQA14scCJkzcToZ6n3kXxN3/3txxlCawG5E2ZIYdGl1sMkl0rAiY4Oj126CWR8YAfyV5URUxtgiKsQlukuIWn+1lNZVfOZdcYNAIfv0YxIIMMkdhnxO0snCmgRIOs47gFJ9g4iANdbdB3eMd7oEeBpQeC+XqCMViw+9JMj1CFAbc1XV1hCS4N7Wi9TqsNxRMr0F1nVGd/tJMplBO2i8KyXEASAei4P4ADmKd9XhFXMp66PQS6J6O6y6C2OJQGZMVBjWyEVIADTEQGCEElHDE34/l9W4JeFlzB++UTI7xQBAQAIfkEAGQAAAAsAAAAAEABAAGH6sCh37KS3KyL16uN1KuP16iJ1KeK0qaJzqaL0aF/zKCDx5+Dxpp9wZ2CwJp+v5h8wZd5u5Z7w5Nvv5NyvpNzvZJyvJN0u49uuZJ1uY9wuY1tuY1qtpF0to5vtoxrs491r493s4ttrotxuYhitYlotIhns4lqs4dksoVjsYhqsYdjsIRirYlwrYhqrIVrrYZlrYRjrYNjrIBirIFeq39cqIZtqIVmp4NnpoJoqIJlp4Fip39npn9lpn9ip39do4Jpo4BmpH9kon9lo35joH5jqnxYp3xhpn1npnxmpnxkpntbpX1kpXtlpXtjpXtepHxjpHpkpHpipHtgon1koXxioXxho3tionpionxeonpeo3ljo3lho3lgpXhhpXlWpnZPonljonhionhfonZUoXlgoXZbn3xkoHxhn3tgn3pjnnpgn3tennpennldnHldoHdfnXhenXdannZcnXRbn3RSnXFQmnlgmnddmnZbmXVbmXNbmXBamXFTlXZflXNalXJYlHFYlXBVkW9XmW1OlmxSk2xVk21Qj2xWj2xSj2xQjmpPkmhNjWhPi2hQi2dMjWZMimZMjWRIjWBBiGZOiGRKiGNKhGVQhGJKhmBKhmBFgWBIhF1EgF1DgVpAfVtCfVk/eFpFflU5eVU8d1U9dlI5c1M9bVI+cE43aU06bkkxaUk0ZEk4ZkgyaEUuYUUyZ0AmYEArXUU0XEIwWkAuXD8rVz4uWTwrWjwmVDwrVzknWDghUzgmUTgoUTcjTTcoVTQdUDQgTjMhSjMlSzIeTS8aRy8dSikURC4fPy0fQikXOygaPiUUPCEQNiITMSATOxwKMRwNLBsNKBoPJhcMKRUIIhUJJxAEIRAFHRQJGxEGHA4DFw4EGgsBFQsCFwYADwwDDQoBDgkBCQkABwkADQgBCAgABggADAcBBgcADwUACwUBCAYACAQABgYABQQAAwUADwEACwEACQEABgIABgAABAIABQEABAAAAwAAAQIAAgEAAAEAAgABAQACAQAAAAAACP8AvQj0MqPEAQYzfPiAoURgHS916MSIMaiOEh8X6USKE4ePlyIrTqCYMWPFig0kSmw4UZDEiZAwZqiY4UFHq1/BijHzRi0ZMF3AcuGidcbLGC80SCoZc1SJ06UYL/pI6AMFihgoVviQwTUr1hUyYnDlGmOFWK5mS6CAEWMGjaQrSJo0SVLFy7grrJ4YMeLEiZkzioyhYygVLF3BmCULtqux41y5bOVqjAsXr13GiP0ixqgBAQIKQos+QPqAgQIDUqf+TCC1AQMKIDBYEGHHp1/LkhUThqtWLGHeuK0CBUoYPHjeuinXti2b8+bOnWOLHh2bdWzVsmu/bj079unYton/z+bLUh87Zn5EaPAhAgcQNeAEUqTplDFr3vJ7s0atf7Ro/TWkxAxIQXAAVU55sdRDBCk4oA+D0KFEJHzgkcWAd4mUl0shxWUXCSCe8JYPKrTACU7DMMMNNcz8RBkwf0wFV1wCKWSjUwvFpFBJMuSFwlgolACWDD6MYRENMtDgA5IxHOWFhDGUQJJcdJlklwpWmoSCXyeQMMIKKmSV1wxGRkLKLb8A88xijrUJWWNCWYZZZqJEgMBnouVZmmmoqcaaagO8xsBsD3yQxiWm1KJoLbggo8wqlkTqDDzxKNfNNtpoQ92m01XHHXbabXddqJ2KJx43yoDSR3o1iHCDCx9g//ABC1P8gYkmoNhCjX79UQMgNAGOoYQMZfhQwgAQ+GCUDjr4QEeEE3E1opFjGGJIHFjIdFcJJOglpltFzNClByR46AEHetzSyzDJtNviL43JAgwlPZZkVwxFFJHUWzToG5IKbc0QpQxZcVXjW2MZhWSSTMZAA1M+lCWmChTPBSbFboWUYV4bjIBCmFaROUgkmZxyizHGrDlMm4+1yctluRBjTCsiLIDAzYMusECeoZH2mmuAAiroAws4EMHRLPQBiimoQNrHIZFOk06ll2KqKXXXZTPdNdldw3WoYIdNqnhVa+PNNbEIYgYRROARxKsifPBBDXoosoknqCTDjTfTSP8jzTTTRAMNNEYJVKwSEAzwgo1FGmnRRQ0RVMIYg/ARCRYvzGUXtyCmdNcKNKwAIrcqwHCCBh3g0AowxRSziyWx3EJMY7QQk4oOb2n+FklJ1YWlSWXl5eNVNi4cbVhlSezVUdxOZGXFFdMll195vVSSSHK5FJgXmaTyyy/GKOZ6Y72UT34vu/TycmOapeGAAzYrMOj8O+vJZ6AGBD2AAAIMcAAEEHjfehBQtKSpygx9UFo46HGOqlmNU9aJztfERsGwWcdS21DONriBKlCsrRGJ0IMObsCCCICgBUMIRCY8AQpZNCMafZPGf6gBjaMMxiljMAGyLoKFjsTBKDg8y4D/YhKDRZShBSWwywZQsoELLLFbIfFchmayggt04AOk2Ey7dhEMXcALGLaghS6woIRwgalcFzOJX0rwublYJUhqyUoJ5mgV4WGFjSeYIxvDkpI5aklMfhmJj6onprhc7wQdQ2S5CBQJ7xEjF7IIBjDSV75KUpJluyAGJx4QAQeIRjbzmw3PFMCn/KmGf6gsQAH+BwGdifJmDTAhAvsQi3SsYx6mGo9zrqa1rHnta16rYKim4R3nYLAb6UCmcqoRC0sIIhGKUAQaXFCD9nygBWtYRCY4AQpULMNXgPuPU+owCMoZgg4MGIAPilUGjgymDA3ZCsNI8oIe8MEE3FqiPp8I/8U8CmlKpDsBBCxgAUZokRnBGAYwgNGLSdrCGIkwghJCpxIucSlEXLLYCkoQPBkIqVtw9ONEYGA6bs2RBB7wQAk04IE36iWjXbKe8OSypb70BQXaIxMnTkGMU2jiFsWopFDPhz5K6qIVLugkBD4JQFCGcjSmeU2fUNm/APgvNgY6wM4W8Jk7NcAMh0BGPOQRj1xCJxu8BE81sBHMrk2wgoArpjYspZx0yGNqyvGGMlDRCEUUAhF/YEENOhmBDrhgDo/AhCU0oStrEHMaRyFnGYTlgxQgSyFjwBaE+FAsL0xkQCXxQAX44AOUoqRzJDgtHkXyki2h1C4DxQAaToayYf8Eoxe62MUkZ2EMUuRgKl1ayYf8khK7ZPSPWjJpueBolYmMlHMchQFO6bgli1r0WyXZEl7mMoPObUBIK/DCJ17RU0uggotCNV/6GEq+XdwCERg4GgBDQ9CmOjVnPSuNKfcngAD4NwCkQdadCACbAwSAAAAgQANYIAtuUCo6Z71GprCmnbZWw8LCzA5a6aoceZA1HeoIRzrgwY1haOIQgOXDDY5mNA584AaBCAQjJmGKZFDDGtWgw5MiQgd4woABB+CKEjoyhkVEoikJoYESqqiBCxhhDE7c5xKpJ7zqbZS4KigBBDLAARGkQmbJ6IUkGTrJXAQDFjeQQZdSS9zTeo7/YsbFUhyxQi613FFLYIGBHvecEpD2qLoa8pFbqMTdKbnFeoEew3hltgxmDGMY6S3qJct3i1bUIL4YaKXNCFpf+4LSfqZE5X/9OwACf+bABmCAfwFw4AbUwBTWgMc1NpWNX85aOhUG5i8zrJ0Nc9jDwFaHOuJxHGiY4hCC0EMg4saB9TyAAx0wAh8WAQlN1AIa1nhIggYziDLIQAEVUIIk6KCRQSxiDJGIUIRU0MQmamAQWQbRErU7JSv7k6QUg0FKX6ADUSzDGIsZ80J3wYtgGCMPUdoAAF1qXY36SEhR6lwcm5ukiJVgKTOQrgyGdQKxbEktVdZuhqj3F0P/pWK8/1PCIFKhi5Q9oycBv61Qi6Eb8wFDEyCIFQbiC8BOAzCUs6kfAnzG3wEAmDWsUQAC3rcABmDAAjsj4AdEAAJLMEMb17gUMo8j4QlrrRqa8lqmbE32snedG8gMh9rTkY7goD0c4lF7N1bkCkGowQ1wQMMNRMCBBhCwBTnYwwo5gQpgJKQhTBnMGPiQAQYogQ4KqcMiBlERCC25yRfwgAY0cJQNeOBDHKp3HqNIgtJR7AWfZxYlUBbwhS5UfcFYRiWQSIIJQGC7WmqjGymO05TkhY5gYVLHw8IWL0QoJU5ZrUhcG0iNZcUumnuJcd3ylka+AmXLWFNQzTfzYti2fLQABP8LRNABLj/dAjv3+c9zVj9S7te/CGCABVLgAhdEfelEewAG6lc0akbgENDADRJWV7ImYbt2YbVWdliHdRMUVxemDXuTH90gdxyGQecQD5miDcWgCX2AB3GAB0MgN3YSASLQAmoACZzwCaOwFORGB3Xwgs+iAwpgAlIxMk9yAkSCAhdQAVF2ARewAoOwUlnmR4W0UUKSR6VHUjDwAh3Ab1iAB7iRDI8WDGNGhYmRCjaQRxUwAQ7nRhrCJSJlUmpBAhoAUkFyAi8QA3nkT0gIA8+iBH3mOXs2eji1URpzckfoF21hFouQCuRlDNnnfZGmPrbFGLSQC6cgBK+SAiFQfjv/xwHpp35OtVWkZBqpEQAYwAePsAl+uANJ5wAN0ACgiAAKQBvs8QENAAo3xhwidjYHWA3TYHZlB4u9AiDUIHYZCIGWkg0bxA0QyA0ZhEzaAHbQwAqHAAh4gAduYAMd0AEiEAGzAgSAMAmeQAMDIRBMQQfCIhtR4QVFoiw+IFo+6ETjqAF14AMaUAIqtSVFqF0XoyM6oG8zsQZrkAq58Wi2tVBUSHO/QAU4NQFc2IUW83FrdlJ99HshZTovQDAqhVJ4pBZ0hIR61GdsZBInhYSlt1EkcAEH2RZmchOsRwzbxzK4oFC3RQu3wAk4gAM54AKM2IjQxgHmV18+lzOiFGAE/9YChpAJoZAKizBgBkAAS9cAC0CUs2E0EfAARhML1LBW3ZAf14Bj2hE4zvAfVik4zjA4WOkMXNkMXgkNV2mVxASBEpQpHJRM4sGA18AMpuAHfuAGHtgCNnADIAAfP6AHh2BIhuYwM7BkCqABQtaXJOEBF6ABSzSO5AghiwN9aDSQwENSVKEDJjATWNAGl4AyCZWPwECFUsgMf5ACGxmQuZdRh7SGJ7V5IOIBMmAkXtAjXAEDMvACLnGRefQjdrhnKUUunwcmJ5BSpbeGvdlkB0kSkRAKpPAK32MMCvV6Q8VQvZALtwALk6AGQ6ADMfACLRACjaid5QeJnMZp64dfB//wGQegAB1ACHHAAATgX/1TagfQAETTdE73AUiJAH1gY2BnNhZGlVsJDV3plc3gDADaDMugDMoQoIOToFwJQw+oNbhoNt3AHNowHdUAD9qAC5YACH/QEWtwA0JQA3XJAj9QEg7HlzSwVFKSFA3hARQwATx4AQA5AeQIA0Y0IEeYFe5IPYbmA0ZgBB5gAjGxBn8APpn5aPq4DMPwDJxgAh6QARDwRmtEmoDWWjhVhtzSUklCMFdxnTEgXRI5OnXkUZyDUimljliCJSEiF+roAd/lR2CCAoMgCZIQCqdwEwOHPrnlGMTAULlwVH5ABGvgBD2gAznQAi3AAi/ZnU+XAef/ZwEQ8AAMAEpR9xnuaXT/1V+rIT8NcBAQgAEh8Gx20gCuEA0PeDbDFA1dqQzJoKrtcgzt8qrHgAyx6qrKUKAGigyOgqAMGkwGmIsRhA2UAg/N0JZ58AeAdQM3gAN1KQIhMUfNJ5g0UAIKcAElQQLRyqIxOgESEKM+GAJlwAcxoAJ9dKaBRD0BMwNjUQEaUDpYUI/KOQzCMAzEQAyPtgzFsAyvoG8ZQAFrpEfW1TlcYhXcIrDANxd69gII+wJMqnm6qVJXiloAW5Gbk4T4lpu5mQImkLHm9AiZIAqwsBnfAwwhO68kK7KsAIIc4RQ90JIugJ3c2YwZ0Ize6agP4FQ9/3NKo9ZfpBaUB8EA8QcBIcABzXYzh7AMpLo3TZkdgQMNzaCqyNAuxXBbCVWkrVO1Vts6w1AMsXqgCyoq2cBBaDdX3ZANwAYP1oChfZAHgUAIbZADe/cB/hpoZTElg0IuoiOjtscAMcqDFVABJJABRZQCYMItmmMSMKCXuzMRFFABHgADzKIJ7/poJDsMuYEyWGACGVABFslG1RVFT4RHOBpHnhMkvhcDKQADGWsCHVBnvtk5dZZHDTu4sKuOJkCGKoB6GpABE5ABqJMBIVATQ7YIjoCCozAKpUAKpFAKx3sKp6AKzFsKo3AJZ7AGfEAHcVAGWOADK0uoLqmd3guT5/83UD83GqGRGv0lAAUQAKi0GlrFAKnGASEQBzdgMyxQDM4wDXszDUlLlV6ZG8fgfZlphfg4wFcbr60jDMVwoEx7v1+HDWDLYfTgYcSmV6qioXxAWnJ5clgiF33JLDoQAgdAASuweSmlAXgLkIZpmGT6EM3Dm39RhNKTFHo2R447BHogM1lLssQQe8mAGXkQAQQ1hP50puoIIjEhExeTRCclXTCAsQgLA3BWAkzapikhsCFFpqNLUimwxaDZryrRZJsXxiQAA3FACIpACZSgCIkQY9AUTY7gCNAEx4gATdbigW2ABVhAqDmwxy3AiDIrs0/3qDULqTqjdPfDP5fanq7/QRqR6gAPkAOGEAlPEAE1oDfecBy94h+CA5YEaq9Zm7VV+6qinAzLUMrL0L+lvKpgSQ2x6A1tpx91xXayPGLIwQ3CAAqH4AiBwAdYEAIuDDok4SBKoAMvMChVWpgAuYV764OG6QEq1yEaw7lzcXJmkXEzfLo60ANtcH3yOq9Vmxu9YAyXAMQU4KwqoVJejE9ZliWlQ7svsMUmkAIIW7tzxLDkAqZras/2nEfyrLApFQK165so4YM8iDoaYAJYEAiGEE3W0tCJkAgNbQgxxsYPvcZ/4IFrgAWDKgUrawN9rJ1+zKiOCgEREED4NXQHYL46yz+qUQA/YwALwEkfMAeb/7BiIJAL1uBgZpvJqPof/pkb7fJoVUurqpobqUzKp3zUyZCrM3QNe1OB4ZBXyeHKrzysCXQHa8AGGsUvCaIEXUoBB1CGW6jMyazMhVmYZTgIBfES/vo7VxY9UPyj8pwDzMIJmUGy37wMwUAMqsABADSRKmWRn5MQUwJneoY6jdiMAK15pSeuhxnGYZwBvMtPZKqOJfAW54w6C0uYbKoBfWvQHZADfGAIi7AIF3zap80RfLDLenDB86EIEr3LeRAHbFCZWCAF3NvHhpoCjkhQT/cASilK7sdf7MnSLR0o8QfcIcAFKxYBq3CL+cHTXAmWCcqq3oePrXMM2q3dSD2gTf+r3cKAwMnQDAkaDQ/Ki+LxKbwYoSuSNmZgBkJAF73TL0sxURmnAYMCo8kMAQDpgyiseRugrtaoUkLs1l2Ib7ebzVnQA4EAPpJ73cyApLnwCzUAAfyqwVlSFtyChiVAUnr0Amuqnan7uxbreQaZmyRsmKelT6iZZT6YmxTDpJCdu5KdAR7gAxzBEWWQBTne4zneBm0QB22QB5HwxhAt0RWS41nA0TlgAy7Qkh9dfjOZlA4QdMONyOsbNEFJQMCNAQgAjaZwY9fgDTLkH0yrlf7ZtDR3wPHK3a9qoKdMoF55q9otq8fAtWBJqrMWQdLBHes9d9pwDOZhBk9MFW/RELn/g1ITID97y98u2rfqGsYF7QXmXDpKSBUkAZkZl0SlgxErS17AINTFED658VCAYAE/2JcKYi8CETp/sVFYEqVjikdkSjH13EdSFCQl/ESf+xKI5EQgogIqtdlNunm8u3kmgONOgON4fL0cgQXthL143E5xoAeZEAmU4AhqvMaBoGxJXts9MKhNHuUx2wGBfF9Xnsj6U2qlGKlCGQGlACxec5VpTt6CQ97QsAyuqhut0y5A3S6y+rSmnAzb7ap2rsA9nZ8Z+DXTQTa0nB/QsAqHkEQvAJn0TaKevQETwAAKsPHZCumQ7t88OAEkoUelMyWMk/ILQRIYMQZOkAOiQK/B/4DAKPMMuYELxOAJGECtqg5a1KctanQXauhPY4pSZTiZGXOl9wwiYgyxQoJTGwDZP8pSxW7sVl+mjuuExLw4y64QWOAEHtwD2osFlJAJmVAJkKDtEK3Qsu2BWYDHHd29HdCIIm1fHE9KqJGzWe4npLgAALYAfkAM8p7nTAug0fCV+I7UohzK3U3e/Uvw/9vvkH/nXwkgZId1aKWL8UBsyLEfsZBEl94v4TJH47iF8sPfEADyOwjy3OoBM/AC+bajKm8jmX54w2IImzHzo04MzxDhwZALrZACFTCEKEeiQZ9Hhj27nOOb5IISFFOmwk6mmleGbLpEJAwiPijPHtABJv/g2bm7uBWwuLnLzEcfAjHbpJLtAb+7uhm7/YodAi3gCJ3QCZuQCdm+7WsfY3pgx0vOvYy4xQARogMHCxYgHGSwQIGBAQMEBIAYQMBEiA0JGEBgAEAAAgh+oGJmrRk0ks1GNqM2MhpJaMyWLWP27JnLZDVrvnxJ02axZMZgJiM2bFgxnMtGkmTGrJkypkypRWu27FgvV5ZUqHgBw4cSGjNWzLhQ4cIGCBMmMDgwoWwFthfCsq1gdkIFEhdm+IAx464Pvnr3+vC7Vy9fHzJ6vAI2TNgxY8RkJis2S1ePDSVUrFBBosSJEys8ryhBQjQMFR5UhPZQwoMHEhk0qN7AmTP/idQlMrAWrcG1hw0afGe4kIFChQwdjBsnocGDcOJhfb+9oCGFCQ/TMxTvcF278YIZQnw31OlTJ06ZKDlC70hRIkOGAvHJEydOGyxSdORo8aJFCoEYChaEgAEFFmpoIgMFGCCihga4CICNEEAgAj9gMSYml4wy6sKXIDumGKGCATEYX3ipZRZZZIklxVVWXAUVU140BRQZZ7RkRhs10cSSGmesJZZVYgGlRlNUmCEvrr6aoYQNlnQrLAgOgMC5CZ57S6yxViNhBb6U8EIJwoqEIS/AxFSCq8BieIEUY25Kyhhjionsl01CWM0EE0oj8rLPVjhBM8sy83M11jZTrQRD/ze7qjTRNFsuAxMEMu667Ixr4bsXUkAzBAxCSKFTgrLzTQMTYuDPhBe++86EDkIwodQMKkCVgzlC6YS8TCBJz5FEECkkkD/wwGM+LHrIwYYWjq2UAwwieMABCBxISAEEDljwoYgUHMCAA7RdQEAEBlzAgTQuOYUVV06s5ccUY6ml3RdR+XHFWFChl8V1Y5GlFlx44cUXf4VZDBmmmnHGGWmkmaaaaq7RRptuHvbGm3jggYcbXFYhsQS9uqRBCT45C23JDVZjgIEmqTxZgw1oM1RLH7yA+cu8wqR5q75iiMEvGAz5BZhgemqMmGB6oUUXUlq4swQTEP1qBRQ445OEE/+Upm6zQFObWrOpN/NMhdlY88C3R1HNrjgOiusOA+P8w4ADDlbFoG1VO7Bzuu8mXTsDAC0omQEIInAgB1rJK4+S89Bbz7334BOW2GKNDUFZZpl9IFoFti3AoWsrypYhA5p94IEDRj9ggQdEOAQWZqCxhhpqrLGGm4jhoeYa2xtuGHZrbOcd94a5AZ6bh4F/uJttin84nHSWD0f55dORZ+JjTPGlliFXKLNjGkrjbAO3FiWhAgUmuMAsDZqMTjmWrzrhLx90APOFq17QK8wi9dozBhhcSEUVVVyBxStakQpWuIgVr+BDqWBQHM0Ehk+FshNrLlOCB3INBYYCWWdOIxr/QWmAAhCoAAa04x8INCsCEWjAAlS4Qgi1kAAv5MgLGbSghlzLQTfE4QAesKlIfGI8nCiPeQyHOPYEwoiBiA8bqjAELOgAch9Y1rJKmBCFXI4hBZJIABZkAAaYIA+UIEUoTECtbSlgARHAQSNg8YzYRcwbFINHNbRhu2z8znfZ2EYe8ZhHbQCvYcgDJCDD0Y3mdWN5s4OHM1Bhi12gAhQ4294MlCA1zZDAeysLjW9KFp30pUxlEpzaC14gA5zJgGakOU2iwpSVPWGGBCFwhCZKAQpSnMITngAFjkbxCki0oAPViaAH/PLAzgjKA2PxXpOsJBe5uMUsAaKWtWyIQ2pW/9OaDrpWQ7Q1OgVYTiElg4AZFQCBuIUgPKIgXCbUqc5K4Eo9iYCne/gQLDa0YQ1DuEELWNABtcUtAgGy3OUy5xCCNoQBMXjEJ1rxikwoQAAFeGi2ELCABnzgCJaIRUh218dpTANhe+xGNkQ60pHmMY8PM2kgVdq8Qg5SdvC4xipkAQxWyKh9qVTSMd2STLdYSUBRckuofBO2kVWyBCnogN2oo7LeDJWDvBkZbsJmAQwI4RCTaMQkLgFPRSACEY04RSHyo4NLTecFqLFMy05zKK8JKpnNnMvKLNmbCghoQAfoJhVVmBC+JgRalAudAyLQthMOtgNUpduqOPWdFLzgUf+VEojeIGA6DoQgB4HYRK2AuNlNbCITlRgiI97Zq1/FIYlVcCJkB4IBhPTtrlekIZRewAcf6sAAWZQIgw4AITMSYAEgsIQsmOE6aEQjGgmrBja4gQ3mNpe5JB0pNkRqUuoeD5DnKCTEvMGNHg3DFaXwhCYSMKAEFKAAo0tAetOL3rz6zTlCFerKBEUCE2RgQdzsZlkuUMnyueU6PaVAQlhQiERAwnCBIEQhvNoIVZwiEaLslAxkABzlFHMsJdCNcjKJPrNU4HwdRh/6fuOa870KLnqTlHGQmh1luc1tcfNOB5LDT362Kjv8KU6O+caAHa6KB3mABHnEQ7haeZadhsP/1XpIa8Q80GcIxqrUQADU2rtui4YG6KYFWrCAiFBkc9q8IQEa8ANQ5IIZ0XDdNYJH0udCN7p7tK5KizfIQXZDdtcQxiqKYYtTgLcRcmFAAvxWFrUAlNBx8bAH4pK+83FyZFH1AHUqQIHhDKfRV2KUcsJGpQxMtgNGVMR63kMIQyBiEhQ6BRYau6r6zrcE5fNACF5lYmYyswLJRLQzraTMV9V6LpS2AHEOAgEKFJqc2TEIBUiMgg0UB6nXsUAGOlU2ve14hyFoARsKQQnN+tDbtSKPkdVJiSTvaleB0EMc2DCE+0BOygZBSBUV0DkD1FtbV7xtRDaSzQFgM4YNAMEh/1axjNcFr4/BQ7hKhQdI4gWyeekIx3a5oYxVCCMYqGgwPDV2FvJtgHxwiYtZyqcBRJ9PLCZn9Pl4U5uwrWY3jYY0ydkyFytpoGQW4EN7GKGI9+gcEaowxiseYYOykS83WdpABRQd7Q+Lhebl6/hYwiJ18vX0mcORy7ALPWiu9w2cfYtSXBb1ql+awAKHRXZB+vaAwVq2DX/YhCg8wQlvf0IU4/khED8RRNCqB1eJ8FV81jCsHLjg2VQlYckUsi1tDajejr+iFm+4uX1rcbcqjMAPNAEMaiDcjZ8HfehF70aEc8N3vvjZd2HxiTwYIjsfLJlaKD2cChzkg88ktFxmP/97kAcnVFWydU85qQGRq2UuZsG5IyCRiU0YYhGPUAQkJmGKxoyCBcABKGaiXezik281xAehMy9wzAksab6WXM3JotObkzUKAiRQwfkyKZdl7neuWToBf47jwQ+C0CAPsADBUpsU6IE4IIRMOAVR0ITN2jtO2AQHvIQIvARKqIRKcATRWo9zywM8YAMsqIIegBwOmJwHCBAVkpYqqzcaKpCJsAgCWBDzqjfS2S0IUSEHEAE/ADrd0cHWWQmToAk4EYYR2QVcqIUT8ZEWeREbkRFTWAVaoAVUaIVW8ANFcISDiIu+MYvd476qCzmnAw4TYwsK643eSA70aYsQ842QmxL/4XumOKCES6A7QyCE89CESQAFYHgGWMCDFiiB7JsBU+m1ZuINk5s5Dqu6ouKM3wsqj2OL3as9KwQ/ADO+qxM++cqATTks1xAfLjqIE+qxUVGCnMsEUYCFUaAEHxKPW5o7TlhAIMqESxg35XsnI0o3dRsC/Iictkm8aDHBy7EyAxioFVTBAYBBexudFuItiooAFhCERrgEHJkRHMGRS7CEZ9SRa8TGbNSRRuBGS9AEUBgFKLwFWICFVhgFbkwBBiAftWAACZAAZUKfSxIZ8xMNkcGNzcgg1OCNJplHqTkBnZKvJhm2HsgETpg7OVgCPbgVHHGFZyCGSzgsdqwO7wi2/5GZAApgjbB4lf6bNNprpk4Ki+ObC5mbtGEbtgw4PmIzSZNkO8qJGwi4RBCatLrKNwUgwbaxgMp6AR8oAz5YBEf4BF3QBfC6u7vzoVtiwPJwRXYqt155jzi4J1xEKskhQb8pmQGxItIBxhdUwWI0xtEhgBk0IxVqAAy4ATyIPkhoBEZYy0QgLUD4Az/wgzuwAzVIg7s0gymYAiEAAhy4ARdwARZgAX2qASG4g0o4hVs4hUk4BEvohBTgvmFDJmSaxw0YgT6px8pcGc7QE68Jjaeix6Lyx7lijSU5H2LTMiDahEvYA0J4g0zABEzQBFSQiVS4AQwIMAYwjsFiuqRTOv8VuA7d6EhKAyHmcI1I8bALIE5iu0T/mDKAgrdhq0EHoE4HeIAGqM4IkByDWABiozQF0KIFoADDihxsywEliAM+CDVNoJBfOIVRGAVRkM+6o7u826wgIrd3ErV0YwMQxEV+IiGDcC2sREFgrDfz8kp7i8EDeCFk5C0zOjZUiZzj+I4PsFALdbEXixvnpKrBarEPcAERSAMcOYRD0ARdiIQXAA6zkADvqTV+ZJKdEhmmoo2luYpDMRTqaLlIw5IOqhMdXQ1g+wBK8AQfcoEQIIQKxJFScAxiwAOCCJDVcpvsYIuz8wDjGJtM/CUcO45LLIgIsIB/AkARylANjZtVqSz/gRABwQTMY3GBG4BTHPgBIRCCIMCCMqEDJTABBmAQBkAsTqmUFoCBHuhJQ0APcqkQYmCF9ySF+fS2uxMPvbtPIwOt8xC1P4CDKrinfOqP/4A3xbMrX1RQYEzQUaWWbSLQVPWbjQQou1qhV1UIB4WQjuiIFloAGnQAFuiDPiiFZ/gFReAU4is/5+CpJkm/9Ikq8Cm7ToEwO4ks7DiOK421WGOVsaGTguAAEVCE+nSEddqESvhGcvQEIBCIYOMPCWWVskIWUcqBds0BHeiBJsKCeV2DNZAP+cgDPdDXI2oPI+pXI/qDPUC3QNiDP/iDfNXXOZiDOMgCLCACIthLHuAB/wm7FJJDi3FquxRoAfywAR3AgvQ01FgCBV2ICWNQzFMghZSVz/mcz/oUj/EIt87yLEhgBMDTAz6Ig2ExvAn10v7zOqyUwVGFLXrbpgXFK4cogK8E2gTZHIh4oaet1bGkqAbATrZblg9ggRoQBFBgBWPwVU1gAU05CBS7G+y4jkiz1lY5Fo1d16xw13a9D3h1gmGRAXg1AieQgryVgiwog76VgzLAAidoAzdcWeZ7hG+VTfb8BcXshEgwBD6IhEWQQz7gg0EYBMpVWIWNgzmQg4WVg3nNAilYoiC4ARswXShzAWS5G+MwU39aFraD3er0ur2iop8VT7Tw07fR2BdwIv8dcIKeDIREcIRGwJFW8ImZuIVWOIXlTdnmJYVUUF67W9lve9m9Mw9d4bk/cAPUgrKytYD+izcC1Up7o6FivLLIa1oFeSG8Mp2WHKwTwoALdZsLtVARsF8RCFERqAE7EARBOAVYcAVTKAWsCgQ8yLn2aA9CeL5HiIQGjgQGdmAHdoRIoIQItuALjoRNsOBHeL5F8GBCAGFCkA8+CARF8LYjw4QI9ARdgAVOKAQpsAFNEYgprTYI+D9mEaxmwc7qxE6qpVrqpFpYFWIhBpdvmahYhZDdCtqBAsbL6c4FgJJoWxXe7QGPLYM4CARDUARyowRNGIVfON5kAAZXUAVUWN7/U0iFVCCFViCGWyiFUVDZlb27OLZeCtSVAt5UY9G/V/mP1pI3X2Q88kXQgXoIGrqmyouhb2GACOiAN/2BHzADM7ADO9hVP+jfQ+DGSQBXVsSlUigXV3CFVXCFRf0EShA1XwmWNiADLrCCIQgCHYDTwGSBD3CxZbHO0MHlXA6sW24WKpIWWXWhWsWA5Ru3SpiEY7aEYxaCD0ChW51VqF2QiICh9KVmiDjka8ZmbA4AaiE2cGqbpOLd+4jX9AxeRWAESLiEUYAFYCAGmxiGXCBj/0FZNAZjVYjP6X1UH3LA1YSEv/uVNeiBGyiWTg2QYVO8VB0dfBvahjCvYRTaFGQQ/6j9lgXAAB5QBFGA3laghVughVxgZ2IABl24hVvQhV/4BUUF5XNZl1LQBG4EBCCw3xAQAfr9gOMwU090gAVo0CAeYgZoAJ8G6gGRVaglAAWIgBSAYmVMBE9gvgjUhEuYhGpkgRRCgGnWt2zG6qzW6mq66ojAstHxMAx4ARGylByYVyfIgvTMOSpkhErABE9QhVsgBg+Bk2EAhlyABVYwhTO+hWcwhlJwXjl21Lmj1DvmQCZ6ssOjqikD1VBN6ITeSoYe5EF+6M5p0KoOy454ABbQg0tQBY0m6V5IDFaQBSd0QkYS5XtJkUOAS0DIgyFIFlpm3bO5jrj5UsAJHZ3uCP+q1SsifmarrmaOwKaOUANWnEZpDK8IIABr3uprDgBqCu7olm6nrWoEcNoA8Bsucg0KcIJVyY8c6IE1aIMrJmEtdoTzqATmU2dd6AWAsbhgAIZe2AUAVgVPJgZmUN4zdl46/gRVLA9IUIRC0N4mw6coext+YmwqQ2jGK8bJpmwFvS9t+RYZqtVwUQNIWOOSBgZgUBd2+RdfCEIQR4YRx9ob2Cd+uuUU9zqv8+GqdYAdtk5o+WlYPUFgbiGhhtWq/QARgANNOIWTJgZiCBpYQIQWOCEgHuKJsvElt9VXbfHC0k4QAIGsrYFHjmRK7gNBOISviupvXEJ48Z9F/YBuMQD/jLS5MuCUFwDvj40PPchiKqTAR0jvTfiEVNhoXMDzXeCXXdgF0bYFMkaFW1jUND5j5m1eR727wnEERPgD98hZEKyUPXZOG/bjBQ/kA3XwpMX0LcKrXzbiWZ2ozQaEUzAGa/AGaKgdNfOG5SEkQnqeeNhQZdnQWJ/SgVAsN+1YeB2CHuB1eO0BHugBHNABYB+CIeABWI5lZFH2Frjf+x1MDJhpFsABIgAEL6YX/zFjTfgDv8QBwRTMGsABIJgCM3CDO/ADQCjnSehig7ylUfDk5WUFViDHjR5p0d7wYQhyN3GTnrgJnLiQpIiJmVCKo1iJZ4CJVrhOAbmNuqqDxsoB/x9ggzhwc3+F8/Rm4ILkhFLQ6HOZhXbxeF4Qil2gBVVghQYr9JNH2Thu1P5eTV0x7HuyAVG6lBlmG8bmq14EZMY7X4YYZBYkHZu8gTaQgx7IgIWglo44IxzYhFtoBlN/I3iQB3lgh3m4B3zAh3lgB3twgzUgAg9cAollgik4gr6E07I3+xqogTj1yxvAgbV3AW4Pdx4QgimAgzzwg331qkSgwn42sEzQhAd8wLe+pU8441Iw/MNf3nKEhXGkd6E0aZPOdzeBCYCXicqv/IC3fGh4BpbgfJngfM5HM9dxndCnho7qKG5oHc03BjxgO4VXTgYYBAnrgSzAAzfvFUSgQv+t6qwGLshOEIX/SekUyZda4IVgGAZbsIVxzGv/MfnlJXRDr6VGTXTzaCdFMATtHZb70I/Iehsv/VSAkje8Gt+HtjctGgC8goAdeIRU0AU32QQByTen9a3MAwVhoAZ4iAd5oId7uId6qAd/AAh/AoUQQYNGDRs1afz4EXToUCNIlChVyrTJ0ydRokiROnUqFchUqlqRLNkKFkpYt1ayXKnrJUyWMGG1eqWSpaucsFyxOtlyJa1bL38BA0bsKDFjyZIta8rsKVRmzZpBq2r1qtVo1LRS69rVGthq18aS1aaNG1pvauHBQ2ssBwUNEA4sqJCBAoRBSpRgicMnEKJEiRT/OaJ0SdMmThUzcerkqRSrU6pYuYoVS5YsXryCBStmjJarkqxUeVSlKmQqj6pJafzEKVMnTpQcJQqEp00ZLD1yvGgRokOI3x04YLAAwTgEBgwWKGje/AD0AwamUzdQoIAAAwMGQCiz6ZSuZc+M7SGgHUCA9AEIsCeA4IOgWM28yaNH7549fPrxmTSJMigtQbUEky5CvSTTTwkGuKCALDH4YIA55RQgLLbIctmFsuQkCy2zyDJLLR/isguJvfQSjDDHHIOMMi22OJUzzmTlFTVgjXVWWmqtxRaPPfr4Y4/eENMBAxuUEIICDGTgAQUMDELHGH4ZkggjjlhpmCacNAZJ/yYWeeLJKB6hgsoqq1QWyyy7BJMMWLeMRtJoprWCGkge1cmRKJ90kudrtAXCBx9xZOGEDry10EIKKfyWQXHFIZfccs5FFx111w0gwHYKhGDEI60Y88wvaiBAQHoAoBfAduyhSsACEfwAii/XwFOffffcYxquueo6ma6rjKmKr2MKOyyxxQpb5phlKrtsmZY5exkywkgrjC/SvhhjjNFMM41YN3KjVjo8xjMuueTKcy666ZZrbjxAwqOjN9xYI6811EDTzDLJ6PKLJAkEIMEGHXSwAAR3UaCAF4s4EUccgQSSCCJXXtIlxVpygpEopZiS7CqUVSaLLc/Ia4srsLxC0v9kucBCSiiSRBLKySV5xDJHWmYSySKEAJpHHGgMcYMLwQnHKHIWRPDAAw40sFykz0kH3XTbbYddAQcwYEEMnbySSQgIUDop2NAhgMACDoDQhynLcEMrPcMy+/azccsSYi1114IL3rj4Uu20Karo4rXZRhONNNtW0+01ZimOFq3nvstWue5CHo88lK/bLpDxXlONNNLE2GK0e1uGiimgmG7JQ32obocZP7D+Qw0igADCBxAkIIAAEoxwgQUhHHdXciVIEighDzsS0UQUM7ZJYl9mNIrGwpqmLCzAMJOMLKyY/MopKq1chwQJJLCCJKml0sotrXDU0SeebHLzIobIH0j/Hm1U0YMNLfSm6HAYYECc0Y4GqaY5DWrWkdoAptOcBWQAAgt4mnQGELZJOQ0BCmhABFhgiVpIAx7xQAaLAKeMZmCrc52rBjZSmI0VZmMb2+gGDGEYjhnSkIbpOIc6cqgOyqWrhz481zzmcQ/71Eo/Q2SLN36kI25co15VwdcyjjEMX+AiRGUyRelAoQlLcDF1qusD61pXAxbMroxmPOPsIhAB2X2AAxEoTgKwI4AEjGAEFMBABzBAtONYoBOD4AMhEnEliigvMYnREkY+MQrobewUqFDFmExhGp6wghW0qOQtXpGKSNBAAAHAnQRmUAeQeIoYkfHIJ/T0vkg0QhGK/6jNH/DAhvvtZn8CExgHiOMoCPBSOQxwTgGlU4ABVK1qCjBA2KSGzLCNrZkHGJt7FtAAEJgBVuEgxzmyicN1kAOb2lwHOMPJjnGu4xzhDCc63NGOdbKzHeVYJzri6Q53gLMc5TjnPPOpz3zWox7z9Ic+8BEPX/gKFL7C4ulQ95CFCqKhDhUEQ/rQUIZE9It2sEMaMmqGjQoBCDjAQQ1CGlIygoAFImABSlEqgpWyIAQfENgFboe7BOhOAhSwgB47kAELMKADEFjEJvhgiMJIZDFdspjFUpkRUSxSY2IiXSlKIRnSnEJ7t0hFy0ZwuyKMQAJf+GrLJPGLZ+jCFB4JBf9aO7GJSkxiEpBgRCIKEQg9xGENZSCUoRQVnOEA0AJ+7aVyFvBLYEKtahM04Hamw8xmeg067ZGm2WrwjslSdrL5uCxl6/GOfnI2n+x0Rz/VuQ5zmCOe61TnPE9bj3zEEx3rfEc7Wvvad7hjsqZthzrb4Y96yAMZYqzBRoMb3C+u7qLEvcNF7XCH5SYXDnDIw3LhoJA0qOEO0qXCFD56gxzkgAc7COkPfoAGIgihvEDYbhSyYAQaFEECuJup7i5gF4GFwATJyUAHYpCKRSzCEZFY68QsckiLJZKpi4ReVLGoYKmeoiOpUAnLXvEF99KxCBaWBIa7ughjGGM1aHUNJy7/MbHZvNIQfMADXdcwhEId6lD80ykHMtDXXkKKOZIyQDCfowDoDJM6lFLspKbTHvcoYAEP2AeSk/yPfejjsvlI8j7+IZApC4Qf/eQHlq38j3/oo8mczYeX57nayk62HeYgM2zfkY/MTtaf6kgHKMIru/DSuc51xgEQgEAQIpA3z0DIaBqEmwYqYLejfs7zR0HqAhfwZtEpDSkQfpDoHMTACErwwgzc+8nc1REFF7iAB35jghTwFAIp6EAoSNFfAXeJeYf0BCKXemAEJ9gUUS1FmEgBkleEIhWvkET4ckfTInzB16EQXwFmcLJcsyZPntBEll4zm0QYIhDV5lkWpMDd/xzAAFEvvuWMAascYJI7yNU5N3USu8zpoGoA5nkmAqCMZH/swx9bvve95Y1kfPNb3/zG97zrLXB6E1zg8xbIlv1xD3lEA4xTuAELEv1RkfpZ4h+180cjPXGR3gBojk6pSUXwgZG30X/+U+MHRLAQHIzcAxo4AQk24C/0AICmIzBSBioQ6hC84AW+g0AIWhCHVmwiEhZR64Av9iXnzRrBprt1KUwXpo/0+hW87iooEyAJsL5iEDINABtK0+Bmu2YTqXxNJRzhyhLPta5V8EGhYLA/of1Gl359VGAl9TXpHPA6fve7df7eYwOoJz2kCgCUqYzwKDNe345v/OMdr/jJU/85yVNOOD3iIYs+qEEKweloeDceUheAPOQrPb3ISa76XBJHja5XY9KU1gAHxN4B0sTAIaoKCRdoYAMbqGMCTGWqf9VxBB6wgAoG0QIb6MAHPuCpBXYDM9h0AukExsjSFXlg03Gf+5pYpCgOUYmNaPLX4fvk7er4BbRqFXcB+MQzbIGK1bDGNXnSk7QnonZqnzgOuYG7objYXumSoyDHuBEWpSCQ4Anee1nKdAgfBAIAOqAZBaKZk1UgBsJWO1RWPnBZP62ZZtWWmH1ZPkyZO3AZPXgDKBxCIezBHLQBQ+SBDOIBHuSBHuhBHuDBctEgDbqBD+KBG8QBG/ggEbYBG7D/ARZYARZUQRUMwRAQQRMOQRDowA3YAAiIgP502xt8wi3QRCoMglZJgIWFj/jMkQSc4c1VQAXMQAosHxasQQuoUQfcwNCdwiZU38RkSZYsXfbB2ihwgiaAwiUAoibAGifoQQQQgANsgi78Wih8QVeJj+6MwFdt3Qh4UgBMADW0BTLgmih0QiZAAiIcgiF2CSVAAiSoXbX9QR7AARusgW7YQP4ER0vVXevtkrgNVjDxnaX83aVMjd9JTXtAEHTEE2W1U2XF1gbuUz7RVpplYDvxE5eB4GZVY21x1pjlQz00mT7YAz0gA+ogAh7AARowxA3mYA2e4zhaFw8GIRG+YxvE/6MRGiEarAEanAEUngE+EsGKddxJ6Y8KKEGXjIInAIIR1MEIoAcdfRUk2lzxkYAHeIAJLJ8OtMGf2AAGRMAN9IAi3AIpcIIovM8e8iEfLtLSgSQkIEEI7AEpdMIeEIIMJEcZ8NrWkWH4MORXRWIAJAAfWMOshAMueOInZAIiNMLZvUYmTEQlvBW1zVUN1hUW6ED+tNhetRHr4aK4lZsBLaACBqMwotsBsJMGtsM6qFaZkSU4jZNaskM9sANqrZM/5dZpsUNaruVqrVkGWhZeqtk6yAM8gIJDBIIbHKE54iAPyuAc4MEbwMFioqMbuCJkPuYaqMFkrgEc2KNB7COfmf+XR4mUCDTfIihCH6DCM2yCCUyYqXiVJAxCQ56h7qwACngACcwADAxBG+iBIAUCFXyAC+DBGYjCLZzCayjdxUDPKIACmCAnnoRC0XUAqQxABZRACehCKijBDDCAJHRd+4FSEdCRJKjfICyCYfACPNxHNwiDrbmGJ1xCa4CY8swGXDmMw9wGFgxBDthAFbZALbYRX/mP0TwAL9WYjelddQxTV1oKAiVWAVBHO61TOOHWPNEWPYmTWq4DM0JoNK6lhq7WPuxlBYKWNsJWOcFDMzjEIfjBHSCEH9ygYdKgHLyoHLyBjMLBHbhBjUYmHEhmPaoBGriiQdwjn21mxYHUB+j/T6D8wCkkEScwwAzcDh2NwCBIQnvRlGvKgAy0wAnMgA+wgR4YAmEsZRvgwBQgQiGARyoQWCp133GCwsx0QioA0iYpwQQwAARcQHbWwQxMQK9N6XstpFdxFVqdQtSZAjfcBz2kgzKgAij8ISeQHYhZjCmqYlOm2BD0wIrZgAvop9DgksnhFN4xjS7u2I8ZqN8JANUkKDAaADy1VjadU1la6Dq4VoNuIJnRKjKmFoaWZTvUw27pU1yK2Qj6Uzmcw7uggkTtAY2agRus6A3OAYw+q4y+wRG+4w8SoT1eaz1WgT3qIz46obcGARAsmgsYQRy4wCUkETUoAgMk5PB5FXtN/+kZXoAONJ+WrkHDKAIkXEJiQEIh3AFEVEIqUKcoXAz3Rd2iTt0okMIr8IsTvAKo/FoJVMAKjFL58AvWvRcoPeIIiBUroELUaQIuzMo94AM9OEMsmM5GNFueVF9sIGXaVYmfxFIbrAESFsr+tCH/sJ7dRQAEPIByDJBWbmWpYmyCXoeqtlY82RM7nVNsyRYyvgPSnhnUOu0zyuWu6kM/ndY+xSVntQMOwQM1HIId6MFiwoEQuAEOymAOygEesK0cwMHbLuYauEEb0K3d1u0a5K3eLmEVvCEW/O0SOmEUDkEL3IAOOIELIMIzPIM16AIdzAC7mooAYFjLcBUajkEZrP+BD9ABHhhPJTQPJ2ACJjBCJWDCJYAH93zCwRasR0CPLhjDL/yCry3uM6SCCUQCznyKMYRCJH7dTH3Bd0qCMbhCJJkONJSnQNxDNZxsKayPRtzfynLC+1QCRUzbtcUBHsSBbuiA3LVApurVLfXPyQUoYJGb00xHMGKsgSYoaZHWOLzvOJgW0sZT+5LW/LYvOpRWa9XvM8KWaVnW1H4oZ6FDOXnDLJgBYy6mGhCBG/BgD8ZBA/egc+XoK76iPNKsEeotLFaBFPQtExJaFVDBEywBCfdAD/iGDrSACKSCN3CRKNTBd+IOAAjAF2gSVmHYFxQBDYQnHyiBHOyBIHHJRXz/ArRdAqwdBnsuLCycwiI9na2NgiqMFYfpLu0aw+uOx6f8woQ5KSbCVyUagyaRxihYginQBz7UmzxUAy6AQvM6b560Rmy8D2MkpSrKZ6AMStzdpwBuan9mpF/hBaSYr7kF3jAhKAKZA/wmsjiMQ/syMjo4cmnVb2kxsjnEliS3rzLCU2m91mUZIwW6QxC9QyWngzVYwg/EKBmcARUchAMDIbUOJhtQsD2ygTwe4RFiKxZwwRIaRAgPARM+wQjzAA/owAuoQAfYgAgQwzNIVCRkmL8EwAhYXfnxWsuEJ84QQvEQhhHD2iccBqwtHbR5QvfELixAksdKFSwwAxZ/yuJO/zHt0u4vTOnXpcccLWQogHErkAYRW8IyxMM9JC89nKettfHzPm8qGaJrJCUklBj/MQwWACB3YSqiBB0fE+BfAS0CGhD6euUhR7L+moM9hbT+xtY53FNslUNtZXL+3q9rOe1n4ZZAcK1mVZY7jCySvVkxmMEdyMEM6uA5sq1zMUz2MgwEDybcRusbkAEZyKhSK/UVcMEVWIFUSzUwUzUwl3AFHMAAcIALiHMj4MEMgGHxbWzsSrM0/0JY4e4iyEEgKEIjTIImnK4npMazFfFrZAkoqIIt2EIWYZEyP4M6VzGHPQWHgQpaNyTGepIZUmIogEo+C+IhCIIlFOo/DxE99P9WFmHCJBQCImRE+0Bql1wCiSGCfO6BoOAVd72AC4DvphKNfx5N0jDNgIrqqE4NMV3KezXy+9oTOoR0SKODNplTrMqqbPU2JeNv097WaeHWNmJjbSWjrXSoOnBDnCWmA1vXHDgr27YyUftgGyB1UpPBFYw3eZM3VU81MKf3VS9BDzCAqTxAEHyUI8Dwd9YRsS3sL5w1fhtDKkhCJ7gMICUCXF+CSqiCKZUVKFiCHsZ1IAYiFyU4LbwzM0xxYb8zh1ksGWJsethcDcNuK0SdJSCCHfSBMMjDPKjDftADPCSqFlnCJFCCs5nkcEpvJiwlIyiCIRSPaecGFkjBbuTA94b/QKLslU7JWEbCXmwH1mzTtjBt9HbgTkiLg5RLuW+LQ0gHtzkl7W837fs2Mmnxtqzi1mc1dzMeYzuM7JYhKuzMgXMF4dvCLYyOI1F3N91+d7Q6dXlPtVUvgXovAQ+QMKA/gRQogKlEgBCogSHA8CPmJA1kZ36btdWJ1TO8wiKoFR8MxiQ0giWMgisAAyz8givsAiuYQjhDG4Mn+GGYQmADtmBXeDuDChieYRm632IPwi8Qw1WVgiY0wiGA0SFUgzrMg0CQrDykQzSsgumIGEeMglI1O42f4lvhuMOkWBv0eKHkwKH0xkTfUsmd3NEcjQMoeZEh4LodEDFZuT1ZOZWX/8OUUzmWn0M8rXs5JK0kd/lvh/nSNvfTTpY76IfCpYMp1AAOTDCcO9cbwCjBO5c81vmdi/d4O/x4TzWgT7yf/3mgDzp6rNQcLEJ2bl1ObqyvlV/IQyIN+JokcHwkwBUiXIIloIIp9YIq6IIsdCEsmE6DHwYXWQIo/PU7W/inWMPi/sLudpVrzjo909EgvEQqkMInWIIgrM4PrEI4zEM9/AM+3MM8XPbycp8b399Rdgn1klhTBsocxEG1+/h9ctvNbqpVnlxG8lK4+9IB6hhtU0e7p/uUg4Pea5M3aZO6t/uU17tv37v8TuCa4ftZDrs8TIMZgIALIITBl+3Bv2gcwP+BPF4+wzO1w1tBVFv1epOwMIc+oAvzEiQBAwTAAkTlIsBMKFjYVxXBBdQB66OVJGTVGc7AFwxCHSwC7h5PI1yCKbBCL7BCLrhC8Re/Leg6911CgoMCMAA9WFDDM0j/4qozOwO20Me6awabYs8RsfWaKGjCJCBCcf2AGTTDObyD1eODQHjjNviC6QgqnohCIqVSbIB9jaci2+kMUW9vD8QdQLxo0SJFCxYhQnzgwAEDQwwRIjxw4AACBAYXFWTUmPHAAQPgxIUUKRJcSXDnzoULZxLkSJfixsWMWa4cOnQ0adocZ9Ncu3fv2qFrN5Rou33+7sGTBQKEiDNq2LB5MxX/jhyrcuDAacOmTdc2bsC2mUqGzJUrVqw8UftkSVu3bXnskMsDblweSRgMCMEnjqRXvySNkPBF0iAvKCSFkiTpS2PBEgQXKTKDTqRInHTBAmXJFSpbrnqt2uUqlytaoFBr2mwq1zNqz6xZe/2M2TPaxozZtk1M1xfBIx4nEB5AgIAERb4sCkVJUSBAffrYsfOjBqht9v7h8/dv3z599sIhM2Wq1ClSokR9+iQqVKhPnThlyhQ/EyVHihIZ0s+Hz5w4WbDAwokedMgBBoFccMGgEDpQqIOFMHjogQcqsugiBhZYYCMFOmqpJHFYYkmlb1RaiSWXzhGJppByugknnmD8/+kdm4QiCp2j6KlGEBBY4GCNNdRQQwwxurpKjq6i8sqrH8kyC6212HprCR7oikuuuai8cgcOFnBBub9+CcU3CQYJZZAVFlvsiyJGSECCNyEb4QQaFunkE2OsYUUTTUpBpbRbSINFF1dGAUU1UHBZBhpmFLWGG2tqYyZS3Gyz5hljWhlkBOTYFEw4AYhLYNMy7wvkj+jMSIMF6oRRxx58uMsnn33woQeeZlAppRRSeE0vFPbcg48TT+irBBJGFHkEP0MC4QOPOOJoI0AddLDBhhsSdOEghBBSKEKIMLDAggovxHBDkkBCCaUQwSHHXRNNQvEcnFYMycUWg6LRHHTeyf9nXxptWueoeI6p4YMPMGBjjTPIGBLAsciICg00kFT4RzScTAvKKKm0smMt5wJZBBbISOWVv4w5WbH2FFvMzE3hhHOEDUaYYRFJNvlElVIu0eQSUEaRBTRYbkmFFdRAWSUZaqiBBppmqLHmGFuYsdQ2SXODzbZfUhlkkMZ8A67N4kQdYZBODEnEDztQTWNkESzRRh5Y95n1H6ToiSeaWMozTxRez3PvPTs/4YQ+SiChJBJlmQ1EDz3waGONaXXYIQdsFWSBhQUTcgiDDMKtsKILNcwopA9PD4mcEsNx13WT1I39nHVarJ3GmMwxJyZ+2+kpn3d6cqcccdYROKlV0sD/AYcQ0FiDjYaJFOsNMt6AIw44uFry4oydfOJJjulSa8orqXyLhyBqEEKRk0/+pX2uWU5MTDYlcLP+ODcoog5JFuEEkmH3hAnVlAIUqiDWKEZRimBwAx4N9AY3tAGPazQtGVV74KOsFhtrpMxMYGvMIAKTAOO4yWuJCIQfUNiHO9yhBj/owyGaIY97/IM7d7vHPeihDnlUIxaoucQjHtGJUHRiE5wo4nyMuAn5VCISjkBW4/jwuMhhYQjVula2ttUBhDTIc+ESV0UcwICJmIsjw3MJSMChkpKwTo0lkV3s6EUvgOluX7rjnVB+YhPhlWMd56iVNQ6Rhie4gHlSIcsb/+QQh6lMpQ1ZicojJzaxsqCle09yC5XUYiUsdaxjQRBCDdAQilSM8hWpaM8oTWnKxHytTW8STpw29QUveIEPeShEJ0SxCU94Yk+awAQvPQGKUtAiGdCwhjcamExuQAMXtVCGNrwRTW5UKmocXMwg6gBCNQnGOEWIBB+Y5Yc8jHOFPxAC20ABD3r4ox71uAc+7jGPedyQHtiIhSU0UYlHiIITdhJWPw1nxExUohKIu08iChEIhQYiD3FYQxWoFRfMtQAh2+ocQziQAXGJa0IQeADpMhLH07GLdSRqHbveiBI5oiN3uhuHOXIyFJv0KyjtKB471EEPeeAiVTzQFhbWQP8W6r2hDFjIwlEhOTE2TOwMZ8DYWdCisbRM6WPjA9lVd8ADGwzhBoFoRStMxjJRjtJ92hxTzDYFnDVJZgY6iEMnSvmrYY2il5Y4xCEs8TNUyKIYy3BUMr2hDW10Ax7R9IbTqHGNabYiEXQ4GykV47UivGkQi4iDqfJwBzys8A7mNIMd/FAMGd5wHuyghzz9wc55dMMX+KTE386jHvh0grZEVOIS7fPEQCDUcdHCQhWoMAQcYE5BCaIogz7woA5EKFwQiUBFJIKhBdBrpCQt0TdIRA6UquskKjUjTXInk53URKZCyUe+iqeOc8jDG5rogxUSxIIAYYELTSUDgI4K1DX/RBINEpvYGqCqMbZkkpOa1NINsGo5G+RgCZAgxS10UUpTihJMZgWOcEbgQRCuaQU08EIkEvOKUDwCEpg4RCMagcI7+OGuJ26EJSxhClTg4hjRiMY1uoHMeBSWGz2WJjNu8VVg2GYZvwCrKRdBB0kYAg9/2Cxny/mDKcABEHHTqTywLMN66KMf/eAHPbwhDEOZ4hQIPI8Ra1vbTax5oAU96LKa9SyusIEKPLhcgibKLQY9CELMDZ1EwuhSdK2RjSNSiXbZBTvZqUi8u7OJjdDhDnekVx3qiEc8lKHCJWhLBFaYbxXOwAUuGPWoP/IvU5uKhu+JbwlsKbCB5XIDBGM1/wYpuFYN7vCJVkSYfaR8RZo6JSoPgs1rjUlTKgmBByrAwQ5CSEMe9LCHQBBiD3pQg3Si80JLJA0XyoBGNa5hWHikIx7pKOwDDesNSxkjwqn4RCYEcYdxgsUNbJBOC4EwBTsIIhYN1CE92LHlWfUDKfJIRzPGUwryjEI9DZetsOCzRGM5wom8ZWgc8hC5KgzBzje4swtSoOeQd4DPDWHucycUk5GIqNCsQzRLzqFoOA6vHI3eCcDyFWl2rAOn6migKczABhxw+glSCBAa1NCwAAFIv86bGKiJEPXvXbIunLySrK8+61jnIAUwaIELblCDGxSCFK/QxdlPZrLCDEIyb/9CzrDX9IXKuqyUpFgEH9wwBSAIwQzYw4NVHhcEIFDnB+akzmcPoQlT1OIYie1xN7oRDmQ20NwPpMYy2v0JRyRihXhww1bsbYcW3uCc0IGGPOKhDnnOg500rAc8deoMWYBiPEDbZXoanmb4KJGglMitIvTjuD9Arg1o4HhWd4C5FCx/ICHfMwceBLpvQWAcZzTJSlp+aHLE3I3c7+7MxVFz8f7LRTQqhzt2zg52nAMezuhD0G/AAhB8oOhOwIJTxcAFoweoCvNFA3CpIOqIYAjWoupeTZNkLQEVMNZkjQVEoAVs4AV0IAZiYA424RRQxn1E7GvYRNjgLu6QQ5vSbhH/fOAMhOCTcAAIgCDqhIAIqIMFaqAGhmu4YPAGcOAH9u0QhqmYokGDomnceAxS3CcVOmHzMksrfkQ6zIAFwo4I7MAMfsAUuEEezsFV6uEfZiW1/AEf8GEecqQWxoM80gM9HK7hdkmgBko+IOGgGgezsGfAxicHsmUgCML5uIXkMsAhqm/lEg27voHQts/7uOv71KVebM78akIozqG0eI4dzM0UfiANgkAOD2YJpMAHeoAKqCAKmiAKsMAKpMDTuKAKuIAKnoAKquD/TFF8DjAIzgf5ZA0HdmC4wO5ybFHWROABW+AFZOAFYmAH2IATWuEWiEE3AIPt3O4DQTDuyuRk/wbBB6pAeX4AB4LAWmKQOpoiF0UA7GwA7DJRDdKgD/ygESbBE0oBFmxhGPxKsSDoUZ6hyF7hFIrQVOAAKvZLCUUgBk/QDGrADJQhHuRhHfTBHfThHfxBH7SwHvoBH9hLGMYDFWChFdAD93DP4dBQoIwFWRIhP0xFDxRJ1KygCZLAznLAWiKQDkPODvEQA1Ru5dbl+hItXlzCjF6iJmHCJsphX2zqhvDBHdqBHeCBGuxgCnbACrZgCZCADDixCbjgLKJgC/IvCqQyJJ9gC67AKgMMSqZgCIYgCLxS8HgACJTnBnQAB8pS1nIABy4HLW/ABqjFWjwuB3IgBFqACEShGP9p41LE5DeU0TeKgAYkg0384hUGQQl0oIpuQGG64kdSrakccwBB7Ss0a7P+ABEcgRJU4xRcARiSwTVi4zWIARZOQRQyQW3uwJHYACyko95C7wnNABS4IR0Isjv8QVbayR7ugR/8wR7kgbVAARV6gRhUITX2RD5077aWiOKWJaH+oKEk57eqSC7l8OtQUs+eTw9lYiReMiZhpyVs8jtZpObMYV50ch140h/cgRzgYRZ+YAeSIAlEEj6XUiqboBPFYAukcj7zcynrk9W48isFTyzH0ix1gCyp5UClUy7bskATUC4HwgaE4BJ+4WpSoQ46RTKUMTDf7gv+ghTGgFrk0Ab/quBHqqD/No4re6AHVHAsbwBAvVIN8gAQAgERSowTSoEVbmEYsqbIRPMTKEEQ8qAe1UCpHmmpkE460AAKayH1uOMobNMe5sEe7AEh8aHcxIMXLkVXQGGXKCETZGtw1ozNJg4/NrIjnwVJsIBACgQGSlJBms8OkUshxEs7B7G6ZBJ1TiI84wgnVKQmYkKlAuaG7sEf1iEdruEQasA933NR67M+5xM/+bMT6bNR+zNK/vN8vJIHlGcGGdRAETQHQLQkZe1TQ8BagkANDgEWrIEYIiFsGmND4W5Dy+QXjKETBqQkvy4HULQHuDIHCGQtZa0GTNIkxW4I1gAO8uAPAqEQ/xJhEjRhFE6hFWjhFmgBFlSBFDxhEgohD9qACqZAAJ0KDVKNv5bwEKqBHO6hO+omH+pBnqTUneYBy9JBGWohGfIkgTyhiDihDAPKcOSjPu7joBSqOfHgTNdACn5VOt2UDgniDj9gTkli0UAkREYqJFAi/PY0YxNxJ/poHYRiHbjwO1ZHGFgAB+BTLhY1ZSk1UuUzPym1CfyzKwFUU1NQLKklAUNVLg+0UwtEOm0AAm3AqfzAlOrAL9eqL8FmBgjjFYzBEHpVW1rAUw9zCEC1QBRQWE0SAmORCKhADeRND/6gMhsBMz1BFBhuly6BEQIBD9DAW7mSKwUwbokgSXmk3//WyR/24R3aVZ7a6YZkiB3mIR2kQRiYIRf8ZhM0YV/N0BNqy1/lwz7WED8Sqlmi6FkAxAkwMWG7cWE5JwTCaxxoUkXAc7ssNqVip3jIk48qrXhAVjvU4RuuwRJA4AjeE2VrV1Hhsz7fs1F3dylTNgnqIlOpxCs3dVN3VkGvRQHJUnmrFmiHoP/yoLK+ADI0FGmLQFMYQANKCQ0EL+y+LgFxQFNjcVMVcFhdAC5vYAhQsb/awKHcIFlnVBEUoRAQAREuLk0HMEC/UgVPsH/NgCnMIBriYVD/oR7QD3DbaZ7uwR7Qkx3kYRqOIVdGIT0uQXE9QT126Qzp418NikwnV6H/IOc/skBhNu5X29JaFMT5xIu6MDZ0R6IctvNEZE52WNe71EUdiocL74EcugEZ5O9KUhaId1d3h5hRf/c9sySrqCR8l5h8CRREZc0kFXAGbfAw74+rqqANwMkQCqNNMuxo+zIUfm0DQoAUHMGcgCAGa8AFeEDWqER5WTQBTTJBTJJXURG41mAI9Ku/6rEe0YAIetYGArRmV1QFDbkFmQIETCEd5qaA0a8RJ22B0ZOG1ssbjmEVCIhYNKEiMTiDdw853Uwj9SP4aglaomVySrhn25JhbZKFaxInEg1ETFddUHdeYBglcHgdtnAewqEaQCECRECIb1dl49OIjzhlNalj/5i4eDk1Z0syecFXeYAgCPR4DdzgBuotDvijslaAepH2C7IpFX7BfUjBS/XADMyACHAAazdVfJVXjuFyWK1Fa6tWB3oAaAtERYHgDLoSB+a4eA2ZkA9ZCCACBH4ghgYVStVvHgy4HbQjtXSTIeUBHpABFVCDlyaSDMuQcZOI9+zjPuRXckG4YKFFYahoCFK0QLpxID63Xlz5O2EuRSa2+0y3eCw2ECttC9WhG5yhBiLgA0Cmdn9Xd4v5mIM4ic9neIOAmW0wQXUWfaMZB1qQCM7AmqU6DfBADwwBGZWW2D4QhDLQ7FIhE+DgDuzgj9vSjd35nU/4hOW5G1H4WtwSIf/o0AVi8I+78pltoJ0D2pD9GgjABQTSaW4UmqHbyR20MLW4EPbkIRos2lAmeCLL8OGIKOIGag0pjg2ZhT/0oKFOOY9ROpBtILz69JWtb7tMlxBzmXbEQV0CcQvzBhdqQAQ4IIhx95hflneLGIntYniTWlNpli2VNwbBVwVlcArO4H39QBD6QBBOTD4MwQdmoHrBJjAbQ4zNrtc2AQ/8YIXsgA2is3vZWnmhWQHruVoOdL5+KxVT02LOIH/fNr6HIH/5dwo+qQaGgA0a4fRuSB0keR8MWG/3lm93M3CdARXw6QzZLBIUoeH6ibbWrFgojhGUs3HCtpSjhQ1OlCsLhA7/XQp0XbkmaI4mYW6G36i7TgKn36jS4Im9LGEbP8C2b9uoc5eIc3dRDdAVXVGZx9IWFbSNU3AIqhosvDZZEUERJiGv9qRsSeHdsKm6OUUy6gC7s/tkWqETmuMQBEGc8IANfuuPBY9FybeKxzcu5TKlrchaUvR5S9Sp9iuSBlC+4zvqunIK7HwKmLAH8KAPTCEedApwB9Ug26kepPRd6yEf/sEd1CEd9mbbdqlwbssMdc9xCwoS1pAR8oM5QTjj4sDLUZlq23SFv4vmSPsmXiJE1KV0v4+mq1C9cLnSWDxvkIE6aHtRg/qIi5pSd/s92eI/hZeTlKeNbVCpqSAI5ras/5MVEMBWEJC8Z3YJNcrjq1qBFDphEOhg2K6XaYmBVnFjCP2HESAhEQSBYLFHDQIwzGNRQKs2LZm5QHb23XWAmuOcqqlaXIlACCaRWniVzePbzocAz/GbDaADGVBPHthhSt2hC1ePbw0YC+uBHcIBHqrBF4QJNQxnzSY7zRy3zTJSpCd3+M50Kx6qB6RT1HMCJz7XRU67O0s3dgix1VMd1v3bVkCBOhYC1mhcJHU+t4s6CXrd13V8x337fDSRvZtH3vwAEOi3fsdWEy44gcpDFVgBFmChWuNKEiLBa+qkFYyBGZKBUi7lFZp8ExiBEhph3J2s04PkvbtSLAM6QduZSv/UFN7j3SuBPuoeE9/fdt9R+iv/fSunoAZYgAim4DksgYHSAafqYTcV3rB/wh1oyB/m4RvcpRuUwaJNARQAagzTg3Fl6+L/FbcqjlkRYXJDGFokB2ELxORfBB3mlE8HjeVFIuZeMnYqTaVaG9Z1Chr6QAgcEAPuQphxm+d9l1GjwHw+JomzagmoeX3ZICvggLtlFBEonMIrwekT6BROQepdgeqrvuohDBZS4RRSoRVgIReSYRmaoTZAUzTpahIuARIUwX4dBw/GKePcYL/eO39TlEA2dZoBIggQIEMKBgmiQ8cNgTgGAgkyhIhEiQWHnDlTpWDGigUlTpmCowYOImr/7PTh5Q2eunP1/NnDZ89evXw0af7z5+/evHPn5tFzFssUqFGfPIk6KurTp05Kl3LitGlTpqiZLlGCxEiR1kSFAv3RkwdsnDhZsDxZYm7cOHHl2pYThy7u2nHmxLFta1ccuL17eZ7LK87vOb5+1a38W+6cYXX04sX6MYXFhwhPkli+jDlzk82bo3iO0uRyE888lpjmgXoJ6tWln2hE0wYOnDx49PwJhIgRJEqOJmHi9KnUKVXEW8GidSv5r1+6egFb/uvWr2DJmlGjZs3aM2O/XJXSpImTpkuQHDVCJAgRoq5/aONhw2YNxo046jscWPHgkINA6tuHWNFERJyhURVV/1xEIEdEfCRSDT9IZMch0cSjTjv11IMPPvXoU1NNOGnoTj76vIMPPdPEAkqKnCB1VFNNddLJU5tAJdUllZTniCOKcBVIIHz4mEccbWTBhRVqqeVWW3GhM9c4Sb5lFzhRCoZXXjwRpphhPLHFk2H0aGOJGUiwgAFloWWGJmacrcnmZktUtJppqrX2xBNUUIEGG7LVpocfgKTXyCSVVPJbcKek0opxt+jCaC/LGUMMMMMMQwwxvxjDzDPRXGcNNdAsMwwtp3gC3CfiXXLJJI0wwup6gPzRHh5uwMcGFvsdhCuu/T0E4EE9/PrrEMEaSGwVa6xhK0fKDhFZDc6esQYRP/+sgg077cwzj0zv1KRPt/m0g1NL//TTzz770JNNLSkaxWJSLipF6lM0VnUjJOXtiIhXPeqBhxxykMHFkUuWY05cBB8JFzpVAmaXXwsDxhc4gvHU1jqLySOMHXrsIMIHDvBw2Q47JHFmmiR7VhkPTdTJspxTnMUazKY9YUXNVegJB59/ABLIIYwIigkmm3gyinCJGsfoL5ISYwykxBRTTKWYPgMNp502k0wwtrgyCiejEHVqJY3YywiPsMIq61hsVIFG22cQERHcAjkkEIAFBTvsRkNgwTcWBl5koER3TjGECw4KAcQNZ/xgBzLkgFOOP+z48862NHm7Tz7+mPvPPuX//lMiN76kWAoppLD4LryerA5VJvRalaNWhgTCnh5zzCFHG+bsvrtcae2+FsPCD098OcHfVc467GT7Tjv2yOMNKHbksQYQaOCwRMkmk7wyy3ZacYYVg39EuGnbY0YzF2S8IcfteuzRIyKLOFKJ68CNQgqisBx3Sy66LN0oYAAjGJRKRqaY0QxnQAMazVhGMXqxNVWUYhSr88R4UsUbRawnEPxqj2zYgIYp4Mlvd9NBDoSVgxvcIAc66EFCWmjCFi5rhkOoQrKoUBEqXERweWKDGn4ACm/MIx/7wMk/jojEI9LEXDW5iYbqcY9uHGNdouBEJiqhwRepbl6u4015spKI/0T0qEdfwUMb4mOOd/QOHWl5BxuBZxe1xPFIUGLY8cRxR+FdyB7tsJA65NGMPtwhD2/7yBM2cz7uWYFlH7mTI8lHuEMicnubSd/62qeH9wWCEItgxCMqcQlOGIUUp2BFK1jhCuQ4JxjAyEUunAOMpyVjGcxAYDNu2cCsQZAWrjjFBCsInktgIoMa1NdXwCKbDx4LWRwBVg8KkhBnPrMiBqqI3/RWzVspaEF4OtYPf4AMepjLiElEornOeU583OMf+RhHPbqhDFOA5xOboMQlGqHForCOi5S4iiOysqNCzM4reoiDG9xQOTeio3noaMcbeUcX3hVsSQp70pEueiSJ7v+uHvPQR1zcoQ54oMIMBY3DGnBABSuAJpEk8x4kRUgFSA7hkInkjCXZNwfbwY8QhljEI66SCeCIgpSqGI4rFvWLXvSif7uQVDFmScta3nIZy0hGMYKxS1egwpdfY50mpHIjHXGFPbACSx6CdMYzZoQ1PMDVaobgSBzC1UCOLBY2c3inuEmkh2qoAQgswY177AOJImriEbvVrXIecY/ycMYqUgQKT6DKXS7yRFE6ERWpuC6s/9xRIgxROzzgIaGk7aNDJ+pQiprWtA3t45IKBtuHarQc9gjRO8bxDXhI4xB98EMb8HAGIQRBpVGwzCTT5NJGwlSmND2fTa2gPpzaTpP/PH1EeSgRVKKRcjisgEX/GNU/50ANqlVNRjKOMQxh8IIXuLAFLWThCuKcoqv7tGJYNZiIDRI0D+2Jg2zagIa4CvhWVCjWnYhVV7sayG8CjukUiNA2O0hYBD+ogS/ksc59cKhDSESsPsw5WH/gox3rsAc9sIEiFa0IdS6KEVVcd0UcAfSz7Dkrad2BYxw3rx2kfceF6pFjd/S4cjzecWmLTOR2aKhy3/iGN2JhkrMGGA44uMIWtLc9lz5yfB8Zgko7A5rjrsmSbYhDTnMKv0AYghE6gkQlZvQJUpJSf97VxaJi+VSqmvcYxyjGMIJBwD/3YheuhEVRJ6hP4GA2ExlM/4RWNnjMP/iBX3eAgxra9kiYVgGHeELDpum66QYnuMDXJNYTpnCGCEsYBM4CrDw2l7klDrbDHx5X5zR3D3XMwx/ryMk2cEFF07ULKUqRV1Cv6E8diZWseujQjy8k5B4/+9k0qVy1h4zthLoDH5QzxzfSQQ1LmMQOeGibCK0cGpGJzGTei+tyyeflMHuGM2raDHTXV+bboXmna04EmykhNKNYdhSnGI5xvPsLps2SGeY9L9Qe7mdg9CIXt4AFK7iaaFKB9V5bWU9X9ACIV/nBPXhIpqXVgHI4tGHl/4VP2+haYE+HOsHI8hvfaJZqNEjYDiBg9Q9qEQ98aLiwR8SJh/9x4o9bu4Qd9vDHh3OSjtFF1nRUP127XvQUZMdOrJD+AxFjnY9nRzuh9bBHt36sD7A7e9r5OHIft91tJ/vCDNOzA8qpwIM2WLm4IWM3IyHJ5Y9Y4UyjCQ29RUOze5NhLGTwl/vgByvaOVo3jAjUJTRBtEO1gha9GMbC9+xnQA8QqxOnuCtYgYoJUtATQ6NR0AY1KLIxYj1hVE8hujLG3If8bGdzz0FntUzZrMFtb0v1sRC0hpqhYfg6t0MEPkDhPlCDHv/wcLfuoRN7zAP73Ofwt8hlLnyEY4pDOUrVhypsFssIdsTkUSC+njnEsv3DUNQH0nGCznNqzvod6j+GKIf/Dt+QDaDwA7IhYVMQBHBABWKwBSt1eKJRSTVzaoTDLOPjYGE2Ghj4gE2QGjPDN61RM9F1EWqQM6KlB3eAgrZxCJMgSqSgCrCQC8TQcFY1KX8GaKw0aKanVaUwQaJgQfAiI1ERhJsQNJBgI1dhL/+ECGFUe7aXe14BK2clWr83hQcVH8OHERchH1VgBW0TLc0XAREgAjhgBrEgDzBRf9xnD8uzffRwD274Yed0f0dUIvAQT6NgfulXdelHbKYCY5XQaF2BTuUSYvpgdmlXdBlyD0eXdNV3ORtydpB4IdZGExgidPugDspgBkdwVndgd2qQag2YJocXgTWzSF2mXI3E/yYQKGZzsgRSIAV80wNSYIpW0Hg4k0y2kUk8kxuXMHClBIPDMF7m1TSVQgy98D8CRHGG5kulkDqmEhVCAxVCQ4SYgEH1ch7qoR6HgAjcWAgeBwh+Eo5lBRZ4cAeihYLCt3xo8DZwU0M5twYSlgZ2QAR2wAZ3IAiH4Az0gA83cRNIlyGKqE7cR5D0YJAHKQ/wAA/WoAoUhIdDNWxX1xQ0IhX+tCPs5DngN1iGaHaNeA8BeX+IVU7WJ3/1QIlhlyE3EQ+rUAM7IAfm+IlnwAUNeFyiAYFL4D3i42CN5EhtwoqioRqmAYuxOIumyAXsAwfwsSe6eBvfyAhvtgmG0l2vtP80xliMkeIcS7U/rCBBpKB6p1MUUEEjFEmERAhK9QIJjaCW2biNS6gegcAzO/MqklaO5ZiO8REfbkMEB+I2zIdyRCAEa5AHftAHpgAPbliQB4mQCekN3sAN2TAN0eAMzYAMyOALuFALsRALstAIvkg0SRGREhmWWRdj/3QP5VAPGfk5HGl/R0SQJNl/IkKS+jCJlvMO28Zt9nANfeAscuBfboByasAFYoCB9VYyTWAazMKTFAhTMTVvq/iASZAaTzCUWDCLsRhdcvBBs5FJmdSUjuZmlxCVBKcKxkEL/iNAUlOMzJELhiZfvjRfn+AuSUEqv/FVQ3hBqTIJ+7mfa6n/lkuoQerxJ38gCLx3VoM5cnmAgr/3eyB0EcSHJygHBBLhiX0gCLHAZ8LgC5kZC6tgCkIBCpZgCYcgCH1gon1gB2ZgBj8gAjXAAs7iVxVmB5OwelYXkTb6LhqHbJCgDCsRIuDHTjLhYdgXE8/mLTVROR6GdrVJWiJ2D/EgDBXGAm+wnaA4k8VpXBtYJy/1Uo70BM8JZtDJgalRnbHIN+uDlHsSFt15G4igCP8GcPdDSqZknsmhC8sRKXZGCxdHHEUlZwRHn6VSn+EhL1ERTPzJn/55HluRX+nhqH8icmeToOeIgnfwe23TQ20DYWigBhNKBBXaByv6A6PqLBU2qqeK/6qp+gNAAKNA4Ael8KGmgAq9BAo9aKN5eKuUFZabVQmHIA3d8A2paS4con0X0i1FOm1GiljIaqQm2WM5AT0EWAMioJ0nx45WQJM1SYpNUIvdagVXcAU1A65gmoEZqIFnIZRm2jdYcEnVOhZjwV9N6aY5Yi/YJVRUV3B92l38AwunVFSpUFSnsF3zBZFHUUFBIy+cQI1Bc4SDoir+WXk6okHpsYSCYLEFujNQ2B6dqKAL6kM9BJyXZm44UBIminIsIAIgkLIqywIv6rIt6yCnGrM/YAMhAQSaYAxVFSrP0ZBfM2znJ5qkAmMgAArVkA7g8HWVOA8XorTJ6rQcJRNOS/9aNAGtzmAHLPoBcPAGeXkGKeWAWKYmUVAntQiu30oG4Wq25DpvnyFv6LoEs7iuWJAF7OMvsfGuccBftAOgjmAvY4NdQ9Mi8ikcw6EKpsSVzTi4BeeV+COwpGAqoDmaMiKNmhA0mABKVqGW9pKEkPBoFBug6BFycWmgg3mglsoGB9UGsyJhmDYEZpAGdEcEedACHBCGtRsBHPABH8ABu4u7Pee7IiACLIC7LUBhpbALxBAmyBFfn3mjfHh1LpYJLAACsZAN4VAPt3ab7sC0Yfe0PxZk2IItQKa9TJpQOQEPLOlXEaAGb6AGWEhca6IZnIEyjWSKaEu2V8C2bGuuGLj/SDhZpnyTBWXmL3DAoG6Qt9/oaDnyT43gCH/LFEJVNPlquFz1NaZTcM3os2Cpq/EyjeGhWVe0WeWhuZDQn9tIoiZ8sYKgsVHIX5PKoGe0c3YQYFDwA0LwIGugAy2AAQ3Awz3sww3gAA4QARhQJrYbhg3AASlrB5oACkwMDMjRCqXALj9LdaHpFJzQczVwDN6gDkkHbeP7xUGGY+2AY+KbrEIGxpWYvaFjCT8AApORBmSgBiCEBoOXrZOUvxkoPovEMt+KtuAKyPibx+VqUyxTnX0TwG3APmd0ugd1G/Lqbzmytw68CUzxCQQnwRL0NRREdQQnZz7og0RTFFHJekEY/1SaNShRcSOswreUUAkPm43cuI0XyzNwuTOS1sKd6AYEHAd0vHNsMAU7gAOjCgQ2oAMc8AALgADLzMzNzMwLoAAIsADTPM3LDMRInAelgEq3oJWtcAqhCbTDdsVJ/AOudg+bQy7p3A/3x873B5Kdg05J5M5PGg/HYKJ3EARL8AZbi3IA0wVRAAVQwAQDPdBIQNADDQVaEAXvu79suwXgmlJj+618XCczQ51DaabqGsBjcUZ5Egd6MEbfqB4RmyOubD+lMlQFlwor7aeksMmms8lFgaOnI0pKUQlfhQn0JJ6b4AhgJUw3MglcsRtX0XFdcXtHLQiFELohl0m0IRa7vP/LK0fHKAehZtBp0UIELXC7tLvDPRzEQPwAYW3ED1DEZVIDijAe+5kIguAHbe0IQYXSllVFnWBZU6w6mkC7NWAGphAP9JB0qulE7czOAZkh7RyQ2KeY8hAP3mAKKBoEXMAD7JsGaQCuXADQAR3QB80EAo3QULAFDZi/+fvZEH0niSeB3mPIh4wFZrrRHG238XobuDHSY8Nmu1E/cK0U6HfBjevSSfE1E+mLk4AIFnQJgqCW+cmC4JEJRsgI9dQIsDdMfCvCsYMvR23dIXd7IbcHTS0W/qVysUErKIcgFzE+RDChNrC7GGABERDEDvAAttveYm3EQxyGb5y7u1u7H8D/An+gCVNhyblNn/J5FKGgOhyAsqPqC/zIIZkzrPpA2A+uiNxHD/JA4RVe4fEQDwqp4dqQDPf8Bk3gAlfQtVZdM5eN2QeN2SkO2qH92VGwBWIgBuDatVQg0RSdk6utrqsNwGXG0XCAt7wnr7kxNm/Kt7cN13KNflUnsHhIQakSHpinCYHCwBbLt4lACYgAiEGTCYkwKJxwTz89TEaIIzkyYx5n3Uqd3YCwB9vdnaKFB/4VGyvXBqA43uTdZURgAzcwuxjQAcg830Vcu0RMu1vdc/cdhrTLAb77ATXgB5OAeXEGmsMWCpMOLyKQBzFqBsggD4o5D4oNDwmZDt3QDduQ/w3YUA3SIA3OoAyVKQy4gJkdigofmiIiSqInaqJ/0AZY8AI5ID4qakhPoAUCjQQGndkpjtkr3uKeAdovzoAiXtqmjdpjq+Pryto87t1xgAfxqi+3N9IA9W+w5zozguR7eH4WlNbhcR53oAh+kB5/gAiQMAVwgAm6AQl+oAiOgLnCZE9H6GZjznXaaOZHvdTHZFaipXLePeddO94WWMwIMbscgAG4+wH2PfG5S/G5O/Eqq7IwWqoPQncWegia8Ev4E+n4YzqTTulKEQh4IAIRwGp9MAuxLhQiOqImmqIVBqMr67s777v1zfM9xwJ0l+tOYEK9bgYwZQWZTdABTezG7v/Q2fqcLh4FpC1gXJpScRu3rS0ku4zttqEvtCPSjqYV9NpPtm0/z8him4AIbT02+YUIaNDWeTAFeQAH9u4IicAJjJAHgPCNgYIJzy2emtBP/J6EjCDSAH/doUvwUlhysZFMAIZgeVURimPeQYCywFuqE2oGOsfuiGB5opR5Brd5/aM0xggMV3kL8/U1BVcKQ/HNKI/ynzAEWh2GfuAgtfvDYfjVDsDDX/3D18z7wd/eYSjWP8AGe2MEPbDrDkYEVs2FxK4Fwa7ZAh3QWoDsUL+2nkH1VW+BVoD1WT8W7+EG2B4WQN4j3A6gb8pm/9TK9TMjT1FBNQ2anNAIIZcVr6L/BhIhBC7KAjgwBT0CEH42JfoTCBGjSZcwQdqEyWHCSZkqVaJEyREjRAcxZizU0WMhQH9E6tGTJw+eOHBUqmyDpsrLKlSGzJwJBMgZNG4UnUoFC9YtXbp+/SJGzNhRpEmXGVvWFOkyZlCZMUtW1ViyXqpKnTLaC9WoU6JEhRI7NhQLDhEe4NDjIEIDtw4azG2wYO4CvHjp1s1rl2/eu3gR4HVx40aOGD1a8BgyRcgUyFasIGECBYoWKEwqW85sWcuWLVFAh24SRYyY0KK3XLkimfUZ2FRkz6ZSBc1t3Gxyt4ETBw+cO3jw5BEZSKTIPYEIESqEKJEi6IykO3JEqVKm/0ybNnHi7sm7p0/hP3GiBAgOoj9CgMwU4YKICxE4agRh4yjkn4PVJ2FqSOnSJYoccqgSSKQzcKOPPjLuOJJO8m0lNtR46baYZBoiiDVwGAKNIBK5JSkQQ0zKqqqWuiqZppqqasWmglnFlWe4sSYZVEohhZSyykorgkAUiWABBxBoIAIiizRSLQceSNIBJuWqi66+otSrMBdaaMGGHG5oTIiZnniiNM3CvEwLMjOrTAvUVAstiS3EeEOMKFSTzArWroDtztioOMM2NnRDg42W/gS0N9+EG66gQBJFLrlAmoPu0ekcgeQ67DTRZDtOxAtPlPA8YeSOPIQQNQgWWMBBhP8PgBBBBCLwYOMPQPAwKJFKFKoVE+4qcUg7TAiE5NcCN0KkuWE9UnSkkgyFgw2VJKztJdkuDAIIIoLICY1PfhERKaOS6vaoFYsqakVyyy1GlmSs8YabXU6x8cYbxcKBCPJEoCsCB0SwsgZ+a7CyhVUDDkGEEDro4IMPOMDgSCLT4oCDhFsIgoclvFxiiSComKLL0rhIgrLNxMRsTChIi/PkNlELDbQnLrbiDNnupA223Pq02eY2fMtjwUYLMUQRQwxJlJChPUJEEUYcoYjSTLrDlBPwNO00PEEAEeQGU2+AL4gb2BjiDCBuwEOIPNRA45BDFkIEkkYs/eQSTnDdZKL/XnUN9lFFODI2UUVLOukkltrQrU8KZQpiYiqCGEKIO1ohChhgghmmqF56AaZyzC2HHPLKI5d8GNBBL2b00UssxhdltOFmmVHAA2+UT0TBkZRL2BBBYbr09feHH2z493fgWwiBBVQDXvWD4wO+cgovLZ5p4yGWaKIJI4xoQswxzxwTszhLO1nN1ESzwssr1IDNfDzPUEONm9twH1D3edMZ0Y6G5Vs5opPz6DmkHcEOu010Ijzc6Y54xBK7TVXiD0RwAx7gg5YhiMBUbkjYDYCgBxcYBG2VaATbJjEJTUyCE9vRTkN+NZFfXSQ6eivEsZD1t9/A4X1/cklMpDUxHODg/3A/oMRQIDeMYFAuc5jb3OY6F7nQJVF0xTjGMapSDFwEgxnBAEXUwnOjU2AiEYCgggvgs7AHiAAN+sKBDQxzRsOY8QY2YGMb3ei7GrDAd1aSoA0UBxk8QuZi0qNe9a6nGc9oYTOBhML3vAea751sfE+w0/nQ50g44GZ9cJikSu4QHJPowQ8mQdT9ArEHPchhDwUpRCKSRh1J6UoTBISaFXP0iVGMQnafYMQNFPEHFniRYBj4AAZyUCV+oYEKaECEIBjRiEkg8z//WWXcLrWQSVFEhYowZbE6chwG6QElwgmcn2x4oSH0wIKGUdy8VBGUXgQDGKAb4hAvl7nL/VCJS/88RumS4YtZoAIUoNBE7DhFilO0Qg9TiNAZeDA8DDxAD1g7oxvHqaVpAWFaOlijYXRwOJuwUQdt1IEOGnMEkEImektIQh+tFwUzAZIzK7VMIkWjMpRFoQmtkYz6HglJSq5PDStZCSZNQpxNmgQPeugZ30gyykYhDRIVUdqlCPgJK/oTXrEkxSji9Qc2BOF2H4hACDCQlg6E4EpCYEsgpCMISyGzEpayFCc0ISACxZUSjOBfNT1yHwY5iKeA8qbhDtcDcQZBhxmbliBuAZR0BiMYu8DcLhjbznbKU4mkI90TZ7FP7siOFKlIxS3m8Nk57MAFPMBAA6jgBxHwCwdhs+j/4Q7n0MO08Yz8cgEQyugCLAH2cCAFApemcLEmSEGmpfljZcKEmTCdSU0vPU1qRhOFOpVPp9PlaXUvaUnhZJIknSwO35Zzv0JER2mXsI5D2vqdqMWyFFYtRXvXCxZInGEKXmQSXh6AAfx6FAhTQIMf9CAIHKB1EpVIyFrfiokD9+qEkKDmcxJhTZBgsyRxSIlK+sQ+l0RrYoAFrJZ4QIUdELYGowBKLtS5WMemOMWQzZxiQedi0jUxGfVMRjGSEQxTXEITVt0sLIjBB0IkYQdy4EHCiACJftXgBxqiyUwwOq0N40AHOcQBGm8wLcO4QLeunRaXhtAyKQjXS1ZQaSCR/2umy4xmNG5qLmjSdAUykMFO7FufzarbUzxc8pLDyQNJ/LAgRP0hD6UkGv6YowhU6kpACP5OK9M7ivWSor2SjuUpSKGIG/woSAhAQMEewAGxfkANOGABIBghCGRChMA6XvQHCcQISExzWBC+T4MqLMP10cyGhuMBh3VgEw3tgAfDrgEbfpILJKpY2cpup2IlB+MYk2sYNt6FKdwW0FssgxCfzcINagCEPzhCCDWIDw5cIGwecHkIMtEYbPrUBvaByg9/EAQiOrgdPKDhQsNWd/QAK4UnaIwKLCVTmUh2me+lrM1qhm6c5xyhPt2Zp3oOTnY1yaCC5AENbShIIhLREf+PfxzRS7UVgtmqCfRuKpaQdm/LU2FpESBAAfhaQKcTil8vwoEFQvDDIVCN6mWuGhMDTmYHg8UI6Hz8roAABEn89pv4sSFPNlRcEDjcg47a9so7EDIPXMACTcAiF5YbxrIdm4uzo92xveDFEIMhDLjHfRjHGAYyZlxPJwJDn55QBSyK8Yw48EGYVFCEKDxxByLAQQ8hOVoqswMezfKkFa14xSuAIhSifMsYv0hETKqA7uhR4QlWuBjFlvC8K3TvkFqIghbCEAbPSGb0cI7zauK0BS7EiQxveAMZ1Mcs9jFL4neAg3Aqnsl5/0EPyWnDAwAAAAS0IAt8ALLHHSUp6xT/CG2HAEQf+tC2qJVFvSxX72ZPcYo/DAkvDHjAA4DUgMKUqgZNZ7ogBEF0AKkVIUM3UIEepXSQ2AP/0iY++w3CqRDZoLq/AqyOsqAqqzIeuIGD2jlVGDvFMjsVwwVcUDFe6EBf4AVfCEERDEG4OwZhQAZkKEFkUAYoMgVTiIUYyYk/oIRUCAqf+InLCwodHAoe7MEehJyhEBdiWIZneIZXwIIsYQEkSIIj4AEkWIIlLKnp+Rgk+JImSAIsnJ4mwD012wLfgxmc8BMuqAIryAIuwAIrkDPXkDM4AwMwCAM1eAM4kAM4eAM2kMM5iIM5wIM5yIM+nIPl24PlIAQGeD5D/wwABZABOViERXgERrgO6jAEPngEtOmDJLODQ9gxljsFVTg/T1QFVXi5VCCFTAgB92sABuC0B2iADniAXooPNJgCPKCrRqjFVJuE7Iu1WEMlR0i6BysEQVC+Pvsp4UiJlngJmJmNiXEtBrwowVotmwCCYQM1F/AEYigGZVAGWaiFWZiFWuDGWtBAXsAFbpwFW5AFDayFuEPBbHQGd5QGZ5CGaagGbMCGbNiGbkiHdOAGZEAFVBAGZcC2HsS8XvBBHRSKg9TBItocHwIdqDCGTDCCHIgjJKhIiwQpkGGCimSCOAkzj4wTLghJLlAZMjAb3KAQl8CCNcAClsQCNnS4Nv8MA96bSZqUgzmQA5sErc86Kj5YhBQwRKBkABQIgUl8hELYg0ToEQoLBD/oAxB4ShDgl1IxA08Ai1H0REvjiZerKlEAhAVQAAXgtJlbgIUhnv2iAjxYG0ewt2QqOkm5iGlCOmpSEEEIqjzQszyLA8GhEPNRxmG7kGbsqB7ggd7qrcPhAC/qA1hYhmwUhiY6BnZ8R3dsBmhohlU4BmighmiQBm9IB3lQB3kIzdCMB3jQx3RQB9Rkh3lATXlIh2lwhmhoBh+EHGJ4rMpJSNzMBd3UBc2JpyKSnKV4hTfggR2gyIy0yIwMkyjggiwIs+8RSS4YjfI5yZNkgzVYySzIzpf/fMnXo0nvxEnw1ElAJAlC4AMDAMrngwAN0AAXECU9eINCEKobqII0sAMWIJIGAIFSiQACQAAMKDVMgBcBba9TaJ23wRcHqDlOS5IPyDQWwANASJREgIR6q0VHaIS3lEu8SbqO4JuqOY6TyDPiI5zbMB9omZh0szqs6ygdAKxoFILD6YAWUDJQ8AZ4iIfO1MfUlAd6aE1u8AZvEAZcmAZtwIZpOId7wId68Ad90Ad7mAd2iAfUVIdzQM11WAd2uAd5iIfW9AZtiIZfCIoiqs0h0oVdyAVdQDszxc3eXMjQOQpPsIIIjKMjOE7KSM7K6EjnPJncW87UsBPqrJmVdB8s/6iTODvU15NJ75xJ8MxJ0HK6RQiBAAgAoCwACYCACmBPLhiJeQMVKhCC+3yLCHhK/iSAAOhPIIGCR9iEAXqdUqiiuFGDBEUAB7AAB/AqFkAYFgiEPguERFCDQjgmDK1F/9tQpEE6AAwEpgPRPMuzZSFR8ykcJ+u1q1vRHojGYQMYFlCyZrhRdWgHd3CHd3iHelDNbcBHb3CGWJCGbugGafgGJX2HfcgHeq2HeVgHdWAHfc1XdqgHe3hSdlCHdGhXbpCGW9gFzlkxyGKstYOshZQs0EkGXbiDNxAt49SMjdTI5GqpJJCC6QHJPr29OLEC2rANlFxJlswCNGSNOJvJRP9dVEZtVEd1Oj5ggEkFAEoNgEslgRIwASeIg0CAAzNQAzuwAyEwAxbYC1I11QDoAAhAAAIwgAW9AUaAKgQbhSoCBU64BBFwPwxwi4epLTj4AUC4JEwUhEPQiIswEGNFGl+0H/vDq5IoiRElnOtcAzSADSKolqqr1h5wMtfSVd6p0XhYh3F9B3OQV3z4hm3IBniYhlhQhm7YBmnABnzQh3rYh3/Qh3yoB3eg0iplh3U4hytdByjFUioNh3DohmlI2MRiMdglIs8Zhs1JomIwBlDYL9EqleSySI0tsyhIAuvpmJF0qSZ4mbx9FphAA5RtSTo5VJdN1EPdvZhtVJ0kCTn/UIBJvdkEkIANIIEJ8AAKW6gIIB4HiCO6QIBRBQEEmFQIoAAFqIAKCMtJJYAF2AFGcAhI8wRLyQQ0+FoOcABealA4cANQEQK0bYRiOgRTijXpaNv/c7AWAsZgFAlA8AP/clYZupm8PQMiGIIPpgm/vdZo5AAJqgEzMANfkAd82Id5fYd8sIdvkIZsSIdr8AVhCId0wAZpWId6uAd/COJ6GGIondJ5gFLVROJ6WAdyOIdv6IbVnSfFgqxgiF3McbEiCp1iyAU/kCjRkiDL6N2MXKngLSmQhROQ7J6XiY3lFRQ2wAIpwIIsgLPeo14ySNQwoN7vlNnPwklAlAIDMIAB/yiAABAACbiADbiAE/CBwMOC1JoL/WwAThOSp2wAnB0AEgCAAQgAA2AAC1gApu3PB7CCS+CU8MiEQvhardlWHKAksvGDeqO3SbC36dgI/oHgpBsW+/sDDOZlTXq6GGIDN/CTvN3bEA4nv7WtHOKl1PoBM7CEa6CHJMUHfLiHeOBhIFUGX+CGeEgHaUBSfGAHfJgHfLCHJL0HdL4HKB1iIj7iIlaHcPiGcACH0Zm2egaiKo5dZ5viyvmczfmcojiFHxACEHsgNAtjyuCMggteLQRZPiWNmoKZCSGcPsGCHpCCLLDjQ70CKHBDRV3U8HRU8NQDI2AABTiAAxCABNiA7/8lARJgZJVFA3JDX6glgPwEgQbY3gxwXwUYgAMwgAOAAAg4gFMlAAKIABfQA0rQjkjAAQdIGB5AgzQQFTXg5UY4hFpsywORjudA1mPFmwebNZ/rJAz2G5MgPjdIa7zFWw8+5pkArJkgzBI24RS2gz7ABS6lB72WB3iohmvwBmrAhWrgUmzohh7lUb1GTXdOUnrQ1yX1B3s94ntgB3IAh3AgXXDIhcM6LFrobFu4hc4ObdG2BdIubQ08bVywBXFJp14gBl0QBLI6gyFgjCC4npSqDN8dky1o6JAcroaeHka6E5gwWYvugZSlvendvZedST1uVN6zXgxiAJQmZAi4AET/noALeIEsyAEsSOsfqIFSDQAE0E8WIIDnYwAIIAAGyICgLoMQkG4ZkIEBCGSfHgwMeINNCIVNuAIXwIE7SIM04L6srsVLqMXmUGAGO9a4zJsNDWv7i9vkU74GiaEGGubbuJO9vSEUJcwc+ksc4IEp4B0z6INmuIZqmAYUP/FoiAbUudFtsMd2Lex7zMdwWId7WFJqPt0jZodzOAdyiOdvCPIgr5yzO9MU000kP9NcwIUlP21bCEfUtoUgGgZeqOJfSIU0GLYpOJwLSYLkAiTs4R6XWk6Ukc5GUl6TlQLAakno5b04w2OYfYNGbdnw3AMp6AAHAEsFuAAN4HNMDQEd/4iDKhBmIcBppkWAH2CBBcDZA6gAA7AACFCADHhvTGUAJQjkAJjvAZjvA5B0I0iOOdgD4ECbSZi3W0yIY4IEROjFpGn16GDwBkeEQ+iIuA2JkMBgwCngtLbO6+zgDz4cfosom/hLLgcCEQcFakj2aFAG2GwGyPSGeAgHadiGa1CdZJeGaugGbegGLiXnHL9S1eTxcPjxIAcHIXc2I2qsIldyJle7XRDHDoz3YCgGuOOFXdCFQ7iyxFmPKggCL//y2+YM4u3TkYRO6STZBBzulxiCOGZJOkHuOHPDN4zzOd89PyYJK8CCHcgACGAAE4gBE8gAExCeFhiCNVADM6gBSf82bwKoZJwNgJIegAV4gF8KAaFORAbY9E2fVE5HaQUgSxeAAj1AiFrMA0BQBLOyjqwuulSHta3WiAPJCKm3H+NY1k26g7TWs5VYn9vQGGkBcWwdtnSb7XSDDBzog2GwBmt4BhSBBmTwBWvgBm2ohrlPdmqAhspshmhwBmrghnCIB2m+hynlV3KQ53hW3Xbthnl6sX12scoJQQ/EYWEYwRBUhiaa/F6ABSDYgfFZrZmggn/Hno0N49MI2YIXSTVD+NrAjWipgpZEQ9dg2TtebodrWTnHyeceaT0ovkJ4hEA4tyvkOiyQAywYAjdIefbltJb/bqadVAZggKglAAvoAAb/WIAMSIGd33RB5uRAPoBJVoAH4IFghYQIxY9HhISEQCZKmAS2QSZgifqtlo6DcA6O4Jv7uEuK02Cz4XqNgR7HsAmACCKQB48gPHYsuWIliJBLzJ4RA5aMWbJjFpE1azZsWK9ewIDtooUL17Bm1bylSydPHUuW7M6FiymzG01kyCzizGlRmLBjPHses4lMGVFnzqQhrXZtKTVqpVjwwMLjxhQiQYY0YaIVClcoWplA0SIWipgtUc5G2WIWLVsrbq9wicvlyRMpWO7evaLQil4yZMIADuNXb983cg7LeaMYsZ49fwIhovSJFKchZDLN+fMHzh9FZlhEaNAAQYMffUAQ/yAQAABrAApMUDgwQMGBGAdSp1YAQfUDCAcQKFCAAPiCBRhuBEqkHJIjSJMqOZ8kfTqk6oyuY89+HRF2RIcKCQoPCNAfP3nu5El//g4cOGraq0FzhsqUKfSHCMwPZP+RIUMK3lCDI6m0AsswxfiiDC7HQJPMKquYUkopp1BYiimoxCJMM9qkA89K7LCjzjksnQMOODNtsw1RzRgVjYsuSjONUtdow42N3qAEDzzxyNMjPT8CKQ883lDTRw1LGLEDD1RQEcQSX4HVVZRaBBZGWWitpZaWWvKlV1x+WVEXXnm59ZZeigE22BV+LYaYX2QcNscekDWyyWSw6PLKK798Qv8JJYoE0kgjZoAQWgMg9NFHA6kFsBprjR4AAQMGyLBAAAQsikAECxBg3ALAIcDpcAQMdwADH8SRiCOKVKIJJpdU8px0lUBXHSTa4XqdoIx4d4iv4QlCnh9+lHceHniw1557Z8zHZBVT+OffFPsBIYQQPODAwwcfoEFKKrcAM8wxzSgjzDK5uEKLKhSeQmArp5SCSi3HTLPjSvOESI6+6pAjUzjdpBhPPDoSXHDBAgvco8L33IMPPv5A7I/D98iTTi014LBEDzwskQYVSzzBBBJIRMnVlIFpoRZbZ4lRlpZxdQmXXzBjkUUWd61hpl5uoQnGm2Qo1mZibMrRGCGJQHL/iSeltEKMMcYQ80sromyCCSOeWPKDoQ0keggICOC2WqOtBQABBI2OWlxqnwYQatoHGGDAAAb8tkAEZDiSySaVYIIJ35NcEjitthKeq3aIIN7rIeKN94d66SGbLBtqMIsGFnVJO+0PPwDBebUigCCCH6X80oswKwrDiyyswHILKvCq0sq7F8biSzPc7KgOiOuA8w045wDfO8ApKiwPwgLriPzxPPY4jz0R+7OP9BIzHA83Rh6ZxBJL+AdyEt83wRYTWYWlBVdbYtlyy1tw0XLMcnFBBhc134wFF329qdAbYYABxppAk0ENAXxDGw5jmKLNyRCM4MTSVKGLp0FNF62g/8zeGHGIHxTqUIfogyUs0YcfOEA1jRrbCBtFqkstqm1gww3YZDOAF8ZNbgdQQAMwwII9VKJqmNDEJTTBQ1jRqla20k4jHIEdQSWuV4wTRCD0oIc8OBEPekBWe9iQhjOgAQ1hytx+Nocxa0UABCCoASuI0QtcCMMoyOBFLvBkDFfAixUFYh0rZJGganQjHSxZx0u+4bt1kOMbNEnRNhhGD4Uxz3iJpMfAjOchejzMH/Zgh4nIsY0eDawZZvhBtji2hPwsIQlNGGX40ELKU5qFlFGQixi4IAUu2CwtWmoZF6IQPpvh0i9p2CUve+lLNaiBDXBoAxvaAIcqtAEPjykEI/8ogQlPnAIWv4BgnlIhCqshAhBGEmMEONhBUHTwNKNp1ADGRja0IeBSDwDbcIbzKQUYIAEFCA4DDjBDeypgASGYg94Y6IlReOKHl3jVJDAhqIMelBGOWFUikogI8IBnD07cg0STdQc9wCFo/AMDFZhFhcxNCwc4qJa1WFADNKTBFcxoBjJi4YwGJYMYw9BFRG5h01/cYqa74AUyooFHPYJoHvQIkTrCIY9vEHIb2PjRwAjmDR3hKKreuMY0pkGNa1QjHveA2D3oIQ1l2EQazlBGMUDByRsMYXvc8w8VpODWt65sZVpaJfzEgEubScFlW6AlF8Inhbvez5e9VMMv3wP/BzYg1g3CzEMgkuOISnBCFNH8BTGiBotWpOIUnGBEIfQACDOArgagMMVoQQHOD9YABKMRIQkfJcIFLIpUwxEObQZQAANAgAIQoFtw4AZP47zBTp74xCc0wYlN+KlvBq0OQgW1UEUoQjkN9U4hqkvR60p0DorRQ9D2B4YwuMdjVEjDFI5Q3iOg9wjVasENhJCGQ/SCGgpSBjWYsYz7TgRqlb1pRA4UDWpwiBy6Y0ePRBSTcwwvG9twBjfkuwywWqQYwvAFhXmBi1jIIha14IUvsrHVfQhVGb6Y8E2GIQvUukCt3KtPW99aylKeBX0viwtd43LX9bFPLqK0sc0CK9hd/xK2l2gAphrWsAbEClOZfyiEIiiRickUSBe6uIXsMtunQgDCD3YQwuZMsQpUfNkUlthkDVjAgg80gFMlLCEAZOtmtw1HbgqoAATgaQAGMEA4poIAbF2gh8gU9zk8rMQlKCEdQzfXEY2AbnQbyqvvYBkQ2KUod53oRO++gT2EfY/H6uNpT9fABjiwgxlMYQ1rQAMazbgvfpcRwV/8QhexJoYugrEMaFjDG90Yke7mwS+kpiSpvWCGNWoRC1vkghY2pYWyc5FsV8yCFrbYRYfpIT2KOUMYxQhGMpJhDFDUAGMuIAhBpJVWF6MFflvaUi1rzGOb6RV+ooyCXW1Ghiv8OP/fQwamkZEszDhIMTnMvAQnPjEhzJ6CFKT4RCWw3AczQPwQsVhFB70MiofX4Acs4OZqXzgA3GBqAQC4VDtLnhoG1DluCsgAAxBgzxRUAAN5hi0LfMXDSdz8EodGtKAmoWhFXAe63EFcdQFR3UJMujES1YN2AXNRTRPZPrukT31w8EU7+GEYNrJGUJbBjK9D7dWvyNMtpGxGZmgjG+HYFzvWgWCApaMb2QCYs5/BjFzYVMpSLruUYcG6ssv0GvLIxz7ukQ5pbOSBOD0EDlwQBBfsIPI8GEJ9zq1K+MVlS+prZVw4Dz94u6zzYph3++x673z/GJhDPnIbiIlYYsJBD5r/KQR3GjGJgotC4aIQRSceUQgtb84SvKjFaWpgCVBs0A7hFiM3MeAbkIdK5K5NzagIoJs80yYDFqgzAiCgAQiwnDgfCHcfGtFDHwau0JSIVc+rs1BF64pXDz360Sd9XabvDw53uEOQf0z1jGccxGnCSvHEMRRDt7ma0zzDlOXdK9wCLNACLAxbNMzd2vERO3TDN8xdOqSINsCaLkBE67xClWVWwoVC1XBCJ5CCKTiDteUDxeCCJQhCGuiBGtzBDfCAC+ggua2YfSyBFIySu9FYjKnF+rAS53FeFmze5r1BurVMFpCBFfTSeKUekfFbMbFBFiFWMMFBHgyZ/ukBsQAC/yNAAq1kQib4njZxWR/EAi6cRqGAgGkkCmpx0xFAAQY4gHBUnzmphmzNhm7hWaRkAARYQHGYQAXkWQw1wMaJ0Q8cQg9xQg8FDiXAyiTYHiUQTnM1AmfRX/3ZH6XBB5CFF3tM4RSEWw0AARGYgR24wjCYQkZo29NsBDAswzAQg02Nney0Ai38gq1NAzd0AznwUT2cA1KpXToo2B4AAhwggjEIwg0AgQ62QAuEQAdkQAY8AAZwQAgsQR8gQzz4wwuqAzIIwypgEAvo4A3kQAt8wPaMDMhYQV+FT/gMIZbM1V610irREi2xDD4uYV0pRhTyEpNQYWFZYetloRZODhcahP8QUIEN7l91KUeTVYIF+QHE9cEqxELx4cAHiBELJIodbA4LiMBnbI3agBypMEqjJACe1dkBbIDZ5BkEVAAFMMALpUYDREAErKIY+YElnJ9AVSKtGJp0QEIjMNetPBR3cGInWtf96YGm6R//keJAmsEppqJIHYIrrEI0TAMyFIMtdttGdBuVqcJltcIv0IIubEQzXAM3hMMwssO/VGCKRMADRIADsEErtMBd7mQEmI1MZkAI5MAcAIIyhIM++IPh1Qg12IId3IALRKYLVCNdIMERcIwVkEFcrQwX+GNaqI/olV67iQFo8hXn6aMYKAYYDCSTAFn/ERazABNCZhEaFBP/5QCTSOGAtaQBHOBBIDxGQ+VNJQgKqbHhKvSBCLgAF+hgDXjkFOQBYdWAGQgCaOikA4CAGXwAp1AfAsSNowSAAJiKAVDABeRWcIRABUyAAYTnAGiKTgqC1oxRHwTlD9FK+lVCUU7CUbYfZ2GHU3ridY2HebiHFQrWGGFMD1QBtoACMwCYMxggMVCEARZDLyRDG8UOKxjDM6QLLRQDNGhDOLDDPOCDrwHMBmYDBrQABnRAB2SCLhCBCLRAB4RACJjAjXqACThBHDACKDhDPNQDPhzSkEiDNRDDHwjTFBAEDtTHZXJMEhhBE4DPi4meytCb5mFeaLbPLKlPurVP0ABT/2F1l2IgWTD5W+u1ATBVURu4gRvkgR8AQiAEnCLkTcFpQtZknCmYAghxQArEQAi8AQZEQI0qJw4cAiColmhEQBpYwuKIQGyx2TkFwPXdJPhVQAUUwNwcQARsXBqYwU6OkR0IAg/5EA8VpZ/4CX+SoXUsFK80pVMmHSA8kaZ5KsR9Wn1AXEcNwcbggCVYwzV0AzdAwzMQq32x2tfFGqxBzQO2gi6gHTzQA8MYUsWEQzzQQwvoYBxkQQ58AjEEggtIgQzEwLjKQAqYQA7gASNYgjPIAz7Yw48YVTfAwzMUQhrgARxMwQ0EQZMiAcg0ARAG4SqdRebp1ZWyW+ktoWqqz/8btMwbHGF39R8vAVOVkCmSoakxDVOaAlMWskGbQhGxxEEe/EEiMAJkfQInaIIghNto/cAHhIC4mgBzuoARvAChqoEeYBCoHkKj+spVRgBrCYAAFEDQjpAAJEDc0JmkCEAAzIZHZmehhFEN9MHOpt8kzkp+7mdzXUerAt2r0l/S+YET7R9hmUGYTh19eCqT9MDGAIEZuMJS/KrXJcN92R0zPM00RQ2xxlqB3EIzeIM8AMmPGA9NwEMOSMEcGIEM7EAViMIvBIIRQG4ZuFIL2EAbFAIlrGu7Cik9XJI6wMMu2EEaBBkODAHJaAUpSQFbyIW7rRtfyUXQLCHDqmZ3xS7/mFohMKEJYAQNAL1BMbVeFQmTe6wBGqyBG+BBejiRb/6BApmsJoyCKWhCH4BCKYCWC4iBE8jAHEhBDxDCDoRADKRACKSAC5hZdoKTryRKB9VAChFA0BZAAZjTyJkKyilA0GLKTjoi843RIZjfDvXNoAmOJWri1hpR13ptgFJUloktHOxSgQqWGeDH2tLHDwhCMUxcfT0gCD4D1MAaTu2dBJ3CJkgWMCiDNTwSkARrNSCDE4xBGbhwGcwBG5CCMRCCGMwBH8xBHNwAGoAHzkWD5h7SNpwDPEyDJQiBljmkQEDJKakujakbl8pu6Y0p7SJswjasYtwu7k7xmF4sMR2Z/7JkIZsaLxRNkR44VvOWQi4MQy7YAiscQg1QwRxwgRHwQRkswR7sgAvEwAu8QPhygAiwgCCQVjgdAjg1KqF8ygEkwAEI7dCSjQLcJNroJKL0QRg1oiAcgqv0DX4OlM5p4iYqVAFnB4AinYCWxwIbltkO5H+UmxBAnMqagqs1ghDsgZ50gjXlHinc8u4pXHWRwi3kAjRcg4c4kjdEQywcwhgMQiQMwiJ0wiZEwiK8gjFswjOHQih8gihklirMAjdA0mKSw9xxQy1AXOiigUE8wVo0wRO8hcoU4br54xXLbu3SbjxbsRgADZH1ku5qlGAATdAgZBaugbK4Qb+Nsew5Uf8gKELSaEID9UIwOM2FlgIo+AHlBAJizcENvIAMyAANiOtgfoAjjpaY6en58uwPNABtHEAByNPQhid7llPbiAYI2AEcggALYF0m+y8nKxet7OetBB3QQdcok7KAkscfzCp6nEd4NTDlDMEOiNQPZJwQaIIqOI0ntIATREIovMIjPEIknKHeRIIiREIIQ0ImcAIrQEM05BpUOcOeRoCeyLXe5ckzWIOsTRNOKSszeAM9cFU4IAU0ZA2pTcE5s/P6REGXkMH6LCGXLuyY4tjs1nPtLuFfCBYV9E+V9M/PAE3r2aaRgTHxfrEUIfWSKQLgNDQosAIwOI0xPMSwusIF+cH/HUyBIaijEyhBDKwADZAA5W6cSK/ChQ1yxXkQC+ThANjTAAiAbigAH4aK1Nq0aQjCJHyC/+7QDylX3wyO+zGCUCsCMx3w11KUeCD1E0HRehToeygWFRDE53xAC/xBJ3DCwg3CMm9CNS8CHxgCH2z1Iux3JhjCQkECJ9xCMjQDNXgDNyCDJahWBBgDZXVwa1eWXYddsjoNM0DrPvyD4UXDMtwCxLHH8L6V5JYFa+7SYi/sPUt2PfujYjRsK1H25lm2YEFB/9g4VxDG/yBWFhkZka1B5dhm7DmRaTdCq0BTK9zCNCXDM0BDUzQIKyCfGfxBDgyBDviAEiiBD+gAHzue/wvUQEO4gi3IAoSQliEbyQc4gMvFTXKXU2uQyvKBqhn4QSYzXH5SYvplt98IUaviCinTHyAAS5aFrROhd3uwhxuYrRmgATrWqBwQwh4YwiDUAR/wQRw8AiHodycsQiR4dSd0AqUPSCuoAjAwQ6rNwmk4QARwwN12sLKG3anZbdlRljEkQ19DzDwc3jBoAg6oARWgQRxwQQ/8FedtAUcxCRkUofrYs2SneFmouGfulWNHdhikAbVb+0bdOI7fD/xokW0uJDBRQRWE+xnYoKVBBiMU1HyfApITwzIwOTWsNbw/wzBcgsrigA7sKB14AQzIQA/EAB9wgX+0xyGYQoZppP+YbVAa/IAdsMACwM0MedyliNBMR+2cT4IncMLgUAL6DZR263mt8LlCEXV1HbAgFMLiBMt4DCih798d4IEbpHd8bEuNxsBXU/oY6DcO67c0/wKnb3UkxIEiZEIqpEJa07opJCcIfIAFKIBcy84IVlmzwgIx2B0toAIrPCAvCF60Usw0xIIZ4EAVBWRcMGzm7QWVhIH5gIX5oH1gvIEWiEHbp32VVEnKiAXK1L3cawEY7D3ddwXcR0EWVHH7DE3MWEEVPEEVcKEUxSkiAN3GNxAs5EK7f10zpNp/wTstaAIg4AALUCMJaAAJhAAHPIEOisAUuEALSC0oHHyjopYfOOf/aHCnxK9QpyhqHAqCoBjXfZcqdmeCnnt18Hs1IyxC8ZNyeKf8gA5L2IZk6Pbm8AITEdgmEWThXfABKYRCHdTBMktC8W+6I5zCJzjCJ3RCJlxzJiycKIygJwACERTZDYw+L4tCNu/e/JMCvBQ8MxQDK5SCKrhCLQBENXj06N2TNw1UjRpv3pBx6JDLGzFcuGyxGAWKFo1QMmrUEgZkmI8eQ5YESfLkR5EoTa7UaFILRyhbuGSxSZGLGJ1iLOqMwsUKFzJq2MDBo0fPn0CIFDmqdMlTKVWuchFLlmxZM2jQokWD9oyZsVJAPnRI8aJFihA8blBxgceGjRYsWPQpZQrU/6FDfczYYRHBQQMHCxAQILBgQQMEDUA0ZlGjzyFBkzhx2rRJU+bMmDZl8pypUujQkR6VLs2IUSHVqQuhVv260KFCgGjv8XMbdx87u/G4WbNGDRqiRNCcWdNGTyZJkUJFGsQ8EulMmyiREhWqUydSlT5lP1Upj5s2VFpwiBCBeuVMnrJ/EiVqFCtXq2Ida1YMVy1f2QriM+isjxpYaOghiHSi6KImZPJoJAYdVKkll1ryqKMIWSopJih+sikLnHCKIgoxJPpJqDfYOBEOo/LQI5BCEGEEEcpGOYUVWnbZJZhikmFGK2iaWYYZZm7RxIwPbnChhRzmyEGKiNrogUkqRP8AwY7M9LKkDxDOi+ABBwZroIHEGHvshx/MEEQvTTyx7DLMNLvsszhBI8001Ox07U7YEJGNNkBw+7OPPu7Io7cTT1TDDTXWOHGIOPgYZBFIJXkllEVCuTQTUl7Z9BVSNnmllUT+wAOPM274AINUI2gllVZaeUWXWHX55RdijMmxGGGUgcYaapzpRh1/8KEHnlp+oIuhAsnIaaKKtgAxQwhXyigkaaWNEEOVqIXJQQs1rOkmD0FkdosmSjRRDaKKMiopQAIB5JBJ1JyRlalsAWaYHX/8cZllksklLyFw2GGRMsogJAk9sHB0ERdqsAMULA8BJUAttfzgg/MCY6yGMs3/+KEPPywBxRNPPnHTzUs4kzPO0eq8E2Y7X9uzEEH6vDm3QUl1g2c32EiU5zjYiGORTeioYxHmOokEVl1e6eQUUlIJhRRSQskkEDbOAMIFEVDF4DxbjRkbyGfGNuaZZ3ZkBhllsKJGG3XU+ccfeq6x5IfGGNqbQIYmsmgLMSQ8aSVuu72wcJgsfPCllLSYiMNmQRyXi8kpcihdotRIMUU88vDjqNYomdcTemnpxSqslGmmGWX8TcaVUhqZQ46DjeAjCz4ICYQFHA5RxRIWfvDDDhBqEIEFELze8ryOzdQt5FFaOWWUUTTBBBPNVO6M5ZYrofO0mGNGZE/ZbAbk/D/z/1hfjzzueP+Onk9EowqiI4m0DjrGiO7+R/g4ehFF68QjCoGHG7TAaxgzz3mM0a9+BYkZO0pb2pjxjGXoaBnKkEY65oYPeRzDDDUAwQf49gY58G0iUQic4ESCIWw9yIXTQtyErkXDj0DOJpJrQhN+MrmJWCEomdNailBkFCqwIQ+BOEQjKIGJSVyCE6bLRb6ywjofUQOLxNCEIOAQiTkEYg5zWMQeblCDRpxCEArhwAdEUCaF4MBrWooACMoEskD94HewmN4pOHE97a2MZaH5jGggUchHiA9mjUBN+WwmGZv96Q+R9MP6BvU+nnkOC1XoQSTqMAYlwEAJoTCEDnSAu/9H8eFSi9ADG24gAgyw4AMcSJWqIAgWXm0FGrWsIJCC1IxodGMe/rhHOkBhBha4Eg57k8MyJSI5FbLQWi9kELYI10JqztCGOOxQ5SbXQx7+8AlcUBcbjqg1Q8EhCFRAAxxYhIhEwKsRUJyRKlB3law4wxnU6JU1mLELTRxiClB4wxwewQPhaaIUdnDBC1LQAQ644Ac4SMMdjtUY4wWqD2gKlCZccQs9puITnMDe9bKHPZOeFKWYIOTLENkIRcJIL2iKKW38oJQ/6OE26/ucHwbFMx7YIA7NKYMPZOAFOtBhE5KI1P8MsQisccEFsYwAB6gKtvM8YIK5hIY2vAKNZYD/pYJp28ozoEGNeBSEHtHogxCiyoFklpAMO6nIMy/UuMQ5robUrFa17JqtbGmBJhzqJjdBxEOgPCGc64IDFdRwBsbC4UQ44EE61bDTO+hBEI2QV1RoMat8MYMrWMRir6DRC1cQ6QeCEELHPjGKKdwABjBQCw+q0Ds0pOFjj8HolQ5xiVLAQhew0CMpTraZ7LUJpZtIKfYgwYhHQKISh0Qk+agbU7048nyCAN1OP/e5O/jBDaSCLB+wMAhJzMALXoDUKwZRhkctghCEsEJUMxaBr1mVS2FJhjF0lIxdDIMYwPhFrIBBDFnIIhnHiIUvtnFWeeBCEHp4AxWA8NZkmXAn/yWM1uL42tdtTVOaEMpr4TYCWDEIlkQ/SSFOyHCFEsmhDWxAQxviEIcYtwEPdyDV+z73B/QhQrNQ/AQpTpGKjgKjGP3q0WivQY1moCKzAsKBJhrhgg5kgAIPiIALstCCDnwABx2DDEYx2ghNnEK4rVAF9UJKUkyobLkoDc1zK9FcRN5JL7G5riDQZDM+C8LHgfjDbQZ9B0kipX29WUMP+KBU8w5iEHzwQQrKUAfdyYEHSApBCMoSy1mmSs2sYAUqSiGVVHACPpOQlyYsYYpatE0gZ/UGKACxhzdMQQgWbgiGd9LrxL1hcd2yoTX1ahJg+9Vx2qSI5QgLoiu4mAwMmf8fG9oQ4xnHAQ534Fy2c6wHQLiIEZOoBCdKd4pWAHcYVHRGNLBYja5AQxio6AMLzDAKQbAACynIwJbloIM4uGAHebCDGcwQmUAdAkuWKIUraKHHNY9iTSeFc5zlXAmVHjJ80mVNIVyqSOz+eaZ/EMS7IilJQAy65H8g1BriQIpHHe05kRiDD8oQ6Tgs4Ugt2PQHQuBQWc5SE53ZxCc+kYlK8SER2vWDIEARC2dUIxzp4GA65KGMQ9RaC0CoMN+i3cxe62TEGOJIsfv6V8UtriPRogmzo8DDbra9CYilwhnmhwa7G4ra2H5fiuCXbW+7SLOTyJ4niHxuG+VLK12Jxrr/c0kMU1hCFY0QgSJ60AEXGMFghLiBHJYYKEtY4kpYagQqhOuKNVPPE9eD88QpblKLM/fOdnLpIhkpU+xiV9CB9kO7Tq5yPKyBD02F1CJe8YtOOOoRWejBkTTN6Z5XdZaR2EQnLiMJSQwwEI0YWSyQUY1ukOMb3wDHOdiRDniYQhB7kAMThPADODBz13v7uhi2dc2Y6DUmInZJ2Runkv4zQSZkgnKabdm6Ke6s4AzOwO7QQMaqoApOhMbwwChIxXMIBX5wShCAbIkEjxNa6xRoBBamCCuawRl8ZF8iaBlkoQ8mIQhaQAySwAnKANP0DBRQARUi5vP0AhTSjBU+sBQg/071LoH16uz1sKcI42zOwkf2Os6lrssJ+UwvEIHPAuFd3AXl+iQQ3CcP+CA6JGG9XqEzDAELcgAHmI8Fdq7nfG6WliMSrg80OAEUWIEXmsEb+kMcxMEd2qEezkEd4gEZQmYOwOAI2u/9Skj+vi7tVOLYOuyvGOTDHDEROYJCKCTtFsQjniUnKqcJpIBDpIATbaIJrODZlsUh3sAKEMsKok0OsK3G4qACPUcCPQen/ARNGuEpyK10pIIqguEqmGEZcmkZnKEZqKG0TEFQ5mC+XIAJ0kD7DgEXFGwVbDAvAOEUPKoVerDUgFClROP1REOlWs/1NG7jCmEPMCum9gB9mv/QCQ+BukYOEWaDClvEZnzMD0TFEKzG+pTKEKIjDmzABW4AIF1g05zvy6APA5wjEjKBEi4BFXqBGuAhHuSBHvDBH/4hD8uhHNyh/GYtDRjCCnigTHSNQOQKcLYA2QanmhwkEUuMQpgAAGPCJWWCCTwiJmEIJCwiE0HEJj7xE7NACkTx2S7nDYAiKFRRDuDAFUlFp5QSKdjHDkIGnp7oiTQBFExhKnIhRx6IBJ3hGqyhV4ihFABhCqYAB0DmEkaGF+KNPmQhLxpBFWjBFUTtFLIx4i6BEkJjuY4wzpprNVwDNuCFETzuutTRCclHEFwEEWhjKQzz5E6OCjshE5zD+hb/4RHwoAdc4B8xUyA3rQN6LpZ+DgMSc2J4IRqojiDm4R7sAR9W0x7sgR3YYR3mQR4AJAy6gAuWAAhCkusc4kCcxSKQLewch8Q2QhJhEgleUiYDkCNiUjkZRIW4yROjUzo5xAqoYO48BAuwoCgZYhVbscbCyISWiQLzIA3UwA7uAH2syxIuARRAQSpkoSoaCJe0gRv2iRmKARUuwQ/MqBQ0oT5qYRUC9PEOYRRgwRrXrBRAYRTa7BJCAxLAERwdFBJKA7rqbBKYsBHWUUMNEzFnw0Vqhs/QZ+QCQXeub/oiIRF6QAdugAWYbzN7zjMNEhVIkxvOah7moR4yUlhW8x7u/2Ee6EEe5CEe4GEVzIAJusAIcAAIBEYN9uYhmEUnVkgMRoLYFJGvOkzEAhAAl/M4ixMKatIlmTNDFgQMNORZQjELsMATjUA6OZEL5u4M1AAiiLIou25ovDOMlkk84WBF1AkN3GCnBCFQ0GQ9o2gVXAEWCmxHqKEru5IYv2IZbGFkUGEV9KMWYgFTIwahYIEWaKEH57J6Qkq5vBFCSxUTCmlCbVHVMDRD9aJV2ZF8EkEyCiERPpQ2ZooKDcEQ5oAQro8UHiEOqmAI/tFFOZMDYhQ0gxRI50E168EfnrUe6kEf2mEd/IMe4sH8qOEQzKAj3yBF1KA89yYM9gYMriBC0v8gDNA1DcBAXcOgSdF1ERsECk5CEkXiS8N0S5eTOaEADKgACvw1Df4VCtaVCtgVDFKRItCAC9CgOhcWJ4DIChrLOieWsRIwTlMkDshAT+UgjOaAfRBNknDDx2xPsyyBKkeh1FTBQJEMSHCJ3bDoK5hBGGIBFUzBFCiVZkHvEk4hVj4KVEXBE9pEkDCjTdqkMi6jMiqDM9gEubAHNaDrVTNUEBihNvRgN27DaneDzL5r4NLAa9GACpIoEBwFC16ADyjFENJ0WF3AH1vAbXWuA+I2AzJgliyAHeYBH+whWuvBHZ5VWOrBHm70HggCHrrSFri1PNUFssb12Mg1JBbRayP/V3In12uxtDgh8V6ZE1/x9V+nwDrTwDo9d2JBdwqWYAmGYAgccAEXkCgXtgqooAoUUAFPRAHVpdreLw7kAA88VhaRoqZoitBEND1L9hKo0j1B8BbwZQS3AmZxyUeEoRZwdhXwAhVo4RY8ShV+cE3W5HriRLlSqmjDNzO+9zJM6hJUDRJcVdXIB6ZiSqbmMWSXTkRtZn1qKg+Ugg96IAKwYBMigbyghG1vQC7eNg3j9sroFgPkQW7WoRza4R3aYR/0wTXVQR4g8lrjoRp8oRYO4Qcidygyx9gYAlsoV3KpwGtNGF3xSgvyVSbDFAmOc19bOEy1dEs1F7FMV3QdyzrP/wBiq7MKiCB216A42OA3ivg32sANvJMClfJ+S442Au1d/ODbXsSlVK14FVQqYIHh/mt5S7Ar1k0apKEZkOEYjiEZhmEXOhUWsJFkMsMuX69BTfUyhLB4+8ikPu8sn+IpVG0SIOESFFKPO07cFEERCmEpPPRDqfCmAAERVA4OKssBPoAP9CAOsGAIjsQGBPht02Ig5XZuM0CB1QE214GB9WEdKLiCrwGfkMEZkCF6P6Y8W8xi1SCEqQlcKfeWJ9f/ooVLuzRzXxiYaXhzZVhLOeLZgIhix9I6T/EJfNgBLdY4ipiIifg4qg2Ja2w8m3jQnthdBM1d+AzcMjTINCGK5v8SFVxhFrBSdbYSn8I4jL1CGaBXFhpu1LS3MuxSZehY4oRwG7uxEkZHEypB1SzOZN3481SNEkYHnx3BEYBsVTuuEBShVrMQDgbtHfVADYQACL4Lt4hASRvgA1SuDSw5B+QiLjZZLTr5gDMgDzXyHMbvHKIuHbTBGYRBFlbhGIQhp5MBFOiiWx8iAWs5JMCAqIn6hCc3lyUXc2XyhWc4c5mgqaH6CKYamDeXczMXChCrmXtYq2/YdGG3CrCgiNW0CqygrBWWfhiQ2pAyKVcEp2qqpiLJXQz5NvrkMK+uFjXLeN2TUmUBR46hbVZnKxevdYSBF2phntd4LkX1e7Fn9YT/UDQSus4g4S4TmhImIaGrODRYVTIagSkiKRAGRX12Q9vGow1UI5Iuyw7U4A4GruCeMl4QYQrc4A98Q5N0wAZe4KQJeCDTcG45oB6oFTbVIR26wRuqARl44cBqgRdAK0iA4QdqAAfCoEAsdqgZd6iJml/Z9XMjN6mVmjhdeHOR4AjGu6lfeKqpGoah+ryjuqm7GmJv+IZ5gL5RlwqwwO4Oa6t7uArUel1i8WOTIuWU4l1m0U9wQ7RlSvu0z3hNYRVkYRZ4oRiUgcJJ0EeU4RgOWxYQtV7YLHy/MaAj+y7/ebIpobkM80UYIab8QDL8AKPsQAhinAgUQkAEZEpEAHk6/0YN/GAxmchkSKHUSu0UVEFWdIEYdEEUCmgNhBW340KAkWQuetu355Yd5Ka4tcHdoqEZEsyM+6VXwIITPuCYns3FEtA6ixoMsDsMtFsm2BWXQbeE02BMXbKq2Zu8d+A4gZm8yxu90/sI9Fy99zzPj7PturqrTZcHdkDRUXcKiGBix9JzIT2HE3Bzsi3bKmmn6tpP5PpPbkNQ+uIpl04v0nM9FdQq0ZkXjkGwhRHDNTgWAlQVTAHiRGo6FlIT6NgSOo669uTk+OwPupZ0p+AIcKAsiWe1pmSERMAMYJV8jHeeVIEVWsF6r/cWOqtWiOEXCowYtn1stv0XUgES4GANiP8AdeMit83dbc9Qyg24A9LBG7RBGpQBGea9GI4hyXwxSMyGGGABjqgKIopDAQtWJtSczbe7hD0XdFH4qDPEhctbqncgvfEVmP88vRVd0Sde0f+cCaiavZ8gCZKAB0x3q7V6CRJ9B3ig0Rs9dHFN0oVAdIsDhTfHPN8Ho/6EpujR0wNlN4gDDbT2Np4yo5aIPUfBKiNcGJAhGFvnGIIBFzY81kcBFDSBEhyBERQhDwDhsjtu1DGK4BQCx0FAeM4zDewAXmqxekphLtHe8K43Vm5BF4ChF4AhGAJs24khGIIBGASMVmjF2+veGLD9F1pBP8U9CHqgB9C9ydFC59bdgPn/qRiGQaczqKyIkRosaMD0aBPg4AymgLYYEGyFQw3KdLvXHM2LelwjlwokXeGPuoX1vM/Vu+GBOePtvF+VOXTTAOFxfwrUYAekQEV7wPd1QDNdlEVxnMYFRMxxHGOOCcebH3ke4/jrKMZxQAiIANeAYAq0DgjCjNhrACBv4Adi/Fje6GHS4DbiSRMc3BVkoRZwARdiIUFZDSoPIQxcIAKiYAcU4AF2IA36YOy1CyD69PFzqJGlQ5Y0gQJVSpUrWBAj0sp16xYtWrYyarRVq9YsWbJwgZQ1qxbJYiiB9br1C1ZFiK1SqRol6hMnUon+6GnDpkoPHTmC2hj6ooXRFCGS/ybtwLTDr1/AjDFb9swaNWvWmBlrdYrTJlGiEA2hMgQHlSpozlBZiwYMlLdg4sqdGyZMmrt4895dSyVNXS1MkBwZzKSw4MFHCgfewXgHEsZHkEhGsnaK5ctTKl/mwUNKj8+ee9wYPTrHDtI4btS4kZp1axypXbggXQOHEBxAgAghIuQHENu5YeOowULEh+PHOUSIwCH58uXIQYAQUcNMH4SgTK3ajgqUJUuNDh0CJGgSpklg9jDa0wiTp1OsYLmaT7Kjx40Za3Gcxb9+LFmxxNKRLAPaV4uAuCToiy/CJFMMM8P0sgswzMCiCCKVQJKIIoGo4UYgeVQBIh54sIGGT/9ACUVUUS0ghZRSTRFjzDM0WvMMM8wQA0sqn2SySSKkpNIJHkOgQUQQRKjFFxpUxAUXGHW9BcVcYOhlZRp8paHFW4ZNhoRik3V5RGNkQobEFEJYJkRuaaZhxhRm3DXEEljUucadPbFhIhtxxMFTG3DsGehYVYw1xA1DBKFDD0HNdoMLQAQxBBFDCBEEabK50AIHGHSKAafLOdBAA6IusMCoCCyAwKgRSFdDH5ZkhwqCHpWkXy652IJrLrTocosuEvbSSy681JJgggYW2JGAATYbYEcLMigMMsgoo4wzzkijbTbadKsNN9xAswwwwPyqy51xZDHIuoSUEQcfgZSBBx//6daJxU9B5WCDDkQZ1WKLSoXAFFU0PmOMLr+8Ikonm0TSSSSLhNJJIFWcQURqZyhJBRppOTllXGE86fFeV+61VhpScmmYYiwH5iVig3nJxBFsrqkbmkLknJuknmGhp88c6wkoHG2QUWcWZGTBRQ9PWLFDpi5wkYNsIbDQgqYiZC0CC8VlfZxxx0XgAAZfH8fCD2inMdAhk3yniSalmMKKK7TMYssuwwwjjN7C9O23MAvykiAvhCOLiy+CR3usggv6TW211l6brTTZcNNNOphnjnk44XTjOefpdOONN9AcUwwwT7VCRA4+jEFHHTMUMYgXYyhBLx/0YpFFnZ8xGhS//za8IJu/AC/VwTPLEENLK6N8EkoqkoQSiiSSLLLIJoasoWeiRFy2VsZXSCmX+HO9RXJeJ+ulxfpSFralyoHBL1nMXgpGxZhHTLEDbDsgtj8OPJANa9YShCn8RjiwuVQKUiCbBaYgAh8g2weWg4EIdMoBzDFOBB7gAA7UpjZmMEMeENGISnhCE54oxSlS8ZBfQQUYxIihjIaBkmPY8Bh/E8YNcYjDaPnQh4DT4TGoda1mYEtb1cBGNrZxOXjE44nyiKI84BE6z11OHvS4xz3mwUV1eFEd5wAHOMJBjs51gxvVOAYvYviLVuABBilQwuzWNYYx1EESdMAdveJgp3vh6/93wBve1YqnlFywYhSa2EQmOkG9UJCCeosYRCQywYc6BQE2QMgMX85AhvBBKQzl+9jIrpQZK0lpfe9DpSpXmbIvHWYwjHEBC2ojHBfApmta45ouvaac50AQAw94QAQacKpgDhOCH+DaD9LgBz2URxOcGMUoGkILF8rQGNicyjJwtE1tJuOb4PzmEG/4OGn17XHojNzkppHEbHQDHpeLhzzkiUV62POe9tSiPvd5D3rEQ3PpyCI+/EFQf+izHuw4h0LVIY90eOMayFjQMIjBCjxg4QUpOEEdaDAISXhhBl7wwrtw14Z61Sk0OgBKSocyFKPYQFMvSsomNiGJTYQiEpP/7MT0xuCFiEWCEFgo1Fhgkxm1WMEKXNgCyEA5vpRJqWTpy0thoLDKVLIPClN12fzGBDUXIEGWXoPOcSroy7Iuh1UgmKV1BHId8VwCFNNsCN0qMqFhBCNv36QhOIsBzmWEMxnH+GvkBktYZxhxctqaxjSwgY14hiMd9MTnPbWIj8pa9rIFzaxmCfoPf+Cjn//UnED9sY/O9jOL82AHO+YZD3hwoxkMKgYxWuEHILThBTG4wEeLoAQfKMEITpiDHuVABkJVoVApTe5KhyKbqbnAgQukHvUYedNMSIIPi+BDJzrxrqByhgc1yCQV1IIZvlDBMkygAhOe0DK2pEFJVvre/xmuAAYt1BerTHgfVsfUP1hCjWtgQ84ExSrgD2ytNkJIQx4AAYhDVIITnxjFKVrhklxAhRjBCAYxUJKMZXAYsOBExg0BK+IdDpFa0xIxEZUBOWutsxrc4oY30uFEKUqWn/f47GUHWlAe++MfQA4ykPdRWiEbWcil9ew9Grq5gOaYtKbtpz7v2Vpp9M10txCFG9hgA6ZogA52PMELHrGIHBCCpHMgQxV6cpYh/ES5Kb3BS12gL009d4GMJMX0UgG9502vE6R4WA5aoEurETpTs6yBormmaETLkmuZyuUuv6Y1AXPg0pwi63NE1YBhkorTzzlOWpdpBoK0TSEqRIVDYP9xkYro4tVPIZdKdkFrXtB6cYMTXLKQ1RHGNS7FkHuxEpnYjcdiTp4MlaKNt8hFLtrj2dB+tj7uoQ99bLazQtbHkbcdZCJ7m8j/0Ac+5kGOb2xjG9g4tzoGmo96vGMe6/BiQrcRDnrIgxs4RAksKLEJPrwgC06QQRn4MIhI1pQUizgFJP7whzgclwpYCM0f8XWDHMDgBRhnUYsWKDHpSULP0t0u9SLxCE012tGPTrQua0DoFtTAwFrLGi5jLgLpSAfmxpH0LGeJAyKYwQ538IMgBIEQhcTVFKiYG6stcotd0frpucC103GNC/sca9dAfJyLJ9dOdxY7c0/8ohTncQ//1c6jHvVodrOjfY9oP1uL1a72j3+s7bljWx/5wPs/SrsPfZQ270Xm9re9DWTPrsPc2Rg2OOrhj3wQ2R1oV2i5u0GPdChDh8TQhSJ6wNFBOKEMdSyDJF4RCkJIghCL6ASHAhEHjg0h4p/57g4obvGMa9yBEtOpxxkZconFwQaqoeVwYOMCRRv/+CsXQcplnmj+AeEHPxcI0SExCU/ANdWqmJssLtLqXewKVxLyftRxgStcZCTXhUuW1RcHxHMS8YjSaCexOUeOhYpDHOtYhzv27452vOP/ANhuaDeAaMd/7gaA0OZsWsR2cJcPDph3ELh3Esh3+/CAFViBDniBjhd4/0ZWbUfmd/7gDuCAbthgbt9QDxvogAUYRucAWc6ADN8EDI1wAy8wBoNQB3VQBk5ABzfYCWMwcF1ACIxQCIHwB23gerDXA0uwBJwxBMkVFDAQhRhHPCmwXanwZ38mXaRACpGABbmRG2ijG8KHA2iDNruBBmmgBkHnTAWREKimQqnQCnLYChihK7kAa8JCa70wa+ZnC4sjOIWDC4WDOIMTLbXACz90ZSt2WIk1bN0wf+FwDuqQUPm3DgqFDu2Qie2wf+2AieiADgD4f+YQiqSIdhDod/3nDu/wgHlXbQNobXEXi9qGgRZogUTGiriYiw/Ibd02gURGUOwADt/AOd8gDv/t4HgZuA/o4A7nMIzbIA3H0Azjcgku4AO+5QVKUAdypAR04AV14AVlQAdlQAiJEAiBsBMm8noRJwVL2IRvliIwUHsZZxTR80iRIF34mAqkMAhlwAZBR3TiMQmTcAkoNE2noApz6BIuFGvAoGEx1JAZFpEZ1jcRSS5PtwuEk5EZ+UPmBGzBhi3ZAmPdIjrwMGM1tmw5VllvVw/2EHcHSIoOqImkOA7mYA6fSIo4mXZnZw8s2ZPzIIsZyIp9J4vVlou3qIsYOHhKaYveFpT58H+d+InjUA7l0IzfIEZXCYq0uA/vYInq0A0vqAzJ4wk2EEczMANKwI10ID21Iwk5WAf/hBAJilAIf5AHfsIk9sKOTMgDbvZH+iIUgtQCksB70sN7WtgJEWMuCBNDxiAj2PSYkBmZ2IQSlFkMNoQSeaNDOfQ3JvaRiTUN13Bu8SRPlRdFkpVFqCll/KRjmQVu4eaAe3eL4HaKEKiLD/h/DhiKqoh2rgiL1kaAsbiBSqmUe7dZxplZ1EZtPLmTaZd27bAOmQiVnVgO5lAOU3l/+EeVValQCiUO5bCJyHiLCPUN0lAtzVAMoEAEOqABJ0ADNJCWaVkHnVBwqTAIPPhT5agHeZAHbVAFVJAFu4MFT7CXQ9CXKZIvc+Yv61IHHTU9i1AHi+CWdDChneCYj/lNfPVX/8kQmXsFWEPEYiBqLYcVDdoSf9fwLdxwDZZzRZOVRfu0Y5XlWTI6UDy2D6R1oxwogby4o3bXo9i2o0Jmd0nZgdomZMJ5gcNJZDuWkgmodl8keeVGDuAgpVf5DcXondp5f+dQleWwDugAnevADpUYpvm3ibiJpJGHDc6gDNKICkIwBCmwARdwAjOwCJFQR4PASNiYR4aAU0SoByTSn1TQBgE6oEv4ep+RUvmiIsPjOg86oZEUCRPajbVDB6fwC5BpmTZELUOEoRv6YckADdRwFScqYzRGT6Z5mqnqopVlbYRHgTYaqzjqoxNYq7DqmkAaZMdpnECqWXvHlIMXbntnbf8EJXeZ5Ypop1pPeg7k4EXMWm5WGq1WKoxXqVBTyp1bmq3Yuq3qEKZcpFrK2q3scHbEqmTz1A0qyg3MYAlq0AIeMAEb8FFKQDsd9Y02KI588AiEEAh0iQd3yQZtQKhYYAVP8AQ9gKhvtqiLOhR1EAmhMAg22FGSYJ+z4zpl0AaJ0AmvcAvFIKpGpC1rGg2+wGE0ZEPLQA3eUJKQFUWa80XsUIBpFw7nlg00+w3nkH8DmHdAxg/6UA/Tpg/L2ZMtOVDUFot0R5RFepxx5w8u6YFAFndPW5TthndGaaOtmaTfllmfxWzN5qzPGq3kELbYKm/hCqbQ+ZzlgIn8xw7PuQ7/qQWub6t2XCQP81BPUZRs9iYP4ApG9NCC3ZAN1RANymALqHAJaFCWJbAC9kkDezqhSuA6P2ini0CEOuGvROMnu0OwS9A7vZMDpFFxgNkCdhQKdBChHVWpbhlSXtACBxsIgkAL8BC76dBQ3oAN3uAMwsBXllkMw0At05CyUNS3X+RF0FmB75B25rYNNLtEk0h2Truz/KBPlbVPbvdswCmLvLm0u3ptO8p3v5qBm7W19nAPPpub/aeJ7cAOwyuJX/sNYfu+C/VFZCqmYiquYQqunbgO78B//OsO7OAO3wqudKu3egtGnOM5M5t4jLXAC6xY1aC81XAN1HCescAKpqAJ/4GQAzGwAScwr0XgBUVQRzz1wXmEU3NpjnUZB5frJwM7oD0gBT5QJ06YL5/LXAy6LhIzCEWAlnUEUl7gA3FgCFjQBn4Au/DAOfa2DbH7UMzAV3h1TtMgu1EkicMLnb3JDt+wRMvbDeNqDz5GUNFLvj6LrIznitBWtEhLlD+Wq93mbdtbrK6YWvm3UOUWDtJ6x3dMRmIrRmK0rX58DuKwpV4Knf9byADsDjw5gFzkk2Jqicxqx8rLwIw1DSVayZVMydKgWJoMmhIsuLwwC6hgCqUACpwAB3HgBSUwAzQQwmlZBDz4uHXwCA3DCIhAuYC6wunCBQQrBVLgBE7gAwWasP+fOxoRW0eSEAm04wVgNgN1VAf04gV4IAjDMDrVMonx8E7XAA3PUAwaljfDsCDIUA1OxFBUTLxsa6yHt0TKS2/soEWbFb2u2pQoiHc967P34A8oSID6nL1Qy8bFqsj1wH/toJ3lgMd4rMfN2r7uW39gBEb1Bw7YiaVp+4mfiL4WnYkCTdHxdg52bKXnlsCSjA3sxE7VUNLVoFglqsmW/JnaEg3R4AzUAA3KMAyyEMoMAU3YYwiSkMqrjI1KwFGL8J6lGwmOkAi1XIS3XFJ9UjS6LAV14ssF6mZupqieewOuQ6mDaUfcGFKzI44xAMSK8Awzpi3KKjrKMAvEcIfEQC7/wYCIvqAM2kBF8VDO3ToP7iB3+KAO60yz26AOjLfGRkZQg2eb+UBahK2LcJyMGM2/G82dwvjYWHmVEB3RVYkOf3yzY1qJDc2+YIQONvmJ5jAOoj3aoo2dfCytH63AIS3JJt3aC3zSKD3SKJ3SmZzJmzwN1ODS0QANzeAguOAKqlAK09Q8m0AJMBADK7AC7rkCIBXCsMONj5AJlOAIR125uMzUVmAvWADMwRzMPcADrTGh6/I63WivjDs7tNNbceAIz+BEnHMO86DE2jAMquAJggAKD0kMGMkLwgDXVJQOZKt/71Cc+kAOqZ0N37AOflerRoakWGujyJibxyvQ+Zel/9Rq0Bh+x3zMx4BMlRF9f5qIDlSpUJl9v+AKrnPMpWF04R6d2qv94thQ0iTd2psM261t0ptcotGA44rl0rg9qjHd28kQIa6ACqNgCZOASF5BSSWQuCugAifA3Mm9AifgA3wQCdNN3bZsl6bcJ3HwBlzABdrN3VLdl+A9GhFqR0INZqrrBas8BijgASqABXmwC96AbIdHY95ADaVAQp6whbqQebnAIL7gDKZKvPqHgt7mDsnL1yf4bUd6izoatQG9f2g3D2hbDuLA4gZtrRuOnQQ94gql4pr+4feXthOtiWlbiSe+0eHw2N3wDY84s0pEszB+67Z+6wycRDJ+276Oyf86rtvCPuzQ4AzLcAy+MAu4EAuhLNyacAmncApBkgqGoAGDQOUkkNwnsO0qgJaLkAmZ4AhajtR54K9e/uVkIOa6gwVOMASFcrCJEgRBAN44MAYz0J7zOq8SQ6nK7AUVQAJVbgijkAwyNmMpyw3U8AyiUI6JkAlA8gu3sIfBMETOMGOSCJ2qmILrIJoffQ6khbUPiHZoy6wZ3unP+r4Jja0Vrp0lzp2VSOL324mNPMcKhdoJrNqMZdK6vvM8r/O8zuMkDezBPuy6DQ3QsNvY0gzWwqm+IBKxsAqosAquAPWoEO2n4Cu38AqRAAN0egIlkO3JPQPJnZbfTgmMAAnVrZ//JHLub0AGRpMFAisFVfAE7h7v38UDSoACjwtmaVk9EyoD7ykDMQBmVp4JV/8Mo4oVzAAMuvAJi2AIhDBhmHAKMkIMHdYMzXANs0u3AzWBBPVZzWZZ5VpQlS7y39rQJ66+ZJv6Zie3cHvp4MqSz3Z2ayfHyhpvKP/qdmxFs/7Rvs9E6/zRvD/8xH9G3uA5K3pGvA8uyc/83OAtzN8t3NIt11D91i/BQL7bvL0MLHYMdqVrANIsU78d88EKSkcLrvAStwALr6YLmbBAVF4CKkACYs+gRUDlZRDd4n4htmzuXU6oAJEFCxYuXKJEabIkCY8lPHbsSPLwho8xXpQM8kJD/4kSGhZR0KkTg86gOl7oSBL1iZg1YMyIwUqVSlKdRZJIvdq0qdUvY8aSLVsGbVq3eOrs+fu3798/f/rqzWMXdR27dVWtXm0ndWpUrvPmyYPKVd1YdfHknUWbVt49tmy9hh17Lty3btu2ZcOWV+9evn3t2s0W+K7gv4X/cuuGODFib40dO+YGmdtkypW1XcZ87Vq1atSiQXPWTBmyY8eG+eKFa1asWKtcv16FCvYqVqxc3caNG9Zu3rtv3dqkA0aJIitmkDC+omSRGDHiRKLkyJEiRIUCAfqjJ0+eON3bZAGPZcuWg02SnDd//vzDQUp8KKFDR4kMJRkphmo/g6NJSf+dPsHS5RZddPmlk0gMqWOT/jIhRBRKSPHpp2acQWYodeZpSp9/nJqHLHXWaacdq0Jsxx13SKyKRHfeYicsduqxx56v1FIrnnRuTCeccLqp6y6+qplGGmmmwQZIIYWcJkklOWOySSc5y6uawPDKKxvMrrxssiu50aYyLbXEUjNrqPEMtGaWScY01HCpZRZZZGltNjlVoZNOVO5chc7aanOFzz5ty223VgAkpY0eXvBhBSVOKMG4j+qYQT9CMoEEEkaouw477bjDw7vvshivPPXSU+8hOmKggYZBIlGiIhkGGcMH+d6joYhBBlkkklBEOSVAY17JJJQ6OsFvkec2KcT/EZ6WaWZCZJzB5pt68qlHw3xEPOccdbIt55xu0QHxHHBBJBGqqsTyiqq4duSxx8D24izJJ+V1Mskh47VXSX331fdJKLPRrBrNNiN4YIMPHnhMzz6DRrTRjhEm4tRqaVMWN2+TBbeMXdk4tz1ZqbPOmFKp82OQTQZ0t9taYTmVYDuhSJIZLlChjiJOOKGIimagI5JMoru0uuv80A4Po7vzDtRQESK1VPZM6miMi+qgQb6NfCCp1kFGWiRYUWIiRZJIFqFjkUXGCKWVsTvZhBNViHkmmmiO3MadfPLZJ5932kEHHRGt+jDwc7iyKlsd2223L3779Xcaf+MFckkgmQwy//J9I6+X3iY3o2aazqnpTG7R5TbTYWQiFga1iStmLRY434wFt9hpeTM33FhuBWVWWK4NdzpjCvlkPU1uxRVaVFbllVc+aSGHOECigYQLPPDBi+JWMA6GQTLZpBJHgrZO0zzw2K5TpLMQQ4ylm2BfvYgeimEMqaWmoQ6OqtYIazoy8qKOSCLpj8/GZrMx4CpXv3gFHTbxCkME4QelsEZkvNGNcKjjHvjwB7Xcoa5snYMcOjrcX96VF3sdyYQnHFKQkJSvE6qQXyssoeOMJMPFLelzjvNcDksoOtA4IzSjIQ3qfOELir3JYnBqXRJdwZrbrMIVTsSNa0Cmio+VbHe74/8dFvdUJ5aJDHhW3CIVe+cKWNCCFq14RSscEYcOdMAEiVpBcUqgAhLMYAUooMEKZGCITlSiEowA33WyM76iIS0OWXhD+pZWHlI9ZD712YgX6FOROgwiUjSYAf8kEQpOvmIRPdBPpLzQCTqkIhSRoMMY4iOFG6ShD7KIjJe6gRcU1lIao5ObM6ThQ1vOzZYnjEa+SvhLFKpQSHOTmwuPycMe/lAZQEQGaSCWOl+wiWKrcZ0RK2ZE13Uzdk+EIm5YQZs8hexOIVPFnVCBzlO08xQha+c60TnP4A1vd2SkhStU0QpKZKACczzBBo4zgyKQgA4kOAEdrleGSGyCEpW6VPj/AKGHohXyfG9I5CLJg5BS7ad/88PPSUoiCYsowVacXMTWZOCDSI0BBYMwkCQwApIxxMAFjyCFKoLRLGlGExnPjOYzhTrUZhV1Qj5Eqg9xuVSmNpWptxzdLaEaDWdEY2GkC02zhBpEIaaGTbgAKy98gbqIrYli1zTiLNS6VrVy84i5CWdtzIkKd97JFHfFqynUSVdTlMIU71SFO9vJzsHS82O4IyPuRBGHEFTgAie4wAYuQIIieAEGPijCDFI1AxnwoW0PrYQiqBO+QebBonFoAxswqsiDRCFU6XmI1FZQwPiMYYCWHAQp9ueFVUmCbLAag0xJMpI6FLdsJKkDHQhx/xNdJOOZyXDuM5uVVaMqw6hFdQZooLFdp5LJu98F73evMSZrlJdM5g1vLrMK1NIMQxjB4IVXz3pWa4I1rGH1RTEiZhrUxferYM0FLmxhC/uCdcAHRrAtzGiLWZiRdmU8HixsN+EoDk+MvLMiPS1cpzKSsTew+I0o1oCFMlxgApPdwAZWEFASlMALXrCjfvjIiYcyIhGFwHEgsrOp8ZkPtW3I6HiE3FqOnsc9kixueypCg+rZL5VYK259KgIS5KpyWBXxgnGU4IRFpAJAxWAWdKN7XTKXuWFF3e52kZpm7nomvG8u03aLyt5pDnFNYJ1vLWyhZz4z2M98nm9Y4xvfiP8VwzTu9S8u4ruLXDRawAQuMIATbMYGN9iMstjNgz12G9ugTIxT3GcXqYhhw4J6n7AoHqp5szw0wAAGYyhBilNMAxWTQAUqOAENGuUDH2TiEzSGhCIMUYjqWKe05fNxG+SQSPWRZ6NFPg99WlWRVkFyDKkYxHu8UMAyQLJVLx5DpJRQB9vGx46zdUIlWJaLYPxEzD8VarOYNW/rAqXMZGZzvtNcVGYABbrFKMYwhhGMXuyC0fYd8DVn0SY85znBD3+4gW1hcEbvIhgEFzjA9TtoRRscF44e8C7sG2AAP7pNbmKrETmmck5z2mT11LCoNSxXK6L6FC17RSeEk4MOSFb/1gklqBJUAAMPJGcGmxRF9ygh7EQkQmg7Nq0ejNYpNygboxl17WtJ5QMaxIA+HXGPRkw5hpX6oD/fBrcoYbq/5JJ7BieYwSD4IIri6WIY7hazUIGyd773/bp9R1MyNB7wYly8F73ghcghjmBazGLxA86Fgmkx6QU/HsGNDnAuKL6LXgRjGL0I+L/7mxqDY/7RiS+5gCWucMfTzohGhEXHtPhyDauCZCT7Xe1NrQpBtezmnWgBDF4gg1hvYBBFiOwKVNCRW49hBS1+AR9C8YlMXOKPTXe6sSmqhz/8YepxqPrVMSpkRZKHfU24mg9kIIOu63Ek4U6BEsQmn1BYbwyY/ywCDQA4Bj78T34VkbtESIVWoIVcAAZiSAZiIIZhALh/g66eGDyAY0AJLDzVSTRbuAXJ4w0H40AIg7AFq7wE+41cuAVaKEETxLzfIDCKiTQCc8GRazTO6wVg8DyBGzjBA7hCQ52L84XD8ypcKD3My7zIOzC1mjwFaytMwzQJ+xOZC5kvsr3a0z102h2YGJlUoAQYSAET8AINKLoTIDfJ0gAVmAEPwBnnK4EY8AE+6IROsD5LSQRDEBod677u6zGqiwPxY7b04UPzawIUoJ8YUAI8khoZiIRBkIFFqANJ8K2aoB8aUKUiOIlQ2IRDpINOmAlJMIRMkDATPEBjUEAbDP+4YVhAYACGg4u8k2u8lHu9jPkwCfuwCPvAWDSjMso0MzrBA4u8DDywhqOYPYM0GIxBYBDFCQQ4NNmFQsPBY5DAgYOvzRPCkGM0BGuwA2u8jJG9MBIZL7I93JPCb+Qi33OZEEiBEogVLzy6FbiAGSiBEiABD1AB7GmxEvCAGHiENvyZ6RC2OazDP0C279NDZhuPZiuP+pGkWzEQqakeXjMESYDEkciIWkGBLOufX0gFPoiDcWPEVCAFPriE3+A8BSSGiwMGHwzCRks4PePAWgwU3qAwD3tJjYk9W8y02Esri2GrJFSrs0Iw1TOwj6O4Xsg4ChSznxCG0oAuaWLGgCv/q/gqOEYTQs6bxgFbyQgjI3G6InDUym+8wjQamUfggAyAxxLAmZnxAHgchOSIxw1oMeOYgTh4hE/ohEzwHtHKvkDAy378x05ZNj3kw/I7CBl4MUasg1cIBUgsRBkYA7LJpFYpgvzTrPtbzDIYgzLgA0X0grGJAzRohQNUQFA0xcMTTYrTvKmsRQd7xdRMzQkDlJiksNjJJpzMyYU7q4WDPEeLQc6rwQg0NP1iBmZoBmg4ndIQBqbsKpEjzc0rOGucPFn0MCakPSrcSpqTwpYZGVIgBUOwAAiAgAk4gQo4MceaHp4JhVfgiOeztRWAlTjwD064hEuAhKYzhBvDSzrU/8vx6Y45WLb9TKTVIgMxIIMAVQJFKYlFvD/ytCP4GASSesydkR+TeMyO8K1uMwkY04E4OAVjYIafYAZQFMlQFM2nPEkS/I0SNVETxcUTLNGqZFETLEEMTEXL68k9qwWEI7DShEqSc8oQ5QX42i9oiIZmqCZeYEG0QiIkYqIoaqLXECdVeA3Z2Ct1aqe7iidUyCu9slJ1yitUYA0ncg1YYIXfCBBN6D4siAMsgAEZ8ADHYkt33IAK2AAPiFMSIIECGg4ViKwTUIFI4APp6wRO+Bk4jEMcK4Q9MFQ92IMdkwM4eAM5kIM4eNQ3QCRHhQMyYAMuQIMqoILkgI/9SctWMf8OWJmBAqqVF1MV3jrQ4vCCUEgF+SkuzXIPPkgFYti7Dy3FkixJERXCE+XVETxBE2zRYFWw30jRI5TRniwwqNw8gyO9QXPWWugF1FkGahgTicEFImq42Vwr2PmmJYqT2YjSKxXXccVS2WCNGh2rZ7Eqq7IGaCgG6CIGTrgBDrAACxhLD7iAx0KBE4iEgqJTDyCBVpkBDcAaFSiBfJ2sF4gBQwgFtoHP72k6Qi1UQ6XYPdCDOcAoR/UUpGmD1GIDNkCDMziDFZutzKqJFUgVRaGDFZgVncmyIpCE/1OCUCqlQ8SPrRE6XluDTSAGY1gGYjBFoFVAXM3V0usFXdjVE3X/MBStyl8FwRAsQWJ1URe1BSG02hIluWTdPGflWl44PPhSnYhhBm2IoGZInfga0mUVOWtSOCRNIjlxDXK9K9lwDda4VmH4qaqahsBAnHSQB3oA3HiIB25QBl9IBmMYBRZggRDIgAxox8uaAVlTTxpAgXdkMX+9LIQ6sYCVASOIhD+lS0iYjkEl1Iql2IvFWDmYA0NCmo91XZAd2VxLlVAghQEtmxmIgUyiA17rCEzKI5NQTPuRn0XgLUW8lZJ4sThYA0rQBWP4hWEI2ugNzRA9vBwl0UbrVWKNWhdd0SPkQMnLwMnLwPG12vLFPI8jPUXrWrFKvK4doms9xmTABWEI/05oOIaxGiuCWzTEi7Q8my+3PdcavdtjgDddchxs0IZueAzHgAd48JaqAAdxEAd08AcRYYduoJBjYIZWEIIW2MITO8uzjLV2jKxIoUcSiFOE3YBbgwGE9QAZ0IFI+LVAhdhhK13Ttdg50GHVZd0f69iOZYM1QAPNqiwvkKn7WYHc3ZoZWISORKVF2IhOqAMuGwRDeL/qUdCU6teNiIQ1CIRUIJBf+AVT9DySPNoBQeMBOdqrTcERDJDslVphNdaHC7ABKzAc3YX2zeM89lrE64Ue9MHOM7z57YXfNAVLcAVUuA1TAD1g6FHPoyY7k2RJPkp4UwZdkoa82IZuSIcGFv/ctKCHeXCLt3ARrogKcSiHVC4Hv2mHu7EHdsiGIYkGZgiEFniBMZCeCYhTDaBHeBzQyj2xFcDXfPWAdhy6EtjcgM2CSEg6GlYE0sUxHKYoHdbPRzUkjIoDOADiIF4DlEWBOKqacNMPlM2IOkCgNRyJ+iC3S+QDQ2gVXouPkTiJSLCjk4gDPDgDTriFX8iF5yVGM05jXTjaMx7B68XeW2hjpg1WEJTRaIS03AxKqdxRxLMzZ/UFHhSGHhW8WhiGDiUGB1M01CFgn7pkTJ6Ga4iMBlbpT6YHfGiLl4ZptvCHmfYHfLDpm8Zpm/aWDjoHcPBpcKiLaQjSXbjIF6DHCZD/AAlAYQ+gARjQALE8AQ0wqINVsQpA4RPAV4AlZhLwgTgIlk1w5oi94Yqd5h1e3Wu25h9OrW4WJUiRqUgZVfkYg1d4hlSADwAs0I2wCcrULIiUBJBQgjqCD4vQAReghFf4BV04QFOc3jMO6OwlUcpjTiMUVohDwfN1NLWNaNHcUbG6aIseImo6yox+V4CTBV9QhrnZ22zYhm8gB3X4W3q4B8Cl7dm27Zh+adrWbcBli5t2C3aIiw+iC8OYEmzYhmvwnGYoBlkYhejogQrQgHyVgA3AGeVzR6nmZTqAx5V1LEZBKBSOrMnSATacSxrGPok93dNFXTmYOvPR2GyGg/j+/9jkqCyNsB4aAENJgI9X0K1vGwT82Agj4AP+ViUv8IFF+AWSMuIBLQGNqAhee4EvJhBiZOwQDeikJdEStcZqBMa2ouynDcFJQ+jcxGOKW99JtjORDqqSDibP0QZq0CpnmAZuMIvYviAMoukct+kcp+l9mOnZ1m20sBEcuZFvAKEc2RG7QBwF7hIv6ZJroAZmAAZUuIRJSIQ/4AMTMDEISAA6ZRQTEMsNiAEU0IANiDVhLj499QCxESh8VQLpC4XQDbbzHmtEVW/9xM/uwAONje8+dwM2wCTj2KxL0o/54TXinQH/kZ9U0b9TqiT3+G+pGRYGHYMiGOxWKYNA2ImeUP/Ad+1ZTh9axv7oCKOdlXPNlasdjNmNVH+TbXWTVt9J+qKvaw1tkuYlx7ESHXlttKBtGomRG8/pmc7pYcfpp3CHqiAHIgchx+ARLuEGw9gGLNEGg5n2a6j28aIG+8UFVyiFSTgESEAEQ8iBMj+xWCtmEpgA72yxDZiAWBvDx+StFSMptqyfGJBhUai+6HjmOCy2ibXYQ0Vd/fw+OOgOgs9mtXaDGEuVCM0IzcofziqJWtEITMJdk6ADUggFeSY7SOQt+bAenkklW8n0VhBJU3TGYBjaGQxNYPjApX1Jcjr12ATgAAarIRpp66qqTOZbToaHdPhkUJ4WfNAHHneKeoD/kRjRh6Q3+no4EarIlg/66W+Q+qk3cnD4BquXegpa8mhfjMWYjHYBkyZ38ivB9oZJBl7Qp1K4BEQA1ERgIzhFseiWNRQgYYSKU1w7JWGm01i7gPjpgUX4BHx/2H234Wg23e2jZvLxMdYl+I51g1SxnsrKv5UtKbh2y6pp0IwwjhfDiOSy7y1Tgk4oIEgZ1VdVpTHAKTFObAPEVYMruFxYY2B1sAZLdQoD19loHXRN17zVJePmkRvRlhqXh6l4i5teeqSPkadIl3VQB3boaaqXeqyHfmin/r/gEcDwkeq//mifEmn3/mqvdoWBBmYohl6YBboqhV87BVIQBT5oARNY/wF6TOENyKwJGFV8dVO4y6NGWWF1nCwYAAgdhj59ylQJkiNFihIZKuTQ4Z6IEvVQnDMnD0Y8cfBwjLNRY5w2bYoUGVNkxowVM4p4GTSDBg0lSmi8HCTpRJFBdMaMmbnTixcadCJFGlRmkSQvi+gAXWGyJ506ZRSReqXrl66sunL1unUrl9evXnPZwmUWlyxZsdauVdu2Fi5evo4hQ6bMmTNp1bJp49atW7hw6dSpkydvHmLE7Nglbrzu8eJ1586BAze58rfMmjNv28b5W+e/nUdv60a6M99sqrNha736NTbWrWfHpo2t2rXc16zxpubbdzRo0JotU6bsWLFeuGzFmv8ly5UqVaemv2q1KUSKDhNWDNpQwsMESaEmkJix4cL3CxpmDDqxYQUJEicmXDCRQuCnTpkuIUzI8GEhEglIkR4W5UFRHhzhkYdHHYXUBlNAkRTTGHRIIskMdUgyhhdKRMWhFyRx6OEidci0SCeSFOVDhEF1SAdLHb4YSiaZkHILVlrBEtYtutxCy1i78IKLL8IIU5ddeEnTWmnpxBOPPIQZZhg99Ex5D5aGpZMOPF1umU44f4m5TTaoqTbaa6+d1tk3Yo5ZmmhomrZmmmm2phtu1eip5zTTUBOcM80Yh8wxyAkzpHOxuLLKKqg4aoqjkTp6CiuVsqJKKqmc0gopNnT/kIEGF7A3Q6jorUDDfBecdwGrJHixAQmwwgoBejI4QUgnnWySCUKMMPLfQwJOROBFCHKE0UcgueFGiDR4wVNQMo2hkxd1mMQUUyXRwZ4kSnhBB7aSLNKhDNOCS0OFSowbE1B1fDuGD3FkYlVWt7xi7yv54ghMMMMoE8013KQjT5X30GMwlljic8/C+Dj88MJYskOYOuRk5iY3aK6mjTaqVWPbbbOpxnGZpLk5p8knhyaaaaqJ1rFufUoTDV6CKkOoML7gUkstbMXCKKOomDI00USXcjTSkpYyHaWtXIqppqQYYsJ3JZCggQkvlKDBBqGeMAN6q6o6wXkVbLABfax2/+ADFnxk8smulEDiK7ABCjssgnpgtLdGDsbhRhwyveStFyuhVG0RP/VEQx2DeKhUKoO0FIkSY0QS1beSLyI5Hev2BIOEj8tERyehhLLrIobwYUgihXjyizHJJNPMNfAQXCXuuVc5jzzsGCbYl1+GefLwJxvfDTcZq7zmNhxrw3xnzvfFjfTOX6PNNdRMEw3NgQqKc868DFlLWj4DfX6jkQ6tvtFIIz1KKe2TQkop0dkvHScdUF0CHUpcAIEHSuADGVTgAiRgVQDPtoECXsBsJWAV2TQwgQwoIQtzyIR+LiE3RiykdRC5G94QhBG99c1vcRjEUoAyFJegYAZI6UmHZP/SkjqUpA6NQ+EMlJBDniQlFKQYRCgWIRN3KaEOPuCQD2byEqGMQSp8mMO4BjEIj8ABEaNYhnCiUQ1vqANMwxtNN1ZzGuklj3je6IY3gBe8NabDG25Mx/G64bzk0XGO1JPeNfgkjT12b1Dgy5kvhrQznvGsfOVjiysUhb5K3Q8V04FU0YbmPveZ4n1HG8UpVIEKqGnCBil44AlQEJ8JqMAEV7uAB0rVtQOyalUkoM8GaLABCEzABA+iBCcMAom5LQQRiAgWCPdAIBEeKEFwUJCyJNEJE82gWmNQwQqKWKERhahyhKOD5JQIEyXooA6v4IOKgOg4nWBzENNSYYUkUQf/cN1QiuXkAx8I4YgrNqMZzuDeNPakp9iwRk1k4gvHdDOyOToPTtvwC/LomDxvKLShdNRNHn2zPWh473t2GZRxbiaMYxhJGMXoqJF8IVKRik+Q4jMLz2bhnLQ8xxUubSTT2jeKmYKipjadaStgAYuc5nRHPoLFKzaBAQtQLQPnIcHWLpCBBqqnAmlTjwc2YFQJaoAEFSCBB1gFgRTwgQ1EQEQuM0GJhCjilwCy290IJMyIFGgOcnCrHOIaVzgMgogzIYlTdmIta3moDs7aySAulxQlnGpaZYhDJMpQhnAWpROSQyFTPLSTFS5iWnUNrE4GwYfUBaIU/jJOPSl6T+5F/6NP+dQTRFN7vYCudnoKde0dsZebamiPtBStpx+RVJdCFaqjHC1UXTJql94aaRjCGIZxgyGMXpR0F849yy7MYgtb0IIWKk2LS11hqadJ5xTqcx/9puO+nbaiFaog7091kYkMVCADHvBAfFJ5gqwysKoauK960HM1DWTAvScIVQXKlYEXPCIPbGBEjTRI1kSYFZggHCaxLCJhi7zhDXOQ3IRW8q1UNG6d0AJKEesaiqKEYhAx2aYPQqGLMSziFS7xcDPXCRSg0IAlY7hQHUqHwkhoaJ2bc8QpekEXZCRjGfWsJ16SDI3gLJm0v6FGNayhG+tF9DdM9p5wecvRjWq5y//F4G0xwoycL3e5UKA1zpiH0a9hFMO4vfBFL+LsXOfmos51/lF1aQELPT8HFtplRXnLy8joOCo6mmIa0wpN3lQE+hY7okQLMODerFa1gfGxagUKeN8KaOC9qAxVKn1gtaqWYAVe0IAPNqGIQEAilwrmIIPPGsy0tnXCtuZQhWSkBCnWoSiA3UmGdLIIUnRoEJGLwRINEYpUCJFyO2QJhepaOQ5ZSJ2LWERRUChFKUYC262gRTCOIbtlkNvIRz43utNts5sRassgHelIjyvvjiI3zGROhr3zne8xd1l2yWCGkdEs7mL0q1/LlbOc7WyLsOQZu3v2s0sr5YpWuIK8gr7/n6FPkQqMq6JS1WlFpm70Ck6wYKjuva8GZJDKlCuBlaik9HvxS4H3euGUJfAfKvmQH0q8zSBj9Y8HATRrWs+h1hN+VuXa1aEZYNNDPAlsE3tSh3EpQTyFe0lPYiDZuqJLhV3vxLiAMi11do7X2W6cITYXiZwCoxj+Xoa/ZQdmQJ4UpYRU6SxqMd2y4GIXuYhu34UU52AQfs3Irbe+7e1lxQP3ZsYpNzOYUShyJ+MYalZzMBDu91wsZ7p4l8VKW5rd0W+39OXdOMfvx93qZOoUomgFJT7AgezQt6pK8IFVZ4B7lF8a5VYjwczdq+mrZroEi/iEKAhSkIMgpIMNDhZa/2et1mFKWIrVstYY2DVEdO11J97qSfYNB5McekuH5/QQTIpgw2fNOMTk3HaJpJi6bgPxXmOJc5xpUYvrKlJR2QXa6LmCLOQZAVbXLdhCnW3e38UZvxQeve0b4tkbmzGeXchORp3ZcRhK5mUeL8yZ30mXLaRU6LmF/wUg+pwPdNgPKpygS1WXn8GCJnAQHmCBDuRABzwABECABUwAfHUaDNBBDGhADHhAe7EXKmEVqb3XzKUSCWQACgRhVKVAJIQC8iWfLjVfIgTdWTmY9AkLgaRItQRFDnlY5tQQ+4GIOdGASryEUxQBuhSRt6xE+q3AT4gIOYGLuHTOte1h42wOH/+s3b34WcONHkstCqMEICIKoCzoVAFal95NF3SVlFzIBUhVoiW6m5F8mXG1GW9BAzU4Q0gFUlyID+B13t6J4ErFglqUz6L8DAqyRd7VAiUegzLY0z1RgzVMjzVQwzMQgxlEQAQsAA5CQAbooAXkoKh8hwfASwmUAHvdF6hUFQp4wAoQ4VJhFVLN3Bg8kAfowCYknyiE4xX6R1ltoawN3YPtgU7MgEmcBDZxSB2EgiSoH4x8nxJEwit0Ata5IdLNGE2URBHcFQ3YBK55S1RMnTptG1Fw2yAYQrcRBSl8m1scks8sikutgkspys+sRXaBXlrsGQGyVCzyzFmYhUmJj0j/KVdHxVvOhCJIcZRxdRQ0aAM10N2QSOLODBIhsZQq+ows8AxKNl4zeCI1XA83uJE3dAlSckkbUU9u7GIwjIIgiEAE5CADQEAF5KBWMkAMNKMHyIAMXM3KkRpSoUDK8VeneQAKfMfV9I8HwAAfmE44huMmaBAWlqM5cmE6DghF7BpT1NgUuksdpMIrcIhO1JjgDAIp0FA/gt9M6FBLdAIMucuFNJEkOMvmbA78BVZRRIK1YVsQIUIpEFKRABK8nWZpipQrrsJavKLPsAXoERJJmuQkyoVIrWQopmZuitQxFInOiA808AZH6YxIleRZ8EJHBdddSEM+BUxSdgl0Ric8/yClG8WWbOmGU2YPNCxDL9BCKWjCGXRABVzlBojSBABQ16DSNPagfc3c1njaVZEADLDls8QcCohSDPBB6XgCJ/BnjYyVQmQhIzzfB6EjRXghgTTOtnhIt+2VtNkQu7AfTEQIr51AVPSPTARW2IWIM01L/IGmOaHQh2qbtl0bHxSCIKwCkliUbulWchIKSq3idaUF3uUd3und35XicUpiSaGmj55mRxFJ5Ylb5RUHoYBWXkyDUbqRdEZnGyVUNsyWPs3WNbQGak3ZQjGUNljDdvbCKqjCKHBCImjHBDAABJHaKlmNV8YcEZaAysEXqxQQfGVAVLTpfZGADMTAQBAEJ//0adw4gn8gwoDmZYGi493MWFBk37eA2IyNAUqwhBKwBIpMS+NIAjlNZmXiGoiwnyS42FJsDjYtpIeGwi90aiioDhVqgiwgiTOwW4u+KpIYyi7w3d5BolmQxd4FnpCU1CjyaI/aZiCdFLCWJi2CFjQoQyyAAi/MwgoiA1JCZxudUfKwVjWYlmnt0R5Zq7aelj4F1JXixp80QzL4giuYwih4giYYQg+cJwOgzQQAxQVMwH29VzPul3wG0AlUAAXsVwV4QAZcDVHMHO+NQQwcXyd8Qp9ywq4cBKCW1aASavQV6qwJkU18y/cFxV+xRECehMXyGBDN2DrJkIZYHwxxztP/ZaZOSMIPbVa3RcUiZAphhkKujJgm8MyRGIcl/qhIwYV05ejecd7f+eqw6uwlXlSS9QluaEM3BM90XsMx7EwyCANcKAM35NE+8ck0MCe2MqfMbO21bi22bmufYM8uAodwMEMyBAMuMKspsMJ0fIIMlOkETIAEQEAJuIdT9dd7xkB/zanw/evKocC/vtx/bc3VmIAUZIIoHCx/Kux/9koiMALE5qWh7oGJmI7SgayMPAsTdc5OxMAU4lpUPKaFSMhP6NXTOcs6ScIz6AK3YRtRREIneOYitIIxvMIi7IEgyMJpFhKNOsdKjaRO1qoteCBOEglLbpRy1lO2xsZfOMmT/8gDlDwJtHrRN4TJQXEDzRirlO2TtoIt+M4MaY0v+XKPcHhPcSgDvg1DL8xqn2kXoS0NYaZCFlgAA0xAAtxv2sTKEW7NWS4VU1UVK6XcIARhBlBAe1lVV6rHHHTC4n5C4+6KLvnKw06u0EVfMGXf5qBLZK2TTpQEDPGQuISChxlkXWGoF0TCjMUftljLTxSFJPxCJ8AT/Glm4+jnL5TYIOgBKuzMSIGejVZX6I0g+fwkIdEmsdqFPZXWkj4ndEIJ7kyJPARGYGiGaRiPQZXGUWJP1U6ZlebTtVqr+NpWkuEWu4UUSs1CawIN+wxNd50C0pzCLaQCFognfUyAAtxvK//NrQaUAKelJQBv2n3J69x6gaiJpQcEIcqZgCGEo/Il7MLyUgVbMER8kMRGxLtYi+OYyFLMxKKKneVMYRClEDzWVYUoKLhcFlPkWuJcW8t6KK/ZRCzLH68hAijARWnKJvAC7/7J4m0O2V1EQ1EaJZfAw5Mcs5MGj5hQ518s5ZYsJWAExtIusxvN0WyRzD/dhp48Gc2YsTJ81KHsTKK85vmUHhsLTSUtDdPEjyOlQiCEgB0/0NxeZQWsAApMQL9CAH+BSgbgc6jgc5zCHAnEAPCVgCRAIQmYwCOQgiNDsJ/uCkI0gqD6EoFSMuWqo7ussrcoaDX9hFC4cCoEkTpVjvWtMcXUIWrUVQgdOEviiMsrSAIdwNPZTaFmbpu20cEjgEIs2GzO7IwrGvEuxNkxzORzxkOTVi8cpUzLgBFgwFF1Zil1IuXSrtEZTedRbjE34IZqzEbWSkOgCJyR8OrajmBLVeQqSFzEDdr5TIp4Lc3RmAIo/IEIdEAHIHAOzvN5ToDVyOtV2Rd7ZVp+ATQPGlAFzOcDKQEMoJwMRAJDJx+fOq4uSTQFT7JFm2NEBAQAIfkEAGQAAAAsAAAAAEABAAGH7MGh4LOT3a6M1qyQ2amI1KiL0qeJzaeL06F9zKGDyKCDx5t+wp2CwZl9wph5vJd8xpRtwJRzv5NzvZR0vZBwu5N2u5Bwu45vuo5ruJN2uJByuI5wtJN6s491s45xuIxssoxxu4ljt4potopotYpptIdlsoptsohlsoVlsoVfrolvroZtrodoroVlroRlrYFjrYJeqoduqoZoqoRoqYJoqYJjpYRrpoJnpoFmo4FmqH9npYBmqn9fpoBipH9mpH9kpH9hoX9lrntSqX1aqH1gp31mp35hp3tYpn5lpnxmpnxkpn1hpnpYpX1kpXtlpXtjpXxhpXlXpHxjpHpkpHpipHtgpHdVo35ko35jon1io3tjo3pko3ljonljo3xfonpgo3lho3lfonhhonhbonZUoH1loH1ioHtkoHxhoHtgn3phn3xen3pen3leoXhgoHheoHZenndfnndcn3dYnnRan3NRm3lfm3dcm3Zcm3VYl3hgl3Vcl3RamXNamXFZmXFUlnJZlXFVknFZnG5Ml21QlW5WlW1Ok25UkmtTkG1Vj2tVkGxRjmpPk2hNjmhPjGhRjGhNkGVKjGVNjmFEimdPhWhUiGVMiWRLhWNMiGFLhmFGgmFJhV9IhV5CgV5EgltBflxEflpBfllAeVpFf1Y6elY9eFY+d1M6dFM9blNAbk86cEsza0o1Zko5Z0kzaUcwbEIlZEUxY0ErXkY1XUIwXkAsWUAuWz0rXD0mWD0qUz0tWDopWTkiVDknUjkpUjgjTjgpVDUhTzUjUDMeUC4YSjQkSTAfSS4bSSoWRDAhQiwdRCoYPSkbPiUVPyMONyQVMiIVOBwKLxsNKhsOKRYJIxcMIRQJHxIHIRAEIgsBGg8EGgoBFw4EFgsCFQkBFQQADgsDDQkCDwgBCwgBCgcACQkACAgACAcCBwgABgcADgUACQUABwUABQYABAUABQQAAwUADQEACQEABgIABgAABAIABQEABAAAAwAAAQIAAQEAAAEEAAEAAgABAQAAAAAACP8A54yZ46XGhAEbePBoMSTKEStkyNRZyMTQHBhG5piY9GeMnDlHYKQYORLGiBEiRJRIgaLEiBMnSsJowWIRL17DjlH7Fu0YzmG1hI3CASPKEB41jHghY4XJkKdMyAw5chQGDIUoULhwcVUhjxcwXmi1+uLF1hdfy5ptcQKFWasiScodWaIu3boiQugNQXJqnUuvcAU7tsyYsF6Ie+1avDixL8XBeAWaoWKDhgoOKmh+4MBBg8+fFyhQkKB0AgMFBggIwLp1gAEHEgwYUMDBggQLFniOPbqBgtcHHmX7Fk/eNW3IkytPfq25c2zOo0evpu04t+vaklXSowfNjQwNVDz/4NBBxZlCkjydIpZt27Zv37Jho0a/vkAeYxYaSECEyFGFQ9RRBxk8TBUSD15YlEcjc3wkUl0QopDSCCuN1BIJFJYAFws3vBJMMMPsFI0zkf2SizCuzACXWWhRxUNXU71YkldquQDWiy20wBUMTAioEFo/viBRHVYslNVcJNn1oEp0pSACBnzZlUJRdRiiSWC8HOPMMMUk5phiX/YSjCx80MCCCRtopsFlm3XWWWijmYZaaqsN8NoCJiBxhwazFWBAbgko0IADoynAQAW/wfbALsTJs9yj1UnXHHSSSoccN950o+k206TCXQ5BdCBDDCB0UN4Nd1ziiSm1RAPfN/XR/ycNfWOMQUStPDgwAAm1jgGkgEzYCOQQtf4xxyR5eOFFCynEVNdJJ1Vo1RASplRhCxt4EAqIxxyT0zIlmsgLGjVY5UKOBb4Iw1MKwYBCW3CxpFWLUVhR1bRMMJGWQufaGEWwbWUFYYVzWTWwXSVAOVeAg0xCyirBEINMNMIc5qViu3j52C/BoGJHDzWcaZkHlrFZwQMne9ZAbgqIdhpqdgaQQA2RdLIKMZ3MNtuftwmaGwOHNjDbAQfokU088RwHaaVMN31cN95kCvU21PhSSRlmBAHIGjeoYCoIMfTBiCehqHLMcPRNo/Y01Egzxxx13HdCAQko5IULRDARxYD5Hv/hEAxb5THHH4TUIBZMJ5SQ0uIZrgTDCR+4tFIJLZDwQCC8BIPMMbGkcguIv/RCyzGQlGtVVi1YNWW7KbRwZOsouJ6VW1cNseJZZmV1blsu9DgECSTIjkIKUtYV14PFq96k4hoOQcYnshATsTOG/RL6xdYjtjEvoNiRxhI1mGCCB+KjuaZmbaqcm8sGGKDaABcc+8kpp2yg82wJELqfoA0c2sEDD+gfB3yBtOM0RzlOu4Y1FugcazTQgQqEmgS7cZ1uZOMZqcDaIhYRiDRgQQYc4IAKsPAHTYACFLFoxqyoUQ21tU1v9YJhBApAAib0Z297G4OyeOCCGhDBCy9oQQ3/xhAJF5DgBCd5EgYwcIEljqAlKFHJ5CZ3AgtoYAayGAYykLGMig2DF9azxTBOwRDbnQB4AqvQswhWktm5EQUvgcmRxBI7FADvBGyx4xFJoCG5DIx4apTSXPRCPCbB4HmvIAYuYkELYYSOYx8KBmKy14vHBAMXlriDHApyJhOwoJMkW9P5NPMm29zmNKkJgAEc8IdGuMAArLGTAApAt9sQrQEBzAAIHnADGoynEu+pjjawgQ3mNG2ByEymMpszQU2JY2rDtFolGMEISKRhBTb4X3my4AhOeGIUqlBGrNQWhSj8QUB1IAQPCrCAKLjgKVHAz0De9hUeEMEsNeCVF1iA/5Il+tOfFILjSaYEA8WJACWZ8cAqhiGxZjhyGMOwXi6GgYseFKigJPhAEikUrWjNpQTDg53AsoI4FLhrK2wB3h1V+oEPtORgB0uSICUXAihZKwU8qAMpooeJUUTUkZD8UGKuZ8laKAIPeRjDElwwgxnUgCZnCuUGSkZKNwEKlQEQwAASUIAAAKA1AtAqLQOlgNg0oAIgEI8M1KACDpQBGttADjGLmUAFKvOuENRG1DSlKXXEQxx/7cY2nuGKSlBig4FYwQz+9wAQzCAOjsgEJTBBC2nM1Rr1IgRE8sWDBRTgBC+4lQ6rNBEv8BAsgCOBBFAwiJa2dIkfSAkGJhQtyf9R6ElIdMBlGKE5LhrmQ79wZC6IEQiwEG8EGo3iGv94l9ixJVoxeZccT7qVM6r0XXdMoxRfqiSRtISgxyvoH2FQh1NkDhWjiMUvfGG99l6vF++FrysSAQhjjcEIRkgKyGgiPvJ5wAPnm0BmPHNV1LjmwGF9DW1wUxoFNFYGD4gBFnwQYV9sY67EbKDT8LrMa/D1w/IoDtLU4Y14bMMYo6gEBwORA/JwAIAdoAEcCnEJSozCGNSYTxSGtDceMOED7PzK24wVCUMMhAg+fsoHLPABCdShBRb4J0BXwl3JiQCJGEDiBCZQATbgQovL6IUwQOfIWyAjEywQb0tve9Da3kX/prFDYhxZgsccAe5d2A1eRj+ARxfMDkJTIp5MWCJIuFglQ4HmASFWgQtiOOPRFaMkJcU81GCoIhGHIITgxgCFHugwvy74ZPnGxyYuY2Zlp9xPAcIq1qyypk7461kDQLADBuTADmYoTyoyfA1e25WBleIwA6sjtah5gxshjodflY20eFCjFYo4BB8AEYMQvvgBGfDACujQiEtsIhbRwAYZjqA35/2BDEyQQAJcUIdJEKERf4jEHAjRCAFJ5QISuIAFJJDTM2KgpSKAo6FdUsiDIg6PHyABC4CAC2cgoxnBBapwkSGLGgwPAw6IgEwBPWgLmTQFHQ0pS9Y1BLH0Lp46/4oKEfrcktndRSXDYx6ghzAlgvfxKuuaxCt48Whn9OQYFQt60CEa6V8MgxWBCIR9Od0DLwABZDKIqvio6pk3sSwBsYHZgV/NatoUQAEOYEACHoBNTO/BBjZIxYUNqDQHFnM57nEPcpqTzLdvI2riwLs4xBH3D4MjalSjRSLswAY12MEGIOAAA4hmghbM4RKg8AQqelGgfOnNCnt7QQIkYIU6DNEQjSBEHfIVBRhcIAIYoAAGmGwIf59ABBoVgR9HUPA4wqQFWW4BDk7hcIdW7EMR3YW36OCChEXAAYZ+M5Jal7qCNq4utHMXD96lo3O1wEck4EE84QhTgx5M5Bmivf/swcuET8CCF1v0ebckXnShQ/LSh1B6HuTghiqwYQ1egPqZRA3gyww4NKdUGu6zGgjWdV6XP77BAB2gB4uQCEFgA6MgH72mYcM0V8gRV8mRYdZQH26nDXcXNepAYoAXd9vAV3/lDcTUDKOgB3gQB3sQKhnwAAeQASYwQozACaBgCkdgb/Y2CKInAQqAIPhhCAMyBKnzAk1GAR+ghBhHBmOQUZDzErSXJE/kEgaXIznCZzXQA5CwRc0AUWA4DMFgdM5wCcWXehoHXst3FyUQEy0gOVTmfVqhFUakUiQgXTyAbnYURYszITCnXBAiRUnERkNgM7iQfs5QdO7VXhF1Pbz/gAqLwAiLYAh/kAd30AZ3MAdrsAZPJwMycC5RNUonA4BxAjMECFasplU7gxsLwAAKYAOB0AcxAIEcCEHVUA3IhGG6SEwbuDb0YQ26eBx7dYEXVkxQc2zeMEzSQAuVAAh7sAdsoAL/5QEZ0AExcAN4QAmcAANHQBVUMQSYFwUokAAWoBBjQBUkdwIYEAEUQAHsSAEXQAEnQAjA01IuERNwVhe3VwP8CANHBANewAeaswxhKIbCAFHOsAozgAIYIAESsIYftUaJMyEglQJn0RIBVxbWdV3ZNTBJBHsq8UQY2YfQZ1BLxCQpMASTsAoeskXIIAzGAF8XAya9kAu1cAu4/4AKkAAJjGAIhBCLSJUH84d/IMOPoUZqa5IBKYNq7LNqBZiKs5QaCfAZRLMDh6AFPpAKv2gNt9hCaiMN0sA2bQOWZCkN0HCWZ/kMZwmWa7M21xBXzjFM8lGC3iAODkQ12BANqqAId4BUa8ACo9IB5GEDcYAI4BUWagEWEbAAQnQjBZIC7tiOpxeZS0YIRJAjeAQTH/U6KfAC/PgikdMCRJAGr8BFRAdRwXCQxrAMvLCQDTkBcnFwMeFdB/cuIzBbB4UBQzAIdUAtLpAWlXOH12VHc/hSSeRasSUwg3hcyPVas+U4R+AwpyALPwEiYyhJkzRJoZMxvPAKlnAJlwAJi/8Qf4CQdJUoB2yQBkAABUvQAzMQigCmlAHUPysjgKqxdVm1GqlBG/uxAEQzdkpwBqhQH7hIDV8JltBQlmaZoNDwDA76oA66lguaoC4EHQyEYd2AHN2gQNdQDfGQDVazB4GAB3zANTZQbRxwjQU1PLdHOzxwAgkwAeXCAylwBCkgARHAjhLQjhEgARZgARQwBobgY5qZOIBEPK9TFv1oenWxhZ6wRcYwDAcJhsKwDMeADG2QURIwAdJ1cM1iIQMzPAIFLQF3OrPjZ861kQl3AueiFX0Ie64VcNzFJCB1mxcQWwflEiMAA5HQCNK5c2KYOTfBC/DFiNYTGbKgCYp6CY7/0ICHgAjxFwhCKQdr0AZs0GnvWT4goAHyCRr1yVWqcYpc13W01D6reAFaIAtpI5bTYJYOygywGquyqgzKAKu0WquzSqvMoJYJiosa9nbawA0ceg1I8w3SkAqCIAiAcAh7gAMy0DXkAXLQQjl2dhUOkAAk8AJIBHLuaBudkaM7qnokYAhEAANtZqQIU5GdCQP8+AI3igEjIESAoDk5YQxRSnTNoCWakFEWMAHMIpsHB11t2CwlyTxvRJw6ckYJZwEsBTwX0IcfAFtwmETwCnLE8wEXEI9N9CR8VgeDYAiRcAmlIAsfkjmRYbKRJIaRhAua4AmdoAnh+QiM4AiSGH+V/3gHgtMGnVYDUccCK0BqJwNAoYFKs8Fqo5pVOmNgAVBLGbAJyzAra4OgzzCr9lq1VmsMt0qryWAMW2sMxVAMyvAMZhmWC3SLd1mC7pGh3SAPIRYfuqAIgsAHSucFmZoB00pSrpM6vxOjGIICOLqOtnF8+SYBDvBvEmAscnRQNVchIWVoZZECOYoBQoQDpdkt3RKG+RoNr+ACSyYBMNGGmklnyHVl70I5LpEVKFGSfORGJZBRG5BwJbABdxpbdzgwsPdvVugSr8VnGKC7TJSjd/pvH/AUY9AI3eZtngAKoXBCyjsKoRAKycu8ohB5n/AJL5sJ4SkJOzmeSZcHf2Asbf/gBZhaA5kKYOhzarcBM6G6GglmgLTxVUurGw9QBq2gQmQJocxAq1e7v1Wrv/prtcmwq2opDb6qQBoqNc/Etm07WCuorIITPiwwMMyCLk/BrtfqUkukeu6Yo+AKj02UZYaAe0eUOLV1JPgIXhLCZy3QA1gQCpvjLcRwuVrSLbhgAhaQcbZlFwLzJHtaUHQERSfhFmIBfWmkOLEVORECSHboWnxkI8GZUXtUjxkbjy2VsR/wAvMWCZMQCYi1QZJITY5wCJK4QZHYqJDgCS2rqGi8kzUrf5UoEF4AajMgA0BbdaZEGgdAS/eJnzpDSy3TPg2GS4mwC9GQDYZsyPMRK9T/0AyMvAzN8GiMzMjPEMmPPCKRvAzMsEI59h7e8IF1uXfqIA4huGzxUQyjgGmAMAcvMDkUQlA16hBHYQEGYAEloMEbzMEcLJlMNm58phV32xJIhDgWorCe1ANAsAj1egzEEMM54QxdRAxmIGAOkKcRK6cQMlAg5y6sC6/PQlsAh1z+9KZKhJwf8LoJBzyhNlVTtWdVnLEWEI9KeKeDA3qhZwiGEAj2jM+BQAh/YM9/oHSEUAh+cAiaUL3V6wmeAJ7aW7OHEH+CIxDtCQTOKj7+hxl3/DLus8etcT/4Y6oD4D770wGKcAuFnA30MR+arAyXTMks3QyTfMnLQKsuDZab//wNJaihUPNMmeKBr/INGCQIdiAHYeCuX0p+3TgEZ3QbSYijuIzLHrxEL1AHJ3FEFAkhwQywCedJNcCJsuAt3WIMxwDWztAMvdAMj8AZDnDNtCcST3Q86tJyW1HLeAqnyFkXqTdb/hSxeb1mzXnOJwCaLcWw9QhbTRauQPoBXvC9/vw2QvnQ8/TGb/M2bUAHlyAKnxAKopDZigqzbByJ3Huea5Ce7nkml7EmArYypGGfGp2f93MADPAA/6PHBnAAggICguAKExMr0hAN0qAMVZsMx6AMVirTLj3JDtoMypAMyp0MxRDAazkN1aA0y4EdlzKC1EALglAGZ3AG+GhoBf8iFb9JArLc1LjskDv6wfuGAVbQAiMAPAJ7LV6aZwpnBGPAAqVADDkxDGAt1ol4DKqQARMQAUQspj1cSCClIS+Fug/bZseJsXd6UE/ypidJ2MgJr8Bz1/+2R7vbkBKwej7KKwIxEDoU2ZHdK29TK8qiLDTgB9UbCqXw4p+A0DAbnjvJk9xriZbIiSEzPkAbQOtDGuqrVWGVtBUABIzQCa9wCg2gYLRhKOFxBopQmj73aM9gr8UA1svgyFke07Lq0s1gq8mQ3Mq9q2gJDdANQWynHNwANSa2DcyACWVQBnJhFQqBjqnDZLeRcRlHuBzskJKJbw7ZAjzQ3tmFhesyE1j/OBLsDRMv4AVj4ALI7C36ba9a4gzH0Au8sAIVIAFXUS+2YxVWcATTB1J+hqZzulwoEVsH7oceOeHkvF0kgAETINhLvEQ/ausUwGQk4Oj2RBBeQBAo7uj3pSy1sgRG0AM9kAEsoAmZ/eKi8LwxjsbgCZ7by0FyW4ls4AU4AFVAOwH0yT7qez+znAfMDgurwAYHEEt9sh9n5do2AAroZ+kxba/EveX5K6uxKuYBLOZhG5ZmTg1uxzTBamzbYNKtUAkFky5segIU4KPXqhsZJ7g96pATP/E+6o/IdURcURbr0i6G5i7oUitGsAaNVq9gfQzR0AzLcAvEgAcTQAHTYjsE//UifkbqIDUvdqTWZAp7KPAVEW5Qi3OSAAeSdbpkr5VRq/ejSq96Se9EwXMuPgRVPXDs/GhanilENQCKJvAAGrAIl10Kp1AKmQ3tMi7t4VmzNy4HaVCUNGG+AURg6QsztDRWFlADl3AKl5ABdnI/SOsnsDQ0D7AHqoB+jqzyWZ6vhQ+hx63vh6/yXEvmNI0Nh2yBHnh3zRYf2bAMqdDdMz8lI9COGCcB6+PU4crUTe25LoA4LQAWQQQkXtEu6gIWMVID900MlN4tI7IMu0AMnFABFABor7MVNY8XLXchHCXhcDqtitNER5zXUqZRSl+P5bwBSu+Q+wakEfDOFqASrv9bzrNuAa+rziSgzhqgzhaAGRVgAn1Q0GAf9pn97NXbCaEQ44pqCZDgCPfPQdiuLOATippx2gCxQEECAwUMFjCQYKAJEwoGPBwQQOJEAREBTBxwoIENTrKcOWvmLFozZCWXKVuWUuUyZMdcDit5bNgvmsaMDbN5zGaxYsB06bI1a1Yyn7paqcKkKMWJEzCGDIHRgseJCBcuSIiQNUGCCA6wRqAQNuvYrBQsfODRogUMtjBeqG3Lg8fbtWxduHgxBC8jYsOOCTPmMhrIXrxWmbAwosTiEYpLoHABA0UJESNEvCBBogSJDx9EiPiA4TMG0YpRjPBcYkTpz6AxhLZ6wcL/bAmzN2jQwJDEhg0XJtTGeoECVgqdOZNgQcL2bAsbmj/XwNvChAoONMzooynUqVLcS30XJerTp1KiQnnypAnTJU2XIDFaFCjPnTltltRgYcJDdA0VJjgQiCCEDCCQwAUEHKCAAAYAoMGJAmjQwQUNOICBDgBBJZZaaKnFFVdaaSUVEUckcRQTTdwkxRQr2eTEUUgcsRWhmEmmGGFG2YSVWFJoCyoUYKCMNAwoAEuCrcKSYDgMhJvNrAswsACDxloY4gUiiOChhhdqcIEFtV4As4UX5OIBBh7ZemENXFpCZpmP2kQmmFh4CSPK1ib7EbK7UECBM6YyA7Qzzz5TrDFC/x9bLDQREiWthA8ukK453j7Qz4T8jDDhtg1YoHQC5mTLDLIPSDjhgw0A3WBUzj7QwFNTJTWhB0A6EaU7Vcb7pBNdO9EkV141aQ8S9+A7BJA85JAjjR5k0C+DCp5toIEFDjyAIAINGkAAAgiAqNsEDzKowAK3UkCBBjrwQRFVePHrmGWagUaaaeKVRhpqqMEGG2j2lXcaaqy55hpstiF4G2+8+UYddcSJR+F4Hn4mFVuEaSUFHoeQC8jTRBCStBEiSMABDCRgUoIkLXjyNeNOQEGuMbzAsgYtWzhBLTHBLJMtFHh8wYUaVgkmmGGIKYmYoIN5BRdHTDjBscqAfGHjx//6DDSzP09YjKkTNGNs6scsayw0DFbtzIJnn8XtgQpw86CCBxp4ADcT+ptAgw9IHnVUC5SbbrYJ/gPQAYW2+nuCLpc4xJNVVjFFlVBCwXW8TnDlNT1gLxkWkUD++CMPNoDAb7/93HZAWgUO3OpahArg1ltwDxI39gPMfaADNTYZJppvdn+4d4cfloebbg7uZviDvREneeTVaZh55sVRR554qBHKl1lGaVkujFugzDLhRJPyg2mbJDkslFP+YDMSUKiZhyuzdEEtFkaw2ua34seazz4NWUUVVXR8hStWwQpVgOIVpXABCRr1KD5lLGpUA5TVtEaCxvypM60pFGwoYBX/ImWlcP+RlrQYoIADlDAjByjAQx60QhY+KEIvhKEDTKUWLxziErLABStMAZ7HQW48oiBFrnylq/a4ZxGIQMQhjrWGZbFABXNzVukWIK0AWatArGvdQb4Fu9hdcXZTzIAKFDGLZmTjGw+zBja00Y3kFU8bb9SG8LxRPOMd72ALE8fxzrgNowijFibikcXSUhnRcOxJHIuSBUL2KNLIBmUdawypSHWCnsWvBSzwkiRr9iUUtIB9iykBU4CgCU6AIhQ75EQoQLEJTrDiFXegIAYW06ie8Ykzj+mMykJjFguY7CsOcEBZxJKVBRBAACyEYTKVqUyMDIAgChmIAoI5rcBN/7MBDqjAqVggszUcIhOnIAYxGFeKHZYCckAE4ifSSTleXUISkJCEIzR3LNDhgFmj+w8IpzWQrVjxdf8kwIDElZF+7pMBD+BAGUZRDGp8A18AW2PxuDHRiRZvjnU8HvSgp445buMbymiFMHihihQtJZSWGVJYhBMWltYmAQsYDslmgz6xRVA5nYkUbcyistfMlINY+VsfFgEJSGSCEohwxCIWIQhKmAILLMNT1NJHPz5NbWv0+xNpPrAaCQSzl2ARlFU+QIFplXUBwKTitBoAwmuiVW0VyEBc46q2DOSmAme5qQVc0BkWoIA3q5LN27L5gW0aYQZ3WIQmQBGMaBCDFf+oQMUpTGGe8NSqsuHp4SfQAyxgvSc+d1gDG7yAg/yMjm5SLFe5UleQf7LOtV0cV0EhUiEO6EEVu2jGQ6+hjW0ETHjciGMdMfqNORLPG9t4RkiHoYpRgMIS/TQAAQhEgNUWCAFlDSYFoNQxrb7mNQoclQMkUpGEvDQCtckbc3w6nAhMEQ2HQCJRAxGIRTBCEJvARSnGIILJjAAvK00fCYRzAc5EaatDYg57axPTDcbGwRzcIHN8+be13SY6Jjjbs+rqgbheOFW9gdQEMrU2FHzgOb7pajYt5YIlzAEHeUhsKF4hEmLUQhWmQEU5v8Odyn6Hh+fxxHmCxQj5dI6JXdr/D2/8I8UpCoSfqmttuATK2gJA90EnVAAH9tCKZVAjG9vIFzZ2uw06lnm43yheHqExC10cIxY5xgQlHGABkJ31rF0BZp49OGcoTSACUYLSbLbLXRMH05czrY2UtqbeliapdDgIhCEW4QhH+OEQShUEKIYRjE/gUqwSeFTeNliCPntqOn/ryt9miqQkIQnCLGW1ycqSFUN3Nc+A60+rPCXWEl/AVCYw1YUR08teXqABKq6BEbyQh2XbMBSoyF00kJELV/gvx6fAdndW4R0fVzYU3zlPJ4y4CCXOwQv4sZR++lOda1IRulekMpTD9a0EUagAF7nyATLCgDKkwhjSyMaX/8FssOMWzI4H253xrMHmZdBCFbIAxXxdgAFgRmBI5/UlxofzwQ94ytR9Y86g8foa5ySYZN1ltC+1Oy0W5MEQhkCiHwhhiEMowhK1QMYqluACkg3YUapSUm0YTWdTq3oEDQ7Lo04uHLIQKZh6zjMwqVnWcgGIin8mknGmk6pstkoDsu5KBJ61ARO0wAhjYHYeEKGJTZiiFiIZzDBiQUBVRBbbSXsFtrPt4+5kWxTpwRwk4pOHI3eJIbd5lj732U8rigtc1/JWgiIkkYhEZEEVigEmbhENamwj4F8OeL6ykS983Ysa0oDGM55BC2PsohWu3MMeDkH0wJGF1lG/Pa3JAv92lTsJZey1vcpp08sk4ZkCwfwAIxiBuU5E4uVE3UQsnMGLRWSABE53AAw6/rdgZgUrrzk6kcxiss5ssJCLWo1lGkwa7ULYwVkp8VgdZTZs4kYDfxYU2f3Kmw1UwAN1kzWryIoLWBsPsJQa8II5yIM/QARJQI9SCIZ3+Yhj6AVaqLa6UwWgQQYdAgVT6KFzCg9fCTxIKBbQqgEZYJZMmY48ixYnYzxriTIuupbYeUFrmZ1yORcfaBEQOYpUABFVEBFUMBFMwAQWSZFUmIVbiAVViAVTYKpKiDoAsb3ds72YSrSLO68He5TYgDXzUS8o+QoJAEMx7AoLMARhoZUFjIT/SLiETVAFZ0AGU4gBzuiKBYgKzvgbWcMb2OglXjIL8dugQaGf13gS2XiSKcy9sKg4rMgz//Azncq1DaCObKoAMcSAP3OAATCAqriwwkK7OfiDRZCEyRGFV3CJd2mGZRiGXjgK/1kXZwiGHIMsU6DFbhOPXLkcwZOPNQCCc0uOD6hEbGI3KjqdJ4Otx4OtLqoua3mpg3oAGwAES1CRFMEEVsqESyC3RHiER6CEFkEFWYgFWUAKpsIzOluA9gILCOig89Iu7hoS8Bkw0ACNxjCUXAo0nzqkxkAw7xqOsDirQNAET/gESKCDGjAEzMGEUeAFZ8CFO/AAC8gz1BidVLlE/wrgDN9YQWD6IIw7C1PxNeDopQnwNe/Ds6gjkq5ixChsNzzLsOpwgA3IQn9MgIhQAP47wLMDxTwIBEeQhF75hFPAhXZRiWPYhVqYOybMHVmArLqjRVPYO/MABYEUt/eQjzsgvB5wgUzJtXVDqyarogSolsZLxrGMLcZTAAZggArogBjAgR24Ah+4gRmQgRhYARXoAA7Ayw7oABWIgSB4hFWQBU4QhETghDootooTGe5KGdIYDfDhrspQDK1hCkMBDUERG/BTjdUQlCWZDY0cA17pBEQghBogBMzRhFHwCGTwBBCgM2AymweATQ3ow73hGxM7NfWajrFDPPt7AI1cm//fkADAkTpskjoqYkGzipZrcpu4ERzigAAIWAAEMABnyg2GMAEX6IEEXMBAOARKy4QfYoVdGAZhEAac+AthKMpaaIVYOIZfoDtXtDseEwVQMCVcdI9D4M48eBkayA+y8wDEAxzAIUbVejeyNNB+OgCqWwANkyu3eZa3QUu4eYAM6AAQ6AAcqDlBUARTWIU5cI7xs7h1ZMeTYb+dghKaGhXJ9BOyERvLzCW8YlGK+5sa0ITJuQQP6IFG4CxQYAWReAUVcID/WIANaNC7mo4Lsxtgcw7ZPJVg84AnxQ0NW066qisNeNIOeNIqBQEQMAEVWIEV4FIWkIEVmAEaMFMa0AH/JKgCNECDNgCCOWACJjiC54QAiiOIDGAIZtkmLxgDUDQE7nSEoiLFUXCFW7iFXvgF8gQGXyDPXhCGXoiFuXtPDFQFbNsh8yiP8RgyRsDPPKgCJJiBFcAk/UC8s2Ers+InxjNQxxOofkotxlMrgTgA1nqIAiihEgJLHPSBPcgEVsi5GtCAE4BIrIswLzQw29wuFzUVVbEpU+E/6XjWVFlWFv2Ap2OBXgkPSVjDnvQEUEBNVaAEGeAU62CBLbVOErAUTOoSmTG7HjCCJeDTl/ECNmCDNGADPMgDPKCDPqADP/CDPvgDP5ivgQ0EYwEEP9hXOqADObiDhrUDNqiCJiiC/4nVgTOtSydigRIIAQgIgY4VAghQCBMgUxqQgRnAyT+INPpyhEvIhBoNBU5ABVeQhVzYBV+w2ZvtBXcRBll4hVh4BVbonwxcnErNNr/LFcwZlkCgAzdoApkxvEzRlCgdRqlDHVVd1ekUqFstlxJSHVfdiimCTbjSS75UARXwATywBFQgGmJ4pS2tjrqJDpx61iel2ydN1/y4Wy9pAZ+Rmb7tAXgdA5kxgnf1gsKN1zHo0zmYA8QFxRpVp0yQBPa4BEsABVTAhWDAhVNoPkL4g0bg3ELgnM6hgzlAFmQJgzCoAihQ3SVYAiOoAR2IyzGtSxXg0i0FAQ3ogCqNq7OBzf/S8d1oQcvgZQAnSy0nCxAEeE4hEIIQuMQFsAAxRVMdyE450MmhOgRGEBbO8oRMEAVVcAVaoAVb+AmfsFnAGAZewIVaeIVX6J/Fcd/FwbZt8w7xCMj24FRAwIM18IL7uCSGMECoXbcHENB9IlCx7KIUApcKyQAfAIREuAMGcB0CUYhjs1IvNVMfiAEbKAM9EIRKeLhVOA9LmK8+yAP8nLmXM4RIIKoVRlr3WOEVboRGiIQYluE1tGEbvoRJuGEafjnODd0/2F+GhQTyCAX2eCdP2ISEHClGyIMlmBvr0IDdfYDgfJsqTs4GYADgFd4RQstyCd7UAuNXHZwapJBbnVX/KsMWiKgIAkBe5X1OX3PeE3ABGkACJIACNtDJ6xU8oupJYPGES/AEU9CR8BXfn/CFmqXAXigJXJAFnmUFoH3f99W7TKXfS0gq+VDcMXDdS8IkvC3VxOvKxasuVnWtg0gADfCDT1CFNRkGM7A8FkqQlwIBOsiEUkCFurtlV4iFW8iFXPDZvPMEwTsEPjCWO6jXNEgDLPgBHJDL2c3d3IXNB8jiK6ZmLJ5m0+EnrgUXTQTLh5idFWhZlhUWS+BGSqCEQAABad7agog8FWqmV26hFVqmeabnen4hAnjOjUWADdoAB6AZFjCCJ/hbNpADlK0v7DXNgBTIbxtkQraFh6ZZ/0ctI2rAhXB8ZBzCBfSVBViABe8g4vY42vfoVHpqokpRtwBeMtQqxuqaMiwyphRKABeIhFN4BWKIhmyQhQ6YVU28ogF5KQcAAS14hFXOaKFxl2ZohlDYBEo4BDSwy7qFaiiN4v7IAGvWtxsc3hHy4nJZgKzu6gU444KgMogogAXVABSanRioX01o2Tgz50R4ABLSN3i257q267tepsrDCG1BXghAgL8mmVMxhBqAgTAgAnilXu7E3kBlDz/Gle7Q5VmgBaGYBYh2VC+jBqOkO3AMBl5Y3/WV31NAjyKGnHYiQe78A9ACgh7g5NIanbVxRCYTZQMuiG3JlgJwgBf4A/9S4IVoiAZV0Om5jh0pk+AGyIAYsANQkAXzROpnOAT8BAQ2mIEn+k/eeFILW7cHveKZLICz9OowBkuu7ZZ4vjIIoTwGWIRNWCVqxIRuTQR9k+e7hpDJI+/6tm/79uZbrbwBeM6/fs4EGJVM+QMW4AEmIIMxKOhAQISheqeEDsjxCAVRaBxWkBHKlmwOyQVnoAY3cwVXitlguAUdUYWjuGVUWAVzgpzygJxNHbxkAQIcYGa83Q/+4Mrfne3GOwjyWlATIIRVgAU/aAAEEYDhfp3yWoDasQOFvOmAq9CyvV0sVkm1akGzkvLTwWLg/WowZrxbFRdcddXT6WpnBAEVOIT/TahpZFjbvjgFNUhnCA1juTbjOJdzOU8t4YXNvNxLvrQBGwiCMthgPdiDwXyESiDCTQgyHPOfVrCFXg5HWOgEv65TIlmAD2gBE2iAPyACJoiCOlBA+hqqFtZegVSn77hlCufBWYjUSL3co9xsnsXlIESFV/Dsb+s2IQs8+Ngcz/GCNAAdcTUBEDBAqV4yxatalkZghDCXbBKcrSgAbRnycLmiWm1VtHzGUTgGM4qr3MXd3YUr+7PSDfhfkWWBMkXTOq7jNO0BGL8BHFj3GyBZFBxTL32iee9SugV2hlCBDOCAtbQBO0iEU3JF/zGFRDCDGcjgPd/zGwgCM0ADO+AD/+5MhKGyhGqkTxwr9fUNR1mohVrIaF44GqHxi5IQeZEPiZJH6pAAiY/4CNV7hmmQhmd4k1VAgABAgI29gGnBDPH5AzoYgzr4gznog0vjyZZtWYUWdU+wLEQnIB4EkUeeu599LMDsaE0ghVX4WVW4hUYOJ1aYZHPCxVzE9fk4Fi/ogRnA21H9z+wGnLJ6KaudzodICNaqrmMSgFImZYR4ptligNpShTUwgx8AghsQ/LbcAXaXSxScgcSX3RUoWcSXSzOFdxQU/HX3gSywAzzggz54+OdWKuwVFvYQdc0ydFWyFVyGLMgioEZuZI7neF7weKEhGpFX+dmnfd9Wed/G/f/c133drxffrpffr5dp8BfhF35tuJfBkHkAEAAESIHXODZOER8iaIQx+APOVXCEXmuFhvAgCw+LB8JED/hHDviN7gQYQAARMARYuOlvyIZoOAZksDH5BQ/J0axgiQ+UXaL7EFdO1o8Zp5u1B4gFAhUkKGjAwIACBQYwNJDgoAECAiYGUJhQoYGFGiEmABDg44ADBxgEKWkGDRo1dvbwARQoEaNHli5p0uTJU6hSpUyd6qnq56pXQocKlWUUF9KkSpHyarqUV1FZuGTVwhXr6lVXr6Qirdpr165gYoeRJXbsGLJly5qxZeusmbNn0ebOlWb3Ll5qevfypYbt77XAf7H/adtm2LA3b98WUyOFYCIBCBAkoKjAwMSFEhE+fCKUZ1GgQ4sg0bxZ86anT59CgRoVapQpVKhUpUr1M5Xs2bdVyXpFKsRjAQhCwICVbXE2Z7xYqVq1qqdOUZ9EhfKk6RKkRYsYHQqUpw2UGuJrsGBhwoSHDRs0aKgwIYKD+AIXEDSYcQCBjAESDtj/saJGClm0EEMaAXDgfyG9clVUsXSFS1VM8bKUhLiAhcsttySlYYYdZlhLLbeE+CGIJVJVYi1XyRLLibXQQsssMdJy1Yu22GgLLbrososvvggjjDHGKKMMM0U28wyS0Chp1zTT7DVYNtkcpthi38RzJZZZarkl/5bIOSZRZCFgIMIHlpnwAQkRRDCJIX80gsgijtBkk3V0rhYKa6O0FltutdWWW26syHIKKUMEN9wgEBCQhSrORIkMUM9BV4oolIbyiXWQQCKJI4h4J4cXSyzRQw0tmIceeuq1J4ED8DkwH0EZCUiAQv/ZCuCAFjG0K0MI7rerK66wIiwrwxbbCrLJFrssK8k6m+xP0Uq7WyuqVEvbs9ki60osMtJiYzLJKJNMMcWEqyS6TU5TjTWDIWZllvLIw2U88tprL71cVvnNNtlgs5c0bxlTjDC7DBrCRJCFkAIEGPCggQImtLfBAnWQEkkkcJJGEyecbPLxJjeBkucoqPiEiv8ryQar1VRGnQLLJMAJhwAEQjAcgAAVO+qJa6dQ6oklljyip2nYOZJdd3mMQQQPpMpgngfssZdBBRU84EAD8TUwX0FdHyRgAbISeBGBYJuNEUQGiHSAtm3H+Dbcs9Roi4516wIM3uWWGy6RRSL5zJLSqLtXu9hEqQ0323SjOD30zBuPlfc+ni/lWe7rjTbWUDONks8wkwwwurxd2yijVHK6IHqorkcZNrhuQwwxqMABBx1UgIBECBwKgZglwEBCAyaAkIEGG5BwSicZMyLJJZlogonHIIv8mimV9mSKtK24oopQE/YECyx1QJAwAkIMMkkKj0UGgyEx9OJKyaaAAor/JZWYgico1l2yP9LezTGGF4DQg6ehRwMgiBp7qvaACUxAawOhT9ce4hCInK2CFgwbRETCtyL5DV3QUNe6rCHCwARGGyZUXGISI44VslAc6njhC9chQxjOcB2Su9c86pEPfdjjHj70Bz4c16UuLcYw/qKGXZ7RDGYowxjC6AWOZtEKP43iY6erRCJSp7oycLF1sVNBB8JIuzGSkYwPeEAYqVYBCjjgMbpLGAF0t7ASlIAHHxDeBh7AAgk0YhWRaARpJFETjnlseqKAzf1OgQrszWY2rFgFLHzjgkaA7zfqk2MKBpEo3eHOAKP4xjNmMYpUyM8TmNBJKfDkCU4MEhKM/wBNHuZwBzmkoQc0kIHwznPAqVWgPQx04HwgGEEJyoqCFzxb2gygDhfCsJnNlCE5oilNaEqTHDJcBzvakU10cBMd5vimOcqBjnOcgx3mfMc7zMkOdLLzHfWABzzh+Q5ytoMf/KDHNKTop1SUrnSbwATqBCHQgQpiDwQ1KB/2wJKE7gEQgNjDHewQUTuowQw+wAENZAeC2MkujCAAQQc88NGRilQFGsBACBSFM+HkDgI0WxgGMPCCU5mgAR84AQmeEwlIXKcmNuGEyEYmClPoxBRGXSQqYNOcnqyCFHWoA/hgkag4CoF3kzAfKVyqOwKQIBtXqsYsSIcTn1kqf0C9Dv+nPOXQPMhhDUDAAQtWEFfhIbB466laA+MjH1gJk5jJPKbZ0jaPwRJ2sPaox2EPW493wsMd7miHO9rZzsWeIx2VtWw72kFOerqzHpv9LDs+S85sxrMdlq0sPN6hjlS4Tnaqs0MXuahQiNqhtnbQg21zC4iE3qG3tfWtGoKbhiyoIQ1VkEITkECDGeBgBjKQQQxmMIMV6KAG1R0PDbCAhSUMQWYJE0BkJMO7FJCJBCQ4gXlWsAAHuIAEc4DFJ2jSCU3MFzWemF8oKlXUo8qmZKJ4ggP+AL6m8AIWv1HUcIQQghCQYhKT4CQCHMCLeDSOHtfQRW2ICp1D5i81872OIxL/kYhFHOIPbPVCDaT7tFN5oMXpkVrV3JPXVwUzghNMG2Ar+I8d83jH+dghj+0pZCH7+Mf6OPKR/4HkHzO5yUfOx2KjnE52RLke7IynPNHpDnjcYxp6sIEPYsABH5C5zGYm8w7S7IOKlsEMZTCJGtBghjnPOQjBDe6cs+ADPetguSv4s3OfqwIVAFq6M6CBDvqMhR50NzgrnZl4QzCEmKLgvDUwAQsqsAAL8GAFmjAwfTvRCfsK1agaNqptVMEKUDjiAQGIACkgGVWpatWlKTAf+AYB4T98Qx748CE9tAEMUpaiJ6cwKmum8wlRa8ISlHiEK2EpByj0gFQuKA9Nz5Oe//XAuAIScNVe6+O1v+pqVxa0Z4/THWR+qHvH/ng3vN89ZHb3ON7vTve81W1PIPoQH/hghzx0UYYz0EAFILiBD27wOunioOE4uIGhnStxGbjuBgp/HXSf+0WDg2AFHNdABqgWcg5k4IwmF3kGwqgBE4hAUQd6+UcgzDsYfABNJGiBqcgTHxMUQQmnaKqoO4Ep/IbC1KfWjSpGQYMFSIAHQyAF1KMas1qH4KqDyDUBso4AXMQDH/+4R4W9MexRGPvY1auUdD5Rk6Bl4hKvDEQf5MAGNnjBaSvGtrbT8wFu+/KXWBPIMJMpK14RHmzoZjfi/5H4xSu+8Yj3Bz8gD/l5z//b3v7Ad757HPlf9zuI3tiEHu5QcBXY4OKw4yhHBz3oj7b4gGF8/etDnvIOyJ5qD7DaAxrQAAYwYPe8/33vz9gAkzdgAxEQwMsRJIAA4E4AvBMCDEaAUxe0wAg1gIIRTMBAHVBBDq8wsKirQ3Sjm5o5iyxEADyiu0nIGpJVBa/uaobrqy6fABPABj3sCXZ6+FAcxShZbpBVsVGKdHjCP9WEK3lKHiwgqBhBtT2XqZTHeaCKCagHt8VYXsGKjeHY2BBegRTAj1WZCFYZlpUgPPyYCaagYzkWOi0WP+TDCcJgCsKTO9SDv+HDu/VDEDGDICTCIfQWHjDUbO3BSiiUb9n/Vm/NkhzIwSzNEhvI3RK21RqsQRoEEBBAQd1ZG7b92Z+ZAKGxh8GZAA2swAzQAQykVK1BmHCEgM3AwAWQgBfMAQ/UwBjkwR94gQY0QAfowBv0wcucwnSIgiAOlSmUTiGiAiugwvyIQhxcQBuB1weQAi802FUBB81AwCCw4fm830Qwwjfggz3Jg+PIwznMQzckA27oySZcgnboxKWYhia0HdIAwne0Vd3VwN2tAF21mAbwYntgYF5tjQIM47iJTQd64K5kmZRJGTtt2QxiWTvAE2Q5ljJOVg69IJZtmTZmoz/Ug7ylgz7cQzykQg8Ggm8N4WwVIR5E1ERJVETJXRuw/0E8xiMbrEE9TiE+rgEaAIEV9gAOpJgMXBu2xZUuZkDHedwMKAEUEMERaJLNiBeCPV8KDAEJfAAPjIEReIEc/IEhGMIYsMBHxUEgQMIpyMIq6AROsEZrGCIrVBEoxAAIEEInNMIgRMILOIACGEJTDUJVXSImCgFQKpglSsAn3YPiiaI83EM7vAM9eAMz8JMiesL+RAcoYIpPySKJeQcDpgEQ4KIMOBdNHRBdqUp7+BIwAV4xGiMyJiM8ZNYKviVczuA0PpZbnlMLDpY6mRNe6lA9uAM70GU0vkNkwUNf1oM9wWBmyYM0CFQi7BZFKRQe7EEf7AEeVKZl9pYc/FY71v+WSthWcKHBFIKmnJkBEAQBEORADljcDchADVAfzpWHLgoPoc1An13BDxjBEJDB+dRBSqEhGqZAFLSXC2TkHPxBIchJJByCGtAADhzCIVhCSZrkKm3CSpZOK5SOKjzCAVQEBVAADxDDJITBCjSA+2mV7ihY+WRi1TlYJoACM/jaP9TDPczDPZCTPtBDPDzDdZaSJhiVpSzbqOlPAobGp9BdtYnHDBDkBGobWV5gA+ne1vSVfYjNRXggDWYWhqZDOmDoWzaWhzrWXGbTOqHTOunlPOQlO+wllPklYS5lag1mX+bDC2YWPIBDPMyCHgjCIbBEG7SBZf4okCphZh6hZ97/2Z2Bpj6uAWmaZhCgJmpaHGu6gKGt2HmsAA3QABLIQR/kwAx4ARkMwRCcD09mIu9IRgqQAQ+4gAssQR0WAiLISU1IgiI01CLMRCkYxSuoQiHOzyjQRp/GwipcQhhcwAJEwAWQwilcWg3ADHBkndaxIaReHSlQCijMwjfQAz7MQ6bagz4sFjs4jjRcJz+Bgtn9p2oUDSR0yiv9gYm11RUuQYqBJabFZqpsQIvd1YzRmIQS09nwijRiaGZp6Ia65WNFll9q05SRqDoJpoiO6JStk5XV4A61ZTxt45ah0ws+VjqMwzdQgyIAQh8Agh3ggRiIAR2cK7qmaxRGYTxmJj3O/x0bpEEaoEQa5KNbAQG+7uMPAMG+OhwO6MDDfeVqrgAO7EAZXMIqyEIjDEEKsKH5sB+jLtiCnSkTzOEYzEFoyMmcRM8jUAImfCwocE9XYEUsqAKLoAIxOAMxwEIjOMAGfEAkGBj49KREwN9wkIKCwQIxrAJRlcImKIMoaio90Kc+/FgQyUM+lY5sTAp15Fd1SOUlcIojNEKb/MEcyN0YAJD1lQoLRGC20VUCNZDfwQoxTujXCAhDCKvarq3aZlaz5uWzrlOwtq1paWiGxqAM0mC10mA36gM52agtnAEc+AEe1FYXcAEdzAG6rivjLuHcyd092iPdeQHlUi4+Ui6+8v9j5m5uwf7ADyQcDiRcwt1AJkgFL6yCFZhnCFwdLFTVgo2XFURBGBBBHSICIjBPaRjgP22CJYQMJnyMKbgCLgQDWexCLsyIKgQDXUzCCpxCJJzCXPDCJuFOzcYRAjgkLEBKKvgMz2RDUs4nPdiDYMIDEM0DPYAVVBobAeYEddSJJkgC/FItIZjYAv4PAFlba1KfBC4oAlXNqugV2aalMRaA2nqTOXRTN30TOtht3QorZAFrAy/wsLKt3cZgY4HoCs6lN/rDOYCDOGRDJXQBGBDhbanBG9DBOiZhHMTBHazwEvZoPNojPtZrPVauDXtBFW6uDuNrtfUAvv7ADhQsc9L/ACI4B6FMwhGEgPXWTINB5HiRARnQwcX6wSLA75zc1yj8LsiEzMh8DCjERqqlQiykbDQ4g8oSQxkjgzNEAyykFCfVLPytrhCsAjJsj8+YQiXoAoWZb7/9mLsF0YXhRtkRYHRcynzRRCZwypuwKqvOwf94gQOOh5qayqyCLXtcILjpHn2Im9kqRIaCEyiHsgRrqARLcDsg8NpOIwSblluioFumgzbC8pZ1qmeFwzcowxlsgdzZQRDYgRksYRL21goPcxzAcI/K49zpo7walxdUgRdIARRkgRdkAb8CwQ4AgTRjAb/2QBD/sHYB8Q4sFx58wvw8hxlaomSYD086MQxo/9L8+kEgyIkldAwWV5EpfEwV3dfvggI+l45tyIIZBzQyzMUar3Eba1XN4kwcyZ/OJmJP8HMlUEO93EM90Kc/6AOPARE9bMOwmQx0GBVZXcqyhVqcOsIiIEJHsqrSVO4SbK3+wiaDvqyqSMC36VWESiiOZRYCKzACo0OGLjCGchMFrzJRzyUs/5iG5gM1Aqs74OALcuso2AAeyEEKt3AcLOG5AnNlbqYdrHAbvEEbuIEbfMEXiDVZa0EVoDVaSwFyNcEVYMFb+wBcY4EP7Ks1ZwFySYEO3AAOIAIlVMIxfMMx2IADjM/yCQAb1sFVRZoQONgfBQIgKEIcAMIjSIIlmP8CL6BCMNDCLmyPIoICJXjsx1bCP/UpGjsDMhCDGgs0MfBCHfTkdx02zZiPauNCIhqgIuhBK0y0vQ2tO3XqOnwDKpYOJliCIiQCUd0PLGqCY/8RIjhnIJjYHdAdP1qfQA5k3r3YL1aAXmFNhHLyuBVATyewKHMTOJm3OVBwOow3NwEmsNrtjz3WBZdgU/sDDMoDNOjBDTAhENJBHMBB4wIhV9vBG7yBWI/1F2gBgmuBFrC1FDA4WzeBW18BhfsAhVO4XfvADugAEkj4DEz2GcTCYtxCDBgA8r1c1RnYJPAkUCq2g2kCdxxCIiiCInysK9QCL+zCV/RCLchCIn4sQAX/ecnUAjKk9mrTRTSkduu6cXBQhHDUzCQQAzHY9j1bQiLk6DPEQ33uWxANFl/Oizcow6huwrNVD56wRk0E3SQYjXZkJQNOISSLRwTe3QS6WAIp0NX8XTBx8kGg9wFzUzmUwzgM+jhEU6AHejgFulCvLXv7dIamsjMWa1y6gz5Anj6IQyuoAA2scG0toQuvKzHHQZGasIGTdYJrwVk3eFs7+IRfOJlduG3yo0XtABLoQA+wABv4gB5EwzdkQyqoAAUQQPIJQSUZGNQ5WHM7gkkfpyNQgiWMgiwEQ4iAyC1IRcmSuRZjwijgghoXeWqjMUGnLM6K11ZJBM7MNimkdp6C/wImKIJA6cEobEM8zIPkdWOUDZa80IM6PAM/ZXEmQAdrpIaHfVjUasorgYZ33AFbrUGct6ZX0rklb7fVnOVARJCfg7KgE3qhjwOiHzo4HbpQn3c3nfIos200wuA5ECs1ukPk8cM9VIMexMAKtIFtefpVywExw7Co51ZXG7hZJ/ipR7iED30TnFmZXbhdW1QQ+MAMXBpIrUI21EIwmIIXbBLyEQApgI+szVqDRcKaa4ok3G7HYnYs7AItgEgs3MKNywIqfOzHoMJAl7FAx30ZS3miSAbNNPm5Q/mUn+QmVELqAILqFIM6hMO74SA85QO+J+U6mC80XGcVDaArWgemuP/vdWBHtHXHHyS8HIzBqNSAAInHQOriAalKL2Fgd+vqAhRENx26xr++xpPDoJfDNx067R+wx/M0T+903boDUjM1XUaePcgDMMQOCKiESnw1zg9zgYN1j+48RQVXgSP4qTO4qks4EmR/maUZ96sZme3r56LmDtQAD+SRCiR5DDyCI2gSRFrBrL1/a8MCxtREIh9Ns4MCKvDCje+/K8xILKQCQGwSyAoZtWjRnCVMiOxgNGTEYAmBMHEiAgQCEATACEHIoFWrPmlalEjQnjt3ylSi5m2eP3z+8sGDN09ezXr+9L27N63VqFGnTpUiReqTp0+hQoHy5KmTJqeXLkFytAj/0aFDgf7kkcMGypI1QHr0cNGCxYqyJtCa2LB2g4YKbys8iOugQYMFd9HlLVdu3Dhw4QAHDtyXcDlzh/caPrz4cF505hyjazfZ3OR07fLlm7zZ3eZ//uh9q6SiAwg1p+O8Uf0mTurVqOPYkX1ajRs3X7TklrKbdxPfSIDvED5cOI4dPpDvaJLFRw4bOJa8kDDhRjRcdhDRGSQkRIiOpGCFFx++Y3hSkyY57STJ0ypQmEChehULVyz7sVq1SrVpVCtn2RpyBiFnHjqIGmeIWSWFibqriAACNCKAIyE6ISUSSA7ZYw9B7sDjBxtm8Uadl/iJaSZ6UKyHnxXroaeaWUZB/wUookQRBamklGKqk6Y0gQoSRhYB8qqs2vBCjjW8AKKGGmZgQQYWzkLLAynXcgsuB7C0awHH9uoLnC8FE0cwwsYhpy/FGmMMMskaiwydcthMB56YOJuMHXb+wUceZmxQIYMM0qDNNjbakMM11VBrww7aTvsCN96k8E3SJoBDIrnicMg00+F8UK6KHIK44QYjJHDABBlOsWSRP6zYzruOVhlPPFJS8G4Q9CKJZJIdZQFwlEoEipEVVvBLpZJRNkklmmyYbeighaKhBkBiTuFOiGtDqOgijThKYddGGMlQjzvikGOGGPSARh17/Pkns3rghTeffz7Dhx55ttHFJxlFOf+FxlBGASWUT3YsypOnpIqKqkMAyeMOrY4EQskZKH5yhbTSAsEDD9qycq66IuvSr78CE0ccMMksTDG9EmtTzcXgbMecczDTbLLO2nnnHX/uiSeVGFSICw01zjjDUS/YkEM129xQI4022mC00Ud7m7RSHS7dQVOtjRPOBxyQqMKGHMhmYYAASJBBBhzy+GOS7bYTYhLwZIVlEiFSuHYQK1IgI5JPhnpFFlMwwYSSwjcxhT9gK0llmWykAUYXaQ16lqFsDHIGF1IGGaSOa7ENgQABMArB206uyoOPO+yII4sZPIihFRHbrcceefPRR5/PXLoHxW+ASQUVVEo55ZNSkLf/sUZRPrGxqKag6vHHRRjuI5A8tEJyiRp6WLLJi00A3wSN2WoLrgccgJPlvsI0WUzBwknZzL7IQazlNd18zLF03MmHn3Iu84473cleotmDFGhggqEVzQ1v2AprVvMGqD1tNqcxgxYcpQVIadBqSLhC1oRzg64hxwc/qAIazGADG8jAAgAAQAJqYIK2zQ103bkVeIYyt0FMJG8p2E4KhlCHSQCuFKEQBSg2UTjEwccns5AGNb4hDWxIQxnNwMY3mNUsylGDF7A4T9w617kQWAQBEIBBIwrBMOzxYQ922EMObrCHTWBDHu2axz3wUY/MvGse9rDHPQBJD28Awyeb6NEi/5QHClF4ghOeGNhSngIVSUzlKn3oQ1buwIYkMWlJT4ISxjTmAQ2McpQZOF/6EsMX9pXMffCLH2HIMb9YpnIvLmtTXiaDjnTwLx+dgcw6gLmOe8gjGYKIAxLMggY0pMFobmADG5jGtNMEalG0MYOjHiWpSEkKODr4IHG2RkLkmDANKbyBDDbgwgSwQAN/MMR5XiWR7+RQjGXkzquAWIdGRMIQl3AEIlChClMs0hNITNwusvENhcYjG8/QBTCgsY1vbEOL0spGMGDRCfR0Dj1vwxsCJDSIRgRCEHzAHh7woIc9jM0OgrBFPO4BmprYox+6y0c95tFHP9ZjmN8ohk9Ucf8KT5SiRgUVGFIM5pRISoV6gXDq9bbihbAsoXszIAuUVgC+UGpAlKM8XyrZRzLAuO99rkwZYV6W1sasgx3tQMc5LuMOeKTDMMFchzy+MQo9qAEJKpCBMnOTBk16AZvSTEOgpHZB3HDwN0jgpg6whqlMifA4JBSOFLxwBRvcYAYmCEAAHCCDCvwBPJPIlg/jNje7XYsi2ZpQCmBghSPUIQpzCEMckJcJRmrCEobbRCyO0QxpfSMe8fiGNq7hDeNi8YlZRMYqDGGISJxiVpOIxHYQEIJJGGIPq3sYHu6gBz2MzQwpmQY9hnlXetyxH++Ilx91etd4JCMVuRiGKoh6iuX/JeUT/U2qUn0UrkNUpWF3OJIXvEDVJbkASljN2JQ0Rsq30HIc4RBrOMjqysGwD61qfRk6gJmXXV4GHjKzqzri8QxB2CELOFBBDACrhcMi2FHRnGagzGBN3eyGm479DWQlO1njdGo4OMACELCAgxvQgAUGSAAJltQJ83AHAnCTW3juJhEGMahWHRHCEYbgAiI0or+F8AMiAoGHQGxIEZU4VitswQxpTOMaEi2uQiU60W1goxm8wAUuBBQNYgTjFV6E7oUOYQc9yOYk4R1vDq5wBj20Ih70UMc67lXpe5wjXrbLqT3uWBNm2KIZx1BFv5CHlOU5bymtRhiQhASIrGyl/0heMEL3auCCGXhSfGjZqgYyYL8KuzLDGpbfLGmJpvyRYx15uVMABcgOM6H4G63QAxtyIAOgoaEK3Z5xtzGIzcMe1gw5tqAGq9bjburgOJpSsgjdbRwc/ADJO+CsCybQgDnMgW6wiBXnhrKK84Cnc1pu0KvCuB0YHOFWk4DFJ/Lgh0AAYnV7kHQZxCsIQQCrFb5QBjSktY08qwPF3sCzQpllEGLIQhYgeQQgFi0bObBOvDGwwRUwLghmyOPSNakJim4HD5zOA0X4wMc97CGOaSgjGrkYXvJWXaP+LuWRCHPEj6oyca1oZQwJvvWSmLRrrIpvY6OE2SrbZzJjkymWyP9OJWMis8sQo+PZAZzHOphdE2oIQg1rwEEMgJaFbi8zDV+oghRyg81yk9vcargguhvb2Ep16muaEhW8L58pev9gBzSYQQ9koIFA9Fs8xOiieASew3syCHQd4eggyDAIjQ7lD3LAnqLOoEKbj433NiiDIJJli2RQAxsi34Y3jk9c4qpD5NE4Bi9eoQpOKGJ1srFDG9hgfcDbIAji3cQ21ntXnyP9vTSRBx6Njg92XIMZtIhRUIgaCqgz70ahgGSPfDQVNF8vK3MYQ9cTLCy8p0kaTKtESdg0bKzKCn6ObRw+7E3cRO6abWbOAa4q4+7IoSbUgRbKQA3QIAeApgOu4An/oCALzKDwDi/xHGXxyq3cHO/xeIxSHKtSJq/dLE9UJgsHcSAHgGAHkEAHuAcI2AASwuMjBE61eKGLiIEY0OM88CZb4qn19OZWbsWLGmEO2sANDqsMbCAGbsDmcMAMtG1tQOX3GicXliFamOWKFkqhDAIZhkEWhIoRrod1FmUN1kA2VODFgsAOyssX1IEmxE8d1itecurn7qEl+EEf7kEb9EVGgIKokGcS489GHulg8E8SpmdI+s//AHAJvq5iKMbBxsccEgMwwAR+FpABYant8gLu3mQvImNNDqMC04EdzEFnpk0csEEQbCDJvpA0kEAJmkAKyq0KngDxEi83rskM/7LgGcstCyCPx65GB2jQBnMQB5DjBjMFCaRACWaAe3ogD0jPi/qNF5aQczyKyvJGb7wMb64l9gYBPDoBAJHgBq5gD/dwB2RgBXBAbXogx9xoDxSBP1QhFm4huJgFi1LOIaDvFDCBDvMg+xYFDfDQDjrgxXKg3HJAEKqBEOMHmOQhp0iSJNGLRPzBHuihG3QhFYQH/ihxEkWBqCzx/vBvEwmBEP4gK/KgDcaADcagKwQwHCsmSoStwsAB7QLjS5iSZFbpTOwHMkwRTW5pMcihAgkIH0pkHMQhHnTBBoqAx3jjCZ6ACqhgN8iyLM1yLbWACrBpsRAvCz6oGCmlg7oJB/9oYMkuby8vLy9p4C/DjmJmABFeoYuSsG5gASLmMcuyRQodE3SGYBC86A88ES9R6Aqu4Bk7BQvw0A7t4A74IBEOJz5YQRaGoRnUEECcIRhiARVCwRISwWFkYw0skjbRoCKVCQ3KoAxm4RsI0R6O7h7uJB58Dl5KcoDkYSWBQSAwARIgISlmcilqhBRYDRM1IRMkYZKq4ioCoQ/yALzYYA2+wAt+8C8pxvOyagX2EAQYgzBeyZWaEjDIRD4dMCpjkSpvKR3QgRzY4Ryykh/+IRzUIRsqASyVQAmK4EAVNC3Tci2pgCwd1EGTUQrk0gd+jAZ/ELI0VEOVzGty8AYgCzD/wW7XmkASVgEdTc/0xOP0Noq1ovAxr+VzJJMU6oAMEszzfuAHdHAvyaZH+5APAiERHsESNiEUUCEWdmEYkGEh6gMVQMESSsIO8BAPW9AM8BCFzACFME5d5CH9hHMdiLMm3Ms4zS+nfIcb9MVwIKGITGGgSgFwhoLVdsQpsHOSFuFOr4LiwPMN3KAKZFAHaABQ0TOrVIAxwMo91w7tKqw+7+d+1ESX9BPE2GodUFJAkyEGdqAINDVBEZRTn2BB17JBIzQtfQMzLZRSrLEaNxRQIUsHbxBENRTsakAGOKkPJOEUlFAhlrCLvojKXvQxZRTL/u/WKAaORMU8d01tlFUG/27gB9bgDrorEA5BEYjUFFTBFWShFmThFVjBSSEhEO5gSqvUDIJAmca1DGJgFLZBHLrU6ILJ5+Zh6HxOHtjhju7FG34qiUwBKEzBiGhyv/yLR3pEEx0BSLKOD8CLDpTG8KSABgF1BtIzTQ5VKTfsrIaNlmBGrUQsL+zKH1bkHsRhG0ZBBXxgUzlVU5WAQckyZRmUCsBAQle2CUx1BlNVVVdVB/Yy3jJFUAdQbSjmB99AE0hhFWSBGALtIIjBCSHAdGD0HetgHiHCEIhAqmaVWftSMJdVWW9gI9XgM/EASAVBER4BE4q0RkBBKTBhEfjAD9fADCQGCMg1CIKg3OS23P/QNQaSIR4o1ejk4a5IciTngR3sql7xqGe8IRlGARMCqnhOQf6MaL8Gpr/m9CadU0gCgQ/4ABD6QGH5tGF/bFAh9TFqKdlExi/GBFGPzUzaDu9c0TGCSR3GwWMD9BueoU9M9nYPVGUTVGUf9EEZVAl244MsS5w6ZWdXVWfdbS//0vN8dgZ2oMWuYAUcgRWCIQ2pQVqcgXMkoh1bL+E6og7qADwgYgxAsWpXQHkF85yyVlR+AAtqMw8/E0gLIRESYSSsAlxp8waAoEf5l2yCwEdzoAM4oBKwAab4ll5zih1GsiaA6dLqFSeOzriYIRVGIaiAwhIHatUitygATJI2ceL/tA57tmLcNqliRkx07Yd05/Os6LMVYSmYVvcc8iKWSG4cVkQfxOEbUoEDQEAHTPZAN1VBc3d3VzZ3VZYsg5fyiJfIjHdDdZYv+9LzIHYF+nEF8nIGMkAFBCEWnOF6o4UXXOVXvfdzWgU9EqQGqIoG1EYF+FKKRSVr1aZZ3ReF6Bh+F+Uz7QANsODyZKB/jXVr/xiOOECAdYE48Qgr20pw+7aBSY6t/AGCh0kcoAFGgqpfbKRN/3VgItcmoSIqLPepsMfA5GArkATXZmCXuEQWY5FlJnbYLBaWWhGYVHcdzsEc0sEcSC4ebJgf1kEdpKEMBtmHgxiIUVaIjdiYkZkY/yPlBy3FsiTrZt8NittYitNCBs5TBvQRDVDhcQBkFVzlWvLmaRMujMJ3EgxgAWAhEmoACexNjc838171jbVWhN4WDWSABowjR3O0DfRYfbXtiTOPLxngAThAEKjh/PyhAtmqHRT5xC5tHR75M+bBXuThRVLBgtnUFP5VeZyHgzuYqagi67wzlOWgSKAA1yKVlvLnFRNjPhO1TNhOlsuElm0ZlxvZY9fBG2xhkCtAQ4N4mIWYUxf0CW4XZdWtU4SXOHYAmqNZmnHQPP1KBZyEWf8RCO5AWjeBF6iBCT0ndIRAnBOuRkmhi/7ABD5BDr7geTMljuF5suD4rZvVBKTamv/9kg1QaI+Vdd5y9ENzQMgyZaA5gANmodIS+hzY6k7Eb5EbmVIfubGPjh4ckV+Q5xQwWShq5F+nzih45BI0kRGkghHQTNZ4cpQ1iari7j5JN9lemcNiie3arkyYjR04luRg95HpIR5GVgU0oFOLALJQFqg/1YjVMmWJ+UAb61LksjiKI1AFFZ87Ly8xz5+XFWLHcGt/oDYfRlofISTqYIzwiWmlcB6TECg8ARLSgDnc2mrjDZ/x0t3YuwdwYEl6AAgQLA3WQLAosmv98ArK7W31mX+3MVN8YA8jrRLADx/64Y/QDx/WIXARe3BLMnBT8hpmgWwzARIWKUcIphNqZIP/rfMmYW1huvM7Rbi0wyLu9FOVUVu1V5t+XLvtYgmYZNscermRj04eoGG8dPt2hblThTi4eTctgdi4JcVUfcBUKws5VpW9nZqKp1uNtfYHrJTRAoERLoEpGmGHJuSrYRQ8uugUXuEUDuEO2uC8PwiOfqCv4Q15NSUs3FwcJcYLxg0PGcUMrkBuN8+/2/cHlngPdSAO9sAWzi8RR/IecKoedGaARHKASlJF3mEdrsEWKgETLmEmTeFsB0aDM5uTnZOpRPqSStwLugLF8ye198KsWvy1YRsyYHx1fSceWmGzQEADivq3hZq4WbZlfVeIYxAzP0h4xWmpj1eEpNln83Le//ZYytXgaw9hERSBEjhhJj/iExrBWlwvbmK0c0jvIzwhc6vP8T4IC37g3do8LNzNzdF9snKgfcc1S3WTf8tda3KUayoL8GiADvSgEqzhXuA1cBHdTgaI0R08p/ThkddPFwoHKChbo41iJjvcw5VqYKPig59q1mrNMfDHTUy9HFB9hVmYfg6jFZkN0+QhGxQhCFQABDKg1hO0mHNXuEX1iLdpOUwV2IsXB6AZ8wS8hHZgvuW8DRoNSBcBEjTBE47IFFbhFQTnFd7GVuBmnOcxVlL0yzHkKlYH3H0AC8R9B/YaB94W3cEiLCTGzUVl3bVe68k1S/83CEoIvnHA3OVtU/+Q4woAbwbMYA8mLR4aeR7OIV7rwR06A/DZIdpI8k5y6iXygWa4gZCGBxUwWdWgDqmmThOgp5OjQv+sgjvzYA62AmZSSeNVOdlOV1FbG+3Q5IVpXL58oQzQYAU6IAOQYFOFueVvHch/94jJclJ8PdgD/GbpnYTKbZmSRnWk9U4hwRI4QZH2VRWSXhb+TBYggQyuHeoH4ROI4SGMFkEeLioSgWHayIKcBg2yAA0kht6+Xuzbd+s3Ra/NH+2xoNwwMxrfVmK23muO/IO27wYUTQ+eQe/DoQIBop6+eu4KuoN3sN67d/PYOaw3D5+/fPngteuWrBUqVKpQmQoFqpTIUqL/RIUKVSrUJ08sNV3SpCnTJUiOFiGyeSiQnz5y5KD7ac5cuaDlfho9Wi5pUnPjwjkdB7VpOKjkojp1upTpOHHk1v1cF+/bpjI5ZHDggESJkiI6irh9q1btEyVP6taVO9du3SZ8m1y54iOw4ME6ChdGIvivGTNq7Ni5k+dPoEWMIF16CUrUKVWrXr2ShSs0L1ynIk2aNCi16kGGVjnLFi2aM9mkP2lyROkRo0SCAPHh0wfPnTZriq/xghyIciA9fjj/sWPHjyzPl2PBYgbLFTOKzXhZDsRLFizRd/j462NHjBg2cgQ5c2ZUtnjg3p2r568ewoPw+ud7V0+A7ARYj0T8//BTkT3xPDPLKKqoYgooIY1EkkkiqbRSJzDBJBMkjFCG0x9+5DHHOuy0AxRR5qTDIjotoqPUUlY9FRVVUD0VI1HjqKOOi+mAxYwedshg1gNI1PVWkkXERRded9Gl111SSMHXX4ChN5gPSGy5pV9ZXJEFY43dcUcfklEGCUyehGIKKp2BVgsuvPCyCy/BzInLKqR0ctokkXQiSzTZYEMNNbEhI8sqoXDyCCeYWELJbokkUkgggARH5h1ssIGcF1D0xSUSTUhBHXim/mCGc9eZCgQWz5kX2A44qKACezmU4YMNvnhzjjv75BMgQv5RVFF/8OhH0YH+/LPPP/z4Qw80tP94VMoopphCIUkoafvJSpq0FNNMjtBkUyGF7NQVUjCuyGK7SaUoVFDjlBNOOVSRU1WNUOUo1I5epWOOOt+kckYcQKjQgZFIKgmXXFDWJYUSSFChxZRT8mXxlFc04YMUgEUnGKiihhmmGmPuAVwghyxi2bcocfSZnMH0sgsuwQwzzDHEEIMMMbzAAssqqxATDTXYbOONN9hIcwwurIDCqCebYJKbIotMekhOvt3x2B09tcHGF1l8UUVfTSCxQ3OsAqEqdNCx+sN10J2HHgg23J2DGTQEIQg15IBzTj72DMgfsYZXlI8+CD7rTz/MPksPNtN6NEq2F4pkEoaedNtShzP/fYjIIYUAsg457KbzU1LnvJu6UTG+rpRQsBcFY71B4VPPPffcR4480giiBht3oJGeFFQ8keRacN1lNqmkNpFF9NEvJoVe1Ud8NpeG9YCE2qpigQYawuPBRx59TAZJJptnxhErMddySy52BkP/nDcTgzPPsxXKvzTNGNMLVoxiEwTcBKQWkbWsWco3fCCTcOzABjWkKgfj+QEObnADHOCgBxzsgQY12APldPCDH5TOD3IgGBSiMAgszEEOtmOGM9hgFuqYBz/+obt5BOtwB1pcD2/oj2X9Qx//wIc8ptGKSmACE6LoBOdY4okKdWslnuiEhlwyE0h4CIGW6sMe2PGT/3b95BwsOoePjoJGGM1ujeZQY1DMYY96xPEd7FBHPGghJDasAQiBecLxlOcWQDLJbGCSXpgWg0gtPIlJgHxL9zgInriFb3zAOR/L1McSUbTvfbXIRS/od7Ob4QxnxjjGbKSBymlQA5X/60UsUAGKTcRyapaAxCJumQgFMnAPeyCTHdSABjOEr4LR2eAIQWiqEZbHhCj0gQufyUIWlmExaFCDDQQxDXksS3f3CJA+9OGPAxHxH8764Q3/EURykrMe8UBiJUaxLZSIwhOaKMkUqWjFDV1GElr8UE4s1Y52tCugAkXdGdH4otS1kXXtEmM5XtQie8yxHuBQxzUqUYY95P9hDWj4kl0aKUi1FIGQViopIrOgyLkwiWFueWQIlyPJNFCyD4BA30s8wQlQnGIV7oMT/HbRi18IdZSkXEYzYhMNVCo1GssQxi5iASFPREhqtOznLRVoKT70kmsmC18wK4iD64h1rHJ7jtvM6py/tNCF0VwMMNeghvWkQh3axAc+vjlOdRLRnD10Vjp7WI91qGMatqhEKjZyClOIgkIlCQUU8wmTy1jmcwjMWn/c0Q6DCJSgLXpoQw0q0DCKMY0+Kmg6BGrXerDjHOD4BjD0oIc94IGjWfDBH1kKF7dkzJAlLWn1mLRIJbkUPNdBg0zvQD6arqxlOA3JZmKGi1zsAqj/vxjlMa67DKM+A6lKlUY0mtHUXdTCFapgU4Ri+SgtbrGygeiNVrn2S46GLw1pGE9HsSA9sroqbtTRL3auEM1oBmY7XkVDrcoADXncY1l4VSc5v8nXH/71QP94hzjiUQ1dpCIVHfmISE4BYm2dZIpXvIyJt5hLY7kjQARtB0JavB+DnOgd7ZhxOxZSkBYHVLMtlkg+0gEOcWCjErB9zC8DQwUqNLItyVNLX0glvd5aqXpRYqRIJdZB4mbBuG24w2/MNxlH3DSnpdjMKmQRJ1zUKaikxG4zmrHdZ8j5zdm97jB+kYtaxIIVbboWKDzxKEpYopYoPsSk3MtLXgoHD4xe/3Qc2gDpNqghDZKedBrc6tVDcoc7AQ4CYHwQBEQypgNy/UY8wnm4VBvOnBM+ELDooY5tZCQVrUgFtj4B4hBb7iT01OcWLUssgajWxf1ZyEKMBQ+KEGghBAoQRS47rMsapEATAbI3mFGGInPNDFlIgxaUjNslxeXJhiw3yai8yIepVAkdXMJyxLNlSiOXD3g433JfYglOhMLMn0GznHhR3ZwdI7tvpvMylGGMYghjqMLoRZ5lwYqNeMSxBMQEhzJBaEbk5hGLUEQirpbLBP6zUoAo+aX6EBxGD6cNcfhaGsK3aTOwcDGe7k74TMYBUpdBGdpEEF7xqup8sPqvz0YnPf/kIQ9m1NrWis2103M9EpNQ0SX8/FCygIWPe+gQ2QTierMhosOvK8TYABI7tfnBWmukwgZC4ipj2PBt5OEWSkogafQKWW50x0XcTYpLD5YA+PAgB7/ia4McVJ6Hmt7bMp7QjNA8Axo5DYMY2DVqwcGLcGMIY+E5wxmdcAHVDisWJBL6M0umtsQlDhpSlNCiIxzxoVteTeSBqD0Dtcro9zrGMSaToKi5vRj54pwDKrDBJrxxj394cyBmn0fYKfJNe9hVcX0N4j2OzowNw1IzTz9FmaGOOan3+jKGKxDuUh2sZAPr6/OII4GC+E2zCztABgKHN6ChBx/AtwzbYQNKwQD/bm7BZOImJVTiF1LWW1amgHEBeIDXKWkgSWxgeMh1eOczGZVhGTnFfaugCj1lMzuDDJZ3edmFcJsnVHZ2J+LFCg+yEddiEtjSWKZXQJuQCY+yeq7HCB8Ce7IHclpje7+xS7/RS7zXe8FETcJnBw9AfDFQBslAD/jQfhLlfFM4hUgnD2FHIPRAD9QWTkFkV0cXD9DQCtayb93XfYyFIZ+gIcmCTq3mc99kOOA0ENxEh/dgD7pjD1F4h3goURIVRPyAD3dkAz4gW44RBy+HBorUSEWwbiI1UmZzgIPxF9HjR0l2PE/yUUvyd4AHBVAweFtmXBLYE/WGchdYGZaQCd8i/yGNV2Y85W83gwzN4Ayz0QzMcHDXhYvHMAzB8AtORV4SN3ogURKl92exJDWckG+QYgmXACmP4IzOmIO8kUCF0BuC4F63J1sOBF/yhQbyBVdqAB92IEx3IAij0A1PGETp6IV2xY7tmHVaCI91eH3x4A3fkA3HYApm+H0f5n1RJwreogka0lfrVE4U5mCuBk7+oA/uyI57mId9SId9aA/pSA/bUAk2QAMPFAdu8AXGpYhKMheBJFKQGImTaEjqtoBx0T0N6G6tgl/RE4r0JYrkw0C1V3uGFgiJ4AjLqAmZYQqsEAu4kDPL4AzgtQy5iAzIoIs40wu0wILXImKhUBKZQ/96m3CMmICMmJAJMkEJXemVzuhxk4I15mKNgvCDuIcyD6RHxbGW33gGaGADQQBXsAUM8gCPdwmP8hAP4uAN3KAN1lAN0wANzJAMxQAMujALiblhqTAKlVAJgqAH1pgJ33ctZ/hh4fePGaIJY5dX52SQFPYseKU7DGlXzkcPpqmFuoOXE+kP9xAP2BYDMuA1cRAHb9CR3qZSTdYwj8hbVwImohYljWhl3QM3YwWTyCFMa9A1j8FoKFNThYAIlSEJL/EJoGAKquAKtWAnucidSzkMvKBnDyJ62iIhUkmMf8YJnpAJnMAJ69meNsh6lvCMViOWh1ZyZWlyvyGEvrQpbGD/B8oZQb0XBDmwBrykB5UwC7aQmLOwdI3pmI8JW7BVBmUQBHdzNzFAahdqoXczoWXgCJ9QCm0icaeACvvIWNyihp3gDepADuegOM7ycxDmas0mkTVqD3Z5l6qJmtzkD0Y0MGUQAypwB4/2Bm5QBdFziYvYZHUHPVHmm4ZEZZb4UQpInKZinKDoBS+3BsLjS8jlnIa2MtI5ZprRgbEgC7zAZt25i7cQC7FAXizoETDoWCEBCuaZnuy5nu5Zg6vXlYM2nxwnlh53n/h5e7+RKRDkn4haaXYwc3sQW3pQoRtqoTmAN+3RHgNKqXdzAzmwHjEQBJrwCq7gCrFgC7QgC6cq/wsg1mct6BHgh4b3NAvb0A3gIHTipA92GEfPVizNRoW9uoejqXVT2If1UETxQA2CYAMYKmlfAICkggZPMnfjNioWgzEXkzHBCVxTKjJ90YCd2ClZuimQhlzIZT72Zmhochnfcglr0oqfEQs/1Qv5s4u8AHEruBGihy0pYZWiUHpWGUvs6Si0tHrN6KeP4HG3ZLAfxxuAUJbWWKj0dqhcunsmYwc+EExqAFt7cAYIAwIqAAIfWyuduh4yIKmTWnw2YAamkJTIgGfIMAxyQgyyYAeWcC0iigrgp2sVYk+fYAPA4A31cQ7idH1aiCxepxC9SoU2modI+w7F6gucqgIcAP+OligFVZAG0KokVlat1KoFFWMxXZuSdZFkBdg8UoAcnvitXrCl/dlljGY+gJA1CIQmkDCdLuEy38eBrCCq73oLt1ALp+oKqHASbYKvIVoKxbiKmCAhABuwAjtofSqfCdtxVeNxZckbDusbJaefwpEp8LV7a+BW2aYHbCAHKpABD5ABHJABp6u6HdABq5sBHUArKuABrtuxHRukdsAKuzAMkfmyTqMKoMABimCd14IKi8WP/ZgtU9kBegAN3TAOyfYP9nB0V7h1KrZsDqG924u0OtQQ7OB87PAOgPgNmLAeCQMflggFUvCs65Y86dakWZAxXTslXasFXxCceiGlc0H/KtcxrWbrrd+aBsaxpV02k+Z6rowwLsvICHX7CYt1Cpr0IHrrCisonqaQnqLQZ+a1WKNHjJuQU1RVQIA2sIO2ROqVgyyTwpVlaA2bn/rZQJkiB22we45hBjugBgMaBF4wBiDwAAwAxEHcAA9AxEX8ABMwAatLxGfRAAyghCqgB5swQLGwC7kwqnpwTbMURd73dJd5mcgbtZVwDeLADjcEdlNYD8SCEMa2vW2sQ3HkvWDnEFPIDtDyDPkXtQ9gMl0ABlVAJVTGSATYiM5Tv107rfb7Bfibv2MbJU0gVhmzBBy0BGj7HfNVwHKwKRWoMjkhCB9HGTvJMjdVnRZyrxQs/3qNlUkgEaKkBxIskbjpiQlTY5WApkWrF8uaIGit9wiJoAiMoBtWcwiCEMyYq7n0BrFkMsOJKiS/lAUYxEI10AMZwAAHQM3VbM3WrADZrM3ZfAAKAMRnUQkryAq1oGeiCgpKNDWaUGanGnGVaZk7xQHsQQvx8IQFeU5/yDjrSJoSgU79vCzqyI73oJetoAeAgAVQUANfkAbwQV9kk4lWVmVNYGV/5EcA6EfYyshMYoBSAAWcKMmdiLZVgAVNUAVu4AYGLAd04Ad+UAiHgAgfh4GQsIzpuiYlEaIgxhme8QodsW+lwAkmwQmHixInsW+awJ7FiIygQAlWGcsgnG+UoP8IlLCVGPfLjOBxvawIWU0poiMI1Dg6KAfWjbZy4dqf/WkyHEVfMgcCsJsBFQDEDQDXcP0ADuAARFwBFaDEbM0BOZAICSsIjiqOORCZeyAIj2AKxJANzkALh1UKVfTAyFsKZ6aEbJcMdhlOA5mO+dyj+8zZWaeaWqiX1PCYdvAGCO0GCw0fZuDHUpqSjIStcVGJ+evadkEFTwbSXsCJAewFFaMFb9ATv30HKm0uNxGm4yLTJqYmNR2i+cgZQqNYpteel+AIgKAJy8gHjLCu1Q2wOFVxlOAJlhDL6omMgsaMmSAJG2ewWa3elGIuWWMuXw3WeeC2eCAHXmN4MwxpZf3/cmGyBkEgA6+Lum4t10ZM4EV8ukR84B1wFgvO4Asuu4KQC9nwDdEAIacQCp3wjx/WGbxwFuuBTfRwDxKxjroD0AFdh1lnhSmOdPHA4i0eD9ugCxmFB1JgBDOg0Kktv8Yztq0NXJZI0VFyia+NF0nWBJzoKZ7YrWgLBRXzBXEgHPVd3+bzB9B5E7f0enSL3GryCSfRwTgNIVAjaBjnCZdwCJAwGSrjIYlg5sgIy4pANbSElXmqlawnCecNluqt1e+NCKFjLiUH1n2QB4FO30/+NWW9KS/nKjmwqaabAR5w4KirxEacujmXMA6u4A3O4Ep4FgoeA5UQDd+wDcNQoqXw/9jtygvEoAJmkHM2UAnbgHSgbYXxsOLxwCPqIA7d8JeBCQ2DmQzJcJiIyaAbNgoO6piRKQhkQgM1HibwET1TctEKiK1i6+OxDeSM7EfZ6kccTcln29GUXAVf0LVu0BMUiFxm0tJVPrfTmeUus+VSmY8gdryH+92JABOOwAcqswc1FQg5eAN8kAmPQAmJwAeLIGhUk3ru2Z6WUOcLf+d47nFULjqjY3InF+heQ+hgI1P9SV/35R5rkAMg8LohH7uu67oMTvKuO7u1Yqm3AlvWOCnofJ205guCMgx12kSa0Yq4kJR5AAQ+HM+jkAy6oKAN6qDWKKEW2qkIg+lLz+BsJ/8kWdADMlAD0TOhf9EEUKBuH6W/1i7tXH8XlRjkQR4lVUD2ZW/2327SJn1pZkBp9d1oiacyxG3lWqTuJvYSTuTKNp+83ocJKrwygTA8Br2pJrMIjnAImgAIXvZxLfMSMNGeeYpxgyYJBjufeO7SfC7xfg7oeaCNtClpadB7aw98QLAGPwAEMhADIECy7mEGdqAH954IgiZLxts+ruBvdhJwAreySTmLsrgMAAQhpRCQGygLPEMMNbABDNAAGXAGMaAHC/7DQUzEQUz91W/91w/XQWwDZ6AGP8ACPTADLED1f/EDHOQw+Qv2Qf4w1r6/6F/t357I8Q//X+AGb2D/b0D/X2rQtowG6PZ2E7EHEI4gQZJ0yeDBS5o0ddLkyaFDUKFElQoFShQoT5oO7bFz5QYWGSpUxLhxBZCZPpDw2NkTaFGiS5YSZtKUyRImTpwy7dxJ6dHPn4qEKkJUFNGhQoEALe3TNA8eqHjuxGmjxmqbNGa0bv2xZs0dPKVkyeLFK9iwYcTUEkPWtq0zZ26RxUXWbNmyZnmbwb27F27eZcd6ocLk6ZOnUqVWvRrmjBesDRMaNHCDpEGGBg80M+DcmbMC0Ao8MwhNOrSCAwdIfwbN4EYMGjNmsJjR48rt2z969FCi5InvJ7+DDw8OnHhwKsmVJz++3DkVMFXYTKeeJs30/zbZ28hRs/1OHqdN+wQ6tGgRI0fpJa0viFDh+4fxJ1YUVZ+Tp0A3cNyQkUEGCw/8WwGHNCRRA6xDyhsIkksosYSTm3DSiSdJfALqkaGMOiqpQJQS76mopsIqDauyykKrLLLAAgs00AjCE7XkkhGZu2qkscYa46oxL770ciaaaJyxC5lgVHFIk1JMWQWXtmBZZQLN8jjENAUaqOABBjLTbEsuNWtgtNFOAy21A0RboYYZTGBhzRt8cNOHFZfo4QnnkKNiOCWKKIJO5YiDjorefLuTTzDAgK7Q5Ar9QjrqsksjOzkilTSOOyrFQzxA+gCEvPPSU089hBKCLz5PQAGllP/6LpIoIk0CwUEGD0ICwb8OPJDjhxPxUCMQPBxZxBJHLGHEEk90kjCnCS2hxEIMhULEkaKQCqSQQjJ1Kiqp4lAjKxLTSDHFK374QSs27lhjlRnTbeuuY9o9Bkd3ccTRLr30QoYXVDzZRMlXiHGGGCdvMMMSSDLoLLMVVhApBhtiUFgkiEHwYOKJO8jgYowzzuCBDGqNtQcjQg65hx3cvC3OJe4UdFA+B4UuUD6Pk3lm5xT9orrrsGJDOznA2oMPoAFJ8BDyODVvEQ2LYoRBgxb65GmHng5FovpQrdoUU0455RMfRMoABBpkAKIHHFi4gY0b7LhBDT4OSQSSQxhZ5BL/TDa56b4Jk1X2QkXSMwqpTTu8Vqqp4qCqqhLNQEPFH1jMAQ2tBMEFLcrRImaYYDLXfPPM0fqlcmGEGcYY0o1x911lTL/rF1X2VSUWuGAh5ZNQTrHkhg44+JKBB2QAQYWGX5NBhochNl4FECSmuAPmPWC+1g5AkKGHJapfwogexPUBNyyygAKK4Zijk84wwrgTOj+ZY9nOlg09P1EwxBDDjeuo27mN+yUFC+igyRv6EESYRyBIixYA5yaqTnTiE6KI2tSolpjEYA1rp1BFKTShAg9gCQceAAEOvGAxGVyha4GABCDmtghHLO0Ry9rEfYqVk0xQYieS+IlP+gataClF/ymZAlGIDrct66CIcT8AgsCCEAQ1mAJzlfMc55x4liVSLnSjG93pjqGMZDBjGar7hStSkYpaAGkVojhFq04CghWA4AGZedVIcmCD4cVRBjfgTxxjcMcYyNFhK5BBHodnghXE5nojyx4WGrciKSRSCtUbn6DIZ75Euew5LVtO/MSAqPbJ7w1s8MoaqGMHNtjBDpW6wx5+ZinxdIhobivPIlpJNFUugkGjMozUJALBJEnQFKo4xUTUIL0MaKACDfDACligAhbIYAc3uAPRlsYIaCrLQZvIBAx3YglJWAKbfMPhhpbCFBCRUkTbalGLUrQicd0gBzcQFxpywAdZDOMXn/+j4jw594vN4TNz8/yc6KhoutMZIxnKSN27ljEMW7SiFv9CRSlOcQc0sAgNNGDeAyrwB5HEkY4b5WhH6UgDGmwUpHUk3gxooIMaiGw3hRTXipqgSEb6iZJ9kulMI1mo+OFUOYWSnxs46clQglKcPuMf0PDQszx0KBABdJsrExSIpmxKIKJySChqSbtbTmQiulzFKbDGCTUywARWagDzkjmDHcShD0QDhCcscR5tRohC2mQPDYfirGhVSzzXukOkslOiNCzunOgUVw7WmYOu5CAIm+DFLug5Onvuk5+Tpew8QycMY1TxdATFojKW4Vm8TLEWWVvFHP4ghzkYYQU60Mz/GOZgguHtJ6QgpW1s4jiDG8hGjnLEwatWMAMc1GClJNvBDsSFBOQioQlNyMIiqwe+5rBsfTTbKU6ta0n5zc8Nb8DfdET53VGCBQ+mxAP/muIH9PphrQk6miuttamBOAgnpYqa1LRqNV2iQhVZK8UeVnOAzWiABThAKxbagIc2yAAmcmPET7T5iGzStYY2vOtRkKLXS/XhKX2NFM4CG1EsAEHEIzZsDoDwuCsEoQysKEs/5VlZGFP2ssUoXY0HylkcK+MZzWCGMmaBClSY4g9zCIMRwlADEFSgDYb4TzJ729sdkO3JvaUjlW9A29zKYAYyCCmXcQAEGtSgBlAurnGT/4tc5mbhCddbAp6MM7PfvJmSiKpudu08P+rcYZSiFOd4gRYIPtyBDx6iwx+qpdREJGJoSSlEIuCKiWpyYhObqK99JSIRXbJCFagw1SMycIABKCBACtBAgECwAxDM4A6F4MPRBlJDS6yQWRcKiiISUYgEUYsp2OprdthgnXIubkUhFvFuTmzYE//ATTZ4BC520Qt6xlja/LysMYpB49IlQ9s3xvEznqHjXoxiFEI2rRKQ0EdAMOIHw1MBGmKABh8oOwf7wcEOQlpvNwXBDFdQHBrWMMpBH41FPyhzydwkLpCFDLlXyIISnguFJQSqNzRL33PcB7+c3nl+afDkUEnp5/+gXQoQd8jCGwrRB1xb2DwJSvTRGhwhTNSthfHBakSmJgpTiJsV+pWIJ/DAgDJ5YDIMCBCXO3ipQZuQYLFeIVDuyjdbV0vX1uK1HPAHbMGqaMQjXumxTTzvktnABqi4hWPR0gu0p52yaYf2PH3hC2AAQxjFmDu2t43FgfaYGcyAxjOgsY1npGITqfhDHpCwgzQcohSQMINi16AHlgy6PEuzRDU9EYqs6XcVrHjFWHBRlrSwhRiywAO/zWBw3CA3T3pCsxQmHmffwCxmy0HOxauLcUWBwQ27570b/N2G8BLOUuUNTx96oIAABEABNZCDoanl1Ja7MimCoL4e9CCIStT/zYUNjIgobu59VWz6Ip64hAyqVJpU10oGaQDPz1wCiUU8ItGJFkqtFdGsqEsdqnwIUaWs/mtz+hat27qxwYHsMSw6AjsciAEQAARZcCzMQru3m8AJRLtckMBemMC4i7tr68Bi2La8Ywa/g4ZqqAZviIdvYIZUGIWu2ANGOAVewIXNe4XOkwVcuMHPKwsdLAvOqRwoohy4cIZS8IEdsAEVKAIdSEIdKIIkWD09YUIncILfKAJHUgIpnAIsnIIoBI46sRNE2YIu6IItcIIt2IIz6IIzSMMzsIoDkQPD6Rk5wAM6iBQ57AP0KoTCKwAA2MM9DAAHMAI/QCFIcDo8NLfr/zPCkbCBPSAWi5iIUuAlrTmFVZjEVTAFq6kPUOAEoFONLKmSBkAjHVA1VhOE+UsEoViEuypFU7yragEE/tkD4es1AMwCL/ie79kNORmulfqBIzoiEfoBE1CBG0AF1HkGWzhGW9AFZVxGX9CFXKAFXzhGuIu7LOI7aJiGaSjBErSGa9AGbuiGbvAGcVCHdZCHeFAHb4CGVEAFViALKOocytEcswiGHaTHJ0ILeEQLuBgGREACHYiBI1TCJXzCJEgCPUmCKDzIgnSCgkRIJ8jCKKw48YEfKgBDMSzDNLSKNWRDNYgDN5QUOghJkKSDpviDP2gAPkzJCCABEyiES4CEav/5mUKggjDQgTOwAQ7ISQ5gmDsqBE4gI4c6hcSIRK2ZGlMxlWJRg9KYDA14AJDSgTRYikQAhFIkxVQcilW8tUYrBEHoEFc0KlL6vw9jAy8oy1ykHl2sASRQNh8wrCCAExAwgRsQhGHwu2kIQWjIy2y0BmyQBmmghmSYhWegBmuAhm44x3uYh3tYTHkwx3NUB8iEzHK8B3qYB3HwBnScBszpnM7hwSeaR3kETc2JrB+ci1MwAySgARWQAYFUwoNkyNeEwiiczYV8yCyUGdqLpIoMwzI0w43kSKt4A8MZTjkQyeIMSZIkBCMIgJTcQwq4gA1YgTCggzsYuT0ABB+YASn/uIIyyB0GyEmcZIABOAA0CoROoAiqCYUIQspJozRP4APxRA3NwIwZYIM+iINASDTycDSnahb6E4qspBYBVSql4L+w/L9fc4MvWJQmSC4paNAzW0u2VCw4SSOxm4V4yNBvUAd5mId60Ad9yId7kAdu8AZvyIZZSAZr6IZquAZ2wAd94AcZ9Qd9oAd5WId1iMzIxNHFvAd0FMduOIse7IUnoscd9EwnIk3KQQZiOIQsKIIZSJiB1JMkVMjXnE3bhMgozEIsnK7nWI7eLEM0VMPftIrtMpw3eINIQU427YM/WIDkS0kDoIAFiIAPmAGSHK9RSkOx44DOyMkOALUBGNTx/6yAL3CETHgI72tPRs0JT7ADzRimpnwAZiqclWC5ZzoPVLQ1AF1FW5u///FK/hM+v2ID3luURKqCB1Wu5GoCQ3oTN8GC3xE7PaCGeLhRdngHd4AHXk2HdhgHcABHYNCFa/AGbaiGdcgHeJBRfsiHfKiHeWCHdWAHclCHcSTHxlzMdRgHcQBHb8AFfIIxtkO7X+AFtfuFcc2nYbgstDAGZHAFfaOBhFkBKyVIJFzCh4zChrTN2eRSLuCCQZm4L1WOMA1DMs1INtyuNE1TSVlT5OyDMCiA5ItTAoAAB/gAEiABI4jDNQiCNVgJsesAz8hJBki+AqiABDCAATCAMnkAKf+4BPLLBFCQOVL5BEdQIxBogA2QASn4AakoL5VoJVmCBLnZ1Ku8K1sLVVEFmg3zK4VV0CpYUFVdLghtUCy4DVjtgJFQsVa4VQ9V1nOAB2XlBm4AB3GAhlmYBm/ghmkAh3kI0Xz4B32oB7plh3EIh3WYhxvF0caUh8QMB3AIB3EAB3CQJ3KNNmlrO346V80BHcw6hmF4BB8gsDQxASZsSCtNwiTAwoc0yCLI183lUiwE2Oj6UjAoWDE42DJNUzRV04ZlUz+YgQGY2OSDAAqggA+QABfwAjnIgw6gVCzBSdVQDZ2c3QD4gAVYAAdYgEFNvgF4gDe4hJ1wCEmbr8sLhTb/sBiJcYMfuAM2yAGiOQ+X8BVNNVqk7dRPVTRY8sql4IM+gIpec10FXVCpTSQIVa4mwI03iR6GKQM9gAa/zYdmhYd6QAduqIYSrYZZgAZrbdHFrAca9Yd+oFt7iFYcZQe9xVENxlHABVyypZzMYqJpmzYmopx2cYUy8IErWwETMAEl8NyG9Fwo5Fx9dcgtxdItpa4+SRTUPVjgXFggHsk19QMTKIABEAACCAAEuF0MwIAPIALXqgETCFQGyB0yIV4OOAAACIAEcIAAmN0CUF6VTb4yyQA5cIRLwJv7aERNuDKT2gE1uE6hcQn5QyFogiZH8NTzNcVEI8WnItBNoTrC/5GUNzjVQq6CqV2uFREhNzGsjhG7MrCBVIgHerAHfKBMelCHalDbbQCGZODQY81WxcQHfJgHe+jRxaxMutXbGyVHcgDWcIjlcLCi0vEcfrJlGBOGybJlJiIGTLCBksABFnZhgsRcG9ZCHE7mZIaz3ISOHiZT4OQ9IN6uNf3IPmCBlDWABBCACMAAEWhiEoBitNRaFfBTUMNiBtjDApAAABAABxhUIzaA5Z3dQT2ABjABOpAEhcgJq2GENLA3FRC0QGAEt5E1n4AEgom/813oRBAEt1HfP/ZK8YCK4owUNS3kQl4UVU0kFWHktswBDoieHLA+PXgGeaAHG9VQasCGFP8Ehm/I0Gq4VXq41ZPO5Jru0Xl4B33AB3toZXV4ZXLYVsAFhwvMBaNGxltIaqWuhVuoBadmaqXOBaW+BaPOhbbAx7OQhTMIgno7LiR4YYcsyM9dSC0U69pkyLO2YTrBJPV5Aj15AkMR0zAcUx82UyBmWItm3eI0gQQogAIgAAGggAi4gAuQgAt4gVxEZB/4XUI9gDvigAHY4gtIgAGQgHc2gSpwgJStAwkYACP26wJQABCgg08gBYqoD0w4g+ssBEpoMAyhhE8FCkZIhNnGv07V40R7aPX1Hw/xoUkp5N77Ai2w3ybYHqwtLoLDAq2I5DKoBGi4hhLExr+UhmfQhWn/yFBraNFrYNFuuIYSFQdxIAdT9gfyfgd2wGAbxdFonYdoZYfGXNxe2AWj3gX6lm+lpu+qrmpktIVcqO92wUez4AQiLBlDQq7LrWGxls18VWaERGbbbJnaCw4k3BNAsci5XsMyZcMgloO7dkOPpIMaWN4EGPEPeM4LcIANMIEa8IIlqEnhNV4GuCPjFWMLaIAE2IAFaIDk1d0AMGJCNYACsGcToAJEOE8GAlBLwANAsCEHsQRFsJD6czqsNEX7+9SXUFoPeV+KnkM3XNjdW9DhloIU0QqsbRw0ILgdMINI1oO07csd80toAIZnyNBrmAZr4Mu+pAZo0AY+x8yTxgfy/66Hd2DveRDqeSAHcpDWyFzXdd2ctHu2R69v+h7XZ/OF+G6X0IlvrT6peEMsH0CCA99Xg1zCBueCZMbCBt/SLmUOQTGU1QOOz5VrNFQDhOXINKVmi949j2xYN+iBGdCABnAAFECBD/iAFP8tN5CCmowBoKvn3EE+ABiAMTBi5XUBFuBrzeYByj5iARCAL15ZA2BZBliBO7iEU+AESSiKpmjoR1CWRGi6oKA124a6U0zfW6M+Qdg1qEDOSIkDL59fLdCCLEjDfRs2LMhFJDgRFa6EZsgGbLALZ5CGZCgGbODLlaaGvwSSHYsG6p4GbfDze7CH8+bbdSCHcEB0awXHbv/ghhq7LMxyeXTthdCxLArcQGAohrgjqIkXhmAwhUAqAiTYjxy4giZQcFVHa1VH5rO+4YfkgimgKTvJk5h5AjK0cAwv0zSUZteVA11/3S/IA0RoBDcwgRkwgrKvAkDRgSb4AhqIgQe44p2E7C8OAHlWgEFNAA1YXgNAgQj4dngGY5UN8gQokw4oBJpwBDo4uURwkPvDBIOesGWRd76J903Nba4UBL3ScvGYQ3+fZoAneIb7FiJSVSSQAsiJAVS46l8QEiz6QGVoBmXwhV9wtl8w6ljIBV9IhufGTHUodBwdBw0OB2q9THDUBmvgLG2rMWvrQIHyQBBUhr0TwbyEhjv/t4ZpkAZnEIQjNLf9+AGiP/B+dXAs5dylD38shHDkiLM/oQIxkHUx0EjVPYMveFpq3j3hHGKqXAQkWTwg8ANHMDmAkENHjiMbMR4oYHCAQxk9HAYMCABgYgAHGxYMKJBAAYsAAQxAVLAgQIEKCzQqUKDxgIIHIIr4QcRoEU1JljBRskRp56OdPh8BDQpUEVGiQRcpSqT0ENNChQBB9SO1z0A5ca7GefPGzZcvasxkCYsGTRY0P66YxYIGCw0fl2S9wjVsWTFlupI9E6aKFSpTe1m5UuXKFa1k0rZ9iydPsTx14tSRIzePnDhv2rBhZqZ587Nn0D5LkzZtGjVr1jBr/9vmLTFjeq5dy1v8TZmNFUWKGOnxA0sTJEl+J3EifIqT306ID5+C/Lhy5cyJU4kuPboSJU/AgKECRsyWLV2+dzmj5ox4NebNf3Gztat6N+7fCPRTKFEmT55W8cK1ShauS5ocxfSIIAcxUKANguhxAEQeTQSARwlQYIABL0Q0gAIDHNCAggtUcEABCmw0gAEFQFSAAQuY0McijjCiCSeWwPhTTj5RIpRQigy1CFBIKdUjIogc4lQhUvnRB1V0VCWHVVu5oUYaYI1FlhlX+DDlDlnsoEIHgJTCSjDDCKMMM88UswwttdTCiiprytJmYK34wkw1iS0Wm2PikLPOOo15s/8NNtIw442g33yjTjzxqGPooYsyFlts9NxzDz74+FOpP/hEGg82o3SgQhE6GAEEFj8g4VsStwVXHHDCsdqcq8px4Wpx001n3RPSbdedd92R1yt557nnXlfDphdfIYtggokoq+BCDDLIEBPMKp58IkkmmVRyUAMMcCAIgg8FUKGDEk00wAYKhIvuAApllICCByQgYQHzDiDAvCYy4EEfl/CrybU3YQJwTjrVGFTBQum4Y1KJEPXjj0EOOZWRE1eVVbDEPhlEGRrngMOUHXSqCCpgJjMmmcDY4gp/ganSpiyssBKLLclMw42hia5z5zjrsLOOONpY88wslThadJ2OMsr/qDzz1GMpP09fiik98UxjQ6dK4KbbDjs0caoORQRnnHGsPvcqF7E2Vxx2VDxx69rThYGdFuBtocUZZpyRxlfnqfHGF1qkt156cdAhHyKPgAKKKq/w8iwy+clSCiecHC6IChw88IANlQhSSSVnqHChR6NLRDqGAbAEkYLhlkhivQHYay+GG2mwwiGa4I4JJ5tgwjuMycZIY40H28iIIo444vCPhSASMZFEUhXHkm+oEawbT4oXRA45VOkDyB3YUcsxvtwFzTPJ+JLLLsMMExjMssSCSy20zAzNNd4guqc84oADzjj7d0MausgWB15jwAMabTGLogel/FEPfbSDMuKI/82hdGEDG9AACbnpAQdJJZzfgO04wAlOc0i4HCeI4WzNOZvbwBAGKoQhDNaBYQxfaL00oMEMT8LhWNawBja0xw1d+IIYhOiGOBjOEZfghCha5ixo4UIWqxBFJiCBCEDoQUsP4IDnKjEKz22iDBxYXbgY1KDRiS5DqivAAQwQrwSIyI0FOImEPJQhFvyhE5+Y3ChGEQpPJIsTmbhEJjhBvEcgxRGQWKQjaLIi5TVPSFLBQxzw0AepYCUOXTgiG3gYpSddIZQ+uIIZVBCDM+ihF82QRjFmIQ1oJKMZxhBGL47Ri17s4hfDEN8vhCEMZkgDG4l5TaTu8Rp1PCMVgrCaB/8UaCdEMYpQ39jGNayRjWz4iR6WwpQ1oKGZakwDGsuoRA5uoIImLIGDHMQCFkY4thGW7VWwctXZuDCdtt1KCTSsYRgw9sk0+DCgawiWGApaRDFU0nDWAoUpWCEXaA0DLqsohSYW4Qc87CEGWrJBH0eRij5WQg9lUAFCFjQ6B1EkIgFgwIUwdAAPuXFEJoqABRYgoZvGVAEV8IMnQgGKPupOkJTIBO54whOgQAJ5SkXEUh0mJKcUCQ9SjSolv1PJO9iBDZ1Mw5PC4tWwrOAHPtBDJZZBDWbo4hnU6EwzlrEMZxxjGHHNpVxrmQxsUGMb8TggPRozjQEaBAQe0IAwAdX/GWYkQxnKMIYxilEMYPjCFrOwhS18UQx1WKqvyQAGMHShWGOowgY5mIEK0tnBH+wGbKlSFWvjCSu0yfNs97wVFfTJzxj+TQtaGEtZ0qBVNgiUiAYtqBsQikTmKZGJi5MFL/LzilWs4hShkMRTBFEGjeohFa1IBXdTEVKDmPIB7BqdSiMCgNRhCENsVIAbIbIACkRgRAaQAHsl1IAGJKABOuhDIjYxioDdxHcEs9EjktrUHyHPqU+NWB/wMJWLatKSeMCqHNpgYR06ias4lMENfKAGPdDimtSYhjTa2lZnOIN9v/gSi+NqjGcE0xuvWRQ2gPFdg8TgBjnQRYlp4WMf/9/iFj6uxS1qMYtWzIJ+tiiGOOxxqb4i1hi9cOswKmGQFaxAnbph5w/GxqrVunaFr6UnF7Czthra9ra5/QIPNczVgKLhC98xqHu6YFwHMw8RluipX1bBilWo4hTSpS4g4lCGM/igEkf2onZDWgYcgwwh8yIJ7Eh0AIUAQHUufSkcDRABB8TrRDWVUAJW4IAKpCQhNsCR73oHvJ8AhRJKnXXyEgzJ5UH1eZi8SoPvcAclWVgNV2mDGohthhyI1gx2qIQztrENaSS2Gc1wxjKOcQxnIONLzJULL4Yxy8NAMx7bYEYqyoDsIGDVDFbTZTaEQeRd4CLeaMJFfmoRC/7gIv8YxhAHO/xhD3p84xnGIAYuoCWLO+BgBjMwAQd3sBt2YkG1yZEnxaeANhWusMxm5qd1Yhgd3OqWzWPhKhrcvAY0aME7djboyouY0D4EYhGMgIQmQFEKQZ+iFKHghCQSAYhHc7QYrYgBQ0axCc5dF2Qc6ADmOtAAes0rIQWgCOteqqAB3HcBCYiXBhzgADdeQAMN6BBLGGBKG+yhEptY+9qTFbDhUUIScp87rXGtvAVLMqpx6EMefG2HvwPeDnxTdzl/oIYyqCIazwBGYt26DGQ8HsXN7XZzcfGLXPzixdboxrNnoQeQySEPeUhDDDqQuWH84hjRgFwU2/SK10c3FKH/EPQrZsENSuFDHt+wBecAwYhA7OEGCq+BCZawBIizswmoSoLFMV7x1zq/+VwYrhj4eSuPU6EKYdCtbtv8T+CmQc5zZjl4NnmVNLThDnvgQyAOoaOcYKKQlyiEINTgg81J1gYk7YAN9LAHPYiUQShdF9BAAyiAh7ARRAwAShUA6rzUACSASYCaAYzdBExAAqCIScARhjyAlixdGShC223C7rjdjMwd3TnCCTqCU9ya3UHVkEjVhPnaHUiV3wmeeaBBDNiADAABDgnCLwgdNTRDMRjDMVRbMFzbMSBDvDUXvsmVMohGMmyCDXBABpjAGBABC2RABogXA6xdIjAOHthB/xz4wA4kHAuogAl4gAVuAAiYgR5Mw9LgAz10Q2dtAgeoAAiogA4sHAh0QBOMCmr9QBMoH6pIn6zEUz0VlNmcTUFtBz/t03Rw326NHMlxlVaFH3iwXHdoons4HBaUxRr83SEkAiP0BCZcQlIEoCIc2UjNwAqATAzkAADawaPFwCmRVIGw1LssSALQS4Vg4AI0gAEogAl4ndZZQAU4QEtx4BbpQekdyCYAEgm6HYzwywlKQgrSXQu2YN41WAyC4wz+nXkYxA0AwTn6wCZMFjUAShFCnltZ2+PgQizUQrw9jhEOQysMSAeAQAYogAZUwH1tS4FkQANkjih0gkDel9c1gP8DTMACOIAF1AAbCEI13N483IM4XAM2RMMoqEDCqcAreoAHcNnWDGIVKIFxpA0iHkfZNGL0KUd2fFwNRWINrVmbbZVvYWJBtZwYdIHKjd8b3MAN4MAPoMEamAcgBMJ8MIIlcAImPAIg+ECitYIqlAEIjIES0AANlF4M2AElPZr/mR4DZE4MiBEv2tECToQAQCAcKaMDxNcCbIAESECFWAgHmN2ALF0QCAImgMJTuh2AXcs10p0Kzho3Lo9UOEUgfGMcCB5W2QFWmYcdmBIQyEEPeAEbBAEtjFg2wFLkNYO1LcMwZBt/tAmK1YIreELwzUAHsMt96WJKMIAFbIADaID/CcACKZiACWzABnzAb35ACVgACbzAHDjCKFjDOuDeZHADNFADK2BBHJiBGlwBDuDAKLETBy1B25xKCBUHTGacIr7KB4kBdhQU29wWP2mF4Ojkb2FiGvBkfNKZexTRGxylHNBgHyjlHuxBIfQEJ4SCKGyCIpRednlkA5CACbzACqTBAzQACEAoDdjAI3xeF3ZLJSiCQ1ydSqEU1VnIAkTASVAABViABLiOAuBhByzTFvGfHlACKPDOtfyLJcgoNtLaYXJj3vkBVPSaZAbeyaHBeRzlGnhBE/gAKmQDNnSDN0hDNDgpikFpNEApikUDMaiCJeCBHHjBDPTjFnppBTzA/wR4XXC+wJb2AC+8wlbSgAugAAq8AAqQAAm4AB1IwiZggzzgAz/4wzmgQzhcwzcQwx6IhxnswFSGEjsZ33Y+QWtNXHjW06MaFMahkHmWZ3rWEJMIyxe8p4b9lk/2JH3SZ0G9gW/hJx7kgX76GiDgSCaAQigkyzOWQR+pQAa0aRY2wQrMQBGsgAlAKB7oARVyAAfEQBdxzgUxgEqFiwAoqwCMiwEgAAFAyDEqILcIq0NsEUPswSPwju7MaPxlAgpiYzbWGmLqKI/W4N9N2N+5ZxyowZCmQRU0hDH4CYlFw7RRKZQiw5OimCxggh14QQ2wgAd0wBY+AMFmjtc5wAsQAf8RzEET/AAeoCkWlIoRhAERVIEJsAAREEKd3mme7mk5mIM4fEMqqEEQjEcQVCcpJV8TQMGtLEdsPWo9vUpBySxxYIelqucbwEFXYKJ7uplvtYEmElccEFdxiSqp0qAl9cEd7N3hsGooeBQqhFQfxQBWhkEV0IAcvAESEILCrQCEYpkHCsIXdY4ejG0luGaFGAABEMCyUh0Geh1IQARZcoDZXitDCMIjCJKMzui1iKtSheuB5aiQBAlU8MHfqZ8MAh4bsOuQDtThjYIypIIuUAMy2BsvSCkyDAMxOAvn4sIpLIId3AALmEAGVMDpgunpZk7mGCQRjMEYGAEStIEcLAL/mmYBG8gBHPgBFaxAE9ABU43CNtCDPujpOfQPMunB350Byo6SGYBFFhAiPq2kxUFfzMbsFNAs2gjHI8aQVqSnVuysG7inz3KqGgxXsBBt0bpHHJBqHkiVkUgVICACJXACQykOLwRDLNCCVc6AHFTBHIQeGyCBHIQklrHAC/AmCNgAJnyU55BVA69ofSUA27ItuTiI1glAuBRAgXRLGdxtGeStJ/RtJgSMjdbajSYPYioY80AMH0wYHriwOP5d44oF3qCSlc1CNOCCItgAI+DCK5gCEJ/CK+TcJ/zBDchABwyWBpgumK7uE99XGBjCHxROJ0BCIFwCMsjCIRRSJnRC/30IGirYwjcMrz7gAzhcAzdsQ7ndYBmUYVnwVhZIgRQsatoch/WqEB5zgdGmUD1tR3n+8R8XER9fDLEU8rDIJ3GNn0HZJxqwwQzqp34eQnIxFCrIwuZCnjHUAih4AlatQSCwQRv4wQzUgBG8wCmjwAe0YRlUAnf1kSsTq+UwQKgRwNqy5bJSGoYUyCkFa7D2X97+5d7CSBfzrdylYN05jODeHeEWruHygQvDMGRmKRtUgZEW6sYIQhCTpiZ4QR6twivgTieEwicYwhwQ3+lqgAZ0AEA+gAM8gOqu7n2dQnStAizYMyzEBTU4A3/wAjHkB/4igzPEwz1Uyj1wwzQEjf8eaMwZtMEVYEEV7EBOctXfPCqs9LEeT9/58rFBBfJ2UCr1gUGmEstID0v5/SRQ0s0WPMlRRuYdRPKxQMISMZQq1IKzLEMzOKmUjsIe8KUdoEEg4GrFnjITtClpqcADz4IvHNkXec4Xfd4sywuJJIADcGi4XFoZiFEvoxJ9iMLkXEsg7e1gEubfpnA3QhLhLg8gCEIg8AEgPPMzzyANaq0bOK8Z3OIMOIIofMIpkHMjTMInfIIoMMLMNcIYkEDXGeRgbSE8PzHrPkA/T14/PwvnZkM0YHIwNFcw5Ks8EPQceoP5tIINmId06kAThAEUvKeTnMEWDFcjXjRGQ2rMOmL/DZmZIFPf9Ux0VwCObnOfnHHiSX+HyulKGpDSUT4yHgBCHxSC+xGSJ3RJLPTzTYeGNFBDNBxDKmzCHuxdKS+Bwg4BD7SpC8wADbToKNxCLsyCK4OUdREITJlIApxUuTCA9/TyUe+BInhCV39rJoxgjA5SuJK1MpOrwwTJWislVLg1H8xgHiAJHTjmHhgEDbzAHxDCH0QCIdRBIxCCIWQjIeQB8WmAmBogEzN2YztoQ3Iu52J2tHDus2QDNVjbLQTDlyBDMwz0pKjDN0BDMSSCDWC1GUgBHDyBEoSBsIRfGvwkINc2IE8BFZRZa9es9TpidLzNQQGyQbFZFVTBsGiB/7BUwRyH3G+nNN1sEjtlAakqLSD4wSQvURO5Qr65lXOyIzWwYzTUgiLswQwgQRFAwRyQwRC4AA+4QA34QRnagB30JZId2SwwtUiVgR10AEyNiEmZ17osxBYdiCJgwh/xy7X0t7eOtWEicwvaGlM5TCLQ3yGsdSAEgluv3zNTBX6q3y2aAAkQwSR0giFgOCFEAoUTghzMgAe8ZaqhrhOb+Ik7QBO+guvBQpvIBS44g3W3givEwivkQjF4A2djSjxIQ2jHANG2XHaYWRdwAbmDAW2xjXS8kLpjR0U3XwplXExm7yJKORh8gXakZ/ZlXwzJZG3btriLARI0gRRs+RvQwf8lGU4jWEtPoQIr1EIw3HROQwN11zkr4LkKrMAHkMAHXEAJbIAJ3KoMqIAPqMDIt/IsMDrnPCPaEchGkAjrKOClXRoeguCqdsLkTE7beet++62oC7itlXVRoDr9qbWrP/Me2MHhPvIMKvgdvMEchEEkrAIpTIJfd8IkTMIf9AALkK4HbEA6F3vYv7OxGyTO5ZzZ35yaqIIwREMuqEJDzQIwZLuk3AO3Z0sMbHQeR/m5azkUQIGWV0F00Ba/Nx+ZwdbF4bH0PerbpGffA36/97sj+vvghwF8IIlU/IjCF1IooIIr1ELquVUzwNh0S4MzNAMxYMINdABvtgALbAALeAH/DmxlE9AAaelgKzewSOnBGTCdLj4gSwD/tZZeQwBFUOH87myrV/PtIA2mMaMwCjsMUSiFUwiCWnsLgvNn08f1DFrSG+TRJXTCKnRCI+S6EXB91389QC522Bf7E2sCJniCv2iCHokCzqlJK9ACXBVZ3IvDOjzZNwCEMRsxVLgRI4ZLQi5TFE5xOAXMEygToVShQuVJxothLj6c4sSJw4QiFzJ82JBhw4RgLlIJ85JjyyozobS0SYXlRTBicrp8+QaOHDh06PgpVAiRI0eWQJlSFetWr17GljV79kyaNGfOoiFzlcgGiBkyZNSAMqYKHTRobty4ciNGDEGgMCmqVOkM/wcOD/Y2YKCAQWAGDzrEsDFQz55Ejzg1duwYE6bGmShXvlRZUmbNmZV29owI9CNFiQolSiQIkCDVqwXxce16T2w8d/DkAXRHzqFGkyIZmtSoRwsTLEyY8KABuYYMGSo0d/78QfQHqlStWvVKlixcvLbzIhaM2LBf0aRRkwYt3Dl++OR9SzWww0GECrnM93hx5syXFzW6ZOnRo5IaCumjlOibT6GeXNoIpvwsuqkljcCYsCWYgILDDTiGIsqoQhShZJNRUGElFldo2UWYY6pqhsWqnFkmlkoEseGGOIgi4g8g8mADj0ACoUEuUEbDZJMyOuiAAySRlG4wDg6zoYwz9P8QBBNQrATlscYwqYxLyi6jbLMwPeNMqaREUwRNRVg7bTVA+ADEzddgyyOPPu4A5JJODGnEEC9cIK4445JDjrkKCn2uAukeIIZRYpBx5lFkHo1mq62qWiYaarphx5314pFGjxiOlE8hUktyyCcGYcLoCZwmPDVAkhYi0KSE5juIPlcVhIkjmBRsSYlWbYpI1TfecCNDDTekAxBEHrEkRFNEfApFFZl5xioWn1lGmFZASUQOP8aIZIk85sijETpmwMGTVwRRwQY7fIhL1CP1ko4Dw8ooQ49+K2GFFVVMCSVLTro8mEvNLtmsM4Y7ewTiNE8zjc3VfAwEzowBCYSPPQD/mW2RSXgbwwXhPAD0uEELXQ7RRKV71JlmtpKZq5qjubmZZap6pppw4OHnnnhsGUiFCkytD1dYceKV6ZYmBONUlQSMeiSGbk2aC10rXBW/MHJSMNiMJOyPV2TN1pCOL+LoA6lHiIRWRBJx+cUYZq69CppnqKEmGlwowUOOSIj6I4xJ3LgBB05OuQO+DkA4zLB699LrsH77LaOS7F5RBZVNDHYM4dAvGR1MMh0JUzOIVR8tEYlVO+2Q2C/2kQ8fN97DDDYIMWQOP4c7ubiUCWWZZUQVlbTSm5XnilKulqlUb3Xa0YeebCoh+gGzr7bvIyeeAIPplyi8KcCRqjbJwJMW/0IawafB94nXYXWyKVgl7BdWolZ53Uk+ZOHQoQlqY5uzBKEIaDVFFa4whoqsgpXylIcazojFJgSBBCr44Q2SAJIPSmGKM8RFBSbQQFtsoIYzwIdylhNEJaYEilrgQhaxYAUoNiEZg4UOh19amGZOhzpJqG51rZMYmhKxiNjJLhCHSM3F+GCHNfwhEmuQAcpYQBwPCG85y1FOFg/lMkrdjCt8k0Y0mgFG5fGtjNSIBz7Yoww9lCEGe9GQQUrFPZB8L3xeg9ATHEKgkSBEfSYJCX1Swr0JHSR+TcPJTVr1BCUUIVgRWkKwfvIGYeFEPjrQARKkkIY79AEQdtiDINzWFP9U1GIXw6BKGbOyN1c6YxeseEQZdoAIgpxhFZ4www1osILisAEHMciCGuQ1kBio8C6C2IQqcIGLWsjCFaagoee4NJlq4jATo/PhZigBxDNFLE1pOkQSj0ix2SkxD2MAwhRNsAENVNE4WFRZBrbYxQo0DxnEeNEwjtHPYYgHGcvYRS+aYQxfJMMb66BHPFIhCD2oYQc6MBuyDmIQOooEkU5jydMwohM/yqqOCEKarY62EI5OqFfxwwhHWfW9lrpKI0yzqIbE4AY6yAE3cogDHkCZxEdQwhKcAIUoUJFAWfBiGM+zCnn2ho1sSGMZo1BNB1RwBVHwAQRHSlQFetADE2T/4HFP4pcK9VAJULCiFrVwRcAGVkNsik4SXvKhZ5QSTkWcya5ETMQRBUGxRUDMNItIRCDksIau1gCe8LzioAZlKEMVz2W80A4MZSiLVzjFFJ4AxShGUYlU6CIZyZCGONQhj2nIaA9nKIMNJoqgmrpBQGKokPv4pyCQjpQ+KElaSR1ikKeJIQxP2M9N3BehluJPWEzjSU1lC4Y4yKEN0W1DHGiz00C07llVIuoqYoGLYByDKg50ZXme4YtRGGkPpniXGYoGAhqMoQZ0WAES7KDasjp0hQ6tBCq0A022hsIT1Hwrl3YoV9TR1RGr06sQw9m6RTzYNKOB2CIUwQhGBAJw/17oQQ0QW0V4gmCxjB1ecor3AM0KtRSf+AQpIvGHS0BiNZWYBTOm0Y1uxCMe4oiHLqaUWh+wVj6AtJqQE6IT2vKPJ6y6Lfdue75SNcQgKQ3uccUWoYzYL2xiu5/+hpsTnuzkDXGww5jlUGY5sOEOtTvEIhgB1E14ohSnWMVkv2sVaEhjGufJyjOEMYpl7iEGlFgBCKhAhDmMIQ8z8AOapnQXRytCD5twhTNlyDlpBjgTliBdNjfdpR1+yWE7lMSYuulNBt81nBZ28F0fzOZF8GENaQACh//kYUCBeFAdEPHwnKMJTXxCE534xCQ+EQlELKISmEhFMaRxDXGIAxzQVv9HPLZBwdjsEsimGrJID/nl3x6EJY6kVW5hBVIAkRsi71sQlavMKiwXod2OvJ+qONKqnWQIp3fQNx5mo29976F2bL6rJTQRijhbBypTUUYzoNHwvF2FGVVJhR4EvQI6vOAFf3iDDtKUilakws+OFgR/1RowVJhCmjW0hKZ1mJkvEVgSLz/YNilR81LjNZwQszAjHvFX0VCi1YsIhB3QoGFa2/rWi93ABnS96y7yphGd0EQjNEFDVcwYG9+QBz3IwY52lKMd4FDHN4AxJTWw4cc7MEhFdytSLoBvVYpkFa08QveH2H1WIOnjHRdZ5Usa1ybttrIj7W1kebsEKPmmDb//+Y2bMacZEGxaDMHhbEpWnKgYO7sK3vT2DFuMQg8aKsJ8nRAHS9zFGMloxepBjqZJ+9fSl+bE6DaNui7FdeZiQsRR/MA20RQiNYvxpoLRBFhIMEIpi8ADGoAAhB7ggAZT9KUvA3VFD4Bg6Rpwp4ifEwlCXEITj6jEKGgRjW3EY+v0uAc+5uH1dLSDHfHARiXK4EQs4OAG2aboQVJCkqXlMSZsonz6SCQAZO9AwgmSQAGTAAGdQAkWCcuEhbZYRaN+xbjGhz/E5iWCgrr8bd/8rd8Azg76pYDabBMOyClcoRZ6QUVi5s7OAxuwgW92ARTwoAuSgAZ8QJk8qxh0oRVm/2EWaGEUAIEStKMWZAgVTm5gPMFgaC9hNAOHJmPUQAM0yoQKPSQzRAOIbO7mtPCuHiERGAESji8Q2AAIfsD5cGAsWGD6AqU4QAAO4XDptq+xnOMQVGMTZuz85OEe+tAP2Ugf3gEe0mEe4qEYoEQNDCv/bCDIEOTuBokKgAsAIcQAu+cR9W4hFjAJiiABNZHvMALLHhBCqGDLLunvLomjNAJ/EA+6OtDMoEsO7OAOxmzMzsAWR6mvwPBZQqSoXuEWvqsqmCoGs0EGo6EXUAHSMIezQGsWfvDjKkERTOGFYsjSREEUQIEJNcEJZ27AEEabstCbig9ibO6nuvCnHmEMIf/h1dYAB3Dg+dRQ+kyA+twwDuHQA+aQDp8jD5kh67aOHTjlHPyhHtiIIO9hHtZh7EbBBpKgDdxRBw4jyKamaoLMayoSI4ALfN6HjyzREkuiE52gCBQwJEFiAYvAJEMyCaRAJVVSC6SgCVayCWJyJaXgCWjSJpVACqhAC2ryCXZSC8DgCzpKKDMiDN5ADtTAFcsMcBZvFu9gD8rAB8pADWJjlNKMlIgkFE7hFdLqu7hCGrKBGGWQbyhFFTxr9XQBGHQBCGdhFCgBFFaB0lzB0oYKGzlBGzOjGxHGmghsYRaGCykhM9JkC8exm4DKEihBHQHBDKGvHeERntwwUEDADe//ER/d6VDEYR3kQR7WYR7WDx/8ATQF8h3OAR/ugR7G7huaQQ/OQA1aM8ziIA66oAsqyiBk0zZvUz7AYAqooD7eDiLebiGY7HzqrgEXEAE3cSSdoAyyYF9s0TmdswyuQDqvIAukoDqzoAmuoAmuUwrMQAvSQDm34Ay0gDzJUyW/AD2/wA2I6fEYDw+oEuDeBBD6AJQ2phBaDRIsAStRThVYQTuCARlkhjwgaG9uZhl8YRZSQUGdsSwZgxW4w7JY4eTo0hM8QRMqo2Aco0I3tEIzQRMs9DHiCi9/SBIEc/d2L2PeRBCALzZSYzUSARMs4cLkYNZqoB15iSxWQEd9STKD/8cEPgAfkSP7EAUd3iEf3uEf52EeCNIf9KEe7KE06UEeqA0bVCFKWlMNkKU1ZbMRb9NLS8rt0C1WAKQBO5EBGdBME3BfouQ52VS1gkA6fUBOfUA6syALzABP8xRP7TRP0UALquBPtUA90VMN2uDxQJC63pPf6pM+4aQPyGnNIMHNNIuo+lMWUGSVBnRvsoJTmQEYmnH1EnREmukIJfTSNoGawE8buSQyKOMxKlQbfU1Wby/mLqEcSy0pOoMRWIfnIOYOKeauYlT51sD5amAH8C/6ZGBH59ENP8BZs28OkeM56oEdyKHr3gFb/QEf7GEzpw39ptQaisEW9CAIWDM93f8APblUDHCzESPyQAxETI+zTEkSTT2xXjUxCa7ACc5APMUzCcpAOfM1X+X0B34AC+wUDbJgLeyUYbEAC/bUC7LAC9AgDdCADdgg1i42ul4RN+6ADvKADvrAD0aWZOsTTgrhELALqIhks4rKRGYhF4Rh4RwoKxoOz/IMGpQhGZRhGYxhF2LhCOUSFUZhmlrVQy80MpJ2SyZjdGxIS4iEE2qoYGooMvSzVWlv5bIW/Jai5h5hVxnBEhwhEO7A6IwVWXN0WSHTBEjgWStTWp2DWtnhHaj1HMbhIL2V2qxhGqCBGpLh8waiNdFzomZzXW2zcL10NiUS3XKrjxSQXvEVcvH/FSVNEl8fF1+t02EZNgsOdnMd1mELtvmAwAtC1wvSYA1O93SzIA0u1g2MssyIImRFtvcAofd6KmNQVojOhBKIZFo8bhZsARiS4W5e0OGgYRqmwTyW4RdygRaeSWhHIcA8IUa3JDKotmr100uaNmtVzmojI2pj1OZQNTLyM2zTMT8hwREg4cXU8Q49pogOgQ/YwOhoYAd2gJfGYll1FDLZFkgrc0ibAx7cwR3Y4RzAIRzUgbS+YRumQRnUshiAoRgWSBEIIg2+4CUuNl0PAje3gIM7mIOdjNzWZ30u8Tg18SRPeHI16SRNGCUjNwliEoZjEgliGAmQoAfO0GAfNk+b/28t1uJ0sYBi0yANChUEF5U+8QBOXEM1NMZF+woQPARieLdln8IW6EZ4N8/hcFYZDIp5S5VzRIEJm3DllDZpD5MLf+ows3blam6NwxFNGOHBjmg2+uA19gA2QckOzCAQ2Jd22KDogAD6fuBYaQB/V2AGZiBti4MEFrl//VcDABj+yAEh1UEdvAEbnkFcgzAXKsUZZMEGVGAF0LMKvICUZwJxZ9ODPdgAQ7j/SJiFQ7KFV9gkNUmFOTEBi0AHRlIkTbiGaZiTZBgJdMBGc1hPzeAH0MAM0ACIk5mZ1WCIDTVR94COQUk+VRQ1MqZF4cRjSgNNgko/pxhoe0FmmcHOGv/uGZihGHzBFmihFUrE0gCME8I4E2yojLOWHIOIdVjnEI7iNAAhNuxgtYIADYKAIFQAXlQABFSAXmwgCAABYiDhES4BwOB3DcwgDWlAkPGvkAk5fxV5kX/Uf+lQksmBki15b57BGCJYZzDlZpDhERI6A0a5lBf2OWvaprugElHCAM0UhXG5lkvyJHOZlmk5hXNZJFF4k3wghz3XYdOwMX+ATq9AT30AT7HAB3QYT1XLFtlzzGKjY5TYNZbomv0ZPs+gq4NvNOyCd4uqFWhB4axiz5rhGHrhFmjBFZ6XhjDhMpo2aSuhm+wqEeBENfagvsogCILADNTgLW5gB1ILLo7/JKtiYA8M6DCJBOVcFmi5Ixh4QbN54RQOAQ/SYHRxoAYw+ljv95BTO39XYJFJ4EedFbajVQNKuhqgwW50NhlcREApBRleoV4ywAsmomIr1gxs2ridc5V1GkCQk6iDWoVzeZaHWrqH2qc16aidWzoLtmCZuvm6qqvmNKrjNE7ldDoPuzm5egThU074YDXYGzZm0Q7UQCoTg70dakoKCG5GJOGOgUWiAVuWoReOMBY4h2hjFH0P4VFXDk0qAQztezVXiyCOJAaCIDESo3UOgREwIQkBhjpcIRaOirM3OxiC4Rd+QRhUqZ/8aRjCIxhwIRTiN3Q3rAYyGrVT+5CXlQVQ/+Cjf5THQXoOsyEaetYYFg5Txkh55HoYeOEVNGF1M7eH9fS4r+A5W/MM+m8TP6ojH9enr9txjxOFaYAToTsJtuAKonJfrqA5bTE692UHzKB+s2C7lXUFZCBZZyCh4dCgDToOj8RxVKADrg/PDRqEFPpJciAIcsDQD93Qc+AHcuAGZOAGcsCYGPqwCfpJbkAPUkP8QuQHbcEWdEEXciEWUmET7qLCBaELVCADqAAEFOABaEBK7GA1SPAuMCHZeDGBYoEWmvcW0goXdmEXcuEWcoHYbQHYbwHZ6zoIfYEWPL3Zm72fjGEYegEXVEER9oANRHsJlmDDaJkGvt3Gb3wFQv9oBVBAx4vDWX2cDr8DGMsoU7KBb5wBF1hhYE6hFAIhDbDAfhV2LaDcuN30ObfAI/1o4BniloO6pyW3unMZzH2acn1gB+YUzaMTza+gfiH+CtpRkAX527+9MR+dBtriBsaCkNvikAmZLGRgLGQgLkYeB3zg5XPAB4IABxDd0UWeIO48q5BEL/hcL3q+5xPaBs5ghUIkFZqxGTsrme57SxQhDpDCDyiBE0zhFV7BFYBw1z1d622h2LUe1J0963cd64NwnbPe6yEYgkNLGRYugoXhF4gBFPgAD7KdlLm9Brwd3GeAkFVbR3N8x3k8trcPQLciU5QHGZQ8szzhEEThFDT/IWF/oC2m0wwA/riNG6cJPn1O4pYV/pWdWwe+fQU0iQasO1/LvH7r1/Snk07t9AcQlg3gXGERNmGFmPZXVw6wwAt+AP8MFpC7Sg31/lgdNuJhHv9SXqGzKovuJToEg/kD4wCe39U5QAWchEpGIRVMJNjXuexvAdhPZBdanLN5IRh6YRd+oRfUGdTTXxfKnhbWci3VMgjb/9OBgf6LIbSE91qMdxqqoRq4wca6ASC0ddsGjVkxYb2GqRJk5w4bL1CW9JiIBImOizRozMg4Y4aMjytYsDBBkuQHEx9Sbli5wZmzaDCdBQuG6xSpTpc+RWp0SlSfNGnQ3Ljho+iVMmeS/ypdynRplylQp3DhInVqVKlTnCRxojWJ169eixT5KraIDhoXxepIMlbHjrc+ypS5Qrfo27dZsPxAkwUNmx9Y0KRh00ZOHDltvChms2ZNGiA/cNyIIeMGEJAmQKhYoaKz5o+dVXToAGJ0hwcPOHAgPVpFDBs+zqjZI0jRo0eYQKFS9apWrVu9hAk3dqyYsWLGjQkDxtwXMF2+fAmzpQu6r+rPq2tnzrxYsmTMwkMbP37atGravIkTpy6euvfw14MTRw4cOXHduk0Dlkz5sFR63GGHHA9BJFEPFVlkUUYcfQSSSCusUNJJKKm0UjTOLDOMLKeUssopk5BCyiST7NSJIf9erGHGD0PRdYUZZgBlhlxIIZVUEHKdYeMZXVgV1VQ+QsUFV1xl5RWRXH2V5FZslZWEDmKhlYQPcPlwQ0ZFZXTDDjjEQFkORZlB1FBDzWDDZK5R5pkHpnWQAQcZxJkBaqahlpprrsGmhyCJ4IYJJqPsFksssvDSyy/DHEPcMYoSt8wyyhijDHLIfZfMpN91x52mxXBnaXjPkHeeNdpw04167cUjz6ry0KOON990I5A49OBTjz30uPfeeryGw+up+wFjjIao7KGGHVkQqFheWGDRRIIVnXVlRw6GJNJIJpCg7bYfsERMLahsAoommlwS4oiTDDKIIZPI8RiLWNxAF4z/9M6oFI1nBIFjUjluAWRWVQUpFZFYXVVkVEgiKdaTbZ3lJQ1bXhlDRjGEZrGXXooGZweqkTbnAw0woAADJJOcWscxBKHGbI9s4jIoprAiSy24BDOMMcgsg0wzLvHcjM8/LxNeM+GFp8ylyigDaneWNg0eqNCYV40115z6jTfvqboqPfTc4zXXXHstttj43CPPe1eLs44//vDD9tj0yLOOOuSQ05443liTDDDFHKOQGnfgsUMNiCnGV7NNPJvgWZJdqZEM1rqA7bbcsiRKJ5p0QgokmH8C4hxkNNJJJH/04AUQp98gQ7NZZCHF61kshW+OTPkb5L9ZOYFVkQIjjGST/xelpcMKGF20gmaijQbC8m5W8MCcH9v5AAOpkaaCDXL5YIcde+xBySajgBIoK7HQzIvNw9h8DDKMPvroMe6738yjRhdtv/3P5B9qeeedN/U13BCHrrYWNrB17R74SKACF8i2Bjqwgf+IoD/Klqv4rEMfbXsbAhOIq7itY1Xq0AYzhHWMYKhCQHKYQw9qMIcxPCQNWaBL4hQXLS41TiMdcYHkULAtHnIrJSQikU5IEYkS/YEQfxjdH+ZQA9Ph4DKAMUPrYJcFHNGIdkkxwxlmpMUtbKELYATjF73IlS92YQtlTKMUnCAFtlzEKxiJkByTB4LV1LF6qlENnVrzGjOg4f8OtbGEuEyxilfIolA24wUxFjmMnCUKGZDMWfziF6n+IC1pTUua0pihtPxFbVTXwMY2YPWNeGjNgAccm9fKpkAH4gOCEYylLGdJy3/w45b/mKDZ4jOOejRwgQr8GtfkEQ9okHBDPsnDH7wwAxbMYQ5sYEMapHiFJizBmkhAkDZ14DgcduRaEpLQhFLSiRB9ohOrWMUkTrEKInbCJpEQiQlUAIKQWCw0GMunl2SgT4zdMzSmQV5p2tSm6E2PegdlQANGltDq5SkIe1KEIEcxClPshhWuKB/NcMGLjs7ko78IaS96sYtdjHSk0akOdaizHe3ogjuVehozRPU/AJ5qPer/+CAxtcaqnrIqlap8JT4w6EC31ZKWt0yqUpfKj1zeYx7i4AY3tAFAbpDjqQhkBz3mMY91hGM+4lgVNr5DnFhIIhKEUGYg+pAHxBSIL4rxwhKMQNca2NWuHcmrHCOkgnmWJDPL28BNRKS5cp6zE4idRCMMITkWgGQFM+DrZvz5T3oKtDMVsyzzOuCZ0gyUoG3azFByUAY7qOEMe0gEJb5HUYuqAqMapdkuDHXSkZY0F7fNhW53uwvruFQXLN0OTL3zNFGBUiDqYU/W4rEOnXJVHvOoxzzYEd1bcdUe2LXHU7l6Xez6I5fg/a4+cqmP8pbXluhtKj/0kQ99qNeWTI1v/1Lftg5wTPUaVA1HPe4xXn3M4x7rGEeA5yOPbXByGc6IBR9qUAdDIDEQfLjDHdwa17guYa51NcJdORLZavGVM4BdHggGK6KblLMTn5gEiiPBRI9QrDIfwZiZbNDPi2kWT5j1EmzicgY90EYQlMCEuCqKiou+4hWEksUtbsFRk55Ut7Wt7S6iQ2VbWPnKwf3tc2D6HfF88n+mSi572EFmMnOVHe+oRz3K6w/zltnMalZzPvIBjzrDI8541gee18zeOfvZz+htr6D//Gd+5MPQiJavopMKD/tKVarggIdS9fFUMn+VPc9Qhs5wwQcVuCB0jShEH/ogYbe+sMIXznBd7f/qTY/slTOdXd45bfIJwpaTROlsRA2QcIWi+LoMZ7KBsIdtgxzkIAjGLoMalE2bRCgiyOIKhWtZQb6ZMZmjHjVUSU267ZKelMrgvs5vX4qdTXH5afuL2v9KJdWbvmccdWtuc9mBjnbYu8zpyHc62mFnd9SZ0Hfecz3obGdCG/zgCPfzLQm96EIv+uHs+Co4Jj6Odhj60P+IMzh8pY1M84wXi7jBGLzAhD8YIhCAAARbJ9yGhzhm5HLFMF1nfteN4PDVsA6x5lZx68SSqBOwIEUdxpAF7vnYx4Lg07MxwQlpF/m1SMaF1M/30WFYfRiMvPqhhCMcm3FdGNHhDpXNvan/mF4KauWpxv9O5Q1UpWpVY7OHmjkoXVzZ4xz29jc85mzvvLvj73T++9/bsW9989ve0uUuV/HcXrclHOHmjfx5/zF5PauZzQ80L9vmjEvK93nOdobHOUY/jo1P3D7hOEc9InjL8p4DHOvgBiefIZNLyIAFPCBCyRuBiECsNQ9tdatjwlAFKERE5jTf8M1xHprlnUvF6AriJNoZokIakqPoW+QiI8n97keSUYwyhvjHL35Kmb9TlOoyJ72s7mu4/1RZSxVPC3iPrgGVlQh8YNsujnm2wXepf4Ze/9AO7NAO/vZnoedn75Bml8c2A/eAguZe/9B4ETReR/VdbdZ/D7RA/2OjeIp3DvvWd/Y2eiRYgucwDijYXOMQDuwwDqoXS02VD+wQe9AAHs0wDJaABTUwAijAA3/QCI1wCL7HVsHXBi23BmFAfMaHfKvGahyGczkHAoawWIagOSRSB4MQCYYwCGRACKsQScSQM/ATP92nM8swP+9zDJq0hpsEKulmHtQQh9RANdtQSjz1U6hUf3qoSquUQW7zh7j0Xkc1Sw40iOEFXg/3cBX4Xk1FeeQ1XmxDVPo3QRNEafqQXYrXgisocafXiaeHgihogis4iuEwDuwweuxgDuswg2j2DuxQD4x4ietQDeMhDc5gCj/QAxuAARTgg41ACCmXcsAnB8TYcv9sMAZJWHwYlmoadlfc9ISvZjFkQAaGQAaDUAdUWAd1YAVMEAVMQAi4QAzOAEmQEinkpwxl2D5n+AzSIA1xaA2iNEqmhIfD5FOtAlRk80oTlECUKFT9yDaMmF7/p1SGmEuFWEuTyHoCGZBKpXDxJYFsZnkYRGkJJDbYJW/rYILnEA6cCA6beHocWYqgOJInWJKrCIoYuQ71kGbT9WZktmb7p0vyEFXYkA3ZsAyJYAYuYAEUcAEN5mBCOGrDWIwtJwfIqIR0FRFNWAPc5DiRxXydUQchUgfUOAgkMghR0AhWQAZWUAd54AmrwAvDsAzsCDXMkAzP4AvLAH6KogzPkA3/3xCXpqQq8JEq8lYPZGYP4QBApXIN4PCSlrdmrDdncgaBMKln7eV5kEh5+fBdiqmBEhmJY/NdCxeAE/hn43VxScV5ichUGcQ2ZYNdXJWRJ8iRIBmSI5mCKihg9IYOruma5iCCIshd7ABdcqN4tskO9yB31+WBMwiK86AOUXUN1FCDtDAKlvADJtACJYAChDAJkoAIhaByRDgHxEggaYCMVaCMSYlhd8WUkqERUNh82ih0WdgIkxAF1jgJdcAEZDAHMgAEY7AIj3AM8RCXpaQO3LAN29AMwvAojnIpz4ANV6MOW1OXObWKa6Zm8+BopaINf/kOhzZnFqheTSV5k+d5//lgkA1kXnwmif4Ak5MITJRJkBp6aEklkJ43S+WFgK5Ygs1FeqGIgiHJiSJ5guuADjm6ivJWZj0qmwv4DiIYpO3wXPMgD/Zgm3IjnHjjDfd1DdZgDWrnflCqdmrHDVBqDdPwDMAwC6pgCp4QCCzgAtryB5HgCNI5atV5nS3XBsmojEuwhMmHBDgQnk8ZjZ1BjVp4E2QwBEzgp3VwBO6Ze39gBXNwB8PgHqW0KuDQHttADc7QSOWXDMUADdrwHutQfwi6ivPAXm3GDo5WVX+5ehwqSxdncOaFmXkGopnHouyleaBpgYb4QH/YZmqmka/niZ7IK+tRiuVwDuVAceZwDv/DWqzEWg7IWg7m8JqvSYAESF1n9ma0SWbrcB/4cV9SGqVSqnbm0a1SY6VW6j/UgA3YUJzK4Ate+qXj4gV/MAYsQAiS4AiLIGpCmQfWSYzR9AZJqITGV3xKqWFGYBEYcad7FRoNpo3rwoVHEAXbyAPuuS51MARkAAjLEA/ewAzTgKSvpw7l6gzE4DeKQinQgDUGOjd2uQ7RNWdsMw6Phl/cEA7/hYGwxHpLFUuRt4h/+Kr88KEHeYG/NIm2upLvUIIj6Yk1eppHy5G82qvjUA7oUA6jCLVSOw7mQA715g6y6awYSQ7VyqTgkB+Ohq1RCq5kS7beerb9463tSA3SYBD/s5AKqUBRnjC3haCFNOAIlwAJi3AI1Al81jlhhCEH+pqM/cqdACuwZ0Gw0TiN7VkH5aSeZFAH3tiegzAGLzAEdUAJ0fAN6hA1A7YO3/AMwYAM6WN1waAcfDOy8RBWysVcGTlwjekPDqoNpTIOtQK0BRl5m4dwm4milUlof+eKb/aRndiRFOe0rpms5rC8yzuSO7q1dRO98bas9lat1su10ksOTWu8YUu77qetZDu2ZPu9ZRuu1dCt5Quu1DAN0gAN8yMMuRALqoAKgSIKohAKkiADM+AFl5AJ8sq3gKBMfithdnAYg/umxqeUd4W4j6O/MQZrKkCN2miNWDkIVjAE/zyAjRL7BzwAA0OQCdSgKuohD+HADRwrDK4QCo+ACmFIDMPQC90xDd5gSso1b++wd4f2DqGKpbB3D/6HgeBVgbJKiA7kXvEFegRIguyQDiWoq8Ubkp24iRwZismKrMuKDsuakqvoktR6vdUqvTTKiVJFu2QMpVkapWesrWqsre6Xvm7Mrd5atlJjDXHIvpm2DPAbC3GLCY8gCuNyCacgByzgBZqQCYywtygnwPaKBwJiwGFwwP7KjHbFwNTSwDEAayVCBpMwBJhLBkzQjUMgqDwAnx6QAlEgCBW7U0waD9kQDadwyKJgSC5sUsLgHdPAufRhw//Gdw46Vb1UoQvZef8SlIEZiGcL2A4k6MTKHMVSjJooKLVWvLxVbMVWG29bzCryNl3aC8UT1w2zS8ZUtcZoTKVUQzVUeg1WqsZpDL5V+sbhirbw3K3t+AzMYAy+YAvxqwqpQL+ggAmroAqrAAuv4AUmEAk44QiMkAhD+Ad/AHyMfAeO/AaQLKczh7jTYnMewU9e0p4vAANHYAUg3QmN0J7eSAZjkAHZcgSB4ArSgJ/qUErb0MqisLeQkLeyQAyGIgyUygzWwLl0g2b1sMv5gA69zA3rMFSNuHANiWclmHrL/NSm2bRUK81THb2gWDfMu7w6qqPOWr3z9sXW2r34Fc5qnL7mrM7n7H7em9b/bH3O4pyt5RvP5tGOdN2O0KA/nDQpnaILtDALrdAKrvDXrjC/u9FRuPAKhmACMmDQl4DQfLtWDO3QDy24j3zAVFAFT3B8dPUswTMtTwg5MkAEJMADkcuNUUAKW1gHPLCwPFAD7llynvAKxxANNhnT48gLOmEIhsBOnnDTkhQq0oA1Z0MOr+S7/pAPtLlB/OhADNqSrImRqqnF7SCkW5yJrFKAAadmQcqgtyJ3trJ4eFlm2kuj8+EN+dENj5bejyYQ26AN22Aq+dF2533e8k3f9b0N8d12+m3e8c2f/t3e7p0fAA7g5FrgBs62dv0M8xMpnXLPttDXszALrhDYgp1R/4NSC9Z2C76B4YfkCCIRBgYdr4hwCIXgBybuB31AB3IwYcQIB24gBmIABlTwBDI+40pw42VhFgyyEZHVEXL0yd1oBQ7LBEJOBkeAAlEQBS/QYBdcB56zCs5ADcfgsbXwCuq0LpEAC7LgCabQSDkjHtNgDSULi4EYom/GtT7aXFyrxdA1XTyKsri5Kq3okty1KoqHZ2DDXXbzK+tN1uo8zmas1uBMVWk96Px53vjNdvPddlez3/Ut4P/93zaZDdtg4ORax+1Lz5yEHMBwz7QA4X8d6q2gCqI+4aY+4YOS6oeE4bTwG4ckC45AAywwA0mkCSJeCH+A4iae4n8rB3Dg4v8vXuM1/gRKkOPFfhYc0Wo/jsEZTAY8cLlREMpMgNod3afrSQqigAvDcD68gAuioAl/UAcGfU6LUAqUcNNnOFPTAA3WIGDnIGmBp5FaLG+2qSur6KwFSF10zl3N7YFHKm/xYd6ETs7m685TI77gWs6AXuhrXSroDc6Q7t7uHekU79+Tng3liuDSoOBH0+DA9eARHguoHgt+Leomf/KnbuEWPiiuIAu4sOpJJguh8AZGwAJL0Ajkcuu53ge5juL22uK//uIxTgVgIOPEXuxigfTIvuM+HiGq/eyEYAg8EO1LnuSDwANYj/XXKDqnwE7djgy4oAmfUAciEgl7iwilcAj/miCOzXDX0zBT19BLE8oPopcOp0h6ARZgax4Oa95cOcUOaA74nHpmYO0r14reUxXOU7P47jy21JDw6VzHcPj4Be/GWUrOgX7Olm7gNnnpcUjX+cNJ3+HxwPXpph/hszAon57qqX7qGJXy1Bb7r5/yIr/ygzIzg/IKrmDli5BiUDAHmmDQto6mJJ7rDO3z9xr0bhDsRW/0R3/jSs8gS9/0kuvs2jgEkRCogfoCk1sHHqwu6EkKXW/lq6ATIz2FefBOmoDzmlAKuPAS0rDu0FAN4CCYETS0ae6Szipdb9a1S/vwAKFN2zVrBasdRJhQ4cGCBhVSgxjRGsKJ1aYdpDZt/xrEihQdNixIsCNCgtUyZtQoTRq0Z8yYKUuWrBgwYLp02aJFa9ZOnbNy7gQai5YsWbGMHj36SukrpEiXsoIaldVSqk2N4iIay5WsV540sPBC58+fSZ0ySYLECNGhQIDa9umTZ44cOXDguMHrRgyYvWCoPHmiRLCSIkV00ECs4zBiGjNWMLFChkkUIkPqDGHC4/IQHpPI8LBcp1GjSZo6dZoUicwRMoMMRTJEDNYYUrAYobETK1u2bd66eZNHD99we/PWrZN3XN1yceLChQMXHRy3gSUPXkSoUfv27QstXuTOHWNEatcvOrxIXj21gushale5kmVLmDJn1rSV/6dPoP/9e+50pZVWZjnKFQMPRJAqBZVy5ZUGG6RKKqgWXKopWWrBiqhVFgGiAgsucGGMMU67BC1GDmHLLUAAiWuOuey6Cy8xZtyLir8CE6wwwxArbDHEVniBByYgG5IHIVkbxEjOhhiCjElIIeUUWAzxgogoeEAhikkMWYWUSQgh4rUWbrBBkGW+QdMbNb0Rx7eBRsIuu/Dm1Mi8OROiszs584xTToVSmiY+laCZzyWXYComUZpuyg8nnR7ND6ic9utvllYCxPTSViSEysCoVAFVKlBDdUVCVTyVkEIHDbQQK6UgyWACEj7AAIMW/uhEkxLTQjGQPgIJxA8/8pBrDhjz0kv/rxoBUyIwHQ9TbEfGHuOBjCiGjIKMT+qoY5IkDWGSDBgG6TIS2IyEAYYhUhiElEZIieQIbskgoYZFTEnll2iiMfQZlgwFuN9nBiaUJWgEFTQlafhkmM+FE1Y4UIQL/vfQmBRd1CabaEpUUV801q/RSWnRb+SRK0Uw5U9HHTUVl1FBpeVUYI6Z5VFNVUUqBY1ypSlcXuHKEzk0sCACCi4ggQRCSNH1El7Z+jXYYYmdgw4YYxRDRr+YdZYwxb72sTErhnDBNTLIqIMUQv6I5IVIVrFism5Rq4OQOpysYxBuB2nkDytcG6Q1Mgg5RZZglmmmGcSbccnf+eYbOPLID14J/+H4NkIJc/c4as8abD73/HOIsNk8vvkYX0YZZYy5D5iPQWbUFo019gWYji8WRhjXb8ql911+//2WXXr3fXjiben9llryq6V554mC3iqeWUXqQK1STvlSTxXsWZZbYmlelgxxwUUTILyoAwMHIsCAghOe7OQSpx1ZhC1g35KLLjqstksvMPy3EY5y1KPD9IgxiInCEI7AhNYYIgoPZIKV6hCFCTLBEHpjoLXIAJtBRGEQVqDDJCbIpCaNIRJAC8YxnOGMxCVucpKDYQwpti9pRGNQCNPc5ko3qGckbhmpM4YxdOeL19kEecTLRX5yYTwkNvF3vYAiEX0hjCAq4xjFkP+iFIEHvFsID4rAQ2KjbNE85jnPjNGr3vSw56mUFahUb0TVUg5UC6MUxY5Y8UQPZGAkDLCPAiOwgiY+8Qn5paV+bElRXPK3v2PNCIA2stFgdGQYAh7wBZg5QuAomC0eWIEUdRiSteImogie7QhWgEEn64ArKyQwBSlgghcuATReDGMZzvhhwAbWQl7G0F++fEY0HlcwhAnzGSv04TKOcQxjDEMYv/hiLnrxuzD27ojWzMUtlji8XfQim9rcYvGWCEUoCqMXVDTG6u5DRJt8kYm9I2cTv9lFMposJ82jRVMgxCAHOYgVpYqKPx/kz079UyrYcyOEZHEJGbCABRYYAQX/jHYBDBjiE6L4RCbmt4i1BCKRxJILIxv5SCqAAQyDIcwkK4mYIwRJgdVi0pBOsYrP8MAFqCGClbLVyiNkshFMGMP+PJiCEhzBEH8oxStq8YthIAOXywgYL3nJDMY1A5iR4+UPf7hM1uXumeTcIjW7ONaxyjN5XXRiNue5xGyGFXjk/EVczymMYgQxdfahSRbjSbwnGs+vY62nPWuRz6aoSimcQmxio8JG6vXMFat4xSo0wQIXGOEEJOgjGVKAgQ/84ROk8ISuIOEIRhzSfn34A9X2x7+70AiSkBRgSlUKNtDw4AUvcEGQWoCCbkWwBUwgTSs7wQTLHKEEnJmECAlh/wjPkMEKfzMEJJRai140VZmpU112tapV1S3Tu9716lenSTzlOY+eZqwFWbWJVr761azk9GZatWnWt8I3d8PAb+6Mocz6dMy/uSPiF6fpVi6e14w5kd71DqtYBjdYQg0qilJUsYpVMIIFH2hBC0hQghTAAJUUaEEdOiEKT2h0tIswLbAAkdqQsra1MzJpAJ9wowHO9muXHEKQbvsCKwTpSyiwm5cGEYlOJJBJ8soWapJ7N7pN4g+eKAp1h3EMZXI1ncwURn5/8cxfDI+szSvvPe95xlhAz8xgBmx51btm9rLVrPLkpl/hO1djLHPKzETcMnqRqGTAJIjJCGIxcgdNd/+CcZteLu+BCWsVVDnY0Q1WaGQpvAgPnOAEc+DBCEYggkkYDQYkMAQpLnoJSxgSRb0C1lhafDVk9eVGsK3xJG+cJN7yjVtEqBZoXmMZvo3tCEMoASqHYAherMIQaBtEWboUCFGQj6lTXgZ+nTloQht6vWuuhZkvhN6h1BGNRyHKmNE7bkWLUYxv7iZ8CT3Funr3ztdthi+UgThmLCMZx1hdEAfdC2gSmIvpHXeCtULQBz+60YqlClcgu4pDaEADIyiBCEpgaQyIgAIYGITbMCoKUp/41KhWdR5E2r+89GVrfgmgJG3MgwcuGRak0MwQWnBbsnBmSCRMl7pg0K05jEH/XpGogycNMYdA4IIYxID2MfDLVPEGgxdP5wUUc0E+wJI72+J73tXLrO06Chwp9pyUuRs1X9/BNa5n/4UvthzEIHp3v0GMRjOk0RJAM5PtXk07v6c54HRPM9EHTjCqAiQgAR3coJ1C0PQ2lVgFUfgUeXBA5CVgcQlI4AKWp4AIrDCJQZbCE4Wk3yEKcWoVw6UPIye5qyEZ4xsxS7Y94kFPJ2HBTlxGM53ALQPrYAgmwIAJdUjXcyPzUi3pjTWRCVIjZOFUxOGSmXZGejCkH4xqQ/13vNgFLp5OvuyTjxfaJ1/4xT9+8uOCzWR/86F9h8T6QpHQ0uR3eKc4RWMAQxkq/3nG7MRoz0oBZUCEJzxP2ZQBtBmZcZmWAZUDLMBREZD+GJBbcIVfCD9N+IM58IIx8IIM2wALsAAM0DQRaJ9a6SMMuAAeiIRP8ITPk4RHcIREOAQXRJEV4QM+wAM8WK1jSZYaab2UQymVMgyZg4GyOYJs+S0yGALeGpI6iAQYSCAe8LBMkowhgAEeI4VVSEJxURciyANecKoVGoY6Owakw6/pCwb4kj6owz7t+77wy4Xv677ywwUMgUOqYzN0ay9qYr++g6s9jKtnAoZe0AVfEDRgeAZqyAZpsJ3d8YXjEbuS4Y+dIDwAGbwCdJlKtMRLxMRUaEBa0AXbSQZmgAbMwf+GbIiGOkMGYsAEFdCACZiAC7A0WvFAiZuETJuVimOSEniBRsAoTigRFkyEXxy9QhAEGdwDPDg9F4ODrNHBV/sLlFK5HmmBE4CB1RiCRugEF7ApdakD3uIBXJOMaeyETDIuIdk5WOiEP3CXQRgSGKgBL7iDU3AGZECG+2IqpRuGYLhHMuS3s0PDLQo/7LO2+TI/9VKr9VIrJJqvcIqzbfKFbjq0dPOFXohIvYrIKAqv3JmJYpCG3cgGZkgUYQjELMqiJBI7SvE/ACS8TKxEANyJTvxEULwIbNiG3mCTeAgOeqAHdYgHbWAGYFgGYjCFDjABE8AACxCBEegwGBCBpRz/Fx64rA8YgVopAQzIRYzyBEughEd4hF9MBEEQPRnkg2I8RhfLGjdAuddqRsCIrZTSgRNoAd+DgSchgxOIAkN4y2msA9sagig4AhjosN8LjSYRDROahLpshM+oAxGRA1EgBmcYhi1zpvwiw8n8BV6Iq+8DyDd8um4ytIJcs4MkLzgLK+EBo99pyL2DL7VTu7TLotyZq4skIitKHHnbl1IUIprIK9f5mN2cndjBif4Lu40phj5jBsepBmu4Bm3oBjT5huVwzuckh3EYh+Pwh3qYh3nwBmgYTmdghRtoKBJwgD/atIrzwKikAB7QsBGgqPW5gCGYBBK7yqx8BEX4Ra8s/wRiFEuRKjmtYT0ZU8v/lK0TiKm0iYTY44wgCZyd6wQnaY1fmwQrMCrBsYIxMII5IILdawTXMJI5MAQTwgX8ir8sE6JfoL7JfLrKzL6w2r7rS9HwuwXzSy8Y7aLxmzonWki+4iuw2ke049Et082I3LLw2gVhiIZlGIVNaIVUkAVaaIVlMif/ws0olVKaiInGCcWDSE5vQJN44FJ58NLgCI57uIcvTY7j+NLjIIfjWAd2YFN28Ad/MA5usAhpQIY7iAEZmIMPkCjyjDiJg4ESiLgIsIAXuIALoAAJwAAi4DxPAIUSWUFEgNRgvE8W6QMb1E8a4c8Y25oZAwwZG6CkPP8yyGgBFxiCE4CpOpCNYVPCvTxMT8rQ33uBGnCRQbCb5CqBaZw9MsiDU8DHWsKvEY2rM3S6y0xDztwF68OFYyW/F1WeZk2vGWXWF7XRO3TIbZqzHoWm1aQJ3cFNr+oYuloGY7AFY1CcYMiJXCCi24kJZXCJgrmI5NyGb+DSefVSergHe8VXMdVXfcUHf+AHfQDY4RBYfNjXMV0HcmgOcZiOcRAHbriGaWAJYEAFQGioDTQaEBSBdWmfpYzKOjiBzEOBCJAAEjCCE/yERpWER41U0ZtUuLDU/oGxsjQ5kzrLZtxUlIIBaZzGI+iEQVCXvbwSJoAFZziFIVygs2kSK1D/QlKIGxRokrMpTEKQuRGgICswEiAwBV/FR2fiURN9Onjiu99J1l1YrwKjJzVbs2tyIlwA2zkTyR2VqyjiN2DwqilNRD7DonlThmKwCZisBm3gBm5oDuS4SZw0XJzc14El2MW9B8VVXH0gjuIwDuZQk8AViOq4BoLIXGugBmgwBlowBUxgBBzQgA+gqAjgMEDdNBGgqKUkA4kjAxRwgEE1oUGKz6yEVESQ1BWpVEvlH2UpOZotqf4MDFgbjBPoMOfyPQidwrQZgkHgBVjIy6AjA1LooLEhA1iAG1CqRlg4TCX8tFttkiiAAS+QAUswHGl7zLPrBV4gQ6jzJnfqnWQ9/yuyY7NnbbP0C9vxEkmRtNso9a+YeElCWZiNwIa5a4lnmAZtsEl7Hdg39QfHXdx+7VcIjuCC1VfjIIfofI6EbQ416YYQFuFumMkSnkmOzAbSaYZfUAVMeIRDuIM/MIGiiYAFOMoS0LTW/VOL41ha2YAW8AJJ6ARP+ASs1Mq1ED0UadlKvUGSC94YgzFYgy0ByjkplMJUckLLYDm+/KnnVQ0jTKVJWAWgi8JJgIUHCrV4aZIhUFomGYM5uARckEd5dDcwHAYxlLZjyKfm8TZGawXCAjv+CzslakQx6s2N4ZgqBcUrTU5uAIdwGAdyYIfrnAd7oAcy7VIH7td/4OQ3Ff9YDL5XMSXYeqgHdjhY5/TgNgFhbhjhEr7cVxaIzBWIz6Fl0XkGZcgFV0AFS0gESICEP6iBDrS8EcAsYo4AByABEUABCvgjqUQBIvACNnCET9AETTBitViL3TU93/3dklM9GxFerlHLwci5dDGyI3BCI4mbFxiXvmSCBeo9sqGgdimyuyGDINmbyyCundOgQTCCRTA6Ytha9SXopfuFXEAv5RE46uGZWOCJ/bAnc5udRG7XKz1OwBUHnaTXLxUOC4ZgfYhggtVXerAHUq6Hd2iHdjjpdRiHDk5lEO6GD24T6UhY3+gGVv4NEN4GgTDhnp5Jbdjpz9mG3aBlapAGxen/hVJBBUqAhFC4hEaYg6IRgQ8gAQqwgA/4kBE4gQ+YyopbShLYgE6IhDkQpGo24keA1I+7T5eNgyaOEayBMZqt2dYbZyVgEr5k43D5WSZ4AVOtrWk8sihAAXUZEkPIm8vwvXQersBBgRdojctgDbJ+BWJwX+l7zOqCJ0LbPqobLD7eiaP4bIeulEisFNnpRE8szitFTm3QUuec18YdDtjGB3ugbYD1B32oB3sQU3qYhzJljoQNYXDwjcAN3Okg7sCdScu93BImYerI3EZWbliG5Zms5eoe6utO4aKOO2P4BSYFlVDwhJk6hTkggWh8SqwmAS94gQiAgSPgYYtDgfSu/2ZJ8IRcoQT5TOtDyGbercGRk5FWoxHhXb0Z888nCBcp5IG/zKQDHcIrboRIyNjAQb6kZRIPG7IOIrIoUI2e2tkHQps5YIRVUMPKpr7K3GyxbZ7g0SZH5AmgyA+NEeB2rRPknMnWzuh5nVd1INMvZYd2aNPrfAdyKAdILocihw5wuOmbDlwlD+HAtekmR3Ilj+5Xfu7MxQYrr/LLrXJrqA6QCB3SEZ2IwL+WOBTWgaZ8sgWeiYpVkAVYmAQWIAELkIAXMIQP2GoLeBLURQEMkICpjIANqAFrvKjQ0pX7RmskVmLehQvUA3AaiWu5nmu1hFAjrK2jbQRD4IFku+u8Mf/CBSouCmoEUGICIkONJKmgBOLLz3iuNR6DUxixVdi+zfa+7bsFXlgidjpt1F5kjeDyeLVJdUCOw71keRjp3t7xMj3YDT5yJD9u6gDc6G72ZmdyEV4TEY52aKdyWcZckcCGhogIiVmJgXkJRNmd30RJBryZTlEwClMKUWABEyABRIUBQ7hzCyABFHDKCKCo9rm8DSAEFKzmXLkEQ4/UQjD4+/QDl10tF5MRR3d4k0PLG+l0oCWuvXyNaznM540MdEZa0djLBhUx1bgSKzhMVZeMjH/CoKuDOaiBQCiFEV/D8btHulIGaKAGbPCGjb7knRd2e4Xtgr1kdpAHoV+H5pD/cmg/7uS8XOKWbuUc4aef8m14+qkn4eYO4VgWiYnQCEIRd3LHj/+wFAFRBZWcGVQoe1NgmZpRBQYpFQpbhU84BBbYgBF4gai08xMQwT5/AfKUqAuwgA3IA1EIBU0osfjB72xmWUBI+P5e+KuJkUYPcLl+rSf4NSN55yvpS6dVx6Bb9SYJHCM047sZMjaeBDqQDAY6gktn40GQwrHBDCEZX2hGRwoTBVGAhNRoBEaQBF5FhtR5BmyoV5ws3J7H15x8zuWIhzVRfnF4ejVR5Wr/DZweYW9odsDthle+doGo/sutZc5NiUJ5CbyqiZsA+7BHSQUU+7E3+0uEGUukmfdH/wWAmhDJAgENMAEXuBYKcAAMKAGbMlQSBAgLGERgwHAhgoUNizx90uRJ1KVLlB4xcoToUKGLhfxw7NOHDkiQcEaSHOnmJEoxKsGwbEnlJZVBg8gMsULGUB0YJ2BMmmRlCBMmQ3hYGVSHB5k6dRo1MjRkCIwXhOYQikKK1KBOjZgUjcLjKI8oQ2FAfUHGyp85f/I0GqN0zhwvjFgtixYNmjVv6tR56+vXWzduggcL1sZtWzfA3RYn/tv3G+TIkr95g9xXnDjHiBkvBox4sOFroq1VK11t2jRo0J4xU+Y6WbFiwIDpqm3blq1Zs3DboqX7N/BWwl0JF67qeKrkqJYzT/+Fyjnz5aaio1LlipUqVqsyzTDhYgMJFxhGREDxoeCF8RQKFowggoKFGpdKfarvUCJFR4suYtzY8WNIdJREEkpuxPHGGwWiBMYXDFJRxSSk1BEUE4aQgcILQ8xEBldHDDUEGVFwRQYhgxzBAw9D8SAVLISQMokhpBjyFRlkyFRHUlbYRMYkOBpVYok2NmKUIZCg4swzz0gjDTXWOGmNaFFKqQ2VVGJj5ZVVVrkNl9to0yWYYXbpWF9gaoONk9eQNs2SqkHDDJzKMMMaa8wkA1tsxRhjTJ6yzfYnML7U5ougvNFyKKK0xLKoca0cp0pyyY1iyiiVWnqpKbHIsumistT/sgsutWwayQYRkNACCR9Y8AEJGEhwwQUSCCSBBBTYml6s8XUiiie9apJJRJAwsghGhxhbSCAc+QFgSHI4C8ezCL7hrBxtsMHGGmmsca0bbLixRhVplHjEEUzAcKILQNVo40848sBEiH80EsUgT8EAA4lhzBHJGGNE0lNTWNkYiU0g1ljHJDJp2Egdg0RilFJErmKMMs00gyQ0S2oszTTUNPmkNdiIfOXIJWvp5ZdiglkyNh5Tw6ZqSdapzJ3J0FwzzjXLCWecyuhZjDB78pmnMLMRSmgvuySdC9O91ULL04rG4grVrbBi9aPIQYfKdMsdx5wsr4jtiiyLhsoLLppY/yABBiRcwOoHF6S6Nq2sXmAB3hdQMIIIG2ywxCe8+qpJsMMSa+whgQTyR0cBguQsHdTKMdK0d1y7BubbYpt5toOIhWKG8EqocI1RiKXhIH9M0kgkq0xI1hBedQKLFYbAMggPONGkVB0g+v4Uwgl30skgTNWB01KGLLKKMMoss4zFSbr5jGobL9mxxyGzvP3ILmsc88w515zn0Mbcuef5Qqvv2jIVWwy9MnvGJn9sRfvyC/5J77L//rnccsvTNiUqTk2NagakGisSqEDsZO1RCXwFp8T2Ck3hAheQWAHeDPI2FNCKBB68mwXetgEMCOQ9tpLAB+YgCsF5QhOEs4Swhv+FuMQlS1kccZwcIge5yVXOcti6lrM2p7k6RCFETCjXEf5VvIbVyAoeOt5SVhEiMpCCJikYCiFgsQqGzQsG8DodEWdiBbHUaBKROF5PitcU5DWCEI54xS30dIxlOMMZzZAZHpU0Pem5aTV4jBOe+gS0oglDkIY0XzLUp8g9HaORjnzeHKFHRzvSEZJCy1OgCJW/XfjvFkwD4NM6JQtalG1RVFsUKlEpwVew4joLVOABw/aKVaxCFZvSxAo0MAGBfOADG+BBLz/gAmDiLSEjHAjf9CYBEvyBFKL4xOAKJ8NAGEtxjLOhHwIkOWrBoYc+vMMdqHWtcTaRCVGwgrte0DD/0yVlSEmZUPGgQgopwuCKsUNKHazAsLBE4Qi9AxFWrMCVhmmFDEOK2CAMYQg1EuISr6iFMCJ5see9r300w6SgbHMb3tiCabrIhS96IVKREkoYJj3p/NCHM6HpLJHocw37JMkMi0XPGY1sxvPiRzRhEIp/nMwFbmjRG9/oJhazkBoqD6jUU46tlQhcoNWuo4pYzHIVpyjFKxYBggyYoJckXJVQSCABFLntbR58T3pKMIIRLLMRpRBFKAZHOEg4Qj/8qeY1+3BNHDZrJM4CJ2DBKbnLrUEp7zwnucg4xbNATCgcIsOJolBPqIhoCB66CVf6CZWG+ZMm8DrevBq20CHJ/0ShDyPEJ0K1P2EM4xfB+MXSgnoo4ND2N4n6H27/xzT+jbQXJ/1tIWNTM0W6FJE5cw3PaDonnCrjGEMrpDB+cbT+MQ2oQ51tbYtKnOJwtzhQ7a5uEhWLWmCCEou4ww9q0IMKVMABEaiVCEgAHhfU4QQbcEGsTgifXqZnBBj4gARaMIlTrBCaLpyrI4Z1Ef4EohCM06uyHKfNvwYWnHkArDjZ8AmCEZEHXpyQjqJQhyMkZbEi4hATUOBhqFiBBx7SEL7uBZV7KUWyRTxLiSMxJKYwxWE4aeMfOiELXNzCU7U4Mi5iQdSjHrUVxNluK7KrZEQd+ci3wE11c6GLjB4NUP9eNqQgx1eMOwn3TjRj0jNiE6hMhnRp1c3tkRO15OCAN7xCtYUvgFEMOVGPSdTIRja4lA1qRIMYZXjAAxjQgAU4YAPutYADasUDFsj3J/YNYdxgdYESoEAEJRCB3ixghE4Q+Jme6IQLLyGsReznEK1e3DWvmc2Q3NBxeAjnHfCg6wqHs1oJQ4pQXlAUIh7hRZ09whhtYohVdKIFKfrQhBBLlnOZaywN05G6mKCUfzVMjQlTKGiboolVeApRvTnqnKOc3domKs5WPlRHOYobjW65y4Dyk5f1rGYw6xkY0siGNPqd53of7aPyxi67bVEbPdvsjkuiBjYAPZmJf2Mb3ZP/RjBGIYgOPMABDkiAA9a2gAg4gNEuOIEHXfACX/bSAhT4QAk+MIISYAAFb3ubET5RamiimnCS0M9+EPHqP8TahrSWMEhwretbyyGw1OLBIASKoqzwbhWwABGOLIuiIUzidkcMkWUhGzuoaGgSYjlCvUjRiaREoiYyKd7bhxSJh6WxKRFqBCNUMe8/aTTf+a6tKxalqMHLmaNA1bKgjpbnPw0SuoQs5J8gP5tk6Dvx0mhZbBZO74zqYjZjTgacntGxkG0DMvE4PepPP3FBj0xNUMpSNlomjWb4ghaq2AQaPDABj48ABWyNwHku4DcX+JIEq1JVBChQgreJIPnrMU8K/0lRilLEtYWploThiKURBxcd6RLO4a0rzHQ52MEO2LoJGWAwxjSKuEf0GjFZzmJZrsDLRoM4l1JgJ5NJrItcRomCIUyCP8FIQBXPw8DdQhnCjrVRICjCLIAe6EEDTCGXnIjPnejCdV2XucWb4eVC/+yC4hlNCK4ZmxGK33mebHRe/DRDxcjJzYBen0GcyDyGOqQe6lFGN3AJlYxGNVBDNbje66nJlDSGN2xD7M2eLzgZ9R3CBhzEAqQH8JXAp7UNCaBAFW5AMN1NeMQNBkSAF77cfxnCKVxV9R3YJUjCqi1YfxQCG/oB0c2a9wVIHixd+O0aOJUfG4hYUJCLOeXTGP/Biz9BhbYJRe10ArzgRCQcDCGSwb/USP0JFDpx3e2MVsQoUVEMAinwQiPAgoyQwa5sgi2AHpy8Cc9UoAUOVzH4QkddmSd5kgcaXHWJFGyRlAmSYL7ZxgkyHgyG3jPYwijswixEmTKU3jegnjpQRhF2ichYg8eghjM642lAow9Ww5P0oMdgAxA+iew9wzL8Qis4RyhcwiEQgcc5AAXQyjkdRNuAxwdAn9ykSqrYigh8AMm9FwqgQCOMIfXJVbDYFSLcFRuyIdExDq3VmvctXa4hJGDNyE18hbqIhQsEhVjATkTSBIxg4lk0TO8MVMIMAiAWBbbRixLhSIQYRY9dotX/Wd0nTMInkMIlbEJtiKKdkBkm+R3BcZLS6A9OFly9AcNJLV4uMhzO8Az1oAY1YsM2VIZkYEMyKNwyCAOePYOXOIlpVGVp+OAzuswzbuVWuozLRJzIeM+SOMNT7oLtqQItrcIntIAELIAEeKEDiAAKuAoFCF+qfMAL6E0v1eWtfIA8woDcsEAkXNU+Wh/hBEvQ/eOxtKFAyprRHSQd4sEe2CEeGEIUrAIpkNiEBKIRgUi7kJiF5ESEjF2NAMUQIAyHAIVY+Ag6NcJTGMUkEAMv7N/czV0jrOQnOMIqEAMsRAIgPAItdN6fyJsG3hlv+I+V4cL+4E/+9ML9bBnj9YmZ/80J9UDDNFDjNXBDN+xFDZ6ePMjD6dXgXmDGYnCDNlzDNLCGxUSDx1zDD5rGVpYGVz7jxrCJ9XxPkjRDaySSbOxCb5jSAqHlK2iRF0BaBCTAyNXK3mDAy3lQ3KycrViA8+3le43A/VkAC2jCVcGVgbkQsJxhI/yjYi5mQA6kY8IhSHiEivYBHe7BZC7diTxM7HjkTzBiuSDWF/UEIfCfUvShIZwRWSyFOQ3BQv1fUpiOjjBMJxDD6JDW2xECIhSCixDDKhDCHwhCK+AiMFBZnB1Kl24gljFNLyBenglX6FmnDBKj6cUDeH6nPNCDm8YDd2ZGX5SndgYGN3iDeWpnyv+AJTZCCTdYpaBGI5u8TJvIDCDBRqAE1W90F3IsBwOpAiqModW9Qg3QDQaUnHvZCj0Cn1/W5dtQAEKcEKzQihc+BQmMAam9VSh06K8Ay8/tR2KSqIOVKDbdqg15hK656IvugVuwy4SM2EykyDmdk2UFT0sqFGQdjEygE2oylo1MSFIcUcOYUUI1jJM6zI0oVAAm1B8sQiosHOUZHJX1hmzh4pjxGZqmaTHaoA3uxTdgBmZcxrzSq7zeK5kAhjeIgw5a3DVoiXme55N4JWpIw2rECSaN6bk1KneZUncZB6R4jaQyx3Gswh+YwAZIgAO0RzlKAAqUgPMln94oE19+4VvvvhcVNhMZgoKrXl+sNkLQIU5AzizR+Qeu5qqK8oHO8oGLGsIciNhXfJaFPIWGOBFX7MgpkIKO4QgTGEWOKIxNkNi6ZF1QeOIgwIJPJEWPVCspkNZCdZsh/AEljMIs1IaeBEouEJVQ5YJz+kIyREOgtau7vitgCEZjLEaVaCd51ilj7Ku9yutjWEZf8EUycgk2Yud5UiNqqEbPKCptYOB1/UYsRFlxVI2TLVXVBOjEUgco9AEI+E2teBxcUoB7EYStUAColUDJ3oqs1CODetAflMLKtqwmSILtOkIj4O72zSwhEMLMBuTNKsuK7uzOBgQAIfkEAGQAAAAsAAAAAEABAAGH67+g37KR262N1ayP2amI1aiL0qeLzqaM0aF9yp+Cxp6DxZp8wZyAwJl+wJh7vJd9xJRvwJNzvpN0vZR3vI9vupR5upJ1uo9wuo5st5N3t49zto1yt41rs5B2s4xwr451uolktolotYlos4lqs4ZksopusohosYVjr4lvr4hqroVqr4Zjr4RiroJhroFeq4hvqoVrqoRqq4VmqoNlqoFoqIBnqYFjq4FepoRppoJmpoFmpoBlooJqooBlrH5aqX5hqH5mqH5fp39mp31mp31ipn5lpn5gq3pRp3tYpnxmpnxkpnlXpX1lpXtlpX1gpXtipXlWpH9mo35ko35jpHxkpH5go3xgo3tgpHpspHpko3pkpHpio3pdo3ljo3leo3dUoX5mon1joXxloX1ioXxioXtkoHpjoXthoH1foXteoHpeoXlioXhfoHdfoHhcoXdXoHRVnXtjnXtenXlenHhenHdbnXZcnXRcnHRXnHJVmnddmnVamXRZlndglnRbmHNZmHJWlHJZn29Jm29RmG5RlXFWlWxPk3BXk21Wk25Sk2lMkWxVjGxXkGtQjWpPjmhSjWhMimhPj2VHimVMiWVLiGNJhWNOhmNLhmJKhmNIhWFHh19EhF9Hgl9Igl9Eg11Cg1k7fF5JfFtDfFpBfVk/eFhBelY/elU6dVQ9b1RAc1A4ckwybE04bEkzaUs3aEcyZEs5Ykc1bUMnZUQvYkMuX0QxXz8qXEIvWz8rWzwnV0AvVz0rVzwpUjsrVzomUTkpWDYfVDYiUDcnUDYhUDIeTTYmTTIfSDQmRjAhTS0YRy0aQywcPiweRigTPSgYPyQSPx8LNiQWMh8RMRwNKRsOLBcJJhYKIxYKHhQKJBAEHhAEGxAFGgwBFg4EFgsBDQsDGAYAEwYAEAUADQkCDQMACggCCgkACgcBCgQACgAACAgABggABwcBBwUABwMABwIABwAABgAABAYABAUAAwQABAIAAgMAAQIAAwEAAAEDAAEABAAAAwAAAgABAQAAAAAACP8A33B5EySIiQILfvywYWPgmzxwvkA5gSQPoR9B4Nh4IynNHDxQbrAYOdLFiRAoRZxgQQIEiBMkSLi4cWOEEVnAgimDBi7bs2DBhvnihQtNkC8+bgRR+uYNkqdIoEhE4iPpDR9IVrZg0eKqVZorad5wQdaHSRdmybY4sZWsi5ImWbw9ATPmSJgwXZ4AEVMmEi6FVM3KNayZsl+8EitOvGtXYly4cola1ChRoUJ65OipMwdNlR05ZIiWkaLEBgsSJqh24GCBggSwDxQQICCAbdu0cxcwUODAggUJFmzIkAMRojhxUoHjxry5Nm7bokufPh2bdenWs1/vxr0bNViM+sT/4fHiwYsPGT58yIHH0CdRtrKBAxdOXLZs1fLrFxjkB5cgCxRgQxD8FfQGHEsEsQRNLKwQBCGAuAFJHXwQFBdeJ3AQAglasUAXCCjJdJUJJXxCzIk8VQMNMUD5ssswfMxwlQsrsHDDU0th9VRSZHmFRAsubGVjVXR1dcMSgxhCVVVUyQXHIIIgtdZKHtJ1F10c1kVXXSBg4BJfJsn0hSGOnGILMMY8o8wwifni5lCLERWZKI84UplleuyxB2dpWDGFDTIAqsIIHmiAmgUWTOBAA67BlgBvtd0WQG60FWBpAcH9psADG+RQAw9xuLIcdNE1R92p2GW3jXaqduONN66G/6PNL4zEAQYPOOB6XgYoyKAEJZqIwsoz9IVznzX6VZPNQP8VZMIACzREUBBcwKEIHCvc0AIS1P73ECSKuOFElTCJsGFMInDYgg9QuACChiqtsAIHGvDhi05rCqPMvb4Mc0sylczAglk1rstjVVXNZaRabmH1xcPcigVVWmadQBYU7cbEFpZbdmyxD3X1FZNLZPV1whJPaqJKTsRAsyYvb74Js5tE8ZILKpFMYmdlhfzRMx+ceWaEEYCmQKihhia6qGuvPTpApLdRqpsBmSYwQAMq0IBFHLDch8023UT3nDbbaGP22WWzap3ZrJq9jTfhvCq3N9GkIl4cjdDRQw8epP/3gRmLdIJKKbdU05M1iCObHxyMO1XQAgM42B+1TTWFhONB2MCCG01JQnTI5mqo4YZ13bBXCOmeIC8HG8RgSzDNNCNMKLX4wqK/xqxixFU3rNBCtmMtPOVKZJFr5Uw8cmXkWFw1TwILSMCRVV9bdazxXGRpeT1LIb97glKVrALMic8YY0zM6AcDp5uqUELJJJDYaZllgAACdBpocFGFoCl4sIH/iFLUb34Dm9lADTdSG8BuDpAABwzAAA2gAXJuAQ6yfa1UbjubBrWhNrZp5xpug9vcuGMsXdQqEvGbQw9g0IEPoAAHepiEKUqRCmNEoxqJw081xNUULgxEBQNwgA//3YCHPOShctRiSLNMMIMgGIILIyCBCKYYAg5g4IqoYwsJNKQulpBAXhfQQAdUQYxkNKN8xghGTowBM2CoYUnPE8GVWjCl1LGFjsoLEh3p+LzqFWktfNSYSkhwLhJUL0sm05IirbSXLvHlXYYMgiRWlgtbsCIo6HsTUNQ3s1ZcIhOZqAT8dsYz+9VBDad0ghFmoIL+jcA0hhIga2ADqQNKrVIGyGUCCqDACmAhEMrghjU4eB1ubPCYHTTbfa7BTLNxQ4SvEoc4wuEqbjijFDmDRCUK0QMcfOABHXhBFA7hCVGIIhTCUFbiquHDQRjRnW+AHEOMoEppeSsILBhQEFZg/wMTmMAQK5giBwZK0NFxSIocyl4VTSACB1ggA5EIhhmVYYxhnCgowcBFMxoRhKoIFF2pQxeHRrJHK+GRYx2zUZCCZLKDpitEIhMZX+wSJrZ4sSUtcQkHRNCVJWxCfKhgRDCIIRT1pY9fbgoGLTrBCU5oohLvg0T87mS/PQACD27gwipbmYLSnCY1DhBgAmTzNKjdkjYKtFQAdqOACvQhGffhxgWxQbZjatBr2GBmNrRxn/ug7ZlzI0c4yEGOV/VEGdiMhCMOEQdvdqABHaCBEhrBiUhYIhXLOFY2loAEd16uPyMYwARsYATOEcQQhJiWjRgkAgxwwBCELOhAQ+DaQv9KcUMv5YA/JWABDcghF8Q44zCGC5ThavQUNqCJCAbaF9sykkoeUp6H7LKW58HFYi0QWXVFdlO7wGRDQMqeXcgll+aihCKgwMkrSsEKoSA1Zuoz6r1yYQpPfOITnAhlJTJBiala5jKmTIMTbDCDGZDGNIlSzQSA8yheSm1StclNANIKANscgAEdCEUz1AlCum5QO8rMKzOv0de+ng2wc4PHO8ghDsKKgz7ViEUkZhyIPXyghRV4gAdQsAVAPCISobjFNO6Th4oMYglHfAMLICeDGQwEEHmQhCIegqAvPMUEEeBABFgAB9kS1ErcC9m5RBBQh2oABa9IhjIOQ9xN+iL/GbbYgQ1asFwOYEmKU8zSlpqnlbWY4HqAHMlY7ojIE5groS6IqcXiIiQvdgwtbhEZXVzwhU+cCRrQmEZFMzmUYPDCqJ/2hSpGIQpSfMIT+dUEf/2biFbbzw1WMIKcZ2C0QiUqwQzmjQHNGjUBlBUAFR4AAxrQADAMq8TaAOHZQMzXEZO4xHp15txgFY94wIOwhE2HtrmBjFAE4hCFyAEK1JOBBmRAAypoQyMo0YkaZgNzBMrDIJScgAu4QRJvaI8hDMGRLwxiEEiwIgUwMHDYmqCKW4wJHYunMTxvaXUmkEEOUHFG2Vl0GG42RjL2IIPlSsABVLqzTfcoJK2I5M/E//NQV3S0luj9qAVIgkNMzGKyQ8aEdBvCrUyyN9NJu8UQq8hFMzANDcMIo83DLYYwiqH0o1v0FaIwhSlG4QlMgLIS8ZPff4GmBivsYAZFK0Esw7qopun6aZKSlAAsZYADMNDtcD/AA/pgC8O1WLB317a2X9UcY/LVxM8BrDQHL45pvyoccfOGNUvRBz/kqQ4oyMAD3O4BGUionKV4hVKesoTKMU4CCTDCG2ZgBENIIklQQMIXbiACCrjeihj4whJ2+lJzkWS7hg4RXSA+gxxQIhnPaMYwjHFRog61GZmwgaEjIAG5FG9LQVJeo43EApQPbyba8gEgg8SWL8ABZC7Pbv9MUUL+kyQyZDI516JdoIhV2CK4Q6foMI6+SWHYf+lMLwbGbzb1+nbCE56gav2ldZYBNHNgBU6gSrQmdokCVgz2KLxRVmmHVg+kAMOhAa/BG1SjAB3ACLxgOPOBeOAgDnrXd3ylTIDHHHCDePVBTa7Cd4I3DorHDdWwC4ygB46nBzCQARnAABXQASiwA4FwCaJQCqoHB0b0ToOgCD+QACZQEFzgTpz1PS5AcAN3RVd0AobAXFwUAmCmPVO0ElTCAdmCBnsADLEzfMQ3VMM1DM/QCjvAEhQgAeGlFiRhPBzDFSeAcqYjUkDCFiaRLhoDSEuwBImGZ1REfuaSe4TUXCL/JYhieALtJwvwh0aZ1CaJ0Qu9oBi+gApS5wlUNwqnpmpQlXWOQD9cpwZpUAULiDRKwzQMFIG0kXYTNgEzQAie8AqrUAIFQAC+uBsJ0AAvwAi7oCxxNR/zYWLZgDjUkDiI41fL9javAjbd0HfeME1x8xw+kQp+0Hh/MAYe0AHexCtiQAeI0AmbtxRB8BTT0hrzxAU/gAQ30gJadoVWeEWGEAR2tlOGBl0eY1ItwBAjkC1vgAatEDvmQ3wnQlTI0AzEMAYrQAIX0Hx1uEfS1zEmsCX+pC6GlDw8tS50dnM6txUNhy6KGIaEVEXkdy6wd2hWIgmnEHTJEFzEcD4woxiN/7ELkKELkBEZufAKo2AK5iQKo2BqowhVk/A+d1II9oMHWIUGgFICHoBgAtQ0ELhruFEAEvAGivBTsgAItUQAlZIADGAegRAKvCAN+oEf0yAN00ANb1kN1CANdEmX03CX1JCXeQlCpOJMzZF43kBX3HAN3NALluAHfvAHdTAGMNBNHRBOYhAIFYlHIrFPCcABYrEUSOACrmeFEeB6A0cBXABQQYAXI3UlHYJ9N6AQIWAC21IFmmBGCamQRLUMxgANhcBQE3mHezYk2gJmJDlF/mQCN4B6RhIEepQlKrElQLJdiaiSpCOSfUFFsAcvRSIJoHAKrZALuZAMmyRflzgU8//VCnHgCafgCaSQnkaJaqomgJDQCDxzGUCDBjtAGqVRKIrSGo1yALJ4GwfgACNgCKAACRowAGgXYWJZgWV5AB1IC81wl3UZoXUZDRTqlm15l2+Zl8N0TCqoeKvyNdgwTdKQCoHwbd/WAzwABufxAjjwjzCxPA7ghF1hJBgQAZ9JATaaowRnAooAj3u4SCm1WjRhAz+AAWTWAlXwB2g4mwtpDM5QDNDwCQe3m1uiMZP2m8xJRxiSJUqxFXT0A4BUXSmhLm+xkuQ3UK0lZuDlIcvlWlP0pukyCJIgCZ8Qk/cCnrmQSS0CFLZwCB8ACepJCqaQnqJ4agDoCaE0SvDZavf/83UL6AEJxhoNYHaWMouYkgAW4AEGMCkQxqlR0xsHEGwP4AesYAzN4AyomqqquqqqygzOYJfUoGwaBB1f0w3ZAQ/pQA6FaQmMcAiUIQc5sEKPKTJ25ALyWBP1thaYWUU4ugA5mqMDxwFFtAIbaaV7ZnJiwRASsFMrUAVTcJBMeiI2hAzPQAs2EAIXYAF4uBKIxCEr8IV3ZCUEJi8zMDx8hBKjg0UieaZdaF5cdFCwd0WigxJIkgeQMAmesJ3xpT55uqffCRSqAANhUAmkcArpeQqnMKiEWpSiqAlP1V8DmAj2owZVAJWkYWurwSiOYgBrZykKlEsF4KmRAmwVJik0/zthDNAHpeALxrBmy/Czy6CqQDu0PxsNbikNzZgNdFWrfFcq3QAP1iZY0RAKjLAIhdAIhYADONADKIA61molS3EDwMFFFLAAOBoBzgqtrrdcLKAIMyAvUhRyHbI8Q2oDNooBLeAEMNAJM5mQ4mpDztAMyVAFI3ABF2A8XGES5aISWAqQGUlHEbkCMrIxt7VTKQlTKWEuVaQh5RITGoIBKEEBGwJ7OEoBHGC6HDATQaAIinCwl0AJl6AJnYAJliC7s4sJl2AJltAJnaAJOpADiaAyFYuxGKux6amx94WolRCA/cWodVAHaLBK/eOKVVlAu5FL/AmzujZhAUCz3uu9E/82AHLHA6GQCz3rs8pAtOr7s84QDRhqDdrBHXODeFALD/AwTdlgQiXaanKAAy9wUF10AgVREDMwAgZAhyFwhaX7rJ8psBgwCFBgLif3pnomL0K6FQNpAitgBFYACMmQDAm5ZsZArsvgC82gBxMwhySgwfJSIyfHUK65cNpSfdXVZ8DJEjC8XH9mfYYmAv60ua3pT352uahDflfUmZ25UxVhCFLFM61WGY1AgK1WCInQCGeQAThQCJ8wC5bUCvf1CZoAgK/7f0yFqJOwX/3FM5shB/QpA2L3caqxAAzwGvzpdmcXYQ8GYWh1KbmEvQykAAyQAWVQCi2TH9OwlnGFoRD/+gzPoJbLeA3FUiwsOHguJk2IVw2wwKuH8Ad8IAPZ5cMssBShPC0GERxbRHA1ysA2CppW1Fko+aYZOV0sXCMkMQImYMuklQayAMIfLMLkKnzN0AkVIAER8EXUasssIDAptRYzrC0twFAN50900ZoeQlsYcAFmSlsX4GUDZQI75SEccAGoW0WuBbqgCZquZQR5YAisi1qE8M6EkAf1cxmGAAiXQcV14MY78AeVkGa+0AqESgqjkF+gSAqiwAn25bEAmAmTEAlY+weKSbIyMAKnMXZyDBtmJ4sORil6bKCX8kB93HaPEowZEAem0DKHjMjZ0JYUCg3PgKqNjJfDFA4o/2Z4hjXJ2WCYfdAHdDAH08UVA3w53MISF2AAoanK52yPrjUIe/hnFByJs9zC1EqtLPADqvQJH2w+IqwMjGw+r9ABExABVWoCfKYtEtOlhkRHByecBzecKXFwZyqw4Wy4VgQvBEVIIpAU5Dxw+CrXVmiPNlBE74wH+eaUhl05gPAGnOMG+dxVVlAIjnDSK4IKnlgKRWlqFmu89yWKAShKO1MIQMOKpXE0r6gABERLuvbRt+TRl9La14u9m1LSndCd0JAfffWq0hANzrAMa7ZmuP2W10Ad3cEd0xErL8YMoSAeYEAle7R5BEFHI8ABwXG2n6m26CxwFLAU0uzDGdlnI/8h1TUynKTHBTYACMBAUVq9ZoysDEOFAyn8uM5s1i9HF6azmk2dXbQ3nP6kW9Dpw4nIUFaEr7QnW6hzuq9nueSMhUlNAT+g2ESUVYpdOYrtQ1jlBm4AlSMgGmkA2ZcwC7U9DK5QCpR92cSLsYG6nk+VlKdYCHaQBvVpYFTJGmIVG32s2pRioGnl2mznaxvYABXgQoswC8CXadNAoavK2+nbvki7l2TzoRckHd2xgt5gDbCw01Ndr0bycmthuBKAAGmrymr71xyQFRrMwiSlFJkjJEaiwTZCLUGABraA3sjQ2y69DLugDIeQAWMOBU8SEl3hfUshMPv0PVq6FoNkPbr/5Zo/kJLpspHeDLqbK1DR2VoN3Jo7FbBzLc4UcAGu5R8G4kMOIRBOAOpOYOFuQLgZLgMdDAmXcNL5oQy1wAqUjQoYqwrEW7HGa9CohglgrDOJoJhosIoHdhoToDStYZUQKIu5geOsreO7sUAJoAAN0HYPcAam4AtcHbSpGrTPELRA6wyHjLTwyyrFzR3TJA7MkQ3IYAn+ZMEtUBBZkV0TWaOwgbZgDppqu2U1MdViYST/kZkFcZzMUgWoAMLpvRMvzQvGIAoacAHveiPHqplbUSM28K5cMcMjhX54fQIKYWg/jDoHV9ezha+D5FqkO1CGiwEWYLgpz+mcrlsnMAMa//wD1MpECyEaDGFgBiYaHpACTZYGfAAJYTwLG1YN0iAMrsAKq6AKS38KsmALtk68UifQouAJU8cJWIe1fDCfRVMoG6ABDviAqN3azG6guvGLBgTS2BtsFwYD5Tt03a7t7MvI7Ou+Mr1XJ6aC9Iur09QTvYDMI6FP724CEnDNOerlaVu65/yspRsCvSMvaL4QRDrAlE8TYTvANnAIaDLCdO7SQvEKL3ABpoNdd2GR7e6aKgcTZL2H5CeSjY4S/lRbAj46sjUCGCABF2DLpNuZha/45+xaI9BaPpyudC1b2zzXA5UCROMGgNAImvAJqhAMQ7bSyoALr8AKraAKqmALyf8ADNof9RmrsRlrappACadYGXygBlNwYFIZSwJ02snu7GVFG2jfqZPyNDcrvhg2Ca9wvqi6DACBTNmyZcqMFRuGTCBBZg0VHivWq5cuXQp/TYSVipGJFSxmBAnyY0ULExIocLhAIUIEBAgiLFgZgcLMmDJpcsDQ4obOGyB/2AAa1MbOFi1A3ujZ00YOYMacKlPWDBq0ZsZu+RrDYQSJFixEiDjhYufOFSs4FiVxwgSJr2xDvCVBIoSItSbokjDBIYQJE29x+sVwQfDgCyNQGhaBAWcEDBhmOlb5OC8HEyMEc0BpYTDmyyhTyHBiw00hSJ4+jXr1bFo11s+C1Yr1ytX/q2TPaKnCjfuUKd66T43ylGlSJUiJ+MypMiPF8hIbLliYEN3BggUJrCcwYKDA9u0DBHznvj3AePLjAZwfP8BAAgUf+nRKFV9+KPr16cvHD0u/fooNjx2LJRRWajFhBhZsCMKGrvgSAaeZTIqgAJlsamwmC//SCyyQkICCi59smKGsjmbgKQgffBgLqRlsIKUZqJp5hqpkkjGGFmI8KeGCr0RoQQQUT9CJhZ9kMOGEE1g4QYS0GLwrLrboKtJIt+YS4a0Q1MIMJQ08aI7LDUpIYQQkNzipsrwk2AClwkbgi83JKDOsMsNGoECCCzhIwQYn3ngDj0QgoUSTUUa5BUbV/6qZRppiboHFFVyeaQYVSXkjxZNRPtmNlE880UQ4SBopZA81ppABhRRK0AC66RiYrjrrDjggu+68++67AW69NbzwsuPVAFh9ZeCBOFQhBppqsskGHHDIYRYccZ4Vh9l0wgknWmalTYcccHqB5RhdTAAKpCAWxAsnxTAIgQPqHFvJQgvRpZIvEpDik4uQfmJhRBKLQmonFljoVwZIgAmGmBmTAYZgX2jJRRUZVrjSySNBauGEslJgEK8ikVSLLimdtMsEFrqq0kqUTsJsBMMEs8ACDzyAzoIKNNhgAgcmaFkDDWyeAGYLOPgqMMHqtEACoyVo1YAF7gS3CjzeACSRRv8m0eQ0VXyBEZrVpnEGGWFuiWWYZGzJTZXdTCHllEw15TQTShwxTo0dZphBhhE8SNWBm22m7jrrZN1OAFwHH0BX7nrttYABDmjggQ0WsWUaZ69NJ9tnyckW88vJGcfabMNBpltdYFkBQXFZIIGyxChQLEsKXILM3ccwg0stgMX9oat/+eILSLGQqthII01w4hRUWHGllVdWWUUVVExpZRZADCsrXQ50QkKpH2SwoSwpv2drrbgatHKvENB1zOiV9GZ/OgXehzWBA25NbwDyzsM/f/33578ACwp0AhfeUIeoKYJqp0ENMKLyDGlIoyHMQEYvdrGLWLiCFRfEjaR8Qwr/UgCnbcU5DhrQQKoU4C1mEpAOdd53HV6Fh3C4MtzheHUrXylgARNAwSJqAQ1uSAse2OhGNzp3OWhBi1rMkgYsfiGMjASFRDewC9Aa1Bjapas67oJMY1qHmbqURUUGMhILeBcl4ZXxX/9KASQuEQpRpE0TmugEJi6BCltUIgUrYJNXvnKiopjFBA/rS7rSxTqa1MQBETCJYCSwkgUYQADmAQAk+TdJ/tUvVtahTquMNp1FRsABF1gABfgiAwECgoCJMGDVgHOKWQQDKs7omkKWgYxjCIMXvKDFK1qBwbKpjYMcBE4mimPK45CwOTp7Dgr1Rh1X/S1xg+tODGVoAPVk/ycBC3CABR6QgTikYhnaIIc4sDFOIBpRHNR61hGtUQtdKCMWqSjFV95koaPFpJMvcQkhs4gTzJBvRxUqJCIphBmAsq4xKfFkGhIRCUpkIhOGaAQkHrGISKhiETJY0cNWAEWPnSBEK/jBDUQ0shbExS7ne0yd7KSXuYTgAi/Bpt4QeU+9XSA6OdNZTlNlAZ3xtGUjSNXLBLMBlW1gOSnQgAqIegEPMI0FRnADHgAh1T9NIhOmoYQnVJELYhgDGbE8hkKQsQwXBQMXtZjFLlnRiuaZLVO72ZQwE1GIRJjSCjNQQQm4ZELo2GyZCvDbr7Sjq8JJczvZEVwB1nOdxR2gPf+WKEY1qGENbGzDG9Wa1rMu241zcoMiyrhFfESx2MFuBzstNAACrkkdChnUoIqZSxU5QIFaFUC111wJBugyRXNVyGjUkYHUGDoJQkitEW4DRh1TULfS3YCgSlrBYAyzxdm6NjKBWaSdBCO0wRz0oBfwrgQ04xzBrEwznSmaYCqDmQ3QjGYjaNlyeDqBHFlAZSwIggD9hAdCGAISw8HqJETxilwEIyHF+A9EimGMZTxDGbzAxS1m8QoKszU3ajObpj6hiU99KlRp2IEMjuqB9hYtOin0m/xaKM1cGU4AilOPYxWAv8Y+oA+xcAaykhXOap3Tx9pAxi2WkQtXuKIUl2D/HUwPOaGaINJCjFGJTArKOoJmKV1TdleGHJRFd62kBIlIhCMmMQlDgDnMkchFMlohBxvI4GQYCCRfuJglnKQkyoVUjOwQSgHCpEQCQoOQTC6Q3TqtBIU4M9pzJrAA7YppBBsgKpdKMN7mkPdOIhgBgqIKCEMAghARtappKjEJTJhiFr7wRTCEMYxitBrBX1WGMJyCC1vQYsKtsLDzdIO24DT0bYnAgxucQDcR67WnLPMrM/22YsN5ZzsEgDYBbOXYxs0YfwG4lWPFwIpmZIMbzvKGN8BxWW9wQxq1WAYxXjGLWSyCEmp5iZRVYpJOBpomT2bX7DCDMthq0d+vpfOU/02iLkbTtRGOABUgDt6ISHA7F5NA6r4x0DEs/YzPebZuIfU5kzsNejDZtecEFjmd9cGkJotmZkwzOSEKjEAFLbNAe3tWNOhUZwJrWUF+3QCIqEUtooH6xCfEjIlOqMIWBU61MFr9i18UY5bGYE0wam1r2eS6rafQcNU08WtTosEKIWYOiSGdKum0qpkIYDZ3CvvsWiVgA1eoKCsmEYD8WVIBL0jFM3RcDWuwZjXIMEYzaOGKXKAiEJHAwCdhGu+aYHPxJG9yk7Xb59kGWqAmqVPs2hUTCkBAJYOoRCaqBglJGGISlLAEKpqRDFW8YAQhgMACIOACFnQcQvrES77Tt/9loMlrLVf2Nz8ddBIRWAgsOJFTMocmZXO53AQ/40DMxYtyAwTAABcYpZ7UsIeoSc0RjggUJz4hfg6qghao5oUvhLF+pRdDIXrPRi4mTAxi+OIW8l+3LCysNrVpgjhz3QM5QIMqaLNTKbGd8isGYJUFACwWaqFoqxXw8A4DmAFIIIVWyAVjsQVnihVeYY8H6AAcOARLCIX4KIX4iAVfMJhcyAVgEIVOKIVFizLcirwavLyUspA7sbKvqK7YkZ2TgAyZqK6ZgAAIiIA82ISrIgVTsqpJsARRGAZosIU/SAES6LwF6Ak5u5N9IigMmKlEqhODYqmg8UGMizIny67AMLT/o/GrCeC8OrkASBOMTxo0CHGABPgOBxilGTACLqgDPqCrQjg4SKgETeAETzCNTyAFVGgFWrAFXJggXlgiplO6aciGZ3AFdguGW+AFZQgGdpMFW5iFtlKFtPmETSAOUOGDOqgDNDCCYiMxEkNAveGbvvEbtNMOaCMsA3AAQCAFVZCFZqgGW4iCDuSVX4mfBGAAl4kDRriEThAFUTCFtUoYYsgFVhCFUJAB9Yk96vC8e1MJLeKnK8sSfxsBKLGLc+zCLKMiKulBc3myBbABRNwUQqgDNaiESsAES9ihZOiEpmIkyoA0zeCMC+iIk4mJJXtDKsOydgkBenLDZULDo8Gm/7K7mZtBGpE7MXV5KZtQiUsyyBZYkSpQgzr4AzOLKEI0RHochd5wBVqghVq4BUicoF34hV0YBmXABVagsEccBmPAhVzaKmBoBd84BVA4xVQsBEAIFTUgwGI7FVlsmQroq2VqJmcqLbUzAAlQgTw4hYTxhA5QAMSZoRg7AOtQABDsgA7wABR4gR6IAz8wBWCYhU4gQVCwgUArwnOZrdk6F+qynioTgRWQJxHhnSqxssDspwapIi2igIpUAU0wjUx4gqlKwk8oOqmYhRzYAJiKwwzIAJ5yjpahDPBaGaM5L0VKNN9SKZ6xk6MxGp6hRaRhn5iyGQVsAAZoAFqEOei4Jv/WgQAM8LwFYJxMOxAjSAM3AETjggRAkcxEPA3eQAVVoLBYiAWZ1IVbmEmwgQXkmQ1awAViCMpWOAQ6EIWxQYXmwToOSspPAbNCwINWfMXPCBO9aq+eqsqUc0DACY8EiA4vwAMLOMuxJEtqOsb4UQDcrIAMWNAO+IAX8ANMWIRAEAVg+AQZ2IA/W4nZ8kgqA68u1EE60wqV4YiyGCPDoDOVUZmUSZn10goOMJoNQIFMIAVT+IQrmAFF2ARPqARPQAVjgAZgkAOcmQ4NYNAM6IAM0KkNwJst4YAD9AAVpRkmLTGf6s0vKYEszdJTKQEUKAEVmIEYmAEgoBugUAIl2IH/KCADMriCK2ADNnCDOO2TL6BTEChCCHCpBdCAGfgBIzACJyhJn/s+QClEekREUWjJ6byg2bBO2LBOCnsFnrSgVwgGmCyFDpifB6AEW1gFU5AUX9KUTZiEDks4UamCHTCCuuHSWKxSv1qmZePPAngxFyqcwcrKacqOWBlQBYQfBTgABviARbAEVghSSPCAFIBRCVCTgmTWLNFBFU1RvsCYNllRznjSKYU0sYvSMBmBMHkOl4GEliSFTdiETyhUTwiFXOoEOtABpUoBGsCBHMgBHeAeI7CBKuiBKhAhfXWDARogPAi2OtCDPdgDPviDQkDYpUxYhOW5POA5QPiDPwAE/z4gWDuIUzewAzZoUyWoARqggRhQgZDNKy7RGZwowiMAARJAHQmYgSv4gTfow6iiK0doTkARPUPcFE9AVFMwHl3zzv1InkV1BVVwheR6BUZgAGzDtgM4BJ41BeehlEtBRUpIxbkKIS4IDRHjUr0isWQ6sVYJLP58pPJ4sQAwrMPqFcGpVcdigAN4ABSgg0gwNWhIBlqwhA9AgZ0iMTDZWpVJAZE9qs9YERApUxswgirggjgVID4BWP6Kz8aVKqnyNEKg3EQgBDzIgzLzBA4yBUj4BEgo10zghFJIM6IkhUpoBIV7z0LgA4Cd2DkYoSp4AisoAiNQAhsAAhvw2BiAAf8VQIGXYVLQRFIjZVAT+1r2aYDkVV4FZF4GbMAUY49rKkIfEISUFYsLCAJDIAIuSFyq+jmblUxDHAVO6ARL4Q3jKQVUSIVF7U5VYAXcuCBWsAWygQG6258K+AT4nZRRYBvJdBv3nNj4dMW60dqovM+WUSYVCtvBKg+6Gw9dJKzCGpzx+A5sUw/1aAAP0AJEOIVXqIXZUIVR+N/gyIRK2ISqCbpyDboUJldyrQRJkARIUIQZboRGgCgbVgRD6C/KVYRPsWHLJQSm5AM7IGKLdQM+dYIpKISWPAX/K2FDJLqGaYQ5iAGYaQAGrYAGqIAKWLTkfYAHYF5efZ8xfl4yZg//Mh5j6H0V+YEVXW3j0orAWiEPAUAACACBI4i9K7kBFsgDSQDQfuWvMBsOq3pORCSFTijflpROU0jf9bWg+FBUnrQ1VUABSYqk9AgDRc2gTLkUTemUX5srU0oDAmwzGVCBVR07RbPKZjLG+4mk84BgAgicOLYVB27gSFqcCmgDU5AFC0KFUqiEQmDFEZLXHMABUw5ZLz0mmfniB3gfBkDjBH3m5MXN5E3jNsbmNubABKgASHAoh6oEhrKESIiERICBDnBmX23jF8KVBnZn+6WkeJbned6fAKhjEGiJBdiLG3iDFdgEOOjXqCouUMtH0TtERD7U89Ug943fRimyh14Y/0bIAN1cJr3BFVgBA51FBZ1FRB6thPHzlEaYK9aVT1WFxRLDGVVxnzRWMe2IVWcrgGiDNgGYacPqlRhTAC1WgT+wy4nagx5IAbZ8maEG3rFLFS5+AAdogATItmceY+eN5gbM5lgZnPWoAA+YH8eqgEYYP8yUI0sA607AVFixZHo267NG6/xRW/vBlZYoQrdeAEwLAiTggEGQBICW3IOjBKp1qOcsX51VZA3CIPmIXwqrBVx4hVIIhDjQgz/gA0BAhEZYBCbwAz84BHIutafFulHw30vplKq12joY5bpRVWPLmZaRjtx0HwfsQMOS6Zo+2+wwywG1gD4Y2DqwArvZgP/e5O2+KjvlVWdphmY0PkvBop9bhmdbtuXFUQNE5A1RKIVojO4KYGvzgOe6u+R31u7t5u70aGC2nmALVkDH0ua3bgkQ8MIRaAEPuR5QGIQ3GARPa87QCz1DJF9EhEZF9lRJieT4zcRcSgX3FfBTaB5JYQWwJkE2QtQCN4VRiMZB8SD/i4TvE+mmPNUiqAGtNaFWbUMH4NU1bulbDQ9athVo0spcjZ+1fBnUpmYFTLkw1k3d9OIKaGYHeAC/2k2K9vDcHO5nhnHltfEJ2OIr1gAYiIE9uARiaYYlX/K6NecOoHFo7nH4Ie/rmGpYiepg+eIKWMsPeFAc4AEwAIM4iIP/PvCDQGAERogEsKaPUnBzRVWeWXDE9DOGYPAFFpQFF6jjIgSBEGCMH/gBMYoAGM6DzDU9b+YEg/aEvx6F/E5UA8eNVJjO2RDFtmoFU1iF/MU63jhB+wiFN8eNXWrJF0QbB28bqp0EuGFd2NXYuTnlvZVK6VBpW7RyspQmWiacE59tFOD15ZCBUoGBYI8BGijTHegBY5eCKZgCNBgDNJCDOpCDaJeDZh+DMVh2MkADKegBHZjXHODdF4ABcH+BFBj3tuR1Xgd3vPUAGNABM0AERH5zNy8FRjgEPbD3OKADPTjzQ1iER4iESXhGRD2FUMc1dpvfXPCFhEk1A+uqg4GK/6hgciZ/homn+Iq3eIuPBkSJBkhpBlmggAAgADvFAK+QiRZgkxOIgBsABR2eYZXMBEwgX4SORsBmZEkh7AuaMFVQBLVhHlkIRVCYYVBQhVVghVTYD4oQBl0oBmHYhfV1HlToBFCN8F5DOJLeAzogAymgAd/tUvs86pR2VagOLGMUcVmllbVeO13plWgfg23fgR3AgSiIAh3g9hiIARmIARzQ+3iVV22v9r8fAzmYg8GfA3vfg0M4hDBrKNFDxEGpUf7DDebBtVaYTlxbhVmwBbXiJV1iwYQBhoRPePo7mBlZ8omfitNHfdRvoNNvoAaahteHfWmA/dmX/dmffdaghv/cpwZtsIZpmApZgIBICnkQoIydWIC0UAsSGHRQKD3nFD2YR+TyffBBSV/1jQ+exDVV+APAYp7u93lFgIA6doFV6DZlAYcjuhZwOIZGCWGeVZtSFwWO3jr3RNg/qIMzKIKtRwGuf5meQsBkA4gFAhMQLHjAgIECChcqHCDgocOICwcMKIAQ4QFGjRxFcuRokqVQIkuZQqXqJKtWKl/NatmSlq2YMGPGzGXzpk1fuXTyvOkLGE6duWzNggnTJktatF4xfbXTF1SouYIBC0bsKjFlypo969pVGtiw08aCHTu2Gtq0aqtZa2stW7Zr2bTRrauNG15w4faGI0cOHDhZEAL/ECCAAMKJEDPe3EjA4UQLES0kkAAFSpGkTJk0ddLEuVMnUaJHjSqF6nQqVq9csVJl6lObBYNWgVplW5YsFxAQ8AZRGZpeceTSwes2Dt62Y7BSjTp18tQpU6RIjaL+iVOlSI0SbQe0R82UHDhiqECBooSHDRs0aLhgwcKECBEcOBA4sGCCiwwnUnwogMB/BBTw0H4F0HQgLbnwghODDPoSTFRR5YSTLQzagksuuGi4IYcd4hJLLbXEgssttZQYIogl0nLLLi3q8mIvvwgjjDHGIIPMMsw4Ew2PZVFDDVtvwUVXXoDpFY5wfim55JLpMPnkcH6FExgEhRkGAgQktCAD/x6DLEABCS7cEMIPErxB2yaZfeKJJ6CBJpooo4hiGmquvNKaKZNIYtkqstjWpyySQLDbYaAcAcEFmBCTjXDp6NJNPPCEc0wqp52kymmmSBcdKWtmAokjkHRXxxlT7FDDDDKkkAJ6HrjqQXvvSTCrfPYtgN9B+jHkkH+9+irAQq4IOyyxrsQSS7HGwrIss8sO2ywrrDQLCyupTLvssdlma+KL3fby7S+/FMMjj8www+OP1lyDDZHcAMaXX8TBMy886dh7L7756usklOKIYyQ3cFUzjTTRdKXMML/scsstqpyyhJWFQYAlCSHY8MYgI1ywQgsrXHCBDRcYcsonm4Dyyf8pnmGCSSciiSRaSaUYm5oqeyiQ3wKC9AmoLEcgYNiVR4BAQAAGsNBKNsb04U086KCzjS6hlFIKaaKFgkkl033yiSaVgOpII4XwUQcaO8iQg6ojoMdeeuy9NwHcE9B33wI3E3QRQg35VxGvEFFEEUPTaptit4V/e7i4xRyz+I3ImPu4juRGA1a6bc3VLl7ceLO5N0eOI85e4tBrLzlJ7ks6v/GeTs6U4HCjTTZtUVOwucgc88uLy6aSSiiWMMJIH8HHwQPxPLzwAfLHI1/BAxXUB2BhAQRw2MQumOAEGm+8wfENNmhswg8rSLLKKZalzGabL4dWGiqsxLI7K49c8Qb/Bl/6QIEifQIDytCFIQDCEQxFKAhggBAfSAU54vEOd4jDGsIIRSqmVorRaAI6WvNEJihBCVGJjWxVqIINUpUCE4yAAyVAz3o0AB8LSABuc7OP3fJjABkW6G82tCFDKPejH12jh+yiyza2wTlvhGMcRRTH55IojnP4xWnoeMe80OGOKbojHgp8BxaxSEUqYjEe9YiHvaaIRXtZcV6lcx3oABMwtBTMGcuwnTB+UaJYUGt3pRCJJfL4u98FQnhxAEPxjKe8DiCvA4Y85CEzoMgKVMADhsxABTQQgZ/x5meEOYwPBPGFIKhBBlxAAgtuEIQqyIA9JghCEDbhp/J5QhOb/4HTBDUlClW8r1KdsEACkACHBURAEhSIAKAEAQJKHuYIARzUYX72gmzAYx/7gIdwsvGL1EzNFJ6ojgWp4wlObMZriehgGtSABiPYQAaqWhWrUKhCt7XQhS+M4d3ytqsb4nAh6DiH086BT33y857oaAdAAwpQdghUoOw4KEITKo+DymMe80goQuVRD3pMdKL0sMcC6UHRd1hxH5HixnJ65zI97rGkjAhEIH53iJWiNBCHCIQf/IDSmMZUD3Sgg03jMAc5hCEKOYDBC15gHvN8wJGGfJWr1uOBFMCKA7shjGEoOSgIBPALNsiBDYLQghYEwQlpqEIK1sOCILxBleTbhP8mPiEnUYRiTlNLhbBSYwkVzCACBKAAKDYhCJ3hhn8ICIAxIbBXQfiVUAvYRQL54dHSiYMbzFhOKkxxiulAZ2py2mYrN/hNQNQBD3XgghOMIMJzpjM9SY1VO+VWH/vgR4a6omc96yHbesyjHeyYB20dqtt6AFS3ui1HOSBq24O2Qx4LjSg7GnpR4AaXHetIrnMhKl2CtgOf5DhG8V4QvO36oQ809e526UBTmupBDzCN6R/8UF6Y7mEP5aWDHOYwhzOQQQpR0IEOYoADGtAgBv6VQQxsIOABz8AGRggCEnRDtIhRD4CD+gIXUiADG9xAlFWowx/GAAMLcGAxeRifLCb/u7XqjMIUEyxFLFghM1XAQHr/IYH+cAOMng0QgCAgLP8GWAlyNFOxTTuHO9Ahjse2Bjooiw7VRLGmNXWNg4AoBGfVUAXRyiBVpD3hCU/7Hve4k7X4wVtCGgJbitijH/34B5rTrOY0z3a2Zu4HPuDcj3rMuc32uLNG6eFQ487jonrWqHLzLGg9+1aj9eAHOrhhCeLB4ANjGEMPIp2DSI8hDpZ+dBzkYAZLc/qmcbjpHMxAhjKQQQ5yIAOqe6oDKdg3v0B9QQxgoAKhmicFKri1rWVAgxkI4Qc+IMFfpSc9/yETSwiwqq1/wFUnuGEP39RDCS4g4TdgZmeTJbGJZVYt/1bMQhUqEIhhQIybvmKJALsB4BH6msz/VSMd++CHYvfhjnn44xz1eiymooMpVGhqFFvTZpO3k4hEAAIPbuACOclpTnSOoOFZhpUG1sNC1a72VgbJVZgLMOYBrLnjHve4Pv4R8pB/PM36ODnKT+4PfazcHy5/OcxRbvJ7vCMdzuhDHGpQnkdHOpCR7gHxcCD0+9YgBzUQegxygF8d5KDpThc6DoCKgqCiwKiIhCTzGLlIRR4SBSOoEgDCDgBhm5uSIDi7ILigKlQigQt4AEQjIAGJNNgABjJIQyIgUYlTrKIlDtOUaVxRilTE4hWXCEABIOCDL4zvFOOWhQ8GiABQ7P8VFIGKKgIaQY59/MPH+5ioPxR7b2qR5CSoiI50SCGdUWQWbKL65tjSgAbQhnDh6FzVw9UJH4rf5+K6ErMNRS78kQ+/+MRPOfJlbvLhJ1/lMH85P0Iv/ZOrWR/8AGMq+mCGGJxQPFCP+qtpPVTzuGr8SN2AaV+1HqwrEpIPaAADGPD+BtAf/vJ/AP4Zif8OWIAAYg872VnJxBiTILyBgN2AJAwCFzyZI1SCJ4TNH8yBGvxBI3TNKKhCK8xEUfgCL/DCL2AIHYzdJX3BuPUJKOyGYezGEQhCuvWM/yDALcDDyXlUPPDDP+TDyz3TkNlRazgMdGyKiHlCJUwCJGyQwPH/wR7UgRu4wZQJmDnZXjo9nMTBTQutVmslwAHkyjz9jUbdgz144T0MWhfeGRmWoaD5Fho2lHGtoXHRwz2cnJ7dWZ/5VkV94T243JzhAz/AgzX4DiLcwR3YwUyNFyGWlx/8QXvVQRIuYh0o4RK+QR1ozxIeHBpUgRVcohOYygzAACemAAp4IqsM1QtwIicmnRM4FaFUUvRIz/8Y0xHkQRDIwA1ozxvwQSF8RNdMwiSAzUo1QiRoECaYgiq8gi0QQ43IEWt8wgmQAAouQB7Iwv4YirENiisKgiQIjZVoQDXEw8llkTvkQz7AGT74Q81xwzFIDUlMBym4UtasCSc0mUds/0chICIdqIEbWMEOWNnt4V6rtM3b0Idq1U1rYVzG0ZMYsiEb5lmbWRQaApQ84NmgOZSe8Zkb6kMc2sMcSmSe3QNHvpls7UM69MLv/GEbtMEfIKJ7ISEf6EF7lRdLqiRL6kEjzqR80aQjqoHsoYFOWoEUmEoOxMAT3poK7OMokmIOGEEKrMAX7NWhTNVfScwKHoEPDMIbGEEVIEEa1AEgJMJHDGElcAInYAIlWMJYdgIm5NEldAIqDN7upAYqFILJENYgXEACjICfCBBvDAoLMuXZnVshTAM8+MM/pEMWgaNsCWY9nMM4bAMy7I5kXdsoUILWbE0uEqE8ekdn3SM5Wf8ZFLKKB6iTClFhQNaNApQmFhIkf1BEGq6hbvFZbRUUbAKUPhkaGvaZngVUn+nDPdimGOaZHdIWbbUDPHBDKKRUIOjBp53kHgDictqBHSznHbRXS7rke8nBTcGXfJnaTu2UGjwaz0VBD+jAeOAA2gTl7d2aOeWA2RhYlRGCJLDgxPTlxDDlClJlGhhBGuBBIcQdJWTQJVyCKLiJKOSRJbSMy0hNBKWCKjzCzfwSbvwAHiSAIsiCMBETVeml0FijyXjCLfAYSNpLPXzhYd7DP8xDObxDcrhldHyCKHjCZHUKZWrGEILNN/0BlNVBGliBJuaACKETlqXHFO7eO5VmDBH/ZJhRRHElqTwkqW4x6RY96RbhpkMVFG7Nm5S+4Z9p1DwE2kZ+YTs8FDqQAzL0we90102hJB8goR0oonQmIU5Rp02Z2nXK6RyggamZGhqMQRjoaQ+AJ9MJHY8+oQwMpQro2gyoZ0+Wkw2kwVfBQVxaoyRgCbqtoCAQgn2+wVY2Qn9yQh6BRoG+jEgd6EiYRiuQghJIwAVIQB6sAiGoQAk43qH8DLG5ojGRzw+WgjQQh73AQ4jeWT243D/YAzuUwzh4gzP0oGR5AilwytYwmWcMIagM3MBFGRqYShXsQDmRFj/6o9uMZgOQ5sWhZgGcA3XF5kCZa2/VVpMipG811JS6/2s7/GpuTVRtTlQY0sNz4RNxkulx3mma/isS7gHAllcdzEEjGizCFmwd3Kkc4CROMioaWMEYWAEZ6GgVSMEOZOwOMF3TxRonkmfT9akUYFUVqAEfEIIibMIqzNh7np3LrqAhKIIh5MEbvB1XUsLKWEJaFmj77M5aHugdoSMqzEIyJMMpqIcKeAGgAEOkVgmDTR7/SEIy3IlzlAIsgMNwEMc7TJQ9HBo/4INGscM5OMlj+SzVZFOzakIrZQK0bkcjbMcfFGyO5mh4cKbtZZkG+CN80MeQ4grGjavYlmt1Be45qAO5IiRCJpcaKi4b7lnjTqk7OJM7xCtv1eY83IM80P8DO5gDE0VD8KiXHpiayQZsmrbpdM7kwdYkTTKqGjgso8reJV5iFTgB7RqB7RaBFAjBqXjf9+mXDkTaFMwBIBjCnpyCLQDD/hzKy7oAEhiC8ypCzW7lL67Mzr4CKgxFMMiEK0QQW7WVabxCM1QDNMjCFmiCKmxCM0BDMuQYJRENJQXQEUjtLLiCa5BCKCyDvUDRFFVUvOGDr6LD6EXQ2WYTjG7N2hJhqNAoZsoX3eajOemjZ6qfCu2ean0ruOIKQpiDOmxwdK0DB3vwBoewCG+wPKyDCa+hCaewClPplLKDvH7plu4Zb4Yhb5UDOXBDKmBBScKXHJxBGwCic64p6qL/7k2hrnwdsQTK3uvq5BnQl3dawQfNrhFkbBEUgRIUARDUwK7tGsiq5xT0gBzUgSGYTJ8kAzCYsdAIDQD5QPPG7CYYAiHs5yT8ZyforCgQgy1kLwduCC3UAiscqCsAAzRAQzMU7SAfcjJUKG9Ez6zGbzPM7ypgikhoA2EukDtsbT141LuB7Tg+UzqULdX44Iuqo7+t7QZRwi52BxI2ojhdK4/W3qqozWfqHtwIqQN8qwJc8GmO8AibMC/zsi+vgxoKswqH8JRS6W35g+bK8JYKWj24A22NAzlYQx9gQRfcARuEwRloQRsEcRA3YhLWwXWCmjiLs3y1buuiARmoMxnQ/xeqkcEYTMEUjEEVTEEVKIERCIEQVHER2K7G4tcOQLElykEgVEIjpKwkmAw0Im8an51UfgHxbkKaKAJ3/GJaXkIkDKMv2MIwdGCHuILLoEIyDHIzpO8hi6/6Cs0iE4awHQYAgUIy2AL9osKAMoIuDAcVzZYzvVv05eC9ce9zEPB0+JunVIJmWOZmAcLYzEEDb+Y5qU0KyLLEvYctW7BAwNN0sQMvlwPnGi5EqYNwFRe7LvNwQa47sAM9+MNDaWkMa+m7nVw5iIMuYAEgNiLB2kEgOudMhrPCNiIdzIEbtEFgswFhF/YVnMFhb8EZbAFjbwEVPPYWPAEVSPYV6y7G+v9z0wWVCgSYE8wBJeTCjBkCsP3MxEiCC7i0pC6ehm4N24IKMNZxJ9TEhRxLiITIH0sNMZC0IRNy+pqxNPIGVC2YS+tMMwADLaRCgEbC71hDOuADyrncbInR1vpDJifaOYaCZJkGBkGCIpwMk8moBr0elPGBUruBlG1m7Q1lP7aNCmXAe1SAC9EfA8AfkRLEAfwyRPGTfheuCId1CZ8wn1EXcTnUObSDOrQDPtQDWjcpbtFDFe2DRbpDNjACDwTim8okHeT1mtIB6sok6pZkGxS2iDcxiSt2Yz82E6A4E6w4ExRBFPTklLmy8aCACtDAFrgBJLQCUADDKRzBgqkgCPj/gKSenQusICgkNNew7SRQQiQ0eYGyxC2siInEAsPUAixIDS0QcjKU9CGTdHE3rSqu4nDLQjPkwiwg9yU0Qh/BQji8Q0WGXkVl0XR3rZAlRyjUgi+4RittQncbMFi6kmZsEI0WAsEZnBpYwRQ7tXr/KHtbgAoxUnzXX30nwC+DtdjqN+fu9wZrsKUTly+rQwofV0AR1ENptQvXg2vG8ERFLj9Y5HV9AA8453W2AYd78xD7dSOaWkmKOGGTeIlTgWM/NhW0+IrzcxGsuBTE85QZwc8FFQ08AR84AioQY8qYtlQhgJG/ZxpTqkSnSVrloiNYgnIzAgSxAi708S2AyJVL/w34pm8hFzI0oPRIA4MwIZOsEs30zOcZ20IrlEInRMIhdFcfOAM5nIPLwZtsSfd0l6g7+IU56sIzEEMpTAfbUgdRt5JnuJKgC1yh18GhO0ETzsAMDKWPtsp6TLUFMA/+zV8DEGkImwPMx7zMxzxzlYM+bTqnc7BW9/JzgTVAgfVDlfVEpbpvwZs/uIM3hMIHwMA4l2Qj2jpNHjHD7jqvs0ETn3iKD/uw83OLcz0T9CQ9+3OkoUAOFAEbJMInqIIozEIuZMIgYMmwYbu4HfmRS0JC59UmGDDXTEIklEItlEIeIShrsMYdWe0zdLmWx/sgn/EpyCehiPl8QmMroMK/n/+UHuBcKGjD5sEbPyS8dP/qP1AUOvSFNxTMNLyCv5HCNZEGUaPV2mZQKoMNIRScEoaTFYRWeg/qtp7WBGed89wyfb/8zM/8OBR/8dc8V8N8CB9Upe+8bQH9QZ3wnS2UGsJwO0A3OUTDjMsXiNM6HZSkG2w4h48z6o44iVt9sA97irN4Fe+zsbt/FOxAD/iz/EcBCuCADOxAInhCKLACN4QDQKAChAABAIMATqySJQsYsIULQYGSBGrTpk+kSH36hApatmSWLEUCyagTyFKhSjWrVg1ay2bQXraEBiyZJBAQcOJEQIBAgAAEjwgCtYqUpkiI/PTRowdMnGPi0u3j52//3jx37tBdnYfvH7159c6Rexfv2jRfqDRqIjVqVEaNFj1p0pQpEyVIdxslAgSojps6c9KgqWJDRuHCKRCXUOxhwwYNFipUgFzhwQMHDRqoU2eOc2fP5saFFh26XGnOmjWzY4eadevVqjmvW8eOnr157OTNk9eOdzt9/uKRS9XhQ4czasy0acNmzhw7bdy4odN8Tp06dOj8lTOHTXc2Z85s2RKeChPz55kUUS+EfXv2NYTs6NHDiJEdQnToeJFCxg5IjCJ5hhxyShmooINAeIimhpJxSBZQgGlGlk82AeUUUk5pJRdWSiopJJFCCQUVYliSCSZokmmJpWRkOQIEEHy4/0mnngIgAIEjjhiEFEocWSSQPpTSgwceGLEmHXimquqqrK7yxx597rEHn6v2gUebX0QxpRJO1mLLrYs0imuuSiqxqxFDCAEED0D4qEMNwWyIk7DDUhgBhRI8yPMxCx6LjDIHHPiss9FG+4ZQ0crhrLRz2BFUM8/UUQ21deRRR54ocdOtN3b+8QceauLIoIMMyDjDDDPWYEONOdzwbg41YMVuuldhBc9W8ajYojz0ikhvvRqAha89YOWror77dtgBBv7UcKSPVMAhBxxU4HABhAAOOkIhWZJpZkFBhJpoFUkGUWSTUy4khctORAHJEkZACsUVlUysV8VqJATFBRxxlP9xpxoRAMGFQT5ppJFDkuoDOxhweKEWb5D0h556rnrnnSafhPIefPzhp8poUilFlE9OMcWUtkiJCKNRwpxrE00qgcSRvArRi4893BTMWBtmoFOFOxdzzLE9/RTUnHMODe0bQ8dhuulvSiPtHKNPOw02zeahx9J77sl0t3ZU+4cfcnT54IMMKhjDVDPOuCINNbxjDtZVqaNVjfFupSJXvc0rgr313qMhWCH8Zq/Y+tiLQgr+ZHDjkDiMAccZZUSBQ5BrASAAAkEUoslbFvkVRBJBkPABCTgq3ISUmB15hZVQLEEplmFWKqaWZ7JZaRqXVsqmJRYlGV0Qfl3cycYXDdn/JJFEfuwjjjjoQOGFF/qghpx9JJ74qu051keff8DveJ944AE5lE7QNRkjlVduOa0yIclreTbbfFMwI3g2jIYYfr4zzzyHZgHICCppoQENoaI2jtKU4xwN7AxqJDWpdUhQHrKRh1fkgRvVnKMdwBEOGKQwAw+o7VRti07culMrujVHDWnoTt721rdeMaE8hWuPenBouClMwViG24EKZGADPKAhDtkARyB44IcqXI4gEADBUBTELVDgaHjgcoEPfPCF4EnCEInQAyaIMY1pVIMb4DCjGbORDWMgYxpoTOMYc+c7YIwLXHUU3REgQJCACYIQjSiEHwKRFD/oQQdiCAQj/4qRjnj44x7z2Ng8pOKOekzSHpWcpMfIFw5khKgTbBmFKGAGCYy4RUxyqcQk4ic/m/0FDVbQWf4Qo4L+oQCAjOlABwQYGXM8ijMFPNQCkabARTnwgZFajQRlk8wKUooe9Mjg13jDD3hMIxBxeEIKUDAGMrCtbbBCoarmZrc0kOGF4dEV33yFQ1+5h3A4xKEUdjCFY9VABzuQwQy4YAQigqManRikES6HExAIBRQPecgR9iWIhOLIB0GBAxSqMIUxOIIVvlBGNbIhjgENiJ/HKIYzshGOcJixGnDMxjNycQrRiW4iwRteHhHgA0kAIhF/9MNNlwIGHuiBEaHIBpLowf+1e1BlH/iY5FGP6jF3hIUbzBBZKTwxiriQIhOj/JIn4pKJU6aSZmz6y9sCM5ieySAG/FPBC1BAS1oyRgN94mUvfbm00SRQmA2cWjEjtRlkJpNSlHIkPXizJHTEIx2xiEMYbIBNbdqKDVzgwhXAOTfw1Ao8ZFAbeHClt12ts53sLEKwgGU4HeQAf3EaLWJsYAI07KEayeBEIviAhMu5aKDbesgqQPGifoGAXw0VxBegcAMjGKIujohdKnSBjGiEVBziGGkZm0vSamijjNPIhSYaIYlT5IIhstiiIDCwOUXsoRA328NSkjKkOByiD7pQZD30UQ92UMWo29uexfDBD37/vGMc5PAGM0JWirV4ohOdsCpGNBImrdrFETJbXnlxZp03OSFOM6DB/mIAA7SmlcNstcBbD1jApRnKaUwbpl0b2BrWKHOCfcVNlG7DG3SQAx7ZYEQfipACGKAgDGTwMWS9EOQrHEeytvLxkc15TvTIkJ3sDJbgiDVaOe0gBzkAogckMAM5YAIRiCDEIMDVLwgcISIPiggoLsdbPDoxdOD6gumSp4hE+IgR8ApFKmDxC2dEwxraAEc4BiQObpSR0NVQxjByQaLdNWghq9jEIJRXhz+cVw91WEofhjQGPRyCEdKABzq+Uo5J1te+7rBYx+Kx1LCEIxqwKAUqPsmuA7uF/5RjmgSDu8oHXfeFC07AnxBqcOEMaxgGO/ZfW0F8qBE77WnLNs3RUGzX1vR1ghVURzJVM0lVnwMdGi1GHPSwuBS8IAx6ewIZ0vCEJ3AhDe1u9xWuYIU0wJveV8isDN35HmEBG7T6DtZoc7CDOFE5Bx5IgQECMAFA9GAMXzYEmvkVsCNM5MzD0+2L1AyuLQpPdIro4uOeB6Q+HJIRqYiFMJwxjTSaMRzNba43zhiOMubOW7Roxer+QIdBWkcOdNADpnkQhTEAKRWAHkeq6/EObZf6Kvp9xzmuMg50lA8WqUDFSbJUslFqZC2fwContFoXmXXVZntwgxp6/QQl+C0HOP/I8LDRiqcNgDjEohlxoZYNtURBO9rngCCl5LHMCV5bNqppB8Xa0cAZgyMUcSDDDsaNAjFQQQlOsIIV1B1veb9b81fIPLzR6c506tvfg+N3sGlQ5YAPvMod8IBBAmCDHMjA40NxUVBucqOh1PH2eNQt8YJix+ARYk1hiEIUhjQfMLyAB2DoQ0/zHI3pcqMb3nCuOMCh0ZGC46TBoAUrRvEIRCzFOm7qeRxwgIMchCEOQEIGOdCBDotRzB/u6E1g3RGPeOyjHqAux1jgQRpcTWSyLn1mLUzAbi5wbXnmp02iw4U8TwmkYLTUz+1g4GcUYzM6Y2p8SWnybsRMg+78bsX/Aq/wXkM1UFDb4o8cxGEZnicMcgCbOiAJ1K0KLk/dXKmVqmAHd/DyquAJ4O0JQm89mGxYQOvJLiwJaSD9qixOVK8DUGAAAKAATMAGLMAQPuFBbq+OWoACCCrMGsr3gI94riiLvuAN0kAO0Iph3K6sXoBhhoQH4gBeXsEYnsGkzij7wiF3noEYbIEVPiF+CkEPtkMNrkANnucNY0AM4qD5QuEa0kGjlE7p7O/+2iH/4AF7Rm0fxqd8UsHqPAFdRFHrrIplsAqrtAqV8kJ+9gIP+qJV2MDzimAHdACehE2WUEADOYMDO7DZlm0cQAPagDFRGEgzEkUz+AoF2QFsNkiS/+yv2xjvBYRuBzzgloZACZSgB4kAB5/gB72xG9UtHJVgCNUjPeKDnkoPtC5MHZdQ/WRP9TwABRYgACKgCj0gERoN4rRrFU5BEuCgoCRieHCEzcaQDE/ABZCgCgruA/IEBWAgBhwSBxgOehTmECLhEkqBFWrBolZi0AYtG6bhGbyPFTwBEhJhD+RADgzRVBIRBWIA+cRgSHpBo+LvHT4tK+IPHS4RKzjRH/yhU/yhE9NBGlIhREbRFNLHANvC69IiFWcmfuZHTepgD+ygVeBth3aoBixMBlQgBSaIgJJGrkTDM4ARGKdmgcrhNdSBGJXRmBilHb6GE/kBHxIvHZwh6P/MAxvVAxuxUd3EYwvsLRzD8S8Fc7PMQwqOLwp2QDEVUwdOD/WOEFiSMP1mQPViUAU8IAFU4A2M4A1OwaAaQhZOwetOYROCD83AJUYKkngE8gs24Q0AAQ1kEw2wcofIAA22Yw6WYtMeYRIwQRRU4RVwwQ4xKndQ5A9LARMa4Q+uow2a41TMIA6UQzmiMzoZoRrEQSr4Qf/S4R3SoTuZ5GLcoSq+oh72AR0iERyYIURCQRREIdbIJF1IYWSYEmZiBi/ORC+kciqrMg2swNdsQOBmYKwQY/A+Q8TujtnGUlHsShkdVFI2iFFm4xzk0h/aYRzCIRV4AAiGYAiAgEOvkS//BfMvt0AwTZQvl4wJEnNFj88xg00yoQxG1zHYmFD1+EOEPIAQFOEzzQwgG00VVGGKvhBcfm81BVJ0VuENdnAMdqgHAm4H1C8/qqwHpkAO9iAQDmERHsESOiEjbSEYkuEZnqEZRjI5F2EP5qANoNMMyqAM1nRNy4AHYAHQpEL/cvI7mcS+yHMe9oscREo9i/KpPmlH5POTmJJCNmGr8KKL0gQP8OBmHvA/jaAKAHSsZIA1qCbElo0sR+NojuZB2SEtHdQtGWWDKtQdwgFUYKAGOhRYQDRERZQvZVUJ1G1WhyCd1INFEzM/UE8JBcdXL0xKLbPtYEAGBoMQFGIVcOvM/yThtpR1eCKijtTMSIMiKGQhSQPUSVWvMIqtW9lwCtBANwEpSy9SFFCBFWbBFmzhFVpBFUaBEk5SDtjUPMSACcTgXsWgTfVVDD4gDqKBxjhxHwQr/kyN6ZSkSvzUTwEswNoCq0zGFEZpZNziZcgElRY1TfbiD1zx7BzLDbjAWPCnZ1SMakhjQeHKgKBtgRy0NB5UM7jt/vSr/s4hHGLhA3CAQz/0Qzt0Z2V1Z312CGq1Z90pV1c0P6QUWJE2CQFuWA1DBrgAD5L1FJRVWQ3qWnELXFCz99rMjuoIIONEW6sMBwqjrIaNDXNgCshAN8/rD7C0ESLhN9/TPT2hEvxID//QgAxUNArMIzHPA1/F4AU+IBTCYbA4cWArxr5glh9WsL9YrepQASOi6mFHaVDfgmIr9mIJoRAKoRVf8Q3ewGMB1AZUjO4649k4tVOFCZgaiIGi7Zi4rYGWUb+mxBuuoQ8+4Ag/tAZe1WdnNVZtNd/i4/ho0WirTEaTdjLVj2mLtTCcwBAMyhaSoVuityFsodEmgkgLkmuhtSE2QQaGte3E1gK9VQYkUqJkcztSUg/+oBAOIREORnNzTg2sYAcQswZ09X5viQeYAWD5YWDzFCt0sjfwAR+4LR7QISyoLhVUwRREgRQeFmJX5ksQtRIS9T49jgFrik1wxlFzZgeNYNr/YINkgfF0UXau0LLvSpUdWle/9mEcxKEXiEMIgCBYPpQGctZngaB3aVWH1w5w4iNZhtcykfB4hS15LbNYU2AG5kQTbIEYGqIj0iiNVuJ3HsTixlB7RWchkkER+KNGLTP9yrZbp5RKx0AOyHgMxgANzkAlLUsKqmwGYGAHgiUKIhO0dKAyPsASwCET68++cvKP78/+poQ3oI6wBPDV2gIVHvgAK7ciyEQSIEERDMZgHoxNONd+qmDwkPErM3WEwXJQ0FJ1WzdCUaxj3uEbroERKqADdJeGZ1h3ddZDc1gJfpaWf7ZD3QNY6qkxhTUHfnVGjxcHKjNsqwwFekAGYIAH/3OgDyxhFp5YRaKYG9IIGkZnC6kIiyfCBeDgFN6gP7y47cI2/bi12Iz4bNEAiO4p4KRACsgAnuwJmV8gB+a4jv8Nj1+gGK7HH3QyTwm2Ev/4PJFqkqokAB03FEsGKZHyFEBh6xKschV17ChZLzbXqwDDCiplZDN1Aw/Uk1P3hFmXg1K4gQYk/jrGhZHhAx4gA6AsCV0ZRGNZlnfWpW84l+lJB3hZWH11iH31i5MXB2BgBnZgUo2gBz7gBXCAD0hBWaFX5bRBimXBigUy+LTXIUxHEaBUB745/bR6qw2j2MhX/UoAMXSsW89gh6iMW+XZfukYWMjWjhXgAVaZEbRhkf8Ub3v6eUnsixPzyx/qgYUNuShFAV1QQZFH0aoSbGIrWBJQaWYouWb0s00AQzZGN6PJspeCUVFCWZTtqh2GaUAaCNXSIRU+AAUsIEaVMGdRG1Z71pZRGwjWA4eOD56IN/1ymq2RNga+OQe6NQVkqdgY0gRYYAbcAEKg2BpWohlUarZCR2CumXOgQRbegAsIgcO8OKsHtDLrQ06UOAesYLHOoFTmICXlQDaZdAr0Nm9ZFLSO7wNi4AnOIBCOIRPfgRPjQb/cAR+UUfH+ODzfgR/qAR/Q4b+wjhPYwhMQ9cAaeoJP6dbG7sE0d3Nx5k0yucUkGzV2SQN1sbIH5YAyuzT/Eq/vItSzz8FjrIQRRrsC2NFVW3t3+bJDe3ZnXztX6TcKiLfKjvcIUw+3y3n2DKMyqaxYbQAK3iAPDKESZiEZVC6NgAHiWFMQwvA0m4FFNkES2KBh4nk+hlW233hAPVhOAnSdJQqNj2O8Z5NJpUCt71dXp6cK5qAPQoEb4OHTxmEqgtId2GE2VJjb9rti+rseOBsdwgHAQoGBB+wTKgHBE9yRyYRMIBqDNVjCCC+ZMJWXWiOjQyNUE8jDUawcFAjFRHx80uEXeOAFcCnFYVlnX5p3aVUcbTnGi0AxEZPGcTpp4QO0ciAGvnf2fJyM0SCN06AOCqERHMERPAEVXMEX/6ChGmRhE76AzeyozSDEQWShEtRAWWBgPsC27bA9B/IjWcwaiJOlnqQAK9G43NF4Puj4+I4wzYuNzYGkF9LBs+87KOXLQfW7n+fvHyZJ6gL9EyF4FNgFXQz7IhB7EzIBZhhsZjB4c2+mDpAJU/HKwjOV0zGd0+sKhT2dHBqoSsDBEngABjJAA1p5Rk8dZ3l2VtWuxWV5aF+dfhdT1ovXeFna1ncciHmou3FTDsp4D/6AXA/9FFAhOGeBIvDIB7A4zCShQWhCFhphD9wYB6YA26U+CrAdzHkoosCdFpNFCrBdosJ8DND9vNcaWNaaRRlGB9AgKa7Tv9xhHL4Ce+Ay8P8C2b4s5h3Ahx1uYxzcQRxAJhVYYT7dUxRn7UsqQhM4QQHvgrFViX4gvtIvfLI/g4E6HFE0O+MHhLCiAdNQoAMeQIYhE1hg2kNPXkTV7pZv1Vf2Vnh3NT8eUwlx3Iu3fgLjKY23o9L4INhFooGVtRVeYRZKUxFg5OhZahWa4SWA4RMcIefAvg7I3NzJIAyifp1p0QoiagrAvZ6knkp3aJ25PwzstV7pFb3NPv00rf3m1BvGgYPaYSrqoZncf2KqYpKUbpLAhzfqoSo+pupUoRROorAZOUwAwpMnTZkqTYLkqJHCRokaJlIH0ZxEiBQrWowoMeO5c+U6evQ47uO4keP/NpokhxJeulRgaqDo0EAIkBo0gcwcYnOIzp1KevpUslNnzydMihqVEiXKjqRJdegQApWmVKk0qtLAkSPHjh1TrJA5M2XMGTp7CjVsBCmTqFKqXtGSZSuXrVabFLkAcUSQ3r2CvkgC1ixZM2jEVmmitCiQnjmFAPGpo4cOnThyzoy5PEWKFCtVpmTWLGVrj9Gjx3jWHCY1GSZiyoh5/ZpplKJJYeDAASbMmTh9lpELOa8ePn/17Bk/bo8evePC8eG75+9f8nn3+MGLBitVKlGiTnn3Tir8qfDhP5n/JJCgQUjsETJEC5FdRXbm2MlXx26dunX6L1KUz5F9H3lkEkkj/5mEToLkwGNNH2AMgUIFDeg0k0055cRTTxkG5dMTRDFRxFGyjQhViUJIdeJUOkgxRRVonDFHHXX8AUgijThSCSefcDIKKq24hYtctswyiyqR5AGCD3zpJYkgoAADDTSBJbMKKaNQQkkihfzRUCFb+qFHmHTMQeYcapxxBhmmeZYZVy16VgVnnX0mRRivlWFUUkzoSZsOL9zGgw5zMAGGJdeQ8w0679RDXD3KPXrcPZJOStw/+lx6qT/8xINdKqiMosp34JEyKnlWipJeJpRMsh5COH6ynzzy5JfffuvYV+t+F+FqnzrmlBPfryYRuFFJJm2EjjvopKNLHHTQsMEDD/8woYSFQAGBE7Y8ESWUhh36NASIIRaFFFJLMbVDEeqqayJUOwghBRVhkIFGGjHuQeNZkFTiCSmmmIIKK275QjAttLjlCiV13LCkJA6fkkw1UUKjjC2hChRJI4cUolCXgfixRyB/7LGHjGbWQceZZKjJZhVztugymz0kpZkY5e4pGxNI+QnDCzz0kMMTOPCgizjnjMMOPvNEeg9yxk06KaZSZ8ppKqGwFaqo35lianijoDpQQZUYNMkkmoCyCn/80Zrf2vH1599FwHKUUTm/3m13OefU4049/LhzTjzwcMNIHHZwMVMUShihhA1AOG6DEkTY9JO8Rhm1BRWai7v5uuz/lvjuVlGguJVTOogexbyWkaEGWX8c8t6+nPSLSsAC24J7LrTkwrsvc4UKyiYOS5KJKtBUI7Eyw9jCyqedWOKII4ktksjGIo88sox1qLEy92qGJsXpW22V1QxTjC+aVuPrkINTSqG/w+lSgHHZGGmMwQMj2aSzjz+XQg3AAN5Dav8ooKX0UY94eOMYoQiFKEhlpa914l//6pp5PCE2SEwiEo+AhCRAIQtgqI0/8lhb2ygyQrXFjSIbyYgLJ0KR5PBtHu1Y1jH6EAc3cMEISXmCEYhggyDagAhEJKJPiiCv1FyOCkXZ3OXUZZQimEhdSTER+piCmjNUpnX44lhCIEEJ/02IAmCqUIXAaBGXXPhCjWoMBjHeSAxgyDEZcYwY8qbxDGPg4hWqKEUnOkGJSCQkIYs4hPX+kD2UzQFNaULTmkIDv6xEUpLry8qK4Oc+KdRvDGhAAw+IRo54+E8fAhzg1P5nyksdUB/2aAc5tsHA7QAMVaLoRO0oSMHyoEcTnKgEJspWCRDKUVbElMc85tG2W0GEhMRMoTN7tUL78KdpStsIOcIRCmfpUAnh8yERg1jEIh5RZ5q5HIiY4ER0LrEo62qXid53LtR8RQ5qiBEfzIKWRkSCEpwglSpaccbcBWOgBPPFQImRjIQ2YzBRmgbyqjGNaCgjGMwrRQMPEwlBEv+yehvbEslKJpkz1ZORYlmZSU2zyc+wqU3j+wz6dBAFTdbvRS94ASOoAQ9+WCqAz5GUpX5KylTq44CSosc54AHLVPSxdqMoBdZuiYp/eYdrVkKPQEihihACQxbGPGY72jEPehxzHrNiRzHPuo6zFvOruFpbO2T1VVmREh/1KMc3yBGNPvRBD25gAzd14MMfgrOIQ/xJEWhmTqM4MZ3m9FyJ1jUi1Khui3XgQ43yGYlLdMKfrfgRGuMy0GAYlI4JVYZpF8pQh95Ror+oxStQwZ1OYOISq9pgJFx1I4Y4xEuN8RIgvIRIPpCMD8KtQ8lkNKY5JFdlaipp/U5Tp/pRRg7/H/AZLELpP6j5Y7vc7e5QffoP/62SlOwYhzjAsQztsKIUqCgFVstYu1tOlarmIdUqciHHVSgCrMpxx1eDkxyxhjXAjyowPYhp4LEqeMHH/N88vtENcKSCN3qoZxioUIQn+MRCHP6JEsgl2dSEATSpkQIZRlwnFMvGc56TTYpXpsVF2rMQsEPIJDTLWc8KlGC8CIYxjHFaZCBjGc94BjSkIY2HSsMZxuBFLWjhitrFVhMCEcgfMZEJ9ZStPZBYiJd165DdAle4eyiuZJI7JjWcKU0wRsMY4kCZOHTAZ33AqU4DaMA8G9A5++CHn6Nzj3zkgx74eAc64CEOZMAiO6X4/1cZHw1frXHtFFkFRjKAod83hNVR83CHp+sB6kdNisBOc5qkjqMc4xj4UZeyBzu+IQ5q4LAPKZsDGZio4Z5w2Fo/AbFkV4biEqM4xSOmmRSayMQ8xZTEMJYDPWcMu+hldrOU7qxb4mJQXwxjGEA+rTOWQWQjS2Ma45ZGNL4tDF7EBcpRNcXXKngqT3Tigpqod0FWxWX23DZ6/O5YlxrzB+D+gczIlQyZ1KxmZzsbzh34wCdTwT9/2OPU2tWHP+7xHOdoah995kd0LpUP6PBjH+/YRzqYkZ2oUhrSj155Gb2zihBeWhaSwIMhlsMc4fStOE9rmqlLOUABGgfURK9HAf9dPQ5u1IIHcYiMGcywGg/leteUM4LVleA5EM8r2CMuMbFBY85k0wY0y57XV9RwBTa4Dp9omQQnxqiKVQTUoAQlhmlNuwxnRCMaRS4yNJ7xbSEbg2C5CIbumtfoMVJwFF/zBHdQxYnIY4ITmKi8LzFBiUqsKqPsiZ6/N3aI6vE2uCRD2ZnJNCY6OBuHD6guD/ogjZw6yh5Fr8c+8LGP2jtn95IKKilJuV198CMdyEjFek2xCpazvHZxl4VgkiGLTxgiEZWA2sS3+2nnjHriQu09Kk0ZwObsnq4FvIc7wmENRjB9Dm0ow2yYsIUtTH3XPXGCE6wOxaMgZV6SNbHXSRz/Bk+ERJsjWTGlGmiCdmrXRbDTdphAO6vwI7OQRtnWbablDEUmDX3Xd8qwDMhgDG9keMTgO3zUbrf0L4zHeKdyQZJXeS2YeZpnW52XEGBmIxwlcANXeqanXMilB6zXASgQBXGQCqHkKLXnN/ywe0Q3frw3NZqyXdYRDsUnMK/ACmWUfMrXfFACDcAACoogCZsACQVEQP8wHEj4HAXkDxrXKN3FhmkIauOXe++wKBxndOG1D+SADJ9UB3YgGXFgBmfgBV6wBdWyYR62OEYgdmWHRVuXYqDhiGDHTkIwLuQybPJ0BvVEB8YVcDbiCGZDO2XUChKIX26UDMqAWn6ngRp4/3fKkFBwJIJ8lHiL524p+DWisCOz04K9NDabRwnssRCERD1acgiLgAiIsDHBhUjHpT3LGCZ65SxssAeH0AfIkFMG1IZ+ho0jtw/xwI3cyHHfyI3wAA/kcF7gkA234AvHEwyuwAqssAqnwDUUpAqzABiXdgpf+An1Bmj6IGhomIYa9w/QoYagxl1LuF101Ry552ff+I1PiGip8AI6YAdtQJF+GH/yVy1AUIg/QUTsdFio4Ygi9ogi6XXisi6X84iWiIlltomL0AiTkAmdMEZR9U+vYAvAgFCCsVB+FyXP0AxFhlp392Ou+IrNU4KqYIL/8nizc4sC8UuRxypjEwmT4P95ntcxobcIxIgIArclZJaDMhImPdgHckAGbvA6fRAK2gAP3SiObakS5OgN24AN12AN1BANzMAMx3AMusCXsZAd2hEKjCCYgpkKzwAO1bAL7EiTpnAKqNAWltYMmLYJnwAK+agJ9XAO+GAP/JgP4YWQw0FNHDdyoKaNDMlxzkF036iNCdSQI5cOsvYCMMAGbPB0ZlAGVKBhGtZhHBZOLQaSIgacAChsKGaS6pKSIQljl5iJCwg7kVAJVEYqlAaBs4BfCaWTCxUlC2WK32ZaP/Zj2yZaxCBa7cheigcwsjgKXBN5pNAvkecJlNeCl/BLk/AIHFSfj4CfxJiVWnmMAdf/lcRFMmEpoHpABnOABnXgB9KYCrpQC36pHRY1mIKpVxMKZ3HwSReKoUx3obyhV7WQDeCgDALTPEjpmK0AGIGxCpU5HqOAHseAKMjEj/qAmm/oKJ+phLeHo7iHkEVHh0Qnh/HAKNZBDrrAAzDwAbNZmxjpIRmpkRrpE70JWSEJnMEpko14bOaUksL2FYwEI5Khia9zI5DgnJQ3O+kZdwDFCj/yCrOARrjQYxWoDN7JbcOQbqLFPEhpCmOEKnl6guGhnm/nCSsYeZxACbM1n1NpW/j5CPu5n4igJby1JcHllQEalmMwB3LwBz0YCBY6NDxwG7dBGj0gXRUaB2BQoT8z/xqOMAuvEAuxUAu4gAvo6GTGUA3PwAqe4pglagvJAA3QJx6q4Kef0AfREA7f0A4HRHTusCiOIinPURz1gHHRqplGSK215w8mxw2WwAMv0AFPx0i5Jn/dQohPanVGgJJk14hm93/HqViJVRSZozlbwEhqggbOVq9kIiN8gEhmsYlokXmYN3kyOZPGFwtuGgzcJqfbJgyGdzAk6m6mIG9fw3i2OArvGahkCp8tyCpZtkGOkFFT6R4LwaiiR2MCB6CTGpb12ox+oBg5gAIokAIpUAIxKwM1a7MygAOh+jNg0AO2MRqRoJPGUAvCYAzDgAvJEAwNFAtKVUZs0Qq0QAyBYf8L77hy8BgeH8AI1yAO7jAPBZSsi6Ic1vc0pWYcM1oPYyWHcuij15oOzrCtEfJ0X3EFuYmRQ7CRPUFEVqc5TOSIyyZPJyallYhs6JROVHCR8UdSm8RJ9KRmypWJwtWvaBEJi1CflCCfnNAJPWJGr/CqPbZtw/BGvoALswBQ7QVbEysKo/BHf9RPkYcek/cJq4IJBlGolZAJmXBbN9KJVDmDNpKVxfioo0d6xvVRYVJ6CxcHfvAHdZADHmABFqABz6sBHkC91Uu9KFBT2VtT2GsbPCAKPlYKL7ALRnsLrOAKH9AHTtVHoEiPC5ULV3iFocKY1ZUK21ASXgtqOxe2k7L/v6uWaqg2VqB2TALcDtcqDhDJrQ9QBmVABvLnBErwBHVrt+PaE+VqroRbicx2Yl5XpZBIiSfWRId7uJahuPWKcDuIL5X1W2cxgxq0sbMzkwGzpmjUO75AC1VYO6UgCqfrL+72eJ3wdjvyng5IeQYRCZUXRqqSUbklg/6WlQ3RUbwFCIAwcDJCqWGCB3iwcDgEBmzgBjjgAQ/AANLCAGMsLQ9QARWQARnwvBawxm/MABngAR/wAXFgCQ2UCsFwC7tQC6EABmjpR1HlmNQ5GFsVd3EXv2X0ARlANOHwDu7ghkVnD2ElKQwWVo8yVv4rwMHhX+ewDwzSBzwQIQ9gmxeW/2tSp2EU4qSG2BNM8ARUMAawDMthMAZmNwZqQsu0jBqfEVNFoBm3PAbUQgVXMMxbQMwRfAUlLAcEeokovLx7UCNnoTE2wh4bS2WpCzCOmaadhcO1pFkxWbGeMLGYsJTvOaiVF3mXwCqrUqidoMSBlDGP4Ajy/AiN0KhQDFy+lYxgOaB7oMVyYKHOcgVV0AEZoAAHgNAJndAKwNAMvQBlDNEMoABl/AAd0AFC6AqucAuxSgu1kAqW0Ak6LAqPBrVRMrWtsArwC2kZ4HCWYA3pEA869Q+Cxl07dUo3PVR61l3YyHHxgBK9oFdnoAROwAZsRgZXMLdKkARLHRRJoNQd4v8hTvAED0zVSlAFA30FVjDQVm3VT2AFY2AFb9IZl+FmVdDVVeDVWZ3WacAGV7DBXzEHYrKDkGtINoIW7dGJtht5neB4o+AvjemYh8xUmjAK+yQKlUAKn5AJ/WIK/DR5o1B5mhC78sYJlyAKl3AJnECfk4AJsmUJHDTPlKuoi4oIjVqMW+mfUwygAQoZerAHYdLaZyYZziYDHqABcpwBDiAtDdAA0pLGE2ABafzGb2zRGfAChxBIjHAIgfAxDuIHyn0IlwAqu5oNydAKj5bSKQ1pFv0CcRAK4ZBT0YGG2Og/bfiE2cjTpbmN4diW6UAO4GAJtDYHTiADV2DUZLCkTdD/BEy91Pu91P2NzPZXrvdnBPdnf/fnMgkeJ5xhBZzBSZ0kJw1uBWmQBmpA4RSuZhV+wnEdlpW1rw6hENHTHpOAJYU6O4Hq11IV2KbA156ACZowCX8ARpBwT5DACfuSI5RQi5TgCZTQCZpwCZrQ2Z5wCY+gWZZwCZbw2Rk12qOtn79bjJA6xQNHXMI1oAJ6emRyGR4gxxMQxmecxmmMxmE+3BmgxgUtx3Rs0Q2n5g1XUz3gCKiQC9BQ3VVYhRCY3VeYATjgM3EAC+jQZ9BRHT3djYXOlm6pEumg6Ivu3uQIDtyQDdZQDc6gC3pFB2gQRG4NG6as3/r930ng30PQ3/J3/wUCbnUGfuACruASjgZWAOGdBOFxcuEajnBq4AZugImSERmuTTKIFLkh7ggjXjbANHnu+Qkpns2jIJ+YsE9ZMs37qjGO8AeNkAnM7gnUzuOacMSacGUmTglKblscxKiLqpXkzp9SLKllZuVYLtuXKgejgQY9QL1yLNxrvOZlvuYVsOZsbtF07O/+7ubV1QeWYAuDQQtmdN2dhdJ5jgN+8AIOFwe6QA6KriDh4A3ewA3acA3UYG54qZfH0Au64Jd/aTWWMJgUaqEYuld1UAUyQAMnBhti0ARK/ek1nwSiDuoObOqnnuoHruCwDvRALwcNXuG4rma3jvRIL9vGiz2+zv+AIV7NmQdMl1fs7tnXpPIvLu4Ih+CchRRwwlUIc6AQZCAFmx0Je7AIjsCLhxFGlW254J6oop2fjGraUQxwxQWgYanrkZFcCicH9dq8c/zvbP4BDUf4/l5TfG4bYPBJHBoIjBAJSn41pWB8UNsMxMCO7vhPCo/SKN0IaAADFf16Hy2hOPRJ2fvvAL/vGbDvxc3Sg8/deyUHVWADMhADdgIGYDAbNs/7/90EUb3zPC/8DR709XLhsC4HSa/8SL+Me8/0+CIybBemGvSCJJ5lvBR52C8Qx4718HjthRA9gXAIfzAGPSAHYwADY6ADZ7AH0r71khEIDdF5U1momD1bSQ7/7hzE5HNv2lGO7gAKEHX2DNRTZ85Bg3PkLFw4Bc3COj1evMgBJk6cPoEWOYoU6VIoUaVQoVKlitUsWrZs5Qo2zJixZMqUNZvZrNkzaNBwQgvGymfJVkGFBpXhocKDDIcmPmDa9AEDp1EZTKVatWqDBlOxMsCKI06OKU5kyIAhBczZKEOSJBnSVu3atmvlJlHyxMldI3nz4jWC14oVNIHRpCGcRk2awAvdLHZTh3HjOpEj26FDR89lPXv+bA5U6NCiRo5EQ5pUyXSm05o0ceLkSfXq1p9GkSJlitQoTZMoNfozJ0qOHDhQdPCAQgqdKFEc6aFzRk9nR40WkZ7UMRKl/0uXLG2vHunR9++LFiEiXx5RIfSb+azfI/By5INyFDJ8KCewQD6UbAEDRizZfwBtEnBAAgl85sCcbkIwJ52gIYYVVVqBcKihUtCggQoM4koBqjicSgEQQwTxQxFLFJFEBRJIgAHgZpBhhhRUyCE5GoUYQgm23mpiLh7r2mKLJ55QYsgnfgzSyCvIUJKMM85Q40ko1ViIDSofc8MOLLPEso7LBtqDj802OyQR0EYjjZJKMtHktEwwYY0TNVWL7RPabptNFE8qOQSHGKJ4IQMPcuhg0BdgIOOPMex7rhAyQxPNu0U6msSS7rwDDzzxxDMvvT/WY4/LyyqjgyH7BBtjjP+H0NgDjUJsSaZAWAd8xkBZD7QVp52mwUmZW35C5ZVXggIW2AwayCATPhjg8AComjrKKauiVTbEA6q19toDFCghBW5jhAEGGqMQwsa31mri3B15TKLIH4Gsq0gv2v3xiivOYLLJKKOcskrG7LhSSzsI0ixM9f74rEwzS1MztTfhjHPOUSLGcxRPPMGtEClQ+ACFF4xCYbiydDgV1ecCka6RQw65zpFII6n00kxjHo+8Qzjl48v23BN1VDRG7vnUnut4aKBLiIk11plksilppW269VZopHnGmWeMqUWVUlQZdutXxtjjlEKKraq4D17AQTiNP1Bb7UHbHjSDqJw9KoP/DCqoIIUdbNDbiCKkkCLcIohUAl1z000C3SaKFHLId4+UN0gl8X2yySZJdaNKLC9fDOA6/kCP0URCLwQQ0BNxFBLUIaEkTtU+8aQ1UVb7ZPbZZ7utzohr+0SPjzvIIAcYdAgOBg/IeGEMHKbYQw6UDT7EEdIekdTSjmDO1LyUAyG405x3rkyhxAQTTI4qGBpDD1WSIcY/Y2RSZv31h5F/fvrpf+l+991fxhn++X8mmVikghUqWUkuDGiLU6BiEVN4QQU8sKFtoQAGE3nBxyzIsbStTYMfcNugODgoFKQABnnTWxH69rfkSKEITjBCkApHuMMhrgnuatziHLcFelEO/0pzkBxD5nA5fvGLc5pJD+kSYcRGmK4RjUgd6ibxxDWVxk2sWY0naDebiGUxi6cwBW7o8IFi4SADHTCUBx4gwSmgYAzcq1nKQice71ineouw3sxopr2bdepmOavDzuaghsCgamRASwyq5DCGR/QnGC9xX/3mZwxHPhJ/+ZPJ/vgXDapVDReqQIktaIGSlDyCDm2gAQ1Q8AANTKABKhgDCnAwPLLE8luz/FYsU0BBWuIgBR8rzgxsAARgAkEIRYiCFHZgTBXexQk4UksTsnCuwmVBmokjUpCCdCMfyUuHT+JhlA4yByqFsw1UakMbOOc5QHAPTH8ABBKjAz3qUCISkP+IjvQugYl7yqlitavdKETxT3/G7hOVCIPvOoCUBvTuY9/KQSD08AeUpewzKbtUeGLGCEaI5xCBuOMfvMRHyfSRDgdRQ5PIIEifoaEHgXzIGOKACmIskpHKiGRN5UeMSSoDGcpYRk/75wxMZlIZuIgFsGZx1KPe4QxbaMMWVECDEjigAoWQIAxeOQPgZDUHWM2qDnbwVeCcTawyAB4MxgIDXwazBsMs5leP2Ze7KCEuiIuhDG1oTWvK60dL2qY3vxlONpRTsAC7Q3sy46WbEQI9oVuiaOD5xEg44jPS0809MfGaKrrOdRXzhChGYZtPtKYRKGBAsZ7yAAdWEAZTWIj/Hs5QiIge4hEpo2PMECEzRGw0ELvd7WY+KpnvzeF7JaUcSgkJtIW01A+0iGn72mfTSN5vppX0af+iEVT/KYMXtGjFK2YhFCzt4Qk10EEMjtIejjFUrFrNQQzEejb3BueVWpXCFGigghjU4L414K8OvFrMIgjhq4EbUlzkAk0YsgVI1vQRu7S5pMg56Qxy4OZfxQkwLd2BD6QrhEeztGFGJTERkAgNPaOziETQlo6RsMQlTFMJTMS4YZ3ohGo60VlOUCwTnkhWtRQANwbwslA7CIMcXiCHRRTCD37YKB01oqncclSjvN3tRj06kE9FZqTCHSlxmzRI8SG3ZwvhQSdy/+GLRcoEuo6Ubvt42tPqXhKT16VaTobxXe+2YhWAYMMViqAGHXigA3tIhARdebYeJFrRiZ5vWNc71m/FoL00iIEQagCEGrj1q8kJ8ICHVAQDH9hccmnLgoPU4BtSiXLblNw35yDYcmIYS4XlQxH16LnRAULEjlBiEmu2W89ECrJP1A2MYxxj1SBbExabXSYyAYkOVCsDGuCQ3R5AvAxEATl00EyVA/EZKVcZEeLOrW6jfOXfatmPfyxuSgOJqsCkwT44AAMrhuGLYah5zWyeKZwt+VNpXFfg09BVMGahClI0YgqAwAMerBADFMghshL8AA50gIMd0EgKYQhD5ORgmf/MLDnYjphEJlpzilOUpBBb0G+md9CD5BzThEBQQhGYwAS3qEvnQ8ir4264BSpJiXIL4eGE5XOQUcI61ubMEq0BAWI3vEgNeCBEO0WXCEZJtBDa0wOTxfMd6zwRTfe07LFj7AlTtIYTaSqEAg5wFAVgBQUZ0EEHUBADPsjhD2cw2CKyl7Ioi/vbEjW3ldE9EHWve3JngLf40MDxnj0EMRNkBEuGsdNIFkMY8itGMTjfeWMgY6dwZgYzfjpngUtDatBoRi5CEQcUVKABwp1CD/bgiVl4wmQc4YSb6GQKU5BkFatoxVFTkgv+9AdAryIQMP6QBC1oIdMxHzATigCEIdz/nC05Kle5YEgkvYYf6EIfuhyMfvTKiDPWdmD6HQqLWDxUQQEAAEAAJmCDhgMC61j/HHr2QIc4oIM+iAMeAIM+YARJKbZLoAQGxI7sWEBSuLFP0AQ1mYQMAJEVUQAH8p0MYJIwmAMymINvy61F+LYqGw/eGg/dIrwOUw9PuRng2rJvKqmTaryfGYMeAJoqKB+regFVaAnR87xh6DwiLELQA73QE71lYAZkKD0nNL3UU71nUAZXCAUxOCgGSAADYDJKQAVbWB/kSz4x7I8xLEP4CYZggJ/1SYadWIUhoAEYQAH+GhdycYucm4ucgyadW7BqcjC96gIzAERANAMzaANC/7yIi1C6NnC/O4A1RtwDQojEBKA/SgSAAhiBK2AsQ5AORGAnNcABGOgDLFibF+ABP3iEe2oNLPInfwo+VOCsGpMTPVCAAWiAA7BFBXAAC9gAGniBKeiUP+gMz1CxjTqE8vC7cjNGmmlBgvGU7qGDPqIP8VmSMQiDU5mCKQAzDyjFUFAGZriuXghHXeiFXwjHYzjHYghHYQhHYzgGn1I9cohHchAHcZDHeAyHbFCGVAgEHPCADJiACXAAgUS+YYCfYUBDhEzIYBhDhVRI+UHD9XmJWUmGScC0OBSCYMI+Oww1nUMwu2KwxhG/LegCkixJQjxJRExERVQ6RrwDQjCEC/+oREpcgBMoAS6AhEQgBDv4gztAhCuYAh3Agjj4AKboAArKgBeYBEygk1GYHYsBPlMQBRqzMU/IBDT5gwcYkbizABWYgRkgg1pLhMEjPJpRRvMoS2VcLP4DRhcMKeZIrjEzP3vhOGscg40bpBQAnjiIhWqgBmqAwmiQBmoQTGwoTL/MhmnQBWeohmxozHhMB3iAh3iYzHiIzHQgh2wohlAAAzB6gAX4TAdYABDxBWBIyPVpSDREs9T0BdZUTYe0n5ewiVdgA/2qIIwMpo3kSB2hK8SRJlOrIZEsSZM8STNIyThYg5V0REYkBDwoAJkEgAiggAjQACKwgzoopz9QAyX/wIEo4IFRZAoG6AC1ocVsqYAnaARNmJ3W6CxRMIUYe0Czw4QYyJYEcIAHcAAN2IFCoAPSOQTnIZM3OkuaIQ8VNEYUCx3+4xT1yBnMGJVSoQ8l4biTCoMcHJkUOBsesARwIId0qEd0cId3iId32Id9QAdxCAdx8AZkOAZt4AZuwIZzoAd/sId/8Ad+2AfLDIdq0AVG4AEwUpYGCE3RVJEEaAmEjCnUDAbWRE3XREh+MwabqIQrUIIYUAEUyE0sVRcZOjDEwSsH88N20QLhHESUTMk1QM7kXERGNAQPCACZJIAIiFMOkIEn2AP3Qzoz8M4PgAqoUBsGGIABCIABKIAD/0gAFQAESFC7Y9sOfNoOS5AxR5i2IEUtD+CDM4iMQNC7z1iixtIUAx2P6zlGEUNQ0Wkn7tmDzMCMbyIVNLCXyBkkC32BGCDAYohHeHCHeqCHebgHXqWHcxgHbxAHadAFakjRaxiHebAHetCHe9AHfoiHdNAGZEgFRoiDF+hMqvjMBWCABQjS1mTSJW3SJEXDmrqfZrAFOZhSGeAWLM1NnYuhLOBSdMmrxwHTLRBTkiyDMiBORCzO40TT5GzJPFCAAHBTg4WABaAADJhTN+CDJsCBU8EBPf0QBlCbBwhUAdiACTiAAjAAAygABfCAO4AEs2NUGusETPinSKAbpvAAOv84Mj0gAz0Qy28Tj+gIjVCtreuJGQTl1P3DunS6NT9A1QZ9S1etnBscmRIoFB6IA0vghnhkh3zIB3aQB179hm4YB3G4hl6IBm8Ih27ohnrg1Xywh284B3LQhmKwhAbCAbahmwywgBR4kR0wgioQknFFSDRzTXF9zSdNhlAoJiNYVxXAEXWxw7kwnBfqzXORl3gxEi/9kegjSTPY1zKNg0M80zRV08JqgwMo2IIFAASAAAwIAQkYAS5ojBKgmw6o2A/IFrcTz9elPwmYAANwgAtIgAIA3QPwAESNhJPFhEfFhBsjBU4oAxACFznQAxxAj9A4mI14p9vKlPB4hJixXtD/IFXtBdqgDYQlI1rmCBW5rBw5iANYXSgeGMBY4NB96Iep5VV2wIZuIAdvOAZmCAdy6AZs2IdyqId5sFF0wIZjYFtlMYASKIEYoAEhqAI1cINIZLjIuBxIcqSGXFIl7VsnbYn5wan7wYU+6AEpsAEZ+Jgn0MN3jaF3RRdpeqYZEj/FySsv0ALL1VfLvdx/7QKAVURGdAKOLQABCAABgADppAAO+AE3eIM0SAEP4BDxvBbXnb8AKAARAAADENQE+MwqFtQBCFlEeITW6ARVBD5SmIRrBcUcqIxiDASW+TrvEI3p/TrrtSidXaIUGxPTQdCa6TBh9N4/wAyiddDEKF9E/zwVQukBjOiDaoBMeNgHf/CHe+iGYg2HaDgGqA0HbBiHyYTMdAiHYwiFF3iKuLs/GyCCGSgBDbCACSgBDzhlgARI6aIfDL7gb1XShDxIDZYkYyiFAjwD4KkgKpAhE64rxU1cYG5hvfrSI7kCGSZEGiZOfw3ANSDJHNbhOzCCBdBdBBAABACB0g0BDgiC1J0BI5iga2WAAxiAahmUBzDYCyjYay4ALQyABbCABCjYAkDnBwCCRKiEZDsF2hCFQxCDiQiDQtCDEoQjOeoIR8AUOI5jOaYjThWxUQ2dPE6ZrQsT8NWD+aiPlDyVDLg7A+yDPoAFDoXMyXwHbNCGcLCGY/+4hk2WX3g40XQAh2mAhT54AfFEAY0VyGtOgGoxgAGgCqzQVl7ABVy4BaNOaqO+BaZmaqV+6qTmBanmhWS4H4i0hQ8upiiAuTAIZu4j5sN5JlEr5sf5kXjxgicApi3wgitYA2cmzhomxGkuJ82FNTuggXf24ThVWAmQgBbICxt4AyvgARi42EA9gAe41gGgvwVwgAGoTwNIgB+QAC00gR8QgAK4547NFhqAhE/wZ1KQjUuQqBWz3uvwO+r9Ojp66NVubfGYaO3VOvTwXj/wqAYVrvkgFfOFVTIQAzGwiDhAhsbMhmuwBm047mxgBmqATHIIB3hIh02ehljoUTC4xn7/rBsHCEiBdACs6O4G0NYFYE1e8IWpnmqoXuqk3oVdwAX1Xu+kdi5eEAZfIAZRAIMoCAMUum8Y2pHdVOGwNpxidqZ6XesfUQKaU5wzeOvK1VdCNEQzmOs2wGGlswMv8AAHUBEDUNgLkIAFON0UUIMdpAMe6ABadFMFUJsDqD8DuIABsAAL6PASuOZr5oLMFgACEAABGNTIngAVuAJIoI0uioRFoITdWm2PoISNiGPxmISKwl7VZuiI7tlRzePdWjLfSlVVJZXyBbMxUBIxQMRQYMxssAZpqIZqsIbrgm5ywAZviEdu0EwCZDR/dAqB9G47/25tfUi9bU0+J2+pbu9d/+CFXlDvcAzHX/iFJNS8XciFPgAXMkgO+xYD3gTmFVZhPezNFc4CdsErI2EcHEoSMXhrBndmHK7rNojmabYDIbiCJ0iBFy+BHyiBCxiBUi6BGdiBKSADGDDncx6AB9hT+guAEViAAMgWFVABC7fdH1iAH8bxgsXszCbUBKgAGPgDTTDeSXAEOuCoz2DARWAE6ake6Wly7CX3R4hoOp7ozwG2rdMezfASjdbynxkz47yIPvCFxpwGZ5iGbJAGZsgGb+CGbdBfbngGWIiEOAADGBijunkWprjzrBhq8F6Al6gpzRMGjD90jf8FYeg8jS+GX+g8+y09ZOh4V8ivm5sRMf+IAjH4b2HekXNhYWeaJniN+SzoAt+E3LwCv0/vbUL0bQU/STE19QiX8HJyvzaog0KABEO4gvsCghmggWVCjDoQ6A9wu3N+gFH8XINNAFsE6gXI3QSQAA4AYkEVAKCO4o81gANg+wNwgCmABE+YBM/5tnH3CLCzjnE3d3M3MZ+V6ARNxosmGFRNiO8plUBeiAC8CDBghGZgPWV4hoCLhtKjfGc4BlwQBT+QCLhpAKawz4cPUjvnCokHbzgTPdE7R9RXwiV0QqC6LsH0y2vAhm3YBm/4Wm5ozFD4ALYQArAIgygog7p6eWFOgkxn3Jlf4XoFyS3ggitwgisIA6AH+qD/N4Ohr+toNnr3+wM6eJ5K+ARV+AQ2uINNAATFugI7KARrbV23UwAsuGlAdVNKHIANuAADEAAtZIHdvedid+wAyG6AMHBgoEADBhRMKMGmUKJGjh49ikRpUiSIECNNsqhxo8aKGhctegRSJCJEIBchOlQoEEuWfvzw2aNHTx2ac+TgzElnJ08wPCLRsuVLmTNn0Y4xk7YMlqVHZ15seNCAgYIHDxw4aKCVQVYGDBaADSsWrLSy1KhZs3YtmzZubsGBCydXnDhy5NKlg6dXb7y+8fSKCycNzIshQJQoGTNlR5ckSZo4biJ5cpMsWSRbvjxZc+XMTbaA3vJk9GglT7xw/7mimoyY1q3NmClTBjbtNl3W4M6N+3abNnf+IHLkKBMpVbmAIQd2atKkRIkqMYpT4YECBS/6MGIwYEAAAN6/C4iwwMCIBAEGKNjO4MCABBPYD0xvcPuAAu6LHGr0iBKmiZH+R8TcfwMCyJGBEIX00UkgpXSIg4WoBFNMeuxRYR1zzMGTHjthmOELOIBhyizEKLNMWdEgs4wrkcTwggUOUJWAAglohVVWXXn11Vg74tVjOnbd5eOPdgmZTl/77MOPkv74oyQ84sDyARZD0GBEFVVMUQQVjnEp2WOYXZZZmGJ2ZtlkT4RGGmlXcNEmF2yw5pprstEGWxu5dXHbGnny9v+bSZFgIgoqswCTjKHA2DIKJ5k0woklcUhVVR/Y8cDeed0F0J13ASQgQaaWHpBeAAoccN4BAm1XgAABCNDqAAcwEEMjmWDSH3OXMGcJRszx6pFFBR7I0YIgOVisg4H88UdMfDC7Rx01zaRHH3TcNIceL3x4CCvNNGMiNdMgw4ofL8JYHakCbUWVAjnuuGN1DBSJjl3ykoPOO/QCWa+RSSrZb7/7kJNNHx/A8AQNRBCxQ5ZCcBkZZF9S5lmZY3LWxGigkbaFElt40XHHV5ARRhhkkBxyGWfANhtsZ7BxhstsrMFGF2z45ucjnIyCyiqFckuMLbSg4gkmkCzCCA8fZMD/wAeTWmIJI1hUwB0AmU6dKdWvBjAQdwOdt52lq2ba6qqvKtCABmdM0t8luFpyiSWTrI2rgL9SdNGAdQ+40bANJoJIIiq1lKyyMkVbOIZ17IHtC2DQwi0yzEyzTCqQJlA5qQOxN0COm5fdrljvMsAPkn/p5eNegIVDJDzx7MNkPed048022MDzozjG+BTDEIgpUUQRUTDR8GRdPuxYF5c9ZmZlx2eRp/KSbZHFFkmgGRpoIF/hcslkuNy9y6qxoVr2LbNhxx2AINJI2qKoQgsx3CaTyyyqkMLJI4gE0gcPHWTwQB9OhyIUlggFI16wHqshcFPesdQAGuC1Vx0gAQZI/0ABCEAABBhgPAUwSAEGYgElPAITneiEKDwhCkxw4hIoXCGBOvIfSEAiEpB4SCRGIpK9HSIQOdzhH2bSQ2fxhA4UmsMZ5nAhOlxoDyxhBTSm8QxhPMMVfXiBBiTQgOlYRSpa2eLmGuA5sFQHLF4pXTjEAQ5uwOWM2shGNq5hjWjAMRrToIY4WqcPfsSDGsfYYzScgQxhWAIMOIDB7nrnuyhIgXjDU2RnNnO85YmpeXySZBeGkITM5GkLV7ACJ9GABu6pQQ1yQEP35HCFNKBSfGxggxvswAdAJAISleiEKVZBi0Ilgxi0eMUqUPGJSBTCD4GIwws+8IFQpAKZAQxFH/+wsL8GlCqBAvgOd7KWHq9hjoMbFM8CCuBNCnbwIA2owSNI6IlRaKJWnOAEJS7BiRZeJIYyFA6BHBESe+KQJQ1iyUz8ILgK6YFZddgJ4p7FBzko8RCM8EU2oIGLUugBBh6YAFaymMUtYnQqXrTRFxfgFWZkoxp7FIYxfiEMYfDiFrjgxS5uAYta3EIXu+gFNuz4DnhQoxe/6MUylIGMWvQhCipQwe6EYAQlTGEKiYTYIr/kGTHxqUyVkQyfqtoFICRPkpq8khVIdoZQquEMJTsDGk6ZSlWy0g57SB/cPKGzWdgirrNoxSro15xD9CEOPcABD1IBi7+mIpnNxNYHOtD/AFGFLYGvMkDW6IO5A6jKAOIBJ1g4mAAHhMoDa/jDIzzhNrdFwhK1EhCB6klPAtlQJBZh0CFQUpJDvMQPxUKW4JDIB2XdFhAxOYQjGFGKajSjFIRBgQbIZVGrZDS5NnLAjrYIll8gIxvCwEUufCEUYOQirr7I7ktXGoxibAMe/tCHP+IhjWMowxjPUEYyRAGDGtBABUqwwQ6MkNQpjMFhm9kMJSUZScs80ksAnmQWsBpJTVqhCl31qvbGWlYrnFV8V1ilb2CJCEB1ImeqWEVdUXEKUjTnD8MMQxwY4VJGMCIVsUhFM3nAg2IiDZoG2I4ABmCAAqBHAZmC4GNnbJ8F/4CzU+MxSAksMAFSyagDekBE2y4xwnK6rWmUoMTdKFLa/zwEJL5a7bAWAVs/lCQlgvtDHcb8h0IAokJ/UGggWhGKOMBAohq4wAIacFwtJneLy7VRcsHii2FAAxq8wIUvgrHduFY3u6+A63GGkY101OMf/oCHNH6BC1vIT1w0MIwKjODpK2FpCkxt5H/7C6aJYQZMzsvCECYmvU2uhgxj4J73XPbgCEt4fGrVw5oX4YhJaOKcpBg2KTYBCfyVQQc8YIQwetGHDixNgHl9sTE70IEHdEADN67PBiv3HQA4dsacmkDlbjwBsJzKAReYwAUomORilrhpocCECundtilLhP8SlZiyfwREES0HSyP4C0RKCmHmMxsc4YCoQyLWnIhA6AEHKEiBB4pLUQdg8aJ51vNya5QV5zYgu7OARjNY0QpVoMIUoxiFJzIxCUgwqyGaCEU00uEPSZPjGIwYGA9gEAUawHcEKXCCE0CdVCVQhr//leryuqD05pWpqpdknmUQvJoxYN17JAvDGDaJawlvgWVskAIZMkQhHfoahpB4Of704JM+wEIXA+tABT7Ag0lNysXGfAAWsPCA9QjkVNvRFH0MEoACMDcB40mABRZA7gNMtHLeLIACUPACaL+AEU0TYSdqpcJL8LsSohc9RSYyiYmMZMsHOknBC+H616vE9Sr/+YOa+VAHOUgUBRXfgJEpWoGM4znPex5+RqcgAxT0IBeU6IAHrK2B4kog+gpwgAQ8kIM4IIMc/JA0OqKhlEBgC74qoEEKSgBqUI8m6a4uNWaieurmQTVPa3B1FzQpPlnPuntb57pZ05Br8YEGy+SADvRAD+CXJ52Zg8QSc+RP38EdUHXAC6hABljbB8RBINCBT8DbC/ydV8zIfNQY1lRTAGSQ4lEQBXDTASyABpDb2BgAA0zHdRTW/zTNCNWK58UN6E0ZRZzeDtbQI1jZRtSN3vzNg7hemCEhQ9RBIczBFOjeBszZBVwAVkwADP7enQWfxw3fntUIRU1AA6TAKtRB/xZdXASYoQNwgAj8QCEwgjOEQ+vwAzpsAzdMgzEwQg3UQAzEAAroHqhxUtedgcREklX916oBWBY4hn8NGNU1XdhdwROAzKyRQSiJFYP13/+pRgCeQQ7gAA7kQA+MARog1Jk5RyOsnUg4UxzAQiw8mwpwgQr4nLXlwBzEQRz0HSN8wN9ZBQpcC6lgkzdpytTYB+KhIJAdQHE5QAHs2AFMhf+AwQN8wAvEQSSMUDVywg1i49qYHr3xW0X0yq8Ai0Y0QiM4h+ut2SEgYUkkSx2MAcWxoAVIwATI48X93hViIXJtYT5ihQVQXAnIwB4AQyOkwFCtgAmIQAiwgAmYwA28Qf8j0Bw58Mu9hAM1cAM0QJwZ7MAZFMEOVIFiZEkRmEbFYMYlPU8SUJ3yRJKXUF1VYdJuXM8qxZr3gBXLoJL/odUqtQzLkEEaqIERvRIgqEGZLeAn1M8k4IDdIRMYMIAFjIAKoMAUTMcGeIAHoAAM+EEBdSDfOQ1WZk4CbUqmKB5YCMACwKMEqMqr1J2U+B22SWMghIIN0lu93SCu/Aev+BtzBJywOIcRrtlroWNKzNAfTAEMlN8GGGZxWYAF1OMVAp/G2Zk+bqEJyMAM4EEN4EAjAEMlqMAM2MAIsEAQsAAHmIAR1EEjWEI0kEM81IPojEM6jAM5TMMhxAEdnEEUxID/wmDdFDABE5hG0j1VShoiJhFYIVqV/GXSGUxY+IBMrekfG9QkTkLnKr3MGfCkEe0BsxTREqrPJnyCJ3TCImBLUlbABaiACaTAEwzVD7CACpTABgyBHuxP/3wAiqFY3n3ACIoNq1SNAFgQAVxcAgxAjR1ABWSABeYiW/bBIYhWJ1xjXNYb6FlZD5oeRciT6q0eOf5NwqVjSfjaIchBD7AnFB5mYmZABixmPd7ZFl0FZO6ZCnjBFgBBDNQACkxCZgLBjY7GD6RAChRBIjgNM6Sm6OxDN9SLONRCHIhBHJBBFOiAwiiVFOzmqE1McVLSSRZncMrfnvCJSyInJTJng5FB//9Fp/h0D5xU57M8S09qJyXgDCaUQiuIAiOEQik8Gwq4gRHIgBrYwAwQwgw0ZXuWgApsALyVAgHtXB8EkN+Viqr0J9VsCgFUjgMw1nlUBQMsWxZFIIq9jWjhoL29jZXtCr9NxNrlTV4+wjjupes5x6o6xyIkgh7sVWFqwIhaQImeqD3eo1WwqI0AQccowR0AaxM8QjNgQg0AwvnYgRTsQSMsQiSEgjTAQ5Lsgzt0QxlRAyOAwYaEgRSEQQ5gnRRAKROsn2ZA1Z4s4oBpqXBaFZ5k6W6s0kzKZFi5jBqYlRrg5ISR6cvspJo+i7MIpSx9wigIii0QgzDsQi0wAg5Egf8d2MAUEIIb2AAeDJUJnEALHOSsokAgJFMAoVgAOc3AKIBBGER/rsqmVI7VoIdVxEEfWIW18UAgMMJnYeNcNo1d2uyoXhmAhCNEzBCqliKGpuofjMEgFaZhQiGJmuitNuY9Dt/F2QghVMImSEIlfNgnbMIqQIMskMIpnMIqnIIqzMIr5IIwaAM88IM/1AM5YMMcAtVsKinwZKRYhQEVbIHznGSprRpLGufd6oaW+q2W5kl05uTLDO67htK9SlhOXkEopoERIQ7tnVkjSAQJlYIr+AIxJIMxNIMxuEIpLMIYhEEhWEErqYAMsEAL3EDFXgAKDCqiBhYywYIAaaolsCz/qWxQBVkQqyijMpJgdfjPgUbgBTKCCK3TzHaeg+qggKidI9QlaV0EXhrIOErvOB5COdYBGewADKhACoyAiB5trdrqrebqnS3XPNoIph1HciQDcjQDcAED5q4v+z4DN8TDePHDOEjDNEQDtopBbIRBEWwBFbQMyYSdIV7plprrle7GSepGVTVwZgguc4ZG//kfTCbuGWwBGRygGiDRHujWHzQERnCCKJQCK1xuMjzDM0xDNUyDL0QCGPgBHVABIuihEQRBC5CAD5hAU6JABAZCKcSdLsQuAQ0QMxnQqdyYqiDAeDhq1hzA0gDvywbCJJyQg9aKJsDlXHaj2kFCgFho/6lGhEdMryNAAtDuwRjoQA7IAPdywAZcAK2SqGIq7dJmUT3O4x3PIzEkB3IYSi4lAzRkwzMkQzMUGjFg7jOAQzz8A3mRgzQ8Ay3wABjshBpQAZpAIsjQGhlEzyIicLvmLfMc8N5Wabo2z+B2j/WkyROkASdZASZmTwCTgRRscFAqS68B4QirQivYQqGkMAuz8DPsQipEQhkEQg7QgA3cABIgQQsMlQrcJg6kAA48givgQi3AQmAF1se+mIwl8Y2V7KYcALb0DzRe4CJgwiiYHn9owjp7Xjvr4ITi5c4SyBB+46maYs8mAiCcgQ7MgAzIwA5zgBQa7fMRNPjOMYrWsf8d47E8YkUf7zEuDTIgQ0My8MJ2HXIiL/K91KElwIAZiMHIUAFiPAFyflUokQEVVOknH49xCqeZqGtLA1jTbWnLhN0pgwbdXs8TqMEqt7IrPwEVXIEU9IAUSOIcXCcfEFyzYoIn1FIr5ML7QEM1SPVUT4MyhEIg4EAMFIENvAEcvOJmygAeqMGVbEEbHAIq1EIsrCJT7Fwc8EAc1MC5dBB3jI3UDMTfRWMfXJgoiIIOulMnpBMOyuXaVAJzwBAQ8srz2uxiZ8QjCMcMkXEi1IEU4EA/q8AIjEBAX4AHDHRBJ+Zn/17SIvStLrTTvsKi0VVqp/bP2IIK34LJzcIs7ML/o93cPqRDNcQCGMAAHbQBbLhkF5xBnmjB0ykP80BSqcF0nkCGf0HSZOhJ/V0BKqeJSI+G+LSJariJdWsSE0DpyJyBEL0EOoYEf5AwK9CCL6gXNKRw/k51NQRDKTyCGOjeBYzABZhAkc0ACuRABygBDXgADCBq3CXTzr2Y/iRNBInbA22HuUAjD1zl8I7QOkn4XKIQJ+xbJWRCJuyb8z5EDC02PO9K3jiCvlUCJBRCGuxpfG1vCXC20ULh8312jPfeQZ+oF96xjZDCKJBCdxLljm8tKpRCKrCCMTjDLpiCKrjCLVwDOjBJPNy2JWALHdCGcDeBFlj5lVu5q53aliN3/95STJWWa/2lifWwgXRfT65dtxNgd3RvgZV3QW3ogTBxaERYQieUsNiSCFE8A3tL9TSotyvEwQdI5WVLZRW8wBmgwB1sZgpYHhYoU32uLAd2oNZAEKkwALRF43WgGDV6p4R7eudNeCassyZk+IYb9trZJb/dLL4RyCVoeCPwQRX0Mw2oOAq0p4vTahRegIzLMY2Xto18QiZwgidwwtYe+YaxQlwleTH4eTMIwzFsgztIGjyQwzNgQTH1tmxceZVj+bajWqqpX9Qp99K5tAGvdCZhzMWIhnSTBtH9H9Gp+RU4gRKIqxasQZ2YgRDtQV+Od4YhuS1U9DDoeVlMgzREQ/8KDwOdfkBVDhUXzADEtsEQEIENFEEbGFMccKzmDYxVYNFhrcu6KA22uNjdaao1enqtgHrxjvqo18qFT4SokriqTxnpgWokZPgknPgOzPpQ2fqt4/qLE7QUyrhoz/FCL1dcoe/76jEubW4z+JQzPEM1tFE3zMO0g0MsEFa2lwGWd0G3Wzn7CeKXUxKYLF1zy7SecAzGqD0qP4ESwDsmwrsTHFXwNMGb2wlsaMiaAccj1PmRuwIrxAIuBIMxKMMzxFFRLMMzGEMqRMcLFAEhvAEXDMIW8MEV5AEeNEINAHgpRAJ2XHUxWRu2XZtVeEUHjLwzMY0p8LUoMOjJi5A6XeP/yrMzJuybhpP46JU6zNM8gWS4I+jBFOTAzjtlCbD4VBr/QA+00H92+Ba90Tc0t0A/9KewEzVDoCnD9TuDNFzDOLDDHaVDNhRQYe1JbOC7bJj/1gcnTD9PxJArchMnAm8BG3SMmXPMi0Kiu7uy+KDJcGsB+ZtBGwAEHTptCNLRM2dPoUWRMHkaFapUKle3fBlTtsxZRmfMnD17xksVpjZ33Ay6AsgNoTyAXrwI9KpTSzpgXvBo2eFDhwwZHvR8gQVonzh9ApWixQqVKU5LmWK6xJSpJqmaMGHiVPVSpkqUKnWlxLVr2K9av36dNCnTpERnbMyYoYJGDBUqUJSwe9fD/wa9e/VquGABsIWdgzNUMHx4QmLFi5s19vgM2mNp0qBFftZY2bNo0sax8xeP3DGbHyqsWWMGdeoyq1enXtOlSxbZWWLTztIEdxPZuXPfpl07NmzhXV4TDw6bTXIvy71sefJ8S3TnV6hXp+4Eu5PqzXOXSY2aYBszbehsYWPnD6JHkzA9stQpoitbvCwui3ZfWrRq06o1M4WojUrswKMONwxJJAYYGFFlkQQ90OADGHiYkAcUOuigpw54iAOLPjwEgxFWbDlKFU+WsuoqFKHiZCoVr5pKKq226iqTGrXSJJNLLnHqEq4a2WOMtmRIIa656rLrSA/y2kDJJTfQADAoCf8j7LAKFrtygsq0nCabaaaRZppnpPFommY8mowacvDZBx5wQhntAdPk7AI171jzzgzhZtsNttt62w032YAbjlDiinvttyySY0O66J6DzrknInVU0ueUuBQ6JpJgQgzw2uD0OzPooEEIKtigg49CEvHjkEcugU8VVnCxKLP7+KsG12mSQYUROuRQgw5HxkCBB0tQ0QOHIR+UEAcx4rDphQt58LAPRhgJpI9QaMkll1laGcXEqk5ccUUXOekEqqqcUpddrNTtKpJCzpBihxlSIFIuuu5C4cgS8lLS3yU1GFiDKacEDMvFqqlsGmi4xLWaZxrWErKIo6FmnH3iSScaLGz/2klO07poTbXWBJ0tUD1385O3JmoT2bjZhkt0OPMYbbS5Rp2L9FFIn7gU0yQ2xRM1MVgTo9M2aCCVCTIQ+iMOOgJZqBNRjLLFl2AykzgbiHNVBhdUnj0kBxhgEAUVMWJYYQUVSpBCDhRyMCMOMUaj1lpLGLGkFFuAscWWWUwZpRNxr2pKRXQNX/zEdh3nUcetHNGD3h2GJLJIuvjdHC8PShgh4CcJvpCwgndCOOHEiFmdGF9cp+Vvbml5xZZcWGGlGGRi6aUbcuAh5xYPxQgjhjUIOk21kr0LdM9EBY1NaN6a/03lPrNYY8+aF2VuOTaW05nnn5UQX1LpmmgNZi20/+iCINjWYIMgNuago44//FAvkkhe9YQUVFqZJRdaa4YzNoMra2Sja9O4hbVw0AEYVAUFFtDABBpggRqogQYe6AAOwDChoeCtD5GwBCtyMaJXIIVwj3PcUjqhOKuoUEeUOAslxPWVS3RlEpAAxBzGUIV6yUAGMRCikerCuYB5zl97IZgGdEKYwKBOMYfpyQOS4glRDG4UpzgFJDwxiUUgYhGWsAQseiENanQDHehIBzdC0Qc/jCEKOdCCyL5DNNaYgXnZm14WkpDH5+1RN9arjcyQk5wt5OyQzMEZz6LjBUyV7wlU2JTRjLO+9ZlGfe9blBrUML+oseoQC6EEJ66oiv9WbGsYxFCGM8BkDVeCaRrLqAUjJmSKR8DgDCqwwANo4AYjuKEIOqBDH3iABWsdkxHVKsUrSjg7FBbuXe0iV7nUhbiq2HBHKcKEWRpRBzJMYQr1moEM4jLEzRnxLp9z0sCedKEmZuCJFriSFHvClUx84hOb0Cce6HCIQ3iIEak4Bja2MY5xkGMcakSGGwNBhhzkwFB0qpMdy2A0LexxT8xj3iD7JD0/YbR54HOUdJ7jBJL+rHyY4hkThsAEJpSBUOobThuS08k5zEENZ4iaHkD5iEisBxOlfAUtaFER+4BpP5MJUzNqEQpXWOIDjehBB1CwBTy8wRAXfMQjqhUKve3/TW+WcAUtAjcLVqgCFSl0SlceVzgdoagqLYSmGMWoI7tWxURX4Qok/qAGHxrBBkIS4hCNRMS7pOBzdlGSXvLizibGU54TqFIFpiiJfEqiEpCABCkcsQg/jPEY1uBGONDRjW+YwxzkIAc4SkEUIOkgBuFBHsnuRMlBogxlgdINSP3oR5CKNHwlvcL4IgU04vJMkkiDqZzU14RLxo88ApEuHXbqh0CEEozu6UT/VGFKWvBiGKvEz2TE9AxW7iIQlhADDMxABSI4ARBM2CojQgGLVKTCq14NRCgAN7tWdHdwbu0RDatSibeqK5spkuuCGYyVS+SVE5XQBCTogIYqGAGw/4EN4mDzNRci8uteIxCxYpnUWMdCVp6TPQwoDKEIfGKiE6FIxS+iwQ14vIMf9FiHOdSx42+odqF+0MMYeqADHOTJNKE6mnIJhVtA+Ta309tty548G+BC6grauUL5KAUpRp7PO8NpQh+fS1M32AHNdqAfHW6qBzf/IRDWxZ9VPGFFVLDiFbgI7zI8EhkCSsMa1VCGKw7hZgzqgAxRmO8tnlGLWMTCvtdChS9M6ApUXLoULRwwJWrErh2xiyqYoEqD7XoJS/x0q4twRI8c0YhCjMEKU8BwW9qCAxxweC75QoGHQyxi0DVpSY6FUjwnsBMVQ6IRjqCEJUKhC2mEIx3w2P8HP/RR7XWsQx30mAc6VhuKocihBznAAQ/yRBwz3HE1SFMuzMS8W5Y92d3N+1PL6C2bRvWsfF6wTpe5zMgtnEELrZFpF3Lz3OSc2Q5ucAP96iBdN/M0akTB3yQiMYmqoWKsuRBGMh7jpWhoA4H9ITQYohAFMHyW2btABixgEYtapCIQjHgFpZ2J6VKIonBlkYqnDyxqUTf41CIUI8VRHQkCT+JH4NxBYGcQWBuI+9Yc7jCvey1iYAf7QgOD7GAma61mR8Mb0Z42P8jOj2n/Qx/uUHs6yOGMOLxdDuLmwZHlZAYxgKqi6rbtbd/t5HrnNnq3id6YhVb4PjYB3+ODTnX/smMpxfO7UWAug/rWV3D2mVnhmUczGxY+XT0g7ZOhvFar3oO2ifCCGI7hTza4gcAuNeMWoQgEDxhRivouoxeQjgUrQvEIUdQucK5ASimIj/NtfgVH7XprC0fNYOc/H5qVWEsOdpADpzNdBzqAutQ9TPVeX30vWdf6E4092TJyQxzpiMe0+/GPevjD7OsnezzQ8TtxwIIHYBjDGMTdA/a679zwJO865dy6gPIOsDc6Ko/+xE8MDzeiJwmGQAIn8PBaSgmYQPGG6wmcoAqwwwgUDzp+ZgiApt+MZjVkag0Kz2XiR+EOLs1OpeGmKwxm8AwMwg/8YChiToTggxViwRaC/8EYzIRLXC9XGiYYQqG+UiEWfqEXdKEWXs4S0AYYfCEXTmj4SmEUREGvkC8TFoddFOdECgf6ng8TtKIQKmcHZo3pdkAHaiAHlmZpcK377iXE/OWI+gJKxs8CDKP8qiQe/jAepI3s/MEf/sEe8KEezsEd2OR3yCEcqoER6ubtzkAO4mAMyk04JgpPkCZUvkMLMNEA1yc2qAze6I03IlAC+ygLqCAMtoAMqEAKWFEJxkAJpmAWlaAInoM68E0XtyyS9G4Gw0AKwoAMivEMjvEYb2p+9mAP6Ofh9uAPolEao7EQ/GkRrnESKOFVTKEU7gyAgLDPbqUaDshLngEZdMG+Uv+h5WoBFkJhb1oBGIChW/4Li8DlRCrBKuQKKkRBFD6hzvhRCzuhzqxIFDwhrpxCDAvSEzTBEfhgCmRgB5bu+mygBmoACGoADuGw++aCDlNgxI4oLzTgSchPxQxjivYBH1KyHlby/QjRH1LyHd4BHtIhHcIhTGphQ+LADOSAJ48RFAPuTuyOE4uGADsxFEWRZVpm8AjPAXOjKVkxGIUxDKZg/8Bp/6RACISgCIpgfHaxF3VxBqVgGMcgDMagGMngGDmJk5SR4QTiGacRLqlRVRyh4l4lFNBGFV5hFn4wvAhIHL0EYqSBGXKv5WLBFVJBRGTnhJKiIAsScVhk56rpXDj/oc6YooX4kcFwroUsYRKW4hM0oZumgPoiUiIDCwhOEwgyUiO9ryPTKYmUSOsKo0rKryfewR3Q4RzOoR3mYR70gR5SUo3SIf20ARyqQRdigZjezgyOEQ3Q4Aww8WhqS+/UTQDv5AAV0CkN7/C0U2iGgDv7yKXCEwMvcDypwDlwcSu3kgnMMzqowD1dahbBCZzQYAzo0znT4AzSgJMWJfPOzA3qAED3gA/44A/4gBnhEhpDaRG2quJKDxVihRZi4Rbog89gyUvMyBquwRqkYSMyQhmEARdwwZlS4eaQsBMOzNRgrIVAzV1YSNQ0YcH48S4vs87AxRMyIRHkQDTBCcMi/xLDlAA1VTMj55AOQcc11yk2Z1M2DyMm1a4d1MEcvsEdzqH+0gEcqIEZmOEYlgEZdoEVJmQ5j/EsyWDgAvBOBrBT1C15UqO5XGYUs1M7H9DwKLA7KdClisClqOBS4FMJ3BNS3jNPt8A9qYAJ0pMq9685E1VRmzMN2IA6OI/z7OA86oAZB/QPmBEa4SwQpDEQrmtBHwERGEG7IOLSWMEVaoFCM2IzJsOMqMEaXLUanAEZemFCb8EwVeHm+BETJuFVNA3GYAgrvqLOIvMyZTRGzyUTCqE5p6AKOtAJMOxHgfQ04TA1h1QGVOBy7uVI+WKJTIcPCwNcM0Db2IFcc5McxP+BHLzBGpyhFxwNGWTVTGLiBcrgGLds/8ZAfarzTIWSAElGydoUZQrPO79TO+l0CFBTAo3LuERwBBUvTwk1T9PzTrdSCqzyXi8WY8+gGG1qfuaHUgeUQG/wBjtVZEnWUxdhahZ0B0UBIhBzIiriXe9jVc1oMqIBGYphF2pBRF/BFXAVIDHBEuKqhbQphrRxhs4iG3lVhtAiR+hKjPInEjpBEy7BEfYADUSzWZ0VWoEmSGmgWjUSiICIDo/USfDQdKjkW+WBN29THMLBG7bBGma1F3YhGIiBPyojFyrkBaKjOp7ALGHjTPdVTTWxjiZPC3ADO+dUAlGzYFMxAhE2YRX/9lIOtmHHB0/FMzzTswgwkgbE8lDvtSzJgCzJshiJ8QzUQA7m4CAE4kD3QGSti2RLdmQ71QbvZ0FPjdm60VRr4RZ+IWZZtWaX4Rd0wVZrYRZ6FhU00xMEshOCdkWVb2nPYqtSzRGq9xE6ayEYwZ8OwQ+EYij8YA/mAA3qJQ2swAqaNTuMK0indTXDtjURS7GWZLG6lWCMbSeo1BG5YUM3w2YxoiOaYWGgoRki4QOUxCv3bwaXzATzzk6US4HPVHredMwmEDUZV2APFggWt4JPU3Int2EnsAjkUyzFsirpBep2oOSGMSyZIAzKIAyYQAo4BQzAQN3ejrp2ys1uMIdH/7YQCuF1dVgP4kAODMJTH8EPFoERRKhlXSEWdCF3mCEapoEa8oNLf8FWDRMpWFYMn2J5X2XofgrVtPcQEAERAoEO1G2GxYDkxq17J+QFPgCOX6APULYO0MAIuEAN0iAN0OB8sUNhN/hraQBb3bcj4ddJFkt0CAYPB0McuAFLj+EYjAEZJpnPzOsyBNgWWuEF8iIDLOVQE1jvWoOB04067y4KOIWUnVI3JliDATmDJ7CVUbMiK5KDURNoJPA5DlYISDMiK3YMpmCE2ZCXUVgsw1PdmOCUmYCG1RgM3s6Zd6oP3Kx27ecPCuFSH04PePJecRgHh4lVlDg+etcY7MPjnP/BGHK2FoQPFULhRCkhf/QgEHQEaiPBWkhWKDqoJVpiQ6jlEI7JWGLldvJyW2wBFX5kDp5VLcs3azv4UrqWBmRgnAh5bF+zxJoED7l1J6RhGYTBGMa5I27FS6AhGWzhFVphFSpBDcAJB8JyGMnAgUk5KIlygU3ZaCzKuQCWlTHYcS+YglPxYOt0CKhAfLjyOZhAK4+xCISACR5KNOslIu8FBlIABrAVBlCASVAA2DRgsdxJg3ICq/mlJVCgJWAAB2oABmogCrRvB3pgCorM1nDAbOAaBsYaB9K6qsf6BXogB91DxmChFnZhF3qhXXnv1KglED7vAbzzABjgBeKge/v/GZmETozu0mVd7hZoARdKKBdcBxd4gRd8gReEgReaYVca4Q/SILD0WKGdVX0BOSPDVmy1tQRS4EhgUyQZ60HYCZGHwRg4DjJuJRsEmBhUYRQqIRNI4RQSYQzOAAdyYIRbmjphWgCn84FZAwGnDBV/+nEtcmBR8SIr8mBrAJaVgA2eYCsvJanPYAuMWqmRmZfDKSJzIGzl2y2EKCtpgHPhcLBgQIiq2mziOgey76FyoAZ2IAbETcBj4AWw2rHAtScqgDYf4DAyACc+YFroKyL8GtK8Cpms6z06gSgeIYyCSi9n4Qmf8BZwAbB1YcVvgcV3QReacMUBG8Z1wcZjfBeM/8EXRKERAgEN2oKT9th8O1B8pJWDjXxpIDqiL2e2aTt+BWaJ+KLE+AUjxFGAkyEXWuEUNkESJIEQTuGk1SDcwiAKxJLklvnuqFuBHTi60y3dHnAIBA+WKfgigaCP5vw0K3JpLPI0h6DAn5sqVbjMNTYK2roH7pUqLZYnf8V81cAKlCANyMAKKlaYdWAHxoAGbKAIbCAGUiAGbKAEYgC/lUAIBktzsHoDKqABpoiyGqABFADWGQDWYf0Aar3WGSADPqAm+oBvlNDGBfsWbmEXfoFuPTsYeCEYssZ1UmkYikEYhMHGA1uwm/DGq93aq70XfqEYIHmSmWEafKETEuG0if/ABhQuj5vzfB2vg4O06ZY8W508nUKyW3H7qlFAYrSEGICPFPDJshTBsjKBD6pADvivrqVghtGcU0K5DBKelBP+pU3w7razAVExCTJYYO8czzMYcocAT0U4+1C45MIyIkU3CuSAEstSCtBg4OWgDvQADerYCvjY0X0onHJAwWFAB/RFA+ywSS6EX5SkidxpAx6AASrgQuBY1ydEDFgFiekKIkx1W1ScPpDBGI5hkifZ6o+hGLa9GH7B64WhGLKdCcXe66ddsMt+27k9S6FYZlvVGrYhHMJBHNBV7sHBFy7hEPggDZzgB8xdtc/3PBma3TVMomm7X16Tfm+bLwS4ClX/AZ9AYctPQRUqocsVYRMMoXz5TweioAd6YISJMQzQXO/SWO+Y4KYPUBQP9/Q/io9UEE7lvKd1OryFAK5zQOkG/KGECAd0IJ/FLQp2/7/NJkFwYJPFesH5xZ2M7QEIY9UzwEKmKANewNZyMhBW9i5jhXZqJxi2nxho5SIoeRm4dJK3PnfCX/yRAZK1/hfSn/3TH/2Rge3RhBqugaC6wRvQlRzS6B2iDR7sL+69ASC8iYMHL967feTIaYtladGeKkZ+vHmjJo1FK062bHmipKPHjkBC0pgxwwZJGSpUpFiJAkWJEh5ibpipoabNmxosyFL1aZMkSaAkfVp1ChKkRD8N/+GZgWYHDDI4evQII0VKGDJkxGjVCobJViZgtZbR0qWslrNotTRpQrZslixlmyRp8jYL3bpd7K7dm2QIkBpAhtSgQQMGChiIYbx4ESMGipgxP0hu2fLDgwcMLjd40AFzgwYKQl++XOHD4hdg/Dxa3ckUKlSsXtkKRjuZMmXNnuneDW33M2e/nQkfzmzZMmbImTmLduwYsufIkB9DHq16NGnUrl3Dtm1buHTixJEjmC4dvH380KPnx94fP3/w3aePhy5h+IH71u+DNy0VI0Z/WGGEDRNVZNEVGW3E0UcghQQESSbNgFJKKrX0EmQybWCThjhpMIlPn5wiiSKbbAKKIv954GEIKJsY4gQXO+QwRQw4RFGVFFM88UQYYGwFxo89ivGjV2WU0UVaaLG1lxZjdbFWXEnotZZec8nV1xBY/kVDSjGktCVMGlQgZgY1VaDZZ2eOpkBmL8AQRRyILBIII5FEYkkoqqjCiiuy+UJbMMTchpugty1TaHDLDKfoosJVt5x11WFHzaTXZMfdNgIllA45m8bj6afx5MfeqKS299578f3jzz+s/qMPe/u8Y5846JxHKjzRhPLfH2oYMcNEc8ihhhpcOOGFFxrp2NGCSjhYkg0RTkihSy+V8FiGNdF00wabVPKTJJuICJQiiuABCihv4DFgFVPkQGMUNkoRBRP/YYRhI5D49phVVmGYIQaRZmghRhNFFlyGGE6ypcVcavElxJZYPmwYZShs0EEGF1fQgZkYx1SZaTjoIIYefiASySOYiIJKnrPMBgwxxCSTTMzN1JxbMjULWrNxxiHDM3TFJRddckQ/Ko001lyjTXfehCMeQQWBGmp+VHtK9ajxuRefPlx33aqq8Kn6datd6wMfP7KK4zSt66WXzjGWRALgFQMCO2xFVnDBhRdcbOEERxt5FNKzJElIYUrUVgvTTBo2rm1N567C4iqrAHXKKSWyKIkNK62kAsWnnabYYolN/BhlL0j2AWUeXNzB67BfXFMGtFeQAZpiPvBZAwwwsNll/xh3IBkMYPQRyCGM3FkKbHzO0nIuufgivZ9/DjPMn9IHYz0vvvDivS+/CLPL+OP3Yv755zfX3NDWTUoNNtx10819CaGTzjvvTH011ftYvU89AAygqNoTH3ysalWuGhvYwsYqfbiqbBDUxz3uUY9xyE9+4QgHOvhRj/xxoxZyW8Qf6mAHN5TQDQZCgxXy5gQnXKFYTjCCEYhABGjZcAc0kFZjplUtDDHuh49jEShOcS4TschEnwiKIWawktNQDHQvQN1iWuIBKqpOda+74uq0+IEqooB0OOBByMRABz8cYhF0skQnVLYyV8TmFbOghS1sAb3pTc97vNiF98iHR/Khr/8XughkIM/3i18UoxjqY1+kKLWdbXRjbeGpH/7c8Q4AusMd7bikJi9ZD3rU4x74ACUFA4gPfLwnlPgQ26o+GcoD/mOC93CgAxUotgZG8JZc84c7LHjBbozDH/aoBzyuwYr/AEgPbmDDCYeVBjSgQW/QhKEMiTBDaM2gBjrIAQ66pIIdIi5xPfTATMQJxA2c65ySK1GJwLWKT+ChdDBoTA5C16Yphm51LxAeFHGAAxjwIApiiEMczLiIR0yiE2tcmZ5iUYtayHGO0ONe9+zoi+iR76IXRd8uBMlRjprPkOqbDjMiJantyM8b3hiHeMiBDnS44xyZnIdM6UGPedD0pjT/BeA86mGPe9iDpvYI6k9patOeGvUeN+3pPValVFg6NYGy9KlTJxhBBeKSbD7tYDm64cimjaMe+hCmNEphzD8gU5luSOuwnBlNvbUwhtQckEmwqc3G2LVLKPic4i6EoQwxLnJHzNwnfiKLVSjCDTnIAQ94oBh/8vOxUZAKGMYQBz2Q7IyPsMQl1rg8VbiieXKEXvSmFwxgBMNP0iskHsH3izz24he7KCQhC/mLPxajkIgM6XOoczRKwe+kXr1PJNHRjkwWt7jsYAdy5ZFcecjjps597nNv6tOg0iOo1b2uULFLj6l616llA68Ep4rL747tqmNzjzvKMQ6VtnQe+HBH/zqYoStGJGKEdmADHk44BzWgwSJtbSHd4mpNbGaTBjv0JuJeMoJw9vWHQJHcT3zik58QRRJv0MPxkmeJO4VCFJ1thfPmSEdgvIwYgIIZMYzBYutZ70/BEIaMZyxjX8g4fIUUxmzDF9LmEG2R1Ega/Lo6jvq5lJKU3AcnSRXfAFaykvKYaU1pyo4oy9Sm9GDHOqqMZZxeeacBBKAnPWkPVC51vLGkqteeGsEJYlfN+tiumrOWtfB2bbtEnYdyz3GOcrB3HC1Fx57FATdHLOIQZt2DG+pQh7TOIVhpIBYXrkDpFhZLhjL8gQ0MnAMEd0nBLUlBCUZAasU9eCbg8gkoJP+siBEBZUSneJmJZXYbnNns1riumW0K9TPo+Dq3zoGOMIKtHJIGORva4AY4BBIe8xQkav3bT9tQVWdczpKWZAvvd71LU1jmdB6XxB8AzbxKUP4jlavCh9nW7Q92q1JV7I53u+cdn1PhIz8dfMcmMRndfic3ueVgh58z2WeYosMcBXGHwNHhDV1YwtCFKMQe+LBoRi86WMOKZqUvnekfGEEIOziwpz19uM6V2sF9/QIc4DCIVpMLDoogBByg8AUoSAIYzZBZMwqlDOM4Yxm5xnXPEzWcaBQbyNvhjjfAwXSUOi0dUvuUqNRjKq3N22x0zhq2uYZtWlr761xv1dnag9X/qbpqgqwy4Km0tvZ93NuUbNea2wFYyUvyeRx//sY3xqH3vuvdz4APvOAH3o6WbnJq7jAHOa4Bi0g0IhER18Me6oAHi9Ph0RnX+AtjiGmPFyHkOiBMY0iOuM6tZK8w6SvLJTGIL3zBEIPYROtdv4QgvIEUudD50HebHEPdZueFckY1spENZYMjHJyCR3mcHTVPQY0gVuMHVaudyzrPu4EJBNvaqU3nrisQgbJ8INbpfMv0av2WsYTgudWzP3zT/R0t5TPg20v/+uu9vYMPPJ/3L/BynIMd+7d/6HAOgVYQmRQP0PcORTYNpRAJjnBfhcBolGd5lydpmgdDnOdxRiAF/zoQeqJHep9jeqeHehgyCINwIlBALj7RepLgel/wBlxAB42gCq8wDMRHKduADdGQDc/he7w2DUwHDpxiHitVHyzlDp1kU7skP46EDd1wDjuFD/VQSur2SqDEZACEKucGSveWHumBb20jQPAhhVM4hmM4hQCkVFzzXW82Xmhmbd73ffwQX5jEZ+3QZ4G3d/jnZ3Z4hwH4f/+WXMVFD8U1D+3ADpo0SUfWDlH3bFCTH/HgDp9yDuHgDcsQCg4IeXygBxLYaGllB/3VBmwQYBwnQ0EgQzsQcqIXAyCIAiIoajDBVxjCcqAwCEBhgi7gA3DQgkiwBEhgAlxgBXvgB7GQEP/ItyndkBDZ8Aw913M+swzIIA1OEw7KBw/jQICB1g7z4FPXVQ/fwITd4IQuZUBUyED+0IWkQjWlVEAD5IUcNG0EdI5UaED1Rnbqt3XUB0FutlRSqGf9B3j/+A2Bh3d4J3jqIIjH5YfFZYealJAOSYhd9n76hj/wQEktRQ7iMA7hwEvdAT/wEw7hiA2Vsgtx83iF8Ad7MHmTd0J2QAdsIIoa9yKcZ4oeJwWq+IGglgIq0Tl71Vce8AWDIAixV4s05wM+gAQ3gARfgAS7GARu4Ae3QA7hcA3bkA6A5jRMNw3KYAy3gQzH8AvIQA1OMx7wgI2B5g7b2FP6MA/f4ITcgQ3/3zCO8sh9/jBu80iPBSSFTUVdXeNmb8YqWZd13xeYpeSF9XBJeiZ4freYftded+dn6mAOkTmZ2ihT63CZ8qAOmqlcynVcUiZT+8ZJLwVT+6dSGsmEHgk/2lEp7uM+q9mRlSINjecIJnmSk8cHk0cHaZVMbTVpMjmTEWEERVAEQjAYhLGKFKKTO4l6qQcZS9B6SgkUS+CLrecDNMdyUOACeFAIwQAO3MAcgVZkywgNtWYMw4AMh3QM1tBs8MBSZ4mWQWU27RCO3dEd44CEY2hKp9QP/fA11YeXVKiG2wZBPQWYgVlAeUmFmHSIAFcOeriYfCeQjNl39Veh1yiZmpmh/5N5kOzAoTKljWjpDvQQosh1DuZgDvTXSxeUgx65mkmnmpWymtmRNKw5KdbADdogktTgDGQFCQ8IeSg5cXxQB7q5m7sJTQjiVi2EacMpBMV5nMiZEsqpEsyZciYIB19AIllac0uQgiq3lC3wBo7wDOGRg+mADioFDs6AC7ngCrRgWsQwDLVVDMxgDQlxp/WDmBMEH+fAVfXZDeiwjla4juCHZunXVLEEH00lZxQESvpAqOcYQP4YiMnVXhNKofXHZ+ZQDgcZmSfaqSe6kH94hwNYqofokMn1hyZ6oii6mCuamrAaqy6qHSIpkjG6mtaQq7kaZLqqq9qQDddgDdSgDP8NCAmPB3mFgJt8gJskVEJsYKRICk1vJUPE+aQ0sE11VTpTCoskCBkwl6Vd+gVLAAddOp2DoJRQgAQtwAWLoAycIg7dYJXJyA3LoAqeEAieYGIw4z3CQKfYYB/nQA4EiJbzkEveyITd0Q3t0G5nh3bgJ15dc6DxoVMLKn8ReqmXaqGOyV6Cx2eeeqIBd5DHxWcLmkkNuUmFF4AnmqK9xKIsGqswa6u0CqPBaqPZMauzuquM1KvVMHzEZw3TMAyd0AiTQJvI+gfLuqzNmkx2cELRGk1LqgRNOhjalFjblBglVy3cai2QYYs3MAhJeZ2DAAVG6QNL8AUncAEn4AVxAAv/3LAp4DGN4JANrVAIiZAJnuAJuQAM0cMLiMQM2iAe+1eZ9NA1bImw3fAN3VV+9/hKpfR+l9RSfnaxGEuheriHgFeamHsO6sC5mql/g3tcdRhoKtuqftdLv9WRMbu6rAuztIqzN6sdwtqatNuaPXu7xFcN0uAMIFQIPvp4h3CSfzC8KNm0THtCaTVpvdlCHvF5HZgD2cRPMYC1UiqC1kIxHrAELMABLiCuSOAD5yIIKseUPnABInACKtAIobAL1kB83FCJ2TANzXAKhpAHhLAJkKC30RMMxfAc0cANAktcOxWfXDOfvfQN59Bu6ueX9iBTDVq5jKmxFaqqFCyABBiA/yZbsqXaUijKdyuasK0bwvX5srCqurGao7VKs7KrqzXrPtVQu+4zDTIsw0cTDYuCDL9QC2SVCL/bCIggvMS7B01bQsibvFfgBgHGvMSZionFxDMQAzIAAyowIa8oai5BLT5wAr4IB73oA18gCON6Ai6AlDdgCFyMB5uACrOgDNUwDT3bDHL0CYQQc6cgC6TwCcCwa8tQHdPwHegQD3NYNu7RPwQBj7CSHvVwlnxWqtholoF2ZKGZb0i2SYcZblOjP/DwDhUJfxd5pxmZQd7QDSj1wY6koqbcSyiVyk7XNKCcQaCsyqucytzADbA8y7ZMy7a8DUujDbzMy8T3s7dLw/82DI3HcFu9sAu30FDKjAsNFQuvgAqXYBSKYAiGQAiAcM2AgLR3sM272Qbe7M29qaRLagQ7YAM5YAPlLCEygBLSspOv2GAv8b3iiqVGiQQssAQ+wALk0gJQcK5QAAfhkq/VEDPEMAt5IgmEYIun0E6ksAp5jBuNIg3JSFzq5kDukW8tpW+XVFxnOUnugA4aHW4a7VIk/dHoAIlSkx/4s9IsvdIEcZFqE8p+SsKw6qJDprojnNM53Q3cgCmw/NOr7MquDNSzvHS3PMvJhtTAmqttLA2O0jPGYMy6kMy1EAuwcNVYbdWf5Qqx0NW4cAu0QAvPTAnSTM3WnAd5AAgpss3/d5BWbZ1W4BzOLVQFVcB5NiRX6rzO7VzFpEZqipDFLrAEguADLYAEuYgESFCLhB0EZ/sF4EIKrTBHvkAMwEAKm5AHr3YigEAKeYtzzfAozEANgCpo9wA2I81SnCuI4IZJDTm4WIayA5uIUPMOy1ce9SFc4jDKXKWaNY2zrOnbwD2z8NPLxM3LuqwN3nDURZ3cyr10y1bU3nnLvZwN1tCz0+DUw4yetbVRU13VXf3dXQ0LWg0LW13eW+3MrxALtPDVYd0KpUDWkEAu1UwIaK3WeIAHbJ3fbhDXSWwEdD2T0CJXJqHX65yc79zXg4DPPiAIioAE4usCgjDYvtiL39ty/7YICnkyR8AgC0BBCB1uv+ACCJCAc8rwDNdhdNTwDW63p/PgfwN4jQvZuZtqDotceH5YyUgYuaN5d3v3yn7a29rhmsE95LjamrlaKUf+ujiLDcCqDdcArEoDrL9MfL6MbL865dT9wteN3c7ADF55SOYTSMmczAzl3VXdUGI9C3D0CmzO5s6j5m3eCnL+Wd/N5l4N1rPQCqMwCdI8zYRgzdiM1vid39sMzkgMtTH0304AEQFuQwOu1wYugn09AuTKxUeJBIMAB0dZtphuCBVugq0GCg3dToYwzW8Qe2/g0COyCqRQCJ1gDDL8wtJwDQq7hnUpiPt3ohUssOLQwTL9qv81nR3uQ6NBfuRJQ+y4ysK9muQ4a+y9GqzIDu3LnjTUTd3TXg3VPSlN7She3hzGDEhTTdXKHAu3IO5d7VC0EEfOw+ZhHdbr/uZtHu/y3gqvsNXyzt6zwAp77ghlXc3XfNZrTeht3QZHmrxupehTkIoKn4onIQOGU70HPgInoJRejM++eJSW3gLVidiCoGqr0CKDkAea7gOSgNk3twpvoAirgAdjgAOMAA1M5zQaPSqcrKkrOw6jTNNBDsM8b7M9X7vX3rPTTqPI/uwrPO02mu0vPClb7tTD8RzFXAznI0jlTuZUXebK7N3gDd6vQN7yXu+sQO/z/vVw/vVm7+a0cAv/as4KolC0fT7fgADoAU/oRgqt0ITwC+/E6qzOEC/ppOYCgb3pho2l/SwJPuACLdC9N/AFq3YusqAINgAFNwD4jK/yp/AGWPoFQRAEMyAHgQAL2SAO3ADl3BGbR3P6qI/6J576vfXzrg/Dpx9krw/Ds3u7rTnDNMzlXY4cUP/lUg/uYn4LYk71VZ/1Wv/d3i3eXW3erLAnbe5GzU+DW9381O9G1t/8ryDn2i/n9f71csTmrOAJbh/fjTDff37Wg0730HroB1/XTpDweZ8DDV/ghxPpsEi2uigIK5fYkgDQKrcKADEoyA0khECBGiTwxhsWN6C4+LJJkaGEcAbBacGi/9IqW8aeOUMW8hgzZ8yYITOZUqVJZ9FcvowmTaZMajWnTZOG0+a0mtSk9QQKdGbOoTlvBr2ZNKlMl85KiiwW9VcvXVV7Xe1V7FjUYsJ+Ta0a9tZYsmXJ1kKbNm2sWrFiwYLlSi4runVV2U2VNxVdvXrr/gX8V+4rwoVp2Zo1S1WnSY0gQVLUyBAhypQBAcpzR/NmzW48f3bDRbSTKlWcOJkyZccO1TtyzIAtQ7YK2rVpp8CdokSJL0h8+BBkcUnwL3CWfAHVmwshRZIGvbn4RZIkQReDE8oDh9AgKHC+DDolK5dHZ8vMO20Z7dmzl+lhuiwqc6nRpNSq3b9vv5o1/v/9+2ezBsD/rLmPwGpuYioap5hZBhljjBnGq6moqmoXC3XZBUMMsepFGK2QOQYZraLyqpddeLEwRRVX1AWXFHnhBRcZZ7wlLVpoSSzHV3J0q0e35IIrrsKGJLLIIhFLzBROKmlEEsgkq8yyPPCgEg/OQOPiM9G2NA211qpoLTYZbCNThdxyO+E34IrrDQ4fWvjOh+K4yOMNJN5YIs82B0ECDjjeAAUOKJAQwQUkWDBkFVmASaaZ8tBzSr31JmUPvvcunSmmoZRKCj9P8ZtPQafMa3CrErEKSxcUV0xRRlZV5GVCYTwEEZkGi/kq16lgXHVVFmGV8ZYZcRkLrRtx1DH/sVdiGZLZWOR61pVWjByyFWutrZYwZFvpJJNJDHFSkYkmqwyzKq28EjTPtuSyCivAZG2112aQbcwyazszBTWXQAKKPJeAAjhZJEGiYDgUeYOLIBaGorcvbnA4CEW+c+EEDrojZJVZcglGmWeWYZDBZZyaFFJIKx3qJfaemYm9oih1qhllZn4Qwq94tdDFVsm6UMVhZ4RxWF5dhdEXX3SdVRhjQlrGVKpgvArGF3n11ecYiQ22WLXQynEWaqm9dlojwyb72hxViYQSSAx5LDJDyKUsjymr5EwzO+xQl90t321NXthiiIEGGlQY/F7bfEiTBCRcMPQ3JEBRxDcXbpDk/5Mg8gjijeJIOOEGRZKD4iJBfeCgzzxAkeUVX4hRphlSzzM5dvQolXQ99GiuGUJhggnGaF94zeXnn4PPJUaqpd5lxpxxoZp555M/8XhejA5m1giHiXBp80A85ithetnV1+NNXNH5Yc/auhavvx4b22tfaUVa+Msu+xVkTXlkksfalgxu7OSeW93ucLe8sas0pVlNAnfwt8ANTnCGq41vluADF7ypYi1owSAEobjHSaI3oMBcBV0QsLflAVyGKI53KJKxxORiGI3K3dKUYYyZJSN3Dooh9mbVC+Qlzxa3+OGNZmELIhbRiEXMRRKVuEQmKpF5x3seilzFKqkVzRe8G//GDWc2w6aFKEQiItEOrWg05GEoecILVi2OJcT1FQZb86Of++TiClbM0Y5xnBayUDGJSuwPEo2QDCKiBMAA1k1dWuISaVITr9UIzpEOLBwEW+AbDPrAN3BAwhIGYYgTCEIRcJiOuG5gyRG2SVGbcA4cDjIIUBBiE60YIi58kYwZQgh7WRxGMHJJxhOhkVhaS8st1rjGxAzTiGtM4hGJOKMkGk96VYRVD6l2RV0+aIZbXMbHfqEVUtkqJDjsyi+m57uqSS1YM7IFLoaJrCLhkWx1pONc6BgYVsQRWazohCb++KRGJEKQgIib3OiWrkPqzTSlSc0id1CDRz4SgrQhwSD/lvCDTYAHFEtwwRJaUEE4bMKS3VlCEAq2UUNBQRar4ELD4CAIQZz0DYmghS9cmAya8o56NuVF8a4mPCKuc5jCLCYbczRMNapRa8cSprB+mbWxCC9n0HsVD2EkjCzSkGbYdMrS0NOgb0LFK+MkZ/SE4QsZ2eIwRSQmsto4JDu+4o7ufEVd5kmXOBaGFaLQp2P+2M9/SmluVDJkQQ14QISqRgcNbehDW8AvSSBMFqBAQub4dAIkXMQHg8rkm1jguC/05g3QoYgm/TQFUgCDGMagpTJ4t1pd+o6MV1PmMQ/j03V2bRa0UItb2sK1os4ifWYRVlXGEr2qnSh6ueIFVWOI/82QsAcnIPnmMaS7FVyBz7W/O5EvhLHTsaB1mMoqjCvCOxi3DsaO4i0ves973veFbRWq8ITa2LZXcgGUEOY6F7o644Y2IHKwpUFNvGxAgxk4soEOvdebbgCwPPBps9J5k3dU+ZAbwOEGJ/BXZylYMFRipE+Mu0EQNtGoZjTjGbV8EE2JYVPXTq+JtmhiEmUK41wgMbY1PiITyzpF4uJsalQUHxmxGysPdQUryNgmMqZhDWlMBSwU0gX6ttYjWPgoSD86b1zoMs++3IUve/nyllmhCi+zIhU9agtbYlFjmX6CD3jggg1sAINCcOITduanIRJBmT3f9w9/4AMfBHgHN/8Qmg1tYIMXtrCFK3DBCUYwwqMhbYQf2GAGli4wDgAHONrE4F4u4FzDGiaJGxDkBC3A5GIfZslREiwhnWtBmsIDnU8uLsRcKG2Jn0FDayYjGCtmMfWMJmOZxljGL05mjm/sROVNjWrOfubxjharXCVNV+CLyjKyASDpokpDYjFLbql8ZbjMtS59QXe60w0XtuiiQyj5SU2qkY1qIKN1xCAFCixgAQdI4AIeAMQn7vwJyLitz5YBBKADPeg2aKYND2fDFrwwGklPmtJylnOmNb3pTZeJBKD+qCQ2cQIWYGSSJ3AwQaBAckH5iyCWhMMpKLKKikChITZAQyKAUWJiEAP/ew86LfZYbFNgXLfYxmYijXMcPFwkkZk6VR7Ooj1NcvLqF669etaTVuSsDOMXxijGM8ChDXBEw4ta0dXNqvbLGqXZykGCu7rzAvcq6+JDzIgJNayhjW14w+/gEEc64gGPwZODG9EIezNY8QINcOACEaDABUpgCIFrwhP803Mi+nwZPuzB84N2+MMRLfEtVdzilc44DXKAg41znOMQZUHBfACKVSCBIINogeL4tdgg9EbBX8jDQjCJBOAT3zrUkdNnrcCHVjRjGD7/NU2NwdqhB3vYSE/6smVEPKA9u8dj/J30qj69rxzNe9aL0KyigowOGWMZyni/Ln4hjWhMA8lh/9z6966SoQqlSixo8T9326YQIYm8swZs0AZuAIdwYMAGbEByOAdykEByQIdz8Ad/qAd3GAdpGIlmoAUc6IAUeDwKIMHJ2wRPwLMn0bMo4TzP2wPQuwPRi7hFKz2LmzTUszTVWz0acD3XU4EbqBjfUISAwaCMcAE/aQFJkAVQygOCQYLG4gKJQJg/yZzuWKnPYYEW4AJQ4II6IIVc8AWhq6pcYq2b6h3XIjYmOrpigzEjUqJ0SiemA5pWGRrwey1eAZ8J+YVZ8R7v6QpdQj8d+oVngIZUsIRnoQVcSIWO6QquaESumK5IlC6USI94w4Zt6IZwEAdySIdO9MR0gAd42P8HUYyHd0CHU0TFVDyHcyiHc0AHd3CHdrCHe6CHc/CGa6CGaYCGRsCBFHgDEViACBBGD1CET9iEY4QERwCkfkqEQmjGQki4znvBunm40EO0RGMXG6Q0HCww1WM914OBcBRHFqiYUXIBQ1AEEwixUXoTQ0gGYAgCf8kD23uDzJGEg/msFVgB7oCCTfAkSTgByiIYOJCBQ6AFYuAYYzgt6CtD61Oi63rIoyMepjOiHUMjn1miJwKr8KO2tPMQPtxD9SuGYXBERxQGZ1AGXzAGaGgGYsCFWsCFAZxElCjAvKOGS/SGcJDATgzFUIyHffjJfRDKoRxKftgHfkDKpOSHCzz/SqUUygo8B3MYh2+gSqnshm7IRWkQBlb4A9yggAiAAAggQRWoHIHbhGRcxmd8xoRTOAGqxhiUwYkbjRuEtB/gRsFZvdYDnHDcSxhoCBK4AU4KLQwCpUySBWg4hd7rjenInCDYQlngE3r0oE9yk1NTuciSATlQhWToOc70OTKkvjOMyCYKGl8yTaDRmRXJqWbildfSlXFaLT7cOq5QP5HcChEJiWKwN2VABl0YiZrAhqv0hnGgQMKLh+NEzuMkyuU0SqV0zqVEyuUEyneQwHEYB2+4ym7Yhu3czkvsu2u4BmuIBmTABVTQhEaoAwsgQQxYABKcgU0wxk+4PGVkxkKw/09ovAxAwANBo8ZqvEY2iDjRuIJHIwKMM9DUayjA0cuNO4HJ6RcfIAjbE0h+AQUP6iwoUISKiqzLkYVTKA7bIwRg2AQo6McvYIFCKRgkaIEbsIE0GAXTYpRbAs0yXEOJDJ7SRE0aaSqlKs0YiR7VjLY8zJWrOD+QjApJTAn40DsAScBqoD+XuAZNDEWhfM7mPMorVUp/gE6jlM7jdIcKNAepHIdMZEC/w87s7AYz9QZuYNM25YYEBJBoMAZXsIRIOIQ6AAQTEMYFSIAIsACK+gRNuLPHACTNu0/8vAzAcksZ3IIZZAMuGFAjKNADxbgZqAGGMrAYYL1N/cbJOQHApP+gjAiCFS2YN1hRRRiEE/gCQSDRUmsBQwAFdCSYCpOEgRgEVAqpJRilLxiUz/JCRrGh1FIGGxpWFSMGFTurG5ER3MottGi7YHpWo5IRaAWuAEyVqygG8JlEk1DSa7hEbvCGTUSHdyBXchXKngzFd0DOprzAdo1OofzJeB3FehDKesjAVTQHchCHfRUHBwwHNT1Tv+OG7dSGBHzTgt22gtWGbLiGbFhYAJGGZeCFWEAFO1VGQvgBEhTGCLgAGYBPTeAET9AfZTTUQ41GRd0M0YNLiJO4iYtUIpjUA4WNR+LUmt00CnJVOamsFXUIFb0BOFETx7kBEsjChgGFTVhVi8D/oJ8dhHmEghtgATZpmDeog1NQMQiZPlp6kFwCNqM5JqVKM7Rgi1pgNx8x27F11mK5Bf/DVuniVgO8BkzMyU3kRHTgSVAkvKX0B33Y273FB3yw13qgh7/928Cdh8NlB3ZYRXEYBwbs1wY0Uwc800wUWDatXDfF3Mx9UzYt2IN9WABx0mXoBVhgBVTAhEeIL0jgghGMvAnYAUH9BFEQ2b0qWfuMxjfTr5W1xhkkvZeF2ZjFuIbKgeHNy0292VIqtQv7ghMQlCAguVGF2if8KEuapBDrjTxZUeNYgjeoqKZ1VUH4AogAPrbJBWK4otXhHfOtvmDoqYrELTXTrberMrhr/zd3ywoCbAlL7Du6pcBPhAd3INef/Ft+GGDCPcoMdId5aIcFZodymEqqhGAz/QY0peBuGNjJreCrHNjtNNMN3gZwbVOCNdiD3bZs4FzO/dwSPpBoWIZiuAVXSAVUEAVMUIVTOIU8MAETEAEO4IAF8EJPAOL4igSSfUbb/YNz4QyVhUsAXbRG9YInUIIolmIlAIIqtmIauNQa0AHiNV6O642nnZzNuoEGQ4IT0KQgYIFBEQRJYJzv6KxSixNDGQRJgBwkaMIM+oIgWAIW4Jd+6aw3gARTWAVgIGRhG7brwzHmSZFeMFtnjYW1dTfdBBm8+4lr4DtwXUBNpFtPTMVThP9FWAzgL13Fc1jgcXDgB/4GVO4GCM7gNHXlVtbObbhk7uxObGBTgsUGb8WGXeblXU5hhi1hAeEPUMEJUSkPB8GVKEuzudIYWdiEEXA8ByABQ9iAOhC4T+gET6iESSBik/2DRM3d0Fti3k00KIZiKo5iK77iLNaBLR7eb1RQHHAYSwpfnTWIzpKEPu6TgHnQfoGYiQmYTYCchOiTkErRysKoL9DZIPiEyNAEGCNkQqaxXCDkGtMpItWKt61kbJjbnfREdPVJVHyHTjxFCdxXCQxT66RKCqbl7NzOq2zpDFbT7MTOmcbECqZlEVbYh31YSxZmApmGA2GKkuCqY/geZXb/u7jIi3P7i1pwq7iii1V4hVOwgQsYwRPIAxXAg2sWuG0m2UOFxm/Wz3CGy9DjXS9QtCdQa3SmYnUGgizWYnd+Z07NgYCB0J6F0Ew6jgrLAx84Dj/+jjFeQuJzQuf4giVIEzjIg8iprMryvYKpk8+aATUwhEUBhiSShdRZhVVoBVowLa2qBm7gRMGT19IGytOWzqc8B5VeaZeG6W3Y5Zd26c51U9puUwyWaQu2YIDFXDON5TZF2PDkD5+gv5QAkeqqCregO1hQt1Jw7lJAhb6gCzKjblVwq/ipp1lohVMohBTgAAwwAQygAAkwgc+5ZlKgBG6uz/tMuLHGgz8APdEb/z2Ja+ItgGIgSGe3hmu5lmvWG97LcpwlEJShxbCJuRPiezBBKCVWQkeLEClUxaQ5hoLGuixDsLnICjGRWpifNQI3aAT4bARFwA48uC89wARbgL+WwAZyAOnBc/FQnEB00FdNLtOcnFy/Y0DhBNgd97s0Bdg0DeEQZumc/mDLtWCFLeFhzkpRMYnjvopUuQX5XW7SXep0QwXnRoUrf27ozvIsJzNUCBtpYYVQ8IAyH4HjiIAFAG865upKUJuvNln3hm+Gk+9FQ+tFW2spdmsgEAIhuFTizYF2BnTW+xxM6g1xYQF1bI4/kb0R8o4+8RND0A6eZYHeO4WYWwVBqNCPev8YgTjwGzCBH4isgjGEIIADPDCEynoON0iDQxCFZqi/JeMGcehx7YRp77xEl/5ggVVTfy1TX3/cTIZcgC3TzF3TEOZObchlaxCKJ21yqJgQDoHyWogyrTlbupujv9gLvejybufybgf3eqIrfMKB3biAECABDOhhHqZjULjm9KZdaGRvhcNdQxI9/kI0tFY0+57itlbnIvDzGiDeLRb0uV703+hZEpgk4ussh3kIfoaC7NDVhmiBeHTMVaAIikCIgxmE7/gkiSoOEt144puIQZiYhGgwQkiEUlAGBam/n2B28ARPXuY7voNtWd5phT1Y7rxlzXXTY7fcNb1cEh7unkj/kAVp8pJA+lqZLqgoSamI9qhJHilbi1gIjHTbcucWBa137tsqptuyBa89jE+wgAkYARHAAPHGgBAY7w0oS7Pc5kd4hEUohD8oBESoe7a8A/i2kr4ntAEiNM9QNN7l9ykegiF46xro80uVa0AHdH4stbw+wui40OOwOTdujtPhkxX9DjvehDdQpYoS8XusLPD1DX8BGE/6pOZICOqoju0ghEJAhWGYHZeZiZ7gD5mX+WB2WJ5OWJ/HXIQVEPwg7qYoCePuquSPrgaBnVHJzfV7ENqszavjSBS5mrKo+miZC23PC3D3flTQbvDakWQCBk2wAAmQAA6ggLUX7xDAAAnw/4BKkE+B0+ZJkPtFQITLyP8/m/M/EKhzAQg7At0QdMPlypaECZ88UdJQiZIhQ4AAEWKxho6MGjfmyDEICcgbN4IEGbRqkKJBX77AQbLEJRxFeU5JIgRK5Y0WLkiuAiZpkCxDJ75AQcLCB9EvSHxA8eFjCRxJP0HdlCpI0KA8gwgZUuVL2bKwz6KRlWY2mtm009ZSq+a2mrVscufOtWa32rSz0ZzxDbsMGWBkxwITLmy48F9kfpfxfRYWsLFixYxRNjZsmDBhwXxx5szrMy9conHdomWaVi3Ts1a/at3alStWsmfLVjXbdqtWrGe9atXalq1cmlJYkEDhOAUOEZJj4P+gYtOn6NErTXpkHREiQNn/cL9z50+ePHjGk8djpyCX9AoVMmwPUSKQIkUs7tC44359jVCKKkWilOUXksABxyBwrOQCgXAQcsoXNwClyAk+iDSIJKBIgoQhQdzg0hdOISWJICvtF5WAipg4iCGKCJISSimqYsswYTXzTGNjlbVWWtKQFc0zPfLlzGPGHEOZZMUI88svmRUzDJGSUYaMMVAGFuWTUz6pjDKGgeWXM2U549gyyjhp2WWYdcZLLmiKZgsutJRWy2qqrcaba6/MWadrubViGyuxyZbbLLTMktsqq+QiiycoTCDBcslRcAIGGFBggg1OQCfdJ9RBYt0i2GX/Bwggf3j3R3mlmoceF2ystypDEVEkn3z4ybpDFFFkxJR/LEGxhA8uLbFEUXCsOCAUN7AEBwuSbOIDCy64UBQJGyKRkg9wMPUSHEv89NISX1A44CDhEjgIViilpMgqtgSDpTLNtMuuMk0i2csu9ZJ2C7636GJvvbvwUm8vvByJZDAFM1kZwlEeBphfDMMLFpDLMMNXWYM9BuVklmXmmS//jpZvLSGLDCeer8Fmsit1tgJbyibr2Qorva2yJymtUOLBBCM4GsEFFDiFgQMtsMBFdKOIMt0kmz7SqaegdkeqeKaeil4bbKjK3hatwlcDE0zIF8WsstaqyIVw5IHESB1W/wuFUtlCAceuvfbawgkunHADCRKSFIRSZ/t3gws3EOgSSB16Cy6KZIdriCEUprRJLsGJ5ksuad4ycsixaL4555qLjO9oo+2CS2ecGVwm6sMsvDq8i0n8IzNkRXyMZL8YKUzHn/n77+j33nv55rVwDgtsmsNyPCyaszybK8gfH7Jpr9giiiOJpFGFDTZoMMECDkQQQXMXYBACHCRIYMIFVxQtXSXUWfeIp5+G+h0g4ZVnx3gCnecGG1Wv116rIiKRrnWtVmAzIH5qtYlNIMFALdiQSlqirZcMole5wpAkTtACH9TtWYVjm1M22AKXtAAqSHABUrI1oAAJKFwnUoQh8v/QOAqdQhaRq0XoLpe5zsUieTz0XC3wFUTShA4X/eoXL3qRpCQJo0hFqowTnUiYY1BRMFVUzDGkkQ1p0K4YSPpiwEADGnv9bmSdc97xgoevfTXxGBJDyzTgIhducCMbeElGHBrwgAQsIAEOkIADvBeBBUSgBSYIAQWWgsgJEO0To/iEKETRvqRdp2lO4w6oooYH73DSO26omv/YA8AAKoEKpqSCFKRQq1Sq0oBReMMbNjSSG2ilJUCRRLX6AxIkSAIYoHCK2pCCtqWw4CjWOuEJDQGKlbTEPwMi2xdMBMOfrChFZJMKKWaRr1jcAhci+6EPOzcykAlRiEHspuiO2Av/JTIxM5lBkhObGMUiVbEYtBtMMabBjWoA5hjrZOcv6NUvXRCUoN/03OX0pUSLdUkacZwjOCIajnCIQxwTBcdF6ygXtwyjFIdAQQMc0EdCinQBJl0ACUTAAQyQoAUckMAF8EAKR0bSE+2rhNKYtp1QYRIQm+wkUD/ZP6ut6n8PSYgpw9DKMCiVlakMAgw1NK2bYAgUsnjbR5biIShsQpdfWAIKieKUZw0CFNlqIAtZwsBoGkISM3zhuX4iTQvpIRS3WKfFfkHFvfK1F3w9Rg/TCETMhSxf+doXwP7ZTmEMY57xvJ2SioQMexZjncKYhlycgYx5BfSfiq0iM2Jnlrhk/4MbGBUHOVKrWnJYlBzhiCgd6aiN2WbjGtfAhja8QUc7TsMZwqCFKjShhuKYlAIkCEFxKQC+RykHkRS4ACGkczROTPJ98dvOqMBDHqAGtQ1Vu1rWWNUQr8GKCbWiFStXmZUvPBAJKBoE2/ozoKUgqENgvZALFEGgXanEghTKan9+hdWUSEIRoFCEe01EIBMpK0VSgYMhGhEIWCAjtGQJLYYxbMXQVjGgurgFEGMxRNHkSzRHTOw6v4gkdxbpSOxMce1SbLsYu1ExmkWGMzDsDLNQIy7aoCNFUbta1loUHNzQBm6RbNslY2PJs30ylLnhDW8YuY69/QVsTOGJRGjge/8JWM5yQrDSCHCAAyEYn6QuUAJFzNQTn/AEdTXFqeuKyjv1ixp3PflJ7xJ1IeBdyBNMSUAmtNKpUUjlVxsYBDiIpD836NZTSHCUEfZKEV3Vb0zC9SuXkK2r/wnwSyQhi3AtbnHbIhAokgEKYJyCK59QhSV0cQwLRyPDGhYMYJiR68Eco7Pz6kVBCSrQ3fEOxZxVMRN/7Vnb7bXCojXLNJ6hi1ToohbHQwZGg2zRcHijG0dGsjZsa5ceU6Pc1ii3bcuN7iWz2y7ayIZd4mKXjUpjGcKIRSpQ0YlJNGIGDuDj9yLwlIBTIFJoNk4JINFm6WyCOpRcmk55+gen5ZmT3r3/eJ+z9udVkYGpTXUqK8MgCaiewiX7AZYLWAASC2p1P97y1lV/xRIfuOBXP2lJfz4yoCVgGoZwsGrjCCGVAqGrULI4xSlWsYlGREIXfsUwFb1Y2WU7PaCd3cW+AuZZJW5dsUtMUhSZ3WxnTwwt5r6GNrbhjYlWVKLaQMY6BUNQZ9SW3Xa/Rrzzfm51873vfcd7vN8N77fkJRrLGMYuZsEKVOxJ6TIQ6fdMOj7lNqrMj8JABEYgiTZHUpJy5tQiIt7TOlf8Dt41PZ83DuhAb4EMrmdqxz/u8Q5RBQlQqKDtv0AIpRRll0tAydtuQAgGuqRAyPqQUp7SEriJqILxlQQ0/4DhQgabyJp4WEUyZAEJQEzY6ewkqL4K681z7mtfvktTLkonxl3ImNm4prU0enxbtVN0yKlNx2otOuVue2Mb2+DGuXUJWshFXDRZuvkdAiYgW1ADjuSFjuxFWMSLZfiCN22On6gCBqaLKrgB9ywAAphUwEkK+JQZ5rnU+WwCKczU0djU5y0NxDXNxM1P6QEVxqneQlDBepiSQpySQvCKt+ySgfxe8vlHrxCFgSnCKRTIEgSBf7AIWAXISniLIKzQ7cUXL3GFLPwEIbDIiWSFDEGCLIDCG+TBHqTCOumCkYTfh5FGagyRYRWWLpDGLjCRZNgYHPmYaYGDkK1WOsCDH//CQzqgQ2pV1LZN1P51WzckoiJ2w5T9WB1p1Gwdmd3tXQIyoF78CJAIxtQZlPAgT2z4Sb6hQm2oAiqUIioMCgcyCgV4IAIQ3PeMz/cUnHKxwCekoCO9GSa04CKAniVR3AxaXA1ajTCuyhmcAVJRQTEaY0IUoxLqXHyFi7Q0k1M8E1UYAiHkwRswIYCo0CD8yu+tULe0hLHUhIXAEkqQmuKUS7gQArnAQSGEQkFREbCB34eVGNb1wvuhhTTEBR2d1v3hHzmkA0BW1ERx2/4FGUUZZEEm5EIu5P51g0H+nyQ+Wf9hAze027lNgyVemK7Rjot9mPAElmBxDsuUpGyYIgb/YmApYmArJIIHEJcInlQEHNcrxmLAsQAo2CIpHE0uPpwL8mIvdscvol7qCeOfJWMxLmMyKiVL+MfK/V4e3J6EqAS2qBAorIKBnc0bmAhRJFjugUR8/R6uLIGFZCGpuRU7SgJNXIWKsONVxESs4RXcARsspEIq1ALWzRgyTENEBSRAAiSRFeQ4jEMibkMiImJhHia3Sdkhrl1Dcttrsd22eYM4dFs40JH/NZkBXkO5XWJH0k5nFdQ57VDwWODmuAbL9JCfsEJKmmIplKIpFIIHbIAEMAoI3ib4YN73hEAEIJIE/EBOkoInjIIneEJPKs1PzlkvyuAvXhwoZdwWGGMxCqqBMBbjMC5jQAAAIfkEAGQAAAAsAAAAAEABAAGH6b6f3rGR2auK06qN1aeH0qWJ0KSIy6SJ0KB9y5+DyZ+CyZuBxp6BxZt+wZyAx5d0wpd6wJZ5vpZ8vpV3vpJyu5V5u5F1u49vt5N5tpF1uJBytI90t45yuI1rso1yu4pkt4tptopptYprs4txs4pqs4dlsopvsYlpsYZmsYRir4pwr4hproZrr4VkroRlroNkroJfq4htq4Rnq4JoqoJiqoFmqoBfqIRqp4JnpINqp4Flo4FnpoBjooBlrX1WqX5hqH5mqH9hqHtYp35mp35hp3pXpn5ipnxlpnxjpnlWpH1kpXtlpXtjpHtlpH5gpXxgpXthpHpkpHpipHpgpHhUon5kon1io3tjo3ljonljo3xfo3peo3lho3lgonlconhionhgonhfo3Zgo3ZUoH1koHxhoHtioHxfn3phoHhhoHlboXdhoXdfoHdgn3Zfn3Zcn3VcoHVTnXpfnHhenHddm3hem3Zcl3hgm3VcnHNamXRbm3RXmHRbmHRXlHRboHFLnHBRmnFVl3JYl3BXl3BTk3FalHBWk29Xk29TmGxMlGxTkWxTkGxQlmhGkmhMj2hNi2xWjGlQjGhPjGdNiGZOimRMimRHhWRLh2FJhGBIiWBBhGBFg19Ig15DgV5FfV5KhVo9gVtCgFtDf1tCflhBfFpDfFk+fFc/eVdAdFhFfFQ4eFQ7clM/dFI5dU81bk45cUgsaE47Z0k2aEcxYUc0Y0QxZEMrXkMwWUIxYD4nWz4pWj0pVz0qVzsnVDsqUDssWzghVDgmUzglVjYgVzEXTzcoUDYhTzMgTy8aSjUnSDEhSi8dQy8gRiwaRSkVPyoaOykcQyIOOyMRNiMUNRwLLR0QKRoNKRcJIhYLJRMGHhIHJA0CHQ0DGREGGQ0DGAkBEAwDDwoCCgoBDgkCCQkACAkBDggBCAgABwgAEAYACwYBCAcACAQABgYABQQAAwUADwEACgEABwIABwAABAMABQEABAAAAwAAAQIAAgEAAAECAAEAAgABAQACAQAAAAAACP8A1cRRo2YLEQgKXHixIURIHCpxIsaxYSNRojhEAqkJomnPnkBxhMAYOdJGihIoS4w8maKFSxoUSchQRcxZs2fftlE7JixYsF3IFjlJUkQIRYdxxhRZmmQMlaIUj9KYCpNh1BZVjUbdepQijBZfYVBMQbZsiRQwTpYIQTZlCRAgULIlKySJmlWzcg1z5kwYL1+9evHaRbgXYV2oLmHaFCrUJkyWKFGSFIkRI0SG+tiR88aLEx0yVozQMIKDhQoSHDBQwCBBAQICAsgOIKD2gNsDFBzQneDAgAQLGrBYRQ0evHjp4s1bPi9ePG/QvX2L3q069OrVtWnH3g0bdm/gwIX/04YLkp87dXRkiKEiQwYVOexEIkWqFrVv6fJz45Yt27Zs12RD0BNEeKGGCAWIsAUVDArBICAhUaGVDV4AksgejjDiURE2kERWWiih5aFaLUR1wgmPAINMM9LoRM0ywghjTC/IbMJDVDBM1WBDDS3FlVU2UHUUVlXZEEciVETVUIcQAQJIESOWJWWIbbmFElwhpgQDRISYAsswezljDC9klklmYLv0MsslmWwySiidbLLJJZRMYskklmEmiB575OEZD6GNYMJop0nQAAMNKGBAAQPUNhttuA3AwKS6GWCpAQ00gAEkwWRjXH7KNfdcdKRyh5023WyXnardhJNOOOFI/8fMJ3fIUcYZZ9xwgwobqHCDGZVggsorynwDT079BZisGmMQNJAXir7gxUQ2FAFII4nAYJQQRcRR1JGIWEJQhyKqVRZJPhThw0khnPUVCR3wkAsyyzSzDC/2GmOMMEDNUkUQHX7VAlQM8dghVlsVWW0cgOxIUbcTejXSGCG1cBYKap1l1rnsynVlXOWmIMQfgDhiil7IOCPNMYG17HIwuuySSymZjGIKfXA+Zsljk+B5GSKIELIHHWc4gYMMLJxA6AQQNNB0awbAVtvUAgxQQAM1eKEIKHswwOhtCTgggQqXGHMNN9+kfVw82mCDDarXcafd3HOnWnc33rgKazjgfP9TTSyFoDcJImVUccMGG3hQBiOZoMJKLdJ8k43bAV5juUQgPRFHBwNcUKANSdjgFIRUJJEkhxSp8YYle7yQllkhxB7iSuSihDEMKITQgQmuIJPyMp/QEswxyxyT5jB2EGFUSyV6tZXAVU3l0vQwGUUDwj++jpYNT8FwVu0am0tSh2uJr9YHJ2EpliOq5ELMMdE4w7LLLQvTsi6zcCLKKafQ9+ZjcoJMJXxmGUJopmg6AI1oNGCBCEAgAhE4VAKiRrXaFEADXniEl2ChhtsYADcHEBsGYnAH+2xjP2nzBt1QtaoV7meFqIKb3vjGt29woxiUuAOdJtGHKvRABSqIwQ3/7FCJU6AiFr6ARjXclqxrJIViSQHEGBKQgCKM4YoWkggRQsKQMYgkSEdCQQsyFgK4dKBdYklBu0T0upFQoAMcmAQxkBGNlRXvGHgUhi6cMQkicAgFYhyR9loSlalIbCUjGWNaUFCCEiWSLBhjHiNjF0mNpQQtVLrklD7AybXEZX2mAAYxbFGLXhjDJ/TrRYz21QtdsIITqFhF/0zRmE7YMoADjMQkHnEZzcjhDFtwAg1WYAIGTuCYTVPABAnATAs24AR5eAQoHKGBRg0gACAEzgIkMAAHkEEW1PDP5NxGNxXCUBvcOKd2pLO3cKjDHOFI2zemIQs2TeISkZBDDmKQ/wEPxKAHiODEJ1LxCV+Esz/9KUISGGYhJ4lAABdIQl0kugVACOSKFEkSQ1BwgkTYICWxC2m73CU+8q0RAhoQgRz20gyb4LF4yDiGLqKxCiIwpAUnAMHGWEIWsBiSXB5ySSBbsr3nnQSQJZhk7MZopaa2hacp+UAJPtABuHxSCI5wRS5sAYlbLGNfMQpG/fRlv2HIrBSx5J8pTAEKUKw1Z4+BzJ162Qc67EENRAiUBiZgAQswLVETLMBrrJaABljACyZQwG1iI5tIGWCCs3HAHWQhjbO17W3pVCc66fa27XgjHeGBFTvUEQ914Ccd3JAGKy6Bz0XcIQdAxMAGbmAFSf9wQjKsUIY4t4HFiyRFCC1QgAKEEAQ1BCIQQXCEIwBhJLEULHcdiEMS1iLSkbpFSmWRXQtQygEZzIIvzrjjMYaBx70AYyM2QAG8zKLJD30oYGIBEVrmG74gBcliIUABSSiZVJCGT2MjUslKPrQWT37PErAARi448Ype8CRG9muZvgQj1l68IparkGX/QqFWUsBVTnfipQENqAZhroADGkCxX5OpAAIItgCLgvGiGsXYR8nGUQAAQGMdUIhbHDRAmg0yqsQjHlgtxzmlBRU3ePEJOpknBolDHBB7IAhKXIITJsxGIijmWym+4AIC6IAXKuSkRGgiIokwXelScIEQtDn/ESK1KgjSMmDvaa8FYkwBBDogE1OkTH7lxeMxjOE7QcjABSGA11kuGT5BfghE7kojG+87xqOqsV1gAct1EeneLD2aJFlylw0QDAxnRIMa8utJhQXDCxn1osK2kEWGM8y//vFvFW+Nk4fjNFdEMEJoJZbBCUxgAtOsWIITfGyMFQVjGgcgxzZ+NrSxeQAMFEIX1FBWNoR8zlaBVm9HRnI82OEceEgjFZBINxnYEwMMOAADHmDBFhSBCU6wwmzekqhDSrbQB9qgEYTwgiUAYQkvaAJCF0lBVTvAcEBMF6TnGpFJUDI9rJCgBS5wQiVMDWhBezwam5jBCkJAgQmQxNHO/4Xv9sxFFpOgpUc2KJF0OyQECNEZ0v/19FsKHGk1aunkSWgfHU8tja+CVV/FKEYzmvFgXUCiEJngxClGQQparqIxm7DlYjDB6wEWkMRaAM1oTFOBpylTuIGNFI2nRpvaMFOwlzqA3A+wAAc4YAOUQMY28BMPeCRnbcbxBjdINZ3PpkMd+UH8aU9Lw3h6gxqxSLcfDPFaD2CAAQcwAQvU8IhOoPUVRnEKxcYAIUcElwRx8AINCGEJQjhiIiFJAQjOOPsLVOQsc5mdoylOPRBgxQmIGEY0oiFej8NvFjhggQguQAGunLwk8KVz7bC7Pa38dCQ1H4NKkuK9prYrdmSxrv9c2qVT8LMxDlqtyfCj0Yyjk1UYyyjevljhh0NwgtZUX4WHawlXOPG6Z4/wCIhQV2egAyxgAifAARlQARF0KIeiTAcQY19TQW7nYowSY5fyWBO0TTHwCc2wDX6XH8bRd/CQWXMjHaeVH/khHvKUNq/yTvGUE8ZwCX5QCIXgBzuwARggAYnDAkNACPXWCqbjJE7CUI0wBii1BUFQURehUUJQAhfAcLrDcCDgUSdAAh7DRoOUAmIkJBdnA2pgB7MwfPF3DDElaMsgP2QwAydwARfwfHA4YFJCLi3HEirRUzDxAoCEZyGwEg7xhNQFUuS3aG9hXWvkVGSBfrZQasMXXj7/8YjB4Au+IGitBAmHEAmX4Aq2MAurUAqrgApGtApUdwocNgpvonWWkIp4AmxGUwMHSHapAQEO8IDJFmO4MTUEoHa4AWMy9kEFwAASkAE5kArOcA0nhDanZTnKcoKE9yrR0YKHBysqtB/UIAtPBwl8IAeHgwO8EgM7QAeSgAlH0SMNMQZEIQLPVCB4BSWh42YL1wFuOHtJAAgkQAOMBGAnx0YI4wQU0UhgKAejwBfx5zse5wx0dAhsyHxxCIfUx3IsgSM24AI0QAQ0QHFWAmkZIxdxwRYpMXuxgyVvAY9VpVNnAQigkH4pYy+v1jJlwhMwwwpowAeIMAmnIEq58Aqs/8AKGdYKsoRrpMA/++cYcrIJltBLagBMoJGAhVIBZUeLVBRYE8hMuriLcPdBA2AACvBuKkAGlKAL0tAf1mA51VAN0zAN1RCW1oCWaekd1IGC0JEO5hAe0LEf3NAMn1AIQGMIddADfJk4OaAEilASKTeYDRAB9rUtQuBmFwAXbsh8ukMDjlAVYOFekzYSMOEEmOkEjUQDTqAGiPA7ZehxKxMNpRADJqCQ+XhyEvNpLUACJABIJ2ADDXUwFDkVgMSFk4kSHuIWZTSSl1RGceFJVBiFIDAXL2CSqgALuaAiyGAMw9AThlE/MKMLiyAHemAZmPBd0YAMtfAKrcAKreCdrf/Ak7e2VqZgS7TEM7+2B32gBkYgbISSAYVidgugTJYilVI5lbdRlSAUHBLAAQewAV2lMmQpDWVplmNpDQmaltbgNthBl9CBH96AN23jDcdyDbSQbkCTTzmABu3mK4OUSF0hAgnQATRgFNpSAhTQmB2woi3KcCRACIAAE5U2X+4FfRSRma/ZAsV1BrYQXqGJR8pQdNEwCzEwAsu3m5cUJWAhFng2PYx0FRQRBC8gkS+AZyXQAfUFItWFJSAzfv81e2ckF2qRBMplCaagVWDSC8OAJmliSuPVCmRwBn0gCD0zCsBADdRQdLPgna/wp7mQC62ACuRJiqSAa+lZCQLICO3/qQXDRAIcoGIM2IANUJ9UZCmv0Uy3uFi44WLYtIuPRW2bUgs3IQ3S8AzPYKoGOg3QAA1lOZZLhE4QOnjrNKHaUW7foAyfAAmRQAmRgAhkkAM74AEekJGNlAJcgSguAAMh8FEgwHwUEK3R2qJRKALJdT0nkGfac3M/YgN8hgI0cAY9IApAugxnqAxDahPIgAZI+oZyiF0FRlRN2jzT41wC4wL46gJ6KDtlNFIfWZzUJTtZ8pHfh3vUGoUMB480wDCOYAmY0AqiBAxgAgy9ILFgwjKRMKd5oAY9UwmtgAzU8B/IoCZ/+gq54AyCOp60tgquwJNrRZSpuJ5eEATC9ooZ/2BMENSAypRszNRMAiA1tjEAnjobVXMbzyaqhTALaWgTzoCqp8oMqOqqCNqgLLROKaQN0tENR2Ycf5Nui/CrWoADOnADmtRIKUcRF1Ci+RUCD9BmD/AA0vpGK5pfHQVcLtFz8dUh3QqjLqAFTiAIxBB/5iqkyrCn8BMJJsBw79pp5eOkFRckYuQSNnACCKOvHHUCIgCwItVUngQXHBmIVaU7sTOS0dqYbogCNvADe8BLlpAJrLUJnJAJUccJAuUJkVAFSlBie9CxWFaM26ATy6ALtBALtcAXszCeKtsKrrC8GXaeIOYIiHBXFIk0g6JifMU0yXSpgtVMQFtBAzBtj/+SYzo2AAfAABkQCbWwtHyBqjfxDFD7DAh6lnODNhHagswxD+kAD9ugq5bICIvQBzwQA5ZUVIhJEQoAATbQm1UVhdJqulRYEbEzEvd4O3C4JDGXrVOxBV5wss3gO/ZSL6YqDM7gCRgwAR1AIi6BrFw6X0FCFS6AFYCUIzbwAsxzpYz2pQP8ff/KFn04Rv3aryAgArpjuiwqAl6wB64XgJdhCILgv4uwqHtSBlagBkgMvZNQCZeACsBwauF0DStzC7fQC9LQC+ApS29iCvrnf52QikUpNAUoA0gzAvKJGg4AQZmys8rmsxRINVbzYi9mAHN3AMAhARJwA5wwDNlmjNr/5h+/e5aWkw0t6IIqGIL5axzHsg24sKuHMIBnAGnasi3mGBUUoACx44YMt6Jx66JUmAKN4D1oMcEVF3FegVMrIJFaYASrYJDx98EsAmizkAErmlRC1YUp/GkUkYeWm62wuYftAkizB5Jl9DFy1pvF+X3q9azwaEbw6IZxa8oosAeMoFyXEQhCIzRIfM4l5gRvgMSKYAiMECye8ArCJw2JvKfGcAssIwveKUuk4LKqoApYx2vrWTSfwQKlUSh+5UCVenY8KzVrx8dUWZUZ+JTvtgOpsAxdrIzKcg2vqizIKE8q+FnQWMm5epd+UAd2gEjjyCNCgEkI8AAkl8orCq3v/zh70sVI3SfM0xNxJCFGKCCRXsADn0kvu7x0p9oMwTAMNwDMGnObFIE9YhE6AFOlVioCIuCarnkCYPoCAbvDU7hwxSmmISUWoxuPUxiP0MqiLhAH5JwIhEDOA0HFd0UQnmEEW7DOhEAIg/DOmJAJnjALKZOqeqqnfcELtCALOcmTLTtrb9VWm1AJvUQHdvDGxXYaxjQBCp0pgHWfQtu9FdSzvPjHl1IAu/FuZMAKzTDYqm0NqPqqaRkgplIqE1q/aTMNrHAHZHAH46MkDvEwskcBCxCtcIvKM23K2nzCccBILdDMLiGYz/fUGPcCWlBiVpAL9kI8S8cip8oLzlAIN/9LwR1yPUDScuAaBC6AwS/AZ8qMVGt7RgIrfm/huSH1zM8anC46e1cikvA406ULA16gBUesBtNCxQROEH5bA0bgBXit11+LCZ7QOLlQL02bqtOwp88wI7egz68wC/rMk82rCul5J4ggCKwYKBxQGpftQAqNx7yoxxQI2n78Yh4EjBLgAWhACblAdAZ6qqgKv2fJoCxETndDKvkhOb8ACbrd3FuxJGKRsJVacqXbzSwqkhcgEiiRrdjzPCknBFRBAxoc1KgAaMqQ3ab6DL+wDKiQARygLQzjRQ/DRYZEAy5AacOMZ4A0SSjxAjQsO9j1w3FWnGqxzaHr3gxHxNwchSj/8BTc8xRJsAVjsAVPgJkllkBEQBBIjAiDsAjv7AmeMAqtsAvEsww9Dr/TgKrK0AsZXgscLgsebgr/TIqdgAmS8MQDSAdO4IonUr04i9lmN9qZ6tm28bNv58cG8LMzHowHMAKR8KM8/gyt2tpnmaBs2UIs9JauMh3cMA2pUHHOxS3I2gLM16IP8NIT0M2la7rEXQIfJcwKUzArrRVB8AQafJSMcK5kfqqnXgsqwAEvJ1F6qy0x1+X6+gIUAUhXaueCiLoiYayd29UfeRbFSZwIa+gUr6UigFMngK0ZX5tTIUwyoAOVTsWEwAjurEt+LQql8Aqgbgyi7uxSOw2mKia9/1ALGu7hy/vPpBDrdrKKeRB2cJw0xWZMffVXmz3aLh7sDi1Yfdx2fRyq5LsptHAMKqOqURu/1XA2cwmh0uENonIs6fANz0C5Z7stCrff0boACzDc527oqMxwMUc9XMHSFlwwQvAEXrAFWoAGtkA8Y95SZd4MujAMaMDv5/IjzHMiV3oCBM9RQhWIPAdIawQD1fx9G0mwngsCc4sCCbvN5s7NM90BKLB8IoACF6ABpb/5CCsDPNCZ7DnyhKAIj1AJO9MJosAJswAMLwW1rgoNUGuqTKcvGT4LLbu8rkBrnpB1RCmzmKlAJIDi1qvQq3Gp95mLugi01G+0j8JYOkZtZP+jCykTP82Arug66tBgqs/uvsygDMnAqsyQDMxg2Kngj12hty/aosJtAG/bwI3J39usO83TrQBhQ6AQIQINHtwSxMmNVsiOLWvmzFm0aM6a3UIWyQSKFDBSfOxoI4XAFiVRtKCB4gQKli1LhAhR4mXMFy9kfoQZ4mMJEDlBdOhwQejQDiQuiCgqQsQFCkObBm0qVAQJpUs1aOhwVWuHEzScaFHThxAhR4QUMapkCVOnTpxQzRr2sNkzaHWfPWN2dxm1bc5uzZrlKrCrVqtWnRplKtQmS48I7VGjRgsPGStOmBgxgoMGCxMiQGgQWkGCBAYKEECNesDqAQJcC2A9AMD/7AC1a88GEGDAAQcqDn1ixSrVcOLFjQ+PlTxZsl+4cH1KJatkCxsFYdjwyPMnUQMPnlIAGjToBaAxS5ygXpBKEoM0aLS4flBIkYIHg8iYZHEiRYnNmvUCZpYZOoCpBBhQMAgGBWmwIaXpWmCphRNIIKFAl2QqAYUXsrspBZ46YAkppIAiQQMOqBJhhRVeoEEEE1cgYQURLODgqalEcKEqETi4QKsTKSTCqzPU2IMQRBhR5JFJ1OokFCdNcSUXZJpZBi9mrrzSP2m22UYaXWx55RVbZoHFFcMOW8ySSRgZBDI1nJCBBRI2s0CDDCyo4LPQGmBgtNIIGCC11l4jFDXY/xzAIAY0DHnkjQpMM8CAAxJgwIHeLjnmmm2+SScdTuEBFdRvOO00HXjSiSceUKeJhZdkqGthvupsiMnD7X4KgYIGmBqKKKBA6EmmkgQqYj2CEoxPwYMadE8gGtTI5RhjkJGImGGAGSaXL+FoCQWYPqovhfdcOGEllUho4QUIUZBJQ3YzZBcFBbODCVigdKSKMw7q3HcCC/itQIIK/r2qMxovmEDEDjiYkQIKIPDXYBfcAyssQhZBUslK1nIylFNamQUYZCBSpmSTS56Gy2J0uUWWWcYkc5VWTiGFlDTXfKwPO5yoQYYTNtOMswk8g6BoPkeLNGlBCyXAtQSuqGQVWP+AiQYYFkwrIGnSeMPgjluuCTWeecZONZ5S1VHHHHPSmQfUbGLxpRhaUBpICAVBkCmEn/B+qQMEwCNKqPCArXU6Gooowlkarmu3hZAOSsFxk0jYJEzAbHHFlTBZeSWXSkhQyQVcR6rPWRtccEFC9CB8wdsQWHpJhJeCnemn8RyG+LMIIgitz0oPYE23AWzDrfgAaCOetuIBGOCEGmgAaw+xMF4kkiU5dvKUj22JaxlhjgEffGOEgagZWmS5pZZZauHellZQofkUxRhb0xBGHjuDMhgvC7qzoT8DTZ9IQxrTqOY1TRPAAk7QCcHkgiKXkMBqCjDBCRpgAAlwgAQ8UIj/W3BpVPBI1dhKlQ5whMNUosIFLYyhi1c0qD5JyNuHgMW3mFDgb+HB4a9ox5JyuYdBDXIc7DjSEY8o6CMweIGHTmAIT3gCFahYRSg64QlOXGIUuVCFDFAgghOoCybVuU5JTkCuE1SFKuRhisMo8Bk1Ci6ND0CAAIh3m+XV0Y51rM0ACjAAA5AGAgloACBB04ChjeAJRghC9PqACIwxQhIb20STbKa9VXQuLsEQhjCKYYzx+cIXt6AFKNNXi2HYQmSvOMwpDKOYTmBiTY+43x7OAKcVxAkzdPpXZ/R0NKRF6jQEOI1rCACBE+QhFLYghi3Q4ADg6ZGCWdOjARggAQzc/6AQr9gSNzqFtlGRsIQf/IYyVMgLWbAiJrYbT6/SSIEJqPGG4hncDINVrgllhQIaaKPDyFOv8JAnnQ6TQfUugQlMKEIRkqBEJBZxCks4gQZBoAHqbNAC84grou5BnQte0KAtroQEUGmKwwgEExGEoAMPg8DuUsrOCLRzaLnszMCuEjF9ieCeDgMBr4RCgaWggAObucoIWKAQLThBDXbogyEwNgnrQbJJp/CYKlshC1sEoxe9CEZWg+ELXuzifLfABSh7IYxa6CIauSgMKQqzClOMohOMUVMs36QDGlTmMkDljC4HGZoFELCAExSmIJGAiTYcII8SpGCkYrOABlDzAP8qSAU0ssEpb3SzVJ+CBi2OIYxysiIBCkCAAVJDAASUtrSoQcADHtAA70DFnzicYU4oRII9roYABmgAxMDzOnbh7VeuXe0IFrGIR07CoNWTxCVMSQrKpMQFtCpPCGgAlAuU8V5K0WkaBadP6r62AyWFZzqFQjAT/fREWcFnVARHoJHy6l/7ohGdWDCFLexBkUdiBFMn4dRQkMITpYAiK6ZqC13oYhe76AUveMEyWdSCFg/mxQqNUYtSYM4VpyDMKt0aSVfGcpZauI/P5mReoanUaAvwk2hHC8wCCGCPtjmsMysYm9UYYAGrOUAMWJGyUfXYstWghTKWcb5XlEJwqqX/gHeckuSQAgVwaOxnDnVIoax8V537nF0OhwKC1WoAEZF4ZCUQgV/iwsIZwGAEXZeS05xI96NcxKEGdqpGfYpgO70CD1ICp06RtlEoE4DAGv3VFB7tLiogQAEIHIYUo/hrphyAnhckQ6Q94HcSkpgEJiKZvf+iIjicc1ktbnGLAo/6fLWoBfqKwdVbFGIDflgFYTK3Vpp5ghRvtYRc1eAFiNrVBCQwAS6HNrRBKsBPpXkmAuUI40GxOGvMZg1tBsAAMsiCLz7uVDZ+UYxm6EIWurjEJQyUZO+U4KR8Bk9InwyedEq5AyCgUBn17M/18rOf+uRyS8NQvUhUYhCDUEQk/8C8CmQAQxRVMMEFQkAexyF6QjzlFVLkLF51dlfPeV6nuh3GRtwFeo0tBQ0EFJDb0IBG3XhD2ATIEwEOQKCvGghCECQt6SIttRL71bQkT9FpzoUpTKEW9YNjIQtZ0KIWvghGy+6wgRh4oA6jEMwrMsxWU7A1TY9ABCECEQcvONSulqEKLv8F6D0duzSRSs2ybXNAPa4GeTDGTQAKwBs30IIv28hGNrYxjWQ4wxhEzwUkILFO1v4tye0kN7m9c3g6N1696wWp43tF8Y/rcwJq2MRaRLHfSez3EqVARjRsYYYRkIDcIyGPnKPSFPOYNCrj0dsFaAevmJg0PLbvLntzCv8CGyhcBCzY0VOcfBSlfLcEO7KAi4QCgWWD6AlacJNYjrQknG/CE6IIxSgALGCfv0IW3rfFqEG5DPI/xBnDmAUaYqCCGNwgB4Z42WDKBAtYmAIUmmgMIwzRhz6oYZY6WAHMuCU6eSmi6R1jI6AJsi1AIRQBGC1niqakiZQDkBRJ+azGwgAyoIRUeIVYoIVeMIZmOIZdQIZa+IRX+J8JgKMGSC3EY6fGW6fJm7N72Zt3mzftUicQuMHcWzwn2IRNSAxFYANLsIRKqKJboIZhqIQTyBU4goEkeIEcESleqZc7u7LXCxbbc6OjwDN9orNciQAK+Bd2csF2Khg5u4B9CbT/ztCVABCABOiAHyACpCISsWAEJSFCtYgkUTAFUziFAGuF7nsFwCA6BxMfiDgGVqgDFfAAFVABHIiBGFgEkLEwMqk/U8C1R1iEsei//2OBFfjEW8oroQG0AGIABkhAClIN1nDA1KAgGZPAWOwjSskgDNgBSkCFQcyFuBgGZNAF4QgEfGonOFIyHIQ8EPgAe/kt2yGBlTAJdiEBdIK8d2s9KZuzCTgBSwBCUxgLH9yESzjBinCFG3ij6jKRq0C0oDAQo1gnF+QV7tqO7hqKpZizNWInCNApC7iAomkplSpAzxi7CLCAlZoADYiASIEAGHgo6bGDIjmSRyDCtMg5USAF/+0BREEkuoyMBWHwhYfYhU/IAQ/YAKZrvxuIgR6ohDIhE1coE6vrBPxzBEZgBEToA8hwAh2QgZxkAVHMAGEDoABKMQn8pRVjMcR6Jl/KGgk8gAOoFAnYABW4ATKQAz9ABWxphVLwBFjYg5BavHezHXQCig8ogQ/4AL2RJ2ApgWZcHXZZibwxS5jwSvMgHJ8ACiTjAEsQBewzAkLIg02YhE3ghFRwBmoABjqwAD3ZkYGpE+oCjxMgEcc8Ke5iCnzCiqVoivR6wayAKf/5DA0YNqPJLRPjnaJJqbHLk5FzmDKCAAa4gEYggrCoSTvMrzzMOU8YBVLww4vsPqJLjgbbBf/vkYVP8IPhFIQ50AM7QAM94AM6uAFGkBr6y5xVkiIihEisewzJ4IGbjBP+4YBgKxhdMkAUGyC/wpoJQg0FlLFnSqxY3A0FyKAKyAD2az8/8IRLiIRLQAZXsIMaEYoHGA95HA9ldLeeKJcHUYlz+ahfmZDZojK1XNAK4RUOmIQ+NIU8qAFGkKJM8IRW6AVqQAZGKLQG2BEN8IA6uYoqK5GkkDisaEYSGAEP4AAP0Iw7OUeC4QChckQW0NEYYAEenYEfrYEhqAFEMgIosIId2IEeKIMz0IItcNIuYIM3UAMhiIM4KAEbcIKg0YQkiANCiE37mU2CyoRNGwXt+UOZ6Tn/74sF7yvEXQiQS1ABB6gAS5GAOrUUB/idA9CCUygTqWuFwpgfIsSESoAlL6WDIckfnAQ7ChlRofmXXTpF8Tw7SFFPxCLKoxRKPnLPCsAABuCaDbCDShiFvmgFFXg4drPB3xIKePutoqCncpkKBz0BGEGRe6GK8NARLnrVchGKnxqExIgiTdCEH9wEU/AEW7CFUkAEI3CBC0ABiNIBHqgBHYi5h9ICL5i514yMPeDWQKA0PegDQRCEQdA6gyJXRRiLrEtXQzCEQWhXcM0DOsiDMFCDLSgDMyCDHkhSHMhJWxoBE+hJNKKAZ8HJCbCERkiCQGCEcJ0+icSEMW2SMmUr/yj6U5+TheQIpQKbhUywAk9tpt1YypBdytooAB2Aklf4U0A11rf6wfyjyYa0g1mqKxUBO6Wgk7xSqT2R1FhUz9q61J59phpzzwMYDQnggU1whSnpBZC8gQzwzAWdVXpqgRVogYnxIRnwIYhyDyL4Ci241sigNG7dg0DQum4NhLMl27FIV0ZwhDgABCOJmj7cBCn6wbdCBVsouFkwBU1whECwBEfIurONA7HdNS/Ygq9wgsR1AmnFSRmIxBjAjMzIgBHYgJ6EL7HDkwrQXIGpUwnIIDu901PsEwVAMWMzttJ6ABgoAieoApxMBFBIBEBIhD0YhIbVNE3jhOuryFV4Iv/DqNgODKX0mYVXWATDSp7cUB7kLR4VaAXozLA+lCK6jSua9FLImAycjMKaNS8CLMVB2tmkUUWiXLH0LIDagI3YkDumtIAhUARXSKFbeAVTgKuXZAspYotOAIXozd/7bdk8dISYlMkAxi9FQISzuEMAVtex4NY8yAOwdQGI8gI76ISqI1ZNy4RR4IRcmIVKkAMZmJMIyKuBKcXPtdNpqhRLOcXQrZRTVADRNTYWdmHRZeHR8BORXUoaa0AYIwDV6oggyB9CoIFG0IRESASyvUNI2oQxpciK/MMn0k30ITJWgKDkjTsYO94AOABDcN7npdD5cSWsm8nrvF4ayN4J2RH/USTFXVqAviLPZFtFVjxf1ihfK76NPGLKDQiD5GCFUrgERNi1xdUBftXRQVYBE/AAkcwADAgYFZbhRr7TR+4TG/5YHCPaPZImB0AEghLUQQ23S1gEMsgAz53U2gqe4KFjOr6jVFblVWbl1EqyIggCHlCDQAiCElCFRnjbO0SLQe2ETMhdUShTVUKFUiiMXHyFWhjBVHsFTlCBkAXZE5ZTB0gpQJsA1ghZNAgFVaCZUDDWzHOrTBjUNVkERNi/mOUBnJzZCQkaXNpcCYBUpPEr8xytBiSU2MDUpFlKWqwADkiFS4CEQ+gDJwjAGD1kEyhkFXjRkcyAO8GAzmWA4RkA/zxt5BSGZBZOgJAl5dg4AAkYgWZq4T6Q37d62EwIN06IgYdejeNl5ZVm6Za2I9fQjZgOANR4gDQSgiAwAsjwghOgAlWwBLNQhIhcjF8ehTKFIidehZ67hV7IBfZBBRyYJgnIgA3gABbAgexUgzngP0EokkjogTsYzuHChFEwDO0x1lLIhLbyhB90pUmAJZqUpcUNErty0RvdjDvZXAM8ms9q46FUtga053uWlJAdOQm4AzkwAzk4Axr4qB7Ris2cgAqYAHcGDWn21N2wFD5xYQUQWVJG5SrOjTrWjRzTUFMYZidmhVWIgZQ+ntZW6bc75diW7dmO7eGxDY0W2fZkrf8H+AAYeAAbGAMi2AMn2AIbAIFEUIX/fQSIHNa3mqKirkjU7jlRqwVtKYUNqABA4oAZwARVyByW/O4/dZki44RPQIVP+AQA2xwAQ4X/YqtREAWRJsI1eVn/8wItcA9fMwFRzFzN1WsGWONjE8pgomfXWMD0hJQJnBQFwIBG9ICZCjnSJM0GcAAKhwBpLhoJiOwNF5iA0dwPd+c7vfBHthQI6FxLiQAMSOQ5ner2swJKMAVgkIiKkAhgqIQbUIGGRmEZJmxJ9nGm9B06pSYMUPGnjIEcyAEkJQMyuIM7KATBEzxKAMf0TgVP4xzAELVdOAasKrBcyIVEEIAHSAEh6ID/jRqD+zYqimoEn3aER9CEVlqMKQLm6N6+4Pg2WfByV7ACC1gA0yANR8gc6JSZViAMVgCO9EZv4OCc4FhTVniiUjgMU7AZkaafmaRJIpGMXrMMy+BvC7gTXdqlBghwAS8gQzGUOLYt8q2gwZ6UkuRRGeiZnMQBHaAr9+ABJTACJVACK4CCMgiDOXgDOXgDOngDNJgDxT6DKqgCJagCK2hdWg9kkzTJx41E9rP2x21E9tsBMiiEcEsF9q7yS5AEO+CDOqgDPzj3QjgE5KKE3AXWigWMy/FyYMAWbBmGuECGKSG/8pGIft8PipCGgBf4gSf4aZiGazB4aaiWOJCjByiB/6k9CvYIAjWgASKwiUa4P0vAv064tevTPtNehVJw9OBomUG0BUk4gAZ4ARAgAArQBPqbmlwABlcgwlBYhe/rwKJzDlz4hZ7/hVhgBVmAIlVaJVYiVjV5a/6DjEStjE/knxn9qU8nmlBHwKCUZ0GBYwckX60hDTQgAyU4Zxy4gRtAUiTFgVkP5LPHgbLfdjIwAzTwemOfgzmgAzvQA3FVqupxqk0A5j703cIg9O+GTpC5nDHBSMCg98Qfhl7A93zPd3+niMgneIGnhsmffGrA/MzXfM2vhs7vfGuoBmsQ/Wu4BtHXBm24BmqIBmLwAfOlAIVkAS/4CSy1AsqwgRJIgf81B4Xd31+PLwWQf6LgcLChmwVRwAA+Fy0HBAWYhwViIAZV+ADVagFQIIZrGJVtCJtUgYdqWNNX0J4/LfroxTWXzbql106dDMBbygyg8h/PoPrv9SWsX4163noJBLNKyARw1lD2FrDAj/eXAQhbAnPZymXQILCDCIExbOjw4cNcDwcSzKUr16xZtG7ZylgQWK9dvUYKE2bM2LFjy5qxdOZSGsyY0qZNo2bzJs5r1apZ63nt589sQoVqK1qUG1JvSr8x/ZYuXTx43L5FgyHgKoIULW5UcXTigQ0nOOTgECFESIlGqtaq6tTJk6dRpUqhqouK1atbsWLJeuVKSgEIY1L/ICgC6zCsXMSIUfnwAAGCBykaRfsG73K8efPAzYs3LdarVqZcuWq1apWp1KZGddqEqdKj2IwQ9VFzxgkPHTpksGBxwsQIFSpMeOCQwQJyCxMiRIDQ4HmDBQoSUDdgvQD2AgMGCCDgvbt379itW7eoUJeukep7ARu2fn1J9SV30a9vvz56XbvQ2x+Z/78utdwi4C0F7kILLbgUWKB+uvjCyy+4/MJLMRUqowwzzDyzITQ0TbMTT9YElc02JSLVlFPpXLYiZvDE8yKMMcbIIo3fEPMBAZAh8AEMLuBQhSWJUHCCE2eQcQYJJNiQhA2AqOLKk6GMMgopo5hi11168SVL/ylrpfCAJqBoklguiS0GjA8fQPZAI39QIMIiw2yDGTTM2DMPPM+8gsoqpLVi2mmmoLZaJ69ZMskjjBCyh21O4FaDDDKscAIJwg3HAQcaaKqBchNMAAGoz0lHHakGZKddeKkS0N0ApxYgC6yxyjorrbHuxdetueqqK6y0yIIgsMHiMuywvxh7bDHJJOOhh9BA8xM2Ry3F1FMryngtttnOSONl6TTFzTbZ6FTTM80cI0wvAfrVCAJXYeWDDy3oIIcjlvxAAg9FqqHDCBO48MQWcWhCGluqnbYKKrPoRQsvr2BgQAQPPIbABXGogphBjTwmAGQfwLsqASasss01d0wjT/876nyTzCd0kYKKKaV44lpqo8yMySQ5z7aoGlrky0Okk5IgAgnEebDBpppWUIEEETgAHQMMTEeeqdltF952WbfqagHAEvs12MUee6yyF2aYobNpO8vsTj4NpQ1S3HgjN4rUPnW3ipnNI09n1mr794ssestNUddYUw1NzjKjbIS0xJJKKp98AgnlhdxxBxk5aJ5DDCp44LkHHmAggQQVQNAuxwIEwPEHRchLiBqJAEKEEVqoYccZOGSQAQtexBGHJRfDAqUqB7vyii2vsLKlAgMQ8EASX1JgAwVjuAJLQj6gLsADf4Dyh8SRUaBGHnd8Yw8+7aSzjTKpsMIKXaWYskn/J6esZnMmlUyi/86ManEbDWjgAheg4AQnWEHRQpcpTVlgaUyDQHOcIzVSJYA82VEV1rhWgBBho4PR6gYIleKNb4AjHCY0oTlSGA5zqKOF6niRC2MoQxe+iB3xkEc8bIhDHc6jHj1khzvqUQ954DAz9jjiPAZ3GaaASyg02RAzlFGMCOHCV3thReQkRwnKcbEQfrgcGciwgx1oLgad28AGVLABDLCxjRvYXRsxUIE1rlECFrjAxiCjugBE5gNUQAEPauM7LzzhDGrYgyHmEAMTcIAFWghEvZ6EmOGRJiOx4AW6ZqGECRggK42gAJuEgICLAUMTauIYZOAFig+oSWIE/3CAMvZGD3aoiBvFWB4rUEGKUJyiE4EqhShcYwlLwGY2fbCDGhoVBBrIwAUtcMEKolm0EWBqgcjxlHKa8xypLWABpaJa1cKjwQK0cB3sOOc5XbiOdZ6zHe5sxzrbcY53uuOd7ainPeGZz3vS4x3u+CdAAUoPeuCjoPh4B0LxMVB3sOMe97CHOnAROUhI7hOU2CIXMwqJQnC0ox71qB9CKtI6kJSkcpgDGsxQhR3cwIyds9TRisMBNFaTAyQYwRs5cIHtoW5NCPDBH4SgBh54QQ1BANgh+7AIRNihDLqpgh0I8QhLgEKSH8nFMJDhDGksoxeRGEAEULDTB4ACFIkYg/8mDAILHzxAAB/4g8c04T22TgwBkYDHPGYpj3A8xRvJuOIqTkEKQSHMFKRozSaEOQlj7oFRPVvmC1wQQEkJzQSWxdSmkuMpbUJnVNWpIDjHWQB3IvQd70RoP93hT9Oi85zyaC061cGOda7DnusoB27paVrclsOevM2tO9GBDtuu47XqmAbmzHi55V7OD14U6XJFyofp8kG61J1uSKdrBzvM4aRykIORejDGG5CXvGa8gQxwoBv11kAHR63BD2zQVndh5QGO8QEV/kCFPjhKDU94QlH30AdEVEISkViEIfigB0NMIhKVyIQoTtGKWXykF8LQiy0kMYAArO55oAAGMRj/QoxcNMIx3IMXUFUhV4lJzAbbmIc//oFDGoaDGct7hWAJG9hdhsItrTnUzgjRhzz0jAjLXKYAo2lAAw6tmhrI1DUjGKroTIeC36TaqQy6jy1v2aBeVigRhViPI4q5zPL450DTrGY1v+OgpX0znOG85ntEJRY5IMMNVECGHvC5zz0oQxnCGEY0yAENhkbDoAtdh+4ietCCrkIVxEuGleKgpWastKWF49IYtJS8OICvDb60x6usLjKPYeUfEjFUJ/j3CVqIKiIWgYlLJPYSmMgEJiSxCErcmhOcEAVd8KI85JHCBBSADAEAcZiDAAMWrOSexFRJDGezmAK5gIc98vGP/87Itp73SMdfWXGaUfzpNPYLBbpDkVggM2I2eyAyIYngqGUGLZpCE4EIqElNBmYzgqKSjmerg+VTcbng+/gHwhOOcH8wvOEOfzjEI+5wg1O84v5wKMPv0ZlsFALPMfAAGXMwxpCPcXObG3kOynsDkY8RBy53OUszrYKXHi0DcZQj05Z2891lgJo7BQDQAcDh1U3MrX5UNattEIRA5KEPhmCEJC5BayuZAi4WvYSvOTGXu+AFL7KYxSACQIAL+GAMjUBMs2EB17Y+5g9tAgUxVDGxB5DgxfnYhz/uNA97+GPL3/4FaGBW7sCqxrDqfs1iE0WIQOzhDV4oqhqcgORI1f+byUkCDpSV02/ndLbKV64adipu8H8cnMt9Pz3eU4960ZNe4QuXOMRN7w9+9OPinfEF5vK8gZSr3LybNqNwQve54IduAzE1PvJtfnM5ks4BDpCA86PvfNJRf2kSyAAHEBB0oI8aAUSPTBIaATsnPF4TjyCEHiLxmltvQi5zKQUnKrp1VLhv2K2ABRSGHpkUYC/t1ObYqf2B9xADu6ASJMDDPewDPjyUZmTblvnDPHiDL7gPKvwJoBBeauzSJhzKJAAZIiwKkSWTF2gBEQQQMzWTvU0KkzFS5l3Tp4CKc3RTN3keaJmKAcQZDuagDu5gDv5DPiiUQtHDP+kgPuSDP+j/gw/iSSpAwiHoAR3IgSBcF3UJQhRKIR7owRXiwXbtAR5wYR68gRqAIRg+3hacgRacoRY4Sm5QngyoQG+wgHCYgKVs2g0YQQjgkY7koeq41WP4QCIw3uMRQVIJwiJEgiRUgiVAGFzMheSUQkV9AuREIiqcAig4AgqEQB79ACwQQ1mV2MSgGlA1QoldRY4IQzwkoJjtnT30kxG+UDXEwiewgmmoxiZwQiYYnmLlzCMowuJ9YTKZoeSdYL0JzTTt23FoFnNwnqjQoMCZinegA0IJFw8iVDuY1jReY5vlww+uVj3l4EEp4D8p1DxMwyVs1KJB4XXpgR5UIXWpIx5koR5s/5c82gEd0MEc3ON3qUEYqIEXnIE/AiNu7IYM7MYbssAKsIAJvOF5kZcMpABQ/UGaOMZjlBorSUYcOAIhUAEVBIEXvIHTLcIhRoJrbIInOGIspsIVYVEktgwqMIIFeEHwAIIohkAEUMBhqAJcrckDPKQApsljPIAaHENm3IMQaYYsuQPD5QM4qMMrpsIrrIJpWIkncIL9sIZi6c8uLt67OZYZluBkVR4J/MYI7FvSRBkMcl43WZkFEcA+nZZpVeNb5pNqtSVc2hMPFtSbwSUOtkNB9dYswUMsVI5JCUIeFKZhHqZhaqEeKNg8bpc93mN3fVehgdcZlIEVRFrLYZoOoP/XMLIAp6mceskADdiADcSBKEZkRdpXmqRAESQCIyRCHGxBR35k1OkPJtSiJ9yFLtyCLvACehSISpYCKdRAqyxAB1yAKgADIMRB9QCDKjjGqpyYY7TJWzVCmIyCLGxDZshDUdZDmt0DOxzUOKTDZ+gCMIQGasDFjvWYMA0TovBiIMRnHzBKVwYBkp1gNBmkZVETZmXWcjCHv1GZAngWedQWXR4ogh6oai0oN/pTEXLjPb1DP02oO9ADaQ2XDVnDRkGCH9QBePWBHjRdHoQoiY7oiCqmPJZUSUkmixbaGaBBoEGaeGXmy7lcpHgmC6CXeuHADvQADsiAGm4BIIRJm5z/pn1BpB8CwjAlwhfiwSAsAiPsjyQQ01S+An0sCG/yhy6kAp9AiSV4AQdQwAVooib8QAc0AjDkpLtEBlC1aVW1givURTPglRAREUENlD3cw0CVgzqkAzQogzTowp+ggsyY2yiwZ2Jt4HsqAi8KmWOlYRreJ+UZ5ArsJ39ak6dsFmd103NUmXXQFjzRFqiygz61w3CdajWmqjWqKquWFqu6UxDRw5mdGRDNqqzKgz3UA1yqw2XQgnMVAh4YmhnwAYgWq4D1AbIeEz3SgWPWo7PaI6G1qBqgQWVqQRU4QRlYqxMoAW4ogW7oRg3gwAzcwAx8mrnqQBV465/pwSAoQie4/4ItwML3oBqSakIjDJMlgOAgMEIk8FrO2CInDMMtGMNuXmlv8mZflEIoREM0EIMrgKkMvMD1bKKznRKHYUVZARUxJM8ryMIqvEI20Ok53Sk95Kk/AJQ5pEM2UMMzyEIuAdvBGF5rtAYmHMojOIIitBshLAoyGdJt5AakTKp+Asc09adm/acydiqpjOo6qIM5xROolgOqriqqTm2rnlaqvpM8yKo70Go7zGrXcqc9WCOvZgMk3AGwpkEWGBqxJqvbImtjOitkQmaL5qNt/CManqGjOIERKIHf+u0Q6EB7tZfg1kANDIESxEAVyIEdOBgnrIItLIbaVWebCKAmDNPlKv8KIrQbr1UCJlBCy1hpb6KHb97CfuyC8pRJNFDDNhBDHgwCLDwCMTAsLFBBXe1hx3wPFYxYLchCK6DCJ+ACnQphhQ4UeDLcQrHDPHADNdDCnggnoKQGe7JnzcJGbCiekNEjMqWhEfAApAjujU6KCTAZf5ZlpgIoZynAdKwDOhgoOpzDqcIv+84T/M6TgepTbeUv/uaT/u6TOyjUqpLWgnZtPw1Xn/oCGdABHrzBocmBOqrjfDYWsjbWsj7r3EZm3X7XP/ojGvqjEhgBCEdaD1QBD+TGt+pGvigBpM2BHSCCJZgC8iDDYhADRAqg20GkdWqCDhMTouTMJfQrJ1wCJBL/7C7wwi3gghHzZi2wgiw4A8NSQ8M6sU0wbDQ858aMGgA+JDEMQ0coTypQQjXkEELZae05FMb53TxkAy4ojytsAmkEiin02C4hVs12IKLsTLIyyhZwrw50b9D2hr1RCuZh1u50ygR0SvoK16mSAzkociOjAyND8jlMMiWfg6heMia3ZTy5U0GRll1qbTWWgzioAzd8AhmwQVFZgRlQ63aNaGPlQWO9mx1o4Rswaz1ecAZLpj+WwRlYgRNYQWWWARSAsBJYwWVCmgl/q6NYAaA5MCJgQihALjDIcIjBSw3rFxU0gphowm0m1udSwiUYmBDHoiwEwy0EQzDsgumirvvM/y4UU/Hq3gTDrl27DF2p7YjGAkMXT1QspIM6INTI1t7FmewD2oNnPM4qkIKfBMouxXGPucXlumeifODODpkIpiHfgi9vsEDQrOClWlNyUMALPocit+8kk4M7YTIlY3ImW3Im02U3HhQ0whms5mknp8MzkMEVuuM74gFi/nRh4gEcaGEFPyaLJtO0FhqhUasZWKYxP3W67u22KsEOYFql7YAZJLAhGAIlbMIqkEkvDAMneozHtGkS7LAmFMopBJNrZIJbXwI4S87jeN37ZJEtwHM0IANey3DtshXqrA6H9dEfaELD6oLLWtRGPQM8qAM+/EPDDVSZCdFDxcPKSA4nCP+KzIiCJxQKKCDqBronIzAqIQxCHjAdGG6Bo8jb5FFWfsZh8aHRcVRApm4WWpb0Opx0OVXybVeyS/N2b7N0W75DPLVZDta0PSggO3xDKuzATs9yTwO1YcKBdMOBG7iBBeOyHCD1i6aUsIbRU0M1t6phCbvcGZCXFfTAsPJBJFyCJ3y1RLTH7MIViuEXfllnWXU2NJuCZmeCJ0jdJUBOy0BCXGtRLOo1XkPxO9OuT24P7h6pKkTDMOjCnnBCJBxCIaQCN6iDPzT2xQ1UmPlQPTgUnmTDL7QMoLwfNPMYYg0T4iUKLw7Czr4bP6JhMH7lRvcG8SVfciBjqAhXI5+0OLD/UAuJgziQw24zMjlQMiOfA5Jbsktfckmf1iYXNzXm6T/gA1PiWbMq8HZNdx5MNxwUJphX9wVHJgZrd0qZgZqHURV8N1TvbQnzQFXfgBXwgBU4cCF6AimswixUBIjNbppAJCuFojarwn2DwmF1gijIheQ4wzY0gxBTzkWN8yfsAl5TsTwzbCPQVR7tIfe8FSxEgz63QimUI0fdQTGkgzzEGMP904eP2UPVQ59eAy7EYrlViSl0QgYi6m0i3qKKdmON4Ywb2WT9MY4HH071Z+YhLSQvOZMHuQsR+ZIjubNTu7NP8jpVcpTb1mnhgzRSIzViHC3ZWQw867OCObqn+xtg/7e0InWar7l3GzOkzXsVYLTfihcO9LIcbPUiVMIlkBssxCuUJAYwUAG8DDqha8JalFVbqIYnSA4rMGwtWBTowrXkpAIvTDE8O8MUUwM1+ySLucvFHukmzsKEb5EX3QEkWIM63EPDuTp3ilnDrYOKYINE+e6fpIYnnIL9zHFi0SwPJ8pEayVSzzgJLhPQCm3nAMdYYooIQNlsWzsjj7I6pNCQU/04ZP04DLm1n7Rvw+9w2dNw3W+bmSo11iXDQRQ23MHMXbB100G6S3d1o/u6Y7ehbbA/ZvWjQdox/y3fa0HfK0Fu4ICjmIE62gEjmIIqWAIgNAYrlfXBo5jb6XBVrf+FJkivlYyCKIgCwrTMJZQ6XXxCE5PMNST4E8fzYqiCT0rkfK0O6ww2LKxCqaN8SN1BDtCCP7u8P9wqEcV8jOGDP6xDOMSDNvyCsK2CKlQdHKMbXDy0Yl1vaGtlLP+iFnRv92r0jQ+HpTa9cSBHBUg9I7dQCrEQkWu9+Y9DkVO71590koO92Lcv2RcUNO6TY9vQL3iOCrBodb/BG8S9/78BQLiZM1BOQTlnEJY5o0XLGTNkqpCBqKRKxSpKMFa0osXKRSU8dNy4wQMHjot8XNmCBSvOBwQPPnx48EcTqEZ//jRqVBMUKE2adsICpWqVq1OhVplCxSnSrFepUsUSto3/KjVpVq1G0xqNGjVkxDSliBnzwQMEAgIEEIDgA05Vmy5RglSokB8/ZHLcmRbPnj9/9OQFFkzP3799/+ipqzfP2y9Wr1YR9bSKsqlTo0aJCrW50yZMlipVmvSIkSJChPYQ6rNHjZqFTmAbASmD9owZLFisOGGCt4kRIzZksGBBHDnj4pCTQx6OefNw46BHj65OnXFy566f0579Ojrv38+tE9+u3bt95NGP3+cvHjdIHjxsKIgmTRs3b97A0Y+fv/79/NkwCA00EkqoI4TMsELBjiiyyKOMKsLoIx2c0AGHM+S4AY9WbFFJqBTKIusPUFYqUZUTe9Ikp5USceQRVVwZ/0oVuSAxphdfmumKqm266pGarXSMBhhQfPDhjyLJOgsttnygAhRLJonkELrsyiGHGGL5Rp57/gJMMHkI20fMf/xiZx5ucHksKVMoW+WUN0kZZTPOPMPks9FKOw0RQ/roww46XNtCi9h0qEEGQ2nDTbfdeAOOgwyKOy4555wDJxxwpMM0uuSM087T8Iwr5zvyzmlnPHTaOU9UUktdL55nYtgAAwzOKGNANth4Qw033MA1V/x8DRbXAQmstYxjj1UQIQUdxEiHBp3VoYcePoJQh0ErRMOTWWZpRRAnEvHBJQTY+qNEYtBFVyigEtFpjCT2yCMRVXyyhJE7UunqGmuuuf/mG2mCWaaqrrTSsStnhrQJpyKLNGutmJwkbZG6/OCDjxhy2OEOaPjyxx132PmyHn/2yecfMv255555tMEllVZWIQXmNt0k5c2jQumks84wqeQRRxhBJGg+99gD0NYEdcKIQgulLVHccFOh0Q2sUw45cZjDmlLpuKaOOlDDw4677D4Vb7zy8HmnHe88XWcfe+Ch5Q4ybpBPjjTSwBU//Xj1D478/mMjjACJLRbZMhpatiOLIGwQoip2qKiHZy9iAQcLq0DElVdkeeWTQvS4IAUAAAgAABhgSZeYaNBVxUiabBqDijiSaLeRFvs4hJVt4On9m9+z4eaZZaj5/ZuBd7z/hhhYdMJJp53+GLesnOw9ZEq6CkHDDrpoiWceLvOpR5567KlHfHrQ95KefeiZp5pY4uoETlJI0cwU+ufk2U4oSVMEkT37tAc7uEYNW4ANEYJAAxo47Wkr4MCjMiCc4VTtalhbDnMs9RyuScdr2/FUp8RTtnWYymzoeYfa1ma2dfhjHt+ABBnMEAMVFCQNcgBDGAbHhl4F6w2/ApbgwlCshCjEWAw5w4IiJKEHOShyVaBWhHBAG5NgAhWXuMXxpmSBD5iOdAhInepWRyQjAeUmPhBCERLxhzEIIQ57mMQqjrGNb/SOjttQRjGgcQ3f8Sga16jKMJhHxkakqBHiItcH/273iEUY4nqFEAQZ9MAHSHwCGvOYx/gCY4+QaVIw5qvH+vYxjnRMIxWXyISbToEKU7ApFHDK3yZg2bPRkCZoiAjg0Qo4KATSACSIShRvNsCB3zyKghXU2qUyqMHomIOD1amadbZTtfCs41PaQVXaqKlCe8RDGRLBgQzNkCAz3BCHYPAVGG4oOF95gZ1bwCFCjKWQZC2uClZQwhCGoAQdPAsj0/JnD3bgzwY5gTYxqAIaOEGJS+hxG5fgwwl88ADSAQABrgAGGIlRyNe97g9UeB0VqDCGOGhiE554BS+UMY1szNF3v4tHPHqXjWsEjxvbaIYpJsEIUwADFsAYEhldEv+HRgDiEYYYhCHsUjEyyMEOkIBEKtIxj3jUgx3quIc65KFJdoRsfObbxzvwUY90QKOUqGjFWVExihOdyJU509kmQIMnRtRSNQLMg67U4AVdOmGXvjTBCU7AAhmcgAQuEJvVKkipSzFHOszkGnKww6ligrBt1PQONqe5DnXMIx2fuAMaVHADFZBBWWgAIhfMyQZ05gqHgmOnF9wZBngebkH0vCc+LXS5Z/kzoADtbUWcwIPQxoAMhZhLLXx3CUGg4A8SJV0HVHFR1eVCXK/7AMOc9zztOqISkLjEJ1hxi2JQQ6UufWk8vsGNb6SDvdt4xi6MYYweIWMYuViJKgChiUf/CGIRgxCEIPiQVDmUwQ6CcCozXqqOqorvHlrlqmD+gY/zqOMbzEiFWV9x1jWtta2bqZNoHhGloJ1mNUVjTWsYolcnBGGfhhKsYGkThECIrTiJVWwGN7ipq1mNgp3KLDWvYzZUfcxU6hCPOuJRjTvcwQqiVUE4z9AaNHRBClJALTrTicPXwnYKW/ByQziyEY44qAf4NDMQdCst3+6AzTvggYR4wIMY3MCgi/BDIaQBj2kg4xKIgEEjtrgWc12UdReFRXWPFBMj6YSMNfnJTgCRBz7c4c7GfSotUmoNbfyOveYABzjSAQ/jpeN33MiGNJCRC1u0whNzOQQf9NAHi9ll/6llCHAhPrGNeIxjHlylRz62+uDAjCwfiRE1M2LxmAy34n6RYSvOSJGzWIpmEiLek2pUU+LWbHtQRpCNDhRIAxcEYQyJsASNEatYDDI2x+MwpmR5TLYPkqOE5PmYZo8Mj1iQAQ04qJsKrHAFhMgBDVwweGrBwIUu4DAM7fRylwUFZgUxZHHT2oGZ8YnmfeqgzR2/3JtBwgM6m+QQaIAE7z7hh9OkANAvQeRK0MVToSiaYdfFyc1v3rw/CMELVjADGshQBznkQCKFoEQqaPELlXLDG+agTqjpWEdqNCMX3boEJKbEBzzoYet+uEMPIDKHAN8BF/A47/jckY8vBdtM9v9o8JbUMdZkQ2YVqECFs1Xhyje51TOVsASUIsGIRSDiNCTWNrdhozRx00ANgHAEiYBc4wtW6tPsfqwxEVvMHXeKsuMhspHXkQ4lf5bO8DmCEhJ3BjCI4croVHgXFg7bhz+BIQxJ/O2dYPGLY3wI+yxJx9u8zzgLPwYxMMnc/DDHWHgiEI7481h80IiV+PS+oKA5zXGefZxQoQU0uIEZqoADMuwAY0Qnw5InKZVnVGOm3GBv1OHBI4TNYhWZYIQh+GAHO+hB/0u2EhnOwA7mBhKqIR6oI6vQ52PYTh7MxJL6wi/gBtlawRVagRXubq3y7hRsRgM5IxMwAZagRK5GjMT/TGzb2IkhniAI1MDcVKGnIg+xxoFSPq3yLA9T3k1S4E2ywkbezkHB6MEdjiwdYoHohgAHVEAFMGAIjgAKGKIMuOALmKDKrEwKpgAKFq4LtmAKqvAJoMAJulAJvE1plOZBbov3dADNSiK3cGAHhM9CdEDOim8H6gANcoB3bmEVHMERhCB6YOLlSAQWNIFeCum6xIUQs48KDhGwZMj4/O0GdsAMmKoO7qAQDiESwCsWdOEYnMGPjCe9rsEreGoVRAP/6oAO+I8O/I/o5KAK5EAissQAwSQBQUbYLGke+uJkWCgdlGHZLBBmiAKVLGPvcoYTMqEz/q7aSIM0CM/wTOzE//KKCN7AEQIxF4ghF8oBsa4mOhQLOj4txzZvssRGO6ipbdDjHMzBHtzOH9pBHeAhG+Ymn+5JCa7gCKKwCuWRC6TQ4PTRym6IC6aACpkACpgACY6AIJUgIE+vDIFgIRlyIWsACDIOCGqgBt5w+DZOt2TgBvyNGGphB3JADpyACjRKXLSrJwZJo3AC+26uSLQvDtTgDeYADQoCQ+bAFCMJwPhgESThu1DhFWohYKTBj6jiGpyhF5yiFChhkQBM//RPEi2GKe1AEv3gGcyuMNbDS8DkSzopfeyBMXDhEz6BEjChTTTQZlZplTZDFDiBGO0ExOZqrgivT/zECRDCCVxDNv8UoSdgIReAwRUSoRwA05i4RoM0qBs36ButIzl2rJp6UDzQ4RzEwZK4xB3CAR54YffKcAiYYDOZ4Ao88wqk0Mr2UTSrLAqlYDOPIDWPQAlT88wa8jVhEwh0YAhAYuPa0Ak8wAFGwAne4M3QYAdkQEWKBBQeIBHG4APGQPp6AhScJ3qMBBG1D+caIQ60oAsUpAysADbqyQqQBUP4wBAWIRIoIRNG4TFyQROvIhqWwShZTRIWKf/qID7jk6miUj4lcQdSwf3uwTDYRzBAJjDc4QfpIWTQp8HiARtogRJK4ZRcYRVKwe4edE2iTS3XchM8kNoegZb+h0/6AJ5a4wy8IBD/hiJ1gEEV/gAGxCEwK0g5NmgGDVNToGPHIiXzvtGaelAdtkMc0JFL2AEc3OMGgAAjgIAeh3Q1T+8KMIIzlZQzSxM1UXM1h2AhozQ2qZQhJ5Iiv60ia/MNMyAADmAL1CAFhMAJSMAGXOEmaAIG/gAEyEX6hEJhbsLmojMnnIclYKOf3tA2fW8HzoAO+EAQEGERwpMSOKEUWmEWcmEXdMEWnGIVmMIQ+G8OBGRA5GAgJLVS68BKkmGqCgMxvGSrANQdGHCrPsYfyCfJYgEsKVDD7O7uJDRnPOGtPCME8WTwDIFP9O/EUsMSVIEaSzQOYABFRaUcNk8c2m0GuVE6ZDRS/5b1OrJjHR6zg7RDZfxBHihMGawkn6KUHpUQn44UI1QzNZdUScO1Nae0Sq10Il/zSmug9zZu+CpEBzKAdCxADWygA0CABEjEJnYiEWyiSfRSEHMC0bKPo3Cip+IguDCiQuJsSzmuB6oAQ+hAEAyBEg8hPC/BE1CBFVqhVUcBExhBEAiicMKpcChVDooPErQhHrjEU7UyfQKDVN3BH8IHyaqBFT4hw1zBFewuZipjlaJtM2I1lqDELWvJEAShD/ivD6SxV4lhSISgBWzABkTFO4j1Oioox2DUG8XBHLz2ayvIa6gDWnvQa7PDL/xBHcKBGz7BAxSyWyFSCSXkIMe1bv/LVTVds0qvVCIfcl31VPhwgKACYAB4gwQsQAPiwL5WQnGFIigGqXEHti3mVLtyIRf2ILgSzyL1lCSsQGLpwA74wE8pNjwjQRICb/D8ZA4wJJ5q6zpnawMwpuy2pEu+BGYFgx3QBxe3CR7eJxVeYdlaQQMp4+5O4X7ypzPgyu9CkJYG778WwRJIhBoB0QsORdy+Ax0AUzuytt24BkaLYxy+1mvDVmzDRmxx1C/oYRy+ARpiwG2lFCJXU0pXU0LCtW6fFEpZszXRlW+vdAb61iElMs02jmF5YAIagAY4wAM0AAV69VxMRC9t4kRuQhNYMvvQNCekjxhsQQ0aNs5oQE//0zAkeqAMDEIO6kAhapIO6CA+7eAgrGD4cIBZKk5yIBaJMMADYqAQrqFj0Kd2e3hUSfVkyMRM4mEaku0xGjSV6q5n7wcU4kTaZvUzaFXEGCESMMEUvggQhYAGkAAIZIAFrhcwAVPz3q2CPs1YuSZ8K8jpvMZZzfcc0DcctCEVbhgHHjJKlbAhMa4MVdNJ7xdK9fhc+TZd2bUG/PchC7kGQrgNZYAHZCADaGAPBKsRlscV1qqnZO6+aEIVgMpgm9N5NIErbAFzQ+5vQ/gGLCRyILYMNFIHNEJBDuJYlKAkbsBBnAhi/ylCekACMAB2YyGq7kEBQfVj0Ift2KEdhJhM/+5BHuZhGmjBd2eGZigj785STmSVaOMqpyZhE1bhi4BBE+JgC54ACGZABWJAjNH5Gp/JOMChjMUBWcdBHZYJOsxhjc3XOMxXHcoEHKYhB3pZXSVySF+T97yVHjdTCZkAf81VjxvSkK3UNvzXNhq6b31PgPV0sNTg8ahvL1VNuoChclWCXiTYOS/4Jkp6XpYHJGAjTx3WNi9HJDQSB3oAN+YMpnFgwBTEQkTCIphFcixiWijCAXo5BvTCFoU5VIvZmDsVZQwUGpJtAikjmt1kldbEFKy5E0YBeT8jNCxhE5y2GkGBCtjoDYzACFUgnQNzWDlFHCLLndE4jcX3aqjDa/+p4zryOWWk6hdyQAVGAOMY0q8xro83s8oQOqH7GH+nNH7XFaAHmX/T9ePirEIWmTdBgS+pkRiGwRmWwRm2IhqkgSu0IheAQlzmNOcuoARUgRGErzY11zZ5oApguCRiuHNLuCZH9iHIgLaukzux8yIURCNt7Q5oAR5sscHcri/o4YSEOdg+JkC9pB5eJRU+gRNCY2ZuZhSqORSGdhNC4wNpFUYuGxYAgY3ioLzVYFCq4DvQGnuvVjkS890MEzrUIXzrORyKY67pGkfzucFa6BNkKAP8Om7NFZ/AVbAP+m5Rs6C3NSInOl2pdCLTzCLTjAi2oFd9ihiQwRmyoRqyYUf/tqGm4m8bciFOJTfnShoUSqAIQIGDE8+JIOT2lAWJ/Ik7McQgLnU+0CCcWpe3d/uVHdEJ5OAQCDAeRpVaPeaEfnAWmdu5x+ce0CsZwNIDk/gUHhQVSqF4VykzPMETMMEDpdgSOqGn1MUR9uANAuHMzfuIxhGazkG9xRg50NmM43sc8Bls5Xq+v7Y6vIaNVyYeoIH8goPB49awE7LADdygDZsz75ag9XZvJ3oiXXtzeWAIkIAU0iUaqEKmskGmZup3eORMB1H7mkc5O8AGEoFCOveILAJZWldx6Ekifo5YStggjuWVrxM7d9wKMsYK5KAQ7iAW4CEdDJAdRmZ9kvuE/96BmIOtk0aGmb3hK6d7Z9FqY0UBy4E2MzaBZ3bGoliHedooNQghENrINZwgmqrGzd88zs34rd1NHPC8ni2Ivp3OauabOroSHlIhB27AAwA8b/O30JXAwAe7ScnVSDNuwBv9fx2ykN0w5EJupaMUE3IBGTDdvZLhGIJBGaihGlSKGpxBFXSCtDFYuwaJGMbgAuLAEWQg9awA1nn7cIgoWXw6IsLp52a9ILoT5ufpcPDiIwsMEvwAGoJdnhPwL5AdyQf0wTzJL8inZcByZiqwVZPiTYCWfjwh2zfDFXJBK5gHEBDBNEwj3PfAJbVgnX3Matlb3VMUBnVMOeKaseTdHP/c3muk6hruIAdYQAUkQCEZMlznVlyXlOALfsAXen8f/ErfFQc6OEJgWg4WwRN6qmNnYXX6xY+ogRj+FSZGXruiyxXGwBVgYQ+MgECOpWTRoLZ0ntVznbZL+HAm1WQVpObpcITRoGLv4BO4AR7AAXcJwx/w4ffTBqzwIX3SJx/ywS8Qwx6w4St/96ymHZVuphRKwRREgRRMARQsSl0sgRCE5n8ELy5PjDHb5nqxl70rSJ1ZdFOsg5nsmY2/Fp/pPh5wgQyOQAUyQAIuQtAL+u8Bf0kRffAB4ohAgUOAGBxSEGFBgwwbGqwBUYcOHjyU6FBSJWMZNGhu7Nghh44gRJX/LKkChizatW3bvm0DBqrRhwc+Gtm82UgTMGC2iBEzlaePHjtz5HDkaCWplTJMy5x5CvWpUjNmrJyRgzWrVqNZj6Khaubojh47yNix4+fOL3jm2r3b588fPXx069Klhzcfvnz5/P37h49ePWu0WLF61SrxqlWtFjt2bGqxK2LRosGy5OgRI0aI+mxeRKjPHjVqzplehxr1uXXt0LlGV851uXLixM0md44cuXG81YnTTa62cHHm1BU3h/z3OXXM1c3jRonMERMVJFRRgvCgQoFKug8RyCS8ePFSyksZj/6Iwu0I1S902FBHjYk8nFSxct8pmpB2btyoYgcfi0giSSSV/4jyii3HOEMNS7DE9IEPPvzRCIU3geITZbZwJoghhggiiB542EHHHCZ2tR9HUZ1RFVVQHbVVjEalCCNWZOVAhhl21HEHJNOYI047+/Q1l1128ZXPPn8t+Zc/9lRDSyqKudKKK1QmhmVjq7jSU2W5aOKIJZhMslkfk5CJyCB75PFGO6ad1o6bcb4Gm2y00fYbbsGJo845ee6JW23INTfoaeswNw8zd9QxgwkYOODdetsh0V135JUXnnlcgMEFF+adN5B7oRKExBFIJIQEfAZJNJETTix1hn782aGDFVgZcogklEByCSeovEKLLr00gwwsqvwR4YQVXkiMM8QMM8uYi/8sEgkjiyBiyCCC8MHttiKeReIcaESVlItMRYUVVFqdyNVWaPRAFhlO0VHGHbF4M45b7+Tzzjt0+XtkkvsMzKSSTlYTy2FbZslwY7DkQlk0uahiCSibXFwtI5aQee0geeQx22ymtWZbbOgAV86ew60snG6/DedybcCxU488gaEmzzep3AFGHkbskEMTTBxxUKpIHG0EEklDIcVAUnjKhKeflgf1eEcM3Z56QAzB6hA8eD0R2KzyIFFFlSqkRBhssPHGVXYIcsgilGTCSSmtvDJLLcLWskonMqUg4YR//BGHJcQg8+wsmVASySGFLHJI5IVwqwe3dVxe1H4tKnWfUlP/pUjVUSs6ldVTTTGF1eV1nLXDHdXEsw8+BP/D1z8D3z6w7LH/FTtd/9wzzzSxxFJLKZxkYkpkj7ViS5fE2NLJJKSMEkonm2RyiSWVMM6ZIaKVE2c5q7E2m2y4vQYccCeT45pu6JimZ3Dpq49OPTTTEyc78UyTVh5IQEGGHCgBa9852v+egEAjGOEJQxOIeZjwqUudx2qSyo7XKMIDBWpQgxk0AgaNoAQoXIELaGMbHvZABz0YwkCeQMXdZtG8XORCFzzxRCW8EILA/YEKf0gEI2zhDGDkYhasOJ4kpjWtyEmuEIXwgxNBNBQ90MEOI9KDFUWEh29R8YrgIpHqvliH/6KkS11ymIPqzhLAWMDjHrfbSz6WhLs46q4uBrNHPKCRDGkcgxWjeIwrJAOxaDgjF6awxCaSNwpPeOJ6l8DeJDLWmTjlT5LoaEdsyifJ1rymHaphTSU5uY7V5OZ8dHqN/fzhjnWwQx3piEUO/CAIKJyhCju4wgTV878DPmGDDcyUBC8VnqsFM2sKUdoGj+kqBboqg07QwhS60AY3bKoNbxDEIBShmUocckswbJ4udtGLcPZiFp+gRA+0AAghUIEKPvzhMW7xClm8AhWl8EQmtrc9AhUoEpHYJz+rNS1EIOJaSCwotgxx0GyBaFvb4pZD+TAUE7HLRJfjVh/4kIMc3P8BGvPwS+90F0c5Gml294hHNaqRDV6gwjFT6lI0gNGKTXQiMqcYRSIXeYnrVWISmsGWO37qDnaw46eSfIdr9NWvd2TSHZlsKmtUc46mSjIvcRpHOq4BiTvwgQ5vMANZwHBLgxjwmEZAzwMfmKkJ+jI9AlGaq5IJ17fK1QlbUMMb3oCHj+VhEIRgxCQsYb0+uiJBM5zhN4eB2F7oohavsJuWrNS8yhhDF7N4xStYUU9OYMITx8tEJjCBCc9eYrSUoMQkJFEJff6TERnbjLUM6iFtfWihDhWEUOwwFBLRYYoBcqhHcpCKdNjDH3FkknFtlzvf8W5g+VCHNawhDVYspkr/ibFFLipDDFeQghSroKkpbJrIi21iTD1FhDvo8VN2yEMeP02qe92Ll/gC9ad4ISpTJTnf+cYFH7MJRzpwQYY74KEoVkCDDqpGNCAYkAjHTGsE0frgqQ1NPKZSwlznqoUMb8ELXegC2z5mzWtisxKY6MT0XIg3WwhLWL0IRjCEYYxjIGPGKYkGNaghjRvrWI+UtSw9RcGJUYhCFDdVJGdFe4lKKFkSk9jpmU77T35a67UB9VBCP9SHPmDZoVbErUOd6IcY4OgOzJgHG4mL5rj4A0lxQVKT/HGPe3h0YPcIRzWSkbDGIGYWuUhJsU6hPOV11xTTS6T1xlQt89bXHesd/6o7AIYP994lvpSObz4qDdRKx5e4SgVHOrKR1TroQVxJUcIttTbWYzJtalyAIKtfDarvYOoIFr6whreAay/YFa97FTE2J1HiUJyiMa2AYS6AkdgWw/gYy1hGZWys4xtfY9rbuAY1nBEMIhqGnp7Y7nZLUU9PFFmRnDjeJUCr5HQvWbWtDWhABZpQbNk2yxetHB/A7MQY3CDAn/hGR9WsZnsIXOBxFvgb/xGXOM95H/SQhzeSkYpSUCmeuRiGl1ShCsec4jGEtun0rLcxzUA6MIt+9L/6ZWkk1WPl9bA0y+1xaU1TemCdTkcyFiUijphBCWAFVVtzqUAEIhAKUyi60f+nAAWiG73DmJLwhDHFBCgs5XRTfxFWeB0IvipiMyQ28SmslOJjyxgZLg4Gs5vhDGdEI8c3zsa03Z6NbFT7GtIQRi0Mwwp6lgIVqDgF38EN+CGLwsicLfdnsYdudZ+p3Yv4DGyv7KHZ4puJHvDIHe6gDDO7uUl8EUycVy4wutTuo3SpRzd+IaW71WIYDCLGLKz0x+QpZjGATp4pRDHenTKCLrv7S8zzMiQ39gXgcVZ4zAcuZyRRGkkCc0c5zMGNT+zADHQwSka4oIRONe1qRkMCg4X+BKQr3ehJV3qHu6DWs0aQCVeYQlNMdy6rz+HDWb/mZoBt4i3BYhYw1MUwaBz/Y82Wds4gDWynY9N2DXK3DXGHY8KgC7KwbfTUGHxHgXv3d4WWSOVWeJ31WSSWeDtVIJsRZVIGW5GXLZHHREy0AfpmBoXwCdowD/SweW2GF/dgD6AXMHHkD/VgD/PwDVEST7aADNQQDbZgJbBAJZJxJRq3GKawSOS1XLeDcHC2X743fHExcPZggzzIFwK3cl4oD7+nfLdTUtNABjtARbtlFFfANK1WEKbyP1CwSwuEQOJHdOVXfke3ak8jNVNjHt2REUpxLkyRFBshB2DQBnn1MX01YpkgbFbSCrJgXeEkDMfQC8bQbGiXdgXIiQe4Y87QDMdgiYyVd+BGT6eod/Uk/wqZRW6e5YodiAlJlloEQgn7VCDTAlCNV2UCZYK9mIKFcAeH4CGR4Ae/EA/EFVK3Q3w9SHA22IPzAI3RCA/UAIGycAvOsA3IAHvbSF2KwXemAGijAHJkgoz7oA/6QDD5AHp9QTt9oXJf6Iwwlw9eyHI1I4adNzD+MA/wQAsZ9QZw8AYmggZg0AWb0jRDEHWpRodIdzR4eHQP2SkRGZEOFh5K4DlT5xSx0hT7AQZg4AZ5JQiEoAhb13XcNXEwtAvDUImVuAzNoImc2Ik4Jg1p1wzNdgwx5oCVpXdasgoUyHeDB5RAZmSG54pJNloFomS1OIIkWFBI1Ism+IuT0weCEP8JkAAJ1zAPzBiNWzkP8cBK6cAN2oAN1lAN0wANePQLuKCWwxMLpZUKsXALDTIMlgULSDhYrwB7s7dS3YV7m7Ax4FAP/lAO5oiOtPOFfLFmSHKDL5eFA1eP8iBz8WU7wKMNkKBvbvAGbIAVaMAFtuQp6gGHSKNBQhd0RrcFRYdruFZ0fbh+rlaRVkAGsQkWYOEV+9EGiJhXWrd1f4UJwpYYKZaSMHaJLfmSz2Ccx+mSLtlsNimKxxAMtwCBqLhSfNeTqahIQ0Z45WZ4RnkJtZiUBLKUkdCUSbREvpiCd+AhcEOMrFAMaYkLtDA8rPAJ87krVtlEl4efdxBAYhabGZX/UWQACawQl9SQC3S5f7MgT5aFl1jCGKtwCqTwhJWAC+EQDvRgO4UZGCsng4mJFzzohY75ciy3XpE5F7ZjR8qQUSqAmWvDKVdgarE2BAZkTBtUdOH3kKmpmlPAmqwmkVdgBbN5FGHhFVjhBm1ATXlgTYpwTY9AYsK2GCnmfyppdpqYdsdZgM+gnDWJDMvZnMcwDLtARBVYCovhQn0XeJ6wipmlneZ2POqmbrV4i/40nnHjOIXQi3U6OXwgCEmUVfoZmx9BBj2ABrFJBmhweVmRn3cgB2RxHX7wCrpAC7RQC73ggF5qC3jDf5maqQqKGAz6XZ1wTznwC99QocilFzF3/17taGkfeoMjSg8GR6Lx9Rb6mA6pkAMx4AF39QZeEAadGQXa10AGJIfg9wSnaaNTcKw4upoSyayb0pEd+aOhU5tbMQdFSk14tQeEoHVMmn8uxH/HNgwBSKVV+gwFCIo1qZzLIIrGEGPGMAy9cKnU+aA9uXGjcAo1NQrblUj15IrbqUiyqGSghQkgWC3gyU/jmUSFkFBKxETcwkSRUAiRgwa3mgP+8Z+B+hH+SaiECi87UAXisgjDgGPN0AstuQyTZQuaqrKaalmDpRjfNV4qcAfT8A3q4FGiV1/40I6dJxiPuV4/ZYOXxnx5QWmyo4/WcAc5sAEYUK1swGFdcAW/Kv814ZF0RyN0NYq1qnmaqImjzRqRzwq2QsoRWSFRZVutmKmre7UHS1oJjnivVQJDwCBjLTmAm7iJM5mlNamuN9muiFWg1Nl3fXevokAK95qv4OWErmhkm7BIHUhinzWwT3Za7IaLBRU58KZEkWMIfNBEfhCxg4AIc3ADHkC6HrABG+ABKhADq8u6rOufGRUDKuAfZPAJxtAMt7ABstAMwhAMslALKmsLtVALKauyCqolptAJmKC6lIAN4SAPfhFplTa0eLFe8rBy1ftTv0e0MvcW+QAPuHCrGIABaQAGYaCaUduHQyOjdXh0CISjW5trXiC/Xuusz7o2bVAjJrJb+7v/v3ZwV3gAwLmZB4HQV/hHCqKwcXhTcVuanON6rnq7DMoQwewqDBV8k1/KWPTUkw7qd4NruEKGwPxKNxqoSJAri4knubP4T3OquQIlOSaYFp27JlVwAxhQAeJbARWQARlwuhuww6hruqcbxBmQuvz5CYaRCsxmDLswRPzXPE8MxcS7qUmYuCqAARuQCt8QD/UQO48Wq9RbvdUrX3FyXvVFaUDlJN8ACTmgAh4gAWnQBmEQBh12BbZ0Hj4HBVGndHj4BESntagpv/LLBpwikWAwyB25NmvjBmQ7B/zbv16GB/8LwAOcmyNWYpmAwMWmYsPQpTcpDMOQC8FbC7egC7zQ/wtdagy82wvIcAw88QqrUApCVriKlEiynEjYeVPYM1p0g6b31Eg75aZQZrDimUTkiQjCmJ6CwERPxAf46QdsErsYwADTzAAOYM3XbM3VfM0SwM0SYM0SIMRk8Aq9QAvs+q7w6sRRHMXF2xingHseEANkUAjPEA8dhVxTqHDGBRcAB3DHlXDFV3w9eEd34Ado0ARKcJsRWZCdEgVL4NDgEQXpRzXoV3QdNsddgKO8CgZYgAVfsAZf8AVtANIgvQZGWtJp4AbVur94sL+rwy15EMlv8DFZpgcixgiP0GQk5gkbVyV3yakNE0/Di1iszMpe+iy2MIGk0AmLoU1oiryZIP9umRDLnBDVUN2dmEDVmjWwqTWLTCYJj7AIj3Cw1OKUu9iLC4XWYAYiF1UHctDGKkAC1JHDOYwBO2zXP9zDb93GMWAI3XVTu2wLyIZsXiqKyDAMQiRD1hXKsNAKpjAJhKABKoAjkGANZoaM+Cxn/PzPAM3ZWciVWxkP8LAzd4AGXaADHTmbHYYFDf3QR7AEUQDbsc3Rn/JM54fRqcmrbEDSa8DbbcDbve0GRYoHwU3c+rtbVfTSMP0xe5Blg2AIIzmSn2EgmCBTnRAKaEpk+Vq4psB3hnE3vitDx0ZDQmSvn7UIKwRayXtPB+wJjXQJo/BZx0PV94TVAptu+oTfSKT/CMRsUAN13pHn3LOF1noKIg/FB3VQBqMLzx5w13btww7ewzzMw23sATiwuhZ7AxlFCa8Q3uC0yqx82IhthKHwCHqgBCfAARmAA/6ZCt6ghbfDFwXXmAL32dEYDzd+4/Cg4+nwDdzgdifFDMXQRHUwBUYABJ2S2l2w2q/t0A4d27DN0VhA2+dX2xgtvx6227392yUd3IlI3Ct93HjwUHo1wIEQYs8N3VvHWk0msNUteB7nCaZInasQT5jaqaeACeeNLc49CYMgntq0CdoUCaUlCgMbWhdj6FutbgSCsJU7LdaCLfCWLYMgWwVu4A8FLraCFbHbxg6euiqgAj1MuqqL/6uxe+Gtu7qwq1GRoMnh7ROHPUR4LghWwAImwAEWkMM7IAg9INk5EAvpcOPqEA7g4A3eEJZjWZZnyQzJkAzuyZapkArzaZWQkBb42Z//SdB6sAUyUAM+OpsM/eRN/uRRLuXmUeXnFwaBHAZg4NG9bdJGaqRdTtwBDMB0AMD2xi2KKAj1F+nQ7VqRwOagJVMXg6aENwrgRgpyrhitMAqVsAiTIAqVwAh2IAlz4CFz4FdzUAXphgmGQC2ZkNP35IGRu26M3ugIy4vpSW9Taeng4lBnoTpaYQU3sIKgTuqsa/Osm+FilgNjUagBRtCFYJWltXeSmLJHDwunUAmFQAYqkP8BTl8BuA4B1jzxNewBOJIK9nl5AQS7nG66GBDE4iv2PUz2GwDqn166GtXINfADEGGRsmkGI/TksM3krx3lsC2R6C7Hcrw2Gt3uJQ3v1krcH0nvhZ9FD4XWUwm68KbfN91kYkLd4hUKkz/5QmZThFu4G+egpIAIVqAEi4AJiMAIhoAUtCIHVoAHglAJhrBTAbKnD59a/ERiZ3Lf+oSw0A05T6lQIXJFWQZR4TIHZ7Fb7IIVdnBRVWDhYyEHBH0Ig04JvbJ3hxFPkqgL/nd25TqTavds0YAMs9A3kSAHOuABFYDNFTABExABEQAB62/hOLwIO2DFYi8B1eEANlwd89//zfl///nP//0vATcAEGaUTKnx48UMJU3IkDFj5sqVKBGxYImypKJEihXBgOHCpUuXMCHDsGHzho0XNmC+rGHZxuXLNm5kzqSDx+ZNm3r48BHU02efPoMMISK6yCgjRpMmVbKECdOmTU2fburUKZQnrKK0kuI6KlQnQkBq6EHEEwcPHThibFCh4gaaOWgMGZIzx44gQ0bzRoqElJEkwIElGSWsyLDhQ4fmDmJsaFBPPZHt6JRMZ86cunI0b5ZDh46cPnwY2cqFzNnp09FUq6bW2vVr19dkw46GLFcrRDg2OOCtQMEB4AcaQGjQgMFxBjc8VMBAZ5AECQd4T6denUF1/wcMFGC3jtwBDh1QZNSoMWNIFSULG16REjHKRPfx42/k+BFkyJIk2YThwrKlG5himqmNNObIKbIDd/KpJ8YaGwqRoyKR5BGlmLLkQqeg0rATDamqyioOMXnkjRpwiCyGG25QIYMNlPDgRRU8MBENMtCg4y68BCEqr0UgJOzHRQ4TUhHFGFtQED1ussMzPeyoow7MODtjys3UUIOOPuhYZJbVVJPmSzBhE3PM1pw5BpVDbsjAgd+CM+DNAgYYIIEEFKDzzg0wyGASRSRIIDoGKqhAAuYwMBQD6BLlLjvktPvNt+CAY4CFGU44gdIZcFBCiSoYumIKKNyDL6IvRn0PC//6PLJvpPxEwsK/NWQScCZaa8IpSTx0UnDBBx/08agJKZzkwgst1NCpTJzK0ENMLFEqDx5YsEIFFF/EwNoVMYhBrSp66IFGO+yYyxCekCLqsCCHVKRBxg4xEslcm7xxycucfJIzzaY8YzM6zpisp0WGWe3L1sCUBraDqUm44DJ7eQWSHjDo7QAD5KS4gDjlHADONzuug49VJPFAAt6u2yAGanOIYeW2WlZhA5hjzsBQQWsW9FBDZ46BB06tgKIK9BRqoomHppji1IyWsAgj9zjqqCORosYP1jVcGpBWmXDKCaeddkJkKL8UeYQQRfxCKhJhK2Hqqak+5HDDDT+kyhL/ReioYg4VPYixgpVxuAGHF3FQAQe15LACkSUj07FHRBQJ8hDH0113ED0aLPIxn5QM97M56sD387roUOOMOTwjow5UUFvGYNYPliab2RQGc5laPrlDBUShmw4C4orz3fcEFljAN+ETMMWVSKxQ04OSMVBxZZVXlp5llF1u+cUXYfZgA+zbuoFnoIHetNMmrFDi06NPlW/pjFB9GmqpRWKDaqthwtrWm3CNrGs+5vp6qLKV7RGMWAQjIlEhtSlFKcuaSoccWJUNWeIRgrACDnoQgwrsJgaG2pYKHMA95dzgRqCxAx/00AdBoNAQQwrSICBHJBe2yzE+iQyCwkUvOjwJ/0pR0gwP66UGOZTBM2iABDCc0YxmOOMZYDrNl5pIjdhRwxm7KIUfVFCBkiHHN1u0ExcVUBzhhbF4mACKFpwQhBFogAMOYIEaUNSDHfyNcHP02xxT9Lc75vFv0lMBC2SgA06FL3yb2hQToACFKVjEVBRhn0Q6Yp/7RO0+84OV1fwzKwCVDn9JqiFPejIuoTSOEIEIBNke8Qi+ILASClyKspQFlUwk65VQaWBTFqGHKlzRAxgYVAUYYAITxEx6nwFNaHSSQkFITkjtgqG7XLgYyCCpMkua15Msc5keXkabmuGcHuRwh1IgYxlHXKI0nvGM0yTxNK6RRjNoQYkdbIBk2f+JFHAScIA7velOd/qd7yDwGTW8QQsrkAELBDUIHXggRTvYgbcc6q1udauhEOUBQ+not7QQjgdG6BQZwrcQTm3qkFOQwtLk076MROGRH4lf1NjwhZW0xCWXpNVl8JereB0TYI5xTB/ykAdCBLVsSAkWKxOoNldiIpbKqsQsm9UsS3xlEjsgFMl4SR3ueQBFViiDHfyFCEGUkCgQOkxiymoYdgkFlDTsCR5u+FZqekab2vSMZuQVrp3YYhnLSGI5n6HOvTpDGrV5hRVzJwEIMMo4vGNs74Z3pwX0k3e+Y0wepNAFgiCKDoagVgxysAON8kC0o0WLDkxr2ovioKFnsEL/WnRAHh0IEmhWMJ8SDGm0h5hUaUqDz6iw8D4upAoM+tnIS2FaSfvRpA5vtclO9ueTxQwiEHvYwyDyEAghGdCAkwjMUtRGCfBeQryuVNsllJqJTcRyqRpaxIoqAJwBHKACEGCA3vrGgzKU4W+IoJyOijIIwxgFhkIyqyLGyl/MoRAynCzhTqhJTZt6ZjLL5QNe+UCGSxzjGEj80jmdwdcjHkMXqJDDbhwgKBawgAZBIMITDPKEJ2zBCzOe8RSMUAMZrEAEFohABHpXHAhMQBFwyAMYlMCDtfBBEjlQQQ5ukAOIho+2VnACemYLNDrKUbVVwIEWhmAEJCBBCbSVsvkO/4nIKTwkPrtdAkon8gUpPI0+HBmufkgC05heEpNusMlkahgvEx7TQY/JA3WBGlSyIQVYkpAQAsX7aEqY1ynjxQQn1HtpU5CCQ3ZwQHAGICj6ZkBQ1MpAFdBwBjpUzn9EYQSR1IUuATturNFV8IL351y4emZeN6xwCcNaBjTIAomCNac0jtiMY8ziEj2QZwZUAEwSvGELTiCCC0Rw7Q50QAQk8GMNeOCFN2DXEY4YZRCszWPGKoIQezDfDeaQiUlccGXKM0NHa1QXKPkaL0MpoCQukQlPjMIUrXCFK2DBiDcwoQZKOKTPRnpmKJzPDPK5yHsw8ubLfmTOwbXznY+LXP9ZxaTPNbw1/wTxLqHgQQlIYENQSTkIRgywgAYEDF8iAV6cgzepylpqUk2xik5kohIquM5vCHUdCIwgA9FiAQ76oAZC0IEQZkPKqyX3o8gdeIZHEgT/ulZD5oZLDl2bDArhCAlhjJPYSFyGLj5BBhjdYAUamEADDEAyBWjnngfw4nUc0OMJaMAENdjCode9BRmYwAJ6oEMZ5CCIUdhiFRKixChG0YlWDLwVr3iFLGZhC9DnAhjDID0yTG961HQpGsR4hBI4YgRCEhIKYYYCEzYVH99OhCK+vWxHNl7c4lKSJXheCdb4PC+Se50PLlQMXt4ggQAAYAAaqAF2hTRzCUX/YhGH4EMhCnEHNNyhEJAYr3nNj6yloncVpzBFVSaBgeMcgAEJ0E4FTrC9DTjhRmrogx0Q4ZcBIisgiTUgIaCi+J/oapCu65qeCLQmUZJU44OPqTA9EIQeKAMyYIUPcyJnMAZWuAM+kpgDGIAAKMECoBg5KYCKuRMv8qLhCLzB24I9cLlDWIRLaIXSOAbSMwbSGwYN80ENC0IhJL1jQAYhLMLTQ4bVyIUwqIEbiIEjYAIpXIIjWAImkAIpYAKTOqmkQRqJUCksID4smCnkgok0cIM5IBBN0ppbubX9YQxzmQAAmEM6LAAU8AJFcARLUBu1YQTKyYEcuAMQbIsYEL9L/+AERCwFgSMFgVu/VWiFVuiEy9OQQMiABJAT38iOQbmWGygDHDCEFPqf/zMKvvgR7euLArK5AUwMVjQSB6ShPuuzcGkuyrghPMCL8fsEZ1AYaogGYDAFROCyGCCZ4mCAYrSTfUpGFlRGOhmeMAoyDpiBKRg9IDwGY7hGa7xGHtzBYeBBbfxGY9CwcAxC09ur1cAEIxgCFWmC3TqCKlyaLcQ93bu4lNI9e3wVqhm+l0gDfpyDArmMJ5lFNnRDnlCM/wuC6KPDOVyAEECBOEgEulkEvLglGiEDEDyUlYmnHMAETxCFU0CFU2BEUjiFVVgFUxCFoIOKTpiEIYgv+TsA6P/IoBg4AxyoAj0gIB4ZQO1bBFXULgLyC6NgRaE8BO8rBAaExQPRGl1BkBravkOAhFeAImeYBUugyeXgjWLUImbcyq0UIzEajmocx2XIRnAsS7MUR3I0wmMYp2jIhTcwAh1YmYhQGne0CKWhOFGZx3vMS3nMs+HDM5fgx36cq+WyAzY8kOeCQ0JQAIWcwwa4AG17gkD4qUHYCTnYgc9CgxyQGAfAgLboNOlQATtgBE/4ilAQOFMgSU9Ir1iCikUYQZcMlBEwlCrAiz4wBEngkVJcBEazOZsjqkn4ybPZScIQyqLcCWeSJsVRzpLTCaAIjT4ISk5ojVnoAxnIgAyIgJL/yUpH4UrvhKzi8UrhMUJsFEezPM9vPEJrFEJlUDtRQAOCoJQ1g8d4XCR7pEf1yUviWwPisxrB/E+AXK6byh/98QlHIIKEpEMBuAAKoAARcAEvYAw86L46MAM0wExD6Uy9wQA5CQCLkQAVIIRJkJuO5ARPMNFk2YShk4CccQALmBkVsAueQIQ5AJvsi4RKqDlStDmlkITh3M3iHErve6at47oFQSGg+InQ+JpFMAVKUA5R087E+iLjOI4t+k7vFM+vFIb0NE9wFAYwDVMu7dJsXM8gbE9nGAY+QAMkAIIZYAG8vMu59EI5vcc3u8+8fDMx/AL/FEw0GMwcqgPPOMz8//EkRbCAEkzQB3iADggBEZiCLsgDLjADi0SDHgBEzuzMGCHBALCACbjEE5QOE8iDSuNIRDTRUkhVT2gvRMmTEWCBOVACzBCEOdiRvxAMSehRm8tVBVIbwJgE3wTSoBxKUFJAIz1SoDAEO+gDsJID3OGlQSEZK+XOLVoALK2TfbJWLRUjLx3HshRTcEVP9QwsVqiCMrixFMO9OZ1LRYKP3XIPmNpL+/wCpOlPAflPNPhTm7KmAVVKnwgEBUjU6EMAEACBENA2IguEGeCe3fCAHOAN4PBMD4q+BCCBBLAADmiAAgCAEkyAGVgEtcGKU0XVVeAD7omREagBO7ACPEADHf/BUUSQEEnwVUbjVe+iWZpdit70zVVMjFkbl2JtEKD9JMRRVhxYk+NArOlADt9pFAawVixFxm3VUvM8QnAchnBFz3EUwr1qBmHwgyqotydkATdjGrykODwzFXkMQ/2EKTP0U31dQ00a1IH0JDgYQQEIgLxl0BC4gBL4AS+AAzhggRjgDc+MDuD4IBWAvhJEAb0dgAJ4TAgogBKMLwj4WI60PE8oBVPwhEwARBQ5HyV4vKHoC2ANDD6shANKXT5EIO7iLuIkDGGtwR85sB4BWtzF3T1wAhLIgAawE/kzDjrxjQTgTuQIz+JJxqmd2uBZy70SwrLsRjE9zzE9wr3aq1f/2AE5QAPCUZFS0b3vzT2Kc1c8nQiTAl/cOy6YyNf/7EdbKR26sombOiY30A4DSAABQIAL+IAUKIESoIE9eAMgcAIVURkMgM0D8EwMiL4AiICNHQ4BeJMBiAALSIDKnZMRAINH6ARG9ITOvQEykAMdGIIYqIKy8FGe5ENKqIRLqIQVZqWbTV2jqrmaC1ZTJCDG+RHc3RFf+RonWIEM0A7gKAA6safgMN7jWF4l3tbgWYBd4AUo3gUp7gVd2AVduGIszmIpfuJe6GIo7uJe4Ku90sZhgAQy6IE5KIMqYC0ujIIqRBr71Mvcm8f3iFf+pMIoKJX6CUx/FExN+uObott4/xGEIZCANyGAAGDUC+jbC3CBHxCzPEADM9jMEfRQCWCyA5jDBBCBAFiAT10AOEABa+0AL9CYFDQACJgCS/g5UliFQ7CD0tk+ngQvSYg0SjgEmUXdVbJZwJDhBOpNHeXZ4gSSoSzm7COMPjgDFvAADfDUyfqxpkXip11e5V3iMOJSMA0GYQiGYABjMN4FMIZicR5ncg7CYjgGYRiGV9DMKjAcK5CDM2jjPLVTeq7HMEQp9XHHMHTbl/iC9v1jgKbb+Y2MLjiBCIisBFjkgp0ADkABGXiDKWADOiADDyJBADgAanGA6BsAERgAhm6ACUCBuqOABPAC/BUAyC0AAcAYA/+wAB3Qg0rQikNIJpCdCxt8tEu4OUqg4RWWYUa7We+a2Zrd2RoeQGJ2yqFkNMIQhDNQkQ2wAHQjDmguRmne1gaw5uUtBmPQ6m/UZm3OZmHwBbEe62AohrH2hWJI62JQBmVIBrPmhV6IBE1piLA9gzLIAnuW43p2s5SCY4vLYzc+gjzmZz/lxz/9xz6eK7m1lT8zAjXYghOwgAboABsgARFAARYwARYggil4A+6Njg41FOjjWBSggPhiABxjAQ6YgAW4thIUgLzV25V+E77LACUYCl2dyP8zL77AuUvYaUlrKppdYZz7Lpqt4aI26lUMUr4gIApigQxo5gmYgAjwp37/+p3jyErhAaMw4m6sFk+2Dm+2ToZkaOtrVGvyduti+AX2Tu9k+IX0hgZoYAZoSIZjsIUdUAIuuIJOOTUrwGu+3r173st5XjM4frOLsNf2TQP2/UcGLxBdG1SbQsxCI4RTcoIaYDHOBjcveIIwQAOUYQD4cgBAPACBBemNGQAIcIHhaIAXgG0PHYC8hW0DiBMDoBiYvIGkeARD0ANDOKBJiLTfDq8hlzSmKi/WRSrWxVWl3tFgFdagtDlDKAMWeGoLqIDp7p3Jum4un+br7m7v/m5mGHMyL3Mzfwb6lu9pWPNqaHNrsAZs0AZv8IZ0SIdv+IZt2IZXyAFE2hQLzS8A/6dHAe+teN1r3WOffS4VUuHPMAyQlwAQq5GJuJCDwtQhbVounUKER7AEUmiFUbADN8AExlCESGUEEGQeET+AHCiEHOBUhSwAyDQAAUiAAnCBgNWYApjcAEiATyViFbzxvLMAFsiDslldpMoEnAYvTsAESWthFmb28nL2JO/lmc3RXa3hJ1e0VJwEREADFmhmqPZU6p6seXIA7M5u7Y4s3/luJX5za7gGbMgGeecGer/zb6hzeMj3fI8Hfo+Hefh3gA/4eICHa7iDG0CCJ4CCK6BUK+gCOn74+zT0Qu8t8C2Vu1yJ47LXNuDTjedTSU8DStchke8cXzsEpdiEgcuFYf/IhVwgBld4inUJ8juQp07DgPHj0ERVSL2lbgEQAQ3w0EscAHPfGAuAgI0JHlyXk/sdAS4om5mliljC6UvwXPVidvNC9mc/ckxI3WrnQ9RVoO7iVR89m+CkAxngAE+l4Omm7h5zAN0xdy6P+99hd6hNRn2/+33f937X936PB3n4d3uwh3sYfMK/B3VIB1zIATKYgieYAjAwAzOjY/UxdDtNW3ssdDyTCIwfPklGA47HsyzgeDdA7LmqC4CswBqchEw4hVaYBdNwBmRY+VPgkEcQBdtBFN64A0iAhByo5BLk2ATt5A6oXAWILwewmKBPAAnOGJTWGJhUgknIkPMCOEv/G9mqX6pmF6+m2nrW5f4kh2EY7s0B6gMdMIFmru4Gne4eI5lEKXe4l/t+6u4l3sq+x/t8T4eBh4f813u/L/zBD3yAuGdPXjxukGLc6GJEyRQrVqAo4SJRCkWJWLhgwRIlCpYvHj9+yehxjceMHUueBDmS5Bc0HtvAbJMlyxeYbm7SmZNGDs+ecubY4XNoUaROo1DJ6oXMmTNkuWy1CoXpUSRIOTxgcIChUCFIn6xKGAAgANkAY8eSHXAgwAAGAwIcWMt2QIG6AQqQLSDg7QADDCqwyGOpU6dNmTh54nSYE2PFmR5jupQpMiVKmC5XuowpM+ZKnj9XmjQpdGjRpiU9/+pzhoWHDBMgNKAwwcKECBAkOJCgG7eD3g1+/+7tADjx4r8XIFeAfHmC5s6dz4s+Lx716tapw8uePd68e/782YsHzps2bdi/NSNDJocSJVC6dIEIBcoU+PXhc+nChSL/kBo5iuSfSQF+lNESAH7BUkdrMAhSGzex9OAcbqSBBhpz0HFhUIUsIkklmYzSii3DMOUMMLm8skonlSgySCE7bLCBBDl89YmNX8XggAFl8QiAj2TFxZYDBwygVlwHFKCAAQQQYEABCxgQpZMFNDBCIJaEQooop6CCiieijLKJJ4mNEtlnl6DJmWZrYjJaJZJ4+CYlkkQSiSSYTPYZI4ZUof8DCyNsoAFtExA6wW6HCpeoog3AZpxxCzBwHAMJKPCcpQZwB883m3LzDTfcbJONqNlYMw0000xDTTXe3LPPPvbMY00yyRRjKjPGfLIDGUNw4Z597z0xxRZTEFtssVJIxAVKAy5rkkolAShSgAw2mOCDbZC0hk03pZHGHDrNoYdQHV7CiSmvjIiMuk/N4goplQwibhoxqLABJKngi+8nhdyRAwYJFPBWWWf5WKSQRcalVgJOEiAAAQ1MQIGUAEupgAZdYHIKKaWgEqYnpow5iieTRYYmmppl5hmenZUG2iWVSQLZZ4jIocMNJgCagQUV8BxBBIcCzZuiwkHQqKPERcr/gNIKVEqp088xk801xSSjzDG++BJMMLzwUkwwuIANti+/WGOPq/LIg03VxTzTTDO63LHDDThwAUUVZThkRRfCbjGsfcXqxwUYYCg4IEvPIr5ER86mlCC12sJEbUzcdgsuHXgIckgkloU4iy3AgG7LLLC4ogomLfKbww05pBJLLLTEksonfuRQewxZEVmWwWSNpcBaRSJM5AEG9EUBBQvUtQAEByysQASRqjBIJJeQ4skoi435mPYlX4LyZmqiPMn3JqNJyfaVRGIHDjjEgPMGOlsQP6EVBF3/bkQXnf/RDSi9NNOWPscAvihGNt7Wi2DsYhjDAMYuEjgMXdACF71I/2AxrDEPf+zjHvPABjOcsQxpSMMZrNhBFZSAgynYLW9WMAPftgAf+IQhhmEY3OCqZbhnHQ4ka1BcSRzXQ8c9Log1gUm3uoUGb9EhKEMxRCQw4QlUtOIVs2iXK1pxCkzsiQ910NUdaEELG6WCFqmARL9yQC+sDAl4alSLAtJiJCIVAEkBSEDRnGQAQsXFABoYAW2Y5wAVaA4xYwpZYxxzGciwiU2hOaT2MvEyxmxiE5UwhBUQ0r4RjIAD8dvkzuhnv0/mT39H6x8DmNa0S0XpGMdwxjWOIYxjGKMXsgTdAnPhuVzkghjDsEY88oGPe6gDG8XYRS10UYtXHAIHfWLBGf/OUIYymCGaZqAPsboQQ2vKEAzJKtCAuuksbiaIIzokyTdzSK1nWciIRcSQuPQwCEZszommWAU9V6GKUFRiEXyI2w4KMbZCYEAF96JE6mKwAQ8cVAIYsADxAhYXpfkILcIDXgIsgJwoSYBnSqpS/CLwUAzEIAZ3uEQpPoGKUghykI15zEpJhgnFbEZ8kdSeY8bUiUww4gw3sKT74KfJTfLMk58EWiiLBhyjSaqUAFyYlJxkC9Ex5RWvaMVJRxGmNjECKIMgRGSUAY987KMe6mDGJ+4QA9UNwQpDmAELZNDMZ67QDFwAHDbD8MLASaRZzWIWOEPCTW+C5CTnVImFjmj/hnQe8SdVOANQ8MAHQyCCEZOwhCUuM4lFHIJ2OehiMQqBFQxsIAdcuUO/6KUCDOQgCxvwnVqANzC+JGwAEpiA8prDAZ414ACYXEAD6nIABqggBh44q1dQWorjlkIUg0xMY8akGMYkZjIyNQxLQyaySvCBfSFVAc4yGT8O/BSoPBsqUYvKKKMCB1KTWmpT66KE7eZiFBtQAUI3wAFBUcACEOMACZ6Ahl/Ao1X3kIc1rCGNT4T0BkCYwQxWcIJmOtMhgruPNdlg17vSEAzdfNY3gegfv/Zww4H9yOFo4pHCoiGaKLbQEIwAhTMcVg50GERkGfEIz0ziEIfgYixuAYkN/7BgBhwArQruwC8y7MCg68kKbg6gALq49skCuwsEcsOAAkBAAz5TQAM4MIEGJKBIBWDABkBaiOAWwqSfQK5ylwtdlY5JFIzJRGYiiRjoisIUptgEIsqAAxYEt33uAy+hLRDe+I2XvOV1QCiPo95TBrC9s5mAAzIAi0dklGe1Md4FINABFNggEYtIxjfs4Y97sMMb3qjGgc2AAyCsFdBqUIMc8GYFMLShPtW0T10zzNcE/VWw2AKxSlgiTpU0biQmboMRD7tiNMihBjoYghJWKGM9CIIQiFDEjTGxOfXc4XWQGAELoPACFtyAvmbAQx3koJ5C+Is3G0jDBhwAvAJECf8vP+oLA35LAkY1wACGtkAC5iJbhd4BEgHdLCe6dFxRQDzObV7ulyaOpziLLGR6roQddPDnDeyUu5gEbyYJfehODpV+iZZA/nzWKOTwD9LOaWqULoACEriABmcgxiZk4HMXpKAEJYBBC1xgg0A4YhTMgEd3BGKOeGCDG9S4hB3sIAcrlIEHEH7mFCjywvpcEz+CY4M2c4jsYpvzcCwJYraqxfabwJ3Z3vqWTpBoYTC8AQ95yEO8+mAIyTqRFJ+gBBnOmgpW3EECHCiBC1gghzIDWQXo5sNBhJaDS0ACEiqw9+7MElG0FMA2EHjSBTpAgTDHUQIqUEEO/CBc1if8E6L/SO5yIT7xORcSum/+UpxNIYqsWsEJMmBBSFlggu6WvNCc3FnQhLqb8RatNy5/uXqV2hyaN9UG2p81D/pADFUQQQs2gIEQyO+CFwQhEI+4hFe7Yw97sIMd6YDHNRZBBj3QwQrV3jqxJBJ2GWITDZGdsqyEX1WLDuFQAQKR2rHd48Ad3H1LTnxLhXgLGMxQ3u3dICRRHyBCJFSCJ5ACJ3yFGX0C4mWACLyAC6zAGYRUDbjA8anAFxxCE3zWVlBC5pGRv0wZWQgAjwQAASBAAggABVwABUBAD6oFBniAByzZwiUcYkxc7SkXJ+BJShXSYVDcl5ACJhiCHGiBDsjAChSf/8hh0sgV2qEJVVA1H/QVzfQ5GiktlaWA2hh4wQ/UgBEgAjCAX9/8QBL8QJBBASJYwiUsnfvJAziYgzqkgy+QFh9YSBUsFoRdwRX43zUBYBiwQSZqIhiQGDkBGw65XYM0YChmS0yc003QXSrWXYUckUS0Qd7pnSDkHQcywgeWwiWkwiukQpqxgh+owAqMwRZ03xkYgSIQAQqcmwgE2eqxno1kHml5BRkMyV0wCZMMzFgQwJdFQAPMBQNgAEhp3jeiWSRA4e3x3pzRVCFl4SBB3CYswhycgROA4QrsFKAd3/GZocktXychWhqqof0MB/+Q0tLEYQJMQRwAQg3sXR7Agf8iOIMqsEEgKIIiBAIYDAKcYMInTMM82EM9hEc3KCI2QAIZFAIfkAEaWIEOQJuFcAElDo4MXaImbmInnp0PjaLjYIsQeZgpnqIbgAvdFdE60cHgvCIexKLeDUKHONFxsUIuIEMw+AItHMQQ7IEWQAEheMEW5EEN1MALeCUKoAB4qUAh6KIz3osz3gEGQEkBLIwAOIwA/MgcNQABpIU3SgAZKFxAeUAOQAI5VlwUasmbPZc6SlztrQgflEE8+twKyEAMsIA93iPOmBwHZAD87OPKZRpmAk1AAkf/LEBBOoIlnIImdIIrrEIohAIsREMurIIruEK7zMJTAIMxZEM83EP/PtiDOWiDN3DDL9wBGtyBTuifEvikHKCBNn3B4GRihjFnhoni2j3nYCEO5OTkYJ1TA37BTUyOG7TBS2xnjF1OLOZBIESW+MweUgxDMyzDMjTDMbyCJxwCdw7CFMBBHuhADfzAD9iAV17ACaAbJLBC7OCLgGbeDTaBBKxllFgjWRiAw+RFbkhAv4ijSGXel4xCFNpexJUjc80ZJphjJ2ACIsxBYvKADKhgYz4md0VmGRJaZVrm8jnfP36Sb3Tm0igNABHDiRBDjhIDMuwoMlBDNPToUgyDLjmDNHzDBYEHOGADq41kHcwBtCnBFYABd7aBHEwOGGzilspkJg7bOEkn/+J0Yk4q4AEiDkx8RHcOUUy8BNZdyBu8Ad/tQVI+gvh4AsfMwjAsxZFSQ5/mQiSQJB5IASHcAAsYwROMnxCkAArUAGvwZYDiwi/Ezo3Ewr7cgI7UhV44DJjxDgCohQN4wJl9415CwiJQwipYlXVpYYayKocqRmI418ikjxzEY4meaKGm6IqyaIu+qHg9n4wCJHr9BiktgCkxzY4i64+qCzJEwzZQA1Mcg57uKTfMg6vcQzpcwzPognrUgR2gQX1kIhxw5xd4Sxq4gZYuJ7qywU1o4hu4QQ5NCzkRiJiCYk02SxY42xfMhIl9xExwgUOUAbQBRR/ogbYxgodwQim0Qv9skogzTMM1XIPUSMMXRYIc8AkPEMEPPMEWvMAPeOUMAMEN3AAZcEItFIMvuE6+fAXteIAETIkd4YXnjcUBFFmZgRZeQoInrIIodAJijEJybYlyiQIpaElhppScORedGUIzaQEPlGgLMOYNsNVjUi0+smjy9Wo/BtXWkpcoFcdyLMdSICsyFOmyRkOzXoMz9IICqYs0UKs/vANBWMMyeAIO2EEZzAEbMEEYiIEYiGt3tsEcwAQW0JDgCOByaiK8igS1YAFNrMFFBNZJZASCIFuAeNMVyJU2teQVJKdHZMFGXEFDQEEZcAEavIEe5EEfGKx5rgK6OKUzUEPEQizEUkP/M3zCIfQADjgBEXgBIIxBx+ZnRVpBE8wB5b0CL+CCF1UqJfjBHZBBEwxBv9EF8QjM7jCAQknAcHXFJaBC9YwMJ/wsq4qv7cEq72WPt91tPOoAD+gAY3rc1D7m1N7jyOXjyS3U1uKv8xGV6KGXsAIHLAAw6cCCLQCwFD1FLsCuLsgCutQCL1wD0wnEPGwDLZABDugdHsDBg2BnRpwTgbDdic0EvbpEcobBRCTLCRcuSWyE5H7iClsgTL4QF2CiNiELGBiLNWHgHhCCIjjCI1iCmKACuvTCB1GDNPRpNUSs1PTC7JABC5yACKDABZSACFgAFJzVBkTBDNxAP4URLsQO/xmtRyGkgQc4QKXsSFoQCcL0huqJ1ubcafgil8hEHKvqXiF1ySggBheeQfCxrw54nAyIbEgVX65aLQck3325qM4sFAbkL9eW1/QhlaOgKimYwijo2SrM0ypE0SvIgjBIQzDEgixEUDUw3fvNQzZ8Qg7MQNxV5wdH7uIOVuPiazTtK03sqzSZgQWK3QlLxODkVUgcW+OYBBh0gRcYc1bCkF2VcLLsWgy9ARzUZx7sMLd9iM6+Qi30wiodqREj8TVYQ586wyuUgQeMwAmApQicgBLcgBzEQCAAAQ2wj2il7Fc4b9xggG6kUfDEhVbEyFklnPmYAnIJtEDPHkGT7yDdsf8ndIIk0IES1KofQ/T6BLJjVq3VYpIIEJoGaEAGbPQ3ejQje7QjB43PuOH+iIxVmUIrtKYUTZEuGFMvCAM4KwMzYINtahA8VMMdFKqVHqBOCojkYkEH/0cUSNNMbIS+boSzoUF+7PJ+8LJFoERUc1N+bIEx39WFdYEvSwGxYGIMsQEcPPN4BsIOP4KHWPMs6IIwvFIzPIM0pAo1TIMRS8MSo4EH3MDwycAeBIEaBEEegIETsK8cBNcd2Ajm4chH64YCMECihFYO7EAO4CUlXMKdntRAWzbRboxBz94qVPYmUJIOaIETBAENQLQfS7TIUu1jzu9FYzR4aTQiZ8BHy3b/BXyjZmbUoRRVbtMS2y6rujhDNDCF27Q1NWzDNXiDOnzHPKQDLqiOCvA0dk5nmKLETEiTg+hrFhxRhWw1fPhysnS34KSEN3UTVVs1DGEYG+wH2FmYM7NBWO/dWCdlzIxC686CLDTwMSwDn6LKNDxDW/dCKUACGuCADDhCEgBCHHQBHuxBIOzBJCgBZNtIVwB4DpzWN87XN+LGN9bOZvUTJFACKmDyKlj2iGd2KRAt0G42KugZJnSc7u6uEwC2H7PvacOvauOjCYhAjk/mRlembPt4I+OvbpD0kJN0U/w2cP82U8g17EpD27B17IYDcmuQNliFCoyAduakTUSOmTJI/+TQ6xcU9UsYNXZbiBl4HQzXVTYtyE+LN1WHnTXtWrJsd5q/ASY+MzTX5+m+04ccRSmwwjXrQjDktzScyn43uTTcAitUAlbGQSJ4QSA0uvrVQD/VAiqcVeqY0eupQAbYLEiBG2lxxSeIThVZVUEf188KdGbP3okjF2drjCSUgc8RARHA+O6y74zjgMiyVY1HJgnk+CFTZmVawDcm8jdqLZCv3HhVQAQUCnCfbTSAULQXcRHL9TNsczWAwzqARzwww2NvOitPjpd34uOsRA5lQRukmBnsK1JHAZlHk0SkOUzK+5qL939cRBdswZuHATV1HRNQRDPbOSbKJJxOARvwnf9ScsKHiMKfo3UwzPQz7Deq0K4zoAIi7IElSOSjE4IlDMENHMIrcELIDZdjI1nh1SBqgXohNC9ZPoXokMKFmnr4FrSqmzhmEy09eQkilKgMaEFo7y4RGMFC4LrUMhivm8AJkICv1y+PDzsGJLKww2hQdRKyF8oERMO0G7Gz9um0c720W8M3sAOsfEMqJNlpPeCWkymYFk4sN25L0HK713JLlHlzwjAMfyJgTW4UMPXX1Qe/M4G/b3U1Cfx6350mThsUGHxSRoIhkMsTcXIwIEMzgJCqIHGoOOswoEIkmIEdWOQj5MEWUwIy3YAO0MAJcICu9IAc8IEZUDhCbRZXZJ7/H/jBJdTCiTzFKpzChaI6ipt6qts8zmMCHQw4z/d8aNO6E5QQ+9ZA0Rd9avsn0pOAGWaSRmftPlp/1FfAsfPM1m99cXM/9xsxtVdDOkRHPExD3OBAmZ19g6Q9Tnp5h033LKv7un+EUqercrLBVV9YgwAWtOj93gPEFIFTugyUcpDLFChQurBxyIZgly5cwDgcYkTJFDZv9AyiI+hQJEqeUK3KBQzYMWfSqFXLlu3atW3XqB2TVarODkNmbuQQ1QoPDxotaLCAQgeHFTt66pDJEeMOpEKQIH2CdIlVrWHDctlqtYqUqFGlSo0SdZYsKVKlUKl1q3bVKlOSytyQwUKL/xYvXrQ48WulihIeOmrMMHyYReIVLFacIDECMocRHChryGDBQgbNmDlr9uyZc+jQFUiTPnZs2bFgw3rlGmYLmK1ZtnL1khWrGDNav7ypiwcPF6RDb5TscHPcTZs2a9YoZ/6cufMvX7BgeT4dSxTtZtCgmf6lzfQsX9KURwOGC0U2Ydi3D1OQIPbq86t/ry4FDHuJAyUePFhRoi7C2OiN9QZ8ww024IDjDTrssIMOPAQxZBBDFpGkkkxGOWUVV2br5ZhmpJFmGmpiymabbbKh5paoqohBBUw4GYKDCzSIwAIZArlrhCbIcIoMqQqZChJKsNLFFtlk+eoUs87yxJOzRP8h66y23oJLrkjKwKEGGfLKyy8niFBCCSOGIOwwxFhQwYQTHCPBhMkki+yy0DbDrE7MMNgTA9Ewq+DP0iSQgJVU2GrFFE9OOaWSTTyhhKpPPonll2my+ca3eLj55BBB3jAjB+SSY+6L676bDrpTSaUuuyzM4O7UU9F41Qw2wLhVP4na03VA+ej7FYv04BMowIn8o2ghggZc7yE2uJCCizbcmIOOOax1EI+ODlkkkkowUXSVV2gbBjURTbzmJWtoUoaWO2LYARVOZjCCBg04qGGPOODwAgk38LgjKqqoghSSUmTZpatZXmHSSVGiLGXKKdN6y8pVWhHFkCp0EOrLL53/wKjMMwtLc4bE1mThTRNUjmzOyTSwzM/M9OQzZkADLS2TTDbpBJRONOlEkUEOgcSPOyiJhRlttEmHaXPiiYeZQg7JgwunkHNujVKzjhULVL/LetXqsnD11bHN/o5WM26laL+I3PNiwK1/1Y7uYJlYCIqB9J7iWCTyFtCh98JYm6Lj6HCwWmsf1PbCSjJU1ENbdNlFmGWcKVFda6yphhpqlnkFklc+uYGRQExgIYw44nDECzccl0pSSCWdSpZcEJ5F4a9McRJKKX0v5cqKV8lEj8CMMGKvjv2Cokwj0JyhsBtuiIF6k1W+3oQV4oRs5Zf9/IzPPmMOP3xLQNHEEvQt/zllkUhxYeaab8IxB5z5fUvnG1YKGQQPJaow7jhY09qqVLW1r2UtO9ohmxnGY7YGpi09wtpPsSSyhS6AwVfVoVvdsHA3vH3QIExgghT+tiyHCEQ9CsLDG+yABxfi4UGHW4rQuMUtSmBiFBZ7xStmcYvKPYNE1RAiNVgiDRHxohCRsAMLhhCIfSkCCoO4RCQ+wYpYpEJSWLyK7XRRC1ksTHejgBKUODHG3gFvYm6JSyXocIYyHE8Ne+ELmBYSMsLUAI84kN70YpCYE2BvBIzZ3giy1xg5wYwyG9AMn+4UGvLxSRWOeAQoSNEJUXziFceYBjfgMY95yEMd6xAlO8yhDv94PGNIgnCDFcjQg6stB2wEPKCvvJbAKCxQPGa7ZdpGeJCIDGtvXADWMKcjQhH6Rwq9RCYJleWeMPCNC2xIDoIcpAdrXvNBSxGEIKQ2tG5lQlFseYUsbgGiZjzjGZ2jxjTYGZNixAISfMgDHi5ChzRI4hKUoIU0ioELWtyGKqwYxi66+MVWMIyMnCij7ySWRricIhJzkIMcPqaGOHrhDBnVAt7sqAMd4ACk0queH1UmAhFwQAQkUOlKV+CCFTRGZX9UmQcUmQEMWOYzePqMZzYxCXx+IhW+iN/TPGkPe9yDHu4gRzvEYcpvpIIMeMgDmXrgyuRgzVSxKhV2tIqdsdH/qoFjUyB3XgWtZ0VkCn5byBPYyrcNbrA+rOrgMZdp1ggmhIK6gqY028AgBy3umnp4YbYEwQc/SC0SGOJEhkrBinHqIhjLEBFLWlINbnBjJsd4xSLmQIYdkMEPl7jEJ3jxDFzgghe+oEWRZDFQXdzii6yIiynC4gmFLpShZAHeW1YhCs5KtC8WjWNGMyqQOprpTB8N6fRMlhgTkMCklEkpdKWr0hOwQAZ3SYwKPEDTDHDgZTsVr2aokopfVCMdnrzHPfyxXnsU1R71uIdv4AGNO6RBDHAYwg5y0IM5YDVVXTXgqbpGqrF1Bw0ObALdaNUEJqSHCX5TiN/YejwjQEEK/2+FqwajsARjKpOu/pkgBZ/Jt4och0FvyEMe3vCGPeyhxW94YR70YAY51KEOUuNWSCjBicaOcxe+sFwQrXFZFcVkGbL4RCFyAIlCIU0Z/qQFLVJBiU/kwhi9KOgrZCuX2t42SrndLW8zYQgIzYEvwhVucY1LpuPxYDAg1eMNmtsY6KqUMnnWs3QJ2RgV/Lm7HqjMy8KbyA3UNAPJqMY3OmkPeuzjHe/Ixz/88V5PzsMe8ZgHPOBBixy0IcJXcEqoYHmdAKNKlltFNXW+4J0vZIFuC9ZOE2jdhCMcZAhI0LVaK3w8JGSYbksQdt2CzQQlGNvYR1CCspF9BYLsTVkSuf/VrdYABzaoocUWzcMe5rlib+sBwXUwrNT4wIeQXMLHrCDnLoyxDJZc47KYhQlNpGEMSdEiFrhIRjF+cdpYSEqgWdaFLBQm27bwDrcN1e2V2FIJQwhCD3TgyxvUrIaMwqeOzYvzDHBgmOya7I8iGAGcHsPnk1IGMikPdKD3DF57JZIDG9DABjAd36P6A+c5rwc71MGOS6eD09SABBnSYLjEjao5yynwclBVarmymlTz4RqHNyzCIzDBuFCQ8BOORxAmdE07XbPlr65ghbIrwexpv4IZunAGvUkkPQex1a0c4gZrUwuwgdXDNgchtCEdAvA1FAkmwFmKVbBC3eUM0Yj/zoUuFNE7yviOhSxo4c9UVOUVyEBGMG4xi9iu4hRqEQUn0DIKUiyKLCWJy+rjIopJPLwPEcc2xS3qhS1YcMK7BgIQnmeY5pKUkCmXU8sPXfwNrFzQLucAZ/KcAcu8LB/+yAc9qE/99t6jHvWQB889GY90XEMatyC6HKxV/v+WelXN2Zr65RZX+0jdV2GfT4eXEIVkivCDa2VrW48QhewsoTrqb8OyAO0AwwoO0ArSxo3KoAzebiIuaCIG50DYAO+WQu/2ThCEZhCGRGoMwRAQYREWgREmwVtIjy3UbRYgCzVWghrUBV06JyaqYRqY4RdiId9w4YpeQReMQRh2wYu4/wwVykIsekcsgOcUdAsVknBRTiEJe+v1BiH26EAOsi2Obk8LCmIhdk3Xdm9kSsb3nOt6hG8EDk3PjO/QaOoMk6/l9IzQNIAd3pAd1uEc2qEd9iEftO9pfkNTvuEafmG1coD8kOMNrEWASAU6Yqn9uoo+5EM7hI0+6O/qjEnX8GYS9w8JgOAIhE0TM1ETN6gAEdAMEJABEdAK+iJMrtCCLMgLru3ahKvFtu3FVmwPAqHvKMQDPRAREOEDP5ARHoEEMUFGRAEVWoGHbEHxzMVEhEiI1AUbrGEaoIEZmKEZlEEYeEEYeuEW8I0VgrAsPMEsRkGMvFEtIIYtgtAtdMsTJv8BEQYB4vRgDlhMuGxvC95DIbROC7mQZJoLkMSQH4UvDbtr+NbQ5V5m+9hh+8hBHMThDenrG6wBGqAhGZ6BGd7JKebgOB5CDviK6Q7oEBNxluTqEelPABtxE5ngCI5g1/KvwpBgCDLxJIXtJF9SE5fgE0nRJhEwTPwiL27v9rxAzXzSFWHxxQKBFvuuQnBxEXJRFy2EESLhESQhsS7BG4dxh8iJF4yhGVYiiJRRcxwvG6bhGZLBGnkhG2NhG9nCE8ApHMfILKAk9SBmHMmip3QRCiMuFmlvL9gj6+4RCPAoTX4Pe1amH/tx5VhGIAcNH9qhHERJHRoT6PjwGfqNFpj/QSJX4hNy4AbawCGAEtvYwNSoI9Xer4AyaIOWgBNhMiaFrSVPMiUpUdcujBNTcwmGYDVPkjaVIOPIhEzyph51UieJqwwOsAzOAA0yCsHQYKIq0Jr4bpu46RZz8RY/MASnk1sq4RLAKQkdi5x6od2eARrYaRq4UhmhQRl+gReCYRduoRaAkCxs67Y+4ZLAsS3RwrbCbEoyIRJykR31wA5eDMbUbD3aRuvsER//crtUgAUCMzAHU+U8wDAPkzLcoR3WgeeY5hu84Rpo0BcqZxnUiRqGgQxi4AbYQ4580lYOETQFTD4+klXeyjRjkzZp0zZjchIHVOt2jwigwCVjMhNj/9RHh0A3g3Q3FaJM4KwKjtQKhjM4EfAMzKBJnxTB5ABxWmib9ocDC8EQDiFLH25LAQ/w+GBCuCUS0E0qf2zdfCE32EkZr0EGybMYfIEXeGHLztIt0vITyOJOwbGhHMYTyIITRKsSIiEp2TH2/DMP1KxA6HHCCLRAv7C52IRNFFQwCTPlIFTPOA0e0oEb2BQ8z2lERmQbOicaMuHPVIBES3RwVIXVuur94M8+OmyDZPMIhmD3frQltVD3dg8IkIBHY5RHZ5U2gWAIjtR/jjQwqgAwBsOjdJMUqyAUnzUBX2VWuoP86mAO6kAPyu1KtxXwDusQhsQPwlUO7qAOvLVIpv9iTO/UsWpBF4pBGYAoPKthc6SBGY7BF27htWILFRxGjBxGUiSFjDLhtjKBEgq2YIUDEgKVERaBUPXAUGlv9t4DC/1mC3XVL9XEeiRVYxlUDAXyG7jBIZMhGZSBGd4ViIhoRKIhGnLBFXaAuzKgPeDGghqCVbRm1Vb1VeUvrv7P/7JjVmOSVoU1WH1U9y5RV3X1R3W1V31USHWTWJWVBwJDCZqgwWqt1tJGWm8Mx8TNsA6rEMKVW702XIvmDiZqXO/AW8t1SIrkE1BhXblTRKaBJqbBiIxBTmuh4FDBtjIBE0LQx9LSE0SrYCVBEqQCYEYtB8igDhSWYfugUB+2xRj/JEAXlVG5sAtLBjA1VkE5tlIrNc88xxiOQRnOyUSOjIiQIWFcARPm4AwAoziJE8HAIDQNKKuwo/7kqmcfESZp0zR9lVYj8WcvEVd3jSThatii4CSvAEjJ5Gmph3qm5wZwgE0ONDEg48+st1Sz13n5qCdyIHE/60d+pAda6Ue813t7gL8S1wxa6QZ2wEfI4A6I5E5TId/QdN+UoRhuIRUMhWAi4RDoIAOywA0cgAGaoA4OIccEZm2NRLT+dRhXARMmYWERoR39k9tor0ACdGIrtwZ67/fAUFJTLgyFb4RR7kEh4xiQQSsbb0WcgRheYRQ6YRPiIqLQoAp4IKOkFcHc/89mcZbVskODxG7+iA0SZRRYW9JXZ1VYhXd4kQA1U7MRX3JWBQPOqBjOPErOPMowOriDgQB6thh6+nIG6AwHeA8IeAAHjnQHdMBZbRh9jZW/qIe7AM0D9iQDuuvQ9iSP90QFYiAH4pcSUsGKbsEX/O0TDlZIegwT0mAODiEN+OAqeCgbaQFfeaEXeiEYisFdj0EYjkEXUCGCJ1gQHNeC4XH2NLgeK3cGPPiDNXdzxXCQOBedGo8aogF1YUEVNEGXE0EVYKET6ABZkTVtjlP+BkgReTaDbKk0X/RnN/Elb5Uvj3b3WLI2T5LWgPUIaA3tkHRJzYCNEXCiXjejykANWP+3OAGDTKygC4zACabACYBABualBpSgC9CADc7Af5SgB9p3zjwgAxTp+DZgTyTAARyAoAnYAQ5AoRXaoPk4SAS5ftH0tHDBF4IsGOKUF3YBk4MBRISh3ZRBGURWpPctN0TaF3xBF0rhEiQ4F0fZYS042yR3V3iTUVeZSxw1c9tEpkKYcxlUnUYEdVHCFUDhfEDBEhqhZ/rgDOSgDD7qVaK1O8Agd7+GVanD/1p1iEXyiWfyV1GyiXF1CJB3NWO0CZJ2CKwgnUfxALnDbOUADViXuNSgOIMZjaMXrWvgg9fEA1Rgj2AkBjwARroLAxxAj1VAkfqYej4LDe7gW6ditNb/tRbKqd2WgWSbIRpLFqRFNrPvV5N/gd/2TaR/4RdEmmST4bJHVhhKgRIEVRdd2oIvWA0WJFHfg6Z1r4Pv6Atxuk1Qxk14uqf5kQNUdhgUppJIQRVAwRVcIX2OGhQcQQ22oAx4ADBCMQHvapiuu2tWNJnnYya5Oja72iS7+uqUeAgMAxOBVWiDdve4t6rQd4+WawduoI9FinqOL9BsqqYwQAIqwL4xoAIkAAP4+nnH1w+4JZ8u4VBkQRZqYRe2IoWRoRmyshkkyxkqvMJBmmTRScMvmxlEusNDWmQ73LRLlhke8hmhYRmxQcW9IR287xu+gRpSYRIegREQgRAIIfYC/yEW5ylyGWSm61H3dOBMQIpkMPf3Xqq3X/m3PdcWVqETLKETMIGoQQEWlLsRGiF9HGEPpsAL0lkJqNsK7oo0c5eHoy67W1XDSHIkN+hYnuUgjAlohdVk1MQwVGAEAE17YcSww6cCMKCOCZqgGcCgC7qhz1AFemBrD6HHRqsUXqEWcmFyHtzCVTYapKHSP5UatPJTR0TDH9LTLxsaozHURd3T2UlzVFwbvMEbvoFp8nAeNM2ojKqo3Os3qiEVIqHGbxzH9UDHvW2F3kC2f3xAt5A2sbjIjdxkXqoxdnofY5ljKeNndFkVLCF9QCGSCAEQzEcTnHsLvMAJyAQHQvEKrv9gP4BNw4L4zLNb6oYpzekvJIUtIfLGJGuzL2vAi1kACFjAekfApu6c3/eENPb7vwdlUARdAu7Yj8kADRQebZPoToNQ3WpBcrjzNEIkwi8+KytcGp7BGYCI4zUcnT4Vnb7zxMGz1MNTc4QIG7ShG7pB1Vm81S9N5uHLqNbL5u/h5vZhH66vH/SB0uwBHqbh1nP9xvvAUFfMhYC9xXbFuNTqEi9CWYm8yOsMyWWK2RcUlvvRqHU5fZRbEyLJEgABufcAENiKL4wAB77c7MadC8adTDZIrDoMWtAjgmAtCsQjCrggC/Rel96K1qLgmpV4BkKGVtXEzlPu+PSbfAQaA+z/m68TV9ySCN0MT1xy4SS2whggfBlUOBosx8KdQcJBfsMvG50ok8NL3NNTP16tQcVXftVZXdNm/qhinfaP6uZvn71yzh/+gfd7H+f+Qed7Xx/0QefvIR6g4RNw3cYNgRAgbsfnyYVSDG68AOOcfveMgAdE5jAu18iVHaZ0emMJaXsmNeWOWxWOGxZgQROsPZfXH32CYDFkYHrm23lFdI/un49+z3mzN3uRL9AODSAyZNiwIQMGDBUkVEjowIGEhhAdYJBwEMMGFTl2kKlTCBIlTqVQsXr1SlatW7l09eoFbJjLY8iOyZxpzFgwYTiD6Szmq2fPX7+KAR2arGhRZkih/ymdNq1aNWvYsGnr5i2dVavxsmaVN6/rPHv26smTV68evrNn353Nl48evXz+/NGLSxfuv7t48ebLm3ef33XpcEGKxAgRIkODBCkWlKcxHjxv3qjxMtnLlCdTLhshwnmzkRqgZcgAXUO0DBaoUcdgoUIFaxOwY8uGPaK27REecHPwoAqUqt6/QYHSpAlUJ1OWFJW+EaN5DBzOo0t3fsN16xgqnLfe7sHD9uYqPGzw3rp7+Rg3yKi/U8hPR0qXPoUcWXLWLV278q/UKWxYf50ACgNggMII9ctPQQ2lIFBGMaMUNEw5BZVU3njzzTdWmaPOhhvGM1Y97LBDllhkjfghif9loUjPPmex2KJfLNbF1ox73bXPPzfukw8+fv3jj4034rjPOt/QMtgihyG2WGOOQRaZGlB64cUWVGrGGWdBkFbaaFuetoJq4G2nwmyy3VabCbh1p+ZvbMLSm3DDgeIKKITgcAMOOdywww189tlnnsxhlx12YV5HXQ4Z7YAGGnXoUcghkXw030iyyDJLLbbkkpJKu9wkoIDB7DegLwAWY6qpPeGi6oILGnWUg0tJGJU23oCDYTrmpMNhiCOCOJY8br3lTrD0vFMsPu+olRY+9KRoIllgRbsjWtTCxdZbbcGYo18t8ugtjz4CCSQ72sRyZJKK6cEYk05KFqWUVG5hZRD/9NKrJZempcZCdK2ZMCaZaJo5AmzhqckbKG7GKRxxlsDiiiNqWLFDFVXsoBEZiGac6MTqMXqHH34cAokkl4BUSiso14epprsA47JLLgUIIC+89AJqT6j69NOppibDoKuvwgqhU09JRVWF3oSDK64aruP0006H2M7U7bhj9dVTu/OO1sl2bSxaLHZNLT40lg1XXNdq6yI+dPnDltvVTjs2tTf+KCRe+LBjTSqFRIKkIUrqwWSTT74Lr7xTbFZvvVqGJpq+/I75L8AB20awwR4UB8twjcTZuSauwGKJF3TwUcgiiwx2ySWZeBJSKyTNYkumubj8skvIxBTTTLzXVNOp/zWByrMvPPcMNFJCQ9hU0UZ3Aw444Zij4YnRgpViWWHZk0899LQjNlpUe/1OOyGK+CE75FcdbNXA0sOsW2zdNWO3PHJbv/1kn00jXWDdc8+MbVNbj+7GD7j4xW70UEc1PtE3RvwtMYNzTGQmaLh4zWtxQaCBBjX4ghc8Dkza8RflRggbg1mCOJ1zEwob8blEuKJ2LckdMpaBjGY444bOiEY0cMhDZ9iwGT8EojKGSERlMGOIRSkG0IyYlKUszxrXwEY3qHIVrWzFK/O4R9u2KMB9bDEufMGLAHFExhzhKFhXAxawuKc9uECrjW2Bn9vgV78XgU1b+Tub2/YYl/7Zw/9/97Ae97inRnoAy2r0QGSy6CKPcECDgYR54LoG167CSckymXnCExSHpXptkIP52he/RBibgZEwNgaLQxwAkYhGaIKFrUxEIlQZB1AQIxq54yEQn9HDXt6wGc8IpjCD6cQIyUobyEQmNy6Ujnhg8ZlfCaQ0/6jFavpDi/6AERj5MsYwihFGYfxRNsfpxS6Sk5wH3KL8apQXHvmDbPA8pxf1h7ZrzShY8ggRh9Qxjn7685/lCKg6ykE1bMrDG8ygRAMVoQhCDCKCeXjMBCNzSXhdZpOcJAIGN9gl0cwgUM1hzWtOKRvMeaARibDELMeA0leuMg5JiAMcXHHLXwIRecj/AyIQbeqMZ1zjGtnIhjaW+Q14wEMr0EyqV/rnvy/GxZp0Kec4t9hUdfbFm1fli1MDOEYzmtFHVvWm2/zHVGpWryzdo1pA11oOcbhVHP+M6z85tI6psUMd7HBHiAB5UGVAom8MbehDIyjRib6hohbV5GautDiOdvSj0REpC0gqm/JsR5aqaEQcWAgKlG42DlQAxBjUYAhS2EIXx/iphKxhjWlkgxnPCCIwfVrUdBw1K1fR1YbWMZYQxcMcU5zKVMxhPmDpsY+BFGQ9rFlNQCbXHl2pHlnheFx12s1FNrrf2sbWRbUJyYtb5d9Z86lPDvlTHGwNaDugttb1Qs1pWbsa/9feQb16RGse8EiGQiXBCMEOtkl2oMMc3sCGCU6JSlPSpCY1isEMfpIGpjmNdLZD2cqaIJWA6KwmVMFKKgiBpYBIwhjGIIM95GEQh7iFUY0aD3iEw6jcmEYwdbqMYFrjGy125jx0S9d2uOVX4ZiikMGBV3vIhWxeBCtZnyvIP/rRrNHiSjQBGd4vAilIOKJbd7HsTfslkmpqFSg/5RrXfdbVaecoBznWcY71uhe+YNaafOV7lrA4yyvq+MYvIHGIR/R3EICmJB4CPIcBG/jAU7qoghnsyQdHeAYTtk6FCVaw7rCylcVJRIiFAFMbjAG0gbAEHNjABxXDAxvegAdewf9h229QA4jLEGIymIENeOhqHvHgsTrq6uNm2YMd4BDyFMPBjrf8Yy1fZcsgg4Xc5MqNu2bMH1anrdXw5iNaZentPv8JjnF0+9v+3OeGyCzucpv7aeXLq7rJ545fkTdE0gtHOKD3vHioI9jWMFKfGerQSUb0MQGmQ2QKfLh4UUnBT9iogzX4aJAKaqSzIQHluNOdJCSCCiPuHBXiUIRZfngMrIzDD/JwCGN8gxvQSMY4NgQOeGzjGdTwYTOOYYxlFAUa2Ggmbula12HRAyzAFnY3xsG9GnH5H+ykEVjh8j/tsUhtd9TWjKhd7bbJo93pawc/pWeOfspb3lyXnjrIoeb/tr6VHOQYuzrgiva2u73t54g7m9+7jl2Xt9zx/rrzhC5kbczK7/YOsjXMRYhHOIKhgcZDkwZNBzrAgcAUPbDBFbyFJzC60RA2DWSdg5p+yeYEJpA4wMQUnk/PcrOg+OwYihCH04PWBnCIhDRs7Q1tHFUdVnmGSi41DGPQXInJgIY3co17nquPHoFUhzeEro7+gbFt9+BHlu9YLbZtV8vZ7OLYwAxm9I6ZzGXeZ9g1tM92oMN76Dc/Os5xfnTUFR3n5376p+Z+deRd3uBYPt+T6feoSIX/yRRcyNQNyGQVtVcNsbAIg/AIj8Bv//VvjOd4kEdgiJVgmnRwl0cvGtQl/5sXUp03G6BHAiJIJqSnAoCgWY0wBkkACDClSioIWpxGBZ5mCMhwVOmAY+YADvHwDc3wCp5QCKUADMjgDMbACwUSfN2QFcZnNU9VD+PAd+zwR9t0F0/1TnNzP/WkXSwSR27hDlMTUODwVuLwPGEIV+MghuQmVxtiDuLAhm5IfhxCDhrCfvLnheiDPnQ3dmxIhsHGd34IgADof4IoiPz3f35ngNqAgJGgCAwYWA6VB4yhBwDXeHDweIcmJZVReU+AgQ2WQaQhAx8FUvqCGp93AqZIJp23HYCgCUKQCEIgYq3nikkgBEWwcTbQASkwBnIgC9zAYunQDVbxDdswC4+wCP+ZMAqmIIQrcYTT8A1mVlfJAl5Bp3/O4w7Z513hQkbTdy2GlE9Os1ZuxYfiGIZkKIZvFW4bcnbmlnZtR3d0d4fls4beBg7mMG/5J2TUKIDBRYDCBoiB6H/9N4gCaYiAaIDYMA2pgAh70IgOqBh5oAeSaAcSWYkTVVGZeHBUkoEa+ImhyCerMYqTZQKmaIorMJIjmYqtIYMlYANxMAZUkAS+0QiAsHFxIAQXQAIwYAOPkAm8cA3bkA0YcnLUEA2q4AiEYAidcAmt4DIrYQxGVA1WsVtTE4040g59OBVhaED2szbXsjXjE1DzOI5kGJbdJlfmKIZpt47ikHZ1x3Pplm7/bRlvZPiH/YdMhmg0ACh0AeiHAuiPARmQszKQP4UN13BjJ5cN0pCQfTAJDdiQiQGRgzaRj2eJkXdJlXeZlcdY9nIvM4ADHzUDIDmKJmmSK1CSrCE5RZACIgYIHyYEgCBaiZCTMmgDmkYFe7AJrTALzYCYQOUMtQMKjuAIjPBCp9AKxJBLz8AU2qBb7JAPawMj9yAPW5Ei2MSNbpE1dXWHTmNuG5JXVHNmcYY13vM970MsJeJu8cgh9zdvSIM0R9Oe7Xkh8jmfzJQOX6c0V0Gft3KD+tmf8gmf3sANAiqgQ8UNQXWg2bANP0UNy8AKlxAJjNmQkMguEmkHlUiRh1WB//FiBByqOPQCBKQxAyI6A13CAi7AAl+SoihqiiRgkqJnkqRUBDHVcXFgA0IgBDAwBjjqSjBASyO2YckYc84wDLbgCqqgCYBACJagCq5ACqMwC8cpcxHSTHiVTWNDD3f1luUDNSGyDl0Kl15qPsUlNeqmV2Z6dWhKIu5mInc1bkHWj365lwAIoHwXn/ppIcE4n3mqp/zpnxcioPI5oNvwk9lQmE7BFMF0RMkgFL6gDDzBC7VQCpQwCRGKeBDEJAFnoRd6iZZZJVAABUiABEAwqqQKGiO6JSbqAqqqqqXZqiU5mrAqG41wox/WCEVgA0VQBLQIk41gA74aU6inCrBgC/8tcZykAAon6AqWYAp+FgqbYArDIKXVAA3VQGTq4A5Cgg9eWA499p3y517nAGdVYzVayitiIRZvmU/7ZJ/5l4/JNJCECK9+SZDJNKD2yg0WciEVgq/4ijR+Op9E9aeCGlSFSQ3TIA3PoKiMSjO4cAu3QAsOG7ERGwy7oAu2MAuiUAmPwJiHJ1gO6RgVeqGUmaFTInmZMQWgKqqkWqoiWgMvsKow6wKuOrNfkhowGhuueKN/0AhJ8Ac1yUo3Oos12oostKQOoynAYAuZZgnISgiMYAmbQAiTIITRgLDTCg3WoA7AYiNfya0cAld1l3Zadw7qQLZPMzXveHf2pzT4557/fSkV8Bq3cju3fxen/niveIu3hEqw1lANTAENCauoPuMLqqIqEnu4h1sLJ3G4vbALuXCxodCAHOuY6yKJj5EHm1qRFVUlmfGpoSqqoTqqNdCyNPCyMSuzNNuqoUmKsHF6VPCSHceaukqrrZSrgPAHrcS0TGqkjuBZKTUGsEAMluAIsGAKhoAKzSAN1OC3TtENK+ItW4O2W4pX7FB3ddel6mmPfNh3dkm33hu3/zi3QcV/CCpU5KsNCIq+B/pT7Nu3TIGoCasMi/oLvFC49nu/DksLEOuwtaC/JqG4mDI7s6MpmjI7Dtu4jwsLoWAJG+tnDgholRuZmFuJeaC58JJo/52bsp+rsqNbA1lSoqhxGqNYmqs7iiYAA0ngYX8wi6snBBsno7RZi1TQca6kCbCgCYjgCLOUkzJJHLngCmPQMIhQBTnwCdSwTPZJXNR0D2WhtvVon+zZj/7HWlRcxVZ8xawVRYVZmFkMRQLJWgIZVABZiAKJTOV7xoXavn17qNOgFPErv4vKqPc7xw2bv/oLsXd8x5ViKbMwC5XSxwDcx4AMwAF8Withsa/QCRrLmP1lqZcakXYwwXBQwRYsJVPQBV2Ashr8uaLbOBHGAp+cGqpawqMoBJ7WwmPAkixYu6bsaR/GpMIBC40QBK3co6qQCA4DrEXgBTRQBXdwB7SwDf/wEKAVwn+sRTREc8zIvMzLXMXs+xRUrMZY3MXKPM0TEhXsm81cjA3ZQJiEmcWGSjTv28ZujDxGsSB0TMe3UMd53M60IAvvHM+VQhKxUCmxcM/4vMd7PAu0EMh7rAu6cAu18AqbMAmMwMiNDGgQvC6Xe6GUzKnygsmdu8Gh28k1sEERltGkXMI6GlON8AcqeKRjgKRxAAuJMLuJ8BsoZco1aQNJ4GmvNEuz9Jo24ASM0Aq1YAwIqwzxqxQOglNuTEwPMs7jLM7QjMxYDM1XrNTKnMzJXMVInc1r7Ld/Cw3IA8fzmyBBURRGZBQGMhSESzMMy7CFG7FlHbH6q7j+q8//80wSbu3WrEAfb/0K9czWlQLQtzALrfCgB83ID7zQDyk4E9wYlYw4J+u5G7yyoMFRj5PRIvxBG80Cf1AEPtBxY5AIIKdpgMB6qfe6KaVSLxUHrySTJ9h6tDTTY0AIqzALvVBjCTtM0oCwsT3bzxDbRL081JDby3vMVqzNvv1TaHzGQJXGQNW+TmGwBztjzYDVpnIgvnAgzs0qQqFEQ4QUSFQUQXEqPrESvRAMPqETOuMLDIsf5A3QFXsfEgvAAq3WaU3I7g3AtgDAAD07rqDIj1AJlepQg9Bv6dLQk4yhmkslmJzJiJ2ypbrYG2gaHSXCJQyKo2ijM/yaLjibrceS/6ClSiK2cTE4S6GlSqrAcWMAAilwq4gwrDXXU8NU27Gt4rM920St27Ot27nNvNDMxb9946pVDciNsLFFRHGcMzTTC2I95OFd5N9dPMmgDLvkqEnEM6AyIOBd5EOeH/kB0FaO3hGr3gAMz//73oQswJlSsY/rg/iN340pWPwtCJIYQQB+aJybwZ9q4BbN2I4TyqvrUaV8ozoKWrpak4mQC5ogo6rkCIGQBIZeBCP2krTIaa2oSimQAigcxLDA2sbgDNKAPDMWTC3O47AtDQfr6S3+vrl9sNMg47pN6rGNQ7C2DDJhDDnRE9w95Lwg3rLO3bYeKmLN3d89IDkhDDOh5P897ipO7imhAiDh7d09QdZUfuVYzr9eXguXIsjQHsjSvjIVOzutkAmLbNCN7FD6/bFMsgfiblgka8mHHecafOAOdi92DtmpEUqpYco5mcow/IqZVQQwQItMuwU12ZKpDAMwkNIjpmkwGAKuSQimcCm+F0Qp3vAOz+KbzuMytwwUT/Gt/uq+YOv6YescvwscvxJU3rgbD/IeL+S9kPGkEirdzR844XvC4HvKcAzA/gw+vqjHYCq9LipRTio+Ida4oAs0U7EB7bBD7+zvLchIn/RJr7i68LizsAqYsO0OjOaAPTjivgfkfsFekMkZPNEVDaKexO6PNgMaHcLwPgM3qqv/NpCTbB/wiaCaMKkJNclhNoqjL4lSgOAIr3TZPpsITusKs/PyQxhrFd8MFX/4hc/qMb/4v8cTtM4LQo/XVj75lG/lu1Azsf7xmt/dHJ/xNEMqwtATngIqLV8TMoH4sWb4NF9EMi8TxeDqApLyOfHxYk3lVY7XRq/W0K70vC/tvi87DqvX2k6pkxBJiABogLMkECXJFMkGYYDJYfD8XY+ynDyqGNQ4oTGi2r/9258aLj0GAK/hLWlxvcpCOzvapiyDRfAHNgAIgP9Kr9kbKU0ImxDftaASx+AMFl8T+18TuF77AKFLoK5btwgWRFiw1sJathraghgR4sCDBile1LVL/+MuXh179Qr2sePIjr6CCeNlUthKlsaMHTu2rFkzmTOdSXNWTBmzZz2fzVymTOgxYyuDnTT68WTIjrsyOnWakGEtWrVmXcWadZYsrluvcpWVtaCtWasyVZqENhKjRYgGDTI0SNDcPHXt5oGTV+8bNmG6/A3jdwoUwlOQHD4MBEiQGkEc14AcGfIMypUtX67MggWMOIBsaGqkStWYIkJsCBESB9QYG2MAoS5twweM1LBcxUkSJ06iRrb7ULKlq9dLZMiGDQuJtFdTjRgpJkxI0NYth9UlQpxa65b24NNz6Zo+veBAhLg4kkQ/0tf6pSuLuYxZ05lMZ/WlPdvZ835Pmv9BlcF8z6ijjupFGJd6aS4jinKJKLuswOoKQrC26gqrh8gyq5JH1GLLkLjimkuQu/YgUS8T+forxSkGIwwKxJBQbLHGHpOsBsxuvFEGGVATApRGxoAFlCKoGKMRIWCgIpE/UisiN9RgsIGK3MYgLQlAGklEiEQA2eMMWI4rzhnjVnJJmI/M/OgjpwZi8DvwbMmFwTeva5AhibLDMzvoysMFl476RG+9lI4yqqWXlpFvpmZ+WpQaR3tihplmmEH0v2IuLYYlTU86UCNeEhSIQQe1+mpCCiUMy8KFtpNllU0seWSSSRhhBBFEPpSLrjz22LUuE03s6y8oVlzRxcNcNGL/scUcC4KGGm3EMdrKdqRNiDE6Y82GODQpgrM4/gCFCh98GMOHFIjELQkbkuhRkzhOew1KNVxBpr5o5qPpGGSWKa6oAUP6CBhgLoJqI6iecg6jON0UaKOndkkz4uUkTnMkpQhEykB/MTUmmWSUuVQoZZJphppspvH4l2LQ67NlXPa8hZaCaKEFrO1qQVWWV2LZ+RWffwa6551jIVpoCH95mZZSLnEkEEtmZUQRQt4iZOpB+sA6ELt+zcsNN9gAI+wVuxgMCSKMONuIJ4hgllka3pYMM80uu2GGG+7G+wYYUkjh2jGS0MQGG7q1ARB1qYgDNXF90GSMRBKZbTYbVLGl/7NG4ugWyj1cqa++ZuLb17jjKO4FmDSb2whBhxVc0zlQW3/4YYl5If3iXny5eEBNyxQGU999F+qZbIb3uJhk3ltP0ORZ9lPmmGmGnmZZiKa+eutZiQV7olnR3vpYaPHTeGaqqcaaaWK5hBGnJ3mE1qqntloQrPu4Sy83uv46bDD+InaKJ54wgtrW1jbHvI0xkZEWZfKGtxg0sAR7E0ISiqSJFMDAM+sqXByqlQQYcIZKVGgSuwChCkcAwhWP000KhEADJ1yiXs4gCkxg0q+VSGwpp4NK6XrBpjgNbGAMo0jqVNcwg1WMdikxyVGSl8RgJI9QJ8kUSzL1u0ulDGQ6Uf+GNLjBjW9MgxlCeY9LfOeLYvziF8vryC36xKfocSUW08se9+SYilRQD3q4+EUymAENaEyjGtjQhje88Y1vpCMe85hHPLgRC0osYhGyekT73veWt8gPa/XrGhy8xgawgYEL/CMWAAP4P7YR8G3OQmACF3i3BsbggU2aHCzUlYRE2KAERfibtrRlGhvAwDVCSBK7OoO4ROymEX+YkhqqEIlcROMlh5qhS4qiKZYATHWlE1g2gdFDgS0siAp6WHM+lTqIcSRNShTGgJw4xd71joq+k6HH5Omx4ElDGkJxFDWaYSkA/c6MZTTjGX3BC5fhAnwFxaMZP7bHPpIPG9jgxiD/CZkOiqYDHvAwR0Y1qo523KMeimTkIQSBlvYxYpJvCYQl9YBJTXotf578ZLEIg7YAEmGABGwWKlN5mcnYbZV4O1K1fsTLXmbwM7mIQyOu9DdNJGIMoHBEMXWjrc4ktRGgSIEN9tAJOzDCFcN4pjFkIkOXHAes1YyYNrMpnB1SrGAGg2tcyakRpSznX+p0TzupKM2ihFGM87RnLD5RM1vs4hXLcEZRZDgyehZvnvKMFB+n4UdrPLQbg6SoOuKx2UMmsh7zqIc82DFadZTWtKct7TrW0Y52+MMe81hkIweBFlpJjWqECEQg5rfSreHva2DjQnCJZSwipK24pTSlTnvK/9Ma4MC5OPip3qCEGhs0ohFZNQ0vG0EMYqjhb4AoTeKo4C5HeEGDGRyvVW3Qgi00Tg1nyAQwjIOMYwjjczAxhlmniaY0CUyHtVOTXDkS13Eyh67XxJju0pkxY7zHwZdqMISLcYwJf0wozLhUTyZ8E2Ts4ha8CIY8dxJZyVIWkBG9aIo3i0h7tNjFLb6HPWI843vU2MY3rvGL2bEOdZCDHOcghzjuEY90WIMVlFBEHp5WW6tVLRB7mB/9fGU/TXYyuFwY1ooOE8CaFhenOX1WZaAFGehG925Qok0tscTBwhlpDMCIhiokSJpGaEIIr6GCKmARhzEcKalXAoThOngazP/ZQAeMsIVxxAofopApv8cxXTZrB7EAHyx2FElPeiiGlPZQ03cRfieFfSfikX2xGIvCzy92Mg1rWEMb3egGONKh2XnI47MvfvGMXYxIXvP6tb+eB65bvNnSpiMc4QAHOLwBa2YzOx3f4Mb5MPGI9bXPtoNwMpSxxqspm+ilwZVC/5CltuMit21w2ykCn1vmG6yb3YPO7uBMQ5vGUQEUmgiE3+oMCNIUARC2UAUg4kAFGySCGI1TzRhSUAIhDIngWtBBH75anGW8hChFKatZBTYM0yEnYtYc4ltBhelMkwQkCnbPO6l4POOJOFIMnSz5Wj28akyDj9CohjbSwWIZ47j/xv64B9DzcY+h58MfRz/6PXrNa87GQx0VrSiyk01IQgrS6t+weta9AY9vbMMZr7jEIwjxNGtPLRBO1m0fSFQ/vOAvbFyQghQEwyIjBGGAXsYpupcrGXdDt+/QDSq8O8gj1FxQqZxJRBKocCQt+ajOhdeECDVhiXf1OTVS4hIhXEEMMYkJKMegSb2KM3pk6CIXe6KZdqIDM9XDrE+6GEnLRhJQ2tN+niT2Y/kA6Y3MmpYdtn6tPJoeD3kE++dIB3qMXaxrj9ZDxqHdcbGhTnXqV//q3tCGNrbIjex3n/vaz8Y2tjG8azyDF6zgBCUmseSoNZkQJNo2t3t7v9++nQsy/3UR29CGd7y3LW6Yea67CUC8KTPGM40h8TcoGZwi6CUYKILScMDFOxLBuRZQAIUr4TPBMQ2lIpJeGoM/WBJAUANCgAXOo7j4uC/6yq9jOI7naBipgB6uiJ7UowqaKQiEKqiAgiyYKx9XezVvCAdDGr6m6zl/yIcjxAekO8J6YMImrAd6cAfWKgceU4dxMIcgPLZjS7ZkQzap20Lrkyjq84aIsr4tqr7tQ0Pxy4ZroIZnEIZaYAVPuIRIILv2G4Szez9tU7u76DY44KS3CzcWmSnjQi7kOqX/s4x2+zt2K0BrsTwK7JvEGTTBOY1G8IHWSJwFFIIluRYo0Q0iuUAsOf8NHwBBIgk0RtgEYNAvZFAskNAYMkkYhbgZhki9GZzBllEoPZIshwKkQqIoeIgHYNwsW2PCG/s9J2RCe2DC0RqtcjCtcdjCaIzGWFM2ZdO6Zlu2rOOGbsi+axwkrQPHLdKG4UFDblBDc1RDNpSGz9EFWYhDSmCEOpSa3MKtJ5sfbssLX7mfKvMkKWCCFmkRLtu/vDvEnaKMGhDAv0tI6BKvCaTE3eCgIkg8waGlRuigP6gq09AN06AlCzSSRAicLXmSCBoDxNENS2gFW1BFszor/koTtnJFYfAFHCwoX1AZXewjP3ooQaK6ihJGYiM2zWq60WoHdijKdliHc4g+cRj/B3HgQmmESmkUJFizOqpcNm7UBqzrhu/rvq7sPljrvofyyu4bnrIsy2tASzakBnuSBmh4hi8yhmDwMF2wildAhbOgQ1mxQzzMrXvsQ2CBKX8UxJnisv5zm4I0SJ/CgR1gzHVTxOf6mw/qs9YQgqsChPHqMwn6g8Wjkj5LnCtJhCbRBB8pJlp6QNRIAonss9XMDVB4BEugnGziuO9oq9k8E3daKIZqqJy7LIsaQp6zB3kQziYUTtQyLXMYBy0Eh2ajSubExua8rKjMOnDAuqu0SmusSrAcS68EpHE0yzUkn8myuZ8wtWKYSYSoGe8pmp/Bilc4BUxgn6eZFdviy7Pb/7be8jbggjsmGEyzIcQvYxbJAIIaUUTGbMy+u5uSzK4kYJcFRJwi6IxNxBw+sxIYSARY8Iwi4bOmKkkkAQTeWDynEriGi6DL1I0g8AJLyAVtYpCImIVcGAb6WoZnsAYuAsal87Vg01Fcu7F6YIfS0qgrrMZkc84ibbZXK1JwHFJwZFJwZLar7MqHwgZrCM/JcssvSgYzahnoUU9WoKNUkKMwZQWgCdP2fM9ZsQSSar/3wS1CmB/8xB/9FEwWOYzi6jIApREBVQwdeC4DZUw+dcwbsJYFHbgjKQENhdAOvZYscY1EUAXeuJIHVKrXqDMqsC4IVSrKJFHCswEvAITRNP+FV3kcQJAaQygFYKiPZ5gGbYAHHEWkFUukppOHjAoHc4C6cKC+iprOLWxSraO6XgVWYOVK8qPSmrNSaMDSLNVShGqjN1LPnxFTL0WFaUUFOopW7vmZViiFTKCESMAENZUaQkAENnVTKWu7/ATEcANIKChMw8SpZ4kRPt0B5/JTQHXMOiuma7Guvakudxk4CUyN19CND/1QSkSNOHCFEYKFRnAFO/sbBn2N0mDA0xCma4mDPQgER3ANgVMDNWAEVIgGariGP/LF66u6J70+nny26stVqHPZ6SukmM1Vlq06JhVHKaXSYrXSl2Os46k9mjQoW6yZnOGZon0FbOUeVLj/VlRYhaYN01R4Ba7Q1kuoBG8FV0XA2nFt0yfjQ7zYx/yBO3UFSFI6LgJ6lhqIkbQdAh2YV3r9O0DdN8JTONooSd1YTdbITCoItHehDRVijSSAhcd5HFAoJksINEgFL9e4Fk0ItNx4nKgCwWL60I+9iZjTPSnlzrEMVm2UqDCk2c8tw+zD2VYTT5u7udO9uS8SCgsTGcdiOYAKqIEyD114mZmpCukpWp7xmWhNBWr13WmdhTvBjoaYBffshFfREEfA2uV9nydbu7vAAzx4g+n1mjbwpCsIpf8Zpf3DOxhJ2+8d0AGtgbUdAhwAAhzYO8WAjGJiQHWhrr1tXCrRDcRz/xzGDTiCaw2BUw3dUAXGxRLG1RKnAqF0MabLwddtidwPTQRGaAVjeAa2lAbxJJ8etIZr+M6yLMct0kbQtTo0NMtraLUqNV3UfbkSNuGeOF1IERmRkSGVO6MmGihLI4iqWIihBYueoZ6jjdZW4OEeJguyCN6tsIpcKItOCIVQSNNHcATlXd5wxa3ntQvppV43aAPrvb/+0V4BGkjHGALw9eLwBYIhEOMuFl/IiJEaMBzFG7QkwVDeKEk8UzxA699EuEB2oY3SKEEsWdgU4DMG9LcPkiDUvBJNABfCBcnH+QMF9ir78okILt18yqcJTsu0xOAtCr/xO8sQFmGfeEueXf9hkTHhUI4URXm5Tu6J8cSPT2asBhMQkPsINoEIhZgKUomQn9GZoAmaIM6KH7aFVliFUyAFS0hiJW5irEW7lILe6X0DKq5iT5qCLtiCaPafUdJeZiECMv7eMfbiMeZmL+7jd6GCcN5bxt0N3fjMLXFU1rjQRmC4Eh3NRkiSbnFEy7OqyFxc/7Wux7EuLOGNRLCEWdAFoWgG+4BgaYBkRyloRxZPt/SJSGndx5onVRYKRKkJoKjomZCUjJYUReHkB54sn9inZbCwZBCjTAGYkQuVOqEOhriKUbEKUineqJUQIAZiV3CFq7gEQcCETjBiTIAVJWbiJq5HZE5m6WXmNrj/P2iO5i2YZoE8rmTJ5m6Oam7WZsUQYyBgEmwxnNL4Gylp1En1zECrLlCYQGBKAoZjqizBHCqBUMBpBHZpVFDoDH1W4H52BKWqhFmoBdAb6M7BCc+hCZHBlOTxk/RYoiWKojA6hv/4ZIp2bIpWFFTj6Mju6EdWBv0IabKaJmsaJ4KoCITIE5bGCgi5CiA+lZzRmat4BVjwZVeQBA+IgU4ghZ326eRl4iU25nqcCz3gbTywg9+mgzkQbjlAg79Y6qYWJae+aqum6qmmaiWgajH25854jYb7m9SgkjtDF7YOZwacRBUiPNxApuyWjT9IBBBCF8TZW/PeZ33GkiVOhE6I/5MzmSZjuIiWsd2Z2ZOBMBiP+IjD5hQZWuzFFhlEoYn+QJSMHrETRjVVdctpeAZk/SIAIYooSifcGQnYAW2G2A7pAQuGkIUYRBWimcGZqQVdKAVHooMukAETkAAGuIFNON7jTWLcVoQlZuLm3W3etgM68O3gngPiPgMsFiXkriltjm4yVvIkVwLopmpNsLPLzK5Ae40x4JZ4Ts0+3tcUIJwoWbw/cDgh8AHGowJfGjgYyA2B01/Q+AMsyWcsUWBC0ARXiBODWJOoSAihtcEargqE0PCGKYnkWbmQGRmJlmjVBeULi5S3NJlqABmWUxlMUaKJcZjx2HDtsEUZVKOa1P8Jnoi5Cg6/LdoGNnQGPnAAB0iABkgABmiABpCBnd6ESsCEb01erMVx5p2aHf9x4A5yIYfmFfkfAMremjqCI0jy6A5jJm/yJh/jjZxMCN2SIuiNKMecB5RUYCDryxucxGm4zHlQdiG4q/qWJfE3dCbkfAaNfbYuYRbmVSisG+SFg3AePaeZoIWe8TgIgcD3TKu9gFI5iCa11V0oPWosahj1Qq+i31kigiooG6zdPlGZC4vwaRDZS+aib0gxeHhZaEtHY0CFQlABB4AAVU+AkZcBGceETZj1Grf1W1eERKiaXNEDPAjuHg9u4jaDMwgDafYfYA+lAIKCYjf2MTb2Yj//9iFY9qRfdjGuTCNBjdDgN0eFBXFmlwg6DSvvNydZF9xouNagYz67s6RqHHBZvP89Jt5w87T/A9BwVEdAhFLQBYXaiXlquZTJo3kS2ufRb3gnieSJ9ITHFAGnMAqjp559rLlPmUsx+GxINeP5p37XI9zTPe0jpIy3fItaWUIqR6/kyVGvBmkQBl1oBU+wgwyYAAV4gAa4AAqggVAwhab16RrH8dnPWkUwBEGYeTsIcpsPcjTI+V/P3v8ByMMYAqNn7qNHcqRfem6WqsFJkg/lsz5Tb4IL+yiprobbEiNRTQaVdg7NbmDis28xex/RW+tib+sizUagPEdgBEigBd0c/2Hd3KOXi3wMQxqX2XSWUQ+TUBmb/CfjAYhivwYWK2gwWcFkChcqTKhQWbJfxZope/ZMWTNpzJg9gzatWjVr2LJx45buJLyUKk9+++ZNmzZu2rJhq2nTJsycObl5a9mSWzZq0ozRqrXK0yIOECYgQPCggRdTqlatwmTJUqVHjrZy3apIESKwhgQJ0mNnDh47dObIQWPmTJctcrdMmfLkLpS8SPYe6TsEyJDAggcPUWJYsOHEhwPHGUMljo0xQoQ0LmKDchIqMGAIsVFESJJGoAA1AhSnUaJGVByHbqQpThzKcYpQqR1HE6xEiQCl1u060RjeqoiBIpY7kSpXnnglY//mcRq06NI3Uq++EWIxX7x49dq+S9cu7sG4+womTFhBXwMlGvzF8H3E9QMZbow+7b41ar9S+cIVKxYz36SUzoDpuOQNgjLBhI01DYZ0zTUN1tSgSDdZiI1M2Wi44TbZXDPNM8LQwgornmzCiAsQINBAAwgoEIgqU62yiVWVZNUVV199tYghY5lFBx5psYUGGmeEMZdcde215F5QHMEEE0cM0ReVVfa1mGJZKhGYJkIgV8QYY4A5hg2XTSYEFZ95FhxwicBS22qxZXYbIICEKcQYiVBhWmhxpFYaKLn4pklppMFyKCwxwqLJI5Tg0hw0zsHnnnyV+nIpL+UZEwyn5wn/w6l5BiVUDHylVmcfSNWMFFNLBMKDEjfM4IILM8rMCk2HNGGjjU0U9kohsNakGiyxNW3ITa4QXkONUM0sI0wtr7AyCyyudELDUywiwAAhMs5oFVZa4ejVjj0OIggedOiRLlttdXEkknXptWReUEL5pL32Vqklv4lJFiOaiXz2WCOOpVmbEEWkFpyXoIyRRJ2JxGbDbXf6OUZjGetJMWnRAONbI66FzBUhrnjsCCCHyCJffNu5zMusuGS63S+YZsrppeZ5ehB9zED6HEgVatMTgfHAEw/SSaujzkksgdMNgggyeN801GzT4YIX3iRs0MEGnWpIYIN0HzQWMbMMQv3d/0LL2rK4/Qrcs+TiihoRtIgAASvuYQpVrWyiyVWWPKLV4F3pqOO5eSiOxxtutNEGGF3EFe8UeVluORNSSAGl5vdSiZiWV/QbWxyAzGknxIBMVkRsj43RiCqwA5fEZH6WlkRkjTRGRWp/wBZcHK4T2siivKFGGmq7AfKIJbmMBsggsayHUMwy86LLLdnrsn311fNCEKnJKMORRw+S1JJKKiU9D9JHF/gNOPF7A07UUdMv/08lkbQNUDHxqjWDvMY1qkGnbNdByC9itjZa0EIW/3mgtFgRC2m1ooKtcEUubKEGCkxgARR4gAD05q1NBO4qgytcjg6nCEIkTnGNc1zkJv83l7rQ0HJ10RwOO2clKinhClwQXZauIEQfcgE2fkpCHJKARN1cBolF+IwQjBejkO3mYbAxTRz+8AfHjEGLWgzTHz7zB9SAQne2001qCIVGQBDCEboBhCJSsR6frSdm27uF9XDhnmTY5yPVuMb5BJSSpLUvfeE4STgO2TQD+aRVi3xk0xIZDnCw5Bvc+EaHSuKNkmjDkjDRUISscY1qUC1StUKgdnCRPQayspUMdBssHfgfacGNFbW0ZStsgYgNUOCDvWxKA/agCr7NCHCBO6G4HKHCr7CwhYyDoeSQlKQwdIGGdekCF7IpBW3mq5tDBGIQhZjNOikRinvSUyImYyfQMZWudKBwhWgAQbGQVSY1tJlNF8OERDytBhS40QRvAKEJNGoidiFLXm/i8IhP6PEXG5HIL2jxn1tsRxjHOIYyqCHIpKWvQE2jX/0Q1I2RQg0ckwxHI1O6yG8gcpGKVAc4XGLJn+yKV7waIHSesZGGrKc/s1olK2sh1AW6rShCnQVSZ1GLBsoSbhFkBSpIhIo+eEADvXzKihLAgD2swhQV7IQxTegIFCpzmc0cxCBc2LjIhcELcvGCW7cQBmrSUHLZvGs2u+k5vGYTnD0kIhcCAgAh+QQAZAAAACwAAAAAQAEAAYfmu5zar4/XqYnRqIzUpYbRpYjPpIfOo4bKo4fNoIDJn4LInYHFnYHFm37Dm36/m4DGl3bCmHrAl3m/l3q+lHW8lnq7k3a7kXS7kGy4k3i4kXO1kni2kHS3j3CzjnS7i2W3i2q2i2y1i2y0i3Kzi2yziGexjHKyimuxh2uxhWSvi3CviGuvhm2vh2avhWivgmOvg2CsiW+rh2urhmurhWWrhGmrg2KrgWiqgWStgV6qgV6mhmymg2ilgmemgWengGGigGarf16ofmSre1WnfWCmfmKme12lfWWlfl+lel2kf2akfGOkfWCkel6jfmWifmKje2OiemGifF6iel6jeWKieGGid1ehfmOhfGKge2OhfF6heV+heGGgeFyhd2Ggd2Ghd16gdmCgdlygdVKefWOeemGefF6eel2eeV+dd2GfdmCed12ed1mcemCceF6YemObd12cdl2Zdl2fdV+edV+ddF6edVycc12edFSadV2adF2adFiYdFmUdFufcUyccVSbcViZcVqZcFiZcFKVclmVcVeVcFiVcVSUb1ObbUqWbVGYaUWTbVaTbVGTaUqQblWQbFKQa1GPaVKPaUuLa1SLaE6KZ06KZk2JY0yNZUaLYkOHY0yHY0eCYkuJXkCDXkWCXUR/XUR7XEd+WkF5WUJ/Vzp5Vj12VkB3VTt4UjhzUjl3TC5vVEFvUDtuTjhuTDRoTDhoSDRqRyxjRjNdRTVlQSlfQCtcQS5bPChYPy1YPChUPi1UOyldOCBWOCRUOCVSOCdSNSJPNiVPNCFLNidKNCRSMhxMMR9GMiVHMB5LLRhDLB1GKRVGIg09Kx07Jxg8JBM1IxY2IBA1HAwtHRAqGQ0vFQYmFQgiFQkiEAQcEwgbEQYcDwUWDwQcCgEWCgETCgESBAAOCwENCQEOBQAOAQAJCgEJCQEJCAEHCAAKBwAHBwEIBAAJAgAJAAAGBwAFBgAFBQAFAwACBAAEAgACAQABAgAAAQIBAQAAAQAFAAADAAACAAEBAAIBAAAAAAAI/wCt4MFjJYmRBgqMJEnyw8ogPI7+DBpkxIoiR3iSPJQy6tCeh1aCwMhhxEiOHCVSpCgBQ2QKGDps2NBBs8WPV8aYMYMWLtu0Y8eGFdM1jFAXK0h1ECEyECnSMQPHWClJNYjVHEGqWg2CtaRVI1+/muQqsivXFy9Ool27MsULGHDhlkiZ8mSOIXgGqbKFS9nOYbNOCT5FqlOow6A+ccJUqdKkSI08stGCBMmPFSQ6WJgQgYIEhAcKCAhAunRpAwNSD0AwAHWBBA0aLMhQx1g2YaxYEXPHm3e737+7bRtOfHg34cO5KV9OXFvxbdqiY4u+DdxxcNpoUeojpw0PDjt2bP/YsAMIn0qmTNmy5u1buHDesl2bfy1btqZJBJI40EIgQSkCRTQVUkbYkIQiigwySSOIDBJSSyK1BANLXOnAVQ4wtNACDTQZQUMLnBhjjDLSZGPNNMkEJYwuymyyRElI6PBDEE6V5NRUYpVkF1xZjfWVFX4kMpWNYNGYyCKJiPTCVWutZRVbKcUFw0ogqCRlEGM4MgkqtQQTDDTQJONLK6SgItgooYyCZmKcXOLmJQtKpsUZSODQAgkaUDCBBRREANoAAgRqGmkIKKBBEYdUUoMCgApQgAILKPCACZR0IgorzvAWTjnvkeOpOMVxUxxyyS2nXHPQDRfdqtF1Aw4438D/6g0ynbzxBhm4hhfDrjy4wckop8DCjDfv2XdNNfXNZwVUAk2lQAI2WPGHFUg4NImDP9hIUBJsaMnJHmwgYReGL005ElbLDpFhCS3IZMMJJGjRizJ+JQPMMsMEM8yKx7wiBBFG0GQDjUNSVRJNFhaJ1VbLjiGVwcuG1KNIWRE40gsp5IBxk01i9cJcKr20EksjmQukI5qo0suIYAYVGCqopDeKzKGwycnNjkW2x85sMOHDnRpYELQEfioQGgEEjDZaAAN0MEgmpchSixQDBODoAAUcoAADCDCwwRudPFNOOdxcZ517zyWX9jairg0dq6sa96p1skoDSx9vyGEJIlf0/yCDByrEkIUko7Ryyi3s2YcNfdVY89BEGeEhggAhNFsRHmwM8sfmSCVBxA8DsaHJHkgM7NKUIIB80kg65JBCuzLFRAIJMsjiV5ii3BKMiroE08sWU1CrQwskHXwwwjNthSGGcHVlEoRhnbt6S8sGoVJWQXCMll1PzhUXVszHpVLxmbwyrzItB+PLK6ioggopp8RsipqjJPaJYnBGgsghcv5wZwci6MAF+gSaA4RGUANQAA0UAYpUeMIFTKuaAADVGtYg4AGTYgUzslENbHSQG97whttE1TbqNMc5xYFb3Mz2KlfBKhvEoMQbKHEJTvDhCkCIwQZi0AM9bEIVp3DFMf+igazF0WdaePjDQBykgAZIKy8I2sMf2MCGaV2uJERAAoJoYAPxzaUEqUuBVSbEkoXFzgYaOMEJPsGyMKVoGMM4RjD6EomjBCwlV9kRXF4ShBhZaFzjessY3cKVc8HlLasLGcY0xha3oMWRH3ML88gFxpS0hSSaQIWIbDGL3W1SFaA0xSlSIb/51a9+imEMZCDjESn8wAUkgFfQCPgsBaCmaglkAAnYgIMFlKZqTAtUakgzAAYw4AE7IAUwoIGsa3DjG90wIXSUg0LqSPM53FDhqlw4N0+RA1bfiAYsOtEJTHBiEmYAwg48YIIdOIERoRClKIhRDfnQZ4mOGIQjEBT/ggGUAA9SYANAuyARNiAlW1MhQhJacAJHGGFKlvxiyEp2riGApQUlsEELKNABEhxiROgDijLkGBRcNMMUlIkRGEtWromeBGE6+N6O3HLIkWTlJFyxElqm1JZGhmxkKVnLlMj109RJlEaawIksKMGiYYjIGLVoHxBBCTP5zUxNbLqEJPJ3CDZIAQcucMEKRjA0P8nGgAdITQFIYwDSACAAb41goAxQAADEFQF4xSAleDEN+zwzbtPMJqvetjZtmtCFsQJHO8jRDnV0Yxw9eQYrDHOJSvBhBzEwQQVU4IMsWCIU5GzFMrIRn/vg4SL4sQFsjBDQBHUhEplgQxLw0KOQ/2CUBA6KqG6t9D2KakijF+joE2qhE2gABY5xHAaLahGumIDxLT+1Ug4EhrCtFHJ8GNophsZC1LSMZKIwwJgim6Q86E4PpxBVnRE4IQtj4EIUsPhFHI9hjGCwrxWgTIV+SRkzmM2PTebkRCUg0cof/KAGK+hA0DhDtEgZrQCpWdqgTOMoAdg1rkxr6wAeQIlhsEewgE1V3AarKhViYzraUM7c5uab33jTHdm4RSc2sQkCxyBwG+BADGbwBUZgwlK3mEZ8MKJPJT6ECB0owAkCOogETSITmlOEEaRihRxgoAQdaIEjvsjlEuD0QqtzHUza1QIJZFkGplBGM5iB3OR6Sf9EhXAlQ0EgPvBON3Y0GRdPX4KV8ELvSWnBGE+9PMZHliAtjNyexl7yluahl6UtMYInatGLZkxjGtAYxkhHhItW4NcVqtivflExalMmBhSgELD+9tCFKRShBidQsAUq0KeiKQABB1hAaETDNAorzcIXxvBdTdCJY9QnGyi2pmFRCJ1saAPFJ0YxC8Hxzd64Y7HtuDY5wgENUlCiEpFoA2Z1WAHA3WANkrAUK4qRDYc5ZQz6lJYEKIAHTSiCDZloxCTY4IlBJCIRY4ABCAY+cCGpxJJ8/EqMZrJHmMQuoz/QwieasWagWDxfwTBGMzjRAxqIAAMUkJ6juefH1tmUp9D/awm6HjTlKpPED2OgWHY5ppKNiffgfD5JlHiE0z+sohZqvjQ0mEEvZYgIF7BwRSpCnZ75xfOqh7kZ/iBTiD2sAQ1OqAEJZj0BBnBGNgig6wAOKCjSBOrsZy+A2tVugLYfoFAOmMADlCCKDRKrHL0hRzm27alytMMbywH8qUz1zG/EypvenFuswvEqcYzjG9yQRiv6wIhCFEIOO1DBBri2ghrE4VekYAUsKuIwhw0EIi1YgA0G4cpBeMIRmfiDEfxgBYEPfC4YsEIiUtKCCfF5KzGRCURT4C6N2gAJUoiExplh8YvHsRmu6IENsHyBL5MFfFiB6fJMAt6ER29h6DJ4/xBgzsifgmwuGPOeldri5XJtxQiKeAXQmwENaQydXiLyki1eEeqqxmwUqtB09INqiqFqiFAIfIAGr4YnFbAnFeAnXGNAuAZhZYd2aBdha5c1BnAABqAADhB3G6AErAANd8cbhmd4r7IphGcfyBZt0VE2rkIO40Bt3/QqsZJY4MAO3/QN8TEMm2AIhvAIhAAEmlduKsADT/AIoUAKrbAs/+ZvieBvGGFm1NIFF1EQA2MFKUBwlXRljoBRLdAWCZcDxYdyMNUuSHAGfFALFDdSzRdHamYMV/ADNNABGMA91jUuwddFPMdTYOEWh7ZTV1FziwQXy2IEjxQyXxRJGoN+iv84UeWiFjAwCKvQXsxAf8w3DMlgDGPCCq7Af6rwCuxjCqDkPqbwf/SDSm0iCZDQCIUAB1iAYB6QAZrRgA7AAAoAKUYTGo1igWenGqpRAKhhQBsIKQ2QARmQBa3AE5yCLPYRQiFkKizYgtHmVyAETTFoHd1wgu1BbTYIQtlgN5QQhHwABzzgAT2QWTtwBXywCaBgIwPyFAVBAg3QAlIgBV3QEFNmBCCAAQTXjwOHAQPRLiQzhu7SOnaBBDCChntwBqawZsqQDBIJFMZwDETXDIXwIRiAAWAGSMDnLlJCiOZCFa5jFjX3UxLiSObHZYZWSV/0XbcXVC+hCKVgPvRCdPT/Ql+zMGOdQAqi+Aqu8ImgpgqgdoqoMDMyo4pusmpa4AMyoAJjFTQN2AAMEBuRwoEQhjS+CIxq5RpZkwBguQALwAAVsAFksIw+IQ3RQA30gQ3UUA1wCZfUMJd0+ZZwOR9FhA3PJHgg1B7uEQ6G1w0hRFrL0Al98AiPcAhwcAWMGThA8ASRYF1gZhXUEgEX4EoGQSP8eGUBuZGcaQOZQAQCUxZBAFN5pgMxolAlAXFscAaU4BdFl5NAESbTEAoy0AJ2CGYjl4cywTwjU3NBoE94gBbYcxaPlJJLoiSKOBciADI/1ZzmF5AgE1454AilkAqy0Avn81S+cArk1AmngAuc/zgLsRALr2CerzAL7OM+VZWU95NqldAICZh1NIAZCtaAEzABDkCVV9l2SIM0ojFBwLh2anUACUCMqZFXyXgKvrAM9TcN1iCXdUkN0jCX0nChEzqXdzkdhCeY7QGYbEMc72ENs0AJiBkJkeAGQEAGPHCEMyIlcSEWIaAAJ/ADopkDWuiZOrqRA9dQf/ADSVACYIY8M9EVSAAwq7khUnAGcoALRJcMRWdx0LAM0iALH0ICHDk9zWNTzNNFC4NybkFIiLgVioYWYMRoEJJ+XXZo6HdzXkYu/7icJWAFmTAJoIAK5pN/7rUJlrAJldAJtsAM09AMxmALsUCeruALvuAK7f+zX+2pJvPzCZjgimvwBK7kAidAVrO2GREQAfv5LMT4n6IRYcEoGsIIYVmDABiGVxdkAptgC34hDdNgf9FQq7UKJtHwDM9gq7W6q7m6lm95DXqZTWwDQtl0HMKhDbxRDt5wDKJACZZgCQNGBldgBje2Z5EIFkZgGQ0QAXS4JFu4ozsaAiTQBI5gYBnVLtRVXX1kMERAAuzyA2dABqjwpFEKFPbHDMZwBneSpeHVaGK2ZztFUYWGaIyUPRzTZb8JVF32MbrliHLRj/6YOgMnAkEgEZnwCaCQpyISC5swY6xICrfADNZgDdJwDLdAnr7ADLigCvhVivlFSqRUCqkWCR7/wWqvhhkcYAE7WwG2aJW7uHYC8J9DC6BcCWFwdWERZEEesAlOCg3P4AxS6wy6qqtUW7VVe7VSGw0V+pYndliwIhyu0g36oA/uMDbUAAuU8G3gdgY90AM8gHDlYgPTta1G0AEHEAIsAQIUMHAUAAEgx6P+2AIocAKZYAQZZXzUVRkWUpruupEnQANPAASREJtRmgyzqmaRcCcgYJyGdEiqEz7EaT1iJF7EGWhfFEYuGV0HVwIiIALmtxJ6W0lUIrEBCQIh8AJL8TSZcDOc8AmjMGCYIAmSQAmicAq2AA0law3QEAy3EAt+EQtB+ZOiOJSvoF+mkGqTgAiNgLP1mRkj/yBrtrifCHGgu0a0gZI0wNQoqRFsdvVLq0FsTqoTzLAMUmu1V4u1y2C/UUu1wMqWzLGNrgKY7lG2mtITxdAJlICiNvsEPBAXXYQw1JJQNLAAEsCPtyex4jpwISACVvCFLbCHkRhmzhMwxocD8hoHvYCTlgsmv8AMncABGgACZCgTvxV80nUVYKEDL9A6NtDDpQkDfKgkg2ZJIUkXXxQCqfNbZAav58ecuBsCUhwC/jinEKEJdbogfMAHiFBDvwsKfEoKJmUNpGUNzyAMvKAMwdAKruBpQCSAqSAzilEJ3NuQPoBgCiZrEyABt7gAVHlrHKhWvfiLqpF2bed2b4cATP/TNccUA5vgC81wImQcQoyzvD5xaReqlmvZln/5Hp7cKd40NpzSEzImrZCACF0QU+oKI09REj9AAQowFxq8kRSwoxwsAjbgCMPjLi4VPnBBpLDzA/eYCixMv+hjXMrgCh6gARjwOjYcwsHXcDFlA3YbfBpCZr9lAycJRgPXukiMu83JZddMkCTQwXp7AuSazh2wzhjQAVK8eheRCfnUvXuACJVgTqh2CeSkCr6gvCxoDcuAxrGQdJ7mafJTall1CZHQkDnbAbLEJ0TTAPr5x7hGjBRIyBF2dm0njBtoAKyRGltzTA9QBqZgDBA6ydVwacsLobI6q/YHDVwrDc2kl+D/ZHjhUIPvASvg4Mk8mMBCGAeCMM0zoQPwiBQykQIHQAElgAEXQMuB65lGNcUEwcQqwYeSeJA2bANc9ANdwASVSy/JsAw6ccwB7Qs7wMwnoc3q6i43RSM9gtVres1hpKZrys0xKcsUK6QYjLsdwC4lUM4ikBk72gE2AEX59BFsUM+RUAm/+wmM/WOt0M+XNg3XYLJsdgvPG5RBCUo/GYBocjOZYLN7wAQIhmCZMTQSANF+4mC7KHZqhapol4Ecfcgd2DUWsBkcQNLKsLzL8AwPutKYDLX9S7V0+UFloxzXQRzIeoLwAQ2sgDdyYJpEjRQEQdQrQQENwNS17NQ6alQg/+DOLzAIVF2kC2MVeFYTMvEDSOBVZ+CkQJEM9Gt/z8AifcABIfASMBUjCplTElISGhXC08cu44xRDCuTK2lUqfuPh5YCE+u615wZgf1xOkrYAiFQVNSa9QwJkeDFkyB1pBAL/bwTLT2ry3AMwpCySfeJnU1K2Vs/54QIe9CURfAhJxBAFxBcqr2fVXmVWCnbAeooPr6BaKU13VoBs5aMqLDbxVV/sloNmSzfvm21u1rcHPo21HEcxtENnmJ415ALMnTeqFkRUzESBNcAEEAB2/3UtqyjVjA81zzUYW4EokkTleFHxxdQUvAEqsB8xxDW+yvfaUwKHEACFREkY1AkEf+DhyoXIaZ7kiuhuBq1c17EzXgtt0w9sXcyFyQgAupshzxaJVbwOQTB1VJQz42w4aDduxo7CrGgaVG7q0yer8OQC+RZnp3tX6hAswIG42gwGThQA3cSQKd925zhAJ4aKebLgf+plRaYgXOlNQzgx62xAPo5AVmgHjmxE0we08It3Lm6tW+poSmWrIPlKuLgKYAZQs8gCrATOzYyMDDAo3+bAGiO5uJ67xjQAkZAZnCukBVhEAZDFchHRV29CW4Y1vCNaZkWDLOgAiLQOgRDkiEhRji1OmBhLnu0ki1QLcMjtwen4FyWMRTLhf0YAnZoh1Tczp4eRv9NBDawAva4B4f/gAiLbU5PxgmeAAqjgAqxEAxh/QyaDKz5egy6wEnlKQv8BzNMB58H2EpFYCfwAi/rjNqesdq7GKrMfoFrdwACWgB41QC/tDUYtAGUEKgtfSKzmqtWCybyTbUVuqGmEo1lEytne7bv4Q3OAM107hVGsIUB2dSxUe/47tQXgLsBExPqXeeVsRALEfDbWi1W0JpNanH7K6jS8AzJgAu+YAYdEFPSM0bPExMaklOJpJLOKeCRfmgocX5caNf/2M4pYfIlQMXsbIdNvc6ersSz39eZoWAENfOLXUM3n/OQ2vP129u5SqHcngzD4AuGap7Wq3SRWlkLAi5MYCcwjxm9f9sX/2ABRHOLuQiWBrTsviigq5EBMoAFWFAB70tMq4FXHmAJT6vwwm212j50EhnW2s6rWCu19lurAOEMWTJet0jRsKFDBxIjSGzkCIJBIggMFzBAOABB4kaOHS+UCGHDyEIkUkwiQfmDiJGGCnWwRLLQpBQlr5QdO7ZsGbNp06Axs2UM0okWKXLkSJECxtEgTW20eAoRBowSKUqAKJFVa9YWULvaeKFVaVKtIEKcNQviwtkQIE+ccCEiRAcMZzvcpWtRYtYOIkp00LCCzaBDjSpVusQJ0iVMnD6BGjWq1axgypY5e/Ys2uZo0DJDs6bM1qxYsV6pepVaFapRnzhxuhTpEP8bJj9o4KCxYsUJEoA7XLBAQYKDBgsWKEhw4AAB5swFPIeOgEWhUbKUGeMDQDuAAN0DDEAQPsamWLZonUcPCxar9azcuxcVX9R7+vRhESO2a1euTqJi2UiIISOagsEqEA6cCISMJkqQowO1goqlLthgQ4qUALThhx8WYskKmDiUggdOmFFGGWia+YlEZXzpRRYXSEhqKqOaauqFmJ6aKocCk7JKLB5LeAoqsJDikSwQUohLLhJEIGFJEl5coQUaavjhBCZdOAEFFDT4ja0T2uogBBp4Q2KPQRBpJBLEXnMMslFMQcUUV2w5hhk7NcssM514gkaXWUhzBbXTVDHFlE//XKsEkkJo42EGGmRYoTcNgptUuAgaYMA45A4woAACBPg0VAECaECRUl6RxRhrelEhvPCUOyA8BiaooFYeJInlGGigoeaabLip5pprgsWGG2+ExUYbbrphFhxwvnk2nHDIcafacqKBhRdhbKDhJQ+bMvJAcUugoAGKNjoXgwfFAnClCSu0EIkfANTQpZhicskIInA4pBdjjCmRGWOC8cUXW3qppQsbdqwqCIiaykGHIItMSkeyUnjhBau8EnIpiq/CQAQttZQULxEsQJlLEiyYwAINNGgSZbwu6M2uEmhmw0w01UzstccigxPOV2wZ5k5njj56mWSKEYYXXEZ72hXV/1JBJZVRQEEUkj3YeMKHImzbDTAL7rrAUuKK23S55gxY+wJTX+mlmVdkYMBVWGENbwEJauVAjlis8SaccspxhxzD2ykccWfBGadxwx+HnNpqq4FlF2JoSYglI6wIgqqkxD3SKgwSUBfdBLHSCoanMkwiCZbmBbAEKRNy6SWHaH+KhlBegaW0WlwB/rRXcMGkqxZ0uKqqzVlSKCEYMrbqhQJzCKsq6KvKCuMe092IguAoAH84B8Z3AIEBBvjufO+42y4A7rprvzsGpNjjj8LUfG2TTT4JBWhU/kdNUJTBjGQU0IDFAEYuFKhAXRhMaqpYTZxMcTVOJKoQbjDDGbpWA/8ZqOAuTRKbBSQQgQgQ5zjKKUABDLAcARTgABRwARtSIQtFVAABDDDACjmVwwO4UDkJWEAEKFCBDMiBFtMQXDm00Q1oQW5x4lgc48bBOMNJq1re2M8wbgELhRjhIUagSlnGlbxylc6MY8xeC2TXAiLADkMAooHxaOcSADWvBSeARChEcQpVWG0UoehEJ0aBi1TY5i3VSwHEcoAhHWwPKxQ51wXKBj5KcqRsEEjAqNz3vu100pOfBCV3zjcAH0pAbycYRP3ut6bG8M9/VVOFK8oDsGEUw5a2JEYCc3GLXBTkGMFQDQThtBpTgKKCiuIDH86ghSJwMFK86Q1ghCOBETr/4IR3I0AKC5AAIXZgAgjIYQI8tbYV6tAACQBiAyYwgQds4A20qEY4kKUNaIGDHM2KorOgCI5wRKsc4UAGLZKhi1acokdX4V73KEmBsiWAAugCHeog1BUr4YUjXGpLVkAXAhHI5SwYoEARKmGJToQCFJMY6SUoQQlTYMIHP+iCQ1oQBI1NxWNQkRgjdaDGrpSgNwxS11ZABgEILHSSDAWfJF221A54gAMc4JLL7vKyDkTzN5LszQ8Gs4dDrLIxrewfKYKGCkGVJxi/EEZa06pLWtyiILlIxjBsIYtAQdCucQoFbCKBpkPAwQxFaNQKIEWCEYQQZSwjjgIUmxxYpTA5/wIYAGQ51Zy19ZCH6FTO+RDwAM6+oRXFkEY2RPuNfnYjn6f9RmoF5wxaFIMXsXCFKdCJzlARYLbJsW0CiErUjkRUohMlQWQHcM4ENKCoNPNK8nzqU7p0AAIRUIGaNvGaSUxCTZbYRC16UQok4AAHXTECQrMCAxB0VI0d9QsJJHKXilgkBGp56Ol8C4ImzQUvd5lLkwgbqQ6kTGUauACXTlDVDoBPZj8YRCq7mqZKNMZnYf1foWLJu1jcgpe64AUwEtjWtuaCFscYhlxlIYvUqOY0eP3EJRAjmz1o0Ac1gPFuJDW2SYnwUsU5jgKU0ylQBQCy3qFsNleoQhXycAHeAf9PeB4QA1EkoxrZ8Aa0tsHEZ6WWn1cmbTi+QY3WJuMWsSAUBkoA0qKClCPgk0h8L8A93ybvt1Z677nmizrfvve5HYBEJabLiUZY9zCWiAUzaoEIDfGGIlrJmFlI0IIlyYUulnwo6hwESXF9dM0dUReXNGAX700SOHiRQNnUhboA96YFSEgwVw8RCfyxyZVwkiBZXdG70vyJl7s8zy3ayotlNE0UnEBViUtMzNawaa/KZEIRivDiwd7FBB54GctIeCnjMPYAPvaOd8aZzQIMl5SkzGG341eAG4JnB6yABpS/EWVotbvdVZZWNiznjC364jXSA2mkMb3v+O571A8iQQj/iPIWBDFoXOIyo0TsXNRVV+I198PEJSzRiuuM4gkr6MCYQfC8EoQFknRBi7pEsJFHnxF0DdqIRcomSQoU9WUMZTklSdiAac+8Ig89C8sscAIppJqrkEApm9r0pv+9iY+tkCWt/7R09NBiF8kAhjBgQQYZfGLEJSbxiScICmNeYhKIUKYWtLBB3RBWBR6ssXAocOMcJyDb8AtACrnd7fPR/dsFiF93RrnZN8RCGt4AfOAFD2XRijYaxHiGMGZxC1sU4hIkkCQGjNuAhYKvzEWtfCXNjOb1hoktc7m5JO9blxBg4NF3QfNDKYCHNpVC6JvoBCmO0YxakMEEJ7gIBF5g/wMmld50GNDYgeI7Xx/1yEp+0ahZ4pz8NecgeS7wvcJDcAG8LJ+SVc3ZIPhQCERAQhIOdzVkCpWKowOP1rCYxWhsgQsP8yIXwEjGMXLhik4AwQRlSEUv9I+LrGs9FFk7hBZ7AimwjdwoGQ44rAqYAAlYwLNZgNtCIW3aMW3qNgqkQB3CGwRQAAYgogrwgD44BVuwBV1Dj1loBVY4hVNwj1Zoq2C4hVnAhVZ4hFC4AAloOQhoAOMqM82Lr8r7vQR5r/cSgfJKC44ovSAkwuZKi/d6qAvogqt5k0lgg0MpKVHQhWkwhk2QgZshqiBIAhqggd5AODoruFFLuKCqihT4PP/Qwa/Qq4iKwAqQIpujWqj++g2JoCYbhKkz2b5CYDBX+5lCQYXym7XSiIXeEUESvAVgADFbgAVRsAQg2AEe0ANT2L/+O41CKbbYCMAzYIOYApveIKynqjGUoYAFpDYFOA7MupsJ1CZSssAiu5vwUABZ6cAKmAFC6A/5EIWSqkJSOAVXgEFcIMZY6EU2KLCH2i1/+4Bm/ICI+jc05Arj0SgSmC8SmMYSGEK/GMLouwAa4LpCaQREYAIq9I+fcIUZSEYIELgRwLiMGzMxy4FIyjwzgyhIwjQQsKjMay45ZMDKm6QOsEGkioALcAANYILBADvug4RI6BnHeDVYkzXzO8T/pVu88xCGZQgGEwyFUNgEFTCBGIiBNEAF/SOxuiIUTcyr2EAErhLAUIyUwnKql6kxVDybHHzA22IstmGOuotFFZpFVwmPCcgADsiADYgBICgDIGDKGNgBkXTKHegBMngEVPCFYCAFknoFNtALzEMQinBGEHjG5EMo0MGeosCQFKBGslSuNdIo2XmQfLMAFeAfUwgFLGiEPTCmUZgPaJgGX3ADEhCOBmgSDjABLhm5ilg0uuiKjjJCB2GLMMk3alqLqZoq4AiOmGNAWqmVEYqAdQLNCHi5ETIAhNwDNCkE7ouESUgM1ziU/hFEAIol4ImFWUC/pVvEY+CFWTiF/+Of/0fog0dYKVB4hVp4heDpo1Sgmglayb1qhE6Ul0epARl7Nt8Qm/CpOZxEDuTYSeb4SQvkIU7RwFqUFc6slQ3wAA/YgPVkT/QUyR6ABFLoBErYBGVQhTMoOQpIqN6SM+JbIzgynp5qNGwUqq3oKdn5i5dRAUwYhf/hAxxQBMg4FFX4hdCABBMoMAkgAadyqjCBGf36IGgK0TvqjfScyaJ8qqfqgBEgAd1QAd1w0RhYgRiogRngASeoASUAgie4Ai2YCS0wAyB9ghbTAhz4pg7YGr4qDNb0mQd7E4mEIKSbtdtcvF9wvy2Sj9h7BPRMUVwEhRGbTdSAoDihoNioBBbToP8e4AHcgBT+qqpoArDvMRucLI7ZckUKHCVYvMAUOoBaVEUFcADQrIAHYIA8TTJZYYB2KgNKGAVrYAZTWAEsAalz8am5cLQQwEa5UJK3IIo7egspAUMwLAFObZIT0EZM5Q1OzUbjuYsRiIFHaFDW8ARN8ASgCYURJIVCeAIa6IAVeIIiUIKuKQIikBex04IzWCYp8ERP3AOXTKZk4j5EQIRDkFZphYRxbIRszdZqndY+5IO+kgM3QIMyiIJkAywYk4EZ6CASKB8EWIEu2IM+WzAmdQyIDIVCgVJVaAWkK43ewQVdeEETBMZeFIVQIAMN1EAHYAAF4ABLIDFUkJpBIbb/roMNSDgEZXoCJfgB3HiU3XgLELpMlqOmmcNJVuwhPDVUn6xAWOGhUVKAz7wUJeOA9DQBE0BPGSgDXXQFE/EFUtgBGfgNDRjVrsgNwQrVowVDDUEJefkBlDCJLoDaLsADPPiDqv2DQVCEQajaBONaRfBar3WEsP2DnfkEYuKE1njNTyAFXWAGX6gF1piEQciETLAuab1a+9maqO0Ck2CCZNMQHmgUGYiBswPJmp3Zw4UqmjwslFHAWqkVWuGsBxgfBqDcyl1YBJiAARifPchaRZiEeQU/13QTOKEastLXVuidoXmaF4StFCSF+CgpFXg7+EEAQkiNiA0mMs0rRJEN/z4IUi1gWjCE0UghLMuEquDwzBvjzuToFJTN059UWWzzsT5dgBuyABNYARutgRgA3DIwBErohFkAWFx4hWLSBE0YhVqFDDcphchwX/c9lENhk+qi3/qdBEe4X/ydBLoNW0dohK8dBEAAhD/Ymj3AASGIAiwohHtVhUPBmtcMBVyohU3gAx9QgUl5KgvIAJSxQXZaJ8mV3Mm13BEeYeOg3OM4YVWkXMVa2IVVRYQNj04x1O+gYQYQzQmYhFJIsEy4HyZ9jMcQv2GSTaRL3fX7k7lCDanZV1GghAfwpE0KAAbABGELtkCRoI7MmkJQJjY4AwspwCnRDWgqrOKN02mauf9VZF4LTNlXhCy7K4DZnV7lUIAKQINPwNdWeIXa9AVcOMRWMAVOaMkKQYJlU1MYmwEYPTun4gDHjdwQVljKVVgSIh8H+MwTjuEcMlQDQIAF0KxEjYT4dQz96QTYo4QrMIFaqZvwSFk4hmPt2KRQguVYlmVQmoAoOQEbWIXOVYQ0Cbp6DUTSBaB9nTVXwAWDuQU+zgNE0D+AYYZXUAEOMJ8kg2QimgFT0C7tGrbVIAWT+oRNqIRH4AO/4uLo7NiyK967yGBTXKcR0k5re8WUNVTw7JQcMqcDSKd14oA0sDp/GSBokIZpkE9KqAREkIJnIgHCPbtIUYER8IAOQMAMeNz/Qg0ABFDYimYA8mEATMGUylUscILn81GAnStUA1CAByCE//PNQAokUZCBB4hm+JnlmJbpmY5l9UGyFSBAJGgBRygFR+hch+QETMAE0X3SqglmKaWMEWS8SpgAR5AFT7iBG0CFPaA+C3gqD4gBH3gCJ7CDNQiEL73mrBMm921OcIYDPmAD4NWQGq0BFyi7wuqAZ0tcU7SUku1TV/TJNf5ObaLneUYAdXqACtiALIjgfpYGaZCDNnADOCBAFLgvwwow4DhFBqTkCWiAbkOAEnIAyeVoocRk9FkfWIbp7kAAJeCfUxjEFFTtGABt93nlWYbp92Hl2abt2s62JNu7BzAB/wrBAyTAA0/wBEfA2j5zuPgdXQBSbWGeE1/ItVhQgRsohVJ4gQNYgBO4ANLpADto0GDLuhHzHVlITuUk063TK0QohIuFg2VathrAgbYOY4Suzmjj4DP+08aqwHdWWbuL5xRqXlK6Ic6agA1Ig1ZgBmuwhmzYgJB8xwuYgM0OVFSUgAYYHxICzXWqgMUdIg3W8A1WwAqf5A9/cM5EmQx4AA0ISSUoA0woSTtphmYgEV/YBB6w2UElVEKtXKHE8Rx3lcqNXCJiTw8IyR3YAaYkgzd4gz4ITuGkBJLaRWA8BSKuzVvQhV8Ihn+phUJQAd7Gg0EwAk/o6UFwBLrFhAcOYv/kTsF9bYVY0AUOswVJuIDoXgTJUwsIsK0+nYQRw/NUWAUTK40SU87S1cSuS5Rj25qx85qNjbEVeFFFX2jLrBR2zhRNmcDmTaFRct79ViFYHK4NfHAOpIRhCBx1nQEf4AEYqwFS94FU9wHv+gFlY4Il0IIoOAM7YAM72ANbp3U3QFYzwAIefYJed4InEHYfUNNSr1EZQHZ1ldFknwEV6CAZwAIgMIRAUsH3OIX5RHI50HYkLwRDeASeKSmim7A8HrFaWD9c6IWCofJhwIkScXdm2Alm+Ildofd6t3dp2JXD1ndpqIZ/lgbaU4IokIIKEe6X8PJMCPPXkFDYFERVSO7/fVXqF3yFG3CEVfCEINAthxqCFICAEvCEcjcG/bN4L78603iFVViFPuqjCNtExJiE59yaZK0NDenYNhVRvKjJEspBHNMxlq10lYWO58D0utNkcDKA71gAztoASriFPDgDXn8CppR6plQCVQdcVfcBJVACLCgDNBjXMlhsbdd2PiCE1HyER5CExOC6T3BfWEsFu0oNPAdvcpeFWsAF24QtiowFFikYgrnKfwGYgGHxFq93fe+Jw0f8xFd8xTdwa+iJarCGapD8yZd8ZCmWbKiGnhgFEwAEH2WDTBiEMWgKTSgFT8gE4Pby0YU1hz9zpPMTxquFUkgEi/eDD9Cti8h4/wIohbrXrl5QhlUogS5chRavBVlA+WAitv+DDeqC+bydgpT44o6FJhCtyXViuxPqeU6JxaCHrI/eOx5yZfBI1A1Yk024BF8kBSfX19QojRGbhVowdxEkxvkv5oKhf3RnkSoPeV/4l14IhnQHiF6+BBIcGAyXLVy9EOLCNeuhrYizbPmqqMvXL126hg0zpuwjs5AhoZGUZvKktGnTqKlUae1ltZgyY167hu0mTmzZdmbj5pObN2/fvoUrGs6dUWZxLij6o2VPIzx4/MCA4agUVk+eSoEaNcqUKVSqVJ06xapVq1m3Yk2UtbXUkAR+NAURkCCRCwVGatWS1auXMWN+Pv9AIEAAAgxPqxYzHjsWlalRoD5xosypUqRGhw7tYdNFihQkP2jgwEGjRYsVJ06oJtGBgwULFWRHaNBgwQIFuBUc6H3AQIHgBAQQL058gIAByJUzH1AAAPQAARAwYMCwYcRcv7ZX7B4sWMXt278HGw++O/qLunBp9KXxPXyNDePfqn8rV65buuzTolWffS7A8MLLLrvwQgwxxRSTTDLLOPMMhNFEIw01FVJDU008ZROUUEIVVQ6IILozIoklluPOiSGqiCKIRSnjRBQuEDEIG4oMgscfVowRBAx+YPVjV1+FlYoqppSFlkNs1VKKH4t4kkgCVqxSCggQvNULX7X81Uz/L4QRkEACiwwBAQRWlLIYkaq8okoqkI0SCiiTcXIJZoggMkhnbJyhBRKi/WDaaamtsAIJI3SgQWwXxCZBbbbhlptvvgFHQAHEGWaYccY5hxx0AEgXwAAKPDQqW6OaeuqpsKi6KqututofrLHCmkuBtdqKIK4VSvjgM9FUY5NO2vgkFFEfnlgisskqO6KKzapoFIfZXGPNNNRCs0wxxPCSSyuvOHKABIoYYQMbPzjyBxt/4JFEEkHkMIYmqUxZSipYpXJvm2OlhQssujDTiydOJhIEBQUsgAEFENgWQiKr9CKLlr0sAoGlCQwxBAzDwXDmKx3XW+8oXG1CGSaYNVJI/yGIHKKnFkWMZloNLgxKAgkn0DwCbBlkEBsFjDrQAANA45ZAbwX0ZgBwzRWgnHHRSRecAbZFwJsBAgQga3+79EerrbfiigzYYYPtDNm8RihhNBfGlJOwww71NlHfgEMO3eQU5Y4+JJYTzrHLLpsiiyGGEy0211RDTTQQOrMMMsRoDQsrkYsiSieU9NHHG5m/QQYQO+wQAxAxmGDCBqVn0IDVApQwRhJE0HACEWykSyMORiRhhRWLnMkYvviK1Yots8Ayiy+1LOIkBAEMR9wFOaQAwQVGXJAIX3/FZSkEQ3gyWGFDrCIL+KvcW4pXcco5pySQIKL+HnvsKZrLMA86v//NhnLAwaGLRhCBA/w7qgCYAHi0pTmHgE3zFKiUYwAHMEABCjCAcgKwtpxgQxvb2EY3MphBcHBQHOP4IAjHUTe6jUMdJmQHClOYwnboo4UtbAcM28EOdagQhvqQoTzmQQ96wHAf+8gbUr7hjb0Nzhs7uYZKpAGNZzCuGAW6BS2E1wpWTI5ylaMEFh9xucxxjnOe+xzpTOCB0pGxdB44o+kqYAIOnHFnF6AYcSCQgyFYAQxT+IEFcMCGzuzhBy2ggRUGMQhHeEJejBHfmlBxClfYghXDO4bEPuCJjEEgBRQA0xA0gTBPBCEBDutFKT4wHMNkT3sfIMwHclAKiKEpFZH/CYVXJEOySkyiTpxhgxZAw4QilCZmK5BZawzVgWFqAFEWkAAyGdUo3DQAgEQ7ANQMWJxOeQoBGyjDyPhQgQF8yoQ09OYMaYhCb66jnOVMBzrhoU51mnOd73iHOc9hznLGo57xkEc81gEPfNJjHjnMIT3kIdB5zMMe/pSHP/ChD3LsgoqUqGInOrEJLGKxD4+46OUocdGNavGihLgcSPsgBzm4oaRpKIMbyvAEJfCgBjKIwQxeGgMVjI6mo7upBzpAAhWMwFAYSIDVAmCXISTBCHhoRCQ6oIIzdIYzWqhBC36AB0dkwhGaOBP4OvYKWcQiIrhghjWgYTw/DIEAAQAA/wFA8IKfWqkUizDTX2oxhA8E4ANj0p4fPDEmCGDSL7xzZShgKRk5YeISJcvMLc/Qhc/EjwY1eCwwb0YzYvLMAj1DZqNsA0ABGqBowamUAKKDgBhQohXDkIY1mkGJCAYgHgQlqD1jK1vZCnSe67DnOteZT3rWUx71+Ic5zLGOdKwDnuqEJ3LLKc/iwrOc9aBHOZ6Ruc69QQ5pGGkarmuIQhCiux8V6UjDO1JDEEIPfNADevXQ3fPqIQ8kdQMayoCFK1zBCT5Qgg940NLH3sAHP/gvgH9QBCn4AAdDwABxPpU9KzRhD4oAxSGKgAU+oKwQZ8DCLn/QBUU0IhOcGEUqtv9aPV94BBrK+MUsYhEwUQJVOgIwDAU+CZi/LIIwAijlEPywCr2SKQFpxdIr0AQWUoQiMoO1DCfmNAnNtK99LPPTf2lwmtbYzDXELKYGLkCBy+6vNo8i2jMNcCmzBoABbjiFLZRhjZ1MwxII4GYA/pEPOdN5zvnAhz3w/I9/1KPPft6hQAMdaHgYN7evPeg88HHoeOh2tvfM4WsFysNysAIIZIiBB7KgaTJk4QpYKAOoQw1qNGS31KUeqRuyW4aThlrTWXACrJ3AUv3OIAYtrTULVMACGczgsY/lQX6LIGwbUEw6CISAEYwgyElk4hORgAMcDkFhSBzCDE84wxrOEO3/SHCiyGA5RStiAYtYxGKKa3ErBgjwARAQxscJGEP1/oIlGIiSr6V02Cp6DKZahEMZrlCF+L4tJPLJ8hMG50QmJhEJlW2mM3sKTZ9GM2X6TXaYxLyAonrWs2U6E0xHM0wADjADTsTCGNPg0Cw8wFp/5IPlLm85zF+ej5nTvOb+uDnOa67znbcc5z7/OdB9/kN3XIMSaeBBrYGg9KUr/QpkoC/ToQ4E/XquB/q9un59kF+kyzQGXhcjGjlgugxUQGcZKKMHxGizDiSAmp1KAB6YwIZBTGIPkaj7HlB2CEhUohKQ4G4h+HCISFziE4ElBeKPdJZyv0ITHwhtdBKAgRxr/6IWMq5FImxMpuMlohS9yLdhEkABa+xNGLBQE5sg0ybIYCWWcqJTJCCBWCfvKZf/BVQLajCDQVWZZlYuZqI2XpsG5gZMRBOzXU6wB1QwY0PesMUOGIAAY7+8+jGHOc9tnvPsZ//m+/DH98MP/vF/H+c+9L4+yrGLN6TBBzPwgBKmbvUvek4GO7C/DF6qgv2rYKb7v+nonBFOldHZbUAFHOADPMABImACKiAClh3Z0cwBuF10EMAffEYmDEIX7FH7oAEfIALhJRnJWMIlXMImbEIniELiHUkrnAIpdEsppJuNuVgCQMALRMwqWB4MUIy6qZsf6JgxLIKlCEAhhAMLef+DMLjCK7TCY/gOKrRe64FCkvWdwjFZnugJlJnGrckA79VMxR1KMWkZZv3MbXTcbygPBZAAG8hCMzTDKPDAAzjAARjbocEWPNTha90hHqoTbLkWQd2hHhqUHuJhPvDTPLhWP+GTIvpTPfhDI/6WP6QfK2hUIGQXeV2OHvQBH/SBd/WBHsgBH4SiKIZiHvABtMGBG5wiG6wBG4DBGWyBFsRiLDLBExTBfukeF8bACrDACqjACsDUDARjDehAEJRAwoDJlxQGBPwBIGwYEoCGFOzRZhxCI1QCJ3RFWARWKFSRC5pFWZDCKYjCKXjFKsRFCixCIpRAuwVAA1hBLTTDYmj/Ar2BySmR1fHUWFARgC+Uw/e5gzfkgqqIwiVwwr2ggkFKhutRBuwpnMo4HBPEYsSZRu7F1KDw1AhY2f0Yk2VhVmY10PEVgGEcQAIogANYwAVMwKekZADkFku2pEvCg6PlkGzl4UwSVD4cImzh4WsZFD5AWk+6gzNcEXqlgSEYAidyIiHwgXexl3mNYimWohxAmxusAbSxARys4hmggSzG4hM8gRP0QH7ll68BU/4FY68VWA44jxEkAlmhEl8FQVMowhQ8o+xIIzVa4ycIyeElHimwQl92IyucQpHIY4tBQBAoxiJogiOEQASEgOWtQub5GATYFVn94DyCiREogzvs/8M95M01JMMutMIofELqgYVBtp4sJdklJNzCJRbLhMaf0MB+7R6VFYrFIcqhiCH/OMDPFN8z/cZnBUdQBZWLvVNL1lNuIWej3dNssYNA2ZOg0dZA2YM98OEgGtqhycM6EBQ7UFoWjVQWkJd3rddSjqIo5gF6ohocxEFJldQatOcZlIEZzNd8OQEQxF+w+YCUSVlq/JGvaZ3L6EAKzFGTyOMpfcAYOIIj4MEPGMEGskEjDIIigCBewpIppCA3Ro6GBiY4noIppEIJTGYDSEclhUAq9AIgKMIF/AEo7WBxQAD3LMJgDIGT0MsseIM++FDeYMMz5AIpjALqqYJBqoKQlP8PknFCFXJGk+kJbOIAgEkZF1KcbeJP/lTABDAKowiNACEA0iwNSCbYpxTHO7ykS8ZkPbFDPKApmuKTo0lnPFDnIcKknDKaOjHaPOyTdsIDO7QDNWiURrVBSnkXd4kiyiQlKT5le7lXVKbBeqZae6JBG0CqfM6X08maEnglD4AlD+wnf9YADmidEjjBE9DAfyGBEQSSJmxPkyRCYi6oFUhBFwxCKWQgUlUoWIwCKUzOuOFHfuBCLsQCK/ybLCjDIgTBlChCEGiZCHSBWwiBCGhCLwwGUBFHDV6MXWnPKqjJK5wCNIxIC+0DO3SDMwRmK/zbmoSFQd5qalIGa2pGw3X/xmeIRsRJXEzpXhcayu/JBgVMwMb1Zm5IHwIgQKQQwAEsjwA0QAvcVj3ZFsPqE6G9k3G+U3FN7Jg+bHI+7Jgi5zzUgz8xpyJC55veKZqKUDjQQh8wghaVFByEYiEcQuCForSZJyjyQVRGJSrCQVTClxucwRmYQVZm5XzGorV1JS0qgdEqgabqVw0A29HCmtFe2x4cgiUUmSyswmBkgics6GJ5RoQ2AoVWhoWGQieUhS/YAi8IiC4MCLewgiq0oSzgwSq04ecRAQfcABV8D76d0vIIlV1sRY8YQy3EghLKAix4Awv1w821Azfkgigo4Vj8m0Gu3q3CSZyoZmYgghV6/wbE+UlpnAZkdeFO0ZQH3I/O8MwE7I9tMJADCexvCABwJkAHGFXDzq4+Qazt3i7EHlfF5lburpM80EM9KOJzypYergMKkUM5FJ0eBALNwgEr6t00muconmIcnGJJmSIq8qxW8iz3buUsMsEu2ecVPAEQ9ID5nu/W3ZcT8IASmAEfQMIlhMLg1pgkeULCXaDs4MmERkKF4qo4+sIsbIcuCIgwaEQwxMIp1MI0GAOXrEK1WIMxTKgsSIIxpJZckQmmCJVhfIDV+oEy9ELwdEwoCAPe9MM/0MNCUQMtsELHOO6Qlqa6puYlKBxi3dJixSvnkoZj1QDvsUYvgh0HAB/PKP+TBPwMA+2GAyWABMCAFWRCKaATFEPxO0WxxJ4TOpXTFKdDFmNsxXbx7sLkdt4kTNLpce7WnoYDL7zBHdxBHgAqGoABykhvKO4BH6BnHNxxHNhBHLxnSd0xfKEBGmwBFnCvGXivFjwkFjzBEYhqVwqb1v0XL4GqE4zvFUAFJ5iCKvDFxCCGHyTCJDCk+0St1/JdZXQFKXRCK/gCLtzCL/DCMAADMOhCLuhCualZG7bhS7ShMjTDS0xDG4YSX+2tBmdPJwdG8MgCWYgCNeTozQFRNdBCuf7bvzmGkKYrWETG69ESQ+LJFX4GbAIYzJCl/4nu/cAGz2yZ8P3PbYCAFfj/SCidQxRLcTxrMRSfgz2j0ztQcTrZ7nFZbJ2C8TyI8WxdbD2sgwh5QydkwRfcgR6UQRaggR0YqhznAR7fsR1ctB2sAR9DGyBrNBhEARrU3hPQIhNgGBZw5RJ0ZS0WQSMLmLA9QUpjARa4QR5Awoe9Qi0YgyzIKL118iB42JJxhp3cJSaALeWE2y9oxy8IAzDkAi/owiy4QizwMi+/BLXcslVfdSLs4LSe1TDb1SIogzHgQi28AmR0Ai3gzfe5UDlMAy0ooRKuyStMc0GiQptgM5K16yH8QfvggWfEa4DBzGPFlNf1ok3lFAcoimVtGTLZxm1EwLtowmKMQQJksRbP/1MUO2w6wLM+New6wbMWG2c8aLGc6hYfGhRyNtcYw0OO5oM9mAM5SFcgCEJ3BYJtC8Js27Zu78Ea93ZvX7RGB3dwg0EXEPcUbAEYBPIWRAFzR8ESPDd0x7RKd6XRZmqofpobyAEh4CVOA8YkWSuNDkIkZEImLBye/MFdmmAnBNbksEJGzIIso0WKlUUvtOEDp9Yt53czfPAPPh6YSsdhfEBe7TculNspY1E0lINz/kMk5k01wIKHxskmtKCQ3gu6vpIUzslltOYttU8XTIEUxE8RaF0NQOkKUOQKjE5P4czOyMYETIADMQBvMsAEhIAfOPGO7SAEzPMVD1c8Dxdn+/84ZkOxOcDz7ZbTOrVTxdphFdcpO+SoQaFDOIiCEjBvKPq2buv2GgeCb/92Rgs3GKwBcS/WFID4Fpz5ckcBFKw5m695Sk83dcef0U5yGWi3NQJpxBjDGEweWWmPJzBbJszwJNgINfIvCrI3KseCQ8xCLsxCK0BO41aLSug3VeN3G1otYRRGgnlKgOtYM4w1sIqCJTBCH7CCN7iDP8zDP+hoO0QDLERGt7kCE4LF6rnJm5zPhnuttNkwiAsbLY64xO0wF+7fiuMM6epMbTjAi1+AC1iBYqxCjfVYcEXxPdezPcPztW/2tPN4kYd2PhNXw1asH8bD7erW97k2OUTDG/j/QCle+R20T5f3NpfH+5cPNxjce5nnuxSceXOzeXRDN5zDORA8wUy/rzWCgir4hbylgICLSZN4giaQd5IhHA1LgiWgYERVDgqCG1pMDob+gqT7sn4/sMg3g15l+rTm42T6QX0bgy24wilUjlH2ATKUA/Cuuo6WgzSwwtjKb8dQs5Bes5FaBmaozyE0pMMdcix+c7C7VEXeVE+VMwdMgGVNgAa8wBg8e41hAAT0RnCZAzrZ89dfe7afQ5GLfbfPs5FbdmavE2lfp3HCA5LHw83lAzuEAyvsAA/IQRygZ7x3eR2scR0M/h0Mfr179L3bUb6DeL+7+RIcAeQ/PuQzcsDH/98VnAGF8S8nlELCQ8znfQAM3GMnl4L9epgIWkZhYXwnWIIVZXzGtzdYZfVV2ze1TIMy/MtcnVKPgWmAL4IsAK5Zh4IlUIIhaFEnYEM7lF8zo8gz+OUiadW/CWY1qysowIlCFv3sJT3P5hKU/ZevyUCusUCurfgZcUAGdIALGIHuLEbu89UCGMDXn31whVAInQMIXbs6ZDu1W/s8Oyw8gD1ApEsHb968eO/ewYOHEF68fP/8kbv2JsYMOBfh1Klj505Hjx3r3NE4sg6dNSdRggGzBkyXKS+nSIkChSaUJTeP5FyS84iTJz+BPFEytEcPJVfMuOHDZ0+jSpw2jVq16P/DkEWePC2yWgqrJ02eQIUN24ksWVbMlJXd1GmtKFHHssW1Nnda3WbNpuFtZqzZqiEfIAQOLIBAgAACEny4WkuVqU+bKD0q9OjNm13h2u3zt3mfPnfuorFi9Yr0K1WtWqlSrSoVKlOjYIflxKlSpUiTIjU6dGgPG99szmhBguRH8R84cNSosWIFCxYqoEM3oSIGEjyLVq3y9BcDhQUJFCgwN97cOfLj0KcXJ27cevfjzJc/N9+8QIHz7Qtct38//nTv4ikIoYQSUughfcrZZQcTYnDDjYs2smMPkEISqUKN6MhQDZRO2kIllWCKSYqabMKJpxOVcAIIIIgqqgceYOT/oYegaKDBxTMSgeEDPxbhsUdPVimFK09KgS0U2JAMRRRowpnmFLJEgZKUXKzxRq66sLzrrrnQ2u6DLwGDIIHCBCBsRz9WGeWTSyiJjBBCgHiDEmrc0WezO/3Rh5xnYHHlFVlecUXQ1FZrzZTXYpvtkkouwa0RRHjbQ1LgpJBiOOKKS64GF2qYwTkZYoBOiT0cAVI7HTGAYIEFGFDggPHmGy+9Wd2r9T320COvvPx43Y/X/xiaxx6FClQInnzwcYcbSkxo1kE34thIUgtJogOkDOlQQ40tOtzCWw+3ELFSJmaiycQTeUqRxaGUcNHdHn7yoQYZdoDXiqqG8HGRq7IT/9Lf10w55ZRDTSElmGBaOYUUt9xiJZe6vIl4GmuwzOuuia1pppdShsjXj78AS+CwABIbYoxSPqGtzUcI6QMIMnaA5ZvM7vznHn70dGYWV2AJVFBVXCnUNYKLBCVlRSdxdLfdemOji0orxRQHGmqQVzkXVqjhh0Y0KUWWWjSBIYfuGlig7AQSgDU+ddSZlVZba0WPPvPwm3vXdfJ7RyCE1nGI2GKP9accZ4DwwIMN2mgjjTTosMNxkbDFtqRss9X228u/hVoKJsgt18SbdkpXxRVX/Mn007WIkQcy2BijKj9g15fI7IIsheDbTXFN4E5Qc4sWZ6ihpsppgmEmG7qkyf9rLrqU6QWrHj/ueAgICiPgAxj8KEWTSyJ55JE+wN9hxTeiqbPmfyByp51lYGklltL8JI01Q1NJxZSij+akUUcR0Y03PHzTBQFaqgjHwYEPfIAc5UxBEUDqxVRyAIMUSCACFXRAAxLwKl2Zoz1wi1sH5XaOWcXqHOngTzrmxitjLQRA9pgHPP4TD2PlA0G0eMMVeCCDB8UhD47z4eToUBI1RK5yX+iWt6KQxChorlI1Ad1OzpUTJ/jkCaT7CYxkAKMX9QALTtCCbxIBMunlIF+JIFIpslM/2xEsFap5RSqKJAlbHOMY1ihHOcKRx3BcwxvQgIY19BixuRzveL2QhSb/NLEvRXrCDx8gAAEggIFElOoSkFiZ99rQh0dQYhd10kw9NgPKzpQDGbBgxSmMxgnTqKY1Q0PUKEAxG/3VJjdLY1pvgnOp41BtBjJgTgtwwIZJOHAVOeoABSigAQtYQAIUbEAD8jM3D04TV7OSj39QWEL96O0/+/kbQexxkITwJ0/eoEQaysCDGLQBWnA4ieOCODkgYktbXzDi5ZSYRCaO6Ik8ieIRfnKFK1TRdDLiARByaIYemMFpbMBDGPH1FxiUkUhnFBJYhGSKWhhyFanwxCQQ8Yo5WiMb4bjjHb3BDWQQwxnZuGMeKXYNuRgDbIhcRNeCxEhHWk8TjsCEJLwX/9RHyMENjKCEKKpRJ3boQx/02Ic8QKknYpxSTZ9Qhfzq18pXpvJojcpN/yAVKeAMEFMIrAENVkADPEzCaw9MRAo60AEOcEADdUWmM9U2H/RQ04NuG8d42Na2a9oHIXvb24AAVA95wGMdjGWbZ4jxhjI4QZ1lQMOz1uC4IWpIQ9rKlj3tuYZvzSSf+/wnunQS0IGeLkZAKMpAzyAFPIwhEWP4S8e+REYeVdQrPbKCIjLhieD2a02FmAQoMKGkWQjjGdRwaTncUY5vTPek4chGNbIx3WwowxSX4EQparHRWng0KzBIgB804RRIMCKommyDHCZDCVhAtx36aMdS2YG+e//sAxxTHdgoSqMaVLTGUIgKBShC0VXbQEJpYnVacLSgBUvVSAqDyEQqvrYKP8CgBCTwAAcyENcOXOACFKggrMiznr3y9T1uK09g4UOfX/EKsfBQLGPXEVh3fEMUfSjDDCp7WQ6B4QtDVEOR62nkL3DBnviEQhS2oE/NMSF0qPXnTZ7gk9WabkULJQNSzGAGPPghjBseQiKiR9uv+CsrfrCCFcYwhkHMuRQenUQj9sCJTzTiEpLYhCVEwQpa7AIZ0XDuN0x60oh9AxyIzgYzfuGLYVDMGsygqSxkkYpBlKKSkmDEpx/B3ke8lw+bpET52pFqdbSDHja7R56+sYtTngL/UEBj5YBRMTQkjSLBirKNVx8VqaYBB8I/0IIiNJGKWsjCE2PgcAtOYAIPaEAFJIirMicwARSPh8W2ao815RPYwGqTsIc97Dv6Jg95sIMd6mA3OcohjT7IAQs86KVl10DsLYQByUcGbZE/y+QvOBnKUuYc56yMLtAF9HQ/kYEZdiBQODwCEWxAs/S+ZCra0Y4r+yJzbcfwZj9kYhGJwIOkQFGK3HQPfODbJFlgkYtkSEOm080jOXCOx3AgOpAUU4YvavEKUGzCEKFmBCIeUfShygG+m2SFN8oxjlSz2h/1uMc/OuMNWoimNKtURa7BfqhdHzhll/AusCHFFEnhMsJ4/yjVKsLrCSMEwQY0aMEKSNAs6HRg2suswLY52MFufzs91xQ32+yDTWARFt3xUPe6AwtvWLwhDTiMQQwsi4YzbH7f/UayPbV1ZIETXImbO3gREn6ihT8BC1po+BV6kDg4oCK8qxhEDiKqmFX0gvd82ctUroIVTdhWemRehBX+MAhHZOJRkUicHN4ghzToIQ1xklMnBI0MaWSDG98ghx5NGt2XemMazPDFLGKxJu8xohDtb38fZM8HQnyPGOUgBzvU3RlQ+gPrytp6K0gjaFgpqwpsFMSO7GRJf/hnadbON/YgE9qK2awgBWxgl2RABTjAA1bgBPJOrjLAAjYo8Lrtg/9C8PDUYW7qhsb0Zj/UQR7ood3UAeeooQ+yQA6c4AJVIAuiYPPMoA06z9+KbMn+bcm4gAuQKMryaYkOjglQL/XQxScizHQEaqHagAxQoRdwQRmMQRZABkwWYaN6wffuohZgx6Z4RHrKKBH2heQW4Q/YAA7aBQicYLKyYHTIwA3eAHw6QRRuYRmkAbuywRv0qB3Gr/xoqjFqI9QK4RDcrw/IgJ344BDkoA86IanUYR3oIU+Yiv+wrh24IRd6Rn5WQ2hwB0m4ytcqARKCbTeWohEuTBZ6oRY8wQpygO7qDlSkzQSYgwOlDcQEAsVWbARVLARnhW3qhtzW4R3GY/EEwt3/XpBtvg8WgKAMJitUTMAJoEALNu8MOm8LjHC0MAdzoAwJl0CJqIzKqswJU0sKyaAdzUCgOAEXagEXXIETUqFHIEAAAMMPwFAMNYa2Su62PCb4LopINMEKjKALKmIHYgCBnEAJXuYiWuZ72kLQgOEYoCEQbU6QKs0XMi2WIuHTFpER2+8RzWAp+AD6aAEzAoQemEof9uEf8kEe9sEdsoEWXAEAvW4UCyzXxA6WPiEoZakSJgESIAERkPIQuKYUwhBsxmDujKBG0OryVMADXODuTkAFTIADNiAEZWUECe/b2OPwEg9WTGgd2AEe8KM/zkEdmEoz4oEd9ogGnQAOyoD1/7Agn7SgDDDnQ8JRJUaLtJKIRKLgtNTxJpjgCtpxMS+wCAIFF0SjDRTBEf7CMADgA+Cu97SkFkxGDSVqt7oiNLNiCBJyD5iO6aAlDSaRDyZDqChhLUjhFGLBFoaBGaYhEK3EGqBhGHbGFGijexDB/YQTKdvPEFqGEqTh/tDHHzqDHuihHiDCM6rh/3yTLEbRJ2/HSIym7GgJEh6BEZliEjQhM8HGCpIACWgABzKFarBmF0mABEZgBEDMKzlIGHElbtpy3FCwGcctHdgGb/zzLf1BHsYhHHZBDrGgi/AyCcMxXGBCgAQoRJBwMG2iREBHHRVuCZhACxbTHVdABSYhUP9gwY8egVQUQwAAAAAgAEg2SgxXYaLOcAiwR5EUCZESybesgA3cIHESpwyyYDF5NHE0iRIsoRM+ITZdYRZ0QRmgAUt+bmdIYRO8s/3ehBCEsxAMIUsNIRD64A1Ywfv4bzNc0iVDiR7cYTpZgRRIIRQ6YTXCLndcgxSM5BNSaZYiwSiRcpiUjfeazQqIowh8IFOmhgawBmu00gRG4MPo0zyEMRhVLD1OkITsQ9z4c1IFlB3AwZx2AAvuUglYDxvzabT2aQog1CVeQibyyUJDJx1PRAiEwMpuQgo4tAofsQ1ioAc4oRNIIRnKwRtC4RAU4QM8IQFSNAHGExa1kC/84sz/tKJj9IVGPS4RaksKziDMzOAJBEqgsDVbFbMMWPMRIKE2ilQUTiFJccEXfAEXbCEWVGEUNkESEIEQ+CAP8gAl5c/9tLRL3wAZ7u9OXpKp6sE5pdOU1DQU3PQUhgY7X+PAxGIoc2MSOMETUoH3ZDHk8GA4tKAGpEaBOMUFnkMr43NRzQEsHbUYIzWF/NMYK9U+9kEz5EEdvgEZdoAMEhQvf2IJaCKJRJWJQiRECk6JSsQmdIJVU++JNvQRa9VWe2BRSOG5bOEQbm8VPgAABGBFswMMeU/D8kUrMKCMoFWRpNUPxkBWw4wMuEwKSecKykAO5I+9jDJcOyEUYhM1BMwx/zABEgpBXuOAh+a1XuWPEAIhS+EECDrhGzzJH1zyX+vhJUGDYEdhFL8u1yKXYHgtNvLH7DhhFJSNpjQBD/DgD/DgabTAB4bDOKbmrGrAOZ4jPlGQPkKQr8ISUvWThEoosACUUtOhZf2BHciBGzohBrJAQWsWC47gJp4sMBlUHHV2Jp4IZ1eVaGHVaJnAHXm0XgrhDebLHbwBFw5BEIyAYwIDBsZzFWCRYjXMR27L+L7W40JOVskgzFzvdIrgCYrAKFjvDODAXhHhWyOhEjbhfxllUSLhEPggf/PgInhob/eWXlFSD3ZgB96g/shBM/gBZ17yOXWXHZzhlFBBfghlAP+1CmB4bTtTZhTQqBeUAWzYYM6apguQQFYtpayqxt48hQUQdcbSgT7vs8X8ahzEzW52xXZrN1LVIR02Qx/GARycgSF9Agt+IkGJt3iPF4mScByRdzCrzHhVFbVcNUNz9mjftwdtFQ7wkBfKgRtEwRIuARBCYCqkxxNkITvimHZ6xOOqouTWl8zIzAiQAFvf93SYwHSKoAhSBArhIA4ehA8SGSWttP1Scg3QQAuwIA7I+JAV2JL5dl5nQHwo4RrMpx8Wl6lccv8gghxK6RQ8mFDaaH7edKuMpq2axxPYYA8UYRAmZYAiLIZ/wAd4gJc7xVMQtXVjxSv3ilZi121OdrD/AmtSxW0dNgNTsYEVNkAFnmAJEtRTFTTL8JJTI0wbI1kL0CCcv1mSscBcmtecidZVu/jKQAeMzeAMEicG4MAM5KAYepUVLOEHwMAFSqFZhwCOhUQ7TCUrrqKRrEIN1ZBGpXURSsFPt9V0OGeQBxmBKLqJxRkO59da8Xcp4KBas/Uk0GANMAKBF3gp8sADTACCc6FOXM0l20Ee9AEfZDI6yWGqCIVuB6xQ6sc1XAlJvIYvegEUeMN/duM3qBXCCIiibyB1bXgEhLmEdPhRxbKHC488yK0/Uzaw2GEzxqEbqGEHNsAEtqAnsACbncCJTSdBu3nzxrmb3VoLSCSuzaVV/3NCnTO0nbHAHavVVt8ZCIQBj4YhFJpDCJrtjftlKjZuXxhpRvcloaHVE2phEKqIW58gCiV6ogH1IX3AUx0OyGYkKLCggC/iDAbqClDikEdagemVXj1ABTj5GuzkHu6BHtYN//AhHx5iQPUBHJCBFVphUFiJJ1uplVxjFFBhFZShGZRhFQ4BEe5MNxpQCrqA2HIZUAF1qWtYBe4jPnQlh6P6g0zWGFE2q7XJBJkTshhyBIZ2irYZitV6rcU5nMnZvT3nicqlRDC0eJ/Ij9+XB5XgDP5ABTohHKyBFYDgARpgBGixkQgABoQkkdCoXxR7w571axNh9yaBD74sWys7fv8brsOj8CfeGX8vwl5RkukuQlLiYA9WXIFdfA9Y8wraoDU7KSZfrR72IRP/QVhoW93YYRym6pRIIWUwYQBzzX54DWDaqBfuYhUcIWnwFhIYkTd8QwqAQ8KGA4EAtVOcQyuzyXXp0ytVrJpkl210xT9+mD7GgRzGAR06wx3C4XdjQL31m73R2r1br/UiLL75XJKfgEKfjEL7CUP3m7/fOcwKyAqk4A3oUQ42oAIUQAiswCowgABCLhOsAEgiXDsKekc8bn01IRYjARHKoEOt1cN/IsLMoJtNRwve+UEu4jRl/TTPIKRF2sVXfO1Y8x3l4OWwASbXYf/8wR52fB56PGD/2WEbZI0V2jUoRfHWEraDmbwvNCETGsU7j5IRJ+UM2M5StJyXs9sEZAyFNsi7o1pWkLlt/urM5yPN5wPn2vzNowEIdkAr9Tt0WO+JOZUarbXfD30bq9WJ41qJmhd6UQt0oAALgEAx+xvRT0AEbAAiuUiZOgC4rmIIcqAUjMCjsoNFOZ1jPB2Pv1YWNGaAqTELsqAMrHUxGd4dw/han8AMwjhxHGSkZd0u973mYT3X42ApqrDXKaEPaMEdyEEfgn3YcdvxHg+UFlcbqPMUQiEA4ye4rwoWx1C4Yol7HiEVvZOAe2PbJQxQ6ZeGV3fczX3GxBzdqVptDO/w9IocHiu6/1hhB5SgKgu+vfdd5Q/d3/meGgGdRJo3v+89oPQ6zJ6ABARgAGYAyH6gA0oAD9CoIGsh8sk3oIOEof8CbB3b+FZhLwqBD2Qe5csgr5+gQ1+e78vW39mpkm+ejJ/F9TEi15ei1OVg/oKeGqCLHdYBH+YBt12wx+mBH/4BH/YBG7bOFU6p67ruql5ho8YQNoTEaBbFToNtD5jmypmQCa3GOUyAPHB4u83hF39Rh90GiNvd7UVozYveHa6hD5xgBmJgA8rZnIc37/W+WlE/zCzL74E20Jn3XABiyZIjBAsWFCjwyZMrZMiYeWgGiAkAACrUqNECSSJPvVZ5/FgqkydNpf8WeSrlcdEiGDBUunTpJxEGI716wTGjBQuWLFnKYLkCMaiZNhCJPmyDNKkbOHKYynn6lI/UPFTzxLEKJ84eqXzakJHTp9CjPqy8hVO3Tt4/f/7q+ctnr57bf/ny6au2ixWsVq9ixXoF2BXgV7J6NWvWK9WoVKhMmQr16RMoTpwuTZoUCVGjRof27GGjJTQTJz5u1GDBIp1qc6pbpzsH+5w51ulm275te9w4dbzVxbYtu7c63efS8SZHzp27XGSyxDCxIUsUKNSh6HSyEEuZ7Q/PeId4Bjya7WWqV4+CfjpCgggHHhRocInChkCRXuGBAMEKHj/wDHK0SkcfrVJLL7X/yOJRKamgtIonnsAwxEsvjTFGAA2kYooWfOC0U09mYFFUUm3A4UYbS7mBYoomOgWVHFy9CCMhfGjFRyGFENKGHDneyEgfxYRDDjv8rMUWXXUVeeRduxTDyyx9/fWKYLIUdpgxqyioCiqNjTLKJ6OA8glllkWCGWedseGdFk+QZhoLtLnWWmywvVkbbubMeeduvMl2W3C9EWecOsi54w0lb1DBwgbRTVedTgrpRF5335kxKXnkoWcedVuotwQUAlXX3nrxFcHEEw2V0dAOV8RQQRF7/DFIJqXUNGWBNfViDK7GKHNYM6tossgHEfrhh4R+QABACKlwYsYe3lkKURlo/6CR4lIkwoFtttpiy0e2MOYBIx8yvmhjIWS8QUYbeRSShxydVEMOOvzgwxY++fxjZF344ruPNtRYM8wsfvnVV4HMNKNMLamkokrDjTkWyiihgFmZZZdtduYZaGLxhBCmzVBcOu+809o6cL4msmuszSYnnuPYeeed5/BGnHDJLfOGHDfMsEEFWEzHqE5C+8QdGt6dgYYZSa9xhqXTbgH1poxiah7QUHD6xBJOHOFE1wop9BAZqJKxww5O8LBCI5M4AgqutRSoTNzNTGONNdlk44031jRTykhDDCvhIhUCkMkqk/BxCB97YJuG0Q9Ruy2JKGqb4rZ8gBuuuJnXKJWNaf+8kbMccbD7BizhjEPPP/TYU9e9+frzzz116cNNNtPkMovAfhXGK2KvqPJ7lqZoOYpjXIYi5mVlHpLxGWuWVoMMrckc8mt8tvwazNpvL/M69LBDz/fsuBMOK2/wYccSWQCBxhRRSLFEeulhYV0UWmxxhhRnTHHGFmiA8T80bKEMUZNa1NKDEPRI4QmlKtWagPC1NXXNCVeoIEMaQgYLasFojShFLXJlK2NAw255K6E3smENZqTiJH7IQYQC54cADGFKkdAcH55CoqRlaw3TmtYashIHGvEhEIHQAxGLaERDHJGIethc5mREiCjaiHlv6AM13LEPI7FOX/valz3iwo7/cVBjF7DYi8MMMw1jvEJLpnAYGx1jCol9YhObqASZJoGxz7DhM2oqgg+iNzKSteYd8BhZ9mbzDtikTE4s4xP3bNOaesSDHvJYBzvGF40+uGgNUdBO+6QASinILz0FnIIUpoBKMKhylQWEGnoOiJ4EgpIJtKylQq7wNQtegYI6OYobHOKGzn2iMDXZFTOsobe7UYMa1agGNaaRxr6tJAeLSASwXOKgFOBqFZWohCUgAU5wPmKciCinOc+5mUZAIhKRgAQj3vlOQxgCnvCUZ7ls1LnNRZEQ5WJeG95Ai3LoQ4ut6+K+8MG6eagDL2WEhStM8QpmTKMZuHCFwxrmRsc0/wYyndiEJSoxJs7wgQ17BM0T/Bg9eKh0HSxdByELaUjVwEM1LyWZIF1TvZO5xpD1gAc+5IEOQYWDFm8wBPq2cAVpmVKUoyTlFsDwvlNCbZWsbGUB5SeQWdaSlrqMoAUzCKLuwKFbYy0EIg5xiVnVpBkk1Js0klGMZ0gjGs6QxjR60bchCEtCnlgESgpjDFCEghQd3QQmDnuJS2DiEt0EKWMlwc5ISGKy3ZysZSVBz3gyQp7lZN49y0WuffKzEIcwVxWpoQ/Yta4u92ita1vbunq04xm0cChgasFWZUCpYYDBKGOGhwo5cgITlqgMZhChuJKqqQc8kMEK4gHd6EIXHv/RVal1rTtd6wYykCLbLky3G8h50EOS6hAHOa5hKEPoYQ9o4BgYlopA+V0tPaicwlSpCgartnKUWg1NaH5iQaGJjTyQ4xYfglkjdTYiEpqQhTHYWrdp5O4WyaDbNe5mjVqUohRDgAGxJKQJAhUmjqQIBWQiEybKUOawiGVsY19cicvKeLKZPechOlvaz95IilM8BBBAxwpypLYuX/zia498j3/ogxzOKKNfemGNafgCSoMZTMMYs7A4Qma4lFneZ/hYhOaqQAXyKLOZL8mOeMxjHvZY8zyou2bomnnOZZ6uPOJx5ztLV7p1mcc60AGOb+yiinrQQxym9YT3jjJ+o4z/2hTyGzX8FnANT7VqekIphdA8RGhhPQpSKicHqkilrGJZZyQEEYlPtNEWwcAFLHAh0brhLRzesMWC/lYsl2gCQL2QRS1UcQpRiCIUw0ZxZChz7BUndtnMvoQlLCGJZ89Yxum0MY7vyWPmHeIROzhXH56BRbi0ec1FNvJr7eEPfYSjyblTRgptMQtZDGZKVVYFw4QnXMrYERGF2MMP0fAEH8jgOR6gszzQXGY3rxkebHZz+OoRvohT0uAUN3Of1yGOcKA3Z0YsA4qwAIYuSK2pr5xqFyAdaVWuYeVQWzlVpyo1TGtaKOAxUbWYgjmuiOURmpGEVBBRiU2IohWwsIUv/3alDGZAQxoorMWvhuCHFy4iE4VjhjFq4QpSaF3YnZAjKL5u7GSLqdmJXeyzzy5ty74TnOxMZyM0Y2PPltazjyhEDH78BlaEI7XlLvJqifzFtagbGbCgBTOyoYzcUXlK9O7t7377JRXvuxCHbq8PZhADFXiAA2YOn8EVvma3QFwuopdLWyAuD8/POeJ0rkslwREOYlQxD3rIQxbSQECXj1x+k1blffG78uCvwfeVrjQpQdlp8IhncizCHCHaRQhITFaxkLjEJkbhiljMwhe40IUvghGMXwjjGFZ/RSqiHvVEUJ0To5jbMGLRivifghSi6DqX7m/ir4MdxZygo/8N2/9izvZszjZjktVO6wQJiAAJm3FOOOZZN6ICPOBtzoBF9fBFrcMWGaiBsXMP9LBkyEALyDANTXIg8kYYjFdlvbUlJ1YZkXAmoVEE0bMCJsABGkB6a0F6+iBx9pIPbtEWGeiDptcWD0d6ciFxrCcP9vAP8QBo3CAKQJAGhSAHt5cFXyB8IwdVvAdzvydpUTN8+tVKmWY0k3I0Z8B8T4E5osZPjwAJ3nQJXlJip5B9tXB0xmALuqALwXAMypAMvIILC0IhVmAFjpAJnBAKtuAN0yAMAiN/81c8pqB1cXQ8X3J/YBImdEQZhgWAAQht0xZj7cRO4VRtDlhaj0AIj2ACdwf/FqIADjo4XjmoD/ugD7O4D7XoD63lD7LIZMSQDLdgC7bQeIzXeINhUcEFGRTjgs6iEJe3AprHARngRV3EFqmlWj0IhKYncbNYZkY4cdsIcZ4XPveSbu4QDW8ABFyRB2mQBmoABnZAaSO3e1r4SmCwclHQSi5XVWDoP1pAc5SCNGhgc9cSauCCCJFQCNKHCZ8QCnJIdLNgdL7wfXrIDBMJDRXZDLIwGYcwCZShCrKAC8cgDVGWDLPQCsBWYmEiMaTAJaJAf/oXdpxwbJtIXGc3WTRZgJEVCZsBTm/XgGdViqcYFocACZTQB8SARfuigUnJFrU4i/qgHOVQDtPgi794/yvGAJHchwtZiQtvI2/4NhmZ4ILO8wM1sAIkMGYm4AFuMQ/5AFv4Ug+z6Bb4gA9FSJewCJff2I3cSEnhgy/+0A5DBQTnuBXtEgd00I6Q1lT6+HvFtwXB93L6aD/8CB7eUS3WAhXgYlZt2IaXYIht9Aqw4JDe933GsIdKV5F2lUa/aAvGcDCydjcoxAy2YFGncApyRGJbR39fEnZzxH8sZlgCCG02eZORhYBup5OdtXPjlAc3RgmU0AnY4A5NKZ3SqRzu0A6Bxg3acA3OJA2L+Iu40AvgqZVZqZpbeSBRkiWKkQmNsAdMQJYkMAIdoAEWkAH12Q7oUA/ywJayM5d3Kf+XR/iNcjGdrniEEkdndLEP7oBeO8ADnuEUeUAHLkdyWrgpXPh7wodfVIWhADSGlaktaMgVhKCAkgBSlpCQCwk8AnOHvyB+x7AME2maSzcNqDkN1RBldvOaKDQN0OALs4BRkgiJpDB/WqeSEwMmm9AJlvgJHYUJ/7cJzGYJwNmJJDptk+VO8KRO5/QI8lQj5fQIzckKy4AMxLALu0ALtcUKacp1ndCcbdoHb9oHlHAK5fmdqvk2AmOeJtgYkzAIUoADZTmfF3ABFmABE2CoE7AL3zAO8lAPbHkv+OCfc4mX4OiB01mgqmdws+MOyAAEOzADWoEtopMGVpiFE1py9vj/mBoqfMJnB626Bq0Kq3YQB8ynLfrETwtWCZgwXArpmbIAb7jgC+JXDMkADRRZkdAQDdIgDcu0TM10YdlwDdewo8xwDMaAC8HzRnEopFqHf3PUCQq5pP73rUhKRyx2WM9mdpQVY1V6pYyggOZETqZ4ikP5pX0AOveKr/cKFnDKr6f4CHJgCa5gC7Wgmr9YCwKTO69wnqoACpLgBmhDAvJJqBQwARQwsRJwqG+ADOAgDoyqL5DqinIJF3hJcWg2nQaHcPqZbuXACmVjAtiyOGvgBupIaadKoYq5qu64qq/qqisXq3HAIlERLjxGWuoUCZyJCaAwCqgwh9/JosOQDMtQ/6zHiqzLqqzM+kzQJA3PsAzJUK3GYAzBgHVvhAra6ohcAib7t5tzREdMGqUtdq7R9myNNWPg9E4KCAnjpLf8doqFQAlfaiid2gMMGpgVNGCf5hmLI2p9gBSPoLDfiQsGS2/BVQlywAMekAEVMAEWQAGdKwESEAERIAEU8LmfG7o7QAnRAA7qoBb5IJdvSUlyMbKYirLsIA/6MGeXVHH54A/uQA1vsAMx4AHaMi00q19OpV87G3ywyqqtegewegfReweiFiPiMlo2wm9mVU5tSBmgMDx9YQtZGZFQK7UxiqzR8EzLukx2VZFdewzDEAwQeQzHMGXD4xhZsq1FWokuSf8xm8B/hWVYA4hY54p2Z7eudRtO4wRO5eSvfTBOjBAJesADJqACMZB5KiADMsADG7zBPfAESFAqGOQVQ3EJCvs2kXsgqHAJaCADHlABD/AACiDDChC6EeAADtAAOVzDOxwBwfuc47APj4oPqtdwblZxR3xwtpvEuquy5UALLrsB2KIxZwAGxquY9+WFOwu9ngG90pu4X7wV4yIVo3W9PakZ6lQJw6W0TOurvtALwWAMw1CaVFuRyWph21kN0cC1ycDHfFwM8Pu+wTALpKAKpNBGbxRHSnt/KKa0c3RYMIlinYBY6LpYiSVtc1tZ0xZO4sSGjaAI5VQIbzBO8iQIaND/Ax6gKKk8ZhY8ZhWcwWUDy0DAA7iEBSX8Nq8wCo8ABC78AAzAADOMAAdwAAbAAA2wADmMzDxcw8K7A7DwDeDjugg1cfNQD6BXuylLZ2imzZeUbt9ACWWDynLgBt7BBmugjl9wVWDIco2pxV7sGXcAxkS0B0tERGTMY3VnIzzHhglYTjqZq29YPKoQC0aHC3A8x1t7msoKTXYTrddADdIADcsg0XBVDMLwC8cAx4OsCo84PKOgkqagtPpniZa4iZsAyZLcpJggCYolpSR6wJNlgJJgt+76wIzwdp98I3BKys3FATDs0z5dAUFdARmQyhvgAR5gAibAXGZQBGjQhnzQ/8IvrAD5gQAzrADCPMwzvABbLcMNwMNefQIy0AapG51voS9LWY1c9DpJuRZtrYFM2ZTt4A7PUEVycAVoEERACwcs9wV9/QVcANh/Ddhc4NdfoAZqQAd1QAeJrdiKTQfSC9mRLb30bL2iRbSGoMA8ub2RAFKd6Qq+BqzGBA0LDU10UzenbQ0NXQ0I/Qx77LXktyu28Dtc0hhdZ2KkIBkRo5An1iUw+aSQ7MiWLMAzGaUvBlmRhRkLyJONUGOIEE/y9E48yQc8QAMZLAM/8ASBCQRXgAVk4AY4lCNPsThnUAQzgLlBPQE3jMM57ADK3N42zMMTgLHzLd8ksAI98AbPGf9uZy2L+2DWR5KUtSjgAy7g01mdylE+byoHaOADrbpDlGbYh13YgX3Yi00HFW7hic3Yjy3Z0XtEHk7Plk20hSBPeqvcRitZufoJhAy+wEp+MlraC43apz2jz6B0zOC+x2DRR/drnyAJj2AJ1/etHZV//uu/vBkZYGJ9lwiAwn12AmhZyoMZyN1ODOjc0F1PmXW3kIA4T7AC1a3BPSDmYw4ETsEVznJ5KqABmqve6l3Dbu7e7X2oc07nI+ADO/BjrPANsfjWA+rnBw7o1QmV5fANJ7Sd1PAMwECUcrAdRyB8KAI1hy3hhR3hi10HdYDYjH3pjX3pHT7ZgXAH9ExEhqD/Y+VS4np7gDg5feyHCil6h6yZ0MpKo6UN0cWK43x4DF4bDLpwC5GLCib6TZVACJvwCJVQfaEQdJ9wtEZufQk5R9bHCSba0tFmWVOKkwcoiqBsI/IUCPLk7d5OT9lLWjxQA80FBMzFwRv8Is7TXDSYuemNw+8dushM7zz83nRuqJp7qDzwCGQQAztQOuFgncgRaIWuDdjgTHrsDM4wpmV6pmXECsJWf835pvmKLt7WB4SABkcgBPQos0+zBZLe14Pd15Ke6Rbe6XeA6Zvu6SAu6vU8Wt6+padu4ptx7ZFgol7imQPtC8OQdHR8rBOJ0bqQC973tPALkbgAf6OA2Xmw/wnzBAmEAFJ54AQgBQmYQAiMsNIfZX3OtmwflXZqR2OXZdNuF3c3whUv3+3gDk9iwQeIAAfM1QMWdO5AoAQ9IBVm0AMy4O5Cbag3XMz0Lvg6rMwRgO8ToO9BvQl9sAMbEAPnwgpsSpSg06mwXDaZ5wGZh5ZHrShJ7flJnfkXzMoqAARQgQZSUAQ4wKHqSB6CPdgkb/KZXuGbvtgqXwctH+qiLgiCYAj7tO00r7cKHE5UTqIJGdBzWNBJB6NxMwy8LjB70QqsQHSxELnk6Qr196TPZlZY0AhlcGg2cgltWAl5AAfr8giUBU7U3oYzpuXhjr3ivmMwgkRqv/bv5K95K/8HgSkHfSsjcHAFew8QHCoMfMBAQgQHDhgwaNDQYcMFCx42iFDR4sWDEjRupNCDB4cNGSqRibHB5EkOGU6eHFghg0uYA1++rPDgQcsMNCvwcINFixQmOHCgQZOmzNGjVJRy4fLFaVM1UdXQoVq1ztU6dO7cqbPV69dAYcWKFWSI0NlCaQ0ZetTWbVtIcSPNnVRpbqVKnD6FMkXqVKtXsWwNtjUrFqxWp0SJIiUqlGNRo065cvXKVahHhPJCegSnDBYnMVTM4HEFDiIslRDlkSMnLWe2ceM+giTJNiPcuNfuPrs2bdqzZ/kM55PHuB7kY5UHWsuoEKXnlDbZ6qWMGTP/ZcZkRZLxUuFCBQoSOmiwcOHEBhEnXqSI8WJFCRRwjLDAYQ+ggQwmvJxg0/9/AP9jIEAC/SuiCCZo+EEoJtBA6qgttlCKiqac+gIqqejAasOrvrojEA+3Wm4ss3prLjcU4YJkLrrsmkuSS/QK5ZJO9nqMFFI60XHHTXis8ZNPOuFrlEjgyMONKwgpxAkffOBBhRie4MGDGXyY4QlE4HADDjgKUbIQPtpCJC5EEEExt93WCk7NLwkhjrg94ogjD+T0GDGsEzUrpBJIKumlmWmmaUYWSFSoyTzwGEqoIvIYUACh8hxiqCEH3rP0oAgwzVSCDiwYARNJKljAAQMasEAD/5VWOommm1ryb6GCEAUPAVoHpIGGFmjAoYYffMACiyyCLSPCpyy0cCo61Phiqg2p6hBEEUO8Uyw2TzwzN7hYxAuTFe+6BBNOKrlkE3J1DLITci9RdxNMMCGXXXdBAeUTSNxwggcesJhBBSVMMCEDFQyNwQMOZlBChiuucMIJN8rIoxBEwCSETEQMOTPNNAlh00s33xxOzj3qtFM5axnJlpJKPrFOlkdiqGkCCzro4IQWhPrhhy5y7kIKKZD4gQYUNDiooUkbqNRS9zbVtI8+VLnEBJsceMABFWqQYYcYeJBBhhi69jpgfz0IOydVTfJAJQ488KAGnrU4QwsztEAqi/8yvogQimONXRZZZjnMSsOuQvRqrA+XM8vi3Rix+Mza8FI3Rk4uiURccTlpl5NNgAQylFDm/URezjWXd/RRQhmFEz7ulQELPniIQYYZbhjhBhOU8KEGKH2QoYeD4cACEuPckCNMzmqTJLfbMjbxN+a99JiPOkksmRFIIn/cNk4gmXKGIqRg4/sumliQBhdcuBUHIrrAYxBFJnGkkUHYQKIFEiyYQIIJ8s9/U/Iesqi9CKDCFZtww5NUkAGbZOAJXQPCDhy4NQfuYGtb81oFRQM2DwQMSlCSAQ+08EEzhHBudIvQFqKgtwtxIUPJqoqz/gY4wQ1OLCIKiyBseLgSBUf/Y9iijVzyYpdJTO4SlYPcu9hFLs1pLhRJTOISQ8GJQqDhCldSwhPQ4AMTjIADLDABB2LgBBU8QAUyAELWhgMH4fzmEYV4BCNscxvFoQhjZWoecDqWFmoxpzkla4S41FUJQlhJCViIwxlwgAISUGBoDFhAeBSwgPNUigIxWwEOvMe+RuxBCjToVEv695AFIK0BUOQDHLSAhBV0wAMP4IkKeEAGIMRSlrOUZQ9i6RF85RJfPahBDWawAu4VwSe/wsIIlVKFKkSoQnqTCrJa+EwYxrBw0JrmDfWIsemZbDZjmots5hIjd7XrXe361ib0wkR0lm6JlZCDk7B4hj2MYAQ0/yCBQCrggF96YAUmmAHs+CAHN6SFD80z3huPd600MYKOwKmjWrCJsdwgIhOZmMQeuhCFIyxBCC7owAQYEgEFpKeRjiRpeCBZHkVNQAOVZMMgGqGIPRThBBYgT0TO0wCNWKqUe9gDG2hgAxrUJxKhiSUZEnYFMmCBDEZFqlGf8FSoPlUJU+1BVYvQJB88lZi/MqZSorAFMKDQKclaFlVWCLisdEiahZNhIGwoCDxBVI4WkwQkyoSIQ5SJRXX5VrvcZc5zvksvnpMXOkGxxM8VwgdAcEINilADDnBAAxXopNQ4sAIo8aAHcJADIuTwiEq4pVuWMKhBcXPQM901YhBr3v8hDnHNxKEpopFoBCL2MIUf0GcC5FGIAhLw25IG16QMGA9KKwWzDuBgDy/dAw1EIIFFkSen74GfIpqAByv8oAMVyAMjTODA0hyhCERgAhMOdN4D/aAI6q3iU4EAVTOAxgdHoO8SorDVEMZ3C1WgQhT8iwamMMVYyiprM124obWCZURwpdZDF6dQRDQiLhKm7YrEZQlw/VWwmOPEj2rUOc8l8bBAAkUlsBCDGfhrBSuonwMQoAAGWKAmv5zBDHpghjIU0AmUMEQhYvMIShiUtMczbW5kA4naqjZirnUtbK+FIkTAtAs0uIADwjMpRz3SpFouaUS87CjzPOTFC3GABWj/wAZFIIINkK2A/vQHKQcoQhA5E18NOoAISSiBND24Ahb8+2f/bsG+gI7CE4Bw1KpWFQtPUIIWnBCFJWwBCv71SQjREAVk9jcKcgswM53SzKgcGCsJbuu0YItN3MgmyY3o4yQaEQlLfCtyRgSsEjnHudExsXSl0wsiMpiBFchAIROgVQAomwEHpK1gPVABGopTCM5QQtqVoMQlJGEJbJdW26WdcISV7NrYoggSRlYoG1ZAU0YeoFSOerFvDyBc3yagy1l25KzGTFwHrEAKjXD1mjWwWwfsr1LvQ4QUnmqGT1TiCjFoYA8WRrcytAENnP0nH77kFpT1aC+kMIUqVPGK/1dIIg9ZOIJXP3iGM0whCk3w6n2xINYBK8vAgHMhqadpOEOcGtWMiISXypQHOPBhcpKANSa+VU5y6aVHO9rRrXMNpFGAIuqfON0aTLACH2RgAAgIuAMGUB8G5EQFJsCC1pzwCD5AghCgxQtesP1228Q629s2KJInnOQyPTnVKMqDEziwWwYg4ACDJykCDFCAwSde8QZQ/OATwPh3O5JW7X7kQiZQAQ7gYBCu3kMqK4CQ8eyBDyiHxChqgQpLZG4UODLFXygD8ljMoha4wIUvemEM3CtD99e5TjN873tlXKIMaYjDEowfhSlMwYQTokIyuVoGLkAf+mmI/hfSYP2phP9aQ3GgQxzqkIfvf1+a1JxWj83vY3FHLBKG4EAAAFAAEnRBW7Huq4YvIW1pW4wSQgLx6KRuiqibuk+QgZV6gAHIH3xTiAoIO615HSxQkoFio8fZBGqzhErAsHaxQLm7hLmrBG47MhBkHEagMCTLku7wqPIQPHULD8MzgMNDPHVzwRhEPMarwQMoABeUQVqBsUiplPEIOAtYgS7gN3ObLIBDmU94heowhmDAPSccBmM4BiecQiqcwmOAwig8hmNQBmjwvVqAg3vZAS7gL+abEGRCJi6gAqN4EKNIAzd0gzhwQzeUkzyIAzlgDT2gEzqBHjsZP+V4q7cyBES4IdXqo0v/mIQRAABFXEQFwIE9Oae92ARLiARGyII3kLZZegRLcAyOM4WOQ4VUAMVU8LhXwIQYYDcJeLcGcEEGgAkPqAATkIEnQBLOaAv8k7aj08ALbDt1sUAPtI1IkAsQrMVUCzIQfJxGwAIVsJ/7ga5GobeSarzEezFqdCQvu0ZIQhRKMQ/e8pQhrKgV4AALyABfqEIsHAZ0HIYrREdjgMJgCAZ3bMInXEct1MJkgIYuBIUtOAIHSkOlgAKAhIJjqgIv8IIqiL4HScjhcwOGlAPimxPhuUPWkEjkyIMYWg5AzEi8yqs0KxNDjAL3W0RFbAAaqIFCwIRPwAQXsQQ+KANL7IMy/4oBE3gDmtyBNNiEUTCFUEyFnQRFVEAFU5iEnPAAGGM8WvGoszGBMTIDJTADRBgilJE2S8BFo3Ocx3mctnM7vHgRohvGuKCEI6ONp1QNJlABI9yIhJCViCi8yWtL4cLGa5QV84BLBoiAChDCSKgoyJJHJ9S9dPxLeBwGeBxMwXzHwKxHxLRHfOwFPsAoHqiBMgxIMzxDLggWiEtIOWRIN0gDzWzIiWwNibRIwbmTjLQhJlMyRLALBhBJRYSAEijJPZAEQcCNNiIEMsiCNHiDHTiJHQACMvAAWtmAGSgETiiFUvBEoEzOnLyCCtiArXsABUCAAVgIWNwXDsACRAhGSP/YBEiQuw00uqtUF3LKSj/yRbwgOu08smkLxh66hEMogmVsMwfIqYRAqYWAS3gLLriMy/vMxkmRCPsMuLvcg37TwnSsR3UEzL9c0AVFTHWsx2Q4huswBTuIAiEQgho4wzJkPmTygi9QyKOQQxHNTM1sjc80UT0gNYwERCbLq7tShEyYggAISUUUABDAgA6oJDvQDdwATTLYTd4sI+kcgK1rRR+YBKoDwF1DhSXagcCzCQR4AIE4IJnkABmIQGjTA01clw0DT7/iBDD1K/EU0yGShPO0DdlAGbs4skN4AhWQrHuaT/p8RrmExi7bTzy1KUSJS5QyGgWsAQINzL9cRwb/LVRDRUxlsMdkYAZfIIQ70KgbuIGCnNRJPUOC9IIwUIM1BNEQbcgRJT46yUPjCNXASbCw2AO3Kk3TjDBWm4QOmFGRxAAKKAEbwAE2EINICIs70AM5eANYMgmbiAEHks4AGIEVkM7J2wlI2IskRQVSIAS1yQ+ByICB+aI8KIO0QDtxgYRxASxyIdMvBVNxBdN36UWtbLtbxIsVkYRDgAMeSKUO+Lfjuh/Qq9M6/bI9zVM87c9G8s8rc4BGsoAaGIZiIFhDPViErUfdi9BkWNRTyAJBi1RJpVRMDYMznNRMNYrLdEPM/NQ5jIM6GVXkKFU/DARUzcgW9UhWU4QGmFFY/02AEgCBFGgBFNgDOTuCETABlxHWmrCJDejNCnA/BiACBkABFGgABZjRAXgAH7iEeXGFVlCFUOgBE9iAVfoXK80aNEKDQpAD6hkXGEk6zGGXMAWXcT1bch2iC7xKbMtKbKOEyYGEM5CBgBFHCpgAhNiferVXvs1Xfd1Pk7LPWTEAFkQABkiGgi2GYkBQBn1HhB3UxDyGhv2FRygDSMPQiaXYMGi+Sy1ILthUj+XY4ftUOjQOOZmTFA0RtaIhkz3ZVRWE0/TIP1gAASgAARCAAAABEICBEngBIrBZQBCCG6iJ76oAw11aB/IAlyWCASiAATgACtCAC0AApQ07JwgFj/8zhUIwgQowFD4jDSdoDTdYOyCTREn8KyAxJ7O9HCARV7HNHHLBtm5l27bbBLWFBDioAQ8YgU5pxghogDYDuLT8wYf4wbScy7+1xuCiPJKCwcQLj4aN4AhNTHQ0TAsWVAaNXMlVBlgggzRAgyW4gRqY2A6tVIIMgzDwXOsbXY4NXdI9XTkB1dT9CgSTIZ6qIdiVM9g9hLKIsj+IgAUYPAFIABAogRxIgReYgkHYAzTYAieIoA1oy5+NgQFwPw1IgACggA4QgANIgALQABJwgAAgUgTwACdABFAwRZcxCRNwAqBzgzYgA0p4BEkcl3NJIvhNX3D5BDBlIiTSEVozosf/ob8hap0u0gALSGToaogAFmADfmQD9lv8dCTgys/olLcCyOTG4wVO5gVd+GRe+AVP/mRSLuVS5mRSDuVfiGBhuMJjCAZKKIMrcAOiWIMoMOEzTGGDnNSmCNE1HFEW9lg50YM4CBaQBT/BGbUZGgtAUNW1iLIpsADBM4AAkADdfQEQCAGcOQMzABM3AAITGNIodaAHUEQEEIIBiAAUeBRFIIL0OAFFwMEBcEFasYDHWoInyColUJKJSb0aQRch6QTpKJekMyJyZd/2DeR06Vb75UBsa19IcFOCkRnptQAKUKRGhuT6pJTvsFcveyRsNKmRomRLDi50FAZhAIZfWOlf/wgGll5pU9aFTp7pmV6GZUBcYhCGYIiFNKAbOLA0NPgCit1lg+zcKvjQ0fVlFxZRGF7DOfE+mztVVG1dQGhm0zSEHt6DGqAppO2AFPjqCxABGigCPmiDgWqDHTBA93sAYd0AABhjF1CACyABlUKBi+6ABcCDCHDeeVa3d9OPESCBKEiLMZGEIKG2pXsMUVi6HikXPh5beDEndFo6QFbohgYFTogEN9gXE9CAeL2AC7BojHYzje6f8ZCVjv7okC7p8Pgt135teQuPkxaGCjbMlrbgXwAG3abpmdZtYEAG4EYGXgAGXbAEX6HliDsDACtIFKbYEjZImEshY2Hh0Z2TEf/1Pg3ZitWVphuuau+26hsyBK6NgxoYAXVOghcoARfYFZ4YKD4ggygm0gD42Q0IyRd4VQeoACGYgvm4gAZwgRS43dq93QIggNgWj4IBk0rA7EsAMgvchMdgOqbTHHShNXOhcAknaMG67Erggx7Yp075bNC+gNEm7fG4CEjmRgRe7dam5ATo4t+SRml07Qhe3MgdBpTOcWLYcR7vcR+PBmcIcmI4BlsoAyc4imJqA+XmAuZu7kqlWJjrtKj40BeOQ1AFP7VaXZLlijqwgztAVfDmKfAWxOFIzUnAKCIAgyQAAzEAhD2AA6ZpoAeglaV9AyB4APeb0QiY3sOzACFoAAr/iAAjaF4BINIbvEEFOIC2NNJJ0AtJALJLABIhEQUduTV0kvRLtzVJv/AdsZ4YadMaWAEPQGSKHnEKaIlG3q38mS5G0egVv8bWfnF5e3EZr/XGA26btmlcz3WbDvIgfwZgjwZhpwZqqAZswAZu4IZvAIdwIIdw8IZscAUlAKslcAKi0IKgHmpdxtiCjO5PM6tgBuYy8L604hCvyG4a9nIwfysxD0T1AxdTeAVTMIQ7AIWXioQ86M4+cB0oRYAdoIQ3oF4aBYADmJkDGIAgFoIIGGPnNYALWIAAWAASYAADMNxaSQgTWAIhgsQmcgzEyvRMV2zH+BFLB+RLQAQtsJoT/+gA0JaZeE1kVB8IN3Oz6YqaFGckFqf1xpPBwXPBTM5knle8ahj6a7iGY0d2b0h6b/iGcGj6cCgHqC8Hd5h6qp96fbj6q3f2a+iDHvAvKoACB9GCNRhqTKVUFE5hmCMwqbA+phbRELUKc+eKGLphQahqGxJzqxbESXDajrMFY+iFWjCGVeCENPbnPnjFOTeBPqAE56xi1hxj0C6ADiCBMWaAeb6JF2OBCRiAhHiAit86A5hOB4gBPhAn07m1x0D9zwmxSwcdkfd41A+dTqiEMygCGoBXUqdoGYt5mZ/5jaiI/3hkfl1LR5LxHHRBAkj+n/95yEu8cmiH54966I966v+v/nIgB3LAen3YB+7v/n1oh3DYhd6kApbbAqOIAjAge81t7rQnMAtZ6uuDppord+32iqkOBO8WBJ66jx6OBJQ0BYBwVctYs2bMlPVKNWoUJlKi+myo8ODBG0qdgDwIMGBAAAAdAYAE0ACFxgEPBiCowJFBBQQIGLx0qcAASgMuGXhww2nhwlChRv0kBdRnKFCfPhk9ipRoKFFOnRIVSrQSnyc0WpDo0EGDBa1bLYCtELYC2Qlmz06QECEC2okO3jpgwGABXboK7iY4oFevgb4GChQgIHiwYMB99x5w164duXblHpMj97hcZMrhwj12505fO32e94H27LkdN0o7fET/aRKFypYtUaJU8eIlDG3ZtmfXVvPlixrdvHsD3/0lTprixdWk4aKGDp06dZiriUMnTx09ddJEv6PnDvU6d+7sCc8nEB/wd/gIQhRpEqhRqGL5YsasmTJfvV6ZYojJ0psYGx5sQIlFnVDyxgYcBZDgRwomyIBGDyAQAAInoRQTAgUoMIABe1U4wQg8FBJKfqMIRYpUPA0VilI+9TSKUybCaGKKkFzxAw0rnLDVBReIoJUGHHBlQQZjkVVkBWephZZZcL01V112KZAXYn0BBhhhhBl2mF6eadall1+Wg9lkm8lDz2LgdIONNu6EGc4zbwDhRGuuRTHnbbHN5kUVVFAR/1ttttEWxm2B0uYbcGF8IVsYczj3XB556PGoHI8+GmmlemCaKR96bDqeIYxAcskmn4ziii3GzNeMMbjM4soon2AiSR9keGDCBm+IQslTue7QEoMJhqTgSxtJVOFLDSjQgF51RVCXAi85MEMj7qFyiiqntDKKKVKZIqJPnzBF1K5OqYJKfqFUcoaNV2GVlVc+XgCWvGWZVaRZa5klQVoTRPDWBE3OdZfACExJZZUHI1yAXweH485l4XzjjcTeZJPNNddUQ000zzwTjTTUfKOPP/604041yBBDTMfODCMKGWQ8AcYWU0wx5xZ34ilbFX7SNkegcwBNKKE+/+yznrMB3f+oHnIw3fSllEKaqaWYQsoHIYxIcgknobyHC6ry+WLLLLGg0okkhjwixw4xeEAJK2+/nesbtJ70a0ggbSRhS8bKtcBdAhwgwQkkSOkAAgrINcEJdoyiiuOtnEIiKgt1y9SupDR1ebn5cXLIEz3YYEMLLQyelQg9bqVBvPFaYOQEriOprwSz9ysBXH07SzBie/2VMMIbanmAMxenjPIuwAgDDC+8AAPMLrTQkksuvBBTjcj5sNMONsQko/Iyy+DySBk8+DAzzXW2lrOeOw8KNNFCD+3+HLi5T5ufSXuXhxv778801HlMilJO+x8fDAEJS2yiE42TBS58YYxg2KIWspD/hStCcQlJUGJWQNgBK2gBCw+y4iFv2MHaTPAABiBIIwniiEfkshGXDEAuCDDAAg6ggAugIAIHQMAEOCAwBozAARM4giQ2IYpTPAVGSIyKT17kEM2hYnKRUBcNbMCu0pEgi6jTgOp2RCQjgVFJaYmAWt7SgDM2IGBR2l3B2OjGveQiGdY4Bi9yAYxf4NEXDfSFL3QRPV3owhjHqIY7/PEPfZgMGQeRhnxaUYYrKGEJNGuCFLaAhjKUgQuKsk0V4BeoQQnKk4KiX6D6tKik3SEObiiOG5oWQFcCEJb/49TVIJG1T5BCFa+IxQRj8YpXqGIUl4iEIfqQhjf0AXqi6EQH/1lRIDiV0AMQGoAAqFkSlGREIy7Z5ktoEoEdLWCGIxgBTBBAghp0YAQTeEAGdmARUZDiFEiE50JiBE8TXY4UUUTFJwrxBBuF7io4yiJBt/gjL8qrdWC0l5L0tZZ+obFveEkARaVEUTcmAC8TzagCjhEMZlgjGMF4oC+CYZ9eGKMXrLKFLbxmDELW4x/7IEc1iKGLWuAiFq6AxBOiIAQc0GwLMkNDGjKpqE8KzTbvg99tcAO/ORyBCk4NAx2Iw0o59E+WlqKU1LoaCEMQQj2VuASpTJEKx6kiFaXghCQYYYgykKEP1KPEBmLgNgK9YYQx2KsJPJABDiBgAAXQ0IQeEP+sGMIwQggYgQWaxcMRZGACCIgADk5wggsg7gEqgOsjjhjPU3zWFKI10bZiBKMojiJd/6yiFVuwgoGWTgQjSF3qWJfQeS20oQ91wBklKrDfRqmiUtLLb6GkALrgNBbzaYXjtlWUT3CiEpBwgx4CgQhOdAIZ7TCkPsjhjE70YQdO4IETnrCEKNygBjQDAxjQcMk0JGqqPSOaUt+3VE8uFWhQ4FmhjMM//rkygHGY5dSohik4xIEPVgOVJBB4lPZ84hKPYAQZgPAGWhSDEv6pa0UyqMEd2IoHeiDns2CIILy9EIUDiNc358KCC3DAAghAgQsogNmXPGAGTtiBhTcRz1z/RlG0Qt6WPD97ClOU6xOI0MI/V/CD1roWRyhAQRbHuRUfcdG2tyWLQhmar92iMY1+u8uTxnxcMwuszHVhQg1iUINapMIDMlCBCUzwrg6wcwQrQIIciFGOfdBjH+6gRjWk0QkSOsEJM0jvCtbbXve6QQ2hjJ/RFHXfnj0V0z8DVKCqGodPF+fTA37Upx8FYKiNeqt6wIIWtOBeOOSBD5GIxCVqzYlPbOIRj8jrG2CRC0qYQAY+qLMHdsCHtEHTBHCKSAZOqGKOFCAAKlbhAUQglpZYAAUWuAADJuCCEFCgAQU4XAViYAIgmAbd+tSnucwlZHnC+xTmUoUpLsEHLRTh/0Y/+AEOaMCuFbgABaWz8myxvLrbgiUDGSDLwr2slt3ytrcMOKOaK06XMKPxAluZQAdkcYkKAGnbO8JACCxAghtIoRGWQEbI/MGZbnijGswgRRmUoAQnCOEGKOhCF9bwaDfAgQ61+VP9iibKpg79T07lNHNAbZw4ZOp/p+Yq1UrNByw84QlYKEMr+YAIREiiEpLAxFEwsQle+7oTbmYDDpTAgzlrwWrHdCcQ/kMWD6TBhBsh7Ew+AgABKEDGDsABBTpwAQNMWQQR0CYCamUCi/A4rqJw3D6DbAp5x3veo5guvmXgZH73m10uCLhlSRCCdFq5tl7c0Y4U7nqFu44CFP+Y3cPXEnGM4z7MF899CFpQAhrgoAu9GIUPfAD8F6TgBTmwAQ6K8IdMkGIZ5dDHPjwzDnJgIxvW2IQc+JAHLGBhCWBYwxpcg4Y1wCG+U5XfpYM236K9z6lF7xkdkJOGUecB6l2V2qUyFYhASA0fdJ+CFcIhfF0hIAIkVMKtuQcpdMIIAQErwEIfPMAI3IAL3MCIVQAJuAAL1IAS9IFpTIREAAGBiODeMcjdJMgNYQBmLUAKnE4DDMCzbAAQWBglbNAOIBMlWIvlvRu8VYuQYUIhxMEZaAG/gV7ojU7ATRkJEFzBqR5CJVTDuZ7r1N69mNEZ3V6YyYVcYByTwEUQ2ID/FeDBFBRBIRhDKjzBFPBbEgRBEuxbEVxXKCwDOVAfIrEDO0iGNVhCGshBGmRBFjzBFpCfzAiVz4GS0MjPz/xMHbAf+ynipXka/unf/kmKHOxfVwmggimYASICHxTCI4xVWYUCKVgCGeyAKEzgBoxAzrEAF9TADRBBELjACLBAGjBCFtjKBjxergjICJnAAHhEgghAMTIIAZwRAVxACYTABQwWShSbDo4QCQHBI1iCKJgCKmwOKWSjvFWLvGXjKERCeLDBEe5bEvpbC4zeCgicE46AOxpcltnWkLxeFZYF7enLvfQLGIYZGPrjbq1F8OFBF0zBGWABJKQhGnQBG0zB/x50QQsUARqI4iY4w2ZUXzuMw/WFAzDklTG1QRZAms+1Rs2AwSgl4ikton253yM6YiQW3XMwR6N4xx00yncsTdNkYqRsx6NwIigaICiqh9Z4yym4Qq6oYh/EwAzYQRRAgSCwlyN0AQ7cAAtQ5Q3MwF4BgSg4k4c5xRtAiEYAxgEkgDGCRAAoYwR0AAXs3QPEgA5eRFvymEVwow/KkzYGoZBxQiGgARt0gRSc477hQGD6m7+NXjuOwOBYWZZxURclXD3Cnj3CDlr442QyyUNZ5gQkAR4owg90wR58YiMwQyqgASI0QiMcAhoUwiV0QilGA5m83DiAAzY8YB/0ASYFIv/Q2YHPgUEXgIEd3Nf6MYojzl/REadzEI3PJE39QEdMOsd3yKR2qFrUSad2xFpPFiAoPsLYgcu2tILXCAMv3IIoAAEWnCYaQAIbsMEgFEFg4sALuAAOjNMMGEIrhJAvxk2BxACE6EUCEIAACEZHBIAANMDhlUQFeMAG9IEorA01yqUPfiNaHZlobR4cnAFfIsG+XShghh5hkl4WIWbBLaY8so5jOuZCHYkYKYllsgWKokUmeEIpfEIprIJalYIsNENC/JIEvQJL+cIxYIM77IM8dJc2wBwx9IEcEMIf2iYcwEEhroEYiIFvLiJKyk8dzJfRhIFwQmJwuo+V4o/71F//bzCnTDYn1fjP/0BKmcbBpHBiIRQCIRSCAo6KtpwCfCiDfDDDMcCCKfIBHJznICgCEwgBERCBEeRAEIRADcwAD7gNLcCNo4ZQJ0iqgejnRR2AghzAYCVISvAifrYlEISgj+3Tu6kCc11LNpoCJ/CBG5zBGUgBEhgBoRKBEPyUVNbArdbAa8GWFnlFiHZR65FosH5RWYSRGNkL7FRALyhrSvWCMiiDMRiDMliDqkRrfUBrM0ADN4iMy8UmNUzDAwpgK2ES0MUB+a2BHaArmbbkIwZNcoYSux6nlnppcAondCyHvdYfczSdKu1PqUGNdTRHHewPrBHgISBgJFgC2ZEI/ynMQjDcKTRMwzRYgzXowgNSAh+cwSQ8AQ40gRUYQRAYwQvggBDwQAyUYCvQgvM46lPAAivkYksE12FcwOIJAEgU1g68ZVt22CegVRTVZakyVxQF0xS1qhYgAawSARMQQRHU6g2k1626gK6eQDs6IZYtJusJSbCSaEKZKBjhlpF8bQU4K7Q+a7U6azNkwzTIhzIEwzE8bMj8wyGRwzU4gy+0ARp4XxygAfihgag1KbragbpuKUtiKdLYF5UOp/yE6b32hnDsRm8Yx9OVWhw4R5jSgRuggRuIGh8YbCE0QtbM6SvMwkAwA8RO7MRCg6NSghtAAhowgREYgRVYQRAEwf/ICkGiXUEbdAIuDAMweFDLvg2B6GIGrJECFEANCYDfSQi6gRgJvQECkYIrpIK7PQ62UF4UfQIfmIEZuGqsxmoTKC3TBuYN+BvU6mqHGtTVSiFXaK3rcdHrNSbChW3Xii19kC3ZOiszTIP2McMvjFS0QkPL1QNnUEMyjMIR6G0ewAEWxAEcaK6oAe4aGOeXRuIEu5+gJC67UtocAIe+1p9wdHBVRW4aVBVMPodu0MEauAH6kd8dFIIgIKAtKewpvEItoBTETsM1TKwOW8MynMIjXIEPTEEX4EEijAHtJgERHMIebK+CbQIsqKwyEUgfvEEZoEEFPItNHEDeoOADmID/ucXlJoSC49TT5aFVz4rWJpCBGTyBFkzBqxLqFDTB0tIqe/ab+apjO6avPCbcj3BAPXJAIAuyIGeABrhe1iqc/CpykYBFLcSCjk7QK0wQA82CLUADxcLCjt4CL2BDZ1wkNuxCGhzBd9xB4JKpB0vHlF6wBnMpch5nGHSS0v3JKdGGlXIaJALKvVZuGKjBd6wyoniBGsyBHXyHIDAC1oydwr6HLfiCMuBwxFZDNVyMNfyCKIhPDbhACcAACMBACmjAFPiAosXBE/CAO3XQLrQseMHJhM1ABcjQ3s1gYJnEfxRbRXQCPFWez8qbL7kCGReCErBa0WrBqzYBFSwBrTpt/0LjKlVOGZWNE4hm2RS270QHKyMrMsKBFmhpi7udVSu4givAgjBAQzDAQixADzV4MmdkgygowQ2oa6N4cFUJHX5d8Psxikq+H6FMleFqmijl1yPmdFItykzeQSAIwqdEQtZgwj2rQiww852WrjRMQzRjjDVIQzPEQhrIAAq0QBAgnwtIwRPwwQwgAhM8wXi50wfBgi/2wa75h8JNUwxNxER8MY8hk6RO3vWecVP/kuOEAhz0QKsKthFqwWsswUHn3A0kdnpRJQs0NDymTkQjsmNuQGVXNkWX6EXLr1BoC5L9kizEQmj/Ang2T8QyQzIggza0wz643KCFVw0EbEzLNv9zJJ0oPVWleUHQ8DTS1XbPyNdJBrWmHdWkZSkpk7JRfwrWVIIYo4Lo4kIw/MIxRPVUF5o0SMNI01wM+EAR1AAODEJDMgEiwAEaMBkc+MAOJOgp4LVp2EpfbUCzPQBZVHYM8NoO3nMuQehe/9JHqwInmIESVCh6DrbMGDSt5txi10Bjv5Yei0DV6si2KdwGBLJlS7ggU/iFv7fWajbCKStK4W+1ri00MMMylK41VEw3qMPI6EM57MIGsUBsM+dsz3TPCCelmeSi2PaiNJV8JRWPc5ptzx+O089MNmdRG7UgGDPWkF0uwcIszMImD8MyQINUWzc0WDk0DAMrWIIbYEH/FDSCGDgCHgxCeCDCIXACHFxBGsSTRbDCA66NuanADBBbZZ9bR3ZYJ3i0KvTztVgLWvGzK6ACJADBFaCngAu2zETBYRs4gjd21E4ZFiGm6mVAhQ9ypVs6B1y4sG64vOAptpbulUu1iE+DNDwDiT+DNGADOIxDPviDO3BDJ5BBDKhAHaApqX2aB1epcdr4KPW2cM8yph2ubQO30eF4TserIxL1//2fIIBiIyx3KVZLKzS5LgzDnZ56NESDxlg5M9jCKWxCJNiBImTCIAzC8ykCJzzBFTCCLbQCEJABJTyChdkgCYEYnXlAPSPTI4QgD7KUL5WL0JaLLgGTK5gCIfgA/xYU+kIeumsU+KIrNFVi85QxYek89lZc+sVbumVjOoW7r6/+iMdrQEEww3VD7JRTecRGLKhjOzikuKAtAzR5QNSh6a3ra64n5yLm9idZGgYDjWys5M0fpytf2lEF59HJF32hZJEHwncY9RokWAI6mBiTgkfPwnMnwzNMObZTgzRo37SeAiQYwiQogiP8gSM0ArorwSPIgniujQwAAdcVRxaULNt88Rvou4BkECXAR9jMgl7v0y+9QgXJgQ88ATkWeqsiukEruoE7bYKzgKPTGOlNLQq81uh1YGOrgAqM071b+r17wIRX9oRbOKWDvCErHBdNQzOg/P5aA8pb93VPw/+Uozw1gMNq60M4sAIQ9IB/5GT+yfYpaelN47xOs0/QX+mVIqfRTekmGa77/fiO67ii1CQqkbIgHOIeEEJ2WsIjUILUE+Us/MLDSjWhVYP2ad8xeLscHIKsVcIj8IDuysImXAEWKAENzEAZ5EEa5AEhFNXu0zfeA0SnTpQMdZrlC6EtV61UNXT4CqIqTmieYNmzh03GjGfAgIlCZUlIISOF3LhRg0WNGitQtERxgoTLEydQqJwxwyYLFSN4jvDAASgHD0N/At1QNCiHDUmBZsjQ1GlUa1OtTbOWjaq0aVu3QrMqDVq1b+70uavWJwuPGBv0tHXbNk4cOnTU1FUzZ07/Hb14884JwzeMFy9hCAeuMpgw3r93Cjf263ewYsSKAwuOTBixZcSFvVQ5PMezl7x3SCfWW+dOoChR0KyJw6cQJD6EHlXqJOqUKly9jDFjprVatmvXrk5VZktVHzKPCAG5YkoWIyxYlhDBAacQFjeIGBl6Q2ZHn4G3RVES1epgsGC4Yr1a6FAVxFeqLJXRguYiRo1sxIDZEiWkJYQQcCSTajDQhZZgIoHBmUjoaQQTVGCBwp1MMIEnojQcKigOiWIKxBCPGeaYY4JJyBhccLEllll0+WUWWIpBhhZiuCHHHXeIoYSRPdLowa08hHxLyLnm2gsw0fhK0jLHJCsMsLzq/1jyL7+qqJIyvzg7LIy6vvhSjS+4sOvLMjELAzXS7kAtkEBIC0QQQuQkpJBHILGzkk06+WQUU+KTxRZfhmEGGmiAuyabbLzBKpdHNmljByVASQWLGCi8YIQiGmGihhnKkEOON96ghFRKxhPFFVsCVbU9V+CLTxVXUJFtDTgu2o+NM/r7DyQCCzSQhRtoSHBBERgUQYQOlO1gqAw5hNAnZz8UatoNrL12g6i03faUU0g5BRVSTEHFFExC+cQSUm+rMRpsviEHR29YeYSRNbIgQ8h8h8w3jrrmogwzJQFusjEsA4NSyyoTUyxLwP4SLODByFSDrjDtIhNKNUkbbc06Av/Zg4+QQ6aTEEPspCTPTkZBJb5acAlGmWSegYaa4RIdrpplbqEECCDIzSKLLUZgYQtFFPnjjyUKYaSPR0w91dRTZlFRF1tmiaW9hlDZ2r1XTJEtDjgOuVWjM+wQg1eRRCrpJBeETfAlBuV+kKcOoPXJAwiJwntDDY2yNkQOnAoqqk1AOXyUc0GJxGlKmu4EFme26YYccODF8RkeBbGXDFD1FTKuuC5O2MmEIS544coQRv2vKVN3+C/PDuvsMDDBrIuLMsP8EmIpN15sSo9BFllkOQ1hBBJKLNlkEz5ze8UWFYdJxqtqhrummmqqYmaWTmI5BQhJKjkQkEEG0WQPQD7/CWUT80R5/31TYQl0RRZbVWXrbt1zhRRICNkjDn8g20bOljYBrQ1BNRgW3GbiILndDYI9GYoJ+rahwCUFW9ZySiY8AYpRgOITnzCF8sxzi2Vk4xvjGIc4WDiOdpAjHLCglx3cUAYgEIlfobsYlqgEsMCQzjFnKphmBKY6IBZGdoIJTe7ClLsvccGJT+QCl/iyF8FwTBCBoFMhCrHFOTECT5YQY/NWBpEW6WIYyzAUNWpWDWlEYxpgscYwTGUIJxRNEILgxBoqEYpOnAIWtGAFK0QxyNtEzxe4mMXVXOEq/JmiW41URSiYwwc4CDA/GrGDHfzzkQD5ykAKHJZM4kYC/wdFsCcXwhBPLkQUCnrglR5CSgaXshSlOKUUmtBEKUrBiU6QAhbIoIY33NEOfbDjHOZYRzrOocJyZM4QiOCcE9qyL9Dp0F9VpNJfUse6IQbMMKG5Eu2IGLFyVsYLXEjDOstQhnW+s53t/EJkqsiYzoQhNXCCUx7zyEV/Lg2Mj2jc8kLRJz+9Yha2+MUxnvEMrVCjGtSQRs2ykQxa8IgRiFAnIfTwx03QAhrE2AUtaAGLU1iCFb7QRSIXeT9ymQKmDvkEIgphSUxmkg1n64gB11aSA+FggS5RkCkXJCEVHFWVRj0qUpNKwaRW0G8X5IAnJjGJT4gCFsmoRjhypA99+P/jH/+QRzrUAQ9zqAOGrHjDHQCBhiw4AV+fAx3ojESH0wyMh3g5J+kyYxnZiRMKVDjM7PwaGoIJhgtUeOc747DYxaKuL/dk0z752c9/GuJ43TkeJCpxCU6AohOhIIUqYDGLXPxiGYSaaPaowQ1vLCoZsLAEIdaZB0aIghSi2EU0dtFbYeSiE5uAxYlYysj5vLRbDUnFJhrBxQDe9FZnE8OuPNlTk+AAqKMUagMdpNSlfve7qlRBU1UJ1b6FSH7EoAZXyeLVfezDH/Hdh1f1oY6yROMNeuAkFshABiCACsBuCB1djSQlLU1mSZA5Z1+VWNi/UkGwVRAs7f4qztlJGML/7mynYzlMsMScaQ5qAgQ/ATHiLI7Mn4zIgx7o9IhIdJYSesJNK0oLDGCoURrSsN5rF4UV7pVHD5SABSto8Yxl0GKkuWiFJURxi2H8gqXtYYgqUgHT5OJvE5Dg4h4GAV2MbLI/nYRwr36FXaC6AM0ogJuCZgJeN795vOR9qnk5xBRhegNH+oCvPPxRj/jKl744ckc5dvEGKNhhC1gAghP+C2A5uGGdoZNLXfuipcckmJvoPKwSuURhTnuGCoGtAhRJTQUoismJiQ1sPLPAaqC5Ew3r/FIY1kBrWnthDXPItR3YWuI8ltjEgvjn0tLghjzAxk6RMJnybnMKVpgWGGn0/8o1eLyo4VTlGO8j6S6WgQxg7AIYtMCNK3xxjF9U7Wru0RpMY4o/TESipns4RJfz82WdboFXHyHzdXEgrBqgGeAscQmFYgBn76qg4HJuKp3r/JSn0Fcf9JB4PihuD3vQIx7ssG9ZYBiObFAiv3yIgxyE5Dl9SVrS67RrHehiV7tqaS5hOrBmOMNpUpP6S2M+NRQ3vNiel6HVQMf3f+JZBiyUwQ1nQIMb4OAGp28BDVtYw9RrZYc4WJ00vN4DnLiI2cwyAoyQuJNAISE+S1ziEnoKLSlYQeOpBeMYyzgUohKFFWtIAxkjLem2c8GKTaDKGCPyhdVg0citVRkVVY5Vuf8kQVM+HAJpN83pdHcKEjKT5AZC6DdKUMCCzq+AQqEXPQsiNAILlR5DqmSlnDXUSqgq5Vr06LM85FEPesCD4v7YBz3Y8cKyuCMc1IBGLvqQBiHBAfnIJ3kelh+XSMeF+XJYub/+VRgyUYbmmPlrqU2du5uXiQtFT0PR2/nqNGQBClGAwhKOXgY0uD/pZzhD0tFQ//pTferJjwPI8jMbfwaiEKIJ7OxEoApQ7CRBfNJOIEIBN1jBFWLBFnQBZqhHx2wmG7IHZ6LBGYhh23ZhFlohFnDBGJ5MkWLhPU5hXGBqaxqC8Rxv3roMEPIDzKiLCqoL80wCWEZPB3UQlZhK4Vz/j+EyKB7eYR2KUB3UgR12r/faoRya0B26wRuuYRd2BghWLA+Qb/9GDsDyIHQYKw6YLw9cjvrUgDPK5AuGiJwoTMJK7ebGrPsSiwqyIPzmsAzUiQuygArqcP3UbwmiAOrszwwCURCLrv6YbumcjumOzVYuAjYK4RC2CBEM0E7EjhLF7sUwgXk+QSBw6xQecGpeJO6qB3siynqwwRSrwcicwRmWYRh4wUR04RZipBW6BQW7BZJYRhVG4d1oyhHN56aubgY9ogZ7BZRwEFhUYgd5UPQgpEKW6kJ8EAiD0FrmgQjlgR1WSBza4YXKIRy4gRpUERmWYRmKYRbe4Ib4YA82/yku4MDRUM750iAOnC7m/KUuyhBMGoPTIgzCQO3m2jDU3DCw3BDCSi2wVM0P1Q/f6k8LtEAQB9H97G/pDtHp2NGS6g02DoGLDsEA74QSI8EjPzIBMZF59mQUvgUEW+QWeEHapoGNssclTREbhOMbk4FEhgEWZZEWS5IWcyMXLyESEAEjEcEX6y0dwayTVoMYSeIGTyIHk5FChkYZmxGpoDGWYCka+4YdNE6F4CUcviEcvKEanAEYciEXlqGhfuMUIgUYNWINJFLAGsv44HKxducLdqgwboeIMEwgdQ7ogObV/BIwAxLCoCAgoeAIDlMfqeA/VoMxF9L+GNIMsCAQ5f9P/pIOESdS/4bHETMSEToTEcaO7MSnEjwSASXh7C7BEkRyfXDjFNzutOLOGaJBNiHKJVnLyIpBGEbkJl0lJ3UyuVJBFyOhufhAKGGQ/4ry3hgTwnrqVwzkJFDCKZ2SJ+CMqZiK4TaEHMrhcrryG8ByA4EhN5OBKqYhGORgBpRgk/ZjDS4T0ryQw7yEYvxFYXSnsMasMO8TMPPTCZzAL51AMA2zMI+AMAkTJBjTQB0TDbQAC57gCa5AMs2gMi2TPd2gNfbv2EiGiyKREk/GThCwEg6w7BAQEhiBEiSBEjDxNprN7VKSGMxyNtkIe6jhGZChGHDzyXLhFkyQXLYGpr7/JblQARR8shEOgTiFEmmGBznvDd9sUCmN8UBOIjqTsSeWSieos7yu0wM2gBu7EizfSDZV0VDkyBqaoRlCQQZmIAY2SU1piD3lEuXeyS7o4h6t74nyccwE1DDxlDDz863200/99D8HNNQGNE/7sAmYQAoSVVEXUgsY1FGxACIj1f5qCA3iguRmY04isQA3tXEowWk4lRHkoA9og1QsYSBM9X1YobRoIReIIRlikzYjKhqWIRmEgRfGMhZ5E6ZKEhW8hRZN4RN8UhHGphGKM49CJn3UNMzEjBh9pTmfM0qlVPRioOAQDrwWjs6spTu/sUaTIRnE0RkKRVzJ1BZkwQli/4CC1pRNmw4R3VHSIG13wgTC5ukuxYQKlEggBfQw91VA+bRP/3Q/CTTUDpNQC9ZQiSBREVUKmIAJtIAJGHRBp+MhyQ/o3Gn8ykALL3ROApBTN5VUPrU7wI4R3kBUm6ZxBEp5ZExVYeEWgKEYliEapAF74ggajKwVYzEWZnEUPmh5SpIUcutnP2E0EeEPDqFYjRVZAWFN+6M/9O2TlPJZVUJqoXMZo5Vaj+pqr3XOKshapGEciyEZfMMqEmUqoOE4ZAFtQYEPzmAhMRMOOIzDUE4e5XQguSBgpEiwBnYwB5VgB1TD+vOt8tNiK5ZwgWb8gGYLjuCTluAwcYIHHpcHfP+AB6DzJmaABWZgQipEQtCUWmXAc3eAB3oACHpAdIGADNpAVN6pDcavPfvyXkSlv96gD/pADshAVESlD5itkFoByYihW5OhGMItRljhZ0XBEh4hBuJAEDLgAdKARJ0Gt4JVEfKjEYaUn0JGEJRWWbdgp6qLOY3xOaE0WpPRSrfWvK7FVWfGKqhie4zhFRLnE6isEiyJIiCy6C7zHb0wHqVPTnGuMqoA1aaoMwD0MDEsT/G01QCTP/cTaBiYPwX3cBvYCZ5gcQ9zCZQAg5VgP5/ACXzABwzTB/Y1hAn2MJ3gCpTAB0x4P/2rv8qgDR6thuKpDYDuCnxgB6gVh8cLlmL/YAduGIcLjod3oGdGZXdZdRd4gRdygRZaoRWIVxRugxRCYZ0YoS0woRNcIaGGYRaENhLorXqB8tf4oMSWFgxoMCmXkm2acnx1ELyqNc6u9HytpaHWtyqagRl6QRZyERRKYRJeQRZAAQ4gtJ3qj/yKrV278Pni0Q0uhi7/tw0ljFCPwD4JNQ4buE8z+E//UoKDzi/jyUBXYyElthAptP7CBg2Sz/2MbjogFQvuAw062AncIJYfDfneDwuuwE+VoAZiAJZgabyyJQMqoAKC+QEeoAKKGZkfYANMYANi4A3+iHd5AdyEgZrBUxiijReEYRiGwRfUI/CU4RiYwVuZ4RZC/8EnzecQIgESEMEQ8ugitFdZy5hZA6RJTSKNoRUZ15gFfhhrs3apUClDBCcDNsAqpgEamsEYoqcXVMEURsETSsETMqEURgER4GBtsSCW389iIe0y4daxGNlL0EmKZAcgJzkgw0+BM7mTVXqBG1iD99NAuVdBp+OU8wUdKfMM2KD+nkBBnQCDnwANGDd8TwInboIHlIAHdoBzcThLHyADhqLgPEAFengHbFd2S8VU2S4WboEsXfFbl2EVV1EcxxqskQF4a7RGicFVZ8R3j2EWROHd6G2d2dmdk1S6KI9XmrWe73lq83l8fxiwwQuC8iagnWIDwCIY2qOh/WQUXmEVPP/BEzTBEXrpItzgCgZ5UhGRnSzWo9spXjGmMsAvYPQSXwnVXkt6MAf0CN4Kg1kbhRcYg/cTcpVglX06gz24dD33cWtABnhAquNsgnrZKSTEBIi5mXs4Bkz3qk1VIEyyRQIlGIzBGJTBNwilusW1UMbaGRqqocg6HMURGcJbvMc7rBsqZmmhE875Ita5EH7tneGZ8rq3WZ3Vnp20r/WZfJ1xlfSGsH1CoDegFnLxE0Dog0pBFlZBEyZBEzgoEw4hpyPzlSHyMsVvs3vuYnUHtAXDDDeNwWYH1aSIIFUbqWfgqFHYB2pgtwGbWitXBtYig3p5mJmXAYwZmStgmXe4c0D/xVTgpxMRCe6UgboJxSu4YityzKDFNcdyrGahQTaj4Rk0UBWjXMqj3MmjoSWzxxS/gRu8shzaIUeAjxeCqxKmdw/Ejqay973juSPEbHHpm6/vG7/ZOLzuplkKe6APBxQ8IRUie5dKIROOZpciOlfYVkGBoP7k7/7ak8Ms/MLpsi7JMLTLRHbAibA4zV5VTU+PwIMPM4RvIPRGQClWyQOCOcajQpidopifGuGAQMPkALNI9I+SKxZqIXpIpESCnBlSi1CMTI0KZWawG9ijgcmbvMqJnY1aEhsgyhS1YRu+ARy6wdnhBeKmndrpa9B2QSAugczVOaPqeozjeVe2YL7d//yeQ8mvo9NzZSA6j2qwJei//RyyNcETHlsTUiETMmESSmEVBkERtOAM4OAMThhCIRIMagUO5LKzZ/g9yeQL3ukL6GAN6vIL/nHnBvaDL3lyHxdNnSq4B3oojiJLd5iHlSAL0kAPTMYSPkFcVAECccEXplsZYB7ICQXXr9ssZ4a7UzHKn2HKpZznt7vJafMaYtK1vDIcyuHLv7za6eu94OvPnv4fwErqn14fwgG4NqEShjQOzLy9YzBZyTjMpiAKmmBxm3Qp7ZtqnVLdozVzdULU3d2wV0Hf93wVHlvf7R6iNQEJbCCpH1cGSHe3TeJxfeAGfACFH1eXO4XEqdqHY//gTBPuGcMLuH9i1IPZKY6Zxo0Z87EFloS4nXIXVZ2NxlpkFm7hRRBCPVK/RFZ/GLT5yVI/GKj5mm3MxqhZrW//9slbFZ98NqsBG7QB+L/B2S0HXrTR+JO+vehLG/WB9iSuHmwvviwOH+whrKo/rPLhH7Af+62/6tH7E4RTEMocKAtBgIBNXbsA/btgCtT/UIkAJKD27D1dJZ7TBVbA/u///jtvfHniKVEpKXgJIFKtKjWwlKeDpRJ60qTDRo8dPHjQ+BGRx4waNXbsqDFDxgyNM3jEGEkyxg6SKlSULKnChAmVJGXIOLkDCJk0afowekTJUidRpE61cuUqVqxZtnD/KfXF9FewX7+GDQMGTJhVqlixCsvKi9cuYF95ERtLlhgyZM6cPYvGlhq1ati0bev2DZxdcuTakWPHrp3fdvoC0xssr7A+w4HlBV7MuPC8evXwQf6Hz549fJjx5dvM2TLnfP9C7wNHq9OnSY0E7YnUCNGhQ3tiA7JDm3aX27inNGlihMqSJUKCCxdyo3hxjMhdKF/O3MUKFtCjS5c+AjoJEiOya9fOoTuHhKlKCTSYkPxAR0Z+KOHRw0mRH0B6PIyokb7G+yY1ktTYgwcQJU5kkUUacvTBkyWbdBLUKaq4AotRSCWllC7B4MKUL8Ew9RRUwWz4S1ZVWeXVLl8BM+Iu/2WRdRZaaTnT1ltxaVPXXXjlxU5hfBVW2GA81hOPjoPV4888RFrmmY7yEJYkj0wuCVlkUEaWGT6hVWlllf5kqc83tIRyWmp7NNLaa7HZMVttduCmpm5NUOHbcMIZZ1wNNNTZ3J3PTafndNht5+cI3iUki0LlGZSJLLJMwkYTTAgYoBlmXEHGpJJOSkYZcmRa4E49JQjUKawMdVQttkiIiy4aGuPLMB12KKKJvIAoKzFUpZjiiiumtdaLcGmjTTfAdmMXOOPg1Q5fyLKjjjrsxONsPOvIs8468cBTLTzwEKntto/ZU489m8VTpJH2APnkuU/2eK5kkkVGGWZPTkllZv9P6uPNLKJ8+UeYiLgG2x5mopmmml2w2dtvcAYnp3E41EnDcg4/vNyeFEN3Qp9/ZhcoQQZ5Ql4mB62yiif7FkLJyZQkGMqnqrxiVKkSYhiMMcYMY8wxOOes8zHDHFNMMVZZNYwwQwctTDG3mjUWriyqxVY0bsEV1zYzgmOsX+7ok/Vig+1DTz1f96hjkUTCM/Zj+NCDpDzOUhstkj8mediOkv0TZY9Z5q13vfqg68+Tf5+r9+B/7xOYO9nAku8kisAWCSRj7rvHmbURXPBuBwOX8MILY6Qccp5/XkPFeqJwXcYadweyJ5kQlMpCmWiiyUGOrNILzTMrw8zuvPfuezP/vS+zzO7CJ4NMMsgnIzzTZ/284jK68goXN8B+k1de+mCtNWP7dO9994T7E5jen11pJWjo/4O+kf+Ym7eOjVGbJGT+5CPPPPSwu3f4hIPPf5ZCGhxkgqQ2JLXjGrAIBScY5zjWHEJykxOY5abAJt9obnOcmxPoNrhB0kUHBRdDHaC64wc/JCIRIMtEJhLhCEckYgxjGIQnjAE83zFDeLyDhg6hYUPh6Uotzwji06D2ll5x44jc2MZcrOeOrG2NMYEx3Pf8sY//he8zm/mH3s6HRdBosX5gzEcY1We+Lu6tHuYjY/rsEZoumlFwAKTfAAuYpGnZcVroyKMe0VGsarDC/0uTIBNrGnGIQZSJcnYQg+Uu16bfXBBOcsKBJHFwHA5aEnR6qg4LQIixP3lnEYnwxAvH4EJPOOIPg/CDFf5ghVTQMHjCiyX0cOg7aFjjGtnIhjd2GY5wlKOJwHyi1oIJRf9lkTOD40yV0oclLTrTH2kc3PnUd49qtjGMhFOm+tyYviy1kZvcBBc3wVZAJUHrjutAxznQsY5zrHOP51hWHpnFDnJUoxWj+MQlBNmIxg1CcmcSgxjAcBsKFrSCFkQYBm8wSUpW8pKgM04mocNJEY5wEYsoxQoXMbsVJkITL/QDHuyACFDIwhbHsIY1qkENbLg0GtlwhvCgsQxl6O4Z1f/wRjl86Y5f1uinN4LfOIClxLmM40ZeCyAA6QHFrynVbu3K0j7q0be+VXF/3iPcM7VIpTViJo3bvMdmwCVObX4TnJ0Zq7YIg8d0nsMcekTnO96BznXkqDDPkkdQ+eIXavzxE5kg5B4UoQjX/HMPbECTQAtGwSkwspGPhGRxKDnJiN6Ag5X0oMVOZ9ERjCERpXCEJlZxQiuMwQ+ZUOUYrOACQAhCEJS4hS952g6rlcMb1ICG8piRjGMIrxrhwAswf7osdYirSPQYajeK2o2g+iN/0NTb9/yn1P5RlYpUvG4VuxfFq/7vrJ/5ahm5aaW/BY6OeK3rtN5qDnOsE4/sdKv/eqkVNyTdlW3xSNaxANMOvyrwEq0pRD8L+Yc/sCGxtBGoIhvrWDZB1pELpawkQUdJzF4WI5qtaGdRm4hFHCS1VgjxGIZgBT/EUBN46IIhZBsObHSDHOqoLTnC4Y1p6E4Zx+AtMZxRDavlxR3EXdZx51EucfyqqOJgx2Aww8zQOPVcTx6gPuhRv3rgr1vYFGPg4thFMoIVi9I1HBT5UtxxmFkc4jCzmseBZjSrOY/udGc6ymzm4tpZHelIxx2TtSwm8Ygxf9FLNP64QELyYcAFxgMbuqDYBTf2sY6EcMKC09AKY+ShNegchlkwuop1NjufXe0YQGbiz6rSxIlQBBtW/wkJX4SDG9EgRrFqW45sMGMazLApjpOBNGRU43pArtGymqUtf7BjuUTVRpL7BtZtfsYy/cuSGL3VGXIVKYBPQmsXv8U2/OaXHXxcs7iLJe48rlkd4x6HOuJ8ZzuTOVnsgMd9+aysZa0ZHMEKFjeccQpQcOISkTjEoQn7TwMjGE25KehuHgzhyFJ6kpyzrKY53WmKdZYDp3XhqD2BWhObdhEwxMMejGAFTkCjl97gBl7A0ctnoOoowcBZMIQxFmdgoxx4KRZehh0Pe8wjS+hA9jbkMg7AeFeAzyaXkTaTJSAFSUhQHkwciQyuZzkLW+/YY3vHYQ51mGPc7Q57cfVsx/88z1nsaF8WjNd+5jaLI99w74av5i4XXw3dV9xIxilGwYlMBHzgiih4mRS7SIRGOtIJw8EPKg3xDMppdJclXXY4u50OdGAQmfhDJlY7ytPCULWDkIIR8HAIZew0HN9wB75v+4wEUoIUvqDZMWJVc23gnBzF4nk8OJPcZP/K6EdPJlnLOtZzcY1HOnrWHdvbZnOIw/ntdS/zox/9OoN93eNgdzzdrY51pIOu68AWtpzVLLaRmc5tHxa+813U9tPd7u+Pv0u1kY1lsILvfkdEIQirCEEUePC1oUhdsGi5sRtRkFCIN2k/sICMJ0mOV0kXJnnXMYHaYXkoNAZ/QHIfB3L/IWZaY5ACKZADVrAHrpANO4VzVkNj2VALlUAJoRAUuKAqvmAVyPAMKgdjxWUtVGc/b7dcviIOVLY+WGQZavQu6YIjfGFubed2TChu58B147BHcBZ9cVaF7pROxWVH2DItVyd+8EBfyvKEbIZm60dU7Nd+aJiGaqhEc3d37+eG2JANLmV/+EdIAkZY/gcIgBBBCHdgA6hwU3CAboKACiUc78GAlUYcD3hhmbUnF3Mdj9hJY5ADJVBiq2UFBAFKpWYFIhCCQ+AIoKAL05BLdfEN2SAN0IAKlfA4o9AJqtALFhIMw4AMyxAN1pOF2TIP+VB1cWcO9SNOnmEkRBI35+RO/0x4jGn2Zla4R1GIDuAmhXv0feHnhdgCb/XWbmOIZnDnhvFHd2z4hu0Xd0S1hnbnhkMXFy7lUrl0DXrnb4F1CHcYeIOwh3sgCLMRUIxGgAxGQVTQJoQoaUVQBA8nBDgwaYrYOZd1YTOgJ5F4Ag6JHX1iBUHAeZdoQp+VA0YwBkFgBS60Sp6gCrGgDNYwDdNgDcyAC70wCpkwCZPwCr1gCqhgDMpgDMygQzgVXHxRP59BRV4zZV9DOGCDhNaILMNWTzVyV1bXbUJ5I86SJIVBTjxiOIMxD0rJZ/Y2hmxmF8BSht/wDcGifmAZljlHDsNCluMQlsSCluEADl3Zld7Qlv9tuUtvKZdymQ3KcApeggmoIWBjcgiqMTl3IDADRRtgEAVbcIBN0FiMwgSMSQSO6XA+UBw+MJmRKZmV+XjIMQOaqZkyEAMssAKguQInkBKk6RKmOQYZeVqJ0IETKZEgs5EvtEqakAqm4AvWkGPKYAuy8DqE5QmrIAumYAoumWvKsAzQIA3RAA7toA7yoEziY1941TZFOZR7NZT7dV9IQkDlpCRAQpT21oPA0obdKBdzsVxDp0TUM47lCXdVw5ZtGQ7jsJbqN2Pu2ZYz1kv1iXpuKZf76Q259J/XwFLUIA3S4Auk4CWXsIqHMGDwWAiyAQiBGZiESZhgUAVVQAWKyRv/TNAEjvmYk0aZIAqimpaZm8mZM+AcoUmapWmanmAFJDdqqNmBIRZaEjlifrAIjuAJqfAKSREMNmUKozAIteMxkxAJpvAJoxAMu/MMyOkM1NANzDkPofE3elVc6IB1cwV+yfeF6gAPelaN8iYP06lXSoZ8ZKojyqJu6iAOWqme3Dh/vpKOMTJ3clqOd2eOa4hE3ECXcfmWcPmngPqndOmf61gNLBUNzyBTyDAWW+EVuXALtzALo6BAlYAaC9o4r0WP9ngHnCqhtQEGoHqhDbYbG8qhHao5S3AEqnoEwRGiPiAEk3kDl4kREcERm1kRNYCioBkDKpoSpvlCJCdaVrAI/6rUYR5oWlYwBB3mYaDwCi6JkrUACqHlCKUwCIoAMpyACJwgkzV5nNHgpONwP7tYD/KghFzXXnJ2du2GnUtpZ9kIDm+3fnX3fnKKjlNDd3VKp3HqUlJTr3CKhnOnp0W1pymnpwQ7qHQJoNewsIeKqDK1DMiANGCRC7yQCxZrsbdAC5B6C7mgFEoRC5PKCatISAz6WrGxqREqMKBaoVFwUAu3mIwZaau6qrCaMJEZqzdQETwAOjqbq6G5AizRqy+0msgKSjIaYihEYqD0UZpQCqigCqmQCpnQQngQSn8gC8bgCZNQC6NgCKEwDCVJDVBTDdrQc1QHLWanZ2J3fmU2LP/bCIf+aq9x66/aMLf1Sqd2m470B391i69H9J+Amw0Lew3YMLgB6hZPk6jLs6jEQCKOuwsWSyIXC6m08KgbOwuYC6kwAzMg62+YEAn9whr+8pf2CKGcShuBubIVugUNRkEvu3AyO7Os+qrBoaqw6qo6u7M10LM18LMr0asY6QdDcIkdeFohFgQcCEMe5jGyMAqNgBp4YARGYEoH0Qur8Ae10whw0AOdMA1+mhfAlzbXaGbkQIZsuY37aqjqy69wsb712q/wKzWEG7f9erd5G4fpuLBxmEvqGLcBKqBugZyJqqhnMRYmIrmO+6gWSwuV+6gMvLGUe7mzAKmYW8ERAjP/tZDBIPsJmABgodsaruF/f5Cppou6drCyFkpQjMUmTMBgCSW7thvDtkuZSqAEk5m7OJyrLiATnfm7KVGjyDpiJ3SjLUpyOaBKmDgQvpkJSJAEROCifpAKtbMKqjkGSYAEaFAIfQAL2fAN/nlEdOoWYiy2Y1zGZlzG6pvGamyo2LDG7LvGaly4LmW4g1sNhmvHdAzHApq4QTTAEFvAxHAiJOIVI5ILCSy5F2u5G8vAjEwLFjwLEIK5RhELsPAgk3wUkPwKeVkJiBB4/URYfllgr1W6EuqpFVoFBLWPrzsFL+wErlzDsBzLsDyZNXzDOBwRF4ERnNnDK8GrSDwGIGVi/yMzBqLkB6vgCC5qBKMVWquJBHgAxTlAzC10o4lgQkYgBZzAozkGDWhxFi3yzeCsFkA0REOExoYqxnqczup8znY8x/+rxgwrxsjpsGmxDMaDNLZiFkxTFmBBFV3RFYP8uJGbwBgLwY1cwZd8FJW80As9yZU8yZrMwajRCIPwyYMQyiNMwqX8qRW6WA62yhYUBUfgyk4Ay68syzYMordcEZppq7ssE73scUYAco7wWSFlWp4wCCEmWiuESqgkOy3EQoqgcaAUao6ACrWAC8egQ9AzwH1Mzoj61GwhDWesvuicxnSc1ekIuOqosFlt1QNKz/YcsfhMK10BK/+MFcRQ1v+0qDzP8MfOs9aMGjRUQddXwRX/TMj/rAt8zddKATO4AMGXC8Glcgu2ENH/Jrr8F3j+NwijrIeniyYrO1ArnKH/SNIlDSAoHcs+sNK4HBIvzcMwPRKkqYFWMMSe56IcuUo6XbV4ULWrZWKLwEonhAerMAgamQMbGQSOIAu14As35dTL8AzQEA07dNzHSaDKvdzMTdVjrL4qdUvXEN1ZfcfUMA3KDQ1BJFP3bCtondd4HStonRU0R3M/ozxNDbE/gzQ0RwxGU9dGsxUgktddYbG6cLEeawuaq9+CHan7HalIgdgAFwmK8Ml4OAiO/dima8qqe1Cuy4+DSAVR8AQU/gT/mU3Sm53SPmDDPNDZOHwRJVqivMyr0tuam8h5veAJGWkFMjQISRBiGekHGTnjeEBKMGQFMJACGJgJr/DbwZAMNCVLTX3cqGiTRN7cy02SJCkNSt7k2b1DxIM8OHPX9F3lae3PVi7eZw0i8S00xYAzbm3PxcBrch3fWmHmslLlicyxBS3YE/zmFVwqFizgkUDgYkJYhpXgGn0HEMrRoLomuuHCbhIFWHAFhn4FmJ3oJ83ZPMDhuMoRGxTiI368u01y0jsGUiuRE0mtSeAIuG1i0msEtfMHeCCkL5QDMLBKilAKvq0Lx6A7N7Skb80MfVzrxI3cRY7cOsQ7ypA8PCMV/1LRqFChC79A7FDRFX19ITIz7LqQ5bogK9BO3kUT7Dzz5cegPEyNPOu91kBD1yHi7bGy5fRt34nc5vv9yOhewXRO4KzBf4Wk56TM55E92bmxj7rhJr+BBfpe6Iqe6LH8yo3u4TobErga4h0B06bdgUaAkUGAeRs5BglR09UqkUDsQo4AMqfUYaTkCC1JKrowDDdmU8mga7BOnMlz8slTDEUDK33t16eCC7bQ8i1/Ki1/7LzA11DxC76AKsreIReS8zZ/5VVx5lcRND0D5skzPLwlDcpjPH98FjjT7V0u31iO7M1+832NCx2ryJdbC+me7uuuCO1eWO/efwpewhQKBv8CBQZbcJhR8PZvP4j5fuiI3u92X9Ib7ui7K/As7REGPwMbqenIWmotxNsgNbWx46I2KrzGXAusI/EalQqKAAoZnBS/kGPX/uvHcDMdkvO6QPN8PblszvWGvbmmb/qgL/Ohnwsyr+zJDvQ5H+3kHd9Hj97J0DuoKAzIoxbDLUtS7jMqj+Z0vde/cPNY/6haT9i28PVfH/Z3XliIgOB4SMJof8KgOlBsD/eG6faDOOGHfvd3P8s3vPcf/veaaQOlbgShJTIwpJEvWgoh5nEjhuNDUP9jIAvXy+IolAgigwiVUAsA0cuXL2XKjgkTFuzXQF8LfemCmEsiLokQdeHCdev/li2OHT1+BBkSIy6RGC1C5KUrV0RdvFy+/BVTZrBhNIcNK1Ys2bJlzJj1hOYTGrSdQ6U9c/aM57JkTXMWu4lQqrCbw3691LUQIsaQtmZ9rfVV7Fiyr0Z94nQpUiRFjRohQqQI0aBBigTdFQQI0B29d+zYARNYTGAwWwxHMbwlyuIpUZ5cgexEMuQrki1fxqzEBw/OnDf36NGZcw3SNWacnmHEihVPmcbIKuXHyhhPVoKMSbRozO7dVowMGTKbtxU8jhwlGlN3EBNUvYwdK8hMIc1gA7W2dGlxZMau3b2H1Kix462MtySej5jyJS+ZV2NOvxnMZrFjO3v+BMoTmrRp/9ac/U/mGWSYQianY6CqCqEEj7EKO+0uyiW88MiisMKvzELrkknYiqQRRT6UKy677tKrRL8AI0yMwQJLTLHFqKDCsSses2xGy2isMbPNRPMBNNBE64w01HwLwgg/kBvDiCD+0MQ2P8bwo5QxgBvDttkSWQ041krBQzUsjUCCjVKUYaYZZqAxqKBjoBumofZcYmgkiwa66KLt7jTpJDtH8oXPh06KiSHrsnIvpvVcAgYYYRSdqtGnciJGmKcGnOYaapAhJtNdgFlvl5fOi1CjXGghtVRSNSKVQlhW/SqWVV+NJdZXZ131FFBAicSRRgZxyy24DqlrRBJN/IswY8Goov8KKpKFEcYlnn1iiSeOcIJaaY9QAltqK5NMCW+93XFHHnzYsTTTZjgXtSBSCOLJMf7wJIjVXrDiy92Cm9IIT8YwzogchpB3lVoGcSSTJ3OwQgcpUDHGJ2YMGmbNm5T5RaH2HGLoJDq3wvNOPffE82OLLiYZmF8SRTlRqaJqVKqniAEmU2KKIWaZbLzJpsBMac400UNd8hTUCE01lSxaX20laVpZYYXWr0T5BJRJHFHkkA3dkuuQQwQRNi8TTzwWWWWXHbvZZ6GAYokj1j7iWbbXduIJy8D1QbNxxSVXXHN5SDc1GGBYzQ9P4s0hESVXG2QMHYxQLYgc3F0t8igdGWT/ldwS8aNIKc6opJcyg5EYOgbls7ji0jF+KM7tBsKIdY9DFhmiq9ZL2efaUZ5KZt0jrWpNSIlJhuaicPaGmv+QQf7llX1eTyWJJLzlK1pahWUWpJNOmummTd2FmAGdiSYaapQ5JZRPpnYEkbU8/HXrD/Eadi+/wmZ22WbvRxvtZ91+e20lLqOb3YCUN3EBKV2OW40RSrEK3/ALgVWqlxVkY4UhGAE3RijObvzwB+LQxRGa0I0f8DCIM0CiFg+ryZpUWBXTyYdkghJU62DYJ9dtJ3YaYw/tble7RTEqd7p7SsTq05RkHEgnTTmTNJoyDf44IyfIK9CjFOVDhOzCile0/6JEdnGeK8YMGclISvioQQ1sYIMb3vhGGsERDjayURrl+wQmOtSI9YVIa/DDS4n2Uiz61e9+MMpf2vY3yLf9r1vfslsBCUguII2GNEEokmp0kyTG5cAIg/CDvnrxB4NpokqecAQeBnecP/zBCBzEpHFKUSQrlGIQkWjOc1JYxKrUhHSkQ90M6QTDj9nwhiNzE8kqdjKEJGoYCjqmgmb2qJwghD4qrE9OoDGNWYjiK7gIBiyOwYzgETEZUASnzJDnPWT8J3ziq0YZtYFGNpbDne90Rzvk2Q521JMd6sCnPdtRDmu04ixydEsdPwQXPMbvRCjq4x+bFchBNpRthnQCIv81w8jOLDJcFB0NJFlphExkApKRU00mmmEMPOxmEauBYCYUkQk8/MEGNhjEH0SZCOMEQQesGSHnbGEM0BkkGbW85S11ycuY6GJjJ5HTLy3ikl/ILpgySRkya3mTYkiKmUP0plOSAY1nCOMYQzlGhHhhVSj+JyngG2M6zciNcLjTHW91hz7iOle56sOud73rPvS6V77yVa7WgAUpQIGJq12tVyDCo17yctCwBcaPf8wfIffXPwBOdKKKJGBF8xakIslrEUE4DiUFN5teNCMVJX3SImqDJSukYmAlNZInaJq4MbxAXsIxghkK8QqeDoMZKwQqT+UzVIY4RKnH/RlT2RP/Eyo2qpZUYZlVH7XMJ4JzGQVaBled4T1nUKMa2thGN7oBDnLUUx5wfSte7dpX9bbXvXaNpzzJMV9w1Bcc34BGK0gxCk5s6BDr85CH7NI1xfaFj8ZK1mPxJ8jJ8u9tcosouO6G0QKKJjSNhMHhZnMb2yCsNqzxxCDw4Ac/qBY5q0lELVZBF98kwhi1+YOUjJDh2fhGCkXggyqMoYxhFJFBN/mxcBlCuqcu90/HXclJdMgLlDGZU06WiswgVdWqklWc4CynOcVYjWtcIxvZqAY1nhG+angDHOnVx179sWZ/7KO9fWWzm+EL33bEc77zHYd96xsO+6Yxjd5AozegEdjB/06iEf+d40ARwbUR6dHACHVs2RRKhSVEQZD6a1v/4BZhCS/SM40E9Y5+kwNLAkzDvpGgEYig0nYhSTVGcEQpPlibIfihSbD2hCdrLJyWDmIPOn7Yw5LxsOgQuyA7ZoYubEEeiEDP2c4OlUbKcx7z5MKKvLA2Fpl8bU3prqxa9u5av0HeecozvuaOb1zTvN6++rW97cArPdVxZ/rq2d73BbQ3uLHvfOPsy18WtCsES9hDRwISWFMEXRDraPn9BdIITvAf9ydITb/tkBP1zEVB/SNQ2yY4+KoX41DKuCRIQTUorZKSgjDCUniixFBiJWiRBDDcICcReDgEb6NTH+ioyf8gxgA6T7WjkWZ/BVW0iN6pjl4q6Akt21e8slm3bMZujDscdy43uvfRZq6vmR700MfXxf71esxDHvbEpzrGsfY8r10c9X37ve/tZ/H62c/6DnS/9d5vabjin1czOMLhsnCGg62xgSEbZBlMSE3/T6KbUSSoOQOaCjdwShV83JIGQSTfnNwTwHmSyAM3Gz8EB3O7KQVNP2uEJJC41u+KROeArkJlBKP207mlSZL6EaOThWhEgzrywphWM37j6vMtB7rhHfa+jt359KgnPe+JDrWPI+7iwP69xbt97nff7t3Yd/ir3n3wh9/8+Q7/v/+d72xIAxZ/bwQkAo9wxMaPWIf/F1viF9xQBxdSonSzMB/hOAHkOM4Yjs5qMUcYg9tQQJRKBE0APRLDg9UIrdVYhFIohUywgoKpF3e5rd2gCzbghFSQBZ4ywd46nSPLChf6BVGJEC6CumL4HvBBp7ViJ3ojh+SbJx0st3hiB3k4u3hgh3VQh3QoQnUwB7fDvrgDB3EQr+zrPnAYv6qrr+8rP/HahizcBvAyv337svDbwjJaK25QvzL0smzoMmtQw2lgImlQBv0Chf56CwALMAHLI0ebn8aKOAWLLP5rvP/7FgICAiAQwMkjQNHgDd5gnCqJtSfxpCqBEtnoDSvYPII5MU/IQD9QhA2EIJTSjRrbjRjL/4RLGIVa6AXn8IVgkKFU7BOZwIknkroxKqMsND5yqLO3usV4iit6Wj59ODtbbIf5mjd1WELsI7/u08LwOsZlFC89+wZmREbz04b0+7cyUr8u67JqCDNqkIZo0C6mqCpg2CJUoR5YuIVTOItM2BD1maM6fB/40aM8PJaIsx+JWwL9UZu2YTxs4bTHUwJCHEQfsTDJkw0t2Y2Tmw0OuqAjkaDdMBxHWIVQYpLd0IQGvI1EeMAkoRzcQKl6qZJBQIIzyARTPMVeqIWTrAVZiIWdWpOtKrO2Urf3ksl4uyd8crtl3EJl3D5t4Ekt5IYpFK9908ntq6/xMsrts8KqSyPyA/+09Cuja9DGMTonpLgumsmiUUmVo2kF7cGermwFWEBHTiCsDtmQg2MfEekar9kjPRwbBaO0e8S0I1g8trk4RCIXJRDAgJQ8IIGSyMGNKlmXMciEzXOXIYCSR/yDQUiFjhqEk7ICldq8WGMN1/CDwUSCTgRFGxsEThiFUkALD3GESTgEQggFW2CGZxgzbAgHNJszXZSv+ZKn+sJBcrC3Nhq3cdMzorSvZQSHLPzJultKaOS+Z9w+3xRDqBwjaggfpHCGcSIGLNoFUsFKU6meo5mVrmQFr9zKVogFVeCvTJijsjTLt3jHO3y0PlIWt2Qot5nLTUOkiHKCHvmRHhhEQjz/xM4IDdDIhFKYpDFYBI+ypEzQhD+AEkjEDdlIhJgaTMNhHNXAA8tZBVnIhFXwBAvajeJYjQl8tY/8g4SjC9eYLTbYg0oghf1IK+MjTuFUSj+7L7vbszZio9kkB+PjM/LiM9y0N7vrt+07I28AvyzUBjGMSqmMBua8LucUR154TujMolv4vVKxnuqJUut0Be3Uzu7kr/7qkEowOPnzlfcZBPM8qIcTmwRLz7Hpw4mDliWolv95gm+Bz4iqm7yRDCDggR74R7zEzx7pEUdwuZOrEhu4KQ16kg60IAeMKdtQkkuSAjZYhQ85DlmzNUc4Ek3AyEiEEv5EDj8wDuPIjUXI/w1HiIRTWIajSE4uE0NsAC8g7UnfDD994zdYjVW7o9Va/bM/Q6Nb1bdseMps3MZzKtIxQ4phZU4sIyJm0hmY6SGfARUJmZ6xcJVXqVLtodZTsNZrtdZYMAVQiKP1mYQNWYtE+5Aw1Ys98Jo9sAM2sIMVIQwzRZY/WozIeoJ5hbBDeoIiOIIiEIJscQIhiLC8oZvNorC8wRJKAhM80IHjOBISu9BM4heaki3LIZLkYDm6WIXU6yiXe8zTEw6TEtBByARPAFWRvZxF0BVVEAbURE3+kAbv0kZtvIZUtcZ/68LzA7Rv0Lu7Y78vw8YhBVbUNKug/Y+lIFqzGrNgRYpjPf9WI3qUYnqy7FiJXMAICWmVVpEVWHCFVanS7MnOpHGFr3WFV+jOUNiES9AQRfjWcD2scY0pvfgDQNiDPWADNuiCLmDLd72fxbC0tJlXLHiMyIibJSiCwf0BfD0CIVgbISAXxH28zZowcvnEJImcRJAF41iE1CrQejmOVahIUDIchKmSVegFTVCEyrVQCCIxSZwgKMm1WONPTbDUTPiD3FgplF2G/3iG/ZCGbtzd3Z0GavjdalBDbOyyMvy3M0RD5OTGblRZsyLa54VeprAP6B3aob3dlQVa6SUipq2qBJkdpMoFj9iIjrCQWDHf84WFV8DaV2DfWHkFVDgLLY0EdUz/W3Fl21IqV7mdWzY4vCpAvLzVW7Sh18fAAm4BAsElXMMVAsRVXB9YYEC8rDndjIY0JUocoXdxOYy0Oc09klUwpZGs0JMbBE3IQH4BTBJDOQGtEncZnMrMhEX4T+PIBIzMhIJ5hV8ghqTI3d7lYd/t4d3dD6SlSp7IquDZmSM6oiL2puhlYupVWWiIht1dBqDNqqY1GUPpJYlYtlnwiLEACbFISVkQ4/ONBauNhVpQBW4Vy7Wg37RdWw+NKfyN2/3FP8e6n8PY2wGmjDrN18Ed3MRd4AZ+YEAEWAlLREol0N7oDRIz2Us1ksTENStIAcDZDcBZDRB6vdejyP7kVJfz/1RQheFOLZiCqQVcEAaecIYzgQaibYovmplieomr9JSUeFonA4apoiqsWmLoBaPbdYYmnmLmRM0oFh/9UAqt+rGocDKXcLrnmRALIYtYiWZppuZZcF/4jaOx/NZtNrQ3potSetu41d86xlsYwWNL81u/dQJuCVw//uPDDeR4huC6eTzVwo3NU413acgncRfI6Q0lsS0rQJjIkSCPvBfQi1zhILEEPY4Pit2O+qAZ9oRewIWXSJSY2KJmRTpUcTalI7qlyiHnEiJoCp4kbgoiZornLWJUvl6VfYajgIZf/iYq+zGnreUsyuih2WgnrZBnFQsyfpWx2GhasAVVMIVQ4P8ELuXmbXYL4xAwuvhmuNXfA0MwO24WvY1XLNDqAo4MyEBgP644xMUWCAZETPTIyR2Egq2NvnTIKhFQx0mSj1ph4fANLamgv8xnm0sEeJFdRzDZF35hy/2gVcAFX7iFLGq28HDm8HhSpcMFkHlslbDoqBIGKXuKrDJW5Pkmb/qiVh6QLOsuqIQiIIKKHjqUiMgFbFtsJ23sjQYVL5ri/ZgG4QU4nLGGZoiFUYhDOYoEDeHmgBKohBsWh3O4efTfco4RrIaCrS5grr4CLPhqthFrtslHOO1HQJxEVCuYJ8mE0a0X1kqpXlgF1Qi9vowcSPpLCiq9RViFhUacBA1ZkC3/GNj9T1ASUE3INVOwBWurtlBx5tZmOui5iGWL7Ja4NiZDFJTZnZeRQSyrLs7+pi+S8M6WBpxJHp7ZGZjhlFnO6WbWokwZkCmOYuH1sn6D0RMPB3+zbWV4haMWS0MbxW2eo3DtEBAhV70gbqo207ZMbqzeagIu4HVeAiZ45wXmv2fBjLl5z4h6TA1UDU2wHE5doJZyBIKuMZYSjj/IpIb0jSQojtggVBWOktkAJVnDSE0IbEsFoQ/6oAyEBFHIBZnhCSyjcyxr7GcDFeh0st3hnZw4VmYC9J0JcZophl0ohmn4smfwHj7fnW8To5i9GRp9p3JAcTbqt2xwSmyobZwJ/zNpKIZbMOo41NIYl3E6YgsQsfG8yHGIS5Z2TTDEUIy0kYy+DXIhZ7x99B9Des8lVwJKlVzNPTEImt0keT0MwgNNmMCGrpLLjRw/VYQCNdDUAqUy96RE6CjVU61UKJjWQNtLoARauN7lDFrmbM7jCactooVmTq4E55RE6ZlMqWzqOuLfmRly8jZMAXEifoZimGLcHTPi69F2cqccdCc2ui/z+zJsiNkuS1X168KbTXFOJwpacAWjRmrCmgRSd2P7HVcScTgxoGpkcXVmQYx4lZYn2GrKgIzFOPJ8LCQlryzHUwIkwZIv2SAIErEkQRiEjDU8UKkHhGG2nrVEZsgxKP8p2qiFRvZUa7fU1FoF0zIGWZjfVHgFUdgF4QsfodX6crdeTJnl7GgJ5rHllNnzmGn00WZ0EP82tOJGbtwFVojOVUEGbwgHGmWju8t0X31ZmN17mI1ZTZdZMkxenkVDa5iG36KFVjgF+OXWsWzj+m1HVIfH+Ql5VocR5T55v+UWymD5KHAod8bXJI/5b/EkKO/Yg1SNJEgCv8QXgvkDR6iFCbwSlKtI2roSLd9ETSAxTy2FXpjh+z5zWYhQWTAFMR6sTYhz0A6ntJcZT2EeYCgdRsEdPp+U6qLzcd+ydJpGNFqjtmojb3CGTWEKK4oGXuUGmX3ZVGV4he/79m9/4u3/Mn/DxjUMimP4BVuAhVZg3/jFBA15fHAFiEiRGhFUZFAQQoSA7thhaAcMxIgQq1ShYjEKxihQoDx5guWJk5BXrjiJsuQkSpRFVq5cEvJlyCwwnSip+SdJqVVWxiTaOcZPJj9+/oyx4lNRpkGKkijStHOQIz+JgvzU5Kfon0U/rw4as8iKkaGZmvVK5CiTI01qNWXSNKnRK7KZEFGitYsYXmS7duXimysXr1y3APMqzAsYr12FgQEL9uvxL2HChhXDW6wyMmTLNDt7Fo0atWrYsG3j9i0cOXLtypEr59p16tTgwH2r3e2bN27YqkV7Jk3atWzXsOkebXz38WqgQ1dr/+78+fPl1KL1fuZsWbJiwoDtuuV9VixYsF65eiXr1ahPny5dmpQpU/tJkwTSL2jwYMKFDiXyp3hxyxYYQYEFgU+MRCBJKaXEBIMsMeHSTC/JBFMWf1iBRyJFWdETT2MYMQYeGo4xhiepZJKKI4r8gcdOmSyi1U5WXbVIUIlcleFWnjjiyCqeQLVjIjQuEqQik3AiSylKPQILMXdl5hcvv/xli2C56KJLX3tpuRcwwhBTDDLJLNPZZ9UEx403p73mmjttutlmO7GRMxud4HRzW5123vYNN2h6kw2gf2bD53HXXNPcocMZ6txy1FFn3XXIEIPYXrnQcikts4i3KSytsP8iniutqKIKKq6cNwoon2Ai33vxzUffQI3ch59CgCxkx0P8TURRFQACqBGBwSKYoIInScEgsg9GKGEWzTprEB6ObFiUVF/tdJWGiSjiSE47KsIihkLZmAiOPI0r1FVW+KEJt57ggQdSQC7iiYs0DgLVi4lMwspexDiDzGGIBRZYlv1m5gx1oQWXjTdphhPOmhE/DM7EdH5DccUUyynnbOFQTGc35PBZW5/Z9Glan3xykw02hh7a3HS9OfOvpJT+hSnOOM+y886xhCdeK566EmrQqogqiyrpcbKqe/DJ96okAtk3a36ACHIrrrqCwWsUv24k7LAjFXtSsiwtAdKyTjTIK+Efg1hBFFh/BMmTUeWSK3dOmayiyNttjeiVU9iie5Uf6o5Yiie1eKIIuew6Mu8qmrx41o4vAiXKLpJq9iUvtIiX5ZfIOFMNxG6u9trDqXts2517foNnN3XWZtvFdKZuu+oez3ZxOA3nxo0222gzvGigPXrdZnjhlVil3nl36fOYzoLpLTz37PPPoBKtyimiUlLJKKNwwsl88rkqX9QDzUr11VZf7dBDufLXdYAbdURgGViMdAUWYy/RIEuKsAQsTGgmzpJQQAAAIfkEAGQAAAAsAAAAAEABAAGH47mZ16uM1KaHz6aJ0aOEz6OFzqKEzaKEyaKGzZ9/yp6ByJ6Cx56Bxpt/xZyAwZyAwpp+wZl9xZZ0wZd7wJZ6v5Z6vpZ6vZJ1u5V6u5N3u5B1u45vuZJ2tZF3t491uI53uI1utY1wsY5yuItqtotvtYtutItut4djs4hqsYpwsYlpsYZqsIRkrolvrohoroVsrYVkrYRqroRhrYFgqoZqq4NlqoFoqoJgpoRqpoJnpYFmqH9lqH9gqX9cqH5bpH9mpH9hoH9lrHpVp3xcpXxepXhVpHxfo3haon1ionphoXtdoXlgoXlboXZWoHxhn3pin3tdoHdhoHhen3dbn3Zen3RWnXphnXpdnXhfnXdanHZpnnVfnHZfnXVanXRinnRenXRenXRanXNdnHNdnHJcnG9cnXJYnXFOmXhfmXZcmXVbmXRZl3RbmnJcmHJbmXNXl3JYlHJam3FbmnFbm3FXl3FZl3FUlHFYmnBfmnBamXBamW9ZmnBSl3BZlW9YlnBUlHBYlG9UkG9XnG1HmG1Sl21Slm1VlWtNlG1Xk2xRk2pQkW5UkWxVkWpUj2tUi2tXkGxQkWpOjWpPlWdGkWdOkGdNjmdRj2ZKjGdRiWZRi2ZLiGZLj2NEi2NJh2NMh2NHi2BChWBHilo4gWNPgmBIg19Ff15IgV1DfVxFf1pDf1o9fFlBd1lEfFY8eFY+e1I1dlM6dFM8c1A4b1E8c0wxbkw0aEs4akkxakYubEAjYkQvYT8oWkIxWT4rWTwpUjwrVzkkUzgmTjgoVzMbUDQhTjQiTjAdSjQkSjIiSjAeSi0ZRzIiQzEjRi4dQC4gQisdQyoWOyocQiQQPCMTOCUWOB8PMyIVMB4QMBsMKRoOLxYGJhUJIBQJHhIHJQ8CHQ8FGhAGGgsBFg8FEwwCDwsBEgoBCgoBCAoBEAkBCQkBBwkBEwcADQcACQcBCQYABwcABgYBBAYABAUAEAIACgEABwMABwAABAQABAIABAAAAwAAAQMAAgEAAAEAAQAAAAAACP8A+Qjk04TJBQdKqjBpUuVQoUiHIg6pMukSn4ZvqqhKBCnSmSZDevQYMuSIjxkyUo70IdKHSx8kYQChpUwZtGrzvGlLlqxYMWDGNGW52KQIlKFnzlRZmjRp0SJFmoAc4nII1CIks2bFahWq1a9FZoiFWcRkS5YiRaKcceOkWhknZPSQ4ZLPK1qwYLVqlapUqVCAN0mCtAgQHDhZriDJQcNECMcXLFCAoODAgQICAmjevHmA5wEFGiRIcIECAgQiWEnzxrpbt2zWokVzJuyXsGvffrFixWvePHToxo0TV66c8OPIxSkXrry5c3Hgokt3TR2cuHHFx3HjNepRHDQ/ROD/aCGihQ4ngULJkkXMW7h1vsN528a6fqFCSwW6UACjoUAmAkX0URVHVEHEFJdc8scnnwRiRxUhwXTDSGK19ZJLbN1wwxBNHKHhJ8PYVI1O2jTj00/KtKLEEUUNYYQSSVUhFUNVlLVVVCS9ZFUTPVTF4SGc1FiUVFCdEdEgRZ2Vlks9aKihWCm1JdYMcck1V498qPKKLHnplUpffoWyiSaSMBJIInaskQUQObhgggomaBBZBA0ooEACmHGm52cFBGDAAQIsAIEDD3SAhi3NUEONNcw0esyjwgjDDHejsPKLb+gYNxxywz3nqXLWWdecdNNx001015UDXHHhMDPKd2hY/4FGEDm00AIOSMBxSiyx6FJNOL7VJ+w2fBRy0SF8MBEBAzzwcchSdgA5yRHUHiFQFXzYcUklpbyRCFUv9VDhDTP06EMRZxQxV0ow9QCDCkAAYxM0zwgDjYk+BaMMLlcsRBUPQDBUVlQ4oqWVViwaKeNTUcl4FVRkOVWuWE1qmFaTLYUkAwsyoNSxSuKW60MVoNCyXpetqHJKKqf89ckmmEAy2B9vKMaDC++GIGcFdNKJZ2Z6cuZZAQME8BkCDyRt6Cy9CMPL00/bYgulo1QdDT3zrJNdcp+OiiqpYH8j9jfdcGMqqtitmnU419giSBxsfLIIFk/gIB4ObGQSiyyzBP+jzTredLONa9sUHtHh2LowgArYNk6Is8gSRSARTDh0SiFEmPsWCxzLhRZUbDUpIQww1HCLMtJM0wwrvRTDkzHBEDNMIDJSRcQNUB1Rku5UpZUVWhb7wCJIPWZ1RBEwvVRuEbWP1e6EImnIJJMbQ9mDEGhRjFIPhKhCSy1cwuJKyqqoskrLoXiiiWCQJPJGFkbwwEMNKpQAwgUVTJC/aAQIADRnBaAAD97wiRoUzWhGQ1oEMNABL5hiNxCE4CMmWLVs0IMe60hOp7oGqlN9DWzgGJtrzObBVAEHHeLI4Dq+IYxXaQIwhVCDE8qDAyv4gRR8Q9Q1Clc41mzjcc4KEB//GtAAOgjkIZdA1iGacAhqNeEiRPBQIUDBg5CJi3MsUAELZtCuLWZsQlQBgQpcEApjKGMaqnsGT1xHjGBIIxRZIBAPbiCDHGnuYj6CiVYu9BIntYtJ4gqkuFIilt6pZSzrglLHpiSSlJxgi5yr4yVkcQuThQ9l53NZKD5BJjRlAQpMmB+c7ncB/EXAAQkwgP8C4D8BTIAInHjFLnKRAwSyUjMDOAAEMMDADmihasDszgQfYYt1uMMe4wgHczgIKhCCIxxkG5vYqEPNb6CqOCekBzsyVY5wWMMWpmhZKRJhBSvYrQU5SAMmVsGrWSAjG/Ppxje48TggHSJBh3BBAFZA/4cpPHEpkROI7jrEojkeggiK3FgkVcISkZVkCHSUwQ02AAIaLMIY0EgdNHjSk2QgAxjSkMUVpHIDzpVLkBczV1YyBi4fSNRcOkpeyKa0lkUekqYfO6ki15USuDzSiz7gQyu+RwtLwuJkrVhFJlv2MkmgaQ1vCCX9SrCBUppSNAbAjAAG0IAaXOIur6ABAjxzS6EdoAEVGAACOhCERwAzDm4dBS/okQ97NGeD0BGVc5wZwmhKc5rUFFXasHlBd7ijHOzICTRmQYpSeCITbAiC3TpAAyS0IROueKAtouGNadaTE0BsAhEYwIAjTMFZhDgCKDhxUD50BSQzyGJSPrZQLP9a6ZANvQEMJAqCNyEBF9DIKEd7YgxkEEMaw1gDE44Q2y3SlGJ8jC5VLEaSiqlUpmsJSU2n1FOclssqJ4mtlSY2BCxyrFxEOMX3alELSxp1fOfji18EE4kz2UGqKggBRXdGp8r4bwAR0EAN7qkBzwBqMwBIcNA8gwAM/ACucdACXJkxD3rYdTl7DZs1wVGd6JyKbNUEcXWWA5xxkKMc9kixPbSZWHp4gxemIIUnMLEIHIynAyKo7BYaYQpUxKIX2AhHN5JICCJHhAglKIALqjCFw3FCFYdrQox6gAIWoGAGk1CoeVnAEkA2NLzyk+gGXOCCHLjCJtJ4nes8WgzUQcL/CETYmAqey0iYVuVCdPTjdHWUUu5uj4su7a6XmeSxE8TFXDMYQscGOZImeI+9t2CvpE2Wl/HpJZOcjEQlEqEQHuSsBDorDQTqRLQBLGABDdAABHLpmf8lWMGvBoDRGIwBG0v4EdSYBzvsgSpQNZNU1SkbNzz8YRGTkIQlvM6qyEEOFa/YwinGGjRY8QjBpAEHNLAbBnIMhDp4YhWusMUzvHGt/ADJWaVsAiietW5O8EEUEZnEGXowgkfWexJV0FBPNdQVrIhEuxKd44QCDoVSSOPgwx2uMqpxih/UgAUj2MBZ0NIjc1ErXMlzUlvAVRKphETKVRBJEQYxb0DT9C1y/9lioH06Ai4OslwTcgnyzkALXOCCFrfIOfi65ApXKHUVLNsk+zyphBq4IAQcCEEGLDCBQS3gAKc+wGc0s0o9tXKrn2EwAyJgAV6K5xGzANYFV+zsFIfqmdB0DalANZxwhKOb0oSm2MaxjhOy4+6GPaFwSkyOTIVjGrMQhCMWsQg1BIEGHUgaDWqgK1fEYmoXwVZEBEIITtwgAjxo4hEOoQpOcCJdH0GJoUdfBE70dC501GPvpBQl+fUIBj0gAhQkMQyEc9QYHF34LZCwA4iPwCtokW5LycKS1GNM9f4eSYQocgYuJmXl3O0cbXsaF/HKhZDF88EhaAGMXeA80uA7Gf/Pe55JMUlCE5GwQxaKnl/HcCADk3EAA5yOgFKD5uqsvDrWiVaA/kPdAVy3AA/QAo8wDfChTRfEDtBmV9MhTxsmHc3hdhIoQmRjNt/gduNwd9t0d8ZRHB5YHOzggfJBDJngCI4gCYtweC2AY9mGBZjgY7VQBWcwCZNwODTobhdQAh3SEEkUcscjA/U2eicwAirACUQAA3TkAnRkZ6IzJTfAA0QQEz3ABFkAB7twcMrQDDUxXM0gDcbABUAAAyMwAqoXU+GSUjKlIUeAekgYRcXjMVOCFlIWFh7TU5EEJbFVJeZFSDalFtu3C8OwC7hQC+DHXuHTc5WmVExlfoGwBlD/wBgxACcesHRNNwERAAEM8HREcxlbpX9XBxp8YhkIwADyFwELpAWzMA3QtA5ulzXrQA/CRh3zJIt/dYFpJ0+mIjjccIEXKBzKhA53txzZoSr0UA7rsELyUQ22kAmCtwjX1gJOYCs4EASC4AmpcDwzshTYIhAwAAE1IBV8QARNMDJFoAJBaGj1NgIo0BCwh4TBEy5tUXGxRy2KdgNKYAdq4ApYqIXKwFHNEFzSsAg7AAMoAALFM3x31meD5Ed0cXGeBkaBFlvNxUVrMUh22DkTwwKGtoexhQJVdl5icQivgAvDEIiSdpLidzLjkzIrUwqf4FRvAAVAAARG535LR4mj/8YACHAAlXEZreaJn2gZQjlWSNMB24YGs/AL18AatliBsfgNhZMNUslD2yCVVpkN14CVWJmV2UCVhXM22KEcElgcx5hMEuh2yGAKj4CCkLAGQWAFQWArOsAFmsAVXRESa1gWEnABVFEWBVIEJ7AB6TiGY3gCKnADnHAEPABIeHQWWRFFRxBnT5gFbyAJqNMMzfA6HKU61bAKbaICBilTGKN8IfGO4rJbGgJ798QHPKAEUZgV2qNTFFMxPQUDLqAC7yIXHlNlWsY5KqBFqCkSk3AXuAAMgYgLtyA1knYy63GIe5EyLqkJkAAHafBJNHl0HsAB2ok/TVcnDcAAlWF/P//piUMjirO2ABEgAjiGAY/QCyNCHzxkNiQUlVcpldeADdiQDdhwDfzJn9Zwn1ZZlVP5lbZ4lu+RNfIUHcAyD9iwjCVIJpFlTiKgA0FQPFZUFVCBAgngAl3BIiwgmIQ5AiBQmEQIEeIoUT4wIRoXc49JLUf4hEaQBWywC/eSmcnQjzxRDV24C585AmlBLtADPU2SIeaSZxYjA0RAOTdABDywhvLDA2JhZYuUaCtHOrb5mzKgAhJFSFo0pFmKpVESUWcACqrQCrJQnIKYnCjZnGyaF1yiCn0hGIsQCDVznY7hGHLCnQ0wanZiGUNDNEC5VQVwGQfAGQcwfx3gGQ/ABrr/MA3a4EPbYCrcEJXXYA2WaqmLYg2KsqmLoiiXiqmb+p9T2ZRox4oSmEzisGLzEA7CYAqjkAkzJglO8Ja28nLQBRNmsZdtQRecE3ESIJggMKIgqgJGwAlM4ANIOJoWw6IlwQTLRQQosFs8kAVWsApZiJk10Y/NUA0ZpQxpQAO/WTFO0iPkAocTEz0W8oRPyKTyw640ZWVbZltWeqVKGCVaNmcV8pv6uq8qMASTEAmf4BeUdAu6oAtqSog6tx6GKAvtxSWtcApign7qpwQ6QGa/GaxyQgETIAESQESVYQBZNahaJQD94z/9138DIGtCUzRqNQAPcCjTgA3zwUNduZ+a/6oospGz0RBcz/AMOouz1OCz0eCz1ACgkTo21mGMx3iBrKhiWHMNs5AJ1XZ+a4ArObAWEyMyylcEI5AAVdYDH1pve7kBZAsCgflI9GOssId6wddlJFEtSToEYwgD04oEi5Ct/FgT2zoNqOMIOaACKFB8FoMxEbVoKTqk6VoDc0QEirukGck5Htmb0lebZIaahASvWkSEcmaOY2iO5ngDAvFCfuEKgAgMvmCwtkCw3XeS7GVzDetzfvEJldCISkCTRocCoJaxFyAB3dmTg3oZJVuyn1gAr6YnCmZqDXYo0KANPISf+8mpPfsMwTW9waWz0JCz0Ru90WAN+JkNuxhC4P9QDinkG8e4Ds4WLC2UCecnCXCwAztwSMrXA1BBUDzQABTgA1qkAkMooiBamIb5m0fACaTjEt11UuJKFshTIURgBFDwBjQKDTYRwWc0DcQADaggAiMqcHqWop5mJR4SEgJXMVDIrq7HXSkBkji1WzJAOr+JhDIgcDVAOtWjUICrjjbMmwByCKdQPq2AC8aAhcHQC7zwC76gDLcwC7EAC6swVJXmc+L0kn+QBotBA+CKdDhJAZNBRJrYkwMQqK1EAGAMxiCbAJVxGujJS4VyKCPidqYqLKyBRnBcDdWQqfw5x3KMDXLsn4qCDcy7Dd8AH8eogRWGNRd0Qb7hG9sAY6P/IAmSoAhKkD0jARUyIiNMugEMkBIoQJjCSlEgamgocJicAFG7SkgGrHEy9TE9YARUCAsQzI/BNcE8cQsiEAIggJoRJY9zNANVRJokAaUsoHE1oCE8sDEnrK+S65u/abFYSjqK+y5vokVZBLiZHKKdWwOVs8PlAwu1YAzaoA3YAA3H8Au9AA3GYAvgMz5FVVTio1Qq85KBkAZOoANsAidIhz87053gCZ6WMbKBGsYEMMaXcRo7uXUZAAFpbAtr3FnyQR9vDMfT4KnUIMcSnccSfbOKUg197MfHWBwVljXbBBzle8jhcAzdIQhr8AcUF8lRoRT+xgKkAQNky8kgAKLB/xqEHqkCSrGEBXxSGldxNXUDMaoEkKC3mPnK1TANzxAMxoADtBzM+rYSIxG3x1Mt1MUDKIAztonVMJBFW3TM+uqRn6xFG/PJWCQ80ZzM7+K5nxyigAsDUAAJpYDNq1AKtzAMGK0T0/ALwQANvWALszALZwp+KuklnLQIa3AF1gmu7qcz78d0dJKTH3uy/Ow//gyyIGsZZJwAPPmdFsABR2kL0vCo3awTMksNsrGpaAQNofqf/Lmfczy00Vu03buLE3iBmqIpY8mK0cAKcHMHOlItRTKOzMUCF9AAM122MR2iozfNoGuvizZx1kU9c+EDTKAQV0CjyVDUWnjU0PAL0P8gCCFQAnPER43GpGwxBImmmBwjEixgpTXw3qQTW9B8Xj2lUDf9m74Z1rw5A+qIm7iZ1kT4myJa0yZwA1cQCX5RpnBaCrEAUo+qE/dSDAUrNWm6nEflJaUgnYFApzJZkyZgAqDW2BWAxb2r2QUAsv13df684mA8Gi7+JxEQAisoAk5ACsCA0d7Mnzh72hL90Df7n6w9x6YtG/SyvfkplbsoTRwGgdcxDiA9D4n8CGjAUm/bIj2SySjQAL8a02Vb09Q8hiAwjvUdc7jKBC1FEkXQFjdgWlWwfqyMDNndszdRDdEgDMkQCymwAlZxBiTHFTIYmfKjXTny0yu6wrqlrjL/XOhcHc3RXN8i2t9ZijMCzrlgHuBujeCngM2bZAqz4AvL++DaUA3IEAy6wAsFqwuDuHMNC52CIZ3qhwQ6QAMW6xjZeZNMBwGDUhmaHbInKwAFwOKjYdkuzn8LMAEaEAIesFaZ4AuOig2ZatqKMg09/qmWquM4S7RDzr1XaYvXEYHKNBy6Ng/iIB+73dMlUTAzMM0jUNyl1OX8S83ACgIy0ARhyssswgQPgyMDpY1ZsAnKgHvNIOdyHA2jvgs0gAJVxDxe8bYknD2Jht7jUt9XWgMscoQqXN+LHq9sAbm/edWgSZicK0bqjpsuAAWVELClUD6S8AmkgAq1cFx33bzQ/1AMwXC6Bste32cyrqAyoeCS6bd+sR7Dt0nrHJCd3Mmnd7Lrvf7rKy6ovyt1s9bFoUEBLIsBccAL0l4NlWoNR00NcLwo/bmfOi4bPRsNEW3azyDbRy5PBsrGx/hsWMOK0xA8HTcV6W62EbcBHdvuM/3lYyiYG/CbpXmQJKEEC4HvREIwfskiWZAFabAL2voMInLUz9ALxMAFJgClgKZH/yZw7BJbE/JcK7xb8zpHtikXtkn6+N3xYF1lKkBRh4kCzzyifR+sFMW/I3rVWXB+oYDN6xMK4Nbp0sDHDM282IDUxdALqB5pNhdpDlump8BJ7iOTRkCTsp5fIZD92SkZl//osX2K4icbxicLimqFALZ0QCxLa3GgC9taDc6Ln0ed9XIs/w4tvXBco8GFRmDfn0Kus1sfDQDRLJgvVjJu9Ojh48iRIQlHjGBxYsMIEBISXNgwceJDEA89UkSh4gZDH0OGLDQ5xIfCIkVUnjTZg8gRJUxy0FJWrFkzaNCqSZMGrZcyTS5qzPDRQ8YMhEmP9ODBwyDTGTNksLjKggUMrjBcqOB640bYGy5cGJQBQysLFSjcetzQEYULEy5QsHi7cYTejCBAuMiiSVKpVKpUSdoU6pSrWLeATcMWGVu2ydqwVYMGTJeuW7g836pFSxYsWK1OfdIE6U2WLFCA6Kjx1cT/7BAeLlioQGHChAYNFCg4cKDA8AIEjBcYkDz5AxqBGGkSEUB6AADVAQxAgOBBB0G3jCVLtkz8MWG/eJ1Hn97W+vWz3LtnFV9+/Pf11zMrf94UK10HSzZpaCWlIjrhhBFQGOGijigawcCPCsRKBoMWaqKKIkpSyQf/TlqoiCOaYIiImZjQYZOeoAEKM2iUgYYYYnCJTUKmmmpoCB6I4EGpqm6wqioJ15LwxyBn4NGqq5a6CoW0VGASBROaVMEso2qISoUSSmBhBbwmAoGEA71KRJJPFGtFlVNOWaUVV2CRpZahpqkGG2222YayyKpJppddcLnlFln+bCVQMzeRBBI7/67IQgkgYjMhBA5EcDSDDCqIwIEIIGiAgQUOMKAATocTIFQBpBvggR9OwWUYabT55IEFEEiugOwWaGCCDD7Y7odReElmp2WccSYaa6y5BptfgY0mWWWjoYYaYiejk5tuvvlGnHGuLSfbddixh5555rnGlmCakUGlJgAsQscZCCzwrg0k+CjeAiEM8ob/qmiiCBB7sFfAhI5wKUMRj8DxDWCUMYZFaIwxxkVfgNnlDR5u+JEpDBuamOJ1WTCSqiOr2rgqjhEqMiu8RojSBa5U8MsEEEJolAOYYfYggwtCKCGkDTQogTYVahBME8UMOzNNVxiTxRZflIEzzm2wueaaav+qmaYZYjgDLZbR1iytFNQg+cOO1hb9KoQWUqhNg0knwG0CTBkADrhPQ00uAARsOKWWXVa9JQVNlfM0OAVq3Q0DDER4xBdtvl3n23nogTycddYpZ/LGJw8nc8slt3xbdj4HHXR7ut3GFmGO4aWHIVoqogqVImSXYxlUSGADBCdycN55WRBLLB/OzTApHyT0byUMk0KIX7FawaUWXXbZpZY+b5nFsVJqMKgHGNqSAeCT+h3CoBu0IpL3rJBcS6ulNmaBwb1AuCD+CzS4oAK2IYjAAgeUww7WAaYDIABDAAlJIGZoZ1JFoEjzJ6UpQxpwktrUqAGNaUAjGZrZjCy0xqb/0ZipFISSRCBWg4Qc0MAFJmxUpDLAgQxYwAJucwADYig34kiHAjtIxCuGoQxViEA7sCJVAQwwxAQM7gAT0IAHDvcIXVTDG457HD3Aca1wlCNznOsc5iSXrWyhI3TsIEc52BE58xzDF7a4ULp+JzKt6O4ETJLBBRpwIATlTndpEYv4BFQS4eVRfAk5CMmIpDxIqGIVf6qFK1aRClSYwhXAkAUQxuICimGlJQ2hGFq0wqS2HGgvGcmI/PpCkYxYRDrWOaV1VLlKVrYyAMqhQSQ0oYnEEKYUp0hgKzjYplv4whjSoBo0eDKNZzQDGcEghi924Qtd1KIWbXpmaVLxwa/9/yELTgBCDnSQA9nURmY1a+EELgUBTP3mUwEQQAPmVwVQ/KECCFjA/kYVAOIQMQEJEEABFmABD3zgAy3Qgi2m4Q3NzQMcBwUHFsMhDmtVjotdRIcX2YEOclSUHdka4zyYYQuB2GIWS1lLJzmyoIeAcgO18wiCGgShu8AgLV1RgUdAEBeShqRJbsEpXDbAA0184hSlQIUkaOkJT2QiFqRAAhCYkBR7rUtGGrJXD0AWyCMliZTvu8smtyQB+cVvA1316s7od4GXhWBmIdAAzEDAAQ2AQAUuU8EbLlGJWSrmFKG4ZQI5yCbp7eKX0CjGL37Rq2YUwxcD6QUwjNFMZzpza/8/9Vpq4JAG1yS1hN0MgQg8wEIM4EY3b1tAAgyATnoOrgEDMMACFFAAUaGznge4Zz6DA4FbfQA7LWAFM7bxjW4ctBvdsNa1GMrQaxV3HBBFRxcrWo7jNo4avLBaM2WRgN4kwDgEMMA9tatdCXQXXp48kIF0p4KtsEBlXiFAqLCbgAlIIC5Kskr7kpTTd0UABZfo6S0LqAlMZMITqYIFFKgkliLgJas3iCl52fIQraT0kwvqC0nBe5e2vMUvEY7LbHrGJLOCsmcz9QtdVMCDQhwiEfhVTClUjEs1sWlN0nseMZLBTFvoghfBGIgvfNELX+4CNKBxbGlW4cFNQCIQa0D/lGtgI5uzmZWzFqifOCHgAAUkYDqhQqeoWjuqUL32AHTj1AEckIG6DUAEozgGNnZLrW9wbrjBxRZyIzrnOU/uGrxYhlBwMZqVXsC9ccFwRihiIBCo9CEqFe8JKGxesMDAwW+Zl4IrbGi4UIAEh7jEJs60X0tYIhO1kAYwJAEEJXzFBW5VX1lQNgMEtcUv7zMpRGJa0gNN5C0jLalJUQBKUnrV1wv6s1xY0IRCRCISnejEJz6h4ry2WBZIqwUungeMXujCFrFgRY11oeNeJFYzn2nsaFy8Cq9JYhFweAOSlcCD2JzQBWfTLAtZ2LZLNYDLpPpfa6XDZQEMADk1nA7g/wDwyuwgoAWmgAY2CKq5dVwRi5SrXBYpt62If+MXx4AGM4fxU6aMACMQiVfIP1lrvXjEQShjkksNrFIEoaBdIT30VUfw5yp0YhPKlkQk8EvUWChjGAGuQQhmXRUVLMmtDoaLhENuOxVkxC0zBeVMMfKuP4P1AhTwc3cb4F3vamQERzhxIirRiVD4FK8s1qUsVqE1GD9vM9eWzyx4oeMdK4OZuuBTn57ZpmeT+xOFSoQIx8buGtCABi1osjfjZwEKRCACwTmAv//3vwDum26xKkDlU0lPBjzA8wc3hjYW3nCGl97hpw9HN8LhjWsg4xnBeN4uHLEJFMx05t2dOiinnv/7qPe+L3FJaU5zLWh5Lf0Ce9lLFe6aplKUvROkIAUrHLiLNJgABlSfwRCYVALb0/oqtP4IgjqSPiG1j46TNrT5bbcuiMwOxBz56quZxIdEQIKuyQYFs3F5NK0h8hab2QU9gZ5dsDZbuLFmEIZeSJhh2BM+CbetWYW7IhQjswM1uAISMgvDa7LNygANUJu1Iacp05Tg+Dfi0LITrKchgrwD+I0WrJUkMpyDIwaggIZneIZkQAZkOAYc6wVe2IwC9Kj5YIVZ0IVeIAY9gSRBiIUSwAiucy+o4z1Ai7UEm7XzY5K1oLRXczAVIDS5yB1QUgJVKIVVcAVNqIPmC4VVQIX/XtAGZfgEGpCBipCAIWiCGoABl4EwiCCQ2tNC+DM5rDA/OnqImIK6r5JCW/sqipA6UeIqRUQBGCiE+hOqnvoEUDi7BFoTRGo7XtATHQvAgbixXviFYlAGYgCGWogFz5CeZ/ITWFCkaUKNQvmDN7iC16iBbTIhtKkNs/LAzrIfKXOABXgVyOsU4zjB60pBA1jBFVQAWrEVDjAcEQiCRxDC+GAMNVyFbESFUyCFUfBGU0AFVogFW9gFYDBHZooFUygEqLu9Pys+N4JH3YmQIJEQteCkQWSSNwqSiOBCftQpGiCMowkESJACbvQE/viJW9ABJvQzFKiBJ5mNotuLE5gB/+QLJa7SvVECr+EjPiiUH6xrK6gDAReymQqQnwmQnwrQgBqIREiQpUtItlC4RGfzv//7wdhDjx4UrGSAvVmgD3ATjT9xxVaIQJkkFBG6AmyyrMJrgUahDQ5sIRdymykTxt9IgE9Jr+Mgjq0UoiFSRmXULhZsRksxHAxoASsABEEAhDsQhDhIAzRIAyywgrl0grrMgRKiARzAAR1wAjSQBFkYhmFwBVJAhVywg46oiIzQnQeJR3jECpcSnzxSOba4Qsokr30Ei9lhEo+7AA9ogVJQJFfggkQIg59Sw1lYlWGAgxC4OgroGQ/wALMqAVISiZj6ipiiKcQcpby4HVHiw/8LGyuT1ICvqh/c6Ky2mYAKaABymh8TYILAc0lNgMkxmcm0q8kfhJ7N6LYe5AVhKIZuwzZxZAVZyDsgiyYhO5MPMjexuYIrULISUoEUYJIU4gB5k5QXepveqLJ7MgDsIgCuBNCuBEvt+o0BOAAEcAAM6IAOMBzPRLyzQbwUkNAJnY0UepIooYEccAJJgIVSyARTkIZbeAOWKSkDAb6HUDQUnTWcYlHyOgt6rMe0sEywMAuvkBKuMIjzYhkQEIEW0IRYWBM4+IFIMAxGmgVi0AZogA4TuIAJcBIRgBSc8Qu3eitOms+I3J4KTYFG2SwOgE0vNSsTeFB3e9AWyNAM/YH/u9SmHQACJEiCJNiBqJgCJoCCP/iDgdyvmLxEvRoNXrLJm7Qx9PiFYKg2uJMPrVFF84RAMvS71LgDNahAKLCsGHABSn2rFKoNqLQfCHAb/ZSb4OiUABVVexKtgktQD0gBScEASglGBpgVTRFGV4WbgkMAV/W8BxABNsgEVvAGaZAFw3OBjNgelPmKA6nSKGkLK+2KlTkvGKiBZ+2KrwgJ2UBWTlIZaO0KmBEBGliEo5EFwwDXxXAFHnOFRfiBGAiBFWBTJPgBINgBETECKFCCeM2CKWiCLOCDN8hXPiiEKniDN4ADO73TRAiTQikgAqoEY4sESGBYhg2Eh4WDQKhA/zhYgzTIAipYgiQ41xigEh2AApeURKHS07ziU76qBVv4U+3kxF84wmZypFVghXBkBcaQnukBMqFcE0W6q9QYyD9Yg7F51meNgSs1Kye7TwrIDd7wjbgB1VAVVa7EriHqN1kx1QjYDQdwAAQIjuzoPM+LAAz42vrsAChtgQ5IARx4AkFAhVtgGmKIBR3AgRYIASqlJHaDARpw1hq4ASAAAnaLCh4wgsCNCiJggsJlggqpgiqgAz5gXH49hEKwAzsohEKwUztIhEPAXIWNhD84hEgYDHHDpbwit1jYBZ/bBVhQhU44NphM2BKjXDv41y6ognplgimoicAlghr4gW3CAf8NfAHEg1Io9YAo7VIWWiFJgUbOohTHY94IeACsdQAI4FZJCNmeksmZ5KBYmIXG6gxANcKB2LNGmAM/SAWYnQUgPZrqwTsHdCy+g4UIVE+e/VnX4FvYMCG6qFBv4qwWajwRVC1z4pROOcEBLo7rIi3pGI7/OQAGcNXseIAJNVMaeIHD08sKxoEfaIEfCAIrEIRHQIUA1DFc6FBV+ARwNeETTiATTs/mAwVkQzaYfOFLkOEZ7oQWluGETVhjo1zK/VfAZYIsCAQylIWfmqaiQQWIIQU4cIIXcBQTiM0M8IDhpICobKEKwA1KeYBLid7nvVXPY+AYiieqfN4GgN4YYmD/WC24BdAUWuWf5ECAGkiERahe6sTeP9Fe7pU2ztg2YiDUZiqEEHiBFFAENVnFPvFJWcA7m3Um0BgNovSarxEhylICRdmmwrPSFILKkpxKTFnaph3gT9Y3zQs4/9GODkACQOivTPDGUQhH/kMacixCzViPIZaEyM0C95TUbFJTYD0btKnP+nyh5PxFYcYN5ExOC9DiV8kO/qFVBnDjBIWEIsYrmTQFTyCFTMCCFuisB8gO5OAfUQ6gVhLncSbnclalANCBf10EAhKqm1O2WzIaNtneRc7j5zHCHdOTT0hXI9CADzgCRQjMHZKGWvgBNliFPRuNmp2FvivKT9gER6Us/3ZNKh0woUuVUOHd3yqGoejNlE0B0BMcAALeSmVkQVqNJ1spyxz4L2AYhsMiBmVgEWAihoRJhmKw6WJIx1EosizQAWRtgRO635/u5Sg9Xgj4HwRo3qTeDSkjp2BUZq1tYzfWgBhoAOSI3jWIQFdIBVMwBVLgalTIAW6mPHMm67I2a7J+pQBYACZ4g0BY5wJCDOokjDThoHmmZ5ts2efBhRRAgB3IAAVo0knIBVWQAiqQhUBIAQ5IBFkAsukRSleE38gyMiSDAve0RbNQgQiN0l9WXimrN7gB1U9hLVEJaZFOwRUsuM4LWw7ogBfAhFvYBT4Ohl6hoPK4uGPAbWFoS/82gIMsMIKHvNJG8YuidRTjnWL7GQ4EsB/dEKdxYuCnrpvpIOdTCjgdKF8yZIxY0G5XyIGxPmu0pg7pHjhwJm9wdmMEmIASeAPLdcmEtd4xQRMyrGu7np5tg70BzAQEUBsHuAAFGAJaeAUWMIAGwAv3WoEwaIVoa57m2buhXCTJDoTJegM1yOVnJdOL3kUOPM5fxJQZ+tTiEJXRRsFRza4VxA4I+AAl4oAXcINYUCxocJZsYAZmAJZgGZYeleAtdRQXIskrpgCk5XELsBnk1QDj5ewMOE4MaKHOAlv8aV4eZ3Iw3awIkBkbyIE08IRYGAYUAQppUAZgOAUMFgHD6WL/L67VBqbVNFdz7bhVw1lQsm0BvQyCDUYDNIiDOOjgR1DlUQBHVCBD7V0PAMSCBzCrVwAFO+hc/LLe5ovvTJQF91jk+u5jZdoFQ8iAGtCNC2CBV3gFTpg5ibCI3oiATsAFWtgTRW3kQClKwQiEO5BYC6TkGsiBwju8FIDSoq1PJFfyTeXkFgSO/kwvExxxqI3a7SKOBaiAKP4AC+AOxYkiOGOHeoAcvdQmHeDbHHgNa+/bqDACJYCCb7+CKciCLhj3LPjXNfhZ1kAURGkNSUWCd09THMgBeTe8erd3w4tbxMMBJEADQADH+jhfVMCEO3jLOmcDOxeERUCMTSAFoJJv/z/tXugxR3N0EYaB6RU5ERSZhmkAiqaZmo8H+ZAPeWlghBAAAhTgBFq4BMyF4WS7KzRxtmey65otQh98HlpoBVA4BDkUhVx4hRnortopMAlgAebJhaOPNvM8T8iWwEKBhEWwg59VlPqddROCUAz/UiRvmw73VNHqT67sN8wr4Ou6ru0SAK9UgAmgAA3I2u2IA17YhnmQqHbAB3/gB35ggzTgAiioSyTQgTmfc3bl2x/4gXc3fCewAifAAsW3Ai5IA3SHg8i/gztYZwLSBGs2zWw8GtLgoMaq2TZJ5OxkD5T9P8cITGDg44pPGIXp8i4X+ZC/jNiXjNmn/dnXhtvH/f/cp5PbpxM68QZvUAZHSIIwMIMZUIVOX3kYnmaYz0SZ9/z1mDu3w4VXEIVNB4UzAIWj54QZSAB4kQACsAgCeIWjP/pTV/o/+RNXMI0PmiXqncVEadNrL7x3Mwt4g5Qu1XpK4dRy4k+nBZU2BogCBAYSJGDAQAKEBQ8aUBBgAAIEAx5osZVtHT169fxxzLTJ06eQpEyxchUrlixZtGrduoULly5du2bO9AXsJs6cOm8SGwbMJ9CfOocRBeZLl01fNoH1iikz5q6cxIJRNWY1mbKs0LZKm+a1GlhsYq+JLYtNG1pt29Rua7vNG1xu3bp9q2u3bri8etfx7atMEKZLhwj/NXkFitOkS5xAlWp8SlUrV7Bk1UpJuVYtW7Z8NdWFixYtTmdecRoEetCIM5xmCJBwaEaDGbRy0c418+UtzLVoUZYFy9WqU6VCbpIE6c+bLFCgKAECJEcNGtJpuGiRQgR2ESE8cMiAwUKFChMgNGigIAF6hgYIFCgg4L0Agezb02cY4L6AAfoLAAAQAEEEECDwAA62YDMPPfbko49ROwFDDITE3DRMhBDyVGGEwUToIIccKoWTL7z0IiJnSo3IC4q9qMiZML+4+IswxxyDzDLNNPPMM9FEQw011lzzIzbZuLXNXHB5sxdf8yi5ZEZNOvkklE0q+ZcnnXSi2CGgiCLK/2GgnCJcKpDBMpkss8xymWa2FGNLTLi8MpsogwgxiCi5cLJBFbS8MoIEorTSSm2z7WLbS7i0hBktufkG3JelhFLccclloRwSz0UXHXXWpXCddiFw0N0FGVgwQYDlnYdeQga0B58ABLU3AH303TfrrP3dV8AEE1DgAAZBzHINgvY4NSyxxRqrS5rJKrtsmjGh+Cy0KL74ojDVxniMNdlaQ42O0QzJjVzfILmOkk3ac26U6arrJIL0LMmXXt6spU0100RDYzDArHJHHXQokogqh/QwiSivvKKKKKpA1sqYlN1iZmW23GJLL8YgtctntIkihBBbynlCAhKMsIEEJY8wyf8rtQ2Ti8G4sDSTbZWNyahwoWgSSSDJXZHFFU78oEMO1NVQgwsubKqdCB500AEHGHxnwagBOsCAAqemut5BBMGHXwHoVW2CCR5U4IBEAxhwQAIHHIBAAxQosMCAFQEb7bPT2j2ttTIewwwzzvjtd7c68tijj9dkc7hbdImrF+Ph8IVOX+Tao08+9mRE7rrsZq7kOnnV1c022VyTLTXOMHOMMChqNgsrpowyyiOPxIEG7WhoEQQOueMgQgstdICBCFlEsochhUQS8Bk+nFGwwa1A9krDvaGpmS807QJaLoNor70oIwiQAAGtblDECSILcTJtKwsxgyiG4kITZr7B4nz/KsJ9ookkOauxRho9O6dDDQBItOps6mhKY1oGvBM1CDjAAaZC1dUKMhD8xKcACrAAJFRxi120QgQSOUgBDgC3qgVAAQ2IwAMwoAVWHO5w4ALXXMAhQ3HQcBw2HEc50MEOduhwhz78oTuctMMgmosePnRSPZKoxHrYwx1KdBJHKse5cLwrL3DRBjbqNY1nNAMZVDlRmlghRlO47nWxE8TsaKeF2+Eud73rXXbiKMel8W5pS2taCiJRCDrYoRKgiAQf+DCEIYBCT3pSxSv+RKYxkWkWFJMJMHDRCoPNSQgnOMHGEjCCGWwgAQ04AihAcAFODKEBKRuGKEC2gZQVaheV/0nJb1bhPPsVZxF3+AMc1IAFKFTKOUAQYHXeeJ3teKCY3fkOqSKQK/IwgAHoUdsB1GOA++hnAA7YQSiAIY20eGIAAYDmM0n4kBQ6rQPvOOc54aHOdKpTnfJAJzzT4U55tHOd8HhHO/LZjnq28x73gIc74FEPgcLjn/yEhzzusY97KPEe/ehHPujxC9aNYoxlHEUmYqfRM260o48QBEhBGgc0xqGkcWADG9KABicg4QdBmw4OaPBGo6mgaCtwwU17pwIVmAAEE1BACYxwCUMYohOROIQiCEGIKvRgeQZ7k54MJj9Y8GYWMtlFTG7hildsTHuVBF8ACHCCHnRyA1uaRP8RQJEL9Z0gAJis0/tc9spFyVIVNaslJAJhhzXwrDlGMML/ohPM3m2KmMZUYHgoQIFSVa1qEExbNQfQgCSk4hbEOIs2jPEDaraHIQpggDcnwoEcIGEH/NjHaf2p2tWqVh6uZe1Bl1gPJ8pWtvxohzpwq9uDulMd6ogHPNShTnXsYx/ssMYab1dSlJYUEHcIqSCca9LpnpQNIAUEdu9QUkFoF6UoTUNKuYAFLLAUCUgIgg7Sq94fAMG8zvmrEXjggyKcrzUsKEElIvEHUBQiEYmwQxUCeYYzEMxgoDkwgl8GSWgAQxaqOAPHOMYJkEkgAQEAQKsMcIFXEKXDqCxfa4T/MIlcvARj8YOlZBg1HPxJQhKJQM6koHCF5QAWCJiSDmFTEAIdF/MDGkhgAitAAVKRhzzmaawC2nMABZDAEK7YxTSw4Y1qPGIA/XmPQaB5gAFUgAMqMAIfLvEKfpD5H//gCJrT7A8y88Of+OBHmvWBjznXNon5yEed8dHaf+45ofGQxz7iEY99uFYegpaHPuZhizXioAVBcAKkI+0EK4y30lhAAxtqp+lN106ltbMCqEHN0p/lLr05iKl0cJAD9ergB+w1Qg/ouwEBuPUMKzACHYygx/4e4g1KIEIT+HAIPhR4NrQplG2Esk1p6IIUpRkBnQYxCZDNoAcn2EADEsKH//R1OBeXJACqREwLXJBYrpaZTCztFxL85XWvk+IZFAALtBy89AUv0FRht+PjT13gAhYYsjIjUB5TLSCEuFrBDhihC2jQaxRWvjJ82rMACIRABTXgQyFzIY2HctzMHlezP/7B8Y6DHM1whrPJUQ5yffiD5Sz3Rz9g7g/Ujjzm/ShuP+zRjUdo4Qe5ewLQnxDpIITaCpIOAtJd/bMfID0I5n26eV2tA1SjWqaciqMdRWBHOm5qp+Wz1QkOcYQaZGEHOwhDIezwB5wpgQdAUIKwLwEKRM7mJckehjHwvotYoGIVG5NAxwZxAgLQSpNDyBKJiUIbwUugNQHQXhHqVO7cxP9vka5oRf0aYzNJROK/b7CDpJjjHKnnwAYxsLe9rUOCELCe9dzpDniETGTyOGAA0VTABkjwAjfUQhdoeIA3bTWrASzgAiqQgWqeygk+1LwfIn++zWHefI6XfM3WP/n12Yxml7c8zdGnPkc4rg96LEMLeHApDZLealPrrv1Vnw6OaXDvN+b4aB3A+u+cpv/9W+BTTuPAHYWACSRAf/jHCQzBFAiPHXiADXxeICRCzijBDtQAEDABHUSC3D2Go5TCKaACKpCRScwCKmgCKFiSaaRSAlxbAtBaADTABfDAWq0MbYAYuAUA4HVMLowbbpzYK83PKqhCmJxCKHTCzUAgBIL/HrwpAaQhgQ7YgBPGABTa26asHti4XndkQL8l1mJBgH6Y0ARcgAZ4AA2IwANIxH1g2HscQASYABGcgZag1bWVR3HNYXEBmh3eQ0K5VqD9mWsNGqEl1EIVWkL1WR4KmkP1g5611kIpFB6qU3HhmT7Awz5A1DzMwiM0Ah7gQRsgAiD4QScCAieGYifewR04VyD8gV7ZARzAwRq8gSu2YiuGwRuEwRp0wbtNyoz1kqkNDS+6AC+WHjD+ABSwAMkkwAYIwREkwRpIwim8QQwswRv8VyLk1RtcwXtdARasASNogiZ8QmOQhEmswiqMgiQsAijIySCkTBGk4CQMwgyUj4U1/wAhaJzB/B16SMAJoOOWFIEqvMRKrEQP+mD9CMcmsFsgwIFe6QwvtdfP1Bvq4dt2hIB2cEcCWcDTiAcDOcACVM0B0Ic30cqsgFsDoMAQVAEokMb5VFjaLEBxCZpL8mGh/dmgGdqhGRoevtZquRMe7mRB+dMgmlmbEWJM+iGeDZQ/2cM1wA4mukEa+AEi+AFURiUiTOVT9kEp3sEp3sEqwsEbtKIrfmVXduUaqMG7YcGMQUF5+ZIADQ0NQEd02EAO7ADT6cANFMEgDFgRTEEYYEEg2FUldKXaRQIkWMkl6JUaqIFKscFIOYInoAIrnEQsrAIpeMIohEKczMnGhE9rRP/eK0wCKEwCClAACtAGLQjeCpZMJWnPJTUBLgyDyyhKD15e/djVcBRkOULCi72BGszYEv4M0Jie6aVeYR2NdnwKkH0HRjpARi5A2ghEALwHftyHMc5AFaCMKJCPSibE2rykILJWHvqka/GWOzAUQxFUPZTnQJ2net4DPzzUPiAUobkkTdYkQ42nPAQRL8QOI6QRIAQCIpziH+BSgAboKpKiczkXHPALHLDBVjYoGxwmYqYBF2Cj0UVaS+kivQVN7tCAqrka0uEAENSltFXBEvCPJIREKVzCgEZCJHTCJwjhJ4QCKZDC62DU66BCLJjJLADHKsQCVcWJwZTPCFiYDRL/I4dVwSFoACEMwysIQeO1igQMAsnEyQnw4y4MgyuxhG7Ij/MoDBDCKIuVY0LyDM+UV0P+5undWwrkGHYQk3EiZ8AxUDOdB+E9BK1JFgscAcFQaSeBz3zohyAOImvtZE7W03gOVECNpzoNqkF5p/O9Zx4aGjzIpKG51jsE1D28AztsA+w4wn5i2iIEgqgOKBz8gVaeqoFm1yrWgXe1KhuswatGaBqYpVlKGtT5Jr2p2qq5mnk5Ae5YQRYwARMcwiHwDxdownHokR0cwh8kgiYQoV2lwiq4ArWaRCyIkRjpKGTKwi0wqShIwzBMwhGwzCHUwAZoAAlUQS6AAhGgACgM/4NpwgdqmqAQcNiVuqaWbumY/MmfKAyMboJt4iZyrMFY1uqotdQOPKG9ZYqmtOl2vCnUQE0ESA0DdOSrKIAGwEATvGH5lIyfhg+sFMBLwmRNVup8juyk3gNwARc98eFNxsNN4qSh7YM//BPMfmcfVuo+XCo8pIM5sMMvoAEmcFdKscEihKqoJm0gkCLTkuJWuiIrsuJYHuZYEiz/ICbP7EwWmOVyOIESfK0R9NIO6IAvOUevIkEOOMEVfF4lfEIgpMEyfh5yCNshJMKJekIpmIK0VutJOGaOmolmxIIrzEItDIMyzIY0SEMumAEtJO4w0EISlEANEIHdrcwlreB9DP9EAmyJEBRBh90G5VEeb0zV/PjrcITC/bTYi9nBQfLPFfQMEpSXqcEfw25KFT5sAjXN0wQIBEDAAixAeZRAFXDCdTbA90gA4WFZrAjAyLrkPU2qoLVT864sd8rDbzVvHzYve+pZT8bsUL5nQJmDO3zDKLCBHzCCSp3U0Y6q0p5qgj4tWHIlwULo/ljtLd5vFnyt/upvje1AjQGB2bVX2jKoJpSCKpQCJNiBcUxBF7zBHwTSH1wCJEhCKIRCKqSCtZ7E4LKJUviChuDCSdhC4m6TNjguLlQDWgxDIygCLlDCMJRwLpyBx2Lu94jVK9xl4hoDMOiCbrAE5cESus3PLHH/oKMQoXEkwtFqJWLu0i7JbobeWDCpQArc7usZJ9QQmQVAAAUMwfJkz5XVaVi1SvisykvCEzzFg2+pgxmfUzyw8che7/RiL6DVIULN51AmVD6xwzyUXyYaAhdgGhqM6oAOqFZuZSuu4leuotVOLf2mgSNH6BWkwdaa5RUswRIsB1qa6a3+ABLEGxO8ASSEwin4RickQiUYgix+3hvo1yVUQiUYsJiMieC6wocAA1VoiCvNwi6gcFokbgmjRTVIQ1akBVi8AjyGD36AG+BpjzJIAzEcRS3MAkocyomd276uQpjQ5hDejHGEqhI7cpmOGtnaGFsWTdHs1O1uhwb8mKhE/40K2GXKiEKfYi41sUqrCMAapzE6obE6nMMa/zNAv8OfTSpNFjQg4gM9teyk1jE8BGU7/Gw4sIL5lYEYcIEjc4EfDPIgS+0iw2JHW62sHqaEOrKEXoGxVpoULMETYPISXqikyVgT0EEieMIqyALGXEInlEIi1CLoFQIthEIhdKMoMwwjOYxR7IJNUIVR4MIsKENaPPVTBzMv97KcVBh0+kcAhMwJzIkwEwMPz4JkxgLlVbNl+Aa//knmoS43dvPScnQS9lJg8SIMnDNP3e4G3DU7Z8ANmCRtTIKTlgwYPyeWsYpAu2RAs/EZ/1lht7FAhyc6tdM70BNDq9Z45sM9HP8qeQaUnenDP/CDOcxDNcSBG+wBKopqVILiJ5JiH9QBa6+2G7iBHqxBG8hBG8xBG4yBHtg2bYcBGHTBFlDBFnABGHDBFkjBbx83FUTBEjSxEyxHpSwdpEFBGsBBJ4RCKZDCuNlJYiCwHYBeAzerf1WCUEurtLLCDksIMCA1UxxFSUjDVIMFMSduMMt34sbwICAvdAqAfxAAPtKJNECDV9eCK5iCJ2SCWMsMVQVkIqkCNqcCKjjK/VwC/oQqcpAlX+Vi2T4HdMy1ObtAXZtACJCKBdz1p3TAG1xCnTRpyUhAtjFEe0gQfRw2QPvWYf/ZbLkDjue4EtEWjicRjuPDbC3/UY9v9kOxQzjYQhBAZWkHgh/0AXY9OdM2eR9MOWvXwRzYdm3b9hho+Rh0ORhsARiEuZhvAZmXeRSc+RNwbXMvpEtHMkJ2wilMRmvmwsmAAiiUsh3QAR24oiEkgiK0rXV/iTiyAjH0QoncBGcAQ+voAnwDM72MsHsT83yXZsduTeb2t8Ypww7Lwip4AiY4gilUhqizBCzJQiL9CY+igrqlLiS0myrHWHO0V1xzOIfvFE91GRaCAAeIgBJwwmw0aTGayqlgjYvHuIzD0zmcQxrrsxkLWo4/e49Hu44P+Y5TuzssSD/cAztcQxwEQWp395QzrXORYh1I+Wq3dpZfeRvc//a637aXizm8k/mZb8GZo7maLyEQRJpJB4IkaAIivQK5gYK1LY+dG1UiBBIfNGskVMImVPApTKvgzgJnqMizNIXrJIM2eIOko/B8kzBauLc0XCc+qiR0hhWmg+su3EIsmEImQMIiSEJMxIItyILLlPXMSMZvuAJtNsYnBGzSwphyMMeMNQcP8AAvDk2HqwAIhOH90UATTAKcWBLJsPjAORZCpAcIFQA80fg5Lbsav4M5JDvXo/E/u4M+QTu0t4O01wOQQ7uPuwPL/UM7zAMv4EAQMC1XvgEcWGXTMm2Vs7Yb1EEfXLm63zYYtLu7jwG8h7mZm/mZS8G9t3RzT/cidP/jKQB8LnRPCgoBYiwGKFyCIhxCISg8JWhCBZdCKpSCY5oCMNjCszjFLFQUZkG1pHu8NjTzMJDPJXlsyfN3PuaCMmAMp4eCcUCCILACNPCCZrgMaFgzI/3GlxJxz7Nbq/8XEpKpcihBfBV90fMidXg4CniACORAFmTcxowMi+fKBFS91zyW2nR9Pyf7OaSDz5qD/dO//Yc9jceDsnv9OegTQLQT6M5dO4IGBxqsR7DeQoIPH+rz968et0c4frDRCIcOHThw7oQU2aePGzd1UJqso2fOnDZtxsSUOQYMmC03ceaMEmXLzp1SnkCB4kRJUSU6fiBxciUNnEB/LnESVWT/kJATQgZNOsQJVNdLkRJFolRJU6hMoUidMmVqFKtYs+DGWjtqlC1v2rzl1YZ3795q0vxqUyYtl9UTJyQkTiAgQAACCbCKykULVipPmBIlWiQpzjFsvGzpwkWLtCzTp2XBgtVK1apUqU6VCvVpkyRImiBBevpmjZo1WbIIVYIESHEdOXLQUA7DBQ0kdiTnEiVkxAgLESI0uEBhAoQG378rSDCe/Dvz6tCfO5cunTn37+GrR69Ofvp0AvEbhJi/oLuG/vGBSEB/CLRnGRwQZCMONuro6CORRuoDpTokdOOlll6aqaaacurQpw+jSEJEJ0h0AomikNBBRRWTIq6JIawS/0JGIc7gZBKuuuqqk0400WQTT4AkBRW26HrEyCPpMoWXarDBSy9tqvFLmikB0wYaZaY7zCrFCAhAAAEgG+QMWlQ5xZNMbEskEEkeGWUbbUAbjZZaakFNFlpSW22VVVxZ5ZTYPtFEkk0EzS0QO95IFLgrhCPOOORyqCGHLiJRJRfprNrgAgwwiOCBCyqggDvvwFPA1PLMS5U99uBr1ZxVYVU1HXby0+8h/gRayCB8HBIQnn/8oSccU1p4gQYF2XAjDzregIMkkiaMNqWXMhwjw5pisqlDnHbq6UMRkygRiXEdBQKJH1gEQgkiiphBSxkHEUUUUOb9889SZEMrE0+GJP+lLVMecYQRQRzJJJO6oMGmmmrCCecuKPdqssq7pBnmlSKwquowCRZjLIGrxjwllE0wgUTNQAQxkpd5ruFFFzrplAXmWkjDExZXXLl5T0A3oU0S2xY59A9Ef8uCUSiGKxeIHxaR6lJRzjhhBBQ4wM7TDCzIelQISDVVvATmU8c8Vlslh5z3YI1VVVptPegg/A7StZ3/3Cbo12CtQbCFFjRKow0x5EjU2WhVstAkC9twydqXbAIj2w459PDbJLAYStziyFXKCaSJ8OGwEwYJPd55RVGlzFNM3zMVVDxZS0hdvIEmE0ccweTgUWaZRptrsMkmHGqEeSavJhWusq+K5Z3/JPQZEVvsYxpfKeUToJ8CxJEjr5lnG2Fs6X7mOWk2TbWcdV5Ftk+kJzTNQNQkGjjghEIa8zs6eeVpjFEIQQQRPMDgAQc4kAGscWcCBSRVA76Wqnes6lXtgQ874LOqBaZDgexh235uxR8B1YNXCfHPO/qhD3r8Ag1o+MGxNOKGOaxBcCk5HOJeohE2JK4NjqPh4yCnrZvwZIcfWsITSkQiJUAhc5ojIrvglbzQ5eIVoCiT6Vpxs5zFIhauYIVb8KKMK14RLrzwxjzWAcZ5aO8b0dBdGBsWDidt4y7DkI4oQjeJSchrECcYT2IO0YlS1OZnkqDdE+LQpl/MQ1i8gMss/6pYilPMSXzjw5lrYjObTwTqZ0ELxG54Y7Qr1IAG5lICEIwQiFbQwo3TGcEGVLA//nEggKzEWgW6A4HuhMdUBxibA1+1wHaYw2xmc1UDJbiqCxakHewQ0DEhQrcB2SMco4gDFoKQAzWo4SVuWENHCGeSNhyuDTKc4UxosqFt6dBb3PKJiIAYxCEmbVwlAgITMBYZOhZBMk2EYivwOUVXxEIWb/HFLg5ZC1vApRnaCMcYx0iPdYSDGceIRjcQqkZtsLGNb+QKJ17xCnlFbTwnAEUlfPYz2j1CI4I42DbsYY9sgMYWsahMKmJmGpc6EpL4Op+ggGay3fQmC0DQwXCAkP+FSIACF6UsggxOEIK9tWB/IfCAB1z5ygjIcpZeO0A8zoO2XfKyl13tpavYEdaw1mqscLsVMv+jH4Pkwx7P8IIffvADHKQhDb5hwzXpsIY56EEPdUCcSbzJhjTMBCfk3JY5ebgTcIUriOIq4rhywIQYhQ6OlHUjLV5xz/Gphk/7nIVpVrELYMhiLayYBS+WQQ3fIRSM3zgoQr2xjW6EYx3fSEYsPgGKVuxiF27UqCgmIYMEnOEUg+KjHx8hCI0AIhOP4AU97EGPlcYFFquI6WdVk90+weZes1EfJNZ3BzhMEwlZUIIRqnAIVZCSiUVgjgpM8IKliiAETn0qKzFgAe7/ELBUCogHVtWBS/d49au/dI9Ya5WfstZKQAPRldvsMY9Z+IELyJlrF9SwkY7IoSVz0Ca1AjvYa93EsB7qYbcUC64SCaVERlECicjVhMmODrigyOhkMnrPVuTMFak5zSoWcQtcjIwUj7idKWZhi188AxvX6EYYWZvGcqBjHrEjBjCIcbxh7OJSrziDKqaHpj5e7xFoYMMdHEEXa6RUpYZEJD/rdEhYnGZ8qoMNvmgjqELpRrxwyMIaoPCGS4CCFrmwWBNuoIMaFMsFKmh0CkxQX/pCNQMYCJWoZolABaRKHREcMIEJfGCx0mrUCTY1BhnSH3eElR7aEMQinoAEBKUB/8MZvqsZ5EAtXcdQhnSVyYbEeVgUf+jEUfihUK7AqMZaDsYyvoroRCcVUdivZhnFp2pwsQtcjEYVmrDDJyIBXvA6QhBxEETKDNYWWwTPGtugLZSJyQ4wrgPK81BjNZSxZVy0whOSQFNukEvSOsAhZY+YxTrY3LIkz2JmdsqTK1qxp53heRM9+64lA/EGOwyavVC7ARBygAMauIA5Lmi0ClIggpQ7NYAZqMAF9DvVBjiAAWJ7R4AFDGpQixrBo0awQHxOq7eplW7FlDcv0ACHc4mc1mvojRrCEIZd77pvdE0DsCNX4h4WG0RReEJQoJDs+I09iEAogpaWlzF5TRuz1v8GBepY8wpuqwIUf8jMGwoRbkgs4g5piEMJF/R3NAQSyb9gBja8EY5yiBWh9CDkGMOBDWgQQ9uWqQ3tFrGIlDkCWQV/BDPswVbpDjTJt4CZnbQbcXzWVJJ5BtoiEgGJS6x3GBargg94AATl4KAFNagBDEreghQIv76UzsAFQEUBmTNAgTfHpc5DbY6gT9/oQU+w2zpoEHZog6RqQAIN5MuF900zDF0Ap7W4YCHBWv3qwT7sDsvZdRB93QphHzvZ3Xn2Z88oK2v/7STOoAqOgA9wBKOaiBMugQ804RMCIQuaggvgIAiCwArQIA3QgAusIAOxQA3iIJDaoheg4Rpky2H/6s3x7E0bpsEYdqEWWoE2aGfvMo92zIwNUqbcRmEd2Cq6rqF7bOEWTK9OHE418mn17iwUZKPicEoSIqEURqn2XmEShoAIjADklKMFgMD3gM/klirSQqDlBMgCYMk7HACrbo4+4AP6vIrnEGxW2LAd3oEd3sEN3dAd4pCYzMMgzKEd8OEeBmIdeCEI0sAKvk/4sAALgKOuuqALHMdaYoILuIBa0oAL/KaGcOj9QMRbhu1bSqT+SCR+lo0HtmRG4GWO1g64zqAIUDErQucQuoITzuAVO+EUeGMNJJELcGBFJDANSEQNEiUQBqZNUMEVbIEXguEZpiHx6C2N7gIajOFl/1qhFCShEWgH83ID8MztEfDgEaIhpfKBHkbPe05PZkojNXAG4lYvkiKJNtSnFFShqIaBFgBwnYBgB5LDCnmAB3zP5FxAviCN5QTo+GIOAhyggtpDwAysq3gJbVglwM4jHRiS0xwSVmzOHfIhHyYCHtpBWB7BCn6AC9TAEbFACqSACqYgEaOOxBiRJhYHJrjAcbTOsLql2JJA/qKARNAgCISDiMblBySwKNjlXTKGFNfuRm5EXjghdM5gEKQCFJQnKzjhEA4hEcZLDQKhz0QCDtbADgIhNyCBdiTBE04hFd5CF3zBGBImLxxGG6RBBW8hFlhndgRmGuVyLtskGzjIH/+6cR0Gik6qaxRIgc5wBp/wyXRiA1+MCwkXUBYM7R3PwAeGwGjkx6dqYAd2wPdioNGKRfgmrZWwJiAHcoIM0sBEE23M4RzCJmwU6DTZYyIrciLkgRzoARms4AkcEQloEwumgApI0iTDYEOyBVsYEeu0bltokiaXAAucIAMZ5QqUgApEBAmwAAmOABUnSwhI8VKwkxakLaOUSEyygl5KcRL4wOnWIA0SRQ3qCj3T4AqyYJqmiQ2cYlDQJxV6LDSCYTD8YvJ2oS1P4fIYYREYQS4XYS7ZBA1sgR3gwR/0QQf3koqGBAjzRDBZo6bSB30CJRRUobeGARcuoQmqAAoWJTL/d2AeK7MGLlMF5Esz+cf49GuWQDM0RzNG6+M0UxM1FYgiJYIf4GEchuUHbhM6ucAJcpMkp6AkwyCcGgc4fw3r3o/ritOHqAAKlBNEhaJIkwAIquAMaOQMRmAQXiFesHMYqEQZpA245qgplZLtSEOjzoAIpqA8QTQLCrEQr8AKOnETNxAQwEsSfERIxlK0iOHK/ukWXGGPJOE/AQEQzi3zXm0af+YRAoka7EEi9KEbd5DhbgYVYsqRAjPiXCMV0CIUjJAJSUkacAEUNM4OsgBRIPO8jGAKKdMym4MfV+6+Ki0gm68gY/Q9fOmX0mNG0YPTzkNs3DBV9EEi+LAcokEL/wTx656gEJ1AJEeySLugNw1rERdxSZv0xJxU/qRgCeoUDYRiDa6AN5CgC/igKphnELpsMWtvMKQBPOFoFOWFO8OzCIigC4LDCYADC54gAxsLTyEQEBZhTyuOFEwBFeBsZqorFHCDERIVEELi3BZVLklKC1gB4SbiH/jBHnaQn6hoU6VIih4p4kghFWQjFZpQGXahFMIi495gaEL0Vc9rHmW1CjXTqfwx+SKgDH9VPc5hVz+tq9jBIenDNGnUZ29uPcKKgt6BQHS0HMKBFXBgNp0gncJuCZZgWqn1/TgkW4dTJ560627COZcg7NjzN/5AEyohS4HyBM4gTMW09qZkGP9sRCrUVQhKcW+V5xW7wESS7Qrm1E4bSynQVg1AIhAyb+/Aa19I4XFJoRRIwWElQSoDIWIhJPM0V/MEQQLR4BnoQR/6YXT5gR6sYRaEkeEgNLtYtxwlbk9aoRbmVhUu4RISwQ5wNxH+IJMYxShg1USbgwb2plbry5Va9DSDtjTVQ2gJLKxK8zTnY1jNQz1mxT0oiECS1Rq0oAWeFTmvViiktUh1kwp4qEmBjTjLFxPH1idw4mzDzhBBFBaAARhwoQm0JAEIQAKEwF1rr38JQ3lIESvkyShtRI7k6AyYwAmAYOwKMQMJF8butK7W4COcYoIVd3NhMBCwsjxFQmIh5A7/GJVidYACR+Eb8uEfRrcfujEaSC8c86SRSNYVVBYWStViIkETbPcPxMtkWLVVa7ZEYwBnU2Dlii+Ajrc+knc+gnZ5fykd0tB5rRdWGgg0y7A9ICgOgeUexqEbbEEEnAOIbLNyliLZsGB8qSAnIieHSiwmu/VJd6hyyDg4NqH2jOEWOGEETkAAAECPA+AV+veP5/YoA3gUSdGAoa0Khog4hmhzHPiBCxcKDDE932CIHNA3PoLvEiUNDDELHsSDIYRiKRYHguAJtOAY7GEiFLRS54EakqzhHC5PHEkWbgEYpgQXAoWSJOEO1sBQFGU5oeB3TVQ5UjTl6Kt4v7ACkBdY/01zeYHWVXoVioHJgdhjgoRV+tiGQOpBHLYBDTrAOUxEKcZl7K5AJHUTckhMONe4fNeXJhuYrrAgDeyAlIgBFdKAD9wlAAAgnwGgCAAZkKEmKyZhsuSoO0UnAJkACoBgc5iNRBw5iDRHc5gCc14s7NJgEShYDQ6xgz+YczVXEFogCHAADUo4HyqVpBWUHVjYFmYGCF1YfGSGlglDFRRJesBrEdhgfViVPZnzd2MgOYa5qYpPA76Qmc+jmd8DaJOXNB0IIaPYIKdZeo1OIBQ0ug5E5JwVaysH2QQXC7hgC9I4jbcVJ2iijS9RfZHTTj+yDSRBtHSBFR7BEM4gMfQZAP8k4FIA2a4rS15mTI6gTSmV8hDsb4zntITQwJGtINnQEwvEjj3TgIUe5IIvKfMut4Mxd3M1Lwb/DrwewZTZyqT7wR/mwRkOKRauSEjsBAizTUwJ4xQ+oUzSJwl1Y3cxOk6JiAppwAZsgFbra7c9QKgF6GiRdomNWj6Y2JnNBpobqFXS5ubiMKwKolIdj2rB7+u+F9nQdqsLUY3BelvTmSbVdwvOmile4hNwwRd0QRuK4RTuWAj0GAACYAMKzV2xUzoGOksypq/jyEtBAQrUYCiMZrAJu5HRgCncWbHjuLGb5Q4U93IBYbLFKyQilmAte1HLLQ4GNBNY4RvYTCJQ2B7/1oEZFm4WrggVZMY0Zqa3pgQYYAHuCPMIK642dMMOfiOTavs4dsAGYoAfuZC3fXtYgRtpf/xXd7VXY1SKEWxB6QEbtEDkWgBc3Dd+yHhOsaB8XfJ8vXq7m3RsMfEmrGACr4Ca2uAUBOoZqswVNIEOOEECAiABJOAE/NiusZPabESv7xu/lZITcmG/yTVwAZyw/TzZ1nOTFbsQJTHDQOKDIcTpZEgkNheUB49gPOERfsEe6sEf6oGk74GtwkG0D4kVemylhQym33GGhbAVUOEUJjd9bGM3huY3aptEgRe+QsAEdry3MyA1kTq4kTo9hpzIE7JVBIKBEEz0bAEjaEAE/7RWRNAWbec0C7gAC9D4N7PO/bZVy9l3C7r8sNuTC1IBFnLH3ohBEv7gKAlAS94czl8hvoGLjupcdJpyEvy4Fa6ARPgcCyjQz/2c/RwwDeT0ChyRruDzQRB94Df61TJv8OLAETaBLuxSHuoBHizSH/DBw5mhewKKTnxQyHbBGGo5inxMCFfh1GfaZ3SDfXY3OBwlVk800mg9qAXIaTktmZd5PchGNM9mNBUMgqw5rKLLGx4hCH6AqUJyCZLgfbFbsSOxJbUFW9EZndE3JuVvy8E7AymaC2TDFQzqGnqBFCRhjq5CRqIj3Qst3Z9m7bTU3fF7joZBFZAtCKL83gcc0P/Zb+7pShKtLuDhAD4R/ZL4XnMjVnEZIfDrwO8cQRIw4RFsAR38Y26OFS8jLBqE4RfAsRaELLXrthZ6zMdMwxxhw0+kBzcWN+OM5pOK48Zzm/hSwL6EOr9gfoGgF7hLk4Fi1NTgI+dfZdSiSxjQ4AlwIAU6oIy/FZKlnE4jsf0Kq+mbnsQQS53TV+r91QmYwAG5oBMSYRWqYR3oYhMUaTpmRBRIYzLivMvMPij7mq+LgBY+AQnWk1+dvRAJO3Ctzj2nia7m/+7x/iPODEL4PrI394IDnxEAgg2bOHEEPTrojJ67evXy6fvnT18+etmuCbNVq9atW7h2AVOmTRkuWRn/ZZGsZRKWq1WrVp4KtUkSpEWQAsFRkwUKEiBAdtiI8aJFihBEPWTIgMFChXdMm6p7CvWdunNU01lNZ86qua1cu3r12i5sO3ZZ07Vzx44dvXCs0CSJIaIDlilTpEDBguXKlbxX0qThwmULGDBbBA8egxjx4MWMCzt+DDlylMmFsTxxwoSJ30hvTGmb98sWLFinRBURMkjUpFe5DvXI9Yp1rtmiap9BPSj3oEm8eUsY8QrUEyxO0qhZ85cLmuV+jR8XCCc6HDbTBVKXfid79DuBsgdaBB48pJnhFzE6zyjNHYIGC7LK5g4fP37+/v3r588evW/VeNnaiIsuuxhTjTTA/2h0C0qwZISSLLC00opKp5TySUyQSJKIHWtkcQUSP/RUA1BDFcXBURko9Q48KjKljlRPOXVOi+9oZVVTWH2Fo1dpZcVUWOzYY00caSwBFwZzUSEFXnktmRxggo1xWGJjtNGGYmBAyRhhjg0WWZeTRVHZZUw0kcYaiWRBijLzVHOLLLeocskZRaR2xiuioECAKLnURksuw9gpihC45cYbJ5PkFkATuXTihBpcXPGcGmmgMalxa0i3HSCAZLdpHYAE8qmmn4I6qqjlnWqeI6o6wggcd7AhiCBxOCIIHrzM004/+/Bjn3366LdNaBx1BIw0Ielyyy4JOphgRrQ4OJorqf9M+IkmkmCoYU5I6LBDiC4IFYIH4XpQ4olLuQgVVFStG+NU53D17ro5zltWigzJE4869cxjSxxwrIHXcFRsMbAUURg8cGCBPWnllYopVpiVWxYGpmNfXgwmxpVZcUUWTEjRRRhhWAGIN9KM4kotsHRxxm61DVHDCyscIsornIhCizR7BjooobptEABrkUhqhRMCNceGcWxciikciJyHCCKNNMLI1FWjNzXVUTOCiB+ILBJ12OdRPbbVjKh67bVsjLINPf70088/vN7zzz35zOPMLLFslCw0BgK4UUbNOhiLK66otEoqpcAkSSjWBvLGFEb0ZMMLQY0YrgYanGiBBfH/xCMVi+m2i+666T7F7rtlUeWVvObIc89C75zzjjvZPBLHH5Jy8USXW2ppWJYOQ9lww15ifDHFyGPBcV9UTBFGF4Gk4eAqC9ZSCSig1CYKKIfQQccllKRW2zC01IZbyz4fugEhw+TyiSSajHftqquOR/+1kFjCf//8Y9I/R0xtVWRDjwEPiMCzrSptknBDHHhBD33ALW7/2Ieu7CYOYczCFgIiRjWMoSxcAI5vJZFF4RCnOMZpYn6QkwIQauATy43IKBm4wAUqgMMKfK4pTnnKilbEw6bsMIjoisro1nWP2NXDKmn5hRYEsQg4pMEyXHqMloS3mC1ZqXhSAl4VK0aZ/y1UzHdY4IJf1hCGNbwBCEjYxCZC8Yla4IIWseFezQZxAz5MoRNmAMUrcPEn9KHmDIcSBSc4kZoZ5EIZuZjQhEJBCk9IUpJuXKElLYmJTK4wk5zk5P/4J8BGCLBqBUTg07AmSkcwcDmPuIY96jPBfVhwH//IRzkuwoteJEMbydBFgEToS44ErkGxcNBKKDS/x70hCy+MgYiIUiIMmGsCFKgmBT4nj2yqSEXxgEc8spnNz4lTnOEcIg9fREQe7gMf+HDHWMrxjVHMClQBgxJkvMilxhTGYVFajJQalkXfPcmfU6ISGwCxBjUWwhAvYAAGJNEKN96iT7mgxflYQ0daEP8LGtXQhjTslAvdkK82N7PoLnZBC1Wo4hQTIoVLSRGKSX6iWpfUBCcxadNO6hSUqkql2RJ4tQGqUn9WQEMcbDGPfNwHbrJk6j3ssQ5cQsMbwdCFgHxp1V+S0CQKWsVLNnEhSNghDVAAQgxU8IKheICG0lQKDqs5AVnKMokMqcc97JrEvOpVr+DsaxK3CY+/bvMe4IQbP9xhDnas4xhoeMSm7vCXLUBMoL9jzJQe9jCCJqaKjYlSQanUhjnoQQ972IMbECEdSCSiBgAAABBK0QpVwAIXs6mtn4YxDGNAAxvhCIc3vKEMOooiN3O62c28x4dQPEul0yoFKVCBCpYuLhT/oZjuTD8hyUt6YoWe0CknM9HJ/mXSEj3NmtmyJrULMbCocXiENV45QV1ZEG7+uBszbNGMagDjqlbt7y6yGjiSGBOZF0oEHLKAhByoIATggiYHOECUCEeYqevER13ryle97mOvsEvihvcK4iTCDm5JJAc62BIHQDiQOoGZrBjHeM/NOqxKwwOoZ/0J2s+GVrSjHW1p/eCHPvjhD4sIRCAqYQcEAKAGkVCFRnfxvlxAWRnKMJY35rGOeczDGyGhIyeE0LJJqOaQoKjWKmgBC1WwJLrPhW50T+HSUsiZunSepJ0nmYk85xkT4PXk/8ZLQFGaV4CISIR6r4WJIFihvUjN/wd+8EHhCT51Hcz4RTN6wd//WvWkAE7QsqQFkwv94Qo6cIEIShSuciFFmkfRnKvtMx9+rPMe+MiHrdk5V1qzk5334Aevdc0PD1c4ibvGh15J7A5yrCMaBamDG9yABkfxE3j3zFLxaHzZKXlWMaCl0hxEu+Nv97i0PwayHwzxh0CMZxGRuEQNLFCCU7ziWcrA7TCIoYxqeCPL8/iGlsOxjnAYw6KB0g1vutcKZfxXQYaTlikSh4pUSFy6cp4znWN6ZzxnwhPg3fN4/wzonoZygFMzdNr4jAMrpMEg1HilP3xtWF3F7Vf08AY1eKELTF/1pDz3pQg18qxWnAKscMACEv9cEIKkRCACSlm60yMwgQng0AImqk+vYq2PrOvDH/WhD9e57mt8vLzY8pHrrsJObLLLzR+JXccs0ACHQEA7DVaoUpXsGZkbD28xd9exjmnsbdCKlsc9Jq25z22IxCfiOzQZTyS6YAQTJOEVtxiGNOqtDGhoIxxY9sY2vkGPeYR+HsagLSIPNQhObO8UIPHF4EwSi1WggiWpoP20Js5S6da5zhrn+Mb13GfvApC85VWVJSJxaEk8IhM4CAIWAPGIWcxDH/fox3y4vlSI5EM/3sC5L3rRC56L/6S4ECEuVFYKSECBBh3oAAeU/gAGMKACEYAABJ4u9QpEvQJU37p94Gb/H1znENgXdrEmHwaoa7gmV8aWdsU2HwE4EbcTBIFgBw40HX2HJVe0T1fEWYeBRdPWRTO2Y59FeOT2Y4nXB+kWHhdiB4qAbpYgC1XGUdiADb+FDTO4Db21DgHnC7GhPrlxSHGkDdpgDLowCyYUe6yACqYAXbV3e6cwLblHXdNFXdeVcXrGZ8AXfOHlCMRnP8fHQI6wfI8gE5rgCaPADPAFEV93HxCoH9YQDMZgDMRAh3KYW8MADMBwUrXQCpqgBjrQAu6HAYPYOTlEf1GHiPnHf53TORjgELzSK2uYdS/HK7E2H7t2iWRndnoVdmoHEfYwD7ygBVjQHQQBB2+wBqFF/yUZWEWIsU+VdSWahRgY2G3hJm6ER1rlZm6KZwjfkT+dQAmaEAqtIAu6UGXYoA2etw3aUA27NYTb8HnhoA22IAumcQbXeAbdkwrS4A032At6UzgrsYSJY3sSF4UsNYUWR2fYZWcdJ0l7toXe5T+rAoYMpGeOMD9nyArdYA8SYQ//CJC2ph/0UHPJkIe5ZQx3iFu7gAutAAlXQAMp0AGEuHQW8HT4l4hSx4iNKE3oQA/50A69Yn1rGGtyY2snmQ8NYWsMYWuy9mGciHZ3RTcRYQ/hMApB8AN3MB06iYqpSGPUxjDUZm045m3fVpSFV1o+Vm57gHiIl3hR0wiKkAgmJ/8/n1AKnhAKq1ALVoVv01AN00AN1XANNIiMyLgNv0UNR3gJTZAbZ3AIoOAKtpCM2DANwGALsYCXscAKsrcSLOGX5iiF1VVxF8eO75iF7+hx8ehn/sM/yScJfCYJgiA/Z5gJvBAN0fAMyxAMweAL/mELtjALrCCao8AKlYeHuJWHt3AKf/ADgfh+StE59Xd/sul0h5iRi2gBg8hqvLAO7OAOvAKAEHGJl4iSJ6mSKdkQCviSvdaJMimA9BANaBAENIApb9CTEmMYG1hFQXklfbdjo/Vt4paLTHl4u5h45/mU5tUIlIA/VVkKXuUKe+MRumUMydAMHFUNyJifyPhbNvf/maWgCaAAW4DUUdpwg8lADEYIjobTEhLnl3+Ze4ujjlVYmO/YexyXhR63U4zpmPWjKpI0CqZwEEYVBwPBHrGCooKgKqRQC+S3CpCABYAYFxYwAYyYQxHwAA9wkRGAQ9SUiLiZm4N4FFrADOuADvXAD8Hpa/kQa3d1nMWJnPWgnGRHpWJXX/MwCzigpdlhB3bwBnKQUHdnWcFjbTmmiuLpY0gJZIawpujpplKjnv7DQG90ChGilbegC8BgDFQmh9DglWJJlmbpDeGADb+Ac8UyhL/FjNDQDM1QDMTgeiZxOA3noJUKmM41hVW4jne2cVfIZ76nmOFlCQwkCZlQP5Kw/wmZMAqjcIaPoAXLQSmUQhAligYCISRpsAiSwAbshwHkonQQ4AAO8HTA6gCzCXWJWE2GuJG6aSI44F7r4A50Ezdhd2sWxpJQWpzK2Zx5xRDsxHX2sA2PgAMt0AIE8QZeCqZsIKZZZG2JYYu4qIsm6JRuaghhE6eMKV7yswlWKVu0sJW9oKdUpgzJYJ/S4JXYUBE0qA1nGQ7f8Fu91Vu/9ZXP8AzIQIfEsF8oMamTWo4RZ47OJWcvAUcXR12ImWft2HFaKHyddHJ5Zi2qlGejkGek8AhWEAQ3i7NWUFRFhQY2C4gTGX8PgAD2F38MsAAIgADHOgG0uXQZSU05xIgnIv+kJpIBQYADo8AN6KBUcsNOF4acXXth3aqJslRsdHVh90CTThQEgSgQXWoGYaAG6ipj+yQlqxhahTduTIme5lmviFCv6nmv+Mo/K+RG+1oKqQAL/noLAJsMmScNy7AM+EmD12ANYwmN3dAN4LCDAaeo13CZzvAMzYCgqVkLsYc4D7ISDuqx0xJnFjdTJGuymIBn3oWFKzuqLZsJm6AJjpAJy5dnn1AJd4AGOEADxVu8QaADOUC8LSACSSG0SDsA0Yu00Bu9A7AADBCs2BusTUtN1kQBUNs5UsusRzGuOGAL6xBB/rBrTtoQLGmtdbUQ3ZoPeUW2DGi2F/Yr63CT4yr/Am2rIWkEB7O4ivb0WW4wB6HlBnrQB3vQB0o5r/QKp4BrXoLbPyvUCZ5QuJ9QXcSoEb6Ab9DgN83wDH86ltdgwtmAwt/ADeAAsQ1LudRADc5ADc2ADMGQhwdSCyvBoBCSumsGhXAWU4RJuK/Lqd+VSRqahX7mZ0P1mJhQuN11EMsnP1dgBTQgAnERF8x7agwQvQEQfwhQvWHcxQEQAAOgvfKnvcbavdY0deHLkczaAjpgBe5FD/2YfRGhdV+nx1rHx7AUnPehx19Hc9aAO3HQBlgQHdaZUHIgB2IKGFTCBVSSBm3ABm6grpVcyXWgyUHWB0IGZIigt+nZCH0bwY1g/wlZQ8GWwF26qwn7GgqnsAqx0KLBkHl/up9kmQ3c0A3e8A0tvIO99Q3bcA0wTA0USwyY5gvDcH6HAwu1ZzhwxlKoMF2t4AmLg5WpIEmM80YYh6E6hcTCF0D0yECW1KlnuKpwNC2bsAiSogYdAwQuYALk8mA0an+y+bzTO70NYH8NoM/196NtzIjMqpvje7xowDb2kA9vA4B4zMcNja18jJIAGZD6wS/thQdbsATWqchrwMgD/MigZR0CUQdsoMklnR2c3MmHd55h47el3D+oLLgWTFP7qsGHuwpu4gvGIA35actjSYPZcJa8/A1D3cK+5bnTwKjG4AufmaewvAqhwP8ImCAJpICpkZQKVL0JpyCM2zVJMbVCMxW7titeH8dTXfg/46wJebYJnuBSbO1SD3cKkpAGTvDOIVAisZmjEBB/C8DXfO0ARtvX18vP9jebEOCj4LuRAT3QA50CN2sFWjAL49CP8cUPWYetAinR/0iQmz16WoZlEWtzzyBPceAGS5DRG60GahAGtcjalGwddZAddwDbmgJknhw2b2qvE8w/U0PBltQJ1ULTNQ2FKaMLwTCDXjkNyV0NlYuwKIzC0Bix20CDM9wMylAMvXALszALKvO6MUETnwAIYCUJALqvkKC7ksRJ2SU/1rKFXmjWXihe7v2FliDV10LOnZqquev/RnK2CXdQah6gf/ZctEgb2Ej719obrA6AiE3rz4q4iIiY2BHeOUggCGyAA1qgBUhFD2nB4eUAsSpcEdZgDdHgDMwgDIbKC54ZmqxgCqsaxQSxHK+KBgaRwFMABKid2moQnrUYyQYl0rEt23dA2+bG0rgNlRJsyqlsSduVwdUFZ6mwN75QZc2I1NBAzCY8uWOZDWX5lYyaDMXwqPulC7JgCo4QB43DBp9QZJBwB61MHPIDCZoABzQxXrKbU9YiE4BGXlQjVCNHjyMHuGgzznq21pJUIfsaCD+QAhhA2ITtADmao4Ad2AtArMQqrMaqtPvHozmUiBuprIyo5mvbAq+6/+IujjtogOE3q6XlO67kqsWuDuuxDutBACt3EAZSMAVKYJ1x2xyT3NpU8mwmDdslXQeeTORhM68sjeRJ3tuXxMrCzdZamacymNzVLpa2/JXF/OWbuZk37AsMGQuZUKKLoMGaUGRxxwVSdAfmfSF+eBxP0wjjFe/zcyGZFEqsckpAhR5bk0CplDZ9ViH6au5pgANx4X4QZgI1UAM8YAQN3/A74BMx0AIeYAH2F6yzWaObTn8X6bT//OkbeQVBkAIpIAKOYOFXfMXt1wEoz/Iq7/Ivr/IPtvIisFbt5wEdEASvogZdIAVGoASp3et/4a7PRvSa3AfCHttG7zUsXZ4rnf/bgJvKqlxTQ1xxkmQKsqwL+Oa41Y7cyQ0NyRAMmAaaG/QfVqWHt+AKm0DSkOA4mqCTeJEDNJADP4AFaVB0GCIpayBkUtMHptwIM/EdP3Uen8zSUXPshC82BrRA4GXfuvuQ7CcCcQwFWZAFVTAmVYD5XWCddhAJkVAJl3AJkWAIdAAENpB0hP10G1/Pmd7xPxrhTpADHeABdVAJ5BIBMc8B7bfYuunyu7/7QYoBT+cEUOAEDa8ESVD3QS/0s0j0btAGbkDsJd3J07/3TG/4TnnkSB71Uu/sGjyFmmCVN50swEAMyQDCBjsN0vDlnakLoCmabiaasowLsUAKmTA1f5D/BjFB+VcABZXTBTsAECl0IKFx5c4aLlzWwIFTB5EbRoz8BAr0B46fiIgQMULkx+NHkB41itSoMSIjRykxOZKESZMkTZ00vdHhggaQN1mg6DDhwQIECxUmRHAAYcKEDBk0hHixYwqdRIoUGQoDJEUGDBUgbI3Q1WuEo0e/fg07wUJYHCJafPqUwgEHBhhEzKXbosXcDnQ77O2Awa9fCw8eRMAg2KvgwRGAINmxQ8kOJ1DSqKGsJk2aLnLajGnjxrObznXq9CFdOqSfPn5Gqu5oyHXJRrFlz7ZkKXZt3Lk17d60KVSoT6FOwQyVylWtW7hu6erVy5evXrpszWLFCpUp/+zZTaHibioWKUeMsDxB4gTOFSRYkLxosSNGCB0tXuRwogPL+Cdp1tThiKiOm0USqQijkzhK7bSPSmKtwJNUWgmm3TpJBD0orgCiBhEKYwCBAgYY4IADEBBxxAVKXACBBYr6IIUdqDCEEkoKMSIGnyoYq6uytoJgrLLKWuMOWVSh0QIL/KIhCB2cCEJJHZrE4ckcaJBSSrvsouvKK6vUIYsppujisoQmq6yLLsKQYwzONmvjv8/cEK0O1A70qI+SEFlkEUAQ2cM1Pg1BxE9EZpMtN0It2W2330Ip5RRGVTlFFVVagWXSSWOxNBZXWMnUOk1dcWUVUFfxFFRXMPUEi/87rPhBBzgCwSKHHZLYoakYZNWBhoFocOKJHNbAgqI+ROsjwD8CYaQRiVjrqCOSFjzJpI2QPdYRUkjxZBNPPtlEk0oKeUOJGkywAKwItmrAAQYWYCDdE0d018QTUyQshB3CiOSSSKZ4j4MMiJzAgaIgAPhcBhzoyuCwiCSyFlxOeWPWfSOgYScdrFAyCIx1yLhJHXJ4EgcaQJ5y5BakBBkHJLicIovLWhYzDJhhRrMNmt3oo003hQ2WtJA0AuRnQPzo089GiBZ00EJrOxTRUpp2elFIQ5V6letMqRYVqUedmtRVQmHjjjSCyCENJKDAYtYXQrAhhRRscIKGB6Rc74f/RVoNhCSKAoEEJUtSQpbAk2RjsMCNAqf22k3Y0iSSP5hwwacIHthxK4DZhbddd1G8XF0GHkCKxTcu6aQSJVTgIAIGjELXgQZ2HEpHr45SOBVJAllDiiRoTEEEGu4o7z4nnLDCYiuwGD545JFAAgjmy0O++SZzMBvMMBPiArMyw6gijC7SrJnNnEfrY4899NBDTtKABlpoPjVqxP2j40/6pW0j7OR+thRlNBX+QU2F0VIoKhWhasWntrYKTK1CEmxIwxNWlQM42GFWswqBBzwwgRzkIAUvwNVAbJc3YyEib5LATUocIa3YRKQRJxycClW4wvBkwlq7+UQhgKCCEARl/wICCxjB0iUiEylAiCHSHLyA6IAHAGwwFciACYDwh0t8wgguyAAE1rUur+gIdjg6SgUgYYc/KIIOQNgBEELAAUlgoWL3ucIVsJAGLFwhC1dIQxvpWEc7zhEKe+SjhYwABCUsgXrX40IbJhOzmHWPZosMzZve5Ify6UF8pVHfz4ZWp0DFT5ONINRuJAETSUSiEp3I36JO8b9Thop/q1xFK1x5QFBhChanekIQflAfKOSggiHIQAp4mQEOeGBK9LEDFySxBki8pDafTCYmnNk3E5pQUCeEYWwcYZsVctI2mejNJiCRhcd5IANCGcoDUufDEmVOiEIEIrx+qC4t7sgrHP+IgRIKUQh9ZWCHCNuhPLcIlqNQQhGJyIMYxPCDF3SADZvQWBDQUEcorIwJUJjoFfrIRyVIwY4VcqN6diCFJXCvZWGiTPa4lz00cSalNJtDS106h/K11Hyi8UglAWEIj7ymTrHJ5CYFhRsIHQpCpFRU01B5ylX2D5ZKBZUsXAGLU8DBCTl4gRNSgCsbpA0DDlgABELQFxqsCglXsEwgdMAFTUAiNszUhDMz8daVOMKZzywUJmpzzb71bYV29WQgzCgUDVxAKJFbV+WuaEQErFMB7dxciQpmWMNCIAMhMMK93hCDceLIRjz851EuQQlD7EEOUvhBC+6wCowpyQpqWEP/FtaQE9dmQbazlW0b7wMFJygPCZcZ6xSkMAUqfMlllwmuSeVwppktcg4sfWkbXqqHPfDMDzbFaU4BhUmfHg03ngyqJtjSG+Gccn+qOKCnDGjArNUCFrJohSac0IIO0CC+OcBAudQVgBCkoC9sEwESfpACOFgkELvxhCZ64923JniuC2Zwg+1qCbvK1ZmfXAMN+FUBB0yAAhQoZ2HRdVh1pVOxjN1cwSQHgXatq10Z9kBlO/GGGoRgAqn7V8G0GDuZUKILVMACF0qRCjRgLAiX6fH12MAGOADiDnG4gyDuBAmVcFOAolovw0IBh9aSKQ0sY1kaukSmQjKSZjPTg0vN/2dm80F3TjWtpGvYB6jr9jS7t1nmJ1/yhz/AhC3BYdQpnJbKUFVH0J0KlXmPI4tJfSIHGWpBDpAgggE4wAJYGYAHWmABDsS3BWrMgRokkcxkhiJbn/CuJzyh4ASnWtUKxkQmGPxWSywCCingwE8a0IAKUAACDbhiwXrNrsMqtrHDXsABDHAAE62LchAwARNERwXMvg5g5toiIBaRhjssAhW7qEVvSIGKU5hXFrKoBXJwoYtd7MIXwAAGMYxhDGXEWxnQkEa9pVENe6dCDQwh05e+1CUvkQkMYQYNmsAAhjEs96XLbUOayRdd8d2hkhrx03V12lM5axKoMEnECwIAgP8D1OANnUjUov68SlOMYjumeOsoNEUqrY17UqGggV0iYHMEVNEok36AXzyAhCjp4A1/gMQfEhHq35TC1Etf+luZfupMNH3VC27rIpDQggtzVQGUOywCPqziE/Va2AogdhEZMAADIABEIUpRUco1ARVkYXRTSME+p31r2D0iE6aoBTDi/W54y1vwgyd84ePdDGhUQ/HDsMMVnIADKlBBDGXqghgi/wXMb2ELCG8DGLbwBTIclwyhl0Po80A+h5MPJJVkxM/s9PrCvZA22CSUNmujqE7EAAC7330AGqCESzyqFQN0BSpU0YlINKLlcdACHuLwCO/EYha1kMUtqk99Wsj/Qqo6wMAORRQCwmBARIRhtFpygCouuBoT2GL6b65l6m6a+q3Y2kQm2jrXBFvNWr0JBBJQYAIQCKwL4LCj2LVzORfDArtkuyIHEDYGBBgIjEAJ/DoGhLuRiwQzAqbBGIpbKxF3CzzDE7xkGEESLMEQVIZmeIZnUDxpgAVfcYIfAIMvMCgxwDzMo0EcrEHMCz0yEAPSO67TiyToUj3UmC71wRObypPA2aSkqY1KUBQz+Dje270LOILKipRUWLpSoIQ/qANBGIUg0wIxdL4nAARTQLTqsz7qk4VQwIKawwALSgGgwIB1QYDC0K+S0QE2sII0gAT4ezpTEzVAXLpuOjAD/6u/BKsWUiiFT7A6EwDADbiAASTAHbo1S4zAX/u1ylmnTOxETwSxgmGiGoiETwgEC7OigmmAEmmAeIMGwXPFwitBWSzBZqjFZhC8WlzBahiGQAAu/xoDHLzBHDSoHqxBHxy90TsuIES91DONJEzCkpA97bIN3LgNTVAUC5BC3rsAGOABIigEfIGJTcAERkgIQBCEOMCBFsABMdQCHECAB2iBH4CEVYAFWrhHRHMFR3ibS8sLBLCAFHgAERGMDpBHu2ADScgESdiEVIi636gWT1hEUkiUpXO/QXy6vauWUFiE9+KAENiAwNqwDStAS7w1CWTAB0zAT+zEYfshFCmYCP8IAbm7hCzIANR5LHQ5wcGbRZ5MBlu8RcFTwWmohlpQgzBIgl8cPR2cwRwsxmI8RtH7wTyYyjQzn+jamWc8wkWok2PhKSYklFCggwHQRgAgABhwAReoASZQBAOzM0sAhDhgAzTAgbxoATHEgXYZgMHIACQIBUrxlFPAgjVwArXAAEzzADsUAUu7qrTQAUFICUnwhEWIOlI4haoBt1PQyETRzEQRNYpcOlM4hVCAhPcSgRD4SAEUSQ4zwEucQJxknQn8Os7xRBMhEcYSkTpEgAqogT94MRVAHQicAHcjQXnrSeOkxVokPGigN2M4pilYgh/4gWNcShpkyh4Evaf0QTn/0E5lPK6qNB/SGI2fuQPyhMb+MImuzLifyo1OWIEAeE/eGwEQuAEe4AE6MIRLgIRWgYS4ZAMvuIu9aMcHCIABsAEbQDFlS4Ec0IRWEJVFAJkWwAC72IsI0C8ReAEOwgJGiIOUyITD2YTKRIVUqBoAKoVFNFE/qxanUUSIjEgV1YQ0eAHF5AAQ2IBInEQNI0lLjCcIQAzBgMAOXABLVCwiFSJ2yRwkFRFjQzZkCwEl6IRC2AE6NIoJsEVZbIbjHMHi1NJkQMHBW87llIZaSAMumAJZ2YHpNMbpRMbspEGlZNNkPLM5AM+dIc87qAOJsylMMgmekrP5iZAMCAABEFQA/5AAGaDP+lSESqiEt9GBH+gAHPCCDCkMERDDDnjPCVgCCrCBHdAAB/AQO8QCT+ga7mO0motQGRUBj0ECOHAEDr0DRwDRLAxR/jGFozKlPvMzXGVRFl2UTYADDaogCrDR1FRNHQ2YeDqxH2UdVRTSWyvSIQIRzElSdzkAASgAbL1WBlCMRLgEJbigcvlJxIOGn8xSnrTFw2vF5VSGTCCuJDBQOHVTNi29Nn1KOA2955KkOn0TiWsWkVCWwnkf9aSz7aIECCgAAyiAQT0BGZgBFiACe+oEQwieDohHLahYgrzL9wwAMygABUA2DaiBGIgAUH0AD8ACO8itRqMB3sEAN/8aCCdghCVzBKfDjlTYDu5IKsvETBHlH8zMVezg1QAKhB+ggQoaQGKVxFwTybDgihvbihPjIUwEO8VaO2M7NhAxAK3FVmND2K01gPe8VgPwkAKoABPogkhQgxQoEjAF03I113PFUiz1yXmDBl1gA4XAAlmxAWSMymO8V6gUPWJ809ArMzMbDdG4UzbA06Cpk39VFhWCn2ksWA2wRAFoABaYgSLogSHgg0owBIaAgh+wgiAQAYEUEXZ8x/dEgQUIABIggQO4NQaIgRrggAFAgNu1NCRIkltJAUsTATUoTzaIg1O7DlIwBVXqWVYaURFdhQHyn5/tjqc5BdKUEtPZsBr/BUmlFYqRzJGx4FEtkk0izdqE9dryxVZsHQD0Rd+wFduEBRgOMIJEsAMawIBjKIZiEAb93d9iIAZiCAYADgZ2C2ACJuBiQAZkeAZynVtoMAZSQAMsgIPKCANiVEZ7jddkVMov6E7TywM5ndNHAhtsU7I121P07EraWE+leYMQYJ0EEIANmIEZGAIWYAEmsAhPWwRBQIMWeABQrdSL3b0GMIKci4FJ64QuuAALqIFK2JDbhUcI8ICs+q3IwIJFgIRFMLXtABWsKT5P4A6sQQVSWCUwLmMuFlExzpRVyEw/S6MLcQEVAEAQCEANCKylZdoCvJEb4SEPQ5cGqFqrvdr1/x1kQiYAAvjaY/sQBIgAG1AESUCCWkwGZMBf/EVg/PVfAPZf/73kYgiG/f3kFGyGZUCGZDCGXRAELNi362EtYATcewVcg6LXvvVgw20pz0Dcy8BTOEkQE16EJcwuJ0wEIwgBSWwAFPABzkWBGjCCK6idT4uDIMCAsQSABxDDFnjPAeABBmgbDwgBJjhNGICAQ9AAtXOXoqgAD4iBF2jmKzYwrDE1Uii04nNeNDYFA2JeM/YfLlZjzNSENdhdOEaBOa7ROq5jwbpjShwKPc4iCHysdQFkqz3fDvEQiibb9B0AQzZkbD22AhgRCIiBP9CEco1kSsbfZChpSr5f/D0Glv9u6WN4hmhwBmYQBmQghlWIIyx7KDZYAzBIUx/06QwmXGQc3ONauDm4ZTc4ssUVFiIEWKC5E444GsnVpkqAgy+aog3ggTMYgvq0QifQG0nYYdOlaLu81PfkARRAgCiWAjpQghVQgQuoT4rG3bVTl6KwgBZAgisuBVc4hVWIOk8QDk+5WTSmZ1CpDqox40GrjgTin1D4AzKqATiWYxAgAZA06O1VTQIMChv5XspZnQ+LVvJN2IwWANM+bdRO7YwmAPS11o5WlwiIATtQwWewxWVYhlq87RFEhlFGYN6+7dtmBuEWbmdwhmg4bmcYZWCAI9a6jDuQ4FZ2SlmW7qhMxur/Jj0yYC4QFo2k/hryrAOrvEplqaRFuDiNgzBISCY/64IpqAJCoAM+KIRK0M8mI93CEMgOYD4M2FgB0AATgAAEYAANMIILIGY6OIC5/lQRadYkEgwRcIJPCLf684RSyBpU6JTz8hRBC7TF1hRL+ZThuIIc4IEagAEVQIESAIEQeN3LlkQXn8QNq4AiqQAap/EI2KzPdmgGEO2uxVYCSG0gF4DSFvKMRt+t7Wh0MVvapu3jPu4lh+kmpwZqsAYqzwYrt3Ju4IZuWAcuX4dv8AZfwIIuMIMpSGUsS4MxGGrtfGUL7ls5mMrSi0pGaqk3aYPF/W7wHkIi9JmnXoQ3w7ip/8aEZKpwhqEFSVCE47vGT/KER7ACHLjvah4FLcBdskSAFWCBCRCAC1iAKbCAJ4ZHGRsADLCBCOiqrVqAIpHQNPCuH2ulBhUVDZdn84I5QzM0S4GFVfiENdiBGiBxE/8/E1hxy8bsCxBAGCeSv+iRctGR1bmiITq2rR3yID/t1WZtQk7YhPU6gKGAK8+GbdgGLf+GbwgHcid3Lp8HdEd3elh3erAHd3/3d6eHefCGUfiB9vaSNaAMmLnX6f7BH+zOPYBzehUD76kZz7BzPL3TOni4pmazp34zo2kfOssWBLoFvxsGv8OFVkqFT1gFVngE+KpYHHiEUcABD4FP3gsABf8gARQwABioAQKNABH5gA/oHBsIgQXAigmwQ3hMEcnaAUMQoKeCBfNiBVqv9Vr/cE+59VUgzRhIyxKH4zg2gRJgccw29hdPdcPskfBt6B3/WKwl7Wofe9MeeyM38msFEQWwxHlgd7df97ZP97dnd3to93zIB33Qh7vP+3pgh3U4Bi14AinYHjkIAypYg31/ZTe37u4sPYF/yjk/6s84Mkdi+D2YE9LI0/W5pD95DWsMt+rbBWWot+UcBvWCBVWohVh4hBSgeQyIg1GQ9A6g6I3VxgC4ABYg0H+Exw7A3QfIABQZlwlYAKIQEQc4gFLHazhIBTRc+ktR+ktB+ud3BVn/wJRPUAMdqAEVqIESP0sViGMUt/qCxnpJ/ItkN4vX+WzDevbRNoCxf/+M3tolzdoDWF8DWPsGmHt5l/e2d/t073+AoFevXj59Bg/my2dvXjhWOJ6EMTMlTJcpZqiEEUNmI0cyYjTKyeNRDkk5G0mSQfnxY5s2c+boidmnTZ2abur06bMnpp49e/rU7HMHEFGifgIZQop0kSFEhhg1sqTJ0ypYtXQRkzatGjRjwHbVatUqlSlBOVJ06PBoFCtWo9C0QBBgroAAAOzOnQthAAIMDwJEwIBggIMFERY4QNDAwIEDCxYUcDAhQwssmlzJghVr82ZXnDm78hwrtOhYmVNB/0KSo4aJGq5dqIitAgWKEiRIaMitYYOGC74vZMAgfLiFCcUnRIAAwQHzBgwYKFDQuLGB6tYJYM9+Hbv16d6jFyhwIDp5e+bP00uvnh76efPU29PHj1++dujKgRNnj557bHGsYBEGRV0I2AWBGnmEIIIdpVQSSXnkUdJJJpnUIElziDFGGz3FtIcfPv2Ukx9ADVUUIIEE8geKi6AYyCKLQALJVKWkAsstvhgjjY7KELOLLrK0ogopmaCBAw4daOEWK7O0ZYoWHfwVwAB5AVDlXQEs8MAAA4gQAQJZRhAYAxc0oFyZF0xAwQQOhImBE5pYVUsttsxiy2ayjCaLnqS5wv8KZ3qGAgcWStQAg2swuJCoCiaYcBsJHuimG3DAYRDccGFiGiYED3DqgHPPkeeddQaEV6qppjLm3XTksdrAAg2wR8867q0Tzjzr1BrON99wk40111yDTTbj5ONPPwpxw4wzzFhjTTTQxIIGgAUaSGBGDKaE7YQOhtTthNluK4cYIUEIoYcg5tSHHyOaSFSL764IoySahJJKVbfsYgw00kBDzFe61OJKKJ5kIsgPRrJCJ52zzDLKI1q0gMECU1JpV5VbBvCACAsgwOkDEFhQAQQNKNAACCzU0IDKGTDwAAYRcEDDIlbZUjPDs+ip52iehcZZwJrAkQUSrvFQKKKKMnr/mweQRpqB08FlwMFwxFmg6aZmfgqdAglwzfWoX3+tKqtjR6ey2dR44000yyzzTDHIIFNMMMEUU8wvvPDyyy/CHJNNPvz0Uw892yh7DFf9PsLGE0hU2/i1FnbLLYWSPxihhBVuu4Uce1hubofpjiiiiXe0eAfpLLooryc0ulLLLsAYY4wywPiyi4+ylBIKJo5w4YUWs+D9S822PKyFFkEc+YBcc2GcV8YR8MVpxxEkNsGrNbCApgIXxKDcBBPAgEEIV0hySp2xzPIZnqX9WUspi6hxBRBE13ADDPfDRlujj0K6dNNOS21qGLAAATGlHOUwxwHPWQDZoqOqB46HPI+Z/+BzFFhBBygnAshohjeaIbe5xY4YIjQGMYLBi16McBnZsIex/GGPbDgjGs+Yho5uASAs/KBx1nqchUQCOcqhhHLgmlAeokCGCB0RQjzRA1DSla6iDAVFpoPXiiAhiUxgol6tw4UubOcjXeACd57ABCPcEIdH5I1JtuCFLRyGhuMhrwVQ2tIBBMAXBHQMA3PBo8cegEEHDKACKyCB2WKwgpA5oAZGSJRwOhAEU6ACfbVInyzS95k7uUISa1ADFIBQNB7w4AY3KFSiVrACFOxvaf77nwCpVrXkQMBqI2sOycb2mAaOTWXPuaDKEojBCHzvbdPQRgmVwSMRjtBfu/AFMP+AoYxkZIMe88GHPbaxDLkp0xNYuMIUmGAgNahhDWtowxhWsq1wRY5bHsmWOjlSkigsyCdyWGJNcIITda0LinAgHbxOFAhAvGgRktjE6lZhmlsg9Ba1AJLuHIEHNjziGMsYRQtwMAomuVELRsJBC1ogghbsZUt4FI6VpKS8kw4AAjbwQAYosAASxMAEGZiABo4AgxugAGQcaAEb0DAKV9wsqDdDXyxKkYhNdvKToHRNDWjgAkOecn9KY1puosaBAE6NgAVMTgUMuBxfWvAxCdwlWGnZALAe8IBh+t4EmqmLakjDR7iQ00Jh4YpVlEIS8/JEKljhDHro4x/3oEc0HKb/BTZgAQtPmEISgGCELmwynOMcQ4IYBEQgLuhy7izJFxC0uQjp4SV6qGcdbuJEffIzEKaL4j9PlAY4EGURjsBEJkhBilXcFRawKEUmMhEHNKDxGaPgaEXR0NtHEOl4HA0CI2KAAQgsgAFfwtjF+LKAvSDABCnIQAoiQIEdmCAGIYAAD4iwgRG4igEZeAIXgoCGOJjiZpOcJMP2JAk7qCELSnCsIo0ASh0cCqpRdRT/qOqBtHQAq64EJgG7akBYIlBlX02ghNN6QAxmEJjI0TBbKwAHJ4B4F7LIgQ5W49QVzEYFFwgBCmKABTz8Yh75uIc+6JENbFRjuD/AQheWkIQd/9RgDW+IrBpagrnLUc5y7WznZrHloNDCpLQ3ccNNSAsHONghyyr6A5btoKIUqSgN4lzDPl00lVCE4hSrWAUqRvGWM/JCGBTFQRQ6WlFBSEIQv9UoHrQgAgxw4AMWUN5gBlCAAUyALxhzgAo4IIIQZJcFIXCBb4hQgxFQoABf+sDBfKoF487iFrOQ06hzVopAvCEL+nUsD4zgah4AAcA1sEEMoIqC20iVaR9Y2gc+wAFLCVCrwtFqyCLgYEyxdcOZQnaymd3hCkygAtImIAhQAIIMuCAXoAgBo0JQghGA+wQggAEPmHDFY6yjWPpgRzjCsQ1osIILT5DCD4Cgmje8Af8Oa0hDGjakZCBCqHIVepDAUaItjXykI3mA8mipXOWc1LMPXf4Dxe0Ahz9Y/MpX/kMa1MBvNcDBRZbwhCY0QSPcksIUcVh53kzxAxsYAglPsAIOaLCGRECip1oYxZNEkJYX9OEFGFA0ArRmsQAIwAEcWEAGhlDtC0CACDyAwQWmhAAIdBQHmWBFELQQh0zEQqHzNQ0sNvGHVGchqeVWgquB4PZZ19qUqCRBrnPT615f1WnC0fuwhRNArVagwdIevLSTbfjDP3vaxLaAcEzAAxe0+grDUIURlKAEItyAB0MYAiib8IdQ+JU9BLFHOdbRDW9ogxRxQERkszDmNQioJBH/+ohJQCK5BqHzsrXPbEg4lweY8OQn9gxKuq6c5eNb/MspkiLFA5GIRCgiEomgBL3shRlXmKLPv+PFIzDgeCNAIRA0EMFNd/CDJ6zlSRhICxraPIogdKDQzrPSlRzwbfRSAJQ8sIBjHpACNAAXz3WdIKzFLOgCQo1aLazCHayBqmXBFUCB5TEB2/kXD6yGDdCaKUXVKU2VBuzar0UNsLXSCGbV92BK4BXbshWeCa4VW4XJ4jEeBhCBEoRBIaRaJQwDLUDBGzABEVTBEVTBBDYBJHyCKTDDPMRHQrADPbDDPHhDWQhCH6gBF0DB68UehaxTSKAThEDOv+meO7lTuSxc/0zARIhAnIjkBMVhnJY1HxV92fNBnyJMHyasTipcXyy8RZJwXwvEQBMQARDAARIoQRMMwQ7EAA7gQSZ4AQ6IwEdtnZsZFg5QDNLVhfMEQAJIwAUcwArMAAyggEhhQAsYzyPEgZF43SiYQiwcoC3UlSZ0XAOqGhTI4gS6mn8BGAbG3QbemtLY3QdY1a9VigiSYFYREFsR27ERnuHBoHEQ23AQAR3QgRmEwRJ0QScMwytQQR7QARXQQRjswBW8wSacgik4g4zpg0KMAzuwwzo0gyAIAiC4QRpwARewARu8nhyYAe4lEbeIIbn0Iz8GnOT4UEqIYUxI2T050bqkoRqqof8hUJwhOOQfJMWWFQIcSl8kzIsWycKS3AIeJswj/MAOFIIZrIEkvAEfgEIVuNoOvIANhKSRoMGSuNkjPEJbPIlcDACpcA2VAIAAJAAIXAAKhEAADAYG4EAQxAErGI/xoAEkhZ3YycIqwMEVhJMDQqAsRqARuN0OcCWt2ZoJcGAH+tpV+RoAcUCCXVVaDuNaCsf3wOBbwuVwmAEhFIIUKIIhKIIfaII0yAIZKAIlUIIipIGMfAIqsAI10ENC6IM7iAM6sMM3sAJwCUI88tvr4VsemEG5CJyS9aMYBqTsaaZmkouDFORoEZ8ToeZCSiREVtxDsmaKFEJsQl8iYKQmkIL/HeKJLThTMgjDL3AdFihCvmkCIdBBIjABExiB1IFSDLzAD2RCzbSFm9GJWzwCDmBAYagMdxCA80yACTCAlCCACBhJTWqU8cQBKaBCqEFlKWxTVaraVWalVgIBV+4ALsodCgwY/3jg3Y1loH0AgqVlgCoYWw4bXBqosE0NJ4DCK5wCKNACLYgFLlQDMMjCg4IFLtgOMCDDNsQHP6wbOHxDODjDI7gjILBBGxAIvuUbvkEjiPSj73lmHnBO5XghaMYojGpmh+joEi3RHgQFQ3oZxrmmIXgZRBpCRUaCvGwC68iCLWDFvkzDNDSDLsSCJ8AjJtCBIlTCFGQBEzTBEYAp/wtwZRBkAvAoDBs1TFuwAh6kAAbUUgMQQALUxQAw0AFMyQJ8lEVVJ1M+QsrVAi4gVC3AgiT8QBIICEVkwRTAZ1ZuZVfmIn7OnX7y56T+Z1oIqIAC2oAOI4IS6AgOw6cOgzKEqqjKjjZIgzFBQ1coQ45UQzjYA+DgAzpwQ7BEpomWFkXUQZblW5b1AR34hIz+KrDe6Iz64z8+SLCSS7BqZhnqKPC9hGjtwRrc0xoGKa+qoZZBJJIKlCZ8AuugTy/oi1ZUAzagHjGYAhtkQiP0wSdAwRJUAR8cQRE0wQwQgY/hwM7ZQi8cgzCwkZqy0Vt0AGJERwIYgAKQQAVIyV04wP/6JUkcMKUgjMJt3QKgKpQrwEGhihOicukVcKwstt181qdXamBYPooGeMCk8lqlAiiCsSzLXqrUXNUIPs3TDMfM2qzTnKoxDUO4KkOqSgPq7cuq9qw0tKo97EM/3AM7bMM0FIMgsEEUwV4YQOPxaVwd/CqIYO2w4qiwfqZnFmuEBOQc1BMZPmvZRlk9IR/ykdYe0MEbFOkiPJ8k0OFtGtQt6IIzES02aIM2pA029ELDxMEmbFIVZMG7gukRSIEUUMHMxaQvIAO/stEaYVSRiIDWSAcDzUWVSAkGAALP3asWrIUp/Gmgug8WOMES4BvsVYRVyiLbuZ0RdGUGjuwuqtL/ydZu7basB3DA7e7u0pyly/5ugtWszbZSzPpdgAatMUmD7KTqvlQD6kkDMcROz0aDq/oDfSgtNMzCE5hoIMhBGMgoHRgCHeSExq3B1WatsgKriwYc+5JmQH4mt4it2T4r2cIExNXEG/SBHdSB/gJFUNSBOOmvirCIFWVCmlXFn+7CzlbD3qZN2myDNkzDLHiCPKrBG/wBJxxCEzRBFSxBIgSCOAUCI3iCLfSm3vACRukZG/RBBpDMWU3MlDSPCBhP18GXKaxCQt2CLNSCJCABEiSBiqquqnHpBFKgY4EsLubiCqRSCNyuBzjx0ohA7UaxKvWu7t5uy3YA1NysMP5a/wcAWggCoxd10S5gqBcRgy8EwzAFgy50kS8IAzewh3nQwzccgyBYASJ8iId8iNXqhE90iGgSpLkEXCGr79dqpj5uluyRQRsMstc2iIyC7R4YAtuiL4jMQUtIKyJABVRIBZqpWet0ETFAw7hiwylrwzaosjcUQyxkAhuEZA0MAQvwwAysgB0gARbowBpMwQ48QZnywjGkMCuQIuhWpwcQkJaIFARIFwJ0QEWN4k+hj90eYC04ghNQQRJAYzRKYxckajf1IBH8IX1iIC6+wDnX2gukAN2FQDs7cW4sTTvXrm6o0q7xmu7+YoDe7NSEYKUQaM5kBizoSZzcwvAgQzUUg/+T4k00occ3zIIWPIEh7DEg9wSILJFAei1oImvnxOjkYM4PIdEjG+to9l7Wrq9PiG0d+AEicDIjIEIjNAIdekK91MhV7AIpiysqq3IE45guGIwNKNIRFE0XSMEiAMElTMF+PQGZ2oLwUCdNFolHgTGhwYxwiEDXRXNbxEItULOoCQI2azM0dvMUTEETgHM4GwES/IAO6EA5x4A5n/MLGNKilIA8Q3EV33M83+7dRUpfV1VV2Sx/Euhd8UzYcbUb360v8EIxHAOOSUMzOEM3uINC7Ec2gGQQrMu67ERFWzRPEFGMWo5I1yg/MtkPIdloxq9IlDT7nnRoqTRLwzYnwzT/JmACvXjCKWAGvgCD9DZDKaOyNpwyjhlDLLBBDgAxECSBIoiBIoRBJFAcOLFBEPyAICyJknhuC9BAC6SAz61fI7YAUp4RTZoCK+R2V7NCHGBBN23zWJf1WYtzWqt1W+NiOdOaXNfADhSN0axADMydO6uSf+/1B5js7fq1BoAgAN1dpw5DM4lQzxpTz5YyNEwDNDwDNTyvN3ADOLiDPyjEPCzD8fyARGt2aHH2ZsdEJLsoa9OoaAKcknVEsRLctoCtaE4y1sJo1jJRZsc2TMO0JVgCJoxcKRjUVbhxLwRDMsyQKQMLjlWDMgAuF2xBJ+xBYMKhJkCCKsxBFPTBaGQC/yrYgpP8QEUZycHYmXgC11qEbsIcIBcd4LmuQUWs91hXgVkfZw8aQRLEd8gyp1sz534bSoDFXQoI+m24s10/sX/bdS/inYD2Wis1ugDpSKRXw1ZsRQNPejVMOjVYODZ0wziYQz/ogz2Ew0Mjjx6j4Wn+bx3oQbmw79aCdvwisrdEsiSPNMG9Oo3POI76RGZDpFO8NI9HRSBAQhap2VbHgpMaeTFI+Lg2yzVYOKb7gi2kgiUYwiV0gpYmwickwilsgRdgAjDUgnthQiN4ARoEgXTjwMFwFEcZ81pkAirOAjMhNkJ5Qsh58zZH44BUwZyf9Z3/cEjqOXO+gHanACoxyv/BM8opCfqgF3rD27XDR/F+LnqAUuqkQjrRYjqOMfkpj6ulR2k1XEM2oMOn15g1PMJSt4Cpr7Qehw7+4oSNuzqtw++th+a/mUvMG/LNv/qxgvYelKEfGGklN8Wvw/TFMQId1gub+Ykt6HYx9LaSY4M1PLA0zEK6nkIldEIkdILJjUEUZIIurIIVPMGYo0E99tQTkPl4ZsJazOQoYIW/+EI1ZwLp8PL4inU37zudH6cSJIET/DDIhuw5E7wJ6E9dt/PBk8DCCzrEM37Dp+zJ4l3FV7wAaQOm7y3fXn7lA3fHBzc2XAM61AOHrwMveAHap3xsw7ZC/m9OwDzN2/yMi6H/shKr60ty73lt7Ns4i8uoaAG9kVKykfK4tP6B6oRCJngCDk+zLuiLhOttNqxy2miDMtgCKggCIwRCJ5SCJjyBF5iCLpxC/PywDmABINQBI0gCILyRKUIiWzgMK9y0CP2LLGQCi6Sa3XOzgOT9WfM9iCEB4Lv1OQNEChMuXKgwcRChiRQLGYZw+BBixIgeKFb8cBFjRo0bP2jThs3bx3AetVUriQ3bx5TVrm1bl0+fvW+jvCTBQQNRTkR++tTp44dnT5999hQtmgfp0TxK88ghQ0YO0qhIkzLd05Tq1aZT5UzdmlSqV6Njw0JdqgftHkOGEDVSa8jP2rZr6P4JtMgS/yZEjjaRMuVKVi1gxIwpm5ZSm7dw3rZ5c9ys1yxHdSwxeoImFi5LXZYwyYIETiIuayRJchQHjZZHpkaxYjXLFCtbvojVJuZLlyxJkALZyWKITnA6ZohXqdKkyRQmTJQkceIECZAdO2xUtxHjRXYVKggS3G6QYfiEJCSWf1iRIkf1HKG1V5ZMmTFiyoAZM+YLGDBlvHg5e/ZLGHDYyceeZzKxJBE2rPBDp52CAspBoMbS6i2tpDrKqafkmJCpqshaisKrugoLLA8/tIrDt9Zaq5EVG1EkEkUSSSSSSjS58ZNQTlkFlsBu0YU2ZaSZphpstjnSm28W2yaY1dL44QlYYP8Jw4YdWhDhhS4U6WK6OtxALY5RxBzFlDJducUX/PLbZZdYNoHkjzfeAE44M8IIw84plFuuOeh+mM666rDT7rvvFjoovEMRIs888zz4IL31JMUAA1sstaWWWQKrxRVYXCkzNlZ4EcaabMJBhx175rElk0ro4CKNBiPs46egaJ3QRKOw2mpEEDvssKqsgu3VK6py1VUqYX1dkVlD1JoR2hkVoYRGSTTxJJRSUnElllpw2WWwZKAh0sgkvzlyG2h8yQQNK2qBBYs6wnjBhi4uiSQRRajAxJFHMmlNTNdGQWUWXfILZs1dXNGENzvmFC444uzsQs/lmHAOCSSmoy7Q7F7/4M677RJNdDwSTDY5BBIOctSDENCTdD1VYGmllZll3qQvMVebhRluwEEH1XLcsSebUTBRhI42sJAVKD+GohVqXJfyFcOuijXW6q60ypoMY42tmtesRyyqV7K7gmoqs4py1qgV1ZIxWmhhtLGTHHXcNjBdwK0PGmqM3IYbbtDFZppeTNFllidCqSSJJAqhJBJQClFklVVGeeQ1114bGEhigkHYl110WUUTSRJxeC2Ig7uzC4r3XGKJJKLbmOPrsnOBhu4IaoH33nsXCKEUThbe5IRWPq9llyPlAGaNVFHlFZqfl4WUgHk5xtRx2iGHHHPaYQedeXh5BBNDvHxCp6YZ/6QVqKg/9PUrYL0OW+z6rc5KRKuf2l/t/NEuq1dqY9ZYVqQIA0YCgQhURCUQSIlK1C0UnvAEKfB2C1zozRfFeAY1rpENDx4pJdeYhjaMkQlTOIIKdKCWIkLxhlCsgmD8scUsZjHD1uDnc8HwRS92gQvSmc5hhaBTxIjDOootRwqxk510NmYd7MQgd7rz3RRbkJCRFW9lx3MIRZQXqeZp5BWiEMUrXrEKVsTCFsKIBjdSBZN4nEMe8UiHOdgxD2xczhJ/4EIbuLAW9cVlD01LEf6Ahaz51Q9tWctDIu9HlQxpSGxL8YqGpsarr7XNWUlhkQFhVKNKfDJG+aqRJjaBif9NTHBHnYpFDYGkQXKhBBvXaEljntGLUTCCEorYgh8WwYhTfMoX1WCGMH7BH1aYYhY5DMYvdriLW5yidIGAgxqECBw+RGw4YWhdxZLYuOj8QAfh1EEOckADc9KgBubU3e6maAIUvHNkijJBCBByni1axItfVAUodoQKVvziGuGghz1g4o9+9AMe54DjO9xRR1vEgRGBWAMXKAqXP/qhKBjdgx44dKz8gU2Sjjwb2vj3yJLqj39YSxtXrnbJFGXSRTLiJAI/CUpK3JQSpZFEJrBVClSsIjarvEUvgJGMZhwmJUfKxjoW4w1p6IIUfogDG+KQCW7NohjX+AWAkPGLMun/ojY57IXenhnNaVaTDny4phlWt009dXOJ4PwBOMdZzhrcNZ26yx0V37mCFcQTeMab50PIg558No81orJGOOZhD4LCRB/68Mdk/VGPeriDHvTYxiMEYQg5qCENWMCCIDOqUaNwVGqV1FWvvhIWromBf2KQLRlmS1vYQtK2TxGphhhZP0KmCJOGeFEiIFHc4up0N7sxLiJ6uVMJkiITpPAnGm+xi2AUAxrVKBLgwsHUb4SkcLN4RBwOZ4teUCMawlBvZEwRC9oQoxif44XeanGKTlTCEHBYQyGEmFZCDCdirNMTFboJHST8IGN0JSc58RpF3NHgBb3LTl//upAXiEew/ysjAfGQ96gvXuQXi11HYwnKD3z4gx+TlWxk85HZedBDGHhwwx7kwIY0WIELwFXfifInFhpHpVgo1V9tn1Jb2R55tre1LZGLLFs5tEEMbZDDHMgwhiiTYQ55QG0eiJLRQGpZRYbAl3GJWxrjnlkSP1mEIzDBU084gqfS5ZYtOmcMaZjEJUwNx5K2gY1k0LAXvVCjM46hXl6cERfwLUZ8g8ELHtaiFPc1hB1Ck4jU/ZetRDziW5ujhOhkDAg62EEObJCDGugArzWAIu485rEUrKDV2SFZClBAa4GYbCGMSkEXP3wRx/7asic+6D72cQ94wEMfBKLHOphqijjEwQ+BkP82IP4wQOBaKEVRQdZqR2o/p4x0f19gMhna0IY5lLvc50Y3usdAFzms4d10WQMc6gCHPtDb3nb4g7353Yc/2MUQ0tpkIxp4U0vkBRPX8kQmMoGzU5KiFKQ4xU+5JQs6g2s+RLqGNpDkmMV8JL384cVWiQkb2cAnGfEdqy5yUwpN4Ks3lv53H96whjfQ/E5hmAIVqLAnJhgB6EbgAQ+mk2q8wgAGLohBDFbggljHOjyyBqyuF9JFi/Q62ZYNNj8O2o/J8uOyBFLVNqqRDEHEgdr//sMd7GBtTF5bV9emH//oHtv9MbkrY1j33vc+BjX8XQ100S8cCF/4wtsB8YRXu13/pL2IGTGiEZEneCRuKglKYALz12I4w3EmweeeIhWr4NYq6eyLYBjjGeO6Rrkcsw2OKzUax+DPVnlhC14EoxnNQIYOdXELW+DCFaF4+YzsYOm1/KEna+jDGnLeBZ5XbDlEkL70h74Do9cA6TBY+tJfMKinM6TVgB2Z1Q8LM3tc1h3HPvY//nEPd2CWHo0txzq6wYxfsEILgEj7v3vjtgn5X+7eR6SGDMmSrMjETcmITA7GgAEbcAzAwAHLjQHTAPDoog4uUPD0a97e7QJRS32YhRGIy7h0ChJ06kZuJOFOUIJu5PNQIfT8yRVm4Ud64XOKoRmyKyW8IRvQBXCUyhqi/4EaqOEZlgEZmiHldqj3auEWgm/4Js34ju8Cl68rtKnnuiA5LGb6iKD6NsbotG/7uO/pwtDVxK8h7snDPgwe7kENjW2O3A/+1sEbrMEanCEaYq8XUEP/FE/a/gCQ4A7ulKWRTKoAE1C2vsAQC/AQZQsMIFDv2uABGZARJTDw6GIS3a0S3a3mLrAO9oAo+JAPV2QRQnERjiu5rOUENSEFFc4TVBFbQC8VTAEVfkqoWI4XMugGiwQbPOiDAqcbAmcbriEamOEYoKEZigEJb0EJmRBfDOEPZiTgmLEnkm8KKcYKrxALqY92ru8Lt08Mu5EME0V5eu0D9iEe4EEd2uF72P+BHZaNG6jhGLaqDqOBSGwhCKwAEAqP8fhwkKQGRTzEax5pEBFRDAxxCxCwEA3xEBcRAh3xERXSAScx5+TtTuRN3uTkDRCvD+wgIxdvLQIBERpPlBQBEnLKWhKuzRjO8zbPzSaIFPwiFqeLhuisFoNBXKjBGjpoBz9IqajBGZhhGZ6hGINhrJCxFlbBEzAh8tZiRkJR2gxPA//OdaBPCZQg6ICA6KZj6LTxC7MDDL3xG8Gx/CQlHort/cBn/rohGpZBvZIhGUgCG6BBEJ7ACfYNH/cNuPAHL1kLfnZrEBHSLwuSIP1SMA3RIR3wAQszDNIgDVqnCyLyTqZQMQNPTvT/7d8Qb/HuQidAspMsoRIwr81OciUXzvNGExOeq0z86YxYSRdo8Bg26CY9KHCy4Rp40iePwQhvIwlroSgXzhJaxBBkhCmlyfAoUg206YiYI+iAziqxkge0chu9Twy/sgzvSRzRAbO8axuyIZaA0BqKpBpCoiRkAQeCQAfgAPHewPD2Un6GJZGwBpKc4sgEcwvmMzAHcz7vkz63QCELEwzucxGdT0/0pDEbU5sSk6JghQLn7Q7gYEHvwEEdFBAWQf8EoZcgL/IODuEwTyU3b+F4akMFAc76oiVRYRSkKzXprBd+oTX9RiezwRqeAUZ17zZERzcDYxU+oXSMLxIggSnp/xIO6FLeilObKmYqpxLoqG/ostLonhM6vTIFxnD8qLPX5iEctmEO/SMaNogaWMI7S2IYdoENdKAFcgDxHCY9QSRY5sdXTMqRlqwpbOsL5nMg45Q+41TcBDMK8jQK8JNP9fMw+ZQK3IpAB7ULDpQC1YANCO9B6y0O7oAN7qBR0S5CGYERHMERGsFS2UxDNVQlRZPhNlUQQjVEJ4jhxCSoLKWVmiEabjI7Y2kapuEZUk4oe08WYqFTTgFnTGctKIFHFyEQfPTfNHANitOt+IRPjABJk5TolnQbw7ArwxCwIOIMv0gbYLUZnmEa/CYxwBMbpGEYgKGHYAES6AILbE5OFP/vD7btKrDNKLRtkWZrAL9tyeY0Pu8zCg6RtuhUXxFSDNSt3NzADcqNogR2NJwvDAI1ULsgwTLmCeRyrhAsCCLWCR72B3AAB+YqB4LgB8jzOZzACoLgMrAADdhgZNmAqi7QDeogDryEDSgKDdLAZGE2DkJRENDg2Z7NX8jkNWxPGJZhGZjBGYJWLX+hFyxlFmLBFDIBBxbBFVyOYfLlNyEhEfYwWAkvSIU0KpEzOa1yC60Pr5burrayG500nrZIHNlyXIpkW8FLGnbhXVqBFnChFKRNtCwSPQmvy0IkV9JUkbaCpA4QIQFTPv8yT5NgC/L0Pr+AAQ/0QNGNcbGAC3r/bud4zvmkQApEC3K5AHO3gKLSgI8M1VDRoF1eFrQoEA5ilg0YYRHYYA1M9nRD6wmQgJx+IAcs1pwudq4sVnctNmKDQAvCZGf5QxiO4RiW4RiWab5s4TVmgRXi4BFudBMYBhIUwRDIzFebsvAoEWsDlDmKNOi08CqL7muZ1FnHVvyk9MOCkCRCohq81W1n5hVAgRZ24RUS4Q3SYJrgwCLXIArV1UQuxEJIxKQAN3AH007zU08TWE/nc2AZ14EZd6KGdRIDL2XvQP/+APGYEeDs7Q/qgCLhwHTXIAucIAvgAAp+VNruYKLS4ApaGApklwZEoAVSoAVo4Eo6oAMoBYcp/4VSHsCHMaADWsBiVQOZbA9Aivdac48tn+EYkAEZUk4ZdmEVohdfRLC4EuF6fxVIJXJIoY9PlCALk5QLjw4G7soLm7T70Dj8yjYce23jSEIZhkGOb6FHWuEV9omMNOENegMLskBObO5pDElE9tKRBvBN6y4g8zVw55QgC9KR63QLxmCPBFa0JvmB1+AJhpUu0oAu+kD/9G8RCuEPCOHf1sIOukC/sqALrgAKhjV2c+BPDmwHaFcHGhYJdEB3a9eGUwADZJgGaleII1YLbNZ5xyQ2aogGa/AGoeEZgDAInzkIm/kZgtY/msEXSEETPqETeEMEsZhqq1be5IA4stZiqP9y+pR1jK/vjJ/1WbkSOtl4WpunW42BTWThFeL2nmnhFJ6nFF5hbtEzDbgge81T7SppfrYmKtTGtfwW3IwsAQ0SPhmZThP3Phs2c0ULCZ5AtBpWoxFMB0QroLEgCJyAo58Ax5xAOjJGB5DACYT4nK7EdzqAhm9CBESgA0QAd+vRZh/BE2DRNSyuuvCDGOBjmYfkVY9au7JVmrlTDuPRqZ2amrNUF0YhFD7hEi5BakPpCTVYGuUAT/LEi40USYFgOcX3+u7qOpiUG9P4WeFZHIEhN1TBjsnoFXABF1ShFErhE04BFCIhDeLkCuAACxJ13uxWpA7p28aGKYBMbJqsyYT/jGvoLnAdOU8PLKNjd64SrHZ395dzAJdxgHcWoqZluAVweIeBeIeD+HZxAA1CladXwVZpyGAGozCgYUi0Cxc9IiVQ4iRgCSVk6RrkULh/EJqFuw6H+ya5IRtikxuUpBhMgRQ64apLI0bgZquRz4PhrYgk12KQMwuNoKy5UEnxKq3Vulmhbvyu7otcwRXkmhbweq5P4RIUgRPuGBTQc6IE2woI21zlBGsAMWsCOF5HJEOUjLYS6e6abCAfOQoax5ui4AduN8KetHds+qZx2MIx/AGAOJjRABDOThA27y9oiJUGY6jboz2OGqlftRqIBLdfHLeB+yZlfMaDWxd3cbm5/6EbwEEcygEdyqEc1nGg6uHXJMsfYoIenoGqQ0H4igtyrLtZsJsu7ORgea67meO7uZZ2ktToBMW8t/Kdo1S9YeYV9vl54HafaaETSuES7vkQLkGTAzq0DO9c64CjtAzPtwy1TmvKtEwP5gDQAx0t5iBD2oDcyO3KHvBwk6AN+vNwD+xhbSDCIqyGU+CmQ9t3LHZjrSAN0MBSoysVuqW6TLwwlEEZbNu2tUsajFrFodnVn5k70asOgxC5hXsXd1wcxmH+1vHXeh2yIivZfj2yKGvY2c8fWuwZTCEVQqETOmE3PimXthoaPbgrqJzACIwJqIAJlsBIq1LLN6Y5uzxQnP/oy72Pjc0wLC+CFvK5FXIhF1SBFmjh3eH2jt8ACDIG30Et358jo5PgCfxddih2rnZAY0jtTx72BWhAd8/JY1pgwlPAA0TgAxbCtHMYtYF4tHlnPEe2mIOqhuhsNU0vGAjDPkzd5E2eLZX4idnSiY2KeF++eH+WGWae5meeDo9bDnUxcMCBx3Pdx9VxHtzBsh4rH4qeoJINH7YOH5YeH+4BH1JssvrhH6T+oI5cH1KsxZaBFU6B2StBRiohl2SEWbYY3rxatniOwJbAcpWocWjH7amjBmwg7sd96bxcbNcaSqtOWg0rPaaVrtd93ela8E/hFJgACJ4jCCz70w6sdwX/PrNh2fFzd3cn/yZWW9Mf9mIv49lCvFRR4aps4UcwyMRJni1Ln+WdGOadWPWJ12eFsXhrE+ZrHmhn3dZvHRzmD1XUMbN63bGYHh+KHvjzgR+Gf/hRzMRSjPhTjP2Wf/n5Yfm77qD+IbJSTB/ogRm2vusjARHA3oCkneynUAzQPonW3sGTgKzfHlDGXf3pfukgDO8v7MLKkFH23rAw4u/xma5b4XnW/RKuwGOfACCCPBnoxAmSgz9+BFnoJEjChDge4piYcKFANGzQxBH0KFMmUqhQuYo1q9YtXbp2+VoZjJhLY8SMJZuprFmyYjiTIcNZDJnPnz6FCR0q7JhRZkiT/zJzxjRaNGtQs0nlxg2cuHLl0LFj585dvXr4wuLLl0/fvbD88PHj5y8sWX9w465dG9bfXLpo77LVqzbuv7+A+7HVxzYfPWesUJXqVClSI0qKFCUyRPkP5UB/4MBZs0aOHDFiqFCRImUJ6SVJUicxAgTIjtewX9uYTbu27dkxcr/IHeOF7xQpXgAfnoIEiRDIkXtYztzDhw8eXr3KReuVKunSVanKlUvVnzRowotHY8UKlvNcxLOJAwgQx46eRpliNXKWLVsodfkCBqyly5jGBDjTTcXMhFNRRh2DTIIJLrPMMQ4q5YyETFXoFDVQXSNVNtx0I844WGWlFTv0fGXiif/w3KPiPSnKs8+L+8gjDzzxwGjjPmrlw1ZcYq0l2F55rWWXkEP+JdeO/gAW2Fr6wKUPPcwkFgpjkSBSCWSSUaYlZptx5lkYoY1G2mmqrWYEa7G5FttssN1GG29w9iZccHMOR0IKJiQXwnJ7NgeddLlYB4p1rYiiHS7dFbKIJJnEJ19Iq8Qii0kp7cIfMAAqY4wynEIDzTPQJNPMqM+U+oyoo6bajIOsIjWhUq66amE0GGYo1TZUdQMOiOvMMw+J9NBjz7D2kGVsWfoky4+ObK14z10qziVYPzdWe+NYxR6rj7FN6pjkWkqGC1hc5A4Jl5L99ONPk+tCyUoqizXWyJX/kWWpZWZdqvElaKKNWVqZZwasZmuxwZbDwQgnjIMNcer222/E3Zlncnw2x5wo0mFMnaHaXfcKJ7QME+Cm0Ehj8skop2zyNNJM4/I0TkVjaqkxV+jMzLPWas2Gue4KIjvzBGtPsMISm+2xyCartNLlkivuP/1ALXXUVEPNT7pYY23tPmlxu/S2zIL79F/8hAsXkk0Hlu7Z+xgW5SqLXULJvFjaW5lma6ihrxxghukvamWqhmbBBSds+MG38ebb4sQVh2cIE++pnMWTVM4JKKqIIgonl3NyxiGTgKJMyi5D8/LpqJ9OzeqsW7O6rbfm+k04tNO+Tq9FE5tPsUcjTda2/1/7k/Xww4/9dNRQC6+8uswvTzzxTZNL5NhiAzYXulhLz4+18qwoTz3svH3KJ5dUkgi9kU12L955fwmmaKONtgTggbPmmpqE65CDDvwnvIObiltcnYAjMRMYUE99ag4oQseJQxyCE5PY3CQc+LlDhOxkpovZhVZXOk+9jBrb8IY3Znc7XxHNaCgcWgqH9bsmuTB6cWmeuv5StedlzXjhQp4MYSi8dCWPh03CIfFwqKTt7eMeMmIRPJbIRHio44lObIcU4QG+ZbBiFeOT2/nqpr7LZIYzneFb3+DXr/nVz35AsF/++KeDH7BRB7KxjcMEOMACGnBix6HYciBIC1A8kP8Tr9jcIRboQEIEAhKqUIkyvLGNDXUjG9bYhsw6+IzVYaNX6xCWsLbCla50BSxfsQc7xjEOcZhSHO5ASwyTlCSy3YWGU1MSK61Xtqodr3joiiX1oObDcJXNSDS0oTBv1MQnGvMc6mgijZgYj2bKIx7y8IqK8sGOZbgCXp24hGQqUS9FVOYy7FtDGPrmN/j9K3CrwR/hXvPG/ukPcbiJ08Ma57gD6uk4zOkT6AI5KFB47gwRnMQZBgqERASCUboImgnpoZV5fKManwIVNGK2jV7Ng4WefIdG35GiI+YDH+340ClReZZ9jE2YQ0yLWoikl+vlEJfBJJ5L1XbDX4pLL87/UtESk8lTYz4RmT49BzKbSdR4NNGZ3UNiNE/EjmbEAovZ3Ga9EkHV9XWpM+PkFxnlh850vkadsHljQvjnRni+aY6Mo+cdEdinyT0QFKDAWAMPMdAzFGEQAj2EKgqxBkzwwle0o0dX2NGrcGgjop6KBjOiUdGi5aMdG31HMuGxD8Ec0RwiNSU5UomPmPbyRcOrLPL+cb3nVfaHrUQpTIkYUxjp1Ik+VUc70kHbdJjjtritrRR3y9t2MFGJ8JhRZJnI0eA6ay3ZGss8lvHUU0Q1EdpMX1Ur80UviVGr5jRj/VrDXcI95LtjPVib4iknOjbujpFj63IeSNdBioKuAJ1E/xPOgNdLFIIPicAEMeYRjmswQxz1MMc46PGNaWBDGp4i1TIWy41gseOxGy0qaPtxD8xm1hz40CEuUSquynp4a1wTrWqxBrUJU+tFKprREpv5jnhEVqNPTIc60tHb3irTHfCw8RKnuGPIyujHSa3HPYQsZJ26g5NcKUcymvvc6EpmuobgUpfykIeshsmc59xuGrlLsB18l6wPEW/BGCbPtAIHvSY4jnGGkxzQVe6Brxjk5wZKyENUoQmE8IQ0fAWOBrujHUC7RjGU0QtgdCoZEFpsN0hUD8hqtKg+7Ac8yPGhUoqjHcLjJYlpGlp1kStdHkapiIkH5CSyqMY1pq050v9xDlbXNh0ahTVk3cHRZELTmS/e6JBPxGte0xrQSCYHOUhJbGJnVhzgQIYrVOFcTTiGm+nTkhfxtQY65IFv2M0uarSbmjOZCY1A+DJ4+bfOeO6mvMRBs3HWnAI9DfLdAJ0zfAVawSaYwRPQ8NU8MmmPcbAjHM+wxSw8EYsAcaonSIkGOATr6EfXyIf7aIelTwkPG770eUe6WtZce0QZMVEdyBTqOW4bcqHmFrcoN8eMV07bXOea1rSGZqmhuSIU79qTf26HsHc+7GGP9OdAD/o3lM3sTjh7XlP9piH+QO1qX3uMWz3N/KYuOMEFDAk/OAjWwevGdf6PzAwT4HBQgF7/At6p3SEADiApOFAH0vsM853EEHrQBDoAQhfhoEfQ0IEOctCDdr7whCdcAQtZDEMZxCjGgp1hDXBspR20bnH31nYPSk+cHPew+D+SBL0hueUrwHWiyFOO242yfMa6lSKNjblTY0r29cV9ZlHvQdRlGlWnHNXobXluSlIG/edW+b0pwRF84Q89Fq1o9rOTLm184W0PdBAjOa98GqlzG2Cp0brWuV6w1MgmN2Gn4wtWQHYD0pM4dp7BnAf6ClpAcBD0PYMMbjCEI2yCFcfwhu32bdhq1KIUn6AJsFAKsDAMLoEMzeAM0XAN/pZR8XAPouUP9zBxpoRpPTRaqIVESNRj/yi3c6S3ajSGarnVcu9AW1KEc+2QTEkle0Rlal/hcRtlWx1oeRQYfMRHfMKXgzqog8eXfNkUCYrATZAxGV3EdM4HfU9nZdhVGtZHP12lfQiBdVtHbjuABN73P+BnA7tBRyvwAiZwfgN0Bj1QBZMAf/A3CZyAV0VQBHZVBQ1UBXp1C70wDd6gDdsQDtVADMPgfqDwCbQADLIAC6PjKdVgDdfADetAIvaQeVKzef7wUfhQD0nDLp6nIiaCY5i4W13BWzgWXKU2I0jlLN2TVJb4FWNBFvXADyuyFiwyI3/2Z+xgDluBDiGCFcb2IbaIFT1HDpwkbHw3i0g2i3w3jLMoIv/sQItZsRW3s4zrYIy3QztO5YOXcAmRgD5dNG34QgfW5hnXBRpXRgVLoATiOI5MII4BEzBVmAROkATaBwQI4UY6cBCuYQM1QI9h5wIvoAIt4Bst0AL05I+NcwZkGF/zVQV31QRDEDpsuEBnQAiigAuuMAzeUDLQ4Au6gAuqAAqXoAq0sAuyIAu7cHgIRg3XoCENWEvIo4onMmvwgIkt+Q4w15LR1JI0iYkwCZPfo4HeY2o5dQ/GEhYmgor1cGR953NBd4M3SIGndItLWWykNGzEJiK/yHciUg6cxHe3Y5WJSFjNWA7rgA7MyIxeuQ604w1LhkWfkE2HAG2RIW1RFgj/mJEZ2hh9VoZt37gETFCO4piX46gE52iF3WYE8shdY6UD+FMDiImYcOICKqACL9CP/Xh+KRCZoiCQVXAGlVkEl1lXgQR3bPg5oNAKHckfm6IMtNAKl9NHuFAKmwALqyALxlAy01CS0ZAN4+AOEJg1tMdbLvcOHudiG2V7tseTK9JrvTZYx0gO5cCUN9gNVNEhzvmcHUJ83aArSAkO1WmdN3hKOFh8I+WUxZaLY4kVYZmVY8mMtUM73cBI2XANUEENpeILTxU31Vg39jIZcClldAB9+0IF/WlOeRmgAjqOAVMmSnAQB4oErVGYapKYibmYjQmZkdk4EpoCAnWZEQRQ/4NQBJUzUBtaV2g4CdeBC7gwDIY2DNIBV7TQCZ0QCdqxCaEwDNJQDdXgnk/BDeTQDpmXLiwSa+ZQgq8GazH4YhtIXO8givAAk8eIjMvJndSZnVCanUgppdp5ndEZpViqnch2nSPFpen5pWAaDt/wDdywDd3QSO3pntbgFEzBDA+CIEQhDMGgC/NJPvVpn5SBn3CZjUi4L/8JP1MgoAPal0pgoAmqde44Vg26Aw76oDGgj48poRMqqRYKOpt5BpxTV5YJQQNlOYbyCrJAorRwCnAFOqrAByGjCn5IC54wC8agDdjQnlIBYG3RD/iQY5vIFScIebyac7wli+zAc8LWpf/U+aTSmaXfkKXVmaxRep3YqazdMKbSCg7f8KzVqivSOqbUSq2zI6ZjGp3bEK6NVJLvyaavcgxxKhRGIRS/0K6/EAzwGgztGgzAsAvzOSWRcD7WmKcGtaeasQcAu43SB3VUMAUGK6gBSqipURBQkKDiqH0JAVYAJH6SWrEtcASf0wQXOlCXalec2qma036qwKINxIaiEDqqMAy5MEi5oAkZwQrYUDu3ww69M5TBOIy0eIs3KJ0827M+C53RCrS5kp0dUrTHmp3fuqxJu6zRGq3fmqxQm61I65ziuiHvSQ3mOiEJQhTu2rVe267CMK+/sBLvyh/xuh/AoAuwoAqlEAr/mmA+lWCNVEVV+YkvlIGESThOUGewB4uweimOC+sEUAAFB9Gwh4qoazKx4re4i3Nn8MWxoONAlQl3R0Bv7Vcd3VEFfHAETcCG7scdE0RXhFAFahAHj2AL3kCWtaMr4vCcG/K6sBu7rxuuP9uzRFu7uAu01Wm7RCut0ZkrZSqu4VqSagoVrmOuSbG16foLQ8G8Yfu17doLY/sLveALvVC915u91Wu917sLu6C2RVcJ5RO33TS3/Spld2ttT+c+78O37uu347gEUMCwDYsEhguFXBZHicO4i9sbdkZn9EYL7/UxZ+B+cIeptNBHAlWQRXAId/UKcAVBlSNfUxAKctgM/9MAn2yqQRyMIa9jvMQbwhpSkhsivOKau8DLsya8wrSLKybMSGgqFeTqOlgbDRWCFMeQFLNywzjMIHGKrnHqvMzbtfLqrtyrvdq7C72gC7zQxCixC2s7PuK7ReWbCJKxCPn5rwGrvnJAZXZZsO7Lt35bjlIwv4I7uEqAxvjbXV9nA/pLZnDCv75BV5fpR55DSKCgsbRwoZygOQ00QREkQWjIXqADQQ50CSBJDBgMM6yjMyKcIeRaktgQq7J7KyxswkYLpbOTrdLqrd/gDetZpmcaw+TKOjIzKm76IAwCIQkCKwq4QTXDFDmcykbhExBiy6tsyzwhDDzBE8TQEvEazP/CDK9pe01Z1Bhxy0Vzi8V7ahl4e21d3I1iMAVhEMaBmpelMXXzM7hnPLiGm6BuxMa00cZwLMfit5lkGLmg0wRNADqYygdweAiE0F6fM8H0NUEEvKE+IJCXgAu7QAym4zKtkyHGa4giHMKTjA3Em9DZQMmWfMneQBUvLLwNPcmlXMNtihQOkss/ocoJggwbrcqt4iCm0shYm9HO0Ayp7CAL8hMcvSDFIBTB0MvB7BLDfNP16prjQyXJPFXLzMxMd7fPnLegQc3WfM1NKL/e7M1pXL9adyZdlrjmFkByzM7tXEEC2XbdUVeDBM9sB392hqF8AAqfUwQ+0ANnYAef4M//xJAMppNYtEIr1FCIBU3DUFGjC63QkpzQfN3Xfl2IjRwNEZUqrOLSDAIULr0TvbzKtWzLywDSqrIMpAIqAl3Dz7AMz7DSLP3RQMHYMQ2vvAzEMv3Z8TqvRfyu9ArFWAQKP1g+ypw+zAyXWrIH0AzN0jfNU9AFXXCwBusv2WwaV7DUaKzGWycwXkdeDSNAcXwGQ8DOlpnVBawKA8XOg8IHh9DODmTWTQBIk8AHlxC6ZzADGhsJsOC9xKAMsrlBjVwNGWzS1DANNHoNeC3f8k2j7P0ynpJgqtIMLc3ZO9HfLa3YPtHLCMIgPfETOoEMycDSj/3YkK0Tkt0MpSLh+e0y/8crM6XCKoVtFBq+2Qb+2UIR00MxzGIbvahdr7KARVOiTa7t00+2CLGtJQILzXoLJga722GMZdl8BcEt3Ez9jlANVuPVMHACx4oD3Zp5BEVwBD6gsaBQf5j5CvJlwFY9CNvtR5cQV242CJxwCZ1wCypx3iXTDPk9URU+DRFVKgmW38+QKjOhy/7xy/D6y3Ru08Hcy72s2DkxIHj+EziByw3S4R0O0g4i4aCi5tDw3jBzDZaN4TOzKg1O6A6+IAqyy3J608PsC8GwEtzL6R6p4gFYjejzZNIF47KdvuqbhN44TkdNRmOyBDzu42isBAVxEOco5F8HfkSO3LkxBAO1hv/TTUGXcwSdIwpwVZlVYOXxNwm00B2qAEHSMQkQnEiW4hKjQ+Ztriqcogw6IeLFgOk3jbb0ein9Ue7gDq94nu55jtg40diNLeiscgypUuYBHQ2zOQ3NgLXuvToYPioM7uAc/tiW/u3nzukGr72+8OmpEAoBCAnJjCVUFQmRAAmJEOOGsMXX9nTeKAasftRToOOxLutIQOvziwS3rk61EQMpzxtGDidF0EBDIOUJLF9nwLlw+Apxt7F2ZVcNzB2BQEGawx2RUAq+QOeeoiky4cv/8R/nPu6cTu5QfynxWu7AIO5NP9Pq6u0HMhTryvVAAe+SXSr7/sFyXSsmHcur8ub/QPHmB/Ltco7TBn/w2bsStXBNDK8JDn8l9kkJlAAJFM/Ms83FeQsm44TjrS4mUsDjPS7cBVHrJm/cUu0mK5+Fs6GZZxBIh0AdbSdQvv6xya7sRTBf9cwHfFAIWX7HXa4GtUAy+R0gMZEMMOH6Sx/MVN8f406v4x715E7Mum/w4A626frDof3nf47YhW4qZQ/LGELJNMzBpVIhkK7hC8LSIi6nxWDnwhz3cr+9vlD3q3D3ec/3ikAJEk8JjUHxc2sIhUAZ2pgH1mYGNc7xua3bhy8mir/4ULD4jn/yOwBH73QwAIEjx44dNgzaiBHjoA2CBc80aXLozCSJD8+8OjPk/8yhSa8GNTkz6EyRkINEkryo6lCViWeONLHTCpo0adOqKYOWMyfOZMaMFftJTKjQYEWLDhVaDOlQo0udPjU2tBiyY8eQXb2aLBnWYla3VsWKbCvWZWWXNXOW9lk0tmnTRlu7zVs2Z8zsHmNWVdhevsJ+/QUc+C8vXr18AfPlq9fiwoQdE9YVOTIvXbx81YKlqpMmSJA6XapEiVIkSqEVKYqkKFEh1oH+2LHzRrbsNW/WdAnTRbfuLFl4T5nCRDgTJUygKLliXAmUJVCSPE+CZAcSINWr/8CeXUcO7t2706DRHcd4gUWGDDnE8ZCoIk0GDSkyaeQZTiBHFhE1iBOn9v9V2r/ahZNDBBypiir+oEWZmqqBRhmcHGxQq5+UeqrCp4KxsEKfnurKqrDG4uqqZbAaS6sRzWomRWfQqiutY9I66xlqvPnmG7bsYsaZqnbksS++BOulsMWCDNIxyY6EDMlebIGllVAq6eyz0CKhErXTTlutNddim0223b78zbffiFOiuDKFK1OJJZaALjogkKDOOux0oJNO77gTiLvw8AQPvB6OGIKlKjh5pYgiJAJpCIqYIGkQQwkkBKIzQspFFD5yAYUT+Yqoggk7SlFQGmWSebAZB5uREKkNMySK1QqLgRUopWKFlUewkFlmR6psPcYsX321yyxm0HrmmWXsaob/rWrCCWedbNiKpkW7im0G16to7asowQZ7rFtvHfurGVtcWaUTS87V5BJ1K0nNyiuzLCSQLbt8A0wws5iitzHTJDNNI4xoEzo447zuhzrtxJM87/LEoU8aivCBpTNoyeUQkECBuAiRItrovkMn4UO9ieTbb5BJROGkCpEieWOTXUQdNZkGm4EGVQl9mhBWnKNytWdiaqU1aF6xsqosEX9FWthhUUyxWGPXesYmbGT05hpvrHEmmmaGdbqZZ1Alq6wdf/zLL7/K/kUYvHKMhhprssmGm26+YTYcYWZxJRRNLEFEXb/ZdRdL1gpJxDV667V3N3x76w244YZLs0yAA45u/2A5DT54u4W701y8hg2d9AxQ5GvCwCbikw+UYS4ZPb8qXgGlClBOEfCSSQ4NaZLRXwHpkFcSkaSWYUg1BpmcUrR5Z5905pmYVZ1v3uekYP1ZqqBpDUusZE4sq5lltk8GeeTdEt9p85upBhteWCGsl2J4aWYaaMwv1q26cMSf7Wis4R9ubrgBhzjKgQ520MOABrSHPepxD3zkox70cMc85nGMWKyiFOZqxN9CIxpKXEk18JqXbLi0ht6s4TaKY1zjgLPCx5UJOmwS2MAINqfMIexOnbuToUAnu/qQBD0GuoQ0hlEFishnI1XwHSdAcQg+DME9kzjZyURxuoukxw6kAP+GMoyRE5mJryc4+yKFoNe8qOBMetdDIzKCpr3siSh8Wgmf+FTEIuSZDy7FqkY1zoINBgUjbchIFrQESY1rXMN/AASHBA+YQHvkQx+PhGQkJcmPfjwyH5e0Bz2eMa5TdKKDnZDSBjn4LtYkwpSBgE1sYGMbE5oQcbxJIQuF47jhwHBNz5EhnC5Xw4PdME93gk+g+AOK2JVOdCzJhTZyEbJJiUIUHOEDH1qRi0tEaiKtU48P7JOeKlzBZVosFfJGBUYzCkV5PKPe9IoRDFgZpZ3BUNuOiiGMWPEIe3Ak0VbKAketyLF85rMfW57hDGo8gxnRuAY1ooGXaMAtG98IYDn/2OGOeuSDkRdt5CUleUmOdtSjGtUHRumxDmZwshOVqAQo18VB0bxrNasxhCFeA4c3wAEOJlRDTtMQhtzoZoXAoQIVpDDUoQZVCks46nNumUtdFoyGdboT56LKHR84MXT2OQJJMHIIWrziEITgCKFAccRD5CIXhLjEpCYxDK/6zmKgE0kV3uAESODCGBBSBvLgaAwJffGc6ZzVz64nDHjuBZ4dOsZeeCW2Nm6veyla2tam5RYcZU2QbetfNraxDW58oxvbyAb/3tYsBILUH6f1hyQjmVrUntaiGE3gAQ3IDnagw7brWAc6cBsOcWUGFJFIxGfWtUHTCG5wMh0hTVup/4Y07LSnK6QCUIVKVCkEdU1JbRMSoGOdyyEBczbkHFSjqgOPtec+D0HJSpiQKUWJIiToBQUtMhW7ibwimpd4BUY2ApJJDIIPVIJELUIljZzILycE1olOlEEMoxQFGMAoymESs5hfNNiPDfZRUfgyNh8p1lb4ewu0Mvu/AJKDHe1wB0UbGEkH1qOiqm1tjPXBDxpbEh82rkeK3UFb2tqWgLhdRznGUQ4h63a35dgtNJikClBc4hDCBQ0Hi6uawRUCuXagaU2VqwZ98ZSnXZhCUI1KXaGuyZZt+te/LFewGo4Xh1EdCURQ0jEqnoEPELlz6CbVHir67hWTENAkqnAEOv8QYj/vJQkUz3AJO2gCFzRJcKRR5SBKQ7gpQklMphUzpCFta1t9AQxf8idiQ8YNHAEc8kRdXI+MatQf/YB1rGXdj9PS2Nb8wMc9dI0PfOTYHe3gsTnMQQ5ik2MctiXyOJStbCILechExm2z1zFkIFebt5hhMmegfAkpd9C4rEGucm1KG+Zmwcs+FXN0001UM1MuCUpIswyd+oMgtJk74p3qpEQyqSag51ASeUkV6swfk3wEJURMj6CrUIj08OEV+0kZf414iEt8ohXDcNBdI/SMYmhFGUDRolPWqWlNc7p9vwCXYIRhl6y57W2mFiABCyhbe+gDtbOe9T728VpGrjr/x8CurW2LbWxiL3sc4kD6spOOdHEom+niQLXSmW50ZYdj2XULR43CAY1auCLbnoEycb2tmpgmIqYyvWkrl8vcL3dh3ek2aplvqdQl+Otfb7Kcd7FTb3vjO6oiOcnpeke6loCkCJxgz0RMJhEigkytqmgFKAyNEU3tWc8UicQnaLGLu/rEQaQSSjLGiKFYXSWxoA6MYo9lWWsYksTNAjJt3UEPVifQ57VXYCNzfQ95yCMevleHOuAxfOL72PjGpzo6yFGOYlP96El3OtNPjXRw1Mj6pw4g9qUPdXB0A/vMsr43vMH1VpTiE5IAu9+iPGWzG6L9aFc7TnOqhi/Dvbpx/z/qdLGbhDVFTs3yHhh6s7cc6KUb0gHA2zcDWQlQaCuvKgmTkY99Axnd4YRmegVRaDJCcLzQGZBDEImJy69ToAVgGIZh6LylWJWpwJVlCLH9eblsmD6JKqBMyihecyRHsiTUuj0X+7V2ELZhe76nk7qngz5nezZma7YkTMKjG8KmI0LuAz/P8qy5wb5u+J//AS24uQbRsoYbyRVhaAZgkIXy+wRMkASVUr/SaCksObs/+AObSru1yyk5yA24EzOi0r92axO7wzuCCUC+Ay8CDMR7O8CHkJgzEDiJSA/6kA+O6K+RmQhaYKJDAAWTgZ2vOgJDU6KE0w+LmJQKTI8ssP8DVShBzyPBYUCMw7grr6GGbGiWeYCtVvsojnok1MK1eiC+djiHYRu66EO6ogtCIgzGqXs2JVRCqms2JHQ+ZwsHqKuRbrDCLCwk/lGotLCLs+GWb7EFW+gFXRjDUyjDM9w2btugd2nDPoDDOFwDNmCDOaw/MdONuLMuM4Mh6LA7I1CCpupDAeylzJmqOhEUfdu3JuiB9ZgURWyU/EgPTsAFYjqZSRkd+TiZ9XCvQRCFSYiIijhIfkOrVoAFWiCXT7gETQiFT8iEWDCGaZiG1vsGeojF2IItA5IgHgu646OtYmM+40u2AUrGYmw+JHQ26FNG53O+ZgQH8ItGabQGhYr/lvvJi71Am2z0FslIksjYRl/YhW88P3HcNkqIMg9yv5hyw3RMR3ZUAzrsKXh0O7ijx3p8jnssk6aSoSCgy4P5Ll46GGfiBMAjJoJsAlB4Jj2LiMqjCEpUIkGJiI7gKkyhhYocBImQDyKyCJJAIopLhEuQhFMYEE4ArkDYhFmYBmzwH4lCBySrtiBLtmIch2jDLSM7TZqEzdikyQEiIGRztgEKMmRMTemDxitUyqVkSmvMC70ANbIBkiIRksc4Esm4hVuwhVvYhaxshVPQG0n4BFAQrs/wSm4zR5iCvzWoAzhcrnNbSyqIxzukrqHSw7pLAoAxAifIR6ZCArqkTx3Q/w68pBPsYMDI7BhDUZmEe0RFjKaFZKLSaY9oKgRMAUxOkK9ByBT9uMj+gqLHfDgmAjQl0hSI249SqIXQvAZsAC25mRvrwzpxsLoTLQerQ8LdAjKrw01pizZoAzJok1HTbFGkxMIshBsu5FFqqMascQaAGijKEhtemSdtCYxNU07J2MbndM5t1IVdyIwLkgSuVD/QAJwPIpzBoYM3MIM3oAMuabsxGAMwMFMw2II0VdM1HbO5m7s2cQInkM/5pE+6zI4fIMDs4I47/QFQLB0DGYkO5AgJxEg+oAhQaAXfAZmXoEQ+KASvelTYwUCUEZ3R+UCT0B1iosRMQbwLhbhPqP+FZvBRa8gjh3KozfqfuRlREsU6rDNNaXPVJMQ660tK0CqkLRQtH2XKy2qbttHVXPVRaKGfFVmRpRmRXZEno/AFPyo5xphKXWjOaI1SKU2FUgiFTdgEUBrHdSElKisEQuADOhDXcUXLMGiDNiDTMk3TM13TLRizo2IT9axH+ZRTOKlTO+XTfL3TCuQ3QZmEXNgPS41AllCijsBAWiAQjbAYWhgGlMGUI1C0kOCI0Nm3iXCmjoCdBa2d/fiEW0gGX52GD/1Q0cwGkjXVzeIsb4DGuWnVWa0RlIUbbMAGXAXOXeXVXr1ZaNFVpgxWl0uoXR0oqPka73GsETmGrkDaI/3/BZIzjAkzOcdYjF2IjOg0jF3AjGrVBCu9UnVpl9VQhG8lBEMY17GVg7KVg3NNVzTdgjNV2zRFTzNjtxjKpXqN03vV1x/QuztFgkWcOPrQFJRJDw+UyEDLhQmsFE4ZCUKRLz5wL0SM2I0oGZPYCFF4uEkNWGK6BCUChVLYhWJgBh+1iWm81Q81VZk1XZFF3dbbWWhRC/tBC2iIBti92Z3d1WDNWbagXf4pJJvQ1bUQqBQpkWuhEFghrL8IhsRIxUxbDKbltKrlNKt1BWvVBE24TjS80kq4kkL4WnAbW3JFyzlA17Rl23a9P/2D1zetHHqtW/q8WxnKDiTQN/VAFA58/0xAi0iJMLSVEAVayAj+mo/JlUjAKwkMDB1A+7PNFBBObTJi4oRP2IVgWAZqqAaVlGBStV2ouZ8i7ZEN45WqeCyvqZlimZ+cuF2dtVldjd1p+FXdNaSsqQamPB+bUSOtECMLizDlXV6nbd4i6cZudAzFYBLqzNpQ0Na/WSlvSwRvFdvupQOzNVd0PVe0HV81XTd208PniNN6hRM5zeKBqVe9nVMkAExI1LeHoIiNnNBJAVdwdSKIAIlDZCICCZ34GKt9+8D9CCtiwkBi0mMMJEXB0h7vSZtBNhtPAwxfqDAbPixd0Z448qdiKeHLslkSXuFpzAa3AVqvAV6tUKN0Yv8wC/sLHDaMHd7hbyGMy3CFVKhObbXev1lDU+JeJs6DPCjbdLVl8TVTd61ieUVfKICCLAbmLg7jYc4v+rAYkCAQkWhcI+oYv6Wi9kAJyS3M0rGPg3SUjSgiirhYPp4viMsUUciFYSAGxDgsPzrOpd1hkoswRZ6neOqVq/Anr7GfeaZnyxIoSFao1bWaZwnSrTmGFDlWZD3adSIsDduWp22MXkg9vgAkGamGa9AGbOiFWEgFT8jaTsDOVnblDvLOJZblWSZTM71lXHa7MMtDK4aOXw7mlebiMH6CJ4CTl0aCx03EQ/tXUUAiZobIYaAFRrUIO0YvyfwItfqzM8Zm3fn/M811Jj2eL2dShVqAsFDDxsBQ6E77Cwr7BcNAUqMoTg9TvaQZFmKt54Ca57aIFmjBhnDoBmiJEYAWaOI0zk/rFbZxG9HcLG9glmqTICCbh3AAhljIm/MjpiJWlyJGKSQ+uyWOqXGd5TwA3yiOYlzWZZOeruuiruZg6cyGgpeGaRni7M+G30xBRNlB2AFhWE4c7d55OA6k2NAh2ANWvItVzDOYVAXe49s+GcCkBVX4zGCoioOKhvwZ62hhBkOW6rPxEVspCxz5J6+pnyEda7eoxmhZhmfAhm+4GpbTkbnOlbVxC9ztn23oBqyToPI27/I+zbqxPq3zhmCg6FLQhEoY/2zrDaU1PI1YHtvGLtvwHQMpDulc1mXzzT+4PaoruAKVzmxgRgKZdumX3o/biQiHDFxwHRCBG5k3ThnR0R2N2cvQQTwBkdyRMZlMyW354giH1Fxu5uNO2IRM4AUXnEYeXcou5NWnRJsOS6wO7pVeORb8OYumYZF5rqz80Z+6kBGV7EJConGf1azOgr11KG/Zoq0ggz2ktEIRXVlohKjq07oUXYdwKAa8KQVJiIQVh7Kw8zaOtjKPFtfGnmU9mIPHLlMwSFsqBrM2XQK5I6oDR3DNjlPQjukF/+yXZryVsJjKRMSOkQgf0DMN9CoB6dS93DfEg+1HfEyJEIWGvUhOVf8ilBnxV5AGhs2FT9AEWrgFVhCGrHk5Gb8s/sFdhTIoHnlrHvmVZphrtMAR6BZylssRp/zu/dlCQ8KGY7CFY3CMaAiHeYByeihvdohRZeu+K7xCuEFVLGzyVF1VaHRGLWdv97agTdAEM/cbND8NJLYyJh5bPYBz8FXX8G3boIIueC0zeT3wBPfle9/sQdf3z3av+KpmbpozT9QIO4vIs1IrjVwPPJYIk5mI9LjIgPUdgO30iASFXNgFXOBpWsAFWTgFU1g5F6TxtuB1Ih9Oq7gV7fEV7wmW1WvK6P51EWs9Q9osll2HidqxAgoHauiVaWiGvbAGZuE+74t2bL9yac//0WrfLM2qdiz/n6ybws+SC20IhlmwoPg28+x05XI3x7Nj7DZfdzkHAylGUzONLqDCw6Oi9yuwAitYaXx3Aiiwgn3nbCyge85eiVeghWhiZkoM3JCoTN2hCCKSxE+EIpJYD24aEAgsTE7Q+/Wgif1wpsgXhfKLvEcbhlJocV5YOZbzkbLB8Q0LGnx6LHrGWcxqPWqXm5ibOdlifXqgSWBU64SyBpndhhrJvu4ret+EWaU31ZLt/d3XQlwNVmf4wkTWhQqCb0ng5iJGw8P2ILJL7D2gAzeP8+pnd3afc7LfZfU8X7pfe7bP4u8P/7ineywY9PJHf70XNLAyosf1wI2g/0T5ukRr2kxmvsiFjMgiYqKQwUBOaFj7BQhOnEARnMRpEqhWw3Jp0oTJFrOIzpgJE/YrmLBiwYJpxFjxY8VjIo8tW8bMGcpo0ahZs5ZtG7dv4cKtmzePHk6c9nbypOfuJzt26MqNK2f06Lik7MglNTounMyo38qJ6wYOXLes3b5l3eb169dsYrFhu2aNGrVoKJ2JrPiLF9y4unTZqjsXF6xVoTRBItjpL+BOlwZXoqToMGJFiQwZWmxoDx06eeTs0WNZz5w2Y+Zk1gzmM5XQoaWQLk16yRIsWKywbm1ltRUnsl8/Ua36SW3burFcOsQHFJ9JfA6dEVjlzBniZwadMf8I6lWugZwO+Z5kfdIhg8QPHbS+fFLyQ6BEkb8OSiBCUecNHjx//tOsiszUtrWI0aOwkRFVsrz2MqZM69SUEz07EYhTUEIRJeA66AxllIPoJDiPUBE+aJRQTY0jDlbirLPgOjN9MyKJ3HhVlllpqeXMMseA9AuMb/HSC41x2TjXXLfYsssueKXiySaafBKYYIJdUgmShiV2mGOKMfaYZJVdltlmnY3x2RZddCEaFaZJ0SVqqrnWmphj7mYbF1ycSd1wfPBRRXDTgdecctZlB91zwlVx3iGDDHKIKMgRZ90g4M1ZxSGvgDLMK9RNop5AotDinkAErXdKLMJIFA1Jx8h5+EtFJs23TTg3HXigTTZdWI6FSSUlYYUfEgVhhAk2CCs6DN4KIVUbctiNOOLE5JVYZp2lVkQRuQiSRTHGSCO00cZF4y446nILjz6G4omQRAI2GGGFKckkY+QyFpllc6Sr2RhtuDvGlVlyOe9oYcJm5mq6vXYmv2kGBAAh+QQAZAAAACwAAAAAQAEAAYfmvJ3bsJDUqYrSpYfOpYfQo4XOoYTLoYTHoYXMnn/JnYDHnYHFnYDFmn7DnH/DmX3Amn7Dl3fAl3q/lnq+lnu+lne9k3W7lXq7lHa7kXa7jm24k3i3kXW4j3W0j3S3jXe4jnC1jXCyjXO3jG61i3O4iGS0i2+ziGixinGxiWmxh2qwhGGuiW+uiGmuhWuthWStg2uuhGGtgWGph26phWqohGipg2aqgmSmgmepgWepgF6mgGWjgGanf2Oof1ykf2akfl+gfmWqelemfF+lfF6jfGKkfFqjeVyie2Oielyhd1ufe2Ofe2CfeGGfel2fd1qfdmCedV+fdVmec1ScemGceF+ceVycd12bdl6bdVmddF6dc12bdF+cc12adF2cc1icclybclybcVuacVubcGCacFqbcVWbb06ZdlyZdFqVdl6Yc1qWc1qXclqXcliXcVWUcViZcFqYb12Zb1mYb1mYcFWVcFiVb1SSb1aYbliXbliYblaXbVeYbVGVbVeVbVKSblSObVaaakaWa1GVa1KUa1SUakySa1SSaVOSak+SaEuPa1SOaFKOak6OaE2KaVOLaE2TZUOPZUyOZUuMZU6MZEmJZU2FZE6IZEmOYUKJYUeFYUqFYUWKXj6EXkWIWDeAY1CAX0h/XUV/W0R/W0B6W0R8WEF9Vzt2V0F6VDp3VDx1VDx4UDR0UThyUjtxTjZsTztySi9sSjJpSTNkSTZpRS1rPyJhQy9gPiZaQjFYPStYOyhROytWOCNSNyVNNydUMhxOMyFMMiFMLxtJMyJIMSBJLxxILBhFMSFELR1ALyE/LB5BKhxCKRY8KRo4KBtCIg46IxI2JBY2Hg4wIRUvHQ8vGwsoGQ0wEwUlFAchFAggEAQcEgcbEAYbDgQbCQEWDwUUDAMPCwIRCgIKCgEICgIQCQEJCQEHCQESBwAMBwEJCAEJBgAHCAEGBwAGBgEEBgAEBQAQAgALAQAHAwAHAAAEAwIEBAADAgAEAAADAAABAgACAQAAAQABAAAAAAAI/wDPGDozRckJAiOSTJlipI+ZPorORPQxpVKfJ1P6JJnE6U2iPgR9iDQiRIgOGTFi+DBixIcOHUZesowJqNcwY82sycMWzZixZL6EzcqycKESKWbOEJyy1FDSKU+SPJm6kqVUKVNnamVoJGtXI1xFVlXS0kdJsWZ9rFD5sq2OGDqmnDqVqm6rVaJEccIEqRGgv27SZHECBEcLGy1CcMBQ4cECCQ0OFBAgIEAAypgxX75cQEEDAwMe5LAEC9u3dN++efO2bVu2bM+eKUPGK1cuZduqwUKFStm8eebECR83Lly4dMbDefsWDhy45uC6re7GrXo36tW5Xd9+Xfvz5OOowf969CiQmh8igrBgwSMIG02cWs06tk1eOnnyWrt+/VppUSMSKACVGVOYgVQfkSxFoBREvJGJIX2Q4lEdUwghkoVmyaBhVSy5dBJMSkyhAxCyDCNMMjphM41PxfgSTC9vPCGFEkoMccQT/mG0EEFPsCRjVFpd9cQRRPgokCFFLdSjEYZEYogiPaqUlg5iUbmhSSus4JIML6UEkyas1KXKXaaQotdeffl1hxuDFYFDDzekoBgGEjzQmAIHDEDZZZlpZpllAhggaAELzLAJNNZMI82iyyzzjDPMEPPLpLzUhswvsIACCirX/GZOcMQVl5xx3hj3HTjeSEddd9lpt52rq3r/89w46dSaTja5gBJIIF4sQcUSOMxAQxBMJDKKK7DsYs19+W2jTTat9XfGU1OkMEAKT7wRYxJ9VJLJGRwSSKAhhpyiiENltaThhxwuZARKMcgw0gstiHJTM80kc0w0whRDTDC+DANJEizVaESIXCm5JIdJEDwTRn04pCRY/iWplVJPcPjSuiLJeyGWGnqpw1ou/RFmKyi3osoppIyiF198JQIIm1YwkQQQNsjJQQUSWFBBAwqA1mefgPJ5mQELPODABYHMIowvtlVaWy60VG01LLRoqikq3dCTz6ejJicrqs6del103KTaKqzYZdfNrJ+CjdoypewKhyWAVHEFDygM/3uIJ6q4Mt826TirzbP8kUuuUZE9kcUXU5lhBrlKgTTFjEMorokUMYl0koZrxStWVz6kxKVYMbTAhk3QNOMLKrsYc0wxwexyTCsKScFgwZx31fvoWnW4kowLYRV88CMxBe5ILbXlIZUlWRjDChvLIETzRryQBCmvdN+9yiy7vBeafr2RhhVZWIGznBlYAEIGEQAt9AB6Dk3AnptdtsAFF0CAQiClQAUsBkhA3vCmFKXQlBoC8QhQ0EId+cgHccL2nLGNDVWpOhurrMMNbWhnbdWRVTjG8alQIScd16DFI/AgCk9gAg5XYMIMZvCDNFDCFK5wRS6icY1sHM6HrunDG/8iphRDvEAALTBDtp40CEMMwkBKJEKBjjAErHRCCi/YWEqmd4IseQwlHmue51LQAh7gYhj76okxblKMpw0DF1YwysaE1yEqvYRDwQMCEIYwhDsKb0l1XMlKrOSSslSJSh2Tlwyy5DyRxCsFL0jEK2QRi0mibGVl8gQn9LIJTDQiEWu6QxoIkzPFjAAEPmvAAgxAgFZSpn4CQAACKMACJ6AAf5RZAAUoAAEI/OASBkQFAhGoNU3tqoG+yQc9RCW2UiWnbNHhzqtgBcJWvQ1u5iAOO9RRK+UwAxWhMBMnFlEFYPXtB2PYhCpWgbVmvEYbhouYIhQRiXme4QEMMINUnlD/hy9E7Ilf4JzupDAEJbxACoZwyfTWkqUsie55VfHBumIAghSwoBXHGAY01Dg72gUDGMcAxOWOcBIpucUteAwewfjIxyqlNCaI9Nxb2PKhz31uBV+Ei01nmoIUJOEUsZCFLGrxiktikhRm0iRf/ALKUe6glHLyGWQOQFUC0O9+AjiACv7AvV544gAE+BNlCHAAClAGASJQwyWGmcBi6ioQmqLGPOpRD2ZSEJrO4Y41p1lN7YxthHEzRz3mQY953OdWviiFKFThCUaggQc1EIEIaIAEPWzCFKNAhS6sAS1vaCNi9axYCJCYBTP8oQ9IqYQiAtq7oxghBieIQSRQ0tCG/25RZBvzkJdkMIIUoKARwGhG645xDGMEgxht7AU0TiEVIwwhJRLV0Lr8mC7kfU6QMbXuHVfygkJGV7pbOl1aNoSWkUDyBolgRS3W+z2jmuK9LduLJ/sCiMH0oAU9TQEIdiYBByxAlmDNEwEk4IhUsMIWnniAAAgAgD8VDVALvkAQAnGJULgVFGpYICiy8Zt6jAqveZWONz4IQr1m53BrEyEJA0tXwtaDHfPAjzWytolQWMIOM6gBCzzQtyb4gRKjCAUskgGtbZzLSRJRSg8O8IAnEOEhk6jDKSoxuTMghXM6GAFsF9JFLjKUSydtC5dkkEXektEJZ2wGv4QhDGPQTv8YwYCGLIqQhD5CUqLx4hgiqdQhQ56UJXzWikz3DBfhfU5eFkIkhuAVRgy9NgbaA+p6hdpeVYxJFanArFI3YYlF3MG+L3iBnN7HM3wygKpgXQAIjlCJU2ThAAsWAABm7eAAzLrBlSEABHgAh0toqoGPUAMV1IAKb6RjriCGpqq60zZmW6c7KEZxdma14rjRla70YEeL57GNxFrCEpBgQg1oQAPJssAFSDjEKBB4i2hsQ2ILedK5gMCAHhiiE2aYRCVUe2+JDIS3XTyBDiIxMtCxJV0u8RCYiaBHILwgBkCwQi2gsVE2FqMYxoBzM4aBBifo4AUj0IAgyws84UX0jjL/aQlYLrcS/7RkCkjiM0Q9hxKJUol6XzakvLRkBCBowhbrrYUsvKcyS79XfJ0E98zUhxj8Lqa/CDhAAxiQAKEtmAE+g/WehiaAAbSylQhwQC8h8IElPCKAvNHaL34z13CoQx2hMhUGWSXi1djd7qqpO3akc5p0mIOb6VDHNkVVK+KIA+6FK0bdGAGIRqCBBpEVOw6YoO5VIGsXO1KK5slVAQy8wRBProQm5kmgM7x2BCfo4loi8dq1jCwlKofplrwEhJc4HCZOUAU0phGNYQzj4hj3/TGgEe63nEADyBu5oGEyE4giUiucG0lVyCUFHUghJGIGnUNVgtMNhWzMpTuB/w+UkAVS2AIXQqW0yi4J31FoktOQAAQcssAEINygBSYAAZ38+4AHKKDqBXBVrQRLXZcZ9HOAXkcACLAAuiR2HmB2oYAKDQQK0tBh9XAqcmdirTEd13F3dXdihwNPy1Er+KEO8jAPgGcrxkFCb2cOymENt8BADNQIPLAeFzBZSOAFN9Q9AjFPiqMI3nIDEjAEBiIFqiU5MsA5K3ACI5AlqXcCSmAIZHZb8lJHdhQyI9JwWWQEVgAJw6dGPhGGvocNqlB/N8CEJSFo2FVegZZwFPFxD1cVOlAkRNAWNwATQyBFpidd8bJQjKRI1MMl0wMXYARdPWcGqSB0Qzd0KYMyq/9gdC0jCqHAaX5xPoRBAztGJxBQAY3xAA0AgHgygJhBP69EiqXYSgYgGY+xSx4wYRpWDd8wV/mANtyANuDQKtHiQdywgayhH9vQiz+UDT1UZHf3HLYyK6hxGuMwD+yQDt2QGtiQDAkUCHgQCGxAbjXIAkiQBn6wCa2AMEkiEFZWASDwBAF1OUehBD7AhE/YjitQCR+nA7HFMTLlhjDRMEngBHcIFneACxRXXGEYhscwDbhQBQ43AiNgFs3HPDN3OihVSD1iezYSEzfAJTdwh/v4FmOWZ7W1IX7YUGOWJVoWLyzxB7EQVN6Tko74iJhkCi9TPm+QBUVQAybgARiAAaj/VAER4In/pwChGIB6goAH2HUJeIABiDQPQAEZ8AEfsAEzAArYUCqCdQ3VcThjQ2LO8hrXsJVauZXVsJXXUA1iOZZiCZZg+U7PmA5lsxyp0XfEER3RogugQB6AsAhMwARogAMsUANIMAaaoBVksRJEcARSkAIRcAPtwhDH94Qhl3qiBiEFdUdwYY9owRJO4AQNk0UUkQWvMFwBGYb4Ag1scJAJSXLMY4VXKDIywCQR4SNHQCQ1pQN5GJvhBTqq133al2eLtIQnUAJrsZo+8ATcQ2kp+T2u4IiXlklL5RcyaQMqEAIgAJ0WYAF10n8MoEoHMChCuZ3b2XWpmDQZ0AGx/yQCqIAM25AarQFPadMN4dANvugaYGkN1nAN8mkNYimfZEkN+nmf9GmWQMSezeGebNlNzrEa3GBY0oAKDLQInnSXVkADM4AES9A8dvQSRKAER2AEEQACPkAEPcI5x6cBqSeiGiCivXUEnfCaR6AS3mdHJZePDZMCfPYEonAMzQCQn9kT02AJNnADKlCanlOPFOpH0VWhwZkxPgAEzsVHRTIEZJYCGAkT0eVFTohTgfgSXpRIvJklENVqryB0k7SIRJcyRfWImCVf8ZcGSXB/KWACJgCdGcAzElBq8lMAdnqnQMmdAxCAr0RWC+AAY4UAM4AKxBAtr7GB4fCewhiW1P+wKIvyDI66KM7gqJAKqZEqDY8iDdTwldegDSLWgapxHM1hHN0wWPKAK3NJHpwAB3jJAyKAA991JSwhRSPQAFkkpTIQohZQoryKepA0CWZwh7+pSB4jFtdjBA0DBERgAmvBEnewCzeKo2EYDQMpCzvgowl5Rw6pRfHioh4CaB7CPHvkFmQmaqGWeinxArXVkbhZpTa3SCNaAiUQcC/wBpAwCq2QfvpanGFaVCqDWaTgQo0QI/bXdG+6GJzYXw7gAHhyAAkAgHmqpxCGGQwWAAqIABAwA6UQDNPAH+mpH4hDn9XQqJLKDCZrss6wDM6Qsivbsi7bKI6yqWHZqXbnHMj/YRzMUSvblg7f9AiXwAh9QRhMQANvYSVgJgNKQAQM0gAVkKvyqAEroAHTyatMKKInkAJG+CHdFxNV2BJpaBVEQAQlegLISiLRmgw+AZDTIFzAwATOSbaIxCUUCkZ7FqQt0a0KNSJJIGahFmoykAIn8AIo8XB59pGHtki56oTx8oQlKq9M2AJAAAj3mq9CNQuzoK+UpoiMuH6pMAqa4Ah/kAXJihgHe5MYQAESUCcL8H8PawB4aooIWGuvRGtZ1Usb8AGPoAsde6j7oZX3WQ2SCikna7Iq6wzJsAzM4LIrC7Msq6ny2alvcx3GcVi2cm31gB/YkAs+CwncmwZAwAQx/xVR6Mg5INAACbmE8sqrvCqv8rqEKZAJPvBwRgteQToWd8slQOAEWcAJNxqtxEVcrYNGTMACITAC5CqlWrSaCJdwb5GkPacDdwgE4bVFggtm2bdFK5ACV1qH8UK4cCG4MQC4IzCvjtkCWcCgqjALuLDCtwALl3u5/tqIrrAKqGAKqmAKnmAJjXAHTsYEhrFjGyABEIABF8AzU7cAB4AnrmtVehKxpHiAVkUABSAoBpAASdwAE5ABvIQCl9ALptGWzIIfzfIaiRINZtyy0qAoaTwNbNzGZMnGZiwNnHWozBLGYvwbhfUbYjwNmQIK4HYHSvohW8EUU/ECCqABI8O+6v+rvuybwQIhvzOFtzbFhilxh+gDCCD1v5q8thoFCSIAnWAGaSa1MXvWZzDxcXcIwReZwE/aU7cFafmVAn0oailQrn1Ey10GSaIWogh5tSnwBi2jCreARsPgC7QwQLXQC7hAuUSXQ8e5Ci6pCZPwB2ngVJgoAjfJAQhbJw3QAPiExGBlVXe6nV+Hp1NMxVf8ALe7ASyQu9PQln33DafqGmOpKC0bx4vSxmrMxmLZxtLgDJDKqZ0aDvZhK/hReLRCgmKMqrsCCHUgRg+TJCehAQbQm4t80ex7tTJAcDq1RQ4JRvRbOjFgyYNRC/+btsRlxsLQDK7gAdB5wOEae4BkRzH/IcuDm2d9qyF9G2o9xdM9taVbajpKyJuxFcKAO6Ia4KsvMAlIZQqtoFwqAjVVYxO3EKb72grfwzKcAAmJsMMyaRgoIAJuqhhSZSfcDM7Z6bp2KpSt9Lp76rqCAlYY6wEi8AEzIAe0EA3wfBr2eZ+NOg3OgC/N8LKTuqlkObKYmrLLoAyTWg3zOdDToWJhA1i18g3IgGFqAAenyRJS8B8xcQKHfNEYTcI9dTmhFsni9TypjRIjki07wAlo5BPJgLZptEa7QAMmoGVy23wzoWeAxrd8OMuiPNzpOsuQlHqhQ9Tz6I6/2VOpVwJUG7id4AmRuApQbQ3RQAy5oAs3egve/z1p6XeSRZUKAYsJmOAIn3aJLbDeb/o+PjOddIrESqzWCNjW5nyncX0AsuQAG0ACKMACH8ADpTAM2IANr0GW9kkNvBfY+GLGcRwN0gDhEj4NJPvPKtso0iDQnaUcqVKMzjFC48AOtGINsGAeepSHg8x8TWgBDRABUivajTuvqKdlU0BmdPt8RhC2fYQWLzEEUvEGTnAHIOVmycAMydAMbMwMvnAMXhACKRAiLicSSiEF9kgECSddWF49edYlW2RTuwnUtiVd7BhbttWO0O24J0AEAesJnhBkqHALSG7g04AMxdAMwpAL3n0LQbdeQRUL/yoKpLDVi/AG6oMDO1AD+P9VuovBGEbczfNtp0xMP/eN34KyYFTFABKQASQAAWHXzroQDX2tn5wVlrzn4Kb+4BFuxrwXvJP6zytLDZz1lZ2lGne3GslhWHD3DdtADKAwIi3lIzX+LuyoAS3+4jC+yKjnSF6SUhh6PCKhtE9gBl9gBXDuZshQ5DkRDc7AC8ewCR4goz7Q2ccjexDFteuC5Qu1he9SwaaDEk/IRU+oSAH3hE6YeqhXtRowrxksF5wAH0glCq4A59OADa0RlszwC72gC7eAC3o+VJNWpqiQCqcgCp70aUxAGDdAL3ISAhyvzWXNk2lN35Kep5QuKF93AOD8ABYrSwhwAWowC84wDX3/PZ/ZoM9nDCnOoOptXMYum+oLnvOOTfPniZ6rkRq2osf28Q3ZwAs3oKQS3BUZowS5OqIjEAEJ4OK7euy9GrjmPocqhY80IiPQhxFOMArFVQzXji+lHgzBAAsskAI7Xl1yKGYbQwTfV1INlXqQdMuE22XwztzInQK99QIZ79wz3luCn9T3ngLlwgmcQN2k8F6wM5AErx/YLQy7sAsKXwt6Dt6v4ArdQ95bPTOCYYaiZgJt2vEY4DPxTVUi39ZB6XV4ajR92mAWywCydAFU4ArGIPPYIJ/TEPT4WQ2lfuqnLthHHg350kbEgLIrGxvP0CjJgAySMimLTQzEUBuZkoVK/woVKyEDVhuiGvCwGuDiMS7aCKkB3UUlRXI8YTurQ4BH4Y6sDeJ7P3HkOcF7xpD5RdACNWU6AOFDhxEjAnXokEFERoyFMVYwlLHixIkYMU7IwPjiBUOHEB2uADlR5IgUI0yQTJHihUqVI0yW1HACZYtKpzh5InVK5ylVr24dm2bt2jai27BNS+ZL1y1cuG7VgipLVi1Zr06R4gQp0Z83WZwA6fGixdgUJkKAyGDBQgUJEh40UHDAgIECdecaGJBXLwECAQQcqIBhgQABAAz7XfBggYMLQVAFa8aMWTFixH5d/sVLcy7OuWh9Bv0Z1mhYqFCVKmU6tWlUpGGF7rxsGf8yYrRK0do10MiTKT58FPxYQrjwCAVKaNBwPLly5CJPPNQ9ZYqUIwSBHARCkAgRgk+eEARvxEktaMeYRZs2rXwzY7qAYdLoUIdBI7oJ+lgo46CMF/pjbKyIo/806m+/hzD66KGVWDKhhZVeuKEFG3q4wQgZypLQhhfUMglCTUgB0RRTdEpFFVNWmWWYoLLZJhsXs7lmGmd+2WWXW2aZpapWZGnFRE+yagQQOLzaoYYWGkwhhBA4wACDwNh6wIEFDqBSLgMI0EsAAgiTawAFoNAkFlyOOQUBBg5QYIEF0mxggg48uGCDH+wY5ZZceCEmGWekqaYa2Zxx5plnpJEGGWX/lgF0UGr6rOaaa1zUhihvJg0nnXTksXQeddSZZ556Ot2Gs2J2AW+K75QQaCGQhluhhAgiEA65WJcrYSKQKopuOiWSsO46HYAgYr7vCprvPiBSAQYYY5phdphjgAkGl15SueGggxiqT4n69ENoQAL1a4gh3wK84YYC8QtXookI1KikJENICQQQTDBhJRA4mDeFFtSa1wUmOCFllBBJTMUUVVy5RZhorGHYUUcZroaZX5ai6pVWXrF4FVNG4QQTSBq5wysgbGjB3LLOarLJCiZwS00FXparAL4GwJIuAR44QkxgoIEGkwMQqJJKNgEDgYQPPoACFWiw+eYbeTqdx1Kp/+Whummrm04nnHHGqVTqdMYxJ2xzNt2UHnbUWefseupJ55dchOGFloFMlQ4/jk4QbtUSLEgg1uFkFe45XBf6jaAjthsCIXOLPeg3g+YTKIY7YpnlFqZwmWoWWFzBpRYrVjooJRl8UEIKbYndT4bFDWro2v8ERNC5iZCTt3YmnWxLMQS25IsvwggDIADhCahBk1E8ERhEEg1eBeGd07OG0UX7dEaYXXKsSioeTSTFE088BiQNJ4rYAYgij1ySA/WZvEACCBx4q4EpqyTASgMUeEGRWno5BhpPFmBAA+aCJiohYE0vswAJSJCBC+RAFMPYBtU6pQ1udENr47BUODS4wf+mcU2DW/sgBsUWNrKJQxybMgfVlkGLYBiDFrD4zamMUJGHSCRvIGlVBAA3q+GsiyP9iYFviDCExB2kXAuBnEB8gxBu6YAIpDjRKi52CoOhZha4aMQNBqSDGKQgBuDZz3wIlBIyxqt2yOEXCDQwAjRGwAACEF4chWcYOtbRjneko/AE4AQQbQJ5IMpJwQ72ClncohfNQA81CLVIaUSjGdZ7iiyw94pVcG9jWUlEV5zgBCbsgGQqMIuSPKA+DFCgLW5pAAPmRyW8FOABI3DBJpiSBr4cgAB2KSACEGAANCmgARkwSQc2MANQ8CIbVMuGNijoDa2ZY4Nck9ozwQbCrY3/kGzqOJs4MDiParzNGLcojYVUZRGZjEAkyEGnBl6VnB2y6gTs2ghLRuKSNZKxXbKbyAhAEAJAWGITofAeJizBCUs84hKvwEMPslMtI2IEI+gaHUKsFZEaztMlJMFhSCzwqghsVC1qqcBHR6CWDKhPSRaQl5JCYIIUrGWfLsBE9zThvYGZyGCELGQvlgUoZiADGcxwBrOMEQwbOWUWhMyYwVKBFUyALA1uEBkOaMACqrLALPdKGZQcoMqgHaAAaFoAB3iwgd8JYAAFOCsvq0SX+73sARI4wPsQsAE10GIajGLRN7QGDr72lVIbfGYzt1ZNcZBjbOLoWqh+cQxdjAYV/w1oQAISUJe6RFayCTCAZDmqw+N0djh5e+dEVPKCEfzurAnwpQU04EUdLAifbKxABazQCEtYAhOcSIQjIIGJS4SiF7XIog6qRZCy1CsGOhCJDJwjkTXmEznmLAkIzIlP58TkovLSp3RNAEqWvqCcKWWpS1MwhA+R4rY0heJSRbQKQlZOFy08RjB0wZllHWOou3BPL26UI4tdrBVL/V6QEhGyr0i1BTRowcnOQkrcveVMVSqAWg9AGD0KTy8RhjCGX6Ymv+hSlxCYASqEgQ0XbcNSfeWgXjMYWKltzVJjM8fWqKaNzDTDRrNwhSjYqUMNqJaNaFRLOpfTTneKJCUrQf+nS845XXXNM58jxcAOGrFbTHhCEpNwxCYsEQpgHOMVX7nBkevlxf6Yk5zTlYmQm7OCktCTns5Bc5Kf+2PpluSjH5WuSRTQ0RQk4UPf08RNBCYiT4joYLDAES0MGQz9am4WuxiGMJSiC10M48ZVwZiOUnGK70HiY3dIwxXIZwMbGCnBoVTS7aAE2TPx8kpmpXAcKRvhCL+xd7XsS/AEgAAIQECXMyjFMbZxNb0Sm9ga9JrUvmEpTEnNG8vgRTS+iblNYMIHMehxclYw5zSvUch4Y6Pfemjk0cpOyWh+p3dH0pwTrKUFU66tJhJBCExg4hGi0EUzcJEIIJQxBa3diA7/ptvc2ZlzjT8+95Nnd050WuDHPe5oj9fy0ZCq5VWxje1bIjACKVQioOfFCRSRZzBXjKZylavRjVDhClfQYim3oDRRLTfJiv33FKLgRMeCBFVOmo/UZGFpqpkUW1RC9mUKIMwAfmfhs84arYS5NQGCp0cCLCADC9AlC0IhbGN33etNK0qLYASjnyZDF7PoxSgAsYmWjoCjDYe7OlWbbTUL+aKvfbgG8uySlJCEjSeQM0kqwQlR5EQTmqi3KG4DjWGoYiwb6qiF/D53wI8Ah2lGdz5LkNGMUncktgK8BjAykYhgXiQdla4ZBs+Jw98EJzvhycUkaTmm1OjGpQgFKEoB/4tcxFwYlu4cVDDWI1OQIhSY0HIj4IAGJgABB+ZzAfpGiQIRjFJlEmDLVtW0VrqgNS9On/UAq7SmA76sAQ6gQAY88IFhhmIX0GBWM45hX0lrhtKcAefmWIOaUPQfNa0xpKLChUuwhFEAgbnjm3TKu7pLsotCJ897Mja6KH+Lrua6O+RIgUbAuVNoBUJwhJsIBVGAhWaYhluwAhuQAYmbAiMwGYOTQDgLvThDs86jLgbMNnPCLpeoHTUCgQewgA4wgT2YhJmqhEC7CeUZEVWQvVmoBdrThV3ohV1witGghc7QBV5gD/0KvljoL+IjBZxrKlCzAiAYnxuIPnohARagPv/rcxLcgYAHUKUDSgArsYvuA7+76KqjOzoAooAO6IA48QAeCIRROA1UaJ79Q43U6L/+24RG1DJIsIRL6K1ScAW06wWnWIVRCIWWsoDj6CgeS6fPEsVRZJUAMUV1yyfZeYGKwpvn+Kwew4AsuApTEIU/eIJEKDRRQIVdmIZhwIQjUacKgJCTMQHmGoHRKSc0irsHjEAHXKMV2Ds8Q6kRCAF9osbYShkM2Cfsw4AWoLcqK8JACzkqir2LwRHaq71e0C9KY8f5EgZj8AXLCb6KsZhNg6LusYSds4IssIJOIpkjaQE1rD5SIiVTihLIggvJshI6BL9ak7CuQpOvOoAHyID/DbDIC/gAGsACPMADOIADNVADNECDKsCCKmCCJUCCH+ABHMCBGpiqqqIqGviBKlgEWfCyRhyFTiCt0OsxUqSVVtk8vWGVhzguLgoQVPS8GpIIHBqOkdonJ1AFUkgFTyCEW0QexeNFaJCFGtAnlAq6s4CXHwMJl2gXvbPAJDsBFSgnmTjAkAIBFUipBcsADLAAfMEABiolCsjG2LoABoAACWgBQLgtUqiEInS9nEjCVjDHc0RHXLCRduw9X4hCx8SFSqwF/hq+VNDMqOw0IQEETQICM2wBlwzIUNonrFqZtniVt1CAOcwszJqLhryL2ewqPDyABaCAC9DNC8hNEYDJ/+rrAAUKARKoPg8wzlGySIvkgA0wThSgARxghFHABEZ4BVyYBNIaAeVgDoJbSwgUiY1wqAH5DwoMCXzqiOeYiH0KgR2AolYghRzwMySUhaXpBSaoRicxAeoTASU5CXdxlwV5CTIrLpYyC3zxACUBgQ5YKVDCkLEISBWgAReoARjYgRygEIUCggwFgk4qgh74AkeoBHA0zHHUCSVcQhypHNrDhfnqjFzYBWCoTFPQL1Q4uUl6BVZQzEr6wk34mEZYBALr0BvYAQM7ElRbkgyYy5BaNQaIC4W8i4asNcqaTbZSqzRJjAtgIAjIzQvwMIgMmt6BOr7wMA8DMTwQhVqYBv9ccIOSSQF2G4EEOze+o8A5HS14KiOWIqMTSAE9tSeWeJAR4AAPwIFRUMKpxAnvERFX0K9QCIIdaIEQaAHywYEdKJcLVagkcAIr+Ip9zIIs4I03MIMscIM3eIM7uIM/GLB5IwRCSIRWbYREaIRYjVVUTdU7+Mw6INUv6NR+ZAIagIEc+NDBI8wRVZ4SVcz2mgVaSFHLmS8W1QXJxAVVyIEf8ARVsFaEeQrMvBiLMREw9JgBg6okAIIicL4aiD7uopez6AAkTYtVg4vWnEPMglLK4ot5fVIsOQDsk4A1wQst6SUAYgAHgADdVE7j9E2qmgEWmIEggINNUFSe2YVHeM7/s6DGIxsLFVAJBymXjS0Xa7GWHugBIiKCIyBZJVAC75CCLzCDOpCCJ0hZM4BZM3iDPniDP+gDQ8BZUoVVqSwRQAqYQnsF/gGGWmCFU6gEQ9CESsCyVjUEVAWEO3gDqBLVrrACTRUZDfWkUqOBrQ1IqqI+lVowJrkdDNDN3FyLlaEACug1BmAADJCCRBg8TyhMcURCgzlWSUpWHGlCO+EMXvgFmauFL2iAG3iCSuiRV2DC/ZIKnOLW4hOFH2mqz+THnhtSUxsLejGLUSKlC3DXd3VNO5zXWUs6p/OLpPOlBRDTCyABekEBF3DdGYBd2FXYGXhOHgiCIKCBIKgCNggE/1CABfzCkVLghMJcvZy7rZzz2eQFpJzLucNz3ud13rm9CdY7vBCtBEdwhEZwhFb9A1t8gi9IA0z4L1XAiSMUBYMZWkzAAyeogSUJJc2dyzghWN7kzb+UAAeAn/fBX/x9H7YFIPxlWwAW4K1SpQI2oCmZQ/rhnQnog0mYhJyTXpqiIrtdwteonL3ljF8gBl+4sVYwgY1TgSEgBVaIhVpoisvEEURb3B6ZYKYKkjdIgzTwiuajVFI713Q90PRZC9VkTXiVV/DTi6bLkrIyKzmKo7+4NQdggTSAxEZUvNUwRJZrL0S7IigMBl8wqlcwr+yFWhie3CRgAnIdUgQLSBGoPv+CpYDYmoA1ZuMm2U0szQC1VSVdsqXd0SUCMBMG0JKsGzlRGAVRcOL+u4QaEIENeB8q8R0ihiMjZuQ4mjo8guRIlmQ7moAPTYRA262ZGsfEzDQUvWDaE4ZHspFXSIUmkIAMGAIVyAAYkAJW6AUYnYr9whiMqaSNCRid+8wYFrUfOB8WuNjMVR/jZB9Tyh2jg80nDeJk3ot6lZk6vAvJuh8GmIA4pgASYAJP2B9gGIZhkL9t3uZjYJZpwC8ojMIaQQVROD43cFQH9WUHdVACTR/ccQC+8Ms3fIC3cot7PiWD1J0vjToCoIAGqWMlLrSAGYVRKAV07j8RcABdWuQ5muT/iJboib6jOZojwjCBmsWtrMAETa5bJexkFH0Ky9kFY4DHpXiFPpiSVU6MCJABVmAFRRgBTuic4JvlVqgkVaAiMAwSU3WDKwhjT6KBG7CBM0w1M7Y+ziW6CDDmBJ4LLFFmZb61ppvSzKKSxJiA+r2AGbCE/XGWY+BgXwiGPGEGs9OMs76MR1iERUiENACCBfG3dAXLHbQAunwAvmiAU7rnvQbgOU7kh3bkqauwqdu1RDAYUziN/0OFUHAAwKZoPGrkyJbsyR4e34kjPGaAIniDRhg8Hq23I0RMu800vGXMW2ghyZRCUuiBBhAAEmAACZjmTrAFQXAjC/gCVrAFzFnc/+FbhVrmGI+JVUBwAzToR+fzOQSzqhAQSDa8gOuLHyaNi5iRme6LapqB6ltyutiUsAeY5gsY2Bl4hFoYBmioDGVwhmXgk2oQFGpgb/a+BhagAZcsCxAIKZUhOn3F77eKrXZVUjcuJbY4pV7ra5dRk1SCH3zmRrXlABGggR1YhFGohf5pBp6Rv1vAAxoQAQ6oX/3dqjH18A8HcTPptd1kThGAXZbEAdulAjVgAzwIhEB4BIMChVBAjZJzjVlYBSbgACd4A8G8LSoD7QkGaanw5BTdhStWR1w4BUMQOBVAgQWYgAYwBFv4hClIAAtYgRFQgVOACqrANItp3C+sN/C5A/830NQiGJ/KbQFQqqqBFFu6BPB7NrroFj/qzovrvm7Z1G5e8qUH0E0I2AAcEIVjsIZhc5qnqYdrYodFpweFJWOxaJCxiFBSswGivgENJUPv0HRPdQJ+vAJNtYJP3yRyJVdezoEbOPUcsAFVj75W99UaqCoaQAI0gARDdI3RuAQ4oIIloIJd73WRhANAgHFJDMHUaB5kTVFpUUdoCYZvnr/4g/Zo4BmeSY9piAb0qHboYZhrn4ZgYIMLQIFEUARYvQkgx4kRYR7ZkyTSthyimkxbOIITiIRP6IQp2CgZsAVb6IQIuKwT6IM+IOFaiIXdvmlr/ULj/Rjh5kdNpWEbQDD/Mk7uUdJcsiVmtyDgNeE+mbnz6pZNu/jhv3iA9FNbFggCWrCGQ58Hc2AHffAHe9iHf4B5PGADNJjcMK4CkwxjcgUCHuD5IOB5nmeCoA9joWcCKij6or8CNHADOLADQJgyT/ts70meEUmFY8UYVVgF7TFhFEU0RLsRdQT7V04WZ5/waaf2bM92hrGGoAgKtXf7t1d7bJB7EmsYhymxFomeaYCFDWCBFGCFTjCE6TX39Ep3nNKeRDNtmJOWVBiBKfgEITiDWBAEQfgEKhcEAVKtCDiAXyKFqdCe7OFt7jn4yIVhqDrzyq0B0pRroWuStGUZOX9XOqeLO4fqZKaspkMr/17KfclSOsJYAN5sbASYAVighnTwlHzIB3uwB5jfB34IBDhwcUAAhEV4hEiccT8ekd52hdFOXBNuiu8H/6a4xLAH+2Qxf/Mn/2W3EShUdmBwQnmUFslUR7EWa282hmdHpGvHdrRve7iXe0cBiGwCBW4raLCgt4QKvYX7Fi6dvHTfvmUrtaSGjUq2MlXS5AkSJkycRJE6lUqVqlWtXslq2XIWLVq7dt3CZVORjE+xznxiJeiTrVgyZEQSZCEAETMuHpCqVculLJYtX7VahTLVKVKeMEFKBAjQmzRWnDDZgePGDRsuWqgw4dZEiBAcOGCoW2GCBAkPGvBVoODAAQMFBv8XGDB4AOLEigsIIOCYgOABASYLqHyAwWMEM2BRk1evXr58+vSFntmr10zTvXz5Ot0LGDDWrF0HCwbMNe7culHv0p06NW+auXQN76Vrl67kw3XdOs7rOXRev34RI4YsWTJnzJw5kyaNWrXw1a5dG5jt4MSJ6SDKkzfvPfz48ufPay+vFJwqWXKe6pTJ0yQiceJJSSeltNJLr7wCEy2+5FITLkJNYYstn3wiiBCCsBLLFCV0wkomEQzBCok2xSLLUy05NUtUrbSSSiuqZMUJV5A0AlYaWVjBBBA99JDWWiqowJZbIXgw11wYXDABXg/s1cBfgRUgGGGFKabYY40RUBn/AQBM9mVlAQywAAIOXBAEZ+nM89ln+dzyJpxxyjknnDHZeSeeeeoZUy59+vnnn9Hx8ox30ixz6DLjkUeeNtx0401636zn3pqf0XcppvHZt6lEE2WDDTbTRNNMM8PscskjcNxhhhI9fZKJJh4ReIoqMda6klSvuGLnLrRA+ImHFF6YoYVTCGHBABGAEAFfEcjQiS242OIULrXMcu0sCsaSSiqmkCIKjY2IC4gbaJDFAw47pEUDDS2wgAILLMAlFwcb1HvBBRRA4AC/ey0AmGBSEpCYAFZeeYBjDmzwgxxcOHBAA4AhfEAAAhjwgF4OaIbKM56Bpg+gIQf6XC6CQjcd/8rWIYOMMi0f+gzM3lEDXniLEnQQpOmFM84466XD5nvuUZop0fDZ16k322hzTTXUSAPzMsr8wksuMcGCSimgaB1IIGp4TUUQPMww9gwieODBDIHcCEgjkyii4Sf+eXSKSa2YcqCCsrAIC9+59HLLLDVFkkAktrAiRFE/CZLAAAoIEIABL0gxQgNDyHBCKtJO+1SKUZGIkree0AiJjeSiwUTYPJplQ7ssuJvCvGfXuwHt+UIgAQR7+ZXAAf8aQCViBhs2gGUesOHKMNNA0wgDCThvAMKVCTDAARjvC8EMpTxT6czdU7PoNdqILz434IDDUDg789xzz+asZ4468bMzP/898atD//zw0bP/e/nPsz896vGed8DjHfR4T2jyIcD2fINTE9mGQKxRDe8wIxnEmBpxqkYLvqECa1oDxSMewTWvqYEKJQwb2comghWycIVnkx3tNnA2s/GADXDAw404UQkj8IQVFupEJ0zCLVW4ooh8yxbfZHILX1VLCCXQyScQ58SfaCACOlhBBAQQAUUYogHPikAPbAGMoMTiRC3hm4JcJCOt0Gh0pqsCE8ZSBCCYpQY0sEEL8gi7uJgNhhvAFwX0whcoMeBfUqpSYQZTsAPYQBW3MAY2vrGNUTzMebxjzPQGRoAFXEAEF9hA2njhnvmRkpTucMc73oHKd8SDHev/KCUsYZnKWdKSlvawRzxqOct78LKW+LhHPOARj1vawx8K5EZMOni1UpQiFB/UWgijGYgQcq2a1qwmHvAABziwAQ3e/CYaqrCEH+CAXTQgW7zSGa88tsAELBDBO0WAgiyAZZuJ8IQjDDGFKUSiJz4kEd1q9Qq+wYJFs4BFg970t1ZkiBW2wBBEBVECyQQgASvwAbKkEIsLnSEWsIlFJ8oYC5bwTRYjpYoqvCUKT4iOK4CAgzezkAWy0NEsPbABHluQgp2iAAUuPBJdMGCBCkQgAnvZSyEB9jsqUQmMnnDFLqJxHmjggAAHcN5gJFaYTWZgSDcAAhwCAQppyIMf+Djr/y95qda13gOtaWUrW3WZynXU8h77KAde20HLdvC1r3xdB1/R0dd13IMd88jFCXkABxIylmvbtOE2I/tYNrCBa9nUJmWzOVnKpgENV4DjEoLwAySIlpzp2sEcgaDa1f7ICEnQgQ4qUQlAZAESngAEJhphrDNkgkQkigWJcOWSVhz0Fr5YIuBaMYUyRjFDiBNEUSOQgC8hZkKwua4tnCiEMrLkoE6ZyotO4S1SjCJcL3XDG9ygIyektkdpweNO39VTuBwJqBioAH4l0CS+LOAvlsSqAkYAA0e8IhjNwEY01OCYyAzAMQeYkgRAoIIhTIEnwDjGK9RwCVD4gx/88AeIQ/8sYhD/Yx8e9rCJ+UFMe+yjxfuAa1thzI8XxyMeayUgjgtIy2ES84DaeAQVliA2KhCZyEFYQpGT/E3KssFrlFWDN9XQTW9+tgpJJvISmBBa09axBi74Mg3oeJYerBa2PoiBBkZgBE7cqBG5XQQgEmGGI/BQJyK9sxn1Bovh+CoYvYiFIASRiSiWIBKGXpyzZFAC6Q7AArGgkBjF+AkNJKAAgohFimbxXfByyxTdIkW44PwV9c6Upqr1kQ1e0AIYuCBeRYqLkTiQgQxYYKgTqIAgoQSl3RkgwBlgASNuAQ1fUAEBjTFMJi3WAA2sQAg8AW5/bsABCJSpH9a+Nraz3Y//f2i729YecYg9DO4O8+Mf/jC3ufvhD3Wr2x/4KPc/4m1uASZDDXJAAg5mEIR9h3bfQUjyEgIecH/vmwc8CPKRw2bwgCPhB+iy49jS2VN5unAuL3whPFmQghGsQAMCSIAPRjCF2bp0ETdCghj2UIc6KOIUdw6KU1Y0i134IhjQwMYtWlEUC5WgBD8RQha/FIAGnOAMZ3BopIPSccRoYAobQlHMp0KVIX56KzYaV3p1NBYnJOHUaMkBq4P0liLZly75wrWTGsAAtf9FARGQgAVIwAQ0cAABCCDe9LhEAAucwNlQFIQGEDaZLRGgH/swPOIPr3jEe3vxi//2uCMveXBD//7c85YHLMhABiTAgAb9VrjBcSD60ZvznClkQcQjHq8ZqBMFZ3vX2f6YL9nnC1+fjCGSMLCsx0VgCil4QSWYYAk82GERdnBEG5ZQhCwkQhGZCOKGIE2h1wzjGKQaxixQkYpOTKG3zQbK4CLQ8cdNpgER6ARsIA2sBHw8AgVYLqZj3rmpx6jqIeHK2sIi060TwetgZzU75dGr1VeS1Bp+OYkE6Npf7NrEKEADEEyDIQAHyABPxI0TaYDQCR08CNMGcmAHcmAw2Rhc1RgJlqBa2YNd7QMKrti7GZ4IAtNalWCNwYOJ/UMu8UM9UAMILYIfZIEbAIJmXZYQ2gEcEGEbuP/BHdyBHbgBHLiBEz4hFLpBjmTBE1yBEzhBFV5hEfwIWuAURthR6eEUTgGBFBjBCDCbIZwBEJhBERTBFQDCIbBNIsCBEwDB8hmCI1QCrAwIKfShKZhCBzkTKIRCKViCIvDTJ5wB4gBXCSTAFCTiCiwa8YAA+lVILAgB0CVAUWGiINQCLpzG/FVFrWCFKZSXJZxi6cCBWFjB1okZTgEJO7UFkdCXxZkdBQSSXjyJIRkAweSdL06PBbzAFHxIFFUR4wjG7xyAXyjABzajMwqTjUVjjcEYNbIVPdwDPeCDP+wDCXYgL8lgPLjDPtAgN9pYPeTCNBkfTH2FELYjEdoBESb/YRIyYRNGYRTmyBVcARTk4xU0ARO0oY/0CBfagB2JoRjqgBEAAREQgRIcwT71wR1gQg2IwBUkQiIQQiIswh3MFBBg4RNkwR242YB4wiZswoaVQgehQiDggSSQCEd1AuARTwGUwNF9Qj9NTgNIgbBkYgJQGob0kxj1AlQoCFW4SKeByyaMzo2oYhbkyFjwSED+CE4F4CyGgNnEWl1cAH7lF1ItwAJAhvAMgAFMzwGoGdxIVFFZyZQk4zKG4AaW4AdOIy9dI11io13WJV0CkF7u5buZVS6BYy6lkjvQIGFuID1sAwg9wiLYkBV8xR0AwmMmoR3I42TGYxJKlhMyGWel/4EbsEEadNZnXQEWVIE/IsE4/QBrSeULoAVrklnX+UgSSMEXfMEbvMEpTMIWfgFGEkIjOEIjvIHWMQETUAEaVNYlhIIprEIRFREqhMIlXIInPJpPZMJGRYAGUJqXaMAJrAAwxIIZSEEEOJREWdJMCkECPBErQAMwWAuLsERRGqV4jYInrNQmWMKN3AESMuVTFgFNrY5afFkexYtPzUvu1QUG4OIDOAADLKgCWNLvEEABPMAKPKJPOJF0FUZlDEYyKqMCdKNcAlOOVeM9yNU7ABM9lNJe7qVZVWNgvkM/wAMwtcM6qIM8/MI0cc2UyaOOvoGO3kFtvsENSVYTaqZnfv+mZ3oTFlTZaPojw6FmaqbFDezAaiWBcLYhjzzBF/QBjxIIKdTBHRACRjrCJFTC/V3dIkTThoFCKbgCLLjCKnSQm9bChQEDUEBDdgHFJ+BEmo0AtBjCEJwAhWRimAyAz2HickFDtVgLeK2EraTUKJAXSeIfIMAZfsrUFe4nHUGpWrBTvLQFgdIFCJgdXuAOvyyo2gHGAoCADvxEFEUXVkmPYawlYDBjM87gM94qrupYifYSjNFDaKRoir6DitnDO5SDOMxDNoCCZS0WF7QBZP7ojyZhba5cHThhPTJhG2jmZ35mU8pUFuTjPmpBPzqBP/rjHFUpEDjcDgSBlZKFcC7/ARogYRbw6B2wGSloAkYOgiJIwiRowigIEUqkxCoMrHIupxER1DFAg3qyAjAoLCsMQsOq5ym8wAgQwSRUixihpWTgXQCUgC1EwgrEAqKyZ3sSJVUMbEp5i3wq5bj4qFPuH9edmnulBVXuVOzEmqzlCwVYDwRcTwYI46CtgJdoYqUdRmUEz1o6zwYOZq4u7Sk97VuSoFoFU1zaGDSaYFvlAz7Qgz1wLV5iYyr5w4muQzjMAzKogR+MgR94gRc0zLP66B14aRJ6abVW6xOugRO2wRrorRdsKxhkwRd4KxU+AeE+gRIcrhJcoeIK5z+2IRIUAbuy63DCKyA4go9+wR9o/wLbOAIh6KuYagIn/OutrARB8Y0roILBHpGwhYrCYoPC2ikwgAo21MIRsEIqsAKoQAOwMBr7iUlF/Vx6/o2mdY7UiaIqdNq30EiZ3md6Aed6OcFC9p+PvFdOsdMe0WIHzFoGUICS3OIEmAARPJsgSAZh/I5iTA/SGoDzPO1gnhI8MO37Mi37uu/VyqDTRm397lJbvVgBgaOO3YPYsoM6mIM3oAIX8MEX1AEapAHbRiZlFmETXqs93i23Cu4Uems+VkEV8KMVMoETsOIVMm4bjnAb5iMbNAJI5FMfYIIjJEISOsIfJEIeisQo3E2MuIKCLCdC3cJw2MRBzcIwgMo0yP+u696c7L7uEbvuGTSi81DUZAyABmDIJ6hnom6aS6TRwNrKH65sS9kIpfqo8xJuEoyx9N6UDaDFC6iaHrlaCJBAB2Rvrc1aB6hA9z0a4FlApZlvL05PImloArgDOshv+8Yv/brDOhzyOjwtIi8yXRFy/w7mLEEtjL7YKdnqINMgYZFtOkiDGkCBGZjBEywwFrTBZDIhEUawtdajBOOtE27rt2aBFjwBPn4rB/NjFbjrB4Mw1yXBCCuuEmTBDTkCS2mCIiQCC/OoC1ukI4AEJ5RErRCsMt3CaczGadwCQk3DNhCxNhPxEGszMFgo43yJlyRLCWwXFV9L1IWiixTl8ar/bPLi39o8q0wV7hMkQf8J5PSmWix6qgmQgBuTwKyZwBA820OVQBX9BfoSD2IcrcGsJQHl0vyq0vxOdCUH09OmUo3Rwzuwgzuww0Yb0InOj425QzzsAz4csl2OaDS+w2hwmzqkAy0EgR94qR1kkx/c9B3c9E3DI09L1hG6QbWOQRqEQRnEgRuMQRmEARh0ARgoNVN3gRZEdRRM9RVEARQ0ARIoLnuN8A/8QBEwwRXM6x0swiZ4woZ4QiUssxuUgdwawiQkAgpjAoEM0ekW0SxM82mYhi7Awi3I7hArbDfnLmArj8ImbCI2omSEyWScp8/ZgnrSBLXI3xVjMbdkBRtx/4JSfsWzTuHWaSEXsqY+E0kImMCR2MsfyYsK1FmFXKB0HQACKBXwLEaV0JIhJzL7ogNuA3Jus+8MXvRGxxJws0NJb6BJFxb9qHQviYbhzcM1NIwe3ME2aRM86gF16zRPn3IbbFMbxAF3x8EYhEEYjIF4f3cYdIF5g7d5Q/VUR7UWTHUTvLcVhvAIIwESePAVuMEfCLMnpMJGGILocILK/cEf9EFvyTBIzHVKvekqGEdeEwdyJIcr+MI2+/XrQkNgEzYwdELHMRr5LbYGIM4xTAMw7MIs4HDMschkszNWWHYfdrG4NIJXpNcFr9epkRkQdGHY7RQf9RELqIAUACWhVf8RsyjAvzRoAiwVIiES+yJybS/yOazDOeC2lO/2RAd3LNHDcJP0WY3ojtUYS+tDP+SDPOTCDDSBHQBpEfI0dVe3Hlw3HLQBnMP5eHt3eI83eJf3ead3e6/3nkPBVTfBFWxdlTYuE/ggIFQCJ3haUPhcJxAIIdSBGfhoDMtwSMxKt4xCKcDCbRxHBvkJ30RDNvv1NIz6qFc4Ed9cQQs54yDGYkeAEEwxNPQCLszCKpCCKryCFUcFS7iIGqXsH74z6diIV4CFenHr1rWXe+GUC+zUTrkLvPSAGSiCQwW5BRQVXzDAMv7XUv0OIjHyIbvDOYS7uD/5uE/5lC+ylcPSNd7/Q/zeAz9w+Sw5LYjxwzx4wyMEQQ6glz3SAb+vuZvHOZx7t52H953jeXpDtVRP9VT7OcPv4+KKcKH/oCN4xO0KgQaUwCNmhWwZgiEI+B4YuEgUiCpguivMHA/7ia/cQijQAjYUBDZYw6hvM2H7tWFH4nUaI6tXlKt/woUBzumGgiWMAq6j+FC+Z8CCDhtpQkhUgrh4BRhnXaklAddJbxey0wu0Cw30AG9NewwYtAZYwH49gAPumpHzjlIRhpOPOzmsPTmIu7cfcrinfbrLktOWNLxLdDsEsrrpwzwsQxDgAAxA4RqUgRPWAb8fvh3AuRECvMCLd8Eb/MGz955b9Z+//3cTQIFWM+4/CucV0OYd5LchLFo5W8gngC7Tx7AkYGS/DogpnEIoiEIoxH5ypLyvlHgp9PWEazMS5+4wAINEXbxBMxpFaWKGRMsrmELs51YjbEIrQMVU6DpVuCnBplSLY3ZIkE48E7u3WgHhamER7MAOYERrPoEhhFSF+EAJDBUIaG8g7YVR9cUyZntg/E5ti/vahzvbs/24Pzncv/3clxJAvGsHD547d/cQvntn0F07d/D29auXDtUMGi7SZEzz5Ysbj3FAgmwzkmTJOGPCpOyyMszKLlpgankJMwoUmzab5NTphKcTJj+LFPmx4wcQIEmSGCkhSIiQpZE+dfKkif8TJkeE/iRyhAmTJ1KmQpUSBSrULFq0YMFytapUqFC7ok2bZg1bNmzY5M6VCw3a3bvHbAkqUcJpCQ0REiQIEGBAhKafZJEKhclSo0aLFoVaJavWLFmfP78S/cpV6bWqTpEi5dVTVUyQGgFqlOjPG9tZskyR8sRn0B84dtzoAWTKpFO2bLHyceJEBAkgOmTIQIG6hAgRHjTQroB79wQHDBhAh+5c+XPkyJ1Hv549+vLr4Js3z45+ffv3DRI0GG/fvYYP3VnnoX78qacaKixCAbeMOErjozFCKqkNNtgYiQ2UXJrJpZhiisLDmm7CSacmevrJxKCCMiqJJ5QijCkhIon/0ZMZW5vEEUcgsaQrUUZxK5RLQAnyR0goA7IUZ6yZpppqsNnGr7umgbKvJrGBxpZIVhBESyFWKAExAQIQwDEhOollk6ogwWwRQB7ZRBVZZonTM9BGa4W0tVJJ7StSRHENNtgSAeSPO97IbQrcfGKiCKOOOiMTVpD7xIgTRrAgAwk86IADDC7olIIKKpAgO+1I7e4A8MpzL9X2WF1PPvXSO0ed+2itb5134ImHIP72accheN6B751+9JmHFotEECELNBgEw0E3xog22ja8IInCCS98aaWYttXiQw9tAlfEEHPiycQTg2ICKSek0GEwLZmCKpMZV/OKK6422USUtjYB/+WSR4J8ZBE8FukXlFys2eaahe0qJpco77ImySmdtGYYWzr5JBJBzmiKywQGGCABwjp5ZZPK1AQEDsw22SxOzmqhUzRZRHOllTxPOcUUPl3jCjbLaCP0jTSysMKKn3h6oo9OIAUmljNiOAEEDiS4QIRMO+j0gk9DFZXU7Uw9oLzxYG211XPWMc89dNxhR523a7VPofwKiqefghhq2x1/8pGnFDjaKGIHjcLgqI46vggJJDvskJCNjFgCqaVuv43ipW9t8lbEcks8lwmegGB3Ci6FEOQTLT9h5ZPVNhmF3lFgd2vfUlABpZRjcgnykktCQQWVXLaRZ5505PlGnm2cjP8mmmzSSeeb55v8ZptvoHE6qo07yfgTIRBLwLFOqHrNEksgeeSRlS3ZRJZbbsFFllhasTN+VURr5TSdTRlFFE828fnnQIWGGyskKghBcEMWDJGJTyCHFUeQAXNSYIIQJOtqHsjA1j4lAa81gDtgU8B3xEO2srVHHOJg1avW1ra41aohA8nPPnRlkIW8TR/1cEYg5ACFIuCAWV0oXBnK4IYwKC4OEsJWGtDgEpVkyFvfoom4oPChzfUkUScCXRKUoASnmO4TGvtELFgxr3p9xRRlNIXvaIeKUkzjG8YoxRtR4Yq08GIa2TDePOSRx29cgxjIoEY68Fi8bGQDed+IRi//YpGx7DGti5EQggYKkADTYYIT5IMEbBbxCIJlshS4mIX73heLWLzCTvVrxSpUYYpTpJIUo+BEzy45G0AQyg2FKppPnPAGR3TiOMk5ww1goAIVpCCCIWABCq7WAQws0wIWCNWoSsUdELpDhK0q4TVNyJ7zrOoc46HV2+B2n7Q5pCG58o+A6PO2eswDFmrwAhJ2gIMrYEEmXwDiGLoAoZOMgVoWelxGksiSblGucjfRSYhExIQBds5ETgDCEI5ghBWUrosaM11ysseJVo7CFKpQxSpAGkc5QuMYt0CFWtKiRtrBQhd+tGMe85iOcQAykNnQxjecZ41dkIITp5AFMHoB/4xanCJ7Z9BACVbXiNdc0nyZHBhmHnELYMyiFlUV5ShbEQuaxQ+VH02lKUQR1lf6zDKzpKVH0GCFLDiCE017mgxgEFcYtMAExEzBMUXAgU0tEwMVmMAGozlNd6iNhNgs4dlSNbZZ1QecixXnOn71EIjAA51uU8c8roFDLiABBz+gpxbAYE8MhUFa/KSWFzRCuAxpi6A3EVcTECqiKijUCUYzF9KScAQiHEEJE9VSjLBnCzB+ohJfSYVHPQrSVaQlpatAxSx0gYpQPGJ3l9hEWEoBi1z8ghnWuMb0iBfI5zXPedloRjCCEQ0oHaMXuEBO9k7BCSJdsnzmewQgAAFVVP9AoxdxukUtXoHV95kSpK3w6M5aKVb/xcass6xlIkiRCls47Qw66MGFcwADF7CABS3wcDE50AFNbeqvooImBxNzAIOQZ1VvK6E5YGwObJptbetZh30cax/4CChv/VmIZfOYCzXYYQm/+QFMtoCbL4QBDD5MCWlH4gXUpjYNkxtoa6MoxXBtLidVqC1PqjDbhjoBKVr0LReB20VWqC4Vbfao/FaxllWQ5hWqsIQscBEKzNwLEox4RCDgEAiA0e4WwWBGNexovPCaYx7ihSn0pjGMXtwiFmB5BH3ra778BiIQlwhEL7axi7P8l2YBHqUp53fgnYmCZ1UhH4Pzm4hEFNf/rYYAwg1uYAQi9AAHNJjBDDzcghdE8Goc8AAHMuDXCVznAaP6YGJW/CoXiyPGMr7mCdWzKvSEE5zpfBva4OOr8fDHP/U53iPUwIUl1KDXWtiCFBbE5Cf7kJ9SnrJGAsqhKHCoibE9KJeb4OWFivlz6irzEZxSOtSlOXVrZkWb42dKznymFq3AhB1GsQg2yCY2jjhEtfAQaDiogeSBBgUqaMELZnwXp+FIx2Xz2OiYbmMaxtCFLloBlkvE8jKZvC8gAtEI84WiScQYdalDeer4pdqMe9ofJ072M8s4orixmLAtDGGEW7fACFqPZ69dQINg39UDHiCBBZO97AdcJwLb/0nMeERYHnUYltrYfFt7sj3C9TQ2nOSITzfH04574OMd7KAHO9LBCyrIgQrr9jUUlPAE3GShC1vIEGntfW80bJ7fH+o8uUYEW4Pm5HMLPVdPcqsEhBNG4WcQRCQUWFFWWL2qpJwZLtobM1JcxREhB4Qd8GAHP9iBCsWnghqqcHw0kFwNJi8FLXwRDWsQ0hvBE16j5yG9aZwXF69IhSiWahn7ahIOjSifp3NxvF+cxTOviFko60dKppcRdvvrn/guqVGrAwNjXQeCDWrA/4AgnnLABeIq2PAqBEIgOvoKO9gObBJgPKiJxdZh7uiO7rQJVtBGVs6BHW6MA9VBVm6sbf/+Dh18RfAI78bMwRtAIQiqoAmQgAdmgAVgS/Jwowu4ACZYYgwyL7U4TwefqPNqAorGZfRoi4rCDPWO4AmOwAc0QOGa4vVir4syJjU4gepO4eFSIRZqgRVUgzZIARCCDwsmpArQgAcKKAioAA3McPPgAOgEjXdOihZ0gbvYCKfIy0mmgb0ALL5eQ/zsS+NWxucAphrmwRt4gf1gRmZGQ/6Qy4z0h39Ohit6av+A4RN0Iwl2wAZsgCeSYAB3IMMyzAVcwMOOSYKgIwMwYNnYru04SAEKQtzKgVUu0LD4jhxCMFa2SUAgqxfbYR3QIVjSBu7WgR/4oR/s4R3MQR6KgQr/msBDwuwFsSAKruAKNk/KNATz7C0jHmfzNkQmtCCK+g2KQk/0yrH4mEDMeiILnIC3uk4IRuZFmgIqKmpjpmC3koAInmCRMuEUYiEVNEYRDOETFKEPxJAN4AAO8GAhQy4h4cAN3lA2GEFNLCEs4mgWbqEXjEH6CEl6sKEZfOEWZEEVwK981ERNmmr8/owW8ugaEjEjRUMVSgMVVKGUTknVWqmVXmkTeIdISOE4+O8TzkAKvqAnQscJFmUHNtEGcsAGSpHDkIkESCA6NmBrJuCvXFGaWkjcdBE9atEW+W5sxqMcysEExe0E24FtfhE+0AE+9IEf/oEf3iEcvgEVliCK/6Cgy7BgL/lyL5NIB1Mi85gFifbyG2FCHEEEXEAk9BZzRIrPyzrnCpzgCXbLKUaGS1yEi7pIEEZHBqRAClwvE2LkDBRJNDlmNP/gEBTSISmEDTyCQhbEDVrTDTIpffZluegwGI4BGpIk0iZtFlQhFCpjIgPhJFFSJR/BGfJIG34hF3ABwGhGjlCJwFCpjFSjXkTBR0YhFWoBGICBFQzBDMygUK5goXpjAG/ABtLTBloAKkXABM4uOjzlKrEDbAJP3AjLFmuR73KxLMmyLNMS7uAuLddyx9bhLfvhH9YhHaKh8TanCrAgzPpyL2kiJgRz89CgMC9n35qICBEqJ8KlJv8OKhqpiCeuIA2qMaIeaWQmSgjOgB67KBN0QwiUAEY3RkteNBMWaZHOoCPcAA/YAEOFFA2qsUh9wgzzaxFyBBP0pRTkqH16IUrbSyRVwRNQJhDwgNM47SRVMhBKwXjkgRt+QReoqtTupE5K4xHzB3b0RxRMgTu9MxYMYU4T4Q6yoDy/zCeMAtd6ID1JEa9QAD5FTBUvAFSeaTsGNC0Jiz3EwcUs8Jr4cx3I4T8BtB3K0gTv0wThIwTd8hj7QRzCARZmwBzLUUL9svOwwN42D6DyTd/2LTFBZPRgK1ZBNBqNxrbC7Apm6wu0yEVIByqsTrg+QTRhL3WiohMi4Qym4PX/UidYY8GRjGBBrACJNq88rSBXqzFRzFAh8+vSIGF3QkEU4ggWXmEWyPUVVoEUTgYzGDJLtbQ4CVGT1OAXAKkevAEZaOEW5sQ0GrE0uuqrIFEV4NRpMqEPFOEq3sANiEat2FFPL+zC0pMGjgkFKDY+lYmvQMUVGyBt5ENA4Y4scXHuHrWE+PM8LtUs3aFSM7UdLEsd4MMf/KEflJEaECT0XlAnTBUL0IBD+FJVmWXzsGAmOsRDxjFWNycvRU+2btVodLUa0SALiMBjPEYQRGnC+KJ6vlNHLSpGUKdqr0pjpsAHjEAKrPVOi7Qak7BznGDzIDJJldQydOS6wjUU8mUT/yAhUOxADBOSIbHUXd/1+EBhG+ghH+x1/diHZtQiNO7EuUBK1cpIFboTMDhBK2wkUGZpQYi0N4SiB0IRBiT2mPCq2PYKA5ypPhsgQEowQAV0FnFRP0kWnNLDY03wUtEyQCvwbV7WH+5BHdIhF0RgVEckzHAWQvsyJnpWyjCULy8nCF91CI0WaY9Waa0grazgCpTgC1bEEF404R5j//jiSWIh9jZmHiuqfJGVY85gKJMAT5u2CtAWMm+rtq4AIblVNu4Av4xTYPDLDdZAYUOOcdp1Id+V06qA5HJhHvSBcL3B6F4mcUvNX5Wrq8qoFbqTv07hRpTqZxYBDnBDYe9UUf82NxRz4CI4zD3LblM2pXSx4wFQNz7M0mNB1ppoTBfLpmPJI2RxF2bZwRwySwRYYAlyAohtNhondEKlrIi7wPOcCFbxEmnLEaHKc/OMJotA80YFIwIEwRYioARiwTu/1y9SIYEs6kVipHyBC7jOQAmcoDw/x1Zty0TxtLaYQEgd5A5qKwueBQ7sIDbsAA6QKCMYp48D2G+1dAkA9xrqIR8UeP1owVxfgRHtR45Mw04q+DvvpRHQpKzw6yHTSnOLoAdyYITFroSRSXT1KgOcqWs41oUdQnXhTu9mWJuw7TxumO9glnd/IVlQQIiXAAmAuAqEOGeLeC+9gC8x1AuSOMv/nNdDAW5EQgQLnJYNqwDyXO+RYMQpFugTViASrPZqq6cTFEEQMuZGFa4ezzhGpkDyaEtCrdU813hpaUuhptcNiuBzeGJ60WARANgNVpVx9pbT+HaAjU8NaGEe6kEfEjgcGHlOQINOYMFcQaMWeoEvbOGVwA8T+oQyAOV+OfkKgCIoQrEGRhkqkenY9ArZmslQ/+4EX3gsY/iEMhCxDLRjbzec/KGG2GkGcIAGdWIJgDhCITQaIfSIj3eYP8vzwPGJPiRpixB6oaAKaAAHCsiQ3cAMzsAwSueRVgA5MOaLrM6bj4EVljUSkDUKN+acuTZZpUALsGAJ2lBnh3RpbzWu/yfPNt4Av/LrMvCaIQW5Id11EbQUsDmt+agrFLLhoP+hQLSBF9TCFepk6eIsLeIEF4CBL3AhZ/RkX0LB1fR6Tfz4g+sZpEXawzYMr8rOpE85pQ0ULRsChm84ls1mm+TDQNOmZQ80HzArEHhAYl9QiINXqIs48zKveDnEMLWMqYsQRJ+aB6Q6CJYgFGThFK7aRUqgAAIAUoRLdb7oaneTFdIXuKIQXtL6tzgmCyKUCtyXVZmFQoaUjjdv8rLAI9zgfvFaDAmmXdmgj/+5OLdUsAOh+QLhWw84H/7hH9ihHq4hFyTblOTvFWABTjKSL5zmFE4Jf9To6SrD/GLjDg5IMv97YyhGmwY+t5QrKIVVesdY25VhmFJZd1Jj2FH5s9vcpjxaVh0IVx5yoYB4uxyHV5jhGg2KWbj5kluYqN8MKracOsuqQKoNeRGCChq2h/VKIAAAoAG4Ojmgopuh3PXAW+Fej2u/HPYUAQy4gAvMsA0xNA0ohFrpWL3TXM0dUiFD7r4XEg4oxCEDeoAXgeTw4FtBgRoOGh/qoR7UoRoUPF/bTxZKCU4+aRimARpqIRWyqjo7KpVcR6NfTWU6XDKDogdsQOw0zD1LfFO6RgJW+wRbe3VXF2RZnVIbVWRjnNtipbEG/RtAoZdn8Le7jHiJ2C+TN1WFfBr5zVWfF/SS9kP/sIAG1JAKXAEYhkEWWIEpvGfKAQAAsJuBOuHqGOg0y9rLz/qMBYEVOAELypwKorm9g3RIqWxVNaI1EbLO8cC+6xzPB/ld91wN+hxIaCEdEvnw3CYbciHg9fUz7ITRcY8vemFm0HUtTEGCM5orKmN/ieZOO/0GRDzUSxm1l6nU0UbczFLFA+9jKXU9/pMcXp3vXpc/00MdcNEc1ikZqAALfmAGUAC9w+wxfbwv27uYgZ3nXZXYK6cxRQ+po0DZmYAKagEXdIF9amEFQIZ7EiMTrly4pj7amdWRvP2cxTkWSMELyr0K8Lm9hTTd1bw1y56fN49CIHIh+zre671v+RYz/wKBDQi7Ef7FGQx6cOmBHupBG5xBGX5h4GmG0XthN4XK/cz0lOInT/gkXzLZwXCD04EAB0Raw1BAKjWFrza+azr+LNOSLDN1xVscPVg31iFV5ffO5eUBFdQgCnKAw2IeCxrvl32c59X9eHl+Q4h2JirniUav970llJmADWphF3LhG7ABFzLBSwijBFbgDKqW6rna6mJBS8Y5vNGaa1mhEyaEC6jAaMR+7Nf8WV7TNWVzNt0A+Px6Idk17uXe/f975IrTfEphG+YhHxCCHwb9EKsh8OOkXAFi1i1g0JrhkiWrFsJZr1q1atgqlSlSoTZ54mQJUiNAbtKkyeKkCBAcNP9auGCBgkSHDhgwcGiJoUIFCRLa2byJEx3OnOjQlStHLii5n0DVGT2KNOlRoeSM1pOmRg6SHDNEVMGChcoSKlW4Yv2KxQtWNGjGovGCFm1YL13ChOmiJS5cLVHqRokb165eulCg3I0ypIcVOLhuCZMn71etT0JKCHosJJYtVrZifbJVGbOtSII+fYokRBBn0ZE6ceas4VOnNXi4oMlixaNsNB7Z2Gbj5jYcO7zh+LbzGw8e3sLt4AGEfBEgPIGaB1oEnbnw54sCqYGjhvojNbzk8YO3r58/e/nqfXOW65bCWrd6HYMGrJZ8hbMYvroPUZUpUfw9bbK0UUduZMFEET3/2NBCCyiR4EEHGcDUkkw0SeCOOzZVaCE8GNqEzjk79eQTUT39FJQ6TZ1jolJJBYWiOvLQokYbRVC1AVZdXZUVWDqGVdZXaamFVltuaYFFFFgQuSNde+EVRV91XVFEElkAgsssv8gzTzW7WKZBaIKc8UksksXSCWZiYvZJZ5+FNlokbr7ZGCukZOFHG2RZ4Uaeetrmm293BIdcoMgJB4hyyxVXaKDMQVcdo3gwuggjjCyihhp4wFEoHo+Aco0+7vTzjz+i6lPPNbrQUt8tuwAzDTS4zJcQQ7MghNB9reg3yiiicIIJJIu8kcaABd7gQgsmoGACgx281NIFM01IIYgh/5YDYjvorHMOOdkyxS23Pg0FrrbdkhNPPPTQw8499MyTzXZr1JEFFktgFUUVUNhr75F83dXFkVh04cVbb82lRRcA/7ijjvb25VddDeuFRRBMZNFHLKr4Is8309zSCitCeBlaLKx4JohlnmFmWidpsinaY29GooEgtTiSZxV35oZbnrsJdwcghxjaSNBCDx10IoccUugiRy/thx94LL00pIxO2sgjVl+tBi3z3PNPqP/00495v6Byn6rDTAMMQ7HSKst9td6KiimjrJLKKaJg0isgd6QR0oEtqGBsCBwwG5OE0FaIjjvSKq5ThdiuI+052UreLVHUjvgtt+Wycy477P/Mw4sabHwxYFZzNcnwXXnxS7DBBg88l8EI60hW7fQ+7LBdTmblxBNmpELKLfI4Q4t6KzfmmCGfjDyyZ5KhHMnKLb+cSSRTCGELMJ440msj0BEttCPiQwJJRpCIj74j5KdfdCKSSgod1PEfLXWk71d9NSSPBALKM/XoI6p/7GMf68oGL1BBi134AhrY2AUtaOEK9cxnVrS6jytWIbeImMITvVrEHfbWNxeowAQmEByzDActmWBIQxiy0IXcga0WwnAdNMSW5G74E2npBFvdugc+zrUOcajDG6BQgx3uULp/nc4uq1MdweTyOtgZTAs/ql2PzIIjvahOdXgBWBWcQDH/TSyiFN/Yhi5uIYvPlEAIEYiAEDQBgwccoBPAsMXJsucZxgjBTaR502dYAQxg7Edu/tmEIQ+JN7xZIpGYsIQlKAHJSEKSfJQUXyMg+b5J1Y9RP4PU/a6GNTXAIh3/+9oA93GPemiDF7DgBTGmgY1cPLB485FPfepjK1ydYiKc0AgcaGMFIBCrhIODUOFkgkIJwGOZ5XqHM99RoWWy0JnNfKYMMbSOdlToQvCAZgtpOEB+0EMc4UiHMgIBh0DcYQ1pKItb4KJF1HFxiq5znVveCZcqysYstlNiPe85hjgIlA56uMIV6kCIRKzBEtD4RjCM94kzsEwTAAAAAhYwBcnc//ETmdDjYwTRUc9E7zLxUYVJcyUKT6Q0FCxFZCId+UhJwhSmlKQkJjOJ06ltMlL4s5r+KhWIZdQjH2ALTz/u8Y57cIMXrsSGNc74wFtIVYK1EAgFG2JS/XCwEXuzAkhu8LcSeiAEZC0rWUGAVhAMbnD3uEe50MWOpLZ1rnM9l13v6rm8xkOuSHUmXefqTH3wox/vEMc4voGK7OymDWsgy8CU5CR5drGe9rznY38kGzbIZjZnsWwYxhDQOBBUD00rhBfacIc9EGIPfjAFNnrhClmcwjSdiUUqegAAAlCgAxJYQScEIYXKdCITrDiNyvLYCZV5ghQWU8UqVJGrUYRCV//8EQVLQ+GJQm7ipTOdKflmSomYRhKn8KsfeRuhv6tRoVKo+EY9wOYPfXzNHvTlhjJ44Qxo3MKqU51qLRWC1VMAb6t3gNIwTZiBBBduAgyeQIJXAoKz4gMfPlTXueZK4bbGw8J37fBd/wrivwp2H+UQRzqgkk42tIEOcfDIO5VUFxgXjLL/FBI+D4aWzNbGNu1MQxsECmTRjrZpfihEIezQBjv4wRGq9YQpXgELWaSCFSOrDCtioQQYwMBAqm3EK6BhR5V9qTTJ/W0kMvEGRqjiFc/Vj9x09WaU9ie7h6yzSxfZSO46UpLkfd/U+ky+S1zCalTAQnaQUQ9//EMf8u3/Gn1J9Qxl/GKqAplqYaSKi1e9jW6k6KUbiuACD7zkAhSgAAQe8ACaoHrVEkj1BCqAgQRnQICnpPAP6TFhDdsjw3+dsK99HeK/5iMf5wIgicexDVhQIRDDaQNo2fliGU92ijP+541ll5Ydp+E2t/GxkAeqh3AT2chIcwNvErGHL3iCFabYRNvEFKbMjMzJsthFMrZRxmOkwjNsehNpTtELTTskq6YoeMGjS93sKlzhdjbkS/G2XZhKkhKMoDh5/5zJR1By0I/gARXQAIdSaIOoYCsq2O5BquGlRz6ZbrnLXwXgVkzEEVeogQguAAEGUEACEDj1AxzAgFWjekINhjVM/7qGdH4ofdjD5scp/cEPXysdH1P/NbB/TVd8MD0fxl7HOK4RCC7AgQ128AIXtLCGLIwh2nmB4hSdCEUpCqkN2bZNG+zehrznXbR6oIPfSUvaIh8NEYwwDh7a0IgvSGACimCFJTzRCjNpJpC2wMUuorENeaRj880QGWOm10eC7BcWtmpFm01q8IOLAuG5onPDXepwiUMSvO+zeJ8ZUVNLcJwHSLiCpn7xv34Y9ajwJdU1cpGeW7x8+bV4BSkW4YQaoGADpnbAAhDAcwdoH+hBTzW0JGBMWXet5KAKVdTz4XSnQx3rPsww1d3v/raei9h3BWA/9CEPXmxlOWP3whjW4P8Gb7EvTRRjXTAGMYYXq5OAcfEjp8VjmaViPzZQoxV440Y/z4EHH3QAANAAhLAJjGAKlIcZuBBIZ5N58qAO4tAN39ALVJYJXnIGX2Iap4ANzZALsEB6F7QKqFAKPZgrg7R6KeUJuWIRo/B6dtZIs7dnlEBJMSUpttdn+aM/5ZMRi4A3oSByiQYq+sB0jMaF8yANvyAMwTAMZRhIgRRwtZAKlpAFNCACHEBqpbZzPddz35dCDfZqMhFrsmYPSAc2XQN1Tad0+xB1Vtd+bfV+PhR1iEhh9MB09QdA5gEKQdAEwzF2zgaAawdPcrFF/BIGDeN2cuFZaaF3eYd3pfh3FUj/ZEVWCIeACEHTKIvgCElgAA2wB5QQCq0ADL0ADC03DNiAb9+QDvPADuIgDt4QDK0QCy/4UW7SCZwADNgQDb9ACzmogzxYCgY3Cm+2etFVhBbhekjYSDG1Z470XTd1e+/jU+SDezTlSKAACrwwD0NVD/UwD/c4j/mYDcXgC7twDMNwhr0gC8+HBjTgARsQhzs3IXTYc95nh4tXdHq4hxmgD+wwfuUXiIJYdRNWiO1nde9niFrXYfFVHlARBD8AHL/BWG6wdgLIJFpUMEwURUICWqFlinmnkr/BG7whbuNmZK3oioTnCOiFXpCACaegBBjQBKbQCrUAH7s4DNEAjNtA/5XfgBjjQE7RUAuxABrUQwqvgA3SKAy5MAuucEGogJY9KDemEDepF10Lx3AN111zaT7idVNQqI42NXuFYgksBY+6wFSyVI04iIM8GAqX4Aq8uIu1IAqAsAQzcJAXEIcQ4AA0wZANOXQPCZERCRMJxg3qQA/vcJGisnUbiXUcaWsfyX4eFl/2SAtUEAQ4kCdtAAcrGYCPtYALCBfW5hY1GWRJ1ic7SRzCIRyr+JNGhgjJSXgVF15GaQn8kQqpAAg/8AirwCrQMA3ZCYzZYA3ZsA2blw7j0A3eEA2zwAqKIAjDlVykIAq4gA3T4Ay/sAsMYZarsAqugJZvBl1uOQpwGf+XcjmOMKVnS4iO5LWOkBBJlqBxguaX+1Mp2PGggfAIikIJT+YJa8ADLHCQG8Chkll9lVmHPAcBdthgNCETDIZMErmHsNAN6aAO9lByGTlsVFeIwKaIixhsOXou8TUP2/AIS4ADM4BkeaJZafAFbJebUeRZABVaQSacSraKTQM1pRWUyZlJCZpInJAKDvEqrmAKThmW35AN11AN15AN3ukN36Cm38AN3sAMtKAKjlAJ6pkKtYALx9AMyZAMvtALDJGD92mfqJAr+xln/qldhsQJdTZTmLBdA2qXT4iXPgVeCipojxAKoMBSeLBebEAF64UGefIGwHIFOMACGnoB1Ef/hzGhaqymmRKQoq9aARQgmZIJE7N6AUGQCy7KDvzQNUundfhAiFCndDh6iDmKYbymLlyTD/NADGoQmyyAZGvATq9xpLhJbQXzWS3pm0Hmd0PmB7xBZEwjP5IyeMs5cZRQCZWgCZrweJ4gYK9QC7uwC2X4HtNgDdtQDWVqpt5Zld/QDeDgDcSAg6JwCm7TC9CAsMmADMEQDMBwCzjIZqiAn89VcIIqN9PVegrXn3bGCdpVjpbQqI30XXNJcQVacSM7U4vwCJcAj/8hCo3ABDywBDwQBFTAA8EkTNOXc5S5ANeHAAhAAN/Hag5ph696TLOKARdQq7M6A2qgDN7AOb3K/w/5kGuEOLVbZ1fD1mHBlmt0JZr58A2lAJtuqGLS6hFfUK1SVG3ZWpOh1a0UGKVOcxxRQz/2Q17niq7ruq6UsFzR+QrtQYbNgLDTUA3ZUA3WYA3YgKbjmQ7h4A3gwA3JgIOuMAuWFwzNMA15mgzGEAx8+rCuwGb3iQrP1ZZvhrH9ubEbi6ic0LGHJHsCaj5UOHHpiLIwtQkrCwqP8B+YQCkkUQMkMQMGeQEO8LMEYLwHgLzGSwACsAAMYH3IuwCVWbQTYrSFI6u2ir0XwAMzEAjVIA/0IF8ANGH0RYgi6WF3NWG4xojGyg7lQQ2BQAU/IAIskHcA2BFpUAY0FheWVf+TYQBkqaiKFugzUQMdfUYJknDAeKuuersJmkAKpJAKstAevnAM9dqd3Jm4iuudjssNHLwNsUQLuiAMxoC50xANzdAM/NiPATexaOkKpVC6onBw2LWx/oEJdOZIWWpItJegGcFnJVt7FQepdSloisRxVoM3V0AFVSECHkCZxSsAURzFB7C8UjzFyHsAPduzmZlCsGp0MlFqHnq9tsoCTQsL8jBUioZ0owJAouLGXsiFWydf5Yd0ofLGjFYPiJELj2AHcsAFUKAn9wuAcndPrwNaQSZkbxvAheAHh3CcR9OKyrmckoA+lCwJlSAJk4Cu6bquWToKqiALuNALw9AM0WD/r9dwDYibuGdaleFQTptXRt5ZRtYgDcyQDM6QDPx4Rr1wC65geqtwK6FgCtC1CaHAHxs0hIZkhCBbZ5AEcf9hCbUXXgQazY6Ae+wICbinzSNbPowqaJdQCtdlXcZ8CqQACVmwA27IoR2qtBIiIUK3AMjbAA0QzwsgtK7qxV4sq2MsaxkgAjOwXr8wj422xvHlxnfMaFs3bAAEx3E8bPUI0fJgDaDwHGQABVtQBnuSBtLakkwKUHFwyIlMgQQVpYz8yFAjyYzgCJTsCJMwCSudrpUQSXqLZ0PIlBLcC6Vsyoh7uKq8r9/gDd4wnmuaDmq6DddQy8iwub6gC4WxC68g/wqXsB+bAAjlU2eYMAqtm4T/wQg7jDfOHKB4+YQ4FTQ1pRFCk3sw9c2XYMz80VK9VAc9gAIdcAES4AA9t30/5wDzzNcNwAAMsADzDNjN2wCamc+wKodyaKswQAMAHQj+kw/+UFSntA8HDccKXR4QjY+bfY+IgRjpgA26EAhy4AdysAVRUAYAeBscDVpsC9KHzGITCMB9F8BUujSIUK5WqtIs7dKTcMnpCkkLzK6M6mTD3AqwcKfRsNPWQLj5erhnmg3aoA1USd1rKqbRkAxiKK+Zdgv3oQoV8R/Q4UiLAAl4sAkYgTeH8IGeEEkBWlN46UmZZD9Ec9bodc1U6Ehrzf+e1cUJjZAGNEACpGbX19ezf23gDNAAWIzFC7Bq88yqRYtMXZyiiU3hF1AEbhAEMxAEoKANEP2I7KAO86AO5uDKkKsNZEoNzxBpksYLyPdAsICWPAiP+2Md2SGhftwESLAGt5En0MakhxxQb6vI4QZ4cWvbVRqUmYQ+Ll0Jve3SlKC3mrC7RTjM9zkL7rHcpiwN0kAN1JCvqGym+5oN3sCd8JkMwSCvTd18psAIn2xIeGAJjwIIbeBINoMJ6LUIbfAzVxpJ6eNn84NxBcwI9I3WZq3W3xwKrHvnBbkBdL3PpTY4HiDpahUhD+DXWhzYqZaZyWSi+YzPyEThin0BnPD/BjNQxhtODIMp4/DYHJWiBrDJA9s7A7M+6/9M67POArZeqrvOAusFB34cBUiABDvGY2Dw46EF2yQ95ERu5IKX28qZSbw9CU3e25yst410SDbtXLBwC75QytmZndGw5Vv+DIRrDc5NDdKQnSnsC/2Iaa4wCn7ABF9gCUa4XW2gHGxwBWhQBWyAXoBgCYBwBXTHCHTOCIdwP0FjzfJNwDvFKFYDHVaTSfgtoIYECWnAApLZAS6QA1KSBWhrBm9wB3/wB4Zg8oYwCHWgBDegAiGQAQ42AUPXYAppmSP6fSVKvRWAhwyW2FZgcxvAAo/QtLUuAh9g9B/gASLQxAfJAZIu/2prtc5Rv85OL+mRvqlYAAU5jgW1U6Ro69pBluxNE26z3eyCF8kpXXvSPu1MHtMMDLIKt3pyswoCcbnhHg3OgPd3n/d3n8stngsKtMK7sF+rgAmHcAVQMAeV4AkZ0QZpgAVVwAM4UANMUAWAAHKWkCdYcAiNTHEITzVGkwj1czSNDDU/EyiQ8ggqK/HvQ/F4tgkYP7870DuEUAdP0ANhZUJjZQIt8AI3oARmMAiJoAiKMAhm0AMu4PIlqn02L6KtevM7n9gZygEs0AhoIOkfIAIosKGSHvWzipDZCwHZK8ay2nMUsAFVcAVMgAR+0QRLQBab5fXbCmRBTtJ+QOTMPv9ucQuUVQrt76P26QoQkyoNHKhJEyZMmzwtFDXKVKhSrmbhCnYMWjOMzZw1Y9asmDBfuWjRguUKFqyRtG7dmuXqkSVIiRxlqcMJEhomV5jMwIFmBgscNYoEWVTlyhU3d9wcsnNo0aFDiQ7dAQTVqlU/Wa8ewoMH0CKwYRc9esSIESS0aS3BbPSjCJMnT3qYwHCBAgQHDBgsQKDXLwMHDwJPyBDihhIzAie9AaLCA4cLEiBAkFBZMmXLmTVnnkDBMwURHmaIarSBwgYIHliwECGC9c/Wq0O3Ds1hw+0Lue3ehbCbNwUPb5kUKbKjSRU0ydGkSfOlTpgwY8bEoV49Dh3/PXqyZs2ufXuhQtu/W0VU3rxZs5QcOZo0SZJigQU1VUK4yb6nhg9FoZKIq9cwYQIMxhddVrqFpJJQUXBBBV1xUJRFLGmkqTrSAAQ5JqpggQYkWEAhiNWcYCInna6o4o6msrLDjkQSAeSrp7ASzw+runpRLBzNSguttSC5w4osrphrggUOIAABJBE4YEkEFlhALyf9cnJKBiQIwYUk/qhEkz+SaCGECya7bLIHNjNTggnS/IyCKgB5hRMWbrvNgyCC4IGKINSokwc++6zhTxpm+Omn1VijzbXWUJiBhiKycPRR5pRbbo0vvojOOuqmo2NTTjvFrrsZxbvKPFLRc+S9//baq0RVgujDbxRYTTFFFVVWaeUVWWSZZdeUEjSpJAeDRWUVB1epVRVTNoGEEUDwcKOKRS7E4Yc1anDrhxF5qIEGK3BIAwcm0qDKDi/asIPGQwBJJMatoNoOKjxwDOsRtdayBFZROMFkkSyY+LICyxpowIG89ppyygOafPJgKgGDAAMTenhjoEScaIGDuuyq7AHA9nLAsjI1S7MzCmqRhZQ0ZnAhzg044CEIPNWwYkTiai6Chx9+4BMHnmnYloZABf35Z3AfhTQNSdMoo1JNN6WOjqc99bQ772YsBCpSDyEVEUYoYUQSsFEFOz75MCFllPxkVbuVVoJ9pdhVUCll7v9V6q6bVmNrzdvYVSyBY5FG3BgRaeR2mKEGEZjwQKgiWPCABmxdyOIQCw8RDxA7AEFPLKvkDUResHiEiUdRSt/XiTgxoABkgf9i+HXYn/SLYAk4CMGJROa7Awi6xHzASYIfED7kCQCubGTPkl0kjSp+WFmEC/pFYokrqLD++hGZuP76JbIfsU7wed6hhh2scOMJo7Ng7grmmqv0i+mug1p+qKXmlOrssgIvvEPA0xqR/m2ta19bz6ncwx5WGQQTnODEQhjoibORghSmcIjaZIUKC1pQFalIxaxo9UFatQJCXmEDFZDAhBo0ImU/wAENUBCaDYwPKIy7wopa5JRFmAX/KujZnFgYATp5QYIsaWlEI0znhhp4IDKZeUAD/mIw2DUJSbAzGGAI5gAIUMAwE+NSEjCQlyvuRQLCA1nIKlMBNFaAEXhgwyLWgK0k0sARRfhBFYxyFDziEQ125CMfrfDHPo7ICkAAghPS9yg8tu99ZYhO/KrjNPpNDX/62194/HA1ABZCgGZZj0zeMzZUwSchmBjdWkSxEE/EClYOoVUGPchBECLrg60wBSbwYCIq/OCEdPSAazbgAttsoJfj+8EOsuCGF6UBE147xACdyUNohgU9ZKHmENHSiB1xYhGNg4xn0rQxJz4xdk6aIsOgpBeCTYYyeZGACYCQuz/cAAOT/0lnA8w4xntKII2UWAQk7IAGN/CgNY1YBA6CwIQ9OsEJV/jjH9HghD7yEQ1/VGj2KFpIRwHpkI963xfWsAboSGc60oFa/KRGNT/k7zuV9N/WyoOeFrWogDNdT6oggRBS4nSBCxnFBCnoSll9EIMf9CAqZmkKSwCCDUioAQ9wwIIdFGFRHKCAAxCwAeh5AAdRzckxkXiITXgNPZSwRNcoIVZo8rAskLBXvSSETUg0Igs2eIzqhDcBfBLMinqFYhQXoADAyi6c6AwMx674JAy04A0t6gFV7xKy4W0ssmdkRCK+kAY4VKEGLEBLFV6GHPa5IVLJQZqk0IBHK1QBoqudKP8TrGBIR4EBDFfYaBbe91GROtKRUesU/kC1UvC8a5Ndk0kni0vTVOmUlJbABCp5KsGealAVCwLhrIyKQaOq4hWtwMRXiiACF8xABD9gQZgggAACMIAGIqAAa0L0pys04g6NICtCLHHW5a4FmmS1FyXYai8AtxUtcEDdY6jqgAV8bHiCISxfx/lXwCogSg2QHWCGxwAjJakvIbDBxBLRgxBgYHj2XPBkK7OqRLyBCUFgA36ocCckoAELabCCadPABhyzAQ477kq8+slchYjCFBwEhBsm2r40pK+jHl1DbqsjHeuc1Du/FU9wx1MqUxVQpjRFoGJuCokX3bSBC4FuQ2L/NV1TKGhuDMpbLF8RC1JQbgck6ADkfnBeB3SgAxBggHhTs6EfXAEHTmCRDi2Byk0wF8Bn5W+A7YVTR/cIDjsQgQk4YLzfLUCyfL2iA5wYYQWEU3agBiwDKHxOKDFpYUpyAMRu8AdOJMIFGfhdA/CJz3w6QoVuWIQpZGEKNsQLyJsQxQRrdStc1aIWt8CFf3rRC2AM4xjTPkYzoHFtaAADEJhNgxe8AIbmpAEMWQDDF8r9hTIsbQwhHSmU42AHOsBbD9dRaUrrDVz/Yc2ljODyTCVR0/ckYkt3wEAABECBJxBCE85lSCgqOIpQhEIUoQDFJS5RimG1WRWt0O4rXoGJ/yK4wAUkoIB4EeCADTggTLnpzQUgt60izLcqXbNPzTeRkJrb6xL2WcvOb87c/K4lp5BIgw1EEGIMAMyJRRpjGPUKRlMLLNStkx2EI2xqhB0ASgRgEpL2ghcHUMAETmiEJpRgguGx08SVwUMgLuGKXRwDGM8GRt2HcXe85/3u1OZ73/k+jWlgIxZJZsIPutAFLXSh3FtgvBjAIIYtyLbdIm1D5S1f+RV9yt6h+s4lK6lvrqX1rGb1miMoIQlKTIISleCEQR4AANgDwOAh+IMmSHGKU6QZFbAiBScAQYVHBEINagjEI0BRilVs91ayUHYtYnGKNLjFBJ5xAAEoABkOMP8AvRfYQJxooNUauAEpm2CEon2+iVBswuLqf/Ry7WsJ+6x//an0PRBSAAIOgAAEGbAAGlcHdnXqNAdrGCnRC4GZEgmLktk5QCg5GL+gAMnRBEfogQ4AGArAgAS7IsFYgF34D2rDCL+bNmnTu7szhmEwQWMwhmNIhmTgO2ZghmmAhmPAhCDpHsTTAi1gPByULR58vDLILem4vMrbsR3bFN+qGqthqf85Dx4aPdJjNEabBAZygQCIPdgTgBTIgiTQBA4ahUtIP1EABGwiC/ChgkAIBDZYgkVwBeZLNpNJBaJDITrrPg54GAlAEu67ABTwgJ1gAytgA0CAP0+Av/RTP/T/s7lLADJI0ymbY79NGIVYc4IXMAEQwID96z80GhN1AjvhGUADDCfAEpgDhLAHex2F0b6Tu4AccARNqIMWUB28cJJOtKcQ5LsUvMVpS0G8EwZdvEVfTMEVfMFogIZaaA4n+IEl6ALGW0YcjLweFAMxkA7ogA4hJMIivJ9J4jzP2599S6snfMJJ8IQ7IADZC4AqDIAX0AEgsAKE8JpE2xc0WAQueIQgEJQ8Eb4PYIALYIEmwATtMpk3GwU7qIIgAJr22gAE8AAPQBICQDkUgBwR4AE8QIuEEAVLkLiJi7hSKMRGRET7iDibwylPWAQmoIEUCIFKzAD+y8RNbEkI6ES+//ILUZRJqiO1wIqiJFG1g4EAFHgCR0gEIAiBCSgsDXyAXOS7ZvhFpVzKX0wGY2jBaWsGFoyGZtiENDADJ0ACJAgDxwODZfRKxuNBaJTGaaxGa9QDbETLewuVzwO90NsvtIJC1mMBc6xLANAAHVABGygCN2gEnIurRngE4gsCERCvPFGDGUAvr9NDOzAFj3uFVEiDGkCDO/iuOIGAOEGAF0IBDwmKGUADbWIrMMMEiVulUkAbkKy5iEvN1czIm9sETpAQNNgsE0BJS1RJC+g/ydBEdVowAfS0mYy6T7PJBFwSctIwJVmShDlOTXOBN3CEJwgByUo7XMTFXPzFYshO7f/czmJgQe9UwajEiGSAhltoAzfAyipAgjGAxq58vGdkTyAcAyEcQjiwg+z4lGzUxm28Grd8y7FKD0bbEkeAAIMzRwBIgBUYgR4AgphrhE0oMkeAhEVQAzkgTBH4gBnIk8QkgAU4ghyggL74szQgBVVYBBrYkCTaAPJSSD3EqhnYASR4ETQIPphIFmJTpVVCm4nLyNJZzdbsUdjchEZwgh1ogRSgRP7TP/7rv9WpDJcUngDsNFFsHQNkAJtUTuVEkiUxAC7lUiz9UifpACXoAzO4gQ4QnrvAohTkRRX0xQB5U+6M0+78TqgMz2Y4hlBggyTLSiSAxjKAxh4US/gEwsv/wzH6PEIq00YlXEIsS48nXD1NcIMDEABKFYAAOIEV0IEjuIEnEE1/kSoP0JMP+IDcyBMqgABKJYJZ64EcSLkjYQAPOARM6JA9hB4ZooEN+D6eEYpGwINEZIP0oyBiUxsczVF8KR1knTjUJDbSsIIdsIEjDQEOsIAMUNLctADPqAzPaMkHaMkrmlIq3QvA+lJyPQAuJQB0TdcuVc4BEACuO4AHcIE+UAQlkM50goBkeEHvZEE57ddiYMp9TYaMuAU4YIMseAI66lMxSDdAdc/HY89oJNT5bIMivE/8zM8k7J+WcqnQg0K51AQn4LoCMAABSAAZkAEdkIEjeAO/XAQg/8CBCxCNIDAvBJgBPdkAg8uAIRCAB0AACuiAHYABCiAAAfBZEigCESkCFNgBF3hIFMgCHqiCJUiDHyq+nROFTcA4USiFDFKFCvopCjKz0tFRU8BahaBBG3gBI63NDlBJa83NbF2Tz8iibd3EwADOUXQSBVDOLu1bA0hXwE3XAWjXwSVZARjckV0AEOgDy2IB3nCAjnhByU0GZOBOYfiIf8VO7WxK76S2UjAKN8gCJKCjhU03hgUDhi3dP20kyiuXiZUy39KfKruaz3spLPNYucyCCWgABYiAARgBHfCBIxgCKRiESnCRP3ACmAkChESSDYAZETDHAxiCADiAHrgAn/9dAKDtAQpw1wNwABSAgZrJgR5AAc6sga5YBDhAA0i4BCGDiGFRkKBCFqCioIeDlblxiFHwBEzYnbSNVhDogKRT0iXVGArQDbldEyd9ySYSxYPZUr/l0gIogMAF3MG94MGtVAE41wcAgSeYhDpwXIL5BWL4BRM+YRT+BV9YYRZuYRf2hWCI4Yy4xWHYhYIlrTRYAzdgWNN1vK5c2DmYgx8EQm+bzx2zWFChg5SSDs/LWP4sFSZktCfcEk14ggoQmAQogJNVAiFQgSH4gj9IMWxSAyoQAfQ6kjwJAgQwxx4ggQUI3wfIAUnIgQyQgEnogSLZ2wTLABTIgSJQgiewIzb/sAQ2+MJQoCC5QT652dq5CVtivd+vnZvSyZtUcAQn6IEUeIEUOFK27QD9u0RsTeDJkNsnbeAG1FvlHFdznWAKFtzBJQAMjmXENQAsfYAeUIQPozMWNAZkIAZf/mViCIYTHpAWHpAYjuFfOOZgyFdmqFwTRAXlcIOPymHTTd2H9UGGzRQoK1QhvE/82ZR1i4NLSsK25Fho4hq5rIQ6eIEQuNYjQFkZOAFOnRhAcIQznAFUNUcWGD4EoNQOGIEFCNoM6AEYGDkXMIE/ME7lfJID7gAYyIFDkFAHnRtXWAtTwLiMm5tGDipXQhsL0uiIWIVU4ATG0GS15eQQ0LNPxk27//CNBK7bTRQeKn3gLTVXCYblAUDXDD5cWZblkaVl5ZyAGyCESXgCD2BKYviIN+XFYxaGYCAGYSjhEwZmZnAGZejlYOgFPKiCLNBhHPsoP/1TiB1raIwDia08Q4WDyktLtKSDdRsDJeY8lrqkUWnUjo3CPbCsGwgBE1CCLzgCJTiCIyiCJ0iERhA+KmjeI+GBGbgAcywARfgdEkCBOwhsFXCBCRiEDHhXAvhb40TTCwAXQNiE3DMFUoC/h5gVV1izBZlfNCNW3csgjjMFkuwBI9XkTTYBE1BIlCTgusCAjNkNl+YNymDgAXQSCDaACdbpV97pSu1pDJ5goFbOB7CBRP+YhC/ICKl0yhTkbl9M6uxEBvEe7/G+amR4hmdYhmVABmOABepBN6RhAzdwg7BmzzJ42LAuA20OQstL6zZgg/n5FKjRA5ISDySspPHoH0YNvbs+q0kQONuDBKQABOfYg/JwBDfwAzngAnyejJrVkzUegABQgA/ogCZhAIKmCyKwAa5DV6tCEnvyOt6gATzwhFlRiEc0hVXQPQZBluyildbmcdke6TR42U3WZBVA6RBY8pUGbuDeAN3IDVIWE+POC5ru2+VmbuaG7gsuAMSVbiwtEgdogTvgBGc4c2eQXGZgZjVnBvU+c/R+BmmQBmqghmq4hmvQBm3whm/4Bm7IBmv/AIUlsK0vuAI0kO81wGaxvm/7Nl1MiQPM+282oNi1NmtNeRrqmJG1tLJtpGsseykAVQ9N4ATHrIVWAAROSIVU0gRKOIRQ0BPoCRMRKD41JtrYC4AMuAEVWAADwIAO+AIXT5gOQIEmyQEWYAC6RfYDfpwylyCfSjNXyLi4ya666fFa+fFWagVSWAQipYEWMAG1VYEkr02+7m39w5gnxw0pn/LH6sRT5lsJZmUvH4B5j+UKRld599K9BeoFiFczqPNqCPiAx/NsKPht2AZv4PN0WPh0kAd5mId5qAeJn3iKnwd5cAY8sS3ZMk9KafQezu+xxJRIN1TLs3R3s3RxTqlx/5brKktwc06PLSFRWbiF/7C7VnKIVSgFxPwA1FADUACF8yLaczRHAVAAFTABBfgCBuBQEE0ND4DVGrgAlAMOZOcLLIKADvgBSLg9HX+bunEQBbGbalcQvGkzSuYEnCjSb3+BcM9t3a7NT+YAuccAOYHydZ/bLKIMd4cieI93ViaACZble1duvz0ABfhbDtWLCTABiG98x398yId4iaeHfKj8fNAHzLf8eQgHWJiBQa+UMmiDNViasRZriE3d+JxYioWDTMGUS0lU/SRnTDIPrOmaLRkF7aL5ZojBa8OFWngFU3CFV0CFJUABUp2BnwcFfC5aSi3Q2BuAo3dXEL2qC/84Eij32Q1YAAp4gO2foo7ZgBpYhI17BWIhFlf4evQXe/NXf1UIw5lRexOwARhQ27U1AZQ+d7nP/7qP8rnVmLzie4A4INAAwYIFDhY0cPAggYYJDxAUKFCBggEGDixwkHFCPnz1PtabR28eyZImTdKjh09fvnz6Xrb8mO6aGh48skj5UqZMmixfxIABI2Yo0KBCd5YRQydOnDFOx7SJ02bqVDt2psaxQ2crnTFxturxI1YPWbFjzaL1UwjQ2kOLDh1CBHcRI0qaPKlqNWvXsWjTpjUbBmyWK1WoTIWiwuLDhyCgHsMCReUDAQEBBFgOoHkzAgcEIGxAgGADBNEOIFD/gODgwQICChY0WIAAwgUOOJhwavWqlavevVf5Du57FXHiqiBZccLERgsTJmzAePGiRYrqKlI4DwGCA3fuHjhsCH9h/AUK5s1LkABBtQMGC94vkFgwQcL6CQlElAjxAEX+ChpYdAADDzwwoD/+5PNRSSCBNE9IIS0I00figGMOOBDK84saVFQBxhdfZBFiGl9sIdRQJiZV1FBIsTgHHS4u1ZRTVFVlVY160BFWjmGlJRYefvyIByCAuFXkIoDQVRcmnoyiyiu39HIMNFMeA8wutagyyiibXLIEDTPMAAoqoMBSZmQ8hCbAAJhlBgAAmgmgWpwsMDAbahRwAAEGC0jQ/8ADFYQggQXprecBE5i0IssrsszSaJmvuAJppK+8ApwrxHHyRhZJANHDDZ9KJ9111TlnQgjadQdeeKuSd15qFBBIYHvuwReffhA9pJBBBeR3q0QLvAYfAw0QS2CC9aQjjzzJKrtsOt9Aq4022WSzzTb1SFiPNtQ8o8w11VCTDChqYLFEGR9+mIYba4QhBlLupkgUvCy2OMcc70IFBxxTwXGVF21YRVZYPPYIJB4HCzmkwkMemaQlm4xiiiuyQCnllMHsgsstr5jiCSaXUBEED1TAQovJZY654QwUMMDmZgK4GQACDX0Qmp3jbXABBKw1IIMMJzzQQAUSnAdBBzVY8v9KLY3OAsvEhSU6aXCnNFKHFEkM0YOnn94gXQujlmrqdqmuGl4Grbpq3s4OsE1rrf75OlDcE1GkAEa1MuDesH4SKME131wjjTPRMJNM4cUQIwwxv/ySCy+P/4JMOBLOQ40yyxDjjDPM3KIGG1QwgW66a6wxxrzvrkhvivXei5RUNFKFBcBaCVy7VVahhTAgCS/MsMNMOjkLLsAMc8wxvWSMC5aebLIJHFxQEUgu01OPSiBqqBFEEDOQVhlm3meGwAUzr6eazgzsbEAGQ5wAQtA3hMAeCSxkgEIam4jiCmG+Od0bpZASxxNr+MLViJA1roFqOtbBjqlC4B0PdKADqtr/QAbONp60FW01bctbrYDVH4G8524dHKGw8ta21TwgPekhhjWmoQteBCMYvpDhLnzhi2H4ohe6sOEMkzGOfCAoJNdQRjP6Eo1jhKIKaGBCEUSXhiemwXSqOx29VnQvMbSORa+DXRtkZ5Wv4GhHeridHXKHMN71zneMeJglRBG8W+AijnKUhSqY94hA+EEOpWhcKUrGC1qA4nrZE9kMLhAf/AygALJxAGkCQADR2AkCC6DAARoAAxVYIAIRyEAP4ueACyghBz0gwQU24IE2lAIVZXLFKidGqVa04jhX+MITkmDArW0tVC9IwddUkJ0QeACYEOSO2SqINgzubD2ymhUH/98TrAborZklZMAGqYnCWKVQhRJQ3DaaMcMYfhMYvRBnL6A0zmM0Ix304Ic/6qGOajhDMFXCxSJ64gQg+ORDpJuK6U5HxSq664qqK4NU2EAjq3gxKjniCllu54cymtEOd7hD7xK2iIsyghGNsAQnRNGkRdVCebVQlClEcYlAyEENsEgGL9QwAzX0sRTjyt4MCIkCGJhAIATACGgc8KbLnKY9pTkACVDQARKk5wYsQAEFHJCDIsCgBxZ4AAVQgAY8BEJMTYMFYRq1m1aMwg1XyEItj3DLGxywa9JJgagYeKpTfSeC4elABS1YngumrXzle4AG2ebXajLThGzDJjZVqP9XoplnGME4BjaG0YvH3uIWtRipLFqxClKQ4hSnkAUttkGPA+VjHrwoxSPaEAg02CENV2ACp/L5hTW4ISpE2Unr7DXQpLDon2KAikFtNJV/YYUrX9kKGR0qlttNtHd2QONF3YCHiy4CEpgIhSlUoYpVwNIUzXvEhkDBODX8AExBCMQl7ng9KvAATPsyqkbeMzMCaAYACBBAZ1pzARiQwAQkgIAJbuACGFAgA6E0QQYOcBoatAF7aniEKs3UKEW1whJVqAJZlZCEI2StB2dNoKh82UBTxbUDFIxgXS1oQQxqEwISICyLr8liwmpTheg5zwUwUIlEwOEUx4BDEEK2gxz/wKBr1AnmC27ghkdUgx0H0oc5nuGMW/DgBz+AwhWK4IQk3EB0O2HKbG2LFHuB+bYD3S1VfAu74ephuHQoLputMtHkTtTNvVPXG/QFiEY0ghMdJUV1swSKO6oBFLrQRSBm0IQmABkGTTAvHEI23iCIoGbhaU18DEAAth2AAAO4DKBCgALQDGEELOjABZ6KU7tNkgbae4waAhEKVjJNFrIwhR2YQGEpKMHCBhwCEYigNa2p1WseLhUwuxNBEtf1Askuj3mYjcFnp4dArsKmq9Yj47SRp5QjMBUHSFELGoiABCEwwQhGAIIRpMACKdCBFBoRimuYA7TjGIc3sLELOWih/wlIgAITRPkGM6CLoHSQV27LMIc8INzLYsbX68xMI4aCZc1tdqhE43wHN795SHC5Qhpg6wZAJKIRmMCEKEghiuoe5hIpBQUvchGIHQBcCVBAAg1oYAdGBIINrQbFDETgAQ+IgAp2WNkjP4OABhggAD8tQAU4wAAa2AAELnhABo5QhBw8IAAHQIAH0ksFVDwiCK0OBVcf/ApOTDh0uLYwhodg1gz3QAZFVmsLmkPsn3+HAx84donpumwK1DjbzXb2eSYwgWcjHoPZxhkFT3CDFuwAB7LABRqAAAS0yuAGPvCBDmQghUR4AhbbUIc++BFadoSjWsB4qB3c4AYRuX5EBv8vg1COAubb50Ggqju4l4EShi1y0StcGT5YIMp6hwLizRlP45D08AdCHCLkjoBEIyDBiYipIlKuuAQXxmsyKqCgB0BwQxXwwAIW7KAHP2jCEjbxCDSFZwaPKEUoQMGD8YkmM5sBAJswMAIVZIACfIrWMICAXAAOYA9pac/OqZJk1cIrLMIVSCABWdiFmdXbARsCwYALqMCwNZADcQfflZgxHRPhJd4JQhuNOdvijYcOHEESNIIToEEtAIMbOIEZHIESSAERTIERGMETNMImoII2sANL5AM9sIM6hIM8HMMitMHBoEEVqEvs6YS9ENzt0ZZt/ZPC7cRQeAUXUYXwhZH/mjUURJGRWCSf8jGfwqgFIRCC9DnCRm0Ck0hMpYCd2H0fDQCBFbwBE+AB6GRBEfRADvwAIzwCF8wACtRUKcjUY1yPCMCXmghAAaxJAVxGACSABShABNwAdITAIyHABywBFQTaIEUPI86CA56CHVQBE33IE+RaEljgrmmNz3zKBnKgL3nYqRibCFaQ3y3b4qkg4OEVCiqe4BFjtoXHEQzCH2SBG9wBGgzPHkDBFmyBGWAjEDzBHXBCKnGDS7AEO4hDEn4DLMCBHOgLGjwR6bjeh5TBHryLwYVZFckj7tWjbTEFGJZZ7RBXcZkF7ojFHyjfHfxBIfzBQT6fGxJCG7ph/yLEYfU9zMlpHyzUwpiUDHilwZBYQSPcwRt4ghQUgdXtwA4sgfbwwCXAwpj8GSjQAiqowQfM1wIYQALQ5Jq8jAWAQAdWAH0hAAusGipoDxVEDyqUwixMlixgAhooRxMRECxW4IXRYud9ig24QN35kt01UAge21YCY12VTc4Io+Cx4FiSJXl85aqYwR4A3B64gSPcAQ0iAh8gQiFMAiFcASA8DNl1AxAhCDuAgzrIwzPkXCDgARugARygwbq4wRvUgU7sgcKBWe5x4e3ZC8JZZsLdy5qVmW8FjMD04xmyHloI5EQhpEEiZEISQiG8YSKwpkPiWUSiQqRwFTAcgy/8gv8uPAIVLEIjAIIbVAIhvIEj5JoSHAGGJQEMkGQpmAwqjAkq0EJKBhL3HF0EKMBMJsCmacYAjEAHZFqcgMnXgUJQLhgjysJRAoIVJAdTUmAsQuWuSWUnVuXXmIDdvdV2cCVXZgCyVdAEscpYlk1ZkuVZfmUikIInaEIlxMIpeAIpDAM0nEIqsAIrxAJI1cItEEM66ANoqQM4hMM30IIayIEfwIFhrkEavIEb1EGK1oEbPGYW2dZlVmbuXeaMUiaMMAVTbAWODl8ckAVD1U7tBORAEmQdECQhICQhaFwirKYjhNzDjEJsctUuNCg0RIM3EcYjvEUl7MEeVEITPIEUmAH/cUrBICKBFyhnLjzn9LQkcxIlF3zABTTAfyAdfQwARQxAyxDAB4AJTGUP9mRVKKCCUdbCKrCBFaCBEqjn2sliexrQe3biBuqiW4EACEQQY9znpWZAd5SYgH4l4zHef3LqWWaAHAFDqZoqMGADNpSqlDhW8UCDNcyDP/TDP+SDOFzDNTjDI8gBG7CBvsBWxaloHWwpH/CBZF4msR7rwc2oZeJeHngm8QkXjvaoj/6owIzmQBLpaR4kRYFcQ8ahdAFPpEBJ8TRDNFhDqmLDLYACF1gCIhDCJIyVT5jBFExBr6WByMAULfBCMjTOmsJCLkTGElyAA/hHAhRABKiAAggA/wHwH2iESSCR4niGAsVMliiggaE6QaI6ZRKwXa8NgQ7owNbcAKR2IAOJDaUyRsqqbMpuZS/6YqjCbMx+ZQYYD23S5pRQCTZsAzRIyTEMg6taQz3I6j8w2TVEwy1wQRvAxR2w6B4Q6R2kKEVdnB8gax4QKx8cXNUu67Eyq2XyI7TGCJuBrRjpwUBuKdQS5LVeKyB4q0MuScSIqy4AA5VOw7lWCzZEQy64wiYsAic4QRa8wb+BqRQ8wRNkQblEDywEgzA0jpquaW7+gAgETZz6SQEcgNJdRk/+WfaQIiikkqC+QiOgwcVmLMB9COHmGiy258cCmw1QpQtU5XUQWwiQQP/t2m7tMgbuHhveuawEfWV3yKyAEtOqlBjPBobPkqvFbMM3AIYvGIPxNMM0CO2s5sM7JUNiuJnTOm223sEecGsZFau9IGuMbi1mWm2xSuZOjOGNjkGONsVXaIVWjC1YkMWWeq/y3a/yEcLTAsJBEgJvyuGCBg8ujFP06iy1WEuqGkMpQMIVuAEaZEElKEIfPMEUSEEWYEJsecEiUAIq6ALj8ELjwIJMXY8lLAEFvAeB8IqmdScC9NiGjGcfHWUrwIG6oEGVqaXpoi7q2pLH/hp8/td0yG523G4R327uvhXeRdDPSVATc4AT+27wzhV4ZAAFWXEGIE8vELAcxVEvOFb/M+Dt9OzCLvCCMqgTaM3DNeTChojF1SLcY+4Bsc7BV/iB/dqL/eIxHmMhbc1Ljc5j6tTji9CBZCor+SIc+motsRYCH8QxITAy1NbBH4BcI4RcI1DC21aXXhDwMJirNXjyNSBwNmBDL6DCJVSBlQFB5xnBp9zBhAXBHTRBEVBBKOirCG9uKc6ABwDeAzREZ6zHbHwnA8ZmedaCKaQBHDDtE/0buqxdLHpsho3kDghZC9iAWu3iqYhbNhcx32nHpE7qpcoVY4CqeORMOZdSKc2ssl3xLLzCLMhCpMiaolCMyfDCNCQDwE7PL3TDZ7VTGksGFVDt1aLvIc9oHht0Hu/x/z1SJiFzoUIbnLHCqCGf7yELtCIz8vYiaWvi2RrNIfbpxbhGbzRUgzWAMrVkgydDwyzUxA4QQS0NQRLUwV2mQSIowRMwgdjRMprK1CPcERXMwPmxQFPNRtnMACkGwp8yJ1eNVCh4gUS9nomaLi2lbsfeEhBEcw+47g14inTAAC6GTdjc7lZ2MwhoBzhXqjiziqT1JzpvgFqTczlvQCr0WR1OTKPQgi7kszNUQzMQQxmrw2fpQz3IQzKoQUkGtEBjprLm3kEz9mMmtkT78Tw69ENXZtVGZsIR9Pki8tVuaSQjafRFX8hBgiVgQkebwipQjC4EgzEUQzL4xUjfqif/xf8uuCQPMEEW/K2RDgKSLoIVZAEg2AEPBFpKMqIrhN1P48BPcw/QiYAitlog8LTnxmajPKAl2EHyPfUyN+VUd2zWWPVIduIAqhUCIRB0cGCpFHE3v9VW7h17r6zKnuWndupby9FjCQbx+KyUNEMzMMMySIM1bEM2wFs5EO08yAMsLMES/EBFu7Gxhm9jH3RE855iM6sfyyNm0paDD3REZ/b5iq9AO+3zaRxcVLIjOAIlUIKTrkI73wJeq7YxlGvdjvRI/0UwbN/nAMKB9gEnrIElAMLIecLnXMIs0J8qhd32pJf2fAmYzMASHPVjeG4fRVYqvgIj3NlEZQFUA5wU7PD/xhqQ5X13J0pHVr8ALsLuf3HNBp4fCjiH7b7VW5HAUeHue9P5yr41zKIzzk7JNPhFNPhFC0FD3UaD5kzDNXgDO7wDrc6DNTyCgsMAg0M6Z0N4HnM4Q0t4jF52YnctYsMoRVM01mo2sXaviIOcRuNZIzgCI9CFJVBX9pUJLdxCDcH4a1NDNVSDNFSDn+vCLIzCIkwC6HGpI1QCJ2ACF3CBKwBDKCyBF1jCIkQselEBDtiEeEE3lD8GKpgTHBk3nk0UndWBDhfuerYnEBSB5WH1dNSdEH+1CXSgh7EA7LJAm4vbm9OuEdf5vbs1fLv1quw5n//Fv2PDXwS8NUSDNPh5/zVogzjcg6K3VIKzwGFHerFe9KTjcfleuqVbvIxitqdPtLIm8rFe7R9471qUemifOp6JBQfPoSkQpSql4g4JAzPg+ox/C7VgwzGswiYwgikwgiZIQiKkQiNgARugAi5YAhtgwQ78ABK0mhrgQaNN+0tZ+06Xwi70Qg7hwio8AvVNVOCmKDae7hOIu1kRARAwUaeACnNQRwc6x3mHTQgA9VK1+dvXuxHPOb7Dd3jke82g9QYMvCdTCyjLtmzjbd3WrTaoQzwgyDaEAhtUQRCwwCEUwiJHPLHugWoSAsXvwdY2+LJKdPmOr2VWbehz+kBXNh+IPLeC3CGUOmueOlkUAv9dYAIneAKrp5L+wBE6/bk1CLi13K2Nh4JYVMIknIIXpBTFLMLFMtEOsMH1LAKWboj2ZNVjpBJk2FAwOBbYcX2wfrsO5wTqdqzZl3vrTnPd9ZIHtrsKoMD6s/lXFzF62y7eyz+dt3XAY0MLZcM32Py5enL/p+o0AAS2bPT46avnLBAcKzNmHCr0kE9EiXnySNxDCOMejRs5bqT4kWJEkBVFfpTIh+KcOSRZrgxpEuWckygr1lQp8U4dO4B4JjrUM1GiRkPj6PFTKJEjSJAaQcIkytQqWLN6ARvWLJo1a9m2bePaFVuyXavwoPGUhgqeWrPwuMmSxYkToWvsQKL0KJD/GjWgSpVCBQtWKVi3evkK5guYqaWJ/tSp88WxGTNfKEux/ETJkyRHiABxwgRIjx43brywYeNFC9UtXLR2oQJ2bBazWaAwcfs2Cd0kcJvYTeJDcOHDiRc3PnxaNOVYmw079vyYsWDNkvHiFQ0Zr2Xm6OWbl+sRpj9suDiU+LDQzIiFNhLq+H5PHpUpXYakCfNkfZMrS46cSFI9+gD84447ACmEkKASSTCpoByhhBFGGnEEkwox4YQTUUYxRZVXZKkFl12COSaaaabZKpuvvtnGGlpACYWKIOyQZRQ0dtihBhZ2uIOQLIpoIpAg9wKFyL5AQWWWW3bZpZddcAnFkqH+/3hjDzMim+wLKZ7QEjMlOBsCiDBFG+2FG1BbTbXYYOuNzTZz0w23346b07gNhNsAzw9yuWXPW2iZxUlXZFmlL8FQyeWXZ6gJRx116rmmlEsg+cOO8iCCSL312oOvI5heGsm++0K9D6X+Rh3V1JIk8mMPOwxEcEGMZMXIEUcQCWqoWp2qkJNQoFrFw1tw6cU5rKy55itvuMqmmVseCeKRWjapopErcihij0n+8CSLOy655JEjUeELlXFRUdKXdHu5JRRMpLyjyj7qkAxLKbJ8At8kiCAiCTFFM9PMF15wYbXW1FTBBDV7Q8G23nhj8zfg6PzAzokptnMVVVRZpZVWOP/2BJJRwCUSll+o6SadlNWZZx5eHtmEsTHIQA/TTPlozz1OPQoVVJBEVUmm/+wbCeiiAewZVD102glBQgr54w8EHyLEkaGsvnqpCzMcZRRUpEqSSV+MaeZEZLfRxmxrmqHFlV1CwUKVOnooY5BMFNGkDk/KJRmWv/oGBZZd0k13l1mgHCqRnOqQNzLKHOfSS377HZM00k6jAXPWDD6YcxNqa9hNh3UjbnSL5/SElVROUT0VWUTZhC9YeJFGG3nGMYfRceZJZ5tSHrEkET7ImBk9m0/SKCOdNfIZaZM+Mvp5oEWaTz4xxCgDe/1ApV6+Oeho1cCoH4K66QSr1nUpSM7/VwqTTTK8xFdUXHklSXTHjqaaa5DVvxqtTtTlEqiwgxskkYhBaKISgDCFX2jBi1zQAoJ9KwUtBueLJcliE+pzBGNy0gfGSYYyk4HcZpzQL3/dYDSnqQHmaAAD17wGNptTE20YFjrcoGA3ptPhBz7RiU/EIhWmKBcscoGMa6RjHvXIR6PegY91sGMe8vhFICyxiELEgQxyOIrxZrIH9ChvDzIBWkrkQzSXFK1o2RujfNRYhutpb43+KYkeChQ+8WnkDk1DxAZrNYlJSAKQtVKKJQi5iW9tIhR+kZ8rZjELXfiiGFihhjWqkY1rHOsaXknGLS5hCUrQQQuAiJD8UMGM/2j8wjq8oEVfdHEYwukCFhl0hCIYA4jFMa5KkxEhvjCThBKaMDSUM9MKaXAaGLjwhTBUk2tmU8PQ4TCHwpHYDonTQ0+coi+5cMY25JHEeujDH/7Qxz3a0Y510EMe2wCFHAJxiDZ4AZ414yIfaAbGPcRkJfPh3hzUiEZ+Yq+fQGsj97pHUPxYZA91FJ/TEsogRvBRkBGVhK4IiQlLfAt+iUSFXxh5i0fez0SWRNY3SIqNZsyik4togxw2AQtX0MIZzODFL5AhDFqEAhW+GMbgdqELV2wCE5Og5R8AwSMP1iGXX6iXlpTgyyT0qzOhCWYPcGCDGtTgNDZA5gs598LPgf+OTdCMWDSpKRwihYIWysgGy+pRD3q0VR9xzUc+9hEPfkQxGWrAw07Y4AU2oOEo6bEZgL5oT3wWtAxozB5ArwdQN77xn4ltY0FTklj9GJQieLRj+QqBCM8+9FaKoGUiEMGI0lYtfZgAxCIW8YhDhuJFfpmKR8WmHBRl4xvpIOk3spGMXKDiEoFABS1gQQxpZGemvy3FLILR3GAs6Rar4ERQh1pUQkCtD7mkV2WYGpen7itM/tpBVW1QORskE73JpA0LYrMwhr13rGUdTi6WcY1xuBUf/HiHP+4hzrjqIx/64Ec+2CEPeaBCr3dwAxvUwAY3BDY9B7VPYcHIRoGKQaD/jmWs9ayHPQ4z1g1zqEMZwlgGC1c2D3pIcR7oUIY4eG8ke6hDgQABNfI9xLOHOIRnFRSU0jKCEoBMnyV40lqMgsK15PqaLkSElWlgYxu6JWlXvIKNXRxKFzRdBjKQgUpa/OUWwwiGdKCLiulWYrRFHcQg/pBd7YLwXpn55b7oHF6qnoY0ObjBMV2w1fSmVwXsZYEJ3lvo+Mo3OOyIKz4I4o999APS/fAHP+jBjrnWY3fyiEaQeIIHT/PEDwGaCYAm0p+J3IQ+kdUwhxu7YeuBAQxvrIMbZixjpDrGDbR2A/b2kGs79DqhBKrjsG1cbKfBirQ8/jGQgUwJZ1PCEu3r/2QhERkKXylSfo2khS56MaISWUMgVN7GiljkDFTmIhcz/QUsBXOLYzTDGMKw4C1MgYlKTMJqah4E4+ZlJREytambofMQCB5MM50mBzk4pp//7NXZuOBzXx2rnIYzTdP1Yx/74Ac/8HGPeER6H/egx1vbWg958JYWaggEHgqEB54AItQ2E6yoTUUfy6pEw2l0LKs77OHGijjXb3gDrXGda6OXwQ1rWIPR3eAqO7iK2MK2MUam5uNlRwjrEXo2IblOyEtsAuyIFEUphLgKV7hith9tBtm0kqJtKMvtlnwGcn/xiz218jnS0cUtZjEKBFatEYkoqgHbfKV5cVcJiW8qnf+JQHCCj6ZyCVc4nxuu3oev96sMm3jpgmPxifEjHk9kxxObGE5Gs8yb8sgGMnKRl5W//OU0U8/MT4IfM5o4wxr2+fXEAGsOx9rnAHUDZRzjOMcePelLN/oAff10pzvfVbDX8SIitIir5YopS6moRbvePguBHSqmEH+50E4LdPmCGMyQBjWQlSJtuF8b8b8GNdYfDWckQxjREca6b/EKv0+iVgKvxoKi8Prt8CoDM/ClqY6AMwZuCCDvBiRv4VyI4SqvNdar0DRv86Rph9hh5CqNHRpFH+ihUaLIG/RHUZaBGGBBL3jCQF7uDuYpU04FJHDueRjrn17N92AN+B7rsWL/zXqGz3GM7/iwJ/maj/mYrumYDnzy6EB0jLSCgrVYayiyDxK6rvu87/s8QUM2ZBQ4qvxuwaNEJBmkYRqqIX9EKv64oRu6wSuowRmQIZKSgRj47xU84d4CsBEwIijY7IP6zXHw5TICrgEb7wHHRPImbwIpzwIvEPPga/M8z3Q8kB7moVEaxRxSxhuqITty4RmUwRmcIRpAIQiWwA/gpY4GaLCMhwZTLZ/4SQdzsPd20Pd2bxaBsAyG8Aty8eh0D+mIzjGCcddoDTJkbA/+4LqO8bpmBRB0bPoipLSeDdqyMOyiLew8gQs3QUPGD+1gwfxygQyjQRrQMH/0R/7mTxqW/4EOqaMYfGFPXmETNAEAA5BBYqUjsAQBAe6pjmAI9uUQx2QHEnERB5IR/+zhMjAS5aseQpBl5CFl0kEb5q7ufoEYTgQbrEwNgoAK4MUxCkQVZ5CLUMVUcO6xeu8WeRAM3Mj3Xu33tiDWwEAXd3EXdy0XiXAmjS4YR2wmi5FHkNEnlxEZC8EZp6+0fgxCpnH72gfsrDHslvLrfKVrCOVrxlAY0u8ZylF/+Eci5TAZjOHcaOEVMAGB/Khq+DBWckYj4OxeBnEBieBL/lE0AlICCbIgGzHzxIriyioE1UETUyQbqiEUlcNELhIboCEUgiAIZqBAOrKOVpHmymhoiMbneP9wCypTC7SgMrfgJGGtMjnTJcFgC7SAMmAtJr+gC05TJh2n+JhuDdIgDZSO1qKPqMKnqO6AqPwAD4LkGakP65zN6zDq6wzp64DTEh7hd+Bn7ErB2voCMGghFx6pGNQvDbfhGqrhGWKKGYpBGA5j72ZhFeytEioB8BYkKGTlHh/HXrJE8TaDAQ3x8XrgRhJREemyER0REiMG0QxsE6UhFJmhGUTRRKxhMKHhGHCBCnAAB2rgDXJi2O4g5kYNVVrijEhy1UAzNLXAQi8zMzuTMi/UQ0PzCmDtMmHyC1DyMruARGOSNV1z+Z4OD/wAEOyA5aDP0zxt5QKBtQ6B+h6BEXj/9C4uCjgxipBcC1yM8xEgAaOEE3764qXMT0SYwRkm6ZKqQRqWwxiMwYJ0YRZcwRQkwY8AMFcUxDzvsV4qQ/G8ZB/98R/jcy4Hcj7rE+I0EC8RbRumgTqgNDm2YhsIMxqGARhwARdIweXSwA1csEH1ICQPig/KINbywMRQQvduMTQ90yUrs+d6rzMxswwqk1FlbPjKoOhcjA7soA3awA2uoA7eojVdkwlatQqqgAmq4AqWADE1kgqWgFZrNQh4oBR1FTGXgAqwgAqooAq4AJ7YAA48DQ6WlQ3YgFSb1QuwAFnVAA70IhDwIi9sVA2M09r+wjkpksuUQRmSoRhQSRf2/4S4SiEQloAQ7o0sEac8k2cj8DFL2JI9Bc49AbJN6XIRG1EDdeNfES063k1AraErvgEbpgEaCscVWkEWMOgO4CAN0MBQh03FSA1CayJ68qmydk4HQdNCOdRCPVMLokALoCAKLLT3UvMLmK4O4mAM4AmeRPMt0uAKXPMKclZnJxYL0AAO0KAN0GBi0aBZifav0KAKhhUNljYN2gALmhYO2oAN2gAOitZo0SBGeAAHeIBrEXQGaGAGthYHGOJrubZXNTIQjsQb022muKxcHUgXdCGCXIER/gCB7o0pGGERxBQt51UX7XUf3/IBiwA+BZJf+9UCJY4E5lS+sIIwL9JEjv+hF2rhFVIhFTghFmqBFAABDnItDSJ2WeGgji52aAIk1Xpm1X4QJTuUUjO0ZJvAZDV0C8YAZscgDE5TC7ygVOGpVNvANQk16QZId+FARlkLEFwuEVyuGRdhJ+7AwZzODQrkDa7ACa7ADQj1Dp7ODYLWZl+VCZCAB2YABWqDBWaABTxABC6GYi7gAj7gAiCAAiDgAkSAB6iAB7Z1uNKNGLgsGZKBGf7XP6Nh7Z6jFRhhLNNHb/m2b5NqCPXxqfC18XqAcAtXPg934fqM4baqmTawrCzyIgl0GHBBFir3FFiBFDiBciEBDjh3YkPXDUS3QFSMP0zN1Lpne3aOsVb3JTP/Ewh1MDQn1fcq8zS7IAxs93Zl9p2wAAu84HqBt+nSwA5ws8h6wkDuIHF4wg2GLguu4C1O9QqKAIyRoAhuBEF/AAmWAAm8lgbGliE8YAPKN2wZon6pQOWu9UUSCTBoq7mE4X7sjz+l4RkC+TqdITn4MxmGYRUMuBIwAYFvhW/J9G+7pKna0h8lOC7l0nAXbj4H0jUYsZnwEj93CA2ZwYJe4RVqwRZYoRZi4RROoRM4IRUwoY7cQGhfeFmF7g7eQA/iSHtS4meo559gUbJUkgdZrYeN2TNNsgwwMwxOtguitQqaQInhSYmV+HuZIA14FwtedQmEVYnbwAl6wDPCGYxh/0DhFM4Fxrd8WUAEWMBrUcADPGAGfqBWrTW2ViHbhKUwRuQYkgErBFM5RFE5xFEaoDQUpQGhATmQQzEUFQWhn2HLYOHrFnkpNqjHEEFe07JM4yzgCFFNJ5iCM9mcN5k+mUlxJ46aiCEX+kYVUoEVStgWYuETTkETOIEUSCFx3IKWmw8OFvQN6kBANhaNzAixJKvVSvLnFGuYOcxSNXMOMLQJkOAHpDmao7oJmuAHcOAHfoAGtvoHikCqg4CNUWAG2nkGeOB8UUAEOIACNiCe8UQEyJYGlgAPHqG1cEoqGGlYrOLdnCxABfQiwa1gz5Ac0ZD+1o8aqKEaEvsZElpREv8bshPbHNsQHLxBWTgJqCyhoi2atMZ0Xjca4CZ5ARtwCECaTeVTpPlVvQyNg03HckvYhFeHFWKBFKqGFEx4EiDjemnZejs312TMDGqwPvypZ15RsSgUoHAusi71hy1zC2AXDGBXC5CAjGlgNhB0bGnIA9Q6ntFXBCBgA0QAbLs5N1XOOC9BtgDDkQqjWNbunwe6RJIjvqnhDE2kvgsbvxdbsfVnv81RG7rhGv4bHMJhHNSBHcxBHd5qrv5LrkyOF6wNqIJqlhQEo9kDefw2ks/UoxsPjPUVtT98Xy+4z5hJ8/51dDhvYljhE1a8lU34pZ8CEoAoKCgj6WzWiZdOI+r/YCX0gA7iIA7ogA66J3vowCh4fA/8gMd7HMiBnMeLIsnnIA7KYAykXAzC4HZLloibOaqRIKq3+phygAXAlnzNF47Hd41pgAeS1kYtIRSiYhWSpBeIpb3dO77h287tWzkeurETWs/3HLERu7+1gRu8YcDToZu8qeTaKsDCSZwandHDKdL+IZzywcGVM8LvbbQW5CHg5SJyRi0RUMOPgD0JrsM9HMRPnSCTiWFOOi/phBVmOxZYwRZs4RRiIZVXpxZM+Al2YKq3mgnMWIyLoFVx9aqbYFiXIFavoAnAOIyZ4Ea+GoyzGru9GgdooAaqvYVowAVo4L1qwwM+AH3zhGI+/4CdV/2sl0Av8IDNoUJQtE1JCgMY4n0YnAM66v1Kr7QYiKEYioHLuIwY/h3gwxUZxJXgxXUZBDmxsZIbuAEcBnwc0gHBDTyJ5mrB/4vi8QHjMZ4fHk3SOh7SNu4fIO3R/kHS2WEccuFFpouROTsoDoFANOLlZ834xGALoiAKoAAKlCDnl53Ze56CTxvVYaAGcqAGYICFwNbhMs83dEMEOuDbTScWoj51ct2lSxiITuGEP+NVpVqMr1qMzxgxkQAJEHNYg4C6bwSsf4BXEVPt1V5r2R67436NeQBztJZXqcCvrvW8RcFr0M7dmcwwqsIq5v3e423fjWHfhUHx953x/f8d4Pd3f/t94An+4Pe8vwOc4Qv9IVeGrRK9HjKe4hd84zYu40rf9CNt9PmB5Ek+0lqf4/+BH9whHHIBkTghszk78H6iNhcz17BnFzH15nE++Lc82Ev9RnYgpE/9qhL06MF2q9IEYXAjBEJABESgu5/e1WM96mP9pV/d6k+hEZzACpJWVm/2VasgLqzACmYVV4f1VmlV7KXabH312PVCDuDgWi+BXORnKuonROIcIHr5CkYwmDBjCIsZLMaQIbKGyJJJTParYkViyDJq1Kiso7Jlz0JSG3ntmjZu4MCFG2dOnTp28+jVm0mvpk16+HLy20kvn898O/3lHIpvp1F+/pL/+juqtKm/f1Cj/uMHdWe/flPdhcu1KRSnTZgsQXKUKFGjRIcAAbrDdk8dN2XixhUDZksUKHjvQmmCBEmRv0V6CO6xYwfhHIgTK67BuAYOHDVoSKYxA4aLFphbqNiswoRnEyFIiBDhwcOH06hTn2YVy1YsVqxhszp1ylYtTnfgwGGDhg1vNljQCL8iXLhvNmrUwMETaNGjS6BClULlChasWbdu4cK1S+DAYMOGCRMvTFixgwbNFyNGbH0xZBg3IvPYcVlG+h8/ihxJraRJlCuNw5JLL7FDTzwHsvOOgvc02OA7EOrEzz4UVnjVVfsYpY8/+gSl0z5PPSVVU0cxpVRV/yUeBVVS72wViiiegIXJWGWddUhaa93hlhtwyUWXXXrhxVdff/k1mGCGEbaDYopBxthjkU02Aw0uXJYZZ515Ftpoo6mmGgkksGYLK6SQwkoqtJ3Cimua1MHcI3A+d0lXo5iySiuyzIKddt0BM4yfxwTaTKCECtpMMgxNNNF78ikj33z4dRTSpCNV499J3aQ0oDoxyVRPPvqEGqpPoXKYFD/47OPgPammWuGrE1bYYDzx2APrPvb49Gk9No1q6oYrOnVqisQa1VRUSWmVy4uecILJjGSVdaNabP2hYx1vffHFj0DmJeSQRfD115FHLtnkY+hCGSVl67rAwrvwouAZmP9gjlbavfiWJoKas8U2G22s1EJmLNz1Agx4xzBzTDMMQ+PwwxA73Ew0FFPsjDPMXKyxNM8s48wyIC/DzDIfgfyMNNLwR9J/mYaTzsvq1DPPTDR/CurN+oAq6q8iSuVzVFf9XFWG+/yD1T/3WHhhhiXuo0+upI4KlLEiCmv11VivyM864Cw7SrPPRistjjpau8eOX4DBbbdBNjGkuOOSi2RhdKebLmOT4U2lu/CyIO+89XKZL74iZNJJJJ2kwsonnSjCeCSKKJJJLRFX7EzFmEcDjeYOY47y56CjXKmlJZ3kzenefJOOPDPXXHPUosZ+9Ya0HxsiVBfmLvQ/Wd/+VO7/wAd/dFRG7W4870tRnbxROuXEKj5J6UMPOV2X8jUnzkZLFiHcF6JjW2+VkbYY3Ab5rbhExi23knTvkK776EapN5V9+43C3/TSa++9XIpgSCSfgJwiOpGJAP7vDIYYxCR6AbFoOEMazpjUyTIHjWZsLhrWuEY2tKGN06luda1znQhF+BOdlQprw0NW1nwmvBT+zHe8i+HtjNbCoGGlhsCrUIl8xjyiPAhCQITQOoa4jqTkgx7i4IbXmpW9skSre9/bUVy0VYby4eWKbkOfX+KmvsEU5gdgbF9h7kaDxkimSnyz3/1McL/89e+NhftELDJhCMN94hSZcNwZzqAIQzQi/xW18BMGs1Gpa1DjGdcgRsUY1gxnTOMb32DdPCY5D3kQyCXsMBBOjqiOcaQkJeHoCT5O2JR+wKp4wjueKlXoFOAZ7ZU3fOVUdmK829VwH6bMJS4xpKp43INW8XhHOYZZjna445jGhEc84MHMZvqSQ5z0hi5CcT2wiC0RhchmIf6wB+/taA1p+EIVwUDOLezFW00AjDoDMxh2inEHYPwB/OyGN72hMY32A1zgSAPH0kQiErHoROIMZ4gzROIUkUCgIZxwh0RwIhTGYN3qWDeO1V3jctFgZMao8Y15cEpm9ShQJo8JDx3eQx3h+CQ4xEGPoPRslTgkHi1XycpStvBVr/86nrCMViFfLhMex0QmMYdaTKIOM5nNdAczgenLBo0yZ/RAqS5E8TUZXVOb29yD2d7iBnDO4Ud1Md9e+rJFwBzJnXODZxjdN8b4OcYGUXIXPtdIAhToD47980AkDNeJ1/RxCmcQhCEAW1BDcOIMiYBEROexOl6Jg1Pp+EY0jhGNZGQsGcqoRiQpOY9MsiOozLTQPcShkk+yNCe4C55UUsTCXC5tl8HL6e6M4locYsiHP2THEF0yxHKsY5jkEIc4yEHccwzxHOcwajuMqVR4vIOISIUQrVa1qpzxSh3fmOr1oFWWRCCie9ZqixvswKM1rCEu5ewWFoeUPnd2sQdFUOv/Wut2NydJBl5pvJ9+7SoavPZPEJn4JwA/odBICGIKhqhjJRTBx1A0Qx7peAY11EGPd6hDHt+wBjYGtbBkOKMj1AgHJT0b1OZS6CrvIG1KU6KOolCFl7D92Ux/htMaL82VxwNerChkjx77+B0lXu5yh0nE3hITHUhGBzmKjFzitgMdTxaykNfhDiC6Y5lNdRA+VoWgnnBSHNuY5ihE4SxMkMUQ3gVveO9ghzZ39bzkqwuQ7IJFsrpti4J5bxHiGc/22U1dkeEb/dSo3336VwQALmgkFnfAhNbxDJNIxBMQXApsyEMeJVHHb9WRjmgIoxkEWZgxEEUMZYTYo+x4SYlD/7vLFKskpeFgR1Jo+KqjqdZ4NT5xDncpq1/meh9BFGI71jFsoibZ2ElublKV3UxlMvXZwGzQTWryWXWQw9rCFW44tr3iTKYjHNzIhnbJHJZJ9NG73+XeH/6wTbaQ17zkizOQ6nLFsWYRXOv04g+CwO8ghPEHPJgnDnYQcPtOJr/7vR+XUCAC/fbvnwVEIB0djcBOIFARZjhDH0aBjZmlg8JIxG4ybuGKUMxiGMdAeTDYk9l0hLRAJC0pLv+BD5SqVBzx8MdrdQ0V2AbNeDDGKXXjYdSiG52YRSZiOZLMdHQc0+nN/mnUp+sgCtHKyutgR7bFseLSqvTrX3+JOcARbv9dlIIUo3AWJCShiEGUJd2E2Gbc3f3mufwoClEI63rvTdZ1jmsHRUBCv+Ppb3nSbd9AcN+6zli/hDte4Q3vxCcezccE7/HyfFSCDIRwBsWyjnXqEMc4GIuNWWxiE6/ITsqD4Yv3KOMaH4d5c+NxodF+nRxFubHuaHhTolEIiMMuMjHFUQ5rE5cc5UD+OdCx9OYz/6hSjn70qxzsd/SSqfD4ZYmP2eTgZnvbX0cJ2MHO7UyBHbLgzsYuTGGKUWxCLGwfhCTS/F25e8/NXZ3DXNK7BfWecy93RiTtVSRkxW9gNHhf9BeJhwOTISUz0DePp1/vIoGCcAY+sEeFNRsJVYH/CXUCRMB5nEAL0/Ayq5MO8/AN2YANr+AJlhAKqyAKt3AMBCEM8/EM2uBRmPQOvnRi/qB1K4YS7mAVVQE0/aBzFPJLwHd0RacOxcdbx4Vc53B85MBc2wdtwWSF8eBZWphJobd14Ad24jd+YviFYliG4IB+3aB+pWAKpOAJ5TZ/8/ddiIAIcmct5MUjboAt4gMGaSMFWyAFUfAEUKAETXAEgwgFR1CIhegXZVUkTEAkhbdvawVGRRAEihcZNTADmjgDCIcC8XI/EPguZ8B5/yRYZ/A4kQBYezQFDDYFlZAKtzAM2LAN2/AN2zANf0ImzlILuLAKuwANC+NA0nAN3oCD//QALLgDTfnAK/TgNKS0FENBbUD2Ds5VZe5AZcHmXNroTL9EXe/QjVm2ZU4FFDmRM/hwE1t4SS5hDqLHdeGwdQKybVsnXOx4SezYEuq4juZgDiT4Mvi4jgLCEvs4kPsIYZH1Dd5gDKhQCuRWCdcEd9vUbmxWXm7wBl9gBtqSkVmQBU/AkUqQBE4QkiGZBEUABCXpdygJGGKUA4WRAzWAGJYBA5bBN6D4ifVTP3vEgRW4igdmBIIQCUpgOI4WMLIADRs2DdCwHbbwCYpACqewHa7wCr2wMJtDEtxgDp2CD7CkKtT2WUDkWfSwhZqkg0hYZc6VZQ2yD1hWdapCXfcwbf82gQ/5cI5hSSDCNQ5dp1LdsJd7OYbc5nXvCI+iJyDmwBLpQJCEuY8u0Y+HSZAEyZgkeGkY5g3bUAyuYD2coAmVIAlz+Hbppk1/kCN3iIdugJHagpEbuZFP4ASr6QRJ8JqwmQRAYJKAMZuziZLvBJM5IJO8OZN+c5PA2TcJtUf/dAaAtZMAlQnGCVh7pSay4CfgER6tkAqZUAm08QqpsAmyYAq4wEjTUA0jwQ0vYX26BFTtcA6hB2Tt4FtEdA9fuSDUmH3K5GzM1I3OZkoUMhTP05VcuI/appfcEKACOqADupcBypcIiqBmCEorFpB4yW0D6aDfthIuA5n9uG2QRJn/HJQNJUEN0rAMzaALrtB+mbmZD/mZ60Yto4mHGamRqbmaT7CasTmj6vSat+l37NOSidGbvFklwfmjLHBggPUJBFZQBqUIUzCclxdgnXAKsSALuPAnxwAMTloJsJGZkEAKrYAJphCM1jCMEiaeroJL8IBk16hqVdYO0/hcQ+QOn6UgWDafywSO96BMC+IS3/eXn5SgBOoN4JCg3kCgfEmgB0qoB9oNhKpS4XA6i8qoqPOo3AZJkkqZtJgNHHoN1QCeIfExJOMoLJcRv8ALvnALqDBmJSoJZDF/6NY92aSiPPIGsOoG2rKRX5CaHAmjMTqSMwqSTvAXsZmSuQmTPCqT/z4KpDcZYINleYeDQMa5RwG2R4fTpIAEpbVQC7RBRwKVCK3RhmfiCrswDdOQQSOhDeIAPUfoDuhgXFmXSVnnpmA5bamWapckXGJoqAI6qPeaoIiKoNywDd3gp/uqr/nal1/nDXuJOinxqJS6DadDi7TIQdpgqSVRDSizqSQDH8RgERrLHhq7sRnrC6Naqs2imajqCKqKCInQPXEnmhVZB7D6Bm6QBmmQBTJrq1lgBTEao0ogkiFZBDxbBLBJmyipJGEkrMM6k5torO9CWAhmnMPJipfXCQU1BQAmUGrilGXCYIZQCYzTCcdgC4OQCsCgCVUAB7mwDZGVDhUVM6AyIf+/5FmYpI77+GopEaAnAbF2exL2Sqh4m7fagKh+q7cB6rDcYLDcELCCejr/ypeKa6D7KqAQe6mZOhIW2xEZwR4Zq7G8sLmcywsV0bkW4QuhyrnBUBG+sAu6QKqjQAolOgmoqqpl0T0pq6Lk5bIvi4c1a6s4G6MeubM827NAa6MpGRjBuqPDuonICy/Iq4nGKQg72awJNkBTML1QewZr0hrAwAlP0Ad9ML2CwAqV4BqN0weKUAlZgByPUAyRpDrfsG3xCLkQqw0mIb/+Ub/2G7/wG7/6u7/9ur/+27cQuw0EKsCCC7/9C7H+MbkjUbEdc7EYwbEdG8Gf27kUvLkge8H/u5DBu8ALGXzBIJu67NeGmqCZk2CyjiA2cZeyrTqR2NLCX8AjuZsFVzDDV5CaNHwFIckETMCzvzq8hLFWTHK0UyIZy1vEM3B5P8mBcwRAkWAIpzBYfXAGnSC+eWQGfSAFgDUFmcAKncAKdFRHhqAEb+AJ2FEMmTopoIPGHKMy/JGpbpyp1lANGeQfGxSxlqq/2+C/efy/fOywkRuxDyuxkgueHmqxnboR9WEyDezAmfsLGdvIjizBE9y5Gby5GnzJupDJu3C6urALtzALdSLClTAjjVCy3cU9sVsIa1G7LVwHLyyzMTuzG1nDs3zDOBySVmAFPEySPtwDfbajRkus/w3YgJo4zDNQgVR7OMp5Co3TCVMwxYbQB1urJo1DR4qARwG2V9UJcdlcvrLQC8MwMRAUEqJDDeDpxm38xnJcEtaQQZYqsRr0zhtUx/H7sIcLuIWrsKjjsLS4sPCMqRSLMhozMhqBuQ/MHo+CDCbDMRzTMZarEevBHhH9KAYtDOlREQWR0d9BEB6c0b3QC73IhiNrZo1wwteUymbjFnfQwjBMszFcyzMckrb8u7raq8O7Z0VrvDzqAkPsLkactAdGnP+UYFO7tQn2B31QnX2UYOSbCc86cazArFh8BmZACrjQC8HQDOCKUdEgDeiMzuasznDczmQ9x9fQznQsz2rtx/953NbakMfwHMfgWbGc+tCXa9B4jdcP8SiYhVkkAxInwzEXAzIb0RAQIR8M0R4WbdEYndEcrdEXXBC+8NG44Aqn0IaZOSOQMBYn3F0o3RZ7sNLYgrsy+9IybMsz/buvadPDy2ftE8wyeXBGTMSaqIqVp1DRbAi2UAkI9AeG0Efcq3GWF8bMaQiskGBTIARGEM2pwB2+kAwWszEoEw3gWt3T4KEpozJi7cYZRNZnXdbgLdfYDUEaAzLJANENkdd5XR7srR7lYdiGHREZYVkSwQz2fTHR8Awac97znRENYR4bkdczWLqiaxGSvdEdzXog2wu70AqXzbpqt9mc3Qhnkcr/Enk2O1JeMgtOpV0cwpHLIB7iIE7TrI2SfAbEsE3My6vi02sEmNesfTAmGDcFX3Amb0DUU+usqYBATdzERnCBmaAJBLMLKDcxnvM5mUMxn5PO6vyd4JrkznAoioIo6Y3XES3RDNHe730e7v3ewqDe8f0QDTHlzCARGnMx163fzlDfE+HfiS0feL3YpYvRja3gIGvnHjzZp+sKqmAKngA2m23SFF7hn/09OoKH4GRe5iWzHv7hIv7oNH3Tgddn5qLTMFBGRJzpwywZzbqcZyAFRiAFddS9RGAIRBrNx72KqkiklWBHCZVQTm3V3VHkGcVIZ445DHPmGbPrZc7f75Gx/xz9HXl+4Bud0RY9g+yNEAhBHsOg7MbA3g7h3+jNKGKeKPV95hvT1dUwKftt371O5YWd2OZRHnP+C5Cd5+iOwQzO534O6I4Q6INO4acskeCj4YoOTo2OBlfw6I/uuyIZm7Z5o0jwy0HMm5i+6VIyGS7+6dOLxQVlBp+QCVLAlGpiOKfQrLatCLHROIsW8czcCiC9C8Ewahrl7fY9EcZg2BJcwZx7yZuswac77Ofu2I6t5c+u5eWh1w+81/JR343kQJcz3eCqDBeTMuT9QBdz8hKB2PDN2KJ77umO7t2BC60g0pk9FvAe750dd+vGFtei4WnA4WmQ72jA7yJO0wAf8P9/ceJMspsy6ZJ6s3ibblDG6dSLM5xT26RJijiYx3nMCQy28MUF9Amu4QitAAxYjRDJ0AzK/t/HHuxRD7KbfLowL/kuH/Xd4R2RD7Lm7sgFQQwrt3Jf/uXqjdDvQe0RkTEYBUGg853LgDKZGjoDXebVDt/FkAzP/thQf8HeMfmS38m68Aoi7QkkPAkS7gha/0TZFF4ZLvaMTvYebva7PKNqj9MEr9M5AGj1JPc0QFiLkwnAwAoIVlBYjDhIioGqOL1Ry6x7ZWCMowiNMJWDwkiNP+5aDvnCPtkMzvsfrflSX/kA4UvgQIIFffHy9UvhQoYNiT2ESOxXMYrFkF28mMz/2cZo0jw6++isWrVs16h5lLZxIzOWyZIhqxizmMtiwYQF8xVMJ06DPQXu0rVr1ytVpEh50lRp0lJIkhw5avTUUSKqhKwWunNnTx03XdekAYsmjVixYceOvYLmipW1Ttw6afK2yFy6dYsg+ZE3b44dOfzmgAEjBw4cNQwTplGD8GIcNM5MOZMpcqdIjw2xmiLljKJMn848FvT4TGhBkCGz6mRodOgpbxzhggYt2rRpzWzbPtbsmDDevHcGAwbs93DiAokf972zd/LlvYs1Xx5RukWYFWFmbJlsGbJlzrpTu1ZS2fiLDRVKZMhL/Xr1utzrav9eVy7573Pdn3//FixV/6dIccIEE0gSUcopRahK5MCqCClkDz8e1IOOOMYIYwwK2xjDizC86IJDLLT48AotRLziiiqagAKKJlZcEQkXkbDrLrz0opGxwhIzLMfGaOARMRqmMMKIKSIxJJJINDMks8rOMCSTKSB7rJMzOlHENCPOsMUWRYqsMrM+GgFmGtmiye22Y3IzJs3mgDuuTTdxGi45nW6yiU7ohImJN5kuIgaZPvvECCOLXCKUUGWWGU8ZkbbxJptDkVEm0GKkQ68h9uILSr77NuU0F1463W8V/zzZREBHlppEEVWpkkRBRBgs5EE/IpRwQgorDCOMLnbVoldff42CRWGbeLFYY12kUf8vGxVbTEfDeISWBiN8GPIMKT5hRcgnNzMiEzMgU+SMKz8xZMttz4jElk4yiWXdylp74w5ZoKFNt2PSbCZNfY1pbpg33TSOoH+V661OiGKKSCbqAi30pYuoc9gl7g59xhlrvvkmHWqceWY7Zx6uLqNJIVLo0vXg4yW/Tlf2dL1fYHGlKE84UerUpVRVsFWqXi0kVj/oqDUOW3PNdVdeo0C61y60QFrFYVs8NupklbWxWR13jFaIbaeIJRZrI3FSic8MkUKKKZJ8UuwqVWVSESk7oQzuJb98o5VjoNnNmHttS2ZfYYYBfDmbiAtOuMF3Mg5O5JSrE7qDK0qYokAnj9j/YWSSYakllpyJlGNprKmGmGmyscaajTDPnBmXEI108ofM48U8YsZb5hlpqBnpGm684R3jYlxB5ahSIbF5KZ0TRJBnnyMUWmgLidbV6F6T1qILpKNw+umopa6RasKYvdpGaKFkkpV3rS07NSk6qUURcqU8gxVF+jglk076qMSQLAzB3/5OPoHSKe5ACmCcaRh6K5NL9gU4NRUsGICDIAQJNjDiRAdPk1qOwiQ3OQ5GbBnL0A6hPjhCRS3DGtOgBSo+hZNc2GZzLAEh7RI1w0Q9w4bUAM81rqENboBjHPJQxzyEWA8iEpEd93gHPdgxD3ksAxbBE0WpLNGIAkmiVQc6/96rYAUh5g2NaEbjla+iwLQUZW9Y2zPW1GpUNTYyhkfaMg2RlKAZzTwmE9AAxhQqEQkpGSJ/imBFJvJHtimoqhKZUMQpOqGEJ0TiFIYwRCNkYcAz8U2BetuXMYZRsAhG8Dd/e1NOiEOphzRHgxu8HAc/OJ4QGuqDG+nOB6shDWIwo16+2MUvLtcdjtnwdjnkYQ/DYY4hFpGI+dBHMpW5TGb6gx/72Ac/8lEPajxxFKOQoiOUMgkr4kxBidBiz7goIQvdqmhLk970mpaip0Ftez9Alhp/ULUd7OB732PWYn4kBbVNIZCPgUwkIAMMaNRiM6rJRCT6oIhBXMYWkHxCIf8zcRlFvCugo5nCFVpRwDPlRnWEwqQmPfnATdIplMP5heKGQ0piNMcYp8SI5bCTHdSlzqYakQYzkOGMaeSUGMsAJjiGqQ51sKMe+UAmM5WqTKQ21alPdWoy8UGPeVSzKKTQRFImUYkqXvGbylse0CZkq1uBMZ1Mwx4720msd75InvTEp2KeZSNqQQZtqlESK9AFjFioRjWRaBf/6pAJYDx0SZ0AxiMNcQpxia1aU/iDFUjRi47mplD66iTgSCqn4ggsGAxJ3G9YGjlUYoQ8hqJhonhpQ9vhUIfZ0MY2YlsSHFKDG+mQBz2QmQ9++MO3v9WHP4I7XOEWd7j6mKYx6UH/j3rMgx1EhS4QnysOc6RDGvw5SlKUwlVudlMRWbQKIQ4RK1qJtZwUMuuv1BmstbKVrcWCp1uTxcZ6srFHi3mS2Z60X9GESzVTShIfIQnQU9jiE2CLktcG0QlWeOYznwkNk/4w2djIphnRiMZtMnwb3DSDJwVJWX3eY7Jd9MIn5kHxL6QDKRrW7hm11SEPuxGOcUCXHUhdrjF1jNTg9sPHPvYtU5E75N3mY7lKfK465LHkdDTZyU+G8jjGEY5vTAMW/ulEUpzCXStesVWIAPNVxNnF5pVTV1r4IhmhcL20ttNFLEKjPPPCmHrW1400YMx+n/TfLonGWtV68GcgIzYj/9nCfESKxLcamgnJCNpICDUEJggKDQ5X2l5n0qQoQRxilHHaZJ+2lHpUbNoavhiY3BCmOYjKDubm+Jj+6AesZd3b3zYVH8p85j3iAQ94uGMd6yCqOVStDnEQWxzHRjZ1qVvdKI/jyeGgcsaaLOV0VHkW/cGqJiCx1W16V2da3OKsgua8sqaXzes0I5yRoG7uTc1Gda5z1ZQV6Aeb5r/8/HNASXOGOT44NUZ6Uh8E3gf5JVQJU+hDQkcz0VPUopL4ylczhEGMYujrXgLzzUF2wYuNC0RTmwK1QljMWtfyUKjDLuo8cnwPfESTH/2Apo9jDmRn8jYf9zgyO9gBbOgSNf/Z4ghHsqFN46EX3ejgQLoPpwztpC/d6Okw+jesQQtR/QcTlsAEV7vazQVdZZzkNLNZj4Y9dKe7Re5851sXY2c7LyZZEAbouSRjVyhN4X9CiMyjP0OkB0fiE4rsQyce+Yn5DUIK4QpNJPLHCVwAI4Ka3M2cdFJSB352ISHXZalxt0NtdEOozg6ic1ut8iMr8cj4yAc+7qFr1t/DHfBoRzneEXueF9vn0P35OIS9dGQzPenhEOrQk+75pCO9G8QvfvF5x7tucOMbvNtG9LMxjVmswhRWtwQktG68LisovAziIvPG4LzodaGsamZzGc2+bjTGU84/iDcO2o6DqSGe3uj/+oSUOvNfI+17M5/pjMowBGzJP8ngO7/6v0hIPMiqhVNoBVwYhmNwPAkKhmOgwGCwDkUZjxs6tRlLh9BjtaM6KqhyqtIrvST7OaaDNmQLvuQLOt47tmATNnOQMhqcsuKTsmOTMilLvuRbvuYLJm7QhiEsCW0oiWsYCRxaiWR4HV2YhVTwDwCBBO3rti6zoq4Dv3Fqngk5J/RCqxQpOzdbN7Q7lveDP3irrzqbs8X4r0CDErcJl4naDEEwhMQTqEhgBUiqKCNBDUMwvLwTwMqQkidJPFVphDRohI0qIMApHGDohV54IJdgBmm4hm3ImHk4JhGcJh4rMhI0MhPUOWIb/weh+72iK0XgK8UdNAfhCzpzyD0po7EmMzpYhEXgEz5vaD5UG0IdqgYcsiHviBSJYA9OcY/7oIVjnAVZgELhsYStQhUrvEJwEjNZIbMyg56lObe0MqN0ezMyTCN3ozM03AH4myfGuL8lyYzIOKgBGxIpqYxPsAUigZuzOYVUMQPOMIR1QZdBTBK8+i+B+4NKiIVaqIVWaAWjsDpRqIVhiAaQuAZv0LGILKLkOjLnSrKem8EZVMWMhDaNnEWOHLpaLD4au0GjM0lwWD7eEUIj5MVeTAlEwYhKYQ/7YBlQuQVauMlkXEZS2a5t6q4u2xmwghByEquh6YIzE6PrUasV4f/GMfTGb1wj+VPDMyRHqpGbtvmETJACI1CCv0NAu2I0dDESuOkE09CjxVIEW2iXdhkNBVTHuqs7QyIQSOCEIhEkQwAEUbiFabAGHeoGdaiH54KydHA6aKtBaquuxEyHxBQ2ovpA6BIidWjMnpsHYVtMjly6aXO6pROq4stFIdSh2pKGiiGh1iGZyyuZk0GZ+qAPlcmFW7gF/bjJW5iFZPQPUiiVnnxGK0weWBkzW6kVDGkDXTGnMxsjNWMRs9MeF1mCb5yRZIG3uZinqlSWU4iFJUEXQ+DKzVCVA7Srz9iS1Ig7hPuCSgCGSmiwToiFiUqofKSMSNgSIkmkiWoSRmP/ND56z0wghVmYhtyBLVTjhuPbHZMsuilbum8wzMGcNgVl0MUkTCdzNipbPl3cxdAUzV+qLdYaIZXInGSIFPJ4GIqIiM9KCJMpRk6BzZs8RmRMRlk4Bf8IkG3TLkqgUUlghBsFMzDrmfEStzhogzawAztoAzYYUi/QkKLxFevRxuyhgmFZAmFZgiiFr7wIgiq10h/ggTWkr3qiEYUTtMdAEvgUBL6DTwDMR3Ihlz8TsERSlRcVPHYhEvsZsHIxkqx8G8rojIQCG0bjhFqYRNzJHR0S1GyIPtmKvt7BmERV1GhD0FhsUKh7Pugr1Aq10JPwCNbC1Ez1pdqiBkzlHF7K/47JgZyHQByCUM0T3ZQUVVXYnAWC3EkAybpKoNEatSIcRYSeEace/dEgHVI2AIs0uMZ0UkqnoYJibacobU4kkNIXsVIr5YFn5QFxTEMu1YtGAyjw1JL3rMPRAEDKYAVFus4v7QOuAYZ8BAYnebSzMZIHa0NHOjBWCKQApIwm6QRPuIVksB1pmI2RqAZB9ddsANiABVhGYZSUVNSU3AaBvQbQ6UVLHc1M5RiVUIl8fdhf9CWUGE2PwB2UOJ3UKZSHobjn+A2CEApcEoqTPVkRe833wIWWLchR0YQAkdVZnVUbZQQdxdWwEtIf/VFfBYviDCMxSpETKdYmfZplVdZkdf8RK12CZq1SM0wWBBwbu1uXdVGEMeVWRsvHhwo8deEv9TSwAew7Jtk7Kvm/IvkEO5UbsrTPLDsFXPgpZ8Aw2uBXfi2dhR2Ju+3L0mHYJESJivGOERLcV4IliQWJlOBYw1VciWUtlADUaeiIlMgcEJKYEB0ZxPmwn9gFk0XZoEDZlAXdoJCFVkiF7IrVmaVVm8XZnIUQXm0DOBjSXy3OM5OepomCKsDdEzlWZD0WZG1ap1WjIpAnbmUSLnmMdTUSt3HHOJwof4oFQdhO1dAMBaQMbhUE0hCEQBowPjKfAUwo+7HPSegMTZisYOiO2ZjbyMVYaVilmJQOnTiPUgrZiij/FGZoBs1hhsWV2Iq9VNtR3/UFVH6VWwxbQtVxX4ozKZ7IXJMVMaAQChGD4F2oPpnJqknIKq6iBJu90ZvFWVkRt521AziAXTYgYegxzurBxjKqAizAgioo1igtWt9NVhn2XacVXr2gi2ShCwRDMHorl0K6WiNZEr/amnOpN0HIhH17knVtQ7vUU/z83qqFG02IBeGgiDRhoNe5vE8zmdD6pDSRiTSp39RR3F9kXDPeX4zFnZOYpZBgicuxnJG53OEYCI6TD06DYNfsFF24hVVQhVFAiqS4YFm1WdVdXZ+ZFSENUhHuWTYot6VRGki+nibI3Rdeghj23Sag4Rpu1hi5/4u6eBEmaLAiQZvsPKg+qgw6JFs55C8j+K/QkIzS8LMhwavNEGJISlv8LMB1OaROqIRT6AXhOAhT/bQ87uITC4bHsYhBaZjBdebS5KUNVYkPqphnqMRrCNxHkRQRPc1Qm0nPrQ9RY4jLAQncsQZsCAZXWAVA1q5BptUMtlGcPQQeTeQgDWGe/dHnod2zQivcpeQVoYJLtuRNJugordKoYYJQZoKFZgLKmILS2DNEgqRY8Ix15dYBNLSDa1ey/YwriTBB+59wGZv6FDywIUsp9h9SeNFbMDFx5uJPeWn2EAiZ/oWEiF+KOxgOghQP9VDWUa1nluaO6Y5DuZhrQJTt0P9pP5EILf4FUbuU80CG/JWG/uxLQk1U3FqyrG6yb2gGmDGFURBk7cJgmo3nWy2EeR5Ke95ZfCY/dCq/2mXhuG7hgB7ogr7kTV5ohWbovV7oyAiXJ2EwRLMFYNiMJIbLTrAFOazl+4sM+UGo+DkFznAwlLafrEzbylZe9eSEUKCFpd6pj2Gx1FKtSInpp44dFbtpiGAxzJFEjwWhGBJt2hFqRKmlbPCGbZCGREnqi3AxXxqJQ5W2JRMiIcpqrd5qjPlBVLNEZ4AF60OKSlAEd6bZDOZg1p0VPVBkIWXkseBCMEKz6FGnuK7kgN5k8rZrZE1oGJmLUFZaFwEbgWKSXK7/KLNNKCgpF0Hzq/t8aESCkv9JjTl9NL8Dm1RQT/aUm86YYvCtV0iwhFDghWW4HST0RQ7UVNbykxRDbYaglIW5iERpGNSKbdH+IO6oGI+A8E59MWnoV87zhowpbnlgIiZiMlkMBwEFUCG08QDdhm5IyRbPmGho7uvTBEGS7gye2bJGBHquZ9dtZH3+onMK7xbG3aKlct+ta7vma77m3Sh1wyRpmwcLjSq5kkBjMHRJqAMrl//qjMjeElXhszP4hHNlNKut7CS2nyp+W1bwhERgBVlwhV+oHfDgVE6t8HyNBp2SX4WYOFJaGJnapdI8lEgP8Z9+MX5Fwl/o7FygBV6Q/4ZvkId0GO5PX9AbBMIhNPVTR3VUv/EAZT7ljr5ooAVXEHKuGuSxplUOBjMlV2t8zufzeuSglXIXpvJhJ/Yrl+EsZwLddVL98wyRFmnI+GiA+i/CA6yzKZIlaVP7IdsiKV73XJeJYoX1xM9/Q2xcGGxWSAVWeAVTQIXZMTUUt6FJH4+QbakLGtWH4PDQPhRnbrFMda0YY/Um0+ol84Zn+AVlyDCFqIZvOL6GX/WH5yFKjTEjNPWJT3Xnu20izAZsaIZYTwWwpvWsmtGatdUcpWdeDWFGHtJyauv06hXxFnYqmPJir/KCznJ/PtrKUEsABHO3JF4B1Mcp+ASvKV6+i//vbb3vykjifLSjRMIjRsu/tP2fb0UNW4AGXPAESHDwg0+U9MDwDP+F5qCJ0qIdwe0ljf33zhMq3Cqm4XZ7GXQ2ZvuGbTAJvqxE2eJxCj11ChVUUwdYfx3Uvz9C0MGhj4DJktGFXoCFVjAFTwgQTBD5kT9yXM/1XFXrex7SLexulwcRmM/d8aZ5Y49Svs7dtfqMdVFXCHMfCIswSEqFVACsLVlld3kwB8u7hBpTBQT6TDgFYCi4bydLPmI0VgCGWsi6S8gFheh6hlhggUCxgwGUQznc2+lXbfBxrIbxYjKm4e45GczIKTs2GiTJoYvUdOCddPjMVT/1vwf80hmJSwX/RqVu6pRhmRXFyVdg/Jm5ulqf2cnPUZMHiEJ+Bg60A6cNwjZxFi4cE6YLxIhaJmKpWLEKRioaN3LsuHEJyJBMRmIs2eQkypNnFJ2JZChTyzOdBJ2ZIohmTEOfPsVi1SmTS5aRgLaM1KmlIKBEb55p2elTp58vf2bK9NRqpKGZTlV1FIrWr1/KliEjFvasL16+zIYlhkzZ2GfUqFW7ps2bt2/p0smbN68e4MB+1Q02N+7w3sSKF+815/ix43Tq9obTizdcOHDhKOP1tm1bttDZrl2rVo2atGfOlilDVvYXr9iyddGubTsX7ly3ds+adUtWK1OiOFmypElTpeSVKDGn+CRJEiNE0qMjOnRIoB/reAzCOUiHYcMw4h9CpGgRS0kqVTyyb1+FScn4JptgxEKUpaGmWXEiFTTFUCSKKGJLLFvhJ5Uiggx1BlMK3hQJTTRF4hMwpxiiSCSfZJUJT1FZpVRUlZACi1hjOeOaWbH9QkwwxSSTzDPX6NWXXzXSWGON42CG2WE69jiOOeqoE06PjMkjj2KQCRlZOpulo1c63XADDpXcXGMlaaehJg1rrpXFFmy8hDWbbbbtUmZtu+1WCy6ypGIKKaJssslxyCXH3HLOQTeddNb5qR0e27XBxnfgjeHQeOVpcZF86rXn0XoblUSSfIzWh0VAACH5BABkAAAALAAAAABAAQABh+jCo9qwkNSpi9Klh86liNCjhc6ihs2hhcqhhcyegMmdgsedgsadgcWafsSbf8GbgMGZfcCYfMGXe8OTc7+Wer6UeL2VebySdrqUebqSdrqQeLqPb7eSeLaQdbaPc7iOdrSOc7eNdreMbLSNcbCMc7eKarSKbbOJbrGJcbGJarKHZrCHa7OCW6+EZK2Jb62Iaq2Gaa2EaKyDaqyDYayAX6mFa6mCZqmAZ6mAXqaBZ6KBaaR/ZaZ9Zad9X6h9W6V9W6N+ZaN9XqF9YZ19ZKd6WKR6XqN6XaB6YqB6XKZ1UqF2WaB2W592Wp16YZ14YZ15XZ13XZ10X5xzXZ10V51xUpp4X5p2XZp3WZp1W5l0W5lzVptyXJpxW5hyW5pxVplwWplvWZhvWZhuWJhvVpluTZd0W5dyWJN0XJZxWZVwVZJwV5dvVpduWJVvWJZuU5NvVZFuVpZtWpdtV5ZtV5dtU5RtVJNtUJBtVZZsVpVsVpVrVZRrVZVsU5ZrS5JsVZJrUpJrUJBrU4xrVJhpRpRqUJNpUJJpTpBpUZFoUZBmUJBoTJBmR41oUo1oTY1mTo1lSYtnUIdnUopmS4dmS49jRYxjSYtiSYpkTopiR4hiTIRjTIdjR4RiR4tfQYZfRoNfRoVcQIVWNX1fS35bQ31ZQHhZQ3pWP3tWOXdVPXFVQ3dSOXNSO3ZOM3JONm9POW9MNGpNOXBJLWpIMWdHMWJGNGZDK2Y+I11BLlw7JVU+LVI5KVE3JlI1IU40I0k0JE8xHksxH04tF0gwH0gsGEYwIkUvHUYsG0UpFkIvID8uIUAsHkAqGzsqHUAnFTsmGDYmGD4fDDYfEDIhFDIbDCwdESoZDSkXCSIWCycTBh0SCCQNAhwNAxkQBhgOBBgMAxcHABMOBBMKAQwKAQgKARAJAQkJAQcJAQ8IAQgIAAYIAREGAAsGAAgGAAgFAAYHAQYGAAYFAAMFAA8CAAoBAAcDAAcAAAQEAAQCAAQAAAMAAAEDAAIBAAABAAEAAAAAAgAAAAj/AO0ItDOFRgERSrwomdKHTJ9FfSiR+TGFEqUpU+hMWQTKjSJFVKgQ8eGDiEkiNGjgwPGDyEocRnr0MKkERxpev4w1myYPW7Rhw4T1AnZrDBUyZKZoWdqnYciQDbVQ0YIRY5AiP34gwaiESlYlP5QoIaLESBGxRoyURYIkCI4eacmOJEmSBl0fNGaQ/LHSB44ZNH50UkUY1apXpEZ94rRJUiNGjQK9MXPliZAdQWakMOEhAwUHFCAsODBAgIAAplOnLlDa9IAEExrItlEK27fb37bp3qZNm7RnzJL5ypWLWLZrtFKlSjZvnjp15KKTCweuerjr2LOH8+atG/fu3cKH/+fGbXy2bOSrg4se7hmsSJEEnQFCYogLFzqAmPEEStWsZtp8I8+AufVmoDZ2uEGHFyFVoAATXpChBRkhkQFRhUkZQUcnirhBCiB2MDiSSSSNpBIRWaH4A2B2JRHSDzu4ktNO8mgzDVDF9NLLL3wo4SISV2x11BRdUTHFVESKVVVaRmi1kFhhgcXQIlMwsRCRaRliiEdTIMHSXXfZRRcNLez10gwzsGSIKq20+YorpiQ2CiecTCKJY5JpUVkQXraQwggeXCDBBRY0MFprqiVqGmqpHdBABBG4kEov0UQjjTPPSBONM8744qkvuuiSSzLJ0BKJKKlQU49z0103HTjZVf8X3ne0gieeeOSVx8156HUDKzniiBPOOdbkEp98TQxRhQ74NQFFI6i4Assu0wgoTza8YaMtNgiSQYdGZLQwgAl0KELQkYtIVJaSVHhBh5agPOIGIWOVhBIOd510ZE0tzDCTSTO8oEkwOjVj8E/AJLzLMJ6IRYUSbBXpsJEPN+kkWhZ3hZSRXE2BVJVXKlFEEUy4oUVbQfTwA14phUkXSmmuFHMLLazExCmvtCKLLK+ogkqcitG5ySSNHGJHGnoGuYMNf3ZgwQeeNaAAaYq6FsDVWDMqAAMYRICBDqLQQlwuoYoq9i20pA0LLaLAh2o289SjjnaxqgfOrd2UN16ufHP/s9s2vIYXjnTBTueNMqUIojgnalRRRg4k7DAEJJ+ssjaA1/J6zbaLfATSwxIcYMS+UCnSUEMUEtkDIZ2TMkUQLdWVEov4mkQRX4D1UNKKNVjBS8G9pKILjqAeE4vEWVGUJFdKqPwVWMlnhUSRXYplvQ9ljVyETEVMYYgdNrwVU11g5puXXSvFLjMOmOS8syyt+Az0J/QzhifSaQQZRAx/ZjDCB4KSGmkOQADXtAY1BKDA/w5wNQEQgAAP6AAHOEACNZQCFhiEhXI2yEFBwCcSqVBHPeRGN29QJzx2w1Wu9ta3v/EqG4I7xzmAJazrqMMaphLEKEYxCTNkoQn4AYIV/yChijflIhrWuMZ5rsEba9iBDg5BSh9mYIAUuMENVGhKHzrkhS46jA5MUAsSOqEF3bFsdipoQctGAhgftIQvuwtYDWoxjGZUShjAMEYehTIMXhzpYT/oAQ1OcpKssOR50UtkIt1oErMEIWXcs4ERVmKDHuAALGFSCZjOh68SuYQGabzZK3gGv/ipAmijSMxiiCYZQCDtCTjg3whMMIIMVEACDpgaAhDwwAKa5gEwkAQpamGLD5wGgQhYgAM+sEsMDEETpSjFBkVBzWoq7lS5kMeqslMr8KSQheTJW9/89sLzlMeEMpTOPNYhD3XkhhmlEMUOR8EIK1ShBiSoARDQMP+KVUiLFs7Qlm7O44aHLOKgnSBDAxCwlK70gQp06AMhFEQkKlipB0oIwkbwRabZ9UuNdjERS6DUMhyIIAUuWMUwjmFHYwjjGMKIaS92cQxJ7OsHeSmfXw6pyJ7ytC9EYFJMZEJUHIQvBpXEQUqWylSm1mUkSl1qCVLQAkzEohax4FnO4vczUpgCaIwpWiNcqYVJMm0FnLGlBBrAgF0igIAOZIAWQHGKWrCCBwRAANYMeAAHPvABOoADNeNZTWqewYOiYEZz6nGdbnIHhbIS5zgnC7gXkoc7g5MOOVa1zXZiI3ifUEw9m6ADEuTzCIEYhSmkqQtraGM3TTloFKkQAwL/mGArTWkXJiixIIWQ5WGaaUEnVkQzwKDpuCl5iV9W5he94GADKL3DL1jaDJfiERjFEIYumqGKK0xhZWjaqXI72dPoveSQbkxeWkYmE/HJpJI2SFlT/bLUkoDpJC9TgQpgcLNa+FcWsXhFzgpDmPkxxhOSMJoWntADG9gABpwBYAQc4IC28jKvEtgBIEjhiRPkVa9ZY1QAAKC1BZDgDJHQhCg08cEzuDgS1FgsN2k1K19JFj25MueueLVjy2JWs9EZ4QjX2Rx5RAMW1PxEJtRQgxq4AAQuyIET9pAJUlxwGa/dBkQO+hA6UCEIEGDAVii0CDeAohNXdANGjISDfqUA/ylpnEFx5Symu+ArfX7xy0lr0ARcDAMa0LhuMYCBx100oxbTWxnNzpjcQaZ3kcnrS/L2EpYiQNKSRHXwWx7Jl/qSyJMmSlOJkmCSJBQXBo+4ai12FuABsyl+cVLlKBDciDpogQnvfQEtP2ABCUx4AcB+IAIs0IEULKCABQwx1gDA7AY+0MRO8GCLh3CGVGRDHXFTz3ZshTe+6XhX3i6nj8PxHOikU8gjpAc9VjWPbeiibZrIRBOajM8O1GAHUECEalNxxG0ogkJHeQhvjcAAHJABFA/phEX6gHDZtplmKZgBJVjW5jUWMs9K5WlW0iSEK9QC0NCwbjGyC4xeHGMYaf/w0gxKsIFP79S+JYFe9MCSvrCs7CsW3d4U1NwDjWokCGlRWRvHpBcxLRVNdUaJSgKjBC2cAhf+bXWbVtEKVPzMwGENRP6QsIMdxOAEHuhahSEgwAOwxq++rFpqBsD2AQh7ARCIAAQwUAPBRtNtupBH3Opxjna0Yx3rkOE5uC3Ox86qO9/5Bnd0c87L2lDv6gA84G34nHMEax3k3oYwRHEHSByiEWbYAeQe8IAcPIsU/+zFU6LYFC1tYANkUERXHgEKiySlD1PAQZxboIIZyP58PgBM7UiUvoynV+g9v4IpmgFol4585An7MyeQEHwVlICQc3kZWRIJpfOm13po6UH/EYIeBDtggg7xVXNUm6pGNZ6RvvNNifTswApbAFjAU6f6KuSHyk9somhvECRtAQNg1zUQQAFrxQBTYwADcAAG8ECqgSgR2HZuZwAJcAAOYAEYwAE1cAZtcyrOoHcjNEOugh23wjd4s3i6oYK6oUSB83jtJA+Adw7PQW5zMyyARw7esA3TQAuCAAl+wAiBkANNFik50ARv8AnSAgtHMQgQEVuUMFwS8ANk0BULRwY+QCSgVAK7pwJKsAh/MQMr0kl2dmcqET1F0AJwoQWNEAzN93zZFVPAMA2v8AQ4ZX3Yl31gkhWUdhdK0Fx4Jn4x8RYNpoZwMS/N01RkAhjulxcs/4J0s1NxI2UEhpBVOyNgmLhV+8d/iVEnjfAHaZA/QmADT5YBFmBLocFWCpAAC/BWBNB2AkCBivKKbccaCMAAD+A1UKYDHsgTewdDkuUr4dRj2PI3O2iMuyFu29BNwyJD2IEb3xB5k+cN34ANwpAKLCYIh2AGTTZvNUBtkEAKrXAUG0OODTEFG5ABFJMUFaUELcCF+pVGvDcDnYBp/bISelg+WoEEaZEmRkAGaYALzWcMzxdTwmAM0MALVoAEoCQC9oJf9kIX+MIXL9Ey9GVzfCiIDfYWMfBeldRgLLJUxZVTLNMvctaINNN7aRJITAAKlpiJ+NcmpoQKPqNKjfF5dv9wBaP4AiPQAR6wARdwS2slGwzQigbAGgOAlGzXS8hWi6zxbA9AARq4ABwwBLsQIM1xDVqJHuARbudhDdVQDUmklWIplmAZltRQDdSQltWglW7pltwwONYBjeGgd+cADt2xDd+gDbeQYpdwCIfQBPYEBPrUBGowCmQBfjSxEDPQADMwFnIREvoFj++YAnFGBnagUW/BF9FDF7ETJVdgJWr0A1OhCtDQDDjyfITWDMcADXdgSSlwfXPhcoVEkUR1ki2jBA/hFVmxXg32Xh35m9vzFkenXzTTiMGnRseFJryXRjl1SZ7QCqOkVZkok62wf21ySjbJCZJQB1mABDbwAin/cAKAkgEXQAEIKAFkp4BmVwDu2XZMSYuyWIEGAHca8GEkEAm9YBvaoC1Z1g3hkDcvhA3WUKBmeZZhWZZruaBrWZZiqZVJhC0m1Fh6qXhzQw7qMCvZMCDOkAqCcAmXwAmN0ARlYAU1oANV8ASQSUjYkyQXcAE0QQRE0gIiMJklcKMnpV8/AApMMAWTRJFupI9EMD2hiQSj+QNaMAl1NAwEOXLW5QzGMA2jkCYqkALlo1QlQhIvkRU9IGdFVzMLcXNlcWmW1AIO5mA9JxPL2ZwmWV+gFBi4w6ZqtBI0YASPQAqoMJ3vQ53WiX/ykxik8AmSAAgLtjQP9iedUQGKioBk/7eKB5AA7wmfFDifBPCAlcpAAUAAuEgCgqAL0cAtAnUb5PFCZ0kN0rCW0pCqqrqqv/EMmbKqrpopbGkNMLR4tDI3sLId4bAqNdKXKTYJjEOi9vEEUAUmXSEWKtAALWASOJAEoKQCr2d9InCjU5UCNiAvKZMmYvhyKzORickWSGACo3kFAcmaTWoMTCoM0bAM0FALmQEDVqqlZqilXkqI7WV0E5lIRNVeMRADMNAC/aqGNnCcBEszLXN0/bJcbWaj8qhfXjAJn5CnezqxmBgLUsdVpzQnjeAGQXIZNbAC5NkBGSCyGGABESAbCZCyB9CekTqpBTCLBkBimZpMD3BitP8ADdySZeV0DWBpqqnqqpziDMzAKcwwtEF7tERbtM6QqmXJRN1xTnNTgzUoZPMgDx2aYpLgCY1wBVYwb3mWL1lxJD8gARvQRjT6jq+3AdMqrb0XA0iACSlDkZ0ZpDEnFvxoBNPaAj9wBU3gCtBwcsaArkChrgYTDFowA/CqUxiHJvaqO7XjA+5HXyP1Fn9BMytgpnKKXCmRkiqwfsxZXCrZnGprfVWaAlMQWqsgC/41C6zLuv8lYP91iW5SdYEqCSZTGUtDgIACKB1QshIwlAygsu05qbF4QIkis6iBAJCyAM7kCs3ALduADZpzDWqplj97tEWbvUKLtJzyDEGbvaf/epbZYHjR2E7qoHd7N0IDgkO/KgmbkAY78AT5YjtHIrbJKgJEMAO9x3vUurbxSDMxcBFo0q3Gp4ctYT0rkiYQcwWTwFIrdQwQzKSnCQzNcAW6Fq/n9QMWc1xjAUfkIybZJyYsITMnGZJ39ognWTMHy4jHeVx+kgIi4L/9Agr0swq4EAzHAAy4kDazcAu8gAvWaUqrsAqGsQqloLFvsBRIQIQuUEsY0BmmCAFktwBstUvyCYsG5JTuWQAGYAArewA0yzUYYLMAUqEDgr67QaBgOQ1AyymWoinTMA1vHA0LqpZynKqu1Z/bMCDne8YD0hyAXLVnfGSi8Al2YgczgRd1/6sxITEFLdAALZeS74ij03qj/9sCWTTAFGmR8kq3O7WSSKAFb8ALJwcUptyazQAM0KAJLmACItBGjrgSMjGGMzFI2ad0dqGIMYMm8VjCecG5BautzsV7cirJMTytKQADQUAKiYEKs/AL0DANCXkLaHPDtVCdrpDNh+EKq2AKGgsIrmQZ4UlLtJSoCNgA6lmUu/SADzipLssaXMzFX3yLeRUBExQCVbAKOHsbfpwtPUsN0eC9QauqlRINcmwpDOqzqkoN1hCq5ltufCxDz+HHPWEsgjBWfHDLSkIhFDISIpAAzVnJx0ytXNicvbcIYyheZCheLweIOHAFC9YKpRy4gf97DNGQys0gC628AXYht03yFmChFlMgFzJREqCknMdJJipZuSYdj9ZHmZwrj4/pA069v5JcAiIwuirgdHJiCrIQDNNgI8fQC9R8crRwC7NAsTvDVYG6Cf+3dTkAAy8Ar+VsnhSwqGHWimDsgC3Ldlv810n5xV+cVw+AASBgWk6ACsdwIN+Qlv8sx0gLtLF6qg1aDXH8G0I7tJlilk47odiRq9mBoTLkDcQgCoIQB36wmOxyFF4xEiqQABuAo7GttvBoySlpmUZSM94XpCPBXGXIElOQcpuAwzRtDBBcKYPGCzlwAg6ZXukFE9DjLyQxFm7qnI7Iy587Z8spZ/JIsE7/fY8mbbC/PJlZfVIpYAenAKg75Aq8EMfYMA3OsAuGJgzUfAu1kNaqu2p+KicIZgcnszRGBa+A0hnpGJS/pgAKeIFbnJR/veBJ2cVHeZQDoAAI4AAREAIuMEE1IAq/ENY2Mg2ObarUgLSVwqqrGsfT0Krd66rS8KBt2St5szcxvh7isA7CIg/T8B5noCLgV7+QSTMb0AATEMOzXcmWHI+WPANUIMz5ikh86NxutBV6gga8UF3FoAzKsAzLUCnOoAvHgAYjoAJksTEngRTUnS+6k8uK+MsxE3zMGVVKdZzd3cLHpQI1apJyHo9EbgIrAAOOcAo0nErr7WcG3RspTgyi/1Lf/rXoUmd16S2o4SwESCAERgWyu1ueFUABcgcBFTY1ZsfgDY6Uof6yB6AADrAAUWnhpNcBavBx0RzH1UCgCh20JZ6qBX3rm3K0sYopLR6WtLqM1OgN56Rt5LAO9SAP3bCXu5AKZBgWa3YSdv6Ov5u2ajvSXGjJIm1If6FxSgJ+CBy2SrFgs3AMxkAMyJDlywDZXi4KI1AmRDAki8msWQrCjMZ+NHNJU+Dm262/xhnM+JJGxtl7pGvnT13tK7ACPOAJHAYKnhBao1AKNnwM7t2f2CANy9ALxGHfi67fAxY/gP5/JrNgKRMDL0CemxFhqKjpsuGoRznqfg3P71kABP9UnwugAA3kAA+AAM70CtAcxw1tDbZ+0Fz+DJWC4kbPvZpyKUvr69JbocCOG+U2ZFWr7CpjPX9EFjhw7TcaGxOQtlhN0iRd7a9cE5a0j2wh1N7OPFY/BU/wCYOL7juxKUMxCzKgApZEt/g1FyrhLymhdCgMuve4Evq1EiZ5kvqVwr3sJ6FrmXZumSeF1dW+GUgACgtPP6nkVTZsRx7OG9pgDc6gXbgQ+osuuwHWCqcwa2PlSpUxijUw13RdnuZ5S5xelI7KsoD98i9rGnl1bAiAvASwAG0FWKgA1gVa8QZdoHGM68pf4rvuDJuyDOiOKSyOqtfLDMqQDMiA2cyA6LT/UArOMzoPgz1UXdsxLBsbMORYbaMx3L/GGT3TAzG9CX5p8RU2Z7dXYAa/MAzFYAzLwFJx7AwAUUwXLiMrcOD44YMGDR8NiTykgWNGCyI0Wiy0uHAGDRUqJl6ccXBGyIkjP7ZQgbJjCZYqNohI0aJFTI8dU8BUkeIlzBFXSJHa9AnUqJ+kUK2CdavZtGnWtD3Vhs1aNGMDcd2qlVXWq6yvWp0i5UnSpkZ2tDwRssPGWhgpUozwsOFDhgoUIjhgwEBBggQHCvwFPGBAYAQYbEg6BeoEAQCNAwQQQIDBAgQPapQCBq3ZMmPFiH32RcyXrlylc91CTYtWatWwXKeCHVt2/yrXtWurTpbMly9apZLiUBKcihIfEFOq7DghQQkVLJmvdN5RZosZPoJPoTJFiZHtP7xzN8I9eHAiP4IjCVKr2fpm0Nw3O2YMVzBPMkcixGG9+H4iEhf2wGih6ajTyKSQDsKBuo0s6ijBjporIYXmZFohhrWQwCGnF0ZqIYMMTEgBBkVIOWUUon465RRVUEHFFVyOicYabGaUUapqpmkGmNNq2eoVH1tZEShJJGnkjSye2KEGGGJoywS46MoAAwvscmABBfJKIDDBChDsAMEk2KSV+dzLAQEzr1xggbwe4KDNEGroQpRZbtnFF2WekeYZZvZMRhlm8AwNmT73fKZQaf+koYaaaq65JptsttnGG2++oVQdS+fBtJ565vmGmFuM6cW8H6gYjgofEGTwOBUkmGClB1uSTsGIgFOCVC20C+6HHnr4zggiyCvPOyV+QOKUYH4x5hhlgxkGGGBw+UWVXREMiYjiKlro1ARlZShAhhRS8D7vFPpoIulSMrclmFLwwIMRRkjhBBRAAAFeGDzIYIQTDiPKxBNTVIUUVVyB5UWmpqmmGmsSvnEaZ4DR5ZZZZGnlla2ANGWUTz4h64+zdshBLRhecBJfDzrI4AIL7mKggQb48usvwQQwwEsJjIgFF1zc22QyAxBIQAEFEMgLgQUe0CCEpG8wJRhtvpFHnnn/6rFUnaij5pRSrbfWumqv1TnnHKuvlmeddtrRVB5maFFmF1q8w47U/kJKdSSPNlgOQuiOCxdBYcfzLqFZcdj1h4f2K07XGdKQZU6dcclqlllcscUWN2Cg7oeUaPiVPF0J99bbkTBSUKKDaODwQRVE2MAE101g/YILKqjgggxYVtNMAhAgoPfHBBCAg0ZM/MREFFMkxRRVWpEFl2GgOXiaQw+dJpocIZ/FYlm2WgUVU34ahaxAzLDiCbRysOEFF94tGeWVI5AAggYmG/oAAwwo4P4DLugBk1qCwYUZ0sQAAtTsAAcw2gIIkKYFQEADSQsBEEpxDG1gjRvd6EY4yCE2/3l4Ixxc+4Y6yDFCEZIjHFULWwqjJsJzbBBT85AGLYBhjFvAwjtUIEISqEA31HWEQ9RpwQQ2kBLVMQclfUMQcAK3RI3QYFcNgWIUDxKEURxlFVtZ0SpMUYpZ4GIT6KOORDzyEGtJZAY/GJCqViICNrJxA29sI+s2MIECAO8xd3xMYxyjRz720Y8BwIAkiMKJ4v0LLAKzWBeH0YxoNNIZj3TGM5zRDGPw4irY214rVrEiVWSME5IARBqyoIUrIEEtNXhBClL5LnxJqS7xw4uVELAX/CmgARJYAR8sgQIEREYBgPnLARFwwAPY0gEODAEGOFADTfSigovKBjc0SA51aP/QUlrzoAk3GLYRdnOb6xAb2NZRtXloIxe9aEYNXWEe1IFLda9ijghKMIEGDPE5DxqQgexmt3fi84f4fJUIPJCGTWSCE6QYhSMawQlNTOITsgjEDoLAhDP2QCE4WAjhDiI4b6WxBHGUJ99kMk8JlPSWtZsd7SoggdnJjnYdwJeH8NU6GFCAAhnwwBVAAYpTcIKQhiTR8l4xi1rggheLbIZAdrMMSgLjFzrjBS8klj2vrAJjGpvEId4QSiyczwZLSmX7cOqhlcmvaEI7oAIWUAEGGAB4kRHAYIB5QP2p1WgPqMwD9MoBONACGdTARqOyeUFwSMqw3gAHOMKhWMWCDWz/KRTnOU4YDnlQShe6aEYuaAGLVLhMAlniSwFc5jK+8KWkE0Dtq94JxJOMpARvHQBfGiBEEfCtOf38aAUg8IRGSOITngCFIiwhCYZyAheyaIREbfAD7uAzIjlpgYM21wJYsSSkJYBjClpyT5l0BKRt/CiI3PKCJolAvG6pnQdW4Iad9vSnREGeipYni6zc4qjG2MUtVJMLYAgDGLw4jS6GoYtaTMwrrYiFV1CBULJIQqtHSosNRBYvuLirXXShQPwaMEAFCHNmbwUeMP9yvwHcr4AMwMvvCKDXB2BAB6UQhlO28Q1vdMODH6RUOCQVDh73+GtVK1s11QG1bSQjF87I/+8tXJGKj7pEiHOU4xyfzJx7vrGfIp3ODFYHXuk8xyQqeY5zSnABCgiht56whCcMUQlATEITouDFMV5xhSDYICda1qdbRipm7LbxjRtgjnbBy7ow8/m72N2JCTbgoQy80UMbkJAEarcCQnhikIQsXvIWnDyhEnU1dMrv5FxBC1yQxjS/sCQtDKw9r3RyFIQkSx1IGQRa15lJb9EXK8maYfnhhQEIcKsd7RgAEefvL8DTne9+J4DKRKAyNVhFM54GQmr/+MchlIfVqimNI9MQK5oYRXHmaETngNe6caRyurkbK49o+cr4RA6EoqMC2aWgEZvYhCc8oYhHEPfN6sFFI/+EQLIHoW4kPYBudUPKxnJTOScR8m6h5RhlKf9Zdou2HV1WitIKuIwCN1BEJTzBMUwbL2NGGdhQPb2aq8BiFakoBW1WQxpdoHqqPqJvgoFUIlJ8YhKN8NgVhI6EHuDABjF4wQpWQOELqzR+EMCLA5aNRy0Bpne9oxnvAHDHtwJbrQ/QQbS1MeOuXXNrQwbhpCgFqbE/RRlMjRgvVnEJT+TkjaiNshvh+Gc45v278oRVQEH60ejwGdGEF8EiincKU3AsKKPgIjSG0QpUtuDPp5IQ6xjOcOo0B9BbTklLBuTRMBfRiKvbwEUk1HnCP2d2GzCCI9IcPkxn2nuoSPn26qv/s8teZRWlKMUqbmEaXzRjGFLNSi1eEQtWsEIVh3x1Vt9wFiEgIcIje5cLUDACEHRAShaYUgSgPplZdjhmctWSYO6XPwOWX2hCUxMDLKCB7nNgCKUIBvSsB41JFkMYvuiFXdiFy1KNzaqN2YANWsiFXQCG4cOFTLAEU+i7OXqjcvszQmOJvhOzOCKiI+ou6Jg3Igo9wNsbOBqRUVAFVWiERui5URAFV3ieW8CCHOiBeZqA4FgL7WqOkFIjMZMQl4AVAuEIePIuP9uJP2OOnbgJihOBCmgdJri3jRmLkfuE5DEFU8C9ikmkWkCN4RNAneFC1CiNTzmG47Ok44qFBHsF/+djPITihJ+zAzMQulKasBN4gReQlxFAGQ+RErsYP/rpC8CIGZlBv/whpgPgi/d7PwRwgGPqABDAAAxwgSaIhOBbhUtEQJgDvk0sBVEQBU0ARU8shVGzr6g6LlMAhRmowLtDLTFTrXcTwePQJwNBjh/0odFRiQ98jje6ArAAC0DQAjuoQlQohV2QvE8gGdaZgJAgLxBBCZboPL3buwsMvCJ0o4WTxkZrtJtQtLjIOIxrNAq4AA+YgjMbhSncmJ+4QtyzqkSaEzHUBQG0r1IjDVrYhWH4BYnBBaLiER/5kRRcEY0RnzR4Azm0vhxApa+6wxPgvnaJqSmBAAi4C7wwv/8COCBg2pK5OsQDKq2+IL8W4wAQaBMSGAI1EISTFAQ4gAM1KIMyQIMsqIIqcIImaAIhAAKQqYGczMkcOII2yARZCIZa+AROQIVQwIHaijIVYAEWIMKOWMqldDfVAYmDOBVt4ZCTUBAg0ghZ/MA3GoFiUZFRAIRG8AKE+oRSuIVpgIZa2AFFq4APeYERcBIQ+SgRiC4fmonNW5c2CihB47sSgJ0REKg/e0tFWzQPeUsPSakMgAALGAE3GJKgQMdMW8ejqJjGIaouvIXHEUPU0IUz5BEla5zt6ZFWS8GM4ZhGAIRDsIM0KKW0yAH0QSU83D5W8gAN6MO6kJ8G2AtE7Iv/QSxEQQymjfSLAyC/ysiANmkTEHCBGnCB5nwBEkCB7UMB7ZtOFCCBESABeiGB7kQBGZCBG4iCT1CFSHhBXAAFO9uyIdK86qqud8uyJLqPj4A3qTwifUIJNkoBGyCRr8iBIMAEUDCFVhgFWTgGawiGMnCLDagAVRoBF3gd17HLmaCJJgkRDnGLDDWBdpHLCjOBE0iBFUi6O4QBpRPRGEC69EHRtdiBFuUBIbCBHBCCP7g3UPiEySSKymzH0XzHLiy14TuNXXiqWGBBS2oRySmwHmmFJcUYN5yETZCEQHDNJ7A+WlMLpEsl9WGlD8DNKCkritSL3hzEYiNTYjJE44yl/8ZUTg6QkipJk0ZMIDOR0zmlU6JZgAiogUiIBFqYhmBoBBvAARhgnR0kIltcvdW6Si0rHZFIHT1DiZgYvXAxkNUZARsgzyUlClAoCqMw0ib4KhA5JfSxAZkwnV0JAiQwAiRQVSZgginQAiYQOi2Q1TSwg1q11bFsBEXQ1V3VVUMABEBwA0OwA0Vwg1p1Ay/QgixgAvOxSSygUUsYirF4PCvEQlXY0e2RHM28CiD9QllAggrogVHAwkvEzNL0RyBZMI3RGAdzA1JSVfSoM4UcGQrrvg84mQwIv9EK04ok034FjL6omWSTDAkAPwkANgIYgMg4AAZCscZUJmUKSRJ4Tv8ZcAEZyIEuiARY0AX3+AVOQMgXaJcMpQ4YUIE7JNEvWwtARZAesAFTLYLwCI/xUIIp8AI62I4pmIJWxVkv8AI38Flb1YJiZUGA/IlP4DlTcAVeCAZeqAVVAAVKWARQ2IRKwIRHeIRdFVaf9VkvGAM3oAM6yNmcLSV4bdEgiE1RRSUXCNETYFsnqbCx2sOUsQAMiJJIfIAIeIJAiMxzxDfKXMdVcIXLnBjJ+TTPXMDRuAVZUAUYaIATyAJJWJ7AHU3SZDVN8p7k6TmyaE1ZvQIqDQK1SNmR2T4QcBe48D4LkADxc5kwPUR/5RK5mpktQUQQAx4DSBMzcYARWIERQIH/FXjO331OnYxNHdgBIKgBIHCCMxCEPc2FfYSFUvikscS36c03UOAETf2JnSqKneLe7vXe7u2ETvjeAA1fTKDaqt3VoE0DglqeVkCo99W0oByFRoCCHYABE7hD7fOADT2ZmNKAKPHSCIBI1I3IAjZgvYqACEDgAm5EB9CrY3JgvHgAX8uL2zWTBzADO2iEJ3W8kTuRv3UF7ZmYxincW9CF/zuNWWCFWLABBziBFRACUsC55OORraDcJWURFnFDULKDN0gDdw2CtADdEl0B6mxIL7WAV1rdvvhNfxWM2E3YJx4APMIjZgM2M8HTOggESLgEUHwzUYA8S7QY13CceOyF/81MXFR4NUlQBECwAzf44VHqXCqNsJysThegFxDIgAfi4w/w4z9+ID/WAIhsxMmgjN2hDKLppd15ABc4EYTSmEIaSiAgAe+DgF/jnasjANqlXSr25E8OAD8S5VEmZQYwgzfQ2zecXr8d1xBOJMzU1mMQhgGkhVZgBTrYYx64gQ/gAT44hagCIFugLx5hUk3qnu+JvkYIBB8mJbQ4pbVI2+2sFz30PgywiwQ2qwX4zTHNSCl+YoRFPwPiyERUk8ac2w5wAT9YBWgJBmUpQ2cBhkVyj1LjhQDchQB0hU7khEAQghqwgZyEAZ1UEpNVHxfYTg9g0wfonbu1qYYGvykBv/8KsACVoYBYmtOf0WQIQIEYcIAFigASIE/wgTx/GYUa0CsCEgBPJuWVZumWXmlQJgASMIM0CIRNcKhJ4OAcvb1rHeEeNaphCEBccAVV6ASDhQAeuKULKIEVBoUY8IRYSD768sdL3KR05RgiYc1mhk2Q+efnxM48PJnT7UNYUsRAlJli++aMHDFiKi0EMhMGEOCH5QArWOdgOJZ7BkBieDsku6y+rpNIgARIUOYr2AEULVHymle3cB3bvAAMuAAI6B0GaOgIuOYEhmDyw7phA2XISGnIWKBA8J4rDOPgK4UH6Ow82rpQ3rrU1qPNdu3Xhu07ymQC4OwAiIAduAKaftL/TxoLytxpwZ0FWGicMNwFXihuS2o+JWgAAliBjquACaAEW6CECTiADRgDUKgFW/DH7XkFV/DuYzYRTrDpshAltKg+2MxJ4K3Ne901DXMAl+lN/AnO1/XmJ17rQ/yZBNBmRjxnDgiBKDCFF6kTX0iGP0GUAi8UPEEUFzjbrxoBC0CZ/40Siaadh54SCgA/srIARtvDuQU/m0rgB3aAOY0/CW5MAV6ZSJTYGriDUfgf+DiG9TgGXGAESq5mBQ7xky6aRDYTHqfTRD4aFtMriO2A7lzxGtCBIWiCmDwDNYCDk9RTUQg+V8jhMukAJqDVSjgEh5KESfipn2ARawVuzMzW/wE0xVgI35QQgRVogJWiAltgBSqYALu8gJthBWHm7tJ0hWM2S/FWzYLs3M61SYR0TvVRH4bsvgvDAN28pdUVU/vByPr2ZvZj620OmjShbAxImi6YBWPAhhBSh6lZh1EHp3WgB3poh981WeBdASXx539mUSAQgiJoAih4AijA9StYVqGDgivo9V9/giZAgiMQgmKX9RY9W7QV3h0I3h2oAjVghKOQnGmHBVFQgyYYgmzX9iWvgjJogydfXi8vnlKwohAe7s3UmeL+hV+I53hGqvVwj3h3j0ai90aKHmxQS2jABRdol0dQhTRQBN+60cfTaXYEbsmhry6KmMeZbhYYhP9Q6IQkmCMaiAVbCAW8QcQZoAP+AYVYkIUE4+4fqer3TeY7ECU5pGORAU+le8530bWxtqmI9DVtpiv8ST9JHwz9EUTf9JJZggBN14A2EQVi2AapqYd7sId9uId76Id+2Id+eAM1MAOUfwIsqAIrKJ9iL3aabAJit0kgMB+aDPuaLPYjaALzeQIrwIJTDoRAOITewmmfei91DPPuQQUm5Ufhto2JsaSo8nte+AW7ZhZlaQ95j/foQfyDsYbFZ/waWXypqJEZoZHIl3xIkfxV4IAcgAE3iIVHsINNkNreNh7cM3gfmfaJKTAAQ3dbIIIJSIJQoIIkiIVBIINQsIVYmO7/A2CJvtgAAbCBNPR4ixH+AwsS7xFIZV5flD9IG7gBGwDPgkYBsEaZuqAdXpsf1oV0EcP5jHQrArhIi0yAhEW2B7CAD+gdDogEoscUfHD6f3D/pm9yNZB/J1cDPQXFQtK0o/BunOPH5Huc/wcIXAIF8ipo8CCvX78QFvw1sCAuiLdy4bp1iyBDXsGCDes47NixZiKhRSsZbRrKlNOssbSGzSVMbDKxaatZcxvOnDi98fT27ds8ed9qwjqTRYsNSqxALcIEatImTqNGkUKlyqqrVq9ezZpFC5asWbV4WbwYqgSLUKySdIo1KFSstS36UJkQQMUUEQkU2aol62/YWX9f/7VqdXUVKlOjPm1qdOiQnTRarjwRsoMHjxs2atR44fnFiREjPGQonaECBQoQGjhgzUDBgQMGCtCuXXsA7twDCBgg4NuA7AEBBBAnQHwBAQQICHCIRAxovXz3+vXLl2/gwF27DCpcmLC79+/gE2ZkuEuXru3a17NnTzZ7wfO55k+keP58+vS9fAETRqyYMss4M+Az0kxDjTTUUFNNNSzNRFNOPn2jDoXyWHihhfMEdaGGHXZ4YSqCHOKGFkGAwkoonYCyySaefEKVVVa14spWXc0Ci1i14ELLLbXYMsgEScQSSyihDJLEIKzEkoQKcHWSAA2sSGlLX7XE4peNgxGmlf9hijEmySSNRJYFZUggEQRmOWwGAwyeuRCaB3F2UBpqqkmw2msJxHaAbbfhVoBuAvg2aHIBGCrAcIgaSsADjbrgXDbz1IMPpfiUdSmmmWqqKS2devopqKF6mul8pc6Hni7OMJPMM8kEqEyCCipYzTXXZJPTT99g6CGvHtYjaa/BfojhhT9to40100QDzTCRMLLJH4q4QUknRaboCSiknHKKKoatMuNWg7mCY0UWWcnCBJ1Q6RaSRZJBxAYHbKDCBPVuQEMotuBCpY+11JKjLK/EYpgqppAyiieZNNJIIG+YYUVlOwgRxA42xADDCimssAIKooHgQQcfZICBBRZQEEH/BBA84ECessVGW24C6PZnAYIyWoMgrsyyhQYMSJCAAb0Vx0BqDixAgiC+QDcppqY6/bSpqKLnC9XEWI0MMslo7SozzBQoTawMiu3STBHyFA5PuUpazzr1CCWPsBoSm2Hccl+ozjfbZHNNNQhKs6ovuszXaSqFiyJKJIIIcgbjVQwxhA4u6ECCDnAwEogjdnTSiQ9kWAsK6Nuy8ooqq2x1+la1dMrLv7jUclYCZNiy5CC1h0JJAgMkQFwCLSSxQQM09BCDKlTy+0otsPwrS1ysXGXwJwlvIkkjDmPxBBLYBxGEDRbDIAPGK5zQ8ccdzEmyySdDgKcCCSjHJ6A026Yb/wmR3HIMNt8cgwUEEjRwgG+KQ4ACJEACGGhUc5KhjnrU4xlfA9usGFSrCXKjgt3oBjgyGA5ycJCD5zhHB8lxjnWQsIQkbIeGTLiOutWDHvd44aQYiA/r4MNtb8OQsWrykmQpaxnLKIYv5JOLr8CicKk4nCg0kbjFMa5xkNMBZ2rgAhKQYIpUvCIWQUAC83EgB5NIAx/sYIdHYGIRSlBCtYq0LdGdAivjggUc4XiRWVykFn2YQFpsEQokJYEFbylBA1rQAgkMYAKUABK+NiADWwRjdkP6i2BmMaTCPG8qn4hemP6Qhitw8gpnskz3LBYDN41PNHIqDQZGhpo7NaABC/9QQPteRhs93QZQMyDFLHoxjZ9AIwcKaGXuCPUbBDjAAiTggAvOAIttzEMczhSHCtfBjmmyox3WvOY7svkOdmizm9mkJjXh8U1w2sMe9LBHO+CRznOy05z2cEc83umOcrqDOvkAhy6+koo4GrEUh1NiJAKauIAqrqCCWKJBCwoHNTCUoWUoQxWq0ATL5EAHOsiBFF3AGRe8AAY1aNMKXACCKbpgB38AxBrc4AamEGIRhPiB56QkpeaxojA0Oh0cdzQLgaiiD35UUif4iCQWFGA4gYRXAYiwlEFQgRX6ioXnHlmjIW3FMIk52GI+kck0mEEynESCZTDTvYu5CQUdMyX/yOZ0gTr5r5UNyJOeDkDLBMxyA304xf2sMRRNPGABCcgdbg6AAAAaoAEaMEEKetCEg0ZCaft47D30IVl97IOylC2nPsqp2c1u9oX3uCZoQ0sPeuBjH+xwx2lP6450rLa17oDHalnrjtmuFh70mIcvzvA4HTSxt2eAwx0YCtw7COIOwW0ocAt6BzgsVA3FbS5D0eBQiE5UCI/brQ6AIIQmNOEI3RXCESxjhB4YgQdGAMUj3GAHTxjCDoowhBt+oIQ+wGWmMi1MuMICi13cgke3kAUlkgCXPSahwLWbQAIaIJwA6G4ARGDkRhppi9+VoBO10Ios/GKlqnaJFB5ejCUa//GHN0RmMmWaWA94MFaQhvRNojGlyC6QPgrcyQEsew0DGPBX2BR2Ai0AxCyGgY1plOIBBKDrAGQ2AD4V8AIrKAIVyKCuYMwCDoIQxT+y/A9+cLnLXubHP6hDncfa0zpi7sc+PHuP0bK5zaO9hz3iKWd7vMMemZ0zPOMRj9nq2R37WMc3RBFRi0a00BG1wkOtYGhElyELD300GiKNhoea4aFneHQZFC3RIQCh051+4kUxWoMdkJrUQgBvD8hrBCOkgA6dcIMi2AsIRQBCMlOYAhUWAZch8XpI/vrLRHgEElkQwo+b6+MgNgekCfjAB/TK3QTyhYuNUCkU6BIACzrBiv+AZdgvgyFYjA72iRADAhAlngz2kGAEiqnYYjKQwQtckIIThCY0o4lxBdZK45S5tQGwVABwWgkBDqihFrdQwwMEVTPiIOoADdhACzpX31NUggcdeAACHqDljXN849TpOMjDfOaRk9ye1alOmk+ej5Nn+cz82Mdtn8E4J2DUCdy97uO4q3MnPKHQTSg0znHeaYke4XFAuChFN+qCpWORBCDQotOhXsURtEAEImCCDXqQXkOI+BAMq4N5vUCIloLiFLz2kfH0lZBhoEQXqJgCEd5ibT/ucQKIuruPydAHpzLSeEQoAbSjHQuB/VpLBCOYuKdHPXNzFQtYgIL2elAxG6j/iTNt8kzG7O0Bkc1pZCaTQARY6e8dw9IBFPhABAiggAHEL8mCakAJiBDVUCxiAwowjqAAuOXdg7n3vP+974PPey73gx/FP77xk3/mlTNf5c5vuZmN/ytanAENUOBBDWw+BJ0b/ejZLXVFawBFi1o0iuZX+kabDoIOYAADHHg/B9ov//a/vwMc6IAJMkCACthBCzFgAg8ggRnUAQEeAiBkgRDcQBF4AR1QAig4ILcoiY9ERESQhSsgBijsUVsUmLo8CR5NwIINgASki0YYD+zojt0lgQT2C2BwGGFcxSkcDCd8AieECSC8AVdlARYwgboFgeSBX/d8VJvMG5x4wGiQ/4YqpU9bvdVy/AZutFJuLBwCXAANUEEaUYEKbIChDMcWBoA+xMMXhiEYjqEYliEZkqFkjWGcxZmesWE8TRY/ZJY+wJmdcZY93MM+2MM/7AOakVk9ZEMSXY4fdMFzMddywUEgGNchvoFxvYEjPuJCMdcj4mAacJUZkEkWZMElYsGJ7QAQ5AAoTl4o3QCpUd4O3FoKCMEURIYZSMIOvIAZHEIdNIIiaNITSF4PLMEWeMEjOIInsEgNQgIkZMIlRIIolEIpcEIlgAIV0FeBUYIesUDsdAIWAl6SbQAobISSkAG6JEC9sECBxYK+4EILvuC3PI+H0SAnTI+YcBUnQcyZpP+YDeyAmmzGZ3iGvR1hWqHPydAYBLQGLDVhzCjZcBjHBagAWxTJ7yAY6xWAYMFSK+mZRE4kRU7kGlYkRX5hG8qZRcaTPcShZnnkRW6WPvyDHGZWPtSDL0SCJjACHEhXIg7XcjGiIt4BIwaCGE3iG6jBI1aiT1aiGQRlJg4lFkBMdYUXEIbSPPKAqZmJEHCSFgzgKUiCmqRBI5TbVW4SDxZBEYAXFvgBJEiFKSTGWK7CKpSCJkDCI0hJkRxJJwyCNMpMCwwCkVALFWxABSjB7OwR4E0A4B0JGQyCLUADOZZjYVDSVWXVlxxCw3SVGXzVmQTBqU3eR3XUC4iP5o1A+Xj/ngXI2Mm00gIwwPu0XpIZgAAggAnEXVuiSwMAFm0ARwIoQGhOlkZipETa4RpuFjzsZkjm5kiWExjqAz9IZG1WpJ3pwzvEAzywQz18QyqwJCOkQRmoQSAEgh/cQR3YZB28AQH+AQHWwR/k5CSmAU8y1E9KF3o2WlFagaI9wVEKgXbRIyjOJ6lpV2XkgJlYQVelwSecgieYgRbYgRtQTyNQzyGMWBpkgRW0QRfEwUEdDioUxlkeDlXwGivUDpHUC+AZyr20QDDEAh0wQQacQjB0gjQS0ACAYwKkhWAew790xelwiVWhAlYtxiZMgiQwwh00TIJyUrqBVSkq5Udl3giU/1L5dN5pmMxq2NjKJNhfARCjwMAUaFsn/B2CLRzNGIByLMACBGdx2uZG/mY5nVM6iSlw+qaXEidHUuRxwhM7iIM8OMNBXULDqEEZ/AGefqeegqd3EqBO7mRDNVQaoIEZEKqkPcx68hx3hdepndon0qfEaNcRgFUOPMEVYEEWpMEbsAgpeEK52YEhKIIkRMUlWZJUaMIxHmMqfMuMuEIq0AiENRJcQIMtoJEtgAIhrMAFbMAKgIItEEIQmIA4JgFD4kYClEAfJYHeBYPrFB5hxKgqFIzBiFsNEugh4KAWmNiJWYZ8htIozRs+ntXHgAyd7BvKrIb/LAACMAAGBAF9mf9ovSAYkhFHQ2opAnBpnvXZbGWTONGZOMFTvhrnO4iTniWnRRYncF6WmM7ZHdrZa62DUKTCGVxOGzTUSQECH2Ssxm6sSk1ioH5sdBVqUAql4+kg5D0Byrqne4IVt0rMxGzPqvUADiCBgGpBGvzBJpjBwtiBudmB123CJ5CCKZSOWa6CKxwt0l6g0cLCuMjCL0AD1PKCU0EtKxBCMEBDMPDCKcjACRQBX4hjiaJLUTGYcEyAW7AAK0ADL3TFi3JbwCAmKiQmDeIojjIMtmYrZG6P3pbixaxA+JgVCWimZoKMBvDjyUQABTwABGDAC2iBUiQBAACAN7YmzOhGAfDGQwb/7Du4w+YOrOf+a8BOpDcZbEV+6Z1Z1kXSIWfloTxBrDT8lh/MQRuUARqkQR0AAp7ywXfq7hrUwRq8we86IsgGKno6ZlB6gRfoYPIyARQ0LxMwQcpiT6Oemg+mWhCMlxJQwXt5wRoAgiSYgSN6gUqF6qgGrVV8y9G+QtEWEVjIAtOuAizgAtTO7/xe7VjYhC3wgLaAwvzGQjc2GIMFQAIImIBh7S3kiGAY5ipEa7QazGJwAgRzwuKVGImYmJno7fbgwFi9G8YsnVmJawh8gAacRgWUTMmYwA/QVyx0gl005PzMzG8Ilm2mQzok5zvUcDpQZA2PLg8bbDZJ5A+zoWTF/1lyXmQb2sM+SKQ5ABotVIEf5MEcoIGjpYFxJaIfvMEVX3EbvMEWbzEl4iAYo8Eb1G5XEaoljqwOZuIONq+ZQIFRNqp2Nar1KkGzZa8i2AEvAoIXOCIfAIJ6OUIleMIoDO23GO24rIJXoEpE8NfR/oJMTAM0TAM20C/UygQ0HMPVQjI0TDJcTkD8dGEh2Q7WVkSWBMa3mSViOvCLzK1j4KQYeVUneVJkBoEG38ANvFtnLJ0Hi0YIa4AIa4AGdEAKKMEiiOMgbEC9HIAAwAy90mvrOeQB0DANmwM1m4M0x4M057BE0nA2oQM69DA3cdM3je6evaE91LBtAqeejcM5YP9DJHQBG6yBF4wsFe/oHfgBHOCzH6hBG/RzP1PiTzrmGY+sUI6s422B4z0eFCDBEaRsdcFno5qJESDBFNDAX4lAJ2CCq41BFqhXShkCIADyJgxyt7SC0a7CqvICLrgHWTAtNOgQTUyDNkiyJGvDJFfykA3ZNARDH/3Vgm2hN4Jj2mbtAduIUQfMlrxgA3vYh33JVX6qZGirLG9Pil2GZnBGvGHMvJFPCH/AB6BAD0TVj5RACSAYAOGGkjFc5dJGbNhwPPQwD+8wD4uTNtHDO7RDNb0DPdgWX9s1bMHDHCrnmQJnNuVDZfGDO6hDLpxBHpyUd/oBeIKn7vIBd/qp7F7/dhv87hqkwRqYQRiYARukARt4thl8gReYtmlzARdsAWtjQRRAwWtHQRQoamU46plILxJQQRIA3opSC7UowfOSiCKwwlUWqFiWDiq4Qil4BTBoRy4IDi6kByzQgjUgC03Pr0pAbTNQMtZeKLoIx0+joB/Zwk6TRVj82vIYHsGsEVM/cJhUpwFGdSxPtTzSY/eAj2eYgH57wPq9n1l1bVQtSRbK657wCfz0SZ/ANVxzs4LfdWg9OJu1gz3wJh3Cw2a99cDOUByuQzZEghPsge7WgR+MeB1srJ7q7hykuIqrOBuwQRi8OIyHwRd8gWrPOI2vNmtvgRTINo/PNs+5J3ya/9f2CAFFUwELgCNaJFuR0IEXMMEUaIEXVMLCgIlYxi0qIOMv5IJ2CE4u1MctwEIu2DRMoEQk3zT9PrImB4O1lTWS4YahBPUgXO1C1MIrHG2GJTBSQ2u0rlEMurcwLgyP4m0n9aDkbc/kyUAMxEAKqEAK6HfUuYAMGIEigMKQ9BEy/8yT/pWmw48szUbQ9HA2V7M5UBM6UDODexM70MM1qbo1VdODdxacwQOGa5NyrlwcykMycFoeUPYb5MEeXHGJZ+yeEuAatDgbzMGxt7iMf0GM2/iNq/ZqS4G063iP83jKgtepTXQQcBJdoAU4+lHoGAIhjIEXTMEYjAFWSoIgV//FVZQCKqh0ROhCWXS5qzaDTVh3SnB3M0iyJWMtXKJLsS5YUIcC1DrELCj3KKCCKSM1Uh9mtMatKvQ5Dd5o3Zrb3ZqY9gTBJ13GijH6Z6CAC9iAF6gwXyLzBLTVa7Smpj9pgQfNbHSTN3uzqJt6OrBDzIt6N4FTq7s6NV3TNLXDOZWThacZ53pTPFEHP9xDoGVXHriBI+ZBHlyxia9B7/au7xo7srt4GNS4szs7tOP4jkdB2Pe4E/z4RIVXAGbPFYx8H4EjXBJBKGxLJzyCIvDBFBRCxs5aIJuvKmDVKvSIRYwKLZRCKlS3DpE5Tef7JR/+1bICC5B1vCLZm+NRKGz/BC7MAmJoFSeQAmB0foxK6FVcBY1a0sQTqLmpVwVDppmAFcV0DwwkuuvbQBBQgVLo0d9tADJfAI3dCQP028qvfGzMRqhXczkUv/HHPPLHPDjZvDezQzRJE9Dj9c/b8DzF4VtzLhDHg/H1wzxQwxDUABB0cRukOB9rLNVX/flT/bHD+LM/+9dvgWqztrRXO4+XvaJiuxD0wJBTdNsjyZGwAEBQAjXQ0yNLhRDpQcTHkCNMnkiRMjXq0ydRtTDemjULlqtUpWhN0zYSmzVr00RiwzYNGjSW01RCCxasE4sNLCbkTDBgQIAACSYkGRQL1ytUFDlNkjTJVCtZT5++kvrK/5WrVq5WZV2FKuIoUEg3SWoEyA5ZN2m0XLnyhC0St0F27LBh4waPuUz6dIplixWREiIqbMiQwUIEChAaSGiweHECx48THJCcjnI6c+PGmUOHrlxnz587bxY9Gh07dutQp27Xjl470+zewX7nLp4+ffbe5Y4XTze/fvjk0dJRI0eaNG3asGHz5g0f53zWRJc+XTmbMNe/ZOeynfsW79+3SIkynnwUJ06OHGnypIkQ90GEwJXrg0UJFoPw46cUitIiUJ4AdASRROgoJJFKPBklooo+0aSUqlwZZRRRKBTllmmiiQYlmFbacMOWXNJmmmOCGYSFE+vTqQCfBggqCVBqIf9lFE40maSRGych5RWoeHylIwirygoVU2SUsaKwbrzRjrO0SEsttdxyLy4eeAiCiUVC2YuVJFQAjAIPPvjAgjEjkIACCdBcTIE12VwzMnMou2yc0DgDTZw7xfGMM9H0fM3PP1GDTbbc7LGNt3d2y+0d3+qp5ozhXDADDTSSYyONN9zI1I3pOB3DU+y+COMLLsADTwrvpEi1vPHOS0+9Jpo4oogigoBPiB1woMG+JHgdRKhQQumkD1BI+YQUTyyxJJFEHEFQQVJo1CQSQSKZ9o47BNFElFSWWUkaDFPycJqTWlJJG2ygwYUSFoTi9cQJEmBxAnb1QsrGRgIJRJAcnZL/ZZZaepTKFVh+RAWVUyQy8pOkJGl4LDuM08IMJ9ViCwggeDBiDEpYsYUvMurboIIMQOiAAw4ywIACCyg4M0011XTzAHPglBM0O/G8ebPP1jEttZ4DTe01RRE19FCi/8lnnl2Gq4GESScNYw3jNN2U0+g89YIL7bIbNdWvv44C7FVZRS89ttIrwohahUCihx7qY7fXTpLIMpRTBlLwWQA92YQTCUuR1kFRpo2kDUYgEaUUXUi6phpqzvXlwpE8hGYkbU4KxhZg8+M1CRZ2avHETlhZ+F58A4EkdR39BTjgHWWhahVVVDlFFSIpMj0sscy6FC0n0T4CijUw6TiYWAaZ/6HLDS7AYIQOTP5AAwoqqN5lxRhTM7IDLMMMs5vxDD+1cuoczefz2XEt/dXUR+eddIiOh5943FF0M3f4qUceWM7oAgobJNUGNIRhDFTjg9WkM4YEemoM1xHVqLYzKlSJJwrfoWB5zsOqV6WtVvBxGxFO5DkRJoEVrLhbRE6RwlOYIoUSMUUpSvGRW2gDGhTShCZG8aBcaEMe8piHOtTxDXlsA3POiIY2vpHEJGLjcjQ8XrDw0wlghSIJEygAUFiQt6RMQikNU0MjIKGJWdwCF0WRRSta8Qo0ooIqWNnKkHBXEYYppRGHCMQbjGOGLKwlSkKwQhb48IhTeCwWVKCBCv9akAITmMADJCCByTSgAZZVoGWIyV4DFAAZ7lnGZjgLX/g+I5rXAC1Qq/nTadwHP0XVBjfuUxQ78tGoSMRhCxczgxnakIboGGcNmbraAj+FHe50JzwULCbZVoUeWKWtCPGJTxFAeJ/8+OpXJgwFKPBGitpJBBWqMBgqVoGVaXwjGB/5CIRu0QyR9JCd8vgGNnzhi2dso4dLtMbl0hULYHWCn9b0lRUTMIhQYMJ0XGyYJALBCEFAAhXHuMUtYrcjNKpRYG6k3ZBkhBROcAJJY2FOGiZ2hbSwJQ2AwMQp9hKLPhRBBjCAQQpS8IIRuIAEIAiB9Kp3Aeu9THuPmRknv+f/mU8ONU96QgfN0nGan/VslEIzDc2Ipo9+2MM0uTENPuZxi/5BAQg7yAIabslLTwFTgQv0ghe6JsFSqWo8FyRbBlsVvCMYwS1AKIIScCIUfuKHV2QYBD+BBYoTpvCi3wznKnBxi1WkgmAGE4WDUpEKWuhiGUekJzu/sQ11tFMl20iiNXAxCk+AohW4sIVpp1jFCXQCFJvYRBchAYmGCYK22foFNCD6r4hOtI0WvehEJCTH196ILB+NmFoagc1a2AJ5OOCBDGRQgxdM1wQvcAEKRnDTC1wgZSxz2SUhA6fuzUmoRAVlKGlGs6Uy9ZSmOaoqddOPe8RmlPXYhijgsIUj/9yqDGUIaxrGcNayMtALZj1rWlFlKvK49a3niesT3GIEWLXHCH6ZF19D6Ne/UkKKJsSmKrhpMG+ysRWocMUrSlGLX6iCE5LIRCY0AWPI0uIWwnBGNazh2c3Oo57fAGIQrTEMXujiGCuBxjFwgZFagKITp/DEUmwkidjKlraQoFYptNEMWtB4FrKIBW97O7vC4i64G6WjHe9oBzymwQ6gUMVyVeoD5/JgBzmY7gti+gIUYPemHxgMBrzL08Y4pjLjJa95z9sZzKTXHEtF3/pesxk/EQo37BDNOuZBjDOooQy3OkIXwBpWrQmYgQEu9Vm11jVSgQ1VC0YmMp3gFllPmP/CKHIXC1TALr9SghKDoEIfQsGKFp6im4VVhVT28gpJqMIWmLCDIiTRLEtcAhF+8ANtI7GtVNyiF87IcRLZWY91tGMdQfRxPbeBLmDwohaxMEWDuAiJas1bENiaNy++4Ywta8TLU5EKGmfXijEXqcwdrSMgEP4IUHSMF7ZYxA9w0AIqASEHc5GudK+LXQ9s3AMpo+R3s0foOMnp0J8kBzkSXQ7vee9nTWWvUiU9tNzAo5WlWcc3UnEGKzjhYkAA9S3NkAZRcYHUWcsaqg8MwQlO8NVNN4+s3cKeZRYhhCcqQa6TsOv+UEEJRaCDKmIRixLSThUC34vH2u0JO2ACFJn/ssOzFWGIRHAhDHFogxrOsOlNZ1uy8tSGjs+B6XDLQ3/q2MY0isELXMjiKFychLyrJe9rUWtaosCGPJxxC1psJHZQ+Tca0Uh2jHYFLAdNkiQWbgvNUUIJEG8BfChug4rXgPYusP0JRuCBEeQ+Axc4EwR4+hiarTyonQnfyc9LfJa3XKnrXQdp/EQP6Y+SGZu2QhN2oAMdlKELEzMOGEaF9KytIcBIRyupLFjB8Di9bA52MNSRwJb1FIEGKLK1UPJDBirMyghL8AIpMELYvCKFWOHs9qkPFmER3MBJIMYM3uAJrOD6rCDvKHDT4IBaRIEWeiEarAEbtuEDe2geRNCd/0SkGRruFU5hRh4P8uZNDdQA26aFFnroGTSPFjovKvxNjULPm0yBSDJqYV6rizaBFIzHFkBBCVrPBnCAruRjLmyg9lxgulJgBDSuAy6AZcwk+BLgqJTvMxAtZ4jvTtCB+UZpDM2QT0rjNejBHqhqHc5BHVKhCuTQCpomCv4I6LSDO7yg/MjP/LajmFpt/djP/Qgx1tjiEKvgCYQA60Io66ZJ/5TABqiEB5CgSdIAC56gCKZgP0CBwzqBw/aj1xahSSrmCa4gB3YACJrACuTwDPorDeytWmAIFmhhF3qhspBIiJQIG6LhGH6h3U7hE8LCyqqF8lwQ2zSBWqiBx5hB8/+6LGB4C/RGzGBIb2E4ahI4gQhVLxhCgQym4AfeJgbeIgh6gAdu4AZygPZoj7o0ruN0inpArgG2sE68sKi+sKg8Y9HMgXwsrTRyIw1fKeZMwx3cAR7yYR/4gR/KQX+iQeci8I+yICK34AtuKYLSioCk5gvQqoHGIA9XLVUsiMHarxCdoAncry0OUQhswNY0DD/0Dwd6YAdqYAV4YAZsMh2PgAfU5tcWwdcGgcOmiD8GoQ/64O0aAY+Y4w3gAA7eQA3eoCwOAYxiSxM+YRRMbIxw4RhC5O8wxxchCsQ+gQXnbVoobywFgRZ0MRlooYw64kewoux20GB68AejxRqJRfX/eKEbp0ALmCD+2gYJpGQuYuAGbEAGrOu6SGD3wIQwKCACKAl75DEB+nE06vEeP0MfyUeUYEM0/pEzX4Mg3WEfEJIf7OEcvoEWmsAOHzIC0e876C6tYDM2IegjQZKtGowkTdL9EhEKoKAtZoAGfIAI8I/XfIUKfgAuciAHYKAFIm4udsAIfsAHNAz/gnKfyCAJqMANktI4QGpSbqlJtIA7L4URLiETqtIUVMEVZgEXfqEZXAIlhAyiVmEUNEHeamss8XMslQGIvuEZJmsWBqYqXiErPm/MEIYuqzIiaiEYeIEV+kALvOASseAKhED+AlMSb6ClbG/PsKtkussCHjNN/zJJMy2tMo3vk25GT0IjNNyLNDbDHGJDfQhyNPnBHc7BUUxyNSOwmL5ma4ZpmDxyNieIgmzTPJxgJEnSCeTwCeSwCngTCpbACGiABoSTCqaJ65SAro6gBibxBnqA/oTTBxyxV6qzEwYBhEoAB8JzTYEuIif0SZ7kj97gECDhxTjhPFcBK39hTxUPYI4iE6ystgS1LMfyDFKBnn5IGnKBy/4NKz5PK+DIB4MLhWJhJmJhEcrCEC4RSngTwtzDLnbALqJrQ1egCv8sAz4OMulkZzKzHO6kvFIONOiRRV1UNGDUTwiyHxJSH8RBHW5BB6pAR/+orbYA/X7UNT2SmMBGPP+KFEldhSStgC3k0Al4cwmWYEp9QAmogAy4FRKVgAmYAAtcZVa8lD7sYwNARpqoyf5ORAVwYC+fRAsi0gqwIALhNAKx4JbeIHUuoV83SnFMDHZ2691spLawZVDvs1rg4Ax8QR3mQX+kYcswQo0ctaLcqJtGLyIOplKDoRYwwQ0eYSzOYo+uAAt6EzBvhQfKMUMxDgVKdQRAwAM6YDB6L0QXg9HSKzO4MDMuo7xS9GclbVYzEx3gx2fQgSATskbX4RoeJQLHYzXbyke940ctEjZbc1nFRiQL0VWO4Dxy8wmWoDergFqhgAmMoBzvigrUdgqugDfp9QmYYAqUYAmYgA7/9oMMcg0/UmQC7INdQ4gIfIAJ0sJJsKBeC/cKhPWPsAAWA+EQHLeOIAEbq1JCckcY8WVf6+1gEVZQ8y4SrqEe8AEf6sE/dUsWBNRHgEQrpnFIwG4mbMETAKERKmEsEO53gAdld6AcbSAGMG5DaypmaRZVH/NmbZXRXpTRKhMff5YfJ3NV3wFGxzBQFoUf9kEc5EEXakAHrOBp/2h7v6ZYqbZqY5NU0K9Zk8n9uPZZv9Zan8AJnqBsp6AvhQcLvEBtlaBkdw7CtIAMFoF0ZoIVzNRM8S8n/JZds1UttMAUH/Jw6zUC2YJesQANmOMO8uUQ3uAOHPcQagsSGCFf1swM/5ZyKSev3uBAc2mrCvIuF9QBH/ohH+SBBjcCQF0holJXK8SMdioVGniBFBShESTBtSTBjt4APEfKU4UgJne3dxFTMYNXpyogTeznqF70eF+0+OzEVe9kHUKpRNHQHzUjentmUf6hNK9BFFygBshDR4nUNcM3SFuz1ZquVdKXawuxU3kzbqcAC7IgArOgfrluCpYACZbAEDAhSzxG9aAhFoCSbgq4kX2AbUsRCvB1Qut1PHpTkp9Aj7Mg6C6lcIEODS7lct8g1MzABdUghFG5hAW1SSOhGuqhH/4BqzKPFghmhiPq84DEURdUJmLhh7nIzMYiEN7ud/joPXRXiZfYQ/87rmZbhgLsh2bc54uheWd/Nk9SDg1l9XkljanggXrbIRyYQQeicHvTeFiJtZj+kI1nM51PRRDbCtbMJj1axcHGowqi4EnBNW5LNiKzgOjW1q/0YiYEeiaCDReCZa8auYBpwAiehC0kGYIRl5yfNFrt2JPTYz2s4Ao2+RCu5Q7SAKzKIJVF+A6WclCHIFjPgBbmoR/84TfmwT9tUGA9b0cIBhakohZ4oSWMsCoXZkY0AUnIQs1I0VNrRS5s4DAPMzFzj+NqtnoqgGhq9XiJzwthVXl1ZjSedx+Dhh0YZR6EIwdkwGnLOcEsKJ3B12r/MGvX+JiQFD1IskmjgP+QoGL/riAQAEEL3OYGjIAKpCjstrElZkImpiEYFKElPyeh7e+REVgt+Lm/InqS9RjoCteTk9IOKLhxb0ShOvoOTrmEN9uzBzXvAiETRIEa8OEf/uE3ziEZavnzQC8rBgYWZAGnWwIXEOZ2KKLMxCKY8Wik3CNK5AIG7sz2rgtmOW5me49liOYdolo0Vq6as9ioQslF00Ege6aF7SsSdGAHXqCB1fh7yRp8I+iBlDVsztk20Veek9QJloAH6FYIrqAMrsAO9K+KBIAAQAAH2OWvNucCTgGwgyFd7MBKMQyxTyQ44RU8syCy/YufNxno8sgMJnuTL+WCLztf8oWkS7izVTlz/xGWEfKuES5BFHJhHvIBte3hm5GBYKLiywCuFWp6PbUyGFBQ4EyBK4DLdJLkECBmpObaUytOuHv3BDo092ZWp1hmM575i130uZf3RIeWToYWq5XKNGJpaaqgCWrABR6Se62A1ZburEdl6IhpSI2pSAnxWQnRyz05C6CAwH2FCAQAAOiczm+CuQAgAFwiJoKhD/BPbw2cBRDcEptkwf+owfkZ6BT9lhY8X0uZOTzbswOBpE8ZOZADlTc7XwQBxLsgEBpBW6QBdOWrHeaBG3yBFmdhRz6PptczwI+hFppCFn4Lo+zFYXgcLdYCSoLALmoABjTUBXAPZnkPAyoAC12Juf9fFNlJw8mf/FVl1ajo8dLSR3TlQRSynPa6XDW//HvfWLwtkjvycK3MG4PW+0i9vG2fYI/52ld8JRR6oM7hvROCAQQwgBeCQStlohNa0kQS+rCJQAnAEy02OQv8y78W/eAV/atM2SnhIBAk/VpQ+dI1PIQve9Mn5Q0+PRJgQR3qIR/ywR7EgR66gRhyIRf4zd/85RZyWofTKHbWCJyGJLiCkHcgBk6RAC7mwtdhoLhjtgNkljC8iwIizXz6cbpZtdlRVFYvbcrTpx7mIRrgwAqyrwb2WEezALzDF0izvlR4VCSbtBDZPL71CArcgMPwr246Yc7hPc/3ohbKyLQImlv/84NdR+hziIAI9pKTH1xSEF7RufOTQXnhnfIOJnjSOzrDKZi2Jr7iBQENODtbpIUYHrYdpkoc7oEcqEEalkEjumxH/iUrZaIWWgFgpkLgWmEr4mijkCQQcD0tbl4IZk8GXvbnaRbQxqRl6Gsy0/Dop1xowSfplT56Z2ObnZ5/rAAIdIAEEjcLAHHrp/ZYw0Pcx708vh7std0Kxn4K+hc/gIUFgMUN1p7OBYBjA1wmjmcQ5N5XGrHuk6BKJYY52tS/QBnCk7L+38DS1QANXBDS7f/wMRzDAUKQoEB3Ct4JhDBQGTUMBUUSJCrbPHr9+pXrl6+eum3Ebs2aJWtWLVy8/6BBwxWylqyVr161crkKlSlSn2pymtTo0BstV3giCbIjR40aMFagGOGhQwYMGZpiqGCBAgV2VKmiu4r1armtWbd6/VpuXDlxZMuC/Ypu3Tp06dyxU1vvWqQuWIS4IGElr14rWaT4lbKFi+DBhLd8Efzl8BbAXLY4/us3imTJe6s4cVLFcuYqe62UQUOIDJVBg0KF6sSik2ktAFq7BhDKli1WsWwFM9mJNOkkLFgk+Q08eBIqWcwwNIPcTJfkZtI4fwP9jZ/p1NvciX7HjnY72BMS9D7QeyCBghiVOYNeIKQzusLl+/fPn797GedJy0ULZK1bvI5BC1ZLgCCB1FJLrf+0oopMoyz4ySaSNBJIGln4JAQPNhRl1AggeOCUUxZYIEEEEbxDYlVZocOOVuVgdRZXKm4lzlhedeWVWuW0leI68+hyRhtQ3HAXX3tl0ZcUUQDmWJKICWZYYmGEoVhiiv31GGSVRcGZFVgOmYUaaJhiCyi+kXbaBhuYFkoCrwEwQG22xIJmbaGQodsgvQmHpxZYdKlGcmmggYafaUQHnR8JGRrIIeJ5V1BCB5XHCCPkjYcQpJGqcQYcAj0qCjX4uMOPfP78k1E2uXgkyy24/GISLrN49NFKsrwkC0wxkTIKrpw4qJMWFN4gg1FHbajUUh9+GCIEEKTD7DvmjGMOOu//dEXWOmVdK45a1pK1lVhixdjiivbQgw8+8NhjzzzfiBLHGmOYwVkXjT2WZL2BcdFFvvoC2gWg/upLZBZ6CaxXFE5MhvDBWk7GGBqH3NEKLrUQUUISpOU2wCC0daJmAgIAMEgsIr/JSiislFwnb77hmQQRPhCBhBlZnFdGGcgB2kYafkiXqKKBMAIJJIzk1AjQQUfq86LUGcqId5E+/TPQAgHdiCSTCAKLPP2EKuo/+KiDDCyuwHLLLrcNMwsssHwEEkuv1NpKTDONcusonEgCiHZpXIHEDjassEIKJ4yAVFMZUBAVBSFGIAGz6byTTrQkSp5itdqqRVW22nIbljnP/4qFzoonogPPPfXQ08648yAjSBt8rCGzFWg0RuW9hAlG5L7+7q4vwAQTnBdlCyNM/JFchLGGTq/g8kohJSRQWmyUJBEKnFQIIEAC1FdfG5zc20JJnXeyTAQRXqzRBhyQhAcIIIc8HTQkjlxC/yXz099I1ZfE/3T/UCOEqEhFTYD+i0QkgpY/qznkGfjgBz8q4g9+4GMe3lCG2nJRkmnwgm0BqkXbamWgA8mEFLf6BE4AkQY3aOEJQrDBC1BwlMJl4FgiksDibEiieMCDRPCIhzuY5Y4SvUVbVGlHOzA3xLWgw3PRugo7XMQie+yDHvRgR7a+kYozBAIQfIgdGqaEJP97JSlgvesXv8oIsM6o0UjFOxJjwjAHPqTBDqqoxfJ8MAAWmEY2lFCNaSYAgASgSTZvMo2bQqEbMowPT75ZhCcywQm7TWKSk8zEJTKByUtiMpP162T8PgnK/iHEf/97mkMOCAlJWC0S6ElFN97Tj384kB/0mAc3fAGLXfQCGthw1Uc6KKAB1coVciMFKnQlCZ305ApCyAEMBgcCDx0rcVKxoQ3joUN4aBNdOwwiNs9lxKoYsYpGbEdV3sGOxwlxWk400T7uYY97lAMc8niGIODAiD/UgUiyO8y8mCTGLeQrC73Lwr8AhoY08oWfnVkMZPwymC+EgQ15+MMfADGKkGj/gxUTmIBqasMKMnx0EAEojWoIKbKRvSk3g1DZbxbZskGA4hOkwNUoamITTmiCE5545CYtWb+fAjV+ndwf/0jpvwFGKn6RoGQkqqAGQSSjHu9xIHz+4Q56gCMZudDFNLBxCw/KApjBFCtMUIEKVdBkEoDYyRX4JpQUIOUDhEOKB+5q17t+wHDoQhcV/9pXdMVjXH8t7F/LSQ/B2uNcfdUmYxcLj3zsQx/xEEc4vkGLMxzED3noQs2+mBiAzstegCIjGnsHqJqVIWCrXWgXBHYvxXDhMBJlwxzysIc98AEQnoiFK7ShjU5UzJChCJ9qWNEJkH4PTqwg5Gx2M746kcFi/6E4Ra5s+okFMQinn+hpT4Uq1KKK16ifRCop40fJST61ld6ohyzhIyp74AMcz9CFMpoR1pDcYr/8JWut5KZWuzXiDcz0m1wLxxRjTbMpH7irBwj3zr7+9R6JjWdf74Fhw2qYHvC8cGA/jK589GMf5hCHPKrByoL4YQ6plZJiFjNaxwgmoWQ8IxpTq1rVEukz/prtk6AER4neNrd/QEQdAIGJV4hiGtqwxW9IQ4nilkZkJ6NNIWWjUtuAbzfA4fKTq4srU6CiFAuqqXa1y93u+hS84S3qJ8l7VP99Mr0GxMwZBEGMeWwNvqJyR0aowQxf5Hc//N0vWWdhIFWo9ROSeP/DE2pAOA9g4EMUiAAEpCIiSyuLcRSowAUu0BRZTnYfpH4nFTG8DynGE8MZ5jCrWY2PDrMaXbMOrIj1kY5zeCMXZ1BDQdrABUCZ4Umh/edoB5PQ1xK0X8vO1+7QwGN/1cyM/nISG65NUdvidg9FTgRCFEEKURgDGrLoRHCmSwk3xeIUpDAEE6YwBjfZJhi3CQYl6NRSPJWPCJ2oKSnEPBN/2/TMaf4uJr3LZqDWj6hwFhr8QGk1SkIiEkOoQqZEgY0G8kMfV4UPRuphH1WppND9xYXEVDIrtUoiCztwAQcocGkRQcABDKj5A5QFgUxz2gIV6HnPr7qPq2KkXCKO5T//MFyupCM96Ul/5z1KjWpSdziet44HOa4hil6nrw1RMOO1oeTP2RJGSv0a6LJzR21pP3vtgAKybedw220TGRGJQMORJREJV2AjGKpYRMtYUIIpU5kVpDiExV0BjWkkPvHY2HsfLMYb4PRm8kQ4xSlMoWhUtAKtpuj8wAmO0+96d81sHi/9QOlwo8kvlZS8hAF1MAQraMoX9dgaP/5Rkdx//BqnCpDJfw98XNhCJaiYBBqA4HIMROABNde5AxawAAbkvIaL4/mnr3+BWc7S404ntcfzUa5XK33pUn96+aEez32IGPfzUEZm7gCHNrQhDvJPAxvALtrC4K7Z/uILGj+7/1ozw3aAIiUTBXd5oG15MGSIsDN/QBBlYBKnYAdU8FLb0wl9BAp1xAvRoA3bsA3ABVzfoA3H8AgvlQCTh4K+wW6jMBOcF3Bzc2bb1V01MXoIp3A/ZXoNl3pLBQkSRz8GhBOcIAqpcA34EEtDR3T5kBH1QA260Au/8Av0xgtTyAsmVwut8AlvsAMk0AGTVmmYlmnTt2k6JwGIUwFm6GnXd3vad3sVEXXwwXRMdw9xWC7l93SvhofqVxFfkwoVVwdvEH/0lzPEFmNh90/N5mxosGwJNYCNKH8TdW1Dtgdyl1t0hxCHACFm8ArHgAqbcDFkYjK0MRLH0IEbkQ0e+A3bIP8P2jANn6AEvDEBKTh5VHAKMrEKnveCMAh6NKhmNpgJPnV6OehJqKd6PThJQdWDViMKopAL8lAP+FAP0RiN8zCN6uIMu6ALwxAMUPgLvFALqzAJWugCXThpFqBp0ydz6Mg4mSYViMNzaYh9/YAubPhArGZ0c4gPSqiPSyeHtYZhFwZrGJER1SAITtAEfyh/CTlsUMIFfmE7gzFGAGNGaYcza5eQDKEG8jcdByh3f0BkRUZ3ieAHQMMJoKAIoBALq0AKi+BH32MLuBAM1gBc3qAO3tAN4MANOTkPq+gKU9AysYiCv0EEg3B5LChmCgJw17WL3NVT3fWLa2Z6QSNeqIf/epMkCZd0SeszCZqwjKKgC8hADL6gC7lwKrRAC7CQCmk5hKsSDLxgC6ogCVWQAy4AAhyAAcqHc3mJjptmQ2BYhtOUhhlwfRlwDeuQOvqwff1gj/+wD3QYfvwYa69Ga1O3arH2cTuSGUAwHQmZM2Zwfy+Wf/9EbYn4bPKXkaepBnCgmnBgEEuTW68JkiCZCIngCLV5STSlCo8ACqeAIKeQZSbHKtjQgd5Ak94ADuEADuBADjv5DbXgBUTAAhvAAvsWHJ2gaJiXeaaQK8fUeUsZeqOXCU4JVJtEP5w0XlQ5Z6pUnpNwQDvFlaLwEOghn3fmEIJQEGoQCaXwCqbACE0w/44c0AEcIKAYAHMPcHN6yTg31I6VFgFoCBXw+GlNQYTqQA73kJhRR2rgF5mu1mocWmpO93R+xaH38HHrUgVDoAMZmZBpgByfeTsvOltm1Ab+MqNowJnpwxCqaRCNcigI8ZGIEJKzSZu2eQmS8AmoMFakYAJI8Am+SUi/1wzCuQ3f4A1TSqXe8A3qoKUg9w28sAYtswEsQwYmc4uqgCBotSDaWVPZdVPfKZ6/+FPAqEk4iJVTCQmnB3GXkF44sZXvKQqaoAacUQabsRDOoQUCAwQ1kAMkcJeTxnwaQKDrSHN7mXPWVIYL2o7TdCyNepcZMAS04A3kQA9Bd3uNaX6lFv9rG2ZYeAhip8ZqpDIPzHAGKOoCnOkcLRoGt9MkUoIYNnqjM6qR1AF/Osqji3IIhwCkQDqbtcms82MJz7qbmBcgKIABm9AKsWByvBAMxxClqbgNOZkN3ZClWqoOVMqlx7AHrzgBeEInJ3OL2HmdZsYgMgieCWeec8pJbbY/C3en9SMJmbCVk3Q3kKAJBVuwo8AILCQETdAEQnAEZvAET9ByIIABBmqxDIAAGduglRYiDuAAlEp9ZXiGPeeOmvohd3myGAB7vuAN64AP3FeHUEdhqrqqlBlYhmUPpCIPsHCiOkAC9McGaOAcaTAG94d/ggFkxCZRv5qQS4MoO9ooTXP/XkI6pPdTP89qCZjQpGq1PK2ABZLQXPTGrdMwpeWKivIwruVapdtQD2gLDaOgBD5QMcBBBnRCCaegCjFhptmJK2zKCUwJnvSjSpsAp5YklfjaSebJcOTlr3q6lZxwN4wQCZoQCaJAP4JQBUOhuTXgsxywfAtAAASAsaFLugKwAB67AAeQAAzQAOqYadbUaZ0GFSa7qeV4lzrgAmcgDeqwDkX3oTI7szRLRaW2ajdrWP0QF6yEu7Uqf82RBmuwBpDIBi5mbU9iW23wBtgbrE7rHe+TEEODiUMDCY0wvs3qrFiLvpbgCbhSi6swC7/QCoyAChkknN8gD1oqD/krD/NQ/5M2+YGNtxGKVwuEQAMqkAR1SwVkwJKdcHkjpAqWlytt2qa++JSZUJuDK6eZdLiehKeLKz+MsK9F6rg7dROacEqacAmbcAaZexcg0AEGigAEIAChGwABQLoyjD0CgAAKsMMK4MMKgI6WqjiYWrLTVI4W0KgakAEuMARDkArOSFVGh3u6l3v6qKFxWFW353ECacXgNw/z4AsCoQayMyiEsgZ18GNgl8Y/hm1r4AZufMZ1IMd1MIlyd2RbtEXHelGHoAiO0Md/7AiPwKyV4AiVcLXqOwnZhaT8gV+pIAwhaL9om7/qcL/fQKUeuA3YYA3VUA3PYAzDUAtjoAQ0MBp9sP8Ii4AJp8AKmZdWqHBmnABJmWA3FUx65Rk0v/gJCod6HMzL4zu+Inx6k2SwkTQKXdmmM8EJadBCL9ABzWyXKGuOmuaxyoIA0GfNGassNpTNmUpNlCYVPgfO4IwBLlADQyAIt0CNRthxAql7VuyYRVcRSlgu0kjPIOcNqRAJqmkFWDC0/Ry9aSxR0vt2c1AHbuwGB+0GcnzGr0lku9U+gGAIhqAIEC3RitDHtdnHj6DRjmAJhXwJ6JsJm6DIrzASwwAN0YANU3q/k1yl2eDSLt141iDTnDwN0XAMvCALd6AFRUAHi9BH62sKrTAKmaCdmXAHQQO5WJnLmWTBFlyemyT/P5Y0VA73Zm/Gr3eqSlmd1ek1zDEIuaPgCYBwBC6QFOZYaRBgsR5bcx5Lc9D3fNbMANC3zUScOA0KIn0ZznldAUwMe2cwVVTFhhnaxY45z/T8xV+sv4mtDtjgCw+hBn4QBVjgvIJivV8n0ANd0Hyg2QddB69DxwxtUQ8N0RYd0RWd0cz6CJVQCc+q2ukLsH9rCq6QKrxgDNMg0x1oydlwDdVADZzc29bQeMFtDdMwDcYADLswC4GABVvwCJjQCaCwm6iwn1DNEJFyB4ygBsHoCH4Q1SA8P5l0P3caZw93NFSTP+dNvuPF1QX7tzelCdk1CWkABMyMlzVn3/dtzQuQ/7EZe7pszdboiGnKQsTVBLt6Dc5A0J+wJwjPQI30TA9qsZNaGg7doNu8LQ3PwAzJkAy+QJb4cZZpmQrLaEDxeWcPcQdG4gTOy6JDW9nY5uKROAdnrNkzzgd/sAZ8ANoX9dClbdoWrQiprdGpnbXpi7U9NQl/S0KvMAsmdwzRANwyqcm83dud/AzVANyaXNPOcI3YeAuagAZvkLWYsL5qhXmYdAeX0AYIgQaQEAhHUAWX0DSHkAWGcgl+wKz1E97lBTXmhd7nbdXBLMwGy13GlwN1OWmTZtcZ0MxK4YXKEtf5Pc2W9rFhKCIDvqBCLLvgnOmecAhAQAIuUAWRsAtmif+WIQ6fJH6iTawDq87qNeACqz4ULiDr5Dzrs17OgpCRWxAFW/CwQqsG/VzZcAfjcEfsckzjmv0HNQ7aok3RpO3jGV0JQb7arE3kBqcJo4AKrvAqs6ALxhANxA3c0yAN0kDc1SANWo7uy2AMxSAMzWDcu3ALrqAJgRCeN3WVsjzUmCQ7aIAFT0AkaZAQl/AHUFAcdZAGVYOJfe4I5f0/37tUQ9Pn5Pvnl2CwBTsJmwC54ZgDXcgBL2ADPYAE76YFbkAHdEAIhMDjfDAGS3ADJxACGoDEMIdzDapz7GjpmI6pZ9iOWrADGuICkDAEZxDrJED0JMABRY/0JAACS7/oAlr/9CCg9Euv9E/fASDQBF7SBVFwBE5gBcnx68hBtJBI7APNkZlN451tUTmu482uCBWN2oIs7arN0US+1O+N7dr+KrswbtHw7dGwDMuQ7sXQC7uAjbpA+L1wDMcgDLywCxu0CqugCqbwCYHA3TcVNGhgBU0gsUOxA0eA+W0ACWmwJ2nwh4GQE8eaPwgh8aKEKA4vNBFfNKpHP5NA8RUPuZwQCEKg9C8ABE+gHV7ABDsQA4NzAsUPODHw8UzgBYWg0Yag8jewAhTLoDWfjjcPu+14qZeOBDDgAS/wBo0AAuP46VTfAUUvoOeP/s/MqevPqRGAARyQBUcABUcAGPLPHMih/wXPi23Ezv/8b+xnDxB8/gD6s8egQT6ADi085MgRIkQOJTp8VOmRo0qVHFniiKnjp0yZOH0aZWqVK1ezbu06Bs1lM2PAdt2iVZPWLZy3cOna1ezYsF+6cN1SuYrUKJGNAmUKZKXJkyM1dljJUUPIjqeSspgx8+ZPoK+BGi1spLQRI0iM1KoN1NZtoLWMys49ixYSpEuXJl2KNEnTpEmSGj3ZkQOJFiYxRozoQMEBA8gMHEyO7AACBAoYPpy4scTLo0eGvAiBAcIChQgPIERgHUHC69cUZF+GLZtC7NuwYZCoAYoTCAymSbxwUbx4DeTGi5NwQYIECBAdOnCgTh3D9f/rFlI/wNChCBIjRngIQfKE63kzacasYROGzRz48eHnoV+nDh/8+QUSLHhw4EKFIopoIokqsSQjjjgy0COOPAlpJJJQkfCkWWahZaiaYHEllVRKScWmnHDihZdddMFpqFpWWWUUSJg6ywozsLCihhyOqEoIGq14wgoszIDRjD/qMOsQsQQ7xK64knQrLrrOuuuuvCbJRBMqA3uDxyyQeMECBxY4AAEwF1gATAQWiIwBMdNUczUQZIACEAP5gGKFEbRrDQLY8pTgMjz1lMA22LZ4o5VRauiguw5AGKIKHZo4o4ohmhBiUkp3uCoHGzJFLjnjmGvuOKu0EFULL0pFLw3/9bxYg7335Isvj4PqWMMN/fL741aDbgVkV4UOichXAjXCKMEDDUwQE088GWVZU5pVpRVUVEQJJViqrfDamnTCBZcReclp211GHIpQTg7hahNJzIDiiSyOAAILIbDAQtIcsgDCjCOOeOMNSf54ow6vLnEErruSjKsttNBqsqxJ7pIypEmO+uSTTRpJAwseVmhsTz4foOxMBhRQAE01SzbTMgxQ4GGNRzABREsPMLAAgwhmu6wBBvjsEzfZ/pQtllhG8eMGF2rggAQOhli0iioefeLpp5poAghKqd6hsByy1prGrLEW4glRpyDVC/S4GsOLMdJmo1VX56tv1lr5uO+g/z3+QITXAH8FtkCMEExw2I48mXiUo0gxRUJTVDmpFWqrleXxa2s5kVtecMF2cm8Rl+TKRoB8w8YdXMDRqixcAOFqM1x4I5BD6uiXyEPSOuQSvPKiHeGCkZRrYUgAgzKkZT/hpHMbQMjgtJr3bODjNCFbQGSTSz7TMgs6QCEINzDBxI0eTsggtZvN7PPmBiSowLbcZDvFE0fm2AIJGYoDQYgymqiijEfLKMMKpvv3vwqpRY1SA5zUDt5lBrGJKgtbOQ/a0pY2L7hnbWuLDwXhsypa0Qo/sqoD3W71QYgkQoR2E2EiCFQgAyFIe8ka3MQ+QQoYHq5Z0VrcK2woi2tVSP9y2trWLWqhQx9uyyibmMQhsJAFIUgiDTkAwg5s4AIUoIADTZTKDtxlhc39wUiMcMhCHHGJTNAuLWvJXe7sMkZBPKl2tCPJJ96wAxRkgAIWQB4EHrOAj51JZHtUwJjC1DySQcYBqoGABTwQgyk8whN2QALNHjPILkGgAeWTQPly4ydL8GENgBgDFGyEAhds4gn20x/+SllKM5RBRlbQ3yqtYIUrxFJHsBzlEbCghSkksGxmcCDa1vAFCU5wDnmAjwVXFTf7dNCDdbMbRCBCwhKe0CEZoWZHVsiJTWQzm8o6CuEOt4potaIVr8Bh5L7Vw1r8UBavcEUtXoGKTxyiEVn/2JEVPAnKF4CgBiMAAQeKYwMh5GtfjZBEHTbxCUk4IiQLBaMY1ZIWM6pRor17khgl8YlGXMFQMpujBfb0GMl4DKSR4SP0yCQ9MVlGZ6xZjQd2YAdM2MEGcozAZFgzyT5N0k+vKYskAmEGLTRhn3aQBFbME0ukXmFUSYVlLOXFv/41gZZfg0Iup0C2spVKq6UaAzAnSEFiFhM+soqb3PhAN7TeypmIKGFbpekI0EgENJWQhDa3CYqDLmsUJDFFSVChOFfY0BWwmEU6d2jYWbBzFaVwhSxq0QpGVKFGOXBBDkYXswgwAAMv8AAIqPa1H9UhB2/wxCXsotBMrJF2dhFj/0X1ApiGOSwwc5HE5oTgvQxggAKr0dkDBJlHPY6MZGTqo/QG+QCP4XGSg8zACbygCEAEATgsVd4kravTPKErDXYAxBV2UINDjEJqQohletLAFS2kYVSjMkMWrpAFqPpPqld4An3b64UFYrWBW+VKGrz61baNdQ1lxQ9a09pMtrZVhG91hCIcTJFHaNMSm0jWQV3owr16c4aLjVZjK1TOxKqoFKN4RTpfwQkgNAc5NjDaAzrgxxq8IAL4dMETsnarNEgCjJlwUEg+sWPbqTYktssEbI08CU5MgqCbCMQVYHACD3TAAh7DTAQu4zE0TQa4YhJZZNIEPTORLMzHBVMfEf9AAAQ4IAM2cMMjAHEEF2iAAdelM05hg1AljtIKJHFKpNTQhDecsgznUUOh73BoRAuiL1QSxSdKEc5AnNcKW9gCF7jAla2aygxoSAMagvnVVlEQgwQ2cFrXqmATMvjB1KxtNhsBCENYQnAUu/BI9Lqso5RC16mQlorAOUNS2HCco3BBCNrEAx5EgABq/h4DXjCCCCzmBvWy7BsWcomluDCMIXGQ7Rq644WG5C9HBkxtfdoEF4wgAxWogATuaGUtI9eOWqY3yLz8PEBGDzIKKBNkwOSACHQgB4DwBCB48AEK6LTODaCNBAi66UCQohamgIMgBKEJTnBiWY+W1g3TycP/Ef0iGMMYxjGO0QyXuCQY6dqXpbnA1VK9/OXn8XQYPt0e98zBmG6Y1X02qMxS54qtzXQrgxusiIpkpLYxHYEABHABJijiE54w9ySymXGSLEsUoxCFKCKhCVGUwteomKEpXiHOZqFhozBAgccy8ADtHA8CNIsBEKqygzp8JXaOmJjGP6EJkCQrWdsO95SoVKUjJxkwd0gxY+RoRzQh4DLApTe9l1fvkPExzNFbAJrFBCYGPAA1gwRBEwzhiS2swN3Kc8DyGE6bCKSRE67AxTCCwYtf5B4YwCA5yYMxctuT3OTDH37vid+MabjEFuqywhEoXekvgCH6LufCF4B581AX//M9sGLDGvZQB/jk6iD0ObAziR5NAoGmIuo3ViVA8f4LBAAA8w+AAEagBYdYAhTJ6ibV33AGTYiEMxhAQQi7k1iFGyqsWVinViAFK3ABDKiALnGAmDkeMDkUF+iAGiCBrEGDJ7iDbeMEKsm4kci4wpMSIzu8w8u4ESScUWiEI6ATD/CAD8iACzgfloIA5NpBkToTfAszHxQTMSsuIMyykaqMkYKAE4ACTHAEIxgBDZCNDNAyK4OMB+CWkhs+nyi+YTCG3vvC3jMGMRTDkvNC4luGZogGaDgGUtAC+DoC64vDL+CCSnM56wMDMAA1AJMPgximPQgrWAk6DwKhBCu6if9Qv4uYq4zwhFPoAQEIAPmDRAGAASZYgkd4P0/YhL1CKEDIAkVTmiFwAot7FEEIrMIqsQU8u02YFNw6ARNggOOBjAjggAfIQBzZkXMpwQsbwb4jQRHEOBUcQV8kwaOQBCyIgRNQNxq0QRzMQR5EriMUQnsLpCHkPOexRjRhAAqwAYJbAxn4ANaApEGqwp8gviz8iS4kwy80BmEABmEoBmF4x2IoBmNYBjMcvmVYBjXEhTpwQ6i4Q+mztC2QQzwEAzFYG5tLyJxzG1ihD/p4lUAURLoJIQVrsENExKRbxEdYAEiERAAIgBboAR6AAkWwBEeoq7yABCe4AzUQBEbRAR3/OANBOAMSeIAIyIEqiBjHepxWUIVPsIIdeIEasAAUeDEPGAEGAL0O4A0hcAEgCARJgAThIQWMy7oWurC+60WMy7iuEx5fJAWtyIFk9IAMWMYLQJ476Zhn/BjMO0KSgZ494jw1OSkxg4ARQAIHY4ITwIArwzLV+EItXMcx/MJ5pEcxLMwxvEeTy0doaAZTaC8myBeAlMPoK0iDFAOFVEgLGqaHhEiHlEhmwhVoKqFDUIRDtAj2+4gdcLqOBIAJ6IEYsAEjYAJHOCjayQSLawOXdAEdIIGYPIMaGBMCWADuGAEzMAVxUgVVaISpwBcQgMAZywAGGAEU0CeBYzEgqJil/+CEOxicW+smrAxPF+q6ZRHBjNsEM6iKFJjBDKhBG0TLtLwyndEyyai3aHwePvqj6CGTMuHPNVmBz9CCLRk9yVgNL/RCYRhDk0tMBhXDdzSGwjTMwzzHY2DMXbiDNMgCT3qCypS+yiTIgszMhNxD7ds+h/RDQVQrRDAIihShAWEwY8GETcgAARgA1iyAFkiBHjCCJ3iDRmAKuBAEloSDIVgOEhiCMxiCByAABkCCGMgsy/gAF+ACZfmDGkAB5JiOHSCBRAkODtAny0qDQyiDtKCdUQA8veqmW9Mr71xTNr0wJQrKF4CyDCjLGrxB5EEN1MhBndHByqOMkeIyfkOAQf8tk8/jTwT4EgQwADD5kgP4EkYFkwooAjqggx7wAOSyMgNlxwS1xwRNzHb81HiMxwidx8QsBgpFw2ZIhUHzAib4GsucTIC8TBGdIJujIGHyTLcpNUIUurUyur7pCEDoPBt9xBKgASJQAhuAgkaQkioggSbIgSOtgurggN98AKeLgUvtARu4AAfwPBBYgzqAgeL4Ug5IDqOpgaKxgRzo0ZZkBDSgkr7SBL1qFlNQUzfN1+ABPFLYhDQAAhsgjhEgywpYxvdEjdM4DdngUz7500e6N0RtVP58VAOoWAN4VAKw2EY9AKeLVAYA0EfQSwvQQdVQ1WbIx3ysxzGU0FFtWU7/ZVDhM7lmmFleEIRWhYJJEQPLxMMOFQOflQM5qFVbxdXN5Myw4kzxS1EVNSEHM81gORZMGAMxedQBSAAaoAEfCAIm8NFzcwIM4I0hoEUMeAASeBQSqL8IYAIBiIAFiAATgIEViAADEAAEiIAPsIEigIKMkQEZwNIRwIIj2IEdkQQ4UINJ+LpNRAUNa5Zuwtd8HTE2LcE3wBG4NYEZ3IALmME7rYCEpSPPXdj4JFloDNRD3ViLtVgCSN3UPV0DUF3VdbrUPQADWACoMwQ3kDHZYICZnVlnyMdmkNAI5dSWFdUHVcdjMAaZbQZYOAMraAMrKA8g2FmercyfBVoRtTmd/8tVnZsPtzFa8gNNEEo1RTAEQwiWauKIMaAZBpCAAtgAH/ABIkhWN/AEpQgEJ3CUZ30ABHiApBkCHSCAACAAHmjdGPgAybPbG7gBCFBdBjgBGRACHoAfHjAdGkmDQLiDMkADSKCSUnghUiA7ew3hEDYcxoWhUdA1XesrwvmEQLAxGHiBFLBcsryAgXXPs5yZmcEOOooAO7EyPhUpkEoT/mTdinVdIz5iAuBYpxOAR0UABriAIlAEmZoyCBAGX7hiLO6FK+4FLu7iXtiFXfBiMdbiK/YJmHDHY/gFQWiDMmiD9sqCN7jM6APay/RZOxaD65OgW8W5hSQmE33IPZgDYP9qSF4NzT8QIV9p2rcyFkvAAgywjAY4gBZAViKYgR7wAqXgF0aAgzNwAf0lgAeIySp4AEiUgRVggBBIthWoBB44HjdAAgVoAAU4gJHJABOQTSaAgnXJSTX4OnpF4VFAHI2LIVy7VxjC13vFtWWBFuXcBKqogRiA4Rg2gYFlzzo9y47y3Nbg4W12RixLqeFK1CZeVNRFYgFAYgIYgNa9WEVNsxSwA0tAgoEtzFGdx1EFBl/wYjD2YnzuYiwWhpldBnoUhmGAhS7oAjRog/PiCjaQA50FAzqWXp/VzITM3lw9WkB8DzYY5D8s5LqpG4hQiKZ90ae1BDewgRO40/glAh//CEkmSANLKAtHUAMd4AACeEQOeBQOcDoLkIEFSGAMuAEeqM4V8IBH6JLhPAAGUGoKyIARkAEbeINNuIM0WpZVADtdI7toCWYV9isRrlcRvtdVUM5RuAMceYFoToFpHtgavubOlZkd5uG4jk8sy0Yhplh2bl1zXmJ0HoAByNhxBhMIgAE3sAQvWAF7LFV4DNV43D0rxuIrJgbJhmzJdobeRQZi6IVfiIQooLlOM4MwiGigfeiCtOPrxb5hsmjVbg82iEiJLIgPEmkHe1GImKYEgS4v4IERMAElyKUiyCUkSINdUQorqEkEoFuY5ABIJAA6MGAQQIE5iAIoMOULaO7Z/2XU1iXUy6OAD6gBK1CLo+grSOAEUviEZlkREkYFGJIQFAbmkgjrv4IWSYCCHHiyGIABtV7rar7m7MhhuMZh7dhTZwziuSTnjNVr1fVrBV9ip1NwB/frim3iMcGjE+CDShiD3s1HZdhwDi9MYhAGyZZsZBhxZEgGEh/xZEjxZ3CGZ2AGYjCGW3ACLkibTeM00L5jMRhtHJ9oW91jUNO+m8uD9nBtpf2ggfgDQ5htidibjMgLRFAESRgFfxVutAEE6LKYQ7iDJtCBHUQAF0hSbH3EBQiBETDUBB6BD+CBHhhO0OtPgJM81bBJF4CDTyA7YCwJo4gWw4mWCZEQVGjvsP+2V1QQp1FIAyGwAbi97xVYAbU2AWquZvfMLezQ4f4WcJb65pJp1NM14gfvdE+32EdtZyc+gTHwBGY4dVQ/dQ5H9WVI9Wd49VeXBmmgBmqohmu4dW/oBm/IBmzAhlQ4AghKJTTgijDYcRy3TFDTY83scbYhpjD4gjn4QxQt8oFICPL1FYjYm4lghAhpBVlABW5vBU2kmEbgBCI1GlrkgE88s0ekvzRHgTGhIy8Yk8dAAA1AgTJZARgQvZpBLu0omjcw72P2c4JfhfM+nD9HYT//JhBGhVc4hUYAyoBNAUR/4RU4gWRcDEjvgDrNAA6YdLjmKEuHNzQhQjIpZ3ROedf/rdgCKIBQp1jPc4ARYAJarwabv4abv/Vs2Aae3wZ1+IZvUAehl4d5KPp6OHqkR3p5kIdoOANg56o2GPY1OHbrM/aDrCAKysyvutVX2Whod0gil0iCIF9DwPaFGJBUswSSIAVXuAWR+wVeCIZXUAX1/oQVUYPm+Pgh6DoOODMA/siObIACXgAjyIDhtADiRAESQIAQuIEP0Cyi1EaS2ZMREIJGMBxSeJaxAyc+B6exI3ga8vNW+IQ0QAInguGKh9sUSEZHXwxr1gANqA4dzmH4ZKk7Ki7TLeIDV/kDJ+KXH+ck/iMH0IChJ/qiP37kT37krwd8wId8eP582Id76Id8/7iHdfAGWhgCKOCqNWiDNkibY5c+qw81sNJDhPTxEvVe0PQgWCPfvPGVaJK1UUDAWdCFlnCJY8AFWUhOWUgFOHAOgOBAIpIoUUMeIBBAQEAAhgACBBhwIoYAARYiEMDAgcCCDhgQROAQAQIEBxYUIFDQIMIDDjsaoWolcxXNVa5q4qyJahWqnTR7kmp05cmOGC9S2Iih9MUKFChOnDAxYoSHDhk+fOjQgQNXDBgsgP1KIcJYCREaNGCwYO0CBAcOGIgrdy7dunLf4k2gV4EChQj+LmgAYR5hwvXqFU6suDA9evfw5esnWfK+fPTmXTsz5MgUL2M+mzHjBQxpMXLEiP8Bg3o1aTBs2MxhEwZ2nte2b8uGPWc37zl56uTJs8dPHj/Di/8JtCfQH+N7AEH/8wcQIkTQESVKdMnTJ1WrZuEaBi0atGbDftV6FbOUqCo1SJAYUjBVqvYbK1aECJFhAAYOBLT0AAEcIITAAw9g8EAECzDAF1oOONBSBzU88Ukrr7xC0002bZiTh6uoskkaTyCxAwxH2WBDCy0YtYKLJ0w1FQhVaaUVVxx8BZYFGIxFAQVmoZUWA2q1hddbBuCFpJJwMXkXknntxZcCBAxwAJEOKJAPPodx2eU8XSJWWD34SJZPPfmUI4443Bw2jzzLnOFEFGB44YUWY4QmmmqnoSb/R2urycEnaq2BESgep6kmxmef4dEoHovywQcdeNTRBhx+XHoHpn5o2mkgn4J6iKijMuLIdp+Qgoors+xyDDSvHvMLLrWsYsoon0RShQ7vRVJfKrDQJ4oOHCQ0AH4QAfAQQwkCSEIEICH4wAcMbKCSBBdUYIIEPpKkERSSqIKhLLLMMgssrtzUCoeuwMLThqQA4gYTQfSAQ1JJxQCDiytABeMIM2KF1Y04YpBBjhb4SAHCZkE45JALoPSXW0bOBZcBBBTwpJFvuSUxX2yt5Z8DJHHppjzyqHOyPN98o8434XBzTTbYaJNNPWXig0820jzDzDXVSLNMKVV0ccRndqaR/4YWZoyxJ6CrQW2aoFAHmlprkfLhaKCMSkoHHXxYCofYY99R9h2gop12IIeUmokno5iyCiy18CJeecDsMqt6o3Aiyhk66DAELLQMDguwkZxxRg0YMEDAQvw5FMACjguEwAIsRZAjBUGqgMMMElRAQQUkRRABCDlI8kq5s9CCLrqtuH5uh6hs4oYXShTRQ70ppqiUvi469W8IWA0/MI4a5FgBwjqaVZIDDDTwPJFS6pXAxklq/Fb1UnLPIJEikwRBNd9g84wz5yvTTDPGCONL+77kkosuuvhCDDiT4TOPNMkoQ8wzyzRDF3AoQxSicDQzJC0NnklU1KoGqEBNLWqEwv+ao1DDhTFk7Wt8cEPYxgYHNZgthGf7lB/8kDa2XSITn4DbqnDBi2AMYxi8wAUNa6GKW2lCEGpwwhloEb9c0IIWqRDEGXQ1hBqI5HEKWQgBIAItAhzoAQtI0AIggJYL9GAGFZBAA1IwAghYwAEjeMEHUGAGToziO+jSkE1eIbubuIIUgfDCFJRghNzxgHf4+l1TggeCEITgjwK7EQYuYMgL6Eh5PxoJhJznMIdBjC/VY0v3QvbISw4JQpocGel8EQ1s7MIXvQAGL3jxi1L+AhinzMUueuFKZHQjH/zox5aqkb5mvKoZqaiCFZzwhDwhcA1rGENqGig1PsnhUBDs0zL/WQOGRS0KNVvA4KMi5QZMeTCbcAghCUuotkC0zROZGIWqZlELGqKzFrJQxSc4oQk4EFEUusgFfWihC1iIQhA8HALgFocQAiAgLgxAAANEEoC/ICRBCaIAxEzQghFsEYsmUBAEkGCDHYxAIySwgilKYTjXZehchrPJJsyghTresQd5zGPv8rUCGfQRBf8CAU2LdyMNZCCn2AKLIiXQPAeMpCQPkp7DpERUTIpMk0ndpCbDRxZhGAMbzhClKn9h1auWEhe7MOUwlOGNe+iDH/VQRzWWEYxfHCMYuIBEFsxghV+GJmnDJJRppHbMPjUKgnp14KCeCc1FXfBRGNxgG9RA/7ayiU2EdzjsN9cGCUccQhJoTNWFZFGLy8riFae4lRoSlwpi+OJvVfBoKSJBRH7y8z0yQEFbDGC5B2ggAg85KAISdKC/fOAGJvjAFlUEA5bEIAg26IEHImABEjThDmoQRSrG5TpZiLQVpngDFk66BCMYQXc80N3u8CUDmDoFBTSdacC48gENoPdgYklY6cZSuvBFkalKXepS5dvI8DmVLBaQ4S+0MYyt0vAWAp5FZltBClKYwhRuvAaZ9IEPdfhCFJGQgh/Q0IYsPAEKRxBCAtPwmdKURmrK5NOeRqxXqBHqr4t6pmC/xkE1wFibiTXbjNHmzVAx4g11CEQjIHGqVP+pQhUy2ewnGNFZeRJDELuqQRMEoQnTElFXu4pDG1DwAYRIcXJNhMjkDoQRB8jgBCE4AQVM0AOk5HQKNjDBBtISAReUoYhnEIRHDQeLcsHiFa34RBawMAUmLAEJKeWu7lLEou8CT6YjkOkfh9eBDwzvvMjb0aR15COElS7Tmg4qSZjaafyCOr/vJd2lLXCJRtxBE8OYxBCqAAQg7GAHObiBUkaQAhjkoAyCeAY9+rGPB0vDGbroAhB4EAUoAAELR8hBhz9T1xDvNYJ51SseJIgaaDZKxWPAAx042IZvg9sPbSghuUu4zRGCyrBlM+HagJmGNwCiEZhYIYKDTIpPvPP/DJFgpSByMBQb1CBwkWAEI+BQBX7CwQkkGBhCFqAkBFgAAY6rCAVWMIITfMABPVDBClJQARgYYc0DZUAEmDyESCBuuata1SwwhIpDQAEKJwW0oItgc3p1NwY3QLQLwutHQULaA1hJLwbQizyv6AjpYNm0piHAafyOmnSbThjVdbSjFbgAPo2wBRCyToJFS6UEKdhAC3rAhEOIQhrniAw91hGOb1iDF3coYMyRDYQOe0YOekAU1ZTJzGSauFF37ZO2t70owa6hOOIG97jLTe4aI/bcmmI3MNdQB+pY4m2jGAUpVIGKUYgCDvqWXyR2MAUyMOEJTgh4GiRh5DPAQRM6/4APfHQQh8VJHAEQeFgAlFUACYxgAStoQQlaUIEKKKEHNqAAQBfAASAELhWRaLUgRMFyArdiFGaAghHoyARAYzf8OLeXDXb+XRn0PLwz/eOjPeB+SWtg6EbHqVfqr3SrJwwsVC8dwtybf6sDYFgUjAbAgBC8QKydQjBYARAIQQ4Ige5kl+5MgSF4gitUwzxABj60HThcgzYcg9hU2BuMQRY0mzAdSgOdxl4x0+Dx1WpwGx0U3qQ0SuIxnuORW9qUDajkYGONiiM4giX8IKqYQkxkiN8MgSAE0RmQQA8owRQYQSD0HA/wgBEcQRQ82ewJBAnQmSjIHrFIXH7ox34MQP8FqEAJlEACrEARZBcEGIADYIAOVMEZFMQQDMGciUIpmJM5vcIlYMETMMEU/BkTCFr45U53lZ/5gZf61dR5BUwGzF96BWD9XUTpIF2mLV3UOR3TtRcAltqO1F8GIMEVMIEhpMEVtEIwSIIVjAGg2ZETFsEUPMInlAI1YKCW0AM80EM4yMM0RIIaCEKFSYEXlKAwNVO0FWO0iYGJbc0LwuAYeM1neA3W8MEcfJsNWmMJcVNjhYqoIIIjVIJ2qBALvQJ95MoZDE4V5EAQKAEVQEEdRMErGoEQ3AAQCAIkWEENuIALyEd9FAQRkUATPU4BDMAAFEBDCEACbAAX9QANtED/CrgWA3RA4FSB3wSOHZbC9aFCIEABEvzhnwVa+NlREYzfIZ5fTDEa0H2A0MGf0dXf0XmiJL6kAB5M/1FdJ76kJCrMTeaUFtABIXgGFryBLKAiF2yBF8AgHxTBEoyBJYxCKVTDmNjiOLDDOqhDLujQYqFBGIyBMKUBAsmVMYJlMhnKtE0bBD2K16Dl16SlNO5GcOzBW8JlXL6lDWpjIJzNITQCXjaC6/kYGsXNTQyO9A3OGeSAGyhCHzABIBiCF4DCFKhhsfHAEUCfDkQCsBQEygnRGRCLACxA9SSAseyHAEiACphADHgAQD0ACQgcLNBhHdIZKtyZOmnfRnbk932k/xHY0aApHw8gokmKlyC1n0oGzCMaXQYQkv0hZ3IqnXIyp/1xQE45Ih08gk/SgSFIQlAGgyPQQSIUQiUowhb4AXeQgitcA1RqIDiIwzpUA+IIwh182xx8gTC9QdK8wRusATKKgR6U5Vg6Sl5pjVkyI1p2jdfgAdb4hlvKZYLe2I011tk0woM+qCQ8Vib4pdwMzi8MQy/sQi74jR0AgiIAgiUYwhg8AhYgARIswRLY3A0cgROIwi0Ika/E6BC5AAYExgQ0gF40wADoRwFswAk4HIC4QOCwR6tRXymUArmo0yRYgSgyAR0FIs0RIs7ZAG+aXx+ln/BkRUq+X8B46dCdl//x4IiYdkVy3mRzOidXQKcGLEIonAIlgAIr3NAoBAM0yCkrxIKevcJl4UIvfANkaMk6cEM3fEMunIEvwkEbZOUX1Gej6lgd9OeIReqk6uekkqU0pmVaFmikBEenJqhcNhaD6iCPQehe7iUnrFDcqA4uBIP6OEM0CMO5cIIOcQJ0SIIZdGQdKcEN8ECuiQItwOjgEA590EcpREEIaIACHABa4EUBIEADEJRCTIgLnEEqaEYdnoEm3KFlpUcgYIEoIkGdAGIgLoES5KZIqpQU9qbPyRQgBZ37RdqXShpW1AiZkima1h/B5KuYtiQN2UIwAGzA8sI0YAPAHsPBopWrTEP/LWoJOVzDNUhDyiUqGliYH9RBHTjqxerBxm7sfzoKx+IByPanyG4qpqplNEpjpyLop74lCdlYg65NXpaqZG2eqspCeLxKNEyDNWjDNNyCKCxXI7zBJlgBFEhKE5KBESyBsukAHJSCDykD/AALfdCTJkRBbAWJAhRAmUmAQjTEA4CAC/TKtdqh9V1WLaCCGmSBKHYflJKruRKidlkpou2L+gESCMRIo91towVMjfjtVthr4PLrvg5u0RnsWR0sNLjKMNCM4iouMAwDLk2DPJAJLakDxBpqG4CTfdZnCNVnHUTKHnDs6PInyIIs4DVKxzaKNHaNG6xlyqosXKps7A4H/7uVWzeV0BtMB3To5V5uQqquwivcggu5SjRUgzbQjDZEQy64gijcQUl5hlHSAR0pwfdhQRM4gRrAAi8AA/wAUWBKn66QQElIQGBIgLJCDgKQwJORrSYgqWWViyaUwdoygRGMgbgCIqAxAdzeEb2o65W+1GoFz7/EiIzQFN5OBSDdrfsxsN96qY3Uq+Aep5genVdogKsEw8EGbHm8ijYoLzQAAzBkcDNEA+Xmw6/Jgy0NjR/omDDVQRocQh3cwcVebKSoburuXaQayumK5X8mE9ZMCloySn+Owcq+pcryxmscsXEoB3EYxxPvwR/o2O4CQu9Kwu92XivIwi280DEYL/82bIMHI681HEMpaIIVWEEa8IEjUEIfACIdTEElvAHFCsIlyFMv+ML8DCvK6ZsVMA4D+BReEIBrCQACwKGc0VkpfAeBvcIdzC+uKgEM1on3/eH+xq0QqKsNnN/O9ZGMFHDefvIfHfCM1FQHhIBw0mtWhMCjsbJGaIQGcMAHcAAsu/KYsmS/uhA66TKr8sIxYMM06MLw8kIoqUMt4sM6XIOhWsHuRgp0gK501DAf1AGAas3IVqoPA95YmqUc8AHgLQp/KlPIbuxphKzomqV+ykEe6IHosvNbrrMe/MEaYI3uWrF4noIqrAoXA0Mz7Gw1VIM1WAPNYEPcpcIZHwESBAH/EdCAEgQBDwQCEJQBEASCFQyBi9qTLxCOhCUO0OoACGSOA+ReFB1IwLnmHapKbLoCHHilFjDB0UCp/lqyEQQBvQRBrO1AUsjAC8hADJTkCITAJwtPTdGUKStwURNPpM0fmLLkUhdd0aVXBRMneqVHZrkChrxCZpFLEO3CNBxDLrCO/LBJzmzJNaSCE1gBdAACH6A1H0hHpICuNEtqNX/sNZOlxypjMx2TA53zNfMwHoiuOHOsO7+ldBSCWkNHzELoFYvnEOYz95JwNFBDQAM0zUzDNEDDLJzBTRsBIN7RG1hBIDSBJGSBFWDvRPqQEEkYyrmHC9QAClhAW0DAwNQA/7YKAkHQx52ZU9qqwXyelEvn7/ftb0jO9HDXdA6wlHedn/qxKwh0wAFrRVErMKS5q/wNZ1Rb93XPnyv4RBu9wqrUgj3Fjy4swzQ0gy/4QjKAwz70g5nUwzPEyRFAB+uytTTSsH8CduritzhHKjpH26RS2wmiRlyr7g2HLA5X6oFH8R5gjWL2bmIrNvBaFi78gjAUwzLo7DT880BX9jTwwiqowRAUbRFkgSO4gWJ+SlcalhM0gSZYZilIX2rVQIyvALKiAAmwNuyhHEG4OMvVwiyIAhoEQh2Y1J3c70sD922KJHHnQA7oUQwc4g1A+flJuVPQHgnUFHRD95dG90pid/+Xoxc6oRLAxlDkNsMymA8zPMM0bMM2XAM5wMM/9EM9yAMtVIETAEFaGzbW/EGkQLPl8bXoju7oArZ+iizqgjOl0rVcWzOBl7Ogl7PoSrNhN/jMXnE42sQsDK/89EIxvGplSwM1bHg08ELzwgEamIEnGAIhdMIbSEIgbMImjEIbOEEmyEJB/4omSBngvFoOxDhrH2FtSxiSusKA3YIsaIIaMEIgeBiRT/Jv22ZuYtdwtxS+lN8mQ/m1f1f6UTl86C2WG7V0T3eXy19SE+er5Gw06Gx5fNI0XPgzBJs0YEM4tIM9wHk9YIMo2LlDSwdaT8ees/Uf1PDouvPGDvwNU7P/paLufju6pRq4oAd2XD46x0ojICB2qUaohF4Cqtrsnd2CLvSCMZDwNFDDyG+4ZevCLIxCIDjCI5yCG1QCIIACKHhCF5SBKfCCKdRhDtUhL9GhrgecDugbyhXEHc7CDA3vHgYCJEjxGxilS7utbQ4iQg/3Td/LicAATEFFeAVwz+VjPtY4CTjFKAu1t2f5uD8il2M3NLD7hZe8NVT2L1tDNLh7NVDDNawDO/xDPswDMZxBFABBDlAxWh+CdBA+1hA8XB4+oJMsgHYsySJ6oe9woD88oCu+4jf8HhACFa/NpCc2OEFCOA5hKZTT8G66mVe227u9GDfDKnxCIJyCI2CC/yI8AilsQhtYASrggiaouA4AQRPA2BlYiqvtChwSxHwEuwtl1StAwvJLsZA/Y5GPK7kigRKcaBCcaAPei1EwBb+cALv6XNd/fXjRVNiLPdl/e1KjPXZvOOprgzX4s9tX9rqv/zWow5nUwzekQhRsARDUQHIwh/8DRKA/A/nwIahnT0I9CxcqZIhHDx6JEyEyXCjRosU9ESfKEYNxY8aEIRFyNEmxIqGBfwAdavTykMuXLyW9uROo0aVMnz5p+jQKlatZt3ANaxYt2jRr1rBpc6ptmrFVovwAUmTpVBsrcFzd0tQGTZUjOdAIgsPo0p0zVnQMiSQKbqpUojS5wsWLV/8wXq0gXWr0580bM3TojBnjxcsUxYqZMFmCBHLkHTZsxKAcA0ZmGCtkyFjhAkVo0S5IizZ9GgUI1SFYt3bd+kPsD6xlx9ZwG3duDdiU8sb2jam1adN4KyWOrZo1bfLq4as3LVIXJjlqBIo50Dr2PwVZ/kH4ZyPEjSQvckSZ0Tz6hxXxiGkYHiNChyXjf99TnzsgQDMbBbLOv5E03qgjkL4yyYQRSDQZxZRVYJmFl1+Mgqa3p7TZBhtrjMFlFTi6+EQrOGqpBY4yssjiCigOkQQLPy65JBI4zjhDlFJKSQUWWEpZZZa7fvnRFUgk+SuwN/go7LDEplCysSUeQyKIKHf/4IEHyi7rbDMXOPNshS4/Q4G00lBDbbUQynwNTdds0003aNyEppk4gTnmmGGOCeaXOnXRJZpndElGnXnqqScXTSQBRI0zGIlJIO0CAYQl/QBJaKCQRmJIofhGIi+ihjAdSY6KPlXoUvEcGm8++TQqJFJDEHEE1kNehRVWSV681RJPdP1pFFJQWeWVV2rx8RgKp6kGm6a22eYbqGjRRJQqnGhDFlOyEAKIyXZwwxEvjjgiEDjMiqQUuESZC8dbdNkFL1xQmWTIgQRbwzDDlFxsCiaQMMKIfYPooUorr5RhM8/CDA20MVNTTbXQGF74zDRrm/iD3GTTDRdcbtmYlh5r/3EFllVuvDGVXHx5Rpps1FGnnm3mOlQtQQ7xDzv/Ho1UP/lI3dQiPEIV9T2SHKqvU/QuXU9nT1NVbw9CCuKjpZgOodURRGJqBJKsab3EEkd08oTXBl+RZdi8jjlKqQuXZUqbZW6JxAlBaiHFikPQ2CEIQDAxpJI19rhEE0EikYtwdGdhdxd2cTEF3kb0qyMNNwizN7F79eUX838DviwGLLfssrSEFVaYYRBYi/g1ii/GbXXZXFklqFdaUUWVUSYhZZS3zvXlGpXVkYccQZOJRBNH7khUEJuV/+NRSXPWaA/wMkUJ6J5Buoh69dajfqKMUAo1Iz7qqANnSKVGBH1H+P+TxGuqM/GEE15L+VXYjPEyKhqmsNkmG2SFa+YWdimFFVARCCF4QRGUWAQp6mAJVMxFFLQgHCzQdRdeJI4XtxiFJCTxCDsAAnIFcYPkkoQYxjymX5AxQhAmY4PN1QCGMYRhmER3sNGRyUymSxNtVKebirFOA6NoxexUcQpVxGIUnDgXLXxBDW6cox3kIMc51nEOeagDFpGABCNkdIbkKY9mzQME1CYltOipiiLao4gcwIc97pknPj77Wah+hhGIyPGORNPD+HAWE0ixRFawqgQHOWgJS9zqRQeK3yhEMYr5tUIWs6gFUXhRDLQhpxrXsEZyrJGUQqGiDVx4hCIU4Qj/TwQCKKWgRS5yQYscUbAUsLjgBXehi1ls8BEetEMIj0RCxByGMY6JzAr/tYMd9KAHLbSBDGNIms/Q0IY3FA0IHKZDianph7dZHW5YAYpTvIJ2qkAFLHKBDGwEKh/9sAc62rEOcZxjHvNgBvH804YZfRGMA9FPQfQjvU+JB45A6wh7uEe9OrKRPWxEaBoXMkdTqYefkpIVIiQaSKpVwpCWwGglEpmJ+EGrkfNbhSuEQotb8MIYaKsGJ6WRoW207RaiyEQlCDEGPwjugakwRjTWtadbzOUWv9hFL3qxC1zM4hOWeMQiDLFLIxUESfUy4RYcswR9+QuZOxCCMXOQg2Uy/7MGYeqMl6IpTdOU7prYZN2afngKUDDoRrlwxnIEhY98+OMf9oCHPe5BD3rIw2VqgEQg1FCGezIin/ocIxkrdbTqFc169emIQilbWTZ+RCKVPU9E6pg09ChWPxMNbfqoJsiMVoKjB1Ik4KA1CkeKbKSyoGQwVJqhZH3jGxg6Biw0AQk4tOEOdUkFLZbhJ1/0QhgxXQUufkHUWt4CqZtYqiHGWAenHaleUk1MVRtzORbywJhc9WoNqAPWzoyVrKIbjVlTk0NswoatsnENXVSZjGwwZ1D1qKtd85EPerRTv9IQxB3E9wbDlkEQgkCs8si3T8ZuilM9i6zP1qjQzIoBw/+XzbBHxKDQDXfYwnK0cEnS05DtSEqfh9DnrGiVy0eg1hKYoBVqa+USSEzCXOWqEY4kiQtg7DQpTdEGbnGrDWwA0BUxSsUtmCgNYvjCF7WEhSgg9AtgFFUXt5DFJ6S7CEUYwiCEEPPksjtVq3ZXX8UUwprD29Wumve8XHpmNMUkTYalLnW2qU1rcsGMa3xDUPTIRzvu0Q58HPrQ+XBOPOchD1ooig9XMDAayqJgMJKPJdz5AyFQRQg98OHTofb0HC2bWQ6D78IgxnCGPwwGVa96jrCuY4fngIc8yOcPdYBUo1bSklmhr5SOeISwMeoIGGvUEpuYySQ00WxREC+kwOr/0S6AEae04XZZL3XKNIAxXF3kIhnMeLIviCHBoVhZGInTBS5e8QlMjJKU+imEIa6LJC9Qjqpo9pcQgrBm8IL3BjkI+A1qIIOCxxnh5y0re++MJmteTHX5HZRd79EPi/cDH31th6L1+w15WCMSNxEjGMHoBz/sYVJ8QHkhxHzdgoj5aU9LKEI5e1APg/jmc1zDznm+8zr0nOd5EHoe9iD0ObDh5IHYQ9L9cweR2ywmjEhQ1lhs7Iy+KKNg4wQnms0T+c3vV614xVDuMqFjKSvb3nBKNZjhC1ayUhduT0UpulInY0Q5F7dQxSfgTV1AtByq2QXmYqzqpCUUAfFUotIN/3hwA8ffIOEJ99LkuxSayY9uNdZ8TcNpE4KJhSAf++hHPu7RV3v0gx/82Ac9+roO59QDsNjIxRmeTnKSmzx6I9l0y3kf85hbJMTBf/WHV138nv8c6ECfw/LnMPQ8mNw/Jpf+Hfxg+6g3IhFa8xoiLZGJ7ndfVx5t9tZ94loGoeJXrhjbUHTBC2E0wxnRSI6yvJGsZPXvGW6P+y6YnIteHMMYhKEXsqwWUMHdZiIQWA7mjiSqBi9flkAKpGAJjADxKlDxFu/xIi/OKI/yUODyUOAExoTzNk/zsCk2QsCv2kEF4QEe4iH19KGvfkdQGi0bkEEXIoH2aKZmai/6oE/pKP+F93rP9wqiZxBKw26u+JJQCZOv58aACXlufKJwfIqkDgKDfAyifFxFERJBfdaHkDhoE8JwEzjBo8gwfraOJ3rFFEwB/X7FQciuqIRhGZzh7JLlGu6wd7IhG65BGvpQGpxhGeYkAL8NukwhqYZkUQyhEBax3qIKMUyICSJwAivQAi8wAzXwvDhQE1fghhqmBNFEvnjoBP+rHejBHtjBHdzBHuyBHtah0bZhpVAm/2hBRnRwfMCI+qTPBzclCAHP9+hAVERMw5SQGFsNDMCAXpww+ZQRCo9vCosEGsfADWIOEPxOPwwBGxUBQBqBg2hiEsRwE8owfrzO61yLFNbwHBv/BGRM6hZyIe6UIf5WKpPwUA+zgRv4RxqYARksaRDzbhZIwRMsAREPYREL8mnIrIQUYwsk0EkokBItsfEgDxMzcUs28ANFkJo+Mc9O0PNqQx/iwR3iAR7WgSTXYWW8oRqS4duSAWWioRlKwQmc4A4GYgqdzmZ0sfrAKCGE8OVcjg8MKgmPEcOEUgmP0dWO8QuSUvCWUvCeEBoDIw2i8g1wxhAUgYwkChGs4xCmrn28RrXeR5HQ8BO2jix5xfzWMP1yxKTc8cecQRqogRpWih6voRqo4Rn08f2KId3yThZIYRME0hGkDhEKkuUOsgFNiAsk0UkosQggMiIdbyIxsQNJ/2dhdgi+JkYDYmMVWbGdzuF3tkEaoMwXiqEYhEM4hkEQpIWPcq0ObPImpY/kdnIBn4Ynf1KOVs3VxMAod7P4dhMpk1IpmVI4kxHooDENzAA5zSAwVsI6MI15mGdmtJIrb+UrM6HZNEEsP0Ecx7En0tBGUmEVUmEd25HaiGEZ3rIu57EunyEZiIEYhKFOfOHbaOEVRgETBPISpC4R/iAREqEwoeowFYMLFpIhGbMxLxADIVMiI7NL0OsizwpiLLMjZ6MjtckVGy23siFZqMEPpSEpjAwboAEVdOBbnDPXXLMHoc8HA+HkZnMIfc/UOMw3wQA4ZzQpfxM4v0Dw7o1yeP9Uu3gUOYvkOJMTDdRADVDUJu8ADm4Cn/xD6qYOkQ7kOq/zE+hiSq/zxrrOkcrlO8dzXcwTPa1Bk6ohH5dhGepEqPIOFlzB3fBTPxGhP/+TActMQAl0EovAIQ8UQRN0QSPTIr1EBtTrrDQSvkzwA64IFv/QGRa1JYdjOE4TF8pACHIACOoAC08UDl4TJ1XUD7bjRWHUMCZrKHczR7+AVL+AC2h0QLkAOBGDCx7RXrhAVn20R8fADKIyKpPTDNCgDYzU6ZwODoJVWJcUn5JH6rYoQRCp2YjnSq8zEp71WW8sEphNiawULhxJKDZGF8zTLf2nGqYBKZrBGIaBF7KMFlz/ARU24T4PKUGqJk4bkQ/KzFXt1CHvVE/3FDL9NPImrzM60TI5UhQ/QBuiARCLASnyxymawhqgAU94wV2s4w3SoCBWM0VLLidZ1A8s9brqBUbXSDeRMlVHNSlT1dVk9AvEYAtONinF4AuecA2Qjw98bgy2QDCQsw6yAAqe4AmswAqqoAqsoAliMmilxQmA4AiaoAm+BWmPFmmR9md/1gmqoAworQ2WNFh/VQ3gIGvhAA3OgFezltIEARIG7J6M9FnjAhZWKe6QgW2VQRmerJbUVEcEAQgO4T7VJ2sWJU4LAUAdETHp1UD3FAP1VTLTi3QiJmI4Mps0YBniJCmGw8ia/yUaoAEXZGEVIKkWOCEQoLIgrJB5NtViffBTY24i+MAjfPNGadRUadRGU3ULUnVlwcAJm3IMfo4LetQLdHVIzSALsCALysBErMAMumBX0wANzKANptYKukANuqAMeFZ4p5bSirRXgxW4uLZI0YBny6AKmgAIdAB8wTeG2mII2kIHaqB8ybcKzgAOyCVt1QXKiAEZnowQmcyVVgES0gATMIGDIAEm9tZpCgMh/1YSMSdP71XxMjBfCZcin+lwNe8TKZSt4u84jGw4joEXaoGIQCEWakEVAGNIq5AKx0foYDNFYdNTR/d7OAw3j5IoR9UoUTUxpWBVR/bevOB26+XnmP9xDZQTOdvAD9DgDr72SKUOJw7B1xrBatbgDRDhDZh4C/7ADMjnZqEAC5AzDdrgDQKB+t4ADbCAZ5+gCSbVBcJqhkgAjUMgjTmAjTkAAzDgATCABHSgCuh4cNaS3ORXGczUTJ0B/pbBGIyhFiTBE+5zSGaiPxWRbwWYzAiYIfnFXhE4QWXgEs+rc/S1zk4DddJqYpQiOBhWL2ThFVjhFGIBFDiYFSShwQTkKQekDhLChDG2+kzuDix1CPFA5ipMw174hU83hkc2dY9xdh8Rh0vIC7ZgC7A4C5A3iLNWeRhBwRwHajzVUt+AC6CAC8wgCvgAC6AACYDAaL/lW8A5Jo//IFtyAHzRuQY6gAPKOHxrgI6dwIsEB6TO5X39rxeAQQ4XNf6c4Rn++Rn4GaD1ERhu4RLU9S8PuZQSQZGdZgwCr4QGNAIZsiEfUnAfr5I745IxWVAdxuHwLGBDQDiMwWFlp4NVoRZi4RRImRT2jkAiNkifMtc2ZVNpWUnHZ3R/0rJ6Mzc/1ihh+JdXVje/YAt4NgumNwusIAu6oAuMOgucAGmBVw3QoAyElnt5Fg2g4Ah21gmewAmOwAV0gFJ1ADRkiARQYKzRmARcAAhiUp7P4C0cCf1WgWzsR0IAME6O4mDj72CRYg4Z1Q8HmhkGmxn68C7b0ys4IQy7kZQcwT///xOXf9IwjFKiFdPw8lRwHxOjMboyNjoyM7maXGMEyiQU0SSDQqaIWEEVWKEWbOEUTmETQIEUTqERqvA4N7eVGwuWazpra9mWfZJ0kRDncI6yhi/DTBVVj5FVt+CroyCpo6C5rcCcjZZSs0VpzTmsyjhMyFqt21itMSAEYAh8nUANIkFwRCEo1PKkfsQomoFCjMVR41u+47tD3/ItqYEZUKZD9bsP4fIOuSEcuEEPsWEXREGxFxtWFloBabMgJpuy7dTwIpkHJHmzN9tKGLijI2YERlsUd0gVZocVVNqIVOEVSKERHoGDT8ETBiQqKc0KbMLpcFrlIEwXg9VI4UDGX/8u5upIxDpsskS1ZD0iR1N2C6JACqIAyaVguoGgvNwsu0ljrUkABNTaBTCgA+ZYB5qgCsRFXJ5VE8QTZGCBKHbByozhbBwXKfi6rx8XXB8XKeZ7GuBSzuUxLuWyd7ghD7MBHGRwivYL0frLOeShGERhLD3B+yrBEQzBEb5swUl3slN1QBcywicQsxMPQSuckm9AYGxggTWwoyuTNUabUOGLlF/biGKhpfeukGOBFfjmON/gqK1AQJxul6qwDmp6+pRUa59qGg1CfHau+RIiD5rv6Jpv2NkgDNgA2cOAqKXgC5idC5DcCaLgCJyABzLd4Lhbu8s4u8O3CZ5XwQQBLuj/Llvvx07qxL0ddxrcZM3XfL8B2rClAd7ru7/jMg+9Ad9XhjkEReKao7/+HeD76+Iu7h/+oR/0yxnm4hMMXaMSnZSwUU5lbgy4YAoOg+Ip+rIDN7M1W9MFBqMnErRB3UzQZAQ6ryNZgRVsgdVtoRZKWeVppxZYgRSm4Am2Wmd1tglunqvdOiaftgpwfmd1FgqSds1yPmmrG5zBeQfc7M3IC5rUWsrVmASuHJrA1wrOQA0EAVp25EHYUV3I/BeCYRjs5NybgU7MnI+NoRjUPpDZXhjc0z3ZFhmSge7rnu4HG979+w71kBu4ARymqCRdsTkQza4yrvQOn68Ov/T4SvQu/y71Hv8fXpAd1MEX4GLhM4GDHGFqqgaJM22x3GAMtMALtOAwqKrwkGDSD/iiP97xNp0yMPHJBfWspdx0av8yM5M2NIDVY2HlWZ2UQxzl3YoJdrZnoZdnc1aMm2AIhqBpo3ZpxTlpt1r514z6jXb50zd8wRcIrv/65flIBYe1REooZoEdcaH9fgQYfkwY2j6Q1979A5A04x8Z3HZ+5Xfu6z/u5/7u81u/63zvuQEguoE7p07dOnnr5s27x7Ahvnz06DW8hw/fvosYM+rbyHHjvo78NvIbSbJkO3XERI369CmTJEmNGjlyhOgQoJt8APFx48aLlp9jvExhQnTJEiZGkf8sMWKkiNMiPKJK5XGjqtUbNrJqlWFVhlevNcLWcEG2LAoSaNGCSBui7Qe3H+K2ZRWLbqy6rFid0kuXlSIsWKxUqWKlTBkrga0oHuyk8eDHTSJHHjKkCeUmhM+UOXNGjaBIkUSJKrWqNKxZtG7dwoVL1y5evH4Bmz2strHbwIQJK7ZbdzFjuncXK+aruDBiyJEjW56seTJmzZkxeyZNGjVq1a5l4yaQ3Ll17ebRq1cPnnnz9ux1XN8vY8OM7u/Bn39R3z9+90uS1Kef5MmUpayUySYwyUSTTTjxoeAaPgEl1FBFIbWEUks1BdVUU11VlVZbXfWVDGKNVRZZZ6VlIgn/bbmVolwh1GULXnjpdYottoBiSBpqtIEGZ51pZlgZO54Rhxo8qgHHZ5poMlopqLgyC2qqsYZLbL/IBkxtxxgzzG3ACZMbMcchVwwxY4653JnIKJNmMsqoyaYy0kn3zJzWXZeddtyBQ0443q3j5zr0tCNoO+fBk96h9rjjznqMMgpfP/289yikkNJHaX79hbSeSer4UkqALW1iCUwz1XSTTgrywWCDQT1IVFETGsWUUxjWStUNUnFoQ1cfhjgiiSeamOKwxJ4Siy0y7sUKKHvReIobbyCZ5JJMruKKLE9GOeUvwdTm7THgNmMMuMc0Y664XLa5zDJonqmMc/BC91yc/3PWS02d12i3nZ7f+dmORBVVlM9DA+PTj8GURirfRf803PCmI8Wjj3ocaSoxfx7Rl5HD/yRc6T4f5yNye/A1nCl++f336UqeiBrTTIYYcmqqO40xxk9e5DzFFq8a5XOFTz1la1S4TrWrhh8mPSIKTDMNAghMB/v002qBoOxeeJ2itSq1LBtLbLENE24z0JRt9tlol21uNM607fbbzrQJZ5zQyUnnvXbqy1044agjzzzkBR44wR5DenLhHCeO6cn6Ja4xRoo3zLDjllIqcj6Qdqx5P5Enzs86KK38ScsFzqSIzKim6sYaQWmRs1Bb8Czhz7MGfeHQPOyge628Ju3V0v9NowB1iSY+HcJaJIAQQiegdNIJXaeAQgkooVCiyCKdxIJ2NNx3773Z3JfNvTPRPONMddVRV+d11OSr3TbexB9/338LXg8+999P8OWYF4545wAM4H0GiJ8CEjCA/uNc5PbBMQb+4yIJg6DHILgPi+Sjggvbx0TuocB7nCMcngIV6RShCEeQMGaowsnqWPe6nMUudj9DAhJqRyvcSUV3OMxhDnaYg7Bw5UPAC17wpkbEIlKCeZ1YhCKadwpKLIISfVAEGRSBi2OYrRnOMF+95sS9ZnSvbdyzBjawoQ34feMb8kgj4OzHRvsJ7HL9wFz/+NEPOhowcpDqH+I4p0ABeu7/gPj5H8oU9z8/NqxwEqQURu4REYkEalCQFFSl7PFBX6RChARyxCMeYcLT4USFa2BhC3cWu9lNiIY15EEqp5LDVvJwhzXo3VdIJMQhKi9YaOlEKGKRROadIhRJDEUfnqgISZDia8NohhjzVo1nYEMZbHtbdbbht/qRRyF+mseg9FeRdeiJG+HgBjkiwsFL8dFkBGTcP0S2P/5ZMI59pBwDL7W4kkSOcYME4H4Yt554+FNRAGUHOwqVnvPYo5H06F871hEOZFxSQJk0nSdTx4c3pCENZjBDFlpFSqTITlZMsZDQbNhKHcIyRD6UQRBreRblIS8tU8NeLCihNeb1YZih/1jETQ2RhTfU4ROi2EUa1TgPchTEGm/b4jO2kcbBCWod7GjHO+DxDv5o8B7iAIdWtSoOidSxc/jUD8jiyM79tSdhhtQcPhXXH0D+Qx8Mq4967BEPusYDoHhNhznGYY698jUdeH1HOtLBjqkalq6Hasjl6AE6h2JSEiY0Hep0cpM/1MGiGeXozpDSswqh8na2KqlJe4jSGvxupUJMHtWk5jzn1aUTfSDDMBdBhWESohKksEMjItGLNH5DHfcDh0Lk8Y1oYLFtz4CONJgKqIdAlR3ueIc/4zGSj8SjHFvlqnwU2Li0miys4M1UPf3IqHvog6rwgG5UAarXvu5VHPAdx/9f3WEOwA52sOaI7jumKtB0SNefiK1rXdMzMXtc7h7r+IYyHjq6TCpikyc8VWUvi1EzjAEMOuPZUWA1w5DabpVSAYIQRizaHfCwtL5yAUujhksTLUJ6lKBEKIQZW53Ktg+UwMQjyPAITSxDHuqgzjkYe5BtTGMa4jLX3JIhDW809x4C3e90JUYSd2Q1u+v4aj3zmdZGbYo/4W0rfuBK5kMJWFHwwKs7ymGOcriZHc/Fb30Hy950oOO+igJsngcr0D7/d8r+7AiiKoJgcHijGKkwBUQlcbpHkHCip6oDhTOLYZ1x9lVMkKFSRBo0W43400IAwg6EMFrSotgstWyxi5//iFNWYA/HOIYtJR6hBR6Pwhp/y8Y1xLNQdUzjSlUClzHMlAxqqGMegBronwM9En1YeavcAEc7vtpdP47kUuBNZ0m8zJHoptcd6gU3uN1cDr7ytb7odod/9/uOPhd2v+dhNzvQQe9yGMoehXpHehBKD3sI1r3uBceVs/tUcGQjG4hWdEssUQlHGOLRkD7VH97whsxeGMObfSGsfMbpD0cF1J8GgohFrbsd7kAHOjB1ileq6rRgz3k6pcQgoDiI2sI2irFVxCim8beCIJsg31jGLVYhCllg6Ri9YI6xkU0oqv5XJPzYB3ahLQ541LGthry24e4zH0Qhir3qVpR7x1Hu/76SndxuHod6Cct2vYYd0NM91L3R43Wvx1ug6FgHfAee3b77favnIEdWD45oVJBidJho+IMfPVkEAYLCabAZGCq9sylsFtMg/fCHQR7qkbcSCEcQtcrFgtoSmZ54JAgFK/oA20HoVKc3JYPsFzEFIySBDJAAxt+Geo5zzOMb2KgFS1pRi1oMo0rCYE41/AZVdjN7JPbgOzjWYY99iLdjBdw2t9WsKLTv/fvlLgc62MF28qv7vnQGaH65H10B2xXu031HROD8p72T4+/4z392u8H/vqvjHOIQTtugDKtgCofnCYlnQhB2OqhjE5Z1WRZlMxfHBQ9iebKzcTTUcU7Bef8hR3K6IwSUAQQpd2ql5wIkgHpkMQhkQAQ31geDUBdONExQZAO2RwWfAAvOcEa/9TfANw2vQAqb8Amq8AnG9wu8UAzQ8QzXYBBRJl1gBn1+Rw/tYU+HRCkekR53tWZtRnZ7h3blwA7i8IXu9id+xm7t5m4CpV9w53Vxh1DtgHfo4Gbf13fcUIdaVYfRpn96CA4CoX9AxlDZsA3FUIAsw3AmVAmcdEIxcwiB8Ad/UFGhxDoXR3lZMAVZgAVMAAVQMDtGsARF0BSgGDQcCGpAwEOgJ3qjR3pLQ0sqdhYm+Ip9QAQyuAiLQAbAdES1RQZUoAW0SAaYQHzAMA3aoA3foA3/03B8ywIKnlALuLAKt9AMYhMN0lAN1LANCQEoHKQfcUQR+HAPelQSJMNIjZRmAyVQ5fBcfdYObOh+dZdYksIQ7QQyF9GO+NZuead39kcO+qiPerKP8CV4/wiQACh4APh94kAO60AQBLGPvdeQDvmQBVEQf8NQZxQNsCBChjgTjpAIHFkIHvkHe6AHIbkHcsAGoWQzXsAFW5AFXGAGWxAYWKCJmwgFmhZSHTYrQRAEMyQEQTBiI5c7PJADuVOKOwQiRnlaKvYrKNCKS9k0SVlbNwVbstcHVFCLShBjU4A9izBzp1ALr9AM2rAMxsULuGAL1YMJqmALuNAKrlBFa/MM/3cSDuIhhZzTbPogjvUwUPemX+AWVQslKP0WmPawQYx0UPiGKJJyVV4nEYQZEQuVkPCVf3nYd3wTDlpVmXyzVXyyj3vCmfv4fwnpJw6JEP/Xe/rYe/9XmuQAZBHZmmmkDtugDc5wkQeYgDPBkYiQmyCJCH+gB76pB3IgBpEYFFyQBRmlUYChGFawiUShac5Zk0whQ0YQBEYAalJhFbdSFb6jUr/Snd7pAp0wlaxGBbIle5TAS7oIlYuQF7KAC1dyDMMQDK1wCsyjCqfwCqbwCa+ACrWwNtVBDc+QDd9Bl/fhbO6gd37idFI2WNNFVe5mhlMVD043YOnBECJDmAzRSP/t8H38CG14eHB4GKIiWofdgIf8J6L8l6ICIRCWqVX8xyeYGaN7EpF90zetaaM3yjff4A3bsA0Hdw3UKA3OsAy9AAsGiHgZiZu6+Qe8GZK+iQdyUAeReJxUeomBcQWYlmkypKXOaQTO+RSfdp1VQTTauZ3feaZk0QlUQJ66NEy62AmUQAZQBJVk4DzMUny3ABvHEAyqwEvG4gmjAAmj0AqfQApWJI1w+QzUIKAcZH0hAVB+0l/zFl36ZYaOaXfmsQ+IQlWP6Sf8eH/ZZaIlyh0qOqokaqojmqqqWqqlyof85w0pKj/yo6M7Gj/bcEY82qM/eg3WEKT1Ih1qghy+EKz/xOALu5ALBUgKo+AJCIiIG5kIuRmtTeqkUCqloUSlx5kFVnoFEPIqW8ql0vmlG2idVCGmZao0LrACLvACaDoioNCLZFCL1TNMsSV7ziN7zdMJeyEL7YkLtUAKoPCu+qoIX3MKo1AXqIAL0DAN1sA+1yAODGSX8QBv5kEP8NB0BXUe//JUBnmQoOqhIrod26GqI8p/21CHBzeyKkqyJfuqqIqiKtqjMiuzKYsNvFoNQSoN5iMdzVGsxfGzxSGsQLsLvoAcwtALvdCMBsgyEbWRiKCkukmteMAHkIetGpUFV5C1lpelSNCczymdFsJ5QMA752qmL3C2aJu2apsErkev/3Iqe29rr1BEBlyJNaegrKBQCTcVsAEbDLbAB6eAC5wQLbRAjL8FgO0wMs2Gb4HyJ36Sj6HKDbqWspRbuZZLuSFquR+Kudygq4HYuSoKq3h4sttgsp3bo91wstmQuiebubqWLzibs3MiL8mwHD7rC7pQHLqwu7xbHLvwu72wC0gbvL9bvLOBtK6BC66wtA0GE5fwrNHKpNP6pFRrURdlBtebUVibtViKad/6tWDbFEJQBKQocmNLptpZtmBRA2p7tiimiy6ogjU3W8yzpmtKW4NgF7GAC6AwBoZAB15QW7z0IqDwYJtkB2nwGb7AVL+1o5lpcPnyuu4zwdeAHRQMu/8RfLmUqy8a3MGVyw0c7MEHN7MdDLvscy/pM7vQgQzEYLtA+8Iw/LPFm7vEW7w2vAu86xq8ELyuMXSGx7Qv8bwcCa28Gb1OqgcVRXEYdVHZe4lZCxia+ARS/ARRPMVSTJNeigROIb4deL7oK0vrGxZlgWJhUWOs93qxID05tZ61KFugcBcBqwhUQAdTUFtU8Dy/lETENAV2MAqzcAvLMA3NtEXoQ8iF/J8njB3UeMIXTMESXMIZnLKN7MFjVMm9GrvXobMqvGTxQjc8Cx1Be7sxPMq/y7s3PMM5bMql3Bo+rHCkIwnPe5tEbMS+uQcQeL1MXGFOfAXIGZNRXMVWTJP/SIDFXkq+4xtqtqIhN5A0ZOwCKKZTVDAI0gNbwIQ9dWoLN8V6eyGw1xMKzRNjrRVjzfNEj7AJzBgMWFQ+6POfi3xk9xIN03DCsTvP1lDP9dzIIRzBPiq5Mws//dyjtkrCu3rJ72w+bbMuaWK7Ldwu7jI3zOA2Bt02arIcE90uYjIcGD0cwuALwaEbvpAbujEbxQEMw4u0s0HSsKG8qLC0LXMJsTzE0sqbILkHeJAHSVxhGYXT2vrEgAHFVAwFVjzFmhi+XmoERxCmGKLMvnNqZKyLKuhEndC2UxmnUOQGmJBEikCvL+dEtPgIqzcIVClbbjAKUwIMXjQN3LPOgnxk/2zN1vP81jhrz/Ucu/d8DTZ713b9PrE5jHytDZZM0Cg8J84ArHJTu2KSHIid2IjdLspADMqwDA9dL0LKDHKjJm1yJsqR0cMhJhsdw8EBDEBL0kj7C71w0q/BC7oACytdm5mgkUMM00sakjZdtTldpTzd0zLpy1d8xcJ8kzN01Ec9tkeQ1B7SK2SMYuRJtzOXzbVICTUSW1F0c1nttrRnB32ACYBwCoqggkSgBItgB6bAjL9gDF6kVOgzDdIgjWmNPomcyPQs1/BtzzhLDUc2Pm6zLnKTHCys2IiN0WASHBjd0cKh2RhtDMugLsuAXOUz2JRd2RNN4BmdHMax0Ug7yv9AW9Km/Rq7AAvJingu3XDP+trRO9OWpcRWq72XaKXJqZwsbgVXDL4zZMznewTDTdzLbNzHjVK6qASyR6eyhSy01wd0sBdVOUXDtKaspwrf7Wi9KIud4AntyQtiAw3lI9nrjD7SiOXw3NbV0NZo7T3RdN/rcuDIEOCfHRz//d+9MeACDuDCIeAQPhzDJufrMqQJDkZV3jYNXtllHueb7bMeXdqj7CW+UNKlDdo2PAsrXYggHuKvPcskfss4XaUp3tOJ0eKKIcXPaZNcjMzJXNxhnONhkQNhveM7TgWK4ERUUMe/pFOxEFs1R55UED2K4EuDMAjh2QmP8AmssQtX4kX/9w03bYNFxzXs52Iu60LgH328w3u8JP3sJx3tXjIbAs4lXaIb1s4lfl4MDN3nvzHmwj4+mhzRDz3YB64M/o0mil3ovcDRPwvaxgHahj68ib4KP9ysjgDijw61e9DvgXAHcJAjbZBRaIAGVYoFKn7pmK4YQy1DNH4EDv/wnp4huKLMNyDqKKUEsbXqVFnkttgJUxCw20w9KjiVN0UJfUGfixAL1bMsrQAbvAAMxXDsY47s8HkbRxvvhi68NXzKPs/zzX7SGB7t0r4bIM0bvNHRSQ/gGd3QjV0My1DsbtM9aI0MdFLI1GHQ+I3u3K7QCy2s7e7uIw3v7G7DO7zDOPy7/7Ng73jrCQzX6PtOxP2+B/8e8DmyxAafrQiv4sqZGFLs4j8tzA8f8TQ+YjakzK9UWicVFlVJlc6jF7WYi1TALLV1RKWeBFQ5TH57PU80Yy8iCaoAG1cyLuKi2SEd7WFfJVUC8zB/2rzw88Db88Ib+/Pe7sPL0Rvd2cZxu8nR5mHC7S0sN8Xw2HjONuvMPczA3iicwuZe2cOh0G0yJrZ/6EJf0qcMGzXMC2t/75iQeBnp6DA903Uf8G1Q/mmQ9yh+tZeI6UEtk0P98BLvkw//6VfxSidWAzs0gox/U6wATLwQCwBBZpGiPlO0LAq1iAqZPg3JkKFCpY9AUA37LALVif/QKVCSGuE61ixkM2fGjBVDabKYMGAtW/oC1uvXTF41bdbsxWsXr167fP7k+VOoTp46f/ZC2nNXL1++mDaFGtUXMWLCrF4VRqyYSa4mlSlb5kyss2jSnEkz+2xaNWzV0KJ9FnfssmVfvyLDmxeZsmJRkbZk+TepUMI/Z7lSRWqUp02PKlmy5CjRZMqUERX6sydQID9w2nxukyaNGdJmsmQhfToLFitYWFuBbeXJ7CdQbENBkvvI7iNCfAvZzUP4cB43jB/PkVx5DeY1cuh4nhwimU59KIUaBHERKzJTLnYKNVEgGSUXF1Ga3odVKIKLFvWhoqWSLWjToEWb1kz//mP/x4YZA8wqYH4JhiaeenEpJgUTnKnBmQYc8MGWfknwqgCvWkkYlFDSiqqqqMJwww27MokuE5dBhhlmlGHmLGy2oYaZZGTEq0OppNIlRx131KWnHHP5MRchhxxSl1xuQTKXw05R7BNOMKkEk00qcaRKK608BJA//kAkkD38mKONMNBgQ8wvuOBiCzW74KKLLayIwoo3o6CTTifuxDNP3nYDAojfhABiB0EDzWEH5XJoLlHnDkU0ByqUUIK6QfroJFL4pqBkokE6WeghKkAhpJNHplhIolhseeS8TqajQhJcoLkvGpFG0u8YrrASJphgIkyw1wkdBDZYCod1SUCWsAIG/1cRRfRwWb5GPLEuu5TZixhlnPmKmm28yYaZZ5LZC5mtOPTwxqZ84nFHItdlF8kkaVkFlSafjHITSyS58kpFFAEEEET22COPOeYI4ws2wigYTTWlUHNhKR6Wok6Jq9DziDv3PMLP3/ocVFBDGQU55BwgpSI7MkJhhdTuGsIUopLhO3mgR+iQiAxKbAmlE1syWoQ8MtxopBVYp+mvP5NEIrErX31tkMFgD1y62AyRTTarrD602qpiiNFrr2m/MtFrsKRlccYVq/nmG3WoeUaaFcmeVlxhbkTqJx3ZFdJdvW8hUpddfKHFFVRGGeUTey+xxF58861yX0O0BFhggg1G+P9MhdVMcwuIH5a4Torx3O3iPTXeuGNBRUZdOUgZouLUPpSghFNLe35IoYgkosQNTNBzL1NQQLku54b2BQSVYKAZ5r+RQurqv1tZSpbppnttmkIEF6wQVw0FrFrrrT30sGu87qKWWrhNnNaZGdGaZhpkpMFmGmvEOlFFFb/6nmvwicHRXGKSuVbbqFGNa2RjG9nIhje+4QxYrGJel3AEZO7FuMYp4nEAi9wc2GCwg33BcmgCoebqFLHOReFzonMCxnbzJ0CZzmOpAxlzImKRnLnsUVTohEJOYQuMIOQhrKgOR0CxiE5QQiLWoURGQlG7UyhiE7wYhn+MoZ+w0MUkyfv/jzCMwT2XGGMYLkkehRgEIWIl6HrFOlZVMKShZW1IfF37GthM1CIVieVazKjGNGiRihzlJBewOoYzmnEiuyTDkIc8pIriIg1qDLCA3PBGOOQhj3lU0pLzqAc97oEPerTjHvOgRgNLUThOZAISmMAEZCSxyka00pVZOkRmMniwgxXsg5fjXAnrlKcm9LIJTuglxv7EsR0Q82MwBNlCVkedRZBqIhL5lK7oQAkiCqQ6nWAFzwpChd4BLxShSEISFnEK9wDiFcdTHkmseMXkbWWLCeJKF78IjC8mj0FJiVpLqDIVD2GljSihVl42NK260EWOBbVfi+jnjGk4gxgMjQY0/3rii2Isw1txadtbqkHAAnYjHOq4ZD1EWg985KOkJ8VHSlWa0nzsgx/96Mc+8lGPbIiScKXMhCWkdC+PuLKngDhELGUpMDbU0oMgzBzEdCkxXvrSlyrcGKGMeUxkKocKU1DCeajwTZdVcxDBmIYt3GARnlGCIKzgYc+4OURWnOd1tZsUFa6ACihGUSQnYicWAYRG6OXTjEn5C0tgMtioZI2vbESJXoqhjJNE66BzTKhCZzQXhsaFGMyQxjUKGA7OnmMdmCTpSkUr2ny01LT9KG1qVZtalt6jHtuAFylIAQpPpBKVkKGST195iEYgAhGZIWotExZCzSl1qVHI052cqv/CFfqGUB57YVUPRQSVFYQhD4EdKy5ii1goghCZ6kQsqjORTgTDForIFBlAEQxybgciRFjIpMhghyt8AiT9ues6jeGf5F0RQCbpqy+g94u/tEQwgCVsVPZHlWJUbUNUgWPcWGQ/s0X2oox0JAINeMCNNjIb4JAHSVMLU5jmg8QnRjGKVXsPFm8yk51cR4w/O49ziIMc6rAGLVox24xACZWpzG0jWOnKRhwiEb8NmAaLalTLnalhJFxqcoHp1GD2prktfGF0pZuc23VZZRCZyCLooIVTGIIK1+lDdiLCiljkbFXq7a4dsBmeizAkU4ZYRCPs2wxo8LkZ0RDLn50BK/3/9Fk/gK0bYdKlo8IgeilMCZD/mlKu/yXyos9opGazwQ2PrqMd9AA1PUKLj5GKFJMsNXE//vEPfrCaHy8t8WpXHOp21LodMT5HrtWxa173etec/UaOEzPbTlQiSrddZbKJXGTIYTAPRR1YUYd71IXRCcpMxZMvp/xUK/fGuVPdsnL61OUjXuRRD3mmFx4Bn/jCbAoCoUQs2lrERWhBCxYEXpofQs33dMINnOCFn/cjyP0gzYv9QXRSFq0uIC3cJ1BRClS4hsgZxSXTj+QGOMjh2c+CeqUmfnXIXwrrEqNWtfu4hz3s4Q596CMe72BHzMUR83WIo8bkAEeudZ5rG2+c/xzk4OyNfb1rtaktHOcIBzZusQpTzNYTkPkxT5VN5KD+a5ZsiHbCMJdUEl57l9nWdpWvHNViQlc5VE0dENrNOm5yk91dpsN4yKDmiDAkh5RIrx3sYAg7aLcTnLImJQYxiEVgYhSywK+tCr41LQJ4jAbeRboif7e7FSlHEjektzD8SI1z/NOgrsc9Um3y0p5Y5DBF+T32QQ97gLrWMsZ1jcUhDnDU/udAD8ftgV57cAT95+HgvcZ3D45uFJ+zxz9+0b/BWW8o3RVNL9wmJrGJH29iE0Pe7SGQnGSsa9CWaWKYw7quy6ZSuQm7GQJweOPcsmtZujrQgaZsuBBKdYp1EP8BRSjgS++eWafOZz4FVQAFQyAFVeiDUEiv8mAIwsMERRiFWuCFYDiGYPCidmo8wICQAEGJqECXyYMKZDCkRcq0TfOoj+I1eQC9e2C9FbQHFsuHTdoHlZNBeGC9mGMHeHiHHHwHGRMHHty5H5y92wtC3GO+3gs+3iu+JCw+TlPCJPSGJ/SGbuAGbkigbbDCK7SGWxAcxeCEScgE6kMl65u6VgoqoYocaPM+D3IyXBo/8lMu8wum9DuC8/M2QAmUskOmPtFD6MgU8UC398g/m0mIhnCPRZiUSenDJFqVA4wFIUKvhsiOfkuz93gPRWjEVqiFXxgGXdlECvkiTRyGXxD/kfGxHwFyJE7LPZDCJE1qMRfUpH0gMZQDtXkINddjBxk7B5w7QuE7QnKgPd3zRV/MNWD0xdmzMdvzPc4ivtprwm6IQilcwg3TMATChmuwBmvoMLhwBhTZJ12Al6ZzkkzIKWRLtp56JS3ZEoBRsmdDmMrhAsspLmvzOuQCOzgcAjmsQz28w2I6O4/RR32EP/ijHfNIDyKSxIsYBMGzGfTApv4DhYTMpoGQiL+rjk3pg4potxxahEdIg6CJwAnUlV/gBZEcyWEYJBeJJHUgqZUkNZYqKdOCxRSLqZSLB3t4B3hgh2G8vV0MvuELvuMDutvLPWDcOSLMPWNEPuRTh6QM/wco3AYqzAbNyka5UJFkoAqGIxJ3oYWtnAWma5Kc0qlUSrbrM0dm2xJZUrKAkTZbOirwixjj+ro3tEd8ZKFv65ND8UcgSA6ADMjBo7+EZAisukjrMMTBS8iKcA9QsAWKDA+EiJ3vQAjsQIieeQ+GeCaCmC9MYAVZkIVWaIVP+J1R4AROQLxoKItq8AaRIrVSK7WWxAcVhDHYW4edszlczMXb+8Fc9D3c073eA8rfY8rgFE6n1DDNuoZGgouqxIuo4BG8cU6t5EpVkJfCsYRjC8NVIkuq0z5Z2oN1VLLKUUMnKy647By5pLJ7pMM6HKZ/hK67zIE+0YE91IH8o6aEzP+Zq/qUhLDM7KCUVaEmTCAF8PAUbtqORbCFnWmzwXMPSkE3mJkIJIIS66uIv3sEOzgEUqAF+dE0degkeVAHXftQpOu9jcu1dVCH2+u1SfLQXaOkeZDNF53Nc5ikD/U1zjrRGxVKG2W+J5RCqDTORqIGacCoqkQkZDAXqFg058wbdzkSJKEFJJEF6SSFT/iEVKotqFOcShiyoGK2PeCDPVgDNliDOQjTMQgDLwjPy1mYeJQYKIgCKHCCJ/AlOaWy9atLu9yB9fzHPQQClEkvgXidd6Mmfhu82mGIxKSduoMPTMCFTjiFUwivikBAIgKeHCLM7dBISuWZv8M7w8vQAWL/CwSawuKDwkgyPqVkyrRRh7RJm3BQGyL8QRsdOl9j1eWLwqcszo2qBuR8iyANUiF9BkVSKPv5Gr3YH6lAF7+pvL3Rm63kSllAhen8BMa4LQmqhEugEstABKDqF0CogzUA1zVwA3AdgzHwAjRNqhHSJSigDdpogtkwv25Tz6gKFDvcR+gqJj0sIjeIu9uZgvPAu4TMFK0iTFAgp7bqDmtSBIxYWFbgCEhlBWqiT0M0RLwLhd/BiErNGSKKHVD4hFk4C/bZKOMk2QKyQgMq1eVTWQWq1Vo1QRNcShP8hie8QgSSyl3l1bfAqJ3l2Yx6C519Bmeoo7mAmxrZJ/6BOKHA/8omZda9qYVaaAVVYBJPMJynk6DqNDbJmAzfKoQs6Rc+GFc3EFtyLVc0bRgRigK0bVN2bVd3rdM9uVM7zFeO0cO51UMhqA7L/ENbUERClS/wCK+ciYX3gJmeiYVgwIT1MiK8Uwj/k6/+sw4/jQXx+qZOAIVHSFzDu4ViUAvTnIZG0tVrtAbNukZNQ6AD2jCWZVWnPFlscN1rzEag3dmxEAuerd2ebRuMAla0CFKMEtqwENoVEagNsQqYEAbAijy78ZvJ2xFccF5dcN68yQXnhVpVaLpN8IRM8ASrxa2s1doj69pu5QOwHd9xDVdz/YKzLS61rZPbYNu2hcM5VE873f9T0tHHPxkIi7BMN9vYgO23HFLMflvMuvuUU6mIU4AZwQszhNBIBQ0FSP2djLDcjIhgg8UFYFgG0/RcUNXV0BXdXd0o2MVZuNjZyIqWYaVdZ8DdoE1hFV5h3UWLPJoGYGVhi1qRgEIGrUAJAWmKmPAJpVDaZE3WHBli6HVeXKiFV0CFpqNaS9jeqzU2KqmSrQ3frx3f8g3XNTBXNkgThYkY9qUTKHANLHjftoXXYBI7YYpb4Ihby6Qm//OOQgSvbxJY68ghMpjcbQLUhZDY6kCPPnwPIILEJAIijCiiJKJgVLpYUsCFXzAGsYiVsvjZoA3aFQGXHEbaG1kwCBOXE9n/xk9O4Rcm4dx1Yd3NqEZai2nArLIgWhTJCxD5q8FQWh5h3spb2umdhag1hcV4uieGYimWDK71WkC4Yiw+Xy/YIKTanBJqDdeIDdgw49lgLjVWPxXSQ4z5O8J0CMusTPcQWMLVX1J5N/uzCEXohEOcDsv1P4sgIo20XMvt2IzgCEw4XF5IlisqXhxxuKNAMKngmn8amxMeixee3dp14Z9lpBm2Bp0VC2YwKGO1EOhhiome5XRR0nZBEldgOl52Yu7tXis5Mt8a5vIVW/MlV7PdAjZcZjppZiy4gmeWjWiWZt6Y6Wm2ad5YDyJ6JpuhxANsCMGj2Ib4OwKOiENkSHOD/w/aITzxMEh++6aM/abfeee/O4VGjgm/QRBhKAyLFpId4eeEe4pJ0wqxIRsLM2sLo0rapSOMepFqCNb7sQu82GGrqApzAeLm7Bu/8WewaJv2sYZjOAxVWAxM2F6PNrbqnGLfEml0/NYsPt8xWMPMebJcioLXeOYngOYnqILNftd2pemaViHRCW0nKCJoSmpL7QNbOAVmmruLuMhgiAVSqUxAfdCE7b+aoU99g0xQiNgJrlypzr8HJgUIjDhfqOV9Pm6hcIp+VrDw0YtDsgtL/oqztrC5CFY7soZvqAYKA6C4BpFyYU5fuLzmDiBGYgts0IZtYFUVndG0kQc9ipfZsv9SX75arA1mRHCELNmSxnZsck3ThjkTyobp2MBsaN7sKjDj3YhmBecN0MEYPFEv9IAP3gYvW8AFyHwITwGFWJBwi+BPdJvItho8aloPQqYI8MiIJMqZ3z4FRD6FWJjSWQCGqbgW9UEkIq2wqly45SUM/3llRIKsyGKRhjbrIb9hZbgsbGg+tynSIgVBsznlajhdVWXvKlfRXtvRW71CPXo+UtheR6Dv+s7akM7vP7hiLXbsso0DapvslW5pAi/wmJ6NMqYNBr/pm44dhRCIiy1ESy2iDMe7DM9biuSmP2eI/HtIwxRYiy2ibxKv8/id2MkZ4AbuTxAFXYhyoJ3knrX/SvGGiodrbonjZKNFpDj6msjK8YQK1hRZpGDNKIy6OJT1BiunpCtfVQWywinU9V3n9WcswbTJsS2c1o725cO2760t8zMfg/420zhYczUVvzpZDZiOczlPcAX3bM9u8BQKHW53ggUNMzsTD0K0neuiCO1KTEjlt5/204EFZPRgBVyIdODp2I21XFsIBlaAbdp6BVlIBV/QvAFC6N1t9dllBkyuCgwEjPzhGrEpJEvDcRkxmxtXdYsDXWygBsAhhlyghVyQhm9Q0Upa0V9rynCYwmksTtNF+QLatF3PhqbUdSvUhiyEBXmZVsIubNyKIJ2vDKs7wznIA8lZMmeHR/W9/zbYOPDPSXo8ufYjMOM7qXOLcQJ6lLIlwia3q5mr2uYMX4j3SAjFdIhAv4jrUOeeschCvNh3pgS0KiJEh3QLx3d5i4VXGIVU+B9MQwsLoziKWzAtsoot+ntjEB8WefLMo+4LA13jRNmjo6QZk4dtkIYcfgZlmApqeEKUx/yTn0ZNK9mStVnMr8JpdN1ouIWaH2ycD3Od/96tPcuACXqhLyqiL3ovrpMtyAIrSHqK2WwnOPA4lemn9/3ZuBM7kTInyBTu6gP0AudFnEQCTSL3oAPeJsQc4s9xcghvdo/qqKaxPwVoCIa/u9hv+qZs4gj6wAVS4IRL94VEQlJkVbBJ4/+nrKCocQEoZUj1S+NdINU0bji6GJuHWgMIegLpzZsnr6C8dQrPkQsX7tu2atKkUbO27aI3bhq5ZevoseO1kCJHXqtGUqS1aiqrUZso7dkzZsmI+dKlq9csV6ZGffKEyRNQT5aGErXkyFGipEgTIUL0Z8+ePFLnzGHDJkycOF++cOGyZUtXr1KiSNmSxUqVtGrXpnXy5C3cuHCd0HU7NwreKHT11u3Tp9MiMor6LKKyaFGnPmT8Ll7UJxQrULEeHVa8CBQoSmQWh/L7txPgRZQOVw5FKVSwU5Q6gQKNuRMmTKBPBauFaZMmWsl27/bl23ev4Lt29frta5dxX8SIIUP/pkwZM2Ywn1E0mW2bt2/yDhas570evvDhwbdbJ06hOHHnHIYj19C9uHDgHn6DWB+7N2/qwmn86PFkSNYIqBI1Lb0UkzLJIPObTbk4eAuEt9AyIS23yKITT55sEpRQRQ1VyVFKJcXUU1BFlUdVV2m1VVhgdbWFFDGaZQWNaLGlll1y6VhXFE9A8WNeUViRF4+PKKJIYqM51gklVCxGiWd+hQJZLKCoRhhhoImm5WFMAjbIIFBKaWVriLUGWiehuMaklat18gksvuz2jDM0GUdccXYyh4x0E1FjHXbhqHOQd919V5BCCrVT3jrnOProOeclal56ky50zjrqaLqfQ9w4/5Sfpp96c9E22miDTUkFTgQTMwkuWJNvNjXoIK21PhjhhLfkhEqGmXDo4YchJiKsU1D9USKKVq3IYlhefQXjjDauVaNaVugIFxRBCkkjkHnRqK0VmDxCyGCK/TXaIGQMcli6oh1WSyynXNlHmYsMwlqUpCnZR7qUnILaKYpQ4i+aocQSypmsKbzIKXHu5owzM9Vkk3LLPeeMNdptVxDHHQvETqMMOeQepOlJKg45jrqXMqUnJ2rypZtyyh434HTTXzcisSRNNDHt1hwydia3i6y60Fq0gzbhsjQuuUQIIS6ztIIKKT1xCBSwloCoFLFQkRgVVWxktRWzzz4rhRVn3RdYI41pWfsj3G/9+O22WHCLF9t4C7lFQAAh+QQAZAAAACwAAAAAQAEAAYflvZ7bsJDVqYrSpYfOpYjRooXOoYXLoYXIoYXMnn/JnYHHnYHGnYHFmn/CnILCm33BmX3AmHzDlHLAlXi/lXm+lnq9k3S7lXq7lHa7kXm7kG65kna5j3W3kHWzkHe4jne4jW61jXCxjXS6jGW2jHG1i3G2imi4hVmyinKyimqxiHGyiGayhGCvinGviWquhm6uhmWuhWqtg2muhGGtgl+qhmyqhGiqg2OnhGumgmipgWapgF6lgGajgGeof2Olf2Sof1ykf2SgfmWofV6kfV2oeFSkelyifGKje1uieFugfGOhelygd12gdVWee2KeeWKeel6deGGeeFuedV+ddF6edVieclObeWGbeVybd12bdl2bdV6cc12bdFqbdFWbclybcVuacVuacFqbcVebcE6Zd12ZdVuYdFqVdV6Yc1qVc1mYcVqWclmXcVaTcViZcFqZb1mYb1mYcFWVcFeVb1STcFWPb1iYbliXbliXbVeYbk6WbVeVblWUblGSbVSObVWaa0eWbFaWakmVbFWVak6Ua1GSa1OSaFKSak2SaEmPa1OOaFKOak+PZ02KalOKaFGLaE2TZUWPZUqOZEuLZVCLZUmIZE2FZU6HZEmNYUOIYUiFYUqEYUWLXj6EXkWHWTeAYk1/X0h/XUWAXEN8W0R9WUF+WDt5Vz90V0R6VDl1VDx4UTVzUDhxUTtxTjZuTzlpTz5xSy9sSjJmSTZoSDBoRS1oPyNgQy9fPidZQjFYPStYOyhROytVOCRSNyRPOCdLNydVMhpPMyBMMyFMLxxJMyNIMCBJLhxILBhFMSJFLx9ELR1ALiE/LB5AKhxCKRY6KRs+JRQ+Hww2JBY2Hg4wIRUuHQ8tGgsmGQ0tFQUjFAgdEwgcEQYmDQEcDQMZDwUZCgEVDwUUCwIPCwMJCgESCQELCAEICQEGCAARBgALBwAIBgEIBQAGBgAGBQADBQASAgANAgAKAQAGBAAGAgAHAAAEAwADAgAEAQAEAAADAAABAgACAQAAAQABAAAAAAAI/wAJEbJipcmNAyCaFGxCxooeQXoykRliJRKiJlXkSJHEiQ6iPgSBABkyJMmQHTNm0NiBBMmOl0R2AGnZZEebYMKQObsGr1s0YsKO+Sqmi02VhhibeNGjp2HBpV6iVqnipUkTkS2RWLWadWYTrV+5ah2LROTMrmaBvHxJI+VLkStpyJ1BxtSqVaxkuRo1ytMmTJQgMRrsZ84ZLFCCELlhI0WIDRQiRG6A4AABAQEEaN6secDmAQMUNHjwAMKFI7i6qV7tzZs2b9SiQUsGjFcuZtuw5UKFilk8eenKCRcuTly54sXDIUceLty3582hO3/+nJt1btu+KTc+Tlw1WI4c/f/RwkOEkhYtcPRww8lTXmTd4KWDF6+1a23aVDe1WtDCAatVFeRQJAIWlAQRXmTy0SiM9CHHVyKdRJJcMmVV1ko3ALEVED+4Qswxy2TTEzXICEPMMMUI40cSYrFI0Fb8eVHFEkgsUYVYZYF1lYZhCUIgjF8h8ZAggnwlk1lvibSWSDPAMANbcrEwg1pI2LWKK7LIckopo4jiFyaWQCKYH3UcBoUUizUWggUUbIBBBJRZxtmcmGmWmWcGHBBBBRHgQEov0QQazTSEQgNMMbTVdhszsIACCirVyAPcccQVd1xy2zWnqabaURcdddVtg512lnaXjja5XGKHHVo4IYSrNeD/IIQSjJyiyiu78BQPPNzch19+TjkFwwAJMZWEEU0IIokexxKhkBVeyNEHIpxU0kcfZSG5UpI0WYHEXDS0BMQMNlBCDDLPRONMukCdyAsymyzBFRFIsBgkkEgQQcQSSSRBY1YKkaEHjFoJLCPBLZFBxlXZrpWkwy2hpFJKUbKgFhCSXBlLLLSosiWXnnCiiSaYVDJmG114gQURP8CQAgkWkMDBZAgQQABodAags852ZnaAaRFkgAMor+jyCy9H25bLLLDAwvQsjjqKyjfyxHPpcsxtKs6noHYNqnXeYCcqN6QORyk4zaCyqhqczAEFFDi00IMQhnjSSiuzLBOf2L9q/5NNInogkshCERDgrLcE6UGIHnIwZUUSXpjURyKIjILmxTuslJJKK5l11bYV7sBYFLsgEygwqOhy7jHC6PKMLFBsRa+z9wZ5cb00EpEWWARZmFXu+eqLxFJkUFmWTA4/jLxKbAFRxMUw7JDEKhvHIgsrHm/ZV3shYyJYH22Aj6YPLodQAgmQRcBAZQcUgPNmmS2QwhCE+DBAZpoxUMEF/LeABilNaxpvBjjAVYUHFumIRz0qtZxNOXA6XqOOdb5xHets44LPMY7ZiFMOVDnCDpvwhCbGYAYstKAGPdjCIkrRCljkYhrX6Ft+tDEQxenBC4S4AQFCIBVCAC5weqBK5P+q8DgiHCgTXjgJDcalkhU4sXMuUQlWXDITIMDABTWgBTKQIQ1qGOMYxyDGh34xjF5goSpNIEmGspWWtWRFX2mJY4Vy1BJ9EeEkyFPLtmZypOTpMS5uMcvzMmcCGMBAE9bLkitcwYpUpEJ7XBoFJ0rWoAa1AQtH+EEMUuCYEHDgTQ1YwAIsYzPNEAABPijEKGphCzrcrzMGQAADIIAABzjAA04ABSlCEQpURC1qjkCDI0DBCwXWo4GcemCnukY2ClpQVNC84HWaY5zgCCce6UhHcbyRNlB4oi9+yMIV4laDHGxhE6po4SyggR/raIMbTEmEPBOxLAgQgCqQu6GD5CD/h8j1qwlJkJ4PqoCIl2wuJSuYQUL7KJezfOtJNABBCl5QimegixrLOAYyxDiMYfgCGYy4UUBvED21JO8twROXQ9mIpDlmZQg3SJ5cYLDEk8oFdGzJHFxuSgMTaAAGS1hFLWpBi1gskhXYe+QptCdCk4lJfEfQQQyuGAKYUQACDQjlAUhJgAPoQA6eiMUqmMCAA9RpM13NjM0I4IAa2AEUofilo4TpKGjIox7HxFR0Hsi1r1XwgtB8ZjO/ocFsZrMed5WHOrCpDV+QAhR9gUQWhFADEaRHCHgIhSp4o4sYvgaeZMjEDxcGAwGEYCqNi0olKiGjqhjRWzdIwQoyQYS2/yS0SQflafPYEr0dSLQGdQjGM9K1DGOIkRjGMIYvoqEKKSTBJYaEkh7j6FA5JuliUwyeEpP0pD5mDqedkyN1gbACEzSpEbEYqiKPqgpVNFJ7ksTEJCGhiDpg8gc6sIELqsomCETgAQwoq80OEIIUyKEQJdjqAXY2JwA4OABrRUALrvAIR11imGjIMCiw8Zt6KNNrnPIrdsgGWGleR1Sd0mA5DIvXFlcNHvCoBtQuUS064CBuInhBDqLgB0vsEhZ66wY3BGEFSQAuEQobQgMYYAQjLEUScpBkHxanEKuQ1GVWIENCb+ukKbV0ug5Ti0RtIARcoCsayQWjMIRhDEDhwv8JS4hJdNsSl/CaFAhwbClK6fhGkiSPYi5B3ne925XMLcl5RUg0l4mQClsQNUtGZaR731sKkMVXMHXoAhSIQD7HWJVPEHjAKLca4DgJgAAG2JmqA+DgB6uVrR4Qgh0+6IgryBoV2kjHXZU5wa5lpzp/fU6Joyk2whLWmtksR4sRKym8ysMbvAiFJRpRCbjFSgQeaIENnnAIUpwiddTwhuOyrAd5kiEJC1gBIkwhB0lIohKSQEQnyo3kGZjAiebNhEFTAgMg0OB5VRS0nXdABBjcgAhYoIU0Fm4MZYARjB1FlxpisoIQgGC8cbTQFA29RJVqxQpVoBdT7iUIMlTIpN7/PSlu6TyT54GuJVVAby2sF2mktjd7p+hL98Y0BzNAIZP7hQxW+STqrdoMNJ6hU2cEgDPQFKCrsfRv0HDgBrhemJgdroc66EEPdqjj6+noq6f6Kg5wFOc54ABH18wujgRiM5tgT/aK07FY43jDGKTwAyMUwQgz5AAHIigND6CgCFGw4hWz8MWzsiwwIFrAAl7ogxQ2IlpEJK4JPXVieWFA5IQu0UlLxMpbvht6kRSc4FAoxcLR/EXjnmgYXOTEEVCSAhAUQePU9Z1XUH5nC1UBCUOY3UzKbYVw6cEKNs1t5jj3Fp4ycSbPzUQi9XJUpGJvqR/r0nwVYRhN+yAGIcDA/1UpUIFQM2DUBkg/0j2TdKQzff0DsJkBBsCACEQAAkJDw6xBAY2sm00dl7JMZDNBEIR2aWd2XwNYZGN2hpVN2DQc1TQc7MAO5QAOsHELjrAIdqAIipADNVADESACOQAFaYBOWOIQRJKCgpAJmTAEETAEUeEF9EQQO2AV9nZvmmcCQJAIbiExR6Ik23JTeGZHMLAvXsAIXIRmDhdGyPVF1AA7tBcCTWYEt4dxbRRwL+EScxE6SPB7eJSFMyEwRQBIgNRlbLE5N8U8UbItAdUEpjB9G7NI7NVe2AcymIAJjOAH4vMDQUcBHMAmE2B+oqQACmAABeA+8Pc+iQgaA6Y/F/+QAR8Qa45ADfRxVyimHcpRDs8RNid2Hd9gH6BogdfRN9vQGhbYGtWUTchxNeUQD+qgTd4ADtlwDL70CH+gCGdQTkdwQk6gBoXXCvxBEAJiLBNgATYSg5DzFTBgAsxYXvi2AomQBF0mhHqmJNmFBDGFBG3QBrggDdFwDEsYRmC0DNHQC2ZQcCEQAiQBBEZwhW2UU3qUhTIBISgxBPwCUzG1fFNSFt3VFhODW0/ibzDgRF0WkDPAAualUFmRCayAJZAmh9WHPe71SFwyX4LRBlIQBGqSjn9IAYFYGqFUiIY4AIjofu+XiJpxAAiwALO0ARDgABdACs7gDfEQD9jwK4P/NYB8ow3Y0JM3yZM+eZNBaQ1EaQ1B+ZP48Q3gcDVlt5StGA/isImx2A2pcgmPwIFvgwWUNYJqsAkOFSRj4QUw8AA3wC808RXO2IzMiINNkAgscSSlN14A4y/RMzxeoArS8AwNt4QfcgzRkC5+MAQwkI7rOARK4lJtRBJNcgOMeQNJkAiZYAX00i/HsxadozzfxW+GZEhl6HkHxQLOKEUtwQka85B6kSWvwEhIxUhKFV+TxAj2FVUx4AIu4BgdIH4T4JEQsACEeADpN5KLiHTus1aopgAsKQALUEstAArF4DfXEEOtwQ3iUEHcgB9CaZQ9+ZxEqZ1F2Z3P+ZxH+U7e/0AdsVgc4KBNxkEq27Ar0aA2l7AIYXIEUFAGseIEV9Awu6MhSDABExATYYEEPnVvzAgCa8mMRJAJLOJd04VdDrUENGJw9IIFkEAMeqkMfAlG0/AM0uAJPjADjkESX3hd72gEQ9AkL5GP9XJHwqM79KIWCpVHF3JQm4mGmZlQSqJQK8ACoAk6RCAJpWAKDZklQioLr5CajASRSZVzW8IJkNAHZ5BJP3ADtZmOG/B4FhCIWUWICZAA6VeSi1gATKdgvlkAAJAZtnRLl6AL09AN2XANsciJ7oQf10CU1VCn1UAoeJqnerqn0DAN1YCd2qCUFniATpkchIVX8UCVVkkJi/+gCX4ABWogBHIDF8zjUk0AAwvgAkuyA8yoARIAAhqgASAwqswIA32gBzDVgwv6gxaiLykQPUQgBWdwC88AjuEIRtSgobVQoo7hAw5jmHdmaGsxIQQXEzGlLzARaLzlJAWJhitQkIbUXVCiUL2lFpp3rfcGA1ZQCZxQClhCVLRAC0IqrqkJaTXnXh4zCpiAi1ggBUvAA/rVAiHQAfSaPnAiSlvKpfMHfyU5J2tVpjrDVrV0AWgwC9GgGq8BWL+inXeKp87wsA8LDc4ADbIxsc8ADRhbsRNLKNagneI5QcbRduh5HC4GD9CACpewCY+Ah4gBNzzlZ4ZJE0nAABMAeiv/oAEmAKqhirM+pQHPmgJIkAk3AFNtwRLYdSQ00RJGQAQSBQNIIAVKoArPsAzK8EXI8HC5Kg3BIAUDCQKGiUfAuhaBpBZ4RC8ncXAx8RJDoKwosZk0MJC3dVCbs5l/hFDZ6nlwy7Pl9apkwAmjkAq0gAuCC66zUAu4UAtDOqSLpBeskHPrWgdlkhg2EAPymo7oI373l1Vb+pteeojvQyeuxnQKQEsweQWwcLDdIEPYMKdziqcYS7ERO1x/uS4Xm7ES2wy42wx92rFG+RrUMXcOmE35kA94NR/ZkAuOcAlhYglq8ANSkHEiAVAAhQQp8AAagARwW14jMAKhur3NOJAp/5AIBpEhehSQcLE7SNCOzPO0ZwAJ6DK1W7RFfvkTyJAGKECgKNdQF7IDTiIuwZe2JkVHt7MYnMNvzAeET9IkbrsS2NiY03hbTqS3zwoD3coJqWBm3kgMt7DBs4ALwVALrjBpN9deklYKnoAJi0AHdWAGTsAD+3Wb84oBGEB0o/EAhJh+N+OlJ0mSh3iIhpgnB6AAQbw+MBkBHoAGsPAM3RCL4EAfNTmV2RDFz6mnf1oN1EANdPqnRfmcV0wNMPQr3uB2CVQ1NVmT8sAOkvJiMdYooSAmeqA7hkYWz6IVN9AAFsC/5eVT3LuzGjACOLgCKdAEOUS+/hiXYWZSgbQEXv/QBr0wXMsQvyAyDT/xDJuAAiQAAj04tqCjJPTyllFkmRQiMfymeXK7Oc9KkJqHEkOLx6Q8wRFMqs96A3zBF6rQjVEsDb5wCx0sRuLKSK0gh3nhCq2wJaLgPZDgB2cABT+gXwWWjrdJfhDgkQ+gVQaAavvKrz2czUAcxIRoMwxwAR4AzldgsN2QdjAGD96QutrwnddAsXl6p9TQsH7andZwxXiKxTFkHeDgisHRgMERd+ccD6hyYY/gB3KQLQATMCGxAylgAIU0qqC6x9vbxwIqWzDglt1Foyf1Z72FIFDAChaVUfK7DLExDK/TApfsMB1nFjmCIwTHEm/bZdGqwNH/OpCbqXnZO8GmDMFlkb0pgKM4OKo4C8hLYArf9E2qQKtSHA3CcAvL1Qu3EK7iSn2Q9l6S5AmWwAhzIAWyKVW26SYV0JFwsj5BPKbB6XQ+/JsGQIgFYJwLgH8fgB5XoArwYc7bmQ1FGRuCstfujMX03LDq4gy6C0M+STaaYimUworWJA7MAAoZZgcr1S29UxYm8AAS4FOgqrPb673XKlFWET1ouEcod2iBBDlHMKFXuwyqDSKxsQzC0As5UAI6+IPn2xJtwUf5IjrI06wTY0gTzNsTc602jaPOSFOAzEkDyW9BDar3ZmBG7QmeUGmnoEVdFMVepAzLoAsbHNVZMtWy/2BUFGnCeEgHXbAEPsBpzDyvG8Bfb4JVDBCSvimcnovWBaDWQPzDxol/GbDfHtADpCAM2dAN1+DF2tm6gR0oXZyn8WyndUoosvG6fhqUvzZYyaRB4wAc6XANsLAqd7S2lIkEBVFFIHCzCSABfNy93ruWgMyMM2AF/2i+SZsv/3s8WBEVS8DIV4vdU/sMVxwN7+IGIWACBUNk4pJlabQDRuASdqTSg2ZQBpeP/ghRa2HTm+nbC9VE36tQTeKMKyDUOLhu7cEJfksKqjALuxANz6ka1jANyrUL2h3VtKBecdhIjTsKmnDMaXAmS4Bfs5mOndQBbGJ/mcubXZrNhp7W9v+91rzZABEgGlInApRgZtQw4B17DX+Kp4GycF78zvUsz9OAsQ4+sZXek68xqFHZHGkXsooVdhYIDKCgtpPJHzNBA13e5Q+QABpgAd3bxynuxzlLqvwYyl8Jlv/EMF4hI1IgC1fbcMPF47HxC88QCiGwAjSxMAkNosF3EncUUP4GJWdocNLzyaKMUM9aylPCqWkZ1Hm8lqIqUStwA5VgCmIu5t/kba8AKJO+xK5xDc/wC29+C0Ml54sUC41UCtXCCG3QT2iSX7VJm572SRRAfv/VAL2Z6Ieu1gKwrwiw8QtQpgJwAAEGk07wCsgw6VJcp0Sp1+oSDV18xdq56Z/ep13/jOCVDp1pFzZMnHaHVQ9l3BO8MLTCAxYacoM5m+slvrPcu9lKz70Q7bT5GHzBQy8O6qDFbiFbsQSYsOw67uzRUAy+QAs2MNu0jRYl6hYwFWgQJbebeXBlvxLQitPX6kQKZQI/TVKnLKCkmtl0D7TfdIffxBelsFSJFw0d+xrpLODUcAy7cAuDC67f3cuswCV3DgmG0AZakBj5RVJTqt4bABnlt2QLsLlqfeg9HGEVsAEXcACtplYbX0s4QNfUEMXb+fL2TCgtP/N7nS7eWKvHkC57XfuF0gzMkAzMUA2vCwy6MAuhsAMzDiEuIaA3G6oNgOsmvtnMmPR7TKD3pl30/1JH3e+gdXQWX9kvUhAMxGChy2BRPa4MudALS2ACSbLJV8H8c7EYjNm2ByX3A9mYN6CGntcWAAFDIIwVJlYUNGECBAgNMFI8TOHQ4cIUJjSAMBEihRRPnjBh8jQqZKlRqlTN8hXtWrZu3rx165btWjRkvXbdulWLlixZOmW5YnVqFCdNlRjR6QIliA4fN2DEcJEiRAgOGzZQqAChAYMGChJ8NRC2wNgBYwsMOADhR6VVuFZdABAXQAC6AggcOOAAhypiz54pSxa4GDDCvHTlQox4luJZs2A9foxK8mTKqCBfhoWYGTPCs0jB0kVENJImSICYpsFCdUGMFgxcxGhiRP/BEbUNHpwxA8aO0kmqVEFCBAmSIUBGBx9OuvTp4TtqRTsWLZo0adGeIXumi9go3Td20ACy47T4HcSH6N6RfscMGt9z56YRnwaMG/W9pxc4w/1BpwcJpjgIQBhciMEpJHZ4iD6BLLBAIxf6GKUUTkKK0BRTTilFlVZQioaaa1bSJhsRV6LmGV9wyeknV2RhhZVSXtREE0j8aCOLI3iwob6oQuhgAwx8vCCCCLTiigEFFAhrgLKSJEuBLkqpBZdnsrHlArzwMuAABBBQoIEMMrjgAxzQIGWWX4pJBpppqoEGmmaYUXOaadBkpplm2pRzzWqsseYabLTRhhtvwBGn0HT/ykkn0XjiSUceeeIBB5hcjvllB+C8sII0INqjYYaDPl3hgQkK0kC2hEa4jQUY4GtvOC9eTSI50YQb7rjhgGDOOE6CIYYYZH71lZhhduklliGGuEG/9sIrTb7zZrBvVfXea289+uzbgYjw3MuNoBUGom8FikB4iEeNBDJ3KhcswGAqGxjRxJMJKbTQlFJSUeWVW3x5hhoPPwT4wxJPrOUnFVkxSaihjKJDCyeCOCKIG3ZMtwMMKKAgggc2XuDIAwwoAOSwDBggARI4ccWWYKTB5QUHPsYyyysViADjDD444pRnuoFnUXkUXTQeRwstBxyjCS1UnHKWZhrRdNRRxxyp/82Zhx52oI6nHnngYSYXY36ZRbgmxm4iPPZoQIgFT2nQIAGDYksooYNU7ZTT8pLA+9b0cvPOhyFoxVW8wHdYoqdZbsEFF8NneaUWW+RwCoYhcDutNPPUS++GZaet1tpkc8PP2wA1ID2EhRZiEAMhK3iAAQQI2JIA2WUXoC4BLoBEE1E4mbBCC0s5JRVW9E3J3zX5rMZfamgS5hZaaqnlFVleQRhDDD2a8QwskjpCBxtcmKrcEICsIGMIWu/4gAWuJFmBEo7QJJZgRrmAAQZGFjksLLtsYAIObhYCKqIBjp65ZFCJSkc8CnU0o5UjaURbGgKflo6pVdBpi7LGLIZxDP9dvCI4ZSMNe3LDgk+t5iAPsMBtDhI3UMFnPfWZlWlwta2+HUtbMxwcDYiwCVKcQhVAOUUQT0EKWeCCE9FazwpmcBpcOetb3iKIQSxCOipagHQYSQFDQGCBBNSOLl8MgFzEOEYylvECleDEKDDRu1HUq43CkwUtbtGLZTwjGnLCk3SecQxi3AQXu9jJK1zhCpOwIhUkwcSM1EAHL0jhCD/4ngskKRUeYQAD7MrYxhiwgE0iSX8RQEEHuveyAyggZGYZy8hK+ZX+UeADYMIBKZARE0AJilAObFoEH8i0Q+WSghVUR6LKEQ9t5GIYyMDFK1ohnk51CyFxY8hFSiWBB5T/CiMIKeG3urWqb4FKbgkRkOi8mRANhCANj9jEJkQyiTViwhGXcIUifkCEJHgncJ0bwg7ug7nwrEogCDndNcElLgtsbAIHnQCDEmqBg2qAoezqwFQYtBAOhC+hGOjAGXr3EU6IIkKlsBfwftiTW+xiGHZcxi94UYxlQMcXvuiFLnBBjF7QYieDZAVQDjkUSDCCEX44QxagAEkbFJViHUCqjypQAY21zn54WZ/6GkAAAVSVACRDpVlG5jG8yI4BF3CAA17wiFk4IxuAIlQ41LpWtT7Qrbksh9SgdihDpcMbvOBFNHTBOFUsYGMJMEsCGvCVr4xFsBOQgAQ08CkVspAg/9xcFQiqKgC0fGUCpItIfwDEQtYU9AiMyF28DNGISlRiE6DoRS0w4QN9JmcFCWrPa1PgKbl5Cm4KiU00bxu32ygEmguBDbkoGRGpXCR8IUhoB1LQB5CocY1p/GiEfLgiOdJCF8IghjB0cYvFCOMYw/DFdm/RqxT9hBXmTYVQOPGRGbUhKT/QwQ9uEAOoUHIqPbrYBDTWgK0sIKpKmmxVA5BVrZ6lAFBlQF1g5wAGhFUIsIhGN7ThjXR8o60PPNpbm4bARW3YG8nIRTR84TxVlCIhIEisQ6VJOgtIwIonjg3pestbUPkniwvhbG2jKEXeJqSgNkAEaePViEmU1hKoRf9GLbxABKdsVjfsucFDbsAauF0xmqV6Jtxuq+UrX2SKmN2iFako4xSg0AIPilcpPrLGkZTCEz1UxfDiKMeSxnQWrbDMHG9yC13sQhg3sSlPbtqi6/GUEXUQ6hGWwOQbfE8q4sPvxSAwpK0oYAG18+IXCawkThdgdgQAo10QMNW0OGEW1Mjw0hjIwEMJk5cSXBqj0gGOaeR1GXy+xSVCIZ4tlmoGwc1tQHu828a2cIU05ixje2yQhKagEKUtSiEQgUZHhIIWz8AFJJbgEAClYAcCac9DxHVN3+IWxjxmoUWgyWIxUzHF7FaoQhGq0AaICgbPnoQnKsHR3pFkFD2UMy3/ZmFTnHD3FZIhxYb43GfsoqhgroCeLGIBROC52Sh1OIMZvLBo+NoAKvW9r48sgLEJTPoBCwhAgDWdVU5zenYFiIvtJmuALV3gCqceFAHhsXN4rNpoPfe50V7iDUBpoxnLcMZ2d9EKR4BiBRdpsWKpOEWpu3jMK746bEwg7gC9tssBza25dQubREwIpDH6yChCMQuauOJ7MNCAi9NDrtMF1wS5ISjcjr0Ctc1ANZ469rKRvRD2GCQ3U+TtQTlAhGmvsbRslq5IcxrHWhxu4TZRnCpQoS9d8CIXKUGGMBIX8UFS3N8yUsQczAAFLCglB99DQQle0IKpVNKSF6BAydHX/7EEiEVJIGu5kmRXlpDp72NeQX7HINABD1xABKZGRnXsaB1lDOYXKvV8YxwDmcpIJjO8GHGfL/GIU6iYdFIfgQbST7rawIaKpxv2NWv8qYf4tiI0HjeOeXtFRIjkFK5ohELoiI5ChejDhTPIERNgECSopxvQP/1jLP3jrdjgu/cQvHFjN2liEHKysqsDgYQKASkIsn17vH6zFx+avOcROJzoM8xLnF3YhcPgBWNYhmN4qcSxhVqIhR0EoiAiCRk5NDVog9V7JBt4gReogReAtA3oEUxqqgfoCrDIH7JwOQIgPq3CH8LyGASIgA/ogA/wgBq4gkvQvM3rPlRQhVAghf81DIU2DAVLsIRL2AQ1PAk964VkQgVQmAErSr/EkoDaAMRAxL/5+xRWkQ9n2rtPATfa0qYA8TENqIKQGoVC6IJCGAVROIVQ0AVpQAZPiIEUiDsLoI+ICAGDYAGMKDyFyMAxgz90WzcQEJepAAEOYBAO8B8SMJ0QuIiFcqhahAAK4IAq6ANG4J0SHIkTjLMVmTM604U+24XEaUbD6LNjaJ5ZwIVWoAVc2AkedIVVwBcMGQpMYARFODTteaTXy4EaALna45ENGLmM0S/+4iopPIvgu8LiU6VSQgsF0BIHgIALYD4PEIErcARHsAM7cAM1OIOMK4MsiIIscAInEAIh6IH/HsCBGsDIJJSBI/gCS6AFYsCFULiE4NmBxRozFpgNEpoNFlKNlpy/v6uW+HgPceom/5hJ//CWiigdIrCQVBgFOaBEktiEVrgF6qAFHjAdK3qIDQgfcgKBVQEQTwFFL4MxLAoQumMIBiEB+7ovS6qAdsGArywfCrCksrSkCKiAEJCDPoCEYtw3E5Q8ZbSpFcwFnPijZkwMP9uuxriFVniF5ymYicOp6iEJTrAESOipPjgDKVAKHgiC13O0R6s9DqDFSzooreiYIyEs3yOwVMIfmfkYA9hCBrsADwAT50vCJJy9FigBEpg9ERABFGgB2PSA2vSALywBFTjCKMCEUxi//1YIhiOqiGhagfQDRGiasUFUImnRp/qAlmQBl+j0D23apijSgBSwgVFIhVUwhR84gkk4wVB4hSkJhiyYCtWRpBBogRaAiCxyARg4lxQAHwcZCPWUT6lAqtrLz/uUpP5cz9mLgRqwgaXwnhvQgfg6AiI4xyMwBLYkCmP8KMmbPJ7gS7v8I8Q4DGJRHEcghTvUvL8kPZzCKXBcL064ODUQKiWIGB54vRroT4ppx6rAiv3qJMLqPZDpTCz8zLBIgCPZklEDyA74kggouQb4UQTQkiONHdl5nbs4AAJwAAS4gBr4g0uQhWwIBkhwAacgHWyCiACJiP94LZzMjzC9lvoYCP+IiIoxHdPolE5y0QFO2M5U6AgKiRBU6IVbIIUr4IFPdIEgYFHIrA99Eg7hWDQpWIIlkIIqeBUvOIM0aAM6kFQ/MARKrVRDYAREKARIaASf8lSf8oNQpQM/kFQ5MFUv0AIoUFVAPQM/6AM0MtG3bDMJVUZZqFC7rMtcwKsTcYUgiIAg4ATgaYV8mTMVUUagUAWhCIn1+imMwwLGXFHI9LhJqj0SqIqLGRIobIAFsFEcNbAcNYsB2NEn1Z8FKJ8JGKx6zJItsZ+w+scLsAqBFIEWwEh6zQEzuIRX2AXqCM6LlApYlDKBeNEztY8b8IGDRdiDnZVETVQpcNhFNdXfYNT/VzFVPZADPcBYQtBYMtADRGAE7RSeCBGJUYiQVugFZAiGWvDJSuiD9cKESkBMRECERECEPpADLzBVORgDiWWCJFg0J1hR7ymqF4iBIzxCFUABSEMqi/ERq4DXDViqpQqSCwCrC8ACP4AEjoLQF6FVnoijW70FXQWGX9guWVgFGGCAFFgCSDCFOPNLFZwer30F6knWilOjnvIDhTSD1ouYHMiBA51WSoq9SroApqK0bfWKG/XWTes0TmOSL8K0ATiSjlmACGDKI0zC9cxIjMSBzvXbHsgBIUADNKhSWYjBnSAJSKiEsuOdoWhd6CJZNyJZkajTGLFdTeCd2y2KeJGX/xjJhEyoBEmQBJmV2UIghEJgVDlog0pIhe2MENgdhVMIBloIhT+AghygPReYTRG4Lw64gNuj2sIdErQcEggw37BC341pHfR1V/VVX/uxHwRoMASIUtdR0i2JgDmoA9BCo619ERSc0DkrOJzohWH4BcVYhVW4gQUgFx8whVWgrlrIiZ0YuJ04mDjbqfWakTqYg6CCghUNgo6jr6hA2pC7GIyJAP7iPcXN0ZYTACpUkgIAo1BzUtlxgAvIAj+gBDgEhR5WwyDSEOl5Bb6EwV4IL5yQBTVrhJrtgzbwgr1VVdEIYaElEP3sEQgAX6r9ki0u3AvIgA4IkvOx3y25Ethxnf8BuAsHEIE0slPeaUNRuAQhaIENyNYn/bQAm6wZ1uM9LqM+9uM/BoAIyII68ANGYC9ZjVAUHCSeoK4B3gVkMGBeuAVVWAUrsAAO8AEZsAAZGANTCIZg+JWa0om5nZ4fijMSTaRD4+AUfUwcYFGjor0QQAERSKqwPNfzQdxS8qR6fOF6tMfGXZIs5Ef5/Ucw2QAcoARa6AVQBpZewY7pkAZi8QVhEIZeMOI0DIVN8IMjyBGocIHvGeEXtS8fwYAH8Cq0NFwhWR3DrYDChYD4RVLZ6arZgYASiAEFgB0IEIHeFFlR8Gc3bIEoRYBMowtANuiDRmgxKui5iDkBeIGF9Kn/Q4Y8rlVkQVtGFuwFYphmXOjGTpiAtPCBBogACyiBVYiFTlABT3AFS4AenVjkFmmRZL1ETuipcXTWh3HMpYDl9ZzN2wSSkdMvzLQ0r/A94vvllqtHz+RRBSBj+XWACtgAqn0Bj8xoZHipX/AFGrQjvOLqwngERVAEQ0gDIojM+2xPSqKoDmAQC4gA2WmAqF0qdY4A+B1j2hEwMJoLyA2jukCANRCiIRIiVSCFC8g0P17oPt7jxFbsxQYj2BloASMADPiBLqADRRDHREJkik5Gi94JOUIJm5jmWkjgJpiqF6iA/rGASLCFTpAABZgAIyCCRiiY52FkFkFWVE7lvE1R/yhQAkCd1helPfzyERQWY8TlR+Dz1qMOPqXWZZjREgYw39N8gUWQBWEYBjpRkz3Bkzaphu6uARxIx/T8SnI+YZLLPYQSS7Iky6a1Cgz4XqqN2vPZGPZ9AAeo7wdQZ6a6PQj4ABKogRyYg1GQBeyYvuvABUbgARHwgKiGAH9scPSl3/uV8PtF3/CtTdjU3M7tASG4gisYXTewgz9whEfw4XxphVaIBU6I0hDog0LoA0TI2kTK2n4DHkWmrjiivH1hOFyIhUyIBNWQPZFuACuwhVUgg8QqiIQyhRz02tpG1p3yhN0RRz9QPSzIAizobaKKgaJaxw6gzOFmqklT4SPh0f+iVu5Ow8fQLCU1PwAG6EIhzYFLYLujyRp2mIeokRqhiQdJ2vKMlCQBLSobOFAdMNAhmCdFdVgm6IJF7wIpwIJHh/RIj0gleJge4IFAfT0csAHO3XQBxd7ZC90yIL980b65BQU7wIIOV/UrKIMyQAM1CPERv4SOgjO/lJ7nQRxiKeJp9hVk6HW/kI5gpw7qUJ5iVx4RyQZqkAZVuADay4RYkAOZJQrEnOjAHp5bX8ZZ6DPEwQVbEAQJYIFI+IRPsIIPZIFYsIVPkADCWgEyUEDZ3sHaZmTCFFkNVoQ6UIMO5lsWJXQ0hdEQsFYwD/MxP5JdRvMzD2YcHZkeFYCwQID/CvgAMHSAB6OGnomHeZiHdrCHf/AHf8gHfcC4jIPIiFTViIyYIICYI1B5lEd5So/Il4cCmLfyLCgDNVADQmYES8AES+CdjrpE6VLkFnEFFOSJKKGFIW6MubUpaw4GmBKGl+qVX7ejYR92Yz/2ZC/2gBmRgAEYZD8rESm6onOJEKEGUhABHvABJOhx4C071V0jkq3xQiJlgfNaWojBkur2IhiBIiD3IrAFQACET7CFWIgECXgNDZiABJAAAaAA6IkFeZ/3ZA0eoRCF3PYDjEvRiDlYp6iv+wT4qiCfMIdC/yJqzoThoy4+A8MfylKSUYOADGBSHIAFa4CHevh4fuh4/47/B7BWhD+wg4JsOlBowzW0drnUCejh9sRR/heEQWKx5udf5k/+ZKYPhueffhe8Q1ywZlxoRvFCHKa35qfn9aj/9WCfDqv/F633erAP+1oSFG94fwNiIHHQGnHwhmwgBTSYAzkYAitYhU8AiEyZOFXCxInTqFKnUp1SxYrVq1eyZM2SKOvWrly3btn6NKLIp1hWOtkC9MlWrCImCBHiIACElRUGCKGsVWsirZy0ZLl66FDVqVKjOEFiVLTOGTNYnBwhMsTHDRgwXLiI4SJFiKwdNmzIgOEChQgQGpBVkCCBgbQF1hYY4Lat27gD2hYgQCCtAQIB9groS+CAALsEHP/0gDUNnrx68vT567dvF65dkiX38mX5cmVhmjVf5nzZl7DKlnuRLm261y7RvlCnJk2Z8i1dujDu0iVZV65csmVL/sXr9+9hwocVM7bMmTNo0KZVs+bc+bXo2LRp69bNG3Zw2tPB6w4vHnjw8saTL0++nmJ58byBusRITh8imVZ96pSpICdPnkYtVOXQlSsTUfTKLLTggstGuNhChgRFxNLRJ4AUEckqtsTUSSyZKKDDKh3a8mEtsdSik06yxNJTT0AJxQkmmECiSB1qKAXFEkQQAVVUMNhgVQpYhdABkFthEJZYZZmFlwFszUWXXHMJJtgBCOw1ZQACTDlYBA54IAT/LNQgVo8+js220S0alWkmmWmqudEsbbo5C5tu3vJmm3Pm0mZueeq5Z27A8fLLNMpNwwwzzjTznHPYTKcNN9lpB8538Zg3KaWVkhdeeeB5B4433WhzDTXURLOLI39A4gcjiCBCRif0CbSfKaY41BCAAcpCyyuttIngRiGeIAFJKEloUoRFaFCABSZYMEEDEtAQLIgIjngLLTa5EgsrKorCoiWQvDiHGVAwZeMPOuxI1QsvqIACCiRstdUFF1QgFgRiMbCAAgocgCRcczUZl18MiDDHKbWogsYGFTBgl5WCMSCWAxfggAo18dTTGJ8ZA9enn7wA8zHIICczMqHNmKzc/3LVqPycootS1yh2joJTDs3gpJNYet1Jal54Pfu883g7x+MdPI96ow02zlUTaDPJAJMnLLCgggooVdthBxpZXyGEED20gEMNIijByByosoGJJl40QSF9nXwSayqupPIQK65YpGvUvcyJSy2dnJAAGcJGAgggkUQigQAN9GXACk2YMAENNJiQyofBPEhitSb6FJQooWyySbcwnpEFjTWWa64NMsSQLrvuiuDBVhlkIC8FFUDwQAP45ntkkmz5vtYAARCAQBCn9EINON1II4QD+PYVmGAIMFBBBREXhk09+ai8PcuKUrfNNtyEM3444oxjfjnjlGMO++ao8z788asTz//75NFzP/73m4dePZLePw871JM9fShmaODQ1KY61Y1sgGoa0XCGMYbhG420KWpTQ0UoquaIDV4ta1rbWg9wALYWkLAFIhCBCU14wtex8HUeCAIm2tAGOtABE43QgxWQQIZPdGgVpkhFh2T1kFZEpIiwuAUu4NSLWlhBAicgySeK0IkinMAkI0gAC2gggQJMIBKCkAALPgGCGNgiGB0RkSt2spOJAChbQRmFKLblIkYgJQtd6IIUoHCE05lLBulaVwlIqJXYbWBIERAL7nKXr32lBS1rUUvwECCFVeDiGd2ARzeC0QIImKUvcBlelBCAgAugEAeOAEY82KeOdayDHez/mIf74NfKdrQDHbakJS5zWctzrMMd83AHMFm5jnkQcx72OCYwf+kOVvpymc5kJT3s8Y53HJMe7PCHP/JRjjtJTWpTI0UGq3aJDZLTDhv8AznT+YersfNqbnCDGuIZTzNkwQlKCAIPcpADHeTABjX4Zw3SJVCBolAEL3CBFyThhS7QwROM6EMiyICECfFwFbGIxSpSkQqHQKSIr4CFLnKiC1ysQhBVvGgUJVQECRXASlgcggUGMAT6AMIKqwiG5WhAhlRc9FZqvGiKgkIKUsjxRUiRIR71+AMfLNVcq1MXVVoQAncBiQOFpABW6UUW3eXrLGjBS0tBMAlW4EIa1pGG/x0c0AADxOWRUZpeCSrwgiCY4Q9oQMU1jHmPe0hzH37dBz/8Ss13/FWw1NzHMRMrzXW0A5i+JGYvXfnKaK7jHLpsxzkyy8t2sJKX6MisMN/hjngA4wpbw4EHU6uGdrbznWp4pxvsEFvWXu0PdYCtGpJiBjOUAQtQENe4giBc4f7ARr8lghPsGYQjNAUGPrCPHCRRiTakqg+IsAIQkDAfi170RLUSEEV2Qa3ZyCISRbBosYYFCAkkYIt8WcsQyojT+ZLhig5axURGdBMTBVUhK3IRjPwQo9GJ6wg18oEOnFoVHvkoKz8q5JAqkNXbPQBfXGUkW0Egg02UVXluQMBdBv/wPAOgJQETSAENiIAERJgiGMhQhR1C8Y8Zz7gf/3AMYHNc2B37NbF/5UdifalYe9CjmPOgxz32cY93zIPJg20ylIkpTXS443722Ac7wIEKITwhhE4wbXKdAIWlhPm3WMhCGtJwhjWvuQzyVEMZ4ixnOYMZzEoQAg/y3BQiBOEGN+DBDYRroyP8lrk2GIIUHFeFTPShEaeiA6q8QIQqkIEMemhVdy8aIlnchBYYwUg0pCELK9AAEJmI4gkM14nDOasIK2CvACZwEvma8RO/EsBHVgEgTu+XJ5tT0VDmyAhG+GEOaehCFqQgBdMh2AY2cCqDQ9DgH2EAAxYYEgUmEAH/snAbXwc4QAIGgDsVUGIjOLCLAazElwEYoAEmoMGEOoTRSjABBRCAADbz/Q9/7Lvf/Ob3jfshcIHTuOA3Dqxf8+0PfOBDHw5/OGMi7g+JR5wfDGeMX/WRD8bgox7TsEMUjgC25F7BnlwTgm+BG2YhKKHld2Z5y8Ms85ZzrQc5wIE+RViDEp6QhLATgYOz0gIX1IAqLgjBDeQwhCEkggh9MIQfUMUIOhxBBz8Yg6oqwcOLfqjrpBEGMZCRDWnM4hRLWCkPT1DFTjBI3VUCIxkIUSH5oqQIIyhAAu6+dU7bIidsTFG2UvHfFhVFwHM4gxbwuATTJbjxO7KK0Ru8Fate/3Veh6TwvZxngAU4IAMicIADBCDi5+3lABZYARBMQh+VNADEgmkM7PsRe4U3ZuC2v73t/cEP2mMT4hCfOPApHnxsDtzh2MyHPGaBhi08gQcqODn0hXBznOsz59QHWw1EiP1/kpD7PF/hCT2wgXh5IF7x4soFggSkE3YgKwhIgRy84IMkLMEHPGhDHaLOiC0oQQc8YIIcNIJAcEInxIpF2cSBIMgsTM0pjEIUYQgVkUQnSAAYuVeVTIAEZMJ8fYhHJIAAtJcAgATX2YJNrFEb9QQrCN5QHARBMAKMtMEZtIEXKBuz/cDpOFsMxMC59IiPkAAH/OBVTdgDDOG9EMAARP/PA0SAiLWFlQjA+93ADq3CFLGAiPEFX0wTFk7TPmRhFrYDYW0hFoIhF44hFtrDXh3TXvkDYjmZNEnTPDTWYH0hYPVVPnADKDyCI9RBG6yBbMHWO92WGwAiPM3BHMiBHNCBDLGBGtRBHcyBGyiiIubWmu0WPWVBFmBBHjGXcPGACO2TDtwAjuwAEfzADajYErgAFEiBF3gBHYwCEbRAFgRY1M0BFOBTEEBBF3hBH0BCixwEJljCIzzCJYDCBW2CJkTIDhXBSqEEC0hAE7AdC5jAFgkAB3QCTlkUIPxKAVCgMgLCgwQDLtyKgKCgG70RixAesdUR4inbEQQBgiEYtBn/XVQNEpBAmLwcEiI1QOaJkl24xfOoW2BwwBAIAg9FEQUmQAGkxbcpQAM8ABk+JEQ+JC29YTIVUzXZAz7cA8LFYUSGIRbWAzBsECTUQRq0gR/4YSC6gYCdJCDOAQ3RUBvIEyM6YjytWTyp2SSagRZY4m8xxXLhEw+Ui5/9wA4Q5VMMgSkSwR3RAXyYgidoQRCogYANG7ElxW9BQctlwRw8giWIAin4Byu0QiugAimAgiVoAkYBkYSsGg144ACYQCRgVCR8ghWUAAUYAQcCwt3lnQRICBnMpYv1WhvVTTmuiC8WBYyoAR2kwULl0SiOIjw+3rlcxbTV41dIWO0UCQMw/8ADMAAjKYnoDUADrMAQsE19sZdb5IUBLGQCOCQX0tI05dI0GZkx/RIxPZaUuUM72CYxWZMrARAAIZljdCQXosM0oYM9iAMq/AEe/sEZsIGA7UEdSCcd5J8fVGd17oFLMmIjypMfvllN5haclcEVYEHJJdedMZcmBiUPDJdwGRgSDAEQVMEMqsEMlYIpjAKx6Z9RQEIlIKYinKRsodMlhAIpoEIrhCVZggIpsAIJyqU3foIGaIAJNMBeaMAQrIAZjQEfUECL+Y0HtlSDJMAJPCAy4ILf/V0b+QfnjEKwzVHUMWIb4FEeLQESOEVkog7k9UgIlIC7PBgGFNI9IhJnLv/AvizkARihBtCAFXxCfTQjar7Ft63mAeSLF3rhO+BSbGopbXYpbQ4ZbhrZK72SPQhcF2IpFqLpOzDWZ6kDNNgBHl6NGqRB1L3kS16nnc5BG8wBd9IkeP7pPI1nb5nWeSrBnq3nJt5iUyRBEjRBdhGCF5wBqnACI+gH1AWoH/AiQiREKcQROA3VBYklEcFCEfUCMrhYMISENATDSNiCKSRCDPxgCpBEJuhADDyI3bWUJ31EFRWBFeDUiJhggKAgi/rXCs5RUfRBH8ggHlXBspGLDZaLs9mA0anAuqCAg7WfkAxpvXTbZhIAA6wA2uklBaJmAQAGATxSWuhLk+mmY+H/ZkX+kpO5q5NBmZN1oWMdkzFFU5HZAz8AmZAZWWMN7DTZAyuZQzxoGRo4AtagwRqEQZ1GXR/wAR/QAR8YoiGuARvI0J7uKRvMARuEbJqNLJtNohZgAW9d4iVeZU9q4hEY6nEZgREMgQacBRn0QRecgVFYpx8YQv4ZhUEkREMARSuogqiOZdEarVi2CTJIg9Naji047SrIQTBIw6mmgh/5QCOgRBnZGuL0RZUIgATEwhR9gjQQA7Woka34WtIuxCmYY4sIW3eewSoqmx61YxDY4Cc6mwsIlApM2490QLXJCwZsW71AgAM8gAUAwTOuwggAQABQYFvkRWguSUKuZrsO/6y7au7AoqmWXhZspunnPpY9SNkZGpm+ipaTbSE9rAP7xEM1yJZsrcEW0G7EKquyVuwhysEelmQbhOzGhuwaDO8akCxjslklJsUlYkHKKRsTPK+hKsFV2ggS0MAIXFEBkAGj1QEm0JEMQVodDJumCq3RKq3SzgIstAktoK9Y7oLTjp3TOm3TllE2WAcuMMEorEIpSEM2IEMs/ApCtlSVrIVJgITVileJjCMKFm3gmaMv/meA6qEM1W2hqWfe+lnqPBVV8GC2CsmQTEDtQEAFhMDahEQRWAnePdIRilhbXe4BXGmWokMtzbAMy3DovoMtGadx4vAOZymWaum7GplH3v/wGG7hPLiuOoCD8oEsGxRvUggYd3JndRKix37sHLwZJLJBmuUk8lJiGexWnDGvmZEOFETBEySXGCMBEgABC4yAhFRRJCBCH3BCbtHB1LVBgDJCJWiCJyjErChtK2xEL/xJadxC1ETDAmUDNWTD2MFvI4/dMzStI0tDJACwB06JAGwj4XSC1foCiq4RePEEOTawULjoYbog7tLBKtJoBd+In6GO6uTgBlcmBvwgB1gA0jXpRRUBBTZAuAHM87wFW6xmceawMecwDx+zLeHwmbqDDzdW6dKmL3mhX2kpGeomZo1DOnSDI2yBGRyeFpxBms1kHUxxI5ZzI+opIYKsGnz/rCKOrJrtVjjrFhh/MSWe7PKy7FUyLxZ4QRGwgNqdwEpFQid0QiVwwhmUMyIyAicgwvj6cbYULSq8Qmjowp/ARpvU7wIlMiN3dEe/r0f3LxXBGpUEwDYKdCqcrTBQSyiD8gn2REalQn6Wwn95y7DJMSLOKI06Jo7Co45CHmUGXVaQQAoQAUHawirYnQZIgL744z+G5jB/G+hacy4Zc+h6ri4xFmON6SsRU1fTQ2Pt1S9J02u2w8Y5hjnAgy5sgXYyIhRb5x7QQVwPgh/sgV3PQRywQV4TIvACbxooIj138ZyR5xWUwU5GgR0tmxQwwVUKARQQgRcAwQgI9EoBAqtk/8IoYIJWaoEXyMF8JMKwWcImiIJCvO0pkMJGrIYv6MZIScYr6EL9KjL8gjQjO22oxW//IsMqZOM0hu1e5F0V2UL/6o2AqNH6zoIoY0tMx4pQGCaA/QHUIcXoKFuN2siN2B8PxGNQB+5WkFAHlIARCEKFRNEILPVXnQW/0MUwr+ZU27AuKfNU05IwSZYrtRJXdzU7uIMZFtM150M+OAY72GEUxHUUT+cgDIJd2/WB48Ee4AEexMGDxwETa6zIbjE91/NgE7ZhRwFi5+KyLcFVNkUTUBFlE46ECMQomAIjnIEUGKIeJEIfMAJXjrYfn3YroK0u+EJtzMJsiJcqIMMCXf+DR/PvbON2bcuvrY3AQerqbzsRIFQtMSyRLPhHGuUEcu+Ed7lChzAETcfKsULCIyBmI57BHd3Rst3oKAoXguXIVPjICnmACdlAFYh3R5xAebMXWRiAWaA3kvR5Wkx1ZimzoNuwe2PWfNc3K0lWorNDLtXmY73mxu1bPDAD16izS/7uHDB4gtu1gzt4HED4gxOvxqaZGZA6JfJWhscZoRq2JS5vyl2lFCBBE6hdN5o42rkoJvjBxcJHjBuFJSBEab9tK0QGRoyJmbQCLMS2dShyqFBD/D77kK9qJV8ve7VUATT5Ez3tLtACKwzFKLSCOILXtawoULhtfgabJfxi4Un/MFLZrXVDZoJh8OMFVAkRgRXEZUdY74QySwPsjr/ri55/G4YZwAzTUg6fw8FrljGTQw6DLi8JE8TTN8Tnkn4bLDCJbjsYHz1oGZ4BbxsY4p6CeqdHuKd/+qeLuqmbOoZnOKGaVqu7+qsvQROQAQ0ItInfvNvECiZUQiNULLG5oB7nB02f9lCRgnjFxizcyZygwi1Yx7KDyiLX9pE/Q2z3rzTYAomXK0KqW3s9EU6hKCucAlFAAiewQigrsE/4hypolCmsyCZwgib8J7H1QR30ASKa+eIt3iguFVRMq7MFVAwQwaU9SCewAIUui4RVGLcp0iL5+5QaQKAbvC1pFuWT/wPlZxZmWRYtUT7Ed77nM/rmt8MxxffEIV81XAEOBEGarQHGfvynj/zre/obzP4boPzInrpOxpkW3PNhc7jvW2Jh0xlTJEERaJEbm7jbRIiTZoIn8LEmTAKAGgLQ7gdNh4L1owKcZH+ujCUq8IJGczQjJ7KzG/nYNa3fTLaSs9clf2CDeCMuuIIqkAKLFAVDq4JFhHJEHK1PyLRQ7EfzdwtAMGLkh1EfOm3aeOkipYqUJUuOHAnyw4YOixZ9JNHTyZatTjRMWMgwskLJBw8iQHjQoMECBQlgxoRp4Nw5dO3aoatJjie5mj+Bnmt3zmfQc+vWqVOqDilTpEjZzcNZs/+dPXs4sWbt569evFk4WuBIk+ZNnDty1qyJEwdPWzxr28Z5M/dNGDZp14wda4avGS1aypTh+1dLliiHESO+UgbLFcdOoDQpMkLCCUCXAXX61KnIp1idJFUa5Wk0JkyPDB2ChGmTKFKkQoGSDUqVKlSxZYcitSwbtWnXrFHr1i1bb2nUjEtTXvxZMEAnoJ8YQRlmgAAFJBQh04lWKVGbLEGCJFARp1OyaMlSr/5V+1atWL1yxUpVKlOlRuH3xAlTpfECDUJIIS8aWgIKKCIKQqIffiBijEg+6agTFkYAgYIPPhBhgwswgACCCSY4iaURG3gpJgPQSTHFn3pqkaedgHr/kagVl6pRqaegYmcqodzpESuhsNqqHmzswKGGF844I40wxhBjjDbWilLKt+gKIwy88upLy8KyyOKvLg1DrMsoHHOsyyucuCKLJYCYDroi4NTsuSIysWWVTyrxhLRRRBllk0oAZc01UmS7xJFDDVXjjz8eCWWWa3qbhhpqriGut0mRo2a54bKJBpdOLLusCOkkSECAAATIjk5XROHvEUVgVeQPRy5RhZZb00tPFld4ja/XVE657xT9+MNEPIH8qKOOhORQSAopoHBCiSCmDUIKOTJZpaNPiljBwgxQ8GCDDTDAIIIKQJwgJRJZMhEmnFZkcZx5XXSRKKBUJGeppm58/2rfqbBy56odg/RHHmB6qKEGEdJQMg0x1pADLboojrKuucLQK43BtOD4yyjATOywMcuMAorCnICMCArfxGwzzoqIZJVVTKk5v1FGeW00PXV7bbZZUDn0ETcUeQQUVKIhDhvghMummFykGQ5TTYsj7hpkbPnkk0hEhfMECQRIFbpOXPHkNEdgTfaRP+wQBT1cdVWPV1nkmy8V+4DFb5Ri+xtPET8OklihwqJV4kApCOlE22C49ZYDDjIQwQMROhj3gggwSFddEUd090ebiJLRnNHNGadee21CJykbk1qHndWVygonq2Snqh995IEFjSyU4CHJNPCSAyGLy4rjizDKqv/riy/SAn4vLf0ijLAwxxQziyu0kKLLaKHYYYURohv1BCBYKAKIIqwQRPGaTRnFlFNOuds++E9BBRVYkIYHmddC2YQUVFpxDHgMcIDgAAc8wKENbUQjGtkoIDiIM5zhSCMYsdgM1zqRQW6VKgGV6YQmRAGKR4yQhG6Y1SV20Ytb7IIVskjFfFjhilPw6hWtUAX9hsUnvhmLPMkS0EIOhCAtQGEJdMjWtroFgxSUgIkikFzlMEABCkRxAhAg0UoU4K4E3GQooHPR6MZhjtMVBV/osFGN/NUUIAXMHu6QHU76kY9rOAINWuBBDpLkMDYgBEpyoRjykleXK40lL1uAXvT/CjM9w1RvZNfrkhSwEMSVsSA60KEBEM7XBDIkQhKSyIQpPkGampUCb6xIxQ1RUZtZEOcW9kNF/VoBC104QzgHjMct45FAYABjGgckYNUmWEGtZVAzd+LMCGDSmUps4hIkFJob7DCrVmRDGLeghSt2xYpY0IdXrrDhDemnN07w7T8DWZYXFIIFdTpBC21ABCe0ZacmzAAGMkjBPUPQghZI7gMZwIAFLBDFdbFERFoE0r3uRY7SzSuMo+uJUVKXojMqxRxOcco61piVNt7odevQRz1ygQY0QCEHOeCLHhEiBopVyUottdLzoge9L2VhC1tgpMjKlAV1MkadRJgBy05Q/4TLCIIM6PRCHxqRVES4LxOaMIV93nc3+pHiPbd4BfxeIYtTEEo2pIDFLH5By2zYMh4I9EY6bjlABXrjgNfoxd5M4Qpc4CIYtgDlJwBBmU+YQhGWeITQDuUIO0TTEY9ARjd88Yq49WpX86nNY+EnznHy51h/88McMHsGMyzEC5LQRDxT4YUb6MAHNnABPl3ggn1+gAMAbS0VUwKBgboLSDqJ0UIZ6lAyBkVFZpxoRZvylIxipY2ta0o9wAEKO5ghCDzowUkd9jArrVR5y7PuF2D6F78gMmQi825Od6rO7q2ABeVDnxXQi8429KEPiGgEI+SQJ1PoiZTys+8pTBkLWf/ULBW2SAUkFHGJUFwCFLEJxf1yAQxoWEMbbIVHPORRVramoxwIzAYyiNEL3vQGGb3AxbY+OYpHNDOwgWXbrBwRiuHsYha6ioUr9NvYbz4WWDns0zgxER5GKGIgfvAhQhoxisWtwgo3kIhFbqDEFbjgBfpEweM0QILXSlFdKcFiTCJqFNLllnRkfCg5VETR0d0IuE95XUZ/YhV29Esd8igGGuwQBef2QAtd6ILDxCCG5QFSkFY6np+Zp5eaDprQg/bud8vEGJ5CgQgwmMEMgCCZJDTBC5Csw0CQlSxG1PepT10F3mbWkY6A0hSriAQZEFEJY1liE45gW2CPhooEO+P/Gg4eYDzUwY4Ip4Os6bAwNY4RDFzUIhWguASJS+wIN/hhUWvbBTyywYtbtFhucvMmfOBDH3DqTYc5PpZACtKHQkjiE4tLRROGYOQg5OAHQ4CBC2Bggya3AAUlCMG9oYiBClBAXVZsF0x6CyOekA63XX6RjMAsUXUQnCkXvehwiUuP1SUFHqhAgxmgIIQe4OAvd05SF/S8Z5eOPAzLK2ShUY7yQ5Mp0TxV5xKIQIQhDAEJRjBCEqSQkDr0oQ5pY4Ma1MCIUcSiFi9mRQxXEQul2ykSkRBEJDIBCDJskhB9gMQilM2Gn6tBpCKN5tFmAYxmNBgc4hiHOtIK4XpEGBze/7CGM3yBC60a+xKQSPbQiKaIQ4HiGvHQBjBmYU1ZtLCxNTz64WsT2VLgp1XeFs+3K2GKWNiigkXegZGdMBEfJNkFCnvBvO+N7w5g4AL8jsBAGwBwFYXORQxtKMEfupOeEHzMbK5RTn6ClXXMgx5rRko6miHSLEBh4y9gghS60BcwgIELzbeun126PC5srGMpT7l3wXS9RKspks96SBKSUIUqGFW9dcCsGs5wPSiYwQ+euNsoMKEJT5T6TpHQDiCajhkyNEEPPIdmmhajDM6g60TKhGjlfnwhGq5BG7jBG7zhweQhwuQBHrrhGqJBGHAhFkxhnMTjrwKLEdhgDgQisP9mAcK0gRcCL6vWo5vmo1dMqcYiazQ4QRMw4RKMJf44QfKCoYIEIQlkzgeOgNF+YLR8QAeMRGFqQJ9EAAXwjVwoAF2qqHMUYEV04nS4jPZkhEUGjvYqyqK6UB1wjypwQh3mYR5eZ83SARWEoEucwEha4PikQLu6gPmaz/mez8+cbwu0oKbSYAsOw/pWjksM4wrIZAvM5HCW4FkUsQvQSQrQKf0E4wyUQAgeIwvSoAuywAmkQA8SIYPsT6i4BjNExQqqAAvK4AqEQAiUADKyQNHUYNkWhVYOrBVmgReGARlqCa0OCIKo4RmIIQNTAf5GsMQYwQyUJcAQ5Roi8AS/Shb/amEFu6mxjk6qakycmMkGMcF9Jq+uMqEJkgAJiOAHDiTmilAHYkAHbCAdj0Sf9CkEoEiKTM/fsiheZE/2WuT1uJB0zoGiWMe4Fs4phsIc1gFeziEf8kEf/MF14sEaHOMPayoKbKr6auoL6tC6mo/klocKtoAKqKAOO5ILqGAKRHIKIDJMIDIxHlIxSiYKjk+d1IkJYFIKiADmiAAKIgkK1q2kFEYHboAOKiERTu0yLCMSNGhrAEF8xicRdswNlKUpl2VReIwRPFDASOEUaPEWeuEZkKMbDIg4LtCaWAH+IMEDk62wRiiw7AAWwOGWTvAWhKGGYEjbeiXxFG9nPGET/67REjDBExbHFiQBnRricBDkyNDRImzA8+gt9N5x3yhgthIAXmwL4e6x4PKxMvuxXzDqHAQyJ3TCIBFyHsIBHmbBCZ7Au6yvDlHzz0ZO+lAzJDkyJEfyJE0zJRFDnRpyCphAp9SJprqACroA5oIgko4ACyKCB9LxB3aABSgNEYCgg8RHqI4SKafDTcjA/9QAIYDuDLwgj9oA6F5REVbDf05BFV7hFnSBGLSyOHoRA2mhFUTBWA4FxcqyxNimGCCQG4ph2urm6GzIBekyBvkkFDjhPS3hqSjPI/SgOtHpcKAlQS4CHWVgHVsgBUSvXKYoHtsFMiPTHnkijFyvMvOxRv+Ay0ZqwhxSxyf04SD5YR3KQRvQQAhKEyX9ECIJDSRfsyMp0g6vqzVdEzZjc+UMTUxcMgpEsiVN8RQdowyCoAecQAggg4iGoFkQwQo0oIP0AAYiYQACgFTcpJK89ASqsw7QL0kCwyXNFAtacdmKhtUGFIACbxeEIU497BZkQRVEwRLic1H0NBbL0g5CQRtwrR68oRhgwRljYRVY4T3qpoYga1gWj/FEQRROYXGCwRT6DxH6oA3MIJKAKCKOoAjLMR1jQLUotAnLxQn7jSU0NEZaD4zw0TJJZylqr0ZmZB9D5xz0ASHpYRzSIRdwwAlWziEHzUZFEkdR81ht9DWngCP/R/JHZ3NGIVILXBIKcDMmta/rziAKSlMIQCZ9IkTUQEVbqiATuAZOKuNLpaOSKA39+uJMpxUKssAMzqAO/qBoIIHVCqwqafFW1oMVToETLGHHBmtg99TV5BOaeCEd5CEfBDUXaKEWiu7a5MM9ZgyHFg9nVIEVKC8YUgGpKqERMlVTs8DOoAVBfkAHfqAIRZVUS9UdyYUDUDUCWCLgtFAyQfRmaW/haK8mdGLhfsIfgJZFtcEOaiBGD83QaupGOZILLBJZPRI2mbVZp4A2Gyn7wAQLGiILpuBAsgBaokAwNhUK0g8K+IDcJk/UdjBrVkEaTK2uhApdoaNLg4oO1EBL/8rUTIMoXrVgDnwMVhhhPCDh2EJhUCJVFMxmPOh1YBV3sNgmmhblCtDAEbChHgyyHk7wYZ9RUdujht7jsSDrPlKB6HYwFt5L1XYsWS4xSRTRZFMWHW1gVFugyVDgiSrnHdWFJSCK9XYLZ3m3oriQZ/dxdGoCaO3BHNIBGBTmMIxWeWnUD2tqWZPVDpvvRnn0RkcSNmvKJEHGesBEEa+2SwijC6rACqYuE7ZRGkTNFqQhGyooW9BXa7gFbuMWfN7EC8qgS/jibvEWXrskDTCrDnyMEQDYb8kybebgOs+AbaBpcRVXTx0DDXIhHg4yH+QhG3yhxWahFdqDbii2c+nS0/9sARmwxj9UjYcEuA3SoA3OYCEalEFO1nVTa96cqANqN2Zxd/WAF6FOtCjGqEVileF+2ERBR2drYivYoUVBwQNqQHmNdgti9CGftyOZVYqVtlg9slijtlll89CsVnv+IgDNgCGaoAnIF/+0xhYsCG2RQTnYmHHuSuqQ8kunUzqAYDsfCU1102ptMpLkVV6bEgvkVQ2UJYB9bA4aZizqwA0UmYEZV097wDHswBrqASEZ9gRnIYOxydpcYXPfo3O1KYQpyBNWAxM4cDx8jA6WRbMa9AjCUWVNi8lkl3YrJwMuoAJOLwJolmdt6yfQ4eC+7HRgdUSFuCZ0ViCNWByaAQf/POAFSvMJnLk0/fCJBw16oTZ6iRWLrzeLnVVkqCdkvEQPr0Cd0AkJzocMRBH/VoEFAGF9OYWNKWhmFIco41g63GSOR6CONatr8Vi8uLZLxEunbLIvgghN5fUMkiVZ2MBhFHmBGVlP7SAVIRcW4KEegPajsCEXYOGa4mY92KM95qYW1jgYViH+9kZA9fI/6MAPMvUMnuVAYO6FX3kdZ9cDaJiGIQceKYAeedkoejj2dqKYuVBED+oL10FI4iEXhAAHXgAKnlkJYnR5aVRpcdRHXxMkk1WqfXRqoZWLw+RAuHWIpECTvGY6KqNUOiNCLowYiEGEdzAYpCEWMkEztOY5/+S3korAC1RYOzWrL6xWu8Y0SQq6KX3MD2IF3BaFXhm6gQlWT0VKESghFCTZH/7hH/wBH6wBkxsLxlKBPjT3FWqBrqQBGWphlEZhcPsnPACMIC7rDIYIQQ7kCE42pmOZpjuABGh4JGq5AnorXt4oXnrah2+WdUq0X/zho8DBEXCAB5YaMZxZZAqNep8WurG6ikeSarFvTIbPS5igCQTBCs7H/k6gg8AmAU4gEmIhGIojGqThGUSYjW0BKOU6EuraruVgWfgoj1i7LzoGvwG7oOdAsAk7VmDlD5TlD15xkR13URp5UUTKDybhEUowH/6hH/phHuThsrPqmgbv6FRBUf9bDLSlARc+7dO8A35EQUB5yJTr4BIVUQoiIrY7T6afqARsewNouSR227Z6W3d/W6GCm1aHe+E8ioKZQeNyQAWggLmfNWmXVvo+Elmn23qre9C013oisQ0YkQyaLqg6Q745SLxPIELWt2qKozjQ9+mIiVvmOW7tmr34qA22rm7zqKD9N869E+iYcpCZbU8TuQ7YYKEXOLEbucHH8hKggXL/4R3egR7KoRou+ZIHb5vi4xUueYWUo4JeyBXACZxOfBNuUMVXeGQdIhxd1wYitMmcyANofJZrGZdzXCh2m8d7vHdj9SfE7KMqLhWTcKuPdtCqmjWd9qqpWMpFktCq3Ev/9pspIQEROlHNL0NORoUyzvW8L30H13jMpWFriBLa0ZV+30QP7Bsh0sA7NUZj5iDO8wjPFbkp95TAlWVgGVrQHVcNQhAZUQEc5EEfeiQp0sEaeEEXdEFX5kM9Ag8XiCG0awHGBs9zb4gUTlwT9JKHVlsLFOKlDdPUY7mmWd2WISDHU0RDq7DHgZvWfVYzdZZhrQENnoAHwKIwuBrZ9/DJpZdpgR26p5eKY5PKQcYwOmbcBTkqEYEojxIzNKMThDJ8KK/a23rpY+Eytp0z5juowP3Nfd4N1H2hlQXQrR7PnRKAB1tWHJpgY6WBB5wN6sAMGIVWgAHC6OEeeA8f6mEb/6xhGn5B4AkeK5WjFziaV2qDw3PIEzSBsnYsldNAC5hgQVx3VCkUimjYQm3Z1XOcM337dHoZmGmd4Ey+otYuFwiRBxamu6oW5jvmyZtcR3lUej8yi40dfPkiBE2IxyqBE0ZBMkTR/uLbazoj6S8MGZa+riivE5pu29f8S/kvZMX9zl+x65UfgPNczwfbx/RUERK8Xgdc7NnGDKDJDWBNGxYWH/DhHoCWgr2hGnRh2t5mhUL6GTf66BwLnGRQ8P0AhbH88GFbVGOgVBl/9KLoCXXb46lQ9gACHbmBBAUSPGguocKFDBeeU6duXTx53ByhmcJDhIcsHKN4jJIFJEctJP+1cDmJEuWXlV9ScqHChWVKKjRhbrm5haSZnWnUuKnzR5EjTbZwdTpxAlCRIoBOSPgENdKJEYBs2ZKGFRmyYFyD2YplK9gnQGQimW2KNK1apE309GkDtw0bNXTp/qyDN6/eOn7w+vkL+C/fv4oU/Tn8xw7ixYUPl0Fjx44iRnXs5IqXb92/zf3+6ZPnLdktWrNo3cJFDGuvWrRIy5LlKnYsV6xYqTpVatQoUZosQVJEB+4ZKU5+6LARw4WLFCFCdNiAYQP0CxQoVIjwDh26c9q3c+9+bmD3gwYPIiRn7pw59OzTQ1SX8KE5iPWAoXFzRIZGjltCRsnpUX853fQSTCf/0RQTSy0ZCJNMKNV00hZmSKgFT2akwcZghWGCi1dFSMAUIJ1EUkABgEDFAg1gBYNVi11ZFcsnVkUCiB6A0FjEWjoWQQdecM0xB11n+DTHXoEBVliSgRVGWJJBJekklEnagQZkdfTRiB2gTFOPP/xw1lk+5TgzS5m04LLLM9kggwsurb0Gpyuv0WYbbrlxggkkjPgRXBpZFKdDcss15xx0GGBwQQXXRRBBd95pl912BIUn3kHnXIrppeZtOuk57cyzjz3trGNOPeCA4gYbXWRxxRUEbjFFFFPASmusU9SEoEsrnbRSGjj9CixOI5VkxhnFsgEkX4ZkUlQtgghg4omx/xyV1IgyWvWiV1Z9BdUqtnRSBBBNlJWjjiMgNUITfdRRRrFnpNHTXXv4YYgi9S6iCCR6MqLnIo8sAnCSASs5rx9MNgkwvgk74sgjjjDC7yN2wKLOPJv5s9k/68hTTZmv3HJLL9FEgwtsrNECZ8q03UbKKHWOkicjk/XRBRRHHKecC4Q+h6iii0ZQwTuROkq0dwUZtF07mYZXHqfmuWPPPu24M0+pzTjihhppaNHqFgdOATaCuLpE9q68fuFrsGpDAcWwWrz7Llx00GEII53EUgsusUgAwAlQxfgJjSKC9dW2YdmySiyKJ654J00MUQS5OqY1AguCVALJYVI6kjAllP9Y4rnnkGA+OiShU5JwwoUFbLCUrkP5sMMQQyKxI8zkgzHG//SjTz3wTFPmLbsMQ000t7xCSy3Kt4ayLCjHpooqpZRyWymixHxlHVIc8YMNOTPHc6I/+1xBO++0gz76RKffTnfta8f+0vLPj6k99q+zDnzpoHJfHW10UYYopKElBcIVhMiGQJeobYFsG0kXunCGNqRBbnTww+zk1ItskGgE3ZrWiT6RCFOYgnBWMcXharG4WqSCE6XwwxGGILkd5agIncgNJDCBQ9BZYoc87KEOfVMJTFTidERMHb5eh8QkNewRs3tElVAhDtztrh+dwQdErDGLXPBiGd04xixGo7z/MDLvTSs7xSlYkYpScEJPdThDG6HQvRgwxzmHuoD4xqeoCKBPaHzcIx/f4Q72CXKQhETf0tjHD3vcwx7mGEc8qhEZO9RhDmYgyRoWVJNbge1WBtRVghS4BXilLW2hTFslH3iGVEaQgn+B2CJI0YpbdAMZRRiB4KByok4IIhKfAEssVmGKXgTjGcFoE1eewaZbhGILPrCCUsoVonIlBZik4EQoPMGJTWhzm9r0IQ9HV4khErGIqhsYElWnCH89Ql+0q5IdklEPfUyxH+5IJP6qAQxeMKMbxiiNaUAWRjE+r063GcUa/TCHLLQBC0dAjs464JznbKADFKWodHiGAXdo/9R+9tjoO/YB0j+KVGjzKCnVoDYPjtqjpPPQKPo2aj9/+OMd8xhHOOAxC8jYAUgVMkMYvoCrsG3SgAZiyU8dFJNSihJeNxHlGtaQBlUuNS4VpBfEHrGJVpBiTaZowlKYMpYbRSJxUBlharKB1rRKA63C8AUuRMEEIwjOXEghwydMoQpRiEI3oehrKLTpCW5uwptC9KbnQBe6zg3siIst5yPWSbtHXAEyoOBGPea5Dyqejx/b4AUvqKELkH0RZKQtLWtWlopUmMKgkPBDF5wAhSDYYI4dwAAJOCCd3OaWA7wlQXMWCVyVKhKk+xjpR4t7j+QKN7nKFS7UVCpTe6xjHP/p0IZFIjMHNqQyDT8NKicPqBKjhiFBBFyJUpe61Kc+FV5xkVsb5mZViNmBEqNwBDJ2IQtNSNNvievEKiIhiFWwKBvd6IY34AEOb3ijwNQYhi92cYtRJOFGSlGLBEaA4RF0IhWjIEXLduPXa3pixJsg8TZ32Btv/jCxAEOdEdN5RBjD+LH6eqwQruAGOwCjS/2Q2u7OoVl/bAMazMhFLkpT2iTfgjVzYsUqOMwJRswBCjx4KAbyGAHrMGrLjKoABTDwZQtwgLjETS49zszckP5xH4vkh5sXyVHmwlmRwrUHPeyBMemOAxy8mKwb3DCHqKZBDD89EFFToqBEny1BYUj/r3ofvQY2sCHSkgYSfOcA33q5EhKNUEQrstELVZBBLby0BVkQEYtoFNgb4LjGNRTM6gVHYxi76IU0cEEEZ+43wxn2LytKYadSeJgUehXFiEc8CsF2U8XjXMQ4XYxOGScsso/NQRa2oCVt5GOeVOx2P/xRD27wAqBtwsVpyn2a5cEmFa4wRSXSwIMWXMABeXzAAxiAbwjoW99b9nJ1/o2BbmfsH17Kh8HdjHAyf/seCGeu/Rj+5uQmUpHMpQc/8kyP6oLiPmxI1bUfGIZCl60lKxmvrghI3i+EAarwgvRTkbWH7MqlDZiGL3zpNRl+jY4Of8iGNF4hCDJQ+BOrIDoi/3BBYG9oQ+nX0MbSvcGNblDDGdO4RoFpcQOm1JLXFz6Xhldhm9vgZtgt06tudBNYwVpisMx+NjmN6DmA/Yvaj8iBE6LgBkfwIp6ckak/uu2PfMQDGF/MW7kPX27lySIVnqCDE16wAQg4YPKM0ve9871vfmf5318+FJgELlOD5+MeoUJ4w+n8cDhDXPX3OLPrz4xnggu+Ga3ywx5SNWkxjCHkmBQbhFYyNl4dUOVhwEnLXU5pSbOB5jXn09yqWjdDQEITiFADLZ6hCjmI6BOdgIokcCENA2sDG9XABvmtTuBumB8c8Gg/OHzhhCWQYesZ7jqGM5GKYE+P2MUu9rEBq/9s3RQ6O3RYBNhszgZtCKhO60QJj+UweoIJoAAK1hBP/qAP+mBwF2iB+VAP3lAMviAMxCCCwSAMvWCCxVQLrjAKfhAEL1Bbd4RlXMYoD9BlXWYdABcdG3APn0dFsid6pMdcpzdnqLd6KoUPR4iE+HAPMvUZ8AALV+AEtvdnubd7R2VohmYgV6gSRRVyIedULzdpyad8P4JpR/IX9ZIv/GIKmMAInpCCmgAVvVQUGbR0TocN01B+1tB02tAN4AAO8lAP8pAOfigNjkAE4zIV9ZdhJ7Bh+VcKprB/w7YbJEaJAbhsbud2nZOA/tIw+uI5jzUZayeBsBAP9WCKp4iK8iD/D/BADb+wC8gwglzRC7jACisoBC3QAXb0M1yWeb3YZT7DeYeSW/NwZ5kFevmADwfHD0H4ZnE2ZxK3jHK2SK9HD0sYePGADXYgBEKwB7eXKmuge2YTfFiYhTHxSSX3Bun4BmnwaMiSXUACj/DYjYBhCIZAL/XYYpiwCWYUC3KwBI0ATIwTFsRADeIADthgDdpQDcxwDeanDdzAaulQiqY4iN2QDaLQBbo2FYl4LidAA76GG6agf7mBdgCYdpZogJhITiwmd5BlOqHDMJCwCRIICr/QDMyQDPlkZEc2C7CACj8ZCrfQFcUkC5tgBjnwAh4gPvtmbw/Qi5rHZRMANIoS/4w5KB3VAB/2QEWZtRnIiDsNJ43A1VzK5XAOZ2dnhg93JlP1EA+/cAVC0ANAonxr0AViII7g9SBUkGglR3xvEAd/GQfqVWndSJhmSI9oeC8tZgmeQD2sgAueQAEyMAojZBXC9AzaIA7hUA3VcA3KoAzU4HTfIA7lUA7pkA71oA7l8A3XMA3S4ApjoHVq0ZEnAAS95AqnMArANj2n4GFoF1j/p3bcpGKIpZIs6Wzs9JKfs0SXEAoS6AhUAhnuhAad6AaHYQehoDyqAAm36AHduQG6GAEOwAARsG+VJ4O/WB1UWZVWuQGogA3lMA5a2YP8oIxu5iVjKZasJzR1Zj/E6P96eNY7p/KWOIB7kxYGYkBoVlhA5XgSR9WFIaeOfokHeLAHyjcHBXMk9XgwGlpOCLh2uXkKr1ALtmAcq1ULwdALwnAM1TCa36ANnflZCjaapFkO4cANCUZ+yyAMwlALmVAWozY5RZAKs4GbuTk9pRAKxnaSwhmcg1WAPlSccWdE7OSSkNAwoHAJNHkJdtAqaFAGj9EuatAGXgAXUKAEToADSmlHEfAA37ko9pZ5WwYBXEY+XkY+umhHF3Aoe9oDsMAN6WAO8vkPboYPCdeMcZZ6cQZSrEdn1Aig9TANaHAFPdACuLcGb3Cga8B7KIdo4gWhEQqYcUChezAI83iYZwj/YwDDoS2GOk+6CaNwCtFzJrVgCZxwCrjwDM8QDdbgDfFwkE5XDdbAfqZZo+HgoghJDdCgDL/wYLXgCXpAI5MDBEVgCrTBm7pRbJugpEu6bEy6CUQEpYeFiazqOY3ATpdwCTvkMOiKrq/6B1cQBEdwBEJwpllgBlKwBDeQAiJwAeQ5eQgAsAjgM+SJbwwAAXB6nnXqb3aapxWQp3uKAdvIC99QMT04qGkWKhzFUvxpP2TGcEN4lmqpD/EwCwPaAmigBpL2BmLwVJvaqcQXBhHql4A5oTVLqoMwCIGhofaSqkakiZawCDy0TbB6CnJyC8JwC6AAC8SQVt0AD9h4o+03/4ikKQ7fsA0vWjzR8AzGMAy88GC3kF+SQAZAwALocgJLQQamUBt2sht6VWImJpw+dGKnE7RRWpyTMAmQwK6YcAmPZQd9ewlrxKU5UAM2YAM1UAM9gAMtoJT3RgAMgAAEILmTuwCVa7kKsABxyigTwLl1ynmdV0cPy6cicAXQkA7qoDsXS3ogRTUpxVKuu7EltWbK9br0MA/sQA+94w2OMKk10AJ0IWngeAaaelQlF7MPqo40W7M2e7M4e4b1iIY+S65FtEP6CFh4pQqvMAu68AzDkAvZkGDtNxEHJg7pIA5Vuw3cMH7YUDzPcAzE0FbCwAu7EFqhhgmIYAVLQbYswP8UIaQKriAKuTFievVXJ7ZDAng6a+ekn9OqdtuACtg5eKu36Mq3lnAJjvAHj+AbkKAGV+C7LcC4SukAkUsAAmDCBHAAByC5JiwAKezCB2AABvCUEcC5E6Cwn7unFEAdewodNSAEToAK8ACI+pC6GeN3R3zEF6jEGONtA/dtFniB+aCKyaAYlJQFYhiGm4qODpqOfzmzfzmhojqq3Yiz9YizZWwIh6DGapwwDmg6j8DAplO9nBBYHRZLujAMVueH4quK8RAP6UCaCcZ011A8yzAMJtgLurALvsDIoSULitAHRAAESNAEgtAJmZAJIsSY0/Oh2soJmoAJnlCrOeSklsD/RGuXktPLYgz4xo+1CIzwyq9cpRbMriHWV9o0PZzQB1hAZSDsAbl1R+R5sHAasAB7AAA7p2yKsAqrnhNAARMAZhRgAWCWARSQAdf8AjXgBGgwC6UoRQPHhBqoxOMsevkgzlBMzhx4iquICs/JBmnABMo3hmOwxcb7qRIaqssrqoR5xv1cxmvMxm3sxvqywdW7CZyQTbnZCqaRJknHauBQDuULDuqrYNqQDdYwDdHgDMtgDL6gCzuZC7qgyLV2C5TgWl7gFp6gCZqAObOjjxoMCXiCCZpwQ4yQJwStj76BQ8kppQcIMMgZWbMD1OzEQ+gqCn4FCn21V5zgB0rggv1a/wGSN3mTV7BNeXmViwALwAANsAAHcJ7kycwVUMNj7cyfWx0t4ATbiAY7Fk/e1g/8gIEZWM6ih4rrHIiqiNd+3H4Ipg3G8JxukAZdEM+SRheitMUPCqE0K8b73I373M+G4M9pDNCp84k0BgmEpU2hgAmiQAqqIAvCIwzPQA3ZwIdPN356aNHWQA3U8AzKwLVtRb87KdKKLAy4sAl+0AeIgAh9EES9jVCK8Ah1ENz8skOtBYF6QjvqekOWAMsJ2LM+q3PIKRQQI9QOyK7tmqQFjENz8HjfKcxTXbCQi28LUMwI4JSXR4PCvLlS+Yvk88xkPdZmDQWKgKZXYAfQoIqBqP8Op2uaxDrR6ouQm0lkOQkMO9mTPvmTzskw0Dmdf+BaSwAF8KJK78JdiO2XmBqzyhvGYzyq/ozG9QjQh0DZDUhj33TZlmC9oUDHsLrQaJIm1OBqengN2XAN1qDa0cDRDsbIjLyj9DvbEAZQovAXiFAIdMAI4YQ5fcEIbFAYSqAEemIwbGAwzD0ZtFMY1A0JHbo60kvdWP4bOVfdE3zdbGdNmMAGQYCL/dqvkwcBdapvDHBvABve6a3eX93ewAjf8f25uowDiHsFegcLCK7gkSGp26i4OIDoi9sCIiACiA7Cj94CiPvoIhDpQmAHP+EFVVAFR6BKaLBdaYDhXfgGeJD/vMq7B8x76mTcvNALvSE+pciJ4j1kvZug4nQMbCIKMr1ADNGw2qs9MlsrDB8d0orM4zvaC7uA7CLtMbfZWmkwBnQwGXkCL3WQBk5QIUwuZZbgBySRBoDx5ULxGxbkbKkDJeT+yl3OCA3DMEsUOo9w3ZeQQwgNCWdQAxsQAR1QAi8QAzbwA0zABGMgB3wgBwEv8HLgBUugA8yxAV4WAQ3glMl8HTG43jVcHXlO8Z8rBUFA6SLgCDf26N0J8owO8iNP8h6QASVP8hrRnSKgBH5gBm0gBUSwBFJgLGbg6RSe2DLbxaaO6h6OxofQ6q4+bbCOCdWLQ9uk2ZjACbmZva/R/xq3INKlVSZTP1pQP9K1BuQg8wqtABuq4AmV4AdtYEEyQ0laQGWI/sPbbgZSRhJuxBeM4AaG8Qcy0zqoI2Ot8zroLhTr/liVfd04FMqYUAc84AEd8AJBIAd0UAh80AVH4AMyoAORrwM+8APy6gV00AjhhAhyMAY+4AIcQAFbRgHlKYPwHfo0nOeiXx0NtQEtUAeQ0J0X4AEqj/JqKvt5uqYRgPtruvv9yihQAFszvwRH4AQ1vxMXUuEXnvNfLMbdOMbN+9iDwOqSPdlDT9RFn0OzrtIrDqJ55WE/iQqtIP5b3wqvYP4f808uvgvmpr1l0gqeXT3YBDCb8Ahm4ARZoP8EOcADWsADNRAEPAAQQY4wOqPlTJo6fhS6UfSHoSI/ihRRWiTR4kWLixht5CjR0UdHjyhRevTo0klLmCxB8gOlRgwiVZbo0JFiAwQGORk00NngAYQIEShsIOHCRxU5jSQhkmNEBgkKGCoADVq1woQJQbFWxdq1alUKFF6IeMGJ04YLNzu4aCHCrYgaLeS2ddvWgwgPeS/s5cv3KwQHaYM4IUJEBxMnUMwsXnzmTJc3b8JMDvMmzuXLeOLg4bzH855Bn0WDHlTa0GlDh1SrXtS6NSTYsFOmVIkJ0ybclDRx8jSq1KlToUSFCkXqlCrkrZQvbzVr1i3o0GnRuvWK1iv/7K5cIU/Fm6KjM2XORMnBQ0mNGkLQO8FyREsWLQYV+qmjqM4fSIz8MJpI0XVFjFpjJLaNFAnpI5FGegSSS0qyxBL9oJBCiiVuCCECBhBA4AANDyCAAAYWQGABEUfMaYEQF2igAhJkSEIORCpBpAobQrjgq6Cu+moCoLrKCkehwtqiDlc4qUGEDTboIIQgoMhBCCeuEGJKIXqwMggcctASBxzQe2EuMEWY6wX0lOjiTDTN2IKxNNI4c4wvvqgsssg0w2wzzvAQrTQ+++TTkEFSW+2/1iiJDZIHU4LNtts28aQUUn5DThVWKlVFO1dkwW7TV2ShDjpccInuFudomQU7/089ZeWUUTZZxA1Er7hCMSV4gOIIKKBworwscjAjiCDUUIM/Ndx4iD9G/CO0tYxe42gjkBYU6UFIShHlWk5YoqOKH1LAgAIIHhD3AZ5CVOBcBUgsUUN1283pAQxC0MGLSiphpAodQsAAA7R0fGCnnxpoICgIevwxSApkkaWUOXhowQYlN2hSCCmvcOJijC+20koeeuBBS5C5RC8HLruswTwz0DxzizXVPEMMMcaAs7LLIrszT5xH89NP1AQd1LVGGjn00Acx0QQ3R4srZenjWKGUFVec1u6VVjaVxblabgl1a1xQPVXhV2qpBbhTNlGEITf+qAMKHoJoAYoXbAhCi/8WPMjSjBrMqG/Y+/64CJKRAqeoP/8UNHQj2EpSPMGVOCFlFE4wYSSLGvSdquBxyzUXXRI1ZHddEnd6F6h4dWij3j6ksKGDByIIN/OtXC84gtgRJsWSRdYw44ga2NoACi2CUMKMXLHIAotcM1ZeCeaVuJh5J44QSPojpIDPjDbTYHn7M8GQeYzJLItDfPFx1kxPnXcG9LRAV/u5NaEPrbcSRo/GzZNNRBll/9/ITmXVU0BNOaqomnNKFZ1QSYcWCmOgqGKRit8sgg1nuAInFKGEXPHABh6owQZ4wIMaaGlKULCPHyAhkZKccECJskTgFiE4GEJicSlU3Ehgo79stYH/ByX41lWyQi4U6aRd6ErXAoh4LhOl6F3jqkAIYrCERnBCElVIQQUYULCcFIwqtNPiFquyCM0M4g1HOIIO3FIJJ9jKDNdbTHy0UIb4ZEGOc3wPFpCnq8QkhozVk4IWtpC97a3pTTITQ5zmZDPM5CmRn8nTzgLFs0P4bFCN4MjQIFEvlTwIaUjjzShOwTRJHSc5r5jFdKYDKq6JaoFXk8UtagE1UZDEDWo4gxooVwMbiIAHYroAClqAAx4IYXj7UQQjbpM4TSwqUTBkJkkMNUNplYQksDELI5TQgg1UQCg+DFdOBFYudRFxiOhKYhJbFy50VqADNqjCUqQQgwuIa3a1/+uiFyOgmknk4QtcOEJb9pMDJwihDGXAgvXmKMcJ5cqgWchVQxu6xltBIQtn0gJjWLaYM3FhDGgqpJzoJL473YyROXPkn07jvtVQ8lkrhU3gWKgJmPamN77xzScl1QqolbKUo9Ia16QTNlk4LRSQYIMbzpADKJzhCA7rQAQC0xaJKSEIDK1DsZRQh1Co5BEq0YQnLIG0B7m0hTE8yUkSJ8MFHaoN+bpABbSpTdeJiwHjkmuKSHREvAYRATqZqzzHlZMmSqEQjajCCzKgza1A4JuLnV1QgganQUwhBy1QBCcqdoUy0NIxjNmsHBcDny688XjPS0yutCCFLkyoC4zhrP/KziSGNRjyo+ObbSLNt4fOlNQ0qjnpJIv5LNhUslCU2IQmbLMbs+yPEzDtqig44cmmsfKUCdTaLnCxC+x2TRa4WJUqIHGFHkChB8wTQQQ84AANfekCHiDT24SQA0WwxDacxARvNhlWSrAwvyws6yVYKMPgKkIKLkgSBjDUgLAE5V9LrGvoGIBXceqVr+MiwF7/pSEGVMAFUnhsjcjVAKAodrEgpoonGjEJNjDUDJ4IRRaUIEw2HIENbyxDY4R1Y2O54T73UcQjvvpc4FRKERN0rco2+to0rCG2HqUTbZucmdsOIrc8+xNvJbmIRvx2QIdCnOBODNNJFAIRMbVXJSH/8dxS/E87V6NF1hBo3etidzpBBY4buCTHM4gAARcIwYUY8IIOrFeXODDDi/2ACUhg4hH5e5wneIM/3LBQ0vztL0qolZ8zXDME2XTdAgwQV7k6wAF05euJjMg5I6rL1HzVEBI5lBMEtK4CKmhDtpZQAgtoJQIjJnFQYHMQRYhibH/4w0hwUwroErBTO63uLnrRC2EQgxjIQMYznhENaWRbGsjARJtmjCbHvOlMBzkD9lj2hTWEYQ1vYMMb1s2GOKz7DebTU2g80ydA4bu3KNUIcAl0KEpUYhKNqEQhVCAAAVDACH0QWpkxUQk0p2JSpCAgKorzCq31ArvY7cUtrqOK/1D8QQhRcJv0OuCAC1XgAvyKQKBrINW27WcjKSHOtUbhCZzfLxS4qc0mN/GgSpv10n4IQp83IJUHnNp1AtPJqBdc6hMVMXTpUoAQPee5BRyAQxgeXcEuUIMxaIIQQ+AAjz7MWKr84RGcaMUuqA3taEtb2tRGxrTpXve7553az0DGMpZBDWlkAxdtyEJAtYCmNGCv3JtlU+LbtIYks2ENkmfDHNhQ+c7g9t66NWm+JXkILAdN9EEbOOkFXgmce4IEAQBA6wNAgA0wHOf7S8UpIFgJSNTBDqBwBBp8jwZQtOIWvfCFL4QRDGLgQhbOVcQZ1taCDmCAAREIAQQupCG01P/gAjhoQQ2CMAcz+EGTnNj5JohT/k0wSv22mU3Rgk4KHBqi6H2O/r4oAFcRf9MBDdg/1B2waqhTogAcwHLhCQfgABkohEqggxhIkg2ggH8ZmJ+AgAWAtrzjO72ju7mjNmk7hmNAhg/8wAtcBmcAPGkohdQKqC3ggjgJpD9irexZjOy5PBqsPMubA3obDdJQH89DKdAbvdErPYKbH00whSUIANYDACQUgBSoAiKYhFIwhVKQKU/oAz9QAzvoPVm5Ajv4PUfQmmDohVCpBVcYhdw7g15JgSWpPgx4AFFzgA1wgLbogRdIKjOYA0y4uU0gP/MDBT8kDrNQv0BcP9wIulD/QDZFOAIXCIElqb9vqYqz0783zIk3nMSm+z8hCiK+cjCoE5HO2SsWOQKCq4IQqIANuCJyIZcrqja9C0FqC0EPjMVYJAZZjMW887sSlAZcoIPUeoIgiJM40Z7tSTLd8bY2wZ40qEEatDzMu63N47wq4zcgnMZJIEJPqAQIQEIkVMIVKAx60YRJyEPbgIQz8AM3cATw4hIuRIMWCIwcUINQUIU2yxRXKIVNcIMeyIEaiIAX8AAEUBL0QoDA4CCHyQETypZNIIVGEY6aOz+HDAWziBzbMItNIg7c0B9IUIJF1JcOOLpvoQBIHLH8479KtERKFDVTC6K7UgCtW0mte8kD/yiilgyMGBgDGfkB1sGQBQgYCKA7D1wGa6tFoRzKWvS7u/O7azvBMeACJniCHwgfdXu8xyvGZGSD7PE2ZWRGNsjBz4BG0/g81ZhGIJyEaqyXUSAChNNGAJCAHYCBG/iBLlgE2kgJAymqLeCSX/K9HghIgbyAFtiDUYgaoeIES/ADJ+i+C4AAJAkMEeiAI+EB7usByYmvezQ/USAFUiAO+LuW4Tg/zoTIiESa89uESygFSHCJFmBEDOhI+7u/qtCib4LNkjTJk7QrdemQl0QXmDwAA4DJczmADMmwHwiaJbgQEOOJoPA7v1MGY1CGZVAG6IzOYzAGYyDKojTKarM2a/+Lhl7wAznoAiYgo0NSMiWbyvK8vKs0RmW8PDyxEz3JPPQJDZ5ZHx88BERABLEkPbKEuBBAuLQcABgwASIwAiIohEXYhPwYEEfAwieQi7sQAjQQAgcggAVgAni6IgioABTYglJYlVUJhSvAix5ogfW6AEDrvhbggTNQhDKABLWDBFG4SMyc0cfhTBu10YccTZ6zBC2wgUXsAAvQAA7ggH3pIbeSHcAQtS6aTZS8RFMbEdzcTSk1gN7kzSp9SQ1pgBKogkagAxcgGAcomGd4Tlx8zuiEzuqczjSdRaH0OxHUzu1UhccYAyPwgSOgDHUjz/IkxmRMPGSsyqqkwSS7k/L/gc9628Gv/MrVOI37zM8T289GYAACQLgBCAANoIEhGIIbSALSo5wqEQGKyQsP2L4rQIMLmFQZ+AEOOAIfyAAI+BAE+IA9WJpLcYO70EfEPJKTyYGrIraz+arLZLRIsan9udHhMNbLHM3hwAQt4AG2YEQLsAAS4ACPlIojXVIHIJiCecMkxcTaDJGr2xAp1ToqNYAPeUkqfckPqTCtwwAduE8iwIBtdQCgtDblXIbmtE59LUo4fQZh+IPHYEo7xVNiJE/zhLyC1VPylDwlC6n2HClE1S1BOQ0xw09qHLhq7AMEOBcDGIACwNQhmAEjgJGCOwIsyAscEIJRvQAHEAHf/2sBAQCRJBCABjAALZWBGJjQvnyBOgCOW+K+upECtlGCLIAINbCEkzg/zASOpXmcUaBRGr1Mp8XRUACFPbQENtDHFOgzErCACQiBaeUAC7DWI9VWqqgnLRI1/iu1TxTXcl1XKl1XuZ3bD/HPDxkA4JQBQpiEI+gAwIiAftVOZbDODpxFWmzTetVOWagxOpCCI/iBH4iMydBTyUtYhVVYhmXYNcAZPMGt95yyndmDfNutQygE07XYscTYSvCCEPCJBigACxgCGigCIzACPZCERpCDPtAVKRGBN7yAHhACHJhUAtABAxAAGbCAAyCRCKCJC/AQUWsBJ9CC6LGBI0EB9P+Yg4SYoD9A2swsDrIhG1BaGvIlX5tyWk/CTOeyIBCKgUXs2mjlWrHFgLZqK7cqW7NF24JZ2yeN0rilWwBGOLkNAEpNVwSogBLogkboAhSAAAQYBggehuKD4OKrYAu+YGHI4AwuPmGAYGtTBmeoTmQQhkc4AyxIgzZIgzEQAzoJn8udvD19Ycplz/ZEnzjArTD4AjwojYiFpNWoWEd9VE2oAg0glwQwABPAVCOYARqogj7gAzmwl5dFLwJwAByQlQtAwhSQAQRAAR+IgBjwBCLggAiQAzkATq1jAAfQMBnQAdTKlSywhPoIBUu4FkgxDlXIzFPATGQThT1u2qiNlBn/HQ7kAI5RUIQgwKUY2Fr5Bdv5tVb7xV/9nVfavM1xXdcBGAACyGRO3uRO/pACyOQCuFICOIALYIJGKAScnMUIbuVh0GBh8IVfqOAOlmBXhmBnyGXn/EBaUIPF0KyDmBMXvtzLk2FipmHb8lzJCAP06WF94637jGZHrUY58IEQiNYJ8IEhMAIagIEdSAKGQ4QBYYMeOFUkvIBS9QAChgAfWACayAAfIIIUKIEYIAFEuLC9Ck5TTAEXsIE2OKEeG4V4zC9R6B/kMI49tqlPYlpA7h9IadpWQI5SsAQzyIF+XmRGBltHJlL6vV+4kp38xVb+7V90pVtOzmQBOGmVDmVR/05XD+GQCjiCgTsC57xXv6NOnJ7OYxiGYigGnuZpYwCGni4GY0gGo4YGaGgGo37lS1AMx2iTYHY3Y9bTFp4T2gqfmqktRZqMG/bcZ+RBijXd023UIKxG0/UCHXCBEhjZJBiCJGgCI6gCPigE/oiC80KACsOBHlBnhCsEDkAAEkCB73wnGdgAOSiBrMu6UvYJFfkJDIiBLNiPxzkFUfCxncNjGhXf8LWph2Zo8o1oVRCFOQgCG0iBGMDojJZfj+QLjwYS/d0/b+0ccv1fT6ZUTvbPlFbpky6AUU7XCtOQC/iBMUNqpM5l43aG5VQGo15u5mYG5mZu4oaGZDAGXLiCLP9IAzRMA6NKg8mdavK8aquW3EP6KMvgjM2QjK72jPgsKfYRa7GO5tQoa9NFvUpALTrQ3TFohPukAzpQBPB6QwJwWTRwgJiNWRRAgeWFgFQtAQQkAq1j1wfYkOkLkdfppTrAhN9IlIJeaFXYbA//cA9XjlOwBCz4AR+FARhwgRRIbUdmzSLNgL6w378IMcAY6RIhVwIw17tFad1WaU/22JZ26ZdegDXWgUKIbiRP8iSfBiavhmqwBmzABm3YBm4AB3D4BnDQhmxoBSfogiO7vDNoA6gkbzJ3Msr4qPBZ5tkyb9r6XCnbE93ig7muWPgWlLF8FFcgQ0WohFXoKk1oBEP/2AQ7UI+9cAAP2L0rmFABSMIAULgUaIADeMAxaAAQkdQKeAEIOAB6HjUD+5cbEQFCux9QEiVSFyVVQAVUB45C/nBKEQU3eFz3vYEUX/E+q3Ww7chqzQAYZ22Vc+39je2SznG57XHdnttQ7u10VYBzxTAMcAFrgPIol3JtmHZt4AZu8AZvAIdy2PZ0SAd4iId4kAd5qAdyL/dyjwd4uAY06PLvmaAzkIM0J3N5R/N4r2qtxgPJmLc80byu7BNElXP3FmvUCMug6apLoYVeIIZgCAZkcIVUgKBRyGM7qIG8cAAh8EMPqDACSEIAWPQFeIoDqAIOqLAOUGPo27MjIAEH/8iACDhFp8oQDOmAH1iE/TkOqunwVZ8UnS91no9oEn9cFZd11LZ1jcb1JNH1vnArv3jN/dWcrMPxUn7bHz/pHZ/bcr36mFR2DtE6BMhQcP/6rxd3sZcHcB/7sSf3fMgHfVh7ts8HdQCHXOiBKGCCKhgDyEuZLsjTdauZQzpzeq93ebctq973Zu5K9d48gA/4QuiZQ/gyT2KFWdiFZ9A2aegFWejwU3gFVLCDuskLR/DDckaAAidgRh+AFvkQp4rVDADuDCAAxcxQEMMQlsQJCNgAHOhZ7RigASIg0NZ539/5VgiFliijoEdx92ULWrf1juwAo0eLGO8LsyVJEoFJc/+1UqnX8avPfu3/TXRx6b3iCbMn+7IP/7AXe3qgB31Qe7Zn+3qQB25whB74gTGoezHogjQQAyZQtyfLd/Eeb78nVIB4I1BgnIJx8OAhyAbPnoZ45uyhE5GPHz5zHu7xM6iin0J+6HRk5LGQoUOTNG06xUoWLmLRpMEkFgyXK1WnSIVC00OEBxygQKFC5eiJBwICAgg4GmCp0gMRCDjw4IBAhgsEEERwAAFCBQMNDBxYIPaAgwsebECxxEoV21Zu3bJVBbdt3LmnGJWB8gOGixQ3bsCAEcPFi74pQiAO0WEx4w2OL0CGXOFChQoRImzd2sABAwYKFBw4YACs6NGmT4P/RW06NNjPrhUMKHAAwYLODPTpq1dPHm95un8D5x3Pd718uOnVUyeunDjd8uI5Q/PkyZjqXbqcSZMmzBsx3sF4vwPHuxg45seTJ48eDHvvbwyymSN/DZv48u/XmVOHzv46fv4D6IciAQpoyICKGLIIJZZ4MsoprdCyCzIvSfOMMLvcwkopo4TyCBo41CCCHaiAAgssqMACihAeICDAAEkpBQAASl0wlQMtQICAAw5UAAEHDVigQAMTTAABCUNG0EADFWwABSaruBKlLLPM8sorbr3CCiuutBKXl5z0gYUURPgAGGCCuZBmCyWwSQIHHDi2mGNzRiZZZZZhppltDNBG/xtrq6kW6GmhERraawqIxYCSEOSzWzzxwBNppOlQmg443miDjTabahNPPv74g9w200DDDDbWVLMMKmhEwUR1Y3ihXX1hkMdee7aC5x166ZX3Xa5wFCTQGsMSa999+tWRbB199OHff84S+J8iByqi4CajlKKKK7X0MmE00RDTCy63yHKKJ5tcgoYQPQiByiyw5GIiLI7Y8WGNBOB71IwBABAAAvheIMJVWUGQQQQURCBkAykEhlkDFDQQQQUOdGBDI67IknGVrVipypZvyRVXKZC0ISaZPsDwF2CDpamCCm1ywFhjc2JQMwUU3FlZnpsx8MADDIgl1qGuEapaoYYO/f9Z0Aso2cBW1oCjDTTTROOMMcssY0wxWwPDSy68gA1MMtx86k+j1STDTDLTOOOMLvUq4ep1XWi3Rhi5ioGr3urtqp6vugb7BrFrpEGffMYiq2x+igOYLIEDClgtg9iqwlIvxBCDTC+74IJLLaycS0m9T6AxSy6n5zILKnbUK4QQOHhgVVL4vkjAUjpOBYEDESBwge4VNMAABD7owMEEDKRQwpIPdBADBih0gckorNBy5VtYcjyXKpv04YXJPpRZ5sosx/DCyyWQsFj6Ms+5AQY345zzZRAo6fPPtgWtdNAI8H80///TJmidWZqimraVCBRjGtn4xS98YQxf+EIYEPT/xTAkqAte+OIXwxhbPfyxj0ZhoxnLQAY1vqWKK2QBCkdIwxmwcwYxfOELeOOVrs4DB/Gkpz00FMNABEcfNmzBcPUxluL8k7giOg5AioBWghaEiVCoRBa3wAXnOlcLWqhiFJtYBOvQcAld5AJFpktRvdBwhR6AqEb/OsAADMCn3kUgAFdxQO/KUkcGvCAGJMCMBXyQAgf4bAngKwGTPGCGUpDCStjjmCI9doolesELYyLCEG4Avr/YIAaD0aQKUODJ9JFgfXLaAJzcd7PK2Gl+EYOA/XymJM8gSoBAWxoB97QnpjXNaZmBQASGcYxsUGMYFBTGMIghQWFIcBe66EUv/4SBjGWAQx7+6Ac+1IENZxDDF8iYiSXMYIYUniGc4YRhDG1FQxueh4Z4Mw95uCOsIRZuiPWZAxGRqCz50CGf0XocIxTxCExsQhQPegUtanFFWrjiFKK4RBlDUQxgOAIHV0ARKi7hCDPiAI04aEENUMAA0jDAAR+4QL/kiJUd0bF3MVhMBh5wg774zgVEsGQIHlCBDihBDXYASpUUaaUraWkTbFBDC6VwhCP8QAc/SKoOdGCDp8pgMCk4TGIQw743ue99lKnKnfJ0mTyx0pW2yWXwOtO0sTbtAQ1o5QN2+VWJVQAZwuhFNpCxTAzd4ha0yBgrThEKUWCrFbCwhjTf4f8PdfACFHa4AhsKp4UUBsEJ4nxhrXS4Hl6xM2817FutevhDNhRriPRUA2mP5bj83CefIAnQagFkIDb4p1qQACgpTmFbLZ1iE6C4qBd5UQw79KAFLRCCHS5xiT/8wYxorIEa6vACgzFNRwewHb9ahFKo5MCTKIBACIgQAht0AANS8IEJNKBWCLTADFe4AutQ8dNXVEkWWVLFIs5AVClAQYU/8AER9ttUpz6VZVOtqlUZg1XHYKAqGagKZXTW1bduxWe73GUrJ+zWt0rsMjmbTCEYMQdGIAMSrssBD5oqAzR1AAUv0EEW7AANae7jsNOYBi/UdYQnMOEIUggCD7SjnS7/iKE6fGNnrtpzw/Sgc4eeHVxo2dAGJ7chylJWLR2OpdqPrHYOrZUW3Z7chthaYhMNypZCjcs6R3wtok+IwgtwgAMhKCi5ZiTuFVqw4AVP5aOmqUBo8EUACLiAAy/4AASGEBgXUCAFZALBZ4T3giP0wBGgYC8oWlElKlWJFaJggxnS0AX86vcHROjvJW/w1EwKeKrJE2UH3nTgO9/ZTnXSGVh5ieFb4/rWG84ZZKgagjrgQgkiaEEISACCY5sgBRyIgQ+kAAlQTCMd/OiHP9jxDW9kYxiKwK8UcnyEHPjY00C+A5LHA56+3SEP4rFhDfOmwzDAOwyDA22TpWzvKKsW/59U3jeVk5gdWc1BQAsS87VsG4pQuMEOjuCFLi7RgycM4glQiIKb2UAJRbgBDV4UAk88IIIc+AEHF1hjAxbwGX4hZQAT4IACSjAEEDhvAkkwwg0iIIADMOACPahBD0jUAzQUF75UshIrLKEFLLTh01IwqqiXMOr9iu/UmkyTqlEQyvW5GquwhjVkGNzgXYM97GK/E2W6vuALbMAEO3DBDXAwimCoIQj7HcIMiIAEMumgCojghCqsEQ998KPa6SgHNrohjQHNYQ1teIIWnvzjLoyhsuX+TrnHk9lz9lBY85anfOx9LCtvGUBUVuKA+mAIQxSiEY2ohCIgEdBSnEIVr/9QqBlLNws7iEAHR+ACFBhRgxY09QdCuMJPeuCB44sIJ6Awvp+ZgvJ+JcUCKwCBCRoAgiEYwQcQOEDEcLAFL6po+MUlhRTJRYtTqCELSL/O0qEwaqcvlXh/aWomqa5qxIiyfY7ZeqxRaSfL7NoFZNj8TJiujV2dXIARJMESMIIbOIEqBAMmHMEgHEEVeMEQVIGoeQEjcAIq+B3g5cZwiAM8ZMNx+QE9TQEVSBkbvMoY9A06oUdmpRMM8kocZB6TidZ9SFlqVZm+6dM+/WCAmB7qpV4jtF6YUc4rsAUlrBcs3AIa1IAPVEEVHMEc3FgVGEFS9YAdeMjviUAPhAIqhML/T1xUCxhFUgxAArxIASCFACSABkxAA6gMDBjAVVyAEqyXYrkOe4VCIulVxoSCGeRXG3iB0kHBEiBif/nX/NFf/dlfsWGdq+0f/52d133d/03G19Gaho0d2SEgZGxAEoxBIWCHGawBKwTDJOweFbzKIGICKZCCNdSDPvhDboxDPIxDOvCCHbjBH7ABvH3BGKxBC1aHDMJgkh1jkuVNQdBbk82TfMhBNEpjNPJBNVojH9BBNe7TNvrB6RVCISCCEUKCJWiCKGTLlchCLbRCidxeD0hBIfDBGTACH4iBJozBETBBUv0ApKGRHagOGTqCiaBBUQgAAohGAqihUiAFBJgA/wjAgAYQAFl84RbCwhUMH3uRgntdkSy4giJkwVGNwdyAWn653w8MwSX9wA0AGMtQHSS+iZtI4oJxACVmwGPUydl9IiZu2Cd6ooKd3ZyMASHIwRjkAR8cAh64AjJYAhwcgkkYAhTUASa8IixggzzQoj6sgzikgzxgAyigAXLZTRxwgTASY3nEIDrdQVqmpXmsJVu6ZTqJQUHQE+d9HjRKYzVS4zVi45VxoxL9hyGIROpBQutBQjnG3pXMQjBYiNeAghPUwSKcICYYghgcQo4xARMsgREQQQzowBNcwi2cCImUyIkolsjtDpEYAEIOAFMUAAikgAIYhQO0mRCAQihcJP8fnsIr6BUWpUEWOIEThCT7gRp+jdrJ+EBKrmSatGQovSRzZt2bfMCCRaf+TSJORsYGcF1OaqfZwVr7IIInmEIleMIqpEIpaEIwSAMrpMIqxEIsZIzn7MIwgMMsmo05fAM46CLr+GLirUEXSGMbRKNartsNrZuAqpt4qCWBJqgN3QFCIIRB4EFBOGiExsFdWuM0yoFeWiNradk+ASYjgCgkMMI4coKDyN4s6AIyPMMzRMM0GMMstMIj/IEdWALqTcKndYEFVkESgA8PREEomE68nE5oBkVOeMAGNAD3IWQBFIAAFMBXLIAAUMXvTZQdDB/QXQIUbcsVjUIWZEGOzY3/0i0dqB0BJYHPUmHS1LUkzFzd1WXdB8BpnFLngrUP2lUn19Hkdl4Anc5JMMyEnwKqn0pDN/gpMqioMGSONETDfPrDP/DDOGDDNVSDV/LiGgylf1ZjPkVjHgRCHhyop66lgX6quinogLLlHRzEg6aqhDpoQWDohU6jhu4lSPClH/iHPp0eYIrobJXoYc6ChLAoNVzDNWRDNuyCV14CJeyBJnypHHhBFTSBHihgFQRBDtgBkPICM3RNaMJLilwBoTVNAhQABKTABLQRUkSAB7TAH6zKen3lwUGIQcmCJUDBlx5BcArnmObXqA3BEMhdmrLkYbBpm8Kkm8QpnMrMzIwS/3ViJ01mZ9dFRnfOyTMEwzZVLDLAxIpmg+FhLDJkzoRcQzx00D8cFjZMgy6gwRr8Bx/IAd0wC7Nkoxyk5YGmG80KaLrNbFvCoIDGwX2wqkEAbYViaENEWaziZV6Gnq0mCz4pUYhiQolmSytMUbdEAzVYw8Z2AzDpwjq6ASZ4QZT5pxU0wdgmQRWYgROwFyoMgzH8AurAgupU1Bl1AAQICaJMwAI0KfQhgAhcgldeqSP04bbIAhbVwWMxARFYx3VkwZiC2t1REhH8q6ltUgwkz8ASLHMe7AcsxvElbOd2wAYc7JzUZMM6LCW2zzNIg6Fuk6GuqKJmAzhUCKISw4pSA/880Kc+qIM1OAMqOMEe4EGGBtle9kE+8UGn3myCLmjN4qzlncfNmscbLASFHkTQGkQ0Fq0cEC2AWuirUgQ2UsRH6GCH+kc/jaMmeALsUc8t7IIwPIOwYm03ZG02PENFeekctEEjIAIhGIHYVkElnOAW/MEjkEIuFEPYxAuJ0IsibMEFmFUEHIBs+Bm+CIHGTfC1kgKE7FW5aMEZLC7ivkoXaAHjIqLjFmfkZlKApQAKoA8HECyboA8JfMDVwSkJiEAoea4HLAbCMoacwinD6l8PM+zmdM4QD/H6+sIxXAM16MIU7cIuJIM3yINx5ANX1tgVDEKndqqnykEgFG8Wc6r/gDYvGN8QzaLlgp5HHFzeWYaxqY4xqNZsINQsze5BIFwxQgzCHc9lwEVOtVCCmFFO5dxCM7XvsA5rNmgD/GaDL6jCI5SBEEDBEBABDWSfDPDBFmxBD+zBE/TAFVwCigJDvPyExoGCG+CACEQAA08X7qBUC2QUe10CKcjFKxhULZCCGcyBp1XBq0xhFTCBFFSBFMwcv0Ky3KXkDUyuJpmPCpNAm1yuDMdpB2Ru5tZkNJduNVNixnDklkiJxlCJLkQDMuyCbn4NN/hGPkyxNqDCFUTBFXPqqHrqqCLogB7vPA+ozSajrphlGTPogTLozL7zP/8zHQ/CQ+ixgUyLgoTZ/+tlixStL4tW7bBySrFSgzTQAhrkQBAQwRIkQX91wRYYQhRAghlsgRMMXycf8G45goeASAugwMToCGQc33BpnMIBhXsV1BVtgi2fwRQOZXXsMhNMIWYawVCPGjEjJ/1pkgzoQPl0kgs79Qu3aTRL9VTHqTVbsyrUVlu4witgcyAv8S+0bzQcAzAwQzlYZQhWg5UqATtncRzbbB6E8akWKPKasc2aqs4yrz7f0BjjtVwD9MwGQmDTMUP85ekdtIIMHCdwAiwTFC5Q0NVUrTUQazYkMTVQgy+siiMbVRc0whgMAh8sUXacwRwowRMEZCvAoiqoCIiASA28gAdkgAgMG/8OAJ3CSVpGtkI6yusjuAEdpIEF9nRIcgEvB3VmEnVRF3Pw6UBUxYBSEw9zI7PLKPPVPXUJUPV1w+mdVbVVL5i47EIzYc7Hzu6KfoszTMM1wC82hAM71GI9wEMuoIES8EAWBzZAuzHO+nPOxjM9ryWpEmg/JyODynUcO69a/jN+B/bMNkQ3GsJfVssiQPgjLAgSPsgs3MISx+cytK+wWkOHVzYxVBQaZMEZeELqaUIdQIIfYEIljMIWRIEj/GMiTZqbvU4PaNTvDZdt7xYowDIt3MIst8K0GAIhVkE0fvAu83ISzJxmIjcmPZWJyUCUK7WUmxhTq3B1Vzd2a3l0ZsD/dcMa6sJEmCuqNFADMAkrNcxYi2LDN6iDO5iNPHjDpPXAfAs2fXtqfb8zYL+z8eY3ft8sqYqxGJdqoLsxp3rxfbs1fhd6Q9zxHTM4hEO6ghxhwXG1panvEQerNUxDh3f4RIezKCyCIUyCJ/hBJRgCJ5ivJYfCLqiCZFnCIkSBGZ2REqCRRtG2I/TtT/D4LDBT52CRIjCCIdCBHBR5cHcBFwx3UCs5k0NuEMjdSr5AHpVPCbiMCkg7MptPtauwdnnSU8Mpm2y5NPMfVYe5ZZu7ZRNyIU8DmgsrNpjDOoRgdEQBGgn2HWOxoR/6neN5voMqPxMoorclfx94qBZ6nbd1/0C39Z8HQkPsQaN3o4BEOoTH1iO83k1U+KUPgzNAA4cPazUgcjS0whbdBSYcQiOMAieswRaQwi2EwhZAQQ7ogBJonMa5wRmx9hXg+k+QiB2QwjIhk+ecAiUwwkc4qzR+MOQpezAXZ1E7lVNFu7VHu3a5cLW7TLZz+9WXQLd7e7hjN/+de5l3Q7oPq2UDU2VfAzaoAz00CjhUpBb0wAtccaMb/KHTN56rm32TsYL2u58rvFsDvD/re6EDdILT7Dv7bsMPwukdQuI35YMvQnwICK9yAkAJlKXrwjEEa7p3gzdsfjYcQyuEwh8wwiJUginQgROggdRewn0dgQ5owR+4Qf+1ZJxOEJeuBwUoPEIr7EIEhUstiIIlDD0dECLLGrkuJ71mIoHTjRrxZBJSR/vzWz0KdBLVd9LVWz+3s4nWc/1Ub12xSvTrer/7lnkhA5M1dIpzWIMjqAEUuFmj23ud0ywdB37OHvjfAz7eCygd+32en+oXG7r9A8SdPIEGBrojMM+dPXj2DDJ0CGLDQ4YMKVq0iA2bOX4UMYIEqaOlUKRUvZrlSxixZ9GoZdPWrdtLb92yLcOlyg6aTX6uuJl1y84ZL1WYHDHECMocSpQe5UQDClVUWLBCtZq1S5gwX8RqcbIEiRGdNl74yDE7Bm3aKlWStDWCZAkRIkN86LCrw0b/DL0xXqh48RewCr9/BQtGcRhxYsOJEZco8QFyZMmTIWegDJlaNM3Lnj0ThgwZMWJZQfPiNQ1armTl1NWT9+vSozpqtgwaFAi37YeGbucZOMg3wYK+iSc8COcgwuG+kzcv/jz58IMJ4TwviBs7wTu9l9vWDXHiw4vjyX+shKkSJ0+iRJ1S1coVrVu9PrOkds1lN2/gwHW7duuSUMpwYotWVMniiB90UEGHMRoZ4wcl7JhwQlRAudBCVFq5ZZdePOyFlk2+YsSPPtoYpCw50upijC6IYiIJI96Si6667spLL8ACK4zHwhg7zLEfE3vssiKNjCyDXG5Z8pZZZMGllvda/yEllFBgQSUXYKapxpt0ypEHHFQuoWS2MmzL7UzvhBvIOt9uw406OOScjrgz12yTueSQm+7OPKOzLjvtBBJuj4YcCo8iiHh7yKKLPPrII0s2mTQUUVRhRZZacOmFGGSemcaaa7ThxhtvXsrmmVwc6amWUpTwowodfLhjEkImKcSPRR5xxJGooPIVlVl06cUXX3rZJcRKwPJDLDpSVDGtMdYiKsYlkKDRRrtssEEGGfjia8ceffRRyHKJhMyxI9X9gBVV3GNllVRW0QQSUkBx5EJYgMFmm3LSSac1eaC55BJI5qDtNjUJyq447IJDE8475BRjz4aFc6645jQWSLmHxf/4WM45Ow7OOOXuYKghinjzbuVDFgHvkEZkRqQRSCSllD2SXpGvw62euU+bUYMO+ppobkFFF1KeKKWRI8A4JJNEPJEDE1UsBGUqVKaCBar5ivUQl1fQawQRZtvgI8Vo0ZoWxiSslWuubHOY24YaXugWXB37GkxcFcoVMt0PHDt3XcpGWSXeVEwxRRZRLoFqFmCqEWccdcZhTR1z0oEHltgUYUONK7yzs6Az6+TOYTjz3LPj5kJGLqGS7xCUY4n1ROj11zWu+M+DUNaNokK/W6QR4mU+/vhFLJF0pE1ACeUU+OTj0JdjPr3mGmy0x8aabK5p6RdQSuGDC4gGQcQTP0r/QYUUWHTJZZat2W9ll2J92WUXXFrBBBOymXUWbdCKFtvasoS3ySVbPJhbDmpQg255S28R7Nth+ua3IT1mcIUr0io4YYp4neIUpJgFL5KhjXTEIx/6aMc52tEOc5gjHgJzxCMUMYc0IIwidgoUcRj2MITQ6Ye92x3rjiOy3BmRYiKjk29gJzvi1E4hhfLDFCnihz1MsVHGa8QkZDYJLxZvKZSQFMGeRwr3vMIktxiWMT51H1FdwxrYuAY3tLGMW2yCEpMYBBdyZYdTRGUZ1CjGL3LxPlSEohb2u1/+VME/svWBDnQohG3KojZprQVGUpDCAevygx/wQIE5qNsDcxTB/73trYLkQoEFGzM4wmkwMqYYxShIQQosQUMb8ajHLlPoD3vMox32WAc94gEOWNjhD35oQxq2UJscYudN2nmY6tiEuz3BQVC8c50SJwayj4EsZMdJohiWSJw54emJKJMiFafoB0OMhxE0Q54XuRjGpViCKY+rVClCqKGf6MJn1HCjqLTBn5k8I0SKcAMb3ACKV0xlGdDgBTB+YYxcQAUXWikWLxipCU08MpKFmGTa1Ma2KmzyWkT4gQ+OEARQhjIHD/QWuPait1SKa5WsZEzgYBmZUHStGduQRz1SSA965CMfRE2hPezBjnrEoxoTmoMclnmFLeDBIdF0mHGmuTDtCP+KOcYRmVhDBs5uigEMZ02iOMd5xImd84kjW0ih1mlFLDYKEvKc50eW8ogwYvERknpegEhiFTX6YhkswU9M+NMfmDzjFq24hB2CBYtfUKMZpvlFL1ohClnQR6O80MUtTuFRkPphpGaBlgAxyYSTGvBanjxCS186Nx3IdKakBEwMBoPKm1pQlTzt6Qdy4YyCDpUe/mhHP/bRD3/oA6lI1Qc95BEPeOQCDWoQixjW0Ew8BMJ002zYcsKKm4OYV2JK3ObHwGDWb5b1vcgRwxjI+U362g5kbwCZnpr4GzzM4Yp15YgiDMGReOr1eB/5yCNsZgksNth5jtCnzoSFlZXcpxv//IFHqWCSDWoMQ2umYcaIizHIXKBiZ1kZDbF2cYtSOJJsdEBtIQIowLW1VpMGjItKW/qDIPiAB3e5LW51+5e95K0wvuURBQuTwcmQ4ANQVtcueakPfdzjH/9g7j72sQ5zQPep8IBHNiZrh3YqQhF+GB3wvBoo1f0QdqmLnezWS7Fvvve96TVLG1TL5zX0eQx8loMyxVAWMVBVDmhTNI0V3Wg+FIIiaO6ISOdZCS4q+Dya4J+mNbGJ9dSSn+9K46Y6FQ3s5adUHM6GNZoBDF7kIhemcTVVUHGLY9yaGMfChSxKsQlIMaIP7mTWFMVyhjGkwQtDOakUmNDsoswW2gkC/7JdcHvkmu72yDZdsiobcxkOfODbkSGBlCVjj3vcwx70OPc7tMzcd6QbH0mtx4az0Ys/mLmdxB5dD8Hbmx6SDCER4yp1tvlWtdrZrIFWrYrOolq0mCUNNjyDWdZQFkdf3NGQ7ggjOM7xmn3c0sqqxMj5V/JNc0I9nhhFqKUUHw4Jw3o/w97QTDU0bVgDGq42zatnkQthKEMZwxBG/mohi1Fg4teF6EOB69D0OiyzDVFXtiad/exoe9IH2Roy3qxNU2sbWUd+welOMzhuDpz97JAht2SMyo51rMMd9uCyc40qj+qGWRvJCB8a8B1JP9SBDvu+U7+FQ824Qic66YXDnf8Zv3gwtPfxjP8YfcdwlodbEi1pWGYa9syHqC98DmKZQ+hl3M6KdJzjaB6PXyFBidYvD/Ymx4RHPaqelZeC5a1II0B/UYxlgIqgNre5NaZR/Gg4wxi+D7ovcHGLWrBCFEiHRCMKgYiltzOSUY96Gs6wFk1SoerQ9iTWtb51mXb96y8oZbi4DaSykwDtaTfS2+HuDi+Tgx/zgKE80sENa+C8GqYBGGbBDq4A+7BvDyBGdfht4JgIiDbmdSTv8SBvAiPvmyKP8izv8h7uLNZgDtqADQKID9aABD9v9Npgqvxu2NxJ0lpQ9fzKr+4J9iyBf2iQ9mjP9m7PjP5I937iFgr/CRicYRrcCBuEbxtS7eagYRmSwRmWb7RooRU84SumDxGsD82wL5LEgvuG4vuqzupma6WyTlbugshICf26jjDEbsnIzjHGDf7Q7kjeQQ7fjR3UQR3KIR7SwRusQe9yARqaARo0AxWE4FXQRgWtqHR0aDkML66gyHXMqpsm8AsqkL0ucAInz5IEyPLWoA1K8PO0r88ELdGy0FkkSaRQqyLQjOMUjBVJbnkwgQYnRRZnsVJEYSRIoRTMSPdg4SdyYReGIbFA5f+2pwi1h/icgRmKwRmWYRh84QlVQQo/gmyskMAKjBQ3rwtcRAqoAPycLdrAUAzFkNrK0AzRMEeSbOwu/yjK3NDs1G7tIAMd0OEc1qEOvaQctgEakoGijOEYTo0ajsEOemALDDELmaWr/k28noOajiM50IrxHu8LIjIiL/HOIFIiwQDzMrILPoYEPVEUOzEjKm8Us5APTFGkCoERWhD1WBESzgMWYW8WMWEWZZESJkUUaokkoiKNfHEYlHFL4ogYsWEamCEZkkEZnOEY7mdJZEEVNgE98qoKB6yK/kcslgktvKALuIAbvfEbw1BWxJEc8Wamvq6UBEPJdApI1K4E2DHc3HAyzMEOvaTmuAcaoKH4BIomskEaVCEHeiAISrIUs1AhtwqdoiNiikic2gutJPILuMAxJ5IiIfIxG/+TC+YLLbIxG1skMzWzC4xNbbQPBNNANDVPDg6x9KioIlJRFVdRwcRoeQgGNi8EFCwBFGCTYGjoEfRpJCxkN3mx53QBGJTBLuNoVLAhAKHBGZDvGIZutGbBFXrN0maGEVJxKrNQ+y6zC8BAK8Ov2cQv675zHMkxBsZyL8gz7HrkR4iEBNbSLd3xHeXyGlCjLoUQGkLlPlpCGpABF7bAL3Eg0QAzC/dgzsgrT2QnnOJEnJDD8dCKCxgTMiexAsFgErWSChxTK1mEMzcTMzHzDDxzM/msE0czI9gABemgDkZvD+og3/KtBRcBEhgsBpcnn2yTYGjTEmLjEXKUV2aIjEL/4XEuJBT86Qd5ARiBTxvkiPimYRmJQSlp4RVa4eiisxFSLyXz7RrbgDPRqhu90Du/UwzDUi/EMrey7TwnCAXOhT3HTTLUVDK6gRqQ0xmg4XuygSbyMhqEIRh6ARdOwQ0UQTTb4BCnSEC5KlC4I3YIAq2qozryYPEesQIh9FEnkb0kUQyo4AvEICLRCjS1ryP/rA24Sw7SQAvOoA02cg26AApSFQqyYFWzIAqcgBCdQFavQAiuAFZ7QAiEQFZhdVavwFd/FQ3QYAuyyw3UwA3sQA1Axw/cYA4W6gxARw2i1Q3+gFf+wFiRyQ4kbCRUgRdzoaKKMhmYQRmS7xda7Bae/xQV/gAHFGFsJAEsOkLSrJEUzwIztTP8jqA7EyQMvdT8yvAMybRMF6Pb3FGDloEzpmFOaQIcPOwZQEQVVEEWaAET/OADz4AUnS7waCchCs8gysl2GJWtyipSHfQiJTEiuQAMKlRC00oMNpK7OhI014C7WjYNOrNmu+BUtcAMdvYMRjMLzGA0d3Zn02BnjRUNyuAKysAMzqAMlFYNzMBYk9UNjpWhNCIj0sBVlaAHtrYH5qZrcQBXt1YIcAAHcrVWdZXvoAIWhvQXgKEYkmGQ3qdJTOIVVOEP/gA9JEFZUnLjCIzYstDystFevTBfwXFft65fiewMTWnbLihNC8cuF/+LJgTqGYIBF1ghFVKBE2Lh+aboDNTgDJpu9ObA6RLQQHmoQOlsd7zJIiUUQhkTIiP0ZKfAUh0z8jqyZbORBL9pd9kgDUiUROlgDjxw9OrgClmwwOC1DaZoDkb070RXVIFWCzaindYAaM0gVZXACY7AbroXB2oABUTAA8ZXfC/gAjzAfC/AAc4XB56gVu2gfW5hosBVGZYhOTnjGUDDU3rhFNBj5N514zhOXudVM8VgOwn36nzgcIcscf11PMlz/VApPQWnPScj/s4OP7JBg6OhU3rBFViBFUwhFkZBhFfBYJquQ0VXDUi36fDAT8pJml7YdoxIQSc1Ml33hi1yIiH/EzO/yVQ5MndFlERPkA1S9K4UQelGUaTowCw2dGm1gFVnywmgQAlmKwiCYFXdt2tzgAfINgdaYANaoAbA9nvL9n3v9hGAVEjrR+iMwX7rsvhQI46nIRroWEmXQRmIgRT4Z+SUZTUFmCoB9zINeEu5FBylLVtkoIHDkuseOGB1Sj3Z1IIvWC+RQU9jAVNsIRViIRZKYRVMgRNWYRT6ICzaYFRHl3SJDQ8wJnU/VobTS5w4Br4UE60o0fEkskFl91KheGnNIAtYNQugWFURJFWzIA1IcAtkVQm2IGm3gA2YIOuWwOpiYAx5625ewG5QoAVwQIFaQAREoAVwNVd91Q0e/6c9zohniEV/V0IzWGKOqWEI5dMui68aqqEu7/meiw8aqmHEQAwU+FhZFqEjwoPR/pOqdncjKZRwuRLawFPIGBmiZYD9gqsNJRkyLhjtLNcVMteDPKgWasEUSiHlRgERoq4zmxeVVZRZXHjgWidkpOMBi6g6ZLrxFg/PGA9lG/NkueDZVDV7tUALjoAHgkCoc+CKeUAJlCAIeqCBxBict/kFvrkF0PcDxBd9PWCMydYJ1ACNRQEVHtYqNkXFOsM+WkKgvAd7Tu3/1hp7iK+eq8Ea4Brn5vit63lL6ll7tuEbtoGvueEauGb2NMHSwKIRCFoE0aZTNzJlC9mQG9qhH//6gcgwoidaYF2pgsENozlAXjwoFhZHXjo7EdDnkzUh0aiqDc4gC1CZ9OhgUDWGqxgyY4QolnPnziLxUtlrEiPSUqfgCKZgCp7gCYoClETpL3AgB3DgBVpAm1HAA7zZA775myEgAzxAq69gQvhuVy5BZ9DoJ+qHGIwBGTSDne3jLu9SoM77vOt5rdebvf+vGoJSr/llG8IhHPwlHcZhHHSJqIwqhaZrl8BhFkBhEzxKSqdRpBTtPztxDdiARbRzKxs72vhVyMZxwh86PCGIsi3IldhTMtDODc8uXkhYcTo7czOBEyohFlYhESTBC6hKNKHgDFAZBT+QIfJglW8cDvT/Kw7uYMcZAg9+HA/iIA7eIA5+XGTE4A2SXMmRHAySPAwa07eT/AuoALjBMAhy4AXIdoxroAVaAJv/oqlfoC/7kpmP9Q9EInpaQT48RDRWgqw1Q6Da2Z3jubzjeJ7nWI7nua7rWnu0YRu44RvAQRz8JYaojJekK4WiC9GtzMr8wdEdfR7qARwuyilHjouOBxGWuCRLsyz+jMHRggu6gLEL17HFccIj+9Rva1u2JbfshrKB5EwrusPZEdxiIRVqwdZtwRZE2BY6exVS3BSqgAi+0QmS2tih4FWT+gmggAmg4Ami4AiqWAmeoIqjgGt7wNivfG5e6rbI1ttdXZu7fKo//+C5P2C6PWC6xV2MwfYK0GBaKWEkosck5AMXeiYrUgI0OqMzQOMYPAUZjsEYAh7oBr4oS+xti3LEEl7hAdEu33p7+Pob6JtyKkcd2CEe2EHRowsfNp7jOV4f+CEfnku69OG5Ht3R+8G5+MEd6MEbqALlkG4aZ0ak+qAka97hoMVFuOBF7rVLvdTUKxwvuCWmvJ3ovz25u1xgEaOqLwPKOuADnJ4EUpyTVwHXEeezQ9wToMAJftmnVbWKd7WKiTralTpsCTFWc5VrheDar/24x3ztxbndj3VXHmETbKkkZgHvl0QX6ufeRUM0bg3wA17wDV7wBR5cDx9cFV7h4Vi9H/8e0Ov7X+yw4tmB8o3KqDaeHjo+3u6BHzrf8z+fHxzd8/2h8/+B9D/f5P2h3UjfHdiBG6jCEziBf6ZP5me+D24/khYOWqYFk5IARpbgGxE5HIH+1OfGuI/72xtI+Y8e6RkDukVgXVL816c+XkxBcajehKVgVa8gCqA4C5wgCoY5Cmx1V8s/bK9dV3n1CXzV3SdEwi5hE4L0YdNoSeq9Z1BiNIgB8P/9GIZhGAofIIwZK2YsmbKDB4sBWwisWLJkDB8mY0aRWTNo0KZNq8YRG7Zt276FGzdOnbp48lKyo8eSHj59+u7JvLev5j58+XLm48ezJ09//nwK5fmv6D+i/f7/Jd3HL2lSo0X79QPqjp02WKREceKECVKjr4jCFupDtg8dOWjRehkzpopbt0ziJknC5Ijduz986NXhQ4ffv4D/5hhMGIfhGogT13jRorEKFJAhi5gsAvKHy5gzr4plK9aqzZ9XpfJkq5YnP2nOqD6DBo2aLWZiyz5jRo0bN2ps23H06BIoUqdQtXr1alatW7h29erlS5hzYseQHZsO/ZixY7+GDSvGnaDDZNwlPqQ4kXxFi80uYszI0ZrHjyFFliuXLl28+/LmzaNnj97+ee64o589BM5D4D32vKPgOzY1uM89OQEl4T0+SQhVUURdyFM/NUnVoVRSQZUUVexwg5VW/5h09RVYiIxV1llpybEWW29VwYSNc8VVF14/5KXXXoEFRlhhh+Gg2GIvMKbCY5FRVhkKmUX5QSqcrWKKKaKt8kkqppQ2ShtuOOKIb76FEkopp6jCiiy0HJfccsIQI6d0yCDzjJ112nnnMsscw+cyCAUq3nkSWXQeM+tpxFE17mGjDUjfiEOfSSahVE89OeGkTz6bwuQpTDklSBM/+/jzD4H2MMVPUQSq2tOCDNp0oEw2rarhhReC6GFNtuJq1Ib/kMjNLKSMwpWKK7ZYSCF0NEsHH2mxJW0XXXCh47Vx3aVtjz7+GOSQgxmWg2HkKpZkkktG1qST7DqJpZWgWXllKv+1rOJJLMHkG0yez0Qjzb8ABxxwNAQXHM0zzzijMMIET+MMRumlR1F6GCnKaKOQiiSOfSnVI8+lIIOsE6ecfqqPPydLqPLKKvsalVIw/+OqgzSraipUTEFFak++6hqiUaYGHezQpo7ozzrrDFvssZVMkuyyzC77bIzSjkGttdhmq+223f7oAw88+AXukOSOexiS6DKpbrtsi5BJJpFkguUnnUTyySeJEJJIIrEgI7DBBgNM8N/RaGS44Ysy+t6j3IDjuDeOl2NpyJfmg2nJJsO0cuYoszy0yy6zLOFUpPvjlM+og5irhz5jmKFRqQcbFMr87GR77ffgc8+I9phjjjb/s6BiLFdNJ6uss1OjVTVbV2ObxBJGHLHjtkf42KNeYGcPdg7bE0mukWinre74bU+WSCZ1J6IH3XirH5YeiNTi978NQxNNooAbPM012XSjjTeQAwc84IGSj1HugAfMyac6Jzqg+AplmhMd6CYItNJZ0HSmU0rqTqc62G3wKS4DkYPu0RKWrIQe7EghO5C2DqngYx0kuYrwtoKJSjQCEZIAC7OQBy05SMuHzKsW1uTyvCVoDS924VZewNaDJjqRB03sHg7MdrbEnCtdKFCbZMoXiU7EohOCQJ+WwPgJPQhCEH2AhChcEQxhROMa2sAYNqqBDWU0LBrOIFg1uiFA/Fzq/z7xoBQ71OGSFMpDHeFIZCLLIQ//RNCBpuqVTzSoK9m1jIKYhB3MnLLJmL3uQkIrms8+VMlR7mNB7WgHOlZ5jlaeg4XrEBCAVriOFM5DKvp4oTqAV6xQEO+GN1QWs/iwwzYYsw1jUN4YsMaFIcYFetPj2vX08gMo9kB72QPX96x4xSVpcYvlE0EYY2G3VaBPEHpIxCciYUZEYMEPbcAEKH5xnwGmQx7jSAc8tHEwgj0sI9DwRjoY6bF6mISF7XBHO+yBIJaYQ5GJHAdL7hGUXlEwdqsSWs8yKSIOitBBP4NKA4HCoZLaBJWpdKVKV+pKdKT0lQlN6Dv0Q9P+UNQfOf8ZJC9HgSIbIkKHUENes4yZhmQyLy7NdCY0t7Ytr/0gCE/M3jV5MDazcfMF3vwmCsI5mbh1wouriAQgrEAGdDahrHqAxCj6wIhH+OI+9akHPcZRT3BcYxkFc0YzkjENbdwzJflQRyoHuyBezRWiI5kHhY6yD9QNZVWu6sk+KPnBxnLIJrqqmWU/utnWqax2+MAHS5Dmu1ai4xynPQc5VksOVw4Wlix8ZYDasQ6Ywuq2tyUQP/RxqXWoQ2ml6Ckwbwi1ZfnBD8hjQ1GnxUysFdEI0UxiEq33AyUI4bpPjCpViWSutGmVq+J8myDs9glARIIMkRAEGdKZiUr0QQ+NuMT/M+ABDmhUQx3rmCs8ukGNbBxsGQlzBjP46o0C0mOwqSwsiA47DkWawx622uAELapBzdbsg5nt7CYTxOF3zPa1tXWlOchhDpWuMrUsVSlskdZK2AYItwo66YLcsalDjqMcwDtFKTzxy5+GRZiFOO5xh7pc5iZVR0U8IlOVWN3rOtmJUN5uuMDXXW9mMTIt4OoZ0yuIVKwijOg9YybS2Qg5kAERpMgGAUEiD9LCgxrDQIYviKGnglBkGuFISTzWgeB2KEhXMBxJRNfBj5tV0oOHdhlmUdcg1l2WZrdVsSv5XNsRl5i1rsQ0ak982piuEsEfTqVCExqgALFkPy2xhypX/7la1JLk1a/2XTnE8Y1vXGMWOvZEinwaTCALGblzaAMb2CIGMVgtqUNMso6YyqOnOlkIToTqE7VJZcR0M6soaIy2t63t851zvOM143o7AT9E9IEMhBBFNlDCMRiqAxzLuEUrLvGKPCHjO8yohjjuQ8uY+hlE93goRMcxjwzKzCYdTbSGmsJZGcNK1AhGB2tb61qWkuOlLV71KmGsoFS61B32GLWfQY6qkos8pb6DdYMRq0iSsHwc4hBHOLjBjVvnetfDFQvUDCFkOswh2HcYQ7GZh+wbMeF5WWN2EoPwbCdLG5tOpGINjHQurGZVBdzOegs6YYpwm/GM6FQvGayQCP8pDKEIemDEMFBCwHiQRB7wyEYtNiEKWbyCFsggxjB+kYyL6DuQ6lChQt8hFX/YY+Utp0cGSxpSyu7KQTN2R2xLTHkSk4Mklm6l5Vd6Wk5rerCfRjCladsOABnI9As9eTtErHJYs/zlr4/9fNJB629kA9c7xvlPgbosQ/AcuT5vQx7uIAYwGJ9aV+MCjuiStejeRQnQh76TlQBVJjbxyVY1TNWt7k2tc1sQVgACGcpaVs9k4ozp1IMLiFAEMnDiFdEQoD3jAY5sZEMWo4AEJlRRdzkPQxkWAQ3YYB8msRIGYln+MA+v5mAnw0kgxFi4pXmqtVqtV1rjQHGw1GLn0Gf/HNiBIwdypRaCJcQO85BC6pByC4h4irQNsdeCLvh6MReDkjIf4kBz2XALqLBjPbYijVBchWAIQcYHZ9EGfEB8xnd8XNAFVOBMVNB8y6YtSuAEURh9QaAERxBFTiR9PRAuU0d1V5Q23rdtgoAEZTVm6kU3kRAJTUBWVlAFiaBelUAvwtBf3eAN/EUMwRALmaBrtYALqnALCIMM1BANjOJX/IYPkARB+cAS+aApKYNB/cAPBcIf80B6CqVQfFaJlLaBqMRxhXVbNaEgDCUT/KEP+8AfqOgfJZhCvmUOlHJjsCgOMDeLsghr5hBrrpgOJqGLvuM7J+iKrriL9MGLJzhQ/7NXH8hYH3CVDo7TDbqACqTAY5owCZOAQ71GCIUwCMsyCHQQCHyQB3IQB3HwBmFQjlxABV+ghE2oI1MwBU/wjk+gdPLIZNXEA1VIfVRVLlfFGIwRhtu2XokQZlagB2TQBOCXBOfTBG8TkImwCrLgCs/QDcdADc/QC7VgC6bwNqlgC7jgCq6AC8QgDf2iER5xTyR4M8FCQqe2Ev1BU/oRgqZmIDM1Uwj2DqL2DgniZ7BCMzNBEw2CKgiiHytkEq7ngiIRDjKHlDK4lDI4H075lE9JKSZBH+WgDsl4lVgJlU6ZjOBgh7sAjdJIjY2QQz8GZNk4CIEwfHggjuT4BV/ABf9h8JZU0I506Y7wGI/vKI/UM131GEVTtk3bdy7+2BidMH7jVpAESZB80wlWkATjJwiJgCWygAtxkieskApiVAqsYCyucAryM5LWYA3QsA2+0w6NdZqSFyC1tYmuxYF8ppOguJO8kkui1RKNaEIq9Iu3qIKJBBK++Zu+WWvCKZw0V2vcMJy1FntJqZRPyZQzeIz18ZT1ISnRuTHl8DjeoA3a4BGh6TDPgIPRyAmaUAk21Gs+WFyDkAd5gAfsGQdx6ZZx2UxUMJd1+QR2eZd5mZd6WT19KWXfczZJ0gIvgCSNEaBaFwlWMJBfhV4F2QmJYAXs1AQEaQVvw3W1QAu3EAz/u4AMwUAlkrAKtaAJ+TcKrMAJo+A31EAN04AN9rUN4xArjfUOCLV6qbQO6MBn7vAOJTZ6owZj/WCTHZdKlGKMNKhIyPkNwBkfR7qk30BzNLcNxWmcIHGcIrGkL+icMug4WgpAXKqd2HANoVkN07AezTBg3GGmCsELvhA8oyCNlZBDLGKW25ieebAHe7CWbfkF7ymfc0mfdImf+Lmf02VN/vmf4WNtVVeg21c3YacHelA3ZPCg42cFnZAJ41c36EMltIALnWEKlUoIctMHqxAMpjAKsZAmgGh/GDMOPnkU9sBCocYO7SCrfCarplcVQ9mLu4lYvumkwOmkR9qrVDqs/9zgmyzHpEzqOEwaDsPJrJFinMW6DdrADdq5ndgQpmIKDWUKHgzRrQqhEAzxC+K6d8MgDL7gC7SgCjvGY+Q5lnAqp2iZlnW6luP4nuXolnx6jnV5n4Cqn/PYI9LWRH9ZRQN6JIg6oFVnkODHTuT3mHqQoGCkXnFzN1RSqp6gCQ/6qF9lCsFgC3qwkZjQGrDQDfAQnZLzEieTSyg0SFJpEijIq0nqm/ARszTbq8J6nNEKpcfpDdzAs1R6pMA6nMXJpTTnDd9gtE76pNXKnYsyptq6rdzKELwwtVQrrt36C1MrrlorrlPrHOa6HL3wCurappzQrpIgCU4jTMI0CPF6p//j+AZtmadyOZ9+2o722a/+ymzcEgRMB2XeU20GeyQJi1Zj97BfZzdrmKCCIKGr0BmcwQle4KhNwLiV0BkOCpmJ4AVmECa/IECOE4PzEQ4g8R6kW7qmW7qPApypm7o1S7PVqrNTyjjFGq1J66u1W6zTirteeq2haQ0ccThPO2DAAB7c0RDderxXS7XKu7y6wAu7sAvO67y98Ly7oAvPK7alQLbtKpbEtSxmiZZ2iqflGAbkuKd0W7fu+Kd4q2Q8cgRMB21bSDb6GLgGey4EOW7qJQh6mAipkF5fNn6PGgtflAmEQFZeYJAKqSWfcH5pmAhJ4AV1pwvLQA3XMKYbccH/68EeiZM4vdvB7hGaHrG01TrCr9u6qkvC2pm0Izy7ULq7vOu7TgsxZXooFxExCgO14Nodx1u8wGC14bq1XLu8z6sLRFzE1TvEuoALraCunnCxNeQVT1MI35uWdnqn5Qu39yqXU0C3++qn8DgFR/AE16K3P+C+2BW/ORC/80u/gXtGBompgoCGlpoJsYBOj/oJGRk3Z0Q3cBM3knC5lRo3iIAJk2kn0aCiiLPBHOzBoXkN7+HIpIvC1Tq7uZudU1qcXcmlkKPJnMyzS3sNYPq7ThsxAyYeplwoE5EeFuww0KAwgHIQBqEMAlEM2yEesJwMAjEQ2rHLvNzL2mGuzWGu/84RzOmavRdLnpDAvWWJnvGKB24Lt+RYr/g6l3y6r/z6jjoSj0oHsO8rsPLLxuBcAw87fnBzfuoDwA8aCQ8qCecXdmXVRXszXg2ZTmRQBAnqBaOAC5R5yIhsMdi6yGDawaA80ARd0I4iyQiN0F8Kpv08yjN8yhDdHbk8EKfMDMrQDHqVEYbTyhjdDMoQy7I8y8Xw0RIxELnMHb7cywuhHc0RzMJ8rs1RC2N7zF7Bvb3WIocANWxbxeNYr9Ksxec4n9Z8zXGRt0rmbE/mt1aFGIALzmRVVpBJzwtrC+SGbonQCYggB45KuIs7kJJACF23uEBQBInQB6VwC7sgDMdwyP+FczgakaLTQA0cTA0eDMoCXdAFnQ143btwbTgK48qBchAiTRAD0R2GfdiGPdEmHdh/8tfT0NatzNEDRhEkjcvGENKFzR0irR3iith79wsMAdMtLdq+cAszPZ5OQ41OE6fnOQg8LY5vm6dBfb5DjZ/ZvGxjXD33aF1Q5s3/uU30axgFObmGudWCYAtfdlZNgCVk93XgZ5CZsAqIoAeSkAgRugMKWQkf2QvE0C8N49bgbTgpOt7WQNd2HZrjHdeAE2B/ItiYrdjwbQzakcvDIBAp/X/xHdgnfdkHsQx/7d94dD/ZSqbowQx8ghAgLcuEXdjyTa46XLygvRCkPeHCYNr/OjYKqK3aqx1Mre3a4cuW0Gy+SxjUtX2XTshs93jGSv09VAQ+RgLcODDOw20FTYAE0P3cVmAKn4BOq6AHZ0XjY4fHiFAJXIdOY9ZenFALcOLdf/1PBtPkGIEwUu4MCfMnr2zfv+y1Wu615arlvqx3YC4nxHAd1hHfZl4Qthwo/K0M/s0wz2A/zoDIA57BMpwer4wQZv7LvAwMLD3hE84LYGvh2TueNmTTjXAIiJ7o6HmneArNcnuO1TzU93nizPZs3uzNLf7bv83USGBWyg2h47dOTVCpn7AKX7Xj60UGgAAIZBDdnpHHsbBOqyAJqfAmwhBneNTkCzMd05HZKg3E/7/gC+Lq58Tu0lt+7Fx+37TMy2aOy85eEP3NJ1QOOIZT3syQyG6NEXp154K92MowHXq+yxJe7OfKHNTbC/J24TRt6F+R6Dk9p4we21jslnIZ6SUuxkyAzUmnLUJgXfCr1AOr6Zre3JQa3V2HmGPXCZ9gBeOVXoZZBICAdonQsZCQN+RlC7bQCKfQRpWJMH4S0tShHXo3zOTu58xR8qJ98iif7LyM2IS9HduRy7L83v6dR9/dMHJN183w1uXt1vcD2H0C37x+DFm+yyQP02Cb9NOrHMpxC6xw4eJZCcls6IfQ7ogO7+yJB+QY4veKbOfLxeqL704YXf3u7709NppeVf+GgZB6oCWRkIeRik40Hsf527AFqeplRW7vhT7nt8CJ4AcgqScEM/S8LuaGn+VHP+HL4QuLD7aM7/hIn/LPyxzBXvnCLgxaqx0L4fIovcuK7Sd98vEKkz9tPaagrA3XIKaGYzCtfODufQzfDvrWUfRZXu5ID7ZMP/nLgQuXmb3EM/Ubjug8ePXZWMVaT75YnMWzTbder77NBwVPAAVWCIWWfvbUNkVTVFXj4uOtjl6o3gSRsApW0OmCUOTjx+oQz+rqdVYfu+NmFKFeED8Ak6JSXv/PMPR6J/LE4OVdfuxysuUAQUwYMYLCDAocljDhQYINCRpTpszYxIkSJybDmKz/2EaOECEqW7bM2ciQIp1BQ9lMZbOT07Rpw8ZMZjJmGTUWA5bz106eO3n9BKqLl09euoweRWr0Vq5bt3Q1vcUqlalRnDBVYjRpUqNDXb1+NTQoUNg9eOLEefMG7ZswYb685fKFC5UpdadQoVv3yV6+T6JAeQLlrxPCSoQoUXIkiJAgPBwHacwjx2TKOCxfplwZRxPOZCIJEtSpCZlEnEFbIZSJzGoyVj4B6hSJdREysWwlShQpkpXRXirVkhac2jNkz4wbR3ZM+TFiCR0KFDas+TCD1asrtJ7doELu26M7pEjRYviMxjaKtxix5PqVzprJdM+smTVv3rjJnNnMJsZi/zdxAuMJQKAG/CkXAw9EMMEEZ3nllFNGCQUTSCChZCuuvLqwq7ACGaTDstAKA0S4uIhLrrnswssuvqJYMQrCXixMCCEUC4JGyCDrQbLJcMgMsx15zMGyJoAoQpDWOlmFM97IECSJTPTwognQRutEED0SWZKMTGz5ZMtOMvmsCSjrYOWZ4JApLrninoloueemkw467a6bMzvuulOouebM6wgj8jAaLyJBBS1JvZFWUkm+ZlKyBhxw4LEGJWgUbWbQZJThiCNg/iOQQF0M/FRBBHnJhRdgeJlFlQetqkQrVxu5MMOuxOpwkD32ADEtt0wsUa4UpyAxrxb3isJFGJ1ATP/GI5Zd9sYbHdsxM2mnxaGIIqzQwwrbyGgiEdE4u9ILL+TAkjMpE7lSNdAkkSOTTEKLzUo9EGmjFGSkQRPN454JaTnmiAnPmDgZKsg76rbzZc47F74z02Iu2k+ZSy8dVL31nAkJJERZgka/ZqapxpprFs0mm2tSUmmZimuqyab+coL5VFNj3hQjZqCZBmRssNmGm22+AUebW1QtRRRMXEU61q8OCeuQDs1ai61deeUVLyqCtWsKv1jc+ljEDJuRWRshg3ZaaXXssTMy9PhktyZ446yTRKow5TZTEvlktVUyQeSTTqqMJBM5CCFEkkz+TmU0QVLpAxNc0CTmGOOWiQb/42WOyTfy5SYq6E2CsAN9IYMSpu5ghrkTOODwIkrGGIotLmljy1k6CaVkoHHGGmtyQaUoYXzJJRpqRiLevZXww8/mm3GuJuSdt/lZnHLUiUce6+WpJ/t53JnnHnroqQccXoj2ZJNJJEHawkNkZXqQ9qEGcWoS558/xV+zLpZYY19MVlmxnW2M2QTYIxxYgVuj0VIkkiCltx0JGcHwgiQi0QkmoQsRqzCcHprkhUQQwluZ+MQnmoAEQawCEYjogyuCQZw1Va4k/lKO5v71HIIZA04Li84wfFG6HDbsPKiryOok5rpBiURlsjMeotzTMWhYYxq3o8ZwhvELYChjeZLC/1nOmvc8bgAtHl/84vXywQ99lNGMZ0QjP/DBj37wIx/pGN8pSuEJTaTvVbBaWljC4qFctUV+wbJa1gQ5hfx1zWsySsz/nIU2szFSWtVqQpEE0YRUdMIKlxREJrAVDGnYQg+E0AMZ/qYHSRBuFbaw0iW9tbjcHLCCZPBCFk7RC33xaz3+gpznTrdLXnInU64TWEIoopyKVAx2xAuJSopHO/fUrmPOmIYzkjENakxjUsyYBs+wEY5wjGMc6mDH9/IxTnKW05z5OOM5z5k9dPrDH/mIxy/IZ75J1DFpeATLIPZoq1xJrS0jslpeBDmsre0vRohR5CLPRpmyMVJHRWigIP8MmK0RlpA0togFIq4Umlg8iRAcDEYtIoEuK3QiGJ8QxAX1gAQgGPA0fcCC42p5y+Xk8jnCFNhG7vQL7uykl8PoyEUehtOHEZF1NHGGTN5zPPysBItadB42uPGSoFmjedbYpjzooY99+KMfXwWrO8U61rHqwx9lLGf21Hq968UjHWBcxzjKIY5ftEIVc9xEJSphz1etL4/uCwvU0vKWt/gxDIA80V0EqpdCFqtYMPpaIpsVGbKVLQdoa+jZeHBJJXH2kq0JpURdM0kQapBbVkhFLLqkGlHGwkqZWMUnQhvKz8wLEY4zUzR0q1tn7Fa3z/htcXwxXOL2pFND+QVyfUL/3NFNMUCb+g/MNNUfnNAEeYtCCciqsTNt/Kyb6gAnO8RLj3GuVR7hLKNXwQrWf4gVje/FBz7yQQ/xyuOL6cBvfvWbX3jAoxzl8KY4wOGLVrCiFKPQBCYakb5YZWifHjILW87CFrhQwUSBHKRdHMuXYyELkctywmQr6xgSl3iAl93s21xqpUki0EiXjEQoXaqH0SBhbZmIxSoE8ZkXfzI2ppWSbkSJiErgQhrHiQZwRxINyREHc8nJznABlNygFMXKPyEKcpWrE5oBQ3kyye4Wn7eNcEgPvPYNJ3nHadZ+eNXNbXSvGvnhzq/uw87vsLM95sGOdajDHH/25p/N8U1z//z3v+KQnqER/V/9zlXA+GV0OsoBjmG0IhVFu8pe7+lXDT3YVhEOg67c4pa4ADIvi9XwhgvKv68l9FmVHXFDMeuY1Rhpba2RTSpVbMAgM+k0Ygrlu4SMLT2EUsdfwmRsKpiIUsiChcgwhi2XEcxhLGdgnzPIT3rBi2176ijHjZl1sbtdnpFZHPilXvXAlw972MPOXVXveuvsznzcAx/2oAe+6bsOQAvam/8GuFwPLQ5ulhnRBzc4wcMx8IM33OH/BcfBv+ENZLzi0giuBCb4aiF8aqhWEI4fhb9AalOfOsMtcuz+IutqAD4mMiSeDMwd04Me1Lo1vHGpakIpY2514v8TSLDCuwSBJT3weDWR+MQqOqEHnwuibcVOAiA8o8FM9IETtegFMZChdX8l5BilEwjpcBqz5PqEijmxWZix2t0uIjq/X2SHVs8r3nJ+73v32Afe7fGOvbejHefwe+D9HXDCj2PQhR+Hw8tccG5+4xuMD4fjHx95yTse0dwkuOMdVR/He6MbxHBFKh60CUto+o6wktWDP8QWXY2c1FVD9UD1l3LIGoblizRx7qE18x4IAhC2Xo0GQ5O3SJii2J4BjdR/byREIF02bFOt34q+NomCxuimTUQtUpGKWgSjc8QgnUNyCDFFoaR55PZuOd6Kve/hQx/lNGN8863vNNNjHvP/EHT+/91NcSR+/91EvIBbNEPzJgJUtH9TOMhTwMbjhi76hgZswJeYqp3BBt2phpzpmJoohmHohdA7BVEgPUrYONRTH48zBLLAA7MIEVF7Pdg7ub7gsA5zAv8RsVcrsRvcPRKjOZoDPtBojQp6Fy2RFx9kEtnAMSyZoKJTutNgOnfRINmoEisAhGAbukTwAkZghWDInGAIhl7oBV/oBWGoJZfwBvyqh3N6vzREJ3Qyq/fKt/u7P3fgt8MLwAVkvAQcwP4rPEPjw0Tjwz9kOEdrvAf0GZioQKuyppRgBk4BClExkKaQilIIhRAcQVgpQacZCxRUwQnzI7kgrAu7H62Z/70Y7DDbExtmwT0cVEUe2MGayxZsOQ0yWKDQ2CjQoK2lA40tcZckRARTkARJSBen6wRAQLpEmLpb2zlEWBtJWIVYkAVVSAVPGAVPsIpLeAVkiIacwQZwUKtuVKt8OMNwBEe2si/9Uod0OEf8KjS5YkcAc0d2HId0OLg/LLgBLIeEm8fLazhHczQB8wZwsI9teImdscBqQJmZwInjChVHPBCogIpa8MBQAIVNEMGN6yuvMIRM/DQVTMGomRrCCpbE0ouC4hoZRJZWO8WxeQweeBbea8Ud9Lna+qARKqlPwBKJypZMkg3cOJy/4TUvOKFUIARbsIVOUK0iNEbWKrYGav8N3KgEIquEUUCETKgEWFGEULgFariGneGGt3Kr/QKwg0s8QwPL/TJL8PIztAQvMDpHtzIHSWu0SIO0PES4yvOZbaBAbDi/RMzAltEImqGiLNsFTzmQo2hIh4SKWaAFiJQjibQES9AEi9QK9gGsjYyDEJmwtKCwLvgCzvSVL4i9wPiLwYACJ4CCK/CalETFlmtJVnSWHggC2Ew6TcI1QUACMcGNGIsxiVqbUOLJcuEWKPENW8gEUzAFHKuS2AicthE6HtubXHSXXTycTEgEThiFWaAG3bmGl+gZCAQahMNHh9vHPGS0PgRE9csvuTw0R9u8+ihEQ9yZ85PP88MZLJL/lCRqhoxhHY64k+EyrqQ4zMSchQFVzFqAxjmyBEyATItEvXxqn7KAmo6Mny9Ygy6ggi7AUCa4UCpgAibIGigA0RAVUdOEEdWskf/JkVYssdeMjM/4QQP6rNywPiPRDWzhm064m1QwRiQotk7og0TwxT5YBaXzm47KpLYBjSSdoMOBl550F8NxF0yghWUAGe3MS2x4iSxtQMkDSEdxuIj7Qz8ERHkUsM0jRIGET71snpzhS/u0TzYNmQvEQPtEJpVRGUExj2GgNuL6Qp/YhaQwTKZATKjABVa4KwR7zMhksEs8wRO0ldUTLKnpggrFUAzFC0v10LpgAiiQAikQ0U8t/03CUM0jkCzEiM1WBKBUDYKlW41LCjZbWFIes0Ut6RIi7ahQWo2P6r7DCYZM6BaS2jEitLWhM4VViIRY6KgQWtJEOJyrOwY2zU7dEZlr2MorzdJr7Zn6cJRtbU/3nCpDpNa9ZNM2ddNylZRxzS441R02lZRowB2MeQ9AGaIN3KlfGC4v7IVdyNdd4Nd+/dOj4FekwAVcgMhD5QTSk8zJTL19Kou0ALV/6gIxGIMxqFQLxVQUgYIs6FROxYIRBVFRVc1SVQJVXU0RO4JiE1ZR0g2/2TGh0xK56YTbEKWi3DUcq4VOIATjMyBjDK3QEDrr+4Tj/Jsu+Zu/cZe/GQVc8P+F3tKtaJVW7aTWqJXaqJXWNWVXSVmUjVGmZsKup5pTLPKtdn2qLJoG7XQiaqhPZ3gGkrCijIiIiRgGYOgpex2uXbhXL+xXfN1Xf/1XoxhYWTAwRK1IO5pMjHRUkHuDCNPMMIjYia3YgMrUu8iCye1UKehYUA1VVls5UjVVyEhJzz1FDRK+YDUg3RDdCQIcY1ylJmhG3qANdHmbRAiN3TDGGPO1SmKxCdobb/kbpDNa1M2EpPUFbIwi4XGiccXARPHLZIgZh/kliEmG/Cye6R2Jc+VL5MVea4JWasrOaxAZnHGiJEOmo2oduE0InjhfuvUFvu1XQHVfpLiFVwjcTaj/o8hUVAbDyMq8lY6UUF0Rgy4Yg/+tVKux1LqggsnVWCy4XMwN0chSggZ24Ag2VQkeJSEDrdnSEtkdKRYrNhrrrNFooJ17kiv5wSRkMSNhVjBh1qLtyb85Ttjiwj25nIjosuSaMgLpiZ7IiR1SCOj9CJCgXmfyWnOtz3TNGaethmtAV5LAmKP6IYWAmbj9T39Fir4FVAXZhVc4VDqqJ/u1I3w6wfZ51BQk48wMA4kVYAvV0Au10LxAYMtVYAb+1AcGVQm2YwdWLdLFlhrVIAoquhNOSre5OSuwRSPRORi9uR3jFtKgTgnylrYZWr/5EkmYZFPAhWD4nZ3YlBs+rk7G/zKeGC47Aarz+OEiCgnc0VqtJeKOGTdt1IaTQZRkuNO3dV6dyOFO/jYc3omHEYkqvQZquAW7wrhGsN+E7Tgx3sgylpo3WIP/FYP/vdRKnQu6yAItQODJzdgskGM5/ponsGNvjuB3wZZLImTqvBIusYLaEl2nC4ZYeJsX84zevDkmYRIEajofvBJJ8JZUONqhHdqjDSFTwDphoLJN8eSDprIcJq7hGuWggoiIWYb8ZKpUVmX7xK5m0IagSQma4Gh51RSy0zIsO5X+iF7mmVZt6IZ/fJT+YmmW9oZdsKtSKOZiJlwwZlgyTkEKCxE5+N81oNSIlWYS2QItIOprRuBtFv9ROo4scI5gFkGMvUCMBLo1o/yMLUGlP2aNSzJKdElS1sBVGtMDHJOXd4ktZjUFJinaL2nhEPI5SMbRWICQWfgPRbEupVoq5MEPhM7hnNgI6CLpS8EPICYeZkqiQ6FoVp6U28mG+pgG5NkPm1CqcyU3bVDp/gKjy4aHeGhpSeNW+2hAz/uFV2gFma5fL57MO8qn/UULZf4nOWjmZxbg/+UVLhhqo9bmo07qlaNjKFACqN7cO/6azygNQvYb4WZV6vzB3Pgs1lJOKQnCtfG5KrHFPx465jSFTzDSngyctE7rTOAETgCFXICGq7Iqq93L7MKimuiy5uVr6KKIm/iymVD/D0qZ6LvGa/noS+Y5GZCZhkXRrrXbhvrAL8vG7P5KB24Vh4C8ywbsTgjkvDIDh3KAh24I7bvihNK+3624yK+olQ8p46hxbdiObc6cZtq2ZqPOZmzG3MgC0d7mmr/g7W5mageuRULGFtnNlt60TQP6wUxahbBeTjDBZ6RDqRntYCP5hF49Wur85x2L2WBYhXbmhEpwhVhoBWAY7zidT4OsT5AxPzl1BkwpKuf9j6IalP6wa/mwa0RRlPtuKkmRzwoEBlgABgPhBWh4FK8sx/ySnsv7BugBdIGkwDQNdOhhcOhxvAXnBs8bBi0uhQvv4oTdiq9YBDHeX5w+i7MIcdiu/1hLxYuhLoMrEPUrSLlSh/HcbnHBIBYRXREY5Iuly4RUIOTQWg2mRCDeKLbRillCtr7g811cpDrqNtovKSHiPByWnSCitIV2bsZYKAVV6I8s5/Jreg+8Vp5iiIiOmDb0kJj9UKr7XhS79lr51B0sjR71u6/qAQdo8LL+zolGAYcHdLxCp/d6B/QrHXTuBHRucBQIFMhuuAZfcPQpJ2bT1gq+ypBKt/RbgdDMbIPXfuZO74JgAfVQF3VTTzmkBgy+YHWSTLm9AEZkRevZepITTuehkxsrxG6UlVGXSoXT4LHP4DGdy41OkAYl9xu2Tjok2RJpwIUpD4VfsK7ozQmRpv+ZWvbrjaiYO71vN/3vcvsG6cEvcjQv+0JLuJwrb4CJ5qFWyuY8B7R3vMzLNMX3K6XWp3WiDGTe5BKGYH6QBJsEOjL4+8WnRah01Wv4CfPIjwRJKtgCMyiDwB91Usd4jJ+9DRPRwk+5YkNuFqugpZt16hMEU6ikjkoEjfIM5dw52Qql2BDyYJVdp0M6KN/uflbrL4lyW7CKR8iFnFCqKbNXHSKu8+Uy6aoZcevaKsVSfn8UMLoeb8ye60HLAFu4wiu0AexWgPSGcpD3Qw/0CLzWvKRaOWXlRUzIonDEAb0FWnCF0bMESpD7DKd7PLJ7j/OQvM/0xR011yO5irf4i1f/fFP3eBZJ/PiPAtxgVhKOsdjgcXTxNbYBCFOrYmXqJCmRID2ROkUSFClSJkEIGWaKpMdhwoWfPmXKpKdgx4KfOoXMpGkUokyVOMEClowZNGbAitEcBuwXTmA6fxVj5hPatGrVsGHTxs0buHLp4sWT5/QpVKfx1KUbpzQd1qxatVJVp84c2HHjxGEtB+4s0m/iyn1Taxact7ja5tLFZs1atWnQoDVjlqzYTl6CBwvWZfiwrly3Ft+a5RhXLVenSm2yREkT5syTJmnaPKkR6EOLFh0qbcjQoNR79uBpHef1m9hhZtMO84VLFzNayvC+4vtKluBRhhPfsoU48ihPhkNp6e7cOPTjyTMlIoSIjB7sFQUJskImEkIrDhMlihXrU6pEFzt14q6w00U9Fx86jGQFkMJVn4J9UpiJI0SfxMIegR150kklp6DCy0t7KWNMMb8IxlMxxizTDDTXgAMPU0zJU488TUHFVDrlmHiiieGEI9Y4XqmDoolbyeiiV2LFU6I4Z53FzTfhqCXONkESdQ1e0+jFl19/AYYTToTxokthhvWyC5W7IGYYY4tBxspknlByWWaadbYZaGWSVtohp502CGt4vOYmbLPF9oZtXOCmG29l/HaFFloE92cW0SFnXHFZOAdFoNEpalxAACH5BABkAAAALAAAAABAAQABh+a9ntuwkNWpitKlhs6liNCihM6ihc2hhMqhhsqggsyef8iegceegcabfsScgcSafcGbgMCZfcWWc8GWeMCWeb+Xe76UdLyVe7yUdruReLuPbbiTebeRdbaQdLaPdLeNd7iNbrWNb7GNc7qMZbaMcbWLcbiKY7SKbriFWLKKcLKKabKIarGFYa+KcK+Jaq+Gba6GZa6Faq2Daq+EYa2BX6uHa6uDZauCaauBX6iEaqiCZqSDbKeBZKSBZ6l/Y6d/Y6p/XKd/XKR/Z6R/YqF/Zah9XqR8X6l4VaR5XKJ7Y6J7XaJ4W6F8ZKB7X6F4YKB4WqB3YKB1Vp97YZ55X592YJ92Wp51X591W550W55yUJx5YJx5XJx3Xpx2Wp10Xpt1Xpx0WZ1zXZxzXZxzWZ1yX5xyXJtyXJtxW5tyWZxwT5p3Xpp1W5l0W5h1XJhzWZR1XplxW5hyVpVxWZRxVZpwWppwV5hwWJRwV5lvWZhvWZhuWJlvVpluUJZuWJVvU5NuVI9uVptsSJdsUJZsUpVsVZRsUZRpSpJsVpNqVJJsUZJqTpJoUpJoS49rVI9rUI9oU49oTItqVItnUotoTZNlRI9lTI5kS4xlT4xkSIllTohjTYVkTodjSIxgQodgSIRgSYRgRIlbO4NbQX9gS39dRX5cRX5bQnpaRXxYQHxXOnhXP3NWQ3hTOXRTO3dQNHJPN3BQOXBNNW1OOGhOPHBKLmtJMmhIMmJINmZELWc+Il9CLl49J1lBL1c8K1U6KFY4I1M4JVA3J0s3KFQ0H080Ik00IlIvGUwwHkozJEkyH0ovHEkrF0YyIkUuHUEvIkAtHkAqHEIpFTkoGkIhDTohETYjFTUdDS8fEiwbDiwZCyUYDSoVBiEUCSMRBSQNARsSBxoQBRoLARUQBRQNAxAMAg4LAhAKAQkKAREJAQkJAQcJARIHAAsHAQgIAAcGAQYHAAUGAAYFAAQFABACAAsBAAcDAAcAAAQEAAQCAAQAAAMAAAEDAAIBAAABAAEAAAAAAAj/APkIjIJEgwAYUQhGyZJFkKE4mKIUSdMpy5IogmyIYrRn0J4sR4DgAFIECRIcNFiwwBEkCI4ZI3HgQBLliQ5Ow4g1a7Zt3rZox4L6SrZqy8KES57EEcSHYcIsaY4+uVizZUsjU00aQRIESJAjQaJ0DWKSbMsiRWQWAcLValeRQGjIZTEDLg0gQFTOUBkXSBZDrFi5YpUKlSlToBJ78mQJ0qI/f/zE6dJkiI4aNVyE4GBhQoMGERokICBAQIDTpksLII0AAQEEAgaUbvCgwg1Vy6xZoyYNGjRmwoRpC1dt1apZ2OjZW4dunPPn5p5Lly4OnPXr1b9pB6f9m/Xt38SJ/2vu3NkpQIDeSGnRIYeIFjuI/PEkChUuauHWzZtHD1y3btts44033TSVUBo4KPDAUQsxZAgjYzyRRUIExdFJIYV04ocfdSyBBF54tTTDXV5Z9dIMMNH0BA9E7BIUND1tQ40ywxQDTDK6aLHEEUcgYYQST1Eo5BItPZHQE2UFYcQSHqJF1hJZBBIIk1RxtUQghgiSxkkwtRTiWyOSuJdcJ7JgAgtA7AXiX6m4MlhgqMR5mCigeMLJJY5M4kgik1XGAw82qBCCBp3VFgEDB8hm2mkBlNYoAR20YIQNDSg6wAIPQLABE6f0cgwzyCAjDHDXCLPKKKPMMs48y0U33auvVv93nXXizdrdd96BI8446JAXDjazRJLeFD1IQUQNLdTQwxqNqHIKLMV0s9883XDDzX8BeuMUVFFYMIANafCx5UWYKDIGEkoUgdQYYygiiCiKxDEGiHjJ9BKJZC3kEl0jtWRDDa28GM3AQA1zTDHBHOOGh0eghRVSRybEFUtTXeTWRWlE9UTFDTJpJJFPppGFSyba65VINIyI114osqxXXHLRcEQahoTipiuvsKIKK6gUdhgon2iSCSeTQJLIHGts0YQSQ8AgaAcYUBD1A4gqqlppBFDwAyeu5JJLCKo96sAFG4iwgySr3KLLLbywPUokcM+iHz2uwjqOruJVl/es14X/E851uXK3Hd7NFT5OON0Is8kbb7iRyBZS9IBZDkwc8kkrsNyCH7XaaHPtNtlsw0eWfCRkgwEPJGXRQnwwEkcUcUSVkBJGCCKIIpDQPlK9e9FFw+75ijRivzjY0IIkxxAzsC6z+KLMMsnzsgwoQBKElhIbB5FUkiwl5ZZVJSGFhIfflx9W6TKVbDJKXZGYklx9vQUiX0dglMortMQSGM+B+Qz0J6DgBCeMNgc3dKELTxiCDVYQAqhBjQIPWMABCmCp0lDAB5hIBS1cEYOwlWYAr4EA2S7QgjeM4hTGWQXj3hAJYazDHvYgx6vAcTda7Y1vOMSV4LqTK+f06ofjWMc6/8JxjVm8QQ4ChARlhCCCHOygDZpARStk4QtrbMNz3NAGtjI2kKaAgAA2mBBGGCEQMMThdeNDQhaQUJIxdMIIMEBJy1SiF+LBJERwcYkKaiCEXSwjGtSgRjKUQaNjJMN5tmiCxIKQlpbsrl4iGUlZWAI+tBTBBpQEESMtaa/0vUQmM/BSJFFyl5TdZUwjuYtLUmKC3qVIEG2KBS1eQUtWvKIVOpPTnDyBCT0VYg6SSaANNNOBBhZKNIkagGwMMIETIMETg3jAohilGgQwwAEOIIADNLWDSIxiE+nxpjSUYw/xjMOcf5vV3gI3OFxpx1o7vNWuzGGOH6KDHuKYxxC94f+LTWwCgKKYAxHWw4EWCEEOn1DFFHlBjW547j/cyBglDPEgRjyBABPggxESIog4FMIPYAADH9gYlSJsxQbyKkLK6EhHFbBAlSf6SkhQ9BJB1cAWx/ijNQZJSEMS4xjDWEMVCAIEG8BAeDL53e8eaT5LpqUILpGJVxyWFhvAhCUngkEc7dUyFNExTMODWe9oMAI63gUJjHBFLNQaC1q69ZZw6pkp6MQJTBgNEoWIwxMmJagTDOqYCpggAQZggAMk4AEccNQ0G/VBAhggAVjDZgR2IIc3AMKb2uBPOWuVQ7zp8FbxfCc3vlGt0eZqnuQo3D3twSp9rgMbuhgFKQQ4iYH/tqBsNWBCIz6BChQGYxv/+Y+4OmGIgTwBA2BcQhz4oNc6YMIQSCgdWkxShBmooAiMgAFLv0qXsLYvlTC4KghcUINPKCMaf2yGMo6x3mQkAxjLyIQSJqZVUCoVJY/sV1sc2Un+toSNnLSqJ8NLya4qFUWahMvJ8KJKvZjgLjgQBC1wkb9axOLCF6ZlK1qhip35jK6TIBqfumAZF7hAUCDozAQekIDAHuAABCDAAQxggLAxipqqAQAATvOasV1gB29YhbRYZavv5JCHSEaytZb8Tu+Ew4f2HAcMWbsfeswjHM041SeKNoUWiEAEZctBEh5xCVOcwhbRGJA3DJEGSvDB/3YLsUHWlmCEMcSBEYPoRCcMhJQlrEAFTjNEEFTg0u2SKI/2TRmKbBCCE4jgDsP4YzSK0YycBuW900DFENaCA0DLcUSgjiQeRWKiq5rILWwsHibtVd+S0RRE8APRiSBcIhHdZSWMZAQtfrGLWNTi1xhuq4Zt2T/DBDCAkzjaFixjVBSrmDYL+MwCECXBGTvqxtjWcQB2vBrYIEAEo8hGOPjDDR1yJ57cMW2SlczkdJcbyr1ah3OmPGX+0IMe27jFJjIxiUn0oAVe3kBBZYAFSJhCisDIhjcMxJDWMSUEDMBuJ6LQCUHsGRPEnWgWVAACFsAABFEwxEvowhdK+peUv/9LCw6KAAMb6GANv5jGNGak3qAcDBjT2MUWjICDj4OAXvQq35f4+xK3sERiJoUKyDAShVrv7uljqovL9BISpNKaR0gQRS6MsYxd1MIWtqjFhgPTYVWggjCpOIwphibiAk6B2cTEQAVY/ACqLSABBiCNMq+GmqupRpmELey0HRCBH4+iGd4YYpXJaY94M2eI6cSh3yYPjsgLrvK82o8QNc+r5/SKV+hYxzZ6Ac4/HEIOTMhBDS6AgAjo4AkG3/AtlkGTKITr9oZYQgNWsBQj8AETmGCEIRaShiWwoOOABjQl0oSmveCABUbHastWjgMfFMEFNvhBE2Ih8xn1NCjFUJ7/MubAcxacAARQlV/Qy0Jq7XEpfV0yS1h4bsmWOMQlRzkRilZKcq/yK03Pp2h5ARcmEQWpkAvDMA1d92u2EAuwMGw6Q2yEcRikUCeY4Ah/4AY7p0AucAJQs2IUAEENwAAJAGMGsHd+53eAt4IFUFivQTYfsAOjUAzeMG5zA0PntCuUt0PWQXl+c27fsGTXUnk2uHlCVDhCJG+9cm+HEw7R0Apy0AiH0AhtkANeBgEiUANJ8AeggDmwEHKGEAgTJQiU8FwhMAFGkhBuFhUzEQTHNwLWpRIg0BTOxy91IWsQNgMwkHJD8ANGsAI2YARbwAndR0jrxV7upQzWAApGkBd+/5V+ogR0stYvLlEXjtRVaGFyrBZKM5Exg+ZKvaMXUqcC+0dHI+d8/cIWWpeACrgLYScLsvAKGYZLGrZhcmVsIhYHa0AZQ5AZIRA1GBA1c9cAd1eCJ2g1KfhByhRjNJYoPVY28DEKwVCDN+g5QXgtwWVa5uY3wQVR1hJcRPg3+cEczwF5+TEPoOc31kB6kdAIkfAHTVADOaADydIDaiAJnxALRyBGYiQQaVAEu5eGEpMQeQECJmACI0BohEYDlBBe2nUv9CJV/UU7RgBHgQgGc5CA0WCIh8hex0ANtdAEbggCIbAWoyaJTwdKV4VVRodJjhRe0xdeacKJLLMXhdYl1v9FaCxVUypwJi/lFUsgCrtmDMbQiraAC2HXVrDwgLHQCre0YamQCoSBCrOlJ3PAJ8uWA5rBAQ0UjBQQAQ9AG8iUd6QRYyoIeI5VWAcQGwaAACLEAWDWAoDAC9YweZ3TOdjIDdiADXiZRZ2TDZ2zl3t5DYSJDdlwmH3ZOZh3TuHoN+jADujgZN3gDdkQLJnwB4lQCDwwBUQAcDtQOZ/wFWzUI2ZhEiDwACbFFeMjFhyHkCagAa+JfIwgESQjVeonEmjhFUqwm0oQXmHRBbgwDRvJkTbXDNFgDFPwfH6FkunTFiYTF93VMmAYBSv3BKW2kvYSVSihFyygk552IjoZik7/05N1BARPIAquQAtegwu7sAtIiZS/JguwIAu1AAsXtpQKlTMTiGyc4AhzQBmXYWIpEAIgEIwTQAEVEBp3N2ODtYIOuozMWBoFgCmEx3oQoClvMAtpZpih043ZIJiGCaIhig2EeQ3VUJgcCjqG2TndEA670pj58RzX0Q30EA7I8DaNkAiOcAdEoAZEkIVCoAVxERORpD1PgAMMUJJbAQRNNwIaAJsgEKVOagKEBgaYQBOYVC9B8Dv0Aom7aRIrUBdKsAWqMDAc2VPJIA3NMA1+EF4ctxZkklQpaTKViJ3aQyQrB1XpU4mAhiJxNDHbFZ5xRFNOUxfbqZCiqBJF0Amg/yAKqSAKn1AKrcCeu6ALYFcLsNieDeiAt5Q/+pl2oFCVieAGlWEDzRYCBGoBwZigYSlBNEZBD/qgDapMB7AA08ZjrQEBTLAK0GBFHQo6hHmi1VAN0iANw3qsyJqsw1qsxloNe5kN5RZ5k+c3NWQdMEQPlQk3kpAJl6AFQiAFVpgDaWJKeVQWFtAAMKBSLLEXT2oBT/quUQoCMIAJSAKTLzGT9UKJ6LKbRnACKkADQaAEjlCUZ0pIyUANzWANpoAiK4B+KNdJMlFf63OHK1MiahETMdM7gFZHcRioK9FVWuVSaZImhDYCCelShAYDrQN8nEAKpHAKurAMCvgLlgp2v/+wDL9gYRkGbG3VP6yAGP35n01gBByIYhjQARwgd2C5AArQtBM0AAUwWLEBQjFmlsqoTAagYzvWYz+2CsdgRaCzDcrKrL4RDdBgtmdLMNIQDcbaDL5hrNdwmNigbrmShH7DHOgwZTUqDG+jJ5jgB0nQBP+2f+4zFjQBAw1gAU4DBE7KAhbwuE8KAk6qAR53AorAB5jEcpYoVetHPmkBApQbsFqwC+i1E2dKDdFgDbbAcg0rPFeFMoomfam0uabWc9Q3PDbpUjmpVVrlSiqhkH6KIgqJsjYJAioQucMLJb8nCpBKCqoQc9tgDdEADGujCwPjdQ34a79GC55aS6gQQP7/eUBMY1TEJAJIGzUU8BlNG1gFELWysYyAZwCMxVilobXc1hrbtAOnkAzWYJi7Qay9AQ3FWrYEU8AG/AwILMDGSqJ8WW7XMURJmIT5kA/XOg/VYJmTgDtdkANDwLlT9TBIggQToAAqMGiEhpDv+qQmO7wwQAk9l65BQFOPBEky1RV6SDFdwAoKiF7L0MOEhLrLMAw5cALnV4nkGkk3vJvTxVUs51TFk6f6p4cwOTwr5X9OM6ihxLtOoxcr8LvGa7yIyqR80AnMawqkYAqlsAvTICDeYA3P0Au9MCNLCQsbpmEdFic6YwqfkAn+uYtGwAMwkALnCzUXUAEQEJYJQIwv/2a1sTq1gFcAi9wartEaDMC1O7AKwGBFA8LGA3IN2KAboJwNoGwN1TDKn2wNJjqs2RBc57h507If7MAO9XBv/HFlzHAqmaDBNiA8AOshGzUhbLQCB/CvCpnCKSy5KpCQKhsFLZcWvHtH+TrDz6cCNhAETdAFnMB1zdDDPtwMqFsMy6AGHfCk+8cyXgGx/vIET1VVLWeqvOvOmKSHCqlVLDW89qzFerQC/qoC+jy8oKsBLPwEv5cYh4EKn2AK1isgflMNwlAMytALtgCLGGbHqpAzqgC0GOgHvAgDxNRASVsBCQoarYp3VVu1LPjILXgAkkxjzdhtMMgEpbAMApItA/9SyoE0yoEUSKWsGyeaysx6oqFzLTZ4t483D/WUhPemHxcMTndwB27gJS1BJQySEhagAE4TpZFrzMiskEEQCC8Rz9OXVPvnwbxrzWCwBX7EkcugDAkbDcQwDaTQASnGpSmTSqrESEjwBNhDfWgBAyvAuyvw11rMuylrzyV7kD45vCrRdIQWpfYMxqDr2ISmBAPdqIfxCZ8As9EgIOvgDdsgDcnQNrcAdq9Ix5jTs2ZXlckWB8s2TCnQgaiatBgQASFYd4r8WAzqoO3bvs3YjE7btG2pTTAoApwi09myDQrMrIE0MNVADcNaoiY6wM/wtidqmMA1rU/2ZEdoT6FHLbz/ICyA0AZWYRLjIyEToj00oAEHYMzsrQFg3NgqMDJaZVXYCbEzHF7V3AVuMAStMJzPo17Q4NzIsAy20AKD8pMJZiIuiQP013JwJNiDDWh/BmghG6gnjNglm8x6cbwcl7I5CdlYDdAwoAR+gAmcQB+H0bKZbb2+CiAy8l66EOOkLZ/22Va4RJWcAL4a/ccwAMiwDTXBiL5hSYLF+LQsyNssXVgKsNsKEG3Tdk0X4AFwWQObMAy68RPNwAzQ0NzUsBs5nazBCsADvOWeHKIOHDiX53mrIkTScAqWhWpJkYZecQSUKwGJC7mEotUKGa/ao8WZ6yR0ln70clVK0AVgYAST/8DWypAMO+G2u9EMxDAMRBACKmAkGSMWLSEy1rlyLvFUNDUDEO6nft3ML9y7c3TFiJ3qJNed7q1dITueXwzigKYEhTAJJt6oosAJmsAJn7AKvZC6/bvK2/DJahoMvCDjmMqzOWMYQAsJIFUZf9xsfsWVQF7btEE1xkhjULvbLL3bu/1iETR4DvAAEYAAPiYCkRCzA+O2zV3KynqsPj3AYy4NnvyhnvODldcNp2Uda84c4ZBvo5CdZJGGMzEDGmCy6u2u7prnkRuvkQ26JTwD8OxUF0HeFj8xAVsFXbAFa0C6bL0TZ7sb0OALy3AIxnt0UUAkJkE+eaqd1DfFvatVgv89E0gQ8xZeaAdpJi91fB3+3nve8w6vk7QOCSGWGKIwNKF6Cq3gR12uogGCDdE7ab2wNpdqYbUklYbRduI7BD7eVx7tlbRddwygACU4YwaA5NquTJBMlgxQARyQAQ6AAAmAAKjBABGAhXKACx8ZSMZqDcXa3KAcosTqGwq8rALc04bJDdi9+OFwb0k9D9ZwC3s68GIRBdZlkE/6AArwuAvf8O0N0KG0alSVmuRNJUZyFthTE03QCmsN8iGPur1gDKZA6W7BnDJhVKrmzDDp14Hd+xLbu4janYbNwh3ucXuO1fHq3v/s3l38BDoaYp7QqIpw4qZw0a1gvTcdOgGy/dL/S71HCZ+zCFfNviGszTQ6wNEmhqrni75gKW0JUPZJfoLMGGMOkAFuwAmsgAueUO4EoG2NYu4A4QBCm1rLrB20Vk0hNYYNHUaDBi0aw2jKlDWTKE2jNGrVpEF75owZMmHCgkV05szXrVWjgrwMEiUKkiBIWGhQYQKEBg0gBjywYIGnhhEjhh7tqULFEhxFnBYxYuSpESRVgwCBGcRpkCdGhnCyCO1Ys2XRDlIjNqwWjxAzcOCYwYIGEBwwcdiAkbfIXbwr8uZdocJvYLx4VcDAAeMwC8ZKHYMAoQLyzp2KI68IrKLn5M07k8aB5GgSJ0+gTCmChEmUKVStWvmaeBBb/zZs27LdtkZN2a9dunDZslUr1ivhr1iZAsVpEqRCcbooGaIDho0YLk6ECNGBAwbuFCY8aNBgwYIDBwycN0BAPQICDoR8irXL2LRYCAQgAJA/QAAB7SE4uECN14gpphdeDjzwFgUXvGUWBx1cJUIJT5EwwgcfVPBAkJhhZpZVdNkFByOCWCKKIOrCgQUTVAShKBAaUMCzEVp0kafIHDuMRCRk6gqqvWzw8aUlkHjiCZpqgm6LYaZZpiyKoonmmF2GieOwvGygoa4TgXiqCBtWeOuuGf4azC8Y/MIrL7fGZIyFGWZwLC+lVjjhBMEEO3M6GJSIYYUQTshzMhBWAGE6P/8SgWQ00kRhVJRUUmGFlVdg2WWZaaixZrZrrsHmLIp2AU4WWEZ9pRVWUEFOOUf8cGOL6GpooYYaUhBBOwwu2I4CCiIAbwEGyDPPgAEGUI8AARy44RBWcDHGGlxaIIA9BBA4IAEFrh3vggw2EIGJUXppJlxoqslmm22q2XTT2bZJF5t1u4E3HHnDWafeeudZhx597bGHnmx4CeYYXaCSaYkhcaArLhNGMGFFEBSwwISeipqxRRwPe7OmEqMw0semmhqxpple0vKlJmgx5hhlympSmWOG0WUYUNyaDi4ckKiLrpr5+guGN8fM860zbSAasRPhYgFHyOTEzDPIlOLuzxj/QtiOA+xc4A6DDugEoYhCHEkUk0VBYfRRSF8hrtKGsNl0IWqiKYs3XHYRVZbhTE0lVeUSiWMLI3ioQYccYMVuOxA66I6CBxYXD9jziFUPghSEaCSXYUzZYNr1qK3WWgUWSMCBDETYIAdAetkmnHlW19fedVZffd556w0HHdfrLYcdduiZh53c67EnnAOP6WUWHJ6IwuATf1aR4cZYkKCBoiamGEc14XKLKyOlcgoHGt4Ms+QwSbZhklpqsWXuXXD5TZZWdnHFCMVsSEyFpqpCYq8ZiL7reuyDToyZ1PQmGCTtMRoQCggsAJmgWAADuqIAAzTHnmIJwIL84Y96AuCC/0SgJlGc4AQoyOaoR0nqFbGoRaUuZY1obORtzVAGMYDxi5j9QhY3lAXaWKEKU5CCFKrqmxR6MIRXwSoFHsCOrTBQASbySjwJMM+wCmCABVSAAiVYxA8ioB4BZJAA5ymPtQaQgAU4oAIZ+IAIRHAIXVgDdvQAxze+MQ7b0W4c4aAjOvSox9uhoxzpMAcf0WEOeqxDGLdQxjDcR6KXPCEIPlMBYxq2IgOqoAEWYAHFqncxn/nsLS95SphoMMosYcUun7wLD5qAClSoohVoYyUrTYGLXPiBB38J4Ay6BzQgYQYzSjkBZxo4zM4g0AIPGMB+lLmf/DTTmc+E5jP50x8lFP8iEYhSlAjJZjYT0uJ8u1DGRJqRDGRgpBnFIEYvgNELXfxCGbrA4XCMkwpZJscRc1hDE7bQhCHwQAc1cEEKUoAdD2wna7oCDwOgWACGFiABCTAAGUF3gAIMwILFMkAYE1CAMDogAmf8ALfecItsrE4b3PgGOMaxUnSslKV8zOMe9WgOdtRxj/SQBi9cZotWrAIIb/oeYzRplKEYZQQNkMBQKUZJpTCmk4dRWmQsFslKXgwyHfCAIy6hCW1OIhNfjQR8tKCDmiBGf3DxpM3eQr+3zAAzZ5KMjSZTQMUoRQMSWJwE9DoBC0zArxLoKwL9yh2DcoADHUAsdrIWAheEAAb/ifCDNT8YQhGKAhUlNM4JazG3YSwjnboA2DFk6AsEqXMYwBFOLIbDCkjxEBSZcMQf3OCGNewzOjZwQXWuUyvDcmADS3SiQstzAAVQ9AALKC5DLTgsAgxgisM17gIaQMYtTssBG9jBKqrhrpPWbh3sAIc4xCsOl5LDHOc1r3nZcd71isN22LgFWeAJi1MoAEYVZegAYHQtBTDUvnqVAFEYxrBJUrJNLJCTBvYjgAEQtwEP4MkI3HSxx+zkVmsQDQg5ATavZoIUv3hFHPR0syKowE6Iscxh6IQnzXBmKJ7pjKBuFFepOg2BPQkmEhsLAoMeLgTc6cAJrPOEQkQWm2Lz/wQmKntZSakCFrEADmd7cwtYzIIXBuIFaNkJDIH9JrWrLZUqUJGcSVxzDq3iJw+IFoPqtOCIWEXcAxX3gF95jqIOba5FGczgYTl3isIqT0bDk4AFI8ABANrBKISxjXito6XidakeY8rH1zl6HIFchzZ6EYxosNMWqzgFTjTwAMAClifDTKBmIknUoixsqZxUzIuJYtfITDiqgsJABpKAmkp4whOocYQkMlGKYxjDFD8wzAkIhSe3RgZOkhHUUYSiAUBxhjMHhAxSpP3ioPCVrwmEjF81EAKlpIERfChEIRQxiUlgIsmlsWxrYOHKG6ZPF/fWxacpVOVbHMgXuhDt+v9wcb4v1yLMqCDFJzLBbr51wW9E9Kes3CxQ3iYuoQwwT0WJZcEL8rnPfzZWf754APwAIINl/E8NRnEMb8hrHbKbHcxdTi9H6xEcJqHGv3fRik18AggqCApOjDo9bQ9FYqzWpAkoLCcKS4bCI1BBxZ6mAgpgwAaIUkQlLJGISkzCEZkYBTCWUYs42IDcN3JrJ4O5E2BS5gTF7MkKiEIZySwwrkdRoFD0Osy999UCeMUrUEi9OKEoJQp84MMg1M1ud7vbNK1scitgIYsos499PKXQLAxkIGAoAxjDuHxwakELb95NzKQQoarw2QTW/01wEm9BC5LInQtEAAIMEK55uqj/zAv2WYrn4Xiev2jyBTNYAWSEQA1OAY2Wt1zm8vJG9KXvDUZ3QxvayIYwonQLEG1CEpsAOgJNfeNTT9v80y46UqYqdfXL+GkwDjpPXOBuU3wCFZ6whNg+cQpdUGMYnGiBWAMsIICBs1ugnkiKxpA1ASMKA5OkSVIqikkKzeAJt5KMM4GxyeArG5kBQfCDD1S31HA3ymKNSJG8yUMfXAARENmFFrw3XiAG0RK7Y/gFXFgFGmIfgkMb1xAzVOCET9gbOVADKRgCfvonF2isP5m9C2CiCrA9B3iiQMsv32su9WAuMIKu4/oV5Poc6aqAD0gjJiiFXSCG0eoFXzAQBcGh/whphVEohVOgkFWwsmDIsuKJhFL4hPj7O21Dv/QTMKLiiaaDNvebqgNKCqLSDAsIAUz4BPtjBXXzhB88BVmYhmiIhSEooLuygCUogrx4OwrUgBUJDBhDQBhjmJxokxmbOmlDNZzIOwQ0pgYitaHAgTjYgz2ILNTAhBEUIVOAlFdCG1lIwRW8t97QsnTyhWWgQX1ric0aOFo4oUlphR70IeUAhDlogy2wLTUDKCRUgYHSjg24gFtxwoQaj4fKuGFJj2Jhrj9DjzAaD9CRqIeCAFzxADV6g004hWlUBVeCQ1M4hVIoBR/qsJ4rhVWQBV1YJ3aqP1Qgv7vSq6L6w6EqsP8CI7A2eZM2uTVOGpOmexoHggRTMAVV4ARC+AFLEIVPKIVWOIZp+IU/CKa/kwAE4xoQUBGcQLBsyzvAIqYJdLpiAgFlE5S+8qsJwACq8QAM2A4r8rYJQKhvAwEig6xDgYTUII0QIoWRZIVXeiVhTB8VtDx8Ay1e8IViKAZdYIkICUhhHD1aUK1SMZVYShWvOzPnsK0jhAHdSgHtMCzaK8cHa5yFmqKGWkcCaCjCzKjheqhrgahoiYAM4AAP+IAaEAItaIM2UAMtkALNJAIh6MwdGBxZkZUdIAI1GIUpIUlPYAVBUAqi0itXc7VWK4oDU5HYdB7wCRMCqqs4sZ6fsZL/iwmKDvADVmKFTKiEK+g1UnjDXbCGaUCFF9iJoIAMD/CADqgxFRiTGbs7oIyM68CO7MgapUSs8UycqvuxJcKACPio7mjCxeErFYiCQzGyqkQyrBxJV3INFASOr2QffPO3YPg3lohDUOvHtlStWHilWNihR5nL2PoDP+gbIyQa6nABN6vOECioxImAXQkP5IIiKMoo9DCAw8Qvd1TMBCCA4/KVQ4MANaJOEYi9FlCjGZ3RD9AOGm2BHGgBKPA1YRs9EdsJo1oYpEDEIZ01qMMRBPOZn+kZQWw6prkTngiBJvBFVhCFFzACT1iNkbSFadgGXKiB6jTK6/CAgTo7ECA3/xVgLDn5zhNTU+wAR8OqTgzYgMgsgRSIURkVqBQggRZ4gReogRwQVFnJAR7gASH4gR+QAR9wCiQoMkiYT6tMDlDIylZyDclDofNJH3vjvivzBV8AFVEZULXcx1gYuANFm1KZJ+QAQna7pwjtp356vYkzUyWqOoTqFTKCIik8TN+DnHcMtM5JAAY4NI/SloJiwmlRVutaVmU9tAi4LiKIBP6bBlpoAheINVHDiSd9UjlRjAECGriiMF9yDAHqmQJE0yEwBdZKBVHQUlEABVY6BRsaBS3IgST8p0AtGhj4AR7oJx6IiiFQgiUoEuQBgycAg4R1gziIgznwA4f9g4hNBP+wCQ1HuCZHsNhrOhSHbdjZWgMumIImSIIksAEfYNQniCxI/Rr6DCEStFRYwFSC21Rc4D51WidciAWVbCUJ6SlQO4XWOFV5Go7Voie92bA/cA7W46foOMIWQMJaDU85WxwGeCJ0HNGG8lXmMkwwGgAwIqMJQoAHoIALeAAHQAAGqMcMUNsXhVFC7YEeyAEmOIRRkAVlYKFdUANZ+bFtPQwXeFO/xdZzvZJ9LVmTnQruQQKCrYIxUAIlIJInqIIoSNgxGIM6wMVBGASZOJTLghSy6UXlrIVfWIZfUFBQQA0QYreqVARFgFAIjYM6qIMxAIMqoN0iUYKoMAJkyws2y63/PxWoEhABWhGB6kQsg6qAW2FCJ1RP24MA9cS9BMAAJfAD0ZiDP8BYSRWhrMTPUnmyTN1UW9AFm2WnWCgEHRgDT0gFUnClCjmFSKgBUjgftyQOVF3QHkK9vcEnh2O9fgrNwanQJOqA7DCoXWGcwDSPdMxa35vCPsuoBOC4i2oACliACPiAEniBGJABGbgBQX3bHiACKYjbNpCDSBiFW+gF4DgFUvA6XdzFXWxZytKmRtGmGe6EGu6EXbRhHK7hEarhFraEH64ESFjdIUbYhgWFVHCFdgWF0lDOgzQGWdiwLdABFcAAihtPC+iADNCWDGhCJlRPJ3SAB4iABwOPB3MA/2KVIGI9NLSFgDYuVtyDY9xrVs3hIvWgAJSd2Dv4g4ltNxhmje0dFdXS1N+oWXa6t0TgABJYgSUQBVdQBRQCjlY4BS0IgA1QBVyQX4ND1bhkjblMhDmIAzfQX1nNAR3I14D6TgFOnO8IjyhE4AT2veUaluVapmm6jwVAgAXIACewBFbCz8mjvFqgvPD9BWAAhnuzBVgwBU6oynRjWFHW3/31p9CcUd/iACs6KAiqOi2+gG5OT2itMzoulrO1j2hxgBxYDUr9hITbhFEYhU2IhBzYgA0YYxTlogfevVrWZ2aKpn7253+OpgAYAAx4gjiYWDmQ2GzqxSpFm0AWZPQJX/9gyLLfMAXE8gHrLIIxQBljMIZlGIY3EIHaawFSOCEoO5/hgNlpRJWEW7hEkIM1WINRDk1ZqVCByg7yfCDlLWBgCTRhmWVYPszErBb+Oj6JApAPyIASCANRsIUpGYaVuZSWWZmyiIZTeOdJcAMdQEIkrBMkjD2urlXEqT0G6A+PWt6z5pWzVt6HUtZiMZb1qIAUeIH1SD7WQJV1JgV3fmcOMFv7qGWABuzAFmyA5o8CeIAVAAUwAI0/OISJzTBtYo2zmZSHRh/wNeZ804VagJYKgIEG8CskoAVXGIQXQAVRqAEOgNEWkINM3awDjQWY5aHTU7hJ+AM5AOVRFpzXq1D/2UvlONPm4AKdiRrRPrPCBGaoxPxQxvxQBDCAsN3iD/AWXOgsqhYGZLBuDmmGaIiERmiEP1iDH3ABX6oTYPJOgjocDrhVsiYAMVbPxXFvOlMoCgq5fFYm/eC9ACA+AYiASbhPgHzDU1CFTUCA+sbvwYamZSK+fVbwBdfnC1qmB5iAQaEFTGAERrjFRLCE0dCmrIQUE5o81gYOXyCGYsSFT4gABEgBBtjAUKCFLHiAA7AAG4Dw6fCEJDbVk37LHXSl0yMzjJWt2jJCWcWLp0Vl8AzPcoTCDnWcPIPlj+OoLDxg85gWYk1bDmgBb/kFazAXjeAUbXAXbshR/93Lqsua/wugACa61V2pgMXRFe443gdycydU3id84wRAADt/qDgOY2j9qAroZg/IUUdABWZpEiiBm1pog9MWR+Zt4/84YzmOljmWdGcViObt5guo0xmtgR0gzc18g0+XA0CIhO9z51LoR9d4BVoAhR+LgRNQBFcwBEUohEFADUUIodKIbBMKxocGjnUCEZwdBBLADqCYAEqghVAoAqGQuwdQgBf3AdLLBVrIweLYQa4Us7mkyzgA8iL0Cn+ygW702+so3gz1Yl7plYkKlgU27uNOTBHdnLMViAjAdA7QAllwIzwaB3Joh3zg99SOPVgp0+B1WoCSlenQAX8dAtw1giZwgi1wgv8mCFmllfgmkAKRHQIh8CdTLuWNF80aAFRBHd5ALU1JkLx6s4Ub2gQ5YIIP/uDN1AI1EOE5iIRI+CqsfNknozwVbMFd+IVfGIafNwZlCPpCj4ZpqESjvxSHcAiEYPrcsIZWiA4fMIIV6IRU6ARBEAQPUrJehLwE/XDvxQVfb0FR6IRQoIQi0KsjyIVcoAQAm8ksSKpOoIW1X3v2IT3Suxt52iFUmdQN+2Q0az1SDlSJq9XqNKhyd6JzhK6rXXd3FFGhlqg7V48GEMcL0IJVYAZtQAd2aId96Id+uAPa2oIpkAImYIIpIH0pIAIiYn0icH0iIgLTl33TV33Xj30pwH3/LlADNqheQOBjRfHjEoyUSHElmIWyHLyh85GF32jBnvf5ny+2qTZ0pEf6s2j660eIbLj+2+D+cjEX2+j+74eXbuD+bSgFKegCLKiDEnmUTqAEQ8CETqisSlWFrTyhVhAV79WFf/MNXHgUGgAISrSOUHKVK1QgCQ9GgHigQIKAI7km5ho2kRbGWBlpxXr1ihUrVKZImQLFaZKjOW7WdNnSxMgQHjpy6NBRo4aLFCF2hvDQgQMGDBWEUnjQoMGCBQoSHDhgoADUAVKlQi1AwABWrFcJXDXAFQGDAGIJOIgAAcKGTcy+0cvnr1+buG7myLkDKFKkTJs+fQJFCpUqVa1a/8GCFauWrcS4FutqvOsxZMi/Jv8aZvky5syWd+F6PHnXr8aicekCXXkyMWLAjilr3XrZsmiyqdGmZu027tvZdvPuve13t+DCh3sL1w0c8nDKw6GbN2/5tlNq1vwZxAdTlk6hQnWihIkTqJGmAg9+FaswLFm2EPvSxasXrlipXB0JRd9gKBNHOgWaYABJHSBYYBAtFBmTiysbcXRYLB21oopIIpmE0h9xWNjFEy/FNERNOdyUUwstiCCCT0ABRUEFRR2l1FJOZWXAVFNxNWNXUxnQlFcAiBWAAAQgAAECCKTlTDj02BNZZJMBQ9lplVk22TBO/gIMMVEyeaUvvkzmS/8vu2T5pZZaXumlLr10qUuWwJjJyy288NKYmVma2UswwRRTTDLJNNMMNNBII001gV4z6DXYGIqNNtsIt9xy66zjHKT0SEqPc5NaOqk9kzoXXRtz+FFIIaIIckQgoaTCXSegiCLKeIO18gp66dmi3i/v6YJLKhiFQkkgBLniChBH5JrFA3z8ahBFuRxISRq5YvRsLbU0+GBgEJZ0kiN/FOJHHC010cQQMMlUUwwx3BTiTj9xABRRETxgFFILJDDvvFhFNQCNXOErAL89+kiAjmL1y9UCDkCwwyjQzCMaww3f8nDDukD8MMUVVzwLxhZrvHGb7rnnJsi8+BLMn9I4czL/NM8Meqg22nCzKKOPznMpzZgaWTPNkOrsnKPGBZeNNdRE01ormcxh4RiKVCJIGjPs92sqp6bCiivmyaJeeler91gvk+GCLEKkbpcFCxIUMIEGE0zQAAhFIEuRKygooEEoGOGSyy4NvlL1g6ucUgopnmACSSJzHM3StxuOawMMLrgQYgoidKDuTxlcUEEEZjngQFLyOtVUVQVIxZVXAzw1QAIEQCCCHKfIEosIDTDgQJAMENAjAmZB0EIkHIf8O/C9vGemMMUbLwwzzJz8jDPPPOMnoNUQemg2ib4sXHGMMhfOOpJmGinOOYcvqc49G8eNNtgM+qczyAjD5i0Y+z3K/yaRAPIG/m9osQP//Iv4AQC5gIk4VGEMmKhEHArBhyIAwRD2ocWxQGIe9Mgia7bgjGlQEYqDEERsWRhAARTArwcUYQkasECwjoAsY1BiBAMIwAjqRhHzNMgVrGiF305Rkgk5whGFc0MXvpW4mOiAcS44Vwoi5wEPSI4DG7jA5TD3gM0hZSnzAl1UvAKjexngA49oxS+24Q1vuKICDGBAkILkrx9B8QIlE9T0WtYybnDjG3YEhzjyKI5xjIMc5vjjH9nBjnIIspDscIc7BFmPetBDkPRgJCPtMbNJRfKQi7xkPfKRD3tIkmc7W4dyuvEboFEjUM1ARp2E9zD5zY9+eP8BxP3ypwUmEKF/IdqBiEaky12OaAMbEIEvnzgiDyQCE36oAyYG4Qc/uIGARYhCJxL0Kwi6okGxUEVhGtQZW+hiGLj4RK4CgQJKHGGclJCABIBgArOBgBJRaEAgOjEBQ1wEBSMIgALmhpGJWDMWv/oIK1KBClGY5CQn+eEatuCSxMnEBjaYCU5akMQkSu4nT7wAiqQIryoyBUcHCN0ABHCAE3giFruYxjbC4Q1VOIBeHcVdGiPQgXKkw5CFbAdO36FTeOQUHj6FRzx0qlOc4vSnRoWHUNuhDnW8Qx3xuAdUEemOeEy1qlJ1BzzkIY+pxiMe//CHPa6xylWwspWbOCv/Xux3F7XeBZZshaUc6nIHOcSlrm3QghRo2QMP5aCvNWhBDWIQog8d8QUt2ECIWlCCGPxABEMw5iAsgYZBzOEOXJgCGMAQBQceK0EYqZpgXsUZbt7qFfMRJ2oDMYIC8EgCNCibAgLhilAYghIUaeEAYjsCE2zwIh3pyK9AEtBUjOQTnDDuJAoXByB6S0M8eC5EIwq5YToxAxkICgWy+y54dS6fCcjnR01ngSV44hXDmMYYfyGCIB2AKQqAilcIsIAKdMAF+cDHfaF6D3xAlb/6/S+AAwzVrhJYv4jsan/5sVR3NFUdDF4qhB2MyHdo9ar7wMc8ZvEGJvAvfx5WQ11C/wxLQNzBcHc48Vz/oOLKuiEuJ5ZDi+162SlMQQpEGAKOOXQDHfjABuGCyRCakIQhEKEJOHgCDmygCCXUoAs/QAMh7FAHP6ikxk8YAx8EwdlncXkxnSHNMqzxi691opy9IudDJPBCHuWWnsZ485tpYc/3ouAI5UTWRvzZ2YCKhBSg+DO2/qCS5TYXXEP4QRHL5TjHnUAnIZicB9Z13exSeqNHyad3C7CAE2TACaz4BUpxIYKrCKAAHw3hAA6wAAqEAAZBiAI+8MEPf9Ca1vjQR61zrWta8+PWuLY1P3rtXwHrN6ta1eo99vHTY1fYHc1m8DvcgQ39CYF/Urj2tbWg7f9tc1sLXFgDuLcA7jVwQdzhHjcXto3tazNBr32NCQ9sEAOHwoAHOQ7XkH/AgyPQAIWKAEOQnfCCF6ABDXGYAyDcQIQb/GAJcRAEI7SToIncbReWMUY0rLGNZdSiFJWgBApQgBBKZGFu/B5BPgeggQLBeSK4VcAIJBDyQBijQM/qJw1tGBjxAHoSyZ2DclmyUJjoO9HligGjeVICEpBA0kEJitredZR4tSgBGHAABpKAClxIAgK341dIw56AB2jA1VkoyD/Srva17/of/Xg73OG+9rTvuu657sdb8o73fvBjH28JNj/grg+38MMd9PDFG+AghL62mwiOf3y38bpuGz//ngnXdnwPMp/XIQihBxD10F9zOSJIc2ByptdlYkOwAg2U+gg4MMIW3IAJIXwgCXEAgxv+kAg3KMEHMMCBEuKgCEyoKmqsME9nHqOLWcEioJ3QwAgoEQoaKGDNARiAa9NAz4nAOW4SyKfMQ0GQiWgnI1fDeStYYa0+FxQlPjxaHBI69EM31KGKdkGjG72TEjkdAyjK3AMsQLwkgAEkwBkxAObwCwGEXUjxywFYgAoAATRJk9tVYD9YoNvpXdxtoNxdINzZHQiGoK69nT7gGj/YwzqMQhu4QRLcwAs03uN1XubNYF/VoA3eBA7iYIgYVogMUweMXjBB0RP5UhtVQDBt/8C6JKEFCAA+0YAN8MBliYInJEEKgAEzeQq3IMFz4VgTUEcmkAQpkMRejMIptMKsqIInnMoIiFwupAHMscASMqEASMAEuMKbUURCFMAcvteZHUSd1Y20VBD68VnUoIKfTYjPZcvhdEFzER0P6Jv9Id2iOVpPdMASrQt2YU4DvMsZJQACzAiP9EgCgJ0ASAXb4EB2nAolAAEL7MM+yMMruiIsHts9yEMtziKzGRuzvSKyBZgr7oN+7UM/2CIw7gM/wEMt3mJW3UM/wEM/GCN/naA0RIIkRMId0AEcoJg2ygGJoVhcxdVchaMbfKMblKM5ugEYYAEWdEG5bUG5TUETSP/BEGQeTRQRvdlADshEDnCeDhjBEwBBzJlAFDzBE4CbJ6zKIDxBIVhhISgCJDCCIvhBF0yBGrSBGryBHJxVKZzCKgxGeqzCJkiCJWyHndVNKKBTPEUBCzREKa6AHSIIfaDA90nACPRKIEjfnGlAKgxDLVRQLZiHq4iEQJnCDp2Ez/1c/LnE/HFITRgd/p0AVDpapGHi0wlFBbzL5qDRJ3JFv/BLKDogCABBFtgHQqxTAygAs6WlPPhUWt5iLqqlLeqXVsWDLT4VgD0jgOmiVhkbP8CiP8SDM95DhqXVXInBi4UjYnpjiJHjOboBG7CBOa5BOY4bubnjFsAj5fWAEIz/S7zBAAzowLj8wA/4ABIUAQ4cQRYEQhQswbfJgScogid0giAUQhwsUyFYgicAGidowln15iaMwkaugnDm0CeIwqkEQqnkYSnSgCHMlvRFQUMwQi7QgvjNJE2SE3KWkwmMQAPMgTH8gizggrR0BCwMxnANpZ9xgnr6nHKtBBDN3yMWnbxJIv5J5eQk4dNhlBQ5wBlt5QJ2pRY1gNPIVlmi03sVwLHppTwUmH4RGFARm4B11VQtEiJhEj70wz0so1qyZVzeQ+Ehkj1gw1rBEhyQwWHKFYr9QTj2gYrOlRzAAYzG6GM+Jrg5ZhusgRqogbbpKLs9Xr7J50M91yMWQREc/0ERmMB7SUAg8MG3OcK/fQof+AEYxMEfQAJuigKEVMuDPAhHDmd6lGf6aUQqlAotnJMJaIAC8IgKqMARGEMo8AESWECBZAEKiM73hZwCjFPI2YcN4cIyxEeeBaX6WUtJ9AUnZAKF3MHB3Z63wMRLiKbReSbS6cTSMR0JRNp1VaUUyU4aEWBWEAADcAAOlIorgFzMpVwp1iJgEthTEZg73EM9xEOs1gM8TKiswiquziquVpWs1kOFXhIz4gMy3gNdquqCHis/wGpVkcM88MIb3AVGfoEYtCiKaqOLomhcxai20ii4scGNTse28Si2OR4T5FjR1YQQDJkPFOkRbKfc1P+kIlzBFHCChdRBFXCLoCWCI+DmX4xHYLyCqwzncFZQYbzCLhzIBk0DLQABfkQBDFgACKgARkSBDRQBgsik6EiFzImTmVFcfDxGLeQZwLoKSFiLn6UnovrQHywToSmUEDmiQ0VifU5UCpTAJU6OBmQiJzJA58hLAlRADESB9IWCTBqoHuLLABzVUekUYCIVVq0qUL0D1D7tOySjLQJVh+YqrPpDPtxqPWjt18bqfdUDO7QDO8xDNkTCIRxCLLEBGuwB3O6BH8Rt3NaB3dZBOX5jXNmVXU3HSoBbS9BYQsEj4WJbu+GYEAgBETDBkBUBErDiGoIcQYTCIHABJ0xpHIz/gZRK5iM4wiSEhyFqacDOQsXggiDWwjRMw3QawzS4KSOw7jT8AiacgGd2wnRORBbEXMbm1gCgAC3QKS1MwzDsAvMtRrRghHkAbHkC1FASZaEeag+prEqwBCPOn77pW7wh3Q72oA+GAAiwi1BEABUdxQNArA2M5UkGQAjlU1U0oNIalVAh1Tu0wzssbf3Kr09RGFxmFYMSK36BrdYikibVQzucQznMQy+0ARwcwh3gDxuswR7MgdwuUwRHcB3EwQWjgY2eI9966xo8JjpmFjsq1DvSGDx+C2ZSHhFc26ExEAvs1syVSidgwiRAwhNEQRSMwRUQwu4lwiRkQvEBRmh1/ySc+AIwUEloGMYwWEPqTgMTs66yiNE2uEIS0IIoBG/r5sf3TUUpFoAEbAcK5ELs+sJiGIYx4IJhSItHCIZHMC8qoMJQAhqiJmJ7dgEYtMRCHZoRGAEkmosOJlYKeABP/ERQRBEFqI0G0MDZzZYE6Ige7m7YFUD+CtVOUbJQnQNTWbIlL62xQa1PddXX0mXfZShg1uInr+U7yNo9FHA5dMMoiAEWzFVcgFtlGY4tG46FLBeMOeY5zigIO6ZkTmYXsEQ7XsEVUAEyO4ETNMEUKJRLwEQSsHARBAENuCupkFypHKQiZAE3ZxYmsAIj+AEkEB8oCLFgrMLVRAmXfEloIP9GE2+DxqUubvxG6rIuE6OUMdjT94mOwOQWCiBn8H6nLvykKoCaLshCtOgNDXmEcIEEehbUer7fchFaIyqBEogLPtbgTfBgCkhUIFdOBmQX2qhAEEgfdR4BpjVgKZKiAMivJjcYU0XYUhEVUcXvT82vTqEyYNbvU9FqhgqjPNSvUyltKtfiOZwDOjzDG1gBGKyBHGjBdMyBispBLZeYHMTBtdZFMzUmLwszI1ImMXOBFYy1FVCBMktBM7uskCVBEjQBEixBu5pAyBFEr+xHJ4gCJtAmAWHBHjCCIGDCAYEuKoCpLPyCxXFJL6hJ1+xCLYTRbzw2PGscPacuPW+DE+f/gj7z847klsxlgRgP72K0wimMwm3Ez3pwBA11BEAJV/P+WftJLy7fcUsowRJYNB+PC03cQA68AE64AEfv3wdwQAZ4wAxkB37YE5oeQI90ZVeiciXj9EtbslLhr/zKA/0iY1CnA/22AyK1wyJ1lU5F1at+LVStZVbh2tuxQzisAhPswcFVFor1gXzfQR/Qd1brLRzYARygwX7vNx2ggRmMASyr4xiMgRmAASyXNTJDARWMNRRIgVpLQTzS0hA8gZ2toZ0hZ3ZKH0FBwhyAQRVUgYVItedqQnh8wnicAiwMQxH3gmM0xiocQ9A4sTz/xj3LMxM/MQuJk5p55Y7I3D+z/+7w2gIsqEL93MI8iNUqqIJwwcrIkgdIiARRHiL0SvRy3fEWEKRFGxokwoBDyQAMvIALrMAJlF7peYBQZMDA/QAfCEQuBMKZSsBZusiLxMgkU3JN57l0twP+4rRLT/JOuwMBCzpg4lRdCvqBNa1Pofc+0EM1bJgd2DJ9y3ceULocyPeLwgFX0wE2xqgZmIEYhLoYeAGpe4Gok7qCK3iDl7UTqPW3XFsT8MASqNM/a7itmwpBHVQu16a+XoIngOFfDLYthIbw2Mou6AJZZVxu4EYTvzM8N3EugBw6HW1IiQXMiVw9E+8qlAInyEEkXMM8SMMtFGw1nYdHpl/6CRT7yf8xShTOylL0EyiB9cabD/QYDNDno93nTmSADHSBItSNK4jTCFiAnM95Uxz8vVz3/KaDdjO8dhPVwydVTuE5/c5vxfO0T1HoIv05gjnoUdFaP+DDOtzCDjCBhYCjHNiBHdBBHrQ8fsfoOWorHHy6qNd8qJf6WC+4qiMzMjdzCsejEUQBEHwfqSDndoxcqc7wnyXXu/tBIkDCJHACGKpCKaBCGbL4x4jGLZwCL2xDNng9s99Gsy+DFN8zLQj8qUqFHD4Eti/DmMnCKWxCJtzPLDyKNGCMP/VTYcjCqzh08xJlQaWsDxUC/LUEHn8L0eFYvDGOZ4aACjTaC+iEC6SBSdP/x3ZawARs1AK01xWdWgFcfDs4fOg7vMOrA02fvsTTNJ7rVHcL+k6tpV1y1f3mb63VgzYAwg7kQDPFwS6rPMvnATZmq7bGvKeDus2PeqmjuqqXNRQ0P8/7fDxK+B4fQcyNQNEbPa8EwkFQAiMQX0QXgr5CvdQ7ryqMdnr0wsTcgt+sQjN4g43fBmQ/+zSQvRjN/zR0wnai07RLhVhgX328GUDgkqWqVKZGjQBFajZvXrVbsmhFjFVLVitYrV69csWKVapUqFCZMgXqE6dJJyclKuTHTxwwbsB02dKkiREjSmz+4GEDBgwXME6kkPHChqBOrnK5OjJCgwULEyY8eNCg/8ECqwqwHihQoF1Xr+nOpQMbdqzYrmLTtUv77p3Xdurgsn0Htitbdu3cdYUnb+++e+7iuZPbVl0/f/nmCduxo4Ybx47ROIZDhzIcy3DYXLYsGY4ZM2JAhxbjxYsV06etUFG9GooTKK+dXLkyRUoSKUqQBDExAkXvI0cCUQrkm5arUJQwgVIOihMmTCg1fSJV6lOpUqdGjWp16tQq7thnWfO2Lds289vGW1Nvbdq089OMDQs0gr4E+woEDAgQYICEQIFy2aUVVT7ZJBNAEARkFW7WscehWmrBJZZYZJEFFlgycmUjjjwKaSTmMjFpEkcSSWSOOFCMaYuZaKJpiCF40P+BpxhiyCEHJRgJBSmlRgCBggowcIoCCiJ4wAGqqsIKK8LUOYusc6CMEq0pzTrLK7jUgbLJdNqyy6tz2GoHnn3wicdMuboqzB971hllhxZaWGMNNtwYYwzIKKNDsz3hcMMyz0QbjbRBUVuNNdhca0022mzDjQUJekPhv/8ooQQIFLLQMZVQROlUJOVEAcUTT6Qz5RNUNhllk1Q3iUQSVzfB7hZqaKXmPGtqXa89a9CzZhlaluINhRHsG0A//iT4LZVXSBnFoEgSBOQNYRp0UBdYarEFwgplmTAWjTgK9yNTSGGOExFJ9GMOllKUacUWjYBRxhh0MKILSJBK6ojdLIj/AEgMAB4ygiKnokrJNNURK8qFGZZS4bTASuutd7KUuJ0uu4SnnXO8eueee+R5Bx408epHH3ukWawFEbqYkw078dTzsswwo/nPz0IbVOfSUlPtNSh8/vlnJ4iWwmgpjAiCBWEjHXYEFoCgAYg0DAmFU09FQiUVkbg2xTrsZCEGu0gykSS7UVZZBlda0duGvWmo0dW9XqehZbgsAjliWPsK2E8ASFEIhZUCU4pWkjc24aYee+i55iFbbJGlFm+9zYijVzgMqVyS0C1RpZbigKkLd1l8kQcehgDjqFyMUYoGEzQgIQIHOOAA4AsqqGDgIpHE6kopGw5+rCfD6gpMiiVG/8tKwsJ8Rx6QLw6zK3cOm2eVHV5IQQQ5v3j5TjfQ2JONLzD7wvzzAxUUtZ4Nfe1QoRWdgjYppkjahN5GuL83E2igIYg0qCYITHSKgFr7SCpYoQoFqsIUqCiFLbzhDV6MQhKZ+MQoTgGLaPDKbeLJRjB0cSv1tGc844EPLSr1nyz8pjcK2A/gdPQJR5AIIW+QgyMQcgt62INx0rjFLLRVi4hMbkIZwYjlxkWuzZ3rJI6AhCNWcqLQxcRdNImXEfywOmPQIgs0WMEKbFcBCHigA7YLmL8qEJWCKcAtahELO+AYR3aUoxxwpGMcoQSx5CnvS2YRWVv4IrKRyWMf7ZBHOv/gMbJy1ONk4djEIayQhBxsgQ1sEAMY0FAHO2lGT+aj2fjM5xlR4ow0haIC+4TGGqK1ZgpNmIIW6GcEHJhgN/w7QhomBUA+KAISlVDEAFHRqVRsJBVHzMgxVfELbxxDFqtQICxkEUKGzGMd4QjHPLjRjWtAgxremEc4IljCcC4jKcehFCWshgIJDEAByeoEEyExCWglpA1tAMQoumEPfeSDHs+YxSpaERJQTMhCF1EFKzCnCpCIZHMlycQMZ5gIdYVuDV0YgoteNAQdzGGA+VIKC754ghCIoAMl5UAGMoAB3OWOYAZTgPScJMc40pGmdYSjw8wypTa6JUwjE6TI9sH/l3i05Rx3yYc9mAEIODhBo1xYgxmwgEk0gGEMN6tZJS1TyVCS0gugIZRpVINK+FEBNqx8JSyRZgMQmIAFNDhCFOAahSxkgQ+FiGcmUjIJU6RCmAg04l9fgZFaWGRyuLAIL5ohnmsyhB7frIYwkHGNxYLTPN2IIDlD0QmrodM4oRiOAgogAUp0AhN4neE8I6EFNzQiEr2ghz7+cdRn3AIWDRTF5KB5oWNiLoEeIhfn8HoSSHzuRGtgkRWHYARQpIIWuUhKFFgAgxhkrwUpCEEIPOCBk94ud2ksWAMUMDK3gEWONSVHTWdaDoeRpUpuydI54MKxJrFFHX1pxz3eAcd6/7DDHtZ7wxecoIMecOELYMACFsaABjuZQauVdLCD0ac+K+wMrIYKWlmH5gT6ndVoRvCBCtgqtSKMGAlyFUQiZtgISRziD5MQhUc8Ei4Zu4K5uMgFLTrSXFPEqjuz8AU0qrGNxVLTmuuY5jzQY81wVEMX5xIFLX6Ri2HQwmqdOIIETBAKUCRiRKdFUGrbkAg5jEIb+fjHYdbhTwWyghbZqgiGjMkRkCx0JCXhRHBJlIg/nGh0K5oJGBTBXOe6Igttle4L4NSCE4iUBNndLgaGNKTvMklhRa3ppWlqx5vmEac8fYuWsgSX6KkDqGFyhzvqsY7GAUIOaxhCDoRAYAMjGP8NWBCDGcr3YK2e7wtdJU1Y1ydW+A37NfLTghZo0wSc4IDZOCiCEVyzhCjwgSV/+AMg7tCIPUNCFBraECuIqaHmDvrFoUjFc1a1quysYha6CAY0spGNboRD1Y395jrw/c1rFIMYwLDVNqaxjF3cmBaYsFqXIYoQBL1BDXFIRCR06A9/LG4dzfinKiQXuQpd5JityNy4ymXn5jRRz3NwQ+i64IY5cHvcqYjCDGjgAx3ooAY1cMGig5KCEjTajACDdFSo8rsoYZrodbSpTdkxvPa+5b3wFXVdEOYXibEDHQyZhQ250AOtc8ELB6Z1GG59s88AKlA6C3aFLyw0J5AVfmf/lV8TnPAEJcx9CUt4whNkU4U47KHaCFL5nvegiG4XpyMccQUthunZSi0+EGlQxEkk8SpAICQSq+oOL5AhDWzM28jzQIc54jhNVX9zPNEwxi9wQQtRxBOHCDoIgrTwBjf8ofLS0Oc+2eTPVdxC4xTB0G4/DnLlfMKheP7DROfwS0EPg9A+8IENYqCTeblgBSfInnVDUMZHS7oqWHqveot+3kzLNI4P2+PwQN2kNsKFkG2BIzrosY1IqKENUtB6DkxzYDmFIQxdHeXYcUY0KCw1KqxnWkPtiIbthMbtpsAJlEDu5q4JVuTu8A4M4qDarM0N1kDl5mAM/MASFEERWEIQ/xhBszohb/BmUiYlCwzhORzBqeCgDeSgDd7gDWKv8nYvGKRByPBtHdjBHIyMHuihHhprHbYhGpQB9VhBFDjhIBRu8g4i9tZADlhrFcLh9ijOGWZhFniPoC7kW46JQzoiiZbDXPDMEdYFEjqBuYyhddKgCIbgB3KgBkxHB3piul7gBYLiurRvuyhAKhqA6ZruHIiOHAwRve5IjsKieNyo0rSEYtTPvZpkH4YqjtaBF7RADWBJZbTACq4AC1omDMjAC9CH7NLH10yjlKigNIBNAYlt2F6Jfohm7pTgXSSQAp0g5U4ORdyARbZATrigJh7wCeTKEIRDb1RQBecqDuZgJv9+cQ3aIBMZjv5sCBDM5haIgRrKI4K6YZr6i/R8BfVigTkm4QkBYYYAQQoysQ1Y6w2QwR7yQR/2CTG0EIhq4RUmoluAT8ZgTKBIgRSI786ayBGSIxVYZ4sCAQmUYCfm8EV+QEagj0amawWwzwN4DtJ05wE+7UnCT/zEDxHpaBHPbyywhGI4BmEuRkzggR/cAY7WgRsigQnUUQpy4E1W4wrkxAtG8Xy8gKtIQwx6zQpGA9hSgxVXsTSApn3UTmhmcgq4wAHnzha3gAKTwJVWxF2GwDbgzglcCTdSMAVRADjOKRBWCH9G4Am2QAeYYAiYIBM1UQvWYA7uQA4OQcU+4RT/ZMEWeoEYoMEarOne1sGElkEJRQGvXg8QPAcQhIAJ6I/Vxmwe9MkfzoyfnIG2cGFyiAgMPY4fO2QkGCogQ2QSCpIW2jAX+CAKnqAKmoDmXKAm4nAnoE8GaOQFXAD7dm67dCcCggdKio6mDvHSGCa+gsf73uEk3aFJ4EIe+2EfWnIegoEImMApuUA6U/E0fO0nQaN7PGl82sB8eCYVS8PsLGysiKY8nSAJ0NNo3o4mbJECceIHjKBFtkCS5vAGbMAGYgQSBGGFiAUF9Oc39CZS6GM3UCAK1GUOTmQu5cAN7uAO/iARHiFCH8GCSAEVWiFCfGEZbCWc3GYwBQIVPmFE/0rkEOpSz+qyLg+CRAGBF1TtHv5hMulBC2FBFaZjE4qoFXB0DPtRc5jjEzThEjLBIJaLuYbhxgyhCqoALVsko4QgRmwkByTy5q7LIrULIwcGYQaREHuz6IBHOBuGOKGkHZLuvZRzH8ohMDeBCRLFfdAu2E6JNHjNfNRgTtWglEzpNFgjaMxzT/dUflqpRehnC66AK6fgB+DzooSRB37ABnyABlhgBvhACbJgBNgpACSAWOyDPppmU4+AD3jRDSppDdSAC0hVTtagex7hEqKDFExBFV4BF3rhGDZohJJQIE7hEyShEfTM2kj0REm0EXo1Ia5hCPnhzPwBH9hBGGZhQP+wo3IMijN9iyRI4hOCNMeGwRhywRB4UUUANQmGoEl1wEbuk0Zq87p2rkpz0/sapje1FNOAZzeDM77EtBH5wR/6oR/O1Bl2QE3N031+Zn3IigpIlVR5jU7rNDzB6meUUk/Lc9jK008hdgvkZzrVUQ16QAc0SglG7AiQIBA6wcoEoAAMYQieAAj8Q28owWk2dWWPIA5aRk5WBNnoh2JnFg7q8hKANDosNJp24ReG4Rd2YRdsARZKQRMkYVcblFd7dWkPARC0YBbWoR4kU+JOZh2EARZWYRVKoYiM6KDEpTM/ZVql4/BKExOi4AJNrooksAm89SFnbubIVaSuKwRI4KT/fiQC1JVh5qimFoZLOQ1eF8b75lUu7PUfzBQcTmEHpIBP1xRo7nRg49Rgv4p9LCys0i4pXdEJpsDP7o5oaFY6ueBbb0JS0WncksJjjcEUaiALjGM4AnRlVxYIoqBl/IzD5MdokmAKuocu6zJVNSE6SkEVWoFbLiSgqNURHFRB5eAO+qBB74BppeUNnOG1JO4weGgdguHihCiwjChHvzYkNCdr2Kw0O8EPCuF8W0JF/Gwm2vZtp09ur6tubedHvA8uqMTSQlJLeRPTNg1wQw1LwiKOLuZe+SEd2CFlXuBo6Ad31XNgCeyUCAxyC3ZOue47Tal9KjeDV2MqKfAJNpcK/w6MVJH0CWKjDtYwIpyLNJ0rF1BhGHbBDTTLs14XfzaVaWR3fSX22BQ4PZ2KQa3N2kjEEU4iOgLyXB7KEf6AQeVgiRu0eeWgeZ2XRImACEYBHCLTH3DPHsKhF1YBmmjhWybkIuCMH7UGJAovFoxhGYYhFfxguOagRE7EDfpsRebOCKQvRmjO5rBvSssIYK5EOKdkb4cuJHuTHQAXvpzuvagkHe71Hs50FkQggY9mfmpDChz4gQXWgb8ggkl1VDsRT6uzcpMylRRwNayACybw7iR2C2LjCupOrtIAnZxrGlKYNAGuDYehPUghhv8DdpvGhp9AAmuXNmhWgbmATtxgif/loCUQ1NoQNNsA4Q/uoJJ6cUGTuYn7YImhuFd7YAe0QBjmIR+mdh7tYRx6YRYqhGu59yJkTEc5hBZyuXUIsuQi6kRURCbkLl4eUl7msAZybm77GAMQRunQ4pDbFTgXxhF1qukMGC0Mwx3Q4Rq04ANaQIF3eGYvOaM3WZO5QAtOqQDbNDVeUWGBbWBlY5W3IElh+ZwowRU81hWMoT1keqa9IRZcIYZDIQt8eWVxoAuEeUUgdn6SgAlsw5JJtWUcQ5jlxDHkQJpb7Sq54DGSmYm1+Xl7dTF2YBOwwR7qwTCo9mTM+SEkRyM2IiM4TkM4wlU1AsrgAxcw4VyQuMVE1J7/R6cL7u49UQePa84FFK0izehKqMRJdpOQiS6hFXpKsMSA4QgvJK4e0IEXRKAFSsA20DM9p6CyQTeCnZLXLvkLRvWjKbcAjTLDXgNPV2NgqUA2KHAJigAIjqAsw1IsjyCm52amSegXDM5qPGunNxUIXHZ9N1di/XSS6acJpIA9u8Am5PMXpXkuTXUDmXp5G1SZm5dE72AHiGAxXEucq9cf3OGowIEXttAWJqQ4vEW3NARH8ZGtp2EXlMMU7qwR7mAgTaRdkhQn7FhewnWvbw77+thKGvFdFxFeCxunnsQsTlJMyw+LGcdNcuAFNKw2bON2Nwx0N5rAONuB55RQDEUV/xUwNVzjlKjgPEP8tK3gso0ACYogCpBgBmBOQFGgP46gpeHDGHbhWtuQtrcBFwyhExivhn05COLguU11VAcWdOt6YF+WA5t5V6N5LuXymZO2uZm3D6z8edXgDe5AEqzQHiRuHyTOWO3hG8R7FlQhFUQljL/wW+5xInZhGeDjH/8RRIJ0rtNWju/OjmPkRWZur1tAj0sgu1CqLb5ikQU8eNzVsNEvedxCjvapcd5ACG4gBYZ7wmkDYjWa10DJs+e01+y0OtHOfQLWZ/oVc83HCVS88R5lKfYGUgAnEEJhbuRmV6zhFwTBGBdvhne6ZT/1MdrguUv1uet6yZnxmfdsDv/2DMrv4OSUOXmtzcqr+xCy/A8aYROEgR7EGczx4UX/oR/Y4RtuYRVkwRQ6haC4ZUK0BRfeHD5cQWsUilxKoiSaaM+Y0SXs2o5/oA772QUAnecygNDPArG91KAH+dLSAemQbkqKKo5Ohh5uYV9loASOprIrnFQzm2AvfNN5jWcGMNQx98JW6Si9AA7AQK6CI0BPXmU1FQVguj3gnFfCKYK2IRRwiVKGg7d9A3Sk2jEcjMiJ/GWhW5mXF0GlfImh++TmgImdN3ml/Q3mwBHMRhvgUeI+ptuXsx60gRcAioHajCIqBEJsQRd2IaZ/xRQ4YkDenVXLRUT0TKL4bAtsIl7/5GWvawDRROBcOaCNqiQdAJjgC57o7Ajp4Ohh4uiouiEmhaAGRKCoLXtiM1qCJThOPX3CJte0NdhnTkkMJiMPHrRSdjssYZ0SWGhYegNAyF7KcHxXzIPQUrBScL43znbnHwOZQ3VOdt5Ud56Jif7YGxRFfD/pGdR5lbYG3cARMiESeGEeiJUf5GE573VNtOGHdOFCISdbql/daRsXOOJGFQh8P8QkgtgR1EWOcQKj+rzm7B7v+UgSB/7QGWZL0UumIiaOGCcYtOALdGBl1BGtjq3//T+jAUINly9fBA4kSNCLFysKFzJsaMUKFSoLJ0aMSIWhGDh5+hD6A0kQJUpH/wIdoRQoVCiTR1qiQOEql7Fp04YNk2ks58xpuQJl+ZnyyMuhRIdGieMmqVI3ctgsfSpHztOlcuZYvYr1j9Y/frZqveP1Txs5beY0irSpGr169/rJ6wcXLj572phBS3bLli1cfPXuGkbTWKxUsWrFetWqlSpUqBabAsUp0yRHkxPNidNlSxMlSoz84GEjhugXKVKQ8MAhQ7rV7Vq3e9dOnbrW6s7Zvo079+1yvHv3ZseuHPDh6Wy3Bm4v3CkmUG6IEKEluhYp0qtr4YKdS3QuatR8YWMQYcKFEK2IEVOeocSMDb1spEPHY6NMqUAJDWQSPwpKKrMIHREILbnQNI0xuf8cqJNMBZKURRppkFRUhChkgdRUTU3FlBx3RFXVHHdsGNUdc/yBlVVbJZKIVil+BZZXbbTxxht3RCLHKuHY09Y+ccHljz72oKNNN8Xk1ddev0xjjTG4vPJKYbHEklgrrKiimCmkQDZJlpXN4UZmnHkG2miknZZaBu2w5lqar8VWW27l6Labb8IFN9ycdJ4zWzvIQQPIF0k4B510UlBnXXbYXdedGi8adBBBD7UHaUTtSeqeGWbAQUdHHh2Cyk1pjFASCiUpoEAg/AWCQiCuCLiTgTgZyKoxofgXRRSUZCFhURRW6IZTS8XBqxsffsjhhyWOeBWJyHbFVVcrhqVVdDH/zpHIHW8Is849++jYoz7+fOtPPuuAQ40ue/GFyy7LWDPNLk8+WYthhyXGSmKqWPkJJ5Po60gifmC2xROdfRaaC6SV4IEHGWRwAWxqrvnaO+/IVptsxZ2z2sVu+gacnbx1XE46s8E2zzqzaCGHEzG0sMF2WkxxXcwwc/eFod4JpAZ44oknxhde+Ay0FVxY4bMYGqGHhRho0LG0HR4RcogqwxjjyggStJRSIAUEkKpJMdGSU2AHypQLLauSTQkQQGSBUq5EZWFVUr4qFYdVIGr4x7Af5r3VsF492yK0KR7yRyOJNHJId28AUpaHm3Dz2j7/5KOPt/9cHu461/Byiy7p/+5y5DbL2BIvk7iQbhiTrCDmGGSc8OvIv5kJ7JkOMbhwwpioLXwBxeqs5rtsuLGmMZy4vWk8bvXo0w4879zDDj3YMI6UdkxcB8UUUHBBxdBDfyE00UL/TP4XZrCBnkI9F8R+G2y0wb6hNXOxxhrYrdFr/nIwm8ovuNDCAgBIwFShcAWEjpCFUNBCQAIqm0wWWDZXSPBAt6KBCYDQNre9hEL2w46iXsQGp0SlD33Q0B0OcYgTIq4RLGQhCg/xCMShEHEfemEKa2jDF7aQhf1qxBt6wY64dMsf/4gLP/KhDV7M4hayKAwurGGNX9QCF/KK17tgEaXWvW4SroOEv9zQhP8rOCEJP9BBDmrwgha04Dmo2cAGJCaxNPnONhnLWPJuUzw8Xmw1trmHH+HhPHbMgxdvaENStmCR9UxkkYmU1EPSd55InkchBFlUotqQqEzer35d6AL+lGIiFJkiF7VYhigAEICUxGQkKAlFKs52oAX2L4ILdEUn+FCHJRgCBywAAn6EQhQTiEooWVCEIzykIROOSCuOaMQjYvjMS0hzmpJ4pjUfAcNntjCH3OzmDnnow1Foox5F/Ae4igiXffCDHptboixwMYxtRGMXfImXPa04r1dMCRWPeR2WYneZLYzxBzeowRpFsEbUcGADF2gYHOMIMTXV0Y7Ga00ez1RH27D/5R7waEc55qGNSKhBKvaDAkUuwkgqQMGkF7kIpNRnhkn+7H2WfJEHMykQT67Bk0uxirMSwYlawIImPijAEVRSwE50QoKuNJssFwg6vggIF7+wBSxg8YpByIAFPwHmMH0CTFfqaxLSlISWppmJTGhCE5lA6yXS+tZLSEISZX3mXKu5zW12M4ffbGaMbrGOfBDxcoQl7BHZqcTOKcMbx9CF5+x5Or3UQhZMgtKUrASZf/rBDVsYQhKGkIMztqA0ZOJdBSoAyNQ676FwTG1rV8va2GI0HRF1TTr0oa12nKMc6xBGjO7QqzVMRCEYWaREWCoRSr1UDJZCz/peBF2bcqc7/9Ctn3V/5VMUUaYVp1hsLFiwnyykBKmh6EQBzUaJVOwkGsuIRjQKtI1k8KIXuoiFJWhgKpMM5T8bLKApPgGKTwg4X5zwhCY8YWAEr1WtbF0wW6cp10fcFa/OPMQ3XbjXvjZCDTGqhj30gU64FPYf+siHPTZ3i15Qwxu/cGxkp4gu0h1mXqzgZ2b5NYcuNIEHQ9CBQUWwu4Ux7AKnjYA85OHHe8SjHvVwRzzcweQoxyMe8JjylAFpZStjmcqp5bLEVOutfaiDt90YxRtCFEKjETelx82IS92TPjg3V31s+EJ0oZvJ6NYvhCFUSohU5AhHkMIUuthGLQzhElGhhD8SpP8EI1ihrmxYYxve2MakLb0NZRyDGPSkxRJK8suhjGAEKCD1EVLBT1OouhSkaDUpBuwJASvYwGul9YLlOtdM3PWa2rxwhlsYiWATIUazmAc5+7EtERc2XPVI4i2kYQ36ek4v5yoSvOZ1rytBBhKF4KwReMCDHKTxNAtLWJmEjOxt4eMeUW53lP0YjyRnOcnyjje9ldzleMcjzLtFxzMWF5U/1NkMEFHpShn5KEjG+TzNZTgc7HzniBuyKXOjyt7+kAhHQAITpthENHrhijQMRQIoUGAoECgIV0xD0uvYRjay4Y2YV9oay1BGL04Bi10IAr+oesmofz4CE5w6FaZgDD//T2ElK7UaFEv/BIJpbetbv1XXEq5m1a/pQgzb8JvBjoQQhg0IadjDH+lW9uXS6aPNOUMZutiFY/WCrrjf07I23nYiwMiDGBh0jSU4TcL+/gEPfOADcdlWkvGBeHzkY6PubnziEU/vdd/73vwmBzdWwQQTysFnbFgDehRpETc3ROGjZ66lTg8Hmr7IDRFPSlTcAKw4cOjPJ3IEJjoBCS0owxq4AAUN9usKBR5hCbSwhje6oY1wYAMb2dgGpbuxjWnUvBi9YC8YguCfUv9cAqMudRZYwYpUiJ8xp0C6KUqBflKkP8CylvVa35/WtFZzrnalvzVXqFcLW7gRjuh6JHog/wRS8AarEFhlJzkhBhf8UA/28A3Y0AyO9XZ8AYEuBnepc1mgABnHpAQ2cAIdIAIdwAEYgAFEVgEiiAEUgIIUgAE7wg/8gHj5AIMwCHn1kHju9oIxmA/3kHgt6EcueHiI5y39UA7jcA1vkHkfMhDn43mfh3CPohFwJkmRdHqWEkLQlRSrRxUcchV6gze1hwmcAAlxoAreAAyogB/8gVSrsgwxtw3akHzYcA3N1w3dwA3Z4F6Utg7z4A2k8Gk9B3Sk9hJp4ArgF36qYIjmp2qJiC+wFmtRx1ZtpWt0hWtxNWG8lnUxBE5dVwNCwAVtEAnP8GH8sC38UFg8Ei72YA/0QP8NvACBuGAuuwCLbuc5fWEYUtJPidAEOhACJ1gBRBYBvxgBEOAAwEiMEUCKyKZsLqh4LdiCigeD7faMUYaD0rh4iweNlEN2+jBITCAFeRMVcHA+bFBw7GFSbvYoDqE+alZ6lSRxWBgisFc3xWJCgRNok4AJiQAIxwAMpVAIaJgKtPAK8URpzXcN0oANUOR8c6gN2NAN80APD7kO6wALTTADuAJ03PcSJpAF44dqqnYK6MdqquZqA+Z0T2dgA6YJkhB/1DRXuLZrdhVD+zdD4NRCjgASnLAJNoKKlTNY5tQjOJiKZPgLNjE1ypATmvYLvxCL9IQLsWAKibAFBtUBJoj/AadllVcZAVaZghTQIyNmTkeUD6LYjNFIjTg4jUxmjdYIjZXjI+GwCUTABFYhB3BAl0kxSS3lBeb4UqVHHlJ4PhBnhVn4jsDiIX0TFo4gV56QCpAACKogC60wCSoRE79QDAzpDXCYDdLQDJJ2adwADuPgkPRgD/OADuiwDsSwBlFgEqQGdEMRCKkQfuOHCuWHdCApYK/GiE+nCZ/wfnHVVpQoiZUIkzs0Q5HAf73WL5DgCJuwCcIQmqgIndD5kCUTDuCQDcPgC0NpDDaxDMbQnTahlLtQC6gwCWugAyKwAQt1gihYZMUIjFqZgvWQD+5wD4TVD/+gjPigTjooefTW/4w7CJZoeZbQ2COpCA1v8HVyKQd0AAd2+XkupZeQEoXO5XB0+T6COXvv6FMnQo+I+QmnoAqxwApD0AOgUAv/CEHDIA2eqQ3OYA3UQAzEYA3XcA3c8A3hUDLrIJrsgA7jwA2ZlghRIF5EAYgvQQmDiGqNMZvlt2q42WokKWsnCX+PmFYPFpwvKWH3t0PG6UxVNyKTsAmjEKa90Au8YKa3MAuzsAqnMAptKqbMiRatADqwODU5MQxKeaJ/sAY5gJ4XEIy/iJXFeFpbqYJUOQ7swBbucHYuyGQ6+J+P50eP93hqOY1kSYMFajJa0AM9MAdSYaFusISRgpftMaF+SZcMKv9CGTqPeiMizMJMGJdxlOEJpXAKqxALudAEEFAH4jc2w0AM17AORAgN2VAMulAM1KAN3FCaphkO4bAO6PAN3IAN1bAMwyAK4tVzEcICCvQKRKek5VcK5zeSUApru8mbDrZgavWbcPWSL3lhLGRXNplxzCmmgBAj93qvgAAicwAIgBAJ/dqYunCnQ6mUscAJewpkC9VQFQCoVimoV7mVVCmCvDAO6MAO9ZmA+BBl+PCokjp5kdqfkcqfkUdi87ANkUAEPVADrzcGnVc/MlUepVeqpmcpdIkpDAoHGcqqNnQiK5JxsYqYu2kKVBILu0ALQ+AHIpqUv+Cd3bAO36ANlsb/C76wDc4akejQrMfXDdlwDdBwDMeglK7AB/ohIUCgQLBwL0VnCrXpak+am7q5mwsmCe/3iJPYVu2KdTvUTCwkCYH2B5MQCZLAnJuQCWpgHVrAYWfGIQA3B2oACCbalKjQCD3Qp8K4ASNYZA/QABQAjCjYuYR6ghIrgm/gDD3KD23RD/5wRM64bpKaeB/LnyELu/Wpjb6gBUJAuVIxBi2rFDBLXAkXSeBYoTYLH5mSBzm7qsPCTSqCItpVj1miVp9ACqqARbUgRZyACrjAXstADVUbDm44hzC3Ds6KDuAADtCXDdRADe4FtsNAT7tgCYJgCEAAXm+TBaBQGIvBGOfH/2puC6UJZpJxqwlyVaWPOGG/WVYTZn/PFGg7NBmFM1ebQFaf8AZEsANEkLKbSijS0R1TsAVbUD93sAY1sAEQIIwIQAAp7ADC6AAt3AAN8AAxHAGeO8OgK7omuAOAcA3jUA6o24ImZg80GHmQN7tFfG/yMDnhMArcWAMiYEhoMAZLIUmTko7BG1OXAh+nmgdbTEJ9gEO/Zjj9EmhjPBlk9VYHJgqpgBi20AvHYAuncAuX5g04+r3gkIcR2azVCX3TWg3UAA2aBgy+QF/w1HuCEAVAcARAMAK9JF6e0AqyoKRJ17Yk6QkBZmueUGDpqmtyRaUTBmEuKZzPlHFnEWxa4v+v/ioJkDAJckAENeDKrtwCOdADOxBaQvB1SaADOuACHMCwLYwAKEwAAiDMCUDMxXwABxDDMvy5KXjDVLkDOzAKDVkPRHS67PZuRnxvU3Zvsstu7uAj0vAGt7tGTxzF1kUQZgA05SMGbHA+pwqOHLHF8MHFTwM13PRN0PQIY/y8ZRx/B1Z09SILs+AL0aAM1dCsETkPCe2sFWu+dAh9UOTHzYAMwPAL9EVftwBPu6AJfiAIQSCkDUJArgAlast0I/lqAux0Azx1BcabVdpWj7Cuk6jAvKalYUzKWnIW/RpsyqkFO/AcC9UBHvgcCLVGHEACVYkADPDLS53CwiwAAZD/wlFNAAZgAC8Mww7wAL8Ysc1sgiKwA1rQC6IpWCPWLWxp1mfNlt9C1uBi1ib2kLcACHMJBlfwFHxmZ3d9M+3zPnRZszdrvFusKYRACF4MNYV9CITQCIjQCIi9CItwCYqwCM8U2ZfwCBB2YLFWdLCgC72wDN6bhwmd0Hecx8dnaS+qDL5gpo5Fpr3gC47ldpogB3HwBGnAB+Z1ex1JCvxEkv/FCaSwm6/DCQKmCZyQkpewVrwpVwnckhCmwFjaaxamz5QRaJKRa8OdCa22YYbbBE2AP9UzBDVQAiLIuTHsAA2AAMWcAMd8AAxQ3i+czMSolRVAqKCrghmAAQg1bNAg/5pEFBeY4y3fgtaVY5ZoDZTRmYrWMAqAcAhigAVQAAYVEkKWApgS52dzSbzz3MVdPNgkJNgdTgiI0NggPtmP4NiU/cnSdNnSiwqvYAu6QAzRQGlzfNDjGw5zSNrpGw3HEAwX3eJtV6asqAtJWQrAFQf+wgmYAAqOwAl/ENy+PQm3qQknzVafYNzBDX+ZQNzs2tzNfXU03Ws1ScZZErjxF3+fYAqc0AZT4MFbgBlP8N0eUJUoGMMvzAALUOcLUMx2btXJrMwNO6jzDegoKAI18MyRoA0fRnYsyA9CBOAlBoMGDukPKemSntDd0Av9KgdK4wS7y2drAAZjMOFYaEgZEv8VxWu8JKQpGr7hT4MIrf7hIt7Y0hRNJz5Nly20rVALtrALL35pCYm+cShp7qUMxRDIrC1tsuhY2el2pEAifpAIcaAloJAJWpElgCAJcsAJl6DkmXAIafUJdIXlVCp/M+3l5V7TMgTm+jwJZkXmavWkjsBZH/xtNQDnvwgBdM4A+b4ACzDncw7DEdDnfX6VFTABExDo800Ec9ACzzwKN2Lgk04PPDoO5hutC1mQ0uAMziAMwlCmt4CmaroKbboJ/xoj/xoJcGAFUGAEUdzpWNCyFG4hgI3hGO7h9NzqiPDqjd3Y10TrtY5gmeAJuc3iuuALwLAuUARFkqa+7EUMq+3/9NlJpm4Hi28XL+T5B0kRB8r5hZkQq3IgGUQgB2w1CY3QBodwV40wdcrtTMLZpXnb9vfnTYcQ3dC77mT+25AxB1LgYynQARfAwi1c3vnOAHsew3JO3oCvzJ4LsQV/8ITKCWrQxAu/Cs3g8Wm6pm0abPYazhj8zJ2/A2r0+WqkRkM9+qU/bFHBBmDgBEYABr3ispxuSHfmZ3526hku8xw+2B4u2K2u8zpP4pPd88aNYPsivdTb475wDO3FXppGDMDgdh7fOW0Hi9npC8juObCwCq1wGKBQLWCRCPviCGDBOFoQ+5OQIkuOPx9SjxmXJWOMt9hkiej+Tb9GGWcFYe0O/2DcTwQu0AEREIIkCBAVIgwkWDACBAcOEEI4WJChwQgVKFCYUNHiRIwZKTDpseFCi0hE1LRoIeLDhw0eO4jokNIlBw4uX8qU2RKmxw1a2rhZ48TJFSdrhA4dM2ZNG6RJ3biR01TOUjl08uTpU7UP1apY+xDaSsirV0SLxI4d++jSWbRpL2ny5GkSp0+fSKFqJatVK1iyasni2xdWXr62bOHSpWvX4V24cNnauwqvqleoOGVylImTo0ly7mhRQ6THDi1SEnGR44jNmqd/EjlKtNrR69aOHj1qNJv2oUa5cx/i3dv3b9+NXk8ifimTpEzJM2mCyymRFBENI4Q4EUMHj/8fSZxU4f5EyRAeNlKEwCCQoEKIBiVStFhRo8YcIja0aCTl4wcRIjzQ3BATp8cLAgzwoAsAHAgChi4Y6AIEN1iDiyacUEKJK5IYao0uuhgDjDW+YONDOEIMsSkRo5rKKhRTrOorsBBxMSyyFplNLbXY8sQ4TeKaCxUdSfHxFFXuuuuvu2qpZbDCdFHMlr5aOeWUV+YyxUfjTHFEDTdC60ELLXLIoYcepuBiEi5Ou0O1P1RjbbVE0rTNNuB+2y1O3hqpUzfi8kxukj0TaaKGlU6wwYguwABjjCqg8MmJJaoYY49CGIEEE0wg8eOJH2Ig7wKBEEwvIoEeaM+iB96jQL7/FjiZJAIBRSApv/xIKim/DlZiqVaXBBSQQAYRZKiDIYz4wQgleEiCiwszrMJQD0EUccRnp9JKxRW96gpGGGMUyzYa0dLk27Ny9NEUyeCSi5RSTFFlXXaDjOXIxQSThckh8bqLFFVMkUsS2tqQgzMwpcihBSJqyGENKcS8Qwo51vjjjjXThO2QRySx+DY6cZtNtznvtJNj4vbMJORJ1sihBh62cCOOJ2wIwQMMIkjIAQYQeODmiDLwIIRBwfBDEUgU8aPYFMo7UL1QRR315lIzUkOOVj7ZLyUOROCICJGw9gzMHnTQwUsva6jhBVlnrbWDV11tIYchuOMuQyy6uFCo/0PB+KJZZ58VkQ6+pcpKRWurJcTFwcWC8RKzuk2LLbnIJbcVViKXnJV6/+pLliWNZMxIWQC7q/NXYmFlSk0kaUOTSNoIrQ0hmJiCiTWmkALMNXpYgwkpHIb4zDn+kKQRQPjdOLc3H+HtTY6JtzO4RowbmU9OOCEFFFA8cWSLJJqIo4sfXOCgApoZEH988Rcw/3zzGVCoAg5O+OGJny1tedMLKKjg/vsXaKAB/R/g3z2NvIsTXKgBSQIkgiFIAWuhIQITHIg1B3INTF4DW9jEZrAWGMxgQ9hOFDzIHS4g60KGKkre9DaipkhLhdMC3Fde9KJtPUJGivOWJ3RkChyiQv8VrEBF5F4huVe8ohWqWMVf8lKLWCTRSEaylxFhoQpctMJxmfhYI+YwB4ERoQVTWBsXoCOCGhBBCDVYg2l29wdAgEwSZ8nEJfhVm4tVTHi24RhtdqMbSURCEnrKBChI4YlExMENTbCBBzgQM4QkpHzoYyT6yKe+iGAgBUOIw6QKAQaXVeABBdmfqB5gPqU1DSOk+EQjvPiDFLTAAxcYQxKGwIQmbCFhU6DlLEMjBVzisoFNaMIQfOnLJvSAB0OogQ6awAUwVKELbsvQCEk4BjOYYW90kGaI+ua3q5yIWl1h0eAIV7jZxJCGNopLj8iVClSgIhXrTAUrhHiKUpwCMJ3/g8W7jsQ5W8ACL/Q0Eg9JYYpD+KsNoLiDENYwBCG84AUc8EAPxOYlz3DhYa5xRCMiEQmLfutbbbQYvzra0eLRkY7JiwSfJvEaR4ACE4qIgxFcUB6JROABihwfIxNw0wQwEgEJeKQDCCJJI/gBEpCIww9OELNNVoRpTGuPKB8BBzoUwgnDlAEHYuAIHQyBl7GjZVdpyYUpcIkzXNpCWc1aVl7yUqtgjRsz5ebMuolBDNWE6jSvucJtBo6bLwKLjGQYw8TR6Fs2/MS3OEE9UKACh6I457rguYrL8QVeilGMLphkOVgw0RQ54k0b5nAHLp6MAzkwJAdW4rUeEAE1bXID/yhUFQnlLEejbXTjGs/yUdyKdKS0sdgkJIFS4szBpd+bKUZkSrMF1PR8OL1pI8U3s4UcxKcY4FkcKqGIJ8QgAw5oTyeXOoGbTWQRg1gEIajghCGwZBJq+BKX1CDWs24hrbycghOmMF9eOnALXEhCEqSABZ/ELYQZkhsWsGAoBLsBDHKNZjShyrc8XBPC0tpmC8PSorLEyDZ+Daxxohc9TyBWxIxNZzpbEbrLCWYwlCUMLvZSi1bYohU6pIzDuGA7LrCtBJxCQNU2IAIhCIEItJTDH9gghLeMTKM5WjK4kJOc2t4WpBsLKW+J85pMWMoJMeDARGRKkJmGL7mLNB9zz/+nXAbsL81hDh8DinsCJQANkySgQHj9t1Q8K0IRY0DDcwqIGa1JoQ1qaINQ4mvgKyQ60WDdgha2IDspNGENWxiC7IBiBaGEkAsEtoKBwXDgNSiYwc+ScKnxWuFqfTNbMtJwODmcuOR8mFIh9gQmKgE9Vfmxhyfey7xskaQWG4aynZPFuqyUgyEfLAcp2S4CIFADEVxAbTWYQhghlojkMOcTnGAOKQs7W+VsNMpSjmNIG7HHPDmiCzkIgYIk0oCcUuC4YibzApib0/QxoLn7a8DN9L3T5yKXARUIwRD8gAlBIOEEdcZzwy0x1C5sgQhNcO3VcPfWua3hNBpfClPuIIf/K6YRM5MAhePuwIYvcEENapj0FjDUhU4b2MB0G7U1T2jNCVOYWoHrpjdXDdhwzigtQKOUIvYwCErZWhGFKESaEoGJENMliHlR8a+TZJjCJMbFqPBRG2rQA+11YQM+TUEHDpKCEkRgA2NjQo65sBrjTKKccy9nk8OtCY5CObfmRrcj/iCFFmwgAhigALz3p79HJn58zWUk/9LXgPEd4AA43ekCwpcQgv+AEZYQRBE80HA8n5QnczAFLkCBlDsIhziHLXk6dxg6eBlmF78YhjFsvwzcR2Mau9/FH0ijBiuEcIQxl/mB5TrXvdH1mtaUA6oFx00W/RzofxX6JR5uiUpU/4ECARAABaowiEpYQhGJABokQiyKHqKzFKtYxSlGIc9bYP0wst8FLEwBCje4DlBbyAEELmB2gQgQ/1s7YsoBhmmN3MgEufiEUviETaC7uWsyvNME47iYjqotizkO5DipOBAC+diApOEfySMfBFiAEmwz5Wo8x8M382kAAjAAAzgABJhBBJiZhGCICjgBI1AETOADH8iApfqyTWqKSFCFXTCGYZi9X6C9YWjC2rM9KIRCZVAG3KNC3LvCK4wGatg9VwCwJBACKwjDMMQCLwjDMAgDL/CCMigDNTzDM1zDMziDMjgDOsADPNCDPoCD5vu4pvi4O/jDqriDQ+i56IMhGf/asOlDC0vABFCohAQAAEgEgAAYgBOoA0johE4QBVFIBRxyiz9oA0DYhDcYRS14g01oBVyYPSVMwijJhIZxAx6oFQxgANNiHwQQH/bpAA4AFGTbAjUAhNJhjk14QAesOwnEu9gCKT3yrUlAxuPYk23zkxbQxQvIAE65n3mzQRusmRmsGUcSn8M7n3AMOPVxADbTxgWIABIwAkgAhUHwgVWSLp9yAF2gPSxcBmOYwik0hmOIQts7Bn0MSIAMyCtshmbYQmPABABDqDREwzRMQyvwAjdcw4YMAziMQzmkwzrEgzx0Cqf4Q5C0ijvgJsHxubDglksoi7PosEUEhRMIgAD/gMSYHIAYAAMlsIRUyEQ/Uik3SIQ2iARAYIIdIIJRfAM1YAJNSEVVxIVYMAXKmIM1aIIWKDvvYZ/xEZCS6IEW4IkmcARVcUpz2QRNIMZvW7KyjC20zBNVWY5NUA5O8IMhcAGWKA9rxB/pSiRtpCnFe6RGyjfy2cZtHJ8KWIEqaMcrSIEKwMsIAMgqtMKAnMJjAEh+jEzKrEzKJEjcM8gtjAU3AAqGdEOJPMOKXEPRfEOMjMM5vCs99EjNAMmRHMmdcyEY2hbEOcQOU0RPqAMBkETeFAAY8AEfeIJJ8YRKYI5J+ERQDModWM5RVIMLUAgh0AJNeIVaeAVaeAVT4ATf/+sBL4GAHLgAAjCkmiEAB7gAD6gBDxQCzPiD5siRultAuvsWY5wtcMu2+pwEP/iTFICZ8iA8bLzLvAzQmeE3yAPHcDyzvVS8nHouDvCBOmCEQeABDECQhHjMKwRIy8xQDaXMZZjCK1QGzVyGS+hMJ3Cg0HRI0azIN7TINWzROUzNvsmD1fRI14TNFOEK6HshDfOr2qQRT+AAmIRJSLSAGYABGDCCOCgESPgW37KoUSQCWNmBURQBGiRPaUsEVPghVkiFPyACNriDHtCPAuEAmfGADEgBtMsBHaiBMUGp3Jg7b/MRCIxPjRrGYWyybRsZVXGDIbABF1AlDAgQDICpTv/xlRvESwH1H34rnwP1S8VrJIALnwjgABnYA0ioghMAnwh4TH1chmYQyA09BmIY1crsUCvsUM3EBTW4AydIAhMFTTd0yNB80RaN1TKwSI2UCjkokaboyKroVdgkxEJchJ8LOhpRBAQQAAHgPgBQgBlQAeBEUj5pBDkInn+Rgx1oAfwQASndAQIQgAg4TJlRCGlzA7rYLEnwEv2Ij5SQtpUgCR14GDeQhNRrBFOQhHL6Jx9BF2/rkTmd02FsjudxAx3w0xAIgUOiS/80j4PwFYcVUG1ULsdrpHur2JuSvMkzn4RYAA9QAkZQhB/4nsf8VBAF1VDV0E4tSNzbBDVgA/n/CjIxsNVbTVFclcOZZdGbncM41NVdXc2O9Mg+OISStJZhdRFtmaHFsYJvVVZlXYEZoIEigAEscI2T+aI32IECSYnl3AEH+FYlKAEPuAEZuAAEIADybIE7+IQs/YQa+LGEyo+PmA8eEIImSAQ5SARqnQzSkYtSiNN+5du+/dt/HcZtg4tJmIMhaAEXGI8OGNT+JFSHcFjJNVSI7csys1jmkrwEgMEYpLwSrAAb4MExiIFmiAbT/dTS5VSATAbWTQbIrEzIxMws1AVCe5AmCDIzmFmdvVXSDAM6PIOJdFHdxUioIhEUQqE+tNFusooWmU0No5EkmMEYFAAJeFocKIIh/7DESViY/uPWHdgA/4MAEXgDLbgAmMSAGAgAB8gpD7CBEuhaAkCAC7gBOUAFTxij+HgBD2iB22ECIni7O2gD5JAEUhjLBvwnHBqXUVjgBS4FB37gUmDgUehXO2XAuNDOPzlYDXZcChhUu/wUgvCUhq1cirU3jD1hFJa8AVjhFX7BAzCAnGqASryu0zVIGzbZY2hdHd5h1gXRe7zCUdACN3DZ2xWCW03DF0VDWuUbNmRR1HzR0zyD4u3Z40Xe5kO15nVeY1WLJIgABliACRgAE6ABIEACH1gCP2iNj2MCLSCC761BCNgAodwAmGQAGwgABIgBfXMABMiAG7iBrp1BCP/wACnIqq+pAQ9giRzQjD9YAzXQo3wthXzBIcf5Jwi+5AcehU9oYDmdu74FhUnYghpQgYM9Gw7OgEGdCPxhWBBuWArVxokts8lLYRiUPM6FQWUdALNt4QWIQfPBACNgBGIohmIIBmA4ZmAIBmNWZmDwBV84ZmVe5mhW5lEdZmqgBk/Vx10wyqEQPjKUyFqdyCcG5yi2WdSUYjpA3l/Nw7tpTb3aCuhjEWI9SbSgzbT4AfBhAAUogKdFAiD4zThIhDnoSUdoAyYQAfiFACa4WgKASSSoAARYAT32gUp4ge3ChBg4gH+rwem4ARvwCS4wqMxoBAfkunTBF1JY4H3Vlyn/weQGhmBN1hEH9mRUAIU4ICZSPoFSTlgOth+7/E/pCGHJZTMDXa7MxdhaRupbTmrN5VycogASQIZkQAZirurIrOZiGNVgqOZpVmaqrupiMF1oSIZmKAZlKAUt2LQM2TQ3wILgvVkn7t0W3VlxpkM8SOdnMV6UYwPNuGIUwdFC/CbAsuezsAQ0iAESwIAJsAAkuN4i9QEjKIQ0hoQ/wFYIWNYAsBotgADuO4EMAN0XqIDs8oATIIEVWAID6GUDiF/yfIAKKAFB8QNHOBMFJIVWkIRNMIW+ZRcHnhJ9SadLZmCXHoW+nelyUqxQ9tOcLuVagQkO/ukPhgiHPQii/mL0/6lYW17qpS6AArjl7IbhF16AB4CGaDDIkn3dyEwGsF5vZGhv93ZvaZCGZ2AGZkiGX2gDMfk0tm7rN3TR4LVZnIVDOqhrOry5EPkQvnYKFvprF+qmbDkctKgEQqgDJUBswlwCJECCIqiCK8ACR+id2xk7s4WAbOVsPGYEE8wAGUADKPgB08aAPfikGFxtXxZvmakAapuDSZgLuZiETSAlSVYFBnySk3asJ4GnCH6/I0fydHlgUiIlpzwoGCBlENDpgwUBD2ju5xaIVf6U6YaAMEvBi9Xci+Vu7mZhNE9z7obBAajlBJi8BDBdsS5v855CG24G1nVv+maG995zZ4jvZ/9wBmZohlbIgStYlrgJtbYW3ieO693l3SeGQziMJjbg1QOHAz6UgwWvlniWTcOhzcQZBB4UBUdogqlFgytQhEFI4zlIBDZQAxFAkBrs1oZGADwmgQwoWwjwAdhuAIUTgGTtxhncn52ax2ebA07AobfYcVVAhXRRhSXHISNfcmqn9mZXrMAlpTloAh6Y8hCo8hPQaSzXxSx33IUNEKA2CMmdGTHP7lk2gDSP93jvbnjn3AM4n/iWhmiABn7f932HhmcIeIEPeGjI92qohmtIeGxYeHAAh2/4hm2whkhgAu4YAyxQ9C7AAuGl1Yu0WY6fQwKnJgcrETgAET68AxZ6Z5L/zOLyKpyxuARFiLp34VJQEAVLAAUeZM+j/AAB3IGL8lZbj8QAyADPM4B++4AriF8+RgAPIIEZRGwEIAj1qYACeQE3OKzpySEdcr0lh/Zq//ongfZ00u3puR7wgAGdJu1wL+3SKq0MQOVB1ZVVTveH1cvlyu4zl3e9N9tbfkF7N5+ED/xrWPhsKPxt6IZuAIdwWPzFX4d1mAfIpwd6sAfKr3zKp4d5aAYmEAIO7/AxGOI1eGtJv0jSHH2MJP01NPCSr/SPlApt8opp+YprgSEXEouzaL1X2IUmXEJj6CFR0AQdCmKT8AhTjAQIKNtllUSYFIAGkIEMWIAxSFYGIFsH/2iB5/SAF7jxCtiupRefCMiAIXCET8ChyGEXHQKSdvH6ameXri8xUuCEQeIBHYgBK1/70iYBQyotDnj7uJd7qkd3gIggMAIEgQ8cOGCwYOHCBAcOGDBQYADFigIqYqRIYGPEiBwjHkiQYB7JkvPooUypciVKey7zwYTp0t46cKt2CLmic4wZNj7LhAlaZijRokPDDD2T9AydM06VBoUjdarUL2ykysl6h06ern2+9vEKltBYQmYJITq7aNGlS5o+qYpl61e0aXaX7Xr1ChWrV6d2iNiwocWoUZt2QBBAQICAAI4BQBbgg4LiCwQcdIBAAMEGBwguEIyAsEHIAwsSbv/IAQlVKlatWKmKjapV7FWrYsc+pVs37tyyY3/6s2UIDx0uTpwAsQL5iRIknnvwwGF6BgwYMmDPcGE79wsVBoJHyEAhQ4cQJRaYmHH9gI8EOsJ/KNIey/ooT6qsh0+fvnz8+ecz0zrY7ICTTlegMcYaa7ABlFBKGRWhUxGW8ZRTUplBFRxiwEEHVllxFVZXHuYBlol93NHHIYSs2AiKhDTC1iWe9IXLLspMY800yxjziy2vsIKKKZsQ8YIIHzBhmG2RMGFZY4w5FqVjCCBAAAQbbNQZlQ5AAEEFCDSQgAAiiYRABBVc8MIUNLICG22wxNaKnHLedopvq9DZmyqoTLL/RRPE8eDCCiuA8MJyzDkH3XQcXJddd919B55A4o3X0EPnGQCReuxVBF98HV2awEz0pTQqqS2p5F9/LrVTDjrjkDpPL28wkUQYV2CBBRhgrOEGFkchdRRRQSFl4VN0lEFHUxU6pWxTTJ1hxhkdlthVHnTgoYe223K7LYuHgBtuuI1Ickkmn5iiCixzLWPXND3uYksrpYCiSSRC7NCCCKOsMsosts0SyQ5OMtZYAJAB4JiVDggAgQieXWBmBBk8MMEBDTTwwAMeOECBA6JB4IETlqQSi8m1yCILba28sjJtu8mGCiwzv/bJGk00YQQPPNgQgwsvAJ1CCc558EHR1Dm6/0EGGzzqXaTgQUDpAgqZ19FG7hHQXnrpaeRpppeGxBB9JpF03zrzrBPOOtxw08023nRjjz/+0adNNdJIow0210CziRpt2OpFrmB00SsYwla4FOJFNYusskpN+FRSDibrrLJ4YJ55t9yqKK7njZCrCSmzyaLLMO1OE80wu+iCyyumfKLJJkwU+MYst+O+SiS0thBBlYsZLABkAfz+gWWeEbTBdxgr8AAMMXiAscYaC5SBDJO8grIstbBMGyqqtKwnbrLQjIojwymhM88+/xy00CR4AP8HSC8tmGCPVpC/pARRSrV5YD/EawXwGkgAKJ8EMEQb87jGNaoBDWg444HMQP8GMpgRjGDwohe98AUynEEPffjDH/WwhzSYIQxkQKMZzbjFG9SQhCHkanCFc8PhgDI5ZkFoQowzVg6ZRRSoWKFyTHFW5rCVrc3p4St3WCITD3EHcIHuXKNrRS128QtjGGN1u9hiLVDxiU1s4g1aYEIkbsGLM97iFqt4A612QIQWbCAxAWAMAeZYxwAQwDIIQAiXumQmBhjAeiSgQMZgYIEJPIABJwhBBlrAhUiMohUqixOcVEEb8akiZXL6hBv+lL4f7Ox5MYgB0F4gNOcMLTrz48DSOGA/puEvUvrjX0IqRaZblgkBAfwaSBJgACqRiSEMGc94hLENamgwGMTwxQX/N+gLYvzCF7zwRS+AAQxmzAOEc6MH3qJxDGpQYxmb0IILkxBDLCxoQWbY4Q6H2E5jsVNxVjgDHpryuMvV04hI7IMcmNjEJ0JREpnIBCfSlT0b7cJGuMBFLVQRu0gAAhBvOEUveOGvW/RCd2wkQoHyFTEECMAAilnAZS7gADwiAAIpLYgDKnCZFZAAkQ3AgA0OOQELVAEGOvCAQDbwhlKcAhZzGupQ45SyvZzPk0YYAih7FgMZkNKUpxwa0Y4mnVfCElLfyV+kota/8hCzPGQKFQJFshBiopUBfHSAMpThjWYUQ5nEGMYxfjGMYWTxF1a0qzGgsQ579KMf+ZgHNppx/wxj8AgXd+DCFZJgTl2B4QtfaMMXxPBDaL2Th0uxEIWOQoVkQe5ZRsSnETOHhxL5E1x36KcTodgIR0yCE6AwaCxqsdBa0OJ1X3zDF2wHDV4woQVvsM0odqeFjhZIBDcggUeoBIEMOCBhePTqxzaSSoo9wAYqCMEEJhCEIsCABxVwwAVEoAU28gsW5JsZzYh6VFLcwU9DUEL6mLq+G9wgqlJNAX+JNj8PdMCVgtGOdrTqtIFErUt8TCuDbXnLtK41whozhjKisQ1i9MKuW1yoLWoRi720hhW1uEU48uGPe+RjHRaNBBwacQc3dMEJTjCCEbAwhl1ZhQ2VDdYQHwehy//CM3JC/vGEvODDIQ4xn9iynOX4qRUn+nOJ4EqEG+bwh0TAlhPoCnGbUMGJTQBCDm8YBQbfkC83RgKiEdUCRwskBy984AOemfNGorSRlDqAABWwwQdKQAFF2sAFhgRBFGCgAgwQgAEXaIEatHBeQJwiZexlbytgoRdZfDgTa9jCUpdQ36bGQAf41W8K9utfAC9KaY5q2oEFUpAIaGytDVarAzAmTFrzMdYOmN5AODGJSNRiGGJUwxDsqwMbwAAGHAiBC3TwBUloox4hHKwzmDGLAgnBCVeY7xBiAIYx3FgMZhh3sCp0T3huFt2S46zkFNesxvWYiJnLw1TkAJZ+Ohn/RYdIRK/iEIc5+AHLWjYFwWNDik9IdMwV/cILnJCEF7RgB1oABETloAUhCEEOO/gALDNQJQa85zKe2YhiMCAdjmXAByBQAQgsAIQgsAAECdjMBWrgRjCjl4qSnple9GIyVDRiC1MYgg6e4OmlNlUHooZqKd03NPhFJ+qszE6BuZNVrp5JUgmmbh+75HUF7/oBkhL7QLgKgxCIQARySnt0NGABEGggBCHggApWAIY/jKIb5ABhPsYxjnBk4xZacAIVknAFIxwb3GDAghcyBIcb5hBySAay5MKwbh0mblg/fJaFllxazHXF3ifKNz/78IddgcENVb4yJ2QLCnSpwhSl/9iEmEfRC13IQQh1qAIWMO5m0MlBDZGQBGA2cCQmyKEGehR5lQ6mMAyMF6ohiEEDNIAEIOBgAQKg0gYAQ4RTmHnio1Dvznv+CpOBYg5bkALRn/CE9NEYlD/4gahvIIOmS/XpJYh6dOi36vtxB1cJoCw9zf4YoKQQYP5QAAUkWwvkwA4wlBDcgA/MAA2wAA4EAQ7YgA1UgSKAAiyEwwfpg0vQwzhggzfswhfAgerFQRdsgU8snq6gARpAhVCk24RYXo/1kA/xoA5BxVI4y7FgDj5xDun9k76Byx/sgR8MwiAUgiJMwiQ4ghSVgiXFQr+Y2RvcwiwQwQcUQRFUgROYQf8LtMDO/AATqMEpCIz9iIAknIJhIEaVgFSUJAwAFAwFeAAMTIAC0AANYF8CcN8ONFpx1Q7FrcLO8RwsmAwrZMIcuMEWdEETGB38LVVx1B/TNd0pPcf+SQd1XEDSvBIGaNUAHmApdokBFiBXXYAPGIES+AEXaMEWOVwULAESBMEQdAGNVQEkfMIqhKBM0EM9sEM4zIMyNAIcyAGMcYEb+MSNfdsM/tgNchaTRY7i9GDkMYu8MZm86cERJRHpfYVq+dMf+IEfFMI5KgJswZYUzQYsrIIavgEg3A4R3EARGAEYXEEd1AoYGAH9CYEjAMJxpZ0WvGFh4NwGKMxFMEYBPEn/ACzAAySABeDACsAACGyEA4iAG41Zm8XjKETapE1aLJBCIszBpvnJJMIfU9HfJZJSVPUXKvHf1FEdVm2AdbCa0wxgAZYiAuZk/lxAFZTjI7KBHOjVHhhBFERBHKDBGuhAE6ABJ5CCL9qDTKADO7ADPYTDKmRFPy0IF7CBGyQIuM3gDXIektGTknHWkWlW5sXbNl7O5x0RWJTIiZDFWDDhORZCIigCJDTCI0iC6LQjLMyCLajh7WjBDfiBIPCBEzQhGHTCE7QiKPEAE+DLDmzCLBRGcfnLKjDBBoCUASjA1jDG8AjABGjAoDzA9mFkgWzCTRQIEUSCbpDPzlVaLLTC/yTEAQ1tgfu5n6fRV7ENgRCw5Avkl9ORwNDEWf9lB01OxyttR1Zth08GYE+CR086TdNcwSD4QRfMwRP1wRYB3BMmwh9MwR385SfMQjhMZYCgAzmgAzdJFCC0wYLIgVeCZViOJQ+1pVvqZ+dRo7EEoWhZTj2ZVlyOXl2ayFk44Tkmgl725V9O0czgwjIsAzBgECBIAZUlwh4owiDUQSG0otEhgRIMQQ30AEFuoW20phoVxhuIwAUsQMY0QGgqgMEEQAG0XJU0DBkyge64ERHApkeul1CxVyyggiPCWBfwZm/S11IVG/3hF1TZXylNlXMYTSemmv0sSnNiFXZ0h3WAaf/T9KR03uR2FIIoQEIlWAIrvJ4p8MjooIIruAYs1EIt2EIwzIM98Ic9oIM4oEM4zMIbbKUb9Moa2MGhJsgM1oEOCmER+Rh/Iplb3hNpPeqAkhbmfOPoicVZEAI5XhmDKgKWsWOlsUu7REM0AAPLgA4cVMIeDAIkNEEVVAEtIkER+MAN5MCYpdEWptG/eOQ7UoHxIIABNECmDIABDIACKECiEc+iCVcYudF5bUIkxQIiqlcscILqPaKSPoGsomT6SMELCefSTanTPV2crdKWbmkGTEejUN2jVAeY2mSZ0mt3YMdC5UK+3tUWGcM2WMMVGcO7XNEyRIM10IOq2MM4aAP/N0ADG2nFi7nBGOzBHhzqodZBHTiqvGVskg2hpFLquUlqx4YsHoiItVyLWIDFHtwBwP1BIQyCXmLZW5CCKZDqLiDWNFCDNbyNNdxCGEkCIezBJCSBE3wbEixBFuCAETjBA+oqLziDMKSobajRJgjBBWjMAijAAlwMCGif8ASAAwwGGJkZEWgBGJVCbdXpzKSMysxBF6QeJFbBE4BB3PomfTUB+zFV/Y1a0FCVlSZn1HVA4AauulKdTBYYdsgrBjhnvbJadvAIFmGRXURDhXnDNhDsjthVuxisic0NOmBDNcwCE9zBH9xBHIBbHUwsxdpBVuRmHijZW46Wx0KqPYmW/1KUZeMQ0aRO6mldC1f07lyW7B64wb/5ATkOQqhOoSfMLPjYyOnkyDZAb+VGgy6sQib8wflggaz6WxQY7RIYARcMARfcgSwQQzEIAy9s4e28IyCoQQ5cAARkTNZOwACMpsKIQBgdFxGMmUfW1pyorSycAiS6rQsqaRd0Qdy6n93irXDiV5TybQn0Fwn8Lf8BWOBWcICxKwf0n/9hwKJ0sIBh1QXQJACK8Cu1CxZRKBadajRQgzd4w44AA14RrMHKzdwMSDJEghYkI+r6GxqkbsXKQesKKObsp+d13uu+2+P4kI81Cx5kYxCaJVOQrB3QARXbQR/sQR7sQR/YARygQf8eEIIduMES+sESJkJeKoKWTVEV2WzB6qzbwA30EoMaOtoa1IEiKEIadG8cYELqdcEfTMIp8EIwnC/UYiZEvUEkSMEFMIDGhMnv6CgB1A4TaAEknUIrdBjNzCYsbMIUGLBuHrDbggFvKkETOEG45m0D259L8tcpUfArd8Ary3LhqisrsZLS4LLVLc3SiLAI7/IGDMMv6NUWEbMVHQMwTMM2TK8ubNEvNEMI+kM/6AM9YMMsaEESpG42p+7FTuzFZqPkDOgQ1pNm4S62mFtZUh4TW04UK4s2u7M72wEa2IGrHi8eVwImeAIosMZB/cIxFKy/ZkNAvw30+oIaUmYSFAH/DsBAEcyADcRBE2xBD8RBEuiAGowCRkFtv+zOG/iNvlQABmjfZnhdSkWc/nK0bkiSLNhCh3mYbR4CF4gy6smqt/omjSXB/PnArd7A0uFfc1AV/MRyLANuLCvKdKwSulJdUit1Ujdu1WXHh9VCz30Y2trC7RSDNRTDLZSOLgQDNEszNUtCrQCtNqPuNl8sGijxscguFD+x5eAQNppbFBex5ZT1O9t16jZhEz4hJFgCPouCKPCFbfXzMoCTNWQD9CJ2NlgDNcBC++qADyxBTj9BHEyB6u0BFjjBEBCBRZsRZoIZRDFBDYhAC3hABTDAHr3SDlByPFryKqjXSrP0z8mB/6742644I0036YzddE6LWv3pl6EsRwhYcAgMdYB1wHMgd9Gg63LHmf8t9ap5KXc8Nyp8D3X3hWtUqy30wi1wdTVQQzH4gi84wzqwwz/8Qz7QAzNcnBDctVlf7DjjbrypNRTP9VsThYBejn967B5wszv3tzabRV7n9RNWwj17AuzJgo308zFAQ2Ef9jYo9mL7Qim8QQ6EqxOgwSDswRgsAor8TVZQ8mW+4ymsAiDkS8TVABluAAccSUayEcUBwrSS+GvDti2YzCe0ARj4W23b9twanW/K2E3/AG/z9iq/wCiN0nKUgNxFhwV7ANshN3RcKXMv96I895VfeesQM19Brv8yUGg0PAMzVAP0ZgM2zIM79MM/2ENWjtENtHc3o8HFaiznhSwTF3F/0u46z3fI/vc2k3VZB7iAO6EirEWBu8XorAsu6IIu9AIxNAMLG/Y17I01LDYwrIIktIEW9IElWEIdeAIcSIJ5aoInfIEWfIItGEZQNcJxuVEOYFwN5IC+tAATRFQkbIIlr0uNw/b5SQIX1EEclKO/3diN4bYSyFg/DnlOK/vSQRX7iFIKyB1xp920R7mUqxJzX/v8YIeVYzmWE2xduIs11EXOghM4QYM0PEMLg0M5mPcIXkNACoEMvDl/l3U+HREetGXGCuieQ6pa6+da40Gfd3M21/XEEoL/oC/oWuzlIQgU7KmXJDE6MDA4NVRDAzFQNSw2MsnCKMjBWnhCHkjCIVwCKFyCFnxBK/zCJxBBG2TCHUhBo10c7RRIxO0AxaVZYcQmMy+6Lqx0nepFI6gBE2qnH8RBHYAbsdOtses2Tuu0Kt+ADTBdDGzgBo5SDVg9xIkAciQKdFS7BF9p1DU34Xb7UrtLYRc2pS82pWfD3YDTNXADO6SDP9AHL9BKcKWuWbxzf2uL5hSoyLolvpez58Huf+q3xwb8O8d5N6PuWGvzgOv1WqgIuWzC8gKVJJkRMBRDM2B8mWNDmQ+0MpxCJjyCKDxC6RMCKiCCZLUCLuSwFPSAhbeB/8PKQZtFXCLb+iacgiRA2l79Qut0mCy8giocghuc49D7gdEb/a4gMBLI2NIv+9KN0gvIANQjuQ0cm9LtTA7kQA0MCqI8XddDR3RAHXOv69hnh12gPZlfQ0CjPaXnrNp3AzvgQ4B0wyh8ARO8Eacyvl1vC6b2/VoDBB2BAwfiKWiQIB6DZ84QpIPQoUA8eyhWpFinDho0dSxy3DMI5KCPIAkNKlRIDBw5dxpNyvRJ06ZPp1rJwqXrWLRo1Kphy7bNW7du3rIRWzVKzp9JjlCZ0SInVi1AarRI4aGjzZ03jSTdobqDSKRNm0aNWiVplKxdv4gd86ULVy1Zr0zduXNS5P9FjHXGgIlS5cmTK1CcGEnyAzFiHzdkvHDsIkZkFylSnHBxOUaOGjVaOF5xIkUJ0aNJkzB9moQHDx9Yt/7AgXUG2bNp095m7Se1oT+t9fadzZq3bdmydaOXzx49Zm/gMNlMyCL0PYSk69VzHbtBhQ7xMGw48IxC8QUTgv9+pkyZhBAjTtSLsaJGixo5hhQJkmJJlHBU/nHkKJNEJNHkE1NUgcWWX45RZifchHrQG6KO2eUUOeTQhAshDsElFjnc4IKLJJpopBEu4HgkE0DeWLEss1aZxSxcfgFmmGF+2UUXW2SJ5ZM7/igkkUL8sGgPvvwCTLArnCgsicMO80EHxiL/kwyzy0CrrLMWUnDshRVCIw3M0UgQzTTVzFzNtQ9oU7M22ayhBs6dokkmmmXsVIbBaIApxhpohJHGHHromWeWSB6Ro402qFt0USIr0mO8gbC7DqHvHMrOIYYe2m5TOrwLDyJONUUID48cPbWikuwDqZBBSloE1kYSScSRSTCZhBNQPiEFlVZgkcUWXXw5ZhlqeiNum6HCEc6aWcZSQwg5atEkCSE2qyEH6KzggYk7VHwjkrLIWmWTU9T65Rdf3volx1pi4SSRH1stUqONjKwCycGYVOwHH6CU8gUqrUzhshcoOxjhMBUuITU0P1AtzdbanDgDX3rZBUdbbNkFF1lq/2lFlVNWGZkXZKSR5htB6blmFEkWQVSNRvOrjkg8KOU0O4gsJejmgiAVL1KBNH0IUom0M5poVPeCTy+K8hqJJKcRQWTWWR2B5GqXCCTFFF9jwWUtYqGhhjihwAlHqG2iuQUQIjLBRZMpHHEihyGuUGQPTKhoJJNIxFrlFBdH2WQVXHxBV11dMq7lFU3inXWQITOyty98n1jiCn2NSEyxKG+IIWCBQTvhSoRNXzjMMs90OE2KawOZlVdcmd0VUCYhZRO/zRLmGm7mKYcddtaZh5dIApRDDS5kzg9VhSYFmj1PjYZ+oYag9y4in6PHvqCll7bX+71QdZW6Qar+z2pF1P/HdetSDHwl2F2GAYZBarDZhptuuMGGm9uauQUWu9iEFlBhhR+cxBKKwIQdPCEyssxiZC86xSYCiK509UJxOZJFKyYRL/UJ6T1GAoPlMkeYzXHOX1GSQWSutRkXWOYykzHdDClDOhueAExlUt2ZJOa62YiCFa5IxRBT4QpPZGIUIuOFNLixDnqwgxzlAB49vDE4WcVhDWtY3nRQtalJ/Swi3wFapzx1HqGhZ2dlHFX1GJKeTzFkL/WqV/jsRaRBZIQj+lmE1a6GNUcoYlaVyEQmCLS1XsXCFrgAGzCSAY1qXAMb2NBGJK+RG2voYhOqWMMYLJEFP1SiEn+YySpu0Qv/XtxiFqk8SoKAgS4M6gIutogFKzr4hw8+jSMY6csIq4AFzXGuX/+SkmauFQPMGJNLBpuhMm9IuoOJCTUNYx2bMqCm2NAmFZ0IRSpEAURf3YJ367CHPfJRj3qo4xzyiAc75iEMQEjiD3NwAxu0iJ+KPC061LvZ9tIoPfO8cWcAHRp6yvCpiIRvaRURH/OcVqQ8mqQQ6lOEH9EHJEVMwiWcyMRYCoSKA9UkWMNyZE8qmY1rbAMbwlHGLTQxCUgM4gp3kMMjVAE4OAUjGL3oxS3KoosZuRKWsYyFKpZiS0W0akhFuohGxuBLXyrJCU36wWGC6bkb5ICY10rmVrn6gmba//CZYiKTaSJW1mvKBhSgEAUqSnGKWyCjG/OgxzjzoQ99mPMe+zhHPebRjU0AAhCJiMMWPgS1e+LzUUU7CPSyBx7zpOeM2COoG90YWe4RhD6malpHUpUXfBKiELACpPr+8x9AJuKiGJ1EJCSx0V2ZAhWjOBCwdEG/BuGmbOHQrTeiIYulNKINb0gLKavhDF4EAxnIcNYqfjG/VuIIlriQJSqW4odbJvUj9GIqFp5KmCUZwTBVvcENdIDVrNYgMl3t6me+mrDUocasrqFN7kYxC2FgQ67krEc++DtOe9QDHvxohz3a+QYP+aELW2jDFwzrKKbt4WfsoR7SMnWe9BS0jf9hCENB07PhC7uRoG3EsKbOIEfvZVazDP2IqUALq1mR1hGNeASsYFVaR8zhD4DgG4E+8RKR/UoXvQDGMeD0k2Tpdrdq08UpJAEIUt7iGdVAhk59cYvA2aJGNnqLLm4RS1iY4j/WPaofyNxQ7Ta1qSVc0nep+i8dlBer1wLYY1yg3i6tAM94PoEyT1cassa3hxmYBTOwEQ567Jcf7rjHPfyhD+T415z0WMc6VvGGNswhi23QAhw+UhJUWWR643FepapXBjSUeCMaMfWFM+yFMHinDFgwdRiwoBEsbBg9GhZxvcYgR42AwcQPVuipVGVRWiVCxohYxCMe8R+MzmEOOh7/JCEbIZYkHmhjzV1GNKwBlHCsY7fd2MZtfEFKdSHjGcgQhjCCAUGbDOMYNnpllzUWCzA7wg+QOKqQ/HAfimy31mk2YRK+u7kU6uAqObiqDGQw3imBzs5cWgFXTWcwhQE6YnP1Lz7ywY9+fNwf/KiHO9zh6OTMYx3RAISF7jAHP/wB5n0ghB4gXPOJ6GHme7AZpiSyqTEqNNiZ9bWtaz30OdbBDnIcQ6/RsHSmD90NY3CDHeRAdS7awQ4Uwbob9pD1RUF0VrB6BCT0rQhnD1Kj0ybkJ9hOCvedQhU1qUWwFFSs3ox7KBESzm2gEQxe/P24OT0FTXaBp2MQg13SzZGO/0yhCUegdt+R63fkHNr0WvsSCkrQPHjBW4RgpnC8DH846NLb1YMlkzLJBA3qGIZx+f7XnPjAxz3k8fF+iBwf/zU5FbcxCwPb5Q5dD/4Xc/a8nUcYaD2jA9CPbvR6cbfoRgdDHHjtdKbuEgxOd7obuM99C7Ec6+Gnul2q/nUgJYJqiyCt2UuL0UxcQu2E1ASP3efRVryCtrsY8jLG5hO87/1BsEEamEGneiEYgmoY8ATxOEZHNIZxSEET1IcRbknyKA8jms7pMmcJNG/zjKAIPtBfhIkxGE70HKP0Im69bEg0vqQEKEM0XM81kiN43EEd4EEe9uH26kFl5iE56IEbkP/BFwDhKfog67QOwiCF+JAwO/aJekSF+ZxP6ZqKu9BgCqsv+3pt6cDgCrNQC8HADbJok3rtAsEHI7qv+1bi+3wE5h5nVv7g2CBBteJQDgcpozyBa0wBD2ELpMBGXYqhGbjtJ8RtG7RBG/JHf7DhGqThGqohGpRhQY4BGBZHFibxFViBFC7hqCYw8kJCcibH6XzpcjhQCTqvCPylX6yKMaRk9FBwvbyEhlywBGCwNQ7NnOJBHdThHe4BHthBUOYhHAixJ6Sh3LSACYiwCPPji5yHUpJQPJBPVM4gjoZO+65v6aCPCrFA+6pxC7GvC7fwC9cg6ugDA6EODdygHM2Q5f7/gBDWsGpoJWvgUA7dLxM0yv04wRNAgRTy8bXiDkG4jBd6wQ+NxaQkiRALkRu44RuEohrSLRmaIRmAAYPiwmM+phVMQd8GQRPxwj6Wqum2CzA2sAM9sBQR483GyyRHkARPkBUljs9m6AVl8QPuIR5m0h3SIXjMgZ3C4RqYIaeegRnGJhokQQiYIA+IJOuOTzv0wOeSrwnJYyAmx+iyEQOlcAo/ERur8emgTyuZbgyyiA3YYBx9bek6Mhr5wlQmTw1/JH3+qFZU6xLeEv44gR7ljxPYru3cxxRoYoNm4Rb+MRj+8JEgiSALcZIS0SeFwSGB4S10BBbc5RVagRQwKhH0/+0kWmUjK4/XsOAjlQAkOc/zOuckQ1NKVgjiuKQ0t6o0t6QlWfAlXU8m3eEd3KEehGcdtEEakAGngqEYiKM3dkELhEAI7AA+MALriEYpiYZotmPnOKUJIQIqpzIbr5K7qhH6pDBzpvMqqVIrsxMMwJANsO/pwIC7gE0+HGoPxkCzXMVHDkEdCyH9FEH9LmES4BIu51ETOAH+5k/tWssuSQHufkwWuqwXiAEZmkERB5MQEzG51I0ZhMFicgQWGtNdWoETMOpqJMoyQ4L5PHEzO7PzEgNKUDE0SVD0SvM0TfNEW/LiXI8d2iF40GEcvkEbtiERoWEn4AQotmEaMiEHhP9ABoRzL+Jg6nxOIoxPGTllsSKr+qjyE6/zCrAT+jJHSq8AX7TSCqwAC8QT+roQC9aAC8BwDbKUC8UTX7RQDIXU+2TKDe5gHVfCLvrgEA6BRJjtESThEiQBT/F0kDSBkFprkPK0yVpi7dyuRUSGtgywkQ40G7jBpKThGXwSGYrBF3gBQluBFRiHFl6hQiGhEMiOAi/ToTgUSUJxFDmvzfxFNE2y4VAyvVQy4txrBVsT0CYtHLChGk5GGqBBGuDEN7rNGpYBF4hAM2RgcuLAWC0kDxiLDopGn6qn5zylw8KAGqvxSa1zSrFRK6c0c/BlSqmACrAUC640S7vQS780i7L/Dw26cYSy1CvZYJ7cAA7uoA/kIF77QKa+byXiVE7nlE6rLU+nrbUkwW/wNBIAAeYARCY+QRLGgixogi+D7C8fyScQcRGhoRlw8y04pBU8ChUeARRSgRMgIUhAqexWRSQ6UVQt5wk40FSp6hRTNfRUlTQfDgVdcgVDAwa9wRqeoRmgARqsoScEcdyoQRmM4RdwgRT+QEi7wFjjYA6+zw2INDmVVTzOQMMK6p/Qg3Ki9Dq3E0qlFAug4ArGoFqnc5eyUI7QFQ2+1FyzKESGYAjWzAmugAmAUwikgAjy1m57QAj4lgl6AHB7IG+ZgAmqQgqkQAvUQHHbAFHaAA764Cu9/0/TtCBRFDdx7aJy1WBFwGVhXYQve0EYmEF0RRc3KVWVVuETvuAF3rIFmIBP/UAjPPVT7QkzrTMwSJXzwgs0YXYEV5FmWbHPYPIDlgFPbnTcctQapsEXbAEWWCEWYmEShHQNmBZNvU8OFkvUkNRm2KjCUO35vJa7MocKzDZ8uUtsn6qpsFRL1VZMwzVcv3QK2DaLtDVzuKBwtQBEkocqkidxqaIq+lcL4ncN1IBx3SBRDjhxF2wK4hc4zSvONqMFdkCCJVgEIniCwUIL3qBcUukf123dcuqUUAlBNigSPmGDagEVJCER/GAMQKkSJMpk9SIzr+ByAmMDc1eqOkdEZf+2REfPVdULVmFSGYyl2473V4/2FVABFTghFmgBFaS3C8BxntzVDZBVeiJljJZSOXXGO6gQ4MCXa6XUW6+ACpwACqgACsT2Cq4QDKzgWy8vO/viK7nAXaV4Dag4Kf4g+PzADu7ADfTYj/04i+BVDsx1C6agCeL3S8/wG6VgCgi3B3KgBSq4gid5AzhgAy7gAjIZAiBAkzvZk0VgB5hgBzT4yXohuZjBGZqBlZmhZ1mZeBvR7qYBFjKhEf6gDiyBZGeX8iqvcj7ShkMyh09xh0eUREl0SkIHiMMKZ2HQN8ZtGoxhGHZBdlhBFFxBFDqBFmjJDfzgQ7jgDKF2PZ6VOcf/mSBgTenAWJ3D+KmgT1y31H2x4FutwAnoCZzftYrd1EfsQnKcJp664Aun4HDB+XDrlgfgFuGixG6FAKta4Lw2YAMqOAciuQaEQAsyeGCTaPBeJMiAgRiKoRiUQVd9FldPRldNGhoeFd1ElxGboRU2QRKE04UxdFXK7AJ/+XI2s1SHWQR5N/SOGZljgDSX+Uua2fWygRqioRh6YS5wgRZSgRZoIRSmepui1w3mwFwtxPv4gz+ypzuwVmiy5zx2zdegLz2ucZ2dymvBAETYdoGlgG3hmgukoEkK94C5oCqYQAr0Gq6TwAYQwwl+YAh0oIU4I0taYJJFAFta4AM24ANa/2AoC3dFAKEsRMZXEmkttM1OdOJG4cSzeYInfPakq4G0TdoZTvtRnSGlcdUZnmERqaGWF6FIXFj9jqqmQxXgptS7TBVE38y3fRqog3tmUxQWRwMGk6EXZkEVVEGJUYEVonqbKKETOkEUBMsNEuwL7YL7+EMO8sB6yqhTwNpTosefRMzUnO+syxqOtZIKn/SpnGAI7pYLBHqvD5ehdSCSdYChh7KBEZuSK3gHWoADRIADOAACIBrBFRurdkAN5KDaMoEmagJY1gLetq1BiLhXM1zDgZa0A/MaPrykcfVWSfvDJUmSvuEbwGEcVrwXw+EWJOERBKEOZpqmORG3MfCpSv9otw0jh6EE9IA7uE9yuImbNWGQFYZodkxhiIJIFEwCFFgBFCphDISUnr5gCuiVq+HgIRoLSSmMO84ovcsaDcLc6DTM1Z6UMNI4qqhgsHuAsBGbmF5ABOaczut8zjdZscHiDVYOXFiLcH5lEkvJoxeEs3Xisw8daN+EtHujGjj8Gqzhwxcx0gUzkgqyEFEcIcVhHNBheAZFUMiprhwt1PXBHxoNOYhnFDShEHJZl+FT/WraD5amSXW74JpEqkzxZX36p1fVmIf6NItbVs2KiIgIm7kJEzABEoTIfAjLbafgjvnDHLV8y6U9D+hAy7ejxM5AOO3A2i0lD6qdqxliD+T/aAoZ4vm8lbvcOKqaBDhv4AXG6wWwZc4RG7E5Q6InmggSVw6k7RP4MdtqRBm2bdumQSfepLPhpBp4osMXPsRLu6RHfBEDU5IO8mx0a3h40L/8i7/0gR/sStT5a+NL3fZs7x9szx8IjKc+ARL2wBJaHVYy1MZzabu0dcdt/Ul8oLeLWch5XTRLNGBQ73Rcb3ZoQYhygRZEgRZwQYie25qNIL6FAG4Fu0ngtq6JQAiqXq+n4EmmyjCG4AeEQL8X2rz4VgiE/N0bw+JKoAVKYAMywLERPMHpHLFHWXPfqbJB6hZuIrOJoS3wxE7+nnjxhJWVIRkKv/BTeUGFYUFH97RF//e0W1vEP7wgUVwcND14gkdQzGnjPR7kQV72Ph/0O9+uSr3U/6Hk++H0Tf/kCWUTJsEOxuDYE0h9ZuUkFmUOku7frpGMxdi7bN5lD040FQ4lV5XnG84GVPFEtSQ0jBrjaGfoj7yIZufIQYETjOBwD7cJNM/mD9fq7TZvu78kTRHq+xY4JzhwF1yCN0MzcuCCJZgICJhxAcvu4U7CNQaWeoEtBv0YjiEZ8MTwkgEgkBVDRhAZM2bJEiYsSPCgMGEHIzJzRvGZtGrXrmHTpo0bt2/gxqFbR3IePXr1UqrEly8fvpcq693jR/PfP5r8bPrzh5PfTp49ae706e9fv6P9ev/6yzfv1idHbrhgwlQJkqJEiQphJUTojhw5bvbsQYMGC5YraNFSgeKkbZK3b3/I/eHDhw4dN/LezZEjr9+/f23YiEE4xgvDL1qkSNGiRIoSJT5Inkx5sqvLrmjRSuUqlahUnF2J8rNlihYpTKQ0aSKl9ZTXWrQQmc0kNRMiPYTovsFXSI8eRGrX1qLmjZw7jSJJ2nRq1apWsmrZsqVLVy9fv34BI0as2DFl3793T3aMYLHz5xsafBgs2EOCD+NHpOjMorSLGTl+FDduHDl2AJ5kD0r22PNSPvqkdA8+ODHIz0v3LMjgTw++FBRONl1I0z4c7oOhTSAahVRN/yy1zi3/o2RyxxqYWFLVVVpttcdXboRVRx1lmZUWFWu15SNcc81ll1469HDXX3cdGdhghR2G2GKQQRlZZVReRgtml3HmWS65gBLHGlwUp0YbX6mhBhdamGYmcW208cabcgDSiCSZfPKJKai0AossttxSXS/ZZTcMMccUWqhC5C1EkKLMGGSQRBJRNBF9lD5jEUYZbdQRSCKJVNJJMcUUjzvxRHiPOxHSBKE8rN7DIVJJBfXThED59KGGSvkDa4YhgrjPUftY6FM+J5KSyR9sUAWJVVlhVUghhPwBFhs34pjjjlBk66NbcQVJV5JFGqkkuIAJVphhMjy52LqQUUllKrTkkkoo/6GANm+9udCCSRx/AKJcJMptsskno5SiCnTS4aLLLrv8MowxD3+3zMQUT9zMxRhnfDEyyTx6kDMffyxpRc7cZzJ+GunH6UjrzGMSPQUWiGBLNOtjT0v66MMTPhISVZSpM+HEKjytRghP0PwE/ZKDS/vM01C93pRT1EMVBSKJIcIq1E75hDPLKJPcoQZVijAb47PR3uEGtdaaddZZPLK1LVxJyNWtXTrgDW6Sv+nA19978VXD4IO/YPi6j03p7mRacnblvaFk5pkrDDdsjDHHUBzN5tN07vnnnVMjuuibQ2O66SZbqnqlz0BzsjQaYbPRRyGNQ9JJuMcc88z61Ixgzv/A/yT88FZHbXw/Rt0Eaz8duio10sKrSvxOxldf4k/Wg4iUhw4u5TXYd0hlybJXceVs2mDdSJbbV5x1RY/bOgHkD93SVdddv/WNf99/5xC44ISrweHYBRnFuYsSnUAgZ0LRCUPQC4GGoEQuPBeNzkWDdKPLYOhCR41o3Kca1XgdCDOSKf10oxvgCAcKU2gS3bnwZsCLoQxzpqvl2XBX2evV9ITXD13V8IZAnFqvhJjDXjGPQzzcXoeWCI8musMd7HjiUrrxtUwcog0tqoQiykeIraBPDnvAkduwQAVsxY9bdZufXHzAgza2MVy58Y249ta/wSHmBYhLXLsWJwhDJND/EA7sRCgAaYg08EEQmPgF6C6IupORbnObE102srENbpwwHOH4FMxeWCABvRBnOtuhKHcCxFIWMUQ/6aEqfbjKUu4KeafM0NR6YsTmxeOWT1SHLnfJS15CEUDu8Ic9qGisQ6jBEi7aYlYI8axn/UFabiCEGN1WRrXI7YxwkV/dgjSEbv6gjb/RjW7yR8f+5UBdeSzgHitDicgBkhKUAA0lHJgGQk6CFbh4GDUoCbuMVOMZ2WDGBUsXDWhYI5Muexk9EuoyALHjZvXIhz3QwR9xkOMb4mBHRPGhq+QhLyn7MAoto/bRqBFxasKzCbBehZSsefSlsSpiUazmShsucR/y/3CiO9LB054+cafpeGKp4PGOdzTxHfcY1RNT4g6bEdOKbUCmFp2lFWh1xStusNa1qsmjtVwTjXQTkg+CJEc4ktNvSfpbAA2Hx3QubjIRdIUCO9GJNASiE6kwBB8CIYgmhIUTm1gGQ2FmDnSE4xrSgGRBTVeNcLgMZjCbh0PZ0Y52oMofLKkHOSo6jm+QIyWhVGnyYikiqW2NeD4rkfaAKCKb3jB7xDsih4bGqpy+o5e6PIdud9vToP70t0KNkDzuIQ+lPrEdKnGHRJ96Rakqs5lW/YNX5KC+HLnvfV79Kli3uUYfePMH44xjePfmN8EBcICIM+ABEdiJzRgiEFnIQv8gAhGFNKQhC4XgxB4GkYlomMRl9mDHf+axDm9QYxnRuBg0nuGMazjWkw5tR1GLeg/k+SMemxUHOMTxDXRENJTUm6lpg1I9V6I2KTVNsQ2vF70nTpYd6dgtL9tRjnLolpc8fWJv4wEPHhe1spStrGVdbNl4yAQfoaoHqApExVJkohFRdZHZmMmVq34ljOtjn1q8is2weisJQ/imOMccXiMZyZxqRW9627VOyURwnnQNhX0DQYk0RIEPfmQEI7KQiE9QgySwQwmA5uGNbFgDwc0oaDMo4uCFwgxA6ZDwhH9lFHdkWMMZbQn1Tok1Xv3jV6C+KYf44aGQqnh5ot4Hcd3/AQ939HK359BljHtbWV7GurIT/nGOLRtpIUtayElOCZLr4Q4hFxtA5TCHstExoG3MwsmNSJaUYVRVrkj3ylodo46ye026eXsuYJYLmcecP/6hOQcCZGtbpRQZdcLVEILY62UC8d758mGelGBEFLKgCFRswyTX0AY92FEOw0qDGNEo1OaUAY2PYWMdC3VopIvaREr3wx3lEIfGLXoPf/zKlMbLiU0/PvJUm3xoOv1pb1fOU9y6fMJHzfWEcWvk31bW5kBuB7JrXA5y+HzjQAc6OIa+0GzMwhSY+IMbsqjMZkX3Dl7BMlmsS81sQeF9YN0umLvZzXGHt6yAC1wNYuAC/xewdc0fcEwB3QxnOlOCzvCtZwMFoW9DmsIb87AHSQBEjnmEQxm6UMUmbKGMzTUjGQeBxsMHDiBJG1UeR/kHPtJh0Y2Xo8Kw+jjJs5fiJaKcqLp0dW5hvdsap4Pn5SB4jZEt8Vjj9rYUb2ITczp74da2tvcgtq/57vNxBP33HMZo0IWv4aGDo+hHT/rSx9f080VLuncQS3WpDjcevU9uSYift7nOfd10fcxDIKf/0jp2sqt7zW6dFx86kYU01Nmu841vFgwRBRscIQuS8O9JGsoOeoTDGrLwCZvAJ7uwDMqgDMmwaM+gDZIFILkmDx/nD/ewWZfGDgzyUctTWkDUPP/C9VvqwFvngHo1plswlg7qYIKzxlPnAGM65lvA9YK4lmvERVy29Q5D1Q4qWHo9l2GXBnTEB3y/9w3CBw5CKHRE+A1FJwumYAlK1yJWcRVZgTbPB3XSl23aphbYpV1gRT9wIRxMMAS1MRu6MRv5wwPkdU6EcX55tIYpUEhI0H6BUE+0EAp1pleFBAM4UAR8kAm6YA0u0zIQFw7eYA2vwAmTwAmqMAoFSCgXYxHc0HjtQFREE4HxoHG+53sW6BPaAyI/4SpDI3ofqIMiaGO9ZXo5eA485WtClg6ThSr1YFzBxlTuUA8651Co93P84XtAuItA2B9A1x+6uGFEGBLFp3H/xmd8LpMNSlgJhWAHTrhFMLJMaXMHdiB9U7c+Y4AF2eg+ZVRG2uIEcmME3taFtZEEXigERICORDAEchR2fJEu6rZubLguWUADdvV29iVXDZQF9RUFSABIUQAJ+KQM2eANBjmIyzAMrhAKmMAJtYALqqBIm2MN1BBw4CBZKKEzkSdSMWEPwfND/cAzucdU7+AOJflEJZmSUPREn3dUtyd7szdcrjJbw7U0ByJR+FAgyfViqccO6LCD/uFzQmkOQ6lsRqlsPGcOyTaKyQYgRokOhUUORpls6FCVLEMSJDESVYmV64BQ22ALpfAJlqAIWaRFilAIfoAVifAHg+AHblmF/2gwBnE5BmCABVVgl1ewBFfwBE7Al0rgBEbgBH+pBEkgjuNIN10HXjwwZmaFG+fFVooxj+wSX3FYSHZlZ4UUBICEBH9UT5lRC9PgDdFwaLuAC7kwSKEgCrjwC6YgC8MQDQhWkQHXYUwlciIVIcT2RLlne/CgDr/FVLcEkz82ZKJSe0BznKmiasiZe8fGc+Tgi8F3jENXhMD3nMCoi9d5nUdJlNu5bFu5letglUcJnlyJlZnUlZgkiAdpDbZwCp9QCYPgCVlkNlBYCG3pB3uAn2F0I2PQn3RZBQBaBU/QBV0goE+gBAiaoApqmIe5dWQlTnEkhj2QZpAZmZIJX+03T/92Zkj3RQm0QAnyN3+UcBmxMAzK8AvKkJCdgQmdIAqs4AqmQAqvQAq7MA2iUw2ycw3fEEXpgHnMIw8neXomCYq6ZFRE9Vu0RzS1dUulYioRJVG6oxK4w3g11nvAKIRYiqUe8RFZmqXTeYRdKp3H2IvZ2R9WaZWeUp5YqZXomZ4n1A3bkA3Y4E/SAA0ggwwXQwywUAqesEVTMW1ZUZ/3mZ/6WS38CQYBCqAEaqAK2qhGwKANyn3sCKG6cRu+oVbpVqEWyhiRSV9REAX0Mn/xNU9RwH7y537tBC8PCTHT8AucwQiZAQpTAQquMAmoUEH7dA3cADvf0KP8wDzMow4luUv/Q9oOwtpE6iBpQ2qDtMekRzOSugcgZwqMxRemYIqlYjqd2HqtH7GlINGlIJGtKSQO4dAf5ToOxneu5pqe7Jqe4NAN3MARHDGnIVSn9NEo8dEe+uoL/MoMxQAMsoAKn3CWLZJMUCiobzkIbbmfhvqfiWqgT3CgjYqgj9qg2/d9usEXcTShFBqPLfCxIBuynUBv8hWHI0tvG1qqhtB+g4RXrKAZu5Av89IJfCAKnaAI8SIKotAZreAL1jBJ8voN5YAPr8IP8mCSRCVhSjth7XAOTLqTtphsyhZ01wquVnu1WHpCxheuW2utXDuMYvqtwxgOKYRJ2fqmJxSv2oANIFSv/5YCMvERt8LQHuyhr8HgC3bLr/xaDMTwC0r4CVbxpy/SfImgsG2psIXasHSJqFVQoBB7oBErsQlqsYdJbhrLseclA/G4uYbzsVHwXvLVoZQZh/UVCvB1BHQmSKHACqlgCqYACpaJCaCAV8aQC4bgCrmACVogB7yAd+e5Dg9FQ/rADylRi8AUtb23cUK4pczrEVj7Dc0bvdELr82LtijEpULYtV8rnWSrtceIth4xr7JTr3XKYHArt/HRC3PbHuprt3fbC+3Br70wv/Rbv/NbKL+wp4ZIls5FuFmBuIPKsPy5uAAKBgUauQiKwAmqTZRLN2SWP5eKqTeguZy7ufsGf//3VV9xCE/8SJlREAiZgbvGsC/9eAS3awm54AoJlAWdgAlPsAZaEAnN4FjpKRJV2VnL2xHyusM83MMd0bzQK71CPMREDMTLy7zLe8SWhLZxOqf+BEIn87bMgL5UnK/7ere+cB16q7f1ywte/MW9wDDVwQvV0be70AqksL/z2XRQ+L9uOQhiYY1ooFX96TZdwAVbUBqrURpTsBp+3MDeNm7hhLl/kxcUXMFsxY/zRbKG8KGGkFeBIGf1lQWhcCUMpG9x8KmBcASdIBqp8HZwVwRgQAq1oAvNYA1s+0HX0LYX0bb+REKwnCmyM8uaosP6YUm4vKU/XMTNu8O8rLbiS0L/5Ltg9zop9KE6xCwpVfweyGDF67uvW5zFXfzFXlwd1nzNumDGaGyIiSCflTC4idB09omfcBzH6oNl/mkWBswF7JzHU4DHfOzH2ke5TOB142ROf3HIFcwHdgZBgJQKCcR+7WVIghBPAB1BgiAInwxP7IUJcMbQhoAJtfALsWkNrYwpsZzRJDTLHCGn2dDRHx2+8lpJ1lvSK/SuQ6dC79oNKlTS4TvLT3wfC9YMEVEQjaIekMIMDOY6r7NgDNYoNc0QB0HTDGEe6HHU58Ed3NEewNDU/NrUvxDNvjAMv7ALsGAKn8AJkFCwVWEVhSDO96mw5kwW1VXHV2DAdwzPr7HW/37cBN6mdV1oz4TMF4aMyOrGB/smojRbSPEVQe4Xb39Eb/x8bwmUBg0UT4HAz0fwqWMgCg1zDKNpDdVADSOk0U4cO9gwSZpNy5rd2ZO0DaAd2qK9DSb9pnE6SZcNxeUrKQfRzBBR1LBd1JAiKQzWOhe92jmNEIxyEIpi1EndHb9tt8Ag1b4w3NFM1VZtCvIJCfI5bWcpzuMs1mNtLemMBWuwBgTaznnszn28GmgE129RG3KNz34hA+Zt3pwbX/aFj4W0shIESGmQ0IwgCFnAz/M3Z/t2b488X0dwBEUgCHWQCgwD2aJzERfdtq68ypWdKSRkDdeAyh5NSZ792Z2d2f/WQJGUbTIzLRGPwhDvEdSwjdQDwRCIBynN8AzM0Ayn80EybSkYExGIkhAw3ttHTQzBgB427r7ETdzAUNVKKJ+K0NzgvEWO4CyHyxXmXF1jBAbXDSbs/ORPvtZS8CPZx8DjKBzo+MCEDBjoPcGbmwVLcMGfq95pkMKGgAR2xrpZEG/8bGfxhVfxzQjut8k4kAVTEQu74AuFd0FQjOB+juCSXQ0XjsqZbWiDfuEZpFimgzEKwTHFkAwDEekCUdSPLuLoAenn0TGxXRAd0+km3jrQoOIrnuGnE+opfjG6LeMzrig1fuNJ7b5YLNX0K7897rfKTRVCTj5lowiOUOT2qbD/VVaFbeM2TH7dUH7saz0Fc0PlVy4c6fjAQlDIXC4DhnzehtN+8fWp+4YEn8t+/pgG9MLPrnBf9HUE90UvjMCieQXfEQ0KDfMLmTNQdbri0BBCpX4yilU6FxPjv73UwBAMNh7wAK/U3IHj6ZHU3pEox6DwDH8MI77pNm3iJ446ruM6N2rvMl3qqB4RNM3hDIEe7UHwTP3vxi2/9lu/gRKwn9AigvuEuw4JjgAjhovkWCZ1Y9TkTn7sxz7Pc+Nt4p2OYkhmdA0YRD/Bmit/2h7mK0vJIApP8lQvbt5+93W7nSEKmACrg5QKmOAKVe0LxVB4HbRYob7oGIOACdHqwr3F/yUfzU3d9gT/9gWP4wDPt0pd6ZCO6UcN8UItERPP0yxODRTJDDzt5/ehaB1P0yVe1JiuryIfDMPt+Fxsv9f87r9QC6gACp5gCbkOjVYB8/VpnzSPI1JnXU2u81C+1jzP7OSojrPx7GSmJEVf3jIQBZTwqXO19J4qSLSPQPcVX+b+5sZAC2OpZ/SSL5DgCsMwDN+RaNSw7weYDOAR99zR1HDf9tbf9sV9/dq//W6/1I4f8gB/4+Lv6u5R/pQuEOnBMYiXgClu2xouDTcqOs3w5z1t6rm9KJqe4wM//U7t1CY/vwCxS+DAXb8M1kIFChMmTwstQVIUESIkiIoSJSo0iP/Qxj110NTxiAYNFixW1qzhklLlypVUnCRx8jLJzJgzbTLBiZMITiE9e/TsqUPHDaJFjRqNkiZQqlCUhrmKYihQlihRKHVKkzTLVKpVs2QxhJWPH0WdDBkK1UnQpGHL3EaD61bZ3GPKjh0jlvfu3bx5Df4FFljwYMKFgfki7AtxYMWNGweDHFkYMmGSkRXDnDlZsWR1585txqwZNGjSTJuOJo0aaWvYtmGrdlo26WfPmN3GnbtZMmTIiBWD3JcYY8SOex3vRXDgX4QKLTXE9LAiRUeOIl68uJFQx48hRZY8iZLleC4uYdakKfNmTvZEgL4XInTo/BtDjeqgGqhTlk7/oQxVpQSqINIIq5NAkjowKaX4SIMqPlLpRJE0lMoqClB2mWYaazaEq8O47NrrrmKOMWaYYYT7LUUUT2SRmGH4YjFEF/UiBq9i+uIsGR13zAyzy3rDbMfO7kpGmWRwawYZ0ZoZjbRkmGwmGmiq2YYbbZzBkpneKBOmSy8jg6wx5MbsRTHkeEGzFzR50aVNN99ss5jDbDGFE0j88ISTSx6KqM+LqmvkkEA36qOPPOhAFA44zBBDDC/E+AJSL7iwgtLypqCCCyiccCkmTz9Vz4mc3IOv1B7k0yGHHFJVNYcaWqUKCf4m/I+PQJCw6j9GOtGKKkPS8K+qKI7ggxZcBBGE/5L/knoCE2MypIYaD6NZZq5qQ8QWRW233dZEbre9MUchOeuxmN42y/GYInWEst0l22VSx9KeycabcLR5JsvbtsTNy8y6hIzM43gZGE03DdblFoUTVrhhhYMp85ZTPrmEEE880eSSSx5ZZJFHOF6kEZEFDfSQQumAI9FFG32UZStepuJlKKCggopNQcVZPSmSYI+JUk3tgQdUWyUaCSCiqiqVVJaoSlZKgqAkiifAajCNVCik6itDchEFE1o6MSurLLqAJJYMrVmmGWWaWYbaaunCdq8eV+TWRLvvFu7GvH8rl8dztwRcy960ZOZI0XK7DUssm3mGcWhsq+2ZbcJZJ/+ca6SpxjZo9h1cNB23BBhMMAdWc02HT78lzV66rKYaanoZZZNHDvnEk0w0BtljjkXmvWRDUVaZUUdZ9gLmmG2eueac01MviZ3Z+7lUHoQQWgceqmd11aO1ooWWNKDmlWk+lo2CwSOiCOIssH4NJCxgO6Hkqv8CScMPR15ZZppliqw2ymg+g9tdjDQkzAgHb92aUV5OhKMUlYtc4uLN3/iFG2TsqHBIOlziauOMyNUGGdLg4OVahwxrbCMb2JAGNNoVOcYhjnBegmEMYYilZ5imGtfAhja40Q1wgCMclKMHPeYBjVVsIhKN+IQmboe7j4HsEb0bWaEOFTxHtcxRL7P/QsyymLybgcomzZsJ9KIHlKBZ73pnvB6qdACELDTIEK6gRINitYRQZKUTrkCLfiaER2BdhQ+U4EP5lBKKtITiK3wARSJM0Za3sQ0a/wNgJI3ElxqFyG6V3AuK8PItvullL+hy4LksWDh4lRJKtWHSM0hDGsdZgxqzmIWaiOGLXnSIlR2koeJ06YzTXAOH2tDhN8QxDnTQox7GtEc+kqkPfbCjHs8M4jOVSQ9prOIUkohE7ZaIu4117GMiWwQiSnaHPshBDoqCAxu+sE7heaF4WIQZzTbVqZyhZz2jItV7erBPofBzn/88lXzSgKsoUAWQTMvaVzAxjVzkKhRLMISy/wxBi6sgC0CBiJ8hIHSEJVAiFXwoRCJsoYxlEEMZ1IoGkyQZwE3GraWZ7AslOdk3HvVIRz46122epDZTnrI27+rg46BBDWkwQxquXAYwelEMxtVQNje8BjC58Q1homMd9LBHVrWq1Xx0tavM9Ic/+iHWf4yVmV9lpj6UeY1ZXDObGFvix7qpu0CFs2SHIOc5FaVOdhLPncUrHvLmWU973pMJRMjnzwC6WMYGYVhUg2MWcGUIQZTvWbiIyq8yygg+CCIVtDBfFq5iNfcd4QiiDWQc2AALRr4FSisFkUvnxkkUBaO2fLMpKHUktwgeKTQ6MlJPm9rB2tDmcabJV+uqAf8NZDgjqtr4xjiI6cx6JNOrXk1rdtO6Veui1R/6CKtau2oPaFZXiNVYxSgyVjslasy93XwiOBGhHUKU05x7ZUN+/frX4wmWsJ+yCc948h7EJhYo0xPCPuED0PNFIRCBJBBVOpoK/hiDFn4YXxooQdFA8oERFo7ohEJhDP8EwpBHYCPVohCHKSzyLW5RodoAeC0Z4TYz3IIMMGzblx2nCDKAAzKQj1TB3DiDGUZO3C43yEGnYu6GOeRGlH3IDWxcoxrY4MY65pHVfIA3rF/+rlrFDF4yfzfM3M0qNNmx5jWjgx3zWEec0TFne9BjHdaYRZ0Swd6MvZeJvAundgplTr3/5le/f32ZO2sm2C7+94s9Awpif3Y9n4xRCOc7rbC88hVBZKGyYxBFICkRivYJ67P+ocRXQgFaPtzRkFTT8IP9kAhSDCND05CWtIYqrWhMw0NtO8xixCSwMjnGMYlZjGSCIUNmM6NLztZlL587Vem6mR3GPCZW0Vzdr365H98ea5i9mszudpm89WjHmoU4D3bH2d3vfvecfxiOccA5HNSQBSowUYmLaaLPcoUv7xAxX0LcgdDozO86v2AGhlfReDWbWaP/W5OeSVonZPwJ9XiQ8QQD1CdZOEIQTvsrB3ulfIFsVlbkmDUkjG/DrmjfWcQXllRPJVft60QcQDGMXk9L/4UfIqlbkhqY4QiG2Een5Zh8ITrJwDDJNMTcL6ErzOlW95n2wId1tZtWcZ+12/zgxz7uIQ94kD0e7miztedsDnOUw+3lQAfc4T7nOcv53ZSbN+XinPdw2NsasjBFQ/rd5/dyLL6HGPhG8nrfdPJ14S5bdBYhPrOJe7Hi7rk4GXtCac1jvAcFpV8b2/ifNmaFoF4xRBttjlBgtS+OJ0/K1eBX0KtMpX2KSAWG3nZSZTA1SHMZ0gITqFRir2lNR1+2l47sVF8Gc5hWvTYyyQv2sIK7H/uwPrj5kQ983MP73z+7O9BeDna4nRzkKMf5x6F+6bbf/e93vzjkbw5yoEO64v/ooVXxPm/p8r3vP8QzUwCFSQAFuPKzPxOZxCs4+yo0dWqDx3unRZPAiJu486C49uiJw8onBds8fSKjVBEC1asQXGmj/agKBimoKOgPNjILQ2AQAgmE0EOLtACWVDCxXwG5qSAQQ2AERQAFXBgGY1CGYfiMmyqSEbELYBC+zIiMMYGYXki+wakhqJKqb+ihcdCyIJK+8ro6buuyePi+sZMHsoMHeHiHM1SHdHi78ns78zu/t6O/84vD8yOH9vuhYRoH+dNDcNBD/PPDPuyhQKQqcOiGQvShcCDEQizEcOiGbYiGWSgFTpgE9tomP4uvRlDAvIIDvWq8NlADRnGnRAv/rMmjPMKywJdoD1IpMIw7MA/0CR3oiV+RIzkaH7Cxilc7i7OYkDTIMNHyjzZKBVdgCgORRdv7I6Wgn18RBFoIxlwwhmc8hpIaDkw6hmEYkc9REsXpJWCyQmKKMy2sB+zaurN6pnIsR3dItzVLP/TTQ+mqw/aTv/WrQzxsPzp8wzmku3eEv3jMwz6UP3CQrkAEh0HsoW/ohiiLMm04ISs7DWgwsspQk8rwBV1YBVJQIlBIIsIrvEsMtIJbPL1ygzYQyb8KRSxatIhrtPQIsAC7vAIjlX/aPATruJ9ZOfqpmjToDz7gD/bRMDf6jztqkNpzNReEKPipORcMBZ3cih3s/0EwgARXCMJnLBG7MYgXSZtmoJIfuipuI7ev6rKv3Dozy4d7qId4KMt6GD83nEf5Oz+2BMRApEdiojv7ez85NAe6a785cz+9hL/+K0iDTMgqY0jkekhhKB3jQ52GOY6EaYVR0BiM9LcDxB1AIzi8KqdyUpSQFMlGcTgJPMlS9BSaWEnD0kCXZEWN67xSmZCqmJADiRXU+hUcVApKiEFgyQVMEARC2gr/iE3apEG0+I9O+wrREwQ+6CyvwQVaaIVW8ARQEAVQ4ARTwAVliJYrCwc0QzNlUqZsezN2m4c3szOrEs91QAe2M8/zvMu1u7/3Y7u+JKb3jL+47EtEDMSE1P8GwRzMfKEggCETxDQ+XkhMhZGFWAJQW2jMTJAEyIzMA/ymRuiY+bJMBpQDzfzEdjJJyZs8nLHA0QwjfCrNSBOCIbC095AfpUCLqMGVUPiopWwQ/Ui1iLqKtBhO0Rq1NMiFr3EFrMAonYyaLEDBgvoKZcGERJiESfAERliIO5kDUtAFa8iGbICuq2IHeJOz95tLq4q3OPNOLV0HNnO3KV2zOPNSu7vSunO3H8JLeKSqb7DP+/Sl2DCNx1EcZ5sMGQoTM+nP/2STNklMW/BTW9gFPk2vTbgEjOw3yfyYcHpQxZMiTuSrhiNJL/BMiNPQDR3NnsEnSSOCIeBUEQUKTi3/lWAEpDYCpCJYglijzdTTSVuhFfnJmiXImk7IhQBJCw6TKLCJKKmII4+SKEzoBF/FhLAIhWDtBFGwBWqoMmyA0qla0yukN4DMS3nzv8rhu7yUMyytOywlT3ejO62ctx46SPvEBvxULuV6U+QqrlWKHBpqHM4BnMrIMTPB0z11k4aBJViShXyVhYaxhVOInUwoQE+wBEuohIId2IL1mIFTQD2YIjxAFERhFDNYlEhFtJrZIv+KCSjgUJ7pUKDQCZfc1E59D0+Fj7BZza4AC2WJufUh1VYzi6RMg1NtNUEAzhnsjwBRlv6QitnEKAjBClwdtfhhhKugBE7AhWhQrtYA/6allSqEJEj/g9q8o9K907u8G8hwBSb8tDLlko2u9Vonax3MSaEaWqXHgRdsBJwcCzbjUBM44dNbYJg/9VM3wYX0ush+I1iDRdgHVdiN0AM9wAM80IOHpYMyMNyVcacqCkWLZVzk8aKVxAkBa8kC61SRHSNACqSCmpANix9ipB8G8UWcDUaSE6QsoIVh4IMRS7WMcjBdtMnS0yg4cgU4uln4KRBQ0IVmcDJqaA0cGtffzSGm1YaDVMRusJeopU9FNKGF3NqvjVPaeN7SIA3n9Voru5yGbBLaaFchAaUbEwxjw9PkGIjSeRNcwAVdON9A9dNWSAhPEAW8zduCrYSOCf8nhSU4wBVch0WUM+Bf4eHMUFzcyNsiiQMjlpxcxGKCJLDcnlhgIYhNXmRNQgraXY0w+QmFXChOzt00Wc0F+DGkgko9HQwL9rGVUWuK/kgLsAEbSgBWU9gFYZgS1+FdX6Jh3wXecX3SHB7XN+XaOCUuXNJeVZrerx1i5y1bsTXXa7AGJE4h2oiXwtmtAiq6ogu241hb5NiFpCOTgWgT5QjUV6gTTHjfixlYgj3Y+aXf+vVbwP1bwuVfzvzfxL0iLAos0CzFAJOC5xmVTEVgm6jcEMXUHeTFiBIEnxyfsyAkQR6tKOgeYVGKrDmL2aOf9jFROGIftICjq7Bd+DFKsMH/BFTYBWCooWjBNWsoV9lYMsFhtt7oki3RDHbxqaAa4tIw4lWaDRtKYhy6BlUiKlZqF+7tDL0JhsEoDi0WGII5zP+EE14IjECNhVR43zHGmIM9YzTm2zUW3MHlXzo4gzJoFIYDxUcBRXiSvJsBTXvKY8k9LExlgp2RAkwFZHUOm/gBXQh2wfI5C4lqIwaxua9oEAVZShOLwdSjPdpMxtHD1YhS4RhFYbA5XWA4FwCCoSc8TOQIBlpKOseIjLx4Ze41JaGy5VouW1su1xu6oWzgWrNdksKpoJuaGzD5Xi0+Pj01PrfVBV7A03wzBTG+mGkmWE2I3zTuyL/NZjzgX/71/2ZwbicxYDiSNB6URMnQdJ4OzYk8zuOqnmp1HgJ2dgVUU8oswE2aTRbj/JXxYVXaZE0SDL3NJZCCOtWqOAuuyFXNIiRh7Y+bHbVOYITc+wViuOjBUDpjLhjVOY5jM4xgMJcJQhx2/eF1ZbJ8EeLHUSVpmGxaloZs6AZsyBcjcwYl0anLMJfuZbphNmY9PY6my8YpQdZsmJwf8gZgUAVS4ARpnuZKqGZrVmP8zV9u5t8wYDhF8d//tYLAiqeIY7RPsep3rurkbmervlR2DhaCjgq9Hh9aMCT18VFbkdWlcbCquWSx2YoZVUFS08FaNGGFBpsTVu9QAIVUwAXEKOwrHv8Tgjk+gTHswoCMVQYdxVYyx2Zs4ppespWccNgGVbINzkYyVq5TZpOh1I46Zd0G4503LfPOdtvScHhtayIFUZBmoC7j+JXf3MbfNkZq30an4J5jmLkiiGNc0JyCKdCCq17u5KbxnYHcntnJ4bwjRhAEDvY02pzRLLjgODLOm6wa1uwEG+TFOBLGiDKk97nrGDXhKS8kWgAFULAFYni2nzqyXcoSXWKG+tZijQ6T/IYhfplTU2ocZxiu/15Xyn4cLXGGbmBEykYyJNuXLscSG/IlbFhEyqnwQK/wM/3WgZyqHto7byCG9PoE2vbwMpbfva1fwKUDSt/fbkYZ/3WnRRn/Z3K2GSegGcf1lCm4ahlnjxpPZ+em6pxwHwRhCkZAZBfEhNeDQX++ZElWFiBFYQrZ3Hw2CxP+mmSp66D9VU72ZE4YhV6gZRyCU+o9DdugDIgZ7eTrksQOnCLTl3fhoC/PJS+nIYcUBmcgKswpja1tHanjhkP0znUL9DMNxHBFSHCId0MXSK3UsspR9FUohUbvaZ+G9BCn38RjY0vnbU5vuEZBXHKuY1CnQIaHAlSf8RqfCVUXsAAbHx8VvR08pOL8jyMgkBYNBVdIWbx2wQnpj1SIa12klSxIhQ72YGWZcozqBFowBlHIBTjChNltBWSYQh529q4lDToFnSgEEu51/yE91yXi8vZdOo0nU9Zq6IVZQAaF4QVp6Dt2CyI4kzOApM81TUiEBPuwZ1avjzJELN5F9IZtsAZfqEj37elH/3dJX9S/JerA3V+lBmemTnFRLG4KREkpiHFUF3xUX0mr5pWrAIvR+4qk6CyqaJAjUB+Uv6OpyFWfhJA6sr1Uxbm0kJ/Pih9C+nUOzoWnSAVWoAVTUIUuca7W4SA7X3rFAbIg6RHPJpzFVpzIIY3br42naj4dirJupPAK7wZpEAajcobJuAZEJHuwr0+E9P02FV7h3aGzx3Dl3YbrtwZq0QVViOa3//C4XwRrJjhCoHu771+JPXG9fydRXP9Pp7xQf//4wNeCwM/j+R98Gp/45AakG/XROPp4WQSINIICpTGURVAnPoaipKLFJ1AgQ4bSZMliKBREixAlUjIUqFOUNB1TTTNGqVOolCpTiUrVKde0XKAmjeolzBlOZ8KEBevpM1ivYDt3IhNW7CjSo8eSMWXWrBnOZ1KfQYP2TJq0atWucdWm7Ru4cejW0Strtqw9evXq0WPHDh26eePGhQvH7ZpWbNm6hQPXDdy3wNwGEx7s1bDXw4m9YvOaLZteyFyrYbXKrBgxX714AeOlS1ctVKZAifJk2pMmS6pTW6rk+vWiRYgQEaqtRw8ePHTOlIEDhw5wOGbEmBnuxYoVL8qPI6f/AsUJlOhUpkOZokWKFC3XsWfXzv37lPDhsSf5LoViJ0pRAlFKU/AiRT58shQMlLKTK4kU2aM0mIVPKO6lEcpJHhlCCXsFERjKNKlQctKDnUjYCSMSumIMLZhMssktQznDDDI/9eRLMCT6NFRPQyEDolNSQYMVV41xA04466wzzzxn2bMjjzy69RY65qDDzjjmGEkOOXONQw46dNX1ZF3ggLNOOIFZ+U1hhS2GDZdc4UWZVB8WJYxmm/HCyy1pqmnLLbt8ZossqICCSWmnsaYJa6/BJhtttRFym268ATeocMQNJ8ZyyyFnhXPSTdeodd1td512lXonhXiZToHpeFLw/8EIH5SEWlAWnSxEH0GBhERJSq64glJ7aUT0oEisRvTRgR6xRxCrKnXE6oMnhZJesCgxggkkn3R4EzTNjLnTiCIiExVWW8n4V403otUjjzjOsw5c6JBjI7ljjUUuuunClS6VdYE1FzhjOSllN/Vy0w1k2HCF1TMfMjOUML0IfCYvAhtsJsG6rGmLLZ/pYkstqpCiiSh1oqaaJXnqGRufftqG2255ACcyHcIVdyhziC5K3XSMSseFpTHLjJ2mmnJxc3gJKZRFIBZ1NNGqGUUkiCG5uDJsewci6NFJqMq69IE8F5RKKLmEwhGBDzY0IdKYgNLJJKasspMz0ESTDIhABXlVFDM4SZNNjTieNfdZcoklLpLkiCPOXOX8GC644a7LLrqDD/6klFKK881XXk1GmTTQ+PsvwEKpbebABGducMK64IILw54/LMsppHhSsZ0YY7wxx7J5/LFuJNMhsm8nG4ccosw9SkVzL1eqhsyW0jwFzsTjfDPyXAQEACH5BABkAAAALAAAAABAAQABh+W6m9uujdeoh9OnidCni9Skg9Ckhs6jhsqiiMuhg8ydfMecgcWcgcWZfsOafr+Zfr+We8SSa7+Sc72Sc7ySdLuObrmSdbmOb7mMbLWQdrSOcrSNcLaLbLCLcLWKbrWJZrGJbK2Jb7OIarOGabCGa7WGXbGFYq2Gba2Gaa2Eaq2FZKyDY7GBWq2BX6uBY6t+XamAZqqAX6l9W6eDaKd/Yqd+ZKd9XqSBZ6GBaKN+YqJ9YqV8YqR8YqV7XKF7YJ57YaZ6Wqd2UKN5YKN2VaJ5X6J1V6F5YaF3YKF4XKB1WqBzVp55YJ92YJ51X594W552XJ91XJ50XZ5xXJ5yU514YJx2X514XJ10XZx0Wp1zXZxzXZ1zWpxyXJ1wW5xyWZxwTpp3YJt3XJt1Xpp0XZtyXJlzXJp2Wpp0WZpyV5txW5pxW5pwWplwWppxWJlvWJpvUJh1XJhzWZdyWJR1XpVyWZZxWJdwVpZwVJJwWJduV5ZuUpNvVI9uVptrSJdsUZZrUJVsUpRpSpFtU5FrUpJrTpFoT5FmRY5rUY5pUI5mUIlpU4hlUI1nS41kSIhlSo9iQothR4lhSIdiSodgRoRhSoJfSYNgRYJeQ4VcP4FcRIBcRH5bQn9ZP4FUNHlbR3pYQXpXP3pVQHpWO3ZVPnhTPnlTOHNTPHZQOHFQOHJMMWxOOGxJMmZLOGRHM2hELGBEMGY9Il8/KltBL1o9K1k7J1k3IVQ9LFI5KFM3JU43J1E1JVE1H0s1JFIyHU0yIUsyIFAuFkouGkcxI0cwHkcrGEMvIEAuIUArHUEpGDspGz4mFz8kEDklFjQkFzweCjQdDC4dEC0YCCYYDCIUCSISBxsSByEQBCELARoQBRoKARYPBBULAhUJARUEAA4MAgwKAQgKAQwJAQcJAQ4IAQkHAQcHAAQHAQ8FAAkFAAcFAAcEAAUFAAUEAAIEAA8BAAsBAAkBAAYDAAYAAAQDAQQCAAQBAAQAAAMAAAECAAIBAAABAgABAAEAAgEAAAAAAgAAAAj/AKe8eVMECIYBIooUBPJlypdAD6e0mGLojY0ifmxMaoRGD0EgL0LKGNmihQkTLUKaNCGj5MgeKhDV8kUMWbRu0ZAFC7br1jBVPoZ8GQKkhxMnU5IqUTJEScMhUIEAITqy6lSpI0HKkIq1ag8bRXvEcBGjLJCRL0qqLZn2JEq1LEx8iHuy5NQvk1zVohXM2S9et3AJvnXL1i1atV6N2vRpkyVOnDJdoiTJ0SJGiBAJAmQHy5MtUITUgJECxAbTFihAcMBgwYIEBAgEmE07wIABBBI86DBjhgYGCA4caEDi07Ju7tzBk8dcHrzn8LRt00Z9Ojbq2rBpx1aN+nbt1apt/+O2bTw3bs088eFDB0yHDDMy8L4Bh9ElUquIXeuG/F22bNZQI6CAb0wBxFIyJNCAEgdCNYRDgUwB1RRFfKVEI3roMckdHoGUUkstyFBXiDKo9FaIU9GQQyu7DGMTTsv00ktPvNCyxFRE2dCDQg46KOFZUkV1llVcZXXgF19wxZUNLwzkxxRirbCCSmuVNKJbVp70wQdY2jVFIJOsUksvwTzDyzCBCYYLYYHtQosqm3ACyiWgQLZJJpVIoqcjmA3CWRtutBEaDTCgAIKhG6S2mgOsIUDAALUFIMAACUCAwhmXpJJKIRoEJxwCEMzxSjTJ9Qfdc+VNh90212W3XTXfgf8Hq3TnnTcON9G0wsccc/xwgw44hBDCCTOEMUgmpKiCy03JTWPNNM5SEw01BSpE4QQDqCCQRTZ8aYiBMqwAhIFJ6fEHJoQslVZKba1l5BAi1vXCSCp08EkwvyBDTDDIxDijLrf4skcPMuSoo5JXYZVSkVVtJdRQRAWZFMIlvtBDUjaQ5cIKWa4lr0lcuiUyC3SF+EUfhojiCjC9EPPMMMOoqSbAuuyyiyt1isKJKKKA8gknmlwyiSWTVNbnHn62gQUSPBTqAqKKOrAaAwkc8KikkxqwwAZYTHJKKYygwIBwsSHAwAMh8GHLNf9lw8057zxXDTXdYaedd9fFyl143V3/x82tf5eXjTCU8ErHIXSEkcMJw+KQhyShmNIKMvvRDe00AkYz0B9JFfFCAgpIpYS1XybVx1IF2WDDG3/80QgSNnDclsgoqbTVSmyNZCgeu/C7zCym3LLTL7rYQowmNkT1FVgInxVDiVtpVfG8ODJcVUghlRXDC0W8oYSUZblQpVrYtyQy+SSn38KWISrBiSu9AEOMM8T8IjMuuqzJS81vguL/KAD0H2QwkYlMEM1oiGBEIThzhqXxwAY0UAFqVKMa1lTtNgPIWqVIgIQ2wAACViOAAWRDgAOcDQIzUIQqlGENa2RjOqx6Vd5apbdXhSdv2hgH4MhzjvFEgxW7soQl/xhhhjAEKwQzYMIhNmEKVcziGdIQ0OVauC3vCQQDBhgBhQQSiAJ5j0FFKYISxGIDJGCiByPgGO22VLvZsSst84oBCEAwg1gEY37L+EUwZBQMXwjPFTZgilRisILnNUwGhLRKVrDHSBAxcl7YG8sKyDJJFajABZi0wfhOYj6UdEktbmEj+xiCiZUh5hXEu5+aeOELX+wiFqj4BChMYQoA8gwyuLyEECfhiEjwCRGEuMMZrOCEHkQQNRaImgOqdgAM3sYAB3iNbGxTmxFSqgEQyAADcMAKZmCObze8oTZgBZ5YwYpv1xmPDnXIDXic453cyMYwKkEJIV5iDzqgQggycP+CG5SBEqRoYjep4awAWYOLXfyDIYoAOosAoXtKGIgSBNIDF1CoB18ZgRLQsDHaaamN5CNJXUxAgQ2EABXyQ4YzhrETMvmiZr1wQhGI8gIptSAGJSnLTbVnSLTMy6ctodKHGLkxKU1yBZYcwSU96tGOZSmUW+JS+0QBC2BowhPBGIb9aiaYXeTvF79wJS1aAUBa1rIUPEurziKjS13ykhGE2EMc0IAFY0pwAxdIVAWplgBnYpCakYqUAaC5AAAQAAE4aMUzDEpQcp4TPHSzITizsw12rnM56HDnOboBDVt4ohKOcAQicKCDfWogBTrgQyVC4QlP2CIaLWzhQCpiRSD/YEtcAoHSFB4RiHF5zmIZ5UAMAqECuYSMqR4DpSfz2gFEtIwYy2ApT/QYDFwQgxE9kEoLLOlUlzxyemhZC5VCApIXhM+ohXSBJTVGu45djy3riu9xOfmFUtQCGKiQnC58gT+b2UwwYXUlLmbRClOgIr9fK4WCF3xLXHJCl6E9hCCCubQcwAAEHjDNBSpowQMMdgAGuI1tREwbANRGxABIMQEeMAdZPIMa13jWY/nWQmy0EJzixEZlbXUObjQHOudwxzmQYYrPhjYMwnoPb6gwiEV8QhOqQEZsN+dFMa5gOGDh4hse8YjcFoFCRRABB0ZwgTf0QJTHfSP2QIlTlKzg/wIe2IAVahGMZSDjF9J1JX+XIQoalGi7KmjzW2pHIvKCd11DfSNIzgs+9aYxBjYYS8dUsmZQsut6LzifyVJR1WU4wxn46uouZEa8VtqMFqxQxYFNcYoEt1rBaeUEWh8MYUbAVQ9ocEIOVIACQ3lgwxCY2muq9mEBBDYAKU62iZGd7MNqQBG3eMY1qGENHIcntnQL56yks8PzPMc5p3qONV5BCUqE1gcoGFYGMoDEIxQiE54YxROvMZSJdq+LUxhBAoaLCSUYIhCPeAPA+wCRIbARAxh4wR84tgIufcC7JEmJldilPRSogAZmiMUyNg4zfPUirLhYRi3C0IMXfAADF/+A5LxcgpZDfghEJhBJxRxGxoltr3tFKKRYxOexET3VLZQG+sJG8oiVedoZOdFqWAOsC13ccScex0UrVEGKqoOCZ5mITAGzjksDEo1PcL2DGXxAAxScRq/C7nCIM3gbARibNhiMjdwRQHcELIABDkAbJXxhDeRA5x3JAXxyuIONbOi4VkF+p+JrZatxhKPH57gGLyrBh0EQghBWuME+H8CAYjGCiahghS+m4pBtfakIDSizmZXA5UBESChAOPkHOMBGQ8hAqibJ9MzZshIT8DQGKCikE1Cx8WVktaVh1QUxiCEIJpmAAxfYCqZnjpV1LdIk4o3eVl7gAotFWuF/AAL/bnuwAqae75O4i/mJslLK+xafX62M/0udfsddvKIVr6DFWPMbilGgtU47AxlqBYBuxUuIsAfDVHYrgAK/ZgGLsiiv0UzO5HYU6ExyV0IHUHcJ4BoI8AA4YArKcA3u8A5vgxzJkRzPQjfWgA3kIWRB9g6Lx3h/Mw7nAA+skg3PAESDIAiIUAczcAIdgDYzoAN1IAkGhgpD0AdKGAh98BD/xgEQsCNiVBFDkRUmgAFcgoUnF1EcYEnsE3OVNju+pz02IAIrYANO4AjQZXz4AlYB5gvOsAl+9nwYoH0+JXNC9VPk4yErkT2qEwMqMEkbMxYxkBQwwVRpZn6ehH28JwNF/+d+G7cT89d0+YMLfdQLq0AJi1AJqOAKsTB1+TUKpHAKVXcKqYAKVVd1swYZBWQJkcAIgyAHVqADZAc1FFRBruFhHuZXk2KBF3hYdecoZ/MAP8AKzpAN18A2L1Qe3HA50LKChbcdbtMN52Ee8XQe70CD4/Af0aALnrAIh5AZP0AsPzgDOUAHiJAJqDAuUMEUQoExqdcDSLAUSmJyFRBVJ4eFJmAIgVZ+b0FpvJdTMqAjOjICLmADZrAHtcBxMOOGbugMrsADQPB8HCB90CNzf8Z76/KPmfYCQ1JTZxglUhKIRlVTIjACvaclIZMSKvlRKIGPJwIEmJAK8CM/xkc8lf+oJrSQP7GwCU0mCZsgJm4SC6yACqtwhKgQC7WwCqjwav8ngA82CbAodmeABBHEgBdgAVmpGg3QAMNGbBjUi371i8DoKIf1ANk0B6pAC8sQDdEgDdAiDdAwl3MpDXCJOQQ1DSxIHtPRNm4DN+OQNy6UK4sAjohwCDlgBjrQG8UiCJbQMF1RIkBQAQ1whjrSAzT1AfeYj5qJAXJRIDFAfi1QfhJHaZD0EhiFRpA2BGawCnaGZw3ZhseADMBgBTFAkZhmO9VHaeazki0wBIFgCEOwMF/BU0g1koFWFpkGVTC5Emy0Psy5kh6JCZ1wCrAwJizjX6N2P7uwCoswCIVQCIz/AAq0sIa/8ImqoAqrsAqxAAy0sAqt5pQK9jWg4BiitQfB5AQ88DSm0YCqMTVemQBg6VdjeYF0N3d4BwHCQgm68Ax0+aDQ4JZvGQ3QYJdwSQ00VHhtQx7ncR3ZUA3u0A3F8I2KgAiOIAhhAAc/ICw/YAaOtGbREwMKUAGqg1HwwgEVoIX3iAE5ioVA8AiBVBaOND7lc5k9wAEcYxSXUBNZ1XFtqAzD4AyDUFxixkgaeYcs1xaIhiLQAwSRpj3qpQJmiFTdp14ig49sdKYxZyVR5VEvYAiPMAmlcAp6ISO4sJ21gAu1UAtuUglyAAiAOgiSMAq78Axu6RezwAqtsAqv/7B8rnBg8TmfpzhrQsMIfHIHdVV2ICACGhY1qxGgCfBhBOqLsXEAtQGMDBAACNABlGALysAMz/AMzDCrzfAMzXCrzcAMzVCX0wArMaSh18gN1bENz+EOhKkIjiAJjFAHS6A4SLSc5DN0tqUAIwCIbMqjElABOaqtPPoBI2AISACIxWUChcSIITWQGGUD+mgxCml8MCNdeMYMUVoK5SdmQ1qabmR9tgNHevghhRQ+KqBUYzYCIiACgagCxwWTayRV6oemMHkygYAJkCAKSjkjNrOnuyAjS4kIcWAHZ4AGaCAJlIAKu+AMbHMNyzBgsvAKfYGJqoYKp3hgmpIK9ElrUv8pCLlGA5OEAiIQZxtGARwWgSH0KGHpdn5lAClGG3K3bAgQAp5Qnq/KDFE7q8lQtcnADBH6ls5ieL4qg7bCHM8xON/IJ5EACEuwBDpwAlgSXzEAEkPgAglAAd76At1aARKQrdqqmZuJAf6WnOQaIvBVPluRrnR7jy9gAzqQH/vyrjsxDMygUrGwA2L6AUBwpYh2EmuGaObDLiEliEg1Akq1AgSrVKDrUVGVkjDJAaHEoznKAbRHuWJka5EwCZegCZvgP5+Qu7mrCYgQBmawBD7gBEhgqZWgCmXSd9cQDcvgC7NQnsjwCq6wnqsws+upKV+jMzojlYCABrADQStAAhj/liiKMjUCSjZE23YUKJbKVmLJFgAEwABG8Am40C/KUL9UW7Wz+qqGWqE6RnjjAU9wcw7NIQ8h+gytoAhGwwhoUANHkJHzwiQFsRASoAAcYHJbgnAIp63cio8j8Agmd1NP9UaXxhXQioZhkAn7snz78nTLsC+9cAMbgHCEBMKJ9hYW2RLhApLb82f/OprImaYnkpKge5LlV0gBG7Bp6nCuu8RLXK1oQAiNsBG2RgiFMAiwaGuIMAgeawVmYAd6wIN7gAiU4AmtQAywdbLRoAy5YAu28AqskGrxKQpzila3dAmcYAl8IghVmQMWhgIdoAGK8p+MwlcCunZuhzVG60yD/yUcAiqgdXd32UQFptAXsGUNyUht1lDJyUtQ1JANiccfyfFOcYMO6BA3gtcNyjAKoMUIjfAHMAAiKIJRXzY6sZcAFWByWMi6GqzBufwBIlAgJ1EWXbKlgbsSZNEDZjAILcO4y9cXyEATdGAB2vq3x7l97oJIzoPDouvD/iglJkCSCAvEKunLBTvEBWtJgeYCBeu6UbXOIoByFXABF4ABHCACSqAHrNwIl/cHeuAHhKAHgKAHl4cGZmAFZ9AGdoA0d2DFljAKbOmWlhxjacwLsoB/rXBgTWm91wuVl5DHueYEPlAoqAEBgCzIraEAhYy+zjQbijxY0HQAzFS+CcAADP+QAXTQCm1pyXkpoW5pqJhTbdvggtSoeO/ETkF2gtDQCoU5CHngBn/mkVyxRUNwEhKQACe3y3aL1b38AcPVcLTDMTilFjalXIHWA2fgA65ADO8qXX2RssSwCRlwARKgPdv1PBhZMBFTuS1RuQ8XSiKDzkmMjxyAcG1qXGl6Flsy2A53wfnYowjHAd3zB643EAPhEW9wB0iABmdgBk7AxV6ABhxiBzzoCJqACmxpqNMi0c+gDL8wC/e3nkY5vTQLawp2x69ICHYgdrWIYRaAYVu5KF0ZgWs3qgTq0ossHMhtQhDQAYpAC9FwDag9l7H6DFdbl3ZZN6tiHuMwHsx4Hu7/kA25UAl4MN7UVxQHIiFb8XwJkK0TMAFavcFRRc9fcHtffVOQJF4hcRI6hwY0wAlQp9Ywg0e+EAyucAIeUAEqcFM2cD0KMyV7DXNpMV9+Ddjm57BoqoVygYW0N870jMGs66NTMFFfJBAgC9p0dRRI0NlYANqAIAejnQlBuQvEAKuoPS3R8AwtjAuv7QrRy5Sv9mpRCVcHuMcwQAIeAL4N6IDBBgHBHarETdzG/dJVw0wMgEKVwBcbF6u7Cg1Uu6sW2qt2cx2+mir/u1ndkB67MsLRQxXPg4UQoADZerfairfcqoWs2wIT6RZgvT1dwVNU8jxOcNZ7IONNCjPIEKvE/4ALvfADHvABUIEkVDEu6I0ihXa5JxJKZDEWAetzzmnhuPd8ObolpTsCruvhHs4lV/EgDqIQCoEUsOMDsO4EWOAFd7C9hGCptTsKrYALwxC1dMnTL0MLsjALsdDjTWmKQC40jiCV+RnSwcezvp0a/9nkyT3cbDeqa/fS2Q5NDGABJ/ADqOALyDCrzJAMt1ruu/qW111D2b0N7wCD2dAN1CALngBfWUFTIhLqE9wAd0vnvGzq29oSK3k90RMWGFV9YCFGWPADsaATeFYTh25nt0AMiHABXI3X8JIwf0YSeEjMvfcBOkd+I4CIaPpRJkF7io3yHe7Ys/fYIWNeLaAj2//VAhgFOzHgBDoC60iABE9A64BwB4RgopaQdbpuicSgDFsul3N548iQP7Rwf6A4s8lux3iMCJhKdhmjAkielYA8AUzulV+5i09e3CMEd2WzACv2A6aQL+Ruq1Krv24ZRcrol25TK88BePwRDbKwU89TJJVL2NnaAAoAAXI+AR+O1bscIhxzUyMRaQt+8GFxFWuOBEmQA6CwwoY+DDiuDLrQC6IAAhVpSD/VMJerFhn5VCHjy8lZusYFVYbty/VM6q6bVGL2a/I8zyiHwa0r2Bf82GImZoFYoymOBWfAIQJ967S7CYzBIvyiq1tOl4+LDNLPvPenntFLszVbCg92n1X/CdI6y7NxFmepIQFf7xrl69JjP5btq7QmtmJwsAp11i/LoAzIEOD1e/+6Wu7IcAzGYAzCIAwAwatZMmPCbMlSRalFjBgygDx8AcSEBAwfMEyoUCFBAwkSKlDEEDLjyJEYTMho0UKGjB4ybLxkaaNHDxsxXjhcyXJmDj7Agv0MhozYs2fKftVyBQPECpstTLR4cXPli5ROUT51akKriQ9duX5YEVbFCBUruG79+oErBw4iL1xoK6LtCBEjPIjwAPdtBQxtM3JQ69UiYLZwOYhwYYOGDR9OsKC5oycyIUaOLGW6pAnVq13EkDFrFk0aNGjPmilDFu3aM12zYrVa5Up2/6pTtUWdEsXpkiNEetCgcdKDhgsUIkCA8LDBwgQJEBo8X5AggQHqA6xfx57dQAAEFmbwIMEgAAAAAbh3qBPKlCpVo0aZMuVJPnz4rOzfZyVL/7FkwoSx8qQVWhpy6CEZqEorpJAUUOCDjDCooKu2FOzKq6eAiGEIDV2SIYaFbFgJpoeAGOJAIF6yohZigvFsmWWQESqYWGoZBAQVboQqKiAKzKmFD6oCEi0hb7zRBYacUisrrlZQ4TgPnoQSBBQ8QGEFFHZAAYQNpERhygs2MEwEFVwYi6zDRHjrAhRIcAEJH17yAYnH7gBED8oagQQTTkTZRJRVOluGmWdAY6bQY/+QecaabJ7BhZbXVukFGFhWWQUVUkTJ7RJJGBnkjjPOCMMHGLIEswMNLLCAAgggcKBVBqI7oLrsrBNAgAGqS4CCQTSDRVJCKEjgAOkSWACCDhCJxZlrrnHHnXeahfYdeOA5Z5xzqj3nHWmbpUaWXAzykMQRq0pLMAUk4ICvkCzqq0K0UuqBRA1bqulDhkTsMYYTFUull15+ImbFX/x1pZZLUIiBKaduauGhhIMUklytouKqrBuZokrJCjEwTkq6OPhyAw9AoMCCDbY8NVWRkSt5A7k4UEEuNEd4awKMKLjAghV84AFOx9Cwk5A789xzT1Rc6YUYZZQ5Zumlm37mGmv/kLHFllleeSXpWlZJBZXaSsl0EkYIEYSQO5wQNUsqO9jgVFVXZdWB6KSLVdZZb5XABU5WqQUYYEqh4YEDBg9W2AYsMMIUZ7pxdlp45IE88nPCIQcdy6tttpuqh9GFlYbkBSKlrSxS6ywJFJhw44oqLP2pCx+i90giF/Iwx4xfYAgFQlKhtBVXHq2UlFhS8UGFDxjyqkCIUqodyJQQxCqrsLQSPa0JM6KgZAvgfqBVB+gmIHzxCTCvfPPPLy998gAgAAQknJDpfS/sCPrOSfTMTZRSUomlFxg9gxEyhjGMYzADGbeQxSxmIYsZBSwWXjtFKSIYNt5w6g5mSBsJVKA2/+Vk722umtt07JadA0iABJBIBSxSUQgQOIABgzsAAmSIgMExIANgYMUzGJeNbWxjHI6TxzjGEQ5veMNazurGMWQRjF20whQyKBEUJXKWtGiFdA2YAOvYpUUhhYUhX/RQwpikgiNFJSrPawFTdJCZT5DiFKgAxSY+oYlKrAIWghgjGY23giHsKGHU02JXFJQRm2FEAhhRVwVs1oDtlE9964NkJCU5SfMMgADSaYBzGpCAVTkAAibjAQ98MBM5ocEOgCAEKhnRiPsVTYKoWAUtWPSLYdCSGMPgRS4Oop8FzgIXu9hFMLbmtdtMUDeTcITYzIYFH9AABjTYoJbAhKpUdf/ShQuAFXVGSJ2NkAAKRLBA4QoHwxkS7gEamMMrohENa2BDG+NAxzngIcQiCvEc3HAHNGSxolaowhQSW4sgIVQSvjRAAQ9a3eq4aAIVmGB1bJlQWwI50bbk7A6IWEQlMmEJRjBCEos4xCJSYQUj9cBItWPSU8x4IKfkyEelY5eC1qVFDEjgORDoSCE70hEIMAcC2XvLBrJngZzBRQTZmwBcknqYCaBpBSIQE5o8oAIaOEFOpMRCG+wgCEQQAhGMiEQr8/fG2NACmL7QhS588Qtd3GKBCdTPLXTRqF4ghTb7u2vYNGXBMyBBlDRgknE4ILKcVdN7cqPb4GQlq8ENIAD/2DHA4AgwQwSMDwEMCMEcPCEMaljjnfbkhg/HsQ1udEMatvAFMWbBnlEwSAEGKEBsC+BaBhUgAQxyTkc2NtGJTsA8tjIAgzgSISuyRUICvcCqrDCIRDhCEpEYxCAqIwlNbI0QZGRKS9wVAxO0hQNrAQxXZDrQQapLpjTFwAVC8haRJPUCeTmZXN4CVL1coAIcGMFhOKZUNIVEBTlrEzOD874z0G8QXa3MJO6nP06AohSoUMUqXkGLX+4irW21mn70Ywu1yjUW7FlFbVIxYmNe4phjuwMWnGAGmsTgRnI5zjTfZs0QRtYA2Tlf+W5FThmWb3wMQEAIPHGMa3ADn9y4/5aRrzWNXORiGbR4hRM/0ZcJ4HSnijxkTjPioNVtWaAzDeRAEdqVCPG2LxBK709zwNxERAISjCgEIjCqiUiVQjExgxlgkkS6FrBlvCRBJGAGOegPTCgkgiYJX2wmAfVewIOHxMihD8kXwLTg0IFJ133ZEoOZ9OAMPXCCEyCzhwN/NawmdrAcRwHh2GAtFhS+xS0OEmUN36LJuniFIn6giFPQhlK0mSAoRAGKSyCzU5CZQnAStsEuIUc5qMpeJ18VrGDZLce/vRV1YEie8zmWAAzAgSqYcY1uZKMbRsZnNoRxi2X84hW4UIUlNiEDB+mWy+Xly4O2LJLxKlTP/5YQRP8Hw7ozp0skXVkVCQDBiEQ0ohF2+mpGaUEMV9gBBnepkItV4BTvHtrQF0nkfUm3RYNbZCQ2+0iWd7pynvIUbs1Z1XA/UqELLJUvH0AXBzgNaqv+bA9cZYSpJ2Fi/ama1a1uRStioUBZYK0Vr0ggWm3xikXMIAQ4QESvXfFrCEqwFJzIhNgGUTZPKVvj0dRSyqoZt2nD8AAEaKT5yHPjbGsbknIvDwEekM6oSY0a64zGMFDziljswhOWqelHOMIclBsyAjllDqQLOXmUP0jgIlFk5UticjRDyCMD9QAjhr4JTkSiEc6thCdesYxdVCIEK+BA5FFSmAl0fnXiRahCLST/pASpDs2CzAiSTNJd+575QYHZc6EHm5c0cUAxPmhMY8wgh8l0NMGoFsV7ju67pz89gVMP2E+E0gtaLAIHM8jBDahwid9tnVKxWQXYMGEJRzBCEHvYAxqs4IQczKBLzU4OakIVuLmmtrMbuqsVW5Et2YqsYXFAB2QABniAEBADSvgEVbAPAWERYqiFXagFTzAFVGCOlFOACCCJjoiAFAQ0kpCpkSi0MMO83AOzzZupj+AA0ZsEB7MDsJKESqgEVUCGZWiFHAABh+qIh2ASkDG5m6sQ82rBmUIL3dOzE0SkEfQLj8i8CfCgEZSpf3sLk8GZC/iAEbABUdo/H7CCAqMT/8roqEiwBKIrhQc7ulVIuqTDGqhbol/wDH+JBUUIgRM4gRvQgRsog02IDfeLjVSIQ06YP944BETYAzkwA/6DJv/LElNBFQ3IgAGMm1aZG8XSJtiyjgWMLW0jnAdERQaAgBBYgkXYhFVTOlqoK2BqD1TAuSxKwVzMt3U5r4rQvYXCitHxvRfcvZErlwroqTvQDVCYBELYAUa4hEz4hFHABWeohUNAgXSxKYZCDrYQrx+BPfXCMsnTPMIoOLcYwzShgEVbldpTr6RCxkOasaHyIGhLL5xJldoziRhgDDTcvzA4g+qDM1aKxj2JoDeKsPejw6e7Q1m4hVoKBl9QBTwIgf8OmAFAvIEZuIE9KAWugb/YMKaNqj9HOARBuCAraKYcgKZmaxtMXDsCnLZxCsWZnEm3c0BhGZbouCwIyIAQmIEZwAEwwANKiAVgWAU6MgVDIB2PSEGC2yILEYxAoqLqKRc9A0Yz6wgLMANO2JNJ0IMk+INJyIRK+ARacAZnMIUT0EZNI6oN0C++uBHjKjRFsjwI+RKowgsO8AAOqKakSo626aC3wZloYxWcqrIHQEwIQMwHWJUB3J5iQZVCMoGa6AE3MYMlMAPIUKVGWKXRM8hXSsj36z6ne4VbQCtaSAj8i0Q7uAM7cE05OINL4J3365oSQyZJ4A1CiEQzeJ9mcqb/LDmOtMsZD7KmmKQbmqRJt1POxIJAVdSADvhDDQgBMKAEH6SE2CAEuWDBRPPFmaIQqWSosBgjhjIe3gJPKuKyC6ABrsyNFBCCPJFGTVCFZYiGWLgBMOkIvdQAMFGvvjiMF4QxiIIZ41kZaaIm5SiqkwGBDuiA4GSbBk0BFICBCUWBsqABGsiBDNWBDdUBIkACKICCI/ACJUiCKeiBCVCABJAAqpiJJzCCK3iCrNKDQSgEsGqEsMqEBovD90DIVWCFhaxDrJGFRmmFRQiB7VFFT9qeVXmABNgARhixhEQFYtIr3BwbQbADMzgDq2omK/m/BT2Zwlo7T2SQ40TOM9Wm/1tJrBgKH2HxpFWRQAR4ADiwwGSBhSVYCpCJEOMqDAGtEKuEyg8QgQ8gEiL5GAFFVEStixFg1Jj5whnoE0y5Hz2JRlIYBVpYBUv4ARqgCxGwAReYUBcQzxhwgcWwASSgiVALNSWYgikogsf4DciQjMiYDFRCJUGILlwdBEDg1VNyzd+4A0+ZRCfQgRwYRBioARhwgRRIgSdhiwkwgARwABPoA31BAiSIAhidn800PRzdkzgkBVN4Iwj70SDVD1zAhVggBTB4ABqKrFfRycsSDwKwgD3gnaOZ0ggCG7DTDUvYlK4KVjSYROFgklFZE2dLkzF1gOdIUTNFUzQVFhiCu/82TYA4hYAZ2IMfBAZnIIZYoAOfzEfDYDYpOY4KLVTxvFDAKosvMlWZ6DQkSAIlQAMkKAKaLQIlwFmcRYM3eAM/+IM3aFU92IM90R9MwAQF041KQIW+qQVFxIRA+IM3KwShgVqe9QPfQIMtVTFVvVaaeInf/L9mczYP2E8NMFsBdEy4UVsC9J4FaABsEq4FUICeelMXeIQpIJEk8AIswII4mNEaDStvdTAJcqMphTAMZMhYUNzVogMLIJ/x4Db0gVwAQAA8mM0RyytQaDCuLLb6ExqT3FIkUElnMljjeBIZmzFWYYAyrbaHvbFQnBUdu44bIwAIuAE6uE5HUQVU2AT/+qOMR3gEVrKMobuE4jXe4zVeS7CESXC45oUESGheh1slSJgE4IXe6IXaP/CD7d3eJOgBNAgDR9CfUriEo43GzACFXkAFR7gDHogZCjhdaqq5kmlMtU3Mw3IhBnCVCORfV3Gh/81f/n1AyqKhunld7BCAABCA2YqQCUCVC/iDQCCRKUiCNvACOeDW5cW+ODyFwj1cxHWN13CiH0CAyV2fHLOO8QgAAsgA9nMFzNXXYcMUzV3eSLA+swEON+EBlYSBDeoY5Cis1F1Y1zpOt0tTBIasG7s2yP22EFiEgsGaStkNoQnWMzADK0BJH8hQZ/K/E1hQs9UA7lnbMX7TmHvb/2GRWMk6gOgInwRAgBTghEnQjbBTMEmgBN6YgU10oXEaHwJwrCVe4kkS5EEm5EJeHwFQAAxYCBXYAZ0xhEDQkFZ1goBkw+HNBDkChcIt3PVgj1cIBvJ7hVUwBSqAAMqSwMRszEmbgPC5LAToAEfghAgiWrCrBM3dhLCLhPpDhEHYgyxFGwz9TRJgG5E5GWgrTLYLocKhybu5G8VSTsKRQPTYBE+oBN6IA6UIzmx20A1gG7WD08nSX/wV58NigDWNlYlt0wcYmQQA5w4wMbDbhPOlhDvOACCrLEcy5HzW530eZPMIH/NB5AhomB4QgiOAARH4gkfogy/4gjcosD2gDP/nmgRL0IRNAIVMro0ODkEIIzzyowVaQAUdyAAI0ACytboZ+AEwAAM4qAPXXLhIoII5oAM+UARH2AQJoo0Z3oRNIAXNPSZksuGxsYMtjRMtNthsLuYl/SBPxKZP1CYDZmbsCB9TBEViWQAGsIAQOISx2wMzoIHi0Gbk+MsvgbYZYwACOADv6UTvQWPJetwciyRH8mcGGIRIBYVP2Gn3oATxMA9+JuS+jlxAFuzBNp/JmiHxQQAJSMEDAbUn2AEi6IGEfgSGnoI7EBrRi8ZL/gRQcA9xNYVw3V1VoIVZqIXSRoU2CCcPGIFAiMPZ/DWFpJRPMIVP8IRR+IRpRAVgOwX/224jnS7eiUYm+9vNM0DJHDDYLiGBtEPbpV5YbEqsyILqqLYk8THFHZOOq8asE0ABL/aA7SFMtVXrMZ5HVZkxxuye7vGech6Wco7A8PYkVXkAC+hJGKhrVwCGgFkGYlgGo9yDGdBEJo3AB+BfeybgAi9w/l1MxpTvDIBOQARKHEjpOZgDPOADml6ERajO1KvtEFzIWEDXXXCUpq0ABSiBKeC0a90BP4gBDvgCTHjkN7ATzoyEaCS9i+ZRS3kP9miFqyFtWLgED1iAWEkAE+iEVNi6rZPDUdhdUwCQ2u5sf4qwrTMF9/iEGObKeN6o4NZNORjqX+7hCmXJsw1ia3qO/7dNZlCkO2YWn7p7amHB7g7QbhDQ7hNoUDnvEiJ5pjy/0BwINSTYvz9X1Sx2giwu1gzNyJ/8yQhNgYsERC/+Pwa3SB8IA0QAhSllD/YwhUWIgx/g9E5XaTigAwoPKQyXN84OwUunQ8L7aFoo7Q70F4AJmBZxkVmfdWdwkbM8S6LQ9V1/hnV6Blt3BlioAAWugCEQjh4wAyxQAiDoiikw2kCAdoJ854smBTeqjfcIQVaIhSh7NU2AABJ4gdPpg06AhXKvhXLvhEeYhFNYBVVoBVZoyKrhhVySBVbA9FHwujgcNq7kBE3o3LGBaE8p7lBd1uT+yzBNldQtc+f+RAMeof+70Sa4IxznlsQwCIMlKFYd6PRCV8kb8PiPvwFDD/lC39Af4NAfWAIqgAM4iANSkzNEcATnUt7MIL1vzegOXrVeO8RLv3TYqAVWL21g2oVI8Rv8pvVbx/WkdwZe13Vf73XA83Wol3qppwZpkIZ1kgZqmIZpyAZriIazhIUIKA8FaIAWeAMb4PM76LQR+IAheARMeARDMASjLZpMrvbaQAVsNwWlSzpaSIUzGOnZAoASKPfC75UgaMpAqAXVIDdza5ZncQdryAVW6Cdh022wyR/N1RTPBViiNu4LhYEUMPiRQfhqIkzoaGo0PmLpNgC4s+7rXgA6iIOW3wMKVwRFuPD/SqDoBoMPw3Vt2fgdxRX+4X+1nwf6Vkf+5Ff+WoiF3zH+0r5DxSW8GUH+XUDXfwGKWA/Co18GpieKqZ96aZgGaiD/8e8sa0B/9M8GbFh/9s+GbDCybuiGa3kH+b+GVFCABC6AD4CAClCCswEIPWd62OgBZESFIY86YWqI6ZIoUKJIUTxl0RRGVa9etXrlKlWHAS+USFDQCZYrWCqBwSoRQYGCCCWUwLrWzZ27d/DkaYPnjpotVapOlUplkWipUqJOReR0aZIjRo4QEbojJ4wPHgRhwEiBggSIsB42bLBggYLZCRIgQGjgtsGCBQkSGKhbdwBevAIE5B1Q98CBu39p/xEmHGsWLVyKcdWqtWuX48eSJ0fGBbkxZlq1CnPu7Jkz4lexRs/ChVjWLFmqV8+ydcuW61u3ePHy9WsYMWTHjiVjxqxZM2jChUsrTs0acmvXsjHPxq0bdJzSp1PPWX36O+ndUiko4D1CCxMVbBByUj4GEhs0gKzgIGNhp/iclIoqVdEUqlOoTLWS1apVLKu40ggESjCEiUoJAgNMJy7FxEInLFSwBCvP3ISTLfDA8040tpjCVCohGoWURaWAssklljgiSVSECGIHFkgg0cMOXK2AAo4oiLXBBT1aMIFabLHlVlwJBGZkYAbktVdfBDhJgF+CbTTlRh1ReSWV/2m5Jf8rXXr5JZj/gcmKllSuthpssOWSDJvJGJMMb8NBU9w001CDTXPPSaeThn36+Seg7wg6aHbX4QRdNtdcEw2j0TizDDLD+ILLK6m0sJcAAQjwARAyXPCBChw40QMNBdmwQgtAfNBCH/GlEl8nSZVyCkaorIJKlWSuQgQFQSogAYQqpQRLhN0VEFMQQZQQQAAO3LHMNax4Mug5ybAyCif1mSiKKJaAohQonKCoIouI7GGHGVb4QBANLqigQlg6gkDWBWaZRYGQEDzgFgNyIZmkkn0J3NdfgB1QpplnKixLmq7BdksuEUcsDMXCFHOxMW/2Bpycc9JJjZ3JNZcnN9yMM07/n4XiRCjLg+6pE8s5qdwNN8xhQ400wgHXjJvC2CLLK12a4oknlSiiyBxJJw0GDk03HUIIGUitwQIF7FUAsxGw0EILK6gQgwgcrGAD2TbE8C7XMnyBiYivJnXKKKPgt0orrKjCyiuaMCCAAqli0AALL8hwEizAPFIC1t6V0GoQ3cX0wiQhGAOPPfGcs80xqnyCCrdMSQQKU01pYgnpkjAyyLnpOpEeDTF4neOOZWlwL775OsAAA3PNZXDAAwtcMGA7BzdccXROU0012iivzTbbeOON8ydLL/051Z+DDjrhYI+9Ot1rCDM6fcoDTzzkx1O+n+rEQ8899oyfXXSHdpPo/zXUMPrMM74pIykut6RWN0aIJkCjHY0PSpsDGH7gNKiFoAMOlFoGOgBBB2oAgiHQgAMhoAEOdEcA3rnaB0zgOhX0gBAqcMAGcuADGzjBCTFAAQdiMIQhrC1EnQiRUkiBClSkYhVBw5sqBuECBQxAAn1QggKC8IgI0EQlLIiAByNQgAgEoVUReMlLErAId8ijH/1AxzuyYQxV4Cc/nVsKUUR3iRRFxVx2OMMZYqQeGqxgBTCAHQjGQpbZnQVftXvA7XJXJCQpyS52yYshDQCY7WEvHd1jZDoiuY50YI8c5YjkJSOZjnJwshzs0CQoy7GOUa5jHqY8pSk/mY55tAOVpv/EBz7mUY96zAOW/+iHPKTRJaKZYhQDpMQignm0AuKhgHwwpiL4oExl4qGZeKCD0uAABjjAwQo/yMENZqBNbZ4Aat3sgDdPAJawzOAEHVABBhSgKQ9650EmWEEMWmCDRxACBBaAQVZaeCoQcEAFRXhDHxbSthGdIhWueIUpVNEKPiBgASNogQQKYKBH9KEPqSjc4bzTB5l0oqKduOJLFLCBZ8DjHresxzjOwQ1jtEIVt9ohGpEiuk1kwhKRON259ICGM4yKbDSgAVfwuCM+ouUsbAEkA4hUJMDsLpFOrYs96nG+882DHlW9KjvmwQ56cNWqVs2qK7UKSlCSQ5OlNKX/ODhJynWYQxziaOtbzSHXtpKjrnLFBz3gIYs5OG1p05wDHOaABz44k7DOpAM0lebMxQ6WsIhFLDXhEIYwUOEHOrhsDrB5gxzUiAc8IIIQdtADgljBCj0YggwisE5MxaQEW/saeggBCUbc4AY+KK0ZsOCEGYDgnEjwgyEesRBXuEJAKIFFLTZCi1cgIgHMutoXVrIgljzxWCVIFoTiA9KYwIKL/PAHPvqhjnGEMRlBaynnRJEfmXKCE+FK0U0JIV+d6jY9NtBBDmgwg3fp6Ct53AAfK2hUfTkAkG8ZJO+eash7MJjBXnwwhL04S35QmB+zpKUp65GPenS1w/noR4dP/4mPdbSDrWwtx1xTPNcSq48e7ShxPKShCDCAYQYhsOxlf7CEJfyAClbY8Q+C/IPIRnaaRCbyGMJAYxoLOcg6qK02MwvUFMwABjOowQ528FMerCsJQBgCC9TJrDG3k4oyaIELYiCQOzRiD0vwgRnCIAc93MEMOahyqdBgiEZMghMGRW4vgEEMYjjDGcAIRRIq0IDuVIBwCYLF4bpzRRZUkVgfBSkQulFSfngxH3hFhzyq1dKhKCUVO0yjKLKVajYyotWE0CkaVtcDH/ggv+1SQY7A4gE9Apio+XoLXPy1uwQ7NcL/ODayk63sZUe42c6O8D76Ee1p42Mf1t5HtWEZXv972OMeXhyfMADLgxR0wAc4xm9tc9zkcz/5Bji4wWXjjVlaazabJ9jmNymogX1DcGr7xmAIQPCBJwoAAAYHQAAAMEUpUnEI8HRCrFcnBx/ooLRn2IMg6rCHOqhLzmggRCQwkS2DxqIXwVhGMGjRCh4MQAAS+AANL1o4lURIigvvaB9U8gjHRWAV7rDHP7gd1Wr3w32iVkV+imLqpHNLKe19yk0bwQhCAOIOaNBtGNRV6/y6wAUrSAEJxumB//LxXkIy8AKCLWxCJlLa0v7HPuAu97jTfe52t/az8673Zl/72g329j184ok5mEEIMCBBZmur+Gxuc5s4Kie+TyB5b0L/rQP5fmAG/i01C7DFLPnivAU2D0ELmACKBzd4AB7kkip+AQgx6AEaesADJ9BAB06wwhnsIAhGHAIRK2ojInbfZ1CAQod065JLC+FcTbkFQbVI0BKtdkUF9KHSnQiCBxUAgWXI49juo5y1/9E+eazUbrXa4Xrf5vSaTiISk5htIV690zOojtZzdEFXvjJOsturj0cFttoNG8DUxYsVoDm8GD60wwEWIAMuIAMy4CiV2Ci5EizNw1nNwz94mim1EgeykgeuA17lAz3sQz6YQ+A1w9EgQhtggRzsgWEd1mI9Vh3YAQ3S4B3YwR20gRy0gR3ooBfAERzplhU8QdaVlhPg/xcN5ICVoUCVzYBXUBkM0MANcAUNfIGyTN+xgJRrJUsfBMIU2MAXokAd0YAT5EAL3QEhIIJUTEImSIS4UIImUEIlaIInhILcJJRQqEIqGMIIYAAEKMkFdMLzxUcQhFlMREAfUFpAKcsHxUE3yIO1+Qk9xFI89MM9vMM02IInJBR6MUV7zUeqtZclQEWrTR2dxZEcpAvF/VS73AiOhMVQlZ3nEZgDOIBS6c6/3AVekNiLmVg7JKBcNaACOiApFSApscM6IKOLLSNXsYMzclU+eFopkdhaGeM6cNUvvtg/qIM7sMLRDIIdlAEdxOBjNdMe4EEd0EEd1MEd3KAdzKAcyP9BHMQjPcZBHHgBPuZWaU1WGOzY1pUKK3LFHQlkFCahD0zBFAxBRQUBSMlEFXFhIATCGzic16zA1kHcHehBq0nCJWQLKehHKITCJ3zCKIzkHQrFJ5hCJkBCJzyCIWCCEkxAA0wBLLwKQx4iIlZR9bGAg4iAJmRD9/1D+egEh51PP+SDOpwDNMiCKcxCL7wC0pmCUlwCfTzdKEZCJEid/OXeGWRdrbEiUN2R/oXdvABY/9UOgR1YXKxdkuAFMr5lMl6jBPKiBDrjVn2SXdqlOrCDOkwSX9LD+sRD93SPI8WDp81lNTIgPXDYL4pDO+SVjB3NHuwBNU2mHZwLZl7mHaz/I2dO5mSqozrao2iKJhDGAT+GgRj0o5Nllk8FJEEWJAsl0A4AgRVe0XXpZCEOQSAYgiE43NmsABnqgRmgARq2GhtywicUnynYoQB5gtzcoXOiAhYkAAWIgAswiBIAgQRcVB8gTjtdlwKwwCPw5COInCh8gjCUlFBuCPnIg1HmQ/koJWwswy+0ghlFBKo93VO0n1bS2R5YxRmoC359JVDliFeARQeYZdmh5VHVYr+spb8kCVzmpSpRqDNqEl9m6F5uKF9O0jr0ZTywQzxEEmGiw/ok4FoVIwOywz3EwzCmwzi4gy0U0yHswRjEwRi0Iw62I4/yKGfO4B48FmjGAR3E/8GRwcEYlMEYiAGNoaY1AdllzZFrRmENZJYO3FaQWUERPJHWsIAiVl8JAIFwPcIXuJDrmAcmWJ0eEEIhMMJxkkIvlSRGYMQdZsTdmEIkpAAFbIAHYIIr6AEJmEBNVpd3TNHiUFql9RAqjEIrAGWLqoOGTFUlghg5VA808MIzLEMsIN0odE5+ZkImrBF/Tp18CcINBqgT+MDqzJFYdgVZJqgG9BrtQMAf1SKwIZgBmJg5rJVakZIo+Wo6xOWExmWwButbPmYkiagjQaMI0sOFWqgzVs46iMM6jEM3UMMiDNYzgUEZkAEO0pmO1qC42oE8jqY9lusZxEG6AmFumcEVTP9WnJWWvC5BqspbveUAZqmQD9AAEgCBS2hNsgTsQgZUQ0gkqdAACuQAT2EBIBCC1B1nKJCCHY4CmUxJ3UQlf9QCMNTCJGgACKRAI9SkSmyUFHkQO5VAR5VAKgBD0OyQJwwDF52P+kiqt1FqUkpDMygDLdxK3GxC0jndJzrF+0ldIcRfVchBV1qBGbTQVxKkV/iXA8kq7aAlINWiLSKYipmDKMmVr/7qKPVqioat2CZjXnIVPniaiw3rW7IDY5oDOWyDO+jCHIgjHhgpGWBBHuiB3obruPZgG4wmHNEjEMKRPWKB4Rruu+bWEyzu6iDB7TmBkOGXlaIbviJBEQzBB3T/x+JUFOdyrku+pCEQwhuQTVb4ABZ8HCAYZyZsgkneTSzQAmIURoCQSSwsA6OcQg2kgiWcQqExSAnAxAdlHyJeXyc4Q93cyieogjRE6syuz2Ka1D/ggznYwzlMQzFwhCrEDSiMSFKES7ZwwkMMLSNIHVXcINKiwdKmqpSF5dPuH1mYpb0w6AMY2C2i2Ilx0q7mbydpbSdpUieN7ddmUjog44e2GAgmoALqqgLTZTt8AzdcgyeAwTziQRjEwRPwYN/WYB3QYz3aI+Ga62gq6RiM8GmGAePKCBIYYb1mFr4i4ZUaxL86ZBUJV0sqUScYwh8EgtQFwhkgAQ8gARGc7iAU/0IjLIIkZELr0sLrzgITx24s/BAuFJqhAYMzOMoyGNpNFupzWVcffEEqaGorrMIqqEIlyMJNwEMkbWA71INJ7YM+6EM+jA80zIIY78f2ph+3qBr4YsLQYiWp0hkO7pQq4pdPdZ0rvmIH7FqvEZX82iKR2C//6i8nudVb9S8mdRLYklKxgpIzTpL6IKMB5q+uptg+lIMCekM3KAMeUAG6GKkZPIEbYPC4tgEt72Ac/K0Hl6ZoRhY/loGSKmlqhkHSLi4QE0ELMS3F4ZcOeJYPzIiqyEQJuJYiCleylMAjvAojJEEjNEKb3oETYMETeIEdAEIirAgbsu4orEItIMZhwP8uE8dCS9GCFBcao1RxocFCFmNNpmjKgwTBF7tCGJNR0TRDTqDDKr3YPPRDPVjbG4ufTzwDVGavKZjaUdAH0DbEfrYfI8Sfqf4nGqCvFaTqjNwfruGa2I3Fv8Uv1bYFXAQwJssVJmPyWG3SJv3vr4ISYZLozFLjASNmsI6S1uYDtuEDOXADK/yAOprjDLoBU8fyGjR1HrjBGrBBGqjBVKdjkcKBuWb1korBCIsBWNMYFYT1ZP3YjqUqrVGcCukrrWHBC9hmNHupwD6RNRMLJhDCH4xvq+lUC53BHQgCIvjeJFhCJZAkK8zCaBwGaQSNKVDxMlzxPE/xIyiLAmTKXjz/16T1QS04Qy0ESEkugiKYAjfIAznQw4PtQ4cxq/twQzEMjSZkAueAS0Tk8R5DXSS00SAIwn+ean2NVmu6S474F9nxW/zSKi3iDgO4dEwvd0xLUkxr8kxTEk73JT1EoAiulSSZ2IfBEjxAwxzoQDo201LnwRqUd3k3dVOb91Uj1i5HlpEi6Qh3NVgzKRjQNxXc946VVlrT2pVeaVt7wQo0pIDb5geUwNpgAkNss9S5GiD/tRpOwiRowidUgicktoWPBivwx6ARWhU7SqEtQy0YgoNYDabws9Y8AjCAuCuggifE4TElAxelA4RV1fl0mCXCAzbkgid8AifYSnpxC5B//2L4TgKLMEJgo46LWF1vE8QceQ1/fYUIxCIjD1jVOsA6MHcngQM4LLeWc1JN/+8okQMjVZJBj1VckhhXeegk/fQofdgtuYMsnAB4P1Y8MnUapIF5ozd6r0FVY7U9UtMYwHd8fzV9h7VY4/eOLYER7veVpmoYYIEeJAEHVEBDFngMl4AJmIAMDEEjNMSoNgIkLDgiDELvSYUlbEIlUDjtXvgryE0vPMoVX3E9XzE+N2Sh7vMUQYig1cKteEIwGZAnUMM7xMOxeRFXTVVXeZE9wAM15IIvuRQPMQVTyHZ7PUSKEDluU4Wp0t8xj/RPeZ2T4wgJRHlv7RGPqLSQOMAku/9VObB7OWh5l2c5OHzDN2z5cod5XVVSXTlSiRarWtFDPqiSWZHSg8kDNSjCu9kje6NBG7gBnp+3VOe5VKcBF5BBGbT3CMO3V3+1fBs6GNw3FSS6ooc0o9+WE8gBGugBEUwApVfAFn5B9Q0BEABBEfwBJDQE+EICVkICz0M4tgcTI8ghhReNJ9jKlrTUKNACZEtxPRuaMxxOQ3YQrlMRitfCio+C0SzTHNhCN6BDPtzSPRx7jXPVsdUDGAFF0YsxDnWOfeQxzocqhN+UGk7dtpvBcOoWk4Ol1+Ga/oVFIvNIj9SL2UEAvBf+vNM74tO7vMc7c485JKkDJTVSTZMYio7/bbTJwzsIAw6UkxmIJsN7QRtIvHqb951zgRZcPKDHt8bPNxgQuhhUwX3DvsjnN8nz92XVWhh8MwxYQAVggAmwgAwEwRBMwRe85EUt/TLAAieAus8/BCaEKmHLYdFQ+Cd4gtCzbvV7gioQ2mNHtqNs7BVGvXcwyxRVkUGVwiZQAjHxARgoAjSMg6dZ4mDOrFUhW+BhYlCovVEUH61QBG1XO0BMsjTJEaOCjAgJuiPnjJ0zZqz40JGDBkUYF1FkzAiCo4cNHz9esGCBAgVx4sCBO5nyW0uXL1PGTFmOJs115dCR06kTXU+fPMulW3dzXbt2N8sNtbluXz953TzNOAHC/wwcOGXatPHipc0ar1/TrEkzlguXLFrKxLE6hu0YOG3FiAEDpsyYuFWqUNFLZUlfv0uc+JCYg/DEGRQpovhgwkSLFi+ATHnE6VSqVa5WZU5VihMnTJAgYRLdmdOmTZo0ffKkatkyVItgU6pUydMnWcSWOcut25mzaM6AwQoSIUIJ4hEUFCgQIECBCEGCYDp1yZEi63zw8KHyg9W5eP/63Yunjry6ePHm/fP37586e/Cm5VKlatUp+6FMmRpFqlQpUZ1E6QyTSwaaJJKDCCHkDjsWOiMMKwITjAcaaMAIBRVU0KgjEDzaQKSRaDppJXBeKtHElsCpqaZwWGRxJ59y6v9pKZqMQkqpoNb55x54mgFjqg6qugqLrbISa6wjjywri7Pagisutu7Kyy4x8MprCb762u6HHwQbjLAvb5ihBhh4yMGGM3tAYgpCGGEkkgMlcYSSTRypk5NSPgsNE9JA6bOST1JbpptoVIFtEUpk88QUYnjrrbdoorkmGmJS+aIE6FgowbjkmBMgAhZYeKQUgg5RBDs88NDhhzmaGSeffvo5r7zz0vtnH/b6SUceamxRpRVUKivFPlL460+UYwPk5BICB6qTkUP2iHbBh6yAMLAyKbzIBRcw1JCjDjbQQAMQyxnxxHNhSklEcFoMZydyYPQpnaRsNGrGoNLR0R1WcDj/oQMLqmJrSK7aSKMsLsYykqwlr2giroerFGPKvKiIEi+9/tryBx36EmyiL3XwIYcdYCDChx7SVEIPNhFiBBFE6oyZkoIwEeWzPY8FBVllNRmFll1cIWU22jzxZBRWfPvNUd8kfcaZXlLpQ2pMg8i0AAEEUKCEUDsp6BDs5sAjDh1wwMGTbNDp5x924kknHXTMi0dt9sDr571pelUF2FP2tq+/v/3rLJNLBifIa0ESmhaiaiPEFgYKXVihWxJQIAEEcMO1YN2YvuH8pXbblUmcmt6FtyeeenJ73qHWMcecdvBhfZ150UnHKajGeKKGGQIewwwv0EBjC4SRXAPhg8vS/0KNMupq8mGIKd5rr7/6+sEvjz8GOWQeTEbCCTRWblP8NmNeJOZJ7tzMP8ABP6U/VFARRT9TVMHlmWeIUSbSa/iXNNJIlwGLTjxCalJ7xAGNo5xPPSIQzzrEIQSBHUH8AA58qEQ04HGPf8yjH+qohzzIIY96xIMe86DHCekRD3vIAxqs8IQmJHEJ9xErFDrbGWmYZYk4PUsQe+hhHeIAkb5EaCLZqhAMNPSvDIxkXBDQ3IhY0jkTga5FohNR6eBlOnm5jV6tc529kkKTt91DHszgQxmIoAPevcV3Z9jK8IiXMCSZZUlkaN7zqgC9vFxsetSrnvWWgD0dDHIihOTBIf+JgAU7AIIQL3vZAx/4yJclqBGdSMUlK+M+YZXikq6oBSz6Y5lV9OIa3cgGM2yRC2aUshvd8B81+BecThjiEbR8RCcG2AcWRCBrfXgEm74miB5mZy50UAQr3GGPf6SDHh60hwrJc54UonAf9zhHM1hRiU1QIhX2OQUpQlGsY5FmcIOzhLMg+cMgPuhBjaPIhC6CxBOcQFzi6oAGNgAClaDEcyeiIotkoiIs5kSLMFKR61yHDzFqUR7vUMUczFCmGYQhDE8yAxawsIUsIA9JC8tCFLSghSs0rAklNalJmcCEJjABY368kpY65oONEfJjNOXBEcxQBx8Kk6fREiYEBXH/CEQkiE2TWFZnSmHJTsAiFUrFRCdKAQtgOIOVrczGNbLhjlYOKlLZyMYyXtEmTKQCFmVNBSZqORwMHHBlPYxWtPAAhh9khw/MkId4ztM2FY4nmnmlxz6qeY5kmOKFlenmsEihSVGAojObKA2BdogIHu6hQWY4g4OsgAQJ+WBCNJjBZ6VyOY6AYAU92Gc/0fUN0LkkRaTDYukISo6DIrQd5lBdT84BD2nwgQ5WyMFnKVpR32FUoxs9WJKUxLCRkvSkKE1pSl3qFy0BUjBboul1dWCEJpxBDnWww1vB+9Ye2kEPf3gDGs5wh0EMIkG0xIQh+gCdPhiCloFoRCNA8Qpa/xDjGdGwRindEWB3YDUb3eDGNZ7hC1zUYhmQWkZwYOGKVBwQE4wI6h7w8FZUybUOdVCEKbghj/OMkBzmkces/ArYWHHDGIRFBSbhR4pR+C1nnWGsJi4xiTg5CxHQWkgc7MAQMzgBCZrV7IRuEKYZpAAFIEBBCmwgmdNGkUQm8saVPweTK2LRXa+dLULxwY4So2Mc73BHK8BQBx8o2QphuEIYhruFKCzJuMhLbhRAulw9P5cJR/CzEfrsZz8awQgaA6TGsHvdJYQhDh3WabQ6TFk7fFend0CDEoLHIB8S4g1DCMLUPj1f+n7hC1NAwx4UQYmiseIWx4DGNAjsjnOcI/8c3uCGVbVqSkktYxe1cMUpLPE1PoR3w2Cggof5IAx4wANuee1rXqVJt3zAgxvCWI0qUgEsVOjHm/5ZbJ9KU7gDoXMQewjyHRqEBSJ7T7ODtAgSYWCDIvxhrFOucpVbcmV9eyPLrI1Jl11Eji7HS7Y1Qajr9kEP053jHdZQBBzC4IPPnoAJT8BoGC6qUTzTeUkHW1IUShpSPZfUzyn9M6D7bIQlEFrlKy+0xv4400QPctGNdjQQ4xAHOcThsnGwwhnacIYkYDSncpCDHkhdta2F2oDQGcIUsGCVOfwADHNQhCdYYYtjdHUb47B1NwL8Dnicwx3ZiIYyfhELV4SCEqb/wg66MYwqjYEBO5WgBjzkkZN61OPZ0GYHrGClwm0IgxX0y/a2TeFN9+UM3JvIRIF0WJBBuLWH6XaCE9QdIZFVxAY9mIIhOuEKWNi7ROH4hr6nGA4q/7tdOgk4Fg2O0KLQ4224tQUY4CARqYSACVCAwhMougWNb/zjHv8oyEdeUj6bvOQnZ3lfVG7o6hoa0dhdghmCRFG+UIGifbFCX3jgA+9hwQw5D4MTPG2cSxnwgASEzhfOewY6LGFLVbd6JVRxC2U8gxr/ZSXZA2zXiIEW1m5mDgFVJq0O6ABVymYuUGUOXoEb7AEdwkGamiluSOiE7MEe7qEf8iEf7KHaWIE+/7LNFOAHfmgMWZLFnCyhWVxmvRJEDywNvbDgIS7v8jSrB5yA3paqrEgvy7Bs3/jtRDiHXdilHMjBCMMBCctB9VSkXMzhJpiJHryB7K5BEXDACoggB24gBHjvCH7PCsRg466A+IiP4/BspJyrz57Lz47ACN6Q5Qht5ejwerrEegxt5n7g8rakL77EukLGCHag84ZgCICg3cRPBhLIOS4FOj7NEWXg6bjLB6yg/BaQD/hAEirBFFphFnABGZaBf0zJq3YtGGJhFUhBEhBBEOigDnYuDuggFm8gB3RgDmxxDvgAGnILHdrmhNhhVuihHehhhToQH3REHrghF0aQPk7wBP9pzFhWcFlakCDaZJIAQQZnMHiohXHOIBDGyqwegSbw7VyCcAhLj0WaUCZEp1zYcXTcEQlHhybu4R4AixzIjhdwAOXcMKVWKqWWy2GuIKQEUuRGSuSai8/cUNCMAAmOgAiIQAiEwCG5hwgIjQfmcAlMJg914JB8wAgOKWR0MDC25AYq4rduwAjGxAVswNNY4AM+QAmwQAiAQBGH4ziWDlRwkgUiUQm8oAa/a6cEAREWQRI0gRRSwRVo4RcabH+s4RmCgRZawRQ0wREOQacmLQFvjg7igHngYA5MoRvOwR4Arx/WgW3yyij4KhiF0T20wRYISzYmAX7yY/GMhbEc7/H/BmKH2uQQEoKydg77eiAGKNEHlqAGMaEURE+AqkYcZeJEsCy12gVFYgKK9klE4pEc5sUcymEe9wEf7DEbPCEf5RAOjyDQVGqk8igu9EwgC1LPmAsh3XDliAAJHBIiIxIiaxMio88hpY8HhECmXG4hkUAwZUoHVGAFPCvJYKAHaGAETEABFCAABKAAhiAJlGAIMsU4ikNTWMARu9MRg0AJtsAhi+wJzFORAKEQGsGoOIEUVCEWdgE3emMZegEqpXIR+MC7XjHncs7o6oB5mMcWi8Ed1IEeAK8soc0oyqNAj4IdRmgaZKFoWvAE51KT/AMUTCMTWHDHHEGyEKHczI3n/0KyL7AAEBiBrMqqE76gBT4gROLxJBwztVqiRdKFn6zoJDSTCfGlGPeBHLghGcpmNFnuz0qzpKigSk4qIEXKNZ2r+d7w5G7TNqXUNh0y+lbO0B7SB5ygWvjCIsPP3ZBgBUwAQ+RNBiqAAySgBTCgORQgAoBgCL5A6YhDU7gTPMFzCIrAZHyACA6Je5AAPQehEBKBEYjyE1ChFWKhFhRV7VbBFCwBEfYA57AP+y7rsgCUK83GGt6BA+dxQcmDHX6xPNiBHkC1HuzhHaDhFYpmE7LtkhBPFKDRLjPB8SDLWbwGgijrDn7uQdrgDyChBwXoC16gMeJRRVCiRB4TMgFKHf+Z1TLFIUcLjiZgBR/2IRyywRROQEiH1A1Nai+qIEkJMvmYrzSdj9BmMzenFDcpkv5cTmOMwCGXoFrAjwnSKGRsQAZYAAge4ZIE6BFELxWAIQhKoBMeEVN2aU7pFFSq5k6B4Dc5iwd2YAe45wm4YpEAYRBeRk42ARRMEH5GYRQ2QRKghecmFfuCq6KeBwzKxhZyi1PjxlPJIx3UAVRBVTzgwR1aqGgO7/BM0BSgMUAcaxOkUcdixmU+1K2M7g4Y4amkChYwYQpeIAYoRCVc1B3FQUaRVbVYRDKbdXOoFgl1QlpvhRzGARpwIAS0ldASUqWawM/0IjWfxC7gNkpaCkv/gvNdi+wh01VdieAHvm/6rGcOqeD7rAALzk9LgeALDmipgGGqyqo3XMEZauERBMjTvmBqtJNOE1ZhoQMIekAIwo+zKmIiByYrfnIPhMogONRl9mCdTvZBCLdarEB6vJAPpOEd5IEDX3YdyIMX2yYdoO0eVuhmsckTVqEE9aZjfRYaSYMT8PKciLZDP3Ty9gARQgNFnXYKzoRCZqBYRaQcVALftlZGabRzbNRqvZZqXY8mAIsexuEcWiEDQsAi5TAOh7QNj+BtnwSP7oJupcsv5DBKIzZi93Y2iUww6A+QssQKkiAJnGAKJCMQ2m9xUTQ4iCEafM0ZmKoTPK2ABBZh/zUXJx0RCIBATyUkB7iHBywOC4IHDdqg/HTO0eIgUtUikARDXv+CMF1KA7ywFdwBHjgQ786Dd9XBd93mZYVXHpatG5KBFeBnFeBHFUahY/3G26JxGvOyIBwpERbBEkSBrD7pEb4AZSbks4y1JiqzMbHWc9QRfGfCjdUFbJewHJpCHcp2DuSXfum3XOEw0EpOpZ6HSvIILwS5pfzCfgkNIgd4gPdWCIpMs7zPb73PCa5zChT3lpbqET7tgICjFoDBk6/BGXZBN1wBE2RABi5XajJXc7fmO52uyLqkTAiDB2pgIpHAPJ8gBwTDCRYNIuRAiApJB76PenTYjzKgA0JgDv+gIZliRVZ4tyfigR2OOGbnMXeXzR2aGBUy48WiGAX/ZpwEh3BasAV3rE0kIRMQExY+qROmwBCRwLNQ4ARu4iRqgp4ZE7VQZI2LsGvlWCdgRR2S8Zg1oE8hVm1JkzTZ0DSZgJAFeZArppD7CJGNoJEJeEof2fuqxQzOzzqnwDu9k3P7oAcb1xn+S3I/mYPla740ZTs3V4SDYAhgOZY5UmJpWWJn83EQo0uCSKNl7kGiy5jlNwSQSR76YR6cufZIVR1kVqnTYR7ncQPlQbCW0bBQYT62jT9gVQUbKxNQ4/F0TBJi6BTUWZYMAaYvT2RgIASKVUWodnOw9iXA199IZJ//0TjgbIeM3sEU+gUE6FdIE5Jb1TBi3rZKogdjBhtLPNIi0dU2CfghD0kIdqAGaoBjiKAIEncIMEACjiMCCqBNiSMAPqCpyGqAyAoYeqE3THu0F5bUdImlt6aVczIIpsBBHrk8zbO2yfMJKvUM+jNScQ7iwOB1ZVd241VeqaBsxMCYqIGo+YEfxKMfpokdypKIz4NmU+g85GHwVMEUbOacEA+csPqGaFV1J0HHjKq0ayEVDKGdTc1wI0JknNUyqzauiXAc63uuqayuu4wchBceoGEOpKIDWK5P4ZA0/5ofm4ChCRtuj7SwjxSxWS5KC1hv+ZQHqEAHoOA6L1dgoRNr/7AGAABAAYbjrGBgX5mqrEbaNYBBwqLm/R7RtbkzJ1mgEC8L8y4Pl3H8ts2Toiyr5/gz54A7uE9WdmGXuKlgBn6ACeiAD2Qhg4r6mT6QHmSHiD8VVFFIA7WBF1SBFDhhQvPDFIglQLyNnC5BEnTIqCwhE8S6cV3hEd7A1BTn/FAmvu25XOIRn9Hln/TcXVLCRXpihdzhFXDgBk5gA+Rwjw98H1VqwRs6j+YCDPgoS7bPfiNysanUIf0M+LgPDSSDaoxDAEAcxAPgOfogRXGpght3qhQVGCzpEXRSvgQ2hGEbVHaSu3L81m+7yOI1DOBALXjdKoD90aNLXo0cB37ACP8WUBGaQR5AyKjnIR/wAR+M4igW9ISmfdr3wR6w4RZGAWhLMD/4Q7EWq7HE2RI6Y82DAxPeAN3uoIeEzAl6AAie8Htd9J7fWmv3/J/6PIuU+ApxIMDVFpHX1uSeK8EJ22Ie3dik56X6gtIfmW9xszShYEjMYA/O4A0IiAV06dM4O9QBgDmIAxM02JMbt6zU+bSj4cE2GDzjaztlPCffdOjOANdxHQkW7XV7PeetAveEnKKG2y+G2wqM/QeWnA9UoRvgoQLngRzmgVqv3SxHddqlHXaaQh6kQRb04xNSYbu/PLG+ucaCNhM4obTTnagEQQ5+SA7UDQnk3VjpHY07Rx3/sXa1/kngVI9dWOQcGkoY5IqeOmDlynXg+fG5CPtIA/nRvfViADjCH55KcbP3ogAL0A0NCMGXNlmXHqEERr0AQj05IgAWnEFFbwnFH6V/ekHCOgEIXkAGHLE4ZNxg87UInMBBnuAKcpwJXHPHXxfjgog/gb3XL2tSfd77TlZVKGjJ5+AY3OEddqLpp94orjwYm17qwSMedOsV8oM+9EYuZ0zcv40TjiWqSr4TEuRDo4V6LS3znrCen5BE2P/e7Ptz8t1dlrVFxgEeoAIMeAAGOiADgrOvAeKIwCNMChosWKWKGDFLqCQUM2YhGDBUKiasUnHJEiMcjRxBApKIECJE/wZCORnFyx09d6b0eQmzxKM+BRREEFCgQAQFnYA5g9XJ0KOZX2DVWubM2bJlsGCl6jMESJAvLCKUYIGVRZCtWWUAcXLGzBImT8pewXIlrVq0YdqGgQPXTBwzcuPEgUuHrt69bfeayfEDBxg4eOZ4ogZPnbl5//btw9cOcjt6lCPju2z5X79+9+BBe2VK1SpVqEqbRnUqdanVp0SVSgULGDBYmCAxuj1oz55ChAjdQXPGiZVyxIsbPw5OnHJx4MB9++b8ufRv4apbv46d3LhwzcGFGzcOHrM5ZXbA6JCByhEjPHhwXD/w4EGFCRtOBCNRzH0qYC5WVN/REU44gcRAR/9AcSAUUUSxhRdoQJJKIFrN9BJWjwQRwU5WKRBEbM7M1kkfj3SCCWyynQhMJ6k8AoQMQwTBQglXZaUVjUMU4QRdSxBEFhY+ovWEWle4FRddYdF1F1xw2BXHGU466ZdeNwQ2xxxx0PGDLNmkYw4++Wx2WZiX5UMmmY9ttplj9MDTDCuqiLbKKqalQmcqqJVGpyu1yAZLKZE4IokkjiQyCCCM8MaSHGaEYZxyxxGXDnHdTQrddNB5h5102IVDjnXNVTeOO6zMQQYPKWSQnkDvqSoQE0eMxUQTBTXh30L64aefrWJg5NBFVbj6XoEmIXjSFgx60YYfsMEiQwRBvBRiABH/9IGhTQUIkIpPHwIFbSedGIViLU11MoSLQZRglYwzZnXVEFhYsWgYZZl1xRM+1psWFmEsKoZbZhzpJBxh9GvXk1H6lYMOP0wUBhZi8AHNOeu0Yw49+Yh52T//lEmml5z18xg+/byTTCutxEJLLKPhWWedq4A7WyqiXHJJJpUIWsggjRxKyB523FWOOcQpl1x3zIFDDjmTFq2pdZY+PV1z5VAWzz3psJMOPNIoAocXWDT0AxXAdrRjQ1Q01FCsTaRFKxULjQH3rbsyQUUTssLHo6vrIUEWSEg8QdLfQWLhRSEvu0LTtCJ2EgQA01YbQBAq8snts95+C0wtvcRmFCxD/3wQY4bqyshuCSb0oAMVTyDhQ+saLeH66xpZEQZ9CfWq661gWEG7Xn3Fuy9dSi5ZRx14gMHKOfY4phnH+WgMffSa3dPPxY7Fc84xr9yiVCujeDJKaqWdgsrLwCwzWymTTMIJJ5lcYskkgu6MSG53zGVO/uUsx784xCW9tKP9r1NOe1p0niO1ckTGHvFQBzrQ8Q5bWAk4VgDDD2Q1No38Z4NgOIjdLpK7iVzBbrEqiIFMqCqPHCFwSCCC4M6ChTbs4RRxSoUCAMACbzlFBjaJkU5UlK3ZAGUmI/KWifYkxFRgolxVSddWnngu0/kgDFb4W+uueEXZLYF2YbCIrxRiq/+E4EcvZ2DSXA4GlzKUoXjGAwMfmgEP5klvjnPcjMb2sTF4uMMYwniGNZChClOkhnylWUUserGUWijxEpwQRfs4AT/5yY8R9dvDHeSwjkxGijjreFSjkuPJpFUnOkublHEiU490qGMc58BGJcBQhzvoy4Ij1NurzMZBMRwEdyCcSEXsRkKDGMhAqwrc6sryoza0gRCTiJMzigAAnhhxJlspgeSa4grOcasPl6NTU1LhilSAIhZ7ekQLYDSjZ1GrmkGYghngQIcztIF3W6Qn7DTilraUYQxqpIM/6YCHgOKhDv6sgx3uYAc7FE83cpCDXRrqULzQYaF7CIwpuGGPfkD/zzEc7ahH8dgYjmrGHudoBjSuEQ1amOJOqBCNnpYCDFc4khOgEMVMNxHJ+DmCkvbLpE99yg6gpmOoPuXkUIdKHHQkjRye9ORQ9zGZeKDDG+cwRpUseQYvVMEItdSbBjfIHzAE84sX2Q8wg3mQ+LjKICCZFzJj2AY7bCESdroGMDigAG6OiJrUElGJsNkToGBCRSoKZykssYpX0IIY6HuECa6yLhrJKAiPYMQhdsqIQQxCEJzlrG50IwjNilaziEhEIupn2tOOVrOC+KxrdcNGOsAToBTFwQ/mkAx5ZJSOvL0jHsnUmOlpw6TRwMX4yrcKPfkkfa4pRXNn+j5LRHKn/4hoLTvYoY7sZncdlKlMO75LGXbQ47rkLe9R6bGOdHBXvNddR1Dfy45+fJcdVLWGJ+bAhzrEAVlioEItVSU7sIqNbr7qlRjvc9YEy2fBbn1rDBPqBkaQohLRuIYlTPCsZw1lK18o4uWEIptaZLMWSKwFynCBC10EoxaisEILXsACm4xOXRPaxCZoKor30Yxm8QuUj3+8iEUEKshEVi1p68faz7b2tXsA6GftoBscSNkT3XjHPTRTPedlmWMg28dmdhvce1QjGbZoxXGTG4vzxWw1pSBFKU6xGlGAwn2XwKlOKUmI7uo5Hnqmx3cno2fy9nnQfS5vedNkDm90Yzz41f8vWhTy3/UEGKw7ErCv7gOGESYYrfJ5QkEabC8fxdUOceXEInZBjE8AokZa6YMhMFHEoWACE6dwRjRunZRcR6MXtNDFLXIxjGVEYxd7UEELSqATGX1ARuliASZsqhrnytmmc9Yxjy1RCUpo28dEXsRpkYyIcIf7EJ3t7GvxwGRBzEAwcxAGPDK6Gerdwx70pnc97n3vLnPmHtTzhz4cYw9peG+lqYhTmpEi4jenhhSkiLacHwnJOyMiZB4jE2XqQZl5aDwfhSa0xz9OD+rtgxzboIYqcECHPdThDGRowr40DaxJCxisZK3CREh41gUzGNTJTChnEcGHUTyDFpOQSuj/uJkKbxExW9do+jWy4fRrPOMZvhBGMZIBDWu4oxvLEMQKmJ2hdKELXUGQNvngzPC0gwIUNraxJt5us2xvm9veTm0ibiNucR/iEKw1d7lZGwLbzqES2ZCHHTW6GeeRKU2P8TL1GqOPMGkNNIV8qTOI4ZRT0AkVphiFnRxeU7bDD7OOwUf0vsTve3AcH/OonsW6y3HKKL5MsIc9x6iHD3KcAxpz+EEd5BIGMlyBLmzzKtoEvCteGfiLN8cgMNeqc7LwnHAPvsMdWguHOSTlFG+AIjcvp6JaVPga3ZiGNKjxdKhHIxnCMOnTu+EOd0SDEja4iuiYPbovOHd8qThF2tXe/3ab8HZvVwkFqG0HOGTd5m23gXd5t3eDsHfkxlkPqFkhMAM34Ea5AA+qxzGXYTFcBjJjUg/0pnocNTLu8AytsFKG1AtJ0QurQCcwWBqk0DKq4RqOBD+Cwgi+JVLxRj0X4yX2QHt9xjH0EA9HiISyR2iPdw/uYAs4YAQIZRdkQAaLEkwC8VUz5x8OMQYZ4TYSsWlp0SoGYTcGIjjHZC9n0QaXdAfV9QOp4AycoAQvQFl99S0kIn7UIA3TMA3JkAwmJQ3XYA3SIA3WAH/xF3/dEA2OYAPLdn+jEwEf0Ady1nCrQQqhgImfoIkCSICVoAnZJneUEGSSUGRBllp5p3eIwP935bYHoSUIEhhaKhdui3AYGfVRvMUZ9CYP8gAPu+iL8KBH8scKqHAyPkEMsVBwcRInb2InqOF/0yZ6k+AIO0UPd6QP/4ZH++Z6FiOERahnsUcP93aE92ZxS0g98sANngCFCOVQakAGbVF8BeFFFGFpvEIfFoEf/cE2dqMWOodBnzZ9cQUIg0AIt3EHjAALnEAIgeBhdHIKtWBr1jCI0tAMf0iI1JAN2XAO54CI3dAN3OAOKIUKMbBsMjZjMoIJpQAKDLdwmBgKNvYJAuh2BeiJ2SYJomiKpKiApkVJejcI4yZanBWUm9V3ezAIiqAItvAOusWUvviL5zAO26AN1WD/ftBQkcdgDLlgC7YgC7LACl9ZCS1FC0hBDK6gjGcpGpu3cDfICTgljYxQD+owD/twjf82UvWgerI3e3tpD/g2gvzmcbnIJmCAAzXQBg0VB+6IFvFINzP3Hw8BQr6yEAmhFmtTmc83KwYxLz6ymQJZCIzAPqlACIgQCaUwa0aETcRQYdRADdMADdAgDbBpDU/HDefwDu+wddyQkbNpDc6ACivgiGK3Li/QCaLQcILkf6MwCqGgic0ZkwMInQZ4kwmogKb4bXunihHYWZq1iqE1CHXQioywCIqwCLbAC1opC6/QCm7iCZ6QbeOpCHwgn1VCn4QpZT+wMPRJCaowls4g/2KuAKABajJoWRqC5FxtaQnTOA3nEA70QJd2+Q992Y0fOIQfSITiOI4jCI56xhl6xApSlgJtgAZ28SNYoAUwd0uO+RDJtxC4YytjcJmVeZl2My8wRH0+ggZ2MAiJ0AiT4BquwAkgMAOO4Ejh1BS9EAzRkA2xWQ0USYjTYA0ZyQ1TSqXZYA2uyQy39gyx4AMmEGORlRVf0AmZMEgLt5zOuYnRSQmeOHeUQJ3dJih1h4oRuHfe2Z2aBVqHgAjjOQcWBAZhgGlw8RbDQ59zIKhhkAM+YAV0oAmxIAuzEAu7gAuxEAzBAKkBKqCtEKDKeBoHOnqsQA3n4A35IFL5QG/e2P9x4YWEq8qqG9pd/WAP72ANioADM3ACPuIFXnAGuHqiXTVzmOZL/KEQEwFGcDMGYagWWtCryroWhOMgudoGejAIjBAJk5AJrpFcHQABjAAKp9AUsICkfrQNhBib0MCaUqqb2KAN2IAN1BANzKAMxyAMuLYLhyACH6AAyxZZMvAIpcAJpNCtcLZ2MbmJbTeA2FaAn+imQjaddMew1ml3ebdam+WdOroHeKAIh7AIfPADNzAlOQCyCoOfIzuywPqnCqMDdKAKuUYMtIAMvqALs/AKr4CpAKqemKqMBVcaKrkJlmAJOCALUxoOc7kPFlcPqDpe4tVd18Wq9cCqfPaNi2f/D+7AC4Q5Ax2gTF5DF1uwBZtWH/+BabozEbkDEcYKTEJyBcpKhWtLBiXqIGggop4JmpegCZtQPrFwCjogCaKwCpqDpMpgDdhAlX2YDBjJDR+Zrq1ZlcyADMRADL8wdZeHCi7AARVQAjKQFVPxBZPwZqTwCQI7sJ8ACjG5CWxXgJbwdqi7CdJ5kwe4sKMYp6doWhL7k0HpiheLB3xQp4xgBTMQAijguyFggTNAvMW7blImZTdQvFNyW6+ADMugCHOgYrignrFQs64ws9aLsznbGhGHA+22DeHADo3hgRTqqkuLXU+rvkQIXPbQDZ4QGCeQAWXgrGHBIF5bBbgUtmSb/zv8BDfJqqxqSwZqQMAFrEwHrEx2ALd2MJDU6omkEBqGhAqI8JC6lg3vkA3UYIjvlw26KZGsGQ2vyQzwSgzBELPLEAy70AufAAIqwAF0CCOtFgiXkBrKCbqjwHZsV7psp22oC53aZpOL4Lo6KWTTaJ2lNbvhRlqiRW6bhQjGwwe5qwd68AMhgCpXnAEdoAEdwMVdLLxfLLwnoAEacANStghv4gmzgAy/oAuy0Ao0GwtxLMdzvL0yKGfw47sQw6Clx3qypzHla17YpQ6saoSFdl17Zg+e0Xs3MMZagKt04SPMCnN1U3P9YskDUzuZXAYsVwZaMAZaUAZkEMploAZlwP8GdVDKBIzAo0ZqbZAHA1kIjRAJmxAKo7BSh7QKoxAMgkh+7oDB2eCRGWmlEimRITzCyDAMv7ALtACpr2DC5LQJJ6ACIgAEU/AFhoDNIyIK4vQJqDAKNlW6pPt2z2mAlODDmwDENxMobkqdgjKNjgCxSVw/SAaBrjhQVcIHdMASN9ABD+DP/wzQAG0BA20BEDDQGQABGbDFgUcJuEALuFCpujCprzDHFS3HNRsnqCEKPWuByLOUGuUP/sAPI21HweVRaIIm/IZ4c+RluWgP8hB/rTAHeGAXPoAFXIsFT3IGV7AgzsfTXWWZbnUWZxFqaIEFUXAFEFEGcFAGcdDUTz3/URNFymuwBm5g1XmQB27QBm7wyjtarZlgt4YUDLbWy/H3DsHYDcJspe6qpc+gDMQgqTL7qLPwqLHwCixWAyjgAkVQBFPwBoYQCI1QCqjgSHW7CaMggIht2JqgiQOobQGYCez8Y3SXCJEQKJEQCTtzd7eRCIWQMxMrgeQmn/KpG/70Ax2AAigQAuiBxRqwARvgxR0Qxr8LxmBw2I2dsKqwC8DQC7vdC78dDL+9CySWMiljluLkCIcAAh3wvRoIbyPNDyjdUSideqlXb/NW3fOmi7sID7gZDZUQxWHgA0tAOFmQBVigFzwdBcC0IO3N3sbCtfHNtVAg3zgNEUpyJbK1/yT/NFFsUNVXjdVZjdWAAAiV3aObQEOxgAuq6XTA7JFpzZpsHQ1TtxSN6wu00Apv8sYm8wqzgAsmxgmmYgM2oARK8Ad3QAiWQFOZYAk2lsNux9irG+MCSAl1S7c2M9mTXXeWfRuNoNmc3dme/dmjVW6cNdqkbQa2mtooMMZjDNtcvMVdLNshEOXDG3jEi7xSNgd6QmJdvtu83dskFserIAqSIAi9ewIgAAPrhlu9aA/U02VeUt319tJO+YvdDYx5fpu4uXVQ9wyzwAczTUU2jQVccN7pnQU93QQ9HQWJbjcMwiD1zbXI4gWT7gX3DRf5PQb7/U91YNUAHuChDgiFcP93kXAJr2FIuLAMzxANrEnMWAoNbb0MyBAMvuDQr5DLnzAKb6IKrPAKHx4LqMAJaAADO6AESaAHaEAIjYAICYoIlCAIdVZnCfp26EwJAagJOzYJlSA/QKbjpsXjm80IdifkhLBafvdZURxQbREHVpDavuvFX3wCtJ3aJ3ACtmqrJ4C8WJ7ltlUJqjDHKdMLYG5iqcAJjHAHPpACWlzQPHAHNxB4igANZ53n8LCRrJSu7UqIzcDxxpCV6Lme7Nme8BmfhYpf+Uw7OXAW5u0jZnDT5q3oj27eMh/pkp6rlZ6rWLDpSZLfTMLfng7qoR7go+7ZoMkJmucKHk4MzjB1rH7/a1rKuL+AYjJrMgNqCle/UqpgMjLrCqkxCU8gBEiABsjOCDtlCYigCZYAB3tgZ5UgCNOoCdqW9mua7T6Lbd/+pjw57uJuWuVeKAPJigGFuwIl+HQgB3uQA8R778bL+Pze7xNRqBiLlGtaCaagWNYbx3qCjAcfBzkQAieAHgMNAaNvCXGw2oG3CLfACqbQnpUQn4Hep1lugfMuvKxd+1KeAWAs5T8gW3UALz6gA0EiJD6yBTAf842eBe8t6fV981jQ1GbE39FfB1nN1UI/9LA86oyg4gnuCrQQDEuRFLP+uDGb4aHB68kFoG9SGup/9TM4CZEwCGgg/7nxk5KACHAA/57NbgmSUAqOQAd7BxCUHFWqRIlSJU2XKFnKVEnSw4eLEkmSmMjiRYyJCm0sNMgjIEB6BI0UtAcPHjonU6JMSWdPHEFyftzQ8QMMHT6HFDmypGkTKFOqVrV6VXTWrl3BiBFTpmzZU2dRowKL5WoVKUuHwszoYAEChAcWLFAgC8GBAxxcIXQ4NANMiA4Z5M6l+/WrXK92LdDlS1dshh9xzJhx4kPHkiuJFT95EsXx4yhNmkTJEllylC2Zt3jh7KVNm86fsZShQyfO6dKpU+Opk8f1a9duXoMcVMhO7UaXOJ1ahWpVrFrBgvXaNauVKlOeFi3/1HyUKVTRe0M3FWqTJv9ToD5tYiRp0qRMiBx5HFQnjhUdceo42oNIkyA8hxAtQmTQ0cGFBi1Rghgx0fKMNOKIo9rIGwQkPfDYY0GVVHOwjgUPOeSUWnoBhpinoJJKqmeeiebDaDr0EEQSP3wKGFcogWMGDcxigIEEEEDgALDOshGtDiDYgJEnLGhxLr0gEAusBx6w66sik1QySQeWNFIHK3zIoTAncghDjMSigGJLyLKorAkvvXwsC80268yzzzhrY7Q66iijjDbjlLNN2OqEDZDa7NhjEPHA40QSgwiqxBNPCKJkET5uWkQTn0ABhZRTTlEFlVFA2SQTSyz5xJHvOGXEkUssiYO9PZY47Yb/HH74QQ5BLjmkJPHuW8QRiCaRxBFa+6soQIsG3MhAkILVo46TWFItDgfluIMQQuoQBZhlNnzGmQ45HDHEEkm89pllYvkEjxkyeIABBBI44FwC0iXgxQXadVcDC07AxA8IGoCAgQxC0ICuDvbNQAOA/bLASSfPepGBsHKQ0gcaFPZhiSWYYGLLJDKrLMzIuOBCTMrILLPMNB3bAgsy4IRzTpTtVBnPQZS9o71PSc1Jwln5W04RPk4yKJNNOOHEUehO+SQTny6ZBBHuOJXPETkY2aOOH+CIQ4cZzKAJwgXLQ2RriBzpzhJJxOuPIl4tqo3AA/EExDU99LDDjmIdNA1Z/9NKi+OOOwR5dZVora02KhEDFzwaap1ZhhhaUFEk3HFlTDcByA9Ql4BzDzC3cisEOaWRCyT4SqwcZsBh9NFvMP2GGVKfAQXWQ3Adrg76BRhg2WMP4YQclkACCScYsyKMKqhgogkotkgCCsc4hiyy5D3+ODTQ1Cz5TerfRLk1lWcLtpCYvWNIk0wn+d6n6zIhGtNLPyHFlFOiQwU6Ui7N5JJMvpNkkEUOgYMOS9gLAyYqWGEPP9iDHJYQBh+U6hBWiMMgaMUIQWwNV2HLVUXItquMDMhAaUOQnuLmINSk5jR4qwMdDlGLpyCjKU7JUAs7ZA0Q/Y1wKHLED0KQgSPZ5f8BN7LRA9y1gAS0iwGpSEUkoEACD3gALBbIgQ5Gpyoc5CCKpDud6lR3gtdl8QRbREEIZkCTMDCGMUeAWBWqwIQnFK9izetSZZrHheedKXpoUkOcTnY97GXPNcECRCFwNUHvSYIhl7KEbnyCKfMRxFGhIAUp3GeKUXxCE+b7jiiOxghKIIIOcNiaeNBDtTjgzgxx4IqVSCmfPRzCEVuTTycZMRGKPKRsvdJg2jgIEpN8EITHctnT8ICKwyEDGcwgZlOWQUxiPqVE0yIGLEQhhxN4xQEMMBgD3HUwbFIziNSc5os2gQhBhIEIO/AACDJgATPoAFWqYic7dfBOeOYgB6b/k2c9T4c61J1gBlZYghUkJrEjBFRijKHYFpC3PIR27GNmOpOa2kAGNbCBDWqgaETZIBvYYPRO2sMT91z5R1yJzxLfmd8mjEa0TVwnpZ9gZCMhmdKe1U8UlqRI/qhQByuUAhE+MMMSfDCDFPTLCTRAwTzfuYQ9mEEQHtnT1viEiP9IBIP/wcggaPmrA30kWPAplrHkZrc6yEEOC6KDImhBDGGukBkqVIYwVbiMGC5jF6qghA9A8BUHANFy7tomuWRUrgS8qEY8XFAY9oAFGOwABPEaxBeP+jt+QswK/KQCxCDmgx/UpJ2qkqeUOvuwf0qmCU9AI0GLZ1CEuhGhC20o//QgStHXRtQNGo1NnUCiPfJ00pWMAFskIjEJ306CfqFCKSgqsQmWtvQUptjOpXyWCU6IwmiH2ANYzeNFFuUgA/3aAAho8MUbhOEMegqDIxKBB48gYhCfomp7JRHVWQpog8HKZVcbJDcItWkPJcGDJ5SC1qYUM63IWEpUllGLUfAhXGMhiwMgl4AGOCDC3cwmNnuopEL8oRBtIAISYLCvQmDhi0uAkg9MfGInROnEK55slHRQzyVk9jBWQEKLfydGMWJBxzuezPKU17wyhaa1n5HoRCl60YvOVo92os2BuMcIKDOiEVJuRCMgcWVIfOc7obIVpsjH0udQChSVglSZNf8hiUPQ4QdqhoGp5NkVCyBAA9HsAA1gMIMmHvAMJ6jD/XQry//4J5bvhW8GO4JV+to3bve17oL2i4c5vGIpxGBGgJtCYGEuJRabCIMGkgQCELCOdSpQQcN2wAPD8CAHNYDBCfollrwMtkiGeIMSknAGH9yuNjwYMRXCMJgw2DgMKSY2jVWsqppo9gcK4wESjICEMEQ7jDh2QrWfgIXE9Fi1GBsTa1vrUCQfebZJpu2S89BkQEB5I+ouRJUZsRErQ8LdUIaqIH0C5ka6DxVEXMUqrJIKUFgCD/q8AQrMoJYMkAsCQbXABjQQuxts0bB1IE8icDWr99ZU44sYWyxfeRH/DfJxQXzImbHsWxo8nMbRY90DHBbRi6UgYxkBXkamd/GKSvwAh0LSAAjMcIafD5sHKIABDRrmAys4AQtt0MOTCXEHNMAABRuINQQMEYg33OGn/JPE6VL1O19LO9pwOMNp9Kun/crnU5S4xCZEcQpR5KENTTjCr39N0Grn/QlXwBIbO8ZtL20BM0GG3meILNGKklvJryk3R1nWxz8QghF+wAIaJN+IQPzBD3/gPLOY9WRJEK05zVlf+6QjlN+4QvWrcATVcgB0DTBgLS2CAAhaZIHYpUAHHYBSm7TG8YfkSpbA7zhEIkFoWpJH5HsgeclRomiVwMHRL9vDHObAil8A/zhDBA5GLCrxlttJfQMUgAC8wMKuBRjsLEb6XHdhIAQv6IFZf0BDD1bgAQsQ4g9A34MpXKGJkziERQgUTSA96JAO1XOFWKCFWqgQYHjAC8EQDamFPGCCLMCCyYq2HcOCJHACKNg7LBgDLWiei8kCjQkTE+SCwcsMOTI8w7OoI5Oo2Sq3xtujYPGIQgCEyEsCBwAAAEgAF1ACzfMCNHgDPXCD2pCySJiy+VgEnOGDSggFfVsFVRAKBayKqhiFPdCAeZI9OLOLJnmAUIudfbKDM2gTQeiaW6GI4zs+W4EI4usai9iaQlAv9eKgknA0BjGJ+qqv/YmDPaC+MAADs2IKFv86HFwwBTzApxPYAAhYgAMIgABAgMlRlweDnB9aAG5ygK/wABTYASXQgz/QgzfYE0pAhVoAhl6ohV3oBVd8RVh0ReEAhmCgRVsUDlwUjkmTilTYkh2AAbETOyaYNsm4ghEUrdRCwcrYAi7wAjIhkzRog2aMxjVwgzW4RmysxhlcPCa7LT7qqHb7gwTwQXIMAAnoATTQMCizlUloBDSwgyUAg0QhHXk8xX5LwFjIxwVswFqIBUGIiwfQAEcEixi5C9yzgBRIgSfIgTuQEESAMlrBFf4oPu+YyFtxBADRrUMYhI0kj5IgCT3MQwUZyT5Eu1TiA0WIBWrxEMNBsHDSAVf/k6ZqwqZLfLBMzMRs4kQLAIEaQALgsBBdJIZcFI5fGI5YLMqiHEqlRCtkmIpIOJ4aqAEzmsqppAIqMKNiHME2GpMU1BjK2Bgv2Zg0SAON4YKxTINsTEttrEEbXJtza7J2uwByJEcBqIAXcAE/gITucKB3c4I2+AHru6EMIB0c6AA64I2qsIoEVD0GdAVLwKIToKZ2SQBODMgMmIENiMoniINPoSCQAqTgC82LBKmbUYREYCUJIbmR4AOSGIk9QLuP1EPmKxbZRARFqARkiAYYIgbHrIMciCZONAsbqbCaDCKcvKYKe5HghMAHnEWlFA5fiE7p9IVfqM6kxMXqDMql/4iWVeBAIohKqrzK4LFKrDRGMtg2wEvBsfzKsNyYsnzPs1TLa+TGlXHLPfqIRtiCAZhLAAgADBiBEXABL7CDtQEnQZiaQZwDHJiL0QkBCFiXDLgBRIAUVDgFR/K3fLQKRLiBOBMLyFkXIemAGbCAG1iQpRKPWLmPPwq+z2RR0lyOikBNj1wqA8nD/WpNkHS0HHXClOyGbnAGVTiEG9AXF+Gh5ISR4rxJITrSg1lKoXzO6aRO67zO55w0DCEGR+BAG9iBGuA7MRCDKgBTM/pSLDFGLVAeZUzTv+vK9tSYsxxL+aTPleEo3LgASZzLBsAADhCBFEACAu0IRKg+PrCJcP+ZixDAgQdVFwRwAAs4gtALBVOIVFQQClQQhTCwANkjF6/wEQ1IASyaAUG4DT6pgxQ1CINwUdEUCJCKCADJiDt8qg3CUVn9yKVyzQWZFWLoBU2gAhbBoR2yEeFkUr7CxJtk0huhUqVESuicUmYdBmcdhqG0Upl7BThAgySggR3YATNVjCsQrSZQDC04U9XqmDVFzzZtU7N8U7SMU7a8kxvMsAaQxDstAAz4zwBFAj1AhDowAmQBAzCYgxsqknxZUAIIgAOAgQ1YAMqxJgiogUVojk2QwlEYBUoIA7kokr3wkQ6AAS0IHkEYA5dYpT7xDnZ8Q1qxn+/YD/sQvpqC0Yz/TK9XlRAJGYlXodmabU2OHCu9wQkb+pdYyyvhHM7kVNJiZdKDgVZn/a9gcFakZFanrc5nhVahnNpJI7CKfQIksIGo3FbFaILQSgwtuILUUkGuFBMUfE+zhE91xUZrXIN1lVN3fdckOIABkFf//AATeIERIAI0eBksugG5+AEcUJJDDQEEkMQUoIAGSKIGQID+JIAHMILQs4RIOQVQkIQT+BcIOKfbCYEaiBM6AINYkYRPESmwGRvT9Z5MsY+xcdlW1S2nklnZnV29qVmORAQzeBr02NQhwSsH892ZzCYgQr8fOlJNVE4bGQZkOAZieNbmjVqmTcqntc6kzUUrjQU4/6iCJyCCHmA1rs02bxWDMRgDsaWMMSHbjilLrhxLNyXLsIxP+WRb2ZjBbuSjQtgByzGAAhCAAjCBD8DbFcBX3NWBEHiAfClgBCCXB8CBEGCA/lwADwiABRgACFOigg0AAkAACzCCtzuFUuCEQYCXDKCaiLuBOhiDH4iP+RCP/qEV/PCO/jBV/pBhVZ3I5WhZl70Ir4Fd2J3dTnJIRMCbn5KmTZxMyKkXoR3a4zVabFrig1kAtzoGKT4G6H1W6Z3SYcBi4YBWXLTSnDMCLBCC7oUBLAhXMwbbsNWC8R1fcv3KNEjf9+wS9k3Bi0nXdcXG+ORG+q1fkCgEJKgXBWiAAv+QgBYwARlYARtAAzQ4g19DnbR4gL9a4AIOAAAYgBGoZA+Y4AUwAAKAAAqIRAwmAA0wgkHoGU7wgXPKFyq4icxKO0qwOPABn0DhD7ChYVteWYLoONcFkEWIMh5GTSDm4TjwgamzESECosg5gAaYMApjYgtzZmziBV7IBWqu5lu4BV3QBVzYZm7uZm/eZl2IzqdYiuykBTGggiNIoyNwAi9AYzPVgm894/E9VxI82xN043TNAonhAreF3xmUX3Nz19rYgUeEREsegRZwAQ4YASRAg2CTA6hZUErM4AYtWABQIhrxgAPwgDe4AAgwAD/wgAGQnAxOYA1oA5+5g3kyrDD/UDtAsRlN4A9FmGGHECSLPNWHkGGK1DgcnkN6++VgDr6LUK8zyAEQoLoJ8BzPqZdlXmYeMlJobmLkfJFltiYr/gVeiNLozGZu1oVd8AVe0IVcuIVqzgVpzgVhOgZhyGJi8IQlOAI02pItQWMzJoN3DlvxPcE03WuwRNeNkYy0XdtqZFvGyx767CMvQIG8aIAVANARuAASgIEEGq8xeAtKpOTBxAHHDYCvSABQawAX8ICyuIAeGOkBGADKSZdF3QAhQAKligM5OASB2AS9ARSCKMCDWENBUgidvpWDMBQabl04bFWL2+Ff/rNb2ZpECKeIo7oLSOql/oqmZuaczMlm/y7iJ57q7H7OYIhS66RO6pTmsxZv8k6GZDAGYRAGXaCFMuCB4vlALECtKDDjcLVrMyVTMQDLsrVnFbRnE3SjrlTbtNzGalSZwy4EInyCFNAACnCBHqABF6iBX6wBHWsDKpBo1XadB/DBAdgChTUSKBCCxL2ABkiCCTaA067bdDkXBEi/DaiaPQCbSWAPB0KE0Dsz/JBhQQFu/hAUHedxXd6VWcHIjBxq3bq4rQmnGWhEeKEA6M6hX4Xqg3lq686r7C7eTLw0Anve563i9OaF9A5zMS+GYjCGZmgG815rU8CBI8gM+JZv+iYDMihGvlvjHwvLMCnLEkxfE0westTr9v9FS/i9RrSU08MehDawg9xIhCcwAi/ggSfYgja4Ni8ABCMY0heRkRAAA80GAALwdCGZEQQop3pxgQs47QA4bZI+AEq0HHNJAAs4A0EQHz6xqtDz8dsGH0tACE3Y8R3/cR/H6ZfG4c/ESIsgbq4xLwhaghQAgQ7YAIejgOg+kl8tkvV7amyn8isn2gUwb2+fYnAHd2/39jOHBnOHBmmQhmmYhmzghmzABmqIhkW4AShIAiL4wCvAgsbomPq278RY4zHYazTlGHPNAq/97yxIg66MT/ZN137WRtiYz9mwKkaohN34vyVghFLIg1eygz9ohAvvgCJBgAwIzHShZHKEgBH/8AAUX4AG2IHHSZcGsIB0OacWz/SbFxIkIARc6Q7b7vXbJojrYJQdJ3pfP3qc7m0XfdGLg9FEaOFDODhoh/YLsIAnh3KCyXZtF15u/6FzT3ewpwZrsIZryAaz91G0dwe1f4d3gAd5eHu4h3t36IZj+AEYgAIkuHdsY4zmqWs5D9c3mWe/3m8UfCPLyPM/t+OzFPA7xqi2XYP7TITukEJXSMUGBIZSMCkpywRK+AGAfABCVIQHUJe5pOQD8OgFmFsMdoAMvhfITdh1ST/HWfEDeIAO4MxbyYTtEBSgH3qjZxSgP3pfN9Vft+UWXfo/YoQ4oAEQqPoLeH4LkIBpp3aC/1ESrb9ua+p6d2F77ud+d+h+tocHtf/+tocHeLAH9LeHe1h/9H/7d8gGT5gBHkgC+h+ZMMKCetYCOScDwC8DwfdvgMgicGCWKAMNEiTIJU0WLg7TQEzj8GGaNWsqWrToJuOaPIAGJZKUidSpVbSALVtGDFisU5w4YSLl6UcHCw86KMoZggEBAgECAAAKYGgACRACEHDQ8wGCngwQBEDgAAFVAk17GjhAgIEGLJI2baqkaewnsmLHoh1baS1btmjbwqUkdy4lR3TlSsoryZEjRndyoNhAYQKHCxcoIIYAwYLixg8eP3Yg+TEEyJInX2agefOCzp4/JwidIF48eKZPv/9LbfodvNTuXrtjLa/ePXv3bteWJw+eO2k4ZtRIoiQJlCdPsGCJgtCgluZarlwZI10M9ChXomjJogW79u7btXDJLh67w4FcGk5MT5HjRogWI3YEVChRpFCnULkCRiwlsFqxUolyCSaLLPJDCBlkgMMiinjiiSJgQNDTTxMGBRRSUGnmVE8bXkXAAQEMMACHCzxgwQmDaMLJJpps8omLaIG1YlpwrfVWjWq1Jddad+2o116OCOKECiAcJoFhhyW2WGNLQtbkA4o5adkDknH2GWiiJYDAbbqdtttppnHpTmuy2XaPbuNsk+Zq7uQyhw46bJGEnFsY94RyykGnBRnNjVH/hp9+ShedFmWQQaihhWoxxqCJFkrGGE0oSoakkk4U0XkURQTfRWu4kUdFHs0XSSb2mRRMSsT45woqnESSyCCK/HYggw02OIoiITCFFIVDBRXUUwAgkEFPVCHAgAMJODBAAgcskIAEzGZJ1QMn2DGJKJyAcp8pobTo4ict0rhWJuOOy1YmlohLiSR3UUKgJDtWUhdfjJyRgwooeLCBYRbwi5i/FBjlmGMNPNBAA4oZnLDBDjTgwGaaUWllZ1gmIA9r77jTTcYZd9NNNh9jI4000EhjjTTy2NOPmfJA04wxxkADDTPDLAIGFTdgEecWOxunnEDOkXFFotIRPYYYYvT5/6fSSwPap9FVEK0npRKpl6ml8Lm3UXyhjnqKK7XotxItrriSCimtDlLgDDOAoQorprBC6xxg4JABUxv+BAABRPkUwJRWEavZsgdkZVgDBohG1QJSaWCHKKecYoopn5BCyiaZeKtJuOSWy3kmPdIVb16UjIWuuo4gcgcSLgyZ7wb6XsCvBYhNMIEEAS+JcMKNKdy7wsY6LHGzWELTjTTJHHOMML4MM4wvvDyfyy2y2EI9L7y4k3I/9sCTTDHF8KLMMcS8MgccOuwAhfpQWNczQkDnmeifSCddhnRMN1200VTQLzSlC51HIAuxVNUydZE0dAokkZjESFYRi1pAMFVkO//FJRKRCEXMoQo4mAMrOviKDnpiDnPAwW86AAGeTGgAP/GJ3nhilRc+hSoHGEADPECBBBQOAjKkgAUYAIEd5GERnzDFWLrFom+lRXOV8By5lvi5uIhlR6RbUSUsMQlEyMEJNLgXCEDwunzta3a0s13ucmcw3vnOd8bSjGcSMDHRHOAAuXjGM25xC13cAhe60AUuaKGLXeACF7Kwox6FkQ15/GMf9ngHNIxBjP2ohBI/sMIOarA+KEAHC9cxCBck1RyhNQd/9puO/ohGv/vZbwn9aw4Z0BNAilStgGt4SKfkkwhGTIITpECFKlZBtlWsIhWlqKAg+FAGMYCBErZoxSL/PGEKWThohHQLwYHuJiIRaQUBJ9Qb4GJYFQJQAAKhYZYGILA4B8DgdQ94ygMURIlNhOJb3QJLEs/CxExoglxyeaKNKhGjczliD0vwAetQAALXeQCMsevXYCZQxoeiMY0GWyMbh0exOB6AedFQBi9u4YtegDSQu9hFLWgRiwfuohfEyAY89qHIdzTDebUIRi1cgQcrIIEIQrjkFZCTHIR40jlSK5TSSmlUoUpNC0cA5XOacydXQrUhEFEIRtLzqY8gwhGSsMQmQFEKVEDuFKUQhSUScYgx/OAHntCFLcAQAhxUwhOV4MMIcUBNamagJlrZ0AJ0yCukDOsqumuWYE6Y/wAPEMkDMZwWCflQiU/E01vyjBGLYkRPFuUzn3k5SxIrCxZLIMIMOaDBCriI0NcdiaH+akySIAoBiSaMSgxoI5biaAAD9IIWu7BGMGIxi1i0ohXAVAUqxhqJrWbiFKqgBjz6oUh3vGIRc/gBHX4ABysQgQdC2MHO8ORTggR1Us5BZdGWpj/x6uk5TGAqKJ86EfSYZyFUrYh6uLAGO2DhDHGowx72cAhETCLAl7gEJ654iOriQBHUm8MMOtCBDfKBrtPFwQlC0AEqMMFuMvxm3qBCLAIk4AJQQgAFNsAvY6VgA+YEHARuMIO3JjOekfWWZSdLWXquSF2ZkFESJyuJPf/4gAakNW2+Evo62BnmX0p27ZIO9treZeaNcCTcbfdwhzgwohd7mEEO1jYDg4qAAxiYwOtScAU+QKO5ihxHM5ghix/M4AZLeMIOfMADM19BIFHYmRcCqJ09DRWpgZaUGiYFaFaG9zlMPZqifJaQ+pZHgAC8VHkW0gYfOMEKZjCDfu1AiEI0AhKRuEQmJKEIPoABDAqWxRxC4AMYdICaM8ADH+hANxLO4QR2g0xTtCIiDv/kAE4uFgkg4FAGeEAEF2iAiKyS1xDgAQwzSLAzQ2FtUGBbni6y7Ipi9K3P7fiyMQLFt0AbhhvAAAalNWgXN9DFhBr5SEhScjiZXEaFRdn/ouOksgEKY2JHrGIGGhi4viZQAQxgQAIiUAESAFGJaJzjHttD0zWgMQsxIIEHO8huunuq5521oQ0BTO9QDa0GqRXa0IcW6qH35L/nMHoMAiwIQuqrZwFKhOYJyQIWeOADH1ghDGbwQhsA8YdCMKIRklDLg8DAB1m8Ag8pyCkPaqCDCjdBEHVA5hwUoesHIOgGbDjBAwAnQxZWCFkE0JcEJrCABqRA2XtziglDULMMhMDpmyCFtUmBbXJDllvcBkvm8EljyWKbE5Kwgw7WNmR2H5QEIujiQRWaZHrXWzGZd21sI6bvwd3WAB9QgQpWgIJTwEK0NHABDUzQAhm8oAUr/ygCIRyBCmvAY0u84QY1rNGLMMhh02YIgyrF4NSdbeFOQG25eMNL6CZAP35aUEOhFZ0n6HiyTzeXKtWuRjVYDtBqbfDCGc5wh/4a3Q1+APUkNBGKyRUIB20zBQ4sAAIY1IAHVehABlKQAhjwgA5QAh/MwK5lgGMpwiKQHd5YyF/9RAPczgIYgGF4wAVsCAMkSAjQFd7JHx5Qwihkm2WBgrddzo7hE7dpwrbJSItUDicwAhoQAQ3AgAuU1r2gAOTB2+togLxh3uZt3kPhW0WN075h1AHYgBL0wB84gROkAjDIgQ4kwQ4AARC4gBK4gAs4QSE4wihYwzvYhpecw2sQw/8elIEc1AHxhQHSaEHObIESbIEXJARSGdr0pRyhnRzLqdwnsRKiyY+fSRqmDJBVdV+mOARybJoc2IEd6AEguIEbAAIjiMr7hYIn8AEJmYIq4EAHpEAN7AAMhEENwAAUpJv/9dcPnAD/wZUnLAgGgUEGWMhPCACFwKICFECIGc6GgN1b8cGBcKAiUMIn/F2LEJ61IVE+hZtl5dPguQgpBMggPEGQoQANkt4NGhQJVJ7raEAFHkkPspa94ZvDzNbnFeEBIAEW+MFOMUEVrIKWHcFOdUESbEENHIEdOIIlfALu2YM9WMw4jMM7ZIMqzMEYxMFAhkEcSAdy7IwbipzKtRz/9UmK1ajHH06EJ4HSnpCBGgBKGURkfA2i1RCQehiifiFiHuRBGzgiJI7KKIQCKqyCg0gOhRHBFnTBDgBCFBBBI1Rduq3ACtDA2oSAIoyCKmLQHDQIGJRdAMxQAShl3qQdBN7QTwQLguCBIuAdNf3AIjyWMHYLMBJjZiXj4HEbjZECJzhCHGQXaa1eDd4gCVjjuyGUNl4evWneD5pR54EjA1DMlGHBG0yBTLbBIJRBfgxCF/iBfOSBEWBZPZrCNcDDF7rDNvRjMogQHtABHMRBGBTkGSAkn7VBGuThpFCfQxJipMXXQ6wBG1Qfol3kn4wBpJVm+GnKRQhiGrQBFsSB/xzgph2QZC0xwtK93yiwQi8Ewy0sEx/cQCLagREUQhsgQRvUgBDQQA+8wHSiwAncgCe8TYMwSNyo4hzYDYjRolIWgAD8lcGoUFRAAN5hUFXOwBwsAiVwi7Zhm0rGEzLemDLSGFkJghnY2eoJWQ3aIFtSnpEllLzN27/MJV02mcFMiWw1y+eFhh9gAiY0AiaUAkxcQi8sgyg8zimkAirghyvEgi64gzzcBjycQzV8DCvMAR246EBqGhrUJhZ4QY2OH6QZ0AHBJo7GZhqkph2yJnpAxHu50kPA5kdSRG2igRzcph0AAiA4KahRwmPBzSuEDTIswy6swihQ5hkUwhseJv8R9MAUygAQiAAMnECCuY3kdFDcKEJcVQIVvFYcLct4GoAAhAhSXshjbNCBUBMO8MGbVo7fASO5jQLfgUIo8N1LvMSK4FMRbZsKuuBlIsEOXKGQXeG6rWVbdsAGwJtCyY5qLRmTMehl3GVFvREsqGovQBAwAAOrOkM0uCpK9IerEoMzlGg/9AM8jIM0bJQIxYFlxsEZmIGMymjIhZwXeGRF5OiyOuuyhqYdEpX9uNKQ+qGk/WGRqocX9FT5xcEdfAQgEAIkMtD7qUIs6McyKMMzREM0PEN0gYEg5MEWFMIO0EASFAEQyMAQxIAN7MDagMEiqMIrCIMtZGeDxA0ekN3/AhxAnRqAAlCAATDlVjyACPlpexLIJ6BC5bgIKKhk5fQdooJCo8KIMoLFJAyCGTwBEqSlDaxeppJeClCjNTrYpxrovnCjvVVGg5rqw7DRrIIUreoHMESDNajEMvTCSO3HM+TqPsjDOUCDMrTCD5QBfw0rGqCBFxwrstamGrDB17rHe0Dke1gVpozmQ4BmoSkNpPmho3GSn6UHQdDJE3Dabe4BIYhr0jHQELXCA6HEurZruyqDLIzCIpQBIfQAEiBBD0yBEgCBDcQADdQAEdzADYDBJ8SCHclCm8oNhZnTlIkIrwQFAkwTB+LBe5KECo7C6h6qtSlqKCReo24Co9ZY/7khwh6EAREQgaWugA247BVmKgxQIwq05TUiWWr1YGsxGc+aamYwwEoAbS/QKjEggzVcwzIgQ0rtwiMpQ9PaA9TmwiLcQB2Y39Vm7daGHHJcJGpWygGpgY9KBNlK5JGuQSuBhyeFpp6UQR2Gx87pmaORQSeFR6TV1xUYxxmQn5MCgh4MQtJZgi6hwivQgnAuA7taQ+C2azBUgiDkwBImwRv4gePaQA8kASFk2hLUwem2gi1Uj8FG09zgwQ04AJ0mgE/Y8N74DdhlwAxc5SJsAlhF6urKGKK+bqKSm4p4m3xugiXsgRw843bFgAv4rpDNYLoJ7/ASrzV+qr6AqhjJpf/O7qxlNK8DnFQsiKgZm7GI7gIt/EI0LIMstMIrnJQvdMM7SNw9vEM0sAIOGAFu+rEdYK0dJOsbEt2QZsFFFtrXsoGhUF8adEEXSEEkS8EjS7IkdxKhKErJoVwnMQqhAJp4zZyjDAoZUEehOSQrqUEUsA+NmqRHHF2ojRonjAJ+6NbS0hG7YjAtfIIi6MAMmoAJfEALjMAKYMEMXB0WgOIN8MEzubB04cAP8IEOlJOxfEhgNQUCPAYHuueUgiCHcii28Z3rui5kkXN9gkU8YZswIkIdmIHiLq7v2isojuL/wYD/CagHaDG8GagXYx4YhzEEjLFkgChYdeh9lAIwXeL/LDADMryCKsSxLbDUPfwD90QDrPCAH/txICcr0dWoIdOhnmCk0gQwJVcySUtyFoT0nzBkefBJ/YDmnqCHnpBXnwTVUCnHG4Zcp3iELTXCqG3CKKiCGhODMiADM9BRu1JDuz7DMqACFZxACqyAFI8Aw/lAGPgAGmwXDMSZIqxpJWAQHowQ/2XACV0zA0BGVZIQoMqFJpCCKXizKAxqXMu1OM+Y35HbyQrCGYSBO/cAPFeSPFtxPdtzF+VzvMGOqI4qGFNGlDwGJxAYOEPOQLcCLUCdLRzDMyADHh0DN8TDP0z0OxQDGNxADeDmQN6mRttossLXRXoSIgNKdlRybMc2/0qrdNpS30QWCk3XoScNBJ80jZ8w33NwZk67QSs/KdJFgiM8FktK8B4NQ1EftbvSkTPggie4VSfCABG0wRYcQW3KgRXM2RisDR4EpSqGkK7lFYLsGpQkiPzNzTZXwuqeAuseqlzbt6KCrOuSwup+goowghwQn+Lurl/XAGAHtv+lgDXes5EdWWrxc87685M0hqrCAgSBVNCqFDH8AvYeQzI8wwVLwzmQg0vJQzeowg/kAAzYAZMOpBwgK/qOH859LfWBdEq3kmzjuBRcMnDb9vs6BPXVNtDA9M9ExyiptJA3R40SHdciay0VQiGkzS+SgkO/QisM0i8M9S3TUQVnqf+t/EAVkEEh+AG9PsEemAHSMUIAJgIqLEglmAIezMApyjl6q3fegYEIBWwzoYLkzDfrzjV+23d+K+p8Y9slDALxLYE7C0EP9MB2/bU8A7Y9s+WC2yzyHmjOhhNjgDFKpESnO0NKOEOoL8OnH8NCM0M0YAM6tMM+7GpFo/gMrDhGJyIWcK2NNgSnuAFqWiQiY6QacIFsQ7IkUzIXYKQdfi2vT2Sxo9ceTkRL30+iCdX4LfmSN3mnLGIdCEJIUCkqjALcyAIt+AIkPYNRj/tSLwMtqAIlsEEedAEkeAEhoAEhQAIgwIARVAItVAIJ4cEYPDMJxZmFqXeCiNAc8MFULoL/A60CS9J3fodzoAf6xmKbJMiBD+QUxSsuowuBoxf4xh94gk/6NeagpScvgvIQv4AxqIO6M0z3M4R6qG+UMiiDM5BMOJTDS7UVDuRAB9RBHeDmzs86sip5G2hEHrjBbgPp+wa7sOM4sXsy9c34jH9foTikyhWapQxN0kgKewkNjXoBIVM71zaiG2BBCiPCe8aVJnjCLK9Cc5uKUTfDM8RMNFxDNBBDKCRCHmCCHjx5G2BCHhyBDmzCKkTzDZxA4f9AqqXai/npBhF8TtCVJzyQGW8p676uODu8XIPoKYwlIli17lr84vpAxjv6o0c6gn88vFXeYY88vfFLBoQqk7W8/8srtXRr+TJEQ6g/AzWEAz2YyTVUAt3cgAbsvM8jJ9ciR07jOmp67dRP/a8Du0l3gY/WYWgqMhtY6/o6ZPY3cnl88id/EnRs/Z7hNNBvNLIywXHwV1ZJwiH4ovuhQhxvLzKofDRAQzT0nvU6Qy8UrhZ4ASDkQSYABA8dP0ipwvNDR40UJ3TAoVJnj5gfOEKEmKOIj6JKnhQpMkWrVi1arlCdGhUKZUqUpFi2dNkSVUlSmfb40IEEZ04kPoj05MFjx44aQ4fCgJECaQoSS0mA8ODUw4YLFyxYuEABa1YKU6tmrfoVLFgIYyFEcxYt2rNo19A+c/s2Ldpo0KrFq2cP3v+xOWAodqjzt44dwW0IFy7sZk1iNWrY5GHDZvFiMlqkVLZcuUsXy5kTQ47MWLKaNKO5MHYDmUxoNWS4ZMkSRY2WK6llk5l85YoW21igQNli2M0WL162CCdsxMiRK2XwDEKEh08iSpo+mUIFshcxZW6jUbNmbS1aYrRClTGySAcOMKtOjVnCgwiMHYJ5MLEjiM4cHDg6avTkaZFRVqmlF1poiWUVVE5S6aVQXnoJFVNYmiSOHG5AwgkndMKpJyJ+Ciqooo5KiqmmnvIARamomorFFlnsKqwYY1yGGGSICYYYYnYJppced8HlxllmWaYYW4wJRx153GFFkTzy+OEhwQb/m9IOw+xII7E1RpPssdW00A2zzTIbEzPFPlvsscRGG61L21Rbk4s4bbPtS9zqvEKMMsrAgjjj3HCjjeEI+/PPPKQUbI9BDkHEEUos0SQU61ZxZZYdkXGGu+6suYatZ1hZZBEcThDjFElumCGEDTQgAQs0iEBqjDL2yqijRSrRyJRXRIrFFVcSHGXBTz5xkJSVHnQpJlRIYSQMoTJ8NqcnfPqQqBqMGpFEE1Hc1gOqKOj2qq2umiqrq2Q8d6xW1H2lFVVU8fUTBTX57z9ZeGkGGm/IGQceaSpZxEkxwDi0SsKwKAyLg9vAUs00GEsNtTnDxGzMzMpc40w3RVsTyy5X/1stNdHiHHnOOb+k84oxVDajOD//NCxQQeWYeebAIBIEkUUcqWQTB1FZJRZadtROre686y6aYVpRBAc8UjE1Dx48IAGJP5T4A4o2BFEEDDwAVGSRrz1pRegDe42pWGGFJdbYY1lKEJVPELHC2WczxOkJJKYVqtprUxixxKag4rZFrcjFitwMMjg3xlE22QQUUSQXpZFBJkEkI0pY4UUabMYhJ51w4HnHFj4W0QMNM6wgGOE25IgDdjkWTuOx2iFr80vKLpOi4t23lOzkzxjG2DM3J8vdteRJzv3LMcRQeYwwfDOuMOoDLWxmO2aOQ4477thjUUckqYSSTDghJRWgaf/BZRdililammmgaQsZVkaJhelKmEghiSn8eKMRQgBEJj4BqlHQ6z+K8MQscIGLWLBLFRE6idqGxaCWEAtZqjiFJvbwnhw4AQt2s8IIl7AEH5xQBzlQoQpvcCqjICVwTBkc4cq1lXJNRXGKA4sOv7I4TIiiFJwQIidKBSpPsCIX0ODGOcIRDm+YAxzkOMc1ODII1I2QYAUjzF9oJoeO2e4xfwKZFrKwO95pxoxScBjwNJaa4YUMZIthXvLomIU74eZ5sXJeFKxHmJYNKg96sIP39rCHOwiGkDjLmSQWIYnpiOIUqXBFK15BC18MYzvQmN9cmuGWZUSjFbZighD8kAT/JbyhEF6YhCY0JwtWsMIUnjjgIlixi10cSF3uUlYoKJiSCrqNJajQYCXqsAQi+CBhyXRCGEZohRKiUAfRZKELARc4pSxlW0sRAYpc1M0cfhOcVVFcJx6BiU5wIhO8VMUtjkENd8DDHvVQBznAYQ5vlOMd7sgFHg7hPTRYIQxZJAz3tLe9OGQJoaNp2JrMWDGLYYYLcIoTaVwzsoiSxqLKy2gdcZMblempDGLoI2H65IU2EEqQdtBDIQsppUIKYhCJQASjJGE+UJhEmK+YhS4wyYxMzQ8a4BmGKhYxiDxIQTlXoIMmNoIMZtgCqq78lyyCgYsDQTCCwAKF2lRiwQfF/6RUcrDCTtCAhjNgwQxhYGYzTXhCt6awhTfw2zWXAoISgQCvIhjBCFYAQw+IYJvbwiE4M6ABDRA2A5h4BCQyoYlRzIIZ2XDHO+Ahj3v04x/0WIc52iGOeLjDGpSYQ/fSqlbWEaaL3IMdYrTEsTUgBk5ZQOPEemcZi44sDXGqYxZiq9GL5rY1dcwdGUCqpzHw0aQwK45J3eCklK70pSxtaaLssAecic8Sm+DZKHJqSfc5gxlykcam2EIMVRyiDlRYAhwWQYojHkMYspDFLW6hCgXS4hdWfWAEsxoKUDyuZ13lZbFeYh1lOUIOZtDQHcp6htIClJnPPKEJU2ghub4wW/8zzOZeR5ACFyDFBSFWyrYMe1jFldjE31yEAmWRjGzAo7LykIc97HEPG98jH+1YxzryKQwwlMEMdnAmGKgAs7KioYtd9Bic/qQl3UbhobxLYxSorNssbNQ1VP7SyOgYhStb1Da+HW5x9cRH4QgqZsltLiCk9Fw2CyYPgMGDGc4Qhz0gIhHiA1slPjEKVVDSksh4H1qokY1sXAM80UBGLEbBhzkcURW2YEYubCHfVniCEqvohS/0+wpdSoiXm+BEz9aGkmEVC4PBRAUoFiGHsyLBnw4urRnS6swSPrPCFoKBtZICQ21xC7Ae4AAH/trhD18TRR2ICopRDE5JW6MbMKb/Rz/K0Q529KMfN7YxO+iBDnd0YxRgGEMcak2FKrRBi2jgk+vaEAfXCcYzGyMNRkUW5dlehspRCG6X8x2FJlA5eQB/smvIWCfhdhRPsQIpSdcNs8MYKot6SCkg9oAHPOwhYWeQg3VxhoetUYLP1olF0IJxKbVcIxvWSDk10OIMXBxRvrkQRi5ycQtbqKISpnDFpnExC6xGiBRbFfWwKuhVCJliE4ywQ1mdEGta0xqtTxirMY3pA4EIxFrWmus18TpDwAYW2GCfmlNUxewSF1YDMIaxXTD7j3/sYx/toAc90gH3fKDjHN1ghqPpUAY5AKa5hFpDGwY/+DQQnvAJzS1o/0BG3NSs4d5iinIaK8OEKEhZjV7WTcmONwYtqOwKw0lmxp9e59fR+aypx8IZ2s1u2dXh74V0Uh7YTHtAwNQ5g9C9c2bKCEc0ShOP4+7PXCG0YLyvaN75TqKfgYxbuJIVsrDF8wH02GAE45axaFdWR0EKIYqCE6luySnIf4pknYIUp0i6HvKABi9UKQ5nTZgTtsCbJ2jomDsRgg1oQAOjiAhb6qrruIVbpGIDCBBFmqIDyu7EvsnE1EEd4oEe6mHu2gHbsG3u4iEdbEwe3kEaooEV5mAO+o4w7OA08oBQWAuhVpBj2CTe1ACk1IALzijyKG/KLu8yCM5kdOPzoMd5rv8gChCO1uKPzmBH1s4ACZOQ9dzN3WRHDhBlDwIJEADBSaZw965w92ZqphrFUTYhmFahFYLGF0rOpwjtaAhNfpIhF+QLql4h+mihF/Rr+6yDJUCBEyKHE4CFFIDFFMiPJfqQ/CSE/DKhEABBkNBAMF7HCxImCYqjNzREb/SmB3rABviPBmrgVGZgRE5gIQRHwwoQAQuw2czOsNpBx3aMHbjtHuwhHs7hHV4RxtzBHaSB0g6CDk4D3aRkBbNkeBTPBT1mMUCKDMpod3DQjPoNGSsj35TRjnLHTrRADPIoGnHjCZ4AN1BP1kZPGzOuDdCgG7vRDQgmkPRgCstxEAiBELD/UPdmSvfyTBIcyRIyoWdM4c+ChoF+wamKJhqkgR/jZxqoARqaQSCZARmGQRd0AZdWQRUk5BM2IfjukJdAQSKBRau0ChS6zxRALRIK4Q/YDA0EaWbcL2EcEQogkQg4RAgokf8w0YV6bSFOoOs+MRS3ZQNq0uzKDsXMQSd3jBzC4RvQAR7OYbK6QRoE8hiaQRh0wRR+4AfCEVAMoxd5MaEWag1q50yEMQ3QqN8ojwm60vLy7Qgqz/KkAOCc8RmjEXrEIJlwA61oTa3C4Aq2cfSGYziOrKxg5g4MpRwBQR0HoRD+kh2dIxFApZEapRKow89agRV0iqeOwafwBRr6MX6w/2EapqEoj4EXbAEhta9dTKH7PiH4tuoOJZI0S5M0GeQTJOEvPTKl5EAksaBlSnJDiCAlKZEGdsDCMAwpTuAEBDDYZnImaxInN6ADmO0U1yEdyEGKhJIbpqEZMtMWjuEYlGEZlmERZoAHDOPIEi8xUnB4FCpLGMMqT4MxYhDyLIPKyDLfvJI9kTEspYAJjuDykJF5ZKOjPk8MOmotEa6jrHEbRS9h6NJgTC977CAPWAr3dC9BeS8wYwpU8GwRQC7k6HExZ+EWfGE6mQEyIzMypSEg4avmdOEWZqEVFNIzWeJxuEpYTFMiG/ITSpMUUpMjBUniEvE1W2YLkgASTVIIdv+A/3CzhXQzKXizKbRJ7IBT2aLCJmuyOFEMdNIBHcJhHMaBG7hBGo6B5njhF4YBLmIBIWpAO++yFwklKhEKjNiAPGFQT2SwGNnzCN70TZFxPSvjTS3vCJrg34IwN+zzPp2nGvkzLtfyCbryCsygUFcPUVUvueosdgADIi5OEA5BUvmADxSFQbMwMKEjIxrpMDeiOv5svm5BGJRBQzWJQ6GBGYqBF2xuRGWhXSSIJXipz9KGgigIwBzSEiyhEipBEhihEAWjNbvxrPokR3UUQ1DSR2mAB1joWoS0NwPn67YpWrelA6rVWq+1WlHMFYNyGyiTH5shGZKBGcaVGRLNOmf/QAdOIEwJw7V80UyB8TNSYzI8jxjJMj6PwCvhtE7lNAos717xFV/xVGBxQ2CbAOHe0gz+EwuqcVDVqgrCYAzgIGLLIA7KAA7K4AwsFg7gIA44lg4+lg4sjlIp9RD4QBAiVVJnCqZm6hAGAQ/oIA5CllLBRhLAhhI84VNbQfpyYRiSAV/ix0OZATNb1VUXchQkEvxeVG1wFjQ1wWnJB1QogRIwwuIU4fcYgREGYekM8ZAIw6wCpTiSQGydwFh7okeVdYUAEFs6MXBAIFqn1QOwVW6JM1u7gRsAMhmkU2996i3UYhl6wRVwAFVCIA7s0htnZxdb6zv/JGI0JjLIwPPS/0AZ/7Vf/xVf2dNN9RVgMbdgm4AJ8JQa3zIMGPYJkilvcEKtiAwMpFFlotF1xWBjYxcOQNbiRHZkR/ZkUxYRBkG69iB2RxA6DkFm98wT6LEVZoFnj3KTPlREfa4zQdMSLsER7uxpdxVqQYVq92Ii9uMiItQREIEQDJEcKe6Qls4b+wQLxtZYUTIHcFOF1NYln7VE3jZanUJurZVJszUamGEYhqEYkoE7vkMukGEXamHkLOFjVccMjPB1ykA0VvBP2lWMuiR4rNK4rqBeo6BOvXIZ4TM+vzI+4XODLy8NJmMyDNaEb6OjlsAMSoiZiOAJsq4GeKAGckAHMnEGWmgGdv94h08lBE4Ah3s4rloIBwZiIMQgDkboLZcgDNpKhaLphm9AB6iACqKphX7gBnAADro35KLvFngBjFfVfjyhEmhlEQ4iA4rpATKACugAI2yFfDZCljxTFV5JZ9eHFlChEhyBEQDBe7i2YO6SLovDbpBACA5ZCH6CWV9ornhTfo1UBCAZsEDgfq9VOA2rf01OLb6DLWgkFlBhE7grFQ5hD8IgDpZA4+KPe8qgDtQgcZsMguGV8dSUXicXTu0VTjFXlze4K73Mc5vgTo5HNkAXoEYorZAACzxEmX3gmZzJJph5CajAmaBYB5YAiqGpmqmYKZmSCqCkhBDCB3JgISriBEL/wFoPy1oLS3Gs1ZxDYAbAQCMSkw1lQRXoBXsXoc9CwXQoIWz8zECEZPp0wRfCmBeEQRh8QaB9wRdowRQo4Xv1gMEGgXyr5C5jhpChxZB7dAeW9X2bdevoKoZI4DefgpIruVqFcwPyES3AwxmcARhgYRWCiBMmQZI4wQ4WEQusoM4cLGbjoJXbNUtgWUvStE0kYwdnUBn3tXJ7WYMB9ggOWXPvtSsN9goKtqqpGoURNpnaIC7JLfbsAAvuwAvc7/3O4AnM4AmWwAis4KyJwApCiIZ5AAlqgJnf0giqOYpvYCEOK8Uy4AEg4AECO7AZgAEGGwEQoLA7QHDh2RNU4RVs/wGMhWFVbyEXdIEXhkGyh0FLceQXOntLMRtLc6GgJTuMac60ay4WNuH3EGEPIHoKDUl7Klr0xpZsTTIoqEVtPxqkY0ha49akLXkDMsUZiKEXXjoVSgH8OmESGuEUOKENzgwJzpoIYcen5W2hvpNNPoaCjZpOdAc9qYyp1ZMJ0LMr45SDAY4J+BN07wg3zkCtZMdgsIB7/qKQ6sCstoD1ykpaqtFDdIAHrC4HYIATeXgGUqAidpg3zbkDKsKc/ToDFnwGeFM9wGAO8KAjQG5eEnMWaOEgfQEfkQEZjiFvj6EYjgEZikEY4KsYVtygVdWgCxrFR9ugZ9wYarzGfXYgcf/hExyatVFnCr0Hke6ApBZRbHVUbJH1Q/gm6zzaJUOaKSb5t7F1A6Lhb0dCQVIhFUQhFU4BE7r8ETqhEd7AC/IACqI7DJBwgVVZZBRq3lqwNPQEMFZDT0rmS7jSGPv1PfENhHv5c7WACoxgCZ6niqtZrQndim9gCT43Pu96IBACSnRAE+XqVG6AwSuiOKs1BPj6BFClAxQnBHCAKSncwg8zFCIEFSgpaBoIR3IEGZSBOp1hGVxd1lt9GPRWXJkhXPPWGI7BGITBxg3axm9cxDc0MqehGrRhG8bhHPDuHGCMsrpBxx2ad32c4grJe+7gKcGWJKHgCMxWCDwEKIZiiIP/uMlDmsOaQsHvV8FrshZcQRQkkhMmxxVSocsN4RHu3f2SoBrDIK3QnPUSpgVbcKFSw1FbWU05T3eM0QYpr1/Xc9F5YNIB/a6l+IZ5eNN52G+K88HXucEVJ7Ah4Js6IIf3Aw5MJ0LjxV0oiUCuT9Cqs6UxpaWfAVP61i3IlW/JVSBz3hjCddgFEscFUpM89B+xwW67QRZlcXQoa8Zs7AKbPttW0R66wRZYyRFaFqIlmqWuPQ8Kg1h7g9s75NuTnCWHmIf/ptfMfa9IoJwr3aQ3APw24RRK4RI4ARNKgd7/4A/qHhMYoazuwAzkYAl+wAgT9noCHjxbkDEKnszKQF7J/2DhG4q8LbdHNfoIKv4ErDXBs9Ww1BmcQL4DpLjkV8x0drV4/wzVcaEXrq9GlKHlq9P1q3Ncn8GnYr/mZV9DnyEgc99Udz/o46casOH3kV3ZKUvtZMz4j5/GakzbtO0C98Htnt/tsM3GuEEWqJ6UI7rar/0jzbfrewNOOwTcp2ncd1hIA4fD9ErtKz3d79d85j7e6b0TOgESIIEQjlsPCMEKxEqsmph75O96SgMg0qjhgoVLGy5euKRZuIYNmzhlytSpU2aMxTERy6hRk4aLFC5dPHrMIiVLkyNGdjBZmbKGSxgwTpzoIPNEiAwZOoQIcWKGzRM4dPwAgwfPIkqUNv+RQrVqVaxawHoRmzoVmbNly5xdxcoVqzJlzJh9BYtMbDJmzZoxS9YsGdu0cKFJkzaNGjZs27idO/dOnt+/9gLbu5fvnuHD9/olTtyvseN+/yJLnkz5377LlyX3s5etFVJHiAbd0TNoEKA9e/TcGW2nTRsvW2LHhgLlyBEiuInw2J2jRu/eN2DMgAnDRYrjJJKTOD6ChIjkP3nunN6huvVSpVJ1KuUqFaZUsLxnF4WpRw4aOdKjP0+jxg4eOuLrgM/DB3z3LnfscA/jhv//Ph2XwgwE1lRTCNXhpGAGEOAEgQUWKDhdTziAQcchiiziySimqNJKLCDOQgsuuvjSSzD/KKY4VYrB/DLMi7/E+IsvvggjTC444siLjTvaKIwxQBrjVlxy0VUNNtps481e77wDz5Pw2FPPlPTQU889VeajZT5V9rNPP1xmCdmYlZVp5j6S7YNPZJfh04480qhCiSOgEfLHnabpoaceaOThhmuw0RYFFCvdJsShuAnx3g457EDDozQQB8MKKaBwHAokoICpciB0GgIINYFgnXUbbODBKdlppx0mnWxXSieYTNKIDenV2qijLtWgAw44/HeDDj6kN8MNBBJXA7EEJqtssjIl+x+vPwxFBx98ZIjUJ6OgosoqrbwS4oi7nMjijL7IOCMvO9JII7o79oiuj+/6aCOQ/0M2A41c09R1ZDZ57cUXOvDIo048VVppTz9V1iNYYPTgk0879EDs8MT5TDzZlmZahllmGbP5pceW+eMmPNCoYgkjjhBipx93AgLInnb4CegWg0YxaKGJJqrfzpBGCpMLLqiggoCWCqjc0Zx2qnQHHnjQQSqppqJdq6xup50eSPgg3w9U+OC1fLv26uvYAA7Lq1BUgFEGHXhUe1QlmnjSoSqsdCsiLSPqorcvwfgSrrq+DFNiiTGyqzcvNfKY4+I6+hikkG/ZO5eRSY5zjuXnQClPPAQXXA+X7eAjuuj7tLNlxO20c9ljjWlpj5X02FPYZvnILnvFo4++8e67dxwZPv8f/wN8ZCK3804zplDCCCMq/+FHIX+47LKebvz5GmxR0EwoE7cRIYTOOzsKKXE0uLACpZcSjfT6yXVKgqjVdSJ1q/RTjUl4j6ARRhhwwAEGGP2LlgDT9j84sK1th1jE2zQRimx5qFuxwFstcBGuXljQgigaRoxoFCNdsCsX8eJRj4ohr2KQ0EfFeBzk3lKkaVTjSEnSy+X8hQ50xEMdOFQHOtIxsHiw44fzCOI8UkfE1OXuiKHLx5cwozvW0c52inni7JS4uyPqjneRyUfGVucxNAmPHudIxijm5IhC2OkP0JPey/RQPde8JjbYKxSikAA+/fSMfEBDX6Uqtan1yYT/ffADgfy8g4mqFbJV3cHEHfZwCEcghRKV8EQoSGEKprgCRLSoRS0qCAxgqIgqyGBRBjX4olK+qEY0QqG8HPejILmlXvcy0pG2QUvLwYNzUprSlAgmJcQQRnb0WAc7qsS5gtEjH0Kch8Mis45mriN1ylTm6IwYRILV45inK4xhDvYPMnmzm+C8oppGt6VykhN3F8OYxiCzTjDNIx3cKMYnLEEn5t2pZWt8wxtkNrMtYI9QhjoCEuioqPCNDyblM5+ALtXHoxkoae+DX9VaNTVWFdIVnXiEKzrZyal05aMf1UpXkDEWkiIDGcdI6THckkJjqDSlLl1p5GIpDbtkg19M/3qSXwL2F78MhjGP4R3HOoaZbgbVMrg7p2VEV6UglhN3W3Ii67aZRS1msWNWvapmwGmZrnoxqclspjnWIcR1aOmd5AhHNm7hiUlIwhGMgN4916iHN/SJn2/0wj8BKtCBes+gjyJfQheqPqTV5GjuiygIAmEIxlKtsY94xBcmG4hUAEOkWVFGV8IC0o+CJSxogUta7hXLfFHDGjfNRjfyope+9FQeC1uYL2crVS95sYtF3WJmFANU1i3RS5NZXVA35rvINGappBsn70TXunw015jX9KE4pktdclj3uuHIbjisO13uioOY5PhGOLBhC09YQhLLk2vL9JQHu/rJeoB6o//N+OrXQ+nHBvi1Qc8eBTQYCAgml3LoYSHaPhB8wRCYCEQgvhBZTPThCwue7Bs2upVllOWza0nGWDQ7lmU8wxrWuMY1VNsNd7jDSVAKWIpTDJjAGOYxXa2tVI0bxd5yNU23PRONHfPbHgP3tmjqcVc1JtTcEhl4TGSim1KXDnRc18nY1W44vBEOcHwDHOCQcnave91ylGMdOExHOu5Rjxtm1xqyaCtc43rP6OWzT/B1o3wHZZu+/lU/PcivfvfrAkn5l4+aQsFDSfDH9xFaOQjO6BcwYQhYGYLBk/3CG/TAiFPAYhfLOO1cqFENachFGGIJdVg+nA0Tn/hJ/tpLDdP/YQ+fwmMc2oi1rG1Ij8OwzrnpVKdmtnmPn/Y6ijA2qoyDF1zhKdGrSUVyUYNc5GZjBkzGpAc7xJwOLlt7y9bmspi93OS0ijnM5FAHPTo3bs7FIzCwTQc8qJHmSdTzjIUoxPTau88461W+ACUCFOq7sx7kec896y9hLbUpQQ8YOoM28CM6kWhDPGIKB37Eg78whR6ggdKK8IWpT3yOvHQjGicNC4abYY0So1geUL5uOsqRutqpA9baqEasvUGOc4PpuGQq7mR422vB1Na4WmrdjMXZJmUX2UxQrVg75jFWljezHNVOq3W1PGXtWrsc5MC61rNODifvUB1ZXzW11cFD/84NbHPFfK08njSObUSjFZp46/Lg7WY96TMPeH3NG7XHvb4SVFH+zu9+y0ccomlKOYMu9MEZ+4hGd+LBEJ/sECLtcCXoQRG/MDE3uIHycbzDHd3IxjNI+pWwGKMZ1Dixk+xxXeqawxzJZYc3ZK0Nb4wjHfRgJ5uGXM5/PFVL5CyysnWncxw7W6hMrVK20+qNb1y5ytje7najrOWuixnKXs7+OsyRDu5zn9pgvuENdYiOHAIMHug4BzrGMY5veGMbsh4HN+BfjWkwQxVxXzPdpVfXestZ73vFPVDgBPVlXzugZ3fkZwxVcAZyAoTmgA9YaH3QWA9WSJEGeQ9mCITgB/9TQAiLsAzd0A3GAA3nAHbw0A3W4GEW9hXIkAxA0gyl5iRg512vZw6hcxnpMHuyRnMNQ2RYVFxb4iZWNISiU1W6Vhn7UDEVE0TO9HReNl1Y5nzOB31ZhmVplV1V6HzUt2VVyHVat0PoUA5h2A5N6Ezs0Ewr52VXOGU6SHsx90JweBdxuHn0Nw3KwAqacF5wJVdpND361Eb/h28ABQVJwG87oCgImIAA9mcMRVgNeAIC8kd9MImTyCoH1gcL1geSFQhvMART4AeaYA0n5kLotyTZoAy78AsURAwnhQwt1Qza8A42ZF0rV4NGpCbk0Ia1h3vMNk7J1TG+tTG5U3TTJIz/o9OENbgOaigO4SWFUsiF1CUOWDZd2ScO5YBl4KCM5TBW5uBlzpR9XnaGTdh97NAO5diEVuaMzucNugiH7viO8PhCd3EXsTZ/2VB/04AMpmBecmdGaORm06MHeFc9gLh380UbtGEoioKIgqeI5mM+5yM0Q7NQBkJYKeCAjBUIkvUFDxZhk/dwEDYEnrgJ0eAO8KBquXgO2TAMrfAJi4AKwVAVw9BS0LANTgJltXiL+0APU0Z73rAOwzeMQ1UmzuUYVDRORFSGUCcO4cCMVpZl6uh+7KiOU0l1VYaNWGmN4LiNYyVWRUSGaAh+aehlVsaO7OiGsuaOsRaPbBmP84gN//KIDfaIj8RgCptwXpEQVyoTb6YRkHj3XvAFG7FxkLUhUDkjBP8GcIH1M3kUkUJjkZAZiRYYCJHHkRMXeX3wAi0wBEogCJkHDyY2Q+fwcavgSJWkClMxDMKQQskgDXqBk890gzj4DTuoDeGQXGqSW714W8CXO0G0fFsYDlHpfuL1DeQQjeAgjdTIbdmHleCwjdvGbdSWDk04beVgjem4jmaJlmupli8Ua28ph0cCl+9Inu7oQnDIafWnnnGJDTeFDdMwF79gl3ipl4TAl/wnkIApZ4JJM4TZPblRUPi1XzCQUEADkSvwmJEZmV8ABC9QmV+gHYEwiUPwYCNgAjKgBP+OoArKcFMhWGLXEA3OUAqW0Eii4AirQAwxMgwr1QzSoGo7RJ3JlQ85OHPsiA7AN5Srgw9lZQ7MyIxryIZWWX1TR6TCeWVbmX3TyQ45xENNen1Shw5SqYtp2ZbwSHsyx530CJ5wGZ5yaJ7uyGnUgJ5jSg1laqanlQ3XYA3U4Gm7QJ+TMAnpdZ+F0JeA4Ad7MpD2JhuykZA5gxsGVaABBzQGej4pwIgLulBT8AIVOnGLZgiTCAQQJ5IKNgWBIAqugAvOYA3REGLL0Au1UAqGAAmT4BSg4ApYgQzPwAxygQ3/kg62FWSNQSVV4jBB1zrGNG3TSW3W5XVPRg7UGaxQJ2b/P1SsxRptxISsBWNu5pdywtl82rmdbsiOtFSttGR7tsd+7LcN2qqttscN2jp/ebGt7Ciu7CeueZENm2ePqcWuqTViasqm0TCv0QANq4oMxDALdnkJkxAJjWCfZzQ9dkA9BPl/sJEEs1EoCnlnuVIDfKaAiXqRkTl5kwWpk1qhXyADjScDFAhh8oMKy2ANxPCprlCyj6CRnOAKsCAKqEALwIAVaIEv3AAP5MAOucUlN7Rt0al1TfZtTkqd6rAO3wZ21PZ18TCs4Ce0OYRDnKNL41ZuZocO4TAOZ+mGcfiW4Jm1smat3ElLSXKt3OANYRu28geu5ypD57Cu65oXrDV//2q7eal1U2sKYtYQn/UKDW3hgiTEC7lwC7ZgC7fgt7YwC7PQkptwCZbgr3FlRgFLV3piB3H2RkkwuUlAGyvBPULAA97DA/qRKweoiH4GYBG7UIYwBSI5gVMgqV9wuqkQCCLpiZWYHbGwC+HSSaLACYEAK5xwCvSUCpawClwBDfXaDNMwDsC6VL73TilHndqopNSWpGPJvMWqDuzArM1aQ9jrL1T7ftXanVb6vfA4j+44j1vrtbFmrdaatmpLS2+7rt3ADeoat/HKqXe7qspwDHubI4L7t/zbv38buIMrC7LACqNwuJYgK4urMnYSkHhKPYHoBVhAuQiZb4eSuTuTH/97FroaLLoR67oUF1lTIFlDIHFT0AdTAHEnbAgO9x0lC6rAAAutkrudAAnLcwmcgAiiMLLO8AzQMA1pUQ3hAJRq8g/zAKxXSA7PeZ3JiWXgGKNfZqzVa24522RSyn7vlyRcKp5WqsXgi6Zm2pZf6qVinA3hKb9mnA0g1qbScLdqkQwpdUJ867/+S7h0TLhzLCKzALi2gDez8AqqAAqcgLgInMALvEYNLJDWA4gRPLkHyT3es7mc27kHqF+S4jOScqgcfByIKiCPtrqSJ1mWKpJKoASNdcKN9wiskh2usAqEZAhvgMoTVguT8B2ioAmtsAzzOjnV8A03KDo+mn3AOp3/YZhWMYq9zEe12mq+3gvGYny1bfnF3yuep3Uk49ml1Nylb0nGIIYNaZwvcxGfnoa3a3EMQJK/gbu//HvOfjsLsnA3fEzHfEwLeIw3gYs39nzPsxALqzAKgXzA/0rI0bMnh6yngOgFlMt3jkwEhrIb4QNwG/xnhfdfEJsCGDsEC4bCJxwISmDKk1XCCMYqvssJk8CJH9l4nQAMqTAFnQALe6ADYKAKJecOlxMOuDc6wQSl0qddVStr5ulC+YKe+cKW6BmP0FwNYqqeZ0q31hCe1fyWcWnUSh3VbMqmZgrOc0Fa0PBK5HxCjIMjgIvO/7u/dDy4hCvAAgwiaJ3Wao3W/4QbC3czC7jAx7HQHYAsyP9cCHpZd3rgB4esn+/1GovMd7YRoAzd0OLz0IitwRRNsabboBPncEMABEoweZMnP/JTC4yABEXQiUDQaI0QHm/AiZzoBFaAB4pgC6qVWkgCnpPT2q792uDszT991D9dF2haFz/9QqZV1bU9prY927c92/Vn1Ggq1bxtt2uMt3CRYa8EJMLAt13dt4GLI+r81f0rwH9b1nRs1q/wCrLQ3Wfd3eIdC98t3q8AQWttzyCyynXtz+mV1ww80H4ykG2ABhCMBYJtKN5jwZLMM4n935LiyRO4YJXVWAmWu33giSGsHY33BkUwBUVA2Y2GyhQIqf89gAWb4Aq0QAzM8Ayv9BaRI1qihdUkTlP4Utu77cW+DdxnuuIoLtsoTheb5ttXjdVt7MblDC89spoppFLGYELPDd3RvTi3IN3VLcdlbdblLd6t0ORO7uTd/eRQbt7dndav4AqooAn9PMhzCpB64DzsBZjWc98IezOOLASDvbn7AViCupgAHromPHkq/GCNN4Ej/HiS9tGP9mi5G1mQerKNxWCQ6sqNoOG7UBag9QyjVeKMTlOv3do/XVOnpeKnJdVL/a5qisbuyc23LeM2nrdvDMcf9EEgFEI2UgwppWEZhr86zi68oDel7uqvjji+oDfnDOvTDcD8C8/vzM4CvN3/St7WbO3O+YzloGDA/frezEMIAbnXDfxebOQaaBDBWBAoCpsb+x3JdkSgb/7QFFexChZpnjxZffAHljqhkQZxcz4FkJq7HDkFMsCZUzAJrlALv6Cqz/BZRGKvz9Dvwnu3/06vAi/wAT+vlH7wB7/GAJ8Wq57jPpIj6KIjrs44Ee/qq2RCK/UVbmxCQN4uNkIuso4uhyPyelPytq7OfovPhCvP2w3sv37Wab3ycv0KqLAJyH7Xc8fs0uM8z/6XbjTtWIDf+a3QChk+PMPt3e5njP3tkTbCsFC6FMcIj+Dgb0BxjqrggeAHmDBZQOCgnIipszuyoBVacaHoIs7oAD/w/2qv9li9qmKhDCh1DKYkQiIU8iKEIyZP67V+OL6ALn1v6iiE8WPxxi8CLzKyLiFv8iWvzrqAC7dAC/Uc1ytfx3Xczpav5Eoe8xHE8rFA8zZv18rePDsP5nuCyNJ+39kzXwmdKNpu9IOX9EoPBCJ5wic8eZXVCQ3KmZ3ACVPwB1U/WRkawp1gqYGe4CZwYI2wCrBQCzHpYWMPWstN9s3Q79Rf/dFQ/f3ODMtQUieFv6XkIxukLoQzI+TPQYDj93xv8r+AOIbDLjXyC8IA/6bO8aiuUqB1vyb0IsWgmuH/9yHPCwDxy5cvXrp03bplENctWg0dzoIIMVbEWbIsXrT46v+VrFgWY30ESTFWK1SbNl2yNKkRI5aMChEi9OcPIEAy/fjRkzOPnjxt2qDxgiVJlC1RokBhcuQIEaZChPDgsUPqVBpVrdKAkVXr1hpda2zNOmXIF7FDhgBBq+TRFyBTvnTC9OZNqi9DypJ99OiNobx9/PYxFCiSq1i0dv1CtgyZsmTHkjFjpkzZMsmVLSPDjHnY5mG/OgvcZVAhLtGldfkKvWugr1+/grluPbB17NWzabP+xUv3btuthwnjJUy4sGPFi2NWBvkYs8aOjSM7tll471/CCfJabRqXQ+4PI4IEr1G8xo8ewU+UOLIkJ5QqW76EWWimnps3AfF0g/9n0CT/W4oiTWoppohwCqqpdvAqwa/A4ipBsHrowywgzJrCkCmmwKQPIDDJq5NHMMGErLq+IDGQVFKBKxBD4HqkE0NKqYUWXFxLjBjohikGM2KC4fE12XbLJUhcFiKSNF2GRDJJJUVDTZfUnNwlStVWo7K22ATCkjotfRuumGMWU+aY5JJ7hhniHoNMsjRv3Myz2ayTzReDECJtOxnt5E6kj8bjU7xYxgNvFlpm+bOVUzZhL6VI3oNPpvtuou++PNzIY9KfgMLCv6OYSIoIpZZ66kCpFHSQQRhIBauIQN4oAhNDUomrCFYv/BCIPgJ5RAkKX6hriECASWWKN74wxBBMYOmk/xFQaokyGMyWCYazNn+RskpcpMRWySHvRJJObbtF6BYkRxsSIV1y0YWXINdV99yCsIOXNdx8a/M34sQcc7HImClzOWaaSTM5ZjA7phjpOpNNIF94HEbO0pTsLiLz/nxlzz379DMkQv9c5VD2Lplk0ZYYgWkmmv7AyQ9J3aDUjUuD8uIoKJA6QohPCYxKVFITpGFBrXbeSoY3pvDwEWSV6OONQM7q45GlSYT6LLu+uPWNP/Zy+ou83rjDFWCIIUaxZer9rLVqHZbyW7W1ZcihcBGy5W25575lXbtzaTfehG2TljMv8VUGzOQWeyYaaqJpJpnHwoSuOIN/K3s2XxAWTf9ciBuyU2KOLuaoYvFk0Qj0zTuCSJaKQO+Yk48tEbmQlV6iiaZBaNKD9kot3U/TmY8iggelmjLQKVERVLCqrrLa2WcYzBrCr0AC6bWPTihUMcSxIpSBahIpfCuu5gPRdQg9UllmGWeceSazwMFGpkfaWuulFylBi3Kgs+2vH8ooDQpNtCmrBOBA9FYdAgIHN7L5TGf61iUceUkYBktGMR5jDWpA44HFEM7dcoGQDdrCgx/84OksQhGMgG48oGtFClW4Qha2cDzrskgr2JOokL2uUbGjyR4AsYc82MGHPvRJG4JyBaPMDCkEggKoCrQDIYjqKlVp0KmS57MhyAAI2mv/WvaqCIRHaOgLSyvLEELktCJcSAZTcAUs3kCItUhNfF5zhvl0BDYb7eg1kmuNj6b0v9XUr49S4h+2+se/AMqrkFZqjXX41re+FeNxjnTkMHghQS89wxrZmIYxjjEc4exGXXirW5DClQsQYkSEfWphClmxSla2khUbsYgt8HamZlSjGtighjWWgYpLcOIkNXSJS2JiMkAIYg/H3MMPgegTLGCBiDLjlFI6JQScMdGJT8QK8r4yRa/A4AVWrAuGOvGCsdhFLBaaEInaYggSTaEIVxyCIVyRF1fwpQ9scecZRAEM8/GIjnTsEY+w5D78HYZK8osftuS3P/3xMYC98aRu/zrpyeEEZziMXGCXIuklDBYnGtkAKTQUt0ljcBI4wfGk3UAYLg+W0CKuhGksZSkMYySjGc2AhjSooY1tcMOn53iHPOxhD3m8oxvMUEUlfAmySLxOmMOUHTKPWYc6LLMNzcSCUTYVoN8Bb3g7wCYUpcjNBJHTLF84kViIBYTsbS9qzCNWEQJDIsBM4RGB+RDUvvAHLEyiF8uwYzD+GdDXxO+OZpvfQOKH0MUuFlunCSBkqcQL21DUpJe1KEYf18BjEANHxsGgI5eDDMjc4hjReEaZlPE3x4UWs5+82wc1SNOa3hQaOZ3GNG6ZDW50gxvnOIc7gAvccIAjHOEYBzrIQf+OfvTDHu/IhjE8QYmTKMqpjTLZIIx5TDtQ9YfMbKbuuCog4DXxmmEdK1m7QiG3YGJpzJPBENrYCVe8wWmPmIL0LMQhvUBvLFTD1YfsEghM6AERrujFjnYhWLAR1rCu8RFq7ueLhQrSwtUyTYaxs5oN7y2RJqWX3z4Lyc1uhsQcLZMqPHELWQzqFYvxrOMK5khjlFQ4Ncax4myL22poQxveOAc8hDxkIctDHvAwsjzisWR1oMPJ6VBHlNWRjnI4GR5RTkdz7QEPbhhjFNRtTyOuGx+TCcLMxqzqd8F7BS/8J0DTdMpThHdebCZvVAqSEIW6GF/mmQUTy6hFD6BnIar/CctFhvDDGyZkIWMR+BFDeEEf4vIGO3CiFsQABoMDyyPDClRhElaNHxt64dA4LMOigZcnAUiby2p2xJCUFiRBe4z0CUMZz3AGMRaii88qzqY3vak0pKFbbGwjuEVOslDv0VxmN/cez4Z2tKUN7XxUu9r4gDI6gMsNb3gDHeHQBjamIYxRLKK6wHwPIeRDkzOjWZlBbOYVxCtNJUKFB3E+UFitMhUF6awraJEBYIbgIeYJ/FfOCNawvuAqEsmlFK7QwxvO6t4QWciK+f2CEpTghEvAAhiZFuwdCQs/Uj/21CdHeboiumHqeFg4rj4xJDV5jBoXp6aKK4YmI3MMXhwD/7fa4MY4xkEOdMQj2UkeatKHOu1pK93pSV+ykM8hdKFvw+rY8HG4sYH1c3CDgs/AhSkssVTWrSTd6wbE7GjSw3dfNd7iDdCACnTvOUtF38bjd1eGp/cJTW1qU2CrsagGi1LoIb9NcxGJimC0VCitLpgAxloIPAUZnBHjQDhDDg78cfddqRcCiV9DQQ1I2B7JcicfkmnwtnLdLPKywsEg7HOOYxwb59c4xS2xQWoNadxWp9wQsj3osexm9+MeSo828qH99CMfGR7Apfpwp+5T6lef+lYHafa7kQ1rPGMXrBjFJkCRqKaO7CVon10e1m6HNiwTq2z+D82YIqCnRKXuYP/dN1X0vvcD1UAqeWaeCZmQC3GLIegB7+GLIOgDsWiVU8gLQxiLFqEVuFArEmGnvdIDRvAaxUAGG9GROWowOpKRPKEFWQAhWxCUhkhBWrAcJYEbDtKgu1EXiZIo2qqx28upYauGnjqHcCAHKIsHeqgHabOHJTO6pWuufVBCJXS243u6oTKyIdM2oJK+rvutbbM+n7I6n+Itbsi+7NsGH8MGayBDMowGZLiFV1gFUlCdTUiJ11G3ksGhOWQ7ZZKDMzADeXOzN5umnBmeqrizKfqq/QM8CrmnAowvt5gQVQmjLwgCASyjVzm0L1KCIviCvbgnsmieTDSENYKFsGGwYcj/jPbZtNfgFoaIGxSkiFV8CFWUKQ+aG3YZjhzbMR30sW0QunNwMqOTh3qwB19ctiX8h2EkRiZsrnyoh3rIB3poh2Zch2dMh+UKh3Mgh+OyRuQaB2/Iwiv8rW3Mwm7wLZDyKXD8QjDchmwYw8N5BmXwBVlohTXkBFCorvIrhHqEiTmMnUpRJvaLAzwMg6LYKnoDFT/8w/5LkK8yyP/zlV75O02kkLO4IkMIAow7C7eoEIwTizWSi05YOAgkkay5FT2YBFT4ODvakV/QtfoJBtQIhnJBkrgZlIgYlBLsExM8QVmapRvEKR3EOmMDqnd4ByKTByFktiU0SqPMh6GqByOM/wd4cLJqzMZt8Aah67aq7Dar20KptEpv2EJuwL7suz6s7Ckt/EpxLMezzIZrSMtrIEN1bJhZeAWSIIVMGD+UKD+WuCE61Ec76CE5iIO/NIMw0CoA+ZR6I0iqoAF/27/+Q8h2CqP4IhaxKEB4+hAWiCfAmJVAWMC6WBEO0ZoM6SJNdMQSCQQ9uIRViIVMkx/3ubBxYZKbjBtZzDkd20li66luAC53cId30EV4aEp1QDIp48WhjAd2SId1OM5nFAdxAIflZE5spLqpnEqqGwes5DZuk0qr40qsvMVuyzox1LqtE0+sw7rvHM+tQ8e0LEMKoob2jAZoeAaAWYwb4YVbsP+FFoPLVnCFjgGFuiw7vMQuHNpLH+pLv4yDwARImiEv4Lk3hNw7r3DQ/tMryYSaFvGVTnALqvGLDB0aVrEnEsEEFmGnCxSRW9GedjKRXkqFWgCGWnAsheoFwxAgidJJ2xo2rPutoIxCoXI6pINCoVKyJvu24/oGbwgHq7S6rNvKrRRLbdTGoBsHKM1CsaTSMAzDrEvScDtHkMIGkFJLdGTPaRg2YYOGm1KcG8kN+7wI8UilFaqYP9lPVBCF8csERUk3dSMmQLidOuwuv/THeRsQuZMza4pQ4vE/BHHQnAmnC3FICyQLQ1jAe1rACvkCuWo8qlmLFVkLRSOWYgEwrRn/kUelmjc4gzuwtI+Ln1qIhVpQ1VhYMBu5NWroht1EsqMjqqRjOmlbymiUxiP9Tm/4zmDF0lsUVp4SS6/0SqsTurAcS+sbSyo11qzDhmpoTzG9rTJNHJrrJFJqqYxgIZhiBVUQ13EN11US11VYhTd1hf00hU/wT2CCw3oU0NtRJqrqRwR1s9/pKgK5v0JNyK9S1LLIULtgK1DVUBFRkUt8A0xIhbvClfb6g0CokAzhEL/oIlsZEYt0q0AQBVE4BVG4hEYgBEZwhENABFT4q3+Bhmyo1aOLQiQTsqCUuugbrigNOumrOiqlzpzNyirlTqzkyu00Vp8VS3TcurYU0967/y0zTQZjiD3gEKUTxIiNGI8WMtdxxdqsVYVwHVf9XFd2DYV3LT8xc4l6VDs9pdcfkgM/DczBVNCbwZk4My9/FZXDPJAPyURJMwQgaAExypAMZVRInYLnKZa8YEil6YRAcIWGhRW3IDSPDCdzArBA8INAIIS4KBaY2ANKYIXCEbZq4MZlDTotnFLqGy7fGscqxNma3VngalYotULrq87sFEtprYbcStqlTZzmqLGn1Q1R2qC6gRvYdCkTissUiktX0lpVQIWtXV6vfcdVCL85ZY8aEjOzs8ez5Qm266G/BEzB3AIjQook6io5C9Qmktu5BVh7Y197C1GJnRq2uCIAG//c/IpfDe3EALRIQ4AFY7mrVOhE96qe5ymRL0rce8IVvhhRvGoER2iFZUitHBw2arCl8TRa9MyGr6Q+s/TGDs7C2L0+rwTTas0tMr1WYAO2ZChT5nCM5jAOmnNaR8Ksk6ocuFnFimBTVeJarmVeVPDhH/bhwhAUQlHBwqgFWEiFUyAFNmSPSHDi6zW7YXIUnAAiH1rbezWDoNiCJIACLnaCI/hiJKAmp2gK9Z2KujOQHbA3HdiBHHDjHNCBOBZcAlREzTTRC9xQYvlM6ZHYtsqVFVmjUsAESHCVAzZcBNbQvOiivKgewHCaYrGEVSAGlb1WCRa2Ycut9iRDDC5HLhT/Rw/2ZC4N00uuZGBjDl9DZV9r4VO2LYCBDBd+YZp7WmHgsA0TjXKxz1U03uPV4VY6V3QFZnTdmI+Ay1cg4lrYhDrw2FBQHaZqqusVJpmQZpzQgzu4A7XF4mZKgm1OAidAAicAZyQQZ6ZAgjLGNyY65/blgThm53bWgQucgvCxK1dI4INF2GIB4BBlJ7v4L1jo32NRNL8YEc0ckQX0FQIrZBcBkWKxWEOABFdAjH9p5dt6z0uWhmiIBouehvW0hmvw6C9kyzI8HIzWXch4ZVV+4ZkbqVRGZZM+5Vf+l2dY4VM+jsaRYWFok4jKjeBFiO6IyWE+D4w5XnRdofMgDJCA/wVHmIE7KIVSYObqfWJIIFuSiQkpxglr9qFr7kc81GZu9mZw9mZxLmdzRuf0jTN7MwKoYGcf+IF2/gFJJYsMXYsPCQwCjhBcaRq6UIv+5Z4VaVi7CifoKei8yFC/gIumecDChVRFxgRX2IVhEBicagaZruT3JOlKvlbKxtaRkmVYe6DniOXi8DXLkAyCQYZkOO3RVhzLgAxgO2GTbg42kQ7sUBjteBufpoXz0O2gFuq4/BOQWNdVSCNHCAEQ0KdTGD9OyIRJqCFIkGrshYlhgpRrtgOtPoPr7mqvBmuxHmdzNmu55QEjEO+01gEfWAK2bmt2/q9MhB4l+CK94osugv+ewd3nTkiFLRqLQvyiDPEVjPsLF8lQXEncAMMrxVbgY6kFZ1mGyCgfgamM4rCXk9KNUVqXW2A9XsAoG/mSL8kMlvY15jjlZGAM0v4Xib5WjH6Mm2LhLzGYT8uOhxEXllLBVSTmjsCI3faci3kFVzje3EbXE1kFOdAADVgBQkgFUXjq5WbuRnDu5y7bl3CUnPgh675uL/ACbvbqbQ5r7h5rQT1fahoQqDDv847jHzBzHbgrYslE92ZUwbbjQjtRNwK8Rd1fuqoLBWSnTIQahi7cB1TkD7mrUugFZlENagkNuWmpRPcgiDhBczEXdmk9z1CgYQAbStfwF/Zwlv4SxnD/DJeW6FYGGBf2kt/IDd2QrNKI8eG94eItIfLYZVgyne+oBU1wBEY4Ax/YARKAgAmAAA5AA07oWNXJBJAJmSYn23qM5vvQAztYdjsw0OvGFCyX9u0OZy639u4O1DFfAh0w826Hi/euSEiFmhA5UcG2qz5QgjOCqxPdTLvIngsR6Klhp+dB6AD7c5FthLtC8F3AnG2BzQ+ySUYPIUGxBW4pEndZuUYSLeOgvZqzuZmLZcW5wRZOhmiwBmgomN6FJAnfjYG4ZXE5CPsEeM15xdgMks+mZJ3q6Oy7Bowmhh+wAAtwgAdwgAaQAAm4AA5wglLYBFEQdmKPBGOfarwkhNlZ//Zmb4NnFyL/8I+ZYXrxPYKZ2VdPKcxPwXYiWIKsX4Ju/4Gs3+fIpXdi6d8vuqf1xoRamJ78vp78FthMLKcQldQLKRYB15q7SmxXMRYQYVgZSUW+l9p//yCRhxsWFPm4oXC74XhOirmGpz2GD22ag/yPigbQeiCT+t3fFSX7hMFQyoXPJhNoMJyVzwZwdIdZ1c3SP921ZMto0IVRQIQQoAAIkIAGaADZb4ALMNVNKIWfZ+5ImAShXwk4NHo7uA/2u2I0WPqnd3qoj/p9/e44u/rz1vqt7/owEKN2EqPEFXtYoJp9LgslWBGJhZoKzDh5135KPewVyS9X4ZDCZX+7h/9/hl0JVZglYVAcG2T8hheG+7RJwIfFGAQIYQIHFismbBjCYceOFVtYzNhDhw8LPjSW7JgxiLmORbtmjdkxgcYGkhRpsVkzaNKkWbOWjVs3d+7eyaxp0103bjqz8cyGrSU2nz2vRYvGjBctVaDMgLgAQYIEDhggcGiUKlUoTpwyXZo0KdIkSJAakWVUiBHaQoMA2WnrFs2ZM1jaeNlidwuUvHr3Hul7hAhgIX77AiaCBElhIksWL/nh+HEgQ1+GTPny6FGgL5Y1G+pTeUqfQFNGG6r8yJChIV8ka57yqBNrzV8C9Ql9+hGmR6kkG7rcp7eh3L1zB8LkiJKtZCihQUP/6dx5sujJLE4XmMsW9lu3dOXq7v2W91y8eAkcb55gMYQU11PM6P59xmTFeB1jpkwZs4sp8zNfOS3oSzMJWBM875xzDjfbaKMNNg1WQ0011kD4YDXVNHhhg9lsoxM3PBHFjC+vxIJKKYx4cIEEDUAlwQcuWLUKKVlx0pVXYY1VViGNpEUIIHrY4aMdbaAB11x13bUXkkkOtiRghx1mGGONPebYF5V9ocRkmnmmmmxDyEBZlUNg0slskXXySB+yrTZmbV+kqeYQqcDyW2+Y4YYJb7oB0wkwqZx2lSm5nMTcc9Ap14x0iCajTEjcORoepLyIR15JAhUkDHvwjTTQe9Il/6MSNNFI08wtrPBiSyuyJANTTDIdyOGCCzpYzTT+TXPrNLTiimuFveJ6Ya8teRTNM8rw8ooqqIxiCSNIPAUBBCpSZlUqpIiiVSY12ngjI4mghQi4a+nR4x1DEkmXkVFEAcW6SSLJBLxL+vXEE04iEWWUjmEyxZhDpPnZFEMoMRqYkylR2yOWpVKZan1g6SaerFWWWZunFWdIIJ3AgvFlaAbyCCywuALLKamcUooknuQijDGKampppcKI5wvNvvxSM83j+SIMpZa2B1FBmlKHqHMqSTMNhNhseM5N7liTzMrMzCdMMx1m0yvWWet660pd2+p117hSM7ZLLVGDa1HFDv+jyyyssPKKK66I0sIEKjZwtwk2MLLKKqJcuxWNXoklFlk6govIWoAoXu6QcrVBl13qsqsu5e3uFS+8mWdOL+dPWPE56KFrlkonlZXm5mytpemvm4/88UYRr2kWCG2T+YuJZv7WVltmljX8RSfO1IJabpgUj8kklyACyzKwYMIIciuPZIyk32l3faSO1nzzLwgRhKl7x0Qn/nJGH12NNhvOBA/77bNv4IHjjOPNNgimz001zfVnzTXY/Ffh2XYlwFodDWwGNCBzmsOM/BxjGL/IxS1sMYtZyOIVrWiFK1bhiljAIhVKQJEEFJAABTRgAiSARAZL8TeuaCsSNyJLJBz/8S3ECYJHd2AcXB6XLnVtoXKUcxcToKC5IEKBXpr7XBiSqMQkYgljatKSZLikJeB1IhCpCMQbVOebIfgrYWm6ze5655niOS8yp6kTagjRCEeIYk9/CMQiXsEpmWknF7i4BS1uccftQKqO5hkGphYiPmakRCXUwAarZPKORbZPHo6Uh/sOdA75UXIblrQk/TCZIEt2yCXXEIpOsNGrsZFtbFyThvkSiJIFXmQk44EgdmQhy1fQ8oKtcNvbLsg3vrmiFq7oAQcqgIEPSKAACpDABVSAiVWkQoXY0tZXXFi4GMowXIMgxCD0cMPG6bAulOshD8GZFx9aDkmdo9cS0xmG/8x8bAoUs0xqRvMmefaGdJfpHWg6UxvUpKkPaOqMm9rUh+Jh5g0fQ01vzoRQjvUmEI5QRXeEwRDzQPB6ddQOL+KjHKPl6iXcYNo73Oe+RUpSkvKbpElLqlIEcYOSleTQhjoUFERaTaY/CSDXVImoS/GsOxHETixlKUFZEpWWFrwgLpG6ClWoohUaFMQKRFCBqGAgAQmAwAREMIm4OXNGXolEVyIh1hfKkBGHG0QheKRNbuoQnJEL513iepcfTi4KV7grXtW5xNgwbDW7o0ztQEO7PlzFeKKxjBd/40Uo7q4PUuwEJpxn0IsRz08dA849LzEKW4gkGdapoCxssR2JHoJDGdKISUhF+r6Syu+SG2qta+UXDvlxKEHjmORtV6rbklrNJ6J00CkJJZ2M8OyV1gMqcocqywlOMBbOjQUFZ2nLpDKVFabYwwk28IEKVGAC0FIAVjmAwlV0NVstFKs011jWw6WVEGvN4eMgF9co2MVIXrjvW6EATh9iob9YuKtelRgQACH5BABkAAAALAAAAABAAQABh+q/n9yxktmri9OpjdakgdCkhsqih8adgsmXccGWd76WeL2Rb7iVereRdLaPc7qPbL6MZLmNariMareMa7aJZ7SMbrSJabSJZbSGY7GMcbGKaLGHZrGGZbCFYa2JbqmJcK2FZaiGa7ODX6+EYa6DYLF/V6uDY6uBYquBXap/XKp7VqaCaKV/ZqaAYKZ+X6Z9XqR6XqV6WKR3VKF+ZKF7YJ18ZJ16X6B5YKB5W514Xpl4X6B3YJ93Xp52XaB2WJx3X5x2W5h2XaN0UJ90WZ51X550WJ10Xp1zXZ10W5xzXZx0WaFwSp1wT5xyXJxyWpxvTZt1XptyXJtxW5tzWJtxWZtuTJl0XZp1WppxW5pwWplwWppzWJlxV5pwV5lvWZlvVZltS5d0XJdyW5dxWpdzWJZyV5VxVpZwV5VvU5huV5ZtVpVtU5ZtTZRqUZVpRpFwWJFtVJBsU5BqUZBoUY9lUJBnSpBlR4prVYtoT4tnT4pmTotlTopkSIZkTZBhP4xiSIthSIphR4lhSYheRoZiS4ZhRoZeSYZdQYNgSoNgRYNdSINdQYBeRoBcRIBbQ3tdR4RZPX9YP31ZQX1WPHpXQHVWQnpWO3ZVO3pSN3VSOnJRPHJRN3RONW9ON3FKLmpQPWlLNmlKNGlHMGFHNGZDLGFCLV5CLlhCMWA9Jlw9KFk9K1g6JlU7KlQ5Jk86KVY1H1E1Ik8zIU01Jk00IE0yH0wxIEwvGkkzI0gwIEQxI0YvHkguHEEtH0kqFkQpFkErG0AmEjwqHDwlFDcnGjUjFjwgDjUfDzAeESsdEi4YCSUXCyUTBiQOAhwTCRoRBxoQBhsOBBQOBRgLARIKAQ4KAgkJABUHABQCAA8FAAwGAQwBAAoHAAkGAAoCAAcJAQgIAQcHAQYHAAQHAAcGAQUGAAMGAAgFAAYFAAQFAAIFAAcEAAYDAAUEAAQDAAIDAgMEAAIDAAEDAAYBAAcAAAQAAAMBAAECAAIBAAIAAQEAAgEAAAACAAABAgABAAAAAgAAAAj/AJlUYVIkRoIDJ3z4iBGDiUMwTOzEOMHGDpOGPmBAQvMFDRMhMVCQQJFChQoSGFKSSIECRQeRKVjGSNHi0qtZtYAxu2ZsF85ZrHb1gRFDiIwYOKb4eFJFhlEZDp0efcEwZMwUVRmmePFi5cwYL65yxUpSJAoTWMO2JMGWxIi3HC5w6CCibt2UIi6k7EAiBtRIpFDRsgVMlqtWiFkpVsWYFWNVrFo5bowYcSpRoESR0kyqVKrPqR4hKvXqVSthzJgtM2bqUqJFiQoV2rMnj5w4a9RwmUJmCxAcNmjMYLFiBQgNGipUcKC8QQMFCQ4emF5ggAABAa5rFzCg+4AC4A00/7jRKdm1a9rm0ZvH65PoPndWeFiR4cMMG3gaXQqVKpm089poA82A0CyzzIAOFaGgBgNMEIMPTEAFFRhsKKTgFDOxUccUdtTBxRcXhdTSWh28NBJLbHXAwUpYyWBCHK/QUssvOyXjSy21ALULJS5U5cILRAkBkl9FHTVTi2BxFRZVDLUUVgpMQJTVkS88QaEQL6AAwggsmTXiWyOgMMIFcmFgFwZ6iUAXBnw55QZgMfYCDCyyRCaZZIrlmSeeilWGmCqlaFbKoJ2BlgoonaRS2iq3/MILL7eMckkjkSwiGyF87IHHHHO0sYYZaJjRGxDBzeBCCyaYcBxyyC33HHQKTP9nQHXbbdedduAVcAADNYBiDHrzBHvNMaPAd0ccQdhQQwghrDADHIl0sskou+yE3oAGFmggEwpxi8N0MbABFQpuuoEDDFzh0O0TbLBxCBdsZDniWiTw1SVDMrjEwYokxaDBCqTEsssuvhRTjC+0zDJLK7WU4kJMMfzYo1ZVTdUSVkmK9aBDWaUgFVhVXVykWWGO0AGYbo3AFkkkxMVBSmaiGbOaK0XpByak2GJLL8XUEoufiK2iSmV93tkKLEC3oooppniWitOGprLK1EqfMorV7jEiiSNcKyIbH3zooYccZMcRKhlXkIoDDTSgqqoGq7qqwNyxHjCrddbVel13uRr/YMABH1RCDHrdzCNNgbI8cgceeOhRRhnLFqdDH5SEEooqv2rTzDPNNHPgMsmw4cYTRRBkwQAW+OCUX1HWQZBSS4GsoR1ooNtlvSV2wGZbKPile4krkbRBBpQIDEwtn4ziSi0+HW3LFhiPVRXGWHVJUpfWo8AkQ1zNdL28ZbUkxEVvoXCCmGCCyYFII7WsF0oitGTXmimRVMQkqOgMDDCx1HI00kkDmp0AeLSgMQY0UPvM1FRBtVGM4hMQrMQjtMY1RyzCgrEpRNgahwc5wOFsV9jCFdZ2KlW9LTkVcM6rZFWdW9kqAN4Jj98MwIA7yEIa2riGNHbIDGF8og99eIQk/xwXhMjZAA6P0AQoRiGLZKjmQAVSjUAGQpAiTMcFC1EQGxxSIRwwISYRwgpF7KAqkZisA2TSS4laspcTwaQlyTHDK3qxC2AUAxe/qIWMZgGLXgziBH55wfm4dLHbhSkmI0rBSObVkpcokkWIZF9bRoJGlYVpkbgD3u90p5K6jEQEKdGLBCiAgd6BwRKvsMXTTMFHP5UGFgT8X2VgiRhYwsIxU/tM06T2mccMTTGggKAwJShESUTimJHAYGz4oEE9dNBsoDKDCNfWgmqesDkOeNVBZtXCvNlqAH9TQAOmsysdjMIY1rCGNKwBDXa6gpiWkAQcgqCDFXxgBTq4AyU6Af8KU7jiGKrB1jJI5waLVMQEBeDAQhrCrYZyjEhbOQEI6nACE6hoX5xUYwdiwkkUqCAG9WLLCB5QARasYmcHw8UumIcLpPXCExNLgQlalrK2mExliUTR9ayHSZUhEpEqS1G99nWBDZwsRbkrURtzZxdQkgkDEbjAKDGwEjBwIn990IQvbAmL0rwSaLSsJVdpaadVpGKXuQxaYlTxiUq49a2PeAQlLDGJSdB1EpHYWiMSwVewMc6Dt/mUb9ZGgxIeRznNgc42weOdbxogARbAQR14kIMZfIABH0BELXZijWukExvJOEUlKLE1QtAzBBnwAAvCQIhKaOIToNDFMpgBDWn/LIMJoqvCE55wLnC9QCELqUMd4nUUjLWEAxaIQRUssK99oSmNuqOkUHEX1AVowAOc6EUvfAEMX6wUR7SAhS1egYOruIUvSQ3pJK+XU/S1b2Um6B17a6qyk5kMqUlN6ohwdyK21AUFpFQJSdzgidI8ohKqoEUrZhGLsQYQrLQMayuEdlYGrkKArBgFMRFxYLfKlRLHtISIRTwJSZjYEXzVoKbE1kE4iOoKaWvbCVG4Qrtx04XZ+c4BKuCDOuCACzdwgN0OMANTmAdA3dCGNHTR1kpIIhFwYNYH5mODMhDiwJo4hTFoK40qFFQg3qrAADbAENK16xB2KAIY8HWUDUzA/wIbcEMHLJDGNLLJSyx7yYrcoiXlZAAPqeRuLVSKo13QYo5mOAGKLpBUNgFvkXiGNH/XMgJFX0WSNh0BB8JEkvoCr5FuxN3uLqYCllC1jSmwgydWsT+DwaKlALQlhGV9tAbTesJCM8WE1XpLxnwCEYgwVocpQWxLYOLYIyYxXbcGm0Bcig/P/KAZyvCbU4Hg2jR+DjlvfJ3scEdXChBzAMYNQ3CyABGwSIY1AsTu0MaVEYywQXFQS2U4MMK1oLjFgRxaBC9XwQfRiYEb/OADP9ThEE8YOBjcAAYZjJICF7DAE4QwJk2vyF7zVeRNw+eCDYDABGiQkx1ZWuhYrKIYl/9ogQtIcIEHLCCSXrrKpcsSkzMe8pHUI4lDFEmuL5ZlkovM70goUCJGb/STdTFR7/wCifzZ0WC/+EX/EhYLhcEiFljvn8+wLouue10WfrowY44WGQIS7Id3+EEGMlCDO/RBa5ngBCccgUwLXnAReE9EIASxB0yxGA4fJAPaciDjuC2HbttmLHa0483vfEeGfgPcI36xbm10I8nWEMYoQkEKQvThDcryAAMaQAMzJCIToACFKnzBEB+UjinsOgFCqlCFhtjh9m6IEEikegEKWGACL3CDyTZ9X0iiSJEq4nRLWuBxF+QAFU8fGC5w5LNXAAMVQGgBCqT6AJkzkiQmOX7/7zSOU7d4ZXosupgb3JCCDhQlBpvO71MZvf3c1QuU+N9+SGMiBJwRxo7AMDBX12BV9zNZl3Vfl4B+wgoLdGFiVRmGVglvwAIZkE0hUANw0DiU4AmcIGIgVnd0Z0GHMAiGYAgZRAjO5EGB9xs0YEKH9Spzs1i04k2Mlys2aADgdAAOYAWfIAyE026tEAqigQhxUAMzEAIM4AEzkAN4kAmdEAqlECVg4GVT+GUJ8AAPkhR+ICUekwItB3EQhyZugAIuoyJ8Ni8r0TJzsXzVpAEmAAMusAnRtwu4MH16RAvaBQcucAIXEAHd533ft18w8Uj9tWktkSpuxD5comky0HAq/zMXufNcaPISe1EipCQCKBEz6tUXkEAKc2QwCLMLXIV1D5YYerIYfRIZqjAKqnBLfoI0thALlBAEoucADpABMxAHjKAfT7gJmXAJlgCMdBUJdTUJc0VajtAIe1UImMJBZkMG1UYDxOEBFfgczyEdd3Mrjfd4N9gd4fQBfXBO6+ZZObQLcQVsfUAGzkIDITADQfAGhHAJogAVQvIRQjCFPrABBzACDzIFH0EkLBcBFPAAElCQGCABMQAGG0BT9bVfK8M7W+ECP+JxSJEIIid9A6MzOlMMiEADJ8ABC0ABMmc9kbQy7CMmm/Ze11NRhURdJsMS9sUBRhWJT/U7KEEBYf8IcZiIATgpAWTyEijgA5BwVTujXbYgihiWJ74EGY+hJ2PXiktTQHeCNKsQC6mAB6jlHMzBAnCQCZuhCaHQCdLyiyNmV5bghKIgCplAWnrFV4SwTHjwjCGEAy4gH9WYQoplNza4jXyzlzp2AOIUAncwCgC1TjuUDKMQV0CkB0AAY8VhA6wlCVehFRjDEAmwANPjFzKQAn6Ikw8QAZ0pAR1gB1nSfinCMow0mQwBAzAAN1SBBtYHDHQ0MLugkbaQDKHAAh/5ABMQiCeCSLwjEiryafcIBj7gJGBxkilTPi1RMsNHJmC4IiPwXBJwF8/VkzjpSEKJCZ6ACqlkC7AQXl3/RWtjdWtixVVHszRI02D/MzWvkAksMHriNAEToAEwsAjemQqjUAqb1wm/eAmXMFdOSBqroJYeeGKNwDVwKQdosAbU1oKHlVjQMWTc1E3ecaHdVADhxAADwABvoArJMFs7IQ23IEHAxgh4cAVlEAQrwAI5AAdHkj1LNwEHsAFM0oV+SJCg6XKfWZDr9wJMcEgks16TSRVAMgEvgRSisD9HuQu6UJs6UzC2oJsXMAEPQC9AB5xtgSLAozIX4DHesxXtJZNmtD4yBQLNFRc42XsXx0kUED8oIAI9+ZNssi8wcAiBcAiT0J2vgHVeZRrlOVa0kHW0UKjiqTAK1opXV0tH//MKomAFDcAADKAADjABFaABJ7AGncAzvjBhphAKiJIJmRCMmxAKq9ALtoAKm4AJyWYJc+WqKKZBdRCX0iRjcJMc2TShLMRYjXWhAwBD1aGh0zFuNGRDThQg14CYcfUIeyUqYTAcMyAmfMEWiFRc0cEyfUECfrgA3NqtC/CZV2oHveNxJRIme8Y+RSqRLfAApLQVfCAnTfqkGtldxQAHJ2ABFnClQPeQFhdU7eNIixQTJBBfLGEC5yMmG7ABI4AcHKABG0CGG0AmRJVG+6JpmtZ7VBU/aBIBEiCQEIevFPEEfzCCNjFef9qnB4iyhmoLK6uRdDgwP9OKpBhrojAG1v84qQqwAG92AjxACKuQDMkQgLAAKGGZCZuwCZ0gCrH5Cp3ACaIqqgDqi6OaTLJRCGOzBluAA25zWLkag7vqeNxxoeRWbt0BAOPWoStQCT6IrMwgCyYqRHggeMsSnDnlFxZwAGTCJR3bcguAANzKrgvgkxhgAXbgA/FFhj7FaTz3PVxxAifArRQAJEBAGE06MEZZDLuQDJTwkRMgAZg2SRcFlCa5URqHSQF7iJqWsPuyATKZsBoAiSrSexCnhhcwJhZASr2nOy0XAd/Krm+2AQrRBXXwB4WQCIxAbMhLCW9FbJKgvAB6CW/lVpowvdNbCRDEilvXCuKZCnrgAOKkAJP/epm8uQE3kAeg0AupkQyY2wqBIgph2QmeaDCvwIFyJ3e+2LScsAnAmEwoFjZYS5fWtAFy47V66Zd8M7ZjCwBmC0MHkAFvsFnn4VnEco7MaAY5QAboij0ysMH5Eh0XwHJpRAELwLufCZqjVKUy4AZoekk31T6pSRUsga8m4AI4AASkIJu7QEe+sDO2gLnAEAoe8JkLwF8rkwKPaKYgxVPmCnMnkiqpsgHIsQEVFSaOu8IXtaZr5BYJCwITwLoY8DK9V5D0+WbMBSVs8AeB8Ad6EAd4kIGaEjZ6MAd5wDh5sAdgw0yNUwh9oAd7HAYZqAeIoAoEkwzGIAy+0AurwAgZ/0A3DcAcDnupJ3ADb9AIqVAMImoMW0W00rIJpaAzpeCLACpixwbKIiYJjcAIsbHGZgAEbWNtyQGDc0MdwdpNuGKDtjxDf9PAd8AKzMBu2kAMDyS1iYAHj9Qv/CckDPEABfDBUtWx2/oAJWzCEWABI8B+D9tIn7avaCiTINACOLAFlqBdOdyk3nUworgCE8CtX2wycmGSLcNpfRE+YqIBQfVoI6Aq1yaTDKu6MomvOAlxsisXJdJ+GvBmEwDQdQaaHEsBozQCuAU2dcCga0A2czDRbSAHdTAHcrAGbaDRZNPGbHwbtwEEW5CBfZAKuyAMhHwwtHAJHsDIDfBmj6wBLP9AA2NACKHQC06UGquhC62weZYDhaUQlkf7tKKav/8JqxZUCB2EBleQA6zcAi8oTjVWobyKobZ8g5FHQyxQCcGAHgGirKNFbHXLECABEi1zAAnAARIAzX/bu9D8cB/rEPS8ac3FF2WKMm0BZxugcjhQBjuTw7TpXcbAP8AgBg6wAAkwreVTulexmQxxsL0Txa2bOw77cYfF1xqAr79Hn3aGJv+cEjHQAQPZsQDN0KS0owrtk0XwBe2yBmjABVyABrT9IVOwBWgATaBC27vN22bw2zmQA1bwBnmQCr0gDIXdXZ3AArFC1RWArx53qS4qBnhACakADCHKDNLADIQ8C0v/MwqIIi1iab+bUL/5W9SuSlf9iwdo8DgjhCq4OsDkVMC8mtX2HR7gRENvcE6edQ1tK0GSwAg7VZlQcSQkkAAF0LG92605SpAALQETwAFVMAILORdvgdfz4ri8o2kaQMNkMAOkoMO0uQu/YAzFIAvAwAiVOsSY1Eje0zJdIkgmwGkJq7CaZtn6fNloms8bgK9vVmdhnJ1UVZAFGYY8WeSqDZqk5HpTsBtKAARN/gVS/gVToART8AW9sQUiBGOChzaPI3gzQAM2IAZ5YH0G012poAPkJE7MwdcmAGcswANlEAeKEAqxgNzZnb6/oDSBEpbu6wnvywn4a95Py6r9y6AM/5q1LmACyOEBA3wQ2HjfMSTp+X0AIdAHrIAaO+RDiCCZ15MVQkIWDK3WLvetf6vQPTpKBPkAm2kBKKCw+wUxXLGHjtsSrAsCL7A2K0AJ2zXiJG4MxnALvgDEFYCFUHEREPMROjWIJPMWQKc7Cpsq15bPHwcXnH27Icxoc0EBJPzPIUzkHOuHCz0CC4EDCoID5l4EXFAE6lIECjEF8O7u6pK1QNCYW9AbV7COP9AHsWlHr/AGDGBjbP7cHmcCHhfnc04ImVAKKW0MyaAMswUNySAMtGBWgUIKm5GWltMJntDx5i13mYAJkxCresAHia61KxAC2Pbo0kHfFuqrthxDf//DACyw38TA06YwColUMfmiSH54AQfhrX8LzTsKzbz5rRcQAwrLuoVUmS/wI92TnCYQA7eNA3BgC941ML/w68agC7HwCixQqS0CEhDDEOnXfk1vIvT1MvtCwy8AAhYAN2na49AN5C8RxgXJrhQwxnwPzXzfxScg4+iSKt6cEUDiA+cCJKz59EAikUCC7mzjAc1ybq9w5q+ACEJmY43c5h4nUSYQ52SQgY3QCa3wC8JwDA+/DNsdtM3zGaWA8Rmflmnp8XJHv6waCRlk8mig6CyAKhH6HAuQly7fWGEL82cbtrpiAB9wB+nGDLtgCr9ZmTFwEgydo2rdrUZP9A0OzVf/+AArESYGuxVFqiRRfzG5TgPAUQqoepRbn7nCIAys0AtwkAEVcALRzxJAxWeURGlIlaYSa7AAccKEiREgLFjYsOHgBAsXLlCACPFCBAkSOkCUQOGBhAcdK3acMOEBxQskFnLY8KBCBYQHLRh0mVAmBw4ITYDACaJBgwweGr3qBeyVJA8MDhRA6mBlhQ0gTLR4SoNHmThyCFUyBeuXsGPJkjFjtswYMF+0YMFalapUKVJtRZESJcrTXE9xPXHKZMlRor186qzZgoMGDBdQN2io4MBBAwUJEhw4YAAp0gGVBQy4XFkzAAABPAcYAHrAAQ93Kj0ChSKF6hgyZKSI0eHB/8MHCxY8TmB7QccIvTv+3v3gYIwRKYyneLHa+AvmyU8cRxH9BY4XKy71wo7dl69kY1vZkpShggkSKEh0KE9idQwS5zkU59C+JIcO9TlcoM+BglMTKEHQRIgmhRp6qCIKKopgAY4uEM4lC0R6IKTfJqQAJf82mKACxB7kcIIBHTwIQwtqQmgDBRjIIARKSEGFFEJCUAAyyQpQaiWnTnjBBBekMkMOOfRgZJRWavmFGGO8AisZYXZh0hdbXkkrFVLYckuuueKSi5NNLJnEEkkW8QuNLa4AgjqoQEBsJcYak3FGyjATILPMOOssgM4A0MyAAz5ApBTjYgA0BhVUQKEDDP8wuEAC3wpIQAIFR6pIUUgpYKghDmBLwQcfADUuOhRecOG54wBNjrkWVogjO1+KYRUYYHqJBRVUWGBqhEtPAGE11aAbwQLz2utgBBJoIra+YP977wRlDdrgvREGNFQikSbQgFoNbALhhWqZMqEplTI8CIQRlLVgBFsDrAmnEwCsAFd1m8JpA3dNWIGFEHK4yxNLMmBAAX9tqy1Cm1p4gWAclDAjDjyA7GQVW3wRxhiJjzTGF112oaWXXWxBSy22sAylkys72SSTSyyhRJK9CtEjDjPIBIKGU9FMLLE1ZYzszTh33lkznw0AGik9D1DAAyjWC1SGDlaLViIOFjjgAQr/IsCoN4oyouCCDYItD1BNOdX1BBROcCEFsWOADjkXTLABFVtsyQ67t1+R9YqcxB1BNb1tzXtYW5tFjwRhO6AvPWJpEvUEWwV8kCFKEZr2gQbUbGAxDRbbaaUNdpo8sUpHZEi4kKbVzTHICghAT9WBZn2AAgwYwAA9JGkEiDUV0A0kCzQAgWxQYcBhCzR+FKSQS0qBZReIjREmYuZ3mQWWWGixhZZYXknFY5A96SQU70XpJC9JvAQTD5fJKOMKwW5CTAPEbobs9ALghJPnyubX7PXJWCcahdb+TwGwMBARDHTgIY7RSARGYrWMOMQhx8rbC8C2GsGZK2/K2tWvyqMs/xNEAkttgQtcOqEJVCziJvLqT7MChTbz2CpYNBFWe9wTn/PgBycc6N26FDK6CQBMN7dxjGNixDrJ+Cw0n0FiEpNIJyY20Yl2ciIADDAJPtzAAUG0jQMilCENbOApLoAB8JTwhTXM4Q+DCIQHU0GLXWyFF1sZy8asd5azxCJKpigFluTyFlmhIhR5EV8i+IAHOcDBZVuIGQvQhBPELMZfbJrR/XzGszjlbzKv45//0CYDFBTwAogi4AAZlACqSWAiVpOIA/PTuwx6yjwv5AAGyxMdGS6rDJKQBCU4sUtKZCJlkkCFJ2hgAoTwjgMaMAGv0IMC/DzEIRhBUEd+GJza2P8mAQUQgBKjuE1u1ilPjDJdAmqTG930kHNKccDlPJCBDPCEne1MzCRQQQPFJAB3AGMIQ3inIxz0EwhcKOMeBnGIQUSCE6iARS108Qtc8MJVvtjYWVixClWkYhUUVYUq8KhHUaDiFU8ihZbwopdEFIKQhEQDGQTTAv7QzJGMecxRLjlJSgrgkpgkoq7KU5+HRMRqV3vAAUgJqUhhzYEzwZBMLFDUjIRoQBGh1Og0NIc86KEQheDDHPSAhz3EoRGXmAEI/GcCsaWAPOaipWraM4IOmAclCbkAhIDDEAHV5DaQwSIQgxjERypgJ7jDncB6aJuQLMBDGAJBu1jiFA3gEFn/KlkJ75iiIZyYAAcm8MAKFOMBTiyiAn/VjQO4SNmnwAAIiBSeHPDAh0EsorWZIMUqEqqLW+BCF9vBGCxakVE8lsIUpsgoK1qRClGE4i1rdBIqSHaXvEQiEYLQwyDlICbBsKAw7LOZI2MUGTcZsaaUuST/THdJBCAgfvHb6wKuhrUDNdAh7nPfBBIQgDghBa+78VCiIsRUadoTC3OQAx8ErNqF3YESqJAEDDjQreeYYHQbEJzT4mqBYC11dBzZiEgIy8PGuQRCvlEvhiNUrRFvsZrU+k1LLrCQxHRrdya41kJ6yBKmNOUwAwGBC9AAg6aspAV8AIFfK3DPCEV2nwa7/wIZtlAGOKy2EIuIxCAaQYlQpKIVsajFWYgEUV+QpRV4HIVvgXvlWrQij6EoRSpsUQxgrAJ8d8HLJFZWUj1MF5E0WCl2V+JI08loMpqh5J9dJzSgqXevjrFmenezgKz5hr29ce97D1PN3Dn6AvVZqkYmFDB/JaENcfALH9rgI6pqQih1GEG3EtLFB5IgURQgwYGupmFq6k5CJjbsrSWkQGkuepqN0WtuIEROuvbKQ5LVHAg2sJKQHGSLB+nAQS5Uky5+tnJEIyc+K+CBEHixBcA7rRnMsIYfPTkSk0gEIyjRiTRfWbixsK0wvlIMM4f5t6Ygc5bVIgrgrlkoWIIzJv8mEYlFSKKkfJDDGtIXGBoUBk0aWGdi/BXTnOmsZ/nz2WRSIAFSLmAi6p2QbRKkQJKr96eQhghJqJWQfE4gUpCuyEGmxusJRcAxLDgDHBBeh1FrNQ+M6IUtOBGqjSTq0s06T0UmgjWQ9HC/IEkJgrKmEUpx5IeURnSiD42brefGAh3BIYYe0EWG1Gwl5fx6DyUUugeNc9CQ8RdjfhNZ/hjstGiIA7lXy5cupVsSmgiFKVYx3Fa0Aha6+Aoz2izme9diF7VghSrSspZUvOJVbgb4LjFhCc5/SZB4gIMZxFSmgt0EBB7wgM0aQ3FBZ2aS97tkB3aDaEpT2ppXnybAAvb/m/Vi+OqbliavbYOA4CzABIGwKpTrsHw+JOIRrygGKcrAEkfdJgUcqrR6EaWf2lh6IhRA1KEOJYHxs1dqElIvRHQTa42YZAKLUYqGpy7tdUXg1RYwrEFoMqz3UGsBFeAACVEIHLKABICTAlgAnVAAWlMMlngPp2ABPLuCcUMDOAiwQnCELqEES7iE7kmzi5Ke5DmSZKAFtbAo2cKF59kFWPmoJ/EoF3yFLNGSvKAEStiLPkApMiCDK8gBGmCBFUCTw1C9ifMz/MEfSrKkycg22huJ28udahqJgBG+jpi6VMII3uM1kosUKKQ5R0kADriqRDg3LqgDrEq3UigGW2iE/97BgAUgvhhAAWUTCd+YjQGCiAXyCEnBmgIylio8kDuspiUUOSi0jUdqAIChCKlqO4/jNQswCQpTiGEZLBDYogQcwAKcEQJYAA74LMPKIqWQFxSIChy4gjIgN9VKvkjgvBq8BE3oBFFIM1UwvFaQLVoYLsozBVaoBVwQBogKOlTIhEYohETYhClBhVVABSvZJU64hA2knUTAwekKPTLoQRa4CT27ne0KmkGjKSOajOBIkPKqtQU6OaqZuk96CKpBFGNhRwdSFFRKJQNSlKxxCKu5DQuog0Tgi0KYAhiog0FIhEbohF4oBlSYgQqwugR4FsRgCP2KgBGIq40IxNzbDf+f0ggIqcivC8T0CphF26tH+qF7ErIFWEBGM0cEIAE/8AMZUAHZKEBGyw0FSAgL+Cw2wSsK0ICOyEmVQIjeKZgduTs5qIOFab5F6JJmvIRM2ITuIYVU+K2Myii1GIV7MwVXkAVXYJJdgIVSoIStqgpCoLI+ootl9KWTscFEIAQ8UMvpIoOYaQEWOBMh5Bwi5K6bMiJvjAGPOyWROzkIMEd6dAg7VBRTQkd2PI8O0IALSMzecAij4kNnasyZc4wHQAMoiwSh9MdAKARJqAToswU58IAryo2laECNnABXO4hr0TDgE45rqZaDqADdaAAI0SIHIMmJUwAHmDiusyd76qv/uFMMxRCq3IAACHDDBfAEVMAESGBOSLADO7y0EXgBXNFNv4qRx5AAZnIfpejJE2iBhsOz1Fq+6DK3LsmLpFxK41qLtTAFp1yLqZxKw8uoWqCFUbiDFWCnBmAABnCAFdgDTmgLuoAzTUhK8WkEQYoulLozFyi9btkzxaDLoXET/LnLAeAEGNAAOqSacszClBuJmaOaowoWCzoMmagWfYIq90lNuGqIatGNKXCESIgEPHAAGAiE1nIESUiFZCiGTAjNHlKACngnZhMJDUGMh1sKyhLCyaIciaucGhHSnngndkI9bguBFQgBD4BAFpgBGvDSG7gBHOiBIvCBHugCKiiC/ypQgeKEABXABE/ABJX0gzclhThVSUhYTjaAAQvYCd0EIgx4DcVMNrLBs/BMmDoQMD4Yxhi1BKW8hEvYhKXsnlAIs1IYhUu91HubqIxahVJgBBYwCu4CGshwADjIBLvwBO/phE9Yyk04mWckhM+Lg9HrJ8IwjCTVrvOquD97k8roBUtQNojctJ+qCJdTTQlwudTcnd3pIrwpiGa5lgpouWb7nN2RCRMlyQbAgUVYBC650UEYhBxtBE1IBVDQgxAIgc9yABDI0hBQtmbxzhaACplpgX6y1ysoAhwAAiXYAiWYgi9AAzQAWIBdAzRYgzWY1aqAg4UNWDQQN/S5gisYE/8gAIIcsAEv5VIW4CCcYAoLoAAIEIESKIE1La/iRAAIEII3hQQ/8AQ/OAQm4AB08ivJYTQKKAEhIAGF0IAIgoEcIJNSJDdFDcMYNU9XRU9JBYWkVVpQyNSsgIWK4soQMAAkupM6CYADyIFL4KhQAIXuIZlX3YtF+Dw7A4J8hYEzST3UG8IgKkK71AxgIAUaSL3Y3KIuOoyQWIlldc1mVTa7bQqyIitlaQHBfYEwwgFlQQ4YiAF7xQFNKYIpgFwy9QE2GDhLwASCCgSxVQRKEIVXoBtOmIRAqAM28Is6EEo2QN2GddiU0kElI5NaDaPCEAjTO73Ti9IozQDM2Yl+6Zf/R+rd3yQavKK4AygvEXCDEoAABCCA8lJe5SUAlpWBJXADJjiECRCq3dkJybGANkRZnL2A3gEjUlQyU/yRouQLGeW8pHxUTWBfV/yE933fpP0EUAiutCCFPnAAJYIiz4idA3AAPqgLuFBVkbkLV/USccUq0xWTMgiM66rdudUuf4mfCRW0AegESsBBNCgDNGAC1EXd0WWD5Vs+OxCwQAiERE1UE7aDP2DhPzDhQHBhcDXhgcLcF/4DO7ADEW6DUZMDH/iCLyADo+S8zL1RR2gEReiEV+iEQjCDy/os0lQM25jLNfnd3Vy94RzO4Y2f7dLVCSaiL3Zby4iT5YUAkU3e//IigDNOXiFoWRnwAwzwgxSAmgTYHdsMUhOgANsQgSdoSRSoV/E1gw0uX3OL0XNL37Jsxfb9BE2A3/gdBVZ42lHQhDdwAAb4YiMaVb+aAUt4Re5R1bn4WpQZny9J4OlyWCXAAdl1CmXbs7+KUArWjOxRLlL2Cw8Wky3YginwgVo9E9sNTs6Zy77Kxt08L9bBqdZ5HaxdhLDVx0IgBEMgBESAg6Lol7rsVTGuqSPSX/3tpm7uJihqogAg45J13jRmUxUIJhWAhBJwAzfgOKBJp0OcgG7piNxQgSVgjxegARuwASAIZIRdLUV1hGXGpVxaxUpAaPZF6Ed4BISuBE0ABf9TuFRQeIQw+ICL/oArnYEa4GgdCIIweIM3UJg9IIRMYF+TTpl16wQteVVc6os6cxkzWFCW0lJfzsaYCprughNKeIREwAMyaAH4gi+1TRPSdOUh0hPe7Doh6jNYBq8gdYDY0ZMZcARHSJlEUARFIARFkGajAJrK4GZvFuuxJmsm4sb7EYCTTV4CWF4RYF4EKIGTlRVMWIKWXQL1e4zJYQiDmIDKuQ0MWAJ8ng6f5YItSJiFCUMZjYSCpoSkfGiHfmhNWOhK+AT4HIVPWGhE0GyG5mzOhuwapISHHqFKAO1ImIsZNMuUWQSsqrODlWm3vEbbtRlX1uIJrQxC2Co5KAP/luKdw4AvDYFNaaVZ3EkA2CkAonmkvdLVoPmzbNpmzfiMAXAAI6aERmgEXCKEXDoDbf6MJ/IMOtnm8BZvJAJr/tVf7v6Z1enft2br5SXn5IWAJZDTOBUBBbENofKXEemIxLgNuAaDKngBICjF4YkDrRKERFjmxWZsDswEhx4h9u2ER4BoSp1ozO5shkaEC2/oC3fo923fvJgE7onUTMgLzvOSg6uzQnoZt/ROgVhSxXDlLu6uK10BIJztYP7NxtBx39TxHMdNGf9iIoqM87InA/CrFMEDSgCKuOmFoZBb/axmIBfVIKfyUT2v/cRyB/iADLhoja4BjwbpN7iDMe+D/wxvaNE2rlGQxcLLnldwA/Z2b+Utzrhm65I1ztvAcwWo5+DIkCgmPiGYXh/Y4DYIBCd7sqpWcNDmwEtI6KQVBUwdhaSN9EaG3w6n9PfF1FPQdE2/has8BVCI1E0ImRE3mUblkpXZqq0KPUQiDFvVs8TQLrZt256IOCd9UihdCoiruxbYES91gQj00mAX9hmYARb4QXqhF3Zl1yytUtS70ndagRkoAz2YcOPynkyIAxuYgXopdhaogRm4AZ8lAzMwJLUsc4ZOaFek1DTLnovy3Ol5m7fRDlehd1dhlWIQhnu/d+Yxkokxhq44Bokphl44hDgp47c+2TSGa+d960Tzq/8FwJXH2A3StCYKeAI/AIMQrgPkG8bzLehcAu1E7h5QoPD4PQVZCIZhUHlkYPmWV4aXV4ZmcIZoiIZpmAZsyIacxwZt4Pl5mAdrIIZT+IROmFSiLxkSLxnyQdABUzj16aeGO5P2aaQ1UW75CYIgoNiKzQEcyIEb8NIZeEsuJfZir3GxF3ti90FjV3tjJ3YbCAL0KQMmi4OqQEUB6/gEl4TNzKUOjAuIJnr29R5ZuajBXwXPjfd5BwZ9LwZjWHyJ8QqvmJjHl/zJp/zH74rJV4ZkgPnNhwZp4NFe8APPSGPkVWuRRV4I8IMSaO/mxQDc0M0HAJTizjU10fPdSMlD8AP/O8AqRUVwGc0lkAdtV3xF+WXkUZAFYpAGnu8Gn6eHenD+54d+fagHfaD+fugH6a+H5nd+epgHaQiGyyZ5VR3xEec8gsOqq2rtMlCCfQUCGCi9RXKf2d5NijMAjq4BfubnHxADMcg5hTH3MgcIRo0kUaJ0aVOnTqEWhhLlkBREUqVQUVxl0eKrjBo3rtr4SiIqi6hSrUpl6mSpiag0toLlEpatmDF7+fIF7KawYjqN8TSW7CfQoEKVLStq9CgzaEqXQpPWVBpUa1KxYbum7VoyPwS2EkBQAoLXEn78lCixxA8ErlsRLFhwQIGCByBiCBmRIEGFChP0wo0bQYgfSIcW/y0q1MiRI4IFF1OqpEmhqFCPQaliFczqvHn19P37108f6NCiP/crDboe6s2d+9WbJ43XqE+gEibcZJvTpkyWJjkqvCgRHz1y1nCZskUJDhwvWpgA0XyDhrwNGjhYoODugewpt6u82NHjK1jhX7ps1VI8+Ize17O/SNL7dlOlSrZSdeqUqpOqKrNi5cpVf67IMuAtuOiiCy/BBDMMMQ0e8+AxPxGFlFJQSWPNNRlapQ2HHXr4IYgfZpjME2pBcOKJSyyBCSRLnIgAjAhwBQEFdyWwAAckXJCCDxtQp9cDFbh1IwUYVAEJJpNEkkhiBFnypGKXaLJJQwmJQsorybhyS/8389CjTz/7hOkZmGWSZqZo+qDGmWel1dPNMrLIFgptnXByJ266RUIYYYXwgUccxH2xRRE4wLCcCcyBAF1eDkzwQAPXJZDdSZVWyl0pKFU6CqcncfopqKFyCgqppI5Sqqii3nfKSavidwovw/DCSy6z8uIgMrkio4wyzSwVFTbadJlZZt0Ye+yxxCLbTYjNZiiVNMwsk8wyxhQjTC4DtiLKJDJyFRZYEJilYowxoqiCCiRUcN0DHTzwgAXOCbnAuxU4oMABBSQgQQduYMLiIgJJMrAkA1lyCSVULtRHJZFAUgwzYRDTjTzrtFMPPPbY00478nRcjzwgi+yxxe1knJr/xv/Yc4863EyDzCmfdLKJJplcIokjuGGy256FJOJnHnPEgUYZZWwBBA0uKPqcBY1S50CkcGWn6imfuno11qv69x/XBN6SC9gJDjN2g8RAmCuvvBbVzDNMWSgNsRxm2Czdwy4LoobWQNMMr8gcQ4yst7hyX2yfVPLII33ccccbYehQA+Q1rDCD5B9kkIEDDhyg1lonfgVWWTIigGJZZgmhQgwaPDDBCBHQ25a99K6ugQaRFnDAAxzEYAcmnkyCsySWDMxYJ6J0kkknjyBCQgQy3FADNh6zw846qVW8DvbYy7P99dibvPI99djjjj39wANPO+rIEw0xsT22ySWW5LzJ/86WRNLbb4LskYcccKCBhhmOhgMaMKcFJ1iUBpqWF3tFDV8KeuDYyGY2Xe2qV824YDOc8YxocFAa0/ggCKmSjRGSkBvmUB/3UigPemyPHi78kj7gIQ8vvZAe9aDHPJh1FQ3xECrMkNZPjmEMYvxCF7eQBStUwalPMLESh1Pe4hjXuCDo4HGSW8EHsqhFy12ui5fLXOZC4AEPYK4CD+DcWkbnBze8yFylU1FZlqCCFMSgOSN4wI0i8C4LPCpIGgABCKJzlwVsIAZM8IMn/gUJSPyOIJmghCbo9BhP8EED3mIAL+bRDndor2Tq+KQ6sifKdYCSHfCIhz0y5o53xKMf8f+IxzvOIQ91SCMYMfvEJp5kiTvZ7EmRuF9h/KQHQMkhDgEEwgBb8AIXnOA50VEg1PpCwhFyw4TVNKE5smmObWAzm+c4BzjCCQ5tmoMd3xwHOs+JznWOgx3tZGc7p+eOdJQDHOIoRzrcoc95piMd+sAhMarGRFA08YmJ6wNCo/iGKDK0oYt7w0IhKtE3lCEMVviBDWjAghWEgKMhCMEHxihSkQJyA4D8IwYWQIAACKArnfMKIksgOnGVblw1RR0McACCtvD0AQt41AT+aAIXLKcCkZqAC2RwpN79axKWMAgkjTelRF4ARgQoACK0QQ99krJiHANlKEkZVrF+kh2sPJ//PV7ZylemgxznWEc3rBGM2OTySbyM3ySU9MvfCBMPdRjOMQ1lKGaawAQbMGl0GAiXezC2saJpbPjqwVjQQJZjHEPN9jg2PXZcVp3sIJ89yCHa0aLjHeEYrThSW47V6nO1qx3HPKDxCCt+oIo1qGIQrBCGMUiUt7yd6EThIFyImsEMZYADRcUghjA4jrlX+EEOMjoDG8yguiyo7gpokJwBbtcHPpCBEESAgJYSgLyjE5eKwAIjCKiove39HAboWCjVteVdewyqc1yAAzKgAQcr8EAFNOADNtgBEp448L8KUrxQHGQTnnCDVRHAgWR0Qx/6bAf21DE9sII1w2A1Kyth/xnifaQjHvuAJYbn8YxcjMI2SboT/Haj1z0dYhCB4EMdcCyHNqBBgD4YbAuWFkinNaAzRj4ykjuTptDgo8lO3oxlLyvZxmpsZamExzvegY4tcznLqy1xP/WZ5XS8Qx3zCIZtQfqDNd+gupS7gQ3iTIM50yAIQbiCnXFrZ+bemQxlWG4Y8qwDG+QgujNgAaInd+iNrqDRM6DBDFxAZ+3KQAZpEQCmzaveNtI0ju+FY1lEoIIioMEHJpgAvVAdr6BuYKg4mIIcdGwGGpzABVOwQ4EP7AlOZEITxssEgj0h07WI4hrz+MeFN8uODnvYw5+02ClFTOYSx4Pa8YAHaujRDP9ZgCI3mMBTJpKkJCURpsaB+MO5/8rj40yhUIcyoAmaOWQGLjnJ9r73P9L0mSWz6cil+TfAAw5wNalGH93AxijC8AMaiBHRbn74wyE35xrQoAaUi1zkHg5p6zK60RwdqRen48UuilQDKBhvAACg8gCw1KoEQJG4Oq2isaxRCGZxgxBi4IMp4KAFGujjA17gBhn8sQUwuAIa8FAInwFHDkerQyEgwQlSUKQUqQCFJjiha7SUlwAJSIZW/2FZLmuTw882ezveQWYt91Ptat3HPjL2mXkogxWfuMS38dTUvPJsEea2MY7nsIY1fMEMZLgCMmEQZGaetFFo6odnIg/5yUv/vvKUJ82/lwx5fN8b4PnO9mZaswzGkSHIHoD4ojvu0Y+KkfUg9cAHQJpF1ot05F+cDgMY0IDc8z73u6fOFx0AggQIIOUqBwCmXdoVmDNfBWfxgxBsLhZMDP3o/QXkuyZggRR0AAQneIEPzBBrnzniSb35UyIYIYmpr+QVqUAFKRYpbAgAgKU5MPZmvIeOtpLT7P5vR2ll2ZZ5mYmZWMC9CTGYgiZQgtbp3c78S9/V2CLY2B/UwRy0weChARkIEAy4QAc2x7zBA5ldGyyVg9qdoFqloFpR24mh4Du4AypVmcbMEwzCoJicmIi9AzzAXQrC3croQ/joAz60hivcAR74/49xqcEYLCETLqFEKdcYnEFxnUEZ+FkZGJ5xZWHRkAEZGIdxKMEVIB4yJY3SJJrHnaEJsIAJrEAL4AAQbMACuJy3bEUArEV5Jd8dptFWCAACIIkbvEBeKI3POcADVMfqxEsbkkGsJQIjNsJAUEIjMAIiIM4jXEIopIIt/AQwYIIfuMgdDoAqaBVocEM2lBNXzVKHPVv2gFU9tMP0pB06mKAK3gMPooM6OMMtGE64/UuS4Ewk5NWeBNMgDMIf7MFfER4ACRABtYDSME1e9BM09hM+RSM0TiM1ruAJZpk2ZlnawcMAamP52EOWnc84no85ntJqmA87vIk0PMLiGJPhKf9hEzLhGywhFI7B/wBQ0VzhFVqhcXHhBnLhFoRhGAIB0tCZIAZZYaXhCpwAC7QAC+gXC5xADFTBEticepVXHSLA5qSRy31LV8hAItkBE7yABzBjz4FAXkyA9rXaCwCBGSidI/jMIy4GJT6CQXRCKdBCL6AC9MkUWChACIxCN8CQsZzQZ5ESWa2iKLGiK3KWKwZgP72SxrhSOpzDNCiDnNQMLz6VJADjL/VGIZhbMR5jMQXQFQyWCzDeojRNDmojNUKjlnHZ/m0jN6LDK2rWhnFWXl6WmlhWK0JllKWdVVYbOMiDNgTDQsVBHBiNE6jBGaTBGcxjEyqXGeRjcZXBGGj/phjso3HtoxiQwXKFYRAUWg7QgHTNmaQpZBo6XAvMWQ4gGgvAABiMhYuc14vcyAIUiQiUjnrFyAKogCINghzcAA74wBb4gAuoZAVYgEmdwH7FAR8kgiQIxEA8QpQ8USVcwkE0hB24gYtggB8sgiRUwicowzyAhjkcJVRSj1I25dmdkDropcWwQyyuXZaRT5jsAzlsQzbADNZlAifsTEGEm/38EjAlwiAIgv7QwRzggRwQjTIaikIGkgackl2qnVzi5zvYZwCK2De+4rKdgzqQ6FtRD4peDGN5DIuyA4t2DMe8g1WKQzp8Q1V8wkIJ1xg4wRZApmSmgWaWARVu5mYW/01xHakZEGloWmEVViFzBZoVBAFGxZmcPdqcWVejXZeb2QAO5MCj3cAO3MAXHMKDPZ8fsMgLOOcJkEAKLEEVVAEYRF8KkEAHdAAJuAEk/NIgzMEX4MD/AMFymlRhuQAQJF0hlJ8jOqJBXEIlNIYTbSdCgAIpYEJZQIAfkEInaIImPIIreEk9rCc2dMN8YtlSOlsoqYN80mdUrtY26mf5uMM3uAwyuEIoOBgnIAwlZIKB6hViOIK5NegwDU1gJYfiFVYgpR0A2qeHfqMOgmjbsdKYaSNd2ieyvkO1diOWrQw8KCs6XKs2lsY+iAM4UMM1EMMbCNdkakEWdIEafEEauP8rF8TrGXxBvHJBcXGhGIxBvu6rvlqBcinXFXDhFQwk4hWkQeYAEJzmpKUexNHADdCZDYgBHORBI2wCRCiSJ7xCTzoCEhhnEbDBIQgGJASCHbABj7XBIfDGHgwHF+zYGmzBDUwkM94AGcTBHlAnJSSCQTyGREiVE3HnJmidrpVFSBCUpn4CMuTQsZxQN/qf2WXTfHLZ9JzDfT6rDoLJPrhDOG3DNByDK8zGzCBMnvTS/YTlzxTCH/BBcADKGqAl4iWTsVrW9OAlXWbomE0bNd6tAGojOWJZOWpZ+Xhjl9ltZ8SDOFADuYKCFVgBHPyrFlDBu36B5NIrF0huvdprFQL/JL6SwRiQgRUE7OGB7haM7kACgRiKIRDcQHQ97Ma5mWyygGpegRnAASFY4nz05Le9AjAwwzUwAzCkwiisQi/8RDEAQy/ohC2Qws8ogiMIguC1AR/sgYOqQQ/AAAzQAEzKgSCQJyVIgk6mBEmkQipI1SVkQtAO6FksQQm8gi2QiqY+wihYg9KW1WahKtQ6bTYtK1566JfhJzxQFtxtqzpoQ0BhXW5Mwq7xGtnyamEEQiD0VaAYzQYmB6KYwABumTiQQzmo1pd92Vy6lmtV42pNa3tqVgACrvlsmStG2TZyBj1RAzYcwx2IQQ+YQaDpgBhcwRns8A7L62fuI5MaaeZq/+4Gjq5Akm7BGmTCFhpqUmnrWpebaRcQ1GwhWIJO0oIt9AIwvIIoDO/c7BAPhXHvJsNHZIIiCIKDDmMg6A+fToHpwoFMUsLBiEL4vof4Aq8mHAQnQIIKeMVFkoItiEK3ZQLiBAOHUIwrkgMo3a+Hyaf9sgMI02X/Putm/Ns+aIxrDMMpHE+SeMKViMKt6lLf8RXgWeAaEI2EJscynhYGp5Yru/IGZzBqvfI0jrDUmtNmncPUmhUAokPG+G076PIrzuU61oPhwjAr1AAPDKTj1EDA8nAPc8EZcEEZUDMXkME1e+a9EjHpbsERjy7iHc3BFtoNwFmVWml1OazqXkEZxP9aJHjCSvTCLmgx8fKusODNNUhDGDPDT9hCJjiCjQ3GIiiCIgBHHJCB+E2nHCOMTt6xRYivKpQCKLOISr0cBAhBRhgPd1ICwzBDqG6SO4xDKWmYxWSYI+evBm+ZaFEtB9MlaIDrv92Da+RCgFqCKKxCTKBCJ0Dgk5Cb36lxBV4gGpwyF6SlcrTAPdkyaZUWOmRwOKg0K9tyiJ6DK5qqs1HPxbDDPagJVT+lYPol3GWDNCDCDFSuceWrGayBGqhBGrS1W3sBXHtBFmiBF6SBNWMzF2gBF2DBFuj16DqBE0yBYE8BEhS2ExR2YfdAD/BAoW3XlS7ao9nADxwXHhBCzqz/BBbPwi5AzIVYRZfo0A4xAzEIA08kQzH4Qi/YwiugAiXMwRycwR7gAR7sgSDoQR7ggRqsgRz8wSIkRmOEQqZYHUmkti2swoD6AQKwVFeIhU6sQilsAiUwAuO4gjbIg4yeRj1wq7J+tSh9k3eHgzmEg3d39cWU4/kY4D1kgzKcAuIwAk4XbyuEgrgB408DdR2YcuV+gRtT6AlEsmidFjlAdTg8NTqQQ1SXw7RqltMym/esIxB+tbJd1j30gzvMQy7UwA10ATVDYby6dRrUtYfDdRaMeBZ4gRac+IljgYqvuIpHAY8O9mEjdmIvNg8wtio/9pYGQRjAMSI0QiZgSUZg/zEwGAMzdLY2zMM0cAiGYMUu7IIvqMIqwEIsxERGoEImoO0aPPDSLR0j6sEezAEfDIJhlCdwp4JwY2IvrLYnIHfxtZRXYELxpoJkJM4dhEEfLIM6YFno6cM5jJafKxtYkVP/MVvapcM5GuA/rM8wjALi6O5P9EIp7OLOTAIkDPQg1BggBDUGEl67AZk0lsN/E3iBhwM4DHioE3iAq3R7Brqgj9UnAaaaCGaEXwyY0IM1PMIHsEC8/lm+xmtc/3pdy3VcS0ETpDiLRwGLr/joToESKEGMI7Zi13g5MzGdPVo6A8Fx6YFh2HT7se/xUkuRW4U1KAM09G4x1EKa2wJre/8C1Wns8RbDK0yCAwv0Ijjiz/DBjdHkIzDCI/gaRYwEJqp2/C1A8SFfVyyBJxRDL2BqdD+UDpwCNmzD+OSbPoyDn4/WeJNTNQn6oIdS2m3jKYnJZ3RDLRnOK0BMMvhCKZQvBOpVuWF6BbaBzLeBfv/YodDTBht4OHyDn4vTgO/8NwA4gK80X34Sx4OSWGVTVrcDEOqy3OZlaMzDMVyRN4vmEsYriZf4r5N4XM+1FiQ7smNBFIx92G8BsysBtCs2jZez6irslUIs0ikddW6CKPy7uxeDT4D7hTjFD/mCKXRET4bEe9dEMSRDL3jCL9oPnzCi3x1CJFgCvz9Go/oa1Yn/r2qjAiZAAEsJgMGzlyekuSdkgnRL0UIdQzaAgzvsW5/T5ZZlvDZtPMeX3bOBmDa+EoUnOjY0Qy58QirsbjLQAoPl6nzTWKUPIyDcdxvcN6e7WyyLw89/Q9APOPRDvzdUvzdE/88PeKl/U+w7cqCv4/QwVoFn6JblGz1owyjEXgggwRU41+hygRRkvfyLOFyngbGvOLKTvf4jQWCjvdrTOEDwEHjjRo4bNGjMULhwho0fZMzACSOHUCJJm0i9emXLF7BixowlE5mMmTRmyYiR9FXs1y5gzEAWk/kqlCVOliJBWnSIJ6RDiRhV8nXy06NHlz6NMjVqFSlMKQgICBAA/0AAAhCW+CHlSVIiPW/uvAkTpkYladHc9dOn79w5cujgwh03ly43u+bwmlO39y7everYtRPc7p27eP0Q2zOnrZmsUal69Sq16RKlTJgwTbKEcxEkn4cG/akzek6bNV+cIOEhjrW4cK+/xQ7n7Vs126+90X4d7ttucOBe5xWu92/xc+3Ynat3D947dO+gO4f7r948aHc+eMhw5UqYK06cbNkiRUoW8+ezeFFv3ksaLVqwxI8fhX4S+/eRIJmiRDWPHgIBJAghhBZigYUVEESQBYVCWGFBG8zAow8JETHKqEoqMSqpWIxZxpprrDGJmWVGXGYkY3x5pZSaduLJj0MWof+EklJI6iXDCyv55JOtwECAAAKoquqqEoTArBA5wnrjDTGCqKGGXLABZx+12norLnToqosb4YrrizjABhOsMMQQu4eebpRxBRRQROnkkkouwgyTzSap0zPQAhFNtNJOS601177JzRveaqsmNkGrGVTQ3b75DRy7thzuy7/aSo4ce/pxTtMrqdPmlhVC8KABK6zgbgoqtuCCPPRWTQ+9LOSTr777kjDC1vxw7UFXAHkQcEACFTLwQAcXCsHYFWi4ogwzuhtLDLGWhAOOZ+9ApBJTcCHpw2tADJEZZUYqppdUOInkEM8giYQSTToZZUULMcQwE08gKQECH6WaigAESlD/YU494IjjjSDCMMOKA+9Qhpp3EGPH4YflyrIuSc2JdFJ23BmMnecQmxIxedBkRd5MLrmEE04w28ySOie5c5BAAAFkT9O6oOJP3nKbrVDbdrbNG5/Dcc3RbyCFFK8ti8MrOeTCgSdT6K6ESx96tHmkQQcagAIKIJBwAlVVyzOPvCbEdlWKJrCgT+1Z7bP1Vlzz+49XX31NiCGGEDp2BmXRiCMIMsIgOIxnrbjhCiDIKMMGK97o45FPWOEFGWi00Ybba6SBhkQTeyHFM8w48YQUUkQpXcZHMNQkE5TBkKEEe30Ecl8I/HVEjzjMKKOMsXRg4YMPXJmGG336Sa6tKsmR/1hL4bz8kh3oNIaLzOnr0YaYU1TPxBKTT5Zzs8zuxHMQQEgz7YubAzXUtvVj47nQRmNrFDjXiq64fnXWyV+db85JDrp49iGOcryFHOFATnWWcYcx8IAFIfjB1nqgHy5sIQvksaAFX0We+UQhbVGwjwdrZQT7pCY//JEbr3pFAwHdjYW/ssEV+iYHPOBhDnKQYR7yICE+zFAPepgDHpB0hz44bkPCINE1Klc5bjFDFHKwQxXcAAlMeAIVnpiiJzZBiUpYxhOe8IMbluAGP4xxCRD40b6WcAg8xCEOa0CDGczwhjGwoAY6qIQ15kG8c5jDeMY73jmytI1tFG1LSCvOxv+ik5znPac577CHPepBj2kEoyiNKAQfNrEJlLEsEpPIiU8G8bI8le80NxMUOHYWv54ZKjaOCgdwwtE8Sf3FHOA43nPSsY94iAMd8HhOO7Ixj26w4g1kwMGBHpiE/ExBPBe84KsqKIUNru0+brMP3OKGwoHcwAYHUQiwWDgDhAAhImy0IRDlEIcZrvOcQLzdDXmICElUQhOjkEUwSGK5axQjET5gggxkIAQZVMEPn/NEKOgZClFgAhJj9IMdDsFQPyyhBD+CACT4EIewoOGNcQyDQhiXi27QQx97Ycdc/pjSthCyfnrJy8bKAZdKITI6j3SaOaaRi0pYMhFY3ARmWFb/p5zsJJTjI+UXytEaQXkDlbERpCB71r5WgsM1szEaxYZjS3JYKR0AFAd0wMEOeZjDOn14wxVggKBkLpMKTjhCE5wZtmiObYP38aDb8Bo3XZ0QhTggyEF+FU5x0uCFEZEWHNYgLTcGzJxsZOMbDiuHOUyWDnvYgx6GeKFRxGIlr2ADCSAAARGoIIxuECMkPPEKYYhEGJroAx8KgQpUvAIVDf1iCRAABjUq6Q1m4KhHF/QDHTwCGvOoh/7yMlM/tkVSLc1LOMghwAGio3/9c1g76tGcfuyDHss4RSUYwYhMdi8zlsiMJ3UCmlCKpg58Siprfsaz9dkGquxrH89g+Zqr//oFq1oNB1zKAcABJo8d5uiGNnIxuBzQQK1QKKESwPPWsMW1CRU+W10/WCsiECGvfNVmr3CAAxX+1ZuBHawNgKAsOKIBDnCE47JYLC3e5s6wcGjDjedABzrgIQ99IMQQ+1CySTzhAQjg1xJKa9oxsuESxrAGNqAhDFvEwhYiWYYvbEHbrdgBEoXAw4x/q6QF1UAMYWBFN+YxKXUAUqXMPRpL6+cW1sSUug7rH3bhAQ8A7oMd2UjGKDK0iU5ocpPmPe9QefIy9pbmT/GdbzWeuo1Hs3K+OYulc/eLF3AMMGisSUc/4DEXeqiDGtiwRiV0YAUbzACZRHgwEoYg4WhWmP/Wb4WrFDgIQhFGwVYb5rARXO3hvobYrzYwtrF/lWwapDhxK26xi6HdUTIE4Qpk4GjA5CBjOKwTD3B4gwwLYYcYLCB2WHHouZmcjGmsW5/SwJw0pCGSLFfREWZVUu50VwaxIGgGPwhDwoTp0rxwo83neCohB1m/18xZgM+Rzjv0HI/DIIYe2CAGoEEx6NWhzNBCHWqLFD0aU0460pOGX6VzA2fnmuOV4ijge8vBsOSsY5DdMMZYfmCDBOWACBFEAn9ibeGz0Xpst8Y129rWa18HW9gAIjYOjo2QbgJW2TlQMbTJQIZqk0E8W9C618XDBbGzOA7SukOScLcCDZyACW7/EMK9jDy7rHjGoW4QRUmwMQ19cgsblmNGMXzRilR0ghJ66Hbusg64sSjoBmHQwSew0Q15qCMvlD+exCJ9cEEWEi8Ll245Yh6XdIz+HfH4xz/UUo9JfkITmiD06uQEVPSGL+QjVx99nzppSKM85dyItMq5wRvXCLA15OiHYLYRTGt8ogZWqIHOG5QDHuzA50MYgq2OYOvs39rCFaZVCPEKbF/v9cNPD3HUCWtsqv/qBsweyxWCkAP5A0H+VveBD7rwhSlMYYLLwrdhHS8IaEADFqAAKQDufAQBIKBfwqigbIsTeqEYlIEZSgJETM1bksEXYmHwJGEP4uCNFC9wgiAI/xpkBX7gB2ogDIJBG7ohaZgH+Hzv4N7sNaIL9MohHWzwBkevq/ShHohnH+Ahp0DB9TyBEwgNZeTEkyLhkxLtD/4A9OBLUHbmqahB9+YrUHYDUjLvLmJwkL5h+N6Ll+7hHO7BwLThGHSgBn5AIUBlBXpgB+AwP7LP14zgrbav6JrgCESoVtpmw/ZQ/DZsr/iKBgQCB3jAr/7q2GwAIaguxAbEBupP/mzg+WyA2IBgC74ADNygClKgA1Lg/riD2l7MSRhsAgrQyOLOovilBJCsAR2QE0RBFXahGEgCc66BAv/OF2CBA/dADtiAC8og6wJHB3QgAxpkBqDASR7hyb7EHP+yYeDsYi7eDFK+YRuIJhxqiRuAI7rmDAdt0Bu7qh588B8+rR6kQRaGsBNOpgjJ69DQK9ECgQ8KCDbiK36s8B4TZVAIiWKMpjcWDvTI4R7uQR/uIRuw4RpGYQZuAA656QTh8Newzwis4IPi4z3S5vuSzm1+rQ97jgeA4ITkjyAk8dgIQhFpAAZQEupywAZ4YNm4g+d+oP28zQzY4LQuYRFA4AJEQAFpJwZWUgcgEQhwIGDgAAdIoANQQAVIC3ZC63VIqxXFaIzS5RI6oRRWwSWSgUROohg2MBQuIRHmAA2WpczGglSsIAzMEgpOsAZugQXZ4fTEcS5+QxtRamh+gwb/gQOWCGgeXS4unKMG44GR7EHi2qEbmsEVNEFGHKEQCAEJV2ZlljASiOpl5HGrdiM37BEfH22piGYfh6No/PE3AFIg+2EusCGBFBIOVXM1OYzDakVrJpI+OkhtaCX8gA2vxu8QQ6xXIhESV9LYesUkUxIIUMw3U2wLpoAQY8AH2EAOAsEPVKAE7GAFbmAQwIgVw6gKYGAG6mgRceC3YGAESEAFhECMmHIB+0UIWjHJ7AC2GGFdQsEUYCECZSJFUsErE0EO0IAMyJJUtAYKrIAYdeAEb6AG+oAZsEEeTq8H2+I1tgEc6KKpZAO6doMG59FCCQguNAXiSK8w4gEezkQZ/75rpxihEE4mE7QHMpcQ5AqhEJLKMnEjNzTT5KZw84Bv8xrllaBrHMBhLfrhHuTBGlzhA2pgNY30IV2TCE4QCvaQ15KAgy7yD0XINjdsBzqS2AyiICJxJIUyB4gNEnHgJ3Ug/oJAB4AABmKgCMhTCNh0tESrEd4ADbrID+zFtCChDiYR2XAg67bABcQzBoRAE3FLAV/HKdcTyTRRsigEdTpBFFJhFVYhFVKBFDrBEhIBD9CgO8p0QE9QuDqVQGvgA07BGrLBB9fiHLCxYhyFlVTJHys0aCZ0qyxzq0QvHaAHOvLMTCwO0OCkEU4URTcjMhdhWA+hRVljHgNFCmf0Hv9/TwvhzJVeaRyMrx8g6TSxowb+6kgfEvt2oFN3jdeMAErvSteSTsOI4CH/A0u3tDdRLMSA4F3pLweCABKLUyi/QKD+CbcIoFBLQAQcQRJ8QAb8ABOikxU9Y3eeDyGuYAuAwAU6wBNlAMngjl9fRz3X8wnYILECRkL6oEIq4RJaTxMqoxH4QA7MIMUE9AQd4lNB9QN04Bgiz1RR9c14lJV+I36WalBeFbpkVVbjIql+SRyhgx2qAxsoaYsc4WQ4AUXnxOMiwREWwVgb7b5ydqkerVXjp1nt4uCM5i5fA6XIZB2sIRd+B1sJQjUXclvdBg6XNC3NMi1D6Nc2TMNU80r/33VdJbH+hNIS73ZvcaAIhIAJwAAMPIMCUBEC6LRQmzMGVKAKPMENSMsNMCMQyqA7k2ULfOAFOAApU0Bim5JiLbYVmQAYy2AMIIux8KCHVJfHTJYMgOAGylQRuclJaJd2f+eOsCGP+iE4tNBGt3ZnFsVCd4NWaRUdchAuAkOR2EEt6OEZcuETtkhpmVZllBBqQ+lPWCNGLW02rNa+7KsatZZr7wKVdHZLzoFMzMEaHiEDPoDEtLU14feBYPNt6ddc4Zdu0VU3w7T+/uo35c8j4fVdcQAIiqAImCB0y4gVB0qMVMDIQgsBBIAPPKEXrMgNuoiKumgNcgAore4KcKAF/zgAA0igc9+OUEH3UJlACbYucRJnWcpADMpsSQLnILZzJZ2EILCVdrmzBhQiA9j3F1iwHnb30rY24bSwZ4IXHWDUSnjWeG1QpvZIHbCLTOqhGURGE5R2aedEZSITag8Be1tjZw8FUawwa7ewCwmJfLHRLtQBMeoBG4ahBjLAA9wXbdMWSenQVubXCv6TVOJWI4HNSHnAS0OMxPBW+iLoXYvg/u7vCaqATYWAFUPLDVChDjY3doIkAWTLFlABE8aIimTrFSChDK5gEbnjg0N4hJdABe4FPfn1KZFMBnwA6owtB4Ag/XLgB0bwB5jlBxZsIWy4dgvUSRSCh2fAARiAAf8QgRm0gR6G2H56t+Q2c3gvlFZ5tmfhYqvGYUvWoR22ax/2oRuQYRTYRXpTVHsoQRJWdBHAOHsrlDaSVUZp1Iy3UPOeahywsPJQL30/wYczgMTu+GxX0wiQVI8B1D8PeiIBcenOdTULgtgMeUtrGV4ZWQZGoAMsVj0LFSs8wQAA4KNBGgAEAA1IQTIoOCoxARWyzBO+4F0v1wdcIITFM5JNmGJheQlkYDu/yZZX4JvSjwbQwDuuYMEQghiPzWx1mDsVIpkd4ANyQRvM4ZkBaZu78KnuC2hgg5qLN5uhS4llNYrP4R90aR/uYVc/YdBOdE6AlRLWuZ3DGDYOBb7Wx9H/7CvztDYGuWEcdkOf9WEeruEOVsAD6BigtdVKN9II1DKh+fg/mfQ2A3kHlA5tvZQG9hdvg7KUcQBNBUoEMGABopNNsZOiIIBN/WAS2FQFLmABUAATItAjXgGMVhkSZMsT6oAGFqwMkPMELkACOsBNTVgpKxYqwaAIaHmiuaPZDEtJdsc7SEVABdTYapeYZyAEPuAHrKAStCGP4CEcAmMc6qGqc499EsUftypWi3er3yKmyIEd1EEe6sEeRo8c5GEahgEU6GkTJIERojZFKcGThrWdvcGdK1QccraMwdeuiybS4IeIuSGSuiEYeidU7PiOjzSP51d++1ih5dYPxU+y/9V1/npTb4tABjQRAzCgXxYwktcTtxpYAFJAAgDVDZgAEiLwJIABFRJXBPwgtWqLDLjgBvZTCU4ghEVABJhSKU+bPKHyCXzgNyc6xboDuQeHLIPgBJ2bGDs1up3kA3paDO6AF+aBHtbhHCAUpczBiH2vNuTHQtHBvHnDSt4iOgAsHRxGHuSBHu5h9MKhHuTBeT9hCGUkERIBWCHzv8E4wIuPBgncZ+j6anHvjKuaVY2YHuZBGyqhBhron3eAsAvbsCUSoTPcj8OPw6uUIfG2/db1EnEgYul0AUXADUSAdg7VXlixKgQgXxBABVJLI6oIExJ4xzUCErbgjeRgDbggpv910siNjEgyOnTdAAyYgP4UURHHVHBCkHeA8qhv+AZQUMs/YEHO0izmIRvUAULdwZbYwVGGZs21mlah5rw19GdHzx3s/M6zCy7sQR6gQRZYD04SIRJSpr9X1K3/5ELlWZ7x0a4V3hpbqWgqPRneQAdA5Z8BmsKNVPw+nY/p9yzDAPw83lzhcJC3VCRTHQcOeKIqVgjIk1CRjCmzAgJC+qNlYNdJQbZwXD39YLZsgRP2AA7IIJ2+4AUogAKMvJXX9FCRrAqYoMmnXRE3eAQFZyw29cpTdhJpd5hr4BhrQElkQRuwgeDo4qQo9DXU/VWJ12ejA2oczuEKwx3cAR/EkR7/5OEe7OEd0qEd5oEZWAF609kRUiZYl/BCMZQGCSVZZ2OurZAaFJ8aFl587cJRuOHARqEGrmAFPkDTGbLT5/Y2N37jPX7UG3rTR9LY3NVLAxgI2MAOWh4qWzm0yBPuFhA6Yx4BdtzmQ5leCmq2KLhk46CH5sAHKCACMOCBaeemL7YIeCDnmr6WN1gHuOP9NnUEh1FA1fKGQTXrZ2AF6igMEGEZtCEbUAkc0AE5jDdqouZh2KGRcBUeIEkgxVEg2X8fHkkgF1Qf5KEd9OEf4qGvu8G7RDYTAGIRJkyWClqKFIkcuXAMFS78xjBiOG8RvVWrZvGixovUOlLbBjKkyG3c/0Bm2waOITdtzO5YocEiQ4YbO3bcuFmTSM2cRIwkMdLTitChQ6EYNYLUZ1IiTHfusAEESA4bVHHgkHo1alROpNyIKLFkSQkVIgIQQIAAAgQBAcyKcOMmAIC5ACB4etULld5XrzxB8oSJlCdUogjpgUOI0B80HCJAQIugxFghYSuHZeLjxg+qOqba2JwjdA4dQa78+BEkCOnUOlq7Pg379I0aNVbMWFHjhxgdo65124YOnb129+LFS5fuHbzl8N45b1evXjt71PtZ72fv3j192vVx/7fvXvbr4fXRo6fPXr9685oZG0WJUqSBBg8mdIjfmzeIC8P1Z6jfRfoNOGBHG/+NJFJJ22STTTjiiLOSLFac4cIKMtFk000YOsXUUkYURZQVRkGBVE8/LdVUTTlEtaJULbaoFRClvIKKCBCINdYSCAgAgFkE0NUjWDzOhYAfqPCl15GoRDKHI6SgQsorpPChRx6IIBIIGx1ggIFaEJQgRJiWVSaEZj/oYENnOZxmg2ihsbjiFakFcSZrrYkYm2w3hBCCba3NEAYv2nDDDjvwrFPcccbFs88+zMGjnXTUZRdpPdtx550+//ij3T302GOcO+74gw890m1HjzLM7ALKJJMMNIlBCDmIn0Lf3OofQw+KI5FFBBJ40TbVIEjsgtzQao41j/xQBg0hZMDADzv/aejUDkwxdeKHRv0wxhhiiFFUUj5liyJTMLIIBA7nAnFFKDSCIUBkS/gBiRBklfAVvg8gQAABJaAwVwAiYDKYX36ckAMLM1Qyii22HEkKIX0g0ogjh7BBgZeSgTVmZU/4QAMUZ7YZ2g9QkOwmEEEAkedpOlihQ2wimyzyDj/0OUMNn+X8iDXZjDMOO+uw8w5y6RjXaKf//NOPeEs//U+mUnt3jz//eFpPP/vE08+o+eBTj3fszZNMMrBkEgknBMkaSTnplLOrOHCLQ1E431z04EQbCRigRtt8VCxI3HBjTz3rmNPcOPMME4YYVzz+g5mncbjTtUqNm1QSmlthBInj/2peYoc6WavTDTbckEMPOfCw+uo8vM46J6KQEgmPYPnhiRs5qmCvCrsL4ccFO1YBlx0nJJBBzncwPAosr8woCiJyEGLJJIGk8MCXGs/rR/dLhMlEDEDQUIPpNNx0us5pUkXVaKq5FjPJP7hZ8un2w38aETrUwEs38vQTNU1dZ4D7GCAAryae60BtgUuT2nX8AUEI3qMf5lCGNJoRjFzgghSZcJUkKCGJRCwiEMiZ29ziFg5w3OocvBrQRn5lkb91BCQzRFDYtPONd2QDG5+ogRjIQIYr9GAHM5PWToByrQ5lTlxJiIITNQdFKIYudKSzCexgd4MeXPF1ObhEKFLRi/8Y1KV7A/FDWCgTFjeEDwWeIMVACFYwVGCCEY+oRCU+8YlRtGIVpUDFJa6EiOoFAgURwIAI0PKlsHTPD264TBmmgqbTmc4GtEkT/FpjJ/hp5U0u8gzK5qQDowBhf4+ARjY05R2mGXCV1lkaAA/IQKhlCjv2aFQE/eEOfbQjGss4BjEecYpRmKIT9AGhIxaxCOeggxzBWaZC8sYQcJwjheCo5q2qARH/KAQd4DCHOQbHjW+SBJyDM0em4OGNcWQDGW/QgRi2QAYgIIEIeDIiT6qoRHFlLoqg06e4UlSTG2zxdVrcYg4S0YlRSOMVB0CAIiFhRkaa0Q1geMIWSJGXI/H/BS+26IUoKFEJTeRxFKlYxUYzwQhF9KEgfxjBA2x0li9JxjJCUCMarhAGHZgOfZSs5CV/6hp2uUio6IrK4+aUGqHoADeuwAZ6XGnAWCqQlf7oR1UHuLRJNapRANRHdKjhDFfc4Q6f+MUuPvEITrxqEo6IBDKViQ52tIMd20RHOerKjmlKJCX+cSY6zmEOdajjm+T0JmG96R172I0a2DhFGN4whsfJk55WmBzpRpeinvTkcj/hZxQ/l61rTYsHPSjoFUuL2h7IQRKPYEYvuIAA3t3Od94DAxMs8QpgAMMWsHBYL367W1F0QhSj0GMvipGMYkiJE5RgRCAnIQcOLEAt/4jcWI6W4AY/MGELOsgp+1jnMqCK1wqSjZNkY6SVMKgXqUv9wB2WMQ96MG2rXGVl0+zBwFbGEmr07ao86rGNaDjjFH34xC2EkYxTmCIWoLhEJqo3iUhYSjqCVYdcmfMOd8QDHoYT7DrWMVe5tiPEclXHhwdr2AqrWB1h64c4vjGNZdzhsWMowxbKoMWf6KllsPEc5kDr2ShGQYqazQlpSws71CJhyUxegx7uYItSXEICGFCBWjgGUQQ8ABK2SMYuiuELVZi0o7+NckJh8YtiGCMZzAAGKYSbCUT0QRKRWENjqCtT64oJDGwwwxv+/K3HfUso6i10GIaiXhEZhbznff+co88bFSsYek4f6NMptDGP+SrtaVTrzg27I7VOeeo83oFgVKOmjm5EoxnNQIYrkrFmV7hiGdb4BSg6sYkQJuJSFP5wdKhD3w6bGMQjLvaIoyOPZMvjw8xuNrNbXA5qTEMWNXhDGMxgBiD2YMlGiJyGNHSaEfk4yJ4dsuacaG6gIKUmqUVyu5WMhC+gIQiaAAYqfACBr6jFjCrgHSpsAeZTGEMXYrYFXnph8FXIQhjHKNsymOHaUgj3EpRoRPW+oAHH8Eum+ZKMCtxgh0LooQ93iIPJTQ4HOPxZ5Wfo1re+legisusKMcrBox9tFDkhNQOVfkMy5qEPWEKtH1Q7j6n/6oGesEUH2ck2uqn0YWqsRq0eYCUGMZRxjGAQgxeyQMY85mGNW3xCE5aIz9ModY+li6dR/HCHsaGj9kptR9l0l8eKKxy2eHyDGsp4RLWxHYYrIOFxSADKtMBNs6MgpZ/ZOrfjx/XEn2yWKUx+d7uR4AQqsIENNPC5LRaRAsosUgZuaGNHfaELVhjjF63YhW51WwxgIHgZ0LCGNm4vDWHAIhWiEK4kOGEJH0wgY2ixrp4PcYhE6OFKfdCDHvaQhzzM4eRxSLnKAQ3zRAtl0Fbg/su75XIxlKEMYii0TELAglE4FYGi1o7R647KAIot7vToVKMWxTVIcaPVucgFMmD9/wuucAzS8HXdsAysoAmXIAmO8DT3wGmdIkD8EB7tNzXccSlOd3TnsXROl3fggA3BQBtkkG0/gAVIEE+Fh0REkCdQoGics3gn0nhRgAUzOGSLV4OSJ3lEwGRIYHlMtgVcsAaH8AdxYAOrkAyhYAfzAgmQgAmiAHCssAuodwuyYAzFEIXFIAxr9nDMcA3XgGlfpw3QkAy/oAoSp4Bq5QMX0CVnYXwb4waQgBCN0AjO1Qd9sAd3CH14oIdycHIp92dnAIhvAIhnoAaFmHLUFwdyIAdzwIjUd31vkAF9UgN34HXRkXb18F9Np2zdkGryUH8YCIp053TUwWH0IA/KMAzDkP8LpzAMwaALsuALDCcN1iANzOALoaCAjQBVCpQp2lFAB9R+2tGA3eGJRod0ouh03rEePKQz2FYGZIAFTgBPTmB4JsNjsAFkUmQEkWduQVYuBYVkR3YTPIAEP7gGcyAHhSAHOoAIttAJcFBTfkAwCkcMueAKp6AKpwAKscCPu6B1yEBrt6cN3fB186AN1iCGxQALErcJloAJkOADHWAjadGGYHIIi2AJIcQIjXAldDgxhJAHdViHhIAHfSAxzieSI5kYK3mHhICH0Rd9eogHixgHb6ByKYcHdzAKmHZ0SId051GQQSmUQkmQBdkN0gANy6AMyOBLwcALucALrjAKweT/CrmgC7sQC6/QB28wViR3B5TQCZywCZpSQPzAD61kgcLYNJu2X0tTjBpoinWnbJkyDy0xAzTgjNAojVvgBEnAFNe4LT+wWft0Iugmg+TWT9diedsmUEjABWogB3tQCIRAZzQwA32gCZJgB0voCZ5gCsGADLa2j6CgCaagCq1wC6ApDQI5kLeHDbSYlMm1kJ1ACYvgKmDQAY+BAB3ncSUgj5bgYBR3CRRHCcMZH8UJnMfZCJLAnM0pCXK4gI2gCNNpCNWpCNW5khLTfFUifSiXiDnZB8QwkEbZDdqADa+JlM2wlMjQiv0na6dwCp9gR5XwCPU5VnfwZ7ThGm8wn/Q5/wqzAAyr0AvLIgY58GdcSQiXwAmcYCrjsA9tZx2d8mu+WF9Cx0BvCYqg6B300A23UAMswAJm8IxkwJeEdyKACRukw0SdZZhYwI3dSC5EoGRKpgTkCIRzsAeD4AiOIDtfcAArQAmb8BedSQpGuAy0EAozoglLCgq1YAy1R4vW4IWvSYvMsAywFlyW4AiJUAiTUC9bQpEb4zsqsAQE0wlnuglnimuakKadoAmZkAlpegkJmAnGeZwg9EHG5AjSOZ18ep0rKZJ3mAd6aJN6SHJ3hEfyWZ8k92fvsz+0AamRugIfgBs10BrtdKlc2ZWPkEefEEys4Aut4AurcAdlIAdswP8HeMAHV2IJndkN1FAP49APZ3lf56E0q7Q0bHk1b+mJTGeMYfMP7KEsS7UCIkqiWzAFV7AFSAA6KxiY+aNP/GSYMmhuTwRaSVFaO4gESjAF5QiZdCAIixAJlGAJosAJDACkm8AJnTkYtsAMxsBHq0AKitAJsZAM0oCv0KCv+oqQEIelSMJBz1kxlhAII3ABKZBv1sU7QvAXmxAKwnWmoaCmm6AJZ1qnFQunDlanxWmn8eGcOyqdezqdfwqodgh9eWCTelCSiHAHK9AnKwCzMTsDM5szkWqzVNEnLEBvqUAKJdUKrXCPrBCfW5lHwXQKrAAKoVAMtlAJjZAIhxBhZUf/rgsaDOf5M7P6SraqKcMYjJayHdrBq0enbE7ngPWgDcnwBrURAtnGl1OgBMpaeJpTRD0mbuQ2rebmok1krZF3IjyYrdv6g1xwo3TwB4cQCcM5GJhgBo1ACk+yF72QDL5gCqZQC7vgpNJwDfv6DKymlMoAa76we7jYCZ2ZCZKwkY4wCXZgAhSAAiLQbwsLBiDXmREbCqGwCQ47sWpasbiWsXUKpxkbH8TpsQu4oyJLnYZACIignc6nsnFwB3gQkn0gBnzCJ5XGJzGLvbZBszNLAzSAGzOgA6DgC70guaqwC7BwmrXwCStwB48wCngUn+6rCu97u5dQEHhaMZNAidhA/w3nMCr8sDTRkUrsJ2pXUzgSiokZmqFlqw2moAO3kQHP6ARO8LaPs3idE250OxSGCUVO5KJD9kQfzMEc/BM8yGTcKriP2QZzQLiGawmZwBW2ED2dkFu98Hpe5grGwIVdeA1ImZTK4Lm+9IqmAAqV0FyEMLtHjAiFEAlfgAIa0AEk0AGwC3JNKAq1CwpJS7tuqqZd3AmZkICb8LvAW5wbO7zEa7wjmwhXsrw5OVYqmwdyYCEOIBN1nAEegMd57AHUy8ch4AEx+wahsAqqsAKVQAv5SJ9v8AGPgJ/LAwrLEwthlgq4WHGNYBh9MKh6UAOVoAzToA7/MCruFzZbWyle2/8pvNp0xmiKC/wP9AANd1ADNPABGXBomKcEW/A4UiQy4rZohHZu3ejBH0yDNHi3M5i3SbCDSnDLXPAFQLjChDsIkkBxbYQKvZCPOgxxzFA2OtyF+NrD1rAMV1qFu9AKRKwJjzAxiIAHejCntCkJbLwIOAACIEACI8ABLxADMvAEdrAIntB7oHDFZ3rFvcfFtYvFblqxS5rQCq0JIVWn94unzFm8frrGgFSH63yfiVgHM9AAB6AADKAACnAADEDSJU3SDYDSDqDSKk3SMvEBb1BHlQALrMAK7xsGk4gIb4AbmoCfYDTJm0AJiOB8cQwHa4AGZgAHNfABCpUN8rAp+XD/D/jQHWd3iZbIHRp4jKacdnGZysY4D7ygUyvgAbQseBRsVOmmgioYBSEiFNkIwh+sBVpgzHMdzMRcwsqszD/4BWewBosIzZKgCGIsCqVAC2vGDLMopT18DQjpw1a6DMYgDORcCrj4znKmByQ5BnfwQfT5CMyXCGhgAi9wAicg2jDgA0xwCP5cCqSQtLULsaRwpkuapg9L0LfmppmwphT7pnU6nGacpxK9pxUznYC0kiX3Z3KwBmvAAgxgAM3t3AdwAAYA3dPt0SFt3dbNAA3gACuACKUACpM7CrdWCSzLCIzAlW5aCaFQCeWdCH2gh3GsiHCQiHBAqXdADARZD5ty/0tR40pDR3QVuLWcVoEbqA3XUAlvEAdbgANTAE9k8EMmegRHwERNAKOIqbcySNcVfm40CEUTvGRTMAUp/AVrsMI5ugiOQAmZIAqpkFuHja/WAOMwjq/aDNm+QAusUApuKgnuTQhy6LFX0giX0AkU57RyyAeFcAUtAAMuAAMC9QV/4AiX0KaaEApxKrFU3glZ3NBnqsUM/aZsCuYPPZzDWXbOGZ1zOLJsLDEvyYhtXpMeoNIK0AAgbdIljdJ3rt10bMfJ44c59aiQ2ho1EAKA0l1l8GciWgaGRgbjB4khoAPv9XVQF0ENFODy51VLh+lSEx2gGJTaQAxbaQZbUAQ4sP8FuKxegocEEa7qEm4Eq34ETQDrHYxuWHDhd3u3tY5uyQzipQ6EfQ2ug2C4Qt6ztFAM2WzsVwpmtIC+o9AJ9GnZeqgHe/pBpssIxWm6lKB8hKCIccAHCgOiPPAFexAJKE6xuOhgaBqxWb6kEWvbun27cfruvD3m9nunEi2H5T3cal6HgtqIdyDfNtAAGXDnH13nc37SeD7nAb/nC58Bel7HHzADPaUz4kUaYeABlVbI1hBfQadKazl/mM7pQzkP3UDyJV/y2iANoxAGd2AGQOADpG7qhJfqr94EES4uEQ7rsS5kfFvrO/9E0zqDyYzXDO7MhBsIfOAIlrAJooAKqwD/cGwGa7HnC7awCqMQCqS53oB0JYnA9R+L4g5GCcmb7Ymwh2VwBTeABIu4BnnAB3naCZLwwhZbscJ1axLrxbH9u2wqxrw9xmR+nMwph2ie79lpstI3ByVXfSEQ8A6Q3Xi+0nfe8HtOxw7P8C79AZdPqTUbBI8FB3cwcvUZUgBdCrYRArSxkwVpdPMgD0U58q55nugJDeqJdcTQnrIga8WFR3Zkn38WB2hQBDDwAqV+6siqBDO/6q2O87Ae4XZr6z4Pwi0ajRPsBCDutig84jiaqoVgcZvwJKtACzbcC7SwCqkw2QkYH84lZ4nA3lyfCBUT3B/U2yGk7XigfHyABlSC/wZ4gAZxsAhyQAOOABCZKF3qg0jSpU6ZOonq1ClUKIYNJTbclCmTpk0ZM1rkaPHSJUuWKFGSJKnRSUeNFClChIjQy5d99uzJkwdOHDxvPGQI4SDDT6BAPwwlGuJDCBYzatTQoSPImzd39LR89KiSJk2gRpUylWoVrFmzaNnqtauXL7RogeG5svNDDVfJeOVy5erUqVGjPn2qVLXPnTthmi41StTw4aFAa7yBc2ULDhwwlGwJcuXKFCdIkBzh3JlzE9BNOBuJUjpJktJRsGBJ3dp169WrS29x4mTL7SlKkCiZzGWNHOB6+CQauKlTRk2XSDJClMh5IT168ugh5DxRIf9Chaw7Z+RI0kBLym3mecmHz5UyaORYRo+HEiOEhvY0EkkpoaZOoBg+FBUK1MTjJkKuI4+UU46kkkxyxJGVWHIJppj2kK4P4X6YYYUZbAgijKjwIIQRRh4pDiJSSEnFq1dgiQUWW1rs5UW0zvIFGBprVMvGtGYUZsccPGCAgQ+CqOGOFYjK4Eckk/yxASabbEBJKJVswCkbrigCBhhcuAKIIIDgrQjNOjPCsyNC6+y11bTQgrXW1IwtNtXcZJO22nDj7c4tuDgDDcvIuCkOOfA4owwrrig0CjLwUBQPOeZwNDrzotOjEEEEKUS77iQRSaRE8CCPD/XIKIMMG2yYgYb/K/DoQw5HNpkJkYEUaigUhySCiFZQcgVQI+Q06eijA0ciqZEFVVqpJWQjjM7DRBxB5ZVXYLyxGGCoLeZabKmt8doat9W2WmyN2XHHbMfd0Rh0d2KggQ0b2OknB6KUlwEF6lVgXnoZOOCAe23IYcsWXogMCIK9VKKIITYjs8zQGmYztdW8WNO1Nd+UU87ZMnNiii2m8PhOJ7jgwgyCrxDVDJT91awHHpDYYo01vvgC5jXQ8NS8SHHmQ7tEGikpJEosYSSOOAgJIwczyMhhBjNsWKFUG9zLpA9GEpEkk4xmrVWi/h7yD8AABayowGBHKqnYY5FtiRCZ9GCkD+gIIeXF/27rpjFbbbnFtttsqxWmGHTRPVfcwAs35hjE421A0Sd/zOBdeCEHyqcMHHCg8XntVWDfdWlgwQUXWogM1YI1GyLhz8yUomHQpKjYNYnZPE01NtNcU87YaEPCNtxy2y1kLsrIAQj2yjCjjJV5uIGHlkXO8zYyyAAuUDxwlnTnRLobSSRNGZEDjR/QqBIIG8iYYYYfaDCjkDwMqY44SfCrdZNQSKlVFPy7zg/sXX0tUFizSQJtx0pbTPrQh5c4BxGvsBuOGpijbk3rWn+7luEsGLhkZFCDGnLEIny0LnfR4HwZsoEIZ8ACFLJgBSFYwQpD8MIQeECGMgwKUGK4AhcUjP9gSCAeEKBQqN2cTmFkYl1oSvMm2dAuNahRjWniVLHYaCFPXOiYxzh2G5GJrAzTw4Ok8FCHOQDHUXMA4xjn0MU9LEo45oEOG7VDLGL97COU0AMcaECDGpAhBEwjgxn0IKo5kGdomWgErWxVIvyZqBSJzF9/8uO1XEWyIb7yFbDqQ5IBFvBBB6yepCjRIl/Uoixo2UWLTHlKVLaIFqusxS5c+Upd6OIXs6TlLHOEC1zoghfBGMYwlCEJT0SCBo/LwJMyYMIZBKGEyBzhCFXYQhd6AIbSjOE0aYADghUBTDwEwg+g8EPNIGEIqetMw6SwOtCcZnYQQyJsagcn2qlpirf/wQ0VpyiyMxANUMBRlKPqAEY8BBIPcYBDo+RANC6yUWeX6llKvBMri1jie2g43wo8EIQV0AAPaFjBDcxAiDi84TiX0IQhb+UQRZaiFKToGku95p//CMhXm6gkSAAoQGM1aG1so1AXl4WIUvSila10pS9SeVRTspKor9xFLGtZyxzdQhe34MUwgoEMa3BCD3goAwo9YLkGmI8F/soB1Mxqg6XcEZnMROGFoLkCFuSgB0DYpmag8AMiGEGvSdCMExgmmr+2bnVlioI62YnE1axzdg+LpxZs47x63lNPaqDZGtoAnN8o6qA42SpUCkpQOPypUWt04xtT8p3wZIITC9lE/yPCkNEZsHAGxyzDFq5AvT4MBCGLXIgjRaFS4HbtpZGMqUwvkomPXBKTKSHgTtuWhy5OBw93oMQqd0GLol73qKtMqiprsVRXxtKpT4WgMHS5y6taQxtEu0LSXMiAEMQBhUCYQQ7sW1az4tesNFimWk91Ks/VFwk80GYPeqCZH/xArwvm62bM9FcIc8Y18EQsE2HDTjV54bFYpGIWs3iGyqrhDCBeg2YBpSg9hJRDoCXoPgO1s9L2TIDfuQTWGiIKUmxCBx5gwU5o6IH6+hEOeiDJJkaCiv3capGNFC4ovpaf4lLEfx4B4HKNpbYI1QTF0oUDHkRBC1hY1xfaReUqx/9iCzPb4rvgbap4n2rLX/hilrrIRTCqKo15rFc9W0DVDC5Xhy2sAAY38IEPmHfoQ9/gjjdgtKIFBgPI0OAFLxAdpV9QaG0iwcDfvGs4Pe3XBz/YM01YJ2OP+CbaITaKapKiPSXrYS5Q1rKVNegaRrYGgpahDFeAghhGfJM/ASoPfeCDcC5lCEV456GXMI5DSoFkS+QgBA24lwI8cAMHpAo42IEVIvTwEIfo51YvJTe4JdLssSG3xjYVlgCZeywIyYQm0F2UouJwhz6sIhZh2cWYzfxvgNNCLErFZS7Fe943v5kXu2zGPLoxjzrIYQpcQAMLQpABNPDBczS4QRFwgIT/3OhG05o2cMkNDBmU4+CakIG0D67kAyCQ3JtQAIKBP+1XIoLmCGMqZ6kPq2rEslroWoDsq7nwhRFTdg4wa1QbmL6GAfMACEuzLxD6eJOBTm/YfRj2zgqBbGV/x8YPQQUqSgQHyx3AABmV4dJoMOQawEFYncBITLFCU0pe5CNY0XtydFu2m5bkJDllSbxnUpM8ACbrB4VDGDQB5lkU9d8DX2VYKq/UWhT84Aif5cJ58YtgBAP0Cw9Gw+dBj3r8cw1OUEJS3oCIHLBAhDboIXu2ZJnhEey+Ce5TGKJnhtCG0WWsP3DuYz7gA+9GCVcYYjmlUM7QSOHnWBg6q1WdatxB/xbWIvuCGryvBlHBDAmEptkUgAAZHtCAB3kyw2++ByjQSgWBMAH7jIvjEFF4haVwaEDlDnDtx/GAXQutGyAEklAE5viOkmCORmCEkwCRwQs7h0oQkxg8BwQREHEOQnCQTZqJw8sDR7mDe4ODN0ADE3yDILgDUwCL7/KFypuFW4hBGZQFGazBWyi4XMqFXDivhfsFzyO90Fs4ZNCGeZAHfdCHP2iDL9idPbgERtCBGrABHXgD3zsxVYGb5vCZ4jCO+lEpFHkFF+kFUhgDKxiDH7C5musrm9uNcGIYzkCCJqCCI3CwczqnKLCCKBADLNBDMdCCMfBDQByDPRxEPUw1JP96Hlj7ApFZA+8bsTKoGRAYAAAIgASAgSGQGS4gA9vaAjSgmTbgAo6zgjBYCh3ANwhBNmJZNoWAiFdAhVUQhTi4nAywNgW4HBYwGQwRgz3oMjmoiZYoCEIgDwQyBEQwBEZAwAY5RkRAwGUsvJ2iP0IQBJg4IHlDPBCcgxYLrTc4g+M5HsGoBFiAhczDhbCwwRiUBXS0QRqMQR1sRx38QfQaBmIghmNABmRQBiKUh3o4wl47Az3ohFbMivohhbL7wnCMhX87pReRkYVUC2yJBCdYGhbYgR0ggrzSq53zNIapjdroq9qgApB0ApDcAisQA1EsSStISTEYgzAoyTFYSZj/FAOZNMkxqMmXrMnt8zCZkZmaARQYCAAACMqgDIAJeIEysEIxwoEieAEWqoEPAJK3SMEPiSOL4ASswTFSWIVXOBGzi4MA3Bwm+Ql3OSYaKKsU85DomL/qMISvSwRFcEuVQBsGUQRDqEu7vEtCsEtphAmamAM6oIO+DCMWCy2CegMzQAP+goNU2IVfmEdXYAVXkAVXuAW6kAUdvIV0ZAUaJD1kIAZlUIZmCE1niAZpeIZpmAZsSE1s0AYidDh1MIdsoAZqKKlUIIuFvM1eQKVSMqXrYirfbMhZupZXmIMtuIEaYAGLTM7kHLXQ4MjM2J2PDEmRdIKZDIPqtE6ZxM6Z/9xOMcBOm7TJnMyinYQZE0QDAxBKoSwAC9iAFZCDFJODglIDHnABGGCBMHhKJBkKBnCAMFgQS5gETLAETlit+im7RWKpH/AJBaC2I2ESD7AoM0AV6amULkIg6ZiUQKiUQBiEDR2Eu/xQENXLShEED/RAR/nLwNws4GgDYDNMNLAvHXiEYkiGz5xHe7zH0LQGa1iGZWAGZqALZYCGZcDHbkC9fawHepAHenC4bmhSJ33S1+SG2KSGVxoz37xSpEKlhWQqtAjOYrgEMpgCEUJOi1ywMsXI1OlIT9sdkKQCkaQCkszO69RO7pzT7fzO8BTPmamZOuAA9AxKAXgAC2gAEP8QnuOBg5K8EBb4gRVQkqccAEiFryk4hEmo1FWEiJV6tlCogRWgDkLAAzi4kB+jAeAwA0Y5KPIIxukQhD9o1REVhEAQ0boUhA99VRItUQ+8xhPV1YHaJ9AiQTRQAxoAgikMBtbMsyZVh3qQB3VYUm2QBh1VhlNQBmmYBmWIBnq4B33oB261B3hoh3ZQB3EdV3IVV3OQ0inFBVfKvLQIr4PbzSwNw7LQhaKipWKgBTkgg/RLigVbsNHw1854zjV9U5Dsgi7ggpIMA+1U2IWl0+10WPDMU+4jTzYYgAAASoxNgAVYgAcAARzogZrhEzGogR/g1CTRT4sNAIsdAANQAB7/2INBiITvwL/8sZ9OYCmWEoVMsARCeIMZ8AD0CAIzUNgyCCQP5ANB4INW3YM/GNFYDVFbvdUS/UsUDUy/pAMzUlHg+FWYoYEfcIpPuIZ5KEJ5aId3gId3YAd1mAdsQM1ncIVhSM1mcIZ1aId+iId+2Id4iAdvbYd1kIdz5QZuMIdxZdZznVJqAK81u1LteiWkYqpYeiVaAgZN8L0bqM8bWBjQ4LnUkQKB3R2P5MiRTNiGVdjsdNg6fUmVHAOJnSJZe4GLjV0AQIAHiIAJqAAQsEQq4AEWKE6lCAEkOQCoTNkEUAADGAABEABIPQAaKASPwNT84Q/8OQ6BkARGAFUz/wgCMRiyNwikmtiDpGVaD4xaWp1VqcXVqaVaa9RVM9Kn6WE8OPC+pFiMNxiG0xsHd3AHdviGd9AHc4iGaGhbHTzNZlCGbagHeHCHfchbd0AHdGAHwTWHdVgHc6jg1zQHZpXStj1NK3WlshCqK/2uV6oFNLOFXWCzNiMvWwgMIOABGDihItpcNG2CcxpY59SYjizJ7qxO7jTdOpVJlzRJl+Sw8DwDymqDCUjeABCAACCACHgACrAAC4CBIuiCIfAJH3GARjUAtYPKA7jYAeAAlk2AA7DYoVSAHDAER5AVhcAIvPMf5RCgquGTODgDUO1FD4yOPPgDD2xaqX1V8J0JwP9EXw9UX8Qzo/Z131MNLUZkAaZ4Ax2oBGiYh3twB289B3owh9CUBm1ABldwhm7IBmWgBn08wn/oB3t4B3ClYMKdYHK1YNikhtM8zbMAhhiRFl9YSDU7OHV9pV6GXMbMEV8IBR0Qg5oToRVIHZ0TE+i7uensSI5EAu5U3ZlMSR2eyZqs5muWyTHYmCuyJw9LujVYgAIQAAIgAAFYAAnAgAeYABK4tCJQIX0Bkgxg2X1B2UmsAIstAJUtgDLG2ABo2R4ohIf6DpLQhEpI6CojhEaAT5wAwTwI5JrQA0Iu0UrB1apFX6qlA2tEZERGKBMLLTiAq8UAjFw4PX2oByRlW9D/1AZlcIUhnIdmwFZ9XAeVrgdxlQed3ml1UNsLrmANnuXTtGVhzpEPdtfNEy+Dy6VfcKU4S4te6AMbCIMr2NcVyCsaHiwjOKdlfkPojE7ppIIucFM/fMmYhElrFuIf/iaXrElNpKecPIMsSgMH2JcDOGcKuIALwAAKOAEfGAIY6IEeU6EMOF6WBRIGkERKPAAA8GcBKICULQB+nkSV/b8pEIRIoATvuAi/OxBEcATm6AM44Lp5mwlIGeSKPt/zxeiN5uiaQGT2xcYT04PNIigU+oGouINHmOQlzTNsgIZmkAZp4CWHiwZQfrgmHdtk3WmdVod2WNZ1+OlsyAahPs2w/7ju6w7HWYCFVujuyERH8A5v8ZYFakELWngRUXAK4kECIkgCLCgizW1OsC5YN73hPZzml2TrtrZJkwRia8bOt94+erqnLqjrA5DsAoiABaAAClgAEKBP3t2BGpiBD/jnATgA/bzYAkhiAyBj9XyAAz+An2Tii01eA3AANViESzKQjOCEoDkbQkixmSCEeduqip6JEeXjVuXjPuZxQfbLPfBeetMyLfPoU4U/woQKDvmEZWiGZ/jMz+TRYcgF9cKGmXaGtnWGaXiGAMaGbOCGZj1CfWAHMg9Xc9iGbZBN2RRqXcBBzYslXDLHGMQFdazBGvHgXkAEsgKCvDqNGC6iOv9sU0GXTuekgvu+U5O8K5VcSf5OayBm2DAY8AHnHVhjAQdQADJOgAZ/gI3dAI/lARvogQthAAOI3Qz4gAyI3Q0QgAMg41ZPgA4vABA4ABIvcZUVAAPIgBUwg0YImvDYBE9wcUewGut9iRK9GT5IbfLN8RLl40H+y/X1lGj36NpGqDfIRiu4g2DwUWZAlwwihlyABmzohtB8BmiQBmhQhnuE1mrFBpQ+QnY4B3ZoB53mhm2Y7jWf5YT7BRw8uIEDr1zCwRgshh1p6l1ABRu4geT7IStIgq7+89AY9BsudEN/GFTbK0NUEyFe9O0kA2+W9N3xMC84A+ZhgQpIAAc4AQ7/GIH13AALkL07mi21g1QDQPXYTQATqGwHkGJYP4AFsIAlvljKBmPl9WcH6IFA4IT/zIhEiIRFgEtFiOg9MPapj8bVBt+oDYQMrRQfF2RBdu31hS7EC6gx0iezx4k/gYM2SAMx0IQeTYZqySBeEtIeFdJkWIZkEBdhMAZ6pNZxV1J9OIdzyGnApQZ8l2V9TzjR6zwfTOo2x6WD4wVdEgarknxbeIQVSD4k0GEjAKzO9XzPEHSKH/SKZ6cmOjXWsB1tFkXrZNiPH3DNmCIjXoMzmANYnYIWMAEXOAG/xhJUsYEHJXUDGP4PaNTYVVkDgOwBKIBML4ATQF4Sj36VRV5I/2VZB1iDmP3P4UiERaDLlYCQGcf6ixb/qOXQrWdVr3d2IA97sac3an9fF4uD9ls6PEiFXLaFWAAGY9AFYciFeQR3gLjVihWrVrRUmYIlixcyaNi6yaOnjp06c+oqUstGbeO0jtOGCQMZTFiwkiZ5ofyFktevXyaDDYtJbOaxZdCUITu2SwyLHkOQ9IBixQmSI0aNNmkiJSlTplSeOoka9SlUqViiYI2C5WoSrFu1fAW7FYuYsmLChLFiBUqQLW7fukWCxAmXNGvmzNkzx5AlTpzW0KjTpksbLkjglAmxgsGBxh/e6DAwIEAAAJYDJEhwQECBABwOBBgwecCBzqQHCP8QXWC0gQMOePxZlKhQoUSJHDlqxAhRnzx6CBESJHw48eKBDCEvvmePoD10ni/Xk2c69el4qOPNM0cOd+5x4uDxvmZNGiBmOqFKBQuYr1/CbhkzNsuUqVCjRIUqhb+UKVbBlFmjzTzzqLOOOtxsY4453GjEUUfRzBRhhMdQiIyFyCijzDIbMgONNNJgE6I23QxY4jzaXMPKDD0NcUQPRlwxhRJFHcWUFEs11YRUOzpB1Y5IbJWVVlgYYURXWIilhVhblaVWWmqxBRdcUnFx13KGOJLJJqTYggopr5CyxyFzrEEHIW98wICaDNxxxweiTVbZZQEUkEABCjhA2WoBGCD/GWkHjFZAZ5RRltoBHpiRSCSLLCKJJLnt1kcfiABXnCCGDBdIIMIdl5yly4EaXXWj5rGcdtPh1R13eHwnBxxnqHGFDYp0Iootu+ASHzHC/NLKKquUMkoppKTyCpijmHLLMQ4NKI8865izDTcXZdPgg9F8aM001oQoojbfgjtiN92MWCI99NSTrrrnzvNMHx+wcESLctFLI1JJ3ZijjjtS1e+OY101pJFDAlywWgc7GQYZTkzRMI9beKHGHHRcOoklnXzZSy/A2PLKJJg4MsggirjJGAM1PHJHDQwYEBqhlFkGwAAVCBBaywNIZjNlqtX8MqGkeQDHIo44iltuiiBC/ykhyDHtqSCaDtc0cZg2x9xyhPQhnW96cE3dHqjigQdeY88RXhxwvAEHHHHcUIMOj6iiCy/E5HQML7K0ogottowCSimpoIIKf6q4Mowy03RDj7PyHJgNNxZZO0000ZhYueXzjDuigPOcW48+n3+eLj3zYBPMB/DK+5NcPfSAhBH3NnFEvjny+1QX/fYLsFdXfTWWVrtjodYYZ6WF1lANz7gjF2rEkZchimRS6yobA9OLsaJE4ogggNCBpgNq3tHHHSlb8UHOAfTsM5+U5SzazzsDIKfPohmgwApzROLoo0jvpogiTSMHOISgjXAKcSmmTa1qoMLa17bGNT008FRjw/8DHca2h++84Q3fgcMMalADROyCF7konDLshguB+IIWphjFKFKximK1ohWyCAYyosGNeqxjceaoVjbkwQ0HdeRco7tc5UZHrnKdC3TnYNDmyDUKHdTgBkjwgQ9aRy8jxM4IRCgSEWanlKXUSApOaAIVpFDG2S3lRmpMyhFsdCOtIOxgwzuYGNQyF6JcIY9kIIMZ4HAdQijCEZTA2Cs2Zj0veWIShqCDq8LwgQww4AOPmOQnJvmIlbUsfXKKmcxaFoAD3AxOA1hNnOC0GkGN0gAJAMEaBjGJSFzCEpTIhCMY0YhENMIRiZCEAAVIm+AgMGrCARV0llPBUhHzOcqs4Nj/Kqi2Z6pNDT8QAxwU4YtkICMXuSihMIQBDFwBgxazsAU5YZHCWeiCGDZJnDzqobhxdSMb8eRhiLJROXBlTnMjwkY0rHGNf84jXfqohzyikSFkWEMazAjGHXRggxUgoQgSrRdSYKcUN7IRX1/MFxrdiCMsXvSNwYujFZpkFjtGBQl65CMc5ICHPhCiEZLQRCiKZQvrgYkUnrDEIMi0thWc7g2fGOonKlGJPkDxA6B0n8/mJDNAhcaUcBIAZzQjGgFIRlAFaI0D2hCJTFziEpSQ6S1zmQhGCDBpiPilcKjWVqr9IVShooNcjUnXZT6HbGM7WxzC0Mc5gCIZzBgGDZdR/4zDAiM+wFisLfbWixT6QhjKkMY05sENduRwQOOSZzew4ZFtXQMay1AGM5Jh2mQYQxi7CoYIXbGQuQWUoPToxjC06YqS/OITOtDBDVgg0YkW5XUWxVFTiIuvNR43uRqNHRHaSFyt1DGOTYojEpCnxzKwVA55IMRtBkkKVKziFavwkig8wQlH0KENrvLgCh4xik+cgoWfUFkNgApJqBKqZ6UMJZwMQEqqHsBOVFXlKEeZgD7Z7wZxkMQlEMGIs+4Gl2pVK1st5bQ/xHWYdV1OcyZWNbziRZlkI0MZ1tYHX1zDGhs6RjFSawxgFMMXjSUnOWmhscQmg1vUAMdFMKcNz/9iIxvXioYwmPEeWbgCFq2AhZJZweS8neIUBLlt4kRH21/4ohbsocUdwtBbGlCxCPSqqHPxVebjIhe5X1TuRY+gxTMnhSzRpSNJr4AEJeA5j1sggx77iIff9IERlLjEJmpVXr+AbA9tOJvbdADf+VaChY94gwdP94HvAWo0qVlNa3YmSlHSScCpyQwpFWABBdhJMgy4QR4CnTRG2LIRE06abTwFQE9h2FJVI45z6NocEC+TbGgwAxricIdP5FgayRiJMYqRDPbAmGPG6pgtVnErXSSDstXgxrQ2W60gSy4a04BPMvBmEFowWbyviMULTaGKX81CGN1YB0FJN4xf9ML/FsXoBSl08IPewoB1VkRCEpLQhCJd1KMblUIWOJpmNXoxX0dobsJjJ6SCFzxgGE+CXPCsBCDk8QpAAPke0bA2OfyGu46IRF8w4fJIHIIPrOqgDkZxi0oEdZJ3gIylTwdJD5RGlI2RX1RxNhrN+PdPoBTAASaQmUwbgAEeCEEI3oCIRzRCprBmBNJsY5v/3Vpqe/iDcjjcVgXStdciDvYc4iAHM5ihDG+QQx9akQxhyIIYI/FmMdjzbGMV0li/kuEvjuGMaUhLHYtjUIimIQ1oQENjy0gGkzsG+PCOlxSdCMV3X6ELbLSzHvOYxikqiQhKOGIOSKDBDWDAgnrJpeBh/1wjxCGehSzgq+G1hziak/I6G1k8Kxj/XRQ2ThQ8I2HkygdCDkB+BTGY4QplgLvJ3c6HQohsETFfrwcrwYpK2DcDNTiLGDw4A59/gAgeUAAoScnUl+GMMgFuzSjZf+ACLGABAqYfAzLg/w/oQKDpj25w3YPVWtghx/80B9lJzdk5za8tU6+pHTP11fS1FB5UAjCcgiswg979wi4sFgjGGDAYS7G8gnrQQmQpwzMEmeLdgz6cwzZ0hDWo2DGEQlh1yQDpwXeswRYAAQ24QAuswAqAAA2QwSNAA7rUQzc8w3u9QQYoBgs4AQycwAqEAL04X1SE0e2hGe1xYRPc3u6JIf/vedQReIWQoGHBRcHx5ZnIMV8ONB8cgtwNyOGekVgbzEEd8MEgHEIhEAIehIEHPcIpVMIMhAAMgID/hcA01dEPsEAIeND3MAb9gZqf/ExjLBX7BVgBHID+JUApHYCaZMAbqMkMjI8kjFXWbR2s+U8rMs3/+A/VIGADDhNeSSCIzYEOhAEauIqxlYIqBAMzKMO9+YIvFIM3+QJ7+EopvNB60MIu/MIwZBs2mEM72MM+2IM5OJ40LIMvqIIHeEAG0AApkIECVEADOEAD5J8C4EkCNMAEvMAVPII0UEM9sEM9UEMzMIMv3AEL3MCXsQALeIBcNB/IRUXCMZwUnJkX4h7/GOpe7YUUw91eGNpIwx1BV2CFGqJh8a0hw7ThyMnhG4IcDZBk8+lZG6jXHPxBIiwCWlEaypzCI9iACfjACbzAC6wAOCLB8PxADagMJK3JD6yAA/gJzqyGAMQM+rSMATiAZpRGAuQfaBBKKB6AB6nJB8xAH8hUbqji1rViLD4P2IHlLCYHpnAYcvRaM+FVBU1TsbUUHCACMGyINRxDMBhjanUTtFUbM9qdLxQELAjDMoDIOthDP9yDOkwDM8jHJ/SBA1SAAzgAGqACF4CACUwACFiABXCABYwAPMLAFyTCKFhDN9RDP+iDPd2EMVACD3iBE2zFFhkBFIAc8o0RUxyF/3Pt3sJhVI7kZo00xUVuHEamIcdVF/IkHxC4xRUkZx5VFxdwgRmMxxpQQRrkRSFIgiVsAiW8AVAd2x1kQAOcwAawAA8MpdSBIwv8AFIBZSRJyh1AQQZYIsxwUvyMUmMIAAE8AAIsQAGkBmk4QAY8hslkwAy8ASVIgiq2Iiu6IlkC0Kcwx65NIDPp1V65lNnAwS5cA4hAwzGcFmrFh2Ld1MYkQy/AQiw81jIgkTuRTjLUgibcwQq0wAa8wBSAwCC8wiHY5E2eQAzAQAxwwAj4QBsYAihIwzzoQz/0wzloIw2WAu8YwQ7EplrkEZ6l1Ox14RjiCJZOJBl2YcAAjJKIRf9GysUUbIGMJN8VkMEWhJzzzcUWPGd0OgFh7IEiMFh2MoIOfEB3fkAFICIL4AALDCEMbEAFeAALjMEOrAAkZYAYIEKbdFkNmE+coA9VaRKlHgACIEBpsE8oMgAkNoaa+CQqdmXXIcJYzuJboepwmB2HRejEVJCIjY1LbcfZVEK2bYgyCMNhOVsyHFYy7ttiPVvHrAItyOU1NNE1HAMrPIIOhEAG+MAXfMEURCsk2EIgUFGYDUERuMALfIGZgMI1GCmSvsM3bIM2SMMjQIEYDE+6/oCUXoESOIwTIEVCXumNTGQYptG94msWeEHDKcVDSuTtFUxYKEmQREGb7pGa6pn/wo5cHrWOmy7PeMyFGtCBIaCiJmiCKLjoHRzVB5jAF8AADhRBwE1RC5wACExdCDzi6TxCJTjqG4wPmkglfxIApRIdAdQJf7LPVTrSpzJAACrCJeBG1hEt1zXoAUkNAtHiMEFohK4lBbodd8xBm7DCLTxCLiRDK9SHLYzoTVXbK6AC2IKJKGRnJ6xC4TGDsTLDL4wCUjWrAxQBG3TB3BYBF2CCLQxCEUjrF6zBF5wAElAsInyCNtCDPhQmuU4DNuSCDojBGQgFlFhByDXMFFBBF6gRRQbsQ+qr7umr7eFr5uqrl/IOkixJwLhFwr5FyLkhmrapc6rBGrRBGlCnIMjU/yV0giaUgi3AwiiUXgjMwBfwQBewQRFQEQ6YwAkc78kO6gr8QCUU1SOIj/OmDKU1RmsUAAFgb/oAAGekxqYewAdA6qd+gBgEmtASbdGaKqYc7akqB685LYjJwdmojbHlwfTuQjGkArPygZdsAidYgid4AiZwAikIsCicFyWAly9MXjHEQiVQWgh4QAMwABP4ARMwARscgh2wgSf0AiTUwSHw4SHowcpRAiiwAmn2wz/8w+Qk5iOEwRmMgRVoQZGo7um6RRd07kR6Qb9urr7u8Jba677e3g7z8ERqQVmMwfCoq1lMlxW8BcNM7p3B64zMxVyQWB/hIUrSwSAQTSaAgv8oWFsv7IIv9IIoSMIibAEVfEERyIAQ+AAImOwLpMAcWwChBoHgFlWkFZX4TK8DtN/1CgqlDspogNL3psma1MAb9MEsGej56gZuLGgwNQfS2trRmp2qPq0yfQ2rZFAnc+woWNsq6MEXHMIhkAIpMEohQMIiTMIk9OEkkIIlsFwlrAIwpIImKIIVCGQDSLACuBwnAPApl1cvJAPYhq14HXMvGENAqXA9RIM+/gLjWsEYqIEWuKkT2OEekYFzSmS/7nAa8CsRE3EP82sPF/GWjrMRa0ESJzESnxTCSIUUexy8mim9OAEfmZwcpFdeDELtEhL1CMNp2cIjjIFyFgET+ED/C8AADKQACaBADJDACZyAB6xAGDzCJ7CCLJReJTwCInC0yhBlnxRYzvYMfQ4AA8zAmkQSzCKCljhK1hFN0UAy2C2tLE6NJZ8d2q3lHjwQHrSJ2rBFHNxSInDCIbiBG0DCIbRyIHywHbicHfzBKh8CowzaJfSBFcyABzwmO7LjtOVbIWlMLxQDM+ybWNPCK9yUXBqpCsvDNCCDMWgCC7wBGagBF/SAGkNsGWDXHnHBvYrzEP9wOZNzOAf2EAPxOd+ekiCxEr8zwqjuPMsI8rEOEjTfFlCfHNRBHv7BICzCLHUCM6a1s00easnCJyDCGZwBDpyAC8QAFcUARK92Czzi/wyEgSaogkYPlfR2GbMyxlZpFVURXQD0n5qE4grcQR40QiZkQiP4j0zJtCNE8vrq2q1FjadsmCb/WdZ0DR7AQQ6QARoIRhv8gR0cdR18cBuwASwfAiQEwiR4wiIEAiQAcx8EQVanIzs65QFoDI2F6GMBg2AZQzG2Alo/ljKs9T/UwzQQQyy8wQ+cgXNuQResARJ0wRc45zZvc13gcBd4AQ6X0YZnAQ6LM2ITtu6B4Q5n6ebu8Dqzc2OXFBLnkVRMAcM4ARUDRevwQA4owTbz7RzgIV1xMXaKQtjawl0mw4aMdjGAQh7QgELDgA88gRDEwByfQBEARgeJwfioAitEWf9Mig8UWQERNMAf7wmceBpp9J8ObFdY0VJuCJKBEg10RzfStlVw3PT6PiAhXI1c6QEf9EHY/FkeoCkN4AAbJPVRg4Eb2EEdsIEdtDfY1sErwVwpBwIf0MBQNgB+P11jAN4xj9cLFdI1GQMumEKxrAIsEAM21MM/mKY2HIMm1MAMyC4Rz22tZ4EWSIEWdHit1zoVTEWFAzuH/3AQf64a9Qju+PqxJ/sWrDMTl4UXaMFGYgWOFAUSmFEWFcmT8sBcVC7suupmL0IkFDCR+4IxoBaFHHlpAQMoEEIYEOEGdMAEXEAHPIAJBCTVBaQH1EAfgEJ8HVWXfUBapEn1uo/R0Q//KPVfCFiBHmglJTi8/jwKTBuNnNO0WTJHL/XSrCmNLwUHIQDaA/U0oAO6HuCBzMmBoSeSHZD3evuBHZQyJGBCJLQyJ3wMJPCBHABBC2hABWjAzk/AAzwAL5+yTolC0ZcXxgRLK7SYKYBCfqjCMJAmq+tDNwgDpbHAiP9wvxL77fi67cxt5VY4tEKrOZ+zvfI61yd75VIFs7e4WUB7wGTFRsWOUYDRbRqBFYG9GqDkxPxBIPBhK2eCKDBjCnZTfJzWhhzWK+hBCFQAZoanBbgeD4TAFQDqCjziBz2v+GRQoq4JKElGn/QJp1qaDoRPHzyCoxio/nDlxM90xWMKxsM+/yEkDcbThgHxAR8Ah6SAvMiHjQOVfB3ENx/AvB/4gXwndStPwgADMCdgwiKwwRa4AAjsvM///APknyVcQiZcZ1htQqF1AiiAwieowi4IgysgyynwAjaogwqfiCp00Ar4ddZrbhZURY+E/dl/fe0BdhFLJP7Prf0DRBeBXbhoGXPwoBgxWrA0bBglihSJUpo0OVLxiJEjF40QQYLECZWBatKsmUMH5Z9DhiRl6iQqFSxau34JM3YzWbKbxnyFgrPCg4kTIL7A4PICCIsbM2ZcmfFhRZ9Kj+706bPiAwMHDBg0YHAALNgMH6DWWPGmKiNKaylJcivJEVy4jujWdaRIkf8hvXoR9SX0929fwYgAEyp0WBAfPn+tNtaDBzIePZMp6+FTh00dPnbc2PHj6dWhSahIocJE6hUqVJPqXHFhQkOFCrEnTHjwYMGCTZ08vURVKlWqVatg9YoFi2ZOY8OQydP3r948Zo9qzFiRBXsWL9u9pPGSRUp2KV2olBf45YtAkQOpTJSInbv279gH1revfotBhGMUOvQfcaKKBLRoo4w8+siJBNcraY022phjjz0McYQSTUIpxRRTWEEOmGJuIgZEY4rpBZQ7xLiBhTV8qIIJNmgYwwwgCrlihRkkoQQtSRDBiiwGMvBgK664IuuDGmoI4w2pNKlkrbfgagTKuez/wkuRuwwRhK/BtNTSkLwOO+wvMBlrrA/KrKKMj8c0g+QQN/x4E5I4bUHlFU8wsQSTQvgwgwYTQIhtNtpsy82WXnrxpcNiiukwJ0UV/aWmZaSRhht4/qFHm1/C+GGFELLTzrvtvMMuvCzuO3Wg+eDbLjtW6TOvC/RiRY9WgrzYbwyHtNiVoYZIpWhAATcywoiPjFXQifPWaFAOk/ZApJEKO7EQuFZsAQYYYUIkRhhhfIEllEzwwIENJpgYgoc10CiEBhZ+CKWTGkL4wQoWPmAhBCIdyEBIslaoQQck73iEFFE6yaQtSRpxC8pG7KKLSoj3MmTLvvDaMi+9wiyksD4K/yOkTI/PtGwyPuTYzA872HADDDsgsaOOOtaY4gs2ptgChxb8jM0BDQS9bYFEFRWR6JyEyUmnbI05Rpp6+tFnnms+0cEsD7jrLo2ssVbVC4Gy/joNVF29ulVW1ROJ1rTVvnU/Xt1mSItfmwB2I4wucsJYkBQE6SMq0FtjCzPiwKOPRCiUpBJNQCGllFZoqcmmpY8xZplkiilFDy4abMOJNb5glwUrNmlkBhpW+DGEGliogdMP+B3SSB3EuCOMOzpZpeBQNFG44YYfvqtKiCWumHhE8MqykEQ+JsQvkK1ynhA9CElTDjLMqCMQO5iIIQY7MOHCBzTqQAMNHMzXeecKHP+QrYLagHZUUaSN0UnyY+ifPxlo5OknumTusMIsGdAa1gaoKu14DWwJrI8Br9bA7sTqPGqT4NcaqAXuuI1UFZGI3erWBLwhKEEh6UHeQsKFHlyBDGiQQx7+QjhEUKIToIDJoTokuWQsYxnMYEYxQsEIMeygB19YQx069YZOIIIGpvNTBlD0AzH8YAb5GouRaoCWOwwMNaUoWCfawghG9O53YYSYIopXRr8QBjCDmZ70GNNGRPQBD3LQQyA4wYZypQAMVfiDJxbBBjQUxQQuWEH61BcbC7TvNg+AXzEqpxycEMN+xmBGTpQhDXroA1OsgEK9yJLAAraKPl3w5Nfsw7X/7niBJNzJ2hrUIEFXoockYHMgr+YjIPc0gVgXaQIJE/SRHnwQQVygwQ1ygEI4zCEPcNhDH15YiU6E4hW2sAWikIbDSeJQGKsIRRxuQIYgrGAFeQhFHkpnghZsAARkGKYTxWCkD+jgDfG8Q18eoYlSvCIVWhSFJSjRiC/6ToyOiMTDtESlMjLvjGkUTCIKMRmFKg+hf9GDHNjgA0j4gQlVcAMbIIGJLxTBBzBoAQtW8CdA9UwDFrCA+x5gOcsBw3Ldwha2fKEoX9hkGMFozjrmYQ2qwOENYQiCKhPoKvmgipT1gU+oRHW1rJEkbctSWwQpuDVa8kcM8bklsIQFwvL0/zIkXy1hGchaBjMckw552AMhonSJTvgmmr1IFP5yqMNk7AIReAgDWfBACRp4QAPr21cPWMCCDNToBwC7wxvgudiBjeIVqygFvDRxiX7+E0p1idjvqNRZNKqxY8sLTCISgUaEmrEvjAjEF+wQCD8cwg6HqIPKcDAFHLymBegzaaBUapvb+GKavaBFLKwlWVSIIhShIMUoPnGKYOQiF83ghjq6wYs+0GEO/AmC1orqwK4NZJT2ARVTKbiqNLTylbVCzwWb6oVd3UoMBxmVeOa2QQGBMITA1O8WrhAG/5KhDOeFAxwIx7xoXWIToijNK15Bw/nhEIeNggV1QsAIS6yABv9TsIADCtsFHyBhBViAgw50cEUT9wEtmkgFPkthsEvw05+YnQtexEilRhgUtKclDGlNGxhElFYwOq6YF/uSiDV4whMrc0MVAoGJQEyhCDiAgTl1BoLd+kyliHwAKD6hiWfyZjWRwMQirMKISowiF8iYxjS6kQ1tSO0OdJDDFsiQA+6CTT4FRGrWxOvAUH2qa2lIb9oEEh8LbmdXCInvGMQToAEVCL+9zBuCqMCFK1yaDJnONPkI7DFoMUISlkjwgqPpi6UlQxnKQAbSijGLxGlCB2hYgwlMQAUY+GANPeDBHKwysEc0hip3GMVwWgwvSlhCYYzAixfHOKXgAa9KNyb/I8gIoWwyXgwRjNBSYbbEPB7/WNuB8SIZFRMzO/yBM5hABSS+gAMavIDKfroylg9ZG0pcAsGc4AQmMAGJ5CXiEZ9gxTCisQ1qbMPg2MBGMvogBzqsoQhb6MGdtZZnptaHz6LM+EA+taqOiwpVUy00q7CwK4coOr6OxsijM2IEBVEhv/hFGxcAXFayZnoMcFihyKrdkgRrMRWtqMVN52e/yelEGMDoRR/yIAcYwKANJ4DBGlhwBkLk4cyn+MRUpmKVVqwiFaSAVyZefFlrdzag0O7s2c9IvEQwAshBVuiP3+7FuGdb2Y5IxGUmMQk7uAwTcgDCbXOrW5P6jN7tm8Ai/xYRiUkcQjSWaEQlQKELZWCDHvWghznqAQ52yAMb1xjFG+LQBigrAQkDrKp3ZyVVV0Kw4/ApG3dQdbYFfmciD8ECyq3Q6A3ekkBhFat+YcUF4x/fDGa4NArPcMw8zAFCbEVcZT8RClOsIha7UBr+5kcMZhhjwnBAgq1ZYAMWxKEvnzAGK05xilGMgiqSiGwqRGEwsiPbEf5E+xhpHEa8QImMCCPI9MDEqqIvJsPTSKu0fEwAv82LiCzbGiHbCoETPIFN/uAP0GDwbmuQckveDi+l2Ec2AoEPFkFHEEFxhIEZrGEe5sFp+uEe2KEe0AEesuEajsFE4IAMlEAJeIAIZP+pvRoobP4mvWaFbOSjgbKDPcpDJMRqPbrgVyTC5PQjIaygVIBP5TxoPWAuJI4FVr7g+Iwv+TSNDOLrDNQAC9TgmJiJER7hESrBmUShFLAPUfAnJ5BBh3ZoFRrhDaBoBnRA2x6BFX6h/U6BFUwBEfLgdsCu/g7m2Noi/87O2Tbrd6TNeTxmTJ7ni8Ltx+hOAb+NAZnnn64N1PxJoA4BA/lgCsjA3UgKBDzQykBgAzRgFkOQfUxmYD5BFpABG7RhHjKvHoKxHtRBH+7hG76hG7ThFGoARi4NCH7gBwiIqMYm0ESO0M4jCbWj4zaICfOLC1+uPBxNCqaQP6xAIaygvrj/SpeCRQvJI+ZAqD7Shgu+AA2mYAoSBCJKbgfMUefygJmY6Q0VRxRMARauJX5uiBmkIQ+LoRVG4Q6C4A2WBBSEIRcK8RQqwXhIYTjoD14si5+eZP8epv+mJLPyD0qUDQKLJ40+8e480dvOThEWxhEWYQ/4ABL+YM6AoF1IKt5icQN+MvFkQypcgWm0oRvkwR3GwR3+QR/qQR6CcR3oQR7UQRuYARFkR6iuABqt4KlC5bziAwnVYA0EbSDSwyxvj1XiRgukAAvGkS0pQvjCqgu8kQtVTlewwAqSwAqiIAmioD2c4AiQIDAFpC3bMgqcYAu+Cr8oTZSKgCDCkAu2QDLz/8PkiAkKxOAN4CAO8gAtADJxQCHoigOmEDIPmaGRfAEUHgEU2s8VbsEV2G8UEMGZ6CSfkEsT2AISpe3ZNGs3NYsuGsaLTpIUU+sBi3Pu+oKZiiw4CcPTiEwSGIEuCqEO5EAOvmALaEAnW6BTPPADgRLxDqkCngEbWvApi/EfzpMpm5IYMWkeQs8VwiC+ki/5zvCpUum8VuU7TonPuoY/NS5ssMMgDOJWBHQMBlQMfIWrsvA9vIAJycM8zCMxEzMyt8AJ7tFCEZPOnOAKkOAKNBQxgWkLkMAIokBAkoVWwlANzuAgmm/A0CD5Bmxw/LHaFsYSXCIURAEVVoEWagonbv+oriYpGYThFtzvE5rrFFThE/pAERQsskgDuTrBshLGLQZKSuLCScTIYUzyxgyBELgUZPQgD/wxD/SgD+4AD+KAOvux6YAqDiYDMsAUjq5oM/EgShgqcKxz8GhApFiA1gzPJ21RNjRPHWSwH+CBHc5TH4oRKoNxHrrhGqYjYMYAMrmgu1QvP1cPP8sr0XBl0RJCIcTAvuorWNwDHEu1G5GAB3nwZiaTzshg+VCIvygU9W4Gb7YAC7ZACriAIMAQ+c7ADMbgDM5QDdTARc0ADQZMM1eIEN7uRjLBJeQw6KaJ6Hw0wiAMGYihItuP/RIHR1Vji6ZlLUrSLrJ0YdyiLub/Ikq0NMY6y0tNiw2LjDAipEsR4THwYExHxjEkQw8oQQEJwQZyIAe2IE9hwAX4tPBoLRatbBazrALeAR3egR3OYRvMQR7owWItVh4ytgW7YRmIgRXCQHYk9fjKgAumsTuG9by+BmULiKhGJdE69VNj9lO56tHY0YOQZTHDCm9SVQlWVTLt8R5DSDKvIFaJlgwkU9O4gGTJQGnLAFhV9AziSWrPgHyOFVlhVK26tFwpwSVAYRSEgzh2wdSQ5g6RQRlwSNUmpxh8oRZWQcHEblqYZGH64iR7h2EWpnfK1S1k7C3awmH2NttIqxD+iXcagbS+SO8YKk30QBCU540eo00L/4FeH0MOADbDBtYFdOZgP1BhgfKQ3kEcaLAezIEbzIEe5sEoG3XNpKGSgsEV+sBIziAMk68MTDZlEyiWRKWANNUgZNYcxcAKgld4adZmCeQI8uuDiA/mkMAee9Znt2AKeDBvWJV6j5YMVrUMyBAhoDYzpfYNrPZqr1YOoo9LY5ISPvP9TEEVkKOm7AcZ3hd+zzbChCEWTAEU9GlaLEthCAOz8hY4T7I4v4hh3FBhmiTG8PY3oaQQPOYwGKoPkkcPoO/5NBNM8QCoNiXnyqB7YwQIbkAJNpBgC487OVcWF7YC/uEeHJYcxuEbuIEasiH0oOEYeEEWhoEXhOEXWiEMav/ECyKzaTPNqUQF0I4QCYP4O3bFd81ReJd45YKlQHIpMBFk0iYthFCVZ3uWZ5FA1z6iZ6EXaC0UaCeTDAEMwMhHDQdMapE1nuAgRdUwDqAPmZhJEQJSINVX6H4BRCDpGI7BbM02SGVBFd6vxUDBEeVC2xShDZ8z/8Y1gMeNjL4tyJjTTfVVDjQzDlwUjcUgCALmDcTgMvUg/wgBMvLgDsJUMgjh2CyrEMoAYAXWfGggc0WY1uStOzfgkGSwHtgBHEqXuqQBGYJhSA0RfuJlBVhAIEYWiFs2DUhFG8GyiB0oC5AYeJeYmoXXeIVlWIgll6aYm6XYWK44VbWYB3jAWH7/tkKZ1wlmlQqKFtNqzqzAV43XGI3fIGrVgJ6hlsCeBdTeEH1NoRVkQReCAUT4mBjMdoZdwRRG4ZlAYUly02/9SRII2BTvtjjfaA8Q8Ewkg+nioJPfYAzkZQagiKRCYAZuoJgBRmD04A2jNBNKQzhWjMHiqhdeQRQWAQ5y4AauYANhWYRHeJY7N6XUgRuyYRtgeBqkARqw9RZy4RewJRkmCRjeAJw8YCCMT9NGZWtO6ZlX75QMKAsaYpqr2QqggKzJuuU04omJQK3X+kC62a0nLZzFmQeIxQquoK7vekM39Ggvzb/62qzkE569V7A92qPFwL9+IAgwEw6qguk8U3FG/8EUWpMXBPp9U22GWWEUuAxcH0ERwqQms00A/zE5taRMriie4DO+rICTF6udqOgH4OCFMkETLIQUGEc4XiEWaIEWbGEXbGG3DQW4gzu4UcES5MAMcmAGgACnb4Cne3qWf1phfUbhsMEamgEZ9vgYhsEm5KdRRME6QsAD0AYM6WwLsJqpUqmrCQirvTr3wlp4ofEHyhoKtFmbW24H2Hqtu7kH9luKR2i//3u/w/m/kaCslzgMrCAMriAI+kuo+vq/xOBXI1wN7XmwgeoNnNawGxxgSSwMxqB7M/MOqi1x3k8VAFqgj0EZjoEYZIG5Zrvr8oCjyYoGgiAOmE5qF8uKTv+sAAHSDfmZW4FjOIZDJmKhFwqlyKWpFnh7Fw7FF9i2Fp5cmgxFmqa8UKQJFTwhEdDgCpJIuZmbp1kgltHnuWv5UVVcu41BGOyHWi2nGGzhFQoBDsrAHo0vVsKQqbhDDZzqqbAmCzRombVKIh4iCQZ90Om70IkgmzWCWIggl3LpZkGCCWHOHb+KCngACK4gB0YICXiABWag05NIKUgKX6KIpMApBE791DsF1UMAnFodnDp9BqhI1mvABkrH01+91IvZ0wvr1WfABsJgsbOtEj5hFFTBFWRhW+8AYEIgA8biAzxdK2pgSGYgDI7EAN0wcT7BazNEfVmhFb5dFmBB3HP/m7hkQRaO3dxhYRZmQRZagRVUgRVYwdxd4TVZ4dhx2Bd6mxa0KXeclROSRzHiSPmUe7mZO3PBfHPHXN5+Mhh4AReauhhyQodyKBl8oRWSSxQ4IQ7KgGiRwPjQIwznw4jBZlgBXRt9jy2xgC8JPQnom76zGb/vuyOMwCLwZoSShQrGL+f5ZoQAVrl5QNd4gAZ4gLlvgOgB1gaSHgqSnulpgOmTftarQ+qT/gaoKNavftc9oNl/ZOsdYF+aXUiExOvHInVm5w2JPZCpA2BaewVK7A2jZxMrIRSCoxVgwdzvHu9vYd6PHd3PPd7jnd4DX/AD39yhK6eGYaCPoVt+ARdg/2FEjBsOCkEQ9KAOtqAI0AAyKnngAfYGOh+WMzfMxfy5ffIWfsFDyBaqbYEUNgHZKjARku/SAnYLjE8yjQ88ZM+8VDbPwSM8DMg9Al3lV77QW16bB91uOmKtb2AHlh/RPaKX+JuE8sYZL335rOAgzPEgiPb4Zt+siFZgqf8Kmp4pnN7p/zUHbIC5c/3UgSQDGqABvJ4BFOArwoL+DcD+DeAAGAAqViAMEIHYDREgZLlidapVK1itYtWqpdCWLV++HNratUsXLlyyZN26lbFjRlcgQ4bMmCsXr2DDhhFDxrKZS2fQoEmb1g1bNmzWrC0L9mtXr16v8NCYwoZNnSp27P8wKSKnKZoyQHLcyEHjxg0aM1xoddGiawsTYMOaAEFWmLFkaJMBs/WKVCdMkzAdOkTqUhwyZq4AATJli9+/XLJIkZLFi5cshQ17ScM4zWHEigsLJoxYCpbLUTJnTrI5iZEkSZo0OULaiBEiTXYYOULkiBQiN5DI7tEDiRPZs2vzyMH7CpnfV6yMGX4GDhw1Xbp8Sd6Fy5baSHjQoJEDyIwZLFasYJF9RYgQ2r2H+JDBg3kPGRg0aJAhhPkQM2rUsCLmzh1Ej/o80hSqVKqDCuGiiy68/BJMLr8YKCAut+CSy0a36PILg7qUdEtJGGZYEkoprcSSMiAqs8wyMmHTjTn/2dyEDTbUZLPNitTEyA03MWLTzDC3ANMLW3q4AAMYTzwBhgxPMOFGFXU0tQZUVEllFVZbceXVV16BRRYIaBlTDC2lkIKKJ5hwAsmYfkCCCR54bbGXb2Rw4eabh1GWGGKQKWZnZHTOaRlmmkXBWZ+ZjWbaEYKyRuhqTRghGw/QXXWDbjTU5ih1V+Twwww/3CDfpj+wcAJ3NHD33XkZlHqeAw60F0IGDrAXAgvX/RBEGHcQgogkl1ACSn+prLJKLA714gswwAhj7LDGJvsLgSdxmFIwvETLC4bSnkSMsx+C2Iwzz0QzTTbddDMPPeOWS4885qyIzTTsmkPPPe2ss86J/+bUa86M+HKzzTQ3cqTjK3ngEEMMVQjphx1PCHFwHWy08dQWvEXF23Qw+KjVlFOGRdaWpoTSiSWWTGKmJ5AcYocffhziphk9VAqEb1s492YaeRaWxmA128yYYZLVWRmggGKhxdCXCUboYIKaprRpobJAAw9PThcqeCx8p90MWM2wAnoZkNfeCg4wEDYD6pXNQNcffBCCDmW8EUcflFxySSediJLKK6/QIiwwxfRdTDJ9GyP4WYIHPrgxxKSkEjGMExNtMM42zlK2yjQTzYrazCNuuPN03jk99YRejz6k69OP6ajrUw893Wiz4jTUrNPPP6frc6688qjTjTq8m7ONOf/TEJMLLj6hIkcPRfiQQgpCxOCGG0IwIQSSdThcBsTV8UYVDRVXvBXGXVkJgiicgAwyXJ6QXEcdgRxSxxy2IVEbbVfU/9tvgU2Gsxc4J3ZnzjUbTGYugwXNXGZoRIuCYERTmtMcYQc3IMIOaDDB7GQHPR4QD3pSlSoPoCpsDSDb2dK2Ah2EwYT2uUMfKlEJTWiiE6VYxStgQYtaDAsifCuGsQJnLGIgrnHGMNbhfuhDYxzjiJOjHLei4QxneAsbmfPcuEC3Os/Rg4qhU53oRFc6ffzji7QL4+z+YTvNuW5F5phd7a54RSlqrnPYUAYvGgSLVPThB1z4QgpQMIIixcD/BzhgwxfQ8IfqoUFNUpHY9rgHA+9drAVSqhII4IIJMC1iTJMwWRfqkMk2dGF+TpAOD+rHpvsREDNCE5r/FKMFy0hGC1mAJRYsIwUtYEEMuMylGMYgBixY4ZdQgAJokiBBq9wAVt65oHZMxTXzpMo9r4pPEH7wBjwQQhL7CUWvfvWTXuxiWHzTkjD85rcgJqtxiXvW4obhrA4dgxjHmFzlYCINa0BRXG604uhIt8UsehGMqivdGMEIUDISlHb98Ic/+sFQhpJxda1bUTbk8c+HtjGfnYPGgXwBlEwkggs4eAEIOJACN7BhCjBAAyba0AY71GENX5hCdHKAhBzwAGpV/2FklLoSyfCZgJKYwAQpwDRUkU3iFZAIBHe2w4IWcAdWT4XVdaZ6HallbTpYgypVsaOdpYbnO2A1T6nKkx6xkW1s6ilrqrq2nRoE4Q15QEQj4taJXY3CFL1qRd4k8hNfUIQiA7qIYIlXEV1AaCMO0hCGoBU5ebrEct5K0e7kIY8rUvaylx3dPu/BWYc21KFg/GwYv9jQfXxWjQg97Wn3wdp72IMd1IiGbGULDtfeg4znyJ3uUnSTeWgDGcMQhi9eIYk2+OEJA2NCDNjghjLFBS6DCMRLv0AF+c1vBxCkGAxesFNIeuUEYQkqmDhBCkxAghNgggskClEHqzaykVTFKv92noo1rnZ1qdyZb3i24x3tjAc8YAWr2sATnxroIAgHfsN9btXCuorCP6vQ614l4pBd1AIXCxnsRQ57WAtBSLHSQgnj4okMbXVrGuqyCefYyOJ6ULYenC0dZ2dMY84elLWsVa2OV2vaHft4x/X4RmxnSw123PYf91idOrbBDXVwI0XzQAYxhKGjRtzAeW4Ag5aLwgZPoMIO7vtDIP4wB+RUlzbyu2l237vdR17sBHAGi3jFOwmRnfcQYeIDF6AGwR3cFAg2CHSgc2CDGhwTVlah6tWmGtX81uAHOjChGN6g4D4gghGPaKELQ/FgU6jiILCIxSwm8tddKOTCFybsXwP/ixGPaIQjGsnQtEpyEsU5thknhl2KzIHZyiYZxvcQqD1Oh1l/dpF0Bz3okZONZGY7+9k31nGOTxuPftxjHEOORozAAQ8k31Yf7YjXjPaljGMIrheZmAEMYgCGI7mBCUwoSlKKYJQ21IEObVhDGrpwm/jRBmo3YHObIfkC7rYAzuANkyfQm94xQWISC6/DFJzgp2GSoQwIjnQQZhWGG+zgByD/gRXCMGlK28fSj6BEC3clCrttMyG0oPBfMbyQDG+4QTjfCLVkTetqhbhDHirxS3KNYhXXSx2UZYfS21GPdrjDHUpX+jve0Q57WP3q+7jHaW13xc2SbsYVhbbYoT3j/7Gn9sdbrweKUkSNanyj2wR1BxmzoQ5sSPkYaumEDZInAxlEzw1PsEMV2EBvQdbBDoWcwxqQ0+/qzgaCAWczd11QcIMjvJJgeq55zetlTNSBB2M4gxrUcIY3wCEOd8BDHyzNCElYIhObqJsovOSrVwBLWBD5yTch4tfdL2sXPRlQYS9CoItQ60DTYixKIOdOeVbOcuxScbgqe66ugw6LXNTHPdjhjqsfOR5PD79pkywPprcj6uyoeo1/LTp7LNvsANUHPvAB//qHth9Xtzr+7QGP/k/9HeAADuMADryVDdzwDeHwDgTlD0/HDtwQR7yAd8AgCmNAA0UQAyrgd2BQBP9+gAqHIAN+gAnwBmaBMAf5tm+N1289wAN+xgM4IHmUV3lcAWeVZF6aVzJxgQpygQl1Qwq0R0MxtzfkNIREqEPJcoTJUiA8kSAJYhLNImLN9yEv8USYg09WhH1b1EUNdWxcGHY75g7g12MMRX5JFlD14H41BmNdZH/JVjrwN1AENWNW131XBw/ogA7kkId6+A18+A3e8IfekIfjwA1Hpw7mEA7kgA72AEbuwIDjYA43wgvJIAymUAZrAGcdEAPwthRF4AaYYAdjAgYk+D4nmBxUQAVdQAUqeFMuKHA+sl0FJyVjcggQByaHkDJzMQl/MAm2kENF+ItFaE7oNIyS43z/IrIMzwANKBZFbtRi/fSMXXhsBNVQbEiNqAWHBOVF2nh2ovVsq1WNpZV//vcOdxiA5hiAfgiI3sCH6/gN58iH4xCP8hiP53AO9nJ063AO6PAOw+ZFpqUP6aIM8JQMsHAHZoADKYABFBADQgAJgHeLmAAkTCCKhxAIfECKarBvqZgcTnAbK8goOBCSAtdIsdgVYHAwYIYyftBcWfYERYEJvtg3jIOE41QMxWKEQmRE8XSMzSAT9qQN2mCFnRMuQklFweZPosWFp3M6zLaN2xhaC2V/qhVGXEhaYsSN3ehs/TBt2MhsnDWHT5cO6VAO4PANeQgO4ZCO6tiHfIiOAZiH/2lJj+xwDgNIl/HIDY94Dkq3DpSFdJWVfsC2WeSCDdLADMyQDKYAB0DwAhdAASggBH43kSgDJM0FBnXwB+5DByaYkanoBPumirnRAz4ASCMJixcDipDQbisZis9TBe9mB5JACq8gLDu5ONfCTrgwTkdoDMuQEz/pOdJHlEh3LuowD9hwOUNWDVNXbVbHWvHwnNWWbNdIjfxkhviwT8g2dg11dT7GbKa1UOC5lfGQY6a1D1qJduL5DuVQDuRwjuAgDuCwnu9ZDuKAiHqYh3g4dXd4hwmon3qIDuxAWSx2LtRnWfIQOucinMTpOzHSItkwDdCwDJM4C6GgCX0ABC4QA/8jIAPvJj1CwgRFkjCiGAiFwAeamW+ciYr8hhsriASA9IIwOCUn4AZm8jxl4pAn6QdaZplAYAaFQAmfkAxAiRMrgmvLwAvJYk7DcAzLAEUTJQ/rUA/bwGSEWC/pp33nElsxIlvVAA/vAFqf1WMH1Z1cOH/Y+ZTeuFrdOaZhypWnlX/5J5byCZ8BKA52ao5riZZ5mA7iMJZ2Sp93+H//h4hT139eOnXt0H9Xx0aUtQ68Y4gzkg0NOltM9BJOJFvO8FjTIA3QcJjCAAumUAqhYAkYGgN7JD2QKQRg4JrwRpGLUAh7cKKLp5GmqIK18aIjKYMmSSbmJZFGAj1B4gNEMQX/ZoAIyxCUUZQ78oANyyBOwvALwpBOz2AiuqUPTBaA45CI7DBspwNb2jZb3PAuVYlQbNiU00g7OJauYrim0HZs90BZ42CIa5cN48CWaqmW6xiA3qCvdhoO9nmfiIiHd5iIU4d+SleP/FeHSsd/+WgO4DClMQI7lNpEj1WxFnuxLgEihZkMxvALrdAxobAJmbAIbGAHMoACkQkGQgCZdqCyVZAyixBdsjqrXaCRoCk/SJA8IpmrBqeSIZiaKzuR0lMFotiyRdAGxgqUyoAN8lCv3KAN1sAMxqALvmAskMMLw9AMJmIO8lKPeLin7rCdQpZt1KAOZ7qG5bpj96CuOFZa/26arm8Kp/znf+1Qj3iJL1T6ZLx1gOoIiH3Yt3/oh3zor20ZDuBADojIDgCaDvUID+zguOoQDvUyI+Ywtg2abbOVqdzSRJlqqRiLsZ0bIsqADBIqDLOgCqMACpqwCSIbCWgACVWQAgMjA6j6BA45kXZQCIdQCIVAB7KakYxRq/2WszpbmrHoAq3JBHbwiWAAou/mmlVwu0zQBprADK6TC8pQft8APFNmDMRStc86LcQADSYyD9wQDl+7nukQtqYFD5MqW9RwhtQ4jVtZf/0Anfhbbc6Jv22arvkbD+RYj/MYj+bIh9VwwNXgDW73DdWwDeAwuVXqr+cQDhM8wf5Kwf/16K/s8A6Ka8F6yQ75qA7nELnb0MDVcLmYS6lMxERNhKlN9Aww3C0wvLkv3Lmfi7EjogzJcAzGsgugmrr80QnlUwcusEd9Z6oMGT3KFXiF8KqC4LsmuAazypmdiRtFoLMwKnCT5wZ2kGWg+DzNCyQowwTHxZBfQArXIC7TkDmSmg3NkAuwMAqf0ArEUizMMr5B2Q2Hu6frW21aVw/vGw3b0H9bua4MlWNvuJWl5bYAPHXpsJ/oYI7iQA7wWcloycAIfMCYnMCcvI7e4K+UjLhoicEjfA79Z7Do57hz+cETfIBTug2BrMItvEScG8PbskQz/AwUW7ExMcOPBQ0x/Az/N/zLOfxOvwAMtdAKqhAKlfAIjKAJkpAJnIAJBbc8KHDNKoCBJLA8TICZi6AIhBCrUTzFNju8V4yrMLCzJPkCK4kyQiAkzUu7qtq8gIeyU1AJzCAuQKkN2eBby7ALmoAIiFAKr9CLviAgJ4EM0yoP3HC4gep+X6QP6hCxs5VG8HBa99djbPuFLtaX8FqAkkoNbcmWniy4JY2AoBwO9bnSoVwO3mCnMD3J44ioq+yv55jJKTyxlypbMszCnJu5nBvU2xLMulzUMBwTSA3MOJzDz7cMoisiOnwMw6ALssAKHzsKo+AxnRAKqNDVrxAJJ+A8KEAC20zWy+N3bHAIJWMI/4Ygziw1xchRq7JxzrgaklncSLdbJBN5kquqxO0WAdvMBI0ADNcwpEN6DddQDJfAB3tgCYzQCbawI7oAOcGADCYyI+Egdd2ndfcAyyrcDvowbG0IRmt7D+CXDuxAluIwDuLgjn3IW5cL0gX4DQNYluNguO4ogBiMn/+HDpNcDvv5f4k4sPh5wCicwpz7WEF9qct9qUTdLTXM092C1M/9wjCMwzExItq93U4NIixxROkELdMCEqdwCqZw3ugdqqUgCg7xCpgAAyCwRx2wzSc7MLJLb4cQCbybCG6db/pGs53ZkTJVBD2AAzwAAy544GwmAyQwPYAnip5wMEDSvEwgA/8+ED2DIAq+wAyF7TrXsAzFYAuZxAeJ4AmbEArgpEMr0Qyaszu8Zjqf5bhQyg1GJlDuOjrw0g7ocA7kwOP6qOMTfNvxiH7qwJdI56iPyjv1UKjwwH/v4KVMF2ykI57xcKhPzsH1eA4Pqy8hvaWzxS7som2wc9xkHrFgfuZonuZgviK+mRMzAeZuXk/WIA10TucyYZgjssPvFL4PIhADcQqqUN6CPuiqUOiwsAq0gBCzAAt48wqeQHkgoKHXfM0g6Aam6gN1sAivygeCIM7jrAaLZ4qneBug+ZEsyIJXAQPcEwO0q2XTw9du0HeQaSSCxwSBIFSpkAzLcAzM8KldDQn/dhAIk9DVjJAKe2MW8TStBhilXnTI/UCOUbeP8HB+WX5+6sAOj6qXAAqgPZ7Z277B7fAOH7x01v6ofElZrmV1XAiljnov/nrCZKvCKyzv3nLmX67mLAI7Z97lKdbv/o4Tcy7ncU7nAc+pndrdOzyTwWARHPHngz7o6V3oEj/xE483B9EKrHDor8AJXwAD3DwwI8A87DYwMDAFdXAIrzpm/S3FoB7XqaiKHXkbrOhn2HUVUhM979yhkFkFFV4FEcmhen0I6SMK3nvMrVAKb1GygTD0jRAKodCLxYJElqMO52da1RYPfFqf7LiWFxwOt12PSkcOwJ0O70D2Zl/271Dl//EwbHBqqIaK7fbC5bG8y04U1M9d3bWsyy9M77JV53Wu5mD+9yg2DW1e+H7PqU6dFjO5LA3/Eazw+BL/+KxA8YGe3hF/3pQ/8a2wCoduEHfjCXxQBLLbPD5gAgODAjHgBzIQA/QWCJqeCIXwB39wov7N8rQK8/3GimpmTDavXCuroysbPc1bJivL6rR+XqRQCqrgEMVACpEA7J6AZ4uAB4kgCnJACr5QDIgTT1lbZOxg9fswlvLJh/sJyoor5ORA7uQosPv45IdK3IhYlgh8uRNL792iwtVN1DZcw809w9wSzAABDZo0ggUNChxoUCFBaMscJkt2jBixYLws8sp1S/+WK46uWn0ECZLVKpIkWalSdRLlSlMtXbJsuVKVKZmrWr0iqSpVqktxPPl54sYOBw4x7MQgEUMGGBlf7CyCmqgQnz905sxps0ar1jRdu1BB4kQskh49eJzlsePGDrU0wAh5wsQPGDB+hAiVwaSKDDdMVFSxYwfTJE+hUL1CPGnSIDaY/tgJpLgQnku2fBmLiEyzs3P6/v3rty+dOHTv2I07dy5cOHDgwqk7t46dbHW1161TZ44bt23buFEDDjzacOLEnTkbfly5s2fNnT+T9gyadOnTi1OfLvC584QFp2+vjlC8QIfllylThkzisGHBKmLMuLHj/Pms7LMKWdJmK/3/q1J9VGUVmVDaySUDXdoplZYSDBAnkkpJRZQrPIghBjfASCGFCUbwgQkZUEBBhhSm+COSSBYpZCo6rMJqDTXS0OrFNL5CggqxnECCLLTSUuuGG9xw44knwAjKDyaOZEIIuCARgomgwHgKk0w88WQSSOpwowo2INmyGFLYQAUVON6oBBhmmJkOOXPoqYceffRh55zZcjOnttx24y2bbIITTrnhnlmuGUEFZQ485Zo5DlDpGAJvPEATHWig7cYT75lmHG3OIfTSU2+i9izKJSONZJGPPlPvm68V+wbsz79WdxJwp5VSmfVABAtU0BQGScIJwktscAEEElAQAoUYhBiW/wMUUggxhRimCCQSR1Dkg489VmzxxRi9spGKbnE0a8ceb+CLCTCObFJJMKpgIgYw3FCSL0gGo7INO9jYK4YnDvkDEyr78gQSMmaooZJltNHGGoSxwaYbh6eZprg/m3NGUPQGxVgZQsF79LlCOWYOY5ERtbSZ7QplLmSTKab40oY0RU+zTj1tr6JQbxmVVJ1JNZW++34eMGhbDYTJlFIgPDrpo281MMECS2k6QZxSQcUSGip4gFkMUMAAAzdQYMKHC5aKAYUX2DjkxEUS4aOQP669Kis1YlSjC7vttnEss3Q8q628ztXLXDvogsQNGZQUoooYDqESkoB9qFCGCiGhHP8Vuy4E44Ur8HjkE2GWYUY9mUefiJhjRkdds01X13jklcG7NDxoXJ590GVcx93kigU9b1PSiWHvPfhCzcUi99y7SFRZctbZlZ15dr7Ujn5etegDR8E++5ayz17po0mBemnvdTU6V10T1A+nTfjA4QEJOiChawxSkDyFDp11dgo+IplkkWlTfJtV2iC3ubnobngbC1l6wLey7IAG6QqM4RxXl0PIABOYqAJd3NC4OtihCG6wix2q4IZDHIINgfGDHYDEhkKQ4hW+EIYwjFE6053uGDa8oQ1Rx7ryNMMhK8uOQA5CqYUU8SDSEE95YpZD4B1veMSDYhSLxwv3sKdmyLv/mS5wsUVc1AJnuMBZGL9Yi1rMwoxmjEUsYLFGNsIiJB9ZBfWAFjT/OM2OucKV02jiRliQJBa8egUpzICDOsSAAxLAwAUw0IEYdMACw2KKs8LGB0hMQhKNmApVWDTArcQIb97yFo5yhARx+YgGcRGCClUJJDvEJYVHAsMhUsiGOmgQEn4A0lzsYKQREgkMbOAEKlJBCxkaI4bEMMYNIZJDZh4DIs9MBnqiycNNmac8lBIPmrJ5JiVG5IaeEt7wxChGMOIsIzeToi6KVzz3gBOLGdEiF714iy1+MYxdPKMaYaFPNn7EjW+cI/WCppM72jFqBWqJG0tSilekIpBlAIIL/2Qggw4skgSM7ACzUjACZxkrBiycBCUcgclqBTBuWaGbV74SylHmqCw88hEsc5mluMjgCXPJoLn6woYpnCuDQGqSlihHpA/lZQqiQEUrbAEMGR6zdM2EKlSh+UxlTJN1yrBmN5eZw+AhDyNatKdG6llOcpaznmXl4hZ1sVZe6OIXvPjFMWcYzrXGU561SOsWyUhGM9ZCja2AXqo+IkcBrWRVKiGQTGIy0FshdEE7eUWYULEKT1xhBS1oZATgt8gUgAFsFcqQRovgiUVY4pJSKSncsDJAuXVlRlRY6Y1aGi627ABJevGlT0lBCnRVoXBIalJfjpRBNpwwSBj6ix3qAP8+pcLQmE4t3QyRaYwZJlOZzpwqNLF7DOp2l7oxdM8v3lpXMKY1F7i4GS52wcVdrDeveyXjOPGaVy7ala1vFe8vghHDGdasrepcK30FrNe96nMWsoBF80ICtILKxKBDg/CDU7EKnEgWFZsgAwtg4AMSXBQFfkjBBUaAFCEYMgZVSEGHT7Al0yYCtVSBGyfXgNIX4S22CdRb33ZQoWOV2ENKmdeRJgoGTAiFDRqUXOI8YcI6pDBIhyOhJSa7Clr4ohgxFIZ7sDyMiWAZujQkhpezHAzxErjAZEyjLNIIi1nQohZuni9889re9u6VznfexXzTqkXyBriuuoBrfuMaV2P/GsOK7RFvoP884LSiOY2P7qeqRFK9glbafDOBsEuOlgqlTXgnuyXFJq4AAhPgIAUdIJYM7JACDmyABCMgQYaUAr8UvOALpT1tJk0qYxnP6ICgTOAoX8oDJXloojx2kpGU4oclM2Feh4vXkNwQiDpM4hC5fJcfGDfZVsxiF74Ahi98IV4sC1q8bLXrWXH2vFasuY3vfnS8+blPR8dCzXvtYr71rOe83hMXf7YILgK9Xy+HGTPC0G8wwFzucy9awGjep7v/KWlV3Yeglk7Q0jJttKS1ZNOdplqYSMGJGWggWG7IEAn4YgEU4EADJ0DBsJgVc5lzobSWcARq9RBAAcqY/yt283Uogz3bHjhJCJJ0kh0O54e8QGJwt2RSkqC8pF5gonBCCdhPWoiTNeIC3HimMxlpQYszziIWZ3x32tv4xkiDRO1sNuO7l+fFneHVi3dHq1r/DWiL/ALQcRUzf6lLDF5IBJmlI3iWG55u9ubZrwiOeNtBQpJKz8qxUIOw9zTvvcOgYuQ0cIADYN5hEqggfh0oAk99wEgUUGBZSXHWrS1BiUboHBBV6TlKf37AGw99lFCSgR8oRwq7PEEIknO20tcldRmoQAXHFwIkUCHcm7oBEsQHpi1s0YtdhNsXYX/z2GmhfVqcPY1of3uk2z7xkPCR7W8ESamexzxSjZOeAv9nq0XcCtfEY7m6MlyGYwjA0gkexWu4f9szLfK7LqoFUok89pu8wro4WrEeojkQlDgQzEsakQM1KokEE1AAB3iACegACaAADIiACxAxo0AFTDgWVMsoGaggH2CD0ooEF5sKPRCEa+m5GdsKNfiCLgjCIPyKGylCl8qRvBAMJqASpqsCXFKKd0Elc4kXmzKXc7GpXWolIDE+NvCEXgCGYuiuXxC3MtyFXiA/8SujNBw7NSq/s9ursUvDWBA/8Yu3OsTDPKQFf+MzBNQ7erqFm/mitTI3t8Iv8QovKgqG9kgGhyA8UBFEjQijwOqZn3GF6lGFU8DA6+GeUTCQTgRF7Dn/hVE4BfpQs1aQQ1LAAzTYAhyAARgwARPYAA2wAPiBHxKggAs4wWEZgSKoghF4JAroANPzgxjAATuIBEs4EdTKgz1wRquQg6zQvS9Agy+wRmvkAiqYAicoAiToxm/sAR9APiYAkrfIi7k4FiJxOg8ZknQUrrzgi2YTAjBYguNjgi/4wjCkrl/4Nl+ohW/TPlt4szZ7MzZ8tDasw1kISFuowzRqwzR6M4ccuzejSDwsrwT0Mz/LBXU6r70zREG7L0FjJ0VEE2kgvGAIFZQkHvt7HkpkhVMAmlMwBZmkye3RHlMIRe45hZ1kBedhJ2JABugQImkwBlwIw1XIsAowgQfg/4AXOAEQIEEQeQJIiAFF4hoSOBeuIRIOGAEVhJ+YO0b+WcYctJY8wIM5iMY1kAMfRIO2NAMuwMYpkMu5nIIisMsigBzJCQoLcgN9GTLDoQtY8hDhe8K9gDY/eIVJaAygSJIn8AE02ARbKIYw/L5//L47C788NCOE1MOJ9Kt6k7d4g6/RlDNGq68/67OPFLS+S7SLABUqGgZmsAZrgAaKqIjFC5V0Y0lKvMSX3MnfzElS/E2fXESgRAaNeQaIYZhs6AZ5oAfnnIdu0IZlCAZcKIZXwIMVAIETsACWyxARebWMQjEZ8DAKUIER6MoT2ChcxAASOLoYKAJknIQb1LmyvP+KaGyDtcyKtkQDM7jGL+CCAKXLurzLDKFCP8AEpiCq43uX4xMS43OSoGiStwCDShqtwsGpJimCLXCEVwAGYKgFflSv9rrM9mLDzszD0PQrSBNNvLM70sQ3AWM81ORIvtO/QAu01oQruMoFYZCIZDCGXMCuZIghc3NNKYpE6JEe5/FJi+CyGzpOkxmOaWAYbMgGK8XSbDAH3eAGcBgH1NCHepAHbHAGwhMGYEiEFdCwEXiADugA9ESBWow5DFCBGDi1izrBRIKfE1BPRRIxFHABaFGMseQDPbBPtByg1VoD/vTP/wRQLhhQAj2WJPEDyzk+O2gXC5Gpm8qLIzESuSj/RzdgAx/AVBC6trfQEhzgA1QINzJar10QUS4KyInEwzZ7Q8681YcMzbO7hVno1ftjNDJSq3T7M+JxzWNFVnMTNGFIhl/4hFFghVGABVVohStTTWRNHuJZRC6TmdZBjmlgzuich3El13lwznpoE3nADXM4B3VgB3VoB9zQ0tpgB3aohzd5TmywlKoihRyggS9ggguIAM2itQsoChGpqBNMga6hgBFo2IyKuRPMqCfAgS/Yn0nIOanQA0PdA7OMmzVQVEb9TwGdApKly8OJAXLsi+MDrbowl1fABBQ6hBhAULnwBCAhRxosLhDaoL5cHBPKPu1rL/FqLwasBaF1M4YU/z9blUiJTFE1kreyK7svoi9hVS8/3LusDRX4wNaLUNaL2C9jugVmBYZdaIX5Op5DK53j1JhvnYZyLdd7fZO5DVN0tVt0ndt70Id74Nu+vYd6+Nt62FLd0BPg2JNpeIb04AVTkAQzAIEW2IATvAAPExEV7LAOWIpFijlEirULqCg37QAOSAG8lIO0wVgXI4SNdUY9yIOPXa02YNStiMspANBIlRyUtb528RB0YYJXKAYjeZcqYBd28YPiPQR28QFSZQPhsz475Yt1kYEpiIRXQENagNUFZC9b2IXxO1FdfUPzOz+oXaNdldoG3CtANFo84zP72rsbTVbXVNb8qghdQP8mYcgIXgBKjRkOw1UH56SH/wVgAL7bASZgdA3gAwbgcXWYbrjSK4WYaSiIiHGG6IAGZSCGWxiFSmAEPXCBDeAAFWzT0LpcRYIf8pyo1gNdWqO5C7AfNDgExZhPqdjBPaiWja2DFsGKtHRL2bVGu7FGUAqlGFABVVuKuSix6IMXT7jOc4EXwaCLc0FMTHgCdpnKmJ2LmQWRI+kLGQCCQkCFXkBDOlOr9Tpa7lXahDS7eEM7s9un8T2/NJa3+KJarD3NYt3av3urrgXbbX1StlUGZliGmUGGZpiGbpgHNtGHflDkRa7bAg5TujVgBP7f6Fxg5lxgBq7STK5SKsWG2TT/CGYg0lb4BEToAzmQgy2gRQpYgAWAWBRoNQ5QOTflGlRjloxaWCHwhCowFmVBg0DABE6wBGVcm0yqYT1wXVOWgzhYVDTg4R7+YW8pwsOxKeh7gmO7NrmIWcARPkjAQia0nAsxlzBZF8pxAx8oAmkTXiaYghb60GIoBnH7UHDzPnEDYzD2hZBAicGao5SwD/pwu1j4iOapv3XTmTCCokCUIuPZVuOM0meIBuDghv6VB/+d6NzQk//F20Ve5M94k0hG4DYxYHW9ZG3Q5JI2aSqdzZSWBmuAGO+ABkBuVlgwBU14hD6QijhoAaLoThLgAAs4AQ5YAAq4KFx0PTelnxGq/wLMBbHJPRIciAxgNi1MIuaNPUtTboMWWeb+1ApHddQidIISmyi4COvDSRJzjKXBXBcs9K3ixYRPxSVypBwP0hKVjQtR9cIw/FB+JFqwO0M09Cd9ojg5EuxL5OeejB75E+iE3tZubdtoANdu4NI6mWh60OjK1mi6fRNF3od4iIfNfod2UAduyAZu4FI92Q09Qe1s2IY9YU6Tdu1M5uQqVemFaAgL/gVYYAVT6IRGcARLcDEaAIENiFPP7c4NeKSYQwHPneUUeAIpTjESuIDkdk9jLAROgOpLSpFCLVQ8OEu0lAO07KS23GquvsbYUpIqCC4qnCh0cVCpy6AmyYtj8f+ttsYleDk+GaiCQ2ACNiiClN2ltGaDVQVDWuA+PIuFOHuzd2sFWBg7CMSPgBLsnuzJ5UFoXmAP42xbTmZOeThkzE7kRbYHEIeHz7gHe0DXdmiHv22HOLkT3uiNaoDxauAT5cSGaeCTG59xarDxB6ZxhnlgH9/klBbyInrpADSmWmCFUhCFULiETEAqTKCBF2gBsxkBDuBOEkA5CWAKze2wZSFPZ5kfFHiACCCBEyiCQLDu2cs17a6DNm9z717LNYADrWBmF3GtO/81KoALeIlvn+LziUoyuVBQcIaLoOiLt5C2p3M6SHCSZMPvIakDPqgMNGTwXbAFOoxa6x07NCL/yFJBlcI2bFJJySc9hotZFCod7W5QB1WXaABWV9moB3gI8X6Y9XFIB3dIB3YoB3Zwh28YB3aFjS7dhm/YE2pIbdSmhm0ADh5nduEoDmaHGMd+4GeP9j/pDoQAZG6KiBkCL7/TiJOwD077HhciBTQAARCwgAkoLp+2ck+wgwg4tUXCAArIRSDhLFoTaj6dgkXwBExQ89ojSzd/c6seIDiY8zpXg4SXEZW6GyqYYuNTkpSFkr4oEiRxA0zwkHcpR5VlA1e6oCJztnXBVHZxkr4YISaoAyp5hTTUvl44u4bcJzMyJ3SaosWO0oGwBoYxh0MWYIzGW3w9YHXdhl+Pk3EA/wdl55P9TXocV3akx3Ec3/EqhXpol/aIiYYh0g7p8KGYUQ+JQDhd0AjC3kSc9ESbHIVNa4WdUHKkQgU+CIEWsABYZgI7QIEJuAAJiDUmSCR57xoWloFFAl0KeAAMsAAX+ALCuO5GQBFqqxY3t2pkTuY4mHO6kZEucC3em+KSf1AhYLYguSW9wBxybPS0Ll7+ZrYiG5y5mOKlIEc/SOcmeYI6wIQ60ANOWPmFvP2FFMhd0AWFY9vkZBhDhttyRWS6BY1/yNt6cAd22FLVVm3hSHqJIY5pn9Idt/4dpwZs0PHth/Yf735oRyKE2PolaiL4uIWO+M1RDM7sCYX2DwXsEf8FURiF+CeFVYCaCCkFVOCERTB3YXFlEgSIFDEsoMBAIQWKDgYpYLhA4YFCDB0YkujQwUKRQJM4ebJkSZKjRYUC8SlZ56QcOW1SpowTBw6cNWvU0FST5ubNLjp1PmEihAkYJj7dCAHjxujRJ26egGnq56cnSD8PuWECCdJRJjLcuPHjh4mfo3a0+lT6hA0aLnEsoXqFihQpTpw2bcoUahUwYMKOLcM2jx7geYIFAy5cuB5iwPXoyZNHz1y2yJKzYaNWGZtkapo3c948TfO00NOwkcb2WbRlaqJXn14tTZq119CePVNmWxmyY8SGBQvG63cuWa6Gu2Jl3Pip5MpNmRr/NcpUcuegpoeqHmr6dOfaracqVSoVKVShzmQwwSGGGxkSIiR8guLChYYMUZDAYNBghwskGErA8ICCBTEEwhEnHknSSCIjlcTHSSixpBJMMMk0IU1pVJiTTmAIsWFTVQmRglVjgVGFhj9B0lNTV2HlxxM+PEFVU5hwhVUVXQmV3k9gyCCDEFMwwcaChRRSBxtsnLRSJ70kc8wxyvhFTz3zdDNlN+qYY05nmmUDWmSkUVYamNpQmc2Y2YiJGZpeStbNaKW1GZpprE0j22zPONOMbcjkRsxuvPXGSy6B5nILobIYeihxiR6nCqPMOdqcdpGGst112VFa3XelhKJpHCuA/wACBymkoNBBHYzAAQcKxXeBQhZRoCoG/cmgAgYRULDBC4cQaCCCIwXyBx97nDQHscSq1EZMbSg74UxqNIvTTZj40ZRShzARA3oyAvXEhkLY6IYddkBix7Q+xSAUR3a8AglHVSUVllEjkghuV2EFEsghh5DrlRuFXBJLMssoswwzr80pjZwJJxynNbE13LBopLEGpptwShxnaK9JA81seN6mJzLEgKxnn8H46WdvKf/yG3CB4vLyLbUcKhwssLTSinGMNspcpKNUih3Q07VS8ypFDx2LLa+8QgoZDlRwwggboDBBBylYQAEHFFyQtQTxyVcfQw1hMIJ9ri4wAhq6yv9lCSWRLCJSIYII8scedNAxh7J5502TsjXZBG0aXnhhobQ9FfEjtmaF2xQTSTVeBRtcVSGDVjIYxcQkmNgRiLiaHyIjuZA0hRQYV7lRI7l26AuGHVz5cQgjsxjD5DHJ3DZwM808wzE0GvuOcMIPC29NxGAK//vG0OSeJ8i68fn8MNFLP8xufDIZsvS9Rd/bL9173z0vuuSCyy3k13J+LbHMEkvNNy+qsyqORioK/fT37HPRqRStStGvtLK0HCpgAQt0gAMkMGAHUJA1h1BgBBWJlUH0IxH7UCAG9RmBBPygHgtwYRFyKVDb3iYkudXNbnhrwwn1poY2+K2FFRJcGkb/9JMi+IAJLrID6Y5yucaFZRJ+gAQmqvAEGShlKZnzASRIAa4V1cgPdnhCFYAiRK5Iyw6YOMQPIVGHcJGrEJJohTCIQbtjjExPt7NN7nLHMd1xzHfDQx7HmLEMgeEmN7R7Xp+mp8c9Qg+PYiSj87YXDGEQ8nu6MKQuXpZImM2ikeyrmc1uFslW7C9+zPEOJr3jHO+Y4jv5SwUoU6E0VMghAxXQwNa2hqpUjYoCrkxVfjBQH1ZJQCEpkEEKWCWDDsgABRQAARoiwYlOiIJtboOb3ARht7vhjVh625sLWxg4LxglikU4XBWi4gYa4ZAJPemKGzDBCTZAwolC2NE5IfEK/088wROY+AlXhKCU0QkxKCS6ilei8jo7/KEO4ApEITbRCl0Mwxh8mt0YQXbGM86xoXRsnvNKlrKJUnSPFr2oHvFYOzsGsjeF/N4ufrGLkepikYxsJCQnScmiGY0VOgtlKDP1qE6W4hWiRAV46GcLUqAhBBuAiAVQNQIZwIcE55zIKlElS7J1QAJaQ4EQ7oMtV0oAmJPwRCc24ZFjjpCEyyxWClW4QhZG82+jY4ob2FCjJ5TzKODyQxWq4MQnYEIqTCCFJygnFCYcAhKHcIpPHschP8ioml3RnFecKK5ADOIPXYFEIEIBC1oMMozGuCxmj4FQg2aPe7ogKfluIQuYEf+qtIIqKcu+lzJhXDSP0/OjRv+IDNxQj0nRE8YgveeLkfL2Zec7VCxkAQvhuk8Vx3Ep/OAH0+U6amepEMV34EIKUXhCFGYIgQZaoAFUUY0EYEgBB0YghBhwYGsdIIEDHYKC9d6HIbaK5UQu4AI2WGKYWrVEJEKSoEIMQhAlZGaxnvnMstbkm1yxAxuYEMWq1Mh108pK6xqHlfEKBQwvsBwYXjevvRYREkIporSMktjU/Up1fvgDKV5BC18A4xe+cLFISxpaRCnKODcbWkpnMVxZlFbGJf1xar3HC+1hNHrPI2QYrffH6wHyedzz3iFl/DJcnC+4MxMOzo77PvgpZ2f/M1XOcW5WNFQgSA5oAIIJXlCBCjhgAhCRQHotl4IR5BJrDkEVCeozKlJVpD68TAEFSBCBDcCAD+LsRCe2GhK49fe/YA2wssJKVrK2ECtc4bCCGze6peBww0HBJVmKUoTRAYUoPTlnFU7kzRqNblphEVdfX/cH1ZXzEKRIGiweeeNd7zrMxykOKxKVqCsfqrTGDtRvfvEnijI7ZRblk8mo97w5HkNlgAKO+GBmvlvMotiGGo6WkQNm4wwb2bWd7cB61zBmMCMZpFiBAxiggHk/YAIaeEC9I/DnDZDADTGgj9YOyCoOoCAFJEjBQmRJAfpgIAVCANsIXsAHjtBF0YtI/0SC+uvfrz76hJIWMKU90SGfFGVaKRpLVjRdBXGB4VznlEFcmRLXqvBor1ohkU/m1ZXSVdEr5VTsW1+XYv+1osZaBnawWXGKYAt72MQ2lLEJJaip54JlVl9Zs7O+vZP1rtrB+AWyWTb1WwhKtMJpOnEEpT0mBYwZ6r4G3K+hjblfAxt0j81r2r0KSrzBAQ54QAIS8IALKADfCzi8DBzIgV6OQD+rLHjVzluQ+NBnlxVBgRtUcPApsMGDw0w0fh3hCIwXwhAaL2HHPf5xAduEKN7SCjib4glPAOUrei0KKlChI5wLIa5CqcI5hRCWBTPFE68OCuvCNS5yYRGf+PwhJv8wUYhO0IIVUMcFLwpFdqoLClC5aPrZidMK4RKn2OWbuvernuwhM/s3f3L/RP3Ei5UNg93L+Pq1ud999hsZ3c14u93NnQAOoDZgA9w9zJy0URvhXbsJAyykQic0wg14gAUc3sFtwAIElQZsAEFUhAGhSn5gDXo5EENUTS5VjY7Yx8Ed3AjEABp4EF1sAiVIQn6NXoIYAgmhnjOBHMjxjd+AwSE8QQx4iydQhbi8AqfZwYZUWIZNi7fsUFb0BFhE34jECyYYheawzg9NQrj8EBblS+q8ThYVQh98wi2snWtJWx5BzzC4Qvhd2SPBQiNFnSKZltXdIR7mYR4uG58sSTL/zA4xaI/ImFEatcncDYZgdMPcucnG0IYzPGIjKuDubMxrWAM2WEMBSkMD0kJzhMIlkAEFJsACXIAEbCDBbQDUIMTBXcCpvMcFYItDjIArhQ19QIIMBJpFvOJAmMAUeF5WzWB+XdwNJpOj7SAKGSMPUlo8KVhiGUVPNBhR3AgUgcVTOFG5dAW3SBhc1RMYzNNRSItf9VVa/dCreUX0fY6+yEEiPEIl5MLzkIwfGdkaYs8wAErUlQ/5KNIulFRIQZku6KHVvR8ehp2z9UntEIMrnML3KaQyWCJpDCDFxEk02EkaVaTu3EnuOANtNING0oZHRgPH7E4cQYMcJYMwcCIo/2jCJThCIZjA4SWAK02AG/iAm6GSqWxALpWXwREcBmEAfThVfBgcJMQABMkSVFkACKzBJGQCU8ogDboN6eFgDi4TgM2BCSEj69FEhQFfUEgO8jHOEA4RiYCB8YVLV2BRVTRO5zwYvXQjUqAC6GSYvoghDh3hW/QCJPDBIrxCJZzCkA0DPPKJHmXd17kMLvwYYv6YIv1j9/gG/BEmHw2i/z0DwlDM/bkCLxADL7hCMCxDw1CmNEzkI96JR2KkRaaRMlTkQuXOM+gObdCJ/S3DHwrDLszCKtBPKcDFItwbvj3AAjzAC3xKvW2A1PBbLqlSfpgXqaCACoRN2exHRQQaB/+AQB1YAl1kQidQQtsE4w1qnH/9lwlxXOoNmBqQiCc8ETe+nDcVxRNIIVi4wSH4QFR4U+MElhZmhT3VZYaNhbhsky2c5x9cxVxOAipwAilgQop5giP0ASioXW88HYQCVy1MGYXiAkkxZrO9Fp8oFEdGg4eOhphQyWBMCTeU6JfMiTK8Y2pSojQ4YkY6omkuTxrR0UI11MAoQzLoCZPsxtcl0izgTCs0ineIQu69Aia8gG8uwAH85gRMgAWYgAVIzQgoUAuWFyk6RAI5hL7JgB8YxNVswKuQAMCRwAu0QHUOUyZo1XaKXoIowiB45x7EqXiKJ1hFmt6ABSoQRVj0Huv/ZEWNCBEPhUVVSEvtzRWPbNNesaUzdkXvtc4rFAMm1MEf5MsX+tVIHEIvFEMR5sEjyIKgeGqEvuGhyEzU5UJJ7d9fihG6LWAAEoZh/MU8yEOsdoM50GqWcAacHEzvGIzBeKhHUuRG5s4c3aht5KiOdpT3iRZxKMcpPAekPIcm1U+CmkAFcMADoEDgLUApgoCbLQAJbICT5scC9YcE1FLYPEAEfMgBudILqMBENJVA4MAgWEImcEKaamcNjl4huCmcxil4EgudOlPHlZo9HYW34JwQochRGF/0IdjpdIXqIJ9XtCcQYiNXSM5h1cFG2MGbzprqzCWlcgRkCcIjuGHV//kGj5kdopifaO2fyQwiGkVDaQjglCTiiJZJl4DJl5TGlGRDiZooN+TsJTZMr0YMHPHOQ3XUygxK+IFblyXXcnSSc2zK1IICdNGPGVQAuD5ARRxeBIxiDHTAA2zABYxt1mTN4OWHU1HAejREfLCgBJRORFjECfQiJmzCXGTnmgojv8LpVFIl4Fblo3Xjg3VlhtlnN/YEU2ARKsTaiLgVOHll8vVpUjDF63wOkbAB52yRuPzcPoXhIFDCKGxfbyCmb03oYf6CMBhDwLwdzSIiYUiJAIJJNHBGZkSkaTxkAXoJZmyDiUoGaTyMxkxDNIRG8bYm89jW+30q2oHb++SMcVO5lClIL00NqXZQRyXYAAhswAg8wHokQAQk6W/60gRwoC+9B9teQATYR9f8h9hOBAVATdREFX50wAm84FzMRSZo5yQEYyMsQt8mEzHKaeAWcFUGBAAh+QQAZAAAACwAAAAAQAEAAYfmvZ3ZrY/WqIbOpovRoHzInoHDnYLCmn3JlGvBlXS+lHW7lHa6jm21kne0jnG3jGyxjHC7iWK2ime0iWeziWeyhWOwiGqwhmOwg2Gth2qtg2KtgmCtgV2qhWmqgWCmhW2lgWeuf1urf12qf12te1GpfFmnfl6nfFmne1qneVSjf2aifmGhe2KjfFyjelmjeVmidlmidlOhdFCefGKeel+deF2ddl6ddlebeF6XeGGYdVycc12adF6Zc1ybdFiec1GXc1qUc1ufcU+ccFCbclybcFGacVuacFSZcFqZb1mZcFaYcluYb1uYb1mYcFWdbEiZbUyYbliYblWYbEuXcVqWcliWcFmXblqXbliXcFWWblOXbVeWbVeWbFaXbVSXbE2WakiUcVqUcVaUb1mTbleUcFSTb1STblOTbVOVbFaVa1WUa1STa1GUa0qTaEqTaEWSZUSPbleOa1KNaFCOaEqNZkqNY0iOY0GHaVaHZlCIZU2IY0qEY02GYUuHYUaCYUuOXjyJXkCGXUSEX0mEXEODX0mCXUmCXUKAXkiAXEeAXUN/W0V/Wj98XEV8WUF3WkeBVTR7VDl4VT53UTd0UjtuUj9xTjZrTjlySi9rSjNmSTZnSDFpRS1jRS9nPyReRjRdQS5dPytXPy1cPCdYPChWOylROytXOCNUOCVSNydSNyNSNSJPNiZPNCNKNidQMx9NMiFQLxpMMB5IMSJJMB1ILhxIKxhFMCFELh1EKxxEKhdALR88LCA9KhxFJRE+JBI6Jhg6IA42JRc2HxAxIhYvHhE3GQgtGQsnGA0kFAgnEgQeEQchCwIYEQcXDwYXDgQYDAIRDAMWCQERCQEMCQEJCQERBgASAgAMBQAMAQAKBwAJBgAKAgAHCQAICAAHBwEGCAAFBwAGBgEFBgADBgAIBQAGBQAEBQAHBAAGAwAHAgAFBAAEAwAFAgADBAACAwABAwADAgAAAgAHAAAFAQAEAAADAAABAQECAQABAQACAAEBAAAAAQMAAQAAAAMAAAAI/wC/CPzyQ0MBBS9+wEDxA8oUMF/guHERww2cHxhhfGGkhY2bIT9ilBiB4sULFBg0bMAwwgWHlydGmDhhwoWGGqNi1dJl7JqyYLF0pqJ1qkpDhS9u3CgypQhGjFCKKL1hEgaMEihKYI0RA0YMFCNOkiyJwgWKsmdNegA7ou0JFy5OxBTBocRLERsqVMCwgcOGvxj0BsbAYcSJGEO0YPJ0KpYvXbBSSZZcqjKpUZdJkUKFihQoUKRSVVblOVOmTZ06oQ41KlSoTYgqoarc6hiz27eVJStWbJgwYL1muRL1SZOpZMs+/Xlkat48atOiSZ8uPbq069Ck/aIUR0UGCAssWP+A4KA8g/PnFyxQwF69ggMHDMg3UKD+gPv4BejXP0DAgAILqDDHIZHY0AEPozBzTTbZFOHUUjcwUABFT4E0hB1tSOWUQjfc4cYRjLjBxhdDpFDCCVmRNAJfI4jwVlsceODBCS9w1cIKlMQiC08+GWOLjqzAIoscJpnUQgsu/OBUQlxh9AJcLrxg1VlglVAjDCJgtdALULgRg5RWncQQFGTCMMIGKJjQ1poi0NWXX4L1BZhefsm5QQkxTEHHJKOs8ooxkE0mWmWVnWIoZ4hWhoqgqLyGGiipuebaKJtUokllkuWSyy6c7nLLLcK5YsqopohC3CemuKIJHng8wotz1kz/Iyt11UmTHTTQMEOLI2Ks8F0DGYhnwQPEMlAsA+olqx588RkQX30F4HfffvtJa0ADIOAAQgYdGPLLNeAW8YWGRWgwwANKtvFDkl/Y8QUMLsCrlJJfuBGIu1/EMAIHcvnVZmFyHcaVCDLOSNMFGcwRiy2/NPxLMLbIInEqtigSV5QmmNACV09y/CVbJZk01lmIQcHVxy8MYXKRYqEQQ1QvyLSBBjJu4AEH/+KscwUT8HXBBSvR6ZdfI8gwxR2BWNKYLw3LIpkqnJVCmaFUR72ooKl09pmkoYDSWiiagUJoZad+YvYlmhR3SSVor13J25WwKjcy2XAT63XU2Yodrswc/0PKH2LM0AEEEGjQQbDiPeAAsQ8gq2yy7zF7ALTR5ketAAH4h5+z/x0AQifKgDuQQE4xMIAJMDjpYL0OOuXgDS0c0cZGWpgVMF1+8QWwYTGcEKMHGtRkwgUd0DAKw7+08ggpC8sCSym2cHIDDE9mbIJJaX0ZMwoitHTSCVppVdLJX1GZlkxqjuBBTT8MMcIFaYJV8EsvGUZXCBhIUAEHGFyQJf/0y4v/3mIHTrxiYcHQBS1YwYpVqIJRiIpgKRbFmVQ8UDSa+VooOqFBy3SmFKLQhCbQpolKPOKEj1jOCf/ABzy0EA85yEEQWiWNbMxjGnq7zjOeYatbMSNXwdiEHv/ioK1gychwiHsABRhXHvU0AHKSgw+0pNUfagUgAPiB1hWvFQdY3GZ2X2iDFnzwBQ8MwAE+OIK43NCGI3zhCHCkylSk9II7FMEDG4DRnIDGr5j0ZSRv8UBLToCwDmTCFrYIRjBgUQtZvEIWtWjFAX3wA5NkTAMoiMlY2pLHtpiFJFppy0hg1L01jcV6JgBeKtengVZqQCYtwt3Q8EKY/FXgL32hCwYwMIFbVuAC/IqBHTARi1ecohOwgIUqWrGKZqrimc1cBWcc+MwLTuaBiArbZ0gRis5IajalAAXcLPW2FcrtnHKL4Qw1cQ3n6PAZ0nmGM6Sxwx5CQxm6uEQeiLj/gsOtYAUeAEEHOiAsCyyxPAh1ABSjOEXLXU5z/ynAFQdggA9IwhjMcFAbPESHQLRBAQN4gRZeIK4vaEGMcPSBlCp5vSO1oUUr4UteftkXw+wrS29xAfBktAAHQEARiHyYLoYqMYmpwhd0mJ6ZPOA/vOASl2vKJIpGGTCt4CyWLzlLTVqQSpp1lWatFOTN3rSSv1yAMGUlTO4G08vAUCCPLjgEJ2KRCT6gohawaAUzo+nAaKIimsu85gNZMZnZcBMU3dzM2CZYCk2g8BEmPCE6zxmHOMAwB6xyhQ3nMZ0dRmOHoLXnMWRBiTyYQQc08EAHjvRP1f7sZwa1QEId8ET3/7BHcpSrnBUzB9EBAOCKAJoBKIwxOzjAQQsmPYIZHaAU5B7hBm6gwxF8oIUjmSQuTH2DC2j51Jj+pZT7Up/6aOaB8GSgCqdg2i9wQQshSawWqAjGJKjighX5L4ByAq8IqAS+E9kll6S0C4qOZD1XZgy2ggTMm4Z2lxAEcAQlkKUIBvNLF8WAEZ6IRScaoYll5rWZr4imBQWLNQayohWEzdpsRIFYVRBqFVmzjAlVuMI84MGyrLJsHMIQhB5/4Mc5IEbd5gHPeErHGZ99BjSUDI1joMIRepADEGBnghrUgLXAa+XhhEUe8jTRPeuJ3OQoNy3MYe6KE/XtRK+Vh1i4of8IFmlDHY5Q3cm1QCltaCPSvrAUki7FBT+jQEN++drXtsmUJ2jTCWSUSvWZVwWd8AXTaNHIiDFyFb7wBOzw+DOn4pJopezeWUYZ4V3irF8uclGauspqpmqgBeuDqalzhlMHl/Wq4fuvg1kUg0hk2BfBMEYtcvFhvlbzaShmoF6XjWIUS8awoPgrKlTRzFK42DMpzAMfloOIP9g4CDGsbBx63OMc/PgDeChGO+eB5B06A7RKjjeuihGKRuhhDmLwwZF8oJQrA/SIh0Mc4RLqOPfgtqFnRrPCAwCA3/7HABlIhBuiMgRxtcEO+j6ABY4QCDd84V5+2Agb3zAFQL9WA3f/WDTNNgA0FwVMk4m2WcYYfQEPrKAGnFBkMGrBc54XVdJigPUEJMCALNGlRQAD36ix4hY/vimUckmBJVFXhBeszwVSEaSaJCxr+nFAMLfsZAnw9xIMRNgwJ2gDJtKrSGP8AjLOS2YyW5FXusud7sxedoqlBkJRkEJRV0uFxEpxYxw3ohGPaIS382DjyeLh3I+QhjWcM096whsb1rDGraRxDFAgIspm4PcNfFCDf64ABAJFoni87GUHOE4BBmcWme+z8N5msQDXAoFVlEQm5IbRAQo4woduQAc7eEhdYHDfBShQ6Kjs9C9XfXlbTICXV6Ky5i2oASOA/Qtb4KLntaAF/y0SqQiA8owBJwIf+LI0EvO1SCtysYtf1v+SE1ny6lw1AZzLNYKQ7OvTLPczdBIYewF9uIRWGEAXAUMHnLA0vwAoxFZ3eGd3cieByZZsKTYZ4SQ2ExR4gvcKoXBZOTADQSBu4uZ4rAJknyB5zsFk8hRaOMQ3fbNhe3BvZ1AFPpAFpEcDNNBaAIc4woJQBRd7slc5/cFb/EFFEVUAB+AAKgMGYJBnYdRRLXAALeA6dHAHGXISPyACPHNWgXYCb8BUZFhT0rc+eMFo+Rc8d3YGsdAw3gd+lFYLxrAJK7AiRPdy8Qc+ojQSbXJ0MUE/KABAV5VHM0derdRoP9AGMAA0u//EF/0DNECzL3GyEmcVU3tBNG3hBpiQEw8TDLmAV3nHbNWUKIuFKWPDYtGGNZLhSKAAQzMwAyogQ0GgA0EQBrjYY5VVgpUFZK4ADdjQgu72bs7QDMtwjLnxExv2B3tQB2xwBllwBmaAgzXQg6aHegKVAdq4eopzHq5HhFJkhP5xOVREOQoAFUNQcUUABWF0BAygAHemJFIREjGwAb3EfBUgARSgj25wAxegPh4AiDFBE7A0fS1gJDSDdVngCXD4fT1HaboQDK+AAy2wARLwAHoIf1nhh3/odWTFPSRxdN1zkMMDVkcEVkADGLtUaGq1S18ogITBMxLQSxXQIiNwB5P/0ICI5Au2EEmExUBYY4qMdYqEQhmfYU1AKXiy0Al4EASxCAK0yAM9lovkFkMxBGTCsAzWwA1EJk/N0AzFaIzLkAzJoAxm+Qug4AiK4Ad7MAfP6JZmIAZAYGVWZo0qIFAdYDjCwkRfJmbhKC3kWI71cQApkAJdUSNPUhUacAAXYBIxECVcYZETMJlDpz/LB12vBjziJRfoMxNo9xZgQjMn8AM3IAmS1pPgx3MOIwd4tESmBF4jE2H1A1MFyBclAAVwMARi4gIEFlau1EoqQlYESJl78Yg8U5xnJZM0WZN5BAeRsBin8Ao96UghFmJ+FUGI4kDTVk3PlJ2kQQqt8EDL/5RiEqNPQXCXHzADOIADPKBOPEZu5WZu6IYMy1BD7PaV+PmVyJgrzPAToSAJasmWdTAHAyoHciCXPpCgOlCN/4R6ALVlw8KXkLMef+lQ/IFFt1cAMZACC4ExJEE9LvCO7OOYIsAAEjCTJ/oAJ1oBFNACd0CaOhUXNtU9GTOQUEJHQPMWN6AwPGkLoQh+CWQMjqABFzAs++J1hzZqf8h++8IXeIEzLgOSZZFKBfYzCaYSbfGIBKgXgpE7evGPtEScj8hyGwAFdyAIkWAJnLAKOsJXfeWmfPUKcupIdBp3sPAK3zmKrbgKj4AHYaACP8aDOKADVlmLtBifP1YJylCf1//ADfmpn8e4DLhhlsFACpLQCIpwCGy5B5x6b3JgBmWQBWWAgzv4TzcCPEVaUMTyZckCH/RhHw+FofcBLYlGF1lCJdTzAhdQAA/QAm6Bh41DdI0zrBJwAW50STIyo50pF3DxAkfSAsXKLzcABKHQo5pSC4hUC8PAE57AVPs4iC+xAf/SFtz1h+RaGBHWJoJkSke0Pt56AZN5Aa20pXvBpfVanHrRM07FS5M5k720fBewiO1CCJIQCgd0QMUkp0FhnX4ipwgbFBCrI+MXMaswQRa4bLKACn/gpyDwARCgAizAg1aZAz1gi+AWQ4D6AaKgG9KwIJH6ssugG8cws8fwE6//UAmO4AiMoKl+IAh+IKBzIAdoILRiUAXUSAP+BlBEijB7mVC19R6vqlv7gWa3B5KiZBgxYxUuwB541CbGggEJgB7EMgEMMAFE2gKBMCPihXYyoYfNmn8qegE1gSOPMVS5gEi2oAvD0DCx4AMeYFC+ozMh+S+7JK5L2iZgoQEsAVPiigIbcIjLlxKvRQHFqaX52jMuuRcXYJn6kxdDp6IzuUQTcD0wUAc/uwgAKgmUsLqqy7qS8LqrG7uyG7uXULtsowmgsAoVOHetIAukYGNycJcdoAIzQAOxaJXtObI5AKg5gAu6AQ0uG6lkaZbD8IokeAm+YAy+kAk5q7OHcAiM/6AImQq0BXoGZzCqCXoDV7ZKvxmECUWE9lFFmpNm/5EVJmA+LhMSNbKrDMA9+kOARGeiJ6o/hEYHVhc8I0AzpmRTMwGaZqESM+ICNyAHjjFUeasLiBQMv/AKvlAFskUBR3oXhyYCraRqvqNJj6s+IjAT6RNqRxRoTxWujzi5FCBTZyKvMDkYvHSRD9CvSrQBPsAGpisIzSgHBFqDesCWerDES5wHesAHfFCDc8DET1yCcsB4krAKusBz4hd+EmMLoeBtchAGM8ACLFC864kD8FmL8TkDeDAM/ckMkscNdJwNtqIMvtAIECAfB/ABlBBso0AJ3qup3/uzzUgHQSsH5/+bBc+lvjeCl98BoavKAH3ZLM8SLfqBhON4HycRkPHyJCHhJBqQAAlAF/lYAQJ8HicqwJNJATfwBVT6VXnEmes6Fk4XwTdwBqPwGIg0VEM1DDvnC39AHg9AGHTBR6X0F+tjo4bhmeRVM8laVkRKuZorgPlKuZR7ASwqrxTwVhpAAZQZzuC8RI1jLCo6ATCgBcVnB3TQzmzABm4pB4g8B0HLBkZMzwYqtPm8BnKgxnEQtFm8xeEnfrTgSLaQCXlgoGQMAmUcsoOqAyY7lSerApUws8pwG9JQx9fQn6QQBJPjLA3QADOQCdq7CZIQCTvLCCpdyAK6xG45Ilqgg+rbg8L/e0RJ9ACttywH8B7xa2aBaTtlwTFP8RUj8AAE0EsDrMqpbKKT+Usa8AYt8MyuZFNsAptnRTN3VgOUgMHY6ssRuXO6kAnkwQDCOaOcWROPCRfos2iF9jMqEYAyEmjFyqL5eqLEeblcehb5qqK/1M36uI/GMsASYAKyQwd1IEZfkAVasNhOoAVKkAVsYAaP7QVn4AVZIKpOkAVOUAVKUAUsMKhhMAaU8Aq/IH6zMAtztwq2IAn5DAQ0AAL/dMYiC9G3mItWKQrHUAzHQJbLAC7SwAy/8AgfsAAUZQA95VN6EAvBEMiSEL4q/dwsbch1UAd08M5sMKpAgFr/ZI3AA6Hi/1EetbUArqpb8jstA4AiUVIjTTIFlfQkFXAACSCsJooegk3A+Sho/vhVBdN06WNK4jojSkEDdRALW+zVX60LsrAKIAABDxB9aMcvcWEzMhHBBRMTzCevNoOqAQiwMfUzgRHO9jp0Il6vjAPOkrtE+sjDjCMBV1gEacRvdLbYcJRSCVrjO1DjOF7jK8CDQBAGmeAYPQcqc/cKfBAHZBAG63mXIMsCKzADOWCyOgAEJ5sDcYALxzAMxVCWyZArnZcDzYJ7zrIADQABLJAJ3dcJlBAJKP26z72zgjC+PtuMdVCDilwGU1YD/HZlXJVlGhAsXtZTOm2E5t0fAxAXb0E+Tv/yJSz3ADtN3+ghwAMskxKwAT9QMF5FEzkVF1p1vyfw39cDOzpwClusKb6sSL+gCrpABhAwukkCBesSExjRO2y7X22SRyKA4U8VGJ5WuCrRSn/BpcvJM221S2Q7k3tx4d3s1yk6theQJFFCmhDyOnM0ekrgA9QDA9Y+FaOXoBmgAjdHBXP1C+B32np1CmMcBq6NWtgI24KaxjgQQ07OB8OQ27yBDMowWojQANKCewfwRD7VAXkwCqcQCpkQCTobCa/7ujm7CG3Os4egCI5QCJ562WaQBUd7I611OKynUBTaUGV23szqmBhBJRfAAPkI3wwQtvOtyvUNuhIQF660zFD/MvM3+gLoLcFSUQOY4Au1gAu4kAtDZQyKxAq24AgWMAFwgRj665jy45kqUl9O5VRv3T8sUSOO2z+KO6/HGexC00sirj8ofpEpWt+UiwEzMiMwAGseIMFPEiWwQ2AEljH596xmzC0goAI4MFc82XMSk0ydAATryQIqcJfr7u3Fe/jGK4sUPbO6PbPBoAkfQHtoxoQH4EQOYAE0IAdOTgmZMAlq/vlq/roGr+Yq7QiSsAmcYAmNUAh7UN30fN06eGXrq1p+Ph5NxNPxK78R3KwxQI8nsMMV8AAJAN8qz/ItT98aUF+ohCQ1zzLYk0lRAgOw4wcL4/NAn72KNAut0Akd/0ABjZY+egiQyao+9VVWgOHh/cN83aO44vpL/SPsNNnUbRX8xbp8EwDYq1wsjEMsxj7N3NzNAGFBgwWCFwZmIJiQIMKFFjJ0WLAAAgQaoWz5kiXrVStVqVKdkqQCRAeEEByAQJlyBQ0WLWfMUBFT1LFhw4wZg/XnwIABAXz6LHBAaMQFDlTI0dNnE6dMliY9hUop0qRIU6ta2vTqVShKjg7t2eNnT505cs5k8ZG2Bo0VHkYOtGBygQKhBezyFCBghAsXJ1z8+MHXxQUGFy48YPDgQAEGCSQwkBD5MWQJDx5LmEDhxGYTLQS38PyCr2gUKE6IFuziRgsfr2rVwpVLl/+um79ykTpFw4IHDyZGbNggYsSIzSN4e9AwXANyDRgwNDd8AYPhDRqAa7CuoYJBDBW8f58Q+YHlxA8uUDBPocKECYgtI8aMGHIFDYaRU6CQ8AF+ChcUEpyIoAccSAiCDCKaiAdORulkE000uSTCCPd4iCEHIEgJJRVWmKEll1SYIQdZlDEmmF8uUcGAnn4KAAAA7FpsqAY6GMSTBUcZhRNLdoTqKaei2mSUi065RBKvDlHkED/EmoMNNs44y4fVVljBBA1KcmAuuuwqAC8TBBvih81e4GC7DTAIT4IECKBMMjcly0y65GJw4YUbbkCtL9NQ4Ks0F2KI4QW/6nShBUz/fNEFmGCCMeYXX36phZRYDqkPuwtQ2IC4EUzb64QRlvPAOAyue665UavD7jngRBDBMOvOXK8+CiobL7MHBCIIOxM2sOBW7PJjILz9ttPAyuVwxS7XSnHtgCQPHErWoQxAWKCBC+XYhJJMJOG2WyPFuBCCuCYSNwNzm502pQ9AUCGITkLp5BI8GuCJSxiFwjcBBRS40AI5MOlDhTw68aQpqrh1RBFHrKIEq1V++WWVIhUR65BBxNqjLDPOKKOKG9hSoQMNOogrSy23xEsAv04A7M/iRIC1AucqSCCB9SSo4E3MJpD5Ag6Gq/MGwG4Q7ITSSjOBzxeW3mwz0DxgJJZa/3Rx1BdbrqYFt0lAPYE5FPb6+ucTTOANO+yCu046tE+tLtPhYI7uAu/6w++CCRhgoFeCFmDAgVstcCBLAnsNnMABzc6PIYXGY2DffYXiKcag7C3AJ55UaMQRSRrhvJBEClFkD3rxNWCoaq0NfCIQ1lWBBhD42GSRGRpQkfLS8RWqZgWKmuiGHT9oABEGOcHEqUi4rWoqSzKxqMRXMunqkEMYSVLJsebAPsoaVlCB7CsBz5KBBerqcoC+AIvhB0EzFaE7mc/kgIEDdJbsuwo4GJXsEV4AFDXONvgZ0kpTnOEMh2xZyMS7QoEjT3iiE53QRCg8UYZKeYA6IkDBC/gUqv/jHGdVa9OAcNr3KuuMAGb1iU57yjMexkWELnQxAOXKxxMW0XBFAbihT1y0Qx72cIct8qGLZsC5zSWiEaBL0h4gcIDCkctAIKASSrhHgxmwBESj8AUiDhTDAQiAS7gb3wH0pYDEAK4FlojFJT6QA1CcwkZMsQQlGuaj5Y3iF8oIBpEoIYmqGMkR1LMek56EFhpMCQQIKVyWttQlv4gpfcA51Xdm5p2a4QxnOYuM/aaTKd50qmkmMMEJOACcDYSKOJ4qYAGxcwhJyDETmaBKVxyRiVH4AQSWus8GltaX45zAVXKTmwRmxUL54C0x4mlcAgqQFxbpMIjPhGYNBzC5xcz/RSgKGKOWqlUU8BXudLSr1gdOsYlWOiJzjlgEI6SngnCJC0AdGAk8NaSCloCgJYrAwQJkGBQwnoyMg3MA1GIRjE/gQROyOMUoHAjHHTU0E6cIhjJ+EYpLxLEqVDneHxWRJEFcjw0dk1IL2kIyAClyMQU4QQxQIAJPxWw9PGNPzmiWAAbIFDz2ow52PEAB5BjmpZjsj9lQGLcK5McBZthDHwrBCEaA5St6+EMm5lAlFxTLNx6AGXDI1kHesK9n55kMZCzDHTlNYEv5qlladZeAA+xrLkRJJIEuFLiBEOggBHnWchDCHP/8rUImGdwFQPkQBzQAAnGIxY7I6Qh0LmKj/4dYwbgSghB0PQQlH2BdyLJkgNLF8KS4OwBRXFhGC/inBY44hTGUgQtTzOYVo4DXJjrRlFcurxOx8MUqNlFRqUTiRxg1ElOtVwc2aOGjPmDLSCoEOGuKsWYnvVddCECAAqjVMZkED8++Oh2DPCAveaFudWkqgeecxzJuYhxbPSCHOuxBEH6ggx3auwc9jMISdPBAC8hmghdoYFYX2IAJDMNTWQFYA8LcDnosIyzL8OelmZlbZBiMN2ICzle9ojAL/TYeuPQ1IXCxkoDao2FpCcRsJjjCDUhSOD/4YrbkRJgkEuGIP5DEXOayQLPgKRJ1faBZECifiqZ5F35eU7RFCf/ss1agCFIEgxnQKIaifPGKU8DrgZxgyitfOduKxpESk2joj5IXCXW+lyzELYOUkusBkjAXm/KxrjEbUzO81Q8D9fOOhHl2nrhRQM4UlswvfRoe9khmXx6I75Ls4IZF28EPiHiFLzBxA97kKj0GOU9QZzUrZJanzkUVFmYqs7M0jbqYdcYbGRPjuH1RuD8Ujmmr8jOQgfjKvxcQ5n7485/+nAcuGjAQBCRhi0xcohOS0EQnOLE5SfChsuYykEPgqeMOrGuLMxxyvfjJar4huSC8MQEL8gCKO17jGsU4RqNqoQpSgOLKWM7yKzexiYZOAhP3bqgcn0JmRhDCD47O2Bn/qqADtlDpew4Qny4loIAH8Ix+En64zoqaM7oZBMIUYE9mItNnjI8aTjWjQBvqUIcluYHRdtgDIkDhi1HQYQUaOO8DUPgbXN+sP4/ZD61YaEn8YMa8mZmVnBGjajrva4zYNLp11RqsYBlEwYvrFc4ZPuLAWQA9tMqP3qTtCVtcIoGVWEUsbLHHRzj7kE9EF0lMkmORNECfPIG7tgsQw7dqKTFVz8ByOuOBFfChE7NIxjWyAQ1lkEgXtYAFKUKxwDdied7z1rIlsKzl4oHZeGQ+hCCURBY0ZOFj20MOIhkA88kkoJjv+fOfT52YOrsJPxqvjDF3Pmr0hLpxrE8MHTTP/1RBONoPh3CEJn4xdpL5uWYm3M/p8TaBmU0Gz+wxjHNOJR1c7ywy/Lk+fhCznMoYBMM5H/V3+mMCDvhHb4m5tXeaMwI/DygDDaewAsCHVwuAIBayuESyKcHyTlTiEY/IAxaYNnnKOwtQgJ6YprZaDLiznduhi2vanbvzq+VYgQxYgTzQBFiIqGuQBmZQBprQhVmQBVWArQdSNseLvB0pnjD7reMRriWpAzpgAyl5gfxagTYbOvdIpjaJPco4poiTjIYDuu0YMI+rlTfRvvHYGSWcjC+QHkaIhEXLPEZohEqwBWMIBR24pTnLIO47r8sAD1oRtUJrMLUBjrnBOAgTD//5GA9VE6YMQ7jUO6ZboQD/GhBdG49JkhnvGDqCwL0BcYCH2I1nEQOryb94yYT/e4RKqIQ4YAEoiqeRcICd+AkveoAEkLsvckBu65tb+ZsL6AC+a4EOmAE9uARV0IVjYIZVZIZkOAZgwAVa0IgqO0FOcCDIawpLuLcVZEGMQickEQs60IIUa4EpSRbE2ACGK706K7VCgyn74Rn38Q7qICUPyjQF4xn1kJszlLAwNCYfILOqOAIfYAPpkYRHgChbUASSucQEwAATKK2GyzMJALD26MEVYkPMAA9ico/DYBxWIyMWuj2AZLVUW4ABuTsC+cEKwBsZgIMhKAGGHBC+QTj/+RsQwAGfapmBTaCoZNuESpAERvS/MTiXaYOA8bmLnvAiNdmnInMcuPpEghAZvqOBGmgdUySFWhgGZVjFDyyGYQAGWXyFVaDFebOypdCyyaOt2uIRqvgjSVAnPyCucVQCHxApD0CIB4AEmPMzvHEM7yi1S5IZ6ZNGSQKOnxkBDuiqDeCzTPMpSSrLfaSwFWAEPhIENqiDI2AqzemEm+AEEBg6BeiPwlGPYVqOutE+fHyPOPGPCeiVfwwWCLhDhHOhoogI8VkA3RGtBggtuPKmtjqvCEAABHiCBoIEQACEQIADmCu06ugN0ChGKXECPUigZIOgB7kE/5OEPsAesKgD/xtYIsqpl8ahnHzZncssnIIwCJ3qjBpIixXQgT2whFCAhV9At8I7huwsEV2gBVhYBVQowcUTzwbJBHjTshQUs6mASkKwAxl0Ai1AC9BDiFPwg4HoOQZAkzcpNHq0G2HKuLqhvlI6DqGKmwLts+WUxrtJjA44BKuAJzsghLo0hEzwBWOIBSCQzMbJD3eyOu27gGf50PpICINAjv8AH8BqomAzkAwgl7iwMRsbiQxhl5eggZqUEuRyAhgYAigQzQiIAEAwTUgQUtO8AziAg0AQ0jv4gjb4AjdgUuOahITSBFAAhXnTBEZspSZos80iH8oRAJpSpujKpsBhodICla0CDf/nzIIyqIEqkE5QUIVaAAZgOAZl+EmbuIlgODxZWAVSUDxQWLwShDelPM96o4pJkApG6D0nYQM0qAIfqIEWcAsLrYNQ9MdhysZeA1DEBNACXY5PrRTzI4isK63SGjBTjRvEqD8/mIpJ6DdBIAQj4ZZTOAVKcB0LwBsdiycSDcW2WAGRSlO+uJM7SYsqyIJjLYONgRJGZQPskYNnZVQZZFYngRIxsNYqCAIx0AEcqIFu3R7XSRoO8FESCIEnIAEfRVcESAFAwARIgIN2BYQ7AAM4mIIKaLW5UwFJyASOtDIIqgSngADOWsAA4CcZIgAEiAD5uR3nUrXB+bbXLJQWsBP/H8iCM2ADHSgDP6CETiAFWNCFXBgGmgAGqrkjEimRqlm3fn2gxjvPV8I3LytPSyAzqZwDsjCDRy04Y7AFRxgJk9C1oDJRwygIneIqUAE3UOoM/UraF6iSpIXNYU2LqIUBOykDRoAKKIxQQWAER6CEU4iFU8CESDiEGFySsaADOnADtGVULTAutmXbcTyCFBvWSKWSukUJHbsxAHEibyKKBvDbIyMKx8GdBEBYEngCH0WAg03c0SSACPAESAgByAWEGLgD1ISEGBgCOHiABeiAIGgEBWqQB/lXRtCnuwAK6LKXA0CAnGErfIlA0jKb1yzGG6iBG/ABJTCumvUBNNDY/04YhVXoTmCAmNkgXogxkUf5BT19LRN8F5Y9z3vLRVpKqEwQW7GgWYGzyhVABU2QhDyQgzS7gTYQ3zY4WzqIQd9bkvRdkvdakkMIhEBYX0GQ3/md3whVJ+nBX/a1A/kauTrQgiVlAz+42kMghOlhLEmIhVGQhD3IghYYCBvDMRQNHL/928AF3KFoq+YCrQ2+ncnx4JbkkmliQJoigRJeXMUdzdFkVxIABBIQAkAQAkgoAUCAAzCABE6wgAOAgA7AAVrCkRKktzOAO87qiYLlEqND2Ah4LqJIjPwAxTP1DGJNi/ds1vbSgjk4BErYBFAghVdghVz4hcOrBVqghdmohf8RRAVUUIVXkIVYWF7ZeqDFU8pBpa3bsoVY8ARXzbzNkwMzAILVCAVSYBCZVVT5Kt8nKYMyQIs7iVSRiicWNQkJNpmIcLvTKayIIJ0YasAhM4AM0FqmYoRFGATQKQREUAQagADOPAAhi7tW/gm4a6ZYlmVoouVafqYAEIAkTuLpEoDGTWEgBYQngAQS8IR2dVdIkIE78AQ3SAwTOEkP+IJJ8IVpDgZfKATOnCZWLoBFGqM1aVwMkJ/j5BvSegh4EsUWcM5iPQM5qFmw8ANGwArfRYVWmBpdsIXXsAVZ1Ig/DVQ/ha1QAIUHmTdO2IRMKB582zKIqmauoBiSyxg2QIv/F2iBjzwiOXCdsqE2asOxknK7z3qhtuI2Lcng8dHkEG5lHe6A2mEiVt1axkoYzmkEalllWG4mW7bpm8bpHoo7yxkAxRXNXCaBxJ2uoEYAQMBjYRZSPMbjBsIETwgEZWIAE7ALmoIEp6YRS/gAIs62BAwKo5MuBLgzfekbMnVic6YSdLbdij0DNGjnsPADQXCESdjXxQMFepaFVoAFjdAIdlNZBfrhxYMg2YI3XZS3LX6F2rAvR6gYmmUDJdiBF/gDPZDsOfABYxEqs8kA81MwxEC4nZim42Q10BJOmpZlHFoRnjAANtgjI4HpzGmEBcihnAYAIJrt0rbt28btZkLt/wFg5QEgXMY9WBROYdIEhNOs6gbyhKVGbiFgAAFobl5G4S/N4XrJxAEAabaCkemKgPgpIwIJqt4460LygSowAzRo1pp1NFj9vbjessVDhe8shVJQhflOKHgh6HnrBCrN70BehVI4SvPUsk04hZL1Ba7wit/rKOLyAse2JxYQCZIZ68DBTMC1YBfqTNHandDCHc5KybhrQNI5AMPKADNwhE54hauZZqsZBTkAgcLyW6G4Hc6S8bnj8BmncRnH8Ry/HQr224nArA8AkRDJgRwIgjjAAzzIAz74A0TIHEqIkE8ABVEQBXdTNqIWTeEeTR8Nbl320RAgV8MN5sT9LvAS6v+Dbd0hs5eDjJHPEorpYoAUqID9QIi8e82atNE1RQN2rlk9CAtY9TeFaZgEehdSkO9V4Ah/hhd5UyAqBYXffQVYUAX/pnLyDHCIYgZjeJ7gmh5/Gws2WPB22tvUcSJyORcQ4LtfpYEWSPWVWIsadfW6rduYkNFHvrFytrF1mQEgkANJ2GJAfaBNaAQzgAmR+HFcpwEc0IEijwM5yAM94INC4BzNaRivg2NAHYVTWGOtkAVasAXinY1phphwX5RxH/eaMPeaqNMPNJFgiIUS6GXRHG54z/Lpmq7hVlwC6GUEAC96r3d7RwDi9PADIIjKGbIude4YgHMMwEq9i820AIL/Msjzdm6v9Y1Q6QF0S7gE/B4FVJAFXwgGW0CF2NqRfX2X/U4FWYCFVgCFT2B5QKXyfS1oAY8olosjSSDgF7SDJlmDgdOBKhi4bkV2HdCBbnX1Gp0BWD96DvGQDYmJmKhbFqgiZAeCqRcDM3hWdpZsPfCDQSAEQ4hQR+gDRDjg5flICamEjKelBaJVWl3jWBA7FKfmRbmJuaf7ujeGdMvOvK9Tved7vi+8ZEgGZUgGZAD8wiu8ZYAGD7yJWJCAvECAc83yCDhXdH2Cfj/hMcflXj5YdJX3cSUBcO7SbQ4oDzgAHPqik/LtFBCCEuCA/YpiH0hkiMeeiU9fzSME+zVl/0VopfxLtlCQhYgyhtwqaCcv7HcpBUNPhVJYeZaHckb/BE3AxVAQO1WgN6roN37bvLIweg7BARzIgWRX9qtP8iWP9laSI4yndnhTNvEMVBxZ+/d//1WQf6I8BfmHrd99/0D20/ansleYb/kHiFevZMmKVcuWLl2/FgZrOOzhw2LHJlKsqEzZMWXJkl3kuJHjspAilzGDZlIaNGkqpVmzdi3btWvMTkUgYBNBBBI4cwJ6QoKEJ08ICAiwabSozaI7c/4k4ZNEzhARHigoMODqgQUOFDDQYGFAgbAFDhwQe4ADGCEnXrRoUeNGljNy6MyZo2ePHz+GCA0ydOjvIUaMFP81aiSJkqVMmS5tWhXMmC9VoC5VqpRpE+ZNo1TBalUK1CdQnTp90qTpk6hWpj6N3pQpcadNlyxNiiS4tuBDe+ro6RRqVKjfo0adQoVKFfJVr1QpF+j8uXPlq5JPN279+qni16+rsk4qFKnw4YuHFwVK1HdSpUqlMuXevStY8mnRwoWrFzBgwojxJ1bsPzIBBggSScyUtJI0McWUDYMNOvgghA7G5AkDRiGgUwQXkgAHJIA4FVSGSA2FAIk4kcgUU01lGIFUBShA1lULLPDiAQpYYEFYZOmYYwESgAGGDD+8UIMPcc1VRx14CfIXIYwQQsgiggkWiSKONOIIJYhdQgn/Y7+FoglllVxi2iWdjLIKKqB9suZpa6J2SzHLJLMLKJqMptglitFmGyO1ReKIIof4sQdwwQUHCqKJKrooo2q6+aibpkV6mqSltQnpo+eJsummu+zCyy23uLKLK/v1518xHyVD0kktZcPNPLHKOg83tdYqq622RrgrTAqqZCBGDwGjSyynwGHUTRkSgFMIJPQUASCYQEJUiSXedGJTTT2VIQkhMHCAAw7MyMACVo011otijVVWAAMcwEAKb0DxxQpE+nCGXHPsgZcfgvgryCCC7KUIwYQV5ogkCR+WmJ5ZPlKZmKFNFuaYY1ZymivEPAPrPNbw8kllgL72GiWT+BmJ/ySDDaoHpJw+yinMMcP8Hs2u2HyzK7d42gt+wvjc338SDbiqSM88Y1JK2cja66u68tpgrlHveg1KciaDTDHEAAOqzaKUBvEjj+AxNh5x5HB2ECqoMMMHEHzQQYU3EbVstTiRAAkkQWECiFJ1W4itU9rqVGICCkDgAAQUVGWAAWEZsOO6CZQlgADvlnDHHW4QWUYZcsyRZF5+PDm6IaUTbGVhByPsCOtZUpIwl5Vd8kko5oEs+yW5ayIKnM5gQ489wc8jzceVSKLIyJbQdvKfgebFC/TR82IqfwAKOKBISJ8kzTTdd28NNuGLPz426qSjjjroqI8O+ui38z49sNYTT/899MRajz310Mp0gwrG9OtFJjKMheiiFrJoBStAA6bKhC1sfCBbHIIgwbOp4AMWvGDbIKDBDGoQAg1wQAcyEEIHUEACCbDQ3E70hAgoKwKe8IUvPIEJIRDgJyRKQAIYUK1kOeUpg8sQAhjAAAtk4AIPKItZkKijAxTuRVcpAAMwcAdI3OEInaMLv/wFmEUkIhGL+CIYuag61qEubJKAWGU0AQpSjEI0oEDj7EzBC2Q8AxvzAN4+8qg/afQCZJJInvJKZjI+HYIQgphG+LSBDW1sYxvoKAckIbm+R0oSHemgJCQbuY1IZrKRj9SkJMchjlGSUhzrOOU6zqHKdegjHvD/gIc71sEOdOjRY2xiU5gc+IcHkg2Ccejl2H5JNjnIIQ7GNGYYJAgEHfAABzNgAQvUpgIQdKCa1uwACKhpzRV04AIYqAACRDQiFXoCECyEli+MgYmgyCACT/AQCyUwARaxkAEnTMBOTHQhn1TgAQuwgAcskK4lErRGClDAjLDCgAoMAW9uaAMd9uUHwBRSEYtQhBe9CMYroY6MZDQMJSA2pkSNJlGSEgUviNEMc2wDG+VwJD7+IdN92I+PIHuN8vS0PNww4hCCyGMe/9EPoQo1H++IB1LfkQ95wNIdTnWHPJgKj3gc9R3sYIc6sKpVdIijHOJQhz7qgY9vkHIc5zil/zjGoVZVqnKU5CBHKfdhD2644mwzUMEEJRiEHAThmGH461+PKdjBxoEMYwhDYcmgWDL8lbHLxAENaMACZ66gsjOYwQoiq1nNiqEKN/hBCoYyt2SxUAaA6NBPAJFOT2AAEOWEFmojgIEQpEAGMkhBCSogOSZaKwJ4A0QMLuCADGRgK7vdUY0MKiMHPMABVqlRBU4QrUDYwQ7/UsRgLPrF1HkxdY1YhJUe4dGEIewwljGTaSSlKd4V4xnoWGo/qmEOdiBVpv0Y6j70t4yPaUIx/lWeJbLEp57K1L73PfBQC/yPqCL4vlF9cILjkQ985EMf97DwPi584X/o4x9LfQeIrf/KDhA7VZVvJcc53qpKp5oDG9J4BAU/kIPL0tiZl8UBjnFMg7PlQAc97rFeJehjHIRhmTrQgY6bSYNnRlMFLFiB2rI5zcpalgY4rkIVQBtOylGOtDmBxDrLiQkYEmIILxSzJyDxhBSkgLYyeAKcY7ABe+IQnxVw7d6EZAEHWOABDKARWRTwAAvMCKHhssAFNLCAxingAiJ4g7QCsaSeMsIRYfTudxfB0cI08BFXUljCLOGbUNRpTKgxxSyEsQxrzMMe+ziwPA6cj3wg+B80nccybvGJ/wI4kJSIhG0OoeBhzxSo9iXqUJOt4H0YWNnOJqpQGyztaS9bf8MIAg+i2YH/yNKYxlaGLLdnkGNnLrncm71suKGpNihPs5rE7aAGEQdvDYowAyBYAQUIEIB9A0AAAejbsuDgiWK9MDuj4IQnjGGMWJy2J0+AxBva/GY4wOENU3jBBOwpxBTkDRN3iEERMmCjPr8Ihy56AQz+rAA+W6ADK2iBBRqA0AmMQAh4g0RPHSEY1I1xvK57XcLMeBhKXGY0sblUqZBhDfzlsR9AffW0+xFrp891GbMoDU5zGuBfA5sRyP56sp8OdrADNepmH/uzk31fY9t6Htn4RBDGAE0QbHbJl6XyuiubzWxWk+/X/HsIMzDveDegAVoxPOILr/gPHg6EECAAACIfeS4v/8sm0JJhwhWu8Fhw3hexgIMQTPtCaa254XC4wxtkEAIJMEACIYiWx93ghhfcyAIUoAoTcShoIfLZ3iu4gQ9WAILGv+AHsOeTR3uOpcRYgjK5w1PuxrSJ9I7pNKIoVTKkoTR71DqPrpZ2tO9ra7nOAxmm0MQmLIGJnG6pZMCOhDtgKX93kOOV9A8x/uVBYne8g8FSxz8AhphTgdjUyZ/UvZLUMZVUvRI85AOzyRQ+4JrYyMEaiAEQyMEZmIEG4osZ4EsGbqAZlEEGlkEIdmAIco4Jck4WVEFnVQEQuKAPAIEP1AANUNkKeIAH7B0ITNO9UdkM1KAOidaWFQWXIUDexP8CZKSTMjCDMZxCUKQZHGAC5+kNGDwBJkjLG/yIT4RABUiABJQAxQ3BF9zADQRUBjTXAuxWnSGUVvheDYjBGZQBDWRAA1gACsQAmEVCv/CFI/yBH/YBXhxCJBjCIPSBHyJCp5kXGlXGJ5jCLRADMiBSrZhPPMjUPVxiPOCDJsKDPNiXPOCDUs3ahOFD/XCDMJwfJTDCICiCr50MA74iPJzYW8FDiEXV/p0DAdriO/CfAD6VAOKfh91DPNwDLbpDPiAVMsZD/MGDJnZYPrTDPLjC2OQBGoiBGGBgCZ4BGpgBGmjjBmbgGbABB3IOOZbjCZaBNbKgOgKBDNJgDdJAC9j/IA9CGZWxgJWtwAm8GVRYC1EURQrEgi/8gjIonIEYiC9YAicg3AsRXJrJQN7oDRXB2RPEAG6lABQAQhuM4Q20AHHdiD/pHleEC5/dWw10zr7MgQ6EkAn8wB1MAiYwgiAUDB8ggiIgApZMgiT0AR/kAR/8QaeFDcSsiSuk1DJI4iOlQztYFTLKlCiK4j10otNpIj48oK2RIv5Mw8dYQsIgT+4EmJ801VO5A1u9lS/2n/7tolgi1VWtJVu2pVteVTzsAz7Ew4ixwznQpVu+Ej7Q1yxxw4vhQR7MgRkAgRigQTdqIxqswRmsQWJ2YzdyozeagTVaowZKJmVa5mTq1ZEh/xm4RdaTPRkPrhsL/CAO1EsNwAAUYM4KVQuLREI6ad5FXAQzKMMpvE52cF6xxAInROETIpyaWWFPQIEQ/EgguMEN1EA8ctMIycgCMMCgEdG96YAY6IsfYJcfiMHLfYEdgNkkBAagNIJNIkaASQIf9OTDxNGnAIN/IMMysAQ2WNKIxVr/KWUy4oM8zNqDXaL31YNYPZ1cilU/2MMyuAKYSMIi6JRXRsIunoNTwdJYiuUAhuVT3eVbsoOESihausNV5RE7rMNRUehVpYOIrkNU1QP7tNQ1AANg5kExuaBhauMarIEWzGiMKiYHgmNl5qgGTqYYYKYYBNlm5phmyWM2rf8ANNmjjhmpDdTAEfgBFdkWIETpOhlDbCrcRCyhNBhD7nDeYwyk5wUFDHleDEVLDD3BG8CBGwQCI1TRcdZADQifCXRAnz3AoF1AB3jACvhAGcxBdQZGpQ0CGlTBHFgXJnCCJdRkYUiC8iSMmDyMJmRMe2JDS4yPI1GDONzl1PUDPNwDiLGDVManVEVVA2oif4qVVEolgPZD+Z1fwuBJIJmMhaaShYolW6ESfaESrs4XVqUP+8zqha5Y/PmiTL3DOriDMp6lhl7VOuxDPNADJGFDNkhDJYQBizLWGFBBYtZojNKojGqBF0imCY7gOYoBOqIjj5qrC1aBD+jAuq4rDbr/aWThXWZBEw3AawvswBqkARsIQiSsU4fgzQsZCDQwwzEM0DEYiDQwwwBRKTPIBBPCEEA+RjDEUN4sXCCgACQIgh8wQiDQQRn4wHFG1kZ6AHGJEJ7SgA7saXXqnEchgh7ogehMQlBMgiOM5xlBzO70wjIoTazQgzmcg1nJUv+V0jrwg9Hyw/tYqFkuY6gyFTLSAz1I5awVmFze11wRwydQBoLSBiV0KCrRKlud1Tn4KtiumLKe0lWVGFupbYPaXyVqKoM6lS46VYfKpbO2VDYUQxyMATGRARCMARkYJmMyphacgRYk5hl8qxhkQRbMqBaUI+RyDrmSKzmmow9c7uW2/ykZHmdyZlZbfC483oATsIEe1GwmjALn4Q0mnIIyyAQAZQQzJMj/NKyCAMtAQobEiqnnxcI6xYIn9NQesMEKqquezqByvhyRmAGfVokkrM7qJELpEEIkcMIoeIJieNrDVIYpEAOr3Q/TSV2t/cMorcMlcqqH6sNc7mKI0eJ9MtgrqSVS3eew7UM+zJQ9TEMf5UmvcW3Yphg5hMNbhUM4jAOKAbAsymL/rtIpmQOuom1b8p+okgP92V+yXpU8MCs6KJI0fAIPYAG+/CgVjAEbyIFjcuBhkqA1Mq4WaKDk8iiPVsHwMu7wyiDm7sAOvIWbwuuQ2mC96gAQoIEfOMIkcP/CKXQe7yZcw64E1SCsTFCN/8REQVap5k2x5r3m7wrCHKABG4hj54jjRtYL8J3B8pYXqCmMIwxCYKyTE1JCIpynKADDM8wD0z3gAyZYsfln0wUgXcJvPDwYA1KVWcJX9zFbP8TDM1zd1gZY2AqwAJ/DADNyOIADOPwvJQewAMviOJgDJ62PiKqPiIqoObgDPkidU50Yg7LlOtjnOVCDNSQDHiyBEaAjO1IBFYywOG5jB3qguaZwFuxoubJgOnZWFiwulrkgOxKvD9jwDbepDtddZNWAdMrBHrAiEXOeLbymwvmPSixxghRkw6aEN88mlV4EFU/x7Z5CT9lBHcwBMdH/QR34gR20gROQYRWY5CGQ8esAHXklQqAwAia8QiyMAiPuwjLEyveFb4E5HR7754TSFzJ2KFxSlSgCcqy5Uqbil1BFlTkkgylgRiZcIYCpmCqplSidQ1qZ1YNKMIr174SaQydb0idz8ienwzqkg9d6KFquLTvgz31RwzWYQg5gQeF2oOAyZhqcgRoYplKPIzrOKBd4wVNjgRhgQRU0wVRPtRI0QVZnQRMYAREYAVgjgVfbwA7YgA7k8GZR2TMDgUkqAiUQMUAPhC9g6UtwDDf0ikwow2MYQ8EGgy3EwjUHw0KMs+ZNrC/stcLBEDrDMxtUoxj4AJLUgfCCbDLHhR4o/8IgJIKoLYZWJgIiNIIc5MFEOUInCPZQKl02/I5NO1UyGmuFOvBa4iU7QC09qEP9mM8loYNDI9VU5pGEiWKB5YM7kPI+WEMxTMZrJIwh/AFZspU5mEMpkfQ4DDBbkfRIh+04WJJMT5Inz/RMp+2E0p874A9TlcMy/EEOqIE4nsFikYEaqEEapMF7lzC+VG4acAEXYIF+NwESYEET/Ld++zd/I8F/g7WBEwGClzU0z2AzqzUORPNl/xFxALQs6EIwKENKvMQ8TAODyC4z/MIreN4pAHQsCMQprEIs/MI4H0NDKFyLJ3aY+kIkCAIjSDYbkKtE+QEdCK8Wo8EeFEIfOP9CJgSH0WUCJTTCH+RBHvRBISCMJrACMUhDrbhUO5BtWFao1yrrVaGP+qDPJXm3J9M2PfDnqdZv/RYYPEjdOfxDPUyDMICCYlCClSBCI5O0OED3N+S5WkGydPd5n3M3oE9SbsNnllu5Oxx0NuxCDrCAeuOLYuFLfMd3jHrgB9p3fgc4fwv4f2+6WBsBEnQ6WBOBDYv6DbMrWtegZeEAYeqLIkRCJnhCdjiHEtJ1NmxEwiqDLfw15ykPwhUxYKu4bMYmORu2MTQEDE3sKHSdHWwxG+TFkgyKXdRBHzB56xhdJ3CCa0jCLuXBHiDCGV2CKyzDlLtUOuzDhdLtW9oqRM//UqDLdG63jzqMuSZmYlN64n1tqj0Mzy6YhlZKQiMI8J6Hw53j+Tc8cjh4wwD7eZ8L8PpwUiQJejqUw/ooKwNb+TkEVT28mNpQ+qOfARfEtxpMugeysOReeoDv94AT+H9/Oqgf+A4keFmfdYOv9TXugaBMrycMRxGHuJUuYUkMrIEYAyicQif4wim8OnH4wl8rYTiT8y8gdrEf9sQ2YW0EwhfUQZr2i6AIih/0AWF4EdEZnWvgCXnmgR74ZCWIQjKAzzRsAz2gQyqXba02sCytQ8XHNsS/dG6/e/vI+1xSGHBH5dTdw07jGoFuScKM9Djk+ShBtzd4Q57n+eNHfuSP/1LAC7DEO/wmAXrEo8NzyxI7MHAq9e9McUMx5MAHqMDkkgEXkIEGfrwWdOvIkzw6ojymp7ynf/qAezWC936C2wDwN7NkGSm9+rAZyIEZTDPCIORtBmQwDANfHwMywC4TAnsw6EIu1IIuKANDtDhGxOYxmHOxF7thD+QpvKTspekdhA7BIEIhgKe3F11sYLt/XUJ55kEiVIYrpHb6XJI5xANAnBM4jmDBcecOClQo0J07gezQpUuHjmJFixIjTlRHjx6+ePHw5RMpUt6+feze9et3r5+9eclMXbpEiVLBcN68ffsm7hvOnD2r+cSpc+e4cEfDiSu3dFvTphYplkNXLv/dOnPr4rFbt3Vhw37/6l379OFDBzFixozBkiVLGS9ptMTVcuaMGbtmypQ5ywVL375NmiARjMRIYcGBjRBRvIMxYxuPbdSoQYPyCssqQGRWYZlFBxWbcYSZU0gPokaPKqVWXenSp1bDlF2TJo0Zs2TFmA3TrbtYsWPCdh9TdsxYcV/BkPvypax4rEmB4LiBc+eOH0GHFDVyJElSo0aXNoHfND5T+UuI8hR69OhTsXlNy5nLKc/gOHEFF3Zl6PDgOoxLAYwqo4go2qgjfBD855+R5MFnH4/yUekrl4oRZSZKwMkQHKE49KaaD30KKqefevppm3KccgqqqMTZShxz2In/USurtvLqn3mQiYOsDM6yYgy2nHDCC7m88OIuM8Sw6ywx/gIMMMIGK0xKwRJbrLEdbKCMBsloYMFLyy7bDMzMOgBBBRyAIIMHHXQIIoww4ohjjDCWICMOOfiQJJRclGHmmj+vgWaZZAhFphhDiREGGOGKC8aYYJR7NBhl+jTmlEjgAAOOQDjFThFLbFEmmEq+y2S8U03N5BI++ljkEU12yaaeqmCMJ6GjCDrqvnPI6dXXXsP5NZxzxKkIQBSjoiodqShKZ6OPHFRQwXz+ecckk/KRR54JsRHmk0oo6UbDnnQCEacP0U03KBGF+iZFbVKEb8BvzDFnp3W0mrHedbza/ycbU8jqgEcxrGhCCimyEDIuL9i6a8mHAxssSiQilpKIwhRLbAcjGnusSy67ZAHMkb3szEwW0CRDDh2AAEIHKsIYI44dfCDCBx+sWDMOPh65xJRekvEzm2yssUaaZQY1VLhjWAHFGOaKk7Q2ZpjzBAwoAIGEU0YY0bPPXzRpRBJLTD11vEskycOQQiRRJpt57PkmH636cWccd8gJxz5dc0XqKA2D9fWcb5aaqlmpJmJWG4uejcckaaXtJ8IH9/lHwn3qecaVSyoJPMOkStRJG2pIL50aoUQkSienjg0QI4rEUegqduLZynatxgErm0rC6IEGEM5S62C2iByyrirMoP9Lr7P8wsJJJyWO0korHfMY5JJLBrOFFmiYYQYagBADDTnmKL+O8tHXo47119dDjznkwCOPP1D7xBVg+rxm6GwA9bNP4o4xNahNjRnGsMMIQvAEGQACE5PABCYywYlQbKIRi5CEIyjRiU5wgoObqIQk4EeGPBzjbfbQSjzMcQ762G0h40gh3vIWDg19Ding4MmJmPW6iVREh/WwB4IQRK3IqeQf+7CHPSpHRHZgAxmi6NxRuiGuEvnEdKZjF4hU5y4cti5AU+FJQmaXFXOI40Uz2sc8joGHMDSBBSCoQhWaoAQlDG9IRSqSkpKHlyU9L3qEkZLFiHAlQUKGMpMJGfb/RraCFrBgBjgQHxvIhz74SRJ97YOfHOSQhzzI7w+I6BkoWPGLAP6Jf/yDRjFucQtjXEMZyzEGATmxgQjMMgIkAAMkPOEJTFjigtpJxB8aYQkOZsISlHDEH3KgAh6EQRPXmEc90CGOj7DDHeJgoUJcKJAY+u0ovyIHsbhYuGRBJR0+NEkQhWg5fvCjH0Y0p+X6cQ50TMNbectQFMUVxQ9VsYrnSh1RwomOeC3liwk5B75q9yJ8TaUe3PhEEMZgg80AgQpynOPBlMAWthgpSQ5bEsUiFiVAKoakgRRk9TymJUQmkjM00IEY1rAGSEJSDmhAA00xick4xYkMdorkHN4H/9RBJMIRrUnFopQBDf0N7Rq1QeYmXlmbWIgAAQggQFUREIEUQAITkXCgJRyRCO8gQhI0MSYiVoYZHOQAD8PgxjzoIRUaXeUq2DxIffCTH4EoBUUDZQoOT5SRdjgIJCNRUD/WKY981IMj9ThsPMTRjmfwwp73jCI4urHP0o3OdB2aYopaN9AvLmQr+KCRVlA0D2j8YQxLYIEKWLCEiiohSFJQQhIsmgWOKulhYuCjSKtUUuqdFDJZwoEhsycyRSqSezXoQRXGQIYzoIEudUmeTe0kp7SkpacxJR/73FAHO+yhD4NohCcr8QlR3EIYo7yGLT7QgA5Mok+QSIBVBUCAWv+SQAZP2BQkGPFASkhiEd7hzgX1EIYgBGEGKphBDoJQCWnMgxtS2YY2sFIvc+C1PkjhMF+PBdq+HouHIPmISCKX2MUyth5JlAe92tEMo4BDhpnNZ7r4STpzDeUb4fiGNoAML9b1FYejVchWsrKVqWwDG9mYhZy6NAMQUAEJtE2YbWkbJCdkQQxVyEtv4RjSwZD0pB0rrg2wlKVC4gAHKs0ec7dXAx/I0UfJy0tbymCXM0S3p2Po6BkimVM5uI/Qe/hDIfIghzjlgQ+e/EQpZCEHBzjgAAoIBCSsWtX8kuAJnQbEdCCBS05AcMBllQRaXbZgB6MsDjlwBdG2gQ51TGX/IhrecEGymEUy8mR18AlxQHk4WI+EJJ0S+opJkKggeMjjHeY4Sd8wi8/MoivH1EiXT3o8DiH7tXX3MehBEcoOczyFG9J4RBCWwIPXgmAJcqxCwnKbsCC9sQxcXtIbxezHKpU5zWcmpJYATpk3b297NNiBHNNyliq07N1ZqALBrGCFJeXZDJi8JCbhdCegus9NaIgZuuOABzngYAEKSEAC8ksAlac8q08AxMtfDgdcesISNT9rHqqggx6kGwef+d6C+eA2blADHXGlSnzqZRAe65qMqjtRvOBVuICmQ9gnhhw8FXQtaW3rHyDZx0EqG+1pa5af6sIJruIFn7Rv4xtG/8GrOeLRDhRJBRu9gHAPdKCCD4DgYj5ouEW1PO+Gg7liFtt3Y0yKUn8LHODe81KXLEPwRdZgY0uwvMtwoIOb+UDnm2f4WY50XTksOAhtEsObcpADHkA4CDwAQhmcsIADHOC+V9W0AARQVRKQIGuffvkbuMrLRvBBjaWvghFsMAMe7J0F3QtCDj7hTGpgYx7IIqi3CbJ0ouw6i3+9MJC3+OscmjgeKN66PK7ej20RsYhf59UMb0xt0wXZn+bycZCDvPamtN1vBOEJO9phHSgCG6zhEXIg3RoMBD6AMW4GCKrgtozAomjrjcTA3u7tSaRnuBTP3yIjMgJuBpQLkSRvBf9ooLiwRDJsQAeOqwZs4GbYxAeO4AiUYAlYpqOSh81wEAe8p8EeLPVmQAeOIAYYoABOjgH2iwBwr6r2y+UgARDe4A7eIBB2SRH4QNFKTwd4IEu85wM+o80eLA6KgfpOBF6mYoxeZMN4LdeajkPIqBx4DSe0gXCI7Clex3Fox/wWZB++oh/8wR8Oyx3YTw9prMb0SZ/U5RA9BF04BMioIermLkAAZCfIyCiS4oj2YR2KJRuGQfV4oBN5oAd2bgneCN8CQwmqLI6soApSMeLehAqo4C/8SLispAU7RjJs0Ra3xJAoYwexhwUkjwVgIBiDcQdYwAd24GJ4oApgkA7YYA3/5AAO4EAIwEAJeCAIxEAL2ODiBA1JKi4OeooMkqQIRmACKAADSqC/niACVA4Bdo+/PC1rmlAKOQGs3qfP0oIKLA8f8bEHPDEHLuEasAEdsu4SMdFdkK7pdILXuAlXbsIbGPImkmLX6uVEJGIrYiQr3iGdqiVC+MEf+MEk1A8e2s9yBlHs8OkQ1wUl2QUOgyzEfA1A2vA+8mYcLPEf1gEbpEETcsAGOpEnOzEUXdEVraCPqCDijLIVqeBJMEa4rqQFb+Apb0AyovIWcfEDe5HgDMkEgtFLdKADkc8HhkAIoOAL5IAFUiACQiACPAAJqAAIfEALxgfQ5KC69AJJFOws/9wSBjRAAiRgA1Kgv0jAqq6qHdHR5eAREzxhHhehHu9xH3cOFPnRE6txF6wBHVjCJA5CHFgHIbMIVyixbxyShvxGEjUTcW4HIzXyK9bJIx2kH+BBJazlH9yhJEMzn6IoEc1FJRXRG/Bvi/Jvi3TCDXNlHPIh2eKBGpCBwXwyCz0RFC0vH6NEtoTyKMPAFTFwKcsMzaCSKrkT4LbnBban+QKuBtjMBhgpB9oMKlvAB2AgBUKAAzAgAyyAAZQQA26gZeAEk0BPDL7s4VyGZXSgBm7ABCjgAR6AA/4yHdexHXevMOExlziBEhpBD+SADPBxCUBRMjW0Ez/gEaAhIK9ljP/KAfy2QTPfhUQQksYua4ZkaFxU5wz3RUbcISNR7HH60B/wocXUTyXWwR6oYYZqU+zqr/50kzd78/tI1Cl6DfseBx/QwRpE4QM4cUM/MRQtLzqD0iitACmdh0qYsil3YDu58xa98wVg4AXAczxrAAgaKfky7wZi4Ad+oAhgAAOMEANioAW0oAIQIPcwAAWOoE2CAJMWjAK7zAFdBvMkwwMegAEqgAPO8QkEkx0ZtDCZ8IEmIawolAwwNEOpVDI/wxUA0pzG6Dd/zCmAjERUx7JmCP66gSi8gYxsDV9iZEZPDB9q8ity1B7+YdngQRy4ARlYtMZMcuyk7SSPNbM260j/42UnfIzt9GYcVCIf4mEakiEIPqAnf1JDrXQJjIAtg3I6WTEoKybxyKx6+s2QdFFNa8AF0BRNJ4M8I0MyXuAGfIAFYUAGAPMJ7iAEoDECSuAOQOAGfmACAgAABOAA1vMTs4AOWuZhWwZAI/ZNL4ABHNUcn4AEFnT3MpZjO63T7iAQDmEP3kdOgABDP1UybSAHyAIP3CYbkIgpSDT/8A/8dEIopO2eTPInYnXXZJVWLxJa6mFoQ+IfdlUPX+wblsEVhlVDjjURCzFZj3VZf7M3ndVdElIcpnUbrAFgshUyPnFDrbQwslRLIy5cqeTwzrW4qjLgAE4qpxJeb/ExYIBg/4cgBl4ACtwzLWeJ08BABiIgBgJhBSwgGAsAABD3ANzAZr6ADhYOYtlEBSNW816AAix2AjDgL9VRvzy2Yz+208CgDdgADcjgCnGACiIzZT0RAsgCFPSnxZ4uSWvWajkkZ4u1G3iMM8/wdi4SH9qhHToiQooIiVzzHJzBFUShRQfRb/Ap2qpBaqMWnxpxdqnXGwhidSRRV60VD8giC8G2Jx/jE5/zOcXVbIMybc+1KR8DZELGbQvpKbnkuOSXbmNAX4VACKYgazKWlmoJEGBACGKgA3xgBQrgALygARAXYcHAcQHtcR82cjMvQHVgQC32ASQgBNwz09rxYxu0v+53Cv/agLrCgE3YDHU9VXUhgHWDgIRgF0WAjCiaAv88hGcT0RvEzrKkTShE0z5axCLzBUGgJUKObR/e4RyowVuSV0MoESlW9Haj9kOkjWoZcXqD7BvOAXT2L3f+oRysYRc+AAIygCfPzHt98jHHtyi3Ky2M0hW9lN/Ytm1zUUvg9gZycAVvAAbqFx2FoNNCoAKEABDQcpaeAAwYAOUAoAAWAHErYAUQN/eeIBIAbQ4ceHJVkE1o4F494HLRMjAHkzA7zR31VQagoA2YsUL/82UgU3U7sQFS+AOijxvsIXZzIg21gTfPRXVqmFWjDUhF5Db1xse8YV9uB0EaBP0kpIjiAR3/kMEUROETYmh5IdJV0wV6m3d2Y/hIeQIcRKdEc+eMHEoFOqAD/E1sIbN8zzYo36Q6lVJjNoadIYMqVeptJQMGvMR7sAQGimAKQkAJIwCrqooAAoAA/DIFMOBgExhxf+ALYiAERgAACMDTMGEPqoAM2ARyHckMFk7zaqBiLzYtVW6/GLRzZQB/3YCm0ABJ3sgK9vEnU1dDpVQHxuAPlAFufpci5IE/QmQlO4RDMoQgQMTHSmQ472ocbOcqaDUlpgWexGEf6GGyTMF+KmshW5WaodeakZREe4LGtCg+jGgemAEPPiMDwDd8uRUyd86cqRMfC28xMMbMyNR9b5EFJGoG/x6jfqNxnwUAYXFP5QAgoAkAEljAoBM492QAE9zAvhIgAoQAGhnIEtiADeYE9JSEQiuuy45AAyw2kDU4pPmLv+x3lEPYpk66y6rgQru1pT3RwYAgDPBAFN6GHspQIcThKITiITmEtm2Yxsbh7OyDKAziHBziHGLkNFPiHFTCcbJFHm5SGETBFEyhGPzvDT2TEp2WqqWNeq/aZm34WXHIHhrKFb4HBMJ4nCXTrM+6bM0XH0WqpNjZMd5aniUjQImABdCzBmKg01Igv0MAoA/aoa3qCQLhoAO65QDBE+zADsAgAiogBQCBCTlBEOpA0CTJfeQgwtmgDTQgAYywn68KpP85O5TF8gvOIM966lCrQJU11MFwQGb4wD2wgRpSKHb4YyENgpt81jMn0YXqZdcOoiEcgj8I4hze4R0AUSX2IR5SQh7QIRlEobmJQRoKoukW8m+cGHq9gXSot2bZbrufdSlcwtxygAYExieLi1st77xVejrVXL31rUraujF4gDxBZs7j25JdpgZgwOUY9AkYIK8TOADyq6q4ahIaPAU2uMAxgRAwAQFCgATg4NNwiRH84H0IrdL/4H3owA2KoFH7WTA9vLPb8S/ntAjY4uES7mE99YSp1HtogAzwAA+ayRqo4RuqCbjtZomjlcOIZVd6pSEUwh1mBBMJYkaJ3Nd/PSP/10Ek1A8fDirGkFcUdgEauMEgyIjGWjVDvAF3cVMlcQLL8Y+KZRh3tdop6mEehCEOeMBMxFp1nfPywlUo21K20pzK2jxj2htL6hgHqZLNJtgH4FTPeS9jAUEGDsDP/7yvuQoxfSEWPCHUsuYUTiGXAJfTXk4IAiESzmfjKr0PSEMO6EALLkDD6ROrODukRf0IHO7hqtMVH3YM9vE5yZkHetBN8CAOgAEgq8E+gJ0dOOzb9oMh3mHZtGXIh/wjkgyhEITojX4k5sYc8KEfvqHZ7GEaXEG9XCEZuKEegtz/qPzaYXU3t53svj3Ls92GCKcpKOwSgqAGMgMCUJulIfM5/1mmZbI03otSKBHDYto58R4j8/J934+rDJ4yzz/25SLA8A25kfOaADChwR894T0hFnzhUWIBE+CABGrJ5QhgCCaB0vVgD0DffQqhD/TgsVFg9rKKf0s+1OP0B1JeDOJdOoOyU0MRtTP0ex4sCFrtEZZhHmbduD1iHfRKyIvdx2dUW5B/6N9BWzzC6KEFJPuh/DQyH9DBHpohGuKJHcqBFz5BvYrBGnh1V664JK/dx95wKHIaRPiJEatXXHgCRagPGfBAB3ZABSCgAVLWvHdu7inKFasTPwHCChUqVpogMYLQCJEdRBbueLjDho6JE3FYrHERI0UzkYqEIPHkCSBAIf9kAJKBAIEAAQQQAAAQARIkkYDgvKGJ6ZQnTJhGkgBJggCkSX/29PlTaJDSQYoK7anjZEKBBBFCpETwM+tPGVljxPhxxEeVsRN7LFmio4dZKmeXDFzCI27cHnFXzJiRg0cYHTlMTaMmbh0+e/HYGT5sOJ5ifIwZ/3v8r1+/x/kq52uMT3E8fPv2Uc73WHK/fOXQESM2zp25Ypc+fQImbR4/f9/CjQsXDhxu3OB6jxt3rve3b968fRNXrZq35Mq/adNGLTq159Ofb3uu7Vs3b+K6b8OWTVScMTtAQGigVq56s3R5mHU7MH6YMECAzB9oRaCRJfuJ8CDSww48CCggRTr/4KBDDQouiGAPQOggySmclBABSCI9IQBQCBDQ0koVYjITHDa9AcdImMSykyeeABLSExGAEQsmfCBVSI01IuKII4L4cQMDCSAQwYYEVBgSV1rJIMMPPzjhgw5ABPGgk0D0QNFabLG1hFpqLSGQDnbhZdGTeCAzTXfiGLbOOeu4w46a58TzDj7y7NMPnZ9JBhlknXV22GahRRaZaPuU48w0xCAzHS+tucJMNvb44w855PRGKTiSkhPOctoUp1umxRXHXKjYTSddqdpss4038ozTTj3mmIPOPMz8EUQWSgARF38NQcQQEkg0ZAQS8GE5UBjFznffW2kBgRYPOqhnQ7Q2/xDIg7TT8trDHJOoOERLNEESAQAIPBEUAQEA0BIJIJJQ4VYpiMQTJCqySG4IKjoiBx966OGHH3vs4YckjhzixwU/RhABAQJgZWFIWSEpxBFi1GegGFXUh3HGQIylccdVLGEsFWIEkcMn0tQjj2T7yCNPPpO9DCjM/7Bc2T/5sJwyno91Zk9noYnWz2yQ7uPMMssQw4swyBBjyifDLDNNO56RA8+lmIZz6TjieHNqbr15sxtuny5XDXTRYWf22c9548477aADNzrZ3IJHGFlk8SAPBynkEEMIAXtQfGcVeyyyQVBBsZQGqjcgr9by+lAPZ1iyUyDmkgCIvJBIEABWIf8Q8FK6kPSUlcMlji6vJ5AIAYcMQ3mSyL779kt7joe0YTCQGwJZ+hNv3ESCDE+AcYYZYlhMcccec6z8xmIYa+zzOeBRDDd4Ao199v3Ik2doOeu8cz2ceQ/0Y/qUgwwyybhSiSiuuPIJLsIIs4w3++DzDjnu7O/OOf7/P45XieM3uDmOmcQxHFShbYFo20Y5SmMOd/TjbejABjag8YggjEELZsibr/gGESL8TYSBe8uwjhWEFB4uSgZq4UQaZ61oQY4hQBCDHzDBCV+0AF2ZUxEcPschDgkPSSOBxE9EApKaACJFqnsCHEY3CU7oIQ/7+hftmMKIQ7zgAbrjEMO0UiT/IYABDFqQQ/GMhzzlSSljzMPYWKpwPGQhawYfqMQ07DGZQGlPe3nyR9Dk4Ud/dG9PnvnTPzpTD3ugIxrE+EQOLqGJYXziEa/hxSd4wQ7P7M9/mzwH//r3v/5p7VWkJCXcHoiqVKYSO6h6YDnodL9tRAMbwMBDEOSAhjPkzSAgfEhDfpkQE8aHCoZT4QonwkIWGughMZwhsHqwh0lYQhmxSIAAniCTFT0hBTL4SOZkUhM4rKhEIclc5jARiElMghGRwCFPMLGHOejhX1bslyIEUQcNMABhXmyXVkBCojfQgQ1mPCMaj9dGJ7URjhp7YxzlGAYV4EUY8+hZ9y6KUchI/4Zl4MtonupkD3qgYxrO4MUjHiGKWRwDF5W4Rfp4QQx2PAYxh1mHYt6BU5yu4x2GSYdP4eZTn6pjqOoIatxO6Up0BJVO/XAHNaYhjUvEIQ5yIAMZqKQDXvaNIb8UIUKwNLjCQelJQaCPGlvYuIjIkFfAVIIP5iCJRhiDGX1IQAhYNJIWCa+I4LyDJ94QAZHIZHQgYoQ0M7GJUXSCE5mYBD0fS7tDHEILEkCYSob0z628ARB3oEMd9CCH0IY2l2IonsUuVp83ohaOxzvtGwfy0Pl8QKKVsAY3PNMZzOQWM40BTUZ1OzN+CHc2wn3MYOpBjWYYzRS9KIYwgGEKXjQDHf/tiAdoOqOZ7LJjM/mIxz3esb93xKMd5G2HT+uB3nbQg6hBbW86zPveVqGXTvIQBzWsUQw8TNWqaWCLDj64VYd4FSFtOeFAjJlCYwFhIPVBnAvTOkOuelUJFD5EHmRhDEqwAAPkshBAwckiKDzhB54IBBhGp6ITYWISlKhEJUAhi1r8QkKSEEQf9iC7eh6CET+obMIWltmtgOEOdsCxHuYgWlwWz7RvTG2THdraKM/neGMYg2w/kIMg3IIb9vgHPtALZvTawx5hVi8+/lSnOt1vMT3rB6TeDKlD7qMe5WhGMYhxDGX0Yn6i4IUz6LGPd8iZMz57GWM2w5h83AMe8sj/Lj0eXQ96gHm99Hhbe9XxaHXEDdOP9kx9pwENR46nykzITxUAzCu+BQshwmrLMBmMYLMyeI1ojXAIAUdhgpKhEsEghSA28BOEOfGckLjDHc7pC2Mo2xexiIUvPBEjSVTiE7MoBjOuoQxdbMIRkfBDH2RXRYDZYQSVVdgXMztkf+nhKHNot2jRgAarWhlZVFBtlM2ARnzjmwxjoPK8ITDbHDwiNvdjzJ4MXvBIP1of+iBkz8gM6UjXo5CQ8Qci64GNZiBDGLcQRjGGAYz3ISMb85h4SOuBDot2LzOErkzKHC1pe3D60ZCuNHkjjl5Ij9mi8nDHNJCBhxyMOgx6G4tW/7uq6r21OqwMro8x7fOggSDTwS3cVYSB6SslsCELOIiDMX6RiRh85IgyAVHZORGLuSpbGcxQhrJjEYpNoEKlzIBGNq7BjF+MwhKMEMQgwC07P7SAAQwQkj8fJgMxFtkPg+jDt4/s7ndbdfJkaK2+D2r5fZPBDHGw6nwgAAEQZNkVFd0MIdesmUyrI8w0bz2k50EP2HNDHbCfh+25MY9pOJcXprjFL3bhClMAYxjMsMY0nmENaZAcGxoVTaA687LRNGYxBc+uYiZNc0xjv9OR2Uc2XJEDHMS7ymPAgsWwgAVeJmT9fCPCW4b5IIyVNQyHiw/GqKC4ZTpzhkZogq3q4P8DObAJGXYDFeBhQmBOo8MJp2AMwXAMwTcLuRAMwzAMv5ALxCcN13B3d8cMxrB3ksB4eyAH7TYHdTAHLPAACUAVCDB2mSUDdxAI/dIHNgJuoYVkojVVnRcGYoBGzINaFKExY+UsTiIGVBAHf7AMgOZRO8MzYWZ7TwiFT3gN1yAN0gANy5AMybA0xHALpuCFKQULuiAKuqAJfIAIf4CGfPAIxUBy6xAawnU9nUEzNjN9ppcZ1hcP29d6Ckdz0FcP0lAJM0AD8MZv5Wd0Rwcs6/dLBeYWyaNC81F/9nd/yqQDtsZWRoAFasAGdeAHdIAGfTAKmGAH75JXgPBOkzAKDjj/DMXQC++zC7kADMVwDMxwbXd3DdYADVTYgauQCSB4Y/LUbibYAQ6ggpUVZCQgBDDICIywCIuQI4qACDQIeDeYZKMFb0vWg68VBFUwVlSCIGIwBlMlClFIjraHDSRlNFpIDMLAC7cQfKLgGp9QCZdQCY+AB3+AB/kYdEFwjy5WCX+gCaJQC6wgC53QeWNhBmSQB3jwCI2iSPHgDsIFD4bGGKNhGZVhXaCBh4pBc3zYkXw4cftgD/NADEEwAyxwBmdQiFYwFqgGEYr4S1rSFvf3iPQGfws2axQhYX1zLf3HBWxQgnsgCJHAidLECE9UdjsRCafggMewNOx4C71AgXkG/w3SYA3JR4vKMIu0aAyx0ItJEU/z9G1oAAELkAAPUAEcwE1akQLJyAiEcAjNmCPLCI2K0BQ18geOd2OAB3mRl2SdR3kQtRdOQgZygAd8IAqmUAquoQkudlJ/sJD6FQckkwOVaZk5oAIqUJl4cZmVSTJxkI9q2JiaoAmfIAutUAq1kEFrwAZsQAd0oAeN8AefAA3N4EDxUD79gHA2c5GW8Q8bGQ+SFmY5t4fi0xnzEB45MAMqkJCFOAZwZBAH0VXTuYhMN0w1mSySiJMZowPUmWpNkAabKJSHYAmcwAg1oASGdQiEpSKcsArKoAzFIJ9Jcxp5RovQUJVXmAzweQzDAP+fxmALoSAJhTBPkGcUdZAFZYmWFbABJYAkISEEUAAHgUAwSlEIisAIinAIdsmhHIoIHloIeZmX/yI7JOiXOOicY6ADQVCYoBkHynkXMSqjgkgDNUoDnWkROJCZN4oIodAJoNAJpFAKogAKRCqPQfAIpfkJoiAKpXAJtvALl9AIhSBZh0AIjNBiiLCYz4AN27AOztdohPYP98BbhIZovCWcw+l6kRYPIikrf5ADIAACk2dlrdUE6td+wBRM8ZEfIQOJ85ed9qedD+JMwAKeQDmeklCenFCW0TQJPKEio7AKwMAM8hmfuDAMx5AMzCANtMgM6ZgMx3AMwaALtWALskD/CpogCXkQB2JggzY4B2jQAQ+gARqwASPgAi6QeEN2B36woY03gxiaoTniCI2QCIngjMTqCIuQCDYSonnJl0cmWjeYg1MFBGQQBi46VSrwAXIqpx3grSCwAuP6JTKaoyBwFwLnC7rgC7VQCrRAC7BQCmIImnwQkNMGCpXQCKEQCvRYj46gCI4gMCfVCH1hfOIgQYLkZWJ6SGXKcmUKZjs3nGImPv9gD9ywC5UJAh9ApwglBr6yN6rGfl/Fp1YAPX9qk69GTPeBMd3ZN17VBFgQnnOwB4NACJFACZSQCadwCBlQB45AOSpyCquQC8qghckgDL2QZ1ZZhcyQhVp4DMXw/wu2oAqgsAmacAmPgAh8EAf0MQe6NgYjSAc1YKse0AJn+wI38AWc6Acf6gg2Ypc5kqzL2oyNILDEaqzH2qHRiIZ4OaJVtC95ILiCKwc5iAd5IE808AGgB3oN4AAdkAEZAHoZ0AHg6q3d6q3LOQNBcAmvIAv52AqwQAryWAkQwJBxIJqPwAehEAun0An+KpuIkAdouC8qEAewQQ+4qbC7eUg5h16HphmYIZwSO5w7d2b2cA2VoJyL65wIpQQgG7JEAL3Q+2oCsbL0B6gqWzj2pwMjREIxywVrEJQ2ywjSdgmbcAqMsAeW0AmxYAu+4AvE13Zst58ZiJ/LAJ/8KbW0QP8Kr+sIfyCbg1tVYhBPc7AGaNBudJAFLeABJtACClIFWcC2hdAIdtsIdRmwkqDBlKDBHZyzH8zBG/zBHUzCAqOsdFvBjYAIfTAjgssH8aQDH9AAM0zDNAwBDoDDDcC4O3weOvwBWNYI9agJqFAKnbAJfCB0spmZf6C8lyALEpIJlKAIfMAHcpCtU3UGRsCteJAM2FAP//Bm93APDMdw9xNxmZEYeNgYBZcZH9lp8wB0QbCxGUB+/VYGTvC80JsQ0HundzpM+YEfVlYsgkwQwxQGJmuyxDQQe+NVSHCn4RuUfWAIODuPmnAKsTAJkkAKa3dt11CVVFiF9+u0WhkMvTD/C6gACpcQV30wBwopB2OQB6NlBv/yd0k2UD5QAzRgBkDpq4iQCCf1CJTwjDkiCZRgCZmQCZZwzMl8CciMWJvgzMi8CdMszdGszMoMwjmrwcv6B4hwhoIgCGLwAQdgAOVszudczgegzgvAzu2szjP8w3GwCZfQCfxqxL14mPioAvNICdM8MAATTzg4VWXABhCgAkEgCiT3KEIDKWWMW6e3cxHtGc6XJ3sischpCvoVBlVQA17ABel3N1mAxyEbLCDbx9EZskiAfgWRH1YwBvK2yFSABCzdBAUh00uQiOznyJkIlHVQs84oCZkACqeQbLqgDBk4hdlgi1QIDVlJyr+g/wuvoFiXQAkqHKJUTIJ6YAg35i9WtAdo4KpzYAbFA5Ty1AeKsAcBS8wCU8yOoLPRLM3TrAnTTNeZMNd0Tc3O3MyXwNeWkM0hrMEEe8EBywc40MMNsAA1TMMO4Lg47AA8PLkGrQd8sJBdGwR8IXRdGwbLmULHM9bNiSzHEwf4JrkzEAe7gHv74A/CNTSnJ5IRHWZk1mYQPWboBYXZwAz2yKJKsAN3c6dKcDdOUNIo7cjE7Su8VNwnbRAxm37Te9zoF517rNPgO7N10AeEwBRAywmj8Aq/4KmcitSenL/9CdWysAqkYLX16BSBO7hzQEVnXQiMRzv+Igf1oUtkQIKNh/8Uf5DBbm3Mfq2znIDXm9AJBW7gP3rgCW7EA64JyMzXl3DNf73NxZojciC5DsDOi+3YjO3YjY3DoPfYOCy5kA16P/zDoKcCFhF+OYogl12ZKxoElKuZeHAMJWcnKlMZsO2ET1gP5Xh73MANSi3kdzcL+WhGNeADFDYQY+EEwp3cyu3cKK3cJ51+xv3czc3HB8HHMZsGrEmzg7AHheDWmdAJoyALDpi/Tn0MwvALUA0LROyjUewIWwuY1bhug1AIiEAw/hJZfzcHOjAfPCBPcsAveuC2a52zxzzNC17goBAKoACkkC7pkT7pkK7gVzvX0fzgEA7gHfyMOgDiG87DH77/wxnw2JPbASS+w4sLcD/MrehamTxQVvWKCHZLCZfQAVXwwznwB8iAe7YXe/MA5MIu5FNoDbdohcuQPs6VtMAXfE3zCY1Zj4+Aj4drRj4AAzCg5EtOYSf93Hca5SYN3co97uCe3NBt0uYO7jHrk5oYlOumCIoq1KeACslmDMNgDP1ZgblAC62Qqi4mCY+QCH8wRaE1VYUrWu89T5DlLxt6CINgxWTAAkCAZKBlBnog5gKb6Ioe143Or4/+8aRACh9P8h8v6Qd+tXjt4M2czADOwS+vCCsw4h3wARlQ8yYOcK1u4jufmRJlmUEAmoeLho3wCPMISZAu8qiwCq/A9LJA/wu2YKq2YAueBbk/XAnDsAvuaArwGO3T/gd8kI8vupncuvNlr/M4DwEz8NJm4ANJ3gLbXm+HqH5PbuXH3cd8XO5TXuV2L+UoLUJNwAVqIL4mqAeDsAjGzAn8ugrvu66nWgo+2piqe7iCC3myU42h9dI2uPAA0y+DsKEZKgdUwAMjOAd9YEaE3i8a3Ajyjlj2/KOhIPKxL/uxD/uzb/Inj/LQnAks/+D+COE5qwd05PMrSlV5MCO1XszzKM2wfwpDKwtSL/W6wK7ryq6/4AttDtXSr/26kP3cj/2/YAYqcB4QEAcqgAc4r9jpr8Pqf8Mz3OHq7wA6YAUi7QMv0AJJjv8EVxL3O43lT77lUA4QTQQiaYIFi0CECRUiNGKEYBMkDYkQcdgkDZs5cubsGeRoUiZOmTqNOrXqVKhNlyQh4hMnx4wcYcKQkVOzph45aHSSoaIDBw8rGvXsIepn0CFFihhJcuSIp5wwaAZVEXNmTyFFlCRJomQp06VMmzaBIkvKLClUZ9WuXRsqFFmyneTKFbspk6ZMeS/tBZvSbqdTp2LZsuXLsOFfwRQvDpaY8ePHvyRPViy5cuJhkzX/AgEBQgMgchxkgJDhw+cGqVWvVr3AdQPXsWUvaL3gAG0aNpy0aFGDhg8jVIQvWaJEyUODEB8ORNJ8oUCDBwtKf/68eUX/iA4nTnR4kcwajXsOMXLUJ1GhP+n7ZAzD4+WHDyqAABlD5sx9MXLOiBFTBYhP33qQo4469vDDwKOSUqQpShSZY4YZ4uhDDDTm8AMrBimhJCyxOnkrFFJKQUVEEVExERVVVDkxLRPPcsstsmCcq5O6NtEEr69otCuTUQxrDDIgGbMsSCIVG+ZIJJNU8jQH5DgkgwNgG400z6q08koHsmSNtdlua4AFG1aooQUwa+iBOCqWAMK4haI7qLnl2uSCC+ogctPN6ZKDSDnmmthhh4n+NKIJG3jooQclvDDDDJ9mwAGHGQrVQQceaFABvg9+0oGK+f4T479JJwWiBhVoqHCj/wONGmTBpppiqpBCcAjCjDOEYpArDenq5CwUTyylxBNTTHHFFtV6UUZddRQLL1BmzOQUXzZbbDPLqLXW2seUHKYYbY+EtJBJVFBttBVWcNRRGspVd10VVAABhA46yGDeK63MoAMQVPDBh06B6AGIMIYzQgknnHDOuoTehBM5PpWLM87qFIroISMosoIMNNjQeA2M0Kg1JzO0YMMmOcgwGWONasoIDSD48w+IKqrAoQodzjhQPD380Hm8plhtlY8gVKhiBv6uKgQRpvLqRBOzRixlWGFLCTHFp0389epfzXoRLq5nXPpGTS65Ma+vNolFl1rQ1kUXwmppmxa3bYm7lv9aaKFFbrrjXtvtXPpeW5e+c9Gll14EnwWWW3LZZZdegKEkJBw68KwBBxagAUJHg6Bh881nYGFd0N+FN954Qbj33Q5o8LffToWjogrjCl7oYIX0rH32iHNnLiKHeEdiDDTCqEpjNjxetCY0tBB5DeZ3GkNlm8gYQweqXv6vB9/KKFDnopBKypFFWuVKkkT+A0EPRfboI8MOd0VllVVegQUWFVVpRUUU618Ra6ldBPGtrs1lWWEbG1jAMgpboM0WfUvg3WxhN7jZjW4RhFve4kYYwgQucH8bXC/WNgtcJA4YvRAGMyyRiIzUoAaSI5cOViCrR+EgBzHEAQ0e1TnMcY7/c5+jAQhYwAJ32QAHnRLVfHSwhIHFzgm6s53uEgKxNtXpiQuLExn4QysteIF4Z1jUorIgMjbcp3knK1kYxiATmLnMPzrYFw1qYJUD6WEOG0GK+LbSla9IQg86kIMiEFEIS2joEpuQSyje9wpEzi9FqWhFK1ghrPxBcn9Y0xqMAihATeyIbIN8hS5kkbdcPDBvEJRgKSmYN8IALnC48BsHOYgLVvZiF8BIxjXWI70qqCADK/iMHGrAAhroIJihmtSjjEhMHKhQhZPyzS/TtTmaHRMIQZjPoZJYMCUwcSB7mh3t7JQwhOCJmwiBE5+iYx8z9EcJWciCE4p3hjJkoQpf/6zJxpBnsjiMYQxxMNkY+PPP/hjRjRaqQ6pW5Yit4KorXtmRIxDhiEY4ghOdCMuuSBG/+CVyfrBgRSNZEclGhhRqvrpaJQEIirfMqC4cEstXQPFJCbrtk3WDoCzsZtO62TSmFswbKwUHOFeuLYSE40UyspENjtWBDTbYgQ0g4AAf1EEFYLKBD9i4rxvsywcqvEFXvapMZW6uqzVYgQu6yi/WdaohSkhiFahYTm7SLjq7g5gUq+PNhTVMIFaoyn6yoEXlaeE+gVXeFsWQpiXMpD4lqw8Z0lmVgNbgUSzogYEMpBSEKtQSXqloIS/RCETEwRI06gQozBI/FLVio6uFRf9IXStSYeHPaZQkxbGQNReWko1ptZAFTh9Iyt72lhbCHW5xaQHL48ISln2D5d9y0bgR9gIXREUGNuYxD0G4gQ2JAiIEeuAIS7HgTz7I6jyNowStpje9OgBrDchbgxtk4QjpZV0PjOAD9DakClaga3Pe5LA86QmK4nTinJpoVyzohA3M80KDtauFMoBRC+xErwptYIPE4jOfUcmJTvYznyoskwU68MMhjrKUrQRyEgwlpIdCMYpRdMISjugQiEy0ClmEKH+qhUVNVyuLjbpWksTKWm1t2ywB0iUvKekEkH1705v2FhbBHW6PZ2E3XGBZubFc7nRlSTjCTXcXxLDGPNT/YQ832EGLNgCmHBzxEhvODMQu69Sh/tWpKlAhCDKZCRrkoIeh+CEMed7Bvqw3H/waZ2BW4K8Tw3kn6NgOC3Q68J2iMydKP/pOXDgD7LwghUJrkQ1eYKsRkoDerbZgBSyQ7MU2rE+UefjDQDiDbyLXgSr4gRG7jsQkJLFZzhLSLae46CvgRyNNgAgtI1KF1ErUCuLa7cdSnl8jW+tRVrAiFcTSGoy3VloBtjQllwjFK3o7QeICeX5OVjctZvHud9/iFrCc9+LszbgvE26EuxAGNOZRj3/0IxBu8MIOqqAHrYQhQkGIQxxqkoc88IEPhUhERO/IULnAODCviMVgDnOK/zlQYQxWGBi/0HpetmbTCmPI63QQMgYsNBquBqG0wiZtYOlAOtJzXZiluZAGJSiPBQcIQAAU8AIfSEEJTf0hWKs6Hx5EfQYqmAEP6oMG6dEZCMlc4b0ywIJBRGIpk1gohzykcWNzfBWxaBZaLkpS+0Gbtzdlbd2tHWSPrkK2aSHFKUZxLJWuNBOBvIS5YUFTINvtcK2Ft7pl4QpXzALys5B35e/NC3zrWxjE4PwyuPHvfvSjBzTZQyZi8Qq5oHQUfT+FKhCJyI533G1sc+VhfPE3Y+QeE4CiAQt41xCJJEH4cOWTFYTDaEaHwQrKbzSkLW1pcj5/0jmv9KRFfYQBAP9A+wAougJMAIMdKN0HZ1DCdn3Dgg/k4AOpgUD6exAGxupAD50WQxmqsAIV4MAze2BErzmL8bNbNvsxN1l4BRUBFlWYsuBawAV8vY0KLp7KG3VrhdfTuxUhBW97kcDjBA2hBFR4LmAABlMYQVNwhRGEPBTUNlYwBVagvF3gBV7gvGJABhpcBhtchmZ4BmmYhmmwBms4qmzgBmzAhm3ABm0QiVMoDF9IIAxqQryhmybkqQ1ypb5RDF8QhH35oYWRCCK4jt4RvuJDvpGTCX3Sp51LDp2LGOmrOQKjOS7QIjdIgO3bvgBIAAuwAB+ggzCqgu3ygRbooZdgjclhATNYAxr/oIo64I/5sJQVAAE/aAqys4SQMLsXOwUUIcALkgX4ORG9gx9PtED8IRETUQVPRCQKZK1GQiQLXIsMBDy6EIut2Itc4Dxk4IXNI4ZimEFkuMFjSAZmEAZREIZkUAZkeIZ52IZ6qAd7sId6uC4hHEJoxAZu+LxpfEZqmAa2SaCgAhzluqAobBsnDCVc+JvCCQZj4IQsQC8t3MKG+L3mAEPnQD4xLEMzPEMs8Kbakb5Ng75ImxMvcIMXCIA55D4FYAAGsAAYsAEl6AExmJkayAAQgJTPMIDUWL8BCIABWAAH6AAbqIEsQIN9aUgdwJc5WJCF6gSw0ISMK4mMer3XUwWt/yGLvzsyr5mLGHkRDDyW2tpJ/zmWSwo3HNGKrcCFo5qHIeQGdECHZEyHZnyGHoQGVyiqacDBcqgHfJCH0Au9dkgHdaAHdCiHbShCaazGZ+TBaNhGoRpHwcmFLMOb2PNGDFqbVuqgxkAE+YKB3nsrJEgCL9TLJpBHeeSzMUiY6JArfTwIfaSTcHq0OREZBSi6OSSABCjIBzCBHcgCKgiDrXMUqptIijyNiyy6ohuAA+iAdaqBiLQUHZgBOUgEruCQiqpEjDK2wMjAV1wyveAL3eQL3KwR32wflfKa3xS8r9iLGXOER3iES2CGIGyHcRCHcTgHd3CHdWgHanAGHuQFV/9ohmlwhmbQhnw4h37ASnmAh3dYB3Eoh3b4SiIcy2ocwmuMhmjIsqDasi2zICeEwiacy78JhlAYgzPwgYRkgeGbmCSIguvYS+Hjy3gETHnUJ+lbjkt7DurQRwqdkzTQghsITcgkAIOUgAewABNYJx7Iv9X8gBnwTPYzgNFUgNAcABgtgA74JXnpgAb4gDzQEJFAibMjidqcSSRrqUDSEFdhiiJNKFwBtoXaLLAgG84im03KTb4Ats3qwA7cij74g0ZITlcIQnMQB3E4B3I4h3dgh2hwhmjABmIwBWSghmhABmeIh3V4h3P4B3lwh3Ewh2+gBmrYhqRMynIohz8tB2j/nAb5/AXaQ8u2qYXlikBHZSUO6gXJQIR5qoIb+KEoiAIG3UsEbccDzdRyYjQqYLQyJFUykD7GnBNNU1V7FKeDccMM9YDQFICi+9AJYIARgAElcCoHWL8bhQADCNbPbACBDIAHOIADSIADoFXuCwADwBcQsIDUyAFJiE3g1EAdyYtAsgSmSIpC6IM9+ANYwQoF8ZnMQtI7slJ1XVehRNeEahXkbAR51QOJQ4TkRIZ5oId/sFN36Id4eNNnsIZlMAViwAZqaIZmQAc5xQd22Ad2WAdz+MpARYdtEFSKHUI/JVRqwAaz1Ea0zEbCuE+6sc8uW66/AYZfIIU46A/2AqJM/11QmH3HKNiCTN0TLBi5ecTZ+ni+fNy0n0uDNGhVnSOIS/s5LbCAARAAASCAAPDQCGCACagAEzgCL2AB0qBIzzCAAQjWG22A7KvDAwCAixSAAkiArx3NA7AA01CBPtgskAC2JduESaxSrUAoR1CEQhiEm9GDPujbQRjXQUAEBQkfeC1cwz3cVpFXeV0Exm3cRUgEyIVcMoA4RPgDPhCFbPi3ZVRGbmgGZLiGa4hKaZgH70SHrlTGZUSHdEiHQSXCdWAHdgDUpNyGa+RBQ5UMXZgMV5IbuWHLLZM3kvWpKVybX5CE+RADFQKiBc1UTU0CmhU+5k2CcMJZUtUn41u56f/ItCh6PlXlXjY8QwzVgg44gAIogGVlgAqIgAqQAAyAARgQL6vFFK3dWgOADwPQvgFgALFVAKWlVfMtANFE2wbogV5bsSJV13eFqES4Wz86BJ3xg74FV6LoW/UZhL8V3HLNYA1OCsZNBMdNBEQIYcg1BBKO3D+CFUSQgzjggz9Izkcohsy9rnngBoFdhmsghluQBhpeBmk8ShmmhnJQByHeynJ43XiIB3WQWEK1XfmMBslDQchjBVe4tmzrKCnOtpCaBSmG4shD1L1ZG1SwopY5LAUdPpg94wVNGC4gg5WbR0ZzvptDgj8pCE2zUCOIUN8hCCUY3/JNWgZIAAmQAKj/9YAX+CEwAQGLvMgBgA+v1b4HgFEFeEwRLV8BQAEADmCMXAAbEATy2DWEWjGvwJV0pQTEhVcFeSjDNddSXuXCZdykwGA/CuFXRo8/wAM+qIRisMFkWAYaRIZkKAZXQIaj8s4cFFhpgAZo8EEiRId22Adn/tJ1iAevVF2w3FgmprfKizd3m8D5aTwni7zJgzdgkEu60QVK4BSY4RQiYIKXLWM4QWM1HjnXWbkyzJMzRAKKKAii9TnFhI4AcxPgcw6DYIHKUdYDmIAHMEgFmAANaIEdYAEfYIEUZdGiu9EP+NoHKF/bKIBj/V8FeADRbFbRzMgOyAI/IATySFIj3QoG/2FlBvajDVblw22Exs3gmtbgED5hWDkKC1YfQ+CDPPgDV1AGZViGYsDFX54FYQBdadjlZYAGZkiGZOhFaHBKaWzmZzYHc1gHelCHQG1P2zVU3xVZCLKgHjs3mlI8eKO8XxihXJiFAowD+8qzM1kCJlhQd0Zj4TMIU5Xn42uswaRjcKqI//LZmzMnBKMI5Pi5C1MBC1gABtCAC7iAO8wACwABNuuhD5jfrbVf7isAE8DIKIlWC0DWAriAAKZD0VTaArAcXXOEAu4DDF4EloZXeW0Kmn7cyAVhyM3p3d5t3d5tFBbcnC5uPxpXnS6EB35gQfDbPoC4SjAGZmCGYQCGbf+RpWWY7qdehmE8hmPIjGH47l20Bmygh3rYhy8Vh4hNh3LQhj51b9t9BtxFVC8Oqlbym7G+N3sDBmEAhl1InEyYgTVRgjQxIyso409dXubNVIMoQ+mhZ3qsxzaJiCbo53zkgoLoZ/96PsL+OY5Bg+3xgXdpAQ8g5DBhAR/yIWAN1kXOAQgI4AJQgAO4yAJwAGQdAAu4ZEwW6QCgVdHeAZTuP6NAZca17cal6d/e7T8S1yQv7uFG7qNJbhTe6XGFleXWGZ5Wnz7g2zwIhWipm18YBlmahcbp78hDhVbIH1EohVa4hVwm76pUbzAtB9Z1byOs3Wh4BpTd87YeocEBKsL/yTzoCkFhuMVcLAanRobv/oMZwC8jAIJRHTkEf1m9ToImskcmagjBplACw+e5yhOHmLSLmANAG4Q++DVLqIMV0II5cCf0yr8PAIEGOACuDYIc8NqLpEMFyHEBgGSQDmAYLboCeFEO3VoHsIGCShVCoG3w+WAld/IQhhVxPRoSJuEq/1trx/Yol/IqB9w+uHIIjmBTB7SakAQPIQVZ0IVbEIZZAIZjwAWyCJu/QLZOEAVcOAZoyNx62Ib0DEtANVg+5cFneAbOw8VDz0Xv9m5fJurpZgZokAZpsIZrOKrPk+GKz4ZrAAbNwS/gQIKYqQKYbeeQX9BLjzRHa4J25BMo/6pwDHeOiEAw6EiDNZiDAvkDrrAET4iFU8AET/AEnZkDjsGJW1eNHMCDHAh2gVTtAmCA8tWA0VRkrQ0A8y12TBZ2C1ACXTsEQwAf4A5uEO72aa/yP7DgQjCEvC37Ek4Esy/7bpf2Kb/2vr3yP4hgOSJ1qPgDkTC3XBCGbdmFXxCRk9ARGIsxTQAFVqClMjtGcfjKsBTUcuDT+Bx4H/RB0AVCy7d8brj860rGZdzc67IHboCGSpgq40g0JZinM9ZUBV1wBrdef3a5cbIO2okTSVOYh5k5D6d5jrijTRAMw+g4bl0EvS2EPBAXZP0APEj+BqBoyITMZkVaYcdIpJ/+5v9PemBfACcYj11bhJgu7hPug78dV3D127wFf+/PW7KX9vRIj7ZHjwj+9ge2XKB+OD3IAYZDBE2QG1zARWKQLlQADIB4FerSplCjRnXqBMrUrmLQsKnbVg4dum3aJKLDRi0aR47zPoL8yG0kN5EkuWUTSa+evZb7Xtr7WA8bshwqWCjxoSRLTp1JkCBJkiTKT6FGjTYZ06QJkqVNsHDhgsXpU6pTnWIZk7WJFa5Zt1pBYgXLVadKmDZdmkbNmjl19ggyRMnSplGxfOF9NcoTJUaD9OjBowJCgwY58OB5hCfHBwMDAkCGDCAy5McBBlguQDkygM6dOVc+YIENI0aLFin/Sp0aEevWrAvBHiR7UJ/afWjXHlRotu0+sP/04dPnzx/YhYDbBlx7D/M9f/jkmTMH8JwgQXL8QaVrliteyIoBm9XqVSxdpBJ2OmUQFSmGxZZNq7cNYzlq1LbRq9+RY8t6/kMCGGBJ8/QnkzPUaCNSNrNcZwMVVUBYhRITGiGUElJgiOGEF2qYBBZEASXUFltEUWKJSUhF1hgrjrHEGGSMYQUZZIQBI4thUJEji1ZQYcUYWQC5YRZeaMGGW3b4QYgjc6Vniy+2xDIKJ5k40scebFwRxwcQEJbYI19+mUMDBmwm2WeTkQnAAI5d1uZjlgUgQAAERCanAAVYoAUjjkgy/9dcjTjiiCKB8mlcIa4Vlyhyu93WGx/E8RHpbbhNmhtywiU3nR57ACZHHHk0Uosxx9wiynfA/KKLLbXoIssrr8giiyq2yMLKLMAgA98827CTTjr1zDPRNuhQ88wz0Rj7n4LzZNOss9lcI4201lgjDYH2AMtNM8h898wyygyDSA48OFgFEEBAOKFRE2aoIbsYDgViUEmQSJSJUaSYFYs9yLjijCzeGEaNNlpRcBVAOuHEhEMW6RZcjERCSUGr2ALlKZ5wgskkhNTBBheCffBBDpWQXPIjOczwQQMFwBnAmZMNgOabbrZp5wEHyBlnzpcN0EAWjFAStCWSoDYoobPpZv+cIYY8F2nSlNYmXKRT58abbYYgAltvnDbXnBxzBFfJL8oQ44owyQwzjDG//LI2Xra8WnEtuPRyzDLSaKQNOup8RA+x9k1zLEfQZJNMMdweU0wxaQMDTC+73OKK5LPcsks29ewT0zxl33KLML3gAkoQS+zAwoPnQmjhhu9yKEXrJh5FL+xRjEiWiita0cOLY4SxYu8C+y4wjMCvKGHCqw+5hpF1JAm0JZwcdIr0nHBiiSWMzMHGGovNoAIemnwSviaVLMZYyGO2vHNlZLZZGWaRFZCAZnHOTz/LBnRAhRx9JoJIIo0kYhGOWIShWlOIpTWND7rRTW+CM4hI/UE2wbn/DaOulrVCbK0Pftggc/zwNT0MBxXMkEYyDCeMYQTDGMH4hS9ksYpYxOIUsaCYLHAxjGIwwxrToMZEyqEOetgnGtPAxn56oYxiSI4VrkhFK1iRilKkQhVP/IQooAiLW1hDHS+ZBzeK0Qtg2PAXtnhED2zAApxEKEhJcNfq2pUhL9xLKCaqlxyjsBSy/MsKS+jXjXjXOz/6jgp/HIOEJqQw5HlheX4QxCAG1afnUS8TlpiEJPYgnTHkIJOPEIUm/lAJKj7iOipI2ZbQN7P3rSlmlXHT+wRwgALkrAD1KwADXomZNX3gU4gAYCIGiIjV+K9/iCAOMSP4tN7ohpixmVQF/2tjiN80UIMbnKYe5iCH4DwiGNKAxjEalza36SIYwSDPK6QnPVnUohXDYMax5rONH2JjGkLUSEdmoQtmpBNWtIjVK1TxqnKSAhXSi0UupMGNffSjHl3shS5qEQxfnEIORtgBRZUAITFAqAmr29AbveAFDHl0RPc6EeyQ8hQs5JEHe/RXHn2Euxi5lEWFVMIhN5qFhtVhOn44hCIYIYlITGISlJAE0XIqh+7l4BK50ETIgvAlPogyZCEjTAYOcEvMGCBNk4nMLSEjS8wIYAAKYFmcEvDK+a2pMBDIAR92CcBFJCIRwPwNcZhmzGcOwhB9ACECDTUb40jQNxjMjZVq4/+Hrlkyp9PJAyiMMQxX7EIYjgtGLoIRzmCYE4ajOAUpSFEKWAgDGQe6TzvaQY9pyHMa2oiGM6KhqrHRIhbkMac592KJTHCiE6MoRTLmgVB6cOMWlRimIxAxhxrYILkqsGgWMFoFjSaBo1LwKHU72gWRjmhE8cLuFu6IUhjpsUcFexF4XTpeH+UxRxuqqRKM4F4jTIhIVRDDGdAgh/vO4RCDIMQgBGjJOGRyBn8wBVO3BAEV9K58KpgqBJYAgpux7Kqg4dljCjBWspr1lXcaq/oM0IADeDiX/+tlXFPTP9ggkJi6eebSBpEHPeT1mbtJmoyXZghKgXCBjULsHuxbh7f/6KERusDFJ5JBjF30IhepooUtLAvR6I0iFKRQRS1oQYxlCLEcpbUHNYgYDY20NmiIkGEe9iCHM5hBDECoAQtUAAILdAAEKwgDHoiRjd9Go1SP+AAIVEADJZSOBR7YSRYKGd3ovou6H3XjdUuU3ZFmdwu2++5LYdoj3PmoYJp2KY7Uu9EJ+SDUooavDkSNrjKY4Wt1gDEh9JoHHnSPD6K4xGBY0AHCiMw6OsjkB1TAmA9n1TG3lJOEvSpLzVi4AFYVgFk1s9UABFsFY4JAEP7giADKVTVZ659dI3hAG+vVmXhN2rfBLUHlVGo5HWQOGs7glunMIROiMEUJgbGLXCjZ/7K2SJUqzhOKTpACbrCgxS3es0N0vKMdFUntRqJhYAgMrQEQcADFKd4AB0BgAQ7owArMgAdkTAOhM2kGNy+BAxqcMeUgAFKhfWAEJLiudW90o+sa7Wg6xs5DtttdjDCNXpgWLEfmDdin27sDlxsh1PClQQ1KHWp0fU0OmxqEI25MBpTx4ROVyEEHbtACEyw4ZDwgQw+WMIM4hEFlhWnATSAg7AFE2GWfqVktNRy/V3pGTZhhO4glroP/wVU1iohrXFnDNNqAu8V9SISMv22oweZ1mYBB92H3wEEz2LealpRDK5SRDG72gqHDSFWqavELgYCCFKDwRTCkXApcHAMa0/8oRz7Y0Y5tbMQZQ4wGBG7NcU9YAgTCB4EGOtABE3RAAx7wwRz8cIlkcMMe+wBWPJOhDFDMSAwYzcnBCq0ERHNIuu9ql0hpR6KcCyUtJ9VXTFlKXhsBfbw2ysIhj6eTjTohCz7IQhnO4H80sAF9TQfV9YkkgEwQVMKeNYAGXMALeAALFIYFZEAHsIANQBVhZFUD4AEi4MEYoA9l5J1nBICywVIANFv9DMDNNMAMWFVWrRWfnEbRBJNrLA1g9YHixdiM4UZg9UYzWQkIMQdgrFoQCmFO5UEoMAM0SMsxqI3aGIMKpdDpyUIs2IIx2AJnjcIqBAM0zANLwAQ6TENroZb/B6zACrDBDThBLHCCD9gADMBAC8CACbyhB9zAHAxCJfSW9FEfNkDDNegCjcCIGPQAuvBfTcXcIS5aR2HIvTxapJXfpN1O+73fjMAfz/nLingB/SXM8WyiwuiEE+xf/50BG7CBHECIHOyBIfDJ0IiLyCTgxJmAB7iAB8BAnNnaBIIAF/DAYBTGBygGHvDBYjTGZghAzjybzRQAAexMASzAATTAB2CVAUDAGPyBJAzQaZgY4SFCXx3QbtyYbWgNYfkG1FRNbyhH1wAGEW6KEf7BL0jDMhyDMojTCj2hCjkJXjyJCkVJbqHCMFgDN7AEPtgDECGLNEzDDbTBF3zBERwB/x3EgicowQ3cgBb4wBFoAQvQgBj4gSJIQh5mDhBhA7RoQhCEARrACBWgS/dtlLtMlxtVF+1c1xZ0wUxmV0yOSBpwASXCn05SYlQAjPv9JMvRVCdu4uocTP8VCSm21xrogSpKwtBcgibkAQLuGQgcgQvcwAscAXJ5AQh4gAdYAJyxAAhsCR5Uwh8gBmKgZWO8STEWo5l0RjESAAoWQFYt2C0ZwAfkwSBIguAR3mlwG3HIRot9Y200k2zMWDRBzeSpWxByyovpwY/pQR78gSbowiWIgjLoQidswikYw5NYzClslid4wihggiXsgSNswir0wjJ0IToM5DYEjjNIwxC0Af8UKGQbaIEfPKQPsIESsEEdaAENAIHUNUIlMAOBZI46RIM1XIMw4EEcAKIOwMh8AYlLLppHteR0KZpMqsF1zaRNOmIapAFPvt8a6KRPAoxOrifLIQzCdKIhAYn/kWJ9tsUeJMIjSUwsyIIogEIlzAAInMENHIEPSMEO1IAXdIAHmIAJaEAFaAAEZIAKPALJ/GKF/qIKgBjLKKNbyp3LbMaaeJi04eUM5IEh9KVq/CVcbaNgxhjSVA1tIOZgRVON7kFjNsdkSoeRzAFl8sEjzEBjvUIcqIAYkOYkaAySTgIjaAxQTYIglIElhELn9RY20IM6ZEQ0kNwXwIEdFIEbEIL/INhBJEBUHURCJJRGoFwCXZSCtSCUPWADbULDSMqBv+iA9mmBdoKUovFpn4ZUF3zniNCkTIbndamBGpAnTkYFFySqoi4qefJkJc7ITniUJmoiUQIJfZGiHPDoHNxofs5FJoxCxehCeHwCIjgCRhGBFPjADhjB8TUoCqDACFCABUAADlTo+FRoAj4HYmiJAURYh5YJiIroMzqGC4ZBHvDJAGVjXMUgi9YgjdbotCITOe4YYv1g9pSip+QBIlxCeviCI7CAHRACJnjCBgVCIPhBIESCHYDpJBxCvCpCJxiD5+ENNqDDPFiDMzzDJGAMaV4MacaCCm0WDJUTDLHeNcxD/z8k1DQsA9p0IBD8CxmYQRWsQZ76acby6Rp4Z0wCKqEWahc0qqMy6lqQ56KWLHv+5IsASSZe6ibS38I01yjiV8fUgWyAqiWkx138AjAMQzzqgiTEAQ5gQRLsQBWAQAu8gAlswAigAAYUXwaAQA4gwieZwidowpf8QYXiwQxAgFWBlVzWz1bhEvpkVQ7EQTVSgiJckLM+K2CaWzlOirUqJg8yh2zwGNcolnQEAe8I0CGgqRu0wR0EAsTYQRsMbiBMgh3UgRsEAh1Arh9IwinkwjDcDTaUA3CxFgxx7l28jS8wgxWyHq1QoS8YQ0owLD5MAzIIQyfkwJnJgZqhwRokEv/tEgnGUpfteoHuKtoaAOp3zuShCmrIlueMjKzJNirKSsXK8s6KCGUnuuchmUsVYB4pusWPDYIgLMIj7awvVO4xgK8yHAMtnCUZ6MAZeOULwMALyOpXekALxNkM8EAlkEIqcJLJROevWVUyFqNl5B20ud2xGgYe5Kck2MYguG0MFl7iyWgDK97cWg0EI5M0oaMe2MEFc4oemC8SJJLg1oEdfAEIh7AbhDAm2MHj+kEkHEIWwAXGWEIsBMN7WMOw0MM2RMOTgCYV3qPpMoNm/oIsxBZenO7CysM+0AQuIMIMcMFvisEaAInykOIaSDHGSjHvcmfv/q54EuqhAm95Hm//yZLsyUpFVJABSuUkTI1BJtqUe66ODqCL/xXJj3nqbWwvXWyWLehC2lifMvDxMRgDKOSBDqwACyhtEfzAC5TACIxAC7AByqmADshBIoCCKISP1gVjJo0LBLBMhMHJY8BMKuVl2jYCUe0g4RkCYApTDeJVpcAoBMdtK/PGNDWHlVywHWQwD1gBRXnBCdPBFxQBl/6yG9DBHXhCLPgBHfgBI9CBD9CBG0xCJBBCJuxbMtwrPdADNpDTZomm9IzCK9DKqOhCKZACNxcUEffDPCTDJ/AAC0Ax7l4xn9okTcLkoH4soNocyBbqiHBBpEEaicjkP/vzFuwzF9jRHXFB7ChB/xRIwaElgXshAaCFWv4l0pFYHiFAzFwUxCnIQh6Db0f38TBIZRCAQAdYAAVIgARMwARoQAuQZQbcog3kwSWAwic8QjAGQa6pDLC+j/u8CV6yXRzMAR+gxjUqAlwRXuEZniGk8nHUKNKYW14FFg/u1absAR9QdQZP3o3+GBv4gcYIsxvAQSDAwR2MdQqna2mkayDYwZNGwin0EzCMUEhwwiZsAvXYNW5xwr+BAi0cAyt8Ql2EAitYC8Pmwzwgwx/kADvXJylqrBc4InYNKqEOb02GbHiWXyNONqCa380B9Eihn1GEiIXA14UkkvX+mOUJgpJIAkGEgkb7Qs+mDfiWkP8fB0Ms/AEIQMAFqHQFUIAJ1AANqMAgq4AHxC8fWChiBAGAEcbN6PRlZBVWrd0zBkEe8EEhDIrgGbUCa6P/tIZdfRvSDOZTtxgsR1OOrtrkbQqSQK5aKy4dvEEgQEIgEG7hMikmABUkQMIdlAYj4FYn8DUzYANIDE3Q9InQWE8mgAL4wMIwAAN7gIIrGNRL1EM25ALKKPZiM7afPvaGh+c8U3Zllx9nm1+hqsFmw6Rk18uJoJ+8DIVQjDZ3QrF0fDCStNqSZIJurQIQ68IvpM0NMWHb2MImkAEISO1XvoDStoAP0AANlGENrECvJcZzUHcOEEZhLACwBZuH9WLIoK3/HLTVL6kGKhv1UffPUdsVA8+GjYH3eEdwMTUmem+KBe9BxwhzHbSBG9wBJMQCJMABJmACJ0DCJDwkxkxCIJCmIDDpJqACMCiDNcjEXCdEXWyzW2+0Llj6LcSj+B6DNcBmTFzDJaCMCngUhrPB7vZpZeczyOJzpIE4h8czeKoBigM0P6v4UZQUaLvX+HFnfV4vpxTCKm5CJ4RCKJQCK7AKj6dNMKDQQ3UCH4SBCiyXEhzBC7DBClRBqNGBFgjf/iCG/1B5lUucA1x5sD2jVKkAD8jBHzRCI1y3ijormf+lNtaVmof3je0geP8VbiBHbfxBBQPGIMz5j/1YMt/5HYBB/7rewaB7AnwHFbvid7rSwSTMtSi0ZknUg5Ow0C/MIz2qUNsMwxf5bBJmA2wyyzHgAayBAIbnrhTzKRe7PPBWNhdHdqvjc/AOL6zbc8hydr1s+BbEi7wEha7H1+7WZx18zeKtYiZcwreKQitstManjTCwjWXJwiZIwhzYgBfAgBsQZ0XagQ1QoCRsAg98gPy2GVlCwAdkALhvecjMwLjkwVxYo6C4O7bBewApMJonHpuzeb4jZnAIB3BM0w8CoR9QdXDWwR24ARQMwRBAwR18QRv88g/EQBEMgeMW7uMywuMewiWwQjE4ej1svDgluxN2dOIIwwkdQzJgA0swiyiEAf8O4EAHkHoVs/zu0i5bVPGhrsGhBi/M5zyqh+zLy7zM27Pv/26Ju3pMzo6K046FtMv3sQt1sUEW3Gd/Letqa4Kwo8LTK3vaLA74GsMozAEZEEEdGBIMCMJYsoAjWAIPEDmXTGif2cBgsL1UYXIOGMImZAKBs+0vAUQigYsEFixIsCAiRIYYNnTIcFBEiRMj9il0sdCfPn8KDfKzx0+fPntIgix5JouWQG9+vBDxA9KXFi3awCjyAwokSHXo3CkCJ5AbO5ZKDUsmbZ4xX8aYHlN2zOmxYlOHHRt2tdixZejM2ZvH7E8QHDM+sDF71uwaNmvWeGG7Rs1bNXPVdKFbt0v/ly157dLtizfvXbpw5xKO6/cvX8V5tzSO8jhKEsmTHxsxkkSJFM1SlHT2rMSLDyNe5NTZUyiRnj+NJFG61CmULV+/rg6bqgy3sl+gEC1hAUOKDzsdOsyg1GiGChAdLEBQwYLFDh4qPnyAUJ16jiB44uCR1GlTJkuUFilSaKjgQ4aJFjVMpP5hH4ki5VOsOAhj/kEk6ffv81EPOdigYxI3foBhhCFegAkSlg6cYohAoLiDjh/sgMQONwi5JJdjpOHGmGCYCkYZZp6ySqoUozommWXSycerXuIgg4YPQEALx7TYWquwuQJLjK/GAhNMsL/wimvIwQ5b7C7FGnvyyciQ/0BisiQsu0wKL7zg7LPOvKjBBh+yQEMOPfaQY44+EnGEEksyOSUWWXShDaqocAtxlEzmgC4NED7gwZI+ZgCB0A4ysMEGEFgYg4cZyPogh0i74yOPRjLpJJNMLXHEvELWMwhUgtATCCKKGJLPkEHosw8/VfFTCKP9zFy1EJE8KqmOImAA6oUXhpiiDUx+QOFXCOGAo4hA7miDkRvswMSSVX5hRpoQgwnmFxGz9cWXYGbLNpdbjgGGF2KqIaeebD7JQw80dAhDxxzXQgsxIplMssfCCGOrR36HlAsuxZpcDErHotgCMoSR8CxLLTXLjEvNtNDCDDPQmKOOWRFxxJHW3P/cJBRSZLEl22Cqcio3Y2z5Q44wIIDABkmAgCCDBmxuoAZCM4BghhxU6DmISHOII4w/JNkkPEskkcSR8hS5CD6HFhEVoj5OpS/VivxbtVVE8vO6EEVclSijQrzmaD8/tHADjjfgAAOOH1rSoAIYYBgCbjjaaIMOOgTBBBNPOOnEFmOUsWVkWVRBBZVVToGNk0sy1eSST24RhhdkvhFnHmQe4WMOL5boQa0c2dISrb6G7IKwxfjykci73uK3XsH8Rcx1vQo+2GCEMeus4Yc988GHzpxwIossyrBYDjT1kA+RRTy+dJRV5JyzqtxODAaVR2aAIA5JdAABhw4cyAAEGFr/UKIDHsKIdDs8gogj6CAQuVTTpZtWRJH14COVVAypVdX6Mx//DCJrr5KP2RTiNa/NBz9li5UfCKGFv7kBCnKDQiACMQQP7EoIx4JEIBjBiElMIhaeiMQkOBELXRjjEpeoxCU2cQk3SUIRkVDEH/jwh0d8AhjFeEY0zFENbWTDFHjowxy2wIQdzG5HbNAS6s5iJB+1jjF7cd3ArOijvcTOMINZQ+50Z7CEQSYyVYLYw35HBCJkBnllkGMZxCCGM7BhDmZC4NQ6ZolNdKJ6qpCTyeqUohC94hGP2EQOZjAHEEAAOkq4gRJWIIc85GE7j8DDJvEQhjB8hxOWECXTHFEQ/6h56iEBfAgCS6UqW/0vgbRioEIiSDaziSQ/hwAJHbTwBTd8oQ1v8EQs4ACFnLwNEDphRCQYwYlJRAJak/CEbFqTCUq0iRKYYMRqGvEITcyiGNCwxjSiUQ0jYoMZn5sDE4mwg7jsqHRRTN07aYc7vbzuSIj5IsG+WDvVAclJu5MMGqs0mTWyETOY0dLEtHCGM5ihjlWwo/PkY7U1temPsEGFLHIBDNtkpRi1AcYvdPGIOORBBSuQgglMwIYasCAPlqxcJR7xB5tyJxObGM81OVZKgXSkIw5h5XuitkpbUcRqrVRVfjCCCIuADVZO5chFvOYHP9TBD4IIRDHvADgOwv/BDXc4FgkZIQhoQtMSy7TEMEtowkkook2V0AQoepEMa8xjHtzYxjq68Y5yzCMbs1AiW6LgxsO8U15m8cI79cXFH/1TDf0U2Ba16BgtZvFJAbVslMxIGcxoZopaUgIRjJAZL3RhoRPTUvKq0FozqCWP7LIIx7BJQ1CUohW50IVHq1KVYhAjGcMoxSN0gIMdsKAD0CEDpR6hi1l84hOUQ8RJMbVT/ZUygREp6naz2x896GGdZRIJeJ+HEZtOlapQQ0REUInARAziEIcQhB84oaxj/SBCHLzDJLbqBkhgQpqcYIQvtGlCttqBEZRwRCMqAYphMOMaeK3HPvZRD3vIAxz/58CGNZRh0uZVwQpUIIJh4CnPsywJoPVanV2EdK+ClTFhUHqM7wIa48XwLmFegNiWgmeZhnUhCqkNrRhaKwYtrUEOcWieHsKmCI615hJzxW0usmWMkxUjGSYyxiocsQQbQGcGeajpJXohCuiKAhR/GMMidDrKji0CuxJxT3r8Nyr4TGRr39UDAlW1h/4wFdCpeupPf+pk+DJiq1NQ1h3uwEGd2OGZdrBDJCLxX0+UkJmYOAVJ+PDDXkADG9yYBz3oYQ9T26Me4pBHP76RjWy4IghksGMVghAGIBBpdjlCMeyKRMYyBsmMMUYj78zou4IhDI1CakwScNwYHW8G2jpO/0JmtxDa0HamtJ4xw7vGYMkeJoIPhmDNDDsBilbQYk7BgEqWpcEMZoRoFZfIAw94kMhKzOIW0IVuJfCQhzaJkhJMa4+o5PwpOr/HIOjZrnbd010z+RnQTH0VKj2ViEI0AhGKOEQdvhCIEUICDnfwQyCsugdGeMIT/L0DokkYCU5AyxPexIVdR90OcXyDHfigsKn38Y9+xEMd2bhGJcJABojSOghBoGdd3JKWealFLqpT0mmzWPW6yDiN00aYwQaKRi9EQQrV3oIUwC72rw/7MUmY0sG4EAUubCF5Wlht8rzABSxgwe5YSEMappgFLmWhS0rIwhlwoIN3KXkOMc0DH/8QwZooh0IVqiCZuktkIhOdyBea4EMlzmwKUZj5E43gQzXHoz/0UG0iBifqnBHOXVZmTYC1LMlG8sORhXiKfxphryEyzqn50uELF/LECCWN4FNcGuWY0AkHA7FCwHlCGtnAKz3ewY5+XP8f/9hHPOiBj+v3ox7WuIYwuBMHJMsBYPUc41zWErDZMb0tTVeLlrwIJdW1GNk4nnYacewFhnoheVJCC+huAAWP7gCwM7JAS8zAC4wMosRgDKxAAq1gDCpwDKhgDMiADDKQDNKgA9NA7uROS84ADdCABEuwedapvOCMTSTnUkJho7DnZFAGN47BGH6BFT5BhjjvE0DhEvj/AA8WgRI4QTysi2lKyBEY4RBKiAV76s04ZmoIbmoQQSAUYs/2Yw++i1IuiQsvKcmUDE3m4AvjIPHEkAvzKAXlwA8O4arqgHjcIBZ8IRYYgYLqgBBiIRbsoPkmAdF0Qvkg4ZkIwdTQQRzioR/c4Rz6Qft2rh7ogcLqYR7aTROGBv3kQl9IjJ7Sj3YUywvQgv6A7TH64tiSbcbSjneyhKEGMO5UMXmcQPA8IwAFsGIc6qHqyAJv8QLDYAzOgAx40Rd70aEaqqFKEAWJsXnCcM8UAc5awzU2ARRg8Hpo42SSIRkKaRiAwRX0TRQ0ARHygE0ATn+m5j0GgRDKcQmjEB2b/wYhnIxjCEFUGggjrIo+ekgj+OAi+IDJ8PG7SiKP1mnx+IAPNqKHPsIP9OCqrMoPfMABbgASjq+tMG2EAsETlG/lmK+ERugc3sEd1sEcyqEc0sHC6qEe1EEd0AEbACsbmKEXWEF+zK90ShAu3k92LDGM1ECx4i+0EsPYGCPtmI3/0C5hpCAWWxF5suB4WvEVYXGhAFAB5Q7wAK8KlKAKsEAMqJIqvQAN1gANZtEMHooraVEOHEoOiLEEzyKPoAfOWMM1cgoGcasWsAcqfCsrkAEZoAIYeiEXVsEH2YSURKUj+oAPXs/iMo5/CtMwDfMQCIIKF4EKEYEQBEG+muppXv8lETrlIvAjvrJKVp5nJDIiC/MIC+cADQBvATygDXRiEkaI0RiBQPiLEbSJ+ZbP4zTSHd4hHsxhG8qBHoIu1ObBGqCBGYqBGYSBFR4hB0in/cgyE/3CXgKmL2bH2qguSCJD/ygj63wSOwdKKI2yKF3RFZWgKI0SARNw7hIQ8DzjeD4jFhnqAedoeSqmK4+RBAVEK6EuK1NQjwwh3BqhY+SqE+ZKFFKBo6QRpKaiGJChGq0CFjqhEhoh4BasPTpiC/OgPlKFqhSCfzDUMBGhhAihCj1lEZSQEA4hgjIuvgjBEEZiqWrFzz7CDuoARpcsTeaAaHiACuSADIBAB4CgCkz/4ADuYITgQCcA4Q4AgYNKaNFOSCci0uPw4R3OARHD4Ru8QRuwIRusYRmK4RZMAS91QRdkgQ8QpXTYQDktEZ+axDndAjqtbdisU+2o5DqnpEqkxAiohDO883i+03i6M3kCLwG7pLWqIAtaCxbPsxXrCFHFoCu7Eg3MYizJJMkidSw1UAPRhF0S7w+o8BFcY4Y04RMClKOAARiEgRhKdSqqcRieqxIkgTUWbBz74HnA65IC0hAKgUQdUxEIoTDnbBE0szFRIyI+YryeZw/qIAwFZCybJwxqbQzEwAd0QA0L0gzlAA/EkFrPa5QOQdOGj9ECIZk4iA9jc0lZTifKoRBv/1McxEEbpuEZkAEbTcEUUmEYQsQYQoEHWIAGzGJiHKoED8tHfK115GlMpwgyCirt5FRKJmNK5FQyroRKPiNPwTNPJ9ZPYRHbOkOiJMoWxcAKprIKmkAMsgBRja5Ze7EX65MNmgcM40DJWJYDNZBl5WAMyHDxVoNVH6FTYSMVXOEWegEYiGEqiKEugcEULuERGsFoMO4vv2sk9IxCOyIkXoUwTakPZEskOAIfVQW81kkMbc2TeIAG8FUHHEVociAM4oAPDNMRLKETYOMZR2EUTuEUbEEXbEE2fMET9oAORk6swKDRMCTlMuQ0PQ4SJjIQJgET1GEbFpcasGEamgEakP+hF3ZhF34hW+4kGBrhOUAgFRvKoQwDoBaj/aYIinDSC7juTSUDCepUdalEYRf2Ta/EMirWT2W3Yq8kUD2pAj1pCXTxAjnwFn13AzUQDcgADVgWeZOXaHTRk5o3B3Qg1rztD/IgUxnMP2+LFXpWGKZCKnShFC5BEhKhDxgTVgPEK8/gGDNwRpqXDMCQCymFk2KKWsvPkuQ3yZYVbTvmmighp/4oZFChFWThFWRBgPEQD+3Wbg+YW2QDDz1hDgQB+I7gCNzgDfzQE/AWSO8ADN5ArAyXg7hhw5wBGYKWGIRBGKqCKQwHT3xmOcygc89AC/zlX3AtLRwmOnMS2dTOMlT/1zKmhAjgVEqmhHWF2AhIK9tml3axLdtotwqAIOmal3ebt3ehmIqHt33bt2WTl1pbZlmTzvCCgAZooPDmR2U3iXofQRKibK5YoRY6ShiOIRhkoRMeIUW/aw5ylAZWYDlAYAVqAAhwQDn8pDqw42eSbn66g3oRwabQmBLILRTgdhRIQRVaARZowRZqIYEvmRZ0y0u9FBdqgRYw+YBt4YBLGQ9fIRYwAUbt4Au+AAY8YAiGgNHcIBDwcNE0uG2AwuMC4RqCUxh64YRP5vKe4lps4RQkoXnEAAgU1f/4JQ0GxnbWtC2A54a3xDGsZHUvg4gdtnUXtoeRgLSmRGTrCD6J/8yOzECizoDIeDQqlcAy8JUGbGAHbIAGeuA5WOBnWMBRVOA5AhmfCYWfQYCfk2Ogf6ZndICRxJgGZmCh9zmgA5mPw5ige0ZSqBURcJbzPs8UdBARgoA6IKABDuBmGmABGiADDsAATBoEGsA54OekLhpno6wHSyEVWqGmYQGncVoWYKEVeroVXAGoXWEWXIEVUsEUSsEUWMEV4JWpXeEugaEWZCEWVuGRQ4ETdOqE2LBvIEELfqBtwGAKivQNpmBCIKENAgETxOpY4IZIcTkQ8BIXRip73O1ObAEVNCGnMkEPHlCiGND/tMBeAqN0T2eKoC3+QEtLUPdNFzabv7mxLf/DiIfYCAK1r7sSUYtsnYEACErLMsJkB3bAjYiACnBAR3WgB4CAB3SA3hCFB3oAbHEAB8JYtmGbtmcAtotLth16kDPAOl4GAhzAt33bZnwbO2ZgOxChUz9Bkx4lOQZZBeQAEfigTFSjY/4oklEhFViBknF6FmBhFr4bqMFbqIkaXoHaFIK6qYNavSmXF3jhZ4lhVG9hFr40GBSBDMLAqubADrSgBYrgC4YABn5ACGIgmcAACsAAEOBgChAcE9rgBzruDcB6wQ8cDCr8DjpKRAznToxBF6jaEvjQEjAhEthAnTU7tLgABEFXYOxp/kJLCtZiSwob7RbbdRmbh4W4neT/ObKbYAKpYAl+nAx+PAIp0OiIrAqA1wo0MAPZ4qHQoKGc4D5HwwuMYAdEIwt0wAd6wAdqgMt9gAZqAAeauApwewVYYAWUowOC+2Vu5gDaHKUNAM7jHM4b4AOyQ8w89cxAYaZLoRRQAacpGZPp9pJzgaNyIRe+G99uQb7FW70bXb0VfRfam1RNlS4RdBmWARqkQRqs4TevQRp+ORdgAZUn4csluA204A3eQAZiIINkQAbgABB+5Q2KZfmmABLcYAo4WIOh4A0O/A4WvG1+wRigQhmUQhdeobpWCNFerg7YIAvWYAdAY4pQPIYv63Vcp9pwkhNN12GAjKBct6C6jsYh/3uIp+THJfDHqcAKlkDdfXx0eJRHKTUCNRDJuFZfGWoNtEAqbaAGqjxMoAOf75mflYPgCWU5OuADMiDNh5u3E74DQIBs56ffeOgPHJkUUqGmvxsXcsFnKZfjc6EWwPsWdmHRFX2ov1u+I33kIz3S21vSJx1oKx1BW2QZOB0bbp7TrcHVrnScpCEaNswapAE4icEUDF2AI2EFTOAHHBwKYiAGhOAJnkAGml4I/FYIICSWcwITMmQK3OBXvBpujMltNBis4/IX5HgTRiHlAAcQUZMQOjEzxEQBuzIYtaDFnMRIUKuaqzmySrEnrZP/aPyHGdYImqAJRkfdl4DeWtvHW//btW2A3nrAx/9YtekNB3IgtfMYOl6KBfa4UF7m4HcGfUAgAxzAZupcn583COSghzpmUy8FFOIWlWsBk73UckmK43vBZ332Fgxd93//9ymX5G+BF4jf5d2bF2BeaCu9GZzhGabBGm6eG0QNr6qfG3g+6KOfG0gNHcphG24e6K2BGsYf+jVdGopBqH+BlB2hBl5gA2IADELoDoZABtwmBoYAJyp8CIoACn6pDdwAINqw+QIFDpg3gABNeQMJDpw3U8AAuhPs1aZMmShF2oiJUyRIgQAFYuSGjRYpSpT0yGLGzJmXWrRs6UKzy5abN2vS9MKTDRueQIGm5NklSpKbUaL/bEnKNKfSpUyjEEmCxEgUJESa2GDBwkYPHmBtiGWhQgVZEGS70sDB4kOGD3DhqoDQIEODBgfu0m0AIe6HHGHixMnTSJKkS5c0jVr16lUsXb5+BQtmrDJlY5ONDdvMmbMwYMJCCyM2ehcv07xCE+NFrJhrZLCTLWsmzZq1bNiycZvHm3c9e/uACw9OHHhwe/XmccNmexo9e8b31UuHDhu36+XKbcPGXBqyXa5m2Yq1iEYRESlCDEEB5Y6MFEJiDInxg74bNw5NBLqvpY0dN2CAMYVId7xxByBvJAgGFGBkYskkEEbyoCUezVEHIZEEEsgRWlSRRRVVACFGSy6dEZMX/zrhpCJOXqzxU1AwSiEFT0sdVeOKUT1FFRI8GpHEDjYYQYQNO+yQlgogdNDBWR1k4GQGEHQAwZRT3tUAXCDMoEMQYQSBx5d5SFIJYpd0Egoqr8hSiy6/6MKmZL/EGcwvwwTTWWfC3EnMMMT06adrfRYDGzLLzIZMM85EY01u2PQ2Tz2/IQfppL9FCt0+mO7zj6acbuqppv9sag89112HzTbx9BNqP5jSo86r9MSaDqncLNPLLbnAsookQNzwwwsYTCDEDzCYMMKvPwwBhRBTyDDEHXBAEQMU++EHIBQLgQEJJBAl6JBBYESICSaMTLJRJHv4UcdGddDhRBlZxKtDFf8kkmiiF1ykoS8X/HaRBlJBaeGFwD8JPPAaMWWhRBpY5NsFFklgIbHETVRlRBMVEwHkWGeV1QEIIEDpF1x9fQCCWTPwEMYScuiBiGGUZBLKKae8YostutgSWZyYyTnZz6Ll+RkwoBUtWi+gBe1na4POBs0001izm6O+PQrd1VgDp+o/qmbq9aehhi322GOryqo96liHDTXo7LN1qMFROik980xDzC645GKLR0oUsQEFFWwwxQ9HtNBCJHe8cMezU9xx4IIJtRcLJgHCkVBEbxxUIEJ3HITJJJx87oknk4xubumYHEJDDSusYLjhXM0wAw20c0WDDTRwZQMPLOTeO+3/rK/A1fBnEc8CyMgn+fGTHXxAV5VW6kVlX1nmwMMYc/CByCOUXILRJqCEQsopjKV588256JLL+rnkncss8Md/Cy7xz3LL/fjfYv8tqPGS2p9NawaiojENanDnOvOgRz3igQ+vOXAf8sCHPLzWj7etqoIVJBvXNojBDnrQgmLrBz7YoY1omPCE5lBVPNaxjnRsIzvUMGA0eIMMYOTiF7awxBzu0IYTyAcFQsAPIwKxrUkEwheTaEOAGgIHGFCrcZ7AxBvccAc3QMQhB0HQtgLxkM+NC3WM+GIkzHUIP9TgjDW4wQ1eUIPcyW51NJhB7GYXRzkab3VcEZ7wbMcVJJXl/2RlQVLyToaDHABGMHHAwx8awT3EaEITZiIFKhgji1jQgha1sEUtLsnJWciifvXD3/70dwtXhCd/u0glL3oxmj4NChmyccYzoLaoA3IDHelIRzvaITdIXQ2C8uigBjX4wWIa85gfHGYF4yEOakTDGYmKhjjk8Y983CMf5nAhNbaxDQPOYxmfweEmquCBITxkCEIYwhSgAAlPcHFDdfCEMSBRhM6BwSDrhMIX2tCGKUwBDhpqyD0PBNBAOA4O40ro5ybBiEgs1Fxn2JIOdOCDilYBLGCZqA54QLu1GBIHspPd8MwyvJDiAAdg4VIi80AYRkqie5mAZPgkiSZZ2FQWmv/UZK4wWYtc1GJ+9vspLnBxv/qZMjyuwF9S7+e/pqqGaYRC1CyhZsByoAMd6tilVnnJDgbiIx5epRQ+vsqOsZoVrF4d6z7Miim1ZiofcI0r2YQ5TA3K4654vSs84HHXUMEVgyQ8YTSo8Y13cE1V7mCHOdBRDmpMgznAqJMvOqEDELhACBBZ0BCGwM87xMCJMPiCFsrVHocAAgxuMOcbGDTFKQxhW28AqEi29RANTUKhX4RQQ0d3iDJUQQxcEoNw0RCE4gZBB0AAQhB4YNwtcSkwcshDHwqRCEe8NGab6MRMJ0nJTN7Mu7UIr3h9Cj+i0o+U+btfKterylX2oqmpaaX/oGBTKFkSkICPvQ4uddmOdZjjv/89h4AHfFcJxuMd7HDHXSsY13zEg5cONKtbHxhhtmKqrhdkcIMbTExkvi0fwezHO8qhjRhWoxrfOEeIKziOrm4TG8sgRmSDcQo5qOAIMJBPDKYghDtAQVpQKEIRhvAFN9hBC3YwaEKgZaBAtCEQ/mzPHSYBCUA0BAUb+IHjtjyuKG7rc9uCRCSiSIczyCGReMiDHliaBz78ARGOoIQlLJFdM82sfLHA6c3cxGdf8Fl97Psz+9aXN7yhcpW3OM1pesFK/4EmUIOSzTKeIY2o1RKBj/KlAiNF4XO44x2gBrU83OGOveK1HyxEBzvU/xEPesSDHV1FKwNj/Q5Sx0OuGM51hDecD7FRGFRky6uw7wpqUp+DHOQYxzhKfOJvoJgcfMWgPJhJDW44IzTHMMYp/AACFOTY266FgicgQWRIfOEHbXhDIPxAxM7B4Q6w1VAgxu2Q2N4hEAcZAQMSIAIw3NtxkBjXl2+7rTF6wiOTMNMoFhOLTLppZ5nBTMR/RvGfxQkYvyCa0YDB6I7vgtFEa2VrXhObZTgDGtKojW6ywXKquZxSWYuOA5Xp4Qre9YFjpQc+6rHznjfQ5u/oNa9BvOKab8prcB3mrzeM1gE73R3fiLrUmw2OqMfQG98QR9ahjUF4VFMc22jGaooxDP9V8EEHNxABB9jzg7b/YAqQADgc2gAHkHwhEJiAVnu46IZt/fshUGgDfvyNCfocyKCOI6KGOuL3IWro3rGojMQnc6c6WeZnlamTnlqTpz+5Zr6wLBQ0lsEMlF+j5dlwedWS08uYy/xruY697A9L1051CsMflMded29qYUfbg3gNda1J/V9xGP/4Uk9+8o/P/OYf3xziyE45xGEOZZ/jHar6Kz7SAePWKCMYjcCBDzxQgQqg4AWXe0hDoPCDILcBE/Qsgj+xCIcvTBkkB6qiG6AAIPVv8SEFdR+IBweOBy1t8AV08GSx4AuXNwyi4SebUXGUNwzHUIGhtwwoJw2npxv/qtcbmPZyk/JLwyFzrHJ0F9ZhdDV7dfVAtOdBKhg2NWdzIaZ7pKZsyoZ8Whd1J9ZsybeDKBZ1zPcNVed8xgdgzIdL6sBYVsVCZdVWwUEP3QENzKAMupAHOuACEyABIQAFKNB2BREIP9Y4UEBkRfAD59Z+mpN4dlBQSwYt7fYtihcIsWVQfqduRJR376YgdHAInHAKkTEMyoAMf0IaxdALm0EnwZAnyaCBG5h683ANkKgb1oEOChQr8+BM2CANzzBL5ZBVktJAXoMPYANsG0RNZeNhsZcpFyRsIARXuveKwNdBRZdBdSWLtXYO7OBf5uBsKPaDPZh1zTcO6wBruQhg/8PoDgJGasiYWCzEQkEXD7mkVfx1VaVCifbQDtmBDt20HNPwDMuQDMNwC6JQCY2gAy2gdieQOT8gBNiiLG/HfgvBTg1xWhEBBqMTCAnoBkrmd9Dybhqij7R1T+qGhwFVW9xiEG7gA2UgB9ujCyyXDaeHDdMQDdAgDIY4DKDhgMJwDKd3G8oxD9wxieVgDusQTPgwKs7kTCbENmBVgrNnTCFkdKnYgrIoD0kHg8dENvGwV8rYjOewDuPAfL6og9WghNrBTdsAjOJgg0zpdOfwX7mYiwe2QvEQQe8ga/XwDumwDlfVDumgHWsTQ9HwDNAETQJ0lmjZDNCwlsyADOEoCv+gsAmUIAct8AIjgAH0kZdjGBFt92/a4k6QEBGN006JJ4f3ZlAQ4TiC9278OBFg0G7wFy0/5m9vt05aIAhsoAd8kAupd3rzQGLlwA3SoAwYmXFJAwzJcBuOCJLcNJJBeQ58xTXsoJIn5A1VmUEyeGrHxGu5ZjaH5Q/AyQ955YIuqGuSQilXxVhIWQ4+2Jw+qHzK94PagJTTqZTUB30sRJKg5l+Qsku5FI1XpZXfoA2NRZvPVJZpiZaFcpbPcJaFkgzJIIXKUIiuIAqacBGWwAhlQAdfgJfJ8gYxEB8RwSyshW+u1Tid0zl0cAf/sUWdY05x92RwgB8a8m7Qcm92GHf/C9IeYKBO/hYIdnAEc5AHw8ByhMIN9WAO1GAbzGAMcXJxHZeauoGip7IN1YdsptYP8rAO5ilNs1iTuVl0uRZXtyZs+VBB/tAPSaqjyPQP9/CkUAql62B863CUSMkdMRRDBVRAzSl1TAl9xgeEOfgN3jCli0Ud2bGV/bWV6GAOa9pC5pAd2lBiPXpCzpCeaYme6lkofNqn8PmnyKAMxyAM4vgJmuA9chYJdVAHdrABL4ACASofQyAS8sGOPwARQ9Ch23JPC1FkdWBQAjIfcOBO7PROXORvB5I50QJvgWkQcJCpnYMgRQAFftAIx7AofYIN9UAN5WANxJALwQAZcaIL/8HQC7sgDMggNdMAkqdiDgLWezraTIJFDSUpg8UZex10kzEIfHq1V7IWhDrYg82WpeRKDXN6rucKjN/wXyyEdVGHlClGDslobO4gr8XnDXRartSQKGYpQHqap3eKKGVplrI0sHfKp82wiX46ad74jclwDK5hQ7BQCp2gCZXQCZaQCZNwCCBgAh4AqTFQAikgA/QxHzIgA1r2Bm/HRZaTT0L2eGC4Wf4WdyDxbvunIHdAOVzkYwaVh64FUAWBqU5QCdKwG9lgDZ8ZDZm4C6WgCY8ACpHhZ7hgGsKQmsuBlM7qab83m4IVDdVwmzApezraV34lD6FGbMNXg0y5lDe4fP/i4JzNNqbJ15pWalVterfsaozN2IzU0aYCpmxk6g3eIJZda7ABi6eIArDpeaeb+K+bqLB9GrmRqwwPi5HCkAutYJ+V8AiI8CAcoQQmYAIlUAJqlwIncAIlMAIjkAIj62PS4k8yEBE75mQIaFA/ECAxoHdbBCBDUAQDBRJyCAnYAgfrVLwLkakx8AKEwwclOg8PiQ3lkInHoAmIgAiZsBhxQlQfJwzLsBw1Kg7HVmqAdUJk6QzfAEHFBDekWE0HliljhVYO9g7NB7c76A3Nab/OKbiCGw78Cw7j0L/eAA6CC4RZF3Vl6l9PGQ5aF33aga50aqfNAMGIi5aGO8GHi5b/j2uW5duvzSC5DuunfyobyYAMxWCRs5AKrCAKhnqoiHEKo3MKmFADHvAGKMABFcABHIABJzACJ5ACMYAeMTAtP+ACMUCyPgwHp0BPXyCZA1q8Q6BlnUN3F6pucJAs2BIRVbZaY5g5GqABJqAFf1AKzACRD8kNkKgMmVAIhaAIlOAIq+ALa4ILjEYMz4AbrbkOWltB+4AOdvpM4oC+GuS+VskO5wCu9HvIUod107cN03mUWBem38C//ItsyCZglHxs5JBNfZsd3USuhXvBE0zBiSuwdypLAkvKCUuWj1u+7bmnHvzK7xnCI0zCJfwZjLYLpWQKorDLpQCXoRAKnRDM/7EwzJ7gBB7gASaAARggAkKAujHAASUQAzvMwz7kAup0uicACY8ZCEXQd+hEH+yILT42q9SCb3WHbz50EJkFfwWyIB16A1/QoX4wCasQDMzAiKMZDL6ACYRACIqQCZxgCbEAJ8PgGslwetygDjwXYnAzKrGCDvXwa+5bD/TQDujAlavGDlclfRyNx045r5RMDvxba4TsX1KJYMN4le/QjFd5YOuw0v8lp+TZyVADNSdU0zeNXzZtDTVd047lWD0d1DVdac3R00WdcmuZgdOQctKQgUyd1GypDJRbgWTHcbgMP6ZkCrqs1bq8y6JQCmBdCquACqrwCquwCqqwCsTMBv8eiwIegAGqKwInAC0hKwIxAB8AKrJQ8AbxIRGJc6kM8Y5aFngOcYB7jX8ABQnrqM4MUo+Z8wL+9ANJFiA5ywmhEAzK8AvHEAyqsHCMcAcY4gmnQAmb4AuRYSeCsgzSgA2MxQ7CtA+ykkskubcslEvJycm3zdF9i6YXza7DmNK5SGqh5g57e5W+dI1fiZRda6dlWb4RPJay9LhMzdQmNJFCfd3YbRvazdNLPd3TbQ3e3dRQzQzkzQzwiQwQGxrAkEqllNVc3dW7DApe7dVhXd9hndaqUAqtgCanEAuesAcuELpFAAMwIALRHKlBPLpC8G5P4MPSnAKNkyDTsloBqmX/UxADbcBDB4iPBbI5DuHExPvEk/lj8Pd2AuJvt5UJtvALsqALsnAKDsIIdiAIk6CxjuAgpyAnBQ0bzpCU4sBXfGW2/nV8xnYOXwp9AIbkzciuMD3bLBQP0DEp7VDRkFLRXkkdnixYzn2W/2q4h9u4AwvmGxzdq7yWSI3Ua9nTTN3d4e3dUD168FmBg2rLuHxUrsAKXC0K7z3f8x3W8T3fpEAKX23fpUDWY70KoVAKp7BwkeADa/QCHvADpIsCKFAC0XK6MVABGECyTwAIMtDDPpS8PxDiL5ACcMCOT+wCLxADACmZ/mYQBZIsP5AQzAIGMRAg6iYt9bF3kHBblo1T/8YQC5IQCXYwLhuxB4dgCYUgCb+gGRAriMgQDeYAbUDuDkupdd4ArkCY5BfNWN9JHbsN7ratnNuxNgXE3ASryhm8yqtcwajcp4hbys3N7m9e71CN5klN3g77sBBbwhxnrFd951qdCqlgCgRP8Hhe8ApP8Frdy4Nu314t32BNCqEgCoE+8aQA1qiw8WMd6AvHCXMAIT9QBJDwAhcgAnAQAzU8LfMxBSPAzOmRTrn7xMk7hk9cH20XxC5wASegZWDYdqoK65lVEDwbEXcwOINzTkKAIETECQfnwlHEUG3ACIxAB2EUCVRvCaHwChTY74dSDboHDzqKjLmYHVNahHjbt/8brR0NzE35utxeXsqk7LjPAA11X/dvvu6Nm8pkWSh1f3J/v4mj18GqDPgN26f6zqchDBvFQBoW+V51flSsIPCTL/l4PvCpoAoEX+hgffAEjwqFzgqs4PmgD/qlEOioLz7iMwqo3/o0hSaoQAqqEAqjsG0d4AI3wE8xoAGajvOn6wLYLAKrW8QPDgWxCwWrvlk7hrLxUR8vMCwjD1A+lofvdk8Lkk8KMYYd+sTavFkXOhJj9DnEzk8FdUSx8H6ncAhhwAe0QN7XUGnTUA72kA+ZUg/tkIRsv9Fun+XQfbCz4Z4A0UygwGUFBwp0lvAgQmfPoEF7FrHgw4gRH0KsWFH/4EWOFx1CW+axYMFkJZEhO1asGDFhwID12rXr1i1XNW3eNJUzJytWOnWmMlWqlCiiooQeRZr0KKqjpJw+HRVKKqlQo6xafZr16CtVqk6N4lSlhgYPHmK8GDHkxAYOG1CMcBHjBAYOJ0ZsGFEiRYoYJYRMAQMHMJg3Q2LEkHEYzA8hUIrA8XQHzJApU4a8gRMDCuA3U6B8rix5SJE2n/9CwoTJUyw/bNp8gZJiyqQ7qScFKhKIUZkgOfgMu3ZNmjXi2IxTS6hw4chkJ5c1b34SWbKR1a0XdLZwYcSBz7RfLygRvEWQJJmbRKZSPTH2woT14iXz5nxXs+i78pnTaKpU/0qbipIqQAFDEcWpokQBBRRSRlnwKgetCvBBBqnKihShUHnlK0/MyOABE9ri4IINfjhriglGeOMFu16IIYUSXjzhsMMMgwKSQN4A444p3uhMhh+GYJE0N1KEIhAofshxsh/egAKMysCA5A44AjGyjSJ+aGOIOzzxBBIvjzgChhhIBAQTRjgJBDA4wIDBhz4q0eSWY5JZiZj1WGIvT/bUU+mkYqQDdLrzSgJvGe0IKjTRQpkhCTo/VWKppV7gk+mWmHbhpZeXJqV0JvtmAdW++1zpyRSeTuWPP6GMGqooUgBMMFZZZ511QFtvlQqrUJxKCsNRTuHkkDMsuGACESqoYP8DEVhEIQYwXDjhBRdIjLEvDlIgMYY3oo3hjkBe+DEQQCABw0cWT/gBjiJszKw0QADB8Uhv4cAMkzvugOQHSDx5o4028MUEEjjugOINgeFAGJBA7sAMEkCmuKOOPTh5RZZfhnFPmD355NNO6fo8KbrpSiKZUOsemgjljzp6SBqXX2YZGkZJPimlYjB2adJLK52pZ58r3cUlYDJ+79JbZsHF56Nn8TTUT2uZBZZWYKFa6lZObSVrVvhDRRVUvgYbbKFSTeqUCkkxGyuorspKFVlUWYWrV1A5JZZT/KjBtQ0ewKCCvk84gQK8hlBrhMNeWDbGxJiEQTIWj4xhiM/g8PL/h3TduOGLG3ILpMs2mNwMjM12XBiMJKH4nMfXqFxzSDfcWFgyyew4JN6CwdCCkV8tHubmYexUz2aO/6wZpUBLhg55ZZJRZpnlmYG+OpkZjf45ko+xmSWhYeK5Z6dBVbrnpH++lFOiXzIaaaXBb7rpqKuW2upTt+aJ67Dv/5rspCo8pX+211abU2RRiq55jW4Z8oMYatCCHyCrLRUQwgg08Ba3oOUF4IqBC0bwgim0KF2K+QEU0JLBIZBrMTXChBu+AAd9nQISbsBEICy3I8o4KRCCWdORpmCvL/jrX18AopVK87rPuAEOdsBEG0SXghcUQQuW2N0vLka0jalkGL0b/x72tLjFLSKvZMoAY8m0aMUr5ox7McFFGtMovqWx7xa0UNr4fLbGmaQxF3fERS4mJTScoa9nuRgf1NxYx6SBimqyoNrUpMYKrfGnfvYj4IVShYr+IIVVpbAQUs7WoLMREBUN+tUo9qCCFrhAAxfAwF0wIAIwNOsHL0AB4EZgOIfZ5QcyEAIcTjCEH0FBLiySiwsE5qwmoakIpLERJBhRhC/coQgx8MyPKFOwzxSGS3T4wRfWxYjXlGaFRXCMllTYhjr8CwYiKJIgODEKVMhCFxcDxhXlOU96roRPXMRnSug5jO3tTI7uayP4ZkELWqgxjQStRUJrQYtaGPRocXRoHf/vOFE9Ci2e2kOfHQGJC4XWIo4zEeRArZZIRl4tVVvjmlK+5h9N8sqlvMIkJyv0NbRF5RSdGGUNbmACD1DgAoCQgd9EIAIh9GUEUDhBW0aArgyeAAq8JBEMUAADSAwhLpbTYGFIZLkfwO4OblhXl4pAsM/wknCH+RG4AgEJbW4OX3f4Alt3JIQfCSFgzVyrGzwDBTf4QRK/WoU74WlRof0iGIcVWktaQliX4HGNs0Bk1bIm2axNVhaXlQUtZFELWUAWspvtqEIRmtBcdNSgScPFLtK4MzTm8Y6csqgwruiexG4KJhvlaGi/NwuoLXJqWkNVqlIhNqU4ZUILQq6FXrX/K6owt0IScsoqTlGVqnBCDivwgAl+4IELHGYKMNBAskqwVBGgYAh0KUG0XPAWDMQABc0SUwm6ZVUVQWxM0ATED2BgORYWoXE2EpPkfhRCXp5FMzHg3A3oAIeAeQsTReClEIYgOspBIhKMKKeN3hAIP1iif6+gxTulSFgp6sLEjnWfIYEb3EcK96Q8mSxlp5ZZ+HUWFrQY6EBFm1keMy18t6CjpdD4WsLOMyW76IXGIkXbl+CRtAptI0ijVlmSpqJ+qhiuJ1lqXOMKqEBEYW6AnCJm6KLNf57gxBwy0AITtCEGdTlBIFY5hAp44FgceIsIMPDeC5wABa90ARzeC9Vm//ESCjoSDDQbAwd/wY6tgYBBwX5QBNFp6wd3+AEKMCMZFjbumFQqkrc80xgkSS4QsfBEIOwAu4BxAhN1yMTcbmyLEuM2jQmlhWRh3Iqu9NqAYOu1i4Ut7PnxhFTzI1VNQlWf+hjyex0NVRwvhYs9xrOMV7xZMY6RZOCdb1OOBaT3QHXr98UvkVgeLtjMJpRMYrIp7K5QgZb7FC+DokASsukouMQJNkAgAx5wgQg2ALgNXEAEJviC5UTAFwxgQJYleIsGzsKBH+AZR2wqgVXhEAswRM4FQjBdjZ6KsCHIUHI4EpgMjrSmtXYOE0uCwn7Hmq8mVQYKQigqLofA4Du04f8IdbhXbVR9iFjYwsRS/EVpQ4vZy16Nkap4xSqypoqpw60Vq3BkcIc9bJQCxcpfp9+oQEUfqHU2VA3V6ESrPbSMYawYLlHGnNLjHpZoilNovEUu2DgTQE6ZaoyscroN2FKYapIoTykQJomyqgMRBRQRugqX0DyJLDjA8he4QAUuQAEJZN4tbuDSYQQ+yzhP4b2vhIJ5DTMjy7jgBQWbloEjBwPCGenPKoxBaQAzhBQsBpm5iYxjKPfKwNzr5jvyEWgm89Q2MMIPXzViwp3AiFj4wrDGMIaJta8LX+gC14iM7GVfMX7yS9ZqM8YsLF7Rileov2KyaD/8DplrzXq2sz//xrGPw+dRj67RtRRNI065O515iWNghmQghviIj5lotvkwtlLJD58QBVV5lcZzvAT5BAzMwFj5hA7sQHujFXsThZowBfxghVlIBVqwhViIBUUwgzO4gRg0gRbAPA0YATsTOGRpOLZorzcogYGji7m4A/eKgfIagUwbOLvggAzKi/KSEdo7iyFolimwnEDAhDeAAXBqA3UZAiAak0trAywJoc6AASc5tHyZAlLbEYZZjCEQgjZwNW3CEcuBghtQBF/whWAwhl/QhVx4J12whUC0hYUiqMtyP/IrPxlTJPlbxBqTv0OCBUSiP7N7qP7DBTiCozk6LYOaqD4EJD1irZjQ/xS4YwZoQAZeiI/u8ZnvmY8IlMADEUEN9MBZpMUOLIqcqAkk05hiWAaHYAaXOQZgOCxf4AMQ6IALsICBewEN2IAKuAuqaqCh2oANOLQTkAAZgIMRoAu/4YAREIERQIESWKUiRAGH06DDiBGBS8Mb6ioq4b0UOAEmmTR9SaLcsBEUAJcvoEIv+UJowjQwACdq2jlIGKswlCbIwAQkEhjKgIEv8AHdOSxjuCPSygVBxDXNMkRDND/MWr9HrKyPLKlGpJqoIUlY2K1QAS2oWRpNbC2DUq1deC1RFECdQTJNUQaXgYa3e4lb6IUfW8Wxg0BXtMBPEIVatEVcdIVb4IVdFP8UaJCGabAG48AGbpiHeqiHeeCGbICGBAyGX3AEFcAuDZAAcPyzF+CAVTIvFikBESgBCeCAs+QAEYiBVGo4ogIcJVwlPRuBxPiBpQrCpUKBDaCc/UIzujKMH9iAFnBIFqSDL8CESfgCcHmBLyg5SHgDF3gDTIucIimCzSmNGTEicBKMKViruLJMcREdJ8oCORiFPGQoW+hEQLxIjMwszZIspiO/RcwaV9Aap6OyRjzJk7ws3kqohwIy8XHJUNyZmZwUngwa9RgGVwAGLbI7nekFUNyFQWLAUbkPTOGFofEYQ2mGh4BK4sgGqZTKclBPdCiHbSgHdNiHeKgHdYiGUxT/hmDIBBpQgRsQS2WZRg04FnDUs0zDgA1ouAo4y2QRAcA50FSqixjwTxGYArYgOLlYwhR4yxEAA0AAkilZjBBCmBvQghfABF8IhC9YNUbwLsDokikgjSlwgbFygx+gA7YiFzigDEaAgy9gBDv4KjhwA8mhl3G5F9Kggz2Yg0moPkHcPqVjKELUSPhBxFeIhah7xPOLsd+SP8wiKKfhrJQcn01ELTWSSeWMCT2qNpjQlGMQhk/QBFP4hKP4BWDIhZqkyZ1RQFTUUyUDFIGIBmrYBnWgh0G1ykK1Snyoh3igB3Zg1HVgVHaIh3jAB3xYB3Moh3VIh3Vw1H3Yh3Yoh2co/whl0IUzWIEs+IIRkAC3fMsS8AAM0C4924AJ2DO/odWBe8tmpAtqPIHy8qUSoLhdTQwtAYSF29XxapbGkAwYAJciQKIvgIEj+IJAmAQ6sAM7YAT9IhHA+IwfiL0iUCE6QLXcoJwJeyEY8oNAcANnurQcAYQKy6A7gEw3OIRRMLoQ0wVcuNfcCq2FiiyqQUTxiz/4+cjJmqz2C9hDCk7ipCOHUi0xxU7W6oU8Yk41DUZciKekszJXQLKaZLs8kQ7sGA6qnIeRHdl62Id/ONmURdmVVdl+cNmXhdmY3Qd2KAdt0AZqoIZo+NNoyI7mKIZWyIQ9WAGekoCGi0sOkEIMOP+RoUIRA8XQCcALDoBaA224husLDIClEBITWXoByYiBpZILvcCAdFFWDNqvG/CBzKGDG2gDLrHCSZCBYAUMTGChSdOmrvIEY+CENnADwiCMgpkSaXWDmNs5lPOWmIOBf4ECzZGDTghE7wsx3OqoQPxS8otSRQTJVrAyRgI8+EnYUGEoMQ1FIEs7mDTdOkUyNGXOmBgGmYgnl3AFXiCG6WgGZ4iGaaAGbBBUkiVZQ7WH3+XU4N0Hexje4iXe4x3e31Vee6iHdkgHdECHbbDZm83Z252GaYgGh3CIgjgGXRCFSnCE3dAAZpwABuCAEtCgtdCzVcIAKPhGpJqA8xWBtpj/37dsOIKbDCcRAoIZgRRwGPnKr6VyEWiq23EJmCxEgRtwgzpQSFW7F77QFhbCjGO6gdIMBF9gjSLAkTewF3/5Ajc4BU9Yoc3onIWpkVcCl0MDyDMwA0soOlpzrVtTKB7jyPdLJIKtrGJzOqz5SFhott3ylPBZrdEVMjP1zkxJMqZ0DmQoiPRYiemwBm7ghnoAXuFN3kJdXuQVXkMtVHqwSnpQhzBmz6mUYm5AT2woDqkkjuudho5QhmGAhU94hEbwgzmgg1N6gApggFQCHBFApfYSuFRiiwWN36QqAUwABL3Qs8NAAS/RxhPw3whSmK6VEiGYiyUyjCFQGEjwBTgQ/6HJdAMkCsNo1YLEiAG6IhHCmbQioAPS6LlAyJK1kpIOKoJJ6BIjKg1bDmVp5aYl2RHT+QI22INJsIU8RLo51ZR36j7uMzFfsIWwqaRKYimhyIlU8bViUzZRoY+xS8of09Ol9FhBqV3cxYZtQAdB9eIvrgd6QAdCrWKYRdnkzeJ5pmLnhd6szIbzVOPiII6oNI41ZmPieJmBvl6OcJ5kAIZZKIVLoAQ+CN89qIEL0ACfmqUL8IANoIAH8EaprYBjYQtnIYwR4IAhrAsZuINu5IAXAIQXwID0ClsUWK9maRbAoRe+SIHC2CBPgAMJ2IASYBEYUNbvshxUpsMBG5NjUv8hETUSJCEMKnQMb7HCF2oDOriDI9ACO+AwOuArzwAEwmgDPziDSChmPjwxPbojExvEhArEuJGak2KpxqPmo/CJnuDObo6JPd0T56jd283dc05nd96HmBVslxXeSZUHeXgHdziHcTCHbXDsx5Ze6sXZyZ7s6+3ny/bna8DsbLhszZYGzRbogcbJhzjAYJwFANmERpAESlAERsiC8TU47uIuEbnBB4rLoaqLK0yBaawAFIAzIaCLcjzawkgWP3Mv+WJLZykqdDwLaYmLCZCqqdovoN4vxviLatqMN/gR0ujMY0q4gvGMyrAcI40Sb7ESqz6CG4iEBXMDzdhQJwGDqcb/hFdwZticqFrIhYEarczqmlWAm/XTXOFCKcYjClf0iZqwlExRsj8xFNu9XuOQ4nnw4knl1MGG2cKO1HhgVHMQB3P4BsqmbJ3FWTZmYxAHcRLP3n+2BhJncRYX7eEY6IvASeiJu7fDBVYQhU7oBEuwhFAAljKYwbvUABO4gBGgwgfYjGMpUGfci6SaSzyTWvkV0AqAgVVi0EybpTeDZCOPoBJyr2ZZVrlkZBQwnQ4iHMJREsNojENzjFXenB8QF2ehFx7Bki/oDCGCajqQ1jYQGNHREtMhjDpgA0eom1i4LNEqxEMCv0dkBZtASvwowflQSnAmnvB4yjTGBvVcT3Ro/4d3yPBHxYd3WAd3cId3eAd4OIdwGIdxEIdVH4dv+AZtqAZqmPUPn/XJ/lMTJ3FpyIhn0Nlf11nb1dnrdZlezwhih5mWkYbpgZ7rSQn2yCgc64nhcgpQsApP0Dc/YDMLALhAKItT8hJkORZnjFUMkAFAmEa2ZC+K4wC/OTS3yEtfSiVvvB0oUDkZeANSW70QgjAyzxfBkDAYoBz4dsOimrANw7S1+oyCWZhFawN0/eDSefhJeEwjYbQeKg1qCrmeg8NJ4IRTWMHx06zx26zaVCSnsZSZwOvZZeJnGI5sMON0oId5Dt7ftcp2cN5MddR3gPVq6PlqqIZgB/bqBfZfx/91EM91amhxYG/x6y367G0Ii6gIZ1h2ijgPJ14J2pIJ+4DAC/zAEAQbqegETvCEU5iEFRhfCjCcITwlG7wAINlBHfSbq9Uzv2npukABERiY/l2LGKBbq42BPtOXQFivH9iRGBATSPsCrZ40I6kqxF81OxCdJzHDJvESI7ohiCGMzrj4L/CDZrqXIYChKPFk2OHbY+o5EwIMkNswO0CDM2HBQMRgFoyFuMms1xKGYqAOaIB53vV93ydeK67wDM/wEM/1pw/2ivj1jIiGp2Rjvsbd6Ff6pmdj56f+6p/6ZiCJR6Et7qEJEjSFothAo/wEHddxDzT/WHEu6gILDOOpuMD/AIuOkbIoOD/Ly77pm/jlxr45X5H2kW8ECBQxUpz4geEHnBMiUJw4seHEnTsiXmy44wnGCDqMGNn5oiXGjzYwYgxxA4NRoC9ToAwZAmbKlB9goAgZAmcKnJdgbu50A0cLpFNuoNyBNKXonZdQpryBBGhnIDBfwAwRMgXMmylt2mhx44fTqFGcOE2aFEmSJEqhfA0bVgyZtHly59abV/eu3bzzuPHty20eNm3UsA0ebO0wtsSJpzGmNs3xtGiSGVOuXFmaZWvTMF+2LE0atNDQli1LlgwZsmLFiBET1qsXr1uyXdGubeo2blG6d4MC9emT70+ahmv6TZw48E7Kl4cq/yWKFKhQoBB1MOHBxRsoFySM2DDkBQUMKCpsENGdAwcMHCpU4HACg4gJHM5viAHnhYgY+mOMSCFCfQzv5UcSCiO8gEIgMPwQiCd7+BFIgjB4AgkMRX3hBiGCvHGTS28AAscPMQgBiVFXveRSIHcU4YYddxCCUhtTDDFFIG8khQkkd2DyFBiBrHQHSzD90NKQdtBxSB1++HGIGxHRUYccjahizDGoPWMXOnsppphlkkXD2GFhaobYlmUmZo2ZW2o2DZrYiCkmZYdR9hlozzRDWmmoqdaaa7Dxsgugst1SG6GusHIoorfpZspujfbW22+RCmfccct1sslym0AnXSih8P8xQwsteDDCCehdcMIIGmyAQXcYqDeCCBX8p956GFSAwg8jVKDeBi+AEUOB85VwQgwlpHDBEJAEeAIUbxToQoGBQBKIL5x4goknk7QAiSc3wBBIJGxoYQcmk8DxxRdQ1PgCSSmC8S4U8e4ERht3wAGhGzH+IEQRNzASCxzXQsKJj3C8YeOHNmZ1cI5wRJQihG9Ia+8hkoByDMbJkPYMNM48wxhnla3ZGWYlW3YynHGGCeabcn4W2jN2koaanquxdjNrwggDTC87A8Pzz73s8prQgBot6CxJuzILoqyk8jQqpEgtSqeQUnoc1sOpsgrXqKDyyiqy0LJKLKf4AYEFLpT/KgJ6Imyw6ga71roqBuWRZ/dCFZTAgQgwyCqEEPOBJIIIDRke4hA//ICCC3AE+AKqOgZiFiOeeBKLGybc4NG4gbiBCYRtFFHEEG0ojtC7gNh71Ew4fXFHIHQMJSNCd7ThRiR31FEUJChhcoeHkBwMRkTE5xjIELDDnmJEdwCyZCi/uFVMlaYhYxqeeHIsGp3dv0znZiOzGeZnh70M8zN4nkazajbr/L7OP8sPjM6s7fk+/fL3wrPQveSCCwABKKhbJG0WsIBFK1rBClWkwmuleOADpSadRwXHUssBxXKihgpVkEIVqDiFLGRhi1McogMWUFXbzJOCuLVnAxwowapU/+WqYBEOPsBKz1FMcKsYwMdAqHJBiH4VIrWpjVgl6I8Q+PMCF9zgBkdwgRsgUYQX+MAOR4gEHVQUCDu04QtF+MHoSCe8QACCKS+BwxCgcK+ibMQTbmjJEL7whi9wiw6BiEUg2pCim3hoYTAxUVNyRCLYCS8i9yKEIkKRi7a0hXoYoxkkTSNJSYomNN/7XiWZwYzSrK99OYMf/OYnSvqFEn/CGIb93vLJUQatF7oIYABvQYtZ0EIWB7xlAlWhilbocmse9FrUSiG1YXaqmI/q1ChI8YpTMHMUoTjFK0boBxVkwAMauAB8XsCeEqCgBK5ij9tmGDcOjFMEMXGbQFAwBP/CUeRWC4kBu4TwgjfEAAoNWZyBIFeqeoboBy8YHa5OgCsYTAISbkCJG2JwBze4wYvxoiMmwNCw1b3rXnDgVhv8gBQYJO4HdogFHif3RTdkBQrvstFLsvMGiTpFWpC4F4QCAQc7BMIPjjgFLYDRllNSz5EYeyRqqnQ969Hsp3vik86IptSlvoaVpARl/EgpylPqFJWqSQ0xVhO//envNa/MRS3CWota1vKWtjxgAnOpy1UwEJgfZCYpwiLXYtI1FGE5xSjwOorLjYIRIACBBS5gnlUJwW0b+AEUYLgrWG1AAygwwQjIKSsRQAEFdUPBFFhVnlXNBwWMI1YMNuACFcL/agTPGtaAQDIFkkBORC5I3EGLQMcpCCFGK83JStMVOp946A44Wai0vIgtKAzJpDkBnsISt5N4MeV3WCEeIHZ0L9Utj3kQ8sMkoKmLqgYjGI10C3j5xLNADbCA5j1v0mQTwKENLRdNnV9UfwbVp8Jveu1zJDJao9VhjFIX/vVvAMNKiwGXFYG8hBrUHAjBB+omLBIMxTBJoZtQ6CaunWDmWDiBrToAVlQeoBtlh1CCCgjhB3wj3BFTxSoYcFM9rpoAfDZg2RGobQQhugB+2kOQ97wwxeoEVrN+0BB4ehZX+gFDCu4QIBi04QVwRK7D3jWFIkDhQreDg8MAYaPRMRQO/zdoaOJgcBWSyKgpK83OD3BSRuDNxEbTgq51IQQ7lAgCE7GQhS5yoedc+Fc2SqMNbgId6KcdKoFNW1p6byFA9eqZaK10qnyh+r6stu8YqrE0VlfJVf75938BJLB5E/i0UT+NwY069XNQPehDpWIVp3CEIvZwBh+0wAUXsMADKECBt7FNII7rW3zqVrcNlMAE4kEBeuCDYhkPgW+jQoGTwXCgcR6Rh+bZGwZIItoKQaFwxWIXClIggySmYAgxaBwjggSFSdQoKYkjyoXo0AY6qBErTLnQF+DAEhgQtyVUUalvQTQEerYEeDL6bVawLGeXpihHy7uDJWLxCloo0GmsaP/F0wSt8Y2TutAJvKV5ET1AoxmNF0TjhcmZ+hpJI1UYOdPYMbbav9fsApa48POfCcXqVAh6N7dhRW2SNjRgZLV6y2DGZ65xDWYoQxm+yEEDINAAByyAAre2ugQkgCwUEE7fyF4PiDmAAhiM3QRw86x5xOOshaDqbUsxT2TT45C2OcQEMHCBjPUJBRkspAQikkEJZEBckBTBE1CIERRAN/CaxIB4cHBDEQq6In2/K19wwJF+vlDck2aHuEshLhiGpDCqqJFG93I4GQExLTkXJRCMyO4rKn6ojTOK9oFumikIffEE0ga9Axw5oGAj/JQrlX9TjarPlGGNZBBtF39yPnn/y1uo6dPmFkNzuSNNo0lpKL372fj+969hjWuAhhmjOUYrLsEHEEDAAQxQwAO284AJSIABDwAW4fSDnsi6zUAjMK1paUAJ7E0J/ADZwYq+TcRNxIAGTERBxAB6nICxlIAIYNNCjIoHqBCxCBRDcIBLpAAgpMA8pQQkTALpZMcduARxNcUdyBsnxMIX1AsYCAFVDAkk4JFJvYQQHEwamdSQFIW95QSO2EggrMjyoMTpQci0DBJKVE7FkEIpuIJsDM1szALwkVxs2B4r/NyhGEoXEooVCgrJ7YJ7LdWj8Y/KCYPJPV8vmN8yuMaf3MLzRZ/z8UL9vAUykAY0SMP4gZ8f//6h0onJHtbJ9ljDyyhDMgzDLLTCJlDCGZgQA0hAfoxArlnTqoxADPwH16UdeSBb2mkAZIXWQizFBsDK2AkE6ShRgQiE2EFgN8WADMiYtPwfu7wAqYwbSOhH4kACGLjADfoCHUxCG6hWjaQRGOCIG2gE6BCFvlnFVVyFwSyFjTiO41VFj5CITtyE6lyjGk0L6EjMtDjP8WwRSkCIHejBI7hC/WSVy+FMzrTGzaghAbnCbfQe9cGCeeHcFFrf0eBC8DUfzQ2N0KwhyqGc8PWCHLaGpR1DPGIfamjMMuzhNWAD+P2FX7jJZpxPzDgDaTiDR1oSNHDM9mCGmICGMgzDLf88xyZYgh6AgAc8AANcwAZcgAecgHV4wCoayGB1UyuiWKyQBwVigFOQx0SIxxC4QAb+n625yigim98FiGcVXhGMXZrxB7Pw22oJRAwUQQu0gR34QizYgRbAgAms1FK4xFXYjmzlm0/sy7zES1E0S8Md10xgBTYmnJTBC7e43sToUTjCASAEArYcAo54ziRYgiTMAtHpiTs2pjsm1SwgWtIQGGXOEi0J0M0t2hgWJGd2JsrVYUGuY1YlQzG4wicMiii4QjFIQzZcQzb0xZloBp2EZDM0gzPUZvYkA27eSW02Q8z85m0uw8tsj2gw3TEAwyyIgiZcQiZQwiH4wALU33b/XIDoXAAFyJApktOxid2I9ZCtyAqw1IisWBY3gcH/wUrdUFaBLIRALIR70NgLmEALmMALDEk3Cd5OmI6CwE6SsAEmGIMfhMo8McUdCAGQgEG+iE7pxAvgAI5JQUE48qKNRIQ08k5U3NZzVRSJxM5FrZ60aNm9eMIpXA4mEMLASEIlzALK4YzOeKaLkmEupBdY0YJYBVAuCMp6CSRTuagdtmNW0YzGOANJuglFXsMb0oZrzMIuwAVoeGRvPmn2LENvRmlu5iZEas8eQoMmkUbTKUMxAEMu0EIpYJAzZYsJUMADZJ0EPMAJWJN1rsp68hDfrAc5sc2IeYCCpOd8jAAB/25igZQiCrwNPClUrhBb4WxAU5ClfBbBHUBbCqTAD0ACJkBeERyMD/iAH9BBGdCBD7gADHwBIxQBjgzcM7LEjKTUG7jETMiUikiqbJmIvFzUSsGqvWgZ7CxF7DACWELIRsSUpE4CJjACJ/iCJxACOkohZ+Yc9fVeZB6KedUCLniap/njGOoo/dgPMdCMbX5Mm/jFXMgFN2DDNmiDNiyGZixDfo1mRIJGx9zmk0IpaVyp+kwSvQ5VzbDGeBHQFkZQdHRKJzzTKXCCD2QATCaAAujaBZzKNe1NdxwW3LBH3eCHq8jiC0gWBlAgB8ATethTKSqOk40Av8UAIAiBZxljIP8cwRe8wA0wiOjkCgqAwbUwAh14QhFowRFkQRY4gQ/cQMuWjuL1iKpeVF3KiJSRCB1AwusEAhT4BBmBiBoprYzI2Zm9i5SlyH9iAk3FlNYGQoZ4ArEGgh7wQWrKIcrVRiuglQK1QshNX3qFoY72zI9eT0Qehmu+5l98K97CJmEQBjX0rd/67ZeAySV1j7vaZnBSabwSVc0Uw84IzWwAmqLoBgV9gnJQEHOM6MBawHVKQAIwgNWBYtYFpbK1St2Ak61ggARMgLkdSKyUwBSMAKuInT2hCo302ys6jkyk6rlxy7iUYBu4QBKJgAtIy+0wwne8gCBMAiNEwhfU09K+Dhr/JdwPPAVNmMhKHB6JYALoeA5DMW1O7MRLHUzzXMXoXePWMkLzKA9/EgJ25YgfIIIoDIpBri1tAF1kVh/Z8sK1vgVEQsP41e3dfmtffB9fxKaYuEmbbMlgJIbfKobL8CFoRPD4nI+WbhInYVVUOS6hcJwpLJgoUFBvXFCm/GsnjMIZgIAGaG6sZB0DxKTaTMCuwJitpMeurEoFyIetbIAHiIff7Q0MKAvhdJPh1M0JsAvZLYQBQqh+2M4kxAIdaIEJwhNTKFRHwGVMfMG11IG0+FOStQGWqZFLAOYbIBZOrETpsEjAKO8WNZQdPB7wOA9M6Ju9SMyGmPFFMYhBvc5LuTmMpMaUINjBg8DOHjiCJiDrziBN0FkhoADDMSAd9/3ha+YtNxwwRjKGZFDDNmQyAh8wmaSJuCowNoTPcBqiNGxknhxV40bfoEyfKcweo4gCBDWQMEmNqVENBimHJmzCJmiCclyCGaiABngABUwATBJzJLZwZO1KBUSWQ9wwe6CHBGxArsFNerAuBgzBjHGAPmXsCzwALXKTgehHiDygjmhBC9wAlYWIPcVAvigO8fDs5KisHsGBEAQEACH5BABkAAAALAAAAABAAQABh+O6m9isjtamg8ykis6decacf8GbgL+XfMiPZb6Qb7qQcraQdLWKarCMcq+Ia7CHZqqGbLiCWq+EYq2DYqyDYqt/XqmCZqmAXal9XKaCZ6Z+YKV8XaZ8WKJ/ZZ5/Z6B7X6d6WKR5V6l0TKN5WKJ1UqB5WqB2WKB3VKB1U6BwSpx5YZx4XJp1XJ12VZt0VJxzUptwUptxTpptS5d1XpZzW5dzV5ZwV5dwUJJzXJJwWJJvVpRtVZJtVZVtT5ZtS5BtVZBsUpFtUI1tVZlqRpxkO5RpSpJqTpJnSJFqU5FpS5FmSpBqU5BoTpBnT5BlR49rUo9pU49qTo9nTY9mT49kSI1qVI5qUo5oU41nUo5qUI1pUI5pTY1oT41oS45lUY1kT45mTY1lRo5iQotqU4xoUotnUYtpTotnTYxmUYtlUIpmUItmTYllToplSoxjT4pkT4ljTotjSItiSopgRYthQIpePYdnUIdkTIdjS4dhSYRkToBkUYRgSH5gTIVeRoJeRoZdPYBdRXxdR4hZOIJZO39aQ39WN31ZRH1ZP31XQ31VOHpZQ3pWQXpXPXpUPndXQHdUPHJVQXxQMHVQNnJQOXFMMm1POW1LNGdNPGdJNW5GKmZGMGFFM2FDLGVAJ10/K2E5H1c/L1U7KlY5JVA5KFQ2I1E2JEw2JlEzH04zIU0yIUsyIUswHkgyI0cvH0MwIkwsF0gtG0csGUQtHUQpGEEsH0EsGkEqGkEoFz4sHj0qGz4pGT0nFzopHDonGDYnG0EiDzoiEjYkFjYgEDMjFTMfEC4hFi0dETUbCiwaDS8XCC8RAyUYDCQVCCISBiIMAhsSCBkQBhgPBRkOBBQNBRgLAhULAhILAg4LAhYIABAIABYDABAEAAwIAQwFAAwDAAsAAAcHAQQHAAgGAQUGAAMGAAgFAAYFAQMFAAcEAAUEAAMEAAIEAAcDAAQDAAMCAAIDAAECAAACAAgAAAYAAAUAAAQAAAMAAAEBAAIAAQEAAgEAAAABAgABAAAAAgAAAAj/AI84CZOkhw8FCmAUufHCSJiBTsQ4ueFDDKAiRpxE6aEoSpskTnygGDnyBYoQHFKeQDFiBIcTJ0KgeOGiRItNsIAFU7btmbJYsmTNWoVLz44iPmS8eOHDiROkPqIWgXojhtUYLlq0MOHiBYylLsK6MNHiRQySS08sfXGixYgTI8i2gNsyBEqUHEBwwIAhL9+9FSqkxAACRIgYMoJoAjUKVrBgq1SdMpUqlanLokiZIqWZMufMplSpqjyKU6ZOnz51Wj3q06hOggSNGrU52LPbt501S5asmDBhvl6dIhUKU6hkzkJFihRq3rxv3aJrm069OrZu2LBdu6ZtOzVr4MOH/582Tby1aNKoXbvezRs1Un32jBmTI4MKDxAgeMjBplCmTKYss8024IDDXTXkVaPgQD30cEQRGxSgAUhH9HBDRnSIkYQPCxXxQg9zABIEIn8EEYYPZ40UU0x2wUTSCRdwMEIIZsVQwgeIwEILLshk04wytMhCiy2u4AJJDTBYtdULUMVAEUUozlVWDD4stVVZMNxgggkjlNVUHSiaVdVcR4TxUAwnbNDSmnXZldKbf/HFVwUS9GXXXTIcMUclnsACCzLBuDIaZZZdZuihhV6WimiqmNLaaqlFmlprmXBSSimmiNLKLrW80ukroLYyHGehlGrqKaHssUcfp8xDjzfRdf9DHXfVrZfddrhe8515vIqX3naxyspNL5HYIYQQOQgxw30ZeDCDFpBYwokow2zDDTjZIKjgM848c0QS3zp1gwIHuJBEQTckEQYgdMBgwg03fNtDF0kQ4gciUXSx1khu3rnSTDLcMEJfIMCUZgYsoKITLrecwgstscQyFC6d1OCCVSdsaZBVFFn1gltqraXVli7cUMRTPtzwlQswhLnWC2+dwOELMq7JwQYc3PlmSigFhoHPPws2WM4xiCEGIZWU4qdOslTmNKGJOm2Z1E87Oukoooji2mxYi3IpKaKUygknxWFi9tloY7IcJqq2/YursEo3Xa7c4Tr3Nb3mDd400vz/Ol035mAXuDbJpGrHGIHc8YMO+HmgwhiLSMuJKs/09Ax50DjjTDR0OEHHQ+deUAAFBTVoBL2dDzRVET20cLoRivixZQsosLhXXznHNMJSLtlFAlwXaPBBJ7TotAsmpLAipC2txALLEzcolbEJHtf4scFrwbXl9ia8oGULYmllkoprnhDDET6MoKZLLvF8+50hkBDCz3oRRgIIuLtZAQYkvABIJajwE6CaRjWpKeppBUwU17q2wK5dKmucSNtyIiGIPliwgvFpGw5wIARVMcM5cZPV3ehGt/Dsihp8kwZ5rEGeFvbNb9oAHHYApw1uVOMVkYAcIwphhifooAMdUAEN//RAiU2QDRfK6JbmoMFEp5TJCUeggxEOoACHKCEMc6CDuoxghCQwpAdIacENWpDFErBpMBfYXwhWMr/cjYQEvzvBAzTQAUjkBBnIuMXDZBELW8yCFcAoBEVgpr6VrIhF/iLJTOYCEzY5EiZsaeQZUzKCC6yvd7fD3V9uNxgMoAQDF5BABS6QRg7MBBCT8FNqVBGLVayCFaORGqMqIxqqxXJQl5nNJ0TBtaw5yhSlyFrazLYcC7btmKraYAcjwQ1XaQMb1RlhCcejQham8IUtJM8L1bOe9kRnHO0IpzdqmAxOLAcSlAiEDmqwAgh0gAU/WMQlKsUJWjSDWy10Ch3Yxf8uOmhAQkroQUZ6kIQ5hKGLTviKD1oXFg0AwgUtgdOc+mLIOy0FBXqxywMskIEz5OQxu7DFjoQ0C1Mg4xI16EEM1LcBncEPfv9CgZTSQpdHqoUkEY3om0gpI4ny5QKgxF1KYrQXUhp1lKNcIxk9gYpR7MEUuHglK2BJy1RMdaqjUQUrZMkoVypQa6VY4KGIo7YJTvCYGTzmGGaAgzHsIRTgcCY059YdEuJtb9JAjwq1+UIVIohv0UCPev4WK3PYgx70qEd7sFUMc0YCEohYgw5Y0AEIqCAHZIDEJSyRCVHYhlvOIAggAOE5LrqAihdKQud6AAhDdAEGRmBZD2DQAxP/WJJD6rMkB4Aqp5y16AQvuZMnR8AAC2iABqPQSR5FiovlARIVO/hKCDagAZfCtHYGy+5c3tQSSbakdmxxySUrSUmXyEmonlyj/AqT3n6dIDB7mcAFaISIPqEiEpxYxSxc4QpWRMa/rnRlVwNMYFe6ohWRKZTWLlMK0jDYFJmgYB8EsZxFxGc+YzjcfI5VBSF4wFk4eEVc6VGru/YKhYBFTzb5mtdsBhaGMYwVYulhD3t4wxzzAEc1TrGcRyyCDyqYwQwykIEV0AAPjKAEZ016G0CYCRBiCAMdlAADChRgA/Cag5ZbOwcnAMIHICmCCSgwggmMABC75SkpMeAi7J7E/01vkdEJivuBD1wCGDqxhS34GJRYFAkYZ9jKzSjgJve9BCYtUpHBWHromsIETZNs3wVq+kk74QV+e8m0emEiv/Tm7gWKAEVOlKGMYOy3v/8NMKNUUeCr+pe/rkgwZkZRmQazIjRhHYUl4mPBXsdHCBscw7GEDWwcfJitxBjxdu5mDWo4Oz3OpoYK88pEFbM4GtAIrAvTY40ajlMb3oBVjWtcj3bUox7OAUcxMCGIRQjCDjQQYgcy8IEVsAAKbFCDHfoQiUw4JQlT8Rwg1MUABxjBEHM4+BwIkQRFRIQORThB0CowATr4wATrm69MZsKvlbRPkmkqQQ1q0Ag8DuMWe/8OSpBswaNGsKAEGHgAA04AR/ndyc0qqt0ade6vmIDXSWNRiEjUAsUVvVRnfcEd0PjSohAAlWc+R0ERNFEKYOBxGcjYxSxmEbGIHRjWsF5FK8DO37G3ohWSGRRoDnUZVsQiFYLAsB3a7e4KqsrXbbPDsffgjG8gtsTbGc+KrWFi89y1GtZQEOLBU0NufAMc34j8N8wRbrm1hx7pfgYpImEJS1yCEnzIAgsskB8IOKABDViA6jkEEjM9JAyEMIECTDAHC81BEYAgxInCcAOn748vE/ABHTYA3Pa95EUt+nh2NVACF9SAD3fEBS2mT/1Z3AIZnWCBCTBAgQegoOaKxp7/SQ45k5ik5M03p8lWTKCiEMhADDJg84NQwMlOXmACFcBfYPSSs/M6nekb5wSLkRNWNwy8sHV+5goJSHausHVld3YQeHarMBmY0RlsFzGm0Ac4IGSXVQUe+IEZlnd2oCrHhgnZwA2ItWyF52wrVh7goSDgUXjWNA2BpW0Kwh2O93jPUXnhxg3cMB0zViDbEAyZcAmNoE4d4AALcABM2IQHYAAGUCZ0UAcZIgb7RAhHwAAUYAQXsi5O0ANdgSb4tz9ANQEbEHslUAI4czMyoRYwAQJc0l3goxUcUAI3EARmMAp4hAvSR320MAu8gAywYAMY130lMT7ht2gzskaIhhIv/zA/d2EXceEWG7ABILABbBYTVPJemfRT+6NGIOAzt/N0Scczd+IEniBqVgcoRMJfAMZfBSYZonIKtFiLk0EKhZIKYXNAlXEZETMKfZADHIgDOVCMxyIExHaMyDgGH+YBoXCCriIe0bZXLhYNK6Yg06At2EgemrM5CZIt2ZANhOcNkdd43JAN1DFu83COz4ALjLADGgABS2gABQCFBXCP9WgAMsAhUbGPRUAQEKIAJWA6CnEDE0FxQBUYY0gBA7EBLiBnOfMiGYNdMFEyNwBRzRcEP3BnwNCHfDh9tWCAgFYCGtB9NAdHiiSRjIhpvrUiaHIncfECGGeJ6WVpvpVJaf80SpoUGKL0U0OFkGqUM2HAJ6iwI3hGC1PVX1NFYJJBgZNhi7XYKKtgKKUCNb1oChEjCoKgLPdBjDmwQcmCLMW4QWTZjLVQDc00DyfUV32FbZrTDMwQl80wl3Epl3UZl8lwDHLZDEuEbdAwDSc4HeGIjtNRYzlWDcogCmPAAg3AhPj4mI9pAFYBA0kSAybxFT3wAgrAABdZBAoVAxggX6A0AaQ5AaDUAoTAMjADM/+yElsyEmJhkQLTJTcABHxQPNN3CzuSm8mwC8hACR+gAaF0knFkMDNxPS2xJS2hAWpSiSPgBHXgBB/DFVuihiCgPoQBdXbBXhMXGPtTGPgjSmj/pJDyJRh3IgaSwCdKsyOx4GpXFRmrpmqRUWCrYFVZJQqhUUuLYhkRAxtVMAMe0AE0UIxhqYzHQowb9GE4gBwEMg/Z9ELoUYNMpBvOwAy8kQxweaEXegwbeqF1mQx7+ZfVEI4jSh3YEHnc8Ayt0AcQYADzSI+QCZmSOT4XNRNQogEKsAFZ0gIxUAQc8AATIAFBKgFEKkqW5GQl8xYxcxJc8pprERYMISMmAANB8ARVl5sfiQu7kAy+gAyfEJwaIAE0d3QbV1PJySXjNQJZgXFl0QJqaEYjcImEcRdsNCfeuX9qFAL6114cQHF1kmlv4gOEQAiQUAmdUJSwwEdXFTGu/9Z1jvqoQOF2XQc2S8lqCdaemdAHawVEQUYDNECWHBSWY2lsEMB3zgCNewWh2cZErJqhxUAMxPCqxPAbsPobwgCruFoMurqrr8qhfOkM2RiOMYg33MAMoSAEBzAAARCjAxCj+ahoO4cClHkDs7WZWUEjuxWkDyAB2yqkRGpJLkAIWlE+Osc9hxgWSwFUG2ACNkADlNCRt8CH0ncLWzoMwwAMNiCcYvo7MNVIGxAjbBKHyrkmA2sCabgBZrQB5IlUCWmndxqKhBE0pgmJ8zOkpOmdFIACEUEIiFBEAeQnsDBVQMFH7fmoJDuyQSF9QSELtyYKjLoKsMhKrBAJemAHKv9AZCxQA54Kqjy7QTOQH5hwGycIDhHKqkY7obrBDMfgG7/hC7rwtLqwC1HrC1RLtbZ6tcBxq3qpG38JHt9RDdugDJyAA8kaAACAjwPQrGkbo1CYXSQxpVkCLxNwABpgShzAAEDFAAzwAEAqSkIqIxpACDewrmtSO+ClSN4DL0tBAaZZAjbwfDuCC7zwkfSqDMXAI3iwARZAAY34W5JISd51ppXYpOvjAutKXT+Df3MyARQwGPjjsPnHXmSour+Hf0MqSvhHAdQDIoXQCI0ACY+ATpQwvJ1nCZSwHMRbvMrbeZjAWZiQCZz1CabAR7DWnqykCotgB3qAAx3gAfYmZGz/Fb6f6rPL8mGkwJdoCQ5Ha7TdqDkWmpfA4bS5kAu3UL+7sAu8wAu7ULVY6wu3OqvE4KtzCQ3dlg3PgAycMAMLoKxm+5hpu7ZsO342yhBRERVjdAAMAJp9SnF0wq1+S4ag5AOAUIlZ4Wi0Q5EX4zHA1RYusANBoDD5G8P6iwzFsArB8AimR2ZntDtwMRgo0D3cg7Buuq5bUYmV2AKVqIYaUJJGfIlGLCeBwbgVMLoYUIlGFSP/ulvdRwEXQAFebEk30AVzgAiIUAiFwAd5wAeF8Ad/UMaB8MZvHBuLUHcVRMfa2weHcAiPUAqygHII2HVIaWF6IATxxgIs4KmeSqBg/1mMNACgM+ALvBGsl9O+mTMNmgNaGbobswoceiTDwWCvxYAMpIZHvEFqP6IMF+qD4giY24AMmYADqeeETAiFtHyPtAyjBVCj3mMQJ/MgKuMACqCnClmk3UqkPkNKJ/BQXeIW3WVIdGEwWtHDNiFGNqAJHRkMMYzNyHByuMAJ+fEAztk+MdOI07M9P7wlzGnE6Uxd6uzFFHCnUcy4pPnO86ywUzwC7tzFXczFpMS33sq6F9ACbeAHftAIgMAHf5AHeeAHfMAHDM3QDZ3GDd3Qf8AHeGDReIAHyMgGDc0ICsMwfxwxtACMejDI8UYDLCBkA0qgxogsjewBe1AMINot1f/QvjbdvrsBohdaDFSrv9lsr6As0xo61BeqeDXtDI2FA/K4hLMsy09Iy00Io2sRt6wHZkcAPiNwAA/AAcS8rQ9AJ9t6zGkkBuljE6ALEwNbPo0EFzZxA8/Hh54ciDzdXyoAAQ9gM2+hFTJxUWbhFTVRAmQxZks82INNAZXInCWpARXgzottsbQ7hoGxEovNuBJwxfxMAUQ6z5ZkBHGgZXHQBaAd2qCdBF0QB23QBmeQ2mtwBqt9BqjNBmugBsmSBW2AZKjAh7cQ0qxAC52wBzX7A/G2AvZmyIlMoMeSAy8dCXk5l7cxl8590xWqtCCKl8cQv05rC1Nrtb9RDByq07z/cQxLC6t8+avDMLYQkHrk4tROaACzzN4wapm73CBgdCLUinEPkADcyrf+/NUdHFT3NwFSNwKArdZtEUnaBTI24QJBUAM68NH4m787UQzDcArAYAcQQGZywUgrsRRuchIsM5PobMSHvcTU5cWEPdiV2Nil6Z2Z/XsYIAFfzMU3s8/3p9/bSgEuwEUC1UWiPdpdtAWgHQVPMORPEAVBEARbAARcoAVQMKA28ATQkhMMUwtc157KYwl2YAdVgNwqINzCTdxfucgbuCyi0BvM/Qx3WZe/mrR5Od15Cd7E4L/XrQu+MAyyqquxyqHd/ebGQAx8mQyWe6yop3oIod6G7pgF/yAWXgEvFHEEMmA+P4MBCcAA+V3p2xqko0SaQjoBY8QmMAE+XvEVH7MUGLMVJcOFNbAJwNBHuyAMvLAT29wKuGAJEKABF3MEYlAE8N2PJgAXMLMBI4GmIi7iir3EgE3Yw+6dkK2Q+ccX+Y1/G5yTtlukxhzQXuQCXcCFRrDjprPtXLTtDbIDAmU6O2AESAAEKzByQPADlCAL2MwwukmysPAIZLDlOjBZK1Bn9ZbS4LtBjawCKoADtGDm3fIM053mdvnmILobey4MvsG//7ursMrd4F3xxtDnc6kMw+BU8jjohM6EhX7o9lgAZDHVBlElaHJ/FMcAk763ROrVfot/Hv9MpDpaPmXxMhZyFVcBFlnSIDYgCMAgC7awv6+OysNgC6wwCh1gAb3+AjKgFIf4wy1BSN/1AuE87MWuAWJEktRF2JPNwT7znRBbnmNI7Zm96ReLAerjpu/SAnVWMjAApRbSFbGZFWEBPjVgA3ofRDlLA5cg5boZJIwKC3rg5CsA8Cqg710OvowP8DA9DLzBDEpE1GqeoUQ91HfOtPHr8Br6vrIq3s2wDLjwCB7QmKeHerGsAIQe8k5tj81HE94TFWbxXj9TpAkw6f6M9pr+8pmN425R8jEQ9+ADLzpvmdXD6DfwA0VJC7uAzbA+DLhgCrCgAxZgfiHAfsHOfnF4M0X/DNjOOeIYy85dn+IVsMRfX5q2K/NhvQHujNnaSszeKqSjpD6DbVwaYP8o/q8nTuKDre8fkB8AkaGDik2wgMmKFYvVQlaoRtHosOJDBggZPlzEqGLGxo0qVHjwEAmZsmTKnD17pkwlyWQtm71sGZMZs2Q0YxbDGbPlsGDBhiEDihPnMKI+mSkb9inHAgMFGix4ukDqVKkKrB7AmvWAAQMmXLx4caOID7AvLkyokFbChAQFGDx4sFbCWbl10VIYcaOFi68xXrhosfeF3xcoDIOF8fWvixWegNHCFYxXMGXIhuEqBYuPBg4hToTYsGHECBMmwI6+ELpFidAaNGxwHVt2/2jartO+hl2BQtoJvSXABU7hbOwLuh9QmEDheIUJD3pT2FDitXQLGqpXt+76wgXZrmFrgO76g4MGGVTQ6DTqUydO7TO9z0SJhYoOGShCwPjB436NHT1+WoakZk5yZqWVWhKqGGEW9EWYX3rp5RdhdHmlwlYubOWUDEkRJRQPP/ywvfZIIQUTOzI4oIACHGAxKqqqskoBrbDiKjAYbjjiBsJQCAEDH5nT7QDn0EIrLd0o2K0CDC7gQLQXerghCR9i4Asw0lAoa7AYCOPrrxIKAQYYXIBCpqdgcFEFFk82YJKD0UDAsrTSTnjhhBFYo6212CqoLbbQRvvOuw102wAD5P+Qm4A7JF2zgLUSWrAuPNiOw06D0VzI8zUNpKNtBNEo0MAEDT7gtDVSL2rAAQg6yOGTSzaxJFZZKYEkEPsoskBVC3a9VaCKIFg1A5AWiaTYYgXpI1lllS0WE2efhTZaTDgBkZRTrtWwwgpzgfAXYr51pplUBFHBgQUOaLEBdV+UKisZaeSqgBZueLKIGMgKwbAQOMBASTcfSEACgYnsbbs2QehstLBu8GHKGwEDbM4TUNjxhBbKMmELVGCRJcyDEoolM1B2KGEEDjjgszTDUBjBzhPyhE20TEcbAbeYSTNBT/DgMvJH4BjYlTxVIciVARYdCNqBB6xz4LvtNkDOOeX/lGOAAausPmCAALB6N6umAhgg7AUeoSSTRyJ55BFG1mZkBQOganeqVFkEFlj7OgBJCGObdbY9D619pZYGiSnmGJleciZxxZ2ZphrHH7cm8msm16Zyyy0H5xlT+lABggYUUDVddmG8ymsD5m3YhyNeaKGzfdPCYF8OLgh4ySIL3o7fk0MYrQUTbtCRMBM83cCzlQ/j0TM7N/hgkk4+gX6UTqbfJJNPUEEEt5x3A2EwsE44obRMZSaez9AwQEuDCjRNSzm4qoY//hi9LiBs+8MOIH/99+e/fwD+/18AACBAABYwfwUsIAQo8QhLpE1tjEhEIhhRgwZYIANIy1V1PrAC/xXohz4Dmc9GMPGMZijjJQN6xuJSiJKToGQaL5xGNGA4Q8hFzobWmBzlLrdDbiAjE2NQQa4qeB/PqcuIozuXVnQ0pRgcYTQh2JePMHCyk50AYBIAEm8MVhwq0mwDfwGL70zQghEgDIrKg+Jn0ngCDmgAD5Qo2yY2AUdKFMsSqKjECqRzAU/5aDATc5PMYrMb5fzmAfGDH1zWckir1a9/BERgJCUJQP2pqAAHsIoDFGA1o2lSaXChwNF0tStSWvA+oIOAB65HiUtAAhKPWITaJMgDC9SHaNbRYH4+0IEObLA/pnCGS5ohE2YMaHGKg0Y0opFMZTZTGtO4oQ0nJ7lrVP9OhzyshisiMQYWaMBz9SGiKI/ILq2MoHWzK04F1uIbQ/5MSEaqwBYN1qQmRWdnzjkkcAa2Heb0hmDJqdoK/iCIR0DCEYUoxCGQ1YdLPIIF8/Jdy/jloxCUxpyr+VNp1Pca5gCnOXGBJ3isFqNNIrJqcAGdKEWZqwdkEC6wAZVroEMBUUVHOjmrGdSS4x1GtWZeK1gB0TKAg1KMIhOdoBUkiqU2R9DSgqTMDi956RGpqsAGOcjBMJxRzBMmbiZcNWYxiwkNspbVrMyURlrVSg21SoMab6WGNeIaubhmwxmiEMQYavCBXF0EnBaAwNDIc0QXtYtrMrJkARKwWKyoCJP/nMSikS6wJHnOLlP1G4BjE7BJ57gOff263fsUkAE+BKIQjWiEH/wwUEFEYhSwqMReWTOCGIB2SSZA0kyTAyp1wuWjbzlOPtf5nAmsRTe9UafA2nmcUALWOg84Wks1oLTkfAemuQUPTUsAqgdcILfe9RNsHJUEJ3STV2OQBSqO6kpKWAJti2AEDW7FV+zkZz+r6iUNZrCHZSTuhMZE3OKi4QyzLrOZyyyrMt3KVrdaY4bRhHA1hsEJPej1A9bh4C7tU0pgDXacUzlA7g6pXHZ6tLvepQsWJxtPeW5HA9x5MSiNu9vt+OgszBlub6pmAT4gAhGNUIRq+ZAsQXwCGKjA/8MKWuBddS7JRyYA73UN+RZEHqe4JmbA7a4cl+VyOTgTqJoDwqw0JLFoaakZHpLEu4Fd6Qw8Z0Gua6QjnPFNQAMZEAQwjPoJSmziE6WIFdo+aMEO8KoDo9olL1elghXQQAUjVBxKUgjDZzzOcZWuRuNsaOlqZCMb2pBmNSvnaVJr49OkRnU1cGEJPtwBCHvVQA1YIJELu6Y+u+qwEdc1FYtR4C0SCEFxB4ZjCVCg2L9RS2SRJE/hgEc7wrmAwJjzXSXRxTeKBLPRuvAHHyMiDnzggyDEnQlgwGISNdBAd7EIxQmA5gIPwAC2f7NIff56SKD8aG/ed1JGVi0BJi1pVf8WEPBNKiA5zhGNBppTnQdALbihVBoGsLgW8CSqu1Crznc6YAlgiGJ6l/iEQTrRwEfYQKoZQLQGDu1XFbBAqh+gQQ5KgelKbyMbnXYcqrNh85t3Wuc/3wbPt8ENnpM66EHf+dGD/oxYRIIPeMhCDSSyAxvIugR4unAGcN1hD0dlA8z1N3Diwsh+A1fsZ2fudw0WtbPP27heFljV5s2AIDTClZXwcSAQkTZMjGkUOrDAu/8dghgkp7jAbY4EQACCw3NZ2ur0FxV71K/H95OdiYp7BYI9F5j61jh2bo1oRpAaNu+sUEwCAWlqhhzSC6eUfI3NLh3zCT/fERWfsAQcIcH/A0az4OouKMEHZt3yWTuaBVTfwQ+Q8QylN9/5z4f+zY9OakmzMEAq4YmZgrELXFyi1WbIghl+oIOqz/oisgHs0XS96wVAVwL+/rfAzg5mL/v2u0jaLbRbjBwSywW50cY2Ycs2BriBSTDASsiDJ0CtRagjVFgGWCiE1wCYBCABGTAZ9+mtyDISfVKufHKOePIR41KLCYg3+Ts7uVOnt/gtflOaUhIUB1CUB6iAiaoAEBC9dHMO9FGO65gIv6oB84AFZOiETBCF91igSICjQrAB4mOBDzCBi+iglmM0G5iBDmCBGrABPgCGAAGK7JOMXbgFWpAFhGCFVTgFDumQUIAe/+hxj0xwlvd4FvdyLzs6lj3AAQ8wDz1AQkrggzbIg1Y7g/ADAqqrAanDCNggJbpRv6jognRbCwaIv7qYOCCZLB/hgCIpjkycIteRnSVJNoHZDmg7Ge8qNlK8sqrZgEY4wDiIgxtALUSIhE8Aik74AEZKgAoYAdfbDYnrrlzcN06qsrggkg58H3z6GfjZpHbKMmCEH3FqQQdAEgZAEhlUkkOSAUMYBBh4AeHIJ/dBEqLBjwtqgFS6hFLohE04x/hor9wLBDzkpQvTsKnaD0ezqiAIgjMIhD4QN0E4hH5chEXYx38USIFMG7RxoIMsqIH8R0FYhEMohD/ggzfYARXIgP9zMYADgAAagII0OANw+4M/wIM7OAMuyIIgIMRZA6rzK6X08zBQ6AIrAw4QzETY6Y0pkqIWs8ndkR0q+pG0aLFRnCdoez+jsQBEMMBzAwMjUARVhIRN2EJYAAIxsxqAgi4LcB9ohJqYsgDoMjGPwj98QqSPggsWqZoFyLJDMsuRCji4MSJFtIDPeQu1iIAEEAFQAAVNkIS8NIQiQJl+sRO+qAHgCYIu+AE+WIRNQAV0PMfqyQQ5XAQ+yAM5kIPIhAM4YIM7YIM1yEwzuAMdsIIt6II4mAM2UAM7UAMvmIImaIIsyIIfcE0dID8akE39mg/+2I/8kCpeuhWuG7ityKz/rTiAVLGAHQiEQPiDQgiEVsODNtiCKDDJQiw/iWAUUgqsFgEGT8iC7FKOUMwtTGSSFqusk6GZ0XCTJikO7wTP1ECn2eHKDCiESqiESwiCD/ADRTBASMgEVlgGYAgEq7QaCthKlmoODNK6p8I1wNLKlTwaohma6riVk0M5lMOIJywBoCpE2bQBHdiBDQ2CJ3gCkzQC8jqCEIiAEq0Du8TLvNQEUPAEQ6gDSRgESdAEQxADKqACJUiCOLABBXwtP/sE98AEWdED+6gb8igiqHARrhmpwooRuJEK9nuK9ZNSI2KAz7GKqSidxLIkTIoRC+A20zItPoDI5dyCD9XQqjPE/0DBpepcBmTYBKDamVDUjtTYIjbZIs7Ik2aDGdjwrvvLPxR7sdcgvXdrqQy4A0qIz0mAhEmwz0mwBEgwBVOgBDZowuoIDBbwvRIwgUcpxBrQgSCouiCIgh4gVSNwAiMwgijYAtBsA1Y8gzaAVT+EVVak1ViNgy6IgjbogsEMglUFAh3AqhyYAUxdAROgtYnYowqIABEQgRQQgRKF1gTAgCHQhBT1hEEYhDrQ1iJwDqtZgA5ABDmCHvbgBPjIhBw4gCSCl624SK3Q0ktqCsy6n3mdV7B5pHsFG3qd18TyGggoBEhABIQK2ID1gzxog0Ds0Oe0uqv7gO9IP2SIhUyYgf8VKNDvuLrQ2KCLWAFiBaqNlbWPLUTgAR5SdU5UTQLyCgMnSIKUVYKUDYOXfdk5kNk5WFnRbIRLqIRJQARFUARXcqVyLDdPyFlAmANAAAQ/mANWDIMuWNooAJ4N3QHggYHEGKOro7XctKWKCCdxWr8nLSwnJR0slREGWFYiEAEEiAACQIC1Vdu1lVEQGIQhyFYikIQXFYMiIAQUAJog+AN0XA8gjRUVuB98PaBJMtzDlSTCVVz9sZ9LWoAdmIRLaIS0Qa1GCNhAKNiDPQMzeIJBRFNZo7U7swBWKIXbu4RJsNyjVN2chU/VvU9IqNwfy7viLE5EAISPVC3V+gNC8AP/o5VZWo0DJRBeI+gBIzCBxLgBKZiEStAEu1tK2KUVh3iEJ0A3C1iArfSwK31SLB04Beje0sEKw9IKdZ2R8jVfrkBfLc2sxv03EGDWCFjb+JXfQQAFIrBfEJCEIchf/S0CGT2CA5gAY4UEUBiFAl7DTYCEBVjc/BEA/HFg/OEffZXgAUhf9G0KCIakAdKfANof+zGABvCDTfAE3fNZR/Cxh4TMp2sDM3BOqruBQkzJCxOF9ZijP3jVINCBTgXdGNbN9Puwr0UiGKGRd7UkA1CA+nHcOVBU2DVhRGCEtAkEHciAp2isxJrgwV3gDEbcLUYgLQ4gAUiAEl1b+CWAMhbj/wgggrtMAUkQAUkABRmtA02ogyMABUUQsxFwAQUYTjBBBmBAhmUAhRwotBZRlfqYG6QJHa6gkXQ9gLuxJfvwAP7YJataggz9AS1QA4PdgRV4y62Q1wm24rApAK5oADewS08Y4faihEMIWOT8gzwIyc19Ah5AU9y8G0yIBIDEAyBYgV7apfOzNZUTXZY0FwOg4CBml9KJF0u6n1FuAA3Imks6gChQ1KRypYJUAd/EYC/m4m725knqH8z65ANIALRFALUV4/iF37oEhUEQgze2S1g4ZU3wBE2wgAE4gBIYWwVQhLvcUE34gkKzgJxZgRqggR94gh3QgjXAAzzIg0BghP/S1AN9FLdHWI/pOcfp+QRPYFFKyAMtQARQQAW7BIVSEFo5qAEIUIALpldmJuLGxYoGYAE/OOUhjJUF6jYUHtMVzgIg4IEdxogOsAM7MAMWtoELW8kDrZvAWpd1aYp0FVvwjVcVsZ8FHgANDhsVaIT2ugRZwYT38ICqzuKx7p8rptd8NeuwUWT0xQoJgNZzll9zXmdsVVGSRtG71ARCuOdUcYsEGIK7BAECKIDpQpcNgAF6RmW7JuBPMOCjKlf44IQCLuAZVg+TngQgsN63AQNF4OhJaAMWgABP/uTMIuKX3lKo6IAG4ANUvuhLoKPYBVPjNNjNBYIM5YEsuAMzSGn/i0DqdPkwr51S355SINbeIO7acdSPHyiETDAIjwkTWHgEioWA0ZkRC7bu625XqF4/uwGJ/ZgBHMABIaiCMdCDiWZIY4mV90BHURiFVJiFU2CFVFAPVKiDMSZj+V3nuD7jZS1REaBbGeiBBlgBTJLWaq0DSJSAxdpSQqgEjkZlxPaE53mev32WTOCENaSeS0iEO1CBBvBk0laAHSAEF2CKqXbp0kZxx0pXCwgCCFABT5Aext6ES3BtWnGEyrVcV366M9iCNfgDSKDxQtgPoELJjsXUK9ThTs1Qe+xQD2VykyQ/LPzcIz9Wv8Lak+slIh0IGqiCWGpMOGwgPhiDHBAC/6wq8zEYAzvQg9KKJVeyhEvIBDnSaMYuXVRgiFiQBcjABecGBu3rCaIgii78CTJBhgQRimM4hq1KhmIIhj72AQIQgHS2b3M+W7hW5zFW5wig1rpN8AdwY00QAQJIAFFPgQoIGBlV7BmVUdbuhFIwhWuxFldQhVIoBVC4hDz4gAUogHMR5bBpYLfQ28ZNcRTPbsfy3gYoAT9ggQxAzOhRD3WshKRa4hynXT4oBEvoBIe4hCx4gii/UNnEAf2a2CM/ctmEzhzQARq4qh/AKh1wTSvQAjO4TDwoLR+zOzpqr/ikcTnvhAiXI1T2BFqnvSHkhDnfGFhgBVjA81iADD4fBv8/JnQyMZCJp/iJP6GSsPiWMKH/momuIjAHKxBHL2MCWFb7ft8SHYRzbltMR9tnbfm8rIB2FgP6bWcQCGP4FQCV//QVtUtJSNsEkAFN2MKge5ylgwVKoAEHMOb8KYAjHlwBEIADYICsEeVhf9fs1opjdwATKIQOOABIcAjoKar1oPEaz1lFfUV7B7mNKYVNCASG/LHJhQQ4sgT1xug1lGxap3VU4Pu+9/u+hwWED/zBJ/zCbwi+D3zSLWBUKCrGF4XHn2zGtvOFUIVVSAVWGMM8h4zJ+HNCr3iV+C9jCpdjYqFjcgYZapyc87RqygZucH1wAId5AIegA4ZQL+OWh9//ZR0Es21jYBgCSFd5aIVfdR4EvCz+uGXRI4DEUYd6AiKA98V0AYB0qCcACTAEZBi6bZh9WugDDyftAYD6xrIf6qd+SK96qi5tC8760lEA4eyBSWABA6gCWHCIUSiFP5MeOSr71p12IPeE5gaIUptYoSpoEBWrhLEUyooVSxZEhxIlNkxo8SIrVak2cuyosWMqUyJFijolipQpUaZIkTp5kqWpVaRWnTrV6tSrnLNq6fIlTBgxYsWSEU3GrFkzZ0qfMa1WLVu2bVK3gatq9SrWrFqzboMVggCCsCIiREAQQQQRSYNSiNAEiggCAnIjDBo0VoAAsBEkgQJVF+2gIQ8Y/xwoIBevgACI8colsDgvXg2TaDEVhaOBgQIGCg9IXIDzgNABHOd1HPr0gAKqBxhovfkA7NgKFCxYMHu2AwsapHjiY8ADKlgGP30aVQrUpkubNmm6VKnSJEqTLG1CBQwZsFGZRHHv7j2Ud+6hxn8fb/48+lCc0rMH/5JlTfg1W+V8Zez+/V/HhDFzBu0/NNFIA1U23BjIzTfzKLgggw02uNVWB3IjlVPPOIPUMsogE8wur9w0iieEJNAYWCKEJRZaRIAwhCaaRCCAWRGkRQRZYMVFRF9+ESHCIGJIkACQCZxIVll6EVkkY3GVlkALZmRgwGmqSVlAAgpkNuUBcoVFgP9mU6p2pZStxSYbbQscQFsDEHSwRnIQQDAKLaiMMsonnXRS3CfJJUeJdJNAAgklm8CCHSqbQMISoonWtGgrjTZaX065SCppL5X+culPQQV1DKdGMdOfUtOIOo1TTxEIlYTffANOgvPQQ4+C4HADIa0RcgNVNdNE4wwzyRxDjDC/9PLKKaSoxwkmkUQiSB977CEEtDhIO4MHKsxArQcQeJBBBgyM2BiMYZF1ogiStAhKi3GdRcQgNBY5FgER9EUEvfQOkQAD3go5JJEi+Puvv0WCpSUB+B6QWWhYnmmlmLQBKW4CXYbpmphj3lbmAg00MFsDDmSwAh+ejKLHDJ8Aw0r/KaXQaacnnhC33CWX8MnnJZ0MCswnlDzyKTMA/kcN0NZYc8012hhtdDdJe6O0N96YY046TTvdDtVU01PPq/XYU0/V9Xjt9dVe2zO2Pe60Q0456LzzTjv3jA3rN6hOKBVTzyijTDLFcHhLLausJMp4nCCbrLLLMuvsGGNAK8S0KnjwOOTcZvB4Bm5y66abHXDbAQQWUMBAXFtqadaOZYWlCTDAwKKJJAikOIha7YobFo6a1LuuBA/gG+SJZonAFsApjnVkBN4qcLCUqalmsca2KWCYXgls5tqYZM5WW20aO7C9AwswkFsHNiACCiyf9PHJMLQQpHKddt5ZZ3Ixy2yJ/yWdoALKJX+usz//a5Pzf//eoQ53uEMd5AhHOMgBD/6hAx3lEAc69tdAdPzvHBE8Bwb3h4945IOD7zjHOtzxDhGu7R3sOCE7yoFCdPTDHvTgxikwkSxMWKJwixAEs5rlrB3qoYc+/OEP7TAGOwgxcUa0wg90UAMarEAFH1ABFD+guQ5oTgMdsCIVqfiBLW6gAnEhmI3E0qLhESF1oKiEX2RUlzXSaEc0SkGLJEEvf+0oXxKYgATyqC8hretf9TIRisZivINByUu5uY2ZXAM9sySgegurDca0x73tdc4CFnDAA3SzAjNQohSwoAUnRrEhh5hCZStbDp46IT/lWIISrf+cGT5iKctYxqOWtrQlPv6xwXjk8pa3PAc5QLg/DJ6jhGur5TrKcQ5xnEOZyozgBB1YjmmKo5rTbCE4iMG4a1XBiIkjQxnswAZxkpMNeiAiOtOpziGi0wxj0AI8rQCEJOrABjWoAQvyuYJ9rsAF/vQnDGBQAx1kYQc9kEEESKQlItFLLWwZAixU1wMT9AUtkjDX7RrKI1CoBS2ASWgeQ0ACEoCgAhLwlrj8OEfT/W4sQJoNIaVUJQZowAEFSA3FYGMYsjCANrC5XsYa8D3uZdKSRr2iBjRgSQ18wAZ/uIQnkSGLWSADGbiQRSpQwb72bQJPnoAZzGRGief8ox9lPav/WdN61n/wcpa5lOU/4hrXWm7QrbT0JTvWwQ548FUeev3rXuFxQnmgcK9s4wYnpPW4HDCWBo6lQQ5sYAPG6qCyOXjC4hZXhW6OoQqZzewPGNtYGuSTBfusAT/3ucUVlPae96xsD16Q0NI4xkiuGwQoPMFRQ0TUEz3QRERhx9GGwoUuQ4jAEOogRxndjgAPkAAJUiCDFIwUAz/a11lSZLqzgIAwC6ueAvKFG5sqz0tzAYEEFNAA7Al1kkXVTVLju4EtlqAEGthACWqQhUZsohSyuNswkKGMYOCCIFqdE3Hc14m+fHWVMavEJfbxDwlTeMIWrnBZ+2FWuXI4rvvYh4ZD/yziEWe4HyA+sYlTjGINc9is9piHM/aAgxlA8bGOnYFjRZsDG/O4xz6+8Qya2EQnZlFzELgc5jC3OS1+YAMJeAxiepeCHIFCdfdDV+qAEbuGdpRdDFjRIGwXgRRIQgxPVkwCojuENQ8hBd3VV4zGFWd9YQx7CgDST3NTmC61RkrxEkEFvidJB1RyqUmdb5NLsE8WuLa+NdgBHibhCf8qw27KaIbeElKQlNEpwSz7BCg6oafkPAfFplaxiUvM4g63eMSuHvGHYy3rWcv6Hh/2MD3A0QrG0UAFHWDBDIAtbCgSu9jGJnYHPFBkKiq7yJJDsgO0J22NpQkChE7yBzRwAP/FQHlg8aqdJ4CxjHEvQ3WwCC4RhkAE4KLLLrAbhBLE8Ba0sI4wIciXmokghnQPobu7Y0CREJACGuGrp7TZ3sb2/Jk87zkzfVbNn0HwgEkaNb73pW99TdAC19rgBjtoQQtuEIWnjgIV/7WQM+wWjIWkrOWmJI4nOuGyT3w1fs8RLDzkgXOdyyMeOmeHzwtbWL72Vec5lwfSk650o8vDrHW1K103yNd4xDqX7qDHNzDRBz2QgQtPYIMa0FAGNKghDWV4AxveEPayq+EMbjcDF9x+Bi7AHZ7wNIMWsgCEIAABCDvgQRCCsIMd2BO1pt0i4hGf2tL2AAOmE91hGFMH8l3/5zrLeMYyYKHbdrsFFjmSxBAk4QlN1KEIcqS3JmRAAAz0aKQjTcEQZCCDI5R0MPginUNfevBoP89Ly2u4l1JTMBGQgAIUmGShDZ14xDP6nje4pw2iEIhAiYIVw0hKyp0RDPW1fE5zEoWdlrOJTGzCZQ2OmdAJi0L1o0PoQic6/OER9VvKEpe51CVd4wGPXfKSl/BAR9Ptn/7hwzwYQyRsHRkgERzAQRqsQQOmAQQy4BqggQOmgdzNndzRHd3ZXd49gQd64N71HQ/U0z2xgAuYAAq2QH19QGotmmu9QHKVzomQBgG0ReooA7ldHublyeZZWW5pghjUQcugy0W5kSSk/wBpJACZkZ5aDIEYOAEdHEEITMADDAbrmUuZhYAEIJzGHI/vSUnDXQnCfAYDiIAMgEBNFZrFbcB8LVo+QZ8N6EAQPMHgPUEbIIJyfIIpBMPdVJrd4EIsHJj3IRhXLQfLtIwnXAJfBZbRHV38yZ8vHdPakJAxlRABVWIJ4YOG4dwCPeL/sQPSBdY51AM4hMIe9AEckMEP/AActMEavOIrngEsOmAsroEsmoEa4CIbjIEZkIE7acE7AaMVaIEVPMEq0lNl2YBj1UALaJwLtMAKsKAbQt89+ZMP0MEg0MG9HUkFiAEsLENVCdi41Q0wZAIkgEJBnFtBgAIh8AWDjV67tP/Ij0jAtgVAAmDAAwDXEVABIIiBGAwBCVSAQIKAuWjCIMgAB2TSxtAGTH3hlyiSTqUGvojAEKDABlhABiTVavHTG9aAZEkW4D1BFpjBGTxBFLTBH0BCHpaCLQRYgF0eMMiCKSEYp62MgtkJqLWMYJ1Qzu0c0sEf/8VSCcXDCF0iPhAQUiLlJFKiO8TDJq4DX0ElPLhDCFVlKILiO3gDODRDs6DiFaxiG4RlWNaiK9qiLcqiLLLBGphBGfSiWyYOB8bTPB2jji0jPjGaaUUja7mWR+KTHO7AE/DBJBiCGPhAHWRjiyDDuGlIVQ2DHz6DK0TCuYnbuJlRlaXOucGCWgD/AyiIAQx4QpltQL48gBKAgiJogBHUBR3EAElhAAiEGenFgAvcVwOcifMonE7lpiPdFJWUYeyZAFNJY/PB4eABwRPM4UiuQRvgQR6cQRvwQSFMQh6OAivgAoHxwjCMm1TN5JzUZPt42nLo5DpEEFTyj3lK5U4CHTy8AzroH1EeEz7An3ku0P5E5Tq8Az7sAz6szX6uTTuYDYD2gzyo0DqYwzdsAynYwR7AARoswRUggViGpdxFqNyR5AXCHYZuoBlsaN5lgYdmwRMYJxCMYGUpUeGVYGmxwDLSQF+2gA0EARvcAR9UAnB5AuwYAnBdXjZUQ4YMQzAkwzPQTTAoZt3Y/02WRVTlaSbqcKYMVAJmekINOIAGsAAi6sg/UlcK1EGL0EEPtEB8MYD33MZmLM/xOFJs3JQBJIAEUOQR3ICiNZ8NDN4O8J1IcoFyhiUe4AEf8MEfBEIe5EEgIAIl5KH9NMRD4AIuCBihDKLK1KRNipr4SRB5juek8s8iCl37vd+lYmoDFdZ94md/gqrXtMOougM+/OQ5dAM4OIMgVIEesEEV/EACRmgbXKBYVugFzh3evZ3dkeQW/OqvRsEHHueIjmAclqgy5tNjAZu11EAJ9MAWmMEh8El1WIcnGAIaIcM2EAhTjCNTSMWtBCndYB65pQ52qE6Sap5iZp4O5IEn+P/BNyIDKIyFuq1ZlmpCiPTABkwABWzAxBnc8byGA7TAA5yJ9XihATCABKyIE/SAC3jknEZBFACrcy5nHvjBxf5BnxYCIiBCnyICoBCqcSDEQsQCLVwHdtCCcGyay7GPgi1HNDXQNEXTzE4QO7Qfzt5sp2ZqfcZfz3piP8TD/tRSUYoQAeWDJrLDOXgDN+zaGOSiN7WiHIylhMIiWsqi1Z7Bhm4t15Ik3nVg3wUe3xnrsSYjX6KoikKsGfzBI9RPcCApcoibVBQIrgTpt27r3IwruZJrOGLHuYKjYmJHRD1DVYHjIJQFc4nBEcCOJiiCEZhA7lDAxDmAeMWGAShAtC3/TJmEV09thsKuiBh0gccFwcSGZR60wZ/6gR/8QSG0Lsd2bCPELuxGxyVkgqjZScmVEivIQmae7LnRAvDy7icBr3DAD8zG7DQl7wNVkzgob/JKU81SKjqoQ1VSJfW+w3pmr9DCQ9A2ENElJQHVQz7Awzm4w4FiAg6ogTcJwRjAgRy4QVm2ogWaJSyqQSzmIhfcnYba3YeCaIiKaBDwwLECQT2d6NlKVmVZARekZM0ER5YhA+YNw1Rsw63k7TbUTTV8a5FiHg6SW9+GYw5aXg5W1Y6EjhOKAeNKghG8gOQa3wRsT0850sVkzPdUYW0eAANMAAlgYx0Ywa+i7sWqbiBw/2zrJgLsxm4j/AkkdKwjSGftqlImkF9xjOym1UlxvG1mZtnJdFqdTCr0NtB5Sm/MRpB9JuV/poM6nLHZvIM94EMbj9A7fNhRLiUBqUMa28M+IF04cEMxVIH9noEd3IE4pR0cvIEE2q9a5mIZgB3YTSAXYAEXXIEWoMEjP7IWQAEUcCAULMESIMESPMESjOjg2QAPjLJkuRac2gASqAEb8AEj1I8nwcJD8EKlSQWEXLCiZsj2wQIrnGwwYCcO+q0Wi3CWAW5VmVEJ1xZFHqZaHEEMnMAISC4Mw9RrHKz3TFJrKMAEhMBhikEPGIERdIEcxIEcBHHrqq4fuG4hJAIjtP9zO//JzMTMJlhCFG/CyKpMy4jf7d6JKHhf93VaJ0yq8oKxGKeNzfLVpJox1aQDQ1dN1YCvHcfxfhotUtpxO9jDPSDdOCAWDrBBrdqBGoS0GrwBSaeBSLPySbMyG0AgGqABFmDBFVxBGrz0S8e0JF8yJm+yJ3cyEpTy4JXyR6LyG8apFuDBHyxCoJTcue0uHz5DgVSFgVQF3SCDysKCUgvHylanY9rNB5vruZqrB5+rJgASDfLIu4lBEaAAcBrfv8LUT5XJeo0mfGkAJFHACCjXIDhBG8RBHMyBEL8uIiSCESMCIwR2IzCCIzhCIzgCPPMJ/ZDfnXQnKtBcWCmHchj/InF02veJAnGQwwRR0/PGbPNOk3kStB0TEEOntmqntkPb8QA5pdBC9ADZWj/AQzswA+MgMtipNARCYEqnNBuwQUu3dE1fgUvTdExjwSUvQU73NCf3tE//nSmf7aM9wRnkAccGCjq+bSzw4eVVAwWDgzUwQ4UMAy5kJv501Sdk8bp2a7kO81cTaWVih130DmOIgHLVwREkwQ28wAbElwVMnPPANVHpxgcwmg1YwHpdQAsolyH4tR8EwhAD9hEjsYUjsRLDMyQ8AlSdLDCUwsvEzyoNqiG+D3GceD+Pwv80EPMy7/+8ODm0uGeP8Wm7w2rfeEP/J0U7ZT+EUFEOUAF9/1g/qIM3hMIM4ADdbWgZlMEr9nYaBHdw/3ZIDzdxx7RL23Ry43Rz88BzR7d0E54Be2QQaAFKdqx2jywvX8fdpJxT7Oi2OsMszElvfULKRBQsyEJ7F2llWl7fVt7lZYgZpcDjKUleIFcdJEESBMENqGB9/fcl5ctQdY5SMVV+BQEYyEENdIADbAAM0AHrAMLGtm7HjjoiXLipJ/GfxO4jFAIfCIIoZZ4qvRL9WMIqlfiJZ/YomEIqJASMtzgC/Xo4jEM4VBOMv/gE1Xg6PA3U4Hg6PPQ71OdTrmcB1XFcvQM9NMMeQJEWbCg4MXkFpgHaQbmUhx2Vw/QVmHtMQ8G55/+0TiNBT0O3T8cpmPNla5FyFqyBFdzBIcCzPVMnLQRDgAlYHzaD3WrIuMkCouI5dgQDw+cyU+AgY2rnuWKHB0fUEQ46AiwGAhzBEyb6892TCZTARXLPUn2AotXADQSBFMwB67aBDXyACxSBlmoCIQzxqBd2xybCYe/8IzxChv98I7C6GvwADeTBJWgCJBRCIAhCEruSPBsiZnenrrPCQmgEBf2PjB8QsG89AsF4A7m2Oyg71LRDjldNatsxGMM2VAoQkKuDWd3DPLwCjc0At49dAzY5uEP5bp/0kpc7ctt0Tl8Bu/M0vMf7R56oPrVgPlXLteCAEOiBIOhBHwhC4UT/Ag1ZwgyFAlWJ6wU/A8EzZjGEPlHojUtCPHbgQuWlDjjuuV0cyZYgBgEkFx3EQRtEgdjewDOWQMWZvAvcwIt2QRz4QakvcR7MaRgAQosoAiIAtiMwAju38yIwQvT3fBKjeoYfQh5UAWl9wMfowBPkQZ+GbMyQn62PrEVshCmMAmdffYyLQ9f/+jgIO9cD+4sT0zk8zTiMvWqbfbJb0KRyL0Csg/dO3Tl37c71+0evWiQPKlSYMUOGTJo0a9akQWNRTUePHsuERIOF5JUrJU1egbLyipaVUJYsQYKEB48dN3fY0KmzRk8WP1msWPHhwwoWECHOyDHGjpAxT+1E3VMF/6odPXsicTIVTNmzbNu4ZXvmjGwys8eICSs27NkyZG+BAUMWF9gyu25hSSKRgkgKEREiICAgQACBFIMkBcLTpgvjKFGC3CCqoUQLGD2SbGnjpxAiSJMmNULEJw4gQpU8hUbEiLUjRolYs370CFLt2o8a1aZUexGfMjly6OChBc+fQpAqUaJk6dKlTZs6fRI1ylQqVdZHiQr1aTunT+jQkSMnTlw48+fHpT9H7nx78+LPxT9nztw4c+napUtHH3/+dOfUQUegdciBpx904HEnPnX+UwgcYnB4KAMztKjiiinAWKMNjTbqKCQ2QASpDJRSwgKKlFQ60aWYVqKpJpxw2v/Jhp58opGFnnRISqkx7rjDqTGcikqPKnKowowfxshBCDv66COSUFr5pZmvwAErm2qmYaYZs5J55pZQZLELmWCGmcuutpQBBhVJJKmDiL5E+EswASJAjJBC/MhzjjjiYKwGFkpw4YYeusiDj0AQyQ20SnJrpJBGFEGtEkhyow0S2XRbrrlLlLOtU0giYUSQQAI5rpFGlGtOU+c+GYU6U0wRRdZQQuHE1lttBS888Xh1z1dfeeVVP/76G1a/dtpxJ8ABEewnngTdUVadd/q5BxxS7PghBxW0mOhCMM7gQiOLOAqpDJAoGskkLNQ16aWYluBCC3hnWqKmmWy6yYacaOz/118daAj4BzPu4OMPPhDu49A/Ahk1EIZJ/UOPJptcJBJMRJmlmGe2AQucKrf5ahtmntmFq463eaYtlZdpCxZQNGETMU1oriMwBBCTxA866JhjjjzzyIOFDzr4oIabgjCU1EIedcQzRKBGZBJPKhmNYT70CIQPQRbpWpCvu17kkUX6mLjhr9EOO+xHIqEkEksyee65TDDBxJK7765b7711Fa9v9n79NVhe6SNWv8MPT3ZZeNYRMJ5+oJXWnX7s2SaSKpawgVstsNACQzDERUN00c8111yKSEzRXZjgXTGmmWDHN0Z9efK334B10IKNghHuvfc/II4YYTiI18N4Pg4R/+QRSzjJuBhnOP74Y26maaWVXpz5uONnmlG5LVlAqYTNSjTxhGZJiAhMBEkMEaOOOegAZM88/nhixhp42GKN4oxrxOnOEOEI0YhmEqDwBKUgQRtKzOYRaHMg1952iUf0QW1qY1vbmPOcTnRCbpnwIN4w4cEPWmJvdWtcOcrht10FDljAsk/hDncfY6WjIOQQUOMEBLloKQs/95iHL8ZAhh38xApV0IIWuCAFJWrEdBRx4hPJAAWSmIhFKYIXvWJ3LxfhhAf7yknt7ucvGuRgYLvDAx7ugAc+oJENahRE2fTQozPegQ1wCJod/ZAHPwDvEMvLBJSI0YxqcEN7V7LG9P+24Yzubc8WlphEJSYBC1S8TBGGkMQgIsAANolBDGHgGR388LDFSKRgwAsEJJzDqdqcilKnKqABNXGJSiSnEYtgRNhiYxvdqMoSyvElc5yzwU9scG6ZcM5zLiFCZZYwhJxYxzpQKJ73sJCa4eBVeogFw2HRJ0DgeaaunrVDd+CHHuDARBXIcBQW/AAKR+QCF5rQBCmWrgxkqEI9oViGk4yEdSdiXU1eVxMe0OQmBIXRQb9Yg9r1ZCc6sIIZdtcjENGRDRC9w1X2YLw7rMEMZ1hDHeGABz0aCmGkElskUIoJTpzCF8k4hjOyQUhExpQbNXWGMHDBClzcBRig8CnMnGD/STo4oQg+cIIY6MA0g/2uEF2jBHQ8EdVLIPBUjHCEJ1ABiks8speWYNsv8XY3ZcpNg9AhJlnRqsGzPudWociErUJBilf4ohjflOY0zTOOcHSjPenx61/HsSBsylCbhTNHgFCoK/DAYyDRYlA75pGMPYzhBz9RwRLa2S14ypMkoiuJZ6cIWnfBayX2EuhAbfIihK42RjJyrQ6A0NGJUhREZ/AoG6yiBzL8wApa2MIZLmq8OGKNYg7M7cRGxbaVtvQZ1egYISHbjm94o6bc2MYyRJEKZCwDGJKkmiGcIIMjjNcJc0DEcRBBKq7N5qkchKonFpjAR7BmE6jwxCWY80G9/701rqRYBSloZStlKrM5xtxUMjORX7lFB660EsUpWlGLXhgjGYIkJHjuGrhu8DWvf42Ph8/xQsPFsHDdVGzjBPIOaaXjG+AIhRCIdJTLIiELvt2sF7BQInZNkcclYR1p4XVag7KWdgd17ZF18IQztGF3IJLIk59MhjFUAQpGYMJvgytc4zHFeE0yXm+1kGQu6OA3VdiDxZbbvWpowxve+MY85lHTbWCiATNAxTPiUgpP0OEEEgDBENxXh/h1BlULVJ4lhvmcqHqiE1OdTQIdcQlUsIITJFRp806hi2IIEiwdy4YzjtGLVtSKE8wU64DfiqtQiIIUrciFMCjsjEG+mf8e9LDHrcVDnvMArj0b9hVg/RqO+RhWhts8nDrIgcLENq5A+FjxN5jRBxj/YAYPmUkWolBjeV6hCt0+yY55jKLSBvmKp81XvnKyWi+2FkY6od1woKwFIP3gB0+w9xOAsAMjcPIIPWCCFs4VFTuwQQ9OEcLB6W2FHIyR3sDJAQ6CtIc9OCkTqxBGMshSjUF2DBUdaIACCuGWnhKiAglAAAMkgAExtG8OjZgEKlpGC0sswhJq3WBUN7FAts3GErJQxi04EddaHCMa2oCzre1xj1vfutbfmEYyjNGLVwC4wUGnFSlIAeFX9OIXxmAGNLKhjTfPo9a2vsc99rGPf/jDH+D/0bV79ErN9ITDw+QY9mARZzhko5A8NwzHOvCxjvi041oQj7EHOgA7e2dBnkh4AhLT8E4toCglK7ECFC5/xSsS9Nw2cTeMdLAD2KY23TdBd75qANuEayELOnA9D4IQBCAAIQ9JKMIQUlABDPRAnk+otxnUwIYxOjxgNJAxDWYwAyGMUQhmGEOXKXixUJzCFcEohlhK8QEGMCABEgAFMCTBgQQQhgAEQED3jzAIQxBiEqWI+SUiAZ1hCjPREtw5SkkxjW1UI6ZHT/o++iEAFeIfAjDtlI4e4AwcwkKRzEJLnGEa+M8axI7syu7Wzi7tMPAf1o7t2A7DBoeFfI3u1APY/0KMPvzqPort2BQrsdABH/AhAAkCHJ6hD7SFnZBgB2LHCKBgJppACrTAyqQADJQICaZgCuKpCNuJQrJgCe8N38yNi2zC9aRwCoFDOKaw9GyAB2YPCHTADHTgDLTgB3ggC/gAEMIAEAahDhrhEQKhCx7A5ASDAW6gBhZuB54AC4hnMdpgDWyro+TliI6oiJhCjbAma9gGbjpBFFgBFkaBBbbvAbgvAUAgAQZjMAhDMMyPBCRBEybBEZ5jgY6jOYppEzLhEf6gD6yiSZ6EGcDhG75BuughWdyBseAhHt7hFnHxFsepHcoOzuYBWXixHurh1obRHtLOBTGQA/tBHpgxHv80kO00EIc+sJra48PU48NMEJv2IwUVZ1fKQVdcMAD/oRvAwRVywAaQAApw4gZjZyaszAjgkQmUiAnk0QibwAhrzAyWkAnvLfZUC6GmkAqDQzh44PVgL/Z87wdmD9/wwPWCwAiSwDTYpA5AQAeEAAKMIAb+4i8IQAZ64Isebw24wLZs6w9ZD9+AQKDISAieYAmtwAr0YL0ggRIugWqiABIroAIioBItcU4QIE7iJAUMgWYqIRECIREOwTMqYRMQzIM6YYKugmIwwRioYbp4ET9ukRZrMXLEKVpw0QVvsR3q4RaR8Rg18CzPUhmXkRmfUQMPxAN75VeCrcNIMMQAi9j/EidadsWGBAQf1O4f3uEaGgIHbEAmdgDdcDAH4XExmcAIkIAe4yky93EJZy/2LDMITg8nqjAgr3AHLHMLdcAGdOAHXA/fgkAHuqAHMAPQ6mAIcA8EJMAM+MACNsAQDEECAIMBOKAOjMAGgiAKJAIIWrLGsgDf8I12aGQncEQHxqB3FqEzIGEOKOABJgAESEBOEGBOCgMBIkAE+uJNVm4oJwE2DoFpUCmZOMG9FuGNpDIXuGG6ukEsDyJatJKx4uE+8fM+tVI/1yEX38Ev1Q4f0NIt+0EtHycA/eEf8PNvprGvSBDY/iob+UOb/sMd0GE/zgE83CHtAHMctEEYcKAK/w7zJpag9BLTHRdzMWcCMiMzHSezMi8TM7lIMweSMxUyCFTTMrPg4BAOCB4SIomKk8RgCAIjBfwi91xAEWBAABKgDmJAAhIAAACgAuYADCAjCLJAoGbvRTwvjGwn9XjgCazCDg4lEOJgAx7gAXRvL95kJwuDACLgSN+ECAZBDNQPNSjhEA4hEPYUEt7qrTohE9ZTEFLqFKIBHNrMHIBRxdzhmRz1USGVsQSCP/HBP13wHy4VLZdRU8WRH/whHgAEG8BD2chDHPiuVN+umuBDxERsP0TMHADkQvVDHWiVQ89BMDFBBX5gRLMQB9cRdlI0WFkUdpKwOJtwC1PyoFzP4f9sVCF34CMRcgkNDgi2wPaOgJPqQBLEwOQAA07iRAIkgPtGgA4YIACkFAACgFBgCzIQs7UW6ktTTzjvoKMWowXStAJCgARIYAiIQATmBE69UwQOYxDmdGY4kTcWQU8pYb/qZqVq4ReYIRvmwSrpgT668cQg9VEZ55m2sj910R3I8llqES2b8R8wUEA38Ba7wRjYYQWV7VRLNS7bY3DEY7BYNUJhFT4KJz7Ubh/SQRuMIULO8R9vsKCAFQmEVQoasx1ZrzhnTyGRNd8OyuGYVQrp7UZlTziH8wnMYAu6gJP4NX0QANDYhE0A42YAQAA2ERQkoQhOIAQYoAIY4AIIIQj/zCD2jIwn3hVeU+8L9bELdsACGEBNrZMv/HU743RO6XQQGLcO6sCnqGaqGOERkCelOIEUeKEZnIGQKPAVgZE+9FKxdCVjH1VAaHEduhIXn0UgXBAfmFEeHudkNzAe1MEcmOEUXJYFYVYcaFbugK0+cBbZ7G5nz0ED98EbqoETHoL0fPWgjjZYrYwJ2jEd7Q0IxFBLt/S0dIBqqdZqr/Zp7S0KtsBrg8AJHFdxN5JtKdH8BMBcpZQBQEERYsY17XQIjoADFOEMdCAI2iBvvfRP+BZHgCBLb0ADHrECQCAF+DUC3jQCFPdNEINgHfc0KsE5dsMRkHJiQiF6wMH/ku4e//wDWbySZncXVdGBBb0pWjhWKzkWP183do+xQP3BHcYBGnIhFF7WhE+4HFCV12TWV7rhdw3Lr9ajHOpOIeyBGprhIlXA9HJioBDKHZE2RaW4HaGgeqE2arF3Wbe3Cm1gIK/2aqvACqIgCY7ACWBAA1Dggdu0TuqAEtH1XNM2AVKjDUBhEHCPTutgEO7kB9aACfJWoe7nJwKYBnSARjaAARSg+ypAYPu1EruTjReXcYeqB9qAfhhhT3PAnnBAEJ7hY2ytHs4O7fZBHZDFHpztHN5BdHXlZV82d79RHQTidDe2Fl0YdgWQAAMQH9pBG35h+k6YPEgVVYm5VKlxsMxhw//GYRsNSx2iSQQzVCF8KBdwQAU+4LTSrWhPFFiDdYqtmAm1diFRUnu5t0a99wcOLgeAYN/EQAZiICfDtmDTxzvrhHENgQ44AOV8wKdohmCDEjEMYRKewA7/MaEUKoBFUwfSyAy6IAgoYPskQPf4wk3NT2CNlI0Zl5OS4CNF82pZYIyuwA5aARzoQUD1IR/Q7kAci1bVQYVZeYdRiB1kmh3KQaZreqbtk3FMtz7tE3Lc0kAEcB/sARriKhRG1ZWLuZh5TS5tVpmzEZvOgYeliS/7YR/KCRNmACLObR1/VTHjsTHhsR2XgB+RFSVTsiClkHub9QeWUAduIP2IFATE4C//JBkwJGEwEkABFiBNE4ABhsCAUgAE3mQjAdoTziAItoB29sW1AlihuvAOGKMEtg/lGjkFKDqSvxOj69QJjEBGpZAHaEChQloQpoEenuUc9OEeXvCZpIVWVRiHBOSoXZmmX1amd1qnbzs/UfY/A5AdAjAe7uEaTuEUSMEVWjmHUXWYySPD4M4+sAlClTk9ki1YwOMffIgZhCCrOwAxbaJop9czGZMeWbQJ6gXzqncht1Ah0XpZu9ec6W32omAHnMCf43SiHbhg/yICNIEI5FhKt5NgC+O+42RmQGEOasAI2K3dZCQ0N9MihSAP9DEJEnlwMSBOLts7JZkIXNNxOVv2/5BADF+PBXTiCspgDEJhHtQBHuLDHuoBAL/JmwbEUQVEpkv1GxVrpnF8p3Folu3zPvEhPjQQHtihGX22F7CuFZTBxl85uZWbd5faV4A3QiF0HGwoWGrVHlwMB7alAw6qu6eXm786euMJdjDLCo41as96vdl7e6fwvbdgUPZ4sAfBSPObTvs1O1NAEkTAfc81ACp6EMyPADBcBAZBE3yKEHaACbAIXsS5CZ+gt6CMTPWoC0ouAbqTIwWAO/vCSPlCcXEP0MRACYygJt5boGhgxLFA4pihHsLhHbrhFo2RdHncUW06sXAcHpixPnm8lvcTP/NhH25RHiCnH96hHo6h1f9O4Ri2QXT5cnB0BVV/7a/CIcpP8KlfiGbnw4eqoQ9y4Cg84AfwRYu+HEXjkYpjp52sgN5a0qzpTXu7eDPdWyHbQBHmQAY63c4t/WyHgATg8DCIgAH6W9DjRGwRoF+7sw5oBhYUAQxAZw2Ix+GJ5yIgnnhCKmjyAI3OKA8KYQ5MIBK50ycxnC/ufU4//QjCAAxo4nu3EHeeoMTHABPCLj1A9ux03Svfgad5+nUD8HV5vufXUthz+depZR2I3R3mARqyjhR+4ZBeei9VCB2gHe7kwxqf+1WRmcrFA9nowx7m4RVwwAogIgN+4HUOc9yRdorDPKzPXQvSfWufljRPizT/07rNw/gH/iCriuC++3UIeLKv+ZwA6PQE5DgACj59zrY7ASMF2I8Q4pcJMsSOLB5hLB4PKp6kfgd4EGELNCAB4DA7L1HvM9xIZUAGikAJpODRvxfffkDLAeaIlqQWEHUcWlCU4wF2RVYXb96WH8fnd37ngR7oBTD4hV8hzgEhsGEgfAgaTiGuXiEa7KEdMKzpRTeapjGwpn4cnJrap3w9Hssc6CEbIkEIloAFPAACwJ3zzN4xoVdFz928z1zln5YzXa/u6Y0RJqkSulVg57wCEOBNK1EAAAKAABBDABgUgECEiBQRREQAEeIBgySKNFFCBArRjjNp3uDBkycPHz98//iEPFmy5J9AhVrm0aDgQAIENBEgXEgkp86dRFKkkOHDRxImT7RkeYIU6Y8ZOHLk4LHFxg9BzbyFK9ePnr148rrGi4cP37t3YfH9O9svbb+zZ83+C/sWn9q5dNX+s3cPmrFu7uZ9exWK1Cto5v7xK1dOHLrF6Mitewz5MbpyjclZJhcu3LhznDmP69bNnOhxn0GbBk2as7rV5uYd26PGBosMEH4AQcKDx5IlSJBA+d17iRakUZ5EiXI0S5YmWppAQbLbivQnP35QB2IbiPbqOnRw9179+w8eiUCN8gQiQIScmiSBWDhERgoRFyJUiJCQwMEUgwaJYcBABQ400EEVkP9scgkljoCyBhBmkPEGHBKCZFJJJKX0R4YsFRKIHysokMBM+BFAkwg8nUjEED/5UEQRRmyhnHQyVlEFDjPkIIQNNhixgxChaHNVPPbMg09XdJWFpFx2seUWXG/VBaVa6nSDDTV7geMMJ6KQcsw19/zjD2KUMVbZZWYuhllmlmUWzpqkkdYNaaLN+WY3baKzzzvwyFPOPuBwMoYaazyRg21B5KaddkktWhSMyj2ahRZGQWEFFEtcYeluui3Bw3jj6bADqDzsMCqooua2Q6o7+OHJJp/kIRARg2iiySBDiCGGfLcSUUdPdYhRAQMcDHHEEUpYoEENNPywxx59WJIgJJr/AHFjGWywcce110oIx0cg5QEJIog00iEiNsSUQAQjkhiBTykMkZO78g7RYhJJGJGUFjTuS6MQQlTxhHLF5bBHM/akdc89SqrVFVtM4hPPWv/001XF8kjssMP+TEwxxV3BQw401DBjjDHRMAPYK850M6Q97LzMDpmSoaMOOemQow6ZZGJmWWPjzGnOz6O9+WY48PSjzj7oiMOOO8z0oQcXZxxl3RNBBJEoEIw+YUUWZpgB6aOSaiHjE79pmlvaao+qats7XJ22dkjMUcklwKDiAACySkKrGL3WAfggdQwBAh2aeEIrrZ4gDkoheOhhh7OLWFLJJJVUQugP2mr70YQh/1nYyCSNiItIFw+EiAB+AghAQEPx7uTTQu8S28UWMCbFL79jjFGFpF+bkQMOocyzzz/7FB8lxnFNjBaUGWfsjz9zycNOWtRAYw00mLxCSjGknEKMMcxgY087MaPzmDvqqx+Z+qu9v74776sj/zlA0yk00OccfY7SRrdzCiHoYQ1Te4IOslCcRG0tKV4DG6TMELCxTedsaFub2tymKrghSmtygIQlgPEMRRBABIPYmyRk1R9DSIIOYpDEJEDhCVCgAhQ0nCEoIMGSRTwiEY2oxOI04Qc1/CAHm8MWSCaUEj78QVx5aEkUTpcABowIIa5DUU98IoMiOCEMbWjDGSRlBf8t8I5fSNndGLTwOzMwZQ/HoEfxOBaljC3MYxdLS1fcAke6XIwt/YhHN6Txi0hwghPEIAUnMNGLY7ziFdTYB8XYAQ94jGWSeoIHZNwxFvVlEpPv0GQn1ZGOUIoylO0oZTtEqQ65iOUd4fDGNCKxBzhkKws6AEIWbqeopGQNKb971NcimIWy/YaCudkNpyx4tWQmc4Pa4UIhGjGKZXgiBOsxkaxMdEIQTGBWhKgEMEbxCVTAYpzj9IToIEEJSByIhosLhBrIgIMyWAtbd+gchZLICES4pAQhUhcCCHCTnljRJ0MYQhji4Ac/hKQNBOQCF8xoRrLRaHdpVAEOcMCJb9j/A47Me57xPmpHizFMHk5K3luOh490jIwTkcAE+JIRCk6IzxivCIdXvhKPsdjDHkiqGD72cY+d4kWoQq2HUesRv/XZI6madGSewtGNv4yhD29gwxq0AASjGOUJu+SqopTTy7AZJZgyGiYFl5CpY44qbrnRYNZ6UxQ+UAIYnVCEBBSirpyQEAQSEEPlKPEJYHyiE6UYhThnWAlITGITm/BEKcQJw0oE4g+7I0MZ1EDPO9yhWygpCYf0+cR+/vMmC8EJTwjqBEC05A8pyUO2rmXZrzlUUljAwtfsgNsxqGCNxiBePyCWpJ/uIyw8vQfyKqYWPDoMYmApSzyMdw96tMMb/9yQRjZ6EQpmECMZuTjFMajxDdJ4TC3N3enx2lIxoCZsvesl6k4TtlN3CDWpO/3pb9+BDW9kIxJj0AMe1DC2sR0lawoEa1ghJamjcI1sV8CUWYdZQVKt7WqkytoSrPCDo+RAFsDwhAkaohBZRQADMJBEJRrxiE98AhehCAUqHguLGV7CsYalBTCQsYxlwKITj4CcENQgT8xea7MfEYlKGFEIROTBBACiCUATIjuFpGAnBfUbIcQViEAkUbPXUoMaZOtQLngBDWzArZk9sFshYIIb90jL8YaLD7zAV6jGzaPEmvu83zo3HsfbaTu0cTJmTKMZxChGL07R23rcIx8TM/9Scvvx5vMWqSuRFm6k4Uxc9+70qHQ+3n274Q1i7MEOavhvFcIYqa3qUmsBS3WCIYWUVAdzbA+GsDHVygMCoyrXtxGOGsYQiCDQgBPPQEUgQLA3wc3BIpnYRCdGsSVekCIUroiFLMg5CmizQhnP2MY2uLEMXHTCEouwQ6BoZFnMbpazKvnDIRrRBpjIBKABdZeUdXKrOhBCEYpoREsWkWXW8sFbXGaDGrggqDGX2cx2QPOy9kAMN0osSZUuS8YgnSeyWPrNZxEpPtxRD29E4xi92C4xfiEMUhCjGuAwr1k6NpezXPos/uCH8d68cZz/lM7snbOcHTmxc+iXE0KwAxv/qvBOrmXBoQoecKxhPVblMDDBYSTbWW19ax7AddVAyDVS0LqGO/ChJVzQwzKAsQkfEEESfANFKWiRCVOMohSmSIUokHEKUbhiFrgABi3+zm1vgwMc3n5GMD4RCUHY4QdaqE4VgsyGCN1zJIGItwIKQAB6Q1l28/EJEcRAh0EYgt/iaoQ6H9GSySbxI9lag6DYgAZr3YHhHsgADWgwhjXbo3h73nhYxoIk+LrD55pOGJwTRo9vSIMZv1hkMoiR8loUwxnfmMc86AGOeRhXLfzgR/TYcl4wbWy5Hm0Lp30O36O+HNLfaMYehPBa3LLBDBzRQlq1EzYFtxrWR5EO2cLY/2CYshvEtCm5gQRdx0yqAgRc0C0l0QiNgAdC8AmlUAlFUAeDwDefEBiBgQmcEAqZwAms8AmjwAq04AqtMAzPwA2DBw4ryA3ZUA3KgAujQAmFkAeRYh1c4HphRyEZoiFPYAExUQAMICIgphBHqBBDgIGTAAmO8IAPKC4cEgh9ADV6YIVcRjaSUhRiNAZkQAa7IwRjYAZsoAd78Aq+NVJRol7EVz7uRQ/zMHjfMHjc4A3aYA3W4Ay98Aq58AquYAu7MAuugAsgGFMtxgm5YH1o0X3eN37h1w/jV37LlWlEVQ9yFlT1xTH48A2tIAQ5oFkMR39cYH/DtEBIoTWPEjBPV/91/ldrUCCAWad1caMdo6I1WgAHebBEpndiHoADB6JCfKMJnRAKtRAYkRAKn5AJltBsn2AKt6AM1bCCLNiC21ANzZAMuIAKnQAJfiAHTDAcVqCDr1dkfvAHCeUHMCGEUWSESHiEKSAGhiAukJBPpBOFiyAIgjCFVqgHXGYGkiKK/XhGXlgFYHgHZ1CGkfAM8+CG9MCQ12d94PANL1gN0NAMzHAMJKeHi3QKpxAKmOCRkQCSsNQHe9BSh+SRpmAKwbAKuIAJuCUEzUKFkUAM4LAZ/3AOi8gPa+GIyaNHJAVU7lWJ7WVeHFMP+9UUbHAGaSRblFI2XGWKWqMoApZ//cj/iq14VriWaxf0BAyIi4igTpcwYxlwAFegCZWQOJ4wCrMwDKJQCpaAjI/QB49QCsCwDM+QDd4GjduQDc/gDMoQDLSACqPQCZPgB1LAI5SiBQi3BouJRBmSUEEYIurIjuzojoTwgI8QCY/wCFCICIdwCItgj/c4hX3AB/t4LV8zf3bwNQ3mhWMgBGYwe5DDCbtQC6/QCqQgCjHlkZgAkoJAhc3CcOZ2UTjgLxclBMM5nP7iLCXpgZwwCrhACrggClAjCHwgCPYImpigDKRwDXzRD92nFo5YR44GcyP1U0JpD5UoZz83MftAD8RwnDiALfT3O4n5f1ZAHdYhdYsSKaKY/39e83+j+BsOhla3pikS1nWKklVrgAd+UAiMwISXsAmg0AgQAAebYJY05HazEAyC2QnjFgmfEAx1WQ3V8AwneqLMUAzCMAumgIyXAAmN4AdncDXaISM6aFVpkAZrcIvmyGQA8gAPUAEioCLz0Y4yoG/igpmZuZlPyAg69AigGZqimRKadQemGXloAGSuaQeQYwd9UCPDOQNMMaZlyhTGKQTe4S/+QgNNgQN64CqZQIgeGAq5GQr32GItJgqsQAqsgAymkJmgqZmWYAm8GQo40Ava0A2ONBc7GRdNElyZiJ7FpzDGYw9/YiMqoJqyxYVkQKDGlH/FYTYC6n/+l4UC6v+Kr2igv6E20BEpUJAGt/gHhZAI6EQJjQULl/AHlmBYM4QKqEALHXoJo0ALt5AM3XaizqCsylAMwXALqyAKyIhDeDBZCkVL3sFqAXMGizk2XNAGC9UCQfoAFCABFUAQBdV5Q1AHgLBvl4lO6gSvkPAI8KqZmimoUmqPSiRwrHeaZgA5o4YHd4ADKoBmHoBmH7ACCcsCC0sDZ9oUTuEvweMvguCnwRAMteALvlALrWALtYAJzkKnoZB3ghQLn8AJcgqWyqiyi+ABe5AMiqokdfRGafGobRGpafFelzhURHWJQEUPzrAHA+sBYvg13ihGVZBWA4iKAhMFUCCgYBSgATb/gKl6NrbGqmnjG1KjBbGKi7TqCHVzCeGEdpYQCriADMgADH4XC6NAl97mtifaDMcgDLawCoJpCYl3B2YABDUwBwmFB1mQA7fHatqhBWdwBrOVmF3UBiZAARSgARqwARgQAu5IB1UmeooQo6f3rvEKr+lEr5opr/W6CJ55CJMlcAOHLf9qB2vABz+gAhmQAR0Au7HbARrQAR+Aux+gArvLuwWLZsQZCalgC6QgPLa5CpzQCjYSCX3QUpggCi1lCqwgCieLCXdLCSGpQzPgAZEADddwXEuSFnhkcXXxFTlLZ5v2Xuk7D8k7AyrQAUTbBUzgjWNEI5bitKgYMMchKb+R/5hcEEamikZmMEwB2GADmlbPgRvQAQUOBQU8mgcOWquWkwnPxmGr8AvVsA0ougzDoAzc4G0weKLKMAy7cJsfSG58YAY8UAMrvAJZ0AZ40Hi3RwM6kBvdcYqtFjBSwwU78AGPuwEtwAEngAJHUAd0QAf7NgnjMjoo1giM4AhPHLrqRAlTTMVV7LmhOzqki4+BgAd8EDl74F9bkAMqAAENYMZmDAFprMZpPLsd4MZunAEGa7A40LzBywrgZAkXhZl2gANjwAl7IAiiAAylMFiEOrpWqHiapb0zEArZ8A2MOnHxEEnBFRZ0gVOWpmk5e4n0YJTt+75fE7/zSwZV0GD2h/9W+Qcj++u0DvW/VeePpFzASEvKs7wEP7AbvdEbTpuYDXyLSlSriiWhE4gLJwqDGOy2GVwNfakMaCsLqGCyvCkIemBANrDCNPC6P9CPOVCmLEADK7zCNkDDNtA2rZYHQVADLLACNeACPZAETjAHqtUSjlCv8xqjjsAITizFlGAJ+gwtYOnPl7DPVKxOTfykoMkhj1OGesBQ7QsBC+DQDw3RD23GDn3GDeDQauwBQuCWmTB3hNwJl9AHdvAIgqACffAJyogKmwAJkbAIy9sHanAHVWAHedsGHkADQtAHx9ByHPVmyiNzl8ZxDgPUl3YPg2cMzVIGVYAEhtsFtbMFAdb/BE3QG0ZgBExA1VVt1UagBQFYW5hSW1jgqaSc1LnzA2RdBdUBBUkxgIkZqz1aCE9MCcH8dilYotlwl3vZl8PAC7SgCh6aII8QCHfgmveEB3qrA2dQkNihAzWw2CvMAjtwzivMAzNcS6wbEngwNVlwBm1gEl2cB138mfa6CPccpYzQuVVMqKlNqFN8epoZhVmWRAPnpV9mbkJAGxDgALjtALmtxrydxhYwu8EtuyqgBysdpYsANbilB74ZCHpQdP7VxfropbilWfSnu30cCc5AD3ahXkO9hj0H3jqbydgHDqEwapjCA2fQ1L/DBVMQ1VE91VV91fJL1VvdYF1NwAXs/4q5sy/0uy9mo9ZrvaNuPS7o5GyjEAu4UJco2pdoC5jghCCU4G8DNzXY0cUlkbfDkZR769g1sAIdwMK3+wELuwLdnAV3UAhKlGUsIS4qrmWzimLzHK9TTKgpW+P/bONX3KSjI4UZUhIBmy1q4KVkDLu+vcZqDNzBDbsQENwEK8dPDuW1pwI5oKZrauUQNQYgLrGYoA1KAl3G9d1sKFRvCIfSaObcIJHTILcjqQdosAQ2sAX1OTbv3QRXLd9YLb/eyNX4jSkB+BsTlTu7kztWsARqHRzCEatdPKvjEteuUgqscGPLIMK4EAupQMibsM+QULo/jgfz9zX1FLDzRzYGRP8D3HzOpY6wHfDhIo6wK8ACZ4AHKc4HLP6EAbcS44IISxoJVszPl4Cyvi6nwR7sAB3Q8SraUnqPvlmFfUBZr6vkwt3Gb1x7snu77hvl1y7HvOuwxBmGXdoH97gIOoDCFiU87UDmcfgN1AWD0eAMFlkyJ8eHtzltusmbIPmbzbKmONAsegAHSJAqtvM1ktJgU+DeTZDVeC4FeS4F9n3fBIwFBAwFAyno/c3fSGvouCwcOtjFkxUIjRDXnTCBqCALuNDMEJ4gSKZlA9dar0VPp4lh3SHDpV7isrECGbACuPvhKrDqPLDxWZZkTxijn/WApg2SvB7Xvs5YmyCnST9Ig6T/9Jlg46nN2p8r2tcZpZQ13NdOsL2LZrzr9WU6nDgyBrjlLNcJkoUKghooCnWXCqnACqxgbbSAC43wB2PMi36cCbxpjyOZ72K6W+3r5Ngu+LwoBEc3BUigI1RnBUgLBQSf8Hk+3/Rd1aMI8VCABWjw8AFY8ZuPtIU+YLMYlZv92V38TOh0tyAZpaqX8gGruBLCZWXghXcAYNShAzYgw7V/8x/AwjXwAW7c+xAg4iywBvrE4qXHuTGa61eszzi+9IzVCYP0oSom/YP1oYMEgk8P9f+s2vus2pBg92fqL7vTpXrw7Uua2s4G8nSHCnAf932Xtu+ftshgsfNP//UfDMMA/wQ24Oyzp70GK7uwCxAePHTIUDADBAgGCyJEeJDhwoYMIdDQwkUKEhsZtWixYqVKlStXpjRhUtKkEZNMUErRAsVlyJdo0mCBEvJKFTJkPu7kyRPKkidZnjwBQhQIDx5AsnBZEzRLRTVqyoz5URXpjh1ttLY5YxEMHDhs1pTRWUXLEx06cthgsaIGCxo0VqhYwaLGihUdCGaw0KABhA41siAqxCcQIkSNFEOCRMkxpEaMGDumZOnS5cubNG/q9MmzKNCiRo0mDfqzKM+fOq1mvXpzp82bLo1GxQqWLFq4gO0GNmwYMuDAfwcnXtx4cN/FlCtHNixYsOTKddRIGAXRwf8GGfQ+lNidoV+/EMCPJw/eRpAaGW1gzZKloxUtIUmmpC/FJEubNqFgQYPmyn4sbsppjJ4KrOKnJRIE6gmkGlRKCxtyyOGHJzaCUD0MK+LiLB6wWmMNLqBA4oe01IqrBhraskEFuupa4YO2+CLIAQs6cMABwFjAo5DDFGuEscYos4QSSB5xzLJLMomts89GI8WUVFJRZZVVWKFyFVVSMWVLLk0hbTTUUhNTtU9kAea45nwbDk3h0vztTWSKiXM5OpdLJpli7rwzTxb0SqyDv/7qQCBCCyU0A4EgQog8B8hb4FG/7NrBLhZs0KG996xwyQhOOaXvUywCzO8K/mgC8CP/MsYg0ECfFFwCiaGwwiqppyTUgcKOnqghrbdq8BUIYI+SlYsQO9zBhrjimiHZFFVo6wNoP8hLOwssoFG8hlTI4o9CEvsxSEoquYQSzI68TEnNVvNstFK2TIUVV2KRVxZ6ZYnFFVbyxZfKKN1NBRVTSimFNIEHFqWUM5sjzrnnnlMTOoaHc9hhNSsepk7l9LxTGWU0VoONSyqhDoIbIfgAB5RxECLlGVp2WYUZWFRhIL30UoigmvViIYgohgoiCKfaExollFQqWgqkSzp6VFJFhcklVln9wVWjjgp2qKfusIONO/Lg4+s7wl7jDDzy0IINru9oY42ttABiVh50iEtC/1/Ts+Ett6Dt4IMaOoDAgoUK+iBnPPhA7NvHJrMESccisQxdzpgUhUsqXbF8Fltm0dxyzl1pZcosu9xyFNDANM0zU3BRHRdeeNlll9Vjl3322FtnvXXcefHFl9xbz3wXX4Tp5ZdeNhmFkjv61sAC8ToQYoYchFg5ZeqXdTlmvLLHS2YWO8CL7yh6Hmr88bPYYgujT7ovaZOmqIlp+D9SddWof3DJJaGqLn8jM/S4g42P4QEPYfPaGczQBgGG7Q54WIMZNiK0YPEAWTlIS0bSwwO5sKAt3ttbn6qVnRsFJgMN6EAWCrEYyigOSZg5F7o40RnRQGlKq3CF5jB3Cxzewv8WmbPhLDjXiivxS0tcKg1oTJEb1b1uF7agXROdqLre6Y53vbNFMIAXvF8c4xKHGCAPagADDWzAASswQ1qS8gMhTKgqJVILG3VwN18pawYapIEKUlQDHmxBaHv82ROicL5OMcE+n2JfE5pwv/fBLyTyU1XUDoRIKIyvKFhrzxbMcEk2mCGAbciDAu9whjt8zX9hy6RQihK+nqWFgiSqIA90lcHB8QVGCOlAX/yyAAt8oEY6CAQKxxWJIz0uE8PUDCeM2QlOfCKGqmDFvWqouVrcQomtU6I0b1GLWvSwc0C8Ur+6VEMc7nCHqmMiLsopzifKDnfBmGIUXbcLXQhDGFn/rEYe3rBAPOxgBTbQAATwYAYaCOZS7nmKGaxA0KoFK1hs/AENdKBBFrxNj3tsz1D+CEhPsS8lhZyCIkPltJtUYX6O/A8iyUdRLViygWYQiwPNALZPLvB/drBChcxgwPak9ClceIIVqsLKuAHLVy/aW81G2AAHLAA8SqVRYAz3I8oEM0maURKTTjMKdzVTFj2EpjR34U4lLpGrm+PcvbppilPMQoc7XKI43brWHeZwrbeYnVel2E5eNCwYvKiFPIVhjGzMAxB+8EMe2oMEv+XgETiYwcrsAIQgQBaySQFWgyhb2QpmhEQSxIoRdkA+p/gRlecLn6dKgrRBlgQJSDAk//w++los6KSRPCFLTkTlEgtRVGjnU+kZtDK2NeDhDAakJFF+ENQsXDK5BuwIsRxYUwqR6Chv6ZOMcFRLayngAAY4wI0WEK0s9LIxlllcktClLmVilUupqFK8aEELze0Qm7qgry52d1/87k4XOHwdDrPJVcu1ohWnOEUrbJhDHo7VhpnbIebiyl9bvO6u+c2vMHxBjF9MYx6CBcQctnAWFqigCpR4Hsqkxz8H5jZ/lDzjDyREwaDcLQhY2QJonYLKi3ZhC0U7LWoHyVpDwjZU/gnJkNFQBpHSD1VleZqFnLzHlJ7PDAPkynCHyxUJWnBS60mKFqxsBi5ERSpVuOQlN/9iBR0AywZ18RsuG1CtBRxAuwYogHfffBAb4AERjrmEbIjJmdSIphRSypdW3wtF/iqRwou2MO++Sk25ipOsrijwMx2cYAUrWIc5DKsverG7Ru+udbsb3i9+AY150KMehABEIdqQBWAhYhJswEEOcDAGn9q0zHbQmh308GtgByIQi3jEI4BZGSV5whGvxnGzTSvlM/B4Jag1ZLWRANv+ELlpocpJqlbVbZDoBwpOJneUeWsGPfrWCC5wQQ+60AbPHisjLLgB0LZwhrFlsgxk2XcV1FDmM6f5CWxRQQaS+uYPNKAAB3jUAQpgLb844AMQWAEQAkEuJZ2XSaSBkqFvSFf/XHzVq49e9H0t7NdQ35eaX+0vNjUnYBrWy8GZ5iqDI+zWTuf30/clXi+MwYx52OMe9yBsG8JGiVF4ohCHWITjwjXVyH1GYLWJBW5owRveGAcSWYDDGXi7hWajD+xRqIgg7cPjKYwk7SNBAho+mu2Z9KcMsb1JbQmUEyR/ZFTlJpaTuTDcv9+7Bw4IAAAG4IAWdKoJRuhBD4zwdT3S4AdjeN4McODvS/q0IzpIiq/8hqMDIGS7C1CAAuL8KNJbIC8dUAEeMgMbQH+C41CqUtVxEc4Fi3Oa+EV574lRDGKgvGFT3Gs1M+eKym31mZdzsMsV7NZa5CIXupB+L6x//VKb//oXGP4FM75BD6HvQ9iR2AQqdvPeQ8cO68BYHft1w/7dqI43e+UFx5YBCyYgYVIrpqQexfdHLki7ajOk1SrAAqyJjyqLKigDqcA7u5ufVZktnMiJpimpccMCYuGCNEgDYskDP5gDBgAAERTBABgADYABJpgDOVjBTzqDG3CBvGAsD2AID7g1kTKDHNACNQiKGgCCvFgBC5AzhzMABjiAIqSzR4GABXAIFfiBQ0iXdEmN2TOFVZAXVmgwH7qcW6Cv4FETv/o9YghDYQjDOiHD4JMnX9grT9OFXcChKmEFWbAFXbC+AiuwVxiwVsiFV9hDmMMSy3mFWig1YxjEYzgGZv84xEOEhmiABmmgBm34Bm/4hm9oh3Ywh3G4DfnjjdXBnSZKPySCovbLHWUAjkrIvxTRrUo6nyxAJS1wn/vxApfwAlmcRVksstjaCTLYt25LlQGBQJwYqW5LpPvJjyHDwA90gcIbQRE8AAp4gBsAAxXUgjLzFRawPA+4JWxZgA6wAjaIEIo4g7QAghooOCVsAAZwANNTAO46gAbAJcDIABXQgTHAA0jIBNhgDSmEkii5khkSMH90hS0EHmHwQt8DvjA8SOU4yDOUp+fQL12oBVuQhVSIBXgRHu0bHmMgBmMwxEMsxGRQhlZ4hWRwhmbwvm6wB3pQtXrYsHkAB5acB0r/TElKnMlK9Ib3CwZgaBh3wgX068lPpCscaj9gyB1kUAZgyANTpIiJSkXzuaSxy4JDggJalEpanMX86IldHJBe3Epvm8ADETem+Sgu+EAFSMYRLIAJeAAHQEFOMSAg0AEWYYEfuMYGYEfxOIABCAADWMIV2AEkADE8CrGDYCoDQKrt4i6l8h7A0IE/QARI2IRPiLrZm6Eg4hyumqbW0Um9CoaFlKcyRLkp8rReeEhbiIWJdAVdqAZu+IZuMAdv8AZzMAd3ELp7SAds0IZ5MAZSSIZssAZooIZ62Id/GM592Id7qAeaNIeYTEnmnMnXdD9c0KuwYrk2dKJEezRe2I1R/+OF3+gELciCHZAQc/u6pkS38NGCqKRKWEQkWnS7AFkynKgtrczKrFSy1/qPsOyPNPCDGshLsxSAB2AABrAADbABJogCociChqKBmGlHpZrBBvDPACjBAmiAD1gtGOmbvMkOSGmAwiQZv4EWijOMRXhMMhmFQWMmeJmXeqEFWwhK1YErF4WruGpD7NQdYeDMhOw9UdMd63vIWbDCVRBJcPgGckCHI0WHcEAHdOiHcwgHbOgGaDgFY9AGbfjNfcCHfkAHeZAHfICHd3AHSqwHeojJeiBTMqVE1/SGbmCdasIhNpzONuS0N5UrkHu/7UQGXBCEHZS3viO3ndqQjQjA9f+MRfWsyjToj1ucwH1r1JyYwLLIyp64T5vAtjRYgzyAAAmdUAFlAArQgBLICjiSm5ZRgXbcLobwz3PMS1YdgO9igX76Dm0coaTClsFhAS3ggzNAjMr4BFigOlmInfeyup6sF3vBF9ChkkJjLxqynFjIHGnKzM0cvtBcQx1qL1d4hVwILHIQB3HoUnjoh36A0mtoB214hV/Qhm6gBmg4h3f40n740nVAh3Mwh3RIB0pMh9iMzXQQ05pk027AzFGT07CyU4PlL9a5ncxEhk8YAwfagbjIQEG1kAwc1DOQRfasSlrcwP7YxUb9WJ3YRa8EN1TxKCOTCbZZgAHISwEAAAL/kAAGqIAL0IAb8KwV4IsR8gAViDMDKEyBMIAJPQALKAABLYABAIAJHQAS8hslVELtKAhtTIgUAYLGLATIuIRPKAVYqDoWrTp7yReKLLR8yRKAIZ3QCA3SUS93qb1YmAVZiNbeoT/c8QX62iFXMIU/PIVjAId2QIdykId+kId/eIfftFJjeIVouAYplU11gId16Id4iAd3UId9vdd2uFfL9dea7IZu0Aa5baf+OljRtVPYUdiGAYZFGIMzAM8UkVjXzcAy4wKMPdSqvJ9sQwOP1cWsdFS8g1RVsS2QIpWmuV0QcbgCKAABCAAGkIAKYN4N6IED9Z44g4Br7FnuEogG/5jQANiAEixBIZTQAWC4aKmRWvoAB/isGvgBNjiMQICEStAMz9jar7VCVtCSdgkYMCGd1FgNY9oETsgETvBf9EJbtTWFKSmrsWqwzlkFAy6wkNQw2izOe8AGZsiGb2CGUwA6b4iGaLAHdxi6e9iHd1iHmXQHE3aHdw1TdcBXy3XNzvXc3PkqKwpdBHsw/jrY0l0nnCwFO3iCNhg4trAy1+0K5yqz9dTYWUSk29VdXcTFXATZfqPPMlDU+0TA2+XAujyAAxCABHgACcCACcAAFPCs9FCBDpiB6l1ZA6BeTZ1QByiAACi9ATje8FUAONbehSNQE5AWnOkATC2MQOADx/+AjVH4BFQoBVRIZIEBEzGBvWHKBMxYnMWpjMqwhEfWOGQ6DdEADVLoZNGBEgIjsFSYnC0JyVMgBpdMNXtASWmABm7IhlwwBpeMBmqwh1SDyVW+XEpE4XcI03fFh16ezRZm02u4BkzrHGSWF2TuHB8SsGdqGJHbjUdggycAESQQpL8T1D/VkCKm3SSGJC/gD/eMLbJQgyqoCn/LxUiVz9ydu1DZNgscRi6wAQcwXi6GWQkI0A1wAbt4JRWAAANQ4wb42cI7AA0YgMJcOBcIwgFQgBHQXu2dYwXQgBa4gfN4gq8JBCNJEthQEtWATDJxZEguryE5tqiKqiEhaSR55CX/GZPSKeD75ZJEBpgt6eTdzIZpmAZoYAZoaAaf7oVc4IYi/c1r4AZruAZtoAZv0AZv6Fd8GM5/wAd1UIfiVIdzcIfYrETOtVKxkrSZs6G2RWYbskzNeYVZGLVagB1ZKIU7GIozUAlDkoI/rVhi+TIzQOIkrkpxTkAk04mqUOdHxbuQFVlVoeJSieeXwAIkMF/SM0IJeOwuDqNJCU8a8ACVzUsD0NkFKLwBGNoFgAB2tAA7tmMTuGOIDgABkOgGYAEjAIM2MAxHgARhK1FKOLZFeAzcLhJGeARG6O3efgQgCe7JEBJJluQWShd8DLSX/hLmbpezbYVmqIZncIZCZIZk/yCGbQUHbvjNaagGnHYGaIAGbbAGbmgHenjq4TzhFHaHeo1NgLVS/ZpOLHQrG8ombMqmPZS+WgBE7cuFWnivS/gBIECaawaD09qQupZYKzOg2Y1FvA7n2PJYrCQLUnlisvDKJFOVbfsoCywymdgBI1hsC8AlEwDjCVieAl0PBvXQlR0AgYAA7d0ABkDoA/iADbAABrBjmIVoEpxQAUjt8JW4HciDPwhkVCmDOxC2AfqDIi+EQqhaJ49yJ/cWxXCEH9nt4D5plMYMyImc5B4TlzZbUQiFUCAFX3iGZ2iG38MTX0iGbehNnZ7uNNcTZ0iGZrCG7wvhfbjqyXUHER6Hff8dB87l3JQrufqSvvqaQ6CWvly4vl8whkf/hWhiBTJAgtbOPyYwcGx23UHlgtj9ZgdHYlKBVJJdwEYlFd6F1F/U8A0vKQ9PgzeAgzzIgxNCBH36ABPIdRiAARaAFhoYlAXoWVdFGaDVXgVQuOOd6IWb6NNu9qSlUAcwAjxoAzW4FTLgGjwo8sJhcif3A0QQNimfcm/pbSv/beCeDHDB7UpuoT9DbtVoDfQaE/4VBWRYhmBwBV5ojuDphWMYRGLwBXGSBeTzHF04BvH2hna4Bz4/B3UA5nPQV0sEWGwQw4UkhuzTvuALw0HcSI48xGZQxGjghtXkBjQvhR8oCUNaCUH/Wju6RvCoIBaNjcUv+IKpJMbXign9fDuR3QkI3PB3tuJYLxtah4RJ2ARPmIT1KAQ5AAM5WA8kyAEz5tkDmIE9wIGVNUsAqLOhneMB2AA4vvrwzcuF29SkXTgHsAEgMAM4QKCvaXvDcPLDKPJA4JG5j3LEOIRE8G1G8JHFEO50lyoWig3BR27Bz7hMsGTZGwVWCAZb8IVZgO5iIIVQQKZjUo1kIoVcSIZp+IZ5qId+ndypRuF7jXjOxYae/vjwDu+c9u5syAaRf/3VBAfZ3zDmBD+UBL95IPlFyIHFu+akQRqW7zsOJBYxk92YR2IA8XlXf7vXok9G0jsO148rQINY//eaP3AER6AEzkCFX0XkSvCDQsiDM+ADQagCQPFQD9iDPtDUq+9x1M7xAQjQEgzo8KV/hyvBq292V+0AIGAKD/wDgOCTh8+fQAYLETQYqBDDg4UOHUqUKCIiRI0uYnz0CBJHShw/UqJkSeSlkiZPlsyUKaVKSyUjidzUqZQsXLaSJfMlbJcpVqI+der0aVSpUZlCnfLVjBu9eu3cvXvn7pw7fO3SmRvXrRs2bOC+gpsndizZsmDF2rN3796+tvjW2jOXrReOH02MNJECZosRKUymAAbMRUsaLobVrFHDxQvjxo4fe8FCpgoZLJaxXMl85TIWNJg3SyYjevKY0mMua//WjCUNnDx/GFIq2WkULGDAaMFCVYljIEiR9GRo0GCBkD19ZhwYMCBAAADMAUAPoOAB8wEGAgw4wLxAgeXKmYN3Dj5AAQtMBPrhgwcPn4R/2Lf/U1ChQUEQ71fEiJERI40f/3cUUkiVECiSJQcimCCCIkXySCSRZMIKLq0UY8wxxOiyiik9idIJJ52IMsoonIRCyivGWNOOiu3UU89U6axozlbYXHMNPWWRFRaOZzXFVls/7gMXONlggkMOSDTRBBNaPBHEFkxwMUWUZxRmmBZcpEElF2igEZmXXWIBhWOeVWZZGlhwcYVhhqVRmGWZdSaZnKOJVkYZaJBxRRVyqgH/B3uBJMIIJTLRZtttqIyyCSSOIMJHH1V8AEEDEOyxx4OC4ADBcuM1F5512BngXQHjbepcdM+BV8ACH5yRBx53wNqerATNR18g9t0HESKMNMIrf78+4giAAApYrLEKHvigSBpFssgnwdzSyis4FVPLLKmwMswqn3AroiimkEJKLsdA04096cDYjjrnjDOOO+3ISGONadlzI4736jiPWv30s086W1FDTb3zgKPMHlXYgAReTEQRxRZmaHGlGVxsQbHFW2ixhRRY3llZZWWkcSeXnqGZBmB5TQEGEkww4ZcUek3hGBRQYOElZ6FVMUYVO+usxh0EHcIIJJZk8gkqtNhG/wuinVwCCUJs2JFDBhlAIAQmfWCCSSSYCKLCAqMKIEB4pwKgnHMLeKeccmGLHUDYm7rt9gALrJBHIP19xFAhFiEirN4PIbIII4HyR7gjjDhyuLDCQmKs4wKWhKxLyHpk4CjIFENMKMc4U8www9hiCy+2rIKtLKvUNEsrwhwzDTff0GOPivfIbs858YTDFTbdUCPWNwRzsw03w2+zTTbVVDMNM8sz4wwz19zTzzr42BONMb/0svwxwWBSBQ87JKmkww+bUf4Z52+xBfpPskxYGXSKpsb7Ils2xReAsfyyES2/rBcYMUNGZjPTk2h0ljMylIENfzrEI2JiNFjgAjelAP/KJihRCFexoQwq6IAHIsGJrIFwDziYQQYWEKrxiMc5yylbctTmwrYFgAAFSAB4CCA27xigA3xoRN4Y0rfEOe1vFUGERAZXRMQdDomMa9zjHHcJyTWRiZTIhCuUkYxT9KIZzcCJMHiBjGAEAxi4OJ0tIsgLXiijGdX4hjfakZZ6pKUd5wjHOriiu2Q4IxvE8IUvgjGLWdxiFq5wxR9fcYpTtEJar2BG9PrxDnpAIxe9yEUyiMGLWPSBDDpAgl/alz7ymeF86FufyzgGPwS+jwxcsswXWjmF/klhZXp5GRj+F8DGzGyAlBENz+J3hz8JLTazKQUqijkKClYCEX4YyB3/aDCDGWAiFNIMxQdFOAMVqCA4JwQP3JxjgOu4MJxuS8AB2sYdbrawASzgAh8c8RBGHOIPiTicEIcokXsa7ldJZFwT+2ksKXqkcRtpnCU4oYxnPMN5yRhGMpShjC/eJhayqIksbkOLYTjDGdzYijvu4UaPbkVGAMOGK4LxDF6ozhWskGgsWLHSWKiCFKdYBStokQtm2KMf5diHPaaRiz4iI6iiqMIPgGADLWTBCFc6w8vIJ8qnnkFj/gtZKkdjJ9F0hkuBeWUtVdYXWNpyZowR61hnhgQoHNCApclZGXzGh0AcIhAbcckmZNKJum6iaYHgwx3MoIMf7EEUpLgaJ0jB/4k+CAEHOPAAY4cTqnAqxwDaKRtkv8OdUWFHAXA7gAIO0B3lLCAHZAhEQRInT70NsSL4vOevAnW4efIzJI2T4n+KBZIA/Ucjc7VELJ6BvGIANxnF+GIYgSGLlq6UFbCQ0CyKUY0adQNG9aDdjNrVFWzcoqTL+OMscBGL765UFrkhJipgQQtcMGMe++gHProxjV3QIhYShMQPeJCFGmwhC1kgDBiUpIWJceGpa1jD+boKhjWMLMFxugyXmhAY/6lMlixrWczI6gUxlVWXOjPNzng2BjK4FQ8F2VsjQlKSSkwixcq8gx2cuQdp7QECHtiD1vYwhhF6AAIQCE4DHPBZtf8d4ACmqo4LM8sd5QS5O+RRQAE8ix3rNOAAKrCDIP5gH0agNrUQWS1rESeRxPFwWADyT251O9vZ6lYjlIDQMJZBjFcIwxeeQ8YwwrgMXLDCFNhyKSpSIYpZCKMZ1thdOvDxlq1cwxvjuG4qZCEKZChDFJLm1l1X4pG9FaJxmKgFOKJnFWNEog84iFoOdPC9INSgfOUDDBg2BuCntqENBDZwmxK8SpIxeKtdlYIR9gdLKTTBwrnE8Fj1tOG1drjDY0jgD7LABTWwAVZ3eAhDeNiIQOhBD9cUgihcsYcc73gGQtBDGewwA8bmWAU/gMABQnXZbhJZyZw9cgGY7NkBKCD/AWHj5gLafYDQ6gFQ99kbIvR2n9UG7VcQ4c9++POI/gwUEhtJM5kHuhGPwFMQA12zKIIRilw04xc7CcYweIELZOACz6lABStKUZRUuGIXwnCGNrBhjh+1YytbWTQ28AAEHeigFJ54pgpWoIIPfGADGtjAA5Zegh2MIRTcsEdb2sGMhUbimUjIwg5QzYJQnsEMrAYDVEUZ61l3tda2zmpoVKnrWvaPf/07Ky6hQPe66ynZHf4B3/teBSvsYAc8eMITrGD4Xw4kEBdBRLYViwNOiCLGSbeAjjuwBDhUIQc4HiEEFtDvdovzsdzsbHICQM5717sABCCVvz0gWRX0IVcQ//lbrvCZ8MItvOH9gbjEB/or/iQu+MJPnEEW8YgwW4IUoSBGNYzhizOCkRdgDAYuRDSUUbg0FcFwRTGicY1xxKNf+BiHN7qilW5oIP0W0AAoGjG1qWngAhWoAAYowIEX3MAPgmhFNujRFm9oQzZ0jiVUganZgA3UQKqVjxZAQROAgRzE2lMZxoAVWFcpGNutklW9HRi0zIR1IBPcXVkJEBRkxmgkW9+h4BMcYODxXeFJm2tYhCMIwiI4XiiIQh9YwAbAwAZ8QDZBQMJwQWLhwHEIx3BAwA90ANqozZE1h3gIgHIUAAMkwJEpAJM1YXV8E2N90wJ4AB/IHu3VnkQkXP+gTETQNJxGQNzD6VMSDc7CfVkSQQKgBAIixCEkLEIm+IIzVIMzxJkXec4Z4QIwxAJRHBMtLAOipMIsJEM1dAM58Ms7tBeNYMOiaYALfAAL1MATwMIk1ADQ2UAJmIALvIALwEARzEEjWAKnzcNa0AMbRYMzLAMl3EEeENgWBIEEakFToU+AnYFhtEGrGdgqZZVnqB2X2MlWsZr/gBUYQIaFOcZm7AwvRaPeVYEWIMETaMH5rMF6GMbPWERsUMIjLBYOYAInVEGPaUAJdIAOBMf6WcAHzIAd9IEHDEe/zUCozWMLoRB08CMACMDpKQfpwZCqLMCkfJMBNEAGsMEi5Ar/wSFCRHDZ7yUO8DEOEIkZRzQCmGWkI+gHRgjf8WHkI2CCMlRDNnCDMyTDMkAana3kMogXLNQGMhiTKvBCNawiPvDLPrgD71zDVtyAC4BBrAEBH8CCJ/zAGfBADfTADfQADNyAEZxiJLwCONAD7dyDN3xDO3xDNvzGHbABFyBBECxVL3KBXqhPVPFiL66BgYHBF7TJW8JlGiTYMSJjqy1jLd3SLaGB3png3v3AEyxBFpjPNuLBYJgBH2RabJSEIJybBwkBBFiACaijDRSdCYyA0nUADahBpggHpURCpdgYPcIN2zyHcwiADUmHZ2EWqLRb51mHAXAhHzDkwFUEQ4oh/0QWkWvtU/Bl5EVyBG92ZHAKX5g1goOEwjNkwzQ8gzIMV1CpJKTdhm3AwjIsA25wSyokA1OwRTzwlDloQ41oQw8wgRyoDBAgQSEAgyasDBgYQRwwgQ3sgBH8gW/UAuykxT1ggzdgZTDsQbbdARcYQX9NQZuUHVqKEhdQYC0BRivFpVxySRrID13CnV2yZVc5RivlpRd4BmiwnWZAwRKA6BMIpjauhxr8Fx/QIThuwidYgqVkgh1kwAfcQAvgVw24wBy0wAaUgAas3wdkQAdAADRdDWhaCg6gDXY84b6hynYMgJJtR7s1wAyEyjcdwAzczULQ3mzW3pYdkW4K3398Kf+YTqQSseHvXYSwOAgm+MIrkEIzKAMrsBwyqKShwGSd5oYnhEQnmMLMtcM9nMM7OMU3BMw1KAEVzEETyEEeyAEc/EF6IoEfQKoc/MAdVMSa9QJVrkU7UMM3aEM1YMIY9IEemKjC2M+AUeAZxFobiBKBIeiAKegXeIFbFuPIQKga2Kr9sCWEGRgAYWhjtBKsjsmDyiVqwElmMMl/ncEatAEe5AEbrMEd/AEPKeYmlIIgqsINqkCN2kAc/KQRJB0omoDSPcCOjcEHPUilaE2oZcq9DYANsc2pKCkWGoCMTSlC4sCVNsRCyB5cyR6XHhESfcTwBV/ABh+ZKk5rHcLe9Mf/gxRJHwSDMkSCGYzBJ8DCinZCJXiCJkyCJ3jCJWzsH/ABJaDCKeAROHTDirTDNVDDNfiBImhC31yCJ0wCJXiCTOKVJwSFiKCCKzSDvqwFT+pRf4pqFaQBy8DB0Q5YG8iBHMRBHJAnWz7tr7rBF7hB1TaoMdqqGlDt1P5q17rSgnatr/ZqY9Aqrl3BAGnGsaLqsubBMgGNsMTGirKCGOFCMMhCJ1ACH/CADYDBU0oBC5RAC5gACoRACEiABmTAjJUjCIVC1vRBHwjCcZhQdxCAu8JQ3ICKdXiAEmbhGPzBI+RrQfQrRMpeGUqE4PBKcGLEbxIsRw7fRk5kIjDEIcyg/yAIgiV0QkV1AiY2QiWgAiRUBPAiwiRUhB9oQiXARiYMQ0JdA4ykQysGTHmVFzDAJPXC5DMgAy0gDfVqb1BVQ1Xy1DdEQ/N8qqh+ZRoE5dGqLxwsbfvWUvsubS1xrRxUrdXGJdZCW/22UtXej9cChv4Ca15uqGoMcGbkkhVkI9tCKkEUAuI0ziVsAvbZRjA4pzKggiDQwBeAAQzgwdHBwAuEAAi8AAboqI+qAI1xwiE17oNgTSRUQQag3mmGjb6VptpwYXJsYQ7YwSHEoUHIB7/yK5du2RBHxCEsguCobkcukcD+Jm8uykQaMeTa7iUMiic4ASEQQiNMgiYUwhx4cf8gJFMbxMEF+QEi3M2zYJQ2mEM6vIs2UMNt1Eb1GgowIMNy1m0E2cbnfO8j0sMzFAMu9EECsUEeAGg2wgEbsMHRuu8iP60c7O8XrAEc8C+syqratZWtanAtPbL9+O8kB7BevsnZXgGuYUYuBWaAKTCk3g3iCNMoHA0dQ9oyPINKjoIlBIIO4AENrAALmMALwAAJnAAHlEAJsAA2zYAgfIIpnAI1gZAg7IEQkBDaHNlpjg10DIBwPNa8VoEeJAIkzIroxhV9jO7BGbHgWEQSr65vAsiZBp9G2K43+sED1oETzIEfREEXL60iENwfpFgXtMEcaALHjgJDQYMao4tW0Gn/0lTUBNfxMwyDRNUEMAxD/7WFO3CDQ3dCFcDBEuABHKQMHDyrVyqyG7xv/LZlW06tGzgyaxxtABdjm4hMytwPJ3ftGgzogLrlF3QJmGhoT9fMFfR0l4iyzZiV3YnolayBHCyTazSwI8TtJ5QCBEHaQTmDFlEnMFiCtmUrC5SiDITACIyACXTBDbAAC+hADmCNYJVIKDzujc0ADagAuw7AExIZczxWZKkAG/xB4qwHe7xGXM0HyBpEXBE2OS/CROSHEm9kmD3xl2pkRQJff7QHs46xIsSBGDiBE9BBHEClF2vCJuLB8CpCEoSBIkwCKCRCJsjCMDCDNXTDOLBxOyBK/1FYH21jXyqsQjAswyr8RCmYQissBT0I9zz41DNLcv0u6hsc7Ru8wVvCgdfuL9durVu+ARvIZRowd3O/wdT2NNVSsmegwRugQZuowRuoAYSiwZ2oNxqoQXqnt5xgwclMgYM52Mk0ARLgd37j9xSodB60rQ/BLQQbTSyc3EM1lBY1Ayyuwm/kQAdYgAVgwANgwAQ8gAtogI/WwAdwkBB4kChwwmfemAeQwQw4lpMSmdo81gEEqR4IBGnJx2soxIiBIURoaRFPxL9SZMGS6RoKH688ca/8x+IhAsYCAh2IASFIAiEAAiFYBIHws2kbgiIAwiSg2CawgisIwzRog1qsRf9dqURJeHkmBAUnkMgsKEMscItgHcNY3Eg1hMIY5MBx1y9zL3d1IzIbTHL96rl0w7SdqF2beC3/xirJjIydXBUqGfolJ3oqxbd9h0+S4Pej57eDUW2iQiqAP/CKloKEkFwxHDiCO9QwbEKDP/gGYIAGTIALbEANZIC3Hl3icvgH9YGN4UAVqMBwJNl3HKR1eF5BNoAKjAGLv8aLv7gP6+voHrERG9Fq/V6ON/uzSyRH6sdGWJu0Q4IiGIIkSMKRZzsg+MEfVASBKEIlGEIlEIIiOI0nwMInuMIi+uw9RE7k1JVQfEIoKLMoSEtD8cIu9AI0jAPt3IgziBoOyLn6Knf/dt+5Guy5/upvrMrlJc8qoIctY2zoMKY3L0WonWStxh86Gjj6o983kkA6fveFgk6BpV+6wg4NoaTCd9ECyU31Qw3DQ7ECJUiNjyqdEZgAWe9ADbDAB6yADXRABuDAERuHM9NjQfY6lR7kpOiYjI2aHegByEJq1X87yP7w7OZKsguOROhNl/E4tIu9tFfE7yGxkM8BHRBCHQyCIYCCJ8zBFleCFoNC3YOCJhCC705CiWWCKPBCHsXOPUgvTBK4GeECL9RZMPARMeBRNUQDNZxDkNADOOhCYs1Awa8vwiOywi/8nv+qXEIbGzR3g048Y6gdc5O3oduqxm/8xtuJx388/32LPKT3mtwFRn+37dUz0FP/hCioQncFQ3MuFBg9tCXwQQ7MwApIgQ30QA/AZ+DtwBysQAfMgB2OgaV8m6QMx6TUY5AtgIzJmAeImx38QTjPykB88w9j6UPkihExBGsRjrO3VpeBPa/UJn8cceoOESBUAh3UgdoDhCRNgDTBAgVrUiVPniolrFQJkKJJnkql4uWMm717wIANQxZsWLFhHpWVHFaSWDFixJJF66bO37552zDhwDHjjZs3b+D07LnzDRuhatwUNWr0y5ejadKoEcqUKVCgRb1U/QI0jdQ3TZ2q8foVrNcyZdB8AXMWLZgma9muNWKEiRS5UsDEVepGTv8eP3D4BGIEyVKmTZk4fRKVKhYukCNFggQpytIhKzaMULlhZEeTHnE0fPjRCZIHDzlyiM4AAUIHCA0aLHDdQLQHFR5mjBEECRIjRHl49+bDJ89vPn+IFw9U6FDyQ4UKIXL+/Dkj6Y4YJbIuvXoi6da5a2/0fVH4RYwWfW/0nJAhQ2HEhDkyB9AkQoTiOElCJ44fiZIAEVIECJFMUiGmGnrsQcYjZIpBJpkGiykJwmWUSamYZJrBZpx/9gEnmT1+mEEFONzwiUQ4dhKKDTVyOuqou4pKA0U2otoKqp3cSMoonrQCKsawvkrxqzXwSkuttYpcawom3pqLLrimeHIKvLD/eAOPPw75y5JILLkkk05GQYUVxTwqpsJinllmGWAuIeOHPHpQwgYkwJjjgw7IuKQPDzpwADXZVFBhBtVYYw0C0QCdwYMqIqGEkkkaAS4PPHrLAw5Jg/vtj+H+OI655qKDLrrprsNuO+4O6c488RZ55BDzECkkkC7mCIMOGWB4QRJDSijhsiKKCMMPTegjBBA6DJnDD0o+GcYZbdpBBloIn2mmmQYhRKYkbJVppll7+rkHHFJ+yAHEEkuUSiigzt3ppxNRlKpGrI7CCiuosjJxJ3uzojGNNcxCq62Am0hyybSQgIuJhOlaAgo02MjDykUEGY+SSzbp5JNYaFFM22SU/znzGWVisYSPGnagAQk5asjgg0AyqaKDDzSwoIEOWFCBBh1A9GC1QkXDQQghZtBjy0YhyRSPSvFY2qelL9V00049BRU67BzprrtTE1HuOkSUOyS8R8ozL5BNE3KihxFgKCIJQwihow4fjihiDkLmgC+JMBShD5JLVkkmm3nQVEbCj0MOmXAJFQ+ZW23u2ceebCL5wYbZ7jCXRB7ZwPzcqIZSY980zLXRqH115JepzO2tt99/z2Lr9YClUBgtKZA4+C24pNiBhyWuUAOP4YKfGJKKN0EFFVjELOmZZ5xZ5nllcPmEkhxUWIOFDz445JIcZNZg5hVqsNmGHGhA1AOgbf+qYg879FjEkk0uabSQPyjF3FLhiouaU1AZmRoR2MGaqb6WHO14LRDJCdvYEHEe5xSiC0aQRA9iIAMlOAEUhIhBDMQgBrr5IQzECoMh6uCESVyCFcziRjBYGAxc4IIWsQAGK2hBi1SwIkykEEUuitGKV0gjHfeghzAEUQg/aEEHlytR0nwilDsokSecQ5dT2KCuKLZrRUfBXL5Od0UsMsVfRGqCWmI3BSPNTi61o8tZ0tivNayBDcGLGiMeUbxLWAxjpaBhR0JSEm4540zKCIUQ9LCCDGSgEIzogAUcwAAFLEADLvgAIw8FKCHYBJN6+EPfGPWdVwFnaUxs2tM2FQj/TnGKOVXTTdW2FghTDfA6iRCPdB5RS1t+BxLnaUQQjGAIOjgBEEfwQRJusAEYyOAITqjD3dpArPhI4iAZQ8YzPlFNTgxmExfjUiYoEYlIYAIToXiFMZgxjXZ0wx7gCIUg/CAHLvyAcySKUTx9IhWvCGV08GLRiLyIlcz9pF1QmYIcxGikIpmxCQmLCxvBgMaGLokLEeWCGuB4h+AdB2yO6JvFPvElWGwMJNtyxkiTwQxl7OITQtDT0bSnAQc04AM3aAEMsle+GeBgD3sImhDGgAM7HKJijHLEA/kgSnMFD1PGgVWnqCYdVpoqgVvTmtasEx7s2PKWuGkEJBDRBmGF/6EITuggIHoAAhOIQQbKJEQlCOGcRoACGJW4hCdQAS1LMMpid6zEq1bVhz588xXMiIY3vNGNetCDHswQhCDy8AUyVEFp9PxJjChbWRmxy0SZq1dR8LUjrYxIRDdCSlKq4oWBkjF2AnMLXIhUl7jMjglgiKgZzlDb2rLhDsM5zlZxE5hNdLQUYKJFMB60rWo1aBi06IQgNhEJD6xhBw6wgAlgAAMqsKAGeeiDHYQgiD7kNKcqUEPxKIEbRhwiEKCM7BKFAzVT9q+p1AlV1pKTwAJWdTy0fIR0wgaJOm41EH6YVdyOIAlYVMIJMJCEJOowCEMooiGa0IQnNAGKSlQYFv/AgIRDJmHHWi4inK8AXDfIgY1wdMMc4+jGPE7h1zykoQpkuANvJOuuO1i2spilURRrxBTO5st0OzpKab9QWiNPobWpDRjt0gLbNIJBDmd445TfaAYzrCG3fyhEI1Zlx4tV8xN6pAUvQlLSY4gEQcFAhilw0AcbfIAFO2iBC5LwASjw4X3gxIR3v0vI8lJHOqYEZSiNWqnhJJU4qKSac5zK6OxA1b5fw29+SdXf/xZiEn/oDyHEQIcK7w0QgKjDqA0hiQYmRBMPScglSgELTUgCwpq4hCUwwYlT/AIa4KDH48ixDnSQIxzuaMc8mBEJQcCBDWQQQhXiiAcnJu2JmsX/7Y1x/Lkgc+Vz98zijVxUlKSQ9i5Ftsq3yf0vghoUdlBC8pPRoiTdnSXKa2hDG9Yg5TacwcpSzu1vAkG8it2xSx1NhSzITKZhJINMFlIGLThhBx2wIHsruBkeBLEHTgzjFKHgBCYiMQYhBIISAkRv2e7XxGlblJRKZc4AO4W1TdU30QU0YHKeY56t1tK/dcTNJAqR6k3TAT6wBsSCwwAIQ6T606Cw8CQmgopKKKIRlKA1KYpRDXDMQyP/8Ic/4AGPd6xjH/gYBzhEsQc94KEKVRDCD3CLhxsrMdqdfcMTqV3tFDEFDVC5J5DAUhZxe4HcRraKt8fNom/DG7VEQui6/9M4F4QxWd70PgMXpGxl2k6Z2rm9UvEWFZg8siIxClJGg45RDUBKLxN3uBmgftCHiZFiF5wIRShEkYkxVOEQkLhSdcqGtBK1PVL505QpkZOIlVtHasc3/stHbkqZf63mnuRtznXeiIdUYj2hrpvRBZIrQ/RHwhdWOtMbMWFvYkIUxIgGN+aB9cft4x/xhxw92iHEeUxDEHaIoxnG8AO2nxxF6G5zgOKJcIyKhmIr0AANwmIoyoAMxkIBFZDIBI/IbkTwWqTIzKi1xshIFq+hnowuXksKnsQs5MAEo8y2nuAJskALuKAF0wAKoIAM2ECTJmZitMTzPkEVVkFMioFbnv+hGkxvGZCB4QRhDGZgD86PF1qBE5qQEwShCtQgERqBERwhOTJFvXpiaVCON9pLt4hvOZTP+GBJqgrovZyvgKJPl74DqxgllxShbhZMEtLDPxasrZSOrXJFEp4O1SoBFE7BGKrBG77BQNrBHdwhHvpBETXkHuzvG8ABHF7BDvTPDO7ADHTg/yoF2YICDpSoszpxE6tIFGEkKNjlDRSwKVKxitQAC2IMC7LCAq2CAsfNtGpxCmzRFtdojcDACD4QLb6AoBqKSGLrLEgQyoLxjSYvorSAGVtwDXRAB3igCtzHr/TA9R5hUbhEFExBFRLjJJqhGprHeZwhW1RhYpzwFDL/TuMwwQ74YMsawREcQdCwMFJIxKIkxQt1C1YSSAy1g1SyRjvqC+aYT4HCw2vcSpfEZhFwo3g6bBL+Y+geItTsZq0o7CA8YcHUgxAEAhQkLOzuwR4M0R72gSTjDx/W4R3eoRHpYR64gRu2IRImke4syhN9YkRukkU0UUR28iZ58ia/LSdE5w28AA28ACpicdz+rtzkwA3AYApGkCmdEgy+QAqagC7WAAywkgukYAvu7QzmDSztLRltiyzt7SySYg3gYA36JQ1uMUfu4I2e6KLApo6kzmIuRhRKYRVkARdGAkKohVuU4SNaIRT0TPY0bhHsgAzygFHK6zyYI73yMdHe/ws5YIWqqqMQ/PEfy3A5yqYP8jE4UASp9IA0rfEz+6IPiIM0f6MQIAFWiOUyPAEYXK2t/CAQQAEZNMEPHkITFGEPU20PH0IeFJEkSTIe4E/+3qEezMEe7IElqyEZbqEP9IDuQqkNekKLQmuftpM7ua3clEIp08ALkHIWAe/wkoxI6IIZJeorvbIsbavelLEs623K2mBE0lIt3ygN0KAnY0QuMWXz7Mi3DMMUaGi4yqxBmgFaGgThXkHjDjMmy6A1IcERHtOU/IBSJCWUJPM4Simq/kczr8OAqiMMF2uxTGkysbCU+KwP+k05VMVE3apsCOEDWqASMuzpFEEREGESNP9hEoYOFPbmP3wTwp4OH1LyEN3B1xQxHoTtG9qv/bQhG3qhFTBhDKjzcuaNabQTtLrTS71NKWixPCdwTI/sKdmN3dJCoiJKysayLNdUosCCypJxTuVtykBRKJZGS+HgOoPjOBBBo/7CePJoFBCjB5OhYxi0QXxhFlyhFDbhEQKBOpYPQ/FADuBgCnayJ+TyaYoKqaImDJujEbQD0CrUgRqBqRrogRIh+hAhPJJjHwsyv8BmVdyxL2zAAoxAETCyN/cmRz3BN19tPh7MbXQ0H1IyJdUhHMIBHdwhHephHr5hGo7hGH7hF5KhFVRhD8bAonpCS5koO7+0O7/NDcyTtMr/FF2PTGF0EQR1kSmUkU0nj7bwzfLMgAvslQtSkU3p9D3rjd7e6OTaAA/AkmAFNji0rBECARHqEo9+axQKdMwYg/So1UJGChlUgROMbb86E1LgIA1eMCgspVOFowsTbR87ZfcYweZwaWWd4zqoEGYd6IEy5Q8CjQ9wa7H6YAzswArM4AMyYFgFAhD8oD8QAcLmUEd7c8GebiP5gR/QYR3U4RzMgbBaclpzoRVOQRi2dkFEAQfYridMUGDxgLNsUlwNb7SUgkYiEA2wAAvaFguqIgbTdW7XQgRFkI2IkQmgYD3XU6JakBn5Vgu2gCvB4AwMVwq0gAkIl3Fti01TRy1//68Acasn2lTeDhZiCmE8tCQTBnQbaYgXgkEYVoJaj6EZmOEYbiEUIkFi/EtifoPu1IAMHlANUM5pfqML+eCJhCO9znA5THRiXrWITlY5zvC9DiFT9AIyNeUO2vFmTXMP+uARCkFSUIEh+mMO99A/FMFthk4Tjk4PS40d2CFqqdYbXHIajCEXXqEWdoEXtqUkgqEPvrZSTlAO5q1ssfNsWyRtdSIN3DbvItBtryAGC3huSwsK5NaAmwAJXot25mJd97Zvm/FvoWAJGEahdjFvmUQKKK+27OVOo4gm3W7a2IDy6nPeuCCO+EAQDuERKOGFA6MwtvEUWkEXRpcYjMF0k/+hF1bXr6RXYgJhOpsXz+5AD9jADmqXDehzJqctePCAikhJd3NWiIG394SjNPVgErfYojBFYQHDYjJBjC9mFFgBFWSBI4ABWH1zPuiA++ZAIUKtPyphwSTMEC4Mxb7hG65hGpyBGf64dCvEcCTkE2aABmgADk6QYL0UR7gTR8rNPBXQbScZCwj4dpAgBjHZgL3AgC8ZCm7nLRIGYeRCYTL4b7UgBltwGS34gkM5jdRt3RSmBcViLMjgRzgxjrA086rADNTA8rTACnLgB6qgDEjT9VxvVSxBhkVBFE7hFXxBGCokGY5hF0SB4wRBD9CrqNjADLTgCfyvZ6tgXEjjkGn/gDTIeacu6abK+ZzNRwEfsAzcB8+Q2ZukTpkJwzBKwRT0GXlKQY8+6oVeKI2RARgIGhYMohHexgmcYBDEwMEkLHkeTI7rgA4OQj0kgRuyYRqYgRiE4Rc8enQVFRmGEBZQQQ9AhAXWQGwXeVwb2dsID/DA1MgEOAav4AoumAdu55M1WZM7+ZIvuQly5/GkYElgiwugwAqSOpWbMXAvmG+zgG8jKg244Aq0AAtc0IKRWpUfcHbLQNs254kmkTrvaQy6+Zv97wfMGQdyoAp2VotLUxCwsdY44TBcwRZCKhhcATKmsy9u9gloQAU64JA6AGdApAMEGzUSGzUaYLH7ZK1t/0II1MAaBcF4wKyjvgT0ZIEWZEGzNyZ0W4gXeCGgayigX6iG0ng2aQEWPCEQ7EYJisAEXsChB0IR6oqtuteNjaXUDOEZksEXfjukm0Ecz2QYZIEVSmEUNuFmzyALCnbehGR/RYsqSittq0KSbRq7K9mSC3gWE/h2FPgLkAw9TfADuSALssAMnsAMgGAFbcC939sGToYFZoC+DxlE7ns2zkcFJG4FDsWQ67ucD9l8yNl8bIAGIG4F+PtP/oQGcEC/bwqy7cD1GEHqMsEwRIETMiESTppnVoM1XGMBDoA1DMAAGLsBRJxQCkUFgEYI9kAQzo+uReFhTSEVViEWYqFRXf9hFm7hFmbBx3/8FV4ha2sha32oyFmIF26BFliBsznbjFEBuT9hEzxhIiYhDrqgWMSgDsSA045ADAChbjqy6EQthNKjDubDF3TBFzzmB4HwGQj6UeenEzwBEvAA37TAuZeGKffXRRo58EpLkrU7Bif5Cn7agDMZCbxApzk5pn3xodIzcc/7CYAgC9j7CXiHB3ZgB4CA06HxB3RAmP0v1NGaNHTAvaHR1GvABjDx09sZ1O179erkkA5JsWsdNWbdUGbgB/TgxTFBjPdsBk7DA06DUDxACOzAJsYgB650EQTjE2RvGxEjFpr8x33cFq7dFmohyH1IyFvB27k9yLf928P/fX1zoRfW3Bd2wRZWYRhwwRJuo7zKhtLbIAp6oAeMoAeGDhCKwI0BwQmOgCAMwQhohQ60nA4K/uAPHhCEgZzEUUKQQRasF+kUocI0IRDuTQvM4Ln9VWCZstvGdTu/MymwgAwIvaavoJK5+9B3Ggk0HZMxeS3oYnYQ5vGIsQXbIAukTOe1oE3b7l/zoA3SgGk+dgl2AAkuuA12IAiW3gZqwGRMhtN54AeAQAdowMATXAV+lk8U+8NBPMQP4OsPQOwXwGdwwDbm+jCd8MJNgcYzW2NI27NxgRdcoRbq3u7DHe/zXu9fIRf6vhes9ReMQfCp9Y+nQRqCcBqqIRvIUbRl/yHDICEIoiAIwoDyDeEIeiAM5oCYlOkI4KaDjIXBxCBXFjoiPGihi449AEEMmGGkJCS5WGG1LwHp6tjizQAP1iDjN7497dOlozttye1/S57QsdumFx2BEX2nE7iADyYulCQujEAuloQJznsNgIAsM76iBLANNJioD6bld6DpW74GVuADEjzBPyDr0f9PDpv9Bfs0yH6wB/tPZiAHeGqyJ4YSnN0USKGGd9x9eQEgbO0aaGvWLFe5bNVSaCvXrly1dOmq9epVrosYe2nM1euXR2LGjB07xqxkyWbRrGnjpk1bN2/evsn01pIbTG7XqmVzRmwYLly0YBWq0SKMDzFOjv8WKeJDRowiYgzROeKE6lFQmujQARRGSZitSOmI2eqkjphlynChGtXp0iZPlTx5mlRpkqK6fNrg0ZIly5o2gAO3+fLFjWHCbggXVlw4cWPHX7xIlowGTZkyZLBo3ozlChIkUEKLDv0Z9GgkO6Ys2YFEixbUrJHw2LFjNgsdNH78sPLkR47fwHP8sLFiBYvjxjN8yNDhg4XnGaJDgNCh+nQIGVTM2C5kzJg+ix5RomRpU6dPo0qhkgULFi5g8IEF+xmsfjBevHbVqjVQ1y5evvgikS4a9ZKRRr909AsxHoU0EknMQANNNClpI9OF83hjjjnedOPhS+7cgw8+66BzDkz/KKIoEzcsVnNMLbzMB8sfLHyAgllH0FGEDEdIcoQYR8iA444/lkWIE2IkEQYgWy3pBJNiQGkIIGttUskllVSiiSaggDIJJIooMskkgZxxxhN+mXHGX4K1YdhhkjF2GGOKvUnYZJRZhhlnlWmG55+TmVYabDSwQENtO9igqA2FqqDCCo5GOoOjGUxX6XQedHBdAws0AIGnC1DXgaM42NFHH38w4lYm5o2CCiyy0GIfMrQio8yttSIzTK7F9NrrMMEII6wwxBBzkYK/CJusSCGJFOGE0UjDooXgVDvPtdfao+223HIr4j7vtEOOOeG0s88+/aSb7j31tOPuu994w2I2/8kYOAwwsghiAwsbbCAGDD74KIMPPcQggwxLCRnlWHU44bAYc8xBRxiGVFyHJJLUAYhZSGqSpZZZTnKJJpMU8gchHkOSh15ctIxEGmmswSYYYEAWmRd1zskYzjrj+UUael6W2RWcTQYFnlAMipqiidKAxL6QdhCdCtVJbamlnm7qqQcz5DCGHn3sAd4ii0TCyXmdiJIKK7TIgot9wQwjd9y7+tprMnbnfUwyyRzT60gOPjjSSRKWBI001lyTTTbVgjMPPfbcI/nk3UY++bmYZ6555pOzy6479Uh+7j//9HOPt/bUcy043DSToDC4yPKI0y1sUAEMMqCQOwy8+xCkD//AR+nECy8MUodZgMwRhhNK0GFIxnQgH70YYpBcV5YeT6JJI4ogUgkogDRihhltZPEEEGbILLOZawLtBRpfvPHz/PKn8b4b9XuRxhdovO8FFpMB2mWEdgWidaYzUOBBDj4zG0YdhwWTqk6mOuCB6DDHAxjE4KhmQIMcVIENejhEHx5hiUx0Im2oiIXb4HOfYPjKVnL7Vd5mSCxi1NAYxWqWDps1uGZMSCfVuMY3rHUtehgRcpTT1hG1dQ90qUtdmyMd6dIlxSpasYrnkpwR22GOdoSuiVLsXOfoca1sEKMXwggGMD5xJhdsAAMVWIoTQjACJxjCBEYogliQQoiGAWL/EIYowpbqEAaJKSIMYpAEkjZGh0EMYiye0IRcvgcKLU0yLiTLQxB0kAMd/EAHOqCNDYLzGxyMUoG/WZQqc7Cd49CgUCyQ1KQiFUtHjWqCzNHUda5jQQw6agY4EIKpBFG2EnLiE+gpRSlYwYpYqDBWtPgJL6Q5zV3cYiD5GchAbiGR/XizFhgJJ0cQ9AsemkRC0aAGNa7xEg25y4jdSqI9RkRPem4LH5mbIhWvyE9+0pN0I7IiPtxxDg9h46DdSIc99vEPfLxjHO84RzjMkY5xjIOM3zBGL2IkC02E6Qa8g0EPdKQVQkjCE4DASvMAUTFA7KiPVAAFMJK3FUKEoQ5a/ymLxlpKhy1J8qce05JPx7RJHqBSB0BYFA1wwNSlvvKpHdyOVLcD1aladara4SBThfAbIVQBbIIQxCMiQcJMHPMTpQiFKEyRClW4Iha0iOtP5oqLW9yiFgaZxX7suh+IUAQjFLGIOAuELJEkwyTPSic1VgITDNWjHkzM3Iii2M/KMpShUuxH6Z5Y2c56Vp/9gEdBu4GNa2CjG+8gnTzkEY91kIMc7RjHS8jIjGQhgxaZAGnDqLCUIxyhDlgBhCTmkNJlaIIKTiAEIKiHpK8AghB+0IoiWNrHrQDij5pQLiEi6VOsfEwTksAkIoLAgyWg8gdAgA0pmdpUrS61qezdav93xmAHO4C1bJS4hAmRKYpRsHVtrHDFLGxBYLr+5Ba0uIUt7GrNvYpTFxepiIQFG07CeqScgTPchNbpIZh08V3pSIe73kHid0wWH/CARzziUU+HprjF+PjsFfEhDxrTeLX9kEeOV7taGWdWXTwOspB1HFrZHhSh7tAnPMIxDnWY4yXtoAczjNErXHSCBi7wgcaSAjyzZMwHdLhBGMCgCPCJxXlm0aMTlBeGQmoMesLFmCSuSwiUcSmSQt1SJSTRpUkAIgtW0E0VvEOGJSzhB4MeAxnIUF89gK0PxBxrJEponk/0txQAbiZc5WrgA19zF3rt60V8AU6J5EIivYBwRi7/zGpjNMicGqaQOq9Ba3bG5BtRrsc76kHQc0j0HSzGRz7i8Y51rPjY7IAHOuLB2iD3I9j4VFdD/wnQgH4Wx0/c8ZA16+NsAznH3k5XPNwh227INhxJ3mw/1kHQDmvDGiFRxhpxAAQjDKwIiKRDVY5yhB4sRQmAAEMcCJHIjZmlpskr5HIVkd2KicEHdqyzJAiRJaxg7GPhPSko5hyIQySCEZMuIas2YWn1vEqFcY2PyuHGcvvgB0C+0KbMBwRhwiIIWRh20DkldLh1aiMm7fBGOuhxuqKLcR9N3Ny5gJ2PGE/xHOx4Bzv0wQ5+sIPd7jBxPNDlDngAO9jTrqe6vS1k/yAP2dnhlnbas13FsxM5XUFOMTzY7eQNmcPX8Sjd29XRjXZ0AxrG6FswPpGDD/SgKTuqiiQ08fDrQjwq01XElKjwvIkLFxAeYxJxUfbcMFSAARXwwXPrfJdK3AUUcJGEIjDmse3CQuW7UkaubDX72uuqGHKT27CGVSxhfMSGxPIIsfZmEmdIaBrVCKJNgP44erRjHpUTo+iUrjkfZ7Z02Nesuv5JTxPTMx/5yOePtY3ttLuditrvJ0PhXna415Md8I+//NmBDhOdoxzoKEc4wuFrc8g2HepwDumGY/FwDhsSDcbADMmADKNgBzawAS3QFDzSFHRQCcejCYaAJMoVMf8bNxZbYQh1YFIUlxU2xSTHQweEMAIV8AIhaAiEMCV0tnoYc12KQAgR81zAUHsLWAwjwTcLSHuyhyt/44NEaBI+BA3TMA3WYA3ZwCLfwBIy0XzbIn3TR31WODrWZ1mZ0w/ocln/gFlThH3Wt3bS5k8ttmKk44Xn0n0k1g7uUH9wuA5y+FrksH92KA7lkId0uId2uH9yKIfqoA7uMg7poGupBVruYA7XMGXNoAyr4IA1oAEVgAIxYEe+FRWaUARHABVhIEl0kARawSTJRUh8RnrX9TBioDFcIlwv+IEuKAlSQQfTVQlSkXB0EAeV8Hq1wjeAIxIPUgy54oPJ14TcMET/jYMtzXdEyghPU3gu6EeGYnhFlJWFlcWF1tiF18iFY1eGnvVEbtdPMLZi7jCOvhaA5wBiFjUOfbh/dFh/r7WO4hCP4bCHcfiH6+B17xCIIiZikTNPDBUPXHgP86ANOrENz0B4NVACFYABToACRYAkdTAlm7hcmogUSpAEN6AEDLNcdTZ6L3hdxzNnyvVcDUcIzuOCmRdntBiRy0UHc9AGfDAJoIAKuFANz4ASiLOI1UAMxcA3vsI3zcA434CMF/IN6WB39uAupxN03UAN3aAN2OAN/giGVkSGO7ZP1KiFmJV+XJl9end+3lZFVpkukkVigehr6mhR7WiOgTiO7XCU/+ngDvEgd3Mnh/g0UO7gUPX3h+PYl37Zl/gQD1NYOdoCWZITdNqwE8wQDKOQCXxQAy/AASTwSAgDFUACFXXgW1MhXFqRiiHpCS4oBmEgeS8Ii4AwXddVMc+DgVtBXB5lCBhoCMuTSAQnmjWQB3LAB4LACdxwjH7XDfNQDXijDMVADHhzDMbQDL05lGQ0D+4SYuSgDusALu+wD/bwZKWlDabVDgv1hVa0lWOJldXmdFmZhuqmY27HY2mXfYE5Ise2YvEHh/Xna+RwDhaFlnZ4n+XoDiWCDnKIDuoAoH3phu2Qj/5Jl/gQiOqQde8wjugSmCTGn/wpLukwLk9mUKWlTv+kdQ3q1KEbeg3T0AzFUAuk8AmbAAkuMAIkEAI8oomauIkPBxWNFCWgwHAT4zCaAAuMpzGpWTEE5zwfWJrXNaSjd1JSgUiIhG9cMQeTMAd4IAih0JvcQA1uOC7ewDrPgAzBoAzJUCwL4gxD9A2QBWIBeo8B1Q/4YGRH1nfrt41ZGZ5wqnZx2lDc8lj1EGJvaXfpqI7ryI6vdQ4BaFF2tyHjQKjpeH95WH/lUCL2+Idfx2LE9g724A7uoi1vmQ7dEA4fcmS01qEdSiHpJA3qJA2kWqrSQCE0YQ3QkAzC8AqkYAomegl/sBQhYDAtWpmAQBVj8ZHRg1MlOAd1plyr56P/E/Ncrbkki0dnTHJdX2GjSKExR5BvgOAHc/AHf5AK3GANzJAL2NAP+0cP9LIMtDIMvDAMxOAL5QQNQ8mdz1mmyaZjpPNQGIoN44AP4DZk1uZj6bmv7Fd+4CZtNVZjz+Z17DCXxfYuXFRR46AhG9JY3jAOvkafdUiH9smn5VaoerohISZi9xh/yrYOyVaXjEqH+0dap3VkB9Whteap68SypOqppxoNE1KqMnt80MAMxOCqoXA2nMAqk9BTJ3Awt6qJhuADLwpmDpMUidSaXOFc2QUISVEEkeQ82aVd1iWbwMoksPlcqVisW/EHbdAFfLAIwVAt3gAN8CAO4bAO3sAM/64ADGuDC8jwNrrge8agrs7ZrnIIf/D6D+4QDkdGDdigDmZ3dpVFbc+mnml3bGdHl6vlsYAIoJJ7DuSQlkzGfwZYsWk5qF1EUSGmoKCrDhsbYpQqYs8JlxursXVohyaLsinLsizbqbALu6ZqqjP7stMgDUmYhBQCDc6ggMSgC6cgCjsrCpuwCR4TBSZAPAPTFEYregfDFGWxFBpDB4rUFYU0B8MFtZcoBqbHJFYbPdEjFSYJgk2CU0ASBgTnBHEQBz3QBouAC9yQIeOQdd1QD9qQDKJwCYJgCbQAH7iwCwRSTtIADt/guQsqh/BARaJlsuqEDe5QuEJGnt3ojcx2wf9zyZd725/6Jw5wiH/lgIcAipaHGrEmHLGh25aUSqkI64Z9GYgtTKAh5n8fsqmlxaGzO7uimsPqJLOjWqo8TA2kmoRLmIQxGw27Ow2/2zfCUAvD27OW0Amb4Bbb8wEuUDAogALM+wImEAO6gwLGczCNBHGEYARd4RWvWAegCGaGoL01apJtRj0mBQiVECVUcTxi8EiXmSM9cAM9EAd38AmMAw70IFsxsQ3bwAqPsAiUsAn+Cwy4YAt1SwzHIA0HTFEJnGJp6A4fqqHA9nZlmC43xmNyR8pyZ8IQm5Z8WrKXa7l+Gg7iQA5qu7b9GYd7SA7y6Z+NmmJy2HWutY+GWm7/JovDQUy7FLLDP1y7yCzEL9uhytzM6pS7NAuqSDwN1EwhSfi7xyAMueALrkAKosAJnIAJkTAKn3BClbQCcVAEJrABy2sCKGACXYwCPoACQVIET/ECPgADReDHkdRm6usDiKSrc2AEKKgIc6AEN8hIRdACUAG1YcBn5ntTTmACINUDiGAJruAM2VANLMIN2ZClnwAJiFAIlUAerPATu+ALxMIMFoJrcQlsTrcP5LahBzUO+xCY/IQ5c2mw9neHfai5JRyxANgO6jAO9Sm5r7UOIMzUe8luUP0O8NB1Ul3VDQrV7kCyrAy4N+yp6aRYxVzMykwNS1jWZZ3Mz3yquguq/7mbxG6dhM/gDM7QDCXRNyNxRrnwCqdACnsNzqKATJ8QFO2xCTpgeCkKzzCgxSOgO4kNzw7pAy9QBMQDAxFjCKAwB0mgCJfZW2JgBIYAAwq9FdOlXLJ5A07QJEjhSHm8Iw/XA9dFB34wCZ1QCsPQDM9w28jAHh7VCIjgCagwxXI7DD15WNNQjF4ERtyWRUl0OZuDD5N61QGqDlNNDhIqufypYnKXwSm2Yu2ZYu/KbE8EkOqyddbp3APVoOEiiIlYqDBhwy3x3vDdEk853x0CE/E93y7RIfFdEzex3yvRErW237T23rW2OIuTfMmnxHNt18UpDL6Q1xXRChJ+ChRe4f8UvgqsgOHOxExBAQyeoAPy3M4vcAIxENl1UAQkQAJOgQJOgOKRXbQAk0g80jGDYLQycNp6xFJdMQdhkjwo02bFCggQdwRgFiQXI9AgCDHaswmw8Az1gQysMAqVRAiNMAmegHqXMAqxMAzE6YMu7ZzvAHfchpcF2g7rQKCiK7orXKD2QGIO5eZvXmImtob1tIaS9eZdiDndZ9TpYJ+tiw2eCuiwS8y1dg3xfQ1LGOD+Hd/yst/x0uiL/t4GPunZAOAGjuBK3Ax07TfHYEMPntcS3gp9TQrgPOqkztemkOoWfgoAtgpttQqq8L+e0AUu4AIv0AMwYAK1+hRicDAvUKv/dTAIdBADtjqRLBU8Qs4Ux/MjIZgkEwOsU1JTktBmDiObSwEkVAFeSUHkNaUJm5AesYAvHl4JykUyoNAIgZAJ6i4rw90Md4sN5ACQOCYPc/en6PCG0S259opiVX2PK0aX2L3dz4YPp9MtkJU6zvcuHwLgsuvVYO3VYa1OS9ihZp04A17oBI7xA+7flN7xl57Nc62AfePpfvUKoS7qFc7Xq37qr2oKp07hqc5WMZ8KqZDqbaUKq7AKrJ4Kr1IKfBAELcA7RxAD8Fzi1PMCJIDiICADL/AjR/AC9Ow7Fekw+DwVY0EkEGmaZVFSUdHiTyIJWnHifwSRUFEV2pUlnvAJ/6iACsAAC1piUp6ACIFg0pTwCIIgC7bCN1N2t90QD/SXLvWey/UZnfcOD9IpoVhH52+elw2ade7gZDfRDdwg+doQ1s8s8T2cw0d8zDtcuxRvDdRAxBUv+tVgDQgORKc/jAge13K94CMvLKlW8id/8hXeCjlv4RNO4apwCjHf+zGP6qcu8/9l86ygCqpQ86leCqMQF2HQA4TQAyMAAlTx6zKQii8gBigAAiV+MGIQAw+3zzHweA8X/kR+MFn8AtYrFZa5MK/NFbr6gkeBFEYbkb4VgoQgJpXw7ahnF7VYCXHgCQABq1KhTZ4eZZrVzJkzZtCgYVvXT2I/eOrUuXOnjv/cxnTkOqZTl85du5Dq2pnz1k1lym7YqL2ESS3aS2nRZtqMmVMnNWnTev6cZs0ataFDiRbNKVSp0GlNnTYVWs1atWpNqU6LtlArQ2bMkh0zRkyYr165cr161UrtKbZq3a5tC5etKVWr7KpKlTeVKr57+ZpKZUrwYMKA9QrOi5gVq1WIS33iUYLQETp0TIwYEaNIERgoYqA4ceTzCxkxTMcQQ+eIExk+ivjwceR16xgyXqBoHaYInTBi6gwCRKdODye664RBLqZIaidifAAC5ET6IEmSKnma1AgSIjpJwhgypEgRLFCIEIFqZEdIpGLZuGkzl04kPnv16bXDn86cOZX//bFhuyYmmxwaUBqebELQppqikaZBBx30KcIGYXLQJqiWwjBDDZl6qiqnEFyoma68+iosYX4py6xa0EqrLbZehPFFUmaEcUYbC8MxMcN0RIxHHH/cca9YGmMFlU0CWaGFDTwL4YYbNgjBhBdu8+Ez0E4IYcraPoNNDDGOEMMJ3jZ74QgYijjChzCdqI4QMcKowzcxkvCBNyfqBDM4OiQJw7UbvGQTFE80AaWSKJLo4k4xNDHEE1CgC2OONs7gQo8+OHmGm6UOpGZETxtyyCERR2ymmVBPTXDBBBF8sFVXH1yVwQetAaonCyNsCkGHQuzqq2PAMibYsFA0i0Vj0Xor/1m3YpzrFMJsJEUUaaGFVhTBZrx2WlJMuRHHaIEsLLHFBDMyiw5KMAEFEmIIATYUnEABAyeOOAEFLW2r9zTNvITOkDAI6XM1GGATrYcwjqikjiIASRPMyuZ1wpDgwtBEkz0JcYLReZ8DRRNFAAnDuySK6HNRRcCDDjojgmjkk1SC+YqYYYWlWdhfj0kmmU8/HdUZh7D6OddoQo3VpwShUVDVVXtqqqansOJ1xF+DJeYXq3vB2iyte7H6F2Gq/kXrY41tJS1klW0lRm6pXVtat992OxS4365WW2qt9dYwwfrCqxRURkFkhQ2W5ICDCkJ49wU0SZChCNNgq5Jdz147wv+2GOjQBE0xAAGPjh5Eg6GHHoKbuLkvNfEtCekIAYQQOjinA2DMQQ4DEEnE8wOQOeaozpDXWZc4dtaDK0STUWQJpphkirkZZxJz9grnUZkptdStrvf51KCffpoq778H36lqntlKRF+PEUusX8hKsRb3VXxfa/m9/oWYYsQSBusUc3G/f//dnwWLZjELVxTQFWopoLLscpe81MUup3jgKQ5jihfhhVkXBBcr6sIYVsSig7iQRSnwsIUujIADEwhBCDBgGhCEgARFqIMM2hWbetmmSnQQgwzqQIcXxABMMDiTlyShCSfAQAmAcMENemAE3nlCEf+CEx1IppuUTawI83L/He1qBwglUGEOkXodIFJznEr4iw5OCkMP/gAKVCDvK8Vg3q9ylgxl1FEZc/RU9fS4R+z1USvTeEYgBUk+rUzvjcTAH/vK8j9Gvq+RtZCfLiQpyV74QhjCuF8xxqI//kmSkbf43yxqMUACJrAVpUzWAlfBFweuAkZ6OcyLfNRKVTirWzhaxZBS4UFTsAIXsUBFHnbgAjqc4AKgOeYLXKguxk2pSieInBMcV6fW5DBNMTjTcsQYnThoAhBdIASiNOEJQBRKNUfQjXTCgMMwSIcOxemYEZQQKUXMAQxgoAIVIrXOIniHDkpQhJdE84LaBcITpZAFLoaRDETa7xhwnGNE/yWqs67sUY9+DNEec1aMYVzSF77YRUj79wpGipKkK0JL/0T5Sf/d4ha66N8kQzrTj2ISjh6dpC524VKXxvSTAzRgAg+INrmwxS6wHExgBOOsH+0lbzly6l5SUQpTIPQTd6hBD0yIgRCcADNe8mFtbnMbFAxCE1hCTQwAUSYefslep3nBEGVwsDgUyghdiIIfBqU7Q3TBCE5QXRF6cEVpSnE1mpAEb5JgBEJoogtxmIMX5+CDHiShsRjLXXCccIKFFaISqEBFLHgxDDiWlnkRLe0bvzLRXkm0tMMYRjBkywtehBSUo3QFUA1IylKKkre/JaVKXfFI/+XUuLugbXIvif/JnC23F7rwhU53Slz/kTKoRF1WjPDSI3BtC1zfJYxUUVEK8v4NqzVQZuHo4AMT3iatIJCBDFDQVR0WQb5qkuZ9d0OHxzkuBCC7ohFqFwfdVaIN5ayEEXwnG9200zWwKcINYGgIGBhBwd5MgiYIoQQ0odM3koCOeISzQ4kZFBWpSGgwkCHbjgoDtsQgbWxdfEmxWHIsHyWLLlSEltwa0C1C9fEqgprb3xJ5gLZAckt52tP4vc+4x0UubT8aDBqnFo7pS+RHa+s+JtfitsBFJSrfcpcXgVcwoxjFma/lXVOkGUfkhTNhVAHaUozib5s4wwdY4ANl2mtzJoASblCgLjH/DCGFZP1Mlm4wAsgt2nYviBwgYhMb3jhpdCG7wRwIZVjZEGe9V3RO7cQkiRsQQhKGODUhJhGH1RwBTGIiVCUqQYg6DNGsqq6zKRKKC2TwQrY1HctMbTHAUZbSlGiDUS2VDcFWrKLZzRayj91i3aAS2xbUdZ+OdWyWSebiyVH2RTBgq0nTNrcXDs0kR4PhC15Iksk8LbZLh41KaatlgXyZi5nR/CxsXaswcAY4wFkxCvLaeRM/YIELVMcBFHBAEuxK1wm8GoLTHG6+uKlSCNZ7ghi4BtJkStPrDoYaMZLMCU+cgxO6EJ0IsyYMMACZD049TkAs5wZJ8I4m+gSdVptp/zN1AgUs4tAGyFbHUYU4RCloIQtbyBYYtKDFLWZhC10gmdo/doVdgvqiVKrS618/BVGH+pbd6va3/btFJ9NeC128dBc6la6UbXrlci/vFzl7qENrXFuYennJpHQpLXTbisV8vS9K5beZuYUjNwsm4HAer9/+BopCAaEDUjrBCzgOmvnSwXI9TKFn7GUvjvvASTFogW/69PEjgEISYOp4ar4ziN6AogiVcI5vnDAIQ0jTNWJQRCWcIKiQxS4JxCGEm9AppnnJQJpH2CFyCCwxJwwvC5dIKDBkGwxcCD7qSJ63kVvhisWUv/xe54sqof3Ar7uy2S9yNnbHb2RjW5ekov8UaS1mOtPk0rbK97Mf5bmfZHAGhUCf+1muG3s7mGo7eJsFnhI83TKgBToFZUsFpmKzxfsRaKkRUmALaCGMgAOtyKO8SqgBCNCAw+GAC1jBFXQhMZAEUKiDG/ABFwqBxhGDzyiNHFQTSEMn1eCzIrAYP/GheYG+zSEY1QiTzVGO5eiS3wmTG6AD3DMY4Ugs2cChGGgO3nCO1bCOOeiid7KwKKAEYECGM+y17ds+XpC38HMFWYBDD+ogWditIZuFWLjDahsyV4iFPvTDWKC/3yIprZEkqgO/Q0Qy6VpASQKpKGM7RsQxX8iFBCwGrUCRsniFsxibtMiuC4oRarGRtwn/BbkZRbghRbkRhWiZm2iRERjZBVuAuk9oBETgg0Lwgy7oAhcYnBMgARCQuArggBAonPk6AkPwgcxzoRgggUEYBNzoIdsogh6KgXqBNNCQxv6iLMeBATEYhBgIgzJSghuYp95wPj6TQuaQBNiYQRnAoSuSNFcrgiGQhN8ghNdgDSFEBUWIHYaRjS5og0qgBTNcsWDwNe7DBV7ABVywugGCw4bEQ94asj+UyD0sIFn4Q4sEM2KbBW/btloAvyNLRJlaRErCGl4gi0jEMW/DMWE4hmzIhmngmpiEH/dhEezyxFMIRVEcxZ0UhZ30yZ8MBQ4sm1ywGlJphkBSnjP8hB/4/wAN2IASaIEWKAETGrQXGAQxkLgUCg3VuIBSWzQUAIEWshcSICsQKAJ7CT3POEYfAAEUgCHpcAIl8I5odIIX2JzEugEjAATISgLocJIbUCdD0ITjOxgwkYE3oZPmeI04cYIv8oF2EoNCUQLX8x3nMIIoOINFgIUzjAWCpAVfm6lbWDqmY7pD5C1ZuEOJVM0+nECt48PXxEPUhMhXWKkm45//4cgny6lc0J9K6k3fJIv86YVLOoZtqAZuaIaqwRphkCT5UakBos0WuckZScXqJAWg3EkaCbtMtBpjOAbqCYpr0AZu4IZvmAd6OE96+AZugIZeKAZlKAUhWIEVKIENMP+BJKKTYCQBGIgT0sOSd2kBzKiSFuCqEBANaAKNQ5M4xYkBZdK8Bs0SFFgUaSIUQugB03OCJ7krQgAGRegCRQAFQ7iBF0gCV4vBOnhMY+whMSy+NLHHb5oDgBGT46gDQxCDxhqEJHinQjiDQPgEYACGWPjMhKytwIO6hryFeeOti+zDDgLEiSQ/DqJIs+OtRzIubtNNStKF36ykSOyaq/kaYsCZZDiLnHGGYqgpHNtS6PK2+IGfsUkWYzELqxFTnTEVaDAQaxBPb/iGPvXTbzAHQAVUc2iHe6iHdGgHb4AGY/gFZaAFQZiBGmiBC9gAzRuBEnCBESCBKMEA2FCmFLr/gBEI1cw7gRY4gWDsKs07RgyQONOguGO8DQ6YEs17ARjwlxv4RpAxmMd0Ab8ihGXQBMbik9fwgeIwhDq4kyMQHRh4HcZCBduxnXe6HSMIviySNC95HWYkot3QBD/gg0tgBaiDOlxALiM9UllIUut60j50SCflQ9akyOua0toEoKnjslsITXwNKVvYP+RiN5Bit17YhejCGpT0TQI8BUy4TlFYhVBQqNr6KE7aUi7Vn+70TopyiJfoBm9Ih3loh3moB5ClB3sY2Xsw2ZPFj3qoB3tQ2fzAj5G1B3zYh3uwh3bghmg4ymewBB2ogTl4gQvgKq/K1CVxHLCsgAq4jQrA/wwOwIzMiwGuCsbSqJfXaLjNsJdapYweYiayfKc6kYQiMoIeoANPmAMjuIEtqBi+BAQY6LjXKAJCMIQLdQLiGCxA2Ewwwhh0CoM4mLV6cg4tFCNJgNt0fMxKiNEgSLqnowUi3SlxFVfStEhAfFcojdfK3cPgqq6pS9Jr079+3df9kzKUPEmsoR9fKN1f+BWuqaNgMCBb+KiuoZnv7AqkoYZr4IZ5wF3cRU96uId98N3fBd7gFd7h/V2SxQ/8MIdxOIlv0IasaIZgYAVIyIIaKIETwgBLfQ0T4CoTuIwjeIEKqBcWlLgT2ADMCL0blAGn/TnNsw0U6JcajC9B46xruv+B0AmZSOmBobOBcSIEWYMNGDgCQniO3vs9fxm+ZQCF5ChGPvmmLojB4AATMTAEuNUTCMMhOugCHuCDThBXgtypJHXchoxcD4LXykWgY8M6A3oFV6DNRpoFplNIq/PcmYI7kyzYSNSf11WkSzw3YuBNTRKGV+gFYygVaLiGa8CGbiBUe6DZJj7ZJzbZmYXiKaZiKq6Pejhe/OgGbeBiLj5ibWAKr7iFT8iESwiED9iAYJSAEZgSGHgBEwiBFgqBDbiTELiTDbiAF+CAzCschhvGQysrOREDWY2dzoiNKSFLzbhKLRSeF8jQFojRJFCESQAFRTA1SIsNaSKZHIqNSmj/p4rRnXUyNQOGLMqDji+pA2DQuT1RjX1JDR9Igiy4g0uAhafDhSVLV1kYzRGOXOhkERQeP6Iytpps4f+ZN87NUpL8zav50i8NFtlFmmmAhmrIBmjoiu+EBm7whvqQ2YmQiH8gXuHtB9+l2fow5yvO4tz92OPtUz790z7VZm/whi7m4myohmYYBlPIBEugBERoBBvQgAt4AAbADO5VkhFAHBSwTyypQYkbgcwbgT0BvevlM7NKX0iTBDFAAcxBDVOzL9wwHfsyK0UABn/hMx8ghDkolHYCMdgojQeDMNn4kppDaUM4TBsNk34iBCcyNXXShDhYOVnjQtPhDTrwgzzY/4TNnK1wmzI1DAZgwAXtywtmS5ubhCCus7cFEjtONBZIKpZMlB/e5JpfoJnZpV0kHof4aAd3MGcoZtn6iGJvnoh/AGcpruInpo919lN3fuf1LM929gbyLE/y9OJsoGcMecljyIVT4ARMeARLgARIyAOnrAAMuM8NiEoNQCETgIERwICG22PIIYQXaAFUk0Ye5LjEemhoAgTMcIK2db7PKAJDOA3oEx1BMVUUiA0jQCfBQhPWeLDmOIJ3XI4v2QzfezXloCwlOCJQ9h1ACNvHSj44qZw6sO4wCoRLAFJc8GCTZDeEXNyEBKFVYAxXUhtboqBU9MCbVAtOLBu3YJGtGf9r76wopEHiJPaG+FiHdniHd5BZ35Vrb46HAAdwiZAHdkBweFDwdQiJ5NWPcYDw/ojwbkhrlABseeZrvxZsDMdw8tRw8nSPenZJe54GZlBsnAyFTIiES7gESDhjDcAAzB6cp9yA6zUBEMAAVv3PE0C1aNxjU4UmHsLsh46BC6iT9soMIMImjnM1QNAM+/KBJBpuFTrpWj0T2GiOOlEY2bgcdpQigpEBMJntw1yT2DgYMaqdLkiCOPCDOegCRoFbaeLGq+QNQIjsWoZqX6stghygGF468maMHnOFvmAqf/PA9fZEFpnvXwGV2tWGb2gHSD/PSV9Zmp1ZAN8HuY6HAe//B3yIh3eAh3dYB1FXh3MIh1OncJUIh5b4j1b/jy1mdVd/dZVo9SN2dZWg5y5+D22Q5y4+Ytvt4hEX9qsowGMI4uvkhH3+hE9AjxKAgQDVxRKYyo67XjEANCzpKi08AjYegRbI1D3WPI5bQVrlM6eFAe69DSYXgx7i5BdY1iMQvVp9l9U46SVMk5iuAzF6TJCBx1oLuR16J8pwk+KYA1lThDhorO8Y+NiIYOiYA0TohFGAhdG85WE7JVvgQ1lYDMk1pQuC70HkmmeeXWmwBvLM8EhvB3q4D/lg+ZQ1Z4zI4o2Q+Zknh1O3+ZtH9Zboj1h/9Vr/9fv2eVcH+vtG4iN+/wkvvgalqN2kj4rvKaTn0aToWpGqjhY0szNU8AQb+IASoAAXkARpd4ELqANPyPEi8OxTLZwXqIMXqFRT/Vk+ZtoTKKZSxYwbaAFlaqFtlA7d3hgCpqy/uhPdrjkt9BLXqExA0Y3dCGBvCoN5dJgd8pI3QY7aOVYpGqLbARiQkY4Idp1iHO7i0IRKgIRNKAVY0OWli4U4ZAU4TAUj07H5DhazPno+1V16YGtz9l180P3/7nSWl4+MsIhzGIdV53lZ93lbl/WdT+Kdx3VtKPpWL36g/4+fp/4AOQql8B6oKcBeCQtiIAtNlM5QVEW3iZbGODOrRwVQWIMOwOMVcp0S0P8ACjiBHIKBCeCAHG/BC1irDSjVUAV3ugeIG55evDjB4YUkQydCkIiBIkaROpKc3PAhpkiSJD7CJDFCiE4RH5IASSJ0BMaROYbqHGl5JMzFImJg0nFSh5AYMXV0OhEzqAgdT4CUzJkoRpKkOU6MHCFEUkxTMXRA5hQDCFCYOVu2NEIF6yssVKXGjhrFCliwYMKSOcvGbR69e/bk0r23zy7efXr36u23Lx48eOvWkQuH7TDixIipUcNG7RpkbZInU5Z8uBvmbpczY67sWXI3baGxUb5m7bS0adGgNWPGLNmxY8aI/eqV6xXuVqdOkerdW1So4MKHDxdl/BPyT6aWmxr/RRbUJBYlRrxAwWGEixIlOHCoEKIIhoUcMGDgcOHCBu4cNowYweHEiyMnTsSA3yLGCCeGfICQQQJECPFp8sINMBQBihMm3DCHIkbQcYQTG/VExUmANAhhS044UZMTPcDghCJ0ZBUGIEUcIVFOU3lCiCR0KDLHEYY4ZVWLCeVkSIl0zJFEVRrWkYQTc0xSiSaXTFIIkogsIoglrAxTzDHMWAOXPVXSY8+VV85lZZX2ePPlN2F+Yw5mX5rpTWecqVkZYpwdds1nomlDGmlxkmbaadNUU41q0LDmWmzGzPZLbbbdlptuu/HmG6PGAUcccZ8ExwknwSWXnHPNjSJWJznU/1BCfGJwIMEJLRxRxAYAglABgCGEMN55FKh33gUvjGBQDD74MIKp9xVEUAX/gQDfDXS0cIIJL2gCSAtOeKJIiIQYYYIkitxAxSRxxKHIJIZUAggVYlDBYhEw+MDiVGGE0ZJVddBhlYuAEOJERxuJoQkhmoBCiCct5sQSVknUdKqGR+hIiB+F/DGJSgj7gccinCDjjDPNRKPNN2dqzBma3kzGjTfcaAOyN2JmbPI37aAMpskdd2PmN5JxM7PIcU6G2mp+QgOobLMJQ2htuQh9KG5FI9qKbkgryqhvjgL3tHCXIhep1JmWVcomd9TQggkb1BfCBPAZBAKAGITQ6gUhlP933QXc0WfQBe61UIcPJ7TXwgshOHRCsPuFAJ8T8yXbghGAdAHKs4pUWwIhwADSg7dz9EBIvlgVMaIRLmSlk440yaSuE/KC5MMRPlwehrMJKZKvIXQQ0jpJotcxu0QfzaHS6jhaCIiMkGwyTDKtNQPNNNBIIw01p00GGZxwjqxNZJJlY/PIX1b2Jc0zg1myx8ufZg2fqzXTmmvM9BybbOYLShvQvwjzM9C9/OJLL73ocn8u+Ncyyyyu+O8K0hK1G1MwjRSQkhpyKPUJVbCigQ2MBStwQQtZyAIWm6iBBUpgghGk6mwYUNV4MFCBCnRnPNxp2whkhYLyxAAD7ZlP3f7/VoRXHQQFDXmIiGDgghEQoggE4drhKlEJWEwCFqCAhSJcMIcw3MAJlKPC6tQFpCT0IAxGmANWADGHqZyoDpebiuLoUAlDhMRghMiKJvzgByIRQhGGKIkYDIEjEUlFJ3J8URudMpLXydEQiOjELoqRjEEOUnjO0Jmfjoe87+HJGtl45CMpk72ZjSx70ssGn6ZRvD+Vz3yBWt+g3CcMYoxyNoIK1CAFZYz3CcMXo3zf/OrnC/rpYmj5qyX/+vc/AK5iFQNkTqOcFgpRfMI4xRFFLFLBClWYIhXLoQUtYgELT7DAAhowgdqwWQEbkqcC5SFbN8czH/VwJwauAgEKCPEC/w6YagR/k0F1SCADGcTgBaYj0A1cgDcfcEBXMChBF3YUhy6oERSVuMELbEIHkmzrjEQxQhKUEAY6gAJHSZmKVGTyOkBooiT4MomuLqIJYFSCopJwkOV0IhV15eQIOpFEJeZAJEMobqPy8mMnagGlYxDyNeP7KcWCKtRDEm9PkMwG+MCXyaCS7zXomw0xoirVqVK1qlMtRjFGSYxT8tSTqyTl+6LaSlrOUhe70IUtamGLXdhiFm3lnytY0cu59rKBquhlKvJKCgIupxRlKctvHGUKVBAWFc5JBSxoAYtP2AACGkiVd0xANhCQ4D/k4UBly/M3F3LQPXVb53zSeSvquP9nPtWJwTx34oMb3AcFt4rBfVrgA4rAoAUucIETXHCDJLigCJOz6FQkSockSI4oYfgIHUbiOpzshHdXWZESAAEKSejKCSfSRL+cWCIZ0IElUrlJ66biLpi+DlqUg9bqeEcISHyiFb4gBpSSoYxiKEO+8nXNT8f3mp4SMjZUbd8s6yfgXriSlQbW6lQRbFVWRhWr6BskoGAD37ASIxiz9IVZebELttqirR3OJf9iEQtZxMJ/clVFKlYhV7niNa8uZg6MYcyKVBTWr5/4iido0AENUKCDIHjBfwJUBMuySm1/QwEN48YBOvATAy+gw9/m0wIOEoQDRUDBC4YsT3gSxAT/KHgIfAjSkgUlwUQ67MENilAEZ4moEpJIgktzosWpJCErt8uK6yRBO3Vd5QaS0ASTQ0oHFKhLIoAIXU9qkhOkVAUQg8BXHeTlFBm9rryAcMQoVlELYRyjGMhQxpOK8aQnkfJ+pq4FqlthtFWjutW1uKUuZvm+Ah/Yqg02RjGkmmus8pqnseFvMwQ1SP8KYxhpSQsvNLwLXDD7Fh22hbNBLGIW9xLFznQxik+RirFwuxQw/g1zxCKWv3YCFZuwQQc+0IK4dVAGTlCbDI5gw7OR4MsccNUL8Ba39nAnBLWym5RvRR9XcQC1XwaQOUMwglydgHQOiUE+jWAuglhEzWJA/wGENsKRpyyUXnUeblZCVwebuAsqqJNofHRFOhOJoSfw6smpThRemFRlEE65aU1ZlBCkEKKIsWhFLXzRYba+IoABPIUAFYX0AK7if0jDzSxQHXVbmNrUBZb1gRVs6wb3Gn1eP0Yzht1pUopVLchO9oY3DO1d3GJ/IAYg0nqpdKX35hTAdBoplN6KVTyzE5agRCD4cAY+rAACFtiArK6DgS8DQgbofMEHJ0tZJL/tBPuGzwhQ4AN89zNXhDjBl10Feoe8aj4hMEFIcoUjHxCkB1hGgQyKME+I+BAFgBCDhP5slZgUARAimqgi+FyV379OI2qWAemq0pQNASnOLu2umv8X6i5ASKRFfSyJHPloIU+gosS7hLvRlTZ38Svqrk3fZSv89wpU29J+AxYw/Nr3i6rO36qy2aoqjcGMaTjjGKMk1IEFWFmd2quh2qoV3dH5xm4YndHkwvwZQ5QwwyHpyZ48wzIggyB4QAY0AAQ4gDXxGAVQwANcAD2pDVTIADaZDdn8hzw9xDq5Dd7k2wmIQX3MR2nJRMKBXoCYUw0GiHx8GUQ8RBF4mTyhlhE6gZopgSfQgYOQCIxASA/0AINkkUGFDiDEGUwYghH1QETIxBEcmkutiw8ITE7IRBE82k54l+vwzrfw0RvJEVKQhCRMAiRkQiq4wikczdHN3fgt3QL/hl/4HeD62dLQyNIszY/8yZ9VgRIoNQMmrZIxEIr8xI/QGIogXmIuyM9W8VQzUMwzVEM2bMPMgAMplmIpxswjVcMzDMMoREIOGN4DOEAIXkAISsADPEAMwACSxRs2uQqS3dALyEDDuRY7vQ11hIBVvEAMuNTmcYC8QUTpIVkMHMSrmIAugh7saZ4P6aIy1gFqiQFKUJEiaMJEgcTrtEREeIIhWIUmwMLt+J5LHAFxVcIZOcFEWddLgMS6NAW+tBz1GcKy0AE5hgG08JyFrE5NKc5B/tkkBEImaJoDjtIkJiJFLo2iJAogCiL76cL7XZiBFZgowY+BuQ+hQNXP5IIw/zTDniTDz8jP+2Vi/ZSkKkWJn+iJW3CDKeYkKYYJN4iJZJgGKH6PNmDSMzyDMvACLYzCJixCB3TAA/QYbIUgB22AL0oWCgCICZiA2WDTl7XHC6CerbxAEhjCDrkAStjTFxZBmMVArqAA6n3ZaYWA5tGBrcAWWyqjD8iAucSbDCQEDACCJ8BCHCxLEMwBIWBRSIwLjmzR7y2UiRhMiShBEviedu2HEz2IunjLOs5Ey3XXQm1UJYyjJJCIQrYRt0wCtCDCJBBCIQSCIJACMfwaM+TfKdGmKgUNAhad0bidW70C/9gCrMEaRwrYhRWngFEkcgINfHUalLwGV7lGTZ5GT/+W4jxUZ3XuJM38pGlo0jRYwzSkhjXgCWScxk325MyoojIEA9+NQic0gnTcYnmgB3Ws0+nBAAx4mVwi2TZdmZeNAHpsgG2ZQFPAwAgkizX2wOYVRMO5ilxmmQ98mek8aAw4wXSNQBMdATzFQBjIAIKaC2rRgQvEwSQAAyz4gSJ0wQ0c2mT6AEjIREuFS8EkFEYEyRwAGuVIhIysFI18y7t014bkRBhooRwxiFO8Dhy5zki1IyhAwhp5giW0QklGCQTOZM/YpqBkFdv9pls9G5e+1dDtQi2Y2nHGZHLGj/zNZPk4AzPkQijUQiv0xi9kQ8bMAzhUZ8Z0z/MwxmpQQzT/9KnO+Kmf9KkiJc9pMAY1SIY1UEN38gkmVUwy+EIrhMIncMImxJQFUIAEmA0G+EAdjEBknd6XycDZPISXmRMGJMsGbICtJEu+YIcLEMQIMBk2jlMutkc+IdR9nMANWOiO4CXuKWNLkMiGutth+sETQMIygEIQ3ICfHZcnuCgVhEsRNJF1sRzuTZRhahEoXGFNlIg9ugjlpMvuuUuQ1kH2EUIlgELuxCHvcF9gboIneEIlQEIktIL8qNJEFkomEmImrl/b/SaHcSmzdZjVuZIrlekv2GYE/qk0WIM2lMw30EPJzIM1HIPQRKLQHEPzGCqfIg/ycCzHSkOf5kw0HA8i//2pJolsNEwDUHLnM1DMawzDLqwCKXyCXyFOG1DABEzABUyABISA42HABLiKl6HAfZ7NV56TXBboCNwnQRCEC5jAq+bbDXzNCYgqCqjZkyFhstwACpxADyiCE9inPV0EW4ZEz8VBRkTERzQCJPyBJzRCPiUBISiBJICCiOzEEVCBYfZIy6VIiAxXUFzh7FAf6SSXu2gITnSXu7gO3UwaMADDecGh4qBmJSCCJ5CoIhSCIIjCKzigA64f0viPLgGQKxRNq/nPLdwC/6TdLvhCsmEYgfkCANIG/uHX8EBDNDzGl5gDPfwu8NaD8AovPbSDOYzDOHRD8obGNUBDlHSiw/8mKmSArGp4rDQgksqerPYyFX45Vae10i70j9Ls1SiIQll4BSogwgdowC1KwARQQNt8rS9+mQk4RAp+UNF2jQtMjhMU6AYRiIIMoQnME0GwJeyt1qExGQwoY4d4Qhj0gAtkBL482QvAwByAgiZYlCFUERhswRrwgA2UmQ/MAVEQwse9S+jUhLXWkSKoYwajMFDgyDq61ErMBO/MjlT43lS4iCIAAiosSxvJSPbxjh80QhGBgh+4ZihUYm28giucn4j10vedrgF+rtAMpytt4vMW1U2SonVWJ/B2iT3UgzuYgxmfsRmrCWaEg2Fgw8tUkjVwQ3hKRswY6vdoUjWAjyb/+elqVMxPea/PBE0t5MaiBNZxfEL5HjIih0UjrG+PXQAD8Oy9rdAF4Gd9XuXZqIqXbQAKbIAGTFQL3OcG3UBWNq0J4B6WFYEk5EQPvACCUg4CT8XlLIsRtDB10eALuIAiTFcYZLAMJEEcNEIhIEIXcOFCiYghRJeiyctjtlyGXMWfCYWeZVS7NNcgpOEgXPNO+KjBvNEkTIIfYJEQG2ml0RQiIALlAEIjZAJu9AIx9MKrFY2qIU3U4UYmJiwEJgMzWEw1VM831OkXAy/wpkw7FLRBvwyYmEM7pIM5pINBG7RCF7Q59O44OHT3UJJklAxoeM+e7HHFONWU/kwtGY34/+Vd3u2GAjaKpD7KMA2T+cKCJrDACpRA3FieBMBvBaBWprpKkLnKVq4KgHTWBijIDZwEdZRUC+BN/fagEyzjRRCIRjjBspjAO5JUF2iC2K7WfhjBOd/eIOAeDLRwJUwCOcbAEGCRuqBOEVDBVdiEmlFfTRwzIKQrQJ7RESTETtjERLyLVIiXSlVFaGKwH0CzHJFEv/QRITQCOh8mJDyp0ERVv55CKJBCK9yGLpSkI3rxF1vnQxvv8pYJmqhJOIzDOZyDxriMN6BxRLdD8RqvQqdDOsAMNyCVwzLP7lKDn3hSoNCGgN3GIK9a+CmdKtidMy3HSRuyMbW0cFhCDdTAB03QdM9ywCxWwAQ4BDjVm1ve7+mtSqq2hwnY1g14SKyGQVYSiDK64OLFgAuwXgBbRBgUAUr9cGEe2m7RgYYqQhswhUQESbrmQRtcBYYGBAAh+QQAZAAAACwAAAAAQAEAAYfmvp3cr5DZqYbPp43ToXvMoIPInoHCnYPKlGvBlHS8lXm7j2+0kXazjG+yimy8hV20h2Syh2Wwh2mwhmKwg2GthmqthGGtgWCtgVyqhm2qhGOqgmGqgF+qf1umg2mig2ykf2OvelOpfVqnfVuneVelfV2le1ule1eleFWhfWOfemGheliieFahd1ehdlSgdFWfc0+bemOceVyadlyZdVubdVSacluaclWbcVGbcU6Vdl6Vc1mVcliWcViScViVcFeRcFidbkqfaUCYblGXakiVbVaVbU+VakqUbVaUbFCUaU2Tb1aTbVaTa1GTalSTaU6TZ0aSbleSbFWSbVOSalGSak+SaVGSZkWQbVWRblORblKRbFKRa1SQalORbFGQa1GQa1CRakuRaVGQZ1GRaE+QaEiQZkyQZUiObVWPa1KOalONaVGOa0+PalCOak+OaU6NaFGNaE6OZlCOZ0qOZUuNYkiNYkGKalOKZ0+JZk2JY0uKYUKGZk+GY0uGYUmBZFCBYEmPXTmIXT6GXD2EXkWEWTqBXUiAXEKAWDx9W0Z9WkB8V0N8Vzt3WkZ4V0B5Vj50VT+AUjB4UTZ1Uzt0TjRwUTtwTTVqTz1pSzhzSCppSDFkRzRiRDBpQidfQS1pOh1fOiJZQjJYPi1XPCpXOydROipWOCVTOCZROCZNOChUNSBQNSJPNCJMNSRMMyFHMyRPLxpLLx1ILx9ILBpFLyFFLx1FLBpFKRdCLiBCLBxBKhtCKRY9LB88Khs7KBpFJRE+JBM7Jhc6IRA3JRc2IRIyIxcwHxI6HAoxHA0sGw4oGw8uFwglFgooEwYoDgIeEwgcEQYdDwQZEAYXDwYcDQMYDQQVDQMRDQMZCgEUCgEQCgEQCAEXBAARBAAOBAAJCQIJCAEHCAEJBwEGBwAEBwAIBgEEBgAIBQAEBQAKAwAHAwAGAwAFBAAEAwAFAgADBAACAwABAwACAgAAAgAKAAAGAAAEAAADAAACAQACAAEBAAIBAAAAAQIAAQAAAAIAAAAI/wDPHLGDY8WBBStw3Kgx5EiYM2Xs2LnRIswgIy2MGMHBqMqcOkeM1GBB0kUNFx04cBAx4sSJER1emkBxwmSNTrBi3RLmjNuxWLZmuUI1604PI0GI5BgSxkgZIzmiRj2CI+rJGiNRaEXhAgYMFy62kuCKguQJkmhZmHA5om1NFi9FnBBBty6GCRQ66MXQAYNfDBT46oWBI8wkUKZgzdo1C5VjVKcikxplqrKpyJFHiRqFapVjVqQ0aeLEyRNpUZNNcUqUiJMqVqWEUXPmrFm0Zs2WISNGLJiuV6lShdoUilmzUH/+XOpWr563bdqiZ8umbbp169amW8uerVo1bODDi//HZq2aNGnbr0Vfj6vRHz5ofHjIoCLDhxg68hx6ZEnUMWzcdEMPPdhEQ81stDlTRhlHDDGEAwZwcIODRoRkxBl2NDiEUzjUUMceRiBShxFKbASWCyukCNMILJVl1ggczMSCSSsckpMswgDYzC61zFILUYnIUAMMOcBQAw44QIUkklKNNCNWJ24FllYkjOVCDlAQ8ZULOHw14xFQHJGDCy+x1ZZcc4nQV194CfZXYH/pdUIORthxGCyr/AIMKrI85phkmGEGGWarsOLZKqqV5smii042GSabULbKKLL4QgstuPBCyyvAlSLKp6KEIqqovFzyBxB/hEJPc9BJd92r2mn/t9123oF3YHi3endedtps4ys422RTDCZ/3IHGDDLIMAMIKaQQAxqAVFLJJrVE042A0WBDTTTc0hbGEIUNUYIBCgyhBLhIGiHIGVh1uFALQ+xRxiCFaDSES2CdYMK+HbRUVlc4wKjSWjNqsAMprtyy0zLHAGOLLbEQtYkMLXhl05EnmYQkViuMsAJYJG2Fwgs5BBEEDC+ARTIRQbgwY5dwzRhVXCzpZXNdHdBFAgYQTIDBBX8BJpheIrBAxBWFUAKKYnrGEssqUEN9yqCRSR1ZZ4WyYiiio3RNCimieDLK1197Tcopmg1H3CaXXLIJJm3HLXcjlwARwx13pDJgPa1W//fqrIDP6t3ghA++LbfUQLMrdb5u440300WTSrFouKHHDjSo4GwMO/CRCCaYiEJMgNA88ww03N4G0RkP4bBAASU4OMQLRjwEohFVTGjEEDXcsEcdFw2x1gk0wWRzSy5xlQOMzLu0AggeaBLLLMCwcokorNTCoyuumNLDClu68ELGLoOsogkkrbBWlVV25VXKYXGVr0twuZWDlm3l36/xOefs0s49w4BKMECCE/BFBH6hAAU4AJYy3OkWvxCGK54WtahhrYKrmBrUOqO1DFqGFKYIG9kmMzbKoC0UoAPdJRrBQhYm5w/ueWFyYnC3OxRjb+vx23UCt51p+NA80hjcef8Il7poQENx1eBV43yVDchlgximQsMhFKGHJewgBh9wVhQMMQlIoWIZ0TBd6VD3DIdkSAlhaIEBFpAkJD0kDGUo0UaOZIQb2HEFeziDBvalpgFaAGgreUm/4LICFqiPkCXIgCJmEQtgAEMYsrjFLmxRi6fdIg/g+4q+1kKT5KWJeGZJHgrYxz4RVElnYxnBWkywIhYZMC9yYUH+RuAXvZBABHBqE10wMJeg/YUDJ1hBGSihilmoQmyxMNTWMJi1ZWKtM9xb5ikqs6iulZAyJhwF2+R2CUjEUIYvvMMMdYCqZ6yqHtG5hjqvkQ3u8NAaPoxnEM9DT3oW8YhJrEY2luj/q3Sk4znbeEYqAJGIKSqCDT7QwQcyAIIZqGERlbgEJ0SBDGqcThqmE8geBKGEPexBAgbISA1qVwY4PqV2WAHXClrA0j2YgAN9ucAF1CTTP6JJLx4DC0zWUgIJeAANqriFI4VhC1k8LCio+MUjZPCCr5CAaHXBGUtc8pZRiqyUp9SZC5DHSv2dQCUduED/2sIBX8bpL2ryJQV6NgELcGAELNiDJVQBC0BsQijJ7CDU9Ko1vWatUBPknisMNc1Gke0yaLuMJ1bYQm9+s1jhNNYdgKCDyl6CG+dc5zWswU53Ak6ePqynNI6ouPNwi7TQSGJ2+KmNVanDHo7rxjA40QhF/yjiEHzQwQ7mk4EUzEAPEIXEJV5hm2hYQxpl8OgZIGKEFRigAVjRyEbOsIdzhaEGL1hSC0ywAapoAKa1xMAf3dqSfblFLcaDkQQakAJQzIJ6wtDFJCmZzF94gmJhoUv/YKomupjpLCwYJfFQ0F+d6UwrLxieCaIak/31y2YQ7gsF5EKTnB0wZwb2GdAGuQecwKIRlSAFKwSrzBFvra8d1JpgVxzNDG6mMiDU4ClAuIlGJMLGLXSPsdAABLztGA08vk8MQhGg5qhns7OaBuB0RU/UHvE8qD2P6U6Hz+n4qldXbk49XrsOb9CDG7XwpiIS4YcleGA+DfCACnqgB0NAAv8SmxBG6iIiiIc06AYLMEAJeucUI9ShEHtI0pE2xgENbGAFYdgABS6gQL/MtF8vUWXHWqI/E/QUepOYhVCBIYtJ1iIoToMFD0qwAgSmpI83Qx5VqVrACh9wLLeEdSfPBFMYiWCm9HurzaiaM5ro19RyYR9N+KKSWAqiE6r4xTEaFtjB7jVqKkZxX1ksi1cMlhWoQI0qVGGKQkFzMpcAhAxtnBw0VBYIPJ4sECgLhA98QAevKHI9OItkeNZzGkB8Mkap/Awol06MUxZjEvfZqiw3xx7NWUc6BrSMUCQCEH4ghArO7IEGMFQFP/DDmy/RimVQg0FHCDmGwrACBTggXoP/KAMi9oAIIwxiEFCwwxVwwAG3ftcOKFmTWFsSFp16LH9n6ZgJVrABEKjgEL9Q9jEeVoumM3IVxzgExW4dAQcUkC1TnVFYBnyCVqMgZ7e0qilRYLGWlGwuKCgZSlzSv/2xqJYWhhOjO0DgndWyvy7jCCiUzjD5yiIWE3SaK2RBbVkYfvCyaEUrrJ14xbPiFKKYJmKvdgpDNQJvfHjPjckNzuT4+A5Y1EExsLGN5vith/IMYjXGSLhbZSsbuDpt6gbuK2/80/a3X2J0wOENbXSjGaIABB/WkIc40KBZGVAAAzDuh0loYhOeuAWdKnSEMkCkDBJQQA32QJDkDkIQe2iI/5g6EIE/asACRrhChPfX862izwQ4DaYqW7ABUrMBFsJYNtMp2SNXHEMTM1ADtAQBECAyq5Y8L8IiZNEXBjZ24jM/EGgHUOACIkAkX3U8MQUnEhYnewFssIQ8R5AJS6MnxyAMs1BUgSd4hMdiLKZ4LlgKilcKmREoU/MnrnAKjbBulfUsQAZkmJd5nudjNPQHyUB6zdFOqCdao/Vv1DBa3IIrscctARcNVgZQ/vQ46VBwAKUN4JAOsEcNugAJfDCGeZAFKQA9DOABKUADeuAIljAaR3AFciiHGBJoCbABTYEDZcAIEpgDLHAEL3ABE+AzPzMBJiAIIgBWREN3A9YW6v8DdCmyUoe2AjdRgkt3C0f1aa4gDLCwBDVgQAQYP1tBPzRRPC0hAgvYAexzaqhEVSxSF2kCA1CwPClhMxwgU0AjVmElU3zxM7wUNDbDSkOgNLAQQQ1zeIMVTdLGCq3gJ6WACqUQjdCICornGJpxClbjJ93TCPGxg1EABD7gA+s2jkA2jut2H5fADNSwDQNSHvYmWmP0b2NURM+AOGH0DMzADPioj/YYDUBEcNqgTtRhHezoONlADdywDKLQCOLWB3igA81yhikgA1hgCI+gCSEXcmFyBAJxBBKwAC2AAyH3FCTjh4KoQArEaBNQBkNwAW3RL/5FPJGmPvsCYCzQAi//sAEmgBWSQIIKYwuY+DCddgx9IAMrQH4RIDJaQYouoSanqF8HJAIuEGuomIjowwK12AEWEBO2logRJl6NhgE0RQFtwosIhBcoGSMmYASS0AlLA0G3ABQrhmKPwYyO8YzPOI2PIY2ggT3LZEGxMAqNwAcJRUPhKI5A8I3mWFmM6W6lYBvZMCBMtoSkFXD5mAyYmY/MoAyYqQzMgJnGYAzJEJqi6ZmaaTr6iA2ykh3h0URZaDjRgAzEInx9kAcqQAM7AAIgIAM/QAiK4BVe0SVXkl0mkAASIGgtcBJH4AIRAAGNBgERMAEXYAEsYAfocwIxEZMHCGAngl2BWAIuMAR6/xBBwiBJkvQw87UMk2CUHUABEUBK+7JKM4JebvFUcKcXOSBzJDACJJBgcAFVK5ESLSEnNiNeg5iSaSWIEHABZVVTbRWdG9AWJjCMlOCWdMVITpNXKFZBhvIZzTRteoU2H9pBlecJwqcDMdAsMzADuoWYPchjOoiiMcALzAAN2CAgTRZw/KaZmNmjPYoMyJAMQEqaROqjnWmaqQlP+CYeOzREBPIK7kGbeDADVnRmM8AGFuMy9PMC4yMBCYCTGOOHzTkBPbNWzWkBG7ABF4EDCUYms6Zq3KkxXOqSLFADS6AKDbMLu3CetjBJunAMpDADJaBoEGACp5Q/+zIjXcVKS/95M4l4JTAQn6pkXixyi9nJFy+Bpn9hASmpQHsRVhN2S1rpnnjBoCohIYgwCIxACZqQGDnhNMqUghkqeIE1q7Q6PbEwYxq6oaxALH0wAzGgmzRAA4y5A+KImDGKRWhgDLYBIPSQOKOlo1N2maFJDMNgrb7QC73gC8EQDL7wrdwaDMMgruQ6DOY6DKGZDJ7Zb7QycNbhHdAxDQPiDcmwCckBCIdACDxAA0uQAh4gA1KSFtmFAydgnMk5dDAwAgS4sAvrANE5AThQBy2wAiXQPJ9EVSUBFtjVAhEAUyZhCcIADHtqnn2qC4/0C2lQAhwQARGwYK2kSvmTpm/lSgWGSrL/pEr0CbPTiZJupRfTaQEW4BdACzQ/sxc/s0D9BRjQGZ1AuwEc0AJ1QF1TZAmmQFewcLWyGmqxoBi2ykjvNT3vdQuzgDaAN5d9VQljmJtnFgMsypgteqyMiUWNgAzGASDecETSapmfaQzjKq6+oAu5ELiCmwu6ULiEqwvbGq68oK2+UAw+Wo9ApGRO1A1Wpg31MCDPCqV/AHGHgAc8sAQz4AGlSCZncRZsigMOkACWthbueQEQsAALQICDWKYXUAKDwFIdExMBRj8xo3Un0gIssABttQIy0Ac7oafmKUm7ELLLYAgyYAIRQAGiCmlmUouT2pRSyQK3xhIvNTDmpRKM/yZWuZiSgCRAinagO8OgjBa9FMCpoBqdDuCwbaUBsVMDYbAHhLAfj/AI0tK//ftmb+a/AlwJmEDABTwtnmAKgkerHTSYfIAFEakCbOu2urUDOxC3WLQJy9AMzAAg3WCZOqqPmzmau9GtuVALuJALtIDCtTC4hVu44eoLvLC44Oq4ybAM+qhP0/AM+3Qt3fA43qBl9AA5w0AsD0cIhKAFvCklYMFSG3IkHGAADkB3gKEma7WwBxoYYeUUFgt0Mkk/J6KlMjUCvaMGqiCyuyBfCiNJ5XkMleABFRABC1BKYze9HEACYPF+qgRpGxBM+pI/k0ZWaLoBfcQSLNIBaZqmTf+rEvnTsTWnvk67ARIwiCxbyU+rBHUgCIhwCHnQyX0QcRGHxH7gB33QB4BwyoaQyhCnyqmMBmtgyo1ACkIVFLPwd8kUC6aQCO+BBzuwoiqwojvQA4cZBTbgA8bqtrKwDMmQjwbSDM/gzPWIOkWUGzecG7shDL6hp3o6VMLAG97MG0CKDLoBpLzBrLjRDNjwOLUHxED8T7f3T9iQCyvkCIZACG8gA2FMJEhiIRixAAlAd4x2xWTKsGi5aCewBysQI2biL8WDJgDmEipRAi3wA1PACcKgp2qsvMjwSJ7wARXwujgjVnQxSrd2x7fkAtf5cxFKVjMLUzKryBNwi3+0s23/BbRA21YyywEqOwEOoAESoAHntwEWIAEWEL+VzLIlgMkb5QdzMAd6EAdxoAdukAd6oAd+oAedTNV9oAel7MlY3ckUDQd4kAimoCdHZXi3TArvwQdqAAQqoALJsqK4KY5R0APjeME68AfCoMyeyS24cZrQ7NeXecPKbAzEgM26EAxpvAvB8EjC0M3EYNjGMKTIYNjWKq7EkAwc3KwA1cNAXHC98hzdYAyzCQh6wAYBxhWDliQhcRIWIMUd4JxXzLCyq0ClegU58FZs5xYuwUrcW5MuYaol8AM7YAi/oM0jq6cbHRQxkAEOMMdRBWsjzRVfQXboI2mLLNQRWnNOCxMW/4DTZDmIlPywNj0BTOuSLlACEyABEhC9nOqe0Vt1Rs2yG1AYHzIHYQAGXgAGbzAH/A0GYNDUb+AGbOAGYOAGbhAHBe4GbfAGcNAFNPADUbAGhnDGwFDLaH1tm4A3eIAFafDWyRLXO8AD4LhuPJZQOtAIuqEM66qZLn6a+MjiRnrZvjC4gVu42hoMxFDZ4TzZfDsM2TrD6LrM+QgNs/IqwdIr0eE43tAN0dAK33QihLEktTMEXTECCZAAPBO7DEuWtf0zEXABfwgjkcbb9OM8kagvejF0SbAESwAL2ozGyk0MOHIHFdAA0G1Kt0QXYbHnJH2zMUJ0L/3SbmXTPbsBuP8IluJd0/Ad3mLF3ustnTVn3tHJsvErvx0gXbtzA1OgBQD+BgCuBUuw32AwBVOwBD+wBFqw6l7gBVPwBV8wBclCA1iQCLAADMcQlBgKeJWAbmmwBFgwAynw1nA9A7h5wQlFWeKoA5vQDMbA4i8e7ZqpDEU6mqM5rjLMC7lAw+fa7ddKmsVgruAK5L0wDOrK4qaTTz9UDT6UTtoAxNnADb5gKo2gsUtSFWLSJaCYALELu7SNxSjZMxGQA0Q3S5H4MTgQYCnCUhM7MCswBEsgA5pw3MqL0UAqC8BQCc4dAV1hMjDAFS+gFBSIirf0xzCblVAJSGTV3RuAU2HFqe9t223/FVYjYN4OW+g1ddQ6jxeZ3iHgwmebbkdDcAOaPvS6I/Qb0gRT8APFTgO2nn/zVVSMxAqLAARYgAVL0AM9oDnDLsFyzZgoXlmuoMxEPtjnzuJIypnpypk9+uPk3gu84AvmKq7Xeq3fDOTfuq1+ywvo6pmemVrmQVrU4B3xNA2iDR7HcQlpoTF0wgI4YAIHmuUEyOUETabj7bBwNQLbjT4uU6dFUj5cyqX6gpND4AU84AhCJUmFq9zIEBSgAAISQAFk5/HyU91VQmDUqxa1BhP6NZ0q4fgsILMjwKA+S5aGDvNv9aCUjhc6b+k6v2gmsF07WQMlUAImYEcBaEe9w1Ir/xriMzCxydk7NhC6Xf8IsLBse/owGKoKfDADvZw5ws71Xb+i+OG2z7LXQnqZzWCkR+qj6fqjAIEsmbFhxAwSGzbM18JgxJA9hIgMYbCFvoZJpDjMWLJkypg9i0ZNpEhs1LBtQ0nPG7eSy0qFYrFihYsaOHLgwMGCBQcIFCgsSLBA6AIIPYsePRrBQQQKMjmsKDGzRosWNWHAqJH1xYsbJ1iYaIHjxo00qn7dsqVLF7Bdy5YBcwXLxlISJ1CgsOsChV4SIvz65cDBxIoRHEac6NABAwcMFyxY2DCisOHCEyxccDyBwmMLmilYvhAhgoQSFiRskJBaggMHqRuoTj1hg/8JDhpka0itQbfuDSV4bwDOm8MGDb1BHAfBoIKHFJZg/foVK5YrV6tWqfI0w8NxD8s9qEgRXoUKGTNinNdxPkYit8uQtYfPUT6zZRwjun3Y/pgwYRENCgMGGLWC4S+YYNRCUJdZdrFFFupaaaWWVyaEMJVSRHkpFA01TMXCUC7BpBFMYmKhhhxuciGnCC6boKgEgkIKghZjLEo0C0aoYQUSXXChhRVa4DFIH1d4ASywcMhKBk+gs2WXXQR0T5hVfsEDtxH8UkyEvvRCQYTEOOighd5KuIADzDrgwAIKyrxgAslG2ODGETC7ILELfHpsAtFEY22B1UyTIE/VWpPgtdT/WEttg8A4KAE1CXarQIIKfCMOOOKKI64CTDc4joEGMkhBE1BGIWWTTTA5FRNMIFFhOxC2qwC5FMajVYXzzEvvEvze4/WhgxIaxsADa8mlllpkeQXCVlAZRRRRNoTWVFMvobZaa6+tFtVNoC2llA4nfAUXXnjxpZlkmgEGE1NmMSWrGozIoQYWYEAMA8Va/MkAoorCdwJ/+V3zsg5GSBGHIZCkykevXNCxha1u2MoFnbIqYZJjoOOvPwCBMQUWTUDQoM4OEOsABhJQIEEvF/qiwASXyQSTTnsTS2xOwwaeE7PA6LwgTn9hm0ADTSuwtAXciK4UNk1BKMGERpvGbbjh/0poOjDiSmAaa+RAMA4EFRpw4DtNKsFk7EsgqQQStfvIoAK3317OOw8y8MADTz/9IIUP/mjkD7//BvzvRhrB9pJtoQ2l21QmFHdcx3uxqJhijFGmcmY+AikazU2yJptsttEGJW9G9yaddEqnx3Rv6KEHm2R3iUWUFbI6EQcXvDpBBAx8ogADDF40qnefAO59sZpLdMEII5DMSmGdWBiyhhckPmGmFkpI47lbngxwl1tuYcWUTmTQ4EotR14ZZSz7GnhRw0yws07JFKO5AxNOOGEENOn8LILhglsNolxjKA00wFOtKQ5rGqCpRAEnTaaJ1KEc0IChLEABBxjAAA6wwf8DGKCDHMzgAAJwAEAsohJpc0QjEtGHRCQiBQU4gAIYoAAaMuBudKsbCDKwQxDEQAdA4ES1Dqc4xvWiIfNpRhKbEY0las6J1AgJNqQ4Rc9V0XPawGIWtbjFLIIDHF0EhzjQMY5xqOMc21gdN3whCl3EYhQjygG8ciAxEeBPd71LDAYgkACkaGZGPvFdB+p4gsGkSCtDMoH+RuAylxGJBfjLn0xKIANReYJUpiCFKEjhCU5oQhV+AIGZ/EIBL6HgKnshQV/ANJk36c9M9jOBCOoEP8FMpjNMoYBSWDNBsA2FhhY0QAEM4MFhFiCEIgxAMjMYgAEIIJnPfCYApCnNZE7/05oAUGYArilNBjgiESh0xCLCmQhD2IABjxJa3bYzq1rJYJ3ogYQzlDhPJTrDiZprRubuCQ1oREMa0ahGQK0x0IFa0aDZ0MZBr8hFhmrji9+AaBit0Y1uGCMUurCFKU5FEyTlwI722l3xGnMBofQkpBSQkUgdY5jhjAB6VFkBIxMpgvc1Mn+HkYzTSjCHRzyCbJoY2wkdMQlVWEIFZuKALM1kyrusz2bAcQxT9sSnPu1SKUNJQAEE4ExoalOb2wTrNp+ZwQII0wAvetECGkDBXS5FrWtdoKYccLS3zW2tHrAEKBxBNkhMIpyLMIQhkDA0t6nzOOEBQXhSoE4VpCcU/9SYz+Uke7lnVLay/IxGPzXHT85CQxoDlcY0piGNz3ZOGgJVKEKzeA1tsLahrtWGOBza2mt4jhmloAUwVmGqSkhMJi7wi++E+xnP/ARG/uId7wJpLxEUBjhNK4GZHrOZninqf47xnZoAJQNC+IEQhziEIrob2D5UYhIpKEFhXMaCwvgllSToQF1amT82RRUCrIGAUvxnpswABa1p9W+ALTjgt6qVl4QCmwPc1hrgSIADEljBaQQzpuhyYDRB4xTReAOCFdxABl7jYSdAQTZLrKqvf+UB3TTAncSu8zi0UucMgACEXESDGZabbI4na1keWxZzmw1JSKgRUNKelqDZIP9oQZGcWpSAjovg2EbnsvGMxelWFJxY1QIc4F+0cjkBZ+0yH1OaXOX67k4WsHACyCpMtC4FMhvQ079kFIH7NiABEiBDHPJACD77QQ9+MEQf8noIlxVmBC0wQS4pwAES3GlNw7FMYnJ5J9HUKJdLyWUE4qzpy1hgqrpsK6FyUwEFrlVSpM7NpXCjGt8UxwRCi9SaJoDOpx3HaSBoQRhu0GIPAAEWIwbqCdMGCUcoggYqflUOEwueWYXnU9+JwR2WQQ0d5/gZH+lnjy2rWW4/o59QDLJIAipQKafW3AvFomq3kQ1uRGNCxJAFKTTqVy3/t4JYLelRhtcTMosUA49J073/l8KnCFg3Thjw179EIwE/JYEOdCDEHvZQBz8TAhBLAoURAsMUzKypTCLgXQf09Gkth5opI5+qAxIumpHf1wH3ze+WtbyatQqFggZejVAIVaZEaaAEqrFacdQkAT153OeKkvBsOAUeD6wBFp6ohCY8oS5VDFsRMziObgx72BQkNjx0A8EMdFAJezoxifccyUimaJKSqL3tbp/i2ql47mzMve7m7gY36l4SY5RiGLo4xSlMkQhir6ADWp5AB1Cq8BrNSEYyalHCE57cPEEmTbZhub84DZnOyPkoegrKDR5ehzoIgvTeBYQlfgELRjhNAplmE5byi9IVTWDg+i3KwEOT/2nLsLx/uyTKvYUfFKG8iIYKKH5QHEAB1jBqAwhEjQYAJUEHdEbl6AyabKLPqVeBQBG/8IQlNMGJjoGf2I7Qwda87nXwLFsGOBS7J1iSdpKUJO5xr78UWXJ/z2GjitjghgCMuwAkQAHEv5HQHGeQJyWqj2SQCIM4kFxoBVfYBVcQBVaohDtIBECwsAjYFwt4uT1Bin2BOaR4udzLrz2RPD3JvRBMQZarNPzSuQkQihvgM0U4BEaQuD0gBEWohFk4hvGJtT1yABcYuS2rkfxiEzrLrxm5AH4pk8WgKY/zPZQiLjqrtKMggUobgdEQoADqNJ0xATgTmtBgihGwAKo5jv8NiDDR+B9Pm6viwBSv8QBNOIbwA6qOgbq0SQQZIA8/LA8ZSIEZ8MMZIEQZoIHx6IEd0IFZ0D8BLMBIJED9kyK2EwkFXMBm2BUIDAZbmAUHaQULuZBnkRZMqJYTgoTBUcVVHBy0ARFOIIVYAIZbUAVWiAVMMC9CUIoW2RdNY8ETRAoszK8mbBHW8EU8uYDG0Aw6A8YVZMEU1BMXXAATGIQcZARKqINB+K5HgARVOAZYyAOmeUItywHaQA1gXJF/+4wUTMEnbMJHo5mTG7l9uy8tq0ctu6oFUIqbW6tdQrlIgbPXqABNcwB7SRNGCaUSMEY4e5RH0ZTi8I1mg4VjAKr/8RubRugrSLi6P5SBjlQBr5uVjpyBHZiV8/C1Y/ieW5iF6XAFVlgFwcskDeGEUjTFU1Sbm1QbVcTJ82NFVUwEVmyhQyAncgosQDBKQOgDPsCDPkhKPjDKvQIFWIAFVdgESDgEOgCYkiLBz/MX3+m34dKMQKIZ/ekARbmlFdwM4fqjdcy9BdCAQVAERWCEQ4AYQfiuSfCEi/kY2+iTMdSN10MpCLAAxdgTmdOy4EuKPNEMGvEJPrm5oXiNPhE+GoKrA5ug1sDH6oMAPYKAFygEQYABlNE0gQSbBoC1FfMAB8iAD/iARpg6aTkVYZsEQMiAZVOsFysPGrABG+iBKeDN/yXogjXwgz4oyqMEBEMAhBZSzuUcyhYaHOZUzqIcTj3IAzy4g+uMguyMAh/wgR1gRB0wxBmgla5DjrqBG7dZK0/ZoRSIgShwBFUghaC0AgxQOcdbgBXkl7AEJOE6qeLBmTdRjOHgHX/RLgtgLt8Jy5DiRT8hBEZw0DjYgxbYA0RghEmohFv4xjSogAmAK7oKFAvIrxvZAF+sNIK7Pe3ztCPsx4U7lJobCgfwFE/5pQWwIRmaIRs6oF1CvhPkRRHIhE+IhCAN0isouMCIipi6gSFQ0jf4MxHRKEzgpE2YyVUJpz7wgyulzjx4uDh4ODKggir4Ut4sgiLoAi7oATXogf8f6IEesAEaMET1iAFmI8/yVKc6rRscstO6+YC52aE+9VNSayu4ElShOL7j26DjY4D1vAM+uAPvaj0LCx7OdLzF86PJSzjOQDOcSa+WekOAqzyf0BMDbQxQhYCS2wMHZQQ3kIAhGAREUIRHwARVcIZjUITuuDm4IbqRezOAI45Zgww42QC30Y1ImSCaS7Dz7I4FK6w8PazxKEQagNYd4IFpTQIcIAIiCIEH0FYhyIRujYRACNJPAFJBEIRCKIRMKIRBgIIjUAIlCAMycAJD8ARVUBVPMJWpM69KgAM/hSscxVHkK9Qb9VccraCBtaECszmD9ddCNVQO2qBhgthiKqv/iS2rYwohYzqmsuogDyrUDOADR6iCM1AFQtCARALRx4M8TSMuxfRFXrUURaEaqvkf4oiNzqg8TH2zDSgTM9mlMGAESaAEHRSEVn3VR+AEVdCEPgAZoXGAZOMaRaEwpxkME9CKGrgBIxiLG/iBrV2CKfCCKXCDNwhbMyCDh9ODOUDbOFDbsAWDsP2CL2iDNEADNODOaeWBQ/TI8cCaZMSABwiBEAiCbNVWbUWABwgCcQVXdI2EK7iCQCACBXIABagAP5gES/AETrJX3poEG2DYQnXYGNogYyImYcIgizVdZOqq1FXd1VWm0x0As+KggO1HuAog9YuUClCBHpADQ/Ar/0Kog1/4mBTQAJVrWeBQk1nbjeTVDUaZWU6JWegaDKg4UumVieqtCnepCZxgnjmoUEqgBETwA0Rw1UmYBE6ABVMABU1gBN+dAz7js4k7gzOYgzCg3/pNgvu93yTN2jb1Q1rZGj5tGwkqzfRUWBut0c5VALQq3BAQgmxFAAJAgAiWYATo1hAIBBgIhCsIgsX9ViIohDpYgAqwATKwBE4wYRM+FbRJAdNl3WgKqxemJtU13Yn1IIct1ARAVIUVVD/1U3VasVepAEM1gBAygAaQAqcEhDeoA0twBDz4gRuoARnICiMIA+UJgzIoA7SdgzrYQR7kQfd9XzBuVfElY/H9Wf9UFd9BaFUw7mIqRtvupYQcDK9HcARI8ARY4IRDyIMlIJ+H7A7YENR+XdgZQuBCNmQaAt3P5SCIpViKFQAIXoC/deAJjuAHQIBA+AQhEIJACIFI2GAhIAJPjoRO2IMEaFoQOAQRAwVTgE9P0ARAUIAQYqbTbeTXfV2Kdd1bnlhF5uXYDdi7EcgcYs8YmAEa2IEowAI14AM+6IPjjMtHAFpLsARJOIQ4kIHIXabULYA8AAVScAQ9qANVUIX0pQRJcFDw6rOznYM3eAMw8IIlGAsa6MiuU6fzDKBATbAJOmDPjaFhCt1hUoA4OIRHYIS4NGhDSARHSAO7EWKJxeVcPt3/Fu4qGKboaXKmbRKASrbkEHhgAiAAwX0AIfiETAgBko4EIM0EcA0EKMiEQUCN3pBcGyAEVZDK59CEr2GAQ42h4/sUAzIgYGaNwsJdFQjPNM3OLNiBZL6DZvYBNFjUP0hO1+yEywUFT1hlUBhnUNBqraZpcYaFWPieWVDJmp5Ksp7K9D2EL0iOA8BYWk6mDLAkTJgESRAqP9ACGcAaNUQOSxnWBYPRfWbYAjbghn3YiIWhBVoAYaKhKZAE8n0EHFQER5BsNcjp0JVl1a3ozNbsiu4qY2rr1y1cS/Zov5Vgwj3cTwgETI6EX/gEWBDXke6ETNgyAyiBX3IAScgERNgA/xXIhCJQsMPKzR/IgiwILEMY6El4hEnwXvHrBE3ohOZ27ucWscydSU6wJE6aSdiMVVPgblXobliYBans6lVoyZZkBQcBa08Mb/Geyk6QBD+wgSDuoInN5bJKpgOAhFPgBGlOBBz0AzCogefNmqyBFKGBDQUIphh6TAsy5Iet2GPq7CFWpgIAgYKmBEU4v4SGBB2AcBeOYYmW4dWF6BGH6AMg5EWGAAmG4Am25I3e5G/90dd+7W69gsil0QOgICXoBEqQgGFykQW4ABuQBOkWsU4YZ3H2BFZG361mck+YaszlpLPRFik1FVNUFWrZBGfR8sud15r2bk8ghVHollbwFv8ICevwNgVNmIQpUIHIZetGfnBaLgBmOgBMOIZNsgRiJkThLRQBDmS1qiDkW3Dk+9ca4meHpliIBV0DKNS1UgFFsASanoVJv4XVc6EM+GnA5ude5nQbriEbWqsdYs288aEd8AEgcOo7gGrnVBuykVJPKAVUcIVYyGocKNxbr+QIzlaOZvHB9VttZeALDgKaQr4EaIHYJgIIMIA1WQB9EQpEeG5QkO6qpupOqARLiPYif+6KBKrqVhsQkdJnQZwN8ZZUQAXyjgUg/IU0D8cG8ABIcIj8aI91lwQpyIATN2w41+WMtW9m2gRnkDdP+FN9DuR8hhsPWLFJ8siOZPiGF0n/QMzb8ZhT7tAAD9gAiz+O5UisGFiDRIDFgL/cSuCD81CsvBEPRDR1NFADPMiDZj4EybbQa9eEV7ckeTsFdJeOWWgSJwkQYACQjNmPjAF6ZBB6YYj3ZniPi/mFK9gqwi1tS9b1B6ZkqHd6S+bWSLADD5SAH80EEQiKoAgCFEgAH5Vxrf4EQhAESZAEQYhvh4GBE9kDSojKspZKsd4YYBCIyxm3gHoiuVuGW4C6NGgAtm6mAWCAO8CEZsAGYhCFRoiBDChdIpbYYsp3+r5Y+9YgTHCGWaBp75TWJeCBRdzaH/BOaHVTaDVEkXTTYnbThScPjiSPYvb8HZiCLNiCNGiD/zhg+Sv1ru+Ky+8Kr8oNNlRRlW5fZVb27lUga7GGDp8/hueHfuiHD/yY/uq3/vZIogZ0C2agJyUCCW6gBgX8hSDYqo/m9V0H6UB4gBUv7Qhu4BYv6UCggE8oBCg46UywAxEoAHt8EWHqBBkHiE+wMl1IsMBBggQGBAQAACBAAAJBPrkg8cLIHD+KKIGCtQwbN2/06NUrObIbN27OkNHC9OeDggEHDgyAaHOATFizMuDsOYAhxAIGDBQoWmCA0aRFeyYNIFOTM2CsbsWoGkMFVhU6dOzwASTKljR4+PTpAwhQokSQIE2qZOmtJU1yNXHi5OkuKFN69arq6/dvX1iwAv97yvvXFKnEnhKDAqVqMCtXrmJRnjXr1q1du4ABE+b5GOhjyEYvQ7bs9LJmqJuxbu3aWbNn0WbTpk2NGjZs2XRnS9ntN72Ux2AQKI7gQYgHCEKECBSIeaBfxAkgoI78AXYE2h8E+hQpUCbnnzIRWRApUosBCQrdkKDkE3yBvz6doQBhQcIFC7RrL+6foQBABSgAAQu0UMkuIpVUDz3eODPKHzEwMFNPARhAU002FSBAAZQggpMBNonolE9MKXViUzKB4owwgt314ot77eXXKjWuIpkrguko2CqA+eiXKar02OMpqhR5yil6IanXKKSIgpgpp6yS2CiiVGlKk62gkgr/l6146YostdSSSy+++BLMMMQQYwybybjJDJzMsCZbNLjllpJv3nQzEp99+vlnn3pyc4wL/S2XHXJCfCdECJl8IoShzT2nnHEhRALfdyEoGh4EdmQSCQcSSEKJozsK1kkQGEAAwQSr3rddctspx19xQEV04Sx7jsRNKTFQiNQCOEGUgAIk2kRggQssdNRPto4oIk7MmngiTgxE0cguwtwiCrdWjvKtKHd1O64n3YrLLYye1LXuJu1uwkkoobg777zx2nsvvqFwmwsvuPDyCi240FJMMWyyqYwyzDwDzWx2/uaNSIBKPLHEEP+GUkrUOLNxacT0QgstrIASSXX+Hcff/3IhBMGoEPBhYJ2mmQiBHXXVTQRfIEIoGskVIjhAlEJEGbDACwLF90kQyi1wn3768YcddpoyylysBARIaSfc/LbMHxNGK9RQQiMkdNgF+IefUGATBTaKSpX4tVFONcAAA5eZwm2+eYuC796ilPI34IGXwiXhrxgeMC+8mDnMMAQb7CbCcdLZMDXWZOMncBRrTrGe3WATzTPMKJMMwf2+ksrfm1yyeiON/PHHHWgAsZUOVekgQwwf6P5BAwkYV93Js2oXs6PjVfeAEM4xOmtyBIQAX/I6BxLJAgIkUEAAAkCQAwkLuEfCFfFlEsLxq9q36n7aLZCozsyxzCjKCHDwiP9UOjCgwAHYJxW2AWMbEPRQEnA8BPCvgGtTygFRZECkpCADDICFMFxhuFf4K3GJ80XjCEYwhEUuTtD4oDSqUQ1rWC4b2jghCrehwm1ALB3pEMc5YihDdaxjHfawhzvcYQ95oOMd8vghEO9hDwadpBsWuxjGsLEx1ZRGGMC4xSxkwYpS7E1emLgEJFoHiNfdIXZAAILsare7MY4xA2b0gBnN6AAPsNEDFdBABIBXMusgLzmzisQvfjGQTKTsO+eZFKK6I7P2WSoEBnEBBMwmgitAwAGCIAEEOiGYmRXnARgQgQgwgAH7NO047puazpJHPqiF4D5spFv+4FaU/yWgd2r/M4gDILAdAhqwlrY04AEUoEtiFUABbfCAAmBxjFmo0Bss9IYLkenCdLQwHeUoxznUIU11zFCaNZQmOsahTW1mU5vsYMczx2EOc6BjnOjo4TvSqc54sJOd/IjHO+LRD3vQwxios1e7VpfF1rXudf7kAx/uANCBCrSLd8CDQWOHhoUCwQc82AENaDADGaSgoikAAUYx2saMcrQEG+BABxbwu/gh51JQE4IwxzMe5DjnjyzTFHMy8alQitJq2UuACESagEx0ohCCEAgsPkE+AWjqkiQIAgxCIILz7Wd9UqMp+YbXPu/NjQFD2VDZ/ucA/BjkIA3QT0K0gwECAvCW/Mul/y7TqgBiqVU/B2jAIVRwAFAs4xb3uOs+7IEPfMhjr3uVRzsC+w8g4gMehuUrX+UBD3m845uOdewzy8GOdgC2HZF1rGEje85vooMcnh0nOdFxD28w4w9bqcoXU6va1UYhCmhIAxrUENvYGlQNtl3oHdiw0IUuYQlZyMISeCBRGeDuKlkhbkRtENEbMHcJQxhCquZoHKit7DxBUNkvjgELIrgAPpo6zyBnpqnndCcS7ZPeAwqUAFtpLxOCyaNgAkEpT4oABkFYGVJRoCqnLUBlUovqctqnEAcQGG1GCWACLDAC/IA1aAUI63LISqyZHOBCCUCrWjOc1qbppwEeboACQP9giR0cgBNR+QeKU9yPFbO4xSv+Rz9gLOMY03iv+7gxjm/c13zgOB8+/rGPDQtEwxq2s+Q4pzrbIQ5vpOKLYqQd7SK6gylDNKI08EpDfaBlH+xWy1TOMpWrPNGsVJTMFk0BcdO83BvgwAXpJRCy6Bjg+Jwnu58YQibyOL3x5Ow7xwnEdYNwhUgkLXnOESkERFAQ3xGgO/IRjFDl+AAYkAAGMHDOFYQQBP0yzSDJYc7TkkoBZSXAAQpYwFrDtoAGENgBHOAA2Wo5PFKzdZdr1fCpObzqD3+41RJYwA86gYYDQEUYKT42spO9j38su9nMfnaOoy1tHCe72ipm9o1jvI//dHTjEnfogQxUAAIa0G4G5j73uWOA7nWz29wycHe4VXBmELSRjWm8txkrUAE2YlQDHDgBAgaUPWRlZzlH02NjQJFn0HwnZzsz78qQQwTwzCx61bPVg0VAhELAR0dIS2/NcrYyQwci04zqdCcrCeqE4C+tBtDlAbiakP9FANa3FOByIJCQWutSP7neNa9Z3WoHSKDoEtD3GyvgB1AkQgGYWMk++hH1qUu96lS/utSnjWOrc33qz54x2Gks4xTn+B/3qEcx/oCGKfxA3hFFd7jjbeYzz1ujGq03GvGdAQd4mG4f9ruHK8B3VmdA3yVYb4BsYrX+EGDS4wHFL5ZxjGU4/0OPlid0cz4xn08E4tLngcIVZKap8eicBAXJXvYMYALNB3Ug5PudpmBwHpKXHAb7Zdp+nJez6qAawz4nClLUNjQOlNWAw0O5fhjQtF4P3ehFR7oGoq8BD2CUAzZghCks8QETL0Ov7pCHO9qxDnaogx3rEH87vi+PeMAjHvKYh2IVS2QgprP99Ycn+9k/Dxbjfx74bycAvgOKvdg/4MM90EMo3MEf5EEcxAEbrIFspQEbuIEbTCAFskEaZOAWUKAbgIEHggEbeIEXTIEWkCAJaoEWAFdw8QALsuBwEVcJqEAJzCANzmCayUANsFkHyBLK+IfJEIFAgEZ2bYwzwEIngP/CJ3RCJJRKUHFe8iThINiBeX1XJpAAAVBAIBQCpUEA0LxAJ3iH6KXX8JCXeaFAENiBINgBEVwX7i1NB2zKczRS7y2ABmyVQiCQUJza2lzVVQ2AcaCAzqFaz52ahwEd8/ma0RFY0bFRBYCAGFCCKXBCFGhCaXyfJdYQJmbi+dkfALIfkX3iYslf/b3DJ/7QisWf/IGiYaUTislDPxjWPtTDM7wOH+CBF7zBFqzBGqSBGrhBHFTgG7jBG7BBG2jgFnzBF2yBMmqgF2xBM6bgb2XBFPTWEvwAD1ijcNHADa6ADHAjDa4AN6rZEMgAC+QAFCzPrFhNcZBAJIAG5R0DEW7/jCdowhG2Hiwg4ScQgRAUj3dMYfKIgNUIgAGIgCBEghQOAges2qXIjBgqB8vkTAhgwMYNwhWoYRBwEgRQQAd4ikyZFwkQGAisVYMl0B7+TwGxzQAYwHHAwKhtlSESnSI6XwUY3RtJnwbUZEbZACFYgiqQQiKMQjMgQ/yFYmABkVEyVjq1kyqWolEGllNWVl/hwz4gFl85pVU65YrFwzy8AzowU5P9gR7EQRNQwRbAgW3pIhy8QRu8AVuqZRt8QRpwQQamARa8VgS+FhZkARZggWtFQRZkmUNNmUTB2w1mhQrcIA3sAA8Q1wzcwBUUQufJCnLsgTCBBjJM3mk4AzYI/8MmVEJHdIQe9UUhXEpjxEfOfIrOicB6WUgELIB7GcEQEI13RJVxzAwCQGQhqAIoaAIjCAIUwIB+UQAFaBJHZgIUuECoeIADpKTMkaTQCN9JCsVxBIEIRIDgCR3RHZ2+2aQGgIAGbAB4hicIiKe8yQAdPIImPMYmxEIzJIM6vec7tEN8xudiwUNSstNSoqJVnt86yIM6oN/5hZ/3gZ888CeAol8/zIP/mYM4bEM0NMId5AEDigEVOIEcwAEcrAGGtsFatiWHcuhZqkFdvtZC1aVfupaJ/mVgPpRg7gBhFuZhMqZi8oAKzIAN2MAPlMFoEgEMJE8hdEIn/AJsBKVnCP/DMuCGM8hCI8QCLETexhzDLyAhKEApfH2HHvHoeAjCC6yaA9xAJyCCCUTApVCSyQSY1ACVKnSCJFDkppEABqAACkBBR+ZADawARknAg41kAkFnLQmFAGGAEKBABGjA80Gf9HVUCYBADc6gCZTAChzmRBUBIkyCJjSpKuyCasCnOp0TOmkqVzrWfqLfe8qnfLLDfJLqO/hVYrVDfQ6lYiUoO4XDN3TDKwABH6hBhqoBF3CBHMjBGKiBGASrGJABGQgrhVIBFXxBMW5BFihjFkDjFEhjND7rNFpjb7XgQyXmDtQAt96gDFiZYgpmFKiBHhCCJPBUJwhCIfwoLDiDnTD/AzIAQzAgg2ZyAzXoAms4g0o4g+RBaZMK4R7lUScMQTsKbAk0Ygl8AhLCQiRQig8WxxI2B2gIhil0giVkQhlwFwrYV+h9QiEYQQ2kgAO8Uc8JYoXxT9oU0Mnyj37EHngeakYlKgikwHHFnbfWQAvUgAzcwDXqASVUAicI0xAyQzlxqtEeLZJxZTqhw2NNloHaHyna5yhGrX3CQ4z9UH0updX2AznEwzdoAzc0AhCogRyoAWxhQRfAwRiMgbG2LbIiaxM0gQjO7dyi4LSioN2qoApi64wKppppI3LdAETxgBr0wSFIQj2qwqdQgiocAzfciRIxEUjgCeXiCRGGBpRS/2ke5dEngEbliYEegAIiZNcxfAIKSFecPYB5BYIQ3oIp7KbFKgEM5ADHOkokGIEMVICHmVquwRz/JMALFB+FVVgeOtUVBIEJmICizmAKxGA4IqY2rhlz/cANDAEPZEEaxIEivIUnxII7RkMzsNN7jpOnphNobWrSourSdio6FeUPyacrpiKRwWc73MM+dNbX+gIQIEERiMEW7FYadCiHKisHdqAHiuABfyAYeAEbeCDeoqADP3AKXisLTlkFVxlj3uAM0MD1ZkEePEJckMJg3MIvAKmQogQ2dENvKJFmTq7WVO6+8mu/Yi7pCqEzCOHkYW7Doi6yIID0AKwqzGMlqP8CIxgBERBBRdruENxAHTZY3+HPHiYAFADQhanVySpABCCHHUBBzprA884At0rZDvQAGf+AGf/AEkzBFHgBGBiBEbBBHJQrJchF92JmnbCTZ5nv+a5TPJiDZ5GDOplT0uoxO5iDqbYD07bDN1GWIrNDfY6i1L4nO9xQP3zDN2TDJeCoFagxECxBBiorW35oAR+wCBqwArOxCD5w3apgb/1Wb1mjBbPoYA7XBpfxFBSuIlBqR8yCK8wCPJ5GSPgG5YLExmADbtgrEeaGDF8u5rrjDWMuv4bGLzzHHA0IgRyHogBsJGICJHQEIYRBGVzBoH0CI+AAE0vAV3XYV0Fx2Mz/HCvhWlplMQqUXA7mLM/2QPVOYyur8RqrMRu/QQPGQRgAtB/4AXrKxSh4r2hoJvm+gzmZg30Ocjl9lvkCsqd+U/lltPhd0zQx8o0pslWuLzq0Qz3YQz/wAz0owx3MQFioAQSuZRy8QbA6QbASK4VWAbESaxWw8QIfYxooY1jMZbNKIz9TYzWe8Q/0QAVr69tB6g78wBS0AR6gBXo6hk7Igi7Qa0pEDJ9cjEoIwzEIg2kIgx7pxC1wBmY2cx6p9RD2ax5lQlKVDJwxhHXsI7/CQiRqgiU4QiIAwy8Agh9AARJHQhnorO6uc+8qwJ6CDYZl2IWcGgSggDi7wA2kmbmJ/zELUuNvPfAWtEEDvsEcxEEeGLQlYAInjMItFCnlgRZrm4NIc+o7kMM4kANo0XZrp5P5TZM1xZBu19A3ycM+gLRTSm0PtQMl44M3lIIOzIAX8OIdACtbsq2x2rQYVAFOk4F1g0EHNmMybsFeCvVvSYF4MwF5lzcSmDEZl3E2WtksP3UajLYhOIIleMJjxMIt2IKRHvNI6Ak9YAy/ysJlkEJgDEZgDOGT0nDmaq7nRjOURkKsVMdcXzPyfMINwwIp6PUkJMIfbIIzuEIizMEVBIIggGwNuBHfdRhYKfZZ+V7JelhaxZJk2wEMDEFElTEaR6sW8DQbTGBAi7Ye6EEf/P94QR9CW5h2QmPGLkzeQ7c2aGlTbWvTZ5VTa2+WbkeTOkCTlWPiIr8vOs1vOhn3PZjdLMaADITFQgXwW7Zt21o3mzfBBzYjUDMr9k6reEtBeZv3Gac3LLO3Nm7wD6RBuSqCfBdGYGCGabhrCusJMzwuizTpqUiCJjjGY8yCgS8RaoCGX9ew5jLzNI8S49WKdUSH5PUkJlTCIpzFH+QCN7jCAhJCHizmDXjndTZA0bk4ru0a340s0s0NFlMACthBIBBBGPSWPwtjMIq2hObBjwN5QfsBITy7sxPCITxCkWOCJ6xCZfwCMDA5k2/TOI1DOMy2bZ8Tk1e5lU8TJkoTO1T/Fl+Rk6fW713VAy7oAFZMwYgeIzLStJrXNJtbN93GuZynAZ2bNxIUfMEjtXqL2Qb7+RaM9iEwAgjbRV7AAmYYaWq0sDEj6SyQQkfAgsSbgjBRvJFujMYQ4TL8Alg3M5XC48ZwblQJz39Qx+hBqSd0Jl8Dgutcgr76guv4QWMOQaKC59FtwE06wP2oFQN42NHdZHeCwGGCQAUwwASIQBCM5hXUAQUG9LL3QbMX9LN/vbQfgtiHvSJQu1tYu5N4ginMwi5IeWuLkzloEzhsUziE+zaNA7m3trlHE0fr9rorMl8NMnzuw9l1AyRcBQjY+0JJ4xZUqL4bKxUMa79XwQKL/yBQ//RvCXw0ErzBHzx6JzxEndu7cfAUbMEb4EEeGELZUyp9U3xnCAMxmAYyqIZm8isxbIwuBEMuyIIwRAVnqAlpmDzmzvDKE2EeOfhxwHxxRITzKIqFa0IlQEIinIWGN4IroIQyiMIfyAE41yk4Ev1FsVFV+R3RvdHMxigHZ8EOpMAbsQARnMceCMKPl0W0f73Y3z/+H4Ii7L8i6P/qtwVAWMLEiZMmTZ5MwTK3cOE4hw8dggM3Lty3cA8vOmSIjuM5jx/VqVsXEqQ6du3YsZOHD967dxzRueT47x49Y0BigMiAJAqWLFq0NKHihKgTMVSQIiVThWkVMm7ARP2yhf/qlixXsWZhspUJEq9Iuv740YOsjR1nd9CYsVaGCrduZ9AAESPGDB5rACX6k7dR30aQLkFqdCkULWLUuHXDhs3ZMmfNkBEjZmwyMWS+hB075syZ5l/ANHv+xbkzrCsYEIQI8YA1AgIEAgggEEKIHVCcKjlaBMgQoD6ABjfrVo/aJkKEBh2psXxFCRltQVRowKCBgwoaNoBQIeMGDy1s4vTxk2eJhxIwrmTKVAjRcUKHDimSP59+fUWMHj26n3/SpEqWKqlkEkcm0YQTUjQyx6FwMpLIwQcfpCgjhswp5yOPQlLnwnNCSikldOTppyV0FoqJo37u8SaUGFTwIIMflpj/4qegrKCiiRuFSiopHKuAygswtpAxqyG5+srIscoyCy212HrOybhScCuGHYBAYw0gsETjDi3vqHJLNP4wBJJRdFkGscS4oSYaZphJxs1kLENGGM5COyazOjmjZhlYJEGBNiFgWO0B1wSQ7YEQruhEE0gSMeQ4P/roY5JGSvEmG3picYQRRubQYggtlhvihxtmiK6C6zbYjoYbvgvPj/gYUcQPFWg4wo5MOpFEkvjk2zS/X4H91ddfHXlkEmP9q+QRRxLJyxFLNHlIwYq+gdDaCC3K6KFyLARppAzBRSmlceDpR6YSX0KnH3uw+SOGFDJ4EcYptPACx3tvREqMo+71/2KKfwG+SsgsllgiCyOR+MErschq2AYaaDiLySbXgniHKOuKYg088gAiCiyj0BINIKjcIYqG8fijEUxKGQYZxLqJeTFqmmkmGWQcoyUUVzhbJrTMnMGG5mNAseOKQAIRQmkhVCPA0BACUXSRRI7TI48+8BgQEmbS8WYZASUh5A022AAqjDDAGEIGELIrYYVVlwAjDz/eU8RYSSh55Acv7Lj1E10VKfZu/vorfBJJCid8QGALN0SRZCExtiGIwnEwomsngmicyTfkEFxwMTwppnLNmQcedc2Rp5196tHlDjl+UGEGsGQECt98m5hCx9ynKIIqL4AHHigtCC64YCm6Av8rLLHGYr6HJSFWC+K4aCArrR1+SCMPPSIVD9LuI/3e+zyu/g04TDyRJRgzE/OGnpi5waYbZqLxJRdksOGGNM6E1lOVTCKBNCEEIhIFFMIDXoOAB0RCEvlZBHwM4YdFGCIPgABEK+hBD2+4whKdQIQe9jCHMpytBjeogQw0kMINlGA7cWuDeN7DK0UcIg5g2MOtOrEp+yzLbsHy4a/684hFzNAQfVAEKGABi1+oIj8Modw4MBchzWmucxgiiec89yF0lGseoztdO86RokuooQlFkEEKkAAwoEwBd23cEY6m8Dt/0WtGVzHeEpJ3JObtsQc8gF70mATIHfAAC2vYHvf/ume17vGBfOSLVB7iwLGr+YE3iYAEJkLRimAkIxrccF8GuwENXuDCF81AU/ycEY38LUMVlBhEIQYRiUKoJ4AHdE0QMhG2CRLREL2pIHCYkUFfWCITiNhDHeYgwrMZYVTPiZIMfvCvPBwHPvU5BCD0QAhB4KqBh0jEDn8YzgAJMYJ4SAMeOnEMn2mCYxyZHIOgGEWJPGSeEnJIFTF0Dm59hB3o0OI75CGP0YmDHSOpRzLuoIYi2GAGKjCejP7lhNtNFEdVCdiQ7rgwPjaMo33kgR8lBkiR7mAJaXhDJA+pBzmstJF4kCQe4ACHhMLBpXODFB/4sBdLDiQVpYwGzDSY/41swI8b3PhpN7jRDFtUYmqWSOIvQCGJQkRCEChwQCEoMYm8GKJZvelDIu6A0z9gohv0SIYlKMGpMhyhDHYoQzLJNwWyRLMNcyOE42bIq181ShGD6MQnsuoIR/TqV4tYhGCJ1cNi9edxxzpEH9bgg7Ws4RGUIMRZ4uBOBdnzQd+olhQvt6CMVNFCGtpnSDiSkoW8Ax4Bfck32lGOroUioWaUXcEAFlGKUjS3/xpS8ZbAgz0iqaMOE8tH0yLS6DUsCiY9aRygG4eYwkEOMcUDdOGwBi5wQQ0udWlYf+NI3vDlL5cURS2AsYxmqDJm3oBfN9zbjWgEYxfAIMZjnCGMX//AAhSgyFUmHtGsRDTLgpG6gw6AkLI/6MIbziCmJMLA1gi3tQ50G48epvAGPfhBPo+ohCYGNAn6fJMRiOgEKCwxIN10uD8BssSLYZxiAh0LWY7Fgw/elQIPaEcGWegDISgkoYtc67PWwshFzKFPblnotKb1HDrG8aES9aMf5WCHSLaRjmb8AQ1cKAJc5hWj3hWBjbvFV29lVDDgFowHPXBecTlqg4+CdLk9AORcsZCGNawBDnF4Q3bVsGdBv6ENbWCDv8BwUpfiNKx88N5xAPGe8pUvEZW4hChoMQxO5s+93thGlt/XafcKbRnAgIUqUPyI3hA4goRggwMOEAOY8qH/EvmL6h6OYAQcHAEKULDDHvbwKPEY0ZuVAIUqPKEJgQRxEgNWhIlBAWJHQGISMFa2smP8YoOkWHFBfOwaComHPjiu2pMIMoMqJ89r2XNzSt5nOcSBRSs6RMoLobKVzxFveqQCCD7AwgzoEoMwj7kIt2MKHNEMsDsu/KNzhXOclRRSiNn5zj1YQp4DDYc3pAELHU+DGjiehqus0QtvmEMc3BCHq+GUD4He2CQJYbAsTKENWVjDyO6gMsK4IhjNkJ83gN61DNKjHkDHxjKCEYtVeMISAeaqBQnRBy9UQAEKYAAP8lBhVnCjEyZwwAiIQAQ7QIEIZdjDDAe8G0AowhCL/6iEJw5EClAw/VjM+qaJ+WsQvcc4cTWGlrITZzjDvbja1l4IOSTkWQgpXiKMnye6IaJPcYiDyZTnkD4/AmVzaNYc7+gHGCefDmo0Qgc76EHABT6EghWB9QW/18FvlHCFGw8oxptzR22Q++LmHi29Nz0gc2+DHvTE41iIgliWEIWPYemOcUxDGuLQhjS0QdBq8EGW0JB9NPiA+9cHQpd6oqU/qKwSotAFMZShJmpg45Ma7IaegLELWCT7EfDJy3huMIEEOKAABghDGa7gCOZAEhaAABJgATAABfrmCvbgEJilEjZhEwbsWUjBFEzBEzCQFJJNQBglETalE/LOPwwnQP8gARIC5ARP0BIKIjcErwWNBUD+wxzIAfEYxLPiCRwcDwcdT8ggglsmr/LizbS6RfMoBB3KYR/wQZ80iBZ0oPQA7l1UAEZghPUkiszIrMzY6F9YD80WzvZ+4KN+QPiSRPdwL+Kgh+Kq52FoQPgKRmF+AC3crHlg5KGSoAmW4AeULwpoTrp2wAd2oAkBMeCa0PtKSg0aLS9MEJNSgRaEARnQRGYaQxhuAdk0QT8IwYL8IAwcIAE48TUWAAVQgFAKJYFSw2gGAREUQROWoahM4QHhjhRIYRQ4AQM9QcQcoS8egRE6AdUsoQRHEAWB8T8EwkAsYcYMBxKY5bD4I0BkkHL/apDIPCsai0xzlqwaf3BD1GFzNodEFOQe7mEf9kEdtoEbGiEGxDD4ikAsWm8LqXAKnMAdiyIenaAIpAB5vGIJEmYKjAcJ7nAsgu8fATL4fK/3VqXhyKIIeqD1bABGnq+7sCBIwqAO9sAP9iAQrgAGjCALRgYNlsBqyIcPXGoN7kAkDdEQPy772MANyqd7EuEvIPBAXAEYkKEZ1u8xjuEWlo4TJiE+ok48SmABFgACKAA1XsNpCsU1AoAAXAMBMAAGBAGWLGEznMETpkYT5o4W4c5AJqHtgIAP7qAPLAHuKoGrAqQRWrIl/SItTTA3GivAGoWSLOgPZgxaNgEDZRDx/0SrIqBRGnWwyCaiW5Rs8izvQqBsHMphc8ihG78xH8qhG4ahCc9R+NZxMqmwKCpTHp2AC6RAo8YiYYhrByIzIAPSjwQSufzo9pCP9XrgC76QDcBgCXqADJ7ACHpNEFTABDCANTDACHhAB6KghvJA0IQzDdCAOJ/PjmhP5LJAz/yAqwSr2jhBFFBhFkADGY4BGGLhAjFhQAjBD7xzBaoDAjogBGBgUJTSKBHgaVYDAiYgEnKFEQ6CE5IRWjCQIDDQICbBsMQvETbhFlwBExpB5wTjEjYhFEohFVKhFEIhFC4hMErQLAesQWEMExq0IJQNE05wBmcwL6Nx8fiyLyOkW/+W7Af36SOmaLPA8R/2QRuy4RI+QAf+MSERkjJp9DLjkR430zPJImEgTjR9VPhuIEiFdFQ+qvuyBAgIBka8QwvCQAmUAAf8BAJMQDscYAEUqCmvYAiKAAzY4M8aUg1AzviQM7gkZpBAqqQ45je4ahESkRNGwRRWYRVUwRQ0MMUUQQ/0oA5uQAIaYAI2IAGXRghc4zUEQIH+RAiCIAiwKhM0IXAgwVlesj4xcBNwY8BwCjg2QU0U1EB5oRiU4RmsQRuADui2oRqeYRhSYRMuQS19sQVT7D/6Yxw0VHMqIt0cRBr9cp4ypxp9kPKWzEQhYiFSYh/+gSa0IRl04ANAM/j/HEZGa7Qyi0AeWQ958kgsdNRhflQ0yUJIh5QHjPRjss8HtMA7hoA2iYDsLgACHgACbqAHqMAIIAA2KOAEiGAIakAL4oAK4qDj+FX5kDS45iwt6CxiSspK0pSSWOw/9G4TNAFDF4EQsm4IIsABJmACRkAEYGCAAgGBivIBMvZQA6HXBkEXSXDAGgECI5ATIjACPaES+sKCWhIToiGDQhUHx4FEvuFyyiEk0iEd3s8YXoFBB6NBLyFAJoESXgwTAATGNBQvtRHd9LIvazBbIC8jBPNqfXUwz8EhZlBYz4Ed+qFY66EbQuEDpqQHxJC44tArtoIyMdMymSAPo6AfGaZH/7OVWc+izXrgBlhvDoVrCYqACcgmC37ACHKACJQGBgohCNIjBDAAUkDgDF5AAQAAAAxgAcIgYrKADMiACbpwDvfoNJMrYqJpCqZP5bbHO2PIAQVriBqlD/SADobgAoByAzZgBWAgYwMhBIpSgQIVaQToCgrhEKINQNDSEQZiZSNQ2RplN5plE4bBG+rhHuAhHt4hHrD3ek1EWOGBHfbhHuyhHopOGXghFUQhFDYBE9RXE9KXQjFUEyhhVqWFQyciGtHNs2oQascBa32VV7mFa4X1ytjhH/oBH9IhGu4gA5S1Yd5sbdnWbS2TCgM3bo0HSe7QboNvBn60j8w0DsUCCP9WrwmsoIySAAzq4AhQgDVYIwSI4CJDgAIsSANGwA48oHIr1wG8IGLewAyQr4KFa7hOU5B+WEa2oA1OSg/iYA4aKVIcbTziYAveoAloNyg5AHdhAHE5VikfYGmAN4CQBgoYQRIU5cUS4RZPdmXVFxOQccAGbKyagejugYD7YR7oGHvNpY5dwiWKFRy/9x7qgR6ygRmKARfMVxTOd0FxA36bdnI2iyIswpGhlmpxNRz8t1ctmWtnkB3OIR3UgcrYYRte4QM+IAM6qm4d2CsgmChabx6ZQArm9s36EVv/cS00WFtvQPV4oB+jwAd6go2cVAnOYA+2yQ429lAcNxLqgAT/iAACZCAPCtAFwsCGASAArmAO/EUPFu64vhCkkmt0LeY01exH3GBenk/QIgUPwCAJhsAEgHIBJiABg4AIdrd3f7eLC+gKroASFEXZKEER0m7aTLBoO/As/+ASopfo9sEf/KFYVZSP94HKqIyhJbqh/bge7AF830eorMEamkEXYJEUFnmz3gmehEx/I9kiPMJ/SVQwH2IGuSUdyoHK1AEbGiFeSBlt0xZJmIdtnTVapbUoWvmC3awNd2+W18JH91ZUFg5Jm8AIwg5xiQAGguBQLvJQHgAD7GABDCAAbtgALFcQKjcAgJIBu/QNZm64mAe5lCt6sCdiIOajDGYNhctj/5QPkvysCmpgExeAAiiABKR6nl9jiwdIY+05Eq4gDPzAEzBhE17ML9AyLRsUkw70FZQhg6ZXHxSaor3xG/kYovfYob/XoglYRTc7fLuBFhIUGJqWRNhNtKgWaqnlpCu5krcWMc1Bk2G6gOuBGQ6sRR5urhSGK9ZxHlV5Mp1gM7N5+GDT9HD6bmM0+Mj0Dm9IXVV4UBTIaQIAAq4AB0ygAKS5cmsAgIiAA7a6DAqoEBiBDXag5mbujvx2zrjZTOEavuFaCz6OphYNDxQhhuagBYCSPRNQqh9gFAU7ULm4gCxyBxpBFlKBQVd1/HSuQHFhGD41G7yhZ9OBHkKiHeChJf9aIiVMNCZYK6DaocS/Zej+2B7+QaHDth/AQRscsxRK4RWiYbWdyBlhO5Jz/Btme0R9VSPobZPDyB7ooRRwIgVS4LcduG1X+W2LwpXnNg/v8Phwr7mRWveCjwaWQNegQBACJT1jIykLBQBeYxD2wKulWQASIAf+KhKOwAAcgAU+AVciIRMIwQxyqwvZDL7ROpfvCK5nTs/AtLvw4D0ocg44YAEcIAIwgDxDID212MANPBCmag/YYBOQQTGewRhSgUBLAReMgRnY78I1fB3kYR/kwSVawiXioSXaASb+ySVKvMTdYSSGzrLVYcUVeqG/wSZmnLK7oQhhghsb2RxOGn//Yduz+JdE4e3HIQLE04HI20UH3sUDsLW4rBUshttG4Vb5ks/biboMN5iBbQALlkALcECepRoFgiBevzsAXAMCOkECAqDek5I1hEA9PoEOJCECFmCBPqETMoESJKFcyawNK/i9E55u9fwnlpMNvnQNXoUiTeAAhRIUEUg2UkPSk2ZprsAONiUW2O8axCHDAXmohi7DRQIlOu8dVut6sbfD+4kj8njY/SklTHwdxFd83cEdiLVY4SEf7MEbouFAS8EYtuEeiL1EYIJCRppaXhvqZ/tq9wkjJiIl0uGPcQFL3MLaS1kOFUZ5mrzJbzRuo1zKG3gMtbVhigAJeuAnauBo/5iGaa4gCBLgu4+SAERgzgGo4wdIPUBBDzphEAhgi+u8EPDGSUEXrQHWz5mH4Y3H4evlOLMA5NBADfxAD26AAzgRAhIAA1CDwCU9UBNVCFq4E5ZBfsQhGi1ayc5hHdbBHvbByk6iXOQBHlo+5lsrQzjcelkrj0ucxIN/JfABH2I61VVUHeohG17hQHmhGuChi5Y+MVtatDYriqRxth/kB6GochLkHOiBGyABDagdyTkKrecw+ZiA7Ivbp1nZX+W2gqvcypn1IFmvCW7gcJGGNnZ3gDL+uwECAIAOkQplgvXr16eFoFTBUgXqE4IHD1AEepHCUZQePXws4QEy5I6QIf9/mPyxBOWULFm2uHTphQ0bLWzcsHmTJ84NBwl6LphIQAABBCGEGD2KVEiQpUTKdOLWLdu3b+jKsWsXLmu4cePMsZO3Tt05dWTXtWsHD548fPLcuXUnT968uWrX7tv3j228eHP7+e0Xd185d9u8+QqVKtWzdXPROUZnjis5ruMmj8tKeRy4zZw3T53aubO40aTFcRZXjtxkcfSGoVFDg8aHDydro1yCe0mU3UV6+3bixHcR4E6YLAGCPPePKLh/cHzO0YZ0Gz2oP+/9o4gSIkgDRYIRJJIQBEEFAkAAIICQSIGC2CkkCVEnhL+O/WI/fqKQBQombeTh0Ue5fQQSbgX/LjHFS2m08UaDceABYR4STphHH37UIEFPCfyEQIdDFZXUUYEoFYRRRBxhyCvdpHNOO3e5SM47e83zFz7urLNOPfbsCNda+Py4oz3u/PjPP/P4WGSSfy05zzjTLOaOOukoE0oopRgDDj79zPMYOpapBqZlmYVGJmhkglNOOaWZxpWalJXTzSVAcLHDDB9kkJJttw3Im3DCEUecFLshl9xyzOUJXXTW9dAbo9hFMQkjLoAoxIgYsBdCh0KRBwABkYgXSKiBQBHIJ5kslAl74lEUAgFQZJKEDQAmtwRLabCUhRYsabHgGw/ikYceEuqhh4V+EOLHsYT0QYgeNzTgE0UP/wylX4ghLnXUFXg0wkw999xjz7f3/JVkknfh1Q8+8PyIT7l3sbXWWvPMSOOSSxYpjz3TFPNMOt5YU2UovGizTz93mWOOY+aotrBqmVFG5sOcpUnxOOVodhqa47CTpjiUpcPMHWrQ6YEKeKbEkUnNqYwbE9kNF1xvgBLHBRY237zbbrghgYRJfvrmqHBL8OFQIRQdFckCBCiFAXmcUhRJqqKGemrUpqb6qVIhPGAqDkUAqNtKW6Txhhtly8RGHGrjQSyxFvZhrLLIJquHH0bwlMBEDyAgwKYglmitUUHAYKIdfdxRCj3hfhsuXuU+/g+5dxXpT+X+vPujPJHPNaNf5f/6ddc904zO7zbM0GIlM+dovs89CE8GZmVgIhzZmZx9hnvuuoPDFTh3rXPPOOjYQ08pQPTQRRQ7HJrnST07jwQT0ksvRfXVUy8F9l1gYRzP0vMMPs/O9TB+dSnXhqAisJhCCQQCFBVIqgIEQDgGBBAgEAEPZJJqCCIEgYIrsKdEWPtU1ITwgKghQgUzIJ9KWpKGL7hkQQzy1YMkBKw8+OFtfTAEIQjBCEkw4hCHGEIDFpA3ivBNKA/421KwFTgiQKEMc3jDHf6gDHq4aB87Klg/IAfEyUWOXP8Q4uZoVEQh2msf2nhGNpjxCl4YIxm4uBIzpiEOeBRJYQyDDDreQQ7/hKGDHQ/rHe/AsTvOaGWNmOHKu9iBDnikgxqN0AEX0oCGKEyhB8zrmfeYED3sTW+QTKgeF7hgyENmD5DUM0n4eubA8pFvQLiZwiFA4YlO3CAAS7NaIfpWkQXkjwAh4F8krkCCDlRKPIOLmtWyRoRCROIQDHRgbqaAywR94QsMUtsb4EChCcENbseShCIYoYgwcGBDC6BIUD4UOMAJDlsznIMb3NAGNQBhE95YR5G+5cMfAvFzP7RXkfbxo7/0JYn6qNyS9rGOaTCDF7xoBC8u8YpS6CIZvFDGNfZhjn6wY6COeYdBDQoZMaKjjGPiHcY4w9CHmeNdXDmHN3ABBDTA/8FmaOBZzqIAvh88EnvXG6T1TorIRQ7SkY9kmW0oiaA4dEITvwDFAAAQgkigCoEeIoAL7HAF73yqPZXKxIiMItRP2eE9kUCEJAghgxmwDEG4/MEUdrnLNsShDW1YA4QilMG4gfAQ8SlBAiAgrWe2kFLRBE8QiHCFK8whDmtQQ1d1AIRi0KNgd7nXOJXEORr1xS9xUSfklqgObTAjFED4wyWGMYxLXKIXxqjiNM6BznbEpR0DbcdB3/EY0HbJMVwhbUS7QrvUcgVhfR3HN66RDTnxAQ03WwIXcrYE8dkmfCc9aSFL+lvrTc+Pj0QCTFGiklziUg+UmAQsnEGHACQwav+ZEBwMUGAH6hYwVAaslFBliQgSijA+hNACSKaqHF26RKsN8upXIbTBuB2LEXUYggUWQIG9BYUoIaDUUZMyuLfScA5zwENd1bCGNehAB42wxrgIS8S/DtFef+lrjR63pXrtox7eqMZiG5GKXkBWYFdkhjLs0Q537MMdPMKRWeSxLnnsJR7wOIuNz3IVzuZ4oDz27EFHmzB09DUe2shGMe6AhjtgAQ5pwEIUsJA95qAPpkvorZWvLFxABlLLPKPkSaiKS5eAAQyKmAQouAELniAtEEEdlSz5Z8pCBOIB4UnqpwqBiEdAohKQSISw/BAHGdAgUbX5LRe6oAY5+OqrFOr/Q7GS9UFClKEEKFyA0vwmBMIZBUT/FRwR7LAHP2AQQnBI8BtisGBe1COc5sRwhSfnjyQubkf3wJwQB7vhDjNj171IBjGMEQpfVMMb6vhGXorYjyAJyS3rsAtb5jKPd2g2LtSWx41xfOPPavugtY42OGKrg9eoYaNNjkL1pIxe3eRselg2JJYJ+T2eTcHLyU3QBPMAiEU4Yhmj8MMFCAciGHiHCEkdhCCMcCpBUHchCxEhJB4OiU1sQhOVwMO8ZzCdRTkwelLoAhzg0AY3uLdCFXJ0sphFCCNEIAEGOCsBOPkAwmmaREhNih0EMQhCAAIQfOh5zw3shhSguhHQsEc///hB4SKxy2AGO1c+8qGP1tlDR1On9Y/OVaQt9QMe96hHNpThi2Ikoxi+QIYufPEMHckDL+1o1z+ijk7M2eMuccEHXdJS7bzHBe8wTovf9853ru8DHd/YhjHQoAM13AHJUfhCk68HPj591NztDm67VUrIeVdS82DO5Rb6kAc83OEWsfAEDh4ghK1N14ChEgQjMlGfYyzDPrB4CChA8YhEQCIUtUAGNZwRC0wYAg9baGDGHZiy6B1aDVsQeYSGtcG5+eEGlk5AASAAgQ+FQJpGmbmnb16IQhxC54mAGx8mZOAUpGDBqdhrrB+XOR/ZAx/zR+daipSPtryl/uzqfzp5eP8NylAMr/AKymAMxiALrpAM3UAP9VAP6rA4mtNOnxM69icXR0JtFGYvPqJ3hFVYa1Fr/fANABMDPqAGJ4gGXdAGNpNlxqVuT3YzWHBIKeVbhuZumBdvgqRcO8iDWQB6WxADmOAMqkAI/ZV6OeVKn8I/oHAMzjB7TeiEyCAMpIAJnCALweAM2MAN3OAMwqAJi+AHtaIo1GESHLFld9R8EQJ6oedoxOIHbwAtBtByGwIBGBACMOB9SREIBhd+JERCipAIgEBMcPNV6odqfxAN3uJ/NvIWDuiI7nAPNoIPjPOA9NCAVDd19EAWUmKJDbgNxUBPqRAKvYALuYAKwPAKwyD/gAI4DM/QgOhCYUCCD+giWNBmi/YyF9RWF4HBFvASF7X2D/eQDX+gAzOAB3CgBmjABVvAgteDG5MHgzYjSNRjUopkZdMIb4QkBdDxAx2HaGyTBXfwC0TYAQFXFHeGCJbgCsJADMgQDK2wCrOwC8RADMGgC00IFd3QDVvYhaPgCG9YhrERHc+BIIWEaFvABiMHeseSLHKgB3HAAHLoExeAAijQXxd5kXgoBLKETICYCIdgCDsHCHPTNj6nBm6gB6IXCvSQDosjLsrmiDEpk/VAD95AD/rYDdugkwYIWbyAC6/QCqWAGKGwCZiAGKkQDK6wC6LwBzf0B0/pWNzQgEbS/w98US8GAy5EkmHQNmN+cYuAsXfVFn/WplniUg/FgHg0UGonuEtpkAYl9YzQuG6/xW6X11t0WUjDVVxMsHFSkGh5IAd+cAjC0gmeYAlGEATeQTX8IwmgAAzIsAxi9wqpUAu7oAvEsAzNoIVbuIXY8HvOAAykMAl+wAY34BwCaQM0QIa4JAXLlwbOl0EaRJJ+8AUOoAAKYGkNgAGEEwQY2V94mJh4pgiK4AiNkAjHaQgh+UF+UJI9hwZpEAeh1wjIYJOW6A046ZnQYGLGMAz0RICpIJShIFmN0AhQCZV3gBwLpp6NVQmSJVmhsAu2EAuswHM9dwd8EJKNIAoMOHhbqf9h30Ik/zBjVtkXtlgvY0ltvkiWa9d19BAKCzYDDHKCbeB4bzk9VPaCUYCNicSh1+NbHlpS4BNvSEA+hZRofmAIi5AIlMAIhKAIlKAJhGBAC9EJlAAKwrAMmclPVMQL7YgMzRANWriPnukMzZCjxzALnjAJfaAFg/YczmEdVmVvvJQGCZlgwAI3I1k3fmADHtAADeAAEjAB/9N9vhlAg8AIaeoIkFCcxpkIyQmnyEIsPdeUeOAGGsQHkCBZkECe54kGhAIE6imoghoDqIZXGWWe5UmeiypxoSAKovAKudAKwLAKULlzxzQJfOYL3UAW7EAvPyR1bmckBkqqg7WIp0r/ba1DD8/wB0AQAyrAVW2QBi7RjNKDW5L3ZNhIPSk1gyBaeSYVbyLFBcCkB4SwCItQCZoACm+gAnrQCZJACfzTCZ8ACqawDNjQjs3gC7jADGLHDNFADdjgmdRADdFgpMgADLPwC7AACppwCGvAA6r5pM6xBIMmpbqUBXiUBl4lTMyZLDPgARVQARqwAR1wAoDTm795BRyppo7gsA6rosiZnHPTBz63eG5YsYVaqOq5A8U4Awu2AyHbsYO6YK+qAnfgCbfACrHQCrtQC67QCqwwCpjQlJtQJaJQCqVwCaIgDKewp48QQpJgCZqACZcQDMxAD9ogDuZQL3nRQ0UyD+XS/391539iyS5Z6X/JRg+pgFcx4AFpMGZbMAVSYDOIZKtyGY0kVZfW06tsS4Nsez086HlxUDcu+giTYAmcAAqHcAAgIAmZEK2dcHuwsAvOwAzBsAxmBwzL8K3VUA3WUA3R8Azm6mu64AqkoLeaYAmKgAc7UKjWQQNfJpD1lgVTEAWvwa9YaixbkAIDWwIrcAInAAOfRgTgsbCRIELD+bBr6rDD6ZGG8KbL2Qd/wAeLBzca5AdqoLHLa6gkqwMiC70yELJqwAkJsQubMAq2gAqjgAqz0AgxAAiNIHGYoLO7hwqbwAmYUAmWcLeTAHEPFwrVkA7iwA7k0otZF7VFhKA+wv8ueSd39YdOs5hs3NAIgRoDHyATXuAFU1AzaZBSTPBRTrYbMWh57MarikSDbTuDNMiDW7BLOHEshxBCljAJnOAJoMCXQiu4DeEKugCkzGCktiAMWdiZ1VCulEsMusAKorAJleAIk6AIhJAHURAD6jdoo1uGBJkbpXu6CMZoeEBM5QUCJfC6K7ACNWAEV7AHhZCmkuDFx/QIj7CmbBrGvuuRyAmSG0S8fAAhxOIGeHDAsyHHHjAbHgAC6meIMiADzHvHKhADfOAJpsAJOhAKttAKosCnfwoJs/UHRfsHm7ALu7AKnqC+j6AIIvmUPKcDpTBs6jBESud2oMND9NcWpTz/JPZQynzXf0IyiwGMF/ZwZER8wGwAtk2wBcu4BcIVwTYzwc3Ytq3Jq13QBcC8wRgszBysXB7MVSBMCIegCNBqCZvgCaQACiDUEAmxuFoYDeD6e5spruZqpLM3C5O8CX3GB2rQBwamBjxQxCkwAzdwAwKZKJNESVjwnF6FzxLSB4fgB3MABvE8BXT7QSLsxZIwCZMQxmH8sMfUkb57nB9JQsjCcxV7B8eoBnkQAxnwpQ7A0Q2QAR8N0iGdAR5A0iTt0XT8AY18CZvgCqiwvZvwB2gQiIDwAWjAlI1QexJXCUC8QYtXvMQXBzFwB5uqDvUrTuwyRHcxf0HyFk0NF+/g/3f95xb8uzgOmkcqcCdp4AVgYMtSULq+paFQxss5A2W3/AXL6G5MgAWINjJdUMzG7NaGJLY7uAW+IpvOPAkwWoWicAuqUAmeAIXUABXcsJmdiQ3gbKTCQHqCjAmOwHOIF24T7LnqJ2h6HBuXTQOCFkkqA4P4fKUGxiwkdCyKcKy5lwgJrWcIndAOm9BmfMZvCpI6J4gVy8YiowYmwwAMcJsKkNu97dtfmttf2gC9nQGzoQOQMAqbIArJvdJsqnuOwAeOUAnTbQl9BgjHKYh8QLz3eQd5EAYfEAONgA2rdnSVA3efXERJdC7rfS7ilETiAt/gQpPNUJ58cChjttVt+f+WwiEFTsAFRRBc07MFC5wgXlC6uDKruMK2bm2NKMUFueQFLpFVb+CQo80IB20JnqAKtyB7y7CF3XCdN3mdhP2ZiSsM6boKo8AJfBaIG8TGs4VgabAEOxAbM0ADI5HZgnYDeiwDpmkDPzASO7AEW5CveaAGEIJgdTtMFeIHO9cHIgkIyfnQUy6xUv7QcIrlUC6Sa8gGJK3RAsvRYV4BEuAAAlsBIv3RXg7e6OkD6rm8Jat+OuADGbV4db54SYYGSXbkHoBql+AtnvPejgM57E3o58I4yjZ1DliTqdCUd8AFJNoETaDAHuwSM2PpxNEbA67Am64rY+OWuIJIby3qcx3/ZsrMIBXezJaMtya8CovrDITdmZxJDc1gpDk8C65gCqTgCT1szhDCxsn4GsGiBj/AAzOgAiCgx8cOAgwkAyrQ4zQAz1NAAzywA1a1HFiQYKVGrGsoTMQkklhO5eEu7uP+0E7uB25AAx7w0WAu5mYOpg6A5vEu0nJM77NhqDvgA/mu73Oe50l2nx4gdIQ8f1jJOOBU6K0T34c+k53I8PTQDJfwlGqgoT+gwFOw6WJ76Rl/VZuO3xGuILeSBQxezMe8wR2MVVrlhi56CI8wtJxACrGwC8tQpM3gDM5Qrs2ADMMgDLvgCqLgCZ6Qvj4ciHjQ7yd4gmsQelvwA5fdAyqQ/wIgAPV2fOxP7+w87uwzwAPErhs3g2BrAEy/UnLD1ORRDqdTfqxnf/a7q/Zrf6zIebwpUNLqru7ynubxficffSf1bu8bK+dJpt2J0AgPhwlV6AmiYAqmsAo0cMBCjQszqeiXSJMs6Q026S9RUQ3Q8AzKYIDFQIqTGZ5E6Z4xfZ940AN8qekXvwUZf+kFvtVjBgYeP0G4IvIzeMzA7Nas73kSjhN1O36HgLeaEMiswOE5igzFLwz2+LKn4AmX4LDGOdt5cGD9jrproDzG7uyZrezqBwIArwICy+M0APUqcNnN82RpMG45ISFNnpyAMPbAa/b65ggKvbvv274HPd3T7f++DwexxOkIcBz3JQ0QHwQKTFEwxsGDOnwAAXKHz58/gBpBgnQJ0yZOnDyNMrVqVaxZIW3Z2lWyJDBgu1ICI4Qlg8A7xpoVG8YL16tUpUKF2oTpEqRGjSDeAaLDKMKDA5UOzNBUB587atT06EEjSxYtWbVMmeLE61ewYads8VK27JYtadKg3XI1SxcuUrjM7VI37ty5XM2i5cr1y5s4evwQGqxokiVOpFSZmgVMWMpZrFCRErUJUqI/DvH08dPZjx44odeoSROlKg0VIECokCFDhYoUHjyA8OCgwm0NMlLIoDF794wZP3jsWILFuJo8evL0AWTokCLohhJNT7TIuiP/7BQnba80qdJ38JUsjSdPHvwk7RQd8UGD5g4gQIkmVsKESdMmT55ImVLlahWskG7Z5ReUCnRMmMcMFEYlA1FC8CQHgwnGBg8yaCAGIND4Q4cYlvqgKRAtZKCpBko0kUQTGWDARBYzwAKNKHagiiqutNqKq7CKKCKsr8gyywu01GIri7XmkguvuuDCS4q+yvqCryXG+qKNwD7z45BHKtFEo/z4M4UUTzip5LI/0DBqB6ngyAMPNt/IYw210ABihxlcS0E11mZITbYMbqugAQYqUC03GXyTYQYafvhhhyiMw0INPJbzwxDoHrEUO0wxpQgS8MqzBBPy7NNkVFJLHe87/+8Os0STW3755RhYY5V11lkRtBVBWW+9lRhhiPH1V14P9DWYYUDIYEQ/fsigQ6VCdLZEFaOVdlpqo23gBxuWWIIqG2zgyq0pkmiiqxx59AqtL54Mso021mLrXXjTTZevJsFQd4oo+/oijjzSgKMPQp5z5JFE4Cu4Dz4SvgMNH2JIIYYZHG23jTfSaGOJ4XagATjXVKjzzhRU8KAC2Urs00QHQFhBBhAK8niHH5ZQtNE01FCzMEUs3e6R7SbhmdNOPy116C0zMpoTjDYZFdTvNBnPO1UeixWZqWm1GtZlYEVma6679pprY7oO25ixjTkWBEKsWLGp2Zjy8MMM+ATR5P+mqpW2gQxmsKGHbmdAwlu3thKXCnML30LetdR6o11304KXq8PlVdfHs6Dsy683ZlwijTXgUGNOH3zYgQeG1MAiRocL0pbILKZYNItFeeBhY9RgKyhkFZqqwAHeeQ+0xApk0KCE1VZDlAdFeVgC0tDyuDJnnblD1TvxQiX6aOyzz2hp+8bT5KJbcD3G1lhvHd98WHX1mhhkhEFmma+3TiaZZeCvn/5kmNEBCEsU+bMBksUgCzrYgQ8StQON0WBjHOvY7WIzELlVSDayUYENimCEJuioCH1xixfAUIUmNKFw5rocWq7yLhuNhS2Ti5y8KHc5GI6FYmtik6Q+owc99EH/OXngYQ/XRJrkKAcPpsPCD7iSMY0tYQes2RMIZOAnB3gAgLYR1O40oBrZ6Al5CFReGtjAhs0EDDoD2w4Zw3NG+tinPmtc4ybc+EY4shET37HEdyiyiVmYZBckSYkebyEgPZYEkIEMpC524QsJBaMXi0ykhGqRC1z0Yhi+KEY0IAEKRbAMBBVYUQp8QEAauE52CORiAuvUQNs5UDWxKQgIenCDC2ZQg9+6iha8IC4RjlAskBvSu7ygFRWiC12SYwsYjAmkLcRwClN6A5ucmRwd+pCHfTCEH/DgOZvhAYeeGw0WVue60W1sCXWigW5GpppN+u5PK9LA/64om9GpgAeu/4uZWsAIsOcogow+k555qlef+5TqjUjDiPYIukZ/VmITqyCkIHfxx1vYAqITBeQfG2qSRmY0kbmoRS98wYtKdqN/etiCazbQTg+kgZSwW4LoRodELo4ygQosZ2t2wxoZ2CCDQ8CgBjdIS1uGMJe6/IoUpNCoLJgQLcYEwy+38qOmejCqZlnmvOjFy8NRTCpq6Byb4IDDPMQhNJGKJljxMJohokEqUeBBUkU5HBosoaavSWdqdrdOFR0AgA0YGcl2M7ssXGwJRGIDvwaTz+jxrFP1SSNA4TjQ/HApP5MVRWXDZDQ33qcnmxBFRfdIkpH8cSSjDe1ER2JIQuoCkRrNKP8kffFaZnjDG9bcAhmM0ALiNWAGeeCNogYLhNVlAWPakl3yYKYo4fDgBjegwXJl0IIhDOEGRjDCLC93Fa6EkKhhMSpS35UGpkI1qsc85o+8oEJeBjOrb3jDGtwrlZrxK6xiDc1XeWhWPKgVm2poj1pgh1zi8EA3LUPpyFRkIgUkOMEko40H6rQDGexAD0RKgxv4BTCcRa+fQgPoqApqtPxUdhSiGMUoSEEKE5PiFKc4cYlLbFnLaiQWAgJtjUl749DmmCSpXS1rN/raXiijG/SgR1gJMYcX3KAGtjnEFlTwgx5ESVtT1lbMkIdc4dCAlAoETjnrNAPrTkFHHKxlX4b/ul0nGIkukmNqm93c1DcbE71jOS9U3cBePMdBz3GoAx3ooGc58FAOO8RDxfo7Gqm0B75t4UrsBGxO2zDAAe0ElAIMUIADMCDBDoibbFajmxnEgUhcJSsg8Am9nnlnPKLycEEpS2IVo2IVqJA1K1xxa1y7ghWsmDUqVsziFo/iFLO4hUhGUota4PjYyMaxLpzt7FzoYpE9fm0wVjuMSU7SGNkgcj0IUYckhGEOLPPAYIAjHC1EFSvYpfKUkUvcmcKVKzoyYl9+ypXB3qgIZ96ukrhQFza/2Q1xdkPBw+tCtNS5LMa8M2AAg0M6kKEKdejzG+AgBznEoanCFU4B3QsH/zYtDA0WY1capjA7uXosBQ6Q9AIcIIEDGEABBxjAABSgaQXgbURSTIHGuOLFGnLG1GLUsKqFptmM5CfFp5C1K2IBklnEQhayCImxZzF1WcQC16xohUdoPQpXhITqy0Z22c1e9tEmO9q6yEUvpL1IuPsC23MfBrF6AVJr1KMe6riHlbzwg9Y8BzUaaysbkoqFLTjqdFFgfBQYAoRGqVUNbLgDHu7AmTwwSQ3JbF12+6KtGzFBCmj+ChccBfDIMXzgDCcvnMFQ8NV7gV3p8uDCmdpwN1QhDGYIg3STUAczzMEMVeAKk1y3sd5mAQ2dSxN84Xs6wOpJBiJiQDsVgOkDJP/YACuauclokwEabCFmWyhspCQ19Odo+J+jArF+9qOKVTh9FiMJZERH60f7c3TquUZFK2RRi6k7NqwbwLKburNDtlxIwLeDO7jjhWl7LQgshmegB3u4h33Qh0PQA60ghE44BKNYCP6KlIRhjuaojoGhI1LJj/eDBQBplV+whLqQAiyAoXHBt8HiCtELCxESAycQIcIhHCfoArWoGTWQnC9ggzZggy/wIDYYLyd0gzZwAyMki9tTPfbKvTkwAgkYgAAYgAXAgSFIAumakeFAHirbnx1IiChQqzQwjiiQGeUBDhVoAAdogJuTgOubuQTLtAPIPgaokBFpjSdrKzcwv+X/4IzDypntqKOj04TJ0g/+WAVW0DqQsAXUKqRLbJCS8AW2S0BbAMBZcwUApAVSpAVZIMVXKEVaqAVUTEVaeIVUxAVZxAVeqEUHlLthKIZiIBtlUAZmeIZnYIZsSAd6qAcL3IerSANF8ARYMAX7wAj3UwVp/Iinq0ZisygBcRVXaRBY+QU/6AIkoBMp0CAmYYIpYBKjchQuECqhooIqEAMygEd3DKF/UwMhHEIsqJkhVIOB+6ImZIMhRELGUQN2WT2DO6/XuzM9e4MwKIMKCAAAiEgACAABuIAWuAEtcAM2CCvAULLd4JBjYQCBIKB8xIMZWII8wJeY0SQN0LSYyz4F/6u5mGOATFMRkvEAFYCdNkgLNnCD5QAEQhAM53CERVy/LZksjpBEp3OFsfvEtXu2HmskTlQtaCu7p5PEVmiFV5hFWOxKWqzFReKFj8IJuaMJCZSGaZiGa9CGbfCGdPCGtnTLdJhLupxLdUiHc/gGbagETlCFa/wFF/yFh4Ko0hoJY5MoiBpMQCoQWAEFOeACuaIBJigqKWAC0TMqGXQUoZqCEKoCz/xM0EySLshHtchH0hi5yfOiL/KigNyqIYzC2Ku9hKQY9gqDFhgAiYRIADCACIiAFRA3jRyNOCiCG5ABDPkAFbm5umkAG0iDKKOBL2i05tokTtI0mtS+S+vDBP/DmwZgGRrwApRsA23qg0MESjEyjMNwmlU5ShMzsY5wOom6KB/zsdeCNsOUBVdohVxIBl9kBv98BmhAy2xwS2wo0AIthV6IBmx4BmkgsgqswHuwB3uoB3qgS3W4UAzFULwUB23QBkJyDD1yttH6o6oTiaqjqEEKhpI4hl9YBK8oAhrogR3xiso0qss0Pc1kR6ECTTKQuCpIEhwtTX3sL3tazSFUC9dciy84yCnwAjeQKimcEt5LgACoUok0AAqIAAcwASMYgimoMJmBjRnQAeSMlqY4gC4sgJzzABv4AfAsJxooiJG5OT3UtEszgD7cqwbIyUQptDjQps4gBDE6BOv/4Jn1ZD+l2w+mi79KDNFoU0DVikr6hMBFcjZke4VhwIZirIdzOAd1sId9wAcJrQe4zIZu8IVUeAZsqIZn0AZ7cId12AdZDdV1yNAL9VRbvctz4FBtSAlLdLZdCIZnG1ZdkKj5u8aICpCKWkwVXVFQgAMnEAPivAFySTOjiosjUTwd3dEq6FFvpYIusEfTO1L4IlLVBMgjRVL4SoMveL3xGriFa4O/oAMbqFJ7BYACWAB9lQAOaIEkmAM3WIsiGNMOkRaBUICas9cBUFMPuIEfKIgZmA2W4b4Eo8nktMMKiBsnqjLYiQOACZhDEJhF0Bnv4YSj3IgTO7FTiL+pm7+0/3tFs4s2SdUoCEQkX6jUu+MFZagHcVCHdzCHd4iHeZAHeXCHetiGbcgGZigFZuiGbXiGa1gHd5DVfvgHfJCHdlAHT4VVrfXUWs3QXeXVZDOJS9wFET02QVI2zyJbCTmJFuUCMWiC5boBIEwzvLhb41CLbaUCvu1bvhUDMRBNfCTCNjzSL2KqxiHNrWohF1KXKZkSOnhIAaBIilyA3pQACyiBFjADI4hTbEkKaXkJBuDCAHCABTCAKq05mwseKeKkSiuRm8u07ZQ0D/gBEBiOHogCwhCM84QenREP+0AajSAxU2A6ptu1XMvKW2sFV3DFR9KFSW0kuqu7tstZbVCHfv8I2nh4h3cg2nJIS2+ohlQohm7IhrQsB3kIB3z4h3noh3mAB3hoB3Y4B6llh3EYhwtdh68N223QhmsoiWLdMbMdYF2AKEOyhVxAYKe0xIeKz4cCVgYxhShQAzFLshvgQa/4N3+bC8X1W7/Nribo28BNkudLV8NtQmMy4SOdlynZyapKF3ltAzJIANXlwgTQ0giQAAm4yCSQAQagDQX4gBiYuT4UyQ9A0wBIAAkogAQ4XS6cyNW9jZuzzmNhOWiJohSYgTbYATiYAW1aA0PgDEKgFEvhGZ5RNUTdiOJVyq3LSuZ1Y6YsOwWcT9aaO2IYhgbkBWMAB3iYh3jYXqK9hl//ZMta3AZ6mIZnCAd46Af3ZV944N53YAd2KIdxkGR0QAcM9dQNFYf+vYYGKZCLgja268QEfMqyFRCUuAVIsIFxnNsLLj0NRpIjdUfP/GDODOG/FVzSyNt9JA3VRNy06GXSYOHZG6YlHbgmuL4CWOYCiAALmIAc3gCe8kjlPBaa68ODhcgBGIE0DQBMuz577UIFuEng4T5PM54ZiAFG4QNIoabpWIR96pmSVUH+mESpkwVbuDUDZOBidbZEItZhDSQfm7tbzMVicFVZHVV6sAZlGFBleAVroAdvkIZrwId2kId96Id9kAdJZod2+Gj5ZYd3AOn57dROFQdw6NBrQBDH/zCQUHY7tsOFUi7lYd0xVN6FWLiDKGCCaV0uKgBcu/03urhHtXDHHhWDvg0hDwZXJdHHNnQUwv3lFGYL0xwNdn0SI5SSJX0DMEiC0zUAsE4AEZiAC5gADViBuR2CQikImrxmgRjdiYwAG6bh6xsAmUPdcDaABeCrvVoRvpJDGZEKQMCDMB7ZEyQPUuESxVCFpyO2k1AJk/hkYJCQyQ5WgH42mn42AI5K1SIWbBOyerCHCi1faoCG0n6FZ6iHdEhLdbiG/r1edSgHccBVj55kc0CHi5bfTi0H2eZV/71UWATAV2je/cu14X4F5e3KrsS6BNmFa8QEyOOCJeRMEIJlJP+pC33cgiboVjJIaqTGZaXeKvHmqjYsDqnYgjfQSH98TRNmIXnJlyZJggZIALAegASAAMuFAAfQ3BqoAd4wziNWXSNGUwBQgAWwuQVYZg5oAAPwwgugXIUdgANYAA3YANrwGESBlEQwBEO4ju4wusSmZ/5owVYpEFuRbE3soz2qugEcwNI6iUTilV6pO2wrBmWYBv9UhmQgG2Z4hWKYy2tg0GfYBlbNhmewBtlyS3VYh2N8h0uO30me5N7uUKRNwFnEBVI8QGT7vxaXhVfocllIEFvII1jQ6Rkkiyb9ArDwN7nAbtLYAloGIb9tR6Ei4fFevEchjfT2R3RNV1+W1xX/opdkOpyCKwHTXYAmpgCX09fhkS7eKNiEPQAhZoAqPYCHpMME24CwLgAOKIBwjvACkLkKuIE2XQJ3TgRqUiyAOjouAYX3U4UWFEwCcRCUECTCNMyQeLql1LVeozVU2DXkrUZ8HtZmlRAIHAZmgAZsmIlgMIZkuLthTAdgrAbTZob5SQZqiAZqiHZjlFV0MAeg/Wgpl21wSOkOncrLJmVLLVGXxWcDLDtfWRBi04QYiAK9eJc1t4sj4YJZljil/unv7luvwG513WWaGUL24vMhDOZ1BThi4qXXA4wpqAJDt1wOuIAs5QAOyI2aioEM6MOaE8kM6MIA2IAKWNhxVgEJ/1iA67sAKqXcifz0mmNYGugDReiDDXeeQyDKOtKSNAYFUHBPaYQFqEPWYou6WPAI+PsSU/gSFHMxGPOEyhIx91xZj7A1plzFBJYoYjUGBV0GZxsWY/BPZmgGa4cf9iEGXxCGz6aGtkyHqQV3Sb5odRAH3hYHlFZpY0f3dHfUmZ5pZwMpbAsGW4gFPpiBzkMmtMj3GMSLfgchXAZcESacES54g9fHfIzCwwWDIzXNXZ4Lxo1OKbGw5IiDKyGEImgBE3iBEjCBGxgCnFKBt+7DA1iWGKA50s0+3J9wS1MAuf50hQ1+b2YAFYiDQ5iUNfADfTrsVWvE+2i/R3SxycqIN/+SIzbSrIGSLMqqelpz4+FmynueOrarhVvwiMnWBV5IBV/JhVYoBRIjMVSorKwMMreHe3xgB3SI8qy1+yn3X2ugO4DwJTCYL4K+eiFM2Eugr2EOHRaLaMzYs4rJlq3SQWNLkyZetmzBgsUJSSddTnbhgjINyy1UqsBsQmUmlY5NSppEqbOLFCld1KT80sYNmKJgQLJkqSYNmihcnnb5IvXLlC1f3sTR44eQIkaPKHWiVMQGoTpN6Ezp8YNGig8MFBxQAOROjAMDCgQAoHeAAwcG7g7gMCBAgcEDFAwu8DdAgAGDGd9VAGIKHT1aCR1S5CiRo82JFi3y/Dl0Z86OIKH/Tp36NOpKrl9XsoRpNm1Ntjdxyu1p925Ro36XKjWK1KlTqI4f97RplCdWtmoRG9ZrGTJUpkZt8pT7NydPolL5YraNnr197Nq1Y1eOnbpz4sqJE6dN27VrDyEOK5a/mLFkyZQxE2Az0VCDjYHddONNOvQwSE899dDTDTeXxDCDTR1t8RROKKm0UktNVEFGFTTNZBNOT6EIVU8+AdVFG18Y5cVHWySVFBpY6ASSVFa9kcdlmU1iSSeg/KIKKKp0gpkfcfgBSBQZvMXAB3/8kYFjjwHAGGMJJFCABAo09tcABxjQmAJ4GfaYlowZ4AAIRViWRx9+4MGHnXjUyQccasCB/ycectbZByCDGpJIIo0s0sihi0By2iSQTBIpbJLCJhsmtmGKW3ehhMKbd76N4psnl4hyiyu5TERML7KcYsp1uZFiyiqm9PaKMdKkY88956VXTjnqrBOffPTVl42x2SCYoIIMKqhgOgsy+OCD9lB7j7X37HMPhMYAUWFHSSTRxBQ9bYiiTjWCKCKJYlCBE0ldJJXSU1JAhdKLRck4I0siodEvGmq0+JRUbbSR1VaZWWKbKbD88ssxsKhiySSPHPKZGlAywMAdjfyhg12OrZlXlgYswFgBeB1gV2N4NXZlyGsOwIAKTcTRRx5rrMEnHDvvqQbOcKzxJ9B/9jEnoYYgDf8I0oYc0nRmikCtGdSPUP1IpJNUaonWmGzSdde6eSrKJpfEoksrwxijjDG9vNIKKbfMotxupNDt2yvDPDOePeywpw58v/o9X331NegghIUj/iy01Oq6j+P//ON4tvVwU0oMFU7RBLjiuksSF0583gXoJwG1BRhifEFF6qubBDroS6H0RVRSyF57VDCCISNIu3MhkkhpqNGGvFxchVUeBysyiSbdMezwLaqookklixjihyE9fNCAlH9wzLEOHhTGmAAvt9yYygewrOb4eZFvfgM2WDZ0HnjsDPAaQAO/J0tw5NG/nEUXzQ8CHCAhCLG0zCSiYqRxRNVYc7XX0OZSmtD/1G50Mwpg5AIXoSgGM4rBC17UAhW7iAVzPEEKWJgiFqQoxSt8oYxqeKMe6ujbOb4BjnLY4xzEGlw9qkWtBxlOWtE6nIOwtY9/9KMf+GhHOmLIIG5AAg1q8UgScncTJxShCJ2zAhZxIoYubOEnasACF4CXhp/s6SRbaAO7QFSTIlRBDCMiQxtrwjnXqUEMACNdG45CozQQDA96EJQhFGE1THDihA27BSxIwQlNTMIQfYADH2jggQw0QAeXaEQjLuHJRsQALiALwPr0IrKTmS9NibmLlgQggAK4kpSQMUADVFAZPxwCM4cARB4G1SSl+W9OTVoa0gw1GtAgEzSdWaaj/yiVta1J8Guewo53WkGM/rCQGckoRjCCoYtdAKMWthhhLGIxi1nUghbGYEY1FrQOd6xjHfZQx7PUAY754NMa0gIi4hC3DQkhiDxHxMc+5DGNiiijG9Rwhiz4EAUb2KCKuQNJ50piBS52rgtYAN5SOJqGjQKMJTKZCUyq0JEQiYgM6qJJ58QghpKoDl9IaYMgBQUk5XliYbe4RSxM4UhNWEIRgMBDH9TQlg80Ymye9OQfupUBuBRGTYzJ0mPGpErADGB8r0yAAbQKy/WZ6QYFdJofita/QdmsfwG0ntKIWajPGCqZcu1Mo5z5Gq1ZSoITzE13tNMdFiajGcYYRoCIgf8MYgiDGMcABjhnYYpf3GIXrgiGMQiUDXqkYx3AohY9xQGOew7uGhGKBmmjESBtJsMYxIjOMD6Ii9cqozz/wMc90vFBXtzNm5AAQhR+ENHczaiiJLmoRUsCL4+a8XcdTcNLYKJSk6ZLRCUlkXBL0gTT5S4LWVhjHATZpENYzRKcAEWsoEcr21iCEYQ4Hh4uF4NLcCq+l+iYe93yMchA5jEqc9mVQCYALsWyq7JUzGAO0IAM9EAPhuhTnvhQtD+pVZgDtB4xE7E0uMY1mctEjaNgExto6nV5nPiaKESBDGpwIxqCNaxhgcHYWajiFxCDBSzOWQtfGAMb3dhGOtrTQ3X/iOMa2/AGfaxRH2NQoxe0SEXbWlGLVqBiFa6YcitCUYpWtOIVxSiP4+zhDV4MIxiyEAYwVuHQItzgt7rbQnWdgFE3E/e4SfmdcpMiR5SSwSYoLSl0Z9JmJ3jEC9ndLksK1j/rQU1SCeNEJzqBXopp5Q46AAIQrMwx+IaiEd2KwQc+kAEonckwJ3NMXPLbX5cZwAB4EcAAEqDV/y5A1Vc6gAeioAY83MHBZg0mAMtaVkERisKGUJoxi51hZtL1aliDTQRv87XctGIZ1KAGf4ZBjGUIQxi72IUzZAy9GacQFbI4cTbAER91zDMd1tDGkHeIi2YsoxWukIUuxFmLWMCi/5yuYAUpVqEKWOjCGPWQxz7UQY9qhBkYszjGLzQhBTTf4AbiolFK2kxcOFvhi8vdV42WWyIqsGsKRcgciUBOkgvNhF0kkomMpjAjkBDaeHJCHtUiZQlK4FwS6iXEGi6HBhb+odN/2OQf0ACETiM9Aw7wwMcKU4CUiUxL/SXMmWAZAK6qOgAG4Gr4zJexDMQADXbSNQDNuta1DnDYwybkhY0pV2UysGp2vetsKlGbTQQjGbxIhTF8QQxdkJnMx2DkjCFGN1K4whYUycY2xJEOa9ljG9fQhjdAew3GOuMYrjinOWlMY1X41BOgGL0rfCHQexw8FJuAxCIipYceNCHiEv+fQlUqXt2LO2EMY9B4R0Pa+452QeUurQntO7IukpTIJioHOU1a/pE0gOQHU9gujYKWuzb4TyuKyAwjup9LPMxABTrYRCr+kIJLZkAHUlADGnSgA057OgVF+FKqoxpV/DoGTQpQQKoJE+suCcACcBVYHYYCMEBcfIDY2Qkg9FrZCdDZ/RJbHY/atd0iuB1pLJDVKNuyeRgkfBgmnEIwhMIrYEMx6MI3NZYwMFyRuIqreEIsOEfeRQO7oZu1lEN9tBt9PBInHAMnGIoiFJDNsIEX9ABbyIAM7MAdYEI2YAvqPUMoXAIaZEAK0EAPZNENqMDM0B5HNAHuYdxwcZEV6B7/75EOULRIi5yEGKRUHXUEydlR5xif8SVfvrzcFvzAEtDe9NHIEvDhFIhEwWjFVnTF9vnBD+yAJoUCIKhACczAJVUACEya0b3fB3SL9sBFyjjdlYya1GHdYCwAmfwFyfRflpjPAUhJyqRfADWgA5adhLHVnFBgMWHYMSFT1ViNBirba6DGJOCcbKRCKVQWM/CCLjAWMpDZLAjDL5iCKpgQKcTCMUjZLPhCMmCDN6iDOxCUOkjefIBWCoBABvSBKcQAJjVABWiABPSFBEhAA0gAB9wAGlxCNojDPchTNkADNuTCHcyAFaZZD9iACnzBFhRfF5KBu1zcRV2U7pHEHnUI/xecYezcGR3JobjIRBuShEudXPKVnKAVhXZpVx5OAR5ul1r8QElGgVUEIi7doiL4gPvBlyKaQA6ogAyYAAh4wAf8QBa0nw78QQw0gAFmjBqEkl2czCaaEikNBi2RCSwJoAEQgF5kScocwDiOiQJkgNj5gWUMUq/9jwMOkC9Vj1u9VYbVoi1STWfgIgc2QqRQAlDB14A8AzUkgy8AwzEcFjAk48KpAin4hikIgyt4wiigQjA0QzakAzb2gzyUgzZYgzVswzZYgwdUQAZ4gCGoghN44waUwGaWwAWYQAW0wBDswSKUQjfQQxManDREwzEswhQEZBg5AROkxEBenBa5Gf8YeuEXleFOoIQUTIEaqhRNoJxLsQtOoFzJgVyM7M4fQd8WUJ9V8Myf6EGP4BIjBIkmOAIaXE4jYAIasGNNgsAQbID2aMAjhh0gjONbKEAMHIpDHeAosQ/7UFUB8J//OeX6jElcMEAMkJpV3gHS9IFltKIwSRgsimWFwdXbmWWkpCWl4NWDWsoyABQ1qOAx2OUyWOgxJCPD3MIvOAPE7OUqEAM3CFQSwYMOWQPjbcMLZGETzIAlwMIetEAL1EALvMAQvAAWtgAO1EEiiEI31IMROZ42GEgltIFsyoEUIIFKcAFI2ATuHSRCXpwe7WaH6ESTqpRKDV/JESdGIh9ylpz/UYCBVNQI9HmkVbTB/fRJ/1yFHnBFkGDCJunAlERhBmhAC6iACbxACahACqzABlxSCqiBClwSA2QA91BJ0c2pymSJK4FVXgzGfxUAARAAfsbFAXjarH0AHwBCVvaPgM4JAG3lWh0ogtJiWS7o1UjMXUGo1pDKtBnDMixDh6rgMjiDizUMZHXo4O2lJjQHMmDDaeKDPMDDOoDDNUyDsdyAGdABHSRYJvyCHyTBDQyBERhBR6iADTwBISzCKJimkJ6DN3QDMwACFoyRGvTOGqRERWoOlJaE7sErRu1el77US13kS1FBltIRcYIcvfprl5YcTAwMwRBsUixnof2MdLpm/x4cgiMEySZggihgAvdcwh1kgAqUAUQNQQ3cABiswGaCwCOCQAl4gAfEACRwDJVsjKZ9wAFAxsk4qshkCSxZncmkzH4ywKzFQB8wTVaCqgBpJagOkrCVqrHJlVnW3Abm4rKtqt3Zwib8gS00gye4hiocwzIayZBoAihogqNNjB8sAiewwjBEw+OxAzy4Qzog6zRUAxnUgRIogRUUAR10wi8QQhOYwRO4rRvMABbUwSE0QioUkeOIwzk8ZigAgRrwQVN8FI6kDhVclN6GIe7B6xggpBPQK7z+q0tlKb127uYCp7+qlFAQzBsQDPQZLHO2gc+s6XQyCXhNAiJtginMQv8soMIoNMIHzIAe2MANnAEO1EAY1IBmfiwHXMAFTGYUxGknUckn/QFdiFL9TeqjxtL6PB2mPhWpMYAO4AFXZJ+PAG2AgmqAClOpymKhvN0iIK3SKtsj7OIDbQLHxIIwaEIMgMAhDAkjSIIiUEJ6UUImIIIkhIUeHMLy7AJp0cM5AIs2ToM0VIMZFMIQKMEeFMIe+AGRIMIeMAIiIAIjNKwkyAYuCJTjaEOyKkPRAY1IoOsXqByemYEYVm5CWi5CVm4Ny4HmjiFwailxqlQc7KsYzCsQ6yu/7tnA3gsdInH18U8gumlmPILdbYIiwQ0w3AInVIIiLEEPzAEO3IARtED/CawAC5AACaAAB1DAZOpAJy0VFKYslaDBATrdVznqowIGpkplynzADuDBVsSJVhbNqA6Q+KKdABVt+qYq+zKoI7ydI3THkahCWSCCIHxCJ+xBBhPCIOjcHtRBAI9VIqwCdWDDNiiwZm1DNVTD/2ZCJ2TC6A3JMTiDkYDC5/1bZCVDkDrOPVjDM0RDKehACqfBGsRBwdBRlmJFHNxwDccrDY+BHDCzDR+z5urrD8eBD5NB5bqU7u1wv77Ec03FjnjBFIjpN2/hLxPNVuDS1NidJpDCLPwCXqqgMzjDLGjaGmTBDYSBDKwADLgACYiAC7QAB2xAyHoAGnRSKqQCFBId/yfdQQo0APoUpQAQQNZFnWNIySWaog5EQRMHbdlt5YSRb69Zz4SJ5amqry1ODIMi7SN0RjIhDdQcTy7VQR1UMCIUQhjUwR5gsiTUwSBssJwQgiRogioIQzNAA49dYzowJsModa5q2zJgQztb6CzQ2C8QAzPI1j7YgzUoQzB0zBrkAVZchYiYgb4W8zM3cwxXLjMfMxAvs+6p9e4NMQ9Xcw2z9Rhk83M1gUo1wemmAXBxJL58c2AXjHcRAs2l8yjEAjgJAzIgA7w5AzK4Aic0gg/EAQ2UAAqgQBDAAAv8KQdwgAmcHyVewihUmVLNV1PN6U8+9FdN1V5Y9JikX0ZjRv9HfEEc+MgfB63PBq1lTFjaIehcqXTcnSVaVg3UzBUu+YEmE0Ic7IEdXIEg2EEZ7MEeVIEkgMIhRLL+LjchUAIotCVVJ0M2wAewzAdk5WqHQvVQc8Mx7IIwmBM7V3U9HNE+1EM2GIMo6EAPyAEdOEEc5Gsc0IEZCLgZxMEbwIExV3M1PzMy6x6C2/UYxMGDG3OER/OW7jAOw+sOAycYUMEbkAEYtAEb9HU4I7GM4KFQ9IibChAhIEJ4qXMKgRMyLEMz0DiNY+gmKKIKtMAJ5AAR5MAXl8AIGAEW9qkP4AEkiEIpxBfH3AEQ6MAO2AADFKXLlE/L6CwaHA9mTLNtx0n/HsjBboO5VvY20RZTMiWCIiwCmisymrN5mqe5cRfbIghQHTRrB1fBEAzBFVyBEoTBBCPCkMzBIAwCIswBG/gIJRzCJLxNMUSDN7zHOpTDN0g1iEKPeTGMMGDbLJTXKtjKaSbRPniDMTTCky94DMNwvZLBWOurFaS6gMOrHMSBG7zBrNN6G8w6NcvRql8UGUiplI6hSQBMzwQPvESFrBNFjLyBUYRBGJiUyLkmGVTGj3TwJICwr6bQLSw2dTD2jMObMGzCIfAACGyABURABFwABURACYCADFAmCLh7DPxBxGJCys6pdj4VmfBXf92xofZy0HS5j+hB9oU5bwNt+JI5/9NcYPoqfEmfJTIp8iN0hR/8eQYPwnMPgiAMwnSzeAd38KALQgczgiYooywkQzRsQw85jqd0R3csjwmJgitQh+p5RykUAz2sQxKhHi1Img2UOoNneDQDfYaHOBuwAVEYO60DvUohpNInpDLrHs/wDMAsFxjMupjGCBjARLhQZL426y3pUgdLgt2ZECvMAl7apYwvAzPAm4WqQh+E7Lh3wARMwA2suwfgMwfYpAekQCKgBpP3i1u8RcqIyR2b4td9QAyEFITNz6cOPG+nZFb29tIYkNOguTIl/MI/wptXPtxBTS7twRwUQiRAgSBEQiZcvM7pb6OlciYUAiN0gldYQv92AEMzBKtsfZhr4BUmxD7XbEIp6AIxVJmVFUM6sEM/0Hc3bAKUz4DP+zyrA/3S617GhbgbUL+sF/gbUH/SM73zq5TljqFby0H9RL3Ut4GgVT9RCFq+XMhJxREZALjXjxXV2F13qII5lU1iGZasIkNUb8IdfKMKAASIEkZM4DBxQ4YKhT88fPjwpxGgP4nufGDAQIGCiwc4dmSQIYPDDzrQYFGTJ08fPHhQotTzEmbMl35o1rRJk5AhQ4cOKUq0CGgioT9/AjVq9NGiR46YGv2pqCchOoLsXIFSKNOnQZJAfQKVqVPXT5kkSVLFiBAlUKZiBWvWjd6+f5o0ceLkiVT/XlOrVM3aJUtWsGHLmiEr9sxev3326C3708OGijGTKVe2PIZMZs2brZCZbEVMHDdu4rx5Ewe16TeZzZjZnLkzazNjrEwWM1mOHDhw1OzuvQZ4my+jibsBc/x4lSbLl1epQkVM5jh06MwkdMhQI0eVMN0lNQpVLF3AiBFDVp6YsGO7OPHhIUPGkxdHcOCQcQO/HxkpYjhaBIQPSCr66CKQLspII5BCGmkHOPrwo4+UWspjpTz0qE6mDGvq48GactqJp6EWGUrEo45KShFFmgIqqUegUoQQRASh6go7BNljEFjAkmSQQRApJC1KGDkEkUMomYSTVYahpp57+rnlll9+/1HvmGOoREYYZJAxZphhiIkGG2vGkWeferwpJQonbADhsjYpM4OO1uSUMzPKyBBtNNVOU40M1zZrTbM5L8stt90MNXSNNlQzbjQwvABjNOeYY44K6MS4lAzqqoMQEEMW2Q6TTTbhRJRTXLFlF2GIMcaYYMoTBphYPJmkjRaGOOKFG1owYog6QEihB00mSSED/oh1KKQMLjrwI4diiEGHHQBxBEYI8yA0t5XkoC5DmGzq0BBCxNWJp0NIJHFEE9V9hF2mmJpEKReHpMOOqoyoT5BIcKiBPhyMOOIMRhTRg5FCBGEEET8e8SSYZ7KpZ58qJa5SS2QKI6awZtBLRpls8P9RjB5uGomiiBnYrIzQQceYk2VAKZNDNDbY2FPPNwD9s+XWUMaW0EN3W+O00hg1bopHwXBOUkorpWI5SzOlQ448/DAkEUcmqQTUTfBiZRZXz6vYYmeO8USPIsjg9QUllPA1BSAq4ePXChpoIAMP+IvhAwMvEulZIGLYIZFJoDrEj2t5zkNTTV/CcKabwhX3wxDPLUrdddtlailq2a12j0hyoM+EKwQ54ogw9vgXij0kSXiPtQWRZA9GMFkFGWrSsWdiZJbZPZlmjOk9mWSYMU93ZqzBZ5576AnmDix6iCEFOV5OObeXV85ZUNxSC3r706iLo0/Zcq5MU9TM57401YT/hhQ5R492jowpmr700inknz+OJaRQA48+Ok0EEI2ARCXq4glT3CJVx9DS7pqxDGcs4xecAEQUZtCCG4QhCR7IAB4qAYcUqEADGnAAA1IAgr9BL28L+gC0gIAGHfBhEpNwkSIMca3dYGs6idNh4/ygh5vgJCfmmhxRiFK5RaRIEUZxxCNiuLmeDIIRpGPBC3KQAyhkghH1gQIOwlCHOoQBEWU4QiEoMQdCTGIUwmhGNuhxjN3pzhnOaAYztBQ8ZDBjd3Jsxhrh0Q/GbEINWPDBB6I3PemNoXqIlN62qDOnPulMe+kzzfm8lzjXYM8MiSyf+UrDyZq9gTiOAqWjmoC0//nRTwyTahoZaNADJnQBDikpHCAAsYhKWKI7sIBFlKrEQD3KERin4IQaUuAFGXjAA3ywxA5AAIINaKACFVgTCFQwAxo8ayQ60CaA/qAGQ8iQXTzRQx5uqBs4oEaHO/RhDz2EE5p0impC0YlQRlQidSERc+2SodUewYg94OAFkbDDEaBwBRzYqAW7gsIR7DCIMpxhEDdChBcs4QlOoAIZ2ODGMtyopYshAxjCECkwliGMYOiuS89whzvqkQxaRggNaMAD9aqXyJq2rDOzQRknPWk+S8IpTnIKaiYpo0PzoYSn52vDUif5hqVeqlJNcBr9pApV6MRMUbIUV0+YeEtOaP8iLKrYJTCstEDCNMMZyGAFLWUAkj4YAgQOcIAEFjA3FYAgmnbDmw7usE1tvnARTTwEIXpITmzBIWWKlANMErfOmxA2J/CUp07maUR2xStz7NIsE2M4CUaEAXZVWegRcgCDC4zAXwy1QyTOsIc9YEUVdNEEKdzojF3cAhi2cEUtYrGLU5DCFBblBCk4sYlUFIMXvJDGOdJBj1T8obBouAPPEtsmP90Mki9L6nZzqMOcLZKRm+Tu9pZaXqd+4QtWrWp0yHCppjFNfm1w1BbS0IY4VMgP/1PRJCwBVlCAQqwIBMYCmVFgOh6DFYnAm1AyUMEGLEAFHijBDZr5gyhA6w//f7gDEO7gQh180xKCG2wPzdmzxFKXUIzjIU5oOc9ExJNElbVc5pYIzs7GkBFzIIsRrGIEO2TCcy9oqB0KUWRKlEUtoOgEJSwBil8AwxmhuER3vqoJUHg2xACExCVSMQxlaMMbYaYHNRrxoDnEIQ1oQPEhrYtJneLGUDwzlCK9Oz460yGpn9SzU4XzhS18ATpLc1p7U9m0prXBOGCQGRuWGocHBVERMuQvXTwB4L6kChnBY4YyjFEYYbhiyo7wwBRuoIEN2MAEJRgCCGQgBzzcgQ+NaESGNawDIARWcOEqrDmBswY4KBI3a26cYznkB0K0OJ4wHoqL1dUUFW0uRUvU/ywjGPHFPZyBoJH4RSewna96YQWKjKBEJxihCUpQwsq/OEYlbqkJSzBZE5IghCIEuIlXdKwe2tBGOsDcjWBAlxB1eEMasEBd3AQ72G5+MyLj3PDdKBJ8rxHfm80Qh4rz1A2TlGTNyote9Fq1Uqh0r/ycJjTSbC8N95Vap3yilEnfBS+rEI+rgpeMrxEDGLGCLg9AYAIbVOAgICgCHtQACU+I4hKzbgQfdBAFEfOEsBGy4RrUoIY1AFuxPFOxYz1ES6+7+MVDpNyngPJsaj17s4+QBJG2socrDCISZBToIAphI6wIydyWWDIjuKKKXyCC2pLguyXYfYlR8IIZ6bjHPv/OsQ58fEMd6qAHNi7BBz3sYQ5gaEMXUIxIhGedzW4qFHB8Vk7pSfw1OrNCZyL+p0DdzDTllX15rSryS43BflOAjnRASRxGv4G+aegNSt7pKatZAvndKZUrdpFzsLFqGM0QxioAoQYbRIaaKcADIO4QCmGIIhSh2MQlgNADPLioXIQtLB7gABzT8Az0KR6nhWISIQ51qNiU1f+y6WkizKVIs9yFXShBEfTu2lyrDOwARwAvEyLKDiQhE8BC735BEo6MEvwOACfBERIBE0QBY7yBHuxhH/qBBNnhH9hBHMTBG3AB1uJgDt5gCtSAC9Ys9ILtxEKvptqP9BBLN7BlMl7/Y/WCcPU8IwhRD2c0I32Y6pPox1Jsj1IwxXzcgA2OIw3SgL6wwCSGbw36BxB+4hGwBhJCJeZiwRZCaoG0hBoI4xhMARAiIwVSwAa6sBFQgRZEJfwuIQqkIA+QiHBoog/Gif12AzVoUOu2bkIgxH8AoSaSzRCmhrLO5SieDYn8r4nQYhBcixEEoRAQgQELYRA6gdwGgRIIAQKFBMkAzOsaIRR4ARrSoR7soUnuQRb3oR32AR/kwRzsgRvIbyXYwAukgAvUIP4WCWWyTrF2puJ00NfizJxsQwxiQwij0QmcoDPEgDiMcDP2zLxQaQxsT+Ta607OxzjQy36kQAqm0Qng/2AJTCIlqMYRsmOAxHAUXMEvRIqBqAEbqOGBhIEVNoEPYgANBCgUciEV7BAT/gAIxuA6UqQR/9BCKOSczGfNsk5xvMWH1K/4dGJqJkv/wO5ckGgSj8JqcCzgOLEQYGcPEAFHtiIT/isTEEES4u511KK/fqERLgEXmGEb1gEdzCEc4uEd/mEfZHHxhtId1MEbjOEPSkJmpoALgtEHD86mwEtlLIMM4OAN4KANqk4M1KB6RC4ao3FSnCAzEg0bkQa9Os7PvmD2xKANxgAOulIu1UAuVyM6OsnklurPnpILpAAJ1OAHLCwN4IAL+UAOt6O/gItryIow8jEaHmgZtGQXkv9u/DYhFEoh/MbPMI3NRXSCEKQuQvCAklIsxe4sN+hvxTakU+Bp/15MEfNL2YaiJ5LoxajGKCJNhgRmD5IAET5hLDxxRjrhGDoBEUAxEygh7hDBFDvBElTBGlyxHtzhY+ahH+aBOueBTMhkMcKMGzABCHrjfGjQ9ODPTSxjW/zkUkCj4tqEDKyAGjGjM4QQG+eTDtzyvP7sNNpPDYQPaFRjqb4gDdiyDQJUUVpPM0qvB8/JNPBgJrqwaiDhajCBLu5CFWIBtxRodzKUMCITGFpByi7hEsIvFCABDaJAD85IhqBCXPzwJVwiJtjJ2F7iD/WAQ/Sgf1iicVgCD9agJWz/dCXwgA/6gA/4YCWsrkKIdEj/4P6GVBE5JCX6AInQYgaSQBJg4Ri0gtpUBxa4jRGA7EcioSzErSwkwR3uwR7WoR3w4R/igQTbdCjXYSjrIWSQYSnvYKZ4KhB3IxBZgkKiJg4SqTwnwysdKVA8ozJqwz2nMSxjYz6bQzOUI5WmQEAVxTSqzlLVYPaqcAtmD30oCbEQq9fcT+NQoti46mqQr7/wokL9gjzqqHciM9OSYRheQURDARMMgQ9o4ogYkhAoRDTvC53+lP5mVOpI1Q/7h0YN4UHsr9giBBEfxOu8rtjgKSUA4f668K1sQhEVwdiuowRA4AaqFAKpje8k4SQj/2EsKIHuimwTywIR5KEd2IEd1gFe0aGP+gEfYJEe6KEe5JQZfGETgIDD7pSTSo8lCFNbyLMyusDzxoBhr4dO2lMIqREd0bEJFlUIBa0JT0kMmIYMmMPj+gy9qpDguqALnMBku+Apu0AY6RKRhAaUeg99iOMNllHO2nHsTlUTPGEUTuEUWEEWxsM8YLXmas4Y0sMWPKESEsEPXFNIfXUNhE9Pc2MLt3BIhxQl+NQPn9TYjC1c5skzFYE15ak2OxIQICfqpoaW/LBDghQPfAAPPKAChgCKCiEUeyRGsGgrBC85XxKKKOEdAhdeI28dZFEdmosesqEaqoEZqIEXSgEhdf9AEPH0RxE2D5aRB2sKUNuEYTlDLJugYit2OTB29TS2CQWNflxjOTyOdQEUC7nACUCXCrrgC2jXCVDJM8igDRaNDfKEu8azUFzNh8DW5bhDa7SmZ2XBFlyFVbaEVVhlj5BBFjgBEhKhD+TJWol0DdAACKIgCrKQf360QlpCNPn0/mgUJ/bPEM72EOCpXHpiJ+KpC3dC/bZqxChke9OADQQW1tAgA1SgEzJBEHykYA6GE+vWE4mTLACvXechHtABHVCwHNRhG9IhHbqBGpIBF17BF3yBGHRhFDxsN05jJSY3z4IGW6qOB31DN6ruUCU2LMcSHa1AlVavhms4CCelCJX/o5Tg58/QawvsZwtW1w0QDdGGIzqSWAxClqnibKYQK08/lTcslTCf1DDpKR6Nl2dRIWgFo0uK4XeChxheYRNkDYCcNjTjIA/aAAukdiVClfTwIAt54zR9zSWuhZwI8/7uDxFtQlyW9KUu8joIi2riKdIISGtMQRVAwdyyohD2YEYiIe7EDRF65CTHNBO7lBHeoSfRYR0ON8ysQRl84RVKoRRSQUuqBBJ0IAZmIDc4ierGa5JKTIV75lNd2DZgw4ZHF3RjF3SLQFFBlzloeBpVCYeH2YZ9eVKUIy2/IPe+wAsepXenOU8YRXeXClNVGHhdTXxL+FK/GQvgIFfdERIc/yEekRcVXgEXfOGLwdgYfKEUkg6A+ODFntap3CAPnEoNYiqmomAKvhcLogAJkMAc+zIKrq8HdmAHeoChIcN7d0CbnkWbduB7+Yf43ioRBog7JNTdUlWsdmkWQnoWpKRKhEHdVEHe9qAOcIQq6K4CYcGfXMsTP5ECyUgS5DXyvGEbssEasGGUcSEXQkoY4mgZZoGCYkAFYOZ8gCM18uxTd9D0DEUYH7YbxbKYnaAIsnoai0CGKzarv7oJci/3VGlpnOB+jLnPgliIp4C+GM2ty4tksfmbL5UwDWUltHcLeaMKsSCmsBALdsAHsABIaemME0GApoxURCEVaEEX0OODR/9BnvngDqxVNMHgB26ABm7gB7JgCnZgBp6lhH7lDUvoDUEAmZApBZDpA/QqBqKg6u7gDtSAD3RCi/FCkSvUQndBt3XBFhAISqBESoAhSqSEpI9BSlRBEfLAoXAFB6BAED4hEijBSomTElYaR/YAyApmECzYG6xh05RBGZIBjHVHdxyIoyphBmZABVIgaH7V17bnqEoDincjj6e4N6aYMkz2GXMYq7m6v4EZq5nDq7+awItArMWaacJafmLXwNHazw48C7IADUi2CqsuzbCwCvkSDYLRUu8ADjzcw3f01e6gatmgCrNgCXxAxYGABqKlhWBbspO0aow3FEYBaG1hPG7/QVYgARD4YDf4AA1oQAZM2wOgyQMUQoPmpgGWhcnpJiRiAECGYoAKyBRMgWtmwUJ/4RbKMOeA4baEW7d3QRd0IRiCYcx14bfTXKRnQZdgQRUWmRDm4NoI6giGAAqI4AquIAwYARY+YaUvsbVeSxPjzhuiQbyHwRjOo3fQCq1K6hhmQRUAQQ/qawpiViKVWuPwchC5+ZbN0SvtezK64DZo+GJp2L99uZhV6b+BuQmyejk6tvag43blQAymkQqmQDm4ugl+YApowAZa6dd/4Hk+u5o++7OfBXqQmj8UopVZOaIlWqJ3gAd2gAZ4gAasKb0T4g1VYMh/hdsTItmRHQjw/wAiDtsyQ4F6AQEIUggjFOAAFGDJEyQjGmCFVsjWpCs7KgGxtxholTcWRFoWAN4VBh4wZIEWDv7gXyEVUqEVXuEVaMHhFf4ViGEYvHwXfsET+os5BY9w3kALwOAN9OAGlKDu8pzIFuoKCiESTCcS9qAq7MC5baQqNHEYeKEXvIYwqIEaHhOkiMsuLAEP3iALvGAK8gSFKel8OKlQCLOFqdi+U7YLdlnAe7mXQ3fVv1qZpcrQAm3At9p+GnwJpqAHhJ3sp+AHkECgl4AJsGAJvDeho6CVGLrafYAH0psGfODufUCh9b7urz29FaKENKhuQELJC59uPkJB+AYIIGLLIP8BEhBSooHA2V/InJlCo7VGFU7h3wfeFQpeFnLB4BFe9HEB4iPe9E8fF1I/uXihg8PYwKJhVXrhto4BFLKAB8DgRCG5DFyAoXBgCP5ljAphoWZEEBbqyMIgDAImzwuK+VUrEnhhGBZojxodGGbBE9yNgDRBEfDADbwgwmWGUoMmM7gn0+NAB+va6b8Z6lN96oXZ/UO3wG+gwBN8Chpc1yu21uOAqdKaw4GDJZwKIOKQiSMmTh49cNRw6fKDSZEtU37YoEFjB0UaP3rssDhjRgwVKVJ48JCBQYYGDU4yWKmgZcsDBxTAbMngQwwgaP5A2hQqlKhSpUaVYuXKVaxZtmb/KbV1axewW7ds2cpFlRatV6+sYt3KFSuur7zC+ipWzJgyZcyYPYMmrVq1bHCzdfPWrW42bMx4BQO265anHTLCDJmjZMgVIkGCEMkB40ghQUSuQLly5EqnTILsCKJs54qdyZM12/l8xdiyZc2cLRN2C5YnTZYsSWLECNSkPHHcsMmihQ2bNm3evBlIhsybOMiFI0cOZw0cOHgSqlEjfbrCLti7OHFixUqT7028g3fyvbv47UWcFFmPXn2RKVPeN1k/Bf36Hkt+TAH+5c2XhGvgIWAecHxR3HDCfbFEfj9g9MMPHckQkgogieRBCjGI9MEHGWzoAYcmdRiSTT7gxAcg/4k4UsmKl2wiyilEySKjLFNRpQstVOVSiyyutIIVLV99ddVVYIWFi1jDkFXMWUyq9Yw100xjjTXZaLPNOeeog6U44njjpZfbbGOlN3J1k01euOzlVxw2tKCEEUcckUNihRCBWA6SHQZFZEZcEUkhdpRxxaCEFiraaHachowws4xCiiqdUNKJJJRQUogklughHERTbJGGb765IVxxZJgRh3CoCrfGqs9VZ92r2Wm3HXfhiQceeN3dit58RfDqxBRLdApsDzQEy0RGSCDRw0Q7YBHFD0vQ0MMMFW3kAxYyqECDDNvKAAJIF46UQQYkjesBSOOmFIMO7AJxBx+JQAIJJv+bYOKJJ6SYwspRu/QLzL986RKML7r4QrAvweiSCy66NGykkLTwosuRYYWlpJJnPfNMlNdoI0466tRzzzry4LPPyf304446XIpjJTjowCMPPO20sw7LXnIZZphkcvNML1YJ8wsoS9jwQgtx5gBoDngSAcNikeXZmSBQnGHHEWVodsUghRRyRSGR2DGIZJ0NcswsntRbiSWVajIpI3sUMggibdDxhrBLpKF3qKOSmmpwqrLaqquwZredeYgjXp55uva6Hq9TzCDDDD1UbjkNM4BEoeYqdNS5SOOG/kEKKJW00kkNMNBASDHEsMO7hsRLLyeejGJKLE0BIwwwx/Te+zL/yByDTPDDI0PM8cgfbwwvvRg8zPPFVOw8WWallVY02LzVTTr01ON9PfbQY8/39tyzT8roo/9PP+unvI897tx8Tjni4IO+PPivg2U65fRPf5feoMYwcqGLvnAiC0UYQg5EQALGlOEIOGCaYhjjNChk5gUvGFsYjqA1KEBBbGE7FKI80wlNUCI2lsiEJDrRCUYQghCHoMQh6kAFK8TnV3n7FN/mQCq/vQFwb1iVc1r1qiIa7nDd4U7ibmWr9TixCDe4ARRtsCwKZQsEWFQBCMQVOnKFLiUracDobqKGPtzhDoZAUSM2QTtPiGIVrFCKUwAmjDruLnnKw2PyjMFHYvCx/yx85COT0KKxtmhDG1Tahje49z3y2eOR3nuk+U62j39UkpIn+4cmN7nJS1LyHpBUhzr4ZzJM3gOUj3SHO+TRDnXYgy7JwIUvbhELUqxhCkM4gglIQIIrlAEHNbjBHoyAAw9Opk+ekcxmuraH0QxqM5jxDKI205lKUSITKqSEJGZDCDoQghKM0EMTqNArK/zgBlP4gg7ZIKpTDYcMYhDDcYADHOs4Zw1F5EIRFTIrJ4jBCtupIXjiQ5/1ZMQGCO1ICr610JCQRFwjIckY16UDLPABDn1IxCMsUQlNeEIVsIDFLX5B0l3YURiL0l0dgTE8YSTveTCF6cViqqRkJOMsav+BRjWwMRd6+LSR4Htk+U6JSZSdr5Lp28ck08dU9nHyqZYs6ilPKdSVUdKpJ5uqVsdHD2YYTBi7MMUkKJEEHJCAAx1AwRWMEAYjzCETe4hbGARxBEF0LU52xQElfpEJD9ohbKCRpiDsmhk7ZEJS1wRFpEChwm2qQhKH6IhkZ1ADal0kihuhyAyoiNBlTYQiy8JcR2hgA8lSKAYdaR2FQJCCCi00ouX6YrpSEtsNratEd/hDiuaFCdqJghQwMkosjgKV4jYlKkyRSi2WmyOq4MIqVgkSxSrGC4NdjEmFnMY1FJmOc4BMlEEVqlAnWdTzpQx/JcPHPNbXvqa2tx/ziG//U+frVKjO4x3h+MY3rnGNb4QDHvCNxzvgMY4sfaN/26VHN4xBjDqaIhFkOIMScICDK7zgCGeIRCYQkQlGIKITx6CE1QQxiM7gaQ9fy8TYRNPMZl5hsH8NW1yxGalMfAKcLLwmOBXhhxtsxAZRjOJFaHADHnCkI5mdrJI1O1kVoNYjrVPtR1obkgmhlgc+wO27dOsISFRidvcaBYyGO1ylKGVGMoIuLVzxCjSr+SqveC6c4zzd6iZpSTjVGDSkZCVFLhJk4RXvI/FB6FKerNCFhion6cvo9MV3Ho2mL1RTFg9z6Je/+kUHpB8tD3aMY5Rf6qpphBELQMigBVqjTGXO/5CJTpRhD2GYQxg68YtCoPjFo4FC1ijjVxJLohBn+JrXumbBQezhsNjEZqUkgU1mZ+IQU9CCFqbgkCEMISI+2AEPlgCEbmvbyOyigQ5Ei7nWzYBdOjg3unXQbTRsGRDy8vLs2pgvOB5lFkeRilR2IQukyGhHO5JFdOXclR91pc68uHNZMiYN7faZS98F3zrYAY+K4w8fFc84POaB3vSWt5L/QLTI8bHJkSda0SjXZPomzdRH13eT9yuHfvUrDnbIA+T/eAc6ysEyRVZDGclYBjFuoQgZ3AAHkSGCHXAQJwyfAQeFuYGsuXaGQWTGa6MZW2U6Y4djR2IPJNbMY+wgt/9CtPoyOc4mpS5DiGh7IQ1d2MIX3BCHbtv97miIQonQwPcz8uEPgDBEI7x8CUxooo22U0VR7j0LqCBF38hVLsBpUQvKy1m6QXoYdasrFuo1SWNSqtLOvOtd76nSZuxIPTvQoXrVwyMer4eHzs0R33jEo/bzkFl6S4loTZ485cAHfnphDumXq5zRT7VfP/aBj9T37xzsUMfNLbm+ebDeu9ZQhjGCfgtI8ABOMMjBYuIUCV0bYQ9HGMIZ6mDsPQzC6nYtMWEFEYmtkzgTkaA/DiJwgSAIAuzGRgmKZU06tk2dAAuUMAdaEAd4wAd5kAd80Ad/MIGJMHhfZnj0pgogFVL/StEU/gIwINgwIrgXuyCCClMkm8c8FdM8vpAkCmcWeaZTVLJIXpIOjBRUWvU+JkN9+0AzrNQOF7dJ8hAPQygP6/UPq9cO8IAPJdMPM2NxhDZ8ikZywVeFilZehoZyiPZo8xCF8vAOYBiG6DCGZGgO5lAO4bB67PAO9rM+/uAP7CAO6rANyuALQQcMmBAFN2AE4Rd+ayUIn1AISpMJR6AESvB+xyYJ6Edif2IHcBMJnwBjWddiHOAAFkAEdvUYgnBNh0Uph8UInshYmNIJ+GIKGkhc/2JHvrOKrHgMdTQ8xBAMyONSx/M8A2MwByNTFwODyqBnDZcNfsY93NM9QOVI/5KkVZOEcpI2aeszcr5XaJXEhB7HfKknM4RmhdiYcodmcoiWca2XemRIhvkVDuRYjuGADuZADmZoDuMQDuuIDvGAPv6wXuywDc9QFs1ADJugBnHQAiggAjDwQVCAA0YABZghNlfAfp0Aa4jwdVQDY4LQCXIjf5OxB2VwBnsAiZ5hdZqBCHtAKYiwQm8zCJIwN4pIa60Ii8XTiqxoPMgTSDAZSMkAg9YTDdFADdBADdggF95AjI00PseIjDn4SeRVVCznXldYXsu3fEbJPk7JXtkYlVQYcoU2X/gjM+3Qev1jjubIJf6DhlxJjv3zjebwDpVmhjqHjuYQM/Kwcu+jDf/PwAypEQt3wAZGwAImgAFBAAOAAgVyU39QECdD8FfDhANhwHWCgJEk2TVckxm+5H4l9muZACiAMjdV936FEJKPYWx1cAR1UAcgtorI8Ed45DsnRQzDswzJkBYagz1l0lM+FZuy+VNAFZTmU5RKeT6clEmKFmkpA3xLeVTB+UnmhXycNJXHWXLXqIWFdpXvsI7m6F/hwCUz9w1ckl/6RY4z55X9Y4ZjaIZj+Y3nMA5hGIYlY3OGRkn2YIPbcBfNIAykcAha0AIXcAEvAAVMkwOIcgR9snRxwnQQhDWdkZFcI3aYKTcf+X/uZ1eR0Ih7wAiDUCma8X74l3XSRAiVQAr/sPALwGBTzOB5ZUEMumA8LiWLxOAM3MANddGT3mODLjqM4ZUO7SkmUSKH6+AO6XlJwPlexld9y/hUWHiNT+mUbdhJ62N7SIqk8vWjIQdV9uOcsxeW7ogO5DAO47CW3zkO4al67TBgszeG71AzqVczWVmm7HAz4kVV7lBVWmKD9TBKNugNPBMm2QANXoUKouAJk8ADNdACJvACndF0xsSfUDCYnxEpchOYXwMLC1kHcYWZDdp1ZEd2JdagJeZ+dnBNcdWgIdSg0rQHWcAGhgAJl9AMPrU96eAN05ANzxAMtGiiwWAMzxBq6QA+WHKr33UPJnMP6qAN/KUNNUoyyEly/7/3VPS1nMfHpJr0cZkEXy7Hhb9JhSlTfC3HcegVYO8Ajju3luFQDtwKnt06neKKhuxgDqtHpVhanmNKpp22huWZcTMzM1npDvBwM6LEP+fAJeDgMofEX1MCJVEyJVIyJXAhp9gQDcowDK8wCqtACp7QB1FkAibANEewGJThGbnUNYPVoI8xKH6pYY9qdYw5GmVga2dwdZM5oZnBsZ8QCYNSsZmhdIH5anOQB41gqvVAjOrwDetAD9iADCoVDMEAPdEwF7WqDvfwldBHcf8AYP1QDr7KX9p1DjgajVz4aMxpcsZ5nMWKnDDnm7+pVPAjP/MjDtV5tjMnluzQP9Rpnf8tIw7/A33qEH10G46qx3rrcKPxk7cdBw/VWGBsCw7fcEhR66/XECWIKw2Ku7gNNw2KOw1uUQ2KCw3QgA14QQy4UApp00aUEAeUoAQmULGDIn45MAiCOgTuV7GFGjYJWQdl8JmDkLKUAQOR0Alio4hiNxokBnaPATasGydXo3TCZgdGoAeQEA304A3KoA30mobpgA3OwBr9IrS9kHDQ4CWilLStx5b9EI/9sF+Fqw3sMJVLunLZmD4dd63IGpVP2YW5N2CsR4blcKv0m69me781Zw5h+Y1rq7T0+3yilLcTx3qqdzP26l1ccg79KrXaxV+Hi7gQHMGJu7iOy7hsoWf/0KAxGpMWyUAMtdAKeXov99IJeTAHNcACjJEDckJ+SzeQkhEnSmcEKmYHSnAGNrwHVdcZdgIFtYvDlBA31JQZc9MZlKFhheBBnhEZnRE2lbEHmBAN3cUL0qAO+dUO2VAMu3AMfGFSJWgx1eAN52AP6lAO4wCO7zCE8OWE4Hu41wAO08ejv2mF6Hs/bclU1zqtV1t7SAqGZliunoaGgCyub8ud81sOdDs/0AeG6BCm4AgO+zq/WCJKkqwllCxKpMc/gku4hAvBjCvBnPy4njywU+IWiksNDTfK0kC50kAl2EAN0RCXMymirnAKabMJpDAKntAJk1ACLTACTOMCLpCf/8JMfnHiJxvZdGWgBH8CKESwJ0SQf7H7fpORTHYgCZ8gNi7msit2GO+HkEwXBqTQk/ZwDemQtOFwDtCAC67ACZWwChxqC8AAFsZgDcJIxmZshOjTDr/KxuUgrc66pNholU/4hBWXlujYjlIalmirX1/Zep92q+wwP+vKpWrJen7LDnsbP5LcMo5MuA4cyozbcCHNFiENyhVc0iUdudSAk9AQDZErudJgkzIdDcyQDMWAMLKACqMgCphQeJ5AO4oVTP7oAieAAi7AAi5gAniJAy5wBIHJh4jRGENwAySZNWfgNfrZzFdzBogAinTlV4/RoCRGV6Ph1M5MxFdjAjgwBf+XEA3gUw+pKofpQA3BgAkp8ii3IAy2UHlhsbzboCVlnHpnrF4pUw78lQ3W0F/sAHJ4bL6O5nKPzXEXPYb9s9DfYKXgEA6ZbY5WaqVm+A3g0NmeXY5XSoaiPYZdKnuKHI7j4MgdXbgPDNIUHMqcfNKT27iNa9uTm8GUS9KKa5OuPNPALdPP0AzGHQ3NMJPDQAupUAqtsNOiEAptNAshBQuMAAItUAYkIAIi4AK8dAInkAMUhtQu8AJDgNSM8QI5MASFoAqFwEHD1Mx2cjV7EEWOOXZdl5FXgCfF/Fed4UFKZwcbsAI1UAWOEAzdIJup2g3ccAyWcAiKMAmQoAmz8Av/sVALulC9yrBI4oAlY4o/kAYP/Mox33BzTjWk7MU+JSMz2YoOXGnZZ/uVB93aoS3ane2d6GCl8TuG5zqG8SoPeWvJmH1pDlzkESzSSP4MuR3KAOu4oQzTbmHKi6vku70WvU25GCzcr2w9aQF0xjMMvlC9X/EKqdDcovATpEAKqBAUo4DLJGXdMrACLVACJiACKJADLhAEeO4CMOACI8ACOKDWMGAHRHDUOFB/ceUYkYAD4acYceJ+SlAGRmBXojGZulQZQRyIffkZcgInZcAImnALzZCiCsYNzXAMtwBOhDAJJeQJJKU7x9OLcJ0lJMPYKYMPa/qm7pCbTCmN7cq//w3teldJhl5anmGocUvIfKyEXvEDSmvq7PZqyVsCJpqMSNWOSFVy7WKiyXCxM2GiDaIH7nEBF3027uYOF9kDjO0ZFztpuZa70jYZl6r55WFOcK3Q3EABFG2e76Ww5qiACqcwC0XBI60wXCHFCDVQAyZwAysAzErNl1AAzEatdILgAihQTEfgAqPx3i1Qup0BA4MSBFxXKFAwCPm38ZGQS8lUGX75YnZyGHU1CGdQspkACqawDM6ADM4ADLGgCqCACIKACJbg85BgChx6R9t3vVmy6045rWEK5HP7jUDIDmQafaK0Su6AenOrq6u0Dq1E9UD4g7s3ctvISnnr7KNkv/8eLbVNHsH/+vZUcu7WUA1UQrDkTrhV0u3rDox8f+5xQafn7u6Cj5MbXNPGUAxgzgtCghVlju/8nu9idgpAkeancAr/fvmVfwqxUBScT90IaAQ1sAIvcAZHcAJEjedOMycWnxh7AgUwwALht3W85vqIIbPiR8SD5ZiI0kGRQTV2EjVKlwl2kANlcJF+WUKcUEf9Ukuw4X6HoAnQPwnQHwu6E6tm8QzXMHG0173zIGDpyI7kOXs6/g6e3cdgH6bo36V+fMa6t1Xw4w6otDIbrTMLzMmFBMrSQOW1XcEvHblSIsEAYS1bNmsFrVUbOBBbNmzYujFsCDFhQm7YuEHEFk3/Y7RmzJIZMzZsWC9euGi9QtlKZapUpVyWYvlS5sxRo1ySwnnqFKqdqHjqPLUq1ixWO1Wp6sTISI0jRnC0gOEiqotBRFDAgEHhKowgdnK4YJEDBgsYOa4cIYIDypUcRKyewDFEUKRIR45cuSLIzl4iOaAQKWTH7ZW1gCMROYLDrqA9jCyBIjXq1qxjqiRJ2vNJEiVGfRR56uMJmDBkxJIpK/bsWzt48frNi/eO3Dja4cbZLjdOXDjbtNmZY4eO3XB07di1E45OHrzly9upS3fOm7ht1bVZuzZNu3Zp27dL6+5duzXx4KuBlwZNvXrw0J69hwZe/MFq9etToxYNPzVs/9Sq8d8vwPyieaajZA40phiRfOGlQZRQYomllVLxqUKfgPIJppZk0qmUyGoa5RQPc7pQJwtRGSqoVY6ahIdMCtnDjkFM4ICqHFhwAQW2iLjiBBe+ciEItQrJoUgX7MrhiBxeEEssFzqA4QhBzrArjLz2skMvIqCAIhI7ujxCxiT/EuQKHK4YRJDLOuHEFFiOskQSRs6gZJA6JNGEkUcO0USVXUw7TRllphmnn9heQ8ccdN4JDp1x0FEHUnSEGy5Sdc45R5xMMxWnU22uAVU8UeUTdZru0DMVVfvOM4g89NBbVRoB/asmvlfBG3AjXd9jplePEBzGF5IaNAnCVIyNMP+VVl6Z0KULfVrFJ1amXWWVU0zZSSWeKgQKW1OwBQpDVEoRlxWhToklllFI0SQLDWpwwa0TaDyhrKiiQoEEFERAQSonizQLSbugUDIuHJLEwYimGkNkjzAGsQOvwAYhDC87CrELLyWPqMuuQfYgBBFKLLFEE0sYqUOQMOqoU5JjQAkDFFX6uKMSZKjh5qJrwFHnnn326QcfeYxb59Jy1Lm0U3CW1qbpT7Ob5r1X36P6mVtRvfrW+rJOj9b0trbPvFUPGhC/aNx7Bj/1eO1VUGU+AinYYU96sJVk704WJplaotDCU0j5SadvvR188J3CRfxaUyJLvENye/Ip3VVIMWX/khRSWGGEE4hwwYUrOBgLSqmiIkGqfF94oSwTkrwryywTM8KIIYxwS8kyjpAkkzLOKCOM1u24K8yzjiA4zIjNAn4IHO7MhBJQQKljjzrqwAGHxgrJpJNMppRzCx2AuKSZbrzpJp10vNnGm+lGbY9qX9luWxmqbW1vvfWsfhXt9Nae/3737E/P2c6mHo2gbUAErBozntGr0ySoGA9UULAaVJIHVTBZKrGbhJSVQZlUaCZAAdEoRBFCEY5QJyRc1+JwssLBqaJwpGicuCoUC1d8axIq8IAEanCCE2DgAhxgS1tAZwcXkAArZcmRvoqEJLNs7wgx0gvwlJSDGtQgRnso/8MNsHiGHARmRxFbS5i8dAUv2cUuZxhCIT6RFEpIQnYvUFgOMrGZTgjiiWfYwxCy4IhLbIIYzWiGMhJkDNQUo5AQFBRIAuU2QTFDGb56pAKrtsD+oa2S9rPkJDW5SV11JH4gSdCCGFQSutECF7iYIC9GWRJcVLCCGIQlBjeYwQ2doibkumVNRLFLXvZSFKEIhS97uUKcgOiFOAFX4yxUrVW8SRWV8AMYNGABCogAAyIQAVb6lQMiRgVgV8lBvtrigrWExQWFSIti0hSJKyjvCDV4wRHCUIY5CsIIZUDTXggGmL1wrBMXU0r2uLSX7EmiDoMow8XQJAhBFIIRHxtEIf/KVIg6TAIUsPgTMZABkmIokpGCOtCB3nYaX5W0IyeV5P/eU0ABPoOA9pkVfxrSn7LlikCO/EgyRBIMXzDolKc0ZVBpMVSiDtUkDeqpL0QiwZ+epKhPLeorZDHVqbqiFa7Aalat2oppuYIVJ0KF3SzkrBKZSEXfOsVRCrfWZAKFhrPwarpmAQtYeIINMsBiBzqAgQ5g0wUj4AAKOhCEILAAB1M5AY7SEqaDCUIsSioLj65gBy8Z4WK82wMOBEEJRHSCEmeAwhCuQIQvcfNigdlDjHgn0dtdARGD+FgUyShRGaUWEWfo5xXK8IY+wWIWpCkNKI0RUuISdxnLSIYjS9r/K5R6slec1FV0OwlIQDIDuR+JYC+GRSyTQNW7uMhFeI0KVKOWRJVL7SlJuitU7xJVqlR9hVW3ilVYTsu+YB3XiXpi1sBha0UuNJzhEBe5WAiFFaqIhZs0sQQwrKAFLNCrYFEABbJ0Lkcw8FEOBIEDsBzsCFEqRFmCiCOp2KETdjmT9nxnl06Awk6U2EPGMGYxiULBDrc7whkKkdAz9PjGvaOSxb6El8ZQIqEclqceIKOK32qUGMMgRpRBggwqIyMZGwWllYn7q+N2mRnU/TJ1xQxm5FLZGE8Ohi50Ed71DtWVFXzqg2hBVTrTGRe1wHOea2GS8ObCF8EIBjF4ql4+/5O3vXFmliviu6ytxnIlYfUbt1DRVgyFy1qCAxdbKW2uo7hQFZZYggqqOAK+7qsD5GQBFKbSuQxn4gpgacuXDls9JZ1giWE5TO2gkAkqcQwRdWie9eyoWSVxaaBQKIPDPvGJMuDgdi+63Rks9hfSpnZlUyIiC8qACEVAhhW3AAYwShNlKQvXGFVG97mNe13iUpncURYGoH2x5lq496r3vmp89a3olKDEzXL+d3t/amg941nNuFCzn4cR6IWTRLu5GPihoVpBrC7a0Y/Wlt8UVzjE5SRcaMX0WsPFaVWQQmaU2AEIhlCDDqAAAyTIxJM4MIIgwaBfgoABB3j4Iwyf4P/DcfmKzyNxWKxAoXNEIOwVyoKDQuw4DDVw3o4JFkQoKMYIfjmC8iIhiTMo4QZP1F1DCWMHwm4pKWcYBCMCUwaC2YEQllCFUGyxC2AIGtCBfnfe9f5unq45vLWIr1dZwVWfcNXwgw/r4LW6eK3W2fF0nvMroIpnU/4U4uANry7+/GeeBjrQSl14MBaeCzX7vanjJSqd50tfWIY1463o71op963Z68TjORHw3zY+OJyo9VugoMQMZNCCGnB4c0E4wghWYIEVPKmIRaLAvOqFlQ7kAAcmaAGHv2KWwsaaMGXJUg4UdoVeH6EQg0iMXdySJLdU7wVWL4MbjYD2TngJezj/CIJbtpQXRogMEYIYBEqQEURABJlZBVeQBVuou7sDNGBgwITLM1loNFi6G7KKIROpkFX4KvuKFsZjBflCwMebqviaszmrBVmotzsbOMyjBdLjvKWCMo1ChmDAhUADiSgLPZ6atz4jqjaLwEbLqtZDvG0Rkd3jPWJCKxiyPdwzHBZSodkzhU57HkpIARCogRHYg865CjuwgCMpgRWYOR/hl8QygcSKFxOAgStggRc4CyIQAYDBnjApkv3LksnqhDRBhBYIgz3wC0EgkzD5sCciDHtSAkQwAiWgBEEog0iYC/1DOq/gmF/IhNe6mE+IhE+ghG6rFgTchV0QBnqrhVyw/4WqCkKVcAVmYiZueZxw+QliKitUIAVyIZfCS7zDgz1TrLiskoU3E8EUZDPMA69eALQYlLKN2qheMLMbfLLQ28GfoqoTREFbGEUJXDz7MpdosZbAWUXEWZcVAqEOUcK/IaaagMK1cqHneYQUyIAKaIG/QoF3FIGZM4KUISIiOAERKB0ROKzEar6nMAIOMIu1KAuxyIRMKBKs2D/AMIuzMII9UJg93INCgIL8mywiiISms8QhyKMhmJ1IGITxwwvCCoKysItC6IQ6MIMeQ4QrUCNBIARNgIVbuAVbEAa6wzOqigVZoKFS1BZUxMDAAQrA4Qmc8AliisVYFBGXsAmy8v+gwrs4i1MJlHi8ejOlPiM90hPGYSRGQfujZHAGnVoqBmzGU8qFgjO4UcQqasQqa6wWv3mJxomMx5FLWSwFm0hKpSyhFKI9T/AETuAES6AEQkiBBpAACdCAFbiAxLwAveKAFjgDTFwBm2u5IImE7VsiGIAC6+MwzBydcYKB6sEK60uSSKiBFUA7u7id48G6IxiETBiC7BGEIVCCpqueyYoRtAhJxFgL4CGYOmAEQhgE3LoxI3iDTviFXzgGGQSGXbCFW9gFmbyFdNnJqkoXwfvAU0TFa7TGrsLOaqEWDRQ8DfzAD9zJdJkqWqg3fzPLCHS8UeyzqfrFzCO9hNOuYFn/hmaIhmFApVOqm7qJpZiYiZm4kJcIIWEy0F8KJmAKplLYpWAShZc4pQbRvFtwhVs4Tk5AAx6QgQ1dgRUogQ3YgBXAPhwAww4YARM1gRfggBeAghbAx5fDRyjoFxfApqvYFxI4gRFAgXDKER/JTFpjipWrniFgGTcaAtwqE9ICniIpgykpgzKYvxjjptG6SLTYkiBYi0GAAiWwiyGwA1AwKMsyozJYAuMUhtFAhubsROichTadTrW0zrUcz+2k02tEBQ0UTzpdS60yT1koQRQE1BMUVPaERlnIBVnAPKskyz7jhV44JYfzBY3ABmOYIJNoJX9zM1pYlpSQpQ0J0ANF/1AFFdVRfVCXOJZXQKVh6KjkgoZ0oAd66IZu4IZl2IVjOAZSyAIVAAETsAATcAF44QBf1bZMuL4SKMMRwAvAWosRsCYfOYF8yZF3jAofMSIXqBepoFEUUJJMqLo9yISho7UwMAHZKQNQyIS7qL8QixLdGgJJKATFEL+98NIjgNLJCoJCqItCUALZVJhCsAxvDQysCwMweARYsNVjAIZRnDtbmAVbkE6selitopbr/E7u5Em7wVhTxCCtuqrGO08/Bdk/Fdmb1DOr7LNFVbMJ0q4IVaqZioZi6KkJ0oUV/Df/pCUAnYleGlUFhQmUQKqOeiSryYbx6RTzMR96sId7uP8He6AHb3iGhauMPuBQEGUBE2CBI3iBERgBEzABHCi+FiiBFpgAFuCAmWtMrrUmbH1HF7gAEWg5fmkSmsOAZ31HFhgBhlKL+uOctHiBrp2DMKiMOdiDTkCEJPgRrNuMM3gBP2QdKPjIMxmttuCRriuDOlACMooEevISj2TIOQCDQ1CFXwCGhpXG5pxG6URdUlxL8NQqWABPXPzPWPKqjl09RaOqEHQ8kfVTs5RPy+szNdOuBlEvXoiyYEgGXyiFYRiuZAiGXkg48Co9Xai89brUN2MJlIhQXoAgQgpa7bgGbagObzBa8/GGcygHcXgHRmEHpBmOf+gHe1CHaQgJZBD/hkSQARowghKYgBNNLK2Fi6ptgb411h8i4BbQWhzRq76ysBfoHICEAhGwMFuzMBTYuTJBHUYQBCJIQznasBu4gU6AhTnwgziIA02Ao920RMS4sephDI1EhDKQyNEio935tT3AI7aLmIthxBtTgj3Qgz4wzslo0+Ysy0J105xkPD5NF9eNU69ChWlRCQ7MU/taPBGEvKciL/AyL+5CpUrNhUYdlpUdhmbAhT4qhVA4BVFoBUBbs3kjtC5OpQnyhQdqpPcAlW0QB6Sxhz3mYz72mZ/BB+M4juFoh3eQh0OWB0WplHNgB3zoB3mwh3TIBmpohmUwhTzYgb8dgQnAgH3x/9UWuAASeIoW4IALoBEaCdFgNYEOZVa9ggEiUCINhgESCKeBnAs7kGAcwYGwEB6iUxLKugGNTAJG0AQ/OARFYIR4ShIwykzNhAJ7EgRJRDt8JQJBcDVBuMNBUIJBGAIpYclCuII6iqf+q4M5oATfatOGVbObTGe5mgWdTGLUnVOKfWIOzMCuouKs0jepwl2qgipgXNTwYqUvrlTt6gVhEd4GUd5gyAVkWIZPRAVXmFlVOmhVBdqg7Y5s2AZXrYd66GOlBZp+EOl+2Id/KOmTNmn3HemVBpqWDhp5GIdzAAfrAJWalgZBwoVQ0IRJoIEV2ADAernOWRLA0toUHYRgvf++DQhbEygBYy2Btu0AIyKBF9hR0mqLF8DRNowKssCKxJKSE3iBIeAShcEBDxaEJEiCQVgjQmijhIHXK8iExULNeTRYSniiL/mSMIkoRpCE3hkSKMCePYgE5TmTGJGdbvuFWYiFuSs4xXbn6ozYJMbO8WyFVeCqU6zsPAVCDIIzqSLZPLu8/byzWrCFqzTZ5x24VBqWP9OFYBCGJzMJQxLa6tAUdViHPe5oj/ZjkP6Z3vbtn/GZ4N6H4FbapbWHergU6RAHb5hpp7mOaUCIbKiPgYgGZiCGVwgFTNAETZiDLyzbCKA5FqhaEwAsUk5RDkgYGjFWrjWBIWhHts2mqbb/o6ZgOhk9gk4ogxVYxLTonHXNzF1DBFhghDCoghZoyD2ghE7YsZSpurAuEw2zI/GLBEQIA0o4Bliogz1kzX+KmDIYBFjIhOmxi0uUETJ6iniyMYKZgkMA4V+YjIXFM8dG3Rl3hZ3ERdbDN9eLJWvc2E3N1JOYKqqc3hUk8iJPJYsG2udKm4yo7kCphlf1aJBeaZNe2uIG6T/+bSu3B3fY8ktJB03RlHMYX/JVnzIfH/Wpjm1IiIXoj+NFhUtohEZwBGj60A2IAAjgIRaYlwlAahoJ1gv4QhUN6xI4gk+wgzcsHQ1+gRdR5SGIhCDoADvgw37a5RPwCs28AunJhF94/4MquoEwCIMs6eYwIYJurh3JRRLG6GFGSC2CwVeIaYpC/4RfqwO7WLYb2wyMSfGI0a038APjFN3lDDe668SEHd1YkMlZ2AVYxIm6tIkC3aUAfYltudMKgSX/fLNs/6kjp+OghYboFoejWQd34HLj7uhXpYfb5u2V7od/MGngVto+Tto+Rm6kMdoyx3fy6YZtGB/wtQ5/r46JGAjrgIj8aIZk0IVWOIVNwIRK0AROoIQb8NAR2ACyHQG75XO7PYHEVG/ig5EjWGUjWAEUYMMHRoEVtYPGHIK+BYsTgJfiE+8iGYQmcQE7wIESqAJKaAEJaAEHOxgm0eBTR7q1yAHki//1HDuDG4BhhSkTwTCjpmtNcGZNhwkDhwpOvFiLpk+tObCE41zO55QFXShd5pRGuYqFO21L1wshmeglmVjKUvAJZcGb632Q7FXoJJeaabgGPE4HpNHtPVbaKXf3we9tfLgHeRCa5YCHdzAHcxgHczjfb5D8b1gaPO6UTsHjNE8fM49V8vH88YnVzj8fzg/9NZ+IhjD4GXQFEdqEkgGFTugEMPjQrNXaEijbix+BB5s5sg1b3DECsDVWF+W5GmGBC8B9QehbcPoK8Y7Mu2iSfXQBB6uBFtgAHHgBXVYSIkgdrvCLLWl6tpAn35FNM/qLv7gC2bkBJcCj7YGRGDvEQ6T/hD38C26SeknXgxaXq7JfbPmqBYi9TlQEiFWoSJEqVQoVQlSjFi40WEqUw4ipUr3CxYuXr2HFlCl7Jq2atm3evKUrWbKeO3z7+rFs6bIlvpj45Mlrx64cTnHfvmnr6fMa0KBCfWoTCjTkNm3WrGWztu0p1GzaRnbz1m1btmxQo2btmpVbNmzYqEVrxgwZsVyuTo3yRIqTJ1WwOi250aIFjhoWVpQ4UeiIBTs5RoxgMaKEiSE1SrxoUcIxCgwiSEx+IULECw4dYKAQMZjDiDI5cOBgQeQIDDuDYOCAMfpKjhM5iBBxccTOmdF7ykCBYofIbBxQjlwZdMSIkRtHhhwJ/xJJsCA7V6CUUaJE+nQjZwZxP0NJUp1Mv69cEUTEju89fijJhQUr1qz4s2S5qm/fVSxXrFi5kiXrVSsBtjIRgQW+cuBFxWykDDPMQCMNU9tURU866lho4TrruLPhhvK4I89M8LyDzjslomOOOeOEs2I4O7m4U1FHPUUUjUQBlZVROWZVDY9e+ZgVU10xJVY00TxjVjPNJJOMMcME44svuuBCC4CtlMIKKqeYQhApoKjSSRog8GVBGYyscIIFJYjHAQcXXEDYBWyWIUgJJazQAgcmiOACDJdxUEghJKDQgQhBCJLDBSbgsAJxV9hxxBE5XAEDcEfgQERqtLkQSSTl4f9gaRiDSNIbFKcRYcQRZ+yBCKSAXkGcHYX8BsUee9SxRxhXFCIIFFdEQkkmmfxVyKvSQTodeY6eUUcnloDiHiztxcJKLNVam199/x2IS0UJKsgRM89Ukw1J9HijTj33qLsuu/bYc4+F7LQz77w3iaOTi0b9lOM1MR7Vb40x7itVUD3l+JOPPPIoFllFMmMWM0w26UsvvEwJYCoGjSIKxx2H0jHHDK3CipakuKWKKoeoUMIGiOFQxgotbwBaGY5xsEHLHFjAQQsngBbnBRS40AGfGNgBg6AvkJBDJrGdAMMJHaDAtB0swODCri0MYUQhkpJH3B5QMGJXEojQ4Ycd6Dn/2luqe2TSqSCF9Jb2rNOFYeuce6A3SCaSRAeFIII4eoRvsZLXa6pnMOJHHpOAEp97t0AbLSzy1aILMeFGU01J9NTjeT2h21PP6KW/e88+qKNuTzvreMiOOuvwpA1PtU9z8FJCLbW7NQDvG7DBud/oVVJENdVTU9NI8wzzzzDDkYLF9FIxt69M5BDHoWgPsvahcKK9J6F4Mr4nITO00CqnrLKlKato4ocWMqyQlwkRjLBCDnVuUFjLLZiAs5t2ZgETtClRLhjU1VBAAhLUBmmegcJlWEAoonWNMCYIVgtWwClEDGI3LziDHUhjKyVIghFvIEKpiECeMqQKVY+KVa+S/+UoQZwhCZ3oRB3OACgiFOI5vzmPHZ5DhLhNRzDEoVUZllWFOUgCFE7khCYsQYkpTkITqgDGMYiBjGd0I3SiIx0Y3XWPd5HRHvQ4o0lK4o2njISNM0LKG6HyO5+80WBACZJU8oi8a/gIeUtRWJGc9zyOGMMYxRiGLy6Ci0UeyHoFiohBQCbJ7HUPLuS7ZPjKJwryaUkVphjFW+7gAb6w4GgXsAALGMWyEoyAAiao081KwKY3jcACIzCBCTqAAQp0gASpOYEIrpZAF4jgAiLA1J5Y4ILYsMAELTjDcTIBC0Ic4hCDaEEZfiGJFhQiE2dQQiH09qrbCGI3QzhnJOR2m/9HqVBWR6jVIBghiT2YB4XESlsnBtHDexoHcLPJzsuMUIY9UFMP1DzEHMpZKz9YIhbIQEYynpENz5nEG+JIxzkseq/iEWUr3fioVapilZGQtKQlTYdJRZIUNtJRJGv8UVOWIg1oNM95HFFG9BBZMUUusnqN/GmBHhlJ8y3EY5TsHvgwWT6lhmIUq+CSJoCgghWsIE9R4wAFVjACNtVpBB3gap1K8CY2kbUFSpNMB0bgGhcQk1B7QsEBT0CESLC1lFc4gQlWYIIXZOI7v7DisyixgkIggjSFkMScuvkcR+2BEWW4AQ6CaIc9XOcItBHcFei5h0jUqlfACYMRMvGJPcD/QhKZ6IQgrkOeXdHtCNGJFT07yEFAxaoQg7ADIiqximUkKUnRoAaPlqKNbPBxX8N7io+6AdOs0EgrW4EKSKvy3LAAkqaCvKnEoqegQh4SSt79biIvIt6e9pQW5jXvgQJEoIOgohRF9RhSK7kJTnBiE/OFS36mha3+SA4WntCCAzTQzBWwgAMnwMHO3HSBtPLSmB24QIFHsD9bFphNfOrACaAANdnkgFAJFBRqcMAnzEDhgGw9wRUyEQZE+OEQjPgEKIawAoHWIQyEqIMgOhGJQXzTCEPYQ3KqM9k9DMJRgxjOCom8hyugajaTXTEl4CkJSQAqE4EDFGb/1sPoFOfK/+G8bdwG4YhTEMMYEE1Gg9LcPGg8SGEKE4tXxAJnHz2XK12R81gCaVNCGjKnw/gzoAP95z5z95B/9u6TKDY98fJ0SrWgRS0i/QpXCKjSAjrfxrgH30lyrFqrqM/IXGGLWNwCFFnQwP60asE8scBNHUgrC0TgVkK5ADQEHEEOqtqCCwjOqyw4wQROcAIUEJtPKnTNCVygTBGgAGpsLXGyXVCDGuCgBb26mhEGEQZK3OoJIPymEqrz2D2AJ5wg7I15MmvbTLitE7xBYWb3AKwyNLFWtj2yHQRR5GQRLjqU2NXbCsEIzsoqVoeYBCqCMYxCGmNJaX74w2sKjSIVqRrUkP9zVuRMjY1TPEkNkhgx/Bxo7wo6GCZXuKAFraCFN3zlf36SyaGki17ooua5yEWkcy4LnfvHP/dhxSpGth+gI+QUpyiI0UkByo4xRBSjOIW1PBn0WcDCFEvwwMxwdr9Vu+AEAUzUg4UtAtDgjAMugNktc2C1wRRGMjDYDAziHvfaxObEyux6rHMQhBzw/QXIeVqzh9MJxMozN3XADbjPUIa+CoIRtZrsq3wTTkp0QjWCiMRwTgNOWICiDlP2sd6ORR61ISuIO1bsqgAF5kgQohKu0AXLH7qk2S9pGctIBsQaZHuI057hhoZSLxQ9PV3kItG+gPnJD52RlA+DGMQIdPL//+x8QzKj4X1+vpOc9KSacz8XuOD5znt+n58PfT/6KX/QBXL0oy+ES6ZAhStUsQqUOfFZoHDDyjRAQBMQJgegCc0RbFVancAIABMKCJtXzYyi4EwHVNv/EaAFYBiziYBswAAGnICgEAZhDJuyCdsyuUAQYAoMsAAKaAoU4MCyKAHXQEEOLEsd5JALJhEimFvayEp5CAK9SUK4gcInLEcL3krc7EYksJBvTAesWJl0TBbf6Nu9BZHAXRkiEIImrIIs+IIWPRQWPhTDOZ+TAJ/FTMl5pVcrnBcZmlek3Vz36cIunJzCmRzzvaGhOV+ZlRntVZ8vFAPI/ZkwxNwu9KHN/5VXGdKCLAji+fHH0NUHliRElsxf0BndKaCCQBRd+5EC+4DCDWlCJ/CAB2hADeyPzoCGHRjB/4zGzNySVkkQhrGVhG1VzGjgBvLJCGDKZugS0ZCgrBEbYawVDgTO1YzAAbGAMuWAa/CdHdTACyjBGXxKEATBbqhKrXxTGYRBEi1LORERDr5gHZSBEdTKcrzKGTDHEZQBbpXB10AKbsQKevTKIKTTZMXNrugToGAZInTCe+SCL/QhMOQjzglipQmVQQRVpY1fz51hztVCLnAf95HcGy5k8zGc9THJkjgk9qHc9kWJPRIfIAbigVCaehFIR15PKRwdJJVCKrTCK9DCQf/qgi3MgioAQh7sgAzIgAaUAAhIgAZYQARcwAkQmNmF0Aq4wAZMwM3sz/0Q4AFu1f/VGq7hwKv5TAGi0AFdhgiMwJ7Imp90AN+dgGEMh9WMIJ+4AHDwCRRszQt83nkQQZQRWXVoxwvejR3UwTvRzRUk0UAZQRh8Sg4ci0CFwWSlDbzx3REUAlwSTr6NXtwEDqfsCpbt0yBoQrRgSyvYR4AoYiskYkIISFBNRGSOX300khku0s153yJdBHhNT/CBF5Qwn3ZtlzH8VjKMXGoKH/H9IRmCoRhm5kQAyIHQwmj2Ah0+zG9hAzd8FDcUJzdQgzOQgg54QAY0QAMswAREAE7/WsAE7IwR8EULHApVbRV3UlUNsBUMsEkH4BJhFJgL2EFhxJ2wcQDfUaAISMZlaOCreYYL3FJdZRgJXo0LXAFwDMcQ3EASMMttBAEUZEI2UpaPbUcOlUE6gdCjIBE95dOnQAphqgo0MRlt9Ody5Ntw9EoN+kok6Ju+pZM+eZnAWdHIbCZHaiZIkiRJZgxuBogYWpoY7iZvgiF58ULNmSbFoGZqppzL5RQ1cAMzAFoinWZ4MdoXopeNUglv8sKfFUPDaY5YDOdHiZQ3nBE9XClWYMNvUYOSjAImOIIHVIAEOMACRMAJOIB0RkAEOID/4IkLaNUGEBBoAKMvAhMxESBV/5UBDtwSisVGpsTaW9UGhjnbegrbhv2aVn5lApVgEPiK3yFCJjCRJFiWHYRBHQiUQK3KC+7BJ3yC4hELCuVAGZTBJ8CCIPzY10gH28AGFLjK6NnBJ4TorpDjHtiWbbnjOtpWOrljJHTCIViCKlBaRVAPeVnEeCkrL9ACbpakRwrIT8noSZ4XeYWmLviotoKXkV5EMIxFM/zZTiWpkkaPMYDLM2BDVkyIlrarSV3pjoiFNVTDNAQJSmVFNLxmK6CCKWhCG9RkBEAAs01nzNzMXSDGra2ABaSarS0YYbiACbAAXmpgxIqYeqrisEFN3E0lCHIG02SCCZzAC5BGss2Ga//IXQ4UwhDMgCT8wi/UASVECgzUASJoY7gNnmx9AiIowSAIgmX5xqnSEwu1I3/+DYWu43N4qK/Uga/8hSBIwjzC06+q3iDUAWFdHiIcAiBcQi5ohJQmw2qG7WpejEc2kkma5E+V4ZQs0o1eBEKa5k7xQsV4l5KS5qFBqTH4QpMcEnedK4N4xLhkQze0K+Gai1UMVza4mZvxjsLU6+5IBXKFRb4Owys0lSdwwiHIJARAQASaHVW1jDP5Tw1wwCneD2nwn1dZQKKYYiZcgS0VxmYMxmUQoKx5lS8SAVzBQBBwRmEcQSYoEw6gCmtQSmpAwe5+ShjcwBT4wTHAwhwMwQv/uICmquDdcCPivdNtzUbhXEEYEJY45mohnAevDAfSGgvppU2BZgIiMIKo5Ns+RUfcdAIoHEInOB5DYQIm4MIdKkOhia3/EoMvgGEg8iaTVuuN5uhFVAzcTo/w1S1GLN+3gAszFEMphIKzhgIuMINIaSlK2VniSgMIW1dNiYs1gPBMMc9HVMO8KkzGKQxZeGkzIIMvtEIobML4RFENSAAGLAAGRMAGwIYFSEAJzOQr4YmFaRWdmp3PaMYILEoh4ECdFtjaKVABggYMHAEwwoBa8V8u4VoOLAYu1QBZukZ5hGLwlgEiIEIdmJBjXqffneqt3A0KCkIdWAcyIuNsWBY5/9qBlQlcefSsq6ZNYjqKowSyowRLruZqlMFjkeGWKjjRL2SCPIFCJWAwL0jpRoSteJGreHnfAeeCtTJrTzmweAXfTpnyHWqX3zYICjPFhKCUuTwDL6TCJVvMMDCDVuzONCiPNOyyCZswcLEZm43wmokwmwGXC5MFTSFJMgSDLtTCWnjCKKCMKkxCCUhAwFoABDjAYXAAqtVJnP7pqmkg6Y7np+AS6qYSMPqM1MAaAarVCJSHMALjT4pAOt3F/ATOyCoTEYgWDpbBXwwBDtSBHsTBD9QAZL3THtSvEtgKNB2BCqpKGJzB1/gGItDTEHQCJfCGa/GnCkkWdvRGweVbJP8MgWRFwjGM1j4BCqd8AuU10S90wiTwwSW8gpJqpPWkLZW8Qs8NpM2FZi4oKZJmBGui6zPU61SkUTq0a4VYSAdrgzjQUTUoQzL8LTQojDX48kw9CIRk9fIQM1g3D+9xl071AtkaRCsEHUGYgiiQAspIgkye6QJAZ9nZqf9ooP+V4oIlWzHFCdZU1a0ZBv7AgAlISmegwKt8CgsIY2DiQGH7hhHgxhzUQBhIQicch9qlhkZvVicwh13uwRxUwY+dAY19wiA0tB3ccdxENJAl4Y6tihKwb67AI3+6FrEMB2slYRJSh6yAwjFQAq9yx64IAgcNAiwcQycoAiAAAkUw2k//3Qd9uAKTmmGk3ahoWkTwRamUMkg0iMWVZukZeZEXWUg9mERGkZQ2gIN6g4NPrDdSdAM3wBk2fJSE7LLiKkwIWxdNpRn/9tndMlJQOcTGvFdbUyIpOB0owYImpMBMTgAMoKkDaN0IuOkrlSJosMlWXQAGUGVa7YylsBUubePQSNBiE5sIfA1wlOwV7KLPWgoOyK8RyBMiGEEL8OcJHEEap4ogkIbv1q+BDkF1KMGtQJOq1DENWccZnIGmpsoR+DglXLRDhxOxGFkhLEsi88oMMZYg/NsMxqOILqZwm1bPHkIjlIKyQkkB2+hPneSZb5dVfwS7Fi7hppFJkZRSq5FF/5XDOWTUvZyDOmSUhHQFNwSucmnFjvBIwxjJ8zDJIfHUTmOMUKUCQjjEKQh4pomP0rU1xxCEJngBCFxzBBQTTr7pBbAVBmQdYRDlXo8dBugShvMMXhBQaOFAY7xAsr0AClwAZbSG2jUxaQSRMd4WPSZBFTCCQNeA4MAAZ6FKYL6KIHyCJOiQDtZAthU5CF2H1SZeM5p0HXQQKKzvRWvq4eUb3eQQFJzBawnOrLgW1HaCrAD0cJueYoaTl7XeJizS8lVMAZsXGhLDMlxcnGupeIsOPUDXGj1XT9yLONRZG7nUSJTEnu/5SIjDOVD8GilXfGPDuIzLNHjEnvl3eJGX2V5a2keW5L6mdUIYXdG5F6dp0iXQQFjFyea6aZsKrFfJkrLlmmY42IN1AAXc0qpV213UAHmKLJ8QLwUo09WImBHw3ReTxgtwB0LXgDg2vdODtjQ6ynnsytacQSZ0UEAAADs=", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# choose the dataset path in the dropdown on the right and rerun this cell\n", + "# to see multiple samples\n", + "\n", + "dataset = \"fractal20220817_data\" # @param ['fractal20220817_data', 'kuka', 'bridge', 'taco_play', 'jaco_play', 'berkeley_cable_routing', 'roboturk', 'nyu_door_opening_surprising_effectiveness', 'viola', 'berkeley_autolab_ur5', 'toto', 'language_table', 'columbia_cairlab_pusht_real', 'stanford_kuka_multimodal_dataset_converted_externally_to_rlds', 'nyu_rot_dataset_converted_externally_to_rlds', 'stanford_hydra_dataset_converted_externally_to_rlds', 'austin_buds_dataset_converted_externally_to_rlds', 'nyu_franka_play_dataset_converted_externally_to_rlds', 'maniskill_dataset_converted_externally_to_rlds', 'furniture_bench_dataset_converted_externally_to_rlds', 'cmu_franka_exploration_dataset_converted_externally_to_rlds', 'ucsd_kitchen_dataset_converted_externally_to_rlds', 'ucsd_pick_and_place_dataset_converted_externally_to_rlds', 'austin_sailor_dataset_converted_externally_to_rlds', 'austin_sirius_dataset_converted_externally_to_rlds', 'bc_z', 'usc_cloth_sim_converted_externally_to_rlds', 'utokyo_pr2_opening_fridge_converted_externally_to_rlds', 'utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds', 'utokyo_saytap_converted_externally_to_rlds', 'utokyo_xarm_pick_and_place_converted_externally_to_rlds', 'utokyo_xarm_bimanual_converted_externally_to_rlds', 'robo_net', 'berkeley_mvp_converted_externally_to_rlds', 'berkeley_rpt_converted_externally_to_rlds', 'kaist_nonprehensile_converted_externally_to_rlds', 'stanford_mask_vit_converted_externally_to_rlds', 'tokyo_u_lsmo_converted_externally_to_rlds', 'dlr_sara_pour_converted_externally_to_rlds', 'dlr_sara_grid_clamp_converted_externally_to_rlds', 'dlr_edan_shared_control_converted_externally_to_rlds', 'asu_table_top_converted_externally_to_rlds', 'stanford_robocook_converted_externally_to_rlds', 'eth_agent_affordances', 'imperialcollege_sawyer_wrist_cam', 'iamlab_cmu_pickup_insert_converted_externally_to_rlds', 'uiuc_d3field', 'utaustin_mutex', 'berkeley_fanuc_manipulation', 'cmu_food_manipulation', 'cmu_play_fusion', 'cmu_stretch', 'berkeley_gnm_recon', 'berkeley_gnm_cory_hall', 'berkeley_gnm_sac_son']\n", + "display_key = \"image\"\n", + "\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "if display_key not in b.info.features[\"steps\"][\"observation\"]:\n", + " raise ValueError(\n", + " f\"The key {display_key} was not found in this dataset.\\n\"\n", + " + \"Please choose a different image key to display for this dataset.\\n\"\n", + " + \"Here is the observation spec:\\n\"\n", + " + str(b.info.features[\"steps\"][\"observation\"])\n", + " )\n", + "\n", + "ds = b.as_dataset(split=\"train[:10]\").shuffle(10) # take only first 10 episodes\n", + "episode = next(iter(ds))\n", + "images = [step[\"observation\"][display_key] for step in episode[\"steps\"]]\n", + "images = [Image.fromarray(image.numpy()) for image in images]\n", + "display.Image(as_gif(images))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YrD4_8P9JxBw", + "outputId": "6c4bcf5f-b738-472c-d084-9c87f56962c8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('action', {'base_displacement_vector': , 'base_displacement_vertical_rotation': , 'gripper_closedness_action': , 'rotation_delta': , 'terminate_episode': , 'world_vector': })\n", + "('is_first', )\n", + "('is_last', )\n", + "('is_terminal', )\n", + "('observation', {'base_pose_tool_reached': , 'gripper_closed': , 'gripper_closedness_commanded': , 'height_to_bottom': , 'image': , 'natural_language_embedding': , 'natural_language_instruction': , 'orientation_box': , 'orientation_start': , 'robot_orientation_positions_box': , 'rotation_delta_to_go': , 'src_rotation': , 'vector_to_go': , 'workspace_bounds': })\n", + "('reward', )\n" + ] + } + ], + "source": [ + "# other elements of the episode step --> this may vary for each dataset\n", + "for elem in next(iter(episode[\"steps\"])).items():\n", + " print(elem)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-WHN-2OrKqGo" + }, + "source": [ + "# Download Datasets\n", + "\n", + "All datasets can be downloaded simply via `tfds.load()`.\n", + "Below we provide a script that downloads all datasets into `~/tensorflow_datasets` on your local machine. Simply copy the code and run it on your local machine to download the full dataset (XXX TB).\n", + "\n", + "If you want to filter the dataset before download, please refer to\n", + "[this Google Sheet](https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit?usp=sharing). It allows you\n", + "to filter the data by attributes like robot model, number of cameras, type of tasks etc. You can then download only the filtered datasets by pasting the\n", + "dataset list from the spreadsheet into the code below.\n", + "\n", + "The download code will automatically skip any datasets you have previously downloaded." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 617 + }, + "id": "wcsQuLjY7c0o", + "outputId": "43f99670-13d6-4ecc-f58f-263960681bed" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: tfds-nightly in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (4.9.3.dev202310060044)\n", + "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.4.0)\n", + "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.5.0)\n", + "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (8.1.7)\n", + "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.1.8)\n", + "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (1.5.2)\n", + "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.25.0)\n", + "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3)\n", + "Requirement already satisfied: protobuf>=3.20 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (3.20.3)\n", + "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (5.9.0)\n", + "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.29.0)\n", + "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.0)\n", + "Requirement already satisfied: termcolor in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3.0)\n", + "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.10.2)\n", + "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (4.65.0)\n", + "Requirement already satisfied: wrapt in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.1)\n", + "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (2023.9.2)\n", + "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (6.1.1)\n", + "Requirement already satisfied: typing_extensions in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (4.6.3)\n", + "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (3.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2023.5.7)\n", + "Requirement already satisfied: six in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from promise->tfds-nightly) (1.16.0)\n", + "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tfds-nightly) (1.61.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install tfds-nightly # to get most up-to-date registered datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "XtNplr0AP-ZH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading 2 datasets to ~/tensorflow_datasets.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:07<00:00, 3.67s/it]\n" + ] + } + ], + "source": [ + "import tensorflow_datasets as tfds\n", + "import tqdm\n", + "\n", + "# optionally replace the DATASET_NAMES below with the list of filtered datasets from the google sheet\n", + "DATASET_NAMES = [\n", + " \"fractal20220817_data\",\n", + " \"kuka\",\n", + " \"bridge\",\n", + " \"taco_play\",\n", + " \"jaco_play\",\n", + " \"berkeley_cable_routing\",\n", + " \"roboturk\",\n", + " \"nyu_door_opening_surprising_effectiveness\",\n", + " \"viola\",\n", + " \"berkeley_autolab_ur5\",\n", + " \"toto\",\n", + " \"language_table\",\n", + " \"columbia_cairlab_pusht_real\",\n", + " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", + " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", + " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", + " \"austin_buds_dataset_converted_externally_to_rlds\",\n", + " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", + " \"maniskill_dataset_converted_externally_to_rlds\",\n", + " \"furniture_bench_dataset_converted_externally_to_rlds\",\n", + " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", + " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", + " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", + " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", + " \"bc_z\",\n", + " \"usc_cloth_sim_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", + " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", + " \"utokyo_saytap_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", + " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", + " \"robo_net\",\n", + " \"berkeley_mvp_converted_externally_to_rlds\",\n", + " \"berkeley_rpt_converted_externally_to_rlds\",\n", + " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", + " \"stanford_mask_vit_converted_externally_to_rlds\",\n", + " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", + " \"dlr_sara_pour_converted_externally_to_rlds\",\n", + " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", + " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", + " \"asu_table_top_converted_externally_to_rlds\",\n", + " \"stanford_robocook_converted_externally_to_rlds\",\n", + " \"eth_agent_affordances\",\n", + " \"imperialcollege_sawyer_wrist_cam\",\n", + " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", + " \"uiuc_d3field\",\n", + " \"utaustin_mutex\",\n", + " \"berkeley_fanuc_manipulation\",\n", + " \"cmu_food_manipulation\",\n", + " \"cmu_play_fusion\",\n", + " \"cmu_stretch\",\n", + " \"berkeley_gnm_recon\",\n", + " \"berkeley_gnm_cory_hall\",\n", + " \"berkeley_gnm_sac_son\",\n", + "]\n", + "DATASET_NAMES = [\"fractal20220817_data\", \"bc_z\"]\n", + "DOWNLOAD_DIR = \"~/tensorflow_datasets\"\n", + "\n", + "print(f\"Downloading {len(DATASET_NAMES)} datasets to {DOWNLOAD_DIR}.\")\n", + "for dataset_name in tqdm.tqdm(DATASET_NAMES):\n", + " b = tfds.builder_from_directory(builder_dir=dataset2path(dataset_name))\n", + " b.download_and_prepare(download_dir=DOWNLOAD_DIR)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IyccDsRqwtMz" + }, + "source": [ + "# Data Loader Example\n", + "\n", + "Below, we demonstrate a simple example of how to load the dataset into training batches, where each sample in the batch only contains one step." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "X17VECdRwzka" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow_datasets as tfds\n", + "\n", + "# load raw dataset --> replace this with tfds.load() on your\n", + "# local machine!\n", + "dataset = \"fractal20220817_data\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds = b.as_dataset(split=\"train[:10]\")\n", + "\n", + "\n", + "def episode2steps(episode):\n", + " return episode[\"steps\"]\n", + "\n", + "\n", + "def step_map_fn(step):\n", + " return {\n", + " \"observation\": {\n", + " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", + " },\n", + " \"action\": tf.concat(\n", + " [\n", + " step[\"action\"][\"world_vector\"],\n", + " step[\"action\"][\"rotation_delta\"],\n", + " step[\"action\"][\"gripper_closedness_action\"],\n", + " ],\n", + " axis=-1,\n", + " ),\n", + " }\n", + "\n", + "\n", + "# convert RLDS episode dataset to individual steps & reformat\n", + "ds = ds.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", + "ds = ds.map(step_map_fn, num_parallel_calls=tf.data.AUTOTUNE)\n", + "\n", + "# shuffle, repeat, pre-fetch, batch\n", + "ds = ds.cache() # optionally keep full dataset in memory\n", + "ds = ds.shuffle(100) # set shuffle buffer size\n", + "ds = ds.repeat() # ensure that data never runs out" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t0uJH3X6w1LZ", + "outputId": "a42005e8-1072-4203-e6ba-b56784971175" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0it [00:00, ?it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "10000it [00:05, 1955.09it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "for i, batch in tqdm.tqdm(enumerate(ds.prefetch(3).batch(4).as_numpy_iterator())):\n", + " # here you would add your Jax / PyTorch training code\n", + " if i == 10000:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ekmsGRAnw3Bp" + }, + "source": [ + "# Interleave Multiple Datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "CslwEuBZwmLP" + }, + "outputs": [], + "source": [ + "# Load second dataset --> replace this with tfds.load() on your\n", + "# local machine!\n", + "dataset = \"bc_z\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds2 = b.as_dataset(split=\"train[:10]\")\n", + "\n", + "\n", + "def step_map_fn_mutex(step):\n", + " # reformat to align specs of both datasets\n", + " return {\n", + " \"observation\": {\n", + " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", + " },\n", + " \"action\": tf.random.uniform(shape=(7,), dtype=tf.float32, name=None),\n", + " }\n", + "\n", + "\n", + "ds2 = ds2.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", + "ds2 = ds2.map(step_map_fn_mutex, num_parallel_calls=tf.data.AUTOTUNE)\n", + "\n", + "# shuffle, repeat, pre-fetch, batch\n", + "ds2 = ds2.cache() # optionally keep full dataset in memory\n", + "ds2 = ds2.shuffle(100) # set shuffle buffer size\n", + "ds2 = ds2.repeat() # ensure that data never runs out" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "G2hcCJd8w6-D" + }, + "outputs": [], + "source": [ + "# interleave datasets w/ equal sampling weight\n", + "ds_combined = tf.data.Dataset.sample_from_datasets([ds, ds2], [0.5, 0.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hEnVFP9nw8iI", + "outputId": "68567be3-9c3b-46c2-d569-f999c900f03c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "10000it [00:06, 1546.22it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "for i, batch in tqdm.tqdm(\n", + " enumerate(ds_combined.prefetch(3).batch(4).as_numpy_iterator())\n", + "):\n", + " # here you would add your Jax / PyTorch training code\n", + " if i == 10000:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aew258oUbamg" + }, + "source": [ + "# Example Dataloader to produce trajectories\n", + "\n", + "When training transformers, we usually use trajectories of fix-length as input into the transformers. This is to enable the transformer to condition on a fixed window of history when predicting actions.\n", + "\n", + "Below we demonstrate how one can load the TFDS datasets, transform the episodes\n", + "into fixed-length \"trajectories\" and mix multiple datasets by aligning their specs." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "YU0qKdrp7oBT" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: rlds[tensorflow] in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (0.1.8)\n", + "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.4.0)\n", + "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.25.0)\n", + "Requirement already satisfied: tensorflow in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: tensorflow-datasets in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (4.9.3)\n", + "Requirement already satisfied: dm-reverb in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (0.13.0)\n", + "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (0.1.8)\n", + "Requirement already satisfied: portpicker in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (1.6.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=23.5.26 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.5.26)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.5.4)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", + "Requirement already satisfied: h5py>=2.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.10.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (16.0.6)\n", + "Requirement already satisfied: ml-dtypes==0.2.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.3.0)\n", + "Requirement already satisfied: packaging in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.0)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.20.3)\n", + "Requirement already satisfied: setuptools in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (67.8.0)\n", + "Requirement already satisfied: six>=1.12.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.16.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.3.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (4.6.3)\n", + "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.14.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.34.0)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.59.2)\n", + "Requirement already satisfied: tensorboard<2.15,>=2.14 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.1)\n", + "Requirement already satisfied: tensorflow-estimator<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: keras<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", + "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.5.0)\n", + "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (8.1.7)\n", + "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (1.5.2)\n", + "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.3)\n", + "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (5.9.0)\n", + "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.29.0)\n", + "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (1.14.0)\n", + "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.10.2)\n", + "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (4.65.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow->rlds[tensorflow]) (0.38.4)\n", + "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (2023.9.2)\n", + "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (6.1.1)\n", + "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (3.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2023.5.7)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.23.4)\n", + "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.0.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.5.1)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.0.1)\n", + "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tensorflow-datasets->rlds[tensorflow]) (1.61.0)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (5.3.2)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.3.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (4.9)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.3.1)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.1.1)\n", + "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.5.0)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.2.2)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install rlds[tensorflow]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "N3b5BEt1JvQJ" + }, + "outputs": [], + "source": [ + "from typing import Any, Dict, Union, NamedTuple\n", + "\n", + "import numpy as np\n", + "import tensorflow_datasets as tfds\n", + "import rlds\n", + "import reverb\n", + "from rlds import transformations\n", + "import tensorflow_datasets as tfds\n", + "import tree\n", + "\n", + "import abc\n", + "import dataclasses\n", + "from typing import Dict, Optional\n", + "\n", + "from rlds import rlds_types\n", + "import tensorflow as tf\n", + "from PIL import Image\n", + "from IPython import display" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "cellView": "form", + "id": "Dgf1OxIhJwib" + }, + "outputs": [], + "source": [ + "# @title Transformation definitions\n", + "\n", + "\n", + "def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec:\n", + " \"\"\"Converts a tfds Feature into a TensorSpec.\"\"\"\n", + "\n", + " def _get_feature_spec(nested_feature: tfds.features.FeatureConnector):\n", + " if isinstance(nested_feature, tf.DType):\n", + " return tf.TensorSpec(shape=(), dtype=nested_feature)\n", + " else:\n", + " return nested_feature.get_tensor_spec()\n", + "\n", + " # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to\n", + " # make sure we deal with the nested structure.\n", + " return tf.nest.map_structure(_get_feature_spec, feature)\n", + "\n", + "\n", + "def _encoded_feature(\n", + " feature: Optional[tfds.features.FeatureConnector],\n", + " image_encoding: Optional[str],\n", + " tensor_encoding: Optional[tfds.features.Encoding],\n", + "):\n", + " \"\"\"Adds encoding to Images and/or Tensors.\"\"\"\n", + "\n", + " def _apply_encoding(\n", + " feature: tfds.features.FeatureConnector,\n", + " image_encoding: Optional[str],\n", + " tensor_encoding: Optional[tfds.features.Encoding],\n", + " ):\n", + " if image_encoding and isinstance(feature, tfds.features.Image):\n", + " return tfds.features.Image(\n", + " shape=feature.shape,\n", + " dtype=feature.dtype,\n", + " use_colormap=feature.use_colormap,\n", + " encoding_format=image_encoding,\n", + " )\n", + " if (\n", + " tensor_encoding\n", + " and isinstance(feature, tfds.features.Tensor)\n", + " and feature.dtype != tf.string\n", + " ):\n", + " return tfds.features.Tensor(\n", + " shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding\n", + " )\n", + " return feature\n", + "\n", + " if not feature:\n", + " return None\n", + " return tf.nest.map_structure(\n", + " lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature\n", + " )\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class RLDSSpec(metaclass=abc.ABCMeta):\n", + " \"\"\"Specification of an RLDS Dataset.\n", + "\n", + " It is used to hold a spec that can be converted into a TFDS DatasetInfo or\n", + " a `tf.data.Dataset` spec.\n", + " \"\"\"\n", + "\n", + " observation_info: Optional[tfds.features.FeatureConnector] = None\n", + " action_info: Optional[tfds.features.FeatureConnector] = None\n", + " reward_info: Optional[tfds.features.FeatureConnector] = None\n", + " discount_info: Optional[tfds.features.FeatureConnector] = None\n", + " step_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", + " episode_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", + "\n", + " def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", + " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", + " step = {}\n", + " if self.observation_info:\n", + " step[rlds_types.OBSERVATION] = _features_to_tensor_spec(\n", + " self.observation_info\n", + " )\n", + " if self.action_info:\n", + " step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info)\n", + " if self.discount_info:\n", + " step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info)\n", + " if self.reward_info:\n", + " step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info)\n", + " if self.step_metadata_info:\n", + " for k, v in self.step_metadata_info.items():\n", + " step[k] = _features_to_tensor_spec(v)\n", + "\n", + " step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool)\n", + " step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool)\n", + " step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool)\n", + " return step\n", + "\n", + " def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", + " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", + " episode = {}\n", + " episode[rlds_types.STEPS] = tf.data.DatasetSpec(\n", + " element_spec=self.step_tensor_spec()\n", + " )\n", + " if self.episode_metadata_info:\n", + " for k, v in self.episode_metadata_info.items():\n", + " episode[k] = _features_to_tensor_spec(v)\n", + " return episode\n", + "\n", + " def to_dataset_config(\n", + " self,\n", + " name: str,\n", + " image_encoding: Optional[str] = None,\n", + " tensor_encoding: Optional[tfds.features.Encoding] = None,\n", + " citation: Optional[str] = None,\n", + " homepage: Optional[str] = None,\n", + " description: Optional[str] = None,\n", + " overall_description: Optional[str] = None,\n", + " ) -> tfds.rlds.rlds_base.DatasetConfig:\n", + " \"\"\"Obtains the DatasetConfig for TFDS from the Spec.\"\"\"\n", + " return tfds.rlds.rlds_base.DatasetConfig(\n", + " name=name,\n", + " description=description,\n", + " overall_description=overall_description,\n", + " homepage=homepage,\n", + " citation=citation,\n", + " observation_info=_encoded_feature(\n", + " self.observation_info, image_encoding, tensor_encoding\n", + " ),\n", + " action_info=_encoded_feature(\n", + " self.action_info, image_encoding, tensor_encoding\n", + " ),\n", + " reward_info=_encoded_feature(\n", + " self.reward_info, image_encoding, tensor_encoding\n", + " ),\n", + " discount_info=_encoded_feature(\n", + " self.discount_info, image_encoding, tensor_encoding\n", + " ),\n", + " step_metadata_info=_encoded_feature(\n", + " self.step_metadata_info, image_encoding, tensor_encoding\n", + " ),\n", + " episode_metadata_info=_encoded_feature(\n", + " self.episode_metadata_info, image_encoding, tensor_encoding\n", + " ),\n", + " )\n", + "\n", + " def to_features_dict(self):\n", + " \"\"\"Returns a TFDS FeaturesDict representing the dataset config.\"\"\"\n", + " step_config = {\n", + " rlds_types.IS_FIRST: tf.bool,\n", + " rlds_types.IS_LAST: tf.bool,\n", + " rlds_types.IS_TERMINAL: tf.bool,\n", + " }\n", + "\n", + " if self.observation_info:\n", + " step_config[rlds_types.OBSERVATION] = self.observation_info\n", + " if self.action_info:\n", + " step_config[rlds_types.ACTION] = self.action_info\n", + " if self.discount_info:\n", + " step_config[rlds_types.DISCOUNT] = self.discount_info\n", + " if self.reward_info:\n", + " step_config[rlds_types.REWARD] = self.reward_info\n", + "\n", + " if self.step_metadata_info:\n", + " for k, v in self.step_metadata_info.items():\n", + " step_config[k] = v\n", + "\n", + " if self.episode_metadata_info:\n", + " return tfds.features.FeaturesDict(\n", + " {\n", + " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", + " **self.episode_metadata_info,\n", + " }\n", + " )\n", + " else:\n", + " return tfds.features.FeaturesDict(\n", + " {\n", + " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", + " }\n", + " )\n", + "\n", + "\n", + "RLDS_SPEC = RLDSSpec\n", + "TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]]\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class TrajectoryTransform(metaclass=abc.ABCMeta):\n", + " \"\"\"Specification the TrajectoryTransform applied to a dataset of episodes.\n", + "\n", + " A TrajectoryTransform is a set of rules transforming a dataset\n", + " of RLDS episodes to a dataset of trajectories.\n", + " This involves three distinct stages:\n", + " - An optional `episode_to_steps_map_fn(episode)` is called at the episode\n", + " level, and can be used to select or modify steps.\n", + " - Augmentation: an `episode_key` could be propagated to `steps` for\n", + " debugging.\n", + " - Selection: Particular steps can be selected.\n", + " - Stripping: Features can be removed from steps. Prefer using `step_map_fn`.\n", + " - An optional `step_map_fn` is called at the flattened steps dataset for each\n", + " step, and can be used to featurize a step, e.g. add/remove features, or\n", + " augument images\n", + " - A `pattern` leverages DM patterns to set a rule of slicing an episode to a\n", + " dataset of overlapping trajectories.\n", + "\n", + " Importantly, each TrajectoryTransform must define a `expected_tensor_spec`\n", + " which specifies a nested TensorSpec of the resulting dataset. This is what\n", + " this TrajectoryTransform will produce, and can be used as an interface with\n", + " a neural network.\n", + " \"\"\"\n", + "\n", + " episode_dataset_spec: RLDS_SPEC\n", + " episode_to_steps_fn_dataset_spec: RLDS_SPEC\n", + " steps_dataset_spec: Any\n", + " pattern: reverb.structured_writer.Pattern\n", + " episode_to_steps_map_fn: Any\n", + " expected_tensor_spec: TENSOR_SPEC\n", + " step_map_fn: Optional[Any] = None\n", + "\n", + " def get_for_cached_trajectory_transform(self):\n", + " \"\"\"Creates a copy of this traj transform to use with caching.\n", + "\n", + " The returned TrajectoryTransfrom copy will be initialized with the default\n", + " version of the `episode_to_steps_map_fn`, because the effect of that\n", + " function has already been materialized in the cached copy of the dataset.\n", + " Returns:\n", + " trajectory_transform: A copy of the TrajectoryTransform with overridden\n", + " `episode_to_steps_map_fn`.\n", + " \"\"\"\n", + " traj_copy = dataclasses.replace(self)\n", + " traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec\n", + " traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS]\n", + " return traj_copy\n", + "\n", + " def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset):\n", + " \"\"\"Applies this TrajectoryTransform to the dataset of episodes.\"\"\"\n", + "\n", + " # Convert the dataset of episodes to the dataset of steps.\n", + " steps_dataset = episodes_dataset.map(\n", + " self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE\n", + " ).flat_map(lambda x: x)\n", + "\n", + " return self._create_pattern_dataset(steps_dataset)\n", + "\n", + " def transform_steps_rlds_dataset(\n", + " self, steps_dataset: tf.data.Dataset\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Applies this TrajectoryTransform to the dataset of episode steps.\"\"\"\n", + "\n", + " return self._create_pattern_dataset(steps_dataset)\n", + "\n", + " def create_test_dataset(\n", + " self,\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Creates a test dataset of trajectories.\n", + "\n", + " It is guaranteed that the structure of this dataset will be the same as\n", + " when flowing real data. Hence this is a useful construct for tests or\n", + " initialization of JAX models.\n", + " Returns:\n", + " dataset: A test dataset made of zeros structurally identical to the\n", + " target dataset of trajectories.\n", + " \"\"\"\n", + " zeros = transformations.zeros_from_spec(self.expected_tensor_spec)\n", + "\n", + " return tf.data.Dataset.from_tensors(zeros)\n", + "\n", + " def _create_pattern_dataset(\n", + " self, steps_dataset: tf.data.Dataset\n", + " ) -> tf.data.Dataset:\n", + " \"\"\"Create PatternDataset from the `steps_dataset`.\"\"\"\n", + " config = create_structured_writer_config(\"temp\", self.pattern)\n", + "\n", + " # Further transform each step if the `step_map_fn` is provided.\n", + " if self.step_map_fn:\n", + " steps_dataset = steps_dataset.map(self.step_map_fn)\n", + " pattern_dataset = reverb.PatternDataset(\n", + " input_dataset=steps_dataset,\n", + " configs=[config],\n", + " respect_episode_boundaries=True,\n", + " is_end_of_episode=lambda x: x[rlds_types.IS_LAST],\n", + " )\n", + " return pattern_dataset\n", + "\n", + "\n", + "class TrajectoryTransformBuilder(object):\n", + " \"\"\"Facilitates creation of the `TrajectoryTransform`.\"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dataset_spec: RLDS_SPEC,\n", + " episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS],\n", + " step_map_fn=None,\n", + " pattern_fn=None,\n", + " expected_tensor_spec=None,\n", + " ):\n", + " self._rds_dataset_spec = dataset_spec\n", + " self._steps_spec = None\n", + " self._episode_to_steps_map_fn = episode_to_steps_map_fn\n", + " self._step_map_fn = step_map_fn\n", + " self._pattern_fn = pattern_fn\n", + " self._expected_tensor_spec = expected_tensor_spec\n", + "\n", + " def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform:\n", + " \"\"\"Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.\"\"\"\n", + "\n", + " if validate_expected_tensor_spec and self._expected_tensor_spec is None:\n", + " raise ValueError(\"`expected_tensor_spec` must be set.\")\n", + "\n", + " episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec)\n", + "\n", + " steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn)\n", + "\n", + " episode_to_steps_fn_dataset_spec = self._rds_dataset_spec\n", + "\n", + " if self._step_map_fn is not None:\n", + " steps_ds = steps_ds.map(self._step_map_fn)\n", + "\n", + " zeros_spec = transformations.zeros_from_spec(\n", + " steps_ds.element_spec\n", + " ) # pytype: disable=wrong-arg-types\n", + "\n", + " ref_step = reverb.structured_writer.create_reference_step(zeros_spec)\n", + "\n", + " pattern = self._pattern_fn(ref_step)\n", + "\n", + " steps_ds_spec = steps_ds.element_spec\n", + "\n", + " target_tensor_structure = create_reverb_table_signature(\n", + " \"temp_table\", steps_ds_spec, pattern\n", + " )\n", + "\n", + " if (\n", + " validate_expected_tensor_spec\n", + " and self._expected_tensor_spec != target_tensor_structure\n", + " ):\n", + " raise RuntimeError(\n", + " \"The tensor spec of the TrajectoryTransform doesn't \"\n", + " \"match the expected spec.\\n\"\n", + " \"Expected:\\n%s\\nActual:\\n%s\\n\"\n", + " % (\n", + " str(self._expected_tensor_spec).replace(\n", + " \"TensorSpec\", \"tf.TensorSpec\"\n", + " ),\n", + " str(target_tensor_structure).replace(\"TensorSpec\", \"tf.TensorSpec\"),\n", + " )\n", + " )\n", + "\n", + " return TrajectoryTransform(\n", + " episode_dataset_spec=self._rds_dataset_spec,\n", + " episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec,\n", + " steps_dataset_spec=steps_ds_spec,\n", + " pattern=pattern,\n", + " episode_to_steps_map_fn=self._episode_to_steps_map_fn,\n", + " step_map_fn=self._step_map_fn,\n", + " expected_tensor_spec=target_tensor_structure,\n", + " )\n", + "\n", + "\n", + "def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC):\n", + " \"\"\"Creates a zero valued dataset of episodes for the given RLDS Spec.\"\"\"\n", + "\n", + " def add_steps(episode, step_spec):\n", + " episode[rlds_types.STEPS] = transformations.zero_dataset_like(\n", + " tf.data.DatasetSpec(step_spec)\n", + " )\n", + " if \"fake\" in episode:\n", + " del episode[\"fake\"]\n", + " return episode\n", + "\n", + " episode_without_steps_spec = {\n", + " k: v\n", + " for k, v in rlds_spec.episode_tensor_spec().items()\n", + " if k != rlds_types.STEPS\n", + " }\n", + "\n", + " if episode_without_steps_spec:\n", + " episodes_dataset = transformations.zero_dataset_like(\n", + " tf.data.DatasetSpec(episode_without_steps_spec)\n", + " )\n", + " else:\n", + " episodes_dataset = tf.data.Dataset.from_tensors({\"fake\": \"\"})\n", + "\n", + " episodes_dataset_with_steps = episodes_dataset.map(\n", + " lambda episode: add_steps(episode, rlds_spec.step_tensor_spec())\n", + " )\n", + " return episodes_dataset_with_steps\n", + "\n", + "\n", + "def create_reverb_table_signature(\n", + " table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern\n", + ") -> reverb.reverb_types.SpecNest:\n", + " config = create_structured_writer_config(table_name, pattern)\n", + " reverb_table_spec = reverb.structured_writer.infer_signature(\n", + " [config], steps_dataset_spec\n", + " )\n", + " return reverb_table_spec\n", + "\n", + "\n", + "def create_structured_writer_config(\n", + " table_name: str, pattern: reverb.structured_writer.Pattern\n", + ") -> Any:\n", + " config = reverb.structured_writer.create_config(\n", + " pattern=pattern, table=table_name, conditions=[]\n", + " )\n", + " return config\n", + "\n", + "\n", + "def n_step_pattern_builder(n: int) -> Any:\n", + " \"\"\"Creates trajectory of length `n` from all fields of a `ref_step`.\"\"\"\n", + "\n", + " def transform_fn(ref_step):\n", + " traj = {}\n", + " for key in ref_step:\n", + " if isinstance(ref_step[key], dict):\n", + " transformed_entry = tree.map_structure(\n", + " lambda ref_node: ref_node[-n:], ref_step[key]\n", + " )\n", + " traj[key] = transformed_entry\n", + " else:\n", + " traj[key] = ref_step[key][-n:]\n", + "\n", + " return traj\n", + "\n", + " return transform_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BK4RRYkbLN5B" + }, + "source": [ + "## Demonstration of transformation from an episode to a trajectory\n", + "\n", + "A real ML pipeline would rarely learn from a whole episode. Instead the input to a model is a _trajectory_. A `Trajectory` is a particular way to slice a sequence of episode steps. `SARSA` trajectory is one well known example, but a trajectory of an arbitrary length `n` is also an option. Often, a set of _overlapping_ trajectories is produced from an episode. For example, given the following episode steps:\n", + "\n", + "`episode=[s_0, s_1, s_2, s_3, s_4, s_T]`\n", + "\n", + "and a target Trajectory of length `3`, the following trajectories are produced:\n", + "\n", + "`t_1=[s_0, s_1, s_2]`\n", + "\n", + "`t_2=[s_1, s_2, s_3]`\n", + "\n", + "`t_3=[s_2, s_3, s_4]`\n", + "\n", + "`t_4=[s_3, s_4, s_T]`\n", + "\n", + "\n", + "To perform such a slicing, the dataset of episode is first \"flattened\" to the dataset of steps. The `is_last` attribute of an RLDS step allows proper slicing, not crossing the episode boundary. The `TrajectoryTransformBuilder` demonstrates this:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "id": "_NsYnqnpNgNl" + }, + "outputs": [], + "source": [ + "import tensorflow_datasets as tfds\n", + "\n", + "dataset = \"fractal20220817_data\"\n", + "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", + "ds = b.as_dataset(split=\"train[:10]\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "2qvMcpGDx6hJ" + }, + "outputs": [], + "source": [ + "# The RLDSSpec for the RT1 dataset.\n", + "rt1_spec = RLDSSpec(\n", + " observation_info=b.info.features[\"steps\"][\"observation\"],\n", + " action_info=b.info.features[\"steps\"][\"action\"],\n", + ")\n", + "\n", + "# The following will create a trajectories of length 3.\n", + "trajectory_length = 3\n", + "trajectory_transform = TrajectoryTransformBuilder(\n", + " rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length)\n", + ").build(validate_expected_tensor_spec=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "Fk4ZfC_bMBw3" + }, + "outputs": [], + "source": [ + "trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds)\n", + "\n", + "trajectory_iter = iter(trajectory_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "fSxk3zF_x0FS" + }, + "outputs": [], + "source": [ + "trajectory = next(trajectory_iter)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t2V0xrIVMWNc", + "outputId": "5c71d7ef-2fc7-424e-a8ae-0e1c60252f42" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'action': {'base_displacement_vector': ,\n", + " 'gripper_closedness_action': ,\n", + " 'world_vector': ,\n", + " 'rotation_delta': ,\n", + " 'base_displacement_vertical_rotation': ,\n", + " 'terminate_episode': },\n", + " 'is_first': ,\n", + " 'is_last': ,\n", + " 'observation': {'robot_orientation_positions_box': ,\n", + " 'workspace_bounds': ,\n", + " 'natural_language_instruction': ,\n", + " 'image': ,\n", + " 'src_rotation': ,\n", + " 'orientation_box': ,\n", + " 'height_to_bottom': ,\n", + " 'vector_to_go': ,\n", + " 'rotation_delta_to_go': ,\n", + " 'gripper_closedness_commanded': ,\n", + " 'orientation_start': ,\n", + " 'gripper_closed': ,\n", + " 'base_pose_tool_reached': ,\n", + " 'natural_language_embedding': },\n", + " 'is_terminal': }" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajectory" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ytrvi945NTZz", + "outputId": "50dd5318-7521-4d85-a1cf-42aa046ce4c3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "TensorShape([3, 256, 320, 3])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Note that the leading dimension (3) corresponds to the trajectory_length\n", + "trajectory[\"observation\"][\"image\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 529 + }, + "id": "xhDX3BcWNmrl", + "outputId": "0d4c3c74-7d71-45e3-baea-c5f119eea9a4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "episode = next(iter(ds))\n", + "\n", + "# Iterate over steps of the episode. Collect images.\n", + "images = [\n", + " trajectory[\"observation\"][\"image\"][id]\n", + " for id in range(trajectory[\"observation\"][\"image\"].shape[0])\n", + "]\n", + "images = [Image.fromarray(image.numpy()) for image in images]\n", + "\n", + "display.Image(as_gif(images))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oy89HzymQyAq" + }, + "source": [ + "## Combination of multiple datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "id": "qs0-7alaQ3C9" + }, + "outputs": [], + "source": [ + "import tensorflow_datasets as tfds\n", + "\n", + "robo_net_builder = tfds.builder_from_directory(\n", + " builder_dir=\"gs://gresearch/robotics/robo_net/1.0.0/\"\n", + ")\n", + "\n", + "robo_net_builder_episodic_dataset = robo_net_builder.as_dataset(split=\"train[:10]\")\n", + "episodes = list(iter(robo_net_builder_episodic_dataset))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "id": "2tgJpMqARIFQ" + }, + "outputs": [], + "source": [ + "# The following will create a trajectories of length 3.\n", + "trajectory_length = 3\n", + "\n", + "robo_net_rlds_spec = RLDSSpec(\n", + " observation_info=robo_net_builder.info.features[\"steps\"][\"observation\"],\n", + " action_info=robo_net_builder.info.features[\"steps\"][\"action\"],\n", + ")\n", + "\n", + "\n", + "def robo_net_step_map_fn(step):\n", + " transformed_step = {}\n", + " transformed_step[\"observation\"] = step[\"observation\"][\"image\"]\n", + " transformed_step[\"is_first\"] = step[\"is_first\"]\n", + " transformed_step[\"is_last\"] = step[\"is_last\"]\n", + " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", + " return transformed_step\n", + "\n", + "\n", + "robo_net_trajectory_transform = TrajectoryTransformBuilder(\n", + " robo_net_rlds_spec,\n", + " step_map_fn=robo_net_step_map_fn,\n", + " pattern_fn=n_step_pattern_builder(trajectory_length),\n", + ").build(validate_expected_tensor_spec=False)\n", + "\n", + "\n", + "def mt_opt_step_map_fn(step):\n", + " transformed_step = {}\n", + " transformed_step[\"observation\"] = tf.cast(\n", + " tf.image.resize(step[\"observation\"][\"image\"], [240, 320]), tf.uint8\n", + " ) # Resize to be compatible with robo_net trajectory\n", + " transformed_step[\"is_first\"] = step[\"is_first\"]\n", + " transformed_step[\"is_last\"] = step[\"is_last\"]\n", + " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", + " return transformed_step\n", + "\n", + "\n", + "mt_opt_trajectory_transform = TrajectoryTransformBuilder(\n", + " rt1_spec,\n", + " step_map_fn=mt_opt_step_map_fn,\n", + " pattern_fn=n_step_pattern_builder(trajectory_length),\n", + ").build(validate_expected_tensor_spec=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "id": "anGArTQbTiHj" + }, + "outputs": [], + "source": [ + "# Validate that the specs are equal\n", + "assert (\n", + " robo_net_trajectory_transform.expected_tensor_spec\n", + " == mt_opt_trajectory_transform.expected_tensor_spec\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "id": "L9gRx6BfTGH-" + }, + "outputs": [], + "source": [ + "# Create trajectory datasets for the two normalized representations:\n", + "robo_net_trajectory_dataset = (\n", + " robo_net_trajectory_transform.transform_episodic_rlds_dataset(\n", + " robo_net_builder_episodic_dataset\n", + " )\n", + ")\n", + "mt_opt_trajectory_dataset = mt_opt_trajectory_transform.transform_episodic_rlds_dataset(\n", + " ds\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "id": "-SVkHpIxRVXz" + }, + "outputs": [], + "source": [ + "combined_dataset = tf.data.Dataset.sample_from_datasets(\n", + " [robo_net_trajectory_dataset, mt_opt_trajectory_dataset]\n", + ")\n", + "combined_dataset = combined_dataset.batch(2)\n", + "combined_dataset_it = iter(combined_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "id": "-CMdwIcsR30k" + }, + "outputs": [], + "source": [ + "example = next(combined_dataset_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "w2YJOvRKUb2E", + "outputId": "31daf4b7-9350-4d05-9c57-d9784bc34d44" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# First element of the batch returns a robot_net trajectory\n", + "Image.fromarray(example[\"observation\"].numpy()[0][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "FP0iz-f_UoTY", + "outputId": "244fb34b-fa72-4c02-e432-8a0382f45b17" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Second element of the batch returns a mt_opt trajectory\n", + "Image.fromarray(example[\"observation\"].numpy()[1][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N2Efw2aHVfSX" + }, + "source": [ + "# Available datasets and their sizes:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kQkeUKyrVhGK", + "outputId": "a61cb54f-fd1e-41d0-858b-19d30659c8b1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset gs://gresearch/robotics/fractal20220817_data/0.1.0 has size 111.07 GiB\n", + "Dataset gs://gresearch/robotics/kuka/0.1.0 has size 778.02 GiB\n", + "Dataset gs://gresearch/robotics/bridge/0.1.0 has size 387.49 GiB\n", + "Dataset gs://gresearch/robotics/taco_play/0.1.0 has size 47.77 GiB\n", + "Dataset gs://gresearch/robotics/jaco_play/0.1.0 has size 9.24 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_cable_routing/0.1.0 has size 4.67 GiB\n", + "Dataset gs://gresearch/robotics/roboturk/0.1.0 has size 45.39 GiB\n", + "Dataset gs://gresearch/robotics/nyu_door_opening_surprising_effectiveness/0.1.0 has size 7.12 GiB\n", + "Dataset gs://gresearch/robotics/viola/0.1.0 has size 10.40 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_autolab_ur5/0.1.0 has size 76.39 GiB\n", + "Dataset gs://gresearch/robotics/toto/0.1.0 has size 127.66 GiB\n", + "Dataset gs://gresearch/robotics/language_table/0.0.1 has size 399.23 GiB\n", + "Dataset gs://gresearch/robotics/columbia_cairlab_pusht_real/0.1.0 has size 2.80 GiB\n", + "Dataset gs://gresearch/robotics/stanford_kuka_multimodal_dataset_converted_externally_to_rlds/0.1.0 has size 31.98 GiB\n", + "Dataset gs://gresearch/robotics/nyu_rot_dataset_converted_externally_to_rlds/0.1.0 has size 5.33 MiB\n", + "Dataset gs://gresearch/robotics/stanford_hydra_dataset_converted_externally_to_rlds/0.1.0 has size 72.48 GiB\n", + "Dataset gs://gresearch/robotics/austin_buds_dataset_converted_externally_to_rlds/0.1.0 has size 1.49 GiB\n", + "Dataset gs://gresearch/robotics/nyu_franka_play_dataset_converted_externally_to_rlds/0.1.0 has size 5.18 GiB\n", + "Dataset gs://gresearch/robotics/maniskill_dataset_converted_externally_to_rlds/0.1.0 has size 151.05 GiB\n", + "Dataset gs://gresearch/robotics/cmu_franka_exploration_dataset_converted_externally_to_rlds/0.1.0 has size 602.24 MiB\n", + "Dataset gs://gresearch/robotics/ucsd_kitchen_dataset_converted_externally_to_rlds/0.1.0 has size 1.33 GiB\n", + "Dataset gs://gresearch/robotics/ucsd_pick_and_place_dataset_converted_externally_to_rlds/0.1.0 has size 3.53 GiB\n", + "Dataset gs://gresearch/robotics/austin_sailor_dataset_converted_externally_to_rlds/0.1.0 has size 18.85 GiB\n", + "Dataset gs://gresearch/robotics/austin_sirius_dataset_converted_externally_to_rlds/0.1.0 has size 6.55 GiB\n", + "Dataset gs://gresearch/robotics/bc_z/0.1.0 has size 80.54 GiB\n", + "Dataset gs://gresearch/robotics/usc_cloth_sim_converted_externally_to_rlds/0.1.0 has size 254.52 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_pr2_opening_fridge_converted_externally_to_rlds/0.1.0 has size 360.57 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds/0.1.0 has size 829.37 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_saytap_converted_externally_to_rlds/0.1.0 has size 55.34 MiB\n", + "Dataset gs://gresearch/robotics/utokyo_xarm_pick_and_place_converted_externally_to_rlds/0.1.0 has size 1.29 GiB\n", + "Dataset gs://gresearch/robotics/utokyo_xarm_bimanual_converted_externally_to_rlds/0.1.0 has size 138.44 MiB\n", + "Dataset gs://gresearch/robotics/robo_net/1.0.0 has size 799.91 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_mvp_converted_externally_to_rlds/0.1.0 has size 12.34 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_rpt_converted_externally_to_rlds/0.1.0 has size 40.64 GiB\n", + "Dataset gs://gresearch/robotics/kaist_nonprehensile_converted_externally_to_rlds/0.1.0 has size 11.71 GiB\n", + "Dataset gs://gresearch/robotics/stanford_mask_vit_converted_externally_to_rlds/0.1.0 has size 76.17 GiB\n", + "Dataset gs://gresearch/robotics/tokyo_u_lsmo_converted_externally_to_rlds/0.1.0 has size 335.71 MiB\n", + "Dataset gs://gresearch/robotics/dlr_sara_pour_converted_externally_to_rlds/0.1.0 has size 2.92 GiB\n", + "Dataset gs://gresearch/robotics/dlr_sara_grid_clamp_converted_externally_to_rlds/0.1.0 has size 1.65 GiB\n", + "Dataset gs://gresearch/robotics/dlr_edan_shared_control_converted_externally_to_rlds/0.1.0 has size 3.09 GiB\n", + "Dataset gs://gresearch/robotics/asu_table_top_converted_externally_to_rlds/0.1.0 has size 737.60 MiB\n", + "Dataset gs://gresearch/robotics/stanford_robocook_converted_externally_to_rlds/0.1.0 has size 124.62 GiB\n", + "Dataset gs://gresearch/robotics/eth_agent_affordances/0.1.0 has size 17.27 GiB\n", + "Dataset gs://gresearch/robotics/imperialcollege_sawyer_wrist_cam/0.1.0 has size 81.87 MiB\n", + "Dataset gs://gresearch/robotics/iamlab_cmu_pickup_insert_converted_externally_to_rlds/0.1.0 has size 50.29 GiB\n", + "Dataset gs://gresearch/robotics/uiuc_d3field/0.1.0 has size 15.82 GiB\n", + "Dataset gs://gresearch/robotics/utaustin_mutex/0.1.0 has size 20.79 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_fanuc_manipulation/0.1.0 has size 8.85 GiB\n", + "Dataset gs://gresearch/robotics/cmu_play_fusion/0.1.0 has size 6.68 GiB\n", + "Dataset gs://gresearch/robotics/cmu_stretch/0.1.0 has size 728.06 MiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_recon/0.1.0 has size 18.73 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_cory_hall/0.1.0 has size 1.39 GiB\n", + "Dataset gs://gresearch/robotics/berkeley_gnm_sac_son/0.1.0 has size 7.00 GiB\n" + ] + } + ], + "source": [ + "# Iterate over and make sure that a dataset can be created\n", + "for name in DATASETS:\n", + " uri = dataset2path(name)\n", + " b = tfds.builder_from_directory(builder_dir=uri)\n", + " split = list(b.info.splits.keys())[0]\n", + " b.as_dataset(split=split)\n", + " print(\"Dataset %s has size %s\" % (uri, b.info.dataset_size))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ZnRYMsVpaZKF", + "outputId": "d546a431-5dad-4aee-d6f6-b9aa4207e319" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/tensorflow/datasets.git\n", + " Cloning https://github.com/tensorflow/datasets.git to /tmp/pip-req-build-d48q8hrq\n", + " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/datasets.git /tmp/pip-req-build-d48q8hrq\n", + " Resolved https://github.com/tensorflow/datasets.git to commit 0f2cce155781202f05fbe8007a763e12ef9fc6ee\n", + " Installing build dependencies ... \u001b[?25ldone\n", + "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", + "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25hCollecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading absl_py-2.0.0-py3-none-any.whl.metadata (2.3 kB)\n", + "Collecting click (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading click-8.1.7-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting dm-tree (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading dm_tree-0.1.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (152 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.8/152.8 kB\u001b[0m \u001b[31m654.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m1m687.2 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hCollecting etils>=0.9.0 (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading etils-1.5.2-py3-none-any.whl.metadata (6.3 kB)\n", + "Collecting numpy (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.2/61.2 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting promise (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached promise-2.3-py3-none-any.whl\n", + "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading protobuf-4.25.0-cp37-abi3-manylinux2014_x86_64.whl.metadata (541 bytes)\n", + "Collecting psutil (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (21 kB)\n", + "Collecting requests>=2.19.0 (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading requests-2.31.0-py3-none-any.whl.metadata (4.6 kB)\n", + "Collecting tensorflow-metadata (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached tensorflow_metadata-1.14.0-py3-none-any.whl.metadata (2.1 kB)\n", + "Collecting termcolor (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", + "Collecting toml (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", + "Collecting tqdm (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading tqdm-4.66.1-py3-none-any.whl.metadata (57 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.6/57.6 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting wrapt (from tensorflow-datasets==4.9.3+nightly)\n", + " Downloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n", + "Collecting array-record>=0.5.0 (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (503 bytes)\n", + "Collecting fsspec (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading fsspec-2023.10.0-py3-none-any.whl.metadata (6.8 kB)\n", + "Collecting importlib_resources (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading importlib_resources-6.1.1-py3-none-any.whl.metadata (4.1 kB)\n", + "Collecting typing_extensions (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading typing_extensions-4.8.0-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting zipp (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading zipp-3.17.0-py3-none-any.whl.metadata (3.7 kB)\n", + "Collecting charset-normalizer<4,>=2 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (33 kB)\n", + "Collecting idna<4,>=2.5 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading idna-3.4-py3-none-any.whl (61 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.5/61.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting urllib3<3,>=1.21.1 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading urllib3-2.0.7-py3-none-any.whl.metadata (6.6 kB)\n", + "Collecting certifi>=2017.4.17 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading certifi-2023.7.22-py3-none-any.whl.metadata (2.2 kB)\n", + "Collecting six (from promise->tensorflow-datasets==4.9.3+nightly)\n", + " Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n", + "Collecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached absl_py-1.4.0-py3-none-any.whl (126 kB)\n", + "Collecting googleapis-common-protos<2,>=1.52.0 (from tensorflow-metadata->tensorflow-datasets==4.9.3+nightly)\n", + " Using cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl.metadata (1.5 kB)\n", + "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", + " Using cached protobuf-3.20.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n", + "Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.0 MB)\n", + "Downloading etils-1.5.2-py3-none-any.whl (140 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading requests-2.31.0-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.6/62.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading click-8.1.7-py3-none-any.whl (97 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.9/97.9 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (283 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m283.6/283.6 kB\u001b[0m \u001b[31m16.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached tensorflow_metadata-1.14.0-py3-none-any.whl (28 kB)\n", + "Downloading tqdm-4.66.1-py3-none-any.whl (78 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.3/78.3 kB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (80 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m80.3/80.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading certifi-2023.7.22-py3-none-any.whl (158 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.3/158.3 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (142 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m142.1/142.1 kB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl (230 kB)\n", + "Downloading urllib3-2.0.7-py3-none-any.whl (124 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 kB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading fsspec-2023.10.0-py3-none-any.whl (166 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m166.4/166.4 kB\u001b[0m \u001b[31m13.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading importlib_resources-6.1.1-py3-none-any.whl (33 kB)\n", + "Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", + "Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", + "Building wheels for collected packages: tensorflow-datasets\n", + " Building wheel for tensorflow-datasets (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for tensorflow-datasets: filename=tensorflow_datasets-4.9.3+nightly-py3-none-any.whl size=5042188 sha256=b922a59c63a43266324047d6de8cc70c4e902e4be1002a629f6fc9144b42026e\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-yum8n3h3/wheels/69/95/f3/0a7e5341cee7ec33827b33149e1556b4e39317c704cb2751bd\n", + "Successfully built tensorflow-datasets\n", + "Installing collected packages: dm-tree, zipp, wrapt, urllib3, typing_extensions, tqdm, toml, termcolor, six, psutil, protobuf, numpy, importlib_resources, idna, fsspec, etils, click, charset-normalizer, certifi, absl-py, requests, promise, googleapis-common-protos, tensorflow-metadata, array-record, tensorflow-datasets\n", + " Attempting uninstall: dm-tree\n", + " Found existing installation: dm-tree 0.1.8\n", + " Uninstalling dm-tree-0.1.8:\n", + " Successfully uninstalled dm-tree-0.1.8\n", + " Attempting uninstall: zipp\n", + " Found existing installation: zipp 3.17.0\n", + " Uninstalling zipp-3.17.0:\n", + " Successfully uninstalled zipp-3.17.0\n", + " Attempting uninstall: wrapt\n", + " Found existing installation: wrapt 1.14.1\n", + " Uninstalling wrapt-1.14.1:\n", + " Successfully uninstalled wrapt-1.14.1\n", + " Attempting uninstall: urllib3\n", + " Found existing installation: urllib3 1.26.16\n", + " Uninstalling urllib3-1.26.16:\n", + " Successfully uninstalled urllib3-1.26.16\n", + " Attempting uninstall: typing_extensions\n", + " Found existing installation: typing_extensions 4.6.3\n", + " Uninstalling typing_extensions-4.6.3:\n", + " Successfully uninstalled typing_extensions-4.6.3\n", + " Attempting uninstall: tqdm\n", + " Found existing installation: tqdm 4.65.0\n", + " Uninstalling tqdm-4.65.0:\n", + " Successfully uninstalled tqdm-4.65.0\n", + " Attempting uninstall: toml\n", + " Found existing installation: toml 0.10.2\n", + " Uninstalling toml-0.10.2:\n", + " Successfully uninstalled toml-0.10.2\n", + " Attempting uninstall: termcolor\n", + " Found existing installation: termcolor 2.3.0\n", + " Uninstalling termcolor-2.3.0:\n", + " Successfully uninstalled termcolor-2.3.0\n", + " Attempting uninstall: six\n", + " Found existing installation: six 1.16.0\n", + " Uninstalling six-1.16.0:\n", + " Successfully uninstalled six-1.16.0\n", + " Attempting uninstall: psutil\n", + " Found existing installation: psutil 5.9.0\n", + " Uninstalling psutil-5.9.0:\n", + " Successfully uninstalled psutil-5.9.0\n", + " Attempting uninstall: protobuf\n", + " Found existing installation: protobuf 3.20.3\n", + " Uninstalling protobuf-3.20.3:\n", + " Successfully uninstalled protobuf-3.20.3\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 1.25.0\n", + " Uninstalling numpy-1.25.0:\n", + " Successfully uninstalled numpy-1.25.0\n", + " Attempting uninstall: importlib_resources\n", + " Found existing installation: importlib-resources 6.1.1\n", + " Uninstalling importlib-resources-6.1.1:\n", + " Successfully uninstalled importlib-resources-6.1.1\n", + " Attempting uninstall: idna\n", + " Found existing installation: idna 3.4\n", + " Uninstalling idna-3.4:\n", + " Successfully uninstalled idna-3.4\n", + " Attempting uninstall: fsspec\n", + " Found existing installation: fsspec 2023.9.2\n", + " Uninstalling fsspec-2023.9.2:\n", + " Successfully uninstalled fsspec-2023.9.2\n", + " Attempting uninstall: etils\n", + " Found existing installation: etils 1.5.2\n", + " Uninstalling etils-1.5.2:\n", + " Successfully uninstalled etils-1.5.2\n", + " Attempting uninstall: click\n", + " Found existing installation: click 8.1.7\n", + " Uninstalling click-8.1.7:\n", + " Successfully uninstalled click-8.1.7\n", + " Attempting uninstall: charset-normalizer\n", + " Found existing installation: charset-normalizer 2.0.4\n", + " Uninstalling charset-normalizer-2.0.4:\n", + " Successfully uninstalled charset-normalizer-2.0.4\n", + " Attempting uninstall: certifi\n", + " Found existing installation: certifi 2023.5.7\n", + " Uninstalling certifi-2023.5.7:\n", + " Successfully uninstalled certifi-2023.5.7\n", + " Attempting uninstall: absl-py\n", + " Found existing installation: absl-py 1.4.0\n", + " Uninstalling absl-py-1.4.0:\n", + " Successfully uninstalled absl-py-1.4.0\n", + " Attempting uninstall: requests\n", + " Found existing installation: requests 2.29.0\n", + " Uninstalling requests-2.29.0:\n", + " Successfully uninstalled requests-2.29.0\n", + " Attempting uninstall: promise\n", + " Found existing installation: promise 2.3\n", + " Uninstalling promise-2.3:\n", + " Successfully uninstalled promise-2.3\n", + " Attempting uninstall: googleapis-common-protos\n", + " Found existing installation: googleapis-common-protos 1.61.0\n", + " Uninstalling googleapis-common-protos-1.61.0:\n", + " Successfully uninstalled googleapis-common-protos-1.61.0\n", + " Attempting uninstall: tensorflow-metadata\n", + " Found existing installation: tensorflow-metadata 1.14.0\n", + " Uninstalling tensorflow-metadata-1.14.0:\n", + " Successfully uninstalled tensorflow-metadata-1.14.0\n", + " Attempting uninstall: array-record\n", + " Found existing installation: array-record 0.5.0\n", + " Uninstalling array-record-0.5.0:\n", + " Successfully uninstalled array-record-0.5.0\n", + " Attempting uninstall: tensorflow-datasets\n", + " Found existing installation: tensorflow-datasets 4.9.3\n", + " Uninstalling tensorflow-datasets-4.9.3:\n", + " Successfully uninstalled tensorflow-datasets-4.9.3\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "tensorflow 2.14.0 requires wrapt<1.15,>=1.11.0, but you have wrapt 1.16.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed absl-py-1.4.0 array-record-0.5.0 certifi-2023.7.22 charset-normalizer-3.3.2 click-8.1.7 dm-tree-0.1.8 etils-1.5.2 fsspec-2023.10.0 googleapis-common-protos-1.61.0 idna-3.4 importlib_resources-6.1.1 numpy-1.26.1 promise-2.3 protobuf-3.20.3 psutil-5.9.6 requests-2.31.0 six-1.16.0 tensorflow-datasets-4.9.3+nightly tensorflow-metadata-1.14.0 termcolor-2.3.0 toml-0.10.2 tqdm-4.66.1 typing_extensions-4.8.0 urllib3-2.0.7 wrapt-1.16.0 zipp-3.17.0\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "# Might require updating tensorflow datasets:\n", + "%pip install --upgrade --force-reinstall git+https://github.com/tensorflow/datasets.git" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bPhwnlk1a1lq", + "outputId": "90ec1c89-2ef7-4cd6-aa39-b2df72da15de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fractal20220817_data\n", + "bc_z\n" + ] + } + ], + "source": [ + "for name in DATASET_NAMES:\n", + " print(name)\n", + " b = tfds.builder_from_directory(builder_dir=dataset2path(name))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/models/main_models/rt1/README.md b/models/main_models/rt1/README.md new file mode 100644 index 000000000..930fa939a --- /dev/null +++ b/models/main_models/rt1/README.md @@ -0,0 +1,66 @@ +# NPM-Dataset +A comprehensive robotics dataset that includes navigation, perception, and manipulation data per data point. + +# RT-1 (Robotic Transformer) PyTorch Implementation + + +A forked implementation of RT1 (Robotic Transformer) originally inspired by the Google Research paper. + +This implemenetation of RT-1 was pretrained on the Bridge dataset and further fine-tuned on our LaNMP dataset for evaluation. Please find details of the repository below + +## Setup Instructions + +```bash +git clone https://github.com/h2r/NPM-Dataset.git +git checkout -b rt1 +pip install -e . +``` + +## Overview of files + +This repository has 7 critical files/folders whose use cases are described below + +1) ```main.py```: used to pretrain RT-1 on the bridge dataset. Modifying this file to accomodate different datasets requires changing the ```observation_space``` and ```action_space``` according to the dataset being loaded, as well as changing the dataset keys in ```rt1_pytorch/tokenizers/action_tokenizer.py```. Running this file saves a series of checkpoints and logs losses using weights and biases +2) ```main_ft.py```: used to finetune RT-1 on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset finetuning (AI2Thor). Running this file saves a series of checkpoints and logs losses using weights and biases +3) ```main_ft_eval.py```: used to run RT-1 in inference mode on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset (AI2Thor). The file iterates/loads all saved checkpoints from finetuning and runs RT-1 on inference mode for the validation dataset on each checkpoint. The script logs the test losses using weights and biases +4) ```ai2thor_env.py```: contains a Gym environment style class to load and take steps in AI2Thor enivironment. This file is used to generate real-time trajectories based on the action tokens generated by a finetuned RT-1 model (specific for AI2Thor). The main ```step()``` function takes/executes the generated action by RT-1 and returns a success message along with information about the environment state e.g. object or agent metadata, which can be saved to capture the trajectory taken by the agent for a given task +5) ```rollout_ai2thor.py```: interfaces between the finetuned RT-1 model (from a loaded checkpoint after finetuning on LaNMP) and the ```ai2thor_env.py``` Gym environment, in order to send observations from the AI2Thor environment to RT-1 and execute proposed action tokens by RT-1 on AI2Thor. Note that this file should not be run on a headless machine since it requires/deploys AI2Thor simulator GUI +6) ```rt1_pytorch/rt1_policy.py```: contains the RT-1 model implementation in PyTorch. The ```loss()``` function performs forward pass of RT-1 for training and ```act()``` function performs the forward pass during inference. +7) ```lanmp_dataloader/rt1_dataloader.py```: contains the ```DatasetManager``` class that extracts trajectories from the LaNMP ```sim_data.hdf5``` dataset file. The script automatically separates train and validation subsets according to different splits e.g. k-fold by scene, task wise or for diversity ablation. The ```DatasetManager``` also handles tokenizing/detokenizing the raw trajectory data into 256 discrete buckets, whilst also chunking trajectories across non-overlapping window lengths of 6 steps + +## Details about file arguments + +Most relevant files in this repository accept the same set of arguments that are detailed below +* ```dataset```: only for the ```main.py``` file, specifies the dataset on which the RT-1 model should be pretrained +* ```train-split```: specifies what fraction of the loaded dataset should be used for training v.s. evaluation +* ```eval-split```: specifies what fraction of the laoded dataset should be used for evaluation v.s. training +* ```epochs```: total number of passes over the all batches of the training set +* ```lr```: learning rate for cross-entropy loss of RT1 +* ```train-batch-size```: the number of trajectories from which to sample data for the current training batch +* ```eval-batch-size```: the number of trajectories from which to sample data for the current evaluation batch +* ```trajectory-length```: the window size (context history of ```trajecotry-length``` previous images) used for each trajectory when feeding data to RT-1 model; this is set to 6 based on the RT-1 implementation +* ```sentence-transformer```: the language embedding to apply on the language-specified task +* ```device```: the device to load the model/data onto during training/inference +* ```eval-freq```: the interval of batches at which to run evaluation/inference on the validation dataset (currently set to 0 in ```main_ft.py```) +* ```checkpoint-freq```: the interval of batches at which to save a checkpoint during training +* ```checkpoint-dir```: the directory path at which to save a checkpoint during training +* ```load-checkpoint```: (optional) path of the pretrained checkpoint to load for further fine-tuning +* ```wandb```: boolean determining if logging to weights and biases should happen +* ```eval-scene```: the AI2Thor scene number in the dataset that is held out of the training set for evaluation during k-fold cross validation across scenes +* ```split-type```: determines the split type (i.e. k-fold by scene, task wise or diversity ablation) between train and evaluation used by the ```DatasetManager``` in ```rt1_dataloader.py``` +* ```num-diversity-scenes```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of scenes to perform diversity ablation over i.e. maximum of 4 for LaNMP simulation data +* ```max-diversity-trajectories```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of trajectories that are divided evenly across the number of ```num-diversity-scenes``` scenes +* ```train-subbatch```: the batch size to use during training/finetuning +* ```eval-subbatch```: the batch size to use during evaluation + +## Checkpoint samples + +Please find the follow checkpoints samples that can be loaded to the RT-1 model. These can be found on the supplementary Google Drive associated with this project +* ```sample_checkpoints/pretrained_bridge```: the final checkpoint saved when pretraining the RT-1 model on the Bridge dataset +* ```sample_checkpoints/task_gen```: the final checkpoint saved after finetuning RT-1 model on the task-wise split for the task generalization experiment + +## Additional notes + +When running any of the finetuning or pretraining scripts, please ensure the following modules are loaded +```module load cuda/11.8.0-lpttyok``` +```module load cudnn/8.7.0.84-11.8-lg2dpd5``` diff --git a/models/main_models/rt1/ai2thor_env.py b/models/main_models/rt1/ai2thor_env.py new file mode 100644 index 000000000..60047ecfc --- /dev/null +++ b/models/main_models/rt1/ai2thor_env.py @@ -0,0 +1,641 @@ + +import copy +import numpy as np +from collections import Counter, OrderedDict +import ai2thor +from ai2thor.controller import Controller +from json import load +from os import path +import sys +sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred') +sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred/gen') +import gen.constants as constants +# import gen.utils.image_util as image_util +# from gen.utils import game_util +# from gen.utils.game_util import get_objects_of_type, get_obj_of_type_closest_to_obj +from random import choice, randint +from time import sleep +import pdb + +DEFAULT_RENDER_SETTINGS = {'renderImage': True, + 'renderDepthImage': True, + 'renderClassImage': False, + 'renderObjectImage': False, + } + +class ThorEnv(): + def __init__(self, task, max_episode_length = 1500): + + self.controller = None + self.last_event = None + + self.task = task + self.max_episode_length = max_episode_length + + + def reset(self, scene_name): + ''' + reset scene / start scene + ''' + print('Starting Ai2Thor Env...') + self.controller = Controller( + agentMode="arm", + massThreshold=None, + scene=scene_name, + visibilityDistance=1.5, + gridSize=0.25, + renderDepthImage=False, + renderInstanceSegmentation=False, + snapToGrid=False, + width=300, + height=300, + fieldOfView=60 + ) + self.last_event = self.controller.last_event + return self.last_event + + + def step(self, action, kwargs): + + if action in set(['MoveAgent','RotateAgent']): + + if action == 'MoveAgent': + + event_move = self.controller.step( + action="Teleport", + position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) + ) + + #execute a rotation body operation + event_rotate = self.controller.step( + action="RotateAgent", + degrees=kwargs['body_yaw_delta'], + returnToStart=False, + speed=1, + fixedDeltaTime=0.02 + ) + + success = event_move.metadata['lastActionSuccess'] + error = [event_move.metadata['errorMessage']] + self.last_event = event_move + + + elif action == 'RotateAgent': + + #execute a rotation body operation + event_rotate = self.controller.step( + action="RotateAgent", + degrees=kwargs['body_yaw_delta'], + returnToStart=False, + speed=1, + fixedDeltaTime=0.02 + ) + + event_move = self.controller.step( + action="Teleport", + position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) + ) + + success = event_rotate.metadata['lastActionSuccess'] + error = [event_rotate.metadata['errorMessage']] + self.last_event = event_rotate + + + + elif action == 'MoveArm': + + #execute smooth move arm operation + event = self.controller.step( + action="MoveArm", + position=dict(x=kwargs['arm_position'][0], y=kwargs['arm_position'][1], z=kwargs['arm_position'][2]), + coordinateSpace="world", + restrictMovement=False, + speed=1, + returnToStart=False, + fixedDeltaTime=0.02 + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == 'PickupObject': + + #execute pickup + event = self.controller.step( + action="PickupObject", + objectIdCandidates=[] + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == 'ReleaseObject': + + #execute pickup + event = self.controller.step( + action="ReleaseObject", + objectIdCandidates=[] + ) + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action in set(['LookDown','LookUp']): + + #execute smooth change in pitch + events = self.smooth_look(action) + + success = events[-1].metadata['lastActionSuccess'] if len(events)>0 else False + error = [events[-1].metadata['errorMessage']] if len(events)>0 else ['Reached boundary of LookUp/LookDown'] + self.last_event = events[-1] if len(events)>0 else self.last_event + + + elif action == 'stop': + #stop the execution + event = self.controller.step(action="Done") + + success = event.metadata['lastActionSuccess'] + error = [event.metadata['errorMessage']] + self.last_event = event + + elif action == None: + #no operation to be done + success = True + error = [''] + + else: + + raise Exception('Error: the provided action {} is not valid'.format(action)) + + return success, error, self.last_event + + def step_old(self, action, smooth_nav=False): + ''' + overrides ai2thor.controller.Controller.step() for smooth navigation and goal_condition updates + ''' + if 'action' in action: + if smooth_nav: + if "MoveAhead" in action['action']: + self.smooth_move_ahead(action) + elif "Rotate" in action['action']: + self.smooth_rotate(action) + elif "Look" in action['action']: + self.smooth_look(action) + else: + super().step(action) + else: + if "LookUp" in action['action']: + self.look_angle(-constants.AGENT_HORIZON_ADJ) + elif "LookDown" in action['action']: + self.look_angle(constants.AGENT_HORIZON_ADJ) + else: + super().step(action) + else: + super().step(action) + + event = self.update_states(action) + self.check_post_conditions(action) + return event + + + + def noop(self): + ''' + do nothing + ''' + super().step(dict(action='Pass')) + + def smooth_move_ahead(self, action, render_settings=None): + ''' + smoother MoveAhead + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + smoothing_factor = constants.RECORD_SMOOTHING_FACTOR + new_action = copy.deepcopy(action) + new_action['moveMagnitude'] = constants.AGENT_STEP_SIZE / smoothing_factor + + new_action['renderImage'] = render_settings['renderImage'] + new_action['renderClassImage'] = render_settings['renderClassImage'] + new_action['renderObjectImage'] = render_settings['renderObjectImage'] + new_action['renderDepthImage'] = render_settings['renderDepthImage'] + + events = [] + for xx in range(smoothing_factor - 1): + event = super().step(new_action) + if event.metadata['lastActionSuccess']: + events.append(event) + + event = super().step(new_action) + if event.metadata['lastActionSuccess']: + events.append(event) + return events + + def smooth_rotate(self, action, render_settings=None): + ''' + smoother RotateLeft and RotateRight + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) + position = event.metadata['agent']['position'] + rotation = event.metadata['agent']['rotation'] + start_rotation = rotation['y'] + if action['action'] == 'RotateLeft': + end_rotation = (start_rotation - 90) + else: + end_rotation = (start_rotation + 90) + + events = [] + for xx in np.arange(.1, 1.0001, .1): + if xx < 1: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + } + event = super().step(teleport_action) + else: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + } + event = super().step(teleport_action) + + if event.metadata['lastActionSuccess']: + events.append(event) + return events + + def smooth_look(self, action, render_settings=None): + ''' + smoother LookUp and LookDown + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + start_horizon = event.metadata['agent']['cameraHorizon'] + rotation = np.round(event.metadata['agent']['rotation']['y'], 4) + end_horizon = start_horizon + constants.AGENT_HORIZON_ADJ * (1 - 2 * int(action == 'LookUp')) + position = event.metadata['agent']['position'] + + events = [] + for xx in np.arange(.1, 1.0001, .1): + if xx < 1: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': rotation, + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + 'standing': True, + } + event = self.controller.step(teleport_action) + else: + teleport_action = { + 'action': 'TeleportFull', + 'rotation': rotation, + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), + 'standing':True, + } + event = self.controller.step(teleport_action) + + if event.metadata['lastActionSuccess']: + events.append(event) + + return events + + def rotate_angle(self, angle, render_settings=None): + ''' + rotate at a specific angle + ''' + if render_settings is None: + render_settings = DEFAULT_RENDER_SETTINGS + event = self.last_event + horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) + position = event.metadata['agent']['position'] + rotation = event.metadata['agent']['rotation'] + start_rotation = rotation['y'] + end_rotation = start_rotation + angle + + teleport_action = { + 'action': 'TeleportFull', + 'rotation': np.round(end_rotation, 3), + 'x': position['x'], + 'z': position['z'], + 'y': position['y'], + 'horizon': horizon, + 'tempRenderChange': True, + 'renderNormalsImage': False, + 'renderImage': render_settings['renderImage'], + 'renderClassImage': render_settings['renderClassImage'], + 'renderObjectImage': render_settings['renderObjectImage'], + 'renderDepthImage': render_settings['renderDepthImage'], + } + event = super().step(teleport_action) + return event + + def to_thor_api_exec(self, action, object_id="", smooth_nav=False): + # TODO: parametrized navigation commands + + if "RotateLeft" in action: + action = dict(action="RotateLeft", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "RotateRight" in action: + action = dict(action="RotateRight", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "MoveAhead" in action: + action = dict(action="MoveAhead", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "LookUp" in action: + action = dict(action="LookUp", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "LookDown" in action: + action = dict(action="LookDown", + forceAction=True) + event = self.step(action, smooth_nav=smooth_nav) + elif "OpenObject" in action: + action = dict(action="OpenObject", + objectId=object_id, + moveMagnitude=1.0) + event = self.step(action) + elif "CloseObject" in action: + action = dict(action="CloseObject", + objectId=object_id, + forceAction=True) + event = self.step(action) + elif "PickupObject" in action: + action = dict(action="PickupObject", + objectId=object_id) + event = self.step(action) + elif "PutObject" in action: + inventory_object_id = self.last_event.metadata['inventoryObjects'][0]['objectId'] + action = dict(action="PutObject", + objectId=object_id, + forceAction=True, + placeStationary=True) + event = self.step(action) + elif "ToggleObjectOn" in action: + action = dict(action="ToggleObjectOn", + objectId=object_id) + event = self.step(action) + + elif "ToggleObjectOff" in action: + action = dict(action="ToggleObjectOff", + objectId=object_id) + event = self.step(action) + elif "SliceObject" in action: + # check if agent is holding knife in hand + inventory_objects = self.last_event.metadata['inventoryObjects'] + if len(inventory_objects) == 0 or 'Knife' not in inventory_objects[0]['objectType']: + raise Exception("Agent should be holding a knife before slicing.") + + action = dict(action="SliceObject", + objectId=object_id) + event = self.step(action) + else: + raise Exception("Invalid action. Conversion to THOR API failed! (action='" + str(action) + "')") + + return event, action + + def take_action(self, word_action, num_action, rand_agent=False): + i = 0 + incr = 0.025 + x = 0 + y = 0 + z = 0 + fixedDeltaTime = 0.02 + move = 0.2 + a = None + + if rand_agent: + all_word_actions = ['PickupObject','ReleaseObject', 'LookUp', 'LookDown', 'MoveArm', 'MoveArmBase', 'RotateAgent', 'MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft', 'stop'] + rand_word_action = choice(all_word_actions) + if rand_word_action in ["stop"]: + return "stop", None + elif rand_word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: + a = dict(action = rand_word_action) + elif rand_word_action in ['MoveArm', 'MoveArmBase']: + global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] + curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] + rand_x_indx, rand_y_indx, rand_z_indx = randint(1, 256), randint(1, 256), randint(1, 256) # starts at 1 to skip NoOp + x_del, y_del, z_del = self.bins["4"][rand_x_indx], self.bins["5"][rand_y_indx], self.bins["6"][rand_z_indx] + new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del + a = dict(action='MoveArm', position=dict(x=new_x, y=new_y, z=new_z),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) + elif rand_word_action in ['RotateAgent']: + rand_yaw_indx = randint(1, 256) + new_yaw = self.bins["3"][rand_yaw_indx] + a = dict(action=rand_word_action, degrees=new_yaw, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + else: # move base + a = dict(action=rand_word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + + else: + if word_action in ['NoOp']: + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + if word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: + a = dict(action = word_action) + elif word_action in ['MoveArm', 'MoveArmBase']: + global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] + curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] + x_del, y_del, z_del = self.bins["4"][num_action[0]], self.bins["5"][num_action[1]], self.bins["6"][num_action[2]] + if x_del == -1000 or y_del == -1000 or z_del == -1000: # if any of them are NoOp then skip all. Can do it another way where only skip the specific axis + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del + a = dict(action='MoveArm',position=dict(x=new_x, y=new_z, z=new_y),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) + elif word_action in ['RotateAgent']: + yaw_del = num_action.item() + new_yaw = self.bins["3"][yaw_del] + if new_yaw == -1000: #make it variable later + print(f"Word Action: NoOP", end="\r") # for debugging + return None, None, self.last_event.metadata + a = dict(action=word_action, degrees=new_yaw,returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + else: # move base + a = dict(action=word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) + + sleep(0.5) #for debugging/movement analysis + event = self.controller.step(a) + success = event.metadata['lastActionSuccess'] + error = event.metadata['errorMessage'] + self.last_event = event + #for debugging/movement analysis + sleep(0.5) + if rand_agent: + print(f"Random Word Action: {rand_word_action} ", end="\r") + # else: + # print(f"Word Action: {word_action} ", end="\r") + # print(f"Num Action: {num_action} ", end="\r") + + return success, error, self.last_event.metadata + + + + +if __name__ == '__main__': + + SCENE_NAME = 'FloorPlan_Train5_1' + TESTED_STEPS = 200 + + test = ThorEnv('Walk to the living room') + + event = test.reset(scene_name=SCENE_NAME) + + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + agent_holding = np.array([]) + + + test.controller.step( + action="MoveArmBase", + y=0.0, + speed=1, + returnToStart=True, + fixedDeltaTime=0.02 + ) + + + for i in range(TESTED_STEPS): + + print(''' + (1) Move X+ + (2) Move X- + (3) Move Z+ + (4) Move Z- + (5) Rotate Left + (6) Rotate Right + (7) Rotate Up + (8) Rotate Down + (9) Open Gripper + (0) Close Gripper + (h) Move Gripper up + (n) Move Gripper down + (b) Move Gripper left + (m) Move Gripper right + (z) Move Gripper forward + (x) Move Gripper backwards + ''') + + + action = input('>') + + + if action == '1': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[0] += 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '2': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[0] -= 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '3': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[2] += 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '4': + + temp_body_coordinate = copy.copy(curr_body_coordinate) + temp_body_coordinate[2] -= 0.05 + + success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) + + elif action == '5': + + success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta': -90}) + + elif action == '6': + + success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta':+90}) + + elif action == '7': + + success, error, event = test.step('LookUp', {}) + + elif action == '8': + + success, error, event = test.step('LookDown', {}) + + elif action == '9': + + success, error, event = test.step('PickupObject', {}) + + elif action == '0': + + success, error, event = test.step('ReleaseObject', {}) + + elif action == 'h': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[1] += 0.20 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'n': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[1] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'b': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[0] += 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'm': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[0] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'z': + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[2] += 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) + + elif action == 'x': + + temp_arm_coordinate = copy.copy(curr_arm_coordinate) + temp_arm_coordinate[2] -= 0.05 + + success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) diff --git a/models/main_models/rt1/data.py b/models/main_models/rt1/data.py new file mode 100644 index 000000000..71bff29ba --- /dev/null +++ b/models/main_models/rt1/data.py @@ -0,0 +1,536 @@ +# Taken from https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit#gid=0 +import abc +import dataclasses +from typing import Any, Dict, Iterable, Optional, Union +import pdb +import numpy as np +import reverb +import tensorflow as tf +import tensorflow_datasets as tfds +import tree +from rlds import rlds_types, transformations + +tf.config.experimental.set_visible_devices([], "GPU") + + +def dataset2path(name): + if name == "robo_net": + version = "1.0.0" + elif name == "language_table": + version = "0.0.1" + else: + version = "0.1.0" + return f"gs://gresearch/robotics/{name}/{version}" + + +def as_gif(images, path="temp.gif"): + # Render the images as the gif: + images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0) + gif_bytes = open(path, "rb").read() + return gif_bytes + + +def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec: + """Converts a tfds Feature into a TensorSpec.""" + + def _get_feature_spec(nested_feature: tfds.features.FeatureConnector): + if isinstance(nested_feature, tf.DType): + return tf.TensorSpec(shape=(), dtype=nested_feature) + else: + return nested_feature.get_tensor_spec() + + # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to + # make sure we deal with the nested structure. + return tf.nest.map_structure(_get_feature_spec, feature) + + +def _encoded_feature( + feature: Optional[tfds.features.FeatureConnector], + image_encoding: Optional[str], + tensor_encoding: Optional[tfds.features.Encoding], +): + """Adds encoding to Images and/or Tensors.""" + + def _apply_encoding( + feature: tfds.features.FeatureConnector, + image_encoding: Optional[str], + tensor_encoding: Optional[tfds.features.Encoding], + ): + if image_encoding and isinstance(feature, tfds.features.Image): + return tfds.features.Image( + shape=feature.shape, + dtype=feature.dtype, + use_colormap=feature.use_colormap, + encoding_format=image_encoding, + ) + if ( + tensor_encoding + and isinstance(feature, tfds.features.Tensor) + and feature.dtype != tf.string + ): + return tfds.features.Tensor( + shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding + ) + return feature + + if not feature: + return None + return tf.nest.map_structure( + lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature + ) + + +@dataclasses.dataclass +class RLDSSpec(metaclass=abc.ABCMeta): + """Specification of an RLDS Dataset. + + It is used to hold a spec that can be converted into a TFDS DatasetInfo or + a `tf.data.Dataset` spec. + """ + + observation_info: Optional[tfds.features.FeatureConnector] = None + action_info: Optional[tfds.features.FeatureConnector] = None + reward_info: Optional[tfds.features.FeatureConnector] = None + discount_info: Optional[tfds.features.FeatureConnector] = None + step_metadata_info: Optional[tfds.features.FeaturesDict] = None + episode_metadata_info: Optional[tfds.features.FeaturesDict] = None + + def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]: + """Obtains the TensorSpec of an RLDS step.""" + step = {} + if self.observation_info: + step[rlds_types.OBSERVATION] = _features_to_tensor_spec( + self.observation_info + ) + if self.action_info: + step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info) + if self.discount_info: + step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info) + if self.reward_info: + step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info) + if self.step_metadata_info: + for k, v in self.step_metadata_info.items(): + step[k] = _features_to_tensor_spec(v) + + step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool) + step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool) + step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool) + return step + + def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]: + """Obtains the TensorSpec of an RLDS step.""" + episode = {} + episode[rlds_types.STEPS] = tf.data.DatasetSpec( + element_spec=self.step_tensor_spec() + ) + if self.episode_metadata_info: + for k, v in self.episode_metadata_info.items(): + episode[k] = _features_to_tensor_spec(v) + return episode + + def to_dataset_config( + self, + name: str, + image_encoding: Optional[str] = None, + tensor_encoding: Optional[tfds.features.Encoding] = None, + citation: Optional[str] = None, + homepage: Optional[str] = None, + description: Optional[str] = None, + overall_description: Optional[str] = None, + ) -> tfds.rlds.rlds_base.DatasetConfig: + """Obtains the DatasetConfig for TFDS from the Spec.""" + return tfds.rlds.rlds_base.DatasetConfig( + name=name, + description=description, + overall_description=overall_description, + homepage=homepage, + citation=citation, + observation_info=_encoded_feature( + self.observation_info, image_encoding, tensor_encoding + ), + action_info=_encoded_feature( + self.action_info, image_encoding, tensor_encoding + ), + reward_info=_encoded_feature( + self.reward_info, image_encoding, tensor_encoding + ), + discount_info=_encoded_feature( + self.discount_info, image_encoding, tensor_encoding + ), + step_metadata_info=_encoded_feature( + self.step_metadata_info, image_encoding, tensor_encoding + ), + episode_metadata_info=_encoded_feature( + self.episode_metadata_info, image_encoding, tensor_encoding + ), + ) + + def to_features_dict(self): + """Returns a TFDS FeaturesDict representing the dataset config.""" + step_config = { + rlds_types.IS_FIRST: tf.bool, + rlds_types.IS_LAST: tf.bool, + rlds_types.IS_TERMINAL: tf.bool, + } + + if self.observation_info: + step_config[rlds_types.OBSERVATION] = self.observation_info + if self.action_info: + step_config[rlds_types.ACTION] = self.action_info + if self.discount_info: + step_config[rlds_types.DISCOUNT] = self.discount_info + if self.reward_info: + step_config[rlds_types.REWARD] = self.reward_info + + if self.step_metadata_info: + for k, v in self.step_metadata_info.items(): + step_config[k] = v + + if self.episode_metadata_info: + return tfds.features.FeaturesDict( + { + rlds_types.STEPS: tfds.features.Dataset(step_config), + **self.episode_metadata_info, + } + ) + else: + return tfds.features.FeaturesDict( + { + rlds_types.STEPS: tfds.features.Dataset(step_config), + } + ) + + +RLDS_SPEC = RLDSSpec +TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]] + + +@dataclasses.dataclass +class TrajectoryTransform(metaclass=abc.ABCMeta): + """Specification the TrajectoryTransform applied to a dataset of episodes. + + A TrajectoryTransform is a set of rules transforming a dataset + of RLDS episodes to a dataset of trajectories. + This involves three distinct stages: + - An optional `episode_to_steps_map_fn(episode)` is called at the episode + level, and can be used to select or modify steps. + - Augmentation: an `episode_key` could be propagated to `steps` for + debugging. + - Selection: Particular steps can be selected. + - Stripping: Features can be removed from steps. Prefer using `step_map_fn`. + - An optional `step_map_fn` is called at the flattened steps dataset for each + step, and can be used to featurize a step, e.g. add/remove features, or + augument images + - A `pattern` leverages DM patterns to set a rule of slicing an episode to a + dataset of overlapping trajectories. + + Importantly, each TrajectoryTransform must define a `expected_tensor_spec` + which specifies a nested TensorSpec of the resulting dataset. This is what + this TrajectoryTransform will produce, and can be used as an interface with + a neural network. + """ + + episode_dataset_spec: RLDS_SPEC + episode_to_steps_fn_dataset_spec: RLDS_SPEC + steps_dataset_spec: Any + pattern: reverb.structured_writer.Pattern + episode_to_steps_map_fn: Any + expected_tensor_spec: TENSOR_SPEC + step_map_fn: Optional[Any] = None + + def get_for_cached_trajectory_transform(self): + """Creates a copy of this traj transform to use with caching. + + The returned TrajectoryTransfrom copy will be initialized with the default + version of the `episode_to_steps_map_fn`, because the effect of that + function has already been materialized in the cached copy of the dataset. + Returns: + trajectory_transform: A copy of the TrajectoryTransform with overridden + `episode_to_steps_map_fn`. + """ + traj_copy = dataclasses.replace(self) + traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec + traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS] + return traj_copy + + def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset): + """Applies this TrajectoryTransform to the dataset of episodes.""" + + # Convert the dataset of episodes to the dataset of steps. + steps_dataset = episodes_dataset.map( + self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE + ).flat_map(lambda x: x) + + return self._create_pattern_dataset(steps_dataset) + + def transform_steps_rlds_dataset( + self, steps_dataset: tf.data.Dataset + ) -> tf.data.Dataset: + """Applies this TrajectoryTransform to the dataset of episode steps.""" + + return self._create_pattern_dataset(steps_dataset) + + def create_test_dataset( + self, + ) -> tf.data.Dataset: + """Creates a test dataset of trajectories. + + It is guaranteed that the structure of this dataset will be the same as + when flowing real data. Hence this is a useful construct for tests or + initialization of JAX models. + Returns: + dataset: A test dataset made of zeros structurally identical to the + target dataset of trajectories. + """ + zeros = transformations.zeros_from_spec(self.expected_tensor_spec) + + return tf.data.Dataset.from_tensors(zeros) + + def _create_pattern_dataset( + self, steps_dataset: tf.data.Dataset + ) -> tf.data.Dataset: + """Create PatternDataset from the `steps_dataset`.""" + config = create_structured_writer_config("temp", self.pattern) + + # Further transform each step if the `step_map_fn` is provided. + if self.step_map_fn: + steps_dataset = steps_dataset.map(self.step_map_fn) + pattern_dataset = reverb.PatternDataset( + input_dataset=steps_dataset, + configs=[config], + respect_episode_boundaries=True, + is_end_of_episode=lambda x: x[rlds_types.IS_LAST], + ) + return pattern_dataset + + +class TrajectoryTransformBuilder(object): + """Facilitates creation of the `TrajectoryTransform`.""" + + def __init__( + self, + dataset_spec: RLDS_SPEC, + episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS], + step_map_fn=None, + pattern_fn=None, + expected_tensor_spec=None, + ): + self._rds_dataset_spec = dataset_spec + self._steps_spec = None + self._episode_to_steps_map_fn = episode_to_steps_map_fn + self._step_map_fn = step_map_fn + self._pattern_fn = pattern_fn + self._expected_tensor_spec = expected_tensor_spec + + def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform: + """Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.""" + + if validate_expected_tensor_spec and self._expected_tensor_spec is None: + raise ValueError("`expected_tensor_spec` must be set.") + + episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec) + + steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn) + + episode_to_steps_fn_dataset_spec = self._rds_dataset_spec + + if self._step_map_fn is not None: + steps_ds = steps_ds.map(self._step_map_fn) + + zeros_spec = transformations.zeros_from_spec( + steps_ds.element_spec + ) # pytype: disable=wrong-arg-types + + ref_step = reverb.structured_writer.create_reference_step(zeros_spec) + + pattern = self._pattern_fn(ref_step) + + steps_ds_spec = steps_ds.element_spec + + target_tensor_structure = create_reverb_table_signature( + "temp_table", steps_ds_spec, pattern + ) + + if ( + validate_expected_tensor_spec + and self._expected_tensor_spec != target_tensor_structure + ): + raise RuntimeError( + "The tensor spec of the TrajectoryTransform doesn't " + "match the expected spec.\n" + "Expected:\n%s\nActual:\n%s\n" + % ( + str(self._expected_tensor_spec).replace( + "TensorSpec", "tf.TensorSpec" + ), + str(target_tensor_structure).replace("TensorSpec", "tf.TensorSpec"), + ) + ) + + return TrajectoryTransform( + episode_dataset_spec=self._rds_dataset_spec, + episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec, + steps_dataset_spec=steps_ds_spec, + pattern=pattern, + episode_to_steps_map_fn=self._episode_to_steps_map_fn, + step_map_fn=self._step_map_fn, + expected_tensor_spec=target_tensor_structure, + ) + + +def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC): + """Creates a zero valued dataset of episodes for the given RLDS Spec.""" + + def add_steps(episode, step_spec): + episode[rlds_types.STEPS] = transformations.zero_dataset_like( + tf.data.DatasetSpec(step_spec) + ) + if "fake" in episode: + del episode["fake"] + return episode + + episode_without_steps_spec = { + k: v + for k, v in rlds_spec.episode_tensor_spec().items() + if k != rlds_types.STEPS + } + + if episode_without_steps_spec: + episodes_dataset = transformations.zero_dataset_like( + tf.data.DatasetSpec(episode_without_steps_spec) + ) + else: + episodes_dataset = tf.data.Dataset.from_tensors({"fake": ""}) + + episodes_dataset_with_steps = episodes_dataset.map( + lambda episode: add_steps(episode, rlds_spec.step_tensor_spec()) + ) + return episodes_dataset_with_steps + + +def create_reverb_table_signature( + table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern +) -> reverb.reverb_types.SpecNest: + config = create_structured_writer_config(table_name, pattern) + reverb_table_spec = reverb.structured_writer.infer_signature( + [config], steps_dataset_spec + ) + return reverb_table_spec + + +def create_structured_writer_config( + table_name: str, pattern: reverb.structured_writer.Pattern +) -> Any: + config = reverb.structured_writer.create_config( + pattern=pattern, table=table_name, conditions=[] + ) + return config + + +def n_step_pattern_builder(n: int) -> Any: + """Creates trajectory of length `n` from all fields of a `ref_step`.""" + + def transform_fn(ref_step): + traj = {} + for key in ref_step: + if isinstance(ref_step[key], dict): + transformed_entry = tree.map_structure( + lambda ref_node: ref_node[-n:], ref_step[key] + ) + traj[key] = transformed_entry + else: + traj[key] = ref_step[key][-n:] + + return traj + + return transform_fn + + +def get_observation_and_action_from_step(step): + return { + "observation": { + "image": step["observation"]["image"], + "embedding": step["observation"]["natural_language_embedding"], + "instruction": step["observation"]["natural_language_instruction"], + }, + # Decode one hot discrete actions + "action": { + k: tf.argmax(v, axis=-1) if v.dtype == tf.int32 else v + for k, v in step["action"].items() + }, + } + + +def create_dataset( + datasets=["fractal20220817_data"], + split="train", + trajectory_length=6, + batch_size=32, + num_epochs=1, +) -> Iterable[Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]]: + trajectory_datasets = [] + #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) + for dataset in datasets: + #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) + + + # b = tfds.builder_from_directory(builder_dir='/oscar/data/stellex/shared/bridge/0.1.0') + #'~/data/sjulian2/bridge/0.1.0/' + # dataset = tfds.load('bridge', split='train') + #b = tfds.builder_from_directory(builder_dir='/users/sjulian2/data/sjulian2/jaco_play/0.1.0') + # b = tfds.builder_from_directory(builder_dir=dataset2path(dataset)) + + # pdb.set_trace() + b = tfds.builder_from_directory(builder_dir = '/oscar/data/stellex/ssunda11/NPM-Dataset/rt1-pytorch/rt1_dataset/0.1.0') + # ds = tfds.load("fractal20220817_data:0.1.0", data_dir="gs://gresearch/robotics") + + ds = b.as_dataset(split=split) + + # The RLDSSpec for the RT1 dataset. + rt1_spec = RLDSSpec( + observation_info=b.info.features["steps"]["observation"], + action_info=b.info.features["steps"]["action"], + ) + + trajectory_transform = TrajectoryTransformBuilder( + rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length) + ).build(validate_expected_tensor_spec=False) + + trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds) + #pdb.set_trace() + trajectory_datasets.append(trajectory_dataset) + + trajectory_dataset = tf.data.Dataset.sample_from_datasets(trajectory_datasets) + + trajectory_dataset = trajectory_dataset.map( + get_observation_and_action_from_step, num_parallel_calls=tf.data.AUTOTUNE + ) + + # Shuffle, batch, prefetch, repeat + trajectory_dataset = trajectory_dataset.shuffle(batch_size * 16) + trajectory_dataset = trajectory_dataset.batch( + batch_size, + drop_remainder=True, + num_parallel_calls=tf.data.AUTOTUNE, + deterministic=False, + ) + trajectory_dataset = trajectory_dataset.repeat(num_epochs) + trajectory_dataset = trajectory_dataset.prefetch(tf.data.AUTOTUNE) + # pdb.set_trace() + return iter(trajectory_dataset.as_numpy_iterator()) + + +if __name__ == "__main__": + #pdb.set_trace() + ds = create_dataset(datasets=["fractal20220817_data"], split="train[:10]") + it = next(ds) + + def print_shape(x): + if isinstance(x, dict): + shapes = tree.map_structure(lambda x: x.shape, x) + else: + shapes = x.shape + return shapes + + shapes = tree.map_structure(print_shape, it) + print(shapes) diff --git a/models/main_models/rt1/figures/rt1.png b/models/main_models/rt1/figures/rt1.png new file mode 100644 index 0000000000000000000000000000000000000000..17426537180d0baaa5b824e60bd94298ce6d5c35 GIT binary patch literal 135877 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

Q!2CmkZcV&= zE+D`>`W_^B{DHWHk_O;J9rAJehtNMnEe>joZl0HySb1jUe(#U${00*%J^=++h&Kb@>ZJ;S*8W`YoJx)*Zf3>zW_*YW z81~rWl#i!SDs(OoS~!?vmv3Oiqc6_+UKX@%M4rcV=e{Oi2pK(;08wpITi|5R7i%H6}G@V%pSDL zJoa%3sDX5buxD4dFP4>sCzdwXQ|W{nk<3Fbu?0qREEcsvOF2g!OUrArn_yMml@}T< zO8!?}M3=7k@PlTlEx3ad z!G}6e72vI`uk*)-N^16YF6rH1v@qAt29{^PhUW~wctqQ_8~%r1hvIX20ICjG(j7_Z z)$@sss^78UaIivynHhLo5&^0j1}>ja{<$pAV3n`eieN+7!Gf>{WD;{0{5{s$%GMw8!-3OdF94dah*mc@A_IPzOZB|3O`K6a6`>cOg(csfx4oBx z{`m&#bP7Xm&k!scgo*Z_=z8Jh=+PM~JV90zhHj;!ke#SHv>H}oHXOf${Xt8O=~HfZ zn0miq5CksNRIcRNczM5^`OgvFA7YdWkq`x!k4?J#+>0xFJkqZq0FOhsF!O$BP@Cz) zS_S;wP*V}mLahUCCO_UM=op0Lv*gPFmt-B`%?&1YykZ|xoy;9jS95tn-V}Y&9LLa+ z8S;38Gq#CChX(0Z)OJGbmoV5FB4z3)SjPm^#+Gz7o%){BRJ>_1Umpictd)_HRAt9M zy^PsxR{C_g%6X`yqETSgpLdj&dp-^FyF23NCFOGmgbx{rN0vg07G>yxVS&(lkm@_@Yf%MDVw*CwEDV8#sp+tWft$N#Hc``gY!`=2^c;6nfXUn40i{g0*a_c$ub|5tPQ|3NH- Y#5u$X1_XKM0t5X>iOGvr3mXRgFLU@ATL1t6 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/README.md b/models/main_models/rt1/gen/README.md new file mode 100644 index 000000000..607e80b9b --- /dev/null +++ b/models/main_models/rt1/gen/README.md @@ -0,0 +1,77 @@ +# Data Generation + +We also provide code for generating PDDL-based expert demonstrations. This can be used to extend the training data, albiet without human language annotations. + +## Installation + +Get dependencies and compile the planner: +```bash +$ sudo apt-get install ffmpeg flex bison + +$ cd $ALFRED_ROOT/gen/ff_planner +$ make +``` + +## Generation + +To spawn multiple generation threads: + +```bash +$ cd $ALFRED_ROOT/gen +$ python scripts/generate_trajectories.py --save_path data/new_trajs --in_parallel --debug --num_threads 2 +``` + +This will sample tasks based on the sampling mechanism described in the paper. You might notice a lot of failed executions, which are automatically discarded by the script. + +**Note:** The first time you run the generation script, use `--num_threads 1` to allow the script to download the THOR binary. + +## Replay Checks + +In parallel with generation, replay saved trajectories to check if they are reproducable: + +```bash +$ python scripts/replay_checks.py --data_path data/new_trajs --in_parallel +``` +This will ensure that the interaction masks and expert actions can be deterministically executed in THOR. + +## Data Augmentation + +Currently, the dataset only provides 300x300 RGB images. However, each trajectory can be replayed to save any additional info available from the simulator. See the [augment_trajectories.py](scripts/augment_trajectories.py) script as an example for saving 600x600 RGB, depth and instance segmentation masks from the existing dataset: + +```bash +python scripts/augment_trajectories.py --data_path data/json_2.1.0 --num_threads 2 --smooth_nav --time_delays +``` + +![](../media/aug.png) + +Note that these files consume a lot of storage space. + +## PDDL Tasks + +The goals for the planner are specified in [goal_library.py](goal_library.py). Here is a simple pick-and-place PDDL goal definition: + +``` +# basic pick and place (e.g: "put the apple in the microwave") +gdict["pick_and_place_simple"] = ''' + (:goal + (and + ;; make sure all the cabinets and doors are closed in the end + (forall (?re # receptacle) + (not (opened ?re)) + ) + + ;; make sure some object {obj} exists inside some receptacle {recep} + (exists (?r # receptacle) + (exists (?o # object) + (and + (inReceptacle ?o ?r) + (objectType ?o {obj}Type) + (receptacleType ?r {recep}Type) + ) + ) + ) + ) + ) +) +``` + diff --git a/models/main_models/rt1/gen/__init__.py b/models/main_models/rt1/gen/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/gen/agents/agent_base.py b/models/main_models/rt1/gen/agents/agent_base.py new file mode 100644 index 000000000..34cb3f725 --- /dev/null +++ b/models/main_models/rt1/gen/agents/agent_base.py @@ -0,0 +1,60 @@ +import copy +import time +import numpy as np + + +class AgentBase(object): + def __init__(self, thread_id=0, game_state=None): + assert(game_state is not None) + self.game_state = game_state + self.thread_id = thread_id + self.timers = np.zeros((2, 2)) + self.total_frame_count = 0 + self.current_frame_count = 0 + self.gt_graph = None + self.bounds = None + self.pose = None + self.terminal = False + self.num_invalid_actions = 0 + self.total_num_invalid_actions = 0 + + def setup_problem(self, game_state_problem_args, scene=None, objs=None): + self.game_state.setup_problem(**game_state_problem_args, scene=scene, objs=objs) + + def reset(self, game_state_reset_args, scene=None, objs=None): + self.game_state.reset(**game_state_reset_args, scene=scene, objs=objs) + + self.timers = np.zeros((2, 2)) + self.current_frame_count = 0 + self.gt_graph = None + self.bounds = None + self.pose = None + self.terminal = False + self.num_invalid_actions = 0 + + self.total_frame_count += 1 + self.gt_graph = self.game_state.gt_graph + self.bounds = self.game_state.bounds + self.pose = self.game_state.pose + + def step(self, action): + self.total_frame_count += 1 + self.current_frame_count += 1 + t_start = time.time() + self.game_state.step(action) + if not self.game_state.event.metadata['lastActionSuccess']: + self.num_invalid_actions += 1 + self.total_num_invalid_actions += 1 + self.timers[0, 0] += time.time() - t_start + self.timers[0, 1] += 1 + if self.timers[0, 1] % 100 == 0: + print('game state step time %.3f' % (self.timers[0, 0] / self.timers[0, 1])) + self.timers[0, :] = 0 + self.pose = self.game_state.pose + + def get_action(self, action_ind): + action = copy.deepcopy(self.game_state.action_space[action_ind]) + if action['action'] == 'End': + # Remove other arguments + action = {'action': 'End'} + return action diff --git a/models/main_models/rt1/gen/agents/deterministic_planner_agent.py b/models/main_models/rt1/gen/agents/deterministic_planner_agent.py new file mode 100644 index 000000000..b67e25457 --- /dev/null +++ b/models/main_models/rt1/gen/agents/deterministic_planner_agent.py @@ -0,0 +1,26 @@ +from agents.semantic_map_planner_agent import SemanticMapPlannerAgent + + +class DeterministicPlannerAgent(SemanticMapPlannerAgent): + def __init__(self, thread_id=0, game_state=None): + super(DeterministicPlannerAgent, self).__init__(thread_id, game_state) + self.action_sequence = None + self.question = None + + def reset(self, seed=None, info=None, scene=None, objs=None): + info = super(DeterministicPlannerAgent, self).reset(seed, info, scene=scene, objs=objs) + self.action_sequence = ['Plan', 'End'] + return info + + def step(self, action, executing_plan=False): + if not executing_plan: + self.action_sequence = self.action_sequence[1:] + super(DeterministicPlannerAgent, self).step(action) + + def get_action(self, action_ind=None): + assert(action_ind is None) + return {'action': self.action_sequence[0]} + + def get_reward(self): + return 0, self.terminal + diff --git a/models/main_models/rt1/gen/agents/plan_agent.py b/models/main_models/rt1/gen/agents/plan_agent.py new file mode 100644 index 000000000..eda12f215 --- /dev/null +++ b/models/main_models/rt1/gen/agents/plan_agent.py @@ -0,0 +1,94 @@ +import constants +from agents.agent_base import AgentBase +from game_states.planned_game_state import PlannedGameState +from utils import game_util + + +class PlanAgent(AgentBase): + def __init__(self, thread_id=0, game_state=None, controller_agent=None): + super(PlanAgent, self).__init__(thread_id, game_state) + assert(isinstance(game_state, PlannedGameState)) + self.controller_agent = controller_agent + self.planned = False + + def reset(self): + self.planned = False + + def execute_plan(self): + step_count = 0 + self.planned = True + self.controller_agent.planning = True + if constants.OPEN_LOOP: + plan = self.game_state.get_current_plan(force_update=True) + + if plan[0]['action'] == 'End': + raise ValueError('Empty plan is successful, no work to do') + + elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: + print ("Planning failed. Possibly because the goal was already satisfied") + raise ValueError("Symbolic Planning Failed") + + for idx, plan_action in enumerate(plan): + self.save_plan(plan, idx) + + if plan_action['action'] == 'GotoLocation': + plan_action = self.game_state.get_teleport_action(plan_action) + elif plan_action['action'] == 'End': + break + self.controller_agent.step(plan_action, executing_plan=True) + step_count += 1 + if self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH: + break + else: + past_plans = [] + plan = self.game_state.get_current_plan(force_update=True) + + if plan[0]['action'] == 'End': + raise ValueError('Empty plan is successful, no work to do') + elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: + print("Symbolic Planning Failed") + raise ValueError("Symbolic Planning Failed") + + plan_action = plan[0] + if constants.USE_DETERMINISTIC_CONTROLLER: + # Don't fail right away, just rotate a few times. + rotations = 0 + while rotations < 4 and (plan_action is None or plan_action['action'] == 'End'): + action = {'action': 'RotateLeft'} + self.controller_agent.step(action, executing_plan=True) + rotations += 1 + plan = self.game_state.get_current_plan(force_update=True) + plan_action = plan[0] + + while not(plan_action is None or plan_action['action'] == 'End'): + self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) + + # save data + self.save_plan(plan, 0) + + step_count += 1 + past_plans.append(plan) + if len(past_plans) > 5: + past_plans = past_plans[-5:] + plan = self.game_state.get_current_plan(force_update=True) + if plan[0]['action'] == 'End': + break + if (step_count >= constants.MAX_PLANNER_STEP_COUNT or + self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH): + # Too many steps, plan may be looping. + break + if len(plan) > 1 and any([plan == past_plan for past_plan in past_plans]): + plan_action = plan[0] + self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) + step_count += 1 + plan = plan[1:] + plan_action = plan[0] + + self.controller_agent.planning = False + + def save_plan(self, plan, idx=0): + plan_action = plan[idx] + constants.data_dict['plan']['high_pddl'].append({"high_idx": len(constants.data_dict['plan']['high_pddl']), + "planner_action": plan_action, + "discrete_action": game_util.get_discrete_hl_action(plan, idx)}) + constants.data_dict['template']['high_descs'].append(game_util.get_templated_action_str(plan, idx)) diff --git a/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py b/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py new file mode 100644 index 000000000..497ee242c --- /dev/null +++ b/models/main_models/rt1/gen/agents/semantic_map_planner_agent.py @@ -0,0 +1,72 @@ +import glob +import cv2 +import constants +from agents.agent_base import AgentBase +from agents.plan_agent import PlanAgent +from game_states.planned_game_state import PlannedGameState + + +class SemanticMapPlannerAgent(AgentBase): + def __init__(self, thread_id=0, game_state=None): + assert(isinstance(game_state, PlannedGameState)) + super(SemanticMapPlannerAgent, self).__init__(thread_id, game_state) + + self.plan_agent = PlanAgent(thread_id, game_state, self) + self.planning = False + + def reset(self, seed=None, info=None, scene=None, objs=None): + self.planning = False + info = self.game_state.get_setup_info(info, scene=scene)[0] + super(SemanticMapPlannerAgent, self).reset({'seed': seed, 'info': info}, scene=scene, objs=objs) + if self.plan_agent is not None: + self.plan_agent.reset() + return info + + def setup_problem(self, game_state_problem_args, scene=None, objs=None): + super(SemanticMapPlannerAgent, self).setup_problem(game_state_problem_args, scene=scene, objs=objs) + self.pose = self.game_state.pose + + def get_reward(self): + raise NotImplementedError + + def step(self, action, executing_plan=False): + if action['action'] == 'End': + self.current_frame_count += 1 + self.total_frame_count += 1 + self.terminal = True + + if constants.RECORD_VIDEO_IMAGES: + im_ind = len(glob.glob(constants.save_path + '/*.png')) + for _ in range(10): + cv2.imwrite(constants.save_path + '/%09d.png' % im_ind, + self.game_state.s_t[:, :, ::-1]) + im_ind += 1 + else: + if 'Teleport' in action['action']: + start_pose = self.pose + end_angle = action['horizon'] + end_pose = (int(action['x'] / constants.AGENT_STEP_SIZE), + int(action['z'] / constants.AGENT_STEP_SIZE), + int(action['rotation'] / 90), + int(end_angle)) + + self.game_state.gt_graph.navigate_to_goal(self.game_state, start_pose, end_pose) + self.pose = self.game_state.pose + elif action['action'] == 'Plan': + self.plan_agent.execute_plan() + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + elif action['action'] == 'Scan': + self.game_state.step(action) + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + elif action['action'] == 'Explore': + if not constants.EVAL: + self.current_frame_count += 1 + self.total_frame_count += 1 + else: + super(SemanticMapPlannerAgent, self).step(action) + + diff --git a/models/main_models/rt1/gen/constants.py b/models/main_models/rt1/gen/constants.py new file mode 100644 index 000000000..e646c660d --- /dev/null +++ b/models/main_models/rt1/gen/constants.py @@ -0,0 +1,1221 @@ +from collections import OrderedDict + +######################################################################################################################## +# General Settings + +DEBUG = True +EVAL = False +LOG_FILE = 'logs_gen' + +RECORD_VIDEO_IMAGES = True +RECORD_SMOOTHING_FACTOR = 1 +DATA_SAVE_PATH = "dataset/new_trajectories" + +OPEN_LOOP = True +FULL_OBSERVABLE_STATE = True + +######################################################################################################################## +# Generation Ablations + +MAX_NUM_OF_OBJ_INSTANCES = 3 # when randomly initializing the scene, create duplicate instance up to this number +PICKUP_REPEAT_MAX = 4 # how many of the target pickup object to generate in [1, MAX] (randomly chosen) +RECEPTACLE_SPARSE_POINTS = 50 # increment for how many points to leave free for sparsely populated receptacles +RECEPTACLE_EMPTY_POINTS = 200 # increment for how many points to leave free for empty receptacles + +MIN_VISIBLE_RATIO = 0.0011 # minimum area ratio (with respect to image size) of visible object +PLANNER_MAX_STEPS = 100 # if the generated plan is more than these steps, discard the traj +MAX_EPISODE_LENGTH = 1000 # maximum number of API steps allowed per trajectory + +FORCED_SAMPLING = False # set True for debugging instead of proper sampling +PRUNE_UNREACHABLE_POINTS = True # prune navigation points that were deemed unreachable by the proprocessing script + +######################################################################################################################## +# Goals + +GOALS = [ + "pick_and_place_simple", + "pick_two_obj_and_place", + "look_at_obj_in_light", + "pick_clean_then_place_in_recep", + "pick_heat_then_place_in_recep", + "pick_cool_then_place_in_recep", + "pick_and_place_with_movable_recep", + ] +GOALS_VALID = {"pick_and_place_simple": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, + "pick_two_obj_and_place": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, + "look_at_obj_in_light": {"LivingRoom", "Bedroom"}, + "pick_clean_then_place_in_recep": {"Kitchen", "Bathroom"}, + "pick_heat_then_place_in_recep": {"Kitchen"}, + "pick_cool_then_place_in_recep": {"Kitchen"}, + "pick_and_place_with_movable_recep": {"Kitchen", "LivingRoom", "Bedroom"}} + +pddl_goal_type = "pick_and_place_simple" # default goal type + +######################################################################################################################## +# Video Settings + +# filler frame IDs +BEFORE = 0 +MIDDLE = 1 +AFTER = 2 + +# number of image frames to save before and after executing the specified action +SAVE_FRAME_BEFORE_AND_AFTER_COUNTS = { + 'OpenObject': [2, 0, 2], + 'CloseObject': [2, 0, 2], + 'PickupObject': [5, 0, 10], + 'PutObject': [5, 0, 10], + 'CleanObject': [3, 0, 5], + 'HeatObject': [3, 0, 5], + 'CoolObject': [3, 30, 5], + 'ToggleObjectOn': [3, 0, 15], + 'ToggleObjectOff': [1, 0, 5], + 'SliceObject': [3, 0, 7] +} + +# FPS +VIDEO_FRAME_RATE = 5 + +######################################################################################################################## +# Data & Storage + +save_path = DATA_SAVE_PATH +data_dict = OrderedDict() # dictionary for storing trajectory data to be dumped + +######################################################################################################################## +# Unity Hyperparameters + +BUILD_PATH = None +X_DISPLAY = '0' + +AGENT_STEP_SIZE = 0.25 +AGENT_HORIZON_ADJ = 30 +AGENT_ROTATE_ADJ = 90 +CAMERA_HEIGHT_OFFSET = 0.75 +VISIBILITY_DISTANCE = 1.5 +HORIZON_GRANULARITY = 30 + +RENDER_IMAGE = True +RENDER_DEPTH_IMAGE = True +RENDER_CLASS_IMAGE = True +RENDER_OBJECT_IMAGE = True + +MAX_DEPTH = 5000 +STEPS_AHEAD = 5 +SCENE_PADDING = STEPS_AHEAD * 3 +SCREEN_WIDTH = DETECTION_SCREEN_WIDTH = 300 +SCREEN_HEIGHT = DETECTION_SCREEN_HEIGHT = 300 +MIN_VISIBLE_PIXELS = 10 + +# (400) / (600*600) ~ 0.13% area of image +# int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float(DETECTION_SCREEN_HEIGHT)) +# MIN_VISIBLE_PIXELS = int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float( +# DETECTION_SCREEN_HEIGHT)) # (400) / (600*600) ~ 0.13% area of image + +######################################################################################################################## +# Scenes and Objects + +TRAIN_SCENE_NUMBERS = list(range(7, 31)) # Train Kitchens (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(207, 231))) # Train Living Rooms (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(307, 331))) # Train Bedrooms (24/30) +TRAIN_SCENE_NUMBERS.extend(list(range(407, 431))) # Train Bathrooms (24/30) + +TEST_SCENE_NUMBERS = list(range(1, 7)) # Test Kitchens (6/30) +TEST_SCENE_NUMBERS.extend(list(range(201, 207))) # Test Living Rooms (6/30) +TEST_SCENE_NUMBERS.extend(list(range(301, 307))) # Test Bedrooms (6/30) +TEST_SCENE_NUMBERS.extend(list(range(401, 407))) # Test Bathrooms (6/30) + +SCENE_NUMBERS = TRAIN_SCENE_NUMBERS + TEST_SCENE_NUMBERS + +# Scene types. +SCENE_TYPE = {"Kitchen": range(1, 31), + "LivingRoom": range(201, 231), + "Bedroom": range(301, 331), + "Bathroom": range(401, 431)} + +OBJECTS = [ + 'AlarmClock', + 'Apple', + 'ArmChair', + 'BaseballBat', + 'BasketBall', + 'Bathtub', + 'BathtubBasin', + 'Bed', + 'Blinds', + 'Book', + 'Boots', + 'Bowl', + 'Box', + 'Bread', + 'ButterKnife', + 'Cabinet', + 'Candle', + 'Cart', + 'CD', + 'CellPhone', + 'Chair', + 'Cloth', + 'CoffeeMachine', + 'CounterTop', + 'CreditCard', + 'Cup', + 'Curtains', + 'Desk', + 'DeskLamp', + 'DishSponge', + 'Drawer', + 'Dresser', + 'Egg', + 'FloorLamp', + 'Footstool', + 'Fork', + 'Fridge', + 'GarbageCan', + 'Glassbottle', + 'HandTowel', + 'HandTowelHolder', + 'HousePlant', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'LaundryHamper', + 'LaundryHamperLid', + 'Lettuce', + 'LightSwitch', + 'Microwave', + 'Mirror', + 'Mug', + 'Newspaper', + 'Ottoman', + 'Painting', + 'Pan', + 'PaperTowel', + 'PaperTowelRoll', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Pillow', + 'Plate', + 'Plunger', + 'Poster', + 'Pot', + 'Potato', + 'RemoteControl', + 'Safe', + 'SaltShaker', + 'ScrubBrush', + 'Shelf', + 'ShowerDoor', + 'ShowerGlass', + 'Sink', + 'SinkBasin', + 'SoapBar', + 'SoapBottle', + 'Sofa', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'StoveBurner', + 'StoveKnob', + 'DiningTable', + 'CoffeeTable', + 'SideTable', + 'TeddyBear', + 'Television', + 'TennisRacket', + 'TissueBox', + 'Toaster', + 'Toilet', + 'ToiletPaper', + 'ToiletPaperHanger', + 'ToiletPaperRoll', + 'Tomato', + 'Towel', + 'TowelHolder', + 'TVStand', + 'Vase', + 'Watch', + 'WateringCan', + 'Window', + 'WineBottle', +] + +OBJECTS_LOWER_TO_UPPER = {obj.lower(): obj for obj in OBJECTS} + +OBJECTS_SINGULAR = [ + 'alarmclock', + 'apple', + 'armchair', + 'baseballbat', + 'basketball', + 'bathtub', + 'bathtubbasin', + 'bed', + 'blinds', + 'book', + 'boots', + 'bowl', + 'box', + 'bread', + 'butterknife', + 'cabinet', + 'candle', + 'cart', + 'cd', + 'cellphone', + 'chair', + 'cloth', + 'coffeemachine', + 'countertop', + 'creditcard', + 'cup', + 'curtains', + 'desk', + 'desklamp', + 'dishsponge', + 'drawer', + 'dresser', + 'egg', + 'floorlamp', + 'footstool', + 'fork', + 'fridge', + 'garbagecan', + 'glassbottle', + 'handtowel', + 'handtowelholder', + 'houseplant', + 'kettle', + 'keychain', + 'knife', + 'ladle', + 'laptop', + 'laundryhamper', + 'laundryhamperlid', + 'lettuce', + 'lightswitch', + 'microwave', + 'mirror', + 'mug', + 'newspaper', + 'ottoman', + 'painting', + 'pan', + 'papertowel', + 'papertowelroll', + 'pen', + 'pencil', + 'peppershaker', + 'pillow', + 'plate', + 'plunger', + 'poster', + 'pot', + 'potato', + 'remotecontrol', + 'safe', + 'saltshaker', + 'scrubbrush', + 'shelf', + 'showerdoor', + 'showerglass', + 'sink', + 'sinkbasin', + 'soapbar', + 'soapbottle', + 'sofa', + 'spatula', + 'spoon', + 'spraybottle', + 'statue', + 'stoveburner', + 'stoveknob', + 'diningtable', + 'coffeetable', + 'sidetable' + 'teddybear', + 'television', + 'tennisracket', + 'tissuebox', + 'toaster', + 'toilet', + 'toiletpaper', + 'toiletpaperhanger', + 'toiletpaperroll', + 'tomato', + 'towel', + 'towelholder', + 'tvstand', + 'vase', + 'watch', + 'wateringcan', + 'window', + 'winebottle', +] + +OBJECTS_PLURAL = [ + 'alarmclocks', + 'apples', + 'armchairs', + 'baseballbats', + 'basketballs', + 'bathtubs', + 'bathtubbasins', + 'beds', + 'blinds', + 'books', + 'boots', + 'bottles', + 'bowls', + 'boxes', + 'bread', + 'butterknives', + 'cabinets', + 'candles', + 'carts', + 'cds', + 'cellphones', + 'chairs', + 'cloths', + 'coffeemachines', + 'countertops', + 'creditcards', + 'cups', + 'curtains', + 'desks', + 'desklamps', + 'dishsponges', + 'drawers', + 'dressers', + 'eggs', + 'floorlamps', + 'footstools', + 'forks', + 'fridges', + 'garbagecans', + 'glassbottles', + 'handtowels', + 'handtowelholders', + 'houseplants', + 'kettles', + 'keychains', + 'knives', + 'ladles', + 'laptops', + 'laundryhampers', + 'laundryhamperlids', + 'lettuces', + 'lightswitches', + 'microwaves', + 'mirrors', + 'mugs', + 'newspapers', + 'ottomans', + 'paintings', + 'pans', + 'papertowels', + 'papertowelrolls', + 'pens', + 'pencils', + 'peppershakers', + 'pillows', + 'plates', + 'plungers', + 'posters', + 'pots', + 'potatoes', + 'remotecontrollers', + 'safes', + 'saltshakers', + 'scrubbrushes', + 'shelves', + 'showerdoors', + 'showerglassess', + 'sinks', + 'sinkbasins', + 'soapbars', + 'soapbottles', + 'sofas', + 'spatulas', + 'spoons', + 'spraybottles', + 'statues', + 'stoveburners', + 'stoveknobs', + 'diningtables', + 'coffeetables', + 'sidetable', + 'teddybears', + 'televisions', + 'tennisrackets', + 'tissueboxes', + 'toasters', + 'toilets', + 'toiletpapers', + 'toiletpaperhangers', + 'toiletpaperrolls', + 'tomatoes', + 'towels', + 'towelholders', + 'tvstands', + 'vases', + 'watches', + 'wateringcans', + 'windows', + 'winebottles', +] + +MOVABLE_RECEPTACLES = [ + 'Bowl', + 'Box', + 'Cup', + 'Mug', + 'Plate', + 'Pan', + 'Pot', +] + +MOVABLE_RECEPTACLES_SET = set(MOVABLE_RECEPTACLES) +OBJECTS_SET = set(OBJECTS) | MOVABLE_RECEPTACLES_SET + +OBJECT_CLASS_TO_ID = {obj: ii for (ii, obj) in enumerate(OBJECTS)} + +RECEPTACLES = { + 'BathtubBasin', + 'Bowl', + 'Cup', + 'Drawer', + 'Mug', + 'Plate', + 'Shelf', + 'SinkBasin', + 'Box', + 'Cabinet', + 'CoffeeMachine', + 'CounterTop', + 'Fridge', + 'GarbageCan', + 'HandTowelHolder', + 'Microwave', + 'PaintingHanger', + 'Pan', + 'Pot', + 'StoveBurner', + 'DiningTable', + 'CoffeeTable', + 'SideTable', + 'ToiletPaperHanger', + 'TowelHolder', + 'Safe', + 'BathtubBasin', + 'ArmChair', + 'Toilet', + 'Sofa', + 'Ottoman', + 'Dresser', + 'LaundryHamper', + 'Desk', + 'Bed', + 'Cart', + 'TVStand', + 'Toaster', + } + +NON_RECEPTACLES = OBJECTS_SET - RECEPTACLES + +NUM_RECEPTACLES = len(RECEPTACLES) +NUM_CLASSES = len(OBJECTS) + +# For generating questions +QUESTION_OBJECT_CLASS_LIST = [ + 'Spoon', + 'Potato', + 'Fork', + 'Plate', + 'Egg', + 'Tomato', + 'Bowl', + 'Lettuce', + 'Apple', + 'Knife', + 'Container', + 'Bread', + 'Mug', +] + +VAL_RECEPTACLE_OBJECTS = { + 'Pot': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Pan': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Bowl': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'RemoteControl', + 'Watch'}, + 'CoffeeMachine': {'Mug'}, + 'Microwave': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Glassbottle', + 'Mug', + 'Plate', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced'}, + 'StoveBurner': {'Kettle', + 'Pan', + 'Pot'}, + 'Fridge': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Glassbottle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced', + 'WineBottle'}, + 'Mug': {'ButterKnife', + 'Fork', + 'Knife', + 'Pen', + 'Pencil', + 'Spoon', + 'KeyChain', + 'Watch'}, + 'Plate': {'Apple', + 'AppleSliced', + 'ButterKnife', + 'DishSponge', + 'Egg', + 'Fork', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Potato', + 'PotatoSliced', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'AlarmClock', + 'Book', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Glassbottle', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'TissueBox', + 'Watch'}, + 'Cup': {'ButterKnife', + 'Fork', + 'Spoon'}, + 'Sofa': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'ArmChair': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'Box': {'AlarmClock', + 'Book', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Glassbottle', + 'KeyChain', + 'Mug', + 'PaperTowel', + 'Pen', + 'Pencil', + 'RemoteControl', + 'Statue', + 'TissueBox', + 'Vase', + 'Watch'}, + 'Ottoman': {'BasketBall', + 'Book', + 'Box', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'KeyChain', + 'Laptop', + 'Newspaper', + 'Pillow', + 'RemoteControl'}, + 'Dresser': {'AlarmClock', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'Glassbottle', + 'KeyChain', + 'Laptop', + 'Mug', + 'Newspaper', + 'Pen', + 'Pencil', + 'Plate', + 'RemoteControl', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle'}, + 'LaundryHamper': {'Cloth'}, + 'Desk': {'AlarmClock', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'Glassbottle', + 'KeyChain', + 'Laptop', + 'Mug', + 'Newspaper', + 'Pen', + 'Pencil', + 'Plate', + 'RemoteControl', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle'}, + 'Bed': {'BaseballBat', + 'BasketBall', + 'Book', + 'CellPhone', + 'Laptop', + 'Newspaper', + 'Pillow', + 'TennisRacket'}, + 'Toilet': {'Candle', + 'Cloth', + 'DishSponge', + 'Newspaper', + 'PaperTowel', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'HandTowel'}, + 'ToiletPaperHanger': {'ToiletPaper', + 'ToiletPaperRoll'}, + 'TowelHolder': {'Towel'}, + 'HandTowelHolder': {'HandTowel'}, + 'Cart': {'Candle', + 'Cloth', + 'DishSponge', + 'Mug', + 'PaperTowel', + 'Plunger', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'HandTowel'}, + 'BathtubBasin': {'Cloth', + 'DishSponge', + 'SoapBar', + 'HandTowel'}, + 'SinkBasin': {'Apple', + 'AppleSliced', + 'Bowl', + 'ButterKnife', + 'Cloth', + 'Cup', + 'DishSponge', + 'Egg', + 'Glassbottle', + 'Fork', + 'Kettle', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced', + 'HandTowel'}, + 'Cabinet': {'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'Cloth', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Kettle', + 'Ladle', + 'Mug', + 'Newspaper', + 'Pan', + 'PepperShaker', + 'Plate', + 'Plunger', + 'Pot', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'TableTop': {'AlarmClock', + 'Apple', + 'AppleSliced', + 'BaseballBat', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Bread', + 'BreadSliced', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Egg', + 'Fork', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Newspaper', + 'Pan', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'CounterTop': {'AlarmClock', + 'Apple', + 'AppleSliced', + 'BaseballBat', + 'BasketBall', + 'Book', + 'Bowl', + 'Box', + 'Bread', + 'BreadSliced', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Egg', + 'Glassbottle', + 'Fork', + 'Kettle', + 'KeyChain', + 'Knife', + 'Ladle', + 'Laptop', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Newspaper', + 'Pan', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'Statue', + 'TennisRacket', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'Shelf': {'AlarmClock', + 'Book', + 'Bowl', + 'Box', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'Cup', + 'DishSponge', + 'Glassbottle', + 'Kettle', + 'KeyChain', + 'Mug', + 'Newspaper', + 'PaperTowel', + 'Pen', + 'Pencil', + 'PepperShaker', + 'Plate', + 'Pot', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'Statue', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Vase', + 'Watch', + 'WateringCan', + 'WineBottle', + 'HandTowel'}, + 'Drawer': {'Book', + 'ButterKnife', + 'Candle', + 'CD', + 'CellPhone', + 'Cloth', + 'CreditCard', + 'DishSponge', + 'Fork', + 'KeyChain', + 'Knife', + 'Ladle', + 'Newspaper', + 'Pen', + 'Pencil', + 'PepperShaker', + 'RemoteControl', + 'SaltShaker', + 'SoapBar', + 'SoapBottle', + 'Spatula', + 'Spoon', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Watch', + 'WateringCan', + 'HandTowel'}, + 'GarbageCan': {'Apple', + 'AppleSliced', + 'Bread', + 'BreadSliced', + 'CD', + 'Cloth', + 'DishSponge', + 'Egg', + 'Lettuce', + 'LettuceSliced', + 'Newspaper', + 'PaperTowel', + 'Pen', + 'Pencil', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'SoapBottle', + 'SprayBottle', + 'TissueBox', + 'ToiletPaper', + 'ToiletPaperRoll', + 'Tomato', + 'TomatoSliced', + 'WineBottle', + 'HandTowel'}, + 'Safe': {'CD', + 'CellPhone', + 'CreditCard', + 'KeyChain', + 'Statue', + 'Vase', + 'Watch'}, + 'TVStand': {'TissueBox'}, + 'Toaster': {'BreadSliced'}, +} +VAL_RECEPTACLE_OBJECTS['DiningTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +VAL_RECEPTACLE_OBJECTS['CoffeeTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +VAL_RECEPTACLE_OBJECTS['SideTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] +del VAL_RECEPTACLE_OBJECTS['TableTop'] + +NON_RECEPTACLES_SET = (OBJECTS_SET - set(VAL_RECEPTACLE_OBJECTS.keys())) | set(MOVABLE_RECEPTACLES) + +VAL_ACTION_OBJECTS = { + 'Heatable': {'Apple', + 'AppleSliced', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Mug', + 'Plate', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced'}, + 'Coolable': {'Apple', + 'AppleSliced', + 'Bowl', + 'Bread', + 'BreadSliced', + 'Cup', + 'Egg', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'Tomato', + 'TomatoSliced', + 'WineBottle'}, + 'Cleanable': {'Apple', + 'AppleSliced', + 'Bowl', + 'ButterKnife', + 'Cloth', + 'Cup', + 'DishSponge', + 'Egg', + 'Fork', + 'Kettle', + 'Knife', + 'Ladle', + 'Lettuce', + 'LettuceSliced', + 'Mug', + 'Pan', + 'Plate', + 'Pot', + 'Potato', + 'PotatoSliced', + 'SoapBar', + 'Spatula', + 'Spoon', + 'Tomato', + 'TomatoSliced'}, + 'Toggleable': {'DeskLamp', + 'FloorLamp'}, + 'Sliceable': {'Apple', + 'Bread', + 'Egg', + 'Lettuce', + 'Potato', + 'Tomato'} +} + +# object parents +OBJ_PARENTS = {obj: obj for obj in OBJECTS} +OBJ_PARENTS['AppleSliced'] = 'Apple' +OBJ_PARENTS['BreadSliced'] = 'Bread' +OBJ_PARENTS['LettuceSliced'] = 'Lettuce' +OBJ_PARENTS['PotatoSliced'] = 'Potato' +OBJ_PARENTS['TomatoSliced'] = 'Tomato' + +# force a different horizon view for objects of (type, location). If the location is None, force this horizon for all +# objects of that type. +FORCED_HORIZON_OBJS = { + ('FloorLamp', None): 0, + ('Fridge', 18): 30, + ('Toilet', None): 15, +} + +# openable objects with fixed states for transport. +FORCED_OPEN_STATE_ON_PICKUP = { + 'Laptop': False, +} + +# list of openable classes. +OPENABLE_CLASS_LIST = ['Fridge', 'Cabinet', 'Microwave', 'Drawer', 'Safe', 'Box'] +OPENABLE_CLASS_SET = set(OPENABLE_CLASS_LIST) + +######################################################################################################################## \ No newline at end of file diff --git a/models/main_models/rt1/gen/ff_planner/README.md b/models/main_models/rt1/gen/ff_planner/README.md new file mode 100644 index 000000000..81bc18c0f --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/README.md @@ -0,0 +1,13 @@ +# Metric FF Planner +Credit: https://fai.cs.uni-saarland.de/hoffmann/metric-ff.html. +Specifically this uses the Metric-FF Version 2.1 (https://fai.cs.uni-saarland.de/hoffmann/ff/Metric-FF-v2.1.tgz). + +Note that the code here is not exactly the same as the one you can download from that website. +Their code had issues that threw segfaults which I was able to fix for this project. +It is possible that my changes caused some other issues that I am unaware of. + +To compile: +```bash +$ cd +$ make +``` diff --git a/models/main_models/rt1/gen/ff_planner/expressions.c b/models/main_models/rt1/gen/ff_planner/expressions.c new file mode 100644 index 000000000..8fb8d2404 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/expressions.c @@ -0,0 +1,2623 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/*********************************************************************** + * File: expressions.c + * Description: functions for handling numerical expressions + * + * - general utilities: + * comparisons between numbers etc. + * + * - LNF compilation: + * normalization of expressions + * translation of subtractions + * + * - LNF post-processing: + * summarization of effects + * encoding of non-minimal LNFs + * + * Author: Joerg Hoffmann 2001 + * + *********************************************************************/ + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + + + + + + + + + + + + + + + +/******************************************************* + * SIMPLE UTILITIES + *******************************************************/ + + + + + + + + + + + + + + + + +Bool number_comparison_holds( Comparator c, float l, float r ) + +{ + + switch ( c ) { + case LE: + if ( l < r ) return TRUE; + break; + case LEQ: + if ( l <= r ) return TRUE; + break; + case EQ: + if ( l == r ) return TRUE; + break; + case GEQ: + if ( l >= r ) return TRUE; + break; + case GE: + if ( l > r ) return TRUE; + break; + case IGUAL: + /* technical for non-required fluents + */ + return TRUE; + default: + printf("\n\nillegal comparator %d in number comp holds", c); + exit( 1 ); + } + + return FALSE; + +} + + + + + + + + + + + + + + + + + + + + + +/******************************************************* + * MACHINERY FOR LNF TRANSFORMATION!!!!!! + *******************************************************/ + + + + + + + + + + + + + + + + + + + + + + + + +Bool transform_to_LNF( void ) + +{ + + if ( !is_linear_task() ) { + return FALSE; + } + + normalize_expressions(); + if ( gcmd_line.display_info == 121 ) { + printf("\n\nnormalized expressions representation is:\n\n"); + print_lnf_representation(); + } + + translate_subtractions(); + if ( gcmd_line.display_info == 122 ) { + printf("\n\nLNF : translated subtractions representation is:\n\n"); + print_lnf_representation(); + } + + /* LNF computed. start post-processing. + */ + + /* do same-cond effects etc. summarization here so as to have + * as tight as possible an encoded LNF representation. + */ + summarize_effects(); + if ( gcmd_line.display_info == 123 ) { + printf("\n\nLNF - summarized effects representation is:\n\n"); + print_lnf_representation(); + } + + encode_lfns_as_artificial_fluents(); + /* optimization is translated into minimizing + * effect costs... here, determine the cost that + * each effect has. + * + * returns TRUE if a non-trivial optimization expression + * could be established. + */ + if ( setup_effect_costs() ) { + if ( gcmd_line.display_info > 1 ) { + printf("\nmetric established (normalized to minimize): "); + print_LnfExpNode( &glnf_metric ); + } + goptimization_established = TRUE; + } + if ( gcmd_line.display_info == 124 ) { + printf("\n\nencoded LNF representation is:\n\n"); + print_lnf_representation(); + } + + return TRUE; + +} + + + +/* simple syntax check + */ +Bool is_linear_task( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( a = gactions; a; a = a->next ) { + /* preconds + */ + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( !is_linear_expression( a->numeric_preconds_lh[i] ) ) { + return FALSE; + } + if ( !is_linear_expression( a->numeric_preconds_rh[i] ) ) { + return FALSE; + } + } + + /* effects + */ + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( !is_linear_expression( e->numeric_conditions_lh[j] ) ) { + return FALSE; + } + if ( !is_linear_expression( e->numeric_conditions_rh[j] ) ) { + return FALSE; + } + } + + if ( e->illegal ) { + /* we don't care whether that one's ok or not- + * it won't be applied anyway. + */ + continue; + } + + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( e->numeric_effects_neft[j] != INCREASE && + e->numeric_effects_neft[j] != DECREASE && + e->numeric_effects_neft[j] != ASSIGN ) { + return FALSE; + } + if ( !is_linear_expression( e->numeric_effects_rh[j] ) ) { + return FALSE; + } + } + } + } + + /* goal condition also... + */ + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( !is_linear_expression( gnumeric_goal_lh[i] ) ) { + return FALSE; + } + if ( !is_linear_expression( gnumeric_goal_rh[i] ) ) { + return FALSE; + } + } + + if ( gmetric != NULL ) { + if ( !is_linear_expression( gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: metric is no linear expression. defaulting to plan length."); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + } + + return TRUE; + +} + + + +Bool is_linear_expression( ExpNode *n ) + +{ + + switch ( n->connective ) { + case MU: + if ( !is_linear_expression( n->leftson ) || + !is_linear_expression( n->rightson ) ) { + return FALSE; + } + if ( n->leftson->connective != NUMBER && + n->rightson->connective != NUMBER ) { + return FALSE; + } + break; + case DI: + if ( !is_linear_expression( n->leftson ) || + n->rightson->connective != NUMBER ) { + return FALSE; + } + break; + case AD: + case SU: + if ( !is_linear_expression( n->leftson ) || + !is_linear_expression( n->rightson ) ) { + return FALSE; + } + break; + case MINUS: + if ( !is_linear_expression( n->son ) ) { + return FALSE; + } + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\nis linear exp: wrong specifier %d", + n->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void print_lnf_representation( void ) + +{ + + int i; + Action *a; + + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( !a->norm_operator && + !a->pseudo_action ) || + ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + print_lnf_Action( a ); + } + } + printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); + for ( a = gactions; a; a = a->next ) { + if ( !a->norm_operator && + !a->pseudo_action ) { + print_lnf_Action( a ); + } + } + + printf("\n\ninitial state is:\n\n"); + print_State( ginitial_state ); + + printf("\n\ngoal is:\n\n"); + for ( i = 0; i < gnum_logic_goal; i++ ) { + print_ft_name( glogic_goal[i] ); + printf("\n"); + } + for ( i = 0; i < gnum_lnf_goal; i++ ) { + switch ( glnf_goal_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator in lnf goal %d\n\n", glnf_goal_comp[i]); + exit( 1 ); + } + print_LnfExpNode( glnf_goal_lh[i] ); + printf(" %f", glnf_goal_rh[i]); + printf(")\n"); + } + + if ( gmetric ) { + printf("\n\nmetric is (minimize) (constant part skipped):\n"); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + +} + + + + + + + + + + + + + + + + + + +/******************************************************* + * SUBPART I: NORMALIZE THE EXPRESSIONS + *******************************************************/ + + + + + + + + + + + + + + + + + +/* local globals. + */ + +Comparator lcomp; + +int lF[MAX_LNF_F]; +float lC[MAX_LNF_F]; +int lnum_F; + +float lc; + + + + + + + + + + + +void normalize_expressions( void ) + +{ + + Action *a, *p, *t; + ActionEffect *e; + int i, j, k; + Bool eq; + LnfExpNode *lnf; + + /* first, pre-normalize all the expressions, i.e. translate + * divisions, and push muliplications downwards. + */ + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( !translate_divisions( &(gnumeric_goal_lh[i]) ) ) { + printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); + exit( 1 ); + } + push_multiplications_down( &(gnumeric_goal_lh[i]) ); + if ( !translate_divisions( &(gnumeric_goal_rh[i]) ) ) { + printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); + exit( 1 ); + } + push_multiplications_down( &(gnumeric_goal_rh[i]) ); + } + + a = gactions; p = NULL; + while ( a ) { + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( !translate_divisions( &(a->numeric_preconds_lh[i]) ) ) break; + push_multiplications_down( &(a->numeric_preconds_lh[i]) ); + if ( !translate_divisions( &(a->numeric_preconds_rh[i]) ) ) break; + push_multiplications_down( &(a->numeric_preconds_rh[i]) ); + } + if ( i < a->num_numeric_preconds ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in precond of "); + print_Action_name( a ); + printf(". skipping action."); + } + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( !translate_divisions( &(e->numeric_conditions_lh[j]) ) ) break; + push_multiplications_down( &(e->numeric_conditions_lh[j]) ); + if ( !translate_divisions( &(e->numeric_conditions_rh[j]) ) ) break; + push_multiplications_down( &(e->numeric_conditions_rh[j]) ); + } + if ( j < e->num_numeric_conditions ) break; + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( !translate_divisions( &(e->numeric_effects_rh[j]) ) ) break; + push_multiplications_down( &(e->numeric_effects_rh[j]) ); + } + if ( j < e->num_numeric_effects ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in effect rh of "); + print_Action_name( a ); + printf(". marking effect as illegal."); + } + e->illegal = TRUE; + } + } + if ( i < a->num_effects ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in effect cond of "); + print_Action_name( a ); + printf(". skipping action."); + } + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + + p = a; + a = a->next; + } + if ( gmetric != NULL ) { + if ( !translate_divisions( &gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: division by zero in metric. replaced with plan length."); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + push_multiplications_down( &gmetric ); + } + + /* now, collect the normalized representations of all expressions. + */ + for ( a = gactions; a; a = a->next ) { + /* preconds + */ + a->lnf_preconds_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + a->lnf_preconds_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + a->lnf_preconds_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + a->num_lnf_preconds = 0; + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( a->numeric_preconds_comp[i] == EQ ) { + eq = TRUE; + a->numeric_preconds_comp[i] = LEQ; + } + put_comp_into_normalized_locals( a->numeric_preconds_comp[i], + a->numeric_preconds_lh[i], + a->numeric_preconds_rh[i] ); + a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; + a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); + lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + a->lnf_preconds_rh[a->num_lnf_preconds] = lc; + a->num_lnf_preconds++; + if ( eq ) { + if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + a->numeric_preconds_comp[i] = EQ; + put_comp_into_normalized_locals( GEQ, + a->numeric_preconds_lh[i], + a->numeric_preconds_rh[i] ); + a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; + a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); + lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + a->lnf_preconds_rh[a->num_lnf_preconds] = lc; + a->num_lnf_preconds++; + } + } + + /* effects + */ + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + e->lnf_conditions_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + e->lnf_conditions_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + e->lnf_conditions_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + e->num_lnf_conditions = 0; + for ( j = 0; j < e->num_numeric_conditions; j++ ) { + if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( e->numeric_conditions_comp[j] == EQ ) { + eq = TRUE; + e->numeric_conditions_comp[j] = LEQ; + } + put_comp_into_normalized_locals( e->numeric_conditions_comp[j], + e->numeric_conditions_lh[j], + e->numeric_conditions_rh[j] ); + e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; + e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); + lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_conditions_rh[e->num_lnf_conditions] = lc; + e->num_lnf_conditions++; + if ( eq ) { + if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + e->numeric_conditions_comp[j] = EQ; + put_comp_into_normalized_locals( GEQ, + e->numeric_conditions_lh[j], + e->numeric_conditions_rh[j] ); + e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; + e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); + lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_conditions_rh[e->num_lnf_conditions] = lc; + e->num_lnf_conditions++; + } + } + + if ( e->illegal ) { + /* we do have the LNF to know whether the effect appears. + * if it does, then this one is illegal anyway, remembered + * in inst final due to undefined fl access. + * + * if it is LEGAL, then all fluents we're gonna find and + * collect below are relevant!!! + */ + continue; + } + + e->lnf_effects_neft = ( NumericEffectType * ) calloc( MAX_LNF_EFFS, sizeof( NumericEffectType ) ); + e->lnf_effects_fl = ( int * ) calloc( MAX_LNF_EFFS, sizeof( int ) ); + e->lnf_effects_rh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_EFFS, sizeof( LnfExpNode_pointer ) ); + e->num_lnf_effects = 0; + for ( j = 0; j < e->num_numeric_effects; j++ ) { + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e->numeric_effects_neft[j]; + e->lnf_effects_fl[e->num_lnf_effects] = e->numeric_effects_fl[j]; + lnum_F = 0; + lc = 0; + if ( e->lnf_effects_neft[e->num_lnf_effects] == DECREASE ) { + collect_normalized_locals( e->numeric_effects_rh[j], FALSE ); + e->lnf_effects_neft[e->num_lnf_effects] = INCREASE; + } else { + collect_normalized_locals( e->numeric_effects_rh[j], TRUE ); + } + e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); + lnf = e->lnf_effects_rh[e->num_lnf_effects]; + for ( k = 0; k < lnum_F; k++ ) { + if ( lC[k] == 0 ) continue; + if ( lC[k] > 0 ) { + lnf->pF[lnf->num_pF] = lF[k]; + lnf->pC[lnf->num_pF++] = lC[k]; + } else { + lnf->nF[lnf->num_nF] = lF[k]; + lnf->nC[lnf->num_nF++] = (-1) * lC[k]; + } + } + e->lnf_effects_rh[e->num_lnf_effects]->c = lc; + e->num_lnf_effects++; + } + } + } + + /* goal condition also... + */ + glnf_goal_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); + glnf_goal_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); + glnf_goal_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); + gnum_lnf_goal = 0; + for ( i = 0; i < gnum_numeric_goal; i++ ) { + if ( gnum_lnf_goal == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + eq = FALSE; + if ( gnumeric_goal_comp[i] == EQ ) { + eq = TRUE; + gnumeric_goal_comp[i] = LEQ; + } + put_comp_into_normalized_locals( gnumeric_goal_comp[i], + gnumeric_goal_lh[i], + gnumeric_goal_rh[i] ); + glnf_goal_comp[gnum_lnf_goal] = lcomp; + glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); + lnf = glnf_goal_lh[gnum_lnf_goal]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + glnf_goal_rh[gnum_lnf_goal] = lc; + gnum_lnf_goal++; + if ( eq ) { + if ( gnum_lnf_goal == MAX_LNF_COMPS ) { + printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); + exit( 1 ); + } + gnumeric_goal_comp[i] = EQ; + put_comp_into_normalized_locals( GEQ, + gnumeric_goal_lh[i], + gnumeric_goal_rh[i] ); + glnf_goal_comp[gnum_lnf_goal] = lcomp; + glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); + lnf = glnf_goal_lh[gnum_lnf_goal]; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + glnf_goal_rh[gnum_lnf_goal] = lc; + gnum_lnf_goal++; + } + } + /* metric... + */ + lnum_F = 0; + lc = 0; + glnf_metric.num_pF = 0; + glnf_metric.num_nF = 0; + glnf_metric.c = 0; + collect_normalized_locals( gmetric, TRUE ); + lnf = &glnf_metric; + for ( j = 0; j < lnum_F; j++ ) { + if ( lC[j] == 0 ) continue; + if ( lC[j] > 0 ) { + lnf->pF[lnf->num_pF] = lF[j]; + lnf->pC[lnf->num_pF++] = lC[j]; + } else { + lnf->nF[lnf->num_nF] = lF[j]; + lnf->nC[lnf->num_nF++] = (-1) * lC[j]; + } + } + + +} + + + +Bool translate_divisions( ExpNode **n ) + +{ + + ExpNode *tmp; + + /* "dirty": also normalize multiplications so that the constant + * is always on the left hand side --- + * simplifies function below a lot. + */ + switch ( (*n)->connective ) { + case DI: + /* rightson is number due to syntax check. + */ + if ( (*n)->rightson->value == 0 ) { + /* what needs to be done we can only decide further up. + */ + printf("\nwarning: division by zero."); + return FALSE; + } + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + (*n)->connective = MU; + (*n)->rightson->value = 1 / (*n)->rightson->value; + tmp = (*n)->rightson; + (*n)->rightson = (*n)->leftson; + (*n)->leftson = tmp; + break; + case MU: + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->rightson->connective == NUMBER ) { + tmp = (*n)->rightson; + (*n)->rightson = (*n)->leftson; + (*n)->leftson = tmp; + } + break; + case AD: + case SU: + if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; + if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; + break; + case MINUS: + if ( !translate_divisions( &((*n)->son) ) ) return FALSE; + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\ntranslate divisions: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void push_multiplications_down( ExpNode **n ) + +{ + + ExpNode *tmp1, *tmp2; + + switch ( (*n)->connective ) { + case MU: + /* due to syntax check, at least one of sons is number, + * + * due to above, it's the left one. + * NOTE that this invariant is kept true troughout the + * modifications done here. + */ + if ( (*n)->rightson->connective == NUMBER ) { + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + free_ExpNode( (*n)->rightson ); + (*n)->leftson = NULL; + (*n)->rightson = NULL; + break; + } + if ( (*n)->rightson->connective == FHEAD ) { + (*n)->connective = FHEAD; + (*n)->fl = (*n)->rightson->fl; + (*n)->c = (*n)->leftson->value; + free_ExpNode( (*n)->leftson ); + free_ExpNode( (*n)->rightson ); + (*n)->leftson = NULL; + (*n)->rightson = NULL; + break; + } + if ( (*n)->rightson->connective == MINUS ) { + (*n)->connective = MINUS; + (*n)->son = (*n)->rightson; + (*n)->son->connective = MU; + (*n)->son->leftson = (*n)->leftson; + (*n)->son->rightson = (*n)->rightson->son; + (*n)->rightson = NULL; + (*n)->leftson = NULL; + (*n)->son->son = NULL; + push_multiplications_down( &((*n)->son) ); + break; + } + if ( (*n)->rightson->connective == MU ) { + (*n)->leftson->value *= (*n)->rightson->leftson->value; + tmp1 = (*n)->rightson->rightson; + (*n)->rightson->rightson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = tmp1; + push_multiplications_down( n ); + break; + } + + /* rigthson is either AD or SU + */ + tmp1 = new_ExpNode( NUMBER ); + tmp2 = new_ExpNode( NUMBER ); + tmp1->value = (*n)->leftson->value; + tmp2->value = (*n)->leftson->value; + + (*n)->connective = (*n)->rightson->connective; + (*n)->leftson->connective = MU; + (*n)->rightson->connective = MU; + (*n)->leftson->leftson = tmp1; + (*n)->leftson->rightson = (*n)->rightson->leftson; + (*n)->rightson->leftson = tmp2; + + push_multiplications_down( &((*n)->leftson) ); + push_multiplications_down( &((*n)->rightson) ); + break; + case AD: + case SU: + push_multiplications_down( &((*n)->leftson) ); + push_multiplications_down( &((*n)->rightson) ); + break; + case MINUS: + push_multiplications_down( &((*n)->son) ); + break; + case NUMBER: + case FHEAD: + break; + default: + printf("\n\ntranslate divisions: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +void put_comp_into_normalized_locals( Comparator comp, + ExpNode *lh, + ExpNode *rh ) + +{ + + ExpNode *tmp; + + tmp = new_ExpNode( SU ); + + /* initialisation of normalized locals + */ + lnum_F = 0; + lc = 0; + + lcomp = comp; + + /* if comparison is LE or LEQ, then subtract + * left hand side from right hand side to obtain + * new left hand side. + */ + if ( lcomp == LE ) { + tmp->leftson = rh; + tmp->rightson = lh; + collect_normalized_locals( tmp, TRUE ); + lcomp = GE; + /* "subtract" the constant to get it to the right hand + * side. + */ + lc *= (-1); + free( tmp ); + return; + } + if ( lcomp == LEQ ) { + tmp->leftson = rh; + tmp->rightson = lh; + collect_normalized_locals( tmp, TRUE ); + lcomp = GEQ; + lc *= (-1); + free( tmp ); + return; + } + + /* otherwise, subtract right hand side from left hand side. + */ + tmp->leftson = lh; + tmp->rightson = rh; + collect_normalized_locals( tmp, TRUE ); + lc *= (-1); + free( tmp ); + +} + + + +void collect_normalized_locals( ExpNode *n, Bool positive ) + +{ + + Bool negative = positive ? FALSE : TRUE; + int i; + + if ( !n ) return; + + switch ( n->connective ) { + case AD: + collect_normalized_locals( n->leftson, positive ); + collect_normalized_locals( n->rightson, positive ); + break; + case SU: + collect_normalized_locals( n->leftson, positive ); + collect_normalized_locals( n->rightson, negative ); + break; + case MINUS: + collect_normalized_locals( n->son, negative ); + break; + case NUMBER: + if ( positive ) { + lc += n->value; + } else { + lc -= n->value; + } + break; + case FHEAD: + if ( n->fl < 0 && n->fl != -2 ) { + printf("\n\ncollecting non-relevant fluent for LNF!!\n\n"); + exit( 1 ); + } + for ( i = 0; i < lnum_F; i++ ) { + if ( lF[i] == n->fl ) break; + } + if ( i < lnum_F ) { + lC[i] += positive ? n->c : ((-1) * n->c); + } else { + if ( lnum_F == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + lF[lnum_F] = n->fl; + lC[lnum_F] = positive ? n->c : ((-1) * n->c); + lnum_F++; + } + break; + default: + printf("\n\ncollect_normalized_locals: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + + + + + + + + + + + + + + + + + + + +/******************************************************* + * SUBPART II: TRANSLATE THE SUBTRACTIONS + *******************************************************/ + + + + + + + + + + + + + + + +/* local globals. + */ + +int lminus_fluent[MAX_RELEVANT_FLUENTS]; + + + + + + + + + + + + +void translate_subtractions( void ) + +{ + + int i, fl; + + /* minus_fluent[fl] gives the number of the fluent that + * takes on the negative value to fl, or -1 if there is + * no such fluent. + */ + for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { + lminus_fluent[i] = -1; + } + + while ( TRUE ) { + /* ex fl \in nF for pre, cond, eff or goal? + */ + if ( !ex_fl_in_nF_of_pre_cond_eff_goal( &fl ) ) { + /* no --> we are finished. + */ + break; + } + if ( fl < 0 ) { + if ( fl != -2 ) { + printf("\n\nnon-relevant fluent in non-illegal part!\n\n"); + exit( 1 ); + } else { + printf("\n\nwarning: total-time occurs negatively in metric. no optimization done.\n\n"); + glnf_metric.num_pF = 0; + glnf_metric.num_nF = 0; + continue; + } + } + /* set the new number and name, incrementing + * gnum_relevant_fluents, and setting + * minus_fluent value for both directions. + */ + introduce_minus_fluent( fl ); + /* replace all occurences in effects and conds and goals + */ + replace_fl_in_nF_with_minus_fl( fl ); + /* set the initial value of the new fluent + */ + set_minus_fl_initial( fl ); + /* adjust the effects accordingly + */ + introduce_minus_fl_effects( fl ); + } + +} + + + +Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( glnf_goal_lh[i]->num_nF > 0 ) { + *fl = glnf_goal_lh[i]->nF[0]; + return TRUE; + } + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( a->lnf_preconds_lh[i]->num_nF > 0 ) { + *fl = a->lnf_preconds_lh[i]->nF[0]; + return TRUE; + } + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_nF > 0 ) { + *fl = e->lnf_conditions_lh[j]->nF[0]; + return TRUE; + } + } + + if ( e->illegal ) { + /* we don't care if there's something in here that + * wants to be translated. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_rh[j]->num_nF > 0 ) { + *fl = e->lnf_effects_rh[j]->nF[0]; + return TRUE; + } + } + } + } + + /* no need to throw costs away, even if we're not explicitly asked to + * minimize them + */ + if ( (1 || gcost_minimizing) && glnf_metric.num_nF > 0 ) { + *fl = glnf_metric.nF[0]; + return TRUE; + } + + return FALSE; + +} + + + +void introduce_minus_fluent( int fl ) + +{ + + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = -1; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], "MINUS-" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], + grelevant_fluents_name[fl] ); + lminus_fluent[fl] = gnum_relevant_fluents; + lminus_fluent[gnum_relevant_fluents] = fl; + gnum_relevant_fluents++; + +} + + + +void replace_fl_in_nF_with_minus_fl( int fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, l; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + for ( j = 0; j < glnf_goal_lh[i]->num_nF; j++ ) { + if ( glnf_goal_lh[i]->nF[j] == fl ) break; + } + if ( j == glnf_goal_lh[i]->num_nF ) continue; + /* now the jth fluent in subtraction is our translated one. + * + * first, put minus-fl into pF. Can't already be there + * because we have only just introduced it. + */ + if ( glnf_goal_lh[i]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + glnf_goal_lh[i]->pF[glnf_goal_lh[i]->num_pF] = lminus_fluent[fl]; + glnf_goal_lh[i]->pC[glnf_goal_lh[i]->num_pF++] = glnf_goal_lh[i]->nC[j]; + /* now remove fl from nF. + */ + for ( k = j; k < glnf_goal_lh[i]->num_nF - 1; k++ ) { + glnf_goal_lh[i]->nF[k] = glnf_goal_lh[i]->nF[k+1]; + glnf_goal_lh[i]->nC[k] = glnf_goal_lh[i]->nC[k+1]; + } + glnf_goal_lh[i]->num_nF--; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + for ( j = 0; j < a->lnf_preconds_lh[i]->num_nF; j++ ) { + if ( a->lnf_preconds_lh[i]->nF[j] == fl ) break; + } + if ( j == a->lnf_preconds_lh[i]->num_nF ) continue; + if ( a->lnf_preconds_lh[i]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + a->lnf_preconds_lh[i]->pF[a->lnf_preconds_lh[i]->num_pF] = lminus_fluent[fl]; + a->lnf_preconds_lh[i]->pC[a->lnf_preconds_lh[i]->num_pF++] = a->lnf_preconds_lh[i]->nC[j]; + for ( k = j; k < a->lnf_preconds_lh[i]->num_nF - 1; k++ ) { + a->lnf_preconds_lh[i]->nF[k] = a->lnf_preconds_lh[i]->nF[k+1]; + a->lnf_preconds_lh[i]->nC[k] = a->lnf_preconds_lh[i]->nC[k+1]; + } + a->lnf_preconds_lh[i]->num_nF--; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + for ( k = 0; k < e->lnf_conditions_lh[j]->num_nF; k++ ) { + if ( e->lnf_conditions_lh[j]->nF[k] == fl ) break; + } + if ( k == e->lnf_conditions_lh[j]->num_nF ) continue; + if ( e->lnf_conditions_lh[j]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + e->lnf_conditions_lh[j]->pF[e->lnf_conditions_lh[j]->num_pF] = lminus_fluent[fl]; + e->lnf_conditions_lh[j]->pC[e->lnf_conditions_lh[j]->num_pF++] = e->lnf_conditions_lh[j]->nC[k]; + for ( l = k; l < e->lnf_conditions_lh[j]->num_nF - 1; l++ ) { + e->lnf_conditions_lh[j]->nF[l] = e->lnf_conditions_lh[j]->nF[l+1]; + e->lnf_conditions_lh[j]->nC[l] = e->lnf_conditions_lh[j]->nC[l+1]; + } + e->lnf_conditions_lh[j]->num_nF--; + } + + if ( e->illegal ) { + /* like before, we don't care about effects that access + * irrelevant fluents + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { + if ( e->lnf_effects_rh[j]->nF[k] == fl ) break; + } + if ( k == e->lnf_effects_rh[j]->num_nF ) continue; + if ( e->lnf_effects_rh[j]->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + e->lnf_effects_rh[j]->pF[e->lnf_effects_rh[j]->num_pF] = lminus_fluent[fl]; + e->lnf_effects_rh[j]->pC[e->lnf_effects_rh[j]->num_pF++] = e->lnf_effects_rh[j]->nC[k]; + for ( l = k; l < e->lnf_effects_rh[j]->num_nF - 1; l++ ) { + e->lnf_effects_rh[j]->nF[l] = e->lnf_effects_rh[j]->nF[l+1]; + e->lnf_effects_rh[j]->nC[l] = e->lnf_effects_rh[j]->nC[l+1]; + } + e->lnf_effects_rh[j]->num_nF--; + } + } + } + + for ( j = 0; j < glnf_metric.num_nF; j++ ) { + if ( glnf_metric.nF[j] == fl ) break; + } + if ( j < glnf_metric.num_nF ) { + if ( glnf_metric.num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + glnf_metric.pF[glnf_metric.num_pF] = lminus_fluent[fl]; + glnf_metric.pC[glnf_metric.num_pF++] = glnf_metric.nC[j]; + for ( k = j; k < glnf_metric.num_nF - 1; k++ ) { + glnf_metric.nF[k] = glnf_metric.nF[k+1]; + glnf_metric.nC[k] = glnf_metric.nC[k+1]; + } + glnf_metric.num_nF--; + } + +} + + + +void set_minus_fl_initial( int fl ) + +{ + + if ( ginitial_state.f_D[fl] ) { + ginitial_state.f_D[lminus_fluent[fl]] = TRUE; + ginitial_state.f_V[lminus_fluent[fl]] = (-1) * ginitial_state.f_V[fl]; + } + +} + + + +void introduce_minus_fl_effects( int fl ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, pf, nf; + LnfExpNode *len; + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->illegal ) { + /* no need to translate illegal effects. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_fl[j] != fl ) { + continue; + } + /* here is an effect that affects our fl. + * introduce inverse effect for minus_fl, + * making use of all minus-fl's that are already + * there. + */ + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e->lnf_effects_neft[j]; + e->lnf_effects_fl[e->num_lnf_effects] = lminus_fluent[fl]; + e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); + len = e->lnf_effects_rh[e->num_lnf_effects]; + /* now the most "difficult" part: setup the inverted pF and nF + * informations. + * + * NOTE: as fluent occurences are unique in original ef, + * so will they be in new ef. (no len contains both + * a fluent and its minus-fluent) + * --> invariant is or should be that the absolute + * fluents occur at most once in |pF| \cup |nF|. + * holds in the beginning. only thing we do is + * we exchange in that set for some fluents the + * positive with the negative version, so the + * invariant is in fact preserved. + */ + for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { + pf = e->lnf_effects_rh[j]->pF[k]; + if ( lminus_fluent[pf] == -1 ) { + /* not translated yet --> insert it into nF + */ + if ( len->num_nF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->nF[len->num_nF] = pf; + len->nC[len->num_nF++] = e->lnf_effects_rh[j]->pC[k]; + } else { + /* else, insert minus-pf into pF + */ + if ( len->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->pF[len->num_pF] = lminus_fluent[pf]; + len->pC[len->num_pF++] = e->lnf_effects_rh[j]->pC[k]; + } + } + for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { + nf = e->lnf_effects_rh[j]->nF[k]; + /* insert all of those into pF + */ + if ( len->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + len->pF[len->num_pF] = nf; + len->pC[len->num_pF++] = e->lnf_effects_rh[j]->nC[k]; + } + /* the constant must of course be inverted. + */ + len->c = (-1) * e->lnf_effects_rh[j]->c; + e->num_lnf_effects++; + } + } + } + +} + + + + + + + + + + + + + + + + + + +/************************************************************* + * LNF POST-PROCESSING I: SUMMARIZE EFFECTS. + *************************************************************/ + + + + + + + + + + + + + + + + + + + +int *lA, *lD; +int lnum_A, lnum_D; + + + + + + +void summarize_effects( void ) + +{ + + Action *a; + ActionEffect *e, *e_; + int i, j, k, l; + + lA = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); + lD = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); + + for ( a = gactions; a; a = a->next ) { + i = 0; + while ( i < a->num_effects ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* this one's already handled. + */ + i++; + continue; + } + + /* first, merge the effect's own effects together. logical: + */ + lnum_A = 0; + for ( j = 0; j < e->num_adds; j++ ) { + for ( k = 0; k < lnum_A; k++ ) { + if ( lA[k] == e->adds[j] ) break; + } + if ( k < lnum_A ) continue; + lA[lnum_A++] = e->adds[j]; + } + lnum_D = 0; + for ( j = 0; j < e->num_dels; j++ ) { + for ( k = 0; k < lnum_D; k++ ) { + if ( lD[k] == e->dels[j] ) break; + } + if ( k < lnum_D ) continue; + lD[lnum_D++] = e->dels[j]; + } + /* numerical: + */ + j = 0; + while ( j < e->num_lnf_effects ) { + /* merge all effects increasing the same fluent into + * effect j, and remove them. + */ + k = j + 1; + while ( k < e->num_lnf_effects ) { + if ( e->lnf_effects_fl[k] != e->lnf_effects_fl[j] ) { + k++; + continue; + } + if ( e->lnf_effects_neft[j] == ASSIGN ) { + if ( e->lnf_effects_neft[k] != ASSIGN || + !same_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ) ) { + e->illegal = TRUE; + break; + } + } else { + if ( e->lnf_effects_neft[k] == ASSIGN ) { + e->illegal = TRUE; + break; + } + merge_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ); + } + /* we also get here if we have two identical assigns. + */ + free( e->lnf_effects_rh[k] ); + for ( l = k; l < e->num_lnf_effects - 1; l++ ) { + e->lnf_effects_neft[l] = e->lnf_effects_neft[l+1]; + e->lnf_effects_fl[l] = e->lnf_effects_fl[l+1]; + e->lnf_effects_rh[l] = e->lnf_effects_rh[l+1]; + } + e->num_lnf_effects--; + } + if ( k < e->num_lnf_effects ) { + /* illegal combination + */ + break; + } + j++; + } + + /* now merge all effects after i with same condition + * into that. + */ + j = i + 1; + while ( j < a->num_effects ) { + e_ = &(a->effects[j]); + if ( e_->removed ) { + j++; + continue; + } + + if ( !same_condition( e, e_ ) ) { + j++; + continue; + } + /* no matter what happens, we can get rid of effect e_ + */ + e_->removed = TRUE; + + /* illegality is inherited in both directions. + */ + if ( e_->illegal ) { + e->illegal = TRUE; + } + if ( e->illegal ) { + /* just for docu; it is removed anyway. + */ + e_->illegal = TRUE; + } + + if ( !e->illegal ) { + /* the combined effect appears to be legal. merge it. + */ + merge_effects( e, e_ ); + if ( e->illegal ) { + /* e might have become illegal. again, docu this. + */ + e_->illegal = TRUE; + } + } + + j++; + } + + /* now put the updated A and D info into e. + * + * have to be careful: it might be that there are + * now too many facts and we need to re-allocate + * e's capabilities. + */ + if ( lnum_A > e->num_adds ) { + free( e->adds ); + e->adds = ( int * ) calloc( lnum_A, sizeof( int ) ); + } + for ( j = 0; j < lnum_A; j++ ) { + e->adds[j] = lA[j]; + } + e->num_adds = lnum_A; + if ( lnum_D > e->num_dels ) { + free( e->dels ); + e->dels = ( int * ) calloc( lnum_D, sizeof( int ) ); + } + for ( j = 0; j < lnum_D; j++ ) { + e->dels[j] = lD[j]; + } + e->num_dels = lnum_D; + + /* increment current effects counter. + */ + i++; + } + } + +} + + + +Bool same_condition( ActionEffect *e, ActionEffect *e_ ) + +{ + + int i, j; + + if ( e->num_conditions != e_->num_conditions || + e->num_lnf_conditions != e_->num_lnf_conditions ) return FALSE; + + for ( i = 0; i < e->num_conditions; i++ ) { + for ( j = 0; j < e_->num_conditions; j++ ) { + if ( e->conditions[i] == e_->conditions[j] ) break; + } + if ( j == e_->num_conditions ) break; + } + if ( i < e->num_conditions ) return FALSE; + + for ( i = 0; i < e->num_lnf_conditions; i++ ) { + for ( j = 0; j < e_->num_lnf_conditions; j++ ) { + if ( e_->lnf_conditions_comp[j] != e->lnf_conditions_comp[i] ) continue; + if ( e_->lnf_conditions_rh[j] != e->lnf_conditions_rh[i] ) continue; + if ( !same_lnfs( e_->lnf_conditions_lh[j], e->lnf_conditions_lh[i] ) ) continue; + break; + } + if ( j == e_->num_lnf_conditions ) break; + } + if ( i < e->num_lnf_conditions ) return FALSE; + + return TRUE; + +} + + + +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ) + +{ + + int i, j; + + if ( l->num_pF != r->num_pF || + l->c != r->c ) return FALSE; + + for ( i = 0; i < l->num_pF; i++ ) { + for ( j = 0; j < r->num_pF; j++ ) { + if ( l->pF[i] != r->pF[j] ) continue; + if ( l->pC[i] != r->pC[j] ) { + /* same fluent with different weighting. + */ + return FALSE; + } + break; + } + if ( j == r->num_pF ) break; + } + if ( i < l->num_pF ) return FALSE; + + return TRUE; + +} + + + +void merge_effects( ActionEffect *e, ActionEffect *e_ ) + +{ + + int i, j; + + /* we don't care whether adds and dels intersect: + * they're allowed to by semantics. + */ + for ( i = 0; i < e_->num_adds; i++ ) { + for ( j = 0; j < lnum_A; j++ ) { + if ( lA[j] == e_->adds[i] ) break; + } + if ( j < lnum_A ) continue; + lA[lnum_A++] = e_->adds[i]; + } + for ( i = 0; i < e_->num_dels; i++ ) { + for ( j = 0; j < lnum_D; j++ ) { + if ( lD[j] == e_->dels[i] ) break; + } + if ( j < lnum_D ) continue; + lD[lnum_D++] = e_->dels[i]; + } + + for ( i = 0; i < e_->num_lnf_effects; i++ ) { + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_fl[j] == e_->lnf_effects_fl[i] ) break; + } + if ( j == e->num_lnf_effects ) { + /* new affected fluent! + */ + if ( e->num_lnf_effects == MAX_LNF_EFFS ) { + printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); + exit( 1 ); + } + e->lnf_effects_neft[e->num_lnf_effects] = e_->lnf_effects_neft[i]; + e->lnf_effects_fl[e->num_lnf_effects] = e_->lnf_effects_fl[i]; + /* we can also simply take the pointer: e_ is only marked as removed, + * but not freed. + */ + e->lnf_effects_rh[e->num_lnf_effects] = e_->lnf_effects_rh[i]; + e->num_lnf_effects++; + } else { + if ( e->lnf_effects_neft[j] == ASSIGN ) { + if ( e_->lnf_effects_neft[i] != ASSIGN || + !same_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ) ) { + e->illegal = TRUE; + return; + } + /* identical assigns. nothing needs to be done. + */ + } else { + if ( e_->lnf_effects_neft[i] == ASSIGN ) { + e->illegal = TRUE; + return; + } + merge_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ); + } + } + } + +} + + + +/* merge both LNFs into the left one. + * (only pF needed as both are already + * fully transformed) + */ +void merge_lnfs( LnfExpNode *l, LnfExpNode *r ) + +{ + + int i, j, k; + + for ( i = 0; i < r->num_pF; i++ ) { + + for ( j = 0; j < l->num_pF; j++ ) { + if ( r->pF[i] == l->pF[j] ) break; + } + if ( j < l->num_pF ) { + /* got that one in dest LNF already + */ + l->pC[j] += r->pC[i]; + continue; + } + + if ( lminus_fluent[r->pF[i]] != -1 ) { + /* this one was already translated. let's see + * if its counterpart is in the left lnf. + */ + for ( j = 0; j < l->num_pF; j++ ) { + if ( lminus_fluent[r->pF[i]] == l->pF[j] ) break; + } + if ( j < l->num_pF ) { + /* for this, we got the inverse one! + */ + l->pC[j] -= r->pC[i]; + if ( l->pC[j] < 0 ) { + l->pF[j] = r->pF[i]; + l->pC[j] *= (-1); + } + if ( l->pC[j] == 0 ) { + /* remove this entirely. + */ + for ( k = j; k < l->num_pF - 1; k++ ) { + l->pF[k] = l->pF[k+1]; + l->pC[k] = l->pC[k+1]; + } + l->num_pF--; + } + continue; + } + } + + /* we got neither that nor its counterpart. + */ + if ( l->num_pF == MAX_LNF_F ) { + printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); + exit( 1 ); + } + l->pF[l->num_pF] = r->pF[i]; + l->pC[l->num_pF++] = r->pC[i]; + } + + + l->c += r->c; + +} + + + + + + + + + + + + + + + + + + + + + + +/************************************************************* + * LNF POST-PROCESSING II: ENCODE NON-MINIMAL LNFs. + *************************************************************/ + + + + + + + + + + + + + + + + + + + + + + + +void encode_lfns_as_artificial_fluents( void ) + +{ + + int i; + + /* for the artificial new ones, this will be set + * to the respective LNF. + */ + for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { + grelevant_fluents_lnf[i] = NULL; + } + + while ( TRUE ) { + /* ex non-minimal lnf in pre, cond, eff, or goal? + * + * (i.e., lnf != fl + c) + */ + if ( !ex_non_minimal_lnf_in_pre_cond_goal_eff() ) { + /* no --> we are finished. + */ + break; + } + /* otherwise, the respective LNF, without the + * constant part, is set up in + * lF...; (local global borrowed from above); + * + * introduce a new artificial fluent for that + * LNF + */ + introduce_artificial_fluent(); + /* replace all occurences in pres, conds, effs, and goals + */ + replace_non_minimal_lnf_with_artificial_fl(); + } + +} + + + +Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( glnf_goal_lh[i]->num_pF > 1 || + (glnf_goal_lh[i]->num_pF == 1 && glnf_goal_lh[i]->pC[0] != 1) ) { + for ( j = 0; j < glnf_goal_lh[i]->num_pF; j++ ) { + lF[j] = glnf_goal_lh[i]->pF[j]; + lC[j] = glnf_goal_lh[i]->pC[j]; + } + lnum_F = glnf_goal_lh[i]->num_pF; + return TRUE; + } + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( a->lnf_preconds_lh[i]->num_pF > 1 || + (a->lnf_preconds_lh[i]->num_pF == 1 && a->lnf_preconds_lh[i]->pC[0] != 1) ) { + for ( j = 0; j < a->lnf_preconds_lh[i]->num_pF; j++ ) { + lF[j] = a->lnf_preconds_lh[i]->pF[j]; + lC[j] = a->lnf_preconds_lh[i]->pC[j]; + } + lnum_F = a->lnf_preconds_lh[i]->num_pF; + return TRUE; + } + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* these will not be included into conn: + * merged into somewhere else. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_pF > 1 || + (e->lnf_conditions_lh[j]->num_pF == 1 && e->lnf_conditions_lh[j]->pC[0] != 1) ) { + for ( k = 0; k < e->lnf_conditions_lh[j]->num_pF; k++ ) { + lF[k] = e->lnf_conditions_lh[j]->pF[k]; + lC[k] = e->lnf_conditions_lh[j]->pC[k]; + } + lnum_F = e->lnf_conditions_lh[j]->num_pF; + return TRUE; + } + } + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_rh[j]->num_pF > 1 || + (e->lnf_effects_rh[j]->num_pF == 1 && e->lnf_effects_rh[j]->pC[0] != 1) ) { + for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { + lF[k] = e->lnf_effects_rh[j]->pF[k]; + lC[k] = e->lnf_effects_rh[j]->pC[k]; + } + lnum_F = e->lnf_effects_rh[j]->num_pF; + return TRUE; + } + } + } + } + + return FALSE; + +} + + + +void introduce_artificial_fluent( void ) + +{ + + int i; + + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = -1; + + /* no name --> is inferred in this case from _lnf + */ + + grelevant_fluents_lnf[gnum_relevant_fluents] = new_LnfExpNode(); + for ( i = 0; i < lnum_F; i++ ) { + grelevant_fluents_lnf[gnum_relevant_fluents]->pF[i] = lF[i]; + grelevant_fluents_lnf[gnum_relevant_fluents]->pC[i] = lC[i]; + } + grelevant_fluents_lnf[gnum_relevant_fluents]->num_pF = lnum_F; + + gnum_relevant_fluents++; + +} + + + +void replace_non_minimal_lnf_with_artificial_fl( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j; + + for ( i = 0; i < gnum_lnf_goal; i++ ) { + if ( !is_artificial_fluent( glnf_goal_lh[i] ) ) { + continue; + } + /* the pF here is the pF we are currently replacing. + */ + glnf_goal_lh[i]->pF[0] = gnum_relevant_fluents - 1; + glnf_goal_lh[i]->pC[0] = 1; + glnf_goal_lh[i]->num_pF = 1; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + if ( !is_artificial_fluent( a->lnf_preconds_lh[i] ) ) { + continue; + } + a->lnf_preconds_lh[i]->pF[0] = gnum_relevant_fluents - 1; + a->lnf_preconds_lh[i]->pC[0] = 1; + a->lnf_preconds_lh[i]->num_pF = 1; + } + + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->removed ) { + /* these will not be included into conn: + * merged into somewhere else. + */ + continue; + } + + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( !is_artificial_fluent( e->lnf_conditions_lh[j] ) ) { + continue; + } + e->lnf_conditions_lh[j]->pF[0] = gnum_relevant_fluents - 1; + e->lnf_conditions_lh[j]->pC[0] = 1; + e->lnf_conditions_lh[j]->num_pF = 1; + } + + if ( e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( !is_artificial_fluent( e->lnf_effects_rh[j] ) ) { + continue; + } + e->lnf_effects_rh[j]->pF[0] = gnum_relevant_fluents - 1; + e->lnf_effects_rh[j]->pC[0] = 1; + e->lnf_effects_rh[j]->num_pF = 1; + } + } + } + +} + + + +Bool is_artificial_fluent( LnfExpNode *n ) + +{ + + int i, j; + + if ( n->num_nF != 0 ) { + printf("\n\nchecking non-empty nF for multiple fl!\n\n"); + exit( 1 ); + } + + if ( n->num_pF != lnum_F ) { + return FALSE; + } + + for ( i = 0; i < lnum_F; i++ ) { + for ( j = 0; j < n->num_pF; j++ ) { + if ( n->pF[j] != lF[i] ) continue; + if ( n->pC[j] != lC[i] ) { + /* wrong constant multiplier! + */ + return FALSE; + } + break; + } + if ( j == n->num_pF ) { + /* didn't find this fluent i in here. + */ + return FALSE; + } + } + + return TRUE; + +} + + + + + + + + + + + + + + + + + + +/************************************************************* + * AT LAST: PREPARATIONS FOR METRIC FUNCTION + *************************************************************/ + + + + + + + + + + + + + + + + + + +Bool setup_effect_costs( void ) + +{ + + Action *a; + ActionEffect *e; + int i, j, k, fl; + Bool non_zero = FALSE; + + if ( glnf_metric.num_pF == 0 ) { + /* no metric, or previously failed + */ + if ( gcmd_line.display_info ) { + printf("\nno metric specified."); + } + return FALSE; + } + + /* also in here: check if all parts of metric are defined + * if not, then they won't ever be because we do not allow + * assigners anyway. + * + * also, setup gtt total-time multipl. + * currently needed since in h fn effect cists are summed up + * --> may count the same action more than once, if we insert the + * timing cost into the effect cost. + * + * ... this is AWKWARD... probably would be better to simply + * associate costs always (including relaxed plans) + * only with ACTIONS! + */ + gtt = 0; + for ( i = 0; i < glnf_metric.num_pF; i++ ) { + if ( glnf_metric.pF[i] == -2 ) { + gtt = glnf_metric.pC[i]; + continue; + } + if ( !ginitial_state.f_D[glnf_metric.pF[i]] ) break; + } + if ( i < glnf_metric.num_pF ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: metric undefined initially. no optimization done."); + } + return FALSE; + } + + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + e->cost = 0; + + if ( e->removed || + e->illegal ) { + continue; + } + + for ( j = 0; j < e->num_lnf_effects; j++ ) { + fl = e->lnf_effects_fl[j]; + for ( k = 0; k < glnf_metric.num_pF; k++ ) { + if ( fl == glnf_metric.pF[k] ) break; + } + if ( k == glnf_metric.num_pF ) continue; + + if ( e->lnf_effects_rh[j]->num_pF > 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: non-constant effect on metric. no optimization done."); + } + return FALSE; + } + if ( e->lnf_effects_neft[j] != INCREASE ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: assign on metric. no optimization done."); + } + return FALSE; + } + if ( e->lnf_effects_rh[j]->c < 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: change on metric in wrong direction. no optimization done."); + } + return FALSE; + } + + e->cost += glnf_metric.pC[k] * e->lnf_effects_rh[j]->c; + if ( e->cost > 0 ) { + non_zero = TRUE; + } + } + } + } + + if ( !non_zero ) { + if ( gtt == 0 ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: trivial metric, all costs 0. no optimization done."); + } + return FALSE; + } + } + + return TRUE; + +} + + + + + + + + + + + + + + + + + + + + + +/************************************************************* + * AT VERY LAST: ACYCLIC := EFFS, AND STATIC FL RELEVANCE + *************************************************************/ + + + + + + + + + + + + + + + + + + + + + + + +void check_assigncycles( void ) + +{ + + int i, j, k, c = 0; + + gassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + gTassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + gassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + gTassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + } + + if ( gcmd_line.display_info > 1 ) { + printf("\n\nchecking for cyclic := effects"); + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + gassign_influence[i][j] = i_influences_j( i, j ); + gTassign_influence[i][j] = i_influences_j( i, j ); + } + } + /* compute transitive closure on dependencies + */ + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( gTassign_influence[i][j] ) { + for ( k = 0; k < gnum_real_fl_conn; k++ ) { + if ( gTassign_influence[j][k] ) { + gTassign_influence[i][k] = TRUE; + } + } + } + } + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( gTassign_influence[i][i] ) { + printf("\nnumerical variable "); + print_fl_name( i ); + printf(" lies on := propagation cycle!"); + c++; + } + } + if ( c > 0 ) { + printf("\nexit. (mneed computation not possible, RPG termination unclear)"); + printf("\n (questions to Joerg Hoffmann)\n\n"); + exit( 1 ); + } else { + if ( gcmd_line.display_info > 1 ) { + printf(" --- OK."); + } + } + +} + + + +Bool i_influences_j( int fi, int fj ) + +{ + + int i, j, fl_; + + for ( i = 0; i < gfl_conn[fj].num_AS; i++ ) { + fl_ = gfl_conn[fj].AS_fl_[i]; + if ( fl_ < 0 ) continue; + if ( fl_ == fi ) return TRUE; + if ( !gfl_conn[fl_].artificial ) continue; + for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { + if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; + } + } + + return FALSE; + +} + + + +void determine_fl_relevance( void ) + +{ + + int i, j, k, fl, fl_, ef, pc, g; + Bool **influenced_by; + + /* this here contains transfers from i to j i.e. if + * i is relevant then j is too + */ + influenced_by = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + influenced_by[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + } + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + influenced_by[i][j] = ( gassign_influence[j][i] || + i_inc_influences_j( j, i ) ); + } + } + /* transitive closure so we'll have direct access below. + */ + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[i][j] ) { + for ( k = 0; k < gnum_real_fl_conn; k++ ) { + if ( influenced_by[j][k] ) { + influenced_by[i][k] = TRUE; + } + } + } + } + } + + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + gfl_conn[i].relevant = FALSE; + } + /* relevance originates in effect preconds and goals. + */ + for ( ef = 0; ef < gnum_ef_conn; ef++ ) { + for ( pc = 0; pc < gef_conn[ef].num_f_PC; pc++ ) { + /* constraint here is gef_conn[ef].f_PC_fl[pc] >= [>] gef_conn[ef].f_PC_c[pc] + * where lh side can be lnf expression. + */ + fl = gef_conn[ef].f_PC_fl[pc]; + if ( fl < 0 ) { + printf("\nnegative constr lh??\n\n"); + exit( 1 ); + } + if ( !gfl_conn[fl].artificial ) { + gfl_conn[fl].relevant = TRUE; + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; + } + } else { + for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { + fl_ = gfl_conn[fl].lnf_F[i]; + gfl_conn[fl_].relevant = TRUE; + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; + } + } + } + } + } + for ( g = 0; g < gnum_fnumeric_goal; g++ ) { + /* constraint here is gfnumeric_goal_fl[g] >= [>] gfnumeric_goal_c[g] + * where lh side can be lnf expression. + */ + fl = gfnumeric_goal_fl[g]; + if ( fl < 0 ) { + printf("\nnegative constr lh??\n\n"); + exit( 1 ); + } + if ( !gfl_conn[fl].artificial ) { + gfl_conn[fl].relevant = TRUE; + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; + } + } else { + for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { + fl_ = gfl_conn[fl].lnf_F[i]; + gfl_conn[fl_].relevant = TRUE; + for ( j = 0; j < gnum_real_fl_conn; j++ ) { + if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; + } + } + } + } + + if ( 0 ) { + for ( i = 0; i < gnum_real_fl_conn; i++ ) { + printf("\n"); print_fl_name( i ); + printf (" --- relevant: %d", gfl_conn[i].relevant); + } + } + +} + + + +Bool i_inc_influences_j( int fi, int fj ) + +{ + + int i, j, fl_; + + for ( i = 0; i < gfl_conn[fj].num_IN; i++ ) { + fl_ = gfl_conn[fj].IN_fl_[i]; + if ( fl_ < 0 ) continue; + if ( fl_ == fi ) return TRUE; + if ( !gfl_conn[fl_].artificial ) continue; + for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { + if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; + } + } + + return FALSE; + +} + diff --git a/models/main_models/rt1/gen/ff_planner/expressions.h b/models/main_models/rt1/gen/ff_planner/expressions.h new file mode 100644 index 000000000..3546f2acd --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/expressions.h @@ -0,0 +1,106 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: expressions.h + * Description: headers for handling numerical expressions + * + * Author: Joerg Hoffmann 2001 + * + *********************************************************************/ + + + + + + + + + + + + + + +#ifndef _EXPRESSIONS_H +#define _EXPRESSIONS_H + + + + +Bool number_comparison_holds( Comparator c, float l, float r ); + + + +Bool transform_to_LNF( void ); +Bool is_linear_task( void ); +Bool is_linear_expression( ExpNode *n ); +void print_lnf_representation( void ); + + + +void normalize_expressions( void ); +Bool translate_divisions( ExpNode **n ); +void push_multiplications_down( ExpNode **n ); +void put_comp_into_normalized_locals( Comparator comp, + ExpNode *lh, + ExpNode *rh ); +void collect_normalized_locals( ExpNode *n, Bool positive ); + + + +void translate_subtractions( void ); +Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ); +void introduce_minus_fluent( int fl ); +void replace_fl_in_nF_with_minus_fl( int fl ); +void set_minus_fl_initial( int fl ); +void introduce_minus_fl_effects( int fl ); + + + +void summarize_effects( void ); +Bool same_condition( ActionEffect *e, ActionEffect *e_ ); +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); +void merge_effects( ActionEffect *e, ActionEffect *e_ ); +void merge_lnfs( LnfExpNode *l, LnfExpNode *r ); + + + +void encode_lfns_as_artificial_fluents( void ); +Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ); +void introduce_artificial_fluent( void ); +void replace_non_minimal_lnf_with_artificial_fl( void ); +Bool is_artificial_fluent( LnfExpNode *n ); + + + +Bool setup_effect_costs( void ); + + + +void check_assigncycles( void ); +Bool i_influences_j( int fi, int fj ); +void determine_fl_relevance( void ); +Bool i_inc_influences_j( int fi, int fj ); + + + +#endif /* _EXPRESSIONS_H */ diff --git a/models/main_models/rt1/gen/ff_planner/ff.h b/models/main_models/rt1/gen/ff_planner/ff.h new file mode 100644 index 000000000..d244df7ae --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/ff.h @@ -0,0 +1,2044 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: ff.h + * Description: Types and structures for the Metric-FastForward planner. + * Enhanced version with derived predicates and A*-epsilon + * + * --------- PDDL2.1 level 2 :: VERSION v 1.0 -------------- + * + * Author: Joerg Hoffmann 2012 + * Contact: hoffmann@cs.uni-saarland.de + * + *********************************************************************/ + + + + + + + + +#ifndef __FF_H +#define __FF_H + + + + + + +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + +/* + * ------------------------------------ DEFINES ---------------------------- + */ + + + + + + + + + + + +/*********************** + * MEANINGLESS HELPERS * + ***********************/ + + + + +/* strcmp returns 0 if two strings are equal, which is not nice */ +#define SAME 0 + + + + + + + + + +/**************** + * PARSING ETC. * + ****************/ + + + + + + + + + +/* various defines used in parsing + */ +#define HIDDEN_STR "#" +#define AXIOM_STR "AXIOM" +#define NAME_STR "name\0" +#define VARIABLE_STR "variable\0" +#define STANDARD_TYPE "OBJECT\0" +#define EITHER_STR "EITHER" + + + + + + + + + +/*************************** + * SOME ARBITRARY SETTINGS * + ***************************/ + + + + + + + +/* maximal string length + */ +#define MAX_LENGTH 256 + + +/* marks border between connected items + */ +#define CONNECTOR "~" + + +/* size of goals_at array in 1P extraction + */ +#define RELAXED_STEPS_DEFAULT 25 + + +/* size of hash table for repeated states checking + * during EHC breadth first search + */ +#define EHC_HASH_SIZE 8192 +#define EHC_HASH_BITS 8191 + + +/* size of hash table for repeated states checking + * in plan construction + */ +#define PLAN_HASH_SIZE 1024 +#define PLAN_HASH_BITS 1023 + + +/* size of hash table for repeated states checking + * during BFS search + */ +#define BFS_HASH_SIZE 65536 +#define BFS_HASH_BITS 65535 + + +/* cut random values of facts off modulo this value, + * to make state sums fit into a single integer + */ +#define BIG_INT 1500000 + + +/* max number of different fluents in one list of LNF + */ +#define MAX_LNF_F 25 + + +/* max number of comps in one cond / precond / goal + */ +#define MAX_LNF_COMPS 100 + + +/* max number of lnf effects in one action effect + */ +#define MAX_LNF_EFFS 50 + + + + + + + +/************************ + * INSTANTIATION LIMITS * + ************************/ + + + + + + + + +#define MAX_CONSTANTS 2000 +#define MAX_PREDICATES 50 +#define MAX_FUNCTIONS 50 +#define MAX_TYPES 50 +#define MAX_ARITY 5 +#define MAX_VARS 15 + + +#define MAX_TYPE 2000 + + +#define MAX_OPERATORS 50000 + + +/* in DNF: AND with OR - sons - collect 'hitting set': + * one son of each OR node. + * + * this here is initial max number of such son s that can be collected + * (grows dynamically, if required) + */ +#define MAX_HITTING_SET_DEFAULT 1000 + + +#define MAX_TYPE_INTERSECTIONS 10 + + +#define MAX_RELEVANT_FACTS 150000 +#define MAX_RELEVANT_FLUENTS 1000 + + + + + + +/****************************************** + * DOMAIN STRUCTURE AND SEARCHING LIMITS * + ******************************************/ + + + + + + +#define MAX_STATE 800 + + +#define MAX_PLAN_LENGTH 500 + + + + + + +/**************** + * CODE DEFINES * + ****************/ + + + + + + + + + +/* not a real 'code' define; used in relax and search to encode + * infinite level number / plan length + */ +#ifndef INFINITY +#define INFINITY -1 +#endif + + + + + + + +/* define boolean types if not allready defined + */ +#ifndef Bool +typedef unsigned char Bool; +#ifndef TRUE /* we assume that FALSE is also not defined */ +#define TRUE 1 +#define FALSE 0 +#endif /* TRUE */ +#endif /* Bool */ + + +/* code a param number into a negative number and vice versa + */ +#define ENCODE_VAR( val ) (val * (-1)) - 1 +#define DECODE_VAR( val ) (val + 1) * (-1) + +#define GET_CONSTANT( val, pointer ) ( val >= 0 ) ? val : pointer->inst_table[DECODE_VAR( val )] + + +/* Check allocated memory + */ +#define CHECK_PTR(p) if (NULL == (p)) { \ + fprintf(stdout, "\n\aNO MEMORY in file %s:%d\n\n", __FILE__, __LINE__); \ + exit(1);} + + +/* add elapsed time from main local time vars to specified val + */ +#define TIME( val ) val += ( float ) ( ( end.tms_utime - start.tms_utime + \ + end.tms_stime - start.tms_stime ) / 100.0 ) + + + + + + + + + + + + +/* + * ------------------------------ DATA STRUCTURES ---------------------------- + */ + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + +/* all command switches + */ +struct _command_line { + + char path[MAX_LENGTH]; + char ops_file_name[MAX_LENGTH]; + char fct_file_name[MAX_LENGTH]; + int display_info; + int debug; + + int search_config; + Bool cost_rplans; + + int w; + + float cost_bound; + +}; + + +typedef char *Token; + + + + + + + + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + + + + +/* A list of strings + */ +typedef struct _TokenList { + + char *item; + struct _TokenList *next; + +} TokenList; + + + +/* list of string lists + */ +typedef struct _FactList { + + TokenList *item; + struct _FactList *next; + +} FactList; + + + +/* structure to store typed-list-of /, + * as they are declared in PDDL files + */ +typedef struct _TypedList { + + char *name; + + /* each item in this list is the name of a type which + * our type is the union of (EITHER - types ...) + * + * usually, this will default to a single-item TokenList. + */ + TokenList *type; + /* after first sweep, this will contain the number in type table + */ + int n; + + struct _TypedList *next; + +} TypedList; + + + +/* only needed to parse in the predicates and their arg + * definitions + */ +typedef struct _TypedListList { + + char *predicate; + + TypedList *args; + + struct _TypedListList *next; + +} TypedListList; + + + +typedef enum _ExpConnective{FHEAD = 1000, + NUMBER, + MINUS, + AD, + SU, + MU, + DI} ExpConnective; + + + +typedef struct _ParseExpNode { + + ExpConnective connective; + + /* NULL anywhere except when node is FHEAD or NUMBER + * (in which case it is fn name ... resp. number (int or float) as string + */ + TokenList *atom; + + /* both NULL in FHEAD; + * in MINUS, left is son and right is NULL + * else (binary operators), left and right operand + */ + struct _ParseExpNode *leftson, *rightson; + +} ParseExpNode; + + + +/* This type indicates whether a node in the pddl tree stands for + * an atomic expression, a junctor or a quantor. + */ +typedef enum _Connective{TRU = 2000, + FAL, + ATOM, + COMP, + NEF, + NOT, + AND, + OR, + ALL, + EX, + WHEN} Connective; + + + +typedef enum _Comparator{IGUAL = 3000, /* technical if conds are array comp exp, resp float */ + LE, + LEQ, + EQ, + GEQ, + GE} Comparator; + + + + +typedef enum _NumericEffectType{ASSIGN = 4000, + SCALE_UP, + SCALE_DOWN, + INCREASE, + DECREASE} NumericEffectType; + + + + +/* + * This is a node in the tree to parse PDDL files + */ +typedef struct _PlNode { + + /* type of the node + */ + Connective connective; + + /* only for parsing: the var args in quantifiers + */ + TypedList *parse_vars; + + /* AND, OR, NOT, WHEN, + * COMP, NEF => NULL + * ALL, EX => the quantified variable with its type + * ATOM => the atom as predicate->param1->param2->... + */ + TokenList *atom; + /* all except COMP, NEF => NULL + * COMP, NEF => left hand, right hand + */ + Comparator comp; + NumericEffectType neft; + ParseExpNode *lh, *rh; + + /* (a) for AND, OR this is the list of sons(a AND b AND c...), + * (b) for the rest this is the son, e.g. a subtree that is negated + * (c) for WHEN, the first son is the condition and the next son + * is the effect + */ + struct _PlNode *sons; + + /* if you have a list of sons, they are connected by next + */ + struct _PlNode *next; + +} PlNode; + + +/* + * This resembles an uninstantiated PDDL operator + */ +typedef struct _PlOperator { + + char *name; + Bool axiom; + + /* only important for PDDL where :VARS may be added to the param list + * which must be hidden when writing the plan to an output file + */ + int number_of_real_params; + + /* the params, as they are declared in domain file + */ + TypedList *parse_params; + + /* params is a list of variable/type pairs, such that: + * factlist->item = [variable] -> [type] + */ + FactList *params; + PlNode *preconds; + PlNode *effects; + + struct _PlOperator *next; + +} PlOperator; + + + + + + + + + + + + + + + +/***************** + * INSTANTIATION * + *****************/ + + + + + + + + + +/* helpers + */ + +typedef int TypeArray[MAX_TYPE_INTERSECTIONS]; + +typedef int *int_pointer; + + + + +/* first step structures: parsing & preprocessing + */ + +typedef struct _Fact { + + int predicate, args[MAX_ARITY]; + +} Fact; + + + +typedef struct _Fluent { + + int function, args[MAX_ARITY]; + +} Fluent; + + + +typedef struct _FluentValue { + + Fluent fluent; + float value; + +} FluentValue; + + + +typedef struct _Facts { + + Fact *fact; + + struct _Facts *next; + +} Facts; + + + +typedef struct _FluentValues { + + Fluent fluent; + float value; + + struct _FluentValues *next; + +} FluentValues; + + + +typedef struct _ExpNode { + + ExpConnective connective; + + /* in FHEAD nodes, pre-processing + */ + Fluent *fluent; + /* in FHEAD nodes after pre-processes have finished. + * (internal number of relevant fluent, or -1 if not + * relevant) + */ + int fl; + /* helper for LNF: if that fl is multiplied, this is the + * respective constant after pre-normalization. + */ + float c; + + /* in NUMBER nodes + */ + float value; + + /* in MINUS nodes + */ + struct _ExpNode *son; + + /* in all others + */ + struct _ExpNode *leftson, *rightson; + +} ExpNode, *ExpNode_pointer; + + + +typedef struct _WffNode { + + Connective connective; + + /* in ALL/EX s + */ + int var, var_type; + char *var_name; + + /* in AND/OR s + */ + struct _WffNode *sons; + /* sons are doubly connected linear list + */ + struct _WffNode *next; + struct _WffNode *prev; + + /* in ATOMs + */ + Fact *fact; + /* after translation: mark NOT-p s for efficiency + */ + int NOT_p; + + /* in ALL/EX/NOT + */ + struct _WffNode *son; + + /* in COMP + */ + Comparator comp; + ExpNode *lh, *rh; + + /* for expansion speedup + */ + Bool visited; + + /* no WHEN s here... use Pl Connectives anyway for simplicity + */ + +} WffNode, *WffNode_pointer; + + + +typedef struct _Literal { + + Bool negated; + + Fact fact; + + struct _Literal *next; + struct _Literal *prev; + +} Literal; + + + +typedef struct _NumericEffect { + + Fluent fluent; + NumericEffectType neft; + + ExpNode *rh; + + struct _NumericEffect *next; + struct _NumericEffect *prev; + +} NumericEffect; + + + +typedef struct _Effect { + + int num_vars, var_types[MAX_VARS]; + char *var_names[MAX_VARS]; + + WffNode *conditions; + + Literal *effects; + NumericEffect *numeric_effects; + + struct _Effect *next; + struct _Effect *prev; + +} Effect; + + + +typedef struct _Operator { + + char *name, *var_names[MAX_VARS]; + int number_of_real_params; + Bool axiom; + + int num_vars, var_types[MAX_VARS]; + Bool removed[MAX_VARS]; + + WffNode *preconds; + + Effect *effects; + + Bool hard; + +} Operator, *Operator_pointer; + + + + + + +/* second step: structures that keep already normalized + * operators + */ + + + + +typedef struct _NormEffect { + + int num_vars, var_types[MAX_VARS]; + int inst_table[MAX_VARS]; + + Fact *conditions; + int num_conditions; + + Fact *adds; + int num_adds; + Fact *dels; + int num_dels; + + /* numerical parts: not yet normalized any further; seems that + * normalizing requires certain additional structures + + * transformation, and that these will better be done when + * the representation is fully instantiated already. + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + Fluent *numeric_effects_fluent; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + struct _NormEffect *prev; + struct _NormEffect *next; + +} NormEffect; + + + +typedef struct _NormOperator { + + Operator *operator; + + int num_vars, var_types[MAX_VARS]; + int inst_table[MAX_VARS]; + int removed_vars[MAX_VARS], num_removed_vars, type_removed_vars[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric precondition still full scale represented, see above + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + NormEffect *effects; + + Bool out; + +} NormOperator, *NormOperator_pointer; + + + +/* minimal info for a fully instantiated easy operator; + * yields one action when expanded + */ +typedef struct _EasyTemplate { + + NormOperator *op; + int inst_table[MAX_VARS]; + + struct _EasyTemplate *prev; + struct _EasyTemplate *next; + +} EasyTemplate; + + + + + + +/* structures for hard ops + */ + + + + + +/* intermediate step: structure for keeping hard ops + * with normalized precondition, but arbitrary + * effect conditions + */ +typedef struct _MixedOperator { + + Operator *operator; + + int inst_table[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric part, pre-normalized + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + Effect *effects; + + struct _MixedOperator *next; + +} MixedOperator; + + + +/* last hard step: everything is action - like, except that + * facts are not yet integer coded + */ + + + +typedef struct _PseudoActionEffect { + + Fact *conditions; + int num_conditions; + + Fact *adds; + int num_adds; + Fact *dels; + int num_dels; + + + /* and the numeric parts again... + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + Fluent *numeric_effects_fluent; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + struct _PseudoActionEffect *next; + +} PseudoActionEffect; + + + +typedef struct _PseudoAction { + + Operator *operator; + + int inst_table[MAX_VARS]; + + Fact *preconds; + int num_preconds; + /* numeric part, pre-normalized + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + PseudoActionEffect *effects; + int num_effects; + +} PseudoAction, *PseudoAction_pointer; + + + + +/* final domain representation structure + */ + + + +typedef struct _LnfExpNode { + + int pF[MAX_LNF_F]; + float pC[MAX_LNF_F]; + int num_pF; + + int nF[MAX_LNF_F]; + float nC[MAX_LNF_F]; + int num_nF; + + float c; + +} LnfExpNode, *LnfExpNode_pointer; + + + +typedef struct _ActionEffect { + + int *conditions; + int num_conditions; + + int *adds; + int num_adds; + int *dels; + int num_dels; + + /* and the numeric parts again; fluents all as fl ints; + * + * normalization for cond as below for pre; + * norm. for effects by restriction of types (?), + * right hand side float (?) + */ + Comparator *numeric_conditions_comp; + ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; + int num_numeric_conditions; + + NumericEffectType *numeric_effects_neft; + int *numeric_effects_fl; + ExpNode_pointer *numeric_effects_rh; + int num_numeric_effects; + + /* LNF + */ + Comparator *lnf_conditions_comp; + LnfExpNode_pointer *lnf_conditions_lh; + float *lnf_conditions_rh; + int num_lnf_conditions; + + NumericEffectType *lnf_effects_neft; + int *lnf_effects_fl; + LnfExpNode_pointer *lnf_effects_rh; + int num_lnf_effects; + + /* this is true iff the numerical part of the effects affects or accesses + * an undefined fluent (i.e. in numeric_effects_fl or numeric_effects_rh ) + * --- then, if the effect appears, the action is + * illegal. + */ + Bool illegal; + + /* helper + */ + Bool removed; + + float cost; + +} ActionEffect; + + + +typedef struct _Action { + + NormOperator *norm_operator; + PseudoAction *pseudo_action; + Bool axiom; + + char *name; + int num_name_vars; + int name_inst_table[MAX_VARS]; + + int inst_table[MAX_VARS]; + + int *preconds; + int num_preconds; + /* numeric part, in general format, with fluents encoded as fl ints + * + * also, will (?) be transformed to lh fl, rh float; then, expnodes as + * fast accessible as specialised structures. + */ + Comparator *numeric_preconds_comp; + ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; + int num_numeric_preconds; + + /* LNF + */ + Comparator *lnf_preconds_comp; + LnfExpNode_pointer *lnf_preconds_lh; + float *lnf_preconds_rh; + int num_lnf_preconds; + + ActionEffect *effects; + int num_effects; + + struct _Action *next; + +} Action; + + + + + + + + + + + +/***************************************************** + * BASIC OP AND FT STRUCTURES FOR CONNECTIVITY GRAPH * + *****************************************************/ + + + + + + + + + + + +typedef struct _OpConn { + + /* to get name + */ + Action *action; + Bool axiom; + + /* effects + */ + int *E; + int num_E; + + /* member for applicable actions extraction + */ + Bool is_in_A; + Bool is_in_A_axioms; + + /* members for 1Ph - H(S) extraction + */ + int is_used; + Bool is_in_H; + + /* this is a bit imprecise since actually, in this + * framework here, the cost of the action may depend on + * which conditional effects actually apply. + * ... anyway, this makes things much easier for the case + * where there aren't any effect conditions. all cost handling + * is now based on this..!! + */ + float cost; + +} OpConn; + + + +typedef struct _EfConn { + + int op; + + /* true if access to always undefined fluent, or + * conflicting assignments. + * + * if that is the case then nothing except condition is set: + * the effect is completely ignored except that + * it renders the op unapplicable when its condition + * is true. + */ + Bool illegal; + + /* this one means we found in conn that it is useless (empty) + */ + Bool removed; + + /* this is the cost; can be non-zero if a metric was specified + * and established + */ + float cost; + + int *PC; + int num_PC; + /* numeric part + */ + Comparator *f_PC_comp; /* either GEQ or GE */ + int *f_PC_fl; + float *f_PC_c; + int num_f_PC; + /* array indexed by fl number, to fast know whether + * new fluent value is high enough + */ + Comparator *f_PC_direct_comp; + float *f_PC_direct_c; + + /* logic effects + */ + int *A; + int num_A; + int *D; + int num_D; + /* and the numeric ones; fl_ is the encoding of the LNF + * on the right hand side, without constant part + * (special treatment for that as it's supposed + * to be the most common thing!!) + */ + int *IN_fl; + int *IN_fl_; + float *IN_c; + int num_IN; + + int *AS_fl; + int *AS_fl_; + float *AS_c; + int num_AS; + + /* implied effects + */ + int *I; + int num_I; + + /* members for relaxed fixpoint computation + */ + int level;/* first "cost level" where ef appears */ + float RPGcost;/* max_{p prec} cost(p)+cost(op(ef)) */ + + Bool in_E; + int num_active_PCs; + Bool ch; + + /* RPG + */ + int num_active_f_PCs; + + /* 1P; an effect can be selected several times + * for increasing a fluent. + */ + int in_plan; + +} EfConn; + + + +typedef struct _FtConn { + + /* effects it is union conds, pres element of + */ + int *PC; + int num_PC; + + /* efs that add or del it + */ + int *A; + int num_A; + + int *D; + int num_D; + + /* members for orderings preprocessing + */ + int *False; + int num_False; + + /* members for relaxed fixpoint computation + */ + int level;/* first "cost level" where ft appears */ + float RPGcost;/* min_{e adder} cost(e) */ + Bool in_F; + + /* members for 1Ph extraction + */ + int is_goal; + int is_true; + Bool ch; + + /* search + */ + int rand;/* for hashing */ + + /* is this the effect of an axiom? + * needed to quickly filter out derived facts, in state + * transitions! + */ + Bool axiom_added; + +} FtConn; + + + +typedef struct _FlConn { + + /* effects it is union conds, pres required + */ + int *PC; + int num_PC; + + /* efs that inc, ass it and by which encoded fluents and constants + */ + int *IN; + int *IN_fl_; + float *IN_c; + int num_IN; + + int *AS; + int *AS_fl_; + float *AS_c;/* see above */ + int num_AS; + + /* is it an artificial fluent? + */ + Bool artificial; + /* if so, then this here is the linear equation + * it stands for + */ + int *lnf_F; + float *lnf_C; + int num_lnf; + + + /* the termination criterion for RPG building is based on mneed, see + * JAIR article for definition; + * + * as the name suggests, we use the bool to indicate that this one is not + * needed at all + */ + Bool mneed_is_minusinfty; + float mneed; + /* see JAIR; shortcut for never needed at all. + */ + Bool relevant; + + /* the following are members handled within heuristic algorithms. + */ + + /* this are arrays saying what the max value at + * the levels in the RPG is, resp. whether the value + * can be defined there at all, resp. what the increasers + * at that level have added. + */ + Bool *def; + float *level; + + /* for handling assigners in RPG: is an assigner in there yet, + * and if so what is their max value? + */ + Bool curr_assigned; + float curr_max_assigned; + + int rand;/* for hashing */ + +} FlConn; + + + + + + + + + + + + +/**************************** + * STRUCTURES FOR SEARCHING * + ****************************/ + + + + + + + + + +typedef struct _State { + + int *F; + int num_F; + + Bool *f_D; + float *f_V; + +} State, *State_pointer; + + + +typedef struct _EhcNode { + + State S; + + int op; + int depth; + + struct _EhcNode *father; + struct _EhcNode *next; + +} EhcNode; + + + +typedef struct _EhcHashEntry { + + int sum; + + EhcNode *ehc_node; + + struct _EhcHashEntry *next; + +} EhcHashEntry, *EhcHashEntry_pointer; + + + +typedef struct _PlanHashEntry { + + int sum; + State S; + + /* step is number of op that is EXECUTED in S; + * -1 means that this state is no longer contained in plan + */ + int step; + struct _PlanHashEntry *next_step; + + struct _PlanHashEntry *next; + +} PlanHashEntry, *PlanHashEntry_pointer; + + + +typedef struct _BfsNode { + + State S; + int op; + + /* number of steps from ini state to here + */ + int ini_distance; + + /* number of steps in relaxed plan for this state + */ + int goal_distance; + + /* g-value and h-value, ie summed-up cost to here, + * summed-up cost in rplan for here. + * used in all optimization configs + */ + float g; + float h; + + /* f-value. in weighted A*, f=g+w*h; in A*epsilon, f=g+h + */ + float f; + + /* The applicable actions -- may be only the helpful ones, + * in case helpful actions are used! + */ + int *A; + int num_A; + + struct _BfsNode *father; + + struct _BfsNode *next; + struct _BfsNode *prev; + +} BfsNode; + + + +typedef struct _BfsHashEntry { + + int sum; + + BfsNode *bfs_node; + + struct _BfsHashEntry *next; + +} BfsHashEntry, *BfsHashEntry_pointer; + + + + + + + + + + + + + +/* + * -------------------------------- MAIN FN HEADERS ---------------------------- + */ + + + + + + + + + + + + + + + + + +void output_planner_info( void ); +void ff_usage( void ); +Bool process_command_line( int argc, char *argv[] ); + + + + + + + + + +/* + * ----------------------------- GLOBAL VARIABLES ---------------------------- + */ + + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + + + +/* used to time the different stages of the planner + */ +extern float gtempl_time, greach_time, grelev_time, gconn_time; +extern float gLNF_time, gsearch_time; + +/* the command line inputs + */ +extern struct _command_line gcmd_line; + +/* number of states that got heuristically evaluated + */ +extern int gevaluated_states; + +/* maximal depth of breadth first search + */ +extern int gmax_search_depth; + + + + + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + + + + + +/* used for pddl parsing, flex only allows global variables + */ +extern int gbracket_count; +extern char *gproblem_name; + +/* The current input line number + */ +extern int lineno; + +/* The current input filename + */ +extern char *gact_filename; + +/* The pddl domain name + */ +extern char *gdomain_name; + +/* loaded, uninstantiated operators + */ +extern PlOperator *gloaded_ops; + +/* stores initials as fact_list + */ +extern PlNode *gorig_initial_facts; + +/* not yet preprocessed goal facts + */ +extern PlNode *gorig_goal_facts; + +/* the types, as defined in the domain file + */ +extern TypedList *gparse_types; + +/* the constants, as defined in domain file + */ +extern TypedList *gparse_constants; + +/* the predicates and their arg types, as defined in the domain file + */ +extern TypedListList *gparse_predicates; + +/* the functions and their arg types, as defined in the domain file + */ +extern TypedListList *gparse_functions; + +/* the objects, declared in the problem file + */ +extern TypedList *gparse_objects; + +/* the metric + */ +extern Token gparse_optimization; +extern ParseExpNode *gparse_metric; + + +/* connection to instantiation ( except ops, goal, initial ) + */ + +/* all typed objects + */ +extern FactList *gorig_constant_list; + +/* the predicates and their types + */ +extern FactList *gpredicates_and_types; + +/* the functions and their types + */ +extern FactList *gfunctions_and_types; + + + + + + + + + + + + + + +/***************** + * INSTANTIATING * + *****************/ + + + + + + + + + + +/* global arrays of constant names, + * type names (with their constants), + * predicate names, + * predicate aritys, + * defined types of predicate args + */ +extern Token gconstants[MAX_CONSTANTS]; +extern int gnum_constants; +extern Token gtype_names[MAX_TYPES]; +extern int gtype_consts[MAX_TYPES][MAX_TYPE]; +extern Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; +extern int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ +extern int gtype_size[MAX_TYPES]; +extern int gnum_types; +extern Token gpredicates[MAX_PREDICATES]; +extern int garity[MAX_PREDICATES]; +extern Bool gaxiom_added[MAX_PREDICATES]; +extern int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; +extern int gnum_predicates; +extern Token gfunctions[MAX_FUNCTIONS]; +extern int gf_arity[MAX_FUNCTIONS]; +extern int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; +extern int gnum_functions; + + + + +/* the domain in first step integer representation + */ +extern Operator_pointer goperators[MAX_OPERATORS]; +extern int gnum_operators; +extern Fact *gfull_initial; +extern int gnum_full_initial; +extern FluentValue *gfull_fluents_initial; +extern int gnum_full_fluents_initial; +extern WffNode *ggoal; + +extern ExpNode *gmetric; + + + +/* stores inertia - information: is any occurence of the predicate + * added / deleted in the uninstantiated ops ? + */ +extern Bool gis_added[MAX_PREDICATES]; +extern Bool gis_deleted[MAX_PREDICATES]; + +/* for functions we *might* want to say, symmetrically, whether it is + * increased resp. decreased at all. + * + * that is, however, somewhat involved because the right hand + * sides can be arbirtray expressions, so we have no guarantee + * that increasing really does adds to a functions value... + * + * thus (for the time being), we settle for "is the function changed at all?" + */ +extern Bool gis_changed[MAX_FUNCTIONS]; + + + +/* splitted initial state: + * initial non static facts, + * initial static facts, divided into predicates + * (will be two dimensional array, allocated directly before need) + */ +extern Facts *ginitial; +extern int gnum_initial; +extern Fact **ginitial_predicate; +extern int *gnum_initial_predicate; + +/* same thing for functions + */ +extern FluentValues *gf_initial; +extern int gnum_f_initial; +extern FluentValue **ginitial_function; +extern int *gnum_initial_function; + + + +/* the type numbers corresponding to any unary inertia + */ +extern int gtype_to_predicate[MAX_PREDICATES]; +extern int gpredicate_to_type[MAX_TYPES]; + +/* (ordered) numbers of types that new type is intersection of + */ +extern TypeArray gintersected_types[MAX_TYPES]; +extern int gnum_intersected_types[MAX_TYPES]; + + + +/* splitted domain: hard n easy ops + */ +extern Operator_pointer *ghard_operators; +extern int gnum_hard_operators; +extern NormOperator_pointer *geasy_operators; +extern int gnum_easy_operators; + + + +/* so called Templates for easy ops: possible inertia constrained + * instantiation constants + */ +extern EasyTemplate *geasy_templates; +extern int gnum_easy_templates; + + + +/* first step for hard ops: create mixed operators, with conjunctive + * precondition and arbitrary effects + */ +extern MixedOperator *ghard_mixed_operators; +extern int gnum_hard_mixed_operators; + + + +/* hard ''templates'' : pseudo actions + */ +extern PseudoAction_pointer *ghard_templates; +extern int gnum_hard_templates; + + + +/* store the final "relevant facts" + */ +extern Fact grelevant_facts[MAX_RELEVANT_FACTS]; +extern int gnum_relevant_facts; +extern int gnum_pp_facts; +/* store the "relevant fluents" + */ +extern Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; +extern int gnum_relevant_fluents; +extern Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; +/* this is NULL for normal, and the LNF for + * artificial fluents. + */ +extern LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; + + + +/* the final actions and problem representation + */ +extern Action *gactions; +extern int gnum_actions; +extern State ginitial_state; +extern int *glogic_goal; +extern int gnum_logic_goal; +extern Comparator *gnumeric_goal_comp; +extern ExpNode_pointer *gnumeric_goal_lh, *gnumeric_goal_rh; +extern int gnum_numeric_goal; + + + +/* to avoid memory leaks; too complicated to identify + * the exact state of the action to throw away (during construction), + * memory gain not worth the implementation effort. + */ +extern Action *gtrash_actions; + + + +/* additional lnf step between finalized inst and + * conn graph + */ +extern Comparator *glnf_goal_comp; +extern LnfExpNode_pointer *glnf_goal_lh; +extern float *glnf_goal_rh; +extern int gnum_lnf_goal; + +extern LnfExpNode glnf_metric; +extern Bool goptimization_established; + + + +/********************** + * CONNECTIVITY GRAPH * + **********************/ + + + + + +/* one ops (actions) array ... + */ +extern OpConn *gop_conn; +extern int gnum_op_conn; + + + +/* one effects array ... + */ +extern EfConn *gef_conn; +extern int gnum_ef_conn; + + + +/* one facts array. + */ +extern FtConn *gft_conn; +extern int gnum_ft_conn; + + + +/* and: one fluents array. + */ +extern FlConn *gfl_conn; +extern int gnum_fl_conn; +extern int gnum_real_fl_conn;/* number of non-artificial ones */ + + + +/* final goal is also transformed one more step. + */ +extern int *gflogic_goal; +extern int gnum_flogic_goal; +extern Comparator *gfnumeric_goal_comp; +extern int *gfnumeric_goal_fl; +extern float *gfnumeric_goal_c; +extern int gnum_fnumeric_goal; + +/* direct access (by relevant fluents) + */ +extern Comparator *gfnumeric_goal_direct_comp; +extern float *gfnumeric_goal_direct_c; + + + + + + + + + + + + + +/******************* + * SEARCHING NEEDS * + *******************/ + + + + + + + + + + + + +/* applicable actions + */ +extern int *gA;/* non-axioms */ +extern int gnum_A; +extern int *gA_axioms; /* axioms */ +extern int gnum_A_axioms; + + + +/* communication from extract 1.P. to search engine: + * 1P action choice + */ +extern int *gH; +extern int gnum_H; +/* added cost of relaxed plan + */ +extern float gh_cost; +/* hmax value + */ +extern float ghmax; + + + +/* to store plan + */ +extern int gplan_ops[MAX_PLAN_LENGTH]; +extern int gnum_plan_ops; + + + +/* stores the states that the current plan goes through + */ +extern State gplan_states[MAX_PLAN_LENGTH + 1]; + + + +/* dirty: multiplic. of total-time in final metric LNF + */ +extern float gtt; + + + + + + +/* the mneed structures + * + * assign propagation pairs i, j, and transitive such pairs. + */ +extern Bool **gassign_influence; +extern Bool **gTassign_influence; + + + +/* the real var input to the mneed computation. + */ +extern Bool *gmneed_start_D; +extern float *gmneed_start_V; + + + +/* does this contain conditional effects? + * (if it does then the state hashing has to be made more + * cautiously) + */ +extern Bool gconditional_effects; + + +/* easier to question: are we optimizing or no? + */ +extern Bool gcost_minimizing; + + +/* stores current A* weight: this is initially given by user, + * but changes during anytime search. + */ +extern float gw; +/* this is the minimum weight, ie we'll stop once the weight update + * does/would yield a value <= this. + * if no such minim weight is given, this will be -1 + */ +extern float gmin_w; + + +/* this one says whether or not we are actually using + * cost-minimizing rplans. + * this will be the case by default if we're running cost- + * minimizing searches. it can be switched off by a flag; + * it is automatically switched off in case there are + * numeric preconditions/goals: for this case, + * cost-minimizing rplans are not implemented (a numeric prec + * may cause an action to come in "later" on in the RPG although + * its logical pres are easy. in that case, any new effects will + * have a smaller RPGcost value than facts we already have waiting. + * in other words, the "Dijsktra" nature breaks. + * + * ... I suppose there may be a generic solution to this that + * can handle numeric precs/goals. Doesn't seem important enough + * to bother. + */ +extern Bool gcost_rplans; + + +#endif diff --git a/models/main_models/rt1/gen/ff_planner/inst_easy.c b/models/main_models/rt1/gen/ff_planner/inst_easy.c new file mode 100644 index 000000000..db6c1681b --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_easy.c @@ -0,0 +1,1220 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: inst_easy.c + * Description: functions for multiplying easy operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_easy.h" + + + + + + + + +void build_easy_action_templates( void ) + +{ + + int i, j; + NormOperator *o; + EasyTemplate *t; + + cleanup_easy_domain(); + + if ( gcmd_line.display_info == 110 ) { + printf("\n\ncleaned up easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + encode_easy_unaries_as_types(); + + if ( gcmd_line.display_info == 111 ) { + printf("\n\nunaries encoded easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + multiply_easy_effect_parameters(); + + if ( gcmd_line.display_info == 112 ) { + printf("\n\neffects multiplied easy operators are:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + fflush( stdout ); + } + + multiply_easy_op_parameters(); + + if ( gcmd_line.display_info == 113 ) { + printf("\n\ninertia free easy operators are:"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + printf("\n\n"); + fflush( stdout ); + } + + if ( gcmd_line.display_info == 114 ) { + printf("\n\neasy operator templates are:\n"); + + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + printf("\n\n-----------operator %s:-----------", o->operator->name); + for ( t = geasy_templates; t; t = t->next ) { + if ( t->op != o ) { + continue; + } + printf("\ninst: "); + for ( j = 0; j < o->num_vars; j++ ) { + if ( t->inst_table[j] < 0 ) { + printf("\nuninstantiated param in template! debug me, please\n\n"); + exit( 1 ); + } + printf("x%d = %s", j, gconstants[t->inst_table[j]]); + if ( j < o->num_vars - 1 ) { + printf(", "); + } + } + } + } + fflush( stdout ); + } + +} + + + + + + + + + + + +/********************************* + * EASY DOMAIN CLEANUP FUNCTIONs * + *********************************/ + + + + + + + + + + + +void cleanup_easy_domain( void ) + +{ + + int i, i1, i2, i3, i4, a; + NormOperator *o; + NormEffect *e; + + /* most likely ( for sure ? ) we do not need this function call here, + * as empty types are recognised in translation already. + * + * however, who knows .. ? doesn't need any real computation time anyway. + * + * function DOES make sense after unaries encoding, as artificial types + * might well be empty. + */ + handle_empty_easy_parameters(); + + /* remove identical preconds and effects; + * VERY unlikely that such will get down to here, after all + * the formula preprocessing, but possible (?) in principle. + * takes no computation time. + * + * also, remove effect conditions that are contained in the + * preconditions. + */ + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + i1 = 0; + while ( i1 < o->num_preconds-1 ) { + i2 = i1+1; + while ( i2 < o->num_preconds ) { + if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) { + for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) { + o->preconds[i3].predicate = o->preconds[i3+1].predicate; + for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) { + o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4]; + } + } + o->num_preconds--; + } else { + i2++; + } + } + i1++; + } + + for ( e = o->effects; e; e = e->next ) { + i1 = 0; + while ( i1 < e->num_conditions-1 ) { + i2 = i1+1; + while ( i2 < e->num_conditions ) { + if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) { + for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) { + e->conditions[i3].predicate = e->conditions[i3+1].predicate; + /* here, we can still have equalities. nowhere else. + */ + a = ( e->conditions[i3].predicate < 0 ) ? + 2 : garity[e->conditions[i3].predicate]; + for ( i4 = 0; i4 < a; i4++ ) { + e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4]; + } + } + e->num_conditions--; + } else { + i2++; + } + } + i1++; + } + + i1 = 0; + while ( i1 < e->num_conditions ) { + for ( i2 = 0; i2 < o->num_preconds; i2++ ) { + if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) { + break; + } + } + if ( i2 == o->num_preconds ) { + i1++; + continue; + } + for ( i2 = i1; i2 < e->num_conditions-1; i2++ ) { + e->conditions[i2].predicate = e->conditions[i2+1].predicate; + for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) { + e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3]; + } + } + e->num_conditions--; + } + + i1 = 0; + while ( i1 < e->num_adds-1 ) { + i2 = i1+1; + while ( i2 < e->num_adds ) { + if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) { + for ( i3 = i2; i3 < e->num_adds-1; i3++ ) { + e->adds[i3].predicate = e->adds[i3+1].predicate; + for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) { + e->adds[i3].args[i4] = e->adds[i3+1].args[i4]; + } + } + e->num_adds--; + } else { + i2++; + } + } + i1++; + } + + i1 = 0; + while ( i1 < e->num_dels-1 ) { + i2 = i1+1; + while ( i2 < e->num_dels ) { + if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) { + for ( i3 = i2; i3 < e->num_dels-1; i3++ ) { + e->dels[i3].predicate = e->dels[i3+1].predicate; + for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) { + e->dels[i3].args[i4] = e->dels[i3+1].args[i4]; + } + } + e->num_dels--; + } else { + i2++; + } + } + i1++; + } + } + } + +} + + + +Bool identical_fact( Fact *f1, Fact *f2 ) + +{ + + int i, a; + + if ( f1->predicate != f2->predicate ) { + return FALSE; + } + + a = ( f1->predicate < 0 ) ? 2 : garity[f1->predicate]; + + for ( i = 0; i < a; i++ ) { + if ( f1->args[i] != f2->args[i] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +/* this one needs ONLY be used after unaries encoding, as all empty types + * are already recognised during translation, except the artificial ones, + * of course. + */ +void handle_empty_easy_parameters( void ) + +{ + + int i, j, k; + NormOperator *o; + NormEffect *e, *tmp; + + i = 0; + while ( i < gnum_easy_operators ) { + o = geasy_operators[i]; + + for ( j = 0; j < o->num_vars; j++ ) { + if ( gtype_size[o->var_types[j]] == 0 ) { + break; + } + } + if ( j < o->num_vars ) { + free_NormOperator( o ); + for ( k = i; k < gnum_easy_operators - 1; k++ ) { + geasy_operators[k] = geasy_operators[k+1]; + } + gnum_easy_operators--; + } else { + i++; + } + } + + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + e = o->effects; + while ( e ) { + for ( j = 0; j < e->num_vars; j++ ) { + if ( gtype_size[e->var_types[j]] == 0 ) { + break; + } + } + if ( j < e->num_vars ) { + if ( e->prev ) { + e->prev->next = e->next; + } else { + o->effects = e->next; + } + if ( e->next ) { + e->next->prev = e->prev; + } + tmp = e->next; + free_single_NormEffect( e ); + e = tmp; + } else { + e = e->next; + } + } + } + +} + + + + + + + + + + +/**************************** + * UNARY INERTIA INTO TYPES * + ****************************/ + + + + + + + + + + + + +void encode_easy_unaries_as_types( void ) + +{ + + NormOperator *o; + int i1, i, j, k, l, new_T, p, a; + TypeArray T; + int num_T; + NormEffect *e; + int intersected_type, var; + + for ( i1 = 0; i1 < gnum_easy_operators; i1++ ) { + o = geasy_operators[i1]; + + for ( i = 0; i < o->num_vars; i++ ) { + + T[0] = o->var_types[i]; + num_T = 1; + + j = 0; + while ( j < o->num_preconds ) { + p = o->preconds[j].predicate; + if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && + ( o->preconds[j].args[0] == ENCODE_VAR( i ) ) ) { + if ( num_T == MAX_TYPE_INTERSECTIONS ) { + printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", + MAX_TYPE_INTERSECTIONS); + exit( 1 ); + } + /* insert new type number into ordered array T; + * ---- all type numbers in T are different: + * new nr. is of inferred type - can't be type declared for param + * precondition facts occur at most once - doubles are removed + * during cleanup + */ + for ( k = 0; k < num_T; k++ ) { + if ( new_T < T[k] ) { + break; + } + } + for ( l = num_T; l > k; l-- ) { + T[l] = T[l-1]; + } + T[k] = new_T; + num_T++; + /* now remove superfluous precondition + */ + for ( k = j; k < o->num_preconds-1; k++ ) { + o->preconds[k].predicate = o->preconds[k+1].predicate; + for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { + o->preconds[k].args[l] = o->preconds[k+1].args[l]; + } + } + o->num_preconds--; + } else { + j++; + } + } + + /* if we did not hit any unary inertia concerning this parameter + * in the preconds, skip parameter and go to next one + */ + if ( num_T == 1 ) { + continue; + } + + /* now we have the ordered array of types to intersect for param i + * of op o in array T of size num_T; + * if there already is this intersected type, set type of this + * param to its number, otherwise create the new intersected type. + */ + if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { + /* type already there + */ + o->var_types[i] = intersected_type; + continue; + } + + /* create new type + */ + o->var_types[i] = create_intersected_type( T, num_T ); + } + + for ( e = o->effects; e; e = e->next ) { + for ( i = 0; i < e->num_vars; i++ ) { + T[0] = e->var_types[i]; + var = o->num_vars + i; + num_T = 1; + j = 0; + while ( j < e->num_conditions ) { + p = e->conditions[j].predicate; + if ( p < 0 ) { + j++; + continue; + } + if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && + ( e->conditions[j].args[0] == ENCODE_VAR( var ) ) ) { + if ( num_T == MAX_TYPE_INTERSECTIONS ) { + printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", + MAX_TYPE_INTERSECTIONS); + exit( 1 ); + } + for ( k = 0; k < num_T; k++ ) { + if ( new_T < T[k] ) { + break; + } + } + for ( l = num_T; l > k; l-- ) { + T[l] = T[l-1]; + } + T[k] = new_T; + num_T++; + for ( k = j; k < e->num_conditions-1; k++ ) { + e->conditions[k].predicate = e->conditions[k+1].predicate; + a = ( e->conditions[k].predicate < 0 ) ? + 2 : garity[e->conditions[k].predicate]; + for ( l = 0; l < a; l++ ) { + e->conditions[k].args[l] = e->conditions[k+1].args[l]; + } + } + e->num_conditions--; + } else { + j++; + } + } + if ( num_T == 1 ) { + continue; + } + if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { + e->var_types[i] = intersected_type; + continue; + } + e->var_types[i] = create_intersected_type( T, num_T ); + } + } + } + + handle_empty_easy_parameters(); + +} + + + +int create_intersected_type( TypeArray T, int num_T ) + +{ + + int i, j, k, intersected_type; + + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many (inferred and intersected) types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_names[gnum_types] = NULL; + gtype_size[gnum_types] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][gnum_types] = FALSE; + } + for ( i = 0; i < num_T; i++ ) { + gintersected_types[gnum_types][i] = T[i]; + } + gnum_intersected_types[gnum_types] = num_T; + intersected_type = gnum_types; + gnum_types++; + + for ( j = 0; j < gtype_size[T[0]]; j++ ) { + for ( k = 1; k < num_T; k++ ) { + if ( !gis_member[gtype_consts[T[0]][j]][T[k]] ) { + break; + } + } + if ( k < num_T ) { + continue; + } + /* add constant to new type + */ + if ( gtype_size[intersected_type] == MAX_TYPE ) { + printf("\ntoo many consts in intersected type! increase MAX_TYPE (currently %d)\n\n", + MAX_TYPE); + exit( 1 ); + } + gtype_consts[intersected_type][gtype_size[intersected_type]++] = gtype_consts[T[0]][j]; + gis_member[gtype_consts[T[0]][j]][intersected_type] = TRUE; + } + + /* now verify if the intersected type equals one of the types that we intersected. + * this is the case, iff one of the types in T has the same size as intersected_type + */ + for ( j = 0; j < num_T; j++ ) { + if ( gtype_size[intersected_type] != gtype_size[T[j]] ) { + continue; + } + /* type T[j] contains exactly the constants that we need! + * + * remove intersected type from table! + */ + gtype_size[intersected_type] = 0; + for ( k = 0; k < MAX_CONSTANTS; k++ ) { + gis_member[k][intersected_type] = FALSE; + } + gnum_intersected_types[intersected_type] = -1; + gnum_types--; + intersected_type = T[j]; + break; + } + + return intersected_type; + +} + + + +int find_intersected_type( TypeArray T, int num_T ) + +{ + + int i, j; + + for ( i = 0; i < gnum_types; i++ ) { + if ( gnum_intersected_types[i] == -1 ) { + continue; + } + + if ( gnum_intersected_types[i] != num_T ) { + continue; + } + + for ( j = 0; j < num_T; j++ ) { + if ( T[j] != gintersected_types[i][j] ) { + break; + } + } + if ( j < num_T ) { + continue; + } + + return i; + } + + return -1; + +} + + + + + + + + + + + + + + +/****************************** + * MULTIPLY EFFECT PARAMETERS * + ******************************/ + + + + + + + + + + + + +/* local globals for multiplying + */ + +int linertia_conds[MAX_VARS]; +int lnum_inertia_conds; + +int lmultiply_parameters[MAX_VARS]; +int lnum_multiply_parameters; + +NormOperator *lo; +NormEffect *le; + +NormEffect *lres; + + + + + + +void multiply_easy_effect_parameters( void ) + +{ + + int i, j, k, l, p, par; + NormEffect *e; + + for ( i = 0; i < gnum_easy_operators; i++ ) { + lo = geasy_operators[i]; + + lres = NULL; + for ( e = lo->effects; e; e = e->next ) { + le = e; + + lnum_inertia_conds = 0; + for ( j = 0; j < e->num_conditions; j++ ) { + for ( k = 0; k < garity[e->conditions[j].predicate]; k++ ) { + if ( e->conditions[j].args[k] < 0 && + DECODE_VAR( e->conditions[j].args[k] ) < lo->num_vars ) { + break; + } + } + if ( k < garity[e->conditions[j].predicate] ) { + /* only consider inertia constraining effect parameters + */ + continue; + } + if ( !gis_added[e->conditions[j].predicate] && + !gis_deleted[e->conditions[j].predicate] ) { + linertia_conds[lnum_inertia_conds++] = j; + } + } + + lnum_multiply_parameters = 0; + for ( j = 0; j < e->num_vars; j++ ) { + par = lo->num_vars + j; + for ( k = 0; k < lnum_inertia_conds; k++ ) { + p = e->conditions[linertia_conds[k]].predicate; + for ( l = 0; l < garity[p]; l++ ) { + if ( e->conditions[linertia_conds[k]].args[l] == + ENCODE_VAR( par ) ) { + break; + } + } + if ( l < garity[p] ) { + break; + } + } + if ( k < lnum_inertia_conds ) { + continue; + } + lmultiply_parameters[lnum_multiply_parameters++] = j; + } + + unify_easy_inertia_conditions( 0 ); + } + free_NormEffect( lo->effects ); + lo->effects = lres; + } + +} + + + +void unify_easy_inertia_conditions( int curr_inertia ) + +{ + + int p, i, j, af, hh; + int args[MAX_VARS]; + int affected_params[MAX_VARS]; + int num_affected_params = 0; + + if ( curr_inertia == lnum_inertia_conds ) { + multiply_easy_non_constrained_effect_parameters( 0 ); + return; + } + + p = le->conditions[linertia_conds[curr_inertia]].predicate; + for ( i = 0; i < garity[p]; i++ ) { + args[i] = le->conditions[linertia_conds[curr_inertia]].args[i]; + if ( args[i] < 0 ) { + hh = DECODE_VAR( args[i] ); + hh -= lo->num_vars; + if ( le->inst_table[hh] != -1 ) { + args[i] = le->inst_table[hh]; + } else { + affected_params[num_affected_params++] = hh; + } + } + } + + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + af = 0; + for ( j = 0; j < garity[p]; j++ ) { + if ( args[j] >= 0 ) { + if ( args[j] != ginitial_predicate[p][i].args[j] ) { + break; + } else { + continue; + } + } + le->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; + } + if ( j < garity[p] ) { + continue; + } + + unify_easy_inertia_conditions( curr_inertia + 1 ); + } + + for ( i = 0; i < num_affected_params; i++ ) { + le->inst_table[affected_params[i]] = -1; + } + +} + + + +void multiply_easy_non_constrained_effect_parameters( int curr_parameter ) + +{ + + int t, n, i, j, k, p, par; + NormEffect *tmp; + Bool rem; + + if ( curr_parameter == lnum_multiply_parameters ) { + /* create new effect, adjusting conds to inst, and + * partially instantiating effects; + * + * add result to lres + */ + tmp = new_NormEffect2( le ); + + /* instantiate param occurences + */ + for ( i = 0; i < le->num_vars; i++ ) { + par = lo->num_vars + i; + + /* numerical part + */ + for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_conditions_lh[j]), + par, le->inst_table[i] ); + } + for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_conditions_rh[j]), + par, le->inst_table[i] ); + } + /* was that already enough to get numbers? if yes, + * see whether comparison holds or not. + */ + j = 0; + while ( j < tmp->num_numeric_conditions ) { + if ( tmp->numeric_conditions_lh[j]->connective == NUMBER && + tmp->numeric_conditions_rh[j]->connective == NUMBER ) { + if ( number_comparison_holds( tmp->numeric_conditions_comp[j], + tmp->numeric_conditions_lh[j]->value, + tmp->numeric_conditions_rh[j]->value ) ) { + free_ExpNode( tmp->numeric_conditions_lh[j] ); + free_ExpNode( tmp->numeric_conditions_rh[j] ); + for ( k = j; k < tmp->num_numeric_conditions-1; k++ ) { + tmp->numeric_conditions_comp[k] = tmp->numeric_conditions_comp[k+1]; + tmp->numeric_conditions_lh[k] = tmp->numeric_conditions_lh[k+1]; + tmp->numeric_conditions_rh[k] = tmp->numeric_conditions_rh[k+1]; + } + tmp->num_numeric_conditions--; + } else { + free_NormEffect( tmp ); + return; + } + } else { + j++; + } + } + for ( j = 0; j < tmp->num_numeric_effects; j++ ) { + for ( k = 0; k < gf_arity[tmp->numeric_effects_fluent[j].function]; k++ ) { + if ( tmp->numeric_effects_fluent[j].args[k] == ENCODE_VAR( par ) ) { + tmp->numeric_effects_fluent[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_numeric_effects; j++ ) { + replace_var_with_const_in_exp( &(tmp->numeric_effects_rh[j]), + par, le->inst_table[i] ); + } + + /* logical part + */ + for ( j = 0; j < tmp->num_conditions; j++ ) { + for ( k = 0; k < garity[tmp->conditions[j].predicate]; k++ ) { + if ( tmp->conditions[j].args[k] == ENCODE_VAR( par ) ) { + tmp->conditions[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_adds; j++ ) { + for ( k = 0; k < garity[tmp->adds[j].predicate]; k++ ) { + if ( tmp->adds[j].args[k] == ENCODE_VAR( par ) ) { + tmp->adds[j].args[k] = le->inst_table[i]; + } + } + } + for ( j = 0; j < tmp->num_dels; j++ ) { + for ( k = 0; k < garity[tmp->dels[j].predicate]; k++ ) { + if ( tmp->dels[j].args[k] == ENCODE_VAR( par ) ) { + tmp->dels[j].args[k] = le->inst_table[i]; + } + } + } + } + /* adjust conditions + */ + i = 0; + while ( i < tmp->num_conditions ) { + rem = FALSE; + p = tmp->conditions[i].predicate; + if ( !gis_added[p] && + !gis_deleted[p] ) { + for ( j = 0; j < garity[p]; j++ ) { + if ( tmp->conditions[i].args[j] < 0 && + DECODE_VAR( tmp->conditions[i].args[j] < lo->num_vars ) ) { + break; + } + } + if ( j == garity[p] ) { + /* inertia that constrain only effect params have been unified, + * are therefore TRUE + */ + rem = TRUE; + } + } + if ( rem ) { + for ( j = i; j < tmp->num_conditions - 1; j++ ) { + tmp->conditions[j].predicate = tmp->conditions[j+1].predicate; + for ( k = 0; k < garity[tmp->conditions[j+1].predicate]; k++ ) { + tmp->conditions[j].args[k] = tmp->conditions[j+1].args[k]; + } + } + tmp->num_conditions--; + } else { + i++; + } + } + /* add result to lres + */ + if ( lres ) { + lres->prev = tmp; + } + tmp->next = lres; + lres = tmp; + return; + } + + t = le->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + + for ( i = 0; i < n; i++ ) { + le->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + multiply_easy_non_constrained_effect_parameters( curr_parameter + 1 ); + } + + le->inst_table[lmultiply_parameters[curr_parameter]] = -1; + +} + + + + + + + + + + + + + + + + + + + +/************************** + * MULTIPLY OP PARAMETERS * + **************************/ + + + + + + + + + + + + + + +/* Bool bla; */ + + + + +void multiply_easy_op_parameters( void ) + +{ + + int i, j, k, l, p; + NormOperator *o; + + geasy_templates = NULL; + gnum_easy_templates = 0; + + for ( i = 0; i < gnum_easy_operators; i++ ) { + lo = geasy_operators[i]; +/* if ( strcmp(lo->operator->name, "PORT445_WIN2000") == 0 ) { */ +/* printf("\nmultiply easy OP: %s", lo->operator->name); */ +/* bla = TRUE; */ +/* } else { */ +/* bla = FALSE; */ +/* } */ + + lnum_inertia_conds = 0; + for ( j = 0; j < lo->num_preconds; j++ ) { + if ( !gis_added[lo->preconds[j].predicate] && + !gis_deleted[lo->preconds[j].predicate] ) { + linertia_conds[lnum_inertia_conds++] = j; +/* if ( bla ) { */ +/* printf("\n:inertia cond: %d (pred %s)", j, gpredicates[lo->preconds[j].predicate]); */ +/* fflush(stdout); */ +/* } */ + } + } + + + lnum_multiply_parameters = 0; + for ( j = 0; j < lo->num_vars; j++ ) { + for ( k = 0; k < lnum_inertia_conds; k++ ) { + p = lo->preconds[linertia_conds[k]].predicate; + for ( l = 0; l < garity[p]; l++ ) { + if ( lo->preconds[linertia_conds[k]].args[l] == + ENCODE_VAR( j ) ) { + break; + } + } + if ( l < garity[p] ) { + break; + } + } + if ( k < lnum_inertia_conds ) { + continue; + } +/* if ( bla ) { */ +/* printf("\nmultiply parameter: %d", j); */ +/* fflush(stdout); */ +/* } */ + lmultiply_parameters[lnum_multiply_parameters++] = j; + } + + unify_easy_inertia_preconds( 0 ); + } + + /* now remove inertia preconditions from operator schemata + */ + for ( i = 0; i < gnum_easy_operators; i++ ) { + o = geasy_operators[i]; + + j = 0; + while ( j < o->num_preconds ) { + if ( !gis_added[o->preconds[j].predicate] && + !gis_deleted[o->preconds[j].predicate] ) { + for ( k = j; k < o->num_preconds - 1; k++ ) { + o->preconds[k].predicate = o->preconds[k+1].predicate; + for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { + o->preconds[k].args[l] = o->preconds[k+1].args[l]; + } + } + o->num_preconds--; + } else { + j++; + } + } + } + +} + + + +void unify_easy_inertia_preconds( int curr_inertia ) + +{ + + int p, i, j, af, hh; + int args[MAX_VARS]; + int affected_params[MAX_VARS]; + int num_affected_params = 0; + + if ( curr_inertia == lnum_inertia_conds ) { + multiply_easy_non_constrained_op_parameters( 0 ); + return; + } + + p = lo->preconds[linertia_conds[curr_inertia]].predicate; + for ( i = 0; i < garity[p]; i++ ) { + args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i]; + if ( args[i] < 0 ) { + hh = DECODE_VAR( args[i] ); + if ( lo->inst_table[hh] != -1 ) { + args[i] = lo->inst_table[hh]; + } else { + affected_params[num_affected_params++] = hh; + } + } + } + + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + af = 0; + for ( j = 0; j < garity[p]; j++ ) { + if ( args[j] >= 0 ) { + if ( args[j] != ginitial_predicate[p][i].args[j] ) { + break; + } else { + continue; + } + } + /* check whether that constant has the correct type for that + * parameter (can be not fulfilled due to encoding of unary inertia + */ + if ( !gis_member[ginitial_predicate[p][i].args[j]][lo->var_types[affected_params[af]]] ) { + break; + } + /* legal constant; set op parameter instantiation to it + */ + lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; + } + if ( j < garity[p] ) { + continue; + } + + unify_easy_inertia_preconds( curr_inertia + 1 ); + } + + for ( i = 0; i < num_affected_params; i++ ) { + lo->inst_table[affected_params[i]] = -1; + } + +} + + + +void multiply_easy_non_constrained_op_parameters( int curr_parameter ) + +{ + + EasyTemplate *tmp; + int i, j, t, n; + +/* if ( bla ) { */ +/* printf("\nEntry multiply!"); */ +/* fflush(stdout); */ +/* } */ + + if ( curr_parameter == lnum_multiply_parameters ) { + tmp = new_EasyTemplate( lo ); + for ( i = 0; i < lo->num_vars; i++ ) { + tmp->inst_table[i] = lo->inst_table[i]; + } + tmp->next = geasy_templates; + if ( geasy_templates ) { + geasy_templates->prev = tmp; + } + geasy_templates = tmp; + gnum_easy_templates++; + return; + } + + if ( curr_parameter == lnum_multiply_parameters - 1 ) { +/* if ( bla ) { */ +/* printf("\nEntry 1 missing!"); */ +/* fflush(stdout); */ +/* } */ + t = lo->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + for ( i = 0; i < n; i++ ) { + lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + +/* if ( bla ) { */ +/* printf("\nmaking instance (numvars %d):", lo->num_vars); */ +/* fflush(stdout); */ +/* } */ + tmp = new_EasyTemplate( lo ); + for ( j = 0; j < lo->num_vars; j++ ) { + tmp->inst_table[j] = lo->inst_table[j]; +/* if ( bla ) { */ +/* printf("%s (ID %d), ", gconstants[tmp->inst_table[j]], tmp->inst_table[j]); */ +/* fflush(stdout); */ +/* } */ + } + tmp->next = geasy_templates; + if ( geasy_templates ) { + geasy_templates->prev = tmp; + } + geasy_templates = tmp; + gnum_easy_templates++; + } + + lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; + + return; + } + + t = lo->var_types[lmultiply_parameters[curr_parameter]]; + n = gtype_size[t]; + for ( i = 0; i < n; i++ ) { + lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; + + multiply_easy_non_constrained_op_parameters( curr_parameter + 1 ); + } + + lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; + +} diff --git a/models/main_models/rt1/gen/ff_planner/inst_easy.h b/models/main_models/rt1/gen/ff_planner/inst_easy.h new file mode 100644 index 000000000..1bc6eb1db --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_easy.h @@ -0,0 +1,73 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + + + +/********************************************************************* + * File: inst_easy.h + * Description: headers for multiplying easy operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + +#ifndef _INST_EASY_H +#define _INST_EASY_H + + + +void build_easy_action_templates( void ); + + + +void cleanup_easy_domain( void ); +Bool identical_fact( Fact *f1, Fact *f2 ); +void handle_empty_easy_parameters( void ); + + + +void encode_easy_unaries_as_types( void ); +int create_intersected_type( TypeArray T, int num_T ); +int find_intersected_type( TypeArray T, int num_T ); + + + +void multiply_easy_effect_parameters( void ); +void unify_easy_inertia_conditions( int curr_inertia ); +void multiply_easy_non_constrained_effect_parameters( int curr_parameter ); + + + +void multiply_easy_op_parameters( void ); +void unify_easy_inertia_preconds( int curr_inertia ); +void multiply_easy_non_constrained_op_parameters( int curr_parameter ); + + + +#endif /* _INST_EASY_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_final.c b/models/main_models/rt1/gen/ff_planner/inst_final.c new file mode 100644 index 000000000..3f51a89e6 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_final.c @@ -0,0 +1,2797 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_final.c + * Description: final domain representation functions + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_final.h" + + + + + + + + + + + + + + +/******************************** + * POSSIBLY TRUE FACTS ANALYSIS * + ********************************/ + + + + + + + + +/* local globals for this part + */ + +int_pointer lpos[MAX_PREDICATES]; +int_pointer lneg[MAX_PREDICATES]; +int_pointer luse[MAX_PREDICATES]; +int_pointer lindex[MAX_PREDICATES]; + +int lp; +int largs[MAX_VARS]; + + + +/* for collecting poss. defined fluents + */ +int_pointer lf_def[MAX_FUNCTIONS]; +int_pointer lf_index[MAX_FUNCTIONS]; + +int lf; +int lf_args[MAX_VARS]; + + + + + + +void perform_reachability_analysis( void ) + +{ + + int size, i, j, k, adr, num, pargtype; + Bool fixpoint; + Facts *f; + NormOperator *no; + EasyTemplate *t1, *t2; + NormEffect *ne; + Action *tmp, *a; + Bool *had_hard_template; + PseudoAction *pa; + PseudoActionEffect *pae; + + gactions = NULL; + gnum_actions = 0; + + for ( i = 0; i < gnum_predicates; i++ ) { + size = 1; + for ( j = 0; j < garity[i]; j++ ) { + pargtype = gpredicates_args_type[i][j]; + size *= gtype_size[pargtype]; + } + + lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + luse[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + + for ( j = 0; j < size; j++ ) { + lpos[i][j] = 0; + lneg[i][j] = 1;/* all facts but initials are poss. negative */ + luse[i][j] = 0; + lindex[i][j] = -1; + } + } + + had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) ); + for ( i = 0; i < gnum_hard_templates; i++ ) { + had_hard_template[i] = FALSE; + } + + /* mark initial facts as possibly positive, not poss. negative + */ + for ( i = 0; i < gnum_predicates; i++ ) { + lp = i; + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + for ( k = 0; k < garity[i]; k++ ) { + largs[k] = ginitial_predicate[i][j].args[k]; + } + adr = fact_adress(); + lpos[lp][adr] = 1; + lneg[lp][adr] = 0; + } + } + + /* compute fixpoint + */ + fixpoint = FALSE; + while ( !fixpoint ) { + fixpoint = TRUE; + + /* assign next layer of easy templates to possibly positive fixpoint + */ + t1 = geasy_templates; + while ( t1 ) { + no = t1->op; + for ( i = 0; i < no->num_preconds; i++ ) { + lp = no->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( no->preconds[i].args[j] >= 0 ) ? + no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; + } + if ( !lpos[lp][fact_adress()] ) { + break; + } + } + + if ( i < no->num_preconds ) { + t1 = t1->next; + continue; + } + + num = 0; + for ( ne = no->effects; ne; ne = ne->next ) { + num++; + /* currently, simply ignore effect conditions and assume + * they will all be made true eventually. + */ + for ( i = 0; i < ne->num_adds; i++ ) { + lp = ne->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->adds[i].args[j] >= 0 ) ? + ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) { + /* new relevant fact! (added non initial) + */ + lpos[lp][adr] = 1; + lneg[lp][adr] = 1; + luse[lp][adr] = 1; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + fixpoint = FALSE; + } + } + } + + tmp = new_Action(); + tmp->norm_operator = no; + tmp->axiom = no->operator->axiom; + for ( i = 0; i < no->num_vars; i++ ) { + tmp->inst_table[i] = t1->inst_table[i]; + } + tmp->name = no->operator->name; + tmp->num_name_vars = no->operator->number_of_real_params; + make_name_inst_table_from_NormOperator( tmp, no, t1 ); + tmp->next = gactions; + tmp->num_effects = num; + gactions = tmp; + gnum_actions++; + + t2 = t1->next; + if ( t1->next ) { + t1->next->prev = t1->prev; + } + if ( t1->prev ) { + t1->prev->next = t1->next; + } else { + geasy_templates = t1->next; + } + free_single_EasyTemplate( t1 ); + t1 = t2; + } + + /* now assign all hard templates that have not been transformed + * to actions yet. + */ + for ( i = 0; i < gnum_hard_templates; i++ ) { + if ( had_hard_template[i] ) { + continue; + } + pa = ghard_templates[i]; + + for ( j = 0; j < pa->num_preconds; j++ ) { + lp = pa->preconds[j].predicate; + for ( k = 0; k < garity[lp]; k++ ) { + largs[k] = pa->preconds[j].args[k]; + } + if ( !lpos[lp][fact_adress()] ) { + break; + } + } + + if ( j < pa->num_preconds ) { + continue; + } + + for ( pae = pa->effects; pae; pae = pae->next ) { + /* currently, simply ignore effect conditions and assume + * they will all be made true eventually. + */ + for ( j = 0; j < pae->num_adds; j++ ) { + lp = pae->adds[j].predicate; + for ( k = 0; k < garity[lp]; k++ ) { + largs[k] = pae->adds[j].args[k]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) { + /* new relevant fact! (added non initial) + */ + lpos[lp][adr] = 1; + lneg[lp][adr] = 1; + luse[lp][adr] = 1; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( k = 0; k < garity[lp]; k++ ) { + grelevant_facts[gnum_relevant_facts].args[k] = largs[k]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + fixpoint = FALSE; + } + } + } + + tmp = new_Action(); + tmp->pseudo_action = pa; + tmp->axiom = pa->operator->axiom; + for ( j = 0; j < pa->operator->num_vars; j++ ) { + tmp->inst_table[j] = pa->inst_table[j]; + } + tmp->name = pa->operator->name; + tmp->num_name_vars = pa->operator->number_of_real_params; + make_name_inst_table_from_PseudoAction( tmp, pa ); + tmp->next = gactions; + tmp->num_effects = pa->num_effects; + gactions = tmp; + gnum_actions++; + + had_hard_template[i] = TRUE; + } + } + + free( had_hard_template ); + + gnum_pp_facts = gnum_initial + gnum_relevant_facts; + + if ( gcmd_line.display_info == 118 ) { + printf("\nreachability analysys came up with:"); + + printf("\n\npossibly positive facts:"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + for ( i = 0; i < gnum_relevant_facts; i++ ) { + printf("\n"); + print_Fact( &(grelevant_facts[i]) ); + } + + printf("\n\nthis yields these %d action templates:", gnum_actions); + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\noperator %s:", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + printf("\ntemplate: "); + if ( a->axiom ) printf("(axiom) "); + for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) { + printf("%s", gconstants[a->name_inst_table[j]]); + if ( j < goperators[i]->num_vars-1 ) { + printf(" "); + } + } + } + } + printf("\n\n"); + } + +} + + + +/* bit complicated to avoid memory explosion when high arity predicates take + * num_obs ^ arity space. take space for individual arg types only; + * must consider pred args in smallest - to - largest - type order to make + * mapping injective. + */ +int fact_adress( void ) + +{ + + int r = 0, b = 1, i, j, min, minj; + Bool done[MAX_ARITY]; + + for ( i = 0; i < garity[lp]; i++ ) { + done[i] = FALSE; + } + + for ( i = 0; i < garity[lp]; i++ ) { + min = -1; + minj = -1; + for ( j = 0; j < garity[lp]; j++ ) { + if ( !done[j] ) { + if ( min == -1 || + gtype_size[gpredicates_args_type[lp][j]] < min ) { + min = gtype_size[gpredicates_args_type[lp][j]]; + minj = j; + } + } + } + if ( minj == -1 || min == -1 ) { + printf("\n\nmin or minj not made in fact adress?\n\n"); + exit( 1 ); + } + /* now minj is remaining arg with lowest type size min + */ + /* need number **within type** here! */ + r += b * gmember_nr[largs[minj]][gpredicates_args_type[lp][minj]]; + b *= min; + done[minj] = TRUE; + } + + return r; + +} + + + +int fluent_adress( void ) + +{ + + int r = 0, b = 1, i; + + for ( i = gf_arity[lf] - 1; i > -1; i-- ) { + r += b * lf_args[i]; + b *= gnum_constants; + } + + return r; + +} + + + +void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ) + +{ + + int i, r = 0, m = 0; + + for ( i = 0; i < o->operator->number_of_real_params; i++ ) { + if ( o->num_removed_vars > r && + o->removed_vars[r] == i ) { + /* this var has been removed in NormOp; + * insert type constraint constant + * + * at least one there, as empty typed pars ops are removed + */ + a->name_inst_table[i] = gtype_consts[o->type_removed_vars[r]][0]; + r++; + } else { + /* this par corresponds to par m in NormOp + */ + a->name_inst_table[i] = t->inst_table[m]; + m++; + } + } + +} + + + +void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ) + +{ + + int i; + + for ( i = 0; i < pa->operator->number_of_real_params; i++ ) { + a->name_inst_table[i] = pa->inst_table[i]; + } + +} + + + + + + + + + + + + + + + + + + +/*********************************************************** + * RELEVANCE ANALYSIS AND FINAL DOMAIN AND PROBLEM CLEANUP * + ***********************************************************/ + + + + + + + + + +/* counts effects for later allocation + */ +int lnum_effects; + + + + + + + + + +void collect_relevant_facts_and_fluents( void ) + +{ + + Action *a; + NormOperator *no; + NormEffect *ne; + int i, j, adr, size; + PseudoAction *pa; + PseudoActionEffect *pae; + FluentValues *fvs; + + /* facts: mark all deleted facts; such facts, that are also pos, are relevant. + */ + for ( a = gactions; a; a = a->next ) { + if ( a->norm_operator ) { + no = a->norm_operator; + + for ( ne = no->effects; ne; ne = ne->next ) { + for ( i = 0; i < ne->num_dels; i++ ) { + lp = ne->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->dels[i].args[j] >= 0 ) ? + ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; + } + adr = fact_adress(); + + lneg[lp][adr] = 1; + if ( lpos[lp][adr] && + !luse[lp][adr] ) { + luse[lp][adr] = 1; + lindex[lp][adr] = gnum_relevant_facts; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + } + } + } + } else { + pa = a->pseudo_action; + + for ( pae = pa->effects; pae; pae = pae->next ) { + for ( i = 0; i < pae->num_dels; i++ ) { + lp = pae->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->dels[i].args[j]; + } + adr = fact_adress(); + + lneg[lp][adr] = 1; + if ( lpos[lp][adr] && + !luse[lp][adr] ) { + luse[lp][adr] = 1; + lindex[lp][adr] = gnum_relevant_facts; + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = lp; + for ( j = 0; j < garity[lp]; j++ ) { + grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; + } + lindex[lp][adr] = gnum_relevant_facts; + gnum_relevant_facts++; + } + } + } + } + } + /* fluents: collect all that are defined in initial state, plus + * all that are assigned to by an effect of an action + * (i.e. preconds poss. pos. due to reachability) + * + * first initialise fast access structures + */ + for ( i = 0; i < gnum_functions; i++ ) { + size = 1; + for ( j = 0; j < gf_arity[i]; j++ ) { + size *= gnum_constants; + } + lf_def[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + lf_index[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + for ( j = 0; j < size; j++ ) { + lf_def[i][j] = 0; + lf_index[i][j] = -1; + } + } + /* from initial state, only those that are not static. + */ + for ( fvs = gf_initial; fvs; fvs = fvs->next ) { + lf = fvs->fluent.function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = fvs->fluent.args[j]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } else { + printf("\n\nfluent "); + print_Fluent( &(fvs->fluent) ); + printf(" defined twice in initial state! check input files\n\n"); + exit( 1 ); + } + } + /* from actions, all assigns (are non-static anyway) + */ + for ( a = gactions; a; a = a->next ) { + if ( a->norm_operator ) { + no = a->norm_operator; + for ( ne = no->effects; ne; ne = ne->next ) { + for ( i = 0; i < ne->num_numeric_effects; i++ ) { + if ( ne->numeric_effects_neft[i] != ASSIGN ) continue; + lf = ne->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? + ne->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } + } + } + } else { + pa = a->pseudo_action; + for ( pae = pa->effects; pae; pae = pae->next ) { + for ( i = 0; i < pae->num_numeric_effects; i++ ) { + if ( pae->numeric_effects_neft[i] != ASSIGN ) continue; + lf = pae->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( pae->numeric_effects_fluent[i].args[j] >= 0 ) ? + pae->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( pae->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + if ( !lf_def[lf][adr] ) { + lf_def[lf][adr] = 1; + if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { + printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", + MAX_RELEVANT_FLUENTS); + exit( 1 ); + } + grelevant_fluents[gnum_relevant_fluents].function = lf; + grelevant_fluents_name[gnum_relevant_fluents] = + ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); + strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); + for ( j = 0; j < gf_arity[lf]; j++ ) { + grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; + strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); + strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); + } + lf_index[lf][adr] = gnum_relevant_fluents; + gnum_relevant_fluents++; + } + } + } + } + } + + if ( gcmd_line.display_info == 119 ) { + printf("\n\nfacts selected as relevant:"); + for ( i = 0; i < gnum_relevant_facts; i++ ) { + printf("\n%d: ", i); + print_Fact( &(grelevant_facts[i]) ); + } + printf("\n\nfluents selected as relevant:"); + for ( i = 0; i < gnum_relevant_fluents; i++ ) { + printf("\n%d: ", i); + print_Fluent( &(grelevant_fluents[i]) ); + } + printf("\n\n"); + } + + lnum_effects = 0; + + create_final_goal_state(); + create_final_initial_state(); + create_final_actions(); + + if ( gmetric != NULL ) { + if ( !set_relevants_in_exp( &gmetric ) ) { + if ( gcmd_line.display_info ) { + printf("\nwarning: undefined fluent used in optimization expression. defaulting to plan length"); + } + free_ExpNode( gmetric ); + gmetric = NULL; + } + } + + if ( gcmd_line.display_info == 120 ) { + printf("\n\nfinal domain representation is:\n\n"); + + for ( i = 0; i < gnum_operators; i++ ) { + printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); + for ( a = gactions; a; a = a->next ) { + if ( ( !a->norm_operator && + !a->pseudo_action ) || + ( a->norm_operator && + a->norm_operator->operator != goperators[i] ) || + ( a->pseudo_action && + a->pseudo_action->operator != goperators[i] ) ) { + continue; + } + print_Action( a ); + } + } + printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); + for ( a = gactions; a; a = a->next ) { + if ( !a->norm_operator && + !a->pseudo_action ) { + print_Action( a ); + } + } + + printf("\n\nfinal initial state is:\n\n"); + print_State( ginitial_state ); + + printf("\n\nfinal goal is:\n\n"); + for ( i = 0; i < gnum_logic_goal; i++ ) { + print_ft_name( glogic_goal[i] ); + printf("\n"); + } + for ( i = 0; i < gnum_numeric_goal; i++ ) { + switch ( gnumeric_goal_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator in gnumeric_goal %d\n\n", gnumeric_goal_comp[i]); + exit( 1 ); + } + print_ExpNode( gnumeric_goal_lh[i] ); + print_ExpNode( gnumeric_goal_rh[i] ); + printf(")\n"); + } + + if ( gmetric ) { + printf("\n\nmetric is (minimize):\n"); + print_ExpNode( gmetric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + } + +} + + + +void create_final_goal_state( void ) + +{ + + WffNode *w, *ww; + int m, mn, i, adr; + Action *tmp; + + if ( !set_relevants_in_wff( &ggoal ) ) { + printf("\n\nff: goal accesses a fluent that will never have a defined value. Problem unsolvable.\n\n"); + exit( 1 ); + } + cleanup_wff( &ggoal ); + + if ( ggoal->connective == TRU ) { + printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); + gnum_plan_ops = 0; + exit( 1 ); + } + if ( ggoal->connective == FAL ) { + printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); + exit( 1 ); + } + + switch ( ggoal->connective ) { + case OR: + if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { + printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", + MAX_RELEVANT_FACTS); + exit( 1 ); + } + grelevant_facts[gnum_relevant_facts].predicate = -3; + gnum_relevant_facts++; + for ( w = ggoal->sons; w; w = w->next ) { + tmp = new_Action(); + if ( w->connective == AND ) { + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp->preconds = ( int * ) calloc( m, sizeof( int ) ); + tmp->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp->num_preconds = m; + tmp->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + lp = ww->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = ww->fact->args[i]; + } + adr = fact_adress(); + tmp->preconds[m] = lindex[lp][adr]; + m++; + } + if ( ww->connective == COMP ) { + tmp->numeric_preconds_comp[mn] = ww->comp; + tmp->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); + tmp->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp->preconds = ( int * ) calloc( 1, sizeof( int ) ); + tmp->num_preconds = 1; + lp = w->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = w->fact->args[i]; + } + adr = fact_adress(); + tmp->preconds[0] = lindex[lp][adr]; + } + if ( w->connective == COMP ) { + tmp->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp->numeric_preconds_comp[0] = w->comp; + tmp->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp->num_numeric_preconds = 1; + } + } + tmp->effects = ( ActionEffect * ) calloc( 1, sizeof( ActionEffect ) ); + tmp->num_effects = 1; + tmp->effects[0].conditions = NULL; + tmp->effects[0].num_conditions = 0; + tmp->effects[0].dels = NULL; + tmp->effects[0].num_dels = 0; + tmp->effects[0].adds = ( int * ) calloc( 1, sizeof( int ) ); + tmp->effects[0].adds[0] = gnum_relevant_facts - 1; + tmp->effects[0].num_adds = 1; + tmp->effects[0].numeric_conditions_comp = NULL; + tmp->effects[0].numeric_conditions_lh = NULL; + tmp->effects[0].numeric_conditions_rh = NULL; + tmp->effects[0].num_numeric_conditions = 0; + tmp->effects[0].numeric_effects_neft = NULL; + tmp->effects[0].numeric_effects_fl = NULL; + tmp->effects[0].numeric_effects_rh = NULL; + tmp->effects[0].num_numeric_effects = 0; + + tmp->next = gactions; + gactions = tmp; + gnum_actions++; + lnum_effects++; + } + glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); + glogic_goal[0] = gnum_relevant_facts - 1; + gnum_logic_goal = 1; + break; + case AND: + m = 0; mn = 0; + for ( w = ggoal->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + glogic_goal = ( int * ) calloc( m, sizeof( int ) ); + gnumeric_goal_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + gnum_logic_goal = m; + gnum_numeric_goal = mn; + m = 0; mn = 0; + for ( w = ggoal->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + lp = w->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = w->fact->args[i]; + } + adr = fact_adress(); + glogic_goal[m] = lindex[lp][adr]; + m++; + } + if ( w->connective == COMP ) { + gnumeric_goal_comp[mn] = w->comp; + gnumeric_goal_lh[mn] = copy_Exp( w->lh ); + gnumeric_goal_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + break; + case ATOM: + glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); + gnum_logic_goal = 1; + lp = ggoal->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = ggoal->fact->args[i]; + } + adr = fact_adress(); + glogic_goal[0] = lindex[lp][adr]; + break; + case COMP: + gnumeric_goal_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + gnum_numeric_goal = 1; + gnumeric_goal_comp[0] = ggoal->comp; + gnumeric_goal_lh[0] = copy_Exp( ggoal->lh ); + gnumeric_goal_rh[0] = copy_Exp( ggoal->rh ); + break; + default: + printf("\n\nwon't get here: non COMP,ATOM,AND,OR in fully simplified goal\n\n"); + exit( 1 ); + } + +} + + + +Bool set_relevants_in_wff( WffNode **w ) + +{ + + WffNode *i; + int j, adr; + + switch ( (*w)->connective ) { + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + if ( !set_relevants_in_wff( &i ) ) { + return FALSE; + } + } + break; + case ATOM: + /* no equalities, as fully instantiated + */ + lp = (*w)->fact->predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = (*w)->fact->args[j]; + } + adr = fact_adress(); + + if ( !lneg[lp][adr] ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !lpos[lp][adr] ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + break; + case COMP: + if ( !set_relevants_in_exp( &((*w)->lh) ) || + !set_relevants_in_exp( &((*w)->rh) ) ) { + return FALSE; + } + break; + default: + printf("\n\nwon't get here: non ATOM,OR,AND in goal set relevants\n\n"); + exit( 1 ); + } + + return TRUE; + +} + + + +Bool set_relevants_in_exp( ExpNode **n ) + +{ + + int j, adr; + + /* can probably (for sure) forget about the simplification + * stuff here because it's been done before. + * + * igual.... + */ + switch ( (*n)->connective ) { + case AD: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; + if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + if ( !set_relevants_in_exp( &((*n)->son) ) ) return FALSE; + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + lf = (*n)->fluent->function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = (*n)->fluent->args[j]; + } + adr = fluent_adress(); + (*n)->fl = lf_index[lf][adr]; + free( (*n)->fluent ); + (*n)->fluent = NULL; + if ( lf_index[lf][adr] == -1 ) { + if ( lf == 0 ) { + /* ATTENTION!! FUNCTION 0 IS TOTAL-TIME WHICH IS *ONLY* USED + * IN OPTIMIZATION EXPRESSION. GETS A SPECIAL TREATMENT + * IN THE RESPECTIVE FUNCTION IN SEARCH.C!!!! + * + * we remember it as fluent -2!! + */ + (*n)->fl = -2; + } else { + return FALSE; + } + } + break; + default: + printf("\n\nset relevants in expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + + return TRUE; + +} + + + +void create_final_initial_state( void ) + +{ + + Facts *f; + int i, adr, fl; + FluentValues *fvs; + + i = 0; +/* for ( f = ginitial; f; f = f->next ) i++; */ + /* we need space for transformation fluents to come! + * + * ALSO, we may need space for derived facts!!! + */ + make_state( &ginitial_state, gnum_relevant_facts + 1, MAX_RELEVANT_FLUENTS ); + + for ( f = ginitial; f; f = f->next ) { + lp = f->fact->predicate; + for ( i = 0; i < garity[lp]; i++ ) { + largs[i] = f->fact->args[i]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* non deleted ini */ + continue; + } + ginitial_state.F[ginitial_state.num_F++] = lindex[lp][adr]; + } + + for ( fvs = gf_initial; fvs; fvs = fvs->next ) { + lf = fvs->fluent.function; + for ( i = 0; i < gf_arity[lf]; i++ ) { + lf_args[i] = fvs->fluent.args[i]; + } + adr = fluent_adress(); + fl = lf_index[lf][adr]; + ginitial_state.f_D[fl] = TRUE; + ginitial_state.f_V[fl] = fvs->value; + } + +} + + + +void create_final_actions( void ) + +{ + + Action *a, *p, *t; + NormOperator *no; + NormEffect *ne; + int i, j, adr; + PseudoAction *pa; + PseudoActionEffect *pae; + ActionEffect *aa; + Bool false_cond; + + a = gactions; p = NULL; + while ( a ) { + if ( a->norm_operator ) { + /* action comes from an easy template NormOp + */ + no = a->norm_operator; + + if ( no->num_preconds > 0 ) { + a->preconds = ( int * ) calloc( no->num_preconds, sizeof( int ) ); + } + a->num_preconds = 0; + for ( i = 0; i < no->num_preconds; i++ ) { + lp = no->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( no->preconds[i].args[j] >= 0 ) ? + no->preconds[i].args[j] : a->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; + } + adr = fact_adress(); + /* preconds are lpos in all cases due to reachability analysis + */ + if ( !lneg[lp][adr] ) { + continue; + } + a->preconds[a->num_preconds++] = lindex[lp][adr]; + } + + /**************************NUMERIC PRECOND*************************/ + if ( no->num_numeric_preconds > 0 ) { + a->numeric_preconds_comp = ( Comparator * ) + calloc( no->num_numeric_preconds, sizeof( Comparator ) ); + a->numeric_preconds_lh = ( ExpNode_pointer * ) + calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->numeric_preconds_rh = ( ExpNode_pointer * ) + calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->num_numeric_preconds = 0; + } + for ( i = 0; i < no->num_numeric_preconds; i++ ) { + a->numeric_preconds_comp[a->num_numeric_preconds] = no->numeric_preconds_comp[i]; + a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_lh[i] ); + instantiate_exp_by_action( &(a->numeric_preconds_lh[a->num_numeric_preconds]), a ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; + a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_rh[i] ); + instantiate_exp_by_action( &(a->numeric_preconds_rh[a->num_numeric_preconds]), a ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; + if ( a->numeric_preconds_lh[a->num_numeric_preconds]->connective == NUMBER && + a->numeric_preconds_rh[a->num_numeric_preconds]->connective == NUMBER ) { + /* trivial numeric precond + */ + if ( number_comparison_holds( a->numeric_preconds_comp[a->num_numeric_preconds], + a->numeric_preconds_lh[a->num_numeric_preconds]->value, + a->numeric_preconds_rh[a->num_numeric_preconds]->value ) ) { + /* true precond -> throw precond away. by not incrementing number of such. + */ + free_ExpNode( a->numeric_preconds_lh[a->num_numeric_preconds] ); + free_ExpNode( a->numeric_preconds_rh[a->num_numeric_preconds] ); + continue; + } else { + /* false precond -> throw action away. + */ + break; + } + } + a->num_numeric_preconds++; + } + if ( i < no->num_numeric_preconds ) { + /* a precond accesses an undefined fluent, or is false -> remove action! + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + /**************************NUMERIC PRECOND-END*************************/ + + /* and now for the effects + */ + if ( a->num_effects > 0 ) { + a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); + for ( i = 0; i < a->num_effects; i++ ) { + a->effects[i].illegal = FALSE; + a->effects[i].removed = FALSE; + } + } + a->num_effects = 0; + for ( ne = no->effects; ne; ne = ne->next ) { + aa = &(a->effects[a->num_effects]); + + if ( ne->num_conditions > 0 ) { + aa->conditions = ( int * ) calloc( ne->num_conditions, sizeof( int ) ); + } + aa->num_conditions = 0; + for ( i = 0; i < ne->num_conditions; i++ ) { + lp = ne->conditions[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->conditions[i].args[j] >= 0 ) ? + ne->conditions[i].args[j] : a->inst_table[DECODE_VAR( ne->conditions[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ + break; + } + if ( !lneg[lp][adr] ) {/* condition always true: skip it */ + continue; + } + aa->conditions[aa->num_conditions++] = lindex[lp][adr]; + } + if ( i < ne->num_conditions ) {/* found unreachable condition: free condition space */ + free( aa->conditions ); + continue; + } + + /**************************NUMERIC COND*************************/ + if ( ne->num_numeric_conditions > 0 ) { + aa->numeric_conditions_comp = ( Comparator * ) + calloc( ne->num_numeric_conditions, sizeof( Comparator ) ); + aa->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + aa->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < ne->num_numeric_conditions; i++ ) { + aa->numeric_conditions_lh[i] = NULL; + aa->numeric_conditions_rh[i] = NULL; + } + aa->num_numeric_conditions = 0; + } + false_cond = FALSE; + for ( i = 0; i < ne->num_numeric_conditions; i++ ) { + aa->numeric_conditions_comp[aa->num_numeric_conditions] = ne->numeric_conditions_comp[i]; + aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_lh[i] ); + instantiate_exp_by_action( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_rh[i] ); + instantiate_exp_by_action( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; + if ( aa->numeric_conditions_lh[aa->num_numeric_conditions]->connective == NUMBER && + aa->numeric_conditions_rh[aa->num_numeric_conditions]->connective == NUMBER ) { + /* trivial numeric condition + */ + if ( number_comparison_holds( aa->numeric_conditions_comp[aa->num_numeric_conditions], + aa->numeric_conditions_lh[aa->num_numeric_conditions]->value, + aa->numeric_conditions_rh[aa->num_numeric_conditions]->value ) ) { + /* true cond -> throw cond away. by not incrementing number of such. + */ + free_ExpNode( aa->numeric_conditions_lh[aa->num_numeric_conditions] ); + free_ExpNode( aa->numeric_conditions_rh[aa->num_numeric_conditions] ); + aa->numeric_conditions_lh[aa->num_numeric_conditions] = NULL; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = NULL; + continue; + } else { + /* false cond -> throw effect away. + */ + false_cond = TRUE; + break; + } + } + aa->num_numeric_conditions++; + } + if ( i < ne->num_numeric_conditions ) { + if ( false_cond ) { + /* false numeric cond: free what's been done so far, and skip effect + */ + for ( i = 0; i <= aa->num_numeric_conditions; i++ ) { + free_ExpNode( aa->numeric_conditions_lh[i] ); + free_ExpNode( aa->numeric_conditions_rh[i] ); + } + free( aa->numeric_conditions_comp ); + free( aa->numeric_conditions_lh ); + free( aa->numeric_conditions_rh ); + continue;/* next effect, without incrementing action counter */ + } else { + /* numeric effect uses undefined fluent in condition --> + * THROW WHOLE ACTION AWAY! done by breaking out of the + * effects loop, which will be catched below overall + * effect handling. + */ + break; + } + } + /**************************NUMERIC COND - END*************************/ + + /* now create the add and del effects. + */ + if ( ne->num_adds > 0 ) { + aa->adds = ( int * ) calloc( ne->num_adds, sizeof( int ) ); + } + aa->num_adds = 0; + for ( i = 0; i < ne->num_adds; i++ ) { + lp = ne->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->adds[i].args[j] >= 0 ) ? + ne->adds[i].args[j] : a->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* effect always true: skip it */ + continue; + } + aa->adds[aa->num_adds++] = lindex[lp][adr]; + } + + if ( ne->num_dels > 0 ) { + aa->dels = ( int * ) calloc( ne->num_dels, sizeof( int ) ); + } + aa->num_dels = 0; + for ( i = 0; i < ne->num_dels; i++ ) { + lp = ne->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = ( ne->dels[i].args[j] >= 0 ) ? + ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* effect always false: skip it */ + continue; + } + /* NO CHECK FOR ADD \CAP DEL!!!!! -> ALLOWED BY SEMANTICS!!! + */ + aa->dels[aa->num_dels++] = lindex[lp][adr]; + } + if ( i < ne->num_dels ) break; + + /**************************NUMERIC EFFECTS*************************/ + if ( ne->num_numeric_effects > 0 ) { + aa->numeric_effects_neft = ( NumericEffectType * ) + calloc( ne->num_numeric_effects, sizeof( NumericEffectType ) ); + aa->numeric_effects_fl = ( int * ) + calloc( ne->num_numeric_effects, sizeof( int ) ); + aa->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( ne->num_numeric_effects, sizeof( ExpNode_pointer ) ); + aa->num_numeric_effects = 0; + } + for ( i = 0; i < ne->num_numeric_effects; i++ ) { + aa->numeric_effects_neft[aa->num_numeric_effects] = ne->numeric_effects_neft[i]; + lf = ne->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? + ne->numeric_effects_fluent[i].args[j] : + a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; + } + adr = fluent_adress(); + /* if it's -1, simply let it in --- if that effect appears, then + * action is illegal, otherwise not. + */ + aa->numeric_effects_fl[i] = lf_index[lf][adr]; + if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; + aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( ne->numeric_effects_rh[i] ); + instantiate_exp_by_action( &(aa->numeric_effects_rh[aa->num_numeric_effects]), a ); + if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { + aa->illegal = TRUE; + } + if ( aa->illegal && + aa->num_conditions == 0 && + aa->num_numeric_conditions == 0 ) { + break; + } + /* that's it ???????????????? - !! + */ + aa->num_numeric_effects++; + } + if ( i < ne->num_numeric_effects ) { + /* an unconditional illegal effekt + */ + break; + } + /**************************NUMERIC EFFECTS - END*************************/ + + /* this effect is OK. go to next one in NormOp. + */ + a->num_effects++; + lnum_effects++; + } + if ( ne ) { + /* we get here if one effect was faulty + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + } else { + p = a; + a = a->next; + } + continue; + } + /**********************************second half: hard operators --> pseudo actions******************/ + if ( a->pseudo_action ) { + /* action is result of a PseudoAction + */ + pa = a->pseudo_action; + if ( pa->num_preconds > 0 ) { + a->preconds = ( int * ) calloc( pa->num_preconds, sizeof( int ) ); + } + a->num_preconds = 0; + for ( i = 0; i < pa->num_preconds; i++ ) { + lp = pa->preconds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pa->preconds[i].args[j]; + } + adr = fact_adress(); + /* preconds are lpos in all cases due to reachability analysis + */ + if ( !lneg[lp][adr] ) { + continue; + } + a->preconds[a->num_preconds++] = lindex[lp][adr]; + } + + /**************************NUMERIC PRECOND*************************/ + if ( pa->num_numeric_preconds > 0 ) { + a->numeric_preconds_comp = ( Comparator * ) + calloc( pa->num_numeric_preconds, sizeof( Comparator ) ); + a->numeric_preconds_lh = ( ExpNode_pointer * ) + calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->numeric_preconds_rh = ( ExpNode_pointer * ) + calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); + a->num_numeric_preconds = 0; + } + for ( i = 0; i < pa->num_numeric_preconds; i++ ) { + a->numeric_preconds_comp[a->num_numeric_preconds] = pa->numeric_preconds_comp[i]; + a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_lh[i] ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; + a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_rh[i] ); + if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; + a->num_numeric_preconds++; + } + if ( i < pa->num_numeric_preconds ) { + /* a precond accesses an undefined fluent -> remove action! + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + continue; + } + /**************************NUMERIC PRECOND-END*************************/ + + /* and now for the effects + */ + if ( a->num_effects > 0 ) { + a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); + for ( i = 0; i < a->num_effects; i++ ) { + a->effects[i].illegal = FALSE; + a->effects[i].removed = FALSE; + } + } + a->num_effects = 0; + for ( pae = pa->effects; pae; pae = pae->next ) { + aa = &(a->effects[a->num_effects]); + + if ( pae->num_conditions > 0 ) { + aa->conditions = ( int * ) calloc( pae->num_conditions, sizeof( int ) ); + } + aa->num_conditions = 0; + for ( i = 0; i < pae->num_conditions; i++ ) { + lp = pae->conditions[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->conditions[i].args[j]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ + break; + } + if ( !lneg[lp][adr] ) {/* condition always true: skip it */ + continue; + } + aa->conditions[aa->num_conditions++] = lindex[lp][adr]; + } + if ( i < pae->num_conditions ) {/* found unreachable condition: free condition space */ + free( aa->conditions ); + continue; + } + + /**************************NUMERIC COND*************************/ + if ( pae->num_numeric_conditions > 0 ) { + aa->numeric_conditions_comp = ( Comparator * ) + calloc( pae->num_numeric_conditions, sizeof( Comparator ) ); + aa->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + aa->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < pae->num_numeric_conditions; i++ ) { + aa->numeric_conditions_lh[i] = NULL; + aa->numeric_conditions_rh[i] = NULL; + } + aa->num_numeric_conditions = 0; + } + for ( i = 0; i < pae->num_numeric_conditions; i++ ) { + aa->numeric_conditions_comp[aa->num_numeric_conditions] = pae->numeric_conditions_comp[i]; + aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_lh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; + aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_rh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; + aa->num_numeric_conditions++; + } + if ( i < pae->num_numeric_conditions ) { + /* numeric effect uses undefined fluent in condition --> + * THROW WHOLE ACTION AWAY! done by breaking out of the + * effects loop, which will be catched below overall + * effect handling. + */ + break; + } + /**************************NUMERIC COND - END*************************/ + + /* now create the add and del effects. + */ + if ( pae->num_adds > 0 ) { + aa->adds = ( int * ) calloc( pae->num_adds, sizeof( int ) ); + } + aa->num_adds = 0; + for ( i = 0; i < pae->num_adds; i++ ) { + lp = pae->adds[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->adds[i].args[j]; + } + adr = fact_adress(); + if ( !lneg[lp][adr] ) {/* effect always true: skip it */ + continue; + } + aa->adds[aa->num_adds++] = lindex[lp][adr]; + } + + if ( pae->num_dels > 0 ) { + aa->dels = ( int * ) calloc( pae->num_dels, sizeof( int ) ); + } + aa->num_dels = 0; + for ( i = 0; i < pae->num_dels; i++ ) { + lp = pae->dels[i].predicate; + for ( j = 0; j < garity[lp]; j++ ) { + largs[j] = pae->dels[i].args[j]; + } + adr = fact_adress(); + if ( !lpos[lp][adr] ) {/* effect always false: skip it */ + continue; + } + aa->dels[aa->num_dels++] = lindex[lp][adr]; + } + if ( i < pae->num_dels ) break; + + /**************************NUMERIC EFFECTS*************************/ + if ( pae->num_numeric_effects > 0 ) { + aa->numeric_effects_neft = ( NumericEffectType * ) + calloc( pae->num_numeric_effects, sizeof( NumericEffectType ) ); + aa->numeric_effects_fl = ( int * ) + calloc( pae->num_numeric_effects, sizeof( int ) ); + aa->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( pae->num_numeric_effects, sizeof( ExpNode_pointer ) ); + aa->num_numeric_effects = 0; + } + for ( i = 0; i < pae->num_numeric_effects; i++ ) { + aa->numeric_effects_neft[aa->num_numeric_effects] = pae->numeric_effects_neft[i]; + lf = pae->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[lf]; j++ ) { + lf_args[j] = pae->numeric_effects_fluent[i].args[j]; + if ( lf_args[j] < 0 ) { + printf("\n\nuninstantiated affected fluent in final actions! debug me.\n\n"); + exit( 1 ); + } + } + adr = fluent_adress(); + /* if it's -1, simply let it in --- if that effect appears, then + * action is illegal, otherwise not. + */ + aa->numeric_effects_fl[i] = lf_index[lf][adr]; + if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; + aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( pae->numeric_effects_rh[i] ); + if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { + aa->illegal = TRUE; + } + if ( aa->illegal && + aa->num_conditions == 0 && + aa->num_numeric_conditions == 0 ) { + break; + } + /* that's it ???????????????? - !! + */ + aa->num_numeric_effects++; + } + if ( i < pae->num_numeric_effects ) { + /* an unconditional illegal effekt + */ + break; + } + /**************************NUMERIC EFFECTS - END*************************/ + + /* this effect is OK. go to next one in PseudoAction. + */ + a->num_effects++; + lnum_effects++; + } + if ( pae ) { + /* we get here if one effect was faulty + */ + gnum_actions--; + if ( p ) { + p->next = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } else { + gactions = a->next; + t = a; + a = a->next; + t->next = gtrash_actions; + gtrash_actions = t; + } + } else { + p = a; + a = a->next; + } + continue; + }/* end of if clause for PseudoAction */ + /* if action was neither normop, nor pseudo action determined, + * then it is an artificial action due to disjunctive goal + * conditions. + * + * these are already in final form. + */ + p = a; + a = a->next; + }/* endfor all actions ! */ + +} + + + +void instantiate_exp_by_action( ExpNode **n, Action *a ) + +{ + + int j, f, k, h; + Bool ok; + + switch ( (*n)->connective ) { + case AD: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + instantiate_exp_by_action( &((*n)->leftson), a ); + instantiate_exp_by_action( &((*n)->rightson), a ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + instantiate_exp_by_action( &((*n)->son), a ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + f = (*n)->fluent->function; + ok = TRUE; + for ( j = 0; j < gf_arity[f]; j++ ) { + h = ( (*n)->fluent->args[j] < 0 ) ? + a->inst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; + if ( h < 0 ) { + ok = FALSE; + } else { + (*n)->fluent->args[j] = h; + } + } + if ( !ok ) { + printf("\n\nnon-instantiated fluent in final actiona! debug me!!\n\n"); + exit( 1 ); + } + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\ninst. exp by action: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + + + + + + + + + + + + + + + + + + +/************************************************** + * CONNECTIVITY GRAPH. ULTRA CLEAN REPRESENTATION * + **************************************************/ + + + + + + + + + + + + + + + + + + + + +void build_connectivity_graph( void ) + +{ + + int i, j, k, l, n_op, n_ef, fl, ef, ef_, m; + float val; + Action *a; + ActionEffect *e; + + gnum_ft_conn = gnum_relevant_facts; + gnum_fl_conn = gnum_relevant_fluents; + gnum_op_conn = gnum_actions; + gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) ); + gfl_conn = ( FlConn * ) calloc( gnum_fl_conn, sizeof( FlConn ) ); + gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) ); + gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) ); + gnum_ef_conn = 0; + + for ( i = 0; i < gnum_ft_conn; i++ ) { + gft_conn[i].num_PC = 0; + gft_conn[i].num_A = 0; + gft_conn[i].num_D = 0; + + gft_conn[i].axiom_added = FALSE; + + gft_conn[i].rand = random() % BIG_INT; + } + + gnum_real_fl_conn = 0; + for ( i = 0; i < gnum_fl_conn; i++ ) { + gfl_conn[i].num_PC = 0; + gfl_conn[i].num_IN = 0; + gfl_conn[i].num_AS = 0; + + if ( grelevant_fluents_lnf[i] == NULL ) { + gfl_conn[i].artificial = FALSE; + gnum_real_fl_conn++; + gfl_conn[i].rand = random() % BIG_INT; + } else { + /* once we're in here we'll stay as all artificial + * fluents are appended to the end. + */ + gfl_conn[i].artificial = TRUE; + gfl_conn[i].lnf_F = ( int * ) + calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( int ) ); + gfl_conn[i].lnf_C = ( float * ) + calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( float ) ); + for ( j = 0; j < grelevant_fluents_lnf[i]->num_pF; j++ ) { + gfl_conn[i].lnf_F[j] = grelevant_fluents_lnf[i]->pF[j]; + gfl_conn[i].lnf_C[j] = grelevant_fluents_lnf[i]->pC[j]; + } + gfl_conn[i].num_lnf = grelevant_fluents_lnf[i]->num_pF; + } + } + + + /* why not do this here? + */ + gmneed_start_D = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); + gmneed_start_V = ( float * ) calloc( gnum_real_fl_conn, sizeof( float ) ); + + + for ( i = 0; i < gnum_op_conn; i++ ) { + gop_conn[i].num_E = 0; + } + + for ( i = 0; i < lnum_effects; i++ ) { + gef_conn[i].num_PC = 0; + gef_conn[i].num_f_PC = 0; + gef_conn[i].num_A = 0; + gef_conn[i].num_D = 0; + gef_conn[i].num_I = 0; + gef_conn[i].num_IN = 0; + gef_conn[i].num_AS = 0; + + gef_conn[i].illegal = FALSE; + gef_conn[i].removed = FALSE; + } + + + /* determine if there are conditional effects. + */ + gconditional_effects = FALSE; + for ( a = gactions; a; a = a->next ) { + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + if ( e->num_conditions > 0 ) { + break; + } + if ( e->num_lnf_conditions > 0 ) { + break; + } + } + if ( i < a->num_effects ) break; + } + if ( a ) { + printf("\n\ntask contains conditional effects. turning off state domination.\n\n"); + gconditional_effects = TRUE; + } + + n_op = 0; + n_ef = 0; + for ( a = gactions; a; a = a->next ) { + gop_conn[n_op].action = a; + gop_conn[n_op].axiom = a->axiom; + if ( a->num_effects == 0 ) { + continue; + } + + gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) ); + for ( i = 0; i < a->num_effects; i++ ) { + e = &(a->effects[i]); + gef_conn[n_ef].cost = e->cost; + if ( e->removed ) { + /* this one disappeared through summarization + */ + continue; + } + gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef; + gef_conn[n_ef].op = n_op; + if ( e->illegal ) { + gef_conn[n_ef].illegal = TRUE; + } + + /*****************************CONDS********************************/ + gef_conn[n_ef].PC = ( int * ) + calloc( e->num_conditions + a->num_preconds, sizeof( int ) ); + for ( j = 0; j < a->num_preconds; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j]; + } + for ( j = 0; j < e->num_conditions; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j]; + } + /* similar thing for numeric conditions. + */ + gef_conn[n_ef].f_PC_comp = ( Comparator * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( Comparator ) ); + gef_conn[n_ef].f_PC_fl = ( int * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( int ) ); + gef_conn[n_ef].f_PC_c = ( float * ) + calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( float ) ); + gef_conn[n_ef].f_PC_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); + for ( j = 0; j < gnum_fl_conn; j++ ) { + gef_conn[n_ef].f_PC_direct_comp[j] = IGUAL; + } + gef_conn[n_ef].f_PC_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); + for ( j = 0; j < a->num_lnf_preconds; j++ ) { + if ( a->lnf_preconds_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final pre copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { + if ( gef_conn[n_ef].f_PC_fl[k] == a->lnf_preconds_lh[j]->pF[0] ) break; + } + if ( k < gef_conn[n_ef].num_f_PC ) { + if ( a->lnf_preconds_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { + /* weaker cond + */ + continue; + } + if ( a->lnf_preconds_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { + /* stronger cond + */ + gef_conn[n_ef].f_PC_c[k] = a->lnf_preconds_rh[j]; + gef_conn[n_ef].f_PC_comp[k] = a->lnf_preconds_comp[j]; + continue; + } + if ( a->lnf_preconds_comp[j] == GE ) { + /* we might need to strengthen our comp + */ + gef_conn[n_ef].f_PC_comp[k] = GE; + } + } else { + gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_comp[j]; + gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_lh[j]->pF[0]; + gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = a->lnf_preconds_rh[j]; + } + } + for ( j = 0; j < e->num_lnf_conditions; j++ ) { + if ( e->lnf_conditions_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final cond copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { + if ( gef_conn[n_ef].f_PC_fl[k] == e->lnf_conditions_lh[j]->pF[0] ) break; + } + if ( k < gef_conn[n_ef].num_f_PC ) { + if ( e->lnf_conditions_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { + continue; + } + if ( e->lnf_conditions_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { + gef_conn[n_ef].f_PC_c[k] = e->lnf_conditions_rh[j]; + gef_conn[n_ef].f_PC_comp[k] = e->lnf_conditions_comp[j]; + continue; + } + if ( e->lnf_conditions_comp[j] == GE ) { + gef_conn[n_ef].f_PC_comp[k] = GE; + } + } else { + gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_comp[j]; + gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_lh[j]->pF[0]; + gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = e->lnf_conditions_rh[j]; + } + } + /* now arrange the direct access structures from that. + */ + for ( j = 0; j < gef_conn[n_ef].num_f_PC; j++ ) { + gef_conn[n_ef].f_PC_direct_comp[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_comp[j]; + gef_conn[n_ef].f_PC_direct_c[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_c[j]; + } + /*****************************CONDS - END********************************/ + + + if ( e->illegal ) { + /* we don't care about the effects if they're illegal - + * all we care about is whether the condition is true or not. + */ + n_ef++; + gnum_ef_conn++; + continue; + } + /*****************************EFFECTS********************************/ + gef_conn[n_ef].A = ( int * ) calloc( e->num_adds, sizeof( int ) ); + gef_conn[n_ef].D = ( int * ) calloc( e->num_dels, sizeof( int ) ); + gef_conn[n_ef].IN_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].IN_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].IN_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); + gef_conn[n_ef].AS_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].AS_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); + gef_conn[n_ef].AS_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); + + /* duplicates removed in summarize already. + * + * but don't include adds that are in the conds. + * --- those are true anyway. + * + * and don't include dels that are in the adds + * --- those will be re-added anyway. + * + * NOTE: it is important that we use the *original* add list + * not the already reduced one, for the delete check! + * otherwise it may be that a delete that's in the add + * and also in the cond stays in! + * + * IT IS ALSO IMPORTANT THAT WE DO BOTH!!!, i.e. if we do + * the ads reduction then we *must* also do the dels + * reduction to avoid that things are deleted that + * would otherwise have been re-added. + */ + for ( j = 0; j < e->num_adds; j++ ) { + for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { + if ( gef_conn[n_ef].PC[k] == e->adds[j] ) break; + } + if ( k < gef_conn[n_ef].num_PC ) continue; + gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j]; + } + for ( j = 0; j < e->num_dels; j++ ) { + for ( k = 0; k < e->num_adds; k++ ) { + if ( e->adds[k] == e->dels[j] ) break; + } + if ( k < e->num_adds ) continue; + gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j]; + } + + /* numeric part + */ + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_neft[j] != INCREASE ) continue; + gef_conn[n_ef].IN_fl[gef_conn[n_ef].num_IN] = e->lnf_effects_fl[j]; + if ( e->lnf_effects_rh[j]->num_pF == 1 ) { + if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { + printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); + exit( 1 ); + } + gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = e->lnf_effects_rh[j]->pF[0]; + } else { + if ( e->lnf_effects_rh[j]->num_pF != 0 ) { + printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); + exit( 1 ); + } + gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = -1; + } + gef_conn[n_ef].IN_c[gef_conn[n_ef].num_IN++] = e->lnf_effects_rh[j]->c; + } + /* now remove increasers by nothing. + */ + j = 0; + while ( j < gef_conn[n_ef].num_IN ) { + if ( gef_conn[n_ef].IN_fl_[j] != -1 || + gef_conn[n_ef].IN_c[j] != 0 ) { + j++; + continue; + } + for ( k = j; k < gef_conn[n_ef].num_IN - 1; k++ ) { + gef_conn[n_ef].IN_fl[k] = gef_conn[n_ef].IN_fl[k+1]; + gef_conn[n_ef].IN_fl_[k] = gef_conn[n_ef].IN_fl_[k+1]; + gef_conn[n_ef].IN_c[k] = gef_conn[n_ef].IN_c[k+1]; + } + gef_conn[n_ef].num_IN--; + } + /* now: the assigners... + */ + for ( j = 0; j < e->num_lnf_effects; j++ ) { + if ( e->lnf_effects_neft[j] != ASSIGN ) continue; + gef_conn[n_ef].AS_fl[gef_conn[n_ef].num_AS] = e->lnf_effects_fl[j]; + if ( e->lnf_effects_rh[j]->num_pF == 1 ) { + if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { + printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); + exit( 1 ); + } + gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = e->lnf_effects_rh[j]->pF[0]; + } else { + if ( e->lnf_effects_rh[j]->num_pF != 0 ) { + printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); + exit( 1 ); + } + gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = -1; + } + gef_conn[n_ef].AS_c[gef_conn[n_ef].num_AS++] = e->lnf_effects_rh[j]->c; + } + /*****************************EFFECTS - END********************************/ + + n_ef++; + gnum_ef_conn++; + }/* end all a->effects */ + + + /*****************************EMPTY EFFECTS********************************/ + if ( gop_conn[n_op].num_E >= 1 ) { + /* CHECK EMPTY EFFECTS! + * + * two step process --- first, remove all effects that are entirely empty. + * second, check if all remaining effects are illegal + * or only delete: + * in that case, the op will never do any good so we + * remove all its effects. + */ + i = 0; + while ( i < gop_conn[n_op].num_E ) { + /* illegal effects *must* stay in!!! + */ + if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { + i++; + continue; + } + if ( gef_conn[gop_conn[n_op].E[i]].num_A != 0 || + gef_conn[gop_conn[n_op].E[i]].num_D != 0 || + gef_conn[gop_conn[n_op].E[i]].num_IN != 0 || + gef_conn[gop_conn[n_op].E[i]].num_AS != 0 ) { + i++; + continue; + } + /* we keep it in the gef_conn (seems easier), + * but mark it as removed, which will exclude it from everything. + */ + gef_conn[gop_conn[n_op].E[i]].removed = TRUE; + for ( j = i; j < gop_conn[n_op].num_E - 1; j++ ) { + gop_conn[n_op].E[j] = gop_conn[n_op].E[j+1]; + } + gop_conn[n_op].num_E--; + } + + m = 0; + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { + m++; + continue; + } + if ( gef_conn[gop_conn[n_op].E[i]].num_A == 0 && + gef_conn[gop_conn[n_op].E[i]].num_IN == 0 && + gef_conn[gop_conn[n_op].E[i]].num_AS == 0 ) { + m++; + } + } + if ( m == gop_conn[n_op].num_E ) { + /* all remaining effects illegal or solely-deleters. + */ + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + gef_conn[gop_conn[n_op].E[i]].removed = TRUE; + } + gop_conn[n_op].num_E = 0; + } + } + /*****************************EMPTY EFFECTS - END********************************/ + + + /*****************************IMPLIED EFFECTS********************************/ + if ( gop_conn[n_op].num_E > 1 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + gef_conn[ef].I = ( int * ) calloc( gop_conn[n_op].num_E, sizeof( int ) ); + gef_conn[ef].num_I = 0; + } + for ( i = 0; i < gop_conn[n_op].num_E - 1; i++ ) { + ef = gop_conn[n_op].E[i]; + for ( j = i+1; j < gop_conn[n_op].num_E; j++ ) { + ef_ = gop_conn[n_op].E[j]; + /* ef ==> ef_ ? */ + for ( k = 0; k < gef_conn[ef_].num_PC; k++ ) { + for ( l = 0; l < gef_conn[ef].num_PC; l++ ) { + if ( gef_conn[ef].PC[l] == gef_conn[ef_].PC[k] ) break; + } + if ( l == gef_conn[ef].num_PC ) break; + } + if ( k == gef_conn[ef_].num_PC ) { + for ( k = 0; k < gnum_fl_conn; k++ ) { + if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL ) continue; + if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL || + gef_conn[ef].f_PC_direct_c[k] < gef_conn[ef_].f_PC_direct_c[k] || + ( gef_conn[ef].f_PC_direct_c[k] == gef_conn[ef_].f_PC_direct_c[k] && + gef_conn[ef].f_PC_direct_comp[k] == GEQ && + gef_conn[ef_].f_PC_direct_comp[k] == GE ) ) break; + } + if ( k == gnum_fl_conn ) { + gef_conn[ef].I[gef_conn[ef].num_I++] = ef_; + } + } + /* ef_ ==> ef ? */ + for ( k = 0; k < gef_conn[ef].num_PC; k++ ) { + for ( l = 0; l < gef_conn[ef_].num_PC; l++ ) { + if ( gef_conn[ef_].PC[l] == gef_conn[ef].PC[k] ) break; + } + if ( l == gef_conn[ef_].num_PC ) break; + } + if ( k == gef_conn[ef].num_PC ) { + for ( k = 0; k < gnum_fl_conn; k++ ) { + if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL ) continue; + if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL || + gef_conn[ef_].f_PC_direct_c[k] < gef_conn[ef].f_PC_direct_c[k] || + ( gef_conn[ef_].f_PC_direct_c[k] == gef_conn[ef].f_PC_direct_c[k] && + gef_conn[ef_].f_PC_direct_comp[k] == GEQ && + gef_conn[ef].f_PC_direct_comp[k] == GE ) ) break; + } + if ( k == gnum_fl_conn ) { + gef_conn[ef_].I[gef_conn[ef_].num_I++] = ef; + } + } + } + } + } + /*****************************IMPLIED EFFECTS - END********************************/ + + /* op cost is sum of eff costs + gtt*1: + * [gtt is multiplicator of TOTAL-TIME in final metric; if no + * total-time part in metric, it is 0] + * ie eff-costs plus the cost for the time taken by 1 more step. + */ + gop_conn[n_op].cost = gtt; + if ( gop_conn[n_op].num_E > 0 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + if ( gef_conn[ef].illegal ) { + continue; + } + if ( gef_conn[ef].removed ) { + continue; + } + gop_conn[n_op].cost += gef_conn[ef].cost; + } + } + + /* first sweep: only count the space we need for the fact arrays ! + */ + if ( gop_conn[n_op].num_E > 0 ) { + for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { + ef = gop_conn[n_op].E[i]; + for ( j = 0; j < gef_conn[ef].num_PC; j++ ) { + gft_conn[gef_conn[ef].PC[j]].num_PC++; + } + for ( j = 0; j < gef_conn[ef].num_A; j++ ) { + gft_conn[gef_conn[ef].A[j]].num_A++; + if ( gop_conn[n_op].axiom ) { + gft_conn[gef_conn[ef].A[j]].axiom_added = TRUE; + } + } + for ( j = 0; j < gef_conn[ef].num_D; j++ ) { + gft_conn[gef_conn[ef].D[j]].num_D++; + } + /* similar increments for flconn + */ + for ( j = 0; j < gef_conn[ef].num_f_PC; j++ ) { + gfl_conn[gef_conn[ef].f_PC_fl[j]].num_PC++; + } + for ( j = 0; j < gef_conn[ef].num_IN; j++ ) { + gfl_conn[gef_conn[ef].IN_fl[j]].num_IN++; + } + for ( j = 0; j < gef_conn[ef].num_AS; j++ ) { + gfl_conn[gef_conn[ef].AS_fl[j]].num_AS++; + } + } + } + + + n_op++; + } + + /*****************************FLCONN********************************/ + for ( i = 0; i < gnum_ft_conn; i++ ) { + if ( gft_conn[i].num_PC > 0 ) { + gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) ); + } + gft_conn[i].num_PC = 0; + if ( gft_conn[i].num_A > 0 ) { + gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) ); + } + gft_conn[i].num_A = 0; + if ( gft_conn[i].num_D > 0 ) { + gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) ); + } + gft_conn[i].num_D = 0; + } + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gef_conn[i].removed ) continue; + for ( j = 0; j < gef_conn[i].num_PC; j++ ) { + gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i; + } + for ( j = 0; j < gef_conn[i].num_A; j++ ) { + gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i; + } + for ( j = 0; j < gef_conn[i].num_D; j++ ) { + gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i; + } + } + /*****************************FTCONN - END********************************/ + + + /*****************************FLCONN********************************/ + /* similar thing for flconn + */ + for ( i = 0; i < gnum_fl_conn; i++ ) { + if ( gfl_conn[i].num_PC > 0 ) { + gfl_conn[i].PC = ( int * ) calloc( gfl_conn[i].num_PC, sizeof( int ) ); + } + gfl_conn[i].num_PC = 0; + if ( gfl_conn[i].num_IN > 0 ) { + gfl_conn[i].IN = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); + gfl_conn[i].IN_fl_ = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); + gfl_conn[i].IN_c = ( float * ) calloc( gfl_conn[i].num_IN, sizeof( float ) ); + } + gfl_conn[i].num_IN = 0; + if ( gfl_conn[i].num_AS > 0 ) { + gfl_conn[i].AS = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); + gfl_conn[i].AS_fl_ = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); + gfl_conn[i].AS_c = ( float * ) calloc( gfl_conn[i].num_AS, sizeof( float ) ); + } + gfl_conn[i].num_AS = 0; + } + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gef_conn[i].removed ) continue; + /* PCs + */ + for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { + fl = gef_conn[i].f_PC_fl[j]; + gfl_conn[fl].PC[gfl_conn[fl].num_PC++] = i; + } + /* insert increasers by decreasing amount --> + * "best" - at least for constant part - are first! + */ + for ( j = 0; j < gef_conn[i].num_IN; j++ ) { + fl = gef_conn[i].IN_fl[j]; + val = gef_conn[i].IN_c[j]; + for ( k = 0; k < gfl_conn[fl].num_IN; k++ ) { + if ( gfl_conn[fl].IN_c[k] < val ) break; + } + for ( l = gfl_conn[fl].num_IN; l > k; l-- ) { + gfl_conn[fl].IN[l] = gfl_conn[fl].IN[l-1]; + gfl_conn[fl].IN_fl_[l] = gfl_conn[fl].IN_fl_[l-1]; + gfl_conn[fl].IN_c[l] = gfl_conn[fl].IN_c[l-1]; + } + gfl_conn[fl].IN[k] = i; + gfl_conn[fl].IN_fl_[k] = gef_conn[i].IN_fl_[j];/* the rh fluent */ + gfl_conn[fl].IN_c[k] = val; + gfl_conn[fl].num_IN++; + } + /* insert assigners by decreasing amount --> + * "best" - at least for constant part - are first! + */ + for ( j = 0; j < gef_conn[i].num_AS; j++ ) { + fl = gef_conn[i].AS_fl[j]; + val = gef_conn[i].AS_c[j]; + for ( k = 0; k < gfl_conn[fl].num_AS; k++ ) { + if ( gfl_conn[fl].AS_c[k] < val ) break; + } + for ( l = gfl_conn[fl].num_AS; l > k; l-- ) { + gfl_conn[fl].AS[l] = gfl_conn[fl].AS[l-1]; + gfl_conn[fl].AS_fl_[l] = gfl_conn[fl].AS_fl_[l-1]; + gfl_conn[fl].AS_c[l] = gfl_conn[fl].AS_c[l-1]; + } + gfl_conn[fl].AS[k] = i; + gfl_conn[fl].AS_fl_[k] = gef_conn[i].AS_fl_[j];/* the rh fluent */ + gfl_conn[fl].AS_c[k] = val; + gfl_conn[fl].num_AS++; + } + } + /*****************************FLCONN - END********************************/ + + + /*****************************GOAL********************************/ + gflogic_goal = ( int * ) calloc( gnum_logic_goal, sizeof( int ) ); + for ( j = 0; j < gnum_logic_goal; j++ ) { + for ( k = 0; k < gnum_flogic_goal; k++ ) { + if ( gflogic_goal[k] == glogic_goal[j] ) break; + } + if ( k < gnum_flogic_goal ) continue; + gflogic_goal[gnum_flogic_goal++] = glogic_goal[j]; + } + /* numeric part + */ + gfnumeric_goal_comp = ( Comparator * ) calloc( gnum_lnf_goal, sizeof( Comparator ) ); + gfnumeric_goal_fl = ( int * ) calloc( gnum_lnf_goal, sizeof( int ) ); + gfnumeric_goal_c = ( float * ) calloc( gnum_lnf_goal, sizeof( float ) ); + for ( j = 0; j < gnum_lnf_goal; j++ ) { + if ( glnf_goal_lh[j]->num_pF != 1 ) { + printf("\n\nnon 1 card. in comp lh final goal copyover.\n\n"); + exit( 1 ); + } + for ( k = 0; k < gnum_fnumeric_goal; k++ ) { + if ( gfnumeric_goal_fl[k] == glnf_goal_lh[j]->pF[0] ) break; + } + if ( k < gnum_fnumeric_goal ) { + if ( glnf_goal_rh[j] < gfnumeric_goal_c[k] ) continue; + if ( glnf_goal_rh[j] > gfnumeric_goal_c[k] ) { + gfnumeric_goal_comp[k] = glnf_goal_comp[j]; + gfnumeric_goal_c[k] = glnf_goal_rh[j]; + continue; + } + if ( glnf_goal_comp[j] == GE ) { + gfnumeric_goal_comp[k] = GE; + } + } else { + gfnumeric_goal_comp[gnum_fnumeric_goal] = glnf_goal_comp[j]; + gfnumeric_goal_fl[gnum_fnumeric_goal] = glnf_goal_lh[j]->pF[0]; + gfnumeric_goal_c[gnum_fnumeric_goal++] = glnf_goal_rh[j]; + } + } + gfnumeric_goal_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); + for ( j = 0; j < gnum_fl_conn; j++ ) { + gfnumeric_goal_direct_comp[j] = IGUAL; + } + gfnumeric_goal_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); + for ( k = 0; k < gnum_fnumeric_goal; k++ ) { + gfnumeric_goal_direct_comp[gfnumeric_goal_fl[k]] = gfnumeric_goal_comp[k]; + gfnumeric_goal_direct_c[gfnumeric_goal_fl[k]] = gfnumeric_goal_c[k]; + } + /*****************************GOAL - END********************************/ + + + + /******************** + * safety: if there are numeric precs/goals, need to turn + * cost-minimizing rplans off!!! + * (see comments with def of gcost_rplans + */ + for ( i = 0; i < gnum_ef_conn; i++ ) { + if ( gcost_rplans && gef_conn[i].num_f_PC > 0 ) { + printf("\nwarning: numeric precondition. turning cost-minimizing relaxed plans OFF."); + gcost_rplans = FALSE; + break; + } + } + if ( gcost_rplans && gnum_fnumeric_goal > 0 ) { + printf("\nwarning: numeric goal. turning cost-minimizing relaxed plans OFF."); + gcost_rplans = FALSE; + } + + + + + if ( gcmd_line.display_info == 125 ) { + printf("\n\ncreated connectivity graph as follows:"); + + printf("\n\n------------------OP ARRAY:-----------------------"); + for ( i = 0; i < gnum_op_conn; i++ ) { + printf("\n\nOP %d: ", i); + if ( gop_conn[i].axiom ) printf("(axiom) "); + print_op_name( i ); + printf(" cost %f", gop_conn[i].cost); + printf("\n----------EFFS:"); + for ( j = 0; j < gop_conn[i].num_E; j++ ) { + printf("\neffect %d", gop_conn[i].E[j]); + } + } + + printf("\n\n-------------------EFFECT ARRAY:----------------------"); + for ( i = 0; i < gnum_ef_conn; i++ ) { + printf("\n\neffect %d of op %d cost %f: ", i, gef_conn[i].op, gef_conn[i].cost); + print_op_name( gef_conn[i].op ); + if ( gef_conn[i].illegal ) printf(" ******ILLEGAL************************"); + if ( gef_conn[i].removed ) printf(" ******REMOVED************************"); + printf("\n----------PCS:"); + for ( j = 0; j < gef_conn[i].num_PC; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].PC[j] ); + } + printf("\n----------f_PCS:"); + for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].f_PC_fl[j] ); + if ( gef_conn[i].f_PC_comp[j] == GEQ ) { + printf(" >= "); + } else { + printf(" > "); + } + printf("%f", gef_conn[i].f_PC_c[j]); + } + printf("\nDIRECT: "); + for ( j = 0; j < gnum_fl_conn; j++ ) { + if ( gef_conn[i].f_PC_direct_comp[j] == IGUAL ) { + printf("IGUAL | "); + } + if ( gef_conn[i].f_PC_direct_comp[j] == GEQ ) { + printf(">= %f | ", gef_conn[i].f_PC_direct_c[j]); + } + if ( gef_conn[i].f_PC_direct_comp[j] == GE ) { + printf("> %f | ", gef_conn[i].f_PC_direct_c[j]); + } + } + if ( gef_conn[i].illegal ) continue; + printf("\n----------ADDS:"); + for ( j = 0; j < gef_conn[i].num_A; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].A[j] ); + } + printf("\n----------DELS:"); + for ( j = 0; j < gef_conn[i].num_D; j++ ) { + printf("\n"); + print_ft_name( gef_conn[i].D[j] ); + } + printf("\n----------INCREASE:"); + for ( j = 0; j < gef_conn[i].num_IN; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].IN_fl[j] ); + printf(" by "); + if ( gef_conn[i].IN_fl_[j] >= 0 ) { + print_fl_name( gef_conn[i].IN_fl_[j] ); + printf(" + %f", gef_conn[i].IN_c[j]); + } else { + printf("%f", gef_conn[i].IN_c[j]); + } + } + printf("\n----------ASSIGN:"); + for ( j = 0; j < gef_conn[i].num_AS; j++ ) { + printf("\n"); + print_fl_name( gef_conn[i].AS_fl[j] ); + printf(" to "); + if ( gef_conn[i].AS_fl_[j] >= 0 ) { + print_fl_name( gef_conn[i].AS_fl_[j] ); + printf(" + %f", gef_conn[i].AS_c[j]); + } else { + printf("%f", gef_conn[i].AS_c[j]); + } + } + printf("\n----------IMPLIEDS:"); + for ( j = 0; j < gef_conn[i].num_I; j++ ) { + printf("\nimplied effect %d of op %d: ", + gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op); + print_op_name( gef_conn[gef_conn[i].I[j]].op ); + } + } + + printf("\n\n----------------------FT ARRAY:-----------------------------"); + for ( i = 0; i < gnum_ft_conn; i++ ) { + printf("\n\nFT: "); + print_ft_name( i ); + printf(" rand: %d", gft_conn[i].rand); + printf(" --------- AXIOM ADDED %d", gft_conn[i].axiom_added); + printf("\n----------PRE COND OF:"); + for ( j = 0; j < gft_conn[i].num_PC; j++ ) { + printf("\neffect %d", gft_conn[i].PC[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].PC[j]].op ); + } + printf("\n----------ADD BY:"); + for ( j = 0; j < gft_conn[i].num_A; j++ ) { + printf("\neffect %d", gft_conn[i].A[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].A[j]].op ); + } + printf("\n----------DEL BY:"); + for ( j = 0; j < gft_conn[i].num_D; j++ ) { + printf("\neffect %d", gft_conn[i].D[j]); + printf(" - op "); print_op_name( gef_conn[gft_conn[i].D[j]].op ); + } + } + + printf("\n\n----------------------FLUENT ARRAY:-----------------------------"); + for ( i = 0; i < gnum_fl_conn; i++ ) { + printf("\n\nFL: "); + print_fl_name( i ); + printf("\n----------PRE COND OF:"); + for ( j = 0; j < gfl_conn[i].num_PC; j++ ) { + printf("\neffect %d", gfl_conn[i].PC[j]); + printf(" - op "); print_op_name( gef_conn[gfl_conn[i].PC[j]].op ); + } + printf("\n----------INCREASED BY:"); + for ( j = 0; j < gfl_conn[i].num_IN; j++ ) { + if ( gfl_conn[i].IN_fl_[j] == -1 ) { + printf("\neffect %d --- %f", gfl_conn[i].IN[j], gfl_conn[i].IN_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); + } else { + printf("\neffect %d --- ", gfl_conn[i].IN[j]); + print_fl_name( gfl_conn[i].IN_fl_[j] ); + printf(" + %f", gfl_conn[i].IN_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); + } + } + printf("\n----------ASSIGNED BY:"); + for ( j = 0; j < gfl_conn[i].num_AS; j++ ) { + if ( gfl_conn[i].AS_fl_[j] == -1 ) { + printf("\neffect %d --- %f", gfl_conn[i].AS[j], gfl_conn[i].AS_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); + } else { + printf("\neffect %d --- ", gfl_conn[i].AS[j]); + print_fl_name( gfl_conn[i].AS_fl_[j] ); + printf(" + %f", gfl_conn[i].AS_c[j]); + printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); + } + } + if ( gfl_conn[i].artificial ) { + printf("\n----------ARTIFICIAL FOR:"); + for ( j = 0; j < gfl_conn[i].num_lnf; j++ ) { + printf(" %f*", gfl_conn[i].lnf_C[j]); + print_fl_name( gfl_conn[i].lnf_F[j] ); + if ( j < gfl_conn[i].num_lnf - 1 ) { + printf(" +"); + } + } + } else { + printf("\n----------REAL"); + } + } + + printf("\n\n----------------------GOAL:-----------------------------"); + for ( j = 0; j < gnum_flogic_goal; j++ ) { + printf("\n"); + print_ft_name( gflogic_goal[j] ); + } + for ( j = 0; j < gnum_fnumeric_goal; j++ ) { + printf("\n"); + print_fl_name( gfnumeric_goal_fl[j] ); + if ( gfnumeric_goal_comp[j] == GEQ ) { + printf(" >= "); + } else { + printf(" > "); + } + printf("%f", gfnumeric_goal_c[j]); + } + printf("\nDIRECT: "); + for ( j = 0; j < gnum_fl_conn; j++ ) { + if ( gfnumeric_goal_direct_comp[j] == IGUAL ) { + printf("IGUAL | "); + } + if ( gfnumeric_goal_direct_comp[j] == GEQ ) { + printf(">= %f | ", gfnumeric_goal_direct_c[j]); + } + if ( gfnumeric_goal_direct_comp[j] == GE ) { + printf("> %f | ", gfnumeric_goal_direct_c[j]); + } + } + + printf("\n\n"); + } + +} + + + diff --git a/models/main_models/rt1/gen/ff_planner/inst_final.h b/models/main_models/rt1/gen/ff_planner/inst_final.h new file mode 100644 index 000000000..ab42b6097 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_final.h @@ -0,0 +1,69 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_final.h + * Description: headers for final domain representation functions + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + +#ifndef _INST_FINAL_H +#define _INST_FINAL_H + + + +void perform_reachability_analysis( void ); +int fact_adress( void ); +void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ); +void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ); + + + +void collect_relevant_facts_and_fluents( void ); +void create_final_goal_state( void ); +Bool set_relevants_in_wff( WffNode **w ); +Bool set_relevants_in_exp( ExpNode **n ); +void create_final_initial_state( void ); +void create_final_actions( void ); +void instantiate_exp_by_action( ExpNode **n, Action *a ); + + + +void build_connectivity_graph( void ); + + + +void summarize_effects( void ); +Bool same_condition( ActionEffect *e, ActionEffect *e_ ); +Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); +void merge_effects( ActionEffect *e, ActionEffect *e_ ); + + + +#endif /* _INST_FINAL_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_hard.c b/models/main_models/rt1/gen/ff_planner/inst_hard.c new file mode 100644 index 000000000..54f63d752 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_hard.c @@ -0,0 +1,1306 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + + +/********************************************************************* + * File: inst_hard.c + * Description: functions for multiplying hard operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_hard.h" + + + + + + + + + + + +/* used in multiplying routines + */ +int linst_table[MAX_VARS]; +int_pointer lini[MAX_PREDICATES]; + + + + + + + + +void build_hard_action_templates( void ) + +{ + + int i, j, size, adr; + MixedOperator *o; + + /* remove unused params; empty types are already recognised during + * domain translation; have to be handled after (or while) + * unaries encoding (if done), though. + */ + cleanup_hard_domain(); + + if ( gcmd_line.display_info == 115 ) { + printf("\n\ncleaned up hard domain representation is:\n\n"); + for ( i = 0; i < gnum_hard_operators; i++ ) { + print_Operator( ghard_operators[i] ); + } + fflush( stdout ); + } + + /* create local table of instantiated facts that occur in the + * initial state. for fast finding out if fact is in ini or not. + */ + for ( i = 0; i < gnum_predicates; i++ ) { + size = 1; + for ( j = 0; j < garity[i]; j++ ) { + size *= gnum_constants; + } + lini[i] = ( int_pointer ) calloc( size, sizeof( int ) ); + for ( j = 0; j < size; j++ ) { + lini[i][j] = 0; + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + adr = instantiated_fact_adress( &ginitial_predicate[i][j] ); + lini[i][adr]++; + } + } + + + /* create mixed op for each param combination + */ + multiply_hard_op_parameters(); + + if ( gcmd_line.display_info == 116 ) { + printf("\n\nmixed hard domain representation is:\n\n"); + for ( o = ghard_mixed_operators; o; o = o->next ) { + print_MixedOperator( o ); + } + fflush( stdout ); + } + + /* create pseudo op for each mixed op + */ + multiply_hard_effect_parameters(); + + if ( gcmd_line.display_info == 117 ) { + printf("\n\npseudo hard domain representation is:\n\n"); + for ( i = 0; i < gnum_hard_templates; i++ ) { + print_PseudoAction( ghard_templates[i] ); + } + fflush( stdout ); + } + + +} + + + + + + + + + + + + +/**************** + * CLEANUP CODE * + ****************/ + + + + + + + + + + + + +void cleanup_hard_domain( void ) + +{ + + int i, j, k, par; + Operator *o; + Effect *e; + + /* so far, only unused parameters removal + */ + + for ( i = 0; i < gnum_hard_operators; i++ ) { + o = ghard_operators[i]; + + j = 0; + while ( j < o->num_vars ) { + if ( var_used_in_wff( ENCODE_VAR( j ), o->preconds ) ) { + j++; + continue; + } + + for ( e = o->effects; e; e = e->next ) { + if ( var_used_in_wff( ENCODE_VAR( j ), e->conditions ) ) { + break; + } + if ( var_used_in_literals( ENCODE_VAR( j ), e->effects ) ) { + break; + } + if ( var_used_in_numeric_effects( ENCODE_VAR( j ), e->numeric_effects ) ) { + break; + } + } + if ( e ) { + j++; + continue; + } + + o->removed[j] = TRUE; + j++; + } + + for ( e = o->effects; e; e = e->next ) { + j = 0; + while ( j < e->num_vars ) { + par = o->num_vars + j; + if ( var_used_in_wff( ENCODE_VAR( par ), e->conditions ) ) { + j++; + continue; + } + if ( var_used_in_literals( ENCODE_VAR( par ), e->effects ) ) { + j++; + continue; + } + if ( var_used_in_numeric_effects( ENCODE_VAR( par ), e->numeric_effects ) ) { + j++; + continue; + } + + if ( e->var_names[j] ) { + free( e->var_names[j] ); + } + for ( k = j; k < e->num_vars - 1; k++ ) { + e->var_names[k] = e->var_names[k+1]; + e->var_names[k] = e->var_names[k+1]; + } + e->num_vars--; + decrement_inferior_vars( par, e->conditions ); + decrement_inferior_vars_in_literals( par, e->effects ); + decrement_inferior_vars_in_numeric_effects( par, e->numeric_effects ); + } + } + } + +} + + + +Bool var_used_in_literals( int code_var, Literal *ef ) + +{ + + Literal *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + if ( l->fact.args[i] == code_var ) { + return TRUE; + } + } + } + + return FALSE; + +} + + + +Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ) + +{ + + NumericEffect *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { + if ( l->fluent.args[i] == code_var ) { + return TRUE; + } + } + if ( var_used_in_exp( code_var, l->rh ) ) { + return TRUE; + } + } + + return FALSE; + +} + + + +void decrement_inferior_vars_in_literals( int var, Literal *ef ) + +{ + + Literal *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + if ( l->fact.args[i] >= 0 ) { + continue; + } + if ( DECODE_VAR( l->fact.args[i] ) > var ) { + l->fact.args[i]++; + } + } + } + +} + + + +void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ) + +{ + + NumericEffect *l; + int i; + + for ( l = ef; l; l = l->next ) { + for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { + if ( l->fluent.args[i] >= 0 ) { + continue; + } + if ( DECODE_VAR( l->fluent.args[i] ) > var ) { + l->fluent.args[i]++; + } + } + decrement_inferior_vars_in_exp( var, l->rh ); + } + +} + + + + + + + + + + + + + + +/****************************** + * CODE THAT BUILDS MIXED OPS * + ******************************/ + + + + + + + + + + + + + + +void multiply_hard_op_parameters( void ) + +{ + + int i; + + ghard_mixed_operators = NULL; + + for ( i = 0; i < MAX_VARS; i++ ) { + linst_table[i] = -1; + } + + for ( i = 0; i < gnum_hard_operators; i++ ) { + create_hard_mixed_operators( ghard_operators[i], 0 ); + } + +} + + + +void create_hard_mixed_operators( Operator *o, int curr_var ) + +{ + + int t, i, m, mn; + WffNode *tmp1, *w, *ww; + MixedOperator *tmp2; + + if ( curr_var < o->num_vars ) { + if ( o->removed[curr_var] ) { + /* param doesn't matter -- select any appropriate type constant + * at least one there; otherwise, op would not have been translated. + */ + linst_table[curr_var] = gtype_consts[o->var_types[curr_var]][0]; + create_hard_mixed_operators( o, curr_var + 1 ); + linst_table[curr_var] = -1; + return; + } + + t = o->var_types[curr_var]; + for ( i = 0; i < gtype_size[t]; i++ ) { + linst_table[curr_var] = gtype_consts[t][i]; + + create_hard_mixed_operators( o, curr_var + 1 ); + + linst_table[curr_var] = -1; + } + return; + } + + + tmp1 = instantiate_wff( o->preconds ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + dnf( &tmp1 ); + cleanup_wff( &tmp1 ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + /* only debugging, REMOVE LATER + */ + if ( is_dnf( tmp1 ) == -1 ) { + printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", o->name); + print_Wff( tmp1, 0 ); + exit( 1 ); + } + + switch ( tmp1->connective ) { + case OR: + for ( w = tmp1->sons; w; w = w->next ) { + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + if ( w->connective == AND ) { + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_preconds = m; + tmp2->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp2->preconds[m].predicate = ww->fact->predicate; + for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { + tmp2->preconds[m].args[i] = ww->fact->args[i]; + } + m++; + } + if ( ww->connective == COMP ) { + tmp2->numeric_preconds_comp[mn] = ww->comp; + tmp2->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); + tmp2->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_preconds = 1; + tmp2->preconds[0].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->preconds[0].args[i] = w->fact->args[i]; + } + } + if ( w->connective == COMP ) { + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_comp[0] = w->comp; + tmp2->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp2->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp2->num_numeric_preconds = 1; + } + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + } + break; + case AND: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + m = 0; + mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_preconds = m; + tmp2->num_numeric_preconds = mn; + m = 0; mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + tmp2->preconds[m].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->preconds[m].args[i] = w->fact->args[i]; + } + m++; + } + if ( w->connective == COMP ) { + tmp2->numeric_preconds_comp[mn] = w->comp; + tmp2->numeric_preconds_lh[mn] = copy_Exp( w->lh ); + tmp2->numeric_preconds_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case ATOM: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_preconds = 1; + tmp2->preconds[0].predicate = tmp1->fact->predicate; + for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { + tmp2->preconds[0].args[i] = tmp1->fact->args[i]; + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case COMP: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_preconds_comp[0] = tmp1->comp; + tmp2->numeric_preconds_lh[0] = copy_Exp( tmp1->lh ); + tmp2->numeric_preconds_rh[0] = copy_Exp( tmp1->rh ); + tmp2->num_numeric_preconds = 1; + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + case TRU: + tmp2 = new_MixedOperator( o ); + for ( i = 0; i < o->num_vars; i++ ) { + tmp2->inst_table[i] = linst_table[i]; + } + tmp2->effects = instantiate_Effect( o->effects ); + tmp2->next = ghard_mixed_operators; + ghard_mixed_operators = tmp2; + gnum_hard_mixed_operators++; + break; + default: + printf("\n\nillegal connective %d in parsing DNF precond.\n\n", + tmp1->connective); + exit( 1 ); + } + + free_WffNode( tmp1 ); + +} + + + +Effect *instantiate_Effect( Effect *e ) + +{ + + Effect *res = NULL, *tmp, *i; + Literal *tt, *l; + NumericEffect *ne, *ttt; + int j; + + for ( i = e; i; i = i->next ) { + tmp = new_Effect(); + + for ( j = 0; j < i->num_vars; j++ ) { + tmp->var_types[j] = i->var_types[j]; + } + tmp->num_vars = i->num_vars; + + tmp->conditions = instantiate_wff( i->conditions ); + + if ( tmp->conditions->connective == FAL ) { + free_partial_Effect( tmp ); + continue; + } + + for ( l = i->effects; l; l = l->next ) { + tt = new_Literal(); + tt->negated = l->negated; + tt->fact.predicate = l->fact.predicate; + for ( j = 0; j < garity[tt->fact.predicate]; j++ ) { + tt->fact.args[j] = l->fact.args[j]; + if ( tt->fact.args[j] < 0 && + linst_table[DECODE_VAR( tt->fact.args[j] )] != -1 ) { + tt->fact.args[j] = linst_table[DECODE_VAR( tt->fact.args[j] )]; + } + } + tt->next = tmp->effects; + if ( tmp->effects ) { + tmp->effects->prev = tt; + } + tmp->effects = tt; + } + + for ( ne = i->numeric_effects; ne; ne = ne->next ) { + ttt = new_NumericEffect(); + ttt->neft = ne->neft; + ttt->fluent.function = ne->fluent.function; + for ( j = 0; j < gf_arity[ttt->fluent.function]; j++ ) { + ttt->fluent.args[j] = ne->fluent.args[j]; + if ( ttt->fluent.args[j] < 0 && + linst_table[DECODE_VAR( ttt->fluent.args[j] )] != -1 ) { + ttt->fluent.args[j] = linst_table[DECODE_VAR( ttt->fluent.args[j] )]; + } + } + ttt->rh = copy_Exp( ne->rh ); + instantiate_exp( &(ttt->rh) ); + ttt->next = tmp->numeric_effects; + if ( tmp->numeric_effects ) { + tmp->numeric_effects->prev = ttt; + } + tmp->numeric_effects = ttt; + } + + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + } + + return res; + +} + + + +WffNode *instantiate_wff( WffNode *w ) + +{ + + WffNode *res = NULL, *tmp, *i; + int j, m, h; + Bool ok, ct; + + switch ( w->connective ) { + case AND: + m = 0; + i = w->sons; + while ( i ) { + tmp = instantiate_wff( i ); + if ( tmp->connective == FAL ) { + free_WffNode( res ); + return tmp; + } + if ( tmp->connective == TRU ) { + free( tmp ); + i = i->next; + continue; + } + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + i = i->next; + m++; + } + if ( m == 0 ) { + res = new_WffNode( TRU ); + break; + } + if ( m == 1 ) { + break; + } + tmp = new_WffNode( AND ); + tmp->sons = res; + res = tmp; + break; + case OR: + m = 0; + i = w->sons; + while ( i ) { + tmp = instantiate_wff( i ); + if ( tmp->connective == TRU ) { + free_WffNode( res ); + return tmp; + } + if ( tmp->connective == FAL ) { + free( tmp ); + i = i->next; + continue; + } + tmp->next = res; + if ( res ) { + res->prev = tmp; + } + res = tmp; + i = i->next; + m++; + } + if ( m == 0 ) { + res = new_WffNode( FAL ); + break; + } + if ( m == 1 ) { + break; + } + tmp = new_WffNode( OR ); + tmp->sons = res; + res = tmp; + break; + case ATOM: + res = new_WffNode( ATOM ); + res->fact = new_Fact(); + res->fact->predicate = w->fact->predicate; + ok = TRUE; + for ( j = 0; j < garity[res->fact->predicate]; j++ ) { + h = ( w->fact->args[j] < 0 ) ? + linst_table[DECODE_VAR( w->fact->args[j] )] : w->fact->args[j]; + if ( h < 0 ) { + ok = FALSE; + res->fact->args[j] = w->fact->args[j]; + } else { + res->fact->args[j] = h; + } + } + if ( !ok ) {/* contains ef params */ + break; + } + if ( !full_possibly_negative( res->fact ) ) { + free( res->fact ); + res->fact = NULL; + res->connective = TRU; + break; + } + if ( !full_possibly_positive( res->fact ) ) { + free( res->fact ); + res->fact = NULL; + res->connective = FAL; + break; + } + break; + case COMP: + res = new_WffNode( COMP ); + res->comp = w->comp; + res->lh = copy_Exp( w->lh ); + res->rh = copy_Exp( w->rh ); + instantiate_exp( &(res->lh) ); + instantiate_exp( &(res->rh) ); + if ( res->lh->connective != NUMBER || + res->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( res->comp, res->lh->value, res->rh->value ); + if ( ct ) { + res->connective = TRU; + free_ExpNode( res->lh ); + res->lh = NULL; + free_ExpNode( res->rh ); + res->rh = NULL; + res->comp = -1; + } else { + res->connective = FAL; + free_ExpNode( res->lh ); + res->lh = NULL; + free_ExpNode( res->rh ); + res->rh = NULL; + res->comp = -1; + } + break; + case TRU: + case FAL: + res = new_WffNode( w->connective ); + break; + default: + printf("\n\nillegal connective %d in instantiate formula\n\n", + w->connective); + exit( 1 ); + } + + return res; + +} + + + +void instantiate_exp( ExpNode **n ) + +{ + + int j, f, k, h; + Bool ok; + + switch ( (*n)->connective ) { + case AD: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + instantiate_exp( &((*n)->leftson) ); + instantiate_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + instantiate_exp( &((*n)->son) ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + f = (*n)->fluent->function; + ok = TRUE; + for ( j = 0; j < gf_arity[f]; j++ ) { + h = ( (*n)->fluent->args[j] < 0 ) ? + linst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; + if ( h < 0 ) { + ok = FALSE; + } else { + (*n)->fluent->args[j] = h; + } + } + if ( !ok ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\ninst exp: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +Bool full_possibly_positive( Fact *f ) + +{ + + int adr; + + if ( gis_added[f->predicate] ) { + return TRUE; + } + + adr = instantiated_fact_adress( f ); + + if ( lini[f->predicate][adr] > 0 ) { + return TRUE; + } else { + return FALSE; + } + +} + + + +Bool full_possibly_negative( Fact *f ) + +{ + + int adr; + + if ( gis_deleted[f->predicate] ) { + return TRUE; + } + + adr = instantiated_fact_adress( f ); + + if ( lini[f->predicate][adr] > 0 ) { + return FALSE; + } else { + return TRUE; + } + +} + + + +int instantiated_fact_adress( Fact *f ) + +{ + + int r = 0, b = 1, i; + + for ( i = 0; i < garity[f->predicate]; i++ ) { + r += b * f->args[i]; + b *= gnum_constants; + } + + return r; + +} + + + + + + + + + + + + + + +/********************************************************* + * CODE THAT MULTIPLIES EFFECT PARAMS --> PSEUDO ACTIONS * + *********************************************************/ + + + + + + + + + + + + + + + +void multiply_hard_effect_parameters( void ) + +{ + + MixedOperator *o; + PseudoAction *tmp; + int i; + Effect *e; + + ghard_templates = ( PseudoAction_pointer * ) + calloc( gnum_hard_mixed_operators, sizeof ( PseudoAction_pointer ) ); + gnum_hard_templates = 0; + + for ( o = ghard_mixed_operators; o; o = o->next ) { + tmp = new_PseudoAction( o ); + + for ( i = 0; i < tmp->operator->num_vars; i++ ) { + linst_table[i] = tmp->inst_table[i]; + } + + for ( e = o->effects; e; e = e->next ) { + create_hard_pseudo_effects( tmp, e, 0 ); + } + + ghard_templates[gnum_hard_templates++] = tmp; + } +} + + + +void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ) + +{ + + int par, t, i, m, mn; + WffNode *tmp1, *w, *ww; + PseudoActionEffect *tmp2; + + if ( curr_var < e->num_vars ) { + par = a->operator->num_vars + curr_var; + + t = e->var_types[curr_var]; + for ( i = 0; i < gtype_size[t]; i++ ) { + linst_table[par] = gtype_consts[t][i]; + + create_hard_pseudo_effects( a, e, curr_var + 1 ); + + linst_table[par] = -1; + } + return; + } + + tmp1 = instantiate_wff( e->conditions ); + + if ( tmp1->connective == FAL ) { + free_WffNode( tmp1 ); + return; + } + + dnf( &tmp1 ); + cleanup_wff( &tmp1 ); + + /* only debugging, REMOVE LATER + */ + if ( is_dnf( tmp1 ) == -1 ) { + printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", a->operator->name); + print_Wff( tmp1, 0 ); + exit( 1 ); + } + + switch ( tmp1->connective ) { + case OR: + for ( w = tmp1->sons; w; w = w->next ) { + tmp2 = new_PseudoActionEffect(); + if ( w->connective == AND ) { + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_conditions = m; + tmp2->num_numeric_conditions = mn; + m = 0; mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp2->conditions[m].predicate = ww->fact->predicate; + for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { + tmp2->conditions[m].args[i] = ww->fact->args[i]; + } + m++; + } + if ( ww->connective == COMP ) { + tmp2->numeric_conditions_comp[mn] = ww->comp; + tmp2->numeric_conditions_lh[mn] = copy_Exp( ww->lh ); + tmp2->numeric_conditions_rh[mn] = copy_Exp( ww->rh ); + mn++; + } + } + } else { + if ( w->connective == ATOM ) { + tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_conditions = 1; + tmp2->conditions[0].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->conditions[0].args[i] = w->fact->args[i]; + } + } + if ( w->connective == COMP ) { + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_comp[0] = w->comp; + tmp2->numeric_conditions_lh[0] = copy_Exp( w->lh ); + tmp2->numeric_conditions_rh[0] = copy_Exp( w->rh ); + tmp2->num_numeric_conditions = 1; + } + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + } + break; + case AND: + tmp2 = new_PseudoActionEffect(); + m = 0; + mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) m++; + if ( w->connective == COMP ) mn++; + } + tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp2->num_conditions = m; + tmp2->num_numeric_conditions = mn; + m = 0; mn = 0; + for ( w = tmp1->sons; w; w = w->next ) { + if ( w->connective == ATOM ) { + tmp2->conditions[m].predicate = w->fact->predicate; + for ( i = 0; i < garity[w->fact->predicate]; i++ ) { + tmp2->conditions[m].args[i] = w->fact->args[i]; + } + m++; + } + if ( w->connective == COMP ) { + tmp2->numeric_conditions_comp[mn] = w->comp; + tmp2->numeric_conditions_lh[mn] = copy_Exp( w->lh ); + tmp2->numeric_conditions_rh[mn] = copy_Exp( w->rh ); + mn++; + } + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case ATOM: + tmp2 = new_PseudoActionEffect(); + tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp2->num_conditions = 1; + tmp2->conditions[0].predicate = tmp1->fact->predicate; + for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { + tmp2->conditions[0].args[i] = tmp1->fact->args[i]; + } + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case COMP: + tmp2 = new_PseudoActionEffect(); + tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp2->numeric_conditions_comp[0] = tmp1->comp; + tmp2->numeric_conditions_lh[0] = copy_Exp( tmp1->lh ); + tmp2->numeric_conditions_rh[0] = copy_Exp( tmp1->rh ); + tmp2->num_numeric_conditions = 1; + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + case TRU: + tmp2 = new_PseudoActionEffect(); + make_instantiate_literals( tmp2, e->effects ); + make_instantiate_numeric_effects( tmp2, e->numeric_effects ); + tmp2->next = a->effects; + a->effects = tmp2; + a->num_effects++; + break; + default: + printf("\n\nillegal connective %d in parsing DNF condition.\n\n", + tmp1->connective); + exit( 1 ); + } + + free_WffNode( tmp1 ); + +} + + + +void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ) + +{ + + int ma = 0, md = 0, i; + Literal *l; + + for ( l = ll; l; l = l->next ) { + if ( l->negated ) { + md++; + } else { + ma++; + } + } + + e->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + e->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + + for ( l = ll; l; l = l->next ) { + if ( l->negated ) { + e->dels[e->num_dels].predicate = l->fact.predicate; + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + e->dels[e->num_dels].args[i] = ( l->fact.args[i] < 0 ) ? + linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; + } + e->num_dels++; + } else { + e->adds[e->num_adds].predicate = l->fact.predicate; + for ( i = 0; i < garity[l->fact.predicate]; i++ ) { + e->adds[e->num_adds].args[i] = ( l->fact.args[i] < 0 ) ? + linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; + } + e->num_adds++; + } + } + +} + + + +void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ) + +{ + + int m = 0, i; + NumericEffect *n; + + for ( n = ne; n; n = n->next ) m++; + + e->numeric_effects_neft = ( NumericEffectType * ) calloc( m, sizeof( NumericEffectType ) ); + e->numeric_effects_fluent = ( Fluent * ) calloc( m, sizeof( Fluent ) ); + e->numeric_effects_rh = ( ExpNode_pointer * ) calloc( m, sizeof( ExpNode_pointer ) ); + e->num_numeric_effects = m; + + m = 0; + for ( n = ne; n; n = n->next ) { + e->numeric_effects_neft[m] = n->neft; + e->numeric_effects_fluent[m].function = n->fluent.function; + for ( i = 0; i < gf_arity[n->fluent.function]; i++ ) { + e->numeric_effects_fluent[m].args[i] = ( n->fluent.args[i] < 0 ) ? + linst_table[DECODE_VAR( n->fluent.args[i] )] : n->fluent.args[i]; + } + e->numeric_effects_rh[m] = copy_Exp( n->rh ); + instantiate_exp( &(e->numeric_effects_rh[m]) ); + m++; + } + +} diff --git a/models/main_models/rt1/gen/ff_planner/inst_hard.h b/models/main_models/rt1/gen/ff_planner/inst_hard.h new file mode 100644 index 000000000..babebc20e --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_hard.h @@ -0,0 +1,71 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: inst_hard.h + * Description: headers for multiplying hard operators. + * + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + +#ifndef _INST_HARD_H +#define _INST_HARD_H + + + +void build_hard_action_templates( void ); + + + +void cleanup_hard_domain( void ); +Bool var_used_in_literals( int code_var, Literal *ef ); +Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ); +void decrement_inferior_vars_in_literals( int var, Literal *ef ); +void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ); + + + +void multiply_hard_op_parameters( void ); +void create_hard_mixed_operators( Operator *o, int curr_var ); +Effect *instantiate_Effect( Effect *e ); +WffNode *instantiate_wff( WffNode *w ); +void instantiate_exp( ExpNode **n ); +Bool full_possibly_positive( Fact *f ); +Bool full_possibly_negative( Fact *f ); +int instantiated_fact_adress( Fact *f ); + + + +void multiply_hard_effect_parameters( void ); +void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ); +void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ); +void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ); + + + +#endif /* _INST_HARD_H */ diff --git a/models/main_models/rt1/gen/ff_planner/inst_pre.c b/models/main_models/rt1/gen/ff_planner/inst_pre.c new file mode 100644 index 000000000..3e6877200 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_pre.c @@ -0,0 +1,3854 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + + +/********************************************************************* + * File: inst_pre.c + * Description: functions for instantiating operators, preprocessing part. + * - transform domain into integers + * - inertia preprocessing: + * - collect inertia info + * - split initial state in special arrays + * - Wff normalization: + * - simplification + * - quantifier expansion + * - NOT s down + * - negative preconditions translation + * - split operators into easy and hard to instantiate + * + * - full DNF functions, only feasible for fully instantiated + * formulae + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "inst_pre.h" + + + + + + + + + + + + + + + + + + +/******************************************************* + * TRANSFORM DOMAIN INTO INTEGER (FACT) REPRESENTATION * + *******************************************************/ + + + + + + + + + +char *lvar_names[MAX_VARS]; +int lvar_types[MAX_VARS]; + + + + + + + + + + +void encode_domain_in_integers( void ) + +{ + + int i,j; + + collect_all_strings(); + create_member_nrs(); + + if ( gcmd_line.display_info == 103 ) { + printf("\nconstant table:"); + for ( i = 0; i < gnum_constants; i++ ) { + printf("\n%d --> %s", i, gconstants[i]); + } + + printf("\n\ntypes table:"); + for ( i = 0; i < gnum_types; i++ ) { + printf("\n%d --> %s: ", i, gtype_names[i]); + for ( j = 0; j < gtype_size[i]; j++ ) { + printf("%d ", gtype_consts[i][j]); + } + } + + printf("\n\npredicates table:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n%3d --> %s: ", i, gpredicates[i]); + for ( j = 0; j < garity[i]; j++ ) { + printf("%s ", gtype_names[gpredicates_args_type[i][j]]); + } + } + + printf("\n\nfunctions table:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n%3d --> %s: ", i, gfunctions[i]); + for ( j = 0; j < gf_arity[i]; j++ ) { + printf("%s ", gtype_names[gfunctions_args_type[i][j]]); + } + } + printf("\n\n"); + } + + create_integer_representation(); + + if ( gcmd_line.display_info == 104 ) { + printf("\n\nfirst step initial state is:"); + for ( i = 0; i < gnum_full_initial; i++ ) { + printf("\n"); + print_Fact( &(gfull_initial[i]) ); + } + printf("\n\nfirst step fluent initial state is:"); + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + printf("\n"); + print_Fluent( &(gfull_fluents_initial[i].fluent) ); + printf(": %f", gfull_fluents_initial[i].value); + } + + printf("\n\nfirst step operators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\n\nfirst step goal is:\n"); + print_Wff( ggoal, 0 ); + fflush( stdout ); + + printf("\n\nfirst step metric is: (normalized to minimize)\n"); + print_ExpNode( gmetric ); + fflush( stdout ); + } + +} + + + +void create_member_nrs( void ) + +{ + + int i, j, num; + + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + for ( j = 0; j < MAX_TYPES; j++ ) { + gmember_nr[i][j] = -1; + } + } + + for ( i = 0; i < gnum_types; i++ ) { + num = 0; + for ( j = 0; j < gtype_size[i]; j++ ) { + gmember_nr[gtype_consts[i][j]][i] = num; + num++; + } + } + +} + + + +void collect_all_strings( void ) + +{ + + FactList *f; + TokenList *t; + int p_num, type_num, c_num, ar; + int i; + + /* first are types and their objects. for = we make sure that there + * is one type that contains all objects. + */ + gtype_names[0] = new_Token( 50 ); + gtype_names[0] = "ARTFICIAL-ALL-OBJECTS"; + gtype_size[0] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][0] = FALSE; + } + gnum_types = 1; + + for ( f = gorig_constant_list; f; f = f->next ) { + if ( (type_num = position_in_types_table( f->item->next->item )) == -1 ) { + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_names[gnum_types] = new_Token( strlen( f->item->next->item ) + 1 ); + strcpy( gtype_names[gnum_types], f->item->next->item ); + gtype_size[gnum_types] = 0; + for ( i = 0; i < MAX_CONSTANTS; i++ ) { + gis_member[i][gnum_types] = FALSE; + } + type_num = gnum_types++; + } + + if ( (c_num = position_in_constants_table( f->item->item )) == -1 ) { + if ( gnum_constants == MAX_CONSTANTS ) { + printf("\ntoo many constants! increase MAX_CONSTANTS (currently %d)\n\n", + MAX_CONSTANTS); + exit( 1 ); + } + gconstants[gnum_constants] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gconstants[gnum_constants], f->item->item ); + c_num = gnum_constants++; + + /* all constants into 0-type. + */ + if ( gtype_size[0] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[0], MAX_TYPE); + exit( 1 ); + } + gtype_consts[0][gtype_size[0]++] = c_num; + gis_member[c_num][0] = TRUE; + } + + if ( !gis_member[c_num][type_num] ) { + if ( gtype_size[type_num] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[type_num], MAX_TYPE); + exit( 1 ); + } + gtype_consts[type_num][gtype_size[type_num]++] = c_num; + gis_member[c_num][type_num] = TRUE; + } + } + + /* next are predicates; first of all, create in-built predicate = + */ + gpredicates[0] = new_Token( 5 ); + gpredicates[0] = "="; + gpredicates_args_type[0][0] = 0;/* all objects type */ + gpredicates_args_type[0][1] = 0; + garity[0] = 2; + gnum_predicates = 1; + + for ( f = gpredicates_and_types; f; f = f->next ) { + if ( (p_num = position_in_predicates_table( f->item->item )) != -1 ) { + printf("\npredicate %s declared twice!\n\n", f->item->item); + exit( 1 ); + } + if ( gnum_predicates == MAX_PREDICATES ) { + printf("\ntoo many predicates! increase MAX_PREDICATES (currently %d)\n\n", + MAX_PREDICATES); + exit( 1 ); + } + gpredicates[gnum_predicates] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gpredicates[gnum_predicates], f->item->item ); + ar = 0; + for ( t = f->item->next; t; t = t->next ) { + if ( (type_num = position_in_types_table( t->item )) == -1 ) { + printf("\npredicate %s is declared to use unknown or empty type %s\n\n", + f->item->item, t->item); + exit( 1 ); + } + if ( ar == MAX_ARITY ) { + printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", + gpredicates[gnum_predicates], MAX_ARITY); + exit( 1 ); + } + gpredicates_args_type[gnum_predicates][ar++] = type_num; + } + garity[gnum_predicates] = ar; + gaxiom_added[gnum_predicates] = FALSE; + gnum_predicates++; + } + + + /* next are functions; first of all, create in-built function total-time + * for sole use in metric + */ + gfunctions[0] = new_Token( 20 ); + gfunctions[0] = "TOTAL-TIME"; + gf_arity[0] = 0; + gnum_functions = 1; + + for ( f = gfunctions_and_types; f; f = f->next ) { + if ( (p_num = position_in_functions_table( f->item->item )) != -1 ) { + printf("\nfunction %s declared twice!\n\n", f->item->item); + exit( 1 ); + } + if ( gnum_functions == MAX_FUNCTIONS ) { + printf("\ntoo many functions! increase MAX_FUNCTIONS (currently %d)\n\n", + MAX_FUNCTIONS); + exit( 1 ); + } + gfunctions[gnum_functions] = new_Token( strlen( f->item->item ) + 1 ); + strcpy( gfunctions[gnum_functions], f->item->item ); + ar = 0; + for ( t = f->item->next; t; t = t->next ) { + if ( (type_num = position_in_types_table( t->item )) == -1 ) { + printf("\nfunction %s is declared to use unknown or empty type %s\n\n", + f->item->item, t->item); + exit( 1 ); + } + if ( ar == MAX_ARITY ) { + printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", + gfunctions[gnum_functions], MAX_ARITY); + exit( 1 ); + } + gfunctions_args_type[gnum_functions][ar++] = type_num; + } + gf_arity[gnum_functions++] = ar; + } + + free_FactList( gorig_constant_list ); + free_FactList( gpredicates_and_types ); + free_FactList( gfunctions_and_types ); + +} + + + +int position_in_types_table( char *str ) + +{ + + int i; + + /* start at 1 because 0 is our artificial one + */ + for ( i = 1; i < gnum_types; i++ ) { + if ( str == gtype_names[i] || + (strcmp( str, gtype_names[i] ) == SAME) ) { + break; + } + } + + return ( i == gnum_types ) ? -1 : i; + +} + + + +int position_in_constants_table( char *str ) + +{ + + int i; + + for ( i=0; isons; n; n = n->next ) sum++; + sum += gnum_constants;/* space for equalities */ + gfull_initial = ( Fact * ) calloc( sum, sizeof( Fact ) ); + gfull_fluents_initial = ( FluentValue * ) + calloc( sum, sizeof( FluentValue )); + + for ( n = gorig_initial_facts->sons; n; n = n->next ) { + if ( n->connective == ATOM ) { + make_Fact( &(gfull_initial[gnum_full_initial]), n, 0 ); + if ( gfull_initial[gnum_full_initial].predicate == 0 ) { + printf("\nequality in initial state! check input files.\n\n"); + exit( 1 ); + } + + /* duplicate check!! + */ + for ( i = 0; i < gnum_full_initial; i++ ) { + if ( gfull_initial[i].predicate != gfull_initial[gnum_full_initial].predicate ) { + /* predicate different --> this ini fact is not a duplicate! + */ + continue; + } + for ( j = 0; j < garity[gfull_initial[i].predicate]; j++ ) { + if ( gfull_initial[i].args[j] != gfull_initial[gnum_full_initial].args[j] ) { + /* arg different --> this ini fact is not a duplicate! + */ + break; + } + } + if ( j == garity[gfull_initial[i].predicate] ) { + /* found a duplicate! + */ + break; + } + } + if ( i < gnum_full_initial ) { + /* simply skip the second occurence... + */ + continue; + } + + gnum_full_initial++; + } else { + /* a fluent value assignment + */ + make_Fluent( &(gfull_fluents_initial[gnum_full_fluents_initial].fluent), + n->lh->atom, 0 ); + gfull_fluents_initial[gnum_full_fluents_initial].value = + ( float ) strtod( n->rh->atom->item, NULL); + gnum_full_fluents_initial++; + } + } + free_PlNode( gorig_initial_facts ); + } + + /* now insert all our artificial equality constraints into initial state. + */ + for ( i = 0; i < gnum_constants; i++ ) { + gfull_initial[gnum_full_initial].predicate = 0; + gfull_initial[gnum_full_initial].args[0] = i; + gfull_initial[gnum_full_initial].args[1] = i; + gnum_full_initial++; + } + /* FINITO. the rest of equality handling will fully + * automatically be done by the rest of the machinery. + */ + + ggoal = make_Wff( gorig_goal_facts, 0 ); + + if ( gparse_metric != NULL ) { + /* no need to throw costs away, even if we're not explicitly asked to + * minimize them + */ + if ( 0 && !gcost_minimizing ) { + if ( gcmd_line.display_info ) { + printf("\n\nno optimization required. skipping criterion.\n\n"); + } + } else { + gmetric = make_ExpNode( gparse_metric, 0 ); + if ( strcmp( gparse_optimization, "MINIMIZE" ) != SAME && + strcmp( gparse_optimization, "minimize" ) != SAME && + strcmp( gparse_optimization, "MAXIMIZE" ) != SAME && + strcmp( gparse_optimization, "maximize" ) != SAME ) { + if ( gcmd_line.display_info ) { + printf("\n\nunknown optimization method %s. check input files\n\n", + gparse_optimization); + } + exit( 1 ); + } + if ( strcmp( gparse_optimization, "MAXIMIZE" ) == SAME || + strcmp( gparse_optimization, "maximize" ) == SAME ) { + t = new_ExpNode( MINUS ); + t->son = gmetric; + gmetric = t; + } + } + } + + for ( o = gloaded_ops; o; o = o->next ) { + tmp = new_Operator( o->name, o->number_of_real_params ); + tmp->axiom = o->axiom; + + for ( ff = o->params; ff; ff = ff->next ) { + if ( (type_num = position_in_types_table( ff->item->next->item )) == -1 ) { + printf("\nwarning: parameter %s of op %s has unknown or empty type %s. skipping op", + ff->item->item, o->name, ff->item->next->item); + break; + } + if ( tmp->num_vars == MAX_VARS ) { + printf("\ntoo many parameters! increase MAX_VARS (currently %d)\n\n", + MAX_VARS); + exit( 1 ); + } + for ( i = 0; i < tmp->num_vars; i++ ) { + if ( tmp->var_names[i] == ff->item->item || + strcmp( tmp->var_names[i], ff->item->item ) == SAME ) { + printf("\nwarning: operator %s parameter %s overwrites previous declaration\n\n", + tmp->name, ff->item->item); + } + } + tmp->var_names[tmp->num_vars] = new_Token( strlen( ff->item->item ) + 1 ); + strcpy( tmp->var_names[tmp->num_vars], ff->item->item ); + tmp->var_types[tmp->num_vars++] = type_num; + } + if ( ff ) { + free_Operator( tmp ); + continue; + } + + for ( i = 0; i < tmp->num_vars; i++ ) { + lvar_types[i] = tmp->var_types[i]; + lvar_names[i] = tmp->var_names[i]; + } + + tmp->preconds = make_Wff( o->preconds, tmp->num_vars ); + + if ( o->effects ) { + /* in make_effect, make sure that no one afects equality. + */ + nn = o->effects->sons; + while ( nn && + (tmp->effects = make_effect( nn, tmp->num_vars )) == NULL ) { + nn = nn->next; + } + if ( nn ) { + for ( n = nn->next; n; n = n->next ) { + if ( (tmp->effects->prev = make_effect( n, tmp->num_vars )) == NULL ) { + continue; + } + tmp->effects->prev->next = tmp->effects; + tmp->effects = tmp->effects->prev; + } + } + } + + if ( gnum_operators == MAX_OPERATORS ) { + printf("\ntoo many operators! increase MAX_OPERATORS (currently %d)\n\n", + MAX_OPERATORS); + exit( 1 ); + } + goperators[gnum_operators++] = tmp; + } + + if ( 0 ) { + /* currently not in use; leads to free memory reads and + * free memory frees (no memory leaks), which are hard to explain. + * + * almost no memory consumption anyway. + */ + free_PlOperator( gloaded_ops ); + } + + /* establish gaxiom_added markers. + * ascertain that derived predicates do not appear in effects!! + */ + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( goperators[i]->axiom ) { + gaxiom_added[l->fact.predicate] = TRUE; + } + } + } + } + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( !goperators[i]->axiom && + gaxiom_added[l->fact.predicate] ) { + printf("\nA derived predicate appears in an operator effect."); + printf("\nSorry, this is not allowed. Bailing out.\n\n"); + exit( 1 ); + } + } + } + } + +} + + + +void make_Fact( Fact *f, PlNode *n, int num_vars ) + +{ + + int m, i; + TokenList *t; + + if ( !n->atom ) { + /* can't happen after previous syntax check. Oh well, whatever... + */ + printf("\nillegal (empty) atom used in domain. check input files\n\n"); + exit( 1 ); + } + + f->predicate = position_in_predicates_table( n->atom->item ); + if ( f->predicate == -1 ) { + printf("\nundeclared predicate %s used in domain definition\n\n", + n->atom->item); + exit( 1 ); + } + + m = 0; + for ( t = n->atom->next; t; t = t->next ) { + if ( t->item[0] == '?' ) { + for ( i=num_vars-1; i>-1; i-- ) { + /* downwards, to always get most recent declaration/quantification + * of that variable + */ + if ( lvar_names[i] == t->item || + strcmp( lvar_names[i], t->item ) == SAME ) { + break; + } + } + if ( i == -1 ) { + printf("\nundeclared variable %s in literal %s. check input files\n\n", + t->item, n->atom->item); + exit( 1 ); + } + if ( lvar_types[i] != gpredicates_args_type[f->predicate][m] && + !is_subtype( lvar_types[i], gpredicates_args_type[f->predicate][m] ) ) { + printf("\ntype of var %s does not match type of arg %d of predicate %s\n\n", + lvar_names[i], m, gpredicates[f->predicate]); + exit( 1 ); + } + f->args[m] = ENCODE_VAR( i ); + } else { + if ( (f->args[m] = + position_in_constants_table( t->item )) == -1 ) { + printf("\nunknown constant %s in literal %s. check input files\n\n", + t->item, n->atom->item); + exit( 1 ); + } + if ( !gis_member[f->args[m]][gpredicates_args_type[f->predicate][m]] ) { + printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", + gconstants[f->args[m]], m, gpredicates[f->predicate]); + exit( 1 ); + } + } + m++; + } + if ( m != garity[f->predicate] ) { + printf("\npredicate %s is declared to have %d (not %d) arguments. check input files\n\n", + gpredicates[f->predicate], + garity[f->predicate], m); + exit( 1 ); + } + +} + + + +void make_Fluent( Fluent *f, TokenList *atom, int num_vars ) + +{ + + int m, i; + TokenList *t; + + if ( !atom ) { + /* can't happen after previous syntax check. Oh well, whatever... + */ + printf("\nillegal (empty) atom used in domain. check input files\n\n"); + exit( 1 ); + } + + f->function = position_in_functions_table( atom->item ); + if ( f->function == -1 ) { + printf("\nundeclared function %s used in domain definition\n\n", + atom->item); + exit( 1 ); + } + + m = 0; + for ( t = atom->next; t; t = t->next ) { + if ( t->item[0] == '?' ) { + for ( i=num_vars-1; i>-1; i-- ) { + /* downwards, to always get most recent declaration/quantification + * of that variable + */ + if ( lvar_names[i] == t->item || + strcmp( lvar_names[i], t->item ) == SAME ) { + break; + } + } + if ( i == -1 ) { + printf("\nundeclared variable %s in function %s. check input files\n\n", + t->item, atom->item); + exit( 1 ); + } + if ( lvar_types[i] != gfunctions_args_type[f->function][m] && + !is_subtype( lvar_types[i], gfunctions_args_type[f->function][m] ) ) { + printf("\ntype of var %s does not match type of arg %d of function %s\n\n", + lvar_names[i], m, gfunctions[f->function]); + exit( 1 ); + } + f->args[m] = ENCODE_VAR( i ); + } else { + if ( (f->args[m] = + position_in_constants_table( t->item )) == -1 ) { + printf("\nunknown constant %s in function %s. check input files\n\n", + t->item, atom->item); + exit( 1 ); + } + if ( !gis_member[f->args[m]][gfunctions_args_type[f->function][m]] ) { + printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", + gconstants[f->args[m]], m, gfunctions[f->function]); + exit( 1 ); + } + } + m++; + } + + if ( m != gf_arity[f->function] ) { + printf("\nfunction %s is declared to have %d (not %d) arguments. check input files\n\n", + gfunctions[f->function], + gf_arity[f->function], m); + exit( 1 ); + } + +} + + + +Bool is_subtype( int t1, int t2 ) + +{ + + int i; + + for ( i = 0; i < gtype_size[t1]; i++ ) { + if ( !gis_member[gtype_consts[t1][i]][t2] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +WffNode *make_Wff( PlNode *p, int num_vars ) + +{ + + WffNode *tmp; + int i, t; + PlNode *n; + + if ( !p ) { + tmp = NULL; + return tmp; + } + + tmp = new_WffNode( p->connective ); + switch ( p->connective ) { + case ALL: + case EX: + for ( i = 0; i < num_vars; i++ ) { + if ( lvar_names[i] == p->atom->item || + strcmp( lvar_names[i], p->atom->item ) == SAME ) { + printf("\nwarning: var quantification of %s overwrites previous declaration\n\n", + p->atom->item); + } + } + if ( (t = position_in_types_table( p->atom->next->item )) == -1 ) { + printf("\nwarning: quantified var %s has unknown or empty type %s. simplifying.\n\n", + p->atom->item, p->atom->next->item); + tmp->connective = ( p->connective == EX ) ? FAL : TRU; + break; + } + tmp->var = num_vars; + tmp->var_type = t; + tmp->var_name = new_Token( strlen( p->atom->item ) + 1 ); + strcpy( tmp->var_name, p->atom->item ); + lvar_names[num_vars] = p->atom->item; + lvar_types[num_vars] = t; + tmp->son = make_Wff( p->sons, num_vars + 1 ); + break; + case AND: + case OR: + if ( !p->sons ) { + printf("\nwarning: empty con/disjunction in domain definition. simplifying.\n\n"); + tmp->connective = ( p->connective == OR ) ? FAL : TRU; + break; + } + tmp->sons = make_Wff( p->sons, num_vars ); + for ( n = p->sons->next; n; n = n->next ) { + tmp->sons->prev = make_Wff( n, num_vars ); + tmp->sons->prev->next = tmp->sons; + tmp->sons = tmp->sons->prev; + } + break; + case NOT: + tmp->son = make_Wff( p->sons, num_vars ); + break; + case ATOM: + tmp->fact = new_Fact(); + make_Fact( tmp->fact, p, num_vars ); + break; + case TRU: + case FAL: + break; + case COMP: + tmp->comp = p->comp; + tmp->lh = make_ExpNode( p->lh, num_vars ); + tmp->rh = make_ExpNode( p->rh, num_vars ); + break; + default: + printf("\nforbidden connective %d in Pl Wff. must be a bug somewhere...\n\n", + p->connective); + exit( 1 ); + } + + return tmp; + +} + + + +ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ) + +{ + + ExpNode *tmp; + + if ( !p ) { + tmp = NULL; + return tmp; + } + + tmp = new_ExpNode( p->connective ); + switch ( p->connective ) { + case AD: + case SU: + case MU: + case DI: + tmp->leftson = make_ExpNode( p->leftson, num_vars ); + tmp->rightson = make_ExpNode( p->rightson, num_vars ); + break; + case MINUS: + tmp->son = make_ExpNode( p->leftson, num_vars ); + break; + case NUMBER: + tmp->value = ( float ) strtod( p->atom->item, NULL ); + break; + case FHEAD: + tmp->fluent = new_Fluent(); + make_Fluent( tmp->fluent, p->atom, num_vars ); + break; + default: + printf("\n\nmake expnode: wrong specifier %d", + p->connective); + exit( 1 ); + } + + return tmp; + +} + + + +Effect *make_effect( PlNode *p, int num_vars ) + +{ + + Effect *tmp = new_Effect(); + PlNode *n, *m; + int t, i; + + for ( n = p; n && n->connective == ALL; n = n->sons ) { + if ( (t = position_in_types_table( n->atom->next->item )) == -1 ) { + printf("\nwarning: effect parameter %s has unknown or empty type %s. skipping effect.\n\n", + n->atom->item, n->atom->next->item); + return NULL; + } + for ( i = 0; i < num_vars + tmp->num_vars; i++ ) { + if ( lvar_names[i] == n->atom->item || + strcmp( lvar_names[i], n->atom->item ) == SAME ) { + printf("\nwarning: effect parameter %s overwrites previous declaration\n\n", + n->atom->item); + } + } + lvar_types[num_vars + tmp->num_vars] = t; + lvar_names[num_vars + tmp->num_vars] = n->atom->item; + tmp->var_names[tmp->num_vars] = new_Token( strlen( n->atom->item ) + 1 ); + strcpy( tmp->var_names[tmp->num_vars], n->atom->item ); + tmp->var_types[tmp->num_vars++] = t; + } + + if ( !n || n->connective != WHEN ) { + printf("\nnon WHEN %d at end of effect parameters. debug me\n\n", + n->connective); + exit( 1 ); + } + + tmp->conditions = make_Wff( n->sons, num_vars + tmp->num_vars ); + + if ( n->sons->next->connective != AND ) { + printf("\nnon AND %d in front of literal effect list. debug me\n\n", + n->sons->next->connective); + exit( 1 ); + } + if ( !n->sons->next->sons ) { + return tmp; + } + for ( m = n->sons->next->sons; m; m = m->next ) { + if ( m->connective == NEF ) { + if ( tmp->numeric_effects != NULL ) { + tmp->numeric_effects->prev = new_NumericEffect(); + make_Fluent( &(tmp->numeric_effects->prev->fluent), + m->lh->atom, num_vars + tmp->num_vars ); + tmp->numeric_effects->prev->neft = m->neft; + tmp->numeric_effects->prev->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); + + tmp->numeric_effects->prev->next = tmp->numeric_effects; + tmp->numeric_effects = tmp->numeric_effects->prev; + } else { + tmp->numeric_effects = new_NumericEffect(); + make_Fluent( &(tmp->numeric_effects->fluent), + m->lh->atom, num_vars + tmp->num_vars ); + tmp->numeric_effects->neft = m->neft; + tmp->numeric_effects->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); + } + } else { + if ( tmp->effects != NULL ) { + tmp->effects->prev = new_Literal(); + if ( m->connective == NOT ) { + tmp->effects->prev->negated = TRUE; + make_Fact( &(tmp->effects->prev->fact), m->sons, num_vars + tmp->num_vars ); + if ( (tmp->effects->prev->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } else { + tmp->effects->prev->negated = FALSE; + make_Fact( &(tmp->effects->prev->fact), m, num_vars + tmp->num_vars ); + if ( (tmp->effects->prev->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } + tmp->effects->prev->next = tmp->effects; + tmp->effects = tmp->effects->prev; + } else { + tmp->effects = new_Literal(); + if ( m->connective == NOT ) { + tmp->effects->negated = TRUE; + make_Fact( &(tmp->effects->fact), m->sons, num_vars + tmp->num_vars ); + if ( (tmp->effects->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } else { + tmp->effects->negated = FALSE; + make_Fact( &(tmp->effects->fact), m, num_vars + tmp->num_vars ); + if ( (tmp->effects->fact).predicate == 0 ) { + printf("\n\nequality in effect! check input files!\n\n"); + exit( 1 ); + } + } + } + } + } + + return tmp; + +} + + + + + + + + + + + +/************************* + * INERTIA PREPROCESSING * + *************************/ + + + + + + + + + + + +void do_inertia_preprocessing_step_1( void ) + +{ + + int i, j; + Facts *f; + FluentValues *ff; + + collect_inertia_information(); + + if ( gcmd_line.display_info == 105 ) { + printf("\n\npredicates inertia info:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n%3d --> %s: ", i, gpredicates[i]); + printf(" is %s, %s", + gis_added[i] ? "ADDED" : "NOT ADDED", + gis_deleted[i] ? "DELETED" : "NOT DELETED"); + } + printf("\n\nfunctions inertia info:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n%3d --> %s: ", i, gfunctions[i]); + printf(" is %s", + gis_changed[i] ? "CHANGED" : "NOT CHANGED"); + } + printf("\n\n"); + } + + split_initial_state(); + + if ( gcmd_line.display_info == 106 ) { + printf("\n\nsplitted initial state is:"); + printf("\nindividual predicates:"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n\n%s:", gpredicates[i]); + if ( !gis_added[i] && + !gis_deleted[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + printf("\n"); + print_Fact( &(ginitial_predicate[i][j]) ); + } + } + printf("\n\nnon static part:"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + + printf("\n\nextended types table:"); + for ( i = 0; i < gnum_types; i++ ) { + printf("\n%d --> ", i); + if ( gpredicate_to_type[i] == -1 ) { + printf("%s ", gtype_names[i]); + } else { + printf("UNARY INERTIA TYPE (%s) ", gpredicates[gpredicate_to_type[i]]); + } + for ( j = 0; j < gtype_size[i]; j++ ) { + printf("%d ", gtype_consts[i][j]); + } + } + + printf("\nindividual functions:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n\n%s:", gfunctions[i]); + if ( !gis_changed[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_function[i]; j++ ) { + printf("\n"); + print_Fluent( &(ginitial_function[i][j].fluent) ); + printf(": %f", ginitial_function[i][j].value); + } + } + printf("\n\nnon static part:"); + for ( ff = gf_initial; ff; ff = ff->next ) { + printf("\n"); + print_Fluent( &(ff->fluent) ); + printf(": %f", ff->value); + } + } + +} + + + +void collect_inertia_information( void ) + +{ + + int i; + Effect *e; + Literal *l; + NumericEffect *ne; + + for ( i = 0; i < gnum_predicates; i++ ) { + gis_added[i] = FALSE; + gis_deleted[i] = FALSE; + } + for ( i = 0; i < gnum_functions; i++ ) { + gis_changed[i] = FALSE; + } + + for ( i = 0; i < gnum_operators; i++ ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + gis_deleted[l->fact.predicate] = TRUE; + } else { + gis_added[l->fact.predicate] = TRUE; + } + } + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + gis_changed[ne->fluent.function] = TRUE; + } + } + } + +} + + + +void split_initial_state( void ) + +{ + + int i, j, p, t; + Facts *tmp; + FluentValues *ftmp; + + for ( i = 0; i < MAX_PREDICATES; i++ ) { + gtype_to_predicate[i] = -1; + } + for ( i = 0; i < MAX_TYPES; i++ ) { + gpredicate_to_type[i] = -1; + } + + for ( i = 0; i < gnum_predicates; i++ ) { + if ( !gis_added[i] && + !gis_deleted[i] && + garity[i] == 1 ) { + if ( gnum_types == MAX_TYPES ) { + printf("\ntoo many (inferred) types! increase MAX_TYPES (currently %d)\n\n", + MAX_TYPES); + exit( 1 ); + } + gtype_to_predicate[i] = gnum_types; + gpredicate_to_type[gnum_types] = i; + gtype_names[gnum_types] = NULL; + gtype_size[gnum_types] = 0; + for ( j = 0; j < MAX_CONSTANTS; j++ ) { + gis_member[j][gnum_types] = FALSE; + } + gnum_types++; + } + } + + + /* double size of predicates table as each predicate might need + * to be translated to NOT-p + */ + ginitial_predicate = ( Fact ** ) calloc( gnum_predicates * 2, sizeof( Fact * ) ); + gnum_initial_predicate = ( int * ) calloc( gnum_predicates * 2, sizeof( int ) ); + for ( i = 0; i < gnum_predicates * 2; i++ ) { + gnum_initial_predicate[i] = 0; + } + for ( i = 0; i < gnum_full_initial; i++ ) { + p = gfull_initial[i].predicate; + gnum_initial_predicate[p]++; + } + for ( i = 0; i < gnum_predicates; i++ ) { + ginitial_predicate[i] = ( Fact * ) calloc( gnum_initial_predicate[i], sizeof( Fact ) ); + gnum_initial_predicate[i] = 0; + } + ginitial = NULL; + gnum_initial = 0; + + for ( i = 0; i < gnum_full_initial; i++ ) { + p = gfull_initial[i].predicate; + ginitial_predicate[p][gnum_initial_predicate[p]].predicate = p; + for ( j = 0; j < garity[p]; j++ ) { + ginitial_predicate[p][gnum_initial_predicate[p]].args[j] = gfull_initial[i].args[j]; + } + gnum_initial_predicate[p]++; + if ( gis_added[p] || + gis_deleted[p] ) { + tmp = new_Facts(); + tmp->fact->predicate = p; + for ( j = 0; j < garity[p]; j++ ) { + tmp->fact->args[j] = gfull_initial[i].args[j]; + } + tmp->next = ginitial; + ginitial = tmp; + gnum_initial++; + } else { + if ( garity[p] == 1 ) { + t = gtype_to_predicate[p]; + if ( gtype_size[t] == MAX_TYPE ) { + printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", + gtype_names[t], MAX_TYPE); + exit( 1 ); + } + if ( !gis_member[gfull_initial[i].args[0]][gpredicates_args_type[p][0]] ) { + printf("\ntype mismatch in initial state! %s as arg 0 of %s\n\n", + gconstants[gfull_initial[i].args[0]], gpredicates[p]); + exit( 1 ); + } + gtype_consts[t][gtype_size[t]++] = gfull_initial[i].args[0]; + gis_member[gfull_initial[i].args[0]][t] = TRUE; + } + } + } + + ginitial_function = ( FluentValue ** ) + calloc( gnum_functions, sizeof( FluentValue * ) ); + gnum_initial_function = ( int * ) calloc( gnum_functions, sizeof( int ) ); + for ( i = 0; i < gnum_functions; i++ ) { + gnum_initial_function[i] = 0; + } + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + p = gfull_fluents_initial[i].fluent.function; + gnum_initial_function[p]++; + } + for ( i = 0; i < gnum_functions; i++ ) { + ginitial_function[i] = ( FluentValue * ) + calloc( gnum_initial_function[i], sizeof( FluentValue ) ); + gnum_initial_function[i] = 0; + } + gf_initial = NULL; + gnum_f_initial = 0; + + for ( i = 0; i < gnum_full_fluents_initial; i++ ) { + p = gfull_fluents_initial[i].fluent.function; + ginitial_function[p][gnum_initial_function[p]].fluent.function = p; + for ( j = 0; j < gf_arity[p]; j++ ) { + ginitial_function[p][gnum_initial_function[p]].fluent.args[j] = + gfull_fluents_initial[i].fluent.args[j]; + } + ginitial_function[p][gnum_initial_function[p]].value = + gfull_fluents_initial[i].value; + gnum_initial_function[p]++; + if ( gis_changed[p] ) { + ftmp = new_FluentValues(); + ftmp->fluent.function = p; + for ( j = 0; j < gf_arity[p]; j++ ) { + ftmp->fluent.args[j] = gfull_fluents_initial[i].fluent.args[j]; + } + ftmp->value = gfull_fluents_initial[i].value; + ftmp->next = gf_initial; + gf_initial = ftmp; + gnum_f_initial++; + } + } + +} + + + + + + + + + + + +/****************************** + * NORMALIZE ALL PL1 FORMULAE * + ******************************/ + + + + + + + + + + + + +void normalize_all_wffs( void ) + +{ + + int i; + Effect *e; + + simplify_wff( &ggoal ); + remove_unused_vars_in_wff( &ggoal ); + expand_quantifiers_in_wff( &ggoal, -1, -1 ); + NOTs_down_in_wff( &ggoal ); + cleanup_wff( &ggoal ); + + if ( ggoal->connective == TRU ) { + printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); + gnum_plan_ops = 0; + exit( 1 ); + } + if ( ggoal->connective == FAL ) { + printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); + exit( 1 ); + } + + /* put goal into DNF right away: fully instantiated already + */ + dnf( &ggoal ); + cleanup_wff( &ggoal ); + + /* all we can do here is simplify if that's possible. + */ + if ( gmetric != NULL ) { + simplify_exp( &gmetric ); + } + + + for ( i = 0; i < gnum_operators; i++ ) { + simplify_wff( &(goperators[i]->preconds) ); + remove_unused_vars_in_wff( &(goperators[i]->preconds) ); + expand_quantifiers_in_wff( &(goperators[i]->preconds), -1, -1 ); + NOTs_down_in_wff( &(goperators[i]->preconds) ); + cleanup_wff( &(goperators[i]->preconds) ); + + for ( e = goperators[i]->effects; e; e = e->next ) { + simplify_wff( &(e->conditions) ); + remove_unused_vars_in_wff( &(e->conditions) ); + expand_quantifiers_in_wff( &(e->conditions), -1, -1 ); + NOTs_down_in_wff( &(e->conditions) ); + cleanup_wff( &(e->conditions) ); + } + } + + if ( gcmd_line.display_info == 107 ) { + printf("\n\ndomain with normalized PL1 formula:"); + + printf("\n\noperators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\n\ngoal is:\n"); + print_Wff( ggoal, 0 ); + + if ( gmetric ) { + printf("\n\nmetric is (minimize):\n"); + print_ExpNode( gmetric ); + } else { + printf("\n\nmetric: none, i.e. plan length\n"); + } + } + +} + + + +void remove_unused_vars_in_wff( WffNode **w ) + +{ + + WffNode *tmp; + WffNode *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + remove_unused_vars_in_wff( &((*w)->son) ); + if ( !var_used_in_wff( ENCODE_VAR( (*w)->var ), (*w)->son ) ) { + decrement_inferior_vars((*w)->var, (*w)->son ); + (*w)->connective = (*w)->son->connective; + (*w)->var = (*w)->son->var; + (*w)->var_type = (*w)->son->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->son->var_name; + (*w)->sons = (*w)->son->sons; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->son->fact; + (*w)->comp = (*w)->son->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->son->lh; + (*w)->rh = (*w)->son->rh; + + tmp = (*w)->son; + (*w)->son = (*w)->son->son; + free( tmp ); + } + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + remove_unused_vars_in_wff( &i ); + } + break; + case NOT: + remove_unused_vars_in_wff( &((*w)->son) ); + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: remove var, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +Bool var_used_in_wff( int code_var, WffNode *w ) + +{ + + WffNode *i; + int j; + + switch ( w->connective ) { + case ALL: + case EX: + return var_used_in_wff( code_var, w->son ); + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + if ( var_used_in_wff( code_var, i ) ) { + return TRUE; + } + } + return FALSE; + case NOT: + return var_used_in_wff( code_var, w->son ); + case ATOM: + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + if ( w->fact->args[j] >= 0 ) { + continue; + } + if ( w->fact->args[j] == code_var ) { + return TRUE; + } + } + return FALSE; + case COMP: + if ( var_used_in_exp( code_var, w->lh ) ) { + return TRUE; + } + if ( var_used_in_exp( code_var, w->rh ) ) { + return TRUE; + } + return FALSE; + case TRU: + case FAL: + return FALSE; + default: + printf("\nwon't get here: var used ?, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + +} + + + +Bool var_used_in_exp( int code_var, ExpNode *n ) + +{ + + int i; + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + if ( var_used_in_exp( code_var, n->leftson ) || + var_used_in_exp( code_var, n->rightson ) ) { + return TRUE; + } + return FALSE; + case MINUS: + if ( var_used_in_exp( code_var, n->son ) ) { + return TRUE; + } + return FALSE; + case NUMBER: + return FALSE; + case FHEAD: + if ( n->fluent ) { + for ( i = 0; i < gf_arity[n->fluent->function]; i++ ) { + if ( n->fluent->args[i] >= 0 ) { + continue; + } + if ( n->fluent->args[i] == code_var ) { + return TRUE; + } + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + } + return FALSE; + default: + printf("\n\nvar used in expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + +void decrement_inferior_vars( int var, WffNode *w ) + +{ + + WffNode *i; + int j; + + switch ( w->connective ) { + case ALL: + case EX: + w->var--; + decrement_inferior_vars( var, w->son ); + break; + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + decrement_inferior_vars( var, i ); + } + break; + case NOT: + decrement_inferior_vars( var, w->son ); + break; + case ATOM: + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + if ( w->fact->args[j] >= 0 ) { + continue; + } + if ( DECODE_VAR( w->fact->args[j] ) > var ) { + w->fact->args[j]++; + } + } + break; + case COMP: + decrement_inferior_vars_in_exp( var, w->lh ); + decrement_inferior_vars_in_exp( var, w->rh ); + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: decrement, non logical %d\n\n", + w->connective); + exit( 1 ); + } + +} + + + +void decrement_inferior_vars_in_exp( int var, ExpNode *n ) + +{ + + int j; + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + decrement_inferior_vars_in_exp( var, n->leftson ); + decrement_inferior_vars_in_exp( var, n->rightson ); + break; + case MINUS: + decrement_inferior_vars_in_exp( var, n->son ); + break; + case NUMBER: + break; + case FHEAD: + if ( n->fluent ) { + for ( j = 0; j < gf_arity[n->fluent->function]; j++ ) { + if ( n->fluent->args[j] >= 0 ) { + continue; + } + if ( DECODE_VAR( n->fluent->args[j] ) > var ) { + n->fluent->args[j]++; + } + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + } + break; + default: + printf("\n\ndecr inf vars in expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + +} + + + +void simplify_wff( WffNode **w ) + +{ + + WffNode *i, *tmp; + int m; + Bool ct; + + switch ( (*w)->connective ) { + case ALL: + case EX: + simplify_wff( &((*w)->son) ); + if ( (*w)->son->connective == TRU || + (*w)->son->connective == FAL ) { + (*w)->connective = (*w)->son->connective; + free( (*w)->son ); + (*w)->son = NULL; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + } + break; + case AND: + m = 0; + i = (*w)->sons; + while ( i ) { + simplify_wff( &i ); + if ( i->connective == FAL ) { + (*w)->connective = FAL; + /* free_WffNode( (*w)->sons ); */ + (*w)->sons = NULL; + return; + } + if ( i->connective == TRU ) { + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + if ( i->next ) { + i->next->prev = i->prev; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + m++; + } + if ( m == 0 ) { + (*w)->connective = TRU; + free_WffNode( (*w)->sons ); + (*w)->sons = NULL; + } + if ( m == 1 ) { + (*w)->connective = (*w)->sons->connective; + (*w)->var = (*w)->sons->var; + (*w)->var_type = (*w)->sons->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->sons->var_name; + (*w)->son = (*w)->sons->son; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->sons->fact; + (*w)->comp = (*w)->sons->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->sons->lh; + (*w)->rh = (*w)->sons->rh; + + tmp = (*w)->sons; + (*w)->sons = (*w)->sons->sons; + free( tmp ); + } + break; + case OR: + m = 0; + i = (*w)->sons; + while ( i ) { + simplify_wff( &i ); + if ( i->connective == TRU ) { + (*w)->connective = TRU; + free_WffNode( (*w)->sons ); + (*w)->sons = NULL; + return; + } + if ( i->connective == FAL ) { + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + if ( i->next ) { + i->next->prev = i->prev; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + m++; + } + if ( m == 0 ) { + (*w)->connective = FAL; + /* free_WffNode( (*w)->sons ); */ + (*w)->sons = NULL; + } + if ( m == 1 ) { + (*w)->connective = (*w)->sons->connective; + (*w)->var = (*w)->sons->var; + (*w)->var_type = (*w)->sons->var_type; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = (*w)->sons->var_name; + (*w)->son = (*w)->sons->son; + if ( (*w)->fact ) { + free( (*w)->fact ); + } + (*w)->fact = (*w)->sons->fact; + (*w)->comp = (*w)->sons->comp; + if ( (*w)->lh ) free_ExpNode( (*w)->lh ); + if ( (*w)->rh ) free_ExpNode( (*w)->rh ); + (*w)->lh = (*w)->sons->lh; + (*w)->rh = (*w)->sons->rh; + + tmp = (*w)->sons; + (*w)->sons = (*w)->sons->sons; + free( tmp ); + } + break; + case NOT: + simplify_wff( &((*w)->son) ); + if ( (*w)->son->connective == TRU || + (*w)->son->connective == FAL ) { + (*w)->connective = ( (*w)->son->connective == TRU ) ? FAL : TRU; + free( (*w)->son ); + (*w)->son = NULL; + } + break; + case ATOM: + if ( (*w)->visited ) { + /* already seen and not changed + */ + break; + } + if ( !possibly_negative( (*w)->fact ) ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !possibly_positive( (*w)->fact ) ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + (*w)->visited = TRUE; + break; + case COMP: + simplify_exp( &((*w)->lh) ); + simplify_exp( &((*w)->rh) ); + if ( (*w)->lh->connective != NUMBER || + (*w)->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); + if ( ct ) { + (*w)->connective = TRU; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } else { + (*w)->connective = FAL; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: simplify, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void simplify_exp( ExpNode **n ) + +{ + + int j, f, k; + + switch ( (*n)->connective ) { + case AD: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + simplify_exp( &((*n)->leftson) ); + simplify_exp( &((*n)->rightson) ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + simplify_exp( &((*n)->son) ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + if ( !(*n)->fluent ) { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + break; + } + f = (*n)->fluent->function; + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] < 0 ) { + break; + } + } + if ( j < gf_arity[f] ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\nsimplify expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +void expand_quantifiers_in_wff( WffNode **w, int var, int constant ) + +{ + + WffNode *r = NULL, *tmp, *i; + int j, l; + Bool change, ct; + + if ( !(*w) ) { + return; + } + + switch ( (*w)->connective ) { + case ALL: + case EX: + if ( var != -1 ) {/* depth first: upper node is active */ + expand_quantifiers_in_wff( &((*w)->son), var, constant ); + return; + } + + (*w)->connective = ( (*w)->connective == ALL ) ? AND : OR; + for ( j = 0; j < gtype_size[(*w)->var_type]; j++ ) { + tmp = copy_Wff( (*w)->son ); + expand_quantifiers_in_wff( &tmp, (*w)->var, gtype_consts[(*w)->var_type][j] ); + tmp->next = r; + if ( r ) { + r->prev = tmp; + } + r = tmp; + } + + free_WffNode( (*w)->son ); + (*w)->sons = r; + (*w)->var = -1; + (*w)->var_type = -1; + if ( (*w)->var_name ) { + free( (*w)->var_name ); + } + (*w)->var_name = NULL; + + /* now make all sons expand their quantifiers + */ + for ( i = (*w)->sons; i; i = i->next ) { + expand_quantifiers_in_wff( &i, -1, -1 ); + } + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + expand_quantifiers_in_wff( &i, var, constant ); + } + break; + case NOT: + expand_quantifiers_in_wff( &((*w)->son), var, constant ); + break; + case ATOM: + if ( var == -1 ) { + break; + } + + change = FALSE; + for ( l = 0; l < garity[(*w)->fact->predicate]; l++ ) { + if ( (*w)->fact->args[l] == ENCODE_VAR( var ) ) { + (*w)->fact->args[l] = constant; + change = TRUE; + } + } + if ( !change && (*w)->visited ) { + /* we did not change anything and we've already seen that node + * --> it cant be simplified + */ + break; + } + if ( !possibly_negative( (*w)->fact ) ) { + (*w)->connective = TRU; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + if ( !possibly_positive( (*w)->fact ) ) { + (*w)->connective = FAL; + free( (*w)->fact ); + (*w)->fact = NULL; + break; + } + (*w)->visited = TRUE; + break; + case COMP: + if ( var == -1 ) { + break; + } + + replace_var_with_const_in_exp( &((*w)->lh), var, constant ); + replace_var_with_const_in_exp( &((*w)->rh), var, constant ); + if ( (*w)->lh->connective != NUMBER || + (*w)->rh->connective != NUMBER ) { + /* logical simplification only possible if both parts are numbers + */ + break; + } + ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); + if ( ct ) { + (*w)->connective = TRU; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } else { + (*w)->connective = FAL; + free_ExpNode( (*w)->lh ); + (*w)->lh = NULL; + free_ExpNode( (*w)->rh ); + (*w)->rh = NULL; + (*w)->comp = -1; + break; + } + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: expansion, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ) + +{ + + int j, f, k; + + switch ( (*n)->connective ) { + case AD: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value + (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case SU: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value - (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MU: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value * (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case DI: + replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); + replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); + if ( (*n)->leftson->connective != NUMBER || + (*n)->rightson->connective != NUMBER ) { + break; + } + if ( (*n)->rightson->value == 0 ) { + /* kind of unclean: simply leave that in here; + * we will later determine the right thing + * to do with it. + */ + break; + } + (*n)->connective = NUMBER; + (*n)->value = (*n)->leftson->value / (*n)->rightson->value; + free_ExpNode( (*n)->leftson ); + (*n)->leftson = NULL; + free_ExpNode( (*n)->rightson ); + (*n)->rightson = NULL; + break; + case MINUS: + replace_var_with_const_in_exp( &((*n)->son), var, constant ); + if ( (*n)->son->connective != NUMBER ) break; + (*n)->connective = NUMBER; + (*n)->value = ((float) (-1)) * (*n)->son->value; + free_ExpNode( (*n)->son ); + (*n)->son = NULL; + break; + case NUMBER: + break; + case FHEAD: + if ( !(*n)->fluent ) { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + break; + } + f = (*n)->fluent->function; + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] == ENCODE_VAR( var ) ) { + (*n)->fluent->args[j] = constant; + } + } + for ( j = 0; j < gf_arity[f]; j++ ) { + if ( (*n)->fluent->args[j] < 0 ) { + break; + } + } + if ( j < gf_arity[f] ) { + break; + } + /* we handle only the case where the fluent is fully instantiated, + * static, and in the initial state. + */ + if ( gis_changed[f] ) break; + for ( j = 0; j < gnum_initial_function[f]; j++ ) { + for ( k = 0; k < gf_arity[f]; k++ ) { + if ( ginitial_function[f][j].fluent.args[k] != + (*n)->fluent->args[k] ) break; + } + if ( k < gf_arity[f] ) continue; + (*n)->connective = NUMBER; + (*n)->value = ginitial_function[f][j].value; + break; + } + break; + default: + printf("\n\nreplace var with const in expnode: wrong specifier %d", + (*n)->connective); + exit( 1 ); + } + +} + + + +WffNode *copy_Wff( WffNode *w ) + +{ + + WffNode *tmp, *tmp2, *i; + int j; + + tmp = new_WffNode( w->connective ); + + switch ( w->connective ) { + case ALL: + case EX: + tmp->var = w->var; + tmp->var_type = w->var_type; + tmp->son = copy_Wff( w->son ); + break; + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + tmp2 = copy_Wff( i ); + if ( tmp->sons ) { + tmp->sons->prev = tmp2; + } + tmp2->next = tmp->sons; + tmp->sons = tmp2; + } + break; + case NOT: + tmp->son = copy_Wff( w->son ); + break; + case ATOM: + tmp->fact = new_Fact(); + tmp->fact->predicate = w->fact->predicate; + for ( j = 0; j < garity[w->fact->predicate]; j++ ) { + tmp->fact->args[j] = w->fact->args[j]; + } + tmp->visited = w->visited; + break; + case COMP: + tmp->comp = w->comp; + tmp->lh = copy_Exp( w->lh ); + tmp->rh = copy_Exp( w->rh ); + break; + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: copy, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + return tmp; + +} + + + +ExpNode *copy_Exp( ExpNode *n ) + +{ + + ExpNode *tmp; + int i; + + tmp = new_ExpNode( n->connective ); + + switch ( n->connective ) { + case AD: + case SU: + case MU: + case DI: + tmp->leftson = copy_Exp( n->leftson ); + tmp->rightson = copy_Exp( n->rightson ); + break; + case MINUS: + tmp->son = copy_Exp( n->son ); + break; + case NUMBER: + tmp->value = n->value; + break; + case FHEAD: + if ( n->fluent ) { + tmp->fluent = new_Fluent(); + tmp->fluent->function = n->fluent->function; + for ( i = 0; i < gf_arity[tmp->fluent->function]; i++ ) { + tmp->fluent->args[i] = n->fluent->args[i]; + } + } else { + /* in the case that this is called from ahead, where fluents + * have been replaced with their identifiers + */ + tmp->fl = n->fl; + } + break; + default: + printf("\n\ncopy expnode: wrong specifier %d", + n->connective); + exit( 1 ); + } + + return tmp; + +} + + + +Bool possibly_positive( Fact *f ) + +{ + + int i; + + if ( gis_added[f->predicate] ) { + return TRUE; + } + + for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { + if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { + return TRUE; + } + } + + return FALSE; + +} + + + +Bool possibly_negative( Fact *f ) + +{ + + int i; + + if ( gis_deleted[f->predicate] ) { + return TRUE; + } + + for ( i = 0; i < garity[f->predicate]; i++ ) { + if ( f->args[i] < 0 ) { + return TRUE; + } + } + + for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { + if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { + return FALSE; + } + } + + return TRUE; + +} + + + +Bool matches( Fact *f1, Fact *f2 ) + +{ + + int i; + + for ( i = 0; i < garity[f1->predicate]; i++ ) { + if ( f1->args[i] >= 0 ) { + if ( f2->args[i] >= 0 && + f1->args[i] != f2->args[i] ) { + return FALSE; + } + } + } + + return TRUE; + +} + + + +void cleanup_wff( WffNode **w ) + +{ + + merge_ANDs_and_ORs_in_wff( w ); + detect_tautologies_in_wff( w ); + simplify_wff( w ); + detect_tautologies_in_wff( w ); + merge_ANDs_and_ORs_in_wff( w ); + +} + + + +void detect_tautologies_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + switch ( (*w)->connective ) { + case ALL: + case EX: + detect_tautologies_in_wff( &((*w)->son) ); + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + detect_tautologies_in_wff( &i ); + } + for ( i = (*w)->sons; i && i->next; i = i->next ) { + j = i->next; + while ( j ) { + if ( are_identical_ATOMs( i, j ) ) { + j->prev->next = j->next; + if ( j->next ) { + j->next->prev = j->prev; + } + tmp = j; + j = j->next; + if ( tmp->fact ) { + free( tmp->fact ); + } + free( tmp ); + continue; + } + if ( i->connective == NOT && + are_identical_ATOMs( i->son, j ) ) { + (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; + free_WffNode( (*w)->son ); + (*w)->son = NULL; + return; + } + if ( j->connective == NOT && + are_identical_ATOMs( i, j->son ) ) { + (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; + free_WffNode( (*w)->son ); + (*w)->son = NULL; + return; + } + j = j->next; + } + } + break; + case NOT: + detect_tautologies_in_wff( &((*w)->son) ); + break; + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: tautologies, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ) + +{ + + int i; + + if ( w1->connective != ATOM || + w2->connective != ATOM ) { + return FALSE; + } + + if ( w1->fact->predicate != w2->fact->predicate ) { + return FALSE; + } + + for ( i = 0; i < garity[w1->fact->predicate]; i++ ) { + if ( w1->fact->args[i] != w2->fact->args[i] ) { + return FALSE; + } + } + + return TRUE; + +} + + + +void merge_ANDs_and_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + switch ( (*w)->connective ) { + case ALL: + case EX: + merge_ANDs_and_ORs_in_wff( &((*w)->son) ); + break; + case AND: + case OR: + i = (*w)->sons; + while ( i ) { + merge_ANDs_and_ORs_in_wff( &i ); + if ( i->connective == (*w)->connective ) { + if ( !(i->sons) ) { + if ( i->next ) { + i->next->prev = i->prev; + } + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + for ( j = i->sons; j->next; j = j->next ); + j->next = i->next; + if ( i->next ) { + i->next->prev = j; + } + if ( i->prev ) { + i->prev->next = i->sons; + i->sons->prev = i->prev; + } else { + (*w)->sons = i->sons; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + } + break; + case NOT: + merge_ANDs_and_ORs_in_wff( &((*w)->son) ); + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: merge, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void NOTs_down_in_wff( WffNode **w ) + +{ + + WffNode *tmp1, *tmp2, *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\ntrying to put nots down in quantified formula! debug me\n\n"); + exit( 1 ); + break; + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + NOTs_down_in_wff( &i ); + } + break; + case NOT: + if ( (*w)->son->connective == NOT ) { + (*w)->connective = (*w)->son->son->connective; + (*w)->fact = (*w)->son->son->fact; + (*w)->comp = (*w)->son->son->comp; + (*w)->lh = (*w)->son->son->lh; + (*w)->rh = (*w)->son->son->rh; + tmp1 = (*w)->son; + tmp2 = (*w)->son->son; + (*w)->sons = (*w)->son->son->sons; + (*w)->son = (*w)->son->son->son; + /* don't need to remember (*w)->son->son->next: this is empty because + * otherwise the resp. father, (*w)->son, would have been an + * AND or OR + */ + free( tmp1 ); + free( tmp2 ); + NOTs_down_in_wff( w ); + break; + } + if ( (*w)->son->connective == AND || + (*w)->son->connective == OR ) { + (*w)->connective = ( (*w)->son->connective == AND ) ? OR : AND; + (*w)->sons = (*w)->son->sons; + free( (*w)->son ); + (*w)->son = NULL; + for ( i = (*w)->sons; i; i = i->next ) { + tmp1 = new_WffNode( i->connective ); + tmp1->son = i->son; + tmp1->sons = i->sons; + tmp1->fact = i->fact; + tmp1->comp = i->comp; + tmp1->lh = i->lh; + tmp1->rh = i->rh; + i->connective = NOT; + i->son = tmp1; + i->sons = NULL; + i->fact = NULL; + i->comp = -1; + i->lh = NULL; + i->rh = NULL; + NOTs_down_in_wff( &i ); + } + break; + } + if ( (*w)->son->connective == COMP ) { + if ( (*w)->son->comp != EQ ) { + (*w)->connective = COMP; + (*w)->lh = (*w)->son->lh; + (*w)->rh = (*w)->son->rh; + switch ( (*w)->son->comp ) { + case LE: + (*w)->comp = GEQ; + break; + case LEQ: + (*w)->comp = GE; + break; + case GEQ: + (*w)->comp = LE; + break; + case GE: + (*w)->comp = LEQ; + break; + default: + printf("\n\nillegal comparator not EQ %d in nots down", + (*w)->son->comp); + exit( 1 ); + } + free( (*w)->son ); + (*w)->son = NULL; + } else { + (*w)->connective = OR; + (*w)->sons = (*w)->son; + (*w)->son = NULL; + (*w)->sons->comp = LE; + tmp1 = new_WffNode( COMP ); + tmp1->lh = copy_Exp( (*w)->sons->lh ); + tmp1->rh = copy_Exp( (*w)->sons->rh ); + tmp1->comp = GE; + tmp1->prev = (*w)->sons; + (*w)->sons->next = tmp1; + } + } + break; + case COMP: + case ATOM: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: nots down, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + + +} + + + + + + + + + + + +/**************************************************** + * NEGATIVE PRE- AND EFFECT- CONDITIONS TRANSLATION * + ****************************************************/ + + + + + + + + +int lconsts[MAX_ARITY]; + + + + + + + + +void translate_negative_preconds( void ) + +{ + + int i, j; + Effect *e; + Facts *f; + FluentValues *ff; + + while ( translate_one_negative_cond( ggoal ) ); + + for ( i = 0; i < gnum_operators; i++ ) { + while ( translate_one_negative_cond( goperators[i]->preconds ) ); + + for ( e = goperators[i]->effects; e; e = e->next ) { + while ( translate_one_negative_cond( e->conditions ) ); + } + } + + if ( gcmd_line.display_info == 108 ) { + printf("\n\ndomain with translated negative conds:"); + + printf("\n\noperators are:"); + for ( i = 0; i < gnum_operators; i++ ) { + print_Operator( goperators[i] ); + } + printf("\n\n"); + + printf("\ninitial state is:\n"); + for ( f = ginitial; f; f = f->next ) { + printf("\n"); + print_Fact( f->fact ); + } + printf("\n"); + for ( ff = gf_initial; ff; ff = ff->next ) { + printf("\n"); + print_Fluent( &(ff->fluent) ); + printf(": %f", ff->value); + } + printf("\n\n"); + + printf("\n\nindividual predicates:\n"); + for ( i = 0; i < gnum_predicates; i++ ) { + printf("\n\n%s:", gpredicates[i]); + if ( !gis_added[i] && + !gis_deleted[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { + printf("\n"); + print_Fact( &(ginitial_predicate[i][j]) ); + } + } + printf("\n\nindividual functions:"); + for ( i = 0; i < gnum_functions; i++ ) { + printf("\n\n%s:", gfunctions[i]); + if ( !gis_changed[i] ) { + printf(" --- STATIC"); + } + for ( j = 0; j < gnum_initial_function[i]; j++ ) { + printf("\n"); + print_Fluent( &(ginitial_function[i][j].fluent) ); + printf(": %f", ginitial_function[i][j].value); + } + } + printf("\n\n"); + + printf("\n\ngoal is:\n"); + print_Wff( ggoal, 0 ); + printf("\n\n"); + } + +} + + + +Bool translate_one_negative_cond( WffNode *w ) + +{ + + WffNode *i; + int p, j, k, m; + Effect *e; + Literal *l, *tmp; + + switch ( w->connective ) { + case ALL: + case EX: + printf("\ntranslating NOT in quantified formula! debug me\n\n"); + exit( 1 ); + case AND: + case OR: + for ( i = w->sons; i; i = i->next ) { + if ( translate_one_negative_cond( i ) ) { + return TRUE; + } + } + return FALSE; + case NOT: + if ( w->son->fact->predicate == -1 ) { + return FALSE; + } + break; + case COMP: + case ATOM: + case TRU: + case FAL: + return FALSE; + default: + printf("\nwon't get here: translate one neg cond, non logical %d\n\n", + w->connective); + exit( 1 ); + } + + + if ( gnum_predicates == MAX_PREDICATES ) { + printf("\ntoo many predicates in translation! increase MAX_PREDICATES (currently %d)\n\n", + MAX_PREDICATES); + exit( 1 ); + } + p = w->son->fact->predicate; + /* safety check: we disallow negative conds on derived preds!! + */ + if ( gaxiom_added[p]) { + printf("\nA derived predicate appears negated in the negation normal form of a derivation rule condition, an operator precondition, or the goal."); + printf("\nSorry, this version of FF does not allow any of this. Bailing out.\n\n"); + exit( 1 ); + } else { + printf("\ntranslating negated cond for predicate %s", gpredicates[p]); + } + + gpredicates[gnum_predicates] = new_Token( strlen( gpredicates[p] ) + 5 ); + sprintf( gpredicates[gnum_predicates], "NOT-%s", gpredicates[p] ); + garity[gnum_predicates] = garity[p]; + for ( j = 0; j < garity[p]; j++ ) { + gpredicates_args_type[gnum_predicates][j] = + gpredicates_args_type[p][j]; + } + gis_added[gnum_predicates] = FALSE; + gis_deleted[gnum_predicates] = FALSE; + m = 1; + for ( j = 0; j < garity[gnum_predicates]; j++ ) { + m *= gtype_size[gpredicates_args_type[gnum_predicates][j]]; + } + ginitial_predicate[gnum_predicates] = ( Fact * ) calloc( m, sizeof( Fact ) ); + gnum_predicates++; + + + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, &ggoal ); + + for ( j = 0; j < gnum_operators; j++ ) { + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, + &(goperators[j]->preconds) ); + + for ( e = goperators[j]->effects; e; e = e->next ) { + replace_not_p_with_n_in_wff( p, gnum_predicates - 1, + &(e->conditions) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->fact.predicate != p ) { + continue; + } + tmp = new_Literal(); + if ( l->negated ) { + tmp->negated = FALSE; + gis_added[gnum_predicates - 1] = TRUE; + } else { + tmp->negated = TRUE; + gis_deleted[gnum_predicates - 1] = TRUE; + } + tmp->fact.predicate = gnum_predicates - 1; + for ( k = 0; k < garity[p]; k++ ) { + tmp->fact.args[k] = l->fact.args[k]; + } + if ( l->prev ) { + tmp->prev = l->prev; + tmp->prev->next = tmp; + } else { + e->effects = tmp; + } + tmp->next = l; + l->prev = tmp; + } + } + } + + add_to_initial_state( p, gnum_predicates - 1, 0 ); + + return TRUE; + +} + + + +void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ) + +{ + + WffNode *i; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\nreplacing p with NOT-p in quantified formula! debug me\n\n"); + exit( 1 ); + case AND: + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + replace_not_p_with_n_in_wff( p, n, &i ); + } + break; + case NOT: + if ( (*w)->son->fact->predicate == p ) { + (*w)->connective = ATOM; + (*w)->NOT_p = p; + (*w)->fact = (*w)->son->fact; + (*w)->fact->predicate = n; + free( (*w)->son ); + (*w)->son = NULL; + } + break; + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: replace p with NOT-p, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void add_to_initial_state( int p, int n, int index ) + +{ + + int i, j; + Facts *tmp; + + if ( index == garity[p] ) { + /* see if contrary fact is there in ini + */ + for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { + for ( j = 0; j < garity[p]; j++ ) { + if ( ginitial_predicate[p][i].args[j] != lconsts[j] ) { + break; + } + } + if ( j == garity[p] ) { + break; + } + } + if ( i < gnum_initial_predicate[p] ) { + return; + } + + /* no: add new fact to ini + */ + ginitial_predicate[n][gnum_initial_predicate[n]].predicate = n; + for ( i = 0; i < garity[n]; i++ ) { + ginitial_predicate[n][gnum_initial_predicate[n]].args[i] = lconsts[i]; + } + gnum_initial_predicate[n]++; + + if ( !gis_added[n] && + !gis_deleted[n] ) { + return; + } + + tmp = new_Facts(); + tmp->fact->predicate = n; + for ( i = 0; i < garity[p]; i++ ) { + tmp->fact->args[i] = lconsts[i]; + } + tmp->next = ginitial; + ginitial = tmp; + gnum_initial++; + return; + } + + for ( i = 0; i < gtype_size[gpredicates_args_type[p][index]]; i++ ) { + lconsts[index] = gtype_consts[gpredicates_args_type[p][index]][i]; + add_to_initial_state( p, n, index + 1 ); + } + +} + + + + + + + + + + + +/******************************************************************* + * SPLIT DOMAIN IN PREPARATION FOR SEPARATE INSTANTIATION ROUTINES * + *******************************************************************/ + + + + + + + + + + +void split_domain( void ) + +{ + + int i, j, m, s = 0, mn; + Effect *e; + WffNode *w, *ww, *www; + NormOperator *tmp_op; + Fact *tmp_ft; + + for ( i = 0; i < MAX_TYPES; i++ ) { + gnum_intersected_types[i] = -1; + } + + for ( i = 0; i < gnum_operators; i++ ) { + if ( (m = is_dnf( goperators[i]->preconds )) != -1 ) { + for ( e = goperators[i]->effects; e; e = e->next ) { + if ( is_dnf( e->conditions ) == -1 ) { + break; + } + } + if ( !e ) { + goperators[i]->hard = FALSE; + s += m; + } + } + } + + ghard_operators = ( Operator_pointer * ) calloc( MAX_OPERATORS, sizeof( Operator ) ); + gnum_hard_operators = 0; + geasy_operators = ( NormOperator_pointer * ) calloc( s, sizeof( NormOperator_pointer ) ); + gnum_easy_operators = 0; + + for ( i = 0; i < gnum_operators; i++ ) { + if ( goperators[i]->hard ) { + ghard_operators[gnum_hard_operators++] = goperators[i]; + continue; + } + w = goperators[i]->preconds; + switch ( w->connective ) { + case OR: + for ( ww = w->sons; ww; ww = ww->next ) { + tmp_op = new_NormOperator( goperators[i] ); + if ( ww->connective == AND ) { + m = 0; + mn = 0; + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) m++; + if ( www->connective == COMP ) mn++; + } + tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) { + tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); + tmp_ft->predicate = www->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = www->fact->args[j]; + } + tmp_op->num_preconds++; + } + if ( www->connective == COMP ) { + tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = www->comp; + tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( www->lh ); + tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( www->rh ); + tmp_op->num_numeric_preconds++; + } + } + } else { + if ( ww->connective == ATOM ) { + tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_op->preconds[0]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_op->num_preconds = 1; + } + if ( ww->connective == COMP ) { + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_comp[0] = ww->comp; + tmp_op->numeric_preconds_lh[0] = copy_Exp( ww->lh ); + tmp_op->numeric_preconds_rh[0] = copy_Exp( ww->rh ); + tmp_op->num_numeric_preconds = 1; + } + } + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + } + break; + case AND: + tmp_op = new_NormOperator( goperators[i] ); + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_op->num_preconds++; + } + if ( ww->connective == COMP ) { + tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = ww->comp; + tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( ww->lh ); + tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( ww->rh ); + tmp_op->num_numeric_preconds++; + } + } + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case ATOM: + tmp_op = new_NormOperator( goperators[i] ); + tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_op->preconds[0]); + tmp_ft->predicate = w->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = w->fact->args[j]; + } + tmp_op->num_preconds = 1; + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case COMP: + tmp_op = new_NormOperator( goperators[i] ); + tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_op->numeric_preconds_comp[0] = w->comp; + tmp_op->numeric_preconds_lh[0] = copy_Exp( w->lh ); + tmp_op->numeric_preconds_rh[0] = copy_Exp( w->rh ); + tmp_op->num_numeric_preconds = 1; + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case TRU: + tmp_op = new_NormOperator( goperators[i] ); + make_normal_effects( &tmp_op, goperators[i] ); + geasy_operators[gnum_easy_operators++] = tmp_op; + break; + case FAL: + break; + default: + printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); + exit( 1 ); + } + } + + if ( gcmd_line.display_info == 109 ) { + printf("\n\nsplitted operators are:\n"); + + printf("\nEASY:\n"); + for ( i = 0; i < gnum_easy_operators; i++ ) { + print_NormOperator( geasy_operators[i] ); + } + + printf("\n\n\nHARD:\n"); + for ( i = 0; i < gnum_hard_operators; i++ ) { + print_Operator( ghard_operators[i] ); + } + } + +} + + + +int is_dnf( WffNode *w ) + +{ + + WffNode *i; + int s = 0; + + switch ( w->connective ) { + case ALL: + case EX: + printf("\nchecking quantifier for dnf. debug me\n\n"); + exit( 1 ); + case AND: + for ( i = w->sons; i; i = i->next ) { + if ( i->connective == ATOM || + i->connective == COMP ) { + continue; + } + return -1; + } + return 1; + case OR: + for ( i = w->sons; i; i = i->next ) { + s++; + if ( i->connective == ATOM || + i->connective == COMP || + ( i->connective == AND && + is_dnf( i ) != -1 ) ) { + continue; + } + return -1; + } + return s; + case NOT: + printf("\n\nNOT in presimplified formula. debug me\n\n"); + exit( 1 ); + case ATOM: + case COMP: + case TRU: + case FAL: + return 1; + default: + printf("\nwon't get here: check dnf, conn %d\n\n", + w->connective); + exit( 1 ); + } + +} + + + +void make_normal_effects( NormOperator **nop, Operator *op ) + +{ + + Effect *e; + NormEffect *tmp_ef; + WffNode *w, *ww, *www; + int j, m, ma, md, mn; + Literal *l; + NumericEffect *ll; + Fact *tmp_ft; + Fluent *tmp_fl; + + for ( e = op->effects; e; e = e->next ) { + w = e->conditions; + switch ( w->connective ) { + case OR: + for ( ww = w->sons; ww; ww = ww->next ) { + tmp_ef = new_NormEffect1( e ); + if ( ww->connective == AND ) { + m = 0; + mn = 0; + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) m++; + if ( www->connective == COMP ) mn++; + } + tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( www = ww->sons; www; www = www->next ) { + if ( www->connective == ATOM ) { + tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); + tmp_ft->predicate = www->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = www->fact->args[j]; + } + tmp_ef->num_conditions++; + } + if ( www->connective == COMP ) { + tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = www->comp; + tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( www->lh ); + tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( www->rh ); + tmp_ef->num_numeric_conditions++; + } + } + } else { + if ( ww->connective == ATOM ) { + tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_ef->conditions[0]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_ef->num_conditions = 1; + } + if ( ww->connective == COMP ) { + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_comp[0] = ww->comp; + tmp_ef->numeric_conditions_lh[0] = copy_Exp( ww->lh ); + tmp_ef->numeric_conditions_rh[0] = copy_Exp( ww->rh ); + tmp_ef->num_numeric_conditions = 1; + } + } + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + } + break; + case AND: + tmp_ef = new_NormEffect1( e ); + m = 0; + mn = 0; + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) m++; + if ( ww->connective == COMP ) mn++; + } + tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); + for ( ww = w->sons; ww; ww = ww->next ) { + if ( ww->connective == ATOM ) { + tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); + tmp_ft->predicate = ww->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = ww->fact->args[j]; + } + tmp_ef->num_conditions++; + } + if ( ww->connective == COMP ) { + tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = ww->comp; + tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->lh ); + tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->rh ); + tmp_ef->num_numeric_conditions++; + } + } + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case ATOM: + tmp_ef = new_NormEffect1( e ); + tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); + tmp_ft = &(tmp_ef->conditions[0]); + tmp_ft->predicate = w->fact->predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = w->fact->args[j]; + } + tmp_ef->num_conditions = 1; + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case COMP: + tmp_ef = new_NormEffect1( e ); + tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); + tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); + tmp_ef->numeric_conditions_comp[0] = w->comp; + tmp_ef->numeric_conditions_lh[0] = copy_Exp( w->lh ); + tmp_ef->numeric_conditions_rh[0] = copy_Exp( w->rh ); + tmp_ef->num_numeric_conditions = 1; + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case TRU: + tmp_ef = new_NormEffect1( e ); + ma = 0; md = 0; + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { md++; } else { ma++; } + } + tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); + tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); + } else { + tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); + } + tmp_ft->predicate = l->fact.predicate; + for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { + tmp_ft->args[j] = l->fact.args[j]; + } + } + ma = 0; + for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; + tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); + tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); + tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); + for ( ll = e->numeric_effects; ll; ll = ll->next ) { + tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; + tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); + tmp_fl->function = ll->fluent.function; + for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { + tmp_fl->args[j] = ll->fluent.args[j]; + } + tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); + tmp_ef->num_numeric_effects++; + } + tmp_ef->next = (*nop)->effects; + if ( (*nop)->effects ) { + (*nop)->effects->prev = tmp_ef; + } + (*nop)->effects = tmp_ef; + break; + case FAL: + break; + default: + printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); + exit( 1 ); + } + } + +} + + + + + + + + + +/************************************************************************* + * ADDITIONAL: FULL DNF, only compute on fully instantiated formulae!!!! * + *************************************************************************/ + + + + + + + + + + +/* dnf + */ + +WffNode *lhitting_sets; +WffNode_pointer *lset; +int lmax_set; + + + + + + +void dnf( WffNode **w ) + +{ + + static Bool first_call = TRUE; + + if ( first_call ) { + lset = ( WffNode_pointer * ) + calloc( MAX_HITTING_SET_DEFAULT, sizeof( WffNode_pointer ) ); + lmax_set = MAX_HITTING_SET_DEFAULT; + first_call = FALSE; + } + + ANDs_below_ORs_in_wff( w ); + +} + + + +void ANDs_below_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *tmp; + int c, m; + + switch ( (*w)->connective ) { + case ALL: + case EX: + printf("\ntrying to put quantified formula into DNF! (ands down) debug me\n\n"); + exit( 1 ); + break; + case AND: + c = 0; + m = 0; + for ( i = (*w)->sons; i; i = i->next ) { + ANDs_below_ORs_in_wff( &i ); + if ( i->connective == OR ) { + c++; + } + m++; + } + if ( c == 0 ) { + /* no ORs as sons --> all sons are literals. OK + */ + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + } + /* crucial part: AND node, sons can be merged OR's. + * (i.e., sons are either literals or disjunctions of + * conjunctions of literals) + * create OR node with one hitting set of w's sons for + * each disjunct + */ + lhitting_sets = NULL; + if ( m > lmax_set ) { + free( lset ); + lset = ( WffNode_pointer * ) calloc( m, sizeof( WffNode_pointer ) ); + lmax_set = m; + } + collect_hitting_sets( (*w)->sons, 0 ); + (*w)->connective = OR; + tmp = (*w)->sons; + (*w)->sons = lhitting_sets; + if ( 0 ) free_WffNode( tmp ); + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + case OR: + for ( i = (*w)->sons; i; i = i->next ) { + ANDs_below_ORs_in_wff( &i ); + } + merge_next_step_ANDs_and_ORs_in_wff( w ); + break; + case NOT: + case ATOM: + case COMP: + case TRU: + case FAL: + break; + default: + printf("\nwon't get here: ands down, non logical %d\n\n", + (*w)->connective); + exit( 1 ); + } + +} + + + +void collect_hitting_sets( WffNode *ORlist, int index ) + +{ + + WffNode *tmp1, *tmp2, *j; + int i; + + if ( !ORlist ) { + tmp1 = new_WffNode( AND ); + for ( i = 0; i < index; i++ ) { + tmp2 = copy_Wff( lset[i] ); + tmp2->next = tmp1->sons; + if ( tmp1->sons ) { + tmp1->sons->prev = tmp2; + } + tmp1->sons = tmp2; + } + tmp1->next = lhitting_sets; + if ( lhitting_sets ) { + lhitting_sets->prev = tmp1; + } + lhitting_sets = tmp1; + return; + } + + if ( ORlist->connective != OR ) { + lset[index] = ORlist; + collect_hitting_sets( ORlist->next, index + 1 ); + return; + } + + for ( j = ORlist->sons; j; j = j->next ) { + lset[index] = j; + collect_hitting_sets( ORlist->next, index + 1 ); + } + +} + + + +void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ) + +{ + + WffNode *i, *j, *tmp; + + i = (*w)->sons; + while ( i ) { + if ( i->connective == (*w)->connective ) { + if ( !(i->sons) ) { + if ( i->next ) { + i->next->prev = i->prev; + } + if ( i->prev ) { + i->prev->next = i->next; + } else { + (*w)->sons = i->next; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + for ( j = i->sons; j->next; j = j->next ); + j->next = i->next; + if ( i->next ) { + i->next->prev = j; + } + if ( i->prev ) { + i->prev->next = i->sons; + i->sons->prev = i->prev; + } else { + (*w)->sons = i->sons; + } + tmp = i; + i = i->next; + free( tmp ); + continue; + } + i = i->next; + } + +} + + + +/* switch ( (*w)->connective ) { */ +/* case ALL: */ +/* case EX: */ +/* break; */ +/* case AND: */ +/* case OR: */ +/* for ( i = (*w)->sons; i; i = i->next ) { */ +/* } */ +/* break; */ +/* case NOT: */ +/* break; */ +/* case ATOM: */ +/* case TRU: */ +/* case FAL: */ +/* break; */ +/* default: */ +/* printf("\nwon't get here: remove var, non logical %d\n\n", */ +/* (*w)->connective); */ +/* exit( 1 ); */ +/* } */ + + + + + + + + + diff --git a/models/main_models/rt1/gen/ff_planner/inst_pre.h b/models/main_models/rt1/gen/ff_planner/inst_pre.h new file mode 100644 index 000000000..de859b385 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/inst_pre.h @@ -0,0 +1,123 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: inst_pre.h + * Description: headers for instantiating operators, preprocessing part. + * - transform domain into integers + * - inertia preprocessing: + * - collect inertia info + * - split initial state in special arrays + * - Wff normalization: + * - simplification + * - quantifier expansion + * - NOT s down + * - negative preconditions translation + * - split operators into easy and hard to instantiate ones + * + * - full DNF functions, only feasible for fully instantiated + * formulae + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + + + + + + +#ifndef _INST_PRE_H +#define _INST_PRE_H + + + +void encode_domain_in_integers( void ); +void collect_all_strings( void ); +void create_member_nrs( void ); +int position_in_types_table( char *str ); +int position_in_constants_table( char *str ); +int position_in_predicates_table( char *str ); +int position_in_functions_table( char *str ); +void create_integer_representation( void ); +void make_Fact( Fact *f, PlNode *n, int num_vars ); +void make_Fluent( Fluent *f, TokenList *atom, int num_vars ); +Bool is_subtype( int t1, int t2 ); +WffNode *make_Wff( PlNode *p, int num_vars ); +ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ); +Effect *make_effect( PlNode *p, int num_vars ); + + + +void do_inertia_preprocessing_step_1( void ); +void collect_inertia_information( void ); +void split_initial_state( void ); + + + +void normalize_all_wffs( void ); +void remove_unused_vars_in_wff( WffNode **w ); +void decrement_inferior_vars( int var, WffNode *w ); +void decrement_inferior_vars_in_exp( int var, ExpNode *n ); +Bool var_used_in_wff( int code_var, WffNode *w ); +Bool var_used_in_exp( int code_var, ExpNode *n ); +void simplify_wff( WffNode **w ); +void simplify_exp( ExpNode **n ); +void expand_quantifiers_in_wff( WffNode **w, int var, int constant ); +void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ); +WffNode *copy_Wff( WffNode *w ); +ExpNode *copy_Exp( ExpNode *n ); +Bool possibly_positive( Fact *f ); +Bool possibly_negative( Fact *f ); +Bool matches( Fact *f1, Fact *f2 ); +void cleanup_wff( WffNode **w ); +void detect_tautologies_in_wff( WffNode **w ); +Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ); +void merge_ANDs_and_ORs_in_wff( WffNode **w ); +void NOTs_down_in_wff( WffNode **w ); + + + +void translate_negative_preconds( void ); +Bool translate_one_negative_cond( WffNode *w ); +void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ); +void add_to_initial_state( int p, int n, int index ); + + + +void split_domain( void ); +int is_dnf( WffNode *w ); +void make_normal_effects( NormOperator **nop, Operator *op ); + + + +void dnf( WffNode **w ); +void ANDs_below_ORs_in_wff( WffNode **w ); +void collect_hitting_sets( WffNode *ORlist, int index ); +void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ); + + + +#endif /* _INST_PRE_H */ diff --git a/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l b/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l new file mode 100644 index 000000000..850bbb407 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/lex-fct_pddl.l @@ -0,0 +1,139 @@ +%{ +#include "ff.h" +#include "parse.h" + + /* default yywrap function - always treat EOF as an EOF */ +int fct_pddlwrap() { return 1; }; + +int gbracket_count = 0; + +%} + +a [Aa] +b [Bb] +c [Cc] +d [Dd] +e [Ee] +f [Ff] +g [Gg] +h [Hh] +i [Ii] +j [Jj] +k [Kk] +l [Ll] +m [Mm] +n [Nn] +o [Oo] +p [Pp] +q [Qq] +r [Rr] +s [Ss] +t [Tt] +u [Uu] +v [Vv] +w [Ww] +x [Xx] +y [Yy] +z [Zz] + +%x COMMENT OVERREAD + +%% + +"(" { return(OPEN_PAREN); } + +")" { return(CLOSE_PAREN); } + +\([ \t]*{i}{n}"-"{p}{a}{c}{k}{a}{g}{e} { gbracket_count = 1; + BEGIN OVERREAD; } + +\([ \t]*":"{l}{e}{n}{g}{t}{h} { gbracket_count = 1; + BEGIN OVERREAD; } + +\([ \t]*":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { gbracket_count = 1; + BEGIN OVERREAD; } + +{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } + +{p}{r}{o}{b}{l}{e}{m} { return(PROBLEM_TOK); } + +{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(SITUATION_TOK); } + +":"{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(BSITUATION_TOK); } + +":"{o}{b}{j}{e}{c}{t}{s} { return(OBJECTS_TOK); } + +":"{g}{o}{a}{l} { return(GOAL_TOK); } + +":"{m}{e}{t}{r}{i}{c} { return(METRIC_TOK); } + +":"{i}{n}{i}{t} { return(INIT_TOK); } + +":"{d}{o}{m}{a}{i}{n} { return(BDOMAIN_TOK); } + +\([ \t]*":"{e}{x}{t}{e}{n}{d}{s} { gbracket_count = 1; + BEGIN OVERREAD; } + +{a}{n}{d} { return(AND_TOK); } + +{i}{m}{p}{l}{y} { return(IMPLY_TOK); } + +{o}{r} { return(OR_TOK); } + +{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } + +{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } + +{n}{o}{t} { return(NOT_TOK); } + +"<" { return(LE_TOK); } + +"<=" { return(LEQ_TOK); } + +"=" { return(EQ_TOK); } + +">=" { return(GEQ_TOK); } + +">" { return(GE_TOK); } + +"-" { return(MINUS_TOK); } + +"+" { return(AD_TOK); } + +"*" { return(MU_TOK); } + +"/" { return(DI_TOK); } + +:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase( yytext ); + strcpy(yylval.string, yytext ); return(NAME); } + +\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* {strupcase( yytext ); + strcpy(yylval.string, yytext); return(VARIABLE); } + +"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} + +"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } + +\;(.)*\n { lineno++; } +\;(.)* { /* this will hold only in files that end with + a comment but no linefeed */ } + +(.^\")*\n { lineno++; } ; + +\" { BEGIN COMMENT;} + +\" { BEGIN INITIAL;} + +\n { lineno++; } + +(.^\(\))*\n { lineno++; } + +[^\(\)] { } + +\( { gbracket_count++; } + +\) { gbracket_count--; + if (!gbracket_count) BEGIN INITIAL; } + +. {} +%% diff --git a/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l b/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l new file mode 100644 index 000000000..0e9d8499d --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/lex-ops_pddl.l @@ -0,0 +1,151 @@ +%{ +#include "ff.h" +#include "parse.h" + +/* default yywrap function - always treat EOF as an EOF */ +int ops_pddlwrap() { return 1; }; + +%} + +a [Aa] +b [Bb] +c [Cc] +d [Dd] +e [Ee] +f [Ff] +g [Gg] +h [Hh] +i [Ii] +j [Jj] +k [Kk] +l [Ll] +m [Mm] +n [Nn] +o [Oo] +p [Pp] +q [Qq] +r [Rr] +s [Ss] +t [Tt] +u [Uu] +v [Vv] +w [Ww] +x [Xx] +y [Yy] +z [Zz] + +%x COMMENT OVERREAD + +%% + +"(" { return(OPEN_PAREN); } + +")" { return(CLOSE_PAREN); } + +{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } + +{d}{o}{m}{a}{i}{n} { return(DOMAIN_TOK); } + +":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { return(REQUIREMENTS_TOK); } + +":"{t}{y}{p}{e}{s} { return(TYPES_TOK); } + +{n}{u}{m}{b}{e}{r} { return(NUMBER_TOK); } + +":"{c}{o}{n}{s}{t}{a}{n}{t}{s} { return(CONSTANTS_TOK); } + +":"{p}{r}{e}{d}{i}{c}{a}{t}{e}{s} { return(PREDICATES_TOK); } + +":"{f}{u}{n}{c}{t}{i}{o}{n}{s} { return(FUNCTIONS_TOK); } + +":"{a}{c}{t}{i}{o}{n} { return(ACTION_TOK); } + +":"{d}{e}{r}{i}{v}{e}{d} { return(AXIOM_TOK); } + +":"{p}{a}{r}{a}{m}{e}{t}{e}{r}{s} { return(PARAMETERS_TOK); } + +":"{v}{a}{r}{s} { return(VARS_TOK); } + +":"{p}{r}{e}{c}{o}{n}{d}{i}{t}{i}{o}{n} { return(PRECONDITION_TOK); } + +":"{e}{f}{f}{e}{c}{t} { return(EFFECT_TOK); } + +":"{i}{m}{p}{l}{i}{e}{s} { return(IMPLIES_TOK); } + +{a}{n}{d} { return(AND_TOK); } + +{n}{o}{t} { return(NOT_TOK); } + +{w}{h}{e}{n} { return(WHEN_TOK); } + +{i}{m}{p}{l}{y} { return(IMPLY_TOK); } + +{o}{r} { return(OR_TOK); } + +{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } + +{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } + +"<" { return(LE_TOK); } + +"<=" { return(LEQ_TOK); } + +"=" { return(EQ_TOK); } + +">=" { return(GEQ_TOK); } + +">" { return(GE_TOK); } + +"-" { return(MINUS_TOK); } + +"+" { return(AD_TOK); } + +"*" { return(MU_TOK); } + +"/" { return(DI_TOK); } + +{a}{s}{s}{i}{g}{n} { return(ASSIGN_TOK); } + +{s}{c}{a}{l}{e}"-"{u}{p} { return(SCALE_UP_TOK); } + +{s}{c}{a}{l}{e}"-"{d}{o}{w}{n} { return(SCALE_DOWN_TOK); } + +{i}{n}{c}{r}{e}{a}{s}{e} { return(INCREASE_TOK); } + +{d}{e}{c}{r}{e}{a}{s}{e} { return(DECREASE_TOK); } + + +:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase(yytext); strcpy(yylval.string, yytext); + return(NAME); } + +\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* { strupcase(yytext); strcpy(yylval.string, yytext); + return(VARIABLE); } + +"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} + + +"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } + +\;(.)*\n { lineno++; } +\;(.)* { /* this will hold only in files that end with + a comment but no linefeed */ } + +(.^\")*\n { lineno++; } ; + +\" { BEGIN COMMENT;} + +\" { BEGIN INITIAL;} + +\n { lineno++; } + +(.^\(\))*\n { lineno++; } + +[^\(\)] { } + +\( { BEGIN OVERREAD; gbracket_count++; } + +\) { BEGIN OVERREAD; gbracket_count--; + if (!gbracket_count) BEGIN INITIAL; } + +. {} +%% diff --git a/models/main_models/rt1/gen/ff_planner/main.c b/models/main_models/rt1/gen/ff_planner/main.c new file mode 100644 index 000000000..bc3a795b5 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/main.c @@ -0,0 +1,1230 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: main.c + * Description: The main routine for the Metric-FastForward Planner. + * Modified July 2011 to allow more command-line search + * confiogurations, including improved cost-minimization + * + * Author: original version Joerg Hoffmann 2001/2002 + * modified version Joerg Hoffmann 2012 + * + *********************************************************************/ + + + + + + + + +#include "ff.h" + +#include "memory.h" +#include "output.h" + +#include "parse.h" + +#include "expressions.h" + +#include "inst_pre.h" +#include "inst_easy.h" +#include "inst_hard.h" +#include "inst_final.h" + +#include "relax.h" +#include "search.h" + + + + + + + + + + + +/* + * ----------------------------- GLOBAL VARIABLES ---------------------------- + */ + + + + + + + + + + + + +/******************* + * GENERAL HELPERS * + *******************/ + + + + + + + + +/* used to time the different stages of the planner + */ +float gtempl_time = 0, greach_time = 0, grelev_time = 0, gconn_time = 0; +float gLNF_time = 0, gsearch_time = 0; + + +/* the command line inputs + */ +struct _command_line gcmd_line; + +/* number of states that got heuristically evaluated + */ +int gevaluated_states = 0; + +/* maximal depth of breadth first search + */ +int gmax_search_depth = 0; + + + + + +/*********** + * PARSING * + ***********/ + + + + + + + +/* used for pddl parsing, flex only allows global variables + */ +int gbracket_count; +char *gproblem_name; + +/* The current input line number + */ +int lineno = 1; + +/* The current input filename + */ +char *gact_filename; + +/* The pddl domain name + */ +char *gdomain_name = NULL; + +/* loaded, uninstantiated operators + */ +PlOperator *gloaded_ops = NULL; + +/* stores initials as fact_list + */ +PlNode *gorig_initial_facts = NULL; + +/* not yet preprocessed goal facts + */ +PlNode *gorig_goal_facts = NULL; + +/* axioms as in UCPOP before being changed to ops + */ +PlOperator *gloaded_axioms = NULL; + +/* the types, as defined in the domain file + */ +TypedList *gparse_types = NULL; + +/* the constants, as defined in domain file + */ +TypedList *gparse_constants = NULL; + +/* the predicates and their arg types, as defined in the domain file + */ +TypedListList *gparse_predicates = NULL; + +/* the functions and their arg types, as defined in the domain file + */ +TypedListList *gparse_functions = NULL; + +/* the objects, declared in the problem file + */ +TypedList *gparse_objects = NULL; + +/* the metric + */ +Token gparse_optimization; +ParseExpNode *gparse_metric = NULL; + + +/* connection to instantiation ( except ops, goal, initial ) + */ + +/* all typed objects + */ +FactList *gorig_constant_list = NULL; + +/* the predicates and their types + */ +FactList *gpredicates_and_types = NULL; + +/* the functions and their types + */ +FactList *gfunctions_and_types = NULL; + + + + + + + + + + + + +/***************** + * INSTANTIATING * + *****************/ + + + + + + + + + +/* global arrays of constant names, + * type names (with their constants), + * predicate names, + * predicate aritys, + * defined types of predicate args + */ +Token gconstants[MAX_CONSTANTS]; +int gnum_constants = 0; +Token gtype_names[MAX_TYPES]; +int gtype_consts[MAX_TYPES][MAX_TYPE]; +Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; +int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ +int gtype_size[MAX_TYPES]; +int gnum_types = 0; +Token gpredicates[MAX_PREDICATES]; +int garity[MAX_PREDICATES]; +Bool gaxiom_added[MAX_PREDICATES]; +int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; +int gnum_predicates = 0; +Token gfunctions[MAX_FUNCTIONS]; +int gf_arity[MAX_FUNCTIONS]; +int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; +int gnum_functions = 0; + + + + + +/* the domain in integer (Fact) representation + */ +Operator_pointer goperators[MAX_OPERATORS]; +int gnum_operators = 0; +Fact *gfull_initial; +int gnum_full_initial = 0; +FluentValue *gfull_fluents_initial; +int gnum_full_fluents_initial = 0; +WffNode *ggoal = NULL; + +ExpNode *gmetric = NULL; + + + +/* stores inertia - information: is any occurence of the predicate + * added / deleted in the uninstantiated ops ? + */ +Bool gis_added[MAX_PREDICATES]; +Bool gis_deleted[MAX_PREDICATES]; + + +/* for functions we *might* want to say, symmetrically, whether it is + * increased resp. decreased at all. + * + * that is, however, somewhat involved because the right hand + * sides can be arbirtray expressions, so we have no guarantee + * that increasing really does adds to a functions value... + * + * thus (for the time being), we settle for "is the function changed at all?" + */ +Bool gis_changed[MAX_FUNCTIONS]; + + + +/* splitted initial state: + * initial non static facts, + * initial static facts, divided into predicates + * (will be two dimensional array, allocated directly before need) + */ +Facts *ginitial = NULL; +int gnum_initial = 0; +Fact **ginitial_predicate; +int *gnum_initial_predicate; + +/* same thing for functions + */ +FluentValues *gf_initial; +int gnum_f_initial = 0; +FluentValue **ginitial_function; +int *gnum_initial_function; + + + +/* the type numbers corresponding to any unary inertia + */ +int gtype_to_predicate[MAX_PREDICATES]; +int gpredicate_to_type[MAX_TYPES]; + +/* (ordered) numbers of types that new type is intersection of + */ +TypeArray gintersected_types[MAX_TYPES]; +int gnum_intersected_types[MAX_TYPES]; + + + +/* splitted domain: hard n easy ops + */ +Operator_pointer *ghard_operators; +int gnum_hard_operators; +NormOperator_pointer *geasy_operators; +int gnum_easy_operators; + + + +/* so called Templates for easy ops: possible inertia constrained + * instantiation constants + */ +EasyTemplate *geasy_templates; +int gnum_easy_templates; + + + +/* first step for hard ops: create mixed operators, with conjunctive + * precondition and arbitrary effects + */ +MixedOperator *ghard_mixed_operators; +int gnum_hard_mixed_operators; + + + +/* hard ''templates'' : pseudo actions + */ +PseudoAction_pointer *ghard_templates; +int gnum_hard_templates; + + + +/* store the final "relevant facts" + */ +Fact grelevant_facts[MAX_RELEVANT_FACTS]; +int gnum_relevant_facts = 0; +int gnum_pp_facts = 0; +/* store the "relevant fluents" + */ +Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; +int gnum_relevant_fluents = 0; +Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; +/* this is NULL for normal, and the LNF for + * artificial fluents. + */ +LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; + + + +/* the final actions and problem representation + */ +Action *gactions = NULL; +int gnum_actions; +State ginitial_state; +int *glogic_goal = NULL; +int gnum_logic_goal = 0; +Comparator *gnumeric_goal_comp = NULL; +ExpNode_pointer *gnumeric_goal_lh = NULL, *gnumeric_goal_rh = NULL; +int gnum_numeric_goal = 0; + +/* direct numeric goal access + */ +Comparator *gnumeric_goal_direct_comp; +float *gnumeric_goal_direct_c; + + + +/* to avoid memory leaks; too complicated to identify + * the exact state of the action to throw away (during construction), + * memory gain not worth the implementation effort. + */ +Action *gtrash_actions = NULL; + + + +/* additional lnf step between finalized inst and + * conn graph + */ +Comparator *glnf_goal_comp = NULL; +LnfExpNode_pointer *glnf_goal_lh = NULL; +float *glnf_goal_rh = NULL; +int gnum_lnf_goal = 0; + +LnfExpNode glnf_metric; +Bool goptimization_established = FALSE; + + + + + + + +/********************** + * CONNECTIVITY GRAPH * + **********************/ + + + + + + + +/* one ops (actions) array ... + */ +OpConn *gop_conn; +int gnum_op_conn; + + + +/* one effects array ... + */ +EfConn *gef_conn; +int gnum_ef_conn; + + + +/* one facts array. + */ +FtConn *gft_conn; +int gnum_ft_conn; + + + +/* and: one fluents array. + */ +FlConn *gfl_conn; +int gnum_fl_conn; +int gnum_real_fl_conn;/* number of non-artificial ones */ + + + +/* final goal is also transformed one more step. + */ +int *gflogic_goal = NULL; +int gnum_flogic_goal = 0; +Comparator *gfnumeric_goal_comp = NULL; +int *gfnumeric_goal_fl = NULL; +float *gfnumeric_goal_c = NULL; +int gnum_fnumeric_goal = 0; + +/* direct access (by relevant fluents) + */ +Comparator *gfnumeric_goal_direct_comp = NULL; +float *gfnumeric_goal_direct_c = NULL; + + + + + + + + + + + +/******************* + * SEARCHING NEEDS * + *******************/ + + + + + + + + + + + +/* applicable actions + */ +int *gA;/* non-axioms */ +int gnum_A; +int *gA_axioms; /* axioms */ +int gnum_A_axioms; + + + +/* communication from extract 1.P. to search engine: + * 1P action choice + */ +int *gH; +int gnum_H; +/* added cost of relaxed plan + */ +float gh_cost; +/* hmax value + */ +float ghmax; + + + +/* to store plan + */ +int gplan_ops[MAX_PLAN_LENGTH]; +int gnum_plan_ops = 0; + + + +/* stores the states that the current plan goes through + * ( for knowing where new agenda entry starts from ) + */ +State gplan_states[MAX_PLAN_LENGTH + 1]; + + + + + + + +/* dirty: multiplic. of total-time in final metric LNF + */ +float gtt; + + + + + + + +/* the mneed structures + */ +Bool **gassign_influence; +Bool **gTassign_influence; + + + +/* the real var input to the mneed computation. + */ +Bool *gmneed_start_D; +float *gmneed_start_V; + + + +/* does this contain conditional effects? + * (if it does then the state hashing has to be made more + * cautiously) + */ +Bool gconditional_effects; + + + +/* easier to question: are we optimizing or no? + */ +Bool gcost_minimizing; + + + +/* stores current A* weight: this is initially given by user, + * but changes during anytime search. + */ +float gw; +/* this is the minimum weight, ie we'll stop once the weight update + * does/would yield a value <= this. + * if no such minim weight is given, this will be -1 + */ +float gmin_w = -1; + + + +/* this one says whether or not we are actually using + * cost-minimizing rplans. + * this will be the case by default if we're running cost- + * minimizing searches. it can be switched off by a flag; + * it is automatically switched off in case there are + * numeric preconditions/goals: for this case, + * cost-minimizing rplans are not implemented (a numeric prec + * may cause an action to come in "later" on in the RPG although + * its logical pres are easy. in that case, any new effects will + * have a smaller RPGcost value than facts we already have waiting. + * in other words, the "Dijsktra" nature breaks. + * + * ... I suppose there may be a generic solution to this that + * can handle numeric precs/goals. Doesn't seem important enough + * to bother. + */ +Bool gcost_rplans; + + + + + + + + + + + + + +/* + * ----------------------------- HEADERS FOR PARSING ---------------------------- + * ( fns defined in the scan-* files ) + */ + + + + + + + +void get_fct_file_name( char *filename ); +void load_ops_file( char *filename ); +void load_fct_file( char *filename ); + + + + + + + + + + + +/* + * ----------------------------- MAIN ROUTINE ---------------------------- + */ + + + + + +struct tms lstart, lend; + + + + + +int main( int argc, char *argv[] ) + +{ + + /* resulting name for ops file + */ + char ops_file[MAX_LENGTH] = ""; + /* same for fct file + */ + char fct_file[MAX_LENGTH] = ""; + + struct tms start, end; + + Bool found_plan; + int i; + float cost; + + Bool prev_gcost_rplans; + + + + times ( &lstart ); + + /* command line treatment + */ + gcmd_line.display_info = 1; + gcmd_line.debug = 0; + + /* search settings + */ + gcmd_line.search_config = 5; + gcmd_line.cost_rplans = TRUE; + gcmd_line.w = 5; + gcmd_line.cost_bound = -1; + + memset(gcmd_line.ops_file_name, 0, MAX_LENGTH); + memset(gcmd_line.fct_file_name, 0, MAX_LENGTH); + memset(gcmd_line.path, 0, MAX_LENGTH); + + if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { + ff_usage(); + exit( 1 ); + } + if ( !process_command_line( argc, argv ) ) { + ff_usage(); + exit( 1 ); + } + + + /* make file names + */ + + /* one input name missing + */ + if ( !gcmd_line.ops_file_name || + !gcmd_line.fct_file_name ) { + fprintf(stdout, "\nff: two input files needed\n\n"); + ff_usage(); + exit( 1 ); + } + /* add path info, complete file names will be stored in + * ops_file and fct_file + */ + sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); + sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); + + + /* parse the input files + */ + + /* start parse & instantiation timing + */ + times( &start ); + /* domain file (ops) + */ + if ( gcmd_line.display_info >= 1 ) { + printf("\nff: parsing domain file"); + } + /* it is important for the pddl language to define the domain before + * reading the problem + */ + load_ops_file( ops_file ); + /* problem file (facts) + */ + if ( gcmd_line.display_info >= 1 ) { + printf(" ... done.\nff: parsing problem file"); + } + load_fct_file( fct_file ); + if ( gcmd_line.display_info >= 1 ) { + printf(" ... done.\n\n"); + } + + /* This is needed to get all types. + */ + build_orig_constant_list(); + + /* last step of parsing: see if it's an ADL domain! + */ + if ( !make_adl_domain() ) { + printf("\nff: this is not an ADL problem!"); + printf("\n can't be handled by this version.\n\n"); + exit( 1 ); + } + + + /* now instantiate operators; + */ + + + /************************** + * first do PREPROCESSING * + **************************/ + + /* start by collecting all strings and thereby encoding + * the domain in integers. + */ + encode_domain_in_integers(); + + /* inertia preprocessing, first step: + * - collect inertia information + * - split initial state into + * - arrays for individual predicates + * - arrays for all static relations + * - array containing non - static relations + */ + do_inertia_preprocessing_step_1(); + + /* normalize all PL1 formulae in domain description: + * (goal, preconds and effect conditions) + * - simplify formula + * - expand quantifiers + * - NOTs down + */ + normalize_all_wffs(); + + /* translate negative preconds: introduce symmetric new predicate + * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) + */ + translate_negative_preconds(); + + /* split domain in easy (disjunction of conjunctive preconds) + * and hard (non DNF preconds) part, to apply + * different instantiation algorithms + */ + split_domain(); + + /*********************************************** + * PREPROCESSING FINISHED * + * * + * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * + ***********************************************/ + + build_easy_action_templates(); + build_hard_action_templates(); + + times( &end ); + TIME( gtempl_time ); + + times( &start ); + + /* perform reachability analysis in terms of relaxed + * fixpoint + */ + perform_reachability_analysis(); + + times( &end ); + TIME( greach_time ); + + times( &start ); + + /* collect the relevant facts and build final domain + * and problem representations. + */ + collect_relevant_facts_and_fluents(); + + times( &end ); + TIME( grelev_time ); + + + /* now transform problem to additive normal form, + * if possible + */ + times( &start ); + if ( !transform_to_LNF() ) { + printf("\n\nThis is not a linear task!\n\n"); + exit( 1 ); + } + times( &end ); + TIME( gLNF_time ); + + times( &start ); + + /* now build globally accessable connectivity graph + */ + build_connectivity_graph(); + + /* now check for acyclic := effects (in expressions.c) + */ + check_assigncycles(); + /* set the relevanc info (in expressions.c) + */ + determine_fl_relevance(); + + times( &end ); + TIME( gconn_time ); + + /*********************************************************** + * we are finally through with preprocessing and can worry * + * bout finding a plan instead. * + ***********************************************************/ + + if ( gcmd_line.display_info ) { + printf("\n\nff: search configuration is "); + switch ( gcmd_line.search_config ) { + case 0: + printf("Enforced Hill-Climbing, if that fails then best-first search.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION"); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 1: + printf("best-first search.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION"); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 2: + printf("best-first search with helpful actions pruning.\nMetric is plan length."); + printf("\nNO COST MINIMIZATION."); + if ( !gcost_rplans ) { + printf(" (and no cost-minimizing relaxed plans)."); + } else { + printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); + exit( 1 ); + } + break; + case 3: + printf("weighted A* with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf(" plan length"); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + case 4: + printf("A*epsilon with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); + exit( 1 ); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + case 5: + printf("Enforced Hill-Climbing, then A*epsilon with weight %d.", gcmd_line.w); + if ( goptimization_established ) { + printf("\nMetric is "); + print_LnfExpNode( &glnf_metric ); + } else { + printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); + exit( 1 ); + } + printf("\nCOST MINIMIZATION DONE"); + if ( !gcost_rplans ) { + printf(" (WITHOUT cost-minimizing relaxed plans)."); + } else { + printf(" (WITH cost-minimizing relaxed plans)."); + } + break; + default: + printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); + exit( 1 ); + } + } else { + if ( gcmd_line.search_config == 4 && !goptimization_established ) { + exit( 1 ); + } + } + + + times( &start ); + + + + /* need to evaluate derived predicates in initial state! + */ + do_axiom_update( &ginitial_state ); + + + if ( !gcost_rplans ) { + gcmd_line.cost_bound = -1; + } + + switch ( gcmd_line.search_config ) { + case 0: + found_plan = do_enforced_hill_climbing(); + if ( found_plan ) { + if ( gcmd_line.display_info ) { + print_plan(); + } + } else { + if ( gcmd_line.display_info ) { + printf("\n\nEnforced Hill-climbing failed !"); + printf("\nswitching to Best-first Search now.\n"); + } + do_best_first_search(); + } + break; + case 1: + case 2: + do_best_first_search(); + break; + case 3: + do_weighted_Astar(); + break; + case 4: + do_Astar_epsilon(); + break; + case 5: + /* gcost_rplans controls whether or not we compute cost-minimal relaxed plans + * gcost_minimizing is only used in h fn to decide whether or not we + * need to count the weights of the operators in the relaxed plan. + * + * gcost_rplans may be false even for search options 3,4,5, namely if there are + * numeric preconditions/goals which make this relaxed plan variant invalid. + * hence we need to remember, when switching it off for EHC, whether or not + * it was previously on. + */ + prev_gcost_rplans = gcost_rplans; + gcost_rplans = FALSE; + gcost_minimizing = FALSE; + found_plan = do_enforced_hill_climbing(); + if ( found_plan ) { + print_plan(); + } else { + if ( gcmd_line.display_info ) { + printf("\n\nEnforced Hill-climbing not successful."); + printf("\nSwitching to A*epsilon now."); + } + gcost_rplans = prev_gcost_rplans; + gcost_minimizing = TRUE; + do_Astar_epsilon(); + } + break; + default: + printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); + exit( 1 ); + } + + times( &end ); + TIME( gsearch_time ); + + + + output_planner_info(); + + printf("\n\n"); + exit( 0 ); + +} + + + + + + + + + + + +/* + * ----------------------------- HELPING FUNCTIONS ---------------------------- + */ + + + + + + + + + + + + +void output_planner_info( void ) + +{ + + printf( "\n\ntime spent: %7.2f seconds instantiating %d easy, %d hard action templates", + gtempl_time, gnum_easy_templates, gnum_hard_mixed_operators ); + printf( "\n %7.2f seconds reachability analysis, yielding %d facts and %d actions", + greach_time, gnum_pp_facts, gnum_actions ); + printf( "\n %7.2f seconds creating final representation with %d relevant facts, %d relevant fluents", + grelev_time, gnum_relevant_facts, gnum_relevant_fluents ); + printf( "\n %7.2f seconds computing LNF", + gLNF_time ); + printf( "\n %7.2f seconds building connectivity graph", + gconn_time ); + printf( "\n %7.2f seconds searching, evaluating %d states, to a max depth of %d", + gsearch_time, gevaluated_states, gmax_search_depth ); + printf( "\n %7.2f seconds total time", + gtempl_time + greach_time + grelev_time + gLNF_time + gconn_time + gsearch_time ); + + printf("\n\n"); + + exit( 0 ); + +} + + + +void ff_usage( void ) + +{ + + printf("\nusage of ff:\n"); + + printf("\nOPTIONS DESCRIPTIONS\n\n"); + printf("-p Path for operator and fact file\n"); + printf("-o Operator file name\n"); + printf("-f Fact file name\n\n"); + + printf("-r Random seed [used for random restarts; preset: 0]\n\n"); + + printf("-s Search configuration [preset: s=5]; '+H': helpful actions pruning\n"); + printf(" 0 Standard-FF: EHC+H then BFS (cost minimization: NO)\n"); + printf(" 1 BFS (cost minimization: NO)\n"); + printf(" 2 BFS+H (cost minimization: NO)\n"); + printf(" 3 Weighted A* (cost minimization: YES)\n"); + printf(" 4 A*epsilon (cost minimization: YES)\n"); + printf(" 5 EHC+H then A*epsilon (cost minimization: YES)\n"); + printf("-w Set weight w for search configs 3,4,5 [preset: w=5]\n\n"); + + printf("-C Do NOT use cost-minimizing relaxed plans for options 3,4,5\n\n"); + + printf("-b Fixed upper bound on solution cost (prune based on g+hmax); active only with cost minimization\n\n"); + + if ( 0 ) { + printf("-i run-time information level( preset: 1 )\n"); + printf(" 0 only times\n"); + printf(" 1 problem name, planning process infos\n"); + printf(" 101 parsed problem data\n"); + printf(" 102 cleaned up ADL problem\n"); + printf(" 103 collected string tables\n"); + printf(" 104 encoded domain\n"); + printf(" 105 predicates inertia info\n"); + printf(" 106 splitted initial state\n"); + printf(" 107 domain with Wff s normalized\n"); + printf(" 108 domain with NOT conds translated\n"); + printf(" 109 splitted domain\n"); + printf(" 110 cleaned up easy domain\n"); + printf(" 111 unaries encoded easy domain\n"); + printf(" 112 effects multiplied easy domain\n"); + printf(" 113 inertia removed easy domain\n"); + printf(" 114 easy action templates\n"); + printf(" 115 cleaned up hard domain representation\n"); + printf(" 116 mixed hard domain representation\n"); + printf(" 117 final hard domain representation\n"); + printf(" 118 reachability analysis results\n"); + printf(" 119 facts selected as relevant\n"); + printf(" 120 final domain and problem representations\n"); + printf(" 121 normalized expressions representation\n"); + printf(" 122 LNF: translated subtractions representation\n"); + printf(" 123 summarized effects LNF representation\n"); + printf(" 124 encoded LNF representation\n"); + printf(" 125 connectivity graph\n"); + printf(" 126 fixpoint result on each evaluated state\n"); + printf(" 127 1P extracted on each evaluated state\n"); + printf(" 128 H set collected for each evaluated state\n"); + + printf("\n-d switch on debugging\n\n"); + } + +} + + + +Bool process_command_line( int argc, char *argv[] ) + +{ + + char option; + + while ( --argc && ++argv ) { + if ( *argv[0] != '-' || strlen(*argv) != 2 ) { + return FALSE; + } + option = *++argv[0]; + switch ( option ) { +/* case 'E': */ +/* gcmd_line.ehc = FALSE; */ +/* break; */ +/* case 'O': */ +/* gcmd_line.optimize = TRUE; */ +/* gcmd_line.ehc = FALSE; */ +/* break; */ + case 'C': + gcmd_line.cost_rplans = FALSE; + break; + default: + if ( --argc && ++argv ) { + switch ( option ) { + case 'p': + strncpy( gcmd_line.path, *argv, MAX_LENGTH ); + break; + case 'o': + strncpy( gcmd_line.ops_file_name, *argv, MAX_LENGTH ); + break; + case 'f': + strncpy( gcmd_line.fct_file_name, *argv, MAX_LENGTH ); + break; + case 'i': + sscanf( *argv, "%d", &gcmd_line.display_info ); + break; + case 'd': + sscanf( *argv, "%d", &gcmd_line.debug ); + break; + case 's': + sscanf( *argv, "%d", &gcmd_line.search_config ); + break; + case 'w': + sscanf( *argv, "%d", &gcmd_line.w ); + break; + case 'b': + sscanf( *argv, "%f", &gcmd_line.cost_bound ); + break; + default: + printf( "\nff: unknown option: %c entered\n\n", option ); + return FALSE; + } + } else { + return FALSE; + } + } + } + + if ( 0 > gcmd_line.search_config || gcmd_line.search_config > 5 ) { + printf("\n\nff: unknown search configuration %d.\n\n", + gcmd_line.search_config); + return FALSE; + } + + if ( gcmd_line.search_config <= 2 ) { + gcost_minimizing = FALSE; + gcost_rplans = FALSE; + } else { + gcost_minimizing = TRUE; + gcost_rplans = TRUE; + } + + gw = gcmd_line.w; + + if ( !gcmd_line.cost_rplans ) { + gcost_rplans = FALSE; + } + + if ( gcmd_line.cost_bound != -1 && gcmd_line.cost_bound < 0 ) { + printf("\n\nff: invalid cost bound %f; must be >= 0.\n\n", + gcmd_line.cost_bound); + return FALSE; + } + + return TRUE; + +} + diff --git a/models/main_models/rt1/gen/ff_planner/makefile b/models/main_models/rt1/gen/ff_planner/makefile new file mode 100644 index 000000000..b8ace7b81 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/makefile @@ -0,0 +1,89 @@ +#!/bin/sh +# + + +####### FLAGS + +TYPE = +ADDONS = + +CC = gcc + +CFLAGS = -O6 -ansi $(TYPE) $(ADDONS) -g +# -g -pg + +LIBS = -lm + + +####### Files + +PDDL_PARSER_SRC = scan-fct_pddl.tab.c \ + scan-ops_pddl.tab.c \ + scan-probname.tab.c \ + lex.fct_pddl.c \ + lex.ops_pddl.c + +PDDL_PARSER_OBJ = scan-fct_pddl.tab.o \ + scan-ops_pddl.tab.o + + +SOURCES = main.c \ + memory.c \ + output.c \ + parse.c \ + expressions.c \ + inst_pre.c \ + inst_easy.c \ + inst_hard.c \ + inst_final.c \ + relax.c \ + search.c + +OBJECTS = $(SOURCES:.c=.o) + +####### Implicit rules + +.SUFFIXES: + +.SUFFIXES: .c .o + +.c.o:; $(CC) -c $(CFLAGS) $< + +####### Build rules + + +ff: $(OBJECTS) $(PDDL_PARSER_OBJ) + $(CC) -o ff $(OBJECTS) $(PDDL_PARSER_OBJ) $(CFLAGS) $(LIBS) + +# pddl syntax +scan-fct_pddl.tab.c: scan-fct_pddl.y lex.fct_pddl.c + bison -pfct_pddl -bscan-fct_pddl scan-fct_pddl.y + +scan-ops_pddl.tab.c: scan-ops_pddl.y lex.ops_pddl.c + bison -pops_pddl -bscan-ops_pddl scan-ops_pddl.y + +lex.fct_pddl.c: lex-fct_pddl.l + flex -Pfct_pddl lex-fct_pddl.l + +lex.ops_pddl.c: lex-ops_pddl.l + flex -Pops_pddl lex-ops_pddl.l + + +# misc +clean: + rm -f *.o *.bak *~ *% core *_pure_p9_c0_400.o.warnings \ + \#*\# $(RES_PARSER_SRC) $(PDDL_PARSER_SRC) + +veryclean: clean + rm -f ff H* J* K* L* O* graph.* *.symbex gmon.out \ + $(PDDL_PARSER_SRC) \ + lex.fct_pddl.c lex.ops_pddl.c lex.probname.c \ + *.output + +depend: + makedepend -- $(SOURCES) $(PDDL_PARSER_SRC) + +lint: + lclint -booltype Bool $(SOURCES) 2> output.lint + +# DO NOT DELETE diff --git a/models/main_models/rt1/gen/ff_planner/memory.c b/models/main_models/rt1/gen/ff_planner/memory.c new file mode 100644 index 000000000..601cea497 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/memory.c @@ -0,0 +1,1278 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: memory.c + * Description: Creation and Deletion functions for all data structures. + * + * Author: Joerg Hoffmann + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" +#include "memory.h" + + +#include "inst_pre.h" + + + + + + +/********************** + * CREATION FUNCTIONS * + **********************/ + + + + + + + + + + + +/* parsing + */ + + + + + + + + + +char *new_Token( int len ) + +{ + + char *tok = ( char * ) calloc( len, sizeof( char ) ); + CHECK_PTR(tok); + + return tok; + +} + + + +TokenList *new_TokenList( void ) + +{ + + TokenList *result = ( TokenList * ) calloc( 1, sizeof( TokenList ) ); + CHECK_PTR(result); + + result->item = NULL; + result->next = NULL; + + return result; + +} + + + +FactList *new_FactList( void ) + +{ + + FactList *result = ( FactList * ) calloc( 1, sizeof( FactList ) ); + CHECK_PTR(result); + + result->item = NULL; + result->next = NULL; + + return result; + +} + + + +TypedList *new_TypedList( void ) + +{ + + TypedList *result = ( TypedList * ) calloc( 1, sizeof( TypedList ) ); + CHECK_PTR(result); + + result->name = NULL; + result->type = NULL; + result->n = -1; + + return result; + +} + + + +TypedListList *new_TypedListList( void ) + +{ + + TypedListList *result = ( TypedListList * ) calloc( 1, sizeof( TypedListList ) ); + CHECK_PTR(result); + + result->predicate = NULL; + result->args = NULL; + + return result; + +} + + + +ParseExpNode *new_ParseExpNode( ExpConnective c ) + +{ + + ParseExpNode *result = ( ParseExpNode * ) calloc( 1, sizeof( ParseExpNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->atom = NULL; + result->leftson = NULL; + result->rightson = NULL; + + return result; + +} + + + +PlNode *new_PlNode( Connective c ) + +{ + + PlNode *result = ( PlNode * ) calloc( 1, sizeof( PlNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->atom = NULL; + + result->comp = -1; + result->neft = -1; + result->lh = NULL; + result->rh = NULL; + + result->sons = NULL; + result->next = NULL; + + return result; + +} + + + +PlOperator *new_PlOperator( char *name ) + +{ + + PlOperator *result = ( PlOperator * ) calloc( 1, sizeof( PlOperator ) ); + CHECK_PTR(result); + + if ( name ) { + result->name = new_Token(strlen(name)+1); + CHECK_PTR(result->name); + strcpy(result->name, name); + } else { + result->name = NULL; + } + + result->params = NULL; + result->preconds = NULL; + result->effects = NULL; + result->number_of_real_params = 0; + result->next = NULL; + + return result; + +} + + + +PlOperator *new_axiom_op_list( void ) + +{ + + static int count; + char *name; + PlOperator *ret; + + /* WARNING: count should not exceed 999 + */ + count++; + if ( count == 10000 ) { + printf("\ntoo many axioms! look into memory.c, line 157\n\n"); + exit( 1 ); + } + name = new_Token(strlen(HIDDEN_STR)+strlen(AXIOM_STR)+4+1); + sprintf(name, "%s%s%4d", HIDDEN_STR, AXIOM_STR, count); + + ret = new_PlOperator(name); + free(name); + + return ret; + +} + + + + + + + + + + + + + + +/* instantiation + */ + + + + + + + + + + + +Fact *new_Fact( void ) + +{ + + Fact *result = ( Fact * ) calloc( 1, sizeof( Fact ) ); + CHECK_PTR(result); + + return result; + +} + + + +Fluent *new_Fluent( void ) + +{ + + Fluent *result = ( Fluent * ) calloc( 1, sizeof( Fluent ) ); + CHECK_PTR(result); + + return result; + +} + + + +FluentValue *new_FluentValue( void ) + +{ + + FluentValue *result = ( FluentValue * ) calloc( 1, sizeof( FluentValue ) ); + CHECK_PTR(result); + + return result; + +} + + + +Facts *new_Facts( void ) + +{ + + Facts *result = ( Facts * ) calloc( 1, sizeof( Facts ) ); + CHECK_PTR(result); + + result->fact = new_Fact(); + + result->next = NULL; + + return result; + +} + + + +FluentValues *new_FluentValues( void ) + +{ + + FluentValues *result = ( FluentValues * ) calloc( 1, sizeof( FluentValues ) ); + CHECK_PTR(result); + + result->next = NULL; + + return result; + +} + + + +ExpNode *new_ExpNode( ExpConnective c ) + +{ + + ExpNode *result = ( ExpNode * ) calloc( 1, sizeof( ExpNode ) ); + CHECK_PTR(result); + + result->connective = c; + result->fluent = NULL; + result->fl = -2; + result->c = 1; + result->son = NULL; + result->leftson = NULL; + result->rightson = NULL; + + return result; + +} + + + +WffNode *new_WffNode( Connective c ) + +{ + + WffNode *result = ( WffNode * ) calloc( 1, sizeof( WffNode ) ); + CHECK_PTR(result); + + result->connective = c; + + result->var = -1; + result->var_type = -1; + result->var_name = NULL; + + result->sons = NULL; + result->next = NULL; + result->prev = NULL; + + result->fact = NULL; + result->NOT_p = -1; + + result->son = NULL; + + result->comp = -1; + result->lh = NULL; + result->rh = NULL; + + result->visited = FALSE; + + return result; + +} + + + +Literal *new_Literal( void ) + +{ + + Literal *result = ( Literal * ) calloc( 1, sizeof( Literal ) ); + CHECK_PTR(result); + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NumericEffect *new_NumericEffect( void ) + +{ + + NumericEffect *result = ( NumericEffect * ) calloc( 1, sizeof( NumericEffect ) ); + CHECK_PTR(result); + + result->rh = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +Effect *new_Effect( void ) + +{ + + Effect *result = ( Effect * ) calloc( 1, sizeof( Effect ) ); + CHECK_PTR(result); + + result->num_vars = 0; + + result->conditions = NULL; + + result->effects = NULL; + result->numeric_effects = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +Operator *new_Operator( char *name, int norp ) + +{ + + int i; + + Operator *result = ( Operator * ) calloc( 1, sizeof( Operator ) ); + CHECK_PTR(result); + + if ( name ) { + result->name = new_Token( strlen( name ) + 1 ); + CHECK_PTR( result->name ); + strcpy( result->name, name ); + } else { + result->name = NULL; + } + + result->num_vars = 0; + result->number_of_real_params = norp; + + for ( i = 0; i < MAX_VARS; i++ ) { + result->removed[i] = FALSE; + } + + result->preconds = NULL; + + result->effects = NULL; + + result->hard = TRUE; + + return result; + +} + + + +NormEffect *new_NormEffect1( Effect *e ) + +{ + + int i; + + NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); + CHECK_PTR(result); + + result->num_vars = e->num_vars; + for ( i = 0; i < e->num_vars; i++ ) { + result->var_types[i] = e->var_types[i]; + result->inst_table[i] = -1; + } + + result->conditions = NULL; + result->num_conditions = 0; + + result->adds = NULL; + result->num_adds = 0; + result->dels = NULL; + result->num_dels = 0; + + result->numeric_conditions_comp = NULL; + result->numeric_conditions_lh = NULL; + result->numeric_conditions_rh = NULL; + result->num_numeric_conditions = 0; + + result->numeric_effects_neft = NULL; + result->numeric_effects_fluent = NULL; + result->numeric_effects_rh = NULL; + result->num_numeric_effects = 0; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NormEffect *new_NormEffect2( NormEffect *e ) + +{ + + int i, j; + + NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); + CHECK_PTR(result); + + result->num_vars = 0; + + result->conditions = ( Fact * ) calloc( e->num_conditions, sizeof( Fact ) ); + result->num_conditions = e->num_conditions; + for ( i = 0; i < e->num_conditions; i++ ) { + result->conditions[i].predicate = e->conditions[i].predicate; + for ( j = 0; j < garity[e->conditions[i].predicate]; j++ ) { + result->conditions[i].args[j] = e->conditions[i].args[j]; + } + } + result->adds = ( Fact * ) calloc( e->num_adds, sizeof( Fact ) ); + result->num_adds = e->num_adds; + for ( i = 0; i < e->num_adds; i++ ) { + result->adds[i].predicate = e->adds[i].predicate; + for ( j = 0; j < garity[e->adds[i].predicate]; j++ ) { + result->adds[i].args[j] = e->adds[i].args[j]; + } + } + result->dels = ( Fact * ) calloc( e->num_dels, sizeof( Fact ) ); + result->num_dels = e->num_dels; + for ( i = 0; i < e->num_dels; i++ ) { + result->dels[i].predicate = e->dels[i].predicate; + for ( j = 0; j < garity[e->dels[i].predicate]; j++ ) { + result->dels[i].args[j] = e->dels[i].args[j]; + } + } + + result->numeric_conditions_comp = ( Comparator * ) + calloc( e->num_numeric_conditions, sizeof( Comparator ) ); + result->numeric_conditions_lh = ( ExpNode_pointer * ) + calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + result->numeric_conditions_rh = ( ExpNode_pointer * ) + calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + result->numeric_conditions_comp[i] = e->numeric_conditions_comp[i]; + result->numeric_conditions_lh[i] = copy_Exp( e->numeric_conditions_lh[i] ); + result->numeric_conditions_rh[i] = copy_Exp( e->numeric_conditions_rh[i] ); + } + result->num_numeric_conditions = e->num_numeric_conditions; + result->numeric_effects_neft = ( NumericEffectType * ) + calloc( e->num_numeric_effects, sizeof( NumericEffectType ) ); + result->numeric_effects_fluent = ( Fluent * ) + calloc( e->num_numeric_effects, sizeof( Fluent ) ); + result->numeric_effects_rh = ( ExpNode_pointer * ) + calloc( e->num_numeric_effects, sizeof( ExpNode_pointer ) ); + for ( i = 0; i < e->num_numeric_effects; i++ ) { + result->numeric_effects_neft[i] = e->numeric_effects_neft[i]; + result->numeric_effects_fluent[i].function = e->numeric_effects_fluent[i].function; + for ( j = 0; j < gf_arity[e->numeric_effects_fluent[i].function]; j++ ) { + result->numeric_effects_fluent[i].args[j] = e->numeric_effects_fluent[i].args[j]; + } + result->numeric_effects_rh[i] = copy_Exp( e->numeric_effects_rh[i] ); + } + result->num_numeric_effects = e->num_numeric_effects; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +NormOperator *new_NormOperator( Operator *op ) + +{ + + int i; + + NormOperator *result = ( NormOperator * ) calloc( 1, sizeof( NormOperator ) ); + CHECK_PTR(result); + + result->operator = op; + + result->num_vars = op->num_vars; + for ( i = 0; i < op->num_vars; i++ ) { + result->var_types[i] = op->var_types[i]; + result->inst_table[i] = -1; + } + result->num_removed_vars = 0; + + result->preconds = NULL; + result->num_preconds = 0; + + result->numeric_preconds_comp = NULL; + result->numeric_preconds_lh = NULL; + result->numeric_preconds_rh = NULL; + result->num_numeric_preconds = 0; + + result->effects = NULL; + + return result; + +} + + + + +EasyTemplate *new_EasyTemplate( NormOperator *op ) + +{ + + EasyTemplate *result = ( EasyTemplate * ) calloc( 1, sizeof( EasyTemplate ) ); + CHECK_PTR(result); + + result->op = op; + + result->prev = NULL; + result->next = NULL; + + return result; + +} + + + +MixedOperator *new_MixedOperator( Operator *op ) + +{ + + MixedOperator *result = ( MixedOperator * ) calloc( 1, sizeof( MixedOperator ) ); + CHECK_PTR(result); + + result->operator = op; + + result->preconds = NULL; + result->num_preconds = 0; + + result->effects = NULL; + + return result; + +} + + + +PseudoActionEffect *new_PseudoActionEffect( void ) + +{ + + PseudoActionEffect *result = + ( PseudoActionEffect * ) calloc( 1, sizeof( PseudoActionEffect ) ); + CHECK_PTR(result); + + result->conditions = NULL; + result->num_conditions = 0; + + result->adds = NULL; + result->num_adds = 0; + result->dels = NULL; + result->num_dels = 0; + + result->numeric_conditions_comp = NULL; + result->numeric_conditions_lh = NULL; + result->numeric_conditions_rh = NULL; + result->num_numeric_conditions = 0; + + result->numeric_effects_neft = NULL; + result->numeric_effects_fluent = NULL; + result->numeric_effects_rh = NULL; + result->num_numeric_effects = 0; + + result->next = NULL; + + return result; + +} + + + +PseudoAction *new_PseudoAction( MixedOperator *op ) + +{ + + int i; + + PseudoAction *result = ( PseudoAction * ) calloc( 1, sizeof( PseudoAction ) ); + CHECK_PTR(result); + + result->operator = op->operator; + for ( i = 0; i < op->operator->num_vars; i++ ) { + result->inst_table[i] = op->inst_table[i]; + } + + result->preconds = op->preconds; + result->num_preconds = op->num_preconds; + + result->numeric_preconds_comp = op->numeric_preconds_comp; + result->numeric_preconds_lh = op->numeric_preconds_lh; + result->numeric_preconds_rh = op->numeric_preconds_rh; + result->num_numeric_preconds = op->num_numeric_preconds; + + result->effects = NULL; + result->num_effects = 0; + + return result; + +} + + + +LnfExpNode *new_LnfExpNode( void ) + +{ + + LnfExpNode *result = ( LnfExpNode * ) calloc( 1, sizeof( LnfExpNode ) ); + CHECK_PTR(result); + + result->num_pF = 0; + result->num_nF = 0; + + result->c = 0; + + return result; + +} + + + +Action *new_Action( void ) + +{ + + Action *result = ( Action * ) calloc( 1, sizeof( Action ) ); + CHECK_PTR(result); + + result->norm_operator = NULL; + result->pseudo_action = NULL; + + result->next = NULL; + + return result; + +} + + + +void make_state( State *pointer, int ft, int fl ) + +{ + + int i; + + pointer->F = ( int * ) calloc( ft, sizeof( int ) ); + pointer->f_D = ( Bool * ) calloc( fl, sizeof( Bool ) ); + pointer->f_V = ( float * ) calloc( fl, sizeof( float ) ); + + for ( i = 0; i < fl; i++ ) { + pointer->f_D[i] = FALSE; + } + +} + + + +EhcNode *new_EhcNode( void ) + +{ + + EhcNode *result = ( EhcNode * ) calloc( 1, sizeof( EhcNode ) ); + CHECK_PTR(result); + + make_state( &(result->S), gnum_ft_conn, gnum_fl_conn ); + + result->father = NULL; + result->next = NULL; + + return result; + +} + + + +EhcHashEntry *new_EhcHashEntry( void ) + +{ + + EhcHashEntry *result = ( EhcHashEntry * ) calloc( 1, sizeof( EhcHashEntry ) ); + CHECK_PTR(result); + + result->ehc_node = NULL; + + result->next = NULL; + + return result; + +} + + + +PlanHashEntry *new_PlanHashEntry( void ) + +{ + + PlanHashEntry *result = ( PlanHashEntry * ) calloc( 1, sizeof( PlanHashEntry ) ); + CHECK_PTR(result); + + result->next_step = NULL; + + result->next = NULL; + + return result; + +} + + + +BfsNode *new_BfsNode( void ) + +{ + + BfsNode *result = ( BfsNode * ) calloc( 1, sizeof( BfsNode ) ); + CHECK_PTR(result); + + result->father = NULL; + + result->next = NULL; + result->prev = NULL; + + return result; + +} + + + +BfsHashEntry *new_BfsHashEntry( void ) + +{ + + BfsHashEntry *result = ( BfsHashEntry * ) calloc( 1, sizeof( BfsHashEntry ) ); + CHECK_PTR(result); + + result->bfs_node = NULL; + + result->next = NULL; + + return result; + +} + + + + + + + + + + + +/********************** + * DELETION FUNCTIONS * + **********************/ + + + + + + + + + + + + +void free_TokenList( TokenList *source ) + +{ + + if ( source ) { + free_TokenList( source->next ); + if ( source->item ) { + free( source->item ); + } + free( source ); + } + +} + + + +void free_FactList( FactList *source ) + +{ + + if ( source ) { + free_FactList( source->next ); + free_TokenList( source->item ); + free( source ); + } + +} + + + +void free_ParseExpNode( ParseExpNode *n ) + +{ + + if ( n ) { + free_TokenList( n->atom ); + free_ParseExpNode( n->leftson ); + free_ParseExpNode( n->rightson ); + free( n ); + } + +} + + + +void free_PlNode( PlNode *node ) + +{ + + if ( node ) { + free_ParseExpNode( node->lh ); + free_ParseExpNode( node->rh ); + free_PlNode( node->sons ); + free_PlNode( node->next ); + free_TokenList( node->atom ); + free( node ); + } + +} + + + +void free_PlOperator( PlOperator *o ) + +{ + + if ( o ) { + free_PlOperator( o->next ); + + if ( o->name ) { + free( o->name ); + } + + free_FactList( o->params ); + free_PlNode( o->preconds ); + free_PlNode( o->effects ); + + free( o ); + } + +} + + + +void free_Operator( Operator *o ) + +{ + + if ( o ) { + /* need not free more: the only point where that happens + * is only directly after first allocation + */ + + if ( o->name ) { + free( o->name ); + } + + free( o ); + } + +} + + + +void free_ExpNode( ExpNode *n ) + +{ + + if ( n ) { + if ( n->fluent ) free( n->fluent ); + free_ExpNode( n->son ); + free_ExpNode( n->leftson ); + free_ExpNode( n->rightson ); + free( n ); + } + +} + + + +void free_WffNode( WffNode *w ) + +{ + + if ( w ) { + free_WffNode( w->son ); + free_WffNode( w->sons ); + free_WffNode( w->next ); + if ( w->var_name ) { + free( w->var_name ); + } + if ( w->fact ) free( w->fact ); + free_ExpNode( w->lh ); + free_ExpNode( w->rh ); + free( w ); + } + +} + + + +void free_NormEffect( NormEffect *e ) + +{ + + int i; + + if ( e ) { + free_NormEffect( e->next ); + + if ( e->conditions ) { + free( e->conditions ); + } + if ( e->adds ) { + free( e->adds ); + } + if ( e->dels ) { + free( e->dels ); + } + + if ( e->numeric_conditions_comp ) { + free( e->numeric_conditions_comp ); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + free_ExpNode( e->numeric_conditions_lh[i] ); + free_ExpNode( e->numeric_conditions_rh[i] ); + } + if ( e->numeric_conditions_lh ) { + free( e->numeric_conditions_lh ); + } + if ( e->numeric_conditions_rh ) { + free( e->numeric_conditions_rh ); + } + + if ( e->numeric_effects_neft ) { + free( e->numeric_effects_neft ); + } + if ( e->numeric_effects_fluent ) { + free( e->numeric_effects_fluent ); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + free_ExpNode( e->numeric_effects_rh[i] ); + } + if ( e->numeric_effects_rh ) { + free( e->numeric_effects_rh ); + } + + free( e ); + } + +} + + + +void free_partial_Effect( Effect *e ) + +{ + + if ( e ) { + free_partial_Effect( e->next ); + + free_WffNode( e->conditions ); + + free( e ); + } + +} + + + +void free_NormOperator( NormOperator *o ) + +{ + + int i; + + if ( o ) { + + if ( o->preconds ) { + free( o->preconds ); + } + if ( o->numeric_preconds_comp ) { + free( o->numeric_preconds_comp ); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + free_ExpNode( o->numeric_preconds_lh[i] ); + free_ExpNode( o->numeric_preconds_rh[i] ); + } + if ( o->numeric_preconds_lh ) { + free( o->numeric_preconds_lh ); + } + if ( o->numeric_preconds_rh ) { + free( o->numeric_preconds_rh ); + } + free_NormEffect( o->effects ); + + free( o ); + } + +} + + + +void free_single_NormEffect( NormEffect *e ) + +{ + + int i; + + if ( e ) { + if ( e->conditions ) { + free( e->conditions ); + } + if ( e->adds ) { + free( e->adds ); + } + if ( e->dels ) { + free( e->dels ); + } + + if ( e->numeric_conditions_comp ) { + free( e->numeric_conditions_comp ); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + free_ExpNode( e->numeric_conditions_lh[i] ); + free_ExpNode( e->numeric_conditions_rh[i] ); + } + if ( e->numeric_conditions_lh ) { + free( e->numeric_conditions_lh ); + } + if ( e->numeric_conditions_rh ) { + free( e->numeric_conditions_rh ); + } + + if ( e->numeric_effects_neft ) { + free( e->numeric_effects_neft ); + } + if ( e->numeric_effects_fluent ) { + free( e->numeric_effects_fluent ); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + free_ExpNode( e->numeric_effects_rh[i] ); + } + if ( e->numeric_effects_rh ) { + free( e->numeric_effects_rh ); + } + + free( e ); + } + +} + + + +void free_single_EasyTemplate( EasyTemplate *t ) + +{ + + if ( t ) { + free( t ); + } + +} + + + +void free_TypedList( TypedList *t ) + +{ + + if ( t ) { + if ( t->name ) { + free( t->name ); + t->name = NULL; + } + if ( t->type ) { + free_TokenList( t->type ); + t->type = NULL; + } + free_TypedList( t->next ); + + free( t ); + } + +} + + + +void free_TypedListList( TypedListList *t ) + +{ + + if ( t ) { + if ( t->predicate ) { + free( t->predicate ); + t->predicate = NULL; + } + if ( t->args ) { + free_TypedList( t->args ); + t->args = NULL; + } + free_TypedListList( t->next ); + + free( t ); + } + +} + + + +void free_BfsNode( BfsNode *n ) + +{ + + if ( n ) { + free_BfsNode( n->next ); + free( n ); + } + +} + + + +void free_BfsHashEntry( BfsHashEntry *n ) + +{ + + if ( n ) { + free_BfsHashEntry( n->next ); + free( n ); + } + +} diff --git a/models/main_models/rt1/gen/ff_planner/memory.h b/models/main_models/rt1/gen/ff_planner/memory.h new file mode 100644 index 000000000..13e8ddfb3 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/memory.h @@ -0,0 +1,109 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + +/********************************************************************* + * File: memory.h + * Description: Creation / Deletion functions for all data structures. + * + * Author: Joerg Hoffmann / Frank Rittinger + * + *********************************************************************/ + + + + + + +#ifndef _MEMORY_H +#define _MEMORY_H + + + + + +char *new_Token( int len ); +TokenList *new_TokenList( void ); +FactList *new_FactList( void ); +TypedList *new_TypedList( void ); +TypedListList *new_TypedListList( void ); +ParseExpNode *new_ParseExpNode( ExpConnective c ); +PlNode *new_PlNode( Connective c ); +PlOperator *new_PlOperator( char *name ); +PlOperator *new_axiom_op_list( void ); + + + +Fact *new_Fact( void ); +Fluent *new_Fluent( void ); +FluentValue *new_FluentValue( void ); +Facts *new_Facts( void ); +FluentValues *new_FluentValues( void ); +ExpNode *new_ExpNode( ExpConnective c ); +WffNode *new_WffNode( Connective c ); +Literal *new_Literal( void ); +NumericEffect *new_NumericEffect( void ); +Effect *new_Effect( void ); +Operator *new_Operator( char *name, int norp ); +NormEffect *new_NormEffect1( Effect *e ); +NormEffect *new_NormEffect2( NormEffect *e ); +NormOperator *new_NormOperator( Operator *op ); +EasyTemplate *new_EasyTemplate( NormOperator *op ); +MixedOperator *new_MixedOperator( Operator *op ); +PseudoActionEffect *new_PseudoActionEffect( void ); +PseudoAction *new_PseudoAction( MixedOperator *op ); +LnfExpNode *new_LnfExpNode( void ); +Action *new_Action( void ); +void make_state( State *pointer, int ft, int fl ); +EhcNode *new_EhcNode( void ); +EhcHashEntry *new_EhcHashEntry( void ); +PlanHashEntry *new_PlanHashEntry( void ); +BfsNode *new_BfsNode( void ); +BfsHashEntry *new_BfsHashEntry( void ); + + + + + + + +void free_TokenList( TokenList *source ); +void free_FactList( FactList *source ); +void free_ParseExpNode( ParseExpNode *n ); +void free_PlNode( PlNode *node ); +void free_PlOperator( PlOperator *o ); +void free_Operator( Operator *o ); +void free_ExpNode( ExpNode *n ); +void free_WffNode( WffNode *w ); +void free_NormEffect( NormEffect *e ); +void free_partial_Effect( Effect *e ); +void free_NormOperator( NormOperator *o ); +void free_single_NormEffect( NormEffect *e ); +void free_single_EasyTemplate( EasyTemplate *t ); +void free_TypedList( TypedList *t ); +void free_TypedListList( TypedListList *t ); +void free_ActionEffect( ActionEffect *e ); +void free_BfsNode( BfsNode *n ); +void free_BfsHashEntry( BfsHashEntry *n ); + + + + + + +#endif /* _MEMORY_H */ diff --git a/models/main_models/rt1/gen/ff_planner/output.c b/models/main_models/rt1/gen/ff_planner/output.c new file mode 100644 index 000000000..1341eff7a --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/output.c @@ -0,0 +1,1482 @@ +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: output.c + * Description: printing info out + * + * Author: Joerg Hoffmann + * + *********************************************************************/ + + + + + +#include "ff.h" + +#include "output.h" + + + + + + + +/* parsing + */ + + + + + + + +void print_FactList( FactList *list, char *sepf, char *sept ) + +{ + + FactList *i_list; + TokenList *i_tl; + + if ( list ) { + i_tl = list->item; + if (NULL == i_tl || NULL == i_tl->item) { + printf("empty"); + } else { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } + + while (NULL != i_tl) { + if (NULL != i_tl->item) { + printf("%s%s", sept, i_tl->item); + } + i_tl = i_tl->next; + } + + for ( i_list = list->next; i_list; i_list = i_list->next ) { + printf("%s", sepf); + i_tl = i_list->item; + if (NULL == i_tl || NULL == i_tl->item) { + printf("empty"); + } else { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } + + while (NULL != i_tl) { + if (NULL != i_tl->item) { + printf("%s%s", sept, i_tl->item); + } + i_tl = i_tl->next; + } + } + } + +} + + + +void print_hidden_TokenList( TokenList *list, char *sep ) + +{ + + TokenList *i_tl; + + i_tl = list; + if (NULL!=i_tl) { + printf("%s", i_tl->item); + i_tl = i_tl->next; + } else { + printf("empty"); + } + + while (NULL != i_tl) { + printf("%s%s", sep, i_tl->item); + i_tl = i_tl->next; + } + +} + + + +void print_indent( int indent ) + +{ + + int i; + for (i=0;iconnective) { + case AD: + printf("(+ "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case SU: + printf("(- "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case MU: + printf("(* "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case DI: + printf("(/ "); + print_ParseExpNode( n->leftson ); + print_ParseExpNode( n->rightson ); + printf(")"); + break; + case MINUS: + printf("(- "); + print_ParseExpNode( n->leftson ); + printf(")"); + break; + case NUMBER: + printf("%s", n->atom->item); + break; + case FHEAD: + printf("("); + print_hidden_TokenList(n->atom, " "); + printf(")"); + break; + default: + printf("\n\nprint Parseexpnode: wrong specifier %d", + n->connective); + } + +} + + + +void print_PlNode( PlNode *plnode, int indent ) + +{ + + PlNode *i_son; + + if ( !plnode ) { + printf("none\n"); + return; + } + + switch (plnode->connective) { + case ALL: + printf("ALL %s : %s\n", plnode->atom->item, + plnode->atom->next->item); + print_indent(indent); + printf("( "); + print_PlNode(plnode->sons,indent+4); + print_indent(indent); + printf(")\n"); + break; + case EX: + printf("EX %s : %s\n", plnode->atom->item, + plnode->atom->next->item); + print_indent(indent); + printf("( "); + print_PlNode(plnode->sons,indent+4); + print_indent(indent); + printf(")\n"); + break; + case AND: + printf("A( "); + print_PlNode(plnode->sons, indent+4); + if ( plnode->sons ) { + for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { + print_indent(indent); + printf("AND "); + print_PlNode(i_son,indent+4); + } + } + print_indent(indent); + printf(")\n"); + break; + case OR: + printf("O( "); + print_PlNode(plnode->sons, indent+4); + for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { + print_indent(indent); + printf("OR "); + print_PlNode(i_son,indent+4); + } + print_indent(indent); + printf(")\n"); + break; + case WHEN: + printf("IF "); + print_PlNode(plnode->sons,indent+5); + print_indent(indent); + printf("THEN "); + print_PlNode(plnode->sons->next,indent+5); + print_indent(indent); + printf("ENDIF\n"); + break; + case NOT: + if (ATOM==plnode->sons->connective) { + printf("NOT "); + print_PlNode(plnode->sons,indent+4); + } else { + printf("NOT("); + print_PlNode(plnode->sons,indent+4); + print_indent(indent+3); + printf(")\n"); + } + break; + case ATOM: + printf("("); + print_hidden_TokenList(plnode->atom, " "); + printf(")\n"); + break; + case TRU: + printf("(TRUE)\n"); + break; + case FAL: + printf("(FALSE)\n"); + break; + case COMP: + switch (plnode->comp) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\n\nillegal comp in parse tree!\n\n"); + exit( 1 ); + } + print_ParseExpNode( plnode->lh ); + print_ParseExpNode( plnode->rh ); + printf(")\n"); + break; + case NEF: + switch (plnode->neft) { + case ASSIGN: + printf("(assign "); + break; + case SCALE_UP: + printf("(scale-up "); + break; + case SCALE_DOWN: + printf("(scale-down "); + break; + case INCREASE: + printf("(increase "); + break; + case DECREASE: + printf("(decrease "); + break; + } + print_ParseExpNode( plnode->lh ); + print_ParseExpNode( plnode->rh ); + printf(")\n"); + break; + default: + printf("\n***** ERROR ****"); + printf("\nprint_plnode: %d > Wrong Node specifier\n", plnode->connective); + exit(1); + } + +} + + + +void print_plops( PlOperator *plop ) + +{ + + PlOperator *i_plop; + int count = 0; + + if ( !plop ) { + printf("none\n"); + } + + for ( i_plop = plop; i_plop!=NULL; i_plop = i_plop->next ) { + printf("\n"); + if ( i_plop->axiom ) printf("AXIOM-"); + printf("OPERATOR "); + printf("%s", i_plop->name); + printf("\nparameters: (%d real)\n", i_plop->number_of_real_params); + print_FactList ( i_plop->params, "\n", " : "); + printf("\n\npreconditions:\n"); + print_PlNode(i_plop->preconds, 0); + printf("effects:\n"); + print_PlNode(i_plop->effects, 0); + printf("\n-----\n"); + count++; + } + printf("\nAnzahl der Operatoren: %d\n", count); + +} + + + +void print_ExpNode( ExpNode *n ) + +{ + + if ( !n ) return; + + switch ( n->connective) { + case AD: + printf("(+ "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case SU: + printf("(- "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case MU: + printf("(* "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case DI: + printf("(/ "); + print_ExpNode( n->leftson ); + print_ExpNode( n->rightson ); + printf(")"); + break; + case MINUS: + printf("(- "); + print_ExpNode( n->son ); + printf(")"); + break; + case NUMBER: + printf("%.2f", n->value); + break; + case FHEAD: + if ( n->fluent ) { + print_Fluent( n->fluent ); + } else { + if ( n->fl >= 0 ) { + printf(" %.2f*", n->c); + print_fl_name( n->fl ); + } else { + printf("[UNDEF]"); + } + } + break; + default: + printf("\n\nprint Expnode: wrong specifier %d", + n->connective); + } + +} + + + +void print_Wff( WffNode *n, int indent ) + +{ + + WffNode *i; + + if ( !n ) { + printf("none\n"); + return; + } + + switch (n->connective) { + case ALL: + printf("ALL x%d (%s): %s\n", n->var, n->var_name, + gtype_names[n->var_type]); + print_indent(indent); + printf("( "); + print_Wff(n->son,indent+4); + print_indent(indent); + printf(")\n"); + break; + case EX: + printf("EX x%d (%s) : %s\n", n->var, n->var_name, + gtype_names[n->var_type]); + print_indent(indent); + printf("( "); + print_Wff(n->son,indent+4); + print_indent(indent); + printf(")\n"); + break; + case AND: + printf("A( "); + print_Wff(n->sons, indent+4); + if ( n->sons ) { + for ( i = n->sons->next; i!=NULL; i = i->next ) { + if ( !i->prev ) { + printf("\nprev in AND not correctly set!\n\n"); + exit( 1 ); + } + print_indent(indent); + printf("AND "); + print_Wff(i,indent+4); + } + } + print_indent(indent); + printf(")\n"); + break; + case OR: + printf("O( "); + print_Wff(n->sons, indent+4); + for ( i = n->sons->next; i!=NULL; i = i->next ) { + print_indent(indent); + printf("OR "); + print_Wff(i,indent+4); + } + print_indent(indent); + printf(")\n"); + break; + case NOT: + if (ATOM==n->son->connective) { + printf("NOT "); + print_Wff(n->son,indent+4); + } else { + printf("NOT("); + print_Wff(n->son,indent+4); + print_indent(indent+3); + printf(")\n"); + } + break; + case ATOM: + print_Fact(n->fact); + if ( n->NOT_p != -1 ) printf(" - translation NOT"); + printf("\n"); + break; + case TRU: + printf("(TRUE)\n"); + break; + case FAL: + printf("(FALSE)\n"); + break; + case COMP: + switch (n->comp) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in WFF %d\n\n", n->comp); + exit( 1 ); + } + print_ExpNode( n->lh ); + print_ExpNode( n->rh ); + printf(")\n"); + break; + default: + printf("\n***** ERROR ****"); + printf("\nprint_Wff: %d > Wrong Node specifier\n", n->connective); + exit(1); + } + +} + + + +void print_Operator( Operator *o ) + +{ + + Effect *e; + Literal *l; + NumericEffect *ne; + int i, m = 0; + + printf("\n\n----------------Operator %s, axiom %d, translated form, step 1--------------\n", + o->name, o->axiom); + + for ( i = 0; i < o->num_vars; i++ ) { + printf("\nx%d (%s) of type %s, removed ? %s", + i, o->var_names[i], gtype_names[o->var_types[i]], + o->removed[i] ? "YES" : "NO"); + } + printf("\ntotal params %d, real params %d\n", + o->num_vars, o->number_of_real_params); + + printf("\nPreconds:\n"); + print_Wff( o->preconds, 0 ); + + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d (%s) of type %s", + o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]); + } + printf("\nConditions\n"); + print_Wff( e->conditions, 0 ); + printf("\nEffect Literals"); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + printf("\nNOT "); + } else { + printf("\n"); + } + print_Fact( &(l->fact) ); + } + printf("\nNumeric Effects"); + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + switch ( ne->neft ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); + exit( 1 ); + } + print_Fluent( &(ne->fluent) ); + print_ExpNode( ne->rh ); + } + } + +} + + + +void print_NormOperator( NormOperator *o ) + +{ + + NormEffect *e; + int i, m; + + printf("\n\n----------------Operator %s, normalized form--------------\n", + o->operator->name); + + for ( i = 0; i < o->num_vars; i++ ) { + printf("\nx%d of type ", i); + print_type( o->var_types[i] ); + } + printf("\n\n%d vars removed from original operator:", + o->num_removed_vars); + for ( i = 0; i < o->num_removed_vars; i++ ) { + m = o->removed_vars[i]; + printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m], + gtype_names[o->operator->var_types[m]]); + print_type( o->type_removed_vars[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d of type ", o->num_vars + i); + print_type( e->var_types[i] ); + } + printf("\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_Fact( &(e->conditions[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_Fact( &(e->adds[i]) ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_Fact( &(e->dels[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + print_Fluent( &(e->numeric_effects_fluent[i]) ); + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_MixedOperator( MixedOperator *o ) + +{ + + int i, m; + Effect *e; + NumericEffect *ne; + Literal *l; + + printf("\n\n----------------Operator %s, mixed form--------------\n", + o->operator->name); + + for ( i = 0; i < o->operator->num_vars; i++ ) { + printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); + print_type( o->operator->var_types[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d, parameters %d", m++, e->num_vars); + + for ( i = 0; i < e->num_vars; i++ ) { + printf("\nx%d of type %s", + o->operator->num_vars + i, gtype_names[e->var_types[i]]); + } + printf("\nConditions\n"); + print_Wff( e->conditions, 0 ); + printf("\nEffect Literals"); + for ( l = e->effects; l; l = l->next ) { + if ( l->negated ) { + printf("\nNOT "); + } else { + printf("\n"); + } + print_Fact( &(l->fact) ); + } + printf("\nNumeric Effects"); + for ( ne = e->numeric_effects; ne; ne = ne->next ) { + switch ( ne->neft ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); + exit( 1 ); + } + print_Fluent( &(ne->fluent) ); + print_ExpNode( ne->rh ); + } + } + +} + + + +void print_PseudoAction( PseudoAction *o ) + +{ + + PseudoActionEffect *e; + int i, m; + + printf("\n\n----------------Pseudo Action %s--------------\n", + o->operator->name); + + for ( i = 0; i < o->operator->num_vars; i++ ) { + printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); + print_type( o->operator->var_types[i] ); + } + + printf("\nPreconds:\n"); + for ( i = 0; i < o->num_preconds; i++ ) { + print_Fact( &(o->preconds[i]) ); + printf("\n"); + } + for ( i = 0; i < o->num_numeric_preconds; i++ ) { + switch ( o->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", + o->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( o->numeric_preconds_lh[i] ); + print_ExpNode( o->numeric_preconds_rh[i] ); + printf(")\n"); + } + + m = 0; + printf("\n\nEffects:"); + for ( e = o->effects; e; e = e->next ) { + printf("\n\neffect %d", m++); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_Fact( &(e->conditions[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_Fact( &(e->adds[i]) ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_Fact( &(e->dels[i]) ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + print_Fluent( &(e->numeric_effects_fluent[i]) ); + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_Action( Action *a ) + +{ + + ActionEffect *e; + int i, j; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("\n\nAction REACH-GOAL"); + } else { + printf("\n\nAction %s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + + printf("\n\nPreconds:\n"); + for ( i = 0; i < a->num_preconds; i++ ) { + print_ft_name( a->preconds[i] ); + printf("\n"); + } + for ( i = 0; i < a->num_numeric_preconds; i++ ) { + switch ( a->numeric_preconds_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in actionpre %d\n\n", + a->numeric_preconds_comp[i]); + exit( 1 ); + } + print_ExpNode( a->numeric_preconds_lh[i] ); + print_ExpNode( a->numeric_preconds_rh[i] ); + printf(")\n"); + } + + printf("\n\nEffects:"); + for ( j = 0; j < a->num_effects; j++ ) { + printf("\n\neffect %d", j); + e = &(a->effects[j]); + if ( e->illegal ) printf(" ILLEGAL EFFECT!"); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_ft_name( e->conditions[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_conditions; i++ ) { + switch ( e->numeric_conditions_comp[i] ) { + case LE: + printf("(< "); + break; + case LEQ: + printf("(<= "); + break; + case EQ: + printf("(= "); + break; + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in normeff %d\n\n", + e->numeric_conditions_comp[i]); + exit( 1 ); + } + print_ExpNode( e->numeric_conditions_lh[i] ); + print_ExpNode( e->numeric_conditions_rh[i] ); + printf(")\n"); + } + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_ft_name( e->adds[i] ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_ft_name( e->dels[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_numeric_effects; i++ ) { + switch ( e->numeric_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case SCALE_UP: + printf("\nscale-up "); + break; + case SCALE_DOWN: + printf("\nscale-down "); + break; + case INCREASE: + printf("\nincrease "); + break; + case DECREASE: + printf("\ndecrease "); + break; + default: + printf("\n\nprint normop: illegal neft %d\n\n", + e->numeric_effects_neft[i]); + exit( 1 ); + } + if ( e->numeric_effects_fl[i] >= 0 ) { + print_fl_name( e->numeric_effects_fl[i] ); + } else { + printf("[UNDEF]"); + } + print_ExpNode( e->numeric_effects_rh[i] ); + } + } + +} + + + +void print_Action_name( Action *a ) + +{ + + int i; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("REACH-GOAL"); + } else { + printf("%s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + +} + + + +void print_lnf_Action( Action *a ) + +{ + + ActionEffect *e; + int i, j; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("\n\nAction REACH-GOAL"); + } else { + printf("\n\nAction %s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + + printf("\n\nPreconds:\n"); + for ( i = 0; i < a->num_preconds; i++ ) { + print_ft_name( a->preconds[i] ); + printf("\n"); + } + for ( i = 0; i < a->num_lnf_preconds; i++ ) { + switch ( a->lnf_preconds_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in lnf actionpre %d\n\n", + a->lnf_preconds_comp[i]); + exit( 1 ); + } + print_LnfExpNode( a->lnf_preconds_lh[i] ); + printf(" %.2f)\n", a->lnf_preconds_rh[i]); + } + + printf("\n\nEffects:"); + for ( j = 0; j < a->num_effects; j++ ) { + printf("\n\neffect %d COST %f", j, a->effects[j].cost); + e = &(a->effects[j]); + if ( e->illegal ) printf(" ILLEGAL EFFECT!"); + if ( e->removed ) printf(" REMOVED!!!"); + printf("\n\nConditions\n"); + for ( i = 0; i < e->num_conditions; i++ ) { + print_ft_name( e->conditions[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_lnf_conditions; i++ ) { + switch ( e->lnf_conditions_comp[i] ) { + case GEQ: + printf("(>= "); + break; + case GE: + printf("(> "); + break; + default: + printf("\nwrong comparator of Expnodes in lnf normeff %d\n\n", + e->lnf_conditions_comp[i]); + exit( 1 ); + } + print_LnfExpNode( e->lnf_conditions_lh[i] ); + printf(" %.2f)\n", e->lnf_conditions_rh[i] ); + } + printf("\nAdds\n"); + for ( i = 0; i < e->num_adds; i++ ) { + print_ft_name( e->adds[i] ); + printf("\n"); + } + printf("\nDels\n"); + for ( i = 0; i < e->num_dels; i++ ) { + print_ft_name( e->dels[i] ); + printf("\n"); + } + for ( i = 0; i < e->num_lnf_effects; i++ ) { + switch ( e->lnf_effects_neft[i] ) { + case ASSIGN: + printf("\nassign "); + break; + case INCREASE: + printf("\nincrease "); + break; + default: + printf("\n\nprint lnf normop: illegal neft %d\n\n", + e->lnf_effects_neft[i]); + exit( 1 ); + } + if ( e->lnf_effects_fl[i] >= 0 ) { + print_fl_name( e->lnf_effects_fl[i] ); + } else { + printf("[UNDEF]"); + } + print_LnfExpNode( e->lnf_effects_rh[i] ); + } + } + +} + + + +void print_type( int t ) + +{ + + int j; + + if ( gpredicate_to_type[t] == -1 ) { + if ( gnum_intersected_types[t] == -1 ) { + printf("%s", gtype_names[t]); + } else { + printf("INTERSECTED TYPE ("); + for ( j = 0; j < gnum_intersected_types[t]; j++ ) { + if ( gpredicate_to_type[gintersected_types[t][j]] == -1 ) { + printf("%s", gtype_names[gintersected_types[t][j]]); + } else { + printf("UNARY INERTIA TYPE (%s)", + gpredicates[gpredicate_to_type[gintersected_types[t][j]]]); + } + if ( j < gnum_intersected_types[t] - 1 ) { + printf(" and "); + } + } + printf(")"); + } + } else { + printf("UNARY INERTIA TYPE (%s)", gpredicates[gpredicate_to_type[t]]); + } + +} + + + +void print_Fact( Fact *f ) + +{ + + int j; + + if ( f->predicate == -3 ) { + printf("GOAL-REACHED"); + return; + } + + if ( f->predicate == -1 ) { + printf("(="); + for ( j=0; j<2; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + return; + } + + if ( f->predicate == -2 ) { + printf("(!="); + for ( j=0; j<2; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + return; + } + + printf("(%s", gpredicates[f->predicate]); + for ( j=0; jpredicate]; j++ ) { + printf(" "); + if ( f->args[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + +} + + + +void print_Fluent( Fluent *f ) + +{ + + int j, ff = f->function; + + printf("(%s", gfunctions[ff]); + for ( j=0; jargs[j] >= 0 ) { + printf("%s", gconstants[(f->args)[j]]); + } else { + printf("x%d", DECODE_VAR( f->args[j] )); + } + } + printf(")"); + +} + + + +void print_ft_name( int index ) + +{ + + print_Fact( &(grelevant_facts[index]) ); + +} + + + +void print_fl_name( int index ) + +{ + + int i; + + if ( index < 0 ) { + if ( index != -2 ) { + printf("[UNDEF]"); + } else { + printf("[TOTAL-TIME]"); + } + return; + } + + if ( grelevant_fluents_lnf[index] == NULL ) { + /* this is a non-artificial "atomic" one + * (or the mirrored version of one) + */ + printf("[RF%d](%s)", index, grelevant_fluents_name[index]); + } else { + /* this only summarizes a LNF requirement + */ + printf("[artRF%d]", index); + for ( i = 0; i < grelevant_fluents_lnf[index]->num_pF; i++ ) { + printf("%.2f*", grelevant_fluents_lnf[index]->pC[i] ); + print_fl_name( grelevant_fluents_lnf[index]->pF[i] ); + if ( i < grelevant_fluents_lnf[index]->num_pF - 1 ) { + printf(" + "); + } + } + } + +} + + + +void print_LnfExpNode( LnfExpNode *n ) + +{ + + int i; + + printf("(("); + for ( i = 0; i < n->num_pF; i++ ) { + printf("%.2f*", n->pC[i]); + print_fl_name( n->pF[i] ); + } + printf(") - ("); + for ( i = 0; i < n->num_nF; i++ ) { + printf("%.2f*", n->nC[i]); + print_fl_name( n->nF[i] ); + } + printf(") + %.2f)", n->c); + +} + + + +void print_op_name( int index ) + +{ + + int i; + Action *a = gop_conn[index].action; + + if ( !a->norm_operator && + !a->pseudo_action ) { + printf("REACH-GOAL"); + } else { + printf("%s", a->name ); + for ( i = 0; i < a->num_name_vars; i++ ) { + printf(" %s", gconstants[a->name_inst_table[i]]); + } + } + +} + + + +void print_State( State S ) + +{ + + int i; + + for ( i = 0; i < S.num_F; i++ ) { + printf("\n"); + print_ft_name( S.F[i] ); + } + for ( i = 0; i < gnum_relevant_fluents; i++ ) { + printf("\n"); + print_fl_name( i ); + printf(": "); + if ( S.f_D[i] ) { + printf("%.2f", S.f_V[i]); + } else { + printf("UNDEF"); + } + } + +} + + + + + + + + +/* + * program output routines + */ + + + + + + + + + +void print_plan( void ) + +{ + + int i; + float cost = 0; + + printf("\n\nff: found legal plan as follows"); + printf("\nstep "); + for ( i = 0; i < gnum_plan_ops; i++ ) { + printf("%4d: ", i); + print_op_name( gplan_ops[i] ); + if ( i < gnum_plan_ops-1 ) { + printf("\n "); + } + if ( goptimization_established ) { + cost += gop_conn[gplan_ops[i]].cost; + } + } + if ( goptimization_established ) { + printf("\nplan cost: %f", cost); + } + +} diff --git a/models/main_models/rt1/gen/ff_planner/output.h b/models/main_models/rt1/gen/ff_planner/output.h new file mode 100644 index 000000000..a74e87607 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/output.h @@ -0,0 +1,68 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: output.h + * Description: print headers + * + * Author: Joerg Hoffmann 1999 + * + *********************************************************************/ + + + + + +#ifndef _OUTPUT_H +#define _OUTPUT_H + + + +void print_FactList( FactList *list, char *sepf, char *sept ); +void print_hidden_TokenList( TokenList *list, char *sep ); +void print_indent( int indent ); +void print_ParseExpNode( ParseExpNode *n ); +void print_PlNode( PlNode *plnode, int indent ); +void print_ExpNode( ExpNode *n ); +void print_Wff( WffNode *n, int indent ); +void print_plops( PlOperator *plop ); +void print_Operator( Operator *o ); +void print_NormOperator( NormOperator *o ); +void print_MixedOperator( MixedOperator *o ); +void print_PseudoAction( PseudoAction *o ); +void print_Action( Action *a ); +void print_Action_name( Action *a ); +void print_lnf_Action( Action *a ); +void print_type( int t ); +void print_Fact( Fact *f ); +void print_Fluent( Fluent *f ); +void print_ft_name( int index ); +void print_op_name( int index ); +void print_fl_name( int index ); +void print_LnfExpNode( LnfExpNode *n ); +void print_State( State S ); + + + +void print_plan( void ); + + + +#endif /* _OUTPUT_H */ diff --git a/models/main_models/rt1/gen/ff_planner/parse.c b/models/main_models/rt1/gen/ff_planner/parse.c new file mode 100644 index 000000000..cc5a099f9 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/parse.c @@ -0,0 +1,1339 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: parse.c + * Description: Functions for the pddl parser + * + * Author: Joerg Hoffmann 2000 + * + *********************************************************************/ + + + + + + +#include "ff.h" + +#include "memory.h" +#include "output.h" + +#include "parse.h" + + + + + + + + + + + +/* simple parse helpers + */ + + + + + + + +char *copy_Token( char *s ) + +{ + + char *d = new_Token( strlen( s ) + 1 ); + strcpy(d, s); + + return d; + +} + + + +TokenList *copy_TokenList( TokenList *source ) + +{ + + TokenList *temp; + + if ( !source ) { + temp = NULL; + } else { + temp = new_TokenList(); + if ( source->item ) { + temp->item = new_Token( strlen( source->item ) + 1 ); + strcpy( temp->item, source->item ); + } + temp->next = copy_TokenList( source->next ); + } + + return temp; + +} + + + +void strupcase( char *from ) + +{ + + char tmp; + + tmp = *from; + while ('\0' != tmp) { + *from = (char) toupper((int) tmp); + tmp = *++from; + } + +} + + + +char *rmdash( char *s ) + +{ + + s++; + + for( ; (*s == ' ') || (*s == '\t'); s++ ); + + return s; + +} + + + + + + + + + + +/* typed-list-of preprocessing + */ + + + + + + + +Token ltype_names[MAX_TYPES]; +int lnum_types; + + +int leither_ty[MAX_TYPES][MAX_TYPES]; +int lnum_either_ty[MAX_TYPES]; + + + + + +void build_orig_constant_list( void ) + +{ + + char *tmp = NULL; + TypedList *tyl; + TypedListList *tyll; + TokenList *tl, *p_tl, *tmp_tl; + PlOperator *po; + + int i, j, k, n, std; + + Bool m[MAX_TYPES][MAX_TYPES]; + + FactList *fl, *p_fl; + + lnum_types = 0; + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + if ( get_type( tyl->name ) == -1 ) { + ltype_names[lnum_types++] = copy_Token( tyl->name ); + } + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + collect_type_names_in_pl( gorig_goal_facts ); + + for ( po = gloaded_ops; po; po = po->next ) { + collect_type_names_in_pl( po->preconds ); + collect_type_names_in_pl( po->effects ); + for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (n = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = n; + } + free( tmp ); + tmp = NULL; + } + } + + + /* now get the numbers of all composed either types + */ + for ( i = 0; i < lnum_types; i++ ) { + lnum_either_ty[i] = 0; + } + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + for ( tyl = tyll->args; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + make_either_ty_in_pl( gorig_goal_facts ); + for ( po = gloaded_ops; po; po = po->next ) { + make_either_ty_in_pl( po->preconds ); + make_either_ty_in_pl( po->effects ); + for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + } + + + /* now, compute the transitive closure of all type inclusions. + * first initialize the matrix. + */ + for ( i = 0; i < lnum_types; i++ ) { + for ( j = 0; j < lnum_types; j++ ) { + m[i][j] = ( i == j ? TRUE : FALSE ); + } + } + std = -1; + for ( i = 0; i < lnum_types; i++ ) { + if ( strcmp( ltype_names[i], STANDARD_TYPE ) == SAME ) { + std = i; + break; + } + } + for ( i = 0; i < lnum_types; i++ ) { + m[i][std] = TRUE;/* all types are subtypes of OBJECT */ + } + for ( tyl = gparse_types; tyl; tyl = tyl->next ) { + /* all inclusions as are defined in domain file + */ + m[get_type( tyl->name )][tyl->n] = TRUE; + } + /* compute transitive closure on inclusions matrix + */ + for ( j = 0; j < lnum_types; j++ ) { + for ( i = 0; i < lnum_types; i++ ) { + if ( m[i][j] ) { + for ( k = 0; k < lnum_types; k++ ) { + if ( m[j][k] ) { + m[i][k] = TRUE; + } + } + } + } + } + /* union types are subsets of all those types that contain all + * their components, and + * all component types are subsets of the either type ! + */ + for ( i = 0; i < lnum_types; i++ ) { + if ( lnum_either_ty[i] < 2 ) continue; + for ( j = 0; j < lnum_types; j++ ) { + if ( j == i ) continue; + /* get supertypes of all component types + */ + for ( k = 0; k < lnum_either_ty[i]; k++ ) { + if ( !m[leither_ty[i][k]][j] ) break; + } + if ( k < lnum_either_ty[i] ) continue; + m[i][j] = TRUE; + /* make components subtypes of either type + */ + for ( k = 0; k < lnum_either_ty[i]; k++ ) { + m[leither_ty[i][k]][i] = TRUE; + } + } + } + /* and again, compute transitive closure on inclusions matrix. + * I guess, this won't change anything (?), but it also won't need + * any remarkable computation time, so why should one think about it ? + */ + for ( j = 0; j < lnum_types; j++ ) { + for ( i = 0; i < lnum_types; i++ ) { + if ( m[i][j] ) { + for ( k = 0; k < lnum_types; k++ ) { + if ( m[j][k] ) { + m[i][k] = TRUE; + } + } + } + } + } + + + /* now build FactList of ALL constant -> type pairs. + * for each constant / object, let it appear separately + * for each type it is a member of; compute type + * membership based on propagating constants / objects + * through inclusions matrix. + * + * this might make the same pair appear doubly, if an object + * is declared in type T as well as in some supertype T'. + * such cases will be filtered out in string collection. + */ + for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + fl->next = gorig_constant_list; + gorig_constant_list = fl; + /* now add constant to all supertypes + */ + n = get_type( fl->item->next->item ); + for ( i = 0; i < lnum_types; i++ ) { + if ( i == n || + !m[n][i] ) continue; + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + fl->item->next->item = copy_Token( ltype_names[i] ); + fl->next = gorig_constant_list; + gorig_constant_list = fl; + } + } + for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + fl->next = gorig_constant_list; + gorig_constant_list = fl; + /* now add constant to all supertypes + */ + n = get_type( fl->item->next->item ); + for ( i = 0; i < lnum_types; i++ ) { + if ( i == n || + !m[n][i] ) continue; + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + fl->item->next->item = copy_Token( ltype_names[i] ); + fl->next = gorig_constant_list; + gorig_constant_list = fl; + } + } + + + /* now, normalize all typed-list-of s in domain and problem def, + * i.e., in all PlNode quantifiers and in op parameters + * + * at the same time, remove typed-listof structures in these defs + */ + normalize_tyl_in_pl( &gorig_goal_facts ); + for ( po = gloaded_ops; po; po = po->next ) { + normalize_tyl_in_pl( &po->preconds ); + normalize_tyl_in_pl( &po->effects ); + /* be careful to maintain parameter ordering ! + */ + if ( !po->parse_params ) { + continue;/* no params at all */ + } + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( po->parse_params->name ); + if ( po->parse_params->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = po->parse_params->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( po->parse_params->type->item ); + } + po->params = fl; + p_fl = fl; + for ( tyl = po->parse_params->next; tyl; tyl = tyl->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->next = new_TokenList(); + fl->item->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyl->type->item ); + } + p_fl->next = fl; + p_fl = fl; + } + free_TypedList( po->parse_params ); + po->parse_params = NULL; + } + + + /* finally, build gpredicates_and_types by chaining predicate names + * together with the names of their args' types. + */ + for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->item = copy_Token( tyll->predicate ); + fl->next = gpredicates_and_types; + gpredicates_and_types = fl; + if ( !tyll->args ) continue; + /* add arg types; MAINTAIN ORDERING ! + */ + fl->item->next = new_TokenList(); + if ( tyll->args->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyll->args->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyll->args->type->item ); + } + p_tl = fl->item->next; + for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + if ( tyl->type->next ) { + tmp_tl->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->item, CONNECTOR ); + strcat( tmp_tl->item, tl->item ); + } + } else { + tmp_tl->item = copy_Token( tyl->type->item ); + } + p_tl->next = tmp_tl; + p_tl = tmp_tl; + } + } + + for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { + fl = new_FactList(); + fl->item = new_TokenList(); + fl->item->item = copy_Token( tyll->predicate ); + fl->next = gfunctions_and_types; + gfunctions_and_types = fl; + if ( !tyll->args ) continue; + /* add arg types; MAINTAIN ORDERING ! + */ + fl->item->next = new_TokenList(); + if ( tyll->args->type->next ) { + fl->item->next->item = new_Token( MAX_LENGTH ); + strcpy( fl->item->next->item, EITHER_STR ); + for ( tl = tyll->args->type; tl; tl = tl->next ) { + strcat( fl->item->next->item, CONNECTOR ); + strcat( fl->item->next->item, tl->item ); + } + } else { + fl->item->next->item = copy_Token( tyll->args->type->item ); + } + p_tl = fl->item->next; + for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + if ( tyl->type->next ) { + tmp_tl->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->item, CONNECTOR ); + strcat( tmp_tl->item, tl->item ); + } + } else { + tmp_tl->item = copy_Token( tyl->type->item ); + } + p_tl->next = tmp_tl; + p_tl = tmp_tl; + } + } + + /* now get rid of remaining typed-list-of parsing structures + */ + free_TypedList( gparse_types ); + gparse_types = NULL; + free_TypedList( gparse_constants ); + gparse_constants = NULL; + free_TypedList( gparse_objects ); + gparse_objects = NULL; + free_TypedListList( gparse_predicates ); + gparse_predicates = NULL; + free_TypedListList( gparse_functions ); + gparse_functions = NULL; + +} + + + +void collect_type_names_in_pl( PlNode *n ) + +{ + + PlNode *i; + TypedList *tyl; + TokenList *tl; + char *tmp = NULL; + int nn; + + if ( !n ) { + return; + } + + switch( n->connective ) { + case ALL: + case EX: + for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { + if ( tyl->type->next ) { + tmp = new_Token( MAX_LENGTH ); + strcpy( tmp, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp, CONNECTOR ); + strcat( tmp, tl->item ); + } + } else { + tmp = copy_Token( tyl->type->item ); + } + if ( (nn = get_type( tmp )) == -1 ) { + tyl->n = lnum_types; + ltype_names[lnum_types++] = copy_Token( tmp ); + } else { + tyl->n = nn; + } + free( tmp ); + tmp = NULL; + } + collect_type_names_in_pl( n->sons ); + break; + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + collect_type_names_in_pl( i ); + } + break; + case NOT: + collect_type_names_in_pl( n->sons ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + collect_type_names_in_pl( n->sons ); + collect_type_names_in_pl( n->sons->next ); + break; + default: + break; + } + +} + + + +int get_type( char *str ) + +{ + + int i; + + for ( i = 0; i < lnum_types; i++ ) { + if ( strcmp( str, ltype_names[i] ) == SAME ) return i; + } + + return -1; + +} + + + +void make_either_ty( TypedList *tyl ) + +{ + + TokenList *i; + + if ( lnum_either_ty[tyl->n] > 0 ) { + return; + } + + for ( i = tyl->type; i; i = i->next ) { + leither_ty[tyl->n][lnum_either_ty[tyl->n]++] = get_type( i->item ); + } + +} + + + +void make_either_ty_in_pl( PlNode *n ) + +{ + + PlNode *i; + TypedList *tyl; + + if ( !n ) { + return; + } + + switch( n->connective ) { + case ALL: + case EX: + for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { + make_either_ty( tyl ); + } + make_either_ty_in_pl( n->sons ); + break; + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + make_either_ty_in_pl( i ); + } + break; + case NOT: + make_either_ty_in_pl( n->sons ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + make_either_ty_in_pl( n->sons ); + make_either_ty_in_pl( n->sons->next ); + break; + default: + break; + } + +} + + + +void normalize_tyl_in_pl( PlNode **n ) + +{ + + PlNode *i; + TypedList *tyl; + PlNode *tmp_pl = NULL, *sons, *p_pl; + TokenList *tmp_tl, *tl; + + + if ( !(*n) ) { + return; + } + + switch( (*n)->connective ) { + case ALL: + case EX: + /* we need to make a sequence of quantifiers ( ->sons ...) + * out of the given sequence of TypedList elements, + * with connected type names, var - name in TokenList + * and KEEPING THE SAME ORDERING !! + */ + if ( !(*n)->parse_vars ) { + printf("\n\nquantifier without argument !! check input files.\n\n"); + exit( 1 ); + } + tmp_tl = new_TokenList(); + tmp_tl->next = new_TokenList(); + tmp_tl->item = copy_Token( (*n)->parse_vars->name ); + if ( (*n)->parse_vars->type->next ) { + tmp_tl->next->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->next->item, EITHER_STR ); + for ( tl = (*n)->parse_vars->type; tl; tl = tl->next ) { + strcat( tmp_tl->next->item, CONNECTOR ); + strcat( tmp_tl->next->item, tl->item ); + } + } else { + tmp_tl->next->item = copy_Token( (*n)->parse_vars->type->item ); + } + (*n)->atom = tmp_tl; + /* now add list of sons + */ + sons = (*n)->sons; + p_pl = *n; + for ( tyl = (*n)->parse_vars->next; tyl; tyl = tyl->next ) { + tmp_tl = new_TokenList(); + tmp_tl->next = new_TokenList(); + tmp_tl->item = copy_Token( tyl->name ); + if ( tyl->type->next ) { + tmp_tl->next->item = new_Token( MAX_LENGTH ); + strcpy( tmp_tl->next->item, EITHER_STR ); + for ( tl = tyl->type; tl; tl = tl->next ) { + strcat( tmp_tl->next->item, CONNECTOR ); + strcat( tmp_tl->next->item, tl->item ); + } + } else { + tmp_tl->next->item = copy_Token( tyl->type->item ); + } + tmp_pl = new_PlNode( (*n)->connective ); + tmp_pl->atom = tmp_tl; + p_pl->sons = tmp_pl; + p_pl = tmp_pl; + } + /* remove typed-list-of info + */ + free_TypedList( (*n)->parse_vars ); + (*n)->parse_vars = NULL; + /* the last son in list takes over ->sons + */ + p_pl->sons = sons; + /* normalize this sons and get out + */ + normalize_tyl_in_pl( &(p_pl->sons) ); + break; + case AND: + case OR: + for ( i = (*n)->sons; i; i = i->next ) { + normalize_tyl_in_pl( &i ); + } + break; + case NOT: + normalize_tyl_in_pl( &((*n)->sons) ); + break; + case ATOM: + case TRU: + case FAL: + break; + case WHEN: + normalize_tyl_in_pl( &((*n)->sons) ); + normalize_tyl_in_pl( &((*n)->sons->next) ); + break; + default: + break; + } + +} + + + + + + + + + + + + +/* ADL syntax test - and normalization (AND s etc.) + */ + + + + + + + + + + + + +Bool make_adl_domain( void ) + +{ + + PlOperator *i; + FactList *ff; + + if ( gcmd_line.display_info == 101 ) { + printf("\noriginal problem parsing is:\n"); + printf("\nobjects:"); + for ( ff = gorig_constant_list; ff; ff = ff->next ) { + printf("\n%s : %s", ff->item->item, ff->item->next->item); + } + printf("\n\ninitial state:\n"); + print_PlNode( gorig_initial_facts, 0 ); + printf("\n\ngoal state:\n"); + print_PlNode( gorig_goal_facts, 0 ); + printf("\n\nops:"); + print_plops( gloaded_ops ); + } + + if ( !make_conjunction_of_atoms( &gorig_initial_facts ) ) { + printf("\nillegal initial state"); + return FALSE; + } + + if ( !gorig_goal_facts ) { + gorig_goal_facts = new_PlNode( TRU ); + } + + if ( !is_wff( gorig_goal_facts ) ) { + printf("\nillegal goal formula"); + print_PlNode( gorig_goal_facts, 0 ); + return FALSE; + } + + for ( i = gloaded_ops; i; i = i->next ) { + if ( !i->preconds ) { + i->preconds = new_PlNode( TRU ); + } + if ( !is_wff( i->preconds ) ) { + printf("\nop %s has illegal precondition", i->name); + return FALSE; + } + if ( !make_effects( &(i->effects) ) ) { + printf("\nop %s has illegal effects", i->name); + return FALSE; + } + } + + if ( gcmd_line.display_info == 102 ) { + printf("\nfinal ADL representation is:\n"); + printf("\nobjects:"); + for ( ff = gorig_constant_list; ff; ff = ff->next ) { + printf("\n%s : %s", ff->item->item, ff->item->next->item); + } + printf("\n\ninitial state:\n"); + print_PlNode( gorig_initial_facts, 0 ); + printf("\n\ngoal formula:\n"); + print_PlNode( gorig_goal_facts, 0 ); + printf("\n\nops:"); + print_plops( gloaded_ops ); + } + + return TRUE; + +} + + + +Bool make_conjunction_of_atoms( PlNode **n ) + +{ + + PlNode *tmp, *i, *p, *m; + + if ( !(*n) ) { + return TRUE; + } + + if ( (*n)->connective != AND ) { + switch ( (*n)->connective ) { + case ATOM: + tmp = new_PlNode( ATOM ); + tmp->atom = (*n)->atom; + (*n)->atom = NULL; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + case COMP: + tmp = new_PlNode( COMP ); + tmp->comp = (*n)->comp; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->comp = -1; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + case NOT: + free_PlNode( *n ); + (*n) = NULL; + return TRUE; + default: + return FALSE; + } + } + + p = NULL; + i = (*n)->sons; + while ( i ) { + switch ( i->connective ) { + case ATOM: + break; + case COMP: + break; + case NOT: + if ( p ) { + p->next = i->next; + } else { + (*n)->sons = i->next; + } + m = i->next; + i->next = NULL; + free_PlNode( i ); + i = m; + break; + default: + return FALSE; + } + if ( i->connective != NOT ) { + p = i; + i = i->next; + } + } + + return TRUE; + +} + + + +Bool is_wff( PlNode *n ) + +{ + + PlNode *i; + + if ( !n ) { + return FALSE; + } + + switch( n->connective ) { + case ALL: + case EX: + if ( !(n->atom) || + !(n->atom->next ) || + n->atom->next->next != NULL ) { + return FALSE; + } + return is_wff( n->sons ); + case AND: + case OR: + for ( i = n->sons; i; i = i->next ) { + if ( !is_wff( i ) ) { + return FALSE; + } + } + return TRUE; + case NOT: + return is_wff( n->sons ); + case ATOM: + if ( !(n->atom) || + n->sons != NULL ) { + return FALSE; + } + return TRUE; + case TRU: + case FAL: + if ( n->sons != NULL ) { + return FALSE; + } + return TRUE; + case COMP: + if ( n->sons != NULL || + n->atom != NULL || + n->lh == NULL || + n->rh == NULL || + n->comp < 0 ) { + return FALSE; + } + return TRUE; + default: + return FALSE; + } + +} + + + +Bool make_effects( PlNode **n ) + +{ + + PlNode *tmp, *i, *literals, *j, *k, *next; + int m = 0; + + if ( (*n)->connective != AND ) { + if ( !is_eff_literal( *n ) && + (*n)->connective != ALL && + (*n)->connective != WHEN ) { + return FALSE; + } + tmp = new_PlNode( (*n)->connective ); + tmp->atom = (*n)->atom; + tmp->sons = (*n)->sons; + tmp->neft = (*n)->neft; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->connective = AND; + (*n)->sons = tmp; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->neft = -1; + } + + for ( i = (*n)->sons; i; i = i->next ) { + if ( is_eff_literal( i ) ) { + m++; + continue; + } + if ( i->connective == AND ) { + for ( j = i->sons; j; j = j->next ) { + if ( !is_eff_literal( j ) ) { + return FALSE; + } + m++; + } + continue; + } + if ( i->connective == ALL ) { + for ( j = i->sons; j && j->connective == ALL; j = j->sons ) { + if ( !j->atom || + !j->atom->next || + j->atom->next->next != NULL ) { + return FALSE; + } + } + if ( !j ) { + return FALSE; + } + if ( is_eff_literal( j ) ) { + tmp = new_PlNode( AND ); + for ( k = i; k->sons->connective == ALL; k = k->sons ); + k->sons = tmp; + tmp->sons = j; + j = tmp; + } + if ( j->connective == AND ) { + for ( k = j->sons; k; k = k->next ) { + if ( !is_eff_literal( k ) ) { + return FALSE; + } + } + tmp = new_PlNode( WHEN ); + for ( k = i; k->sons->connective == ALL; k = k->sons ); + k->sons = tmp; + tmp->sons = new_PlNode( TRU ); + tmp->sons->next = j; + continue; + } + if ( j->connective != WHEN ) { + return FALSE; + } + if ( !(j->sons) ) { + j->sons = new_PlNode( TRU ); + } + if ( !is_wff( j->sons ) ) { + return FALSE; + } + if ( !make_conjunction_of_literals( &(j->sons->next) ) ) { + return FALSE; + } + continue; + } + if ( i->connective != WHEN ) { + return FALSE; + } + if ( !(i->sons) ) { + i->sons = new_PlNode( TRU ); + } + if ( !is_wff( i->sons ) ) { + return FALSE; + } + if ( !make_conjunction_of_literals( &(i->sons->next) ) ) { + return FALSE; + } + } + + if ( m == 0 ) { + return TRUE; + } + + tmp = new_PlNode( WHEN ); + tmp->sons = new_PlNode( TRU ); + literals = new_PlNode( AND ); + tmp->sons->next = literals; + tmp->next = (*n)->sons; + (*n)->sons = tmp; + i = (*n)->sons; + while ( i->next ) { + if ( is_eff_literal( i->next ) ) { + next = i->next->next; + i->next->next = literals->sons; + literals->sons = i->next; + i->next = next; + continue; + } + if ( i->next->connective == AND ) { + next = i->next->next; + for ( j = i->next->sons; j && j->next; j = j->next ); + if ( j ) { + j->next = literals->sons; + literals->sons = i->next->sons; + } + i->next = next; + continue; + } + i = i->next; + } + return TRUE; + +} + + + +Bool is_eff_literal( PlNode *n ) + +{ + + if ( !n ) { + return FALSE; + } + + if ( n->connective == NOT ) { + if ( !n->sons || + n->sons->connective != ATOM || + !n->sons->atom ) { + return FALSE; + } + return TRUE; + } + + if ( n->connective == ATOM ) { + if ( !n->atom ) { + return FALSE; + } + return TRUE; + } + + if ( n->connective == NEF ) { + if ( !n->lh || + !n->rh || + n->neft < 0 ) { + return FALSE; + } + return TRUE; + } + + return FALSE; + +} + + + +Bool make_conjunction_of_literals( PlNode **n ) + +{ + + PlNode *tmp, *i; + + if ( !(*n) ) { + return FALSE; + } + + if ( (*n)->connective != AND ) { + if ( (*n)->connective == NOT ) { + if ( !((*n)->sons) || + (*n)->sons->connective != ATOM ) { + return FALSE; + } + tmp = new_PlNode( NOT ); + tmp->sons = (*n)->sons; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + if ( (*n)->connective == NEF ) { + tmp = new_PlNode( NEF ); + tmp->neft = (*n)->neft; + tmp->lh = (*n)->lh; + tmp->rh = (*n)->rh; + (*n)->lh = NULL; + (*n)->rh = NULL; + (*n)->neft = -1; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + if ( (*n)->connective != ATOM ) { + return FALSE; + } + tmp = new_PlNode( ATOM ); + tmp->atom = (*n)->atom; + (*n)->atom = NULL; + (*n)->connective = AND; + (*n)->sons = tmp; + return TRUE; + } + + for ( i = (*n)->sons; i; i = i->next ) { + if ( !is_eff_literal( i ) ) { + return FALSE; + } + } + + return TRUE; + +} + + diff --git a/models/main_models/rt1/gen/ff_planner/parse.h b/models/main_models/rt1/gen/ff_planner/parse.h new file mode 100644 index 000000000..f9924c085 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/parse.h @@ -0,0 +1,63 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: parse.h + * Description: Functions for the pddl parser + * + * Author: Frank Rittinger 1998 / Joerg Hoffmann 1999 + * + *********************************************************************/ + + + + + +#ifndef _PARSE_H +#define _PARSE_H + + + +char *copy_Token( char *s ); +TokenList *copy_TokenList( TokenList *source ); +void strupcase( char *from ); +char *rmdash( char *s ); + + + +void build_orig_constant_list( void ); +void collect_type_names_in_pl( PlNode *n ); +int get_type( char *str ); +void make_either_ty( TypedList *tyl ); +void make_either_ty_in_pl( PlNode *n ); +void normalize_tyl_in_pl( PlNode **n ); + + + +Bool make_adl_domain( void ); +Bool make_conjunction_of_atoms( PlNode **n ); +Bool is_wff( PlNode *n ); +Bool make_effects( PlNode **n ); +Bool is_eff_literal( PlNode *n ); +Bool make_conjunction_of_literals( PlNode **n ); + + + +#endif /* PARSE */ diff --git a/models/main_models/rt1/gen/ff_planner/relax.c b/models/main_models/rt1/gen/ff_planner/relax.c new file mode 100644 index 000000000..dd657ac60 --- /dev/null +++ b/models/main_models/rt1/gen/ff_planner/relax.c @@ -0,0 +1,2756 @@ + +/********************************************************************* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + *********************************************************************/ + + +/********************************************************************* + * File: relax.c + * Description: this file handles the relaxed planning problem, i.e., + * the code is responsible for the heuristic evaluation + * of states during search. + * + * --- THE HEART PEACE OF THE FF PLANNER ! --- + * + * here: linear tasks +=,-=,:= / le / le le + * + * + * Author: Joerg Hoffmann 2000--2002, 2011 + * + *********************************************************************/ + + + + + + + + + +#include "ff.h" + +#include "output.h" +#include "memory.h" + +#include "expressions.h" + +#include "relax.h" +#include "search.h" + + + + + + + +/* local globals + */ + + + + + + + + +/* fixpoint + */ +int *lF; +int lnum_F; +int *lE; +int lnum_E; + +int *lch_E; +int lnum_ch_E; + +int *l0P_E; +int lnum_0P_E; + + + + + +/* 1P extraction + */ +int **lgoals_at; +int *lnum_goals_at; + +float **lf_goals_c_at; +Comparator **lf_goals_comp_at; + +int lh; + +int *lch_F; +int lnum_ch_F; + +int *lused_O; +int lnum_used_O; + +int *lin_plan_E; +int lnum_in_plan_E; + + +/* helpful actions numerical helpers + */ +Comparator *lHcomp; +float *lHc; + + + + + + + + + + + + + + + + + + + + +/************************************* + * helper, for -1 == INFINITY method * + *************************************/ + + + + + + + + + + + + +Bool LESS( int a, int b ) + +{ + + if ( a == INFINITY ) { + return FALSE; + } + + if ( b == INFINITY ) { + return TRUE; + } + + return ( a < b ? TRUE : FALSE ); + +} + + + +Bool FLOAT_LE( float a, float b ) + +{ + + if ( b == INFINITY ) { + return TRUE; + } + + if ( a == INFINITY ) { + return FALSE; + } + + return ( a <= b ? TRUE : FALSE ); + +} + + + + + + + + + + + + + + +/*********************************** + * FUNCTIONS ACCESSED FROM OUTSIDE * + ***********************************/ + + + + + + + + + + + + + + + + + +int get_1P( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + } else { + h = INFINITY; + } + + reset_fixpoint( max ); + + return h; + +} + + + +int get_1P_and_H( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + collect_H_info(); + } else { + h = INFINITY; + } + + reset_fixpoint( max ); + + return h; + +} + + + +int get_1P_and_A( State *S ) + +{ + + int max, h; + Bool solvable; + + gevaluated_states++; + + solvable = build_fixpoint( S, &max ); + + if ( gcmd_line.display_info == 126 ) { + print_fixpoint_result(); + } + + if ( solvable ) { + h = extract_1P( max ); + } else { + h = INFINITY; + } + + collect_1P_and_A_info(); + reset_fixpoint( max ); + + return h; + +} + + + +void collect_1P_and_A_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_1P_and_A_info"); + } + + for ( i = 0; i < gnum_A; i++ ) { + gop_conn[gA[i]].is_in_A = FALSE; + } + gnum_A = 0; + + for ( i = 0; i < lnum_E; i++ ) { + if ( gef_conn[lE[i]].level != 0 ) break; + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; + gA[gnum_A++] = gef_conn[lE[i]].op; + } + +} + + + +void get_A( State *S ) + +{ + + int i; + + initialize_fixpoint( S ); + + for ( i = 0; i < lnum_F; i++ ) { + activate_ft( lF[i], 0 ); + } + for ( i = 0; i < lnum_0P_E; i++ ) { + if ( gef_conn[l0P_E[i]].in_E ) { + continue; + } + new_ef( l0P_E[i] ); + } + for ( i = 0; i < gnum_fl_conn; i++ ) { + activate_fl( i, 0 ); + } + + collect_A_info(); + + /* 0 should be enough here... + */ + reset_fixpoint( 1 ); + +} + + + +void collect_A_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_A_info"); + } + + for ( i = 0; i < gnum_A; i++ ) { + gop_conn[gA[i]].is_in_A = FALSE; + } + gnum_A = 0; + + for ( i = 0; i < lnum_E; i++ ) { + /* levels are not set unless we actually build the RPG! +/* if ( gef_conn[lE[i]].level != 0 ) break; */ + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; + gA[gnum_A++] = gef_conn[lE[i]].op; + } + +} + + + +void get_A_axioms( State *S ) + +{ + + int i; + + initialize_fixpoint( S ); + + for ( i = 0; i < lnum_F; i++ ) { + activate_ft( lF[i], 0 ); + } + for ( i = 0; i < lnum_0P_E; i++ ) { + if ( gef_conn[l0P_E[i]].in_E ) { + continue; + } + new_ef( l0P_E[i] ); + } + for ( i = 0; i < gnum_fl_conn; i++ ) { + activate_fl( i, 0 ); + } + + collect_A_axioms_info(); + + /* 0 should be enough here... + */ + reset_fixpoint( 1 ); + +} + + + +void collect_A_axioms_info( void ) + +{ + + static Bool first_call = TRUE; + + int i; + + if ( first_call ) { + gA_axioms = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); + gnum_A_axioms = 0; + first_call = FALSE; + } + + if ( gcmd_line.debug ) { + printf("\ncollect_A_axioms_info"); + } + + for ( i = 0; i < gnum_A_axioms; i++ ) { + gop_conn[gA_axioms[i]].is_in_A_axioms = FALSE; + } + gnum_A_axioms = 0; + + for ( i = 0; i < lnum_E; i++ ) { + /* levels are not set unless we actually build the RPG! +/* if ( gef_conn[lE[i]].level != 0 ) break; */ + if ( gcmd_line.debug ) { + printf("\ngot applicable op: "); + print_op_name(gef_conn[lE[i]].op); + } + if ( gop_conn[gef_conn[lE[i]].op].is_in_A_axioms ) { + if ( gcmd_line.debug ) { + printf(" -- already in, skipping it!"); + } + continue; + } + if ( !gop_conn[gef_conn[lE[i]].op].axiom ) { + if ( gcmd_line.debug ) { + printf(" -- no axiom, skipping it!"); + } + continue; + } + if ( gcmd_line.debug ) { + printf(" -- adding it!"); + } + + gop_conn[gef_conn[lE[i]].op].is_in_A_axioms = TRUE; + gA_axioms[gnum_A_axioms++] = gef_conn[lE[i]].op; + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +/******************************* + * RELAXED FIXPOINT ON A STATE * + *******************************/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Bool build_fixpoint( State *S, int *max ) + +{ + + int start_ft, stop_ft, start_ef, stop_ef, i, time = 0; + float costlevel; + + initialize_fixpoint( S ); + + start_ft = 0; + start_ef = 0; + while ( TRUE ) { + if ( gcmd_line.debug ) { + printf("\n======================================FP time %d", time); + } + + if ( all_goals_activated( time ) ) { + break; + } + if ( time > 0 || lnum_0P_E == 0 ) { + if ( start_ft == lnum_F ) { + if ( fluents_hopeless( time ) ) { + /* fixpoint, goals not reached + */ + *max = time; + return FALSE; + } + } + } + /* make space if necessary, and copy over + * info from time to time+1 for fluents + */ + extend_fluent_levels( time ); + for ( i = 0; i < gnum_fl_conn; i++ ) { + if ( gfl_conn[i].def[time] ) { + gfl_conn[i].def[time+1] = TRUE; + gfl_conn[i].level[time+1] = gfl_conn[i].level[time]; + } + } + + /* determine the next effect layer: + * - activate the facts + * - if level 0 activate the no preconds-ops + * - activate the fluents at their ;UFhfQoG<2!dn0!_Zi=71_+$Qc literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json new file mode 100644 index 000000000..3fd08680a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan206-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "KeyChain", + "Television", + "Window", + "Bowl", + "GarbageCan", + "CreditCard", + "TVStand", + "Cabinet", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json new file mode 100644 index 000000000..6a7f82072 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan206-openable.json @@ -0,0 +1,122 @@ +{ + "ArmChair|+02.34|+00.00|-02.04": [ + 1.5, + -2.0, + 90, + 30 + ], + "Cabinet|-01.83|+00.73|-02.36": [ + -0.75, + -1.75, + 270, + 30 + ], + "CoffeeTable|+00.02|00.00|-01.11": [ + 0.25, + -1.75, + 0, + 30 + ], + "GarbageCan|+00.74|00.00|-02.52": [ + 1.25, + -2.0, + 270, + 30 + ], + "Shelf|+00.34|+00.27|-02.38": [ + 1.0, + -1.25, + 270, + 30 + ], + "Shelf|+00.34|+00.47|-02.38": [ + 1.0, + -1.25, + 270, + 30 + ], + "Shelf|+00.34|+00.64|-02.38": [ + 1.0, + -1.0, + 180, + 0 + ], + "Shelf|-00.39|+00.30|-02.38": [ + -1.0, + -1.25, + 90, + 30 + ], + "Shelf|-00.39|+00.60|-02.38": [ + -1.0, + -1.0, + 180, + 0 + ], + "Shelf|-01.73|+00.28|-01.63": [ + -1.0, + -1.25, + 270, + 30 + ], + "Shelf|-01.73|+00.30|-00.48": [ + -0.5, + 0.25, + 180, + 30 + ], + "Shelf|-01.73|+00.45|-01.06": [ + -0.75, + -0.5, + 180, + 30 + ], + "Shelf|-01.73|+00.48|-01.63": [ + -0.25, + -1.75, + 270, + 0 + ], + "Shelf|-01.73|+00.60|-00.48": [ + -0.75, + 0.0, + 180, + 30 + ], + "Shelf|-01.73|+00.65|-01.63": [ + -0.5, + -1.75, + 270, + 0 + ], + "Shelf|-01.83|+01.45|-02.36": [ + -0.75, + -1.75, + 270, + -30 + ], + "Shelf|-01.83|+02.04|-02.36": [ + -0.75, + -1.75, + 270, + 0 + ], + "Sofa|+00.12|+00.01|+01.03": [ + -0.5, + 0.25, + 0, + 30 + ], + "TVStand|-00.03|00.00|-02.39": [ + 0.0, + -1.75, + 180, + 30 + ], + "TVStand|-01.73|00.00|-01.06": [ + -1.0, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan207-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a0929c7eba7ca9916298aef2062af25a96cebc6a GIT binary patch literal 2352 zcmbW(txhvR6b9gh5JCtSv2G!$0Spk5R^cER1d24!20?(d1VgwAE~vM#mw-gBs6Zh2 z+4GDzlA6ggbI#0r*iU?KXBVgEmn+qC_0rr-=GU|4sBVs@2hE^vrVq2H+4%nIVRke5 z-9H)M%_l$m^V{*`4(XXGeek8vS(|K~2yiEQ~_TF;Q z-|Ibok9}^F`>v`g=W##F%OB~yOO{u?ylj;_ukzcMpWDdK@^c$`SbmnDyHvkSmS4Sm zR{6M%d@LW!$MUg!EFa6q^08H}yvk=^K9-N=WBFJ<_I`OM{+_I#^|StxEBaYK>u3FC z4)4dR-?@I)U*?WJ*3bG`f3D-a>M#3?eiHlcWp$ia?=Mqs*3bGmul{}6cfWn#o!iLI zz6-aJi_ORKv3x8C=T-ezyrZ7gv-)b(CsohtS^a9NXZ6ML_gGV(?7ngyx!HZi(Z8PV zWB0Ln*nP!u-$uHRyL9gRJNNy$P4!j$%K5P0VBep8e>M-Bhs{$Q?{B7g*gR|=HV>PJ h&BJZX!{%Z0u>TiqrF<+O%g6Gud@LW!$MS8Bz5%}cShoNG literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json new file mode 100644 index 000000000..96571469e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan207-objects.json @@ -0,0 +1,27 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Cabinet", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json new file mode 100644 index 000000000..3c460de3b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan207-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|+00.40|+00.01|+02.19": [ + 0.5, + 1.5, + 0, + 30 + ], + "ArmChair|-00.63|+00.01|+02.19": [ + -0.75, + 1.5, + 0, + 30 + ], + "Cabinet|-01.77|+00.73|-01.59": [ + -1.0, + -1.25, + 270, + 30 + ], + "CoffeeTable|-00.15|+00.00|+00.42": [ + -0.75, + 0.5, + 90, + 30 + ], + "Shelf|+01.66|+00.27|+00.61": [ + 0.5, + 0.0, + 0, + 30 + ], + "Shelf|+01.66|+00.30|-00.12": [ + 0.5, + 0.5, + 180, + 30 + ], + "Shelf|+01.66|+00.44|+00.24": [ + 0.5, + 0.75, + 180, + 30 + ], + "Shelf|+01.66|+00.47|+00.61": [ + 0.5, + 0.0, + 0, + 30 + ], + "Shelf|+01.66|+00.60|-00.12": [ + 0.75, + -0.5, + 0, + 30 + ], + "Shelf|+01.66|+00.64|+00.61": [ + 0.75, + 0.25, + 0, + 30 + ], + "Shelf|-01.77|+01.45|-01.59": [ + -1.0, + -1.5, + 270, + 30 + ], + "Shelf|-01.77|+01.74|-01.59": [ + -0.75, + -1.5, + 270, + 30 + ], + "Shelf|-01.77|+02.04|-01.59": [ + -1.0, + -1.5, + 270, + 0 + ], + "SideTable|-01.57|00.00|+01.82": [ + -1.25, + 2.5, + 180, + 30 + ], + "Sofa|-01.45|+00.01|+00.42": [ + -0.75, + 0.5, + 270, + 30 + ], + "TVStand|+01.67|00.00|+00.24": [ + 1.0, + 0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan208-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..70465ddc524364501d653330bac2ce093f8ef854 GIT binary patch literal 3376 zcmbW&u}U0a6vgo`K}19(<_V^o1hx=uBm~wfUBo6us<6bB6hUP-qzQS7Jdi%ZJc6a= z6jN-mg=Y8r340(-rn&s@eD|DlXJ>c+oPGLu{`p1uS$?$_)A`p~`>tu)^&t3F@XO#5 zyu2-|>tDL`Rr;7drjO}kl}=WA`t&e8OmDyLrH|=hdYB%jw-#nRW`j|fUoG~4oRUUnLusqn_=ICSRa8~;I z^zr?8y(gw`jy`q{XQi*dsNY9?AKX>{=lj7A!F})$ya<+GF8MKEoK=4P;dcGJa3A~- zY+vWQxW85_#eMr?`(pdz#dtH1{p7YEex9p2^i}&|`(gWG`(gWG`LX<1ek`vX@?z(3 zR(bX1#qwf#usm2Ey7FLousNJn9({Q*f6U(;f6O2A$8>O3{`y^gFED@S_+$Q*t|QU!Oki>Um5b)4^GX znCGWI)aQ-6dLHw`{4hV9)%(Awy8JPJ%pdc|{4sybANxI6R{v$)7t4d?!RE{9`b{#A J&13WB^brgf0D%Ai literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json new file mode 100644 index 000000000..0bee20c25 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan208-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "GarbageCan", + "CreditCard", + "Ottoman", + "TVStand", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "Shelf", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json new file mode 100644 index 000000000..ef1237543 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan208-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|-00.56|+00.00|+01.95": [ + 0.25, + 1.5, + 270, + 30 + ], + "DiningTable|-03.10|+00.00|-03.61": [ + -2.25, + -3.5, + 270, + 30 + ], + "Drawer|+01.76|+00.77|+01.09": [ + 0.75, + 1.25, + 90, + 0 + ], + "GarbageCan|-01.34|+00.02|-04.83": [ + -2.0, + -4.5, + 90, + 30 + ], + "Ottoman|-00.58|+00.01|+01.05": [ + -1.25, + 1.75, + 180, + 30 + ], + "Shelf|-00.61|+00.88|-02.83": [ + -0.5, + -2.0, + 180, + 30 + ], + "Shelf|-00.61|+01.32|-02.83": [ + -0.5, + -2.0, + 180, + 30 + ], + "Shelf|-02.24|+00.27|+00.40": [ + -1.0, + -0.25, + 0, + 30 + ], + "Shelf|-02.24|+00.30|+01.13": [ + -1.0, + 0.5, + 0, + 30 + ], + "Shelf|-02.24|+00.44|+00.76": [ + -1.25, + 1.25, + 180, + 30 + ], + "Shelf|-02.24|+00.47|+00.40": [ + -0.75, + 0.5, + 270, + 0 + ], + "Shelf|-02.24|+00.60|+01.13": [ + -1.25, + 1.5, + 180, + 30 + ], + "Shelf|-02.24|+00.64|+00.40": [ + -1.25, + 0.75, + 180, + 30 + ], + "SideTable|+01.83|+00.00|+01.09": [ + 1.25, + 1.25, + 90, + 30 + ], + "Sofa|+00.88|+00.01|-00.59": [ + -0.25, + -0.5, + 90, + 30 + ], + "TVStand|-02.24|00.00|+00.76": [ + -1.5, + 1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan209-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e0abd893f321db939292b31685e32617dbd38425 GIT binary patch literal 4816 zcmbW)Juh=%7{KvEq>)C%`}@n;4oRn45VMU~3?@0z(-=hMR4n3C_(1hhIvNcIgF)5( zTdtAi;7M~PhZb3&n~VevZw61=v4iix;V~@lkQ>B%8PEVeyq#;>t5Zde(#@_ zcl~N~zkgdkR3q=Tj}BUSd%u;xPW1+NCL1b+>(@t2>sl^$P6 z*Uezh?{Ux1o}WEGdwyOHKi_@V`SAE$@NDo*a5H#1xDh-RJQuFpu98k2@#Ft9`j|Uu<7&Uu<982=myN$L)*l zi|vc;i|vc;%Q@_e?ThV;?ThV;?ThV;?ThV;?ThV;^<{loU)GoPWqny+)|d5VeOX_> z7y7cktS{@!`m(;PFYC+tvc9Y@>&yDGzN|0n%lfjutS{@!`m$c;)Qk0Ey;v{Si}hl? zSTBxOz1-J}^6oV!c=|*27$SupX=j>%n@k9_)EJUd`{m`PuwzejUxv=4bP> z`PuwzUiQ3fUN$eAm(6R>=4JD;dD*;dUN$eAm(9!OW%IIm{T`Z^&CBLx^Rju_ylh@J zFPoRm%jWfWVqP{co0rYY=4JD;dD*;dUN$d#ee!o~el|awpUuzaXY;f9+5BvNHb0x6 zy`TAa-p|x^=7?U&tdAVAM3~Z Rv3{%{n~%-M=40~>2S4)mgUSE^ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json new file mode 100644 index 000000000..de861c186 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan209-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "WateringCan", + "Dresser", + "Drawer", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Shelf", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json new file mode 100644 index 000000000..79c456774 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan209-openable.json @@ -0,0 +1,62 @@ +{ + "ArmChair|-04.33|+00.00|-03.53": [ + -4.0, + -4.25, + 0, + 30 + ], + "CoffeeTable|-02.47|+00.00|-02.49": [ + -1.75, + -2.5, + 270, + 30 + ], + "Drawer|-02.98|+00.17|-05.01": [ + -3.75, + -4.5, + 90, + 30 + ], + "Drawer|-04.02|+00.17|-05.01": [ + -3.25, + -4.5, + 270, + 30 + ], + "Dresser|-03.51|+00.00|-05.10": [ + -3.25, + -4.5, + 180, + 30 + ], + "GarbageCan|-00.97|-00.03|-05.06": [ + -1.5, + -4.75, + 90, + 30 + ], + "Shelf|-02.48|+00.12|-02.49": [ + -1.5, + -2.5, + 270, + 30 + ], + "SideTable|-02.02|+00.00|-05.08": [ + -2.5, + -4.5, + 90, + 30 + ], + "SideTable|-05.43|+00.00|-05.12": [ + -6.25, + -4.5, + 180, + 30 + ], + "Sofa|-04.36|+00.01|-02.09": [ + -3.5, + -2.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan21-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..762df682bbf580e2ff5a25f678c95c1078234285 GIT binary patch literal 1584 zcmbW#u}Z^G6b9g{h)ACzTNJYBq#|^4Q(PRJq}Y@WVkHq5@hN;D`v`f2j*b}|92~6X zeu!r@LoeS+&-qW%zMNm4U0iLX$MjTA>-MH8kBjnTc34(LIa@Rj&E)QS(M;>_`sw7h zt=IK-KDn>g-aXo{ii5qXcrN~XjndE6y$26WT6c9uN&*Y|bad47gQyj!fA}-=n_&~jn;3IVG zn4v?54%TzeXYfCImhkCK?!CY7&|h!gy*Yk=Cw)&p7AKqC$L-=pw|IH_e6j2nr)S%5 z+x3?ZXWNs_-@m_Jf8K3w|GxXQ{<^vKlhw1;vRge}c0arSJd;$;!+!Yu{c8Ap5PT4P zKlpL=Mg9Fzu=~62{_OtjewX2X{HWfa4}(3=b^-93h%?-hrJJbAND>xt^IfsJPvMyN5T8L&;9IUd#=MCwukLud)OYfhwWi| z*dDfr?O}V^o|~|T?O}V^9=3<=VSCsfwukLud)OYfC*@SmQ9pdLJ!}u#!}hQ}Y!BPR zZFv4D*dE`vhwW){D#sqShwWi|*dF%(i~WD(dwnX0?*`96oV!c=|){FIGy;v{Si`#zK$$D`UuBYIe^M8MT9efq6 zzx(UY`nP$wul}q*>(BbL{;WUi&-%0etUv3|`m_G5Kezp`llA8&T-V=q{aJt3pY><` zS^se!-b;VhpY><`S%21_^=JKAf7YM%=V|T5`m_GrhVSd|dK0ee@4Ei1KkLu>v;M6A zB&TxpXZ=}!)}Qrf{aJt3pY><`c~<-IG+2Mv_2)KxUw_y2XZ=}!)}Qrf{aJt3f0|P{ z`m_G5KkLu>v;M3<>(BbL{yeMwSbx@^$Km^Ju>QWUKkLu>v;M3<>(BbL{<`S%21_^=JKAf1cF7tQYIWda+)t7wa_-y;v{Si}hl?_@KT&>&1GpUaS}E O#d@**Y(LvS&wl_7N|d$$ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json new file mode 100644 index 000000000..bae18ef7d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan210-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "Ottoman", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "Dresser", + "Chair", + "DogBed", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json new file mode 100644 index 000000000..d38e8c23d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan210-openable.json @@ -0,0 +1,98 @@ +{ + "ArmChair|-04.38|+00.01|+01.40": [ + -3.5, + 1.5, + 270, + 30 + ], + "Drawer|-00.36|+00.21|+03.80": [ + -1.5, + 3.25, + 0, + 30 + ], + "Drawer|-00.36|+00.21|+04.22": [ + -1.5, + 3.5, + 0, + 30 + ], + "Drawer|-00.36|+00.58|+03.79": [ + -1.25, + 3.25, + 0, + 30 + ], + "Drawer|-00.36|+00.59|+04.22": [ + -1.25, + 3.75, + 0, + 30 + ], + "Drawer|-02.29|+00.27|+04.11": [ + -1.75, + 3.5, + 0, + 30 + ], + "Drawer|-02.29|+00.75|+04.11": [ + -1.75, + 3.5, + 0, + 30 + ], + "Drawer|-02.83|+00.27|+04.11": [ + -2.25, + 3.25, + 270, + 30 + ], + "Drawer|-02.84|+00.75|+04.11": [ + -2.25, + 3.5, + 0, + 30 + ], + "Dresser|-00.27|+00.00|+04.01": [ + -0.75, + 4.0, + 90, + 30 + ], + "Dresser|-02.56|+00.01|+04.22": [ + -3.5, + 4.0, + 90, + 30 + ], + "Ottoman|-01.77|+00.00|+01.81": [ + -1.0, + 1.25, + 270, + 30 + ], + "SideTable|-00.25|+00.00|+02.10": [ + -0.75, + 3.0, + 90, + 30 + ], + "SideTable|-04.29|+00.01|+00.41": [ + -4.75, + 0.25, + 90, + 30 + ], + "SideTable|-06.72|+00.01|+00.00": [ + -6.25, + 0.5, + 180, + 30 + ], + "Sofa|-02.52|+00.01|+00.26": [ + -2.5, + 1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan211-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2bf7794512207ebc0a5eccdf4735e852efdff612 GIT binary patch literal 2240 zcmbW&F-ikL6b9fGL?n2K?N%X;u@MoH%1*Jdu##XBEW}76HsUEfP_8gXNSShrEmEW~ zy7L8mrD?`*XZF4S?PBtEb9a4vzgN5$AJu3)f1FhpWpz0@uexP5naiakGI$7Ps7*o*2kx3y>8h%>6V}6KR=z~_p@BI>n5)$xZN#^-G2Y?`DJjO?_cM2 z6|A3q{a8OvxjyU1tFT`OH^J-R{XyGNy@O!$G>i6}dDuK`9&Ya{3QoB{n}^NAbvSPx z`{vqxvn0o$Leuh)vLq* zEvv`samw?tx5G)@yqd$lJly1Zjr)S-u`dtH!}72^EDy`WzOUl6(8w)E#1Y%*tfUz;2!UN$EI07Xl#TFD4 z{_H#?eu<6SjL+=PygQhEzr4PEQ8pG98Y- z=g$WZv(eZ5?0)bx`trf?QMZ$y9Cq@z{GUfF`#JVMs&O^1#&&QkxEb6Ct_RnGv*2x7 z*ZP}aeaq0t`dA+~(t50q^|3zI$NIQTUA+Foi|}6TK8|CSj@^8(n&4&dI=Bqp1aE`0 z{_p44g6qMJ;AU_u*zcUB!~3)M;y5l+uX*p!t8iYg^Lkk?>*aReU)88zhkn-2?&dh^ zH?N=dvwqgk`dL5gx2}HH&-&SOIF9u3F}pY^kT*1ub4o_?3`f9$+|*3Y}=ru)qs z^|OA~&-z(E>tCn!>_6Lo*3XM{AM0o9a2(5Uzwd$Td=J?7fNTA#i0u#CAGSYif7t%8 M{n6=qc756V1VFa#_6Y@zY07o?RFp$EVfH!{Zl6t9y&p{a5>|y~XO)yQ2?B z2XCLhJ9>F|`u@X%H^+x3?;pQDcz<}3ckk}+?=9}$+FN{H{O7SVPLIvC_1WwA`E~nx z{e0e39yf|FX8tkfub$7F%41o)^3Z2qFa2C!AG~t<;rg1tS?gCGtKyw+o#*5B`Mjw- z?i8;)_KJ7r@B8$-oafKHsT_YepXT|(E5{$spLxFU%JGNuXMVT(S04PDuN>bv->%Ou zUOB#TzGc3@mG7D38|N3VJov>c$2ZQm>+_3Oj&GcA^ZeqK;~VGOJimD5>~EZJ^Zerc zj(OO>GsZ8@Ctf*zaemG7iB}$c;+5kU=hyZ5#4E=y&aZhs@yhXw^J|`8oZoK`w(l(0 z+t-=n7v~eN9KSff=J~`c$1l#Wc|P&VgHOD2{Nnt&KA(8y_;o&C-?#qaYvzB?*U9<9 z^)p{NeQ|xw>xWlPU+3%lqx#OAzPP@)et6~d#q~9>A6_|qov-iD>N|7#;`-wH;g!=D z*Vnv$c;)oPeV%@8`wsnQ-c(M1Tz~WW;+4}M*WbLpc;)oR_5WS{XHI`yU%Yaj2e{{f z?DOk-?hmh=`^DX_dH07`&i&%<_fOsL%(-9O{o$2!zqtD~?|Fw;&hroV{4>uNUOCS{ zoImq?;g$1y3Fpte?-SYY`LQ0S$ENb&7q2{)>(jB5V}15FzGu$o1Lqs(7q6V(OE}-= z`Nb>$`#zuj_%_e4`O4X^IN#>^#VcpOI)Ab4F)q$NmE#-dd*=AYm+NtMT%51`&b+Cd z{f+Z&o?pCj_BYPAd4BQA+21(d=J~}dXMf{-o43DlelM-Z*}><``F|B(&hzlf+0Qt? z=C9X$(zublmi^J|_@ymIz4&aZhs@yglHINvhgm!}85XO3^#`p&l=UODUI z);I6>v26V-+df%ew*Ji7U%2&g>*1C2|0b@Ftk2HuWBr-4K5l*7dU)lmk6V9d{TFzm B*Y5xT literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json new file mode 100644 index 000000000..56f6f2380 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan213-objects.json @@ -0,0 +1,27 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Book", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Shelf", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json new file mode 100644 index 000000000..d5835af4b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan213-openable.json @@ -0,0 +1,146 @@ +{ + "ArmChair|+08.22|+00.01|-00.08": [ + 8.75, + -0.25, + 270, + 30 + ], + "ArmChair|+08.23|+00.01|+00.77": [ + 8.75, + 1.5, + 180, + 30 + ], + "ArmChair|+09.50|+00.00|+03.27": [ + 9.25, + 2.5, + 0, + 30 + ], + "CoffeeTable|+10.82|-00.01|+00.93": [ + 11.25, + 0.25, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+00.56": [ + 13.0, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+01.07": [ + 13.0, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+01.58": [ + 13.0, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.17|+02.10": [ + 13.0, + 1.5, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+00.56": [ + 13.25, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+01.07": [ + 13.25, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+01.58": [ + 13.25, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.37|+02.10": [ + 13.0, + 2.75, + 180, + 30 + ], + "Drawer|+14.18|+00.58|+00.56": [ + 13.25, + 0.0, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+01.07": [ + 13.25, + 0.5, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+01.58": [ + 13.25, + 1.0, + 0, + 30 + ], + "Drawer|+14.18|+00.58|+02.10": [ + 13.25, + 1.5, + 0, + 30 + ], + "Dresser|+14.33|+00.00|+01.32": [ + 13.5, + 1.25, + 90, + 30 + ], + "Shelf|+10.79|+00.23|+00.93": [ + 10.5, + 1.75, + 180, + 30 + ], + "SideTable|+11.38|+00.00|-01.16": [ + 10.75, + -0.5, + 90, + 30 + ], + "SideTable|+12.31|+00.00|-01.15": [ + 12.75, + -0.5, + 180, + 30 + ], + "SideTable|+14.33|+00.00|+00.07": [ + 13.5, + -0.5, + 0, + 30 + ], + "SideTable|+14.33|+00.00|+02.59": [ + 13.75, + 2.75, + 90, + 30 + ], + "SideTable|+14.62|00.00|-00.78": [ + 14.0, + -0.25, + 180, + 30 + ], + "Sofa|+11.45|+00.00|+03.21": [ + 11.5, + 2.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan214-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7de05a61f39ff149a9a2e2eac6cf891cf5255895 GIT binary patch literal 3024 zcmbW$y>1gh6b8^?WsM@sitO;8%AG-S6RHRyWhy!l4Fwglh$9L_kb`ItPr(B*k3vaF zLE$0=VP{TrOQu;J@7=xMm)PH5zJBrQ&8_q$eO;YzuiouePnWA_7pJTBa&>XJ`@GwH ze0#Y&-~Rjj`R2pb_U7}e_nS}K8$UWZJy|cGJYFxqE&uaO(|BgJUH510It@Mu&cT!5 zAvgtJ|48GpZy)?8_;>KH;GecjeQu5FGd!TPwb59`DG-iP&JeOMpXhxHjs%c&3R!?~vM45eKswOxnOueD#h^%=VL zVSQL1)`#_B`6nffM}C%{b8T}hKl^`h3iI;2FF(uA^0U0Tv>fuXyqx=fmY0WcKLyKc zUS5`$v^aB{hnvfv-w$=XY*|SFwC=gHa`#ZY@W?8!aSR2 z^G9Kx&GS)BzE1 zSzeZxy*?y_G9^2K9-N=WBJ(MZ?-4r zO`C)DVSQNsT-w*k&+@bUEI-T7^0WNx^ND>vvCk*gm-D90&7I(b;1p~hueT4|r(06< z*oW=I_F?<5eb_#1AGQzoYksy5+lO=be)~AL58H?B!}ei&^h#%;o+pyp?NSRa;`O9G zLtd7b&q`{ZX}yp2XZ?8;zF&Xm`m_G5KkLsqyubd=^=JKAf7YM+R#*K5QSh58H?B!#Uh%ALsUA`>=i3K5QSh&%=_M$3AQyp45D7AGQzM zhwa1mVf(OsIEVY~-MAGQzMhxLC{QuFA~`m_G5KkLu>v;M3<>(6=9=3@O>f7YM% zXZ_iq57z&2Y46pa^=JKAf7YM%XZ=}!&YLy|>(BbL{;WUi&-$~zPfB~QzN|0n%kE?M fvHRH1r`XS@Sf1mMhvi}SvHRG4>^}DM#pCi9x@2HO literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json new file mode 100644 index 000000000..60b621433 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan215-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Pillow", + "Statue", + "Box", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "Bowl", + "GarbageCan", + "CreditCard", + "WateringCan", + "DeskLamp", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ShelvingUnit", + "CoffeeTable", + "Shelf", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json new file mode 100644 index 000000000..69e837fe8 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan215-openable.json @@ -0,0 +1,92 @@ +{ + "CoffeeTable|-02.49|+00.02|+04.04": [ + -3.25, + 4.0, + 90, + 30 + ], + "CoffeeTable|-05.56|+00.02|+06.83": [ + -5.25, + 6.0, + 0, + 30 + ], + "Shelf|-00.59|+00.25|+02.00": [ + -1.75, + 2.5, + 90, + 30 + ], + "Shelf|-00.59|+00.25|+05.98": [ + -1.5, + 5.75, + 90, + 30 + ], + "Shelf|-02.85|+00.47|+07.17": [ + -2.75, + 6.5, + 0, + 30 + ], + "Shelf|-02.85|+00.90|+07.17": [ + -2.75, + 6.25, + 0, + 0 + ], + "Shelf|-02.86|+00.16|+07.17": [ + -4.5, + 6.25, + 90, + 30 + ], + "Shelf|-02.87|+01.29|+07.17": [ + -3.0, + 6.5, + 0, + 0 + ], + "Shelf|-05.95|+00.16|+04.34": [ + -5.25, + 4.5, + 270, + 30 + ], + "Shelf|-05.95|+00.47|+04.34": [ + -5.25, + 4.25, + 270, + 30 + ], + "Shelf|-05.95|+00.90|+04.34": [ + -5.0, + 4.25, + 270, + 0 + ], + "Shelf|-05.95|+01.29|+04.35": [ + -5.25, + 4.75, + 270, + 0 + ], + "SideTable|-00.59|+00.01|+02.00": [ + -1.25, + 2.25, + 90, + 30 + ], + "SideTable|-00.59|+00.01|+05.98": [ + -1.25, + 6.25, + 90, + 30 + ], + "Sofa|-00.77|+00.02|+03.92": [ + -1.5, + 3.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan216-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..c199eae736d2c19c6344eab8dd577dcd539bc5ce GIT binary patch literal 2560 zcmbW&F-j{@6oBDTBuEg^9ZWY0X%qwz!Ol*xv9OY05-da|5gTz8E+{S`OGue=iYZc9 z7?bm*IHl7J-yPn$bAN}Iuj|{Zo4bwTz4)kl{n5j)IxDO5!D-bgtHI0gZPoF_7^@lIyvr?$A_Krv;61PE|ypOdv$Ncowt%VlZ)h^ak0F1V|^ap zNjBf}?ex5ryccfLd^VrWXY<*7-jDfp%(ovq58IFJ$M$3UvHfQ0JZwIj&*roFJijQG z7u#%!if^L-NMu)aENQScuH{T z-a|jukM(2ySU=W}^<(|G9$%y;v{Si}hl??9=*QJz>3AFV>6oV!gPDKCBn(#d@(` z>>Ql$dRf&1GpUaS}E#m>d~u9x*XI~`74!b*ZBScpm@HsVw41DVIMwAdm= zigoYI*Zk$)CVZKA?l~d&`{(74Usng|CB4?S%gxQYKC9~U)oDGe>eb`=dA)eJeq7%! z|Gj^)xZf6QRr8}+^;Z4o8K!a$x9#ihd;2;L9t97B2f;bGAKVL0 z!Ta}Ajy}8KKf(I%Lx0wv^=JJ#cYRoY)}Qrf{dw2*W&K(I)RfuD_s{yX{_H+>AG?p; z*9-Tt``CRfpXIasev`_vhvl<;me2B8eh&F8pXIZBme2ABA)n>5e3sAhS^hBO^JtsO zVfpO$$~k<#AKVL0!G1sT^k@B9|52058FzWCKkLtf@cA69zt8K>`m_G5KkLu>kDFAE z{;WUi&x5Wn=V1Lk*Pr!g{aJt3pQqh@hfOMH5^SI6_OX3D41aH*=Q%vL&vX0OKDLkT zWBXYDNt4RapY><`S%1#kHiz|R{aJt3pY><``Lp|f&-P54wue1z58K1`aNf2#Y!BPR S_OLx{58K1`@JF|A+WZAD>Eo>c literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json new file mode 100644 index 000000000..fab11eadd --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan217-objects.json @@ -0,0 +1,29 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "Cabinet", + "DeskLamp", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json new file mode 100644 index 000000000..ba058be94 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan217-openable.json @@ -0,0 +1,92 @@ +{ + "ArmChair|-00.30|+00.00|+01.71": [ + -1.25, + 1.75, + 90, + 30 + ], + "ArmChair|-00.30|+00.00|+03.31": [ + -1.25, + 3.25, + 90, + 30 + ], + "Cabinet|-04.41|+00.50|+01.57": [ + -4.0, + 2.25, + 270, + 30 + ], + "Cabinet|-04.41|+00.50|+02.59": [ + -3.75, + 1.75, + 0, + 30 + ], + "Cabinet|-04.41|+00.50|+02.60": [ + -3.75, + 2.25, + 0, + 30 + ], + "Cabinet|-04.41|+00.50|+03.62": [ + -4.0, + 3.0, + 270, + 30 + ], + "CoffeeTable|-02.41|00.00|+02.55": [ + -2.5, + 3.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+01.82": [ + -4.0, + 2.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+02.34": [ + -4.0, + 2.75, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+02.85": [ + -4.0, + 3.25, + 180, + 30 + ], + "Drawer|-04.50|+00.90|+03.37": [ + -4.0, + 3.75, + 180, + 30 + ], + "Dresser|-04.74|+00.00|+02.60": [ + -4.0, + 2.75, + 270, + 30 + ], + "GarbageCan|-04.81|-00.03|+01.24": [ + -4.0, + 1.5, + 270, + 30 + ], + "SideTable|-00.04|+00.00|+04.62": [ + -0.75, + 4.5, + 90, + 30 + ], + "Sofa|-02.46|00.00|+00.70": [ + -2.25, + 1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan218-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..43b4a4f9f53a2bfebe3ca8a381ed7d817cddc05e GIT binary patch literal 6400 zcmbW)y-rkJ6oBC^At!{8$?*SUGu>!Hg^d~$c4eorv9K~khFBOegRwDQg%`xR1TKM+ za*8P^rVv^CF=3TXLmtk|IeWbe{P=#qegEd&hezc{`8htFTzs02UyjDF&Yq7CN8_{e z>G$c$*N^AZ)5+iOzdreLF}eHx#pjc6lRH0o_TuPpboBIa^lS8=uhnw@TJGcP&2fBP zN-oKZ%ZKm3O`a#ul5dhde|G%v`Rw`Z`Rw^TZ}(@6oV!c=|){FIG zy;v{Si}m6`ALr(^Wc^&%kM(2ySU--ZmBRWBYFyEe^<({557vYAU_Dq5)`Run)z*jg zU_Dq5)`Rt6zmKfXF!f>cvU%COY+g1mo0nJHyu6ZZUf0db=4JD;`PS2XY(6$0n~%-M z=411*`Ph7HzieJMFPoRm%jVrk^Rju_ylh@JFPoRm%jRYCa@WU++3!E=!FsSBtOv*4 zOJO}WYh3aB&*o?Iv-#QlY<@OBo1eQr&cVyc{@!){w*B{o^6o;y6ty?B560 zZ>z>T^Tay;*P8n@fAK-t6yd z)_=Rk2lZ#YS#KWp@j2F;^=7?UZ|>6l^mbiu)|>Tay;*P8oAqYBS#OT%OJTiPZ`OOK z#wYb=KkuwRueUy|KkLu>v;M3<`S%21_^=JKAe~xOUu->dU>%CXwlX|ni zk9n)j&zs5i;ktdWeXxD7eXxD7eQ=kaZy&DP2iphR2iphR2iphR2iwO#AD8%Cv& z`+Bq9?Ego2w~x>9PV#oLeR;oqv3;?9v3;?9v3;?9v3+ru&Szh)+ZWpx+ZWpx+ZWpx z+ZWr%K`r+$`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`(XQE`{1r`bJzH4AFkU6+XveR M+XveR+s8ru13&Ct_5c6? literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json new file mode 100644 index 000000000..b52cc7c18 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan218-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Curtains", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "CellPhone", + "Dresser", + "DeskLamp", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "CoffeeTable", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json new file mode 100644 index 000000000..eec0c2905 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan218-openable.json @@ -0,0 +1,68 @@ +{ + "CoffeeTable|-01.55|+00.00|+02.53": [ + -1.0, + 3.25, + 180, + 30 + ], + "DiningTable|-05.64|00.00|+04.91": [ + -6.5, + 5.0, + 90, + 30 + ], + "Drawer|+00.75|+00.23|+03.33": [ + -0.25, + 4.0, + 180, + 30 + ], + "Drawer|+00.75|+00.23|+04.10": [ + 0.25, + 3.75, + 90, + 30 + ], + "Drawer|+00.75|+00.67|+03.33": [ + 0.0, + 2.75, + 0, + 30 + ], + "Drawer|+00.75|+00.67|+04.10": [ + 0.0, + 3.5, + 0, + 30 + ], + "Dresser|+00.85|+00.00|+03.71": [ + 0.5, + 5.0, + 180, + 30 + ], + "GarbageCan|-07.10|-00.04|+02.30": [ + -6.5, + 3.0, + 270, + 30 + ], + "SideTable|+00.73|+00.01|+06.64": [ + 0.5, + 6.0, + 0, + 30 + ], + "SideTable|-03.41|+00.01|+01.66": [ + -2.75, + 1.5, + 270, + 30 + ], + "Sofa|-02.47|+00.00|+03.28": [ + -1.25, + 3.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan219-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..53a9e420d63206ac302712d7b74c3076e32f2be3 GIT binary patch literal 3552 zcmbW$KZ_GV7{K9i2}1}W_`lw671DTEhzK{8onm8QCBe&KA)X{+BYp}$ko$42OmRhu z6rMZtG;irN!;={{`~FCNzkUDa-G@8rNBTKjZ10rkAfctKM1}bd@tC%o^M_@FPoRm%Q-yXyw1(b=H=6$G%Y>`-vl3m^}0E) z&(VwZV!c=|){FIGy;v{Si}m6>*7sz+STEL#^yRcG4x~oSU=W}^<({5 zKh}@+WBph^){pgL{rJ@8XZ=`@Q|Q5ZupX=j>%n@k9;^rJ!FsSBtOx7CdaxdRY<*ad zRO;{6|BLltJy;LcgY{rNSP#~N^BF32kXIlupX=j>%n@k z9;^rJ!Ff#6>Pp>bW8J&b_Ob2FdUVZtupX?(tligx^-} z9_;tQDcsk?xgM-XF7AU z^)~7v)`Rt6Jy?%rNz>AU^1uW^td* gq-mL-&Clj%^RxNc{A_++wE1`*Y#!(4Ve_oYUmmn*5&!@I literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json new file mode 100644 index 000000000..770f701c6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan219-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "GarbageCan", + "CreditCard", + "Newspaper", + "CellPhone", + "Cabinet", + "Dresser", + "DeskLamp", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Safe", + "Laptop", + "Vase", + "ArmChair", + "ShelvingUnit", + "TissueBox", + "Shelf", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json new file mode 100644 index 000000000..6daba59dd --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan219-openable.json @@ -0,0 +1,158 @@ +{ + "ArmChair|-02.03|+00.00|+04.42": [ + -2.0, + 3.75, + 0, + 30 + ], + "Cabinet|-02.88|+00.56|+04.21": [ + -3.5, + 3.75, + 0, + 30 + ], + "Cabinet|-04.03|+00.56|+04.21": [ + -3.75, + 3.75, + 0, + 30 + ], + "Cabinet|-04.05|+00.56|+04.21": [ + -3.75, + 3.5, + 270, + 30 + ], + "Cabinet|-05.20|+00.56|+04.21": [ + -5.5, + 3.5, + 90, + 30 + ], + "Drawer|-03.17|+01.01|+04.31": [ + -3.5, + 3.75, + 90, + 30 + ], + "Drawer|-03.75|+01.01|+04.31": [ + -3.25, + 3.75, + 270, + 30 + ], + "Drawer|-04.33|+01.01|+04.31": [ + -4.75, + 3.75, + 90, + 30 + ], + "Drawer|-04.92|+01.01|+04.31": [ + -4.5, + 3.75, + 270, + 30 + ], + "Drawer|-05.02|+00.90|+00.37": [ + -4.25, + 1.0, + 270, + 30 + ], + "Dresser|-04.04|00.00|+04.59": [ + -3.5, + 3.75, + 0, + 0 + ], + "Safe|-02.30|+00.00|+00.27": [ + -1.5, + 1.0, + 180, + 30 + ], + "Shelf|-00.25|+00.78|+01.06": [ + -0.75, + 1.25, + 90, + 30 + ], + "Shelf|-00.28|+00.27|+01.07": [ + -1.0, + 1.25, + 90, + 30 + ], + "Shelf|-00.28|+01.29|+01.05": [ + -1.0, + 1.0, + 90, + 0 + ], + "Shelf|-00.28|+01.81|+01.06": [ + -0.75, + 1.25, + 90, + 0 + ], + "Shelf|-01.22|+00.27|+00.26": [ + -1.5, + 1.0, + 180, + 30 + ], + "Shelf|-01.22|+00.78|+00.24": [ + -1.75, + 1.0, + 90, + 30 + ], + "Shelf|-01.22|+01.29|+00.27": [ + -1.75, + 1.0, + 180, + 30 + ], + "Shelf|-01.22|+01.81|+00.28": [ + -1.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.39|+00.09": [ + -4.75, + 1.0, + 180, + -30 + ], + "Shelf|-05.24|+01.58|+00.07": [ + -4.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.78|+00.07": [ + -4.25, + 1.0, + 180, + 30 + ], + "Shelf|-05.24|+01.97|+00.09": [ + -4.25, + 1.0, + 180, + 0 + ], + "SideTable|-05.02|+00.01|+00.27": [ + -5.0, + 1.0, + 180, + 30 + ], + "Sofa|-00.71|00.00|+02.75": [ + -1.5, + 2.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan22-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a2bddb6722cdbd16b4e4fb99ca0a8f3b62b32dbc GIT binary patch literal 2256 zcmbW$u};EJ6oBEYVe%=uRTCCvF~&qDH;s#flOa;#V8noNF+PP4B#+QXU}Wsjfq_A^ z=Ogisc4@x0_WT^=^ZNGc=58;&rT21N%^zmvSy7%(PRo8#PNuWh+35LxIvZC%*Dps; z^J;s2{y2K6wmv)_4En{%QNQ>o{&^gv?pSoE&TvSUoY3u$9h?>zthWlSuZ!y!FpLQ@8-IYo%On` zm-Tv1FYD#jo?;Jr-Pg-{SugA0{H#Z}9&V$D^{^h+!+KZ`>tQ{s`22cU59?t)tcUfm z9yY(p=Ck>1KAX?xv-xaZo6X}k_Rmdb^V~O&{r|1w{pPX#vUzMCo5$wy{-WFHCgz#X zo9Jir*?cyi&1dsj2lt{U4ZALVtdI5aI(k_j>tlVakM(gc`u4Lv*2nr-AM0a%tdI3^ z9iNv|99+lu%6_-(cf?Khe4E)mJZ~SpVfsCMUu++2A8a3NA8a3NA8a3NAKX=?#P-4V P!S=!S!S=!S(HnjPXOlrz literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json new file mode 100644 index 000000000..51552ba88 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan22-objects.json @@ -0,0 +1,42 @@ +[ + "StoveBurner", + "Stool", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "CreditCard", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json new file mode 100644 index 000000000..445026e53 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan22-openable.json @@ -0,0 +1,176 @@ +{ + "Cabinet|+00.17|+02.01|-01.20": [ + -0.5, + -0.5, + 180, + 0 + ], + "Cabinet|+00.24|+02.01|-01.20": [ + 0.0, + -0.5, + 180, + 0 + ], + "Cabinet|+00.48|+00.39|-00.90": [ + -0.25, + -0.25, + 90, + 30 + ], + "Cabinet|+01.12|+02.01|-01.20": [ + 0.5, + -0.5, + 180, + 0 + ], + "Cabinet|+01.13|+00.47|-00.90": [ + 0.25, + -0.25, + 90, + 30 + ], + "Cabinet|-00.77|+02.01|-01.20": [ + -1.0, + -0.5, + 180, + 0 + ], + "Cabinet|-00.82|+00.47|-00.91": [ + -1.75, + 0.0, + 90, + 30 + ], + "Cabinet|-00.84|+02.01|-01.20": [ + -1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-01.77|+02.01|-01.20": [ + -2.0, + -0.5, + 180, + 0 + ], + "Cabinet|-01.80|+00.47|-00.91": [ + -2.0, + -0.25, + 90, + 30 + ], + "Cabinet|-01.84|+02.01|-01.20": [ + -1.75, + -0.5, + 180, + 0 + ], + "Cabinet|-01.85|+00.39|-00.90": [ + -2.0, + -0.25, + 180, + 30 + ], + "Cabinet|-02.39|+00.39|+00.38": [ + -1.5, + -0.5, + 0, + 30 + ], + "Cabinet|-02.63|+02.01|-01.20": [ + -2.0, + -0.5, + 180, + -30 + ], + "Cabinet|-02.65|+02.01|+00.36": [ + -2.0, + -0.25, + 270, + 0 + ], + "Cabinet|-02.65|+02.01|-00.95": [ + -1.75, + 0.0, + 180, + 0 + ], + "Cabinet|-02.65|+02.08|-00.23": [ + -2.0, + 0.0, + 270, + 0 + ], + "Cabinet|-02.65|+02.08|-00.88": [ + -2.0, + -0.25, + 270, + 0 + ], + "Cabinet|-02.65|+02.20|+00.43": [ + -1.25, + 1.0, + 270, + 0 + ], + "Cabinet|-02.65|+02.20|+01.67": [ + -2.25, + 1.75, + 270, + -30 + ], + "CounterTop|+00.07|+00.95|-01.20": [ + 0.25, + -0.5, + 180, + 30 + ], + "CounterTop|+00.91|+01.15|+00.79": [ + 0.25, + 0.5, + 0, + 30 + ], + "CounterTop|-02.70|+00.95|+00.11": [ + -2.0, + -0.25, + 270, + 30 + ], + "Drawer|+00.26|+00.78|-01.08": [ + -0.25, + 0.0, + 180, + 0 + ], + "Drawer|-02.03|+00.78|-01.08": [ + -1.5, + 0.0, + 180, + 0 + ], + "Drawer|-02.57|+00.78|+00.10": [ + -1.75, + -0.5, + 0, + 30 + ], + "Fridge|-02.86|+00.00|+00.85": [ + -1.75, + 0.75, + 270, + 30 + ], + "Microwave|+00.28|+00.90|-01.33": [ + 0.0, + -0.5, + 180, + 0 + ], + "Sink|-01.33|+00.92|-01.23|SinkBasin": [ + -0.75, + -0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan220-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..cbfb298e970e68e3e6c6e2d1c50d344d6d943b48 GIT binary patch literal 3712 zcmbW&KWkG_9LM3~C0t4frS(teyIqA$p@WFvncS2v9h@ZC6bG@Ah>Q3td_mrq(3jA$ zV}=YFGFb09&+;41V0e0y)ARkH`1}3kyNeHx(vS4BzglfRt@~G9|N8o6KkxeMoAvkg z^6ST&_0{U%&)+V;Y*r6H-+W$vTRr&sVsSq27BA-AukJrz(=@(zf6Du9ecuM(2cHe) z^ZtAi>^#q%$IfHt-M%S5c{Y@Hej4oedHy&&KMi&tpLZX2A9kO+a36Lbb{}>hb{}>h zb{}>hcAxujA9f#hA9f#hA3mwQ_&9hLe5ijPe10EnpXc_meQe)0>|^`bKDLkTWBb@X zwvX*&`*>IPvVCkH+qVn**gm$8?PL4cKDLkTWBb@XwvV@UFWbj=;kmv0u$S#+d)Z#L zm+fVH*`?0-jFWbxZvb}8YA?#&)*&beu zo~$S9+2nFhJy}oIll5dhSx?rJ^<+I+Pi}`azM5R#CqsE}a(y4_d$pcTwVtde>&beu zo~$S9Imu~!>B)Mso~$S9$$GM$tS9TqdU89Id$OMF?&beuo~$S9$$GM$tS7g%59`TIc%Fjw^m#p5Pu7$5Wc`kE8ejUceykts$NI5; ztRK(nKGu)*<2HO=KhK-+TtCnCWBph^){pg?=2Tww_p$TY`RsglK0ALF&S&Sd^V#|A Te0KhEJ>U1)_u2Q^_fPU)3+t?9 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json new file mode 100644 index 000000000..4ade16795 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan220-objects.json @@ -0,0 +1,30 @@ +[ + "FloorLamp", + "Candle", + "Pillow", + "Box", + "Boots", + "Sofa", + "Statue", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Drawer", + "Painting", + "RoomDecor", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json new file mode 100644 index 000000000..39f0b25e7 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan220-openable.json @@ -0,0 +1,92 @@ +{ + "ArmChair|-02.06|+00.01|+04.22": [ + -1.75, + 3.5, + 0, + 30 + ], + "CoffeeTable|-02.65|+00.01|+01.15": [ + -2.75, + 1.75, + 180, + 30 + ], + "DiningTable|+00.17|+00.67|+01.98": [ + -1.0, + 2.0, + 90, + 0 + ], + "DiningTable|+00.17|+00.86|+01.98": [ + -0.75, + 2.0, + 90, + 0 + ], + "Drawer|-00.31|+00.18|+03.61": [ + -1.5, + 2.75, + 0, + 30 + ], + "Drawer|-00.31|+00.47|+03.61": [ + -1.75, + 3.5, + 90, + 0 + ], + "Drawer|-00.31|+00.76|+03.61": [ + -1.5, + 3.5, + 90, + 0 + ], + "Drawer|-00.31|+01.05|+03.61": [ + -1.25, + 3.5, + 90, + 0 + ], + "Drawer|-00.36|+00.22|+00.52": [ + -1.0, + 0.0, + 90, + 30 + ], + "Drawer|-00.36|+00.58|+00.52": [ + -1.0, + 0.0, + 90, + 30 + ], + "Dresser|-00.27|+00.00|+03.61": [ + -0.75, + 2.75, + 0, + 30 + ], + "SideTable|-00.28|+00.01|+00.52": [ + -0.75, + 0.75, + 90, + 30 + ], + "Sofa|-02.68|+00.01|-00.12": [ + -1.75, + 0.75, + 180, + 30 + ], + "Sofa|-03.79|+00.02|+03.89": [ + -3.75, + 3.0, + 0, + 30 + ], + "TVStand|+00.17|+00.59|+01.98": [ + -0.5, + 2.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan221-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..1998dfe53466034f9930433a8609e39fc508e2a2 GIT binary patch literal 1904 zcmbW$u}Z^07zglEBuEjTAzKu>)Ja6>=BBtfI7zW74q_z{7x5{4AoB=)gpM6MbZ~I6 zn)@x^XqM~ma(CbVYm$$vo6GClo%EXCs%hQcH`Q5LozG6IVOh=Q%}Xp!FaLQB(%-e;^<$C8!#wWg@gR5*Y`^tIxNqLL8}6%T zUOiTi)noNI)-i8Pxjw6BUOjd`JD;7yas2*F{gvx}1#g1a!K>h9@FF-@OLE8;b8sBx zGcO;@$MUg!EFa6q@~JB~TgP#f&%AsrAIrz`v3x9_I`Xl6>^!z#F8kSfwq9=Qx#;?Y z`tUxo{cJz`-qiK}v-h8UZ>&D6&+4=K?EhkU`mR!vhvi{;xaj=qM|sT3!}72^?76e& z$ZOwQp731U_dm1#7UO&9~WJ}kM+m;WBsxISbx09{jmO6f2=>&-!k;a`eXgE T{#bwP{8c!gozKo^=dZ>;E<^}{ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json new file mode 100644 index 000000000..0c292118a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan221-objects.json @@ -0,0 +1,29 @@ +[ + "FloorLamp", + "Stool", + "Curtains", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json new file mode 100644 index 000000000..616f56233 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan221-openable.json @@ -0,0 +1,44 @@ +{ + "ArmChair|+00.66|+00.10|-01.78": [ + 0.0, + -1.5, + 90, + 30 + ], + "CoffeeTable|-01.05|+00.10|-02.47": [ + -0.5, + -1.75, + 180, + 30 + ], + "CoffeeTable|-01.09|+00.10|-00.74": [ + -0.5, + 0.0, + 180, + 30 + ], + "DiningTable|-03.43|+00.10|-01.19": [ + -2.25, + -1.5, + 270, + 30 + ], + "Drawer|-00.03|+00.87|-02.49": [ + -0.5, + -1.5, + 180, + 0 + ], + "SideTable|-00.03|+00.10|-02.55": [ + -0.25, + -2.0, + 180, + 30 + ], + "Sofa|-00.91|+00.10|+00.96": [ + -1.5, + 0.25, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan222-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..b2a8cc9718e5f2cf19ef4807f70182005f8015d7 GIT binary patch literal 1648 zcmbW$Ax;B96b9e{$tl(?Bvm9NKuB7JgJ2LS($FOcLdlk32&dpcy}}-$vU0_WiV6xd zpWsQ>ynM4e^Z(tpU)Q%+H+OsKJ$=-(X7SM0=T&|2cv_FD`f=XAwbPgTc{^)<)-R{e zi)OdJc$&U8J0G5%jH=_KQT18<_c}$+0 zm|r>wGWzmnqMEc`T3R zu{@UNcdG|`j^p$`toNlS>&N=BeyktsCr3ZlkL}|)^|P)Y>&N=BeypE!^<({5KXwks fsh@TISU=W}{coJ3FYC+BW9PB+^yrrPgw6OH;_3TC literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json new file mode 100644 index 000000000..3b4888f48 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan222-objects.json @@ -0,0 +1,26 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json new file mode 100644 index 000000000..78f79df35 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan222-openable.json @@ -0,0 +1,86 @@ +{ + "ArmChair|+00.22|-00.01|-01.72": [ + 0.25, + -1.0, + 180, + 30 + ], + "CoffeeTable|+00.23|00.00|-00.16": [ + 0.75, + -0.5, + 270, + 30 + ], + "Drawer|+00.47|+00.06|-00.17": [ + 1.5, + 0.5, + 180, + 30 + ], + "Drawer|+00.47|+00.17|-00.17": [ + 1.5, + 0.5, + 180, + 30 + ], + "Drawer|+00.47|+00.27|-00.17": [ + 1.5, + -1.0, + 0, + 30 + ], + "Drawer|+02.00|+00.78|+01.71": [ + 1.5, + 1.0, + 90, + 30 + ], + "Drawer|-00.02|+00.06|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "Drawer|-00.02|+00.17|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "Drawer|-00.02|+00.27|-00.17": [ + -0.25, + -1.0, + 0, + 30 + ], + "SideTable|+02.00|+00.00|+01.75": [ + 1.75, + 1.25, + 0, + 30 + ], + "SideTable|+02.96|+00.00|+01.57": [ + 2.0, + 1.0, + 0, + 30 + ], + "SideTable|-00.68|+00.00|-01.60": [ + -0.25, + -1.0, + 180, + 30 + ], + "Sofa|+02.87|00.00|+00.25": [ + 2.0, + 0.25, + 90, + 30 + ], + "TVStand|+00.84|-00.01|+01.58": [ + 2.0, + 1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan223-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..665418e122d9cac06770ebc649028343ff60128b GIT binary patch literal 3344 zcmbW&v5FHx7zgli3E>FhGo*_`3cX51a4S2-#==U1m%~ClNyJ8c3LhwWgnfi7uiRpb z6e&D2-)|vbd1;2<>}KXa|AgJY??1l#@aa+cRemq7*4riT&@4lzg>OXuJ7l!UspfY_kMc${Kay9`D{7=Gk@S`R!*N`SI0w)eezxMZE}}f zS1ZMO-JA3EZ-yp*&cpg*eX+h+U#u_I7f<%}fO_)3VfS$!^=V$8-0jZSuPSA{9{sRB zS)bge`}N_vK3E^D57r0k!?~L1hfDG?&gZ)RSbuCE&ZGX!cWHh7jn|_O)*tJS^~3sM z{jmIU$vuUJ2< zAJz}+hdrNJU(TT~))(uG^~J-k=4bnG9`$8jU#u_I7we1l#rk6BwXgHC^Rn}@^YReq z<%@kizjI8J?eDt%+5UWt_1XSxf1bsDdXtCcVR={{mWSoxL*!$5SRTKdJS-2(!}72^ pEDy`W@~}KjTTUN&c)CALm!_@bWM9Xot)uTx!oJVbeZ6ne{sUHT-gy83 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json new file mode 100644 index 000000000..e7796955d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan223-objects.json @@ -0,0 +1,28 @@ +[ + "FloorLamp", + "Plate", + "Candle", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "WateringCan", + "TVStand", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json new file mode 100644 index 000000000..926752e61 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan223-openable.json @@ -0,0 +1,50 @@ +{ + "ArmChair|-00.43|+00.01|+01.06": [ + -1.0, + 0.25, + 0, + 30 + ], + "ArmChair|-00.44|+00.01|+01.92": [ + -1.25, + 2.0, + 90, + 30 + ], + "ArmChair|-02.01|+00.01|-01.58": [ + -1.25, + -1.0, + 270, + 30 + ], + "CoffeeTable|-02.02|+00.01|+00.02": [ + -1.25, + -0.25, + 270, + 30 + ], + "DiningTable|+01.88|+00.00|-00.29": [ + 3.0, + -0.25, + 270, + 30 + ], + "DiningTable|-01.86|+00.23|+02.79": [ + -2.5, + 1.75, + 90, + 30 + ], + "SideTable|-03.60|+00.00|-01.61": [ + -2.5, + -1.0, + 270, + 0 + ], + "Sofa|-03.42|+00.01|-00.04": [ + -2.5, + 0.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan224-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..32ec8b98d34f480b238ced98dc1ea711dd6487e8 GIT binary patch literal 4688 zcmbW%v5FHx7{Kvy2#fd>+pR*X1K|+Ct?U#V3o8j;4h!)l5gYL-e4y+j2kXJ*b}8{#=Vg6Z zAD+Ye`gorEasunaO?duzDDRuI30?*3>3uy}Pj)WHRZshRvYxCb>&1HUTzj!zocr|f z!+Nn^te1N?L-{=G#d@(`tQYIW&gHo3WnV8o9+vkjO3CxF_Ted5PtWyaJvsNw^Yrvw z&$EZ}zB%+`{a8QNkM(2y*tr~6{p=rWKQ6aTiS^^D_GA56Kh}?PA9@7q=ly0V@4L5t ztRL&g`muhjAM3~N!Ex2kez|Q*e5}3rHux@BZ}02Pdb8fFH|IX|3)b8F%~0Mqm)@*5 z>&<$z-mEu|hvj*Cd+uHw*YfF<&il0|>&<$z-aLiR>+QMTtT*R=Igj5Dp6kti-<`*}XZg$J)=n{;WUi&r|rk{+{d4`g896sjT|j)t~h| z-+L%eSWniIr`nJ8WIb6=)|1_f7M?5vYxCb zPqioO$$GM$tS9Tqdaxd>2kXIlupX=j>*0ISgY{rNSP#~N^N^v$Hn~$gZeY5%4d~7~8ADfTO$L3@6vH941&h`DV`Ph6s)%kb~HlOElHJ^R+ zvH941Y(6$0o6kAsWAm~3*nB+J`Ph8yT#l>x?3<6x$L3@6vHASH=Ht2Emrudw^W1!F yJ~ki6)jamy&%XPy`|+vXkKK>mkKK>mkDafp^V#|Ae0DxNpPkRn^Syb#>i+=xY_kFY literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json new file mode 100644 index 000000000..c848824cf --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan224-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Stool", + "Pillow", + "Statue", + "Box", + "Sofa", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Book", + "WateringCan", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "Dresser", + "Chair", + "DogBed", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json new file mode 100644 index 000000000..0e044ef87 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan224-openable.json @@ -0,0 +1,182 @@ +{ + "ArmChair|-02.86|+00.03|-02.04": [ + -2.25, + -1.5, + 270, + 30 + ], + "Drawer|+03.10|+00.17|+00.36": [ + 2.0, + -0.25, + 0, + 30 + ], + "Drawer|+03.10|+00.17|+01.40": [ + 2.0, + 0.75, + 0, + 30 + ], + "Drawer|+03.10|+00.17|-00.57": [ + 2.0, + 0.0, + 180, + 30 + ], + "Drawer|+03.10|+00.42|+00.36": [ + 2.25, + -0.25, + 0, + 30 + ], + "Drawer|+03.10|+00.42|+01.40": [ + 2.25, + 1.0, + 0, + 30 + ], + "Drawer|+03.10|+00.42|-00.57": [ + 2.25, + 0.0, + 180, + 30 + ], + "Drawer|-00.17|+00.47|-02.14": [ + -0.5, + -1.5, + 90, + 30 + ], + "Drawer|-00.19|+00.23|+00.95": [ + -1.25, + 1.5, + 180, + 30 + ], + "Drawer|-00.19|+00.48|+00.95": [ + -1.25, + 1.5, + 180, + 30 + ], + "Drawer|-00.19|+00.74|+00.95": [ + -1.0, + 0.5, + 0, + 30 + ], + "Drawer|-00.42|+00.35|+01.41": [ + -1.25, + 2.0, + 180, + 30 + ], + "Drawer|-00.42|+00.35|+01.92": [ + -1.25, + 1.25, + 0, + 30 + ], + "Drawer|-00.42|+00.35|+02.38": [ + -1.25, + 1.75, + 0, + 30 + ], + "Drawer|-00.42|+00.60|+01.41": [ + -1.25, + 2.0, + 180, + 30 + ], + "Drawer|-00.42|+00.60|+01.92": [ + -1.25, + 1.25, + 0, + 30 + ], + "Drawer|-00.42|+00.60|+02.38": [ + -1.25, + 1.75, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+01.41": [ + -1.0, + 1.0, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+01.92": [ + -1.0, + 1.5, + 0, + 30 + ], + "Drawer|-00.42|+00.85|+02.38": [ + -1.0, + 2.0, + 0, + 30 + ], + "Drawer|-03.24|+00.17|-00.49": [ + -2.25, + -1.0, + 0, + 30 + ], + "Drawer|-03.24|+00.42|-00.49": [ + -2.5, + -1.0, + 0, + 30 + ], + "Dresser|-00.05|+00.03|+01.67": [ + -0.75, + 1.75, + 90, + 30 + ], + "GarbageCan|+03.16|+00.03|+00.89": [ + 2.75, + 0.5, + 90, + 30 + ], + "SideTable|+03.16|+00.03|+00.36": [ + 2.75, + -0.25, + 90, + 30 + ], + "SideTable|+03.16|+00.03|+01.40": [ + 2.75, + 1.5, + 90, + 30 + ], + "SideTable|+03.16|+00.03|-00.57": [ + 2.75, + -1.0, + 90, + 30 + ], + "SideTable|-00.17|+00.03|-02.28": [ + -0.75, + -1.75, + 90, + 30 + ], + "SideTable|-03.30|+00.03|-00.49": [ + -2.75, + -1.25, + 270, + 30 + ], + "Sofa|-02.96|+00.03|+01.39": [ + -2.25, + 1.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan225-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..ad7052df7af997c082b3bbf305788284e4c43c67 GIT binary patch literal 2576 zcmbW$F^dyH7zW^R2}1}W+~pUfTZJ^I2qMBwWvAF!TqVKFafNu2h>iFw{6X$dvApt% zD^jHJ+?l8FE1hO}GQ0D=Z#Mb)_Whf87mw1n^u52_?mzDOm#hBO)r)?;>aT8gUw50& zA8vM++rOW`-hA3`A3on-Z@z3F{P^tov-RrfllAJy>Oa>kjcYN~>+N~H&Vy&c)8HID z3GRYZ@bOm~m-+JCg*+?|%fq>y&+@Q5EDy`W^4y0!EDy`W@~}KC56i>y@S%NQd>?!l zd>i~bSii&h_!^S;&-$@`tRL&g`mug|Y&KI!p2LThm*r)7S)Q)cbNrrI9+rpmkjB-OdYugQ z+Ld}WpUr3UC+&Xo*?cyi^N_~H=Ck>1KAWFQJ;!`DpUvky)aTedHjmAlminA|Y#y7( zd8p5^d2Ak^wEJhJK4(79!@l|U&F38M_kG*<`(yc7K9+A@(zq7we3p;p<7v1*2g~RF zF6^gZ|9|)E!}_p3?ElaH|E%w#q;cuX`m(+}ZFxBd>uXKbA k#-%Uo%g$rx@v`+jZRec^n`hrVb{;!#8O~$pvGbPY50_ygkpKVy literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json new file mode 100644 index 000000000..56cce5761 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan225-objects.json @@ -0,0 +1,31 @@ +[ + "FloorLamp", + "Curtains", + "Pillow", + "Box", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "TVStand", + "DeskLamp", + "Drawer", + "LightSwitch", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Shelf", + "Chair", + "Newspaper", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json new file mode 100644 index 000000000..c14fbdb01 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan225-openable.json @@ -0,0 +1,86 @@ +{ + "ArmChair|-00.88|+00.01|+00.57": [ + -0.75, + 1.25, + 180, + 30 + ], + "CoffeeTable|-01.97|+00.00|+02.62": [ + -1.25, + 3.0, + 270, + 30 + ], + "Drawer|-04.43|+00.47|+03.34": [ + -3.5, + 2.75, + 0, + 30 + ], + "GarbageCan|-00.23|+00.01|+04.78": [ + -0.5, + 4.25, + 0, + 30 + ], + "Shelf|-00.34|+00.28|+03.05": [ + -2.0, + 3.5, + 90, + 0 + ], + "Shelf|-00.34|+00.31|+02.31": [ + -1.5, + 1.75, + 0, + 30 + ], + "Shelf|-00.34|+00.45|+02.68": [ + -1.25, + 2.25, + 0, + 30 + ], + "Shelf|-00.34|+00.48|+03.05": [ + -1.25, + 3.5, + 180, + 30 + ], + "Shelf|-00.34|+00.60|+02.31": [ + -1.25, + 2.75, + 180, + 30 + ], + "Shelf|-00.34|+00.65|+03.05": [ + -1.25, + 3.5, + 180, + 30 + ], + "SideTable|-04.61|+00.01|+03.35": [ + -4.0, + 4.0, + 270, + 30 + ], + "Sofa|-02.12|+00.01|+04.56": [ + -2.25, + 3.75, + 0, + 30 + ], + "Sofa|-04.57|+00.01|+01.88": [ + -3.75, + 2.0, + 270, + 30 + ], + "TVStand|-00.34|+00.01|+02.68": [ + -1.0, + 2.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan226-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..612bff252a03c692fd9fae9587c56e6b1ca74d94 GIT binary patch literal 1392 zcmbW#El$Kh7zW^i

#+;>QM z@;Q!udd~bhxC?HB$KA4Qw|@F}|329HJ@5RypU&@G`mjE%H_PET>Sta*Zc{(jkK5FT zyI|kXeSPe!59`D7Sw72W`FhA_`7EF1vwW7{ruQPB<+FU2&+=Km_bi{~vwW7%@>%|F z-D3`!PI-O6B^RjguNBfz#AKR~+eglST B=!pOT literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json new file mode 100644 index 000000000..955390880 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan226-objects.json @@ -0,0 +1,25 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Statue", + "Sofa", + "Blinds", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Drawer", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "Newspaper", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json new file mode 100644 index 000000000..3a0e5fab9 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan226-openable.json @@ -0,0 +1,68 @@ +{ + "ArmChair|+01.51|+00.00|-00.59": [ + 1.25, + -1.25, + 0, + 30 + ], + "CoffeeTable|-00.71|+00.01|-00.37": [ + -0.5, + -1.0, + 0, + 30 + ], + "Drawer|+01.74|+00.77|+00.33": [ + 0.75, + 0.0, + 90, + 0 + ], + "Drawer|-00.71|+00.08|-00.17": [ + 0.25, + 0.5, + 270, + 30 + ], + "Drawer|-00.71|+00.08|-00.56": [ + -1.75, + -1.25, + 90, + 30 + ], + "Drawer|-00.71|+00.24|-00.17": [ + 0.25, + 0.5, + 270, + 30 + ], + "Drawer|-00.71|+00.40|-00.17": [ + -1.25, + 0.5, + 180, + 30 + ], + "Drawer|-00.71|+00.40|-00.56": [ + -0.25, + -1.25, + 0, + 30 + ], + "Drawer|-00.72|+00.24|-00.56": [ + -1.0, + -1.25, + 90, + 30 + ], + "SideTable|+01.81|+00.00|+00.33": [ + 1.25, + 0.5, + 90, + 30 + ], + "Sofa|-00.50|+00.01|-01.89": [ + -0.5, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan227-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..01fe02cc4a31f59c63203eb32ff53aed7fca0700 GIT binary patch literal 3232 zcmbW(v2N2)6b9f+6j@aiRc+I>l*yYx$^v2lgj7%6in?@QLJ>{HfGA233*sqwAp9sD zJ7(yRAp@=N{gyN0rTSv~{`Z{YxcT$p^8DiClk_wFYOWTm&&%dr-Mqhk)6DAT`eylK zIsf+QW_h)E{QPYGb+vf-eD!7ieevMuFWfiN$9;4JBCtdz~dz$|~4L%M& z3Vv36SMIkSTaT^B*5hed?=W~0d=R`JycfJ1JPsZO?*v!D!{9-%{;W%X)Whmw^{{$a zJ**y9537gO!|Gx6uzEO^`gr>{^#^Z)?}OLDcfq&8`gMPrbM%Y#i}j23i}j23i}j1E zF6XlTu>P?Au>P?Au>SD6)X)0E`osFMDgDt8)(_SX)(_SXRu6B>{#gDtfdhB}kzTGX?yPv(E*m`U|w%%S?kIjcS<^96mk1U_% zvwZgdcfaJHbg4hs?-Ta>g#A9@X}JF|SifBFd1B8Kd!E?y#N)93DA@Dl`YN3FJUQ?C z!TQg>?`$4y9&8?L9&8?L9tUme5A$I2VDsRkQXfx)&BJ-~VDn(}VDn(}VDn(}VDsQA h?9V)$HxD)sHV-xrHV-xrHV=0Hq)q+des=$){Rg6}TU`JE literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json new file mode 100644 index 000000000..f87968d27 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan227-objects.json @@ -0,0 +1,28 @@ +[ + "FloorLamp", + "Plate", + "Pillow", + "Box", + "Statue", + "Sofa", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "Cabinet", + "Drawer", + "Painting", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "Vase", + "ArmChair", + "CoffeeTable", + "Shelf", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json new file mode 100644 index 000000000..76136ed5f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan227-openable.json @@ -0,0 +1,206 @@ +{ + "ArmChair|-01.01|+00.03|+02.08": [ + -1.75, + 2.5, + 90, + 30 + ], + "ArmChair|-01.58|+00.03|+03.30": [ + -2.0, + 2.75, + 0, + 30 + ], + "Cabinet|-01.53|+01.87|+00.33": [ + -1.0, + 1.0, + 180, + 0 + ], + "Cabinet|-01.98|+01.17|+05.03": [ + -2.25, + 4.5, + 0, + 30 + ], + "Cabinet|-02.02|+01.71|+00.32": [ + -1.5, + 1.0, + 180, + 0 + ], + "Cabinet|-02.47|+01.33|+05.03": [ + -2.75, + 4.5, + 0, + 0 + ], + "Cabinet|-03.70|+01.71|+05.03": [ + -4.0, + 4.5, + 0, + 0 + ], + "Cabinet|-04.18|+01.87|+05.03": [ + -4.5, + 4.5, + 0, + 0 + ], + "Cabinet|-05.37|+01.17|+05.03": [ + -5.75, + 4.5, + 0, + 30 + ], + "Cabinet|-05.85|+01.33|+05.03": [ + -6.25, + 4.5, + 0, + 0 + ], + "CoffeeTable|-02.67|+00.03|+02.00": [ + -2.0, + 1.5, + 270, + 30 + ], + "DiningTable|-05.82|+00.03|+02.56": [ + -4.75, + 2.0, + 270, + 30 + ], + "Drawer|-01.09|+00.23|+00.46": [ + -1.0, + 1.25, + 180, + 30 + ], + "Drawer|-02.68|+00.23|+00.46": [ + -2.75, + 1.25, + 180, + 30 + ], + "Drawer|-02.94|+00.51|+05.00": [ + -3.25, + 4.5, + 0, + 30 + ], + "Drawer|-02.94|+00.82|+05.00": [ + -3.0, + 4.5, + 0, + 30 + ], + "Drawer|-04.26|+00.23|+00.46": [ + -4.75, + 1.25, + 180, + 30 + ], + "Drawer|-06.33|+00.51|+05.00": [ + -6.0, + 4.5, + 0, + 30 + ], + "Drawer|-06.33|+00.82|+05.00": [ + -6.25, + 4.5, + 0, + 30 + ], + "GarbageCan|-06.85|+00.02|+00.26": [ + -6.25, + 0.75, + 180, + 30 + ], + "Shelf|-00.81|+01.69|+00.19": [ + -1.0, + 1.0, + 180, + 0 + ], + "Shelf|-01.04|+01.00|+00.18": [ + -0.5, + 1.0, + 180, + 0 + ], + "Shelf|-01.04|+01.32|+00.18": [ + -0.5, + 1.0, + 180, + 0 + ], + "Shelf|-01.78|+00.99|+00.18": [ + -1.25, + 1.0, + 180, + 0 + ], + "Shelf|-02.22|+00.45|+05.17": [ + -2.75, + 4.25, + 90, + 30 + ], + "Shelf|-02.67|+00.61|+00.27": [ + -2.0, + 1.0, + 180, + 30 + ], + "Shelf|-03.19|+01.15|+05.17": [ + -3.25, + 4.5, + 0, + 0 + ], + "Shelf|-03.94|+00.99|+05.17": [ + -3.75, + 4.25, + 0, + 0 + ], + "Shelf|-04.67|+01.00|+05.17": [ + -4.75, + 4.5, + 0, + 30 + ], + "Shelf|-04.67|+01.32|+05.17": [ + -4.75, + 4.5, + 0, + 0 + ], + "Shelf|-04.90|+01.69|+05.17": [ + -4.75, + 4.5, + 0, + -30 + ], + "Shelf|-05.61|+00.45|+05.17": [ + -5.0, + 4.25, + 270, + 30 + ], + "Shelf|-06.57|+01.15|+05.17": [ + -6.5, + 4.5, + 0, + 0 + ], + "Sofa|-03.33|+00.02|+03.63": [ + -3.25, + 3.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan228-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a07f8bf3aa03848dd6ebd588c90ecca0333f83c GIT binary patch literal 2576 zcmbW%F>6y%7zW^D2!{|tXk*>)b}MADQV05uX-GAKmFT4KL<%@pZ^_N$>o89Ki z`PJ@X`|tUi&FB60;rag4=6d_!<7cPO*WJm}b@#pd&oxiuS`GE{_I3R{3_b{61}}o= z!L#5TJPm%_eAn{G$MUg!EFa6q^09m@AIrz`-M4(sXXmr?+4<~zc77^pT+Ub>%@e4K~6kLBY@c%OprTYmfXVSQL1)`#_B zedeX+^!w#S%ftGzzMR8;eZAM0^<{loU)GoPWqny+)^}0Txb$WJSM2|am#rV051S9q z!u}j=KK7drn-7~0n-7~0n-7~0n-81MvZQgD51S9051S9056@eFo(1P%^ReH2*nHT0 z*nHT0*nHT0*nId&%Xd)HxQ>F&&wKM@eL08k>+8L~tS{@!`m(;PFYC+t@=?ooSkk!k jWBph@mXGCQ`B*-dkL6?eRv{nD!}72^EDy`W@~p~VyiFZK9KteKEjq; zrbv+@h3n1v3Qy@Y%a=)J{_}^u`T6?ot2giNlyBvGcfQ(uSa;9b?)k-8w`jYI%k|gw z^7H%4_4(@W>o1p|Hmlp$Hy@W@R=0lm`0VMTee!70{%HSmHDy?*SI58CFOGljCGUUz zyMI6SZ{qzv&pyvS&$~E}AH;dvIM4a)e0DxNpLcOSZ*Emp=!5ma`e1#qK3E^D z57r0Qn2+_r`e1$VA^PBbvOetVgY{ARGAw( zKg-YZv-~VS%g^$&{477q&(|>zn`hjYVfjATJZv5|51WU})$v?551WV0!{%Z0uzA=# zwLji#9ySk~ht0#I$j>F&Joe4Q=3(=&dDuK`o=KXA&BNwl^RVX!Ph%eT{9w-yuIc^b zKm+ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json new file mode 100644 index 000000000..2aca56e1f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan229-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Pillow", + "Box", + "Boots", + "Sofa", + "Statue", + "Pencil", + "SideTable", + "KeyChain", + "Television", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "WateringCan", + "CellPhone", + "Drawer", + "Desk", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Dresser", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json new file mode 100644 index 000000000..27d4df17e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan229-openable.json @@ -0,0 +1,68 @@ +{ + "ArmChair|-01.32|+00.03|+03.65": [ + -1.75, + 3.0, + 0, + 30 + ], + "CoffeeTable|-03.04|+00.00|+02.34": [ + -3.25, + 3.0, + 180, + 30 + ], + "Desk|-00.31|+00.03|+00.62": [ + -1.0, + 1.0, + 90, + 30 + ], + "Drawer|-05.50|+00.21|+02.13": [ + -5.25, + 1.5, + 0, + 30 + ], + "Drawer|-05.50|+00.21|+02.68": [ + -5.25, + 3.25, + 180, + 30 + ], + "Drawer|-05.50|+00.52|+02.13": [ + -5.25, + 1.5, + 0, + 30 + ], + "Drawer|-05.50|+00.52|+02.68": [ + -5.25, + 3.25, + 180, + 30 + ], + "Dresser|-05.70|+00.02|+02.40": [ + -5.25, + 1.5, + 0, + 30 + ], + "SideTable|-00.31|+00.02|+01.52": [ + -0.75, + 2.0, + 90, + 30 + ], + "SideTable|-05.57|+00.02|+00.29": [ + -5.0, + 0.75, + 270, + 30 + ], + "Sofa|-03.13|+00.03|+00.61": [ + -3.25, + 1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan23-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..9e63fce2cd289e0c50458690a443b21b3d1666b8 GIT binary patch literal 1648 zcmbW$u}T9$6a~;xL?np#3Db?jRslhSwVh&FAr+tv8;`erLVrgwOYacY}9=w}bV|)z7ilzEwZ# zXZ@_7Q$G)zN3MC;JnT7+t9k63ht0$0;h#m?T>KsU75o|Oeazu~*!!^eVg0P1^|OA~ z@4fZ2e3sAhSw746J<4bKET84Ge3tKbk;n2_9?N5Sa?Hzdm2Y1@%V+tXlh5wsxXQOL zpXIwx9=ng@>Up{5V|gr(<*~ev{@lxB=bN2x*2nr-AM0C&KGw(j*#DUQPuRI;=a8Kv MHb0x6&A(i%0CTJP2LJ#7 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json new file mode 100644 index 000000000..f21beb23b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan23-objects.json @@ -0,0 +1,47 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Blinds", + "Pencil", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "Pen", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Shelf", + "Chair", + "LightSwitch", + "Bottle", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json new file mode 100644 index 000000000..99352e9a3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan23-openable.json @@ -0,0 +1,98 @@ +{ + "Cabinet|-00.30|+01.92|-02.50": [ + -1.0, + -2.75, + 90, + 0 + ], + "Cabinet|-00.33|+01.92|-03.39": [ + -1.0, + -2.75, + 180, + 0 + ], + "Cabinet|-00.58|+00.39|-01.80": [ + -1.25, + -2.25, + 0, + 30 + ], + "Cabinet|-00.58|+00.39|-02.20": [ + -1.5, + -2.75, + 0, + 30 + ], + "Cabinet|-00.58|+00.39|-03.40": [ + -1.75, + -3.0, + 90, + 30 + ], + "Cabinet|-00.88|+00.39|-03.42": [ + -1.25, + -2.5, + 90, + 30 + ], + "Cabinet|-00.88|+02.14|-03.69": [ + -1.5, + -2.75, + 180, + 0 + ], + "Cabinet|-01.76|+02.14|-03.69": [ + -1.25, + -2.75, + 180, + 0 + ], + "CounterTop|-00.30|+00.95|-02.79": [ + -1.0, + -3.0, + 90, + 30 + ], + "DiningTable|-02.43|+00.00|-01.69": [ + -1.75, + -1.5, + 270, + 30 + ], + "Fridge|-00.33|+00.00|-00.77": [ + -1.25, + -0.75, + 90, + 0 + ], + "GarbageCan|-01.94|00.00|-03.76": [ + -2.25, + -3.5, + 90, + 30 + ], + "Microwave|-01.32|+01.52|-03.80": [ + -1.25, + -3.0, + 180, + -30 + ], + "Shelf|-02.43|+00.15|-01.69": [ + -3.25, + -0.75, + 90, + 30 + ], + "Shelf|-02.43|+00.52|-01.69": [ + -3.75, + -1.75, + 90, + 0 + ], + "Sink|-00.35|+00.91|-02.01|SinkBasin": [ + -1.0, + -2.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan230-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..35ea786ab0b1dda667f3723868c36a81bc2c172f GIT binary patch literal 6448 zcmbW(y=oL;6b9hWunfx*mfigMubXNWQYnIpkg4nx8w)E5W`l(o*@%q@xd$)Ey_A$G zQ>54;h4I_-OmRx52~Q@O^PYDzGx`1Y{hN0mZj>M8=k#!P@@YPOIhnpXdOqEoOplJ| z-{%KkKOWByXaBzc`rymS?E3pBpAWvxuKnogi)VY2Cy)0gzb5~A3`#w=7pt#l`>U^8 z$(zX=$>ZepINU;QcdkZ+lMnS7CKzw`aob?nFXWBalFcog|~m~4ON?a%h- zCjGwsonK4mOR|3ayna|etRL3TMe2w3!}?+UuzpxStRL17>xcEj`eFUBepo-OAHIyg z7uFB!=Q8!f`eFUBepo-OAC{lxXZcxvzKDHT{$N4Sw5DJmU_s`o+m6X%ggfeGV-##EHBH;@~x$OEFa6q^09m@ zAIrz`v3#sgmbcfIdgznoWqDa%mY3yad0AeTm*r)7o0OO3WqDa%mY3yad0AeTm*r)7 z`zbHW%kr|kEHBH;^0K@vFU!mF4pLs0m*r)7Szh+M<>8{#gS~IKN#}dXCHX4uU%#&( z)(`84^~3sM{j9g89_|;`59^2Z!}?+U@G$n{^y!1#`ec2M z+ENdFvOZa#tWVY_>y!1#`s6|M#rotXo!6)H`ec2wK3SivPu3^vll3=lOFi_*TalOb z$NFRavHUDQ%g^$&{478Fdtm!)qvY#+7{+lTGL_F?<5eb_#1AGQz6yBYh)%kr|k zEHBH;^0K@vFU!mFvbKDt>e1>*gQ6m&13V}Jhm^Je>=@*^VxhhpUr3U*?cztPMXi=v-xa3o6qL6 z`E35(G@s39^VxhhpUr3U+5CHHKAX?xv-xa3o6qL6`S;U&HlNLB^VxhhpUr3UAEfzg zKAX?xv-xa3o6qJyO!L`%HlIDe*z=1$zu5DOn?dB*l* z`?3AFw^&`5{r|__-|YR(-rwx~&Gu#cvVA%BJ>}T9bL`tW_U#<|c8+~I$3C57pU$yQ e=h&xn?9y!1l+x`WazMf(L literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json new file mode 100644 index 000000000..7ddc799b5 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan230-objects.json @@ -0,0 +1,32 @@ +[ + "FloorLamp", + "Plate", + "Candle", + "Pillow", + "Box", + "Boots", + "Statue", + "Sofa", + "SideTable", + "KeyChain", + "Watch", + "Television", + "Window", + "GarbageCan", + "CreditCard", + "DeskLamp", + "Mirror", + "Painting", + "RoomDecor", + "DiningTable", + "Floor", + "HousePlant", + "Laptop", + "ArmChair", + "CoffeeTable", + "TissueBox", + "Newspaper", + "Chair", + "LightSwitch", + "RemoteControl" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json new file mode 100644 index 000000000..b866dc6e2 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan230-openable.json @@ -0,0 +1,56 @@ +{ + "ArmChair|-02.69|+00.01|+04.62": [ + -3.0, + 5.25, + 180, + 30 + ], + "ArmChair|-03.66|+00.01|+04.56": [ + -4.25, + 5.0, + 90, + 30 + ], + "CoffeeTable|-03.13|+00.02|+08.53": [ + -3.5, + 7.75, + 0, + 30 + ], + "CoffeeTable|-03.24|+00.01|+06.60": [ + -2.5, + 6.5, + 270, + 30 + ], + "DiningTable|-02.90|+00.01|+02.23": [ + -1.5, + 2.25, + 270, + 30 + ], + "GarbageCan|-05.71|+00.01|+00.30": [ + -5.25, + 0.75, + 180, + 30 + ], + "SideTable|-00.40|+00.01|+00.36": [ + -1.0, + 0.75, + 90, + 30 + ], + "SideTable|-00.53|+00.01|+08.52": [ + -1.0, + 8.0, + 90, + 30 + ], + "Sofa|-01.71|+00.00|+06.45": [ + -2.5, + 6.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan24-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..33ebd8c0cd3be20377e952e1aa38d20c79148755 GIT binary patch literal 1152 zcmbW!JxT*X7=YnXL?q-8)2+f*A|fJWD?7!;!b%pi!9tAeij8;*59Aecgp`&R7AaB~ zoq3um-DY{_XTO)^{qp+a>Simvgx6}?4R?KY8mqI}Nma*cHt(PN_VIS!PrKjs^Y&rr zHtWNE`_yf`e|%KO!-G1$#s5B|@b|1g(t9;Y??vIX8iIZ2*ZKS^pJ(^keRe-IX~%v3 z&fnv&!k>kgh0S;0d^Uf(n9t_3`D{L$&*pQ;4=*NZf%WV(Y2EL^dRPzZVLhye)07Zc z59`@2dRPzZVLhye^{^h+!+Q3L9@fKpSP$!AJ*<$BQ7Y~){@?_Lfs#Ug7fmB&xZYH@L3zO>K`8vr<-JO@`0x@fb^X@$_#QJC av3);t%zWt0G5^QhA9?pN_c8DFJ&wQsFq4rjK=gk>!`;^SsFN@uYsMhc6G4dQ|;AzZyPI ztM&8g)9|%g`{?Yn$WD%n>@)lC>7~u-&YF8ZXzosM3SND0&o6@)!SmpsVEv21c0cQ9 z{j8t$^Ste2{j7f(`dL5gXZ@_7^|OA~zY6`VpI7bs@G@Ax-}SS8_PtZt{Qvq`AM0a% ztdI4v{hhYYezu?OXZzWHw!d4Z&9R^DXZtzLn%r*L-102X@+`j>@+{BtEZ+-xmS=gE i-w%0~XLZgFumnbwLnDT7n^*f&+1d9bpoQKp+r|tWWSu zYQDU`-)p<#s`Y?UoK_8|M(9|be+wVRhw)*2l{SBn`(b<-ALbn@{QxH- BbR7Ty literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json new file mode 100644 index 000000000..3b62eb5e3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan27-objects.json @@ -0,0 +1,43 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Curtains", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json new file mode 100644 index 000000000..9dbe15133 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan27-openable.json @@ -0,0 +1,128 @@ +{ + "Cabinet|+00.13|+00.39|+01.77": [ + 1.0, + 1.5, + 0, + 30 + ], + "Cabinet|+00.35|+00.39|+02.36": [ + 1.0, + 1.75, + 0, + 30 + ], + "Cabinet|+01.51|+00.39|+02.36": [ + 0.5, + 1.5, + 90, + 30 + ], + "Cabinet|+01.76|+00.39|+00.87": [ + 1.0, + 0.0, + 0, + 30 + ], + "Cabinet|+01.76|+00.39|+02.35": [ + 1.0, + 1.5, + 0, + 30 + ], + "Cabinet|+01.97|+02.11|+02.62": [ + 1.25, + 2.0, + 0, + 0 + ], + "Cabinet|+02.04|+01.81|+00.28": [ + 1.25, + 0.75, + 90, + 0 + ], + "Cabinet|+02.04|+01.81|+00.87": [ + 1.25, + 0.5, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+00.89": [ + 1.25, + 0.75, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+01.77": [ + 1.25, + 1.0, + 90, + 0 + ], + "Cabinet|+02.04|+02.11|+01.81": [ + 1.5, + 2.0, + 90, + -30 + ], + "Cabinet|+02.04|+02.11|+02.62": [ + 1.5, + 2.0, + 90, + -30 + ], + "CounterTop|+02.06|+00.97|+00.58": [ + 1.25, + 0.5, + 90, + 0 + ], + "DiningTable|-00.15|00.00|+01.07": [ + 0.5, + 1.0, + 270, + 30 + ], + "Drawer|+01.91|+00.77|+02.06": [ + 1.25, + 1.75, + 0, + 30 + ], + "Drawer|+02.17|+00.77|+00.58": [ + 1.25, + 1.0, + 180, + 30 + ], + "Drawer|-00.02|+00.77|+02.06": [ + 0.75, + 1.5, + 0, + 30 + ], + "Fridge|+02.10|+00.00|-00.28": [ + 1.0, + -0.25, + 90, + 30 + ], + "GarbageCan|-00.31|00.00|-00.81": [ + 0.25, + -0.25, + 180, + 30 + ], + "Microwave|-00.31|+00.93|+02.08": [ + 0.5, + 1.75, + 270, + 0 + ], + "Sink|+00.94|+00.94|+02.65|SinkBasin": [ + 1.0, + 2.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan28-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7b6b1a810345427619241bcd42635ed7ebe51d2a GIT binary patch literal 1712 zcmbW%F-ikL6oBDTBuEg?Fx@C@Wo5+LPO-7DlErLDAx3t^Mm&WFN{*7!GDQjt3uD}` z@Re>ee3Rt8KLqlAb#r-ryOUnhYZ*7)eOu0QIiH-CDwoNueQxW=yIDJKe(o>ohpyS& zchmZ*+4yKQs`ANkmEZDzpJCcQdyC(5zdv__Q}EaP@B2T4*TJh``v(17``A9VkL_do z*gkgJ8&CV)+t2p1{cJzm&xeb&ee5|19tOwXVGv$7*SvV@cdwuIvwqgk`pwnP`dL5g zXZ>ss$5X$1{j8t$vwm~*vwqgk`dL5gXL~uG`rYei{jA^T^s|1}&-z(E>u3F}gX5{+ zy?)m3efn8H>u3F}pY^kT*3Y^)p62@==Ck>1KAX?xv-uzW|DyS9KAX?xv-xcPGR$Z5 M*?cyi&0o&H0c$G?VE_OC literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json new file mode 100644 index 000000000..7abe48eea --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan28-objects.json @@ -0,0 +1,43 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Blinds", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "SideTable", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Shelf", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json new file mode 100644 index 000000000..a56b16123 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan28-openable.json @@ -0,0 +1,122 @@ +{ + "Cabinet|-00.33|+01.89|-02.51": [ + -1.0, + -2.75, + 90, + 0 + ], + "Cabinet|-00.34|+01.89|-01.29": [ + -1.0, + -1.75, + 90, + 0 + ], + "Cabinet|-00.35|+01.89|-03.29": [ + -1.25, + -3.0, + 90, + 0 + ], + "Cabinet|-00.63|+00.39|-01.61": [ + -1.5, + -2.0, + 0, + 30 + ], + "Cabinet|-00.63|+00.39|-02.51": [ + -1.25, + -3.0, + 90, + 30 + ], + "Cabinet|-00.63|+00.39|-03.01": [ + -1.25, + -2.5, + 90, + 30 + ], + "Cabinet|-01.01|+00.39|-03.37": [ + -1.75, + -2.5, + 90, + 30 + ], + "CounterTop|-00.33|+00.98|-01.45": [ + -1.0, + -1.75, + 90, + 30 + ], + "CounterTop|-01.94|+00.98|-03.67": [ + -1.0, + -3.0, + 90, + 30 + ], + "DiningTable|-03.22|00.00|-00.45": [ + -2.5, + -0.5, + 270, + 30 + ], + "DiningTable|-03.59|+00.00|-03.26": [ + -3.75, + -2.25, + 180, + 30 + ], + "Drawer|-00.48|+00.78|-02.74": [ + -1.5, + -2.25, + 90, + 0 + ], + "Drawer|-00.50|+00.78|-01.45": [ + -1.25, + -1.0, + 180, + 30 + ], + "Fridge|-00.31|+00.00|-00.65": [ + -1.25, + -0.75, + 90, + 30 + ], + "GarbageCan|-02.42|-00.03|-03.54": [ + -1.75, + -2.75, + 270, + 30 + ], + "Microwave|-00.22|+01.47|-02.06": [ + -1.0, + -2.0, + 90, + -30 + ], + "Shelf|-04.03|+00.26|-00.30": [ + -3.5, + -1.5, + 270, + 30 + ], + "Shelf|-04.03|+00.49|-00.30": [ + -3.5, + -1.25, + 270, + 30 + ], + "SideTable|-04.03|+00.00|-00.30": [ + -3.75, + -1.5, + 0, + 0 + ], + "Sink|-00.60|+00.93|-03.39|SinkBasin": [ + -1.0, + -3.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan29-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3ae68148a7960946b2d57b4b5964ef738dbcc3ce GIT binary patch literal 1168 zcmbWzu}Z{16ouij^(oSgLMlNK5!}j7v9Yj{;AXK9R}!%ipTY;)SI8r5xn+tJ78b5% zzJLQZPILM1J#){QdB42AxVqU1FX1)L>-MgRCq+D69LKVVi)HiNRFAjIW?p~y&#Q;F z-uB!3>Z#uH-qB%M9PF3HTk+qs8-C7uHP%h4UB=@yglT^ETffeDlX0K(YP_HO;=IbE zFAwh0ek>1`2g`$p?EXi_eab7x^be_Tk9l6@o%(4%mKV#5<;6pGUtaS*<>D(ZmKW3e zM|w<;>E))!^qAhe=rKL+QvTtOcgj7zJLxcAY%lhom=EUvnfCI-{sHsD{4hVv5A((R V!;EvPiTRuJ$NVvW%pda)voGD%xz_*y literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json new file mode 100644 index 000000000..017eb7373 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan29-objects.json @@ -0,0 +1,39 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json new file mode 100644 index 000000000..f3cc8c38c --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan29-openable.json @@ -0,0 +1,80 @@ +{ + "Cabinet|+01.32|+01.96|-01.31": [ + 1.0, + -0.75, + 180, + 0 + ], + "Cabinet|+01.34|+00.59|-01.11": [ + 0.75, + -0.75, + 180, + 30 + ], + "Cabinet|+01.99|+00.59|-01.11": [ + 1.25, + -0.5, + 90, + 30 + ], + "Cabinet|+01.99|+01.40|-01.11": [ + 1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-00.85|+00.59|-01.11": [ + -0.25, + -0.75, + 180, + 30 + ], + "Cabinet|-00.87|+01.96|-01.31": [ + -0.5, + -0.75, + 180, + 0 + ], + "Cabinet|-01.53|+00.59|-01.11": [ + -0.75, + -0.5, + 180, + 30 + ], + "CounterTop|+00.20|+01.08|-01.51": [ + 0.25, + -0.75, + 180, + 30 + ], + "CounterTop|+00.97|+01.08|+00.42": [ + 0.5, + -0.25, + 0, + 30 + ], + "Fridge|-01.29|+00.02|+01.83": [ + -0.25, + 1.75, + 270, + 30 + ], + "GarbageCan|+01.86|-00.02|+02.39": [ + 1.5, + 2.0, + 0, + 30 + ], + "Microwave|-01.19|+01.62|-01.28": [ + -1.0, + -0.5, + 180, + 0 + ], + "Sink|+00.93|+00.94|+00.32|SinkBasin": [ + 1.5, + -0.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan3-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e5a612c999fc9c14ac13d0d68e8f8c54b1fb94ce GIT binary patch literal 1856 zcmbWzu};EJ6oBC?qfgPTnlPvnF(xv(XZ zABktQ%guL6|I_k$b9a4ve~{kNdpWM=k9B!oloyjh*)Ph;tbVOW(}!6-u72iMqvv_G zo6ny{FV)URrzeAcadzAdsa0GPnuuo=VB{dMWf+kM&rO^|pDh z_hUWQV?EZ}gdXd$9_z8*I`mkN^;nPfoW7U!xXF82kDWU4)HBy(J#H?$3G2rW$5Y>2 zpY>VabM~^|aXj_+^Zfq23|qHbpY>Uv^;y5o|BpWFvp(x{lRK=x4t>_=X3-T{pWA$Y6MC%2 mdaTEK+t6b@)?+=^OT+Gt|C9AtkM&ru7kaG6dYtmr8-4>qmmo+0 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json new file mode 100644 index 000000000..0f770854d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan3-objects.json @@ -0,0 +1,45 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "SideTable", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json new file mode 100644 index 000000000..1d586c647 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan3-openable.json @@ -0,0 +1,110 @@ +{ + "Cabinet|+00.58|+00.78|-02.05": [ + -0.25, + -1.25, + 180, + 30 + ], + "Cabinet|-01.46|+00.78|+00.47": [ + -0.75, + 1.0, + 180, + 30 + ], + "Cabinet|-01.46|+00.78|+01.31": [ + -0.75, + 0.75, + 0, + 30 + ], + "Cabinet|-01.46|+00.78|-02.00": [ + -0.75, + -1.5, + 180, + 30 + ], + "CounterTop|-01.81|+01.36|+01.18": [ + -1.0, + 1.5, + 270, + 30 + ], + "Drawer|+00.65|+00.60|+00.68": [ + 0.0, + 0.25, + 0, + 30 + ], + "Drawer|+00.65|+00.60|+01.02": [ + -0.25, + 0.5, + 0, + 30 + ], + "Drawer|+00.65|+00.84|+00.68": [ + 0.0, + 0.25, + 0, + 30 + ], + "Drawer|+00.65|+00.84|+01.02": [ + 0.0, + 1.5, + 180, + 30 + ], + "Drawer|+00.65|+01.06|+00.68": [ + -0.25, + 0.0, + 90, + 0 + ], + "Drawer|+00.65|+01.06|+01.02": [ + -0.25, + 1.75, + 90, + 0 + ], + "Drawer|-01.61|+00.68|-00.43": [ + -1.0, + -1.0, + 0, + 30 + ], + "Drawer|-01.61|+00.68|-01.22": [ + -1.0, + -1.75, + 0, + 30 + ], + "Fridge|+01.01|+00.23|+01.92": [ + 0.0, + 2.0, + 90, + 0 + ], + "GarbageCan|-01.63|+00.21|+02.19": [ + -0.75, + 1.5, + 0, + 30 + ], + "Microwave|+00.99|+01.31|-02.16": [ + 0.0, + -1.75, + 90, + 0 + ], + "SideTable|+00.98|+00.21|+00.87": [ + 0.5, + 0.0, + 0, + 30 + ], + "Sink|-01.99|+01.14|-00.98|SinkBasin": [ + -0.25, + 0.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan30-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..4dff912e9ee932067c7ef80e65180eb5cb8d8469 GIT binary patch literal 1296 zcmbW$u}Z^07zgk(h=Wg&Eef4}I^%e369XodD(80m# z-7ny|ndSI>x%|KH()8o%=JNV>C%lHYYTV53+v=>W&L^kUpsXg-_N5&?-A&tZ^Ig9f zJJLR!FmdAV9{%#(AF5hib2;8N9OQb)1NuXEXc) D)dQw{ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json new file mode 100644 index 000000000..03562e5d5 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan30-objects.json @@ -0,0 +1,45 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "PepperShaker", + "Pan", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "CellPhone", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Mirror", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "Bottle", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json new file mode 100644 index 000000000..779e34a00 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan30-openable.json @@ -0,0 +1,218 @@ +{ + "Cabinet|+00.14|+01.67|-01.56": [ + 0.5, + -0.75, + 180, + -30 + ], + "Cabinet|+00.62|+01.87|-01.26": [ + 0.25, + -0.5, + 180, + 0 + ], + "Cabinet|+01.40|+01.87|-01.26": [ + 0.5, + -0.75, + 90, + 0 + ], + "Cabinet|+02.82|+01.77|-01.05": [ + 2.25, + -1.25, + 90, + -30 + ], + "Cabinet|+02.85|+00.42|+00.41": [ + 2.0, + 0.25, + 0, + 30 + ], + "Cabinet|+02.85|+00.42|-00.61": [ + 2.0, + -1.0, + 0, + 30 + ], + "Cabinet|+02.85|+00.42|-00.96": [ + 2.0, + -1.25, + 90, + 30 + ], + "Cabinet|+03.07|+01.67|-00.71": [ + 2.25, + -1.0, + 90, + -30 + ], + "Cabinet|-00.19|+01.67|-01.34": [ + 0.25, + -0.75, + 180, + 0 + ], + "Cabinet|-00.92|+01.67|-00.62": [ + -0.25, + -0.5, + 270, + 0 + ], + "CounterTop|+00.13|+00.94|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "CounterTop|+01.21|+00.94|+00.46": [ + 2.0, + 0.5, + 270, + 30 + ], + "CounterTop|+03.11|+00.94|+00.02": [ + 2.5, + 0.0, + 90, + 30 + ], + "CounterTop|-01.01|+00.94|-00.04": [ + -0.25, + 0.0, + 270, + 30 + ], + "Drawer|+00.38|+00.19|-01.51": [ + -0.25, + -0.25, + 90, + 30 + ], + "Drawer|+00.38|+00.38|-01.51": [ + 0.0, + -0.5, + 90, + 30 + ], + "Drawer|+00.38|+00.57|-01.51": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.38|+00.77|-01.51": [ + 0.0, + -0.75, + 90, + 30 + ], + "Drawer|+03.02|+00.77|+00.70": [ + 2.25, + 1.25, + 180, + 30 + ], + "Drawer|+03.02|+00.77|-00.41": [ + 2.25, + 0.0, + 180, + 30 + ], + "Drawer|+03.02|+00.77|-00.78": [ + 2.25, + -0.5, + 180, + 30 + ], + "Drawer|-00.86|+00.19|+00.66": [ + 0.0, + 1.5, + 270, + 30 + ], + "Drawer|-00.86|+00.19|+01.43": [ + 0.0, + 0.75, + 270, + 30 + ], + "Drawer|-00.86|+00.19|-00.10": [ + 0.0, + 0.75, + 270, + 30 + ], + "Drawer|-00.86|+00.39|+00.66": [ + 0.0, + 0.0, + 0, + 30 + ], + "Drawer|-00.86|+00.39|+01.43": [ + 0.0, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.39|-00.10": [ + 0.0, + -0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.58|+00.66": [ + -0.25, + 1.25, + 180, + 30 + ], + "Drawer|-00.86|+00.58|+01.43": [ + -0.25, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.58|-00.10": [ + -0.25, + 0.5, + 180, + 30 + ], + "Drawer|-00.86|+00.77|+00.66": [ + -0.25, + 1.25, + 180, + 30 + ], + "Drawer|-00.86|+00.77|+01.43": [ + -0.25, + 0.75, + 0, + 30 + ], + "Drawer|-00.86|+00.77|-00.10": [ + -0.25, + 0.75, + 180, + 30 + ], + "Fridge|+01.01|+00.03|-01.47": [ + 0.5, + -0.75, + 180, + 30 + ], + "Microwave|-01.03|+00.87|+01.43": [ + -0.25, + 1.25, + 270, + 0 + ], + "Sink|+03.08|+00.89|+00.09|SinkBasin": [ + 2.5, + 0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan301-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3db3b80bbcf3897bfc7704cfaef557cb0288243f GIT binary patch literal 1392 zcmbW#uTH~I7(nq$gW@Ub3P}})KOtEa4uV0TNW;1y7Dn1-hVT?T5U;RDn4GMrKp+_O z{z$lzns4XpUC&9kx9i)ho4dWR3NOX9=^onRJTES0r$w0;vqigX>!*V?=`Q@ZoSkvnJJG}FO**9a~&(47xre;%b~ED`TDE$T$1+Id(g)KA(+ATBOKs`(+6iVq+^gII%s$LM%s$LMES3G> M`#pT#53}DT9}otFVE_OC literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json new file mode 100644 index 000000000..83f093816 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan302-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Safe", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json new file mode 100644 index 000000000..17003e4fb --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan302-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|+01.24|+00.00|-00.90": [ + 0.25, + -0.75, + 90, + 30 + ], + "Desk|-00.79|+00.00|-01.03": [ + -0.5, + -0.75, + 270, + 30 + ], + "Drawer|+00.30|+00.17|+01.16": [ + 1.0, + 0.75, + 270, + 30 + ], + "Drawer|+00.30|+00.46|+01.16": [ + -0.25, + 0.75, + 90, + 30 + ], + "Drawer|+00.42|+00.53|-01.55": [ + 0.0, + -1.25, + 90, + 30 + ], + "Safe|+01.62|+00.00|+00.45": [ + 0.75, + 0.5, + 90, + 30 + ], + "Shelf|-00.47|+00.83|-02.04": [ + 0.0, + -0.75, + 180, + 30 + ], + "Shelf|-01.29|+01.45|-00.60": [ + -0.5, + -0.5, + 270, + 30 + ], + "Shelf|-01.29|+01.45|-01.34": [ + -0.25, + -1.0, + 270, + 30 + ], + "Shelf|-01.29|+01.81|-00.60": [ + -0.5, + -0.75, + 270, + 0 + ], + "Shelf|-01.29|+01.81|-01.34": [ + -0.5, + -0.75, + 270, + 0 + ], + "SideTable|+00.31|+00.00|+01.23": [ + 0.75, + 0.75, + 0, + 30 + ], + "SideTable|+00.41|+00.00|-01.68": [ + -0.25, + -1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan303-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..486b0356b0c3ee8b46af7af8a9dd36b5de09ae91 GIT binary patch literal 1168 zcmbW#p-#g<9Khkj@)UK2q>2PW2+14{f7_p$qU$mbf@!K>gtIKSOwe?OaM*!yL@JcQ@RV9)7_qdxO}?qhwd zkM*%W*2ntT`((Ybi{q%*yk6GJdRZ^)WxcGI{omO4h+P~dF;HDz5#xW&Y}PS literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json new file mode 100644 index 000000000..50bca7fac --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan303-objects.json @@ -0,0 +1,35 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "GarbageBag", + "Window", + "GarbageCan", + "Poster", + "Pen", + "Cloth", + "CreditCard", + "Book", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Vase", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json new file mode 100644 index 000000000..8704b6b03 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan303-openable.json @@ -0,0 +1,122 @@ +{ + "Bed|-01.05|+00.00|-01.85": [ + -1.0, + -1.0, + 180, + 30 + ], + "Desk|-01.71|+00.00|-00.37": [ + -1.0, + -0.5, + 270, + 30 + ], + "Drawer|-01.79|+00.10|-01.14": [ + -0.5, + -0.5, + 180, + 30 + ], + "Drawer|-01.79|+00.25|-01.14": [ + -0.75, + -0.75, + 180, + 30 + ], + "Drawer|-01.79|+00.39|-01.14": [ + -1.0, + -0.75, + 180, + 30 + ], + "Shelf|+01.31|+00.97|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.31|+01.17|-02.30": [ + 1.25, + -1.75, + 180, + 0 + ], + "Shelf|+01.31|+01.37|-02.30": [ + 1.25, + -1.75, + 180, + -30 + ], + "Shelf|+01.31|+01.57|-02.30": [ + 1.25, + -1.75, + 180, + 30 + ], + "Shelf|+01.32|+00.16|-02.30": [ + 0.75, + -1.25, + 90, + 30 + ], + "Shelf|+01.32|+00.46|-02.30": [ + 1.75, + -1.5, + 270, + 30 + ], + "Shelf|+01.59|+00.61|-02.31": [ + 1.25, + -1.75, + 180, + 30 + ], + "Shelf|+01.84|+00.97|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.84|+01.17|-02.30": [ + 1.5, + -1.5, + 180, + 0 + ], + "Shelf|+01.84|+01.37|-02.30": [ + 1.75, + -1.5, + 180, + -30 + ], + "Shelf|+01.84|+01.57|-02.30": [ + 1.75, + -1.5, + 180, + 30 + ], + "Shelf|+01.85|+00.15|-02.29": [ + 1.25, + -1.25, + 90, + 30 + ], + "Shelf|+01.85|+00.45|-02.30": [ + 1.25, + -1.5, + 90, + 30 + ], + "SideTable|+00.44|+00.04|-02.65": [ + 0.5, + -2.0, + 180, + 30 + ], + "SideTable|-01.82|+00.00|-01.14": [ + -1.0, + -0.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan304-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d6e9934a5c069b8d62bd8481899144452732f6d5 GIT binary patch literal 1808 zcmbW#p-#hK6o%n4$yL-9k_jLoA%tX8I0y!TA`9z+AdGYbL%0eqXt&Tyn4GMbKp+_O zJQGJUbMl_Q{ob$bKCf@DZtnJqx8l8;){BRxIxnk>*;zF#tJ%DHZ6?q6^JZHA?k^`# zi+a0XJWgKfEgu{ooes;B!(sVR{`0qA{QcTdKf7f=SBW>VU&nMEZqs?6QWU%M$iwpS zI-PfkH<_2wGp0VPV7WL?eeLzd-Urqf>x=cp`tCS-@#>3Rhx62Lw;%NztRL17>xVb# zetVugy$^dn%!m0fALh%sI8Q!%KHPbpn0(IpmHr^ZN$8vF={Pz6z{FooN>AUee=f^xaPyR3ei)C-b{Foo}V}8t!`7!@@ s@?(C?kNGh_=EwZFjpr@KOfiG`obzEm%!m1~yg}s4!}72^EN?LW0Vy~K!2kdN literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json new file mode 100644 index 000000000..3aed39397 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan304-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "LaundryHamper", + "BasketBall", + "Pillow", + "Box", + "Statue", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Mug", + "Bed", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json new file mode 100644 index 000000000..74d9722a3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan304-openable.json @@ -0,0 +1,26 @@ +{ + "Bed|-01.30|+01.94|+01.44": [ + -0.25, + 1.75, + 270, + 0 + ], + "Desk|-00.99|+00.01|-01.41": [ + -1.0, + -0.75, + 180, + 30 + ], + "Drawer|-01.41|+00.23|-01.30": [ + -0.75, + -0.5, + 270, + 30 + ], + "Shelf|+00.00|+00.01|+00.04": [ + -1.0, + -0.75, + 180, + -30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan305-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0df7e536cd06e4bcfb2e6140507b7d48aca555e5 GIT binary patch literal 1472 zcmbW#u}Z^G6o>J+`V`rskVzbh2;JNi7Y8Q^HpM}#B;r!~6h2U2A&=0pV}=YJt>*p$ zp3y9a@7#0#UvHDIyNBER$CKgH}Id&}O7Q8j(2i}Sp=7@rnpUW_O8Ydw6vpVXu3XMQ<+ znpT_n^l|u7ZG3okQs&1;W&V->_d3XauVueo*RyS}lIQ7ule`G_zWbhEhUeMyojv!* zIuG;qlv%b&bNjLLvHd!GFMQWNakXDJ@3#}SAKQxf$f4>*J8@w01AMAI| z(&cwx=j6Ehea-cp&SN-Nq>Sq0{pY^kT*3bG`KkH}x-8pA%A?s)T cte?B@rcQIKe%8Oe&5!wsO!Xi;`m*7-#35%uM)2l%lChX z`JYkc<5jxn*FdxhZ59z)AsP=>T;6A)DAKb@$ z%m?$qs@z=V>-Uk5D7bVe%@vRTBnrGR6cZH;s#flOa;#K*SW|V!R432rr?Rz{uF40|SFd z&(nl6+U4Z^{+##MhVXs&aC`rF6h6XdJ}DN@Wqy_A*VD_qpXJke`Cg7+pXTMH_^aQH zXNzK2U%ZUpiXER0&IkSM;;f&2W&eCm!v0we+jFyQ&vn98Ue(@``+WL*>%@ooFdyc_e3%dOtr8#R!+e+z^I<+*@x+tAs}I`>=EwY) zA2-Q9zrK?xB93^W!R+=hqL>?>qBj{~K5yT*v#dJXjtq508?#FKP z?bGe$QpNeD}Yn~#@*>$zpU>AroaeshVb8;!hdmE_9`-z3ykh5Y6*t27$q&h6@{~L$ z>*qQ3<2KG^{a8Qt9GtKExvwAV$NI5;tRF|M!uqj(tRL&g`tcn7SU=CDAM3~Zv3{%{ zJBRaCKlk-x{a8QNkM(2ySU=W}^<({5Ki1E4=*Rl8eykts$NI5zIbZd2Uq9B5^<({b zh@ThMkM-j*eO^EB>&N=ptsm>h`muhjAM3~Zu^pVR`nj(k4|lZ~>&HX%VEtG>9@FQi zWc_?zKRfkf{a8QNkM(2ySU=W}?c#jZ&;23#v3{%{>&N=Beykts$NJf&AM3~Zv3{%{ z>&N=Beyktc$@yx(j`p+tY(Lx2_OtzLKikh^d_UQKwx8|yeYcCC;Kd1d{Kikjtv;BOCJ#0VQ&-SzZY(Lw7Nc-7- zwx8{1`}q+2c}}+9`}VW_Y(Lvyx^jB?{bl>vezu?OXZv}M{cJzm&-SzZJfyEzpW^s$ zSN}I$#htLfTi*9~fXDRtDOs;3zMfv(_T}_yx_Vvo_1biC?c*BOs|oAHda+)t7wg4( zv0hx_#d@(`tQYIW`YgI~dg;S$U+=R%?B|I~`n*2g*N63CeOMpXhxOsQwiMQf^Q~l>+rHjseYi>Qmt=i>ULV$n^xcEjo787a zu?sv+$+BI2Hf6AVu=#ih_sv%qhcq|FKIHjzuM2g4cl9(M^Nab#{Ngd_`HjACjQq-X z$uH&?cWEBx7xRnx#r)#G{+Ta(Vmch7{p~@I=`lT~w>Lee$Ml%K3;%-YF+CpB`+HaO RF+HZo^!|Y!(_{L6_67EG(ZT=# literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json new file mode 100644 index 000000000..abcb8f2a2 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan310-objects.json @@ -0,0 +1,31 @@ +[ + "BaseballBat", + "AlarmClock", + "BasketBall", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Poster", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json new file mode 100644 index 000000000..586254660 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan310-openable.json @@ -0,0 +1,50 @@ +{ + "Cabinet|-00.24|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "Cabinet|-00.62|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "Desk|-00.96|00.00|-01.94": [ + -0.5, + -1.25, + 180, + 30 + ], + "Drawer|+01.62|+00.16|-00.99": [ + 1.0, + -1.75, + 90, + 30 + ], + "Drawer|+01.62|+00.45|-00.99": [ + 0.75, + -1.5, + 0, + 30 + ], + "GarbageCan|+00.13|-00.03|-02.15": [ + 0.25, + -1.5, + 180, + 30 + ], + "Shelf|-00.96|+01.53|-02.10": [ + -0.5, + -1.25, + 180, + 30 + ], + "SideTable|+01.69|+00.00|-00.99": [ + 1.25, + -1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan311-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2cb922b71da809507481b3a1c9411bc8f03074aa GIT binary patch literal 3760 zcmbW%ziJdw6bImI5RnkXzp1BNg{`(xL~tuRC5?rZEXf87F|sQ*;#2rQd4+j|lqsi} zB87!9bG`+CrQ2M-d*`0>JG06DdiVbA(T7{@d;2jvS#OUwvzOiM)#;1byqle#ZN6<* zUp}5~PS$_-->g1w*Vp^oPphx%Yd>8qp3l3*vw8Qk`_IpQyZKz4PwQ2!eRw);ZFm0q z-{&vFm*F8ihOffE!)+P;&L@wx%FEMfYur~omY3z_A)c4lxx6edd!Iw(WBItRek>o$ z$3r|nhUN3TJeQG&yM?}z1Q`B{D*iyf7pXF!yS$>wEckjRElwV)@S$>wE z)#Y5}w=X{r-gm9?JC~pR|FhpK9_#zi*L-X~HXoah&Byw1uI95p)Ld*nHXoah&Bx}` z$9!x)HXoah&Bx|reK}Y2**71XkIl#CW2?Hks&8L?R-e^p^|KD=s=j^oS$$UDJ$>18 zoU8iw)#ttC^o_B8?&-(+v3s1We)iS3uRg2K>a#kWtNP|rpVepeS$$UT_Oji4)MNEn zJ$C<2+-LXMeRltD+-LXMeKrq!e!uE@o}C}WIXk}>=d2%lU-#>I_gQ~-pZog#eNgvX zeYmgRL-zZ^-XF`u@~}KC5Bq!Ly~@SDcb5NQJy-D?%g^$&{477q&+@bUEI-T7^0WMp zB0tN|^0Ry_AIrz`v3x8a`#)j*9#>xdSU=W}^<({5{U=eM)o1lteO8~a-ucY_=ziyv5ch|S~C*du;SIf44?5c}cU9M(T9jn#4d+nN+hjq7XfA3#4&wYEm z-#;~*_UNGp2z0xi+OAwo5$v{d2AksMSkyj-lVXeUD3mOSPu_*Ki0!~SP$!AJ!5qU zelM(t_3)5;SP$!AJv>?XYrN`l)x&x?c^~M0!N^vq_D6Q-F*~O zy3OYe%=^G|wOOvWJ#|xeliGam%uJhkHZ_qp+1XuPa@w6;YQOVEa?EWz&kxDPwmcY5 zB0U;L`l0_lef2wa;qx65ehF>@S0Uk2u(v7I-H-hQ#!upd@xl1uGWcK;k4${b@xl1u zD)`}Aa3h$0*#pa@zncdiOg~INOg~INUfvt#Ians&&zydk{*DWO#U6byeK32lO!}D9 S2RHm5GW4^DA7&56SH&MW35^s0 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json new file mode 100644 index 000000000..31b0cedac --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan313-objects.json @@ -0,0 +1,34 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "HousePlant", + "Laptop", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "TissueBox", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json new file mode 100644 index 000000000..fa062d428 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan313-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|-01.74|+00.00|-00.07": [ + -0.75, + 0.0, + 270, + 30 + ], + "Desk|+00.63|+00.00|-01.56": [ + -0.75, + -1.5, + 90, + 30 + ], + "Drawer|+00.27|+00.16|-01.43": [ + -0.25, + -0.25, + 90, + 30 + ], + "Drawer|+00.27|+00.35|-01.43": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.27|+00.55|-01.43": [ + 0.75, + -0.5, + 270, + 30 + ], + "Drawer|-00.16|+00.16|-01.43": [ + -0.75, + -0.25, + 90, + 30 + ], + "Drawer|-00.16|+00.35|-01.43": [ + 0.5, + -0.25, + 270, + 30 + ], + "Drawer|-00.16|+00.55|-01.43": [ + 0.25, + -0.5, + 270, + 30 + ], + "Shelf|+01.41|+00.18|-01.51": [ + 0.75, + -0.25, + 90, + 30 + ], + "Shelf|+01.41|+00.38|-01.51": [ + 1.0, + -0.5, + 90, + 30 + ], + "Shelf|+01.41|+00.57|-01.51": [ + 1.0, + -0.5, + 90, + 30 + ], + "Shelf|+01.54|+00.49|-00.48": [ + 0.75, + 0.0, + 180, + 30 + ], + "SideTable|+01.56|+00.00|-00.47": [ + 1.0, + -0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan314-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..f10c008a9a66b66ee3094394f56b5cc292d50f9a GIT binary patch literal 1200 zcmbW!uTH~Y6o=t&lUzmJ2T2uT5JJKf4uV0TNW;1y$VOU%AzTF)v|HFEOioTzAP@}N zM{p!HC-3R+&*}DYeS39tH%hPREzj!qp~+`OKA)fFvdHsg^U_p{`(-n$fA*KvQ(N!% z?PK*^@A+_YQWnQYW$|A8_c=(v&-S99-Kw9vz+K?az+Zvo?N)#Duskde%fs@vArH&L z^6+}NZ!`Eef#rMe`>}j1AG;UpTZcZZ59`C-a39u(^Q-9?Y-F}=I#F+Fx4<~R8;<^9Q|NrwkbdQAU)M%DVMUw-FanOnh|!P~{VW!Ay&``mqYe<$2$_t|}}%01Q_ zg&ym%9_#VfbG3f>Gx#I;J@_s7HQ2spUG`@CvVGaUY+tr7+n4Rj_GSCBY0o(A>)gI< zU$!sXm+i~;W&5&yS>Imztk3$a&-$$Icj~h~>$5)Vv%ddLpY>Uv^;w_wO?}p9eb#4v zHg)6FcdpO+tk3$f!*S|6*Jpj!chC2-_c%^{=lZPgJ$=?^_c%^{=lag|S)cV;hyUg` D0lgP8 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json new file mode 100644 index 000000000..67d605fac --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan315-objects.json @@ -0,0 +1,28 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Mug", + "Bed", + "TableTopDecor", + "CoffeeTable", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json new file mode 100644 index 000000000..9d1fe11f2 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan315-openable.json @@ -0,0 +1,110 @@ +{ + "Bed|-02.98|+00.01|-01.18": [ + -1.75, + -1.0, + 270, + 30 + ], + "CoffeeTable|-00.50|+00.01|-03.99": [ + -1.0, + -2.5, + 180, + 0 + ], + "Desk|-00.86|+00.01|-04.03": [ + -0.75, + -3.25, + 180, + 30 + ], + "Drawer|-00.50|+00.07|-03.80": [ + -1.25, + -2.5, + 90, + 30 + ], + "Drawer|-00.50|+00.23|-03.80": [ + -1.25, + -2.75, + 90, + 30 + ], + "Drawer|-00.50|+00.39|-03.80": [ + -1.25, + -2.75, + 90, + 30 + ], + "Drawer|-03.61|+00.11|-03.26": [ + -2.25, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.11|-04.06": [ + -2.25, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.30|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.30|-04.06": [ + -2.5, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.49|-03.26": [ + -2.5, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.49|-04.06": [ + -2.5, + -3.25, + 180, + 30 + ], + "Drawer|-03.61|+00.69|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.69|-04.06": [ + -2.75, + -3.5, + 180, + 30 + ], + "Drawer|-03.61|+00.88|-03.26": [ + -2.75, + -4.0, + 0, + 30 + ], + "Drawer|-03.61|+00.88|-04.06": [ + -2.75, + -3.5, + 180, + 30 + ], + "Dresser|-03.65|+00.01|-03.66": [ + -3.0, + -3.5, + 270, + 30 + ], + "GarbageCan|-01.84|-00.02|-03.90": [ + -2.25, + -4.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan316-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..6d83f59eb4e355ad5d0e7f104faadc30d538014d GIT binary patch literal 1056 zcmbWzu}Z^G7>42F>Q!Vr3Yi3-pY!=jtDKl7{Rxo>y# z{;7FwcYJa_sjIWox>{BLeU8)bv;N%YSIHsp{%uN!_tU@UH|6}cq&}<<>%&9o!|TBM z$Iy@UWBph^){i&EhsVJD()Zz^?1lL;Kjz2$m>)~tnEdAam>=_Fe$0>gqX)<2Kg`Sj s#Qc~a^W$x}Zyz3eV)t-N|HIrq*gn`k*gjb5jj7*UKOTKwN&Un08!2+Cy8r+H literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json new file mode 100644 index 000000000..98fd21897 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan316-objects.json @@ -0,0 +1,30 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "Desktop", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "HousePlant", + "Laptop", + "Bed", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json new file mode 100644 index 000000000..bf39297e3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan316-openable.json @@ -0,0 +1,44 @@ +{ + "Bed|-01.70|+00.00|-00.45": [ + -0.75, + -0.25, + 270, + 30 + ], + "Desk|+00.62|+00.00|-01.51": [ + 1.0, + -1.0, + 90, + 30 + ], + "Drawer|-00.56|+00.16|+00.46": [ + 0.25, + -0.25, + 0, + 30 + ], + "Drawer|-00.56|+00.46|+00.46": [ + 0.0, + -0.25, + 270, + 30 + ], + "GarbageCan|+01.66|-00.02|-00.39": [ + 1.0, + 0.0, + 90, + 30 + ], + "Shelf|+01.62|+00.56|-00.80": [ + 0.25, + -1.5, + 90, + 0 + ], + "SideTable|-00.56|00.00|+00.53": [ + 0.0, + 0.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan317-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..8fb312dceb153889f4dd5423cd0fb302f6383aad GIT binary patch literal 1680 zcmbW$uTH~29Ki8nd5XG1GKJw!Na}D93<5(h&^dDR`j0LLXsrvZA75f>vr z%{O6x_qD!D>)z96eb#6Da2)l`>$AS+^jV+VbY9kH`*Ixh&Fh=jXMJu{pY>UvbvTat zO*yRSvp(yyKI^kS>$AS!xjuJ(AL)Gh*7aGR^;w_w{jc;{pY>Uv^;w_wS-%b6KkKtT Z>$5)VvpzSz*EBkp^*DCn`963z`Ui(uBv$|c literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json new file mode 100644 index 000000000..0f7129662 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan317-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "LaundryHamper", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Poster", + "Pen", + "Cloth", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Mirror", + "Floor", + "Safe", + "Laptop", + "Bed", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json new file mode 100644 index 000000000..8145411a3 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan317-openable.json @@ -0,0 +1,92 @@ +{ + "Bed|+01.38|+00.00|+00.07": [ + 1.5, + 1.0, + 180, + 30 + ], + "Drawer|+00.41|+00.11|-01.63": [ + -0.5, + -0.25, + 90, + 30 + ], + "Drawer|+00.41|+00.29|-01.63": [ + -0.25, + -0.5, + 90, + 30 + ], + "Drawer|+00.41|+00.49|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.41|+00.68|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.41|+00.87|-01.63": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.11|-01.63": [ + -1.25, + -0.25, + 90, + 30 + ], + "Drawer|-00.39|+00.29|-01.63": [ + -1.25, + -0.5, + 90, + 30 + ], + "Drawer|-00.39|+00.49|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.68|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Drawer|-00.39|+00.87|-01.63": [ + -1.0, + -0.75, + 90, + 30 + ], + "Dresser|+00.01|+00.00|-01.68": [ + 1.0, + -1.25, + 270, + 30 + ], + "GarbageCan|-02.21|-00.02|-01.74": [ + -1.75, + -1.25, + 270, + 30 + ], + "Safe|+01.64|+00.00|-02.04": [ + 1.0, + -1.25, + 90, + 30 + ], + "SideTable|+02.24|00.00|+01.33": [ + 1.75, + 1.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan318-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..998979a6b0345090aaf7d62dee99b1c068d3b895 GIT binary patch literal 1632 zcmbW$u}Z^G6b9g{h!me9TNE;hgNo2hZiMP_CI(E#Ep@W09 z$+w)*ESK;0p8vlI^!xVy=I&uHeWcHPS}mUH{4&e0X6Jd4<+FMHUQb>h=k>Ju+rOT? zEUNAP;(78`ZGC)kR%E9qMfR2b_c=O^SRTt`c`UC9c`T3RvHAXMrR00Dc{a~hIdPR|UmmyN z-oBGL@5%1X`dKc=Rlj}b<37i=9rum)yI^_F>0xsm*Jj9*Yo5)sd3N6a!g+R{o&O2% z!OpY$rLzAH=2;(`XY>1Ep3Sp)_MYrL*gaX_L78@s`?5aP$NE?w>tlU~p^x>kKGw(j USRd;fg+A8D`dA<9V|}CY7Xp6Z6aWAK literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json new file mode 100644 index 000000000..8d246757f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan318-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ArmChair", + "TennisRacket", + "Shelf", + "Dresser", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json new file mode 100644 index 000000000..3f9814429 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan318-openable.json @@ -0,0 +1,158 @@ +{ + "ArmChair|+01.71|00.00|+01.53": [ + 1.5, + 2.25, + 180, + 30 + ], + "Bed|-00.87|+00.01|-00.92": [ + 0.25, + -0.75, + 270, + 30 + ], + "Cabinet|-00.65|+00.27|+02.25": [ + 0.75, + 1.5, + 0, + 30 + ], + "Desk|+01.81|+00.00|-00.01": [ + 1.25, + -1.0, + 90, + 30 + ], + "Desk|-00.66|+00.01|+01.81": [ + 0.25, + 2.0, + 270, + 30 + ], + "Drawer|+01.69|+00.16|-00.38": [ + 0.5, + 0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.16|-00.81": [ + 0.5, + -0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.35|-00.38": [ + 0.5, + 0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.35|-00.81": [ + 0.75, + -0.25, + 180, + 30 + ], + "Drawer|+01.69|+00.55|-00.38": [ + 0.75, + 0.0, + 180, + 30 + ], + "Drawer|+01.69|+00.55|-00.81": [ + 0.75, + -1.25, + 0, + 30 + ], + "Drawer|-00.55|+00.16|+02.94": [ + 0.25, + 2.25, + 0, + 30 + ], + "Drawer|-00.55|+00.38|+02.94": [ + 0.25, + 2.25, + 0, + 30 + ], + "Drawer|-00.55|+00.57|+02.94": [ + 0.25, + 2.5, + 270, + 30 + ], + "Drawer|-00.55|+00.58|+02.25": [ + 0.25, + 2.75, + 180, + 30 + ], + "Drawer|-00.66|+00.23|-01.31": [ + 0.5, + -0.5, + 180, + 30 + ], + "Drawer|-00.66|+00.55|-01.31": [ + 0.25, + -0.75, + 180, + 30 + ], + "Drawer|-00.66|+00.83|-01.31": [ + 0.25, + -0.75, + 180, + 30 + ], + "Dresser|-00.67|+00.00|+02.94": [ + 0.25, + 2.5, + 270, + 30 + ], + "GarbageCan|+02.02|-00.04|-01.24": [ + 1.5, + -1.5, + 90, + 30 + ], + "Shelf|+01.77|+00.18|+00.76": [ + 0.5, + 0.25, + 0, + 30 + ], + "Shelf|+01.77|+00.18|+00.94": [ + 0.5, + 0.5, + 0, + 30 + ], + "Shelf|+01.77|+00.38|+00.76": [ + 0.75, + 1.25, + 180, + 30 + ], + "Shelf|+01.77|+00.38|+00.94": [ + 0.75, + 0.5, + 0, + 30 + ], + "Shelf|+01.77|+00.57|+00.76": [ + 0.75, + 1.25, + 180, + 30 + ], + "Shelf|+01.77|+00.57|+00.94": [ + 0.75, + 0.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan319-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..5d5660830bfc55bf6e7fb23ecc3720fa4ffb1095 GIT binary patch literal 1680 zcmbW!ElvYb6o%nTC94=WkW^v#2}!GP5DWrE8af0)D47xrVHGT>TbLzOR#uFtsGxA~ zQ*k6?PTqTF-hAKO@0+{p+xvs`kv{8bGkkhSI;)3O{WNRe+sW(0terN$=U0=L zd9yp8KTqD89Uq;a4y%*nVf9u0_c=^|&vKOKc9CaScvILOuj0PE*O%D^&eoLn`|>^J z$NYF5-tPl%0&fGSaZbQD2)tb6{klx~ao(ncyW+?4WBIZCxDVgUZ!bTVAIpzdCAX;$ z?!sQ5{l4VE`e1#qKDZCx>tnAE)(7i@-IE@AV(;NN^>wZx=cp`eJ=C zpPYP{5A$I@%%^8x?gR5-KFo*ty5ix(e3%dO;dSx&&wQ8<^I<;B=brd5ALhe+n9t>tDDQ~+r8qoc&p}Zf8SMSWp%zdt?IH`EW4MkdAeJ6^Y&~1qIvAw z-G2YjJhwX^9G}$X(P3S_m;b%?i|=cgO>0_B>pJr$^O!khHg8=0p2y~~d7NS%JHLr} z&a?Bpjpy0(>v*1ru)b5xF1XZb9j<#4{rALBd9XZb9jq$$MRV|%V+tV UVxIrOnA!JmUmqT_^ZIOOp9X=z82|tP literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json new file mode 100644 index 000000000..36b55cead --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan320-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "Curtains", + "BasketBall", + "Pillow", + "Pencil", + "SideTable", + "KeyChain", + "GarbageBag", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Footstool", + "Desk", + "Mirror", + "Floor", + "Laptop", + "Bed", + "TennisRacket", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json new file mode 100644 index 000000000..4461adc3d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan320-openable.json @@ -0,0 +1,50 @@ +{ + "Bed|-01.04|+00.01|-00.69": [ + -0.5, + 0.25, + 180, + 30 + ], + "Desk|+01.52|+00.00|+00.39": [ + 0.75, + 0.5, + 90, + 30 + ], + "Desk|-01.72|+00.00|+00.92": [ + -1.0, + 1.0, + 270, + 30 + ], + "Shelf|-01.70|+00.16|+01.54": [ + -0.5, + 0.75, + 0, + 30 + ], + "Shelf|-01.70|+00.38|+01.54": [ + -0.5, + 0.75, + 0, + 30 + ], + "Shelf|-01.70|+00.57|+01.54": [ + -0.75, + 1.0, + 0, + 30 + ], + "Shelf|-01.84|+01.08|+01.24": [ + -1.25, + 1.5, + 270, + 30 + ], + "SideTable|+00.63|+00.00|-01.71": [ + 0.25, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan321-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..47b25677080275d02a7ad4d0d6c6cf0bced364f2 GIT binary patch literal 1600 zcmbW$u};E39KhkTA;$0&-Kq%_lNu8`xoKP+oD7i?1|y~z7vod-K=KGY0wW_s2L=Yw zyKlMCE|;(E{r;uE*X{ky-NR9M4#-i|aXUv^;v(F^;w_wS)cV; zKfbjPydTzQeb#4v)?ba{nWBy>>$5)Vvp(yuvp(yyKI^kS>-(L1e%5Dw)@Oaz-)7Ix c`mE3Ttk33jsqg>C{(tQAvH5I1o7atg0H)fy0{{R3 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json new file mode 100644 index 000000000..8749b01dc --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan321-objects.json @@ -0,0 +1,27 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Bed", + "ArmChair", + "TissueBox", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json new file mode 100644 index 000000000..6efd3c144 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan321-openable.json @@ -0,0 +1,44 @@ +{ + "ArmChair|+00.85|00.00|-02.14": [ + 1.5, + -1.75, + 270, + 30 + ], + "Bed|+00.91|+00.00|+00.14": [ + 0.75, + 1.25, + 180, + 30 + ], + "Desk|+03.24|+00.00|-01.59": [ + 3.0, + -1.0, + 180, + 30 + ], + "Drawer|+00.33|+00.62|+01.30": [ + 1.5, + 1.25, + 270, + 0 + ], + "Drawer|+00.33|+00.62|-01.02": [ + 1.5, + -1.75, + 270, + 0 + ], + "SideTable|+00.28|+00.00|+01.30": [ + 0.75, + 1.25, + 270, + 30 + ], + "SideTable|+00.28|+00.00|-01.02": [ + 0.75, + -1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan322-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d55bd506cbc30551aafd5e5009bd845a49075629 GIT binary patch literal 1792 zcmbW$u};EJ6b9fcqfgPTnlPwwFvbKXH;s#flOa;#K*SW|Vtfi8h*#(%Ffw-N;J_f- z`_+y-~S zpTXN;dFGJE@>m|rV|ku~JeJ4uSRTvs9Obb*mdElqjr-@z@|#t^FQ4VJe3sAhd64^9 zU*DFJKJN1G!}?es>*K-Lr+(Gf&(aIWAkv6=V9}(dDuK`9*(Q~x9|S9qb~?*2~Yq4 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json new file mode 100644 index 000000000..43380c052 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan322-objects.json @@ -0,0 +1,30 @@ +[ + "BaseballBat", + "AlarmClock", + "Curtains", + "Pillow", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "Cloth", + "CreditCard", + "Book", + "CellPhone", + "Cabinet", + "DeskLamp", + "Drawer", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ArmChair", + "Shelf", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json new file mode 100644 index 000000000..ab36ff242 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan322-openable.json @@ -0,0 +1,122 @@ +{ + "ArmChair|+02.57|+00.00|-00.82": [ + 2.0, + -0.5, + 90, + 30 + ], + "Bed|-00.75|-00.02|+00.11": [ + 0.75, + 0.0, + 270, + 30 + ], + "Cabinet|+02.48|+00.50|+01.00": [ + 1.75, + 0.25, + 0, + 30 + ], + "Cabinet|+02.48|+00.50|+01.01": [ + 1.75, + 1.75, + 180, + 30 + ], + "Cabinet|+02.48|+00.50|+02.03": [ + 1.75, + 1.25, + 0, + 30 + ], + "Cabinet|+02.48|+00.50|-00.02": [ + 1.75, + 0.75, + 180, + 30 + ], + "Drawer|+02.57|+00.90|+00.23": [ + 2.0, + -0.25, + 0, + 30 + ], + "Drawer|+02.57|+00.90|+00.75": [ + 2.0, + 1.0, + 180, + 30 + ], + "Drawer|+02.57|+00.90|+01.26": [ + 2.0, + 1.0, + 0, + 30 + ], + "Drawer|+02.57|+00.90|+01.78": [ + 2.0, + 1.5, + 0, + 30 + ], + "Drawer|-01.53|+00.46|+01.48": [ + -1.0, + 1.5, + 270, + 30 + ], + "Drawer|-01.53|+00.46|-01.25": [ + -1.0, + -1.25, + 270, + 30 + ], + "Dresser|+02.82|+00.00|+01.01": [ + 2.25, + 0.75, + 90, + 30 + ], + "GarbageCan|+01.35|+00.00|-01.69": [ + 0.75, + -1.0, + 90, + 30 + ], + "Shelf|-01.55|+00.04|+01.33": [ + 0.0, + 1.5, + 270, + 30 + ], + "Shelf|-01.55|+00.04|+01.60": [ + -0.5, + 1.5, + 270, + 30 + ], + "Shelf|-01.55|+00.04|-01.13": [ + -0.5, + -1.25, + 270, + 30 + ], + "Shelf|-01.55|+00.04|-01.40": [ + 0.0, + -1.25, + 270, + 30 + ], + "SideTable|-01.60|+00.00|+01.48": [ + -1.0, + 1.5, + 270, + 30 + ], + "SideTable|-01.60|+00.00|-01.25": [ + -1.0, + -1.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan323-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0add409d466e1b9f7b3b2198c7ab57455ca4ff83 GIT binary patch literal 3184 zcmbW&u}ULB7{Kvy5jpNDwp)cXTAd=em7QX9#Z?kCVj(Jt*oaTz1G$f|k6>xJ#THwn zFvraAz^}X%PJRDv#|hKQWKZWAoTNHjmBYb(znp z&2#@bGgV!FqKEac9@fKpSP$!AJzTZ9gR?e2yZlTa>tlVakM*%W*2ns|YI6q{rS*G$ zrjPZpKGw(jcq-o?>tlUfwYh_{Qkp^^>tlVakM;3X`gk3z&+GbF-x&H>AM4|x%wv75 zkIfsxJT{NbWAk_{^VvN1d9dFbe+PX}>~mq=>>Q4(zo+*5a!+=D?n^(rKf6D>Kab)4 z?(cQ?XZP3X{_Otj{_OtjT#l>z+joCtQ`SmhXf0 zupYMRh^rp^dRPzZ;j#3v9@fKp;#`ia9{YND@OhL~kJt6E9@Z7-a9qu|Z$6vP=Ck`d z$9&es-p6q@-@f^5KAZ1-=Ck>1K0AlwYQBB*+2_yxe{j|2BG&6%z1)ZIU9Z>mvU54E fdhP3Fy{wn@IY%GsV|}cToy&36XI~%dn@+v}36aM& literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json new file mode 100644 index 000000000..52144cfd1 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan323-objects.json @@ -0,0 +1,30 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Sofa", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "Bowl", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "Safe", + "Laptop", + "Mug", + "Bed", + "Dresser", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json new file mode 100644 index 000000000..e202bfd8c --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan323-openable.json @@ -0,0 +1,80 @@ +{ + "Bed|-01.61|-00.03|-01.86": [ + -1.5, + -0.75, + 180, + 30 + ], + "Desk|+02.32|-00.01|-03.22": [ + 2.0, + -2.5, + 180, + 30 + ], + "Drawer|+01.98|+00.21|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+01.98|+00.49|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+01.98|+00.73|-02.99": [ + 1.25, + -2.5, + 90, + 30 + ], + "Drawer|+02.64|+00.17|+01.51": [ + 2.0, + 1.0, + 0, + 30 + ], + "Drawer|+02.64|+00.45|+01.51": [ + 2.0, + 1.0, + 0, + 30 + ], + "Dresser|+02.68|+00.00|+01.51": [ + 2.25, + 1.5, + 90, + 30 + ], + "GarbageCan|+01.34|+00.00|-03.38": [ + 1.0, + -3.0, + 90, + 30 + ], + "Safe|+02.72|+01.23|+01.78": [ + 2.25, + 1.5, + 90, + 0 + ], + "SideTable|-02.42|00.00|-00.51": [ + -2.0, + -0.5, + 270, + 30 + ], + "SideTable|-02.42|00.00|-03.15": [ + -2.0, + -3.0, + 270, + 30 + ], + "Sofa|+02.38|+00.01|-00.29": [ + 1.5, + -0.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan324-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..02f4fc67b619400618029e51b4123a4047667b80 GIT binary patch literal 1552 zcmbW#y-LGS7=YoUh=^B_Eef5Sst9#*Q(PRJq}YgqSV_f2yb3R6bS@U)Q%+H+MVfJ$;m;YVuH*XGMAb*e`oU`8clM>fy`%xE@u%=P!rP zlWKi_@-%#{);{W=_KK6^Uh!G{_c%;{$70&8>APFo;Cb*YxCzeFl6lQwd;TnV9^3}& zTTQq7SRdtlVakM*(rI_+os*?!-F{cJzm?>_Bk z`+1SyFE4}5^PJ3M^VmE#k5_pt*vB?=i1zKAX?xv-xbkRX?}+dTjp2)2`J2+F;+I-+dR{g#GS& R^LxHNyDrC7uk(86gCBu)^&tQN literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json new file mode 100644 index 000000000..00fe94151 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan324-objects.json @@ -0,0 +1,29 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "VacuumCleaner", + "CellPhone", + "DeskLamp", + "Drawer", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "ShelvingUnit", + "TennisRacket", + "Shelf", + "Dresser", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json new file mode 100644 index 000000000..18df29209 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan324-openable.json @@ -0,0 +1,110 @@ +{ + "Bed|-00.84|00.00|-00.36": [ + -0.75, + 0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.09|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.09|-02.20": [ + 0.25, + -1.5, + 180, + 30 + ], + "Drawer|+01.60|+00.25|-01.46": [ + 0.0, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.25|-02.20": [ + 0.0, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.41|-01.46": [ + 0.5, + -0.75, + 180, + 30 + ], + "Drawer|+01.60|+00.41|-02.20": [ + 0.5, + -1.5, + 180, + 30 + ], + "Drawer|+01.60|+00.57|-01.46": [ + 0.25, + -2.0, + 90, + 0 + ], + "Drawer|+01.60|+00.57|-02.20": [ + 0.25, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.73|-01.46": [ + 0.5, + -1.5, + 90, + 0 + ], + "Drawer|+01.60|+00.73|-02.20": [ + 0.5, + -2.0, + 90, + 0 + ], + "Dresser|+01.63|+00.00|-01.83": [ + 1.0, + -1.75, + 90, + 30 + ], + "GarbageCan|+03.38|+00.00|+00.22": [ + 2.5, + -0.25, + 0, + 30 + ], + "Shelf|+00.02|+00.18|-02.51": [ + -0.5, + -1.5, + 90, + 30 + ], + "Shelf|+00.24|+00.34|-02.51": [ + 0.75, + -1.75, + 270, + 30 + ], + "Shelf|+00.25|+00.67|-02.52": [ + 0.75, + -2.0, + 270, + 30 + ], + "Shelf|+00.36|+00.18|-02.51": [ + -0.25, + -1.5, + 90, + 30 + ], + "Shelf|+00.47|+00.34|-02.51": [ + 0.0, + -1.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan325-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..56831d6298ed3e097660d18a1df40c23b83aca2c GIT binary patch literal 3040 zcmbW&F-{vn6b9glg(8FyO5zJ_w;;K}6^fAJDjg9GMJi-rTNDV89i>4zMGj<+ut%VD zxy2SPTm+c;EcumjGx~NsZ~x!e%ikYY7neUjq~GbOo=g`v^ZIL5pU=+fK~>Kl=D+6S z`|F4KWcqgf`}l4#eZ9W89Y0QAeSCU098|-TLG`El&(}eEf4wa8x+!ZDoOe^&?tj~T z|4Z;H*!*>wYd)LLO*zlzv-xa(7v{71Y(AUM=5t%}a2LD|-UO#nPT+hmcrW;4@P647dIsz>(BbL{@jK0`rFr^_2*v6%lfnatUv3|`g2oyuR?#;pY><`S%2y#QSnw<#AmeZhanQmB+q3EDy`$K60}6aa`qby)8Ld z9+rpYVR_7zhvi}CIIi-zE)UDY^04o1NXOY zp68f(Y#y7(&U@}T&(5>wl;@)J>^wWa^>e<`8|8Jg-1R!R3vPquF;5)p=Q6OwX!8SxslnTQhojm^I_c&-JU( z^L(G7caEdTjA48NbvBF=srXHm!5Z{zIMarWCdi!^&_hRnNk zp8MO(U1q;;{W`n9%Dl`RQ-xsv@-klGQ2%w2SwHLbGxcNrSU=W}^<({5Kh}?9`Vd$@ z){pgL{n*qipZdA3AM3~Zv3{%{>&N=Beykts$Gtk8(8ejR9?oOuaZ$&8>^yd!={$BG zo1T;PY&~1=Ia<%F^nYgi*?!O6ezu?2={(+K?lNyP?=s8dJbAo#c~~Bnhvi{;SRR&# z4m;IYnI|slxClBfV{o?o8eoV9YoaQEQ3hew>UUwclkGHeQi|voR`Sm#E z^LP_jeh7IikL9s^AM#ip%VXbzQ}*~T`Ev@)hxxF)|0s{;u{_oX^O<~@5A$I@Z1Tj( zXPpo8VZNBdaq?N`!+g$p4|Wd6DbFj9<*_`DldsSBmJjn`KFo*X9P)h|vcC`PUfFjq pa0=)3``gc6tRL17>xcClLqDt^)(@xL59^0h_G108eptV8_64mfLl9g=T_LFfK?osP6%K+ypvc0yOb|v|f+1W57qna0B~(sUOdt>p zdVWiGB*%Pv&Y$o3-tP0}?)vtAFT92KVp6w{O>vPIm(%m2%!}!~d2Pne5A$YH|L$Ln zpW1q}-_FJ_^@fkmPRjiBxXeHD|E|OEx7MSf_KTr@CH$RmsCMrkB&^>m>4){h`r$10 z!}|&IIp^yVALhe+m=E(|KFqgFe3%dOVLr@<`S3b^{}7k|2lHV*oK=1emCr68mU9`s z=D_aZw07Rbx=OfDSU!E^!}4MIa8?ZyVfnCpSibF?i{U*UCpo_x;b S!}4MIa8~WkC!cfqy3r3)Rg?Pw literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json new file mode 100644 index 000000000..1a17b7f1a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan328-objects.json @@ -0,0 +1,31 @@ +[ + "AlarmClock", + "Pillow", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "TeddyBear", + "CellPhone", + "Dumbbell", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Floor", + "HousePlant", + "Laptop", + "Mug", + "Bed", + "TennisRacket", + "TissueBox", + "Shelf", + "Chair", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json new file mode 100644 index 000000000..742c72d37 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan328-openable.json @@ -0,0 +1,44 @@ +{ + "Bed|+00.23|00.00|-00.95": [ + 1.25, + -1.0, + 270, + 30 + ], + "Desk|+02.50|+00.00|-01.60": [ + 2.75, + -1.0, + 180, + 30 + ], + "Drawer|+01.24|+00.13|-01.55": [ + 1.75, + -0.5, + 270, + 30 + ], + "Drawer|+01.24|+00.35|-01.55": [ + 1.75, + -0.75, + 270, + 30 + ], + "GarbageCan|+03.17|-00.01|-00.26": [ + 2.5, + 0.25, + 180, + 30 + ], + "Shelf|+03.03|+00.64|-01.58": [ + 2.5, + -0.75, + 90, + 30 + ], + "SideTable|+01.24|+00.00|-01.55": [ + 2.0, + -0.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan329-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..2328b0b89d500347af2954dd40046c6b4fb53b70 GIT binary patch literal 1536 zcmbW!p-#hK6hPr(d5XG1QiW;=Nl~~F3<51LtC8Z#l^fT%Dk8_+Shjae7|UC&CmX7`m}8J z`{m>GrP=dIRh9YKX_a|3nSG6O2)qrv3!GgZzR$N?9r`dI=EHoLZyS7= z5A$I@%r^ud=EHoL5BKT+=z|aQVLr@<`8L6a`7j^m!@OPc+2c6Z={fuKbu+xK#|`cR zZvyM_{1EQzabFMCgY`J49_%?Br=GukIuF)^^^&T( z?_;kA>%n^Pkb1BltOx7CdYnTK)`Rt69vr70dp)@KJ<`%shfw@+TokNGh_ H=I`on>on)? literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json new file mode 100644 index 000000000..96fb14e54 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan329-objects.json @@ -0,0 +1,28 @@ +[ + "BaseballBat", + "AlarmClock", + "Pillow", + "Box", + "Blinds", + "Pencil", + "SideTable", + "KeyChain", + "Window", + "GarbageCan", + "Pen", + "CreditCard", + "Book", + "CellPhone", + "DeskLamp", + "Drawer", + "Desk", + "Mirror", + "Painting", + "Floor", + "Laptop", + "Mug", + "Bed", + "Shelf", + "LightSwitch", + "CD" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json new file mode 100644 index 000000000..549094674 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan329-openable.json @@ -0,0 +1,50 @@ +{ + "Bed|-00.12|00.00|-01.70": [ + 1.0, + -1.75, + 270, + 30 + ], + "Desk|-00.28|00.00|+00.83": [ + -0.75, + 0.25, + 0, + 30 + ], + "Drawer|+00.95|+00.17|-02.39": [ + 1.5, + -2.0, + 270, + 30 + ], + "Drawer|+00.95|+00.46|-02.39": [ + 1.5, + -2.0, + 270, + 30 + ], + "GarbageCan|+02.47|-00.03|+00.94": [ + 2.0, + 0.5, + 90, + 30 + ], + "Shelf|-00.28|+00.10|+00.83": [ + 1.25, + 0.25, + 0, + 30 + ], + "Shelf|-00.28|+00.35|+00.83": [ + 1.5, + 0.5, + 270, + 0 + ], + "SideTable|+00.95|+00.00|-02.46": [ + 1.5, + -2.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan330-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a63bb699dd8cc91bd1229f78cf5b331ecdecbff GIT binary patch literal 2240 zcmbW%Jx*Iu5QgEy6{5&0Zg&&OO-K`=NZg8!C=CTwWCbG%6p$U!AXdSGoF&{PP*S>Z z;esNBGtZGSWll4G=jWUGEX$8y&rZLc@0Gi9KU^$UKbFH$KYY3TJk0vx@@DyKIsf_n zW_hvrn?IRfuNJTQ)z$oV@yhQ%emb1>haYDBL;s)eU3q((b&UtVYkW?uzMtw?y-Rhh zUQ!*azr?V^q-PGrjO}k`j|eZ|D5zOeN4Zxxrp|u+lRO7>UR_U_G8~4wjbM%t6C{|q8qXK z40eb99JgtHm-r=d8UOXuCFb9r?Yj22J&E~O=O0h0zp9ne>Tw_DAM=mfU1?68f6PDj zKiT@?KD2B6c>fg^V#*g!Q z^ZEQ?{9JE*aC}-7M~7AMUi|kNr0vsfckjh;_wEFz;PvO<-(LkUgBQX3xwjndI)mVT za4*$840f8T!AXMNUZeb(=V ZKBqQqAJ%7m)@S{G=(9fSvp(zhM?dB_q@(}< literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json new file mode 100644 index 000000000..60ee2f021 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan4-objects.json @@ -0,0 +1,42 @@ +[ + "StoveBurner", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "DiningTable", + "Floor", + "HousePlant", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json new file mode 100644 index 000000000..b61a84d71 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan4-openable.json @@ -0,0 +1,98 @@ +{ + "Cabinet|-01.00|+00.39|+00.73": [ + -1.75, + 1.5, + 90, + 30 + ], + "Cabinet|-01.73|+00.39|+00.73": [ + -2.0, + 1.5, + 90, + 30 + ], + "CounterTop|-00.52|+01.16|+00.49": [ + -1.0, + 1.0, + 90, + 30 + ], + "CounterTop|-02.28|+01.16|+00.38": [ + -1.75, + 1.0, + 180, + 30 + ], + "CounterTop|-03.86|+01.16|+00.38": [ + -3.25, + 1.25, + 180, + 0 + ], + "DiningTable|-00.62|+00.02|+02.49": [ + -1.25, + 2.5, + 90, + 30 + ], + "Drawer|-02.04|+00.22|+00.59": [ + -1.5, + 1.5, + 270, + 30 + ], + "Drawer|-02.04|+00.61|+00.59": [ + -2.5, + 1.25, + 90, + 30 + ], + "Drawer|-02.04|+00.94|+00.60": [ + -1.5, + 1.0, + 270, + 30 + ], + "Drawer|-02.50|+00.22|+00.59": [ + -3.0, + 1.5, + 90, + 30 + ], + "Drawer|-02.50|+00.61|+00.59": [ + -3.0, + 1.25, + 90, + 30 + ], + "Drawer|-02.51|+00.94|+00.60": [ + -2.0, + 1.0, + 270, + 30 + ], + "Fridge|-03.52|+00.00|+02.72": [ + -2.5, + 2.75, + 270, + 30 + ], + "GarbageCan|-03.70|+00.00|+02.01": [ + -3.5, + 1.5, + 0, + 30 + ], + "Microwave|-00.37|+01.11|+00.43": [ + -1.0, + 1.0, + 90, + 30 + ], + "Sink|-01.39|+00.98|+00.44|SinkBasin": [ + -1.25, + 1.75, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan401-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..8e4a04103feacbfd316e141080638154d285734a GIT binary patch literal 1616 zcmbW#u};EJ6oBE{kj5AuqFXg#(nXDlo!m4o4o-$hiGvYSjEnIpd?5P>K7u170|Ntt z2a?uR#>ds5tj3e}r5!%qP1;fOd;eni zIBnMVrw_yDX6^lxqd|FiFeu;4|6Y69=IV9Z^Xq(j=83b!tIxmRUnbW3PI|1zdaTDq z%%4S1pY6-~tk3$qi2YfAp6t*1tk3$qh(7Btl0NIRKI^kS>o1c&>$5)Vvp(yul0NIR zJ}=|h1r``(=IBXMNUZ|EE0qy)N5ac^zjLXV|pFIy3(J!L!dDuM8lJA@6bMx3dp2z!R^LLZ^oX0#ipUr3U*?cyiXR#04XD``@ i?ZftA`>=i3K5QSh4|^Z|*vEV}kIiHA*gQ6`U;hA}V9Xo< literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json new file mode 100644 index 000000000..233e0276d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan401-objects.json @@ -0,0 +1,32 @@ +[ + "PaperTowelRoll", + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "LightSwitch", + "Sink", + "Floor", + "SoapBar", + "HandTowel", + "Shelf", + "ShowerHead", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json new file mode 100644 index 000000000..bfe92af8f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan401-openable.json @@ -0,0 +1,56 @@ +{ + "Bathtub|-00.21|+00.36|+00.92|BathtubBasin": [ + -1.25, + 1.75, + 90, + 30 + ], + "GarbageCan|+00.05|00.00|+03.88": [ + -0.75, + 3.25, + 0, + 30 + ], + "Shelf|-02.59|+00.78|+03.91": [ + -2.25, + 3.0, + 0, + 0 + ], + "Shelf|-02.59|+01.03|+03.94": [ + -2.5, + 3.25, + 0, + 0 + ], + "Shelf|-02.59|+01.29|+03.94": [ + -2.5, + 3.5, + 0, + 0 + ], + "Shelf|-02.59|+01.53|+03.91": [ + -2.5, + 3.5, + 0, + 30 + ], + "SideTable|-03.17|+00.00|+00.17": [ + -2.75, + 0.75, + 180, + 30 + ], + "Sink|-03.12|-00.01|+01.53|SinkBasin": [ + -2.5, + 2.0, + 180, + 30 + ], + "Toilet|+00.06|+00.00|+03.10": [ + -0.75, + 3.5, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan402-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..fbbb5a2090f0968bd287946482cba894a287ca02 GIT binary patch literal 1584 zcmbW!u}T9$6a~;Rge8O!)cnA9tB^)36^p6t6dMaG31)+Z7)iuN{0cwF{S-?}3kwSi zV`fj`luomp+2p?a*q5`5)AP%X@ED$|X}!E&R7YiXJUghyWi^{G9u||ktNCJD|K6WW zZkP4yet9#wuUFnV+#8qsyW{e?{O{?9_31R}8De^VzW((`=J(8RndNobywIdP{%(KI zUzyGK-h4Kn&1dtwF{IO^2b<64v-xa3o6qKRx1CqSG*=%E*?WDw*N63CeOMpXhxO@Y zeOMpXhxK87SbjgtXZb9j<+FU2KgjY~KFeqMET4-etj{o}r+M6I(mk8U=COHf9{Yam z`?2rGMLT~prXKpSeykts$NI5;tRL&g`th*sx7GF=WbS9~WiB$?PoDkQer!LsAKQ=Z i$M$3UvHiAVSRebb{n&n7H0ggVZxqwLJeJ4uM)3zd*{L7^ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json new file mode 100644 index 000000000..5135a1b2f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan402-objects.json @@ -0,0 +1,33 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json new file mode 100644 index 000000000..44dc45846 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan402-openable.json @@ -0,0 +1,92 @@ +{ + "Bathtub|-02.90|+00.67|+02.86|BathtubBasin": [ + -2.75, + 3.75, + 270, + 30 + ], + "Cabinet|-00.12|+00.36|+04.63": [ + -1.0, + 3.75, + 90, + 30 + ], + "Cabinet|-01.03|+00.36|+04.63": [ + -1.5, + 3.75, + 90, + 30 + ], + "Cabinet|-01.06|+00.36|+04.63": [ + -0.75, + 3.75, + 270, + 30 + ], + "Cabinet|-01.96|+00.36|+04.63": [ + -2.25, + 4.0, + 90, + 30 + ], + "CounterTop|-01.02|+00.95|+04.88": [ + -0.75, + 4.25, + 0, + 30 + ], + "GarbageCan|-02.35|+00.00|+04.88": [ + -3.0, + 4.25, + 0, + 30 + ], + "HandTowelHolder|-00.07|+01.57|+04.81": [ + -0.5, + 4.25, + 0, + 30 + ], + "HandTowelHolder|-02.09|+01.54|+05.15": [ + -1.5, + 4.25, + 0, + -30 + ], + "Sink|-00.58|+00.93|+04.87|SinkBasin": [ + -0.75, + 4.25, + 0, + 0 + ], + "Sink|-01.53|+00.93|+04.87|SinkBasin": [ + -1.75, + 4.25, + 0, + 0 + ], + "ToiletPaperHanger|-00.07|+01.13|+03.69": [ + -0.5, + 4.0, + 180, + 30 + ], + "Toilet|-00.52|00.00|+03.22": [ + -0.5, + 2.75, + 0, + 30 + ], + "TowelHolder|-00.07|+01.41|+02.43": [ + -0.5, + 2.5, + 90, + 0 + ], + "TowelHolder|-01.72|+01.21|+01.74": [ + -1.75, + 2.25, + 180, + 0 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan403-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..50071edd0cc8cf7d828ff704ed437190a79a84e5 GIT binary patch literal 1008 zcmbW!F-pTw0LS5{h=Zrd7KKbgK}2Y#Zi2!IVsxmEC?NeJn+^pI~^Rs_e-*?Ss zzq_j+n~e`%QXY;)Gv7P(M^Si-Cu%7>& zm-SeW*ZI7xzYcxYXMNUZeb#4v*6%}~^;w_wdC2!;eb#6FA@o_F^;w_wxzFceebygC fpY>Uv^;w_wS)cW%&}V&~@_l#=*7seX^{4qam2{;B literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json new file mode 100644 index 000000000..098f91eab --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan404-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json new file mode 100644 index 000000000..6b3129c2f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan404-openable.json @@ -0,0 +1,38 @@ +{ + "Bathtub|+00.22|+00.34|+00.64|BathtubBasin": [ + -0.75, + 1.25, + 90, + 30 + ], + "Shelf|-01.17|+00.28|+02.16": [ + -1.25, + 1.75, + 0, + 30 + ], + "Shelf|-01.17|+01.06|+02.16": [ + -1.0, + 1.75, + 0, + 30 + ], + "Shelf|-01.17|+01.76|+02.16": [ + -0.75, + 0.75, + 0, + 0 + ], + "Sink|-01.13|00.00|-00.59|SinkBasin": [ + -1.5, + 0.0, + 90, + 30 + ], + "Toilet|-02.15|+00.00|-00.41": [ + -1.5, + 0.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan405-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..b175551a305c675bce4672eaf23dc95cba71c2d0 GIT binary patch literal 576 zcmbWzAr8VY6oBDEP@JN!kW@`Agk%l}!5~m%VO41ah)5C9UO~1fbaD_Cp_$wi7Y8Q^HpM}#B;q1og%@Nm!Ao#-ba2Sf z!D{*p{YTGocmny}mb{){o?Tq6q^I zvwgOoisgN77r%$?vwgPDAK`ty)zD)-)?+=^V?EYeE7ITbeOQn6SdaBskKY&nm(#TC zt{2^{&-$#-`mE3Ttk3!zq0joP&-$#-`mE3Tz0hZU)@OazXMNUZ{msy4eb#4v)@Oaz zXZ@|vXMNUZeb#4v)@S|g&}V(tXMNUZeb#6FozQ1})@OazXMNV|haT&(9_z6l>-CEt DyrtJD literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json new file mode 100644 index 000000000..fee4c2922 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan406-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "SinkBasin", + "TowelHolder", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json new file mode 100644 index 000000000..712dee310 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan406-openable.json @@ -0,0 +1,26 @@ +{ + "Cabinet|+00.07|+00.38|+02.05": [ + -0.75, + 3.0, + 90, + 30 + ], + "CounterTop|+00.49|+01.02|+03.09": [ + -0.25, + 3.5, + 90, + 30 + ], + "Sink|+00.43|+01.04|+02.95|SinkBasin": [ + -0.25, + 3.0, + 90, + 0 + ], + "Toilet|+00.38|+00.00|+04.47": [ + -0.5, + 3.75, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan407-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..e53430e434d631d6fb74bcfe6bc1187099066062 GIT binary patch literal 672 zcmbV_Ar1mD5JijS6m^B93J`>ltiwSt2o!19ZV-eeEx`~@!GX9!kAOrX5J(ovGb5?_ zdA~FBF0;jSzHF(ZI+@bPbuc4s#?{bRZK^sPg4?a?Q2I|laogydK5pFJH{9tDtnPKK zKI?y9TYcZ_n)C6?r(k;WF8*(Vli++^DfaPk2OrEFEE69+J{TX2k3D=aKA1gNCO&$6 hFh1t+!T4Z&Fn3^?_~_ZEXCGz`WqnzeXjrj literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json new file mode 100644 index 000000000..0cec3c67e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan407-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json new file mode 100644 index 000000000..e7f8e434c --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan407-openable.json @@ -0,0 +1,56 @@ +{ + "Bathtub|+00.88|+00.39|-01.15|BathtubBasin": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|-00.07|+00.34|-01.33": [ + -1.0, + -0.5, + 90, + 30 + ], + "Cabinet|-01.04|+00.34|-01.33": [ + -1.5, + -0.5, + 90, + 30 + ], + "Cabinet|-01.05|+00.34|-01.33": [ + -1.25, + -0.75, + 180, + 30 + ], + "Cabinet|-02.02|+00.34|-01.33": [ + -1.0, + -0.25, + 270, + 30 + ], + "CounterTop|-01.04|+00.88|-01.53": [ + -1.5, + -1.0, + 180, + 30 + ], + "Sink|-00.53|+00.81|-01.60|SinkBasin": [ + -1.0, + -1.0, + 90, + 30 + ], + "Sink|-01.56|+00.81|-01.60|SinkBasin": [ + -1.25, + -1.0, + 180, + 30 + ], + "Toilet|-01.61|00.00|+00.21": [ + -1.25, + -0.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan408-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..97a2514fc98772512785982fd1a708a0fb640592 GIT binary patch literal 704 zcmbW!F$%&k6oBCKC!C#D~MQz`xv)5r8NeayS0i^&IyoqELp literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json new file mode 100644 index 000000000..e855538bd --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan408-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json new file mode 100644 index 000000000..a8048b4fb --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan408-openable.json @@ -0,0 +1,62 @@ +{ + "Bathtub|+00.29|+00.29|-00.08|BathtubBasin": [ + -0.5, + 0.25, + 90, + 30 + ], + "Cabinet|-01.50|+00.42|+00.43": [ + -2.25, + -0.5, + 90, + 30 + ], + "Cabinet|-02.29|+00.39|+00.42": [ + -2.5, + -0.25, + 90, + 30 + ], + "Cabinet|-02.31|+00.42|+00.43": [ + -2.25, + -0.25, + 0, + 30 + ], + "Cabinet|-03.09|+00.39|+00.42": [ + -2.5, + -0.5, + 0, + 30 + ], + "CounterTop|-02.30|+00.95|+00.69": [ + -2.25, + -0.25, + 0, + 0 + ], + "GarbageCan|-02.86|+00.02|-01.49": [ + -2.25, + -0.75, + 270, + 30 + ], + "Sink|-01.92|+00.93|+00.68|SinkBasin": [ + -1.75, + 0.0, + 0, + 0 + ], + "Sink|-02.68|+00.93|+00.68|SinkBasin": [ + -2.5, + 0.0, + 0, + 0 + ], + "Toilet|-01.05|+00.00|+00.55": [ + -0.5, + 0.25, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan409-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..278e0a1d880584b4bedf2ea9897c33979fadd4dd GIT binary patch literal 752 zcmbWyF$%&!5J1sYL?q-8+pR(>ZK4RKvQum2HK7jKuDOYCPqjyJh2_W3&A*~0B! zKhWJypilbW@l-j_OZC1+)%y^>3*UsfSJCf1<{op8uiqY~R~J1@57Wc+Fug{k%He;Q v9;S!sVR}u`!}KscOb^p*i5{kh>0x@9o+o;k9;S!sVS2vkVS1Pzrsqd*d}L}c literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json new file mode 100644 index 000000000..670bad826 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan409-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json new file mode 100644 index 000000000..2d50fa700 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan409-openable.json @@ -0,0 +1,62 @@ +{ + "CounterTop|+00.46|+00.79|+02.76": [ + -0.25, + 2.75, + 90, + 30 + ], + "Drawer|+00.44|+00.32|+02.19": [ + -0.75, + 1.75, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+02.57": [ + -0.75, + 2.0, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+02.94": [ + -0.75, + 2.25, + 0, + 30 + ], + "Drawer|+00.44|+00.32|+03.31": [ + -0.75, + 2.75, + 0, + 30 + ], + "Drawer|+00.44|+00.62|+02.19": [ + -0.5, + 1.75, + 0, + 30 + ], + "Drawer|+00.44|+00.62|+03.31": [ + -0.5, + 2.75, + 0, + 30 + ], + "GarbageCan|+00.41|-00.03|+03.73": [ + -0.25, + 3.25, + 0, + 30 + ], + "Sink|+00.50|+00.66|+02.76|SinkBasin": [ + -0.25, + 3.25, + 180, + 30 + ], + "Toilet|+00.27|+00.00|+01.46": [ + -0.25, + 2.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan410-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..09bb6c6c837541d12eb2b3566f010329e8edca29 GIT binary patch literal 1408 zcmbWxu}Z^07{Kwfl%s@F+Be7+g%09W#Nj44#l^u%icN74E2+4MPvHZZ$8vD6CiyKl z`Yqv??{fKnUf*8b+#Q9t@Lp}|{X0vz_ z+x{Hu;Ze5NW3Pwxu%1ck|D%WXa2)=}dRPzZVLhyeXT$wP3f)XI>$BI#F*~o%ULWgY zeXNgX!~N3~y3xn_SRcoB_%8KNefIiTAM0a%ycq7E4foG8>$lg>`gxLlA2aKBUO($+ z{j8t$&r|3|KkH}xTnv4zpJTSyZ?B*Avwqgk`WGp5qo4J&e%8fJZ=#%4Lb1b+W3^z-`m>gH}IyoL92*iIh0^1LW7MrUPJl%sL?+BMJj<8Ijgy}xXp zChhwDJYQd&|M*9@}Gk zY>(}+J+`;X_ShcVV|#3m?eQ}G{!nlJKDNj9*dE(sd)%AGH@!NZVH(d~9nV#|54#^P zvhVKayZf>GvHNjI59{yN@q<3=vp(x{$_LilOMN}oV?EYmz5T4mdaTEKtk=(atjBt+ N$FuZ5=6Ui#{R?)Il9d1e literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json new file mode 100644 index 000000000..f4d477e9d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan411-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json new file mode 100644 index 000000000..96017b5b6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan411-openable.json @@ -0,0 +1,62 @@ +{ + "Bathtub|-01.06|+00.30|+00.43|BathtubBasin": [ + -0.75, + 1.25, + 180, + 30 + ], + "CounterTop|+00.73|+00.70|+01.96": [ + 0.0, + 2.0, + 90, + 30 + ], + "CounterTop|-00.30|+00.16|+00.53": [ + -0.25, + 1.5, + 180, + 30 + ], + "Drawer|+00.41|+00.32|+01.49": [ + -1.0, + 2.0, + 90, + 0 + ], + "Drawer|+00.41|+00.32|+02.42": [ + -1.0, + 2.0, + 90, + 0 + ], + "Drawer|+00.41|+00.55|+01.49": [ + -0.75, + 1.75, + 90, + 0 + ], + "Drawer|+00.41|+00.55|+02.42": [ + -0.75, + 1.75, + 90, + 0 + ], + "GarbageCan|+00.71|-00.03|+03.11": [ + 0.5, + 3.5, + 180, + 30 + ], + "Sink|+00.81|+00.70|+01.92|SinkBasin": [ + 0.0, + 2.5, + 180, + 30 + ], + "Toilet|-02.23|+00.00|+01.63": [ + -2.0, + 2.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan412-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..1d3c8327df573213544b1cf76075351bfd9cf1d7 GIT binary patch literal 784 zcmbV{Ar8Vo5JeY48q!m&TS#gk2tr8ea1aavMH*UyAe6KOLpTKoqDSZvDv<~T0zqNt znU##0zCW|CyVu!bI$t)_Nu5oc9)PCeUV+X2&eruhJ||zWF5D3A+vt$g z+!^!&-R}naqW>*l{mLtBf8A_vIsBBI`NLsP_Sxe+>~{9?un#xI2P=o)@_**;z3|_i z_rUmJ{4jnPU*-5W!-VAJ8ypPU(}CX zv%TLv)X&Y{)yD6`a^|3w<>Ecc5+pER{{j8t$ zvwlwXf%Wfa{j8t$vwqgkefl5Rcgns)w&x(*!}hQ}Y!BPR_OLx{58E@z_OLx{58K1` Vusv)K+r#!uvpsAN+r#!us~?!{m^1(Y literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json new file mode 100644 index 000000000..0e607a3e9 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan413-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Dresser", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json new file mode 100644 index 000000000..528e315b4 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan413-openable.json @@ -0,0 +1,92 @@ +{ + "Bathtub|-01.41|00.00|+00.56|BathtubBasin": [ + -0.75, + 1.0, + 270, + 30 + ], + "Cabinet|-01.61|+00.31|+02.49": [ + -0.75, + 3.25, + 180, + 30 + ], + "Cabinet|-01.61|+00.31|+03.11": [ + -0.75, + 2.5, + 0, + 30 + ], + "Cabinet|-01.61|+00.31|+03.14": [ + -0.75, + 2.75, + 0, + 30 + ], + "Cabinet|-01.61|+00.31|+03.75": [ + -0.75, + 3.0, + 0, + 30 + ], + "CounterTop|-01.80|+00.75|+03.12": [ + -1.25, + 3.0, + 270, + 30 + ], + "Drawer|+00.20|+00.16|+03.81": [ + -0.5, + 3.25, + 90, + 30 + ], + "Drawer|+00.20|+00.42|+03.81": [ + 0.75, + 3.25, + 0, + 30 + ], + "Drawer|+00.20|+00.68|+03.81": [ + -0.5, + 3.5, + 90, + 30 + ], + "Drawer|+00.20|+00.94|+03.81": [ + -0.5, + 3.5, + 90, + 30 + ], + "Dresser|+00.21|+00.00|+03.83": [ + 0.25, + 3.25, + 0, + 0 + ], + "GarbageCan|+00.93|-00.03|+03.76": [ + 0.25, + 3.25, + 0, + 30 + ], + "Sink|-01.83|+00.69|+02.78|SinkBasin": [ + -1.25, + 3.25, + 180, + 30 + ], + "Sink|-01.83|+00.69|+03.47|SinkBasin": [ + -1.25, + 3.0, + 0, + 30 + ], + "Toilet|-01.57|00.00|+01.82": [ + -1.25, + 2.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan414-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..aa82fa1bb4208248476699ac51afd89bd2596dc5 GIT binary patch literal 800 zcmbWxu?oU46oug^BE_f37KKj5K}4{Vo8sc&B*jJ?#7ZhI;#2rQ^>I3O=+L2qwducP zG)wp{Ip^lR*{!$xo_L6-igkK4YA)5{G*iA*r^MV%bUh>{*1!2Gx}>_9r|0OV8;_@f zFN29MU-I8G678uod*@4gSB^`^g=6xClgH$-_}D#V_ntgvKPHcPUpf0Q?=kyoXCG!C zCXdOB(EgkKm^>zr$@iT+CXdPEA`|Vw^bJBg=RcS}OdqBXlOJ|{49l1VyavA~qIQvLqWUf{|UZ33&=1D0!Te78Vv3#$><3 zTRP3*znuH;?7ZLJkM150(py@TNz;wna+S;V^s-dBOy})uTR%U}+ez~~zo}QO z^-Htmlk=^W1wZD; z{Foo}WB$Q9?T+`s{Foo}WBtS4r;qiqzI*6neXQ@E`dA<9OMR@5y$_c5V%j&ikL|}E Qj%nZAf0*-O-`T8w0KJ8raR2}S literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json new file mode 100644 index 000000000..1e083ec30 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan415-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Shelf", + "Dresser", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json new file mode 100644 index 000000000..78d0f5817 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan415-openable.json @@ -0,0 +1,68 @@ +{ + "Bathtub|-02.10|+00.53|-00.83|BathtubBasin": [ + -1.75, + -0.75, + 270, + 30 + ], + "CounterTop|-02.71|+01.03|-02.92": [ + -1.75, + -3.0, + 270, + 0 + ], + "Drawer|-00.23|+00.16|-03.40": [ + -1.25, + -2.75, + 180, + 30 + ], + "Drawer|-00.23|+00.42|-03.40": [ + -0.75, + -3.0, + 90, + 30 + ], + "Drawer|-00.23|+00.68|-03.40": [ + -0.75, + -3.0, + 90, + 30 + ], + "Drawer|-00.23|+00.94|-03.40": [ + -0.75, + -3.0, + 180, + 30 + ], + "Dresser|-00.20|+00.00|-03.40": [ + -0.75, + -3.25, + 90, + 0 + ], + "GarbageCan|-00.27|-00.03|-02.75": [ + -1.0, + -3.25, + 0, + 30 + ], + "Shelf|-02.58|+00.40|-02.92": [ + -1.25, + -2.75, + 270, + 0 + ], + "Sink|-00.31|+00.00|-02.08|SinkBasin": [ + -0.75, + -1.5, + 90, + 30 + ], + "Toilet|-00.41|00.00|-00.55": [ + -0.75, + -1.0, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan416-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..97b05a34c900c4c1a2fa707d19b7fd11afd6c743 GIT binary patch literal 992 zcmbWzF-pWx6a~<)h)7nEE()ncK}2vWJH^JrN`jMN3UMS68*vpb$Sq_EQ(8_jg@uKq z`KNiMzX>OK_r4_WS2vf}w_E8Yy;jq+{@x9>To* zSMHN%d6wt#D^p^9-=UB7u|C$v`qE^4;{8}3>tp%tkY{<8XZf9wXL*+Aln?9M4SlSS n^|3x4@_%Oid!e88vwqgk`gxi6v3*6@$M&&(Y#-al_7#&KZ*++( literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json new file mode 100644 index 000000000..c8adda2c6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan416-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json new file mode 100644 index 000000000..afd6d54d0 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan416-openable.json @@ -0,0 +1,44 @@ +{ + "CounterTop|-01.61|+00.70|+02.83": [ + -1.0, + 2.25, + 270, + 30 + ], + "Drawer|-01.34|+00.30|+02.13": [ + -0.75, + 1.75, + 270, + 30 + ], + "Drawer|-01.34|+00.30|+03.33": [ + -0.75, + 3.0, + 270, + 30 + ], + "GarbageCan|-01.74|-00.03|+01.27": [ + -1.0, + 1.75, + 180, + 30 + ], + "Sink|-01.70|+00.62|+02.28|SinkBasin": [ + -1.0, + 2.75, + 180, + 30 + ], + "Sink|-01.70|+00.62|+03.37|SinkBasin": [ + -1.0, + 3.0, + 0, + 30 + ], + "Toilet|-01.55|+00.00|+00.69": [ + -1.25, + 1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan417-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0e72aa5468376744d0ad51f9911a9e4a1cf2be8d GIT binary patch literal 1088 zcmbWxu};EJ6oBDE3U>X;-y&US=~M~`6}h{e3Z+S=gVf*REzs%Gpm31*VR*7@AvIv z^<3|LdU;-^i?cFq(tn>}@%OyH9_HZfF!`kONB6!T-m_VB@8kUL&fD*Tzk)x5^_};B ztRFiZr@p;D>$5)Vv%Y)%7yFLm)VJ4Xeb#4v_vo`eJI8VA+v~GF>pQ2<`mE3H;W+i} g^;zF{`mE3Ttk3S{IQ8xI?e$ro^;w_wS%;7F2ek>!DF6Tf literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json new file mode 100644 index 000000000..6c7ccae54 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan417-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json new file mode 100644 index 000000000..111a6080f --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan417-openable.json @@ -0,0 +1,44 @@ +{ + "Cabinet|-02.50|+00.40|-01.24": [ + -1.75, + -1.5, + 0, + 30 + ], + "Cabinet|-02.50|+00.40|-02.21": [ + -2.0, + -1.5, + 270, + 30 + ], + "Cabinet|-02.51|+00.43|-00.29": [ + -1.75, + -1.0, + 0, + 30 + ], + "Cabinet|-02.51|+00.43|-01.26": [ + -1.75, + -2.0, + 0, + 30 + ], + "CounterTop|-02.75|+00.99|-01.24": [ + -2.25, + -1.5, + 270, + 30 + ], + "Sink|-02.91|+00.99|-00.73|SinkBasin": [ + -2.25, + -1.0, + 0, + 30 + ], + "Sink|-02.91|+00.99|-01.76|SinkBasin": [ + -2.25, + -1.5, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan418-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3e47df778f8071a73ded546848c342dde1b5a976 GIT binary patch literal 864 zcmbW#u}Z^07{KvZq)6#Q+;$Z*l_FA{-4quGCkZyCgV>T37x5{4p!z5s9UUAT9IQ0I z!EbDq<9B!ej}Y>9eS39tcT_wVFL_qC4^5t?d@(=IWy)V`(-n$|MoAd$F|<> zw~K03?>w5Em1%rhrq^`nGbr}Y`+gaA>(A!Dzk|PmKZA>I&LGTV^VmGrpM;+EtY>{c z^sHw+>yJavdUn4T?z3~N@5|=c*RgvXSH1Vrv!3;=_Z{@CXFcov2YS}Cp7kHyf23zU M>)H9X>z!{mzctp3NB{r; literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json new file mode 100644 index 000000000..6c7ccae54 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan418-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json new file mode 100644 index 000000000..fb4ef1367 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan418-openable.json @@ -0,0 +1,44 @@ +{ + "Cabinet|-02.29|+00.32|-03.25": [ + -1.5, + -3.5, + 0, + 30 + ], + "Cabinet|-02.29|+00.32|-03.81": [ + -1.5, + -3.0, + 180, + 30 + ], + "Cabinet|-02.30|+00.35|-02.25": [ + -1.5, + -3.0, + 0, + 30 + ], + "CounterTop|-02.63|+00.84|-03.04": [ + -2.0, + -3.0, + 270, + 30 + ], + "GarbageCan|-00.46|-00.04|-03.77": [ + -1.25, + -3.25, + 180, + 30 + ], + "Sink|-02.66|+00.79|-03.07|SinkBasin": [ + -2.0, + -3.5, + 0, + 30 + ], + "Toilet|-00.45|+00.00|-03.05": [ + -1.0, + -3.5, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan419-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..191b53f1cfb6d90ecc8734f97572f8c9fded07b3 GIT binary patch literal 608 zcmbV`p$@_@6h#Y?uc#{|6$A_+XdDECK#_)ZK@hgIWM<(j_#pTcBocu@AQ)^XBu`Rv zbMEUq?POQRUvYQXw|daC z`l$as9rZoWbDix=oe#mxm6*fKU(Fu-FmsYQ%stt|GVkJ@n_zt0;~f|uEE69+K6-pG YKA1gN=C%1RJ$`!pFn$<6j0gVZ8}dbb$N&HU literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json new file mode 100644 index 000000000..0a56e852a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan419-objects.json @@ -0,0 +1,30 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json new file mode 100644 index 000000000..46cace91d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan419-openable.json @@ -0,0 +1,44 @@ +{ + "Bathtub|-00.98|-00.72|-02.93|BathtubBasin": [ + -1.25, + -2.25, + 180, + 30 + ], + "Drawer|-02.11|+00.16|-01.31": [ + -1.5, + -0.75, + 180, + 30 + ], + "Drawer|-02.11|+00.46|-01.31": [ + -1.75, + -0.75, + 180, + 30 + ], + "GarbageCan|-00.24|-00.03|-01.36": [ + -0.75, + -1.25, + 90, + 30 + ], + "SideTable|-02.18|00.00|-01.31": [ + -1.75, + -1.0, + 270, + 30 + ], + "Sink|-02.10|00.00|-02.03|SinkBasin": [ + -1.5, + -1.75, + 180, + 30 + ], + "Toilet|-00.47|+00.00|-01.88": [ + -0.75, + -1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan420-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..3d239dd2e8222e42f8e0272eedc659e483177ba4 GIT binary patch literal 560 zcmbV{p$Y;)6h+7CSG+a~leQ>gwkcZ-CK=pW4C2a+SY*G#5As)xMuWj%aMe8sFFNIN zF7FnLS_~`M$_+Wf`2kXQ~j}OMH?_izm=`ZbnVZ8bd*2$ip LJw0BSJNTC`QxbM; literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json new file mode 100644 index 000000000..9c3deeaff --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan420-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "HousePlant", + "SoapBar", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json new file mode 100644 index 000000000..c23df54f5 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan420-openable.json @@ -0,0 +1,32 @@ +{ + "Bathtub|-01.28|+00.28|-02.53|SinkBasin": [ + -1.25, + -1.75, + 180, + 30 + ], + "Drawer|-00.22|+00.78|-01.47": [ + -1.25, + -1.5, + 90, + 0 + ], + "SideTable|-00.15|+00.00|-01.47": [ + -0.5, + -1.0, + 90, + 30 + ], + "Sink|-02.27|+00.00|-01.52|SinkBasin": [ + -1.75, + -1.25, + 180, + 30 + ], + "Toilet|-02.05|+00.00|-00.36": [ + -1.5, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan421-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..bed785d7e97473038a76e7b8d4ebb2ca0e9451bf GIT binary patch literal 608 zcmbW!F%AJi6oBC&BC^>-OgAJ`2#tuuRyv|lsAOYjqYx`Iq7kQXAXic-6bg&|3$OH= zm;YtHYA&q9i zb|GJT&po_0yY+TI5O?uViO!Ek&81qTGZjdcX69z%%ONv~{@t(QbFSO_{1jhx>v0$c zaykj*Q~rBKqC5Vl{}#*sJ9O+h7LJ>DpCey8_U(M>?8ofK?8ofK?8lYu!}L{7AEpn} shv~!gVft`s`*Gozd~N@SJSLCHW9A#1XC5<;nHQ1h4)d6I&w2NvFV&=L)c^nh literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json new file mode 100644 index 000000000..eed1f5ea6 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan422-objects.json @@ -0,0 +1,33 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "Shelf", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json new file mode 100644 index 000000000..3da31098e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan422-openable.json @@ -0,0 +1,86 @@ +{ + "Bathtub|-03.45|+00.18|+01.03|BathtubBasin": [ + -2.75, + 1.25, + 270, + 30 + ], + "Cabinet|-00.61|+00.46|+00.52": [ + -1.25, + 1.25, + 90, + 30 + ], + "Cabinet|-00.61|+01.99|+00.52": [ + -1.25, + 1.0, + 180, + -30 + ], + "Cabinet|-01.89|+00.44|+01.98": [ + -1.25, + 1.75, + 0, + 30 + ], + "Cabinet|-01.89|+01.88|+02.39": [ + -1.25, + 2.25, + 270, + 0 + ], + "Cabinet|-02.34|+00.46|+00.52": [ + -1.75, + 1.0, + 180, + 30 + ], + "CounterTop|-00.81|+00.09|+00.29": [ + -1.25, + 1.0, + 180, + 0 + ], + "CounterTop|-01.92|+00.00|+00.29": [ + -2.0, + 0.75, + 180, + 30 + ], + "Drawer|-00.81|+00.96|+00.38": [ + -1.5, + 1.0, + 90, + 0 + ], + "Drawer|-02.03|+00.94|+02.19": [ + -1.5, + 1.5, + 0, + 0 + ], + "Shelf|-02.03|+01.18|+02.19": [ + -1.25, + 1.75, + 270, + 0 + ], + "Shelf|-02.12|+01.39|+02.19": [ + -1.25, + 2.25, + 270, + -30 + ], + "Sink|-01.93|+00.77|+00.33|SinkBasin": [ + -2.5, + 0.75, + 90, + 30 + ], + "Toilet|-00.46|00.00|+02.26": [ + -1.0, + 2.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan423-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..d85f2115b41423b356fe2292116cfad34b885d51 GIT binary patch literal 1008 zcmbWyu}Z^G0EW?P2|;{{Y*EN06hs6wxhXCVP7-WN2eFcfi}(~ika--(4jnRNur~J$ zW;Dy?B+d7ypEq~cxAzC(ExhN8x_xZ&^DMtup5;ZBFW1d$Q$0Vdn??P5|EhXw>)ri! zRlU?ZAJ6ASc6w4|AK8Deqp-h{Zalv)$8$Dun0Wa5`+M(iChxQN+56nb9v{ZNZS18J z+wTkEq?%>>WG^F literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json new file mode 100644 index 000000000..3045886b8 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan423-objects.json @@ -0,0 +1,32 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json new file mode 100644 index 000000000..21ea750b4 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan423-openable.json @@ -0,0 +1,86 @@ +{ + "Bathtub|-03.59|+00.11|+01.52|BathtubBasin": [ + -3.0, + 1.25, + 270, + 30 + ], + "CounterTop|-00.28|+00.79|+01.93": [ + -1.0, + 2.25, + 90, + 30 + ], + "CounterTop|-02.54|+00.81|+00.28": [ + -1.75, + 0.75, + 270, + 30 + ], + "Drawer|-00.33|+00.32|+01.72": [ + -1.5, + 2.25, + 180, + 30 + ], + "Drawer|-00.33|+00.32|+02.16": [ + -1.5, + 2.75, + 180, + 30 + ], + "Drawer|-00.33|+00.32|+02.59": [ + -1.5, + 2.0, + 0, + 30 + ], + "Drawer|-00.33|+00.32|+03.03": [ + -1.5, + 2.5, + 0, + 30 + ], + "Drawer|-00.33|+00.62|+02.59": [ + -1.25, + 2.0, + 0, + 30 + ], + "Drawer|-00.33|+00.62|+03.03": [ + -1.25, + 2.5, + 0, + 30 + ], + "Drawer|-02.25|+00.32|+00.28": [ + -1.5, + 1.5, + 270, + 30 + ], + "Drawer|-02.84|+00.32|+00.28": [ + -2.25, + 1.5, + 270, + 30 + ], + "GarbageCan|-01.75|+00.00|+00.23": [ + -2.0, + 0.75, + 180, + 30 + ], + "Sink|-00.26|+00.66|+01.92|SinkBasin": [ + -1.0, + 2.5, + 180, + 30 + ], + "Toilet|-02.84|+00.00|+02.76": [ + -2.25, + 2.5, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan424-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..75490b8ceb8bb454345ff51e5d26c3a52caeaa75 GIT binary patch literal 736 zcmbWyF$%&k6oBCOA*0NZijFg;8U(`zNF8vcXnVS1Pz rrq>odOb^q;^f0}S=wW)89;S!s1)_)PVS1PzrWcAHribZadSUVgAzEoo literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json new file mode 100644 index 000000000..f3988fd79 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan424-objects.json @@ -0,0 +1,28 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Cabinet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "LightSwitch" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json new file mode 100644 index 000000000..645647bca --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan424-openable.json @@ -0,0 +1,56 @@ +{ + "Cabinet|-00.49|+00.41|+02.06": [ + -1.25, + 1.75, + 0, + 30 + ], + "Cabinet|-00.49|+00.41|+02.86": [ + -1.25, + 2.5, + 0, + 30 + ], + "Cabinet|-00.50|+00.38|+02.84": [ + -1.25, + 2.25, + 0, + 30 + ], + "Cabinet|-00.50|+00.38|+03.65": [ + -1.25, + 3.0, + 0, + 30 + ], + "CounterTop|-00.26|+00.93|+02.84": [ + -0.75, + 2.5, + 90, + 30 + ], + "GarbageCan|-02.16|00.00|+03.76": [ + -1.75, + 3.25, + 0, + 30 + ], + "Sink|-00.30|+00.80|+02.42|SinkBasin": [ + -0.75, + 2.0, + 0, + 30 + ], + "Sink|-00.30|+00.80|+03.26|SinkBasin": [ + -0.75, + 3.0, + 90, + 30 + ], + "Toilet|-00.54|+00.00|+01.49": [ + -1.0, + 2.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan425-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..a966f44e54c18b5049044de741c61d322c271a71 GIT binary patch literal 512 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I$7COQg6nmP)#3giMV1~B-rA431JhtMz3_z%$dF!c-$sOn*Sn0go=W*!q% zJxm_PzW_BK#)qkAK~oRo!_>q0F!gL`>S27CdKe$3o&!xij1N-}8F21LSSBNl^68f{|`q!o*J3J=7ibnMu{(81tO&v$S} zcacwf&+m8YI$KQV%bGcvvkRkiow$K@!?@>s>*9TKOoH8NpM=rp`6Sq;(ffJ22@cWQ zt#049owjc;_TSSq-_y8PzuD;5xwtOxu_rFneawAq)cxnpd=KwS<%e>ioGWL_p7cFN zRS(~X*$=ZHWADm08vMfQ~&?~ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json new file mode 100644 index 000000000..f904e7328 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan426-objects.json @@ -0,0 +1,31 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json new file mode 100644 index 000000000..c1f4edd71 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan426-openable.json @@ -0,0 +1,68 @@ +{ + "Bathtub|-03.50|+00.15|+00.94|BathtubBasin": [ + -2.75, + 1.25, + 270, + 30 + ], + "CounterTop|-01.85|+00.00|+00.34": [ + -1.0, + 1.0, + 180, + 30 + ], + "Drawer|-00.29|+00.31|+00.31": [ + -1.0, + 1.5, + 90, + 30 + ], + "Drawer|-00.29|+00.61|+00.31": [ + -0.75, + 1.25, + 90, + 30 + ], + "Drawer|-00.81|+00.31|+00.31": [ + -1.5, + 1.5, + 90, + 30 + ], + "Drawer|-00.81|+00.61|+00.31": [ + -1.25, + 1.25, + 90, + 30 + ], + "Drawer|-01.32|+00.61|+00.31": [ + -0.75, + 1.25, + 270, + 30 + ], + "Drawer|-01.84|+00.31|+00.31": [ + -1.25, + 1.5, + 270, + 30 + ], + "Drawer|-01.84|+00.61|+00.31": [ + -1.25, + 1.25, + 270, + 30 + ], + "Sink|-00.46|-00.01|+03.05|SinkBasin": [ + -0.75, + 2.5, + 0, + 30 + ], + "Toilet|-01.84|+00.00|+02.50": [ + -1.25, + 1.75, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan427-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..78286bb77b667bbcec62afd1092b54c87bccbc53 GIT binary patch literal 992 zcmbW!F-pWh6oBCvd?>#gFscu9+{O{T={?_bcy1VWKZwD8_#-i| zu^tb($9=H=SLm}o>$5)Vvp(yy{&(oJKI^kS>$5)Vvwk1?tk3$a&-y&%@6Gz`e-F8@ f$9k;CdaTEN?z7%H^jMG0XY<*7Hh;|XJs;;kiPn^8 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json new file mode 100644 index 000000000..44d2e8f28 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan427-objects.json @@ -0,0 +1,32 @@ +[ + "PaperTowelRoll", + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json new file mode 100644 index 000000000..5cbe082d7 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan427-openable.json @@ -0,0 +1,80 @@ +{ + "Bathtub|-03.71|+00.34|+00.64|BathtubBasin": [ + -2.75, + 1.0, + 270, + 30 + ], + "CounterTop|-02.80|+00.00|-00.59": [ + -2.0, + 0.0, + 180, + 30 + ], + "Drawer|-01.44|+00.27|-00.62": [ + -2.0, + 0.5, + 90, + 30 + ], + "Drawer|-01.44|+00.53|-00.62": [ + -1.0, + 0.25, + 270, + 30 + ], + "Drawer|-01.89|+00.27|-00.62": [ + -2.5, + 0.5, + 90, + 30 + ], + "Drawer|-01.89|+00.53|-00.62": [ + -2.5, + 0.75, + 180, + 0 + ], + "Drawer|-02.34|+00.27|-00.62": [ + -1.75, + 0.5, + 270, + 30 + ], + "Drawer|-02.34|+00.53|-00.62": [ + -2.75, + 1.0, + 180, + 0 + ], + "Drawer|-02.79|+00.27|-00.62": [ + -2.25, + 0.5, + 270, + 30 + ], + "Drawer|-02.79|+00.53|-00.62": [ + -2.25, + 0.25, + 270, + 30 + ], + "GarbageCan|-01.56|00.00|+01.91": [ + -1.0, + 1.75, + 270, + 30 + ], + "Sink|-01.92|+00.44|+02.03|SinkBasin": [ + -2.25, + 1.5, + 0, + 30 + ], + "Toilet|-00.72|+00.00|-00.31": [ + -1.25, + 0.0, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan428-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..0c26e75d4946aea3c1fb14ac01ba8043cc639973 GIT binary patch literal 992 zcmbWyu}Z^07{KvUM5Oc~ZaalcVnIY`CO5^!!AXKmaS$tsxQI{T1NjPlgpM5@938A) zeuFo9OZZ*#ef;xwadm!qy%nCrOPaO)ZI@1BI-MVyYc?ysEUUNReX*AJ)`h@*6;cGHO+b$;(Lwx8{1`*}IdH@qsmF05y-=wUsqhxM=?*28*O m59=8fJ*Y^LY5SY58prB*dQ{c1n$Eh1uDQRSb(8jc|FpU5 z+x32b+sxawcMlKhxW8A&=lI`e6n>u9MOsJ8w7zBUWUmT4@4fTe#d&s~huq_kA0AH9 z2J3Gv)4q9FpY=I?Dg@SN{mr7!`mE3Ttk3$P=(9fSvp(yy{%5{d_rvW5F9R9E-T(jq literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json new file mode 100644 index 000000000..07f7757be --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan429-objects.json @@ -0,0 +1,29 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "ShowerCurtain", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "BathtubBasin", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "SoapBar", + "HandTowel", + "TissueBox", + "LightSwitch", + "Bathtub" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json new file mode 100644 index 000000000..850de0b4b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan429-openable.json @@ -0,0 +1,38 @@ +{ + "Bathtub|-02.12|-00.09|-03.12|BathtubBasin": [ + -1.0, + -2.75, + 270, + 30 + ], + "GarbageCan|-00.53|-00.05|-03.76": [ + -1.0, + -3.0, + 90, + 30 + ], + "SideTable|+00.78|+00.00|-00.67": [ + 0.25, + -1.25, + 90, + 30 + ], + "SideTable|+00.79|+00.00|-01.82": [ + 0.25, + -2.25, + 90, + 30 + ], + "SideTable|-01.53|+00.00|-00.17": [ + -1.0, + -0.75, + 0, + 30 + ], + "Toilet|+00.00|00.00|-03.44": [ + -0.5, + -3.25, + 90, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan430-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..720285dc4d0a54d810408c8459f90780d16de92f GIT binary patch literal 1760 zcmbW#p-#h46oBDEP&`FlA(?2RgN2>#x}RJm z>-Cmi*2``5vR>B9x;U@;no*oAwkzvnecbu};(dM2^|3zI$NF}To@LyxhxKq5J*tQ{thxM@kQx`q{@9g(uecZ+G t$8EAc=lZxw&+BupZ=L#BAM0a%+{QfC$NJd(KF#Mo?ql=Wd^W!y{Qy7=9rXYJ literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json new file mode 100644 index 000000000..4ad43db6d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan430-objects.json @@ -0,0 +1,35 @@ +[ + "Faucet", + "Candle", + "Towel", + "HandTowelHolder", + "SideTable", + "Window", + "GarbageCan", + "Cloth", + "Plunger", + "ToiletPaperHanger", + "ScrubBrush", + "TowelHolder", + "SinkBasin", + "SoapBottle", + "Toilet", + "Footstool", + "Drawer", + "ToiletPaper", + "SprayBottle", + "Mirror", + "Sink", + "Floor", + "ShowerGlass", + "ShowerDoor", + "SoapBar", + "CounterTop", + "ShowerHead", + "HandTowel", + "TissueBox", + "Shelf", + "LightSwitch", + "Bathtub", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json new file mode 100644 index 000000000..ebaf98b49 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan430-openable.json @@ -0,0 +1,50 @@ +{ + "CounterTop|+00.20|+00.43|-02.01": [ + 0.0, + -1.25, + 180, + 30 + ], + "Drawer|+00.30|+00.30|-01.82": [ + -0.25, + -0.75, + 90, + 30 + ], + "Drawer|+00.30|+00.49|-01.82": [ + -0.25, + -1.0, + 90, + 30 + ], + "Drawer|+00.30|+00.68|-01.82": [ + -0.25, + -1.0, + 90, + 30 + ], + "Drawer|+00.30|+00.83|-01.82": [ + -0.25, + -0.75, + 180, + 0 + ], + "SideTable|-02.85|+00.01|+01.51": [ + -2.25, + 1.5, + 270, + 30 + ], + "Sink|-02.80|+00.33|+00.76|SinkBasin": [ + -2.25, + 1.25, + 180, + 30 + ], + "Toilet|-00.06|+00.01|+01.84": [ + -0.75, + 1.25, + 0, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan5-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..86f544e919f217f153d279dff30bf3b77c6ed5c8 GIT binary patch literal 1680 zcmbW%Jx;?w5QgCeAqr06&LFv>;YUcJq65)TP@#x8qCf;Whz4;A4wNhS2q{y#NRfhq z5bqO-DRDD;cPI1CXC?W%xx2o--%0Q3qa4-K$EG|l%8T)7Srz4Y(!4dpmxoC+s(;U~ zhR@S_eLj5}zSe6#JUgk1vwR8@RtsX?s8T+dmJy2;2qc>t_8N zKFo*P{CUiW`7j^mTLd5G!+e+z^I<;Br?%OP`7j^m!+e+zt30vtZO`-j#C(_!^I`qw z>c{%AemV7H{dj4=T=koyAM3}f{5h&~J@_TA?#qweKFb|GZKIigb`LKLgJ}e*Z oay}lvYb-BrL%;mn`n+a literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json new file mode 100644 index 000000000..67be1200d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan5-objects.json @@ -0,0 +1,47 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Statue", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Bowl", + "GarbageCan", + "Knife", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Ladle", + "Bread", + "Sink", + "Floor", + "HousePlant", + "Potato", + "Vase", + "Mug", + "CounterTop", + "ShelvingUnit", + "Spatula", + "Shelf", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json new file mode 100644 index 000000000..c4b6ea81e --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan5-openable.json @@ -0,0 +1,152 @@ +{ + "Cabinet|+00.20|+02.02|-02.00": [ + 0.75, + -1.25, + 180, + 0 + ], + "Cabinet|+01.18|+02.02|-02.00": [ + 0.75, + -1.25, + 180, + 0 + ], + "Cabinet|+01.39|+00.47|-01.06": [ + 0.75, + -1.25, + 90, + 30 + ], + "Cabinet|+01.74|+02.02|-02.00": [ + 1.0, + -1.25, + 180, + 0 + ], + "Cabinet|+01.75|+02.02|-01.03": [ + 1.0, + -1.25, + 90, + 0 + ], + "Cabinet|-00.42|+00.37|-00.01": [ + 0.5, + -0.75, + 270, + 30 + ], + "Cabinet|-00.45|+00.47|-00.01": [ + 0.0, + -1.0, + 270, + 30 + ], + "Cabinet|-00.82|+00.47|-01.69": [ + 0.0, + -0.75, + 270, + 30 + ], + "Cabinet|-00.84|+00.47|-00.05": [ + -0.25, + -0.75, + 0, + 30 + ], + "Cabinet|-00.84|+00.47|-01.67": [ + 0.0, + -1.0, + 180, + 30 + ], + "Cabinet|-01.15|+02.02|+00.38": [ + -0.5, + -0.25, + 270, + 0 + ], + "Cabinet|-01.15|+02.02|-00.77": [ + -0.5, + -0.5, + 270, + 0 + ], + "Cabinet|-01.15|+02.02|-01.98": [ + -0.5, + -1.25, + 270, + 0 + ], + "CounterTop|+01.16|+00.95|-02.01": [ + 1.0, + -1.25, + 180, + 30 + ], + "CounterTop|-00.63|+01.17|+00.57": [ + 0.0, + 1.25, + 180, + 0 + ], + "CounterTop|-00.67|+00.95|+00.19": [ + -0.5, + -0.25, + 0, + 30 + ], + "Drawer|-00.07|+00.75|-00.01": [ + 0.5, + -1.0, + 0, + 0 + ], + "Drawer|-00.45|+00.75|-00.01": [ + -0.25, + -0.5, + 270, + 30 + ], + "Drawer|-00.82|+00.75|-01.69": [ + -0.5, + -0.75, + 180, + 0 + ], + "Fridge|+01.98|+00.00|-00.54": [ + 1.0, + -0.5, + 90, + 30 + ], + "GarbageCan|+01.92|-00.01|+00.14": [ + 1.25, + 0.25, + 90, + 30 + ], + "Microwave|+01.83|+00.90|-01.35": [ + 1.0, + -1.0, + 90, + 0 + ], + "Shelf|+02.76|+00.55|+00.15": [ + 2.25, + 0.75, + 180, + 30 + ], + "Shelf|+02.76|+00.88|+00.14": [ + 2.25, + 1.0, + 180, + 0 + ], + "Sink|-00.12|+00.88|-02.01|SinkBasin": [ + -0.5, + -1.25, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan6-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..eb8f5923c6598a033abf4ed882d8bcd55e632ffa GIT binary patch literal 2176 zcmbW$Ax;BP5C-4}L2-(83rP)C4I!Zl2f-jvq@isPgpw`65Kh5?xWXO*iCj@pQ2})4 zs~E|emv7iN|I7j(S2vf}w|nKayw%g$^1i80tNLs{ss~j)Uo*OrB@IJ~|nW2G#I*P`y|Gd=AU@`Tp$Bb(~+x>Z_>dvrBdTyr&3#ikAI_)# z>iTmV{kh++6mHM^3V$VkC!0^MJy;*kr}@;|n2*iJ=411*`M8UD*}QVi%jRYGIG^TK zH!qu)&CBLx^XY3oHXoah_2GP)Z+!{%f2vHA2dA9wNlWBarItUqt!zI*am9_z>Y zv3}mukM-j&z6ZOnulwviyU*^cyU*^kdz{Zz%%`ruy8gV1@5%OJd8{wzQ{Fn}kjL^^ z9?N5SERQ!a|0dC<*_`L$MRSn%iB+RERVaGhyDMv|9@`N z`z4;;&*QtYeb_#1AGQzM=U`m6kMGC!Vf(Os*gk9@?o&$PHuhoruzlD*Y@dVi54~bm AHUIzs literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json new file mode 100644 index 000000000..b584a4738 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan6-objects.json @@ -0,0 +1,42 @@ +[ + "PaperTowelRoll", + "StoveBurner", + "Stool", + "Faucet", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Pan", + "PepperShaker", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "ButterKnife", + "SaltShaker", + "Pot", + "Fridge", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "Floor", + "Potato", + "Mug", + "CounterTop", + "Spatula", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json new file mode 100644 index 000000000..8337ad36d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan6-openable.json @@ -0,0 +1,164 @@ +{ + "Cabinet|+00.15|+02.01|-01.60": [ + 0.75, + -1.0, + 180, + 0 + ], + "Cabinet|+01.57|+02.01|+00.47": [ + 0.75, + 0.25, + 90, + 0 + ], + "Cabinet|+01.57|+02.01|-00.78": [ + 0.75, + -1.0, + 90, + 0 + ], + "Cabinet|-02.15|+00.40|+00.64": [ + -1.5, + 0.0, + 0, + 30 + ], + "Cabinet|-02.15|+00.40|+00.70": [ + -1.25, + 1.5, + 180, + 30 + ], + "Cabinet|-02.15|+00.40|+01.58": [ + -1.25, + 0.75, + 0, + 30 + ], + "Cabinet|-02.15|+00.40|-00.24": [ + -1.5, + -0.5, + 0, + 30 + ], + "Cabinet|-02.29|+01.97|-01.33": [ + -1.5, + -1.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+00.36": [ + -1.5, + -0.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+00.41": [ + -1.75, + 1.0, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+01.64": [ + -1.75, + 1.0, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+01.69": [ + -1.75, + 2.25, + 270, + 0 + ], + "Cabinet|-02.45|+01.95|+02.93": [ + -1.75, + 2.25, + 270, + 0 + ], + "Cabinet|-02.45|+02.15|-00.29": [ + -1.5, + 0.0, + 270, + 0 + ], + "Cabinet|-02.45|+02.15|-01.28": [ + -1.25, + -0.75, + 270, + 0 + ], + "CounterTop|+00.47|+00.95|-01.63": [ + 0.75, + -1.0, + 180, + 30 + ], + "CounterTop|+01.59|+00.95|+00.41": [ + 1.0, + 0.75, + 90, + 30 + ], + "CounterTop|-00.36|+00.95|+01.09": [ + 0.5, + 1.25, + 270, + 30 + ], + "CounterTop|-01.49|+00.95|+01.32": [ + -1.75, + 0.5, + 270, + 30 + ], + "Drawer|-02.28|+00.79|+00.44": [ + -1.5, + 0.0, + 0, + 30 + ], + "Drawer|-02.28|+00.79|+00.90": [ + -1.5, + 0.5, + 0, + 30 + ], + "Drawer|-02.28|+00.79|+01.37": [ + -1.5, + 1.75, + 180, + 30 + ], + "Drawer|-02.28|+00.79|-00.03": [ + -1.5, + -0.5, + 0, + 30 + ], + "Fridge|-02.48|+00.00|-00.78": [ + -1.5, + -0.75, + 270, + 30 + ], + "GarbageCan|+01.65|00.00|+00.68": [ + 1.0, + 1.0, + 90, + 30 + ], + "Microwave|-02.58|+00.90|+02.44": [ + -1.75, + 2.5, + 270, + 0 + ], + "Sink|+01.38|+00.81|-01.27|SinkBasin": [ + 0.75, + -1.0, + 180, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan7-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..17b04ef444e20b59a55d337e4b7bd3e6962f4de5 GIT binary patch literal 4352 zcmbW%F>Vt<6b9g7WvwF1hj3?*Ttx_>2#KxeKr|Fo$Rds?P=ahkgE$2T@*crQNSSgA z7cN{7^5$D9ugo@+Z)SF9-v11LKYV)s@$<9ttNdPEuD4$|i;MZ<&DHD0a=y5_+5FtB zuD{%DF4zC(->trH*Z1?=Z>t~cdp|#a^>R5sf3ckZnLqKFmWOB7$9UMqI88oFZj-$~ zr1#nT?0xqBU3#Cr&)(xa-q!D!-zS&)jO%Y>f^U=Wl859&vU=P@o~#~L50CfQ#l6fM z)x+xHeZ3E>ht^H+@W zH7j41FUyzZJGzg*)G1$EcE# zf0jSXpXJZ;AKl0I)ggbDKeuVW{H@EM<o(te-sV<9qI*f2@Dp zrv3V7UH@4B_*C;{{bT*(A???{alQ6~)x~*~uX*`$)0KyZ<;(JA`LcXjzRr~|%a_|e z&S&|ud|AGHs(JA-S-#fg#qP~{l$ZIYOZQEdm;Lf$d9l2lBQKT*%Y)^?^5A35gXO`_ cSJ$ME`q+8wJa!&CkDbTP^E>lB_Pt5>5B$3_i~s-t literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json new file mode 100644 index 000000000..02e51c382 --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan7-objects.json @@ -0,0 +1,50 @@ +[ + "StoveBurner", + "Faucet", + "Stool", + "Egg", + "Plate", + "StoveKnob", + "Fork", + "Statue", + "PepperShaker", + "Pan", + "Apple", + "CoffeeMachine", + "Tomato", + "Window", + "Bowl", + "Knife", + "GarbageCan", + "Book", + "ButterKnife", + "Pot", + "SaltShaker", + "Fridge", + "WineBottle", + "Microwave", + "Lettuce", + "Kettle", + "SinkBasin", + "Spoon", + "SoapBottle", + "Toaster", + "Cabinet", + "Cup", + "Drawer", + "Bread", + "Sink", + "DiningTable", + "Floor", + "HousePlant", + "Potato", + "Vase", + "Mug", + "CounterTop", + "ShelvingUnit", + "Spatula", + "Shelf", + "Chair", + "LightSwitch", + "DishSponge" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json new file mode 100644 index 000000000..f0f78366b --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan7-openable.json @@ -0,0 +1,146 @@ +{ + "Cabinet|+00.38|+00.37|-01.24": [ + -0.25, + -0.5, + 90, + 30 + ], + "Cabinet|+00.52|+02.01|-01.54": [ + 0.25, + -0.75, + 180, + 0 + ], + "Cabinet|+00.78|+00.37|-01.24": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|+01.45|+02.26|-01.54": [ + 1.0, + -0.75, + 180, + 0 + ], + "Cabinet|+01.78|+00.37|-01.24": [ + 1.25, + -0.5, + 90, + 30 + ], + "Cabinet|+01.78|+02.01|-01.54": [ + 1.25, + -0.75, + 180, + 0 + ], + "Cabinet|-00.57|+00.37|-01.24": [ + 0.25, + -0.5, + 270, + 30 + ], + "Cabinet|-00.71|+02.01|-01.54": [ + -0.5, + -0.75, + 180, + 0 + ], + "Cabinet|-01.48|+00.37|-01.24": [ + -0.75, + -0.25, + 180, + 30 + ], + "Cabinet|-01.67|+02.01|-01.54": [ + -1.0, + -0.75, + 180, + 0 + ], + "Cabinet|-02.17|+02.01|-01.54": [ + -2.75, + -1.0, + 90, + 0 + ], + "Cabinet|-02.22|+00.37|-01.87": [ + -2.75, + -1.25, + 90, + 30 + ], + "CounterTop|+01.65|+00.95|-01.53": [ + 1.25, + -0.75, + 90, + 30 + ], + "CounterTop|-01.87|+00.95|-00.61": [ + -2.5, + 0.5, + 90, + 30 + ], + "DiningTable|-02.66|+00.00|+03.21": [ + -2.5, + 2.25, + 0, + 30 + ], + "Drawer|+00.60|+00.68|-01.40": [ + 1.0, + -0.75, + 270, + 30 + ], + "Drawer|-01.64|+00.68|-00.93": [ + -1.0, + -0.25, + 270, + 30 + ], + "Drawer|-02.06|+00.68|-01.58": [ + -3.0, + -1.0, + 180, + 30 + ], + "Fridge|-00.04|+00.00|+02.18": [ + 0.0, + 1.25, + 0, + 30 + ], + "GarbageCan|-00.87|00.00|+02.14": [ + -1.75, + 1.5, + 0, + 30 + ], + "Microwave|+01.15|+01.66|-01.61": [ + 0.75, + -0.75, + 180, + 0 + ], + "Shelf|+03.73|+00.55|+01.67": [ + 2.5, + 1.75, + 90, + 0 + ], + "Shelf|+03.73|+00.88|+01.67": [ + 3.25, + 1.75, + 90, + 30 + ], + "Sink|+00.02|+00.77|-01.71|SinkBasin": [ + -0.75, + -0.75, + 180, + 0 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan8-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..f768a488c36e0b0a939b69a01e5488a6c8e1cd65 GIT binary patch literal 2768 zcmbW$ze*!f6u{xDgcLr-bfb`Fgl@bI&ivyq^C#ySUsbPvyD2p3eWy+M}jDzWLpbn)c>?_Bfl|UER;F zr(gT0liT_9bASGC@-Y4M{*PZjN6q2EsCjAr^V%!l*Kk?a^`fr43J>BwyWgk#yc^GR zNp_C=d3}#_?U%T?JETD)wA7?@0<0o`QGc}`(X3ge0C1!)!)Ou`E0)D%xCl2 zd^Vq*%Xu~5{whANee>CTHlNLB^VuBEtNHKoJ(YWxcGI z^>R!rte5q&-reZa%X(Qa>t(&Hm-TXqi}kWz);k!N?@KT1WxcGI^|D^p%XMlgte5q2 eS=Kj(B9dbv(5h4r%D;rIgsV3kz> literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json b/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json new file mode 100644 index 000000000..12da9582d --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan8-objects.json @@ -0,0 +1,46 @@ +[ + "ButterKnife", + "Drawer", + "Lettuce", + "Toaster", + "StoveKnob", + "SaltShaker", + "Pot", + "Microwave", + "Stool", + "HousePlant", + "Floor", + "Apple", + "Fork", + "Cabinet", + "StoveBurner", + "LightSwitch", + "CoffeeMachine", + "SprayBottle", + "SinkBasin", + "Knife", + "Fridge", + "Spatula", + "Mug", + "Faucet", + "Ladle", + "SoapBottle", + "Sink", + "CounterTop", + "Kettle", + "Tomato", + "Cup", + "Egg", + "GarbageCan", + "Bowl", + "Bread", + "DishSponge", + "PepperShaker", + "Pen", + "Bottle", + "Plate", + "Window", + "Pan", + "Spoon", + "Potato" +] \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json b/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json new file mode 100644 index 000000000..a327a281a --- /dev/null +++ b/models/main_models/rt1/gen/layouts/FloorPlan8-openable.json @@ -0,0 +1,170 @@ +{ + "Cabinet|+00.49|+02.06|-01.69": [ + 0.5, + -0.75, + 180, + 0 + ], + "Cabinet|+00.83|+00.40|-01.39": [ + 0.0, + -0.5, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|+00.67": [ + 0.0, + 0.0, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|-00.55": [ + 0.0, + -0.75, + 90, + 30 + ], + "Cabinet|+00.86|+00.40|-01.37": [ + 0.0, + -1.0, + 90, + 30 + ], + "Cabinet|+01.16|+02.06|-00.34": [ + 0.5, + -0.75, + 90, + 0 + ], + "Cabinet|+01.16|+02.06|-01.02": [ + 0.25, + -1.0, + 90, + 0 + ], + "Cabinet|-00.19|+02.06|-01.69": [ + 0.0, + -1.0, + 180, + 0 + ], + "Cabinet|-00.20|+00.40|-01.39": [ + -0.5, + -0.5, + 90, + 30 + ], + "Cabinet|-00.24|+00.40|-01.39": [ + -0.75, + -0.75, + 90, + 30 + ], + "Cabinet|-00.82|+00.40|-01.39": [ + -1.25, + -0.5, + 90, + 30 + ], + "Cabinet|-00.82|+02.06|-01.69": [ + 0.0, + -1.0, + 180, + 0 + ], + "Cabinet|-00.87|+02.01|-01.69": [ + -1.5, + -0.5, + 180, + 0 + ], + "Cabinet|-01.61|+02.01|-01.69": [ + -2.0, + -0.5, + 180, + 0 + ], + "Cabinet|-01.66|+02.06|-01.68": [ + -2.25, + -1.0, + 180, + 0 + ], + "Cabinet|-01.67|+00.40|-01.39": [ + -2.0, + -1.0, + 180, + 30 + ], + "Cabinet|-02.24|+00.40|-01.39": [ + -2.5, + -1.0, + 180, + 30 + ], + "CounterTop|+01.17|+00.95|-00.65": [ + 0.5, + -0.75, + 90, + 30 + ], + "CounterTop|+01.50|+01.20|-00.66": [ + 0.5, + -1.0, + 90, + 0 + ], + "CounterTop|-01.97|+00.95|-01.71": [ + -2.5, + -1.25, + 90, + 30 + ], + "CounterTop|-02.10|+00.95|+00.29": [ + -1.5, + -0.25, + 0, + 30 + ], + "Drawer|+00.59|+00.75|-01.39": [ + 0.0, + -0.75, + 90, + 30 + ], + "Drawer|+00.86|+00.75|+00.43": [ + 0.0, + 1.0, + 90, + 0 + ], + "Drawer|+00.87|+00.75|-01.14": [ + 0.0, + -1.0, + 90, + 0 + ], + "Fridge|+01.42|+00.00|+02.10": [ + 0.5, + 2.0, + 90, + 0 + ], + "GarbageCan|+01.34|+00.02|+01.04": [ + 0.5, + 0.5, + 0, + 30 + ], + "Microwave|+01.42|+01.15|+00.02": [ + 0.5, + 0.5, + 90, + 0 + ], + "Sink|+00.16|+00.82|-01.80|SinkBasin": [ + 0.5, + -1.0, + 270, + 30 + ] +} \ No newline at end of file diff --git a/models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy b/models/main_models/rt1/gen/layouts/FloorPlan9-layout.npy new file mode 100644 index 0000000000000000000000000000000000000000..bd4533e3927e8b5b7557a060a87f6091d6716e6a GIT binary patch literal 1360 zcmbWzp-#h46b9hSLI~k0>I%seW`vMz3J1X;P^4j95QLGIUjvA*o7FV+|9i}l6&V) 0: + lock.acquire() + scene_num = all_scene_numbers.pop() + lock.release() + fn = os.path.join('layouts', ('FloorPlan%d-layout.npy') % scene_num) + if os.path.isfile(fn): + print("file %s already exists; skipping this floorplan" % fn) + continue + + openable_json_file = os.path.join('layouts', ('FloorPlan%d-openable.json') % scene_num) + scene_objs_json_file = os.path.join('layouts', ('FloorPlan%d-objects.json') % scene_num) + + scene_name = ('FloorPlan%d') % scene_num + print('Running ' + scene_name) + event = env.reset(scene_name, + render_image=False, + render_depth_image=False, + render_class_image=False, + render_object_image=True) + agent_height = event.metadata['agent']['position']['y'] + + scene_objs = list(set([obj['objectType'] for obj in event.metadata['objects']])) + with open(scene_objs_json_file, 'w') as sof: + json.dump(scene_objs, sof, sort_keys=True, indent=4) + + # Get all the reachable points through Unity for this step size. + event = env.step(dict(action='GetReachablePositions', + gridSize=constants.AGENT_STEP_SIZE / constants.RECORD_SMOOTHING_FACTOR)) + if event.metadata['actionReturn'] is None: + print("ERROR: scene %d 'GetReachablePositions' returns None" % scene_num) + else: + reachable_points = set() + for point in event.metadata['actionReturn']: + reachable_points.add((point['x'], point['z'])) + print("scene %d got %d reachable points, now checking" % (scene_num, len(reachable_points))) + + # Pick up a small object to use in testing whether points are good for openable objects. + open_test_objs = {'CD', 'CellPhone', 'Cloth', 'CreditCard', 'DishSponge', 'Fork', + 'KeyChain', 'Pen', 'Pencil', 'SoapBar', 'Spoon', 'Watch'} + good_obj_point = None + good_obj_point = get_obj(env, open_test_objs, reachable_points, agent_height, scene_name, good_obj_point) + + + best_open_point = {} # map from object names to the best point from which they can be successfully opened + best_sem_coverage = {} # number of pixels in the semantic map of the receptacle at the existing best openpt + checked_points = set() + scene_receptacles = set() + for point in reachable_points: + point_is_valid = True + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + } + event = env.step(action) + if event.metadata['lastActionSuccess']: + for horizon in [-30, 0, 30]: + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': 0, + 'horizon': horizon + } + event = env.step(action) + if not event.metadata['lastActionSuccess']: + point_is_valid = False + break + for rotation in range(3): + action = {'action': 'RotateLeft'} + event = env.step(action) + if not event.metadata['lastActionSuccess']: + point_is_valid = False + break + if not point_is_valid: + break + if point_is_valid: + checked_points.add(point) + else: + continue + + # Check whether we can open objects from here in any direction with any tilt. + for rotation in range(4): + # First try up, then down, then return to the horizon before moving again. + for horizon in [-30, 0, 30]: + + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': rotation * 90, + 'horizon': horizon + } + event = env.step(action) + for obj in event.metadata['objects']: + if (obj['visible'] and obj['objectId'] and obj['receptacle'] and not obj['pickupable'] + and obj['objectType'] in constants.VAL_RECEPTACLE_OBJECTS): + obj_name = obj['objectId'] + obj_point = (obj['position']['x'], obj['position']['y']) + scene_receptacles.add(obj_name) + + # Go ahead and attempt to close the object from this position if it's open. + if obj['openable'] and obj['isOpen']: + close_action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(close_action) + + point_to_recep = np.linalg.norm(np.array(point) - np.array(obj_point)) + if len(env.last_event.metadata['inventoryObjects']) > 0: + inv_obj = env.last_event.metadata['inventoryObjects'][0]['objectId'] + else: + inv_obj = None + + # Heuristic implemented in task_game_state has agent 0.5 or farther in agent space. + heuristic_far_enough_from_recep = 0.5 < point_to_recep + # Ensure this point affords a larger view according to the semantic segmentation + # of the receptacle than the existing. + point_sem_coverage = get_mask_of_obj(env, obj['objectId']) + if point_sem_coverage is None: + use_sem_heuristic = False + better_sem_covereage = False + else: + use_sem_heuristic = True + better_sem_covereage = (obj_name not in best_sem_coverage or + best_sem_coverage[obj_name] is None or + point_sem_coverage > best_sem_coverage[obj_name]) + # Ensure that this point is farther away than our existing best candidate. + # We'd like to open each receptacle from as far away as possible while retaining + # the ability to pick/place from it. + farther_than_existing_good_point = (obj_name not in best_open_point or + point_to_recep > + np.linalg.norm( + np.array(point) - + np.array(best_open_point[obj_name][:2]))) + # If we don't have an inventory object, though, we'll fall back to the heuristic + # of being able to open/close as _close_ as possible. + closer_than_existing_good_point = (obj_name not in best_open_point or + point_to_recep < + np.linalg.norm( + np.array(point) - + np.array(best_open_point[obj_name][:2]))) + # Semantic segmentation heuristic. + if ((use_sem_heuristic and heuristic_far_enough_from_recep and better_sem_covereage) + or (not use_sem_heuristic and + # Distance heuristics. + (heuristic_far_enough_from_recep and + (inv_obj and farther_than_existing_good_point) or + (not inv_obj and closer_than_existing_good_point)))): + if obj['openable']: + action = {'action': 'OpenObject', + 'objectId': obj['objectId']} + event = env.step(action) + if not obj['openable'] or event.metadata['lastActionSuccess']: + # We can open the object, so try placing our small inventory obj inside. + # If it can be placed inside and retrieved, then this is a safe point. + action = {'action': 'PutObject', + 'objectId': obj['objectId'], + 'forceAction': True, + 'placeStationary': True} + if inv_obj: + event = env.step(action) + if inv_obj is None or event.metadata['lastActionSuccess']: + action = {'action': 'PickupObject', + 'objectId': inv_obj} + if inv_obj: + event = env.step(action) + if inv_obj is None or event.metadata['lastActionSuccess']: + + # Finally, ensure we can also close the receptacle. + if obj['openable']: + action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(action) + if not obj['openable'] or event.metadata['lastActionSuccess']: + + # We can put/pick our inv object into the receptacle from here. + # We have already ensured this point is farther than any + # existing best, so this is the new best. + best_open_point[obj_name] = [point[0], point[1], rotation * 90, horizon] + best_sem_coverage[obj_name] = point_sem_coverage + + # We could not retrieve our inv object, so we need to go get another one + else: + good_obj_point = get_obj(env, open_test_objs, reachable_points, + agent_height, scene_name, good_obj_point) + action = {'action': 'TeleportFull', + 'x': point[0], + 'y': agent_height, + 'z': point[1], + 'rotateOnTeleport': True, + 'rotation': rotation * 90, + 'horizon': horizon + } + event = env.step(action) + + # Regardless of what happened up there, try to close the receptacle again if + # it remained open. + if obj['isOpen']: + action = {'action': 'CloseObject', + 'objectId': obj['objectId']} + event = env.step(action) + + essential_objs = [] + if scene_num in constants.SCENE_TYPE["Kitchen"]: + essential_objs.extend(["Microwave", "Fridge"]) + for obj in essential_objs: + if not np.any([obj in obj_key for obj_key in best_open_point]): + print("WARNING: Essential object %s has no open points in scene %d" % (obj, scene_num)) + + print("scene %d found open/pick/place/close positions for %d/%d receptacle objects" % + (scene_num, len(best_open_point), len(scene_receptacles))) + with open(openable_json_file, 'w') as f: + json.dump(best_open_point, f, sort_keys=True, indent=4) + + print("scene %d reachable %d, checked %d; taking intersection" % + (scene_num, len(reachable_points), len(checked_points))) + + points = np.array(list(checked_points))[:, :2] + points = points[np.lexsort((points[:, 0], points[:, 1])), :] + np.save(fn, points) + + env.stop() + print('Done') + + +threads = [] +for n in range(N_PROCS): + thread = threading.Thread(target=run, args=(n,)) + threads.append(thread) + thread.start() + time.sleep(1) diff --git a/models/main_models/rt1/gen/planner/__init__.py b/models/main_models/rt1/gen/planner/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl b/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl new file mode 100644 index 000000000..60280d713 --- /dev/null +++ b/models/main_models/rt1/gen/planner/domains/PutTaskExtended_domain.pddl @@ -0,0 +1,302 @@ +;; Specification in PDDL1 of the Extended Task domain + +(define (domain put_task) + (:requirements + :adl + ) + (:types + agent + location + receptacle + object + rtype + otype + ) + + + (:predicates + (atLocation ?a - agent ?l - location) ; true if the agent is at the location + (receptacleAtLocation ?r - receptacle ?l - location) ; true if the receptacle is at the location (constant) + (objectAtLocation ?o - object ?l - location) ; true if the object is at the location + (openable ?r - receptacle) ; true if a receptacle is openable + (opened ?r - receptacle) ; true if a receptacle is opened + (inReceptacle ?o - object ?r - receptacle) ; object ?o is in receptacle ?r + (isReceptacleObject ?o - object) ; true if the object can have things put inside it + (inReceptacleObject ?innerObject - object ?outerObject - object) ; object ?innerObject is inside object ?outerObject + (wasInReceptacle ?o - object ?r - receptacle) ; object ?o was or is in receptacle ?r now or some time in the past + ;(checked ?r - receptacle) ; whether the receptacle has been looked inside/visited + (receptacleType ?r - receptacle ?t - rtype) ; the type of receptacle (Cabinet vs Cabinet|01|2...) + (objectType ?o - object ?t - otype) ; the type of object (Apple vs Apple|01|2...) + (holds ?a - agent ?o - object) ; object ?o is held by agent ?a + (holdsAny ?a - agent) ; agent ?a holds an object + (holdsAnyReceptacleObject ?a - agent) ; agent ?a holds a receptacle object + ;(full ?r - receptacle) ; true if the receptacle has no remaining space + (isClean ?o - object) ; true if the object has been clean in sink + (cleanable ?o - object) ; true if the object can be placed in a sink + (isHot ?o - object) ; true if the object has been heated up + (heatable ?o - object) ; true if the object can be heated up in a microwave + (isCool ?o - object) ; true if the object has been cooled + (coolable ?o - object) ; true if the object can be cooled in the fridge + (toggleable ?o - object) ; true if the object can be turned on/off + (isOn ?o - object) ; true if the object is on + (isToggled ?o - object) ; true if the object has been toggled + (sliceable ?o - object) ; true if the object can be sliced + (isSliced ?o - object) ; true if the object is sliced + ) + + (:functions + (distance ?from ?to) + (totalCost) + ) + +;; All actions are specified such that the final arguments are the ones used +;; for performing actions in Unity. + +;; agent goes to receptacle + (:action GotoLocation + :parameters (?a - agent ?lStart - location ?lEnd - location) + :precondition (and + (atLocation ?a ?lStart) + (forall (?re - receptacle) + (not (opened ?re)) + ) + ) + :effect (and + (atLocation ?a ?lEnd) + (not (atLocation ?a ?lStart)) + (increase (totalCost) (distance ?lStart ?lEnd)) + ) + ) + +;; agent opens receptacle + (:action OpenObject + :parameters (?a - agent ?l - location ?r - receptacle) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (openable ?r) + (forall (?re - receptacle) + (not (opened ?re)) + ) + ) + :effect (and + (opened ?r) + (increase (totalCost) 1) + ) + ) +;; agent closes receptacle + (:action CloseObject + :parameters (?a - agent ?al - location ?r - receptacle) + :precondition (and + (atLocation ?a ?al) + (receptacleAtLocation ?r ?al) + (openable ?r) + (opened ?r) + ) + :effect (and + (not (opened ?r)) + (increase (totalCost) 1) + ) + + ) + +;; agent picks up object + (:action PickupObjectInReceptacle1 + :parameters (?a - agent ?l - location ?o - object ?r - receptacle) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (inReceptacle ?o ?r) + (not (holdsAny ?a)) + ) + :effect (and + (forall (?re - receptacle) + (not (inReceptacle ?o ?re)) + ) + (not (objectAtLocation ?o ?l)) + (holds ?a ?o) + (holdsAny ?a) + (increase (totalCost) 1) + ) + ) + +;; agent picks up object not in a receptacle + (:action PickupObjectNoReceptacle + :parameters (?a - agent ?l - location ?o - object) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (forall (?r - receptacle) + (not (inReceptacle ?o ?r)) + ) + (not (holdsAny ?a)) + ) + :effect (and + (not (objectAtLocation ?o ?l)) + (holds ?a ?o) + (holdsAny ?a) + (increase (totalCost) 1) + ) + ) + +;; agent puts down an object in a receptacle + (:action PutObjectInReceptacle1 + :parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle) ;?rt - rtype) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (objectType ?o ?ot) + (holds ?a ?o) + (not (holdsAnyReceptacleObject ?a)) + ) + :effect (and + (inReceptacle ?o ?r) + (not (holds ?a ?o)) + (not (holdsAny ?a)) + (increase (totalCost) 1) + (objectAtLocation ?o ?l) + ) + ) + +;; agent puts down an object + (:action PutObjectInReceptacleObject1 + :parameters (?a - agent ?l - location ?ot - otype ?o - object ?outerO - object ?outerR - receptacle) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?outerO ?l) + (isReceptacleObject ?outerO) + (not (isReceptacleObject ?o)) + (objectType ?o ?ot) + (holds ?a ?o) + (not (holdsAnyReceptacleObject ?a)) + (inReceptacle ?outerO ?outerR) + ) + :effect (and + (inReceptacleObject ?o ?outerO) + (inReceptacle ?o ?outerR) + (not (holds ?a ?o)) + (not (holdsAny ?a)) + (increase (totalCost) 1) + (objectAtLocation ?o ?l) + ) + ) + +;; agent puts down a receptacle object in a receptacle + (:action PutReceptacleObjectInReceptacle1 + :parameters (?a - agent ?l - location ?ot - otype ?outerO - object ?r - receptacle) ; ?rt - rtype) + :precondition (and + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (objectType ?outerO ?ot) + (holds ?a ?outerO) + (holdsAnyReceptacleObject ?a) + (isReceptacleObject ?outerO) + ) + :effect (and + (forall (?obj - object) + (when (holds ?a ?obj) + (and + (not (holds ?a ?obj)) + (objectAtLocation ?obj ?l) + (inReceptacle ?obj ?r) + ) + ) + ) + (not (holdsAny ?a)) + (not (holdsAnyReceptacleObject ?a)) + (increase (totalCost) 1) + ) + ) + +;; agent cleans some object + (:action CleanObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (receptacleType ?r SinkBasinType) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isClean ?o) + ) + ) + + +;; agent heats-up some object + (:action HeatObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (or + (receptacleType ?r MicrowaveType) + ) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isHot ?o) + ) + ) + +;; agent cools some object + (:action CoolObject + :parameters (?a - agent ?l - location ?r - receptacle ?o - object) + :precondition (and + (or + (receptacleType ?r FridgeType) + ) + (atLocation ?a ?l) + (receptacleAtLocation ?r ?l) + (holds ?a ?o) + ) + :effect (and + (increase (totalCost) 5) + (isCool ?o) + ) + ) + + +;; agent toggle object + (:action ToggleObject + :parameters (?a - agent ?l - location ?o - object) + :precondition (and + (atLocation ?a ?l) + (objectAtLocation ?o ?l) + (toggleable ?o) + ) + :effect (and + (increase (totalCost) 5) + (when (isOn ?o) + (not (isOn ?o))) + (when (not (isOn ?o)) + (isOn ?o)) + (isToggled ?o) + ) + ) + + +;; agent slices some object with a knife + (:action SliceObject + :parameters (?a - agent ?l - location ?co - object ?ko - object) + :precondition + (and + (or + (objectType ?ko KnifeType) + (objectType ?ko ButterKnifeType) + ) + (atLocation ?a ?l) + (objectAtLocation ?co ?l) + (sliceable ?co) + (holds ?a ?ko) + ) + :effect (and + (increase (totalCost) 5) + (isSliced ?co) + ) + ) + + +) diff --git a/models/main_models/rt1/gen/planner/ff_planner_handler.py b/models/main_models/rt1/gen/planner/ff_planner_handler.py new file mode 100644 index 000000000..50937c677 --- /dev/null +++ b/models/main_models/rt1/gen/planner/ff_planner_handler.py @@ -0,0 +1,252 @@ +import pdb +import ast +import multiprocessing +import re +import shlex +import subprocess +import time + +import constants +from utils import game_util +from utils import py_util + +DEBUG = False + +CAPS_ACTION_TO_PLAN_ACTION = { + 'GOTOLOCATION': 'GotoLocation', + 'SCAN': 'Scan', + 'OPENOBJECT': 'OpenObject', + 'CLOSEOBJECT': 'CloseObject', + 'PICKUPOBJECT': 'PickupObject', + 'PICKUPOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', + 'PICKUPOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', + 'PICKUPRECEPTACLEOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', + 'PICKUPRECEPTACLEOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', + 'PICKUPOBJECTINOBJECT1': 'PickupObjectInObject', + 'PICKUPOBJECTINOBJECT2': 'PickupObjectInObject', + 'PUTOBJECTINRECEPTACLE1': 'PutObjectInReceptacle', + 'PUTOBJECTINRECEPTACLE2': 'PutObjectInReceptacle', + 'PUTOBJECTINRECEPTACLEOBJECT1': 'PutObjectInReceptacleObject', + 'PUTOBJECTINRECEPTACLEOBJECT2': 'PutObjectInReceptacleObject', + 'PUTRECEPTACLEOBJECTINRECEPTACLE1': 'PutReceptacleObjectInReceptacle', + 'PUTRECEPTACLEOBJECTINRECEPTACLE2': 'PutReceptacleObjectInReceptacle', + 'PICKUPOBJECTNORECEPTACLE': 'PickupObjectNoReceptacle', + 'PUTOBJECT': 'PutObject', + 'CLEANOBJECT': 'CleanObject', + 'HEATOBJECT': 'HeatObject', + 'TOGGLEOBJECT': 'ToggleObject', + 'COOLOBJECT': 'CoolObject', + 'SLICEOBJECT': 'SliceObject', + 'REACH-GOAL': 'End' +} + +LOWER_TO_FULL = {name.lower(): name for name in constants.OBJECTS} + + +def lower_to_full(input_str): + arr = input_str.split('|') + new_arr = [] + for item in arr: + if item in LOWER_TO_FULL: + new_arr.append(LOWER_TO_FULL[item]) + else: + new_arr.append(item) + return '|'.join(new_arr) + + + +def parse_action_arg(action_arg): + action_arg = action_arg.lower() + action_arg = py_util.multireplace(action_arg, + {'_minus_': '-', + '-': '#', + '_bar_': '|', + '_plus_': '+', + '_dot_': '.', + '_comma_': ','}) + action_arg = lower_to_full(action_arg) + return action_arg + + +def parse_line(line): + line = re.sub(r'^\s*step|\d+:\s*', '', line) + line = line.strip() + line_args = line.split(' ') + if line_args[0] not in CAPS_ACTION_TO_PLAN_ACTION: + return None + action = CAPS_ACTION_TO_PLAN_ACTION[line_args[0]] + if action == 'End': + return {'action': 'End', 'value': 1} + action_dict = {'action': action} + line_args = line_args[1:] # Remove action name from line_args + + if action in {'GotoLocation', 'Scan'}: + action_arg = line_args[2].lower() + action_arg = py_util.multireplace(action_arg, + {'_minus_': '-', + '-': '#', + '_bar_': '|', + '_plus_': '+', + '_dot_': '.', + '_comma_': ','}) + action_dict['location'] = action_arg + elif action in {'OpenObject', 'CloseObject', 'ToggleObject'}: + action_dict['objectId'] = parse_action_arg(line_args[2]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'HeatObject', 'CoolObject'}: + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'PickupObjectInReceptacle', 'PickupObjectNoReceptacle'}: + action_dict['action'] = 'PickupObject' + action_dict['objectId'] = parse_action_arg(line_args[2]) + if action == 'PickupObjectInReceptacle': + action_dict['receptacleObjectId'] = parse_action_arg(line_args[3]) + elif action in {'SliceObject'}: + action_dict['objectId'] = parse_action_arg(line_args[2]) + elif action in {'CleanObject'}: + action_dict['objectId'] = parse_action_arg(line_args[3]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) + elif action in {'PutObjectInReceptacle', + 'PutObjectInReceptacleObject', + 'PutReceptacleObjectInReceptacle'}: + action_dict['action'] = 'PutObject' + action_dict['objectId'] = parse_action_arg(line_args[3]) + action_dict['receptacleObjectId'] = parse_action_arg(line_args[4]) + elif action in {'PickupObjectInObject'}: + action_dict['action'] = 'PickupObject' + + + return action_dict + + +def parse_plan(lines): + plan = [] + for line in lines: + action_dict = parse_line(line) + if action_dict is not None: + plan.append(action_dict) + return plan + + +def parse_plan_from_file(self, path): + lines = [line for line in open(path)] + return self.parse_plan(lines) + + +def get_plan_from_file(args): + domain, filepath, solver_type = args + + start_t = time.time() + try: + command = ('ff_planner/ff ' + '-o %s ' + '-s %d ' + '-f %s ' % (domain, solver_type, filepath)) + if DEBUG: + print(command) + planner_output = subprocess.check_output(shlex.split(command), timeout=30) + except subprocess.CalledProcessError as error: + # Plan is done + output_str = error.output.decode('utf-8') + if DEBUG: + print('output', output_str) + if ('goal can be simplified to FALSE' in output_str or + "won't get here: simplify, non logical" in output_str): + return [{'action': 'End', 'value': 0}] + elif 'goal can be simplified to TRUE' in output_str: + return [{'action': 'End', 'value': 1}] + elif len(output_str) == 0: + # Usually indicates segfault with ffplanner + # This happens when the goal needs an object that hasn't been seen yet like + # Q: "is there an egg in the garbage can," but no garbage can has been seen. + print('Empty plan') + print('Seg Fault') + return [{'action': 'End', 'value': 0}] + else: + print('problem', filepath) + print(output_str) + print('Empty plan') + return [{'action': 'End', 'value': 0}] + except subprocess.TimeoutExpired: + print('timeout solver', solver_type, 'problem', filepath) + print('Empty plan') + return ['timeout', {'action': 'End', 'value': 0}] + unparsed_plan = planner_output.decode('utf-8').split('\n') + if DEBUG: + print('unparsed', '\n'.join(unparsed_plan)) + parsed_plan = parse_plan(unparsed_plan) + if constants.DEBUG: + print('planned %s in %.5f, plan length %d solver type %d' % ( + filepath, time.time() - start_t, len(parsed_plan), solver_type)) + if len(parsed_plan) == 0: + parsed_plan = [{'action': 'End', 'value': 1}] + return parsed_plan + + +# Example of how to call ff +# /path/to/Metric-FF-v2.1/ff -o planner/domains/Question_domain.pddl -f planner/exists_problem.pddl +def get_plan_async(args): + domain, problem_id, solver_type = args + filepath = '%s/planner/generated_problems/problem_%s.pddl' % (constants.LOG_FILE, problem_id) + return get_plan_from_file((domain, filepath, solver_type)) + + +class PlanParser(object): + def __init__(self, domain_file_path): + self.domain = domain_file_path + self.problem_id = -1 + self.process_pool = multiprocessing.Pool(3) + #from multiprocessing.pool import ThreadPool + #self.process_pool = ThreadPool(3) + + def get_plan(self): + parsed_plans = self.process_pool.map(get_plan_async, zip([self.domain] * 3, [self.problem_id] * 3, range(3, 6))) + return self.find_best_plan(parsed_plans) + + def get_plan_from_file(self, domain_path, filepath): + parsed_plans = self.process_pool.map(get_plan_from_file, zip([domain_path] * 3, [filepath] * 3, range(3, 6))) + return self.find_best_plan(parsed_plans) + + # Unncessary, planner should be optimal. But the planner produces some weird actions + def clean_plan(self, plan): + cleaned_plan = list() + for i in range(len(plan)-1): + if not (plan[i]['action'] == 'GotoLocation' and plan[i+1]['action'] == 'GotoLocation'): + cleaned_plan.append(plan[i]) + cleaned_plan.append(plan[len(plan)-1]) + return cleaned_plan + + def find_best_plan(self, parsed_plans): + + if all([parsed_plan[0] == 'timeout' for parsed_plan in parsed_plans]): + parsed_plan = parsed_plans[0][1:] + else: + parsed_plans = [self.clean_plan(parsed_plan) for parsed_plan in parsed_plans if parsed_plan[0] != 'timeout'] + parsed_plan = min(parsed_plans, key=len) + + if constants.DEBUG: + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) + for pp, pl in enumerate(parsed_plan)])) + else: + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) + for pp, pl in enumerate(parsed_plan)])) + return parsed_plan + + +class SinglePlanParser(PlanParser): + def get_plan(self): + parsed_plan = get_plan_async([self.domain, self.problem_id, 3]) + return parsed_plan + + def get_plan_from_file(self, domain_path, filepath): + parsed_plan = get_plan_from_file([domain_path, filepath, 3]) + return parsed_plan + + +if __name__ == '__main__': + import sys + + DEBUG = constants.DEBUG + parser = PlanParser('planner/domains/PutTaskExtended_domain.pddl') + parser.problem_id = sys.argv[1] + result_plan = parser.get_plan() + print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) for pp, pl in enumerate(result_plan)])) diff --git a/models/main_models/rt1/gen/planner/pddl.pdf b/models/main_models/rt1/gen/planner/pddl.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4acd4e0a5c03c58ab1177920fd70eaf3ce523982 GIT binary patch literal 196613 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

wc5{pc71>6lps{#4t; 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 literal 0 HcmV?d00001 diff --git a/models/main_models/rt1/gen/scripts/augment_trajectories.py b/models/main_models/rt1/gen/scripts/augment_trajectories.py new file mode 100644 index 000000000..19aeb9be2 --- /dev/null +++ b/models/main_models/rt1/gen/scripts/augment_trajectories.py @@ -0,0 +1,312 @@ +import os +import sys +sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) +sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) + +import json +import glob +import os +import constants +import cv2 +import shutil +import numpy as np +import argparse +import threading +import time +import copy +import random +from utils.video_util import VideoSaver +from utils.py_util import walklevel +from env.thor_env import ThorEnv + + +TRAJ_DATA_JSON_FILENAME = "traj_data.json" +AUGMENTED_TRAJ_DATA_JSON_FILENAME = "augmented_traj_data.json" + +ORIGINAL_IMAGES_FORLDER = "raw_images" +HIGH_RES_IMAGES_FOLDER = "high_res_images" +DEPTH_IMAGES_FOLDER = "depth_images" +INSTANCE_MASKS_FOLDER = "instance_masks" + +IMAGE_WIDTH = 600 +IMAGE_HEIGHT = 600 + +render_settings = dict() +render_settings['renderImage'] = True +render_settings['renderDepthImage'] = True +render_settings['renderObjectImage'] = True +render_settings['renderClassImage'] = True + +video_saver = VideoSaver() + + +def get_image_index(save_path): + return len(glob.glob(save_path + '/*.png')) + + +def save_image_with_delays(env, action, + save_path, direction=constants.BEFORE): + im_ind = get_image_index(save_path) + counts = constants.SAVE_FRAME_BEFORE_AND_AFTER_COUNTS[action['action']][direction] + for i in range(counts): + save_image(env.last_event, save_path) + env.noop() + return im_ind + + +def save_image(event, save_path): + # rgb + rgb_save_path = os.path.join(save_path, HIGH_RES_IMAGES_FOLDER) + rgb_image = event.frame[:, :, ::-1] + + # depth + depth_save_path = os.path.join(save_path, DEPTH_IMAGES_FOLDER) + depth_image = event.depth_frame + depth_image = depth_image * (255 / 10000) + depth_image = depth_image.astype(np.uint8) + + # masks + mask_save_path = os.path.join(save_path, INSTANCE_MASKS_FOLDER) + mask_image = event.instance_segmentation_frame + + # dump images + im_ind = get_image_index(rgb_save_path) + cv2.imwrite(rgb_save_path + '/%09d.png' % im_ind, rgb_image) + cv2.imwrite(depth_save_path + '/%09d.png' % im_ind, depth_image) + cv2.imwrite(mask_save_path + '/%09d.png' % im_ind, mask_image) + + return im_ind + + +def save_images_in_events(events, root_dir): + for event in events: + save_image(event, root_dir) + + +def clear_and_create_dir(path): + if os.path.exists(path): + shutil.rmtree(path) + os.mkdir(path) + + +def augment_traj(env, json_file): + # load json data + with open(json_file) as f: + traj_data = json.load(f) + + # make directories + root_dir = json_file.replace(TRAJ_DATA_JSON_FILENAME, "") + + orig_images_dir = os.path.join(root_dir, ORIGINAL_IMAGES_FORLDER) + high_res_images_dir = os.path.join(root_dir, HIGH_RES_IMAGES_FOLDER) + depth_images_dir = os.path.join(root_dir, DEPTH_IMAGES_FOLDER) + instance_masks_dir = os.path.join(root_dir, INSTANCE_MASKS_FOLDER) + augmented_json_file = os.path.join(root_dir, AUGMENTED_TRAJ_DATA_JSON_FILENAME) + + # fresh images list + traj_data['images'] = list() + + clear_and_create_dir(high_res_images_dir) + clear_and_create_dir(depth_images_dir) + clear_and_create_dir(instance_masks_dir) + + # scene setup + scene_num = traj_data['scene']['scene_num'] + object_poses = traj_data['scene']['object_poses'] + object_toggles = traj_data['scene']['object_toggles'] + dirty_and_empty = traj_data['scene']['dirty_and_empty'] + + # reset + scene_name = 'FloorPlan%d' % scene_num + env.reset(scene_name) + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + + env.step(dict(traj_data['scene']['init_action'])) + print("Task: %s" % (traj_data['template']['task_desc'])) + + # setup task + env.set_task(traj_data, args, reward_type='dense') + rewards = [] + + for ll_idx, ll_action in enumerate(traj_data['plan']['low_actions']): + # next cmd under the current hl_action + cmd = ll_action['api_action'] + hl_action = traj_data['plan']['high_pddl'][ll_action['high_idx']] + + # remove unnecessary keys + cmd = {k: cmd[k] for k in ['action', 'objectId', 'receptacleObjectId', 'placeStationary', 'forceAction'] if k in cmd} + + if "MoveAhead" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_move_ahead(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + elif "Rotate" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_rotate(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + elif "Look" in cmd['action']: + if args.smooth_nav: + save_image(env.last_event, root_dir) + events = env.smooth_look(cmd, render_settings) + save_images_in_events(events, root_dir) + event = events[-1] + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + # handle the exception for CoolObject tasks where the actual 'CoolObject' action is actually 'CloseObject' + # TODO: a proper fix for this issue + elif "CloseObject" in cmd['action'] and \ + "CoolObject" in hl_action['planner_action']['action'] and \ + "OpenObject" in traj_data['plan']['low_actions'][ll_idx + 1]['api_action']['action']: + if args.time_delays: + cool_action = hl_action['planner_action'] + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.BEFORE) + event = env.step(cmd) + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.MIDDLE) + save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.AFTER) + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + else: + if args.time_delays: + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.BEFORE) + event = env.step(cmd) + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.MIDDLE) + save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.AFTER) + else: + save_image(env.last_event, root_dir) + event = env.step(cmd) + + # update image list + new_img_idx = get_image_index(high_res_images_dir) + last_img_idx = len(traj_data['images']) + num_new_images = new_img_idx - last_img_idx + for j in range(num_new_images): + traj_data['images'].append({ + 'low_idx': ll_idx, + 'high_idx': ll_action['high_idx'], + 'image_name': '%09d.png' % int(last_img_idx + j) + }) + + if not event.metadata['lastActionSuccess']: + raise Exception("Replay Failed: %s" % (env.last_event.metadata['errorMessage'])) + + reward, _ = env.get_transition_reward() + rewards.append(reward) + + # save 10 frames in the end as per the training data + for _ in range(10): + save_image(env.last_event, root_dir) + + # store color to object type dictionary + color_to_obj_id_type = {} + all_objects = env.last_event.metadata['objects'] + for color, object_id in env.last_event.color_to_object_id.items(): + for obj in all_objects: + if object_id == obj['objectId']: + color_to_obj_id_type[str(color)] = { + 'objectID': obj['objectId'], + 'objectType': obj['objectType'] + } + + augmented_traj_data = copy.deepcopy(traj_data) + augmented_traj_data['scene']['color_to_object_type'] = color_to_obj_id_type + augmented_traj_data['task'] = {'rewards': rewards, 'reward_upper_bound': sum(rewards)} + + with open(augmented_json_file, 'w') as aj: + json.dump(augmented_traj_data, aj, sort_keys=True, indent=4) + + # save video + images_path = os.path.join(high_res_images_dir, '*.png') + video_save_path = os.path.join(high_res_images_dir, 'high_res_video.mp4') + video_saver.save(images_path, video_save_path) + + # check if number of new images is the same as the number of original images + if args.smooth_nav and args.time_delays: + orig_img_count = get_image_index(high_res_images_dir) + new_img_count = get_image_index(orig_images_dir) + print ("Original Image Count %d, New Image Count %d" % (orig_img_count, new_img_count)) + if orig_img_count != new_img_count: + raise Exception("WARNING: the augmented sequence length doesn't match the original") + + +def run(): + ''' + replay loop + ''' + # start THOR env + env = ThorEnv(player_screen_width=IMAGE_WIDTH, + player_screen_height=IMAGE_HEIGHT) + + skipped_files = [] + + while len(traj_list) > 0: + lock.acquire() + json_file = traj_list.pop() + lock.release() + + print ("Augmenting: " + json_file) + try: + augment_traj(env, json_file) + except Exception as e: + import traceback + traceback.print_exc() + print ("Error: " + repr(e)) + print ("Skipping " + json_file) + skipped_files.append(json_file) + + env.stop() + print("Finished.") + + # skipped files + if len(skipped_files) > 0: + print("Skipped Files:") + print(skipped_files) + + +traj_list = [] +lock = threading.Lock() + +# parse arguments +parser = argparse.ArgumentParser() +parser.add_argument('--data_path', type=str, default="data/2.1.0") +parser.add_argument('--smooth_nav', dest='smooth_nav', action='store_true') +parser.add_argument('--time_delays', dest='time_delays', action='store_true') +parser.add_argument('--shuffle', dest='shuffle', action='store_true') +parser.add_argument('--num_threads', type=int, default=1) +parser.add_argument('--reward_config', type=str, default='../models/config/rewards.json') +args = parser.parse_args() + +# make a list of all the traj_data json files +for dir_name, subdir_list, file_list in walklevel(args.data_path, level=2): + if "trial_" in dir_name: + json_file = os.path.join(dir_name, TRAJ_DATA_JSON_FILENAME) + if not os.path.isfile(json_file): + continue + traj_list.append(json_file) + +# random shuffle +if args.shuffle: + random.shuffle(traj_list) + +# start threads +threads = [] +for n in range(args.num_threads): + thread = threading.Thread(target=run) + threads.append(thread) + thread.start() + time.sleep(1) \ No newline at end of file diff --git a/models/main_models/rt1/gen/scripts/generate_trajectories.py b/models/main_models/rt1/gen/scripts/generate_trajectories.py new file mode 100644 index 000000000..5e67ce0e8 --- /dev/null +++ b/models/main_models/rt1/gen/scripts/generate_trajectories.py @@ -0,0 +1,752 @@ +import os +import sys +sys.path.append(os.path.join('/Users/jiasenl/Code/alfred')) +sys.path.append(os.path.join('/Users/jiasenl/Code/alfred', 'gen')) + +import time +import multiprocessing as mp +import json +import random +import shutil +import argparse +import numpy as np +import pandas as pd +from collections import OrderedDict +from datetime import datetime +import glob +import constants +from agents.deterministic_planner_agent import DeterministicPlannerAgent +from env.thor_env import ThorEnv +from game_states.task_game_state_full_knowledge import TaskGameStateFullKnowledge +from utils.video_util import VideoSaver +from utils.dataset_management_util import load_successes_from_disk, load_fails_from_disk + +# params +RAW_IMAGES_FOLDER = 'raw_images/' +DATA_JSON_FILENAME = 'traj_data.json' +DEPTH_IMAGES_FOLDER = 'depth_images/' + +# video saver +video_saver = VideoSaver() + +# structures to help with constraint enforcement. +goal_to_required_variables = {"pick_and_place_simple": {"pickup", "receptacle", "scene"}, + "pick_two_obj_and_place": {"pickup", "receptacle", "scene"}, + "look_at_obj_in_light": {"pickup", "receptacle", "scene"}, + "pick_clean_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_heat_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_cool_then_place_in_recep": {"pickup", "receptacle", "scene"}, + "pick_and_place_with_movable_recep": {"pickup", "movable", "receptacle", "scene"}} +goal_to_pickup_type = {'pick_heat_then_place_in_recep': 'Heatable', + 'pick_cool_then_place_in_recep': 'Coolable', + 'pick_clean_then_place_in_recep': 'Cleanable'} +goal_to_receptacle_type = {'look_at_obj_in_light': "Toggleable"} +goal_to_invalid_receptacle = {'pick_heat_then_place_in_recep': {'Microwave'}, + 'pick_cool_then_place_in_recep': {'Fridge'}, + 'pick_clean_then_place_in_recep': {'SinkBasin'}, + 'pick_two_obj_and_place': {'CoffeeMachine', 'ToiletPaperHanger', 'HandTowelHolder'}} + +scene_id_to_objs = {} +obj_to_scene_ids = {} +scenes_for_goal = {g: [] for g in constants.GOALS} +scene_to_type = {} + + +def sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, receptacle_candidates, scene_candidates, + inject_noise=10): + # Get the current conditional distributions of all variables (goal/pickup/receptacle/scene). + goal_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + succ_traj.loc[ + (succ_traj['pickup'].isin(pickup_candidates) if 'pickup' in goal_to_required_variables[c] else True) & + (succ_traj['movable'].isin(movable_candidates) if 'movable' in goal_to_required_variables[c] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) if 'receptacle' in goal_to_required_variables[c] else True) + & (succ_traj['scene'].isin(scene_candidates) if 'scene' in goal_to_required_variables[c] else True)] + ['goal'].tolist().count(c))) # Conditional. + * (1 / (1 + succ_traj['goal'].tolist().count(c))) # Prior. + for c in goal_candidates] + goal_probs = [w / sum(goal_weight) for w in goal_weight] + + pickup_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['pickup'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['pickup'].tolist().count(c))) + for c in pickup_candidates] + pickup_probs = [w / sum(pickup_weight) for w in pickup_weight] + + movable_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['movable'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['movable'].tolist().count(c))) + for c in movable_candidates] + movable_probs = [w / sum(movable_weight) for w in movable_weight] + + receptacle_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['scene'].isin(scene_candidates) + if 'scene' in goal_to_required_variables[g] else True)] + ['receptacle'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['receptacle'].tolist().count(c))) + for c in receptacle_candidates] + receptacle_probs = [w / sum(receptacle_weight) for w in receptacle_weight] + scene_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + + sum([succ_traj.loc[ + succ_traj['goal'].isin([g]) & + (succ_traj['pickup'].isin(pickup_candidates) + if 'pickup' in goal_to_required_variables[g] else True) & + (succ_traj['movable'].isin(movable_candidates) + if 'movable' in goal_to_required_variables[g] else True) & + (succ_traj['receptacle'].isin(receptacle_candidates) + if 'receptacle' in goal_to_required_variables[g] else True)] + ['scene'].tolist().count(c) for g in goal_candidates]))) + * (1 / (1 + succ_traj['scene'].tolist().count(c))) + for c in scene_candidates] + scene_probs = [w / sum(scene_weight) for w in scene_weight] + + # Calculate the probability difference between each value and the maximum so we can iterate over them to find a + # next-best candidate to sample subject to the constraints of knowing which will fail. + diffs = [("goal", goal_candidates[idx], goal_probs[idx] - min(goal_probs)) + for idx in range(len(goal_candidates)) if len(goal_candidates) > 1] + diffs.extend([("pickup", pickup_candidates[idx], pickup_probs[idx] - min(pickup_probs)) + for idx in range(len(pickup_candidates)) if len(pickup_candidates) > 1]) + diffs.extend([("movable", movable_candidates[idx], movable_probs[idx] - min(movable_probs)) + for idx in range(len(movable_candidates)) if len(movable_candidates) > 1]) + diffs.extend([("receptacle", receptacle_candidates[idx], receptacle_probs[idx] - min(receptacle_probs)) + for idx in range(len(receptacle_candidates)) if len(receptacle_candidates) > 1]) + diffs.extend([("scene", scene_candidates[idx], scene_probs[idx] - min(scene_probs)) + for idx in range(len(scene_candidates)) if len(scene_candidates) > 1]) + + # Iteratively pop the next biggest difference until we find a combination that is valid (e.g., not already + # flagged as impossible by the simulator). + variable_value_by_diff = {} + diffs_as_keys = [] # list of diffs; index into list will be used as key values. + for _, _, diff in diffs: + already_keyed = False + for existing_diff in diffs_as_keys: + if np.isclose(existing_diff, diff): + already_keyed = True + break + if not already_keyed: + diffs_as_keys.append(diff) + for variable, value, diff in diffs: + key = None + for kidx in range(len(diffs_as_keys)): + if np.isclose(diffs_as_keys[kidx], diff): + key = kidx + if key not in variable_value_by_diff: + variable_value_by_diff[key] = [] + variable_value_by_diff[key].append((variable, value)) + + for key, diff in sorted(enumerate(diffs_as_keys), key=lambda x: x[1], reverse=True): + variable_value = variable_value_by_diff[key] + random.shuffle(variable_value) + for variable, value in variable_value: + + # Select a goal. + if variable == "goal": + gtype = value + # print("sampled goal '%s' with prob %.4f" % (gtype, goal_probs[goal_candidates.index(gtype)])) + _goal_candidates = [gtype] + + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a pickup object. + elif variable == "pickup": + pickup_obj = value + # print("sampled pickup object '%s' with prob %.4f" % + # (pickup_obj, pickup_probs[pickup_candidates.index(pickup_obj)])) + _pickup_candidates = [pickup_obj] + + _goal_candidates = goal_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a movable object. + elif variable == "movable": + movable_obj = value + # print("sampled movable object '%s' with prob %.4f" % + # (movable_obj, movable_probs[movable_candidates.index(movable_obj)])) + _movable_candidates = [movable_obj] + _goal_candidates = [g for g in goal_candidates if g == 'pick_and_place_with_movable_recep'] + + _pickup_candidates = pickup_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a receptacle. + elif variable == "receptacle": + receptacle_obj = value + # print("sampled receptacle object '%s' with prob %.4f" % + # (receptacle_obj, receptacle_probs[receptacle_candidates.index(receptacle_obj)])) + _receptacle_candidates = [receptacle_obj] + + _goal_candidates = goal_candidates[:] + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _scene_candidates = scene_candidates[:] + + # Select a scene. + else: + sampled_scene = value + # print("sampled scene %s with prob %.4f" % + # (sampled_scene, scene_probs[scene_candidates.index(sampled_scene)])) + _scene_candidates = [sampled_scene] + + _goal_candidates = goal_candidates[:] + _pickup_candidates = pickup_candidates[:] + _movable_candidates = movable_candidates[:] + _receptacle_candidates = receptacle_candidates[:] + # Perform constraint propagation to determine whether this is a valid assignment. + propagation_finished = False + while not propagation_finished: + assignment_lens = (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), + len(_receptacle_candidates), len(_scene_candidates)) + # Constraints on goal. + _goal_candidates = [g for g in _goal_candidates if + (g not in goal_to_pickup_type or + len(set(_pickup_candidates).intersection( # Pickup constraint. + constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]])) > 0) + and (g not in goal_to_receptacle_type or + np.any([r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]] + for r in _receptacle_candidates])) # Valid by goal receptacle const. + and (g not in goal_to_invalid_receptacle or + len(set(_receptacle_candidates).difference( + goal_to_invalid_receptacle[g])) > 0) # Invalid by goal receptacle const. + and len(set(_scene_candidates).intersection( + scenes_for_goal[g])) > 0 # Scene constraint + ] + + # Define whether to consider constraints for each role based on current set of candidate goals. + pickup_constrained = np.any(["pickup" in goal_to_required_variables[g] for g in _goal_candidates]) + movable_constrained = np.any(["movable" in goal_to_required_variables[g] for g in _goal_candidates]) + receptacle_constrained = np.any(["receptacle" in goal_to_required_variables[g] + for g in _goal_candidates]) + scene_constrained = np.any(["scene" in goal_to_required_variables[g] for g in _goal_candidates]) + + # Constraints on pickup obj. + _pickup_candidates = [p for p in _pickup_candidates if + np.any([g not in goal_to_pickup_type or + p in constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]] + for g in _goal_candidates]) # Goal constraint. + and (not movable_constrained or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] + for m in _movable_candidates])) # Movable constraint. + and (not receptacle_constrained or + np.any([r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + p in constants.VAL_RECEPTACLE_OBJECTS[r] + for r in _receptacle_candidates])) # Receptacle constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[p]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on movable obj. + _movable_candidates = [m for m in _movable_candidates if + 'pick_and_place_with_movable_recep' in _goal_candidates # Goal constraint + and (not pickup_constrained or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] + for p in _pickup_candidates])) # Pickup constraint. + and (not receptacle_constrained or + np.any([r in constants.VAL_RECEPTACLE_OBJECTS and + m in constants.VAL_RECEPTACLE_OBJECTS[r] + for r in _receptacle_candidates])) # Receptacle constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[m]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on receptacle obj. + _receptacle_candidates = [r for r in _receptacle_candidates if + np.any([(g not in goal_to_receptacle_type or + r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]]) and + (g not in goal_to_invalid_receptacle or + r not in goal_to_invalid_receptacle[g]) + for g in _goal_candidates]) # Goal constraint. + and (not receptacle_constrained or + r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + np.any([p in constants.VAL_RECEPTACLE_OBJECTS[r] + for p in _pickup_candidates])) # Pickup constraint. + and (not movable_constrained or + r in constants.VAL_ACTION_OBJECTS["Toggleable"] or + np.any([m in constants.VAL_RECEPTACLE_OBJECTS[r] + for m in _movable_candidates])) # Movable constraint. + and (not scene_constrained or + np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[r]] + for s in _scene_candidates])) # Scene constraint + ] + # Constraints on scene. + _scene_candidates = [s for s in _scene_candidates if + np.any([s in scenes_for_goal[g] + for g in _goal_candidates]) # Goal constraint. + and (not pickup_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[p]] + for p in _pickup_candidates])) # Pickup constraint. + and (not movable_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[m]] + for m in _movable_candidates])) # Movable constraint. + and (not receptacle_constrained or + np.any([obj_to_scene_ids[constants.OBJ_PARENTS[r]] + for r in _receptacle_candidates])) # Receptacle constraint. + ] + if assignment_lens == (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), + len(_receptacle_candidates), len(_scene_candidates)): + propagation_finished = True + + candidate_lens = {"goal": len(_goal_candidates), "pickup": len(_pickup_candidates), + "movable": len(_movable_candidates), "receptacle": len(_receptacle_candidates), + "scene": len(_scene_candidates)} + if candidate_lens["goal"] == 0: + # print("Goal over-constrained; skipping") + continue + if np.all([0 in [candidate_lens[v] for v in goal_to_required_variables[g]] for g in _goal_candidates]): + continue + + # Ensure some combination of the remaining constraints is not in failures and is not already populated + # by the target number of repeats. + failure_ensured = True + full_ensured = True + for g in _goal_candidates: + pickup_iter = _pickup_candidates if "pickup" in goal_to_required_variables[g] else ["None"] + for p in pickup_iter: + movable_iter = _movable_candidates if "movable" in goal_to_required_variables[g] else ["None"] + for m in movable_iter: + receptacle_iter = _receptacle_candidates if "receptacle" in goal_to_required_variables[g] \ + else ["None"] + for r in receptacle_iter: + scene_iter = _scene_candidates if "scene" in goal_to_required_variables[g] else ["None"] + for s in scene_iter: + if (g, p, m, r, s) not in fail_traj: + failure_ensured = False + if (g, p, m, r, s) not in full_traj: + full_ensured = False + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if not failure_ensured and not full_ensured: + break + if failure_ensured: + continue + if full_ensured: + continue + + if candidate_lens["goal"] > 1 or np.any([np.any([candidate_lens[v] > 1 + for v in goal_to_required_variables[g]]) + for g in _goal_candidates]): + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + _goal_candidates, _pickup_candidates, _movable_candidates, + _receptacle_candidates, _scene_candidates) + sampled_task = next(task_sampler) + if sampled_task is None: + continue + else: + g = _goal_candidates[0] + p = _pickup_candidates[0] if "pickup" in goal_to_required_variables[g] else "None" + m = _movable_candidates[0] if "movable" in goal_to_required_variables[g] else "None" + r = _receptacle_candidates[0] if "receptacle" in goal_to_required_variables[g] else "None" + s = _scene_candidates[0] if "scene" in goal_to_required_variables[g] else "None" + sampled_task = (g, p, m, r, int(s)) + + yield sampled_task + + yield None # Discovered that there are no valid assignments remaining. + + +def print_successes(succ_traj): + print("###################################\n") + print("Successes: ") + print(succ_traj) + print("\n##################################") + + +def main(args, thread_num=0): + + print(thread_num) + # settings + alfred_dataset_path = '../data/json_2.1.0/train' + + constants.DATA_SAVE_PATH = args.save_path + print("Force Unsave Data: %s" % str(args.force_unsave)) + + # Set up data structure to track dataset balance and use for selecting next parameters. + # In actively gathering data, we will try to maximize entropy for each (e.g., uniform spread of goals, + # uniform spread over patient objects, uniform recipient objects, and uniform scenes). + succ_traj = pd.DataFrame(columns=["goal", "pickup", "movable", "receptacle", "scene"]) + + # objects-to-scene and scene-to-objects database + for scene_type, ids in constants.SCENE_TYPE.items(): + for id in ids: + obj_json_file = os.path.join('layouts', 'FloorPlan%d-objects.json' % id) + with open(obj_json_file, 'r') as of: + scene_objs = json.load(of) + + id_str = str(id) + scene_id_to_objs[id_str] = scene_objs + for obj in scene_objs: + if obj not in obj_to_scene_ids: + obj_to_scene_ids[obj] = set() + obj_to_scene_ids[obj].add(id_str) + + # scene-goal database + for g in constants.GOALS: + for st in constants.GOALS_VALID[g]: + scenes_for_goal[g].extend([str(s) for s in constants.SCENE_TYPE[st]]) + scenes_for_goal[g] = set(scenes_for_goal[g]) + + # scene-type database + for st in constants.SCENE_TYPE: + for s in constants.SCENE_TYPE[st]: + scene_to_type[str(s)] = st + + # pre-populate counts in this structure using saved trajectories path. + succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, args.just_examine, args.repeats_per_cond) + if args.just_examine: + print_successes(succ_traj) + return + + print(succ_traj.groupby('goal').count()) + # pre-populate failed trajectories. + fail_traj = load_fails_from_disk(args.save_path) + print("Loaded %d known failed tuples" % len(fail_traj)) + + # create env and agent + env = ThorEnv(x_display='0.%d' %(thread_num % 2)) + + game_state = TaskGameStateFullKnowledge(env) + agent = DeterministicPlannerAgent(thread_id=0, game_state=game_state) + + errors = {} # map from error strings to counts, to be shown after every failure. + goal_candidates = constants.GOALS[:] + pickup_candidates = list(set().union(*[constants.VAL_RECEPTACLE_OBJECTS[obj] # Union objects that can be placed. + for obj in constants.VAL_RECEPTACLE_OBJECTS])) + pickup_candidates = [p for p in pickup_candidates if constants.OBJ_PARENTS[p] in obj_to_scene_ids] + movable_candidates = list(set(constants.MOVABLE_RECEPTACLES).intersection(obj_to_scene_ids.keys())) + receptacle_candidates = [obj for obj in constants.VAL_RECEPTACLE_OBJECTS + if obj not in constants.MOVABLE_RECEPTACLES and obj in obj_to_scene_ids] + \ + [obj for obj in constants.VAL_ACTION_OBJECTS["Toggleable"] + if obj in obj_to_scene_ids] + + # toaster isn't interesting in terms of producing linguistic diversity + receptacle_candidates.remove('Toaster') + receptacle_candidates.sort() + + scene_candidates = list(scene_id_to_objs.keys()) + + n_until_load_successes = args.async_load_every_n_samples + print_successes(succ_traj) + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, + receptacle_candidates, scene_candidates) + + # main generation loop + # keeps trying out new task tuples as trajectories either fail or suceed + while True: + # for _ in range(20): + for ii, json_path in enumerate(glob.iglob(os.path.join(alfred_dataset_path, "**", "traj_data.json"), recursive=True)): + # if ii % args.num_threads == thread_num: + # if ii == 5: + sampled_task = json_path.split('/')[-3].split('-') + # sampled_task = next(task_sampler) + # print("===============") + # print(ii, json_path) + print(sampled_task) # DEBUG + # print("===============") + + if sampled_task is None: + sys.exit("No valid tuples left to sample (all are known to fail or already have %d trajectories" % + args.repeats_per_cond) + gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene = sampled_task + + sampled_scene = int(sampled_scene) + print("sampled tuple: " + str((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene))) + + tries_remaining = args.trials_before_fail + # only try to get the number of trajectories left to make this tuple full. + target_remaining = args.repeats_per_cond - len(succ_traj.loc[(succ_traj['goal'] == gtype) & + (succ_traj['pickup'] == pickup_obj) & + (succ_traj['movable'] == movable_obj) & + (succ_traj['receptacle'] == receptacle_obj) & + (succ_traj['scene'] == str(sampled_scene))]) + num_place_fails = 0 # count of errors related to placement failure for no valid positions. + + # continue until we're (out of tries + have never succeeded) or (have gathered the target number of instances) + while num_place_fails > args.trials_before_fail or target_remaining > 0: + + # environment setup + constants.pddl_goal_type = gtype + print("PDDLGoalType: " + constants.pddl_goal_type) + task_id = create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene) + + # setup data dictionary + setup_data_dict() + constants.data_dict['task_id'] = task_id + constants.data_dict['task_type'] = constants.pddl_goal_type + constants.data_dict['dataset_params']['video_frame_rate'] = constants.VIDEO_FRAME_RATE + + # plan & execute + try: + # if True: + # Agent reset to new scene. + constraint_objs = {'repeat': [(constants.OBJ_PARENTS[pickup_obj], # Generate multiple parent objs. + np.random.randint(2 if gtype == "pick_two_obj_and_place" else 1, + constants.PICKUP_REPEAT_MAX + 1))], + 'sparse': [(receptacle_obj.replace('Basin', ''), + num_place_fails * constants.RECEPTACLE_SPARSE_POINTS)]} + if movable_obj != "None": + constraint_objs['repeat'].append((movable_obj, + np.random.randint(1, constants.PICKUP_REPEAT_MAX + 1))) + for obj_type in scene_id_to_objs[str(sampled_scene)]: + if (obj_type in pickup_candidates and + obj_type != constants.OBJ_PARENTS[pickup_obj] and obj_type != movable_obj): + constraint_objs['repeat'].append((obj_type, + np.random.randint(1, constants.MAX_NUM_OF_OBJ_INSTANCES + 1))) + if gtype in goal_to_invalid_receptacle: + constraint_objs['empty'] = [(r.replace('Basin', ''), num_place_fails * constants.RECEPTACLE_EMPTY_POINTS) + for r in goal_to_invalid_receptacle[gtype]] + constraint_objs['seton'] = [] + if gtype == 'look_at_obj_in_light': + constraint_objs['seton'].append((receptacle_obj, False)) + if num_place_fails > 0: + print("Failed %d placements in the past; increased free point constraints: " % num_place_fails + + str(constraint_objs)) + scene_info = {'scene_num': sampled_scene, 'random_seed': random.randint(0, 2 ** 32)} + info = agent.reset(scene=scene_info, + objs=constraint_objs) + + # Problem initialization with given constraints. + task_objs = {'pickup': pickup_obj} + if movable_obj != "None": + task_objs['mrecep'] = movable_obj + if gtype == "look_at_obj_in_light": + task_objs['toggle'] = receptacle_obj + else: + task_objs['receptacle'] = receptacle_obj + agent.setup_problem({'info': info}, scene=scene_info, objs=task_objs) + + # Now that objects are in their initial places, record them. + object_poses = [{'objectName': obj['name'].split('(Clone)')[0], + 'position': obj['position'], + 'rotation': obj['rotation']} + for obj in env.last_event.metadata['objects'] if obj['pickupable']] + dirty_and_empty = gtype == 'pick_clean_then_place_in_recep' + object_toggles = [{'objectType': o, 'stateChange': 'toggleable', 'isToggled': v} + for o, v in constraint_objs['seton']] + constants.data_dict['scene']['object_poses'] = object_poses + constants.data_dict['scene']['dirty_and_empty'] = dirty_and_empty + constants.data_dict['scene']['object_toggles'] = object_toggles + + # Pre-restore the scene to cause objects to "jitter" like they will when the episode is replayed + # based on stored object and toggle info. This should put objects closer to the final positions they'll + # be inlay at inference time (e.g., mugs fallen and broken, knives fallen over, etc.). + print("Performing reset via thor_env API") + env.reset(sampled_scene) + print("Performing restore via thor_env API") + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + event = env.step(dict(constants.data_dict['scene']['init_action'])) + + terminal = False + while not terminal and agent.current_frame_count <= constants.MAX_EPISODE_LENGTH: + action_dict = agent.get_action(None) + agent.step(action_dict) + reward, terminal = agent.get_reward() + + dump_data_dict() + save_video() + # else: + except Exception as e: + import traceback + traceback.print_exc() + print("Error: " + repr(e)) + print("Invalid Task: skipping...") + if args.debug: + print(traceback.format_exc()) + + deleted = delete_save(args.in_parallel) + if not deleted: # another thread is filling this task successfully, so leave it alone. + target_remaining = 0 # stop trying to do this task. + else: + if str(e) == "API Action Failed: No valid positions to place object found": + # Try increasing the space available on sparse and empty flagged objects. + num_place_fails += 1 + tries_remaining -= 1 + else: # generic error + tries_remaining -= 1 + + estr = str(e) + if len(estr) > 120: + estr = estr[:120] + if estr not in errors: + errors[estr] = 0 + errors[estr] += 1 + print("%%%%%%%%%%") + es = sum([errors[er] for er in errors]) + print("\terrors (%d):" % es) + for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): + if v / es < 0.01: # stop showing below 1% of errors. + break + print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) + print("%%%%%%%%%%") + + continue + + if args.force_unsave: + delete_save(args.in_parallel) + + # add to save structure. + succ_traj = succ_traj.append({ + "goal": gtype, + "movable": movable_obj, + "pickup": pickup_obj, + "receptacle": receptacle_obj, + "scene": str(sampled_scene)}, ignore_index=True) + target_remaining -= 1 + tries_remaining += args.trials_before_fail # on success, add more tries for future successes + + # if this combination resulted in a certain number of failures with no successes, flag it as not possible. + if tries_remaining == 0 and target_remaining == args.repeats_per_cond: + new_fails = [(gtype, pickup_obj, movable_obj, receptacle_obj, str(sampled_scene))] + fail_traj = load_fails_from_disk(args.save_path, to_write=new_fails) + print("%%%%%%%%%%") + print("failures (%d)" % len(fail_traj)) + # print("\t" + "\n\t".join([str(ft) for ft in fail_traj])) + print("%%%%%%%%%%") + + # if this combination gave us the repeats we wanted, note it as filled. + if target_remaining == 0: + full_traj.add((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene)) + + # if we're sharing with other processes, reload successes from disk to update local copy with others' additions. + if args.in_parallel: + if n_until_load_successes > 0: + n_until_load_successes -= 1 + else: + print("Reloading trajectories from disk because of parallel processes...") + succ_traj = pd.DataFrame(columns=succ_traj.columns) # Drop all rows. + succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, False, args.repeats_per_cond) + print("... Loaded %d trajectories" % len(succ_traj.index)) + n_until_load_successes = args.async_load_every_n_samples + print_successes(succ_traj) + task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, + goal_candidates, pickup_candidates, movable_candidates, + receptacle_candidates, scene_candidates) + print("... Created fresh instance of sample_task_params generator") + + +def create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, scene_num): + task_id = 'trial_T' + datetime.now().strftime("%Y%m%d_%H%M%S_%f") + save_name = '%s-%s-%s-%s-%d' % (gtype, pickup_obj, movable_obj, receptacle_obj, scene_num) + '/' + task_id + + constants.save_path = os.path.join(constants.DATA_SAVE_PATH, save_name, RAW_IMAGES_FOLDER) + constants.save_depth_path = os.path.join(constants.DATA_SAVE_PATH, save_name, DEPTH_IMAGES_FOLDER) + + if not os.path.exists(constants.save_path): + os.makedirs(constants.save_path) + + if not os.path.exists(constants.save_depth_path): + os.makedirs(constants.save_depth_path) + + print("Saving images to: " + constants.save_path) + return task_id + + +def save_video(): + images_path = constants.save_path + '*.png' + video_path = os.path.join(constants.save_path.replace(RAW_IMAGES_FOLDER, ''), 'video.mp4') + video_saver.save(images_path, video_path) + + +def setup_data_dict(): + constants.data_dict = OrderedDict() + constants.data_dict['task_id'] = "" + constants.data_dict['task_type'] = "" + constants.data_dict['scene'] = {'floor_plan': "", 'random_seed': -1, 'scene_num': -1, 'init_action': [], + 'object_poses': [], 'dirty_and_empty': None, 'object_toggles': []} + constants.data_dict['plan'] = {'high_pddl': [], 'low_actions': []} + constants.data_dict['images'] = [] + constants.data_dict['template'] = {'task_desc': "", 'high_descs': []} + constants.data_dict['pddl_params'] = {'object_target': -1, 'object_sliced': -1, + 'parent_target': -1, 'toggle_target': -1, + 'mrecep_target': -1} + constants.data_dict['dataset_params'] = {'video_frame_rate': -1} + constants.data_dict['pddl_state'] = [] + + +def dump_data_dict(): + data_save_path = constants.save_path.replace(RAW_IMAGES_FOLDER, '') + with open(os.path.join(data_save_path, DATA_JSON_FILENAME), 'w') as fp: + json.dump(constants.data_dict, fp, sort_keys=True, indent=4) + + +def delete_save(in_parallel): + save_folder = constants.save_path.replace(RAW_IMAGES_FOLDER, '') + if os.path.exists(save_folder): + try: + shutil.rmtree(save_folder) + except OSError as e: + if in_parallel: # another thread succeeded at this task while this one failed. + return False + else: + raise e # if we're not running in parallel, this is an actual. + return True + + +def parallel_main(args): + procs = [mp.Process(target=main, args=(args,thread_num)) for thread_num in range(args.num_threads)] + try: + for proc in procs: + proc.start() + time.sleep(0.1) + finally: + for proc in procs: + proc.join() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + # settings + parser.add_argument('--force_unsave', action='store_true', help="don't save any data (for debugging purposes)") + parser.add_argument('--debug', action='store_true') + parser.add_argument('--save_path', type=str, default="dataset/new_trajectories_valid_seen", help="where to save the generated data") + parser.add_argument('--x_display', type=str, required=False, default=constants.X_DISPLAY, help="x_display id") + parser.add_argument("--just_examine", action='store_true', help="just examine what data is gathered; don't gather more") + parser.add_argument("--in_parallel", action='store_true', help="this collection will run in parallel with others, so load from disk on every new sample") + parser.add_argument("-n", "--num_threads", type=int, default=1, help="number of processes for parallel mode") + parser.add_argument('--json_file', type=str, default="", help="path to json file with trajectory dump") + + # params + parser.add_argument("--repeats_per_cond", type=int, default=3) + parser.add_argument("--trials_before_fail", type=int, default=5) + parser.add_argument("--async_load_every_n_samples", type=int, default=10) + parser.add_argument('--gpu_id', type=int, default=0) + + parse_args = parser.parse_args() + + # if parse_args.in_parallel and parse_args.num_threads > 1: + # parallel_main(parse_args) + # else: + main(parse_args) diff --git a/models/main_models/rt1/gen/scripts/replay_checks.py b/models/main_models/rt1/gen/scripts/replay_checks.py new file mode 100644 index 000000000..b0d31e82d --- /dev/null +++ b/models/main_models/rt1/gen/scripts/replay_checks.py @@ -0,0 +1,217 @@ +import os +import sys +# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) +# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) +sys.path.append(os.path.join('/home/jiasenl/code/alfred')) +sys.path.append(os.path.join('/home/jiasenl/code/alfred', 'gen')) + +import argparse +import json +import numpy as np +import shutil +import time +from env.thor_env import ThorEnv +from utils.replay_json import replay_json +import multiprocessing as mp +import time + + +JSON_FILENAME = "traj_data.json" + + +def parallel_replay_check(args): + procs = [mp.Process(target=replay_check, args=(args, thread_num)) for thread_num in range(args.num_threads)] + try: + for proc in procs: + proc.start() + time.sleep(0.1) + finally: + for proc in procs: + proc.join() + +def replay_check(args, thread_num=0): + env = ThorEnv(x_display='0.%d' %(thread_num % args.total_gpu)) + + # replay certificate filenames + replay_certificate_filenames = ["replay.certificate.%d" % idx for idx in range(args.num_replays)] + + # Clear existing failures in file recording. + if args.failure_filename is not None: + with open(args.failure_filename, 'w') as f: + f.write('') + + continue_check = True + total_checks, total_failures, crash_fails, unsat_fails, json_fails, nondet_fails = 0, 0, 0, 0, 0, 0 + errors = {} # map from error strings to counts, to be shown after every failure. + total_threads = args.total_gpu * args.num_threads + current_threads = args.gpu_id * args.num_threads + thread_num + + while continue_check: + + # Crawl the directory of trajectories and vet ones with no certificate. + failure_list = [] + valid_dirs = [] + count = 0 + for dir_name, subdir_list, file_list in os.walk(args.data_path): + if "trial_" in dir_name and (not "raw_images" in dir_name) and (not "pddl_states" in dir_name): + json_file = os.path.join(dir_name, JSON_FILENAME) + if not os.path.isfile(json_file): + continue + + # If we're just stripping certificates, do that and continue. + if args.remove_certificates: + for cidx in range(args.num_replays): + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + if os.path.isfile(certificate_file): + os.system("rm %s" % certificate_file) + continue + + if count % total_threads == current_threads: + valid_dirs.append(dir_name) + count += 1 + + print(len(valid_dirs)) + np.random.shuffle(valid_dirs) + for ii, dir_name in enumerate(valid_dirs): + + if not os.path.exists(dir_name): + continue + + json_file = os.path.join(dir_name, JSON_FILENAME) + if not os.path.isfile(json_file): + continue + + cidx = 0 + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + already_checked = False + while os.path.isfile(certificate_file): + cidx += 1 + if cidx == args.num_replays: + already_checked = True + break + certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) + if already_checked: + continue + + print(ii) + if not os.path.isfile(certificate_file): + total_checks += 1. / args.num_replays + failed = False + + with open(json_file) as f: + print("check %d/%d for file '%s'" % (cidx + 1, args.num_replays, json_file)) + try: + traj_data = json.load(f) + env.set_task(traj_data, args, reward_type='dense') + except json.decoder.JSONDecodeError: + failed = True + json_fails += 1 + + if not failed: + steps_taken = None + try: + steps_taken = replay_json(env, json_file) + except Exception as e: + import traceback + traceback.print_exc() + failed = True + crash_fails += 1 + + if str(e) not in errors: + errors[str(e)] = 0 + errors[str(e)] += 1 + print("%%%%%%%%%%") + es = sum([errors[er] for er in errors]) + print("\terrors (%d):" % es) + for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): + # if v / es < 0.01: # stop showing below 1% of errors. + # break + print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) + print("%%%%%%%%%%") + + if cidx > 1: + print("WARNING: replay that has succeeded before has failed at attempt %d" + % cidx) + nondet_fails += 1 + + if steps_taken is not None: # executed without crashing, so now we need to verify completion. + goal_satisfied = env.get_goal_satisfied() + + if goal_satisfied: + with open(certificate_file, 'w') as f: + f.write('%d' % steps_taken) + else: + failed = True + unsat_fails += 1 + print("Goal was not satisfied after execution!") + + if failed: + # Mark one failure and count the remainder of checks for this instance into the total. + total_failures += 1 + total_checks += args.num_replays - ((cidx + 1) / float(args.num_replays)) + + failure_list.append(json_file) + if args.failure_filename is not None: + with open(args.failure_filename, 'a') as f: + f.write("%s\n" % json_file) + # If we're deleting bad trajectories, do that here. + if args.move_failed_trajectories is not None: + print("Relocating failed trajectory '%s' to '%s'" % + (dir_name, os.path.join(args.move_failed_trajectories))) + try: + shutil.move(dir_name, args.move_failed_trajectories) + except shutil.Error as e: + print("WARNING: failed to perform move; error follows; deleting instead") + print(repr(e)) + shutil.rmtree(dir_name) + if args.remove_failed_trajectories: + print("Removing failed trajectory '%s'" % dir_name) + shutil.rmtree(dir_name) + + print("-------------------------") + print("Success Rate: %.2f/%.2f = %.3f" % + (total_checks - total_failures, total_checks, + float(total_checks - total_failures) / float(total_checks))) + if total_failures > 0: + print("Non-deterministic failure: %d/%d = %.3f" % (nondet_fails, total_failures, + float(nondet_fails) / total_failures)) + print("Failures by crash: %d/%d = %.3f" % (crash_fails, total_failures, + float(crash_fails) / total_failures)) + print("Failures by unsatisfied: %d/%d = %.3f" % (unsat_fails, total_failures, + float(unsat_fails) / total_failures)) + print("Failures by json decode error: %d/%d = %.3f" % (json_fails, total_failures, + float(json_fails) / total_failures)) + print("-------------------------") + + if not args.in_parallel: + continue_check = False + else: + time.sleep(60) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument('--data_path', type=str, default="dataset/2.1.0", + help="where to look for the generated data") + parser.add_argument("--failure_filename", type=str, required=False, + help="where to write failed trajectory dirs as strings, if anywhere") + parser.add_argument("--remove_failed_trajectories", dest='remove_failed_trajectories', action='store_true', + help="delete trajectory trials if they fail replay") + parser.add_argument("--move_failed_trajectories", type=str, required=False, + help="if given, relocate failed trajectories to this directory") + parser.add_argument("--remove_certificates", dest='remove_certificates', action='store_true', + help="instead of vetting trajectories, remove all vetting certificates") + parser.add_argument("--in_parallel", dest='in_parallel', action='store_true', + help="whether to run this script with parallel generation scripts in mind") + parser.add_argument('--reward_config', default='../models/config/rewards.json') + parser.add_argument('--num_replays', type=int, default=1) + parser.add_argument('--gpu_id', type=int, default=0) + parser.add_argument('--total_gpu', type=int, default=2) + parser.add_argument('--num_threads', type=int, default=2) + args = parser.parse_args() + + if args.num_threads > 1: + parallel_replay_check(args) + else: + replay_check(args) + diff --git a/models/main_models/rt1/gen/utils/__init__.py b/models/main_models/rt1/gen/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/gen/utils/bb_util.py b/models/main_models/rt1/gen/utils/bb_util.py new file mode 100644 index 000000000..46b574b69 --- /dev/null +++ b/models/main_models/rt1/gen/utils/bb_util.py @@ -0,0 +1,139 @@ +import numbers +import numpy as np + +LIMIT = 99999999 + +def clip_bbox(bboxes, min_clip, max_x_clip, max_y_clip): + ''' + # BBoxes are [x1, y1, x2, y2] + ''' + bboxes_out = bboxes + added_axis = False + if len(bboxes_out.shape) == 1: + added_axis = True + bboxes_out = bboxes_out[:, np.newaxis] + bboxes_out[[0, 2], ...] = np.clip(bboxes_out[[0, 2], ...], min_clip, max_x_clip) + bboxes_out[[1, 3], ...] = np.clip(bboxes_out[[1, 3], ...], min_clip, max_y_clip) + if added_axis: + bboxes_out = bboxes_out[:, 0] + return bboxes_out + + +def xyxy_to_xywh(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): + ''' + [x1 y1, x2, y2] to [xMid, yMid, width, height] + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + bboxes_out = np.zeros(bboxes.shape) + x1 = bboxes[0, ...] + y1 = bboxes[1, ...] + x2 = bboxes[2, ...] + y2 = bboxes[3, ...] + bboxes_out[0, ...] = (x1 + x2) / 2.0 + bboxes_out[1, ...] = (y1 + y2) / 2.0 + bboxes_out[2, ...] = x2 - x1 + bboxes_out[3, ...] = y2 - y1 + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if bboxes_out.shape[0] > 4: + bboxes_out[4:, ...] = bboxes[4:, ...] + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def xywh_to_xyxy(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): + ''' + [xMid, yMid, width, height] to [x1 y1, x2, y2] + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + bboxes_out = np.zeros(bboxes.shape) + x_mid = bboxes[0, ...] + y_mid = bboxes[1, ...] + width = bboxes[2, ...] + height = bboxes[3, ...] + bboxes_out[0, ...] = x_mid - width / 2.0 + bboxes_out[1, ...] = y_mid - height / 2.0 + bboxes_out[2, ...] = x_mid + width / 2.0 + bboxes_out[3, ...] = y_mid + height / 2.0 + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if bboxes_out.shape[0] > 4: + bboxes_out[4:, ...] = bboxes[4:, ...] + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def scale_bbox(bboxes, scalars, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False, in_place=False): + ''' + @bboxes {np.array} 4xn array of boxes to be scaled + @scalars{number or arraylike} scalars for width and height of boxes + @in_place{bool} If false, creates new bboxes. + ''' + added_axis = False + if isinstance(bboxes, list): + bboxes = np.array(bboxes, dtype=np.float32) + if len(bboxes.shape) == 1: + added_axis = True + bboxes = bboxes[:, np.newaxis] + if isinstance(scalars, numbers.Number): + scalars = np.full((2, bboxes.shape[1]), scalars, dtype=np.float32) + if not isinstance(scalars, np.ndarray): + scalars = np.array(scalars, dtype=np.float32) + if len(scalars.shape) == 1: + scalars = np.tile(scalars[:, np.newaxis], (1, bboxes.shape[1])) + + width = bboxes[2, ...] - bboxes[0, ...] + height = bboxes[3, ...] - bboxes[1, ...] + x_mid = (bboxes[0, ...] + bboxes[2, ...]) / 2.0 + y_mid = (bboxes[1, ...] + bboxes[3, ...]) / 2.0 + if not in_place: + bboxes_out = bboxes.copy() + else: + bboxes_out = bboxes + + bboxes_out[0, ...] = x_mid - width * scalars[0, ...] / 2.0 + bboxes_out[1, ...] = y_mid - height * scalars[1, ...] / 2.0 + bboxes_out[2, ...] = x_mid + width * scalars[0, ...] / 2.0 + bboxes_out[3, ...] = y_mid + height * scalars[1, ...] / 2.0 + + if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: + bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) + if added_axis: + bboxes_out = bboxes_out[:, 0] + if round: + bboxes_out = np.round(bboxes_out).astype(int) + return bboxes_out + + +def make_square(bboxes, in_place=False): + if isinstance(bboxes, list): + bboxes = np.array(bboxes).astype(np.float32) + if len(bboxes.shape) == 1: + num_boxes = 1 + width = bboxes[2] - bboxes[0] + height = bboxes[3] - bboxes[1] + else: + num_boxes = bboxes.shape[1] + width = bboxes[2, ...] - bboxes[0, ...] + height = bboxes[3, ...] - bboxes[1, ...] + max_size = np.maximum(width, height) + scalars = np.zeros((2, num_boxes)) + scalars[0, ...] = max_size * 1.0 / width + scalars[1, ...] = max_size * 1.0 / height + return scale_bbox(bboxes, scalars, in_place=in_place) diff --git a/models/main_models/rt1/gen/utils/dataset_management_util.py b/models/main_models/rt1/gen/utils/dataset_management_util.py new file mode 100644 index 000000000..de13fa535 --- /dev/null +++ b/models/main_models/rt1/gen/utils/dataset_management_util.py @@ -0,0 +1,69 @@ +import os +import shutil + + +def load_successes_from_disk(succ_dir, succ_traj, prune_trials, target_count, + cap_count=None, min_count=None): + tuple_counts = {} + for root, dirs, files in os.walk(succ_dir): + for d in dirs: + if d.count('-') == 4: + goal, pickup, movable, receptacle, scene_num = d.split('-') + # Add an entry for every successful trial folder in the directory. + queue_for_delete = [] + deleted_all = True + for _, _dirs, _ in os.walk(os.path.join(succ_dir, d)): + for _d in _dirs: + for _, _, _files in os.walk(os.path.join(succ_dir, d, _d)): + if 'video.mp4' in _files: + k = (goal, pickup, movable, receptacle, scene_num) + if k not in tuple_counts: + tuple_counts[k] = 0 + tuple_counts[k] += 1 + deleted_all = False + else: + queue_for_delete.append(_d) + break # only examine top level + break # only examine top level + if prune_trials: + if deleted_all: + print("Removing trial-less parent dir '%s'" % os.path.join(succ_dir, d)) + shutil.rmtree(os.path.join(succ_dir, d)) + else: + for _d in queue_for_delete: + print("Removing unfinished trial '%s'" % os.path.join(succ_dir, d, _d)) + shutil.rmtree(os.path.join(succ_dir, d, _d)) + break # only examine top level + + # Populate dataframe based on tuple constraints. + for k in tuple_counts: + if min_count is None or tuple_counts[k] >= min_count: + to_add = tuple_counts[k] if cap_count is None else cap_count + for _ in range(to_add): + succ_traj = succ_traj.append({ + "goal": k[0], + "pickup": k[1], + "movable": k[2], + "receptacle": k[3], + "scene": k[4]}, ignore_index=True) + tuples_at_target_count = set([t for t in tuple_counts if tuple_counts[t] >= target_count]) + + return succ_traj, tuples_at_target_count + + +def load_fails_from_disk(succ_dir, to_write=None): + fail_traj = set() + fail_dir = os.path.join(succ_dir, "fails") + if not os.path.isdir(fail_dir): + os.makedirs(fail_dir) + if to_write is not None: + for goal, pickup, movable, receptacle, scene_num in to_write: + with open(os.path.join(fail_dir, '-'.join([goal, pickup, movable, receptacle, scene_num])), 'w') as f: + f.write("0") + for root, dirs, files in os.walk(fail_dir): + for fn in files: + if fn.count('-') == 4: + goal, pickup, movable, receptacle, scene_num = fn.split('-') + fail_traj.add((goal, pickup, movable, receptacle, scene_num)) + break # only examine top level + return fail_traj diff --git a/models/main_models/rt1/gen/utils/game_util.py b/models/main_models/rt1/gen/utils/game_util.py new file mode 100644 index 000000000..476ef5122 --- /dev/null +++ b/models/main_models/rt1/gen/utils/game_util.py @@ -0,0 +1,363 @@ +import copy +import random +import cv2 +import numpy as np +import constants +import goal_library as glib + + +def get_pose(event): + pose = event.pose + return (int(np.round(pose[0] / (1000 * constants.AGENT_STEP_SIZE))), + int(np.round(pose[1] / (1000 * constants.AGENT_STEP_SIZE))), + int(np.round(pose[2] / (1000 * 90))), + int(np.round(pose[3] / (1000)))) + + +def get_object_data(metadata): + return [ + {"objectName": obj["name"].split("(Clone)")[0], "position": obj["position"], "rotation": obj["rotation"]} + for obj in metadata["objects"] + if obj["pickupable"] + ] + + +def imresize(image, size, rescale=True): + if image is None: + return None + if image.shape[0] != size[0] or image.shape[1] != size[1]: + image = cv2.resize(image, size) + if rescale: + if image.dtype != np.float32: + image = image.astype(np.float32) + image /= 255.0 + return image + + +def depth_imresize(image, size, rescale=True, max_depth=constants.MAX_DEPTH): + if image is None: + return None + if image.shape[0] != size[0] or image.shape[1] != size[1]: + image = cv2.resize(image, size) + image[image > max_depth] = max_depth + if rescale: + if image.dtype != np.float32: + image = image.astype(np.float32) + image /= max_depth + return image + + +def get_camera_matrix(pose, camera_height): + assert(pose[2] in {0, 1, 2, 3}) + sin_x = np.sin(pose[3] * np.pi / 180) + cos_x = np.cos(pose[3] * np.pi / 180) + x_rotation = np.matrix([ + [1, 0, 0], + [0, cos_x, -sin_x], + [0, sin_x, cos_x]]) + sin_y = np.sin(pose[2] * np.pi / 180) + cos_y = np.cos(pose[2] * np.pi / 180) + y_rotation = np.matrix([ + [cos_y, 0, sin_y], + [0, 1, 0], + [-sin_y, 0, cos_y]]) + rotation_matrix = np.matmul(x_rotation, y_rotation) + transformation_matrix = np.matrix([pose[0], camera_height, pose[1], 1]).T + extrinsic_matrix = np.concatenate((np.concatenate((rotation_matrix, np.matrix([0, 0, 0])), axis=0), + transformation_matrix), axis=1) + return extrinsic_matrix + + +def get_rotation_matrix(pose): + assert(pose[2] in {0, 1, 2, 3}), 'rotation was %s' % str(pose[2]) + sin_x = np.sin(-pose[3] * np.pi / 180) + cos_x = np.cos(-pose[3] * np.pi / 180) + x_rotation = np.matrix([ + [1, 0, 0], + [0, cos_x, -sin_x], + [0, sin_x, cos_x]], dtype=np.float32) + sin_y = np.sin((-pose[2] % 4) * 90 * np.pi / 180) + cos_y = np.cos((-pose[2] % 4) * 90 * np.pi / 180) + y_rotation = np.matrix([ + [cos_y, 0, sin_y], + [0, 1, 0], + [-sin_y, 0, cos_y]], dtype=np.float32) + rotation_matrix = np.matmul(x_rotation, y_rotation) + return rotation_matrix + + +def depth_to_world_coordinates(depth, pose, camera_height): + x_points = np.arange(-constants.SCREEN_WIDTH / 2, constants.SCREEN_WIDTH / 2, dtype=depth.dtype) + x_vals = (depth * x_points / constants.FOCAL_LENGTH) + + y_points = np.arange(constants.SCREEN_HEIGHT / 2, -constants.SCREEN_HEIGHT / 2, -1, dtype=depth.dtype) + y_vals = (depth.T * y_points / constants.FOCAL_LENGTH).T + + z_vals = depth + xyz = np.stack((x_vals, y_vals, z_vals), axis=2) / (1000 * constants.AGENT_STEP_SIZE) + rotation_matrix = np.linalg.inv(get_rotation_matrix(pose)) + xyz = np.array(np.dot(rotation_matrix, xyz.reshape(-1, 3).T).T).reshape( + constants.SCREEN_HEIGHT, constants.SCREEN_WIDTH, 3) + xzy = xyz[:, :, [0, 2, 1]] + xzy += np.array([pose[0], pose[1], camera_height]) + return xzy + + +# coordinates should be [n, (xzy)] +def world_to_camera_coordinates(coordinates, pose, camera_height): + coordinates = coordinates.copy() + coordinates -= np.array([pose[0], pose[1], camera_height]) + xyz = coordinates[:, [0, 2, 1]] # [n, (xyz)] + rotation_matrix = get_rotation_matrix(pose) + xyd = np.array(np.dot(rotation_matrix, xyz.T).T) + xyd *= (1000 * constants.AGENT_STEP_SIZE) + depth = np.maximum(xyd[:, -1], 0.01) + x_points = xyd[:, 0] * constants.FOCAL_LENGTH / depth + constants.SCREEN_WIDTH / 2 + y_points = constants.SCREEN_HEIGHT - (xyd[:, 1] * constants.FOCAL_LENGTH / depth + constants.SCREEN_HEIGHT / 2) + return np.stack((x_points, y_points, depth)).T + + +def get_templated_action_str(plan, idx=0): + action = copy.deepcopy(plan[idx]) + object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) + + a_type = action['action'] + templated_str = "" + + if 'GotoLocation' in a_type: + templated_str = "go to the %s" % (next_recep_name if next_recep_name != "" else prev_object_name) + elif 'OpenObject' in a_type: + templated_str = "open the %s" % (object_name) + elif 'CloseObject' in a_type: + templated_str = "close the %s" % (object_name) + elif 'PickupObject' in a_type: + templated_str = "pick up the %s" % (object_name) + elif 'PutObject' in a_type: + templated_str = "put the %s in the %s" % (object_name, recep_name) + elif 'CleanObject' in a_type: + templated_str = "wash the %s" % (prev_object_name) + elif 'HeatObject' in a_type: + templated_str = "heat the %s" % (prev_object_name) + elif 'CoolObject' in a_type: + templated_str = "cool the %s" % (prev_object_name) + elif 'ToggleObject' in a_type: + templated_str = "toggle %s" % (object_name) + elif 'SliceObject' in a_type: + templated_str = "slice the %s" % (object_name) + elif 'End' in a_type: + templated_str = "<>" + + return templated_str + + +def get_discrete_hl_action(plan, idx=0): + action = copy.deepcopy(plan[idx]) + object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) + + a_type = action['action'] + discrete_action = {'action': "", 'args': []} + + if 'GotoLocation' in a_type: + discrete_action['action'] = "GotoLocation" + discrete_action['args'] = [next_recep_name if next_recep_name != "" else next_object_name] + elif 'OpenObject' in a_type: + discrete_action['action'] = "OpenObject" + discrete_action['args'] = [object_name] + elif 'CloseObject' in a_type: + discrete_action['action'] = "CloseObject" + discrete_action['args'] = [object_name] + elif 'PickupObject' in a_type: + discrete_action['action'] = "PickupObject" + discrete_action['args'] = [object_name] + elif 'PutObject' in a_type: + discrete_action['action'] = "PutObject" + discrete_action['args'] = [object_name, recep_name] + elif 'CleanObject' in a_type: + discrete_action['action'] = "CleanObject" + discrete_action['args'] = [prev_object_name] + elif 'HeatObject' in a_type: + discrete_action['action'] = "HeatObject" + discrete_action['args'] = [prev_object_name] + elif 'CoolObject' in a_type: + discrete_action['action'] = "CoolObject" + discrete_action['args'] = [prev_object_name] + elif 'ToggleObject' in a_type: + discrete_action['action'] = "ToggleObject" + discrete_action['args'] = [object_name] + elif 'SliceObject' in a_type: + discrete_action['action'] = "SliceObject" + discrete_action['args'] = [object_name] + else: + discrete_action['action'] = "NoOp" + discrete_action['args'] = [] + + return discrete_action + + +def object_id_to_name(object_id): + return object_id.split('|')[0] + + +def get_relevant_objs(action, plan, idx=0): + object_name = object_id_to_name(action['objectId']).lower() if 'objectId' in action else "" + recep_name = object_id_to_name(action['receptacleObjectId']).lower() if 'receptacleObjectId' in action else "" + prev_object_name, prev_recep_name = "", "" + next_object_name, next_recep_name = "", "" + + prev_idx = idx - 2 + if prev_idx >= 0: + prev_action = copy.deepcopy(plan[prev_idx]) + prev_object_name = object_id_to_name(prev_action['objectId']).lower() if 'objectId' in prev_action else "" + prev_recep_name = object_id_to_name(prev_action['receptacleObjectId']).lower() if 'receptacleObjectId' in prev_action else "" + + next_idx = idx + 1 + if next_idx < len(plan): + next_action = copy.deepcopy(plan[next_idx]) + next_object_name = object_id_to_name(next_action['objectId']).lower() if 'objectId' in next_action else "" + next_recep_name = object_id_to_name(next_action['receptacleObjectId']).lower() if 'receptacleObjectId' in next_action else "" + + return object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name + + +def get_action_str(action): + action = copy.deepcopy(action) + a_type = action['action'] + action_str = 'Action: ' + a_type + del action['action'] + + if 'Teleport' in a_type: + action_str = a_type + if 'x' in action: + action_str += ' x: %.03f' % action['x'] + del action['x'] + if 'y' in action: + action_str += ' y: %.03f' % action['y'] + del action['y'] + if 'z' in action: + action_str += ' z: %.03f' % action['z'] + del action['z'] + if 'rotation' in action and action.get('rotateOnTeleport', False): + if type(action['rotation']) == dict: + action_str += ' r: %d' % int(action['rotation']['y']) + else: + action_str += ' r: %d' % int(action['rotation']) + del action['rotation'] + del action['rotateOnTeleport'] + if 'horizon' in action: + action_str += ' h: %d' % int(action['horizon']) + del action['horizon'] + elif 'Goto' in a_type: + action_str = a_type + if 'location' in action: + action_str += ' loc: %s' % action['location'] + del action['location'] + elif a_type in {'OpenObject', 'CloseObject', 'PickupObject', 'ToggleObject', 'SliceObject'}: + if 'objectId' not in action: + action['objectId'] = 'None' + action_str = '%s %s' % (a_type, action['objectId']) + elif a_type in {'RotateByDegree', 'LookByDegree'}: + if type(action['rotation']) == dict: + action_str += ' r: %d' % int(action['rotation']['y']) + else: + action_str += ' r: %d' % int(action['rotation']) + action_str = '%s %d' % (a_type, action['rotation']['y']) + del action['rotation'] + elif a_type == 'PutObject': + action_str = a_type + if 'objectId' in action: + action_str += ' o: %s' % action['objectId'] + del action['objectId'] + if 'receptacleObjectId' in action: + action_str += ' r: %s' % action['receptacleObjectId'] + del action['receptacleObjectId'] + + if len(action) > 0: + action_str += '\tFull: ' + str(action) + return action_str + + +def get_object(object_id, metadata): + for obj in metadata['objects']: + if obj['objectId'] == object_id: + return obj + return None + + +def get_object_dict(metadata): + return {obj['objectId']: obj for obj in metadata['objects']} + + +def get_objects_of_type(object_type, metadata): + return [obj for obj in metadata['objects'] if obj['objectType'] == object_type] + + +def get_obj_of_type_closest_to_obj(object_type, ref_object_id, metadata): + objs_of_type = [obj for obj in metadata['objects'] if obj['objectType'] == object_type and obj['visible']] + ref_obj = get_object(ref_object_id, metadata) + closest_objs_of_type = sorted(objs_of_type, key=lambda o: np.linalg.norm(np.array([o['position']['x'], o['position']['y'], o['position']['z']]) - \ + np.array([ref_obj['position']['x'], ref_obj['position']['y'], ref_obj['position']['z']]))) + if len(closest_objs_of_type) == 0: + raise Exception("No closest %s found!" % (ref_obj)) + return closest_objs_of_type[0] # retrun the first closest visible object + + +def get_objects_with_name_and_prop(name, prop, metadata): + return [obj for obj in metadata['objects'] + if name in obj['objectId'] and obj[prop]] + + +def get_visible_objs(objs): + return [obj for obj in objs if obj['visible']] + + +def get_object_bounds(obj, scene_bounds): + # obj_bounds = np.array(obj['bounds3D'])[[0, 2, 3, 5]] # Get X and Z out + # Get a 'box' that is a singular point in (x,z) based on object position in place of now-unavailable 'bounds3d' + obj_bounds = np.array([obj['position']['x'], obj['position']['z'], obj['position']['x'], obj['position']['z']]) + obj_bounds /= constants.AGENT_STEP_SIZE + obj_bounds = np.round(obj_bounds).astype(np.int32) + obj_bounds[[2, 3]] = np.maximum(obj_bounds[[2, 3]], obj_bounds[[0, 1]] + 1) + obj_bounds[[0, 2]] = np.clip(obj_bounds[[0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) + obj_bounds[[1, 3]] = np.clip(obj_bounds[[1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) + obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] + return obj_bounds + + +def get_object_bounds_batch(boxes, scene_bounds): + obj_bounds = boxes[:, [0, 2, 3, 5]] # Get X and Z out + obj_bounds /= constants.AGENT_STEP_SIZE + obj_bounds = np.round(obj_bounds).astype(np.int32) + obj_bounds[:, [2, 3]] = np.maximum(obj_bounds[:, [2, 3]], obj_bounds[:, [0, 1]] + 1) + obj_bounds[:, [0, 2]] = np.clip(obj_bounds[:, [0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) + obj_bounds[:, [1, 3]] = np.clip(obj_bounds[:, [1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) + obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] + return obj_bounds + + +def get_task_str(object_ind, receptacle_ind=None, toggle_ind=None, mrecep_ind=None): + goal_str = constants.pddl_goal_type + if constants.data_dict['pddl_params']['object_sliced']: + goal_str += "_slice" + template = random.choice(glib.gdict[goal_str]['templates']) + obj = constants.OBJECTS[object_ind].lower() if object_ind is not None else "" + recep = constants.OBJECTS[receptacle_ind].lower() if receptacle_ind is not None else "" + tog = constants.OBJECTS[toggle_ind].lower() if toggle_ind is not None else "" + mrecep = constants.OBJECTS[mrecep_ind].lower() if mrecep_ind is not None else "" + filled_in_str = template.format(obj=obj, recep=recep, toggle=tog, mrecep=mrecep) + return filled_in_str + + +def get_last_hl_action_index(): + return len(constants.data_dict['plan']['high_pddl']) - 1 + + +def get_last_ll_action_index(): + return len(constants.data_dict['plan']['low_actions']) - 1 + + +def store_image_name(name): + constants.data_dict['images'].append({"high_idx": get_last_hl_action_index(), + "low_idx": get_last_ll_action_index(), + "image_name": name}) + + diff --git a/models/main_models/rt1/gen/utils/image_util.py b/models/main_models/rt1/gen/utils/image_util.py new file mode 100644 index 000000000..157812a2f --- /dev/null +++ b/models/main_models/rt1/gen/utils/image_util.py @@ -0,0 +1,57 @@ +import numpy as np +import gen.constants as constants + +def bbox_to_mask(bbox): + ''' + bbox to rectangle pixelwise mask + ''' + x1, y1, x2, y2 = bbox + mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) + mask[y1:y2, x1:x2] = 1 + return mask + + +def point_to_mask(point): + ''' + single point to dense pixelwise mask + ''' + x, y = point + mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) + mask[y, x] = 1 + return mask + + +def decompress_mask(compressed_mask): + ''' + decompress compressed mask array + ''' + mask = np.zeros((constants.DETECTION_SCREEN_WIDTH, constants.DETECTION_SCREEN_HEIGHT)) + for start_idx, run_len in compressed_mask: + for idx in range(start_idx, start_idx + run_len): + mask[idx // constants.DETECTION_SCREEN_WIDTH, idx % constants.DETECTION_SCREEN_HEIGHT] = 1 + return mask + + +def compress_mask(seg_mask): + ''' + compress mask array + ''' + run_len_compressed = [] # list of lists of run lengths for 1s, which are assumed to be less frequent. + idx = 0 + curr_run = False + run_len = 0 + for x_idx in range(len(seg_mask)): + for y_idx in range(len(seg_mask[x_idx])): + if seg_mask[x_idx][y_idx] == 1 and not curr_run: + curr_run = True + run_len_compressed.append([idx, None]) + if seg_mask[x_idx][y_idx] == 0 and curr_run: + curr_run = False + run_len_compressed[-1][1] = run_len + run_len = 0 + if curr_run: + run_len += 1 + idx += 1 + if curr_run: + run_len_compressed[-1][1] = run_len + return run_len_compressed \ No newline at end of file diff --git a/models/main_models/rt1/gen/utils/py_util.py b/models/main_models/rt1/gen/utils/py_util.py new file mode 100644 index 000000000..7a357f039 --- /dev/null +++ b/models/main_models/rt1/gen/utils/py_util.py @@ -0,0 +1,84 @@ +import random +import re +import time +import os +import string + + +def get_time_str(): + tt = time.localtime() + time_str = ('%04d_%02d_%02d_%02d_%02d_%02d' % + (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec)) + return time_str + + +def encode(string, encoding='utf-8'): + return string.encode(encoding) + + +def decode(string, encoding='utf-8'): + return string.decode(encoding) + + +def multireplace(string, replacements): + """ + Given a string and a replacement map, it returns the replaced string. + :param str string: string to execute replacements on + :param dict replacements: replacement dictionary {value to find: value to replace} + :rtype: str + Source https://gist.github.com/bgusach/a967e0587d6e01e889fd1d776c5f3729 + """ + # Place longer ones first to keep shorter substrings from matching where the longer ones should take place + # For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against the string 'hey abc', it should produce + # 'hey ABC' and not 'hey ABc' + substrs = sorted(replacements, key=len, reverse=True) + + # Create a big OR regex that matches any of the substrings to replace + regexp = re.compile('|'.join(map(re.escape, substrs))) + + # For each match, look up the new string in the replacements + return regexp.sub(lambda match: replacements[match.group(0)], string) + + +class SetWithGet(set): + def get_any(self): + return random.sample(self, 1)[0] + + def __getitem__(self, item): + return self.get_any() + + +class Noop(object): + def noop(*args, **kw): + pass + + def __getattr__(self, _): + return self.noop + + +def walklevel(some_dir, level=1): + some_dir = some_dir.rstrip(os.path.sep) + assert os.path.isdir(some_dir) + num_sep = some_dir.count(os.path.sep) + for root, dirs, files in os.walk(some_dir): + yield root, dirs, files + num_sep_this = root.count(os.path.sep) + if num_sep + level <= num_sep_this: + del dirs[:] + + +def remove_spaces(s): + cs = ' '.join(s.split()) + return cs + + +def remove_spaces_and_lower(s): + cs = remove_spaces(s) + cs = cs.lower() + return cs + + +def remove_punctuation(s): + cs = s.translate(str.maketrans('', '', string.punctuation)) + cs = remove_spaces_and_lower(cs) + return cs \ No newline at end of file diff --git a/models/main_models/rt1/gen/utils/replay_json.py b/models/main_models/rt1/gen/utils/replay_json.py new file mode 100644 index 000000000..96949414c --- /dev/null +++ b/models/main_models/rt1/gen/utils/replay_json.py @@ -0,0 +1,52 @@ +import json + +def replay_json(env, json_file): + # load json data + with open(json_file) as f: + traj_data = json.load(f) + + # setup + scene_num = traj_data['scene']['scene_num'] + object_poses = traj_data['scene']['object_poses'] + dirty_and_empty = traj_data['scene']['dirty_and_empty'] + object_toggles = traj_data['scene']['object_toggles'] + + scene_name = 'FloorPlan%d' % scene_num + env.reset(scene_name) + env.restore_scene(object_poses, object_toggles, dirty_and_empty) + + # initialize + event = env.step(dict(traj_data['scene']['init_action'])) + # print("Task: %s" % (traj_data['template']['task_desc'])) + + steps_taken = 0 + for ll_action in traj_data['plan']['low_actions']: + hl_action_idx, traj_api_cmd, traj_discrete_action = \ + ll_action['high_idx'], ll_action['api_action'], ll_action['discrete_action'] + + # print templated low-level instructions & discrete action + # print("HL Templ: %s, LL Cmd: %s" % (traj_data['template']['high_descs'][hl_action_idx], + # traj_discrete_action['action'])) + + # Use the va_interact that modelers will have to use at inference time. + action_name, action_args = traj_discrete_action['action'], traj_discrete_action['args'] + + # three ways to specify object of interest mask + # 1. create a rectangular mask from bbox + # mask = env.bbox_to_mask(action_args['bbox']) if 'bbox' in action_args else None # some commands don't require any arguments + # 2. create a point mask from bbox + # mask = env.point_to_mask(action_args['point']) if 'point' in action_args else None + # 3. use full pixel-wise segmentation mask + compressed_mask = action_args['mask'] if 'mask' in action_args else None + if compressed_mask is not None: + mask = env.decompress_mask(compressed_mask) + else: + mask = None + + success, event, target_instance_id, err, _ = env.va_interact(action_name, interact_mask=mask) + if not success: + raise RuntimeError(err) + + steps_taken += 1 + + return steps_taken diff --git a/models/main_models/rt1/gen/utils/video_util.py b/models/main_models/rt1/gen/utils/video_util.py new file mode 100644 index 000000000..4c21b8a3a --- /dev/null +++ b/models/main_models/rt1/gen/utils/video_util.py @@ -0,0 +1,11 @@ +import subprocess +import constants + +class VideoSaver(object): + + def __init__(self, frame_rate=constants.VIDEO_FRAME_RATE): + self.frame_rate = frame_rate + + def save(self, image_path, save_path): + subprocess.call(["ffmpeg -r %d -pattern_type glob -y -i '%s' -c:v libx264 -pix_fmt yuv420p '%s'" % + (self.frame_rate, image_path, save_path)], shell=True) \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/attribute_limits.json b/models/main_models/rt1/lanmp_dataloader/attribute_limits.json new file mode 100644 index 000000000..0fdbbed9a --- /dev/null +++ b/models/main_models/rt1/lanmp_dataloader/attribute_limits.json @@ -0,0 +1 @@ +[{"min_x": -0.40000009536743164, "max_x": 0.40000009536743164, "min_y": 0, "max_y": 0, "min_z": -0.40000009536743164, "max_z": 0.40000009536743164}, {"min_yaw": -347.422251701355, "max_yaw": 358.85895166755654}, {"min_x": -1.146158218383789, "max_x": 0.6427476406097412, "min_y": -0.533308207988739, "max_y": 0.8237500190734863, "min_z": -0.5759885311126709, "max_z": 1.0145864486694336}] \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py b/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py new file mode 100644 index 000000000..7d574597a --- /dev/null +++ b/models/main_models/rt1/lanmp_dataloader/rt1_dataloader.py @@ -0,0 +1,800 @@ +import os +import sys + +import torch +from torchvision.io import read_image +from torch.utils.data import Dataset +from torch.utils.data import DataLoader +import h5py +from PIL import Image +from tqdm import tqdm +# from models.utils.data_utils import split_data +import pdb +#mainly for debugging +import matplotlib.pyplot as plt +import numpy as np +import re +import json +import sys +from copy import copy +import random + +sys.path.append('..') + +DATASET_PATH = '/oscar/data/stellex/shared/lanmp/sim_dataset.hdf5' + +''' +train_keys, val_keys, test_keys = split_data(self.args.data, splits['train'], splits['val'], splits['test']) +''' + +def split_data(hdf5_path, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1): + with h5py.File(hdf5_path, 'r') as hdf_file: + # Assuming trajectories or data units are top-level groups in the HDF5 file + keys = list(hdf_file.keys()) + total_items = len(keys) + + # Generate a shuffled array of indices + indices = np.arange(total_items) + np.random.shuffle(indices) + + # Calculate split sizes + train_end = int(train_ratio * total_items) + val_end = train_end + int(val_ratio * total_items) + + # Split the indices + train_indices = indices[:train_end] + val_indices = indices[train_end:val_end] + test_indices = indices[val_end:] + + # Convert indices back to keys (assuming order in keys list is stable and matches original order) + train_keys = [keys[i] for i in train_indices] + val_keys = [keys[i] for i in val_indices] + test_keys = [keys[i] for i in test_indices] + + return train_keys, val_keys, test_keys + +def split_by_scene(hdf5_path): + + #mapping which keys are relevant to specific scenes + scene_to_keys = {} + + with h5py.File(hdf5_path, 'r') as hdf_file: + + keys = list(hdf_file.keys()) + + for k in keys: + traj_json_dict = json.loads(hdf_file[k]['folder_0'].attrs['metadata']) + + if traj_json_dict['scene'] not in scene_to_keys: + scene_to_keys[traj_json_dict['scene']] = [] + + scene_to_keys[traj_json_dict['scene']].append(k) + + for k in scene_to_keys.keys(): + scene_to_keys[k] = list(sorted(scene_to_keys[k])) + + with open('./lanmp_dataloader/scene_to_keys.json', 'w') as f: + json.dump(scene_to_keys, f) + + return scene_to_keys + + + +def sort_folders(test_string): + return list(map(int, re.findall(r'\d+', test_string)))[0] + +class DatasetManager(object): + + ''' + NOTE: kwargs should contain a dictionary with keys {'train_split' : x, 'val_split': y, 'test_split':z} where x+y+z = 1 + ''' + def __init__(self, val_scene=1, train_split=0.8, val_split=0.1, test_split=0.1, split_style='task_split', diversity_scenes=1, max_trajectories=100): + + assert( train_split + val_split + test_split == 1.0, 'Error: train, val and test split do not sum to 1.0') + + + #train_keys, val_keys, test_keys = split_data(DATASET_PATH, train_split, val_split, test_split) + if 'scene_to_keys.json' not in os.listdir('./lanmp_dataloader'): + self.scene_to_keys = split_by_scene(DATASET_PATH) + else: + with open('./lanmp_dataloader/scene_to_keys.json') as f: + self.scene_to_keys = json.load(f) + + + self.scenes = list(sorted(list(self.scene_to_keys.keys()))) + + assert( split_style in ['k_fold_scene', 'task_split', 'diversity_ablation'], "Error: input split_style is invalid") + + if split_style == 'k_fold_scene': + assert( val_scene < len(self.scenes), "Error: input scene is out of index space") + train_keys = [] + for x in range(0, len(self.scenes)): + if x!=val_scene: + train_keys += self.scene_to_keys[self.scenes[x]] + + val_keys = self.scene_to_keys[self.scenes[val_scene]] + test_keys = None + + elif split_style == 'task_split': + + train_keys = [] + val_keys = [] + + for scene in self.scenes: + + scene_keys = copy(self.scene_to_keys[scene]) + random.shuffle(scene_keys) + + + split_idx = int(len(scene_keys)*(train_split + 0.5*val_split)) + + train_keys += scene_keys[:split_idx] + val_keys += scene_keys[split_idx:] + + print('Train Perc: ', len(train_keys) / (len(train_keys) + len(val_keys))) + + val_keys = ['data_13:02:17', 'data_19:58:40', 'data_15:50:55', 'data_16:22:44', 'data_15:40:22', 'data_17:08:14', 'data_15:37:13', 'data_18:38:30', 'data_13:56:07', 'data_15:22:59', 'data_13:33:54', 'data_13:18:11', 'data_19:36:17', 'data_14:38:16', 'data_13:04:13', 'data_12:04:43', 'data_16:37:57', 'data_15:38:38', 'data_16:40:44', 'data_17:59:00', 'data_20:57:07', 'data_16:03:52', 'data_16:40:36', 'data_19:31:51', 'data_16:45:24', 'data_21:09:57', 'data_17:26:17', 'data_15:01:27', 'data_14:02:16', 'data_13:29:09', 'data_14:22:29', 'data_16:43:00', 'data_13:46:04', 'data_15:13:04', 'data_16:45:58', 'data_13:33:29', 'data_17:17:50', 'data_11:19:28', 'data_17:45:27', 'data_16:00:55', 'data_15:03:19', 'data_16:06:05', 'data_16:02:46', 'data_17:41:00', 'data_17:35:45', 'data_14:05:06', 'data_18:22:47', 'data_17:02:46', 'data_15:08:23', 'data_16:15:15', 'data_19:00:23', 'data_11:50:57', 'data_15:19:33', 'data_14:52:27', 'data_16:58:53', 'data_11:44:50', 'data_16:10:21', 'data_13:10:05', 'data_17:48:24', 'data_18:09:10', 'data_18:01:35', 'data_13:34:59', 'data_12:48:23', 'data_22:17:48', 'data_16:57:05', 'data_16:49:20', 'data_17:51:34', 'data_12:54:21', 'data_16:23:48', 'data_14:24:32', 'data_16:18:35', 'data_14:26:22', 'data_16:11:06', 'data_11:58:17', 'data_17:13:00', 'data_19:34:02', 'data_13:29:42', 'data_17:20:01', 'data_15:20:09', 'data_16:53:34', 'data_15:25:56'] + + print('Train Keys: ', len(train_keys)) + print('Validation Keys: ', len(val_keys)) + print('Validation Keys: ', val_keys) + + elif split_style == 'diversity_ablation': + + assert(diversity_scenes < len(self.scene_to_keys.keys()), "Error: number of train scenes for diversity ablations cannot be {}".format(len(self.scene_to_keys.keys()))) + + ordered_scenes = []; ordered_trajs = [] + + for scene, traj in self.scene_to_keys.items(): + + ordered_scenes.append(scene) + ordered_trajs.append(len(traj)) + + + ordered_index = sorted(range(0, len(ordered_trajs)), key = lambda x: ordered_trajs[x]) + + ordered_trajs = list(sorted(ordered_trajs)) + ordered_scenes = [ordered_scenes[i] for i in ordered_index] + + print('EVAL SCENE: {} has {} trajectories'.format(ordered_scenes[-1], ordered_trajs[-1])) + val_keys = self.scene_to_keys[ordered_scenes[-1]] + other_scenes = list(reversed(ordered_scenes[:-1])) + other_trajs = list(reversed(ordered_trajs[:-1])) + + + num_per_scene = int(max_trajectories/diversity_scenes) + train_keys = [] + + for i in range(diversity_scenes): + train_keys += random.sample(self.scene_to_keys[other_scenes[i]], num_per_scene) + + if len(train_keys) < max_trajectories: + + random_scene = random.sample(other_scenes[:diversity_scenes], 1)[0] + train_keys += random.sample(self.scene_to_keys[random_scene], max_trajectories-len(train_keys)) + + + if 'attribute_limits.json' not in os.listdir('./lanmp_dataloader'): + body_pose_lim, body_orientation_lim, end_effector_pose_lim = self.determine_min_max_range([train_keys, val_keys, test_keys]) + else: + + with open('./lanmp_dataloader/attribute_limits.json') as f: + attribute_limits = json.load(f) + body_pose_lim, body_orientation_lim, end_effector_pose_lim = attribute_limits[0], attribute_limits[1], attribute_limits[2] + + self.train_dataset = RT1Dataset(train_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + self.val_dataset = RT1Dataset(val_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + # self.test_dataset = RT1Dataset(test_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) + + def determine_min_max_range(self, data_subset_keys): + + body_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z':float('-inf')} + body_orientation = {'min_yaw': float('inf'), 'max_yaw': float('-inf')} + end_effector_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z': float('-inf')} + + + + + with h5py.File(DATASET_PATH, 'r') as hdf: + for dataset_keys in data_subset_keys: + + if dataset_keys is None: + continue + + + for i in range(len(dataset_keys)): + prev_body_x = None + prev_body_y = None + prev_body_z = None + prev_body_yaw = None + prev_ee_x = None + prev_ee_y = None + prev_ee_z = None + + print('Index: {} of {}'.format(i, len(dataset_keys))) + traj_group = hdf[dataset_keys[i]] + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + for j in range(len(traj_steps)): + + step_metadata = json.loads(traj_group[traj_steps[j]].attrs['metadata']) + + body_x = step_metadata['steps'][0]['state_body'][0] + body_y = step_metadata['steps'][0]['state_body'][1] + body_z = step_metadata['steps'][0]['state_body'][2] + + body_yaw = step_metadata['steps'][0]['state_body'][3] + + + ee_x = step_metadata['steps'][0]['state_ee'][0] + ee_y = step_metadata['steps'][0]['state_ee'][1] + ee_z = step_metadata['steps'][0]['state_ee'][2] + + + + body_pose['min_x'] = min(body_pose['min_x'], body_x - prev_body_x if prev_body_x is not None else 0) + body_pose['max_x'] = max(body_pose['max_x'], body_x - prev_body_x if prev_body_x is not None else 0) + + body_pose['min_y'] = min(body_pose['min_y'], body_y - prev_body_y if prev_body_y is not None else 0) + body_pose['max_y'] = max(body_pose['max_y'], body_y - prev_body_y if prev_body_y is not None else 0) + + body_pose['min_z'] = min(body_pose['min_z'], body_z - prev_body_z if prev_body_z is not None else 0) + body_pose['max_z'] = max(body_pose['max_z'], body_z - prev_body_z if prev_body_z is not None else 0) + + body_orientation['min_yaw'] = min(body_orientation['min_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) + body_orientation['max_yaw'] = max(body_orientation['max_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) + + end_effector_pose['min_x'] = min(end_effector_pose['min_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) + end_effector_pose['max_x'] = max(end_effector_pose['max_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) + + end_effector_pose['min_y'] = min(end_effector_pose['min_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) + end_effector_pose['max_y'] = max(end_effector_pose['max_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) + + end_effector_pose['min_z'] = min(end_effector_pose['min_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) + end_effector_pose['max_z'] = max(end_effector_pose['max_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) + + + prev_body_x = body_x + prev_body_y = body_y + prev_body_z = body_z + prev_body_yaw = body_yaw + prev_ee_x = ee_x + prev_ee_y = ee_y + prev_ee_z = ee_z + + + + #cache the saved max and min values if already computed to save time + attribute_limits = [body_pose, body_orientation, end_effector_pose] + with open('./lanmp_dataloader/attribute_limits.json', 'w') as f: + json.dump(attribute_limits, f) + + + return body_pose, body_orientation, end_effector_pose + + def collate_batches(self, batch, shuffle_batch = False): + + + collated_batch = [] + + # merging batch elements with variable length + for out in range(len(batch[0])): + collated_output = [] + for idx in range(len(batch)): + if batch[idx][out].dtype.type == np.str_: + collated_output.append(batch[idx][out]) + else: + collated_output.append(torch.from_numpy(batch[idx][out])) + + if batch[idx][out].dtype.type!=np.str_: + collated_output = torch.cat(collated_output, dim=0) + else: + + collated_output = np.concatenate(collated_output, axis=0) + + collated_batch.append(collated_output) + + #shuffling all the batched samples across the trajectories to get random order + if shuffle_batch: + permutation = torch.randperm(collated_batch[0].size(0)) + + for i in range(len(collated_batch)): + collated_batch[i] = collated_batch[i][permutation] + + return collated_batch + + + + + + + + + +class RT1Dataset(Dataset): + + + + def __init__(self, data_split_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim, tokenize_action=True): + + #stores the keys in the dataset for the appropriate split (train, validation or test) + self.dataset_keys = data_split_keys + self.body_pose_lim = body_pose_lim + self.body_orientation_lim = body_orientation_lim + self.end_effector_pose_lim = end_effector_pose_lim + self.num_bins = 254 + + self.tokenize_action = tokenize_action + + self.hdf = h5py.File(DATASET_PATH, 'r') + + def __len__(self): + return len(self.dataset_keys) + + + def make_data_discrete(self, dictionary): + + + + #body x, y, z coordinate + dictionary['body_position_deltas'][:,0] = 1 + (dictionary['body_position_deltas'][:,0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins + dictionary['body_position_deltas'][:,0] = dictionary['body_position_deltas'][:,0].astype(int) + + if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0: + dictionary['body_position_deltas'][:,1] = 1 + (dictionary['body_position_deltas'][:,1] - self.body_pose_lim['min_y'])/(self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins + else: + dictionary['body_position_deltas'][:,1].fill(0) + dictionary['body_position_deltas'][:,1] = dictionary['body_position_deltas'][:,1].astype(int) + + dictionary['body_position_deltas'][:,2] = 1 + (dictionary['body_position_deltas'][:,2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins + dictionary['body_position_deltas'][:,2] = dictionary['body_position_deltas'][:,2].astype(int) + + #body yaw and pitch + dictionary['body_yaw_deltas'] = 1 + (dictionary['body_yaw_deltas'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins + dictionary['body_yaw_deltas'] = dictionary['body_yaw_deltas'].astype(int) + + #end effector x, y, z coordinate + dictionary['arm_position_deltas'][:,0] = 1 + (dictionary['arm_position_deltas'][:,0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins + dictionary['arm_position_deltas'][:,0] = dictionary['arm_position_deltas'][:,0].astype(int) + + dictionary['arm_position_deltas'][:,1] = 1 + (dictionary['arm_position_deltas'][:,1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins + dictionary['arm_position_deltas'][:,1] = dictionary['arm_position_deltas'][:,1].astype(int) + + dictionary['arm_position_deltas'][:,2] = 1 + (dictionary['arm_position_deltas'][:,2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins + dictionary['arm_position_deltas'][:,2] = dictionary['arm_position_deltas'][:,2].astype(int) + + #find if and where episode terminates so you can fill those entries with 0s + if 1.0 in dictionary['terminate_episode']: + terminate_idx = np.where(np.array(dictionary['terminate_episode'])>0)[0][0] + + dictionary['body_position_deltas'][terminate_idx:,:].fill(0) + dictionary['body_yaw_deltas'][terminate_idx:].fill(0) + dictionary['arm_position_deltas'][terminate_idx:,:].fill(0) + + + return dictionary + + + def detokenize_continuous_data(self, dictionary): + + if dictionary['curr_mode'] == 'stop': + dictionary['body_position_delta'] = [[0.0, 0.0, 0.0]] + dictionary['body_yaw_delta'] = [[0.0]] + dictionary['arm_position_deltas'] = [[0.0, 0.0, 0.0]] + + else: + dictionary['body_position_delta'][0][0] = (dictionary['body_position_delta'][0][0] - 1) * (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x']) / self.num_bins + self.body_pose_lim['min_x'] + dictionary['body_position_delta'][0][1] = (dictionary['body_position_delta'][0][1] - 1) * (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y']) / self.num_bins + self.body_pose_lim['min_y'] + dictionary['body_position_delta'][0][2] = (dictionary['body_position_delta'][0][2] - 1) * (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z']) / self.num_bins + self.body_pose_lim['min_z'] + + dictionary['body_yaw_delta'][0][0] = (dictionary['body_yaw_delta'][0][0] - 1) * (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) / self.num_bins + self.body_orientation_lim['min_yaw'] + + + dictionary['arm_position_delta'][0][0] = (dictionary['arm_position_delta'][0][0] - 1) * (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x']) / self.num_bins + self.end_effector_pose_lim['min_x'] + dictionary['arm_position_delta'][0][1] = (dictionary['arm_position_delta'][0][1] - 1) * (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y']) / self.num_bins + self.end_effector_pose_lim['min_y'] + dictionary['arm_position_delta'][0][2] = (dictionary['arm_position_delta'][0][2] - 1) * (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z']) / self.num_bins + self.end_effector_pose_lim['min_z'] + return dictionary + + + def make_data_discrete_old(self, dictionary): + + if not bool(dictionary['is_terminal']): + + #body x, y, z coordinate + dictionary['body_position'][0] = 1 + int( (dictionary['body_position'][0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins) + + dictionary['body_position'][1] = 1 + int( (dictionary['body_position'][1] - self.body_pose_lim['min_y'])/ (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins) if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0 else 0 + + dictionary['body_position'][2] = 1 + int( (dictionary['body_position'][2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins) + + #body yaw and pitch + dictionary['body_yaw'] = 1 + int( (dictionary['body_yaw'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins) + + #end effector x, y, z coordinate + dictionary['arm_position'][0] = 1 + int( (dictionary['arm_position'][0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins) + dictionary['arm_position'][1] = 1 + int( (dictionary['arm_position'][1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins) + dictionary['arm_position'][2] = 1 + int( (dictionary['arm_position'][2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins) + + #if terminal action is chosen, then produce 'no action' discrete value for each of the state variables + else: + dictionary['body_position'][0] = 0 + dictionary['body_position'][1] = 0 + dictionary['body_position'][2] = 0 + + dictionary['body_yaw'] = 0 + + dictionary['arm_position'][0] = 0 + dictionary['arm_position'][1] = 0 + dictionary['arm_position'][2] = 0 + + def get_head_pitch(self, action): + + value = 0 + + if action == 'LookDown': + value = 1 + elif action == 'LookUp': + value = 2 + + return value + + def detokenize_head_pitch(self, token): + + tokenization_dict = {0:None, 1:'LookDown', 2:'LookUp'} + + return tokenization_dict[token] + + def get_mode(self, action): + + #mode: (0) stop, (1) body, (2) yaw, (3) manipulation, (4) grasping, (5) head pitch + + value = None + + if action == 'stop': + value = 0 + elif action in set( ['LookDown', 'LookUp']): + value = 5 + elif action in set(['MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft']): + value = 1 + elif action in set(['PickupObject', 'ReleaseObject']): + value = 4 + elif action in set(['MoveArm', 'MoveArmBase']): + value = 3 + elif action == 'RotateAgent': + value = 2 + + assert(type(value)==int, 'Get Mode didn\'t return an int') + return value + + def detokenize_mode(self, token): + + tokenization_dict = {0: 'stop', 1:'MoveAgent', 2:'RotateAgent', 3:'MoveArm', 4:'PickupReleaseObject', 5:'PitchAgent'} + + return tokenization_dict[token] + + def detokenize_action(self, detokenized_mode, body_position_delta, body_yaw_delta, arm_position_delta, detokenized_pickup_release, detokenized_head_pitch): + + + if detokenized_mode == 'PickupReleaseObject': + return detokenized_pickup_release + + elif detokenized_mode == 'PitchAgent': + return detokenized_head_pitch + else: + return detokenized_mode + + + def get_pickup_release(self, action): + + if action == 'PickupObject': + value = 1 + elif action == 'ReleaseObject': + value = 2 + else: + value = 0 + + return value + + def detokenize_pickup_release(self, token): + + tokenization_dict = {0:None, 1:'PickupObject', 2:'ReleaseObject'} + return tokenization_dict[token] + + def __getitem__(self, idx): + + # pdb.set_trace() + + traj_group = self.hdf[self.dataset_keys[idx]] + + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + nl_command = traj_json_dict['nl_command'] + + + #compute remainder in case padding of action tokens and observations needed + padding_length = 6 - (len(traj_steps)%6) if len(traj_steps)%6 > 0 else 0 + terminate = False + + start = 0; end = min(len(traj_steps), 6) + + #return list of dictionaries with attributes required for RT1 + all_image_obs = [] + all_nl_commands = [] + all_is_terminal = [] + all_pickup_release = [] + all_body_position_deltas = [] + all_body_yaw_deltas = [] + all_body_pitches = [] + all_arm_position_deltas = [] + all_control_mode = [] + + all_pad_lengths = [] + + + + #build the dictionary for each sequence + while end <= len(traj_steps) and not terminate: + + ''' + mode: stop, body, yaw, manipulation, grasping, head pitch + gripper: (x, y, z, grasp) + body: (x, y, yaw, look up/down) + ''' + image_obs = [] + nl_commands = [] + body_position_deltas = [] + body_yaw_deltas = [] + arm_position_deltas = [] + terminate_episodes = [] + pickup_releases = [] + body_pitches = [] + control_modes = [] + + for i in range(start, end): + + #visual observation + ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) + image_obs.append(ith_obs) + + #natural language command + nl_commands.append(nl_command) + + current_metadata = json.loads(traj_group[traj_steps[i]].attrs['metadata']) + + + if i < len(traj_steps)-1: + + next_metadata = json.loads(traj_group[traj_steps[i+1]].attrs['metadata']) + + #body position, body yaw, arm position + body_position_delta = np.array(next_metadata['steps'][0]['state_body'][:3])-np.array(current_metadata['steps'][0]['state_body'][:3]) + body_yaw_delta = next_metadata['steps'][0]['state_body'][3] - current_metadata['steps'][0]['state_body'][3] + arm_position_delta = np.array(next_metadata['steps'][0]['state_ee'][:3]) - np.array(current_metadata['steps'][0]['state_ee'][:3]) + + #terminate episode / pick up release / body pitch / mode + terminate_episode = int(i == len(traj_steps)-1) + pickup_release = self.get_pickup_release(next_metadata['steps'][0]['action']) + body_pitch = self.get_head_pitch(next_metadata['steps'][0]['action']) + control_mode = self.get_mode(next_metadata['steps'][0]['action']) + else: + + #body position, body yaw, arm positon -- for last step + body_position_delta = np.array([0.0, 0.0, 0.0]) + body_yaw_delta = 0.0 + arm_position_delta = np.array([0.0, 0.0, 0.0]) + + #is terminal / pick up release / body pitch / mode -- for last step + terminate_episode = int(i == len(traj_steps)-1) + pickup_release = self.get_pickup_release(None) + body_pitch = self.get_head_pitch(None) + control_mode = self.get_mode('stop') + + body_position_deltas.append(body_position_delta) + body_yaw_deltas.append(body_yaw_delta) + arm_position_deltas.append(arm_position_delta) + terminate_episodes.append(terminate_episode) + pickup_releases.append(pickup_release) + body_pitches.append(body_pitch) + control_modes.append(control_mode) + + + + #check for remainder and pad data with extra + if end >= len(traj_steps) and padding_length > 0: + + for pad in range(0, padding_length): + + image_obs.append(ith_obs) + nl_commands.append(nl_command) + + body_position_deltas.append(np.array([0.0, 0.0, 0.0])) + body_yaw_deltas.append(0.0) + arm_position_deltas.append(np.array([0.0, 0.0, 0.0])) + terminate_episodes.append(0) + pickup_releases.append(0.0) + body_pitches.append(0.0) + control_modes.append(0.0) + + terminate = True + elif end >= len(traj_steps): + terminate = True + + + + #pre-process and discretize numerical data + body_position_deltas = np.stack(body_position_deltas) + body_yaw_deltas = np.stack(body_yaw_deltas) + arm_position_deltas = np.stack(arm_position_deltas) + + if self.tokenize_action: + + tokenized_actions = { + 'body_position_deltas': body_position_deltas, + 'body_yaw_deltas': body_yaw_deltas, + 'arm_position_deltas': arm_position_deltas, + 'terminate_episode': terminate_episodes + } + + tokenized_actions = self.make_data_discrete(tokenized_actions) + + body_position_deltas = tokenized_actions['body_position_deltas'] + + body_yaw_deltas = np.expand_dims(tokenized_actions['body_yaw_deltas'], axis=1) + + arm_position_deltas = tokenized_actions['arm_position_deltas'] + + + + + all_image_obs.append(np.stack(image_obs)) + all_nl_commands.append(np.stack(nl_commands)) + all_is_terminal.append(np.stack(terminate_episodes)) + all_pickup_release.append(np.stack(pickup_releases)) + all_body_position_deltas.append(body_position_deltas) + all_body_yaw_deltas.append(body_yaw_deltas) + all_body_pitches.append(np.stack(body_pitches)) + all_arm_position_deltas.append(arm_position_deltas) + all_control_mode.append(np.stack(control_modes)) + + all_pad_lengths.append(0 if not end >= len(traj_steps) else padding_length) + + + start += 6 + end = min(end + 6, len(traj_steps)) + + + + + return np.stack(all_image_obs), np.stack(all_nl_commands), np.stack(all_is_terminal), np.stack(all_pickup_release), np.stack(all_body_position_deltas), np.stack(all_body_yaw_deltas), np.stack(all_body_pitches), np.stack(all_arm_position_deltas), np.stack(all_control_mode), np.stack(all_pad_lengths) + + + + def __getitem_old__(self, idx): + + + traj_group = self.hdf[self.dataset_keys[idx]] + + traj_steps = list(traj_group.keys()) + traj_steps.sort(key=sort_folders) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + nl_command = traj_json_dict['nl_command'] + + start = 0; end = min(len(traj_steps), 6) + + #return list of dictionaries with attributes required for RT1 + all_image_obs = [] + all_nl_commands = [] + all_is_terminal = [] + all_pickup_release = [] + all_body_position = [] + all_body_yaw = [] + all_body_pitch = [] + all_arm_position = [] + all_mode = [] + + + + #build the dictionary for each sequence + while end < len(traj_steps): + + ''' + mode: stop, body, yaw, manipulation, grasping, head pitch + gripper: (x, y, z, grasp) + body: (x, y, yaw, look up/down) + ''' + image_obs = [] + + for i in range(start, end): + ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) + + image_obs.append(ith_obs) + + image_obs = np.stack(image_obs) + + + + before_end_step_metadata = json.loads(traj_group[traj_steps[end-1]].attrs['metadata']) + end_step_metadata = json.loads(traj_group[traj_steps[end]].attrs['metadata']) + + + + dictionary = { + 'observation': image_obs, + 'nl_command': nl_command, #DONE + 'is_terminal': int(end_step_metadata['steps'][0]['action']=='stop'), #DONE + 'pickup_release': self.get_pickup_release(end_step_metadata['steps'][0]['action']), #DONE + 'body_position': np.array(end_step_metadata['steps'][0]['state_body'][:3])-np.array(before_end_step_metadata['steps'][0]['state_body'][:3]), #DONE + 'body_yaw': end_step_metadata['steps'][0]['state_body'][3] - before_end_step_metadata['steps'][0]['state_body'][3], #DONE + 'body_pitch': self.get_head_pitch(end_step_metadata['steps'][0]['action']), #DONE + 'arm_position': np.array(end_step_metadata['steps'][0]['state_ee'][:3]) - np.array(before_end_step_metadata['steps'][0]['state_ee'][:3]), #DONE + 'mode': self.get_mode(end_step_metadata['steps'][0]['action']) #DONE + } + + #pre-process the data dictonary + if self.tokenize_action: + self.make_data_discrete(dictionary) + + + all_image_obs.append(dictionary['observation']) + all_nl_commands.append(dictionary['nl_command']) + all_is_terminal.append(dictionary['is_terminal']) + all_pickup_release.append(dictionary['pickup_release']) + all_body_position.append(dictionary['body_position']) + all_body_yaw.append(dictionary['body_yaw']) + all_body_pitch.append(dictionary['body_pitch']) + all_arm_position.append(dictionary['arm_position']) + all_mode.append(dictionary['mode']) + + + start += 1 + end += 1 + + #add the terminal 'stop' step + all_image_obs.append(dictionary['observation']) + all_nl_commands.append(dictionary['nl_command']) + all_is_terminal.append(1) + all_pickup_release.append(0) + all_body_position.append([0,0,0]) + all_body_yaw.append(0) + all_body_pitch.append(0) + all_arm_position.append([0,0,0]) + all_mode.append(0) + + + + + + return np.stack(all_image_obs), np.stack(all_nl_commands), np.expand_dims(np.stack(all_is_terminal), axis=1), np.expand_dims(np.stack(all_pickup_release), axis=1), np.stack(all_body_position), np.expand_dims(np.stack(all_body_yaw),axis=1), np.expand_dims(np.stack(all_body_pitch), axis=1), np.stack(all_arm_position), np.expand_dims(np.stack(all_mode), axis=1) + + +if __name__ == '__main__': + + + dataset_manager = DatasetManager(0, 0.8, 0.1, 0.1) + + dataloader = DataLoader(dataset_manager.train_dataset, batch_size=3, + shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) + + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size=2, + shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) + + + + for batch, sample_batch in enumerate(dataloader): + + # print('BATCH {}:'.format(batch)) + # print('Num Steps: {}'.format(sample_batch[0].shape[0])) + print('Batch {}: '.format(batch), sample_batch[0].shape[0]) + + + + + \ No newline at end of file diff --git a/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json b/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json new file mode 100644 index 000000000..da07b6395 --- /dev/null +++ b/models/main_models/rt1/lanmp_dataloader/scene_to_keys.json @@ -0,0 +1 @@ +{"FloorPlan_Train8_1": ["data_11:11:28", "data_11:38:43", "data_11:48:40", "data_11:51:31", "data_11:56:47", "data_11:58:17", "data_12:18:24", "data_12:31:00", "data_12:49:55", "data_12:53:51", "data_12:54:21", "data_12:57:45", "data_12:59:43", "data_13:00:14", "data_13:13:47", "data_13:18:03", "data_13:22:48", "data_13:24:35", "data_13:29:42", "data_13:30:35", "data_13:36:19", "data_13:37:24", "data_13:38:39", "data_13:42:32", "data_13:48:30", "data_13:52:48", "data_13:56:06", "data_13:58:42", "data_14:01:23", "data_14:24:32", "data_14:26:22", "data_14:31:39", "data_14:36:13", "data_14:38:15", "data_14:44:47", "data_14:45:23", "data_14:49:15", "data_14:53:25", "data_14:58:54", "data_15:06:22", "data_15:09:43", "data_15:13:05", "data_15:13:36", "data_15:14:10", "data_15:16:32", "data_15:20:09", "data_15:22:18", "data_15:25:56", "data_15:26:42", "data_15:29:24", "data_15:29:51", "data_15:30:35", "data_15:32:34", "data_15:39:22", "data_15:41:58", "data_15:43:27", "data_15:43:51", "data_16:05:05", "data_16:09:25", "data_16:11:06", "data_16:13:53", "data_16:18:35", "data_16:23:48", "data_16:26:23", "data_16:30:54", "data_16:43:19", "data_16:49:20", "data_16:52:28", "data_16:53:34", "data_16:59:06", "data_17:00:51", "data_17:02:54", "data_17:04:35", "data_17:06:16", "data_17:13:00", "data_17:20:01", "data_17:23:07", "data_17:26:09", "data_17:33:07", "data_17:47:57", "data_17:51:34", "data_17:56:54", "data_17:58:11", "data_17:59:29", "data_18:01:53", "data_18:08:32", "data_18:18:37", "data_18:22:56", "data_18:25:09", "data_18:33:34", "data_18:45:42", "data_19:09:57", "data_19:15:07", "data_19:20:52", "data_19:25:51", "data_19:34:02", "data_19:43:09", "data_19:48:33", "data_19:52:25", "data_19:53:51", "data_20:29:26", "data_21:11:22", "data_21:14:13", "data_22:26:52"], "FloorPlan_Train1_3": ["data_11:14:08", "data_12:27:37", "data_12:28:44", "data_12:30:42", "data_12:42:59", "data_12:48:44", "data_13:01:08", "data_13:10:23", "data_13:16:27", "data_13:26:27", "data_13:29:09", "data_13:33:21", "data_13:35:43", "data_13:45:31", "data_13:49:19", "data_13:53:16", "data_13:59:05", "data_14:02:16", "data_14:19:36", "data_14:22:29", "data_14:24:31", "data_14:26:42", "data_14:32:06", "data_14:34:15", "data_14:35:23", "data_14:38:31", "data_14:43:46", "data_14:46:49", "data_14:48:48", "data_14:50:47", "data_14:56:50", "data_15:01:27", "data_15:35:48", "data_15:38:38", "data_15:39:32", "data_15:42:27", "data_15:49:15", "data_15:50:49", "data_15:51:26", "data_15:52:55", "data_15:54:45", "data_15:56:44", "data_15:58:10", "data_16:01:04", "data_16:03:52", "data_16:04:17", "data_16:10:32", "data_16:10:59", "data_16:33:34", "data_16:37:28", "data_16:40:36", "data_16:40:44", "data_16:42:54", "data_16:43:00", "data_16:43:00:00", "data_16:44:16", "data_16:45:24", "data_16:47:46", "data_16:49:24", "data_16:55:46", "data_17:05:08", "data_17:07:34", "data_17:07:43", "data_17:21:35", "data_17:26:17", "data_17:29:14", "data_17:32:17", "data_17:32:27", "data_17:43:33", "data_17:47:03", "data_17:51:39", "data_17:59:00", "data_18:04:56", "data_18:11:24", "data_18:17:16", "data_18:22:49", "data_18:25:44", "data_18:28:13", "data_18:28:43", "data_18:29:38", "data_18:31:13", "data_18:35:58", "data_18:37:04", "data_18:46:02", "data_19:14:43", "data_19:31:51", "data_19:35:53", "data_20:11:23", "data_20:15:34", "data_20:57:07", "data_21:09:57", "data_21:35:32", "data_21:40:45", "data_22:55:44", "data_22:59:37", "data_23:02:34"], "FloorPlan_Train5_1": ["data_11:19:28", "data_11:23:37", "data_12:05:09", "data_12:15:11", "data_12:22:25", "data_12:37:24", "data_12:40:41", "data_12:43:21", "data_12:58:49", "data_13:14:36", "data_13:22:30", "data_13:25:14", "data_13:28:56", "data_13:29:25", "data_13:31:07", "data_13:33:29", "data_13:40:50", "data_13:42:24", "data_13:46:04", "data_14:03:55", "data_14:05:06", "data_14:09:28", "data_14:10:09", "data_14:14:11", "data_14:18:16", "data_14:23:38", "data_14:36:10", "data_14:40:10", "data_14:47:53", "data_14:50:55", "data_14:56:41", "data_14:58:02", "data_14:58:08", "data_15:03:19", "data_15:05:49", "data_15:06:39", "data_15:08:16", "data_15:13:04", "data_15:19:26", "data_15:22:08", "data_15:27:41", "data_15:29:40", "data_15:40:49", "data_15:44:42", "data_15:56:53", "data_15:58:27", "data_16:00:55", "data_16:02:46", "data_16:05:15", "data_16:06:05", "data_16:07:40", "data_16:09:36", "data_16:12:08", "data_16:26:34", "data_16:29:17", "data_16:31:09", "data_16:31:36", "data_16:35:27", "data_16:43:42", "data_16:45:58", "data_16:47:16", "data_16:50:06", "data_16:51:03", "data_16:53:36", "data_16:53:39", "data_16:53:42", "data_16:54:39", "data_16:56:38", "data_16:57:05:00", "data_16:57:25", "data_17:12:32", "data_17:17:50", "data_17:35:45", "data_17:39:05:00", "data_17:41:00", "data_17:41:08", "data_17:45:27", "data_17:50:42", "data_17:54:05", "data_17:56:23", "data_18:22:47", "data_18:31:07", "data_18:33:51", "data_18:37:38", "data_18:42:03", "data_18:44:54", "data_18:47:01", "data_18:50:53", "data_18:58:07", "data_19:04:21", "data_19:08:32", "data_19:27:25", "data_19:53:59", "data_19:57:56", "data_20:07:12", "data_22:02:06", "data_22:10:19", "data_23:06:06", "data_23:09:41", "data_23:16:06"], "FloorPlan_Train12_3": ["data_11:24:25", "data_12:04:43", "data_12:04:44", "data_12:09:11", "data_12:12:18", "data_12:13:00", "data_12:48:09", "data_12:55:46", "data_13:02:17", "data_13:04:13", "data_13:06:18", "data_13:07:22", "data_13:07:34", "data_13:08:21", "data_13:10:24", "data_13:15:55", "data_13:18:11", "data_13:19:12", "data_13:33:54", "data_13:37:23", "data_13:39:28", "data_13:40:16", "data_13:51:04", "data_13:52:30", "data_13:56:07", "data_13:57:55", "data_14:04:08", "data_14:06:14", "data_14:06:28", "data_14:07:59", "data_14:10:04", "data_14:19:43", "data_14:23:01", "data_14:25:51", "data_14:36:45", "data_14:38:16", "data_14:40:46", "data_15:04:08", "data_15:06:03", "data_15:08:14", "data_15:10:38", "data_15:13:32", "data_15:15:15", "data_15:21:58", "data_15:22:59", "data_15:23:17", "data_15:25:19", "data_15:27:29", "data_15:27:52", "data_15:34:50", "data_15:37:13", "data_15:37:30", "data_15:39:06", "data_15:39:14", "data_15:40:22", "data_15:41:15", "data_15:46:13", "data_15:47:54", "data_15:48:04", "data_15:50:55", "data_16:03:07", "data_16:11:48", "data_16:12:38", "data_16:15:33", "data_16:21:47", "data_16:22:10", "data_16:22:44", "data_16:25:33", "data_16:27:27", "data_16:33:37", "data_16:33:42", "data_16:35:20", "data_16:37:57", "data_16:58:28", "data_16:59:59", "data_17:02:20", "data_17:05:07", "data_17:07:22", "data_17:08:14", "data_17:08:43", "data_17:10:41", "data_17:12:20", "data_17:16:57", "data_17:25:26", "data_17:31:59", "data_17:39:05", "data_18:05:31", "data_18:06:05", "data_18:09:48", "data_18:11:32", "data_18:20:49", "data_18:38:30", "data_18:40:29", "data_18:44:56", "data_19:32:42", "data_19:36:17", "data_19:38:40", "data_19:55:46", "data_19:58:40", "data_20:04:58", "data_20:36:00", "data_20:40:25", "data_20:40:56", "data_20:43:46", "data_21:22:47", "data_21:27:13", "data_21:36:02", "data_21:39:40"], "FloorPlan_Train7_5": ["data_11:33:11", "data_11:35:24", "data_11:38:27", "data_11:44:50", "data_11:50:57", "data_12:03:39", "data_12:30:12", "data_12:36:36", "data_12:41:02", "data_12:45:50", "data_12:46:17", "data_12:48:23", "data_12:50:47", "data_12:59:13", "data_13:01:06", "data_13:06:40", "data_13:10:05", "data_13:19:26", "data_13:33:39", "data_13:34:59", "data_13:39:14", "data_13:39:53", "data_13:41:08", "data_13:44:39", "data_13:48:45", "data_13:53:16:00", "data_14:17:20", "data_14:19:54", "data_14:22:51", "data_14:23:49", "data_14:29:19", "data_14:40:36", "data_14:43:02", "data_14:45:24", "data_14:52:27", "data_15:00:11", "data_15:02:05", "data_15:05:00", "data_15:06:51", "data_15:08:00", "data_15:08:23", "data_15:09:40", "data_15:10:35", "data_15:15:28", "data_15:18:01", "data_15:19:33", "data_15:20:32", "data_15:22:15", "data_15:24:10", "data_15:33:02", "data_15:35:16", "data_15:36:12", "data_15:37:15", "data_15:58:50", "data_16:00:52", "data_16:02:56", "data_16:03:52:00", "data_16:04:13", "data_16:08:41", "data_16:10:21", "data_16:12:36", "data_16:15:15", "data_16:18:47", "data_16:21:30", "data_16:33:14", "data_16:35:18", "data_16:36:47", "data_16:37:29", "data_16:43:59", "data_16:47:31", "data_16:55:23", "data_16:55:40", "data_16:57:05", "data_16:57:21", "data_16:58:20", "data_16:58:53", "data_16:59:33", "data_16:59:34", "data_17:00:42", "data_17:00:58", "data_17:02:46", "data_17:02:49", "data_17:03:08", "data_17:10:18", "data_17:32:08", "data_17:39:16", "data_17:43:47", "data_17:46:14", "data_17:48:24", "data_17:58:02", "data_17:59:14", "data_18:01:35", "data_18:06:24", "data_18:09:10", "data_18:12:41", "data_18:15:58", "data_18:26:13", "data_18:39:40", "data_18:41:38", "data_18:45:39", "data_18:54:32", "data_18:57:41", "data_18:59:56", "data_19:00:23", "data_19:02:18", "data_19:03:13", "data_19:15:22", "data_19:18:14", "data_19:20:26", "data_19:27:05", "data_20:26:48", "data_20:33:59", "data_22:17:48", "data_23:21:12", "data_23:26:05", "data_23:27:44"]} \ No newline at end of file diff --git a/models/main_models/rt1/main.py b/models/main_models/rt1/main.py new file mode 100644 index 000000000..29f6032bd --- /dev/null +++ b/models/main_models/rt1/main.py @@ -0,0 +1,257 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +from tqdm import tqdm +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=['fractal20220817_data'], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--epochs", + type=int, + default=1, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--train-batch-size", + type=int, + default=8, + help="train batch size", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=8, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=0, + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=200, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/rt1_pretraining", + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-pretraining-v1", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + print("Loading dataset...") + + train_dataset = create_dataset( + datasets=args.datasets, + split=args.train_split, + trajectory_length=args.trajectory_length, + batch_size=args.train_batch_size, + num_epochs=args.epochs, + ) + # eval_dataset = create_dataset( + # datasets=args.datasets, + # split=args.eval_split, + # trajectory_length=args.trajectory_length, + # batch_size=args.eval_batch_size, + # num_epochs=args.epochs, + # ) + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + action_space = gym.spaces.Dict( + world_vector=gym.spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + base_displacement_vertical_rotation=gym.spaces.Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 + ), + gripper_closedness_action=gym.spaces.Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=gym.spaces.Discrete(3), + base_displacement_vector=gym.spaces.Box( + low=-1.0, + high=1.0, + shape=(2,), + dtype=np.float32, + ), + rotation_delta=gym.spaces.Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else None + ) + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + if text_embedding_model is not None: + return text_embedding_model.encode(observation["instruction"]) + else: + return observation["embedding"] + + print("Training...") + num_batches = 0 + + for batch in tqdm(train_dataset): + + policy.model.train() + + num_batches += 1 + + if num_batches <= 0: + continue + + #Image Shape: 8, 6, 480, 640, 3 => (batch, length, height, width, channel) + #Context Shape: 8, 6, 512 => (batch, length, embedding) + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + + + actions = batch["action"] + + try: + loss, loss_std = policy.loss(observations, actions) + except: + print('-------------LOSS COMPUTATION FAILED!!!--------') + continue + + if args.wandb: + wandb.log({"loss": loss.item(), "loss_std": loss_std.item()}, step=num_batches * args.train_batch_size) + print(f"Train loss Batch {num_batches}: {loss.item()}") + else: + print(f"Train loss Batch {num_batches}: {loss.item()}") + optimizer.zero_grad() + loss.backward() + optimizer.step() + if args.eval_freq and num_batches % args.eval_freq == 0: + print("Evaluating...") + policy.model.eval() + batch = next(eval_dataset) + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + actions = batch["action"] + eval_loss, eval_loss_std = policy.loss(observations, actions) + eval_loss = eval_loss.item() + if args.wandb: + wandb.log( + {"eval_loss": eval_loss, "eval_loss_std": eval_loss_std.item()}, + step=num_batches * args.train_batch_size, + ) + else: + print(f"Eval loss Batch {num_batches}: {eval_loss}") + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{num_batches}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + print("finished training") + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/main_ft.py b/models/main_models/rt1/main_ft.py new file mode 100644 index 000000000..dca6394ab --- /dev/null +++ b/models/main_models/rt1/main_ft.py @@ -0,0 +1,387 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=["fractal20220817_data"], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--epochs", + type=int, + default=4, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--train-batch-size", + type=int, + default=3, + help="train batch size", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=0, #200 + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=100, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/temp", #"checkpoints/diversity_v1_4" + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default='/oscar/data/stellex/shared/rt1-checkpoints/checkpoints/bridge/checkpoint_14400_loss_70.621.pt', #NOTE: include the path to load the checkpoint here + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + + parser.add_argument( + "--eval-scene", + default=4, + help = "scene used as validation during k-fold cross validation", + ) + + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + + parser.add_argument( + "--num-diversity-scenes", + default = 4, + ) + + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + + + parser.add_argument( + "--train-subbatch", + default=8, + ) + parser.add_argument( + "--eval-subbatch", + default=5, + ) + return parser.parse_args() + + +def main(): + + + args = parse_args() + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-data-diversity-v1", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + print("Loading dataset...") + + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + + if args.wandb and args.split_type == 'diversity_ablation': + wandb.log({"task_keys": dataset_manager.train_dataset.dataset_keys}) + + train_dataloader = DataLoader(dataset_manager.train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches, drop_last = False) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=True, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + + #NOTE: has to be Not None because of raw instruction input + + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + print('EMBEDDING FAILED!') + + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + print("Training...") + num_batches = 0 + total_train_steps = 0 + total_val_steps = 0 + + + + + for epoch in range(args.epochs): + print("STARTING EPOCH {}".format(epoch+1)) + + for batch, train_batch in enumerate(train_dataloader): + + + batch_steps = train_batch[0].shape[0] + + for idx in range(0, batch_steps, args.train_subbatch): + + + + policy.model.train() + + num_batches += 1 + + + observations = { + "image": train_batch[0][idx : min(idx + args.train_subbatch, batch_steps)], + "context": get_text_embedding(train_batch[1][idx : min(idx + args.train_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': train_batch[2][idx : min(idx + args.train_subbatch, batch_steps)], + 'pickup_release': train_batch[3][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_position_delta': train_batch[4][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_yaw_delta': train_batch[5][idx : min(idx + args.train_subbatch, batch_steps)], + 'body_pitch_delta': train_batch[6][idx : min(idx + args.train_subbatch, batch_steps)], + 'arm_position_delta': train_batch[7][idx : min(idx + args.train_subbatch, batch_steps)], + 'control_mode': train_batch[8][idx : min(idx + args.train_subbatch, batch_steps)] + } + + padding = train_batch[9][idx : min(idx + args.train_subbatch, batch_steps)] + total_train_steps += batch_steps + + + loss, loss_std = policy.loss(observations, actions) + + if args.wandb: + print(f"Train loss Batch {num_batches}: {loss.item()} ± {loss_std.item()}") + wandb.log({"train_loss": loss.item(), "train_loss_std": loss_std.item()}, step= total_train_steps) + else: + print(f"Train loss Batch {num_batches}: {loss.item()}") + + optimizer.zero_grad() + loss.backward() + optimizer.step() + observations = {}; actions = {} + + + if args.eval_freq and num_batches % args.eval_freq == 0: + + # Clear cache and collected garbage + gc.collect() + torch.cuda.empty_cache() + + total_eval_loss = 0 + total_eval_loss_std = 0 + total_eval_count = 0 + + + + print("Evaluating...") + for batch, val_batch in enumerate(val_dataloader): + + batch_steps = val_batch[0].shape[0] + + print(f'Section {batch+1} of {len(val_dataloader)}') + + for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): + + + policy.model.eval() + + + total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + + observations = { + "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], + "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], + 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], + 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], + 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] + } + + padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] + + eval_loss, eval_loss_std = policy.loss(observations, actions) + + + total_eval_loss += eval_loss.item()*observations['image'].shape[0] + total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] + + if args.wandb: + wandb.log( + {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, + step=total_train_steps, + ) + print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") + else: + print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") + + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{total_train_steps}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + + print("FINISHED EPOCH {}".format(epoch+1)) + print("finished training") + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/main_ft_eval.py b/models/main_models/rt1/main_ft_eval.py new file mode 100644 index 000000000..708243b25 --- /dev/null +++ b/models/main_models/rt1/main_ft_eval.py @@ -0,0 +1,279 @@ +import argparse +import os +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--datasets", + type=list, + default=["fractal20220817_data"], + ) + parser.add_argument( + "--train-split", + type=str, + default="train[:-1000]", + help="use e.g. train[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-split", + type=str, + default="train[-1000:]", + help="use e.g. eval[:100] for the first 100 episodes", + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=6, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--checkpoint-path", + type=str, + default="checkpoints/scene4", + help="directory to save checkpoints", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + + parser.add_argument( + "--eval-scene", + default=4, + help = "scene used as validation during k-fold cross validation", + ) + parser.add_argument( + "--eval-subbatch", + default=5, + ) + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + + parser.add_argument( + "--num-diversity-scenes", + default = 4, + ) + + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + + os.makedirs(args.checkpoint_path, exist_ok=True) + + if args.wandb: + wandb.init(project="rt1-finetuning", config=vars(args)) + + os.makedirs(args.checkpoint_path, exist_ok=True) + + assert(len(os.listdir(args.checkpoint_path)) > 0 , "ERROR: checkpoint path is empty and has no saved checkpoints") + + print("Loading dataset...") + + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + + + #NOTE: has to be Not None because of raw instruction input + + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + pdb.set_trace() + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + + def extract_train_step(filepath): + return int(filepath.split('_')[1]) + + + print("Evaluating...") + + + for idx, checkpoint_file in enumerate(list(sorted(os.listdir(args.checkpoint_path), key=extract_train_step))): + + print(f'Evaluating file: {idx} of {len(os.listdir(args.checkpoint_path))}') + total_train_steps = int(checkpoint_file.split('_')[1]) + total_val_steps = 0 + + + total_eval_loss = 0 + total_eval_loss_std = 0 + total_eval_count = 0 + + print("Building policy...") + policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=os.path.join(args.checkpoint_path, checkpoint_file), + ) + + + + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + + + for batch, val_batch in enumerate(val_dataloader): + + batch_steps = val_batch[0].shape[0] + + print(f'Section {batch+1} of {len(val_dataloader)}') + + for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): + + + policy.model.eval() + + + total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] + + observations = { + "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], + "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), + } + + + actions = { + 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], + 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], + 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], + 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], + 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] + } + + padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] + + eval_loss, eval_loss_std = policy.loss(observations, actions) + + + total_eval_loss += eval_loss.item()*observations['image'].shape[0] + total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] + + if args.wandb: + wandb.log( + {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, + step=total_train_steps, + ) + print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") + else: + print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/rollout_ai2thor.py b/models/main_models/rt1/rollout_ai2thor.py new file mode 100644 index 000000000..0edf255ca --- /dev/null +++ b/models/main_models/rt1/rollout_ai2thor.py @@ -0,0 +1,366 @@ +import argparse +import os +os.environ["CUDA_VISIBLE_DEVICES"] = "0" +from typing import Dict +import pdb +import gymnasium as gym +import numpy as np +import torch +import wandb +from sentence_transformers import SentenceTransformer +from torch.optim import Adam +import tensorflow_hub as hub +from data import create_dataset +from rt1_pytorch.rt1_policy import RT1Policy +from tqdm import tqdm +from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader +import gc +import json +import pandas as pd +from ai2thor_env import ThorEnv +import pickle +import time +from tqdm import tqdm + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--sentence-transformer", + type=str, + default=None, + help="SentenceTransformer to use; default is None for original USE embeddings", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--checkpoint-file-path", + type=str, + default="checkpoints/scene2/checkpoint_299183_loss_152.175.pt", #NOTE: change according to checkpoint file that is to be loaded + help="directory to save checkpoints", + ) + + parser.add_argument( + "--trajectory-save-path", + type=str, + default="traj_rollouts/scene2", + help = "directory to save the generated trajectory predicted by the model" + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + parser.add_argument( + "--eval-scene", + default=2, + help = "scene used as validation during k-fold cross validation", + ) + parser.add_argument( + "--eval-subbatch", + default=1, + ) + parser.add_argument( + "--split-type", + default = 'k_fold_scene', + choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], + ) + parser.add_argument( + "--num-diversity-scenes", + default = 3, + ) + parser.add_argument( + "--max-diversity-trajectories", + default = 100, + ) + parser.add_argument( + "--eval-batch-size", + type=int, + default=3, + help="eval batch size", + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + if args.wandb: + wandb.init(project="rt1-rollout-data", config=vars(args)) + + os.makedirs(args.trajectory_save_path, exist_ok=True) + + assert(os.path.isfile(args.checkpoint_file_path), "ERROR: checkpoint file does not exist") + + + print("Loading dataset...") + + dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) + val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) + + + observation_space = gym.spaces.Dict( + image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), + context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + + action_space = gym.spaces.Dict( + + body_yaw_delta = gym.spaces.Box( + low= 0, #train_dataloader.body_orientation_lim['min_yaw'] + high= 255, #train_dataloader.body_orientation_lim['max_yaw'] + shape=(1,), + dtype=int + ), + + body_pitch_delta = gym.spaces.Discrete(3), + + terminate_episode=gym.spaces.Discrete(2), + + pickup_release = gym.spaces.Discrete(3), + + body_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + arm_position_delta = gym.spaces.Box( + low = 0, + high = 255, + shape = (3,), + dtype = np.int32 + ), + + control_mode = gym.spaces.Discrete(7), + + ) + + + + #NOTE: has to be Not None because of raw instruction input + text_embedding_model = ( + SentenceTransformer(args.sentence_transformer) + if args.sentence_transformer + else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") + ) + + + + + def get_text_embedding(observation: Dict): + + if args.sentence_transformer is not None: + return text_embedding_model.encode(observation) + else: + embedded_observation = [] + + for i in range(0, observation.shape[1]): + + try: + embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) + except: + raise Exception('Error: task descriptions could not be embedded') + + embedded_observation = np.stack(embedded_observation, axis=1) + return embedded_observation + + + + + print("Loading chosen checkpoint to model...") + rt1_model_policy = RT1Policy( + observation_space=observation_space, + action_space=action_space, + device=args.device, + checkpoint_path=args.checkpoint_file_path, + ) + rt1_model_policy.model.eval() + + # Total number of params + total_params = sum(p.numel() for p in rt1_model_policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in rt1_model_policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in rt1_model_policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + + print('Creating pandas dataframe for trajectories...') + + print_val = True + + + for task in tqdm(val_dataloader.dataset.dataset_keys): + + + #skip tasks that trajectory already generated for + if os.path.isfile(os.path.join(args.trajectory_save_path, task)): + continue + elif print_val: + print('START AT: ', val_dataloader.dataset.dataset_keys.index(task)) + print_val = False + + traj_group = val_dataloader.dataset.hdf[task] + + traj_steps = list(traj_group.keys()) + + #extract the NL command + json_str = traj_group[traj_steps[0]].attrs['metadata'] + traj_json_dict = json.loads(json_str) + language_command_embedding = get_text_embedding(np.array([[traj_json_dict['nl_command']]])) + language_command_embedding = np.repeat(language_command_embedding, 6, axis=1) + + + print('TASK: ', traj_json_dict['nl_command']) + + #initialize the AI2Thor environment + ai2thor_env = ThorEnv(traj_json_dict['nl_command']) + event = ai2thor_env.reset(traj_json_dict['scene']) + + + + #extract the visual observation from initialzed environment + curr_image = event.frame + visual_observation = np.expand_dims(np.expand_dims(curr_image, axis=0) , axis=0) + visual_observation = np.repeat(visual_observation, 6, axis=1) + + ''' + OLD OBS FROM DATASET + visual_observation = np.expand_dims(np.expand_dims(np.array(traj_group[traj_steps[0]]['rgb_0']), axis=0), axis=0) + visual_observation = np.repeat(visual_observation, 6, axis=1) + ''' + + #track the starting coordinates for body, yaw rotation and arm coordinate + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + agent_holding = np.array([]) + + + #track the total number of steps and the last control mode + num_steps = 0; curr_mode = None; is_terminal = False + + + #track data for all steps + trajectory_data = [] + + while (curr_mode != 'stop' or is_terminal) and num_steps < ai2thor_env.max_episode_length: + + #provide the current observation to the model + curr_observation = { + 'image': visual_observation, + 'context': language_command_embedding + } + + generated_action_tokens = rt1_model_policy.act(curr_observation) + + #de-tokenize the generated actions from RT1 + pickup_release = val_dataloader.dataset.detokenize_pickup_release(generated_action_tokens['pickup_release'][0]) + body_pitch = val_dataloader.dataset.detokenize_head_pitch(generated_action_tokens['body_pitch_delta'][0]) + curr_mode = val_dataloader.dataset.detokenize_mode(generated_action_tokens['control_mode'][0]) + + + + + terminate_episode = generated_action_tokens['terminate_episode'][0] + + continuous_variables = { + 'body_position_delta': generated_action_tokens['body_position_delta'], + 'body_yaw_delta': generated_action_tokens['body_yaw_delta'], + 'arm_position_delta': generated_action_tokens['arm_position_delta'], + 'curr_mode': curr_mode + } + + continuous_variables = val_dataloader.dataset.detokenize_continuous_data(continuous_variables) + body_position_delta = np.squeeze(continuous_variables['body_position_delta']) + body_yaw_delta = continuous_variables['body_yaw_delta'][0][0] + arm_position_delta = np.squeeze(continuous_variables['arm_position_delta']) + + curr_action = val_dataloader.dataset.detokenize_action(curr_mode, body_position_delta, body_yaw_delta, arm_position_delta, pickup_release, body_pitch) + + + + #update the tracked coordinate data based on model output + curr_body_coordinate += body_position_delta + curr_body_yaw += body_yaw_delta + curr_arm_coordinate += arm_position_delta + + + #execute the generated action in the AI2THOR simulator + step_args = { + 'xyz_body': curr_body_coordinate, + 'xyz_body_delta': body_position_delta, + 'curr_body_yaw': curr_body_yaw, + 'body_yaw_delta': body_yaw_delta, + 'arm_position_delta': arm_position_delta, + 'arm_position': curr_arm_coordinate + } + success, error, event = ai2thor_env.step(curr_action, step_args) + + time.sleep(0.25) + + #fetch object holding from simulator; also maybe fetch coordinate of body/arm + yaw from simulator + agent_holding = np.array(event.metadata['arm']['heldObjects']) + + #fetch the new visual observation from the simulator, update the current mode and increment number of steps + curr_image = np.expand_dims(np.expand_dims(event.frame, axis=0) , axis=0) + + visual_observation = visual_observation[:,1:,:,:,:] + visual_observation = np.concatenate((visual_observation, curr_image), axis=1) + num_steps +=1 + + curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) + curr_body_yaw = event.metadata['agent']['rotation']['y'] + curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) + + + #add data to the dataframe CSV + step_data = { + 'task': traj_json_dict['nl_command'], + 'scene': traj_json_dict['scene'], + 'img': curr_image, + 'xyz_body': curr_body_coordinate, + 'xyz_body_delta': body_position_delta, + 'yaw_body': curr_body_yaw, + 'yaw_body_delta': body_yaw_delta, + 'pitch_body': body_pitch, + 'xyz_ee': curr_arm_coordinate, + 'xyz_ee_delta': arm_position_delta, + 'pickup_dropoff': pickup_release, + 'holding_obj': agent_holding, + 'control_mode': curr_mode, + 'action': curr_action, + 'terminate': terminate_episode, + 'step': num_steps, + 'timeout': num_steps >= ai2thor_env.max_episode_length, + 'error': error + } + + trajectory_data.append(step_data) + + #save the final event with all metadata: save as a json file dict + save_path = os.path.join(args.trajectory_save_path, task) + with open(save_path, 'wb') as file: + pickle.dump({'trajectory_data': trajectory_data, 'final_state': event.metadata}, file) + + #close the old GUI for AI2Thor after trajectory finishes + ai2thor_env.controller.stop() + time.sleep(0.5) + + + + + + + +if __name__ == "__main__": + main() diff --git a/models/main_models/rt1/rt1_env/bin/Activate.ps1 b/models/main_models/rt1/rt1_env/bin/Activate.ps1 new file mode 100644 index 000000000..9d3646a4f --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/Activate.ps1 @@ -0,0 +1,241 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/models/main_models/rt1/rt1_env/bin/activate b/models/main_models/rt1/rt1_env/bin/activate new file mode 100644 index 000000000..2fdaa7bfa --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/activate @@ -0,0 +1,66 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null + fi + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1="(rt1_env) ${PS1:-}" + export PS1 +fi + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null +fi diff --git a/models/main_models/rt1/rt1_env/bin/activate.csh b/models/main_models/rt1/rt1_env/bin/activate.csh new file mode 100644 index 000000000..af00fde95 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/activate.csh @@ -0,0 +1,25 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . +# Ported to Python 3.3 venv by Andrew Svetlov + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" + +set _OLD_VIRTUAL_PATH="$PATH" +setenv PATH "$VIRTUAL_ENV/bin:$PATH" + + +set _OLD_VIRTUAL_PROMPT="$prompt" + +if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then + set prompt = "(rt1_env) $prompt" +endif + +alias pydoc python -m pydoc + +rehash diff --git a/models/main_models/rt1/rt1_env/bin/activate.fish b/models/main_models/rt1/rt1_env/bin/activate.fish new file mode 100644 index 000000000..388919ed3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/activate.fish @@ -0,0 +1,64 @@ +# This file must be used with "source /bin/activate.fish" *from fish* +# (https://fishshell.com/); you cannot run it directly. + +function deactivate -d "Exit virtual environment and return to normal shell environment" + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + functions -e fish_prompt + set -e _OLD_FISH_PROMPT_OVERRIDE + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + end + + set -e VIRTUAL_ENV + if test "$argv[1]" != "nondestructive" + # Self-destruct! + functions -e deactivate + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/bin" $PATH + +# Unset PYTHONHOME if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # fish uses a function instead of an env var to generate the prompt. + + # Save the current fish_prompt function as the function _old_fish_prompt. + functions -c fish_prompt _old_fish_prompt + + # With the original prompt function renamed, we can override with our own. + function fish_prompt + # Save the return status of the last command. + set -l old_status $status + + # Output the venv prompt; color taken from the blue of the Python logo. + printf "%s%s%s" (set_color 4B8BBE) "(rt1_env) " (set_color normal) + + # Restore the return status of the previous command. + echo "exit $old_status" | . + # Output the original/"old" prompt. + _old_fish_prompt + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" +end diff --git a/models/main_models/rt1/rt1_env/bin/ai2thor-xorg b/models/main_models/rt1/rt1_env/bin/ai2thor-xorg new file mode 100755 index 000000000..7bc6235a3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/ai2thor-xorg @@ -0,0 +1,267 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +import os +import sys +import time +import platform +import re +import shlex +import subprocess +import argparse +import signal + +# Turning off automatic black formatting for this script as it breaks quotes. +# fmt: off +from typing import List + +PID_FILE = "/var/run/ai2thor-xorg.pid" +CONFIG_FILE = "/tmp/ai2thor-xorg.conf" + +DEFAULT_HEIGHT = 768 +DEFAULT_WIDTH = 1024 + + +def process_alive(pid): + """ + Use kill(0) to determine if pid is alive + :param pid: process id + :rtype: bool + """ + try: + os.kill(pid, 0) + except OSError: + return False + + return True + + +def find_devices(excluded_device_ids): + devices = [] + id_counter = 0 + for r in pci_records(): + if r.get("Vendor", "") == "NVIDIA Corporation" and r["Class"] in [ + "VGA compatible controller", + "3D controller", + ]: + bus_id = "PCI:" + ":".join( + map(lambda x: str(int(x, 16)), re.split(r"[:\.]", r["Slot"])) + ) + + if id_counter not in excluded_device_ids: + devices.append(bus_id) + + id_counter += 1 + + if not devices: + print("Error: ai2thor-xorg requires at least one NVIDIA device") + sys.exit(1) + + return devices + +def active_display_bus_ids(): + # this determines whether a monitor is connected to the GPU + # if one is, the following Option is added for the Screen "UseDisplayDevice" "None" + command = "nvidia-smi --query-gpu=pci.bus_id,display_active --format=csv,noheader" + active_bus_ids = set() + result = subprocess.run(command, shell=True, stdout=subprocess.PIPE) + if result.returncode == 0: + for line in result.stdout.decode().strip().split("\n"): + nvidia_bus_id, display_status = re.split(r",\s?", line.strip()) + bus_id = "PCI:" + ":".join( + map(lambda x: str(int(x, 16)), re.split(r"[:\.]", nvidia_bus_id)[1:]) + ) + if display_status.lower() == "enabled": + active_bus_ids.add(bus_id) + + return active_bus_ids + +def pci_records(): + records = [] + command = shlex.split("lspci -vmm") + output = subprocess.check_output(command).decode() + + for devices in output.strip().split("\n\n"): + record = {} + records.append(record) + for row in devices.split("\n"): + key, value = row.split("\t") + record[key.split(":")[0]] = value + + return records + + +def read_pid(): + if os.path.isfile(PID_FILE): + with open(PID_FILE) as f: + return int(f.read()) + else: + return None + + +def start(display: str, excluded_device_ids: List[int], width: int, height: int): + pid = read_pid() + + if pid and process_alive(pid): + print("Error: ai2thor-xorg is already running with pid: %s" % pid) + sys.exit(1) + + with open(CONFIG_FILE, "w") as f: + f.write(generate_xorg_conf(excluded_device_ids, width=width, height=height)) + + log_file = "/var/log/ai2thor-xorg.%s.log" % display + error_log_file = "/var/log/ai2thor-xorg-error.%s.log" % display + command = shlex.split( + "Xorg -quiet -maxclients 1024 -noreset +extension GLX +extension RANDR +extension RENDER -logfile %s -config %s :%s" + % (log_file, CONFIG_FILE, display) + ) + + pid = None + with open(error_log_file, "w") as error_log_f: + proc = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=error_log_f) + pid = proc.pid + try: + proc.wait(timeout=0.25) + except subprocess.TimeoutExpired: + pass + + if pid and process_alive(pid): + with open(PID_FILE, "w") as f: + f.write(str(proc.pid)) + else: + print("Error: error with command '%s'" % " ".join(command)) + with open(error_log_file, "r") as f: + print(f.read()) + + +def print_config(excluded_device_ids: List[int], width: int, height: int): + print(generate_xorg_conf(excluded_device_ids, width=width, height=height)) + + +def stop(): + pid = read_pid() + if pid and process_alive(pid): + os.kill(pid, signal.SIGTERM) + + for i in range(10): + time.sleep(0.2) + if not process_alive(pid): + os.unlink(PID_FILE) + break + + +def generate_xorg_conf( + excluded_device_ids: List[int], width: int, height: int +): + devices = find_devices(excluded_device_ids) + active_display_devices = active_display_bus_ids() + + xorg_conf = [] + + device_section = """ +Section "Device" + Identifier "Device{device_id}" + Driver "nvidia" + VendorName "NVIDIA Corporation" + BusID "{bus_id}" +EndSection +""" + server_layout_section = """ +Section "ServerLayout" + Identifier "Layout0" + {screen_records} +EndSection +""" + screen_section = """ +Section "Screen" + Identifier "Screen{screen_id}" + Device "Device{device_id}" + DefaultDepth 24 + Option "AllowEmptyInitialConfiguration" "True" + Option "Interactive" "False" + {extra_options} + SubSection "Display" + Depth 24 + Virtual {width} {height} + EndSubSection +EndSection +""" + screen_records = [] + for i, bus_id in enumerate(devices): + extra_options = "" + if bus_id in active_display_devices: + # See https://github.com/allenai/ai2thor/pull/990 + # when a monitor is connected, this option must be used otherwise + # Xorg will fail to start + extra_options = 'Option "UseDisplayDevice" "None"' + xorg_conf.append(device_section.format(device_id=i, bus_id=bus_id)) + xorg_conf.append(screen_section.format(device_id=i, screen_id=i, width=width, height=height, extra_options=extra_options)) + screen_records.append( + 'Screen {screen_id} "Screen{screen_id}" 0 0'.format(screen_id=i) + ) + + xorg_conf.append( + server_layout_section.format(screen_records="\n ".join(screen_records)) + ) + + output = "\n".join(xorg_conf) + return output + + +# fmt: on + +if __name__ == "__main__": + if os.geteuid() != 0: + path = os.path.abspath(__file__) + print("Executing ai2thor-xorg with sudo") + args = ["--", path] + sys.argv[1:] + os.execvp("sudo", args) + + if platform.system() != "Linux": + print("Error: Can only run ai2thor-xorg on linux") + sys.exit(1) + + parser = argparse.ArgumentParser() + parser.add_argument( + "--exclude-device", + help="exclude a specific GPU device", + action="append", + type=int, + default=[], + ) + parser.add_argument( + "--width", + help="width of the screen to start (should be greater than the maximum" + f" width of any ai2thor instance you will start) [default: {DEFAULT_WIDTH}]", + type=int, + default=DEFAULT_WIDTH, + ) + parser.add_argument( + "--height", + help="height of the screen to start (should be greater than the maximum" + f" height of any ai2thor instance you will start) [default: {DEFAULT_HEIGHT}]", + type=int, + default=DEFAULT_HEIGHT, + ) + parser.add_argument( + "command", + help="command to be executed", + choices=["start", "stop", "print-config"], + ) + parser.add_argument( + "display", help="display to be used", nargs="?", type=int, default=0 + ) + args = parser.parse_args() + if args.command == "start": + start( + display=args.display, + excluded_device_ids=args.exclude_device, + height=args.height, + width=args.width, + ) + elif args.command == "stop": + stop() + elif args.command == "print-config": + print_config( + excluded_device_ids=args.exclude_device, + width=args.width, + height=args.height, + ) diff --git a/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx b/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx new file mode 100755 index 000000000..0294702e2 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/convert-caffe2-to-onnx @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from caffe2.python.onnx.bin.conversion import caffe2_to_onnx +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(caffe2_to_onnx()) diff --git a/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 b/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 new file mode 100755 index 000000000..daed37802 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/convert-onnx-to-caffe2 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from caffe2.python.onnx.bin.conversion import onnx_to_caffe2 +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(onnx_to_caffe2()) diff --git a/models/main_models/rt1/rt1_env/bin/f2py b/models/main_models/rt1/rt1_env/bin/f2py new file mode 100755 index 000000000..6ae2c3109 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/f2py @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from numpy.f2py.f2py2e import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/flask b/models/main_models/rt1/rt1_env/bin/flask new file mode 100755 index 000000000..fa566a3ba --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/flask @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from flask.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/huggingface-cli b/models/main_models/rt1/rt1_env/bin/huggingface-cli new file mode 100755 index 000000000..5580d7dc9 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/huggingface-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from huggingface_hub.commands.huggingface_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/imageio_download_bin b/models/main_models/rt1/rt1_env/bin/imageio_download_bin new file mode 100755 index 000000000..2e17ded5a --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/imageio_download_bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from imageio.__main__ import download_bin_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(download_bin_main()) diff --git a/models/main_models/rt1/rt1_env/bin/imageio_remove_bin b/models/main_models/rt1/rt1_env/bin/imageio_remove_bin new file mode 100755 index 000000000..bbbdac364 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/imageio_remove_bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from imageio.__main__ import remove_bin_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(remove_bin_main()) diff --git a/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard b/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard new file mode 100755 index 000000000..47503b8c4 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/import_pb_to_tensorboard @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.python.tools.import_pb_to_tensorboard import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/isympy b/models/main_models/rt1/rt1_env/bin/isympy new file mode 100755 index 000000000..8f709363b --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/isympy @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from isympy import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/jp.py b/models/main_models/rt1/rt1_env/bin/jp.py new file mode 100755 index 000000000..2a3859f1f --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/jp.py @@ -0,0 +1,54 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 + +import sys +import json +import argparse +from pprint import pformat + +import jmespath +from jmespath import exceptions + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('expression') + parser.add_argument('-f', '--filename', + help=('The filename containing the input data. ' + 'If a filename is not given then data is ' + 'read from stdin.')) + parser.add_argument('--ast', action='store_true', + help=('Pretty print the AST, do not search the data.')) + args = parser.parse_args() + expression = args.expression + if args.ast: + # Only print the AST + expression = jmespath.compile(args.expression) + sys.stdout.write(pformat(expression.parsed)) + sys.stdout.write('\n') + return 0 + if args.filename: + with open(args.filename, 'r') as f: + data = json.load(f) + else: + data = sys.stdin.read() + data = json.loads(data) + try: + sys.stdout.write(json.dumps( + jmespath.search(expression, data), indent=4, ensure_ascii=False)) + sys.stdout.write('\n') + except exceptions.ArityError as e: + sys.stderr.write("invalid-arity: %s\n" % e) + return 1 + except exceptions.JMESPathTypeError as e: + sys.stderr.write("invalid-type: %s\n" % e) + return 1 + except exceptions.UnknownFunctionError as e: + sys.stderr.write("unknown-function: %s\n" % e) + return 1 + except exceptions.ParseError as e: + sys.stderr.write("syntax-error: %s\n" % e) + return 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/lsm2bin b/models/main_models/rt1/rt1_env/bin/lsm2bin new file mode 100755 index 000000000..a4b517af7 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/lsm2bin @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.lsm2bin import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/markdown-it b/models/main_models/rt1/rt1_env/bin/markdown-it new file mode 100755 index 000000000..e58e8d1e4 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/markdown-it @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from markdown_it.cli.parse import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/markdown_py b/models/main_models/rt1/rt1_env/bin/markdown_py new file mode 100755 index 000000000..8424ab33e --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/markdown_py @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from markdown.__main__ import run +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run()) diff --git a/models/main_models/rt1/rt1_env/bin/normalizer b/models/main_models/rt1/rt1_env/bin/normalizer new file mode 100755 index 000000000..e3a575f79 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/normalizer @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from charset_normalizer.cli import cli_detect +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli_detect()) diff --git a/models/main_models/rt1/rt1_env/bin/pip b/models/main_models/rt1/rt1_env/bin/pip new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pip @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pip3 b/models/main_models/rt1/rt1_env/bin/pip3 new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pip3 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pip3.9 b/models/main_models/rt1/rt1_env/bin/pip3.9 new file mode 100755 index 000000000..95ae2f451 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pip3.9 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/portserver.py b/models/main_models/rt1/rt1_env/bin/portserver.py new file mode 100755 index 000000000..6cdc3c0f3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/portserver.py @@ -0,0 +1,415 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +# +# Copyright 2015 Google Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +"""A server to hand out network ports to applications running on one host. + +Typical usage: + 1) Run one instance of this process on each of your unittest farm hosts. + 2) Set the PORTSERVER_ADDRESS environment variable in your test runner + environment to let the portpicker library know to use a port server + rather than attempt to find ports on its own. + +$ /path/to/portserver.py & +$ export PORTSERVER_ADDRESS=@unittest-portserver +$ # ... launch a bunch of unittest runners using portpicker ... +""" + +import argparse +import asyncio +import collections +import logging +import signal +import socket +import sys +import psutil +import subprocess +from datetime import datetime, timezone, timedelta + +log = None # Initialized to a logging.Logger by _configure_logging(). + +_PROTOS = [(socket.SOCK_STREAM, socket.IPPROTO_TCP), + (socket.SOCK_DGRAM, socket.IPPROTO_UDP)] + + +def _get_process_command_line(pid): + try: + return psutil.Process(pid).cmdline() + except psutil.NoSuchProcess: + return '' + + +def _get_process_start_time(pid): + try: + return psutil.Process(pid).create_time() + except psutil.NoSuchProcess: + return 0.0 + + +# TODO: Consider importing portpicker.bind() instead of duplicating the code. +def _bind(port, socket_type, socket_proto): + """Try to bind to a socket of the specified type, protocol, and port. + + For the port to be considered available, the kernel must support at least + one of (IPv6, IPv4), and the port must be available on each supported + family. + + Args: + port: The port number to bind to, or 0 to have the OS pick a free port. + socket_type: The type of the socket (ex: socket.SOCK_STREAM). + socket_proto: The protocol of the socket (ex: socket.IPPROTO_TCP). + + Returns: + The port number on success or None on failure. + """ + got_socket = False + for family in (socket.AF_INET6, socket.AF_INET): + try: + sock = socket.socket(family, socket_type, socket_proto) + got_socket = True + except socket.error: + continue + try: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + sock.bind(('', port)) + if socket_type == socket.SOCK_STREAM: + sock.listen(1) + port = sock.getsockname()[1] + except socket.error: + return None + finally: + sock.close() + return port if got_socket else None + + +def _is_port_free(port): + """Check if specified port is free. + + Args: + port: integer, port to check + Returns: + boolean, whether it is free to use for both TCP and UDP + """ + return _bind(port, *_PROTOS[0]) and _bind(port, *_PROTOS[1]) + + +def _should_allocate_port(pid): + """Determine if we should allocate a port for use by the given process id.""" + if pid <= 0: + log.info('Not allocating a port to invalid pid') + return False + if pid == 1: + # The client probably meant to send us its parent pid but + # had been reparented to init. + log.info('Not allocating a port to init.') + return False + + if not psutil.pid_exists(pid): + log.info('Not allocating a port to a non-existent process') + return False + return True + + +async def _start_windows_server(client_connected_cb, path): + """Start the server on Windows using named pipes.""" + def protocol_factory(): + stream_reader = asyncio.StreamReader() + stream_reader_protocol = asyncio.StreamReaderProtocol( + stream_reader, client_connected_cb) + return stream_reader_protocol + + loop = asyncio.get_event_loop() + server, *_ = await loop.start_serving_pipe(protocol_factory, address=path) + + return server + + +class _PortInfo(object): + """Container class for information about a given port assignment. + + Attributes: + port: integer port number + pid: integer process id or 0 if unassigned. + start_time: Time in seconds since the epoch that the process started. + """ + + __slots__ = ('port', 'pid', 'start_time') + + def __init__(self, port): + self.port = port + self.pid = 0 + self.start_time = 0.0 + + +class _PortPool(object): + """Manage available ports for processes. + + Ports are reclaimed when the reserving process exits and the reserved port + is no longer in use. Only ports which are free for both TCP and UDP will be + handed out. It is easier to not differentiate between protocols. + + The pool must be pre-seeded with add_port_to_free_pool() calls + after which get_port_for_process() will allocate and reclaim ports. + The len() of a _PortPool returns the total number of ports being managed. + + Attributes: + ports_checked_for_last_request: The number of ports examined in order to + return from the most recent get_port_for_process() request. A high + number here likely means the number of available ports with no active + process using them is getting low. + """ + + def __init__(self): + self._port_queue = collections.deque() + self.ports_checked_for_last_request = 0 + + def num_ports(self): + return len(self._port_queue) + + def get_port_for_process(self, pid): + """Allocates and returns port for pid or 0 if none could be allocated.""" + if not self._port_queue: + raise RuntimeError('No ports being managed.') + + # Avoid an infinite loop if all ports are currently assigned. + check_count = 0 + max_ports_to_test = len(self._port_queue) + while check_count < max_ports_to_test: + # Get the next candidate port and move it to the back of the queue. + candidate = self._port_queue.pop() + self._port_queue.appendleft(candidate) + check_count += 1 + if (candidate.start_time == 0.0 or + candidate.start_time != _get_process_start_time(candidate.pid)): + if _is_port_free(candidate.port): + candidate.pid = pid + candidate.start_time = _get_process_start_time(pid) + if not candidate.start_time: + log.info("Can't read start time for pid %d.", pid) + self.ports_checked_for_last_request = check_count + return candidate.port + else: + log.info( + 'Port %d unexpectedly in use, last owning pid %d.', + candidate.port, candidate.pid) + + log.info('All ports in use.') + self.ports_checked_for_last_request = check_count + return 0 + + def add_port_to_free_pool(self, port): + """Add a new port to the free pool for allocation.""" + if port < 1 or port > 65535: + raise ValueError( + 'Port must be in the [1, 65535] range, not %d.' % port) + port_info = _PortInfo(port=port) + self._port_queue.append(port_info) + + +class _PortServerRequestHandler(object): + """A class to handle port allocation and status requests. + + Allocates ports to process ids via the dead simple port server protocol + when the handle_port_request asyncio.coroutine handler has been registered. + Statistics can be logged using the dump_stats method. + """ + + def __init__(self, ports_to_serve): + """Initialize a new port server. + + Args: + ports_to_serve: A sequence of unique port numbers to test and offer + up to clients. + """ + self._port_pool = _PortPool() + self._total_allocations = 0 + self._denied_allocations = 0 + self._client_request_errors = 0 + for port in ports_to_serve: + self._port_pool.add_port_to_free_pool(port) + + async def handle_port_request(self, reader, writer): + client_data = await reader.read(100) + self._handle_port_request(client_data, writer) + writer.close() + + def _handle_port_request(self, client_data, writer): + """Given a port request body, parse it and respond appropriately. + + Args: + client_data: The request bytes from the client. + writer: The asyncio Writer for the response to be written to. + """ + try: + if len(client_data) > 20: + raise ValueError('More than 20 characters in "pid".') + pid = int(client_data) + except ValueError as error: + self._client_request_errors += 1 + log.warning('Could not parse request: %s', error) + return + + log.info('Request on behalf of pid %d.', pid) + log.info('cmdline: %s', _get_process_command_line(pid)) + + if not _should_allocate_port(pid): + self._denied_allocations += 1 + return + + port = self._port_pool.get_port_for_process(pid) + if port > 0: + self._total_allocations += 1 + writer.write('{:d}\n'.format(port).encode('utf-8')) + log.debug('Allocated port %d to pid %d', port, pid) + else: + self._denied_allocations += 1 + + def dump_stats(self): + """Logs statistics of our operation.""" + log.info('Dumping statistics:') + stats = [] + stats.append( + 'client-request-errors {}'.format(self._client_request_errors)) + stats.append('denied-allocations {}'.format(self._denied_allocations)) + stats.append('num-ports-managed {}'.format(self._port_pool.num_ports())) + stats.append('num-ports-checked-for-last-request {}'.format( + self._port_pool.ports_checked_for_last_request)) + stats.append('total-allocations {}'.format(self._total_allocations)) + for stat in stats: + log.info(stat) + + +def _parse_command_line(): + """Configure and parse our command line flags.""" + parser = argparse.ArgumentParser() + parser.add_argument( + '--portserver_static_pool', + type=str, + default='15000-24999', + help='Comma separated N-P Range(s) of ports to manage (inclusive).') + parser.add_argument( + '--portserver_address', + '--portserver_unix_socket_address', # Alias to be backward compatible + type=str, + default='@unittest-portserver', + help='Address of AF_UNIX socket on which to listen on Unix (first @ is ' + 'a NUL) or the name of the pipe on Windows (first @ is the ' + r'\\.\pipe\ prefix).') + parser.add_argument('--verbose', + action='store_true', + default=False, + help='Enable verbose messages.') + parser.add_argument('--debug', + action='store_true', + default=False, + help='Enable full debug messages.') + return parser.parse_args(sys.argv[1:]) + + +def _parse_port_ranges(pool_str): + """Given a 'N-P,X-Y' description of port ranges, return a set of ints.""" + ports = set() + for range_str in pool_str.split(','): + try: + a, b = range_str.split('-', 1) + start, end = int(a), int(b) + except ValueError: + log.error('Ignoring unparsable port range %r.', range_str) + continue + if start < 1 or end > 65535: + log.error('Ignoring out of bounds port range %r.', range_str) + continue + ports.update(set(range(start, end + 1))) + return ports + + +def _configure_logging(verbose=False, debug=False): + """Configure the log global, message format, and verbosity settings.""" + overall_level = logging.DEBUG if debug else logging.INFO + logging.basicConfig( + format=('{levelname[0]}{asctime}.{msecs:03.0f} {thread} ' + '{filename}:{lineno}] {message}'), + datefmt='%m%d %H:%M:%S', + style='{', + level=overall_level) + global log + log = logging.getLogger('portserver') + # The verbosity controls our loggers logging level, not the global + # one above. This avoids debug messages from libraries such as asyncio. + log.setLevel(logging.DEBUG if verbose else overall_level) + + +def main(): + config = _parse_command_line() + if config.debug: + # Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access + asyncio.tasks._DEBUG = True + _configure_logging(verbose=config.verbose, debug=config.debug) + ports_to_serve = _parse_port_ranges(config.portserver_static_pool) + if not ports_to_serve: + log.error('No ports. Invalid port ranges in --portserver_static_pool?') + sys.exit(1) + + request_handler = _PortServerRequestHandler(ports_to_serve) + + if sys.platform == 'win32': + asyncio.set_event_loop(asyncio.ProactorEventLoop()) + + event_loop = asyncio.get_event_loop() + + if sys.platform == 'win32': + # On Windows, we need to periodically pause the loop to allow the user + # to send a break signal (e.g. ctrl+c) + def listen_for_signal(): + event_loop.call_later(0.5, listen_for_signal) + + event_loop.call_later(0.5, listen_for_signal) + + coro = _start_windows_server( + request_handler.handle_port_request, + path=config.portserver_address.replace('@', '\\\\.\\pipe\\', 1)) + else: + event_loop.add_signal_handler( + signal.SIGUSR1, request_handler.dump_stats) # pylint: disable=no-member + + old_py_loop = {'loop': event_loop} if sys.version_info < (3, 10) else {} + coro = asyncio.start_unix_server( + request_handler.handle_port_request, + path=config.portserver_address.replace('@', '\0', 1), + **old_py_loop) + + server_address = config.portserver_address + + server = event_loop.run_until_complete(coro) + log.info('Serving on %s', server_address) + try: + event_loop.run_forever() + except KeyboardInterrupt: + log.info('Stopping due to ^C.') + + server.close() + + if sys.platform != 'win32': + # PipeServer doesn't have a wait_closed() function + event_loop.run_until_complete(server.wait_closed()) + event_loop.remove_signal_handler(signal.SIGUSR1) # pylint: disable=no-member + + event_loop.close() + request_handler.dump_stats() + log.info('Goodbye.') + + +if __name__ == '__main__': + main() diff --git a/models/main_models/rt1/rt1_env/bin/progressbar b/models/main_models/rt1/rt1_env/bin/progressbar new file mode 100755 index 000000000..1136ebc7c --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/progressbar @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from progressbar.__main__ import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/pygmentize b/models/main_models/rt1/rt1_env/bin/pygmentize new file mode 100755 index 000000000..623ccdf50 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pygmentize @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from pygments.cmdline import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/python b/models/main_models/rt1/rt1_env/bin/python new file mode 120000 index 000000000..b8a0adbbb --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/python @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/python3 b/models/main_models/rt1/rt1_env/bin/python3 new file mode 120000 index 000000000..ae65fdaa1 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/python3 @@ -0,0 +1 @@ +/usr/bin/python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/python3.9 b/models/main_models/rt1/rt1_env/bin/python3.9 new file mode 120000 index 000000000..b8a0adbbb --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/python3.9 @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/bin/pythoni b/models/main_models/rt1/rt1_env/bin/pythoni new file mode 100755 index 000000000..2d650f825 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pythoni @@ -0,0 +1,36 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 + +# Copyright 2000-2002 Michael Hudson mwh@python.net +# +# All Rights Reserved +# +# +# Permission to use, copy, modify, and distribute this software and +# its documentation for any purpose is hereby granted without fee, +# provided that the above copyright notice appear in all copies and +# that both that copyright notice and this permission notice appear in +# supporting documentation. +# +# THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO +# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +# AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, +# INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER +# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF +# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +import locale, pdb, sys +# I forget exactly why this is necessary: +try: + locale.setlocale(locale.LC_ALL, '') +except locale.Error: + pass # oh well + + +from pyrepl.python_reader import main +from pyrepl import cmdrepl + +# whizzy feature: graft pyrepl support onto pdb +#pdb.Pdb = cmdrepl.replize(pdb.Pdb, 1) + +main(use_pygame_console=('pg' in sys.argv)) diff --git a/models/main_models/rt1/rt1_env/bin/pythoni1 b/models/main_models/rt1/rt1_env/bin/pythoni1 new file mode 100755 index 000000000..f0a75c79d --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/pythoni1 @@ -0,0 +1,17 @@ +#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 +""" This is an alternative to pythoni which tries to look like the +CPython prompt as much as possible, with the exception of allowing +multiline input and multiline history entries. +""" + +import os, sys +from pyrepl import readline +from pyrepl.simple_interact import run_multiline_interactive_console + +sys.modules['readline'] = readline + +if os.getenv('PYTHONSTARTUP'): + execfile(os.getenv('PYTHONSTARTUP')) + +print 'Python', sys.version +run_multiline_interactive_console() diff --git a/models/main_models/rt1/rt1_env/bin/reverb_server b/models/main_models/rt1/rt1_env/bin/reverb_server new file mode 100755 index 000000000..b9d8a78f5 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/reverb_server @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from reverb.server_executable.server_main import app_run_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(app_run_main()) diff --git a/models/main_models/rt1/rt1_env/bin/saved_model_cli b/models/main_models/rt1/rt1_env/bin/saved_model_cli new file mode 100755 index 000000000..44f84317c --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/saved_model_cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.python.tools.saved_model_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tensorboard b/models/main_models/rt1/rt1_env/bin/tensorboard new file mode 100755 index 000000000..2ee3b3204 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tensorboard @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorboard.main import run_main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(run_main()) diff --git a/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 b/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 new file mode 100755 index 000000000..aee84bff1 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tf_upgrade_v2 @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.tools.compatibility.tf_upgrade_v2_main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tfds b/models/main_models/rt1/rt1_env/bin/tfds new file mode 100755 index 000000000..0f5636bc8 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tfds @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow_datasets.scripts.cli.main import launch_cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(launch_cli()) diff --git a/models/main_models/rt1/rt1_env/bin/tflite_convert b/models/main_models/rt1/rt1_env/bin/tflite_convert new file mode 100755 index 000000000..0ebb370c7 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tflite_convert @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.python.tflite_convert import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tiff2fsspec b/models/main_models/rt1/rt1_env/bin/tiff2fsspec new file mode 100755 index 000000000..72322f48d --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tiff2fsspec @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.tiff2fsspec import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tiffcomment b/models/main_models/rt1/rt1_env/bin/tiffcomment new file mode 100755 index 000000000..81e89dd82 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tiffcomment @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile.tiffcomment import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tifffile b/models/main_models/rt1/rt1_env/bin/tifffile new file mode 100755 index 000000000..024aaecb3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tifffile @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tifffile import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/toco b/models/main_models/rt1/rt1_env/bin/toco new file mode 100755 index 000000000..0ebb370c7 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/toco @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.python.tflite_convert import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/toco_from_protos b/models/main_models/rt1/rt1_env/bin/toco_from_protos new file mode 100755 index 000000000..4a0931477 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/toco_from_protos @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tensorflow.lite.toco.python.toco_from_protos import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/torchrun b/models/main_models/rt1/rt1_env/bin/torchrun new file mode 100755 index 000000000..bbd4216d0 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/torchrun @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from torch.distributed.run import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tqdm b/models/main_models/rt1/rt1_env/bin/tqdm new file mode 100755 index 000000000..52aa9b22d --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tqdm @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from tqdm.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/transformers-cli b/models/main_models/rt1/rt1_env/bin/transformers-cli new file mode 100755 index 000000000..3cb3dba5c --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/transformers-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from transformers.commands.transformers_cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/bin/tree-cli b/models/main_models/rt1/rt1_env/bin/tree-cli new file mode 100755 index 000000000..822fcbe27 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/tree-cli @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from Tree.cli import create_tree +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(create_tree()) diff --git a/models/main_models/rt1/rt1_env/bin/wandb b/models/main_models/rt1/rt1_env/bin/wandb new file mode 100755 index 000000000..ad3846609 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/wandb @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wandb.cli.cli import cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli()) diff --git a/models/main_models/rt1/rt1_env/bin/wb b/models/main_models/rt1/rt1_env/bin/wb new file mode 100755 index 000000000..ad3846609 --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/wb @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wandb.cli.cli import cli +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(cli()) diff --git a/models/main_models/rt1/rt1_env/bin/wheel b/models/main_models/rt1/rt1_env/bin/wheel new file mode 100755 index 000000000..47a52e82e --- /dev/null +++ b/models/main_models/rt1/rt1_env/bin/wheel @@ -0,0 +1,10 @@ +#!/bin/sh +'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" +' ''' +# -*- coding: utf-8 -*- +import re +import sys +from wheel.cli import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto new file mode 100644 index 000000000..39512921e --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto @@ -0,0 +1,77 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "reverb/cc/schema.proto"; +import "tensorflow/core/protobuf/struct.proto"; + +// Configs for reconstructing a distribution to its initial state. + +// Next ID: 11. +message PriorityTableCheckpoint { + // Name of the table. + string table_name = 1; + + // Maximum number of items in the table. + // If an insert would result in this value getting exceeded, `remover` is used + // to select an item to remove before proceeding with the insert. + int64 max_size = 6; + + // The maximum number of times an item can be sampled before being removed. + int32 max_times_sampled = 7; + + // Items in the table ordered by `inserted_at` (asc). + // When loading a checkpoint the items should be added in the same order so + // position based item selectors (e.g fifo) are reconstructed correctly. + // + // *NOTE*: This field is deprecated; instead, a separate record file is + // written with PrioritizedItem records for checkpointing (in the same + // order as described here). + repeated PrioritizedItem deprecated_items = 2 [deprecated = true]; + + // Checkpoint of the associated rate limiter. + RateLimiterCheckpoint rate_limiter = 3; + + // Options for constructing new samplers and removers of the correct type. + // Note that this does not include the state that they currently hold as it + // will be reproduced using the order of `items. + KeyDistributionOptions sampler = 4; + KeyDistributionOptions remover = 5; + + // The total number of episodes that were at some point referenced by items + // in the table but have since been removed. + int64 num_deleted_episodes = 8; + + // Optional data signature for tensors stored in the table. + tensorflow.StructuredValue signature = 9; + + // Number of unique items sampled from the table since the last reset. + int64 num_unique_samples = 10; +} + +message RateLimiterCheckpoint { + reserved 1; // Deprecated field `name`. + + // The average number of times each item should be sampled during its + // lifetime. + double samples_per_insert = 2; + + // The minimum and maximum values the cursor is allowed to reach. The cursor + // value is calculated as `insert_count * samples_per_insert - + // sample_count`. If the value would go beyond these limits then the call is + // blocked until it can proceed without violating the constraints. + double min_diff = 3; + double max_diff = 4; + + // The minimum number of inserts required before any sample operation. + int64 min_size_to_sample = 5; + + // The total number of samples that occurred before the checkpoint. + int64 sample_count = 6; + + // The total number of inserts that occurred before the checkpoint. + int64 insert_count = 7; + + // The total number of deletes that occurred before the checkpoint. + int64 delete_count = 8; +} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto new file mode 100644 index 000000000..3428db5a5 --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/patterns.proto @@ -0,0 +1,123 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "tensorflow/core/protobuf/struct.proto"; + +message PatternNode { + // Index of the source column in the flattened step structure. + int32 flat_source_index = 1; + + // Slicing of the source column relative to the most recent step. + // + // These fields mimics the behavior of `slice` in Python. That is: + // + // * x[-1:] => (start=-1, stop=null) + // * x[-2] => (start=null, stop=-2) + // * x[-3:-1] => (start=-3, stop=-1) + // * x[-3:-1:2] => (start=-3, stop=-1, step=2) + // + // Furthermore, the following requirements applies: + // + // * Slices with undefined `start` (e.g. x[:-2]) are not supported. + // * For slices, `start` must be < 0 and `stop` must be <= 0. + // * `step` must be > 0 when defined. + // + oneof start_or_none { + int32 start = 2; + } + oneof stop_or_none { + int32 stop = 3; + } + oneof step_or_none { + int32 step = 4; + } +} + +message Condition { + // Given int32 `left`: `left % mod == eq`. + message ModuloEq { + int32 mod = 1; + int32 eq = 2; + } + + oneof left { + // The index of the most recent step within the episode. + bool step_index = 1; + + // The number of steps since the pattern was most recently applied. + bool steps_since_applied = 2; + + // The number of steps currently held by the buffer. + bool buffer_length = 3; + + // Set to 1 when `EndEpisode` is called, else 0. + bool is_end_episode = 4; + + // Extract scalar integer value from a column in the most recent step. If + // the column is not present in the data or it isn't a scalar of a supported + // type then the condition will return false. + // + // All integer types are casted to int32 and bool is converted to 1 if true + // and 0 if false. + // + int32 flat_source_index = 9; + } + + // TODO(b/205278205): Remove le and just use inverse + ge instead. + oneof cmp { + // `left == eq`. + int32 eq = 5; + + // `left >= ge`. + int32 ge = 6; + + // `left % mod_eq.mod == mod_eq.eq`. + ModuloEq mod_eq = 7; + } + + // Whether the condition result should be inversed. + bool inverse = 8; +} + +message Priority { + // Priority function that always return the same value. + message ConstantPriorityFn { + // Value to be returned by the priority function. + double value = 1; + } + + // Priority function that computes the trajectory TD Error using the per-step + // TD Error. See details of the TD Error in + // https://openreview.net/pdf?id=r1lyTjAqYX. + message TDError { + // Weight for the max priority in the TD Error computation. + double max_priority_weight = 1; + // Index of the field in the input step that contais the per-step TD Error. + int32 flat_source_index = 2; + } + + oneof priority_fn { + ConstantPriorityFn constant_fn = 1; + TDError td_error = 2; + } +} + +message StructuredWriterConfig { + // Flattened output structure. + repeated PatternNode flat = 1; + + // Serialised structure of the pattern. All leaf nodes must be None. If empty + // then pattern will be treated as a flat list. + tensorflow.StructuredValue pattern_structure = 2; + + // The table that generated trajectories will be inserted into. + string table = 3; + + // The priority assigned to all trajectories generated by this config. + Priority priority = 4; + + // Conditions which must be fulfilled for the configuration to be applied at + // the current step. + repeated Condition conditions = 5; +} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto new file mode 100644 index 000000000..a14a6ce56 --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto @@ -0,0 +1,10 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "reverb/cc/checkpointing/checkpoint.proto"; + +message ReverbServerConfig { + repeated PriorityTableCheckpoint tables = 1; + int32 port = 2; +} diff --git a/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto new file mode 100644 index 000000000..3c37454c3 --- /dev/null +++ b/models/main_models/rt1/rt1_env/include/site/python3.9/dm-reverb/schema.proto @@ -0,0 +1,289 @@ +syntax = "proto3"; + +package deepmind.reverb; + +import "google/protobuf/timestamp.proto"; +import "tensorflow/core/framework/tensor.proto"; +import "tensorflow/core/protobuf/struct.proto"; + +// The actual data is stored in chunks. The data can be arbitrary tensors. We do +// not interpret the bytes data of the tensors on the server side. It is up to +// the client to compress the bytes blob within the tensors. +message ChunkData { + // Unique identifier of the chunk. + uint64 chunk_key = 1; + + // The timesteps within the episode that the chunk covers. + SequenceRange sequence_range = 2; + + // Actual tensor data. + message Data { + repeated tensorflow.TensorProto tensors = 1; + } + Data data = 5 [lazy = true]; + + // Number of tensors in the data field. Set explicitly so that Reverb server + // can check it without accessing lazy data field (which is expensive to + // parse). + int32 data_tensors_len = 6; + + // Size of the tensors in `data` before compression. + int64 data_uncompressed_size = 7; + + // True if delta encoding has been applied before compressing data. + bool delta_encoded = 4; + + // Deprecated December 2020 and retained to provide backward + // compatibility with checkpoints created before this point. + repeated tensorflow.TensorProto deprecated_data = 3 [deprecated = true]; +} + +// A range that specifies which items to slice out from a sequence of chunks. +// The length of all chunks must at least be `offset`+`length`. +message SliceRange { + // Offset where the slice should start. + int32 offset = 1; + + // Length of the slice. Can span multiple chunks. + int32 length = 2; +} + +message SequenceRange { + // Globally unique identifier of the episode the sequence belongs to. + uint64 episode_id = 1; + + // Index within the episode of the first timestep covered by the range. + int32 start = 2; + + // Index within the episode of the last timestep covered by the range. + // Must be >= start_index. + int32 end = 3; + + // If set then at least one step is missing from the data. The number of steps + // (i.e batch size) present in the data is unknown and thus must be manually + // checked. However, the `start` and `end` step is guaranteed to be at first + // and last position in the data. + bool sparse = 4; +} + +message FlatTrajectory { + message ChunkSlice { + // Unique identifier of the ChunkData which owns the compressed data. + uint64 chunk_key = 1; + + // Index of the first element in the chunk to include. + int32 offset = 2; + + // Number of elements from the chunk to include. + int32 length = 3; + + // Tensor index of the tensor within the chunk. + int32 index = 4; + } + + message Column { + // Chunk slices to concat. + repeated ChunkSlice chunk_slices = 1; + + // If true then the batch dim (must be 1) is emitted when unpacked. + // Requires that column is made up of exactly one ChunkSlice of length 1. + bool squeeze = 2; + } + + // Flattened columns of the trajectory. + repeated Column columns = 1; +} + +// A prioritized item is part of a table and references a chunk of +// data. Sampling happens based on the priority of items. +// +// Next ID: 9. +// LINT.IfChange +message PrioritizedItem { + // Unique identifier of this item. + uint64 key = 1; + + // Priority table that the item belongs to. + string table = 2; + + // Priority used for sampling. + double priority = 5; + + // The number of times the item has been sampled. + int32 times_sampled = 6; + + // The time when the item was first inserted. + google.protobuf.Timestamp inserted_at = 7; + + // Flattened representation of item's trajectory. + FlatTrajectory flat_trajectory = 8; + + // Deprecated January 2021 and retained to provide backward compatibility + // with checkpoints created before this point. + repeated uint64 deprecated_chunk_keys = 3 [deprecated = true]; + SliceRange deprecated_sequence_range = 4 [deprecated = true]; +} +// LINT.ThenChange(reverb_service_impl.cc) + +// Used for updating an existing PrioritizedItem. +message KeyWithPriority { + // Identifier of the PrioritizedItem. + uint64 key = 1; + + // Priority used for sampling. + double priority = 2; +} + +message SampleInfo { + // Item from that was sampled from the table. + PrioritizedItem item = 1; + + // Probability that this item had at sampling time. Useful for importance + // sampling. + double probability = 2; + + // Number of items in the table at the time of the sample operation. + int64 table_size = 3; + + // Whether the sample was delayed due to rate limiting of the sampler. + bool rate_limited = 4; +} + +// LINT.IfChange +// Metadata about the table, including (optional) data signature. +// +// These fields correspond to initialization arguments of the +// `Table` class, unless noted otherwise. +// +// Next ID: 13. +message TableInfo { + // Table's name. + string name = 8; + + // Sampler and remover metadata. + KeyDistributionOptions sampler_options = 1; + KeyDistributionOptions remover_options = 2; + + // Max size of the table. + int64 max_size = 3; + + // Max number of times an element can be sampled before being + // removed. + int32 max_times_sampled = 4; + + // How data read/write is rate limited. + RateLimiterInfo rate_limiter_info = 5; + + // Optional data signature for tensors stored in the table. Note + // that this data type is more flexible than we use. For example, + // we only store tensors (TensorSpecProto, TypeSpecProto) and not + // any special data types (no NoneValue or other special fixed values). + tensorflow.StructuredValue signature = 6; + + // Current size of table. + int64 current_size = 7; + + // Number of episodes referenced by the items in the table. + int64 num_episodes = 9; + + // Number of episodes once referenced by items in the table but no longer is. + // The total number of episodes thus is `num_episodes + num_deleted_episodes`. + int64 num_deleted_episodes = 10; + + // Number of unique items sampled from the table since the last reset. + int64 num_unique_samples = 11; + + // Table worker execution time distribution. + TableWorkerTime table_worker_time = 12; +} +// LINT.ThenChange(../py/reverb/reverb_types.py) + +message RateLimiterCallStats { + // The total number of completed calls. + int64 completed = 2; + + reserved 1, 3, 4, 5; +} + +message RateLimiterInfo { + // The average number of times each item should be sampled during its + // lifetime. + double samples_per_insert = 1; + + // The minimum and maximum values the cursor is allowed to reach. The cursor + // value is calculated as `insert_count * samples_per_insert - + // sample_count`. If the value would go beyond these limits then the call is + // blocked until it can proceed without violating the constraints. + double min_diff = 2; + double max_diff = 3; + + // The minimum number of inserts required before any sample operation. + int64 min_size_to_sample = 4; + + // Stats regarding the limiting of insert calls. + RateLimiterCallStats insert_stats = 5; + + // Stats regarding the limiting of sample calls. + RateLimiterCallStats sample_stats = 6; +} + +message TableWorkerTime { + // Cumulative time the table worker is performing general work. + int64 running_ms = 1; + + // Cumulative time the table worker is actively processing sampling requests. + int64 sampling_ms = 2; + + // Cumulative time the table worker is actively processing insert requests. + int64 inserting_ms = 3; + + // Cumulative time the table worker is sleeping as there is no work to do + // (there are no pending insert/sample requests to process). + int64 sleeping_ms = 4; + + // Cumulative time the table worker is blocked waiting for sampling requests + // There are pending insert requests which are blocked by the rate limiter, + // while there are no sampling requests which could unblock inserts. + // The system can't make further progress and the worker is put to sleep until + // sample request arives. + int64 waiting_for_sampling_ms = 5; + + // Cumulative time the table worker is blocked waiting for insert requests + // There are pending sample requests which are blocked by the rate + // limiter, while there are no insert requests which could unblock sampling. + // The system can't make further progress and the worker is put to sleep until + // insert request arives. + int64 waiting_for_inserts_ms = 6; +} + +// Metadata about sampler or remover. Describes its configuration. +message KeyDistributionOptions { + message Prioritized { + double priority_exponent = 1; + } + + message Heap { + bool min_heap = 1; + } + + oneof distribution { + bool fifo = 1; + bool uniform = 2; + Prioritized prioritized = 3; + Heap heap = 4; + bool lifo = 6; + } + reserved 5; + bool is_deterministic = 7; +} + +// Uint128 representation. Can be used for unique identifiers. +message Uint128 { + uint64 high = 1; + uint64 low = 2; +} + +// Representation of a timeout. A value < 0 means never time out. +message Timeout { + int64 milliseconds = 1; +} diff --git a/models/main_models/rt1/rt1_env/lib64 b/models/main_models/rt1/rt1_env/lib64 new file mode 120000 index 000000000..7951405f8 --- /dev/null +++ b/models/main_models/rt1/rt1_env/lib64 @@ -0,0 +1 @@ +lib \ No newline at end of file diff --git a/models/main_models/rt1/rt1_env/pyvenv.cfg b/models/main_models/rt1/rt1_env/pyvenv.cfg new file mode 100644 index 000000000..1997c5b53 --- /dev/null +++ b/models/main_models/rt1/rt1_env/pyvenv.cfg @@ -0,0 +1,3 @@ +home = /usr/bin +include-system-site-packages = false +version = 3.9.16 diff --git a/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 b/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 new file mode 100644 index 000000000..0ff966158 --- /dev/null +++ b/models/main_models/rt1/rt1_env/share/man/man1/isympy.1 @@ -0,0 +1,188 @@ +'\" -*- coding: us-ascii -*- +.if \n(.g .ds T< \\FC +.if \n(.g .ds T> \\F[\n[.fam]] +.de URL +\\$2 \(la\\$1\(ra\\$3 +.. +.if \n(.g .mso www.tmac +.TH isympy 1 2007-10-8 "" "" +.SH NAME +isympy \- interactive shell for SymPy +.SH SYNOPSIS +'nh +.fi +.ad l +\fBisympy\fR \kx +.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) +'in \n(.iu+\nxu +[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [ +-- | PYTHONOPTIONS] +'in \n(.iu-\nxu +.ad b +'hy +'nh +.fi +.ad l +\fBisympy\fR \kx +.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) +'in \n(.iu+\nxu +[ +{\fB-h\fR | \fB--help\fR} +| +{\fB-v\fR | \fB--version\fR} +] +'in \n(.iu-\nxu +.ad b +'hy +.SH DESCRIPTION +isympy is a Python shell for SymPy. It is just a normal python shell +(ipython shell if you have the ipython package installed) that executes +the following commands so that you don't have to: +.PP +.nf +\*(T< +>>> from __future__ import division +>>> from sympy import * +>>> x, y, z = symbols("x,y,z") +>>> k, m, n = symbols("k,m,n", integer=True) + \*(T> +.fi +.PP +So starting isympy is equivalent to starting python (or ipython) and +executing the above commands by hand. It is intended for easy and quick +experimentation with SymPy. For more complicated programs, it is recommended +to write a script and import things explicitly (using the "from sympy +import sin, log, Symbol, ..." idiom). +.SH OPTIONS +.TP +\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR +Use the specified shell (python or ipython) as +console backend instead of the default one (ipython +if present or python otherwise). + +Example: isympy -c python + +\fISHELL\fR could be either +\&'ipython' or 'python' +.TP +\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR +Setup pretty printing in SymPy. By default, the most pretty, unicode +printing is enabled (if the terminal supports it). You can use less +pretty ASCII printing instead or no pretty printing at all. + +Example: isympy -p no + +\fIENCODING\fR must be one of 'unicode', +\&'ascii' or 'no'. +.TP +\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR +Setup the ground types for the polys. By default, gmpy ground types +are used if gmpy2 or gmpy is installed, otherwise it falls back to python +ground types, which are a little bit slower. You can manually +choose python ground types even if gmpy is installed (e.g., for testing purposes). + +Note that sympy ground types are not supported, and should be used +only for experimental purposes. + +Note that the gmpy1 ground type is primarily intended for testing; it the +use of gmpy even if gmpy2 is available. + +This is the same as setting the environment variable +SYMPY_GROUND_TYPES to the given ground type (e.g., +SYMPY_GROUND_TYPES='gmpy') + +The ground types can be determined interactively from the variable +sympy.polys.domains.GROUND_TYPES inside the isympy shell itself. + +Example: isympy -t python + +\fITYPE\fR must be one of 'gmpy', +\&'gmpy1' or 'python'. +.TP +\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR +Setup the ordering of terms for printing. The default is lex, which +orders terms lexicographically (e.g., x**2 + x + 1). You can choose +other orderings, such as rev-lex, which will use reverse +lexicographic ordering (e.g., 1 + x + x**2). + +Note that for very large expressions, ORDER='none' may speed up +printing considerably, with the tradeoff that the order of the terms +in the printed expression will have no canonical order + +Example: isympy -o rev-lax + +\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex', +\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'. +.TP +\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T> +Print only Python's and SymPy's versions to stdout at startup, and nothing else. +.TP +\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T> +Use the same format that should be used for doctests. This is +equivalent to '\fIisympy -c python -p no\fR'. +.TP +\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T> +Disable the caching mechanism. Disabling the cache may slow certain +operations down considerably. This is useful for testing the cache, +or for benchmarking, as the cache can result in deceptive benchmark timings. + +This is the same as setting the environment variable SYMPY_USE_CACHE +to 'no'. +.TP +\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T> +Automatically create missing symbols. Normally, typing a name of a +Symbol that has not been instantiated first would raise NameError, +but with this option enabled, any undefined name will be +automatically created as a Symbol. This only works in IPython 0.11. + +Note that this is intended only for interactive, calculator style +usage. In a script that uses SymPy, Symbols should be instantiated +at the top, so that it's clear what they are. + +This will not override any names that are already defined, which +includes the single character letters represented by the mnemonic +QCOSINE (see the "Gotchas and Pitfalls" document in the +documentation). You can delete existing names by executing "del +name" in the shell itself. You can see if a name is defined by typing +"'name' in globals()". + +The Symbols that are created using this have default assumptions. +If you want to place assumptions on symbols, you should create them +using symbols() or var(). + +Finally, this only works in the top level namespace. So, for +example, if you define a function in isympy with an undefined +Symbol, it will not work. +.TP +\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T> +Enable debugging output. This is the same as setting the +environment variable SYMPY_DEBUG to 'True'. The debug status is set +in the variable SYMPY_DEBUG within isympy. +.TP +-- \fIPYTHONOPTIONS\fR +These options will be passed on to \fIipython (1)\fR shell. +Only supported when ipython is being used (standard python shell not supported). + +Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR +from the other isympy options. + +For example, to run iSymPy without startup banner and colors: + +isympy -q -c ipython -- --colors=NoColor +.TP +\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T> +Print help output and exit. +.TP +\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T> +Print isympy version information and exit. +.SH FILES +.TP +\*(T<\fI${HOME}/.sympy\-history\fR\*(T> +Saves the history of commands when using the python +shell as backend. +.SH BUGS +The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra +Please report all bugs that you find in there, this will help improve +the overall quality of SymPy. +.SH "SEE ALSO" +\fBipython\fR(1), \fBpython\fR(1) diff --git a/models/main_models/rt1/rt1_pytorch/__init__.py b/models/main_models/rt1/rt1_pytorch/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py new file mode 100644 index 000000000..8524676fd --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_conditioning_layer.py @@ -0,0 +1,38 @@ +import torch +from torch import nn + + +class FilmConditioning(nn.Module): + def __init__(self, embedding_dim, num_channels): + super().__init__() + self._projection_add = nn.Linear(embedding_dim, num_channels) + self._projection_mult = nn.Linear(embedding_dim, num_channels) + self.num_channels = num_channels + self.embedding_dim = embedding_dim + # From the paper + nn.init.zeros_(self._projection_add.weight) + nn.init.zeros_(self._projection_mult.weight) + nn.init.zeros_(self._projection_add.bias) + nn.init.zeros_(self._projection_mult.bias) + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" + assert ( + context.shape[1] == self.embedding_dim + ), f"Unexpected context shape: {context.shape}" + assert ( + x.shape[0] == context.shape[0] + ), f"x and context must have the same batch size, but got {x.shape} and {context.shape}" + projected_cond_add = self._projection_add(context) + projected_cond_mult = self._projection_mult(context) + + if len(x.shape) == 4: + projected_cond_add = projected_cond_add.unsqueeze(2).unsqueeze(3) + projected_cond_mult = projected_cond_mult.unsqueeze(2).unsqueeze(3) + else: + assert len(x.shape) == 2 + + # Original FiLM paper argues that 1 + gamma centers the initialization at + # identity transform. + result = (1 + projected_cond_mult) * x + projected_cond_add + return result \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py new file mode 100644 index 000000000..a9c03573b --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/film_efficientnet/film_efficientnet.py @@ -0,0 +1,446 @@ +"""EfficientNet models modified with added film layers. + +Mostly taken from: +https://github.com/pytorch/vision/blob/main/torchvision/models/efficientnet.py +""" +import copy +import math +from functools import partial +from typing import Any, Callable, List, Optional, Sequence, Union + +import torch +from torch import nn +from torchvision.models._api import Weights +from torchvision.models._meta import _IMAGENET_CATEGORIES +from torchvision.models._utils import _ovewrite_named_param +from torchvision.models.efficientnet import ( + EfficientNet_B0_Weights, + EfficientNet_B1_Weights, + EfficientNet_B2_Weights, + EfficientNet_B3_Weights, + EfficientNet_B4_Weights, + EfficientNet_B5_Weights, + EfficientNet_B6_Weights, + EfficientNet_B7_Weights, + EfficientNet_V2_L_Weights, + EfficientNet_V2_M_Weights, + EfficientNet_V2_S_Weights, + FusedMBConv, + FusedMBConvConfig, + MBConv, + MBConvConfig, + _efficientnet_conf, + _MBConvConfig, +) +from torchvision.ops.misc import Conv2dNormActivation +from torchvision.utils import _log_api_usage_once + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning + + +class MBConvFilm(nn.Module): + """MBConv or FusedMBConv with FiLM context""" + + def __init__(self, embedding_dim: int, mbconv: Union[MBConv, FusedMBConv]): + super().__init__() + self.mbconv = mbconv + num_channels = mbconv.block[-1][1].num_features + self.film = FilmConditioning( + embedding_dim=embedding_dim, num_channels=num_channels + ) + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + x = self.mbconv(x) + x = self.film(x, context) + return x + + +class _FilmEfficientNet(nn.Module): + def __init__( + self, + inverted_residual_setting: Sequence[Union[MBConvConfig, FusedMBConvConfig]], + dropout: float, + include_top: bool = False, + stochastic_depth_prob: float = 0.2, + num_classes: int = 1000, + norm_layer: Optional[Callable[..., nn.Module]] = None, + last_channel: Optional[int] = None, + embedding_dim: Optional[int] = 512, + ) -> None: + """ + EfficientNet V1 and V2 main class with additional FiLM context layer + + Args: + inverted_residual_setting (Sequence[Union[MBConvConfig, FusedMBConvConfig]]): Network structure + dropout (float): The droupout probability + include_top (bool): Whether to include the classification head + stochastic_depth_prob (float): The stochastic depth probability + num_classes (int): Number of classes + norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use + last_channel (int): The number of channels on the penultimate layer + embedding_dim (int): The dimension of the embedding space + """ + super().__init__() + _log_api_usage_once(self) + + if not inverted_residual_setting: + raise ValueError("The inverted_residual_setting should not be empty") + elif not ( + isinstance(inverted_residual_setting, Sequence) + and all([isinstance(s, _MBConvConfig) for s in inverted_residual_setting]) + ): + raise TypeError( + "The inverted_residual_setting should be List[MBConvConfig]" + ) + + if norm_layer is None: + norm_layer = nn.BatchNorm2d + + layers: List[nn.Module] = [] + + # building first layer + firstconv_output_channels = inverted_residual_setting[0].input_channels + layers.append( + Conv2dNormActivation( + 3, + firstconv_output_channels, + kernel_size=3, + stride=2, + norm_layer=norm_layer, + activation_layer=nn.SiLU, + ) + ) + + # building inverted residual blocks + total_stage_blocks = sum(cnf.num_layers for cnf in inverted_residual_setting) + stage_block_id = 0 + for cnf in inverted_residual_setting: + stage: List[nn.Module] = [] + for _ in range(cnf.num_layers): + # copy to avoid modifications. shallow copy is enough + block_cnf = copy.copy(cnf) + + # overwrite info if not the first conv in the stage + if stage: + block_cnf.input_channels = block_cnf.out_channels + block_cnf.stride = 1 + + # adjust stochastic depth probability based on the depth of the stage block + sd_prob = ( + stochastic_depth_prob * float(stage_block_id) / total_stage_blocks + ) + stage.append( + MBConvFilm( + embedding_dim=embedding_dim, + mbconv=block_cnf.block(block_cnf, sd_prob, norm_layer), + ) + ) + stage_block_id += 1 + + layers.append(nn.Sequential(*stage)) + + # building last several layers + lastconv_input_channels = inverted_residual_setting[-1].out_channels + lastconv_output_channels = ( + last_channel if last_channel is not None else 4 * lastconv_input_channels + ) + layers.append( + Conv2dNormActivation( + lastconv_input_channels, + lastconv_output_channels, + kernel_size=1, + norm_layer=norm_layer, + activation_layer=nn.SiLU, + ) + ) + + self.features = nn.Sequential(*layers) + if include_top: + self.avgpool = nn.AdaptiveAvgPool2d(1) + self.classifier = nn.Sequential( + nn.Dropout(p=dropout, inplace=True), + nn.Linear(lastconv_output_channels, num_classes), + nn.Softmax(dim=1), + ) + else: + self.avgpool = nn.Identity() + self.classifier = nn.Identity() + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode="fan_out") + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): + nn.init.ones_(m.weight) + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Linear): + init_range = 1.0 / math.sqrt(m.out_features) + nn.init.uniform_(m.weight, -init_range, init_range) + nn.init.zeros_(m.bias) + + self.embedding_dim = embedding_dim + + def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + for feature in self.features: + for layer in feature: + if isinstance(layer, MBConvFilm): + x = layer(x, context) + else: + x = layer(x) + + x = self.avgpool(x) + x = torch.squeeze(x, dim=(2, 3)) # squeeze if h = w = 1 + x = self.classifier(x) + + return x + + +def get_weights(arch: str) -> Weights: + """ + Returns the default weights for the given EfficientNet model. + + Parameters: + arch (str): The EfficientNet variant to use. Allowed values are: + - 'efficientnet_b0' + - 'efficientnet_b1' + - 'efficientnet_b2' + - 'efficientnet_b3' + - 'efficientnet_b4' + - 'efficientnet_b5' + - 'efficientnet_b6' + - 'efficientnet_b7' + - 'efficientnet_v2_s' + - 'efficientnet_v2_m' + - 'efficientnet_v2_l' + + Returns: + WeightsEnum: The default weights for the given architecture. + + Raises: + ValueError: If the given architecture is not supported. + """ + + if arch == "efficientnet_b0": + weights = EfficientNet_B0_Weights.DEFAULT + elif arch == "efficientnet_b1": + weights = EfficientNet_B1_Weights.DEFAULT + elif arch == "efficientnet_b2": + weights = EfficientNet_B2_Weights.DEFAULT + elif arch == "efficientnet_b3": + weights = EfficientNet_B3_Weights.DEFAULT + elif arch == "efficientnet_b4": + weights = EfficientNet_B4_Weights.DEFAULT + elif arch == "efficientnet_b5": + weights = EfficientNet_B5_Weights.DEFAULT + elif arch == "efficientnet_b6": + weights = EfficientNet_B6_Weights.DEFAULT + elif arch == "efficientnet_b7": + weights = EfficientNet_B7_Weights.DEFAULT + elif arch == "efficientnet_v2_s": + weights = EfficientNet_V2_S_Weights.DEFAULT + elif arch == "efficientnet_v2_m": + weights = EfficientNet_V2_M_Weights.DEFAULT + elif arch == "efficientnet_v2_l": + weights = EfficientNet_V2_L_Weights.DEFAULT + else: + raise ValueError(f"Unsupported model type `{arch}`") + + return weights + + +class FilmEfficientNet(nn.Module): + def __init__( + self, + arch: str, + include_top: bool = False, + embedding_dim: int = 512, + pretrained: Optional[bool] = True, + weights: Optional[Weights] = None, + progress: Optional[bool] = True, + device: Optional[Union[str, torch.device]] = "cuda", + **kwargs, + ): + """Builds a FilmEfficientNet model. + + Args: + arch (str): The EfficientNet variant to use. Allowed values are: + - 'efficientnet_b0' + - 'efficientnet_b1' + - 'efficientnet_b2' + - 'efficientnet_b3' + - 'efficientnet_b4' + - 'efficientnet_b5' + - 'efficientnet_b6' + - 'efficientnet_b7' + - 'efficientnet_v2_s' + - 'efficientnet_v2_m' + - 'efficientnet_v2_l' + include_top (bool, optional): Whether to include the classification head + embedding_dim (int, optional): The dimensionality of the output embeddings. + pretrained (bool, optional): Whether to load pretrained EfficientNet weights. + Defaults to True. + weights (WeightsEnum, optional): The pretrained weights to use. + only allowed if `pretrained==False`. Defaults to None. + progress (bool, optional): If True, displays a progress bar of the + download to stderr. Default is True. + device (torch.device, optional): The device on which the model will be + **kwargs: parameters passed to the `FilmEfficientNet` class. + """ + super().__init__() + norm_layer = None + if arch == "efficientnet_b0": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.0, depth_mult=1.0 + ) + dropout = 0.2 + self.output_hw = 7 + elif arch == "efficientnet_b1": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.0, depth_mult=1.1 + ) + dropout = 0.2 + self.output_hw = 8 + elif arch == "efficientnet_b2": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.1, depth_mult=1.2 + ) + dropout = 0.3 + self.output_hw = 9 + elif arch == "efficientnet_b3": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.2, depth_mult=1.4 + ) + dropout = 0.3 + self.output_hw = 10 + elif arch == "efficientnet_b4": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.4, depth_mult=1.8 + ) + dropout = 0.4 + self.output_hw = 12 + elif arch == "efficientnet_b5": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.6, depth_mult=2.2 + ) + dropout = 0.4 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 15 + elif arch == "efficientnet_b6": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=1.8, depth_mult=2.6 + ) + dropout = 0.5 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 17 + elif arch == "efficientnet_b7": + inverted_residual_setting, last_channel = _efficientnet_conf( + arch, width_mult=2.0, depth_mult=3.1 + ) + dropout = 0.5 + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) + self.output_hw = 20 + elif arch == "efficientnet_v2_s": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.2 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 12 + elif arch == "efficientnet_v2_m": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.3 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 15 + elif arch == "efficientnet_v2_l": + inverted_residual_setting, last_channel = _efficientnet_conf(arch) + dropout = 0.4 + norm_layer = partial(nn.BatchNorm2d, eps=1e-03) + self.output_hw = 15 + + assert ( + weights is None or not pretrained + ), "Cannot pass in custom weights with pretrained=True" + weights = get_weights(arch) if pretrained else weights + + if weights is not None: + _ovewrite_named_param( + kwargs, "num_classes", len(weights.meta["categories"]) + ) + + model = _FilmEfficientNet( + inverted_residual_setting, + dropout, + include_top=include_top, + last_channel=last_channel, + norm_layer=norm_layer, + embedding_dim=embedding_dim, + **kwargs, + ) + + if weights is not None: + state_dict = weights.get_state_dict(progress=progress) + new_state_dict = {} + for k, v in state_dict.items(): + if ".block" in k: + new_state_dict[k.replace(".block", ".mbconv.block")] = v + else: + new_state_dict[k] = v + model.load_state_dict( + new_state_dict, + strict=False, + ) + + self.model = model.to(device) + self.preprocess = weights.transforms(antialias=True) if weights else lambda x: x + + self.conv1x1 = nn.Conv2d( + in_channels=self.model.features[-1].out_channels, + out_channels=embedding_dim, + kernel_size=(1, 1), + stride=(1, 1), + padding="same", + bias=False, + device=device, + ) + nn.init.kaiming_normal_(self.conv1x1.weight) + self.film_layer = FilmConditioning(embedding_dim, embedding_dim).to(device) + self.include_top = include_top + self.embedding_dim = embedding_dim + + def forward( + self, image: torch.Tensor, context: Optional[torch.Tensor] = None + ) -> torch.Tensor: + if len(image.shape) == 3: + # Add batch dimension + image = image.unsqueeze(0) + assert len(image.shape) == 4, f"Unexpected image shape: {image.shape}" + if image.shape[-1] == 3: + # (B, H, W, C) -> (B, C, H, W) + image = image.permute(0, 3, 1, 2) + if torch.max(image) >= 1.0: + # Normalize to [0, 1] + image = image / 255.0 + assert torch.min(image) >= 0.0 and torch.max(image) <= 1.0 + image = self.preprocess(image) + + if context is not None and self.include_top: + raise ValueError("Context cannot be passed in if include_top=True") + elif context is None: + context = torch.zeros( + image.shape[0], self.embedding_dim, device=image.device + ) + + features = self.model(image, context) + if not self.include_top: + features = self.conv1x1(features) + features = self.film_layer(features, context) + return features + + +def decode_predictions(preds: torch.Tensor, top=5): + preds = preds.detach().cpu().numpy() + results = [] + for pred in preds: + top_indices = pred.argsort()[-top:][::-1] + result = [(_IMAGENET_CATEGORIES[i], pred[i]) for i in top_indices] + results.append(result) + return results \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/rt1_model.py b/models/main_models/rt1/rt1_pytorch/rt1_model.py new file mode 100644 index 000000000..30388f638 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/rt1_model.py @@ -0,0 +1,217 @@ +from typing import Optional + +import torch +from einops import rearrange +from torch import nn + +from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer + + +def posemb_sincos_1d(seq, dim, temperature=10000, device=None, dtype=torch.float32): + """ + Generate positional embeddings using sine and cosine functions for a 1-dimensional sequence. + + Parameters: + seq (int): The length of the sequence. + dim (int): The dimension of the positional embeddings. + temperature (float, optional): The temperature parameter for the sine function. Defaults to 10000. + device (torch.device, optional): The device for tensor operations. Defaults to None. + dtype (torch.dtype, optional): The data type of the positional embeddings. Defaults to torch.float32. + + Returns: + torch.Tensor: The positional embeddings of shape (seq, dim), with each element computed as the concatenation of the sine and cosine values. + + """ + n = torch.arange(seq, device=device) + omega = torch.arange(dim // 2, device=device) / (dim // 2 - 1) + omega = 1.0 / (temperature**omega) + + n = n[:, None] * omega[None, :] + pos_emb = torch.cat((n.sin(), n.cos()), dim=1) + return pos_emb.type(dtype) + + +# Robotic Transformer +class RT1Model(nn.Module): + def __init__( + self, + arch: str = "efficientnet_b3", + tokens_per_action=11, + action_bins=256, + num_layers=4, + num_heads=8, + feed_forward_size=512, + dropout_rate=0.1, + time_sequence_length=6, + embedding_dim=512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + device="cuda", + ): + """ + Initializes the RT1Model. + + Parameters: + arch (str): The efficientnet variant to use. Default is "efficientnet_b3". + tokens_per_action (int): The number of tokens per action. Default is 11. + action_bins (int): The number of action bins. Default is 256. + num_layers (int): The number of transformer layers. Default is 6. + num_heads (int): The number of attention heads. Default is 8. + feed_forward_size (int): The size of the feed-forward layer. Default is 512. + dropout_rate (float): The dropout rate. Default is 0.1. + time_sequence_length (int): The length of the time sequence. Default is 6. + embedding_dim (int): The dimension of the embedding. Default is 512. + use_token_learner (bool): Whether to use token learner. Default is True. + token_learner_bottleneck_dim (int): The dimension of the token learner bottleneck. Default is 64. + token_learner_num_output_tokens (int): The number of output tokens of the token learner. Default is 8. + device (torch.device, optional): The device for tensor operations. Defaults to "cuda". + + Returns: + None + """ + super().__init__() + self.time_sequence_length = time_sequence_length + self.action_encoder = nn.Linear(action_bins, embedding_dim, device=device) + self.image_tokenizer = RT1ImageTokenizer( + arch=arch, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_bottleneck_dim=token_learner_bottleneck_dim, + token_learner_num_output_tokens=token_learner_num_output_tokens, + dropout_rate=dropout_rate, + device=device, + ) + + self.num_tokens = self.image_tokenizer.num_output_tokens + + self.transformer = nn.Transformer( + d_model=embedding_dim, + nhead=num_heads, + num_encoder_layers=num_layers, + num_decoder_layers=num_layers, + dim_feedforward=feed_forward_size, + dropout=dropout_rate, + activation="gelu", + batch_first=True, + device=device, + ) + + self.to_logits = nn.Sequential( + nn.LayerNorm(embedding_dim), + nn.Linear(embedding_dim, action_bins), + ).to(device) + + self.tokens_per_action = tokens_per_action + self.action_bins = action_bins + self.embedding_dim = embedding_dim + self.device = device + + def forward( + self, + videos: torch.Tensor, + texts: Optional[torch.Tensor] = None, + action_logits: Optional[torch.Tensor] = None, + ): + """ + Forward pass of the model. + + Args: + videos (torch.Tensor): The input videos. + Shape is (b, f, h, w, c) or (b, f, c, h, w). + texts (Optional[torch.Tensor]): The input text embedding. + Shape is (b, f, embedding_dim). + action_logits (Optional[torch.Tensor]): The input action_logits. + Shape is (b, f, tokens_per_action, action_bins). + + Returns: + torch.Tensor: The output logits. + Shape is (b, f, tokens_per_action, action_bins). + """ + b, f, *_ = videos.shape + assert ( + f == self.time_sequence_length + ), f"Expected {self.time_sequence_length} frames, got videos.shape[1] = {f}" + + if texts is None: + texts = torch.zeros((b, f, self.embedding_dim), device=self.device) + if action_logits is None: + action_logits = torch.zeros( + (b, f, self.tokens_per_action, self.action_bins), device=self.device + ) + elif action_logits.shape != (b, f, self.tokens_per_action, self.action_bins): + raise ValueError( + f"""Expected action_logits.shape = (b, f, tokens_per_action, action_bins), + got {action_logits.shape}; did you pass in raw actions instead?""" + ) + + # pack time dimension into batch dimension + videos = rearrange(videos, "b f ... -> (b f) ...") + texts = rearrange(texts, "b f d -> (b f) d") + + # tokenize images and texts + tokens = self.image_tokenizer(videos, texts) + + # unpack time dimension from batch dimension + tokens = rearrange(tokens, "(b f) c n -> b f c n", b=b, f=f) + + # pack time dimension into token dimension + tokens = rearrange(tokens, "b f c n -> b (f n) c") + action_logits = rearrange(action_logits, "b f a d -> b (f a) d") + + # sinusoidal positional embedding + pos_emb = posemb_sincos_1d(tokens.shape[1], tokens.shape[2], device=self.device) + tokens = tokens + pos_emb + + # causal mask for tokens + token_mask = torch.ones( + tokens.shape[1], tokens.shape[1], dtype=torch.bool + ).tril(0) + token_mask = ~token_mask + token_mask = token_mask.to(self.device) + + # encode action_logits to have the same embedding dimension as tokens + action_tokens = self.action_encoder(action_logits) + + pos_emb = posemb_sincos_1d( + action_tokens.shape[1], action_tokens.shape[2], device=self.device + ) + action_tokens = action_tokens + pos_emb + + # action mask: do not let action_logits attend to previous action_logits, + # a_t is independent of a_{t-1} given pi and s_t + action_mask = torch.ones( + self.time_sequence_length, self.time_sequence_length, dtype=torch.bool + ).tril(0) + action_mask = torch.kron( + torch.eye(self.tokens_per_action, self.tokens_per_action, dtype=torch.bool), + action_mask, + ) + action_mask = ~action_mask + action_mask = action_mask.to(self.device) + + # causal mask between tokens and action_logits; + # a_t attends to s_t' for all t'<=t + memory_mask = torch.ones( + self.time_sequence_length, self.time_sequence_length, dtype=torch.bool + ).tril(0) + memory_mask = torch.kron( + memory_mask, + torch.ones(self.tokens_per_action, self.num_tokens, dtype=torch.bool), + ) + memory_mask = ~memory_mask + memory_mask = memory_mask.to(self.device) + + attended_tokens = self.transformer( + src=tokens, + src_mask=token_mask, + tgt=action_tokens, + tgt_mask=action_mask, + memory_mask=memory_mask, + ) + + # unpack time dimension from token dimension + attended_tokens = rearrange(attended_tokens, "b (f n) c -> b f n c", b=b, f=f) + + logits = self.to_logits(attended_tokens) + return logits \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/rt1_policy.py b/models/main_models/rt1/rt1_pytorch/rt1_policy.py new file mode 100644 index 000000000..f68155a56 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/rt1_policy.py @@ -0,0 +1,234 @@ +from typing import Dict, List, Optional, Tuple, Union + +import gymnasium as gym +import numpy as np +import torch +import tree +from einops import rearrange +from torch.nn import functional as F +import pdb + +from rt1_pytorch.rt1_model import RT1Model +from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer + + +class RT1Policy: + def __init__( + self, + observation_space: gym.spaces.Dict, + action_space: gym.spaces.Dict, + arch: str = "efficientnet_b3", + action_bins=256, + num_layers=4, + num_heads=8, + feed_forward_size=256, + dropout_rate=0.1, + time_sequence_length=6, + embedding_dim=512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + device="cuda", + checkpoint_path: Optional[str] = None, + ): + """ + Initializes an instance of the class. + + Args: + observation_space (gym.spaces.Dict): The observation space of the environment. + action_space (gym.spaces.Dict): The action space of the environment. + arch (str, optional): The architecture of the model. Defaults to "efficientnet_b3". + action_bins (int, optional): The number of bins for discretizing continuous action spaces. Defaults to 256. + num_layers (int, optional): The number of transformer layers in the model. Defaults to 8. + num_heads (int, optional): The number of attention heads in each transformer layer. Defaults to 8. + feed_forward_size (int, optional): The size of the feed-forward layer in the transformer. Defaults to 256. + dropout_rate (float, optional): The dropout rate for the transformer layers. Defaults to 0.1. + time_sequence_length (int, optional): The length of the time sequence for the model. Defaults to 6. + embedding_dim (int, optional): The dimensionality of the input embeddings. Defaults to 512. + use_token_learner (bool, optional): Whether to use the token learner module. Defaults to True. + token_learner_bottleneck_dim (int, optional): The dimensionality of the bottleneck layer in the token learner. Defaults to 64. + token_learner_num_output_tokens (int, optional): The number of output tokens from the token learner. Defaults to 8. + device (str, optional): The device to use for the model. Defaults to "cuda". + checkpoint_path (str, optional): load checkpoint from path. Defaults to None. + + Returns: + None + """ + self.observation_space = observation_space + self.action_space = action_space + self.action_bins = action_bins + self.action_tokenizer = RT1ActionTokenizer( + action_space=action_space, + action_bins=action_bins, + action_order=list(action_space.keys()), + ) + + self.model = RT1Model( + arch=arch, + tokens_per_action=self.action_tokenizer.tokens_per_action, + action_bins=action_bins, + num_layers=num_layers, + num_heads=num_heads, + feed_forward_size=feed_forward_size, + dropout_rate=dropout_rate, + time_sequence_length=time_sequence_length, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_bottleneck_dim=token_learner_bottleneck_dim, + token_learner_num_output_tokens=token_learner_num_output_tokens, + device=device, + ) + + self.embedding_dim = embedding_dim + + for action_space in self.action_space.values(): + if ( + isinstance(action_space, gym.spaces.Discrete) + and action_space.n == time_sequence_length + ): + raise ValueError( + f"""stupid hack:Time sequence length ({time_sequence_length}) + must be different from action space length ({action_space.n}).""" + ) + + self.device = device + if checkpoint_path is not None: + print(f"Loading checkpoint from {checkpoint_path}...") + self.model.load_state_dict(torch.load(checkpoint_path)) + + def preprocess( + self, + videos: Union[np.ndarray, List[np.ndarray]], + texts: Union[np.ndarray, List[np.ndarray]], + actions: Optional[Dict] = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Preprocesses the given videos, texts, and actions. + + Args: + videos (Union[np.ndarray, List[np.ndarray]]): The input videos to preprocess. + shape: (b, t, c, h, w) or (b, t, h, w, c) + texts (Union[np.ndarray, List[np.ndarray]]): The input texts to preprocess. + shape: (b, t, d) + actions (Optional[Dict]): The input actions to preprocess. Defaults to None. + shape: (b, t, a) + + Returns: + Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: A tuple containing the preprocessed videos, texts, and actions. + """ + if isinstance(videos, torch.Tensor): + videos = videos.to(self.device) + elif not isinstance(videos, np.ndarray): + videos = np.stack(videos, axis=0) + + if not isinstance(videos, torch.Tensor): + videos = torch.tensor(videos, device=self.device, dtype=torch.float32) + + if isinstance(texts, torch.Tensor): + texts = texts.to(self.device) + elif not isinstance(texts, np.ndarray): + texts = np.stack(texts, axis=0) + if not isinstance(texts, torch.Tensor): + texts = torch.tensor(texts, device=self.device, dtype=torch.float32) + + + if actions is not None: + actions = { + k: np.stack(v, axis=0) if not (isinstance(v, np.ndarray)) else v + for k, v in actions.items() + } + + + actions = tree.map_structure( + lambda a: rearrange(a, "b f ... -> (b f) ..."), actions + ) + actions = self.action_tokenizer.tokenize(actions) + actions = torch.tensor(actions, device=self.device, dtype=torch.long) + actions = rearrange(actions, "(b f) ... -> b f ...", b=videos.shape[0]) + + return videos, texts, actions + + def forward( + self, + videos: torch.Tensor, + texts: torch.Tensor, + action_logits: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Forward pass through the model. + + Args: + videos (torch.Tensor): Input videos. + texts (torch.Tensor): input contexts. + action_logits (Optional[torch.Tensor]): Optional input action logits. + + Returns: + action_logits (Tuple[torch.Tensor, torch.Tensor]): + A tuple containing the sampled actions and the action logits. + """ + action_logits = self.model(videos, texts, action_logits) + actions = torch.distributions.Categorical(logits=action_logits) + actions = actions.sample() + return actions, action_logits + + def loss(self, observations: Dict, target_actions: Dict) -> torch.Tensor: + """ + Calculates the loss function for the given inputs. + + Args: + observations (Dict): A dictionary containing the observations. + It should have the following keys: + - "image" (np.ndarray): The video observations. + - "context" (np.ndarray): The context. + target_actions (Dict): A dictionary containing the target actions. + + Returns: + torch.Tensor: The calculated loss value. + + Raises: + None + """ + videos = observations["image"] + texts = observations["context"] + videos, texts, target_actions = self.preprocess( + videos, + texts, + target_actions, + ) + _, action_logits = self.forward(videos, texts) + + action_logits = rearrange(action_logits, "b f a d -> (b f a) d") + target_actions = rearrange(target_actions, "b f a -> (b f a)") + loss = F.cross_entropy(action_logits, target_actions, reduction="sum") + loss = loss / videos.shape[0] + + + dummy_loss = F.cross_entropy(action_logits, target_actions, reduction="none") + loss_std = torch.std(dummy_loss) + + return loss, loss_std + + def act(self, observations: Dict) -> Dict[str, np.ndarray]: + """ + Performs an action based on the given observations. + Note that this takes in observations of shape (b,t, ...) + but only returns the last action for each trajectory of shape (b, ...). + + Args: + observations (Dict): A dictionary containing the observations. It should have the following keys: + - "image" (np.ndarray): The video observations. + - "context" (np.ndarray): The context. + + Returns: + Dict[str, np.ndarray]: A dictionary containing the actions. It has the following keys: + - "actions" (np.ndarray): The actions performed based on the observations. + """ + videos = observations["image"] + texts = observations["context"] + videos, texts, _ = self.preprocess(videos, texts) + with torch.no_grad(): + actions, _ = self.forward(videos, texts) + actions = actions.detach().cpu().numpy() + actions = self.action_tokenizer.detokenize(actions) + actions = tree.map_structure(lambda a: a[:, -1], actions) + return actions diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py b/models/main_models/rt1/rt1_pytorch/tokenizers/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py b/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py new file mode 100644 index 000000000..542aa6ec3 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/tokenizers/action_tokenizer.py @@ -0,0 +1,184 @@ +"""A simple action tokenizer used with Robotics Transformer 1. + +As an example, if an action is: +{ + 'base_displacement_vector': + , + 'base_displacement_vertical_rotation': + , + 'gripper_closedness_action': + , + 'rotation_delta': + , + 'terminate_episode': + , + 'world_vector': + +} + +Then we build a sequence of tokens of length 11 [one for each dimension]. +The int32 type action dimensions are already tokenized, +the float dimensions are bucketed according to the spaces min and max. Each +dimension has 'action_bins' buckets. + +Currently, this tokenizer assumes one action space and it is highly recommended +to spaceify the 'action_order', i.e. the order of keys in the dict. +Since after tokenization you lose that information, this +will be useful for debugging. Actions may also be subselected for prediction, +since not all actions are needed in the action_order. +""" +from typing import Dict, Optional + +import gymnasium as gym +import numpy as np +from gymnasium.spaces import Box, Discrete +import pdb + +class RT1ActionTokenizer: + """Tokenizes based on vocab size.""" + + def __init__( + self, + action_space: gym.spaces.Dict, + action_bins: int, + action_order: Optional[list[str]] = None, + ): + """Instantiates an RT1ActionTokenizer. + + Args: + action_bins: Number of buckets to discretize action to. + action_order: Order of the action names, used to discern the order of + tokenized actions to detokenize and assemble back to action tensor + """ + self._action_bins = action_bins + + # filter the action keys + lanmp_keys = ['terminate_episode', 'pickup_release', 'body_position_delta', 'body_yaw_delta','body_pitch_delta','arm_position_delta','control_mode'] + bridge_keys = ['terminate_episode','world_vector', 'open_gripper', "rotation_delta"] + jaco_keys = ['terminate_episode','world_vector', 'gripper_closedness_action'] + + #NOTE: change both lines below to the specific dataset keys + action_order = lanmp_keys #bridge_keys #jaco_keys + action_space = {key: action_space[key] for key in lanmp_keys if key in set(action_space.keys())} + self._action_space = action_space + if action_order is None: + self._action_order = list(action_space.keys()) + else: + for action in action_order: + assert ( + action in action_space.keys() + ), f"action: {action} not in action_space: {action_space.keys()}" + self._action_order = action_order + self._tokens_per_action = 0 + for action in self._action_order: + action_shape = action_space[action].shape + if isinstance(action_space, gym.spaces.Box) and len(action_shape) != 1: + raise ValueError( + f"Only action shapes with single dimension supported, got {action_shape}" + ) + if isinstance(action_space[action], Discrete): + # Int32 actions are already assumed to be tokens. + self._tokens_per_action += 1 + elif isinstance(action_space[action], Box): + if len(action_shape) != 1: + raise ValueError( + f"Only action shapes with single dimension supported, got {action_shape}" + ) + self._tokens_per_action += action_shape[0] + else: + raise ValueError( + f"Unsupported action space: {type(action_space[action])}" + ) + + # We measure # of action tokens in two different way. One is by checking + # from action_order (above) and the other is by looping through the + # action space (below). We aseert the # of action tokens are the same + # calculated by these two ways. This will assure action_order is correctly + # configured, otherwise, it will throw an error in the assert. + num_action_token = 0 + for space in action_space.values(): + if space.dtype == np.int_: + num_action_token += 1 + else: + num_action_token += space.shape[-1] + assert ( + self._tokens_per_action == num_action_token + ), f"{self._tokens_per_action} != {num_action_token}" + + @property + def tokens_per_action(self) -> int: + return self._tokens_per_action + + @property + def action_space(self) -> gym.spaces.Dict: + return self._action_space + + @property + def action_order(self) -> list[str]: + return self._action_order + + def tokenize(self, action: Dict) -> np.ndarray: + """Tokenizes an action.""" + + action_tokens = [] + for k in self._action_order: + #print("k equals " + str(k)) + #print(action.keys()) + #print(action) + act = action[k] # a is [batch, (time), action_size] + space = self._action_space[k] + if isinstance(space, gym.spaces.Discrete): + # Int32 actions are already assumed to be tokens + if not (isinstance(act, np.ndarray)): + act = np.array(act, dtype=np.int32) + act = np.expand_dims(act, axis=-1) + if not np.all(act < space.n): + raise ValueError(f"Invalid action: {act} >= {space.n}") + token = act + elif isinstance(space, gym.spaces.Box): + low = space.low[0] + high = space.high[0] + act = np.clip(act, low, high) + # Normalize the action [batch, actions_size] + token = (act - low) / (high - low) + # Bucket and discretize the action to action_bins, [batch, actions_size] + token = (token * (self._action_bins - 1)).astype(np.int32) + #TODO: bridge + if k == 'open_gripper': + token = token[:,None] + action_tokens.append(token) + #print(k, token.shape) + # Append all actions, [batch, (time), all_actions_size] + action_tokens = np.concatenate(action_tokens, axis=-1) + return action_tokens + + def detokenize(self, action_tokens: np.ndarray) -> Dict: + """Detokenizes an action.""" + action = {} + token_index = 0 + if not action_tokens.shape[-1] == self._tokens_per_action: + action_tokens = action_tokens.reshape( + *action_tokens.shape[:-1], self._tokens_per_action + ) + for k in self._action_order: + space = self._action_space[k] + if isinstance(space, gym.spaces.Discrete): + # Int32 actions are already assumed to be tokens. + action[k] = action_tokens[..., token_index] + # A poor model may output tokens outside the allowed range, in that case + # set them to a default value, the 0 token in this case. + action[k] = np.where( + action[k] >= space.n, np.zeros_like(action[k]), action[k] + ) + token_index += 1 + elif isinstance(space, gym.spaces.Box): + actions = [] + for _ in range(space.shape[0]): + a = action_tokens[..., token_index : token_index + 1] + a = a.astype(np.float32) + a = a / (self._action_bins - 1) + a = (a * (space.high[0] - space.low[0])) + space.low[0] + actions.append(a) + token_index += 1 + action[k] = np.concatenate(actions, axis=-1) + return action diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py b/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py new file mode 100644 index 000000000..9cf4cdcb0 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/tokenizers/image_tokenizer.py @@ -0,0 +1,77 @@ +"""The image tokenizer combining the FiLMEfficientNet and TokenLearner from RT1. +""" +import torch +from torch import nn + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning +from rt1_pytorch.film_efficientnet.film_efficientnet import FilmEfficientNet +from rt1_pytorch.tokenizers.token_learner import TokenLearner + + +class RT1ImageTokenizer(nn.Module): + """Tokenizes based on vocab size.""" + + def __init__( + self, + arch: str = "efficientnet_b3", + embedding_dim: int = 512, + use_token_learner=True, + token_learner_bottleneck_dim=64, + token_learner_num_output_tokens=8, + dropout_rate=0.1, + device="cuda", + ): + """Instantiates a RT1ImageTokenizer. + + Args: + arch: The efficientnet variant to use. + embedding_dim: The embedding size of the tokens. + use_token_learner: Whether to use token learner. See + https://arxiv.org/abs/2106.11297 + num_tokens: Relevant only for token learner - the number of learned + tokens. + token_learner_bottleneck_dim: Relevant only for token learner - the + dimension of the bottleneck layer. + token_learner_num_output_tokens: Relevant only for token learner - + the number of output tokens. + dropout_rate: Relevant only for token learner - the dropout rate. + device: The device to place the model on. + """ + super().__init__() + + self.film_efficientnet = FilmEfficientNet( + arch=arch, embedding_dim=embedding_dim, device=device + ) + self.num_output_tokens = self.film_efficientnet.output_hw**2 + + self._use_token_learner = use_token_learner + if self._use_token_learner: + self._token_learner = TokenLearner( + embedding_dim=embedding_dim, + num_tokens=token_learner_num_output_tokens, + bottleneck_dim=token_learner_bottleneck_dim, + dropout_rate=dropout_rate, + device=device, + ) + self.num_output_tokens = token_learner_num_output_tokens + + def forward(self, image: torch.Tensor, context: torch.Tensor) -> torch.Tensor: + """Gets image tokens. + + Args: + image: Images of shape (b, h, w, 3) to tokenize. + context: A context vector (e.g., a natural language embedding). + Expected to have shape (b, embedding_dim). + + Returns: + tokens: has shape (batch, num_tokens_per_timestep, embedding_dim) + """ + assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" + + tokens = self.film_efficientnet(image, context) + if len(tokens.shape) == 4: + # (b, c, h, w) -> (b, c, h*w) + tokens = tokens.reshape(tokens.shape[0], tokens.shape[1], -1) + if self._use_token_learner: + tokens = self._token_learner(tokens) + return tokens \ No newline at end of file diff --git a/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py b/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py new file mode 100644 index 000000000..8e04a4c30 --- /dev/null +++ b/models/main_models/rt1/rt1_pytorch/tokenizers/token_learner.py @@ -0,0 +1,89 @@ +"""Pytorch implementation of TokenLearner(Ryoo et al 2021).""" + +import torch +from torch import nn + + +class MlpBlock(nn.Module): + """Transformer MLP / feed-forward block.""" + + def __init__( + self, + input_dim: int, + mlp_dim: int, + out_dim: int, + dropout_rate: float = 0.1, + device="cuda", + ): + """Initializer for the MLP Block. + + This computes outer_dense(gelu(hidden_dense(input))), with dropout + applied as necessary. + + Args: + input_dim: The dimension of the input. + mlp_dim: The dimension of the inner representation (output of hidden + layer). Usually larger than the input/output dim. + out_dim: The output dimension of the block. + dropout_rate: Dropout rate to be applied after dense ( & activation) + layers. + device: The device to place the model on. + """ + super().__init__() + self._hidden_dropout = nn.Dropout(dropout_rate) + self._output_dropout = nn.Dropout(dropout_rate) + self._hidden_layer = nn.Linear(input_dim, mlp_dim, device=device) + self._output_layer = nn.Linear(mlp_dim, out_dim, device=device) + nn.init.xavier_uniform_(self._hidden_layer.weight) + nn.init.xavier_uniform_(self._output_layer.weight) + nn.init.normal_(self._hidden_layer.bias, std=1e-6) + nn.init.normal_(self._output_layer.bias, std=1e-6) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + """Applies Transformer MlpBlock module.""" + x = self._hidden_layer(inputs) + x = nn.functional.gelu(x) + x = self._hidden_dropout(x) + x = self._output_layer(x) + x = self._output_dropout(x) + return x + + +class TokenLearner(nn.Module): + """TokenLearner module V1.1 (https://arxiv.org/abs/2106.11297).""" + + def __init__( + self, + embedding_dim: int, + num_tokens: int, + bottleneck_dim: int = 64, + dropout_rate: float = 0.0, + device="cuda", + ): + super().__init__() + + self.layernorm = nn.LayerNorm(embedding_dim, eps=1e-6, device=device) + self.mlp = MlpBlock( + input_dim=embedding_dim, + mlp_dim=bottleneck_dim, + out_dim=num_tokens, + dropout_rate=dropout_rate, + device=device, + ) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + if len(inputs.shape) == 4: + bs, c, h, w = inputs.shape + inputs = torch.reshape(inputs, [bs, c, h * w]) + inputs = inputs.permute(0, 2, 1) # Shape: [bs, h*w, c] + + selected = self.layernorm(inputs) + + selected = self.mlp(selected) # Shape: [bs, h*w, n_token]. + selected = nn.functional.softmax(selected, dim=-1) + selected = selected.permute(0, 2, 1) # Shape: [bs, n_token, h*w] + + feat = torch.einsum("...si,...id->...sd", selected, inputs) + feat = feat.permute(0, 2, 1) + + return feat # Shape: [bs, c, n_token] \ No newline at end of file diff --git a/models/main_models/rt1/setup.py b/models/main_models/rt1/setup.py new file mode 100644 index 000000000..4c3290111 --- /dev/null +++ b/models/main_models/rt1/setup.py @@ -0,0 +1,44 @@ +from setuptools import find_packages, setup + +setup( + name="rt1-pytorch", + packages=find_packages(exclude=[]), + version="0.1.0", + license="MIT", + description="PyTorch implementation of the RT-1.", + author="Rohan Potdar", + author_email="rohanpotdar138@gmail.com", + long_description_content_type="text/markdown", + url="https://github.com/Rohan138/rt1-pytorch", + keywords=[ + "artificial intelligence", + "deep learning", + "transformers", + "attention mechanism", + "robotics", + ], + install_requires=[ + "torch>=1.9", + "scikit-image", + "sentence-transformers", + "tensorflow", + "tensorflow_datasets", + "transformers", + "gymnasium[mujoco]", + "dm-reverb", + "dm-control", + "rlds", + "einops", + "dmc2gymnasium@git+https://github.com/imgeorgiev/dmc2gymnasium.git", + "h5py", + "wandb", + "tqdm", + ], + classifiers=[ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.6", + ], +) \ No newline at end of file diff --git a/models/main_models/rt1/tests/action_tokenizer_test.py b/models/main_models/rt1/tests/action_tokenizer_test.py new file mode 100644 index 000000000..6b082840b --- /dev/null +++ b/models/main_models/rt1/tests/action_tokenizer_test.py @@ -0,0 +1,166 @@ +"""Tests for action_tokenizer.""" +import unittest + +import numpy as np +from gymnasium.spaces import Box, Dict, Discrete + +from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer + + +class ActionTokenizerTest(unittest.TestCase): + def testTokenize_int32(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(1, tokenizer.tokens_per_action) + action = dict(terminate_episode=np.array([1], dtype=np.int32)) + action_tokens = tokenizer.tokenize(action) + self.assertEqual(action["terminate_episode"], action_tokens) + + def testTokenize_int32_out_of_bounds(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(1, tokenizer.tokens_per_action) + action = dict(terminate_episode=np.array([3], dtype=np.int32)) + with self.assertRaises(ValueError): + tokenizer.tokenize(action) + + def testDetokenize_int32(self): + action_space = Dict(terminate_episode=Discrete(2)) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + action = tokenizer.detokenize(np.array([0], dtype=np.int32)) + self.assertEqual(action["terminate_episode"], np.array([0])) + # OOV 3 token should become a default one hot: [1, 0] + action = tokenizer.detokenize(np.array([3], dtype=np.int32)) + self.assertEqual(action["terminate_episode"], np.array([0])) + + def testTokenize_float(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(3, tokenizer.tokens_per_action) + action = dict(world_vector=[0.1, 0.5, -0.8]) + action_tokens = tokenizer.tokenize(action) + self.assertSequenceEqual([4, 6, 0], list(action_tokens.tolist())) + + def testTokenize_float_with_time_dimension(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=10) + self.assertEqual(3, tokenizer.tokens_per_action) + batch_size = 2 + time_dimension = 3 + action = dict( + world_vector=np.array( + [ + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + [0.1, 0.5, -0.8], + ], + ).reshape((batch_size, time_dimension, 3)), + ) + action_tokens = tokenizer.tokenize(action) + self.assertSequenceEqual( + [batch_size, time_dimension, tokenizer.tokens_per_action], + action_tokens.shape, + ) + + def testTokenize_float_at_limits(self): + minimum = -1.0 + maximum = 1.0 + action_bins = 10 + action_space = Dict( + world_vector=Box(low=minimum, high=maximum, shape=(2,), dtype=np.float32) + ) + tokenizer = RT1ActionTokenizer(action_space, action_bins=action_bins) + self.assertEqual(2, tokenizer.tokens_per_action) + action = dict(world_vector=[minimum, maximum]) + action_tokens = tokenizer.tokenize(action) + # Minimum value will go to 0 + # Maximum value witll go to action_bins-1 + self.assertSequenceEqual([0, action_bins - 1], action_tokens.tolist()) + + def testTokenize_invalid_action_space_shape(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(2, 2), dtype=np.float32) + ) + with self.assertRaises(ValueError): + RT1ActionTokenizer(action_space, action_bins=10) + + def testTokenizeAndDetokenizeIsEqual(self): + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + rotation_delta=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + gripper_closedness_action=Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=Discrete(3), + ) + + tokenizer = RT1ActionTokenizer( + action_space, + action_bins=256, + action_order=[ + "terminate_episode", + "world_vector", + "rotation_delta", + "gripper_closedness_action", + ], + ) + self.assertEqual(8, tokenizer.tokens_per_action) + + # Repeat the following test N times with fuzzy inputs. + n_repeat = 10 + for _ in range(n_repeat): + action = dict( + world_vector=np.random.uniform(low=-1.0, high=1.0, size=3), + rotation_delta=np.random.uniform( + low=-np.pi / 2.0, high=np.pi / 2.0, size=3 + ), + gripper_closedness_action=np.random.uniform(low=0.0, high=1.0, size=1), + terminate_episode=np.array(0, dtype=np.int32), + ) + action_tokens = tokenizer.tokenize(action) + policy_action = tokenizer.detokenize(action_tokens) + + for k in action: + self.assertTrue( + np.allclose(action[k], policy_action[k], atol=1e-1), + f"Failed at {k} with {action[k]} != {policy_action[k]}.", + ) + + # Repeat the test with batched actions + batched_action = dict( + world_vector=[ + np.random.uniform(low=-1.0, high=1.0, size=3), + np.random.uniform(low=-1.0, high=1.0, size=3), + ], + rotation_delta=[ + np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), + np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), + ], + gripper_closedness_action=[ + np.random.uniform(low=0.0, high=1.0, size=1), + np.random.uniform(low=0.0, high=1.0, size=1), + ], + terminate_episode=[0, 1], + ) + action_tokens = tokenizer.tokenize(batched_action) + policy_action = tokenizer.detokenize(action_tokens) + + for k in batched_action: + for a, policy_a in zip(batched_action[k], policy_action[k]): + self.assertTrue( + np.allclose(a, policy_a, atol=1e-1), + f"Failed at {k} with {a} != {policy_a}.", + ) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/film_conditioning_layer_test.py b/models/main_models/rt1/tests/film_conditioning_layer_test.py new file mode 100644 index 000000000..0cefd44b0 --- /dev/null +++ b/models/main_models/rt1/tests/film_conditioning_layer_test.py @@ -0,0 +1,27 @@ +"""Tests for film_conditioning_layer.""" +import torch +from absl.testing import absltest, parameterized + +from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning + + +class FilmConditioningLayerTest(parameterized.TestCase): + @parameterized.parameters([2, 4]) + def test_film_conditioning_rank_two_and_four(self, conv_rank): + batch = 2 + num_channels = 3 + embedding_dim = 512 + if conv_rank == 2: + conv_layer = torch.randn(size=(batch, num_channels)) + elif conv_rank == 4: + conv_layer = torch.randn(size=(batch, 1, 1, num_channels)) + else: + raise ValueError(f"Unexpected conv rank: {conv_rank}") + context = torch.rand(batch, embedding_dim) + film_layer = FilmConditioning(embedding_dim, num_channels) + out = film_layer(conv_layer, context) + assert len(out.shape) == conv_rank + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/film_efficientnet_test.py b/models/main_models/rt1/tests/film_efficientnet_test.py new file mode 100644 index 000000000..8fa2944cc --- /dev/null +++ b/models/main_models/rt1/tests/film_efficientnet_test.py @@ -0,0 +1,57 @@ +"""Tests for pretrained_efficientnet_encoder.""" + +import torch +from absl.testing import absltest, parameterized +from skimage import data + +from rt1_pytorch.film_efficientnet.film_efficientnet import ( + FilmEfficientNet, + decode_predictions, +) + +MODELS = [ + "efficientnet_b0", + "efficientnet_b1", + "efficientnet_b2", + "efficientnet_b3", + # "efficientnet_b4", + # "efficientnet_b5", + # "efficientnet_b6", + # "efficientnet_b7", + "efficientnet_v2_s", + # "efficientnet_v2_m", + # "efficientnet_v2_l", +] + + +class FilmEfficientNetTest(parameterized.TestCase): + @parameterized.parameters(MODELS) + def test_encoding(self, model_name): + """Test that we get a correctly shaped encoding.""" + embedding_dim = 512 + batch_size = 4 + device = "cuda" if torch.cuda.is_available() else "cpu" + image = torch.tensor(data.chelsea()).repeat(batch_size, 1, 1, 1) + context = torch.FloatTensor(size=(batch_size, embedding_dim)).uniform_(-1, 1) + model = FilmEfficientNet(model_name, device=device).eval() + image = image.to(device) + context = context.to(device) + preds = model(image, context) + self.assertEqual( + preds.shape, (batch_size, 512, model.output_hw, model.output_hw) + ) + + @parameterized.parameters(MODELS) + def test_imagenet_classification(self, model_name): + """Test that we can correctly classify an image of a cat.""" + device = "cuda" if torch.cuda.is_available() else "cpu" + image = torch.tensor(data.chelsea()) + model = FilmEfficientNet(model_name, include_top=True, device=device).eval() + image = image.to(device) + preds = model(image) + predicted_names = [n[0] for n in decode_predictions(preds, top=3)[0]] + self.assertIn("tabby", predicted_names) + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/image_tokenizer_test.py b/models/main_models/rt1/tests/image_tokenizer_test.py new file mode 100644 index 000000000..3b1dbd0e0 --- /dev/null +++ b/models/main_models/rt1/tests/image_tokenizer_test.py @@ -0,0 +1,53 @@ + +"""Tests for image_tokenizer.""" +import unittest + +import torch +from absl.testing import parameterized + +from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer + +MODELS = [ + "efficientnet_b0", + "efficientnet_b1", + "efficientnet_b2", + "efficientnet_b3", + # "efficientnet_b4", + # "efficientnet_b5", + # "efficientnet_b6", + # "efficientnet_b7", + "efficientnet_v2_s", + # "efficientnet_v2_m", + # "efficientnet_v2_l", +] + + +class ImageTokenizerTest(parameterized.TestCase): + @parameterized.named_parameters( + *[(f"sample_image_{m}", m, 512, 224, False, 8) for m in MODELS], + *[(f"sample_image_token_learner_{m}", m, 512, 224, True, 8) for m in MODELS], + ) + def testTokenize( + self, arch, embedding_dim, image_resolution, use_token_learner, num_tokens + ): + batch = 4 + device = "cuda" + tokenizer = RT1ImageTokenizer( + arch=arch, + embedding_dim=embedding_dim, + use_token_learner=use_token_learner, + token_learner_num_output_tokens=num_tokens, + device=device, + ) + + image = torch.randn((batch, image_resolution, image_resolution, 3)) + image = torch.clip(image, 0.0, 1.0) + image = image.to(device) + context_vector = torch.FloatTensor(size=(batch, 512)).uniform_() + context_vector = context_vector.to(device) + image_tokens = tokenizer(image, context_vector) + self.assertEqual(image_tokens.shape, (batch, 512, tokenizer.num_output_tokens)) + + +if __name__ == "__main__": + unittest.main() diff --git a/models/main_models/rt1/tests/rt1_model_test.py b/models/main_models/rt1/tests/rt1_model_test.py new file mode 100644 index 000000000..6ac8b07dd --- /dev/null +++ b/models/main_models/rt1/tests/rt1_model_test.py @@ -0,0 +1,54 @@ +import torch +from absl.testing import absltest, parameterized + +from rt1_pytorch.rt1_model import RT1Model + + +class RT1ModelTest(parameterized.TestCase): + @parameterized.parameters(["cpu", "cuda"]) + def test_videos(self, device): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + logits = model(videos) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_texts(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + texts = torch.rand(batch_size, 6, 512, device=device) + logits = model(videos, texts) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_action_logits(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + action_logits = torch.rand(batch_size, 6, 11, 256, device=device) + logits = model(videos, action_logits=action_logits) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + @parameterized.parameters(["cpu", "cuda"]) + def test_videos_and_texts_and_action_logits(self, device="cpu"): + model = RT1Model(device=device) + + batch_size = 1 + videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) + texts = torch.rand(batch_size, 6, 512, device=device) + action_logits = torch.rand(batch_size, 6, 11, 256, device=device) + logits = model(videos, texts, action_logits) + self.assertFalse(torch.isnan(logits).any()) + self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/rt1_policy_test.py b/models/main_models/rt1/tests/rt1_policy_test.py new file mode 100644 index 000000000..2d861dc58 --- /dev/null +++ b/models/main_models/rt1/tests/rt1_policy_test.py @@ -0,0 +1,64 @@ +import numpy as np +from absl.testing import absltest, parameterized +from gymnasium.spaces import Box, Dict, Discrete +from skimage import data + +from rt1_pytorch.rt1_policy import RT1Policy + + +class RT1PolicyTest(parameterized.TestCase): + @parameterized.parameters(["cpu", "cuda"]) + def test_policy_act_and_loss(self, device="cpu"): + observation_space = Dict( + image=Box(low=0, high=255, shape=(300, 451, 3), dtype=np.uint8), + context=Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), + ) + action_space = Dict( + world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), + base_displacement_vertical_rotation=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 + ), + gripper_closedness_action=Box( + low=-1.0, high=1.0, shape=(1,), dtype=np.float32 + ), + terminate_episode=Discrete(3), + base_displacement_vector=Box( + low=-1.0, + high=1.0, + shape=(3,), + dtype=np.float32, + ), + rotation_delta=Box( + low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 + ), + ) + policy = RT1Policy(observation_space, action_space, device=device) + + image = data.chelsea() + videos = np.reshape(image, (1, 1, *image.shape)).repeat(6, axis=1) + # videos (b, f, h, w, c) = (1, 6, 300, 451, 3) + context = np.random.rand(1, 6, 512).astype(np.float32) + # context (b, f, d) = (1, 6, 512) + observations = {"image": videos, "context": context} + actions = policy.act(observations) + + action_tokens = policy.action_tokenizer.tokenize(actions) + + self.assertEqual(action_tokens.shape, (1, 12)) + obs = {k: v[0][0] for k, v in observations.items()} + act = {k: v[0] for k, v in actions.items()} + self.assertTrue(observation_space.contains(obs)) + self.assertTrue(action_space.contains(act)) + + target_actions = { + k: np.expand_dims(v, axis=1).repeat(6, axis=1) for k, v in actions.items() + } + + loss = policy.loss(observations=observations, target_actions=target_actions) + self.assertGreater(loss, 0) + + # TODO (Rohan138): Add more tests + + +if __name__ == "__main__": + absltest.main() \ No newline at end of file diff --git a/models/main_models/rt1/tests/token_learner_test.py b/models/main_models/rt1/tests/token_learner_test.py new file mode 100644 index 000000000..a856b256d --- /dev/null +++ b/models/main_models/rt1/tests/token_learner_test.py @@ -0,0 +1,40 @@ +"""Tests for token_learner.""" +import unittest + +import torch + +from rt1_pytorch.tokenizers.token_learner import TokenLearner + + +class TokenLearnerTest(unittest.TestCase): + def testTokenLearner_h_w_split(self): + batch = 5 + embedding_dim = 512 + num_tokens = 8 + device = "cuda" if torch.cuda.is_available() else "cpu" + token_learner_layer = TokenLearner( + embedding_dim=embedding_dim, num_tokens=num_tokens, device=device + ) + + inputvec = torch.randn((batch, embedding_dim, 10, 10), device=device) + + learnedtokens = token_learner_layer(inputvec) + self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) + + def testTokenLearner_hw(self): + batch = 5 + embedding_dim = 512 + num_tokens = 8 + device = "cuda" if torch.cuda.is_available() else "cpu" + token_learner_layer = TokenLearner( + embedding_dim=embedding_dim, num_tokens=num_tokens, device=device + ) + + inputvec = torch.randn((batch, embedding_dim, 100), device=device) + + learnedtokens = token_learner_layer(inputvec) + self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/models/main_models/rt1/vd4rl_main.py b/models/main_models/rt1/vd4rl_main.py new file mode 100644 index 000000000..bd7a6dc06 --- /dev/null +++ b/models/main_models/rt1/vd4rl_main.py @@ -0,0 +1,389 @@ +import argparse +import os +from typing import Dict, Iterable + +import gymnasium as gym +import h5py +import numpy as np +import requests +import torch +import tqdm +import wandb +from dmc2gymnasium import DMCGym +from sentence_transformers import SentenceTransformer +from torch.optim import Adam + +from rt1_pytorch.rt1_policy import RT1Policy + +DATASET_URL = "https://huggingface.co/datasets/conglu/vd4rl/resolve/main/vd4rl/main/{domain}_{task}/expert/84px/{index}_{domain}_{task}_expert.hdf5" +ACTION_REPEAT = 2 + + +class VD4RLEnv(gym.Env): + def __init__( + self, + env_id: str, + embedding: np.ndarray, + embedding_dim: int, + num_frames: int, + dataset_dir: str, + ): + super().__init__() + self.domain, self.task = env_id.split("-") + self.env = DMCGym(self.domain, self.task) + self.embedding = embedding + self.embedding_dim = embedding_dim + self.num_frames = num_frames + self._load_dataset(dataset_dir) + + @property + def observation_space(self): + return gym.spaces.Dict( + { + "image": gym.spaces.Box( + low=0, high=255, shape=(84, 84, 3), dtype=np.uint8 + ), + "embedding": gym.spaces.Box( + low=-1.0, high=1.0, shape=(self.embedding_dim,), dtype=np.float32 + ), + } + ) + + @property + def action_space(self): + return gym.spaces.Dict({"action_key": self.env.action_space}) + + def reset(self): + _, info = self.env.reset() + obs = self.env.render(84, 84) + return ({"image": obs, "embedding": self.embedding}, info) + + def step(self, action): + action = action["action_key"] + term = False + trunc = False + for _ in range(ACTION_REPEAT): + _, r, term, trunc, info = self.env.step(action) + if term or trunc: + break + o = self.env.render(84, 84) + return ({"image": o, "embedding": self.embedding}, r, term, trunc, info) + + def _load_dataset(self, dataset_dir: str): + os.makedirs(dataset_dir, exist_ok=True) + observations = [] + actions = [] + for index in tqdm.trange(4): + file = f"{index}_{self.domain}_{self.task}_expert.hdf5" + path = os.path.join(dataset_dir, file) + if not os.path.exists(path): + url = DATASET_URL.format( + domain=self.domain, + task=self.task, + index=index, + ) + if self.domain == "humanoid" and self.task == "walk": + url = url.rsplit("/")[0] + f"/{index}_expert.hdf5" + response = requests.get(url) + if response.status_code == 200: + with open(path, "wb") as f: + f.write(response.content) + with h5py.File(path, "r") as f: + observations.append(f["observation"][:]) + actions.append(f["action"][:]) + self.observations = np.concatenate(observations) + self.actions = np.concatenate(actions) + + def get_dataset(self, batch_size: int) -> Iterable[Dict]: + # We expect self.num_frames trajectories per episode + num_episodes = np.ceil(batch_size / self.num_frames).astype(int) + # Leftover trajectories from last episode + prev_obs = None + prev_act = None + for idx in range(0, self.actions.shape[0], num_episodes * 501): + # Get `batch_size` number of episodes + obs = self.observations[idx : idx + num_episodes * 501] + act = self.actions[idx : idx + num_episodes * 501] + + # Convert to (b, t, ...) + obs = np.reshape(obs, (num_episodes, 501, *obs.shape[1:])) + act = np.reshape(act, (num_episodes, 501, *act.shape[1:])) + + # drop the last timestep and action from each episode + obs = obs[:, :-1] + act = act[:, :-1] + + # frame-stack by rolling self.num_frames times over t + num_traj = 500 - self.num_frames + 1 + indices = np.stack( + [np.arange(s, s + num_traj) for s in range(self.num_frames)], + axis=-1, + ) + + # (b, t, ...) -> (b, t - f + 1, f, ...) + obs = np.take(obs, indices, axis=1) + act = np.take(act, indices, axis=1) + + # (b, t - f + 1, f, ...) -> (b * (t - f + 1), f, ...) + obs = np.reshape(obs, (num_episodes * num_traj, *obs.shape[2:])) + act = np.reshape(act, (num_episodes * num_traj, *act.shape[2:])) + + # Concatenate with leftover trajectories from last episode + if prev_obs is not None: + obs = np.concatenate([prev_obs, obs], axis=0) + act = np.concatenate([prev_act, act], axis=0) + + for batch in range(0, obs.shape[0], batch_size): + if batch + batch_size > obs.shape[0]: + # Save leftover trajectories and break + prev_obs = obs[batch:] + prev_act = act[batch:] + break + + yield { + "observation": { + "image": obs[batch : batch + batch_size], + "embedding": np.tile( + np.expand_dims(self.embedding, (0, 1)), + (batch_size, self.num_frames, 1), + ), + }, + "action": {"action_key": act[batch : batch + batch_size]}, + } + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--env", + type=str, + default="walker-walk", + help="name of the environment", + choices=[ + "walker-walk", + "cheetah-run", + "humanoid-walk", + ], + ) + parser.add_argument( + "--context", + type=str, + default="""Move forward by walking upright on two legs, + while maintaining balance and stability""", + ) + # cheetah-run: """Run forward rapidly on all four legs, + # coordinating movements for speed and efficiency""" + parser.add_argument( + "--epochs", + type=int, + default=10, + help="number of training epochs", + ) + parser.add_argument( + "--lr", + type=float, + default=1e-4, + help="learning rate", + ) + parser.add_argument( + "--batch-size", + type=int, + default=32, + help="batch size in number of trajectories", + ) + parser.add_argument( + "--trajectory-length", + type=int, + default=4, + help="number of frames per trajectory", + ) + parser.add_argument( + "--sentence-transformer", + type=str, + default="all-MiniLM-L6-v2", + help="SentenceTransformer to use for text embedding", + ) + parser.add_argument( + "--device", + type=str, + default="cuda", + help="device to use for training", + ) + parser.add_argument( + "--eval-freq", + type=int, + default=None, + help="eval frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-freq", + type=int, + default=None, + help="checkpoint frequency in number of batches; defaults to None", + ) + parser.add_argument( + "--checkpoint-dir", + type=str, + default="checkpoints/vd4rl", + help="directory to save checkpoints", + ) + parser.add_argument( + "--load-checkpoint", + type=str, + default=None, + help="checkpoint to load from; defaults to None", + ) + parser.add_argument( + "--dataset-dir", + type=str, + default="datasets", + help="local directory for datasets", + ) + parser.add_argument( + "--wandb", + action="store_true", + help="use wandb for logging", + default=False, + ) + return parser.parse_args() + + +def main(): + args = parse_args() + + if args.wandb: + wandb.init(project="rt1-vd4rl", config=vars(args)) + + os.makedirs(args.checkpoint_dir, exist_ok=True) + + text_embedding_model = SentenceTransformer(args.sentence_transformer) + embedding_dim = text_embedding_model.get_sentence_embedding_dimension() + embedding = text_embedding_model.encode(args.context) + + print("Loading dataset...") + env = VD4RLEnv( + env_id=args.env, + embedding=embedding, + embedding_dim=embedding_dim, + num_frames=args.trajectory_length, + dataset_dir=args.dataset_dir, + ) + + print("Building policy...") + policy = RT1Policy( + observation_space=env.observation_space, + action_space=env.action_space, + arch="efficientnet_b0", + action_bins=512, + num_layers=4, + num_heads=4, + feed_forward_size=512, + dropout_rate=0.01, + time_sequence_length=args.trajectory_length, + embedding_dim=embedding_dim, + use_token_learner=True, + token_learner_bottleneck_dim=32, + token_learner_num_output_tokens=8, + device=args.device, + checkpoint_path=args.load_checkpoint, + ) + policy.model.train() + optimizer = Adam(policy.model.parameters(), lr=args.lr) + # Total number of params + total_params = sum(p.numel() for p in policy.model.parameters()) + # Transformer params + transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) + # FiLM-EfficientNet and TokenLearner params + tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) + print(f"Total params: {total_params}") + print(f"Transformer params: {transformer_params}") + print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") + + def get_text_embedding(observation: Dict): + return observation["embedding"] + + print("Training...") + num_batches = 0 + for epoch in range(1, args.epochs + 1): + train_dataset = env.get_dataset(batch_size=args.batch_size) + for batch in train_dataset: + policy.model.train() + num_batches += 1 + observations = { + "image": batch["observation"]["image"], + "context": get_text_embedding(batch["observation"]), + } + actions = batch["action"] + loss = policy.loss(observations, actions) + if args.wandb: + wandb.log( + {"train_loss": loss.item()}, + step=num_batches * args.batch_size, + ) + else: + print(f"Batch {num_batches} train loss: {loss.item()}") + optimizer.zero_grad() + loss.backward() + optimizer.step() + if args.eval_freq and num_batches % args.eval_freq == 0: + print("Evaluating...") + policy.model.eval() + obs, _ = env.reset() + obs_stacked = { + k: np.stack([v for _ in range(args.trajectory_length)]) + for k, v in obs.items() + } + observations = {"image": [], "context": []} + actions = {"action_key": []} + term = False + trunc = False + reward = 0.0 + ts = 0 + while not (term or trunc): + cur_obs = { + "image": obs_stacked["image"], + "context": get_text_embedding(obs_stacked), + } + + # add batch dimension + cur_obs["image"] = np.expand_dims(cur_obs["image"], axis=0) + cur_obs["context"] = np.expand_dims(cur_obs["context"], axis=0) + + act = policy.act(cur_obs) + + # remove batch dimension + act = {k: v[0] for k, v in act.items()} + new_obs, rew, term, trunc, info = env.step(act) + obs_stacked = { + k: np.concatenate( + [ + obs_stacked[k][1:], + np.expand_dims(new_obs[k], axis=0), + ] + ) + for k in new_obs.keys() + } + observations["image"].append(obs_stacked["image"]) + observations["context"].append(get_text_embedding(obs_stacked)) + actions["action_key"].append(act["action_key"]) + reward += rew * (info["discount"] ** ts) + ts += 1 + if args.wandb: + wandb.log( + {"eval_return": reward}, + step=num_batches * args.batch_size, + ) + else: + print(f"Batch {num_batches} eval return: {reward}") + if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: + checkpoint_path = ( + f"{args.checkpoint_dir}/checkpoint_" + + f"{num_batches * args.batch_size * epoch}" + + f"_loss_{loss.item():.3f}.pt" + ) + torch.save(policy.model.state_dict(), checkpoint_path) + print(f"Saved checkpoint to {checkpoint_path}") + + +if __name__ == "__main__": + main() \ No newline at end of file From cce93f58b9a22b110dc9f6f0e2e85fcfbea4d454 Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 18:53:16 -0400 Subject: [PATCH 10/12] reformatting for merging --- figures/rt1.png | Bin 135877 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 figures/rt1.png diff --git a/figures/rt1.png b/figures/rt1.png deleted file mode 100644 index 17426537180d0baaa5b824e60bd94298ce6d5c35..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 135877 zcmce8g;$l^);9_&NJ@8!fD!@%(ulM)iiCi4cQ;B(BPbyaBBdbRAR;ZHbeBlE>CSIH z_ultk_!#GmGmdUH&t7Y;Ie)bXQ&pD5y-9f!4Gj%fUQS9K4Gmoq4eiQv%w z@E;84$MVlG;mZfp*Rw5P|j;q#;I!^U#6xUQy6Z%l?qTHiT~Ua@jwYPsuVX`wXRa=)Oe zt^6xpy>-I(v2`Mz>q_L_yGnSMF@oM;4C}?K*x-MYCT2X7jm_dlc34a{*%*Q)%kvD$ z$=(~a4c8VDDk?hO>A7!dWmU(zlqRpCL9#ybrPZwbit39OJ-hwl{U7+On+|=k1L!NBYLF!M zxE2&KV16gbFD-prX+7%nZ;YE*`nYciHQSu={rmR_^@IV@HwG&>&z{-vQ<0F6kbU{- zdwQ^)Cw?Bb*b(!xf~UUB`_L}k^Dl*Rs=$?3O!7ykr^Y6dX*TPnOyJZjRtab42edJv?d>ujK79D9^9BAI=Q?^}_HP^Ob_-rcc|t!wKk_IU+e`fz zve3cTZAKC$_NRlDRaNSmnxWHn9X9+#q@*EjMp>1WBq_ZkhA(g3x^?#VVRMTCmxXDa zF6Y|XnuVohiv=$sDXGk(M`&?O^ZQr*))6l@97Wh`EQ3PvcetB^|G%|8EHYKG;#czj*kci0A#^z7usQ%(y zOCT(eixAEE$^K$-{e}_Ljn7ug4Qg?})an_ph%4yVxqMGtV2hrp8W3m*VBAvp@1eyUyiqqu0LCK&AvQFYgw-0P33bpPR5(WBR*y#CEky zq+WX~5~iki==_ct9335fc6%Q_d-iN@+e1!HZmw$5?)JlnWZI-@5drk6$-`E|lq$s1 zSyfdD6B9bH0*^dA1b+ScWnyMxv|X*c@Zn~_ma)37?$0dA(4*si|Go}7|DU5T{gwLD zMTIeLb8v9{gCnrEX5~^AJyxUjTYWIrm8af)^V8?gksm%#-o(c4>gh2)+M2J?ex{ncx5ucDCV`KBVCT8ur z6qgHacXzkP{;=licsa{c`}8MItZsTA{4@NOEiEM_<#0IdzT5AA5r0P^VQc;6<%j%y z)`QL2{+|2Ik>fUI@WV|^OuoYT^E&t^Z)V1V#&z);X%|XZzr( z6n%X~FE0+8x4jw_GsM!YOBxdj3-6I~>UMq)#`ZiIH!s!t(HlXJX+APM<^>1T((-N` z)7$j)3-r+^1VMBUG&GPR$jZu^g1to^rsW2m!}^!%h2`ZN71!>SG@aa|;yy}Qp466Hf!Pc-?<8&u#{nM z-p~sOB*n!M{{H>jWA62hH__2%gP)Yx^&65hGwGS+8ChB1z-PQgL(`io=-m19XTuNk zCj>16o;=BlQ!ax_QzH9jip)gX+S>nS8dKnXL}>A?M?N#~@WidNyo~u}V)E_P72byr zpQ@=zxViD)mWecg!xTyJAY^Jvx3I9#L4X?L`t==H;oo^GbUHdZeL69cp?IYZ^N-Vg zcH}o|7V+Ti#WL`VhP$2nMP*G)m|8<{jd%a{Mp8YD{`pf8ilqV-LoN8dsHCa;c8th( z75|f`urcA;u?Y$7f4bte&t{BdqG*FBQD$dH+dn_>VT+54PuV@x(9mFiQH7J(b0>g7 zf}rk?Tm4-&w#B3E#Wej<_}m;EQGTB1&>xyH_=utVz_W&vusz?}&A3d3Vrh@0XoWQ# zue2r$ypH>QdAHQ0i%{(1$e7mu%<<%KGp1v49?tn()WaG2hYu4kk25ZzE2``3_rWth zwz9gHo1055>P4)fG5*yM-FdlhDdC0Pd^?r>4;%h+DBr(*X+3AhyPi8;ECoeH#;A$P zDYr@6pGn+-Z{A>5*-dvpRS|8gb6uBHQ6X!TOiaQI>3gcHOFce5u0wb=qV2Jf5hHAN zMOBs4q;2(f&&!KASvv1`mV=+(rls}X_diy6#o6)ZL$8@k6s2^t-#Hg$)EMfZe8jjX zfrA|9I`lfBFPuVY(T>I)zncC10|Ep3YkUn28D1UCUyC(OhP`W#q3i!!^6$ya4M%)Iy^jlq4VwSpBdsA z-kXhNuPQ2dKPjg@fl7o!mXV<%BXb>=$)j-wZ?`p=E*(}ezRl>@Rdfq%hdnRR!ouvr zd(~4;*w+JJw?&Zc!ZH$SCr}7D&^!PA$sjCTKgbg$vnY6nNmWCG%1&KFLmEb&VU{6{ zzA+ai%v{-ozNv0in4E1!3_Ofwt&6Bu4Su_+H`%O7y?+PG`qRGHNDvf@6c#SH)fWIR zfR%!w!1Lfi*Uz6&2Tyf$!l&&<%XFZ@W$f*_ynQ205ERj8R=$0*UJ{>}D66D|yT8AW zhIBlrzKhw*Q~y)}#{j?;C;RJpcXF@3iHceZUVix~Z*+dwHI2KtDJvbu5jV^XJkd$i z>(TOlF$H;fEVQ?8-%3eKTShG~$A_(~SO6-K<{H8Uki)p+)rbr=ZsT??&m9v0G%YY; zJ)q@z9LE6AYDZMhbdK@rbCe{I>Apnem z&uWNbosyO|dfG0p?$d{{F)fs1Mt?_3;Ehr(_Uy^$1VPRVyC?a@1)pka$l?3d)d}z3 zy_+{pj|TGt=?~DurRbS3zaJVwk3x=*c7i9=MrFt3gRA$UWx+cw?jBd*G@+hpv@N+A z{_tr3Y_DHJ7Sj=!kuhsovb($6YQP1U>1M@#PzJTbm4%bhs5kY~5uGTv-Ok%FTQlC9 z^P8J0US2{^KPk?$h#zA~OG`uhLbrV#UFahELovY=+7T`;?u06D%w+3CrFEsqA^LTk zZ|nOzt9cn#9At&rWll>^{La^34o*yXwc|U^Hu=6a)mDfdu-lwz{H$Fb0@F1dzYse9 z(zXZd#LFMWdi7i>y#QAR%gy@-|Dxr7{1_V>`whT{ypj^hD47I76B%A;AT*zW99jH} z&D_hy694m}1N)1!W5sll$n=EXkA4Hs z1U~1_l!q~QpMD}BBn)V77Kf(~2)GK^5J1Vm!CUCdunr!_ONnY4?+sf+)O2*Zq1SbF zb{eb=73i!vNDu_|Ra8`bwVmV#6bn7=M|-=Q;M8q4wunD}Os=A%`ws|B*zoIek})ta zFrpC!u|0BhJOrKWb;k$!mYDE$)s&&BabT#PcBAt2^h5(tSmv^-jsPrmBSLuhQ$sx6 z8UsdhA$0jTIYmX2A8&4<0VIh{OdK`5n#SG(!+&vkIdt6SZx~BDJtJcP%;Ko#v!(l5 zU!GsbqwZXc5s&UNVH6cjD>d#YI}tA`5KwE`^uP4>I^0n5@o6}C&6m>qGgUBtIo&(D zgVq}d`Z)AvkH5+0tnBPetgM*j<3C&R#T9*gMC_Z6nPCXFT2=B`{$}z!FM63Xy57~- z_jj$R#B99Gl$eBMJ5>DaH8ffRBBH=9lZC|Qvpd|}+zs39R7g8~^$INnkEYu=MpQ;o z5r;Do0kZ~`I>M=mo%wR`w5-gc*xyM$7Z*oIQ9WGP-0bfxl36ep^v&<=Qe+;q+{O3D z?CtHfnXY>u8HrO?Uf#C#QsU^=u2_h>zuT{ zdupFlGWw7iU076vAP@>}qo9O;^Z@(y>fN~gFMKu{c9p+SYsb}|A54x{SQ5cWH||Rn z#JF*z+-msV!N2j=saof@3Clz*d6K&=efgr?0qi|GMc)eOil5SHYLH}%hGw(MIlTx7 ze%g_9uc?Yt8wR>*tyo5hEoSOXFUc1aC^oW}pMBG8yO;t^;1%{6-l<48Czc>&Vz`s2Ee+xQ=DDnoo z7TO{_Pf^vD78V9jP*VVMbQXKkMZH-$InAK;>MWK4a#?JTl8gKC)v#4+apw**0$4ES zQ-_C#p^)%CKWFnj*{fx06eU{#_yVXeEH#xHrikT5xvjFFqAjAaL`0>-Ha4K?m5!;kBe#kQtYP)MOWbewG zbqP2r(lGpFxYpXHSR@2edQ%=QItcuyJlI8iYvtdle6y=Ax1SXYxEhEVgV{W!K?pyJ zGb=*KJbyT6YZVW_$F0uMTY?nV?(xH+ix5rX&hUg}?w^WIL3qC&v16vO!8$>WC}!}} zwK1gL$BfFP4YZ0vnV$n^{0DT8BU9uv-G z>_oJ*eK3M31f7`BQuu8b0L%(l(=043Byk&GH#9U{ezpvp&kZ#Z+-qhGz*>vlT>o6J zWOT4v<)xV3#ohPs-~VW9OB?h<3WqKxf)JG|iK=bIg6_%)pWG#HG zU`@nP%paj8Wd2=*t10d$5%M>7Mf&CX_o zIWoP<=+B=L_4~Iv&+i9ZsonkZZJqz z{(0L6g@qui-2$@S)!og=%=|Zd==jeL4c?8yY(fLvntW4DP0hu9udt{n)Wwyz^q7<} z9g@(`Zp%iCY_6LCyg2RB`7RZhjxeXu;mQ@=>Fx!HnNw002!IB3}j94_lupf zBO441ATPu315h?f`8d#Oq-13?9Q{?q&v~gH+I`H=e{*tjf-R&U(Hy+B<#3OU4L%}i zqvZFPaFuN}Teh6;=h5<;q2mt6#YD`yo+4uSl^iS}2J32tHjOlu;$s<)=@~uyLSK{JVBT67(}NeUI1BV}a~&dU5^PJw_UiTYZ{*JhR?V z$}7}lwQ==iEmETsb!@3r8U3OC%fg4x?Imi^KsC2Ib?wjHwu$bgH(^bFvH>%XkOBngN!niJ3UFz(d*I6*lbMtTZeu;X=M?CoF zGm8lQNw)t;T`$Xblv{jqau<#J)N3Yr09{+%Y$d9?x{5$iuLoYKp6u;Q6F&Z%VvmW7 zYr60w?8v97Dm}_RR2mK>d@xykecAz1MPgD?D^W#Myr-%5Cy*imsv4A!lZ$w82?`3X zxCkLd4^tE-%%8%d;Oz-KFY50HkOogF90G*F07pFIoeUp5Aoi|9qMv9H*B zY$mI40rkLl!zV*1KX7lrgeed0KS7y*1|}0j88u$Qu>#1$W~L#T&w7N*W{eA70-8}) zQ&T#KiHwYlT7YEXyzZ@!#xyjDJku}*p4(aW6QK9XWc7V$XJ^aemkdlyK|pi}NJw&N z6hI|bNaSo=b%}fbUi!(Co3lQh?l3clyuB?8@@6~q8!SxBx%HCf_Qh>3t07ik zCqfMj8X8MbG@tbwDT{`~d(CbO2mqC7hdO){8Tk=JC8!&Ozh9i6hJ}S0j(s%*WsiV{ zMhRdC?B%ocd=rC55grHELVKW)~JLkGw@_ zfnPz@u!eVfvG_C}Y)mTv9UfTiZ@$%va(nvnWlT0JYxrZ}d7=1pG8!5t+JDnQ`_Fgv z{a4zN|K&>?a2JrSw&35?LvyJ(CeV-t{LTcR3+vFcU@mtXa2b?pebr*0E;cV6HkQ3l zg;^C8_DHVgUuRt8FmX^D`KxK$+mUiioObBm)hEwj!*Q+$@{d1PBZh5Y(=0Xt!5-<~ zxeAFqhTk!&Y{tI>aY`0+W*%_6eX-p^w+o<^$9+Thiz3KX0DwXZ3-?wBZvgy#{P-$h z)+vBbIOJTfhK8Q~?M>+bA?oY6jmY7Y^ORE$hYv`F(1)D?OImXT!zQ2Ym-ycSJoy^^ z#?FLw3Af{d6fgyBGENf!k3*xQyMVDA;nn4K(?XznB|WsKEi6PH%*xvOc#-b16T83p zTf&zYTA;gWzVzioq*cJjRQ3&O!k?fMz}^6%K?cvbc?KwTeberLGvy7cn$ zgsif%5~;ONTCX=yQ3KWXFG0{zu(oDH5a49By*bEpXKR|xj}dttb`XRw2ca|||482< z<Lh=c{&;8?T2IKn2t z$?ySA&&15UQ=V}i36S{J8q!Mt0A0BBiA3+`PEM%r?w%g_nN#kwzMpk#;{cYAe0k9U z3)qAF%QvdqYVUvg0wfNQr4gd+bG|>?0Njv<`CDP(6OdGZg_{9NhoX8is@H6>w1ajr**x8F?%QjmEXiK_s8R7}72bpX&}LQX1bah3OREg!;C;9O z9mHul&7H@zn;0ArX#b}FmHuHY1Gh@Cs|yp}s0kbyc~0vwcV)z0E2edx9>i0%9GSPN zsfZF^@ez@qe&xs_h%C*0rYl=ILhi|v1rWg>fH;8&KF#MSdvI-_EdVh`luKYT2-Sk+ z)T(#m04c)|S~n9D(-thhart$n}|gjEC&$&-o1N= zXehTRCE%X7A;dCH=j4CVE1s0BC`Mj%8?7z5UjrSpAPzuEMne)X(412^ZF9LRJ4 z@8#lxep#F;FJWnt5;21f28R{~Adukt`Te>@x#)wLiFnujqhwwFuDHGhC&g#3r3Hl( zS>}3iAMHrSs%wu1G3u1KnB)oJgDNI*UC~a!!op(U<9iRgnQ7aZl+C)gHjJ&Ez@5@7 za{MEnnoY1BN)a)+goNq_iNB&6Sy(P5+&8AWG&J>c_hS`Pgm7al?UC~l_nYRxHDZ47AU=$U#qC&vH>DTkLIO(4Cjj3-x&Hl^@eT`%b!$Gho_*RKqpz$`@jSQlZh&5jUnw- zS#~I*jQIHYN*pzLdHIhYKhC+;hebpfg8;y;Q}L#(j0X*96oS8Ca~K&IUV}RHb*KD2 za2{@-BL~DngGW{o-6sYl3a&1)$z3Md&?>~cA7PUG!xJu3X6EAB3U7LZEuIR@10;w0 zN7!FAOZ0!Hi&8-YnM8d8%m*_@{pr(IIO+U0zc)ZWgiw->0)NaAl z#i8Q=S8?~Mo@Fx`m_f%gYiGXBV>IliE)*adz~|OoThrx%UJ44AjJL|87df6lmHmdC z@752q@ZGr+4CBD%h|sN8_t7MQP@}#I>~>dI7cc|ThK5&wEC6n_ogdEj3vV{~g_Di_ zUlss4o*oNfEJ8lxRrvM7+8~Xd9&UE5?}KMsbXooZU=ic(+qLr{RB{RmIkmOPpr%;9 zj#19L&BYZ9{%4di23&X)9R)b9|lv7szl$(1k zW1$sX+roPtF?6GUufSloZd4c`wYY|X0hlkMun-&oP<|>GEyOSR`1pLl-}v+A50`N} z4#24ngc*VM%J%&89IATOZ0AoG)15op(6p@CejKj+3WSbC>$SoFdjpK$#M~U*&RJat zY&ZA3?1g;~?qo&AE5TcVjsn!6M(A%Hz^Fo8lZl2Dm;#iPlpgRAOD9o?iwSOXhO;MN z3&c`E)`$B)!v37JJ-tQqb+5*m2%TbwC9ag8V2jv^Ru3-kZUd9q0^uF;C3bdq-!g?k z^VIj<*8o%@DdQDFisL$AoLz<69M2TCzdi~wM1_Hz8ZmU;;~mRyFRJ}$K(AX2p|V2` z&)Gt+??(2MyKeyGAI$l9A|! zDna=*D$uwBxhZ=1)SE0VBZCg`wa?x!*`eWKN7&wIu))CmegmeSpkOlMInBS7r8V4M zXwzZ5p4rM3e&7#H!4NrvVg}HJ;>TC`Bg(zFj|+OB(6{Vy&<|cAgLn=GZ8xfE&v}uME{k?!J+tr=Z~(P zphg@Fdjnd{x1FUPOFO$yFlmpDJf4^6_hww4nL{@P7X0-q7clN*F2k!CK08?8SxS_Q zmV516m3f<7)-3nu+g^FAJaX<4qqg#Vf{I7kj^wQP>eZ_if&wU9ie)04J4{R#t&Yw1 zsMaiLE+$>pG<|o!bzMD1crH*zhzIzum zx^4Wl#&d}3&=#^@5jD- z_v7KLPv9>L=r|a_BMl7b0o)^$2xMGf6TM&nmFj!}$GNc;q*6947`!-0TmTXWg@rr7 z=gO={Il;qI0aMSqSxcd)=siFVZkH8RD=RBjEsbwkt)U1tLI5!A0WKB4MOQtuO1dI! zb+zyPm2|JQg1jbc20s4a1*_mG4ACo}u!U9ONkB|iQ&Xc+PGIjsNZj=8l!`rGSh)Ox z0tR;W$oh@C2yigJx3a0zaIm= z9ySbYt6Y@~G3XT*r%>Mpzdy>;tbx@h1=K7mDhg3l9p)Y(ZYD@HUGiNR*DG<&Z(?H7 zL(7HI1>NfCUwJ>dxL*T5*-AT=9TSY{A3vmQQyrf@BZg+OKClR#6zqgQdp}zi>={5% zfn8xI#rE{wwXm?s1f>Lsqf88~5-c^?9`G`W1kRn;X>@jqfsBl=D z_rjssLUti++=dxoAT&JSF5u^Xf=LJ#-CGDzfMqz&XjC3BkerZ^V8^Fe+%~LO)FGem&m^P``n-;r z4$M9f4?sEgfzFDc*v?M5>r41X(M4+I{5yAcDGoDdhXIuar z&`e_E<0W05@s>2~+ywXq0@4Hf8IkMwv{R_^2OHz%pqf%K8Er9e<}G7@y`NMR*MOO6EsjjR z&!5>*?(tnefVp?Vn5b~iy$(VS5ZMMt>!Tw zOqL|>F9s16)4i2nknV_>_IBF^v-yGT1aEQEi4}N~8NLS;Xx@jYJCJ386*JUcxcc@<$4N}K@|(c7wObYX#%|d0e0qXQc@>GE}p;^OaerDRgL$?vN38J+DL1H zcSRh&g#{yo=|kW_!Ou?&q(jiJ-8QD=5l=wuyE4pp%(^})r%#6ZX}0d4W`(^sbZOT= zE1R=br%Bk)LHiydWKaF_xi4LO_9R20v9CfYbk;PiE1o4jEzMVX`BRbczp^vuquQdf z`t@ti2{>g73n6jUf9gy^LD2jR^$Z7Q6s!uRVe&6wKKy*g5$)ur7qZkk!;99w;a^4)xR2 zA|A2O?BNTnuj`r6?a3o;vDai|WUO|p&d<*)U732#c4N#ezA(v0(ut?nIxk!0pd*=^ z8P8=Jv!6*VFs#~u=P5WpeSjN9wI3v)=`ov#xZ>{mj&yhq|a-)KNzr9j!e|r&M~B-WTL6Z zmv%+H_A-IaFE`G{L&t-r3`cObfLcBdXfT-%C&s)JkJFGG5@JG zy%7Ye5Ni=k2$0t{n@%|qm0@u^H6e1{2DeK5dU&>lb|{IoM8af327=}x#xpB+@q$VF zKaxRjmDxSzXIu5N=Xj0!{Yb)(CBx@247GS>B_mJ?fQdAL-fMTRPw=0tFIt7~w(DWo ztT=`vUJ#vdd{+=G1uzx>=B1ED1Wqq2DH+H=yV`WRVGKwU%&jCSW{}1qME4iug1-=f z`nKv~R6f4tAp(;fXdn^>(JnK=y12MN;Eyb==f}zGxL{j=pTK3dM{esCoXv`)@<6%* zzlQ&%X341g3g5$&-iayeG-Y=k`=g~NC8JLvO$9V5P&u#FuG)EPP6Ebr6q7ti#!>%? z8?5ISS)aNCnM6(&aAn{dd!1_%&tupD2`a$}fJEan@K4gSdXhU94Uc!0bX|uv0JWs= z@3*zJftJAqRYjNSmYCi;4<7+UU$=rHM$GT-L(_v97phYCyyux8vN9e5HkOtcdU!x+ zh1Im|N&zVbFkVQN$C)I)*vH<%jc8CM2J=)#L(U{7`5eF=o|sBF2zm~L4UU&ZGCz>4 zl3d!Du&{Y^@ze1;0s#^C>&^K=+ssHngA8y8E{zO)S`aKD-~%#qY|^{Vn$pEs6D;dj z@1X_RaPY$feBA#p9YUBOFDXk)UxQbI%&rXSkUnUgF#U6YVlNZp&xQmWT0w?G-}z$Z1|zeL04RNd2Jw3^NvY=%}MPqo3wX8(#FIG4onn+C^09IWI?3`F`BfIQU@Y z2@hv1co8@WjJkB(2Fwlh7cUf~q%iP8b6T%jfo(cn?@mNO@C~pl&_M9&<34;S1P+i$7IGTU+S7#H5k&*kxxgE^%-<-#Z7+6=H+nw=-3-zh76mOT)8-(? zKqeZ>0V<>g-mpTE22hH`ap0S_DUu^f}@}%uO5q_>>d{ z0KkYQ1EMgj?C)m(OSU?)t`QsK={i@ave>jVB^w*|>w#G>UNQx-g~DN5a?&ep{V~ze z9r5ho`_ebyEN~E^heLMs6Rcu(b`BSXlDXd2o{jTMVvQ>k#pq?qCkNawC)eM`GSv|rhDK|T^ z>SkGGQOz{!mOG93b+FZdqIZyxK6g%s>eClMy{J3@XCjKf9DG2~!m^gL zDm{=kLO=VS1W307lF07}Oc<3X5Bi(#)Kv!{wuN1SRAD# zu4ECAQX+BFp4m~NCF zZAvr4D~C%99IwG@*KKuM;n%H$Q%f8b!^Bd+Exg9JP<{=(0#;uu`LhQ+&pEvO89$ej zyV!O?-_4y-Q_3kX?x{OoJ;&OO`F@7tW($uI^5)~$96jBBs1=6!Mxw;JC?)$I@0hiP z4a!U0tdVa1;#U%GLRDSX?|(L#Eoy<9C=uf{HGU$)sFux1+dhq=4hdTYk}qPidHp?| zK}XUA|L8*YY=izBRH+*m{a7t`uT{zv3?fhv5UNFq4HbD5*cW{NYqz#nbBF0_q=b}~ zG3UvN#PV7=W(ag!B4))*u>3%zdxbA{^a|(?FyDtW9=AvJ+@X5@&4GHs0;wx@?Xn>A!ol7=vzmrC0o78{cm?WtPjO zQ*~`^-Q#S#W4zj)E{+M2Zq54Bl^}Nx^QRv`oDSDB@c%)ZXhpO<0KBr%)bl_VKWmi+ zz~lb?nH*SH*l@a0Z!_DJ1`qDKa&7n6hc!GPn-vJjHXJ<=jy=I_L87alQtXVN4xy)I zn5TP&0FU3f@pljaoGhLH56}xih@J=ERuC$Bvq`e`8A;xtva#{867d{^R9Y@xnr@h{S4VfU3f7ktC+jBYwPoq~->UXWre~gq7gia&^SRg31@_6ANzoYv#>d`C zeqIufJ}g{XZ|gE_Y&<~mOCCK8CldYJyxqKNFYO1N^}ZT9`=rnx12`t~GHN8zBdEN( z+^dxlbI%f7JV+iE%#Z6Oc;A!O$S-^ETw{i>pIemm%eKX=IcQ$T;khZ>vg*E_NO*k& z2h-=j1Z6q9m?e0t_GIiC9w#Q0F@qvjFWvMMDl8W@gQi01Q_ZFl+|j#>eN_Qr)^GVQhRGzy~PG z5GaC+Hpn%W&CQq=gG{g>Aife7CIQxTYb(V=J8I-Y1#G?{3^5&{o&#ysEDrjD;$kyE z5OQTwV7!6;0eb|(iX3dWP#PXs@ydDY4)ZovR$x9zP<=>v_YSE}-~~9;0;<@`;N2r3 z4%(Q!*0$#w7xna30N211kXD0uia_e6uW`LDC$vTgD%(snz#n5`W8W4Lq4xLp2hnNR z7oFje`qVpW!Onz`_FesswLcxo=a)mvDl|@5wh=qfCl?$9;GN*EgI{&vtsv~7bkPD( z>1%3g6!g;QQU_OUsQx-fJKx91VpGl|l2+?mKh0^~TpJ%9en1(O*Z9e|IC|V>BbM|; zx3=+1g%`Enb;5xWV`FPukrF4pndeh8BM+L|b7~yDF1%mPyG-_zV^+Rj|EF5qv79x$ zE@FI6(iSmoIvC>YNsRv`z0X_d;zco4Vo9Yfd+HFs$-t^*R?(w;U#gU%w{jE3xppPk z)%~9B=N=^Z$}#BD+YIX_sv6WA37qH*7DWmXJ#OtzDzh>z^HpgK1Xoo{>r*WEtE^gL zr)}5ELJMuN-#?F`Njz-sSk(|Q#|g?rZLaK%NptP_s`=dPNxYxuzBz;3azoCL?PS#z z8nR29%UMc;HVa-W$)t(F>*?L=`(+RaL~c=lsZ&>{gZ&vGEc8Em5bX+{=Ba~B464l* zgt-^D!BtRzJq8W%XPR&#sGJaj>IFdp%m7HDCO~VjKDEMkK`tkOXaJoN)LBp-AW$n} z{P%WIB}Y#vV0H^GC(zF!ml57#Fc5Ni>?8K%$rGsD_%11Mt|6fBRQpx<-$d_e7uoc| zb{R^MIi8=+5>x=7OTZ+R;YEOuCh;%TP0_c*3jX94>9}td7#H7BK0b#k_@L;qW{luq z7_)$vEMq{00hDnXa3csSyD|&V@2k zw{yR-$QGRayZ7&RtlHFX^OEC$_#68^Sz68llR19X`&i5}rP0Z6_h!E@?LxAwp-WTn z#C-Lx8-uIxa<=dYDz!@3GsRgfbys}DS+IFcuxX>hwy&N)(M>*(&XoD@Z;a zbg}2fx?PZsfkpb~a)m=Yf)4aDVHJ^W3{XmqSAXZO?4KyVFu4GqIBRs>u~rvsGN+!s z7p!deB}+zc_wYb0fdTO3;fyzaXln}q6d<_95P29H8bU6y5rRPd>I%9C2!Gm5K7ybZ zBbkk*U^4xI15^GKB)gy@cFY7kh7QbfkXMnrd0^rWW!dFjrvZNvMuj7|?1*iIXmVv` zWr%wMo+LkH9)dzc5gp&}WH2KRbaDXco?yU(^JfMq4Km@l8U3SK|Kj_n;S(atUye-l z!ZBGo5^x9NilkHY+^2_EnR@JG1G7_99io)Vg zRs`9qT+;fTe#tT@T?SADK8?rLAcb@dYra&1>a}m&CygMx4<2AJfZ{}8S(&5jo{Lcr z5#b$~=J@_c=-^j@nv9}`n?iOC+cH2?!eU~UK_Ab7s8&{M$j-aVr^sy|fUjEvlK5{w zeCYm}{6Jb^z1l>(9X1GZa$x+1#YB)v#14E33Jx&@PuIrkpUa!A;KG7}tgeDgxMSd5#y)K)Yr zUOy3pc+eNn#Lrh%ggF)ghM9wPNwfC*L7w^KSK@+QPRBI;4&a3pp2MAZB^3NNNe7gH zE#LM5#7$J0l_$S|#j99Ufh(Kf*9m@!2G9f6hl=os8_IKk-%C_e&-MMm5%^!ljhyh9 zz_qG!<)mQ07%(Mp`7}D%))OUj+kM)V434n5kDg|~t45-;4%yt*5_i3gT^v`D zjI#bJx-6tTu3TY!`hK8s>F?hiFjD87YB`?_TpUc=6Ooa1fS3-tO#@Un`^%?7?dPc{yW`dI%Ct^wX^YyzwQqHV@}^TSX9LS0eydJoQ&@KQn=JId@F!XcU* zYKc{mP*|U$NK+PCJk?a2tlGRM82mZD??~{ehH76$BhC)RO@YaSIGnPfeeQgpdf(A; z;(kB8cMN%-KmT7Apo*uCaa~|Z$v)_lllu!!gFqsi zz=GEp{3+K6%NT54DUF*-@<*|BF<&V=GkC4U|L#s#`CXH{%qHWc-$R0CB1*4NkqH*Z z+3Y)&*rg@!o*HjN7PEJa85pPhJf%087G8!^Se@E`%+DYp{EfO{TGXTd;O5t#?qZ>| zw6vQz3>Zja366xifZ6UB|Zi8HUZx%{*0B9wM{D z-+Xj@za$kJ>2QBwo#qhpERN<~sZX+QV5)Rt)RG?{W6(?z;Bfvy$3jhB5JtKa{O0?_plU#n+- zBt42e;%lj(Op`MCm-sa|)B5Wp+1Vc`zAN$Fd~4mli{WKi6@t;Kq1^XlUT-_9QxnZ@}uXQ0dl~AQwm5j9*}% z1d(%qAm&Oy!SG^#mij;j&-kEq>;vZXK=~!1_htAHdLe zA5M&qrO)V(S7g5Rcwlf)k~yA%npTfblrjo*5#c8|(u}v<=Lv5HudJ^x!tL}$7!7|T zAM|->UTx=98Y$L;&<;nI>I%)_;{3KB{l6G4|KI8%PUu=hL-AOvYT2(Pi$clp6Uy^1 z0-1Kvi8$ACns^>xbau|R2(YMVEAfcGp)}`X36l9q=WacRCUw=3R8c7GnIC~dvhf7k zk29=*i?{rBpUQ2z@0|>aYDL=KCJ6FTW4su9^J*tp``P7{xZ2lPeYe9-dt}l&?8;MH zZ0-|%QI>>q`TDc+vm8URMtQ8f=~Gs%MeNvET8cYbc-I*)D!09|Ukg|oCvC?WDr7yS zEqok*+q&Yz7!%{gFb-M!eO0z#8TMHE%$OQYS#&jJ3z4>_n8hjY*G#mmEOWwMjzdrg zl;r#@#E%VT%UU9hSZ&oQsJyX`1G4Y)Z8Pd$>H2KMWvi~oU)5-M*DHP`=<#)W`+IfQ zdmYJkJ{7Fc2swB^l~{fyuc6yo62p(Hb2E;@`Z2?wicQM0{OA`L=f+AAs|{TSW(!wX z4Y+LI_Puy_+^#RlY)_+#dBp@fyidYem;2qrOcqNe)*v*ekZk8~NsmGw$RSJUfnw%V8^{7IY7p^B3ywRnkg>wM3uT=*Frt-o{qbm?NzVXSAG_@ zK6M#|D<37Ta;$}x<_oLEw+L=MCd5s+wWJ#Kj-K$%t-GaX)QTyY_eGvm&{|W+A4^7| z*Opz&{>KaeVzciao> zSOmBE_y2I46r=sDh4|wv0$5)p%H#u}R^~|;l3)d8W10u!Mi1c6qdfl;79`yQUi^5K zEfq+|0EahY7en6Vj_r*wpZSTGoAvH|eoVXhA}F?v+|7P@VDU)m$`frl2G0)5_xP_^ zLPU_ScIhYba0kcM))t=mg2wdMJN2F5`#!HPPn$0n0l3RxwgC9+q%cpFkd|)CH%_}a z?8kA3j4<39dSm&)XD2>`i5hQk(D(-D>G=f~$J7m@!}RHY6O9oXY?_`Fe?(?RF)HY< z-B$U;6{)hTzfRjhCwRNZK}_28V-@Qgy!+|oJ6rIT6#Iz&8;Gb#=oZmJf!u}KNQX%= zp0&L^yXL=5=I{7z5wudFjYWu;yIh_Rm-y|+_KDIKJPQX($!*?8eeWLIOw;So4o5}y zB>F!QU%#AkFn8o-TKn}At~pK_XkVW$Xr!mV<>k(|#QdE|5~dg}?TwFhbsr!=xbyQt zze78Px$4uWi)L?xXF8XhAo$P~6(*!#0()=p>tp*+c(P0G#HymJfnx0YpRJ2pQa972 z@&oF$7H=thcTfz^3go19#c=1JsTYlRcmI^rSnXWVzd1j@Ju?9E)wgeGNSFaJSBi@_ zY9{rbCm@|8C&r!jL8~?BZl36jAUZnw$2fUPN~)Lx z)fsn8hAsJw7mKTM$d8NdPmsK^b2ahm)y1KXEA{k+DuLgx%xvDUdFjLH{c30gZT{QQ zLz$bHC)dW&KL%evr9Kh3n|1BrXx0wT=i~_0!f966g>GIMe|67sjrYn5A+Mlgl|ZP2 z!NTqh-+*TusJ{+p2am^m8>Xp`_#CG=Iz>dHWrGMH*@-#Gi(ve%({l)}(V`4#ct2V0 zjI>uH6an#TuK~SvsMngSgH?8sN`UaA;;8n@+tO#A$#uH#}Q)MhPyeBP` z*ZvX<`%Ng*TdW^%W?7Qd3mznul2=zHzS5E-#EzQPAH|68;R_IZ&HXwP>*(6>_I5d$ zr8-xwF3a2l7Ml{wfbJw}%}C5EBx*DY<83M(Dd+_frq3itJDNi*RDWv~#CK~g=8bdq z847S+@JR*4wckrK@d`K?3n;0xIXm#vQ+-)5m{G>X()rXcQ}CU-D#;)Lm*c!PZs7uD zdSXOqhj(EAat_cNNcZjjR=Dr@Tb@Nt!}VzWCAA$+s{yzH$R!8(Z6mmO zrLJ5UJ^?4;?qWCUnDg%r76?{k|KR*U{H(*ZaJG#)A(*eb{cfk1D(bcBqu*Sw=R`l} z8#OZ8+y0r~t_o^3R2G=W(Dz&-N%vU5>JwZ}HLjCU;Y>6JPT}I>;xM9ZuJ-)-Un~ZE zx)F}e-k~1!xMTfm-yHx-G*O*Kc$Te=bie-Y^^SyD?#wGXf!Tf&rS)? zy)cYxB`Dq`b%wV@KT2VBtXZ$sdntLTlji;0JIfap!6R*+?T7v%$4-i1$?T${2<>t+ zcv`oi2Ng?Bf^f5?2kw7_$>bn3L5gu6`4BO!0fyv=m<$n+taoKZtRK}Iw!UMdLFkto z5isS7yPD|Uls18%yZi_&K^b~7(bIgI{)Hn^KVL6 zPJSNPg(dG1U}H;5D@)a?zW0fE`fgkDuFLcOZK6Hz5>5OVNoh<85ZFt#BCD$Sk*h=C zzamk^&9gE6%g)n^cxEkgK1$jN(pjqXiM_wZ$K_vmQ>CS) zF%e=R2``8vRHJPR6lx{3!EA&d#zcTg4ev^As9r!EBYq(OsxdnKTRDgByLqZFU;4k3 z{p-l;!7qZGhnUvr_yF&bpYYpk%2PHr?2t2LR7(C@4eY!+*x<{;@-L-t;Xa7K8?cB2>VIfz zDqOwODP@BCNko83{c2P(tV)D$TmCc4j+ zHOD)wj1o8sDK`~|T2^)|CEB+R;iY7Oqz{p5dh&i2+J#|6-3p+lB2zPD>ij#MIbGzU z+Pa~FPbpJg{$>d@84F;6+IMCZ5f0UgcWRgw&zEQKvLE8ojo&Zd)QC47vnGgY(q;`% z|C6p?A{-$M8VPTY%bjE4TuXHpQn|dL&2w%g5>ksQYgWLvF#N&^!2AxTSvorqSEH(D{4ihb9QIDp24>}m+XcAHC%4S3-vGXyN%30rQ$bAKL(Zh%4y^Hf<52$|h!Cj7cVIU6;p1Y-r-)LPZq!Dlhsdyzk z*&rP0n5*M~+h_N~BCb~CLbS1fnH;NhW48w9E_uA&_n_UnCQkgF0O7eP^KYWbaf9^1&JMmWp=GeaG~ax#CoY&`*653wN-h}jPt*^dQL(r5?Wq?Vj`)A+ zVmn^mVM6ygPrDMQ&y0C`&fIXJTS-v){%s`Lr!Kqc>P>oy_iNbGW<9hDZK%tRHi59w zE!wgfuHM}Ry%@KzLRVXzbVNTjcAH+|?d5N~(M+}Dx$x2UMca$|-8@rm@-g;KHkwd+ zG6~-+L&fC1E8FXWXi8Omx(d6;Ir*mbQi z&{st%wck%@CPk116XFE?d*YM(_*PWcGUtu}0~rfRS|JHuKtJzwHNCvhZH{GY7IG{< zKfmli4g4GURnxS10dc-zez$rx{qXGFF;PxdYC8g+y z{?AuflgJ#|97^aL>A9EXzU4M^_fV2uBzYM@^Z>rbp2~}hvEu833=Tj;9onqWkzBsL zy*`WJsT zJ%he-~%g&F^gIoVfIK#e0{PPRpV zH04MVZ@LXkxC5~8M3L?JMMW!!sXZfz$_Ts>NO)heZ4++IQB&C2zjA6~91NI_v%h@{ z$EJ3Vsz0r+H(m<;P_sAq1c^%n0tB+6q}|+vkQbi;1_d&d)&^2VBM(^@Jjex~Jz>2u zUB*L*V+&rN9VE8vf&0ZZsZ63nfo4u5^#Hh$Uc2=dfW6Gw@xzmlwrOTyj(yA#@RUUX zn{_In`WudnRMn@V)m!rBuJ)kWd#9GSlbd&C zO)3_mr2B5KD7Id9MLXm9u;bA@$FF3{h~BLvOUhJ_RVS6E)Kc(95q6@eC28UwzF10% zZCQOG zTOZMElT2l=jKaK1f}7NG3y1DQ#0)V83d>VNO;@`&PCoYI zLu;moOuq;$&c9uSaC6Zy9+2!2 za+_0nH5G+E6}au`ch+*h5GpKcw(-3njH4fG~#=a z4(zk+hq58$vX7N!nHbxSOVaM#^OtG)@c32E!o(IohC=vCE>r05+p?25&r9Xn_qhMK zhB$cNTeQM_Myje@;fJ~}cBQj?@^hw^<0L+1*YkWvMY%~&g?5gx1-7ZnSk!15s+Bqy z(+sVlTvwY+f+fy0tfnA1&BuqquerI!gErfgjy)hyT1kqTvohIQMDnYf@zp-O6k6QI z9s5qUFaKnHkK7G+wEf(-Xks%>yOTBhI+#;h{^l~V(W#-X);exl(|@4Ije78s^_u<& zm(pkU2YKZMp_J9mYCl){&pd^WmH3)%nR=#sJyK|?$< zGZ`i2i*ikN6;@`UU?RksJ;d&J30Loz$#;x0in)?l)x^Kal$f)*N( zjQ_>N5Tx|agBLv@Cnc2Vhw_MdORoW}vbYVYC~LeVsm` zi&DM*p;#5UfgnH--G9}5>#Qi`6)sI|dB3S67R#9`C#zpO^p% zfVutoqT2E@2x=bX7=x4+*qX= zGhX^J2}6@;xy#{0P6`_G>ooUO<1MQX&}b?DEQqp6;QsMteQ|r0c7lY76fa7W`R}!2 zqcPm%G9%2gU%Ya(a{Gs<*Qd_T8b$;1sQwAAXPqY6u3_tm2f z8g_EzvcJrU!x_Rz4rV`XH9^lcRpV6ZRvcGaOpj~g!S^?1K9^v1dvkwDhk4X7SHV-jGAO!G{2SkguDGFDl4AvO3Enpo zO>?0pksu70(XMgb{`|c;*OD&B1h_RMz5>Zgg_ai~*1*!!CP^UD0tiJ%LfsxC&&JOj z&b^}{37ke~QM!S<7h>X&J6!uaR=YxZSPNGje1;XkyB&daqvtAtu(u((`|`sy!^N+U{WnZeRtx(vQUp#&D^{ZpMn%+aUfCjc&Zj5+JW0TX(jBDag8Co_A zUmWZ+=i|LT3a~Ci1>BKiBX$eD95ItZ{gx2y~eI8g_(Me&w;H}Q}r4VUa_vv*0ce&g3!;eD={ zoq?gC@zY3HlkXE_Y{z@HtaQseRdHHPy^eY80o?abWm#3p8k4;yPd)izkmr&TOj$+( zA|VTicIJH3Wh!L@GL7yOPi=xJO2W%aOt;+15HyxJv@E1}2a+2RuPsTF&Cj+q+`c8?^>H)~Zu~+4b8@>3MmVYTlN+y0JVOgzv%bERpvmFmyP6iq z(j~<<(PVs$UN-vX!+BQSC>eCYr*kxJ*fIDCvba*`WO1Rvlhmo8ox5#~Gyw!6RTtMH@gpc03U2>0h`Gj~jyWQMvyU ze>80l(hnq3(f|@IkSJ#mk_83@Rl?JRiBupFl~-`@d< z3x~D>&<^C;LxR06r+#$A_HX$N7p)~&;UOz_Q++a%>sGe} zgmypKvnv^Wx6T??*DQFI%{0KHDHS*I|5^Z{*29Xd`!|(a&6Jr0SWQEmGFn8sv>#W; zv+E{mOS|ySr9KgO=)2HssuFY`pE1*d_AXH{YL(kOOyqQ2cDeBmQAlg*)VUa!k$?m0 z*VyjjcWNTPcoODp_6F2_Hq@xhP5pEBSnonE0irB7&W`Cuo)9^5R+$!mKn4_9LgLVJ zd3s)Upfo<#{=sJ}SSM77R=P1z`y=Jx;D(@J_1eaIo|kQK#xQ5DVfwn@+h&H?o-qzr zX)gbqpCCC3{>7yCJ!#9)p_wEB96FzMuq1NBLyB{Y-5U8IqVZn z%oqxC+28*rCHr!%jSw&cgc67o)QtFbkX&qNqX|Q#Mxo|GbU-@D*3-`anj;ycUka;2 zkrB`RbYezk#A$w;AEYjs-@f%YMW0rGxrn%XF>_t-?Gh40F)%%?46VMw<;loL5bp!_ z#CZ9S;Ibhn;e`S;>|j7ciXm8HlWbeQr2n;Z0LKjzc7Ixke$1c$8Bs9^t<9E-b<#P!R?bKf9 z0)eX+7teU+LPZ*@Y%xFD*=c2`Ks=@FKlu?nF5)yJYNn~}SB!M6b_+u-t8eY@%WR&F z{e*@(_v#$ZSE3A@ble^%-r>ccyPc@}f)QW)DO`k~et%hcsHjd9rhYdP<-*eQJrsQ) z-8x@gA;W)H=;z|`wU2Mxg7OnQ&+I!OKU83H8G zSZUH8v6A8|4nc1kXPSvml0*7YF!|FBYksiB$7eVPrp3dhPWrXoNS1p|MaFN#De`#9igue4RXo2 zt~<0`S853Ta8Iir+$c+o1KeucApWrQutuh*qF)&1}_LnIQ!f#F-HhGmY~YZi&KHE zn%&QZ1)fELYseh_cOf`bEj~H(%Wuz2i^~(S2yc|vSi8_oPl^QomA5Ox^zCG6_v9;P zb#f0#baSq)hNS+8WVKr$aSq)evYw|fpc@Z;#=*+)w)y2uU2S$?kQxr#7qsjt3ZUrCzGLXr!qQd9IJ;Xj3aUK5C32&=S%XwvW#+ z&OApjOEmFWb3#4hgP*tK<+4w-_Lf}W;4<<_x1TU;%Cr9_YCx{I1y3i;>S#hkzZOqA zvQlrU0|LUEtItk$_bCMmCLa(-tF=qfIjeO*(yVR;^zn;8BZRsga)^6*3w zvDEX2E81lM=IcvS0T(K;;r3#x&%sOsv6eppN{mW6_Ytb}_sgiKi?0cNT z!Igts=IA{eL*Y3@jJR|Z;!M1gf)Y4!mfM425A07VUH%;dqki+tGcsdMM6M%2F1&I90|4XO0QAN55H~d~8ak?g`1i<0M9L$S**=qRBlHXgMgvDdlxZ^J|VK z+S`$Xgw?K=J{0A*;~G~W=UwQ-6H8)>vC&WK8=|wEa<0bYWy{M=E~6dl{wi_WgVND? z?00(Ig*aAVpj@sxK0_?&dvtXWiMKT7{-#O^S*>P_C*@5uL7P(tn6hVwO$=L+dkkck7*$YJQ*28EYh2V(+) zihd6Qs48<^5NO05v`E~b=46Lnfz280*f(ySajaPvg<#=mhUe;YyHUxg_$|AAp#NRP z7PP2Ylwwq0`Pdn$w~V${zLrM`-MP89RpDFN)NxaXzR)n@lrrmtat50rJ55Ok$CyR|ZmyVcjo;sf(Cp{5EWp)HJ_Fk5i#g-AL4dMMKs-mW3 zJ$WgzMw@j0!^L=*+#L+H`udK}P6IRO zYy4bcC6$gc9h26Q%pmlvpCQZiua13|>KmdRz^PO<2Xos3KH3h?@n?wJCGhkkM8!aH)#F^L!4Z+#-W>|<6p zNQ8v+XcKbYs9!CrsfrkxnSB4kajSr(=;iNjGiAYJ2D0w7$l?8YUbgCsX#18>5!v`+ za#nPq7~%=>P$IW}SF-5AkO{9F=c3d-8h`R{SXxch`H5_#>^bkN-QH0nAt2dVvuKKN zLS4zQRJ2J7e4!!hw7`?J@*uZyK>4%apRW$qC5RzwX66k^AGa3Q=<;1Nz1`ba{MLQ=^dF% z1YOEkG88B7nCh6=Yb&mAh;2>dLPv8$o`G1;wh_~PRg#+SQ_uY2DJ}-OtX1PY)EM`F z06HRTGOBpnlOGh@^8fV|MFdyi<=?hGeFu{1;|&|HuKPbGeIaX<4t%a#D>j!0HkAkC zuSM=n3#C_Ae*)FjNDqS`)tqf&X|G@y08`W-wt|5pxmQ%vgajCZZ{F*oMC`Ec%k*oE zLK@bx*|-aS`71JCCF!40vM$LLY^ZHIygAHrJ`Why>%x|(pp(1T_EW3#j{FPn4RKYS ziQ-}PMfL(v2aHu3GjCYCt=%Q3iS6hgn(FD*uMXMY-)@Oj**@zkA`X#aRf*Gh`c!_M z`p53?WhL?eVF?BIs)%784BxtG(Kvg(8Pcj@t;1IWPk-HH*Bds{)wgm`Epb*2Nykua zQewPs6&tyZGB=R2L6-YLjj_AVDT`@1N2eCRMe_JxuE#6?2AI@7z|`)^hWTB2zCsv0zro z8)6u`J-DXG^+Hyar35GZg7sxmt}ewd7E+vmW&oGbeHuPnwb0`d$h6~sn0|gpZhkTR zbCSi>PzTTS4tZ|M=f>}U-`fWow%?+}jrdH?eV;SZ#OR-x6OUM9uzuKQTNC!6c2e~I zC6+@Ico>O$1x_jA@9Qsn9t&R_EeM}ZmI4T4KucV{a6>YqUwr@9*jNY5j}cnYLf(2D z?Z|E!1A`eNq4v|;=4x|)S6u*0ZXr=AhLm(5+1vi2sIMatNJtc#h6V{Bdi<{zjx=(I zi5Cmor7dAuOJ;h6uCArDEVl+A9>}wQ9SSIdBJ4mh#oDEky9)V0~2uoR*QtVnTmCGMsBD`ioVt4 zfo%ErG7VK+rUYrCCOSPedB-;N??(&}9ztxIXreBEQtbw4dd3eg@480ulfb~AxkLB_ zdAF7GHrxUm$YpT^?8Ie4UME|U(_n<4xasC_MAQ0ua8|2oxpa=S;_rM=>plOb$>mgO zkBPDzx2#Yal42FQ(RG1GoS5t6UfIEl>1Wv*K^5l1bB6nMNM!n|BQCF9;~txM{|YM| zLF9S<*Me+R!Qi>uZalKW2O{9!tI6xUY;o$~QDPsGI9$V4cF=9%#Fw%&T&S=dV|{*8 zwBBZTe!?z5RUx`-=`Y(tmFLfEd*^)*r?oaxB!wD&>twO$EQggF3C~6H(1`{Uh4PZk932rwfJAq2`N~JDblrB94 zp8xznH&S}GDl0bcdyON#sHji*gy$_cl1KWf3mDzU(9TyCX2l@^K!3+eNc2Z={UuuH zh~`W92jqemZIccT^hxn!tvG^Ale}rD!eV+%K@r#*Q1#qh zs*Ud-$QBW1BynYk^XDRd;6njL(_5N12g$G{SmW4rdI{rX>EopHhEz3L!`2N}A}3sk zu3_P>#aI4b9Qc^6BLr0bTqh z8NEfI7Xu_RSQP*Ey=>+VVJ2?rA_1DxQJ;F(ll8pDdtgf_PbTg)E?eCJyHF%wt|`dn zZ{N9tPWzcfCEfDib;HdHkt9#=$!r|)Bu99(ZI=V4kc8 zF1T5D`X;7>;U#l<#ZhLMcJWKJk5+-YZz=^K)g_UxKz*?9#ng^wbI@F&!o`LDZg!kXn*##TRC( z4GWy!tGLgTKz!j2QXdg442oF{GQ_jwRQyGCfjaBNu-0HJ-p29i1`H95wIC>LhBXlY`(ytd z{h?%IZM0IDLLMj%VYSzE$<&|f2UsQ{f~M(vI676FB!#`{ZF z9s6u!+@^90`Sw;NvexUTt>1sf@G)*W(yx_nv=%cl1{!j6@*`%swaJl=hS@8U`3xPJ zp*^4YK&XKzJjp32B!+mFdsCYo`f3|&%@S`v{3NijH>6$rju$xlE|gqOP>JF-F3!i1 z#ii}Iv_J2bKlxxurq|^&L!F*!#FSRGN|IP9+|ekG-<54TU{r23t!Qt1ML%}mof^I`5{ zhihZ08*(3HlFFrjO3>y6lA_bw%ocr>^f$&oI3V5kX<~i;h5hvG8CPoxsc$HX|6V+M zps%fz z$8R>wc*a$5u~dJ#mcu?c#(u09adPs`A6+R{_OHiVsrXnA)&PT`+q~#$2c8p#+x$sV zexbjW!%UtL1-~o$)+`OJIbahh{fr7DPRfF73|Al%A93k}2p{trSro`;AcI8$=TW%{ zNQ!LSlygXta0k$D!A_uK>qs#z(0RFR?j8%n2`kIm3L|(sMzoM|FzCy9c_}q7w}Pe? zkR^t&yr3HHK8~7y5&(}OQNqXIu8vfHrRgl@4U#lO>;h`cPEe9IH%VW6dmcV=d@@q6 z3{Mh*ta0J{oo>~qAwb&MEVdX8DIT&e54mF@fwvQg33+$~5W2%<(heJ5Z(Tgx39>ib zSA=Gecy_Q4kPh)w0*if&h}i26Yqth~`r@>wx%?6Jac(&0IDA9 z?F<5sU{L9z-VT{x*j_jUv|!<4g~W~pqGfyoA*hJ19=H|>klm#n zf9d--S=wiJnRE(U+2BQBy_FA8DC@d2h}!`XMj~GV#DZaJ#Y^*3n1K=!m_cOsBS_^M zY&>`GBEgiQiUmwG<0HFX<2nHxNYGqT_FAJTz zJDu)OoT7)s?ZD#rF=Qlg{E^fi2y#r4y9_tb4u;-OM}iihY!Wnt6o)qHj)+5}%; zT!ANsY(jhmf@h6Dr<^MA7FF^RJ@ zGzq%>hdR3`k+sm}Wt2}NntDFZm|n!(9thTNq-{2<$KUhCgO62n-<#q|l<{@@nk!eb zhjEVlFg!dR^D{b1wxZRxA7|+;%X|$}wo=RQ`b6xjm+=^m1(@GLI~8IiB^{ldGD3~F zZ-!M<;YI|L-{}>9Y#v95B4sEI&A^xK?q1ryXy>F&35r0IF27Pj)8a=@{f8)Ogj^q;`uP@l&yySYG+fB>NU{6E3^jI0$*1PeBz$OIS3Vh3{?a>T$b7TvdUyav0Q z%2#;t{k+cFz5WxIpt?AO*hgY|%#Oi^(F)xq=;s<6#XSK!K*$qV;TXXsbkM0j2~aJv zU?OG9eZ~6p2YVR6eS_1}y%3EU(GjpU0fpum_EZL$Y9n$P+t*o;#{FMl4&blJ@W58J z6Wq9gf(@{Uwr2ZdpL^gFj!J)3mKHdj6o6ENXx;R}!W%iHP{Pl8X3nmIahd{hLzsXE zk5v);2+;lbRQ@dq+jdHq{;{#+@{rs3&9ktZgeh9?A0(g;)p|jG_!6kV0DpV|zbXQB zsj&!y4zGj3$_RYzO8wkMLq+hL8c%OwySV&sKzr+(?6uho<)R@zrqPJB3$O=hFf+2FhQ;s z(IM?9nufR}&LBN~(IM@W0@2}D749}qc>aVh3~6luvO$gu8;^Be;mfn#a;FEe86X7) zd@ZQ{bUE+`U7tT?m?-^+h0Irwh+fH&SdJaj>Nue%OLy7o-Tsy)JdlNN_y_!Tn4-A4>yP$7T90GjxP=NQ;mV9>~q~}+z1vBCcB;jZ~hTL7+ z;iI$V>3Lfyb;NHi8yw@Y55H6aMhn_1khcxRMp;2#ze1 z1#grjl$LUjD~4t65)blC<_2_Fnq`(Z2Tc#-8!g zpoIi+L4gc`lvUU#bkjSkKaHF=eN*|O1eL-P)VcDhx_DUd2_EwI%Noqk)JnhZpH+>~ z6qE*u!v`uR0~VUFH$iW5E8O!Le@0wW2ZpKgFu>Q^smtu)o3=psvDvot(zmN^ zH*c2x& zju`C8Mhf!$rom)*pV*FJL7ctIJ^@x2N((G24{H9QGlN*qjx`X-+cD^;%v0@_Szc>F zd53*3OQ4o#6iLRix;Jb6W2z0=Q&)FTR%8c6JFpRO8yZ8=Mp8zhSGa&P0R7+$8vPgU z+tR(lyNa0uEcdVJvZ%yWujGIEW^7>*40RJiV+iAP%)9m45)cgg;0F(g`m;}7k0U(3J% zLgPQymX1$!frR6@yf2)Y<<`*Y+O^3)uOOR=k*y#l4nd#Fis3wgqZ~ehz??q` zqBl$wev5dzkSry<0A&3b^d)d4Bc}`~4)I(J9X2ahb^wL~FT!OiqADXr64r}6m%cD` zl4K8A`V&H4|0m${V892w6In$Fv4XanLA_3`2gn%({9*3X+2JW1ac~D@}@$Y zgB&o(W_0AwD-g1=3rfn51)XfJ)Si)}Z(cWrU$xhup_iF|`#mPbjdpVX&&6+=_IH|9 z5g=lH*cz^do*ftWfq7Ns#=x&f-ouhd+{9caH0&e~6I!}+xZYC)YBzjWd^Adx@wt#K zt2{UU2eeE-@`A=3mN}hHcoa>eyH=tlRG;dH6Z(R{pxfQYH$S*76XwRMAJ&;0$Cp`s z%-b&I-1kjT-$XhZY<)UAahMgujej5iOp4kQZ|)|;a&eCNfQGU-SP4XtSn5j9@pkl< zdz`IgMRFxRVtw!>JL^kW*=vKBy?<}}(;GUbMZz|cXKC;5XfXX!eX1+TLQX>-L3ppI zDL*C4`?7EPQ+tQn$nj+Y4^{I2YXSOH^gRq5m>+g5ipud5%T?G&p?_wf3EI4+uXjr? za!E_?5c@^-dck@K_Nk=H^Lo)|;zZJ#CfnX$;s1pV51S@2m3etvg@wDj=UG*5W-&DB z#aM~A6wRs%;Ge39zV&m@S_7NDa`eh%!z;dWxhb}&n`@OvsbQpeh3m6%J1hmEnQN;h zq^}MoY9z>rR8U7pPiNgUpGb$c5-(J;1Dm+*?xUA4RrU(&c7_6GyVH8vBhT8%sBr7b z(TJdp3MYHbKKx3KRBCqYbhbZnCw&SzzAJAvzdW7ac8w*axxWtNDdK^U9e&JOWmcp7Pn8815vL)trK*;bK=x@jCYYw97 zm{V8OfF4tdbrhWX{`T3^4=U%odFUJVl@xkeNl6}sk9&{8K zRVIDyC6o#|#DxpW3LE!ow!>`}5kJnS%L^r_`&GB_e;(EKjgFG1t_%zgO0bX?=!RA$ znyGsK;lDAMp!DtR3+8oJsVA?yXw}M7Q>h@oPW{`Jf8a66S{KyU*GI77Igc$j>c>OY ztBCsqv`8IsPNU^hRu{>NOjl7{YlOJcJnQdXz*FP{8I(K7nmk0iqOmLx(X4Hr5!vZ0%Vo~jA8BXU;I$l_2w#w*rwQdTU}i}z~sbZL(Wi9_@q+L%*4bW_Rj2* z2M*}v(r&5x`>t1$2X3Q?PoCq!_j!$@BK_krND-IdZJGlJ;(kz?mQz#|3CAE3f@^TG zWPslII0wY>044E^(EHP*D984#YM90F14LArC$hm<#9?gP`s z@k*N5QZ!e>R66c3AMv6Iec)T6y z1wc9VBj`WlUe^^B5$KP6n$Q7A4Bn{M;I_yh7pqFicl(h*1GNPe*27P`Yzu3_a8qTb~^Gn zORGP%j})0Zy80`!DKXrU?xdL|P89w;${Th8si{BCwcB@71~j6MJmq&p38h$LBRdq8N&2M6Eil?hLsS$@ydE2fzGECoh9p zkXSzLne%VV>zo~d7r^pSb67Op#7&L zg5hHcriF*dCa+c_qISCq5Sbv${t#tICA6ud5RGV_=D;UQ=|oC>I@(SsVLKpwYhYrc z3$hB|Mu=UwKKrKQq$Ru7YJr+#pkqvjTw)ke5X4ElM`;NDym$KXA0C8hy8Cai1bs6VqWtXxi7uH!q2fR_8@^z;~zi=RQFd$fp< zLPu98q%9NqMl$s{E(azer0Br%>Hv#s9iZdl&2vj_@9!rBQfbx=G!xXd7njznRiXh$ z8?Y=KQKZ8YA0c{TQCRhd4bh+9sy}LFU1_1Vzt|Oy98wkv2T?NL>tg5?sOm2Ei~g(S zz(8IWZwXDF+_fzF0A&&z|5iF^7rWkG(;~gu@%WNvcezhiLu$xZ`zh%w zvw(KbbHclx9%6Nt+}uf~>wzjH zRx@TyV94gLL=r#MU(B@k{rCJ90({ph&OE!w_})xN>oUn#KD$P-XLW7u3452>*0d-o zrrwD7iD>=Fuc8t>0kfXJ>92dy_gt}N3TZ{|N)H`xG!yK8yFAq|-xyQkA+y2K1N-Q= z5S&sHK^w23PpdjrkujOD`@xTWxxh(G9D z??UCrDR@V|S#>S+v#$2hO*S>wE|X09qFgu!!NGD2zLrVDugaE142GO|lo*L3;glY5 zqU=IJ7D8gKJkOn0P6>y}y?q1hds1aOOAr^fK)L0L4O&W$nUmi?kPUWM0K{K_ zP;Q?LWlb0lTo>`|k!e zA_yrUb;ls$?L&t6s_JS20W1W802kpY|DVrUM+siXx8TzthZP`xmvVrMLQT4goFf49 z&%xxelxQ6BHlY4P0yPj1;6C;||71|Q+{6o(HFTf#-w2Zf=+O(lRJEsN zAMH9pdOT5oeix=6Q@}7+t9sq0cT;moU%ht0 zqO9l+(HmIQBX+!dE>Hs76ydN(wss3FCmO3hExUciwWKx&G3_HFE1;pf5KTIGX2~fj zmmueEF^l?~1=NzgaZ4+}c7U830dV0hXvmG!9!@`DCvzK!`E|<=RM3$K1_?vX+s=1h za7|GV@?qBZZN$&fz}DhGW_ZaOhiK0o*Nm!-#jwe&+DFEte^DnhH%=MDY^plV(>M6( zGHNJNQp)&qG+&$v)-QJB)fkZ^iG>cDrlo=H@P%rsRO76*JM?2* zfq|u@q0(mqCClZS(x#R+kId6th-nSyzxZ0Tv%j~%+vDsL*~c(AI;nS%e0`TW1(kGB zV%S|HU#XsBm82D+)Pu^`WRpY7P{kQ3TOZ`do+vL)389h@uSWOU2~mGEild1UZ<@j4 zYs>$6WPmrtgeOq0Qqgs}$4DS4F=n4n0xq2_;dRQYK8;nOIC_tM+Z_?sp^ z^YS~#6rlz4l^mgT{nyWLYLr|QMP>Ned?|b|CP2q!EhmjRwD8;VjCEDvm#HQ(%2d9b zU7$d>m4D|?Vx*QF13f+cf7C#k)2j`?Ocn%|LKw@@@*c$JfZVqLlRd7~Lmq2@mmHe5 znQagCU9O^W=>z=;BHjP&46xw}hZZL3CLSg5&fBFd^C5*4{0w+?|Q3)jK6%hN*+ zbq@`k!!>|5Enl~By&9Uy3F$Ex0Kum~iQ3t8sYiB)i5_>TAc{n6Ugg+732-tT1x21+ zrM@^NK-P}_M}zuHlC<<4dLXb>CJP?qWx6^1-KUUAV5PF3m$|BEdb!L1bv5%nKKgsF_cF4i;JzxRAiw= z&Xf3^+()$`6K|@+`#cXyYu1!(n(QbLl{&lvKTPT`21P}7e$p$sZFYe8ZNZ;Jc^2HS zvtb5jbT)1i6Sn#Z2IqgCBheNvH4Bu`oeB3Xz<9uym*RY2D*0DMBk+fK}gTXycJuT z;C1{m>dAuzWM)Es09a%MRtJI&kuM6#_5eTKF3NgcF6c4O)PO(E9Zx>GVIPNGsf9kj zsd=Uevqyo2;qO%!e$e?Y7i6Yl5;jD9`^38GniL`BZ_Cm>|MV7Tsrl`7>f;*$f8WH- zvv577V<08KN4davG( zBT__M_BC_9CLVp#%k~Rete`;c(|b^hdm|^ldOiajHKj&Izh4#o+}}1| z8;<$%xQFUn{j<`!6^uX3=?+jNz6{ zb|38MG5*Gaw*}L=pJ1xKP~}eNz2nh#(KcjJaGvNsJZ)J}zY*~}Xz+|D_{@{-+Tz}k zAZ#nFm6eCkJmL^U1P#y~#O!R)o{GWU4n_G8X*+C@7gxF5Q*lj26arh-7al#LlEAFq zgUomuB&Gs_4?tya2TE#$)`*1|czejt;Jbe14zkjC+toePoehpph%W*q623nn68nim z>$;i|gt&1jWCWpc#kiNDUt zXGWQ^qdl3>01rpmmp==m%H}%mR~PG3i;%T{XE#!#6e}RSjw(?w-AI`8&)TK7H z9HpD0YPb0quFEkHJ*bKw?)rrIn|d3^lC8qqzuV$xlV~T0o0-LK?>9|?QI;C{S`))v%Sq5U-)L<@QZaLAk z=7bnqI&p(msc%n5MJs}`y?>XJ)`msOWLE{Z5({5cx8J6sV2W4Xnas8RT<(j{D#u%# z|4fr|#wqFC&o`~1s!ES7y4S?lTdsDk+)H&iS53FT^3~%&o^T5ug`fR6LHMK@{V|r} zpYh_YAC-oNS3Q}+F{xDUY3$Dx?4{(`Wye?zRQs`a@Tu3{`r9}1zzEX`tI3*>0OrFw z;^*yYLHJ8wVxl;LgA6d~bV;uS>D3MKB529We2OxuuSuU~`eJP@}gFabesT?j%50^S}AwByg8 zI3E>r;@V(E_@L)Wh>JVJlx`m0jN38O&P!soX?@@k{X0Gc--(}e8ECyD+Lb|g@2!jp zdV_IJ=*gZZYiAGxnNywj2`F1^(SK<07KI_OP?jTM0Tw;XLz9x8m34LP2?7YzFZYn# z(bw>kDKHvrIdNo)&XV8xVRlLL*ihmIw#LSfySH;*IyLU8vMBP$(@{N{(=}zlGp1*J z7tR^tN-+{z`ucOE6_*M>SdS-T)dSQi_Q!SjJur6Y7mlO4It z<;7oAh(m+4O0qxonk1?@Pf76;AB)0w_2fwHyWmpSUB zg~U!T%|1seKhD_1QA|ymo6lr`n_uu?_^N3D+(vq*nLnkH#qv7kV`d&$-@K#{$r zDZqg!Lv^-y?QP>D1DntSFuoRG9=5)l$y?565s&tX$;+tGWH`bwyPuVn^>@1Lu98|v z`@9srA;wD`ves8rE-{&lOD$;u_>^apv5za6#<=DmstY?_KxtR+=l7x-pC6#Q#lD)z zH2nbcL6GMQHBt!Gf@WQl?L+Qf>!C;L+vVGk+Jl&&lO~3E!eRCm-QHF~2;@g23srAk z&U_3mh4p`8Z|iATQtRO4NA|;l%hHpx^%#782+UM?-t{`KCQpy`QceAf*ds@Mujx8` zpK_7y8dP@R5($jozp=%i{$d@9?O3Ef!w)|co^if&IzI6Bv&lAr zeBlk|1!4(BE-!Cye$g}vZc;qT^8caf9HZlGyEgnZYHVlXiESs1ZQDj;qm6Aewrw>@ zW4m$VG`5}Z?z`5vGL!t8Kbh;^*T%8WlW8dz0jSA=!%oC1Kom!uc%_aR0%)-~1Dl`! z-U{hl=^%FcN&+jbcrE~?0c4@Jjav~u^=9eS&clXh`Q5Mldxy~nw8=FU&;lc{mw0m& z%gG!$%2FsE;GY3V&Gc;-XUZ6Dzv+bir$#!1iA94yP~wok4rWh^TtTTpt60L3pMsZ{ z(=5T&VqeU+g#m8DNOKkX6sb_t0aiFYL((*+{1*<3=90s3IQW{awiUt=o9{o*8hwmF z0;xr(p@)YV{j=k#NyICX7Y%qt-WE{14`YIt;D-3mm7xk-3=CD zfuiksx?|FAa>YxDoV@&Q%&u>2=9+xIVc_q0;TMfe_@#}q<;r!Q9f_^elCqk?+W$JJ)6;6c(JDi+T<`DI zF!An+zMpGTQ)5wQRNu^hPurv$zM~XX>-S(?|K{&)mU-}mU~UJJI9sz&y(Odu{*I00 zQRvNds|98P;$wYbrdl}W*&`Q>wu0e^`#N0Z-=`XNxB?ngg&33nHW|FQ{3N`_+C%{7*nAr#})*4O&8DB(2 z1<;uL$G+uTlQD}_R0{3X81uZp{K}j z88xU8gG!>xr!siz>O3=CBiCHiV7^Y=jTK4ETvv99W-W^g&j?5U!3nWQ=(EOf%EZSS zSynuXn#aS)kRDTv_V-Co{33L;CT#?obZu(x0UYAEXb+W|`+Q0$8A(jH0KDlIwC*S- z^;m;j0!DkZjCL;d_2xrwEUa;wXz$|0;IksOC?rl*yl^X-1qN-Do5^^>%Wp_ z*ldvjhlKpfMnali&dM?=k&ZD>_pGaW>xeJ;B=~XllITGF1BV7)nA6B_?<*{3l8)UMP zWw1Y;A-6zI;$lF?oJv#O<*i?KZFen+I+psR3H!HNoW_%OqI`d2g-eo(E57|w*PCNhn8u6su25OGu;@{OBk!*r=$ zQjsYJTAj6Ah}ge@Kah-%gx(P#r+>wTxpl$8FOu|B zL`8u+%ztJZfW*-}X2U{h zXAh8F$gu+V%l(}3_VgYAC3O8yB@58L<63eV#M1odKlXlp@g6(Q*ommWv;wHG{cF;) zR{2azJ1g}=iaHpb6V?_rN@3gYS@2NQ-siAz_sPCm zB$L?FKKx}xH~!(7@4~cv4^RR}q4!3sjDDt!nJs7g$Fd3oPW&x)1n_2NBIInQoF;O` zYA(ih(T?=UBE2ngJG0E8i6(YtQ2kOy!Q@)0Ma2~TeH60XyG^QEtmODXfGB(CZvmBBXjt z#XC#PN=NpxEIkYo+B7a(>BCPwA0L|S_o7^l`#T)3*Ll%VrvJ|Zyc?>}Ww>2$lMA3M zA&n@Z9%hZe(7-=-+ZlXZc_xdIDb$+^zE3+{C70R+qThM(L;`1+ghhO;g#IS6|mym(6k*3;O=X9ny|4G8)UGs;B zK|O=X_B@$25~J0@=Liq`nM3S3I9LcRD6(XsU@W*l2L`f>YjZB~%@89&Y*-M+1E}76 z(0E%w$Dikl6Ka6$#!0ZqYw zl_b!{{#VqB^mA$(t$}K!@Y1)arGhxVHR+*duU1ej8^_ zZIV<`8MXv79abo(;NU*hV&mx_St*YRiMydu6ubQ9($4~DCc`M*qx*zGr+>JjPdXnV z#=1lCwB&;Xfz-7H#Br2xAs?XB?LMtrthY>a$x9j1wJkr zcTEh0YfCdrX=&!*4G#LEC@iV6E0Q6s^AjjU1rE+_+ySUSexK?tk%+2{J#RKhckpla zKk)nF#pjKR=_Qb0Vu@vgpWwHGh}qRz?N6{O3(>Bz+FtC>A6VG6e&gwB5xn^MDmwo; z{dQ(Yd`+Y6==+s9;Gs+mjk%PetxON)-kf435{&U(vut>d-GHgg(v(7pJt#*LfiKQi z1nf5o)TI(5p6{!l4R;XvLqKbj`NsO+!&?jQs>Fgn9Q8xZwFByei%|pRD1-h-zZA^o zwSG$m;O$NNj9N8X&zz+yNI3Qpb(vxn)!HnD(##76O!#1te2dhP26{lGm8~yXjxv)2 zlxof)k4K4-Y115e;5BJ#ri~3qIq0LzJ*CJ%_cJ5wuFYC)SmO>Q^QHok^42;&(UDt@ zHpK>e^`%>}U9Us~@B#xH7{;p2doGB|NEhoFyV@n|R7-G!B<7oz#NEwU@kMh(S7djI z(nihR!76(%g1}rFFjOW&yEEe$-dllGEJ$`EW5q}04N;-uLE^Kg2;bnE7sHrTBY=Dj zh4z7rdEl^#!aPRjQx~r0TK@C8x6A)rc%e*iOkQ$4U|F?w9p@YT)&G@PxmvJc1ua;= zhy$%SYdpy&qVe|keE4lm-rk8;?DX=Me{9D3U~DrAv#$}c=H@*fJVn}lQE$@6op_y$ z8ZGDFEBK%%)+22~*wUdHC2ZAMr+(`OiAWYn^XVGFES;E^A7ejbxx4hO)$~huXa?r1 z|Gdm^#xpF$M@A~CVX9Y;H$i0++9!`wTmy#f*{)>70OGIR?7cwB;r6-E71fJF^1(cJ zkA=%Ef3+KUlCq8pB}Id=iH1K5J~_dMu>NbA^VFF#WmIrNTgP}4S;b@EkOpQh2J2642MBx6#R-=M9kmCa``$`V5k*L}gp%`L^4MxHLm3M@>Dp4J-1#jBWPQ10&TVn&Gr zI}~0cet#EYx3rh)c*{`Ys77}%&B?~+XK<;J()D)rRbb|Wzfkv*=$6;2muJ$9Jlp2O z-a3Yx@yFsXMwHXSAU6j}7blA+OGH>fY^tIO{-(uJIl|3>u-7Mi^g<}r6MrO9s2`yz z&H4tirXajd_dDg`9#q!IZVmN2@gMxgGfAwCv+ECEc`b+@#i;v(s_;p zFiRQKL*DlK)T^WpETDGZmTS=cmIIWEqf8e)kB>^J(yx6w!t8|apBDAnLT`Y6j~H)%`$10vAzv#70zq3bS#~v{*^PF$`{q}? z>9ijSux#WQLu~S#uh%$#vd#|3Ti-BR|2VTfyuJ>mBxe-F_iHgog5QF9aV84f_&yK?;>7@D%xTajHbxWHc?Tr z2#H+a4>9R{AEb)gnGlpETIXWpW0I!%73{gXvM~;L0x0vHxedz2rmW2 zGfGKN3N}N@>9QK!musP4+$Bxs4voXo7?UvJF^F{2DnW@M3R9NE!+x$c^m`P=3G)5^ zH2-6W-2kP|1{*R6^0y5KF#eu#6R1n_Fu;y^6qxCWVNw=LS&%TEW1M7jOh^ z8MkKRhh`6{2GqFPhIYR;Xw_(2u1#Re&y){+75Ln%bh+bS5m_Gl_Gkwt$81IiIHh;R> zmf(6pW)eE3+M_EgwV>tk@!(nGgIq3^jFCzlV!JegaxUpY2N0akE)+J@)DRWwIQkri zqhd22U;o;EY`(PbJwM#+H*Sp3P~{G&666?}d18v=v_*#1wgvklDZ8V!e5njDOi)U$ zSws&0ysPj@bT<5$lq`W+f<5wx7k3-CUJKyCl#+kR=&GyxGFk0ZQOnGyGsb^F3!R;v z$*ceCa~GXF)`S^eT@I+->56vX$t6GLgdMb(g$fR~U;Z6HlMclXcD(-ON_}xNQv$E+ z5vN?4{Kfk&%8M0w*ZtaAnExV5v;+!&21oPo*7t?L4Bih>et3ohG~MqcKq&`<(h~(C zOh!~}v9cWd!Y@no-UX|K1>HqNgDLWxAXMINHVu8)?doI-yJ1$j>gucMiZpRm{rMK< zir&w2pRX>LSGT@GmxCSx{5>^v_7)eA>y5X5i24-xQDm9=$rL#UK}we(oMwX=OCEr0 z6>Bo7r|!n&jt#P3lOjoXFdtNQY4cR4L*P~WZOzpWFfkk`n+;c!#|WLb)DRRP3Ahl0 z=5n*~23!z+krq852?wxrld$I}@q&gYD%b}KkRMBM)b!5CdeMKQanyPBNF#g?5VX&c=@dCtfAU0SN1rH&yU^1rz>oA zfA~`gepgY?QJ5Wa*A!`tG}z9Y9wxZE+pkG*a7|!{_S>zs6CCMO#X9_br1LGZ*=n8| z{O$T~dBT|$(@De2xb{MK>XNt|DIAF?fMCHUv>?*1V!k$&jfiX~MopVw2ETbnjWr%k zveIqI)PnNza5i`kcG+hjo1Y7*kj7@v`?ljHh8Uze#T^vI*!|=BkvsC6BezURGei82 zk6=z|Lipf_HmCcf$>xS1KB^dv&WAT=@{jb-0D)1F!@@&FgUOYZFe9J%0j#U%Nm=}cjT0n}f5K{uZA#w%iKg76Rzjv?0Y2oE zdnHl2dEdl`QRGt>QOdOdv~OHGAp_XL!*ruWj2>@F%~!6Ibty$b+)4fBPkobn|jElsswGyvq$h;}r|E!0^VCe}kV0 z39l+S5g0-OnUi3l`DVPc{)QD%U~^~ z1tZ0XarZrXrrIokiQtk5@ru}g#>FlomYk@ZZi=7(^1lcE@S;(2aetYPOv!3`h9cW$ z{(OIC{IH=fM$W=MNs_LB5jV_YOIfpPq>T+LJPCvgq7uED8MemHlJfbI{dPVMI2y+P zMVR%^6Fj}OWNS6U9~!eW04UwytY|PuDBc?Z*U5LtS-k=)vy9RyL2aBf)vzCfHofhO zDp|65j9dxAcG$|tsX^#N94S(YfR9I`$Ag0oD??GNzPKf23^BT=15&?IIv~ql(oCpo z1GYS(H)!}_MjvWn#oY}EB4u!XhJm3;gD(?dKkFb|8)~6flNVK1#}w|m*F-q|SzLut zw1uB+U=$4u+~!b@0|RZ@JsAXur=8;G3Y%SEBGIcJQu-+}bF#TlP3&*+^(DRJCvN>AswQg%>>5~;>)|NM`2I?RSc8;L0C)C_{Q*^I zQV>NIoS+Y*BJRORhq6~W6DfnlX%;R)pEX4`mjw|;DYByzPy=li2526VDiNgtAEP=`-jOP>t^mk-9Ydip3pgUtd;H#{$Vy~SQaLgMiJ+<$?XjZ`fD2+ge!QVl55 z+NGzTBYs`?idkLT&OY{ZS6Okc-ty;GSes~Lo0^(>#s*pIw#7!7$Fekh#fVUY8dfjY zkkd(&HtCRQ)-$fsGC!Dt)S^D@7>jN}yuo24+gKd@BNOvFL(*=NkpKR+%&2A`cJK@{ z6AZZ5Ck@(5M=qep;{0&uX%Vf~fo=^|C9>48B$#!?9lj|~9TO{L5g`rw@rlmT{7|}# zp4WkgAa{9WUbjURSiq@~Dy~XE9OOPbz4-zkS&Z(2!<0{vJ6xp(EO6K~2Ojv`qJZ*r z%1svNhZ=U5YvciOiflrC+*zmz8D2>ZCQdcN?PAe1^{sOqW#0di7?8z>EIm_caifBj6i}3ym_` zVTKGlet%VlR5=Nd3j|A^FsPj*_r`V}N1>;GujVJC_c}6#r*izrFpX%Mr}o|3(vk_kpiyR(xfY zgNbPm6-xCCEgwysL5Yx*6Z@$iKDO9;(bN6LLT*?>CZfbv4Z#Z}AThW!6AgP6Kh;RE zq{=>i+cKPaa?m!-gY}Y-9(P{rLXI{}^Ss z?IY*{G~qV_Lrzzk3Fccyaa@)ac0mtUcA4v)Eo=eza)}YR?anD$+<{b>?0DSA?FupC zY<%sf$6SR!3e_GiO6Gc^@T%byw4C|Za#p0s@Jk;a*?8UulG;8td{}m97`t}PT-_(F zEIAL z2Cc`z(p0KT zLom8i!4)-dHM`opqO3!X|Ds|X z3^8I9P0Np>jwQUvgW1RIDzeR7Z-qGCFmr4+;?iaGdidg*6L$doLU1!h1|FD-FKBLa zd(iiLZ=(IZo+@C^tHQgqQ1To^={yrrEw>Z0Ch0Pa7-`oc13qVNh-;Zsy)WJPViPw4 zptW+@zAr=y4VoXAJJ9fJAxcVO>*N~`L60$3@x>8#3NCNXeYEV{lF-yi5nIA&InSKO zE*V^c;%|_{3h?}fJ2JS{sUxY^drRJC1-$y@;7Cl*ZrQ;GJP-kSfh6kKKr7`Zaj94D zIk|G7ti%ZL+ygEiVWA3R0c@BOEW1E7=68n`4*}3p>HcH#7?#QvcZ5{18NCQQ`rwV7 zO-ujbB}uhCAtF-T&MJ0fS-s~K1Zz3s8lYl_Tn;8T*4wnaY1DND330naj6I>rU=cj2 zEMM8eu^!631^Oe1d}3js$N~l}Y5+O5`7Q{ore%}>OZO=C68-{tq@$lQ?w?|KNnv4b zLXH19s{`I2uGf39cc0r|9iB&KQJ8BkPm*42NDM)V!xaKAGnxw0=2j5Z{8^_C8;u2t;jv%Qv z6#k|U%Qy)nA}=bjLb3d@zy|Dxv+{Yo=lt7D+u(6|+|u3b`|js=da*X07!rj?NFj30h*j~t#6fX1G7I;*!C?*9&?8!_Bcic~4}tRka8MaP z*lAZ+Xxld?W?lma!lrCpqnPyQ}fy-n5NLYD;bfa%EgH}$~jHhez@#~{P%+|&sIFeVLKK@Ej0jz5z-1vO+7=q9J(X__55WMN zCmTWK$G`M>c&G|atR6R>TVHZ9F6;!FLqrOt$Dfn-&KXhhxh*GXAI^6Z?)Y5b`>ozj z-rgM6eZO?4fuwvG{C@W`OJ__RxB22k9OTrrFCYBFJ$r}_xV;*Z77W3o1=&+Lx z3|YeccUE)RJAxQgB=RxQR$TU6_#drtTk+o1ED7w%F`bE7ZKE_X6DTrYXpv=DIO7!G zpj3kcYs$h_GNoVi9|D*%)P2bZT6+D|Dk*H5X?gLp&(0P{@flo7utUY7LHrR%oek#w_Lf>xtlKyNwN z<;DK1644UNX;Ke$Wd&NPVdiCxEcn6>59gwE3n{?Qm6(Z>2b&8U2V3*Q#>dBd?fP$6f#Wv6`Rb|F zG;`^k135|zi$?8vV!LJq0Nt)EuReZwnbdOQC9G)hE*Ye>S)Dt&xzLEuf4;+O{z6~w zSSqL^9v@61ZIYZQRXuxym*gvfHmuj)7Q>lyNBXQkr$KNAg;K&Z{3K|elO*o9y2Lc6 zS^u?li+(qWyg;kIr*(LHHXKFh^&7xm)#!B$e7t{sM`GIO7<{>S3k-S_fU$*)RaD^S z6*T6|Rl(#LvXQAyXJCDQuKfr_(A6!cBQF}Z1knw&1-%5`YiG4%Y*TkVk6 z+Vdi5XMdq&B}$bDwwBSPshIh;tP!fFv$)1GN)C73F!Dn#E+Tn=G@?kSoDE}Apw-(R z*ER@N3k(0(vo|Tum^5f344ahYEbG3HbBb!-P0A{3AJ4D-egaA~%C5I745cqGO432+ zU>j1n@OzJ(JM5R8D(=P&iK;IH?>#!&=H@SR9EQ8ogU)m+o{x3&M|mQqwDs3dHtv6~ zE|4&OljpWu;C)2Y*OYhG$6a}7-v7*p6ZC%FzF}(+lIIWpA}tK2VAUI$^jJ`m{^Huy zyeA$JK@l|=Oh#8X#nKwOo&>kwAGe$ghZD9|I@CHU&4JS+{=13q;Lwe)XsO2Mu4IOy z6T98%+iart6I#@mNwJB?hhPZf(F0e!h_kcvgs1ZL<@TpDvDu3|t5W^C_{mblP{>60 zNVZUg9{CsMl9`g(YDMxpA2`@gc{oah4X4ak*5ew2sEO6XMDYji4u(|Y*m%QK!=+aA zBCx-$Zeu!^vRx)D*pN|B&_wFGy5tkV(^Zfk=30KIXYQFAmEt{{mYkU^L~-R6k$}|g z%+3z?J@lovMCZB#el2bB&ynf0&D{4&j{4(;Dk!nZgBmz*1qL^X|JEOkdznzbpbruW zBqA&0bRt}6N`WFUUBzXxTJSZ(F%9rEn!Vf3#r_ZbRc{@d4Ga^%;g(~jF&da1 z%ps$k3+)x*``Bm{wRQUR^}Gf6|C-7uq9qg|ymC}?KDgI+_<6?&%RsWR$!%c;{g@QZGR z7mF3ao%FkH8cJzmnh*BDBkyCu!5w*LA}IIWPpM-kp$YkaaH`j&+e*79UR`>|Mq)Y5 znRMkk-t9AZceRQ`tNcF;ASgYzv+&g~vyBhdRar?Uz9f=k_S4ZJ>~I}cl2{!1Xq2yT zYT7#p{aLp9vEFU2xLe_ys$W@gXai*3>e6dXh@_Jqk9_uLBhk)pv-vfbVdwB4h? zW6wc{$~ROl$X?w_QPD7?~SLs1~zH z6hpUVR|b(n5b8oWVa}epw!7ca5(IrhaVI8=Z(0*rT!fLMJdr!N*+LKoV@ZSN6?A_B z!fL1IXJlEshnL^jBYsRD5J9t~0%3WQ&B6ELWk7kXQ|KA36Xkw|AWcqagDTU1gg_T< zDEX9_sP1O&B$sDz6}N$`lvXyYc|gXPHU=}XV50qP!^e(h5+JRuA9$lJ(2Moj-euH^ zq}CYdBgK^yG&AnD8{ zrV)jlwm}?bm2tYpl!FOHtT5ILC)weT^+e=38=TqMO3CJJJ>b4kw(`5m?=#078V{uC zBA(J`j#!cL;D;u@fG)VaOZ+YTeZRXj2&*TKG;}pfm#!VKL?0mjKKMPH zRq|2YeSvlCyJcQQK_&th!Q4VKFi>?nzJ5oxs=gPt z&_*o{)R3LAk)8t=q_k*VAcYrr3qei6TtSlx|M=2c$)$7Q^7hLKNypSyUGQMGhg)T@ zeg8fPlF<$s6&_hJ_Q&7YxQh$bRA|jmNV0O=Y!F+nd;%@yc+|HJT8l>L;+qhEnWhgbQl=*I|i7+G`5vNLLXIBUj#UibKWLGU@_rO>M&y*)`ZY z`^ss^^VeDo5DQh*d(K_OJ!BcawuEBk)MV1CMVMj&X?VHtk$cVN(kQ59*_9oSgQxy?W=dIJ!RphrVV6uXgGR6p2r40-8qeu& zP8_|sZU}7{PDP@~8Wb4k2p!zFGRd^wr>| z0*Tt=l`OP>3c}P+Vsp#B2-R)jtMF7|(UQu|N%euj^V%69qF<&y@iCZi2saUJCQ04JEEL5J+=IHj@_ zUv^)-_tB%x(6EH(pv~ig=;30MN?x_4wN+bJ*Y@|kf9`(j>MU(!;H=dEu_2aml%lEK+3$OoqCuM~5DR8r*9=kmm3OlX^q!wM2Ul>^yjV zonJVG0L?jVAIBgr&ZUT(uK~x)0m?oWf%)!y#Xi=R?d51KM|pat^dgIOH3)ZX{`#c+ zh`OR*>-H$%Nq=^T`}ISvu7q~{6;V#xjQucIh9x7@b$T1(SZr;{)3B(Vr|8vy%vGm; zPOcsjr6bet3#^;_Y{;El71!0PoN;j*-^lONNVk$X{H?%(AKDu9^i6>ipDl)GdlsJp zYt>3d^=U`dG@(!VFVB;SOmI=IJKilHDK1$SiU?_zX@a@hRE~;BEhIN7Su_V-LXK9S zN_}1_c+>xg$DrLS=7?*Fi=8_A1H1&s#~SwD-(LQ7dc;*~ z*5(|i+`L#-a)342 zreeLG9tZ)};LO>7_q-HR&6CYTR1&o)nsjIgGEZP>LxVUt7nfLAx3~6iDX_ZS1D&C# z)LdWu_Dn}c3-{F#Q&gJP?1xl|9VJ;IY*|wF5BGvuujO|({ZBX;s}P(s^DQ5aMp+az zKmtF9U6olG=_s`o+*l=6qP1v}Gti3Rs@*e%d*b2)6>1d?un}QwU43kC!%kq!t=wLu zQUar;)~pZV_SQANllP(_e0RkQ#4P(S$PM4##aUm8N4A)b@&?Z->(M}gem1x9cr5j| z%EPi{^H?Ey{B5!LasZ2u1wT`+S3E2pD*~N> z%WV|V?achBapL-aD10x#vnzbkmd zN6K8YW-to729sJtED*9iOBOz+K?gMkq;&gg>Ucw{#`?kiEZIztz#?4T(324(_MX=$ z858d9=ZR8`|9GWEDvFqNUg0smbI9)kevzMab#?#z^qS{mKOsN85H1%@Ti+|l*^X7dG+bmU6j;-{~hfwDS{VfwTqpKf zSj*)%%Rz| zNQYKQ_lEI%iLekBMb~Vt18O&Mb#=tWXT;B5}MR_%IeVb;zL%fmV*8x zv!hU0t+OelXUHplj^T1)x4iZR+xYG2#;nA0(wJTb#^MvJ%msC*%^irH0>IUDh_WcX zsz25sGD3}N2Xac@3I?mhf&;a_qm$HA>yp}qy1|?vrYvA~kStLQX*ZBra_0KvDnAAL z$p`S=IP1cBr$$`x{%3%c+SiN+|6wb#FlsjTzKtdWA03p?qNZ4$ybUC^JKQBphPDl8 zi4^eU!IvW_+nmU*HK7IAo~1R&6!@+s?sLag5yXGBev>3tiyzl5(znMc0N2TC%!w-> z194rjw3whuFr$Y5(g!CFKt`%H+D=B9cSY9*zz=se$cVyX(#d$=QT5U7R{wPI-qc`J zfIXbU`>y0y|H4vBF@UwGGp8Y=Zk-j_hDB;V8WNKunchbUez#~u#{P@vedS=D41uKF zHvba&9|eVoRB|N09V6B%Zc!|n`)GKoRTc+O72ot`3zS5GXrRv6NtqD6v{^EuSvsI- z_@lovWY1);Ye#t%8M!xqyRYiWy2Wa_t@(h0wH|H5nL>ycC;zctr1!cyO#=ru4 z5#nF)_Pzr3h=Pd--Kj}A@P;o&f}?s5!I*mOUO}xN<2a9LAJ2-*fBuLJq9t7ge||W> z@d$Wm9Y`oxkO?n<)mQ)1>5_ZV{mvTXkQRm0s)fl@ui~o95ZeDq8q+wNJk}KbppLX_ zRY4WiD7$oeC?RiM=7*xoy`&3S%AEeD#8`N$3*u7PM5*ez?<)(}9_P{hWkkk>H_t<4 zuhFk5=*142+CC1P^4ID)__-_}ALlW$yE32trrD&1LwH|pQ{A}WFhy8Pc zsj=m9s#ycIb#sTSxBlunW46OM9l;Am8t{DN>9-8uH+wNzJK2%0qM z8)w1(V|0D`nIR=!S!+5ORp2tJH(21AZloyKve_;+M}0fwre9Gi&03=<7---s!7vce zCM$Ct1&%)dv{bdJ4ZEa7VXlht0~;1%^__QcR_JHDkee<~M|ozF;%irW)maijVdmbY zwJPMI%K~_^FD>6?EXBWkJN_%mrfey%`e)(fVP#`gBKsJ_by3>;Pk8{CllSe)29?bB z*M8Kro@%MuXEj-`ac^DO;@E%jC%`&DZKW29Z_ z?=7ik+wn2)y!AQ>I*5ny?!h_I+nwd2Dz6t<#qAc7qFwQ2kQ`{P2Qe2$cKtkwZb8~7 zabP;xjn1y|uufG}ih9hZ>p=QiX4r-aS*;2s(-uM8xwGfKpKBftH|Iicr@!-ai@~>E zze9-h7kP&51o`fA7CYb~B?{3tKMF5|uI_tcQ%|B5WBn%q%rLJ&FddFGJxz6^`+mCT zDSg%DC0on)h%CFcTmHV%a5qx1R6m@%aYqubjooBq2`&| z8u&-}Q~90xH*2WwL*vVuBNZ>;(&Go!Ai@lrBq;AwxLt)ZF?!?*C_1j@^2=t|-}6Dk z9MG#5<0(>-KqaWqSDBiCGD=N>1|6ofbmu~#dNU-7_J4wXcVj$gQ+Nf`_j8j|-dHSR zL0{-??f0&Gl>t6{Dvl*b;vk;7v~EfWRD^2x^=snL_3is3lHd12z84wvt%aqGyy}|2 zUcP-bka>+nQk91Z9|Q(V?0u?Rk1HCMF8f|XW-P;6{Tu!IFmH^wq6wO}OG{Eo!3J5L zm^5aDMUY2O_>$$#(@?P63x8i{ISL(*VYIh1y>%LLm8ltt@AT9xxiP(P^|!T9>=)Bzo2d2Lv%%8eP(3?sO>MoQh6o3-;L3;CzE6 zAs4;>WV^gB7`|aqQBjq)%%9wO0t;!LcMF;kY6DkSSEX4gwXNoVv))#Mrm-Lr#|b+S0?ALmA+TW#F(eFjWHyi%~$ZWP(aj4+TyIa zbV8b7cm@-0-0(z+DfSId$L}24f@DQ0cMPIcMQ)m}jvm)6#IJjtVTECT`20r}PMBPt zP-?G-b!&l<>5ts57dHQ^jnB(-j%TYJlmvcca8dlbK@R~jXVq8dwL(UMnO9w{J^daV zuh`Wj4`(mF-W__%DW~Tbv-X2>mTXNIP-Va_ZEo9|yg=!n;!ei+w| zpC_2R*oPJN?@nVbT~2^St9~8^!5wBar~1~DFv)E6-257sz92Nswp?#Y`Y{>f#>v&{ zx%)TmssG}GMPf*Ab%WG7wEwdQ(636u;YnG9-S#6V^%ZD!tw_Lru!;rC=>B{?uKe@U zEvZ>JciS<$k+KmijfVw2WdmPX9*q*3b-Qa(x99b}##L%!$sDvJhvMFxI+B*%MhWZf zdYXkW)(abqK!(3qP#H*b#)GCJy*-FTA{JM1Q%YBlq2sgFp z8TJJp3qLS|;u;NRy-?`xfqr*MO5C7?jeAw)5y8HCvvjSThCfbBNwN2jjNDmPKU`-~ zs^7U>@nf=P>88(V8HheIayN;GS81=IfJEM8$DN?ce3|$$cF-*wUGPg1tll<-Aso(I z`iKl$7M*a(r47eo`#wJ(MOrhp8}pnJJ_Bu{??DWX^csWzRj+<5l`3`zSuEJPK&r^p zrFwWjZ&0Um+^9}?@rXPGEU(IYRw^3-1XMQ`Wz71P7C;n^>)$ayy7T^z4&G7vr*MWD47ZtTWu61U%qeWx!3LH>J>Pomvj1r~(^tJkT0n1`?6SHxm6et4t*vhWdac?Oo^vE9V)!d{#Y<8dzoLO`+WDHlu!^>d<+rOl%@^vw+B}~G zD)^kZPY{mi^5|Lh3<6!moF?*88oJwiIh?R;3Dvcg&G5Von04uaJ~D{)z~AZDG;+W| z8Gni1d>gg+DzXRBh6NhV&-#0QCw$W;3qjqj=-t})+K;3t0?2}`=WKfT_pLRi`ewK9 z)!W}Pmuk_5bFkC?@(6wWW#SRcQPP&x)_C2~?6GL$G_p0#Ht6ghat!B4?dtN|czK$B z3iH_5-tPUB60s~q(=Jr`cwVyqw~#!VQ|zj=ZF-9C;JAWp8pp~Mm^gy11D#S=e5Z`+ zzB|H@rlh$ln!scuGyQY~!m)R{ttMk*eb;DH)2+8XnPuG?4r;v#FJ98*0TNrNPSKc7 zJbbZ9hb?5yM%$pHOVSb`9`CLj$oC0;3r%c!h0=&7DzQ&PZPmz07;ZV&RMk4VzBFgb zAmNEU&Wc0$Rr?`jGquu~v^MYb^$w3lymfvUzU~a$!4EP=CGd6yF0?FH9|Fg-L}sBY zq)!Y){S|6J5~>Y{3axBLk_t+6I}Jfyuse6s8b7-+wL|&`Lbx0{9n9M&We{{p(bj3( z<2bhw>KvDT^AwdTzxSN)srY9>3iEdQSj1W=dB26iE4OMTDzs(EZP)E=4_kH;=EcM& zU20{Hj=Obkb00rj@xqPiRP=z}ml}@v!C%sl*zH!r5zI?aj3dn(y624({8lH!p53w?(h{zoIK{`rZ(gAgKiu zBGkg`rY4I^7t=*A#)uxTa28m1(*}Ng%26hVk~#_$LPJlU%5w`Tmor*xCy6vm$ltcf zXgPFW6;rknHzB;Z2pD*Ok8Ah&I$(4HLHzz)x|f78Vgcgk@2zIq@)~|N8u@tKe52d& zKI1@+i%Xvt5T%eu2ih4eoSbb=Hs>$r*jNnch;oS}6iSp3liLuaN5yq-l#Nj&R1&>h;-* zV|x8QBblIrwdQjRx0jx!$@&21nh|Z6_Gn0t~GrCW^ciX(T%&VIQRvE5V81|7n(?twA6f znF&8>)WR12o7|)O5Oz{UaX^Vw*nfW=B(ZAbP^+@?A{+RIZIQGLdolg)6*h+h{@?$& z&!i|ZrDmSNEK!_fIZ{AsUqPd{j*rAuvNK28F!vCWt}6C z`>`RR95@?T;V{lS+Y*V2d^7nnTVRfl5K%;I1*wW4N_miJEvb3?%XIfH|7kKt#F7_Ze1-MREiPQRz}AIr`fF>% zN#aGAoKN1i+HK}p#=-sr?%%)9?*1O*@dQ(rB#~s$>(c9WXr~F?PKPu}=yuzzbvuB? zI7_?JCX!yT%7}IearzD- zNpQsIB4;+8aC~^k$!JVb7TmaXlR>*flD3GG7I7RCsTku75B7JL3FE-vsTJcM6_hf@ zptTRUtE%$B-Adq8_w{O^pp~oDT8Fj1rYw?%>J+u}>DV(93`ya6sdez;gr~$ccjU~%rlC-qAWDJtT4v=R>pY6<@$gBqp2$YdKoZzQHMGy5vvGl zpAgT4GC{q$QF(qsk%r&Ko}C$0iiQdWb)KQVvm7<)t1iixLV7q)c(n_MuO+IBLS+b^ zYNTkXT2@28VHp>~9O3A+Qm@=2>MEY46aT5_=`&)MnlI@CgH>u;v%o2VAQ9li&mSnS zsLip83e}UHS7l2hMNx%gY(yIzmDco!8|+-T%ujy#D@M~XB2rie*LdQ55}N)d&d$ zvGmVNB_+ZFDkT4Ek)PV%k#+M`xeSb&9|Dyrv?}pDxyG-El)^^JCpv`+teU0YAy;aN z{dOI3BXs_s2X)GonH9mwpb@p#O`y@ya%eEZcGxv;s#a4?|T zZIdP`uBs@Dj5Lmj(lj9LZvEcH~4sX5v zU2fdEMVh9c?oT*_H6^;tI2lQ%hyRJZ{W1>@MtpqdE_?gFhVI(U>)gJ7kHsQm5ri*J zj!&4*roK6GRbZ;htIKJNsVa=MO|Vl3LEsb6o+5Xe9_Q~n)2u_g?NP~^%4uv6Z1D9; zuJWZWPurfIV5oM<11#&2g=N;F_O7K=fl4QuwdyQKt!9A;#H>}cM!4q2wJy}I1ZYDF zi;5JzUf-XzhKjekcfVcWdS=~^d*p?msa8U;Pj}vBIL2lSq-f}Il3G$bghHW-niSI4 z=LDJY=G&d5(iKq@@!GduW#{Tu9^Add!NDP=*0d7ED>tw5;?5<8-JTCj0OK5`GfeV~ zN*jbyG-;(~`^yQn7FP&!EI8pOxG1J9if}WThEu9k#CSUMa-U@tRuUno3?Zu!NG0gD zQ~vpX@jWhIzRSDseZt;o%p}*$c1Ng4FwBa__^;=7Zs&Gx=XP$-vI!xGV}(%`sbrIn z^yNNvzn7pCx6*s25sq4=!$F|GdCEG%`xR0+WEA0|xG7<%y|cQuw`P4ff&y@;1NMpM zlG(W6@OF;PVu~@m`rH*B9BYIUs5BvpQ<7LA5ENxe;f&u8r9zU}B80{ouZrebei9Xu zw&3Ym#@OH|Dzw#f+8z46E=fQuiaaMT3aX+2EK#ILq(mD-9LFdXA%vtqi0Kd30LP6R zH^}mWe33DkOgKI{q|jAB!$c$4A&U`$8L0#+iakQ)T#!xl5$P)Ai?gA~YnjQY zX=_cP7hZ6|I)9TptD75L1bSVk+a+lwG_ZzSrM9h7*B-Gi>BQBLzQwDC)V+b~I;y(C zYHfaUqM->cQ6NrbdZeo-D-q~$0$~M_t3?fb5NWJen=!URNXh1~!`AvM%?;8{5-xRn ztVapjS&RjX!8$0dC9kRwY=RRj#dFPGi6ubSpl<$rDdnkiNgCrxi;|)&(N%@E6|Qnk zA)cQE{5I-FvCUbLf^IwE^_QRH=JhM=?(K2!;W4A>j9HcwC+VpP|J=^)+`gC@>(KTz zqWxu>5J8=HHPd`<=XP#qnh=6W#YC|~YX4kr{1qWW!*)-3leK69poBswvEnQFQiM96 zDb=zuhZF)L-`vyF?3Z~@gaW(}gOI{g-K9ebh@%$5rI@nh@BiZ`-2bSe-O3q!&ymdy zde0+2k@7*AloFgJD{`FHs3;qGj3;TgV)_k*m_Aplx1Urd=yr;Mj_ zCbK!S`GPFVIa#!LcAs-d`8`e9>EWr{8S_h(z zmHZkZz#+hn&bda;7zZdH^*UUTX%0dK)_{~)8(`cdqSxyMw8*Vo24_8m#UnCpk1q50 z1^ijZjg%PcR-~nuAJ#FSs3$aPDNKnHE=+hKfE1zTst$aF=hHUVSfFKEXB(MDvBLSa zMtdppl^{k6K@=&vY2phZouSiph$trMB;W)mqXh@KM{?@Pr`|@hsV4XWPk;=aiKRkG z8MO5M!D?-=M*E4y)#uNh8rfBDawEVHu8T-1wvw2wL6?_rU1yQ!%=4VR?oEnzzE5`u*M9z0-{#1WQ3$TLx4J4;lA+YYmLI+?TJ`96^3?CD5u#ZnEL* zo`xmsIZEKw;OYsk9wX_T*O_o0{Ru-s9TiEI0hSh)qN?go{Rr1EsSsFeNMgses{_`r zb`c##+)`j2i*cX+os>^L-s5rm5*Nfe!ar z$Qf?BWz#RHYrLfJ@VtlDBSfS~TW#|8n$Ogn+cRaAas2Xr!R1kf}tMNy0dv^LCVb6V|| zFDZ};t759WAW?!uB?uy)RCkX&Yfilop&@PT{W1xmUx^O{q(DT{mlGI=#rgdXzR%Xh z9j-q20+%jd@uFRi)d>2;vaWI#iy71Lgwc4!XnewWHf6CWD9VzutkBx{2CT+lwEw9} z$1HP193hem*vg9_93LICbL9$3Dc@(x(THk^CPn@D6IM!zG3FHN^C%MJ#k*`+UXjEx zQ5++sq_X9TKkphJQ$-4aK?>{raq;wOC7+=uz6;K`1-m+6-Vrx8Tt>np55kHD8EEcS zTQ`AJSiA(JQmP3sYSc*vWJL%;+G^46d>;8tMi4*$ml$+13vGa0| zsN04}fUsZ%Nk653p~LlC8{GZqm=8ZWU_7rVwGV1etMDyHtKlT$VQw2TCZ_SSe$%bF zO1EQ$O6apnQpm=+vBFW;OFcyd_S~M5S?lkufA}M(1!;JswUk+IB zJwwyu@7Nr0ICcDb*CRq-g;@u)0^ZwoL=tXoeYupmgM$P9?9cv;zxa#4;KdhT{PH&Z z6iluUF{^O+XP9WUkQ*Dn&BN&2o-q?jp_D^O<$EML?=Pr8KWpli!$Vcpk3<_14GlAF z=_fUrei`a^0)MsMnsgSOd&I(q=B%}U;%df*j8HOVJX8GgqYKMraKzR1 z7E+e9lp_`zi6rfI=?&H?vpJLTxbaN{f>?Rf$~UN2XbY9Lp6MgK|B}QJkq}sCXr+Q~ zw*$^n6eW3<)cGAcI1%8?_-%~ z2)v+_HkQh2v~gUzdYS9bzr@zX9a^3C<3W&fI8#yN8RN-_!=ob(j*b~mCS+MgUglm_ z+~7r`j7ICS5jU7kXWYAUmyL~0T(m|u*{9WCLu-LGhSA9}SFT(oiXy7AY}DVJTS{j) zhkPpWzMMzuKxj1}S}yPFkfJCiNs^}K$$!_Q@ucr1DhU3#^P*@^3ygSXp7!;5aMn}W z8aLQks;cw_R&vStvaH;^fItTMZ40iBU;}loQ7@AXOzf}-37t+G6?slxL%$2r({HXX zS&70PeKzVO0tXB+6HY0D&=5m~;L0acRW z0$0K}MAOcpoh7pd9nc~_hGAU+7Y2$qpWk5n))3VOM1|M1uVE>NYQtc=#oFL9&)rz( z-t7@TdT)^rUu9cldKJt$kP7XRX3{0r9B*1oiDJ}nddKI+?VVm|l~isI83j$`CYFCs4Q zd^I}*J()U8_x@m(GZ^ZH8SC>YwA8^aCU2zIfM${ zmkFqcZ|dn0CGYSGiI>9`5z^u1yscOCbrzg7NC#<>qT&wyo+DKi(x$Z1i%gYdu15?u zQx=5*?Z{^{jJ3o9Oj(dmPS9nJ)H#u}5G%6WpshwqMWHQ4QD7|Oc?Qx`v*I|S-EJcy zNtKltV~8t*6!o!N%CZC*P#YU4a>^q`#=3y2)-~$Vw`P$tG!He+xS5*TRnx`r!I%$N zG)PIVHJg{N^6Fb}v$?%}rc$JHhN>u-Pe&Xc?6Z4t$ic}8^F>Cf1NF_+3T?jD$QXmJ z43#cJ&mY5NGU1(fe#mRDzs6v#Lzx+5yugYU0w@Zv4wu9+c@yM_h5@vcyY^;-Z?-B^ zzq*W4>M?{!Ddl??g@(0W3=QgpbbWt&%40-5cPu$WPsg5_V5qKhsUcg>F|^HRE?i{c ztkr9s-Uj|gb-oZLoUkSJ%_9+Y@t~yLYLT{DEAfjswaq6X83-w!bdLX2bB;#G-3uQ$ zoDBhuw4O&RoTrr4d+O@!3`=?#f+z$84*yrOd~g`NQb^%^AY`1QvX)s@V5|WQ-9)g~ ziCF8k*x2fD(e*2Wc7wugK6O>7iZlHDtP|jeAdi4$KSvI~>q5Mrt7 z`IJpk5sNvJ&u(UIiK$!%`y1SnvMf0{IU&#U&)im$Bn*c`+U@q|-sf+o31kuzwFL2E z;pL0*>=55yuOY*Q0LS|}Qi>2P)hX2FZz+5|uZp5ZY3Yq8q+x}Oku7;UI@g{eGPV6^tN*4pyNfBby}5>r)_ zu1$74B5C)T&*n_0Gj?`%7_6^1?3t$4J1~=0CA6J$#7PVlO;goXU#bp%>i_+@mn#gT zx?bOeSg8Ikzn%)pheFUK!=Dy~=a~tHYHC*v2q~p7R$#66lY1Cw0>a}1P2Wt_3GejV zFp$D6BTNs0x)3PUp0U57TkXzo-Os^UcRCmnrycJ{Bi%>Cf~DNF&n5`FLWy%crXbfS z<>BKJAC8EIPhSTSGVnT;5XjJo)j1j=34_HruU=(dQI_N7>2rSG zTZLr9Xf`*U_4%4Q^H4A6e9>Y(v3--xImhAQA)QW#IF8RQ#(c&stDerpXkA@k{N&l{ znmYQGSe>o?nq0EhLGjuC?o<8#S^4DW>q#unbAI^4AM)m#Z$1;~5JEr{eT`-@M_Zhb z$oUg4Es(Y%a~nK*9<8GSdefNa^d1r1xKvB*u;` z*<{YnOOpO(#K7e!ri^zN+&O;8NADc-&%QI~zxw0v(`%D{{)J zLTigN7GpHy$&@5X5D1Jm9ud+8U1_SSL~DbtDvUOOZ-`oyC3&7x<^_jGBaTl_XtmpD zqlu;BlTU7QT?n!)^M04`LSx2QCgUmd*^De(kmngnDZcZa@1T_AqmMpDDc?+013#O2`QR-?b1NiL<`e$~h!3 zn@@RoJ3~|%gUcI4gBC;*#IlwrtPIXV1=VrR#~KmP^e@t9t(%iC|i z&2TvUUGLU!WnTwkqt=$mNk)d&RE*pS?GGvgF9l{C@5p%iVIVtgHq1 z({X(~*$_}W!?|EUMMy{H*3VKzL#CJ?M4yd$jv?`&MhRbInJE8H3dq7wKk4h$974pr z%*~gB@zOF~VXfqIm%hm8yM{a8-Dhuam%F=r3`Y}OC3xY&i~PjrzsTo4`&m|&dbHA% zd~F@6d~;W03=%~JY06)C=jWo{JVoU3~~B`UFQ7My6=6H<$2A5 ziO?I!SkL@uqkT`qG-GLfgUidSq({yT@?}=n){%({buf)w!#Q+WFdYxs-r3>q z_Lc`g!x7Wzl(MQqt+YWKZ$@E_VLF}g?SJ?#XV0GH^y$-Rt$kfqr9CSYn3`f%Fqupk zjYjMr>@%KB>Sm~wu1M1iZG4kl3;gKnJKWjYrrU0jBnjPKm$g%;s4C6Y-8*b=Z8MwA zm=#lm5L~!$o-0>AMXTjMpQh>Jgny{bPgJsyU&Tr3D5G;>U&MVQgrw3MYa48kSY)0a zWjsT7iFu+9G*}#h<}lD8p*BVZ8Gyxr6*%E(*?PCeC$}|T`6|30x)%i ze(M9axA!@B_AHk#y-J!SM`pKOO+Giq7&W&7te7|Z@;w3~Kn81l^EVqMlL5@S#?oD5 zTVv0JPP@fYulroP$t6ibzdzv3H-AXG-RANuuRQZ$=t+ljj=MJpOh#q6X@7DdrC>5H zx$xpD@p?`h(W6+qJKEs!$2&xj9l3f=*3}I2 zTsczrFciL-s!~zhCP}bJEGaHnBMXvLhJHf<_{22H0>UDsBT*79m4DviaKTbqSB9!8 zc=g2>ICJV0pcszFUJ5A%St9B5dTgFK%j(K1wyMyTp=CW&Q5L0VJ%psx(5AY7z9l5B z)r(BVe@SPx=M_T&O07{wAQKO;e9jO68_?>saK@q}p)SWFk)8pnDw0lzPJ4~C)%Hdb zfn^dxu(WoHcKfIqg0q%lI%a!oi(9vDvAw&){%FK>R#25CT5EIwK+c#Tb<X=HNv*D5eFb zRkD8Wj8_h2Deqpr%GRyh%qCOHvI61riLxwt`$z9^{`>`Bhb882axMU!SR>Sw#sLce z$QwC_zX?Biuau;i1qWj%D9e(`c!DvHM}qJSfuUw+TL4c4p4Jt< z@v4oQs+jcpw!ihsV4WjL6I!iSI5;ez89zG`z6v1)j~$#{gh}=1qu+>tdDGG6ja6CtgiNW^Yz=@ zymOOJy|~6;GGMnq=B2ZnoO)r6bgd1UU$L7R%Dpk~y}QL#fN0Dl%WN|B-?4b6 zWvPSFhS{{BoXx1T@$ATKN>x=@UD8=SgP;U^i@9#cTW9;94k!`T4VHTyZ*CxbO_U3{ znQyn@`w>Z%aQ3B_s3v2I@x*6$BJ?9FD{t$KVCl>`@=ho8<2f3=-r~L4T1!<-xpm_j zZ@+Vu+uJ)#f&|VPOBG~pv6qt8m1l!=RU0H|t+B?Cr5V~7hQlGF(TJVxZHB`kMO6`- zpDGbDQz2-zT68)cfNFYaN+;faZ8$8Cud+(F+H*hvZKvcy?mFWBGTBT2oZ@Z*SQ1`LUa zLX<*S15SHwsxR-WXCy?l^TS&>Iw!yxg!B!^oKl|Fw8qZ>1ZkYH8W5yu!qW2EqW<3< zmSefa-=mIE#CMKL>YR}HTg3uRK{NFijn6M`cw;Q_I}JeQ*$z)%d(an{lIC|D3s#u8 zdDFG#C2X6hJ>1YDa4-=jIMK?riZI;t8q%03ZNKL_t)USI+b5*s*^w<-+ce zGiO$5FSS5hCjA-j?~eJ}+qd|O|L^PcdZ+mEPrt&M%?)JQLO6r-IzNua!_VkNiC+y( zMRYBh&rU2Z*Z)10DW}%gxO8EYvui61M_pz|K7U}P^AdqT zhkx8UyCchYZay0qx>kSEbpWwo6sTQr0LrQUM8|Plj0Pp^!T2r~x7NoZbYMS;4<82y z2mHyO{0YDJd%wr|^XH%Ra8BYRK3)ikND>m2BBib+@(>*3l%J7Llq3n0%ZU)A%8@ur z;=HRGs9+4`KnAc8WMwrYZ#MD`NP!SdP9WSbi&ToUEX>3D%bDa zWi%T3UO-0koo|1eB*}RB(k05W2uzR-eVV*Mg0C6Ultsy4IG{fmFbYgsyywUKC$fCe z`ocloAIUm5Z=VwOl`)q7aG$;1JzAMJ8q+u=l3uTeR1#}UC_k_yNkW!o6tj}iaLC5S zDT=aOWEmUzMKd358ZEfG=$ra`u{mvN3}rE4e{Y}Jtl(^R#>*ogLp(cR2ob1QiBtZ9 z417yC*ZmHy(Wdj{kdP3a#vrgWD$Ei@L?Qfgg@A6iN1o?idRK?L$LqN)ExvBnsnlZ^ zA^;|VZ5SL7hCP?UIasiFUab9@kM%I%s=pnI9fJgHQ6Gktp+aYo+QPbd9nz5yo?4R5 zgRFjk#Hmwj{Ij3`N4)jc`+WP&Tin|2^XmBxwuWO?xA*B}3Bti(YItX>&-Z@tL(Xrm z@VU=_k>#ajoD(5ovw_k2FtNzI`F%qGcQzE<#X2LufwnFH^&gf}((80McY1>t&uwyQ zsY5GE$cu#HIZhmBvl#~m2h3(Ogb;MQUDj6D>Y~t(64qJ{_7511M_6lX7pFM;^l`$4 z<&Vc>`u#ptRgokK%gf9D=KKk;cu{kG(D(aIO8;P3US38i^@s#LA1|UjPisxT->+*c zvNU6L?a>^IAIEUcF&GRUn=IobPU4e`kpCp!(l}Ak2*6uoC!x7{q7srsk|{-^6bg%U z2H^~%*>t|1_>IxXHG=7p|J~xOqpWm2QHdbfa4RqtCmcdaUz@Bg#ze_VRNO$CrIeEb ztt($dA1$vXbUHo6&{2)YY`t@h+0Hi7Q3C;|<~=8kYVpCS$KSkJ@!$N`?~o@cLP(6Y zRF%P&6$JUbwuam9zlSxNs;Uq|(rUL5QcxMo#>Q!q^Z`J~d7JCmbjsfD4%cs7=f>@u z?DzXji;{9$P|QlIsv=bxqv43rV2BB_wxTGR7Bfbp5#!;A!JyAUzt3bcK_$sTI%o?`-hx-pLj4u@9JL@n;*OUE1%0@AYV>}tNx4XxzC}?*&bh_Qg_S}DF zz)&p$6EL6Rr8~(3i^p6;=GGX;qM?JBYc(4KzIXf5`G&;Woh(V& z+*oC4`6sw`V}tjv-{9+S+~nH&KIb;q5mGTWn*PCvy`4U5tEc$FPke?>ZyDz-)@ov( zpnFYQyJOyug>~_AsT*ttmMa1w--oKPd2wb4M=MP@wYJK|b7#1)vCe9zjliL8C@Q`8 z9(bn18q3bk4wK2GelKc=PoF;hk(WCd4A|M-Sy*OORlM-R3m7Un8t|vvv+uS^v zw-zS_RaIevnSckGM&yCkEh5ap{lC7L25Cc`2DECYJ*A= zkb=E~eUda;AOa4XD8%>bnjwFBL`9{SY03y(y@TD}-abWH(dqT*wA&Z4wC0eCna@KNJ)se-i0~w`S&Q3!+{G;BL%7Gdn@k^b=FhK{ zb}Q$?<_4F}o@R4>g-)J>g_+hAS~CmoE6-zCXPHi?SZf)LMx<#Mxr_+4|>$rcE!G^SXUKnF2io!o&pOP@f9P73< zo6Q)H$0tS^A0dPg&kl%m4s-Js_SS890Fx!8M4mf~yl_6KBu?V_kMN8Yl2$AC{rQrV zEK5;JBBQ)n2n5E19A|*Uw;r)}UOEtZ!qjrOXkc~hYNKQ;_LlKuh~@&?m^$wfA>Z<; zoG&U6we(+66qR>Vv(`)g@%G@;L7%EBs7%VMpZ#T4FAQmB6n>Z%>p&$5YisMg^2(?D ze7P~9g@?geiwx3wZvmYkg+%3<&lSV6RFctNx`(@@b!byj&ZZn39B_AQo4eaP?DzNC z+S+C|nL}e+`W63gM$MmlL@ZE;82Z zNLA}LA5Y9FXV0eipRvEs{O^YWh+C+|shvQqqp}96q^Hq^AX(|r`Shz?eBm6o?%cst zB`e()>+9<*FD)Zv;=48zy!oXdc4-cKX8{z7BV#$TMGdgyKuX^$35#(Kg}e@rKz;J=RN&dj|j4b5DPUgAGh}AUX-Ui(@ z4;lBR**}4}7uEl?^`vSxw`)eMu{w$8JKSV~`R2Evsvi7V!0qotmLbocdHjPriKi!o zBI|ZZ^4tTGBx&5=B!1eT(2GKVQ1b~~r{}ZL#s+%8&fkN2?pXvzMhJyaz7LWAy9DRo zci~szd@ZQ46Cb;DxT?)3 zvR%k8oRbJ8X|=ly#wD||!qF(HK#?SVUpVO}LNb-%l7u*QD-l?07EK32LT{>y*>u7| zf1mB0J??IA(;p6*&SuP}Q{I02ZLYol0iU{ZCDaei7!HTLbM+mrUcJh2I1HB8vGt1} z&oh>nmVIx)zy!(2riC0$#u@$QVU9IJ$2_04*6i&bu)n`YRh0|OQrIB0(adIr?>Sj% zl1_(Kr{n9Zf)%!B=md#U%%)Syq99RfekzFO&qZ()OBiAgNN@-teNG+}RK{ACx=X%Y zrH~|vB00u=_)*0(1BR^gc7js+i%S67Xe1Kn{7w{2wjk_eDHTeI+DXn@FB$R$fIg*B zQqb*oYMbZS_-RqZw)mTuWBEfIefW<2`dP>tl{Q&*`)~-mxfb<9z*3kJ*M&ie9hBWHLc(Z|V?_Meh@k6Q0DA z4ZE`ohZxlRg&PjBckd$4Y@W#Few;!|MAkxO1`mFk$6kQZ_$KJSjyeJzX9DPn$e{*8 z9BO$opV)N5Hym|VqLRe-I;{2U!9C1bY6(7mo>a$Pht7HxiH$=S2ykeFl4{qXLom(!Fa^1D7=cHC@71PjZ+&ashCbCltsb2SFiHj z?|qN{V6bqA;>6a{(h}XSZ!Vjqsdu?ME;qc-<=f0Htu;(0Q+9TC7G&S^&(ip;V>a{B zbYlz%$UAM{HpN=3vz{@s-n5}AO9q1hz1|XKb@)DX%w%F%nX@*qZijO1Fd^P*wJ}y> z!z8X!36Elu?ldW|g!~`is zyVVZKjc+V!Y*QF^)M9(SqWIrjl69{*o^=RrX8{oS8$`{0eW(L}?DgS*;2L5Z132>8 zhg^*i0;E8NeONh7suYP79+(pEKOz_!n6O=Daa{En7NvWOyJ*g&MTW|2e;2`YV=cGUYH{}L*?Lwh&vRCmS02d?O8{w>v9YniU@)L8%i2Jp)oOk0k7e;z>Nm@nL&hMS0Un{1`>Z zQ>0`LgqjQo9z;0j%@VAg*Pt~(kTVvn@t#%TSsy2PEz*}DNC{G6P@p8OPM7Iy=4D^_ z`>L<;_3|^J6gY3PAX9;KzWYFDH@?AN{Kvm!bK?}h|9ij3 z(#i@_Cd|r$@npiRD5$EEs*28Ul{Y~cj~NaIRAs^SYu9<>jW@V?<7TJ2iJark+9zuKU~Y6j;VRZ(&<=(E3nKvCRZ!tQHKGmNt#xAu~_R=bT#Qp#`) ztubIs-BW0HcbD~3rzpyzF3V_2;|`CpDd7`AsRcf-^bKuYuqzL>Y>6UC6OOi-c{K6N zfFYy|s1VQku*j&mplKBW&^RXp6JxPf)(LgA!1f11gp;pJp6B7>oJ;W>gbUr(l;m+y znsgIpj2+*d%hn?6bPSbwKLiu^PqTe#{pmBLo`7bRy~p>*X#2p$HV?zs4?@Zx{$mq7>`POI$d6n)4fLEVo-I zsW9457(-DRO06lie_fQCveM{E^I?zQvlL1x*4EZoS@DJckHU6Y2tlvcqtodS`wBeD znVZ-fAG(GQLTw^UXgA^)oIwkTQBCAY?+` z$^nZhtoH~O;2YZbA=@xE(Qw)oGBk=0ayBa!rE%={O9Xxr)>`LnsY5;zS*)ToSm6yM zgbHQ}b$%s4Dv~rM%`z%u`N5lS@{Mo(1AqUuukr4C?^6^dTRYoqAM|(JOEAhHcZFHdqX&mr-u7L|CJ+~ZVZJUd_rhz!kKDHXT{;hp6OvlO+xw8LMlVaCG+ z%SRUwuQgsqvbww)cCzsYrY`W0m_cxOay0@bzsfl@SD^0;!N?lQD!^{|p%GU^$WksnCWo4+ep{Oc) zPg#QdsKW(`0f0z@-uMwM(^}tq;BmNbS!2;gFZ5CPB*Pl(dp$^7chi0vBNn!LwwWKB zdLd&B-}~Mh{KM`K>-U^jIIL|~#B}wxZPDsB0 zgE#n_ulz0F`iF0E`_3K4(f>QFat9hR(FyznqP~;wptvsh-5H&gxp5_eph}Iczsz5vtzVHj75C~4M zZ?MwsFw-SYo8S<6NK1JO02a?QV`KE-%ddh}hf5)!Qs+oaFBC9-UtlA{5HSB0z6^ z5R4mK{H~~Pz+U(3>#tOzxOjGxSI(ayOA>~~jH)uMFLzmPw-Ev=qbaqe)S61$0DdZF zm1b5|7;7j?&8#xaD*aHP^;wOos@UG%rYJm(-RX4L*x2}3vn|d!_V@Q03!)aU+K*(+(K7nr;Gpg^w6wIu%F3gW;yp|>?Y$!twzjtRRMiYYumL|fsAY0#nsVyY zDcbEvb1a_j5VYGJvPKP@wSLy}up8k?oWzf3+)qgY#yQUdX@k&a&J39ftn=W)MJG3~ zE;#c72n9j~gQofO-3G=e)(*#7W9ckbCP-s2m8PsrP~liikl%T5;&X{&+($ZzH7?|5 zp@`pkQzx$gvKXy>Z8)B_5(Kq^6m`Q{HAN2BRV4X~F8sD*xmE@H_nBAO0ary&h*aPxJOWZ?n6#N1CQ+t*LZ{t~Aa@sPEe~)*&S#7vNfb&-rjtqCcH+qSbttilCJJ*fJOAAp zLz>9Co<2(xZ+rfjle1?C40-f#8`O|5u=CA3n={5%`p;WqFs5qMri6qVK_Z~n>+sr3 z7ckBt3jqbb_{)KFGSGJq(p3utOJvEWoUe<=bR?i!z^t}SRbYZbK~Sk&uZP}v2#I#SIxl1$Dm0;0xz$- zTT5AKrbWd}SC9RIds1PogmaG3aKzr;UVY6~LEC-q+_~qTAyP{6 z+H0@!sWYFd-!sN=>(;G%N`Oz|Bu--PkZo+J0nrYO?~{Y65OvZTYC3|!f)#)izD}rq zKzqR9#Wg`GBAhRCNHb(r)qu$83NzN2TQ@OUqcTaFCgi;qN-4(U5vH=3%2G`Wl+5w& zZxZKBkirR!^{;Wx%kLVBAr*j-1q{?oQFICx%GV!dSckb0qA7n@Sw&y`*80 zm2Jx3yiq~}E=2v=J(h6X`L$RXSZ=C@ER$c6jOBCZBro9P8^#h%BKTm1Ghuf+B#R zSujN?Dq9ycR@&DK6~+T1t(|9zN=<3?aU**!!dl;F2&iYuvn*pU7<^;L$lfJ6X`Q_T+gJs&(Kp;fNrg=SP;@PKUR1%tRNlp z(l{?q6G|~F3hr!e^EZF{6~6M7uP~iWskC7-p0a;1U=r^AQc8a2XMUD{{xAMT?Z(>e z_4w4Mub?sf?tlNg{JVem@A>X`zw0OJdOf8gU z5#r>tcWC=C$^&aHWl^xRyGy^{56>o_G#>^eNs_X(w8ZlADp{70rWr~e2L&9H>5S>D zzzI)8wA&q2qHx;Fu(K>>soP_7^9*19@|QWaeu^8{ZyYO)J8Y&M~39g`YD!r zODO5vu%xN1^GKhsKE8>qX9o<0@Qh}(#P%1WN7CT~4NX~HGZV6VC6#Z;s#0FQbdI0> zrC%Vo71^C#04n2aAABDof^00TbN*jF5-%59Og`qUM`VcR%!mkzIA6!)<^U)Fy!prv zy}HlwufG)lmS<=JfQcaH(9A-UtBF8k4wc-($s6~r_4>3h-Uzs;mmi6&#gqLI0BdYd zlYJtL+0`_i1zTKAl!Oz42M_MFA?he7-gS+qjcAxzV z&~v*_owurjP@S4fXpl$8W|FTn3EF+$kWLr`Q@`3~E#Q{pp@wSiOu>UpI@rY2l+@Sh zm;--?Z@1dL)jG%BWN47h3 zB{q@Z^QsqkZpZ4NDMYD|BQTXdLRBUrxx-3tO<|eVpCDLn1ko(GN+m%HD-nstPkI+x zv{jUAF_BThYZ358(|lQf+S2j4_ue?je7|6N@-@)lAe#Jpj`~Z^Lg)a&a&F`b@%^Ri zg-hT2cK*qazG!!B$$7QKI}Chk>$lVOChsLnr0@Rj*Ve!~iru>NU;NXQXRJJfg6-VX)pNqM z2|c4{hSHQ(mz}Qfu(R#Hr`}2@Z(r@DC6qRSx;!q)aSYmrj%G6}Dk}fWGV;leYql5` zb=EN{l})6b$PzqRyC0b$sk=ySS_qwq7$lfP!o}#3pWxG@xu@r=WRPoCglYrgz7eA;G*2GdH<%STtjPnyRualO{< z#UCHAf5yMZTAwwGlbtMmM91N?fNT%iX1yY`DQUK@p&TgKUpz9TX`R-yX{)GHEm#F( z$eF{yN?PV|E@V=uUgn}ShA3JKpUeKNE!|_Q7oS?vtU;+Caz>m@30OR)XbLY!Y8Af1%aqda|j`h*&|N(M22A3hMe=kt5z@lSH|zSLhn zb>XdR8D5yc9#DO`nS4X?Z0nD!?Cf=5-JH#R!fdMA*c!OC*0dg;85_N;=ns{-Kg7pL z|DutaY!-pGop&r4m2YToU!`tBScwWZ3G2$=nF0h|kjXk5XggIoQx%&`uw|xTnhkrX z##55(?sbI#x$xleOWc(0VX-^MKp2LpB@OWJ1XK8nWnL{k0 zO5~s`FCZHYqU&`Gq{kBT&fMd3;D!E#4+nS)5{y0SY&LO4s?o*?hPDd+>H2<3GD^>f z)xYkPxR&&|4tPH8e`vwqCAu#SFR^Oe$DP8gOx>JZ)V%Y-it3jf?1OBWB1aawP)0~Z zKnMR`8}ZoN_GHe|KNxFKIh>BJWgRPv?1T5x3jHup2X!jJDl?_3wp2ZR_g>bG0W=$1 z;dIB}#jMO-k0Q#@@%cV+$|M4-MXmY|@$g zyRE~Nu%Q6)tW|@io?g-Hkw9anF-Nj;1-Ozd*pL-BzL>7Oyqu&>c(wqA4EleA*MVv6 z2Uts6+t}6hwx;=6@I=YhmhEYPrzUCm^<3!#yhKi3tKQsb+L^+jEhdxr54q#8x{<7+hWppo|==rGu}*Cf8?uc z%v3>j3AR{uZLM-pkd&o26Xc424dwKEn@}!J<+uWAt-x2eE>EVHB!%dtz6~kzZasZ{ zSmM(fk97z(jGKVpkiu78B}05_dz2S)gc4Y3v^<@CeObzV#k23YMw!j; z-a5ROTJ3aB)6!yRY2c;rbep(T5x$l5dv5Z3J}gXhR;|OEJ;J2=QsJsWQ;|zP zspE5^v$4Mb&TL?0X6EROC8efE&i9gm-w-~!(9D?Z1VUbcT=D5A4^RIrQXM_Lf_bZi zVm{?E))XOOjtpDv{iPy!>MwpR3*UAa2X%zKGRttu|L8D|CSD)#cx=ruwCfP8RvKkQBNnmC(?oxyT_CB%V*lxbgwrs zfY~nyoo=UGnEaHPLR}xliCa7s{z?MYf*%30!C&!t%~21T<~TiO2jv&i&FM7!Ci&2T zPp_I*7YjU3iNj3Wz&Q%y6{V5Yva(nu!UsNx z;w32Tr{qbP8d|IMNU#XpL)XyXAM6$+mGZK`5o~CbRB(peAt{>%*WV?!jNnGQNe#YD z(d^dYENHKL?8yJO#;IvoV6!nocn`nun3tjl)d_C4bo3y-aLz-P^YSD-PX3=Pus`;ci`N1I%p zqfoA9fk38zRSqPRN)2E7%Q_Ci7K0rW6CUQ~?VX$ZID_-Jt?;JuJy$z#F1B1_E)o=FR_Oog=SEqj_ z3=ShJOosEx=*zb78=wA~u6Z5uX!;dS+5F#hYAIzrpjZNa>z$jPL48jdIj|l4r)!#) zj!m0`nW4USbcbHNlp*p%v27>+FcZ<3|+#7e-+9xxH|@!h7)W&qCNaQNX_s zO>FAOtRnY}mG@U(xk9WSCX_0EV+Tx!kud_(-7Yud!q&!mCjf>9-6Wy2mq{JYH`XA2*lbew<8w2co)xOc(5HY4$Kr0pEAZy603k3V}ttSz{>R6OT^ z@z&>^JY_d;Vg24P^2@_4&^|}6rLSMSax^bBy5%j#Hwp>%;RGv!5*nRM6OFRApT-5L zXX)x7)vfKJj_cVx#MUP^<1YR8#uHZAV49N?0Y%c>2fCRoliL;$zEVFY@>$}dnba`vV)hEk^4 z<%sHS*8gb|fMT^UeV%4Da-NAf;{Xa1IE6FEg{mQs55%wsRl{OEYOvPvH@s5P>kNvQ@}Gb~#=8v0Q;{K80H51H&X zIzzZS6Hd<7Kf0gU)zq~~X{lY$1b^c!vgmv;xN;W0cYd*dzuUOFHh5!?jO@r1Hm<&9 zPI@I^wAUp+w*}y_>b5Q^t+ABHMV62S?~>pBK@i zJH)^;b|g688OA?rR$r_$CvpTwQvj&CA7{e(cn&|??K2${|BV4CDY~|dR%}+yR?fjZ zHrAi;qtC+M)?9Pw$?x#HS<*m!>Zh7%yC80l!b`aTvfy8fO`JDL3AHIb`ZbNFv7|B& zcp>=}9w(>et7~6>gP_&n*=eAL5ahx?F+mw4KkE^}eiFs82LG|67!pzZREW!s!Wvv# zvmH?&BiGEp2dDgKZp8eef7JamBt(WvMj590DL9IUs|XYHU|zyJ_H!(T82TGQ)mli# zZ5dBRz?}6DQjxw>r!D)~DNUx>7BW1Su%+7m7+rn+gMJ+5nPFx6lM*?oWp+lQ=K{P} z8PQg^NUC)9azYH- zT-o;sW_1d*g~>Nwg0%u>u4cEC34YLI!M|5Vw=VC03PzyfiNOO`HS*hy!n?~`J6hnV z=Y)dLR!w%Fj8CGG7PQFtpX`3&S$Uwe8+w-Pkes&-mM)c4dLL5ZCm40IL`gvX#RMU`DfeBUR~?Q;EM z!a2cvhYBFEM69?mr7n_!*514Xe95vKDIYkQKgs{Ox+61|SrZTUd1zZ3t z`RdnYCqN8t$t0zibO!eAF8q3^POAGw9-=9Q481noFoas`Vk5xI?O-UF}3Uc<8K59-isQz_{PKcYLH)MS{~Er@i2aw8Mr6x6 zCQGq|a_hJ7_9S4o1W1f704}*XRe}D8`t6_1Ie;dL%k&$$ZT;YkK`u=8*`o1JGuHl*7aMgC(gk^{~=_wBs3NBbig>FNpBLbydVPC-U5uID7{uN z8o`)&>vcclXb|{P8bckZx+ZsR3PV?pcDhDkk?J_u3@B7(teSVa$!*MNRB* zjV|jVv2+k~5(O90Mtsh@OoDtT#Nt5cPG3kP;8Q84a+!A1FPWb7@mbxjw(*`jyZB#t zzy`fVLO_+oMI-H)GwkxG&r+Qv8?^J3vi;zvG{^T>v|d85HdslcRrdW?cAtlf*G<-K z;~L!aoF-Ive;ekXFt=J?1o)fl8YT^V_sW57^2K)l=XMvjr15#G8A>xV-xOysGhC6O zx|SD8vIZQGPBZ1lJ&YUG4^VFWQ~RDdiS!}eN|+o-^!S0?_drb3s_7NsWRo09;LhJ; z`b}b)*?AhGNx#Uem%eGwMFs9y=ewxXtK7#Mi+zBo2l^Xdzp%PsprVKAG3L(y*e8np z_8MRF*D`=07QG+Znql%o$U#MTVlljz*ji08Q~?u;O1Y_oVfZmO4e|%mpiEuPx=1r* zcIm~e25Bl$M9MN|!FYDwWG&oi>X%1W^Hy!d_MeSCfPy%y%g)_$4m|j_wzht2YLmzS z@>!G@59VOiZyP~Z6?-RR5zo4Ya{UgxruO!51-*{woua2WLhqh_w~Kx$`u0j!q$>S; z47rzF8oU+Us{PSN)srh48+%gcx@N3|DkF$gR3o_cS2hW3u;rAhJ=}t^N{H~c=3?;b z8mZ~nDkE!xS-`L()5c5p9=@~mQQTEx&FB!`u41t=G#Kw79z+HeLmz_F{|ZZo)uEp` zn#NKqNH~+LCXL5WGPzgXHyoKEiSGOxJ=9_2NAa98A^lj~$>U+B|2aIV4}Xp)`Ho-V_ZM=OaLPv#Gq^-lrF%z54?sX?^~%xFG>{g$IJ( z9`H%66~(4NuSil&^W?HBwE`hEw>(ItP+;PpQ;=WelGfI&kL`mt>hZLa6M=0c;*Nv zdJUD8#fvS-JlEmNv+i2#=aq5F6^9Q)mtmN2vi~Hp=FGR#+qQ`6s2~11re>7N%l*A! zz<&aE)8rFD@TY~?2vl;~|FCk=$diF1J_9V5cw< zI?K%6BC6~CX;Hd1+O2b-B~7R|Q}~6<{jPYm)75&~V^gssdc)w_vfwa2l~NxchoA%n z_7eaxr=7eKnz@@P&78Qs^5sw>lTzW}w*P8J#QYxqp_7q4<%ixh$v;PjDXEi4PWe~& zA`+9F2AN&KN)o#8>`2x9@!>1REsmMA+VF5_)@m??@MbZCWLPuyp!yLm3UMC-E?9#t1o@wv1Vv9x@3_4xqn!@pSSZTII$ew z#w_)P{8M=<*SirTQW}d*2+A|7(ma!{;MPJjqyHt1fN}P0^Do~zq&T}m1X_99#~d~& z)DV*mEwtHNy^_9ug=>F2gVXigGZVTViOSj#h>3sOSG0_Aj?8ELH9=pi%ErJXNxM)^ zFP|vA?D?$>Bh_24@fnVms{KuiR$@Cdmk3sDOVSX_^K3f4AvKf79>9kc8q{hUTfhBT z@iey(2tj-Kw}&m<474o?wwloVoYWgT_8ylJ;8lkC;~i-2t+0=OykEWGOI|J%;T>vd zt})z?Mi;C7fdoZdY|CpfkgN!kfPetk zzxYjug5V>*U?S44T-&(BJ-~_|12{M>*we?le8$Y-$)smE=Q#S!N`7}EJUW2i@2Nw`!zN!M%QZdVQUm;;J>p4v|2JV8eP168xUaC&*LRtN|Y}A*qR%4ulg`o^@&mdV`8$2}8m2dup{e%t^+f=P)4_OshLBD7i$e z!GE57JW@q6>Hqb4=G%jBWui0B>q^A?@zAC~m>T+?5!r2DZIA~jLB`plVb@ZB#g$pe zSabR*a&)6U^&0HPEG8&H#YztlTf5f1& zG#lYC|E{>*yhh?&C%nJ*^?9|~In3aZ<~>}$De4oy46Y4?c`_+m>tUi z)x;64g|x4fVpCQ{H~d6y!57?X--BjLC~qko^4{oceH;4kRu`^4V`~{@ID~s!J37Wc zv*>!5_n>u`TR8jeM5T85Igi{;8488YD189ST`XPWbv+g(jXm{BMp>ek#5 zRFaD>JQ-lvE1tJ{%;7{0r<570jXSHy?b5)6SC*M(4^Bz zgYA9M^+t^&#BH6_7`ma^Wqx5%*>~Q;8axjydR~Xw*LJ!8bnR@~oaiBb-3mW)QD4OJ z{Tp0{0D6IL+r2rG2ZS~Szc=Uh#~_l6k-gFSK;MQB%WK49h-GEnKg9DfsCU?Amym!y zwDxfz#O>ymHIJKmVTZrnXX?DGcz5Q#qAU`qoCaX6xI1LT%v9(*pb6DJZ0&S`QE9b! z2%c!2}q|qgZqQp-!uTCd>+|nC->%@aiAPU8OGN!_pq^spmTIB zy#c{gQoInh41`fKO97L(#smpvN=e5*Lw0wdTAbfJ|3vcc%2wB%&TmogJJYm6il(i8 z%A-BTh`6imjgF<+w|I6Q_)Ok6*DQP}#k9<*ZETdQ+UQ><@0&Nl;y6;%i1`*%#DEiF zJihJ=Cw+XIxuGCNwiB#gKD-{{na^81U*YU(8F4$#Y?(nGIJ&y9puR`0dHM$p9_ML@ zQBFZYN!Gaa)sNJMUA65@F6+*@v(-MV99vZwslFZ?ll-srms(7SVNtLx@r@`w6?6jT zzl@yyEvfI-PY?!77+N}3b6u08E{>5VOzofUjh&9^Lb^0NC{F7+UIz!wf`dCj7e)v- zQcK`$`=S(*!#xKi_H+C5axo~XQJbI08D<74IvcCow@pAR%G(a(m{#%?7Kt?l;ttM= zXvQp2v5U8FqnB?qSEp6-_gOni_;vyE?-+g9os`yyRZ^*lg~p7Q%Hz6DZgX>wQHXR@ zGzvMUo}M9oKqCKI+nLuV7%G@t0sVua%J7uRyoXKb8)PzQPUD_+ym3_%W1cr7(w|Gk zo4fkMN0Orhn-+Bw4b~T%`aM2UekJj=%Un`U|8SSmIhymE9|u6_Ok-b8mz*sc`bc0F zl-pkr?aXc$LMxfa3W&YX95X|iH+ILXSBYoTTFt43v*!WYiXjaQ?DE}CmnCmFNMqeG zbTTtvj^6J{wD_9_BH$D*7=U?D;PPRI(lMF=(cZzZ_P8xkBoy%^Xp-IWu;OxsSJY^v zhOlT%;O0w+Ts7h+j?tx{oCjzGovD9(7U&}yLEGBdY5LD>z@WRx>%8y#w8jjRn$KEc zXH(lSkIG>)60*0@*;ct&^@W%$!o=^o$uGwLP1q;kd&lNQo)n+IV-ny1zB|+F{;0)G zIr`ZYvjC!#I*(g~NzHPI8v1fG&J%8hfST}>dnX_-unY#Nw&!QLl3Y~>SGdf2>BQLLvTQF1fC74C*@M|ON2A63GV{huesbDgV z39VpStpXZ}q7m ztQ);PY2SVXS(6i)WUeoh)~Q-O{yz&K&(R2lethSB14lQ2X{t5AI-Y)1U)qnZl}ZsF zUk2O%;RMMuhhhkQL_wDs#~vqiKhpB!auZSCXe z8VZ%sM!jKWX>+@g*15Q2n1D=j@Dc2oJ9NxLuRmYe_pk{Ie}wBBmAs`b>Ua#T@`A+N zjW_{rH)1?<5PtS@u6 z@Muw;#lwO|=g6Bl+#}Ehrsj9sa_|?3)EIWQA(b#=X=G|=3(Rf#@hw8!nocZaLNf{t zvAVMfF-#S|$Y)b~U|b9lNSZWJS}x}dPMpJMTL0>wv+*9}->+csjsW5%FQu(8ajhGD z8i18_6oe~@gJq)1^?QQudNvU3rQonw@;#)~$?t!fq0{%@K}Pu}++EWf1~688Fa4u8 zp}rY0u;br?7!}epG9VRCA8!aU0S>2aV~4~SNYJQb@d@}=-aj+LZr^@M&C+#;XrIlG zMGr#%?!~tZRPnv~e#B>v^q(UF@@hQ1_d7SSc62v=%6j z5ciWOY|kF^40?lhcDhzrBzYE^u9oiZ@d!o;U5PeMpxhr-6$CoAMgT0iJ6{_t>ZiJb zkQ4g(OxSiHervWKiZ|SSQ5v78lQr+b>%K3H9!c7CNn0Mn%xTy1yJ4OmmpfQarXYb7ZP!y&KQ$p}o6q6enyoUoZ35f)U)N&8=9{6G z4b^AHi1(PYl+6BDs75~F)kCOu{k_jV#bTiF?eJo*-L-&8YUv1ss51Ksmrl_M1pJBV z2$*8p!`o*Mng^^mM~OgvvO|K#DfMH-=dD*!au2!485Zn97xB2ZbT_)&2eK zrSvwW9lR^XQCuWgwSNx({?@d0dZ9d68U9#sCu{NEdV%qKzxU4-eoqqKJE9>zNPFw~ z!{>7GAx2w_knViOy2Ck(Ep!!Hgv9h`R2rhLpH1L=1FjYn;W-SJh|Gm!*zkmXU}?L(|J;GaBPh8 zRe$8Z^WNR2vg)#*#W#ZF?E;SQt6MZpu1DY?v3J%V;Y*|=hoQaEw1>+$e@NST=V1RR zPH&AXS?U^bOp4mn_cnRKq1$}gE2rN0el~7y<(8imEE3F=^v6 zSBdiZytNE!8LOP&U7)|v5iCtljaLQ`qknng0|e425uWbL-RCSw_+P z4-Cr~C>te1xmY&5V(BB~Cq{j}?YX1b_IE#rmCxRK$a>(XP|`?Fc&P-`(s}&)Or`~% zMhD0mZ)GR)e+QI?RBihgmT-B-5b)>bg!Pi`Oe0 zsPGE&vvYtb1p^5sH&KmfxMV)J(ujqw(lD-j?Gv6p>gay!liXA%f0qb69iXFE9N?6z zUoGuc&UbJiTvkijg35b3y7tp(Je?&H9v^FLooilQq0-s&#{{EI?TvEiO4%eZv~PpY zNc%xjRz#5IvI=WG(&hytbZG=nCDt)#T=?W;;}Cb9;p;5BE(QPi#1-R}4=wey(rr37 zGi2IyR|37kNGbIT_lZEFiJ_kU<7(O&T|R!u*BDBnTPu%(IW*DJ>$Im~+{>fhkjXypYoJ4E`t(**L<#q) zmu#(47;fe6m0OJ^`x;?ED(-aOUC8~Xd1JIK(-iL;D(`zzn&<7xJI&~*U}Xj@!>C4j zMo!WC4>q3p{1jfB)WkiyNkQkto+pg7M((A5$et(QCV>`Fpiypk6xgLR2*1&R7jo-Z zySjT(1&72@h59Un|Kq?G{e!luCrfAlJPs@PkMu|3@VTE6GL$ozYN^X?@&A{PUQhrJ zPCn1HcKv0b`J3mkrrCo^H5p`V+UrBsjZl$PcoctotH#a4Q^x%TC?~^YwrwIWM6(wV zs!U9hMrCDn+g(C#V*rPfxFY{+OQa3oL0QW$?Pq8YzTfWeogFrIx7EzFoo9+!ZW?Px zMS3Qdd9))oQVygE%48`Jn5CdDzCr8{BS_zHFQ|U!aSo!8>>qC<9$=@{Xg>{zsIXh- zCej`dr0}#Xtk+Bgf0R^)KX0>R&|-vF{P#{4!V1l; zDlvMGBvCYX9V068@YCd3?M%Utf5%h?1G^2Q$AOe5q$(NV=#+Quu;H52OckUg%b6Jz zoj;VYrFg9P7(sq2lb5L3?yRdm_ab!bt@)8ZvSxr)PQ}UOo5WB6)3a|D)o2GxSG;E0mFaUK@;{bZgE$r-KTUz+6+}m@HcSIkF zXa;wnU1{;rRS^;qOU=Apt>f@gS2(s0ay!4I0G;a^8(5!Lwop zH26J}UnS}$X0F+32EHk2`kpb18y->Pek5e=kp)1A4z9=W-=V{K+m($I-%uUNN9|K{ z$e&z+0TVdRQ_bq`_q~m&1BEUM`fRM{eHjv%X>O8{T16@24BJKs*Bq z5r5z1^V!Ztp7?(Z_C^9F7qfnQ_YqJ{I9ICD{=DvOV`rmU>BwJ_ad)~h2&@@_YvNC? zxvN=-|Fyk;+@gU$(Sd0=MG*@wZ@nrb0MMO2hRD5)Mtg>+7}?WE(*272|ypu?{N2g0!! zuaJObe5w={FU-)RQWPajrC(4*yF@Ct>%e=o;!0C)D(|U#)xaeOlaEjm9X6CK&`nJ# zCHMmry7I^@N{H$G7$;3Ek(rsvXO6Mz4A9+vbiWpQXzlWdCfP!#fQ{I&mUKY%1VhgS zjk=6z{=6m(LvuxluOo`hQ85&}h8H+&aFhmmh-e;<#?2|~LMQ;9_dqHZlvg=l%O}ig zZQ(f-GMKd@6sY>I{fmTJmYFJ04L__QqNc9_ny%=#xltj6d?}{?`~jSC&g29&1DQF! zEw2SLBCh_98}Th3TDE3Fi6o~PogsCnOYy? zh-0w*-=Sp6+c>8vG6ftKz=Gjwf8ySF=tpZ;r@vNJgmyP%MdV4-> zg+1=l2#MBBQ!<1mUx!FIn7csKO{GD(S(Q8|rUO?822a*G{%?{K1_BE9ydP+WqXNNT z=H4wsZ&v-YN!wVjmGR&MA;<8+*ah^Eg7W*sg?sV2-)%k#vK zj7_}~=s7jSNkZQ9A-iDx$5aW=t5h|`V(SGfv+3<X6(Qj5*m4`>=J-&tsHOYwM z@a6=N?1!0{fkoO=nMOMHb2l0)4(Gax$_n+%x9sjU*TFD&?U9+(X}DLvp)>^K%Yr2H ztXu}lkZwLcb9h!OMinS4kmI}WAg})xyS;vEG;B2cy4!}Rk=`NCr3Gs&Wx`Bz?M7if zG8EZ26%2B^DG>P}ZcLx;VyF61a(Cn)xOz#bdOnG#=Cp<9pDcz^g40*uTiN@LYO9E8 zm67`o4hy8K;U3K=$XU*iT#Ow94LX@ka^8>FI%{Y(v89q3qIPBX3~*gCM_k?me6T@) z>`0aDK-&=|EgLyzEEgMJlqBsb{&1bWM|b3aRu9hkfRksX?)mt6Z?b8D_B1XVEmB&l zUWdr40X7ZR7x2=iW&rO@>IYoMudos8C$vFdP2{LzR+{WdoSmKTRmCbWYm&P>mXxcz z)iWS`sSDhi`Wu@KJl`*I{BIWpZu?ALb_^cPP)PWsbBg{#9zNdFmvxR>-v&br)P&yQDa$&7L4ma}!-}5-I+!P|r7*E2G>V!*JTQ zNOUr6HMOjRxS}#+x>Cv(HX9qe+LoGO@AIz7jn_@MmuZsMuf>1<06&`CJ;158`!m88Yz2*bI}osEN|w@5baQRDsjeZab^6J!?|k9Niio;Kt4$UvTW;3P z>5oat>JDaA@y?qSsOv?_v}Bg^m9=r2r^c2n5liN!hgH)JxNM-V?Z5QiHzxs5#Vk7aZzU4Q^^`$-PlX&6K zou!}I=dfmU!NtuRGQl8sAGT(+ku>cG=` z{OW>5erO7KAYNQYnb!>u3=9CXj62s1CzVX%$jrk~0tKL{y&I1fR$Wi`J)nx7o&UBH z7g6M^#3$70720^|*|==lctg1-66~vb>pk$;9;W#*r+T|4jBD=my0Wo1`F6$9;^LYh zVJV`F+pAtRy06~E{;|1$MB@RKI@r+9FK6u<4tF_ui?tV1{O~jPHf&4=*^!Q_s)?Cz zl>7QKoqd*9TG2cgU~}VrAAP?O{<4I8*DoFkEAtVt#1>uDqfhnYf5dwDJl?<(m-EtVx=)B^3>JWlMB_^Li_r5>@!%0oM1nl)2q|7oXypAuAhMD z{x!K(9-!u+Qaro}R!hOFC zjPIwlf;lB-iE?~jKEw%lgnv#;b%0p^vTfdOArRv;;3?d~XX;jPyA)0Cwa85d`Sfnb|>(7^<&eubQi)6m#Y*mM~Xp zA7y{$um4tMy0C>)q!(-c2!~#>y8})X5PdUnx@qOPtVjuepQ}tlpvA$&Hci1 zFS+Oo4E~UvX({5p*P{RA$7#e`q9FEUj31}6zZZgsM^jSA-Y227V~3{P-g()qeznNQ z8#ywVxk}uQPsHt%>y>6BqZuPM(cL(c-6beMuS z020E^N0;gYDMoR1h=%r#A~&c@Kx$aOj=xk|0=H93ZG9*gc8F=&QlWm-P*n7)W+XZA zvtTE@k-?X@YM@Stz4SF%NAK5wdwt{k=BsHY$;tx*2)UD?rg&Lh4k^xQl{0>0`e_&P z7xzIJk(yMd)UTT{?jq{S6A0AJ9M!#K{maX6D0*0+g5qMu+b85uoKZCjH6MiV699__=nTVB? zarK6D5-T-I2J2^xsITXR`J8Ap4Z1*GU7?Ao=5_Mr^P(rX!D%7d6a(6HecbuR0PkkwuANh{1R;>e zqlZ!5gPah4#|WQ4bdEJKeIIX})W)ZcCg6YvZ8I?>mD9!oeerS%gK`bpLm3jKUnxvF ztcTFhs7ZDFp;p5y`5}s|2WxZ5ioZdl=I4Io!M#}K7201&UtmbZ-=|c|CphASAv|5r zg3;sRDW!A#{Kj-In8pE3L2gAhPHkU9X$&_{_v}{Can0-pmfRl*;qA9KvuEYt{|z$m zcY@5wesMv6hGxrv*L&ME=tXBxh_t)GYe&d}pT{{+^8p1TX3<#mR{YkhqdodTnP`L$ zZ^D=WVOuM?jG!Uj`kN4>+u1s#W8cxQ%CNO0MFM=JjVw))*3ndRf?WGXNUiX*`yK+C zp}-WubG%@-V)!L&DZU^Oy-dOZQYfBIrXcsC#*w@C4aXqJT|}6rWG{(Nyy;6r$?(~N z5VL*G?fpKJ82qr$!B3Vn1=b#-pG&KS_sa@HECvH>hMPt(bkojt^*LUMf?u!emU=Qp ztbzZ9G2qztS{v0D5|AOdEnCN4rP77)4bGQqMC|-pTG9fhiL+8-MvZUT)$$YvI*uLG z-{BqQ899h|?Y_=Kb>~r>e$pgko0vYoJ+gHjj`G3GT}3Cazjk*VKcC>M)YUTPm9}im zzziXiz200ufy;bSEbYDzKCxo;F+%dc`r|)R^}6#O^f)LS6+>D1;ptO#DkD+ieoIMx|zdP#KpXd zcx}Y#`Nn;w_1SK(d`Z5^;!d?Ss0mh1u(?K^@ez(&lPXQ>Hacw zZ0g>&Un&?988Ur)=p-V8b{mB3(8EgJX23_y8F^@UtgYg*t0<}@W-Rn+8`Vfal#)`D z22rm7xz^aNtUsWIdvN~`FZ;$;Ku4RV?uIe%p|Mj`JqkL4OL>4}d_j%mcRSw?;6kW9 zs%Y*THmz^+wSe+uQ*r`Am5Wi0?NeXAy&k3?t;mwU5i5dfyzlKMviJaPsZhU) z!lIbX?D`**$ei_1ON+Ho6dKwfVkvZSbN^yupx5geDdw78+W5FUvF9$jxrN0!U0pDU z-9I~0G5v_dvbpg~6al!u2&%BmBN&IF7P4ZRMzChS>fm1~9tyZc)$B>9k)G&Kf+Ret zfZ!!&mw816GD_`aj%|Qie}mEYI8qb3AG46=nNSHglW2>n=R1+LuBfn!-3{BiPObAy zMgrppp!Jl9ZD$qe+g}`-#5wGQ{h&eB`1L7H17)%BA)9bl z_bOynf?C7;9nAO~f;pi@PL!8T&Tz$g`S%_XVT}OHSKV+R(kcr!G!-K$U|mHP&~Q zi}=^d;Mw<2V5+D_5rilwSSrQ@mlA2iEE2!W^k|n~9Q7Dv$!Rp|gS~9H`!*F-b?vod z=1mHAhMEth%YFm~sWDW22~W*CSq8N5WIy_tP{xVho88R<5gL26oJS?#;RQn<;q31@ zAU8LhfM%JJf+b8?zxGY=4R`+^05GgVE0d%CllrIEeAasnN3h#sX6yM7unGeGt?Lp6 zUtW`d3N1%~`Ha`=hW5X?RJXPWL%rn`gO80l%Gr!v!|?JLjgB&S>#(SPM3|*r|HpQk znt#3j=_T~Z>9PGYE2T7@WZhCB_Tc({8`kyVpF52C&-yR>&%g3S<``=eRCZw-5XOrs zNu(p^RH3QIo!{2puSp*IINlk??+6?J8lJwaaNeK)i8KE@8K{&R$K}g4f|_;nsFnL8 zMR_wTk8}E1Zv0}5MyNlh1MUYWK5Z!;3S9fsOx(k;brmaUIc_3Jn1xtJN2ky-(wR;S zDPDQXrtw#L4wcMHbOkw*vYN7?(odsbMTfl9u`Xt@3Fa_5Ys?c^V~s0v4J+&9E4Y!Y z1=F}~!!tvKu`A+(a51u8vj>(e*DF|f{(L?Tt2C>o2!04{VAn>s3Cli;SQ1`{>ZrYUnJ-qo zGIIMYoH$)h8BmVGu&;80Qa+1$)`_U&68jxeHfYv0uJ4VzuUoJZI&CC~|I5z(!!z{v z(5|NGi&C!L6p1OL+cTrP3KCQ)7bv)NVIdzfPM%zF&NwP-ZEE?w5Jv1_pf`VLY5BOO zao!@{JXtWPxFRDZ%Io30<941G(9TxDQ`&X@?|%OUS^_NaugpyG4Szz{mrfn;fJ?bI z6j~}?m-g|VXYHmNjM9)!zM5KkU z`~M)ghlAXFq+-Vk2LpBJAe&>>d#+6;@Ai9aU@n1tWn zb{MiU{+K&ayK2_5cldXR9=qWl920|#U8QSQw+Q^n5(!Asm>C%_hISO#xHzPg%Xgp| z|A(fx3X7|2x^@%Xf(7@+-Q67;f_vjGO^^`Wg1fuBLvVKpZo%CN?(Xb<-hY2*>wMK! zbIz(U?onNNIddbj_1gOIn)wIJ^(!x-cc`)}WT<_YzR0S%1hU_yj>be+-g{aq#oyc{ z9s*KHIZY0^>LgE-79xDE^62Z!#y`GG?VzQN9Dtb({C>X@SuVQUvix*EMXE6%eMUot z;VP*T7(esCt-;1E3975>kOcg=PhThXs(lr5Sd0afQL3bpsvT!_?gm;Gf@JdkfIHVl zR;GcLdrN-KWZoqGQPx-$$m4#h@su-y@0W;^hHc|pYp_Vj^%JQ_7E$9pn#mez3GrHq zb=vl2-j+D4GgvzWfk6rg7mLhNhqDfCrT?b|uw3cFSbbN$hmRV8t#~j_9HH}!{5>?R zFH1GTj=k4W8<-qkc`5v;`k4JY?Z`TsnEzXK`@qaGKbV0*@U_R$gbLpRzh4Y@g*fxq z4fur7&IK5N#THIpI3o!%?H6S+XN(KiHXwA^p25^fr-0Soo~mLC?$iF!?5$jZ1@&9U zRu1X~pg8!y#nuo+95fI|A;atWUv7(`g^SCA{JvelZH2nx+F8xQ%$bXhu5N)rh11?8 z#vZXvPZtB3U=iJJ)-h50b*5+dt}g1IVb;9Y<&u+S68S`oK;$|;txg$yJnuQM_1+(s z@35tT@$t0LWs5d{98bg2g55^{o|+X_$lF#H-*NTpfN4CgSUD;13eR$MG_L9M>h5N+=5WZ?4tEy<6x+|b98Wp9<(V6ha=9YlC&o1 z9-1F2T_6PkNkw~+HqxO?x|>#TD#WSgI!AtLh*p8%lqeLO-~s@jvZS+I7>s?UmzHAkTsA(E-}(XDS?{VfIy?t3$=o_590?J$tE?IEcEp1 zb9g=1Cg_3m$Y(Cc3uvsk2rKRHbUu!BmpDlogucptp8s3A`eCkmEL|;P+c`!*5s6WBaS09uAtxLxnbTb7&$~UJko^GbdUGpUFTfDE7YZa(y#Mo zu5q`gD~PppV!E8>8`p{L?F*xG^KfJe4S(M^T12v1MXfL1lYZ*@&p`z|!xA)ekbS8p z?9dsJga@o))EAy&^zHrjC;U{%wDp`s8{GQy2(!BD`MBu`YvRtCpLF*>v)K4J`Vbpr z;$YaAh|tiXa^Bx}OSqltybIh2G4rYS;7X~J@Rtxy^%cMkI)Tl1BPonyEVRMOq0 zX$oE=$18fnkLS(H6)+3L<1zg_$S(RhiNkK0P#rg(vP?z(SW;!L`mHarT-sb*pal+$ z?YW$-h7tlBU>uAUugPItu2Y~H;eK6Kf`JfOn;MT0WRO=U-td*@7y?UiYN?(2r3Jow z_MYJ^TDSXa!&S<2{ApvqgAY#)i>@b}CIR|?d3U0qNkrWJnNF zun+2ZqxIqmuPEYBwjwbT)d3C!$HWnj~fr&T5tMtBUc_-G{S@4?O9gb8EdYa z-nO>35b8i5H!dQYC4kPsQ6aRhCVWw zxSx?i;R^_fASzXpK}-gzh)PNDjxwO?ZZxU6Bd5|SQNmVQgSfd$PF*u+}&vk;xG6~u2y{Q5G}`-WluV93{3&Q>HM}w zSg69meSF%e*gl@ykRO>_vN03Cl0A+O3RGoPHk zJsf$z2#`)iuYb0xO3TPFwXg_=(5UY`ZeM(c|8*vAVTePT)c@3r_~VJxCs?eCGX3uM%x>anw8J!9&B)I5Eo_pQ&xmabn<5Xz`j=?%QkG<+^L-w7dCM!Tcu%IB$|>Qdf=&|R1+ip05% zEwb(=8`X5Tq=56ZVgXAEa&vp%!5MjMmB;g&mIK{YjRisZ2nf75UQEJ>grJ*XwRjA`CpwdV%V{bPJ+S;{Ykm-mFGDHn(5?NP$p$GDoA7mHWXdR)P%e}V!VIsI)y-|CkJBmEpk?ay zPW(are~e^>WYJ#(m9F32VZ(xu&>_n11-Z(22o86l1gB%MT?ASM>oZi5 zX+v_h`cumKpw*jh63r4A%d-7%YCL}em$3HmWs7S}2!rpsbHu=<@6K@tFQvdG`h1KUp>>6O8!`8K) zdc14V%I;@>ozhG_)u9oViGUpef;`c9(B=FcwEvN*3O?>ppxB0EVsO-}F@B$OyL}IF zJI<4Fe;I$#V@g(z%g^{yIuF8PHuqR$%<*{C5pMMrVex(OUdX{`Z~q$z+rRw4O~>tl zGWFBg;0GJ=-yiz#`vSfaZ>>{m!*D_LhYvG-P;|WFJ>x6{*Z%dr%$OJ3^mQHd)F{~E{TYIb`5aHsK~zV|oVdk>TaZq|iFAKib}UHeQ!RFOq}HW})QE#CtXPgt8u$FWSR z(z3EBqB*N9B8<~R{3>8k;96u~MwdG6s=jP6Ng@GN@G|4w;&fY7?uMs2Xi=o-;`*ON zLBr)rh2w(icGiB@NM&@hfIfGvhDui3J9vYSeag4@UyKT27XWRIDkPs~lkkWb}zG$9`nVE@Wm^~BO>C31T#B8Q+RTS#4?_t2Z z;q^ka>3Q~DRTo`m1`UWjB^Ii@gvrZLE+t84NQEgTSE}c(FDt^ZH7Ik4OUj-H$S=>mHsWmEIRa_#A$sHR4VxM;N8z+A`YLtu)VJ%gql>OT&lI_8qaFHZ1boo`$Ng{#APgxo&vle%&|Ru&H75(bKm!BBKoA;NAVL z6o_~C0}*0iNhsozlS{u#b(#H|$2vpv$2)r6sU8mual;}3s|IT+WK>jdCfhIK_uW~^ zkpOxuTSY2S*GQ)7OBODwD;KOAo2Kx;Rq<>*V7V# zqG!koCKfXuM6}I_B9T_*fEscQzl^1gc{am{PdK!ai?_pdQRRsEu!4!?im)YYGXyrQ1)I>ux4 ze-purc(_uEaj2zINOX*0c_MlQ6v`Y+W-}c4WasBGy~6+ z`SIMs`}hvBkO~yWzAINzzh(lhyw-ZqhD6_qM5V%iQdND_JPJvo-MUkp9J1KE!L0Q% zh!7@K8KN6vIZ>(Mr>?G6=Pdd`aciT6xEUAODR*p8Q2BN7)!=>gs7LqSm+RPh)1HD7 zYG_R_YMH{HipR)wI!1q)ky}|25Vd=;@hUt6IXV-37HF*JdO!p!0TWToIUf6T22WQJ zj0Uaag6$YHZeo1kl zXjEtN0DJxjl+2#t^mDGr0#b%<_=)Nf;fA!BIJM(SwT0#*N##|9d8Qz*G;W(Jl*%uM z4Fe8M%m`H6TC=uUqmOr?Kegm6!Fy>tGdmg!%}uPmQGEc>BuWO^Q$0V&E~Uf1fr!_` zyBo$k_UZvHC@>?v$|>j5*S-gK9U9qLB1_mPkm`C#6R3tsdWn!E3DS19aN)1IIvcXz zVESD*q1D#BOv^&iNXdm;KGInpAzNd@ZO>n$O9M2DRUC`)DP%7XniIAZyh)`#mFa5K z2}3U#6^m_?ofIyD26hFB`O8+1HcAd*C$znB%Xr>@>t>EjU!t`a(fP@l+Jvvb#Bbw6 zf!?zRCn9ffA+E&#mRl{u0`t`>I5g}53H-&fY3o(mOp~#ks+u-n6fITNPRRn6(njQk z2f0JhhR=jrKiUZ4T6wN!cua?9Q38#pvh}|;uUeILaDcFCYv=!cKxkWgL8P6c$^U#= zQnuM~ZUEsGJB;AY@ly}lX7<793$&3se{Jwe6mK7yHe;0|6*RQC9!lF18s zqHa57>Ok6@bw3!O#Rq!7ecrErY3cade6ydP*7uHn2~`EAX-3T+aMa~PTG;m_8&CIdynYFMK`NOd z^?eog*`|CP8=C7+uZhmVeOR(()n&hvO8y{ly3L#-gagun1J_pc< zuzubl{6kZ;i|E5WW3a#P0=Kqm_OW}UEW%Nos8@#mbq%HH75wT-M+MCM zYsKk>LM}=_mM5VQO$v!bsQl5@Ew$pxyGwihIselEjOLTK%9bvuh@u|){%muM)b~uu zifR06>OF#mRnK7eI?3s0v9Xj@EiyWPNSuR_?1*MXf zcN~#e$e>3XqNPrjPx<}Vn(L`*^L2`koeO)88S{kbqU(ml_wnKb+CIytB7M=cpDjss zqpo#r|XC|>{8@l&bdxJ5u0aSCH`9GPw?zE{U$`7AI5x~7k*$;S_yE5X{jcDhfPGJ#tH~_5zp^KtT%E#S zeex-rSWClOJfQ=9BcA0(5-7t~JY1XCw)YbGBcE2BVe=-xAQTFSQ5TGghuZc@Qcg`a z)KmdeKJezWG0rM+L7Pe({Q|9~JQBvMv1E@!Rqp4&-?sr~jkGchS$sec6bwB&3%+bH z`i72DFnfNyzqU3OS&+DmuS$6Cg9fO8vQ)O9kXn_Xhze9bdahy}rMa@ns7U5N{Yj2o z#gxZ^OkYD|T|Bb9u*I+G z2#JbUf?vJE)#X3wttk`oBo6=?5Y!_#9G)$ZzJhLD>ayBY9%= z(Tq@odte@*M&F}UViaZT+Eg}`%0fTWx30O7=XPjG#wM>`y~m&r@}9^TT2;}7_h})z z7+EGk=5AP05P@4fEgV2Oj>-mGvL3%b$e*JMK(8`BLrzQp_vSC=JM7R82(9T;X;~Zc z?VIA8;oo@?c^A%_#8UEl=6D@gHQb*=Gc^7X>&GeiN=y2DxLlN)yOhrAm7f!~#@5p->)2PcuVwPJCT#YBo|QQ|azrhkES zK8TB=re-oGSZu2h%RMb~g9?y=6lpZkC$vZZv_LW~tcBxR5t3v? z>9Rn3F=E+B^>E%--!(E(n1cpcYkN5|s@iB}5czy+v?{DthiFp+(wpkcs$jB38k858 z{4dQJ(u}QQEzLl|FvmQ83UO>^*5}KIQR6B111!^51%o5esw&Q0YO_RjtXkI(C@t=V zw37y%rTSl($!Qi*Np>k5TGd8bQea{`(FWbUNB;4;xSM4g2=i%BjK_k-@rH7FN+h3Pum41tGH@rL>eGMIQOIe_!%8k* zu-W|4;)H(E6ykcTt+knf9da%56U1Z#6i>I<(~&kt5_xg_hDsAi7M?$fYJiO0mBQ4h zBjLSK!^K%?Z!z3P{yDuWlroM|j?6`X`HKgN2jX3eLZX#N013z{zEF{fA^0g4GP30T z_-Fa&#jC2#;jJeRHIeSskiMRF_eDEs zqrUW_xd`-OBpX&HgCtz*bqi@R3MJ#VC`~AXp~{iC*4moS9fC9Ow?aBOrdl;}CBuGc zqyGRPH6O2W?2U{k9O!yh*?TKpoeqfXZp=PhkErP$inR1xMTG~9U&k*M@Y3*h@EtUN zEQ)L=*^?Ss`ZFF~{e?zzxL?yJA|f%aGWT>!K=a-TczrDq?zKt8cr{AtpQu~IZZgoSds{Tsf7e1rmsS>?aY!-0GKuHu%Yh(@Kex93pH%K1Q8zdB*R zt$~q^d~#tWLnU~|~7uCqt?-Qe<#3oB+ zZ_rK>{~RcKf<8uES)4ai!k$gIh~{>-<809BB6&{9Z}2G-t*Lp*I1m$)DaC8-suPHz z_I*b@{1VgDnsjl7`EyvOx9|EDI+QacUiEF!ALHTA1*J(xz+u(v&!#Gg5QzV0jm-+_ zBxsD<>mj6@6B4`dCdz12u+Nv=MUeqJAB=$r(<1fi$Z|40=79%hb5=0eOJr-11WP5~ ziAMxP(*xDZP^h}>ftqTG7>OMH+l`qUAn|gl)dJ!so{L@WNxWp-7WU->haZ6zaOyXh zU=%qw%|-S}Tgumz?spa8AA{^54I-kA0h%TfF&w4ZkBNg8;f!5WwGF)rw{6e%Q+>u( z*8}0nO{eU}C$+1!f2U$YHB*y3_m3Q-~}!?;qAzQxx`*Ap?Z{db*7u4HSSNLfC?k;`i^fQ{wFUywf-pmlLI`7#d*~?+OwwP{v>c88R_( zxRex|`JPlH+z+NOiErLSl5J~7L-9k97EX4O%#~Y&Fm}Ipi@GXFA>D55)wGHmk}efi zv>5SPsu4<7c=gnhRlxwRL{Wv{94DUTa-vlFCi;c$qwP$-oxpwZ)}P7i=xIrOd&>}f zxTg9|goR~5<`tS?g^+qfvMs0zgww&Hwv-v5-FxHV7Q3V`{RIhAb|0<|k?jbDX{_Az zJdXY3eT?xs*tyn~NF!Co9eHZ4ElAL zqRV??1?N4v&mjtt(hhqFJ$FWKJB$JaUj9!DAZu=OEhqyf#tBNnj@W++D%h0AL;X71 zQ9SykxXG2v?p z*51CZvz5R+Wjr zcu^#w`%F#G*)nWa7^9};{qrVpu?&*PY8&2|%sHa1i_bywMd_BB30X-vm~E-_nD=6N zZ4D0K-#F3c!Y1^`JS5QYKp$Zxl=66CyW$I9w z{yZC*jV;+H$Fc24JqdN`$rTTh$_m1Lw5LF@e-Sfi(+3VEC<%{K987VL+?E~3cNQR; zf8Y7LvgAx@c3I~!&~SOWDF~NV(-zNqt&A_Bf<=ZUrL%1-3$?bS{cq#td=MnBznJJA zEf-(p!x~V_H54MFjR8d$&i?4?Er?3;chuaKN>!thSeoTm2ThCBo*Z@fmd{bB%8O=B zoGDf?oqASP_1BenmG*e$lCtV-&5{lw&>kDQ`m`h~f1^4BnG9i`}KS>K?Useg8>2P%(A!4{~T1W0#XeA zMOAoybCUm_u7R?tC~n6WaeGQi?C|jO_^iLHR=Jvf5(-6V!mrZ2f9l8vYCBB%%>~cmv&R|Al zpkvs=AthiQ2(IVHZz78$A5egSmkAyPb^IPK%uClUzr(6#iPxDrmhc{B)INC8yzIFO zRkKEO_Z^7(nL`7IW@M0^An2G({N@-aXa;r|&+-1({u=W!c5!_vM7o{h{l18Y7K~5^ z;_9d9|CU8bp`cob1Z;;IIo}}ZehBgH;V^swDQkTS{KIsXC9Pr|h>}%YSy@@*d-Ln) zij5!WbIW!W)z)x(a`<3>EOXKCRj_Ou&5>-7Uc*PiMuN6#;8cs1$5a?<6CcscaB1wQ zEj#kOLcqP?8S!q9+yxM8m^a+*x$4Uy6P>8-zT>DtFt!4T`11$F_>n-33YHu`^tzYV z<#Pu!5-Mk;mow9iBE>n6DyLq8zo^Qoo1OWSb+oid;9``LuXN%Z2cxrP69z=K-i10i zcvDCX=Ih83LlcTqEHUQ5W@LpTN#`y^4l;;xXz&!;eU09%l{xCux7N4l-%j;0n%aF%^Qw;R$RrN0voR8q3Y zSEle%4z?_$L@E=Jj6ZHf*kA4^>C>OEE|_Mb2#L>xNVX(z2PgEn#Wdp-nSo{Wnm%)m zF+lnH=Q8`?GVcK*cP@T{y4pi=Yor@b>Mr{rY9mtGTwrTmHTnPGQQP zL6(ytm$6LNzXiRG45%g?7I zWpC|%T!{?X;eHzsmU(hr*7+b}@p_@}eiQKuvSHsVWAO?UOCIE>aX_b{lw+u)9LG{6 zzx7&lo{(qxh~4~H?4Dw%?vBO+NDIOs!6fw$z?kHjC@00z76I!?hGyw*o`{ktBRs;I z5)s40B6%3=3p7!X6seBHJ?z+Wb}RF8ifyZ^*^eJo_`@0l!W%UZrmh2}oT6;NVS_8h zfsp8z-QCDM<&QRQ)-kD*j0c74zvSw9Pp#j=(|to$Z3Tx+s^+tWYnj!yJIZV%R1y&| zaJ#;Lsf(-+k-M(*r$0S$g@)YkV30FXoF`E4WUM2C?MfF5Q1{H5X8x^T>?NaTMyVE zs)R>bDz`Luzsb`RB?vG$SEcm`Wht@^#;&!+&;7qvhUa#nblblM)aLz-6EUdpJ zIQ_-#m7Hi>@{P_U=qu^;E4q($bhIJLyX1!&=|MJ(&Ha4qj5OD`W$eEwM*RDB|gEJ zu%1yFHFfhS^2T^{#I?49;eH%DLgIUW@WJx2`ffMCX zUpp=NU~;G5rAtK7!>SWeIwLB4yW__MNv<6(Pro8~oQ~xj9-avv&TJ{7`sG`=g?5T6 zQh=zak6WVzF)^CjW9$ub=#9S!G`~yR$NpHxrlr({3~$*Ezp_o-GAp5kk9?-?9~<9DC( zG86c(`FRIDc};o=TSDTRhDa)((1I5H8gDP|!AhY`mv-M}qoB|=9hB6eg_{^c|ItLE z#fk6eW6Pw52DQ}g1zQJHR1Rq6LD0enhN2aLO1{SlYrdO8Ypzr4uctJ^y#o+q_`Pd4 z1iE~ZvDV@Uy*{Q4QrUymGN4;(&*WHH$o%*Vx7?I}xERSJBY5qUV{vyyV_Y-F*eTch zrRyP!;r0IGm5aGk<+7&}?eZw+jk4c>^Z+IA4itB2P&3AdyHne_yV3}LePQv5yYTt& z9N*_tWwC%^TKp=G@ZA5IU!k;$Y6>~fQFc8Nh+*_yFEl1;WX2C2{Un`LuJ~vSG1iTx z^d$YsE7~>MC%vwX-9qqih&9||={s4gI8tHw)RB~~eB;$hZ87l|_}iJEd6%3NiXib_ zMca~y&nODrTJ^HtCwhf&%o|N)8dn#8q`+v-#5R&Zw-|FBxEC{h2qyW4T?V&}Lc*;t zR)dsMm~gi~qc>L^p+lWaN^cWw#;5}2k(Cgh)VoF;P&72xq~K6r3|H2RT!ETxfV>gk+!B!GBdYZb9gK}(BomfAAT!K9t>7!(iF^cz+g z7Gn61L+vW6d__LrbHM%m@2h>Yl-8_}jgoKZ7Q8g_xZTtMbH{jO?Qk#(Y1hB8s#wem z+ckI?hMZWvPM0r9sIs%7)Dd3cRY>O|9|&?Zr>C~{UHm2=mv|8|PLYZR4juO5Bv3Nt zSur@g`5m^ntK_0hla{3O1-gor4p_0SWE85P+OFEkjSUj5-v-8<1aZYj#1B%d|8>d> z8BW+eFX0kK`322IyjytJYz4ccle0jo^MyE+<_+IoOHigVPdc@M?@ZKJBA!37`TJpZ z&1l?5ruO>ngGncgPsfX0gI^(rode%(+{Yex;hqqYh7tH|uXw|ke=L_;Q$7(aZ$}X5 z#ubwX1Kl72Bpv5Md@_os+Tmx}&hZ<5j>mC-=G&>-p&CIcuxf7tx8(Jr`|Znym-i?c z;q^)PJ?uH3E9&<5LkV1hEOP*B-%6=1klCPZ{Ni=;!r^FUpwwgiw_76s3kq^)n9NHx zt3dcoNhr}S?oy+DOZ`Oc%)CIh5%QkXFnZ5im&ow4?aVbQE|cyyU)~p zwbs=ph?>?JtrLgVz~5;ogH~a_X8pxQT$H8o8>rr&=5m0jRFgN5YJ0)tY+mXercQuf z1!JjyDIN@E;Mbf77!MN5QS?_uYwIax-$85x5}e1SZYa1 zo|}arr?Pba_b1+l-tD)x@P?dx^}{&2D06$&A7}e8^8V_vaSrEm+_?Almy5W}H@)=_ z?0AKOAA`DklWOGd*1j<@YmExNoIMYifr{wnQdzS5cpW%PbtXQ$sb}vv%ehnYBU~1D zMD|2FN@|)-?#SCR0&8PA%ELHA2lo^UnGdKjF`scKd6_$(=*8jrnwjO{Is+l|&qH&8 zLeR}t09x%wm8EHq1n)U$6BC0DnhvRbYV-a%O5$!IGkKNcL(xm3V}kAVNCG?of#laO zM;`r@%RUe}Q#k(nUjbrFT>j0#uD4$<3gpU7>e?mG1$WgZFt8~~6jKTOmk z|2vWMPcu>1A1nDG!pYbx!ah{zrlq(%vRvi64I~$2G`{Wk6*+o=wQ#??+t#ZD1T+0U zd~-$9+b$k#cO%>d9qN>G$xJIY0i;es!uTbOauqK=2pkeiie)3(OeHAVBbQs{?=a-# zm!njL1l6G<*`F|(8*J%!7)gey90f9-WYK0T{ZV_~KmSq?^9G!xD2$2!8Hq=EORj?w z>>rf`0AgYaTewfm6T+Ll&0-bzxl8;bPAI@v+Hgv*8q&mjknuWcTwKZ`PB=`Il(kDu z*P>A)xs|}Yn8r^uosjJ9sQe6E!PQ%9A5Du=Lm8wi(OPIxaSLBlPB!WUo0bGw5iqXL z1pVxNw=W@Yc%P96-N2gD? zLzdYyJr0+zpn<_Y+Bi+WtbGL2_2xQjSSVP!>Ji+>7b||GU+3~I%!~{ z=`B<+p3E=3cbwLt4{}UKw%6M-d^h}vcRHB7ii`0|l_B*GgnVC5$9N~Ad2Ioi^;&v( za^7%Qx?d%J8+4Ce{S?>1@j9qxzTWJ9^}USfzWprxlJ?@Z&yuq{1)*>~WVPqeka#D? zh}`|G@sQF@OGHvW$v@mDI1d&bGE>;4Nj8Ek?G_a(i>ywSUhX#+4-VDOyYqRgRqGW(lKeGln z`NYNq$nLvl=~dXS{kI)L(W5&cX*kCk;pO?2HmGP4$61s9?Xn|-uGnD5(1<7bq02z_ zpJO9m5vO;O`nmc1%~iD{*ti3!QwhLKHyyc6!7+k&oZZ(9-J_$A>uDK}zhm=^;fAE} zK(UnS}{IQZ&|0Z-OyjP+-k|^nZ3F6F-<)%ekadt~Gg2JQIKD#SACIYw z6c)#$QC-0sT;CB2G?7355d(K)ga!*@g!`Z&?n;P1!+m=I*Zp6kR_a7aX7`0~q_dva z8F}~3U<6*u^;6D=If?tF;OZ)byJ(=ToB}Wb4cEk;cO3KuEk4dd)^#j`AA%Y>K~lF% zx?QK}Adhy&W@%2V7t>7plPFO=K`9-TMYuqjKO!0$fTF_93zlpO%sfFfA@P83^<6WT zf0dNw;IF@eb9KL>tUfCQvN58rq-zYklv}}~n8~UpQ5AE4r}eK*CT9_^k<7=B3O2J| zpf`%Tk>QNkyYl_6?^dDOz}qe!qv<5gA5(Uc`%6dO8WPIagD0WCDEL+zb4B{L@7tHg zAuzuD5oh_J2CglyDn5d7+v1 zBDFs!jg-C?FJZO>I0}2)brQeh)+%cd(CwdJ$=Vo(=$L1O(>Hq&}5Mr5z# zmR~jA>fmUliAr$S7l4gZ@?@)w?C_-ClSIwFsy3=!d&ybMQSvpPdfeNvu^HcO4-ALHM#(Uem99MvbRsq(y$ zH=-+;G5=DpzbZJ?hS~91o5eB9cvg0}GUX9POG6Tr*fS=sWF1f$whk|2cXuTql4?0O z67R>);RU8PjPB-Tl~Dnfu;RRh+Lf#bEM=VsEsSNAMRn2Yy4*vi&#Gjsu}FfbnUXC7 zu>BbDF`uuqOwJ*Dlf%Dx{lq~*br>JZzyIcF-(&sxGvD0YF!Jw3=Eq;oex9-}2m&aP zwoG=WP(QZGF*;TeQ*+StS!d9U|4Uezg)0q9*p6BL=u%%MY zcC8G_{!xrqpp)zRKpKQ$xg;YpYAZ}Ni)4x-^=>>`PI+>NA2rlVvQMNMG_bkFt}2Fq zoo(-XAmDW*Z@4p>RFP+wxRb13zcyCi(2u}fYazn>>BLHqP7V^kx0D)hVe3Feho1#kW)Up|IxER-OKpxCzKqUdVq-6&n8BRYGBOf~cu(K*J6MS#dz`5^uM>-L!?L4R z!3Dh0{*@9qY9$yx#QwU$pSlO@35m|M%^{zThoG9d7ea`pER2_Quzxc}F(Uh5s9B35 zqk~vS-$L=gT3<7Tcob6I zQnNzOuR;|Iab>YHMt2p)*7y~mfK}E`rVN)&I@$#r%a4v56c2nta0SZCTW&cWc7CV1 z#Lqr)?@~u8T_>(`eYNUfXYZJPvP39&o#dH|I};(o;6?6a9$eh!jFoD7r2G2^zD{qX z`MKT6AznLQ6JO2+nuC62{fm@IF47ZAs$IdUzY9B&dF9~IIuq~j2_L5-A1sf{IWK%f z7*q!2_)=>~Q%xV);B|c^!#b%3czl*;;gH2- zuM(vjT`}sQibD!9;;)WnMjyH=mC*s6EVFu>WbiM5j}? z+*j4LpfiVMoxLPpNnoEdujI(lE-Z2bJ?+_YrX+smC#X-}3>J;q+UHn!dM5ZJ*E)HG z?CePO#NJ|#mPgZTTvB-EvuNrD-bAtw99tz>s{|m%*Qt}E63?ngRa$e8_nS2QjoD5) z|9^+`hP<+z)8ew{(#mq~TeboHAkOzs6DF6dA~7wE{x|k&M~w5m3PSUgkw7|NJPd%c zk&S4Iy5n}GB2i;f;$d@)M);Li>0`Xa{cT4I0@8X9U1ls1k1YhM^Fy&&Ck9JD@$w7r zRCnDlZa&}F3pzmZo~~}XdjimeB+I|f*#1)F2rrj3I-;^JmH3JIMIbsOB;@t{;+?_g zGJrJjyWRd5j3m0dU8-hgRTt=|KLd#%>}Q|r{M^dEzdG15JqUTS@xlu$+<8-cK#h4e z+K~h*M8XrW9|B#}0zEUgfI}^dfd{&=Shq?^^2s>$ks|p@tLg@SrIVRXPUT{MYfbFt z#RFgFHyi-G3Ypcgx`xJFu{7mKzNKKLY7Sn<%4vcwGA&?U=syGr%Ll+7n%z=jG_2g>eUW|#k_9rG`(APwj`N^|S5R}Z z9JZS_{4U*&!s@4aJL`hwC_&+}A^M?TT)8Vd4qL>xiH6D4b`k$S_TDMFvTlhV?M^2h z+tv;{9ox3;bZpxl+qP}(*tTuk_RaU5bMF5>-!bmneOzPix#rljs#fV&RosW2ELxZU z;m`{z@|)WZgL)Y!)B(^24(D%j&>gj4C?^P9#T@XZil#xo?t|wLGkb=QR2!H+| zVQe+kvkFH*h@QSBYz1RONy;8-+;Msgn#cR-XJSSM!<+Nxxb^kHe%aR~pHa=t*6wYC zz&Sox$gs3+*NR&@ZuYh`l}(ojmCs4&bS~$}D6V^yD9$@t4UN@&QyOym8Z_w8!2N$l z1cvFn5utCm_!Y{u*d_*?Z9YY+k1n5ws;w#Ty%QiYLlRQ)%c==zDSb03pmpqTBbOBi zhDJy3jky<>#uCAE&9^h^x)W3Ki-Ya>L3oPhiggfgkggCC!EPpO=(P)Fuj0}29o@#r z`^4V;^o(Wfck{DNoS&y_eRWq%=w}bIJg{R%<2`HwwvH|{7@M>-{gx_DPz5D#8bCsy ziN|J%iAwBIW(#|)vXJuT+?&P!#Ob`o{tUl<`FYC;-{a2|5A3>w8t|JXzs4gLfMx!2 ziV53VPB9Iud0yQ?fAuB&EI^r9cB%edSeQT~RCfKhrqb{kDS|){o_|O#2|_V8fWPIM znKD3R%O>8CPfZyDQ5tlc1VSdUkeq@T6Uw6PTGUsh&&UJ+aG4SFwZoFpBAKlM^w?0! zn!4%Z1vNC+XoF#H=I23`!|IaCN@#*b*Tf4ckp!K3Z7dwZMjWM3E~6S+EOYuJN`p}7 z6uLrc>I_t5SZv<#7o0`3YBMj%v<+3U@aOmT?!Org3IIcRo!`SJ*FDG|aJHqBt6>z} z;uXBwdzu{{DS3IsKYQuE?Efz?b6`7OK(m;YpAO0;xow;6HI&Bc>YC#VRbB$>&tC4Y z*l&C&0Ff|P18IjmLD6dl7pNDAh^ zeCmbtHJ}LJ;<|bAo#@tdqA}~4yVZLA4|B>O$5aamfme|TKf;iYwdGgx&_=;2tSNhq zJL=Kpd&;P6L;j*fjTA_AtYuG%ZQ%GgERdN+Ov%?FFrS4NVsvA}@!`?By4^mK=52P; z&eJ=}ycN9dX2tyM@)C?A8A=yAG~i}xPIsbr{&ewa*ZbA_Y2bjxz2p9@@#%zNvbxp%M*`{ehDf>$=4OUGfUX&XW+nBe56fmvSBeU#xuUXw(dJkz zm?u;$`ol+@4B`=W;>A~iOibt-P z`3ZF>pu^6b$&Qo{{k}XANI*@7ln+(nG{Ls8D1A-yQRdw}$n(LVs3fJPlA|)LtY{TE zYE*6o!&>JCFWzxGw~y}+Ljif%NWx-FTa_pn`;{Ahg@*LMW4+{r3k#k7TQH+)ZM(74 zE>uE0S}1p&h}rJUO!=J~sidFL@D!)cBQnfSV>Jma79f?BdLk%E6qewPOecB;d^utQ zTR}$tZiyG>%xXyy$`&Mo#N<$34nOSfdlCvcQ>!Y-sBXS|2G3dtoM@!c?854$@j8M; zDw%?-1>}&6&rs!6jyB=aVi{pz8=O!{VMd93jbK?BN!BhsD)3Yu_~9QbX+&b&$imv8 zO!o`DjGNzIk@>Q>lwZJ)2v%(<$CiWwfoRfze*YfY`syWttA1h4*(fgPt6<^71y!F$ z0mbnbjr(@9tHW5rXp$;!#6K?ki+*I^_iTcY!NI0Kv2jqk0?2=seqIeI%#mz~)&U0i z0w1##eVv`IGxPJ+B5kiRoLXf66E_<4*QVcko6vtduzqma5sMH)M#Mnni<`d7jMLgMSldVrxOE^BebEQLJ6|oCF6M_ z&)VSZ|4R2Pwb~NT38}9aiZ*a@c$o_5(xQ2D8R(!63TY<>EGI0GCLfX^|qE7MsB{i0WN%42OpSkkN|z$krxc zOm~Z5qvUMOqky`n0~q~KT|<)iD2P@{;%5xn`P$I@QCKc<8Z{|Fte)Gbh=@H6_O=_` z1-c*Bi`33ZhN!v$P+tb`ukc$4Li8*dLQDXK`mcu~1xA7fA_;kUKtRJ->6AfXJX{&h zMlCa5tcj5J+?X+{S}J|o0mL8Ag2@pRUfgqIaq^#P!ZB<{J^qW4=>D`>rWA#oUfD7O zV$A#%gYG`}y1?n_ww`6*TB@1`!^1PRlNEV1CefYH7~>1`%JX#t{YR|F4SRfZ^R%_K zc0MKSHd(@t70hxNNZ%gl84Ta)p*d{|GyQKtu@sas+yEguAs-^lgiqKYrfz%l2a zpMMOBeGsbapsde&Z&h%rO_fJ3Q9We+fGf+v1Iesbl)I=Ex?)iNu0|?B}lha zo50XF5$f;<-Ob;IKkX1;bbqeL%CPiLrs7CBMI(B167rJ_DoCgeCi>6Ayb*0V(lT=& zyt&I={K>n8LW4`}kfwVn$qOLGqrp$Pl)-k$!CWAPyR>b`vWuQ8yl-R>;I!LoM!UP| zG){lv9N1Ul;Rz-P{AnkX&`mZQY3YLK?VgU;j;*d^>rsS!w6c^}m&jl(U6E5%&~Ej> zRWreH3pwh)Lq^P8Y@W)Sy+e9-Nqdz0eT#R@)y^2^sT@1QN*b`;P}aJ~Yl=JIP76ZF zB@RjX=km|U#`q6q6&6*kRRcymI~$L1Wk@K#^Iw#5KGzi^q~CLtB$H?9ET;y&09Qb{ z6_lP)RzIjzlnf1qmw&RkUkM9u$tn4~PoQ3zK+q$h7iCtcB4lQZ$W8BQrnPo;{7*c# zcNPi34X|3|Gb=m_0OfeJIG6^Su33%ERsj?t_;rmuMH>_A5AFoZ>Rvr&>0UKX(Ln>Z zaA!PB>{Bj+0MU!xO&kk5GizI|LuY>M@WQiMSM-Em255 zlZ>>)-*fY{01#401v}84U#q#vLv(K3l*_+`7`Xsst)hgBDmpvAq{o28sH$S1fC|4Q z&$%-7rDGCz^MDz<0x_O$g%(u}LI}3op=WIFpNKa!#a=)a8J$2<$EBRWpA^|bD{1sq&PC{Nkcplz z2LGFj-3fIA4Ion8*B+6_O3xqA2uHzNX7o4p+bLbct_i&WnJMc*jLi-|iore(_$+2w z9Igx*l=c;9NH~*(^!|rGISq#*vn2JaIIU zF)lNl*y(=^{IAQr`sk8TqDcVxnewLsUIm_OmY??G{pgjWvAT~?aHtAAK9)|Xui=OC zbp#TE@~cv+KPlt)4PPeGLN|ZjKw&NN)6i0?o^vUfp9I$i<8$jvR2T)(Bw;u)Fador z$_Swm4&sz3^mhz|2uQ-a-0h0Bm2T-dBFqd1_7ci$k!=QZ*s^npu39(aD%#uE8MEoj z>W3Otof8=S3NqXSE7-(NWFn#^n8Yq;cN7~_FuVH5NkKX|Va#*PP1m?)t z=ae#rWkRu8-;R4})ptQ>a}5&F*Ep9BEA1a?aUyMRAtx|+a~pnIq|=ZPJzm>hC`zKm z6XAFt?sC%2XX5k0#`CS;5awKnAYT6`p!83I@{`q8Bw2(d(6_hwu)sW$4@wEPu>j|_ zkZ?0c(bpbM-x5XNm&q(9aa%)vCvOFiA8Gc@1)T`FVF3f3%7s5*>GZiAW_n#u*Ex&@(PB2x zKrQME=~%{Dq{$zvk$yi`6uEA`*tBi`fFxr@RmVA)l4_8={hBT+++49-TT_G>C$O`j zDvdHN{?!0WOvuE`&L>LmTe(Is`_qsqXAk5}n}IeK=^)!}1KVoRrS41b;a3jDxJwM4 z(g9|<$uqWKkC$S%Fv!Q)1@ScEsgGe(9e}{7-nUJrti|^n6{Y zbh}$2)}4h=$-0xjle{0jw<;YzL~kL$fC07cu(zw|Pm(-4A7w<80Pw~mvc^%C9W;!u z0+gPSjoo6@od9KGVP=#*Rj-NttjgWwDYATYy0Nj^QM-+)W1jL z!8m9wS!#KCqeluhiCS}aU^?DZJKJn-HkPaTa>4{bS25xIjejOwh! z3oCN$O}w<|ENI3F&|9J;8jGyJ?A$#wy63QM5ThuH13K|9D1yF< ze@>xJ0o()DDutv~P|_v@{JymYeqI*U&gc1m7W?Q1p*jimCfNMdmm035Xu_=V$w=a# zak#z=*Yw?dBTsu+9-0(15^mIVjni2f1?^^!F5VN4((p{?T+?Qn5|{wS)s!y7jcE5ig2vufKujPGjU+F#;zaR@%D=10UbhOShE zJO%$>MOzb#GzA$64|Qe%j6_t$Y+od%Repp9o+C+#zz99rZt5V9+NW4SX zjZtN-v!1Km(n3S2OaC>iIXn;|Uk9NFaV_v#^LhM9TFLsREjR=gEaB z8i*Mx>4k@cW*OhkQB>-5BHfcUVx;~SOn(IJX+fAnfRw|C#(quyrm;H3k&j9QXMMZC zMC|-u`{#=p+oEhlVspHpj2A%{Be`agA`iaGAG8+vq-6=&HGqNu<_Tmn$VO1HzP%=> z3Z(q0^Y?aij8k6n{6~z-;aj#IXaq{qNU#6_GG9gs5M%`U!ZNS~2tkgNC3pNo)c$-n zbT)tRU9N>4Q5PSy zR5=|6EF%EqoNM>~GRi*K>pKOuAKjpmw6+R467{&e)y1W~r!~4cj#_RBvRI0^k>P{^ zy*_glol=Ol%$9@bsQJg!gE0h`joiK&O6>skp=P=$&ZaFvAs@voe{SE6e_@jh7HZLQ z)Pz2zUrFgz>O{=L3yjKQQ*&dGBOC?lLMrog)mKYRGQuBpIhC%2_zFKrXh$qNc>);NuYoY!y=%4{*t*9^1l6)22);x7+%) z{bjEziHgLCC6XE+!xm52LcyS*g-ZWcK@(^CcP;vt}wP#`)Ie*}H%)F#S*x@KzQGz2Yvc7t%WdL9AH-zRt6ugYPlN%!5$$c4?fV z859TTyxG7}>a%gC+ud&crBX6@Cp2ZwC*KHNMF@$5Xo(D-J|NVkE*yo#gov$Sy+j<@ zZ3k0S49m@sGgGuq@S-_Bv-?lp@k@d)k=J4jAV3JQjC>Hd9J3BKADyQB9NiRIjjt!N z0j$_B!Rbt*n9w?ezDjUW;tqUYfIMcRZ=9&fQx)f>C_Hgj<2qTOc$Byn%gxxg@X-)YP%-TTw1vq-8 zbpD7-B#I6E;zFVtK|x`XBxQ1EIlx&9t#pDQoHoUp0G}VM;u$F!mn(vI{MW1bN2+CP24iy!Ic=qH zwge8F**}#g&OWj0i)BLw+z{Oq@oZHumu!pJ(l!nu?1VPoD?dP;l@+=*j4?p|da5zj-c#fCGVSz$v!Od)p53)ts=dZ#b6)5Z^dJgTf6ZZ6H*9QGBbw{&XHJ zX)hfXo|=De@@PH6;%Z;4)@l(KY~-IzumbTV@f8@zU3yJNCOkTA7v{af7{uO5$KQg5 z!TPayHengMm|nF4x267vzzGDR2`v}}N0K+Xub~U!W#=F^*^y@1IRf#Q0EiDS0RjZ5 zGsO4BpLmr`?WUh&6RY?-duv6wqU*Szw)3ugSU%q)qmaNrL1DOuE?a~~o|PFuD%rAr z*?QO)dP8=3{r)?eRK=={jYHGplnLG4%_k^W3<+aX9tg_H^J3QcIAh$%v3l;!W&atZ zjr$A0$JZUXD8`|~zqQ1VcJwq5GdIX81>w2KD|e=O+$?Srtq-l{>`ddCbS~&$1_=X~ z56|KG-P1w4`Z{G=vdV7$`Js;Ypn-Cr@D+z>-ef#eGjD-`JC!U4cxuAq}I+5zGT$J=hW} zKUYS;kcHg=!&nKQan=~54^Q(tga=Wf%RCPhX#3tFTCchF`1vMT2?g*IkM3rJ-H+tQ znv&fh@Zg5f1JL@x85qN&bLL#YEImsibMy%u$0TbgmKpB%dJ_Eg5t$8T)rT2{J*}i? zN>wS+%0MzCY%i|!r!K9kM8CGCiywL_76#ApX%6Gqf`i*g;_3&{mvr2oa+NvF&fnc-WTS zzw}mHS7nPTbFMZ&;AhWyvwUVEG>(%SLW^#RaXS;{`rst}4a_!OLs%N<<#tKNjOVGI z(b1(+;p7*PWVTDsG*FrhQ`KRM<3}mxiB>t3_QQ0p{dnd z84m&Jy(|4-56coId}hvq@QDB}Nb6lr@Ol!bwOgfVOeNw4z9p1<^$DCog%VzFlMP9{ zoApJdjlLf^`L>|B!ZXlIa`wy_cKM+|4Y^I(LzE{bd6uKw8A&($>7yn_*`r9= zQ<=HfyM8#VTI=sl%KnLVqK>I8+>top>-~Xe?}xSIZiOWA`0cjhe^>xCBgFkRz)}uZ zc>3eyn}RR|Ia+ENoPB;vj6#-xMO&b(wUAL`NFZ_0Qxhz{~XJa_`xj zsP0OSVmVVJu!0a-G#n1oLbzsH**(ToXu5Q zcdhT*-|=)BkDXtsJqdUkDXTW$MMjFjA}5es_S*rwn9BjfQUE-u7Z48qc&qlJ*O5{1 zu+C!syVWU!WS`?x6li{x1UqL|Rx*dTJ-fxKH&_~Czw*~kTVy|{caHI>Ml+0*P+17! zZ+pZ|h6rT)W$RiJz-L`}bsEb-C08^Y5;I0iQBhf8QE$iY$pwk19ZU?&{**2fr?TK8 zjt?6vGy<5XeKs3Lg(85P5W$=q%jgfX^qbNAloc7lcTN7Ze?hBqaVioiX~Lg2T4pha z2^0a_2J5_=c&1?-oDyC|VR=SiPK%N#FD_W= z3l)QayrO>yDK&#|Fr&R&P|VlboL%&Ag&2f?cRC!Vy}!T?(=C>N_bT35S>G_1RZB}s z8e*%T5tQzQ&R&`HAQ1Gl6i3sf*Enr^1`!m=cr{!^pL2aJ$fk6vBb}X$#dg(5JlC*_ zfjk`otWRhH3meYZBE(R?H~AGM>(~}y-#!hHwpl4WO%7o57LhVuI)9`SOcemS~s7Y z6HCW-K*Am6K|zGorpZTU48b{RAZGIn?UIe(a0);OJpMZxCQ|S$?rqNgIC#yb%=E{83lE4z zOLH%~zk?p7Hg?u@_o?7d8+X^BIe)C!`7K4h)x0xBH@@frY;8eXWG9&Am)E4uw5EUD z`;}J-yORd{H*rfhKfyhPKwr32AO{g;RSKBL2e;(s-N-UI7FqcBvzhmKxp(IBPpjA$ zmjv~pMD$j9EbDeca4x6rG$-D2GcRJ$^MBsXvv}XnCXHEgV%Ew%>OxvV-m0-%zIEyB zf2C?zqVl$KjscOjALlNZLce#P2ZQXds|3NLA`v@nL+@fE{kl(KB||F zV+y$=eqbJcZJjpJWd}-6^>p>i{75O=QQO)i!kj)AqX1@*s7C(Fm zRiy--vGLKo`wmMs0c6Y&%`Z`$pP4>=Y;~e|VIpnElj=%6l}6BL?LHDd-&NCoQT%41 z)xDq!x|md{J5Tr>?;J=c-NL(`sfE*&em>>%>w(#+qb(uUjVsIPernM(HR`h^iTDMs zlrps$1Lv=jirBF>*Y3gE>Cxe{*~ZiT<&tr%Y*fOuO50@R0EE$arXWUkI`!^8tatv2 z9xEarDW!yyf-xLn>r@Jr=be=4nuMGJOu)s%$}=RYQo|hMa4v`w6SJzv-Q2%7 z3=ti2Qh#^;+Pxj#Bq9?o+|EdHY4^f;Jd7Gt-Ou^G2+-r|xzzdiH8N%$gZo?IwkYX& zx0^JT=a?U|rKcp%eR&o~e1k;+;&fW!WkkZl+NXF(8-~fS?X^bI=>t#>JC9SrJyDW< z4G<~D$V%nwIqdax;XifK<_5&@&}2Y-a|dtLc16~D^V=hlNN!ktnm>r54J;06S{c}Q z9GNn|X%d;==Bwh0xAyvB`Q*7*RFXZ&`|RD>bE=MwD2IeDb8#r+&LP_7%nq6JhwBbp zdreKKSB#5Ureka5i!Ls<(D;sl^wd4lLBROOC^0y;EfHyQj9(jjDpmMhI7s~%8n`5_ zrBC&j=A2JM?SK|Ae)Dl=uj^F-4{qkvYAf9R){&`*QDPd3K3x{PbDGG>6V4&dv5Iqj zp|&eCNVnXO7Nfl>@YbmZBl}MSCc8mfO3Hdh)h}iI)ufujfDDdlO`%nL`+gw=Wh2es zU}>_f^Br1b?RF-Fw{SdZ(~(8~Zl?@| z={_4ufmP`mU7WJi6h5urPt6Qp|Isi^E!=)m$IF3D4<9e0irn(d!|)dg6FYm$k1hFM zE1eewH{xjUMk2i_^p|Wz&0$eoebq9;D>9EwyHbG@$sLW-BD==zqV2{dFXos^4>(Y@ zb6doh1^&;#-)}E}dzrPVXLMD{j?P&HuY+*=4!*SiT$Bt9f&GXdynjYpWIBr(b|)n8 zfEe6myhy<6NUQMqecWQrlKB0@IyMKcNBy$B;|d*Jq!9YZe4`(lLo%O-HUZLySB7|1 zhoXn^8NZ3F+$s3-DIEI3>aa{2$9Ibh|D)RCQI6Xc7vzfbZbuy zTV?KePfFQ#BnbDVp+WzmK@)34gnQrsOMvM8Im;UVT7zdD#A?&hj_aH;Bha4$t6UkI zTsd4S0i|VEBI9Ta$ik z`g3K4#dF^XiOuSSLC&%N*xcYkH9!Q6JYUB`H*VOUpU5r@&R&ptRGFLa!{raW8 zy(#-ju+jD|RTk-Y`i9TC03>%p^Ti2U3)nH(gXKjB#?f0jO5oMNFiNIcWBiy6?{FYf zT8VW6MY4iu_cA*r^+D~~H9yj~TRbi;+vWWG*V1*~uYY73CLjIMcq^qoHv8)^4hJOt zOLH_j7;rZP793M{371>`c9+H=_ywl4q435%nI!-9O|<=ODo-d=N#&qf#+0mt4Lbxi zl~;7s$U!^tfq05eO7wl;>b~6EqVG+1XQ~2I7}pYgcSxruw%{1)4{0!FZr>ITvqKk@QR!Zz^@5jY3%2f>Wa7r6v?VH)%bVOy?{{qNg^$$3+4!SZ_$nWbgXhTJqxB4i{=n zVnM%BCFKX>g$&V$VqXJA>4jpQ8h=*Hy$){5%``?goTk$!GRS&8puL_N79Q?i1psI| zwk~AI9KxF~#TIC6`q*6CLX3H6b!!BuI`;i@!Z+L9BTHl|^wkoHflO`9sZv>nFq<9O zjPh-Hh~vbQx0;!~kFx@eHdnc*5QPtxmk&vod9)qJE_ z46^NKyctBz69!pjz<0KWKb%`C3VH-Jn5Vzgo*h0jwTg*G{V>SVFPcgF-80p`M{ zAAM3ZfV=&UdG5H^Mwi!cO~`ZzTgw#1)+NK;aB6ZP4d5w>yIE|MokI#A4ML zAg#I=O22G6V&HB*0m-+G5xjS>D?x{lKYFT8etGJD(+h+u80dE{@7VEmkG#<$gL8BY zk|E`JVk|=+VB7P4G|GI>i!?GPgk%nCpL97Xl6D8T?>D-1O5R;*a@N3>A5}Xgf1m>r z()As!etNtN8SvcC{@!`WfXSGirv8=eTzR;h!HZAJomBAaBMvN13uf6Wx8$9ExDHoL zhFiI>(DUaYwm(s=+QVgl-{f|3x^&Wor$TNyho~6XSaK}iO&ggi$K@kk`N(hj);NkterflVd(7U+E}A+VUQ%ULKqQe%g&Kwmt6az5Z~mX zB$Pk#;~_+BOw8#J6H>RSt_)VxVFe4^sGq7&O{{{(F2|i%;prO+UXOw^g*TenDJQ<) z&DbI;5)!XH9T#?XcVee6rk=K;4IOeEL&*RLk;=iv$s79>vf2HBJ22mr^FVSa*R10; zG#ru#jpLGb;#1arpY22H!SQV*{lD!qAZroY0tWv+^FpGI>7Ms=|0OYHEcSEw1AaRA zI!&K8zlq0b^)UuA@m{%Lr{j5h+a?>9SsBvo=e#=CO!cgTg(Zz+5Tz_E2g9gJoRW$n z_Ib-MDtkA>7ti)f?KL{D>Dm;1!jd%f9cN|cy>H_YmR^BgwdD)Ofm%`vSmz^#lE_lsm^i}3|H ze3Gk9ZzNbx5ama3SoVRAh(DM9vf-=Z*h-=g7g(|79T+npNgcI6xjo^z%a2U0;7OUR zZD=|hl!EBk{pvANQk{Rv8F3E#iv2+AofBEC-eA*kSUipHvvb4mcf^8Pyt8RIF_i5 zKPj$Rm{;q66Rjrs?gllBuhH-DO(4Yj6`Ryv#o#OAIGxbCR)CMd!3XPPGxkZv*tjA( zbbThG>PQ_YRm5Efg)2nV1%|xPA$Ws7hWFI|oDO!8dhYTtk+g{^PR^B+V^a~b2 zYezSfQVFFp)epRh4Kl-yXDGq;ke8C8Qr6Q}Qc>rPa<1o*f@Z+>dqu-JPlOA|<9GW)icDP;_`M6Mf zp$e07Y$a?wJH3V}wqgMLO}>W;3f+JsvScTawY_0}QNWGz#_NiBsSf^p6IgeM8?e-N zS@&|C(i{4%zdB3m)AO6FJT;pbmLlKJ2~WJ?ySpYINWaq`(F3~?$z&6{rKgU5ip7Jw z*B;GZO3vk{#Ey-`iF9+{Asndd?zM0@B@@=H*a^6{Ls&Hmg}oHr9@Gada}Rx zuE}W4%fSx8JJ@DkCKNZ0^N&42s0$}x(NVG035i**q{8lSw?v<}Ut0-XravbR%R4O8 z__;cHeM3EQ!362=p+KN^6iS9~^Kt%YnRMJx+P-%EeP?=)q5N7&-Z?)G8#R#e=!m)g z{%39>73K{+^!^xTxI9q+R?3SoSLqplQUdN`kh!Je(}_kW_xe|XK;-Ej%Gio!+e=5t zlj(B4`JCwCq;8_TXqLZy!7Y8LMK>jdX2Zyj?*1Yz(XRadw>wNGcer`E`jX_zXc)B5 zRRt<>TliUKtc_<}YhZB--R}UDC}yl1gnpA5e-;Rg!n+>EwFDCc#%^kw68tyok z7?t=Xem%cN*ls`Sa69{mI^nHOP$jFxHr653zD;`zDcUY1?mCbxL?xVcm=Nx1Q~b1(zf)}FJ;?LxN9JNrod_qf%n3@V ziXX34l0j&Fq+Q|p3_M3CPWf0bay8OU_kK0Mr<+!Cn5*YMfTs@}s@uI|3!Zf9yR*Wr zFeVmr@4KDxElP;q3j$Zk-c#nn-KL?(H2W8z~x`zCO{$T)}wpH)lJj|s^!%jadFd$Y{`fR-3Ci<=JSvB{o`?Gk$F z3BfA40(SB{Eca~*zeX9J5Zu5F><#KK@lRzF@B4t75ob*ptN`jcy5b*()Q+pg>vhQN7%3BQf6kHv5?Vw$rl|wN#k;y;+r@zITf>8TX%?4vx^P_n4S0K_Ssy1 zy7`jmTB1fDV*69{5UA+ z1S|qa4JMh?9ySTT26PmBp`)^_nq;JDa12)AxD>L~4%aroEjb>#^A!gL_sSy=E?CjZ z)djjs#>-u+!f&jN>;AM^w`Q;M-cpEW(q|be9Qf&FKRv^q@su0Oi4R08?CW1%8)@N0 zz1y+PD#58Gcxm$Y#4Ex(@2#KNgSyGzkyyNWlg1YIP1)3kMh3id^QZ^CT&rr zIn--~7@xF}?F&sfc{opk;?j0f~uiBV~+z`TYjb>QU#dM|= zUP}ZI;sq5i+#DsUEzzKh=LNK(Ez3DYH5{lV6uMqwE<-ZI7)@XQaO}$y(r_L&m5Di% zFkSXXGqX)pr5|1Nt>h6cJK~(PuZZfEygq=nMno3cidvjFiQurwW5D z#iMm)%9CkDaPrfdV5Eqn{jlAJ2RN^FI13)%BHf~>p!%_wXV9{U=!A_+*7hpsyLx=V zZKK6DDa*u;jo$-X&jiob<;*>=Fb8J}U!i-y2w!)R1WsP!_Sg7^=zRfw!Lws;pM$&k z)R&j329f?ipJdJ}b@XNsIcRiDha1l~i`^Ci&x&^mRuP9OhE|^q(&>l$+L;#HWiQ-! zy&$x1FU#@GCC&YE|}F zf#583@zI;Rw&;Wv9!sOyO5wqv36!*5>FGY0K(50D{p@*Ac>;2BRgH(+0rz=wu@b-0 zpi1GN#Y|@Lvt*`6KckOXuh6PGlp>aApPk}*b7pY^B8f{l290?HRxzjg;ISe|g(GIP z10LG+Z-YHv2v#@9^8{?E>(uWVF>waVD-11OED@z@_2De6Sf)@B1$w%$%gP;=QTOn= zsP*SMBy2rtOpmE2p$m*)*ewKM%u3<{dne%gDA2GrHb)-vm_>B%=1uOI@x`wTdEgiA zNYBdeL?PsnIpEkMm1d@QO$J@+gQYH+;67zD>Z-@>WRQ+AGvfrKQ$b-J=I{rLSqJYf z&_a3A2H^2VgrVe-QNadC4{euu`|)|QeE@@ADmp^xK-{80Aax=Tos?EsEJ6;*%&l31(skx5UjM_SVv0EEw^JLGLm;gH`9&8qsoac{O&f6gzqzM)IN(Iiw zec?|jU#cXIPgBfZKYMi?40tQ!-Gy~Vj&PLQ5(d?L6gzp`$u-AxX2OUl?BsBl8{OMO zWfURXi}gm?S8YVp1=d>9G6GFM((1TEQe?O|)BK~(FE8t2P3WRhr7>5Kf$vArX>s#b ze9Qx`S0g&q$D>}X-`i6ULV110iG$`G+{m-Acw^!ePO_kKtT$Uus359I-g8qoUF5B! z#im+-V{Xu40CiUO)BQM#65FnAV@RYuyFTSl+WuXlV|m2_lLYB3}rKzWjjNan&a7WON1S=m!}^2 zm!NvGS3qHQ@GRFCK=@RG9F%=z%3YD|ph36lgNMA**eGX}H9iBr%emBw&w(=lVKF|r6gbo! z_4$03*7>h!R>EW~OjiQrw_Yrw;`t}mks1c0^tD(wZ6AA9Z%H$+p4*}W+l1_=I~o#< zv#`QI1=qQvP-RfzI{gr0`LwM7s~Z}VogFlYulLIUF#@5%Y++j}e7I%3Z^K{`{WE=ARKr6tVuTOq#WWF_$-OQ_&Rygw0f*`H?E0cSw`U;X+WcqC;9kwbmlO zS~A1S+=@v4B;z|dB0;M@i-7B`E5NpD zMF`-sRib!Vb1W7A!pWj0_2%0zWmI;uftbDbUJJ?%a-(qt644XE!hs(@!1Ag(p1rh( z&KN&d)hMfD%lKGX*X6Vht1d z5jK@qap-1yW2QF^E_7_*F?6QE{f`N*X)8A^y?IzQT*>6d_^+u8)rR-*%hWz7pRj13 zHY8vaNK5x#9^I(03dY6?4@J%{55vx~Qe%dJ!XSWr*h?y*B-B9EUlBiV6QNYk@^HHQ0+618fOM$<>vyT3e3_^>y7N$~s; zu%=O$@w@CZ!m^Z=UV&sUTd_8Mcb7hCzfeq@P5WA{|WAZ$Of%0dn_vS3Litkrc zu;)Ys_m|z%2x4>(mcak80JNNe&nL#SuP6yR`!(Q)aHn-Nm~QPps$1d5+_#zdt5Daw zKjP4DR68aSjSelj(qR9DQOsZ zKH`V@8+yE%DRM&tFDuWGWqfh1r1PYmL14nzVsppglk^%k)kF*WkJ)Q{ zUq5UMsLOKXp%Rv(&P!!X!Y|hpHwr#Xv+p>c!u0YAOG4)Zk+4EWMvb}K-h~s1H5tC;35RMXyL%h_UU6+I$?fd$J97I5;c!X$?>+N)OmtE_ZXrin15PZ ztQNN&seUcOFZMb9x~Y(>O%obkt4eub!d&IQZYvm^0*w%zI{ zX~>~zfFD9J70f86R42ND=W~t*fDP`>?XQ0Khm_VWSBA*FcPHD2%GkAo9}%&LnqO@; zcKT^w260Mm$dNA}SU^%<;~u5@vo}dTOPSN9RmIE#D1KM9}1>oNwEX@~H%)?8qy-tg0@c#?Y`vXW{pA6Hu-{aIA znj;U0JV6SjM1k^div_#D*L^9?VXQqj)@Z(K{~Tp_T-#f%52R=ID%LxO*W4H)Ls+xD z+x+Vix`_Aq0h6(HVDD}fhx{*6(24j0du(!A0l4cNe_tXhI=o+#g-XwLahaXlIVGmz z!pv~-f%H%YK)YEBP4mX|*#Zt&^$-ox=|=`xS3q_s_Ko~MF@eooo1|p_0}MidvS9wd z1s67RkqJ0~^?Q|Z&;?r*7di}bShzQ05of1c=fAxZ0o$M9gj&mvqeYgcESW1;krZ$X zT2E=CwiIt`=*7(?S=uECW}UMALlrr|8zluA{fH1Oh)1X-)#;V znbuDLl*F&5Q5L{4Oa^N9Re-jG(K4mi4Vz~YyVv9|xJ=Qc?#8<~;9p(Ny&==YQuPCm z!E>U+=Wy7Ms@QxiX^EWsPURB$uBxWor!r%T@h)>Jl_Ov(Uv`QexKej4`deNmP zc_#3&9G@<;)pSIsSqP*bFcSsfzyBM%3vUF3m02RzLicefkMvqEl1PSy&wDRJUi8bC zFUiw*s){IHj63a&H&|M{{dpoh`1(N^?#@p%@RI|*;WO~-)3n$^Ng1$HCTlK|zY?{^- ztpnXPJ8NN@!AA4a!*ur53>vlXhE+S>PU!z#L)J2vy9U~`yh4Xaqyu91bhI>bN5h&z z`}_m_|Aqc_n-DHw6YYOTnRFYXY2EO2H2FIR9G9hh^Xnk3I_2N0Kxk5p`LwXrKex_) zf=)!Oiz!_7*xi9^LBsJe&FUBxH~q3ifHe?SQY@!dKT67In+MZXR_DZ_Wy@d!e>cXc z7yX}^oTiMHO&eyC_?tOjyvME3tbv!8y=nc3>ztR!O92&?=tFStuv7y zLdohU&xlAjxEXV+mPNo7+DOmaNIjV^TI6`)x7-)DWXY#3;i5-wuExKgAs+3uOp!G` z?N6Dg856S-Nw=HD6Z^-SYpUpivh9xzivEK5Y8_q1 z-5#_(oQ@!8F_75IZ2xf4@!9>F@S2*BEMumkkenh^*x_}~u3$@(s0ur@_QCeryf_aH zpD;W*CGbWH3)RA`s7UwPf&y)1$iA?uB68masbWqyadkC;dV+LRr}m}*1naf9IQ?9X zRlwTnA&*cu5qy2bYt2Z-O1>aEjtFN?nV7}nBB`Qf`GZFu#M9EPb!(aV*^aewp53^! z$arRKSvI!}-*ysT!8{}|EcHhb))*;IUkA#OLxXtuG?LO0+i>poiU;yI$DkD-HM!i- zX9x9xcr20SImvMr0rQTG8y|Bvw@&tY_a_Cb@}iO>?r{y(qVx*O<}p%G{ojbkbBMh4 z=m+N&B*e|{BKnasxdJPWJ-(PT^{QFri$>3c?3>@^HYgB55p>q8d`e`>-~Dqt?BMDH zSMZUq?sw6MJMvtHo;FYh8cz<9(uGT+VqE9uryU27&?98CcRs=C#{c4o<-2i*!y3>} zv;YR1#^|hpj>(bisx0D_50XCaKJ>JeN1F3Q;Jt8eiM61uMp_KKMdsi@BQo0?r=0aV zdR;o`Y6W5EW=Tw*OcBo-rBZTbdVn>&$(&_~#BXJ>W$W|pR3%51T+S_ts&ZV9$Hl9> z8)J}$@urjt!)ZfzZuGta)S4?@ymLY)5G^b|UETSNN2KchWPsl1vvX z*3)v^WEL}@J7YZF+HE=l@uezH2L%jr6cYfHXg%(`Os^lZ4l)3KH!_@xI)#O=-(ia| z@vTvI+nyrRbmuln&W6S5R7h$aRmsWwX&vgBS%`ly@4nyHc~wztCJhh-Y|VP%=3^j8d5kY461wW zOq1K_npo-Oeq-Q#QC^;qvEx0ap(+a=uq{z=raKQ}(-;0TxQo2L>2tZgBRPqoGqBZmc)LWw_!7ee@!J4jFWq5NkFW`+(KNMzelK7 zCY8(M^Yw1SY`?8Ky6cZV@>Be*rSX*8r<=c|?*Uh<+~y6tQZtC#=pLBX*|*iZJy)&a z+2uwSdQU~lGa1tkM7&?)c-Gz7`gEt8(;K|ATGp1>+u}0F7q?XQlKVwztGPWe598t_ZuNREh*_lKAi4%PVzCn6J|7&|ILHWVr^m3v_Th@?-|FPo9alR9kcwIj}Nq|gZ2L@u%9)h_ZI^^F%gUCCfh>d5pxo8Agci|VmC9|r4L z`ZTlw>+uzt)jNl4^Z@}p6p<{=ywdJ!S5}*go|g$eQprEH4aSgbUf@M)Grpa33NpNY zn^ftMlDGX>DhOu7B6WEBl;B2?mSNT@c>i=y%0 zIKw<0iRsZA#ksX$>0-xH>5T1VD*qm(2F%4ATEZVM-1)rr7WAkrBB!MQ+53U;>wfY&Tp#iCnFp=Y=~}RA&^< z5AtBK=j^`6+EHP9&!_c&0~J3FKGbf>HmL}vu%Ga?72Fu|U!ix55=^%c?GKeM##iSQ zTLbYVb{UAXwwvc>{Icw7UQ+0JK!n{vsAoDgm#=$xzE1>Q|K{ijz5V_h9JlMo7FuhB zJ>!r(-w8=`De^lY8Fp`LR3NEqQR;@K`ndN?drD-SeSS6PJa10$hj0xmzI(ikBes6M zVFmIpiGry0XoNJl-CUV`GDNcdTnD=Qgj4suTd~gQ1$o>c&#~sv3h*UA5U}Beh+)vJ> ziKl8q-DcxZ&ip@+RQ`wV532(`V}Hg8bx(n#WUr-xqTy0pe0zC}q%O-3#$rmW9Xn4CH>>62W` zq%OOphtC%^wI=rOs&h7VW7q3}?CpDflbF-NNwbVizX%+e=(pmbQ$EMj9WK7*(-rY zgI;!xZoO_#KGb_U8+pl@k0I#f=;3D5Q)&kuo@|U7aPIs_i(bol+H&UPi7`OeHp zRTiSb0NA2l33lOH-oJh@()L}nne8(PQ9AuX-CSEyB1v1In*^PePGd5=2wsoRJ)ugj z_Fz2&R^HU*zBQ*`>Xv38kIq2J|H%N#?8P69p?vUo$H1N)pAKHaPu=B)!i-D5sGw9mVuN|E>;kaLSSahQJJE~+mq{aSfUrsw z?9sWz!}P3tN8MjWjB>7pe)oWPMW)+<=LdF_tT=ld|D=motjSTn z4!7qt(%ZuIM_4<&QLo17qngi)!_{w3hM8E}xD6c~ z`9C(k1)UDi72yFa&ax!G<~JVocX-bh!e+V`DzM@q4MpgvYb{ThC;U30!QJbTb97 zOTXOal=oQu$+}tnE4LGRNcVlUR|@KtNRAtexNFU=ntsCyc!K%{g8Wdcd8QB%eT7FK z&dP5vGS}VK+d-6lj{ym1Ze*+lA8Y(qaP#WIf>H3t1Z~kDTOuqR7p*%_Qbd?AxJJEb zqX89SXI8^ItPd{YMup-7IXI7gGZ#XpxCy}+GxCr;19 zmk?}S^oB^~ap&@Ioqs9mB}NorWzFO5ikq2D@;a=;q%et4SVvtpBIBy}1HHTasj#g0 zXJ~lgiql`Yy6|^S&~h46n~`8`N{oc@L+{F-Y#c&u!sWGgB*5O(N*%$j3ZdX!f4i0m z=3k^{+`W0Q({7FSQF5m6?@XKJrMYhjm_^usnOnFY!qDgQru)QZ8hBcHjx}oeG|wi~ zHEE)@rUdm{xJv!4$_QCH-USV#M%cs;>F|tKiW(U-ZdYcT&Lg)fHS3z)H^cFDVsTo< zROJVR`>!oNZ>bXSM*g^b_OL;ixNT1<988!>y2g-FWY23dYz%HMO(+1I4EgQ?hM!&e z972ke53O|i@rceew!eETFdi|=I*)`N>Pz+h}-&VX&$_n&)DJ^W?P4*Z?cS7!WNMHR>|bcwJIV7!l7-&cH0$vp^V-xauKCZay3 z*|Zbsrkky}pdAjNfZy}m3-%pkhW%VD?tn|Q;Id8+>d#~1n|gY9!a2}F8?|`?TgP! zGC{=9N9E6xu6nKY(1by!w$SR7!IIE;3>@~zt;x7<-6jx>34r+m^KmSaL#cU#t zFbv8uJmdd5UDwr^z)~J{R8dp(CT}uep0SOB$>FR$|Im^bL-v^8LhR34Qubq48=T$n zzkx^JB}a(AJl_+|wHq~bxOUzw)J zZ{7>M>76AVWFF+akDHb3aYD0PkV@Swr2`s*vjh*kAOZ*c3S2up-neIM!7@Z$%ukF_ zZZrsbcI%hpZs;{9EAt7L-ub4%B|!faMz=3~&DBV0GMSxcR^Mom5ngbflwP@Keb*-} zScZ22=F5Wl*vfYnj1zvYiR8pYzb{?nU22&}2`w8NpOlcvj?>I?j(sni`~7tJ+?QM7 z^82jD51V3??wdTSRtGo31A5KTNJfnNw;d7yEg?9~;h=2`^;?FpS+bX3HCHhkHF`v` zUAIhig3C=QPR3w~QD@V|*THZ2I7-4amRQ*6wZ@wBuu&VQ6{IZQ#^K1(z?K z`*_lSE~bg;}`E^Efu)?u>7E(p{z7&Sv`=U&9B}#}9)92O4m8 zTD*72qxpJx&+Hj#9TzooQLN$zX3Y%^VxQ;8tMttwqqam{*eS1WmXCH6ydeTaQ+rW% zsK<)KO*l9hPj1r|88If{{$LcdaA0$DTi+F|<>UYP&M}_TB(jaPe5Se_XO}r^M z|M=2x4o+lC&$Lf6Uj%1-b22m4YnCZRY!Twxr+O!{KTCM9UAk01O>_^8i6eVQw4=#n zYFbYvAv8TBg?By6Rb)a~Sz=|+18j1|Cwh_y4%8H|6J%W1|2piUK_LiYj%A-Mb7cIJ^X3g?4pus}w?{3s$$SPkJk?~$lRG()NZ`wi` zMx67h9*^kZtaCBmEf*&Mew;#>0B+zh+umr}MN!CI^ zzT^k&?9}38#-;^*1m%FpC(2=|3=G~dcCh@MBJgD8a<=FY4P#wKP7JF@K4Y*8G%M96S6a*^IWUq{ zw`qh1Z+X-?mSu*nzt8;~fd@kQ2MN;D1BB^s|O^oX01fq=6{p+mEG{Q~%(r<@ZyFL~9$U-c&Vr#7+ zCZbKj&5Kz6CZ?vJt#l@hyKP&OQbFjjl$?Iok0J|aMr4SimJdE;T=%tBHmAotE{j(< zI$4B|YUJ}+9JwsN*PssaTd0-w7s`_gRMX7`Qtje6@=1}2Ifbze(;6qKVynD z#3^xA7J3jBpZ|I@!d1F@pf`sx_&LWMK#M$5I4WBITUTedr9y@!ZE;z4_JC)LOGSJ( z|D;7@NRuCV?-#9hcmvIN)Y4(axGn)Nbwr<8?RZ><$|shbsiW%;dFEz`<_~2jS;7xot1-SX1|&2E`Sw$deFua*GJMfC5rBWtk-r-)UoaAmKrdibaOa z``79q=h74A^SXx2UwgJp&&R$6u^;XPZ_@2D4HZ#uck?pd74GtnrBYu+ZbI|P8?I;O z}+NVZh1>Na&NiX7D1mx9M!J3iU$Yh54MF+ZlSL-2O#BN`Dfx(0GK>VB z&2)EHw%(TfJol>9_#6uY0Sl`3pctxoiFi?9|G9XESk7d4x5Cdh8rG^{PyhL7<<^MM zVP1uN;n;~$@$#tcmaVed=V5oOLZCOvF&vca+d!oty zM*&Js(G1zk_RL5LQS`0Z0`+qpoJv$L$<<4t9#6e3RJ&r3PZ5gi;G{adv7gM=^?5~j z3SrF(V6{YZZJ$>P1PGz^nep!h-0fnK@R|s?i6rRw8qB=kJ}&QH z+0*a~sNk{HZWfT53WH#H!=>_~P@}SnC_U!arkstNjq1sm@!{|mL|wk-vGk1o({YCt zzzAA5-w$s;Iz(8kObA?*W&tjxzXA5X&8jufz6UPx-^W<1%y5{^=iEu19%AWfi4c zPJX#w$E{0eQy}Fa+)@@-s{G<3%*ff%)@Cy<;^CT8_R}+exE!9mqb+x97J!MfRkpK% zf`;3I_sHiSw<~n75>INRtW*l0s0R-Q9yFg2H9mJ%Q+%7suph^PJaz~U7&@)1BHy|d zmci*zWYth=#uemt4yulq+lWnu_jrc+%#}Ue%tX)8eumuhV81N*(wtO1i6zN8=Bxw^ z81Z;FG~`a5Q{FtPGU`nXtUPzy%t=z~tcQH8+83L-&$I`p z*kbR|aNd9X&HD1GXkK*UrFen*shL&X_U~=*bOk~)eb#m6b_+ga*BvAFnq02V=|4QV zaXD&MWi1JX^p+?z+kO~~uZ_2AkYm1rJooaiXCk#UY^ zCGytpv?Mj;4mkL!PbdFYG12Z=`E>pzPF4AalmE-s;`n5)=_W)Vw4pKU$pLD-*-?JK zuUS1g2==HbUz|xN@h|>TjiP@!eMNg1EX3vj&Me>X_|`3Emb^=wXQhjTx4*<)G`r)K znNdQ&yKhEajlpR~uADm=Ug8V4N0;~R;m;Wzn!$H*d;NB~j08hnJiWBD8LI-jshIY1 zg)oLinEpz*BP-Cf$GpOLwcVVkFN58ly1u_;l)rWIF4^zmyb1sBFiGluyh`cM8^Uv-C7eqo!pVJ{X*WhG#_@;Fq4WH+Q_XcB zyDmkF1A$RZ=i2lS&f*CEXptnE60;lH?t&heYJoZp=jJcuRc5BNd1I3O5rNcq zN5grGSyITG5(AMB0+dwqwKPbrt2OG zDpz-LUZ;Q9zf!gw8sz|g+VV$9Yy9zY0Za;Vpu$VGnNTY5W9bj^ID8?9^6RW~ARvam z<|dC_z5H{)m2I!*YB$c;|U{1y|O9taYsXGdP z!{dhZ{`2nJCJXhtJ>sa&Gae&>%zc8wvr*l_oNUU}GYpTR|fuHAOMP|ObkCkHMnCBH|GsKQfP zaF~%lvHg%&Eveg8kojdc=FdNm?q_`)Y z&eR3uivn@m8)!X;!m?<)xR6}ii7%!{V_fCSS0dI}@9;cY9~hG5ow!>ge_*7Vk!ugk z?CmZrUXQqxDwbH(nz6|Z1birVT z_s8*C$>7VY5!ZLeZy86Xf^b!c%69Z!iQL%1f6N@Y6$e2y3#^mB50q=}wSP@4*1k}Z z^aGYhGFF2u!O2$#Nox49x*Z}hlezJM#GNQ6#V@t}ZkpL#;9v}ylW!)UQnxbAxOMGI zfruRa)v?h#OA!lkPTAgLcf+#4J@0CdF(!foKU{?Uks}D*f|<->5bg+jRs^H-nwJyN z5m&DZFy%PO3}CVNYEUD3>+e z^KK2qowRQjS@tZ~%*fYr`7EMYVk}e4cknc{i)ZC1dgDJDIIT>lJ%W<#-B0m-VltsQ zPOq8{0Aut$inKs>V~xe(5zCV6{ukf7mmZ^00pOD1R!>JJgil2H8zS@JG1qq&i@>+S z!tY66eMT9!LaAS;aIUaexPKNO!82qJ#b#``4<(V3hCs!V_7%ChcqBn9*Z=+ct>!&q z*gu*>J|-o;75QhYlvL2adjB2WKbnn|6AdMy$IBT{?eUBy#03Elk

Q!2CmkZcV&= zE+D`>`W_^B{DHWHk_O;J9rAJehtNMnEe>joZl0HySb1jUe(#U${00*%J^=++h&Kb@>ZJ;S*8W`YoJx)*Zf3>zW_*YW z81~rWl#i!SDs(OoS~!?vmv3Oiqc6_+UKX@%M4rcV=e{Oi2pK(;08wpITi|5R7i%H6}G@V%pSDL zJoa%3sDX5buxD4dFP4>sCzdwXQ|W{nk<3Fbu?0qREEcsvOF2g!OUrArn_yMml@}T< zO8!?}M3=7k@PlTlEx3ad z!G}6e72vI`uk*)-N^16YF6rH1v@qAt29{^PhUW~wctqQ_8~%r1hvIX20ICjG(j7_Z z)$@sss^78UaIivynHhLo5&^0j1}>ja{<$pAV3n`eieN+7!Gf>{WD;{0{5{s$%GMw8!-3OdF94dah*mc@A_IPzOZB|3O`K6a6`>cOg(csfx4oBx z{`m&#bP7Xm&k!scgo*Z_=z8Jh=+PM~JV90zhHj;!ke#SHv>H}oHXOf${Xt8O=~HfZ zn0miq5CksNRIcRNczM5^`OgvFA7YdWkq`x!k4?J#+>0xFJkqZq0FOhsF!O$BP@Cz) zS_S;wP*V}mLahUCCO_UM=op0Lv*gPFmt-B`%?&1YykZ|xoy;9jS95tn-V}Y&9LLa+ z8S;38Gq#CChX(0Z)OJGbmoV5FB4z3)SjPm^#+Gz7o%){BRJ>_1Umpictd)_HRAt9M zy^PsxR{C_g%6X`yqETSgpLdj&dp-^FyF23NCFOGmgbx{rN0vg07G>yxVS&(lkm@_@Yf%MDVw*CwEDV8#sp+tWft$N#Hc``gY!`=2^c;6nfXUn40i{g0*a_c$ub|5tPQ|3NH- Y#5u$X1_XKM0t5X>iOGvr3mXRgFLU@ATL1t6 From a6e92a2ea1e1bb7edaa0bf8eb3ce0e240d4caf79 Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 18:56:14 -0400 Subject: [PATCH 11/12] reformatting for merge --- LICENSE | 21 - Open_X_Embodiment_Datasets.ipynb | 2303 ---------- README.md | 66 - ai2thor_env.py | 641 --- data.py | 536 --- gen/README.md | 77 - gen/__init__.py | 0 gen/agents/agent_base.py | 60 - gen/agents/deterministic_planner_agent.py | 26 - gen/agents/plan_agent.py | 94 - gen/agents/semantic_map_planner_agent.py | 72 - gen/constants.py | 1221 ------ gen/ff_planner/README.md | 13 - gen/ff_planner/expressions.c | 2623 ----------- gen/ff_planner/expressions.h | 106 - gen/ff_planner/ff.h | 2044 --------- gen/ff_planner/inst_easy.c | 1220 ------ gen/ff_planner/inst_easy.h | 73 - gen/ff_planner/inst_final.c | 2797 ------------ gen/ff_planner/inst_final.h | 69 - gen/ff_planner/inst_hard.c | 1306 ------ gen/ff_planner/inst_hard.h | 71 - gen/ff_planner/inst_pre.c | 3854 ----------------- gen/ff_planner/inst_pre.h | 123 - gen/ff_planner/lex-fct_pddl.l | 139 - gen/ff_planner/lex-ops_pddl.l | 151 - gen/ff_planner/main.c | 1230 ------ gen/ff_planner/makefile | 89 - gen/ff_planner/memory.c | 1278 ------ gen/ff_planner/memory.h | 109 - gen/ff_planner/output.c | 1482 ------- gen/ff_planner/output.h | 68 - gen/ff_planner/parse.c | 1339 ------ gen/ff_planner/parse.h | 63 - gen/ff_planner/relax.c | 2756 ------------ gen/ff_planner/relax.h | 93 - gen/ff_planner/run_sample.sh | 2 - gen/ff_planner/samples/PutTask_domain.pddl | 152 - gen/ff_planner/samples/problem_0_0.pddl | 390 -- gen/ff_planner/scan-fct_pddl.y | 918 ---- gen/ff_planner/scan-ops_pddl.y | 1086 ----- gen/ff_planner/search.c | 2372 ---------- gen/ff_planner/search.h | 105 - gen/game_states/__init__.py | 0 gen/game_states/game_state_base.py | 935 ---- gen/game_states/planned_game_state.py | 490 --- gen/game_states/task_game_state.py | 368 -- .../task_game_state_full_knowledge.py | 444 -- gen/goal_library.py | 682 --- gen/graph/__init__.py | 0 gen/graph/graph_obj.py | 426 -- gen/layouts/FloorPlan1-layout.npy | Bin 2064 -> 0 bytes gen/layouts/FloorPlan1-objects.json | 51 - gen/layouts/FloorPlan1-openable.json | 146 - gen/layouts/FloorPlan10-layout.npy | Bin 3488 -> 0 bytes gen/layouts/FloorPlan10-objects.json | 49 - gen/layouts/FloorPlan10-openable.json | 110 - gen/layouts/FloorPlan11-layout.npy | Bin 1104 -> 0 bytes gen/layouts/FloorPlan11-objects.json | 43 - gen/layouts/FloorPlan11-openable.json | 128 - gen/layouts/FloorPlan12-layout.npy | Bin 1808 -> 0 bytes gen/layouts/FloorPlan12-objects.json | 40 - gen/layouts/FloorPlan12-openable.json | 218 - gen/layouts/FloorPlan13-layout.npy | Bin 3008 -> 0 bytes gen/layouts/FloorPlan13-objects.json | 43 - gen/layouts/FloorPlan13-openable.json | 224 - gen/layouts/FloorPlan14-layout.npy | Bin 1968 -> 0 bytes gen/layouts/FloorPlan14-objects.json | 40 - gen/layouts/FloorPlan14-openable.json | 68 - gen/layouts/FloorPlan15-layout.npy | Bin 1616 -> 0 bytes gen/layouts/FloorPlan15-objects.json | 45 - gen/layouts/FloorPlan15-openable.json | 92 - gen/layouts/FloorPlan16-layout.npy | Bin 3312 -> 0 bytes gen/layouts/FloorPlan16-objects.json | 46 - gen/layouts/FloorPlan16-openable.json | 200 - gen/layouts/FloorPlan17-layout.npy | Bin 1168 -> 0 bytes gen/layouts/FloorPlan17-objects.json | 47 - gen/layouts/FloorPlan17-openable.json | 140 - gen/layouts/FloorPlan18-layout.npy | Bin 3600 -> 0 bytes gen/layouts/FloorPlan18-objects.json | 48 - gen/layouts/FloorPlan18-openable.json | 146 - gen/layouts/FloorPlan19-layout.npy | Bin 1184 -> 0 bytes gen/layouts/FloorPlan19-objects.json | 40 - gen/layouts/FloorPlan19-openable.json | 182 - gen/layouts/FloorPlan2-layout.npy | Bin 1968 -> 0 bytes gen/layouts/FloorPlan2-objects.json | 43 - gen/layouts/FloorPlan2-openable.json | 164 - gen/layouts/FloorPlan20-layout.npy | Bin 1392 -> 0 bytes gen/layouts/FloorPlan20-objects.json | 46 - gen/layouts/FloorPlan20-openable.json | 116 - gen/layouts/FloorPlan201-layout.npy | Bin 3232 -> 0 bytes gen/layouts/FloorPlan201-objects.json | 37 - gen/layouts/FloorPlan201-openable.json | 86 - gen/layouts/FloorPlan202-layout.npy | Bin 2496 -> 0 bytes gen/layouts/FloorPlan202-objects.json | 26 - gen/layouts/FloorPlan202-openable.json | 44 - gen/layouts/FloorPlan203-layout.npy | Bin 8512 -> 0 bytes gen/layouts/FloorPlan203-objects.json | 35 - gen/layouts/FloorPlan203-openable.json | 86 - gen/layouts/FloorPlan204-layout.npy | Bin 2960 -> 0 bytes gen/layouts/FloorPlan204-objects.json | 31 - gen/layouts/FloorPlan204-openable.json | 146 - gen/layouts/FloorPlan205-layout.npy | Bin 4112 -> 0 bytes gen/layouts/FloorPlan205-objects.json | 29 - gen/layouts/FloorPlan205-openable.json | 80 - gen/layouts/FloorPlan206-layout.npy | Bin 1904 -> 0 bytes gen/layouts/FloorPlan206-objects.json | 26 - gen/layouts/FloorPlan206-openable.json | 122 - gen/layouts/FloorPlan207-layout.npy | Bin 2352 -> 0 bytes gen/layouts/FloorPlan207-objects.json | 27 - gen/layouts/FloorPlan207-openable.json | 98 - gen/layouts/FloorPlan208-layout.npy | Bin 3376 -> 0 bytes gen/layouts/FloorPlan208-objects.json | 26 - gen/layouts/FloorPlan208-openable.json | 98 - gen/layouts/FloorPlan209-layout.npy | Bin 4816 -> 0 bytes gen/layouts/FloorPlan209-objects.json | 31 - gen/layouts/FloorPlan209-openable.json | 62 - gen/layouts/FloorPlan21-layout.npy | Bin 1584 -> 0 bytes gen/layouts/FloorPlan21-objects.json | 47 - gen/layouts/FloorPlan21-openable.json | 86 - gen/layouts/FloorPlan210-layout.npy | Bin 4160 -> 0 bytes gen/layouts/FloorPlan210-objects.json | 30 - gen/layouts/FloorPlan210-openable.json | 98 - gen/layouts/FloorPlan211-layout.npy | Bin 2240 -> 0 bytes gen/layouts/FloorPlan211-objects.json | 30 - gen/layouts/FloorPlan211-openable.json | 74 - gen/layouts/FloorPlan212-layout.npy | Bin 1856 -> 0 bytes gen/layouts/FloorPlan212-objects.json | 30 - gen/layouts/FloorPlan212-openable.json | 80 - gen/layouts/FloorPlan213-layout.npy | Bin 4736 -> 0 bytes gen/layouts/FloorPlan213-objects.json | 27 - gen/layouts/FloorPlan213-openable.json | 146 - gen/layouts/FloorPlan214-layout.npy | Bin 3024 -> 0 bytes gen/layouts/FloorPlan214-objects.json | 29 - gen/layouts/FloorPlan214-openable.json | 56 - gen/layouts/FloorPlan215-layout.npy | Bin 6208 -> 0 bytes gen/layouts/FloorPlan215-objects.json | 30 - gen/layouts/FloorPlan215-openable.json | 92 - gen/layouts/FloorPlan216-layout.npy | Bin 2560 -> 0 bytes gen/layouts/FloorPlan216-objects.json | 28 - gen/layouts/FloorPlan216-openable.json | 68 - gen/layouts/FloorPlan217-layout.npy | Bin 2240 -> 0 bytes gen/layouts/FloorPlan217-objects.json | 29 - gen/layouts/FloorPlan217-openable.json | 92 - gen/layouts/FloorPlan218-layout.npy | Bin 6400 -> 0 bytes gen/layouts/FloorPlan218-objects.json | 30 - gen/layouts/FloorPlan218-openable.json | 68 - gen/layouts/FloorPlan219-layout.npy | Bin 3552 -> 0 bytes gen/layouts/FloorPlan219-objects.json | 31 - gen/layouts/FloorPlan219-openable.json | 158 - gen/layouts/FloorPlan22-layout.npy | Bin 2256 -> 0 bytes gen/layouts/FloorPlan22-objects.json | 42 - gen/layouts/FloorPlan22-openable.json | 176 - gen/layouts/FloorPlan220-layout.npy | Bin 3712 -> 0 bytes gen/layouts/FloorPlan220-objects.json | 30 - gen/layouts/FloorPlan220-openable.json | 92 - gen/layouts/FloorPlan221-layout.npy | Bin 1904 -> 0 bytes gen/layouts/FloorPlan221-objects.json | 29 - gen/layouts/FloorPlan221-openable.json | 44 - gen/layouts/FloorPlan222-layout.npy | Bin 1648 -> 0 bytes gen/layouts/FloorPlan222-objects.json | 26 - gen/layouts/FloorPlan222-openable.json | 86 - gen/layouts/FloorPlan223-layout.npy | Bin 3344 -> 0 bytes gen/layouts/FloorPlan223-objects.json | 28 - gen/layouts/FloorPlan223-openable.json | 50 - gen/layouts/FloorPlan224-layout.npy | Bin 4688 -> 0 bytes gen/layouts/FloorPlan224-objects.json | 32 - gen/layouts/FloorPlan224-openable.json | 182 - gen/layouts/FloorPlan225-layout.npy | Bin 2576 -> 0 bytes gen/layouts/FloorPlan225-objects.json | 31 - gen/layouts/FloorPlan225-openable.json | 86 - gen/layouts/FloorPlan226-layout.npy | Bin 1392 -> 0 bytes gen/layouts/FloorPlan226-objects.json | 25 - gen/layouts/FloorPlan226-openable.json | 68 - gen/layouts/FloorPlan227-layout.npy | Bin 3232 -> 0 bytes gen/layouts/FloorPlan227-objects.json | 28 - gen/layouts/FloorPlan227-openable.json | 206 - gen/layouts/FloorPlan228-layout.npy | Bin 2576 -> 0 bytes gen/layouts/FloorPlan228-objects.json | 27 - gen/layouts/FloorPlan228-openable.json | 62 - gen/layouts/FloorPlan229-layout.npy | Bin 3088 -> 0 bytes gen/layouts/FloorPlan229-objects.json | 32 - gen/layouts/FloorPlan229-openable.json | 68 - gen/layouts/FloorPlan23-layout.npy | Bin 1648 -> 0 bytes gen/layouts/FloorPlan23-objects.json | 47 - gen/layouts/FloorPlan23-openable.json | 98 - gen/layouts/FloorPlan230-layout.npy | Bin 6448 -> 0 bytes gen/layouts/FloorPlan230-objects.json | 32 - gen/layouts/FloorPlan230-openable.json | 56 - gen/layouts/FloorPlan24-layout.npy | Bin 1152 -> 0 bytes gen/layouts/FloorPlan24-objects.json | 42 - gen/layouts/FloorPlan24-openable.json | 176 - gen/layouts/FloorPlan25-layout.npy | Bin 560 -> 0 bytes gen/layouts/FloorPlan25-objects.json | 41 - gen/layouts/FloorPlan25-openable.json | 92 - gen/layouts/FloorPlan26-layout.npy | Bin 1344 -> 0 bytes gen/layouts/FloorPlan26-objects.json | 40 - gen/layouts/FloorPlan26-openable.json | 92 - gen/layouts/FloorPlan27-layout.npy | Bin 784 -> 0 bytes gen/layouts/FloorPlan27-objects.json | 43 - gen/layouts/FloorPlan27-openable.json | 128 - gen/layouts/FloorPlan28-layout.npy | Bin 1712 -> 0 bytes gen/layouts/FloorPlan28-objects.json | 43 - gen/layouts/FloorPlan28-openable.json | 122 - gen/layouts/FloorPlan29-layout.npy | Bin 1168 -> 0 bytes gen/layouts/FloorPlan29-objects.json | 39 - gen/layouts/FloorPlan29-openable.json | 80 - gen/layouts/FloorPlan3-layout.npy | Bin 1856 -> 0 bytes gen/layouts/FloorPlan3-objects.json | 45 - gen/layouts/FloorPlan3-openable.json | 110 - gen/layouts/FloorPlan30-layout.npy | Bin 1296 -> 0 bytes gen/layouts/FloorPlan30-objects.json | 45 - gen/layouts/FloorPlan30-openable.json | 218 - gen/layouts/FloorPlan301-layout.npy | Bin 1392 -> 0 bytes gen/layouts/FloorPlan301-objects.json | 35 - gen/layouts/FloorPlan301-openable.json | 122 - gen/layouts/FloorPlan302-layout.npy | Bin 848 -> 0 bytes gen/layouts/FloorPlan302-objects.json | 31 - gen/layouts/FloorPlan302-openable.json | 80 - gen/layouts/FloorPlan303-layout.npy | Bin 1168 -> 0 bytes gen/layouts/FloorPlan303-objects.json | 35 - gen/layouts/FloorPlan303-openable.json | 122 - gen/layouts/FloorPlan304-layout.npy | Bin 1808 -> 0 bytes gen/layouts/FloorPlan304-objects.json | 30 - gen/layouts/FloorPlan304-openable.json | 26 - gen/layouts/FloorPlan305-layout.npy | Bin 1472 -> 0 bytes gen/layouts/FloorPlan305-objects.json | 32 - gen/layouts/FloorPlan305-openable.json | 62 - gen/layouts/FloorPlan306-layout.npy | Bin 1632 -> 0 bytes gen/layouts/FloorPlan306-objects.json | 27 - gen/layouts/FloorPlan306-openable.json | 68 - gen/layouts/FloorPlan307-layout.npy | Bin 1424 -> 0 bytes gen/layouts/FloorPlan307-objects.json | 34 - gen/layouts/FloorPlan307-openable.json | 104 - gen/layouts/FloorPlan308-layout.npy | Bin 1744 -> 0 bytes gen/layouts/FloorPlan308-objects.json | 30 - gen/layouts/FloorPlan308-openable.json | 104 - gen/layouts/FloorPlan309-layout.npy | Bin 5760 -> 0 bytes gen/layouts/FloorPlan309-objects.json | 33 - gen/layouts/FloorPlan309-openable.json | 74 - gen/layouts/FloorPlan310-layout.npy | Bin 1152 -> 0 bytes gen/layouts/FloorPlan310-objects.json | 31 - gen/layouts/FloorPlan310-openable.json | 50 - gen/layouts/FloorPlan311-layout.npy | Bin 3760 -> 0 bytes gen/layouts/FloorPlan311-objects.json | 32 - gen/layouts/FloorPlan311-openable.json | 56 - gen/layouts/FloorPlan312-layout.npy | Bin 1440 -> 0 bytes gen/layouts/FloorPlan312-objects.json | 27 - gen/layouts/FloorPlan312-openable.json | 74 - gen/layouts/FloorPlan313-layout.npy | Bin 880 -> 0 bytes gen/layouts/FloorPlan313-objects.json | 34 - gen/layouts/FloorPlan313-openable.json | 80 - gen/layouts/FloorPlan314-layout.npy | Bin 1200 -> 0 bytes gen/layouts/FloorPlan314-objects.json | 27 - gen/layouts/FloorPlan314-openable.json | 50 - gen/layouts/FloorPlan315-layout.npy | Bin 1712 -> 0 bytes gen/layouts/FloorPlan315-objects.json | 28 - gen/layouts/FloorPlan315-openable.json | 110 - gen/layouts/FloorPlan316-layout.npy | Bin 1056 -> 0 bytes gen/layouts/FloorPlan316-objects.json | 30 - gen/layouts/FloorPlan316-openable.json | 44 - gen/layouts/FloorPlan317-layout.npy | Bin 1680 -> 0 bytes gen/layouts/FloorPlan317-objects.json | 30 - gen/layouts/FloorPlan317-openable.json | 92 - gen/layouts/FloorPlan318-layout.npy | Bin 1632 -> 0 bytes gen/layouts/FloorPlan318-objects.json | 31 - gen/layouts/FloorPlan318-openable.json | 158 - gen/layouts/FloorPlan319-layout.npy | Bin 1680 -> 0 bytes gen/layouts/FloorPlan319-objects.json | 30 - gen/layouts/FloorPlan319-openable.json | 122 - gen/layouts/FloorPlan320-layout.npy | Bin 1200 -> 0 bytes gen/layouts/FloorPlan320-objects.json | 30 - gen/layouts/FloorPlan320-openable.json | 50 - gen/layouts/FloorPlan321-layout.npy | Bin 1600 -> 0 bytes gen/layouts/FloorPlan321-objects.json | 27 - gen/layouts/FloorPlan321-openable.json | 44 - gen/layouts/FloorPlan322-layout.npy | Bin 1792 -> 0 bytes gen/layouts/FloorPlan322-objects.json | 30 - gen/layouts/FloorPlan322-openable.json | 122 - gen/layouts/FloorPlan323-layout.npy | Bin 3184 -> 0 bytes gen/layouts/FloorPlan323-objects.json | 30 - gen/layouts/FloorPlan323-openable.json | 80 - gen/layouts/FloorPlan324-layout.npy | Bin 1552 -> 0 bytes gen/layouts/FloorPlan324-objects.json | 29 - gen/layouts/FloorPlan324-openable.json | 110 - gen/layouts/FloorPlan325-layout.npy | Bin 3040 -> 0 bytes gen/layouts/FloorPlan325-objects.json | 28 - gen/layouts/FloorPlan325-openable.json | 140 - gen/layouts/FloorPlan326-layout.npy | Bin 1728 -> 0 bytes gen/layouts/FloorPlan326-objects.json | 35 - gen/layouts/FloorPlan326-openable.json | 128 - gen/layouts/FloorPlan327-layout.npy | Bin 1392 -> 0 bytes gen/layouts/FloorPlan327-objects.json | 29 - gen/layouts/FloorPlan327-openable.json | 92 - gen/layouts/FloorPlan328-layout.npy | Bin 1104 -> 0 bytes gen/layouts/FloorPlan328-objects.json | 31 - gen/layouts/FloorPlan328-openable.json | 44 - gen/layouts/FloorPlan329-layout.npy | Bin 1536 -> 0 bytes gen/layouts/FloorPlan329-objects.json | 28 - gen/layouts/FloorPlan329-openable.json | 50 - gen/layouts/FloorPlan330-layout.npy | Bin 2240 -> 0 bytes gen/layouts/FloorPlan330-objects.json | 32 - gen/layouts/FloorPlan330-openable.json | 122 - gen/layouts/FloorPlan4-layout.npy | Bin 1232 -> 0 bytes gen/layouts/FloorPlan4-objects.json | 42 - gen/layouts/FloorPlan4-openable.json | 98 - gen/layouts/FloorPlan401-layout.npy | Bin 1616 -> 0 bytes gen/layouts/FloorPlan401-objects.json | 32 - gen/layouts/FloorPlan401-openable.json | 56 - gen/layouts/FloorPlan402-layout.npy | Bin 1584 -> 0 bytes gen/layouts/FloorPlan402-objects.json | 33 - gen/layouts/FloorPlan402-openable.json | 92 - gen/layouts/FloorPlan403-layout.npy | Bin 1008 -> 0 bytes gen/layouts/FloorPlan403-objects.json | 34 - gen/layouts/FloorPlan403-openable.json | 50 - gen/layouts/FloorPlan404-layout.npy | Bin 1008 -> 0 bytes gen/layouts/FloorPlan404-objects.json | 29 - gen/layouts/FloorPlan404-openable.json | 38 - gen/layouts/FloorPlan405-layout.npy | Bin 576 -> 0 bytes gen/layouts/FloorPlan405-objects.json | 28 - gen/layouts/FloorPlan405-openable.json | 56 - gen/layouts/FloorPlan406-layout.npy | Bin 1664 -> 0 bytes gen/layouts/FloorPlan406-objects.json | 28 - gen/layouts/FloorPlan406-openable.json | 26 - gen/layouts/FloorPlan407-layout.npy | Bin 672 -> 0 bytes gen/layouts/FloorPlan407-objects.json | 32 - gen/layouts/FloorPlan407-openable.json | 56 - gen/layouts/FloorPlan408-layout.npy | Bin 704 -> 0 bytes gen/layouts/FloorPlan408-objects.json | 28 - gen/layouts/FloorPlan408-openable.json | 62 - gen/layouts/FloorPlan409-layout.npy | Bin 752 -> 0 bytes gen/layouts/FloorPlan409-objects.json | 28 - gen/layouts/FloorPlan409-openable.json | 62 - gen/layouts/FloorPlan410-layout.npy | Bin 1408 -> 0 bytes gen/layouts/FloorPlan410-objects.json | 29 - gen/layouts/FloorPlan410-openable.json | 74 - gen/layouts/FloorPlan411-layout.npy | Bin 1104 -> 0 bytes gen/layouts/FloorPlan411-objects.json | 31 - gen/layouts/FloorPlan411-openable.json | 62 - gen/layouts/FloorPlan412-layout.npy | Bin 784 -> 0 bytes gen/layouts/FloorPlan412-objects.json | 29 - gen/layouts/FloorPlan412-openable.json | 50 - gen/layouts/FloorPlan413-layout.npy | Bin 1216 -> 0 bytes gen/layouts/FloorPlan413-objects.json | 32 - gen/layouts/FloorPlan413-openable.json | 92 - gen/layouts/FloorPlan414-layout.npy | Bin 800 -> 0 bytes gen/layouts/FloorPlan414-objects.json | 31 - gen/layouts/FloorPlan414-openable.json | 92 - gen/layouts/FloorPlan415-layout.npy | Bin 880 -> 0 bytes gen/layouts/FloorPlan415-objects.json | 31 - gen/layouts/FloorPlan415-openable.json | 68 - gen/layouts/FloorPlan416-layout.npy | Bin 992 -> 0 bytes gen/layouts/FloorPlan416-objects.json | 28 - gen/layouts/FloorPlan416-openable.json | 44 - gen/layouts/FloorPlan417-layout.npy | Bin 1088 -> 0 bytes gen/layouts/FloorPlan417-objects.json | 29 - gen/layouts/FloorPlan417-openable.json | 44 - gen/layouts/FloorPlan418-layout.npy | Bin 864 -> 0 bytes gen/layouts/FloorPlan418-objects.json | 29 - gen/layouts/FloorPlan418-openable.json | 44 - gen/layouts/FloorPlan419-layout.npy | Bin 608 -> 0 bytes gen/layouts/FloorPlan419-objects.json | 30 - gen/layouts/FloorPlan419-openable.json | 44 - gen/layouts/FloorPlan420-layout.npy | Bin 560 -> 0 bytes gen/layouts/FloorPlan420-objects.json | 29 - gen/layouts/FloorPlan420-openable.json | 32 - gen/layouts/FloorPlan421-layout.npy | Bin 608 -> 0 bytes gen/layouts/FloorPlan421-objects.json | 29 - gen/layouts/FloorPlan421-openable.json | 68 - gen/layouts/FloorPlan422-layout.npy | Bin 656 -> 0 bytes gen/layouts/FloorPlan422-objects.json | 33 - gen/layouts/FloorPlan422-openable.json | 86 - gen/layouts/FloorPlan423-layout.npy | Bin 1008 -> 0 bytes gen/layouts/FloorPlan423-objects.json | 32 - gen/layouts/FloorPlan423-openable.json | 86 - gen/layouts/FloorPlan424-layout.npy | Bin 736 -> 0 bytes gen/layouts/FloorPlan424-objects.json | 28 - gen/layouts/FloorPlan424-openable.json | 56 - gen/layouts/FloorPlan425-layout.npy | Bin 512 -> 0 bytes gen/layouts/FloorPlan425-objects.json | 30 - gen/layouts/FloorPlan425-openable.json | 56 - gen/layouts/FloorPlan426-layout.npy | Bin 912 -> 0 bytes gen/layouts/FloorPlan426-objects.json | 31 - gen/layouts/FloorPlan426-openable.json | 68 - gen/layouts/FloorPlan427-layout.npy | Bin 992 -> 0 bytes gen/layouts/FloorPlan427-objects.json | 32 - gen/layouts/FloorPlan427-openable.json | 80 - gen/layouts/FloorPlan428-layout.npy | Bin 992 -> 0 bytes gen/layouts/FloorPlan428-objects.json | 28 - gen/layouts/FloorPlan428-openable.json | 50 - gen/layouts/FloorPlan429-layout.npy | Bin 1152 -> 0 bytes gen/layouts/FloorPlan429-objects.json | 29 - gen/layouts/FloorPlan429-openable.json | 38 - gen/layouts/FloorPlan430-layout.npy | Bin 1760 -> 0 bytes gen/layouts/FloorPlan430-objects.json | 35 - gen/layouts/FloorPlan430-openable.json | 50 - gen/layouts/FloorPlan5-layout.npy | Bin 1680 -> 0 bytes gen/layouts/FloorPlan5-objects.json | 47 - gen/layouts/FloorPlan5-openable.json | 152 - gen/layouts/FloorPlan6-layout.npy | Bin 2176 -> 0 bytes gen/layouts/FloorPlan6-objects.json | 42 - gen/layouts/FloorPlan6-openable.json | 164 - gen/layouts/FloorPlan7-layout.npy | Bin 4352 -> 0 bytes gen/layouts/FloorPlan7-objects.json | 50 - gen/layouts/FloorPlan7-openable.json | 146 - gen/layouts/FloorPlan8-layout.npy | Bin 2768 -> 0 bytes gen/layouts/FloorPlan8-objects.json | 46 - gen/layouts/FloorPlan8-openable.json | 170 - gen/layouts/FloorPlan9-layout.npy | Bin 1360 -> 0 bytes gen/layouts/FloorPlan9-objects.json | 42 - gen/layouts/FloorPlan9-openable.json | 260 -- gen/layouts/precompute_layout_locations.py | 350 -- gen/planner/__init__.py | 0 .../domains/PutTaskExtended_domain.pddl | 302 -- gen/planner/ff_planner_handler.py | 252 -- gen/planner/pddl.pdf | Bin 196613 -> 0 bytes gen/scripts/augment_trajectories.py | 312 -- gen/scripts/generate_trajectories.py | 752 ---- gen/scripts/replay_checks.py | 217 - gen/utils/__init__.py | 0 gen/utils/bb_util.py | 139 - gen/utils/dataset_management_util.py | 69 - gen/utils/game_util.py | 363 -- gen/utils/image_util.py | 57 - gen/utils/py_util.py | 84 - gen/utils/replay_json.py | 52 - gen/utils/video_util.py | 11 - lanmp_dataloader/attribute_limits.json | 1 - lanmp_dataloader/rt1_dataloader.py | 800 ---- lanmp_dataloader/scene_to_keys.json | 1 - main.py | 257 -- main_ft.py | 387 -- main_ft_eval.py | 279 -- rollout_ai2thor.py | 366 -- rt1_env/bin/Activate.ps1 | 241 -- rt1_env/bin/activate | 66 - rt1_env/bin/activate.csh | 25 - rt1_env/bin/activate.fish | 64 - rt1_env/bin/ai2thor-xorg | 267 -- rt1_env/bin/convert-caffe2-to-onnx | 10 - rt1_env/bin/convert-onnx-to-caffe2 | 10 - rt1_env/bin/f2py | 10 - rt1_env/bin/flask | 10 - rt1_env/bin/huggingface-cli | 10 - rt1_env/bin/imageio_download_bin | 10 - rt1_env/bin/imageio_remove_bin | 10 - rt1_env/bin/import_pb_to_tensorboard | 10 - rt1_env/bin/isympy | 10 - rt1_env/bin/jp.py | 54 - rt1_env/bin/lsm2bin | 10 - rt1_env/bin/markdown-it | 10 - rt1_env/bin/markdown_py | 10 - rt1_env/bin/normalizer | 10 - rt1_env/bin/pip | 10 - rt1_env/bin/pip3 | 10 - rt1_env/bin/pip3.9 | 10 - rt1_env/bin/portserver.py | 415 -- rt1_env/bin/progressbar | 10 - rt1_env/bin/pygmentize | 10 - rt1_env/bin/python | 1 - rt1_env/bin/python3 | 1 - rt1_env/bin/python3.9 | 1 - rt1_env/bin/pythoni | 36 - rt1_env/bin/pythoni1 | 17 - rt1_env/bin/reverb_server | 10 - rt1_env/bin/saved_model_cli | 10 - rt1_env/bin/tensorboard | 10 - rt1_env/bin/tf_upgrade_v2 | 10 - rt1_env/bin/tfds | 10 - rt1_env/bin/tflite_convert | 10 - rt1_env/bin/tiff2fsspec | 10 - rt1_env/bin/tiffcomment | 10 - rt1_env/bin/tifffile | 10 - rt1_env/bin/toco | 10 - rt1_env/bin/toco_from_protos | 10 - rt1_env/bin/torchrun | 10 - rt1_env/bin/tqdm | 10 - rt1_env/bin/transformers-cli | 10 - rt1_env/bin/tree-cli | 10 - rt1_env/bin/wandb | 10 - rt1_env/bin/wb | 10 - rt1_env/bin/wheel | 10 - .../site/python3.9/dm-reverb/checkpoint.proto | 77 - .../site/python3.9/dm-reverb/patterns.proto | 123 - .../python3.9/dm-reverb/reverb_config.proto | 10 - .../site/python3.9/dm-reverb/schema.proto | 289 -- rt1_env/lib64 | 1 - rt1_env/pyvenv.cfg | 3 - rt1_env/share/man/man1/isympy.1 | 188 - rt1_pytorch/__init__.py | 0 rt1_pytorch/film_efficientnet/__init__.py | 0 .../film_conditioning_layer.py | 38 - .../film_efficientnet/film_efficientnet.py | 446 -- rt1_pytorch/rt1_model.py | 217 - rt1_pytorch/rt1_policy.py | 234 - rt1_pytorch/tokenizers/__init__.py | 0 rt1_pytorch/tokenizers/action_tokenizer.py | 184 - rt1_pytorch/tokenizers/image_tokenizer.py | 77 - rt1_pytorch/tokenizers/token_learner.py | 89 - setup.py | 44 - tests/action_tokenizer_test.py | 166 - tests/film_conditioning_layer_test.py | 27 - tests/film_efficientnet_test.py | 57 - tests/image_tokenizer_test.py | 53 - tests/rt1_model_test.py | 54 - tests/rt1_policy_test.py | 64 - tests/token_learner_test.py | 40 - vd4rl_main.py | 389 -- 508 files changed, 61499 deletions(-) delete mode 100644 LICENSE delete mode 100644 Open_X_Embodiment_Datasets.ipynb delete mode 100644 README.md delete mode 100644 ai2thor_env.py delete mode 100644 data.py delete mode 100644 gen/README.md delete mode 100644 gen/__init__.py delete mode 100644 gen/agents/agent_base.py delete mode 100644 gen/agents/deterministic_planner_agent.py delete mode 100644 gen/agents/plan_agent.py delete mode 100644 gen/agents/semantic_map_planner_agent.py delete mode 100644 gen/constants.py delete mode 100644 gen/ff_planner/README.md delete mode 100644 gen/ff_planner/expressions.c delete mode 100644 gen/ff_planner/expressions.h delete mode 100644 gen/ff_planner/ff.h delete mode 100644 gen/ff_planner/inst_easy.c delete mode 100644 gen/ff_planner/inst_easy.h delete mode 100644 gen/ff_planner/inst_final.c delete mode 100644 gen/ff_planner/inst_final.h delete mode 100644 gen/ff_planner/inst_hard.c delete mode 100644 gen/ff_planner/inst_hard.h delete mode 100644 gen/ff_planner/inst_pre.c delete mode 100644 gen/ff_planner/inst_pre.h delete mode 100644 gen/ff_planner/lex-fct_pddl.l delete mode 100644 gen/ff_planner/lex-ops_pddl.l delete mode 100644 gen/ff_planner/main.c delete mode 100644 gen/ff_planner/makefile delete mode 100644 gen/ff_planner/memory.c delete mode 100644 gen/ff_planner/memory.h delete mode 100644 gen/ff_planner/output.c delete mode 100644 gen/ff_planner/output.h delete mode 100644 gen/ff_planner/parse.c delete mode 100644 gen/ff_planner/parse.h delete mode 100644 gen/ff_planner/relax.c delete mode 100644 gen/ff_planner/relax.h delete mode 100755 gen/ff_planner/run_sample.sh delete mode 100644 gen/ff_planner/samples/PutTask_domain.pddl delete mode 100644 gen/ff_planner/samples/problem_0_0.pddl delete mode 100644 gen/ff_planner/scan-fct_pddl.y delete mode 100644 gen/ff_planner/scan-ops_pddl.y delete mode 100644 gen/ff_planner/search.c delete mode 100644 gen/ff_planner/search.h delete mode 100644 gen/game_states/__init__.py delete mode 100644 gen/game_states/game_state_base.py delete mode 100644 gen/game_states/planned_game_state.py delete mode 100644 gen/game_states/task_game_state.py delete mode 100644 gen/game_states/task_game_state_full_knowledge.py delete mode 100644 gen/goal_library.py delete mode 100644 gen/graph/__init__.py delete mode 100644 gen/graph/graph_obj.py delete mode 100644 gen/layouts/FloorPlan1-layout.npy delete mode 100644 gen/layouts/FloorPlan1-objects.json delete mode 100644 gen/layouts/FloorPlan1-openable.json delete mode 100644 gen/layouts/FloorPlan10-layout.npy delete mode 100644 gen/layouts/FloorPlan10-objects.json delete mode 100644 gen/layouts/FloorPlan10-openable.json delete mode 100644 gen/layouts/FloorPlan11-layout.npy delete mode 100644 gen/layouts/FloorPlan11-objects.json delete mode 100644 gen/layouts/FloorPlan11-openable.json delete mode 100644 gen/layouts/FloorPlan12-layout.npy delete mode 100644 gen/layouts/FloorPlan12-objects.json delete mode 100644 gen/layouts/FloorPlan12-openable.json delete mode 100644 gen/layouts/FloorPlan13-layout.npy delete mode 100644 gen/layouts/FloorPlan13-objects.json delete mode 100644 gen/layouts/FloorPlan13-openable.json delete mode 100644 gen/layouts/FloorPlan14-layout.npy delete mode 100644 gen/layouts/FloorPlan14-objects.json delete mode 100644 gen/layouts/FloorPlan14-openable.json delete mode 100644 gen/layouts/FloorPlan15-layout.npy delete mode 100644 gen/layouts/FloorPlan15-objects.json delete mode 100644 gen/layouts/FloorPlan15-openable.json delete mode 100644 gen/layouts/FloorPlan16-layout.npy delete mode 100644 gen/layouts/FloorPlan16-objects.json delete mode 100644 gen/layouts/FloorPlan16-openable.json delete mode 100644 gen/layouts/FloorPlan17-layout.npy delete mode 100644 gen/layouts/FloorPlan17-objects.json delete mode 100644 gen/layouts/FloorPlan17-openable.json delete mode 100644 gen/layouts/FloorPlan18-layout.npy delete mode 100644 gen/layouts/FloorPlan18-objects.json delete mode 100644 gen/layouts/FloorPlan18-openable.json delete mode 100644 gen/layouts/FloorPlan19-layout.npy delete mode 100644 gen/layouts/FloorPlan19-objects.json delete mode 100644 gen/layouts/FloorPlan19-openable.json delete mode 100644 gen/layouts/FloorPlan2-layout.npy delete mode 100644 gen/layouts/FloorPlan2-objects.json delete mode 100644 gen/layouts/FloorPlan2-openable.json delete mode 100644 gen/layouts/FloorPlan20-layout.npy delete mode 100644 gen/layouts/FloorPlan20-objects.json delete mode 100644 gen/layouts/FloorPlan20-openable.json delete mode 100644 gen/layouts/FloorPlan201-layout.npy delete mode 100644 gen/layouts/FloorPlan201-objects.json delete mode 100644 gen/layouts/FloorPlan201-openable.json delete mode 100644 gen/layouts/FloorPlan202-layout.npy delete mode 100644 gen/layouts/FloorPlan202-objects.json delete mode 100644 gen/layouts/FloorPlan202-openable.json delete mode 100644 gen/layouts/FloorPlan203-layout.npy delete mode 100644 gen/layouts/FloorPlan203-objects.json delete mode 100644 gen/layouts/FloorPlan203-openable.json delete mode 100644 gen/layouts/FloorPlan204-layout.npy delete mode 100644 gen/layouts/FloorPlan204-objects.json delete mode 100644 gen/layouts/FloorPlan204-openable.json delete mode 100644 gen/layouts/FloorPlan205-layout.npy delete mode 100644 gen/layouts/FloorPlan205-objects.json delete mode 100644 gen/layouts/FloorPlan205-openable.json delete mode 100644 gen/layouts/FloorPlan206-layout.npy delete mode 100644 gen/layouts/FloorPlan206-objects.json delete mode 100644 gen/layouts/FloorPlan206-openable.json delete mode 100644 gen/layouts/FloorPlan207-layout.npy delete mode 100644 gen/layouts/FloorPlan207-objects.json delete mode 100644 gen/layouts/FloorPlan207-openable.json delete mode 100644 gen/layouts/FloorPlan208-layout.npy delete mode 100644 gen/layouts/FloorPlan208-objects.json delete mode 100644 gen/layouts/FloorPlan208-openable.json delete mode 100644 gen/layouts/FloorPlan209-layout.npy delete mode 100644 gen/layouts/FloorPlan209-objects.json delete mode 100644 gen/layouts/FloorPlan209-openable.json delete mode 100644 gen/layouts/FloorPlan21-layout.npy delete mode 100644 gen/layouts/FloorPlan21-objects.json delete mode 100644 gen/layouts/FloorPlan21-openable.json delete mode 100644 gen/layouts/FloorPlan210-layout.npy delete mode 100644 gen/layouts/FloorPlan210-objects.json delete mode 100644 gen/layouts/FloorPlan210-openable.json delete mode 100644 gen/layouts/FloorPlan211-layout.npy delete mode 100644 gen/layouts/FloorPlan211-objects.json delete mode 100644 gen/layouts/FloorPlan211-openable.json delete mode 100644 gen/layouts/FloorPlan212-layout.npy delete mode 100644 gen/layouts/FloorPlan212-objects.json delete mode 100644 gen/layouts/FloorPlan212-openable.json delete mode 100644 gen/layouts/FloorPlan213-layout.npy delete mode 100644 gen/layouts/FloorPlan213-objects.json delete mode 100644 gen/layouts/FloorPlan213-openable.json delete mode 100644 gen/layouts/FloorPlan214-layout.npy delete mode 100644 gen/layouts/FloorPlan214-objects.json delete mode 100644 gen/layouts/FloorPlan214-openable.json delete mode 100644 gen/layouts/FloorPlan215-layout.npy delete mode 100644 gen/layouts/FloorPlan215-objects.json delete mode 100644 gen/layouts/FloorPlan215-openable.json delete mode 100644 gen/layouts/FloorPlan216-layout.npy delete mode 100644 gen/layouts/FloorPlan216-objects.json delete mode 100644 gen/layouts/FloorPlan216-openable.json delete mode 100644 gen/layouts/FloorPlan217-layout.npy delete mode 100644 gen/layouts/FloorPlan217-objects.json delete mode 100644 gen/layouts/FloorPlan217-openable.json delete mode 100644 gen/layouts/FloorPlan218-layout.npy delete mode 100644 gen/layouts/FloorPlan218-objects.json delete mode 100644 gen/layouts/FloorPlan218-openable.json delete mode 100644 gen/layouts/FloorPlan219-layout.npy delete mode 100644 gen/layouts/FloorPlan219-objects.json delete mode 100644 gen/layouts/FloorPlan219-openable.json delete mode 100644 gen/layouts/FloorPlan22-layout.npy delete mode 100644 gen/layouts/FloorPlan22-objects.json delete mode 100644 gen/layouts/FloorPlan22-openable.json delete mode 100644 gen/layouts/FloorPlan220-layout.npy delete mode 100644 gen/layouts/FloorPlan220-objects.json delete mode 100644 gen/layouts/FloorPlan220-openable.json delete mode 100644 gen/layouts/FloorPlan221-layout.npy delete mode 100644 gen/layouts/FloorPlan221-objects.json delete mode 100644 gen/layouts/FloorPlan221-openable.json delete mode 100644 gen/layouts/FloorPlan222-layout.npy delete mode 100644 gen/layouts/FloorPlan222-objects.json delete mode 100644 gen/layouts/FloorPlan222-openable.json delete mode 100644 gen/layouts/FloorPlan223-layout.npy delete mode 100644 gen/layouts/FloorPlan223-objects.json delete mode 100644 gen/layouts/FloorPlan223-openable.json delete mode 100644 gen/layouts/FloorPlan224-layout.npy delete mode 100644 gen/layouts/FloorPlan224-objects.json delete mode 100644 gen/layouts/FloorPlan224-openable.json delete mode 100644 gen/layouts/FloorPlan225-layout.npy delete mode 100644 gen/layouts/FloorPlan225-objects.json delete mode 100644 gen/layouts/FloorPlan225-openable.json delete mode 100644 gen/layouts/FloorPlan226-layout.npy delete mode 100644 gen/layouts/FloorPlan226-objects.json delete mode 100644 gen/layouts/FloorPlan226-openable.json delete mode 100644 gen/layouts/FloorPlan227-layout.npy delete mode 100644 gen/layouts/FloorPlan227-objects.json delete mode 100644 gen/layouts/FloorPlan227-openable.json delete mode 100644 gen/layouts/FloorPlan228-layout.npy delete mode 100644 gen/layouts/FloorPlan228-objects.json delete mode 100644 gen/layouts/FloorPlan228-openable.json delete mode 100644 gen/layouts/FloorPlan229-layout.npy delete mode 100644 gen/layouts/FloorPlan229-objects.json delete mode 100644 gen/layouts/FloorPlan229-openable.json delete mode 100644 gen/layouts/FloorPlan23-layout.npy delete mode 100644 gen/layouts/FloorPlan23-objects.json delete mode 100644 gen/layouts/FloorPlan23-openable.json delete mode 100644 gen/layouts/FloorPlan230-layout.npy delete mode 100644 gen/layouts/FloorPlan230-objects.json delete mode 100644 gen/layouts/FloorPlan230-openable.json delete mode 100644 gen/layouts/FloorPlan24-layout.npy delete mode 100644 gen/layouts/FloorPlan24-objects.json delete mode 100644 gen/layouts/FloorPlan24-openable.json delete mode 100644 gen/layouts/FloorPlan25-layout.npy delete mode 100644 gen/layouts/FloorPlan25-objects.json delete mode 100644 gen/layouts/FloorPlan25-openable.json delete mode 100644 gen/layouts/FloorPlan26-layout.npy delete mode 100644 gen/layouts/FloorPlan26-objects.json delete mode 100644 gen/layouts/FloorPlan26-openable.json delete mode 100644 gen/layouts/FloorPlan27-layout.npy delete mode 100644 gen/layouts/FloorPlan27-objects.json delete mode 100644 gen/layouts/FloorPlan27-openable.json delete mode 100644 gen/layouts/FloorPlan28-layout.npy delete mode 100644 gen/layouts/FloorPlan28-objects.json delete mode 100644 gen/layouts/FloorPlan28-openable.json delete mode 100644 gen/layouts/FloorPlan29-layout.npy delete mode 100644 gen/layouts/FloorPlan29-objects.json delete mode 100644 gen/layouts/FloorPlan29-openable.json delete mode 100644 gen/layouts/FloorPlan3-layout.npy delete mode 100644 gen/layouts/FloorPlan3-objects.json delete mode 100644 gen/layouts/FloorPlan3-openable.json delete mode 100644 gen/layouts/FloorPlan30-layout.npy delete mode 100644 gen/layouts/FloorPlan30-objects.json delete mode 100644 gen/layouts/FloorPlan30-openable.json delete mode 100644 gen/layouts/FloorPlan301-layout.npy delete mode 100644 gen/layouts/FloorPlan301-objects.json delete mode 100644 gen/layouts/FloorPlan301-openable.json delete mode 100644 gen/layouts/FloorPlan302-layout.npy delete mode 100644 gen/layouts/FloorPlan302-objects.json delete mode 100644 gen/layouts/FloorPlan302-openable.json delete mode 100644 gen/layouts/FloorPlan303-layout.npy delete mode 100644 gen/layouts/FloorPlan303-objects.json delete mode 100644 gen/layouts/FloorPlan303-openable.json delete mode 100644 gen/layouts/FloorPlan304-layout.npy delete mode 100644 gen/layouts/FloorPlan304-objects.json delete mode 100644 gen/layouts/FloorPlan304-openable.json delete mode 100644 gen/layouts/FloorPlan305-layout.npy delete mode 100644 gen/layouts/FloorPlan305-objects.json delete mode 100644 gen/layouts/FloorPlan305-openable.json delete mode 100644 gen/layouts/FloorPlan306-layout.npy delete mode 100644 gen/layouts/FloorPlan306-objects.json delete mode 100644 gen/layouts/FloorPlan306-openable.json delete mode 100644 gen/layouts/FloorPlan307-layout.npy delete mode 100644 gen/layouts/FloorPlan307-objects.json delete mode 100644 gen/layouts/FloorPlan307-openable.json delete mode 100644 gen/layouts/FloorPlan308-layout.npy delete mode 100644 gen/layouts/FloorPlan308-objects.json delete mode 100644 gen/layouts/FloorPlan308-openable.json delete mode 100644 gen/layouts/FloorPlan309-layout.npy delete mode 100644 gen/layouts/FloorPlan309-objects.json delete mode 100644 gen/layouts/FloorPlan309-openable.json delete mode 100644 gen/layouts/FloorPlan310-layout.npy delete mode 100644 gen/layouts/FloorPlan310-objects.json delete mode 100644 gen/layouts/FloorPlan310-openable.json delete mode 100644 gen/layouts/FloorPlan311-layout.npy delete mode 100644 gen/layouts/FloorPlan311-objects.json delete mode 100644 gen/layouts/FloorPlan311-openable.json delete mode 100644 gen/layouts/FloorPlan312-layout.npy delete mode 100644 gen/layouts/FloorPlan312-objects.json delete mode 100644 gen/layouts/FloorPlan312-openable.json delete mode 100644 gen/layouts/FloorPlan313-layout.npy delete mode 100644 gen/layouts/FloorPlan313-objects.json delete mode 100644 gen/layouts/FloorPlan313-openable.json delete mode 100644 gen/layouts/FloorPlan314-layout.npy delete mode 100644 gen/layouts/FloorPlan314-objects.json delete mode 100644 gen/layouts/FloorPlan314-openable.json delete mode 100644 gen/layouts/FloorPlan315-layout.npy delete mode 100644 gen/layouts/FloorPlan315-objects.json delete mode 100644 gen/layouts/FloorPlan315-openable.json delete mode 100644 gen/layouts/FloorPlan316-layout.npy delete mode 100644 gen/layouts/FloorPlan316-objects.json delete mode 100644 gen/layouts/FloorPlan316-openable.json delete mode 100644 gen/layouts/FloorPlan317-layout.npy delete mode 100644 gen/layouts/FloorPlan317-objects.json delete mode 100644 gen/layouts/FloorPlan317-openable.json delete mode 100644 gen/layouts/FloorPlan318-layout.npy delete mode 100644 gen/layouts/FloorPlan318-objects.json delete mode 100644 gen/layouts/FloorPlan318-openable.json delete mode 100644 gen/layouts/FloorPlan319-layout.npy delete mode 100644 gen/layouts/FloorPlan319-objects.json delete mode 100644 gen/layouts/FloorPlan319-openable.json delete mode 100644 gen/layouts/FloorPlan320-layout.npy delete mode 100644 gen/layouts/FloorPlan320-objects.json delete mode 100644 gen/layouts/FloorPlan320-openable.json delete mode 100644 gen/layouts/FloorPlan321-layout.npy delete mode 100644 gen/layouts/FloorPlan321-objects.json delete mode 100644 gen/layouts/FloorPlan321-openable.json delete mode 100644 gen/layouts/FloorPlan322-layout.npy delete mode 100644 gen/layouts/FloorPlan322-objects.json delete mode 100644 gen/layouts/FloorPlan322-openable.json delete mode 100644 gen/layouts/FloorPlan323-layout.npy delete mode 100644 gen/layouts/FloorPlan323-objects.json delete mode 100644 gen/layouts/FloorPlan323-openable.json delete mode 100644 gen/layouts/FloorPlan324-layout.npy delete mode 100644 gen/layouts/FloorPlan324-objects.json delete mode 100644 gen/layouts/FloorPlan324-openable.json delete mode 100644 gen/layouts/FloorPlan325-layout.npy delete mode 100644 gen/layouts/FloorPlan325-objects.json delete mode 100644 gen/layouts/FloorPlan325-openable.json delete mode 100644 gen/layouts/FloorPlan326-layout.npy delete mode 100644 gen/layouts/FloorPlan326-objects.json delete mode 100644 gen/layouts/FloorPlan326-openable.json delete mode 100644 gen/layouts/FloorPlan327-layout.npy delete mode 100644 gen/layouts/FloorPlan327-objects.json delete mode 100644 gen/layouts/FloorPlan327-openable.json delete mode 100644 gen/layouts/FloorPlan328-layout.npy delete mode 100644 gen/layouts/FloorPlan328-objects.json delete mode 100644 gen/layouts/FloorPlan328-openable.json delete mode 100644 gen/layouts/FloorPlan329-layout.npy delete mode 100644 gen/layouts/FloorPlan329-objects.json delete mode 100644 gen/layouts/FloorPlan329-openable.json delete mode 100644 gen/layouts/FloorPlan330-layout.npy delete mode 100644 gen/layouts/FloorPlan330-objects.json delete mode 100644 gen/layouts/FloorPlan330-openable.json delete mode 100644 gen/layouts/FloorPlan4-layout.npy delete mode 100644 gen/layouts/FloorPlan4-objects.json delete mode 100644 gen/layouts/FloorPlan4-openable.json delete mode 100644 gen/layouts/FloorPlan401-layout.npy delete mode 100644 gen/layouts/FloorPlan401-objects.json delete mode 100644 gen/layouts/FloorPlan401-openable.json delete mode 100644 gen/layouts/FloorPlan402-layout.npy delete mode 100644 gen/layouts/FloorPlan402-objects.json delete mode 100644 gen/layouts/FloorPlan402-openable.json delete mode 100644 gen/layouts/FloorPlan403-layout.npy delete mode 100644 gen/layouts/FloorPlan403-objects.json delete mode 100644 gen/layouts/FloorPlan403-openable.json delete mode 100644 gen/layouts/FloorPlan404-layout.npy delete mode 100644 gen/layouts/FloorPlan404-objects.json delete mode 100644 gen/layouts/FloorPlan404-openable.json delete mode 100644 gen/layouts/FloorPlan405-layout.npy delete mode 100644 gen/layouts/FloorPlan405-objects.json delete mode 100644 gen/layouts/FloorPlan405-openable.json delete mode 100644 gen/layouts/FloorPlan406-layout.npy delete mode 100644 gen/layouts/FloorPlan406-objects.json delete mode 100644 gen/layouts/FloorPlan406-openable.json delete mode 100644 gen/layouts/FloorPlan407-layout.npy delete mode 100644 gen/layouts/FloorPlan407-objects.json delete mode 100644 gen/layouts/FloorPlan407-openable.json delete mode 100644 gen/layouts/FloorPlan408-layout.npy delete mode 100644 gen/layouts/FloorPlan408-objects.json delete mode 100644 gen/layouts/FloorPlan408-openable.json delete mode 100644 gen/layouts/FloorPlan409-layout.npy delete mode 100644 gen/layouts/FloorPlan409-objects.json delete mode 100644 gen/layouts/FloorPlan409-openable.json delete mode 100644 gen/layouts/FloorPlan410-layout.npy delete mode 100644 gen/layouts/FloorPlan410-objects.json delete mode 100644 gen/layouts/FloorPlan410-openable.json delete mode 100644 gen/layouts/FloorPlan411-layout.npy delete mode 100644 gen/layouts/FloorPlan411-objects.json delete mode 100644 gen/layouts/FloorPlan411-openable.json delete mode 100644 gen/layouts/FloorPlan412-layout.npy delete mode 100644 gen/layouts/FloorPlan412-objects.json delete mode 100644 gen/layouts/FloorPlan412-openable.json delete mode 100644 gen/layouts/FloorPlan413-layout.npy delete mode 100644 gen/layouts/FloorPlan413-objects.json delete mode 100644 gen/layouts/FloorPlan413-openable.json delete mode 100644 gen/layouts/FloorPlan414-layout.npy delete mode 100644 gen/layouts/FloorPlan414-objects.json delete mode 100644 gen/layouts/FloorPlan414-openable.json delete mode 100644 gen/layouts/FloorPlan415-layout.npy delete mode 100644 gen/layouts/FloorPlan415-objects.json delete mode 100644 gen/layouts/FloorPlan415-openable.json delete mode 100644 gen/layouts/FloorPlan416-layout.npy delete mode 100644 gen/layouts/FloorPlan416-objects.json delete mode 100644 gen/layouts/FloorPlan416-openable.json delete mode 100644 gen/layouts/FloorPlan417-layout.npy delete mode 100644 gen/layouts/FloorPlan417-objects.json delete mode 100644 gen/layouts/FloorPlan417-openable.json delete mode 100644 gen/layouts/FloorPlan418-layout.npy delete mode 100644 gen/layouts/FloorPlan418-objects.json delete mode 100644 gen/layouts/FloorPlan418-openable.json delete mode 100644 gen/layouts/FloorPlan419-layout.npy delete mode 100644 gen/layouts/FloorPlan419-objects.json delete mode 100644 gen/layouts/FloorPlan419-openable.json delete mode 100644 gen/layouts/FloorPlan420-layout.npy delete mode 100644 gen/layouts/FloorPlan420-objects.json delete mode 100644 gen/layouts/FloorPlan420-openable.json delete mode 100644 gen/layouts/FloorPlan421-layout.npy delete mode 100644 gen/layouts/FloorPlan421-objects.json delete mode 100644 gen/layouts/FloorPlan421-openable.json delete mode 100644 gen/layouts/FloorPlan422-layout.npy delete mode 100644 gen/layouts/FloorPlan422-objects.json delete mode 100644 gen/layouts/FloorPlan422-openable.json delete mode 100644 gen/layouts/FloorPlan423-layout.npy delete mode 100644 gen/layouts/FloorPlan423-objects.json delete mode 100644 gen/layouts/FloorPlan423-openable.json delete mode 100644 gen/layouts/FloorPlan424-layout.npy delete mode 100644 gen/layouts/FloorPlan424-objects.json delete mode 100644 gen/layouts/FloorPlan424-openable.json delete mode 100644 gen/layouts/FloorPlan425-layout.npy delete mode 100644 gen/layouts/FloorPlan425-objects.json delete mode 100644 gen/layouts/FloorPlan425-openable.json delete mode 100644 gen/layouts/FloorPlan426-layout.npy delete mode 100644 gen/layouts/FloorPlan426-objects.json delete mode 100644 gen/layouts/FloorPlan426-openable.json delete mode 100644 gen/layouts/FloorPlan427-layout.npy delete mode 100644 gen/layouts/FloorPlan427-objects.json delete mode 100644 gen/layouts/FloorPlan427-openable.json delete mode 100644 gen/layouts/FloorPlan428-layout.npy delete mode 100644 gen/layouts/FloorPlan428-objects.json delete mode 100644 gen/layouts/FloorPlan428-openable.json delete mode 100644 gen/layouts/FloorPlan429-layout.npy delete mode 100644 gen/layouts/FloorPlan429-objects.json delete mode 100644 gen/layouts/FloorPlan429-openable.json delete mode 100644 gen/layouts/FloorPlan430-layout.npy delete mode 100644 gen/layouts/FloorPlan430-objects.json delete mode 100644 gen/layouts/FloorPlan430-openable.json delete mode 100644 gen/layouts/FloorPlan5-layout.npy delete mode 100644 gen/layouts/FloorPlan5-objects.json delete mode 100644 gen/layouts/FloorPlan5-openable.json delete mode 100644 gen/layouts/FloorPlan6-layout.npy delete mode 100644 gen/layouts/FloorPlan6-objects.json delete mode 100644 gen/layouts/FloorPlan6-openable.json delete mode 100644 gen/layouts/FloorPlan7-layout.npy delete mode 100644 gen/layouts/FloorPlan7-objects.json delete mode 100644 gen/layouts/FloorPlan7-openable.json delete mode 100644 gen/layouts/FloorPlan8-layout.npy delete mode 100644 gen/layouts/FloorPlan8-objects.json delete mode 100644 gen/layouts/FloorPlan8-openable.json delete mode 100644 gen/layouts/FloorPlan9-layout.npy delete mode 100644 gen/layouts/FloorPlan9-objects.json delete mode 100644 gen/layouts/FloorPlan9-openable.json delete mode 100644 gen/layouts/precompute_layout_locations.py delete mode 100644 gen/planner/__init__.py delete mode 100644 gen/planner/domains/PutTaskExtended_domain.pddl delete mode 100644 gen/planner/ff_planner_handler.py delete mode 100644 gen/planner/pddl.pdf delete mode 100644 gen/scripts/augment_trajectories.py delete mode 100644 gen/scripts/generate_trajectories.py delete mode 100644 gen/scripts/replay_checks.py delete mode 100644 gen/utils/__init__.py delete mode 100644 gen/utils/bb_util.py delete mode 100644 gen/utils/dataset_management_util.py delete mode 100644 gen/utils/game_util.py delete mode 100644 gen/utils/image_util.py delete mode 100644 gen/utils/py_util.py delete mode 100644 gen/utils/replay_json.py delete mode 100644 gen/utils/video_util.py delete mode 100644 lanmp_dataloader/attribute_limits.json delete mode 100644 lanmp_dataloader/rt1_dataloader.py delete mode 100644 lanmp_dataloader/scene_to_keys.json delete mode 100644 main.py delete mode 100644 main_ft.py delete mode 100644 main_ft_eval.py delete mode 100644 rollout_ai2thor.py delete mode 100644 rt1_env/bin/Activate.ps1 delete mode 100644 rt1_env/bin/activate delete mode 100644 rt1_env/bin/activate.csh delete mode 100644 rt1_env/bin/activate.fish delete mode 100755 rt1_env/bin/ai2thor-xorg delete mode 100755 rt1_env/bin/convert-caffe2-to-onnx delete mode 100755 rt1_env/bin/convert-onnx-to-caffe2 delete mode 100755 rt1_env/bin/f2py delete mode 100755 rt1_env/bin/flask delete mode 100755 rt1_env/bin/huggingface-cli delete mode 100755 rt1_env/bin/imageio_download_bin delete mode 100755 rt1_env/bin/imageio_remove_bin delete mode 100755 rt1_env/bin/import_pb_to_tensorboard delete mode 100755 rt1_env/bin/isympy delete mode 100755 rt1_env/bin/jp.py delete mode 100755 rt1_env/bin/lsm2bin delete mode 100755 rt1_env/bin/markdown-it delete mode 100755 rt1_env/bin/markdown_py delete mode 100755 rt1_env/bin/normalizer delete mode 100755 rt1_env/bin/pip delete mode 100755 rt1_env/bin/pip3 delete mode 100755 rt1_env/bin/pip3.9 delete mode 100755 rt1_env/bin/portserver.py delete mode 100755 rt1_env/bin/progressbar delete mode 100755 rt1_env/bin/pygmentize delete mode 120000 rt1_env/bin/python delete mode 120000 rt1_env/bin/python3 delete mode 120000 rt1_env/bin/python3.9 delete mode 100755 rt1_env/bin/pythoni delete mode 100755 rt1_env/bin/pythoni1 delete mode 100755 rt1_env/bin/reverb_server delete mode 100755 rt1_env/bin/saved_model_cli delete mode 100755 rt1_env/bin/tensorboard delete mode 100755 rt1_env/bin/tf_upgrade_v2 delete mode 100755 rt1_env/bin/tfds delete mode 100755 rt1_env/bin/tflite_convert delete mode 100755 rt1_env/bin/tiff2fsspec delete mode 100755 rt1_env/bin/tiffcomment delete mode 100755 rt1_env/bin/tifffile delete mode 100755 rt1_env/bin/toco delete mode 100755 rt1_env/bin/toco_from_protos delete mode 100755 rt1_env/bin/torchrun delete mode 100755 rt1_env/bin/tqdm delete mode 100755 rt1_env/bin/transformers-cli delete mode 100755 rt1_env/bin/tree-cli delete mode 100755 rt1_env/bin/wandb delete mode 100755 rt1_env/bin/wb delete mode 100755 rt1_env/bin/wheel delete mode 100644 rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto delete mode 100644 rt1_env/include/site/python3.9/dm-reverb/patterns.proto delete mode 100644 rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto delete mode 100644 rt1_env/include/site/python3.9/dm-reverb/schema.proto delete mode 120000 rt1_env/lib64 delete mode 100644 rt1_env/pyvenv.cfg delete mode 100644 rt1_env/share/man/man1/isympy.1 delete mode 100644 rt1_pytorch/__init__.py delete mode 100644 rt1_pytorch/film_efficientnet/__init__.py delete mode 100644 rt1_pytorch/film_efficientnet/film_conditioning_layer.py delete mode 100644 rt1_pytorch/film_efficientnet/film_efficientnet.py delete mode 100644 rt1_pytorch/rt1_model.py delete mode 100644 rt1_pytorch/rt1_policy.py delete mode 100644 rt1_pytorch/tokenizers/__init__.py delete mode 100644 rt1_pytorch/tokenizers/action_tokenizer.py delete mode 100644 rt1_pytorch/tokenizers/image_tokenizer.py delete mode 100644 rt1_pytorch/tokenizers/token_learner.py delete mode 100644 setup.py delete mode 100644 tests/action_tokenizer_test.py delete mode 100644 tests/film_conditioning_layer_test.py delete mode 100644 tests/film_efficientnet_test.py delete mode 100644 tests/image_tokenizer_test.py delete mode 100644 tests/rt1_model_test.py delete mode 100644 tests/rt1_policy_test.py delete mode 100644 tests/token_learner_test.py delete mode 100644 vd4rl_main.py diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 272afdf8f..000000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2022 Phil Wang - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/Open_X_Embodiment_Datasets.ipynb b/Open_X_Embodiment_Datasets.ipynb deleted file mode 100644 index 2b2235541..000000000 --- a/Open_X_Embodiment_Datasets.ipynb +++ /dev/null @@ -1,2303 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "EnWCKLGGaf-d" - }, - "source": [ - "# Open X-Embodiment Datasets\n", - "\n", - "![](https://robotics-transformer-x.github.io/img/overview.png)\n", - "\n", - "This colab helps you **visualize** the datasets in the Open X-Embodiment Dataset, explains how to **download** them and how to **train** with them.\n", - "\n", - "Table of Content:" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "toc", - "id": "UyiiBjzmaIQu" - }, - "source": [ - ">[Open X-Embodiment Datasets](#scrollTo=EnWCKLGGaf-d)\n", - "\n", - ">[Visualize Datasets](#scrollTo=29c7oLlJbWwF)\n", - "\n", - ">[Download Datasets](#scrollTo=-WHN-2OrKqGo)\n", - "\n", - ">[Data Loader Example](#scrollTo=IyccDsRqwtMz)\n", - "\n", - ">[Interleave Multiple Datasets](#scrollTo=ekmsGRAnw3Bp)\n", - "\n", - ">[Example Dataloader to produce trajectories](#scrollTo=aew258oUbamg)\n", - "\n", - ">>[Demonstration of transformation from an episode to a trajectory](#scrollTo=BK4RRYkbLN5B)\n", - "\n", - ">>[Combination of multiple datasets](#scrollTo=Oy89HzymQyAq)\n", - "\n", - ">[Available datasets:](#scrollTo=N2Efw2aHVfSX)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "29c7oLlJbWwF" - }, - "source": [ - "# Visualize Datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "id": "l7OogZYi7qwT" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import tensorflow_datasets as tfds\n", - "from PIL import Image\n", - "from IPython import display\n", - "\n", - "DATASETS = [\n", - " \"fractal20220817_data\",\n", - " \"kuka\",\n", - " \"bridge\",\n", - " \"taco_play\",\n", - " \"jaco_play\",\n", - " \"berkeley_cable_routing\",\n", - " \"roboturk\",\n", - " \"nyu_door_opening_surprising_effectiveness\",\n", - " \"viola\",\n", - " \"berkeley_autolab_ur5\",\n", - " \"toto\",\n", - " \"language_table\",\n", - " \"columbia_cairlab_pusht_real\",\n", - " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", - " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", - " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", - " \"austin_buds_dataset_converted_externally_to_rlds\",\n", - " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", - " \"maniskill_dataset_converted_externally_to_rlds\",\n", - " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", - " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", - " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", - " \"bc_z\",\n", - " \"usc_cloth_sim_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", - " \"utokyo_saytap_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", - " \"robo_net\",\n", - " \"berkeley_mvp_converted_externally_to_rlds\",\n", - " \"berkeley_rpt_converted_externally_to_rlds\",\n", - " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", - " \"stanford_mask_vit_converted_externally_to_rlds\",\n", - " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", - " \"dlr_sara_pour_converted_externally_to_rlds\",\n", - " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", - " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", - " \"asu_table_top_converted_externally_to_rlds\",\n", - " \"stanford_robocook_converted_externally_to_rlds\",\n", - " \"eth_agent_affordances\",\n", - " \"imperialcollege_sawyer_wrist_cam\",\n", - " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", - " \"uiuc_d3field\",\n", - " \"utaustin_mutex\",\n", - " \"berkeley_fanuc_manipulation\",\n", - " \"cmu_play_fusion\",\n", - " \"cmu_stretch\",\n", - " \"berkeley_gnm_recon\",\n", - " \"berkeley_gnm_cory_hall\",\n", - " \"berkeley_gnm_sac_son\",\n", - "]\n", - "\n", - "\n", - "def dataset2path(name):\n", - " if name == \"robo_net\":\n", - " version = \"1.0.0\"\n", - " elif name == \"language_table\":\n", - " version = \"0.0.1\"\n", - " else:\n", - " version = \"0.1.0\"\n", - " return f\"gs://gresearch/robotics/{name}/{version}\"\n", - "\n", - "\n", - "def as_gif(images, path=\"temp.gif\"):\n", - " # Render the images as the gif:\n", - " images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0)\n", - " gif_bytes = open(path, \"rb\").read()\n", - " return gif_bytes" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 497 - }, - "id": "Gcw4eHmxbZjx", - "outputId": "a2cc46f1-5eec-41b8-fa23-6b4797b1e1e1" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# choose the dataset path in the dropdown on the right and rerun this cell\n", - "# to see multiple samples\n", - "\n", - "dataset = \"fractal20220817_data\" # @param ['fractal20220817_data', 'kuka', 'bridge', 'taco_play', 'jaco_play', 'berkeley_cable_routing', 'roboturk', 'nyu_door_opening_surprising_effectiveness', 'viola', 'berkeley_autolab_ur5', 'toto', 'language_table', 'columbia_cairlab_pusht_real', 'stanford_kuka_multimodal_dataset_converted_externally_to_rlds', 'nyu_rot_dataset_converted_externally_to_rlds', 'stanford_hydra_dataset_converted_externally_to_rlds', 'austin_buds_dataset_converted_externally_to_rlds', 'nyu_franka_play_dataset_converted_externally_to_rlds', 'maniskill_dataset_converted_externally_to_rlds', 'furniture_bench_dataset_converted_externally_to_rlds', 'cmu_franka_exploration_dataset_converted_externally_to_rlds', 'ucsd_kitchen_dataset_converted_externally_to_rlds', 'ucsd_pick_and_place_dataset_converted_externally_to_rlds', 'austin_sailor_dataset_converted_externally_to_rlds', 'austin_sirius_dataset_converted_externally_to_rlds', 'bc_z', 'usc_cloth_sim_converted_externally_to_rlds', 'utokyo_pr2_opening_fridge_converted_externally_to_rlds', 'utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds', 'utokyo_saytap_converted_externally_to_rlds', 'utokyo_xarm_pick_and_place_converted_externally_to_rlds', 'utokyo_xarm_bimanual_converted_externally_to_rlds', 'robo_net', 'berkeley_mvp_converted_externally_to_rlds', 'berkeley_rpt_converted_externally_to_rlds', 'kaist_nonprehensile_converted_externally_to_rlds', 'stanford_mask_vit_converted_externally_to_rlds', 'tokyo_u_lsmo_converted_externally_to_rlds', 'dlr_sara_pour_converted_externally_to_rlds', 'dlr_sara_grid_clamp_converted_externally_to_rlds', 'dlr_edan_shared_control_converted_externally_to_rlds', 'asu_table_top_converted_externally_to_rlds', 'stanford_robocook_converted_externally_to_rlds', 'eth_agent_affordances', 'imperialcollege_sawyer_wrist_cam', 'iamlab_cmu_pickup_insert_converted_externally_to_rlds', 'uiuc_d3field', 'utaustin_mutex', 'berkeley_fanuc_manipulation', 'cmu_food_manipulation', 'cmu_play_fusion', 'cmu_stretch', 'berkeley_gnm_recon', 'berkeley_gnm_cory_hall', 'berkeley_gnm_sac_son']\n", - "display_key = \"image\"\n", - "\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "if display_key not in b.info.features[\"steps\"][\"observation\"]:\n", - " raise ValueError(\n", - " f\"The key {display_key} was not found in this dataset.\\n\"\n", - " + \"Please choose a different image key to display for this dataset.\\n\"\n", - " + \"Here is the observation spec:\\n\"\n", - " + str(b.info.features[\"steps\"][\"observation\"])\n", - " )\n", - "\n", - "ds = b.as_dataset(split=\"train[:10]\").shuffle(10) # take only first 10 episodes\n", - "episode = next(iter(ds))\n", - "images = [step[\"observation\"][display_key] for step in episode[\"steps\"]]\n", - "images = [Image.fromarray(image.numpy()) for image in images]\n", - "display.Image(as_gif(images))" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "YrD4_8P9JxBw", - "outputId": "6c4bcf5f-b738-472c-d084-9c87f56962c8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('action', {'base_displacement_vector': , 'base_displacement_vertical_rotation': , 'gripper_closedness_action': , 'rotation_delta': , 'terminate_episode': , 'world_vector': })\n", - "('is_first', )\n", - "('is_last', )\n", - "('is_terminal', )\n", - "('observation', {'base_pose_tool_reached': , 'gripper_closed': , 'gripper_closedness_commanded': , 'height_to_bottom': , 'image': , 'natural_language_embedding': , 'natural_language_instruction': , 'orientation_box': , 'orientation_start': , 'robot_orientation_positions_box': , 'rotation_delta_to_go': , 'src_rotation': , 'vector_to_go': , 'workspace_bounds': })\n", - "('reward', )\n" - ] - } - ], - "source": [ - "# other elements of the episode step --> this may vary for each dataset\n", - "for elem in next(iter(episode[\"steps\"])).items():\n", - " print(elem)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-WHN-2OrKqGo" - }, - "source": [ - "# Download Datasets\n", - "\n", - "All datasets can be downloaded simply via `tfds.load()`.\n", - "Below we provide a script that downloads all datasets into `~/tensorflow_datasets` on your local machine. Simply copy the code and run it on your local machine to download the full dataset (XXX TB).\n", - "\n", - "If you want to filter the dataset before download, please refer to\n", - "[this Google Sheet](https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit?usp=sharing). It allows you\n", - "to filter the data by attributes like robot model, number of cameras, type of tasks etc. You can then download only the filtered datasets by pasting the\n", - "dataset list from the spreadsheet into the code below.\n", - "\n", - "The download code will automatically skip any datasets you have previously downloaded." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 617 - }, - "id": "wcsQuLjY7c0o", - "outputId": "43f99670-13d6-4ecc-f58f-263960681bed" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: tfds-nightly in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (4.9.3.dev202310060044)\n", - "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.4.0)\n", - "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.5.0)\n", - "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (8.1.7)\n", - "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.1.8)\n", - "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (1.5.2)\n", - "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.25.0)\n", - "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3)\n", - "Requirement already satisfied: protobuf>=3.20 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (3.20.3)\n", - "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (5.9.0)\n", - "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.29.0)\n", - "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.0)\n", - "Requirement already satisfied: termcolor in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (2.3.0)\n", - "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (0.10.2)\n", - "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (4.65.0)\n", - "Requirement already satisfied: wrapt in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tfds-nightly) (1.14.1)\n", - "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (2023.9.2)\n", - "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (6.1.1)\n", - "Requirement already satisfied: typing_extensions in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (4.6.3)\n", - "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tfds-nightly) (3.17.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2.0.4)\n", - "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (3.4)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (1.26.16)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tfds-nightly) (2023.5.7)\n", - "Requirement already satisfied: six in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from promise->tfds-nightly) (1.16.0)\n", - "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tfds-nightly) (1.61.0)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install tfds-nightly # to get most up-to-date registered datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": { - "id": "XtNplr0AP-ZH" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading 2 datasets to ~/tensorflow_datasets.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:07<00:00, 3.67s/it]\n" - ] - } - ], - "source": [ - "import tensorflow_datasets as tfds\n", - "import tqdm\n", - "\n", - "# optionally replace the DATASET_NAMES below with the list of filtered datasets from the google sheet\n", - "DATASET_NAMES = [\n", - " \"fractal20220817_data\",\n", - " \"kuka\",\n", - " \"bridge\",\n", - " \"taco_play\",\n", - " \"jaco_play\",\n", - " \"berkeley_cable_routing\",\n", - " \"roboturk\",\n", - " \"nyu_door_opening_surprising_effectiveness\",\n", - " \"viola\",\n", - " \"berkeley_autolab_ur5\",\n", - " \"toto\",\n", - " \"language_table\",\n", - " \"columbia_cairlab_pusht_real\",\n", - " \"stanford_kuka_multimodal_dataset_converted_externally_to_rlds\",\n", - " \"nyu_rot_dataset_converted_externally_to_rlds\",\n", - " \"stanford_hydra_dataset_converted_externally_to_rlds\",\n", - " \"austin_buds_dataset_converted_externally_to_rlds\",\n", - " \"nyu_franka_play_dataset_converted_externally_to_rlds\",\n", - " \"maniskill_dataset_converted_externally_to_rlds\",\n", - " \"furniture_bench_dataset_converted_externally_to_rlds\",\n", - " \"cmu_franka_exploration_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_kitchen_dataset_converted_externally_to_rlds\",\n", - " \"ucsd_pick_and_place_dataset_converted_externally_to_rlds\",\n", - " \"austin_sailor_dataset_converted_externally_to_rlds\",\n", - " \"austin_sirius_dataset_converted_externally_to_rlds\",\n", - " \"bc_z\",\n", - " \"usc_cloth_sim_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_opening_fridge_converted_externally_to_rlds\",\n", - " \"utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds\",\n", - " \"utokyo_saytap_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_pick_and_place_converted_externally_to_rlds\",\n", - " \"utokyo_xarm_bimanual_converted_externally_to_rlds\",\n", - " \"robo_net\",\n", - " \"berkeley_mvp_converted_externally_to_rlds\",\n", - " \"berkeley_rpt_converted_externally_to_rlds\",\n", - " \"kaist_nonprehensile_converted_externally_to_rlds\",\n", - " \"stanford_mask_vit_converted_externally_to_rlds\",\n", - " \"tokyo_u_lsmo_converted_externally_to_rlds\",\n", - " \"dlr_sara_pour_converted_externally_to_rlds\",\n", - " \"dlr_sara_grid_clamp_converted_externally_to_rlds\",\n", - " \"dlr_edan_shared_control_converted_externally_to_rlds\",\n", - " \"asu_table_top_converted_externally_to_rlds\",\n", - " \"stanford_robocook_converted_externally_to_rlds\",\n", - " \"eth_agent_affordances\",\n", - " \"imperialcollege_sawyer_wrist_cam\",\n", - " \"iamlab_cmu_pickup_insert_converted_externally_to_rlds\",\n", - " \"uiuc_d3field\",\n", - " \"utaustin_mutex\",\n", - " \"berkeley_fanuc_manipulation\",\n", - " \"cmu_food_manipulation\",\n", - " \"cmu_play_fusion\",\n", - " \"cmu_stretch\",\n", - " \"berkeley_gnm_recon\",\n", - " \"berkeley_gnm_cory_hall\",\n", - " \"berkeley_gnm_sac_son\",\n", - "]\n", - "DATASET_NAMES = [\"fractal20220817_data\", \"bc_z\"]\n", - "DOWNLOAD_DIR = \"~/tensorflow_datasets\"\n", - "\n", - "print(f\"Downloading {len(DATASET_NAMES)} datasets to {DOWNLOAD_DIR}.\")\n", - "for dataset_name in tqdm.tqdm(DATASET_NAMES):\n", - " b = tfds.builder_from_directory(builder_dir=dataset2path(dataset_name))\n", - " b.download_and_prepare(download_dir=DOWNLOAD_DIR)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IyccDsRqwtMz" - }, - "source": [ - "# Data Loader Example\n", - "\n", - "Below, we demonstrate a simple example of how to load the dataset into training batches, where each sample in the batch only contains one step." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "id": "X17VECdRwzka" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "import tensorflow_datasets as tfds\n", - "\n", - "# load raw dataset --> replace this with tfds.load() on your\n", - "# local machine!\n", - "dataset = \"fractal20220817_data\"\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "ds = b.as_dataset(split=\"train[:10]\")\n", - "\n", - "\n", - "def episode2steps(episode):\n", - " return episode[\"steps\"]\n", - "\n", - "\n", - "def step_map_fn(step):\n", - " return {\n", - " \"observation\": {\n", - " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", - " },\n", - " \"action\": tf.concat(\n", - " [\n", - " step[\"action\"][\"world_vector\"],\n", - " step[\"action\"][\"rotation_delta\"],\n", - " step[\"action\"][\"gripper_closedness_action\"],\n", - " ],\n", - " axis=-1,\n", - " ),\n", - " }\n", - "\n", - "\n", - "# convert RLDS episode dataset to individual steps & reformat\n", - "ds = ds.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", - "ds = ds.map(step_map_fn, num_parallel_calls=tf.data.AUTOTUNE)\n", - "\n", - "# shuffle, repeat, pre-fetch, batch\n", - "ds = ds.cache() # optionally keep full dataset in memory\n", - "ds = ds.shuffle(100) # set shuffle buffer size\n", - "ds = ds.repeat() # ensure that data never runs out" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "t0uJH3X6w1LZ", - "outputId": "a42005e8-1072-4203-e6ba-b56784971175" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "0it [00:00, ?it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "10000it [00:05, 1955.09it/s]\n" - ] - } - ], - "source": [ - "import tqdm\n", - "\n", - "for i, batch in tqdm.tqdm(enumerate(ds.prefetch(3).batch(4).as_numpy_iterator())):\n", - " # here you would add your Jax / PyTorch training code\n", - " if i == 10000:\n", - " break" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ekmsGRAnw3Bp" - }, - "source": [ - "# Interleave Multiple Datasets\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "id": "CslwEuBZwmLP" - }, - "outputs": [], - "source": [ - "# Load second dataset --> replace this with tfds.load() on your\n", - "# local machine!\n", - "dataset = \"bc_z\"\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "ds2 = b.as_dataset(split=\"train[:10]\")\n", - "\n", - "\n", - "def step_map_fn_mutex(step):\n", - " # reformat to align specs of both datasets\n", - " return {\n", - " \"observation\": {\n", - " \"image\": tf.image.resize(step[\"observation\"][\"image\"], (128, 128)),\n", - " },\n", - " \"action\": tf.random.uniform(shape=(7,), dtype=tf.float32, name=None),\n", - " }\n", - "\n", - "\n", - "ds2 = ds2.map(episode2steps, num_parallel_calls=tf.data.AUTOTUNE).flat_map(lambda x: x)\n", - "ds2 = ds2.map(step_map_fn_mutex, num_parallel_calls=tf.data.AUTOTUNE)\n", - "\n", - "# shuffle, repeat, pre-fetch, batch\n", - "ds2 = ds2.cache() # optionally keep full dataset in memory\n", - "ds2 = ds2.shuffle(100) # set shuffle buffer size\n", - "ds2 = ds2.repeat() # ensure that data never runs out" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "id": "G2hcCJd8w6-D" - }, - "outputs": [], - "source": [ - "# interleave datasets w/ equal sampling weight\n", - "ds_combined = tf.data.Dataset.sample_from_datasets([ds, ds2], [0.5, 0.5])" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "hEnVFP9nw8iI", - "outputId": "68567be3-9c3b-46c2-d569-f999c900f03c" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "10000it [00:06, 1546.22it/s]\n" - ] - } - ], - "source": [ - "import tqdm\n", - "\n", - "for i, batch in tqdm.tqdm(\n", - " enumerate(ds_combined.prefetch(3).batch(4).as_numpy_iterator())\n", - "):\n", - " # here you would add your Jax / PyTorch training code\n", - " if i == 10000:\n", - " break" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aew258oUbamg" - }, - "source": [ - "# Example Dataloader to produce trajectories\n", - "\n", - "When training transformers, we usually use trajectories of fix-length as input into the transformers. This is to enable the transformer to condition on a fixed window of history when predicting actions.\n", - "\n", - "Below we demonstrate how one can load the TFDS datasets, transform the episodes\n", - "into fixed-length \"trajectories\" and mix multiple datasets by aligning their specs." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "id": "YU0qKdrp7oBT" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: rlds[tensorflow] in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (0.1.8)\n", - "Requirement already satisfied: absl-py in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.4.0)\n", - "Requirement already satisfied: numpy in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (1.25.0)\n", - "Requirement already satisfied: tensorflow in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (2.14.0)\n", - "Requirement already satisfied: tensorflow-datasets in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (4.9.3)\n", - "Requirement already satisfied: dm-reverb in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from rlds[tensorflow]) (0.13.0)\n", - "Requirement already satisfied: dm-tree in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (0.1.8)\n", - "Requirement already satisfied: portpicker in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from dm-reverb->rlds[tensorflow]) (1.6.0)\n", - "Requirement already satisfied: astunparse>=1.6.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.6.3)\n", - "Requirement already satisfied: flatbuffers>=23.5.26 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.5.26)\n", - "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.5.4)\n", - "Requirement already satisfied: google-pasta>=0.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", - "Requirement already satisfied: h5py>=2.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.10.0)\n", - "Requirement already satisfied: libclang>=13.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (16.0.6)\n", - "Requirement already satisfied: ml-dtypes==0.2.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.2.0)\n", - "Requirement already satisfied: opt-einsum>=2.3.2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.3.0)\n", - "Requirement already satisfied: packaging in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (23.0)\n", - "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (3.20.3)\n", - "Requirement already satisfied: setuptools in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (67.8.0)\n", - "Requirement already satisfied: six>=1.12.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.16.0)\n", - "Requirement already satisfied: termcolor>=1.1.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.3.0)\n", - "Requirement already satisfied: typing-extensions>=3.6.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (4.6.3)\n", - "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.14.1)\n", - "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (0.34.0)\n", - "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (1.59.2)\n", - "Requirement already satisfied: tensorboard<2.15,>=2.14 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.1)\n", - "Requirement already satisfied: tensorflow-estimator<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", - "Requirement already satisfied: keras<2.15,>=2.14.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow->rlds[tensorflow]) (2.14.0)\n", - "Requirement already satisfied: array-record in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.5.0)\n", - "Requirement already satisfied: click in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (8.1.7)\n", - "Requirement already satisfied: etils>=0.9.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (1.5.2)\n", - "Requirement already satisfied: promise in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.3)\n", - "Requirement already satisfied: psutil in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (5.9.0)\n", - "Requirement already satisfied: requests>=2.19.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (2.29.0)\n", - "Requirement already satisfied: tensorflow-metadata in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (1.14.0)\n", - "Requirement already satisfied: toml in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (0.10.2)\n", - "Requirement already satisfied: tqdm in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-datasets->rlds[tensorflow]) (4.65.0)\n", - "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow->rlds[tensorflow]) (0.38.4)\n", - "Requirement already satisfied: fsspec in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (2023.9.2)\n", - "Requirement already satisfied: importlib_resources in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (6.1.1)\n", - "Requirement already satisfied: zipp in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets->rlds[tensorflow]) (3.17.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2.0.4)\n", - "Requirement already satisfied: idna<4,>=2.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (3.4)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (1.26.16)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests>=2.19.0->tensorflow-datasets->rlds[tensorflow]) (2023.5.7)\n", - "Requirement already satisfied: google-auth<3,>=1.6.3 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.23.4)\n", - "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.0.0)\n", - "Requirement already satisfied: markdown>=2.6.8 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.5.1)\n", - "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.7.2)\n", - "Requirement already satisfied: werkzeug>=1.0.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.0.1)\n", - "Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from tensorflow-metadata->tensorflow-datasets->rlds[tensorflow]) (1.61.0)\n", - "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (5.3.2)\n", - "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.3.0)\n", - "Requirement already satisfied: rsa<5,>=3.1.4 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (4.9)\n", - "Requirement already satisfied: requests-oauthlib>=0.7.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (1.3.1)\n", - "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (2.1.1)\n", - "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (0.5.0)\n", - "Requirement already satisfied: oauthlib>=3.0.0 in /home/rohan/miniconda3/envs/mllib/lib/python3.10/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.15,>=2.14->tensorflow->rlds[tensorflow]) (3.2.2)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install rlds[tensorflow]" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "id": "N3b5BEt1JvQJ" - }, - "outputs": [], - "source": [ - "from typing import Any, Dict, Union, NamedTuple\n", - "\n", - "import numpy as np\n", - "import tensorflow_datasets as tfds\n", - "import rlds\n", - "import reverb\n", - "from rlds import transformations\n", - "import tensorflow_datasets as tfds\n", - "import tree\n", - "\n", - "import abc\n", - "import dataclasses\n", - "from typing import Dict, Optional\n", - "\n", - "from rlds import rlds_types\n", - "import tensorflow as tf\n", - "from PIL import Image\n", - "from IPython import display" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "cellView": "form", - "id": "Dgf1OxIhJwib" - }, - "outputs": [], - "source": [ - "# @title Transformation definitions\n", - "\n", - "\n", - "def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec:\n", - " \"\"\"Converts a tfds Feature into a TensorSpec.\"\"\"\n", - "\n", - " def _get_feature_spec(nested_feature: tfds.features.FeatureConnector):\n", - " if isinstance(nested_feature, tf.DType):\n", - " return tf.TensorSpec(shape=(), dtype=nested_feature)\n", - " else:\n", - " return nested_feature.get_tensor_spec()\n", - "\n", - " # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to\n", - " # make sure we deal with the nested structure.\n", - " return tf.nest.map_structure(_get_feature_spec, feature)\n", - "\n", - "\n", - "def _encoded_feature(\n", - " feature: Optional[tfds.features.FeatureConnector],\n", - " image_encoding: Optional[str],\n", - " tensor_encoding: Optional[tfds.features.Encoding],\n", - "):\n", - " \"\"\"Adds encoding to Images and/or Tensors.\"\"\"\n", - "\n", - " def _apply_encoding(\n", - " feature: tfds.features.FeatureConnector,\n", - " image_encoding: Optional[str],\n", - " tensor_encoding: Optional[tfds.features.Encoding],\n", - " ):\n", - " if image_encoding and isinstance(feature, tfds.features.Image):\n", - " return tfds.features.Image(\n", - " shape=feature.shape,\n", - " dtype=feature.dtype,\n", - " use_colormap=feature.use_colormap,\n", - " encoding_format=image_encoding,\n", - " )\n", - " if (\n", - " tensor_encoding\n", - " and isinstance(feature, tfds.features.Tensor)\n", - " and feature.dtype != tf.string\n", - " ):\n", - " return tfds.features.Tensor(\n", - " shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding\n", - " )\n", - " return feature\n", - "\n", - " if not feature:\n", - " return None\n", - " return tf.nest.map_structure(\n", - " lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature\n", - " )\n", - "\n", - "\n", - "@dataclasses.dataclass\n", - "class RLDSSpec(metaclass=abc.ABCMeta):\n", - " \"\"\"Specification of an RLDS Dataset.\n", - "\n", - " It is used to hold a spec that can be converted into a TFDS DatasetInfo or\n", - " a `tf.data.Dataset` spec.\n", - " \"\"\"\n", - "\n", - " observation_info: Optional[tfds.features.FeatureConnector] = None\n", - " action_info: Optional[tfds.features.FeatureConnector] = None\n", - " reward_info: Optional[tfds.features.FeatureConnector] = None\n", - " discount_info: Optional[tfds.features.FeatureConnector] = None\n", - " step_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", - " episode_metadata_info: Optional[tfds.features.FeaturesDict] = None\n", - "\n", - " def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", - " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", - " step = {}\n", - " if self.observation_info:\n", - " step[rlds_types.OBSERVATION] = _features_to_tensor_spec(\n", - " self.observation_info\n", - " )\n", - " if self.action_info:\n", - " step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info)\n", - " if self.discount_info:\n", - " step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info)\n", - " if self.reward_info:\n", - " step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info)\n", - " if self.step_metadata_info:\n", - " for k, v in self.step_metadata_info.items():\n", - " step[k] = _features_to_tensor_spec(v)\n", - "\n", - " step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool)\n", - " step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool)\n", - " step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool)\n", - " return step\n", - "\n", - " def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]:\n", - " \"\"\"Obtains the TensorSpec of an RLDS step.\"\"\"\n", - " episode = {}\n", - " episode[rlds_types.STEPS] = tf.data.DatasetSpec(\n", - " element_spec=self.step_tensor_spec()\n", - " )\n", - " if self.episode_metadata_info:\n", - " for k, v in self.episode_metadata_info.items():\n", - " episode[k] = _features_to_tensor_spec(v)\n", - " return episode\n", - "\n", - " def to_dataset_config(\n", - " self,\n", - " name: str,\n", - " image_encoding: Optional[str] = None,\n", - " tensor_encoding: Optional[tfds.features.Encoding] = None,\n", - " citation: Optional[str] = None,\n", - " homepage: Optional[str] = None,\n", - " description: Optional[str] = None,\n", - " overall_description: Optional[str] = None,\n", - " ) -> tfds.rlds.rlds_base.DatasetConfig:\n", - " \"\"\"Obtains the DatasetConfig for TFDS from the Spec.\"\"\"\n", - " return tfds.rlds.rlds_base.DatasetConfig(\n", - " name=name,\n", - " description=description,\n", - " overall_description=overall_description,\n", - " homepage=homepage,\n", - " citation=citation,\n", - " observation_info=_encoded_feature(\n", - " self.observation_info, image_encoding, tensor_encoding\n", - " ),\n", - " action_info=_encoded_feature(\n", - " self.action_info, image_encoding, tensor_encoding\n", - " ),\n", - " reward_info=_encoded_feature(\n", - " self.reward_info, image_encoding, tensor_encoding\n", - " ),\n", - " discount_info=_encoded_feature(\n", - " self.discount_info, image_encoding, tensor_encoding\n", - " ),\n", - " step_metadata_info=_encoded_feature(\n", - " self.step_metadata_info, image_encoding, tensor_encoding\n", - " ),\n", - " episode_metadata_info=_encoded_feature(\n", - " self.episode_metadata_info, image_encoding, tensor_encoding\n", - " ),\n", - " )\n", - "\n", - " def to_features_dict(self):\n", - " \"\"\"Returns a TFDS FeaturesDict representing the dataset config.\"\"\"\n", - " step_config = {\n", - " rlds_types.IS_FIRST: tf.bool,\n", - " rlds_types.IS_LAST: tf.bool,\n", - " rlds_types.IS_TERMINAL: tf.bool,\n", - " }\n", - "\n", - " if self.observation_info:\n", - " step_config[rlds_types.OBSERVATION] = self.observation_info\n", - " if self.action_info:\n", - " step_config[rlds_types.ACTION] = self.action_info\n", - " if self.discount_info:\n", - " step_config[rlds_types.DISCOUNT] = self.discount_info\n", - " if self.reward_info:\n", - " step_config[rlds_types.REWARD] = self.reward_info\n", - "\n", - " if self.step_metadata_info:\n", - " for k, v in self.step_metadata_info.items():\n", - " step_config[k] = v\n", - "\n", - " if self.episode_metadata_info:\n", - " return tfds.features.FeaturesDict(\n", - " {\n", - " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", - " **self.episode_metadata_info,\n", - " }\n", - " )\n", - " else:\n", - " return tfds.features.FeaturesDict(\n", - " {\n", - " rlds_types.STEPS: tfds.features.Dataset(step_config),\n", - " }\n", - " )\n", - "\n", - "\n", - "RLDS_SPEC = RLDSSpec\n", - "TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]]\n", - "\n", - "\n", - "@dataclasses.dataclass\n", - "class TrajectoryTransform(metaclass=abc.ABCMeta):\n", - " \"\"\"Specification the TrajectoryTransform applied to a dataset of episodes.\n", - "\n", - " A TrajectoryTransform is a set of rules transforming a dataset\n", - " of RLDS episodes to a dataset of trajectories.\n", - " This involves three distinct stages:\n", - " - An optional `episode_to_steps_map_fn(episode)` is called at the episode\n", - " level, and can be used to select or modify steps.\n", - " - Augmentation: an `episode_key` could be propagated to `steps` for\n", - " debugging.\n", - " - Selection: Particular steps can be selected.\n", - " - Stripping: Features can be removed from steps. Prefer using `step_map_fn`.\n", - " - An optional `step_map_fn` is called at the flattened steps dataset for each\n", - " step, and can be used to featurize a step, e.g. add/remove features, or\n", - " augument images\n", - " - A `pattern` leverages DM patterns to set a rule of slicing an episode to a\n", - " dataset of overlapping trajectories.\n", - "\n", - " Importantly, each TrajectoryTransform must define a `expected_tensor_spec`\n", - " which specifies a nested TensorSpec of the resulting dataset. This is what\n", - " this TrajectoryTransform will produce, and can be used as an interface with\n", - " a neural network.\n", - " \"\"\"\n", - "\n", - " episode_dataset_spec: RLDS_SPEC\n", - " episode_to_steps_fn_dataset_spec: RLDS_SPEC\n", - " steps_dataset_spec: Any\n", - " pattern: reverb.structured_writer.Pattern\n", - " episode_to_steps_map_fn: Any\n", - " expected_tensor_spec: TENSOR_SPEC\n", - " step_map_fn: Optional[Any] = None\n", - "\n", - " def get_for_cached_trajectory_transform(self):\n", - " \"\"\"Creates a copy of this traj transform to use with caching.\n", - "\n", - " The returned TrajectoryTransfrom copy will be initialized with the default\n", - " version of the `episode_to_steps_map_fn`, because the effect of that\n", - " function has already been materialized in the cached copy of the dataset.\n", - " Returns:\n", - " trajectory_transform: A copy of the TrajectoryTransform with overridden\n", - " `episode_to_steps_map_fn`.\n", - " \"\"\"\n", - " traj_copy = dataclasses.replace(self)\n", - " traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec\n", - " traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS]\n", - " return traj_copy\n", - "\n", - " def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset):\n", - " \"\"\"Applies this TrajectoryTransform to the dataset of episodes.\"\"\"\n", - "\n", - " # Convert the dataset of episodes to the dataset of steps.\n", - " steps_dataset = episodes_dataset.map(\n", - " self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE\n", - " ).flat_map(lambda x: x)\n", - "\n", - " return self._create_pattern_dataset(steps_dataset)\n", - "\n", - " def transform_steps_rlds_dataset(\n", - " self, steps_dataset: tf.data.Dataset\n", - " ) -> tf.data.Dataset:\n", - " \"\"\"Applies this TrajectoryTransform to the dataset of episode steps.\"\"\"\n", - "\n", - " return self._create_pattern_dataset(steps_dataset)\n", - "\n", - " def create_test_dataset(\n", - " self,\n", - " ) -> tf.data.Dataset:\n", - " \"\"\"Creates a test dataset of trajectories.\n", - "\n", - " It is guaranteed that the structure of this dataset will be the same as\n", - " when flowing real data. Hence this is a useful construct for tests or\n", - " initialization of JAX models.\n", - " Returns:\n", - " dataset: A test dataset made of zeros structurally identical to the\n", - " target dataset of trajectories.\n", - " \"\"\"\n", - " zeros = transformations.zeros_from_spec(self.expected_tensor_spec)\n", - "\n", - " return tf.data.Dataset.from_tensors(zeros)\n", - "\n", - " def _create_pattern_dataset(\n", - " self, steps_dataset: tf.data.Dataset\n", - " ) -> tf.data.Dataset:\n", - " \"\"\"Create PatternDataset from the `steps_dataset`.\"\"\"\n", - " config = create_structured_writer_config(\"temp\", self.pattern)\n", - "\n", - " # Further transform each step if the `step_map_fn` is provided.\n", - " if self.step_map_fn:\n", - " steps_dataset = steps_dataset.map(self.step_map_fn)\n", - " pattern_dataset = reverb.PatternDataset(\n", - " input_dataset=steps_dataset,\n", - " configs=[config],\n", - " respect_episode_boundaries=True,\n", - " is_end_of_episode=lambda x: x[rlds_types.IS_LAST],\n", - " )\n", - " return pattern_dataset\n", - "\n", - "\n", - "class TrajectoryTransformBuilder(object):\n", - " \"\"\"Facilitates creation of the `TrajectoryTransform`.\"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " dataset_spec: RLDS_SPEC,\n", - " episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS],\n", - " step_map_fn=None,\n", - " pattern_fn=None,\n", - " expected_tensor_spec=None,\n", - " ):\n", - " self._rds_dataset_spec = dataset_spec\n", - " self._steps_spec = None\n", - " self._episode_to_steps_map_fn = episode_to_steps_map_fn\n", - " self._step_map_fn = step_map_fn\n", - " self._pattern_fn = pattern_fn\n", - " self._expected_tensor_spec = expected_tensor_spec\n", - "\n", - " def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform:\n", - " \"\"\"Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.\"\"\"\n", - "\n", - " if validate_expected_tensor_spec and self._expected_tensor_spec is None:\n", - " raise ValueError(\"`expected_tensor_spec` must be set.\")\n", - "\n", - " episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec)\n", - "\n", - " steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn)\n", - "\n", - " episode_to_steps_fn_dataset_spec = self._rds_dataset_spec\n", - "\n", - " if self._step_map_fn is not None:\n", - " steps_ds = steps_ds.map(self._step_map_fn)\n", - "\n", - " zeros_spec = transformations.zeros_from_spec(\n", - " steps_ds.element_spec\n", - " ) # pytype: disable=wrong-arg-types\n", - "\n", - " ref_step = reverb.structured_writer.create_reference_step(zeros_spec)\n", - "\n", - " pattern = self._pattern_fn(ref_step)\n", - "\n", - " steps_ds_spec = steps_ds.element_spec\n", - "\n", - " target_tensor_structure = create_reverb_table_signature(\n", - " \"temp_table\", steps_ds_spec, pattern\n", - " )\n", - "\n", - " if (\n", - " validate_expected_tensor_spec\n", - " and self._expected_tensor_spec != target_tensor_structure\n", - " ):\n", - " raise RuntimeError(\n", - " \"The tensor spec of the TrajectoryTransform doesn't \"\n", - " \"match the expected spec.\\n\"\n", - " \"Expected:\\n%s\\nActual:\\n%s\\n\"\n", - " % (\n", - " str(self._expected_tensor_spec).replace(\n", - " \"TensorSpec\", \"tf.TensorSpec\"\n", - " ),\n", - " str(target_tensor_structure).replace(\"TensorSpec\", \"tf.TensorSpec\"),\n", - " )\n", - " )\n", - "\n", - " return TrajectoryTransform(\n", - " episode_dataset_spec=self._rds_dataset_spec,\n", - " episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec,\n", - " steps_dataset_spec=steps_ds_spec,\n", - " pattern=pattern,\n", - " episode_to_steps_map_fn=self._episode_to_steps_map_fn,\n", - " step_map_fn=self._step_map_fn,\n", - " expected_tensor_spec=target_tensor_structure,\n", - " )\n", - "\n", - "\n", - "def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC):\n", - " \"\"\"Creates a zero valued dataset of episodes for the given RLDS Spec.\"\"\"\n", - "\n", - " def add_steps(episode, step_spec):\n", - " episode[rlds_types.STEPS] = transformations.zero_dataset_like(\n", - " tf.data.DatasetSpec(step_spec)\n", - " )\n", - " if \"fake\" in episode:\n", - " del episode[\"fake\"]\n", - " return episode\n", - "\n", - " episode_without_steps_spec = {\n", - " k: v\n", - " for k, v in rlds_spec.episode_tensor_spec().items()\n", - " if k != rlds_types.STEPS\n", - " }\n", - "\n", - " if episode_without_steps_spec:\n", - " episodes_dataset = transformations.zero_dataset_like(\n", - " tf.data.DatasetSpec(episode_without_steps_spec)\n", - " )\n", - " else:\n", - " episodes_dataset = tf.data.Dataset.from_tensors({\"fake\": \"\"})\n", - "\n", - " episodes_dataset_with_steps = episodes_dataset.map(\n", - " lambda episode: add_steps(episode, rlds_spec.step_tensor_spec())\n", - " )\n", - " return episodes_dataset_with_steps\n", - "\n", - "\n", - "def create_reverb_table_signature(\n", - " table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern\n", - ") -> reverb.reverb_types.SpecNest:\n", - " config = create_structured_writer_config(table_name, pattern)\n", - " reverb_table_spec = reverb.structured_writer.infer_signature(\n", - " [config], steps_dataset_spec\n", - " )\n", - " return reverb_table_spec\n", - "\n", - "\n", - "def create_structured_writer_config(\n", - " table_name: str, pattern: reverb.structured_writer.Pattern\n", - ") -> Any:\n", - " config = reverb.structured_writer.create_config(\n", - " pattern=pattern, table=table_name, conditions=[]\n", - " )\n", - " return config\n", - "\n", - "\n", - "def n_step_pattern_builder(n: int) -> Any:\n", - " \"\"\"Creates trajectory of length `n` from all fields of a `ref_step`.\"\"\"\n", - "\n", - " def transform_fn(ref_step):\n", - " traj = {}\n", - " for key in ref_step:\n", - " if isinstance(ref_step[key], dict):\n", - " transformed_entry = tree.map_structure(\n", - " lambda ref_node: ref_node[-n:], ref_step[key]\n", - " )\n", - " traj[key] = transformed_entry\n", - " else:\n", - " traj[key] = ref_step[key][-n:]\n", - "\n", - " return traj\n", - "\n", - " return transform_fn" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BK4RRYkbLN5B" - }, - "source": [ - "## Demonstration of transformation from an episode to a trajectory\n", - "\n", - "A real ML pipeline would rarely learn from a whole episode. Instead the input to a model is a _trajectory_. A `Trajectory` is a particular way to slice a sequence of episode steps. `SARSA` trajectory is one well known example, but a trajectory of an arbitrary length `n` is also an option. Often, a set of _overlapping_ trajectories is produced from an episode. For example, given the following episode steps:\n", - "\n", - "`episode=[s_0, s_1, s_2, s_3, s_4, s_T]`\n", - "\n", - "and a target Trajectory of length `3`, the following trajectories are produced:\n", - "\n", - "`t_1=[s_0, s_1, s_2]`\n", - "\n", - "`t_2=[s_1, s_2, s_3]`\n", - "\n", - "`t_3=[s_2, s_3, s_4]`\n", - "\n", - "`t_4=[s_3, s_4, s_T]`\n", - "\n", - "\n", - "To perform such a slicing, the dataset of episode is first \"flattened\" to the dataset of steps. The `is_last` attribute of an RLDS step allows proper slicing, not crossing the episode boundary. The `TrajectoryTransformBuilder` demonstrates this:" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "id": "_NsYnqnpNgNl" - }, - "outputs": [], - "source": [ - "import tensorflow_datasets as tfds\n", - "\n", - "dataset = \"fractal20220817_data\"\n", - "b = tfds.builder_from_directory(builder_dir=dataset2path(dataset))\n", - "ds = b.as_dataset(split=\"train[:10]\")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "id": "2qvMcpGDx6hJ" - }, - "outputs": [], - "source": [ - "# The RLDSSpec for the RT1 dataset.\n", - "rt1_spec = RLDSSpec(\n", - " observation_info=b.info.features[\"steps\"][\"observation\"],\n", - " action_info=b.info.features[\"steps\"][\"action\"],\n", - ")\n", - "\n", - "# The following will create a trajectories of length 3.\n", - "trajectory_length = 3\n", - "trajectory_transform = TrajectoryTransformBuilder(\n", - " rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length)\n", - ").build(validate_expected_tensor_spec=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "id": "Fk4ZfC_bMBw3" - }, - "outputs": [], - "source": [ - "trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds)\n", - "\n", - "trajectory_iter = iter(trajectory_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "id": "fSxk3zF_x0FS" - }, - "outputs": [], - "source": [ - "trajectory = next(trajectory_iter)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "t2V0xrIVMWNc", - "outputId": "5c71d7ef-2fc7-424e-a8ae-0e1c60252f42" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'action': {'base_displacement_vector': ,\n", - " 'gripper_closedness_action': ,\n", - " 'world_vector': ,\n", - " 'rotation_delta': ,\n", - " 'base_displacement_vertical_rotation': ,\n", - " 'terminate_episode': },\n", - " 'is_first': ,\n", - " 'is_last': ,\n", - " 'observation': {'robot_orientation_positions_box': ,\n", - " 'workspace_bounds': ,\n", - " 'natural_language_instruction': ,\n", - " 'image': ,\n", - " 'src_rotation': ,\n", - " 'orientation_box': ,\n", - " 'height_to_bottom': ,\n", - " 'vector_to_go': ,\n", - " 'rotation_delta_to_go': ,\n", - " 'gripper_closedness_commanded': ,\n", - " 'orientation_start': ,\n", - " 'gripper_closed': ,\n", - " 'base_pose_tool_reached': ,\n", - " 'natural_language_embedding': },\n", - " 'is_terminal': }" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "trajectory" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ytrvi945NTZz", - "outputId": "50dd5318-7521-4d85-a1cf-42aa046ce4c3" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "TensorShape([3, 256, 320, 3])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Note that the leading dimension (3) corresponds to the trajectory_length\n", - "trajectory[\"observation\"][\"image\"].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 529 - }, - "id": "xhDX3BcWNmrl", - "outputId": "0d4c3c74-7d71-45e3-baea-c5f119eea9a4" - }, - "outputs": [ - { - "data": { - "image/png": "R0lGODlhQAEAAYcAAOKvfsqefcSWcbmUd76PaLiPb7eObrWNbrGNcbqJYLSJabKKa7KJZ6+Iaq+IZquIbLqET7WDU7KEX7CEZLCCXq2FZq2DZa2CYK2AXqqEZ6qCY6qBYKeDaaOCaKaBYqeAXrV+SbF8SK1+Wap+Xqp+Wqp7Wad/YKd+X6d+XKd7Wqd4V6R+YaR8XqR8W6N7WqN5WqN4WqR4VqB9YqB7YZ96YJ98XqB6XJ95XqB4WqB4V593Vp17X515Xp14XZx3XJt5XZt3XJh4XqZ1T6F1VJ91VZ11V510U5t2XJp1W5t0VZt0Upl2W5h1WZh0W5Z1W5dzW5d0WJZzV5d0VaBxTptxUZlxUplxT5dyWZdwUJVyWZVwWZVxV5VxUplvTZZvT5lrRpRuUJRrS5JyWJJvVJJtUpJsTJJrTZJqS5FpS5FpSI5vVo5rUI5qTIltVolpUY5oSo5nR4hnTo5mSIxlR4xlRIhlTIllRYpiRIpiQIdhQ4VkToVjR4RgRoVgQIFjS4FgRn9hSXthS4ZdPoNcP4FcP39cQn5ZPXtcRntcQnpZQXZaRXZYQnxWOXZWPnJVQXJUPHVRN29RPHFONXBKLWtSP2lPPGpOOmlNOmpMN2RLOmdJNmlIL2NINV5IN2JFMmZDKV5DMV5ALlxBL1dBMV4+KVs+LVo+LFk9LFc9LVM9Llc9KlU8Klk7KFY6KVU6KVI6K1M5J1M4JlI0IU05Kkw1JU0zIkczJEkxIEguHEIuHz4tHkAoFz4kEzslFjcmFzciEzIjFjEgEjMdDS4cDikcDycaDScZDCwVBiYVCCMXCyMTBh8WCh4UCh4TCBkSCB0RBhcQBxwOAxcOBBINBRoJABUIARIHAQ8KAw8FAA0KBAwJAg0IAwwFAQsKBAoJBAsIAQsGAwoHAAoDAAkKAgkJAgkIAgYIAQcHAQYHAQgGAQkGAAUGAAMGAQgFAAYFAAUEAQQEAgQFAAMEAAIEAQcDAAQDAAcAAAQAAAMCAAMAAAEDAAIBAAABAAIAAQEAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQAZAAAACwAAAAAQAEAAQAI/wCTLSuW7Fmyg8WMHTRWjBixZMaG/eLVppKyZ9CkLYsW7ZkzZs5CgmzmK5UxZMQUCizG0pjLZM2kOZMmrVk0YJ0ycdLkaZNPTJV8ecxozVrIoyCdQcsoMyQ0pMyWHQRGtSqwYFexWt3Klauvr1+7UtUKjFhZh1SXNVP6FBu2aNR0VYr0aNGiSJky6aIXjxw0h8SeEWPJ8uDCYljJBvP1q/GvXr0eQ578dbLlyI4vZ45s2RdkxpdDQ961CzNkWLhwOTrE2pFrSq+GCQtG+1ewYcgiOlQpFZivYcCNDU4Y8dgwZskIRju47KVLwBBlC8vUJpg0ZsykdfSIHSSzZoJH3f8WTpCwS+HGltGU9qy9sVE6efrcpKmSrWfZr1nDdlSk06VLOdUdUsuY1RVZYiWYIGDBAOYgYMsU6FB21VRzDTb22INNNXJFEskijuCl1z36uHONYdIYpmKEyRCDYFW/fOWYZJjF6BlkNNa4mWmXlSbaj5ORtktjkInCCyuLsHaIa45Ugotjt90GHG1U0uaiLw0OwxBwwxAXETASRrXQeQ0Nk1JEwgiTixiz4AfSMzVBMyB27aWii5ZmtjiYS2YqFJNGzyiDzCw6cdKTT/WNkgwz0BTFn1P+SQOgnEl1114zzBi4FZVWWfmgg2Z+6qBL5i1kWISSIgTNheC0k04+93D/Y40umczlmiV5+WLPPvRkg10yKS6jDHMCDetiVo3R5htjM87YS2WhNesskD6KBm2PpDmWCyq8VKIIa4qESAknvZCG43jGKEalL3fueWYxwAE2C0EPNdNMcsQ5BFxC0v3iSCACOQMTe9EM+BEz0eiSCpddPthnMX+Cd5EuhnLCCaKa5EVMM0QZ1d9RkgKIHXj2lmwvvg0RpnJhKrYskMsqFibVqc0oI1WEUtE00DLTTJPNNuB0Uw89stpCySWVUFLJJXkBY08+7UyDHLAwL+QilVAGYyOzO94YbY1geQ2ktc+KJiRmr6SmyLeK3BVJJbEIU9ouugyJ2zCKTfmsmYSd/3mbvLoMRAwzBgHGJW2HN2ZLG7rcuwxI7GEK6UzIjPIbw5gLt/EzHD1DTTTHiOLJ6KNv4kmtukQzU1FHBbhUU8408zima3383aUlP2PyyNg93t3sJ1e9Is44C8TiUr5Pc002zGcDqzjW2JJXJUtrwkknwdhzjzpSLxqsy7lpbVtjYQFj47PMjv2j2KLFCGSOoZXWGC+o/ALKId/a5SEnuwjz2VfjwRxwhPGL/vFtMPriElpSgUCIKSOBeENcusTni0AoYjm+g0t/MpKRZsxiFhGsEuK4NKyOKENQx3CFJ0BButHVahbgkcZ+JgUgmsROKipTy8dCYkPdkaxk3eldEP/V8sMIye5msnsZ8Yp3xGRkREzScIs1tsENe4iDG9TIRSc4kRdN8GQUw7AHPbABDalkp1gHOeEJ05Usx2AJK+STEfzUR8c6zhEyvMgjL36hJlrwghL4O4RdHvGIVhAQMwAMjgCDsYtcxGs3W4rI34oxC12g5yIJrNKUxPeLVLRBKItyBlxk8hS21CQY4hGhKoPRkPNwCRegiGULmdaJYsykGmR8XQ3ZIyEHFQMkAGLLpCDlkYMFMXa5i50yaWeyki0Dd5ciXjKiUZMIFcUauLSGOLZJDelZz3qeKIVJtmmNMqolWDcTlqAmWJusYW1r7asjHvW4Cz3a8574FFI9hUT/QFrsQhZsS0QjHuEITPTPf5SxzSZj9JhG9kKBDRyMbIahi68wcDh6CiFtjCMM81WmDZlQBjA/hx8a1uQZlhMf3synrKxEqRjAkE0vRCEKUITipp5gWiaCQU0ZOiVkGYmdnhy0KM7RJJiTYw+cRHK7mfxUJmuBk73a4xHdXeqqHakZVZtRjc99JxpX819jSAOLWBoqlqp4BTKuWA1kwmmJM5OkbbTGGV9kJWw7skxDq4WtHo2mF/icCD7vyc9drIIXnlBSIu7iCE8QEKHPmutKK0M3WzhSGApsJZeEwYtI2GJQvkBGbp4RkU1KJE0iFEYn2hAYaXQVG0eFRs84KA1f/9iiNm+s0lypNKU0uQIUoggF6bjYCV9USJu7fJ3AHqI5lSSDGsc9blEqVA3XdjW61M1uNa653e5GF5vg5W53qQHdrlIDG+LA5YZosUVLHC0vnIjFLW5RC1WoIhaxqMVauYEN8kbRGtaVBjXY87l0YVY6aUpwMNLEULORhp761Ce2ImwuCpNGF7kgTYb1KTdcCIMTkXDEIvwAiLWxIo+/yEUudMFiu2KFxRjGcCqUEQ3RivaEVFXGMY6xiSBYDhizWOdJiLFJrRFQhL/AhRhSMeBobHc9T5HteoqRiqvESJW75S2XbkFT4Y7OeqOwBVxwWUM5Fc8hCTEMS/6U3fVISv87n+OInDlCXvLCxb/kNW+d59zT6go4znJ+RoWe4RZqpKITnsBEJEy3wvzWor73rcVnsUkNzj0Dm6LsCEcuogy8HTjBR56N1rAUrcFaJo+X8YyqI8u+IY2mWvI79TFqkeRItG01iQiRh9NEmZgy5GqekXE0aIyMYwgKGcM+oTBIEQUpdMIWx6gkn4RT5AUnC46NUUQgaDzm68zkqM5oTzQquZjcrlLLwNlFTUdnqEuscBTG4Eg5IRUVuIJnOQ4ZGJQDdJSt/nCqurtd7qjqQ0wF0TtLZA52OlihaIxiJ49ohCQwwZP8zncVr4BFLGZhDPIGqj3VBY+4t4MM6SAY1KD/5qO05ofiabV85USCOaotM6Sx3hMWwgiFI9b2LUAAwhO8SPCMcCMo3dovyGpURmmpcQxeaMINUYDCDzoxiscUF3Op1ZqyYrQLWoghF3bGRntoQlXtwEUXsxDfuVUJnGMIYxU49cRO3v0LeYcM3E/5qlLZA6GQ9Qc7TIXrECP0q5bNzGWEP7zL1gIsuIxCE5hohMQtYQlNwOLRtECFxmnB8WSfMDv3onHSBYXy0qecgM1isGN4MZn5TUSwgm35YGfPi3oOFr+4OIQb3NAGNYhBDG0IBR+F0XQUE3/HbidSLhzRi2OXXGuxsMQTEBAABOwACE7oRCdecYxRpD1dLnkn/5ZTvItAUIIjrvWcps3OOWpU7hcSWfuCZ3PgHdeiFKRgNybkvopcwAXA4bYePRUNIndvKZIyHmFDyARwtpMUyrSAURFE9lJvOCM7tKN4KsI508QRoGAJkSB5khAJlacKsAALrmAxKyQKwoAMOpYbyPAMuXESuaElyWd7KDZPevR6oVF7rMd6rXc2PWhPFkYaqZEau5AajyYLSlgLSsgKrEAKrOAJi8ATbfB7QXCFTuAES6I03vItrGFBa/MvFhQIlWBsRScMuNAGAbCGATAAHuABP7ADoNAJKrgLnXAnAcRJLfUL5pNivRALQSAM5AUN7cGCyeZkn9NNubAY8gdqbf93DLtwCjjFCfvnCacQZE/GQzRBTbozEMYgcsPGEMVwEZ2TY+2hDM2URIZhL0qHMgzhHK/4iiwBQVxSWqI1DDp2DB0oCY2QCB7iIZjggWK4hbjwV6UBDCy2YsmIYbcQC6tQgquAca/wCqpwCqeACvJVC7TAebNQgrDwCqswCuI4h9pXjjkxPUlDCepICUwShjsXhjz3GpTgXh8CIh/iBuAiBk5whfwIUpyACh80CqKACq5QgrRwC7kwXxtGfIICHK7QAQDAhgVgASfgARwghxZDC78wCqkgWXgzPpzEGF9hC/XUBqIAXcgREc9niHUWDGknQkWGco8oDKfgRZiACY//YAn7hwrD0HB81jkdIRBy9nw2Mj539Bll4wtzo0+6gAvz9ZTz5ZRQOV/buI34dZUaVwv5RQuXx4SLoAd1UAdqoAd64HOLkAhoSZaA4AdkuHNNojSZoI7v2I48tzZfGAh4GY95UY6xJAriKI6pkAof9EG2UJiWpWLKqAupdm0LNkAHxjA7hmCokAn5dwhZwI/8aAkMSWPxQirnoRDKEAwxOGzHgAtOwIZteAAskAEP8AAyYJNGcgt6gTcDZJQrVze8IAptcAzR4Jhut2OxEAqCyBEaCX8CtFmYg3w6lySH4Ad+sCSg4H/UMCzJMCxk0hAOQSWNtI2oAFyxdI7nmBeZ/4A068iO7wiGa4OX6kmWbdCe7vmev6cG7rl7esAaIFJQiuYGM8ADSHAEu+cGepAIh1AIh6AHbuCcihBLLIQKrzALtjCNDUoLj/aURViERxhhv4B8OzZ6HNqhJ3QMN5Z0NnZCI2pjNuYSJmocvZAJomAJoaAHTxAET0ADO7CPprBjyEYNhodEAiE7BChgwgAIA4CaAoADhNAADaABGTBQriELdggLY4Vy+oQLR/gk9XQLQeAKnOV2acILxzAJIiAAOuCl1OALryAMgzkLgRmYo2COtVIJoFAJ/0KWbqAGJAYIh0AJYPiefNqe6omXrpGegXAIf4o/4aKO1LOX2ieQc/8ICqgQjc6oeRJaC7dghELCesgHaqQRC5iQCIAQB2qgBWpQB3+wBnVQCJAgCaoqCZvwCTe5CUz6CJiQYMYxDMamobiqoVxSq8eXZHnmFsDqKMA6rMRarMR6TfuBrNu1HxtSIelVDRxRC6TDCnqwBltABmOQBfX5C+SFXuKADfxlrOA6rOQVCz/AAArgAAWwABowCazwAkNgBErwB4WAp5EQCFWoBnnJc3r6p+rpCOqIl7jwCXjACIwwCZ/wCbggBBGQAASQB8ZmDJQQl5WQCeYojlT3l+JolZkAoHXKB2WpCJogjr2gjGFjVy7iEDZ2fI+Fcr+ZqzAbszKbdNM5ncL/EAuAIAMIMKSo2YZsOAADgAAcQAaG0AimYzqa8AiQIIJAlyYvm4syq6HHx6VuJwvHUGfUVWdau7UVsrVe+7Vgq7XbxRHH4G6RwAqbsAZrwAZbsAVj4AaKcLXQJQ4awg3bdLd3myF4Ww274AZQgAEKsAEFMAAZQAqTEANDoAQ6oAfOqQfvaAqB4AiFWVF2dbJgUWwJNglDIARf0LmeGwIhAAEQQAGkABcYYoBmJ2d7Jm/Y9AvN2QZr8Ad/UGKZkAu0sB1AuR7V1VUcMQzNBzo7NrVRO7xcKrwyCxfHEAod0LM9O6RA+7youQKGQAqmQwqrqgmhYHulF3u0V3sPRqWp/yELuKAMJFWAHnq+6HtCPyln3AYXybYK7BgJseAIbrAGY9ABMpAFbsAJJ0QN2rQf3BDAAYxedrtN3ooNwxAIToADKHABFYAABaABBKsCU2AEXPCpflCfrHAKXbdTIFdpvtMd9mIN5PWlVvAFIeC5nwsCLBwCYXAM1cAN98BB4TZ2ZEdw0cBf1YAMjpDBdbAHhfCcjrCNwUBSuvNm0wAN0MoRxpALxCc3efRg3qthFVrFFQqVuKCEseCEsaCEXuzFWywLasC8ZPy8PNuGPDsAcZAIf8DGe7AHdfCch7CWjUuWdmzHcRAHu5fHefyfcTAGauAGjxAKmiAMxxYzn3kSpP9yoomMoikKs6IFoiGabMGgCJWwCFCoe2q7BPFZC9PpZNtVXlmbXXaGDMJQCU4gBTnQAifAAUBbAZPwBVMwBUkQBX4guz7HCrUAC7kgjtRkDfaATdXQM9OwHtBTDcrQB52bwp2LB58LAaD7BbJQDXTrZtZsdm7WDt+gHZ3gB3CcB7LLGgBpC6gIE0nxOshxQtuCC5owx6yRwXd8x3r8n/RMz70nn/esBvq8BvrcnvjcBnpAfWVsxml8xsyLBNgah0GwBFnwBE/QBFfIAzRAAzxwBEcABBa9BBq9BE3Q0R7dBFdwBUAQBDygBzgZC8h3nCrNMKUVmbhKq1JrerZ6DLf/sBpJIglxQAb2OwZkoI+hkBoIOQu0kAqoIJDalxeBqgh+0AZB0AEaXQRJgAIr0AEIgAAxEMudCwZZ8AfPiQiHYAm7PApalAv7YUXYRMzT4KzpFQ2fMAWcKwsKi9WdCwKc+wWSQA3VTBPaRV1u5gz0UA8VQgvezAZvQAZtnKCvwECa5lQZUQ2BEg0biX914ARisAVagAQUzQOavQOcvQMzIAMyMAOd7dkzINo0ANqhXdqq/dkzMNE7QNFBcAQcEJEBAAC2Tca4vYa3vYYIcAVaEIc8EAROsAQLXdqgvQKqDdqm/doSPdE0cAPQfQP7KQM80AgeEnQptxlCgphOuY2J/82oFsNF5Gme34KXdMqngeAH+KgIajBiicDHYxDfYiADHfAACNCarbmzBL3fQNsANMACRtACK7ACHEADKxADjNC5dAAGY7AGHaAGhOoITEgJH5QJxACuwVwh04CsZk0NuKAEbv0JvADXzty5QsC5dCAL2mQP0oWsynpcGdJfvRAIBgoFNwDECQoLdrLXWTudr1AKsfAIauAEUMDZpa3ZE13anD3VHdDkTi4DU70CqD0DAx7lUg7lV67cMzAAtt3lu53bbBiRXV7bA6AFR0CjMtDZPAAEA+4BK+ABSsoBU43aT47adk7gUp4FWiADWnCFoO3kTo7f9n3f+F3Vhn7ohv/O3/tt6A/Q5PQdBM1ZCPusBvwsBg9gxmgM5qg5AAfwAi3wAh9QAxwQ2wcgAJw7Bc6MBWRA6YiwNqLAZZdQC+JIDVX0rVJ0TRlCwsdgCCf+BZMwCYzgzLPcBVaAB7twXgYsrsEKrAZcDceg1HygtoWwWJ5QC69gC+rFrMBaIbgQX7GgB2IQ30sABUDwA0ywBEBQ7j/wA0CwA6BN2qL92ald2qe92s5t3K2N5Ajg5fye2/zO7w/w0DQQBDvAjxhN4ByQ8BmQAR3AAYD+8BAv5xwA2hxQ1ZrOvIqe8RmP6K0pA04w6mWpB/kcnxW/s/qt8WaMAAuwABvQAiZQkTSgBSv/cAABkACeKwhfwAcAqp7yKwucoAq3UAlgR83D2rXC3FW84Mx4gAe/PgmCIAiQ4GHR0F/Lig3TpWddq7WkSb7HEHmFMO2JgAiL8AieIAqpEBlV+mhZXAutIGKW4AhqMAZt27ZZ0ARbENJ4fwVNsNHEzY8bnYVOkAWCHwVRMPd037ZyH99ksAUCXdu7PeZj7vj/HpFPoLZaoAW/93ttGwVZEHVQ8PlXkAViIPiZL/q/d/mXnwVuuwWe3+TOm+kGjfKyn/L6jej3jb+gLQaKIPL9LAY7QNW2f+it6fAdIAb8PAYW6QEyYAMswPxQQAZIMAM0TwBf4MwGmwgECghJgsmx/0AKllCQnXBCSzxsxXarxYvVUM+qHqYM3lpdutAJ3clCnHAJ7Mhz5s17baAFT9DnQbAGAlUIAIEIUaFDiR45quQnSIcHCAYMQOCQA8MgYyxuiZLxSpONTTx6XILkyEiSQZacXOLxyZMrUDJG2RIzS0yaFsVkeRAAAACdPHcG6Am0506iQBGMWbNGiximTGlijOIyY5abTZdeFaMly5OZW8bEjMqDQ0SyZSM+QNsw7QMObd2+7RBXrgy6dDvUncFjx48fTtSo8RPJE6ZIhRe1CSLjrowdeHd0aHx3x98tPNCuWGHDxgofY5D0sOFAgAAhePAIYnRI9epGmDRZirRIk/8nR27a3BYT5EmQGUucBHk8A8MXPLs4BcpEDRs2e/fEQasGrM2DDhzSRnyYXTvQAUB5FEr0RzUg1Y8WxZHRMLvQAGR/cLEZxYkTJkxQogQCxMd+/j6AkBwJifp8mw8KAw18KaamxNgtp6GIgjDCn7iTYQ033FjQKa8yZAqmmT6MQostRBQxC5jEGIMpKNaQAgkWOLuBhpP4CqJGG2+00Yke9BsJpR5+zK/HH/bii4cfgJBhhhl+WGKHHX6bD7i65prByR2Aq5Ex4MZgI4kDBmgAsxpWuIELJGbAwQYNCghAgS8EwYMRRABJpJFEFmnkEcIWUSQRPZqIqyGHsitg0If/BHBAkmOiiUYaa65RZ5936FHHGmoiQcA6sh4yVDtPC+gAvEPIG/WQRgBRI4olaHiggQYQeHWFGTiogQwpboXCvvuWyK9X/frb78hffUCi2CNOKvBAqRQU4y8tPprVIfam5e6handwI444/lIjRTFi8jZDmJ4i96mZUBQjKjLIqOKKG5B4Agnd5nOCwwW57Yrcr77ll0Nwx93ir2abVeNeDqliSo0acwtiCy5YGKCACj7wADMytpiBBRtc+MCAAAooTRBBGlkkkUMWKTkSTFaOIzcaOMhggQxuWGGBAgyYwIEG1PLAg0+UaZQbccLRpuhprpEmGlX+2OIHxSa6q9cf/2jYgYYbbtBsBRqCSKQwRxxRmTA9ts2iiSNumMHqI8ZoIikyriiWvx972G/uHq7u4Qce9jaSL2F9Remj+phwCdwU1yhYiydGemKMK46YYQUPMsigLbTK6g4iMbLd1iLPvyq33ARfIv2lpsaQgg0uRrxCCy24hR3222a/LXbb1aA99zZwF7hZ3X/XI/jgAwlEEeK/XsSSRGZooIACGmDBgxq4AIMFFnAwAfsGBhBggjcFQeRkklF2BJRNDtFjjSVm8IAFE1ZQLAMLNBhhAw0kv2uGRo5BJppnqJHGcrBRjWooIxeLyAIUGqOYxfTtBzs6QhPoBq44AAITuMCFLDQoC/9SPMJOf+ADH+qwhjjUYQ91qEMhlAI3H1zNhTe42wutdgO9OGlvevMbX4IEoJEA4SSEIx1S3LCGMbhOC2QYAxm0cDYZYOZplzNUB9qgrTog8XOhqwlYDlS6jBjIRFFA0RiYwAalcEsMtePW73KnBz/4gXhvVEQcv0YJOlKiEpnoRCdGscdRpOIVtACkLWyhC13sohe98MUvhjEMZCjDkdGgBjWsMUBsRBIbynjEDA7gPAdUTApgwMH1XOACFmiABWwqgAri9AdEfEKDtbiFLG7BikUUwg1jgMIW6sWwGqXtCkxgkm/UUIhFUEKPr7hFMmnxilFUIhBu2MoRikQDGvT/plhI8MgVWpcFNVwoeCVLRDjF+Yc/GKIQISxEOgvxh0IYog4iuVsPaGCDec4ThtSkppLmqRkb1GBvOzBSDOlGN2D54AjFAmJM2IDCOpBRiW5QAxHLxoNq2sU66oHIEy5UBz6sy3MXw+JTooKgqWTBpFm4AlikgCIw3qmYs4CpLXKRC0LqwhfAwGkwiFEMYyTDkc9gFDUIaA1rVIOoAhSHOOyxVKYyNalPVWpTpTpVqSa1GrgQAwc2KbEMsAAMRWhBDkhpg8mVMmIMmIIg/pAISaxsZZpwxCH8sK1m4SgxdAmCjMKlhlIpAmyRsMTXAuGH4LUBcREd4oXWUAdtlRCF/3FwAxsDcQhELOIQj/CgOBthJ3GKc057SEQhfNADGVTTBjOoAWp3UIPVWslJaTttaukZIxjG0IU/2s81D5pQMqyBD+kUYVKSogXEPWEJPDgCDexSHU0hoAMXcuy6pIvEkHZxiyN1yUm3oM1bpWsNTsCELEyRCmtElarnRS9V73GPfOTDH+1t73qZeo/mrNe++aDvetvrD/7G1x5JxQYuDsEDVylgAAcwgReScD0c4MAFFWuAB3DggJtdIAzCi8PYtKXh4GmLsHq4UGSFx8YRB6+NJ3YjilWsYhO3scQrRjEgANFG4kXCEXFUhB9y3AhITGIPW1AuB2YQIyUV2cj4pP9o1YqMT2ri7Uc34I+xesUEmKyBDdsSrlKeoIV8zuBpbrkOWR4QhMTdRLpXBJ1MrpCF+Zw0C65784hMKiKogDFd8yEFJzIBjObkox3hUEegA10OQnvDG+c4B6ADzQ11cAMcj1ZHO9qhDnBIGhzlMHSmCf1oTnM6G97oRjcMnQ1w2CMc2dBGNlSdDf46Bxu12IEHXlABDWzvAFbIgfVG6YI0rUADLlCCDiisgBek+MQlDp5tQnyhNrxYeG58Y7SlPW044vhrjqgjJTKx7TzmkY999CNMCznTXOyiFJFghSw+sYUm0OAuVqtm2rxMF3nTYG/4XDKTbxvPKPswP1RGSgn/x8CtC6lBcU+gqJJWcBe2oGUsDVGD8CBqoTV49CIXl8lJmWLEERlRK3Q2HVOcIINHnCITs+izpAMtaXe4Yx3wgAc61rGOlle605C2dKfLYY5Ma5rQ5ej0p0MN6mzQox5E+0bRtpGNf/jDOcFQgwcq8IIWTE5yKNgAKV2gGRzkoAUb2AAOqmCDBhwgAzhGu1+zTcc74rHb3f52KlIB01kIcpCE9EXecbp3YvS9GMkA/DKa4QxnSMPw0jDqNYi6+OVwQ2hQXao4sGGpVKhiF7xIhBgaU7EuJ2neaUNyD+6t7xnuG4b8ORYTgFCfLZCwhFmOA2EN/jotBCHhdHkAA+PS/4avjSeykHXbxb9yEWZt3HUd9zjIM7IgKZ5iFJ2ohj383HJ3sPwd73A5zVv+jpt3OtA3x3TPxe+NTod61dkghz7QQQ5vlEMb2yjae+2BjEAwJAMN5kIRMnAAB5zAehqzgSLQATWpAA9IAiywgQpYAGZgQMKDhgeEBmd4wMOrhsJDPKOapEkSIAH6hg78hkiTtHBQNEmTtA4UQUETNBFUQXVIhxZ0wRd8QXBIB3/Ah3tQB3HwhUx4BV5ghZloohrwACPzPM9jMnvjGx5wstMbLdyim2tCApdYgqjYgoVaqKSIgz34gzzxk92ZvdqzqyAIBE7QBEwwj/AhJw2rOCv6HP/QWZDkc0OQ24IFoQtLQIVO8IXmaAfqa4d0oD6XQ4cY7D5IozSdGz/x67RRW7pxMAd9MIdxIId0eL+kywd7wIZM6IAVyIAGmB420ICHUAAT+D/NEEAbyMQGOIEk8AIcsAB6YMVWZMX1qod6aEVZdMVYpEVWdAfsc4d9wAdbrAfs88VfvD58IEZitMVevL56MEYX7MNcvL5nfAeY4wd4oAdmOCZc0IMf8LKeCUL4qQt6y7cmoyG7AYIdyQ8gKUeESigqozISosIrNIhNIAVSgCvVALHdaQPfaYNAsIRYKAVO8ARO8KBGoKwZmyu3sTjPGZE4vAmEORgQsTOviAs3QIX/Poq+dtA+Zmw5GEyHQIS07gu/QjS0bSBJcMiGDtSGcVgHfWCHcegGcgiHpDM0+tIFMeiABsgABNgBKeACB3iIAzClGbAB3EoTV1kA6KkCMEiCf2DKpnTKp/wHfpDKqYTKqeSHpuOvrNTKreTKrORFfMhKsNTKfSBL/iLLr4QHppzEWegEZNKEIKAZX6uADMAMb/xGvLi3q9kbdDRHXzkCYiGcZaEyl7CyhUKhQoAESXAlDGIFT9AEG+OTQwCbHHMEWYgFUPAEzCQM86ilPwAExsqyilPI4rMXpnAzl3CKMYiLHfCEiuQzjOTDXKQ+jiyHnPPIQxTJTCPJpduGDnRE/31Qv25AtaS7hqUTh2gIhB1YgbJDgPcoAxf4kk9UkqGkmzTJxANYAAuwgSowA6uUSqh0SqsEz6b0zvK8Sn7QSvNUT/Tcyu+EyveiL2u0hQxSAyQgE8mhHLtsIv1MEiPcN/84gv/goQD9ocLZgmVBCsPcA0SABExwpV0QBlwwBTEUQ0u4BONpNlGohVUQBVHATE4gDJJRDcICPuFSQ+QzotK8iTozHLlQhFXoI2ugB3doQdmkURg0tHa4zUfbBh4FNVETyd3MBvgjB0UETm/IBsW7BiU1qlpIDBMwsAFggj2YAzU5AAUwpRqYGx8oAjUpuwXIThioAvX0B/Q00zJFU//0bLo19Yc1jUr1jMqo1Mo4PU86tVP2zMqrHE+n+6+6uzxJOIIfiRxMzIAlwwsjSxseEKj96JFdSYklGJCE2oL66KIEjQM+SARI2IRPiIXLEwZekAVQqIQbC4SvAYVYiAVU6FBQ6NDBCCzLkquxGSLhuiI6S9EwCheqeIrPiQsZEINWqENjEId2OIfYdIdzIME9dEGP7FFwKElnBYfcHEmSzIZy6AZFNId4eIchXdKiIiBqOAZEkAEbsAADKIABsAMymAM7OCUN8D/q7AEkKAIckDowBVMNgIF0KNZihcE8bIdJwQd66EVZrEGCvQdZVEZ5kIepnAd4IMZ5wAeIhVj/shzP8TxLXtSHeZgH8+RTZhiFXMigMdCbGmCtIiPCGKkofaImRb2buvGhlGgCR80PSK0PkgKYmCCDOFgrwYgFXLi8XxAGYfgFXtiFosWFDUUFU1hVDx2MSDAPuSJRxeqWNYwJOFsQmzDNrsgIr7AIKvMLToiFVbAFbGgHephBs2zBQVzWHe2+3HTW3fQGdMjYeHivdqgv+hogXqiDHYCCnsGBE8CBM0BANiAELqC1FwBAG8CBIkiCIjgBBdyqAjgARJu5yv2zSHPFzM1c+2JFZcSHsyRGeJiHfiDd0i3dfegH1FXd1GVd1fUHfSDLh4VdpuTFf9iHeliqXJhPXliE/xkAAr95LS8DvS5T2ZUdKIP6D5BwVF7xocCECdIhl5zdg8vShFBghVioBQzSXlR1hVVYBVUFBU4QXxCFzFFxsVlFnDX8CiPSOHvJF661iCUYODE4BMschWKwBxZURv5SORZsQe5j25tzW50bh3HQh3qgr2vgBqeiBkxwgDbRARYYkxoQXB14gSrYAzbwgbACwMW9FSmwARNogAU4gBI+AHSQucqluRp1Rmh8xl9suXrgxWSMRWIkS1u0rxxer324Bx724R4GYh92rx62YdjdBxpsRbsthkHaBVlYiBzSiy5jsnCcoeMdLSCI2ZMAkJN4WUmF3owLmNhLBLBxjcwshf9TYAVVMIVTUGMPFcNLgGMbUwTz/TDg4xb1XV+tcMgMKZia+BwmCJi/8ARZKAVb4AZsCId2qAf0TNtweLQWDGBO69HxA1JD47RykId4QDV62IZp2IbI+4U1MAARIAAViIEHqwEw8AIUiAEYsAEoIAMocAEd4LUcYNxbyT+yqoARJmF0MIcUrtx4WAd9TYdkdGEYdod4wAd5eAdtfQdbjN0a1mH7qsFqvgdrxuZ84OFi/Fx/iMV7oBR6UCqb0gVeOITq+F2+KcIpTpsXwpvRclkt3uJdAaKoIB0344hmcQM/UA1FWASwsQRNmA1PyMyArFDItKwZyzDIGqI7xuOLWIr/q8Xavxi+NeyuvwAEWWCFUVAGomoHfOAHfWhBEYxkHm3WR6PknvO0d1CHRL6GaZgGaJC8WOiAAhCBL7jpGJDgT2oBF4iBIbAe0AirBtOBJMBlMACDKsCeDNjlBTCHp4bqp44HdkDhdYgHhYU5mCvGrM7qhl2HTI4H4AROedAHbubmskZrfEjrtTbriMWHf7DhSaEHbigGX9CFXoiFheAAH/gB/rABvDlCJFPU/+yBg/qPJeCh5Q3MXDEQbXIzH3ICMOqmDGMj8vjnRwAswLKEV43VDpu4qa1o4vscj8sQz4mdj1qXNZBsC3GDT2CFTNAFo1KHegDORi7pZ7253eTN/9zOhnu4hkTWhpiuBmpoBAZIAAKIAApQgSHQaSwAAxdAAa97AX7amAZbXKP+JDN4A9XxAfzMgKh+6gJmB3aIh3lQ2Ex2WK0O3fEeb9GFB/Im73nQB6k0b3lYZoUd6/PW7/1W2IfV2P+eh31gynpwh3tIB2awqVww5+rogADtax/AgatZQtFDwtqyG4IqbCQIEgFtVN9AicEBcY5YM22aWd+gCjXYpb+ALj+QsRnTAy4Ug12KcSeAgi8CGOJ7Co9zM6awCNuxiNReA6YQLjdoBFngBI6uBm746H/QV3Bw5EjG7U4T0iGNcnBQKkkT7mPYAwJIgOMmABFQASPIASrAgv+/ZQEUaAE03zWiZtwqoB4zYIM9sIM3AAMk2AwPAO+oXgd2qO948POrvmqwnmphLu95mGr23lh++G+H5WYAd/RHh9hi1FgbPuJ3sFtoIKRe+AVYeBmYARwI349yvPBRl5se+o9eWd4fAvEB+QiP4JsjIRDGsJIfyJEocZJvVJJ/OhYal4oowPGYaB32bV/bSV/pSoqEOSw3aMxKiO1rWPJyOAdw8MCiuc3dNGmTptZVe1byY0VIhA5hKAMB6HIuB/MTuJUwGIILeNcaaIEPQAFeU1wcSIIkqIIkYoM3CCE+yGAx8gFsBW9fVuGrtmpB/3P4Hm+NRYd4iDl4oG+u5mb/rob4iIcH4Axd0hVw+ZZFbiCGVPAFXuAFQJABy7kPHyIWqcmbc3wgIDGovzRsHwrQmT2W+xicD5f5k/inIxkJp7lLuvinb1yMugAoHoBZJ2iCGr9ZcoEzkzKcgYMdtzHRNWACLuCCMmCDMXCCRvAESkgFSaKH+TaHRPPApAtEbXjbKR81VEu18xtSVesGZ82Ha6AGXuACAuByCACBEBCCEtAAMGADHUCBFEABFjiBFXCBNM+BNOFSeucCMjDM3zIEcxohMihSckj4mdNWniuHFoY5dIh4hbdveYg5P1+HhAfOho30F+bmYGxrYpQHje0H+nqHqfQHe6iGWVDwY5AF/4hagiQRUMTODyZJZyMRfr3hAb8UieNn1P0ICf34XQ/3DQPh4pPIlZAoFo5YCZa4/idQiTnbCrOZmmpCLo7YgpVYM457Q5pQ+pjgAuFS8YjaAzm3g3W1AzsoAzqgg9PAAzZABFKAhVJQBqUCCH78zJH7Fu5guG/aFmrLlm2bN3ASwS3M1u1itmvXtF3L5s9fvnv27N3z9+/fPXHCsBCIEOLll5hpwMDhYqNFCxQnTuA44aIFDhs3oPhAIgXMmjd1lu7hU+gpnzrkxmk7t27du3ru0pVL9+7rO3hix5IVi08s1nfu3MXTx08fu7Fg39GrS+8e3nt18+bFp2+evn4i7/8J5IfPnq5Ut3gdc+RGzQ8eMo5Qrgzk8o/Mmnf8AJIZM5CiSEYj8eHjyOnRlJccWeLEiWsmUJgwWcJECm4opJE0efKk9+/fo3tfufL7CA8aNGbMoNGDeHEt0qdTp77lupjrYLyYIcPmsRrvefrgKY+HDpwvU4QIoTAkz55NrErlqmbP38CCCL9tY8jQmzdcbeNQNtqUg5F/2uwTkkjc3NOOPykdg0UCIYAAAgQXhhATGmVI4QILLXxwgk4+nWCDDadBwQUYZqzBRh17NFWIITUaUgg52nRDzjlWxWMOOl7NVdZYZ5UVTz3vrBNPPPK4xU5c8HxVTz123ZWXXXjVVY//Pl0Ghlc/AkUYzSi00CKMLI+J4YQMO1z25pudYaYZEEt85lloppFmmmlHqNbaEoEKahtttEGBGxNNNDEccL8pioSfivq2aA/JLdfcEU8Ud0V1nVqHnXZgvLGGG26QQcYZaZhHxxdCRACBAAIEAAAABODBhh6wgNJJNOKU1CNC4UzEkETedFOONwQ61NCyCi3UDj3cqLPRNNeIg40wn4ggRAgQeOstCEJ8IQcWSeCA04gt5HCCCSbgUMRsLJrBBhtK8cHHHzQawggjkEw1jlXnmGOON+a4o1Y66bhTJFlGkhWPWugsuc48/Mwzj1hUUmnlXnp1vKWT+uBDj1n/RCiO/y6z2HKLMIo89poMPLB2BJxvLjFnZzf/cPNleu5W2mmVATqooIUuAQXSTFzxqKK9Nb2on7w1DWmll/KABKecerr1dVuIMcYYYHi3xhpkrFGGFeyJQICstLrttgBT0OEEJqyAkgs29uSjjjrhqHNOOsMuVCyA3lTk0IAEaqPQNdxwI44410ADjTTVbKJAhRZaqCFM5CaRw7kooIDTC3KUgQMOSIPRYr0x3ptvjfz6Ow6PV6GDDpBrcVWOO+iUdTuR8MSz1e23t/UXWRtznCWW9NRz8cjOX+zPSMSkksssu7CihhpjLLEDDzwoytqgcN4ZJ5w+MwEpakFXtkQTgRYqG/9t8h8KxdSkPf2z1FSHz9wMrqY1rVWHgNX5GtjC5p04rGEMXGDArN4mQQkSYAo5eMMnQjEKapAEGx78RlcA1J/CdQNABTJQORa3DWt0BCIcscZIrjENazQjGrywAwEI8JKXgGCHLxECHcJQLtDhRHQvEIQsJuGFKqxObPNy3R/yRSPZQWIc4+gG7XwkMd0pLCy/8x2R1pGw4qGDHW3BmFzosrwrNe9589CLF+WRD3tQYxYqy8UtAPE1J3gGfEuLX/nidD7z5Wk0tIFUalBDGSTExn5QGJRspBAF4zhKalOLWv+OULXlKOc5AzTg1rSwBS0gEGxiW0McumcFAUywlW//E0AChgAJUoBCF+KwhzVyeQ1wBG5A2gDQRQDELAJtY4UdyUayNNKOhFRDGdHAhQfYRgAI+NCHERBCGrrgBSmA7ic4oQIdSAGJKniBDKszwxvm4LqnTLFfkKjiVEroo6ssCSz1aJhYgGeWfErsdkCCEmCQl7E1EvQd8pAHHIVXj2vl4nq22EUknBCFLXwmZvUjmqAIabPLLKEHfSLNIpmgyNEAAWk3o5/8CiUFKGzKOJJ61CIhtSj/KaeTSNCUdDQFSk+BCmxcIMMY4vAYLqzSlUallQC+8AlSbFAcuWQhL8HRkcJRVVnXKKZGOtIQZuGjHNN4BpomAMsETLOHO/zC/0tEMIUweAEMXCgCDkD3ghdQIQdnKFcZ5mU2pciInbFzJyR61KNynON29EQSlfBhJMUaCYzwaCw64rEOw7LDdwFdbJUIaqV2uMNJeBFePOghDmJkAo+4qIUaxBAF+c3gBzLAKGznZLOT9sCjmKTMIf1EGyBEYbUlnY1seou0lbbUUU9QTQ+i9hzkhk85PIgUTlvqqU1Jx2tbGMMWuMCFoA61CwQ4KnhFMAlSCEMc1WBhNsDRDm5c4xvG8kY5kNUNZX2DP+111kKCWQ5pBAIBBchhrHI4TQhUCK1T+EIX2GoGMCRBB6DLQQ6IYAQvJKGt3qHXG2bkV35R0R3rcAc+3P9xDnlE9ipNmmxavhI8KX2ld0wiWMHK+JaAmjGzmrXSR/CBH8NArky9yAUvMBEE7E40CrVBaZ1iWzM40SaRMeUfEphQJ6MZSqWIgk5wHAVTTfaAalyGlCWJQx3qSmdpN9VaFnqb3e2uIbVSiAHbwGvUACQAD5+gBjWkYY934GOO9thGfAMdX4fUVyH9QRZHNmKRetgjGGooQAK+JWmytiQC1/yCCsIQhtVJwQYscAEOQF2EJFRBu2ODkYb1xWEOe7hHXpEHk1CMOyANKXhfSZg5bDew27GjS0z6tY2Zdw+NbSkk+OmSOuwxjFH0Ahe7kIUTvraFiW4BuFEA7kUDuWT/jrLmZ4eMsmyQ9sgqG0q4h7qyb1q6Kd9UsgkuhVrT2J3u4kanOMflzROyoIU0X0e7XGizGLhgBAGzUs4SZGUAJDAJZVSjGuCoh59BKGgTnnAhI+zGNuybjW/YoxqOAEIJRCBpCEQABJYmawISQAEVYKALLSoDF8yFuhzoYNRYOCcbXrTOp/yVX/sSrDdA3BbJ6lpitYaHY/EBFnfkOtb0XNJBzTgPiK0xs8q7Sz780SV3iOMZo8jFLnbBi0AEYQnZpXYWrjDc3NRmaDwDzWUO+VFDrm804j53uO9e5N6am5I6jY4W7C3vwGuqCX6S96SAI6l1C+emvslCFq7j03+j/3IPXYh0pL9r8IMDQABWEAY1xJGPiBe6IcZCdILA8RBsbEMjHszEDozgqpRbOgIUEAHuhSABCShAAipIQRjmxQYzxLwINR91En76RHrVAV88T0QiGtEIRtjIij3is5Ng/fTJCsmLSDcLPpL0lcge9Nex7pIZ9SEPNd7YLqPX+jvUIQ47/kLssHjNDLawUrRfGzcrxR9GwUnRzEZpREqhGNLdIQrSXBsU8J0D8l3gqRvjIR7hGcdoaNmk3NTT6FTi/R3kXZdPnUocNAIhEAIJvIq3JEDBbZ7bzEoFgJ7e4IV/OMRFxFeCGEgxZcQ1YEM1zIIM6EAMqAAFSIDKiQAFDP+hBNweBoyAChzYFJhBHbzBGwxfFRQB8pEa6ywFqjmFvkBf9NmIIaQDfCmMX6ifZEnMZAFIwnifY7FYiy3dWijJOnTJxagf+7UfPeQDPvCDP2SDOCRDJvRCL/ACLwBCEASBDESBFChNvomb/yVNbQQKbARKkjmSSElNcczG2vnfSnHi/uWGuPXWdFASpyQeo2RNKb6U1DTeowwH4hFQ5JXSqZDBHkzfJ+ABCXBLtxDYCm5ewR3BMWBDOXxERtSXfwDTRSDIVSEONkSDHshADsQACYjABEwA7l0ANt6eCEjABaQAFeDBHMDHHizFG5BBJ+LGTyVFjLgOF3qhF9bIU6T/g9IdzB52iTyg2DrA2BqORRsunfipRRxO1hldDNXthUGukT/sgz9EizWkQioIojCwghYEwQ90ABdIQXH0xmuc20pFomu8RrYVTbidotqFGyjmhic2IG4w4ALiVATmVCVJTXVkmXFloOLhm7wREHaEh9lA4R4UgiQslSAc2A55i+axoNuQQugp5EIUWqFRlbFcxEY0xHxZgzGIQQd8AApg4wYw4e+RAAmogBBMQQyUAAnEgCBQHx/ISFSwARn4m7ygGltyYSG4I/TBYyEQA4hxyfHYIz3hzjsICVk41q3RQ/hlBUAGpoedkRmpEV94zPJ8RD2AgzUAQ2n5gjD8AiA0/0FFdoAUcMG0vYYTbOJs2IZo4k8TRGLd5d1uuBtw3c8meqJslhvg1ea7Ld6Y9YYW1OSk/B0HSpd0JBD3kI0Z3EHzQcIk4IIsQIIgxMTmQECcISUAAAI1YMM95INTOmXhxBcwLcSBdMMMDUMQPMAKLIAGjIAFjMBYxsR6sMdYdkEXDIIhEMK9QMUejArYnIrONUV9spNdJsKNPMUoQMNXDMQctsU9oqE71AVYSAk8eAM6TEmVDNuUJCZbSIzFsMM8gIViVUmwbUk98MM+0IM9OMMozAItYGYpiMETyEAHdAC1bQHkpRlHQiITjCZLpeb80F2iPE1xKM3dNSDfTdsDmv9bA15H2lGHvmUBBvpGAUlHFmxglulb4CXpS2pBAo2B2RCnHIwjHzwCKRCiLDACHjgnhkQnCyZCNNgHdhojQ1zROMCXfBXINcwXeGKDMgRCB3AAAvSpAlzAFATqFHRBoAbhWFKBIBDCIBACOxXCvZSjfsJI8/1BqhnCfzaqM2RDPeDHj1DM1EHMh6UDPbQDqbaDqI7MO0CLlXjY051Y+bnFX4jMQalfPURPXSidk/ChSADD9eRCZgKCqTxBEEiUjBYH5LmmuM1PSCrNHwWKpDjBE0ArtELBE7AUSzlBRl4B5F3BaBZpFHRrFKSZuFqr2pXr0ojSKM3ovs0o5DlBFkD/65JC3r5ZR35q6ZaSzRSywR4wAisIwzHwwiTgwRTwEKwgZQDgQjU4yD4ohJuSg8PSzhUpDkNsAzZYQzUYQy6oggwgwAAMQAF4bAEsgAIsgAEMAANYQAVkABKYExgMwlNEUVSswYIhBRvEwVI4X6N6ISIgAjvxgTvUahkCxjyY0fCsxTqUal2YaqmqKoPWQ/k1yUGtgzxMnVvMmPBczEHJg5VQSa6KhDSUli3kwjF4ghvEARkoShBE3hYYa9qpbRYEKbZRYtMMShOIpt3erd3mG5Pa7bvibSjyHRSc5gKGqyjtm2j2rbvO6GuwK+SJgbqKUn7OItmQTc6ZTR0Ywicw/0a2NOdLQCd4BRgABAAB7ELo3cM+9IibaoMVQazFZVx9FRPFehA2iMMw0IIjiAHHcuwABEDHDsAOPMDucgDlMmqjUmoUogHzLcUfEO/zFQIiJMLzOqoh3Jo72GOsbRGrjirTQgupckxWZK2X3KP5werFYG3WZkWHluE+iMQojIIuLMYu+AHZjJIT8IDbsmvXTFsCJg0lOisgSSLe8i3ituvdvutHEjDcwi3fNS4BJy7jLi7jMu50YJe9bikZbMEsngob/AEm4IIwCAMuTEIa7GIvdl6AEUCkwUoAKIBS3lI+oC5/FEiBjEPpbQNFWBGBXMQ+pMM3cIM1UIMx6EInrP8C7nZAELTBKCjDLoyCIyiCH5StXTZCIjjqOPLVOC5voz7FFBeCFBXCJhROOvhaidFTq41qwjBtOjCtXbwDk4SMGf6ahtJhHarfQfHZPiSWyMxRMVCCLoDdL2CCGrDBGDQgayDpjF6HtkIeAyri/xmNogjebwSwuxYw4h6u4iau3SowSy5gBENwJ7OrGDguu45ZBZNNBmewviJCKHgwL3wCWp2pgA2YpJkc24CBIyCDC39DQWgD7PJy6uagstipWOhDOTgDNDgDM1BDNATDMBDDM0TDmsouMASCG/iB9EnfIzyC9D3FOMaIjHRxFhfvHkACMpIDQQDJkhSth43qRKT/sdIuz1xoDBubX65iTDzMA6xBbYd+L11gQybMQh/zQpqYzRiIQUddAZE6YLU54OAyYKHgD9umHbdi8uFScm9CXm8mniRq8iYjjbxSKZOy2+OCNJWua6dcF1Cd8qlklxORzR9EQiwQoiuj4MiBSw+xBwN8wCeAgi3kMsNOBDhgg8YRiEbwcuIAiFhMg1IfszV40LXI7l2Uwx9SgiIcQjZHAlZjNSRMHxfLyDeHMxdHEcz6wR7AF4A4LDnMmoIeVKkGTuColxqDqMaIXxvPqkDYM9Q6yT6DRTvYgy9QQi/oAi7wwiJgMNisyRX4QEIPaYyy5HVc20O7W0RzK7tasiVH/3BIw49vzMwRgOvgJnAUTMeMIh4FQmlJP+665q/kYVfXfCYYlIESVMEY1EEksMJgT0K3YIikWdp6CsIkQMIm+KstRANJOKVEwG5WWZU2yC4w+8M6dEM6TEM2TMNIXCdejETWoUQzdIIiNAIkRAImhLd4S8JW38jr/MEhpPchFEJ6R5EfvDcgHIIfBMjBJMmSkAOAEFZnuYOq7k4KpXHSqmqHUklWiF/WhkyGNomXIE/4JQk9VAMl2EJAs8ITiFJvjeYWKHaRTlvXCBe1QfZDJ4qxRjTj6i1mv4a8+W+grEa4PbSNIk0iY3STYuC6LqlpR/DaIjSRXteaaaIUKIE2cf+BHUgCKewCLkyBS1iICDQhHTDCJww2Y8SCKvCCMgSDL4yEUw4OOMAul+vgU2UVXuRDPehFdWcdSIwESWRdPnDDLDwCJEiCJGDCJsy5JtQ5JpA39b1svnTxH+CLWO+BHwCCWQdIOuwaOSDTiMnDgo7qViVMVzh6OUDLgE/JYULtr/ED0rGDG1vMY60vo9kCJeSCLhCiHvCAFvDWa9wMFOz4jguptyYwRCcymom0Fmg2RitKqgvK+JCPoNBMknEUEzj0/Cju07SGpIC0k5r0vvkGBOc42EzbGBgZ0uhJEhiBEliBF5SBIcgHLqTBEHwBHQgCJHyCLBCivx6DMAQZJSz/hjDYgn0sjjE+BJfbMDLNV6Jl1TXYAxuheXbzQ0hUt0lQjy14wpwXvMEXPJ7jJVhH0R70eR1AQgkByDnUKp/Vwzl4g2Dxdzp456Nz7+5Ai1dMesV/7z2aw1vkM9QKxD+sbzuIgzR0wi9Y+TGYQoVjhxh0j+Q9tkIbKeDm3fzo3SjV5Es9Da5P4txq9IpTIrcd2WtKWQQ7SqDkm2jLa041itR/oGqvtnZxIhdkexmkAR80gnxswiTIwrmjOy8oJytswp0nwiOEAi+A8C9AzkHQw1bcw5YnzsVFvDeEQ+uFAz2Ew7JMRAk5rDl8AzZcQz6sAzt0gzS0OZzD+SREviTM/3l4wzkk3AjxMuq9OEVULMUa1IEYQrc9Jcl30s7RppCBnDGAa29ddEUc2tNWdBasoYNA1D4aCoSOgQM32EMnzMIwfDAv6EFvZEEoh/Kzd3iRJittsKRHEorezXhwEH3dTmKv7/qKt0bNiGT5QEG7slv8GLtIh/RoY2C86jgi5+/WP6IUYIEXeAEb8EEihMIuCH/axwIpeIIm3Hl514EeFAJAkOK1i5Y1bt/ChXPnLl27bNvAbctWzltFct2yZcxGr125bhW3Qez2cZy5c+rU8ePHbtw3XY42xZQ5aZIkmZsk5YTEyBAhn3/48EkEKE7RNWPIZKvo7Vy9ffXw4XNXjv8cuXPu6KlLuDWhunb0wIJNh46su3f13r1j6C6evHjr5unTt65cunXrVPKjx00csUC/jgE2FaQJkixiEEdRHGXLlsWLoUSO7MTJEsuWgWRmAuSyZSZMCjd58qSJ6NKlkaReUnlJkCOvf1h+PdtHbR+pcd9GUjs1Z8pOTncuvUQ06dOlnxAX7SRL8yvPoUeGHPkzECZQpCThQoYNokieQHnipAkTJEiJCvXJI8fM5yV1WOFCFQybtW/q0sUjVy+btoTayqGqomymmSabptIxxxtzKPIGnHQSROeuu/jRhx121CEmE0xC8eSTT24C8SaaJIGkkBMPAQSQNlhkUQ01xHD/RqmR3KnHnavOKWeckcjhiKtvEELpK7DMemuds9JCyyx59ImHrLjiSccdeeRRyZ+9sKGkk2GEEYYXQJw4QobDELtCOsUkS1Oy35xg4rLMrIOzsyVSMw03JE6bzbIg+JztiB8ABfSIHnwg1LZDEfUBiCNWA86y2CxrwjI8CxMuOeR+ywI66D6T7DPcJmWiCCakkEIMNwI5ZJFE0NvDjjfKAAMLJXRYoQYpgPhEllpSicaaa9ohZ5144ukvoQDPMWcccjTSJp13RvpoKYjAQdaca+WS65tqbKkEFlNC+XATmm6KicRIHmlkkUMCCaSSUWbpRJE2XoTGwIpGQtabkTRq/yecIFHyKuAh12FrQnfWOSets/SRZx10zIlLn7SoVOkdeuzRJZBcujxGk8p46KCxLbKA4jMpPP3sOvcuK22MLUxGws/ZZJ45NT9x60Hn1/gMItAfeAg66B546OGGRJFWlFHKHuUh0Nd6OAI3qVtWTlLLnHgOtdOgQ21qQpEoQgcdcoBijKyhqEIJKZiozYa3fVhBBiackEQWXEbJxZpqsDnwYW20ueaabb4hZxxtvgFcG6/OySjajLYRPCNtzklWn7zKsaeZeEdZhRRxbbopJ0kiscQSTCJxJBNbqhFHHGuCycQNPfYlMJturkIrx8qt0grgcLxqR8h22pmQrLsqX//oHXwafhideOSykUJ+8GmnmkDyFuYYXtyoTIYOnDPzOpRNdtMz81tu4uVPX/OB5psHLVrqQWcm2ukjehZaaBr0v+EGnQ3Fm0PpjAdACIJsjsADGiyQf0PDmZ460zPCFOY1U5OaBQv1P529jQUe4MAMbsCCFrTABjVgwQ1sMIMZ9IADHZBBEPYgC1nEIhPRqMY0KGcOdABOcIPTRjYEFzhtfOUc0vIG4r6BDWwgDhwPUsc6LsePffTjHveABjFmAQpRhEsSkxBdTWyCCUzgpBK3wIY47GEPcVTjFofwA4S6UaBuuAMf9ahHOspxjqqcw18ISQiQAhY8dVSOLBJKWOX/1mFHt0xoWPqQioQu5452pEIRtrjFMI4RCS1cIWQciMwVkNCplM2JlHSqoMwQdQQmpKZQDhwUAO2nQBr8IH8L1F//NAhAAdrAUETrQc+AxkAGCg2WBPzBzCSIytq0T2cDJCANdrCDGkwzA9WspgY8kE0PYDObckNAC3cwhk+wIhaVyAU1pKENcugQcJEb3DZ+2J/+nGVf/LqGEq2hjcN9A57hOMc++PGPf/BjHvzwhxqpsYvw4CQmo6PJQ71Yk1Ycw3VrPAYrCrGHigRoGvaqEVrSocdl/Qtx/izcN06yDuGFwyroSFbl9Ji7OsYDYeswBxSbNCV/SJIZgZiFLXKx/702jOEKHeiAJ0GpmpOVDwl0WgKjkLCoRdnmZsUEW20INTQCArBoRvNfD36QGV8Ws1BGA+DbmumDEvbyfz+wXyxpMAMa+C+XPPABD25wv5/57AdYdWYxv8qDaO5ABjJYwQMy0IDEVqABDtimBarpgRV04AHf5MAP6kAKVoCihr/SxjsaR7iQhOSH3QhQOdKiFG+Moz9KXOKyAEkPfPiDtgJdCT/yYQ9r5KISOYkoRIEbUUyIohe+2IUtVBEJPszBcB+5CIGcIhWYwrQq4xjHS5dFU0TepR1YCcuQiMSRdpwDLtGrRz7uYY9gdMIX7T2GI140Bs9EoXySkUJqRlWEsP9BIb+iqo3KdoOoOy2zfe47AtJ0CYQM/q+sZc1lL9H6Nl7q7GhEy6X/hHnhG8z1woQ6MBB2NjMRMxNQTgPUNFmQYhWzQMJfVdQS7geELZBhErLwBCWAcUZ75CMf/wKS4uT5w3u8YyKrHQnggGSRPdbIH1VErxTjcVBjrCISa2CDIT6UZVJsOctdFtEmMFEiQzACpg+7yEfq4Y99JAx5ML3WTW1aEpuSF3jBE56QxAsW4qkDHey4HD7okVtxzEIX7R1GLPQghjFowZTlU9kqk1CEIiQh0pOW9KVxIOlVBliAodw0/P6qy7JatQe8tE1av1pqCZewBhKea4NLPc23yXr/g16lKwMZjNWoHTiVhTp1D4AQKArbYMUslrBXwZoZ+l1hC1eYwyY+wYlRtK6K9/jjNwL0w3huJB1K2dGRFTcS65bEz//Axz3ywbx96MMf4vAFJwoBhhy0wA6MmMQ4ZaFZzbKC36z43LhqYh5GQAKRCCPHvqZRjjpOt3JvfnOcTYJIgKGkKwPb81fi4WeV1CONy0hFMIr7i0PAaAxZKIwPLgPgI1R60iy/dBFwkGlFwYnmnYHTEeBEQKGVWLCDjWbQdjADn+vP59M0utFVKHRb3yDpclWhMIEO9KDLFdhirbpVQUxMoQ1Wf0nHtf/0B6hg74AHTbhCE3wAiU+EghLE/7AHPar4429UZNvZaEc6vHE7filOG+K27k2zpY95rDsu/LhHMmZBiThwoQYNqIEduvihe5MCFzKsPC5wQQovgmgSkDDEHpN1ZgOZlrpWUda4HX5d8p6jzoEUpJ3VQQ95vCMeBeWHPDCmC1v0YhfCAEUbxEAGojZhUCmXjQ9c/nKYxzzmtfkZ0ApI82CHNetFu+XWfU52qSd9sEIf7NGPzn26Gi2uwjS/Cn8+WP7pDMRcvT7RbClLny8wmnI1v/Z/HrQfKD1qV6DBHiSBFCohFbChHeIucbRhQDRiIzwi73akP/gO9cpLLgiKoOYhLrBBFzrhEMYACVjAAXygDxhh4P8YQRBGkCZ05W54QRYmYQTHzDxEqioOTgG9IaSsoirMQQbXSYdyEJHOAUKAsCGIh3gagiNCyizcAR7kQh50axaMixd4gV7U4GWWoG164NGWYFGkRjcQha7GL6+IbgeeT9jgT6uur/68D/3QsOlkAA2j6ehkQIXicAe8MK687vzaMPu07/qCxvz4B+rs0A8F8emyL2hkoIB0BglmwAf24BNEgRKSQRwOsHAoAnC8gSLwYXIgcHK0AZ6QLHcu53LmAR5IcR/aoRhSIRL0YAtcoAIcgAvsgA7gAA9oEQ+mQAhUQAi+gA4EgSYEAQ/YwwzQYA7O4XCW5VoO7nYqZ7WSRYf/IOZaIIYsIq5yghBCiPAaw+IquksJVcIeiMEWjEsYLGEHEOM6WMkHqGMzFoXTasN/2tELMUwPxXAM3UqWzDAMCUvoZqCw9DHpCosf91EOa0AGpukf+fHW9jEOn84OuU8Pe24HoE6B5LCw/LDpFsgiB7Eh608hv0oG0u4UHIEZ0OgegKRw6C4Bf5DIgiyekAgBv+FZ8GEf1MwC4YGKpEEXOOEQ1iAJPsABLsALwiANvmAohSAEIuAoI0AEhEAEYqALpiANaDENuoAKDEefdhAdRgJfshIaC0kaC6nMXE+QLm5IlCce4KHw7qEYCo0XcMEJdoAyrMPAVMl8aKYL4REe/6Fp6HYO+pzmlqBvD7vP6FgN/MCv6WpgBRAzMRMzDlftMBOz1QgT6dQw6BZow+aKIZsuMzUTIy9yMy0yMVXIfzIgERxhFKxhJAkHQGpHKcqhHsphAQGnP0oSAckBHZRQJkVxHtgBH64BGEShEeqgClJAAhiAAqZABUQgAZRTOY8SBELgOUNABKQzF6egOqdg3HBQQgIk7yaiiLLT4ZzRpZKn4mBvz4KHHhZGHkixoO4BG8BRGBRBDOGSCV5NNY6vguzyLsFO6gqx5/pyaEpMHpNOMEvIViKz6RQzQeVmBlpt1hDzMBs0MgdyDilzrrxqMzHT6yyTMyeSIjfTsBS0Af8KIQj0RhJJMnEoAiMSsBz2ASOaRXEQAkj+jh0K6h/8AR8qRB/cQRyigRYuoRDMgApIQDkJoEgFQDkhIAScEzqfUwic1ElFICmVctyw03ByJCPyaLWWpSsNieH4aAjDIiuGcEzb4R3kYR7aQh/2IbeAQRdqYQcoyyBBs7Amy6js1Kg4IE/z9Kj0tE/99E/9FE8BtU8fwE8foFAPNVETlQMUVVERQFEZlVAPlVEnVU8R61CtqZo4QFMzYFMzNVM1oAEU61OtSVQHAAEaALGq6VIRNU8VtZpEVVQT6wHUIBB8QRq44QBvh+4mAh+67YcMhBM/sRss5HJs1B94LL1c5xf/RCES9iAMpoACEoAAmJNJQ2AosTVbh7I6nzQElqW6vtUqioj0imhLC8l5vHR4xnR4AulZzpRYoKLJuCUQZOBQ/9FODfJO9XVf73RQLdVQC7VP+VRPj2pgAbVSXbVREXZSEVZSF9VfGzUDEHVSOzVPU7VTJxZTAzZPEQAAAGAAEtZSGxUBSLayFiBRSXYABqCGqgEc4O7HliIj0qEeGicjghUCP/Et+CHK1Cy3kqFdQEEWRGETEMEOuiA5CUAACAACklRbnXZbq/MLbtFJw7UkclBcL+ISG6cbruvNuHS6wpLiwlZKLoSm0NOg7MEXWIRPXgQxsmA0goA5ssAJJKhu/3smmu42DwmrsAirbwvLhfL1XguWXwm3YAkWT4+qsh6VshDgVB/gTr+HT1N2cVtIUEU2ZQNAZTX3UE+1A2hABhAgAAIAAQ6RImlgCThAdB/gfphD0V5ECygrYONqYCmLAwYgAGZBGqahHXiMnyinnrzBRrhzATWCa9dJP9LhHsShHdRIHDKhA4Lge3ZgCcogDGIgAoQAApQ2AZjWOYcSD552W7s1BISAuqz2aqtiXy6xIqyrNqPxK2EqbLUibLvrQgqmu1TiHqohFUZhFEABFmAhFmCB32KBFQI4FgR4gMkJgRF4gRe4gfstgiXY3/bN30IhFLasQ8ADFC64gz3hg/8/WIMxWINB2BM6ZBM8ISbQ5TtCAcw0YRM04YU/GIbFKBIOoQ3c4BFKmIZfGMwe4Ycb4UQKIREa4REkIcwwQVwiIREOQRI+gRQ85ENIIUSe+HO27IpTeIa97Ik/2BHE4Fa9oncl4hzqqSnI2EXrrn3PAR12Nh3sgRvsgXmVIXpt4AVO4ANyQAeu9wsEAQKolWkBeUm/F3yxlVvHl3eodFnat7m6AY8SUFxhCmKm687ol5K7q6aSxx3yVxyAYRZmIRVu4RZw4RZqoRZCWZQxL5VVmZRNWZRPmZVLOZZleZZpOZRpeZZhGZUrb1dsWYZgWYZ4uRaAeVeEmZiHORaAWZj/Y0GYS3mYnRmYGTiaG/iAZ2iAAdiAyWmAIVgVuFkVWuGbv5mAQ8EUTOGbYQEVUCETMoEa+gZZ84GfiuwjCkZaNMJA9OkYIYYdVOJI6GEauCEVgm4DRuACPsAFYiA5n5N7QQCQGZppI+Bav4AWtbUon7O67rl91bi57u6HVE/1rgVsKY4rBmZgFuKQrmIdjvUepsEWUuGncuGlc2GURfmlcQGmc0EXdMGmXzqndToXbgGmXzmoX9mSQtmSfDqojzqoVXmpMc+VX3mUoZqUhTqoS/mVaeGqsbqUcaEWaKEWlrmUXaGrrxqBS1maxfoWEJgWYmEVBBiBYeEV4PoV3hqB/10BgFUhFlyBrVvakztBF6ThGtzBRvPhnZbCHOLhNS8RNq0SGu+ioC7QG+whGvygA1bABTCABFqABJASArhXSZ9zoRmaewMZorX1ORO5SkHPcMpBHV4zI6xUj3bQJLZiNv0oYICHvNABJbbrWPOBHto0F9oUp3dhuIe7F4z7uHehvXwBp5l7uZn7uaEbunc6uqebp3Map3t6p7Obp3saF3KaqH96ql/Zpm/BFsz7vNEbqE65Fmzhqom6vWnBvLHakoCqvdvbk+PbvPE7vU95lGnhp23hF9oLErkhHeBhtgY7JDYKHuIBeBX7GKGRx5SQHcoBG3KBAxCgAi7gskVgCv9CgKFBwDlFPMRDvKFB/Dmx1bR1MAeXBbbDdYjoobX3SAap1MdoG0i4wp/IQredx6Boyx/aoT7EgRqIIRiMXBiGwRiKwRiYvMmV3MmfvBiknBiovBiIQcqtnMq1fMu33MiDQcuHgRjCfMyDYRjM/MzRHM2bHM2NXM3NvMzPXMzZHM6HIcu33Myv3MqNgc7FfMnNvBjSfMkBPRmIIRkMvRiQIdEVHRmUodEZPdGVARmMARl+4ReGwcgrihp+5R3QQbB9qCJsUx4c/EUhXIfgjqDY4RoyIQgQwAAY4AJSgAScFMRJvNZr3cRNfElDwBvWaQZXK315/VpaGxrkIaS8AbT/tgtiWqK2w3IrBkmHCGlC9AMvdBQslPe3b9oXnmEZpMEZqOHbrUEaxF3cp+FXwuEe6IGkrsEa8Amf2N214P3d3x3e6yPereHeXQvf6R0buGHf/f3fuSHgA16JBD7gc1zgK2rg+aKiGN51EF4clMh1EgJjmhfi+T3iIb4a9oYaEO8VbGEWgoEv3hgBl8JFl6ItzEFFt63vWjxZJIS2CMq3KQsFYiAGpqALdvELGPqzSVxJlzTEfR7XG5rX01cHZ3AHycEdsgEassEf6iKkIvnNSrL1Ks7Z9chrGUlY5IJY5OGgiOGlzVsXlmEZnMEZpKEaNF53p0FwICIdZHLNKgch/4hneYknTO1+LxA+7xfe4R8+4fu+4QGf7wNeHAR+TL8LTA9mIe5+8e0+9lZKeOR+vM5BHmSyitqhiUiK8Osj3KUBGODl45sBjewBHOpOK6WFWIaXeI2XGofFHwLKH7jBFjqgAVLASYdgCrY1kG2953l+901ctIne6GUw2HNwHQgEGu7oBwNkxc1hNnP8+a/ea8linZ5nkeJhH+4hGnLhvmeBGJhhGZgBGs6+GpyhQAbnQe5BJuUBtgHnPMMC9/RsXUcaJZhdK+qMPF2v7tNdYAqe4fM+HACiXTt69ASqUxcuocJ169w5dCjv4UN58ggKJFhQncVwB9W188gwnj5+/v/wtQMH7tu2a9ywWbNWDZozW6lmzbKFTZy9e9u0+cyWzZu3bkO9pXtXzhvQpUC1dRtHjpy5dfHk8eP37544Sg8axBAyJeyXL0IgmAWBNq3atWzRmjWbIEFUckKjepsb1Zw5cuOynYM2zZ+3c3XnjjP37Zu2bwrDMX6s8Bw6vVL1jptsTp4+hvjucfNFy+YsX8mSLWMGTZo0Z9KmTduWDZy/2e/O2U6s7lw7d/QeNrSorpw2x40bd1SIMDHj4sw9quMGPTp0bNigL++IEDv2cwzX2W7o3Tb33wXTDfw4MONBg+oYoot3FV86lCtZvqymutisUalG+RIXzk7ZKAeUUN7/lNNNOfW8MxRTTZUDFTmSVTUSSfQQE8QDDgwxRRcefjFFBG+lFUJbJrYVQYrlJCXUigeWc86KMo4DVTbO1JMOYXdFRaM5jikHZJCMiSceZejQOI8+7KDjzz32JCPaLLkQU8wypz2zGjSAAVXOVfrk6BM42kg1XkgMOXTbYkIydlxiCSnmk5pxBonSQfRtg2eeeGKDJ2Mo+bRiOoIKmht3RI5nGzpnpjeoQI4ixNFBjp2z1zoj6eMOStm4Rh1+0ESjS383NRPOQPeMeQ5d3RCV4GALCsVUnDBGdY477+hTYT72+NLBAwtwKBZZIkIAQonFnogsiSGEYCBRMh4Y47MS/3ZzzjTQLJiUYTQmt6aQEhI5mVQ0WjoPk05WY8ssr6RCCzDElMZMM84w44yW03SzzlXorMrUU3qho+g6ANsWVbdBalMfbEvFqU2sTG0Djp7X6FnfNRNvoxJsDTPs05AE08rQd92ZR8+gFn2kXTg9fcOXOfNcFU85QFnrkrXOQDnKKK/4Yo029OwUDsEGGliOO/W4A+vCTc1V660VapWLDAgUQASwY4Vw1rJaa81WislGsKxQq76Y1LNDPXXOON450w0+MQo1zqrdvAknkGoqh5eEe/FF4zjszLOOP/XUww0wqRwuJTHvXskMaoB5c6lSm05TIDkAdxdPyOc01jBQFf/nafHFFkt8jWuhn346nqivjjrEKRmc2GIJwWibXuUIGiOih3IXTpyrHnapzJtCUzM0ywTTHyidAGONN/Xccw/LeDV7Tj3tCBeUgXgeSKOE68izzz5X2UNNIF0toIQSVkwhrFlbv59sW1u76GxSCdrPL4/jvNONM7ifLTe7yS52dxsT3yJEo27oRYHzYIc/9nEPeiTjcKh4hS3cVQzTNKNxgJmGN2A2uS1lgyiV0Ys5UlWwbwCldKZzzTQs5sLQvVCG1nKhDW9oQxbekHXXWCHqFtMxAhVoaM1KEK2I5L10lEOFQHnKVfghuWsQTxoySUaoTNGJTjxDG+mAYPT4FpX/snUjHfJZCou8gadZScgdVvnHP8ZXjCBk4AAGoIIV1keWrHFta/FDi7GUVZi5KGVsdBkKwcaxomxAQzBKzAZfuuEmAgKpOPrT1mFM+LJ31EMpzpjF4V4xC10UoxjMwNIynIHKaaDjKoq0FjTA4aK8JeUc6egdDDvoGi3pcpetcY1qqLhLLf0ymLrEoTGPOcMWzjB0Dyui3OT2LVk2jIWbehkUvaGN0tmDG65Zhi1GIYpM5KIa98qGNtrRuXGgkDBNS0dRxmagj5kDHZr5h/j8Qb44eEADCqBCGLpwNfe9b6BcM9FbDgoBA+UNnoUhGFGUAo1s7MOd5ngKOdzkmLut/ylvPMqLCdkxEnekQxvTMFwqXvGKXBSDGKeURjLoRbl86cOVgIHliiozMB2tMJc2DCYq65UaKqJSS0AFKjGPaq8b9hKZOUSm57YhNrnBrXsEI5gSmdjDbMCHH+ZYkTa5KQ1ieFJ5wcAG5XTTjnDw5VCDeUdtxPhQoYCLnuHbxz/yIQ5aiEEHDGBAFT4UogQQi6CE/aNaEPqWh9IlL3YpzAlRGJVuTONG7ihHRbtx0eXALjElNOEl5/kv+MQjHunYRidPCspgsJQ1p3GGB0eCjnrVa2Iyoh3uhDe5XBLzp7zt7VB1+VvgIhWXTEUmDI25FJQQsUU3peWgBnWOxOhwlf/8YEeMLCYOs0rDF4frxCykocJu8OYjh5IQOaiyDhOSg5DQolTARHKVu4ojEDVAwQIc4IUPlUWwhS2ssrB20LTsyC4e3Vtedhcj1+CjHk+JG0ZhFzTJYMaE8wTYv2T6pW1gI1QnDWUGmyGTemWjS/zoBmpQcw0uunNFtHzbT3J7TFwC016/tKFqlGpcHtJwmafzCes0Vg6UsBi6zm3Ighzi1nekQ7quLMdIyiWza4jjJc+gySiWx42grEgjCP5OPNAhFTA/5S6BSsdUqmJNrNwDG4H4wQUUoID8gggEggXB1QraX7WU6CwQWJYQInAXyuDlX5j51u7SAY0uVmYcxVH/zo8wmirPfha0F/bSO7LBjWV40ia2MIYxUDPUabiDH/WYxomlsRju5EVR6IgW7VACjlr+6Eeyc8znEobrPmWsJysxpzkTchxJ0U05sHzdcpiTEG2w2DbpsFWSJfIOfCxYk/XAB6YQIsXHWYUf8ThHNrYhjmpYQz9XHgV4FVjZcNBDPN1R1FTSu2gKXy4eU0nSE/+BT2XooQYbgDMVAFoW943lC4QtFh/TEgG3nEUIQogBHQJN4b1V2MLhEc+K3CFZNp7XHJDi1rEbE2nLRBwzAKOuPqxHjw2PQjTBSAaIh5qNeviDpI6bBja+oWrJoFciDmnHfMyzDkcZ5CIFeRR7/4aOHqOjLFIeSY/Qn34Rnw+qI+04R3uqnhvaMdvZzx5UtPch7X3MRh/ySKs1apiNW/FDH+jwBji4UY1q+GIUqOiELcTxDb28wyLdCclo0TsZzAis5FSRx3sqhBV822MUQVjBmxVghC5MAcAGz/NA2ZI1EcQADLyIeIUJXXJFddkd9/ryPDsOKWSr1fPyfiylvPQ8JxXjcLSgRS+M8XLAkGMfpYZG46RhjZtPRVFVydxo9THaeFRWKOlAx3Of//Sj9KYde3fHbq5v/fScTCAkK7qjrL/38DfbIc8VmKFa7fwJE5/rg3IIPmYj9rHrgx7qOHtrspEOXG2Gli6pcneBIf8O7/BlP1MP9KA5Z0YVmdN36NV3o/U3T/REuhIIQaADb2YAACcix9JfeZYWbxECU1AEuEANAiNxAJM5E1Zh7EYkghIU8jBPRJIbucEyQUODlMJ6n8ds5lAh8vA82eVJtHALt/BpMjEN2qAO+VAO9NI41UAduUEhuKKAVXEmInU76dAQ0PZcQncU7yBS5MdzPad93kd0GEEQ1Yd91EcP74B9zaco7pB+zWdm7rUOmjRtzpYO9SB24TMbb3QP7XB2LqQN7yA+pNUOLmEMo7AKh5MM7YB8z0MQ+OAO3jFP6PVlAVNyCriAmoF4V4FXlOAEHjABBlAAAdVnWLNHfrSBy9L/gcQiBDkgC9RgDTd4g4UGI1VYDgziQfVgOeZAI5TCF78IFcEoaCUUeOFiDu5QPVfRDz8jDsSgC7sAjcbQGvSQD/kAPfQAQzqxE/eQD/4AgbMBjrNRjePYjeRojueIjunYjeKojuTIje9ojfEIj+FYjv5Qj+vojU8Ujvu4j9boJPYgDtBTjeCYD3AXDLawC7kADPZwT/GYjxCoj/wIjlgRX/gGjm90FfcQDG7wBkqAAiiQAlMQcKXIFqqIimuxLF6jcAlAAZJADTlBGbKIgje4iyOUXiTHauoXehNHeCWnF95gDumgDu4AD/MAD/SgE9JgC7mQC7oQDMsADeXAjdao/0PtAD1T6Q9upJX4RhIEaY/tCJZhSY9h6Y9XaZYCyY3sqI4TGZES2Y/+KA7b0A47gY+6AioIOQvPcA9XYY/cCJHfqJbyOJAE6SQC6Y34NAtiUAY6EAM5EANfMCzHUpLJskfLAgFxwQjHQA3VIA6UQilwGJToZ4UAww6lyRA32COhBzCCIiO0JFKXY5oNOHiLog7oAA97x4y6cBNLSQzQ4DyzoQ1GpQ14GH8U+Zff2JV1pZx1hQ966JbPORsUCZ1j6Y7kaI/RyY/xF45dOZ1vCT3qMDr1sI4kEQ5itZSzwA3twJcO2ZbiSI1maQ/xKZ/zSZ/viA2z8AdlMAIkoAND8P9ng9VHJjJQEZAAKvAJsoALtmALW2cr5CcoEpFe7LAOsZleFcqLaqOazqdEMvIQ7zEPFDGbbPQO6GA0+ICbgugkBIENykALCmoLvgANPpMPpSZb0/ANGCGe+wh2gzM4GOEoYogRsAYO6xGGZEh1H5EQ2wd1ZPgzGBGf4gClUfqjAqF6jfERRacdBBGfV7kTTxqfLRF33LCl0GMNvnATqfAf6UkPEaQTEQSQ2LBN1tAS1jBlMBEN0fAMz9AMyqAMz4CnyjAMxTAMxMCE1REMq9AIRhADJPAVkVkihhWg/xUCESACjDAJkoAJoFAJjXIyz/egDAF1GnE96IR/C+h3xkf/EfJQFfKAD/LQHdbHG7rRoxHRGdBTbddQDbuAC7ugC77gDDmRXTIhDc3wDKkxXL4UVKoRYrI1L7y1rLvkW6jUDNOap3o6rY2DrctgGlZiJdjqrY1jJaWxreLKrdoqrsXgaZ4mrqWxUsQQDO8KDPAKDPNKr75gr/dqr/GqOIoDDJ70Cp3QC3z6DMnQrsDgC7rwjLvwC7tgC68wCrEQC6iwCqsgCp7ACZmAsVmksRo7CrkwDMgQDLPgCX2QA0MgAhKQABl4WJEKAgmHipMqAYLACIYgCZvwCIrQftfXKM/HhVI3KOBQMuDgc7EmGdzxDjx4cgvCo0orbQvGo0xaD/ZA/w+aIW390A/2JA2zIAqtMAstirAHmwtLqQsuSrZl25QIqwtMyZRlmy5R4rY2cThxK7dxyx9ymzN3mzMbq7d7y7cbm7EYi7GVALiDG7iUYLiO4AiGSwmIqwiNqwiO8LiO27iBEAiSS7ltoAd60AaBUAmd27iGK7mLoAiRILqHoAiHcAiJsAiNkAh/gLqOm7iGGwmO0LmgsAvCQAue8AheEAMlIAQkQAAqq3AlaZJrQSxqEQElkAaEAAmTUAhxYAiMEInT2xDoIIACSL1/p6HtJyhcKCje0R70sGD4wKQYoYn6pw9g57TSdg/WdhXzYLX8gA+zgLmmSwmdG7iCi7GUQP+4fwu4fTu4nTC4nUvABKy4B3y/CKzAB4y4DezADwzBESzBD6y4swu5kovBGdy4qIu6gEC5fuAHmtsGbeAGI+wGhZAIh+AHgHAIi4AIiYDCi6C6gFAIf1AIfFAIkGAIhcDDhQAIP3wIiCDDKXwIj/AIkcAKuKAJkpAHLkACGDAFI5AAQgCpIDAiBgUBKXK8aBEBQpAGhkAIrWvDhgAJmJh8o0URmLgODSShmFOJxQcwXOgQ1aa+Z3kPYJe+zKkPTlttzwN272u18/ANgYC5elC5hxAJCXwJmXAJlWAJi4yxlwDJjFwJkgy4kgzJk8zImIzAlbDAn6y4jjC7kUDKEfz/CBO8CIvgCKoMwamsCKILy6/8yqxMyqfsyqZruolwuqf7urjcwT8MCCGcuSXsBsUcB3XAw3tgwzbMCIzQBz2cCHrwB3wAwzlcCHsQvZDAw4lQzS/8By/cCJCwCZsACVLwARSAzhIwASpwZ4d1Fph3UCq7LCLwBZOgw43QCIZgCH1gCMfpz/8skRC5lRYZjhgJgQNN0P5AD/Wgg/AAD//gDIEAwh6sCInQCI+cCZzACRbrCR2t0R9tsR8t0iMN0iGt0ZmgCSiN0h+tCRqd0iitCTEt0zOdyZi8yJpg0yqd0juN0pfA0yl9sT+t0y290R1t1J7Q0kld1Ee90aDA0R69/9EjXQodDQqasAl8gNWFYAiJIAmQoMOQ0AiP0AiSMNaI0AiMIAnRawh1wAY0Own2DAk1+wnjLAmXugl24AASIAEUIAIlMAWT8AmCQHCVV8UKh1hZnAAi0AWCoMOJ4NX6TAiM8M+T3Z736I3WNNDd+ZXueJXi0A56gRX+cA2zsAqswAqqIAqsQAqxAAsQ69qwAAutINuwDduu4AqqgNuqcAqq0Aq5fQqnYAq7rdu7/dumYAqlgNzGXQqiwNzN7dyiAArQ/dygQN3R3dzU7dzVbd3Y/dzd7d3NndzHHQrjHQqiEArHjd7IXQrKvd7tbdy/jQq4HQuygNus4Ak4zAg4fP+pb+3VrKvNNNu80csIOvwDQPAGXt3M2fzWl9rVhgAGFzABey0CQiACeDAJBOdfVkwsiGXFKZsAXyAIebAJhoDDheDMfUAI4Dg4/vAO8FeN4jmY1CmY3Cg++wA+zRk+5/iPXmoPwAqlMFEN1NCn9bBK/5AOu0ILtVALtKAKssAKslB7tODaU07lENvarwALrtAKsaDlrWDbvd0KE4sKEivmY27mpiAKZj7mq3Dm4DQKpmDm4CQKdIcKyM3cds7cqHC3Y27nyK3n3w3e6n3npXAKy33nz33czI3mxo3momAKqsDoxp3brhALj64KkeAHJq7VnyDOktDVjx3XnzDgkDD/s33gzGSsw4Sww1rdvJNACPz8BhqAARMwASQgAhEgAFPMRylCUFbs6wiVsl8ACYSQwzNrCHnw6q8OpQAJkNwgDs7+pM5eHeLAEs+ODYUad/fxEtzAEteuGjAhDfGyDKM0DO/6rvcqtgpKCzXRCbnADdaWFfbQDLZwC7U3C6yt5FEe5azd2lNO21n+5Vo+5rLd26qwCqeACgiv8HWe6M9N53rO56NQCmY+8Wpu6Nbd3Rgv3dOt8eVN3eUN8nfe8KJg6NCt8cat6IuuCqed27ndCqcNC6BwCDZszcxLCs0sCc1s7GRc6s3M36IO2ar+B/o8s3nQB1XgABB+ASpQArgu/wB9huEpqTVgc3l91rJxMQV4YAjKrNUzOwh5UMN/EA0Ey68rFQzIYAz42qtnm7a5QAughFq01/YNOwu3ICX9kbeZ0AlUndSXAN1EvfKWoPe+YA8PZI89rgv27q9VXuWwDbGu8O9dTvCtoOYLP/GXX+d4buh+nvCZr951jgqPTtyQftzL3d7rzdzWDfKhYPokT/KkQAqhAPuwT96zP/vqXQqsr97j3efALQqksPKmAPykIPySrgqkYNqsEAue0Aib8AmTMAhxzfNeTQqysMM0m/OMkMOePgkJXvRkDOCEMAdvQAcvQOsRXgKTGmAKR/UHVywEh9gEmvV9kAd7wMN1YP8Hd9AHdrAHbhAHVwYQnQRmevWq06tRlTJ1ypRpVSZVrTR54nTJYqVIkRw54sQpFi5QnDyp8oSLkyZNnBwtijSRlCZMlhyhfBQJU6hNiiyNUqauGzx/+e7ZS2bLFq1Zs17VklWL1tOnsaTGglU1litYWFu5atWVaytUqE6dKmWq7FmzpdSuLSXqlNixY0WJWmv2lCpWrMay6srK1N+0f9mWClXYcKi1pEKRYtzYsOPDkRUjJky5sOCyggGbypuXsaRPnyQxmsSI0WhGhiRJgrRJdepChQxBYg2JkCFDhG7rJtTHDqRPgiZMwEBCBIkICSAsZ958OYgQIYSEAAEBeoj/CNklCBGEZxChOHzskHmTZ06dPXXiOLKEiVNMSzIzWjoZXxNHTI5iztQU6dGjRWZiz5MAWQpFlk088WST/zRSxKZIFlEEk4wmus+RTGaxhh54+vknqHvE8SWXW46ipRYUZaFlKhSjkmUqGKuCZaqqvsJrLLxujGvHUnbE0ZS9uhKSK1dcmaorVZKMS7C5RCmMLbrOUsuUxhgzTMpSSKlsscYGYyswsrzkTBZWSJEkEdvyEGQQRghhBBJDGJmjD0ZYgQSSQSSZTc8+QGOkjzzYNGSO8uwooww6jFBgAhFUUCGG5JxTzrnlsgMhgusujQAPPAShA4878rBjjjzMCBWN/zf4KGSPRlbbZBNSXn0VE0kweRUSmx5pxFZaMaFQkk0iaSSjRAB8xNdXH1lwE14lWaSmRhaJViP2ZLJEEV+wAQceb/rhh5987EGGRFxmORFFdNON5cQXpZKlXRipkvErvYDM65R7fbxLySRVwZcvIVtJshV3pRK43x2ZdJKytLxkKzLK1rqyMMYcHgzfv3bsLK9N4qgjtEEMKWMOO+LM4w456OgDDkgEyYOQO4BzWZI+CIEDjjfQoIMOOOxgAwwlNhiOARGKFgKCSZdLmlJKLxVBEKg9hdqQ72yWw4w33li1DtZeZWyTT8pk5ROwyf7kkU3EHvsTWRgTjRRc3v2ElP/ONmk7bLrzIvvV0CQhRRayPWGlFE9GccYexO/xVp9wg8kFl1tqidwpqNx9t12raJTxqq0EvuvzMIE8BbApAcPR31IQHsussFCxShZTNgIlFFDoQoWuJtWKsq6GJY4MlNkJawt34CMefvey4ho8s31VuRySPdiY844+BkGZkZdNy0OONPJA44w56JCDETrmmOS7PlRGY5A8AC0jfR1QIIEEFUQQIlKmmauuOeUEAAAAAXxhEp7Cw81wEyfsGcI3v2HEHiYBGliRIjRzA9yrHrgJ0MgCF7hgxatWgze+sWKDZMtg2/I2NwlKEFiv4mAKgTcLbtRDHOKwBz74oY97PCP/F6/YoORaVLlYXA5zr4jXvGp0sIgg0V+gW52P+uUvhPWrFLBYUSwkh4taiKENoIjLFKOUu8EwyWKIod3snjQ84AWvMnNRC1mAtJnN7OsUUiFFIerwhjJ4ITeMuMMc4lQ98kUNC0m4wx3SgAY0yAENhYRDH+5whkHkzA5gMBQKUJACEpRACPfLXycTkAACBOB/ACAAHcoABzOAoTxzKIMd8tC+PLzhN5L4gyQmMQlYfWISdzObaFYDHLfhchPA8aCsGAM40IQGVpPQ5d5uaUuvxeqDngDFMOxBjxleUx/y4IYvXtGKDd4CF+eqHC2ESKN4UaVIUoHFVr7SCnwhyXRM/4yj6uKiJKnQQpy44IUwFKGJHq4LFT0iCxvHsha5RKlhuGvL8XQ3lzQ2SaEZM0tgAMOvJAXRE4WQHhjQUDNBUG8QpbkDaQYhCEYMYg6COIMcXEo+OPBsDndIJBiSUIVWWiF+GMCACKYghARgCgT78yQoBeC//wUgBl1IwxvA4AUznCGVTmUDG8xgB0LYYQ97sCA0k+nB1YDmgbgEji9vKcGy4fKZrPEbCldzy0nc6YG1IttcJaEJWkRDHPSwBzfE0Y52cOMZs1BLLCbnQ8o9hSnvSieMijQjqRRJSJ2R55T0Nc8kxXFfrkAXLnZRi1AoQg8irEVku2jQMLFldL2T6P8Xe/RQMDJvSWH0iymeiBepPGIP5AGDKc+AG9aEqqSGQCmb6OApRcrhZLmxQ3nuEIYyYKEMb8CDF2Igv0bdLwHX6STSQEmAowpAlAEQARXgEKgzlOEMUgXDz9jABTCktKp1uCUkTqNLWenyNA8cG7CAJcFmAm6XZSJFXO90X7jeyb6nOU3XzGRfYDkiFdjAxgy30Y5tcAMbucCITZoiuVtABSopulzBYjSjInEFihvLC2baSNDRlU50GbsnVQy7C1yc4hIqOYQlsGgkJfXudKMDXVjWIlHdjWIVmRmejJe4Ohlzpp4ZJcUf1rCGrIEBktWbw1UhcQdTDUIOId2eR3f/BoY0oDQNadhZGrxwBjsMorphMEIKYjAFFQRVqPn7pFHDK14AiIAR3nGTId6ggyR4Ibo6eEMfssYGMpBhC/WlzWhwacu4hgYSk5CmXC3NTGaGDYNsnYRq4JTS3MDJEJ8whKreJIk5pAEPhOCDInSBDW5wAxzbAMc1sBENSvjhD4VABCuacosQi/hcJZYKUxrrFRV3JRad6Z2XQtewJuKoFaKwomF5wQtctEJBnmhFLVzRr7Q0CUiqOPfo/NW6gTZ0MGH5nCnY2Ja/QDGzcOT3vlgRC0ykhxBvAHPKSMUGO9ihD2ZQ5HfM4z3uhaGPcBBEH6K75jCcwQtwAAMWrKAE/yLEgARCoEBQi0oAlP/5qAGQAErbdBr7viEJOgADGHA6slSCgQ91gDCcaEMatiJQN6aJK9VmQ/QJ6kmBhmYDg1MaSznMlE13aO4fz8BUOehBEcCYITjA4Y1sXKMaudBDHQrBhz1E4t/INtGISdwuZqfznQSryr1cfNAXE5R3M2b3uaWCi1/8gheftWJpubI6s9DFdJmFMd7noq9sV+ZL8+Q3jSu6sT+EZxC9pV6p2PAGUsUZDdvbnhwgAQY1PXJnMaVDFd5wBjDMoQp0SIMSdJqDFDjqkxFgWp9RDl6VC4AAgigNIVhjGki8wQU46DgOklAELFTBDFzAmm12oxtXUv+NEO3bviESLidH6iYP9N1EHeowCDiVxgx5MCkj5HDeQ98MDmkAVG8MoQQjNNUPmaCGONSxLXSYBmughkpwgznxmUQwNmQrEbdLlxY5Jxh5kXMTEqrIi75Ynn/pDDdivIYxnXNThVggmH46BmEQhsFjp1jgEVGwLXtTvDaardzRlx7RC+GpPIqCo32bks74hDogg1LxKKqbLjawL/VCgzlAAyywJUWag9N7szT4LZ6ZLjBQLyzgnlNqgQ+4AAkQAQmwFEn5LvBKOZX7AtJok6W7DTTQAS+ogiRowyJ4Qx+cAyagkzjxOeAwBOqhA/QbBD4chOoJFTbJgyqQgzfAGkL/CA3iuqWT+hRO6ZSb6RROuQ3ccAEl8II6UIRgsId8yAd/4Id/CJFhcARJ4EPcKIRN2CDIuYVcOIrJEaIqYiwaeazI0grJ0osY60A4+pJbFIx96REr8iwcqwVVsJ3bgajaaS0kW8GyQMbMaMEoKaPigZhQUEbYEhh4mra8kIRCWAOGg4Px+YRRYb9YChSGG7OQQiQsSAMr0DgqMAJUwh42YL/PuwM6YIQc2AAUoAIJ0DPeU5pP+r2UC8PfE6DvMA3ySQM4wIMiGEQ5YJ8zMA0wmI05SII50J44iavtEwSCywM6OBk4uANDWC4/zIMv+7yUChma4kM8gAQ8oD3Wg0RO/6ED3fCNHEgCKVgDRVAGTdzEG1IHbHiFQyiEO3A5Q2gEEQonyIEcdIk7WETBWBwSFYuxJVm3J5snW6yXslCSUwAL10EY3QEF2GIjZJwo0okyzDALaZyYFbQos0ii0emMP2ADKZACNICDM6CDSXilOSAPQiyVOYi6NABJ2aMCLKAzHaACQ+wDMmAD3AgUNACDFzABKmAECZCAElCB6EgOMAwv4APIEkiz7DEEPAgDJahEHSgCM6gTQfACL5CDNTQDLyiC7KmexlSkQ8IDNgMVeuSjMQuUNwmZl7EDI2zJ7sADRhAEN6M4TmEzNqMDBRKVFfCBLXCDSsAGTbyHe/CHcP+wBmJQhEPgA0DxQ1o7RWQDsQU8rBZJl6ZsSljoO1dYhVXoooMaC7F4oua5rSUJi4J4BVRYhVHoz1WAN4uBvNPZNyjakScrqCbRyuZBIviET3bzDI4hAzOoUG+MKi4glPIQRFBRLkMKg/XxAioggjAIg3ZEzApVoDeIRz7MAy9gAQ2wgBO4gBGIgU2aghD4x98TPoBEuQiYgidMJS6oAh3IgRzQgRcgAitASEF8gdPEgXZEgRxQuEJqH0P4yOQazU9xmaEMnzhRruqxr6oqpJZsySc005iiOE8JAzbLKjuog+gkAzWAhQpDHHvQhmuwBlpwAzfYg/ahHkPYgz/QoGP/W0AHFDGngJcYwQpX6M/3DFAjk6O7oLcDjSL7DFD43E/4bJ0WHIX/hDdQDVXbCjLbqjcY41S0UIX4RAVVVYX+7JcHRYXDk1BI2AIz+Bkw+Ej2iaU5IIRB2LioE5/1SrQ0yLibOYMShSow4MOE6wNCWU0L0IATqIAWeAEjmIIp+AIR0FGAPKowlIAvmAI2NYMkwIEjdQEXONIcMAIvCIMiCIMTeAEcaAEq8AIktYOE5BRDoL2No4N2LdY0NY1OUamYMp/S+BM4yLidKaBiDQMvoD02i6kzkDVQmYM1+AEgIAM34IVqqDBxwIZqoIZjcAQ9SA9XeiVG2DlMiBsUScVD/1U2qJgFWCCigkiFmU2FVHgFnN1ZVPjUTw1VePNUoQXVVdDZVPDUnT1aoV3a/2zanmVaUfhUUxiFqDWFsLC3qW0dT43aqB1aVEiFp/VUUM2KVqCSUPgEK0slLAAD5eoNPuCDN6iCjxxNZC1ROgiDTzmDhD0DKqjXNHi/kDylWAKDMCCCDdCABXAADcDHO/up+9FMAvA9lEsAIegCKggDLBhRa7UCI9UBK6hWImDNz32BHIhXdEUB1lNJN2PTNbvLnWFTOTsu9qHHN2CEkvkT8sHbfI2a4zKlMqjLif0U9gEDHuABMiiEY+hYcehYbKAGXNCDNZgTUYkkR+IDP9AgFP9RxfMsT5iN2f1M2qQN258FVfDlWZwNC54t2pvF2Z9lWvdVWveNX7FtWvmt3/htHfhsBc/YhDWoAzaQKr3tGVXhAywTH4zLOLxNM9qbMy/AAtb0gjdwk5epHjkgAhQwARRggApAgQ84geJIAU0KVyHY1sr0MxJQAh0wAiMIuSGwM84tgg/4ABPYgGqNzApwgBbIgaBBgRZIR+Ts3Zsx0RLtgoQNA6iJKdxEyLxUILbRpdEsVlkzKUV7wumCAzaQP07BgiKwyT2AG1zQhVVcBVA4hDEwgzkhhD0ohL98gz2Ig5JoWRIBscQSsaSo4zquWfC1Xz2W369l3z1+3z8OZEH/XtqwiIVVyIvCeIQrq7lBkq45mC+r0jI2Y102dWAH5tvCBAMqeAEqyKNTaq4C6oIhWFwHYIAYlh9MuoBMUgEhEDkMmAAFWLkceMMkMAL5iYEUwIANqIAKOAEU0IENUFwGYIAWcIAXwIIWYIALUIB0vFI80Lj1QkgsoL0wuBmo4ZkCaqmTEhX2O59PoT0rsIIuiK4yoD9TmsJ0bFhT+oCa3Es+AATROgQ/cIM1qDkvwKr0KBU5UI8EfJd9WkCjCGiBHuiBtmODngWCPoqEXmijyAWHZuiAdmiJzgVdqOiK9gWMzmhfsOiM1oWOvmiNzmhgGGmSDgaTHgaTBgaTDoZf/8iFWsCXRSgENRiDIcUCFL4pVcqaVKqCy1XHcJY1OLACh1VhKrCCBiaCF2iBJDgUL0DIBjaCFrgAB6DW07WkC5AfDLiACWAABxgOAygABsABLpCCI92ArF5mBWiABtCAC7gAJZiABVCArrYABliAAhgAsA4DhnXYLhji6krTNpu/9AIDM1gkk9qlT5g/iG3J+VMCvX3C+fMCJTilvnYz5kwDSlpRQc2qPvCUnREu5Wqf6JmNRvCEb3PoYTAGZEiGaHgGZ7AGa4iGZHiGZGgGaZCGarAGbLCGasjt3r5t4P7t2+5t4i5u4z5u4SZu3oZt3dbt3aYw6I5u6Z5u6oZu3f/2qxnKphnihuXOJsSB7WqIhl/4LFLQgywgAxyIzSrAARxYSEaGTQe+3DAIZ+iqgioQ0TPAAiMIgy4wgi5AARZ4gWMm0pnzAkYobBj+AHwcgQ0YgQuwgBGYAAdQAAUogAJQAAuw5Rz4gCJFgQ1oa60eDgVggAafABQYjq2W6wen8AgvUTZ18RenAypAyDWrcYeNPrYlSVYLmTfgGThQL9o7lMxlTTdT73Le7zOwgnIOYDzA11fyjU+5mZ2ZKVLpIzMYukJohF3gBYoeBmVohmigBt3GJml4Btuuhmm4hnAALJ+ssHZQh3D4Bm2I7muoc+muczzPU+be8zzPc+jmhnD/WPN2+IZvCPRAp7Bcy7VtWHRAN/Q4L/RCh/M4B4dw2IZCbwd6wAdN3wd6aIdwuIY05wbspAd14IbcNoZewLFHuAIuSAIUoDMjgAEYIIK+HVEiMIIcGFG+LU0lSIMycIGNe1go7gIigAEWOAEWkHUc0AEd6MinmoMiWFwLiFYGPwGhgWUDMAC5boF2xT8j0IEW2IAPZ4ARJ3cRNwAMUAADgOUKp3AFwGUFEFGjNtZw7oIzmOyJXV2NqwIskK6EfKWPXLjVc1gvqHf+7oIlZVMrqNeMm1iCl67mVJn2acnFlnIPddaQYYRC+INQEAZcyIVfSIZliIbetk5ucIZmSAbc/7aGNXeHN881Rw8HbZh5Datu6Xbu6b4GPK3zOW9uXBN0eiD0Qn/0oY9zPC/6R9eGb8gGbSiHcph5cHj6pk+Hd9iHf7j6faiHcsiGaUjzTbyHcMAGaaAGX9iFW5CFQtgCLkCB9C72Ys/1vlVhtw9d0dWBeW3280FOpurvALeADYCBWSbSBn4zLLCBCpgAGsVHrZ52BpDwaLWAas2BJbUCI3CBUh5mEWcAErhwxNf2EaDwC6dwEfe4IVd4pvpxX4+uf11D1iyDltRb8aEeGq/xSV5ShNdrcC7RAuIZ1tRbioeD3ujsvX5EqOnDWOoNWisEcLMFXSCG2ZYGa+AGe7AGZ/94hmXA7W9Qh3Vwh3VQBzgHLMAK9Jknemz4hvLXeaUX+jmP7kQvfznHhrDf+WuIdHXw9JgPB0kPdKEP9HPo/3NweoDwVq7cuXMDy6UriBDfP378/v3b9y7btGnX/GFUp03as1y4cLEiI6XIhg1GiMDwQoSIlzBUchhhQcWLlyJYlORQ4kUJTzppcqx8QWUICwsMWLCAUYVFlTRFqiQpkgQHCgcWNkwYwaLk1RNJWWhoYVJJGiMfqjJgMOECAwUTFCgo4HYCXbgGMNCBQRcLTStnvKRJEybNmTR0fGJJA8dnmDNlypyhg6ePIDiR8eAJLHhwGiVdrHQJc5jzYjx0LBv/hmPadB/JpgOHCR14Tp48d97cyUNnEJ8/rHDd0hUsGTNp4riJc9aMWfFp9NzFkyfvnbt0BMOdC0dOm7Zw4b598+5dHXny38ODT5/++3jv37RtC5dufvVzCe8btN/O+vyC/guS49989BF0jjvyPPQPRvnQs8000Eyzj0PrXFONMbN8JAkTRSB1wklEyOGFEaF14QUaIxoRkxFYYKFDEjl8UEYYQhGRwgsjvLDBCVkRkUMRLnqRhBdl4BBkCjHEkMIERqGQw1Aj9shCGB8owWISOrRgQQUOqMWAAQp8ORdcdMk1gZIpKMCXF2fA0RJmq/XxWmmnwUFYGnGa5hMcg4XR/ydnsSkBWhhW7DmYZKexCQdqquFRJ2xdQDooFURggQZhVbxRhhlyvFFHI7XgkosvyTQjDTf3tMOMM85Ic8039MSzDjvSVUedO+u4859/BOGH3znkpKNOOeF0x6t1A4Vz0EDpuNOsO+/YOiB9z1bXX0HrrAOgrgMOZCCCEC1YDzgPTqOPQ+5cYw0wqeAiyx5kTFVEEVSkGIZKRFDxAr4qwQBDElRUWUUVOWzgAhX55jCEjTduoBUMOaABxlNeuGBGFXlg8YIRir3QsRFwdLFBF4aEAcMLOhSBg01YENGCBhZweQEGbYHplloXwJXzWgxg0FIYdQ6GR58tEVaGYosRpv/oYYV+poMRfA7qWReBGgFaF0MMJqhPmw2GtKKhgfYkFVaMaHUXLAo89BZxkAKcLsVIY4049kzDzDLMWPSqPPFEtzff2K4TKzro/B3PO4bHCjjffNcDrbPQHg7POwNGy7d08uijDz5/Y3v53oBj26w8zUrL7K3rMBu4ueDuk08+4EAD4erpXAONLanUQkodEhdxgwf00mtEDhrHRkRsXVCBxUs53JSTC8y74IIRKYxwgQYjnGABDCwU4YVXNlSBBVRSh5GiwkbQm0MaeAwh1AsttPC8FV4MfwKXKLjgwJcFGPCWAhfEwABf+pKZ7FUYOoRGUSBDnxewkIQqWMYlM1n/H4msoINBWY0nOtAB2XSAghiM6GAj6gKKOPOZLsBmMJ4JFBWQFIMhxCB4QxjRwF4goiEUoQeJkMUtcgGMZ1TDHveAhjOYAY1riIMe98gHRvzhOozwo4kY2YcUp4iPKvpjH/vABz7q4cUvSrEeSsyHGOuBDy1KcYtc9GIWtbiPesgDH9Lh4j3wQY930KOMefwiF/UhISm6DhyrgkY69OGPcRUjFam4xSPIAAYwrCCS6OvCw16QAxKl6GBgc1EOcJCDHHjhZMK7wAVQQEoLjMABMDjBC3CggRcITGVFUAL6ymKEF8QAeSMqX2iG0KMquMAKWEgR/EzApZj9jy5ZgYtc/+xigBGkoFA+QeHPBmUvKijGNRYcUWDqlKIuwAE0RhgCOV2IpCFA6kkxPJigYjO2PiFvCDkBYQxQYIQkVQ+EQ6ACClUySRzIYAw8tIUuojE3e4gjXdjgBjewgY25ieOgSaRHO9pBDyHeI6MItQdHJ0qPj3L0ohwdKUlLatKTcjSjKl3pEl2XjyXC9KUydekTmUhTjXKjIu3QqD2AMQtawKIORxBYFXxghpYIT19ECM0IIXWaw5DtJe8zwQlc4EFcUs8rJ8jBCDSAAxyEQXw12SAu75mCLviEm4IQzJM+eUFIkOwlWVKAA/i3FmVeoAByaUtbBGgAeBKqUMdLQ0tag/+FPb3ECkrQAaSM4IKV0AuGJCBBClJA2cqeM7MwnCH6npSizw5BBzmo7AgwUNkjvXCc/MSDFTILA4BuYhe9CEY0HtrQanCkGct5RjSqQQ1q+Ba41RhuNaxhXOMSd7jHXS5zjYsNayQ3uc1F7nOt4VCHisOhy3VoQxca0e+C97sLZSh4ESrRh5JUHMTwCCvWAIaoVIEMVRhnwoigsKU+rU+nCc1pLGjJW56gBaMdTPsmkBThcS8MSbBBElxwJQ/g90jo/OD64PBNIpykBRpbn4gw/IIJeEkBFtBZXPgXF5vJZZ9D+UIYYIhCFKYBrZDYEznvGQONdSEGJIBhZTGAAQn/SICUMhvBCEhgWsq6UMJDmMIUYjAFSJVzBDEoMgmgOYISLHmc5EQhHFqYghrbYAZ+CMUrZqELX+gizbrIRS5s4WZbsDnObmbzm+Ns5znr4s16zkWafREMX8xZz4IeNKHtbGg+s1nNffYFoxvNaGBAOtLACAalgzGMSxeDVM1QBjJ8kYtdYGINXNgTFqRiY3raKEnoNB/YaPmCE5jgBSiA3wdSIJjqbYAFKBnBU3BgAg1EZcE6GAKPhoACDH92nDAgAvE+SQU8TGISaRAmSRiwgAPQzC1g4p8B9FoAAcilC5YtZwrGiaTgCeITe6rnCzAQA3cPgQRruQCIlbkWCdBl/8gXKC2SXThDJj/5C01GEjRJYE4VILzGwMvXkmEYAyIkYQtO8IMjOjGKWcxiFBpXZCpQofGPiwIUIgdFJ0pu8pOjvBOZWPnKOwEKWnx6F2xOBctrbvOaVyLnlbC5zjOx85yvfOc393nPdZ5zSgA96ELPhMp9TglFKGIRf3gDGARTFiVs9oM31jpqkWQELKFILO97wQdaMMMUoEB7SSGYBqh6gpRxbyodc5JLjICHq6FgUk6iw0zQ9z5o44EvSUBBBRhwgLlMIExyGaABBNDtI2GABCJAUgpMi9kXHmwIGIAhBqBJThKwZQISYECQg4wBIUugyvwmgQpe6HDOAnwK5f90PTk3q7BzOtz1KkCnFYjABTK4wQ2KqITFX+FxkI8cFJ5QPic44Ynms5wTQ7/EJVhe/ZqbAhax2H4sRFEJ6luf+uIfv9GNfolKWMLoSLcE+9kfiUhYAv7vf7/75z//SszfEfrXPyWerohA+EEA7sEcsIEXkA3BpEhrvdC74dIHGVtqwYTwuAAK6EgOwNqRoEAKwMwIlIT9vEAFVIAJuIDA6AAY9MsJYBgMhMHdHQyNgZCAoY+TUIEg0IESlMHAfACXIJ5eCZDM9A8zMYDMKMCXyVv1KMld1BMKuFuSoBaVRV622ZuQnZ6RVc9kqZqNzRAVxJ65KRm9LOALdcwVxoD/FSzZFPQeGBgCK5DCKcACLdRCLaxCHK6CKpiCKZyCKOAhHoqcKHhCH/phHzaf8z1fIDafJ3SC9NXc81EfIlpfzY3fI0Li+ZUf/cXfI7zfI2Di/l3iI+zf/i2CIyxCKCrCIYxiIJiiHqCiG/zBHoBBAynBY0GKLqXIAmoMFWwepGxQDkQPCpTd+5wAACmJBRzACMCAVuDAGegAVRXBCcSSrnHVSUzPSyxb+QxFDlhAC1iBvbQAmyTBTaRIDjpAXcAFzsAFAwzBCHgJz4weBaiA5BkZkK2FjWTgZEUeBXTeBRjZzIDJl6QFkPmjPVKAPVrhkWDhiHxBF8heZn3ZPt3T/+vVXo3pEzmRjQ3sgSxYJKgAx/bBAiwYHyp45Ch4nB6OnCEun8iRZCcYIsqRXMqxJEq6pB9ywiEeIiEGYh+aJMoF4kw6XyZA38oVYvNpQlBqQiYMZVGKn1ByAiZoAiZgwidsAhlcQZE4Ddmgj4q1kKyVEjmhwARsQAvogAtswFkYQQuYwGihQPVogFUwm1doQBUUgQnYQNvhABgwwpqkQb8Iz6TUywwNAfx8XYoQgV+0SBLwRA7U21vQBToygFzQm7alQOoBJAbM2wVIADSVAC6BHuixRedpXonxDwHARemJHmUC2WQdiYQlyQshJJO9nuvRHjnxk0OWE5TFUBEcwf8mxIJFysIbrkIqgORHJp/ItSRLMl1xGifLldxxDl30LWcmXF9zQufQMWJ0CqImhIIfboIsNMIVbIG8UIEO8IQ4XWWSyFreoV1XogD+5ACWdMwGWMAFlKclwUAKbAAFooAGfB2seQAOJAEChQEk9AgVLJvwwAA5jVbwvAAWMA/ElUH33IQSbIACtIU4gklavMXNlICRVRn1qEBplUDn+VgJWFbkXUDlxUAJqEAJ+I//IB5cUMAE+BgFZKiIQlMxqkAKyN7uDVwK7N7VLJkLGdzuPSSS6ACSTIGN4AAUJEK74MIu8AIv0EKURin3bWQsvMIqoEIcXqlHxqFHeqQqqML/KYSpKXhkHZYCKpSCKJwCKqxpm5apl5pCKZxCLKhCLLQCLHhkx3npnvKpl7bpKcjpKQjqoK5pHJ5CnNrhoKpCmgbqKbDCo24kLNTpo7JBEoDBHZxBFVQJTtyS8JBlgAGFF7yEBgzmrCVBCOoAWJzACHxW3rmACRQMTOQACrwAA2zA+2CPyfQLs7EAMXpFaGlMDpTPVIBVHpzBGcwEvbhAWoyYtunV4clFBSjAAQzZCLBjDKSoj90V4t2VElZe9bxFQIZYOd4MKZVWiJZAaRHZ7g1Fwg1B6z2k7JEAihpcOZUAkkyWfcmePOnADKzBb3zEk9aClNKCRmqfRm5pl2Zp/5eKKZg6rCoYqqCGKaFSLJhmqUeeQivMKSuMqZ5yKZ+qApuKbMMKaqOKqcSqQito7KFWLKBSbCxwrCpc6Zw+ZRUAhhUkwQNdCQ50ZQ60AAqYAAWagIBZoAuwgA6cgAdkjwawkgmkhMlYUtnpwAeM5QbFTwW0Xa45QK7hiBEUY788DPYczM94ARj42h0Iwh14QRWMjQuIBYhN67QWQAPoVQMUCQscAF2gKAaUQLrilY+V6+ndlTJJqAJIZs7ozFq8qMysxbla3u7d09NcDT7lXjvOK+udaOslpGSpmo94wAxEwkc0KS+84RtKKfeh7pW6gsqyrsqmbCuAKesqLJfKYf/ECiqZxmEqvIL2lUL3ZR+WZunriqnKNizHcmzGamwpNCqfsm7DPuzzPmwsSCrEwoIosEIhSAEWhAYVRMWD4oSTtMAJdOUJzBpQsIAIJiMIssDJ4EBSvMQQlOXzRI9jwcQHuC0FXoUFLMn6LhuzjUAOFGMEtoDx0EsFLIAODFOKeAF4wsCIackCQLAJVADdNgAayEEFXAAFHEm6dl5ADq5bjEB6Ctlh2kxjIq5a0MXp7dsF9O0ING7rYStfatnmpijC9W3mYu4UIJyqnZv4RFIc8NDolq7pEmykWukruEISry7rJnHrtoIryKGX1m4cgqmgcukrvIIbvuEtHEImxIL/K5QZFCdx7D7soz5qyvopxrbCnq4xKjisHEIs9IJppGIpHZJCHPiAZwyK8DxoGdCLFWgYK33S3FGMDbTvCbTdC3DI+r5Agf7s86CA08iP/fosrK3q+jrM+vYqC9CPyVTVisCEIuuAJyXoArfAKi3JllhAAzQABC8AKy+AA7Bwh/btvfqtvfnYWdLbXe3yhWbbmFgoQF7ZlLlwYvLYPR1MLukwtn7olflYim6WCgzclqXIaVBB0s7AJnzELuzCLQwxwdICFoszEitxEo8zFrfCKqTzKmAx8GrpObdzb2bxLWwzL+jBKewCLoSz9GqfEtfu87JxG/epl8Yu7Mqxw25k/xyagiqwgiRsQQ3gQNXQUg5oKgdFTy6W7y6+wIK1Eg64iIu0rwWwEgukgH19UPVkYApYAdrh2qvFGg50DEwjsglYgPBg2NSegA7oS6UUwfNgoxd0gU7DgAYcQAE4gAa88ivT7dw2AAUQmYyWlgpoa+P6GAaYUi/bW82gMF8FJAvDaDxKtcxI5gjcXo7t3o3uXpKhKLbCq5M9GZMhJBW4RJtQgQYwQAYUwjZ3szcPbJRiXCxEqTi7AkeCMRhjMUeOc5eyMzyLc6T28zzrNS+AgizwQj7fQsHOAj9fae1eLJZ2XCrM7kB7JOuGLMo6rMraKZguNCvowQ+sgIARKUvghP8S4I9V/Wwky68ReIVHfxUYhIGLvIAGrK9ZKgwKoBPBJYkIl9Iot1ISnEAFZM8BsNJJNBYtyTX3AtPRDk8umq8BN0AFFPUCFMABOMABHEAF0EVAujDPwCi90duLWnWJqjC41gVe1VvniWhVY4AN7xuHTplcIw+25lLl8ig5SfONvnU5PRkerO0MwYUFSAErcHMv2MIt8DXBAnbB8jM/OzZiw/MqDHaVSi/qkrj21YKFN2ks/J8egMJH+DXGjbPuYjHHKdIUKxIqfDaOe6mMdyTtsinrSq9qs8ImiEEN2IAlUZbTRM1iveJ6Ps9fOs1XjbJHJ8EHwjQOfO2yUd6z2SL/kaVnI6cnC1QA9ywFTL9MrpmM8dwEFoQBTyCjaOVAEviFYrllEQS3AR9AK+d5eC/Ai1IACqd3CpTAixou35oouBbzV0umMqkF356rU/OtiO4bkRFcbKRWF7AqtvLoC+0wDN3rkyFkDMOAEXTj9JRJBkACN++1hQ/xG1okiXP4Ro4zjB82rI84rFephdNzPoOCynJCLJgujCsSrcc4j/dmb9J4sp9zjoO2HEJxnc6hKbACJPxADTiNDhBk1WQjLSkBDKanCwTKZ6hMxhxtEbySInPIBjgAs6VnC9ldF7xAKe2bPBFB26WMFyCFr023BViAx5AQEXhQEpTBJ/0shuWE//hUQXBrQAOY9yuDN1PbI2LmjI/RGwM4dWnl2y6L9cx8tb0l5qB3HsJ1XgqXqBEA0DjB67uikMDtGGu6nuydVRrIHpNRj00QQQzg4xDgwB88aTe3ma57s6TKqSvQoSjUYR7i4ccp/W/yKaMqr9MrLx4iuyvQgmXXAizc4dJrvdKDgsYlXx4mX0q6nMWNQsoJ5yG2OKjIwvbVQRQwwXx9HQcFSmz8ZZOYPAXmgNXIUqp6BQvggPj2y1V0Fb9HcqwRQRo4AE0zLVDAdMJ/1d+fQE6zwAlsD9qhgF8wOU0UQSfBj1VJRcKD4LMWtV5dWwGYsAK8qIqm95CpsJBtvMfz8v+VieiNfqjgquvpfdmXMdkIwPBCYhnCkQCTCfjM56iTVdZrxWaKxgAWbAEp/AIv5AIt3EKFbzEsLDEUr0IsTLFif2zHbT8VG3RBwy6XKtIrxILo3oL2e+QrMLuO+6bHHZ8pjIL8lynSI738c/0oiMLS16EpePPaAwQrTFGWcElCJEcOHUq6eEkTRokOHR9cXGBwoYWOMDlQvHhRBAeOEziKmDCxYQOLDSNGOKjgwMGLFidRWKiAIoeGCzlOnHgRssIJFkU0CLVwIgeMFyhaECmCpUrUIkVyUKHigoogOUVYWFhQoMCCrwcOfC2AgQLaCSkujKAwYQLLERjosrzQNkX/CQx3+d4dUUKFirwY5P7FoKJEiRGBU6QY8ljwiBiBVcQAPCSviiExYkyZ8mXI4s4kYlBJOoSECtJGbBTitYsWLVu3aNW6RTs2rVivYO2G9Ru4K1evhsMi/gp5qlTImTfnDUt481m0esfy/WoVceHCW63a7qpV+FaqVpEPjwpVKfTrUXlflf298FWxYKlSxcp+LVyyrCMCYiMJHHRIyIiqdCgwoRw+6GipET4wwoUcWPhpJBM+EuoEDVSKy4INPMqhQAtaOMGCFxK6iwUWTjABBxaS0OGFFV9QSikjzvBCBxSwUMKIFpTAEQsvWqDCEEGS4KqBBQ54qYEGFFCALAwU/2hLBbcI8ysxljBIjK4UBGsMhRH46jKFvxQTUy4KShhsiiEOe6xMwSrDbLEUOANsihgem6KLMvfcTM/GjFABgyFawIEMUnixDZZbbMPF0dxim+WV3GKRdFJLL52F006nw/TSS3OzxZbcKI2F01esk0U361y1Djj6oPPOOed6+803V2WBJTxVwruFP1ZIWeMIJMBIwggjEGIKBRcizMEFlFBobIIFXdCBBZJeCJAkHCr4yYIRYBjBxBc2AHGDoCzQQIMNrEDhAhaxSJEFEyyY6gUWYIAhRaZApMIKia414gUidGjBCzTuqCKJFzSoQMmynGQgXL0Si8FLxer6Ky8t6f9a084wX2DrgjgTq0ywtvaKy60LqJhiBCOmGHSIKcpc7C/NKuNs5xIeG8GxGCRLgTTOQBs5Bxx82EOWpmWx7TZdciHVllmoxnRUrDOdjmtTO8WUalJNfYVTSVHF2tPYpKOlVuQ+1frW+RqFpWlJlkCiiDnMUKKKIpx1FsRkdeBshGlHgDbCE4ggAgbGNwhXX5XynRAFHYhoQSafPEKphQs2yCADFjRcccITdGhRKQ9PwNwIHa51AYUNdKDCRCu8kMOLKmA0IckFGnCAAbIUAJquw6osjLDEytzYToxR4AyFaTEuQU+M80qBMAzyWmvQmB8zAk7GthRtzzxjKFnOxvT/BPTLF2D/CUBCGokEUlx6+WUYYIgpphhg/AfGF//7xS98UUBf9AKBCdTFAg/YwAXqYhcQ3MUEGRjAAj4Qg75YYAQx2MFcfBCEIFxgCHPRQRNK7YNUqxR/PvEHIAToDXuDCg6OhLgcWKELXbAKFTbzLGVRgXH72sAENDCCFBVFX0SgghduRAUbGQELpvnABVxAEROEDkcsaIDo6kWuE8AAczroUAuMoIToVS4HBctBFbwQhjC86GERO8CToKSXC1BmBKExE0uU1xg/Vs966usY9SbjJcSwLEs/y6OdMIMxlgiGS4T8whSopxjGAA0zhuTTEC7QEQ/gwEQ4WMERPoEL/1wIIxrSgIY17GEPajRDGciIBjWqUUtqUCMauXzGLpXxDGX8EpjBFOYwnxENXw4zlsowZjR6uUtnOhOZvczlLWlZy1piA5vc4IY1rIGNboqjGrj0RW0e4QYovBAHZygDGMDghSIMyHUbQIEScDgEIzhxCNNKCL9UlK8TjGACG3CAuPIFBkGcwQphAFju0pAGLxgBBdWiogtMoAGutEgDHvliVzZQ0ZmccQMRasHjUNC6kFQBDVgowgkaYAEHKMAAwjsA0GKgJsRobHw5oyln1pcnDJDAYjetzMmwRxc4XUxomslYITeDvbmkJi9uyqPQtJQCGEzhBSQAKmcuENActP+gBUnpAg4ysAdT9qKX09BGK6XRjGc0QxrV6KY3paHLZ+7SmHc9ZjNzmddi9pWZf/0lLAFr12Yc9rB6xessaclNbGLzGuKQbCvFoU1uUBYb1NAF3doQhDFwwQY6MAMYzLBOlTYMcWVUaA67ACgdbGBc+yICCk7gucelCAdsTAMcwgAHL1DhSG7EAha68AEG5KACQdHQB1jghYyKxCcwMIlPUPABiYQ0dh0Fq0JeoAM0oCEMOmhAcr0CJQY0ADN7yZ569wiYOW2mTebTKglEUIL67iwFakrLfRNDgdQA9TGAul7NkgcYx1DyYoGRi/kc0xigkkB7z9sMFbrwAg/sQBb/vPhFNLAxjXbcgxvLeMYykuGMuFZDlYglcTJYzOIVr5jFw0QGMpCZDGHaWBmIhaUyWmwMY7S4xctQBomXcdhUQkMa0phGNaahZGtw4xvfuMY0xGEPcdyDHuJ4hi1qQYo4uGEMUjCIFIrABSkwbLReUEJCPEIEKGLBClYhWE++aoTGvGAE8vRJC4KUBhRYoQxKoIpEivCid77AAiZwgAWatRQL5AAhLzDBCWCHFJxQVCEfzdBC1kywFlihoWfIgU1gcoACHMAAk1HemQpjphK0SU+b3EwlCSUCNcVABLmWgAR+qhoIi4A0iHHMZhCDli0R6pF0IhRQKaDUxbSpMZsh/8FTIbwY8HUBoh6QASZegwxrTEMd97hGMohs4ilDwxmHXQaMXdyMdb+bxzyOMTCBXG9yv3vd7l53j5PhY3sTmdyJVWWSp1FwJ0dZytPABjfUkQ96WCMYt8CFJNzAhjVIQQdHkoIUoJCEN8gBDHmoAlIKJJMdOtFgCIlIC1BAmBi0HHNFcAgddJAGPCTBC2qOCA5ycJCOtMACCpjABT7ggA2E9QPbbYG1sjvpo5vonkpY+rMqt1uF2osBC3jJAAZAGcZkiY+GTEGeDjwFwaAmBsymAAVy7V8MSGDtIsC1rSXA38SUQKvGTsuWbjYYvEM4NT/zUiEbw+ufkuACqXFieP8XJAM/4IIXwqBllaFRjB8vw9zScAYzDssMdgf83S7+PL3tXXrR75vFPv6x6V2cY847A8kEV/I1vqENKVtzGlmWRi5oIYs/rAH4UsiBoAudhCSA4btwMENIiBAjMiZLzveUyFdfHpe25CgHYUhDGYIkCIVUgQtgGO7xwRASj7wACzpQtNSjZy6Wxy5HejbBdi1nhTW7wAgUwYlwrcARRQOP6+6O1TQm7OYEMXgqMVDj79BCBN6OLnatAYEtLXaN7Qhl7SQALuDiLTCQS+bC5YZALyAMMPhuCLBtCJaNLgAvBqzACLDNATRgBZxAUXrBGKRBspKBGIyhGEpMyaTB8zj/z938LchcjPWKkPVQL/WKIQf7bfWOsBlMLPYKbhpoz/awoRoQywaTYRZiYVjWgAu4oAr4pgzOAA3AoAreAA3k4A3KwPji7HIQAkSsIM6SpQUihE4uAic+YAOgogp4LkLYsAy4QmFcZyiqIFk2YkDCKyMgiilaoF0WBAVeSg+r6+goEXZQYgN8Ilm8AAVMAGKCZwA05i2Gbnzo4gIoQDIQo05OBjHkzr5sLTXezvBUQAR2jQLrDgM0cAIYQAF4MQNZ5i/E5I7ypATW7qfuSAXapGYwBsIu4KcwoDRaRwkWwAEu7A94oReAgRnEAeKCYRiIgRhgr8k2L/T4p952MBn4/0f1jJAdgYx/lHB/dNDyVM/HkKHenhD2onAKtaEKq2EZdpAZuMEXUiEWMGEMxgAKpsIqymCd2OkO0GAO5GDj1jAqXCAkAEcJBG3OTgBesAfPose6dMAKdsQFbKAP8kAKysDM3uAEwAAkkgAL2ikJwsAITCCiQDK5gKdZNsBzXiK5KuBc3m/NVoQpuoueosUiGMABDKBMuooBGGDo+EgvJuAwquruDIkC0o6+jIftMADBJOAp4Y4EeG0XoXIC6Ejo0kJl5kIv/KtmCOXY1kQzOMNmqo0wICwFnAj/zssDeGALZOEXgqEYxEEZpkYXwBHJxpEZPM8dwZHFzPEdI/Md6f+RHovwx/gHHDNTM/cHHZuwxZjhGZwhH5VsH2vPCo3hg3yhGmxhFFQBEJgACnygRSynDNCgD5LADORADtTpDd4ADs4gCYYv474qrIyvKmIHXqaFLaJnQJJlA/imCMBACsCAENiAEM5AA+CAEUjCJdmoddLF6DyHAX4ydp7SARYgpipAA+YPE7OrAkpkKYzAjVwALoJHATSmq+DCGdfEjrbkSs5Eq1rRvv5uLNXEZ0rgLHdxAsjyF3mxF+moeNDiLfYC74YKqC5jfQIM8ZyRTF4gIyFN67aoBhphFwKzGnxhFEZhFvQn9qChGRiTxCwPHndQMjFzM2VUHSuzx+TRRsH/sUf3BxwpUwjJjRlEMx8L7hq0IUmv4UQzgRI6YRhSARU4YQ2gQAp8QNJMxAwGQRJwEw7uwAveoA/moAzYgAuKICqgYkAUQiK84KsUwnmeJ2QKBAtcoA+nEwmQwAcIwQxsAAfuwAXogBGOBQtyKwlg4gJcQilhAni6CtUO4Dy17j194iQc0QFW5wSyguaI7gLAgkP3ggKc0UvYAi6Kx5IU48GMB6iArRiLEQRzUQFyMUExMC0VdAIIoBctRkxCNRcxxlR9tWa6gDOWJy5MsaRioHWUZQEyYAEobQtw4Rd0IRpswRNA4RUCyMQ0jzFZjBiCgTMhUx1xlB7f8Ru/VQlV/68YvnEYvBUcy/UblbBcfRQeOTPIOi8foQFJr+EarEEafIESFEERcmEUTCESgM8M/AZzeg43qwAMboQO7IAh2UAKbEAJkoBvhothWsQ4a0sHACUGXuB8GMAFrAC3XGQFxMwDViA2bcAlT0AOqsBOseBF9BAmnCV4HGDogOfoGBVS11OeHicjRupxNuA3u2CkOvUscmZCFQN7uuoUL6CSEJRDSWACAiMGMKC+KrR6+G4X4U5K0rJ4JOBJcvFKsocqi2cCjers6EBoCIMXnbGTqCD9gsQKDMYMBuQFaiASeCEXhoEWTMEUcMEXlkGu+BWajCEYgsEYZCyaaAyZZgwZjP8hcidXcicXci8Xc2lMc4FpsZKMm6zh3L6psrBhGJyUElahFkRBWBghD9jgRRQiCTgOCcJPCuZgEspAzN6AKlwg53ZLCXDXBlrAAfwlBzgDZF8uB6jICkQCTUELDOwADFYgZTNgEO6gAXqADUDiDII3CUbqAzgiEg9gAl7KJj6AXcRivDzCAhhAQHQAzpoC0uQ2eYHnAJTnaicgLYSxLUqVSgBqAyWANGxNBMwnGaUtBeFuAiAMLPeOAimAAXjVaVdmQunCQjXDM/qEMOAFKiWjt8LgDKwODsCgDNyICnBAD3BhgjyBE0hhF3yBGOSqGvLql7oVGIbBhm8Yh3N4XXX/GIeDQRhs2Ie9EYgTV4h5+Ibp8XIlVxmqSa6y1XO5ARuMARQcQRE8QRVAwRN44RNAa/p0QAqS4AtT0hCkoA9wV8ykgOe8YLjCVAmOBQUqAEbkyXlKJloEKgyCpAxoKAk8wAwIAQlsQAo8gAXkgAV6AAqq4ACOrw55opN6EhOHdgEWxAbWswGKwis0wAHctEcshHY6QgdeaqbcIgMJgypL4BSj8i0AKi4w8MFeUQgmIxkDQ02csTKCcQQU4Gr965Z7MRcfOD8TFBkBwzIuI4c24y5acCbkVg7uYA56Mw960wyCBA3SwAzGgBV4IRYiwRJCoYWJ4bB+ycdsWIMg6IF2/wGByhmDSjRab0Fq2pmE3tmDJkie51meE+h+7icwh2HGgElxF9dzqwEZQEERHMESWMESnEASoLcIlMAO0sAGzMxKpSAPPuENVgAHWve1dKAIAjEjiqAFqqAMBOH9UCIFnocBUEADxkhAFOIEiuANMsCiJnYFssWdzIARuMADlKSj1FMpUcIB4qUCzLcCGkCQIdIGGkAHhvoFhtoFWKACDkADFuAFHuIFjGADvsIwJkBjFGCW4cJXCeME6cK/LnTuSKDZKqMxJKOrXE4xdtEC985tu0roctEAerFkiAaotMdq84ST/owOoughwCAN7gAM3uAOQpidwIAO8iANoOAaS/9hoENBcAHogkboFmZBOZRjFFJhFTQ7RddjFG5Bnm8hFTqhE0DhtE07tVWbtVk7EzKBE2JbtmebtmPbtEHhs5fjFTohRX0hlZpMGVZBERZhEVghEjogCgwhD8CwobwgCexACmrAB3wgD+wgCWogJXHCYpVguNLYBcqADhLCBeoQzxJ1/vCgbzY6B4pADgQkZU9WAwTZA/pmBZhgEj4BDBrAXHTgSQ5gAxRgiBhg6cgiLHDAA84gD4a6SfLAWzSgqRugDBaACuggDEwgIaLaGddO2ACjGAnjeI7NTTQwQFXAFiUA7JJHP4OxBHhRQjP8LGP1a8+yrtFyQR3Y7ar2L1D/oAuC5AzCwAyUr7DNYA4iksJHiwzRgA3qQBYu4RAUQRRaeJxR6BZKJRVSdBRE4cpFQctBgctBQctFoRbkGRdWoRM44bXPHM0v4czVfM0r4RLe/M0tQc7hfM7l3M0voRIs4c1h27QzoRMyQRfeCvaQ4RYUoRESoYXcYA/IQAoMoQxybp3YgA0YQQpW4FhQEiSUgOc0mg7wAGEIgSoIRCKiJyNWpwjuAHdxQBCERNRwwAaKgGW9oAEqqklYNp3M4ABOQFCDzjx3a46KTkkCpAIMYryYNQ/u4A0+YUxPoApCBxK84Lis2gKoctjQwtX+Ii34Exo5nHq0SgQYYNcQL02c/1GrfSYXKeBJXnztYCpWMxCmZvwp67o+RVx7FIMK4IC3Ggoie1NM8+DYBYEOIHLI70AO2OARDiEQFOEUoByExIY6RAGLu9wTJp7iKz62PUHLOYHNL0HPOb4S3FzO9TzkQz4StFnOSx7lLQHlV57lI8HNz5wSMsESaAEZlgHJnmEXFAEREOETCqER9mAJsHcQ+GYSCIEJuGASmEAKCAEM4MAgjiUiDgYHwJsj9jAjeUQJnIWeboQNueATCMEQ8GC8Nb0AKqAGCIEObMADNOBPJ70IyOJ3Lkcs1rddHMAEFiBayoIk5iAPCqABiqABDgAHTlIW1skFksQEzoAa19MIHP+AMByjVaeAFONiTcQkefQaUEpAbNkO7nBGLvxzeaDy7i6A3dMdLtidAQygAOpa3p8EAxOYP0dgt/AAD+BADoac7+fgJPugD+4A2dfAsBlhEAhhDfRADxQBFnKhF3zhatQGFUChtjVBtjWB+qk/tjWhzi2hElpem7n/ESLhERzBER4h/MW/Ecaf/MVf/NNf/cWf5R0hz1Xhx2BPGXrBEQ5hDwrhB2RgDQyBDWwAIAhhMZNnkBkfb3CwSNIHCxZBdLBUETToBYoXdFokUbLhQg4dH1q4sIgCSx8WXFjJYlRmEiMTGzYICKDBBB1IHxbo+MRICg4TRTQ4YFBAwdANYVD/MNhwoMqdCgUWLLABZoWHFWjuaECQgYvVFQcO2Bh0ogEDBS9MjEhRIsWECSViTBiB4QLcEXQxDGEbg26MGCRGnJ3AYMIFFRdS0L2gNwUGDFOopLA7AcMEBQouK2DAwABmA4ZHMB4yhEqXLkOmfPkSpgudNHDo0Jnz5k6ePnPm5JkziHaeOnzyEMpzR40eN4pq7dKli5YtW7RmwVolipOmTJkwadquHROmS5bCf7fkPZL5SI7Sqzevvr36RYscwZ8f/z18+/fXV3L0KBKoYcUwwwwywkTihx9bPNABF3uQYUMPPvjQgxkU5sGIGQvIUYZDRXjhxRlp5ICCBRt8kANH/y6kiIIORhBxwgkW4IBGD3ZIwUIOVhjRgg4aLFBBBhqYVIEDOKRhgwcaVHFGBhW0sEFhmYXxQgEMhEVbBUnYwIgNDUDyCW4+cJHBAAgcsEADA1QAhwkVGGGBAjkApkIMjjEgAQOMPTYBChfw+UKfKFSWmF2cYXbBBiNs8IJoiubAQgtpDDIJHDAYAcMFL7RoRBFUeGFEElTokIQXaJxhIR5p4EFHGF60FgYaYchxxhtv0DGrbrvp1kcedkAxRx2E9CFHH4zEAYgijtyySy+/5OJsLrjUcgt1olQLyrWegOLJtttywgm33lqniXfkkjsuJuSRG96666rLbrnlpruddf+ekKcJKsdEI0010RxTCSB6LPHAAzsYQgoZQBSyBRRr1LHHGp/k4UESRliBRQ09vMEIHRpU4EIOGmjgwgYoYBDDECOggMLIG2hAhw0a2GCHIYwkcQYjVWRwggmfTMJlAx0u0AIOfUySRwMVpOGFBjsPsMAAB3jgwQkuLKBBEQmBIQUjRcyhgQc4NFDAAEQ2gEMSOlShNpZD/EUCYxSQcOcFMaRohRU6fHR3GCG+QASraVgRRhhnhEEFHLHFdgcctdFB8yByJIF2FWnIIUdvaLyRB3G0ooGGpIzAUcYZYIBhhiByZGWGF2CUIQetZ+Sm+W529AGcIQVZWMgabjhCibL/vexyyy25DE9LLapYey223X4b7vPecgdvvOym61312FtinrvaRyLedpo8YkkmowwTTTTURKOMJwC7IcMDS3zCChlLQMIHH5/I8gkbERbBAgoaWQEbIMErDXzACF34QMs0sIEhqAwFMSDZCzaAhRxI7Q2jukMVkhCyChQhCYaYBAcbkIEFbIB0SaiCCUyAgw5pAAxoMEEBvsaCBYChDyfwgAkacIAyZKAALfFADQbBghkG5QAveAEPp1IDH5AgBYDBwAhI8JcLDEFVeGCEFgeRRUYMogxV2BXNIKFFRvSBDmgAgyHuIIc5pE4OtNtNG89wBi+U4XR9uCEh5GCGO4CB/wu0UVIe6CAHMOjgQ7h5gxlKR0iJvCFzcGADrd6gGzb0QRLDEQQkDLEFN3BCFMT7xS+GZ7xYxEIUzOOWJ6AXLvC5EjziQVd4zJO96nnvPLTEJS4f0Z/zeGc7jrDEJTrxi/OlTxmm8IMe1uCEKOzhDXVYwxYkwQcofAIXsqiDhFwSEx3UgA246IMOYgIYB7CJgR9Y2QuoECgHtKAIK4MEJPxHlZ/sUEt9KMIJdICDBRwgA1gpgkDRMMIFuECEBWiACVqwAAvQgSkNaEAAPICAB+ShEDNjhBxc4AE4aACJRehnQg/QgBSQ4KSPiQFqYpAGQeABD4JwKQHXSCE4MAJ3xP8xxCDuALlcneEOc0CDHCxJCDvw6g1ygIMX5KCkUoHhDqM7gxnKkLkNgoEOYJAIDhyim0KWwY5gqAIW6AiGM5ABDGQwAxvMwIU15IFWfSBEg9rgCFDu4hfCu0UtaEELWMBCW+CKHitduZ1LGHZducRlLRGry8ZGgpe8TA9kvacdTTgiEpXoxC6UgT5qKKMWfnDDHhrhzB+QoQ5MKAQf6kAGPqRVCj7gCQqUsAIpGIIXXHPSBFKghEM9qU+I6pMVThAGF1SAZz47AQts4IJB4EADDdCkCw5QARaEpbpgYMEdOMqlqSBtAOC1gBGetgE6eCBqB6iBDSoKBEbwRAMZMFP/WAqAgzJQNwlhIYEIMPC2CZDACLOlw0vxMAiaMWKTbNiNhQixVh+odQ6MIITo5mAH0RUBd32wQ1HZMIjN+ZFUcLAcGIqgg0eaYQ6iAwPrykAHL+SgdElAwxyq4CGBeqEKRQjrHaeKBdZJYQ1sqAIYclMHNRjHrr3IxV75GgtYqGKVzYseYcd1iXId9paOzbIuIcvlLjeiEVwGcy/TxR9KZCIXnE1fNHZxCD2IARE7AEINVlADJkDBB4PgHxgU4gWWoCANOTZEz35CtxEoIYExqQDTTKABFIhIByawABZa0IIquCAJk5gEGlgA3SSYoWZCKYABwnIm+JZhiZQMwAAK/1CAA+igMwaQUkQrsAIN1IERHPABJOYgFjnssAA7Q8NHk2Bd/oqABHXhL1Ig8tI+9KE3GjaEIXDDhmrPYZGmY8QkDAGHYLGhqG+lcIYzTYc3lKEMc/CCGbCKgzvYwENYeEPpvAAHGGbVC5KD9+qwYLoktJDGipSIWKtAlSScAAxvkOYT2qCHVRBvWXx9BS1c4WRWiuuX3AFPla08Sy13+bH9iax6vkzyki/C5GI+jyWQ5YhM3IKz54sGLwLhBj5sggNA8AEQuECGFfiAEWBAwiSqsDMNPMoDUniDDarbAj5VxgVW2EALOLZQFAhCCSiQYBoYYdwWKEEDZYCEHEJG4v8kfOIODBhAkBpQ6oQuDQfUrUIFTnCAVYs6KgWogCDwKzZJyIIPXHlAATKQhIQWwAEbSOMC8t6AOaGUBDkYWaoITDPcQVg4Ee7NJO3wBqMSAhJ9wB0j8iDtXelmDmXgFRjsUAQ2SAHhZ8BCu+lwBx381AtFMAMciiBwHRThq1Xw3I2DP/AiKMkLOLDBB71pBzkMBK1rWLgfYvHw5vQ1FqugDsY1IeXprcuw4Gfsebisni63Bz5fpg/605+IRCACEYk4OS/Pc4j4WOIVMKcGNYShCDe4YQ1CVANSkGNzYDo44AIswAI4gAMn0AI9sgIhVgYa0AJ9kgJDkANhcChf1zH/OTAJRLBCGkAFkBAGDhgTGuAFadACiuYCYRMydbcBkwAGYcEC0xVRJsACK+QCGtVQrHYACtBqg4AGRNMAeUAKjIAAPpABGYAAMcNqArAAAjAAFmABiEcCJcBfT+QCs9VsxHJTdsAF0oY7w9F5m0MIwUI7e7AHHTYHbGBUpSMFmYNBCZYHWoN6YQUHVSAHglAEabRnsVcFG8JPgKgEHxBWwSdQKnYCLdRjOKZ8VaAxd0AHZoAGY0AGYtAGikALD5cLfOUKsaAKqgAKlWA9ruQd4AdL2XNL5Oce5ucejpB+6td+sogIh1CLhxB/vRQJgRAflDAKx5BmynAMlKAHcSAD/zLABUUgBTbwCbzQBwz4bhtUBTnwASxRAVJgaWFgBSiQI3TQBRtQARuAhw5QATnACHgAIyRjBEk0JIBYAR9QARXgAQsAJAZAJA6wAIZACEyyAlVwgiYQACcgCBowAFgwCAFwkKy2AAoQFAOABpNQa35EhHOwAj1wAEkAFQMgAAJgAODFaipQAo+nAy6QRYOgYWZICJJICPlYEHdgBkmgG4o0B/lIYUH4R6XTRm8AIjjpeufWeec2YiNxBhuUVIijA1hwbjiQA19lfDigBMYnUL4nKjRmfCmkNlwAe7RCBnHgBodQCbWAC7mwC8VTC7HgCq5wCpxgPZXFfdJDLqeocf/g4YrrwUslB1nl9wjqR3KJoJfv134k1x+SEAmKsAjeIwr5gj79QgltoAZB8G23MWSf4Fxi9QaeQgU5kAOfQAo4YCMwknVJlCgKcAEGYHQsgAXdpGgW0DEmME4VcJQdswEw5QIc0VA5YAJW4wE2YAguUAQKNSZOIxV5NzZRSCWI1wIHQCInEACuNgArsAJggCb+tAGg8YN4ZwEkMCcxgAGOZgUxZYZmJBy9EYl9ZnpLRQcRNkaE0HmWI2+TmJNCFQbBxwVcAAecVwZ2EBEdggUGpwOlgwaIsyEflAYV9BE58EG8FwaSs0GtojbGt0FFYAMDYQYJ5wZ6EAic8JXPolf/2NcKpqAJpEhY8IKKs9RxlMUds/QI8kFy+DEfiXCLJ/dlsth+femXYHYeyOI9oCAMxtQvmeAGaiAGUhCkZ4MDm5QEmmMGHaIDWwcFdmADnFYEIgIHVNAyDlClS5EBOGAGH1AlJnQCF0FpUsEAPqIBDNACWABAGkAi4+UAFpABHtAAb/AJCGgGaEJdEdZqA7ABrGYUBmABL3CPdWdCC2AHZRIWhbd4rMZqdnedJpWOdNCdu9J5g9AHU7UrESYIaDCJd+AShBCeMDSJQZV8wScHd5CpWCBJkYRUbxVWScB7Z3NuaqM2FVQkgRMql5k2XqADL+AQG8AiWBAqRjCNWMAC/zlWBWRABmsACH5QChg6lk2mCqYQCuhiLqX4HeGXZeGhCZ4gCqZgCqjECZiAHuuXHo2gfuZ6cjL6fuo6o2L2CPXnPZwgDDD3DMgwCm4gBkGAACugAwvBAjpwB62aQrnnAQc1CUBQEzkgCJNARmDQgCagAE+ysGdSAQwwFKlZAQDkAlZqNfDoANA1hQ6gABbgTyjAAlJzANNlAHQXFQPwex7AAhtgBQZQFBtgAXDwARqpAKPmAi2AJqpGnaIWmgpgdwOgAiJAFyrTUjk5B7uyOXYQic+2OLuiSUF4B2ZYbkGFK7uSY5YDYYLwSHEFelxwBmgAfBvkbzTGRv5GrGWXBv+W+QI5QAQh9QI4cGPBmgMvkDctYARUYARlcDZgkATHypV+AAvNegu0EAscWgqgoD1qyXHi11hV5gmn0Ap+1QqqUAr1kh4nVx/lyqKIAB/wBx8yWgiFsK592a6RUH/iwwm8wFn8ggyvsJhi8AA2YAP8WQUsQAhJwEK1hwNVgANn8Ak94AFZR0GM4AUKqGgxAYOkwK9CsQDuxABUKL06YUAV4CPVlQQW0AAfcQCIZwJ34E/gtWrz1YNQs3hDMTb+pANDOwCjVgAfQAcO0JELEAAAUACEQRgWeQYDcFIkMAQpAlPEMQiQsIa4YoaWlFGgxysmKRukekZwVKqa42y00iH/Z4AHZaCkZaBUSpA3RnBIRcA4xsciRIAFRhAG6pi3OAADI8ACKUwEROAFVNACL9ACJ5ADneJ7VUAhCecHihAIsUALz4ILz1oKoeAJj6Vy5BEeh7UulIAeuHRZlqAJotAKZklxTra56icf8KEIYAzGtki67oe6tHgIiNCu7roI/YEJuKAMynBMuaAHjLkCXOADUPAGUmAHn3AGIQUHEgp6LAAFK2ACRmACGlsEedBzU9MRPAulsWcIC8AAL2AIaQBpB3ACQ8KRo3MCQdIxIUMEKEAECsA1wclqHzA2Y2O+4LUAKFABCtACFnAArXYCBaCceWqcexsGIwAAASAAaacA/1hgAVVwAFBEAl0gm3jQB3dgG4YwB3fQB4IQV4TACBq2OQ4cesLBkoN0B7SyU4TEtHJUBWYqOkowcDVmBXBgBbvaqn5sODlgBEpzN76XgCzwAl5KBWGAtwsFt5TWAsQqZGDABmMACIegCENMPMXTV8njCZggH5NFS9VTCVHMHuzhO5dAuaYEC6b0iZ6wH+e6CGEsxgd9CAa9CLdYxu9n0n+Axi/qroPpPS+nDLHbC4HQBmPgWnbABkigXmjTIekmByyRBIQwBxaAAl3wypPACm+ABEdiAnYRG9PYApDQAtRLYHWUAQ3AQAygBDEINixwAlhgm1iQvTbLAq1cdyKyav8dA14U+xMVMLN1NwBVEIPA9lEKsABUQAU/eJACoMqbpmptYyJGAAd3IAilmjkyhlVqZAg7nQegV1R1UAiGsAfBMUjVZgcUVmGA/AaUygZ4qARloARYkAZncG5eoJ9HmQQ5YFWC8AJVkERW4LZU4G9F8Jl4gdRhMAQwcQKZcpk2LCpYIAVksAWAEAiRMMTPYQu3gH2mAAqcIJgsN1nhQQmVQNEVjR6XdR6XoAmnMMSmxGSn8NFe3H7zMdKKUIuDyaJofMa22NKpy0uBAAiJID6w8IvpQyCHoAZLMAZI4AMFOAdQkHxFAAmSYAMHlwSBywJzR4EVUAafQAhjwAQ2kAT/goCxfrYALzDLOgEG0GUCNjDJwdsxvmcCBNUAFrFQYYA0GlAAFiBqngFeOoAG9dsA71gAG2AEZgIVFfAGkgAJaDAmQeIArMYACCkATLEAVXCQipECJ4QHuXMGsnEHP6VgckV6GBZhfLAHK8kGd8B5onNUfSA6RV2ArXPaESHaVUDaH6QEl7mIAvVcOBAR+vyUYW0RMEAEVAADFkFp63SZDbgjZcBzxg0IlQALfPUct+Bk1fHQBz0fjcAfuEQJUeyK5kEJGd0KsUCW4A0L420J8qEI74feoh66kf4ImkAKmrAIBv0HgNDSrg7f7/ei850I5qEK+E0NBKII/N0BK2AD/1xgBrjwCSN2uya7M1XgAW7qkPr5AYq8BzxwJCyQgRbwAR/AgY32ASR1ABowCZ9wXgdQJUECB9DbJVjAQC9eADJUABqpkQGgABVQvngHKZKsAXcgNkVwBwfWB2FhBRbw1y8OAAKgs0O7yhhQGCmgKnkgCHnQwXmgKgwvCTvNeds8CN/JG3cAepLEhrchHPTZOmlQbnDQB2/we1VAB2rjzhsE217gNy9AUGlTVsFHBEmURH5+meukI73aAkSQNxZwAkbAb1tABoigB6DwChLnHMfjCklsCShdf18W0SqHS/VBxZ5gCqygCn6F9KhQHZSgCABzHG7gB4FQoYGQxo2wl/+QEAq7IAzCUAkmbdCI8Ad0/weyuAh7+Qi0SJiWAArHgAz5HQyUIAZOIAM40AI2UAOMIAt5UFs9oIw1wAV9sAKGIAuQgAuTQAa4qUNsYqUXkL0V0I+8t0JmwgI1MAm8YAfSi3gu8AHuRGo6MMuafHcZeZB+TSW//NcjoAFnsAHAuco81ABowAgOYPsCgAOjt8oFMAK3DF4ScAEXAAeCYNgZRp92MM2POhyRyga6Ec3C8lYWMvGbswektzn1dm54gKCWI2Q5Vrc5hm9V0CKUVjhVMAdFcDlhYHxU0OdJhAImsE4AoeNFixw5CBrcUGFDCyVVxqxZ5EfUq1m0LNKKpQr/FKdIigABShSy0chHjxydjFQyUqSTKDWVigVLJqxUqVCJ4kRJUaBDh/wACuSH5yJEjRDF4dGhAy1hvzIpOvTxz9SphXqKfNRzUSRLnoQhixYN2bBMYrL8gFJDShkpHmqUIVQGEiQbhMCsIMSLFJctDzJIOWNjQQUUExhseFGgggYNDe6EOaDBQxIPK/JgUaBgwoYPODZoqODgRRgUFQ5QOWBgQgABAVy7FtC6gIACEwoMWCBggYHYqWnn+FDAdQEqOCZNcsFawIgJrRlgGIECjyA4dPLAsUPIDh48cAS9eZNnEKM8c+y8mUOoj6E3d8qHz2Mozxs7fex7qYIFTpoT/1XOgMGiCC/MqMKEJF5gIYkAWzAiDPywwMKLQYpIogojWnhhgw1QOAEFFHIwQQMLCDIhh4Es0PAEHZIgYw1ADkGFootiicUUTzTJyg8/ejpEpJEWaemkkhZRBMiuVJFFlVVWmeWVV1BBpRNLHFmkJ0ciaWSRRPRQQ4YOBhjggUAo2WUXX0bZ6SOpquoJEUQSaeSjRB6JRBNejonmmbFEEUOMLcjwgYs3MvDABinyyKO7FijEoQhCPqnBgwpYQAOODxxwgIgzFGBAB8YWsIABDXKoII87BlmgUQcYYOACBxbYUAMwcDDBhheKGPGA1Fhz7QLhClAANgEOUIyOYA+woP+ANIwAczbWZmNEhzImSYK1CWIIwwADDhhhAyWqg8O9Od4g5Do6+sCjXDbeYGSQ+vqIb5A+3jADDDbsyMMOSRiZY4487i1jPyyUSEJANGa1oQowTigCBxyS8CIJI3KgwgSBWHghiSRwGJVDg144IaHPWggNRRRNCE3DRslww49FUEmlSVpeicUVnCxZBBA99OCxx0WyBJLKRYJWpMhIOBGFlVhaUaWmmqDMpBNNONEEE0cAcWKHBxB4wI1MRonlzmOUiaaaXNIEhKq0//ioEDcT+aioRyzZBc9ojBnGFTEeMoQRSZCoDAobuLABByVaqCINHVp4gwsNJmFEAx2U+GD/AxNOaMGACho4wYgXPnChtAPuwKKByFrQgIELI1OoUZR11WCDAxTAdLbYAlCAN2ddG6CABehgVoABDHgBkhYKuC222BYALYMDFiiAgQJGQN2CCVygY7807LCDDTD8peMORtK4l3tG7CMEjjMEEcQ9Ouh4QwpDICGEEEPKYKOMCOnwooxvG85PElqgAx3kYEUaG9gLqACygnyIQS1YiIdaYIIWhMwCGsCUBRSwmAw6QAGYcxgZ9DAmmDlpZrE4hScw0RE/7OwnL7pKIoY2tKLRUBGOOJIrYIGKVdRkFrO4RS9+8YtbZKINSglCGxThCVz8gmzKCIZYhhEWZQjDETyJ/wogdOSHP/zEbW6KWyPmdotjUENPw6iFGrRAhkZIYhNjWMEWGIEDF3SoBaDTwQVcEAYlMAAPaVgA+1qAKRMQwQKYWkAOPqEEHeABBRsQBBYWsCoHFMABKGDAAoqgBEMYogK+gx7yCnCANBzPAAWwgAVUAywGCEBbLSjDABpQgWZ54QAbSNYAFDCbzLwATAOowAlUqcs7OKBDaXhfGrCTvzewoTp0GAQc8sAI7eQLXoMwgxz6AAnI3aFejIBEHszAvXWVQUFFwELAlFCEKnjBCwTLQcQ8E8EXnMEEKHhBQSpoAsSsagMGOAFoEHmAV9FOARh0QAUUcjkfkEFHmehhKv9eMTNXbMQSLHThR3rWk6J11IaOwAQoVAGLGpVwFrYYRjWqQYkOKFEUvxCGMpRBjWhQw6bR8EVTbOGLmgqDEkHRkRZ11EVAfBFugEDEIh5RiVjg6Yy4aEMQslCHScjCEDdgxCeqUAR+muBCeMAACj5QuQowoAJpsEJCR2RIhcBKEHRgQOUsIIhBOOADSUiI9BxghTJoAD2zXIAHklUAFlBrA2dIlgXCUIBTTkABAlDAAZIwCRYMgFgOIOViX/XL2AzvALKUgxewULEBOECWSugOHMIDBzbcSw5nUO0d7lCfPKCPEXYwhGxNVYb3eS8P5aKPdtiQBiWUoQrxTEMZzpD/hjBQAUSdy8HICLi4EzhgVLF7wQsusAEGcGoCGpzABC5wyl2KMjOcWoCuGoAEh+rBExGlyCtSqIkpHUIPbnCDHn6SxY3yqGiHUESdREpSUYxiFDGzRTCsoYxU2IJsNX2wMoYR4V0EcRe9INsuKtFCDm9xi38ohNv2q9RIqGKK0ZDwLgIRhCDEQRKk4EMh+PAGFrjABdltARFeEIMNOCAMaTAAJTGoujAoVAM2WIwGKucqCmpgAYEMgxV0xYA0MKIFDciACcygAxcIZgAa+AQu7FAGHaRXA5EpM2NHaQFIGGIBvWNBA1hgCNNZoHfDi+wAIIsDL7zAAidggWIyUAAl/9DhPNlhw7/mQAc0yGEOumWtHebQh/OZCg3qMYN9+mAGMoSnXPN6gzvTkINvnYGROpiYDh7ZodCMVckOQBFiUABBTHX3vN2VnvQYaxvI0sYAuRtlBqAwBh2BwmkUaYUoqsYSQLhBDWpwQxz0G1Q1VfsjgQgw0kyhJFEUeKI7jYY1sIGNatxUGjL1xSx0geJg6IIXuxAGnqhxDE4AVb87m7Z+p4KI/c4pEqIQBhWHwQtFOGEJa9DCGsJcBzPcgVoDbAEjrKCDHrsAgihwgIlQgKIkpLcCHmiAWId8mAXigAWHtDWsLmWgDGS5An1A1QGKAIlPeODJp4zMJKyAPAWgoP8BNrhDET5rWckJIkO3iZ5BD5CDMJwABwvAQojAkIQVwMEL5tEO95opW/TcgQ5yuEMfBHEGL9Bh0uUyRB/UM583DAI8bwCQGdBQBv3hYH9KMMKHvGCEWLuA4qxi1QVGcIEUxMAIXdg4A8Qb3gtcwDCOJ29mfM3Yx4KpAUyoAyAU0UMnOQkVG1lhzvDbhmhPO6gZVRNHHaEJUIiiFKYABSg8gQpY0GLdzQiLLRTRC2PYwha0SEUtdoEMCZfRpjKtxjFqAZWP6CEO+cU3H/7wJh752ysyRUYweuGIIDhBDyORxSd40INP8OITLDC5DTAWXRdMgApp2AAdwCDQWbW8CB7/8ABwKvBkxnAODC2wAtMIshP4AAZoAMk4Abj7BFR5sgJoDOgJsgMQgHhSgN4hAjM4gAZ4gwaQJTA5ABw4AzkItG1hAGQpwc96HjAYhARZgQbAjvSZAzjoA0mzgztAg/C4Azl4AzSYA0bwutqipvropD4og0HQDjAgBEZQEIihgzIoAjhQAuIqAioYgAY5gZApiNBxPA+agBRAgRiIASKAAeYQL8fTDANQPMfaJd6IDVY6pdbAjTGoAz+gBM7rvFK4EUt4BEXwg9HDLxc6PdPTKM1bvdYTBRuJPdqzvbDwhagKAlHwhVTIBVeIhVcYhSlShmNoil7IBQxThl3oCUCQ/7Y4IMXoAzF+exF/4wQnUgZj0L5K6L44aIQ9kAQ2kAEfMANZkIUzqIJB6KvLYTo8wAINsoBgqiQ0iBwPMIRPKIMaSKgF0IEq+KQKuBwrKIgTuKUcYIATKAMw0IFJOAMcMJ0GOED+e55PQh4GeJVtEY8DYIFB84DPWoAq0AAc2BzGahZiaRYW0AATGLoBSLQZjMFBuANpuoMQnAM5GAQ0yAM5yANBOJgZVDtNIwR/8RfwmIMzMCczgAMorAI4iMYzIAIfowJDupbCMAx1VLwYGIHC6wIViAHNcKzweiw1c6U2bENg2Z0AQIA1kLZMOLZXWAWcWKFGsC83WANoKz1ABP/E/SqSR8AET3C9U9CIbluFWKgFXZgpXegARzCJXdCFWYASWrCFYkgGYLAFXciFWeiETsiFY+CFF4qDPow2adODPZC+P9A3uaEbmXLFXvCEIBADNxCDHfiBFYiUFZACNjADQxgEMCADDTiBveuOhNoYFjAykFsBWeCFO8gA0NAAjHMAaaRGC4ADPBgvBfgAFECDSbhCF3Ay5iFH2WoALPin54EVzOJAy7K5QbsNMGEMSbGsZumd2DAB/suA3SyADKgP7skXQQC7PriDN3A08WkX+JEt2ZI0acKXfyGX+WADMjCnJFg0JYAQ/0knLHgBDkEBBbgAFMAAmWSV3EkBDEj/gSHoghi4AMiyjTO0ndZQHgBdw9Z4jZ68L1FwGolaBVDAhIvKGT1og2fDr6XUEUB8EaW6EkuYGk7whI3wBE/YNli4hWGghl4IAkzABD3YBVvIBV2gBQPzhWUIBmNwRV8IBl/4hWM4BqAiRZ8sxbuUvkL4iT84BBLDBb8chl9YhT5JSiiQgiIwBBtYgcqwgY3xACTIABYIGQjaHBvMQBNgAUlpgCToAxfYvxYoJc4xuZMDGdopjYwzAxNoAJDrFxcQR4tJggOkOGLxgknIAfUajBMwjQKYJdzAAXfMpQZoi18qgHYCAzRogN9cARuwj+oUj3DJQXuxj0EwFR2sAtmy/4/wxJdxaa1J4FQzeAMcOIFHpQ4vsDoF8YLoOgwG0J0R2CXauIBgyQzxwoDmUJ7XuJ3XENbh+FUAcI0HWIMWcoUEXQVU8ISLcoRE6EM1GIOHWAMK9QO73BGlQlFM2FAO9YRM4IRMAIVSKAVY+AUUu686yIJjMIZfQDBfIAZnaIZnMAZkMAZhGIamkIVA2Jnnu9YfxUsQ86KiaIRIuAUkJaI2cII1YIMfAAI2YAQscJgWeCRKobF2YQwR8RARcQAT8AKUsQHnaQCzcoA0eAENCIMk4FQsAJ7ccYEPAA2CINk3oIsnk1lRQoEzO4C7ogPTkBQHeCfk8YAyyMDP9AAuWP+BA6gCUpCEpRWAEgwDugI52QKN8kADcSnIuWu05mSDPkhI9zCEhMSXtGMPeIG5SbsD9gAD96EDPFAC86wC1MGUmpwNXnMlXnss97QNXnENYwXWYRXc1gAAY12BNRghmnAaVDAFTpiSKvGDCB2DvVGDNbhWfCtFkIDKqkFRTfBcTgDdTiDXUhCFVfBER+iAJeiAXCCbYCA+miqGXMgESqAER1CE2g2KfwVYH92ZvCQqtxEjR4CFY0CGYkjSXNADJ3CDMdiBJSAFZsSCFoiYD3BZF5iMJAiRExgtDIkuE6AD0NicJzPT57mgMCCEM8iBC/gAK9guVnGADZgEUiiCBZD/syKoAG15svzVIF1ZAMpIThYQOsxygCLQgCLQgT7AAg1gBFKYhAbgAlIgBTrToN7px+eZA1KYgwZoyPbISDM4gzNgSCPMl9/qwXYZhDlA1fGYptp6gz3QOjSoAh1gFzAIA15sgXRSAhSI1e6KWvK6ncxQDsjK1QAAXGEF3GAlUL+FLOFwDShgAzdQBMV9GlHIhEjQEvuaXLMQg8pdA9LT3R2BSkzYhM79XNCNGnFtvVHIBdwDBa6RgVQoBggTBtm9ovxytjbAY2jTkQn1UbscWL3kIoNVBFQgXmMghl/YBUXYYjiqAUaYBALyu9DRAedCJhf4DAfQAS/wlm9p3w3I/4En0xXa6S4LkI4cwKBLOQB1VADOgCb8ex4NiNmnq6TZ+aRXOQA7SAIkAIM38IAeIyjuiAxaqQBDIAUwEDbzWAHmGbrbsAEkmwQ5WADZmgM0MIN+gYNJI0jzyI61nQRIMEKG5AJUtYPzeQMy6DRUhTssQA93ogPDWZw9sgIXyAxResPYuFXbCS/hKGK/DVx+JgDl4RQ4BIM4UANHAD6nGQVPuAQqgZs4EAMngOjKRcql3BlA2ApvrRrPLWNNqATQ5QRQMIVRsAVkoIZfeATO/IXfA4VKUISW2V3LXYMthrad4WNSJMU6qIM9mAr9ShsZUgRQKOQk3T412JssiAIPiP9h0HGA98SlDbA7DyAUD0Copeau91zqVUEBikOBKFQI2AyNCyhB2om/JNCABM7AWXKBNOiDYrQAMxuEEzCdDJjUGvgELkAMA9iAzCAWQiVUoZOzB1gBMkgCSNCAZnFARoDNImi4jlSm7KEDQYCE9+EOSHBk8uAXeGlbU5FOZJyDJKDOIqA7MOhIMhMgHfAM0LmAISDD+RSO2CAAAwBrBRiBEcAAAg3WwAXQ3AYW2hCvxwqAAeCC57MEWHCSmrgZIvGJCFWDLRgD5m4Rm3ahIuUKFLUETLiE6yZj0I09BJ2FaCC3KoqFSgiE3MU3fMNpnHY+u7Tpm36+OMjpvNTptwH/Ek3Q12BI0l/gBDHgElKQhR+QgiTIQhfAA3osAjQggxkAgjWgiw+AIG38tSHYVQfoAjqYAA+Bgc0QhDTQsQhCGQ344AOw02ASOoLSABaogngkLBZYATPoXxorAPlAFjRwgEh9wAVwART8rALIg0mQlCSorFmyOtk5AEZ42+4ocjxAFySnK0HYpjbTDkJwO5vtA0fzDjhQGANOtI4EA3ZigQipHPsEQxLI1fN6rH+GrBFQvMF7rAANYgIVJeShjejRs55LgdvwgDXYAzd4L4l6hVQ47p6A0GfbAuYegxaZUGl7kYO1hOruXOzuXA6NPVCAmV3ghVrwhIio0PIuxZs+/2+bntCJJsVoy+mqCLFEQIQiWQRL+IVhCIZgAIZfEAU1cL5PYIUf6AEb0IF00gHy6FNIIINCCL+2ALlLMajnYJUYwAAqUDwFiLVHuieFOoE0UCgPcIEMWAxy7LgFyKQKSCULwDJCaYAFkIMqYIE8AFMj2ICFRAPCsgFZGgQdIBYDCADFaHeevAFCXS44cIFPPgDukOy3JQQ6QCZDoANGqI7xIIR1qR/xQOFxORi4A4P+KYM+AIMyQGGvo7QkwKcYSIH3LIwxz53uip6Z9KDyKs4A5bnuIq9roVXkIeW2PgAaYIM6iIPS5fNU2AgrhopAX27nDlhALFI6mW6M7tbP/f/QSG89UHiKFrqvNijv9E7v86b59eb0OpjonP5jqgCwAOMFVmf1X4gFPI6DT9iEHwCDHLCxMrABOABHLPAASOAFYeCFSXAeJQsDVxGvHjOMNJiAF5gOiz2MWUOoDTiBy9GyIvBMLAPwSloMHjyBFcgAbiIWydSAsetHQn2BQbMsKZUDDBSlxpCDdkcAXRml0srADOSO0+yD93mrx15yJv8tQ9iD34IX+jBC0RYEMygDNMCCOchyLgADM6jm06yCDaACxHO8CcCAXAWW8OpVNJwAGBgCX0HDU+K58trV84LtFMgdTvkQlGkAH6gDNfADJbl5pXeEIpVW5a5Wc67cUtz/r4NdiepmdOvG6A390A8F3Y6wN+h7evMGiDoCBcYp6CYOwYII9/D582fPHkCADila5GjXsIzBfuHS08bNnzpFIDGq4mISqyJvCCVJIksYL1xzGjRYsAHOBgYKHDgowGACkTQ6sIRZ4IDBgTCDKug4sWEDlRMVTGjQkaSCiz5VHCw4UMHLpDs2bBiatCJDBQ9PlVRYsOBEgQIDWLzJ44HFzAMsTCwoUKTKDDMZNCyokMPBgQYZBtDB01hQHzxp4ECmI2gQIUN98uSxY+YNm7psCPWxQ8iMmTJo7ryxwQVMGTh90HgpgwWLki5EJoy4gCKFBQUKGDiw8GKEAQa+YaAY/zGhwAQFcQ0YGC48uoUNGoIXcPD0RUsNGqLUUXOolatX6lOBuuTo0KJDftyoUTNmzJo1bT7q0TMxkSORCGgJJpYYSCAmmGiyICeeOOgJJ6BY8p4ecfR3IYYW6jHQQAodlJBCdezhkEMTHYLIIorgklFGv/Ay3xpirGGDFIR8UgYjkyDBAhh51DDGJIWssQILBxRgAh452MSVUd61VQFPyimHwgaDnKBBBVmeYAIODZQhiQcZMHmAW2dg0YAGOJxwgg1pbbAAA265kAcXXb1BChgIJCFYA5BAQpgPaCjGwlILFFEGXAgg4BgclkWWhhd9TAYHI3QMYogddvRBhhlz5P8xxxxvcJqHHFy8IccbcJQxByN5qGamDlWUkQYVG0yQAgq6oWCBcwq8QEUOvU1wARFE9DaCcD/p5EBvtlpggQMtmPDUCS+08AILRWiQAX5qOOJKeq+kgoqEipioxxpqpKuGG+1a6MchiVg0YIKaKGjvgvlu8iC/kcTnhx96uIHhhRpClBCGHCq0EIl/HHIiiorUcgyLGykihn0/rFCDDYOwwYIZUriQpg0rPPAAAiskIZcDa2aX5QZ4vLlATQ4kR9wBCmzwQgUbcJUlzRWwAIkNhWmAGFfUadCACQ24wEIDbbllZBKE5NGHB1VMYsYADRRg5BmDrNDAHJDccIANcGD/UYABKLCgAQIFDAJHo6DKgUYZctwBxx17W+0ppmzkYYghobFhBqadvkHHHLHlAQfeaMCBQhJF4JDDtUS8YAQRRrTQQk46UFHsCChccAEMKfgsnAU5aD7CCE9p8MIGB5iQXQ465PC0CVV4sAIZ6WoCCyzqietJJeYeUojA7brbH7zwPTIggflycv31/HoCyvahcK+Jv4AInB/AAeth/vkA7zEQwdBDD/AfhRQSf7yJJNLIIrFQXMwwwQhTCcbYIAUwsKEGOPABq0DFBQ9ogAlsMFkGDmCkDeSAVh9wgAZYAAcoOQBNYajABQ6QHAwu7QAaIFPUMpABBjbgLjSjiQZy/6CEPsBhAYPJUs5ywAAT6OAueYBEZzIQN0UpBoUIKMInJlEBMnVlAQNIjKL2loc7oIEOb/DCGeZwhz7QIYuMyFQfSrMGQgBRcIx4g6jmIAg6VLEMbLADGOhAB87A4QxpwAIRRueFNIQhDEaggg6IgALM5cAIIyDCEEaQAxS8YFcOuEAKcAUDKoCOkdJ6QXA+h4MiJAEHZvBBFNbgBjGYAhaxMB57KhGfRSTiDwQzkUWmZwnq3QtC2HMQKLgHilDwkpegwASF+qOu8/0hYOU7JkTWZz6AQe9d8GuYieBzCFVkhH/DEIYnnKAGMXChCFIowwpWYAZGrKEPjPhABQiBC/9ZfGIvNrNAGmRBhwXYABIscEAaGHGmDLSgOAzw2QYq0AAcLIAFUEOTVwaRhBZ6wGkV0IASJDGISUyiDBnAQQUKQDM6oOAARZgDC+4ABihw4QFgeMPYKgAJQ6iwCidlRBmYiIUFGMBIK6QbIQhhB7oJwlOCuMMgwOAFO7zBEDmti42sZohBzMEQK0VVp8pAVDOgoQ9zQIMZ6KC2v7QEC1XAAQsqh4O7GNQFL+CkUFnwgittoAUoaMt2TpAYDSQBBR/wWZY0cIIkyKoGS4iCNkVhCvXMghapjM/DjAmweC2iEQEi0CUSVC/rZU97oBBFKUwhis16ApjmClgcjumQZY7/lpntO9+FnimRP0gEPo1QhCeEEYxhECMjqqjPGqRQgxV44Hef4AUTCMGIHGQgB5Cg6NssQJMTCKJIHmCEEhzgAty0qQEogKnPEGMBE1TgBWBAoVtw4AK3NAALXjiAB7jAhjO+wQcqBANBo7bEDKzAB5N4QwMGsAAo2AEJNYEEKZLwRLR0x0gH0IHTMiAFG7DAarEhah+AKghD9M0MWACDHSbRB6PmlBGGaGoeiqpTve3NDlJNFRzegBo0VEEJVagCX5PghU3aQAc6wIEOTOCBar3ABC3p8QYYSQQdtMACTtmOBS73AfFoYAM1sYEXwMAFHvzACU7QAypW8YrC0mIV/5xwhCIcsQjEPuxhjZ1eJPIl2clqokGW1eVlLyuKX74HEKZNrWhL+z70AUxDzywmayfS2EVo4hezJYYxhlGLba5hgWPxQA3M4KP1usADDljyVCpggaO1bAGDbMAj2+KACmTABHc4QwtOpxPxXOVJB8VSV8qLBTJloAE2UOHYPGAIXKChADShSVoIsQKaIQAMk6i1rfvAgifqty8D8LUJV8jFCoQxU3PQlB0gcQdD/FQOc5CNhjvzhktlClNvmIMUBmg3O4BqDlkURB7Q0JIzMEIOlqsCFlYDBx2kyXJFKIIOvABwFpxArVVgwSCNMC0TUCUDDGZwpRu6ABzw1QwysP9yEPyAClTQorCv6MQlKvGeRzxCzI11bCQOVD1NRFay+Woz9irbie3l8rKecM8h7GxMPiRzD6fFEDOdeUxAOOwQJfqPvCzBi0MnehduWMMYyLDbD9igABoAAgcyMIexfOCuGzhDEmzAcA0Qgg5FgIMXPoACLLigAQWvgBngYAEG0IEIiYGh1Kai36VdCUu+LkCtM1CDLTzAA3yQBSvAsAANoIELuRYiAsxgB0asAAEZKMIK9JuYNLRAoxI8QB6kUAAbYIEBpemMHa72KS1aqnHXtvYg6pKH0PRBp5k63BnoVhdQweFTJ9XbGd5w0hezgOI4MAGU/4KFsN5YxgT3Lgv/LIACKrzgBTlomgYYPpYq2OBprnHpHHgQBDc8whKEfQUtYDEK9zgiQJEwOZrRvHKW3+vlbuZXzeU851y6RxE5D1j8yM/8AFrDlM9EIAIiQAwiAIxERFOJPIz9AMguMN0w8IIebFMcMMEKuEALtBAX1EAR9MEb1IAOZMAH4MEkgAEjYFQGxF0VtMAHjAwcDMKvPdSz4FMYpIG2HE0JLUAe4MDXxAoLVAFNLEAVSMKtnQUHyAAH3AAZQE0GMAIpGMIb0FdvORUX2MED6IUZVMBX4QAeKAGc/E4DSAEZeI1GrdQbsNsbeNgbbBEVdQoYgMEgQAIasZsUzIFOndQcsAEb/5zBScEBqDACIVRVq8ABGFCVVH3Rv3EJIJ4BbYRBS9BGFWDRv/FVEfTYC+DAWmUfDoCBDrgAxbGACwyFS5kBG/xAurTBJRRPx9FCl3ECJUTCJcwSmM1LyTnC9NQfg8RczG3Pg4hClsWCLNSCLMhCLJSCJlhCyZnL/TQCNEZjI0TgAMqHRBwTap3PNRog0o3ZLfwCbSWaMByCGIxBHPRACA6FC9gAxUlBEbBA7mhAC8CGbhUG05hAqvGEA+iYIFTBQ9XOI3WBzJzAwZ2APTZZVzRK76BBHoDBBiSBDlTAAZkBIXBBH9RAmBgkGRiCDXiAFLzGCtnIHRghI2iADaQJFv+cUANwwSREARJ8Qh54jQEYAurpISNY1SAMgghKGqjM3krkAWr0AWawAYaxW2qc3Rw2pBnIASMIghkcXxKE0RyAwdskwRl8RhkkgadYJRjIQRhoy1lBJI4Z1AlYwFtYTh+UwV80RVjBAVXJgR2IUhuIASisAi3cwl3SwihAyIJ0loCgmZjpYiRMVszBXPdgliqogimoAri4wiokpimUAp39X4X0nIhABMEURIZoyML4wTZ6ZmvVjyLQwmwVQzIkWiWwixvsQA/0ARb0wSTgwAqMRg3UgAYYgAZQXRl0pEChiVMwAAPMFx1MwkJVwRmcgBU4QHQMwARMwiC8jQl4wRL/dYUGuABVgIoSOJkG/I7jSYEPVGFDgUEDHMAK2EE4PYANsEEDrMAksNQC0KQcgNoGfA15TsInkMERyAACSNAcmEFOlkWroNHghEqE2YHHqB4qYgZNqooUeIYZuMAddApQMuRU8tUc1oYSZGV5nQGOCMILWAEdmJcXwNhXAdwmmsAmdqJJqonw1UYSWCcOnMpn5IEaAAJ9nEIs0EIuwGKXtYcmgIIqdJZkzVJFBEgtVZab1dxmmYIpjIJmbRZmncIpmEIogE98XKND8FzP4Zn7LAxnvksDhqmJFAJFrMJsGUMyIMMxYEIbFAQU2MDu5AAiMoJurYBDGsBDeQBM2gGk/72N6VwABriFCWDB71wYHWzAXVmAAUyAA1wYliCUd1RBEaAJ3i0eCnDXtRXAXZRhq40nGxhCAzwA2c0BebKQB3ilBRQA0AzACnwCKxjCCnDAA4yn8N0BIdwBZ0zRZmiRUDICUH2KHRCOp4CGThWBRVJYbJABUXLKG/QOGBSBmXBBbZgY2mGRIAjCbXhBGNRRJb4YFiRBVWRLj6Eoxa0AxVVB3AlfS4DBrtoBG6RLIJgCLdjCjt5CLJiCzXFCkF7CghTI+z2WgSiIgtwfMCrpnB2sYJ2CKrBCKZSCJ1jClZZPzyVTMaVPhaRP0J0PmIamzoEmmSoCKmQEmiqDMqhCm/+uwRKAgQ18QD85AByt0JpcwKVpAEXlFCn0QSbmRAx4x69lC1VgSfZRyQtkkCGcyQEgRg7QAV8UYZvEydI8FCOwwdJ4YENNhQ3YAQtkQNB4wH5mCwuM6AnoAEXNgcmQASRsgg/8TlvQQR9ARhj0jd6gAajgak55QR9qSmZIgiGMAU2yQagQwiDcgSCAgRSwgVXFRhZKale2yk4R5RlUIhqEARbgQVaagRd4gRxUIhZQnBFUXw5oC4r2GAtAmRkUwRxyARdIKFFBgRMEQSCMwizQKyzCwinw0pypAidcQiaw3IQICPWoXGQZ5oMYrGAlJmRq1sM6wgL+WaB1LAOKafn/lAjAFAICIoL9wIv82M8iPIIiiIIwDAMykKwyxIIfIAQTqNAFdN2ScVLbPoUO/JMOFEELVAEcfAAO+AxxFIAOvEkSkAIpzIEKRY1ezU7TgGEOKAnQakCchMnUGIVXNEBIFQHN9MXUCFRY5UkqcoEM0IQJpAEYmMkgMAKAbcIaKMoPPEDhrIAN/BSuogEayIF/Bi4M50FPoZEbDU5ZGMIeeBhq5AEh1IVI7ZS75mFn3AEMmxMXrMEcwJgOvK3kWoEXXFgSrEYaVMEduZTrAAsOUJwXNAWb4JgO2IAPQAEqqti7LkEQ7IAirELs2oIt0IIr7F8piAIsgML1LMglRALJ//luJFTCgVwCILcZ99BcLoVCKSysKxyvKKiCKDBjIgDCHvgBIghgNJUZ0TWMAMpPifyB9T4j/pzcJ3MvKHwvyUZDNOyCwMQBF2htBaCAW6GAFCQBF+DAdgxtDL2JXX1OC2iAAqAACkzA0bIAKeCCHJyMCm0LVzDNyGyAF7SAAmzHqFUBI5gAWkDJQxVhCz3U1HwNN//FAWQbFJgMzSjXyKAFG8jCJEDBCe+ADJwtB3BA4F7r3WjRIMAwvEVoj9DtUm0YG9QBbPYBF4RYjPZnWr5BGaAuHHEBQw5CHjQaG8QKGtgAGkCiHMwhHVgu41TiFhcBFVABFhiBDrxAGBhCC/9cH8VxUhGM8RuxAaeQwQ/sQBBUwiy0MSzGAiog5mLaMSeome8GLL8GsvXAmZKWgsIar2IupihgQvg4BAI+TCWXGVRzsv1M8iZbbyOQ3CM0AorgD/6IWSWAY/iaMi+4yxJYmgP4cpOxLBaUAf56Gnd9BRZcUBl4gXd0FE9kwCQQQpgI1AGwLLQMQAuwhVtFBQbtUBpMggYUQUAVRs+cwZsEpwlIkBzogAEMQDJLkApygXCFyd8xAE08Fx/I6gOMQSFIgizgl7ddBh3IAWsbcd/0Z7ulylIhTtSuwQ/plBmQAUNmLhwUrh/6oRSwRh9KAX9xxhJ7ACTCmHlxaCXeAUT/yhgWnMHopAEabCIY5AAVsIAOzKFQSVkbMrQZbAE7BwEowKIbd5wrzPFizvFO48vLvXd731/+QWnCLqZRG6+ERMIjz48CQnVoJqDRxc8kDyBrOUQhQOMjSMIjwIf95KIjUAJYN4Mp/4IfyAgT1MBDGcHIAC0cQAIdQMsCKAAdRORD2pUD4IgLHABxWEBiJEblCBQ6PYvROEBH60B2pAFXOMBCHU0T2cShTtcmtUUndcdw1IQNIQEbfIIs1MAWfk32ZUABoAzXWl4UkIHeah0d9M1qtPYUUVUeNCUbeYoAhZFwfQoqsnZDEk6KAZFOsUEZiBQqzgFFpR4jLLFxQiS+/93GHMpBFI9oIGkrHsjBRisBwIEfvJ3GaPABH9QBG7AzKbWxG88CuVyWYoKCvbjcezOIJzCInOUSfUepKqzCKjjmKqBCYrLCL0VCzrEWVEN19QL4aglgoBl4/Dyjgl/1NOaiIigCRhjDM0jDMwhDJGBMFKgFRJ7AXX3ABSgBHmBSkVVAJxXhXbUA2N0Vo04AcbjACeDASvFQGFiA5kDJdmGBP72JuB/tAmA7TyjAElUAFphAGRCC1spFd3QQugpUBgARAniAW3CFciUG4L1BQ7kXmtjAFMkRQ1rGlw+CIMjtT1lOGZQBGHjK5BGCAEneRK92qIBKThnCN7FBhMptWf+s1BzcTeUQRRh4AWrMdeaGAZ9zUke3gEdzEg4s94iewZc3pA8zAh+wwRiwcxuoQuzeQi7YQiycwv7NGSeo3L24XGXhEmZFJlHP8WadQivAwqgTj2MmZiuIwjI+MiIUXaszuCU/TCYXE9FpMvUiQiPo8SNgwiPcD8ntei4MgzFEAzVEgzBYghiIARTwwB3IjAVcQAWg01OYQA6I8NKIB5pAiXghBQN8QAEQ/gZAwhkMVOZWiwZQgRVkCXe9ABHYjOZx8wHgL0+4xQn1hQkwgkAtGJk4QBEwwidQJQI8gNaaawOUNAa1BU0wQhJkgH/ZzlWlAdx+Sq7KwRRhBlBtRhb/paUbhcobmElqnAGft6GHzd43ZVhDgsFp+HAi3kZW3sYUg0EVDE6+pcHjXq4XGMG3/ptx4oFISerZESVnLPoakEEQyIAemNItEH2XzTFAgOI00NKjR5EiWcK0cKGmgZ5AiZJo6tQpVaoqlipl0RUsVa1ghYTV6qMoTpYaHVqEKFEiRIdgwnwZMyaiQn9wAsJ5s5BNRI0MStokyeAjS4oU0RpmTBm1aMpAOXHygwwdGxU0bKgwYcOGCydyTBKkAwuON2A0LFjgwMEBBwbYomjhoMWCAxssENmgwMiLCgzwKqiQZoMBBQZQWCjAgMEHA4YVOLCQo8KBBgdM4GjAyI5l/w04vExi9EaDByQPFlQ4MWlSgwouNDQo4HrB5QZFqsxJI+dMmjx37gxKg8YQozlz5AgahMYMIUJl7PQpMwcMGDlmkmDJ80YQoz594JQpkyfPHA1c3tg5bgYMlzNmvFR5X+UNFi9o5FTBL8hLEi9ewugvPjn+M4O5+JLgwow5tttjjDWckCEQWWq5pZZdaoHFlFI8eQgTgxBSiCFMBuIEIlE2usiiVjbiCBZXWmmlo1hiGemjUDjBJKVGfmrEx0YWWcQlRIic6RCX/gBEp55uYqmlRyB5RJIpiTrIEUdqOeYYZaKh5phYgnBiByk8aGCDD7pi4AKuuqqiCA+SoIORM/+wUoIBDdI6QAcl2lrAALcssKACyXRAYa1AK4jMCMbcWsCCAyJjDLAN1qqgNhMWIIQRKSBxoLYkNKiCFEg0WAEMJlAzQQMW1FqAEUYWSKLMDNBgtQI6ettPkDsYEUSOO+TAQo456ICDDuXuIK+PN+B4g9czijDjjUEEkYINZQmxAw4wkpBjkDnYYIOLIsgTtgov4EDjjDfmuAOMM6pIgxFuqTACCyOSQKMKLJTAAowyrLNDwTec24OPNeLQQw1OLMTlFlxwkUXiWEoJxRRMLElIk4039mRjTkABJRSRLWZFFVNiuYiVGE0xhZVYZIFZYg1B0QSTSIBs6cedE/kxkUL/gO5ppz8KcaknInV+BCgph4IkkptlEUZqLXmJRYwdZCBzhRM2oMMFry6IIQcNXtCqggbwXOCDDxyo9wAGUMhhAwcYsGCBF4hQQIMKNoBEkLocqIxuSRm74LAFFGDAAAYcmMBTujWYBA4c6KjAO9kKsOwOSNDwwA5DoDiAkDxqa6CBPD5JAgzjXIBkEjY8IHDYO86wLllDgB3kjuOa1V2OPEZ/w0A68gDDjDPkMKR46OwgxJA+7LhD3zzsyIMNM7gg5Axh5aCDDjC2m0MQfav4Fd4WsAiDiv+SCKMMJarAIVowpGieD0L2WGGMLdRwwo9DAhGI/wXQD37Qgxva0AY1/7RBDw0sICD0oCRABEIRjlDEIa6kiEVcMBA0EaAfOgiTDx4QgWpQgxicIAYxmPCEKpQKC/sXhCDsAGsypGGYcChDqajwhCYcQxZWeMI2IJCBbbiaE2jAgxWswAULKIIOdNCCEchlbnqLzVoypwEHRIoBOejCBuq2AQ0cwAKSQVN2UKABCyyOMYthjAvCwAC1KCBxknJAmjbwCUlYxgQ6sEEGMKcWD4AhAx7gAhPwRIYa1MA1NqADCxowCEbooAdIQEIG7nCs4FDHDMHxpO+OA4bjnAENdGAPGN6ABnb1YQ5u8oJ44DAHRhCCDX0YRB+ABYY+GIINbzjDHLDwhjz04f8MSQAmGMKAhviEAQz60gG64FDMc5XhXFWoQhkWJEs+sKEOUTDEkDaowUMoAhDj3CBNegakR2BiEw3pGCs8sQhMeGITm/BEhw6CkEcswhHrXEgkVhIThakhDoDYQxzIQAY1jEGFYxjDHnBShzGogQxbGMNUdtCBDvxAKlGIgkXJgLA41GEPJXXD/sQQBzcQVIFxiIMf4rAGMizBB2+QQhFsYIMi0AFNgTKBYAZXgQIsAE8MeNsFHLC2M6nmUBVw6gLSeIckCPVRB0AqXbBgAQ0oIDWMY0vm6lYBPPSBLR9gwQEWwII7WAqtCHgAajKQAQ1sgQx74MBlCmCABWwgWXn/MAQCMPk7ZP1KOYP4zSDMYCA22EFbYBDEG8rwH3W9Mg9w8AIO0MAG8VTPDrX8TSthGb0qgAcOcpCDDvyDSjlwSz9hqJ0V7LWtJJwLDmkoA3OqYIY+AI8Pvd0DG9agBje49H/l1EMBDZjAla5hiBHkp5DOqYhHtOQQgPBDOZGS3eo+MCZ+WKkKsyAVJ2ThhEGIAhSWIMMwiWENYkhvmNCL3iXMdwlOoO98xbuFLOw3C+j9wXt3kEOphOm8MliBD2owh0ngwARFMEEOUGAFQVRAUGthwADwYuE1TcCoLcADFSLDN7l1BU9YYMEa6eiWxCnAAoz5kwVQcAKnOmAADPiL/xxbUIa2eEBPk7iDa6Awhz+69Y+G4EMHMtCqABTAAS4oAhIgwYMMEAI45DHEIHTXnTsY4jhnsQOWlfe8ZskBDrubliTvwMrjQA9cZQgOt7xgoDKkAQ6cwQMe6IAFNOAmO2DQ8/b2ZQQrUCFAYCgfHdJgzSrowAdckAL++FAHPhQNJ0QrWksgMSWlAekQJYVoIiDBTk98op5UwoRQNvEJVauanjdrxE1yUtI6rGEL9h0DG+LATYMBlwwOHUNIIbEHMox0Db4O6UjrMOuR5hq4a3D2GiS9h2efdAvnrSvQbPIHg5FhBjKIAiS0hqYN6EAsJ3BUC/I2t8Up4AJ6XYsDTP+wAcelRglyScIHXODUIhygAHRksVrSMtQFnGCMsdnqBl7ggMwFLq1wcI0kV3AAGmziDxzwgBkYYQMysAIKsjlAAAAAgFb5wA4y8MBn0QAGwx4Hd3lgRB4GsdroOCeVwMEB+OjwO0m+XA6Mrd4wpSPMObzBmpFNQxqU4Gfb3qcKScABDtJwHwElgQpHPwMOmg6G8FwWinH1gBR+oNEeHKEDWAuwDGRAAwPLoNsyoCHW0O52JwhXDG4IohjIOwY3fNcNB0ygD/EehSX84L9LyCgHZNABDiy+A3FfgUYf34EVzECjBtbo5RXPAck/PvJLbHziL/8AzWv+8ovnwAM6gAD/zT/AragHAhAKmRUwSvgFGmjBBtKgA0FNwHBcfZzvHTDGu+CJBbDxQAU8ABd+H8BSbRl+WjSABaeaQK+QshviHGUCB5CrTHb4BCk+sYIMIAE7ZMCFJDJwAH6HPACXWUEeHj8s5czu5bqbgyEgMfRkQwIS4qIDeNAgD+SgDLqjk36DWeCglziLDYBDqrQuDfBsEJJACaIjmsxAPMzAtLzgXd7lDM6gtsKAbJwOD4bDC4rABR4gA2ZgiTxg9GTg9EbvrVgPAVqP9WRQ81Yg7jqg23ZgBniAvn6Ahpag134wCH6ABmig21Zg8WQQNRDAdFLwrZjwBmVQ9U6vBpswC7Vw/wulkPUGgAYHYACcwKXYYAvWAHZi0OQe7DUaRzIsoCtQ4AIwYMXU72286g2vL3AYwAPiimDQaqgswAToIAfQSv0GxYkGYW8cAAf+gm7sgquYqsIy4A0k5hN2IAMQYAUYgQ9UjQm4AAwKoACWDK0yoAaYoA6SBcuoZQ4GAXdYcRIM4Q3kgKR4yQ5u67B2ZxDoYOiKIw9qZ1kAZjqkIFkSywPxoFe8IA3ogLEQLbHKAA7C4P54Q5nCwFiowAqKoAj+Aw+oqQywwAQ8oAeW8AFaMPNObwZpkAa1EAvLrgeD0PBoAAjG4AgSj+3cjgfgTgcVT/HeqgHSsQEWoAq3UB2v8I2tsLD11FEg19GtrhAByu4BwnAAOiAIZIAHfkAGgMAD4s7kVsADvMAEJsBxAgVRGAADYkABJoCO2sJTumJQAsXGAkcK9qYKGGFvGkAHBMECvAAL6IYtgm/gWOUAVoMKbkzhKsAEwoAIhOoANKAIVuAmouD00i8DriAObiADkgASXkABBOBPgs8DPkEWAgIAIfkEAGQAAAAsAAAAAEABAAGH4q5/yp58w5VxuJN2vI5pto1utI1usIxwvIhYtYlos4hosolqsYhmr4hqr4dmq4druYJPtIFRsYRksYJYroNkroFfrYRmrYNhrIBfqoNnqoNiqYFjqoJgqoBeqX9ep4Fjo4FmtHxIr3tJq35cqntXqX1bqHpZpn5fpnxdpnxapnlZpnhWo31go3tdo3tbo3tYonlaonhZo3dVn3xhnnpfnnlfn3pbnnhanndbn3dXnnZVnHldnHdbm3ZamnhcmXZal3ddpHRQoHRTnnRUnHRXnHNRmnVbmnRYmnJcmnNUmnNRmHVal3RYl3NZlXNalnJZlnNXlXJWlnNUnnBNmnFVmXBTl3BUmHBOlHFXlXBYlHBUlW9QmW5MlW5OlG1PmWpFlGtLk2tLkXFXkW5TkGxRkWtLkWpMkWlKkGhKkGhHjG5Wi2pRjWlLiGhQjWdKjWZGh2ZOjWVIjGREiGRJiWRDimFFh2FFiWFAhmBAhGROhGJHg19FhF4/gGJLgF9GfGBKhVw/gls+gFs+fVxCfVg8eltEeVhAdVpFdVdBelU5dVU+cVQ/dFE4b1E8cU82cEsua1I/aU06a0s3ZUs5aEo2akkwY0k3ZEYzZ0QqYEUzYEIuXUQyXEAuV0IyXj4pWz4sWj4sWT4sWTwsWD0tWD0pVD0tWjspVzorVjorVTonUjorUzknVTgmUjcnUjUiTTkqTDUmTTMiRzMjRzAhSC4bQi4gPi0fQSgXOycYPSQSOiMTNiUWNiESMSEUNRwMMBwOLRwOKRsOJxkMKxYGJhUIIxcLIxMGIBUJHBQJHhIGGREIHQ8DGQ8FFg8FEg4GGgkBFAkCEAoCEAQADQoEDAkDDQgDDQYBDQIACgoDCgkECwgCCgcBCgQACQoCCAkCCQkACQgDCAgABwkBBwgBCAcBBgcBCAYBCQYABQYACAUCCAUABwQABgUCBQQABAQCBAUAAwQAAgQBBwIABwEABQEBBAMABwAABAAAAwIBAwAAAQIDAQIAAgEAAAEAAQAAAAAACP8Aix0TyEzgwGIIiwkLBqwYQ1661EA6lkzZs2PMmCFThqwjR462XhFbSMyYsGPBhKlcWYwZtGYak/WyZInSpUs0b07aVbFZM2nSKGZkVlGZsowfjRr1qGxgr167okp9SrWq1atPo1KdihWrSqpCmfm8Zu3Zs1qQIDVatKjRpEm1uNGr1iyY3WUr7SZUWAwrL6m7eAmGiAsXYF2IEyterEuw4sJRCyOWnLhwrlyVb90qLLhwK1q0FhUqZEiRorWvfgGrCgzYyJQqiR07CZUhMYYLGboGluxgQYrHDuZuGOyXL1+T1ACLuWwZNI0cNyqDGawTsF/CgAkTuLJ7S5/KkiX/E9bp5s2clCbJSobMJzRp0pUaRSo/acf7WQHv6sq/6lSuT7XWWi+tBUOgXcEEl1IwyLgETTTW2MONNNDYMolabEXyli325MONMwktM9BBwQXnEH+B/YUYRPpJpcsuL8YI44wrMoaLLoXlmMuNjCm2Y46CYVaKLqcgMpppjTQCSS37ESigXatRVWAw+y00HDApCdjLeMKI15uJKjEUjEKq+XILEK8QdcxRzBx1n1LNLPOKLb/UGVt3WKq0zHThJWPMK5acF6hOnRyzkTPv1QcnffeJFx1++WnF32pRHoiggFiKCZtd3u0lUHsFIdQMNNZos805+cwzYS2RQLKIq5HQ/4RLh/JAU6KIfpZo4om89NJrr79A5RhjLLa4i2HGwjgZj4j9WJhmmCEWWWU54nKLY7egokskh5BmCCJKZqKLLcj2qh0xlfZSJzBRIejupb0I8wpCYy4zXkJXqnSdL79A8ocxhmK0UTMbMZURLp0Is652VmbHaTJI+bmMLTdlkol5mbwVjFHOAKWoTyA3E91R7HmEzGzv6qWSp55uh9CILG8ns8sv6xpwe8287FM01WgzjT/qWAONLJO0mlYkOO1izz3c2Brcb8cYI9Belf5KlYo9/jUjYJAluyxlze6Yyy2XRZsjtc/e4otgrcxCCyLdGmJIW5HA4ku1++1mVZ2/GP8mJsP6DgjMnCiL151u6yo82CxA2PJlR9CER998x3TCC9+qYVrgScws03lzw3CiiSYWV7xhmz9JM13IrIvckUZMLYWMl+I1SpF4Nuva2+66ssTy1Aa9jFBGBo0KoTnp5CNP07XQFMnzlGRiSS/2qJpzMQ0Gb+JBvwwmWGBP/RJVj7pEKyOOktGoLC47oo8ZROWXLX/5iZmtmWbH6RKKLpsc0i0ihlhLJnJRLPD9AkoCWgkvcJE5TuVGN1R5xXbG1Bt3XSdAw+jeX3jxh0Ms41MNIspRVneUZcgCFhrsXvg0VwxcLcMYxhgGK0hHw0tkbBKvWNOopNG6kHHkIC/j0+r/hgKTNrVpdkhkz83Yw0TafalmUKxZiaSYkdkd4z3XeJA1uHGNazxDFs57iyU2sYlf2EMe1rgexILzpd4Jy3vA6p6yFlM29PGIWTZiX2UuEzb5+dGP5bNMLo5zi1jkAhLdKgQiwNUIVKwNWVpRzUKw1Jo6FaaBnLpUpoIxJysVIxkIDJZghpHBN5ZCDbsYiEci16DpOAMmy+hFJ3w1GKrw7SmwCRMwhkEL0oludJp4SyeC4Zz3tC4jMEGGQ9yFvdWBzIhtms9QiAKx8MyOmtPMSO1KZjMYGsNP38xVibSJkGe8RxpdTOczZpEJSlAiUJkAxSiAcY2mMeNp9wSOrnjl/5jB8O17ktFjHXdEtoHSDzPm+9ofy1bQ+dVPkMeJRSETKbfTUEJtvpgMjNQloDppDRe10EXiEJQbvjFpF69wF0o66tFflDJFuVDDJL40nSqC7JXNSEYxXoELWgaLloKpioEwlwtOcOITwNSEJSYxPef8ZJo+GYoyHagXHUb1OdI0ihNnB7FsepWaEGuil5pjr7E6ERrQYOIyKoWLBRZGFaKzYSY0cQpVCKOez2FPFfXJxtsAVVrek2NAebTQy7CPj4yZI44SCsjK+ChH+MtFK3KRiUP8QZGFaMsleHGcHyGGo1CJDC5sUYtaLMxhDankMA4Jiz/1ohgmeSEEPcqvq/9x1hJqEIZYdthDsTxjF7C4zl+eUsuucNYXqzjq6CpmiU7swpzQuAZ4nkkUh7hsIS8zJ4XQyt3uotWcz2gGdLs7Xu+a17zRiAZ5x9tFawBFGrDYhCVaJUZLoCIWrogFKVKRCle09r1mIVUaxfuMaeIFcwhWTfe6R8eyVatam3nWg0driwqn7Ra2uJ+GN3M/a1nrfma6FiUWscg+FOIPiDCFLwhYiwqTq0m7cHGLa/GKFy6DGMS4sTGW8QxvDqMSYijFfl4hNYQYA3Hq4mydbDsLNZQivC6RhktEttuXFGSWxBVlca9SJ1/EQrmaMI8lMiGLAGcRp6472V5oZpdjFBj/rWKJ81enWWCyNscseM6znvEMsu+aRc7NUO9PoPGMUlxMEo24iehaEYtGk2IV+f2vWTzHDPUauDl+uk6CW+rRzoAtMVxDlrRalCPFki9slqkfH4dhSFpEgi2I+MPcGoHRjGotXiOpVIxpvGNj4BiGwugxDH3hCTH8oBOwGAZPXzPJnwpmbbaFyCHyYIw385CIIiOZnHoaFRX2R13GucUnPuGJMF8CaZkoxTAgJl2RpTkhhtqdvfSCusjJp1FOzDfubuel3OnuPh2ZIsBfgoyXPKMTNWmEIiRhk0zkt9GqQEUqYJFss/ipN8kUD6bFg64u8wtzxz0OHEeumMGQz3tZ/0O5qhsTJPnxQrK+4ASJR/OHmmviOL4Yhvd2ieNfbbATNX6hr3fpi2es9hJr0EIUaLCJThTGcrlRibMvt2Sg3kIWarDFM3gsDXtpE2I8NktIQtufTfuCFJwo900ikYlN7G8ZzWi3okaWzdwM7FEFA3jAprhPKe7qdyD8O80QYpRjELg8kmBEIhwhCUlc4uGxWAUq7hvc5sBQPAU2qzeN0T2c/xPnxx0Wy+FYoxWZPDHwU3Vh+1jYsrHCFbQoRBvWoAY1OKH2nDgOKTl7XFKS8heN0cUsIKELGBIjg32LhSTEcIAAHGAHNpDCJjKR7FKk5jo4/inI4VgLXPwBEneGhv+dyZqMOxNjluKLY7CWvH7MkTIW5Da34y8xilqYMxrTBVlNO9JVNXFqKNbkREjRJkyERCdjKAAXcAoYcLqzb8UwEsTAF83hZs2xCZTgCIqweI7gCJSwX6yQCm03fWUEQ6SkEr2hEDgmDMOggsAgSIh1WPQDPxNGGQl1UPQTP360YZoBGjw4C43mg40WC63ACp/ACaagCYdwE2ogBmLgBE4ABE4gBn9AX5PgP/7TQVa4CB2khZEwDDtGDN1DC3kQAGQYAAPAAixAAz7ACZnACbxwC5ZgC6uREtpnWymyCyHVCkDwC3jWHCUhbGHHY7JAJwbEfj8VPuBGSrdACp6gdjb/cQmi0ArGIA3RQEQvARPhAUTl1xxhcmcbV36X5yXfVGS342sRqBBh4kDdESYrwVIK1hopGEPDoAmS4AiMYAiM5wiNgGhrgYWIAAm0MBno0wuFYWEyNgut0AqusAqpgAqq8IyoEAqjgAqtQHGw8ArYiI3PqAqd0I1k1HSdYDHS8xbP8zxq4SqwhghsAWtW6D9p8Y6I5I7TNhqFEIVPOAMzAARtMGbIFl+cMArTyGhuQwuzUAtkwy87tkuuAAIAAABkOAAW8AEgAAIzMDqWEAu60AmlICUGYhXeExWzgBltsAlbNx7oMgzYt2N41guwUBWblmC7NAxndwmVQAmvtovp//YLiUJElzZWz4AuviIpQWlqiyFhBLWDOwgas7CUsyALPriUQXhCsJCMVFmV1hiEiJAHcAAHYwAHetAHKEYahZAHZPkHffBqGfI8FwKP79iOllVzcNmOkMBUY0ZG3XiXGlkKpaAKsOCUsuCUS1laBjmD3uOSfCMgvudSx1EKl+AJmGAITfiENDADNdAIpLRja/UkwVASJgFDriEMxPCTxnAmZWiGC9ACD5ABE2kTlMAJhTQJt7BgGTRyH0laMacGXkhKupdzMnRzZCULgoE5HVVJmaOCsihzijAaeWBiiLAJt2AWf4eKeXFBxNiUr8CNTTd9NLGdS0WO5tiWbvmWNf/XB2RZe+Z5nrXHhObZBm2QB5eljovgTpTQBpSJBECwBrOXB4YwGn5AlmD5B6LTdqmwCq8gC9n4Cn3ZlLDggzyogzuYC77nhZs3oRRKob9mir+GYxq6ocZ3fJwZobwwCZ8gCZ4AB08oBjsABGIABJ/ge2bhKbdDEfyHO2bhC38wAKUpADEgCBuQAQ8AAkiyCBKVCasAP6BnJpdxP6X1crlAC06gCiuGc1GKCSUgAC6QCzsGXLxwoHqpl94oX2vZCZMgGlpJe/9ZCP7iP+2ZB+2Jnu4Jl99nhXAal1v4KhryFhZjCaHQCd9YCqhQCsyoCtX4g26jYZjxe1KqGaYgCYb/4AdtYJ55sAfsKQiM8AiVwAiOUAmX4AiXwKiKoI6UkHO8eZkRWqoR6nnGwVnDoAvP+QzolE6w+l6veg2yWqu2ChS0equ1ikXm1ByxYG6mAAdtMAZiMAZOYGK+wHWwuqzp9KrvRWiu4AMWkAAXMAAGsAGP4Ak5EANKIAV+4Acd5C9tcHsdFKdpIadw+o55cAi0gAl0kAiP8AiY4Am0EAQQgAAEYAfDgBdvkRZvwVTgiJd3KZWWQJazpwfuWQiRMAqlAFLkgixQ4STnUqpSqgsyqZummrEaS6oSSoIRamPL4Auu0AczMAA4WppmmLImOwAgkAWEoAiM4AnzlyRJcgmD/4RzHLuxGqt7ueAKw7BnQBu0Qju04LVn3LV1vmAJmqAIRzh7a1CsYpAHi1Bty4BO9rCsV2sPWnu1sAoNuLAGUIABCuABJpsBnpAIMqADSqAD30qecHMInHAIkNCUtkCMxvIUQ3ccj7ACQfAFfjsFfhsCIYAAECABnmBO3GAP40dWWxd2jQsUz8ALljV73zoakXB1mNYcGfESnMsMeLaqO5ZBOju6poqzvieLprp1w/AJIICypbmysHuyZsgChCCzo1MJklAJleAJZSOlONd6DHU/TXoLoAF7P+tNOPaAwlChzIuZi2tn3vS8d9a4qhAJjeAIrrAIavCoFKkGeZAJYf/HrOJLq80qDIcgBkmQAh5gAQZQABuACXIgA0qQBFKAsGRZCKbACrkAC5PwC+UHZ3l3O1UrDT3mCFwwBSHgtwr8BSIQAhAAASLQBcMgDepwD2wyZxGjDLT6k4dAnl45CH6AphTHh5S2W4E2Kp9DDLbwu0lqqBrGg6CRlMRLC0EIGvjlCqyQw66wwzy8wznMCmrgukIcuydbxGvQqI2qBwirB/wJln1AngZLllq5lcKKn+y5BvjJlWSwBoygCaEqi9MJOLm0ihu6oRFqxseXm2dcbTD0C/GJCJ5gCrJXeyoqBmoQCyppFgQcYH62Z8cHCUAwBjogAx7wAQYwABLwCF//MAVTcARasAeDAMJ+YAq0sAq3AHQuEQ3zoA3p5QyejCjNsA1CswyC4Lci4Ld3cAeoLAIQEAKnTAvSMA/2MCpo1UNRlRHcYA2dU7B5MAd2sAd78C2lAAu1ADDx1ibOoAzOYEXLUAulQAuUcGKjQZ5m+cQGy55byZ5Oa8VY3M21h8XpqQa0h57eK7soi6NEbM7mHAD3qQY/sANL0ARYMM9OsARLsAP4vANGoM9GYM9L8AQA7c9MMNADDQQGDQeXsAis4HuYsjAJpDmu6FKjq3u6KaW+RwuNQBp+IAlzQAZkMAYg7YSUrJSxMAsRNwqcMH39Go99oAYzAAJA4ANJoAMu/4CGB7AAK4AJCrwFWjAHe+AHkSwJtOAKqjALcRgN6rAO+aBen5xe0bANtfIMmMDIX+AK9KrIX6DKruy3lPAM12APDxLWTl3Ll+gT8zAPhNYKfaAHbmAGbLAHhQC310lMmotMo5JTv9UJoWAKeYAEWSAGWbAEPrAE+1wDPrADNTAD+YzYNUADkzkDNFADki3ZkI2Plo2PiY2PKQoEDEmGDdmQQhzaAeCQnn0AWfAEjr0DPvADP2AERlDZll0DLGDZjk0D+NzYNZDPjZ2P+EizN1ux5aODtUCQQJiMqRAKKQ2mRtMIi3SF1UyWwsqe43kIkGkIe6AIWAwHZIAFt/fSD/9wAAcAAgfw3emczg/AAzigBDnQAjSQATXQAiuQCIt8B2FABmbAAmQAwouww5NAcZAQDNawDfSwXd51tYRGC0UQBEGACT2LCapsyn0rB7Tw1fZAiWgFFOf1XlpLwLrwB3PABoQ9ByG8CarQsHnGXRRiFsagCqMQC4ogBvIs2JAd2bVd2xN54zf+2JaNhmh447N92ROJ2QPw2UQu2ijrkJ892gPQBE2g2Lat2j7gA2j4AVS+AVR+2Vie5S8d5HY8A2pg0JaN4zj+AGRO5uB95mie5gdQ3iab5mLuBIOgB35wnk/rBCAQuylr5GU4AAfAAi0AAy3AAh/gA02wAAIQBHf/MAV3kAZc4AUePQiloQm0ID2z0I3QIMu5WqtX23XDQAh8KweYgAmP8OBccAVdcAe04NVdNKvMaqvNOgyHoMRrMAYhjAiakIxlRsC6OumvpwdaMAZa0ARMsNo/YM8/EOWrzdi7HdmxnduUHdmTndg1Hu0HQORJDtpCbO3W/gBYYAQ08ANqqNqqPZGq2aMSKeboLuY/SpEzkAHgrefnzObyns5p7qMgYOdLAAf9Kc7paccgQN5tPu8rC94N4OcocAIsYANjwAIFIAAI8OCA8AV2sAb6PhqNsMOaIAq0sCSuag/WYA25+h7Rtce+IAd+ywfxOuqE4Ai0UHSUmDqySrQ9/+aFyzAMlCA3kA7pmdV2qjBIOxgLxYtfJCYJivDRwJ4FWBAFAB0F84z0T9AE9ezPS2DQQDD1Tnj1TQAFUBAFUQAF8zzPWhD2YQ/szYfk2H7tZ6/toL0Ea7DdTCgGWBD2X48FWq/1URCFTfj2b4/3TIgFVGAFgK8FRjCR6GyGhf+QAp/44A27ar7u+CgGY9kGdkzH4q3mZ+6j4z2R30wG/z6ZN/DnLZAEZHAEN7AAAUAAWf0FiRAIkTwI9NgIpuAKpnDxrZAJO/YclkeCN4YueovK8YoJLb8MW8tDu9CNo6CdRrMIzm2wtseEKtoGkA7UIewHuLgIkdAHnA3wi/+jD/9QAyA9Bkh/2k/fBAAN0E7QBP5sBECg/uov9Utw/k/PBFuv9U8w918f9k1gBA8w2kWe9qWp9gAR4MCYNmvEHBQzZowWLA0dRmnoRIxEiVgmXrTY0MrGLVu0QLEB4sBIkiVHPkB5AOVKligzgIAZE+YMmjRB1KSR08cOIGLU9HF0iZIkSY0KqQFSU+kMEDRm2lzjZMwOlUxr2DhBxAsRGzE0CAgQ5M7YR4XMFvJTCFGlS0URXdK0qE0bNWomZnFSQwwQviBYlJhy55alQ5aeSZPG7Z49aNB2qXkQM+WBAZUtWw4wIMDmGYMM+Rk0CO0gR4razHhAufLmzSSZQNESW8v/Eya1lzBZ8uOHk9w+fPTwwSO4EeLFlxxZ0kT5EyjNHT6PPQbLkh0PNAPAnh3AZu3aWQ+YsUb8wSxZEDpxKCYjFvTP3cvGomVMlNiwyUj5QYMFjRo+nPAFMEABASzuh+KM6M0HAXfYwTcHWaCJBiB44g1AGmyqqQYNNTQiv75mAIIMNpIwYICX9mMBBy+qgEEHFzgoIIAEvhgrEbMMQUQRRAxRhChEEEHLiZdSU22AAgwo0TIBGGBkmGeSWeYaaay5ZzFonlmmkciILPIyLy/LwBBDzBLNDx79sCupDNY8oIEHZmCBhR28kKLOKKRo7rYlEtTth9+EY9BBB/v8Yc8m/5iDoiHn0luIjDGaWOKJGlLTjDVLLV3NMiDEg2OMgzw9SCL1LprIvfgckk026Q5iQgoyyNCiCR4iAsIJW21FKNeD6lIPIlMt2tWuW3UV1SddQ5VIjVuXvRWpnv7TwowTjLTghA1o8kKLFmLIIQYODBBAgBXuAOQORA5R68dFGiFKkjzE8GGGDDZgwAIbWGiggAQuuMABB1D6AARNjFkGmmuklCYaZ5y5cplS8hjjB5n8MpAHHjbEQcMLawBCEUUaWeRjRyhhJI+CJtqBQ+LGyGIMNthoIokkiKCZCBx0wMFmHHDowWIHGWxQUB8IJS455V57jb5UYcWCZeJazgKJGv9Y+GDNDFYi6bIDxGgDjk4VUig2U6GwNT4rUtUiCrWVZigiRbWYYyOw66KL17ruxjtvvQsST2+//6Yb77ny6KPwP/44JHHFD2lkkCMWKGCABqhmwQovWmghh8xPsE4ACb4ABBA//EBkEXUb0YQSRAoygqkWUNgPpg06KIEDDlxg4aYZCjFGmGSSeSZ4xBAjZpZD1MAi3twhnKEGi59PbgkenjCvjUIkoYUWV7Z3xZNGFDFEDz320INTP9qYY5A1mrCC5p113jn++IMGOmhBiS6aON32fA0KtbVYAxscBbYxrEEhVjDC1HIHk6sRyTIgWIPX5kBAsbWtIRDJgkbOtjb//61NaQ5JlBZew4Y1ZIEMwbqbTwA3lzYQrg+Hg+HiFgEJGtJwEpbYRCd02IlSvOIVsJBFEG0xRFzgYhe9+AUwhGEMgi0jeNCQBhSvFDxG0GABlbHABlhABTMQIXMwgEEL4lQAARBgXInQAyI0sb1YtJEWpliEHtpwQjEsQSIAys8NagMEHyzBPJ6BhCU68Yo2AvEVoaBEIeYThdz4yQcX8gGCltOQJyyBDAXxmph0JCYg+UEPodlDKPcASjOtwWLOs5j84rehDTGIla9E5fN6ZoQe1LJot/FfbMgwBzvMQYAsg8OrxsCcHmSMKSC42kgqcwAnrKEN4gNbtrKFNitg/2FtF4TIE57wK7XVSQofgY2ODgEJWPiwFuccoi2MuIsj9iIYwijGMX7HDGY0ZnjDk9LBDmYPfvbTn/8EaEADerBn0EIMGbhiASiQgRq0r0UxgEEOqlaDDQzAc1MQXSEaQYlIWMISk1jEH/pwsjQBCCdAkFCxxDDKxC0iEkWBROL64LUAslA8XYug1yQ4hzy4EDQ4KoQiQoajH4FPTIZIhCFCMwg9KPUIU9vQxXLySv5UFZawVCUOeNCD4hzhCLXx3xheJco9+FI8jloDGZ4gqw1JZjIg4Jse5iDMVzlqmrHxoDb1SslfQcEKddKCFBTSBEm4ghSlkAY/FyPQf1YpH/+PhWyVqgRQx/rDspeFbGYlSw963CMfjs3sZydrDyndAhE+yIAFEtqC9rkAjNyKUwZYcAMLFKAAGABDT3VrshbmwWu7Be5uCzfcng73cIaD4XCVu1ziMte5MITuHxpxiEWg6w9oUQQjMLGHMdSgBQy9KguwelWs7sxiteTqbXyQKPusYQ5pFdEa2JOFGtQkJmsSyWRO4gRlHaRpBKSg2LCgzeesLVVqa05z8PRNLUzECZ7waC/s4Vl5yMMa+uTGOcIRjm1soxraAAc4yEEOEYu4w9roMDdUzI1tmMMc5ChHjMsxjnGM2MYj1oY5wJENd5QDHOe4xzamkY1pFHkaj7X/Ei2A8AEbbGADFgiAAaoQA8zBIAY30MENWrABGyhBBw6QXA5c2IfglrnMvS0ucqO75uguTnEzrCEkIjGJG3o0hzvkoSp8+Ioh1mIWs8gFJxDBCldgQgxPoMEHxBveV+6MvOU9L1cRBNYmYIEMEZzrq5y5BjWUBwlAqK9NGMgSlYhBt3O8NHzBJp+FWPBU2PyfbDzoQfkcZAaLSIUlXjFhf7RDHtw4GDfa8Q50oIMd6XCxOWJcbHTE2MUjTvaz2zFjGlfbG9e+drVDnI1sjOPa7ahHOLKhDWpMIxrTsCxpeaGG1MLABVVjwQlQcALMtQAGNsjBDV50ghgoAQYNWIAG/9ysuDjHmc509qgg8VyKHr4iiEGsRTqLyM529gIYwXinMOAZz98tw+NPjEbIRS6NYK9Yxfw8mDSeUQpU3CIXiIAXnBYdpw3FadEYIy9/WClLSR8hwXsCoAQ13TU/5EFZ5qljDTY2scioYRGLMAuZewqHsw4wbGhrdXzQtnUP5goEakiFDpthj3y0gx2/noc82gGPYh9bHe1oR7OZ7ewXkyPa27C7t7Gdbb17AxvY4HbguT2OfZQjG+DYhjVE/lh7GOMPIHjAB3Jggy0cIQMFcAAK6m0DfGtZAw7YQBKq0ALVHgMZyFCGMujJDNQroxmvb0wzGhMNaERjSrWvfcinpP8N3vd+G+dAcYa5oQ5uWNgaJlexNZS//OObA+7tcHE6pI/saJvDH/TgBsltMQlV5IIUB7mQfjR0cwWS39FXfd7FYsnVIzQhl/wjyBxoGkE9+EGohRgpryayBAUFyAl9sAShaAQgQYs+0AM44Bur27qs27oGxKtcoQlKGIVOsIUJY4d2WIdfEzZiM7Z0UAcXk7EYuzZwqD5z6LAW6ztsozFs+7tsYAdvCDxwQId9gEFtsAbECLnFkAZLuImr4QEtYIMPqIwF2IDNu4EeyAEYsAB/OQEqsAIc2IAKqzB4oMIqrId64CzOWgd4kAd4WAdfw8J6kAcxxAd6wAfL4oc0xIf/NWRDfLjCK3SHOIxDdqDDepBDObzA59NDuItDcIMHfNAHf0iHa0AGQWoFWoCDpEi0OKm3RnREG7gBrTqlV0q/9GM/nwOsH3iNoJuD91qDT1IEStAET6AERUALk7ELTuOaFoqEVeCEALwEkCFAT/KtghCmAGNAB4QPa9IVmMiDCewEaLAHs6swbkA2Ojw2D4S+cpi7cvCG6jvBDguxaZxGbqNGcPAGbMSGEPOGd4AHbaiG4YkGa6CGebCHW1CTkdiBJdCCyzOSImQBSDzCHrABC1CtybEcKuiHfeTHfvTHf+yHfxDIgSTIgjRIgwRIgPyHy7qsNGzINNyHfVjIxXgF/0tQBVqgBD6Kxw3ggBOwOcyxOUbEHBuQxEmMpUokjlryKigArCVAMJeZg/KBA/uThDXKnlRIHUnYJENYl0Xog0NYBVfIBBzKhKEwHbPwpPmDrwGKjoXQOl2cDWDxOhAAgkwohU6QsHWgQ3mQPnOgQ19TRmWbuxFMtmiUxmtEy23LBr+bRnRoh3SoBtpLmGgAx2tYhj+AkwwwgAPYgSgggxYokQL4ACOspSazACSxABiogjOIyIhMyMfkx4NcSIakTMoUyIDEzH/IzM2sTMkUyM+yh2ToBFjIHjI4AkiEgRPAAA6wuZyIE/14Tc67AZ8RlAOJJARZAiMYmv4BLJZsDv8tEBH5GyVGqIQ1ugVfoAVQuITlHAqQ+QM1yINNmIVR2ARO4IRMEMABLEDfEo+zujpWg8oDi4JcUYhjOoRWGCRpUDtkREbpU4f3dDFvkLERDDEdO8HeS8trFDze+4ZtFEPby71oqIZqgCJXcIIZ2IAFKBEmkCsb0EsiHMkbuIEcIIIbeLIFWIAG2IAY4IJ+2AcPBdEP9Ud/6AcSNdESLdGFVFF/WNEVrUyGRNETldES7UzP9Id84CeHczlHMIKcsTcUcLIWoAFItIGcuJfY3CrgqM38KRpIyY3X8KbYQBqlcRk2GCVFKE5WOE5fyIVY0IRIMJ3EgYRMaIVWGIVR4AT/UKjOtnCL7aQ672w1VotT8ASwq0MIsJkJMUgFVdgEYZCHDzSH6Zu+9wRU+RRBtNyG3kOxaqRGwRM8aqCG/gSHKrE9kQu5KxkGP8iJDYicAZgrOJgDFiiADTgB2cwBCk2CHLhQDG0AD8iBYhu2ZjMHt3wH6HO+D3y7MRzDe+AHXjVDeShDfGhMxwzRiOSHiHRDMVRWXV1WZa0HfJDDeJDWfRRRiexVeziGTqiFWzAoI7gBzrOBFpgBI5VNCf1WcIVEiwmaAzEOSYKUodFElvwmb2IwXXKDPTCEoDAFWnA5X/DXXADYXODWWFCFM0XT6tQEoSiNAiSzN73FVXNAiJWP/wbTFfloDp+4hFhIBVlQz0D1B36wrG1Ih3UAVBDEthirz0AV1HS4sfwUvHC4wn3orF/zLBxVuVyAgxmAAqa4lx4wAy2wATYQhCh4gA2FgQnVAR2YGSI4AdUyANvSFxtDB3LYsBFzy3ZQBylchyyUh866hywEW3yAh2El27KVwrNF27N91md1B2jFh384VoHcB36gB36yhXMyLRr4gR2gAQbJiSEtV3MFV3OlTQe5JeXYkz3pEN2A0lSpV9kQET0oBEYQRVJwhVjInsyNhVZABVQ40+vMBOxUWEZQhNGZOlu0ugATsIYATzk9FoVgxxMqBFpghVIoBhUzh2c9Q/esO/+TvTaUnUazbDEby09qbIdpwMLP4oZqYLxreAZNMAAZIYI44duO0Bwt0AMy2IEWsAEXgESlVYIq2AIY+ADVUlB9kbFiW7ZxKAfnAzfO6lr4jd/45dpnjQfHLFuyTdv9VdsxfMNnTUN+qLB7kAd7EAZZwIVbaAUgAIG9BZq/rZ8Irp/niSTDxU3EPZD9aZXHfdzAkg82aCpFiIRIoAS4SNNTOIVROIVQAAVO2ARLoASOkgRHGKpBSEqHTd063cX4qFNQaUqxkogTUgNPcIVQqAXE4AZ2cENBRDa8I4dtwMa9y8ZpVNQOI95qFLxpJId3wIdvmIZ10AZuw9Fr8AUtSID/CUCAFUABzpsBKdgC14KBvnyUiPpepXXjLUgCGHgygMPQZmNGZvNj9xXDCmtWYGVWZoXW+/0HYx1WYV3DKzzkQpbk/+3VmZWHewC2WtgFW7iFQ2AKP2kQv5VgUQaa59kBdkVldu2TJWDJ2KBXD/LNMYCD+jMLRGgEdinh5dyE0B3KEQYZHUEL8alFOO1hiVWVOk0IAHsVMYgCsVIDP3CFsDMGaLAGO/QHfOhKvNOxw8tGbKNGReU9/XTUw5tGuNuGe5iGhXEGe5AGUmABAiCBL5iAL6AyFgDOFnABbhHXlGmRHFBambljL0gCrPi8BmCAchAHcQjBEHTLN4xDO2xb/2FdW3dY232AVneY2zXkhzY0Q3rgh3qAB5AW6ZAm6ZFeW7dt23+wZnpIB3m4BmHABVvQBVZg4Az4gSPAMgm1AQn+250IFN9Y11SOpOhZ3EKBUm/yzbXpEygQq5winOsqHXYhipeKhB8RqdNNq7QyZqybU9ZtsGKuUzIYzwJyJk0whUmwhdr7wmvuSrt7S3LOT3AGZ0il67qm63tYBxcjMmXAEkeQAAIggAiIgCAogiRMAi/gAXpzAdfavHzLgSNIgm/yAjNwAzbYgh6gmtRK6M1O6BnzhnFo6CvkYrdtzDWUQ2G16DhcQ4veaDY0Q14F6SqU7dmmwot2B2mVVn6A2/96SAdMPgZb4AVbyIXHe4AMOIJaIlzhEBpBsR+gvs0Dyc1IOhRIIRRcwpME66Ao0I2haQ6KEBU1iKA8GB0/KJw8GI9hsZXdcILsjrVUeUq1eY5PEau6eti6GuvuVARXEKSC0YYlHl672+biBQfe+zDes+sDr+tpkId5WId1qAa+HgY7IAAEQADAnoAVUIIW6IIwaAF6Y4Ewymd7KyYcyIHI1oLJZgNemiuQoBrO/oZv+OyTXbsrrEJvbMzZbkxpfQcbL1thTcP/BfIg1902fOQbTQdtuAdnGKJb0IVUqGmb1g2VrKXlpvKfee52laTErW5cso3b6B8J6VvjGFcI5gv/BfmPC6GJGpgJpcuJ3MAlA9thrYPv9Ejmpl7KuhKPZBEPWTaFS4AEXICGamgHd/CHFguHGiMxbp7iawTHAR3QaaBrckPwcpuGbaiwamCGZ/AFMCgjCkeAC3eBOumCGCiBGDiByXOBFHiBfH4fIvgmsXoZUbIDNxgDKOiBb9jsF8d1ZwRtKqRxKtzxsd0HKixbeNDx+41IYR/W1ibyZmfDIW/Da8ZACxOGV9gFgC2EY3qAQskNI0AO3Vzu5l5u3UxlxUWQVU7c2thy/nuk/vAB51EK3ZkBvu1b+zom3amvbmcC5qCNp4SOXWxKNVAI+ib4S2OChXgZLcgCRdAESOiE/2eIBnNYQxcLh28Y8AGN4rR89GmohsArcEW16wE9cnm4kly4AgIQAASAgBAQgSCQAQtwGSJIARTQvHhzgRd4AW4hSZppZhFxgzkYJUIgBPIxIF3/hg0LB3KYWkE2u3rYaDtEbYtuw9gOdmkdVl9/Vs6SLMnKB7DVegIGadNew8v0B5J/hVrIhWGIhYLwjRmAV99wpN+oJR6QULo/r0jrgULxk/0hFPy5Jf5h3ObwKkgxAiRAAm1qgvK4lSZwgkPRq7XSzfrikCZAAsp/fCzIAoXH/PIoD39/SmHqTvEQH/HpRDqggzS4Azm4A0HAAzYwBE1IhVCIErL7hxh74kYHsf8QI7EdI2drDDxvy4aOD2NqAC3QtId0I2MumHAREIEvcP4vkAMvYAMpoIF6YwHufR1uyYGd6QFX9wIy+PmYHJ9BIIRBIB9dT3qpvdo3HPRHpmipd1tHFltiewerv/GQHmSw3Xqvlyz/hYc4BAh97v7965ePW69Xs3QNa6RGzRIaM34sWfLj4g8fPTb24HHjhkceG3mI3Ijx5EkfF5cYaWmkIsyLTI7QPNIECU6cTZpkeeLkJ8ycOFvWKFrUyJMsPZUybepUC1QsWMRoGePFDJk1bdSQYVMGD1iwd+TI+TJlSpAROvDoueQqVC1p9u798+ZNm7VqequRAweuL7hsfgP/Zytc2C64vdmo2Zt37zE9e9zu2bs27AqBCCJCQAjh+csXNF6OsChdukULGDBQ4yBChYqVq2zczNFj288gQ7oHYev9LVw4u+PKtStu3F29ffjc4Vvu7jlzfPXqvXuHrnq8fdrhcW9ezx298OLHi398b/p05wP95ZvHrJQsWL5obRXThAYNjD727+8oMiRJJPn3H0orWZSRSiy1VBETDMJU005CIVHRTkABcaFQRBk1Qw1IOfUhiExJZVUZbrDRxhpjkOFGGXe4WFYQESAgQAA1BkDAHWz0QQonmyRjjz35fLMNkUQWNphfRyJpWGCJVTMNlNpcY0803BQ2jTPXSOML/yYTiCACBGGGGQJocWxBRAsspHkCCzGccAIKLXAUmxmzuaHHHnrglpsiffbm2zd2deONOe2ww05xyDXHHHSNPtdOdZG+o90+8LwDT3PSkbdpeefVI488y8UTzz/52CONLa/IMosvh6ghhkX4UYQgfwEO2BFHthZYoEoUubQEEw0uAUWwTEBBU4RDvbTETjBdCESGRhhVA4cehnitUk5gUZUXZbCxBrhecRFEEBPMGAAA6aqbrgBTyMEEJaBYYsuU9xBpjTXcmMMOkoQJJthgR1JjTTQFU6ONlNZcYw2WyjzzDCYJeLmZZxV/+cUbZ96A2mmoyXEGDkkQQURsdta2x/8eg6hsiCKMKPKNb8CVU85wxR3aTj2ZPuccO466A6mkl25XXc7NbQoZp9OBKmo8/shjTzCv1PIKLqmI8WpGNNgA7IEXaZSrgByJ3QNKFvVa4ILABssgFG030fYTcU+4bBPOPpvhDtNWm9RS2Da17bZVjTEGimqMsQUD6K67+OIIfKEDHJpk0skzQBaM7znnIKaNXtRA6fnB2yBMzcAER6PNNt9oY3kz0CCzDC57EEDAlxVbLAIJaZzhBRU93LBanDHIQcsjsG3hRcm02ZEybrqx7PKfv5GDjqXv2IxoO4tG91zPyH03HTrhiy90pe+gVw955nFKj9JFxwOPqdCoKov/LbT84YQYGe2g9doojR322Exykq5RhIDLKlawZOI2uMXtCXWj0BKedTdl5W1aO0BCA/3GlMENTnAcLNwYriAAxpFwXQSYgAwY4YlM4GJK0ChYNYjUF8517nOkQ9joDlYNGGqjMNzghjSksYxl0AIEBBCAADpju4pFIAhyAAPyiPA71LSgCnJwxSOssAUzmEE2c1ge83LzPEYwInrjGAf1JGWcdlTvfdULH87WaB3xhW9S2/EO+tbHKVChxzvyuEYtVCELWdwiEmIQgxOW4IP92aB/J3GJETqyH1r1ij+T9FoBK7IgiiDQWAV029ua0EAHwsQlEoRkBY2yAyNgUCl8//MbB6HiQcKtQQ1aKMIIS6hLAAiAC5gwxSeWcQ1nOGMa1bDGvThHOs9N42DLzCE2jBmNaRiGH9UQ4jBowQABIKCbCPDMxTaDuylwAYpVIEIOYoAaGCTBBqLRwlWwMps5oGwQhFgZy1pWRmz8ZhzeQON1LoWe6r0jO29Ex/UOZak6zpFSyslUOtKhx/CYh4/NgcenoGaJWXAUFq+CVRR6sAMbNJIJD3zQEVqykUnyRz+WTFAmFcQsTq7NWMSy6U6gIMqkkLIl+zHChRaJSgu2BAlMMapTXvk3LUhlWx9sQxtuSYBdUpUEj/CEL6TxDGJO4155qcbBtLFM0YHuYNjwxv838kLNwmyDG8v4wwEKQIAZcdOb3RTBF0Iggil8AYrIS4IOcrCaFiQhCVagghm0wMV5Ls+eiXBenyKLjvRYah/vKMelMFoPoMXDOtW52RpvdtDxUSpT9YjoROlhnsc0px/7OMg1XvEKXdAiF5HAn1SiEAUrSKFtbjvQEmpyhJS89JIYUVuwmrWsHthkJ82Ngm91WpFRxk25RvhpUZHgkh2s0iU5iVtTwNu3J2CQbz/BQhSgMoZa5u8FBFAcVUkYAATcARMPg0Y10kEZIFUjh8ts5jJJd9ZudHUaTZqHPYChBgNMAAJ29ebsIhABvX6BBH61ghRVg5ob9IBkWyBDVxj/mzJ7QjayioAjG7VTR0vZLHydvdQ7zLEvRB2qxkGTlHaWsyjUTnS19/DHPvrBj6cBoxO6uEUuYnFIMaA3vVrgrW9PGtyUGoG4LTXQAGGi5Yogaydehi4UdEusnVK3ug/0MnmVBUkJjTKpPcFJA3+iLScP7lVjGMIRaRRfxqErABPAxDKegV8E8zeHAL6hWEn3jW58gxpPUgc4onGNZ0ACCC9oMALCJGEJm2t2CJgACUbABS6a4Uw5yMHvOmxYL4RYxPYkhG5MrAhDtIMcMysHPLbDnUi1Ax3jyOxmC7XG4qz4jZeiXqWig4/UqvYx+XgMkOGxDnskoxS1OHIuCnGh/9w6WQtReAIoS9kSHkCy3C+pshFq4hLhwiSnzV1g23T7bZ/I+SdMceBOqutKCfGbzfsmb1F5mhSpqJeDcJgDGMzVzVzuWV1I5GUXhvGMes3FmcwEMA6fGY5tILOr2oCGNCwBgiOsQOERmADKQU2CIFRAAgmQwApI4C0zoMEMGB5Za5KQXhXNhg0nS5nzgu48c2RjOLgO8tByvdlxZEc5w5Yj+eAxvuvk+qHK4ZSPnZ2PfPjDaQqTLS9u4QurOWEGTXUymKPchLVp0ty/skhLhEsTUHo5p16Obrx1K5V629uVaM43T/st+PJGC6lRCJwsVUSGNiRiEIIggYTDNKOGL/8OXR/wReWcnXEbhjXRBzuHo0FfMGi0gkM68MAIEvDpCVSgAhe4QAVGEPsV8LUIZpiDnXgnMiIkgQpV6Qpt5nCylT1W6LrpCxpzDQ/XLrQ67TDHr9HTDnXIYx3rmE5xuFNad/RsOj0jyHOuPp6sa53rj+HGNYJhCVyE3Rf3o8EOcCvvtkklysEy85Y1qeW0obnMXpYCAOZU2h1e3GAB38mZmdVdK72ZmrHS4H1XTigFFkgBVFDF75GBHihCImDCHawcxTgYw1FeuizBMEjDPHAdOHwDzPSGYQAMk2wDlIhOwTxDH4AAEaBACbRcBZBAqElA7I3ACPjgCEzBWNSBHQj/H+55QW/11s6tCBLiScrAmvE5Dzj4w2VRCvPNETqYAzl4g/UYhzpY3/VtFhtVXY5JR3McCvixg9F0ymo12z1wHT60RxC9QinwAi+MnRoAAQ2AAP7gHRTUn2/dX7PkX7sVIrMAXt01UNtIAW8JoG/N2xMY4AE6gZdtmVJlwVA8oFD0Td9AxRZwkOLRBiE4Aia4Ah/w1RdsBgiK4LqQwsT9GDmEgwqyYAveYjhoA5TwUzQQgxqAwAZ4gAdcQAmMQBDwYKitALnwIAaswB0QAiGAhR1MIxsgT+IB3xdBocrA2qwZ3yAEQ66hg2UhXflUh6+Bg3GsgzqEofUVR3Vo3xlK/4f3sSE/WBZzuKH6UNSP/cM+3MM1QEMvdEIt7IIvuJ8TAMEM+CGTYUF0CWJ1NVfbHSKF1N0i4hvgNaIj8pYUwAbcSCIl8h0WJKKCvASIlFkDfVcGgQg8kYHikQEX0QE9McIj0IIrJMIdgMYHTp4r+oGgBQlwrCA2HMktFgYtes5iSEMwJOQJUMAFdAAGlAC5nAVarBztkRMgEIIg8AEf7MFW2gEbjIHghNgXoUw9iVE37sYgFMIgdIIzaEc/iGPVccdClQM5xFH1seP1ZV9y5FijdE/48WMbwiHS6KM/uNYfPUMnqMouDAMniMEM9CEIHFJTQUEBMiRlOhBEalm+nf/ZZp5ZAwEeuDWBmMnbazSQRx7gVIhST7SbVGQBFpSkSQ5cTyiVKCreGnhFGbwBTOoBI5hCLuRCTd7kKnKGTlJeIhhD5qWONvyJUDJJNWQDC1LTNFjDMfzBA4DAARxAAyjABRQBOUkluSijEHQBIAhCeTqeIAzCHtiBG4AYiM0TWY6YWQZdWqoMMkzDO/RDP8RDOaBD01mHpaDjOq4DqBSogX5KzmwWO1CdZXlWkLmWovADPxiNPMxDeGQKP/yDP1DGLpSCLdQCL+jCH6wBGVCBT0imAVJidX2mKGWI4FFXReIbuMENbByWc2kiBE5iU+2o2r0NFGhLazpBFgipE/j/RBMUaZFSZiAy1eHt6Cy1JBtEqZTqQSJg1TDkwiOURe0U554FAC08g1zcAzKBFTX4haB0Q2E42jZgQzf0BpREgzUUQy2UAhAcwAAMQAHg6QAkQAIogFwpgAVYwAM0ARlABVn6gR/swRyAmBew2hrAAaTqicqIkSEggiEUAqZiqh9IqFtaln9q4Tvwi1hpQxgaqDzQQ4GiKh6ZYaW4GKXgTK7JIz7cg4XSQ3Psgz44jT0wwybUgi3Mwi9kAoqMgRU8ARAsJN+5UnVVBCeymUX2H96JF44+YGjSnyACIpBWIt/lXd55W5MGjii6Z5SGWFfMwQbmwjD4gicEwiqCCQLs/xIScRONEMAtTNxcWAMNkQ442IU4tGkz6QU//Qk2hJXCCMMrLIIY2Kmd2sid0sAD2CkIkCgZTOqk5okbkFrw5cEe7MmkGoIfFILzDIIeDIKloBHSZQeAbkc54BD1VZ/1nSqqFmgfOdSuFRSlTEesNgc/iIc8pMc+uIM/lkInfGgu3EIeqMEaZMG3GQGK1lt4kVKzCsXfNcso+RYW8E2zWiT9AWJ0aYu2fqQTxJu3ia28HZ56haW4uqe4+gEl0EJB3sIjpEGMTJ7iBEC8PhiNJIAn2Gs+oE6AnZU/dUM3IAzArmALtsO9QMMzGMMtbEIqqMEBgAAQqEEoMG4nQMIh9P9BG+QBiUWWIQzCEbpBHDwhyghCIASCIKRnxU5qJYDDzPhnPATUzLzjO4ADkZgDgaaqqYIKzkwHpVSP9jXdPtRD1WXKgeKDcjxNMUBCLdTCLfCCJCAtGYiBEezEVOwdkH6IA0VtTpDZspKZ1SYFvykFm+VUIDJkE1gm3nmtttbbko5t2cobwYHlBbqn4rXkwSmCJuSCL+SCJwzngwVwZ0DAEXnBIgjDlPSt6OCQCgrKkGxD58CMv2QDO5SDP1CDMihDMzjMMgBDMAjDEC0DnMLpLvxBHvyBISSCrBkCIfBBHRih8JFl6s5wevKBeqrnHjBCNpSDNySJFw7HHGGU7Zr/wzoOaHisAxETqPWRIfHumlxWSq4xX1zmbKZQqDQk5q/yQizAAUtOhRNEEtjK2bVwLwaV7U3Z1GUGYppF7d3VX/rSXYW0L0gGjryNrdXuqFNxEEsOzs55gVfoSCSswm9iwhdEgOTZlRJ9iQisQAKcACZswisAST6kjvQkyZ/gUOcs03MWRvdACTEpA5ziizRIGjdc3zjIw/L+gR+QESM0gis3AhklAiBM4zSiDKJSLA5XrPDtaw/f2jugUUPxA+5anzqIjjmAijlowzAvsXHIpfLVLDk6lHZIqHfgzNPsAiR8qC3wAiKA5fQCgRPwwBGEsbaMMScqhRXUsZjZlN7p/+gaN2sbW6ZlUuR51dsSoCbB1bEdww3BNVUHdRBUNKIWXYESkEEeNEIq1NYjgAlniEkISFgQ8BUePIIjVIIvDIMsKMNcpA5wAEY2wEwOPUmAQYlh9AMFBwaUPFscPsZc5ENB7IMyWMIhKIIj1LQk3LQkOEJOJ4LpAoIN+4EqqyXF+gGeICpRUw88ho9wjENd1prLJjM1bEMYGrM6yNg6rFFcQjF3XEc0S7N21AM7pIM6cAM0QAL9yAIvnIITjIEUjIEYYAgVePF5XS+IcG8WUEH8RmuZkTFMoPEgCguzvNKyBrZ4cVv8DiDamW1rSsUTaMGxQIEUKMEVcEEZSAEcSP+CJ9wCLUyBl3AaCbgLIWBCbV20K5BCLhhDL9gCkFDyNyAJ4ZLpDWWDXkCJMclhP3Td1nHdbZsKkOyjP8RWIzzCI1QCcRd3cTsCIyQCVqZlpmbqIBg1oupBHvgBNpwRQAWUN1R3oQTbAiPMMSMxESezVGM1pbyjimGWdkSK9iHv8KYDN8gDN9QCJOCCLeBCLvQBEDzZPR9kFBiBXAMpk9U194rm/OGdIt4E97LEca1N2wD2dPndTixIvvldeoFZeuGdk1lra67msZREEhSBEnTBhxFCJZgCLaSBDnyBHBDCI4j2b150utpWJMACLvyCLFRO6gQlk5DObOurX+yFMVn/Qz7QQz7ww9ZBm37e9n7FoYbawysYdyVgwiVUwiVMOXFTdHJfanNnqlFPtx/kQRkNCjaUg6752jgIGzzIg1iJzjaoIzuqQ+asIz4Yh++WY9X5mnZglq9dln7+w6dww652Ai8AQ42rdRaA5ZK9pmvicd/dG4IP+Iy+DXQhl0l5GRnzQEVkBE21jUUg14dIWWAv+mGLWXSVbVMx1aHL0hZoQWSHeBl4yx4oQiWwAnG7QkFedP/SQiyQgibctCEswv7yAi7swjXIA5HQgzl8RzI/yecYhjOYgzEZ0zkYe1RrQ8FoQ3AI7l3gyz20gztgQzPIQiM4wiPk9E3XNJUXd067/4xQD7VRQ+ocaMU4RBMwR7Fl0eX0SBubs7mMDSgxbwMZGofQOPNCxUM/XNZlYZZ+4oM/cIM12ENi+gIe6kIeZMESVCBVKDqK7qj2vjMnNlcT2ASnI9clkrF20cqWafohCnYT8F8B7vNfs7MZN5VSMBUoPhkASsEWHI8b7IEhaILb9m/RuoInaAIlSEIjdGMbwIEhsELRwoI0LIy+9Ew6gAMNkWlhBCWW7EX1ic4Do442eIM4jP0D38M+zLs12MIiELeVH7eUqztyM8Ln2vLGFkIf5EEewAGJsoEzsOk/2RF3PF9vhAM6qCORnIPoZE6cGz41TE/49Gf41KykoINr/f/aO3jDg/YDPShMMPxBHvLCL3BCFlSvVBySbvkE9rJvUiUL96ZbX3dSpbN+s0bSEWyEcP2HSNBEDywBv60ZnIGbFMC+2uRdhfPzjpoxsSS/FWhBV/hBJGgCJ1wCJRw9cs89e7pBTqwBK9BCKfyCNBDMNqRDWFs9DRFJkoSDMyiD52hDPXThUgPHNpzD4yPU8u1nOZxDMEyCJHCCJlwCJmACQFQSqAnTJYOVJElipMjQIId++uTJo4aimjFYlE0b5w1buXfv0L2r145cOHLk1sk7t23dOW3n5KnbNnObNm0my5VDBw9eyI8+eZbb1y/nu3FD+/m7Z03apEnDfPHK1Qf/iJEaWLBqiQKliROvX79myfLkSZMmS4w8QbKWbVu3Ro4skTt3CRO7Z+W6ZVuDb1sePHoEPjK4x1/DgXsYYWuEcWPGbM1CoWu3LhMoly9rvUyWLFbMTM7+kHuEShIpUrS0+XPoEKJBe/TMYcPGyxYpR1jg4FEDU6xYpZZJg2Ztm7l64GxWqzYTHDhs56ZN00atXTts3rx18yZuXLZq1rSNE5+z39B91pjJilSKFKhLlTAhxFSwEiWEkhw5UrS/0J8/kDrpxJJD2lhjDWecmeYbcLLJppxsmssGG2yiW2ed6dRR56WYzDGnJm22MemkduqpB53qUKwOHXSEisebFd8p/w8febix5Y9afvFlGEucAMKHGbCAAosotnrCCbKaeEKsssByQi4jxshCrymN6GGwwRxzzLC2+OprrS5rwGGHvxDj4Ya/bkjTMB6yZGyHN3d4bIkr46qMLrksK4uJyi4r0qwnGVuiBxxy0EEHG5gQw0kqqkiCiEd7SPMGH0DYwbJHXKFllFqggSaaasxpxxxqqJmmGmq0aQ7V5ajZBh8GG8QmG28YjObTasAh55tv8NnnH3/SuSYZWQJkjyCB4hMIIUckWdaRRhaxRJZnrrnmGV4iaSMPbBCcJhtydOIHH5K+CaemlaLbxqWXzsnQHJvMCUdecnYiSVRyOhR1HHfE2f9nn3HKiQedftDxR55mDunkFl6GyaUNJ5gAAQTMoIjiCSiO5Gyss5y8E0opp3wLMSwRK3PLL8FEuUsxyQzMTDRtsCHNOB2DE0yaBb3yB9GW2Nln0UDreS67ds7Shzj/sgEGGG5gwWkaWDjBgxRiiAGHmGOmAQQaaNhhD1dcacWSZISzph1w3smGGuWowQacb7T5lBtnzLmHQey6uS6baWqqJlVzSuLHn8HpsceeZoIhthNNNEFW2Uoeify++2iR5hp7qn0mlj/6mIbCBMkhcfB6yMEG7lZtqmkmVLUxZx0NQQxnvJNO2nXeDstxJ+B94CkHnhj7YUeeVw6ZBcdhGhn/QwqtH9iqCcswM0t6vICoHoi5FAtZryrJPKJkk//aC8zxuzRMTTPTjFnSGhp7k3y+aF7zLx9+8IH+n9Ey4ued7e//aPi5ZgMazGAGH8hABiyQgROcYAMN/AAIPsACEMzgARKbwRgwYYpWQMIWz/BUSdAxIVRtY1fYoManrOGM1zUIO9iwCXi0IasGgUNe+ciHP/DxD30MBXPPwAUn3vOIZAkkckV8hEAk0YphXM4e0BgGKgqRh+hMqFv4wIe4zLGrb2CDhOcgR4jO8Y1zhMMcGaqJScZBr5KEwzrlwld18IEOgQ2lHCRKyjaU8YdX1EIWw7hFG5THPC18Zk93yp8R/wwJqMbwAAc4CFMjGambHsAJMUaQ324e2chGvq9LO7iBANWHNUn9ZUyc7CSbjDAm9N1gB/b7gf78xxj/8aCVPnCTD7rENa4RkAUPeMABLWCBXx7wgBKT2AEOkAEW0GAPnmBFJsYmjQS1Y4upq8mEpGMN5dyjVM1xYdzA8w1vLAgcL3oHP2zoj3/0Ix77yIc9pFGLRjjCcZAz4hEdJ4lN4AIXu6hFKRoRm25oRzze2Bs89vGO7HhjHOL4RhrLQY40okN2J1kRCMnRLgtl6HUclYc82rGikPSDHx+9h+F6YYld8HMYilgDGcYgGSYQ6TSngQITjmCWuMSlCTwN2mB0Wv+lwKQyMZYEjFBb9r01FcYwcFKlU8e0gxpgLWY8EOXMxuRITWYyTI/sQQ1q6b4dBAaSkWRMUoXKVKlK1Qe03GoNZtACG7SArjZo5JiKugSpHgEJTRhDJVyhiUj04hrcuIcNaTIdm2iDb9GJiXRY9x1tVqNBIAJXO+Ehj8Oqcx+Cs4cwXMEINpiBEPMxLSY84YnTzkcTBqHEaymxkETkJCcsYhA4zKMTkYakHOLZSU7EcxJ5zeQc7crQcTmaEni0AyTtLKk8DHeNV9iin75gBRzEMAYtYKEJFPOu9OjUUzpdyUreGxlgvmcy8KHpfOYb5SolJVWZiZKqMeOLVsfnyPH/cc2pNIDfDsp6Sd38ZcDyyy8O/EuD+rLyTWQyjCWRECU3VEITmSgFNAyLWJuQShvKARGqVDKNyCqHbRJC1TjY0c594IMe9yiPPv6Rj2vgIhODCEMOYFCHRAgRbKZIbWrBltr5CMQRjGBEIhgxHp2UgyPOOAo86IUOcH2Eyd7wCIs2Uq7hqqu4xVVHl5PLE5C8Ix7/4Mc6DHeMUvSin7ooBBbGcJEnjCanz6PMn+ZCJ8cM5pIlQ+8PXCY/p5ISTpJK3/nSp74d8Beqi9Ylf3M5wBn4N9KTNmUN5Nc/qTZVlYTO5acZ7UkGO9V+SFtCFJZQA0ZgghOQ6IU95GHDDVMj/xsdZtVL1rGN6MyaxDHshjjFQWZ/8QOh+9BHPPpxj2O8ohFu2EIvWTAHRwgREzymxbWxTQvVDvkRiSAEdhgKXG9MERvyCsd1AFZl7YjbjRk1Lpi9fNx1tKMnIXHHUNphOFvYYhe24IUm1oCFNWihLEWrcyET2aa0XhK9hQkMoNXa6Ke+ScH1tThVH03xR2d8vwOkdMc/frNaHu1oUoUfLU1+ab5sXME36FrXnMqXv9SgCUbYgyM0MYlXSIMbsmYsrcHhYenkmlSQLVWvTSdOj/Aj2f4wtj6OzQ9p0LgQY+jBBx7gtUTsOBF32DG1wUaLXLii21vfOiN2xdB5nWRv3/9yzoS0GI4tltvcIsroceH97naFtI7tYMdQ3nEPabyCzbhwmHZjKpnE5BRJTzrkWdmE3jVpGub+s3wr4aTpN5X80TXYOAEJyHLRSzr0ozc9y0UOJ5h73r8x93wndQkmXTp65SEHoPueQEs9XKLVxYh1PjbstqCfahowKdXxSxWdtU3nGzNpR4sNdw+oQ70f3BBGKRahBy+0oAEW0AId5CCHO4z/Dl8Iwgqm8AU5ECJygJDDG8JwhjjcIe3ekFdzyNEgCEmI7rYzt5Zph16IC8y+LEPAjEVOhLnM4x6CoRZW6hciAQjEoGJ+YE8CY3rOIksYDuVM7uVmb+RKzX5gztH/oIrzWC70QC8FJ630Js3jeIkFWvDRQE8GS0/SPo7SEgx+ak8HWY9rWK8GfZC/Yi8GwWQFZ8CSaoAFjMARRgESimEeDos4JqQ5PEwbLCQ6sBALScVvTEdd1uEeTspw3GH68qEZbGES/IANqsADGIADuiANwOAL5DAIRAABImACIkAESGAFgoALpiAN7iD8/FCLCPEbvKVBDjEb6m7t2k08xgEdaEJd8I4A1YFF3qE64KGdkq0Y+G0XaEEMgEALmEAKrMRl8AwJNJDhyGf0Ri7zwKoD/yvmTtAIVZAWoWaZnsZpYDAGSS/0Vq4GfXG/Xo/2OAkIA0j2RG8GH20XZ2AH/wioBjLAEBahE6RBs4AvVWDFw8zhsbJQxDgsVbpBHEyiHggHDKHOHfjBGnqhExABDqpABSRAAi5gCoKABCYAAfARH0VgH/exHkmABIIgCNJvEAnR3PTPW9iu3FZE7rRMRMSBO8ahy+Lty8DMQtBhHD7iHX7nHZTiGvhtGBDBR5jgB6DgwcrLaCBP5tYErLqkBTWOBjRv85pK5Dqu9lCwFlVQF29xl0rvF0EPBnUJ9DzPF91H9viCBcgHKSNNCBVsZWwQJ2txgqBmBiToAQoBCGShsObhGiNEbaRDHS5E+bRwsbaBHLYjooCns1osH1LiGWABDc2gCOxxAgggAQSAAP/wEQJCgB/5kg7p8B8BMwgK0Y1ERP9IxXTWaBGFKxy4YyIn0csspHd8QiTw4bDkoRdsYRZmAAQywBlfkColyJgsSDRJszRN8zRNs5g4k5iKiTUPyJdgMwNg05c4czZtMzaH6TVtkzV9STeJaQNc8zUNaJgsYAN6k5hoczUbYAAM4DZn8zVlswGGCTal05fEoA92ARqsEVXIIUJKRRtGQm2ObzpIBf8AJh7CASn6ISnCsFp0gRQC6gym4B7x0g75UgTkMD/18wumoD8Dkg7jzu52BVbUJoYIcxHr7iG5jCLbRSKPK6RgRCTogR7y4R6gQRYOQWIegPQsiIBQ80NLMzj/QdSYoFM0ZTMDSFM3n7M2cVM2e7OCktNFp/M2kfOXJOZEiSmBXDM3a5SYbjQDBgAAAGAAfFNFqfMApLMBDsCXkOkABiAAJmEZnKEaKBRVmkNVpqE6zGFvlI9USAVCzDIe2AEf1sEf+kEf+iEfimE1OiEWPqESBoEOwOAeEeAuEQAC8HM/9TQ/+1ME6FAEbCcAz02LJqTcSOUbFnPtyOEhuUMSH5MSd+tEUiLW7qFGKKJ6xIAiFKVJvsJ6PNVTaQBUJw0IehEqU3CCPBQEKmhERRNGVdWYVvUBkAlGnTQ5TZRJnXRJUVM2m/RJA2AAgHUAfmkADmBrQOAAAiAADmAG/2oAVWESBJI166QKCJxALLIgSmbARVH0R1n0SUuBGaLh905lhiJkXPKvS7MQQrCDHcDhC9WhHvrhHexhEkAACCTGCJqgDLogCCLgC+o0HxFgL+Vw/PaUP6fgPv1PXkrIdORuQsylbUTE3GiHUcdhACVyIosrdFhEJ1IiHfzhnaDhFToBFDKBFVjBFUwWbE7WZFk2FVKBZWGWFVy2ZV02FUjhZnE2Z3X2x36McXw2tXw2aBkHaIXWIDihtRiHEhZhESThEpL2EijBIKQWaiWhERqhENSgDRZhaqHWPt5DIYysIRzCEPajWZjFtBzBEAxBEjTBE35WtRCCEtz2bX8sWf/mQ7XcFhPa1iAWAQiycxvYwYa0idYgJFdeBULEEgtn6DzxQR3kARzqIfCSwV6d0WlgoAhkYAKm4A7yEQI6V2AHtvwKlh+TbjAJsVA1RMQitiG1SBwiMRIvdiXYCAGPy2M7EhheARZKYRZowTdioXd/N9uwjXevzTeEt3h9N3mVd3mZt3mbF3idN3iRF2xcIXpdYRViIWxioRWw1zeoN3upN3ypd2apF2ZRNmWv12VN4WRTQWVrdmZh1sfk1xRMoX1PYRUmYRM8JRtWLB+sATxgBRzYoR1m6PiUT//CDdkIJiScgRtKgVQ/4AQ04ARkwB4RYB/vFAI0WIPzMgT0Mk//yU8/+RLuTNf/KOTLmK92/G9XFPR1XZgmwgEk0OFB2eEffiUfoKEWXuEVZsF4aqEWetiHf3iIibiIiziIhRiIfxiJmbiHgdiJaeGJeziKm9h4gpiIjefamJgWejgWuriLYwEWYEEWZGEWylgWYMGMy1h5YcE3ZmF5tRd8wWZ7V2EVqrcV2niMYeEVtlcVYEEVALkVVGEVWkGQWyEVUMFlV0FmU8GO/bgUXsESbAEatKEc1tMf/KYsZ0hU2s5LOaw5sEMn/GWUweEeniEPQIAFUoADpsaC7/RO+dGDObhzNTgP8ZNg5ZAftQM7ClG4EPXctiFDFGtQzY1i1eWFXTgc/1ZEHbhBHcAFHWx4neABM/kNF/aNn26Bn7R5m7m5m61532yhFsB5nMkZnI1YnJdYic95iMPZnPctibF4ic1Yium5jImYjMm4icsYidH4jPeZjNu4h/t5nvNZFnYYnxHanreYi39YFnRhF3YBEo5hG9oBKTDZJvIvG9gBHgh0OkTMJkAZYM6pHoSCHaYhnh7AACSgAzygBEaADl8ZT21ZBEKgpmUZYDf4g/P0C/ZxnMapl9FhV2oHG9pBHsLBc7aoEB+yYrlsJkDEqVUnRHLiHLghRACmH9ZpPdHBGqChiYKhF34hrIEBGIShrM06GMz6rNFarYOhrd36reG6rcd6rP/BGhiCYa7xmq7zuhf4Ghh6wa/t2qz9mq//2q7JmqwLO66F4a7jGq7H+q3xWq7R2q3z+q2LQRiK4RjK+hiKobONwRiS4bNFmxhImxiGYRh4gRfC+heq5RqEYxregR0u+fjMUqP3Yf+8UTpSpTvDDRP9gR3SIRomAQgMoC4roARSYApIIAI4eC/zMA9t2qY3GGAzWINreh9LeBy0KN2YDEH2gRyMAiTGyaEeUozOwRxWApmLw4ssKqQ0Eh4wch8Eht7y4TIzcxb4LRmQoRmUoRmaoVOagRmY4b87JRqsISa0wRqiwVM8xVYM/H9tRRr+VxoknMKjgcIxnCkyXMMxvMP/oaHDLadarIEbIPzB/5cbUPx/Vfx/W7vFXfzFWxvFSfzEZfzE5yHFVxw8uKxd5IEeYmIbWJzCW1s4hIMYIFmHg4GJtAkbbwscvGVCvEGh1Eb/DpLKwSFU+EFw5CEdekFVU4AEZGAKuOAL0uALOFgvr3sf0zy6a3qWcXqDlZq8tQg7xmMaEoQoaquhGNWhXthDXrdD5mVFdEIjPcJfxmwTGxq/jwEZlKG/G9y/C9xv0mGz2sFCZJyqwdJCevyjPurSLzZDaETGRV3GO33UUZzTP8pCVF2jVF3TVR3VYT3URx3V5S3T6eF1JpXTO8oAx+iiQmWU36FDqJopXPsaGPwZ/3qhFPD4FZDhHAzHb670tmJlQkKCQQiXyhX3yklEcARXFkCgAfZQIMecP3Oazc393KebuhEgzh3qGxxqoBiqhZyBYF4ky9p9V54aqvs8XualtwBGpBBKYISiDPlIjGUhGJCB0SEdGiDdVqohHWINh9pBHd5lJjJqRVBkuTYqvWmiy0y9Q2bC1EVexg0Quc4705MLuVQe5SneQypS0zMkAUuE031cHlx95aPsjZBiH9ABvbdBGi7ctT2lGZLhn2JBFWQhGubBHrhBOQrXyinEG3qCyqk+Oja5HpjuY+/hGiDhARxABoJACPozlzf43M3e7N183U331x4S3MahI8ohQf/+BR2yw90JMRLJM99ft+42gqEwMif8BR36Zet3AY13eBc6O+H7m7+bAUGiYRrSAR/8gR+0dBuWA3CiLEXQQdULsOOLC8W3QcY7pENEfSb+N/SrWtR5vbhoYvRHvwBXvrhc3/Pj7Rxeh15SxHHvgR5kAiZsnkGL66LeCB7Wk+e/SMGhwbWjwb+ZQRhEVhU6oRfkQRu4wR6gnVxnaELeYR8MiuqrfIaMw6LnIRiA4AEsQOz7M/2+gLnRPLoj4OxrOgLk39zlHwJMlyH/r4RKSBlIpGHLxXYA4pu2bdu0aaOGkKBBggS/fQsXbpw3bxLRSYS37125fvvsFXsl69WrWsH/hBU7powZM2XNnDmbVi2dP3/72rUzt62aNnPlyqFD9y5oUJvtyBkN940hw2oMFyplaM3aU25Ut51Td67gQK0DcW6T+lTpuaPhzJk9a47cTXLmgqK7qU6ePJzn5LVDZ5QcRLLhwIFzx+9fRnLarEWDJg0atGYpcZXaBBLZuW/37OnUVi2b32ycp4Grx46z6NHZpmWbSPHdvn79/NnbBeKAAR1TpnDh8mUKAggQQogQESK48OHCIxgnLvy3CIfMHyJt/g0btujY0LncB3H6c6QGux+k5t27Q4gSKZrvhm5fPHQc70GrBeuVKlm9itlHpix//pfZ2rEupxk10wxIzjg9//2EYDlmkQOOZg6Fh5lOAk6DUDUWRhXVhdZoWM003U0InoDgGUSNhQghNKB4EJW1IFtpMQiOOQiig1NX6tyol3N7PfeNX+zs888/8JTTXTSJKZZMMbB0Msoru0TzDTz33HNZZpuV1l894JhmGmmijWMgOhj1849rtcxwQAE6CFEbF1OIsBsEyvkGHHLFEffbcL9B51xz0kk3TXTkYKPMNEVJB913IwoIoUHNedMNahMZiNE7HNFjTS/yqQKLLcF8igx++CnjUjaW9lPagDBVQ86BM/Z0Vl5cbShVhhbeims1hkXDa67V8BqNNsBGM2Cuq/p64oDUSOcXgwPBqFmrPv/RqI2HZq2IVDh6iTOOONF9I5o7Qe6DTpGHNdNMMr2U0skmluyyzU/y3ENNQdRo1iBn5NTTTr5ecubXOEDtQzBr+UDzxwMPHKBEEbVNEUQEvClHsZ3E8dYbnnvyGY521E033TfToIMNMm9lyxw2JC5K4Yku//kNpJGO042B46hm6T71qFNMKaWoAlIvwARTzKj7OWNqP++4xDRMp1EEJpjljGOUv6pOE40zxPKqqkvR/Mp01kyHLfbYYa969UvFdjiNNROqis1oI14JTsxUg4PQd9LhRc5PBXbLHJbpBLZPaDDxCk1KydjisyWdJKMNNu/ck89W917ZHz7mYO5lORT/pcfaav/cEwwQDxhgwBVK5MZFEBiL8AVwc1psZ53ENbci7hBF10030lE0jTIZTUTyOEl9R+HK4CmkzXbN9S4wOuXAw5FF3zQjy8/z4UI0Ss2Eup83rE0zNjXpaONX+ukbReKAZqOLrn4sudQSY/LfzxL8+sPvNa9mj02stanqbS5pGYoA9hDS1I05UIsa4LChqmzMxB8NCgf57HGNwywje52wRC1aEim2aONf4GhHPeqxuVQpEBwTAUc5VKMeMtnjGXA4gQYWsAUw4CZ2u6FTxWyXJztBQGIIKGKcIKC73I3nORPxHUWw4Qxs9AMbUfMGkRS1qLyJZ4kMnEhPXria/558Ixq96EQpRGILk3hvVC85ldnMp428yBFGE/qfM/CHv/jZjyV4zN/+WvK/splNgAF0X9OudjmI+Msvj0JNt6yXjQJO4x4zYYdfLngNxXzkMZYABrGo2A51rI9BADNhv0gIDqNgwxsuxEjBXAMLMbjAAg3owhVwM4UI9JBieeJlEJEjMQgUEWMhWCK2dgedKtoMikGJFNQaBSGFPEcc1PyGOKZmoJ6oph9iCoc2mPGKM3IKGMJAiTPw4xJsrAYdpCpgV1I5R3IQRED/i18f5ceYPe5RP3+03x+Z1k47DtKQY1OWNpbojd81UFIU8UlRtkGNpskjH/7QHN6igUHF7P8inJZ4BTQi15+77AUvzymhTUSTr99RzRyfGxNr/pEPexziBylgAAVsiRs47WZ2yfGl7YYTTGL2RkfMOSa2fILNnoyDfP0oRzd84o3wKMU7DNkWNalpM6n5JGf7IEc1pGELkahCFbsgGqnYKL59BC8/zajGWPolx/SZpSDuI58d/SjQvOYVkFoDlta8hjW0XU1VFhqsh7YyHjBNKptTO9A74IERm9CVadugKD/akY1tTIMb0ojGBlXRwV5Ywxkm7Zu23kLSvpijKADzBmdWSRG2vNCVrCHTPa7Rhx5cgAEMuM0XvqDL3vw2dj/1IU+BekTlRGChjvyic7PpSIlMYxz//fCGRsrBPILMtVGpNeZ4jGIW1uCDHdXgBjLCKZ9ZEA0Z32OMMyxlHX5aQx1tSSVRYnUWhnAju0u51TbMco6DwARDG9LQQurltg51iCDcOEeDCSKVBnPjRvTNr3a3kY4Mz1W7aYHItGY0o3fUAx/8mCC/cFKNptGjxP3akmGkIQyfbaIT0DiHZ+Shjr5l8ycHymZ5wITVLxoFjAQrsmuIkQcbOEACCbDNF1y30+H+UE+/RC5vIiCCKchADg5kKGOj9sUfS6QczthImLyi3RvxlyA5wp3ujLKadsiFG9awRSdEAotfFE0/L9mHP7QhP2jMV0ZsIYqhQ3kWbphDHeig/7Cj14Fjdaxj0uvAylXUMWEJ34jSkq50VsxRl0pTWNTtWEejS01pTks6wxm+EVqOstV4CMUt0/PzBE2sjpyIbRrqKLGWtrQNxeDCjJuQxVzYkQ55rOMuznVVgpTqDRAj6LFFfqU9OiEGHWggAQkowm9FwBs6EdeXtAuBcSIQgiuLgAQyMEMuHNhleGP1y4otB/n2ASZ0KMUsaubwXKe5HaPCuR/4mNI85iEMPL8CF8IYVUu+4Y923JGt0ZjvO34y66BAFh42QXM7FGSWjrMD2SMf+aFtoo5QqvzkhmYHUUpucqDc5ScnhzlaXm2UMGH84kDhOUYmyI8S+4MfOE6x1/+0QWJ8aEkb3PBsONnVC3rAwx3smIc8eI5Ni0g7zNL+iSuLbDCZ7kDbBEgAbiKWMZ+qvcrnDrecgpAEWjxDsVLr1nOnZhFXKZVk6BjQFPHy33OkJS3bCMc22MKWcHjDmgLLS4LC8cXVtCYfB5dGOONTi4aj6yXrqFx+QtWMqKijHtTeBzwwXqmbLPpGHzeLy9vBDnPA3CYmNyXLWX5CfpXcJieEPYjfYejVxj7kI795XsbBE2cHRdbUBvqtKT9aFQfdHxm2BjSI0QnQduIY6yhcOu5x9RdK79lhUlA5mP1Fmrej2gXrR0whwYQTMKDsvyVBD4NTMY3l39xtD7cIXsD/Cs/wDD1xVdQ0ftJzTXinei1SaOCANBpxWjkXDuIwgRFBDuIQXZGCVB+GVOJADq7ED/NgD/YQDLaAC7iwC8IADdEwD/mQD1MiD9HQdNYwglNCUbf2D2TSGv7gglNigzzogkEohENIhEXogreGhEmohET4fEZ4hDfoD7VVW0FChWUyQT1YGfZgdVpIOVdoDdLwC7NwC7PQC/ZAUS9oD/fAEdUmhc/Hg1FYW7f2Ujn4UvfQC23wBkJgAiuwAhBTROWmMfhXHG1nRBPwCM8gDdfQLYt4TQeYfs8GiRohHS8kR9PyXF+mVDZjRc6FIH0TD/FQDyJoD8pQC7ZQirtwDM2w/w340IMpRj7b4INH6A9lEiRkkoMzEYQ26IS7yItK6ItJWIRIyItCOBOt0Rq0OIvCiIUjSGcH14W4KA/LUAtiCAvLYIb+EIscIYWscYVCSDlE+I2yWCYxJQti0AUysAImYAJTMAH3B4jm5hvAhGW/IUwIEAjDgIjXwBMFIi2O6FA8t3UY51TdoBEvslprgRY8Jj0+JhGM1XPvsGjvEA/4MIIYZAuygJGe0gySMxPbMHHOcA6UFIVUqIPaWFv7IHT5sGIzMX1DJ3RB15IwSWL8gA+/uI03iZM7qIRx+Iu+eIZveIZMiIUxyBQTBYf+cA7BMBK2AAvSIA/dSBM8iYtY6P+DFWmVV1mRWQgNr9AHV0ACJBAEENOO7ziIgUgxETABK4AJtDCGsnAXPJF8H0YjqPUqnDgtvfMTaREjxecXB8kO2lQOqTR4J1cP8FAPcrEa2DiC0lAMsgALGLkLyqAN7ZAP8jBxpBJq8nBCLhl0BANZShdKk5Zr3DBnpDkPVDFhlnYjVicXcsGarQmbjvZokKZsmwabOKZpqUlpt0kVsImav8kNB4eatykPI8iaqGl9K2gNE0U59xANGxUSu3AN1yCKB0cPOHaa0ykNNJiI1yANicEMy7AMyXAMxEAMxrAMxkAMJfEp3zmdwaAKjJAEKzABMkAC7Zgx73hueIJ/yjH/ARMQCI/gCI5wCZPwbM4mPZY4IzdyDleBY+ewDpPRKjy2VT9hIATjdfUgT5dGm7BJDx/6oQSDjfRgD9LwDLhQCye4C8kQFRmkEipxDC/KDO6lGHakP/oxo82wEiqBoyshP+AzKkajDKFCpEVqpKFyDMdwpElqH016EkkKpVDqpE1qEvYhDJ/yKb2gpcAADFrqpV/aC7ugpbsgpmIaDL3wKRtVCqmgCbowDMagnp/yC2F6grdwC76QC445Cq0AC6OQCq3ACZYgqJMwCZawCYfqLohqC79gDLwAC5awBzmwAiNQAQkwlsIxRGRZO78RARIQCIlACI+ACYygCM2WIAlq/4l3YROpFhdYgSOn1Q7ABw/4gJLAhw/4YEL+UJjyQA/3cJ3yMA8G54NTwg8EI3T3sAzhBDSyUIomaAum+Ky1wKy1QK3PaorU2qzRWorUipHd6pivEB8iIa7j+nSq8DM+g67pyi6dwK7t6q7vCq/tEq8dJKiDSqj3eq/1OgmQwK/96q+HALABK7ADO7B50AZ90AdrUAiN0AiRsAiHwK+LgAiL8LATqwiFYAiF4AcZawiKYAh+UAghewgTS7EM27CRoAm3MAyscAmO0AUq0IcjkAAkgG6YmqlUZjE1GxzGQQJpAAiP8Ah7MAeCkAhncWid+Bb0xXOPxXFvQRTTQjXosP9s8oAP9FC1VTus90CrLQl+vfqCucgPHBEPQPIP8/AKapAHAAsJkQAJhToJkXCvkQC3+GoJbluo9Yq3eauvceuvfeu3fwsJiwC4EUuxEeuvFIu4iEu4icu4iGuybBu4BCu5AfsHlUu5lVu5eZAHatAGbQAHa9AGhpAIg+AHf4CxhjAIhtCxHjsIrTsIe2AIjDC6g0AIhEC6fpC6qosIIasIi9AIpkALksAIePACIzACU4ABDECz+Uk7xYWpyREBQZAGiUC0rwsIn9pppaa9qlZpbTFtFzctGKFNTmsTJMYv7VBiNgh+BCMYiUmT/PCT+UCTq1Ew8KANh8C5efAHACv/uG87t2srt4QKt3UrwHOLrwd8wHKrwJA7uA0cuIL7wBAcwY0rsRU8sSQrsYigCIjAwRusCB7cu46LuIgwuQIbsidcuYXwB31QuQhrsJ0Lw3PAB0K7B66bCNRru627B3qgB4mwB4TgCISgB4RwwzVMu6SbuhvbsY1QCZigCFLQASVAqRIgASTwbUKEHBjTG8TkGxFgxY8AqqpLxIQACBNkjFHoizmpxlP4D4FBhbcWtpI3h0GSjLToDhe3D/iQg8qAuSx8CIWACAOcCZlwCYVsyJcwyIlcyInMyIwsqI2cyHprCYUsyZVMqPZ6t3iLwJe8yYM6yYVMCaF8yIesCYqs/7eNbAmEvMiX8MmLPMiCygmZUMqXUAmvW8MdWwmOcMOM4AiKwMu8HLuJ4AiiawhzwAbCnMuMoMyiWgnNnMuVMAcOcAESYLwrEASiCghf0FPlpsW8YUQIMAFf8LNEK7vUS7RwmJO3JsdxeMbtbJJV+MZyKJVACI70VQ/FGA3yQQqsgAqgYAqewAqrwAqu4AqsENCpgNAJnQqrQAoN7dANndCkcAqkMAqh8NAOHQqgEAoZDQqcAAof3dGcINIePdIlHdIljdIofdIpjdKbwNKc8Akx/QmgMNOksNEbvdIj/dEz/QkiTdMgvdM3vdGksAoMTQqUQLuMUMPPDMbK7AeMkP+6jsAIjzAIiWAIQewDP8AGynzDROwIj1AJAirViTAGF1ABDFABYEkCd/AI2txTVSZU3VxEaOmzdPAIjKAHVU0IfMDXJ7kaMNR+2zh0KCm/hQ2/h12sYQuTi+2NV8kNVjmdmaQY7EWa8pAO+KAOvSALsRALsJAKrpAKnB0LriDarWDap23asdAKrrDarRDQq2DaRY0Ks40KRV3UCo3RQl3Ro8Dbvd3bobDbvs3bwE3cvx3cw53RNw0KvP3SPk3SIg3cHd3TzS3SMe3Tyd3QQm3REN0KqWDRjeAHREsIhoAJjlDeUs3LwiyqN3zDgiAIe00IvEwI7/3eiTDVYOzebPD/AWZNzfcpAAjAS+YmJwH+vBijS0X0BY/AB4KgzPO94IKw4CHZmvRQaQQRadoQYFRRcRnUdIgDLMpJZ8PSDIsxpMhQDFg6p7/wC7twgsx6kSEhEp2AC9YAg0PHDI8JC6pN0JyN2j3u47Ad2wgt27NdCqdQCqgQ0Q+d3JyQ3CEt3KfQ25wg3Mw9ClI+0lH+0hkN3Sft0l2OqC4t0psQ0g3tCT1t5prACZqA5jDd0x8dCh4NCqQA0tsN0RDNCYUwCBAexopgCrrc1KBau2BMCHhww0CbCJjQ1e8930RMvXSAB1tgAWad1kEwAQLw37AzZW8dROd24EFwB4KgB7hb1YmA/wcLztfLcAxYWh9nah9lugsmWIq4EK3i6jPyARK3gK2OOQuvcAvmakaZMAmZcKiBmgmWEAmbUOyFnAqkQMC9wA29arXrUGeOGR9jpdo+7uOz3eO03QqocAre7u2n8O3iDuWiMAofXd3ZPd3Cbe7CjQqiAOVTPuVvHtPSzdM9Ledt3tzWzeaf4An/7glqrgkAT/D/XtOkINMJf9GsQAoIzQmKgAmY8AjxPcwVzwie4ArwPdVFPKCGDqqMQAh70NW6zAd4UAduwAIOQAESgAEkIAIHvhs6KzEE3hsicAcvj5btOAV3gAd2oAd74AduIMN84OjG3C76CjSZAFp3S6ipMP8J3T4J7iK3lAAJjRC4kEDIsUALmzAJmuAKnHALmUAJhUyxoawJLCsJjaAIl0AJkjCgplAJhRAJj2PZ7MCS93AMsjAL1b4KsIDtqF3bqJDtqMDP4U7uh4/4NO3TDU3TnzAK5g755/74jw/v8I74pyAK5r7cyz3dKT3d/J7wMp3maN7TAj/wBf/vpk/w/Z7wbH7RqcDwpOAJ5i3xiXDXVy27oSqgo1rOIR/fd0295ly78w0IgFAHtg8IG0ABJYABJTABB16PR6TFxpVu8ahL7RgEgHAHfGAHc7DDZuAGd3AHb0AHdmAHDDv2lDD1i5D2klAJlyAJknAJi8D27I/+lZD/9mq/CJSwCJFgCb4LEIcacaJ1SZOmSo0aSVqESFIkhYoUNjJICVEjSrCgtdOn718/f/ns4aoFSxYsWLFUrmzVamWsVq5atlxFk9VNVzdZpbp5yqcooEFFjRLl0yipU6lOmUq6tKlSpThjxtzZ1JQoUKNCbf0E6lNXUEC3hgJlypQns2c9rWXr6SCnr5zkwoX71etXsFtJ7Q211+9eUzk9STKUKBEeQIAIDTJs2I4dQp4YMQL0iBCjR4LsPPJEKFCdQIk+u7kjp0uaO0IUSChBYgWJCAgQQJBdG8Jt3LdD7IYgIoSICBPk3AE0HM8ePW7smMFzB00cPnb4KHJUqbqn/0rZrTt6hGm7o0bVK0kS76i6I0WSJCFqqFDSJUqNNF3SPr5QekWG2DdaJHF9pENw4SYbd9zx55+Q7CmmllpmQeklCCN0CaaZXMnJwpxS4YkVVDo0qqgPgzoFKaWYYgoqp6BiRSYMd9JQQ1KyGmVGGmu08RO2zGLroLY8+WQsUObiBBRQyLrLyCJH+WvJVHJi5ZI89OgOkEC8mGMOQhLZw4464tgjDka+BMQORjDho45H+AjkjTfSQKMONu9Ig4siRpCgAgZGeI2E2vqcLTdAAY0gAioDaQ4PQQjZI1E3GkUDDUEAceORR7LzBBNM1zLFO0wxre4sVtbCxBVRK/GElv+cNFnRlU0F09EUVhCqBFNLaUFIE1I16YQZe+y5J597/PHnHnt6seWWCGPB0BVlZ3J2plU0jHYVVqLtUKkZiwoqlFFO0WqrUT4JiihtvR3qXE5QaaUml0zh7yBNREGFk1Pk8mrIUIYscqx8e/S3rb3i0oSTgT+pCywayRLFLLuWxNARPciogw888HgsDkIUM4yPOdzgw40y5qDDjkTooOMRPAK5o47SKubjjjJKe8EDE1wjIYjYaMPtz0B3RkCAAAAg4Is0TX4DS0IEEeQwQaKrgxEtHykTE1EzdYXTSip1BBNWaKHlUkzE84QVSag25RZavNvaQrR05JpqTCj1Lif/THjk5BVriJ3nV2HtWWaWWNAG/CULW2r2WVieXSXaVBZnvCZUfEIFKBm9JUUvG8kFUShUKFwJVTXaQOsTb1s5xeB7ieSXXxz/bUsTH/0yWEi58Lq8W63CCnjJvdg2hA2QvUhkaTxAE21p5QTZQ4otKgaejjTKaI64OsIghA020uhCjjReKGGFEW7GmeeeAe1TAADSR+AOMN4ooww2HjPDjT3msGMP5RhxZI9Ks2YlblLRClP6Mw/VQtWdSkzNOtoZGyuyBjeqzWpWtKJU/0T1iLJdIhTAuEc/+FGPeuCDH/K4xi5e0TVaDG4lGHJJ4VqSuGe1pHGOY1wqWnKTyAnF/yx/sZFQtDWjU6hrQrGgRS58gQhKoKoVrGhFUVQXJCIlbCwxChheviK7uhQpSLSby77AxS8ifYJ3pLCQJgYRvzK4IWUvC4QgpLaHRFgGD4Z5Ax6A5wY6lIwOcngDGu4wPylIoX1yUMLMMICBEUwhCLPhTflocz70pS8AJACDF9hQhi2875Js2AL24keIx+AhbgnsjiMulZ1HmGdrFUygp2bFGU6FzTvWSaUp2cKd8jAia44om9q2RolWPCMf8djHO97hjXaoIxmv2AsrVJKSCDFLJTJpxYMUZ8N1LS4VHeKmh4wyoh3uZSjZ+knmioIKWMxiFl6LBSgQkQdTeE0mHf8C1xPHMiNujZF3XenKVrbYRSJ5kRScWF1Ax3gTiJHBDWagwxnckKhU4tEOjkgEH6CWiDcIAg90ABkf6KCmO7wBEHg4AyfBcAY5XEEG3zPBCoIwAQREoJGDisDOHokAAghApwAIwCS5gIZA8GGTl7SkFzApPEFgzw3ZmczWuJOduCUCM6YMGynBVqarcSYwnqgl1LojtzhelKKUus4jhuedRZRCGupAxzvKwY5scOMatZhEeCThCgclC0IvTIkLafgiDQUxiJH7JlBIkRZTHPYqC0uLDs1yCsOtkxaooMQlFtGHSNzCFYP1C5DI0pcYgaKznl2dP/0J0NLyhUZ/MSj/YllhikGsgQzA60IYKIYHN7DhDWlCgxzWtFE+yCGTeJBDGN6QJTexyQxbCINv7xAGMKzUBFPgU0xzM6ib1ianOtVpT0mQiDtAZnhvSMIWMrmFJLBBqNjzgnnJWsBE7BKXs4rjpVIZR6l1J25Uy6oqx8qIyyTqMknDhKKyFMc4sCwQgzhELaRxjna0IxvbqMY1lgGJPwxCEIPwRCygKSGWVDMmzKLmVP7KTQ59KCyMRaxZgNLYxS7MKadQhUqKmAtaxMoghdtmZ/ciWr0kVrR/4dfl9MKXsQA0oPtSLT75cpeypMWBepgDx+hghjvcAQ8dc0Md44AGNyTNZXKQwxnO/4CHN4AhEIBIQxXksNAymOENYbhCF4ogAyGQYAowxa75/LRd7gJtAqERMKUY8QYl5KALmNSt+7bghY2mUn9Ls0wtzZolpWUplYJoYyIIQQj9hg0PhOCDIMzAhjhuzGR8JA4h6vDmLPGBzml4gx4OEQxuWIMb6ahGNaQhjVrkocp80MNdP6xXCrVkWSWGFodQUS1thojFptCQD63tQ1Swaxa+8EUu0NY1VrWix3wh91eoTQox8u7IU/xxjAxmRbwQ6cf+9KJBD3tYT8R2UW4YjkbNYIYr8aGOciBpIOiAhkR0gQ8CR8MeuXeHLZghDAzdghzQoIQr6EAGKSABCfgcqP8/BzrQBKhMohxx0UO7wAZe8MINckCE2p6hC14IAyMW/ulSz2EPfCCExRYOx8cQ4qOIAuVmMGGHOQjCEYKAmhnqEEdGqfEMVUgD91BDB1ITQglFaF8fJgENeVijwtf49TMmAYc6AOIObjCEM5G9V2UtO5uO0wm0rZViUCQlFWbZ5rX9Li+9t8KIw+C2t2/SElT4+HJbFK1XEjvaIxsZtPcOrVd+bG9+qu7ySzrLHMbQMTOcwWTwQ9r73sDRLlCKo29IxBkyeYY3vOwNZ4hzF9DQhYV24Q0vSIEHLuDxCfT5T7IhAE4FAOhAT0GqjNAwogJBiDcMoQpJmD56X54E4mL//9OEoGgczUSxOqKsjXhY+B0+SuotvGGhHovbmqf0GZZlmbioyTLBPU2IIRQhDG4oRC/sAax7IBZ7uAZgWIRHCARCG4RK8JoUIiJagBCUiMCZSLYYaoXIqaFtGoW86yFvyZwZkYsakZcZKQV1oYVbQJtYWAWtmJF/KpK44CIYpIvZERJ4E5K3IBi4GJi6kItNaJxU2IsfdIX9UarTI4Sj0zlSOz08ALM3MBSLc73lSoMw6AIlkIMyAC/RIwTYy7JEUIITSIEpkIAJCD6dyS4COEORkw0BIBpSaww3iAPmSIIk4CjyO65EMAM+cIQ4mENP47lEwASbWzg2kIOPQTM0/+A5NOO0lykZNGA9PlCMPlozQACvOEgDWiOz6cmyoHqME4iBKiCDQ1gGewiJfBAJsiuFQ9gDLjQMRXCFB3xFwFGhCEQJC6HAZ+EmyKKhVUCFbvkmwtocoCgnciGKpEAFVUC8Ylw8IgHBgroLeHu3ZwSLeAsSgYEXa7zBuYg3TgDCH9OQM9ICLYC93lq6+gE4OQspNlE/ORAE8iovMFACHVACNiE1MEsUNZEDMECBC+CCR7iTjhMB4NAu5NMp7SIB3yo1T8MDL6iCLSCC8toCQXAFiLM9M7CCf+sB8vu0pjmMN7C4N4mDMAANNjEU4riDpTmeOxC45rqDOKiYOQKEN//QPcQIKUskM82onxawgSNYg0iQhlEUFn6oBmsohkPoA0HQsp5TngUkolhQp6aUBag8iQhcCQl8hZk4xlZQBazUSlVAhVLwQNzxQMLyiV6cEXXRShLsJl7MHBDsxVMQilMgkr8LxqUgMiNhtx8kBRERrBEhhbwUrUsgA5abH/cpAzI4tSvBgzDYo1VzFD4oAzkMgzLoAuorTIp5FPKLlCpwAQ3ggN5rqSCYgi8QAdrIqTM8zeMrPgKYgClIg39rr4zTgRyIASLQgSSIgziIyZd7OR0gAhjIATrYKJckBDxyKDYBg1fzqI+SAyrBqOAMBKjpsjpIuwS7AzMjs0tkzuL/OKk4CIQ4sAM2aAEpIIM1aIVr8JVfUYdokAZYyIM2mIOU+SjNIARX/Bx1ikqonEUJhIVX6M9X4MqsxMqs7KZSKAVfJCwE9aZvGixjDNBSUAUStJFOGMGvHMFTMFAPXFBv6UC+VJLSUpIRKcZv4RbBUhK//ItGGIPDNCo8CgQ7EAQ3SDo+qIIlpAM2KYOp8wIzMCqH2lEqdChOMxniEqnNPAEPcAAUiAE8mwLq+jNAM03W5AIzW8ghyAEZiIEcyAHZZMgwIAIvQIEW2FIwiIEWgB7zuwNCsEQwCIM7iDkwqLozMAztNL9IswzwUtMsKw3tCQPjmj03OAP24QLqnAMy/2CBIyADOPAFaTjPAVxPYliEPNgDxky6ipqDpbQxr7lPqUSJTeVP//RPruTKAu0EUi3QCrWRAh0FUwXLr3xQtOwEU01VGiFVWFXVUZjQU6XVCc2cU0XVD+wETsBVGulVCuVFUoiWgXILP8itySyD08s5O3ADL3iDkDqNMNCeNJhWOXkUNKiCmetI5/KCj4pJNCCCDrgAB2CADdiAE1CBIlAkjyO+4pNXAkiA0LwCMLiCIdCBfVWC39SBK0ABHdABMOiCK4gBF8gBD0hSF4CBjtQyiilYZ50z2GsfkAyERqSS0uAo4oy1RMDH0tDEjCE/OqC5RimDqiMOQNiCHrCBMf8YhGF4hmsgu7KrhT5YA49JyTPSA4sZBFd8xUydhfyMwE391E9FS1eF0Fhd2hpZ2lZt1WEdBWNUWliN1RnR1aothVI1Vazt2qrt2lH1WlrV2rFdWhh5LVOohDWYAzYwgzJ4FN26n6TqMjZJg4JNszQAVEuMg9qqAjDwVtxbmjtQGeirAiM9UgpoARQ4ARTgOJdi0peSjQlIgO0qgTsrgq2TARXQ3CuAAR3wANBd2Nk8AQegABQogitYWBQ4jceMvTaxWyUAAzDggjXtApOk1oYyrjTpuVGJmzI7g+aSgzjiAy9YtDLwAjSwRD3NsitIAiXoAjs4FQZRp1bIhD8QAzP/YE4Y1QM/wJ85gINK+JygFdqhjUCjPV+l5Vqx9Vr19VqkXV/4JVv4nV/63dqlzdpVaCZNwARFOMzjvQLmKgOOAp4xkLjkZZ/TeFODvQLgBWDkrQId2AKDNQM/wqM5ywEU4AAGcAAOOIEvTIERCB/xCQISGIELSACgCYAsJYIiKAKOM4ESoIATsAAH+EId4IAL0GAHeAEOeAEuSAEG4IAEeNNAILNFs1Z8tNs3bUKT8aM4OINDLD+sO0Ay4x58BYMyuALjMhnoSoMrsETadZ+ElUcyGIQ/OIQ8+IM8WIM18ILZ9a36gQMySLA2aDsLYUB1YhD8ZBA9xk8/PonyNd9X/9DPWfzjP24Q8t1jP+ZjRq4FW3jkR8YFSZ7kSYZkSr7kXchkTd6FXuhkT+5kYAjlX/BkXviFBwwVRYitMbCCLqBCh0wCHTUDODQDb1XgLpDdkLpiJVAC6mtlHYABF5DHmQMzb00CF6CAC6AAF3iBZe69EnjmEaiAC5AAB6DhAhCABsABK4DgIaiAErCTBFiNBeAACugAJdCABEhXB0DXBCiAAhgABuCC0igu2VXiO+CCqqs67iEzib3WKeaDR7ga94EeMMiyNvliq2MTKqS1gsVWG40eO3ID7h2Ex3iZkK2DaN0SQGDbQWAERdCEXMgFRwaGYRAGYlgGlP41ZkAGZP84BmZoBmiIBpn+NWiQhmiABpzOaZ3eaZ7e6Wf4aaDm6Z+u6V8r6l+zBqRG6plV6pml2aYuarKLaqhWam6Qh73pFWu4BmuoaW7oFXvgBmnA6WfgBbTxBD3Qgh4gAoaEYNrcgkqqpCk8A9mVOQb24uetAj5NggUGA96TgRy4An3dui4IBDCIAyJg3BNoAQ8+AQ7ggHPVgAZYgAIwAAuwAB1I0hPQUsa+AA+gAApggAsoAAbwAAxgDQlQVwZYDc8+bQ+QAD6lXS6A7XouAku0W+45aMC+guHojucjhOaiNX9u1iuIbS6ArnfEuDNQgryN3TaJEz66Hy4JTvWbzjhgSRf/jQOP+bQ9YIQiGmljSIZnwOlosAd5aAZlUIZmkGltUIdz2IZz4IZt4Ab43gaklmn7vm/8vm+jpun1tG+jXs+kdm912AYCL3BueO8C3wZzkG/4ZnCknu+kDnACN4d1wAdh8Qd+SAf6Vu8AlIewg+liwAXNcoQn0IItaAEwqNIszYEquIIqGALpk74qkLldVgLghYEyEC6Lax8wuLMSSIEU2FwhEIIcGI4zmFYdWFcL+IAP2AAN8ODKbgADMIAFeIAT6ILk3tchcIEO0AALWAAHkIATlgAKUIAC2AAHWAAKkAB3VoAFWIAYQAEFyFd8vdY3AOxr/eK8nV3YHu5bpr/h/2DJKo5JybyCyWxlwF7TNNhllK1nmZvMa9Xn6LAD8yPo4UiwOBipLfPDPfADT8iFWaiFXSCGYhhqn7SGZmDp9F5veViHczgHdVAHBn/1bdAGbchvma5v/Ebq/ZYGW7/1++41a3j1V2dvctiGcED2cyCHZUd2Z09wc6h1bVBwc6h2azcHbSAHcjCHduCHf/j2fmgHc6AGZ3CGaShFD0f1Z+iFbzOEKJCCHGCBLajSGIgBGX/xF8/SIfACfL2CIsiBF9ABOcgMjpptIL+ADsCz/BuCgu3bHHDyxYaBGa7sarYADdgAC2iBGADYOy8CF0jzai7zBEiAEigABzj5AlCAzv82cwVo+TVXAMCO7XoGbDBWYtS9Vi7AOCzPMktsk5UhszTjU9275Xz9c+vUYtHrSEJH2UpnYi0zGuB9g7QbXCpBOgHTA0UQHFwQhmJAb12zh2hIdWSI6XNYB3loh2KXdWJv71/XBmtwe7h/+7b/9VzndWuodWqYhl7rNWqghmk3B20HfG0PB8IPB20//MIPh2oPfMG/9sMPfHQoB3f4iH74dnxgB20od2e4cHmohmZYBgahBVMYgyg4gg34gCqNccB98SHwxC7ggiGgwhxA3V2+AvfJgSTY8oxLgWkOciEoAhWQR2+dviRoAQ6w+ONnVyZ/chbISRbYAC4fAnwtAtD/vQAGePNkToDUducwpwA0l+wzTwMUkAAJgO3YLW67zVvU4KM1JTPjxvLTKEmlf93avla6rrOTeq70HzhLBFRqrT+ACETnzp03Z8Bw4QImjJw7eO7QefMGjx08evykojXLVq9iyKBZU6dOGbKSzpyta9fuXTt0Ls+Rg3lO3blz227ivMmtZk2cNXfutLZzmzZtOYluM6d0KTlzTcmRC/cUKlRz7Zw2VUoOHFWq4MKhUwmv3z9+/Pzdk1ftpDN8//qZm9as2KtZsST96JGDBYwqOaqgATMEMBgwaKogHgJDyZUrOZQUSQHGyw0iSXS4eJHCQ4oLJYSAFqIETJErXXJ4/0niYkgOFxc0OIDxOAljJZi7eCh9xbYLBxQuOJCgoECCAgUWbHCwYIECBwMUUIhBwQUFhFcYhklD8E5DPHLSgEkj5/ub7+LvACIop8sb8GfALwxzprHpLuyzix/fvv2dNGnK33FQdmEUBt4VpXWRRhxoeOEGG27IwcYcitBSSy27FKNMM9vkc44yHzpDDTYrofOOiS2101Q4Tjm1DTlHJfUUVuG0JJI5NsF4k1I6qmSVUj1ixdVSQw55VVdZQSWVSvuQdRZa9HDjTDPOMMkPOdVA00sptLjiBxl6JZHDFYOB0QVrV8SQAxdj5hDDEEowZloRnClBRA45FPHCCzKU0P9BCirIIARCYoKRwxlV1HGFDkXIF4MOMAzxRhctdCFIGjE4WgQMCGLWAWwMeDbccswtIIGpCixgHAUbQEdfef7dURgXYRh0hkQShYFfQ+GFUQRpShCIEGRXrFnamsSC8Qay5hXGEHfivRFssTIUUW1CCZVp3xX+bTHGGp7cUostwTQDjTz0TFOSMiGGA088774Lj7zvuFSiifXAU4+++65Eb73vyFuPSu2ko445Itko0joKD9zwwOxA3I47ErMzscM9cpXVUi4BzOQ/H6OVjzrOrIsPWeZEw0wtqsTiyRxkXEbECUVwUcQQQwjhJhgHXqtbDC9A9lgOMCi6aQojID3/QmcqqDAEFyi4EENjRTDWRXgHYsbYEEW8QUcSLSiBKQp3NhaDCyc44AAHL0hQ3HEUKABdDMcNVwAFKCDknxyz6vdrFwcmeEYYPGu3rRJrcqHDtXBCVq0Oe1rLc2NcjOaffexFm0YYcUImBLWgVVttY2AsqsSbPSyBSCyzXMgMNPbc40xJzUSjDj1M9pN7P/7w7o9ZvQPvTz7D59P778ELTzw9+dzDPD33NH/P8/nwcw8/xVufPT/0XF89PvTggw/vv99TT0ry1AM++Pzs037uH//jjzz3jPQhOPGrAw1dq9AiCRlWnAEGJ2gBzYoAGkxd60BOuwJpNqWDHOhAB2Vo/9MVUMABD3SgAyOQQAkkkIIUyCAGHXABY3RwMzgVIQ3VeoEOGqODhSjBPjeLQRGkBgbaoAAGHbgAqBIgHAoAcVWoOk6qjJPDOxDoO+FJ1s7SsBuJNOQOBqSZeMBjLYTULDQyWMEWVyCEKXBhCqEpwhSmgCzrpLAwRQiUAWUggxSsMQUlKMELQMdALgiBjFzYCxZcEQtZ4OIZ17CHPawRjWhI4xrWsMY5licPecwDkvLgBjcgSchLYvKS85jHJaGXSUzeA3awgx4poce8U0YPlapsHvGIl8pXFg95vBse9KxBMnM0Tx726IUsYsEKPfhACojRQRgUUkMaCiEh1kqIHP/ewB1FJU4zHjiBC3JQghSsQI4emOMQSoABGbxwdENYlJ5s84IryGFw4QEErQ6kBBjo7BGBKIMS2sRDBhTAAA5ITgM2sIEBGEcCC1AOEQuDkPZk51jFBAN3uGAgGRyIZjVTAehA88YVZBObGQ2UG0MDOtHlMXSl8dwbX3DNFZyUjXlkKB45mgMczIASt8DFL5JxjZtCAxrMWMYyilEM10Ujp0IdKlGLKo2iQuOo0lhqUpW61KdKA5FQXSoirXENblz1plrV6iK7atWrUhKrW70qwh75yE1yg5BaFaU9rgEMW9CCFW3QghSIUAUwbMFmN8PZZ7ZmUP+E55lrHMIVXgD/tRxIJg0yUIEEALVGFMjgDO+s4YE68EIlsPCFKXhBGLxDNco9EAYmPMN6xqkpHhogARZYgAEMsIEFDACgqVKABCjwnC9yQQbhEcIKUqiQvb0hEf4xoOd4S0YhpMBzHxxBBZrL3AokDWnXBKEbufhRapFmjXz64DVHoAITfCaPoZmCeKYgAxMEaggtoEEfNKEKWNjCFriwhbgsNAtZyEJc9LVQLfLL3//iN8D+DXB//SvfXfRiF7YQMIP9C2AB/1e/8Z0whSeMC1zsIsMXxjCCe+HhD4PYw8AAhjCSoQxmJMMYu7jFLSqxhii44VA6qMIQAMXREgAquVNL5t8gIwPN//z4BS5AQQr8U4ILYEAFa/RAHl3ggdxAkFo5OAEHitAmiLozgouSAbBisBg5POIR8zFdBxiQAAMsxwEGsEADDABQ4xhHAAVQwBTkGCjehuYFVCsCHjCxt2zKAAN25tMFOlABCTDAVBJobnMlcIGkzZGO1b1z6NS4WD4BmouTDukUqmXeL7pRBkMgQhTEkAdIWKIU7y0Fq1kdilGUohOs7gStN1HrTeAa15nY9SYyYYlfW2ISwBa2JTIBi1qwuBazUMWvJ+HsZjs72sSWNrWrbe1pOzsS2r42ty2xCWFDAhKHGLcf5qAFNpThDDrwcREApdxQu3FPY6qmbfj0YxmcAP+yQ/jTBVSQghgI4cklONsD9VzPqN0sDXDCA+nWnYNz3mE0b9JBC/DwCDz8LQke4OGZLbABCxigAbM1znLkPIASyGAEJhhBdUuAUYxSq9NC6MAbr1mCNXrzNxRQtHMZDV0SzJEEJMBoEILQUU+HUbtCoOjnSApolXrUiwkZQrfakIdDTCITnVDFrDnBCU3kuhO67vWugW32s3fbEqFoRSzaHotRWIISlJCE3Oted0ngne7a3jvf+65tSESiEXwXfOAbYXjBE/7wkGjEIg7P+EUsItzj/kMfKp+Hl3lhC0PLTTIvLQMP6MnG18yZkrmwtY2nwJoeQEEMcAwbKncABbH/cTQIayaDNGDGBS2EQXk2ty2F3+kEj7FNC/kgh9EUNgUOYIA+LWAB47TWAxSwW6kGsOgKJKC3HfRmZxJQgWzOUY4v3+4cy4xoH5rKuUkDunRJIAMSBMFzXiwjGGlmUfSCRoy8te6PrbvGmpXRmJgBIbCCJ5BCKridKnAdKTAgKXDCq3md120CJ+gar2VCr+Ua2fkasF2C2Qnbrk1CJMSd3ZHg3NHd3FEC38md3+2d47ng40Fe48XgDCJCDSLCIiDCuE3eH1BeHuRBG/zBHmjBFnTB17yQQvAMcb1RtaCcaYwTYmnGBy0WCmBADKSABGiAAXhADkBNDIDBdglBCSRE/wqsBqY8RhGggGNUS6/AiQ5oAAntDAz4RxJMjQ5wAAM432otB5sthwLEgAc4QAE4AHN53xaNgDddQCJeADalAAmMgCOWQAWYAAZI4ghggAIkAAEQQAJwoqNdQAU82nNhgMu9X9FtEW59QRbBmxd9zp1RSxuJ2hqJFBdUAQ7ogSv4USzQwi6+Aiyswi+WAimEAtfF2ihkoNhlIAYm4zLm2gVqoAbuWjRK4zQ+YzJO4zVO4yV0oDZmgjZ24Nl5oLNdAiVYQgemYCRoAiaQgRTkgOY5TeiIV54s1hwFSgqsCqC8AAfQEWahwNKhwA5xgG8Mgdk42Qq9wCIKSiIkCO7FQP/Y3FASDMENwcmQQQacPEYZjAltYBYFeNxqeRzaFNEGTN9rbZAJMNoGPVoimsAKjAAXMRcJgCKSodwIKIAmbuIm+tAnXsCiJWIFlMBKwtwW4R8eVYv88dadgcYKiFFCkJQWyYAyyUAVNIERYIIrsAIt6GIsqMIrtJqsjQKtdYIzTiM4kiXaERuwld1ZBtuzleVanqVagmO0NVtbruWwkaU3XkIFaoIrMIIWWIGdaN6BTE1uuREIfRDObQAKbNOPIVcIYcBvoMAcpQkMOJliukAHeE4JYBC1yEFhJEIRLEoOvMk4OUo5OVzYwEkSCAaxVAsHDNQC5CFBDdRw+MYGzNH/Nl3TN6mcJSKNT95mCmAABrBcS5ok+mWiDx1aAjAABiAZ6s0ReDHNSspAGRWXGzHNCuBRGW2RvRUXdTJNcS1dDqAOhejiLeRCLgQYLKgnLLQCe7YCKqxCKqQCKfxiKqDCfeInKpzCKPDnKITCfobCq/VngPpngEIgKoQCJ9znKMDnKbDCKbwnKtgnKfCnhNpnfqKCKtznfjLoKeinh36ohepnf4KCKIjCKZwCKKioKIyCKDRgKvwiKriCKbCCG1RBF8jBGWxBFexGabhABTnZZoATQgQcF7jJd1JACQwkBniACiCTnm2GBgzNweWAAnjAPGKTjeXMNsVAZHoO0HDW/26kCRgwnBMVZQrApgOIHNzEVj6hmXIsQAc82Q65kQms3KE1mgQ8pqkUGnPaaXI2Gk6in54uWp9k0J9Yop2ilxi5WxdNZ/4JAXihFMyFIUe5G3ERAQ7QABm4wi6yGHrKwnqqZ3u2wnvW54V+KIpiKIiSAoeOAoqiaH/KaopSKIiOQiqIAisc4H7uJyqQQn6qqn6uaoVuaLDi54W6KimIgimYAik0K7OegnzSZ4b6KitUghdUgUMVIW2MEwxwAGXCwAeJKwvlQHQ46ZOhABB5QAxggNNgCtPQ0RCgwBDoXhKgABUKnApYIo65G8o5acqNALGUQTqdBgrEQSC8Qc0kxP8bucBqiRycQV8D9EULGAAQ/Ymg3Wn6USKfMqmjBWeitQ0mJicnciJtfSJzYkAHOJoHBGcFfBdFmRcYtdQKMN3LSVdLbtEUmID+Ld1mURQREAEIzIAkeOot6AJ+iWqpumepMq18ymeqrmqswlqr3WerWS0q9KcCZuh7tsImgMIq7KcqeCiIxuopmOiJwqrZkq2JviqKoq19TuiLNuDcpgIr1O0BogIouEIiWEEV0IwSJAEd6hWk0KucaoaeLMq9xoAKBCcFJNlANs3NIJcK7AkMyIYLQMoJWOFmPBooHqIJAByfYIDnsBzVpMAQOJESJIcOmElIeREMeCTcxM0JsNn/moFBHGxAIu6JZiINczIaz/GboikAA5hZ+rUNyQ6qnoJin/hbJEqAnSIl/d2ZCrCinb7cCnyTJCol9S4WaCgZEZ7ADLRBp9LCTKWnqI5qqb7C+rbCL64ChkYtrGGohsLvgo6CAr7C6rTdH1iCK6SCKrwnqgIr2sLqhuoni7YorKLtfTptA8/ti/rvKvwqA7oMDmTrmhDBDbhTFzDOz2zWnrwABFWBky4uFaJA01ShCrBezvjJC5xABHnZ13iwHKmcCajATwJKDEyiGJLUZg1BF0RQC9iJEjipQnhODJzABjRAECmAyKUZnHaAzV0Tek3ioaXfo20GBjgaom1syMYN/yZ2Ip8+2ihu1jVVAAVA12JRVHWGEW+B180S51FqZ3EpkEEUwQmELyYU7X3hVywkrfoqIACX6vvip9bmJ6tlKP0mciAzsn1uJSywDrLxQh+Mwi1ohHsaciBbaANHLYjWbwM77QMzYCr4r7SSAis4QhS0wKJUC2tARgu5QDUt2WZ9sAmpcJqkydb8IZOqsGNtIZWdzY9S2Qts5k9qGtO0HgZMov7JAGIJH6QwEGhuFrFMgQo8ygkYwJzJ7gI8LBEFJwbxbqAx56L15hwVGpIh2aERL04qGnJWgDJDV6F9UHC2LMuhV0tFKvV+l1ByEUZZ1BfRXzKVUZmkgelhQAJswP8glO9M8TEs+PEfM/IrDLICMq0gt4KGlkIiX3QgbzRFX3QqtCckIxuL3QInxIIu3MIsrOdGZ7SqaSgo168i36ciN3CzOutNN6t82u0BhgIpeIIe7EALNC8L+YqiyGssR4bhph4LMY2T3smaQC4FIPMNK8FmrRtmCF8LnAAxc0ByrSRosCyTJgB4gUZCrNubbA5jxHIO3JkYPVALWEBzCNRx5FMgFkDu6mkHaDGhBuei7XUGRbHvbhCfguwnKtoo2jA9s9wb4WaSnZdC8KwJaNH4WdQUcBH9mdd0ckGsVIGoZeIFJIEpsBgu8HEvwQIuugLTtsL69qJEq7ZEA3Bsc53/R5eqRav2ILenLETyLcTCIfxBHmwCi6k0LLwCI6vCKgQyjDqtKvzv/xr3c/9vjI4ChQZoq5pCtIYyA1YCFrBAC2Rm6g1BGGyBAmmKDrwROOEJODm1U1eBdLAepqxr0zxcCiiBHFwBHnMA1HywB5TkU9pwoFHANnnOFBQGYwzOD8Nw6VAO1VQBEcDAx81WcxTRcmjxTprKJV7ACpjATn6i0tDyJAqnou0kKHrihb9xokaaviKNZGs4GGT2dO4sn0jnKVoURk3BF4gRn1h2ERBBF7TbJkrABjCCeZJ2Q7cdat92LxK3a+Mv/qonR992lDPtKijtfc1CLszCJjCgJazC/x8RtwK671b+4nG7r/u2byC79Gwbd23b76sVcHxKsE87gg/YgAm9kTUzxl2dddToAOjpGX0IwdacMGsk2bxWwZNJQM50deJEShdcJuo9TqCNgAFxQQlgCnQKgRa70QuFCWaENxd+kJqsWxdswWUk8XCISgOQXAMYtgJcQCfSs4Uf4sbq5IX3tQSMgIXrKQNIojchDUZBFyVSomQnGaNalAqAwRmEERfhERd4UTLxFhd8AWgEgWWXQBKYSaBxkQ4MApFvBOtgpV3Ip9oCKH/SWoI+4APKKn+qaLuDQoC6eyi8e3Xz50vHAothZSukwtT2J1h2QoB6HcCnewRSoDVeoP/Y3ZpYZgIFXqCv7WIsuIJP78EScGtxUc11jIkO2CsNzelTMhCm3Ay+qkAOYADrqUCAI+Iifp41gwGSBbieGFCMYwqf4LC+nlcKnAAMJIhtxFC217LGJ0EV0O7zQWwBDEA2F8BOgqwWT6KjNZdwgnhM0jMlWrGFv/McvaydCucGlUBvSmKkhsZ/d+95haGGhxqlBvR00qwbMVCketEVaIEn5EK4QPIsaMTqUPkvluqFch1+8ufY8mcpnILgC6snj23hS2h8/i986uLDnzkqIHJL8ye8VzeBFqisGii6c8JXdiWtzdooeJ1/cgJW+pIpbPcRbIESkBSXzcoZmAkEUVP/B1DABYnJw7XJQHZpmrDsk6Gr9F3Azqkwc6rA71PuxunrjOspoChzDDyaG3WpB2zNbsDJ1pQGZikBILzB0FiAXS+HmxYRnpqKSTKXo9mcXm99cP7kyh1inyRiFDPNj3XAJPKmN33XIepzjC/dywKKDUsnS66x5wAElzRCSpgQMoWEEC5CZAgxYaKEEB02BuW6FQvWrFmxaGls9RFkq1WqVIFElSoVq1SoWLYk+RJmzJIgX8IKSfMlKlU6Ua5axepnUJaniLZEdWpU0qI6mZ5M1YplKFKpSJGKFctVKleJaNhIoiOHDrFFlIgFK/bEiRdrU7zQIeMFChQqPMRAEWPI/1wUGPZSwEChgwoVMooIweDBAwXBMjp0MLHCBAYZKoRUxoChREO4V9J0GeKiy5UiL5SUVXKlRZdAgIhUaeFgQQEJsBUsWGDAAIYEmFeUwDziwoUUw0t0GFGixHETglWUSNE8OHLBxCMfT15heeQphlVMkQFRxeOGyFfIWLFisJDyQr5MWV55e0MhLwh/f+GihxZPuVxh3ahxFllggeWVATEqcMABb2rlqo9eeRDCAiN8MMEECxQQlqswqtCmBT0MCaZWQvSwwlZSSaonjlxxxRQ2jkgiNLJGa6sFF2AIC4YTOHghBQ846IA+HVTAK4YihswhBgrw8isGDIQookm8MP9gwLfLMCiihAtGWIGL5gqiQIYwDfoOsRvFKisHD4rQwa3PukCjjiqIyMECCmxbQAEH9LRggxEweMg8GZzzoAMPnFMhBRP8HEG58lJwLksMhnvuucl8UxQDCQrCoILtRtjOvcpUuAwyEyabjCH3vhtMsBUIKjVMhRjyICwb8KClP440qsWWWnytRZZgMawwWA6NNXZCCxMsFlkJI/yoRAcRJFCml5JFVpVSZmplRVcqoYEHIt4I4wolhoDBhRzCMktdHU7w4AQU0o0BBhWGuDcvCvy6a68hBTtBrHlbiOEEGFDQAAUPgpNghcMMzcyg8MorIQYX6F1TBjZTOCGHK2L/yCEJL94AY84WTrgTzwYWaMACU48bQUzkkDP0URUWZdTUyVIIUzoZ2oq1BJurG0FRCbr7zrv4GILoO6Jzhk+I8B5SAbLMNDvvobbkCksJQRSRhBZabtGll7J7CSYYs3dZexde2ubF7V10wQWXXei+G++877Z777X1xsUWW/4GvNdfeQ0ccV8LP/xwxPFGvFdhVbnKFU0GkQKKHN4oI7SydEgih7VyOK2LssjSgd4YdLg3htZH1dcDuQ5TAYYhrgAjjC7W9KKKKjz2wIKDE9USDIIkiIy874JGIYcLPEhBhxl3/OyrKsIA4wwiiDjBgtpQNqCAyI4PbwQsaZY5aIim/9bshRLWco64FBjyeTIVKiCa/PFMNTXqhyKTWlEwk0HxysMbm20paudZwRQWIoETxGADOQgTDGgABE2I7RfLWAYzoGEPezwjGSFkxjOgAY1nnFCDGkyGMVZoDBe+EIYvTOEyjLGMEKqwhS8M4Q2TYUMa0jCGLuzhEFN4QhIesYTQkMYSlxiNJV7jGiVcRi820gg1NEELR7DBG84QhjBsIQk3CAuPSHOFLuTAdkrIgVxUNwS7eIA5iZFjDFSAgi7cgVxl2EIXvhiGM2zhBjBwwI8Gw6moCUYyk4HIBZyjARecYDiEaouOONCCIeTgRlWIQxWS4AEJ1EYBBaiNyogmA/8MUI1oxflN0AQ1mFhVhiHIYRTVIKa8h2DATw2B1XfCtCrIUCY8VqoAegwSGYfcMmgReQGjSBCEhklAXi5YzBV48IA+dGQXLGSGNDzIjGMgAxnNUOISTTjDHd5QhSxUZw9n6ENzutOGO2ynOc8pTxUyg4NJXKI1pGENf3JjHvaghzy44c+AzoMbzLAFLFzRBiBoQQsgA0MXvKBHKUgBdKFzixLCQLorDGF1aXLBXVSQA0T6hQJbG0IXzsBFOXwRjGXwAu+6oIEF5CBTxfGNCrhwyqZFzQN8cRcH3gKkF3AAqS6wWA5aoIMzoOGMEtCXnQpQAJZFzU+4XBRmkAMR9DD/BJYHMc8wIZKcEpSnN9i5H6POUwLs9MYglQkTXCtTgYJsqTzuOY6gVrCoqAWqrYwagQo60BAdKIELMWABEFyRC14sQxrQsIY9rKGMZBTjGMoQJzSawQxkHAO0xRAtZkF7DGOEVrSlVe1qWbvaHJ72GKkdbWlJC1pwglMZzGjGbqMBjWg4wxnRsMY2rFENZ3jQHvK4RzSKIYtYaKINayBDEogwBOpuQQtekIIewXBJ1MVACUUAQ2nCC5aNDeE5KnhBczBDOxRM9AwxuMIWwJgDHhwhP15xI1IvwIGfpeAC87MLpFDAEEQh5wo9agtRD/sCN6JACWlIAxh0YAE9waYA/+BTj/8ektWyqk9pDHSVelZAAhIwyq4yeFkFJGDXErvVxFijjIEjU4FT9lV95jmrXRVlAr0ukCBWe8hdGUUYHXAhwSegASVygQthlFC5zC2GMJCh2RIyQxngjO1sWztaL7dWtbVV7Wu3jNkvp3a1t83tbkv42+BuA87GXSI37iEPaPRCFrRwxBrc4KLVJSEJULgoG9xQhjsowQVigQG9SnOFcq3pBTBYkwt06rMLoAAGRNiCyGCQhjtougtWgMIRaNAuacrAAQzgAGIoIBxTlqDAzZkLoTqgYOgdlizvahMKdPCGNJTrBBqAjYUHMAD0nAeAjErOY84zhfM0xD2u2v/fiSuw1gqQoNrV3tKJW3zW7/gvOZmqNi6H7LQ/Jec4C1yVK7F2v7UehzRF4EIRPNCCGcDhFrnoBQnlYQ9mBKMYwcisOJuRZXAmo8xcZu2XV+tlhoPZ4RF3+Gpzq9skAjca2zjHNqrRWw7OI4q1YKgfxsAGMyRhCGpMghWOAAUzbE4OZWhdEXIw0ug12tFXMMv7GCmcIqQgBml4QxeIjocbhMwL9LUCfSm8FtTp3EdK4NHzAjOcKz2sAyWQ4FnCyyMdeOCRMQADGK7ABR6hQE8LKLb6IGIdRdk4aOUxjwBhBe4RaNvaCRDs3e9e7bNyqgIUkMDgW0x4WZZAU8Ocglb//8RhhRRh7r6xK3JeUK7wXkADMwDCfnQhDGVAMeBT9jzBDY4MhI9WGMI4M2kl3nqFN1y0qVe962eb2mTgc7e7xbg24GwNaCAcGdC4xjEK9AnpjsEKvlNCGcJABjN4wQxsoEOhG20uSa9JB44uzbnW8vML+KUtPdI+DMhvgzLkgAw9YIEb8EAEHUB4TZxRow7A8PMn9QjWF+gABYajAAX4qEeAZFJq7gQK5QQS7TRYbQFgYwAwhcWyDVNQbEvyp1QUaJheZgRMbARa7H5KrAISAO8uY/AEz/8UIAEITwL85JY4xcfOQ9sMSK4YAjLuLmgKSzQIY2VYYAcqAhd64Riu/0EayuYX0MbKCu62ykz2pszLUk8JI272aM/MUE8Y0Eb2kpD2bGvNoAG4gisaeK+3YksYjkEadqETYkESxGANpOBFymULzsAMyMAL7OAN3AANkmAL0MALkgDRbkSpUs66wEIuTGkEak2nPCBjyOsGWgAP6EALyEAKtiAMWIDCDmuPqoCjrqAxgodHLowBnudHOKDVGCA4OiAHUuBHUCcFUMA5XuBJzC5TEoABGCB8+m7wtG1qNhADION+FKVhIGMFhuk3tk3ZgsDEBo8B8I7F/O+TEiABTFCqbIzv1Op+ZMDZcKkgwmMwzsMh+A6X6IIwRqMIHKABTmAHsMAVdIEXiv/hGpZBcdAm95rhCBOOCatwCtGGCqtQ9ETPCp2wHu2xH++xCSPum6pMnLYwGrpwG3pLGHoFF55BFjYhFQZhCbSgBwJpdcrgDPbAC/rsDdggDNzADMzgDEDnLGouXfwQ0VAgBSRFZtrnTHLgBJQAdPTIDAjBDQTBDD7gDRKhdrqACLpgC8CiAzjAAShpASjAAiygRwwgFg2AGUXRA14AMaAHpYzGZ+QNDFRA8J4ygFiMAwcrmFKwaIiGaCYvMhomgO7u3BxCAgigFgsPBU2wGRNAlF6wxRTg7nIMfSjDVTRDxSTAGvGnIUBKB/aEBVhAERyrF6CBF0qhFGDhbHLP4GL/CwxVbwovM/XsUTP9UR/vkR4zczODARhC0zOZcOJwS/cwDiF9bxcmARIsARheYRQyoQ2igAl4IAdYoHbKQBAeAQrKgA74YAt4kw6grwpyYI9C41xUZ3XOaDheYAUepQOezRAPywVAJwmq4AbUkA/cIAeIAA9O4A0IQQvs0A6LgAEsQANEkQH0JRa/jwPosgBg0QEoQAMowFAwIF4ugAGyLiLkQA5koOcIoAAuA8XG7THubvD4jq2WTZYSFMdwhqy80ivh8gRZ7ARD6QTvzmYowMYAs1R28aemAAxMpa9YjFG0qjJiQAiUIAYW0AFQwAa0YGxwYRkeMhNeYRd6AZ9K/w8MRTMYQJMKNRMz8XEzZS80gUFJgVRJR9NJm3Q0qVAgq0y3UrMZDtIaoqEZdgESDuEQaqEUQqER2oANxqAHiGBgPqcKnq8MZIoO6MAj8xBkiEAPiW77Eq0Lvq4D3qKX1OMCJKDyHoipcuAGtkAKTsArCHULlOAE3KAHbIAIvCAsUIADLGwtGIA+OwBTo5I9C2ABVg3WfKQu6AIDGEkO0oALUqADLoAACGCtVGDwuEoXOdDFbAYwsy0XXcastkQz2OoDW0w3LhTwKMD/xM1Pxs3G/kQt+Y7EhOAMCKIDXlECVrUEiuCjtG8IbiAMwiIHaEAScqEWfgEWOAEUaGEXgv+vhDornooBGHqBGIyBGOJVXt81iGAoXmMoXoWBGFJvXvtVXl3oXf81hthpg0jIt/xpt/zJGriBG6RBGFwTEianKjwhEboTZFQH0LagB5JuC+jgEcrgEdHgBmzgBrwgDMrADLogDdToBBygLehDBnfGOXZECWCABQCtC1pgC+TAC1hgA7hHEOTAAm7ADW7gCMzABkAGBgglTV4ANtJzkH7EAk6GAtrTYDhgAVzgCmBACboAAVsRwC6AGQsiQYGVFk0AWV+m8KDRAStDG+cOxQyPU0CQU96yFkdA8C7DK1lwmNAjF6mRC7qkAoaDPykgM1rqDARCDrroZMfuCm4gD2j/ARduYRMugRRuAReCoYRQyIaMIW16QUl/4ReglHSbVHRHt3SB4XRXV3VXV3RTt0mHYRiCVBiG4V5ZaBlOKInwyWCFKxqIYRMQ4RAsVxMuCBOkoAdywAbWBNCsIA9rEjxB9gi2QDthgHeSoAxWNg2SwAUsgD6exzwexX2k8gKAcgvM4AaO7gS2gA9cIwk+AAbuoAVs4AikoAGSwAyUKkd+RP+QilAuoCintgNcgAP0D2Fgo2p17v3awux2RgYYIJTilsVw6X7s5wGTVW/7TrB+EQOcTRvDAzvu7jyOA5cSoGEogFFCSQFQ0EMH7wRxqa8UKK4YKGoq4AKGIFXVRGXv/+AN4gBOzuAMuqAKtiAOYm4MTCEXYgESIuETbmEXgiGETEsfeQFvMHdw6EZwfoEXbGEWICdxFAdxbkGMx3iMBycXLAIXckEX1hgdeeEXhiGGghSKLa4ZiCEUDmERIoEVKEEMKkEPxuAIiIAOzAAGqCAJtCAKrCAOPIEOjJYOysAGNkCMyiAJklZ5c+AM8MAF1mJVKUU4MG9qdUB7lJcI0KAokdMGTiCCAKkmreADDKABOCDYLOAoXwCAOUADLk3YirIF4IQIGgAGaPkDaBkGboCWPYABXGDouFYD6JKENeXuNlTcygNtTTTblM1ljmOYqKbDTClZISNTjucv7odTMP9AAQLvhRWAAC502RhFU0jMO0ypA65ADubNj8DgDeoADeLgDtAAqr7oDfpZCwohF0ABERZBE5wYGOoGiwsHFrIlWxwzoh2Toh1TFjD3FmahFCxhEzraozs6EzYhpEdapEXaEk7aEjJBpVNapVeapVs6E1K6Eyq6FDZhpnchGcIJGoxhFQ4BERDBFRphBsZAEPAAjBbXC6ggDqBgBsLoDuQgN6XADeYXZJKgDsVoC1igDOQApJ5zVEoAME4ADygsZGby6D5gA1ogCX72MO2QBnrgETBhCywAJmMANhaAP4kyRk+AAWLjpjYgDOhgAxbAAhogEIxZA+KFAsCAAobgDrr/4ATcqGqz7XiyA26J7E8qo++ww39cePIw0AQKr/FUwAQ5xUPrtljNeYWZ8QRb+wFBsO8IAjG4gOzAIA322YvQ4OXuIA7c4HzNwA3eAA3YoA1cgRIK4RA4wYl3AXJqIUBgoRQ6oRNCgRM2obqru6M5oROyOxbGmBZWIaZR+qQngbzL27xRehIiIRLKW73Ju73Ve73hG77FO6Qn4aRxIad3yxhowUsRQRP6gEzJ4AgS4Y+8ACjdwA0YoQc+wJDlYFE/Z12U4A00+QoSwbqQZDTWAjFyYE+V4JGToAcIIQla4A2SAAYOqwXycGo1wAIegAW2wAZA0gDEkxD0+ih9zTa4/6cBDMDELcALrCADNuABDsAO7MAMMEEO3OAE1toFEoGxXWAIVtXGZkzbfGOndvEXt6TDHgMiKuCc9W6txC1TFEUGsq0ZP0kBPFRDA2/w5FICTvDN4bwWobFhruQNRqalili45eAOAuEO8AAP6gDB3SAO6KAO2KARDuEPDuFy68ZwiqUVtvujRRqmK12lOYETMiG9zTu+19u805sSJEG9G6ERIqHUSf3UTR3VIaERWJ3VSZ3V29sS4FsWTmu3kgEXFL0QLmEQGEEPoOAG3oAPAO0RCAEKoKAS7DAQtuAOyuA0DgukmKcL5MBdTqB0rJUseMTRxouStwAT7IAP7gAmP//DACyABQLhDWxAAzRgi8ogEW5gxx2ArnXAABZg3S0AlwcbJgfAAI4ODegAN6hgATLABgTBDlzBDbwgmMcRDBjAAS4AYCyAaKQNO6Zg3I5nUy6lYVhJeT4w2yp473JxsKpt8KTGy1lbzuly8Fp1ndc5zglv4h/ituuAh4uYDt5ADuIA0OPADuqgt9dgDvAgEQSBD+AgD/LgEFYBc3dBWDBkJyg9Ey5B6i/hpClBvC1B6mc9EiiBEkZd1VEd7MOe1BdhEcae7Mse7NG+Ec6e7VFdvZc4EkoB4DTLGHRhEf6gDwoBCGaADQQBkvmgTfmAD8jACNyAB1iACgChdBaxDK7/AA8IwWCcCo2qPdGiUgeUygXAAA9gwAo8gRYIvNg7AF0EQAAKhQ4Y4QM0gAcwIRGkIJVzoFIdYAAIewE6AAxQgLANoAqEtt4bIFJZ4ANYwAzmgAUOIAO8gAaA/zZYQBBOoAHEsQVQACxXYPDOKgU1+K4yoxfR1jwaBhZ1o8XQMqskY1SuJGoEDzDFNkNX2AT9T1jvjiHkrTBoe+y4IA7uXw7qAECDMxAInecDASDiuAHkxo4dQXjmrMmT51CsW7hwyZIFqyKsVKMuWdJIaSOlS5QoRQpJUqTISI1SplzEsqVLl4oUIUIUMybNRStfspw5s6VKRI0ibQJWTBkyY78g//1pI+bBAyZ6yPSwYYOHDTZsyOwh5MYAmjJdwiTp0qVMmhgnOnBwAaPL2hc5UrwoosMFCg05zBzhc4TGjS1JXLTQsIDChhNJAm1ocNVGBg1SwnBw0KKDAwoOLJwtsMCAgTdyLOC4kYhFBkaeBNk5IuXDgAENDjQoYOHNCbwWLMCQkcLEihUYElwQXiHFiAsjPHjAoOKChxIXMGBQTiEBgwIKOnQY0UEF9AsqVKBIcQbQozhChsTAkCK9jCFVuFQZAp9IlzRg7gS6k+aOnDdcgCEgGmAQCEYccqBxxht40OEgHg3iAYUdcxxUECFtFHLIIrHUogsvtdQyyyyyxBILKv+cpKiiJiy2eMmLMMZIiSQlzSgJjTbeqOOOPN6YI41A8vhRjEFdMoowy0ADzTLDTNJHHjs4RcMgnozhAyFR+KAVHHBgMgcLViRxxRUu9FBGInJssAEMMFzAAVoedCBXCil48IIHHHBAhw0atDCHIIRswUYiW1jAwgeYPJJEAwsQ4cUBLdzwxiN8aGBBGGecsIEHAywwQAEfbPDBDRZskAMdN4RRRSI5uPEBCzQ08JoFRDiQw61VVNGFBTHI4GsJ0kV3AQMXlFCCClwUUUQOQyhx3xk65KDDGWCccQUYYWDLhRxpvOHtHXHEUUcdgRCCxxtKXFGEEt6+EcgbZ6AxLh7/aLDhhRl4PMLIG5gKGMYd3saBRhVhKLjgGW7IQYfCD/4ZCB+A1EEIIWO0cQgktODCCy4jjmjiiSluskmLmsRosskh3RhJJJKszHKPMMcssySN6BjSi0FZ0gkwyzSzpDGWLAXHDA/4gAktYxiRyB5zeEILJmz0IDULa17RQhmM8EHHYUN0gYJaHHRQBJ0pyOBBCjB4oAQMopZxhBd7HHGEaR/wQIQgj1SxgQUNNKDBFmWA1YIFLRABxgZVpOFCARS0YMMCVuBxwgmDG3CGBQWc8YhpgthAWw4XGABDDhZ01oILSoywggzAjqC6DBLIcMfsgQSSCCFyJJIIH2VUgccd/4Qkwoju5noLxn5pyOEGGm684eDCCKIRxxYKAoJHF3zgbsYbW2zhxhlJoHEHHW6EEcMVb4AbR7xdKOiFF2+g4a2CzTvvBh+JqLYHIxTDQUkotPAQx0ZUIhONQmQsyoQCT8bAkqisZS4Lysx0pJKU0MyCFcxgzXBEiUVEwhKb4MUykjTCUjxpDU5wwh7cMAcyMCERetCC01xhhxvwwBGJ6IAHYOCCMuSCDzeYXAxQYAEPOEeHL9BBCpTwAgpcAAVDEAwjHpEDFtigDDc4VANwkAg7ECFSOeiMBmyglxsQAQ2Fyk0LHqEEA+TmBAs4geTcmIEAZOAAD5gDH/TIiDiw4P8EoVlAC3SAAwNwxgAOWEFvgIWBFXBBCDIAAyBoBwg+MKJcdEBDGOjAP/+gQRCBwIPW/EOHMJzLeWigw7v+Iz0CvaEK8YpDfsrylXq5IQlV8MIZyrCFK+jgCl0A2BnO4AUBEWwLXlAQL71Qhvc10wx2MIMbtgKHMaxhEQAU4EQoEotWtIITClwgA2FUI5KozGUoCcrLYKbBdrYTJyqxmQc/uAtjJOkZy4hFHtqgB0OIYQ5QIIMbfrA0NuCLDGyQGyYSwQEltGALgshFIpLANgqoQAkaOBsDKIAn5bxACR4Igwsok6gqnsAGLeBL32wHgwUswAaMysAJ2PCBOvTgBDn/cMACYrAADRSgAANAnKc2EIfFnIAxNjhABrSQiIVu4AGd4cwAclCFBligCwsoAAkqwNULZId1RUgf7QBFCEEIQl7iAqXAiLA8NOyODmVgAx2wcgNB0OFcfDhXIOqAhzqcYQsLQoMmkzAEOYQhDG8oHy+7cIY7dKEIYLhCEuLwhiRsoQpJGEtmARO4wHVvC1YwQxys4IWCzGEMasgDJ2gBEVtYpJutQEUmLjHbk5XzRztKZ1DcWcGVaZAl73yJIuDpCEfcCCiQiEQt7NmMEd7iEG1Ygx6AoIUWfKAFUpCaIKK2hSyCIRFhuNpfmvoItm0gBh4owhXixAELaOAEKDhb/w5Q4IIOUEAJKIhBElpQhUc8wgwtWEyrCEGEDTigAAY4QIIbcFQvMMoAZqDDaz5VACFIoAAJAEMLDJCBDICABXMYBAiW4Ag3LOAGddhAVlFwAjOUTgc6MAAJZrwCYBnrAvkBxCRFKYiC8EEQXRSINN3wPi+QgRCYEMQb7OoGhJzSefk6jywXRD06dMEGb2gBMLtAB8B1QZplCEMXxqSEKggIDJdFZhJysFl4bUEKUvCCFHiwBSo81A1kwIIY2pCHVAQwIhaBRStWMQpLGJqctzVnjxzB20Y3QieQXkRNanKTDCICJ5GQhT2XgU9dQNcPjgABDaSQhMCx4AiC2MIRHv+xhcmt5QQfiKtjWtACTVGAPVyQ0xs44AH6AqIIL+gAD79LOja3+BFnUJMVbLAFTNxhqIvCYwZgQ4UP2MAAG+iCAzZggAEI4KcCSABt7lBIWTHCFYMYQAYeEFQdLMACA9i2GcxgSAskssYjwEAJeNMBOfg7e/kbFyHIJQg+2KEOQ56DG+JgB0JkTRD7wwOgIMSgN+BrenEgIxG817scNIgOOgADHjg7MMxeAQZK+GsSmrcFspQhs0TAJRpzYIMbVIEIN1D4l9FABjKIYQ19aAVrcWELinhzFSiaxM0QfduYMTq4j/6tpGdiE5rIhCdVN4QhELF1mqSkuIcASiRUQYz/EeLzF4fIgxrgAIId1BzObAiDG2BwuhjEQAcngIEGDsACNsRvA3+EgQpigKwKeCAJG7BUDB6BdxRcQAmM8Jp2WHApAO9tdAs4DFBPwIgtxMYGLGiAAxrAglpTDncGwMBPsfMpQMQBBnzIAB88kQi+fyADBljA4grw7deoiQIcWAEJRlAC4vNGCXdwAx7KGnCIBgIhgqgD8wwCSjussEJ2MDj5GOQFZArWDTdwQx1GawU3mMELSUjDFdKAByWUQQplaBX6KxutMe03zWZg8xbCAAMbOKp7X4RLg8IH5odnY7BniBALswARt2B0SBcKmzASJPEiDuR0xkVBKgFcL1FB/5I2aZTGE1rHE4hQCCRYgoVwaY0AdocQFKUwDGbHJJEQXUAAAmPAGjeACblACDfQAiwwZkMABoKRCF6QAaRmA13gBScwH3cABh1wAf2WBA6gATqQCJJjAR2AAkpgd/bmKKKiYh+AbSdQAA7ANgYQPB3GAl6wAVvQAgGwAXzQAgNABHwwAAEQAJ+iAAowBCcwAJpDNXzgYHYQB5RjAUpwYHT4Ka/xUzNmLCNQNikgB+YiB8vHB1pzJmaVV3PlPXtwfn9icNnnBqBlBphCB6IYP8pjBkRwftvTTGEwBHXxcuzCPGewccQ0bGCQBETgf5C1LjngS2JyBUoQjEoABkoAOP+axDxksAZt8AeR0CG1QHS1YCKtkAqkcAkSOCQg0XQygxM6kYEsERMr4YFWp3U24YFad441kYKOgIKRwAkuyGkwqAZtAARs4GRsEAeeEAg9UAXe0wVEUAU0hwmewBo2cBsBBgPoNRwXUAAnUHpJcBtDoAHtZV/pRURgMRkb4AaBEAN6Y1U5oGKiwgKE0AKkoymv8W4OYACzcYhi6AAd4AID4AIUsIcFEAMDUGtoICuG5AELcGE/ZUjIsTorUAEj8AJXgAfPFzx5ZVYVV48IAYoslDXBkzXTJBBEFjhfcQZyAAZVgEZbEC4CMztbEHJjdgI6EBbt0gVbQAQ6IAdd4AL/OYBzSaAEQ3AFZ5AuY3IFYXAFzTImXUBzgCNNbAAHefAHluCMt1ALtCCNqQAKlrAy2JiN2shO1ygS3tgSivBoVSeCW2cTXXeO51gIhpCOKbghQbEJ74hPw2AJbaAGYqAFWpAEPXADScA/bCUH6OcFMfBdVfCGH4AYtRYHVeACF3BrCdBTGdACbtBenKEBLuACMWAXDqBTVpUZSZhfe7MBSVA6udFhZYAJSfABaOAAA6CSWdMZA8ABr8EAB3YBL8AALiUAurcAdJB7hqQEGLZ6iPhTJfAbx1ECSiAHBYcQfABlgsBMopQ/ShY4kzIxAxcHyXQvCHcDNpAEZiAvCkJa/4hVS3hwBmEAGDqgBL1IFphVotGJKZJ1A/3Xl+oxZh4QA+miLEpQF17QAkmAZmaQjH3QB5zgjIrJmKTACZQQFENSTosmCcWVgioDQpwQCqAATiDxaN94aVMngpsJgiZ4joMgmqQZdkGRCSIEj8TQCWrgBEDwADvAA6fWAj1gU0RgBWuZKTmACZiwgycQA3KwUITyRxywUQ7wCImgAZlBGBSgAYZKXzqQGVaVJxbAAYuRG3ujUwbgAlRjYNfGAJaBYHGIB4CnAV7gKQZwAh6QBuopAASAhymAAuRph+K2eoXBe+A2fMRHJ2nAB2eAL3kFZXTwBpQIZaLkCOcicUwmMP91YAei5EWl5S2JAAhoYAblkjXwI1hq+Ys6kAReADC4qF86QBdpcAYUeiuueCtjRhd14YouUASPVQY28INbkKNrUAh9gAqwUAuJuZiDRgpBihIsU4EwU1xJ+nWNQAmZAAqpsAqswAqp8AmZgBJV+oEiOBMkiKUmmKVdChSNYAm5YE/4ZAyvoHZN4Rc2QAa5GAhWcFJ1wJYAiQaYoAOAdxhdAF4n9QEcoAF38QiuQBUa0AAMYAGON53syQA58F584zcsQDqEEwMOwACiKgcN0G1ARWGJCKqdwSg/aQBKQAECMAAEkAAE4AGhkYgJUIfxtm1ZpQNvMADDVwJFIAMvQAf/uYoH+XMubnBXBec8PyY8ovQgSsYwWnM/mYQGolSg4JNLeFAGMBA4Z6CWN3ArOQAYgsWR0oJywKQDJHkrMEA5hhNzXlAF+YUWVFUFi7t+YZAVelAIf+BNsyAitOBNjckJlxB1GxQzjnaxnIAKq1Cwq7AKpLCwHSgTkzYTWmeCwDuxJbilJDhcKnEIpkkJtGBP0PAMxjALagcEM0AGUlB+UDAHmICKLfAVbsAIeMACSjA5OVBrvGIHZHBdg7MB9JUEZ5kfpeMCuJMDJ4BthmpIV3AHJ8ABXaAmk6MDFHAFBsAqBqABicgBhvRT3pZV8TY4C0CGQIUCCxAAP7UBcOgC/zqQBiUAABRMAZ/CBRhwBQMQBKzDBTmgBG7rLdnjLUj5Y0B2V4H7IOZiV+NzLrtaBoHgIAqTV/+RBDYQofyIS5f1F690AmuZBLO4uSf8BmDQBTdHBHRHOZjbBZSLAi0QAzkwRLQmJmJWBlpQuofQCvMqIrNwr5ygCR1ksSmxThiYExsoCZtACkc3aKtgCrz7sJwZmqJpuns8sYPgB4VgvJWmIWIXC8NgDD+DC3+wBmKgB2NgcTZEZ0eAA15AB1XgBokAPkqGU1WgKee2GizwR9vmLTngAhzwCB5gARRwB7bqBZCqAQagA48gGbXWAmloAF3QAQVwAZW1nkClAy+Qtf8UkFUBYFVogTkKPABb8F8GYBq0UQDqcmECUIdZy4cp8G2QtG9DwH4GZ1BsID5WVgYTxwZwSwh7lKB7QCF48B9l8DznghUMwgZl8AaSFQbO4qGBEwaba2a46L6SZKNsAkzOAsVfdLmTY6N/2Ws7NARZnAOj80tX4MV+8AeQUBFkvLqNOVuNoLzApRK+dZmQFrCh0ArS2AquEFsRuAjA23UrHbzBe4JcN7F+8MczXYI38QeimRKrcMj4RAy88AdqAARjAGdv0M5SQBVHIDx01wWltgU24F4FZgFegAmEQAY/0ANUcAcOcALg5QIPrMsOEANpSHotsAANoATPuQBK8JD/YaADFpADHABfb6BTKDAADJDArdqWnhJHG8A4YWTWboQG/EMG05aEFFAABCABdQhUHlAADMAF02wsMtABpvRjK2QHCyM+/sEHgWAHz9dFcKsaaGDOeNA8mRRXu8ogcKU19gIGZeChb9AFzgIYuBhzMKADMUfFAHlesW1/N3e5tAYD/1i+KFDcjEu/kZIEe+nFfcCMFUEis0ALSMcJj7kIfxB2yNvR8CSlGrjdkqAJq2AignZ0ocC7Kk11XAeahlAIw7UIlOAJl4AIf+AH9F3ffyy8MfEHOJ0SpDAMxPAM0PsLixDUIDADf1EGTyNnNQcDv9kCXWBdJ1AGeUO/OZBX/zbQA79ZB+7lArehAUPEYir5bo+ACV/IngbAv28wBDAwGYkABmFz2AWwewIw49MsHNUsVSiQBoRQABug4QPQA8v3CHPgUlXQATN+AQQQAN/GGVnLex1ALCkAMHfwO4nFypLIB44QLnZQEICQzst6cAbhCNEULmxgENnnPGVhP8pXWU3c2zkg24Bho1uAAjH3obS5S2dUyqUsHuFhdypQBDFgLEOgAkIgBDHwXmfZTGRQCKqlChZRIq5wCuDUQaZrdS7BWzeBaZfwCbjrTapwCqkQCYtwCH/AEG2wjE/CxxCbEqZwC8PgC5BQCIA83/YtmuQYE7YeFJrgCy6YDD4NCf9BTQNHUHM2kAiugAfMJi06gAJXEAgtIAiu4AiugAllcF6ncwKQGkcWgG1VoAG4FMoG8ADW9gi5QAcLwJ5rcRctlXsRGaocYKoJMON1SM1bS+MDoClnIMEHBlQCoFML8L0OoOR1qAP74bT3zgBKLgBuwgG1mj6lDRpiRTsMt+XSU6zkggYHVwddJFgUskJaozWAU6u85C3AdAXdJduRtXGZFZy6ckty8IeZVQUxQAEuEB7x9eeDrgIywOcxkAInAHwukARWoAVroAh/EAqO/lqtcAolEwmk/gddN2kbuBI9gROUoAmkgLupoAqoMAqgsLDy/QdPIvbNDdOLwOgzCAL/rvAhmyDrsj7T9D0IW7reo6kIJGgIxnUJvD5CxAAMk+AEYuADUAADNyBnVlQGf6jU13MCe5ALUON5FpB+KeAAF0CcFEABMOBGouIAblAGmg8Focw7DEAsOrTigvomYHBUC6ADDJAAEmCq807N0zzjmQdUE2xIM45gWbvsBbDYdjfiN5C1AXACDDDNmFoCUV7aCgMaeaU1S0asDReIAhMHqnFWxeoGbFAQBVcQDxI47lcGiJEGe+ksaTAELTCjbPaXKFAE1kIW7icIzaIDDF0CKMAevZYCQ3QB4BHog5cCYfO/AEFlzJpCh0KpevUK1sJWpDJRWlSoz59ChQwZQpQR/5GiRR09LjqEqGOkS6RYpUJZqpQqVaE0SdK4UZHMPGqAgDgw4ECbRbl08ep0iKIfokX9DEJ60RDRQowkUco1bNkyYcA4OSGjxcsRKXM+fLCxBU+gO3dQXBlC5IYgTCwyaDjxRo6LBQ5ipGFgAYYHDgsuLDiRQwMdOYEcsLjRYAGDCxQAn+BQBkYLGDC6aNBhoECBAJ0DSCAQQEACAaIFFBhg4Y0FAX4HnCky4HTp2YSUpMGUJEBqGGg2F+Cr5M0bNHLohHHDR45cOnQC1YkTJxGgOoDsAAoUyI4XN17M2OFjxxGhOXbwvKHTJU0aL1KqJAnzpstkJWBc6IiRI0eYKv86dBRxIQcdAlNiiL1yOAGFElSIAQMPKLjAAxQkUMBBDDAogQIHODjhBiLIWKMPRA5KiCFUOLkkEkT+6KMPpioqJCZFZtooopAaoUSTVFwh5SCWWOIkk4cuuUSSRgqx6YEDHmgDEk00iWoYY5aBBhehjMLyqIoMcbEQRSKJ5BapjCEGmFXUGEgQRhyxgoUPoOihCgGHcKELMIZggQ4rMniEkBN0GAKFDjiAAYUFKGAAhSJi4AAFGCxY4I7LDNDABgsYUOIFSi3QwAUlWmigAUo1KMAABxpArbQAEiiAAAIEUHWAARZwQwnZBijAhURgkBVW2hLggAINFlhgVsBaQIH/sReWcwON5sw4o7k7+CBEDjOqq4MQO+oIJI7vtt22DjeqECQRQQAhxIs3vKhPjiu86AKNG1pIogslYvBPBxeuyCGJJLbIQQkYToAhhgAVdQGFFDxYGAMVLrwAgwskwCABCiiQgAEMED2hhRt6IAOOPhohUSFYWgHloSP7yCOPomCEESMZDzlkkUYu+WRHVEYp5RWEavlJF1oyyQOEGYBQ449JYuFlymV8WWYYYKZaBphF/qCoxSz9gPGoixqJhJYxy5xFDawSeeQRMmiQIpEeWjiBhRM6gMGFTs/IwQI+zFgAELMssIBgDxhwwIIYMLmiiLkoAOQKBh7voIALXmDA/4AhlAiEEAcMWABVA0RtoIwbNBNgAw4K6CA1BgTQ7AQvBmjAAlkX6MIADjSYXbYCGIhhM9hPIHUAB+6QQOE05JADDfTQQKOMNJpzTo5sCakDXDsCQcMNOxhhJJHtuuAjkTnQqKMO78LQ4Yp/t3hDznqvUELfxIdIcAMUcgADBRRigCFQFxKc0MUS4AEMPI4BCVAAAxKoAAVgTAIXO0EEb0AGPfTBEiphyclWEaRIRKQPbWiDi7gGMxLGCBEhWUSOSLEKHo0CIaqQBTCk8QxIzCBpmdCFlKj2DB4ugxe/4IUsdrGMZwwDEixikQj3YBQY9WEQFllEJGAxtWdU5RZmW//CHDDhikT8IBGY8EISWrCBFuhHDiiADPA00AAHoGELFnAABf7EAQ50gDF4uIMD9HeBQABiQzrggAMYsDsllIED6LFA7Dglqw84Qgon2IIGDGCBMyxgM4jClQFy8IgWzCo1C3gDGArggGL5Cla+s4AcwpCEKnQSVQq4wh2G4wY6uMEMZaDDHdJQnPPEwTrVIQT1+ogtK2yreXMgRBzcwC08lKEMSQCDEnLgBWo6806BQsEQdKABDaDgPwYDXgdycLuEbQxju6NAAyG0GQX8pgAIRCCxFmABkPmhD5lQiUpgoYpTaKJIEckDCFskwhGOsISIwBEnSJGKVWyCE6iAxSv/ZNELaRyjE68wBg+f4bSqZfQZycCFLHAxUmMY4xaR+EMeWNayPOhhiS8rhMsGYYgokuIXRCwTLvLgBCCs4RGe0IMg9OAGGtigBTYomH5icIELgIELnDvVBhqwARjQgVMeyBtcOuCArZ7ABRw4YCC4wIUFfC4NiXBB7D5QBqTmADUf8IQr6FCGHhjAAB+wnQ4suZm7PkIQxSpACxzQgkBYoAAU8JVmSLeAGIABBmSEQQEAVwAlIO95e7MDG3JZBuS5AQ/QQUN0ADEdQESnj3GoQ3jKsIXk8IEPeHDDGbpwhTLoYAtoMEMSbnADAOmgAx1IWCBRcDsPXMACHfDA/1zg/wFBDnJ3BWjnINv5TgoU4DS44mupMmCFMbBsE6pYiSpacaJLUKKDf2iDGtQAh5YNFGtGwVpF/lAzSmwiFAt90iZWAotdPEMa0rjGDJ9Bpajh4hW2WMYxemELXOgCFyUt4iUkklKW6kEPRBGhRIgyo0ZoAmrLMAYwdHEIJzihDVqAQyVooQczzOERSdhAFVBAiC4UwY4yGKcLCkAEBG1AA0kQJB01EDhDOYCrXcjBC0pQMQbIEzKBy9sGPqAaQWjmCI7wBAsO0ABZUeoRSuBcAzjQgKomwQBd3kAOCIECD9yqrKEagA7Q0AIi0O4EGziDjGUrFz7EAT1swCUdzuCG6P+gwTp2MIMVlvlL7Bzaz3xgQ7O8UAU0nCENZbhCnbrwhiQQoQWNFQIFCBiDpSpQAhKIEAZSIIMicMEDHnhgY5hKIYpdYDMJwPVpbo0aWTXAChcuBClYEt5QZKK8krhaG9awBjiwV6UDHagfsEYRiqQwE5zgRCguoQlOuBAWuHgGMpixjFpAYhfFsMUsZpEKkZIJGMPQ6FQ2SguaFSKlIJyDhS9cUD8YYkaR8HBJjfELXEACCECAQ/dcgQkf3AATucCEx1xQtySX4AUXuM0J4gCGDVzAAV24OAfm1SEfb850C3BB/q5gAc04IIJG1gAZqYmJQCgGVSc4lWYMKwAdhMH/AbLKQRliZ4YNwE5WBdABGNDAq82gagOGBewCwACIFlChBQ9Iwx0C8QZl4qE5eDjPGz4bHWVSLw7XIYR2rncuM/BBEHYgQyAS8S8ldEG2OqBDEs7gLyIMYAhg8EAJFqQC/cH6cRQQvAxkIAQZZIhiBUyABHDdQAn8xlfvZBVtZjUGkTUCFcNmScrM2whE9AEOym52eweq+mmzKEaRuHYoUkGkTYwiFbFAMDN20YaDd2IXpaCFK1jRik7wYqPG8AUvdFELXETtFjSjcEDhMIeW7nvCM1XEzXRRUmIQPBJAcELC9/AINiCGDZ6gBRqSgIczRDAFL+BCGsAAOKme4AIG/zirBjjAh0dsoQWJbIB/0YDCiaAuGIJAAYwcWIAP6AIzIIJHQANLKYDYIaV5qgsH2AwByAvNYAA84IMFuIENMAAW4LIFqILAkCrOOboz67ITsABQkZUBKAMPlIM5SA478Ky5kovkuJazAwQz8ILysQ7r6CNaEjs3WKYzCIPKGo66U78qMAMdsAAwKAIhYCoZMIFTO6ADwgAZ8AATkAEuYDwFOLUEqICKEQACSIBXeZU0NCXSUJUAMICQaYMLAj1VQBEjUQSJULYxAKHUezbWo4iCQKhty7bZ04RNQAVWiIVbMAZosAUQWASOwIVaaIVRGIWFAAZj2IVaqAVbgIVNsP8EWxiGXEAilmK2Oci3ffMDleo3joiEXOC+X9iFTQC/PMCCGfiBGaABFmCBJGgeQQgEZ6qjaAqENLiUe0EBDYiQFHCAF3CFXMCDDLAAavyAIXssC/CxM7gDSXKADziBM3gECfqAeRqyBcADOaAdFNgdA2AAnNsdXJmqBjiBAWDBAXi6O7PHGOyVAXBBA7izYrFHA5ADr5MDHNwDWuIDOhiOg+we6jADZdqW6PiOZVKm5KglW8qtLliOnusCL8iBLfACflEQE1CACyiBEYg8yau8AkgBDBCCKeACFZCANASNyHMVXzENU3KVV/EMOSSDOWgDTsinlegnSjASRPADZVv/g4FYgzZwNpVivRjpCLAhkkxwqKsEhVRgRHjbBSCQhErQg1yohVu4BVjohFLYhTIZhmHgBV7ohV7AhbaMKfQCIaicPn0jijz4A67hnkZwRGKoil1QBfBrSi3Qgh3ggxswqk9DixNIgsAYFA8AHgu4A3XkqhSozC6ggyMAHBYoA8GiFxYYoxs4gbpAAePKATNgAcBoAIYsI3pMOgfwABg4Hcp6BB2owEliAZYTHtlZAAV8LNRoACj4AH5kJSVUjDNjgR5wreiwA/CgJa8rAzTwwOcQlziwAuionu5ArUITR0HAg4jMgRbogjIgBPk4AzAggi5AMjvCAMlLw4phQ/lU/wACYAAJqIAK8BWfNI2fBNAAaMM4BIAFoKA8SAXwIrZM0EMuWQM1IIMxABGoZKmVUqk/oClHaARJeApKuEpKsARLcKgV4gUQy4M1sAMt8IVh6IWEqIVdmBoQM4a2BAZh6AVeiAUKAyFma7ZV3LeJOApG4AhaIJPBLBsTWwMa2AEzYAQvaAEX+B+4SAM2OIE+EpQO0ACG6QCm8gAwwDm7gaoG0IAwGKcuSIJAwAMd2LuyGpghY4FHIRY3YITEWABB+Q0wDSzOFBUXdAAwSAJc2YAyIBYf04AqEEEiwARHwKvUaAAvGIvTXCacuINaSq3odANneh46+Cw3sA7UypboKP+f5xAEXwKPheSDbOkOPHqDsuiCKqiCTOsAC5DPnGSANkyA1RGA+4w80hANzwCAn4zDAO2M0gCAX/0AMlApVwgv8AKFS2iEmZCINRCDaZXQp6RQluJLL3EEpKSEbiUSIgFREeUEUECFB1uGGlobWpiKXhAGIloGYqiFSYAESDiEeT0i9GqZ01u2vLSwJRoEERqEGUGEVShSYNiFW8gDMVgDLeCBH/AETwiDK4iBJayTO7CBE7iCK9hSDljC98uBV5MDDgCcRAqczakLDijINLBNeqkjwrEADvgpIjCVE7CBDSiVUSoAYumAulCMHPiA+pNZYmmAvLkXOoikRPCER3j/ACmIq0SgRhbsGGKJA0+YgwdgSO3JLDMwAzZgAzwQxlO9jjrgnl/ygrObjkQ4uzjwujdgAzSwghw4g0QIAzBIg0CpgjNQghNwLPmsVTX0SVwb1lUpAQkIgGIN0F+FlcBV3FUJjc7oATYgiFbAIPDaBIhABEOIqTEQAyxwgjEYiLuMyj7wkg3t1tI13UiYBEu4Nk7ohFo4hmXYhCUBgVIIhgGLmlrYBKFog4BSg7tcrxbRV2VTRX3zV4AV2FAYBsE0WFz4A4UlAxaYAUbABB3IAReIgRaglyQAzTkDngvQgTQogcQJ2UD6kwPaHcJ5nDrCA9tcAA74C8Jp37gQBDex/ysLqFnBIpYJ5JyyMoA9OIIbuK2nsyQHkIM84gAEsQBCYAU3+AArmIM9IEFJOroBwF4LeAQ7sFo6mAOtVcU50FSDpINKDYRHYARAKK06sAIzWKYSjoMtiI8zIA4vYJ/jUI//yIG6AYMrQIF26skBXRWerADQKFxgBVBVicMBlc/dcGA1WATJzadR2IQOQgQ+3Fwx6NxlA12W+gOE6tAO9VYiQV3V3QRQ6ARZeF1dWIRPuIVfkAVZ6AR6VSkQUoMHTS/1+t2WUbY87tGWchFXxL5DyIS2HMxcWASzGQMokAIWkILrdQFOiSAN+IAb8AIWeIAIagwjuwA76pSXFSQP0P+BFOiA+hC17uUqeXIADZCDbYokYgGcFkCDPKIANrqrQHg6A8gAFrABFsCELdgAIigAF5SdUjkzB5CCBjgAN/mALeiBcTy6AtiARGiBD2iCMQg7JLSD8uADRlBF8CAEtEkEPEDbz+qC1KqDzzKDROC0O4gDIgiDVUqeLYgfFyiCj3UBFfCAF8hCBDqg0EhDV6mAWzWBlPQMnSziwPUV0iiAByoWOeS8NYgEFxq2UcgEFZniD1KDKtaCam22ZguhGNlQDgVp0y1dMa69V1iG/3oaV5gEoYA2C5XKfD09ltro06NplzGKJ8JcRaAEXwAGYACiXLAEMTjRLeKBJPCPebH/ATyAMb3TAl5kA7R6Pw7QAVZhgCLANQgBgzzyAFKTIzxAnxwgI8igAAtYjwWgFzEbAmK5GBh4oz21gQ9ggww4gjlgAQP4Zmd2A0jBR0k6gBY4M7uSFTvgpF52JQc4Ay/AqwYQBOO4WjvYA/NwuznAA0Lggz3oHmGMA9dyAzn4ZmcRO/XjjxhQW+YBgyoAkLq7UhV4ARUwgQtQoFuFQ1hJgMGtgCVTgP6kDYI+JdmQbdLAlfIslmPVgzbIhFUIr1JAEdLD3D54UIyWULxMvWr76JAWaW/FSocq112YhU04oolwaWzF1o2+y/Eeb/YC2CeyiNfj6Z5WPk5QgzyAgy16/xsdYOsksIFEyLu0wQI/cAVHIAMXvABnjDx3TIHHAaQrUCSmihAOcUEOSQMIioGnG9kr2Jxb1UapChU3eYAHYAMnfYNIhrFAuKUBsIEbgB082AJ75IwBeIBOksMcmBXW+vAbKJU78Do6uGavzSw7EIQ9EAQ2AI9EIAQkFMaxaMg3OOw4aGcXfuUyQA4YtvFEUAIXWDwZsJAOkDxcU8M1NEOLmZg1zEmeJAB2yjWLkQHJI4ABuAAU2IDNaQE2oD5OMG6WgGJLiIjlbu5pFYPPBUTRzT6wAWnq7tanuEoh2QRRFAo8DhHwZnSYJu9HN++iGIS+hJGekBpgeEtXSK/4xv+EG5ACfWkB0aGDRyiDLrjvXED1R9AAxmgq16aARgGrCwhZF8g6NGKADkgBuykcDqHMDiBTOSg5fKEAAqCAQJWDaD6BRHAEu9oAFtAAr37BCbxYSwJIGxA0FlyADGiAObPHskKlz/mc5nADG9cePiiPHhcEt8MDHteWORBPhvRAPiiDNxAE1lqtuWI/u0MOwrgDQPoPGegAiYE8NWSM+CSABmK8C8A1LX+VXNvyimGVBHAYzEM5ZAEcHpgDNegDTkjQYRNFkLgI5lYvzSUDEOFRPi4Em2kEQA/0SKjub72EEI0ElobvEGr0mw+o8j49EGov+BohmhKTnr5RWjjRNRj/BDboAUfgAzBogZ+yATkghCTgAVfwBV+4BataAGC5gw64VVLanclJg7o7AwbQkATgAkLQAAThkEyjADYngiRoABcIBCVwAFa5gCR4BDpgTEF4hLfWRrhQglAxABFkTkf9ABiQAzdPQRxokzIISHoEnaJDD7F7rcxyA/Fcu7Sr7D2YAy+Yg0hDQkLAg7OzpfhojhbYgj1LnipYLfessWAJ8Jc8IIzBgBUYAQJ4oBKQgYWZfVbZ8oRGIMljAAK6gOnSTBdgpQ3YACjQAzE4hIX6ESiehKupCOaWUM9dNiwWGayhqZX/aDABEw4VaZgX0elPqZgG7+8Gb47eXTy+S9Vj/6KKEAmx+YVg+Gn0ilAy4IEtuAMwQlooAAgbWvD0YPMoERsWLRgU6CAnB4MOFxws4GCRggMKCxg4uJDgwosOfFxYsJDxBAoYC7wwatGCYoIFMtN0KZnDxokWGk542EiRhZ0tBwaY8WTGwA07GRokYvQBqZuSLficWJDEDAsDBg7gofPmDh8+dtiYsVM2DiE0fAjNmWPHCxk3dsbOMSMXjZU3Z+i46fKG0J0yb7x4yZEkTJoiLiigkFFEBgYMEhXImAL5woUOMmSkkMwggQQKChJQ8NABw0cKElJ4KIGBgwwXLntsyDBmjZpGrFqpUlVqVKZIh/4U8pNnDZk1ype3gf+jhzgiRY0cSaouKVIkSZS2X7rEvfulTOIbDe/TB86aPOrXs9fjnj189W3m5zH/x08fP8QLFUJ0KNYwwAQDTC+6HCIGGVH0wAILOeDhBgtmHEHDBzexkMFSLBCxwAAcvOABBx5gpMEbHTBggEwaMcBRAhG5YJEFC2iggQNSPRKDATupaEEBC5hUlUsOOMDARgsUkIQgfODxwRaYeHHAA1oZ4AUhLDSABiM2IDXYAAXk9MFQfKDhhhxuxBGHGXbZYSYfceCxxxx4ELKmnISQMYcbZghCFh1nvPFGGGHgMVigdLSQRBI2wOCCCzo4qsQQi2IggWNCCFHCCRpwICkFBTD/wJgSLnSAQgocWABDVR7sBEMRMLi0ARUnfEAGGWJc4gpvvZUS3HDF5THffHDAUd9+iCzSCLLVbUeJdpSA92x3mWgi3iWLFNLHfMqZt20f6nHr3nvx/dqGt38Q58cg/PXnXyrDBDNgL75AIsYYZGihRRk65NDDG4m4wcYWF97LwgcLNGBAARfkEMYQLtToghwXYOTACWFktCJHHZzQgIwoClmSBZly4ALGFmjgAgyBlbSBBhYMsEAMFFzQwgY07JHIXBkMdcBWH0RpgQE2YPKIAw0YffDLD+h8hxtdmRGHG1ugaQcedaARB8527CGWnowIIlcic7DBxhx88BXYn1V4/2V2nmd0AakSXYQBBhhFKKFDDCmkUIIMSnCgwxAcxOCCCiVQIHMJLngwhBKlMtrCCTposACjKCRBBBFeHOHDfGp8spsqr7SSyiaRINKfIcapN4cefvjRnyLHWqfsst+JR620mmjCCSeamH5ttmRwO/y2foQrLnv2Facff4iczskwwgz4yy+WAGGvFlBsEUYLNlBZdpUZ7EELK5jksMHBFoDhCh4OuJDICRZcEUhNIVtAAQMcMODBRDk40ALJ7mcACxBiQxyYSAw0QAEdJIIQj3iEFyxgAx4ZoAFpcIEBiBAHFswhe1p4gBcglIEHMMIOH7BAEvySCDMsQCtJaEABBv8wgAyw4A1oCAQd+GAXsdhBSYFIE9SS9DU8CAITfNgDIQRhB0I4ghD/YsMb2OCVMqDhDnLQCx3QUIUUMq4LVxgCCobgKA6kBGUuYFwYrlC5C6DABSjQyBs3FpEc0GwDNbKAB1iQBCt4YQZLwIIY1KAJUqAidKPbBCQOoa5umed1zotdI2ZHu9pRwhLhuR0mN8E7TmSiEaf7Q7fqQ7zhGe94ooyPfVw3iGL5xxK86AUwpPcLUogBOVKg0AlygolbkMEOibjQDR74CBicsEYnIIQNFrABRmyBAS7wgg7q2IFEnKFlLbTABizQgjCgKEYNyEEOtLKAKlShRlvoVx3iQIT/DHzgBkTQSvwWQMNgxuFgC7BCHKxgNEd4wgsvY9kADTCABvCgATZ4ABRuwAI+3GEvdXDDEQUhCELEoQ5m2IIb5vCItUhUEA2cAyHwMIdECAJPXYmiYNxgwzeYwQtmqMIWtsDFK3RBB10Qo6N00IFNgfMESmgVTxiVg1Y5wDSZ0oAOkoCCDZygAx6gSAu2QJgeLAEIQGgDJ1LBG1i0YhSXgITzCpG61/HHEIqQDnWWNbvaPQuTlsjkJqT1O1B6K5SNHF648IO89TTSdX0w17pc2YtevGsYsmgDvcjAAhu44AQ38AIfbsCGRNwgAyFjgQU+8IEGxI9inLWB0TqgEZCd/6ChJJmIMjeQhGLaT5k1QlEXzlBBCzSgBx+g4QMI6AozFGCARnvAB/iQlQYMYAuP+K0NBGGDLr2shTI8wAFGyIIHZYAOgvCKW+ygUSLyIRBrMgMfHoEHri0xoyF1gxuaINU5/Mkrf0IDGvBwBy1ehZpEuMEWquCXMtzAAzkAnBKUkLkk3AAFOYFBFSCXAyJsoMGZ0mYLWJATp9I2B1bQAhlAoAUnOOEPpwBFb2Cxik1MAqzGWsQjY3esSE5Sks2qnSWjJZ5N0JgTm/jqJ81TH3D5dVvg0gPydMxXwLoOsGJFRCRyMdh3CeMWeRhDvRbrAi1l4AgPYAEbbgC5DXyABf9eSEIONKsBs+XgDWBAgR4xewLMoqEOJpHDOytYow3IhKk9KlqD8djcKG3gBla4chxc4Qp9buCiPruQVlwKvwY8gAYsOAAMLVCGE2wFugewgxQMwAMvPOC6XXHDHkq6prm06Wla2wOo5TIWNoR6D9qllRmi+AY6XPEMd7iDGc7ghizSwQxlgGkLiFCFHEQODEO4ghJQsEVEcQ8GOegCzSyXgxgQmwMbIFgOEIwyGDwWLnMwAhDWgIhGoAIVsXgFV0mM4kNEwpPRWYQjHIGs7Lx4rduJMXhu91Yaa9LGwVmEIgvxh/qgaxAGx8/yXMfj15GVP9wy17lcV1ZDFGIRtxj/rDAyzos8IIgNO7DBDUiSgS3YwAZ7MFSEN/AGJyUiCSUJwxuSsKgwyyEQtLVABhpMAQucAQxnWGf87IiiO6hkATmogg6qoAA654ARRNAmhq49KxwY4Jie+NoDuJyBQDyCCHVowAFsYIaRdw/OYO/yAaRghqEM4ACMSAQd5uIGQrClh3hgA0TJwgdGzNorW2CDIPZghrHZJU1kY8MSA/EGOXnFDPA9ZyLesAWFwuCiZzhDFbTYhV9v8Qz/FTbeUABOV+0kqji4gWFaQO0qWCFNZNjBGNTQhki0AhWwQHdXgwOJSFDCk4cwFrIWITvuWOI7l4ixJZL/VkxyAhWtiEUs/wTNCk9cQhKNQLFYFcEIRpz1rIb4viEGocr84Gdbohwlfl73/f7MAuOyPBAZPN4DOihBCjcAeRKGDXIbfKAFLk1CCzCaA3wACqAAB3zMZt1BFWSTSVREF9wB5OCAhPkIZ7WAVuyFslVBHSTYFuRABlgBDnjBHkCBHZxAbZzQZNEGFRDGteGBJ3zdFiTCB8TABkTVBhgAQj2CFhhBJezBAwyAAcBdD7EBHyQCnCSJq2UU3vHBv/DB15SBkugQGSQhWRxB1GwBHniBYCRCIITBDZxAFQQCQyWBCSaBG+yFOqEBIFSBFrIUEZxADIDegrkEzVCOvjxIDyAdSiQBS43JHP/QihqIQSbY3izAAlehwiZYwiSEByWsGLK42yI0S/FBy/FdUr+BAihwwimwwiqkQiqUQih8giY0osDpWCMBmXuU33sIS33EB7nUVfGkX1n5Ryy8kjAYgzAMQySogXL4wPx1QXjhhBkEgkJpgAF8wAnwAFZkUwM4gAagwAWYBI+QyCNUgfycQQpwwcQMgAVgQiCczwl4QQu1kAaAYzptAW21ADJuQQtogQ3EAYY8wNgdAAvEgQk2QAuYQQOwwEGgjxHGAW19QG8dAAg8AiawgRHMgKXdXVgQAiYwwh6QzVoc4XXxQRmMFx2UQdNM1Jp4gRWYhRncQF00DRXRQUZWAd3/yNQWEEEX5IAFVEEYlAEhAIIOgIEcwGQXIEoVwIC+wEAMRI6roMoG6EsLnIEZJIEXEIGCvYHVoIEdkIEetIETgEIrwEIhykJXxZUlfUL1MUt1eFLsYAfvLQsl3k6/bRJahgIpkAJXNgLFFZnr4AePhRKQsYewDMt60Me23EdcSpxYFcIq8IKAGAMxGMMutsEaMEEPJMGURY0gkBwKdMFTANcHPMKecNlSucAFlEAKyMQJdMGixM0deAhmEIkFtB7I2JGPgBlFrEyMWAAHnJAc3IEBMEgDbIGVjdCVEMICOMAGBMIZLED3GCML0AEYbAA3Ig0IYIIn/NIIPcABsIEU/yiJdinRqe3B1gQCzjDUG8hBEuUdeNnBEWhBqJnFHGzBS23BmLAAOREBGsTU5vFFTKonHwACfHZBHJRBEsQUTL2hfxJbThCBDriAYbQeGuQa5oSBWLgFG+BGHoyCIV5lK4QC74gHKXQls/Se8DVCu/HeJXjoJWFSJvAbv3HCWp7oJ1CfJCjC8uSHjymcefyYerBikEHctaQSuggcKvzCYBqDMaSC7MHBD0iBDuTSCOHBFmxABzTWCXXZAxFCIHjCHcjcCUgARKSAkDgAT+qEiXTAC5CRC2hACxBCFbSQAxRAygRgAxJbb7aMBbCAvzxAA+RcwOSWQkDga2ZTC7VADv+wQH610wO5AQg8wBg8QiXUAAiwAHTOhR0Agpo4ZZvNQR0gUSBsQR0gXpIkQhORQeCRzR0EgiAQkUydwaDAVxfQwbDF2pxo10WFAUyWgRf4hRdsAaxKDRVYweTlAOq1wA0kAVOpXk7EwBacAVKagRW0nlzgCRQ4ARD0QSe8gizUgiGuAilkAu9swoXWjvU9oiRhR7OEqHjozu5kolqeKCiwZfWxKF31Jbu2a1z2AZClH7zm6Po1Uvad1SFwgi8MwzAkwzIYQyzIhw98gAOESAtwgAbcFx7gQaa4pAcgSguoDRyeQJYaQAz0RBIwJx6YjJDkkgfEgJU4CLX5SMjQSMH/agTHoIgyCecdbIFMAI1M+MgCoICwTkkPQMEEGUALwKocSAEeJMIjeAImkAGU/AAIoBoI1AAgpBNIxoEXAIJ3ucHTLq1dSCQhAG0i6EEiJIK93MGemOQWlIkcvKccXFFXCAohoKcbWAEVHMYbdMGsupSwtVkcYFR+lYENEEGuglMHbgAK8OmC2UAPEAHeGR4ZMIEPAMEhlAK0SquIkcLu2BgrcAJ4MMv1PSK9eStbYVLk8k4opMJansIoYOInZIIkWAso9UEhiF9cGtzqsm5fGpzswq5ZmZX3FUL3nZUnZcK+EsMy/OstYAscQEEzhsgL5IRMmYES7JRmpoQdrRkc/+aARpxACRCJA7CAJ9ACHRgNwu7EisypCZ7AFpAEjVgAAzAQiNTInNFWb1ZFNvUW/CZAARydAdQBI/BAC0CaZWlTl32AFwitFtDAlc1AIlQCCGQAIMwFIMTB1dRBIDhto9YBYXiXHXSU1orNHmyUF2QRv7zBRaKnfnaBHBDGromhR7oBEbReDzgeFW0PeklNHVjBTuatTIUBmOWATBJoCyCYYSwY4YoNG9iLD8wAEEDCK0CrLMgCLIAuJ2RiVmlCd6jVvFkHJVWSJY4oWnLCKPzGKHRxuXJCIyKCuTRcXKqLu6bL+h0cunzfWTGCI5xOdJyVsSCZLgCD7/6rLuSB7P/9gDW9QEhoygkcG2aY78howG16AcWCQRccTglIwKdwwEFsjCFzVqacaQ6gY05cQTR2wMymwSM0ygEywCaHAfoswAdoQI94XgzFbAtZQSJsgS9tVgtVUJ01kJw2AOA5giuwQQY4JdSm05ks7ZlY1DB7QQ8RwhhcbVzYgSPsCaCwwaCc01WgwRmEARqEAV9k0RF8pB3UgR1YwQZ4ARqk0H6eQUx5AZIaxhZsHpgdKAwgJQwMAcihweZtAa76kqvZyw6AABBkgiEmsRKvJSeEQhdTLltVMSVGy+6UaBODQhf/RigQdESbwieEMSj5pbrwB0YnXLrAbuxqn/adDhtzH4r/QUIdC8PvGoMv/IHsLcEElWMKnIBFtMAbPMIdMIAGrEjMUQwZUuwVJEIMgIYFXIABcMAA9cANmATCClADlAQ5KYEHeEAYmK8FKIHMaERvLkAH1EFO3DBtdWABxAiRGI0FHIEZYAItnNAsg0wBGM1mMRoUkMFBPEBF1QEwB/PSuhQg4EwcvIEbCAJc6AES4cwcCAavecFEoRcj0EFaVPMduFQY2IFBzoEgPHDrfZkNXLJUXZTUwlSiHEYX4AEaBNsN6IthwJySEEKaOGFJrQENgIAYcAISK3ErgMInaBIoUKh3ZGjlGl8mtFXnpuUplNsqlNspfNhaasLpFod5ZLRz/zu3fhScR/el7ToC9+Vu7BzCIdxCLP3uMvDCIoiBGETBB2zA3egNB+yUDjyEU0WjEtSh/XRAGlyBaVyAKPdmYzUdIXzAEIDBBehAUpfECVyBMybAG8UEB/gIaNTIiiS4BqyWTNKWQIW1RrBhlHzA1jbA5BiMMnlTWJvBZuHAUnxADdy1G9g1IABCEgGCF9SBINQBFeQAG2gBRu2B1u5JG+qaSdIB3r1BIOBBICAlZPmaHBTR25kBHhwlfgVKroUBYWhRrH1Z/gHglN/EFYCBGXRBFZjBHSSCBFdw2AQxEIBAG4wCEs8CVtq2tWrSh/LeJJGljIkH7+R2KNB5nY9CKv90Yiu0wir0uSdCbu+95X48d1iZMboUHLuKn+sqgiNon3Wf1bFo9yx09zI8wzBcgni7I63xDweURoiwRgxsrQfYDzbR1uAQyackDMVEngMMgRswJgp4QFK5qQMMlQXIbwHERAyJsiPjTwthRI9sQCIAjVKiCAPkQCJgAsnNUAbobAvMrEvqKcckwjrdgJxmQJ6YgTfHQTczKrfXASC8uJLcXQ+1VF2MzRnAqq9JnhtsbUjZcBjIgU13wdxtQVhIbUxJVQqvoLGCBa36mpCr5BZdchmY5KwSAR+myRyE2h+OwZj3ge0lcS2kOShgUiRsaCRlqLKAR+R+womuZbmqZZ7/s8Io9HkruAIrpELKQ7EkiDTqPDfFwfx0t+7rMrobV4J1MwKHajcs2PHvWjoncNgPbAEdJIGmSIxFSIYbHYRN5UDPJXhvinUBOHIKvAADxIAD5MgJnM83tQBtacBEqI8H5HoCTEoCyG8JnH2LHA7WU0QBLFYGhCo52kAZYALOYMgRtJCBPVCNeH3WV52PVFATaMGZQI0ZpLgDM7B2Fr4TlgHgCUJZCF7UhNCrozMRhtSgZPnivUE4Xo3hb/ZFIWsPvKd6vi01dyFMwWoXxFQSoEEZdIHrY95KUkFGwYkd1IsTgMAfsEIsFOItxMIqfELFV+LprpiLOUt36I6JmgIp/0Q0Kdg5KawCypd8K7ACJ3piKkAxJZwOi2K3IiBCzD+3IoyVKq3uGn+fG7uxJMSbIxyLsawCv/78MLgCs/oAGeQWSmgA/6hGBRRgTXUAQFy5k+gOBQtXHFywwCCBDCUMGBiQ6ICDBQsNLOQ4YUBDBwsUHEgoIiFBggslE0hgoKAkBw4LFDZYoOEBH0FSEmkw0CDJiSSeGH34YCaHhQUnWMBY0KBBIEIOcrRokGFLiwMZ3KBBY6YOIDuAEtmJY6eOlTpx4rihg0cQHzxv3Zx5QyfRmSRn5LCVwuYt2zlzzBxhI+hNGDNbbvCR48VNFStu3HhBozZMly5yCHkhkiRJlf8qSSpvuXJli+E3cbZ4MUPIph4yc/SooUSLdqxbtGK5csXqEydSkiQ5ckTpUvHixC9pUs6J0ydSz0mxcpWKenXduXXvNqXpUiVHisArYhQ+vCHwhgwNSl8o/SD36guxR28e/HdFjipVAk6pkathw3z5zxdW1phhBihO2KCFFt7IwYMLJJAhBw5iOEEDDSjwQAMHOkDBgSuUWCABFWTogAKTGEChiAs0sGADQgKRygEHFoCoJJVMSoCAkhTY8YILZrRIg0TesIGPDBLBwwEDBtiJj0fMYMGOQLYowKsGHMASD0+S2CIRN2Bw5BE3MohDsjgAiSyOrgg5y6s16XjDLTr/6HDLDTPUwsMLL86goy0vtqBTkLbsmIMNL+x44w40utiCj8bkkGNNRPHE443P0KADjSRYAK0KQJMAowzOcrjLCyvMSGQPPvSYYQwt1HCij0L+OKTWP3DtI4882oBDjTbayKMPXP8Q9o9C+ugDkUMOWWQRZpc9Nj5aiWWW2mR1XUOMbZ3odlsx1FCDWzHWWCNWINAFYoYdgPABXSeWcCJdb7cNV1xvww0W2D/aUKPdGnz4ACkNiIhhCBkuSMGFDmi8kEYLCiigIgeMUuAFLjj4MYULFrCAohN8quKDDWt0gCGWEkjhigRQVoAkiBygQIMFOMDkkak+0EGJGSViigU2/zLI4NQNTjCjhQ8aUJAOjfBI5AYWtDgCq666MtOMr+wQBE070IjjjS3YeIONMt5otAs03piLj6+T6KIML9JO5FG3+Hh0izsIcSOOKuIAwww6N8VjCzPKOOOzt+3SoYrTwEhCiS7CeLwzM8wYiw879iCDiUQSUQ+R+D631Y9p/Th29Pnuk6QR4IC7xJVLEJHEOOMaqd2RRhRxlvVGPh9dETjEGAOOPfSAYw0yxhhj2zHW0MOPQfQYgwwygm/CBxoM9KGJJbDAQgvpySgXDj304NXePvqFo19ge52DjKjdgIIHHmy44Q4NMcjQgRYhYqCAo2ZWAAZcQAEpwEAJHlQCmP/9yCAgo0MSjLKkAqSEASkAQ/5YooAB8qwAGsDIHQRBI5AVwAIuOEMDenaABzzgABjJwBi2YAekGWABBnDACfBQJ0I8IANnqcOUfAiIQATih4Aww2TYsBY6lGFtZ4CcGQwXhkVVIQdlGFsS8QAYQRRqDls4A2Pc8AY04CEMaXtDEnIQBioc0QucOcMZzNAFzZytC0m4AhjScIYyuKEMg7ODHfiwBzuQz31r6JWw/NAHP+xKWLwypBoMCYc8+ME8izDEtPqgiPgY4g/DmpZ8CpFIRcbHD4uMFRbg1S0siAEL8VpCvOQFBCesIZWydMIPnmAEIyxhl0bwwS5fuYQmNKH/e93qVrrQtQN2yXJb6IKCD2bwgR7wwAyPOMIGiHACGKCgCnewAIYgcgGJvWQBBXCZBEhSgjuMhAEuicGDNrABC3gBBhwYwAJqeJIbuexGJ3CBxxwggAVQTCYwOINRdOKCRwRiAQ+wgRtosMIHsOADhBgECx5wkQUEYAAOuEEVevAIFmSgTV2xAyEE4RU7JEKIY6GcHd5CCDoEAg9beUOf5sIaQdwhTmnDQ6HMgCg+aEELZehCGtKANkBYSg5fC8NntiDHwQXVM50hAhi6gNU3yMFwW6AiEaxwBEHsYQ9z2MMgElHK57EHPIwQznjGYwjYOG8QjMhPJTChH/zkBz+Y/8CEJjyhCb/m9TuhVCshyfAEYY6BDXMYH1nnsIZXfW8Nc3CE++AQWeRJjw1u+IsbXjMH0E6vs8drA/l89SvlJa+ydG2PIMiwgxlogRFaEMoHNoCCITwCEB6ASQpyYBIamcwDE4SIAkrwI5dRQAgoOIEOUHCDDRGBhjRiAAUYIIEOMIAABTDAwgrAsJdowAUyWcpFOEAHClAgEIlgwQF44AhCjNQL7mWDJ6TwgCYFAAAAKIBMehCHG2wAEHUwsBW+cpY2rfSPcSDDHtgiCMjg4Q5VvIMYdZgktdCJDlnbgxfmwIc5PPAKkdOKV6uAhjKE4ak5gMFdtuCGMHSpM2g4A/8adDCay4BhCznwcTxZIAUDgWAH0JStMmfwyxmAYAbYM9CTn7wDJ4TPXJBEHhAkC6zktcGx5Tqe8ozZhB8I0wcsYPKSQcBkJ6f5yWmuQZrhHGcQBA0EZq6zndPMAjSjmclwzkCcl8zDDLDwKjP4wQ8yIBQLeMABXQhEDDjwAg6koQgZ8xiPEsAQkqgEAxMsgcxgkCAN4JaGETPAiRQwQQ90oEUXuAKGTlDDi1iAhhCbmA7qcAILmGGwH8gAFA6jBVo8goVM6q8A/neCOtigTGMBxJrqQAhAFLgrj6iDGf7CCEa4IVB8sLGlvMCHRPyNDz11Axsaezm+/DQ1abuDHO7/oDhFbaUMlCMbHaIahj16AQxxyKMHYqCEGNAhj1tIgg0wwgIagOABTH7ADFY456AR+gAqlCgLV/hnNGdgBkCQLQ180Moa1GAHTZjeoX+gS9nG+eJMaUDGMy7xiwftKgyvuESZ8oCcD3rig375xTGO8YofYABFp8Ea4IA8NpAhzn/+QAtYsAAPYUgDF+CAB1JAAQ7MKAERE2COLoCBDpQEJBmySBnwUEMDFMDqZ5CB/wqgEovkgBAowBIMQIJPfELEAigAyQaWYgdX0MITP2AhCxKhB0x4ogdWKAOTAlAABxRAQThwUyCmTRZAtMkNgHhEItLihqwlcY85FASdyt3U6fbKgdt44OP0uO0WdL8hDXjDQxr6LYc6vAGKhTNDGPwkRjiGIQ5oAFEOhmAZgqemKk+HeMPnnGahV3wAQ7f4Cq/f8CbToAZPRlcr0dx9GvzgejRYM8t1PvT0Yx/oQB+00DPeAIvLf/4tzLlEb459FYKA6EUHgcd9gAd2YAn6bMnMjCo8YL0oJiEyhgE8QAcGqus0TQIw4ALW60dUYr0gzQK2gBEupAFg4A4uAAy44GWwC/C0qYZiIBGKAKAiggE6AAxygAK8ywKogAUEgRCggOcM4APIAA6MIAOoIBFibQAiZr02ABNcISAAACH5BABkAAAALAAAAABAAQABh+Guf8idfcGVdLmTd7yOariNbbaNbbSMbbCMcbyIWbWJaLOIaLGJabKGZa+Iaq+HZauHbLiCT7KEYLCDZK+CX62FZq2CY62CX62AXqqEZ6qCYqqBY6qBYKiCZKSBZ7d9SrN9Sq1+Wap+Xap8Wqh+X6h9Xqh9Wqh6W6h6VqV+YqV9XaR8X6V9W6V7WqR6W6R3WqV5VqR3VaF+Y6B8YaB7YaF8XaB6XKB5XqF5WZ93XaF4V557YJ55Xp14XJx5XZx3XJl4XaR1UqF1VZ91WaB0U551W510XZ10VJt1W5xzW5x0VJp1XJp1Wpd1XJl0W5ZzW5h0WZdzWZhzVZ9yT5tyWJpxV5pxUJdyWJZyWZVxWJdxVJ1vTJlwUZdvUJVvUZtrRZZsTJVrTJNzWZNxVpNvVJJtUpNtTZJrTZJqS5FpTJJqSZFoSI1vV4xrUo1qTodpUo5oS45nR4hnT45mSIxlR4pmS4pjSI1kQ4tjRIljQ4lgQYVkToZjSIVgRoZfQIFjTIFgSHxgS4ZdP4JcP35dRX5aPntcRXpZQXZaRXZYQnxWOnZWP3JVQXNVPHVSOXBSPHJPNXFLLmtSP2tPO2pOOmpMOWtMM2VMOmlJMmZJNWRINV9IN2ZELGFEMF9EMV9BLlxCMFxALlhBMl4+Kls+LVo+LFk+LVk8LFg9LVg8K1Q9LVk7KFY6KVU6KVI6KVQ3JlA3JlE0IEs3KUszJEsxIUUxIkYuH0QqGT4sHj0oGUAlFDwlFDokFDUkFjUgEjAgEzQdDS4dECscDy0ZCy0VBSYZDSUXCyUVCSUSBCAWCh8UCh0TCRwRBx4PBBoPBRcOBhIOBhgLAhcGABEKAxEEAA4KBA4JBA4IAg4EAQsLBAsKBQwJAgsIAwsIAAsHAwsEAAoLAwoKAgoJBQkJAQkIAwgJAQcIAAoHAQgHAgYHAAkGAgkGAAgFAQYFAQYGAAQFAAkEAAcEAQUEAAQDAQgAAAYBAQUBAQQAAAIDAAICAAIBAAABAAMAAAEAAgEAAAAAAAj/AI0ZK9Zs2UCBCAcK+1VsmC9gt5rIKsZsWTNlzpwtc4ZxmcdlymTJMiZs2LBixZIJK1bSZDFl0Z49Y6asGa5LmjRl0oTJEqZKl4J5fAYt2jSPzCoqU7bRWdKkSD+CRPmrl9Wrua5araqVay9fWsOK9Xr1l9leVRmaNUvRWTNm0bBRi4bM1SRGixAhYnRJUi946rwtWylMWTBhiFEqZgk2LK9dkHk9hky5smTKkjNH1lwZsi5dnjvvAl358+fRn4H5ysWLlK5ViQIZOnSIkW1bvn4F++Wrty+TwIcdA24VsXGzC3ULSzawWLRiCQWyFBbM2DBgwHYhCkRxWbK3GZlW//zIrJco4y5JtnSZbGbSmr024cyUCZN9oLiYPps2jRpSqMswk5FTTwUI0lLKDBSMVrlkJdaDEEaI1lZrVWicMiylFM2G1PBHzzfSNOOKJIwkshdfl/xSjz31QJOMMsk4A91BNDKmFS+9ZMaZaDxuNpmOnp1m2pCjUUaakUJ+dktvvOSCyi6VIEIIIYsk8kgimtyCY29mBRPMMLxZlVsvC6J12HEVIgfdchgeg1BDw3gJHHawNIHLgQZuVGBFzygjCplyDmMcYiatJNMzHDWDjCjz1XefJCMpsx9/fMoU4KFOfcSUR5smUwxZXU2Ypm5r7Taqcogd9uWZiUGH0jGwRv/jXUrO8HfNNd7cQw820agiySO2MfKIJpcIQ8898PS5lIzGwJqQmwtmlmOOQPZorbVDZqutLg3mgm23vs0yyy2IGGIIlYsA20qTDW7VkqlodYkLoGf+gliFwUykkDMJoUTdbiUFgx0vf0jSzEvJfOQegR45I5KpXw7a0krMyMTMMc00M4smnehkHyaaSLLJSzJReujJmHIqHnnMeCoxYRIv5ipK0cmc4WIrudosQskwJ6sxPe9XTTXQcHNPPdhIo0pfwEoyCbHFHPuNshvR7KZAsH5KrY5cd1YtZd02WFnY3Ja97ZDdjh22Z7n4IpkqurAim7mLpDvJLcCEndWXZ23/Zeq8Xp6pKqlenpfzi9OlGuYvcVbliyhsVIdwxQJmlNQzAQazCVoPAeMldcAhhlE0zGTcDC+bdKI6J/Z1IsklvYwuDTVPXT6gTBohmDCBGf33X8vM9Yzg8DC+uFQyV7+5Ur+K8SwQjMVw5Gl70EzjzfX83JO0LJdM8ojTlWyyyTH01DP1UgLO+OwxwoDFdddig7ZjZ91qpvf9uYB2f9mo6Z3kQ7dohS4mIRtC0GYRjPgEL4ChCx2ZKXDUSVWDfBG4Ve3mMGupxURydrDArcUqgRMTLtiwieegb0CZopxTRIGLYDwkN12yYHUEVBNkEIMYoOCY6lrXl1okAy6zq13F/1BIE5wpo3LOQFRTktI7paCPeMTzCHOeRSNYualnWMxi8UhXvEldYxrWgMeupMG9TFRCEpTQhCc20YzyYcM7R2QGzXa2s/Z95X32a5D8JlOkHj0Gf4BcG2rQlr/PFPIzD5mFLWyxHUMEIhG1mUQsVHMkXuQmYvdqTC14EUNVedBehevFQoRxjE956YO9MEljcnSJNwxDeBWJRhOXMROn4EIVvPENDEmFnOYghk6e6MQnVKe6S1xCFceAi8l45xSnYIg6ajoiEVHIMJBIZXic8l0W3cRNKx4ji8Yr3hZp8sNoSGN21MAGPehBjWbIQieVoMQlOkEKUbSRHtewZkawaP8MGO2sTG7TkW/+6K1dXOY0gzwbt8im0IYeCWzdAgYvWrGLUASigIlIRCM0oQuJhg1HgjtLk3BRCzLppoIRzM0wyIQLWUSQlKfMpVVUyRVf2EIMshCeM2SZxIpdSiPG2FyYwNKYotrrqAIDhi2COUxi9mVkzTDKNCrHxAEtgyWCC0YxkolEao6HZU9hyqaQkpG3lC5jx0CGWpUBq+IZz5rXnEZBvtOMBbmtbexChep2okZUqCIu8JjGUjZy1XDCiK3CEBPXdPkjzSB0W3rUlh5Hk78igeaylu3jLvR2i85ChBW8kMRFzVWbR4RiYPWL12560SBc4MIWtcAFBU0VJwj/nlIWuBiGKkhZymaA6aRf+Upv4tUbRLzhh88wCjZQNhOe1qIWC2KNmHRJXV0CwxShaCpfLyGKX5gTG1OjpuVulhjEGCMaHZrUNE42jQ25971GkcY05Muf+cLXnPc15zn3e078SiMu/5VLr0DRFxRdYhOviIWCTYGKVLxCFtH4Bjvbi971JnenbnHLv1SDHez0RjW92UVAS7PQW+QvFyYOZIM6y+IUd3bFLWYxLlCcC1qg2LOx+MwjHrGIQ/wBEIFABCwi41rXZuUsRW5pLVTxQIhBK7q4AAIuSeqsZl1wN9StqS9cYSfS1QobFh4K7qTxCyZrpbpFpS4wXNFUYmpC/3y1+O7UEKVE6MmsvC8xyn72bDFEucV0G4oqT3cK34yVNdCCjkaiC61oRc+FGdRopyg2oYlKPAITO/lELGARi1m4IhWsgMUsmtGhQf+3maWrSDOOsRbrgthtIeYMkehXUPpZ6zI90p/YDPqYW3R0kqvYcUbNxYhKdFQ1vCYTcPo2Y1m4AoYejFh0c7GJAGwCF8BgcnDAdEHh+sZxq3mDwUa3XFrOhDzRSAaTq5IVNE+XS9ixRXY7wVd5bgKZUf1GEnvq1oQdNikkYUjFTgaVTSEIrtgUq4EOfjye9ewlUDzsEWHCkQ0hQz6VqFslKpEJT8ACFrSghStUwYpOIyOqb//JmKIbZjq0mqXDMI85rPH4voBKhrqWHGhmAspzieKaj7zQli1yXIlGLMJcsglEKRYIDGIEFBjDuKFDeuMtXUhiFjGt4FaR7AFrq8IXtRDFb77UuOF62+yrgVwwVE67AFUkKSiPhgavguYs6wbquyjFJ7RbiTeLYhj5RhkT3U5WZ3hKqxippUZAkjDv9NOtMxre88D5cMVUHpzNm54xirjTi3ePNpDYuCZeIWpYmEIVCY4FMaKKjLSefNUYU6uiWq9mEMucsYvtmkFt3tgdNTYySDLNY7S1CgX/4Q1taAMbnsCGN8Ci6U2nzEOkLlFd3GIXrZgEL1D6r3uVqQkQEB//3jZRC4cwburDpa4Ib8EGUTR6qlw03euj8Quxi+lUvumwl4gBjFd8YhR71XeagAq5EGC4gyhI9FUvkjHqsXnNpBEFEUfkoSkHEkXeQXnhRHnEIx0CURAYoyiXYGk9Bgk7lgmpkAqt0ApqRG+lQAxqBSs3pFYIMRzA4QtBIj9G4mtMslk+coMOtS0xxmK2QAtDGHIhJy6b9gqvMAp7NwqYwAiY8AhtMAZkIAZNIAZP0ASBwAiS0IVzc1F6EYZBZlypQAyCMyjNUkqkkgueMIDAMAub40ImcRa5xFhWUQu7cAlsgAzulRTIs2onp2gZowpZYUn4Z3c3dAujAICcUGmq/xMKskBq03A7fuZMNIJy6rFVLadWsncRgyU8zOFNbgIn23YSM5Mz/pIqFaQbwjEcagUMZuQIPeYIO/YId2Ebo3UId7MLrHViI5Vkr1ULswALrZAKqHCMfoUKDBYKodAKHwcLrhCNI6cKoiAKnnCNlEYsxrSNk9CF3tiFthGG4iiOwfKNlCAJJzIJhiAHhrAIhPAEYiAGQDCPQBAIoaAKqiALS+YKz6hIJtZZvFYo/pIhxsCArqJWbXgJS7IJsgAMrOhC3qZYONILeMh+EHYRAfcvsieIJMUlphJDH6Z/wXBDwNAJH2MJizAJmdAJqjAM5zQgGwKTGJlWUQUmXaFzTf+SI+7zNWBzC4v0k0A5hM81lLQgLs+ohK3ACqzQCkqoYK8Qcq9gCHsgB3JABnvwY4BwCFNiCG/wBnsAZCTChU4zCX3RhScijmO4HeMYhijyZpsACtUoCvgYjf04C8JYCz85Y94iUNXVYbNFdsBBkqoECsI0CoDwBFnoA/PYBJ5wQy7oW6U4ECeHEpoXHUCTcobhejtxCaDAC66wCbvQYVOXc0wiLTNmdYGgKF5CQdjBf6uwCqvnW7LQGxVUQTAXHCT5hJBkCH/wB4bACKGwC6wnirAiDALxL7uRC8I4C9RojeLznAe2jZdwjt/ICGh5UdgZCMf3BmzQnd75neDJBm3/8AY/ZgiJgEAq2QhsQAM84ARL0AZUuQdaOSVdeZWG8AnX6AmgwJSepgrROAtGGHJAGYS+piWOyYkImqAKuqAL6nqt13ppSJycGHW2IAmfYAmcsHxj4ARAsANiwAa24JgMGKG60zMeQRHCU6J0NaEuJIu2GHKbYAvV55fZMRq+Zn244S2wAAR4gzcSxUDAoAgUIABx0HQasySwIBKygI/4GJfQyZl9cVFvIAdscJWAYAiiZZ1duaXeyZ1vEAhfCoZ6oZ3ZiZ3i6DTbmBOaAAqgkJ+mYIwnqArOKGoAGpTeInUkyUCxMAqQQAh8IAdlQAZtsAd80AZ1MAiQEAmQAAmO/8A6kGAfh4AI6aIJHUYMJuGCjhmYjmmp1BdzxGB9+xVpojqqpFqqo4pOojo7/LWqqpqq/aUoq/AJlcAJnOAGblAGZTAGWRAIkkAM+pVOqCqq2DCst9If1CAN4CUX83VOGYMMwJAKiMAGOwAIhPAHgZAJYNp8bHmW21GmZvkGhnALkaAHihAJkcAJChYBEZAABAAJq9cLiHAJYimdzyk+cSkKzgYLkoB8yveVvnkJnuAKuaCPRtYtXxE4wyEwNhRzDLupDvuwEGtDEBuDzeqsq/AHHjAAAxAAHNuxHauxA4AAKUAGiuAIjYoJtGqyO/YJnqpWE/uyeUoMtwALxLBf+v/1XjaLs/8FX6vqXovms/nFrM2gC5XQCY3wCpBABreaBWTABn9wCXyITnIhrMOqTuv0DVOLrFkbadKADAMkAxsbAAPwB1e5B9vBF29wCfpYUvOSZLlgZMOBHbqgCEEAAl9wt0FwtxHwAetKAbEQVemUME/RDJbzFCh0rNKQC9qpfL0ZZDEaZyoXVYS2ITubMdmhVlEXdTC7uZnampz7mMTQCRDgsaT7sSArAB+bAydLq4lqCZYwCkMCpDUKhATaWbbQWbHACrfQDNJwDAfXMw7KoA0avC1XscULaM3qCZUAhVEJn07gAUsgBntACyESF9TATqNatVNbqvulKJ9qCTv/QLoZQLa9yQis4ArZJgoFSWpJhCd4MjvNQAyKMAUg8AF3e78gUL97GwJ+wIfXCyD/YTlEJBfSEAzaOaU/RgiBMAmzIAvHQDpQcTnrJUsZMwy4cR0NZH3ZUrtBWYRGqGBO+ZqrkHpKWMLFNwpNULoq7LEai7ofWweE0AeHYAc0LAdfCQiAsAc6PJXjOaVUSZXJF8RCLAfKJwZtIHouaIoy04ql2MRW1IrEaUUHmqCzRy6UkAirMAp7kHxZsARj8KG+0Gj6xao767POygu3sAqc8AiA0AZkcAMIILYcOwAksAJ8QAg5bAhKCAvUBmFx8Q3UkFzMxU7SQAxwsAX5e7d3/3C/XwACEZC/agAMyEoP75VcMTm5AwLIdMEIe1AHbmAHg9AHvwkKuIUMPVMgHkE6s0cLrUALleBI5tKbgEC2U/nDPzylyLelQpx84dnL3ikHYbvCIHu6Kyy2RuAGZGAERZAESVAFS4CYPLAEO8ADO0ADPsAD2PwDSIAES9DN3NzNS+AEURAFO9Chf9AJjEALyNDE7Ax17FyKlrptDOupwBBsj0QIkMCvZXCrzZdgdqmk1Sg+3UMiYvgGYuABEIDQCZ0BKbABBlAAA1AAAWAALjAEVMAHMEwIhtAJrGyXm/AL06BOywVfHpI0yDC/dhsL6KoI+PsBdrsFqyAN60Rh+f/1Xkm0Tv8FCn/AB2fgBWbQB4SQCKbgCg48aCgze9RGCqMgB4gpBmPgA+G8BNfMAz9wzTtw1Vid1Vk9A1zd1VwtAzJAAzOg1T6AAAAAAAFw1mldzCqs1hybAVmQBDlAA+y5BEYQzWHtAWCt12AtAykwA2JN14JN1zdQ2B4ABDLgA5bQCJPAsG5jSDf2k0UJC6/QCqjAptdILN0YjmN6Ub25paDdBsf3lYfABotwpfpcBllQBjKg0BDw2hCAAAgwzLRN27I92wNwABItABUwAAKwAVVQBUWgBTLQBlcqSa9wCbCgCpsAEzM9xu71IV27CnX7BTkWC5HAyCCwBV+gBrf/MMn1Zaz8Qbmruk7HOgs6XAZOwANAbQipcHrBcKzmlE5ce07EgAqkEJVY4ARYUNVcjc1iDdgz0NcEXuB7beB9PeCtXeBpfdYOjtZszbFq/eAAAAFJQAY8IAOAvQM/wOEe8OEfngEibuB83deDLQMdUAMyQAZN4KF7DeKwHeO3PeMzXts2buMzDuKtPQaHsAeB0J1BjKsQUNsRrsIaO8cbKwAOILY00AdwQANkcAVuoNGIkGBrNAtqO8lg5qrXe6zxewf5ewecYK73GwRTAAN38N3Xuyvba6qjat7SwAuBAAh1UAaDaiKhAI24EKxtLg20MHqr0AZZkAUbCgVQ8APj/+wESPADjM4DAS7gXF3NXE3XO+ADG67Vkk4D1azpA0DhFL7Cnv7gNGAETnDVQGDpqN7aGRDirA7irv7qH/7aKRDrs13kRX7juE7jCJDQHrADWCADYvBjXsqdVEgGsX3bIVvbuj7jx37bB7CxRz4AKcAJcJABfOAGcgBkhlAJSugJr4DlvRAXu+Kq54S4yBAL9ysI5hoJgiAIkIA3yCDfSYO4qkrGzIqgxPAIh3AuGn0IgTAseb5A3OKTkv0KtlEJicAGY6CrhI6FT4AFWBAFTgAFToCY7tnNPpDxTrDxTtAEFf8E4wzxIj/oEE/oZEAGY7AEnY7WDt7gE+7WoX7WA//AtGUQjzYfj4OeBRFv6OOMmD7/80CPmCKPBS3+4dAux0j/sUiO60yvsct+2wkN1jvABolwfN3JnU3gAU8f46v+4TsgA0DwBGG/8Ffp5EywAiRQARuQAQZwAGsQC2uwBYNwx47076Xgf5QQC6DgCoqCuLPHifELfSxtBX6QqJxwCzdktdKgDEsmC6IQCqAgH2UZjp7dlR/KBvEonziMwwpsJYwwCXsABAiN27s+AAkNAUCQ8zoP8VFg6BR/8eEM+1KNzeDczRwPBSEf8RCP+1GABSZ/8kgQx5/u6R0b6hwLAXbeBvGo8AtPhTkf8eMcBUE//T5PBk8w6FnYBK399Mz//tpQH+OwLeJd7+oIPtZXjc1AcIXi+e+ZQAnewwiGwAYdmtXUvANjbeDlLAPljNWE6gZakAMAgaMFiQ0bBhTQw2nKFEKACBkyFCgRpk6UHj3qBArRnz1v3rABSQaIGDFPgMiwwQKMoliJAmmKRu3bPXjXpkmrtQOCBw8QICAAOkDoUKEBjB6l0ecQH0J9CD2FdIhNTwQDjh4FisDJkypdqXylkoQJkyFDipwtsuTH2h883K5FEnfJ3CVOoESJAkXvXSxYsvwdc+VKFBoIAgBAnFjx4sRHB9Bg06YNSDZjLJMh8/dvXyxROPfN8lk0FjJP/jYZQ8bJjhkyZsyoAQXI/w7atWkDwZ0biI/dQJjk/o2biV7cPtwa99Hjxwy3O3gDedKkie7aMnbonv0ciOzpYpqIwf39T50sNnLgWLGCxAoBAgRFmvLlUENAEA9NgvQokaFDe5rwzGooAw4g6qAOOEEGmWOOoQaec/75hx1spEHmDwR+CqpADYUSQKgdDgHEoRCfcoQ8IHiQIQMHKjCAgQNWSMGDHa74SoqvysLxCBzNOqsHH33kQbkf4iISibrs2usuz/zSrIwx/oICRQ+quqpKx6wyCoEmIpMjNcsA02wzzgQTLMy/yCQzNCizKIMMKLQYS68oSnriCZLuxPPOMUiyrE8/+yTJTjEuS+2JPv8pEwOkOyljtFFGF1V0ui0BaaOtImpYwYYOKiiggPfie4qQQxZJ5JBHLLGkET6y2MEDFRHIIIUNDuhUARezOkCGWKKJRhqZ1hFHHHKyuaYZZDJpI4odUkihA2dl6CE5HmqArQYZaHhNhiwW4TYRbh+BxBHJ2HhiiRxuQDeHHci4ggw3yEhCLLTmpTcHe93C9y229i0SieGgGIuJKLTALAuQ9hQDC9nGwIIHGlyFIAOfMKwKywAg4FIOzDB7MosqtKgiC8GW1ALNksn8WAuVtcjiy47d8ELlv8p41FFHJ7M5Z50b9ahnn3v+I+hAhkakaEmOvuQSUZbeRBRQTPmkjSb/dvghhxquniGFDEyIJJIvviCkkEMOgSiRRzLhhJA2yFhCBgiYlUGGTSuwgAQLKtggxgx86CTBZpqhJppvsLEpGmRsMWQMJ2bgqXHrduDBBx/Y4mGHJcZ4gg1AMKElFs8976SRsQnhww432pDDjT7kkENtI7RYy0d7Z0/XXnRvqC1f3fHdd8jhmPD3LsGgKEOyNsroa+MnjYhbBg+cnzjDAWRgnfUy2uS4K5ZHXvJM7qMQLOWVpSBDCvJFhgN5MkpKlA2Scv7Zoz+Gpj8QRBjB/2ikL9mkaVFUAaAqXCGLWcyiFrjIRQJ30QtfBGMYx0DG33olDV9RgxrYwAY9NLhB/2xYUBqlmE2QVlADG2hNC1TgwBoU8YU78OEQnFjFK2QIi1hgoiFlaJlsclOdGvTABq/hDRsMkQhKgEIVsLBFEm8xC0084g9sAIJaKoctGtDALUYwAl2WkJcskKENfJDD2LglxlCRjg8i+gMg0ngIN/SgCDfowe5ud7sq0gBddpxjHm/3Ix/5Lnh4EYwW6sAHPtTheG06JBmq4AQjoAh6PskQBJ6Auj3w4XrYwwzByHCyLCypL3gBZV/KRKbztawkbOAWIyYxwFocEBevzEUvGPiLXwijGMY4RjKSoQxmOKNXFgQmMDFIjwxu0JjHRGYylanMDkrDFTuQAQldkJ5pIv+BDBkQgAQE8TVCLMISmsiEJsS5nz9IZgzTmU3zmkcbHzQBCt8RA9HuN4mLPAIREXnDuMYwrshMxnjGY10b6rAHET1ljKVahCESOjayPSQifzAEIICAtRvU0Y7YmqNFK1pFPe4xB/ji45B6gATwaSE1qutDHwp5yEtmIQlGyAEN4ta4iQ0AATvIJ+ssiUmOkcFlockLKOU0JjRdATAI29MnXuGJWRSzHsvUYD2kKlWoHrMe98BqVu/Bj6xe9R5e1So/xMpVrX7VqlPVYAdt0RMP1MAFb32rEuDkAAEQ4At6+MIg5fCGvXqken+tXs8AuwfCBs2wh0UsYgm72D0EjbH/hPVIYRmbWMMyomj120MjFoEJPkThah24o0VFy9GKztEGN7CBDUgIJD72MU48+MFd9ukGN1xPMqV5AhZoI1OaRi8rQIFAojJHhihszKdPwoKfPukZUHLPe4MBZGeWFIUtjSJpx6DHVtXhjXN0w7vd6O44xEuOcXDjHN5ArzesYY30tje95zgHN+QrX3HMlxvkwC84ygEOclSDvdZoRz66MQ0CQwMa1bDJNda7Xm+YFRvDAEIAptcBTOkAB0qAww9qQIICEGAK22xsRzoSPxKXuMRCq1+KVSzPouGPEfrbX9L6t7T/BRAXB6zFLW6hCUasIhaPYEMTYJOCi4qWyBql/yMNUrvk1EYrcj6wQUiHsxYodJG2dbCt8XyKhSU0h7c92QkkL8QGjuTTttczrvI61hnvPbeogvmMZnRbiVBcAhfZ5Qc71KEOdrBjHe4AtDvSkY5Au2PPh0Z0orcLX/sGC7+PJgc49AsObTDYG/OQxzisQeBp+BfBhLtGep9KD2kEwioDSEENVIADFRxhDkrw4QoMIIAQ6EEP9UME0exXNF6/GMaSkHH/Zrw0WRTb2MV25Stl2Qta1tKWxdBlMpbBjF768hnQ4LQFO4jBb3QbG9+46jdIHY3/6UIXf3iCw5g12iquu453vFq8m9xk40Suh8pRzr+G40U31AHLtpUDGP8r85cn7IAGtInbTtjqgTdIghEPJawcJINm4/6pZR3TzJtFZlTNfCkLHtjDKppGjXrkGR3scIefAT1odLTc5YqG+XbdGyxHQ5oc4tAGOLLhX2tUAx34wO96pwENoV/DJtVA+jQ0KI1LQODUGbBBeoaAhi7gILU4WEBdvyCIWxpjl8pQxjLETu1qP2MZzngGr6LBabZPw+jefbt31wHfc6zj0A6C79zzXnc/r6Mb62CHOdKx5/QeuuV63vM+8nGOa1CjFptAhS4yIYYleIAGeXN3u2mQedPKu7XRktyPfsCE0SeJeP3udxtOtwdCOGIRh9grzsgFBEldh/aIECc99xP/0T+AceKY7JNPL47xoprJ+H+xjiZIsYlfZJcdJ9fzOQS/8kGno8+Ibu+h28sN9NIX59qgefi1oQ1u8Lwa8sAH+MVhDQP33O1u30bS6UENUQDB6RJOgXpcgIYwqGAIPSChDWiPEfgCeICHdViHeIgHdlBAeXDAPjPAeHDACZxAe7AHeWhAefAHf9CHfPBAfejAeRDBdiDBAMuHEXS5dpjAdnAHFRRBDFTAeKgHdSjBGIyHf/AHdfgGZZCEI4qFNjC4DtAazDuyzDuydEEXkBKSH4ijyNmXf5ECoyq9MSgDf6OtgGs9TPiEUaiERQiEP/gIkMAZ+amEVwCFSxAn/EmE/6cABN9jqePimNTYmJWhw5WBM844k4/zAENAhU2QBWyoh3ggwZTrM3YoQZdrOcJzL28IP5rzvvGDREikOW2oBvVaL3LIh3QYv02bhvVCMALrhmrAtmmghll4Ax8wjAAQgPxzgTAIAxfAARwAwA0rgABQgCDYwH3QxV3kRQjZwF8ExmDMxX2AkGI0xmL0BxwUxmUUxrAKxqyyB3/gh3rAhqVRBVp4BNaQgSGMFWbxRiL7Rjw6lxtQQrhgwsnpHSYwn7+ILb1wFyusg26yBE54hVuIhVHIhEyYhIe7J0Z4BEb4A0aIhVbwBE0oyEqYhETYj4YAI4m7pIqTwzkkmDpUGf/o+iSR+ThJAoWlKQZ6MMR0IMHnawdERERFXMRGrC9uiMSVHD+a4zmVdAd80Llq4DShI5xOg4ZnmIZmMMU2mIEDEACj2IAb6IIuGAISGIIeUq0VyDoBoABehMpdNEZmpMqqlMarTMZj1Mpi1MVlREZp5CoNCoZNSKJXIIPX+KwOgIDWaB6ecI24mYGDcws4Cim4QAK4IL21gEKj+pcroEJ/qwOlgARMGIVY0AVgiAVPyMdLoIRJqIShIbNUmIVWAIVQKEhNqAQ15L09cMjjUbOITLPQrEiOa5mWcRsPYARX8EN6gAd2qL50OLxCRMT2Cj9GRMlgYcmVnERoGL9seIf/d9i5tiMwoyOwZ6CGZqgF7/iBDCCQwyABLgiDF3CBpMyBWLMBEmgPBfCHfdjO7uTO7/TO8ARPqxTGsRKrrNzK9CRGYDzGDeSqp6IGWcgxXViE5LABVmsWy4tLbIkbbHkNuSzHIhkpIhmLdtyLKMyCOLm4MnCDgDsER5jHWLgFYAAGXXgFTZCEy8IfUICFVkiFyjSFyqyIRyAV3pO4Nzyuy5DI0ITIPxkDt2SDV1iaZoAHQBvJR0s0l1tE9LpNlMxN8Bs/coCGbNAvfEiHcKDJtou/UJwGXsEFNmgeFSkAxHgBNJDOsjAPAEyBHBgCBhCAApC+c0iHdRhTd9iGcLiv/3NAh3NgB3IgtHfAhziV0zmN03nIBxDEUw68U33gBz7Vh3+IykAlxl3EU33gRXzAQbKqh19QhRxbhd3wAWrJlmv5T8hhjf08OMjhATjiF4ABnrscvTg50CtIkjKRw9Z5UEzwsVs4TAqtUF3QsSVKBVNABVPwBE/4hE7IBEvQj4gCBM40HjT7k0yiwyvQpE06VpYRmcuAgvcJhVZQhTtjwHbQh3nQB3/QM2/ghj1DB3IwSdvkUR9tyUmURPGTNDjdhmswJniwh3vQQH+AT2IIBA+YqBtYgQ1YgAIgAR0Qgrc6F/PIgRKqASXAAQcYAO+iO76jO8Drs3cYtN/8TTqlU/87LVTzNM8NLNRC9cCN9UB80EUQ5FgI+VN9kIf3xIZWsgVdCAQZqDdMjctKNbj9zJ0gCZI+Kr2AucuAEVUoiEI02biWwYIyCDhDcAQtjCFasIVbSCJa6NBUQIWntUxxEidLgATRaYiIC1aeSjNNUhkWVbOWwQwowAL3YQRbYAVRiAZscBBr9Yd2uD5v2LObq01wvU25Fb9IbMRsINLfXK8NOkCEDUtSuwTIIaGoswEl4AAFmIASKIHpTK0isBpmGQIlSIEDEK9xMIfMJbTqcwd5EMF5SAc4fQcSxId8kNg6pVgQ7FOxCiuyKqt7sMDYjd0O7ECOvdZ5oAma0KBfOKD/XEgF59nUJBOt3cpU2jgOJpSyTy2SJdDZ4ehZUh0e4YkCKnQDF2qER5gETNCETviEUvBe7z0FUwgFUOiESqgESjhfzTIE0uHMOjid4olDr51D+U3RjckLkHiDGPKEXhgcuJ2Hf5gHt5U52+zRHrVb3GTJRtSGdJCHc7CGa8AGuBWHAxPFUaMGXRiDIBkCq5MCM9CBWTMADlgBFwhY8xgCFyCIFZACJkgB8cpczRU0zrXTfGiHd5CH0W0HO52H0/3ca9XTPn1d2ZXd18UqkJVdts1BeKAHpXO8XGDVPeCJ4E0y26iNTM3UJ6tLf+GXuCC9LuZZUjU96U0uoWWKsvHH/0nIR3Hi3oNEyH/0logipNQJ1jgcPhXdJPrFDOwBzSyAgn1ig0SIBVQQBQrCBhq805PTPm9AB9os4Lv90XGVr2qIB3hYsBnEuWfAZGYgJgpZhLiRusM1gxQQCgMgARdgshw4AhS2gAzIgStAAnMoh3KAZVmGzW4lB3SAU0ybh3rY5V3Oh3ogQRE8wc+1062yh3qQ3amqB4613Yyl3TvlWETNh3/Ih3jwBgz6BVjVhVF4GFZesjgyOE2tHCrOnclJjiXsHSJh3lB1XoBJkuYqvXaRDNYhqIdYhOu9iEmgJxK9J44Ao/elOI9z0SfxuIvrIhaluDwugz72YzlYBVa4hP9f8BV1+NxbVod1KDxxSK9G/j7d7OiVlK9tkAd16ERrmAl1MDBjMZZVqAwf6IAMyAAaKILD1YIVqAoDEIERsgEeKIIhOIIXKAELYIAOQAItKIfLDYdwkOX84q+YfIddVmZg5uUc/tw5tdYQ/FypcsB4IGZiZuaNBVlmFtl8UAd4WFRcMDddkINtdIAe+ZHmGGfbyBfJWYvk6J0t5uLYElXSC+O7YIt/sZM6GYPI4Cs5UCM1Iqw2SBTvyK28aAJQgmyGHr7Q6BjSBFuE3phLmt59Qh1IiIWmoSBriAfTbTkEZGSO9miaI4cfvWV3sGa3s4Z7UAdu2MlmIIZRgIIBAID/AOAAB3AABKACGqCCOUiDG/iJAyCBq/ERHHkBExBqB0gBKBgHSbtcWbbucvg5fLDhGa7qHaZTONVuYR5mYp7A0y3dr0ZvD9zAAFaHengGWXBiYPgE5+mJ2LHZttAd432yfUHHH5Acc0ZHIqEyd/bUgAGYvI4WtqA915gBduKN65gOhJOR/ixe5v0XvKiyTlKTvniSMhk+hMaeSyqDOeFsNgg5DA0GaZgGit6HW4avcOVoBO5NndNbSdNbvY3EW8YHd8gG7oNbe+iGaGiGW0iDuiIAAcAAB8CQG6iCNDiDNEiDFTiABzDlKHOjstCBE+htBoAAGZA0cKjudBA8MY9J/+32XKwu3dMF79/c4a6uaoit4TgP4DnP4Rz2QDf3B4/dZWzABfgGhlt4g0eCVMkBgrpGjsjRHf7mbydkC7owkt/xYijg4rHwFybggdeALUJvnOe5loMzDmiaKce5FsgpPb0QGfDByDDBuIvLDNAkg+sxAxG/HnU0AzNwg7+ABH1UhbVTB3IAOnJ4cWvghh5VP3LtzRtH9hsfv2oAP18fB2iQL2uAB7dDBkyogAAggC0IAQk4gQrIihyggyg/Az8Ygk25Giuf3CEQghbgAKE+gAyY5aN24WwIB3NwB/DGB/E+QY51czhHv2He2M/dd14m+Hng6oM3eBVEPxHEU0DVxf96cIZG1QViKIU38A5o+jzJcYuPwp2O39SPz4G4sFl01o268JclMBInUPl4Yfl4MRLpgPk6kXmZd4Itgi6VNwIfoCIeQAIosIsokAJAyoLtKSqWeRI7AVsvYNAyEIPbKoM8wIM8yAM6qAM7mIMzUANb8wM/qINGGIWlkobsAlTsPi8FY69Gtq9hP/ZwyAZtaPtx9a9t2MB7+IaxontsQAZHoAAJSIAE+AIUWAgVWAF7PQMvGAIb8AI/sIMaSLWQUoKyWAF3H5CkVupxSGrLx9x7x2E35/yudkCKHW+vRmYhDkQbjEHPjVMQ7AdD7Up6qAVVmIXDNAQ2IAMfYI2R/5H/G5idcdQjeymCuxQSks+NJnACJEgCtGD5ImB5sIiCJQgPmId+4q95JxAqlG+LcOZ54ZGCkylWYx3NK+gLPSEDL6CtfyqDM8iDO7gDqdeDO1iDL9iCINj2KciDQeCEUUAFXgDE7ZQ0bnjgawAIbuIGDtSmjaA4btYWWjN4ECE4h9q4cbt2zR8/evTgwdNIjZifBglGJggx5csUITVSlPFSpIYNKmngkIHZo8ePH0yk8MSRogKDAwzChStnbhzSceHGoZP37l27qPOmUqXaruo8eVm15tOn7yrWfPXq2StrNh7atGjl4Ztqz6u+ff/83ROmStYsYqPYtGkChMeMnIJz//bIYfiw4RuKFRsugmSwYB8+cgIB0sTJjyKaiyRJsrlzEipUoixpYvo06iZLVjtxAgUKEyRIePDYQYMGDyRQrmiJouW3FjJktPAGriVLFixRnogRM2YMGTdu2siJrkaNnjvavwSJkCAAAAABAlDwU4fQKk+ipNHjty/duWvYvqlDV46gRITaqvHXls0gQuJk8181FFHEzz30zIeNNM0Ao4UEIUTgXQRf3LEFDCusoEUZRaxQAw5FMPFbDzbcxAQTr3nhBRMrdAAUA+DImBRS2YRDDjtPRQUWVj1OpZU8QeYz5I5SzSPWWGSdpRZa7bzT1jxv5YPPXPBgI4sstdCiy/8ebbBhmQ8yQCaYZofdgBiajo35w2SUWeYEEpyBNiedUTiRGp6rLeHEErDF9lhtt/HAhG9kXCEcooj+dgWjWZCRRXPNQRddG5We0cUUQYSQAAEChPcpqAR8gUcZmHyySS7f1MMPO/B886o66dxXkETkkDOQgQL+B+BAA1azkEDiJIgNNdE0g8wnL4QAArMfMJvdFjGsIEUZNHyIwxA22KDZTSdC8VsZZWgxxAoaVOAAUjIuhRRR5KCTTjpRPfVUjztSFaQ8UeE7lb1TxZMkwEw2+eQ89UyFDz772EPPL6rMIksumvDVxBM+zCADiigOVmZiaB6mWU6PjYniapchQSf/yp2N9sQTrbHGJ5967rkEirL9UNsMM+BGqHGLBjfccYxekcUYkTo36XRsjCEFAaA6/TQACXxxRB+jgKIKe/VYhI1F2xBkIK+2BqirRAYNaM011gRbzzfUNIhMJAIs+wWzIHxh4RdbCNGFGTzIABMOOICoGbZDKCGFFl6EC4cbZDBRQwcZmFPOOOCsG4455rDjDrxOzvtOvUW2g2876OyYzzz9zpMWwPUIHM/BVSHsDz3S3FXLLLO84VxlYfLwGmyDeezxZjngJHJObea0GhCrzSkaFSkv17LLMlvPZ80380CDzjv8sBtvQkcRRXG8PfcccpE+R0YZZHjJBhlWgAc1//0AECCBFZF84skv1NAzzTQs0p+E5GpsEhlQOHZltv0wxBriaEc9aicNXShiBAKwGwg+oEENfmENU+BbDv5mgxq4IHA4yMEQsHW4xJXhDHCoQx3gUAYo0EAGS0lgNmSUDXjpKCr4+NzngiQ6feXLdEHSB+qMtLp/jWVJAutRW+pxJVXQAha3QIQYmiAGIOwACDPwwWs0JpjhpalMPZAN8pT3A5kx4XmiURn0qOAElrGsejKrTPNoJjLa0GAHO8gN+Rg1PjuRLwuNOh9yssCc801KDm2AjhDmVz/6CeAOnBhFK6SBDQBWwyJp84aBDCQ2WpnNRuBQ4H74sxBvqMNV1P9ABiYMYL8ENGuDH7ibGsAQhy6kYCUwKWEKbYDCIVBBCoorgxvqwIdl1sENWYACjcoBr3KAgxzugMro5gFEHeErX0USohHn4Q99pK5ITDTLPe7xun8dCXVt6UgvLmGLeb5iB80xDRT+OAPgifEHOSje8Dh2RpsxYTAoao1r3qgZ0MQRelBgGRaw0DLrLQGPQEDCn3JCG9qskXzjE2QhDWnIKwySaJJi5Bjk8AY2mAEGnprkJKcQiVEQw23T4M81umERUIZylGMjig4nojZuTMQb38AGUoEhBwEEQAAjcVYtmfUFMOjBDDXoQQpsoILAacgFwlTCClvoBjj0oax9IET/H+rQhnTI45oIw0c63IoPb3rzKT+klzdNx454XIWu3vRHPq6Sj3y1LklMJEuS+MGPfyQMHwmihyhmcYtb6IIRzBFDFID3mitoVk+N4RgZc7AmnTAhZq7BgpygB8eGlpaOdLQj84DgGjQuwWZ7ckKKBjk05OzWCYJsTRQkelLojIENbGiCFlDwUphSMgKCWIU0pBENa9QjnRrpRigFUjaJCCQcMtpG2u7hHnysw23SAMYYJPDUut2NbnQDwRbuoIYjjDAFM7BB4FywgiFIQQlDYEIx2ffCOtiBD2VFax+Oko53cO5J85prkeyKsKcIcUdr2cro8iWPIbXzSIUdyznN/2IP8f5jH/uYh4J6oYpcUDYUT9AiZge52c7WdjNFCO2Nc1AzNObkoAh9TWgaKmTozZGOEaUeQu8EBdfAxmVI2JOdUgSFQYZUfLVFghOCG4VIEY0MxW2OF1BAgE4xl35NRcEokEGNZ1gDQWNRW4EoIo7tOqQh6gLvNVZl4m9EAxF7AMIDMjghZ7X3bsxCwRbiYAb6rmQGKiAhtgLnX8Qp7oV2UGZZB1GITZvjRpub8IPb6g53BKkq3Rz1qEt9LyJuGIntNEsTyxJidC7WxOygRzFEMVnK/qEJPiBaIrNAZeBduTOgzfFnNSObjIkRRa9BKPR4Im1pF5MncizyE7CQHP/X0pGQH70CzMaHWynbaU+CnDIUfnDGKWc2ooYMDnTaEEMwqJckZX4aUwngB2KwJ53p5AZ/qoGf/Aw8h3jOs3vOQQ1VICAAGBA0SRIQAQ66NwhgUIMZlNCDGnA8BSnIwQp6WQQpjAiZcIBDgZUJCEIc4hCLWMRR0CEOdAwJ1G0RdTdzLupUA+lHpssKOsSZlSGVBWBFj7W/FcvYfMBj4bLghS500YktzgA5VB72s2UDmmPbeDM/eIyz/aRZ4FV72manNrazjZwjv5hihBQaSaEc5Yyt5skyzqyzz71bR7EvmYpQhB4oAIIJeefeTwOPFPjdHsVaI+BjM6B/suFJa4j/lx/1GAYbIKAAFGRQg96J+HuDEIQ1YNwKJeL4SnJQhTzkQQvf4tAZxmqHPsye5S5fhCPY0daZ4yMf+3jrzUedFnbsdS1BQvWot5KVqKAu6IDVSpTsYXTpK8nf4h1nlODxi0tAPeq9loEMhJ3Z8b0ms8CL2Zw41vXNyOa2Sc6yuLNc9rNLWwtSqML0ILptl51myuEjKcy4DLM9WdgBD5UJ0m+cD/ucwRnwgSI4QiSoAed1XuEZntPwgZpd30MgxK18Ta4wENqkjWLVQzMEAgQMAAEEQQYNXgTUjXesIArEwBqEQRdwgRIIDkzkgA3QQSxwghf8TLgkk4HxASEUQss9/6AjuIM/uAM7TEljvdU8cA4TEh8VGt/OEd++aBi/iBM5HcnRxRrSpRM/+IM/yMM9wMMzqIIqQB0wdAIb7IAPeAD5jR35ZRb6bV2ZLJRnLJSevN/VDRL9nd1v4F+2RZQhykz/kQ9xkJSdIBTNAM+T8RO7nZsirgiitBAD9kEhQMIojEIcGBqzeMdyWWAA3II0tJk/jI1PEZCchYNFAIs46MM9RIMkIAAEFAABSEjdhEAIiN7n0VIQbEEYhIEXdIEU6MAI2QDJwcEoRIIXNI6AFdiBFeEROgIkFIM9ZMXvAR/CuIM5dEM3qIM6EF88VGE84AuqQR9dgUWroU4+3IOIlf/FPSjJiKWTP/zDP8QDPVADLmxCLfgC1L3BEuyAB3gAZ/2hcsgYkOGhHm5dZ7iGHSFU/I1PINIf/hni2mFB9ZzGRy0KSImbZuWW+XkUSPHGD3qBcGDiGeABWUGgLsQC4LWX5yWABX5KJWiSeInDDREFu4TDNvzkT3YDUbyiA4mDYwUDBCBAAQiA3PBiCEgABYQACizL50nAFkzVGZjBD97gtlBBFSSBG7RQHQQhpvXBIBShESIhJMiCNpQhXDnhhKVDAlXDOYzj8BWfzh1JORXRVYyOVxxJ0imWYuUDOtmjXEhRNGyCKtTCLhBDJjzBEshAQSaHIUaUlilkFOBhysz/iR1KJGkAl0SKRhUM4pBVQRXIkbYFm2WaH7uRD/rw1rm5BmuOn/9lFqNoAXT8xjEhEwPSQVr1ASSsAjDowigowh0Y2gdUoAWmGTWsyjb05FIchVIAJThmw68sxECUg1jUQlIyVQBMJQZQgARIAAaMJwpEJQoEwRSIQBikQRpopRLoQA9IwRB4xnBIB34qk4EVAjUioSM4QjFog4ntwzukAze6AzrYCjfEQzZyxTw0xVYIkeuUI4XKgz3EgzowKDzGA+oczD54RRRVnz/0A13QQy+4Qi3UwnDuAV9sGRBUJre5lmkswRMkgRHcKI7mqBHMiROABo6mTByZpmlCz5BG/4/KCKlpXgH+UUFr2sluHRm2XcZyXF1qUmZqjgHfrU8QhmUyuQEfOEIsEAMx3EIkgOIHJMAoMpcAAIMmrQo4guM22EineZd1KsRCXCeAhEM3YAPDIcAAMGUDNMACKMBSMqWhFkABPIAGMIAXMOCKbFwNGE6AsU+4IBOBGRg13t7LOcI86APC/N6C1RyDpYOt7BX09YiGjU5a4EvRUeiIXajscGP0iWE/WB4zbAIu5OowUAJfkEEWAUEh0pFpxOhl1Ghn6KiOzsmPbmZnfCWzbmZDdQaKiIYUoCaMyuiwNgEUVKa2jUFCEs2kJEoQnkGlIhMfLMIoAAMxAAMnCMJ7Kf8nJTnVeDwAm2KDeG3Dm/7kOJRDORBFONjpQqRNQxyEnl4DLnjAAAxAUwmFAijABTyAARhAAyBqARjAAXRAByCTG5CrFEiaEkzqlhLYgR2CEWrqy+FDOzyQiT3JlIzaU0hhqt2LqZUaOcbjv6BFdV0oWxwJN0JJWQxJiSpmLtgCMNjCG1QK+QFBc8Qo07bMsebo0y6rjd4onSBpszrrs6JMHMERgN3fHEkU094JHW1rcgQX0SQkFoRruFJq+7AtMgECJtyCupIp3YgiqDAlAUTcSBBAAHBALLAHP+jDm76pUtAIeC1EADVeNWhD423DN0yDLEgCGyjsABgAoTbsBUz/gAVoruZygBUcwYAxThmAFVghDqWOlaWNbMu13Mu9HKlqQzuAaly6FYKiA6mpmjtkE4dNRc3aA74g1l6VRVa0BVxC4TveA+qMRTzhgi3cAi8wAl+wwRX8ABYo7dI2rWv1aNTuaNZuJtbOCdaa5rMOWbSNBpQaGdt1m7ZhJJa6GyPxXUqG5RiEy/xOh5cuwifownBGwhaAgN7+78Q5y5jxwSQgAz3cg+AObjfQyDjoVNpcQwBdwzYA3EKM4yZFg10wQq95gC0OAALYogNgbAf0ABz4Jh/AkB3AgRfU3zElk6Vhqu2tbusugozUcDVdE4ONGqmCwzi8Q1vpHoK67Fv5/zDrUJ/0SR/xjdhgvVXNGa9XDFbbSIIsMC8wrEKlOAcZ6MQSGCJEcSsXs4yPQm33Pu0Ycy+dcC+RnqaQVWtwSVSSFaK7NUdqRgG4JtJzuC/8sq2jlEEWwF5YtgEgQEIsRF0kTMH/jgThMYvoFQAOrAKuasQ9KDC+KrADe5IEM4Q2sEMZrgMEP4MzYAMy2IIqgMIbeIBlvIEnzMIlBIIhVAJaLRMfpLC4JI7ijBUMLVNZlezqmqyt9HJcxZXLjio6mIMPm4M4uAs5TEWBLthTkCM9wiP1/cs9ABYTI5ETnurq0EPk1gIu5IIuEEIWlMFzBA8TxKgXs534nrEZNytofP8v1WatGJNxkEVrkFVBtV4BlL6x/olBIo0PuPrzHdPxoyDS+jwTckhbxlFLHVjCKlCWIkgI4Ukc4QWjGghCJEDCJwADMNQCe9DD4AZlN0xyNzBENWxDOKgSdpIhYPGDPGwDOzyWgjBDMTCDNFADUlEDNTyvIQCCWdEeHGilF5iBLduBNJ6VLsvwyx1CW2nFW6UDOiQoW1EFvMjKKWHOhNnKk7iDOGZoE8FjE9UDO9RDXGxjV/ylNmWYPMCDMyACxNQCL3RCn0CHGIDR94AtHJ+zRG2m1I4xPCMrjnLGG83zkLUxkrGGkVEmZ21WYk8Z2mIpcmCpP2dBll1BxmiBEoD/ARhwgR1wInFqSiiiAAwkmiJwAmWp6yqYwi4gQy78wnUt8Dgo6OHeacDJiEEMlTeoNBnqQzz4wz74QwRpRHUBjEYEgyQYAiGgZSEMAh8wjnRYGlFP41HvcsvN2TGTw4LhQ4LmkO4pc+XQKTgw2A+5C8KgA0XYJRiSBYaqwzz8Hr3srjb58DvEAzyowiX0AjffwhvwAMlBgWU0AQ/QsRh0MV5HVNRu7zrztbL6tY5qBvQw+FdubWhgmyPuif6tHaMAz4WXn3LMsaOMwfh4uGswQQ8wAVh9rhV0QRgogiW8QixIQQx8gR4oQiSQdtSp67rqgiRIgi34wi/IAjYoiFDe/wh5c4M36FRQckMH1jaRcwNuY4TS/cM8VtcYjiEZJkgzbIIhpOXfJfelndyl9sF+btrtSffqDkg2aA5b4APnPDU6sEOneiPlFMWCwbnmEB8T2iWGxkM6leOIsYM3oEPCICiR5AM+EmhLx0MxbIIvBEMuDIMm7AAWJGCkfPFdIwe3YUE67+iyxnNfo8xeT20S/BMceYZqMRQc15FpqZ27GdLY8dZrsO9rIlJxTJsWYPYa9IEjYMIqcAInxIJGiykw7MItxMIocIIlQIIhMMIq8AIv2MIwbMQ66B6gl052FcScoYM6yBmDjcOA4Os1eAM5VATXXAM3jIM8OPVJf8MxSP9CIMRwyxUC7TUTfpLVcfMn6ya1dNsIUbhDEzNYgrb5U0gnvxoF58RVN6lDXRLfOJphOY4FO9RHoFtT7eLjkLADJ2+CLAyDL/iCLryBX+Bm0cixXaOvG7cGHYVxsnK6Omv6O0+tgv/1+jXkHnLGy8AWhbMMHS82hmc4+dVxt6IPcdgfT0ABT3ABF6QBISxCQ2t01NGCK3RCJ1TCJDxCIyhCIdSBHBzCIOvCLCAVPJwDO7SDUx8zT3VgQvAHNFTDAuPDURAFOFoEN+wpUl3DOZhDPjxFOnQDn2G5yS4Cycb7yb3QymXqvZO5jZRqV3RFFLIDUpjDNQl8v67LOJhDOmT/zjd2wzlEuzjqnlpgYexiN7y4Cz76Qzysg4kGgi9oPDF4wg5UTBZIQfoE+MjDaMy438vf/spDrV/nwO7HfMwbRh/Wvg/ITGtMmRSMnUguWc8HG/PfptADwfeIBofIwR9Qwih8QiZkAiU8giM0wt/nwRykQREYQQ7wwSrQAikMA9eE47skqK14A7h3oEU8A5t1w4IN/DicgzfIxzqsw1F9A0Cse/dOXz58+Nx1o6YK0aJGjR49cuRo0SFAfOzUqcOHUEdCh0CGFHmIEDRo4siRQ9eunbx27MiFCzfO3Dtz5XCaC5fNXM906Xqa6zZ0nTqj6tjFU5o0nrx0+/K5k8ru/ylUe9ikSdpEzBcwXW+A7NgRJQqUKGKePMGSlq3atU6WxHUCN0kSI3fx5sWbQ29du3oB383Bd+/gHEUQJ05sGPFguXPjLuHhI3JcKFCYMEGSGclmJpedkI1yJUsW0WQvo8aMhMePJXWLXC4jB5Ah24cK8anjhowWKUqGpLgxd1QsWLKkTbt2jly6lSm9RU8pzhq2acq7yTM3LhxOctyiD712rds5c+nm5dMnL+E3WZIiPoI0fz5FQn3w9/H4cSTI/Sah0UZAcdApkBxxskmQp+3GoWm7oIB6cKhtyjvHwm7WiYedDTckB5983pFKqn32mQceemRBBBdgWJykiSVm8P9AtdOaqLGJueZ6Aq7KlriiCr0IG2yvwAAzjEjDkLzhBhuSNExJJHlcwggeqOQhr86Y+EGzzrjcbIm5yirrsjE/wyzLH35ArMoeelACBymywAKLKqjIQQrMfujBByCA8ECGJoDgJJZZROmFmuuqKTAdcbixxlFuxNHGmuuwqeYaexTMBhxtquGmm222GQ/UBuPhhx954tmGHlwuoYSSSmCF1RJLIHGkkEHw248/kQzZLxuTBNSGHHnkmccdchLcqUEGHQyqpwbDmXCoaavBcJ1rzUPnnYNCHHEffeBRJhBVbvGFGFrYwGIHGSA4LcwobHxRrijj8hFIwYgsLK8clLz/gbDCknySBiYH87fgfg2+K64pq2zYyjzR/AFLzdDsTOIlPuMTiMuAiNi1iIvIgQexdrDBBhVSSDnlE1xYoQYbaqhhBrE8EAuIQ4xzRRRponnmHG1+sqYaR4nmtJptzulUHm60SXBTbTz99NNtyjkvnnvuqUeec+jpZRNNMskEk7HJxqRWRW4FZL+Ret2Pm2qA1QadefTxJx92Zvq0QWhpGuendAZyZ51zpi2cwgovNKeddD5kbyB89lHnm00ksYUWYIhZJAspYmxXzCGScCJeeSszgse6gDRyXyRVdxJhg/s9+HWCTfb39X4dzj33HjyWOE/ef6ASTY2ByAwINtH0/6HKG0gOS4YUNsgggw6kz2CDDVRO2QMPINh+BjI4WaWVS3rhuRtz0HHn6PHGsybYSMlRx5u3tUGJu23G0TQccMAp56d5+JE1e7DjHsXwRCcQqIlOaAITnHAgJmhlq/74pyNqA8QFoVGNbGjDJORIz3qQFS38QWsm3NlbOtyRDqmdA1uEQ9pQLnQOdqTwHQZxx7b24Y56FCMQsrDFLM7FBjJAYQUQgMBcmJCEIQzhB0AQ3ZciA5cfGGGKU+TBYZIQMtexjl8GY92TlESD28Wui68bjMlqEEYl8eAGNKAByXZQpTfOMY4NAx6beMAmNlmsNRHzgR99wCbl7eCNbZyZDP/WJQMHVKACDnAkI6/XAUl2YHtGhEAKetCHVaxiEzu7TjzCwY5pRUc64oiUNtLTqWp0ihzc0WA2uoMTwOFDH/ywB9au9gxRfAKBvcTEJz7hQE6YzRGK6A8h2nZBZfYtHOIAVj784Q5xlFAo+OuJTHTiIBjKsChFsdDgLKSOcM7wJx8CkTuytqpC4YIXxDAEGcqQhdWY5U6cYUJZuMQEjO1zSxjLDMX0GNCIAS9PeTQolXpg0B5YDI92bOgVc1C7NtKAjW606A58kNEf+IBkI6sjIWdgMom+Lo+/kxgS9FixH+SgB0VY6ZMa2saYWVSMrKvYElyThByQwQ2ceEUmLiH/DGx84x4BHE90TjkgAblDHW8b2lC4EVWmCSgl5dhWPvJBj3rU4x77WMcsVhGLTY5iFJwIpjCHSatGUPCCewDEHuAqBznsIYU0cQc6OEiOus0jHTNJBzvWAbh3/CSFf5OWVC0UznAeBSkFWgnk8hGPetCDGrLARS9yAYxRtGEMY4iCE/4ZWs18ZkueQcJlSjuxLAUUeWhK6e8CitDYupZNImVtD0Qq0onOoKI0reNkeDAD4VIJjmLJLUlL6trFDCZkjXGdFwfDxpiJZYwIHWgRknCFK/TBrJdAzjfggTXyzC+pwUKHKI82tPFIdarcUMksobLVethjH/IIxipe8YpV/wBzFMBE69jUWhGP/KENb3gDGwz8Bp84ByYcREdB0tGghHTDQSZ0VoOgGtXEnkOci+UwOxwEOKhIlh7FkAVmecGLP3TWs8nzTGmZABkeQWFHHjuTIHkXSNcGUk8Z1Z3DdhBQmOW2tjCTmXDdKNyZ0XQGb2zYDpQ8MiXPjJA0feNvq+Rj4mI5dx0VCxtvQOWOgvkGVNKo8ngQmSRAghOeuIQxvsHVe0DVfe8LkDzYscptDM1Rq4xqglAyQ8j9Qx9ctUc99mEPabSiFKsg63+HOba0nq0QHXlDG+TQBkxreln5k5szhYUOZw1lJjIpdQkblFhubJjViUXKeYDCuHzIY/+ytahFLnDhC02wgQ1jiJMTfjCD0HYpijuC4kaTl9EeT4bHAeXxj4sL5Rm8DI0xy62RYzblKdNA201+spKlPeUq+7a4TxaLk0e25Tiee9w7CGO02fhlM/uAt1VyQg4IYYlPSKIW2JBzN6JaZ6V6MGmrJJrQOsUNQJ9XHoP+h3pmDa5osCITEWlgAyONiUhsfOMRFPAf3vAHRCAiEAbu60xgiQ5TBisc2wkHqGSyN2c9K9WsXjVjjcIOp0jlPB+aRz2moQpf4EIXtBCDGMiABbNkiQdd4pJr5oXT5AGZZML9spa1HO1ob9uiSLbylFcQ9hV0W7gykIG3qz6Dsws3Zm3/P7LXraz1Ma+7uG5sN/OuXGW5U+ns9ubBEwjBCco9Yx1FlerKhbZUeexZaAfX8zZg2XJ30E09JDpIPu6BjVxoouRt4IMjNq5xjo9+47VKBCIY4d1gHGMYXrPwTlBySgSVcJXJkjmzGORqo3wY50lBYWE/VOhf1AKzwEiEDMQwhibgyXceQwKaKpNsH587ydoWyyDjiH25i4XsSv66tplcdrOP3+wUTfvZ157tacP9onaH45XzTjIrw5/98ne/3KPcmhSQoRKDh4ep3Gs6qGOV0gcdDM5SiOZoQAWWaEIe1EMf/mEfuMUf6IEZVIERDswHUsALBoH0PLD0HoERPIEY/6gBG6iBHuhBGKqBmRIkf6ABllpwHI7G1Crs9nrC1dgB53rvb8oJmu7hF3AhF3ghFoDAB57gRaCAd3ogMyLGYnoHzaok3NjPopCLzMYIYcKvyaws7LJH7LiQ/MAw77jN7JTM7dTv66iwzJREC62sX5KM27hvBrxQjAxJC7vNZHpA7WTAjXJAjA4BEWRhGq5GH1LiQEzJGvbMHfJslVapfYQGVKphJs5DHorqHiKQW/hhGnLhEgKh12rAAR6ABDrwA0dvPh7hFYihGaShBKXhGEotEnUiG/InU/JnBmOu05YlQnRPsZBCQ47ib25oW/wh84gPGAJhD7Ego6DgBlBKS/84wwk9hriCSwq9zg3daI0QhgfocI2s0BrHsMkMyaJWIHvIMQXAkPyYjPymzQyPjA65jQ238Qb28A1f5x2bjMrcaA6r7x61LWZSoMmehwZSZgUAQQwMBR7sgRBXTkAQcRvcoeCqYRqswREhMRJpIh3kIYDuQR8OAiHoQRku8A3GAApSwAIKQAAuAAwKARJIkePmIxRo4RZ0YRdyQRbGgX9wUiYyxfY+RRKfBUIixBzYYbEYa0N2zyjuapYGIh/4YVVyARZ2wIjW7nnMsSq35yqx8iqlxwOqp3ogIAOMSHrCsiu7kiszwCzP0iu/EizJMiwt6S3dEi7l0pLEci7hsiv/x5IsGSkDHKAtIaAv8xICKOkvHWAABqAC+NIu55IvpacvHQAC2iAQhGEauoEfCLF+yIEhq8UmsmGVpoHPHk9vyMEc3IFY6oEfIpBE9AEbamETEoEPyEAKcIADJkABCqAALMALImGTYqGsHIisfJNsOoETLOER9uYmwUEndVJBxoFCmiUocjEocrDVkCIHj0LnpGIg3qElmjIaaiEQtgcB9PAczS4rzdM8v5J7uLJ76PIuv/I9uectwTIu21Mx7fMtEYA+73Mt5/M9uycxH/MxzRIC8nM96zIszbIDBgAAAMAAoocs+9OIECA/JVRCJzQABgAVpOEZukE9DPGUVumG/8yhMyMyAfWMwlSiNO2BElGTRL4lGS6QENxAC3qABS6gARSAAARgADTAEcInFhworGJhSHuzrIipmI6ThI4zQYRllVCNJnCiapwFnCwEsVjNKFwiGH/iHYYRG2SBDZpgBzwAUGqkCMViCYgnLIpr/NaUPP3kTbFSBrZHTsfvKrsnK+/0POOTPe20kiaUQhFgAORyT/90QvN0e6onPv90AAIAQw1TUCFgABAAkTwAARp1UmmgZnZgYzygUTMA2aAACzqLDMbgCdglPUcGTyN1AGrBGabBHvzBH7bhQOpHHFZJHt6hFhlxV4+mQbJhbvRhRWE1NfVhGmrhEv5ADsiACf9qgAMWwABO0jC1QBE2jhMcgSXDSiZvYVuBlOMcARySlG98NRtQovZkcW+idOaotErPwUpz7rw2JIVuyB+akhlEQRVAoRM2aV/5tV/99V9XoRRGoRQEFjgNlqz4Czh7CZh6SYF6KYE0wWEfVmzKZmw6QWzEZhIgYhIyoRMm4RHGZhIq1hIq4REaARAQbBEAjGwsAcAsYSIqgiRAYhEWoWUhwRKE6REM4RAsob9+U5jMBmfN6mAdbZiE6dF8s6w+oROPQTncwR/sgULch1aHJR0SxKl4dVTMARzQI1jVIwL/YRiFQRQYgQ3a4ApyYAVq8zYFIAAYgA70YBAUQREEQRD/5pZaI4GshpQTFGEQBkEQ+CdJTe3UBIRwYnBZ0hUnxsHmNEz3jMKxYM0d2mEfhnFVZAFfaYEWiDRzY8EWLCdzQddzQTdzRXd0TXdIQZdIVTcWNJd1Odd1Uxd1TZcWbGF1bZd1V7d1b5dI82t1X+F2ezcWgld49Qu/8qt4jze/jFd4+TV5WWEVUuEUTqHR9vVgT2GTWIEVUuESRMFVz2E9+GEorAElBIQ9FIRX9UzmAOeDIJBE/uEevuFY92AHlnUFOuBZdVQABCAG1OAO7qBuvyCApwAEUGALAthuBcF/72ANjtPUwPUWx0FAhvJwoTRKy6HmqtRKW03UHgTW/uEf/5ryGWpBFnzIFrbVc1E4hVVYhU9YhWnXcmD4hVGYdl+YdFe4dEnX1nT4hj+XhmVYdHt4FmhBiIlYiEF3FpAYiWkBFpIYFpzYiTN3FoxjSFvhiWEhv2bBiV/BirMYFlzheFvhFVxhjF1BFVShFVgBjFOBFVoBjdt4i8lYEn4BG84BHSi3HtrHG+AHH5AFltC3Vx1kW/AhPVz0jouBIcTAA5axAyrANnU0ABRgCww4gL8gAiIgASwZBDQ5BFAgCIJgCihZcWUCJ49zOyKFcCC4O9B1bzaMvdgrg8+DQWBtH8L2HrqGhHNhW3Mhl29hl315l3EhmHHtl4E5mI25FnDhhv+DmYdV2JhtIZk9V4eReYeZOZlrAYWv2YRt4ZptLZppoRaOWJprIYlnYZzJeZuV+IeYOInNmZx1uJxtTYjHWRZcAZ5nQRbI2YhrOHPH2RZ4oRd64RKioRq0QRjv4RokkmnEYVsQpH4EZFfrx0G05SDSIx8kcB/4IX4lASwyoAdSIAMYoADyVwA4OQQS4KQjgABQOgI0WZNRAAVCIKZfem8GdyeeNCUYsKZv8knHYZsIpzymBnHMAyiW5TxouZaxgR6igR6QoRe6whd8IRiEYaqDoaqreqqxuhiEQau3mquFQaqvOhh+4RfAeqyteqzROq3Veq3Feq3RuqrJ2qzb2qz/v/oXeoGtrbqt4Tqv+VqqvVqsqVqqsdqqsXqrj8EYELsYjOEYGDsZkoGxjwEZkKEZJBsZIhsZhoEXuiIXhgEbkjoariFRIIdeS9R90AEf2gFByBdqGBEzxwEdGCf49MFF3zcZRIEN2GUAaoCRc1QAdJQAgFulE+ADQIClW/q4PdmTYToEIG8FtyEcqmXPjmZawsEdTCIfwMEnjvN8fvpCgLpwCuenYzko3MEcIEceYJsd7GEaoNkWcqEXlkEZnEEZmiEa7NsZosEZnuE6omEahuobriPAEfo6xoPABzzAp4EaDkXAB3w8FJwaEPoaPNs6DuXBH3zCMTzDh0rDOZzD/7/hwz38w7/hv+EBHkT8w018xP8bw7+hG/4Pa0zcBE2wBKlhFe1bGn7BjO9ZGFBwxC3EEB+6Gk6pHfiYVoPlyDHzJ7QFKmZ7H/qhH/6hHoKhE3aALxGgAzTgAXI0uH17uEGAksE8zMPcgPfscEBFaiYE5tDhV2K55RrkzKfFzM3ccEAFaQILOgMZRNDBf/ABHoZPnnEhGZSBGZYBv/sbwdknvIqKHeBhHTCkxCE9Hq5l0rfpGsAL0uFhQ66lxE8c0yH90kUc0rfK00m91EUd0ifdQjiE0Td9HUpcQ5KCWOxhRZWi1gHrmwbH0dnhHXYdKmZNfjwboUdcwXvmGXBBFP9cgYSjARvCSzoKceWgnSUWEsmPvDnaYVsezvKenB+WwRYIgZEPgEcfoAUwQAJOOgG6HJO/XMzZHcylu84phEJcaFTGoRx+JR+sNkkNJ82lBbw/ZXBmDkK2xR1wghKXoRaY2BVqoRjiexmYwRlcFUCUYzmK6lTUYXCGQtPXYYZW/dYthJS8Yfc2LDoYq8QnHVtSvdMbnYVMvsSNAtM3vuM55CgSC7CuReY55B0aTh5mfUWJxdZvXtO7geNrCCq25uK7gVKw4r6TQRZEgZ5xARvWQauQqhBp9ZRWAq+ondrFQdYs2qIlsB8osBdAYQwq4AEMYAA4AANgWgIioJLT/aT/iTuA/1cQ9OAO2v0LGBHe4bzfW84cXhAfILin/Z3v/b1wivonIvcg/IfnqQEXsriMeyEZikEZlMHhnyHzAQQauKGo7KHDpmXSCUsq0gFb2Cs6XjmxSOnlV/7wh8KzUbzRN73R4UF+Vv/icZ7mWw3Xc/1afk/nmwJVcD7oHZ2FnMMdIGcf3gEdzsEbBtyzqeEZIP4XLlcVRKEY4OEcuIq8UMLIT2kgymvrqYrIXdSiBxlcjKEWEsEHOOABCsAAMCCmUfoOEkC4zx2l557uBeEL8B7Mt+DxAGKbwG3dBnYruC1cunHjlr17Ny5bNoYUxx08ODCjwIsHKZr7aC7dR3z4/9Kl01eP3q9ZslypwlUsZjJmzp4xewYtZzV1/vy1I8ft4LVr3UKGTOfOHVJ27NChI0dOnTpvVL1JvTrVqrpz69adu2aNaFii2LANPce167qpWatSRevWKryrbr2i5YoWpMmk7piyU6fW7rmLaC+Oc/pu3z58TrlVqzat7LRny5jVEiWKZbR17ODd88bNGjdxpLWZ1kZunjzSrFuLMy2OHLp3+Pb5W4zv3bx603J1IqOCQ4PhMYKgSIA8QoIIzJUjf748wgcQIL5Yv279sfaBgzVWYxjOXU5/7CSGqzhOo3qDhtGX+1jOXe50/vjRYyZLlipVsn4Ji1mZMzflBE028//4ow852mhnTTXbjPOeSSKZxJRT5IgTF1XcZBWaNR6G1Q1Yj4E11lDTTANiiN14Y01cH2r32IcZvnVXjQwdZZI5f21VYzeFceQjQ0+loxg+7aDj2GPfnEhZMbJg1t8028jDzz3cdFjaadqgMw86rrmmTWzotINPPvnchls+2AzjCR89WCABBSJg8MUdQSyXHHV6gsAcdNBFQB12X8Do4EYICfRYROMotAw785ATznkVsWcokByhF045mmr6EH381HMNLvup4gouwvyXjDLMLLMMTtCAUxs+2kBTDa1EnWMOOkgplY5TTT2l4Dkutsjihx5WE9aJyi7L7DTXKGtis9P/IGtstdZ6WBVGD34kUjmyAUvOjTmiZ46QsZW5mJcLTrPkZMv0gpkom/yCjTro8MPPh6O1hto87bwG8JdhyvZOPor58w9u+jgzyxspsHDBBSLAgMIXgvDZ3Aca70ldn34+J52ehT6GUaHbPEZQpOZMlA00+jRVznmbAllppQV1gx6E78VMG33+yLNOMaOqMot/MSljU6s5oaNYOtAsQ6BoUInZq1PpVGgOOdt4cw1kOtWa07TTQnMigc+cbbar0LiKNtnSnkitsYTCWC1B2oUDUjn8ihOphOVW9LeC2rRjcD7pkAbZkpQtc5m8qjhTDTn65JOvaKNBBdWW+aAD22n8/4Y5Zm0H69NPl+wIo8kOHFxggggihBCCdRhLp/EHzO2ZcXPO/RnBdiejnJGDOIMXjjg57ZNOpOOkA045lnJE0EUnPwh4OYuCRNs886TTzTKqiEKqK70Ik0wyNSnDak7t7JNPy1Grw83UmGPOdzh2g53T2frvz3//zPx/k/7x723SetbbPDQNWiELZZIqF/3CYR6ViUR55gDHOMxRjdOwbx+cE8dj6KE4Y9Tie5foxbSeIg53fKk06JCHOwSnJdPI7ynoKBNJEtaPfvxjGrJgRA04wAETwCAIU9jCFr6gOxBoTHe145iebLc75KynGtDbCEUi9RpoECl5FYzZ855nkP+PoAccmYpQmeRBDnNAAxfg2w9MipGMs6EPatBIDD4IlBNrCKs18yONRB6TP/6xSoCEtAkAD1nIROKRWW5bFoEY9BhJjaM1kVKeJSVyQTJuI4/iMNg+3hGbx8DjRM74xZM2IQpjdC1+7HgHCr/EDhcKLmCwuZBsZFMmM+FwH/HoBSjYUAMWtCAGQiDCFIo4BSYukTm1m44TOeYx6bEHeh254jhmBQ2SgKOC5fqiN3H1twuOw4KaCgk+/JEPcqRjG0LbT2ZQdbZkpE8btUFHq3BSjWtwAx1UYc23EAfIQJ7tf6yqDP8CmEj/JZSQbsMj2RyKx2MJb1FQcYpeaGgh2Zj/I1L4q4Y8ivQUx8DjWdEQlbxq4SzRtNCVU2ONadDhDnXFBhw0zcbAoOKOdpApH/rQh2L+4Y9nyGISO1CBMIlZRCPODopQpF3tAIU7J2pMWwf5kfSq6ZELFSgf1rOeOQZDM8JUFayAM0dX9ZKYT3LvGSPcjyx6Acea3BMa5FiMNvZnjW6Qox1SIU1FaVgQ7SQQjwwlbNr018iyIZaAy4LMiZ7lWLFRq1gyAg03uLIQdPhlV31xxzzMpJp2iOQgk8EJ0xbDvHNUAx7YiAYyZgG+TRRjHciCxznk8Y6mzO9CW2KH4G45P80yZR4kMVNP9/EP+/xiE4aQARCFGAMiHHEL/yFojhJ1x8xlYheqGNOTpayKkIOAxCMxy4Z8ysG8coBVmsIjDFmrV069KOYdR/qG0NoIE3lSBm3y+Bk0bnKTa5xjTH91ioEtyhBLCeQa2yCKUKoqva6BbVop6sY6uiG2s2DjHBv+xjo8bBevVNUbwuqROvyCFbRcdlfcktDVkvLZniCIuPKYijXWBg1reNId4FAtSX/hTlFMoxuh+YY65OG3o4AkKWaNkF4klJRc/qOnCfNHPaIhC0mIwQEsUIEJiCndLwQhiUpcIlObil1oMseb0vQRr8RYTnBkIx/uCEk4vhg9aebFPfGFT5E+e+UnuVUYxkCa0qrBU248rTKRWf+HrtCRK3bk9MBYA4yk/dIZeGgaHn/hTDzYEY9PM0XEPloHpzeN6lSnOtRMYTVTruKXtdgLKzxCi654tRdeDZenPZXxPl4mGXym9R1AsQY2piENXIACFZvABTzEEQ9vYOMbSOaLtd3xkHcoxShQxrV8SNJTfVRZJZ4whAcMgAMWuOAIxzwiCKKzp2aiebtpbo6P7uLe9bo5R002qxrH8Y6rkUOsbN5GXsTIkPf4GySK+XU+7vENeJHqrYVeFU7OoQ90rA19z7gGNtYh2jqngza5UYpoq6bZduR05a9GcVOSIg8XXruzsQy1zWMuaky7Oh4wl7k8DIxpduh06CqP6YH/XZwUbfNlHuHWh6+t/I1j4/O0+GDHZZeEDFegAhWiEAaS56EObNAj4EhR+q4egmuziiQk3iYJPsQt7uRieRJ1cIABWMCCFxhzutZ9ZsfobV16j/VHeDEHzs6BlAmt/SMBh4Y8ZIWOCyKcIYVBi4jBOS6F+3svntzHPO5Rj2e4dRa4OEYAaSWPe1jjbKyKRllum21su502DzmSgYmuU53HQ6e+SkpTJD1zd+Dc5jr3i6v5EvOc2t5XTImpSYD++19dbVfxSL7w5eF0BPXEp/64B2txDA1tFE4e3BgpNXwhCljsxxnzIHZK7jFyzk4I17tKR3xyvZdc5uMf/AdqPYKx/wmEQAYHcHc4oAPFZETJdDt+N2+AlzEaYxQewUXXIxI3Ml7XMw7sYDzkkA98E1+bIkmTBx+bsinwsRfeMA9F8g/3oBK1cAu6sAvIgBP28Cn3cA/YkCzfQA/1YIP8IGM90X9AJWP4gi8/aIRHiIRJ2BNEyIRNmIRNCIVGCIVEWB9EeA9UKGNByH8HUyUpAQ/0cIU+uITfIA25UAu5MAvCUA8IYxv40nBv2HBHeA9KCIT9ZxsQlwuloAhloAEioANEUExEtAWzE29NJG9qBnhOJnnl0i3wYQ58kWT2pxSo4ULltHjlEk6Lch5rp3Cb4mK9AmqxMib3UAy1YAun2AvMAP8N59CD9YBH38CDYQiECJMwQTiEWIiEPqiLdJiLU8iET+iLRfiDUBiGvjiLW1iLW9gTNvgN3/CFsphc2HAMtXCGsvAMa5gwtlGH2XgbwxiMUZiF9lEMsIAJhTAEE4ABQ7R3W5BMy+FM8vaOG6MngOKAEYA3/KYX3LJ5E8JtH6EU5bBN+AASOCJymNgrjGh/74EOzRMftXc1n4Z9+dAO8XAPPDQLFwkTzyA5PdE96dMN9mAmDVeLRdJwblcmqnEP9mCDKWkP9iAPKgl69sCDPgWHncc+ZnImvKiT25d9vnYwCJJ9uGiEcEiUQth9n1ENVFEPwsgP32BKtTALtYAN8ID/MEuYi1WILytpg/XAlV3plbFIhPVADbXgCY5QBywwAQ1gAkFABNK1BceRANPxBYUIj4iIXVB0j5fYiHWGXgPpYkehFBIRcNzCKwUJU9qGZC1WNZzVDvLwWaoRc1fofU6ZH6pQC6lYDesgD/GwaMswZJzGDjn5g/ngdjHnQsSnFvDgYc3Imq3pjDZXfThnmjmnapr2lV1Zm/BQD7WJaYHRFc2oFhZmamoBai9JEqaZeqD3hfSwLGIXi1eGC7IwC6oQDGXRlfSwg/SgmlFHD2VBDd9JhtQQDQLCDMqQDMZQaOapDEbzC9RQFtgQDKZgCYXgBavTAOpIRGO2HNUhO9QB/4/yOI+3s10fgCNGEYGPKBJGNyYH1kJOcSTiwFdooQ59IX29QnL4ADS3ZQ99MZuhlnr80FOgJ5nwQA3Jhgsn2gvLMG1RZxPOYFDRoD+TsTbPoCz7A6P94ww5qqPkeUissio+mqMBwqM08aOsogzmWT5JmipHOkdGyqRHqqRMWj7oSaVVip7FIAzBoKWn8gtd6qW/0AthKqZimgth+qW/kAv74Qqg4AvIgAzNYAxZCqa5gAu5YKe7YAu14BKuAAvL1gqgoAmbcAmDegmbYKiCikrNNgzHwAutkAmLQAc6cAEY0ADFcUxTAJeAch1P9J+FWI9+A6rpgBbbRqGiRhd/4f8NryYV53BikmYvs/EQJmkPTGGDoZaSWrmSPGWD9vB5pDhCsBCVpCemJ3qi1IgLxkqsx1oLyXqsxEqNz1oL+SGt00qt0upWlXmt+hFk8cKt3Sov3tqthyqugnoJkiAJhIqug2qu5soIjIAI7YoI8Sqv80qv8hoI93qvb7AHb8AGgTAJlCAJ8coIkuCuiJAIBssIB2sIhvAHh2AIh7AIhwAID7uwicAIjdCu7ToJk+AJugAMpZAJZmkGaCkBCgADMWBEQUAByKFEUjUdhxhv9IYx28Z27MAV7OAVo7YO7yBzfNF8UsEUrAoPXaFp8cBp8YCToKW0PWVcvZaV96APJJH/Q/0wOfUgCmzwBoGACOaarl2LroZKqIdaqIUKtl5bruuKtmmrtgM7sGqLthkLt3ArsHFLt3XrrnZLsPVar/e6sIgQCIbgt3+Lr3+wr29guPzaBnJwCI0ACIDwB4RwCIdQCIUQsZFLCHwAuXxQCI4wuYQwuX3QB4MwuYVguYSwCI3QCKsQC5DgCIRgBkfAAWlpsoKYqWX2n3XJMQ0IVUoBadjmDucQSzY7auagdElHcg+BW3sRD0Abm/IQmizpkiH5DzxlG702jP4wDzmUvZ8EDYHABv16r+4qCZRwCf8KsJNQCZVAvpewvum6se3bvoRKvpSwsZMgCfW7rvZrrvW7/7GP8Ajt6r/+C8ACzAj/C7eLwAgIvAgLjMAZuwiJAMEPDMETTMEVHLfxCrgZjMELy8EdbAiEYAiO+weEuwf72gZv0AYpzAd8MAh8ALp9QAiKUAiDMAieSwh9gLkzXAiQ0Ad2MAgyTMOjO7o1rAiK4AiWYAmc6wZawAIWcAENoADGNAV34o63a8V+J6AJUB1EqY0/mH1cDMZcvH/8d4TZKJJayH8+OJHq0A/ioBjCYLiEK7iIMAmDqgl3jMd5rMd77Al9vMedAMh3nAmZUAmDbMiZgMeGnL6FfMiLXMjsa77q68iT7MiNTMmMPMiLnMmIvMeEusecbMh3DMidoMeG/P8JpKwJlYAJLkzDEMu6RewIC+wIjnAItByxkFDLhVAHbrDDkQAJrOsImMAJSGwJmAAJnOAIgxCpwqQDc4KymIoctmPF/+lUuBMdyGExYJyEYczNP0XGtyiMR1glTciC2OAo/aAYohcKqzAKo1AKn1AKqZAKrdAKr0DPrMAK8qzPqVAK/WwKpfDPpFAKqKDPqADQ8bzP/JwKocDQofAJD00KDP0JDv3QE93QDV0KngAKoNDHG73RF+3QFF3RDy3SozzSJ+0JnTDSpMDSHu3SII3RF93PM03TLE0Kr/AKCl0JgFAIitAHO+wIkRAJipDLs2zEijCfk5vMOwAFfDDLs0z/uY4ACUgMCZiAuosAB17gAiRgARyAASKAslugHNLhVNPcqQEKArATBHqgCCTpdGdivT1xIN+Iq/wAh7eolVyJnXvN19gpdlEnntGwgyQxD9iQC64QC7GA063ACrDg2I8NC68A2ZFtz47tCot9z/jMCqrQCqqQ0PKMz1tnCgEN0P9s2gct0DQN0KAQL6wtChEdCjZt0zAd2yC90RZ90RUt0/080rS92xdtCqEw2sE92ixdCq4gz6FQCozwBz3d05zQCJwAzEddCJHACbAsw33g05vrCH4wuT/sCEjNuZZ7CHTgBSugAQ9gAiiAAsUBl8s0zdkFsx2T1iEQBHcgCIIA/7xbaWrdsGmmVg8fpoPT1p3fQA3d+Z0JTg3OOBRRd2zHNp7OoAzFYAzHMAwXPgxg2gt0qqzSKgq9gA31kDD6QA/GIAvACgt8yqcpvuL2jNMvbs/17Ar0zNisQNA2jgqbrQqoMDRbt3WYAQoXzdIMDdtEXuSxzdKiLdxHztAu/dK1DdsPrdIn3dsWXQoS3dugQNIX7c6hEOS0/eUf/Qql0Aqm0AkfDLoyvLmrYMSQYMQ//MOQMLl+4OZCrQjSreYzLLpFXAh84Ad1cAZ+oAYq8AAPwAIoAANTADvuSNbyDY9OFTJOFAIUsNaKIAh+EA3mGRO/kAyoYgxeOqxlWqzR2v8S+eEKrnCGdooLF2kLrnDY36MKguoJmtDHiMy+gEwJd7wKoHC/khAM9IB982AP9JBspk4qqkDZr8CnMF7P9pzPrFDj+XwKOZ4Kp2DtPr4fPu7jXv7Rsk3kQi7kxl3t/NzPsh3RR27ToxAKo/AJ7Uzl737S607RMe3R8t7Oqo3vNU0K7LwKq9AJ0e3LehDUO6wIrNvvMtzmRewHUg0JQ93TMiwIRfzmepAHd6AHXcAFd3AHOmABcjICQfAFKFBduaNMVkw7TiQB9z0IeoAHeOAK45ofouAS4+oKlIAKpnAJnlCuGysJ//uunZAJtHALnTAJocAKmmALqZy+8Yq+7Y7/CZPgv5jgv/S7CpmQCJQgCs0QD+mQvSxID8Igrae+4smO02T/Cvjc7Pfc7/hs7dOu7aI93LBt7qQwCnMf7saN0P2eCqtQ7uZu5O3s7oDP7hU9+Cdt0u/e0L3N0Pfu20heCqnd76OwCp9wzHg+1Ipw+QX/y0Pt5kDcy27u3Ho+CH4gCHmgB9atCEegA2CgBjqwOmr9ligwO/Rm8s20JyEwBXqgB36QB6D7CPRbCVBvCZOQCBvbCJMw/JaQCYyQCZbwCM7PCEj8CI0QsYuACYyQvgb8CJ8QC5kA9JVgscT/CMH/wIvgv9b/9IjQCJQgC9PgWTlkDzqYbNT42Bd5kZNt//Ywrv84rdn5nNB6DxClSI0iWNCgQVKnSCU81dBhKlatJLZKlepUKVMZTZXimIrjQZChQo0aGerTyU4nP4UipXIlSZExQ5Ua1fEjyJqlUq3iuWqUJUKKBOnRM6iQH0WKChXq00fRKEhKHRVyFKnQoEicjtoZpGhQHzh2zEgxE6cLCx1CYGC4IIEChRAovswFASJCggh59Ub40NevXr8f6tZFoUfQHaSKDh3CBMkSJk6cLE2GBClyZUeWHGWmPHmz5kaQGiVadGhRpUqZLD361AnTZEqPDC2CtMiQ6UeLaFs61AhRL3jk2s3r1+9ePXq/cNmiBQvWLOizYk2HFav6dP/q019t5759IquKPXsePLWqfHnzFmmOcthQ/SlUEFtxr9gwIypUOit6XFj+4EmTZHJppYVGQWnAlUoaiRSOOrJIvVEY1KmnVyzhgw9OIhFEEDDuwCOpPuwIK485HPFjDkHyUCQSPfzQcBA66jgjjTzSoGMOL7xQgoMKNHjAhAsaoEABtyiYIhIkv7ALhL/24stJwOqKAIQg7tDjjjhULISQyiYbJUNOCFoFzMg4cUxMgjiJJbLX1OQJk1FWieVLnsL0Kc3HIvNyTUww8QkTUJ655x5+/tlnn3/uoaeXXJiLhZZZnHOOO1i6s7QVVsCrKCJMU8Fvp1Uq4mghUkmRicH/Ukkt5aJS8iMFFFFcmQ/TVRiZpJNOPAklFVPwQ0WjUEBh0KQEiUVQpZQ+IQilZAGUqUEHPRIJ2gZT2S4WR+pwgw488DAMjzmYMuqqM/Lw44wZ6YhDkTXmiCSPQfSYw481BMFDEDrMmIMOHFTQ4AIKLmCrAQlCMPgLDQdTeDDBmPwgr4fzwsuuELYQxI9C8oAXEqYm4wSyMu1EMsNIKgvzljk/jqRPgvr06ZZbSFZzTjHDHCWrkSEZJWWbM5nlG0Xr8QefQ+tZphZabmEOUugmfUXS7iTybiKqM90PokxXEWihUVPNKFUGG8IIP1NaceVsVmK5pRQ2/tCJFE/3M8XU/5hIFclUUEY69liTkg1QppmoFXw/jkxZ5ZU5ARGxizCuGkRjQRTJoxBF4PDjciW86PYMM9CYIwx777AXjUHWQEONLvAwAwccWrhAhAsEFhiFEAQgYOG6+sI9d8DwyiuEINbwQ2M/7OADkkjqqGzlMSMZMzKcHYFkM07qXDkSRzJs7Ho3S2YT+gwfwwTJkh1T1kxIMOlEFGHqgQceeuwhOh9scnHlFeaeey7S7ZzDLhZLXSoimSJgAcEjEJZAq1Qa0Qi1uIaRVkRqFrSwxS50gYhK0KI5qeiUtPJ2N1Uh0FQqiclKBtQJYgULFCv8YOAEB8IHNkhOr8AEIOoAhzAIT/8Qg+CKiyS3Ij90xV56OAMe4kAHdq0hD3GIgx7WsIYucIELZqCDDvo1ARGsJXYUEAHtCCCAiSlpd1PCXcTwkoAQzEUNajiD5QbBhxBBJipIgkTzSkbH8iEve5xwxPgicTM2WaZ8VfljmNCHPOwRsjKjaIz0MKEJVUiDHu/7hjqG841jwIIm05lgJyv1P1AGkDuseAWmCggqrakKbAv5FQO7BjZWwAJStkBZKBARiFc0B1P5EdWpUtU1wJVwQCJZCQtbOK0XsiSEHTncKBxhhzKcoV1dEB5WCqEHPOSBY4kpBB0EMQc8oAENeoBXitagBzqIswuoywMXrHCEFojABBj/oCdcaJcAfCZAd0zaXe7qIsa8SEAuX7gDGNTghTJ4JQ00Qt70cIYzMymiMnXko5kMadEv6SxNJZNeIXSGM0VIT6JzrIwck+IYScgCG9943zXUwY11UKMWk3hEH2MRHQ1aBzvd+Z8oOWVArPEnbK8k1UYaxLUQkiqWiNOFLTShiUoY4g+asAUBCbdKumHVbjBciLEI1NVTERVsMvQJIMjghjSgoQtouBiJzAAHSPgBDnEYBBr8cC86TBGbXZjDIAahhjV4aA1hCAMe/KCHLtBBD0IQAQZCMIIRxCUE+LyL76BExsHkRUpoREEQgvAF1CV2EHAgrRe00IXxTW+i5ENS/1XMhLPpVWV5YUrfzjIkPSStiGOOSArlKBeJcSmiMXk4ZyEOEQhcfOMb5/CGN9RhDWw0gxF7aMohRgELVUAHlJIK5f8qVUoDAnVrHBGb4BQYQ2qhwhWPioUugBGLUqziqdVpCE9SYapUNSSrpeqaCFXpVZYEU5lbGyu1VgEJN9hBrnholx7CslDDpgEOacBYNgWhL3R9s155MAMX2kXYLphFilzAAxhgYILIxiUIkz2jZfWST73gLi96UMQXrGCFNVphoXQ4QxfOIIg1SJS3QtatREPqFcoVObgrKiQk+nCVb9ohyZLzQxzw4E3KDa8OSuHQFtRwhzokYhjf6AY3mv9rjWtQAxdvcMNh+WCJV7giOpHiLiipI6nvviK8BQyVUNvTHvwI7iISChsqwCNLXgBDF7d4RSpo8YpT6LkiWCWIQrSKqgQilW4BaslXf3lU9N6kDmXogx7CADk7oIu0V65yHuhwVySaYRByDcMcbL0GPDAuDKnjwh3MoAQr6EAJ8YQB7eKCgsq6OJ+UvWxlI4CwSMRBB0dQgxm8IAUmmBYNtQ4DJPyqiD74tQ5PvhwdzIWHx9H4XlKWnLs4EZZBQCIPvNWCu4CriDjAIQ9qVQMTzZAHcg9iClMgaB00IY1vrAMd6NAGNK4RjUu8AQ56iMMZDoE46GiQztfJDp6dNjX/U2ZKIlnjiUBW9Wf4oIJVDVKIMlmScoq0wr3EAIaibSGRULBCmZo2VUq0CsxMo6pUynQWfwUX6p1wwg1uAGet8WAHL5DWK5xjolpLRoc0zEERZjBDDkmHpRwSdtdxWCMdrGCGLpigBTCAgWdZvGzLwv0uEssnARLwhaSoQQlm4ZwWpDCEIZzBD2gYgiCWkhSpaOiw94qEH4byeHIaRQ9cuFGtBRGZDSFpEIfxUIvu0O8r3UF0XlFE2w16CF/Qg1D++Ic/FPULREBiQ0IpBCeWNkGmbRzPT8tzKav2005lSiEEXuXc8JvVuvWqlamABS13cYtZsGLTxhSwTIS1aVLt/21ZyEoJrpqlkmPuioDiWUQfODcHXK+IDnBwSrfMLU43Yj0NjLMCYY9gBSYqwtQ0RgMdXh2JNeg6tjOBztqCyrKLy4I7BcynKcCSI+CCOciDi6kD3jKDQogENZACGps1iSqZQrgYWzsRbFIDPLgm0dkhGpsDzzkKowCXWVMRPPi8LxM9csqDK9kQEnEBIegCMkiEZqAHfuAH1puHa5AGUTCEQbgXJHOER9G4jJuz3QsgTKGakRsgqzG58zIVX2mlo1uIuYkPiUAFVjKFu1Eh6nO5vEnDugEbYhoQA3EJXCEhYgowwAEFigiV8QALKZACNDAdOoCEV7ODLkgDI8K6Of/INzjQOjiQgiNgHCXAAcpbF0HwnCC6HMC6MSuIgbYbgc7CJ95JwAVctoqxAiUoxS5QhFjAES2AA9OKg2szDKHYkM2LAxlkoiYSvTvQPyszvKTYEMO4A1wDF2wSBEi4EjAILNF7osBSkcuxgxSYgR9gg02gBqHhh3vQh3j4hmJABEA4rBNkCk7QIFq4KSfUPY+TlLNJx3RUBVXwvVYQQ1LYQnkkBQaam1DYQo1AhXdEBXZUBX2URzEMBVEYSIIUyHiURzLcuaT6pVVKIAUCSHa8w50gCEsYgxwxgyfiOjMQETfwFiUAF3CaAzg4A9LpMGpTAy64P66zgqGgRBqrMrT/y8QjGLgVmxgmAcVQxCcJCIIpiIEWeMB2oYNHHIIekIJSrAEcQLduIYpC+DKyI8EQ85YryQPR64o4uJh4K4Q1UANuwSYSWSPR+7IruZI4AIMOOYw8qAMeiAI2YINZwAZCoQd6uIZpkAZXYDPFOgzDsANUHEfcy71zPEd1lIh+VIWRww+uKhVRAMhf8Rr88Ed+9MdegUxRoJvFZEzMvEyyIRuTkxAEKsOYEKGKUD6AJKD1GIVF0AKu84Iw2EU7AIs6uJwuALI4mAOSPAOy0Mg1iINdk6IvG4ob8YM76IIkXINBCDYraIGB88QnwUkYgzsUKDYhaAEh4ALGGYIuQMoa/yhKHcEBXPSWQbiDMDCogipL/IuDIFMExxNOfcODDOkKJwqDGfw8wlIDgwKDLrCSguoQdOIxGQCCMXgDYqAGucQGajjQY5iuOrgDxUIRyakD28sljcs9c5QFC1XHdSxMdkQFguxQD8UPgmTHgQTRxezHEj0bDh1If6RMD21RF31RgVwhkSBDY2KhUKDRg1RREx1IWUkFZfkSPnADteqCsjCsPigeODCDNABGxlGrMNg2cOo3wLLOY6SDMCCnLiAnKGLQvesCIVACHahJF2s2KFk2uSACIhCCYNMBHTBLJSABHXABFcABFqhTp/xA3lwnwLJPW1wnGLmDzbuc2iwEOP8QChXhzSeKQV/UT7MEA7I7J8PwAzPoAR4Yg0NoBmmgBmzIVGpoBlp4gzKA1KawA3yxA0P4HwqiUDqzUFbF0LPRUH980RaFVVkd0Q1VUVFg0VrdVVmFlYGEFV8lSGDt0GDNVREVFZo4sDaIAzTgOsCaKzj4ikSEA2BUK3F6UjRYojC4Ay4IAy4AAyuIosQAz6aMSTXQAThtARSQAN8Z0xdz18qqmC24MQ5gARPgABzQARYggQfQALTYEX89RicSnadUAysA1w45O8M4g3lJgyNyBHjJA9uKNjMASxrTkPHET4NKAy/AEiXKAy8oSinog/aquVvIhVpQBUSwSEAdhHH/CwvSkoOZeRRbWBondA5WbdUMLUxe5VVVeFFVcIWf7VmiLVpR2ASkNVoPpQhW8AlOOAQ30MguODs4iJEb4hzG4cou0DW1kiKDUgLr1DsXSIsjQL/BY6Jw7QJ44gAScJ23e9e5SzaJebGCMQERUAESUAEO0NcHsIAGaIASWAAXsAJ+rQAGwL9BYCLUWaP7LEsvu8rDOKckjVZzcbUVwTcsQcn6i4ODTUYwCIM0kII1MMsvAwMSyNc1YD9COIQ/MIQ3YIM2KAODMqwLSbWsc4NFAKDpWJpa6N1aiA5Z8N1ayFnitVBVYNV+FFqhLV7mbV5ZgA7nnQXiFd5awIXqxQXs/81e7cXe3t1e78WFXMiFXhhfRinfXvgF9CXfXuAFXhjHV/iERSiEMSCD05paYdvaNmLFrT3YNXhAxmEw61Tb+6O2NZ02lFynNZiiGxMCFtAAElCEKVCAEEDAZFu2uN0LfKKdByCBFOgAC+AADjiCC1AABfjbv1UAARCAAjhcPWBc0rXPO7ACYHyiGc6DdarPEnQEPYiENRmszMUSslMCNWjNwNo1JTjG8YxhEuS6NNADO0iwphg3jbmybLKDOSBVQQhSynGEUdCFpsIFYRCGYiiGY2gGZogGamAGYxDjZWAGZ3iGZ4gGOZbjZ3AGO7ZjOJ7jOXYGPe5jPeZjP+7jaf8Y5Gk4UEM+ZERGZGxYZGooZE1dZEhe5Gm4hpWSS0v+BkYuZGygB+SgB2qQhmhoBl64BVrghDYYgyjgASlSgiHAgSHo1q3d2m9lnKk9WHC9v1mWoqnlAhYQgRaIAVI8AmEGg0EAgyPAARC2AEGIgQbgRM8KArugLAteNgJwCwmQAAt4AAb4kQtYABNogAmYgAYgYREAZwUQgQm4z0YFgy1o1Cn4MhqG56nd2ibKiqvAN94c4m3dSrPcWvlkHCEgAmqy5W8F4iNiIhu8K29hokOsTamcgyb2qz54BF3YBVvAhWAwhmXg40m2B3p4BmZQhmeY5G44B3aAB+VaqW5Y6ZX/vgaXpktCHmSYlmlCfumajumYpuSVWgee7ml1WIefVgd48IZuIGqjXmmeZumSPuqjvoaSZgd7GBRCkQd4OAdrGORuCEJ7iIdueAZpGAaYiYVFcAIyYIIVUNsXSOtXliIhEIIjGAK3BlchmAIisE8XCDv0w8iUHEAT0AEYSAv80wMwYGAOcGASmAAYiAEUILgvmAIKpjsFdIsHmGwGUAALWIAFUIARLmEFWIACIGEFIIISUABwtWWDsoJ2NthjXGcourEuOMZyMyxwIkuNxUT8vDH8VIMjEIIh1jVv9VaMPCJvMawl0gOuUxeGNpcq2yGvAIRVAIZZqIVeMIZk4GNq/7iGesCGZVAGY+BopF6HSFbqbnhpSoZp8j5vl4Zk8nbkAyXkRVaungZqdZhv+lYHb+AGdTiHl7rvlT6Hc+AGANdvAc/vl+IGcuCGdsgHf1jwBa+Hc6gGaICGaVhwbOwGPs4FmFkFQMiCKEiBFeCCIUjrF3jl3R6CI1DrIwDXLdhtfRWCO2g8PDDYXRMCEzCBCcCAFpi2IzhiHAMDF8jbDtAADli7KdiCL9iCKfAsKXnXBKhmCSCYyX4AcgbtCVCAG6eAAiCAEx5nBRg4hDUoJPeydzbLLXjtNQjXgyXBO0grFDGirRxdg+o3cEWdzi0oHNtWWoRzaiIKOqgXw0In1f8hUiUiivUMzqXgg0bQBVqohVwQBmNQBme4hm+oh2lYhu0eaZ6WB3lgh3VQLv/+9PHehvWOaVGfafTehkmWaZd2751eB+bK74WL9YUjB1qvdVofh3FAB1oXh1qXdV3fdXJAh3nQh39oPX/QB3WAcAn3h33wB3a4hmdoBlnQIE4ggyuwgQ4+cRKvzigSZhdoRC54ASuYAhdQgi4oxSMQTx0INhcAAx345gZoATglXCs483DtFwvQgApgWxJgO54s8iMPAhSACwqQAAUgAAKgHQmQ8gfgACnncs6eAAqo8s4WgTt4AXH22vp77SEGrMIiu3Viokbl+DUiS8QARvtkXPv/nAJ2rnODCjH9HCwavhJF1U/0zNjPpUWi8JAmMpc+IAS1oQVc+IVkEOmV+oaQvvRp6IZ0aHpzGAcAZ4d0UIepd3XmAup1IGqnduqVRjOn5ulzKOmw7wavJ++Vdq75Zof6XvsCB/AAPwdcNwdzkPVgp/sDrwZtQId3yIdib3Znr4ZnWHZEaYdpiAZhUIVxXIQf+IEVqAEVOPEj2LUH9FbGecCULHcw4IJp0wEViKJvf3cgWQsbx4AjYNN1fyclCAMXQIsOqIAOYAEQdp3ZaTvPUuwR/qLQboG+jfKDB20rx2zQJoACwAARsAARWIDMr7/B2lYP6bwWBqxklPOSv5cW/16ndW5U+1Rxlt+C0YVhYKzFN4fUz9vK0KI/YDvGmxenPgwLSKAgW8iFY1iGZ7iGe+gGZVCGNp7keHgH/ncH/3cHgGCHjhy6gujOeeOm7txCb+fOdYt4bh3EhxbPccvILSHHjerUGSx48eJCjBrPjRtnzlxBdgJDGuRWTRw6fPn+/du3z588a9CeTfO375+8adF6qbL1io+XIUNwDOEi5EiXLkKivhjSReqLrkesgLWiQ4UKJVx0CBFSokUMExhEtNChQw2Yr2K7KBFCokKKFR1IsHBhgQOHCxcmIG7AQQMDBgJIHGFBgsMBBRxMKCCgoMCCCQsaTMBQYHOBCRYWXP8As8XKmjVg1twBQ7f17DVx1tCNoyaObjBgpqgm4tv3lClbVG8BfnwKXdlq7qhxHf0OddiuwVhRLYSIFSJEpoStyqWLFbpdytQZZasWrmLOpn27By2ZMmXQrp2TJw8ff3zz5uHzTjvvzEOgPAa1kyA77cjDDkH6tdNSO+6081JBIIG0IDoJJlhQOu64FOJH8bj00UchouhSQeSwSNBB57Czn05D5ePPPeo8www0+QwVzzTM1KJKLJzU0dQRQ5DABRdHTOVVF0ccMR4YSgqBgwtb4WCFCi4c0YILbYlwQZgmXMACC0ooYUJcSoRhRVUr+KVBDRp0kEIKJExWwQMMHHD/gAYpqLACeWOxwMADF7TQAGkLMDoBBSIoEGkBoL2gmhph3OHmHWu0ScQRdX3FKXZKvAYdcVZsAcNxVoDnXXcxiBADq8VlB56lvrmpRnRg8JYdEcnBAMMU3n3nKVhKDCGEFWkN8YMjsaz3CzPT0COfMsss8w0869zTbT78gAuuP/r4U2654aLLjz3r2tOtu+l2G+676t6jj7322hivu/fUY0+//7arjz356BePO/bMU4888cyzbjzxyJOPPkPhZC8/8DyDLTr/6LPONMXIIuQiZGjBBQkqkCDEVl11Nd6STG6Fhlho4bDCEWGYkJZbGGBgmJgL6KBmCxwcocTMz3Vh/6edGqzQF5wpVOAAAwY4UIMUNphhhhVKuKDDAw8ocIECDXx22AUYKKoZaQWcUEJvm27hWhjYYXeErmvokelXr+GmBq1gFBuEdzHAQDgMQqjW3RTbzepcctnRZUUM28VARAwtCEG4CCYcnlYXYVjFqhUuzCDHKrPUkks039BTzzfTwI6N7KzTAw/t9NT+jbat14O777/jDg/vvNfTe+/A43588cXvy6/z9Twf/T38TF899ddXHy8/5nJPfT3YPPMMO97T00stsKziRg9SLKnDGlUd0dVVXYA6ZRd4zLGpVVy4oAILHJBATSIYwQlgIIIDYkAIGHiAXNSwpC7ooGhW4P+ABfBEAg2QYAMb0EAGKlCBDHRABTgoixoUIQgzKEEHOADb1EqDGNRMgAAE+IwCJlCAGyrANdmRTuSykx1B6AY6R4igd7YArO+winAoKBwMTLBEzlUuBpPL3HaQOKzv0Ko7lguWCTZ3QBHAwFOey4MVgkU4F9hgB524xS5+EQ3cfYMa0XAGM5qxDGU0IxrS2CMfqcHHPfrxj4KUBjUKachAGpKQhQTkIRt5SNlBEhuOLGQkdce6S1pSd7PTFjzg0Tvh4U6S1GhdKH+BC1usogxXoIKyQNWVZL2gBEOA0la6QB0ugEEPoBvCCoSghBKQIC4w8E2wGhBGy2FODUdwQVr/uJYyF1ywgoTZgAUq8Kca2GCWLtimDuJABzMIIYKCUYABariZGi5AAATgzGg8c0MhGLEFrBFCC4ADubgpQjbFspwJvtOWIMQABSjAAAUkIAGfvQUDXexiCwrX0CoWR1bYkWJbWvCWzZkgo9vZqKxasyzOhdEGPDhEKGDBnlz0AhcqxUUtWtpSW6h0PS6dKU1nulL2rHSlufjFL3KhUvbY9Kc1dWlOi2pUleYCpb1YKlOb6lSe/iIYUhWGMIZh1WU4wxnNOAYubnGLSbShDHTYirLil5X4laArspSKU6qytchIRgfBZChdRNAzGJQRA2j6HwuWGU60lMAEXRIBBypg/wEMQmkIXAIODHSghDhwIhJtYhIJpsYARi1AATRc5w1vKIDRlJFzi8NAEoVVHEFwIjZg/KIJghAEt9hVAg2Q7dgaYFuDiimhajJc4bjDKuIEq4lNbAFxL/fQylmOO2ghggmkeAQcZIENf5CEKEShCllU17rZBUV1QQEKT3hiE+INL3nFa15NmFe8l7jEJta7CVHMAqa5uIUtVNHe9eI3v/rdL3/1KwlJ9PcS/x3wgPkLYPyq97+IWPAf3KAFL+ASLVcZQlpf4IINKNYFXdnmEEmwFSXggAPEdQEHRIAWAl4go4S7wGRYoAMXh5MIOtimYNfAnTsIoWuJtaVxPPViP/9E4g7kIUIJKnCAqU3gAgsYzZJtOKnOFmCJGH0tDBR6ggIKAThSvEBbBNrcgcpWtradLQV4VlAJvAW2IJUiDFAQhOLA2XJSRAHhiEDFYIHxmHKJyxGkOCwheCEKZXgDIiTxXlWIgruJ9i54PaGJR4v30ZK+RCYobelMPBq/lKDEJSgB4E2gwhWwgMUsYEGKTaN605NYNatbTQlWV6LVsp7EI1Zd61bX+hG6fgQjGLHrXRNYEr7WNSOEjYhABOINf3gDIOTgBggL4QUpi9IrX2ABDW8zlhqWC5TkaoLB6ICwcdmcZygIwAW4gAEcKMFywWIlp4A4DKCjShiUKRcRbAf/SkrogiDWkJ0hFuqynWlAATRTgBHYcAIEn1QIJKCANrvlAhJAgdjAOAIwwgoFInhiF+06W0WNWQJl5plCN5fmNkcxjHBeOT+DVazMES5zMNhmvrVoxH0rghOfKAUqRj0LVaAi6KEIhSlC4QlQhOK74FX6JsirCUdL+umauIQmMoHpqa+X01S/xCQ4bXVKW93qlagEJca+6VjPOu2/3nWve832tici7nKPuyEWbIi7GwLZyF72G/r+hzpkAcIUjgqVZhltlh2JBC9w03N1sJYSiIAELmjBZFxQAtAYgAMuEFoYdEAYekJQB06pmWKHKJavqMEKQyQuB1iTQjOE4SvE/2IMYjwTKYVHagFCEMGSFxCCSGEABSFQKAYMalsMnEAEFCjzCDAwArdQoIsUiJQMI1Vbkef2bCenM0BVrpwpBKFwhJNiloXAxCnCIC5oQe6wVI+DQcQi/rSYvy1g4YpWqALRia4uKbqbaPA2nXk1WtMBIAEGYHq1FwIGIKQ1XaahFwMq4HmdF9VFXQViHX6FXaVdQiVs4H6RnSWMHdmt2ihgAhlQwRB4QVa8zJEcyRBYGJ5oWCxZAKKoRQlYQAt0ieIBE2Eo2QQQQQusReuFkws0gA7EQBgoghecwRzYAA5wQQ2Qh9EcC9ewgFgwwdV8Dhd4B5SsUANYgMI1wFukTf8B8B5oLMDyoc0IGMZtUUCKCVcMXMDyhRnPwEpmEIA6Vd9siVnxGdQBNZQZNVEM9FhxhN/5SRERhJ/lwBkMvAARvABahNEW2NmR/MAovMIrxN8sxEL+5d92fVcERmB/XSB7uZd5BRh+XeAonuIqspd6oaIqnmImcMIsdkItWt0rLEIUXM0QIEtaRIkQcIFilYCGkUAJxA8FdRG75cxaCIZplAAATd42VVBgVcAyURAJwAAX+EEV6IEizFIXDIEVSIVULIuyONYRSMH64MC+KcuyKAEHfEZngGFm1NbtTUAXpVhGYUCVmcAIUEDzhYATfVFoJJAInADCmRM9Gp9tSRz/QeXj8wUfCowADJyAPwVB5gjUCQTBFsTAm1FUrHSkIGbOCcRFRU7BCLRADmCBI9wCtOiCLuzCLMjkqMHCJb5CK7BCK7RCKqTCTqbCKaCCKQilKQSlKZDCUR7l0CmlUgqlKJBCUCKldxElKjwlT+JkKrACKbRCUIpC0HmlKqSCV5LC0AklKUxl0HWlVxZlUh5lKYzlKcBlKcilXK7CKKwCK7ACVtZlGVCBF+BBm4gjk4xOF7gAC4gAMKEFebyACGzBdpRACQiBYgjBCWzAuqWFXkRG5XHJNrGAYc1YCWxADL5AtBWjEFxbWrgAiDUFiOFAGOjSlATjEZQAo0yfOd1h/2cdgA0dQBse0AXgGQKh2ZlRwJhNQPO9RfNNgAIMJ8HV1pgVlJiEiUJp3ABtnCDGwAls1BIJIvgh4giMgEQGFECdgJu1TVog4uTkQOnEAi141UvK5EzW5CvUZCtcYk76JFwW5VSWJVKqJVKa5VDOpVuOpX5mJVa+AimkQimEglqqJU8G3VAS5VAyqFdKqFi2JU8m6Fyewipw6CvcZSpYIiaMARVwgRrgBZrIhWAUpmSQAGHBReaEZloRRgmYRldMADBqGOUBkFy9WAQBBgPgybVZwAaUwAkw0wtMwGh2BZE+iRl8UxeowAbkgSDggZJQmwuIgO1JCjtxxgtwwQYUgP/EcU6KDdTHLV9BMWSWJtlyKkqkDKf1RcptSVwDtCGdjsDwUYBEauQUeB8RENAIUFRAeWfztRmdHdPhtMAAncBoDkEH+IAl2EKkuud70iRNipr95R9+UuVTooKm8ieDZteEBp1ZMuhOrgIplMIojMIplAJQAqVaviqsaqqobuophGX+NahQyqVQbqhNfqhdEgITaEFVoIlZFA3XTAWJrdvmYI5eKJ61gcYwcsELcEBajKaXLBMO4MCLsYAQaB7KEAYJIEZlMtNUUGa0cQCjlgUaSIESVAADXElWYAUXnEByvtDxUcCSNQCnhKEEjGlCGRSaLWSZZemZalac0imcIuz/bBXfyG1cCCjcldGZIvbYeRqqQEmkd+7jAL2ZoTbXD04FF3SADPzBet5CUr1nqVWq/dmfKwBdp04oT8LlrNLqhBZo0NHnK8wCLcBCIGjCK/wkK8wsrE6orcrsqHKqhb6qKugkWBZlgPJcKqzCJWJlKazCJ7gBD5gFeZjeVzxJ0UxeMHVNDHYBy7TNYDBTuj6mhpnAyeiABQyRtiqB5HneuuHJY67bC3LABrwAk3TFCtTAEEgBL7oAvHUFGICjhtVr7fXgkt1QZSTZPi6UQBLUmYncQA7ncCYGyI0NnIac9kVkPyrco4wfQDWiIHrHRF7cAL0FrATBeHrHCVBUcQgB/26YTAfwwCh4FcpSaqW6wu/+7sviJSsE3fAa7/CqJa6qpfHirCqI2s6yJy+8QSjYAi1cIk4G3dB65czCpczGas2igoFepVsG6CpILSu8Ql6uQii8giNkQQowE1h0rQ5oCYwl6uMBYd9a3mhe5jKBZrqWJhGsFqJk1BYoVIqlGDAtaiwt6gmsW7q+0hDYCQ7UgBOiQc1Ynnh0BRxuRhhaH2JsxgGEKfF10T7KociFwPI9X5h4RpLN42hcX5welPIVn29WWRwuX6yMwEZG22QWUBCo7gBlbBj5GZxtZPsdgWsQgQUwQAYoglfhQi6krMqOGvAGL9Pen05qMSocL15yIv8ncjEX2ydehu/vklot2IJX8YImxAIv3AKpvYIrEC8ZL29YZu+Eviwq5LEYGy9Pli+HTi1eJqhd1kEPpEBgeMlUgEFeRAaHPWMwDSN2FinLII5U5FgDWFhX1FOiXlEXwUpGjQkRGGlafCEFFQAHnECUTAkvmkVTEK6GOUVaGGEMICRoWN8NLVluFlRBoU0YNsDZBKdB9cwvE1TPgKGijK7xodnmDFQc7iMM+GNCSdlx2NlkjoA/BdTEWg4K+KmwGBFHxoARxYGVCoEBGEAFkMErnGwu1ELKrmzLZrEVt8L9ZbEWa3EfY6g9Gy/wygItoPEbI0LfeUL1qqw9+6RV5qX/gwZdT6YCroIxWPakPWNoKUgtIHMoTrJCXZJgFNQAM4Ubu/mQ6iXrtg6jXDhiD+fYaMomJl+Zt3aFDghw5ejBFCAKBrRAzhxQ205AWnHBJFuABRTpZNYuF+ybGbRrGBSuC6qyFs5KlSUnO21pZjEsaEyAmA2QHlJACIBRc2FAkqkp49oWmi6zmaHZ5DqfXUnRCWjHdkzBCUwBrHxnmwGqEgEqcAxLEHAzXkXJEYiAZkxABkCCLpxsO+8sFdPkJVpxYit2Pevz8Bq0FgPve6YOLRwdKFyCKlDxYoOlTkZ0RGvxF4N2YucfZ2NoaQ9vXa6CIviADUSQ4zUrWISBLzWy/7dmFHcUx2jyj4Z5a9v0LTXdaLgJi53pQRmdjZjYGRGsm5319AsSqV5MgIbt2+itwBAgteXJ0lSgSnHc8DnV1g0pykHJVnKOzcidWQgMn88s3+hSgMK9kJiJTQOECcEKVJmh4cYFAQUI4usuMAochySKwD7BAEC99QhswRcAlHiagFbwdXHGgAsQwkuyc0vJJM/GQlkS3aYinXdpuHcl3YZ3eIcvnYYv5dCJgilwoivMglfZQiy0glCigidueIxzeNI1WgFKYHqJAgKKQnh5F3rNX/zVZR20q+rJRb6NBwQNIQ4s8Y6GhfyoRTF2RQZZWAWJgAUciov1lQ6AwQMQhv+ItQARaNgRYGcsZVBatU3buMAKqEAXmAE47lswblO2bQewgDCU4dANSZwCyNYFwLdYG5R3tiFitKFhpLdtKVzADl9GgTLJBSfPFGdMg98BdQUGFAegTiQFnOd4Vo5x4HU4X6cJpOayXFwMcAEZrAIv7IItyMKEz+RVEiWGnqVZHmWEoqpR2vp+zroplIIpuGr4YjH+oXikVi8s7GTQAZ0qDOWCPmiyy+VYMqWMK1p2Sbu0i3j1xsLUQoIX9AAXLMuMKQv9zM3MnMxpWICJSQ52WutkdgUAAdDdcsAvg5u5meYDmElhsMBgdMUJNMAwCsEGFCNQb5gIOUW74oVTUMX/Mh1Bv4ny9K1TZnUWaeCwopiAwArz8KUwz8Th2RzQyBkGYpT1EhmQXWmsyGesQUKzIFLklX3klTXwxiVXDICBgX9nd4ZROF0OCmD6ENzAIrwkLbgCLbB6qd2kTmaxTQ49fWLlT9qqrc4z8DY9Y18isdPzPMtnpaYvXs6zPmOlIGNop8YlqiJt0uoxaBO9V6ZCKJRCXsICLVz7KvRBD9hAXmirSZ8ezdSt0ADQ4V0ZicWSWlkekXLABPAeCwzNp7wtu8vF216AWjjwoi4TiZHAAhupEpxBF1Bwwa9jMC5JCXSBIsy0KLcp2WBWZikABignXIwJDn/nnT6KXfGMQSbf/8VdHBqGrqIX33E6n/CJAEA5X0fa1ZWBkZ82MHaCUfgBlBGBpz9tFHEFCwbEUg2UwSroQixQKtADvSy8cxXHcRyzrNHTp6iBv9O7rBlXKrCvrNHbZHzK5/Xe5NTfs3027bFzItEDb9XfpB9P7SqwvYeOAhyAGF4AxJEjQlyYaMGCBQ4XOliQ4CCiRAkLJHS0eOHihZAXR15kfDGh48QXJFxY0cFB4AMLLDioZAGGxIMJJcKc2FDCoRCCJDqSwFkDhxIpUnAMWSEw4xAXYNbc2TIlBoYJCqg2mNBgQQMKJiRgQCHERFgRIjBgCDECxYixZTGIaAEDhgkRcidckBs2bP+MuBhGUJDQwCsFClOIYCBC+ETHE2RhjMBwAvIJIidQwICsFy2MIGjDwo2xJcaLEi9W5Ch0K5atVrRozar1WlZs2bJmyYZ1GzcsV7lt7/btCrir2LBiC4dVq/WsWblv727O3Ldu3a+CA1dl/Xp15rhntUqVqtWrVrFWrYoFqUfRNV2kKDmCo4UOFy4GHlnoggSJsQstntCp8wQLLLhpJAtOmK8FEoSwzwUWXFCBBBxImIiDCWea4AQSJuDAhdEuusiCB2uoQQkcVjBqBRKG4KIjK6xwaooXWhBBgQIKoGoBBbIyIa6x3hpLrrLQQmEsstp6q8cYWrhgrrhQiAFKHvn/4muEEUJQYIQpYMCAsMOIiAEyERwbAbKOYiDiy8XQwiwtvSqLy7LIXsCBC0UcsSQWWm7ZpZc+ewkmGD95yYVQQgctFFFcCMWF0UYdfdSWSBklNNJKK62l0UpxsWXTS1/7tBZbQB2VVEw/xaUW5WahxZVXaHlllD5yUGKINcLgggslhNDhPRxYOEKJLrgQaCD5DCJCp45eCHACCzgogYMNfNqoizDAcPEIK3C1QsIKVKhggw1mAuMFDizACVoSThjNBRtsyCAFG4Y4YoUVNujIBZ2mAINfIl4QYYEcbaSqRhMwuAADvIIYq8oQQkiLzBNGMAgGvVowQS+37gohiBhQ/3hzBMDacgzKthoreVkLRNiSzLHADGOKEWIQs0rHRPC4s8OEmIAnCy7SAQcelljFlluGOaYZZ6ahhx5pmnm6mWikkSaaqptB+piskTkGma69/hrsrrXuupmwzTab67TDhrrqtqWWehpq5MaGmqmnpsbqXmiJ5ZA2oJDCvjTO8MKMYXU43AUOcDiiiy50WNAKsEpooQWNInJh3Q0a0NwCIdYF444urFiDCyuqVWM9HFRggAMVOppgAyJG42ACjEYroYEBO1BhhQ5SIGGDFTqcsASlXohhijUiF8GqBggmWC4YLogheiPJepjIyCpGUwgY5iprL+qDiN5gDCjoGC2ZF/+D8oSZwWxfLQqkwmDZ9seaArIxP455rpuJuGABIoBMC04AA3pB4BC3sAUvjsGMZ3SjHvRwRjKepjS6tY0ZUFtGM5bRwbIhA2ohFOEISeg1ZZAQaiD8YDOUkUG2VS1ucrvGDLEBDxsyDR7Y+MY0vlGPHEajFrB4RRt84AUtrEAJXlCiF9ijBCvMZz5CUEIYsiW6iuhEBKLpiBAiIiCpeIgL1bqDGuIQBtEJ4VaNAwMHGNCCZgFPIguygEVEwIGLAG8FKkhBB5SigRWwYAMDwshCTCCENaiBXFeZwFRu1AAJEGFLZHFMWShAs7RILAgoCEIQ0ESEJ1HgLCGQH1qC0Bj/CYxAAqIcAQxQID8BQkQIXzJTFrFYpGUJYQuLEYHnTjAyIaAAMo3xXlsw4D1OwkAIYGhBB3wQC134ohnYmMY97rGOZCgjGR18RtWcwQxsJsMY4TxGOJORjHGaE53HMKcx1Jk1cJKznPGMJzuNUU5l3HOe4hxn1uopz3IuwxnPECg0pgGNZ0zjGtjoRjeusTR61OMe9bjGMVbFCTmQoQy0UoISmCAFLWihC2gAQxfeY5/FucgKU1ApJOfigspRxAQOaWkLwBCGMOhgC6UzSVCGUKIhKAV2DagA5XQgggk8DgYXK4EISNCChbAAQvRpiIMogqZCsqAEVlADIl1ggas0/8AABQgrmNSiFrKIoJLmE5Mmv4SmKWxyMx+zkvlk5pgQSEACFGhYCMwysQz5RyPrWqQAS4CB/PinfhYgpn9E4DMizAhj3jPBJMmCgi+plKky6IQudnEMakwjHve4hjKKUQxtRuMZ3fxmOOlZT2OUlrXl7Kc/1zlbf7K2n7hlbTH06c5vgtOeDhwoNAwajWkslBsNpcY36HEPeEzjF7OIRSPcAIc6SKGnPZACE6DAhDSsxw9WUNCuKrKFlBJGCFDSwU71wwGw2OVxYTDDGlywBjxU0T1DwEFRjDIfCzBAQCRoAAcoN5fIXqwFJdCABVTQoMMJhFfQAppRhrDVLihBQP+KXIAACgBMj8WATJRlWAFBs8opbCEtm2GllfziML36Ja98cVhXQsCjpa6LLBewCsIucAK5CLCXjWWLZF5goI44yQQi64r8YIAmMAjhAiqQwR/29AtpPKMe9WBGaYuRDAca1BnLwGc4eTtb3eJWtv3kp23zGdszcxm2ay7nOOHJjIAK9BkGPegMuTEN4xqXHvAAohABQQY3nCE9OBjKR7XghTU8Ogw4OJyveCUQlJqOV5RrAe1EwCTquUANaOgCv/SwIDMIK4zB6oJ+lbIUIZCgAkdIUFNXZhAO6GAiDmGBQR58BCKYoAQ62MCDcFAtfh2BBczDigAEwDAxtWUtVIr/TCZXWbHMfCyUS46xBBQgGFCCMq8SECDtvJqVCSxAkRiaEAa82BGyBCgxj5EMaOBCTPmZDE1WIIJQU+CDVeiCF8ZgBjzoUQxhvFYYA30GM8Q8T9ieGeKv5W1tddvmioMTznGmM2vXbIwWBvTOAp0GQrvh52VccxrYMIYqYMEJN5CBDF6Qghe4YAYznKEMXjjDGuYQBzUoQac6UMERDudE0VnhCCZgweNKoOO2UI8EqEYc445gho3OgQ42UMhPsxWGXR3hySUQgpZmxBKHVIQBD8iPCS7QVLk4NUUcqNDiGEcXBTivAGMRjFUmQIFeprWSElsMMMXEylaiwMUhEBMF/xqglVNiQAIE8Avjy9L4ReJIR3efQB0fwm76xagsE1isf5DVMerd2zFNbqsBGNABGRwC4L9Qxjek8QtACUMYy8CzmPGJ8YzDebcZj/jwY4tx3AsD+BLXeGwBimfiEnSGDZ0GP5lBjV6o4hWPGAMZtDCE9erADEosgxnmkIY4xMFFcRCdEpYOtIVsdEEsOMimD2Ywtt/6p7lywRDwkIeaBwUOVmDVhsCMzOBarqV1HmA+YqICHuAA5uICLqAlHoAC5W7XInAKhI4EGkzSjmAKlmQqGq8AJGbvFqmSGIbxRABiJiDEqiQtzieV9KeSzqdK/kLyzKcBLmAqsiJHMs8qvP8qwNrCqwxjMqBtMcoEmabge9hiBC4ABlSqyQzgASogB8ggFnihF4wBG5AhVHDhF0xr93jvnUoL+X6Py46vDM0w+dgpzcgM9wAlGNLw91qrtK6JGYTr+RDqGrZh5IqBUXohGmRBFEqBD7RLCYDGidAADvpAC+AADujgDMzA59bA6r5vVxBCB5xIIDYNWhLmYuDicY5gCEhgo5Qg/MxgEOBgEMygA+hAEVyg2HQgjARCAxoQ1v6rAhqQ7e7uAQjmATjAIM4qBuQuF+eDBayAX5Ls3AzAAOKH8UxQ2qRi8STJSNDCfIKAArDtrvhCBDajAQig8fKK8SQgYHow8+7Oixb/aQhF7zGW5TEEKL2QRSeioi6IqfAO43CkkAFsYAUgAeCCwfpEQRRm4QuFK8zuSRmOweB4C7YYEvcMDg3lMCIfsszYKWvo7A3h0PaOLw4fUpx265qWAQ+fbw/5MBp64RIkYROGQRRMIRPcYLtsoCEo4gwEARKg4AzgAA+4YA4GIQ4IpwuCwnSGZb94BRmFgMB0AC7YbpeQ8kTohQuGQAqCskQEAQ0WRw9cAA8UQXS4YL2OYAot4AAs4AHS7gEsj5FYjwEALCbkr3USR+3yowvuIA52RgdvxEjkhx3RgiwWyXyEpKwqya7SAvFYDAUkYDMwwHkYDxzxynmsIkcCppEi/3BGMmyRwESxMGRmRABNcunXxkJkDgYDoCS9duUAKoB1VoAMAK4XmmEWNMETXMEL76zhZEsY4hAiIfL4IBI3FxL5JpIiS2sYYOsNf8H2gsH2jhM5jTMYKpKcuuyf8oy4BCr6/CwXJAEREAEXRCEVFqEM3MALvO9BMpELcM4L0sAL6CANTs3qssWJTGf9gCZbjiAnfq0FooQDGqCnTmQU9YsLpCAFaiBXCNAo6KBEkFFXJqQBG2QtGaAunEf+KJABqMICSYAlVEA+VIADLoAFxsgKOu0CCEAAAAMt+k5MBEgqtMJEiaBKus0x5IcwHcZhvEKTiERM/gKvuE1HzEUHp/9CAfxSyORO9BbD80QviyCDCMBgZg7mMSNQ7IiOpA6xJFzg11LgE3QhF4bBFUIhFGyhF5Lhz7rJhYrBOLmGnbxGay5SbNSUa7bGTdH0IuNUTtV0ay5yGCySbELIGYxr5K5B5LChhqRpGCSBUFsBFkphFEahEPzADIpFB6RSCopA55RADyBB5swADYYAKE5tq6ygURniAZRKB6AELryHBRRQCUZko7rABrgAD6Sgd1IgBRQBDhxACdKARM6gBoBGBSAEB1pnLe8uByvAXDSAAU5TA/aLjeSFTqzgVyAHKnRwAQqgSgToGe1t8yhpsbytK7yiL0JALzxmk2YmrRqvAdD/SgIKYMAWCTI1r0ebhXbU8d0g4zHORKVOYPOMCt3agin4hSnCQA28IA5Kh14A4RZy4RYuQRNC4WCFIUxTaBh8oReSMxiGwWIr1mKHAWOXE2Mz1mM/1mKBoWNBlmQzFk+9JmqqRhqmwZuipk+nYRguIREQ4RNK4ROulBN6wAYIQiB+SgqogAnMQBCUQBDMQAp64ML269SERQ081Qpa4AEOp6ngYknmoiEqAA1wxQyKQglSwAuGVkA7oAb8QAUEVAkqYChgMXEqwCFqkQQORgfNZapY4gE0wAVQMxe9kiBMIBOVEi4mwEb0Ti8Fo9uM6iraAkgpYAJiTK9QaQQyqZQ2/6mVjORjng0DRtACzvUCagRHsKIuruJHDaSXEgMyYmkLtsAdL+AwnCVY1iAP5mAO1sAP0CBrG+f80IAMXkEXYIERJuETDvYXOCghx8lieyEXFEVREEV5EcUXBiV5d2F5lfcWpjd6CWUXrhd7sZcXeMEXutcXgMFixwYZ3hAZokFpomEYNiEREiETVqESxgAT6kAL3EP9cIAKqGAopCAPRoEOgAIPrK4DBMIMuGWjWEAJQEf+TGBDYkqBWYIDNEADckC/9utWvSVYcGCPhmDVzkARhqACTjM/cpECYa0CNOBgNHQtg4cO6MCDbYABNIADHIABVKcsUbO+DvEIwKoA2v+CAhTAfBR38xSXAizDZkBMfgRTBYMAe0KAlUAMBUZz8rwCre7uBPKzHlWmWaZikcKqAIZ0dI1ql/wDNF6gLEBHICzMvsLAvtaDPcwAD/CADphgEXQhFBCBEX43F36hTwoFVWzBFVQBkAM5kFFBFQiZkFnOFnZBF2xBFUBBIENBFEBBkkFhEzzBki25kjdBEzaBkz2BkzeZk0M5lGHzki05FA7ZOjZBFFShFxgOGqIBGUQhOx9hFRpBBshgEPJACrhAD9BACagADphAXoj2DjT1VlNgcZxI/3TAceLgDg4nwSiHBO7PBPRACnJgKn/qDOhkBTKgBqRAA1KgV4XCBpT/IBI4QQn8iCQa1AFbIoBIIO0MwFYzIA3oIAMcwAEqYBBsoALEeQU0IAwewAr0oAsIDCkNgB31Su+ASTBuZpIwIAh6CfJGCS3wSgFOqUrYAgW0onH5ovHqyC8zN0cuLysIpgevInO7GF/ph2GQsVoebQ0IZw4Elg7mAA20YHB2bg20wA5ioRICAREYNhd6wVFeQzkieZKTGhRK2ROWGhamd3pbQROmWhMuwaqv2qorgRKyehK62qsnQRIoQazHGqwpQRK+ehIoIa2vGpQl4RI2ARdYKLWOARYQwRAWgRP2QA7aoAy0oBDQQAoGR+fSoINTgIpedaNMKhP1AA9wQA0E/6EiWiBbdk2adYBvrQAPvABoC4H96OA9NqrYlABeOkADDuCbcYAOzMAANkAPBsEBDuAqNmANwIACT7UCDIAKescMhsABMgA1BaEO7IATXrcDzKACcCASjsC9EkcDTNTaQuzZjGpkHqMxeqkyEA/y8OpbPVowxG00JaDvqGIH64JzFWtzqSKsfDTzsoLvNi9AuOTRTse+BAcO8oCx+48O4KAM4AB26aAMIMEQ/gARVuFgifpTlEM3lvqSO4HBGZyqqVphS/kS1voStFqtKaESKiGt01qt0bqrJeERQvwRCDXEQZwRTvzEH4ERHsGrK8GqCXUSZuEYlEGgkMEWDIEQDv+BEwChEfgACHzADQphKiHBD5jACzjhpxQhDOigdC6M6BSCmekLQkQnW5BuLFzkWtSgPDmBDgYBDxhCCVTAACrABgYh6zKgA3Cg/ApBBV7bAVRkBcZSQzbHAj74CCqgAA4AaPMgDcacChigAoZgEPogFsogKA/AAVTADCjQAg7nAdaKRSsJBgSDrmgGraZEYqwtu5cMlD5GW1uJSBdJLSaEKm6kixuvRgRmYGzERthbAVTmCJlCD/wgdh9xheHAD/TADvLADsqvDOygDwahEOxADvZAwF+hwI0awV8hFTzhwTUhE6Jd2jM8wzVBqzM8xCkhxCdBxBvhERoB3BuBEcT/XdxR3NzPHd3PPRHMncXB+qxVYRiy6RmOIRfsmg8OAQhkoA0IwQ14YBC6wAz8YBVXAA5ohQvy4NQEIQ7AQAkEvkGE4A6elVh14NcWwrJxIAwEQQWkIBZiQRHiIBIGIVlJIAAEYHe2sgMywAYU1QxsIEDB5QAOYAEOwABIIAxK4ADYqAvywAHk2QFyIA1kQFbrIA1SAAFSQAtqYI96HgcEYQNy0QHwI2FWqfFGgAiyVdTJQq8K6B1rTXqooocpYHr0KvRuhllCA1/RrVnCqgcFhosDhgN+lHJeIKVeQKVQypnjgOfwAOv8QBCwboX9IL/9wA7coA8KgQ76gAzeYA8M/yEWDjYXVAU3WqEUpD0TMAHzKyETMlysv7rzRRz0v/3EF2HdF8H0F4ERUH/0T//0E0H1wR0R1h3F1319ZX/FJ+H2TeFORdIYfAERAKEOxgACPGAM+qAMfKAGemAIbMARz8AOCqELGOAOlpYLCGe+mLtCeKWp3sIE8gUs5O4I1IAJ/EAKgOLCVIAFPhiCV4ALBuGe1fyfOyCwOyDq69wCHGAC1uAFWI/m9eAMHAAgijBRlCIDJE6D8ODw4gDBAAMODgyooGfDhiEMHOAwYQIGChMYGjRQIIECyAkXMIiY8ILDhRYLLqDEsECBggIKJkzAcAHGhAYWSLQQQSKMH0hhVP+4cLHBBY4XK14M6YJjiBIXQrig6bJGzxw0eOiE6RKGy5o1YdacOWMHTpozc/T4oTMnTx49dKTUsdOnjx0/g9oAMsSI1q1dvGwppkVrVqxUnyJ/6kS5smVNmDNnqsS5M6XPnSuB/kyp86TTpyultsTaEufWrCnBtpQJU6ZHlDSBQtYs2rRmxyYF4uMDAgQfhTiR2TGojI8ydeD04USngxUrYLh0YGKnkBoOHEiYmFDChYULIkTAgCGihQkNJDjEwVHBRpxChbTAcSQlQ4oao0DSgwMOaNHFAUsJwokeFVSwhhkVdMDBAAwMcIAGKaxggwMaSJGHDV50oYgNdvg3wwH/BgxgwREHDGGVFFpoUQEVU6DgUQghXHCBBA1cYIKPOrTgVAs6WHEEGC6YIMR1RwjRZHZCjIVWHHqgcVYegijiBx5dDLGCElcKQsdZc9Chxx1rnTEIJ4XMEcabR4SRBxpozJGGF16koedbcNBFhx100JEHHHkM0ocf3RXShhyISGIYL7soZgtjs8BSimSVaZLJZZl1mslmnpGm2mmjgcZZaqOiRpollJBK2iSrtpYJI5RkAgoxvUkTDTKb/MGHGzJA8MMosZQBhSJ19EEsJ1IwYUMPOLCAQxc9lFHIIHk8wAJ2FkxgwXhEmNBCC+yJoAIJV2WwghlMnAGHElKk0EEH/1L0oEgkPXSQAYEbzMFFF0qsQMIQOJjRgRdxkGCABtIe4IUfGnSgwgEVnHEAAnVEksEMhaxA8RAVHGCDDRkc4IANK+TAEUc5YrBeAzHcIfMghSiCRx6K5NxFF3FlmTMkiuB1liB50BHHV3HgMYcdecSxxh1WcvGmXGHoQfTTXWhBRxpa4IGHV2EowcUcfqwxh1pdpLGVGUjHgQYcZ9cVxyCO5AGYI4OI8UYmpdhyCy+5LDZLpa+Actmnn2qGuKaIbwbrq6g98sjjrZZ26mmSZ4555px3PrlstDEyySWeAJNrM8h44qsbQGCxlx1kMOEIH2QQG0sdTPQASSEXsLBCCv983ELHRhy4QMIEHDwAHgdEimBFCxYEpQQLNUDiCA4aDGGGCvMyMIQieQxRAw42HHBAU3kcccQKcEihgQMV1BCJEgcwUIEKBpAgCAfwZxDAvh7og6FqFocMraECBnDRhupngAp0BCQ4goEaYiBBQXxNEH7wQyTyUAg8mIELaVCEBfWgh0EkxA93SZoaksYzNKDwT3Bw2lbmwJUa6mEsVlIDHOBQhanQYSte+tca8PCmLnhhK1yQghnSZMSxhAENXjBD0epiqDa0gRGhMMwuclELWwwOFq9ghSc00QnMNO6MlWhcaCYxuch17nGoiWPmGuE5yTXijnesI6xYwwhJ5Gb/F7yJhjSa4YpAyIEPheBOD9xQBygU4ldu6MMZ3MAEKbCJBUJQgRb4oAtFSKEFHJhAC7jQAA6YQAELKEEJRGACEhyhKDhgAA44cb0arEAFOBAEDjKQgZwtcAURCUoX9Ce+WDpgBRWIyAAKoAIwMICZa9iAATpwgBukAAEZiIIi2PQ+BpjPfNM63xDMFwIMSOCcEhBBDEQwhaTdDDCKGEQ8z1CHuw3iDF5QQhpiCL44mCFQdMBnIexiF0EJgoRxOAMXzoCHM7htCEfAAxjUQAc4mMELXDBDF7hkAzOY4Qh0SaIXpDAtJUxFiUX8Vxek4C4peCEPfXDDGNjwB1AYJhe5/5gFLWABRlekooyMO+OnQkPUUdXxqEh9BB7xuIhGLKKpS3UqHiUHK0aILhO34I0zmtEMWgRiD2woBA+iUIMUpOAHWvjBILzABC9A6wyKMAMH1DCEMihiFY5QAQt8ZIHrxIcDFnhAfODzSh1UgANWcIoVOtCFSDjiDLt0wBDmoIgh8BJF5nMAAzrggC5E5ABzEkAABmAhHTzTAHR1AC/N2p0MkAESdDAAmFbAgPytAA0IVMILChACCoQABRQwCXrAcAe54AEwhehLH/Bjh7Ywsg5dOEMXzKCI3dFhLmnww0sHdd08QAK2AT0DGrgABz9wwQVzKEoYrAAHL+DTDGm4qP8SlUDfnY1FCviVgovEhoaxcOFf+pUCF4aApzKQoQls2MMr/IaLnFYKFq5oRSqCKlQ0ioYzrdpcUuuIR6sy4qkgToSIQUxiEudRcohIBG5owZveRGMXhgQEJCDQgxVUqwwzYEIh2BoJJqwAPjpggQukkAYaZKAGLgCPBZhHhJesATw4cIEehEACC+igKIpwgQZ00AUNwCEScehACrxQAzNwIg4IrEAXvMmADECkCx1YwUQ8O7EU4aQA3qTIEAyAAAREYhV2QABnB5CCPTuAQv1aswEssAAUjCAEP8JADEzAgTvkAQ8+KwRfriXPgcYhDkbbYRxwFokMypMOjtCS1wb/BVc/dCEOPTiDFOiEpyHoAQ9rwAFFR+rR/0qBvnHiApjWAAYlkEUJR0C21LggBB0IAdk1SKgSzpAGA5OBpq0wDC5sAQvCSTgUl/gUJsZtmzQizjOUc+NRo5pHpz41ESV+9yEOEeJEzFvE8F4E5wyBCNy8osW9AQYi9iCHOsjgBzX4NUvdcIay4uDhONBryFYwh/Z2gAUkcIEKdKADMCjPChnoQAV0EAkdnMsCXFBEGJZn1ijWoAMawKUDxCwRDUSCCygaQgoicr8aqKAGNSiEGRjAAQMUwADPZMBaq+CHA9x1EAggmQbOV4ICFEAAElGRBRpAghHEILjrMQEm70DF/0I4QtN2pRkHixYonAEmD3WoAx8M1Qfu5kGhXoCbGXAw6jz8Wm34fNOllaAGPNnAolzAaJD/NQQXdIEL2HFSdjAphJ0d4eFHsIIZIKEHOLiLDGV4AhsQodNb5OIWX3xFKkrRiUl0htygCs2rXqWaRzCCjkrFvVXZvQh8j7jE9r538A1B/EMUv6mZ4/fkWIGr3jSDGJKQQxtm4AEmmFQFnNCFHRBeA4ApwQxC9mQGiuCFHPyXBF0Qgh7AkDwTKKRBR4DEHUigPBdYAQdHeEAF8BvnfaWAARoQMhUgLwwgQqrVAWYwZikQAB3gBx0wAF4gCAIwgQOgAA/AAFywAQOwBv+Q8DvadQAolCELwAULUAADIADLhIJWNwImUE5AogJzMAhzsVwClAdeoCWDYFyyVhdbQQeD0BaHclEZxTZENAdx4094shZzgCd7txRocARcgAdugQY20AVq0AUuoANXmGw4oARZoQPIdn//ZSSQB4VHECJ0ggZnAB1tEAiUUHq3cAuNEQuv8AqlkAmwUgnkRm6cgQlFRVSt8mGL4GGEOIgmFm+99275Zm8gNm+OSG+N8F2Q8AiJwAi4UQrEEA3ONwyU0AZsAATW8jVmgAej4Ac9MFLSZgUcNwqcYAPigyHyUgNXdgEKcAEGsAIrUANDwAEqcATRwwAkUAFZyAEV0F//FlABG3BpK8AFFcAATWEBDkACK4ADg1ADG1IDGkBaBBIRJTOBVscAQcECBUACFiEADFADA2ADNZAGFVKCHEAxh2YAByAAEzACKHCPGIAB9ucHgoBB+CFAflBeP5RBTYMwdFAIelAzkDAIyVJxaLBE4tUFVpIWdGAGWpAGDcVQaaBfAMMFLMBleWcn/+WFYyEED+ciyWZ5VtAFRwIGRpJ5O/NwO1MncOAGchAImkALkjIpjlGHpTAqlrOH47ZGqJIagTiIhFiJHpaITYWIvSd88/ZUjziVTeUIjkCJlkgJnTAMXLUrxHAJb8AGWHAFWmBSSoADkTAIPUAoZzAERrIG/540CDjwcuKTAmnQZeDBAAtgMhKDB/RnPhbAAhzAAkpxgTy3AQ7geNMIjSvgWREhchpwBpzwcGhQIQOgAY6ABxZSAA/wEAzwmcJ4ABdojiTAAHSAWQdwBDiBdKR1glZnAvc4AjoiBHeQQdfSB3BgByZkBmpwF/E0CHGgBmqgB5GQM4rANB7lXmgBUWSBNf8ybV+hNnghbCypBGCIJ2LTBdeRSWhxBI23AkPgJMnmeFZAAjhwHUaSWCrABV34L2YAenvwB6QwCzu5UxDGCqFQCZ9TVH64Rm3ERnHkYbZHiEv5e73ne/AmYsIXfITQoPNWfPRWlY+QYpOjCb7AG4OUOv9s8IkQYANzqXPk1QNJ9GtosAGz1IESowLEmTNSQJgcwAAN8ADFqVkP8ACi2SAZh4szRzGIiYyliYzwEzK3eC4a8AA4II8bUCEVMgR0sAIW0QUGIACCVQFxYAITaAAGoC0skI0oaAAKIABWZ4EMIABYKgAmwIIqgQFrIAj+xBdt8RdFg0E3Q0J6EDRUYkJqUVGE4ge3BlF1cgdBgwdqIELgA0LxJQWPB2yaNydWkYXOJgRo4RQoiQMmWZ1OwXFB9pJUcSRGVAZuAAh7wAqwsJOz8Ao+tQqeAKCu94dxxEbrRkem0ioDeqCLiG8P+qCGIGKGcAgN2quG4KBP1QhW+Qj//NYIk5AJgOR8yKAKb9AGQBB1KjAVSmADgyAFKmADeICS6NWKAtMCJIAGiqAFKYA94NECFcAJsQB0FwiOyRMyJlMBTgpM4HhMSrAB8LpnwLgCd2A+KWJ0KGKC8oh13lQ/B3B0qflMR4elKnAHnUmmChAAAFAAE7AAx1gAR9AFAYAj6jQuX0MXdCODdnIzg8Cmd+pYfHppGVRRdWFB5RUHcPA1mIYWkOeDAPMmawAwLgBRlacEuIYDXICp6KkD5eECL2A8JsAkF2sFLLC0GrAkXZADLmAWZqCGfGAIgWCqilELOyVhpRAKmmB7/9mq6rZhldAJn0AKoWA4tyGIjIhv/0+5q8QHoXD7qw1KfIBACIcAb3TUCMV6rFmFDNIgDchAC2EJBDKgBVYxB0owB5HgVvZxRJyXAlQgIUFiAg5wA+2VAkRqAbeUWMKJZgegA4KABpbVQP8nEWGgBiRAAswYHhwgBBpwBAxQCDjAmSY4ABxwdK35EFHKACwQMsZjdQZQdGA6AL5jAC1wBGpwAQAQAAWwAObIBa5UAB6BAVugAxFFNMcFnHZjQjJYCHRwM/0YFnbTXXMRFlKYBhYEav3oFXPQJFrRkTuzM0OQFkegA79Wvx2nilaonS5yXiZgAd6KFWGgAzhgARsnZBEHnmSxUGdQtYhgqrUwwaX6bZ5wCf9WdVRulMGdw8GToAmlwAqvAEap4AmUwLZ5a2/4FrcsPBjGF7e9Sgh3Swi7ClWBgAiLAAmWwGLIEA3RMAy78AdsIAZ8oAV+cAZKoItmUC8IE4WKIGv3tGVg0AIbAAmjYAc2kAJbChRroAZRRgKRoAFEh0H4VBAZEFhKEAnDRGX2V3Rh0IwPgAdHsEwPYHVBBqbNqI0PoAPJU7AmWABhoMa32AENdABhcAQ3EQCKLLxrQAJgGgQwoCTKWygN1Sd94k9ngB8BKU8ZtGnJVXcoZFFJQ0J3EFAvqzZpAAY6sBU1ZF9dYhaqOGBdIAjbshRRQoYv8ALi4a1LtpKtFBRd+HD/KgCexqZ5XgAIfyAJrSALtTALWutTpTBGk4AIiLB7jWCJnkOInCOgtRIKdRgL4NwKoXAbB5q3jxi3gUB81IwIxBfDMgwI8OyrehsIgXAI/kYMgBsNx+ALgcAGTVAGVEAFcJBR6lgDSpAztuQF2kMFNoAeLXABDJAGnPArPdBxa2BliqAGKsAAVoBAsoQGOzcvB2ABRDAUAuwCJRAGQiBK4GECayCaFkAhSfcAEwgGa2CCDvC7w6sDFPNMFFGcZ9ABArABXVCCOKHIE/iiFcAFovURMMABYCAXMviyLps0FXUtTCNPfxFPFWVCnVc0OzScedAVcxAHfhAHafAvarAV/zJreWLDhfgnrZdnAS5wB+kZnkKwSq1kAurDcXpFAiqQWC0gZDkbBhoFBYTwB5SwzIOjGK2ACqFwwYzAb5WIlNhMoNg8oNqMCZ2wCnQ4wrCAn7chYogAlXGbCNVsVWWbCYgQCO8Mz8h8t6f9VPRsCJKTCsMAuMAhcGzgAx6QAlUIB7HALFJgA9MqZh1QBfKSAWoACfe7AkVgKDOAA4OpB8iztMeIPSQgxhHhAJGgMSgyAQVgATa9FBUwAZHwSt1SAAfAAg8xgfD9mVcHps/EAnB5PnjgAAUg0I4ACWngAAtgBRaQ1AIAAAKgAJ8JphMYXA3QAn5gBnKBm9KBF3KhCP9GKCgklEFaEihy4QiStENnEL7HdTapW1xqUBfZujM3ayQE9mspIDbgiQNP2IUSqRXembMu8JEuQCTJS2UloAMvoAMxYK6F9i9eUAaH8AagoAqwIAuyoFNhBAqeMCvE93seds0Cus3aPAmYwAkhzLUTRgmJYAh/sAdv8AZ7EAh/oObUXMOTMAq2QAzAIAnpnM6wLdvFp7fEp2+VEAq5zVX7zAhi0AQz0AM10AM2AAmxkAcr4Cw5AHRKIAgpMAirAAm3AAlBnQO5uAJn3IyIaQAbkIFJ9HImkwI5EAm6EAf1c1jnsrrmwwBHUHQ/AqbzrchIXQANAN/jyAFrUAI2obv/AqBZFTAHkDCmExgAQpAQUXqCuwXfDUABFqAGFmQ3duAGcFBP4VunHbsGdaI0eDAIQ2QmjvAnc3AGVnNcXkNENi2oaaG4jxcGOHDIGiU2QyAFLtCYj0cHR7CmXACFXoKLS6ECzGMFQtACP34C7THkJcAhLqAEVUAGbZAIfxAKrdDkgzMLEjbl05zOu+q2t0eIuKfZHuZ6nTAKq2AKKE8KpQAKrYIIf/AGfxDzax4IqI3ae7ADOD8LvMALnlDnhnC38Ry3edtUe44bmgAMzXcMwTAJbPAEPsAEwD1SuugFawU01OgFKeAIwBAJcSdobbXRDQI/GQfqFrEBeuAF/je5/zkgCF2wroDtAoelfyzwHQzwAIhsABcQAKJl63q/yGBadFYXAEZ3pVc3AF5SAIvcbN/tyCdYAtBLjzzBAsV1B2bdXAO1JZiGBxgpCDkYFkOEQYqQBnpgB+X+F4NAFwd1a9pphWAQ6ltxyMb2SuyZcNNKAlECBplnBWEgCEdABE5i8CXguirQPN4yLkIRAyVgARuQIfUO8YQQCKbQCq7QbZXSCqWgCSdM5vBcfCk2iEpJoPBGiLnRCaSACqIgCqqACqYQCqXARlFJiSIWCG8ABB7gEAMweqaXC5tQ22oOz3+w/QBhSGCiRYAIGWpEiRIvYs2aHRvmScyYLGWYaKmTIv9DhzN59OjJk8LGECU2HI3q4CBFhzl0Vlh4IASMggU4OHBgYIEBCR0P7vjxc8CFiwoHKjx4wEAFCQ5rWLjQ4aKLBR0HChgIkDXABQECCijo2rWAgAp4sDJ4UGDNkbEGBAToSkCRjjuRlAQYMOGFmgIEFGC4YCUOnTV08pRx44fOnDh46BTCMwePIkF08OARJKiQHi9z4Jyxk4dOJEVoJDNesyZMFytcjnRZw2XF6y4slKioIaXLEB0tjogQ0luHleAchJTgUGKoBhIWnJdYsMCCiAsiRExwkGGDCyll2vxhlEqVK1izYLliFSrTJEaB9uz5A0jgwET1F92/z6h+Ikb/jB5lCuWTUkQhUBVRUEHFlE80sQSSRwJhQwwIEECADUQu8eQWYohBphlpbEEkkEAMAQSQ+Eo0SKBDDonPkEUomWQXYqJ5aJhUxCDDjUIKgYSJDmrQAkgplBiihi7wwMEGL6RYAZJCKlBCiQ0q4KC3AnQi4QibSFChKEWssMABC3BISggVdmKAAxZ0UOGBAx7goKgDNEirgKwEUKCAvrrKagADGNBDiQG8KsAFRVwYYFC4upoApg0OOMCABRoQ4QURGqhABTXWgCOOPPIw4wzD6PCjEDrScIwOyvIYRI85/KhMjzTgsEMLPwbBtRA00FgNjDhW6+IMKWrg4gwl1tRB/4chhjhCiS660OEIE0RoQQcTrBWiBQ5OsE5bFm5ybgJxFWjAggYaEJeBDVZwYQgy5PhjEvHGgwWWVkLRpJJHDPlDDjlKJOSg+QxZcb/6EEkEkf4o6aSUUkxRJWJXauHFF19u8WQPGWTYoYk9JHFlF4eaCSYaYoJppkNfQhTxD5dRNCjgFf8gZMVHHrllGIeOCWYWNsYow5FIIiGDBiT6YCKHClZIQYMaVshAUyEYGEQNQAW5bgJqJyB3ASI4EYKIO0yw4A4irmq0AA1YSEoJIQoRhAG0DIBUTwfSqMEAPTVgoAAMBDhXAAMMWKELARxwoCsDwNjJArfS8mqBFhI1oP8CEh4VoOwJSlChizviMIMOOj6bNQ9PBxlMkUHgAEkPQfQIAzNFIFHEDymgmN0PUeNYA40uhODCCivCoEOJGqKUgotkrThiCBdIIGGFFsIwwYQWWnChBRKQM2GCBbwvgc4HFhi8AXJpmqCB7x1Yd4UcyKhjj0zmJa8VVj5Zb9/39kBR4IH/R4RAFPafUKziYeORxSx8IQ1pbGIHbHjDJRS4IYcwkEa9GEYwcNELDwGDES77A3wAwT+ABUwgNFtRIx5BC2A4BBnBsAUbnhAFPkQiFoWgwUm0UISn4QYHeEgBCTTQJb5VYA1WWAAHJtACIYjgJgoQgSDusIASlMACitD/wwQwYIILkA8tVgADCRojNwZUgAFWIYEjlJCCM/SNBGHQUwG45hUFcAESK6DbADZggF/9iQFhEQABBPfHDayhC84iAZ4KsAAlXAZ0eEgDGjpFhzgMJg93mMMgBIEZQQyCDq3Cw0dQ9Zk6KEZ0eBjEGuagBi6EQQmvMcOu0mAsm7hASxywAAtwoAQdlOA6wHnOTaATnSspQFwW0BNY4hgdckHKKDkoAx/24AlUSMwVqVDQehoRCH/9C2aAGFHA/DcwhU1CE6VYRShKkQpXuEIWvqCGMjYhCw4hIxrHSBkyhmFPGuWiFrkAaIdyIQmX7e89JyohIeBTs0U8ohUtTFkw/3LxhyYAwQ2YWAUfBsEHN/TgaSJxHg5WcBQwWMEADzAmLifggjWIq0oVsAD0HnAUDrRAAcYcBBimcNMD3EERKjgAB2pwhhoMAQd64sAqYjGrIfzJcRyIQRz1tIFIDMIAiSJBBXCgCDdZICxf0ZsAhIKGFWzHBQaYkgEaGQc4hLIlcIADHbyAh89dBg6zQiVlKpOH17VVMVrwAqn8wNfedYELajjCEdRgBiIZtQZsUpMLkOKCFSRnAhwQgQVaIAIrjusrN83TAsCqpwaMJY6D09MBMkCFMrjMEwaiFyrwRYlHMAIQb2gDG+SwP5eJCGaBIISIRKQwhq3zEw0jzyx4Ef8NalADGwyUBjOm8ZBdzCIXKbvYLXSRC2TYcxiaCAQI/cXbhLqMoY8ABURfyAtEiAEIZShDHTARCz7AVRFFSIEUSKCIV+IksRa4wARgQDYLcKAL0aESlZhSxqASBwZaNN8D/sQCEjAAKh3QQAcqkBlIDYETo8iAA/p2FQ1E4mxfySoO9NBUvQX1CIKwiVu+soCbFuAIYVjBEA4QBgts4JAbOEMX4PAq0cUhDWYQDRouc5mPCIJXkXkdqzCjBz/YAQ55gCsczAAb1ajBCiwAAxfiwAUcHC8MOrAAc67HgZtaAKZMIUELiLAFE0wqfRO4AAa8p4AAh1YBMu7LTbsyAAf/JKEOgEDEvMbjClN4IhOVYM9t2zDp3cLnZQgFZ3BdZghGTKJhARIQK14Bi11EQxnRiAYuNtGLZOCiFrUgzy6GQQxfNAQZ0qggMmARwPDuoQ1y4AMfXkaIQpCIoSrUBDC6e4xf7IIRHZPDIQoRC078wAac0AUn2qWCqLiABRX49mFJgIcuZNUBXViBA0gwhAzUAAcdyMABxESCB+ggDG9kgN7UxIEHqDsFhTMDJwRxgDMiAKgOGIBRCjAAIXThjzbuAuLgUIE/JYoBVtgUB/RkAAccIEwHsDgDwiCI3KTAAY0RxGDw4AdPfWrIfojMHGSuiDmsga+azIMfFGGqNOih/w956IginuWsNYBBCUdUgxRsIAUDuAAMLrhJ9lpQAu8tAC0suJYOiBCDS4nrXORa5Lj0NhZCfUWQdzoARv7wiGpKrBWk6IQ2EfEH3P660gcN4cvAGQgT/QER//lEKkqhiU4IaNTcjUYvAgEED7iiF6KAdXlE0UJkEGMYvLhFLURGjFvwupvdJKE4AXYIFWbCF8v+BS8osYMn7MERhcCEG2RgAzrEIhZhGIIg1MAcbmP8CDSNab4nA1M9REI2FUCcs/L9ABWo4Mw6IIEBSDA1EnDBDEOIxByGsEfkZ4DjHUeLngTwAAtYhWp4OMAQOjAAFzBgAAy4jU3yHVaOJ0qsl/97FMgHEDo9ZDnlcFAMNBAdUkkD0SkVQ8qDUMoMTrqynxOVPPACwwqD1FCC1UisNaiKMLACHVAi6vA68+EzDryWLYABGECfRboAsCCAPRGkQAIksHiLrDiANHADOciEthsPVQCFfHmERFCoSQNC0CsovQMnEwmERDCnAhq8TggFUniFWLiFY5CGWpCBRziESeAFXIAFVhAFWFAFYUCGXsAFV5OFTbgEhtCF3toDf7E7EkKRl3GRRqgEXeguYwgGXvAEIBCDNgACHuCBGZiBGjAS08EVNQADFmCjLhCEOagAKGEaDWsarYoFXaADDQuxFKgADVC/7OgAT9E4OCGBOYj/hBRIAfUjuI5zAD+YAwbwghQogDMyiqJwP6PQMA2AlKsaAMvZgA1IuETRv66gtzRBvkEZAAgwDNEYHcXADDyIK1JRBMroP8KYg0+puTzoOT0wAzgYBCyDAy8wAy7oAtMBIzByFtbAARdQARNggAuoHvW5KfMxgG8ZDjCAgQbwigv4igkgOz6Ji7cIJAI4O62YQTl4g1BQNFVABU+oBH1JhNtiAzIggyDcrYLCu737g0D4u0xgQnzRBE8AhVRoBVooGV9oAkywhD/QBVmwhVuABVFQBVb7BWEQhl6gSVzIhWEABvdYw1/7tf3hA4AZtkVohEm4hWULBl9whSZ4gjZw/wMnGIMfcAMpSAEV0CXmsSUNWIkOsAGTS8U0KKMMWAENCDEz8AMlELEaMIORWgHjqQEHqAGgegAWuIB6m4MVOACTi4wccwAVGIIuqIAOiDEDCINIaD8GcACOU4GOk7dZxAELO0xCY4IMSBQ/qcAwUINHSZQUYIJbEY3LqIyV0zI46ANc0YNTmYNwlAw8SA0ChKs0gAQ7sIMzgAMccL4wUIQwAAPVeA1ear8+u0eABMjSAhxjogA9A6QY5BOtUM6saMGsAIAAAIAKIIM+eINWcIWIiZiEnIRHWISGbAOIHAOJ/LzxEqERkg9GqASNjLtL6MhPIAUFaoZh0C0+KANgIP+GX1AFWZAFXPiFkamRYziGXgCGWNBJX6M0n4yZ/hHKFVq2y/MZMZADMuCBHXADSCCz5oM6DphAHaidTOQADbiJ5ngAEjhE5juKN0GLO3ABC+iCI/gILpiDqigAawHRFQjLjpsDR7DLA6isArCKwMSBIzlMDXsAMDiCq3ojeeuADlgBKeiAAzgDTnCEFECAPylSPRiEDXCA0ckACOiDz/AIy4ikM5BNO+gDK9uklvgkw9ADzFCVOagMOygEj2AVM+gMQVgDPbgDmYgS+UsKr+iKBmhBAqCArlDB6CAAuNCK51zORW3UtwCA5+yANKiDQHgF7IwYU9CESbgPFimDMQD/VTLwjjZ4g1IlyDe4u4LCyEdIz0zQhEy4BPYchVKAhdNrBkTYgTEAAjoMUJRphntSNUkQ1mENkTfYHzk4UPj4SYOIj4DJD1do0F6whTfAkTLYAS0YBU5gjeEQgurTAxyogGfBRA0wrKHAAQ3AgTvgN367Og04KTi5AzyFvsLhgLlECxKIhFGwAY5zH16MFLl5RZg4owc4gg3QALfUMaR4ABzYANzTAymoAEUYBUWoAC9YhVUYhAwwzIRDxzOig1WAAy+FK5czAzOIpJursj7ov2fEFTqADZ27lTQQBNZxA7g6gyUxg9sEgz0dDjVQAhJtAfPBE4CEwQAAyDvBkxFo/wDoZNRFfc7kVM4YNFpIDQAbqAM2SIRLxVRQyAT9OARCiFBQxYIxEFVKQ1VTPagUWdBMYNtNVQhNEBBXwIVkaIZLQAAIgABZQJlo6K5gDa9SLVUIgqB+QVZKq7Q/WFYTiZn7QARTiNZbCAQcIQOthAROaBZkYQEhsAIXsMwMfQAlUAMSJYI4uIAUFIEYuCkDuKkU5LMoUgE60YAKUICcUADLmQwVSAF5ywAbAEsyopt8IyPbGQIpOIMO4ADz01MGWMt0U4RVSIMM0AI7qIMfQIDcHRS9oawMiAQ7QADYtLIziAPGmAM7UIw6ONNtVATS6CSb44LeyQNH8IM0sL408P+Cz5ACKWiMLgADNdCB4DCTZ2kB0dIT4AwLGIyLc0nUpl2URlVU5ixgBbgTM3ADNmCEWHDJ7PQESvDa2xoDMcgCKBhVw/08EYrDm2lVV52ESUhPAVGFWsCnXAiETriFXng1VbiEYg3cPQjPTyWDLIAXY5007/i8nwyY0DuEhAEFZICIYeiFXUAENmCDLGCCH6gBL2ABqgRFXNIAJTCDcRXR8akOY9qsCziXC5gC6pgCMNCa16UTmJjdNLmDI6g+OUEcF5gDPUAcw+RRPSABSKmAFEgSTuACnmg6pNCbhOM4KZC3lZABKIACR9AA0yqA/aqBFPiBMvjSz7ADOoDNPlD/BDeog2DbOUgYBJ3Lgz6gAy0wjDvGskKYAyXQAzRQAjTgAjFbA8aCliOAvuqhFj37M+GEC+CkgDwRAQyQAK2AWgb2R7EIVK7JCgPwgjpoA0o4SE2dBIIgBEDIrQ4m2xDuJsCFFxd5hBRW4YVkW3PuSE8IBVfwEGlAhgGdBJYZwoOSpveog3u2O39xgxq853vmgz7oA0DgA4HpTkRINmD4hWBoYkoQgz9wg1EYhR54JW9jARZ45Q2wNy+QgR4oA0X4FhIQARO8qSlAqZwIgztgAGTJFEGgRxjAAOtQRw3IgzBwS7PUxEjZRRfwgnjj0SFYgTNwAC2Ag9xVhDyYEzNA/xx5k5P28xOQOwA6gIQa0AAp0LgyWgM1OF4HUIQ0gM1ZgU04+GfvLYRB6ANIcATVMdMvVZUEZEY8VSwucIHGWCzGug0l4IIPransMYFzKS0FaMFAxQAKqA4yjsFEXWDkBNQHNi1tSZQMiKY26ATxuE5VIIVNTYSv1WYoHoOfiUgRJshwbihyLmdzNudO8ITTBoVb4AVb0IT2oMg13C1/CTZ7rgM2HE99BuVQBuiAlg9DQITfvgRgAIZg+IVewEM2WMNRiAUmUAGoYKwecATtiwRImM5YiIQy6ADJug6wm4AK0yoDOwo4oZPkiIG9bgAYAING3I7YRb4tPqMyasQKCP+xDMgAjXCAm7WB4rUBmygEYTkAKqgBQlsxusEKA8iAHhiAADgAHSiAIk0NdP0TgLYyK+uDQuiDMrADsl4djdo50bRw8s0DNIgk0DkDMACDLjCD/FUD0ImDO9CDQpBjW9IWbUmfGvuKQGsAA0AX4UzsuBCkZLoKPLkAEvgzRumeSJGBGizIg+TaHjSEbNbszYZizx4vQkgEVoU0cjZntmVb0z5tTbgESQivEDJV0HsPYDtWfb5tOaiDffbn3QaY3jaER/CFDCpuXngFNmgDPviwH8ABNgnSGsiDSECDNUiBQtAFYNAFSDhMOFEDgWWOpNBQFSgbp6C3m/DAcvkWdNz/jTiQbwYYAiuQsAfogMhIgV2kHauo5A4oBC/IFI5Tv8E5gKcBOpAbHAhwgKEeJKvQkzQTsQOwMq7WHdGEK4Am6z4INlzx8DNlnczwgp7jlcVaLD8wpE3JUxf/vWZpgUYBMH2MnAYgYwJAlxiIAX1cpAGmo0C6CsfJEz47qz8zABOgLMThgasNhFVQNFQAhUtghAA6hMze7D0Ewnw2VkAgvXIe5xTeckzAhLbVBDDX4JYp1TYwKIMy8zX/vNzWbYAW6BIZEU7TBTv/BV+YVtwqhDqoAUgQBCXAgUjgBCZwnWWJBWLQhVsYhA7ItwuIA51A0T+BEtw8abRIipE7bydq/4EuiBOi6AIcSL9BUAKCK6MuiAQ6qIINEJrm+OMOSAElMEwDSAFcZAIvyIMOGIKJM4AaCDEEGAItsAEz2MUywkyVMICvJl8ztbJjxxVc2e06iK/4sjJF+FJP8kZH6kvfQQNQ0Q1wdBYh+NBcagELCC1wd2k5ugAW2CwMEC3zMS29MZ/voYlwyRMD4IDtaZ6NoCExQIRXQAXrREhQ0GAVyWwo1vOBJ1V/+QNxHmd9UfgtrwSGb3guZ8hAQNU9MNaKP3PyhG2Mr0F/2fiOF5j6yBniHvk0RNUxcIMf4IJC4AQpyFcmqGI9sAE3iARHGGq+iXc9sCmcsNL4ZgBblJukIP+BGLgArMmJo3ABHEgBBkgDRcBKpHhvBgAIOmoyVKiBY0WNCiQ0HGDw4MCQPDkOHKAzSssBKnAydHDkqMOBHGkcZNggKMOBLmdWGDhgAI6dmIP82PFSxk4ZmIPSDBoUk4+XM2XqwDkD52idM17SmDlj5ukgPHDmpOlypAuaOVZUKGRhhQiHCxcmLGhhBcYFCw846IBhYsLYAgsaKFAwYYKFCXbvtighwoKFFi4GU+FIpo0YRq9QuXKlCpWnSYgCESK0p00bNpg3Y34jZ88eQokePZpU6TTq05kyVcLkevXqTpMMBfqzR04b0KA/75bD2zdw33WG1wlehw+gyskNGUr/lAjRrGHDggXztcuQmDZjZtRQwWJQnBpamNjoMKSGDAgZENhQMmDAgxYkHmio8EDFHQ4ODzxg4N+hAQqYIMQFJHBgAGAM1LdCJDU4oEF9FD10QAUZpOBADTVowMABG3IoxUx+dOAFJ14YUMEBCCAAhyIX2uHIhTn4oYUBA9iQAksG+HEUTDGlcZMdRw0CxyB9yFSHHX30dNQZZxRSFFV5oGEGkXN40QWVKwwxxGAkkCAEmEfooMJ8DMBghRBEqKCBBWxxZYEBDFjAwhEcWCCCCGO1cKCdKrgwxAokrJBBFSmkUAYbbGTySiuNtQKZJJNVdhlmuPnm2Wd/ABLIaKZV/7KaarBpokkmnZh6qiaYMGLIH7i1wZttoP3xBx+11nobcKARV5wcw/HRh3KVMXfIc69IJ0wwv/DyiBhslAGFF1zgoIMSeTiSFBMbZEADGR1k4IBLBmiggxlHkFBBBSzcYR+HKnThAIr80WdCfw/5h24FGqSQgQYqPESfBi7g4AcXJHnL4QMuPGDBjTbkoUgedHTgwAAqcoQAvAwowYkj4IJ7QAEDODCyAX2cEdNRaZCRRo92nDwIkn30AYcbgyjihxt9KGLUGXUIYhQeZsSBRhd00JGHlF2EwYUSQlylBhdcWMGFDi6oIIIJLUxRgQtCpMsCmRosLDAJSlhBQmAmoP/tggUMHISDEkfk4EUPS7TxBhugtAKLKo2pElkigRxySKuW+qabpoAAkggjpsHWSaiZjHpqJ59YbuokjxjiKhlkzKr4rLPaOrpuuhIn3HF9JJecsMwZwgowxwYDTCZiNFGGFlJ0sUYK4hVScyEEFRLLKA12UIEBD6gRCx4JK8KBBl0I0gV9K6DLgH52PqDD9vpV4F8GggxxgAocPICDWkdAokgkkUhhXgZxMnCHCgdIkcYKeVChhRcOBHUhBG5GEC54gQ6QMANFIHKAARjgRBoQkpFYZiQlyYwMMCGSH/xQhz4UghNGKoSRFKGIQQgNDXTwgh5OGIc84IEqdEAD07r/oIMjqOEIVuCA03RQAQ6wQGA4sCEYzoYDFijES/05FwnoYgEdcIAD36uAA3CUAyl4YQZOeEKzQBEKVahCFrBohSciZYhJceZuudIUIRbxiFChRnKjmlwnPPEJT9ARFJ8IRSYaYQhAxCp0mvqc4gAxuluBhg+7Is6vAKG6QBLCEIPrBDB+8YtiDAMYpUgUGaCwghSwgAM14MQtoDCIQlhvCO2LBA6OhyIcKEIFDGBBJKyQsDUogQQO2MAGFNEFsSFsITgww3/8Iy2KWOAIXHhABqTwMCRpgSNUsAGHNkCCA2SgBqaEQwVUNBQtqAcSo4DCAA4APQOgJJxDwND2ehhB/5TNjIND8kMZimDBSHCwEPaEBAhBWAd72gEPEYtDHMxwNDjkYWheuJINlaDQq8BNBw51moFIMBgOWMEKY+KhC5rmAnECBi86IIIJ2rQBC3yvBl6gog98AIQdvIEUjXKFLFyBCk2sChHMadUbOIMpTR1iEY0oTWo+5cY3joqORqXjJzLxCEQA4jZv8CMfbaO4QSJHN4dEpOr6gJxNEaKnidCELyRJyWHAgg1iKAMZeqeCDqyART2ogyKGQBCEPGhiHGHA97yDPXQdwAEkwCUe1mC97x3AAhq44YbS1R98+UcNahDZxKSQgg7MgCOKiIUX/NNXeKVgECnoKwLKEAkIIP8gAz8oRA8aOAAOLTBOBoCXCgSBhwoUCUlB2iAk7FAImgSJJx400gaLBIdCDAkOzzLDHIz2TzocBWlokIISziCIkyohalyYQxeGQAIcDOYIWwrDEHDgJUHZQAUpwAEO9JWC8nFgMC7YwCYnxoAiSEELZ5gBEJrAhkCYom+umAUsQHEJMVImVr/xY3N+6qlJeOoSRH3jJowaYTrikRGImNVt/IjhPcRKN7zRzeiAU4c9BFJxwhrcISbBC0kKQzq3wBtae7fdA3SABxZywwpWsCa2mgG9GuhACvywBiHcgQvmreUtzzWHOXxvDUdoSH80cCAGlK8ACsLeLTvwWoqQpAb/UohiH4hHhVt6gQwecMAMJoYAo8CotOhBAANOZIYUMDCBeFCCAa5yACPFpAxKuqCRaHKTDcZkZnbAGZF8Ygc3OMUoLIuYcvVwBjSkIQ5p8IMZuoADLrjgCHFbgQusEjUthXcIXcixEtLgoPbUoAM2WEibSKCCIRwBvb3LnVFm0KxATOIxMQVwZJYaiDHiSg4Y/kMghq3GSniKNUK9hIMfrIkJH7XCk8FwiUtMiBKHLtvKsZXqKrNt1nX1EIZghC4kGQzp7AJvbHCDDRCiAgd0gAw+SEEe5uCCFNjggSWCxBCguAbskm0FeBjEyHCp8AqsIQxhOALACHsAQZCAQ0Kw/8IQlIBXB0hBETUwFL0NlYMz5OCWihjFINwAgQ6wvBCQkAIcHICAHpDBAV1ogQ7ucM4DrGBiXcisSxggwuHoJOVwMJIbYFKGMtjsKH6gAxPmoIegoSGgQvNCc1k0JOLiIaB0KNcaFDGHI+TYBWFQgtK4cHYphKELXbCCGgYjBCXoAAcVgJsS1qQCFZhhTDqwgg1qoAQp3C8oPyADG95wiUYBeBavMIUmNMccQLzhDaBJNrINgYhGOC5URF3NG03liU2AIhWvgAXqX/GKUGiCEo1IxB4TsYjZ0372KD6EuEssM63W6jiDTFwjB8eIW4RVGMWYXSDEMIY6/MBhcAt8D/+kYAYu1boDOHDKM6npgMCUYAIPcAADyjMHHGwAiuAigRru4ILtLuQB/Vm/S+JwhxUowQx33oAZlNCB8XihD16wA1uRhAPUgSP0QAdQkRl0gAp0EB0cgBcUgnlUgKl9iwOUASRAARNEQgMykCLwQZK4gW7BDAW5Qc4QxY7QgR/kQVPQwW4FRQupYP7BgRl4gR8cFB0ogiCYQXlJgR5MnRK8FxegARq0EBesgR5IHxisgRoIgQv8nRUowQ+xANh8DwvoAAvkYNWMiQpIQRwYBUyMQWY0gSaowizIwizQwhd9wiQwAuw1VebZFHMkAudFDui5kejJUSiEAimwQqO0Aiv/oAIphIInVIKFEYJtWB6HddiG9cbhmA7q1EqJbRXrDA50/EIwCIMxSAcjJIob8EAPDEIX+IEi9MAKmIEflID1dEjvrAS6gN8GTAAHTMCJ9JUZcAIXpEQYkAAXoMsDFAAHcIIe1IkGgAHCdIgQwFcGhcEGKEgGrAD/MYEdZIA0msF6zEAdAFkG2IAZOIApDcK3iN0aPEAFdEA4IYAMcAIn4I4NNNABkGCRFEIkdKAb1IrMwEQf1IEK5sEg5IFR+EFP4AEaeEEYBI2qwYEX5IEfnMHR8KPuVJfbdYG0MEAQhkFU1ID9eYEZhIEV2FATVs0QOZSfQMi0sMDXuZ0VZIgN/ySXF8xBH+QG3pCCK9BCLcACgLEeISbCJCwCItAeGyIC46zRp3SCqBCV6OkhKRwlKCSlFhmlbLThH2mYhpWOVO7BrpDgZ0Bitk0iIrgCdRRDJhIDJbABbvxAD5yHEpyQH0jBEJRALa3WQkSCHqTBBqSABZBASMEiRZQiDtRAEOaBBbjA9TjEU9THDjlEBdSaBcALvcHJX25SHsABz10IFzgIFCGAHSiCA0BACigCAsXbBvDcHCjjAFQAaQ2AB3DCKgyCB5wZRbjBFSSJzPDWBCWJPfUB0hxNBsXBkMyBIMRBdeWBIJzQ16UB/wjUCkTNEGCXFHBBF4QmdmHFIAgC4f9hCRqcHReAwcXVSZ38INh0Wt05lBXYX6YNgfTpwWMu2h6wwR6kAizIQi3Mwiy4AutRAmkoVWlkTuYwAmk0G+R8iiZ0wuS8kRzNUR3pYSqkQiBmwiTAXiDwEYlBZVQuoq6I2GdoW7exjualAnVgojEQgymIZRv8gA6aF0kUwi5xzbnkiwpEwvoMAjAOARNNQAswQAfgFfkASoJUQKDImgYowSAogb0cwMBs1PWkV5y0Yg1wpvmlABqsAGc5TA1kAAPQ28esgHh1QS3VAIuWgQesSCRwAg9Q1sQUWh+UQRoEicvExKHNhBfaQU8ogiP0Qc30QUDlAXEhDUQK1Nfl39j/DUEY6GZyzcGUBFEYgIHDNRwVEM11LedkKhSoCcyasIB4SSoYYGkYnIEUUEHPxIQbYEET7EAghAJN2oIsxBTkgYom4OdprCFp7CeDMdtpYALoxZEmHBWFHSUplEIpHGUnUEIbOqhtdBsgJQ5UNRWHIc7q9NQeaYrrnBsigELsHAMyTCssPJUcMMHx1KWBcAAU4oEe2IkOYM/F4cBBWum5+EcBMBEDSAE6xkG+wAsHGMiYcKMgDEbGrIl/RMjHgJ+U4oAgWEFDJNC/3Ed1HQAaDIEWOIgBCIEahIGTCYIiQMIqRAIZIAAEaEEH/I4MMEEfzIGPpMEcaEEfCIIdEKcg/xiJF7hBHfhZIThCPLpBnArUpcFBBjVFHARNc9KB1BGNIPyMFtBBxh0BGMSBRlpBdTIBFQjUc6UB4U3fptFaE0oLB3jHDNWaDdxPkxgFGSzBDsgAIpgCTNVCTKmCIP5nJ6yCUMJGJbTqT7mqp8hqbHhCrRpVUh5oKujqroYC5KxKsvHRto3btjHHuHnb4IIOIKCYTy0C7BGLczROIngCMADDMTQD5dbCH3gGFIDfBZhAJ7FA1MABF4hFCzxAFW5Iq+XYCsAJC4iAAjQEDsTCLeABShBEE8mJA+iYBqzAqQHGEx0BxXGAYnLE92BPLIrAAoDMAShAnBSApxmAHhSCFv9ciAOshQWYQCplABwUzxjQgGamgMtOFskaCVXEhCDAwZkaSRmcAdIc3Qjt03EMQiTkgRQ8nRKYr9QZxXN1AR5gxRp4qyDwzxmQZ/41nBqswc9RRRfoQRy4nTVlHHPSnQvEgSBI6mDEjRJsyRCcjBssHRnwgAzsACWw5yy8Z0yhghbp6it8wqjABiUw2H0GFWxIThzFEd2CAt7i7VEmVSH2bes0kiONkQ/n3g+PEegE3+z9VCLc3iLoZyJcQuROLuXmwh+IJRTUKOm2AIQAmUKZT76aTwVgybm0XQVUbwNQSAbEo12NzPq1zQAspwO4wAqczRgrhBpEAp3IF7poQBj/WEBD1Ec46dsACACHfMwZKEL/QSCHsCO4pEAkDAIEQIADEAkkxAI16kQEnSma9hnIMlcdjBIZDIIjkEHNOEIKwkF0+cEcLCrWTRrR9K8erMEQaKof4MGdDeMaSI3bHZT04YEU4MAQcAHbxU0Y9JgVdIF3CsHSuB3aXaYHlkEWdC0QeMIrwOd78k0o2PAqlIJNOlsMdzOpgJ7ZzrAn5GEomEIe5uoNJ+gjJAIhNOhymFsjxbMPA7HiCG7hmphP/VQjIG4jsGEiSAIvBIMxNEM0IAMvBIJmRMGFVIAO7An0qAAeQMIaYI9D0BID8JsRdcEguECAtA01UUgN2MD32ImU/1HI8TDNEViACoCB+1mALDkRRXAIB+CBRNWa10jkEBTAQ4zMyFSAFJwBJ8TC8cR0hVSAyGimzDmAFsBBPFYAyMbEkoEsn5mpzkhaHNDBIOBOTIxQTMzgQcopcRGFIhCJ+Z5pUJzBHLgsVgvCGsAdGGwJDqiE9AlUplnFprmdHsQd3IQXDkjfpemjGdRMT6zsDniAGJTCNJOwTGlRKmQz5FBCJUB2N8fwN8tw5XwCKHjCUqICZ6NCKrDCgeJw5P0qIAzLGJ02igkuIw0uICUH7T1CIySuTzGChTHCLgzDQEdDMwDDJrLBGACZRZkAhJiPFegBE/ExA2TXBiSZBqAfGP+QgFiIE3+owHE6giB0gBKowfmwgPs1dxfkCwPMhwJgjwLUC165HwdQCBegnyB8Zo2cCIpUQf8YwAooQiHw9PHeUmJSTAZ4wcRgK73lgJpSxQT1RJGUAW+e0PVpwU2A0AgZ1xkAJBq0k8oOlx4Mwk/TIEbOATzGo3SpwQ+2nUrAwc8thUoEVMYplC4yjUNxwVPoDhoIQiHYgRboliKsbBkU9huYnky+p0ztaimsAusxWAtTwmSDc+hZzjlfcx6iQiv44ZODdmingmzwbYO6TusYwiKYGxCLW+Gikbgxhxo1giNAQmz7lGQggi3g9jHoNlg2QRtAQQ3ggRrYCbqYT9b/cAArKcJ8LHdPM0AT1kUDXIADaYAjpAFEfJ3VUNRWQMj5hOsCKW8B1Iic3MuEwMlDkIAi8DEO0FlfDYEicMKpkVM20cBn2YBIO8ACHG8FXGAHMAGKYG8aYPLRwaah8WZUwMEQXnUeLMVRPIVTNAXWCUkhKELHAjAkqCBZX7hTQCRELucQTEkXAKdf5x9EgpfZPKEVRPj+Ms1SN4kHyox2AIEHBMLe0AIt2EJ8osKuXs7aNs6rpsasnson4Co6n3MppMKTrwIr9Lu/N3ZSPcIiNOvgmPYQC65pF66XA/EieAQkWIKZ/xQlIAIiwMIwHEObNwMxdAIQiIEPkAEeHIGU/4UFYIyFCuhAPB4nDrTdZ8pJfzCATh9ADzH094mknRwBV9CHfSgPCRSAAhQAC1yAzxsACSivfyyMEMAJhxjEAUBMS2RAtHOCItABvf2AxVpI+xwAfC2AUR/AhaDEAVRBc6ZBH8x6kpw9TyiCHSTXkjxgQhqN+TrFlEhBznjBIEBCbZnBUhdCHqwA1jHX0DSFw0EkRqaaGcAcLwOUH2Dp7jD+1AxNF+j64ceyFqisIfHBYTyBByBCLMQCLczCLdDCK/S7Nt+RUjWO2zqOZd8RKYR2vgdivn92K3y26vGhH65CCrOGhTlS7fkUl6e262w54OZePB9CI5i5I1gCxMP2Uv9VPDEQAzJEQzQQwys8ARAAQc0VkQVcwAOIBQZI1MPpIh6InX0cgQKoBQMogA50QSLHSV/lS3+MiUNAiH9wAMQpr37E2cvjPwcogBPVC0A4ECRIiiMHBw5wIdFllKIVKc7ccIAgRQ0bDhwsGOhgSAcHEMqkOGAhTZo5Je3Y6VOoz5k+c7SkoWMHDR08hQbFyeMHzxo0eBSFUXIGjh8/UOD0UdoHDh0vOeAMolOSC448eLqs6dLFDJwuaeLASWOmC51CYY4oSat2DRcwUraiOUMHjhctdQYtLcNnj5hRt2LdonVLcCzDhztVelQJU6ZMnTRFftxpVKdPn1ZlHrXq1Sr/Vp9ZvRL96rDh0as+YWp06NCiRq9dN1oUezUhQ6wPESpECBCh3Ldxu3Y03BEkTJYeUVIeixixYciQAVslRoYMKSpS2FARhwWJBxdM6NBwhEOFDRVIaGDAwbsVKwoetHDB4QEDCwdUKHlQgQMHRXhYeGC/AxhgQAEFGqjPggMfUGABAwygr0D6KnDkDCX0cMARPxAaoL5BIjEjhTwGoWKAQdxAAKMKBOFkCC8UcaMGSCJJY4O6SuojjTLmUGoQO9LoI6U84oijED3i0EOQPNAIgw499OCqDjtwKsOlqHDKYyovrqLDDC+4GESoNdaAY44z8PipEDi4UOLJMLhYoQs4/7dSIgwzlOBiCCnO0GIIOxShko8dyBiDjSf+SMQQRBhFJJBHA/lD0j3+gDRSSSsNxJA/GAkkkU8TQcQQTTU1ZFRLRX20UUY23UOON9owtA02xhhDjCaakJUNXIHYoVcgmthhB1ybeOIJXI0VQ4xa2WhWjCeaZeONP954I5BqgfCBBx5SSGEFB6oib4IYcFCPgfMKZMCAkQS8oEAdutCgAgtI4MC+eTnQYE4WGKiAgQMqOFDgFqwoUGAGHjAA4QsE1IATRw5wIAUlhsDoAAEMqKAGNDLowAwtMkgBjm4PyCCHPJTowA9FephBCikqmMOOHwWxw4syVJp5ZiFlLqOONP/RTCOurvLQA44+rdQiKUUGSUrJPI5e2Ywm5+hiDj8EYTMPLsgCc4gwmtQzqzXUOIILrqTQIgcpvDCDrh/rKAOKQgoBxBDbTt30j94Csfu2Rh6ZbZFHCF/sEUswecUSRCbBBJNOMKmkktkYYWSRRBZhpPBGGAGcEk4gWQQ3QuQow3QyyMgiCzL4IISQuNtwowwyep3BAw98wBUL1ckwvY025NhD+FnFkLbZatmg9g05+HADiR/q0MKGGvK7gwMLrtfgAXtXVBh7dRVQrzsN8iWhwAoqkLcCFVyIQz+EFShgggYagAGM/hpEcAKEC4hwP0UE8QCJqUBhOgiDBQp0EAj/HCQDDsjAFchghw5UYF0RU1lSCuHAlPgISFQSRF56lIYznMEObrADVgSBhjTApUxdQIMf4CC9o5UBDimpwxkGkQc7OOUMXoADHqKElTXMgQ44wEEPw2IGuMwBDU3qwhGyUratjNAMI5SCGfLAhz7kpQ91cMPvhDetSJGOL656lRzQyAdA9MYQrrmbqQCxCN8cAhB78Jup8Ni3NZrKdbyx2xolxQc5tCEKUGiCD3yQLSDUCguFbAIUoAAEKPhgB4hMJCKBkEliNSELWDDWIX0lg0yOMpO3agIQeDCDFDChBnCARA9SgAMXtEAEVtDDfiqAkQcIQAMIjN8EHoBAA6hA/w86EFD6VFCvXj5ADcZUgMIQ5CAF2MtABVCACUTAAXcNQAHuQpgOvHAQf+kgEnfIWA3oUIMFOmAFHVBEHWaQAQI5IAACqAAOtAAFSKTAAT+ygyBWMhCVsORHTPEiTgbhh0HogShewsMc4uAHPawJDw+NKNSqmAdBbMULapiDGcKwhiPZBA9wedkV8QTSLnCBC2Y7Wxi6YIUioQEuWmBCEbRQhkHwQYtbzIsaeyO64UACEsORjegKoYihIs4SnMBEUYlqCeM4jhNVrepxQpcb1+VGja4DBGtEx8UStgF1syuDGyDRh7PKrgxkPWsd4Bo3uLqBrl/8XRvqoJQ6/M4NbP9Qlhja0Js+ssQPXviBDMoACSmkoAPJFMEUIqEHf2lABUc4gPYEhgGE9EsBLLjehI7QHR2wAAcWsIAL/mWABUxgAQ1QAAUJtABsNmABFqAgewqkMH9thwEaUCoODsCESPihBh2AkchGwQMEGGAAAQAAADZbBDjwwANCSkkZBEqlLbJErTjzQyFgOIerSCENFcWDIBShCPDigQ5XuwpPuqKHOVTNCmfIyhyUMMUR0nQINhjCGaa2lS4owU5N0oF7wjAHL0ihvx3pQAfOcIUZyIAHP/DBErZ1SiA8AQqVXIITlkCsH+wuClnAK1wH+TsyNOF3aGwxGlN817sOEsYqHkP/FIAwgxncgAYTrk51PEBhGXhgBjQY8u2QfLsfAxnJMqCBko/M5CA3WQYQ8MCDG3g7KPSgAzPQgAZE0AA1KGI+9VKDENRjgQu49gD1QViBTFsABqiglzjoDn/ucwADFEB+BnhtbzXQAAtMQAj9qcADACagNhdIA+2JAz/PEAlOROLBWogDFcoQi0hAAAEHGMBzBVCACqzADx7IwAYFIbOVbNEOcxgEJOwAhykRtS54GITQ6JCHNOShEG4wykkqmoYf8iQNRvEDV4p0BzToAQdKIGITe2iGrqBB2gKe0xrCEAYO6EAtH0WDF5RwEXZ2IAMZqI6VIZDuDHCa0whwd7rd/+1uc89gBz/gwZB/PANFdlgG9S7UhZeASB5UEsQ/+EEUonDvHRzZ1Ol2+MMhzm6If+Th6464w98N73gPYAAIkEHsyuCFM5ShAx6wcsgaywLZbi+YD2j0fPxVTT3Xp0EXAM+63qwC/qgBD4hWbW3B4IIHGaA+JDiAEhQhAgNMgAQT8PODHHRZDmDkWxDog2GSixEbKKIPnBhFD7QgBQMIIAAFOEABNpCCH2xwEAD1kT+7vqYa8qEQfLBZl8A7BzwoFEu65hIcpG0mKQzkDGlQgxr0AMBsr4G9Z6K2WNAEQzQMEQ16z68QjuCeFHphwR3oVgo6lgGTl7vd8TY9xhHg8LAg+8DeOqa3sHYQhSYoeQcz+IETaNDjJdseClFYwg6MjGSLXzziGU99uifykXgTHyMLPH674c3xAcgAChZmgg3IUB0fM7YGXLgABRBWH3wxgASozd+/ENafCUzA5ghTDw7Q14VI2JYBLbiDBdYABgsYoAG93YADSAAHFqAAWkARhIC1FmAAG4ADrEAJHABCMmAJZEC93MDkHGAAauAukqADyMARjC7UHMQCUoATYiEgAAA7", - "text/plain": [ - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "episode = next(iter(ds))\n", - "\n", - "# Iterate over steps of the episode. Collect images.\n", - "images = [\n", - " trajectory[\"observation\"][\"image\"][id]\n", - " for id in range(trajectory[\"observation\"][\"image\"].shape[0])\n", - "]\n", - "images = [Image.fromarray(image.numpy()) for image in images]\n", - "\n", - "display.Image(as_gif(images))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Oy89HzymQyAq" - }, - "source": [ - "## Combination of multiple datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "id": "qs0-7alaQ3C9" - }, - "outputs": [], - "source": [ - "import tensorflow_datasets as tfds\n", - "\n", - "robo_net_builder = tfds.builder_from_directory(\n", - " builder_dir=\"gs://gresearch/robotics/robo_net/1.0.0/\"\n", - ")\n", - "\n", - "robo_net_builder_episodic_dataset = robo_net_builder.as_dataset(split=\"train[:10]\")\n", - "episodes = list(iter(robo_net_builder_episodic_dataset))" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "id": "2tgJpMqARIFQ" - }, - "outputs": [], - "source": [ - "# The following will create a trajectories of length 3.\n", - "trajectory_length = 3\n", - "\n", - "robo_net_rlds_spec = RLDSSpec(\n", - " observation_info=robo_net_builder.info.features[\"steps\"][\"observation\"],\n", - " action_info=robo_net_builder.info.features[\"steps\"][\"action\"],\n", - ")\n", - "\n", - "\n", - "def robo_net_step_map_fn(step):\n", - " transformed_step = {}\n", - " transformed_step[\"observation\"] = step[\"observation\"][\"image\"]\n", - " transformed_step[\"is_first\"] = step[\"is_first\"]\n", - " transformed_step[\"is_last\"] = step[\"is_last\"]\n", - " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", - " return transformed_step\n", - "\n", - "\n", - "robo_net_trajectory_transform = TrajectoryTransformBuilder(\n", - " robo_net_rlds_spec,\n", - " step_map_fn=robo_net_step_map_fn,\n", - " pattern_fn=n_step_pattern_builder(trajectory_length),\n", - ").build(validate_expected_tensor_spec=False)\n", - "\n", - "\n", - "def mt_opt_step_map_fn(step):\n", - " transformed_step = {}\n", - " transformed_step[\"observation\"] = tf.cast(\n", - " tf.image.resize(step[\"observation\"][\"image\"], [240, 320]), tf.uint8\n", - " ) # Resize to be compatible with robo_net trajectory\n", - " transformed_step[\"is_first\"] = step[\"is_first\"]\n", - " transformed_step[\"is_last\"] = step[\"is_last\"]\n", - " transformed_step[\"is_terminal\"] = step[\"is_terminal\"]\n", - " return transformed_step\n", - "\n", - "\n", - "mt_opt_trajectory_transform = TrajectoryTransformBuilder(\n", - " rt1_spec,\n", - " step_map_fn=mt_opt_step_map_fn,\n", - " pattern_fn=n_step_pattern_builder(trajectory_length),\n", - ").build(validate_expected_tensor_spec=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "id": "anGArTQbTiHj" - }, - "outputs": [], - "source": [ - "# Validate that the specs are equal\n", - "assert (\n", - " robo_net_trajectory_transform.expected_tensor_spec\n", - " == mt_opt_trajectory_transform.expected_tensor_spec\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "id": "L9gRx6BfTGH-" - }, - "outputs": [], - "source": [ - "# Create trajectory datasets for the two normalized representations:\n", - "robo_net_trajectory_dataset = (\n", - " robo_net_trajectory_transform.transform_episodic_rlds_dataset(\n", - " robo_net_builder_episodic_dataset\n", - " )\n", - ")\n", - "mt_opt_trajectory_dataset = mt_opt_trajectory_transform.transform_episodic_rlds_dataset(\n", - " ds\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": { - "id": "-SVkHpIxRVXz" - }, - "outputs": [], - "source": [ - "combined_dataset = tf.data.Dataset.sample_from_datasets(\n", - " [robo_net_trajectory_dataset, mt_opt_trajectory_dataset]\n", - ")\n", - "combined_dataset = combined_dataset.batch(2)\n", - "combined_dataset_it = iter(combined_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "id": "-CMdwIcsR30k" - }, - "outputs": [], - "source": [ - "example = next(combined_dataset_it)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 257 - }, - "id": "w2YJOvRKUb2E", - "outputId": "31daf4b7-9350-4d05-9c57-d9784bc34d44" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# First element of the batch returns a robot_net trajectory\n", - "Image.fromarray(example[\"observation\"].numpy()[0][0])" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 257 - }, - "id": "FP0iz-f_UoTY", - "outputId": "244fb34b-fa72-4c02-e432-8a0382f45b17" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Second element of the batch returns a mt_opt trajectory\n", - "Image.fromarray(example[\"observation\"].numpy()[1][0])" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "N2Efw2aHVfSX" - }, - "source": [ - "# Available datasets and their sizes:" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "kQkeUKyrVhGK", - "outputId": "a61cb54f-fd1e-41d0-858b-19d30659c8b1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset gs://gresearch/robotics/fractal20220817_data/0.1.0 has size 111.07 GiB\n", - "Dataset gs://gresearch/robotics/kuka/0.1.0 has size 778.02 GiB\n", - "Dataset gs://gresearch/robotics/bridge/0.1.0 has size 387.49 GiB\n", - "Dataset gs://gresearch/robotics/taco_play/0.1.0 has size 47.77 GiB\n", - "Dataset gs://gresearch/robotics/jaco_play/0.1.0 has size 9.24 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_cable_routing/0.1.0 has size 4.67 GiB\n", - "Dataset gs://gresearch/robotics/roboturk/0.1.0 has size 45.39 GiB\n", - "Dataset gs://gresearch/robotics/nyu_door_opening_surprising_effectiveness/0.1.0 has size 7.12 GiB\n", - "Dataset gs://gresearch/robotics/viola/0.1.0 has size 10.40 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_autolab_ur5/0.1.0 has size 76.39 GiB\n", - "Dataset gs://gresearch/robotics/toto/0.1.0 has size 127.66 GiB\n", - "Dataset gs://gresearch/robotics/language_table/0.0.1 has size 399.23 GiB\n", - "Dataset gs://gresearch/robotics/columbia_cairlab_pusht_real/0.1.0 has size 2.80 GiB\n", - "Dataset gs://gresearch/robotics/stanford_kuka_multimodal_dataset_converted_externally_to_rlds/0.1.0 has size 31.98 GiB\n", - "Dataset gs://gresearch/robotics/nyu_rot_dataset_converted_externally_to_rlds/0.1.0 has size 5.33 MiB\n", - "Dataset gs://gresearch/robotics/stanford_hydra_dataset_converted_externally_to_rlds/0.1.0 has size 72.48 GiB\n", - "Dataset gs://gresearch/robotics/austin_buds_dataset_converted_externally_to_rlds/0.1.0 has size 1.49 GiB\n", - "Dataset gs://gresearch/robotics/nyu_franka_play_dataset_converted_externally_to_rlds/0.1.0 has size 5.18 GiB\n", - "Dataset gs://gresearch/robotics/maniskill_dataset_converted_externally_to_rlds/0.1.0 has size 151.05 GiB\n", - "Dataset gs://gresearch/robotics/cmu_franka_exploration_dataset_converted_externally_to_rlds/0.1.0 has size 602.24 MiB\n", - "Dataset gs://gresearch/robotics/ucsd_kitchen_dataset_converted_externally_to_rlds/0.1.0 has size 1.33 GiB\n", - "Dataset gs://gresearch/robotics/ucsd_pick_and_place_dataset_converted_externally_to_rlds/0.1.0 has size 3.53 GiB\n", - "Dataset gs://gresearch/robotics/austin_sailor_dataset_converted_externally_to_rlds/0.1.0 has size 18.85 GiB\n", - "Dataset gs://gresearch/robotics/austin_sirius_dataset_converted_externally_to_rlds/0.1.0 has size 6.55 GiB\n", - "Dataset gs://gresearch/robotics/bc_z/0.1.0 has size 80.54 GiB\n", - "Dataset gs://gresearch/robotics/usc_cloth_sim_converted_externally_to_rlds/0.1.0 has size 254.52 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_pr2_opening_fridge_converted_externally_to_rlds/0.1.0 has size 360.57 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_pr2_tabletop_manipulation_converted_externally_to_rlds/0.1.0 has size 829.37 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_saytap_converted_externally_to_rlds/0.1.0 has size 55.34 MiB\n", - "Dataset gs://gresearch/robotics/utokyo_xarm_pick_and_place_converted_externally_to_rlds/0.1.0 has size 1.29 GiB\n", - "Dataset gs://gresearch/robotics/utokyo_xarm_bimanual_converted_externally_to_rlds/0.1.0 has size 138.44 MiB\n", - "Dataset gs://gresearch/robotics/robo_net/1.0.0 has size 799.91 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_mvp_converted_externally_to_rlds/0.1.0 has size 12.34 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_rpt_converted_externally_to_rlds/0.1.0 has size 40.64 GiB\n", - "Dataset gs://gresearch/robotics/kaist_nonprehensile_converted_externally_to_rlds/0.1.0 has size 11.71 GiB\n", - "Dataset gs://gresearch/robotics/stanford_mask_vit_converted_externally_to_rlds/0.1.0 has size 76.17 GiB\n", - "Dataset gs://gresearch/robotics/tokyo_u_lsmo_converted_externally_to_rlds/0.1.0 has size 335.71 MiB\n", - "Dataset gs://gresearch/robotics/dlr_sara_pour_converted_externally_to_rlds/0.1.0 has size 2.92 GiB\n", - "Dataset gs://gresearch/robotics/dlr_sara_grid_clamp_converted_externally_to_rlds/0.1.0 has size 1.65 GiB\n", - "Dataset gs://gresearch/robotics/dlr_edan_shared_control_converted_externally_to_rlds/0.1.0 has size 3.09 GiB\n", - "Dataset gs://gresearch/robotics/asu_table_top_converted_externally_to_rlds/0.1.0 has size 737.60 MiB\n", - "Dataset gs://gresearch/robotics/stanford_robocook_converted_externally_to_rlds/0.1.0 has size 124.62 GiB\n", - "Dataset gs://gresearch/robotics/eth_agent_affordances/0.1.0 has size 17.27 GiB\n", - "Dataset gs://gresearch/robotics/imperialcollege_sawyer_wrist_cam/0.1.0 has size 81.87 MiB\n", - "Dataset gs://gresearch/robotics/iamlab_cmu_pickup_insert_converted_externally_to_rlds/0.1.0 has size 50.29 GiB\n", - "Dataset gs://gresearch/robotics/uiuc_d3field/0.1.0 has size 15.82 GiB\n", - "Dataset gs://gresearch/robotics/utaustin_mutex/0.1.0 has size 20.79 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_fanuc_manipulation/0.1.0 has size 8.85 GiB\n", - "Dataset gs://gresearch/robotics/cmu_play_fusion/0.1.0 has size 6.68 GiB\n", - "Dataset gs://gresearch/robotics/cmu_stretch/0.1.0 has size 728.06 MiB\n", - "Dataset gs://gresearch/robotics/berkeley_gnm_recon/0.1.0 has size 18.73 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_gnm_cory_hall/0.1.0 has size 1.39 GiB\n", - "Dataset gs://gresearch/robotics/berkeley_gnm_sac_son/0.1.0 has size 7.00 GiB\n" - ] - } - ], - "source": [ - "# Iterate over and make sure that a dataset can be created\n", - "for name in DATASETS:\n", - " uri = dataset2path(name)\n", - " b = tfds.builder_from_directory(builder_dir=uri)\n", - " split = list(b.info.splits.keys())[0]\n", - " b.as_dataset(split=split)\n", - " print(\"Dataset %s has size %s\" % (uri, b.info.dataset_size))" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "ZnRYMsVpaZKF", - "outputId": "d546a431-5dad-4aee-d6f6-b9aa4207e319" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting git+https://github.com/tensorflow/datasets.git\n", - " Cloning https://github.com/tensorflow/datasets.git to /tmp/pip-req-build-d48q8hrq\n", - " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/datasets.git /tmp/pip-req-build-d48q8hrq\n", - " Resolved https://github.com/tensorflow/datasets.git to commit 0f2cce155781202f05fbe8007a763e12ef9fc6ee\n", - " Installing build dependencies ... \u001b[?25ldone\n", - "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", - "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", - "\u001b[?25hCollecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading absl_py-2.0.0-py3-none-any.whl.metadata (2.3 kB)\n", - "Collecting click (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading click-8.1.7-py3-none-any.whl.metadata (3.0 kB)\n", - "Collecting dm-tree (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading dm_tree-0.1.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (152 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.8/152.8 kB\u001b[0m \u001b[31m654.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m1m687.2 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25hCollecting etils>=0.9.0 (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading etils-1.5.2-py3-none-any.whl.metadata (6.3 kB)\n", - "Collecting numpy (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.2/61.2 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting promise (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached promise-2.3-py3-none-any.whl\n", - "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading protobuf-4.25.0-cp37-abi3-manylinux2014_x86_64.whl.metadata (541 bytes)\n", - "Collecting psutil (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (21 kB)\n", - "Collecting requests>=2.19.0 (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading requests-2.31.0-py3-none-any.whl.metadata (4.6 kB)\n", - "Collecting tensorflow-metadata (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached tensorflow_metadata-1.14.0-py3-none-any.whl.metadata (2.1 kB)\n", - "Collecting termcolor (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading termcolor-2.3.0-py3-none-any.whl (6.9 kB)\n", - "Collecting toml (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", - "Collecting tqdm (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading tqdm-4.66.1-py3-none-any.whl.metadata (57 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.6/57.6 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting wrapt (from tensorflow-datasets==4.9.3+nightly)\n", - " Downloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n", - "Collecting array-record>=0.5.0 (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (503 bytes)\n", - "Collecting fsspec (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading fsspec-2023.10.0-py3-none-any.whl.metadata (6.8 kB)\n", - "Collecting importlib_resources (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading importlib_resources-6.1.1-py3-none-any.whl.metadata (4.1 kB)\n", - "Collecting typing_extensions (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading typing_extensions-4.8.0-py3-none-any.whl.metadata (3.0 kB)\n", - "Collecting zipp (from etils[enp,epath,etree]>=0.9.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading zipp-3.17.0-py3-none-any.whl.metadata (3.7 kB)\n", - "Collecting charset-normalizer<4,>=2 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (33 kB)\n", - "Collecting idna<4,>=2.5 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading idna-3.4-py3-none-any.whl (61 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.5/61.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting urllib3<3,>=1.21.1 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading urllib3-2.0.7-py3-none-any.whl.metadata (6.6 kB)\n", - "Collecting certifi>=2017.4.17 (from requests>=2.19.0->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading certifi-2023.7.22-py3-none-any.whl.metadata (2.2 kB)\n", - "Collecting six (from promise->tensorflow-datasets==4.9.3+nightly)\n", - " Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n", - "Collecting absl-py (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached absl_py-1.4.0-py3-none-any.whl (126 kB)\n", - "Collecting googleapis-common-protos<2,>=1.52.0 (from tensorflow-metadata->tensorflow-datasets==4.9.3+nightly)\n", - " Using cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl.metadata (1.5 kB)\n", - "Collecting protobuf>=3.20 (from tensorflow-datasets==4.9.3+nightly)\n", - " Using cached protobuf-3.20.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n", - "Using cached array_record-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.0 MB)\n", - "Downloading etils-1.5.2-py3-none-any.whl (140 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading requests-2.31.0-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.6/62.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading click-8.1.7-py3-none-any.whl (97 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.9/97.9 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading numpy-1.26.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.2/18.2 MB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m[36m0:00:01\u001b[0m\n", - "\u001b[?25hDownloading psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (283 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m283.6/283.6 kB\u001b[0m \u001b[31m16.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hUsing cached tensorflow_metadata-1.14.0-py3-none-any.whl (28 kB)\n", - "Downloading tqdm-4.66.1-py3-none-any.whl (78 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.3/78.3 kB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (80 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m80.3/80.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading certifi-2023.7.22-py3-none-any.whl (158 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.3/158.3 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (142 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m142.1/142.1 kB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hUsing cached googleapis_common_protos-1.61.0-py2.py3-none-any.whl (230 kB)\n", - "Downloading urllib3-2.0.7-py3-none-any.whl (124 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 kB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading fsspec-2023.10.0-py3-none-any.whl (166 kB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m166.4/166.4 kB\u001b[0m \u001b[31m13.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading importlib_resources-6.1.1-py3-none-any.whl (33 kB)\n", - "Downloading typing_extensions-4.8.0-py3-none-any.whl (31 kB)\n", - "Downloading zipp-3.17.0-py3-none-any.whl (7.4 kB)\n", - "Building wheels for collected packages: tensorflow-datasets\n", - " Building wheel for tensorflow-datasets (pyproject.toml) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for tensorflow-datasets: filename=tensorflow_datasets-4.9.3+nightly-py3-none-any.whl size=5042188 sha256=b922a59c63a43266324047d6de8cc70c4e902e4be1002a629f6fc9144b42026e\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-yum8n3h3/wheels/69/95/f3/0a7e5341cee7ec33827b33149e1556b4e39317c704cb2751bd\n", - "Successfully built tensorflow-datasets\n", - "Installing collected packages: dm-tree, zipp, wrapt, urllib3, typing_extensions, tqdm, toml, termcolor, six, psutil, protobuf, numpy, importlib_resources, idna, fsspec, etils, click, charset-normalizer, certifi, absl-py, requests, promise, googleapis-common-protos, tensorflow-metadata, array-record, tensorflow-datasets\n", - " Attempting uninstall: dm-tree\n", - " Found existing installation: dm-tree 0.1.8\n", - " Uninstalling dm-tree-0.1.8:\n", - " Successfully uninstalled dm-tree-0.1.8\n", - " Attempting uninstall: zipp\n", - " Found existing installation: zipp 3.17.0\n", - " Uninstalling zipp-3.17.0:\n", - " Successfully uninstalled zipp-3.17.0\n", - " Attempting uninstall: wrapt\n", - " Found existing installation: wrapt 1.14.1\n", - " Uninstalling wrapt-1.14.1:\n", - " Successfully uninstalled wrapt-1.14.1\n", - " Attempting uninstall: urllib3\n", - " Found existing installation: urllib3 1.26.16\n", - " Uninstalling urllib3-1.26.16:\n", - " Successfully uninstalled urllib3-1.26.16\n", - " Attempting uninstall: typing_extensions\n", - " Found existing installation: typing_extensions 4.6.3\n", - " Uninstalling typing_extensions-4.6.3:\n", - " Successfully uninstalled typing_extensions-4.6.3\n", - " Attempting uninstall: tqdm\n", - " Found existing installation: tqdm 4.65.0\n", - " Uninstalling tqdm-4.65.0:\n", - " Successfully uninstalled tqdm-4.65.0\n", - " Attempting uninstall: toml\n", - " Found existing installation: toml 0.10.2\n", - " Uninstalling toml-0.10.2:\n", - " Successfully uninstalled toml-0.10.2\n", - " Attempting uninstall: termcolor\n", - " Found existing installation: termcolor 2.3.0\n", - " Uninstalling termcolor-2.3.0:\n", - " Successfully uninstalled termcolor-2.3.0\n", - " Attempting uninstall: six\n", - " Found existing installation: six 1.16.0\n", - " Uninstalling six-1.16.0:\n", - " Successfully uninstalled six-1.16.0\n", - " Attempting uninstall: psutil\n", - " Found existing installation: psutil 5.9.0\n", - " Uninstalling psutil-5.9.0:\n", - " Successfully uninstalled psutil-5.9.0\n", - " Attempting uninstall: protobuf\n", - " Found existing installation: protobuf 3.20.3\n", - " Uninstalling protobuf-3.20.3:\n", - " Successfully uninstalled protobuf-3.20.3\n", - " Attempting uninstall: numpy\n", - " Found existing installation: numpy 1.25.0\n", - " Uninstalling numpy-1.25.0:\n", - " Successfully uninstalled numpy-1.25.0\n", - " Attempting uninstall: importlib_resources\n", - " Found existing installation: importlib-resources 6.1.1\n", - " Uninstalling importlib-resources-6.1.1:\n", - " Successfully uninstalled importlib-resources-6.1.1\n", - " Attempting uninstall: idna\n", - " Found existing installation: idna 3.4\n", - " Uninstalling idna-3.4:\n", - " Successfully uninstalled idna-3.4\n", - " Attempting uninstall: fsspec\n", - " Found existing installation: fsspec 2023.9.2\n", - " Uninstalling fsspec-2023.9.2:\n", - " Successfully uninstalled fsspec-2023.9.2\n", - " Attempting uninstall: etils\n", - " Found existing installation: etils 1.5.2\n", - " Uninstalling etils-1.5.2:\n", - " Successfully uninstalled etils-1.5.2\n", - " Attempting uninstall: click\n", - " Found existing installation: click 8.1.7\n", - " Uninstalling click-8.1.7:\n", - " Successfully uninstalled click-8.1.7\n", - " Attempting uninstall: charset-normalizer\n", - " Found existing installation: charset-normalizer 2.0.4\n", - " Uninstalling charset-normalizer-2.0.4:\n", - " Successfully uninstalled charset-normalizer-2.0.4\n", - " Attempting uninstall: certifi\n", - " Found existing installation: certifi 2023.5.7\n", - " Uninstalling certifi-2023.5.7:\n", - " Successfully uninstalled certifi-2023.5.7\n", - " Attempting uninstall: absl-py\n", - " Found existing installation: absl-py 1.4.0\n", - " Uninstalling absl-py-1.4.0:\n", - " Successfully uninstalled absl-py-1.4.0\n", - " Attempting uninstall: requests\n", - " Found existing installation: requests 2.29.0\n", - " Uninstalling requests-2.29.0:\n", - " Successfully uninstalled requests-2.29.0\n", - " Attempting uninstall: promise\n", - " Found existing installation: promise 2.3\n", - " Uninstalling promise-2.3:\n", - " Successfully uninstalled promise-2.3\n", - " Attempting uninstall: googleapis-common-protos\n", - " Found existing installation: googleapis-common-protos 1.61.0\n", - " Uninstalling googleapis-common-protos-1.61.0:\n", - " Successfully uninstalled googleapis-common-protos-1.61.0\n", - " Attempting uninstall: tensorflow-metadata\n", - " Found existing installation: tensorflow-metadata 1.14.0\n", - " Uninstalling tensorflow-metadata-1.14.0:\n", - " Successfully uninstalled tensorflow-metadata-1.14.0\n", - " Attempting uninstall: array-record\n", - " Found existing installation: array-record 0.5.0\n", - " Uninstalling array-record-0.5.0:\n", - " Successfully uninstalled array-record-0.5.0\n", - " Attempting uninstall: tensorflow-datasets\n", - " Found existing installation: tensorflow-datasets 4.9.3\n", - " Uninstalling tensorflow-datasets-4.9.3:\n", - " Successfully uninstalled tensorflow-datasets-4.9.3\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "tensorflow 2.14.0 requires wrapt<1.15,>=1.11.0, but you have wrapt 1.16.0 which is incompatible.\u001b[0m\u001b[31m\n", - "\u001b[0mSuccessfully installed absl-py-1.4.0 array-record-0.5.0 certifi-2023.7.22 charset-normalizer-3.3.2 click-8.1.7 dm-tree-0.1.8 etils-1.5.2 fsspec-2023.10.0 googleapis-common-protos-1.61.0 idna-3.4 importlib_resources-6.1.1 numpy-1.26.1 promise-2.3 protobuf-3.20.3 psutil-5.9.6 requests-2.31.0 six-1.16.0 tensorflow-datasets-4.9.3+nightly tensorflow-metadata-1.14.0 termcolor-2.3.0 toml-0.10.2 tqdm-4.66.1 typing_extensions-4.8.0 urllib3-2.0.7 wrapt-1.16.0 zipp-3.17.0\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "# Might require updating tensorflow datasets:\n", - "%pip install --upgrade --force-reinstall git+https://github.com/tensorflow/datasets.git" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bPhwnlk1a1lq", - "outputId": "90ec1c89-2ef7-4cd6-aa39-b2df72da15de" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fractal20220817_data\n", - "bc_z\n" - ] - } - ], - "source": [ - "for name in DATASET_NAMES:\n", - " print(name)\n", - " b = tfds.builder_from_directory(builder_dir=dataset2path(name))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/README.md b/README.md deleted file mode 100644 index 930fa939a..000000000 --- a/README.md +++ /dev/null @@ -1,66 +0,0 @@ -# NPM-Dataset -A comprehensive robotics dataset that includes navigation, perception, and manipulation data per data point. - -# RT-1 (Robotic Transformer) PyTorch Implementation - - -A forked implementation of RT1 (Robotic Transformer) originally inspired by the Google Research paper. - -This implemenetation of RT-1 was pretrained on the Bridge dataset and further fine-tuned on our LaNMP dataset for evaluation. Please find details of the repository below - -## Setup Instructions - -```bash -git clone https://github.com/h2r/NPM-Dataset.git -git checkout -b rt1 -pip install -e . -``` - -## Overview of files - -This repository has 7 critical files/folders whose use cases are described below - -1) ```main.py```: used to pretrain RT-1 on the bridge dataset. Modifying this file to accomodate different datasets requires changing the ```observation_space``` and ```action_space``` according to the dataset being loaded, as well as changing the dataset keys in ```rt1_pytorch/tokenizers/action_tokenizer.py```. Running this file saves a series of checkpoints and logs losses using weights and biases -2) ```main_ft.py```: used to finetune RT-1 on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset finetuning (AI2Thor). Running this file saves a series of checkpoints and logs losses using weights and biases -3) ```main_ft_eval.py```: used to run RT-1 in inference mode on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset (AI2Thor). The file iterates/loads all saved checkpoints from finetuning and runs RT-1 on inference mode for the validation dataset on each checkpoint. The script logs the test losses using weights and biases -4) ```ai2thor_env.py```: contains a Gym environment style class to load and take steps in AI2Thor enivironment. This file is used to generate real-time trajectories based on the action tokens generated by a finetuned RT-1 model (specific for AI2Thor). The main ```step()``` function takes/executes the generated action by RT-1 and returns a success message along with information about the environment state e.g. object or agent metadata, which can be saved to capture the trajectory taken by the agent for a given task -5) ```rollout_ai2thor.py```: interfaces between the finetuned RT-1 model (from a loaded checkpoint after finetuning on LaNMP) and the ```ai2thor_env.py``` Gym environment, in order to send observations from the AI2Thor environment to RT-1 and execute proposed action tokens by RT-1 on AI2Thor. Note that this file should not be run on a headless machine since it requires/deploys AI2Thor simulator GUI -6) ```rt1_pytorch/rt1_policy.py```: contains the RT-1 model implementation in PyTorch. The ```loss()``` function performs forward pass of RT-1 for training and ```act()``` function performs the forward pass during inference. -7) ```lanmp_dataloader/rt1_dataloader.py```: contains the ```DatasetManager``` class that extracts trajectories from the LaNMP ```sim_data.hdf5``` dataset file. The script automatically separates train and validation subsets according to different splits e.g. k-fold by scene, task wise or for diversity ablation. The ```DatasetManager``` also handles tokenizing/detokenizing the raw trajectory data into 256 discrete buckets, whilst also chunking trajectories across non-overlapping window lengths of 6 steps - -## Details about file arguments - -Most relevant files in this repository accept the same set of arguments that are detailed below -* ```dataset```: only for the ```main.py``` file, specifies the dataset on which the RT-1 model should be pretrained -* ```train-split```: specifies what fraction of the loaded dataset should be used for training v.s. evaluation -* ```eval-split```: specifies what fraction of the laoded dataset should be used for evaluation v.s. training -* ```epochs```: total number of passes over the all batches of the training set -* ```lr```: learning rate for cross-entropy loss of RT1 -* ```train-batch-size```: the number of trajectories from which to sample data for the current training batch -* ```eval-batch-size```: the number of trajectories from which to sample data for the current evaluation batch -* ```trajectory-length```: the window size (context history of ```trajecotry-length``` previous images) used for each trajectory when feeding data to RT-1 model; this is set to 6 based on the RT-1 implementation -* ```sentence-transformer```: the language embedding to apply on the language-specified task -* ```device```: the device to load the model/data onto during training/inference -* ```eval-freq```: the interval of batches at which to run evaluation/inference on the validation dataset (currently set to 0 in ```main_ft.py```) -* ```checkpoint-freq```: the interval of batches at which to save a checkpoint during training -* ```checkpoint-dir```: the directory path at which to save a checkpoint during training -* ```load-checkpoint```: (optional) path of the pretrained checkpoint to load for further fine-tuning -* ```wandb```: boolean determining if logging to weights and biases should happen -* ```eval-scene```: the AI2Thor scene number in the dataset that is held out of the training set for evaluation during k-fold cross validation across scenes -* ```split-type```: determines the split type (i.e. k-fold by scene, task wise or diversity ablation) between train and evaluation used by the ```DatasetManager``` in ```rt1_dataloader.py``` -* ```num-diversity-scenes```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of scenes to perform diversity ablation over i.e. maximum of 4 for LaNMP simulation data -* ```max-diversity-trajectories```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of trajectories that are divided evenly across the number of ```num-diversity-scenes``` scenes -* ```train-subbatch```: the batch size to use during training/finetuning -* ```eval-subbatch```: the batch size to use during evaluation - -## Checkpoint samples - -Please find the follow checkpoints samples that can be loaded to the RT-1 model. These can be found on the supplementary Google Drive associated with this project -* ```sample_checkpoints/pretrained_bridge```: the final checkpoint saved when pretraining the RT-1 model on the Bridge dataset -* ```sample_checkpoints/task_gen```: the final checkpoint saved after finetuning RT-1 model on the task-wise split for the task generalization experiment - -## Additional notes - -When running any of the finetuning or pretraining scripts, please ensure the following modules are loaded -```module load cuda/11.8.0-lpttyok``` -```module load cudnn/8.7.0.84-11.8-lg2dpd5``` diff --git a/ai2thor_env.py b/ai2thor_env.py deleted file mode 100644 index 60047ecfc..000000000 --- a/ai2thor_env.py +++ /dev/null @@ -1,641 +0,0 @@ - -import copy -import numpy as np -from collections import Counter, OrderedDict -import ai2thor -from ai2thor.controller import Controller -from json import load -from os import path -import sys -sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred') -sys.path.append('~/data/ajaafar/NPM-Dataset/models/main_models/alfred/gen') -import gen.constants as constants -# import gen.utils.image_util as image_util -# from gen.utils import game_util -# from gen.utils.game_util import get_objects_of_type, get_obj_of_type_closest_to_obj -from random import choice, randint -from time import sleep -import pdb - -DEFAULT_RENDER_SETTINGS = {'renderImage': True, - 'renderDepthImage': True, - 'renderClassImage': False, - 'renderObjectImage': False, - } - -class ThorEnv(): - def __init__(self, task, max_episode_length = 1500): - - self.controller = None - self.last_event = None - - self.task = task - self.max_episode_length = max_episode_length - - - def reset(self, scene_name): - ''' - reset scene / start scene - ''' - print('Starting Ai2Thor Env...') - self.controller = Controller( - agentMode="arm", - massThreshold=None, - scene=scene_name, - visibilityDistance=1.5, - gridSize=0.25, - renderDepthImage=False, - renderInstanceSegmentation=False, - snapToGrid=False, - width=300, - height=300, - fieldOfView=60 - ) - self.last_event = self.controller.last_event - return self.last_event - - - def step(self, action, kwargs): - - if action in set(['MoveAgent','RotateAgent']): - - if action == 'MoveAgent': - - event_move = self.controller.step( - action="Teleport", - position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) - ) - - #execute a rotation body operation - event_rotate = self.controller.step( - action="RotateAgent", - degrees=kwargs['body_yaw_delta'], - returnToStart=False, - speed=1, - fixedDeltaTime=0.02 - ) - - success = event_move.metadata['lastActionSuccess'] - error = [event_move.metadata['errorMessage']] - self.last_event = event_move - - - elif action == 'RotateAgent': - - #execute a rotation body operation - event_rotate = self.controller.step( - action="RotateAgent", - degrees=kwargs['body_yaw_delta'], - returnToStart=False, - speed=1, - fixedDeltaTime=0.02 - ) - - event_move = self.controller.step( - action="Teleport", - position=dict(x=kwargs['xyz_body'][0], y=kwargs['xyz_body'][1], z=kwargs['xyz_body'][2]) - ) - - success = event_rotate.metadata['lastActionSuccess'] - error = [event_rotate.metadata['errorMessage']] - self.last_event = event_rotate - - - - elif action == 'MoveArm': - - #execute smooth move arm operation - event = self.controller.step( - action="MoveArm", - position=dict(x=kwargs['arm_position'][0], y=kwargs['arm_position'][1], z=kwargs['arm_position'][2]), - coordinateSpace="world", - restrictMovement=False, - speed=1, - returnToStart=False, - fixedDeltaTime=0.02 - ) - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action == 'PickupObject': - - #execute pickup - event = self.controller.step( - action="PickupObject", - objectIdCandidates=[] - ) - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action == 'ReleaseObject': - - #execute pickup - event = self.controller.step( - action="ReleaseObject", - objectIdCandidates=[] - ) - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action in set(['LookDown','LookUp']): - - #execute smooth change in pitch - events = self.smooth_look(action) - - success = events[-1].metadata['lastActionSuccess'] if len(events)>0 else False - error = [events[-1].metadata['errorMessage']] if len(events)>0 else ['Reached boundary of LookUp/LookDown'] - self.last_event = events[-1] if len(events)>0 else self.last_event - - - elif action == 'stop': - #stop the execution - event = self.controller.step(action="Done") - - success = event.metadata['lastActionSuccess'] - error = [event.metadata['errorMessage']] - self.last_event = event - - elif action == None: - #no operation to be done - success = True - error = [''] - - else: - - raise Exception('Error: the provided action {} is not valid'.format(action)) - - return success, error, self.last_event - - def step_old(self, action, smooth_nav=False): - ''' - overrides ai2thor.controller.Controller.step() for smooth navigation and goal_condition updates - ''' - if 'action' in action: - if smooth_nav: - if "MoveAhead" in action['action']: - self.smooth_move_ahead(action) - elif "Rotate" in action['action']: - self.smooth_rotate(action) - elif "Look" in action['action']: - self.smooth_look(action) - else: - super().step(action) - else: - if "LookUp" in action['action']: - self.look_angle(-constants.AGENT_HORIZON_ADJ) - elif "LookDown" in action['action']: - self.look_angle(constants.AGENT_HORIZON_ADJ) - else: - super().step(action) - else: - super().step(action) - - event = self.update_states(action) - self.check_post_conditions(action) - return event - - - - def noop(self): - ''' - do nothing - ''' - super().step(dict(action='Pass')) - - def smooth_move_ahead(self, action, render_settings=None): - ''' - smoother MoveAhead - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - smoothing_factor = constants.RECORD_SMOOTHING_FACTOR - new_action = copy.deepcopy(action) - new_action['moveMagnitude'] = constants.AGENT_STEP_SIZE / smoothing_factor - - new_action['renderImage'] = render_settings['renderImage'] - new_action['renderClassImage'] = render_settings['renderClassImage'] - new_action['renderObjectImage'] = render_settings['renderObjectImage'] - new_action['renderDepthImage'] = render_settings['renderDepthImage'] - - events = [] - for xx in range(smoothing_factor - 1): - event = super().step(new_action) - if event.metadata['lastActionSuccess']: - events.append(event) - - event = super().step(new_action) - if event.metadata['lastActionSuccess']: - events.append(event) - return events - - def smooth_rotate(self, action, render_settings=None): - ''' - smoother RotateLeft and RotateRight - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - event = self.last_event - horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) - position = event.metadata['agent']['position'] - rotation = event.metadata['agent']['rotation'] - start_rotation = rotation['y'] - if action['action'] == 'RotateLeft': - end_rotation = (start_rotation - 90) - else: - end_rotation = (start_rotation + 90) - - events = [] - for xx in np.arange(.1, 1.0001, .1): - if xx < 1: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': horizon, - 'tempRenderChange': True, - 'renderNormalsImage': False, - 'renderImage': render_settings['renderImage'], - 'renderClassImage': render_settings['renderClassImage'], - 'renderObjectImage': render_settings['renderObjectImage'], - 'renderDepthImage': render_settings['renderDepthImage'], - } - event = super().step(teleport_action) - else: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': np.round(start_rotation * (1 - xx) + end_rotation * xx, 3), - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': horizon, - } - event = super().step(teleport_action) - - if event.metadata['lastActionSuccess']: - events.append(event) - return events - - def smooth_look(self, action, render_settings=None): - ''' - smoother LookUp and LookDown - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - event = self.last_event - start_horizon = event.metadata['agent']['cameraHorizon'] - rotation = np.round(event.metadata['agent']['rotation']['y'], 4) - end_horizon = start_horizon + constants.AGENT_HORIZON_ADJ * (1 - 2 * int(action == 'LookUp')) - position = event.metadata['agent']['position'] - - events = [] - for xx in np.arange(.1, 1.0001, .1): - if xx < 1: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': rotation, - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), - 'tempRenderChange': True, - 'renderNormalsImage': False, - 'renderImage': render_settings['renderImage'], - 'renderClassImage': render_settings['renderClassImage'], - 'renderObjectImage': render_settings['renderObjectImage'], - 'renderDepthImage': render_settings['renderDepthImage'], - 'standing': True, - } - event = self.controller.step(teleport_action) - else: - teleport_action = { - 'action': 'TeleportFull', - 'rotation': rotation, - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': np.round(start_horizon * (1 - xx) + end_horizon * xx, 3), - 'standing':True, - } - event = self.controller.step(teleport_action) - - if event.metadata['lastActionSuccess']: - events.append(event) - - return events - - def rotate_angle(self, angle, render_settings=None): - ''' - rotate at a specific angle - ''' - if render_settings is None: - render_settings = DEFAULT_RENDER_SETTINGS - event = self.last_event - horizon = np.round(event.metadata['agent']['cameraHorizon'], 4) - position = event.metadata['agent']['position'] - rotation = event.metadata['agent']['rotation'] - start_rotation = rotation['y'] - end_rotation = start_rotation + angle - - teleport_action = { - 'action': 'TeleportFull', - 'rotation': np.round(end_rotation, 3), - 'x': position['x'], - 'z': position['z'], - 'y': position['y'], - 'horizon': horizon, - 'tempRenderChange': True, - 'renderNormalsImage': False, - 'renderImage': render_settings['renderImage'], - 'renderClassImage': render_settings['renderClassImage'], - 'renderObjectImage': render_settings['renderObjectImage'], - 'renderDepthImage': render_settings['renderDepthImage'], - } - event = super().step(teleport_action) - return event - - def to_thor_api_exec(self, action, object_id="", smooth_nav=False): - # TODO: parametrized navigation commands - - if "RotateLeft" in action: - action = dict(action="RotateLeft", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "RotateRight" in action: - action = dict(action="RotateRight", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "MoveAhead" in action: - action = dict(action="MoveAhead", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "LookUp" in action: - action = dict(action="LookUp", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "LookDown" in action: - action = dict(action="LookDown", - forceAction=True) - event = self.step(action, smooth_nav=smooth_nav) - elif "OpenObject" in action: - action = dict(action="OpenObject", - objectId=object_id, - moveMagnitude=1.0) - event = self.step(action) - elif "CloseObject" in action: - action = dict(action="CloseObject", - objectId=object_id, - forceAction=True) - event = self.step(action) - elif "PickupObject" in action: - action = dict(action="PickupObject", - objectId=object_id) - event = self.step(action) - elif "PutObject" in action: - inventory_object_id = self.last_event.metadata['inventoryObjects'][0]['objectId'] - action = dict(action="PutObject", - objectId=object_id, - forceAction=True, - placeStationary=True) - event = self.step(action) - elif "ToggleObjectOn" in action: - action = dict(action="ToggleObjectOn", - objectId=object_id) - event = self.step(action) - - elif "ToggleObjectOff" in action: - action = dict(action="ToggleObjectOff", - objectId=object_id) - event = self.step(action) - elif "SliceObject" in action: - # check if agent is holding knife in hand - inventory_objects = self.last_event.metadata['inventoryObjects'] - if len(inventory_objects) == 0 or 'Knife' not in inventory_objects[0]['objectType']: - raise Exception("Agent should be holding a knife before slicing.") - - action = dict(action="SliceObject", - objectId=object_id) - event = self.step(action) - else: - raise Exception("Invalid action. Conversion to THOR API failed! (action='" + str(action) + "')") - - return event, action - - def take_action(self, word_action, num_action, rand_agent=False): - i = 0 - incr = 0.025 - x = 0 - y = 0 - z = 0 - fixedDeltaTime = 0.02 - move = 0.2 - a = None - - if rand_agent: - all_word_actions = ['PickupObject','ReleaseObject', 'LookUp', 'LookDown', 'MoveArm', 'MoveArmBase', 'RotateAgent', 'MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft', 'stop'] - rand_word_action = choice(all_word_actions) - if rand_word_action in ["stop"]: - return "stop", None - elif rand_word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: - a = dict(action = rand_word_action) - elif rand_word_action in ['MoveArm', 'MoveArmBase']: - global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] - curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] - rand_x_indx, rand_y_indx, rand_z_indx = randint(1, 256), randint(1, 256), randint(1, 256) # starts at 1 to skip NoOp - x_del, y_del, z_del = self.bins["4"][rand_x_indx], self.bins["5"][rand_y_indx], self.bins["6"][rand_z_indx] - new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del - a = dict(action='MoveArm', position=dict(x=new_x, y=new_y, z=new_z),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) - elif rand_word_action in ['RotateAgent']: - rand_yaw_indx = randint(1, 256) - new_yaw = self.bins["3"][rand_yaw_indx] - a = dict(action=rand_word_action, degrees=new_yaw, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - else: # move base - a = dict(action=rand_word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - - else: - if word_action in ['NoOp']: - print(f"Word Action: NoOP", end="\r") # for debugging - return None, None, self.last_event.metadata - if word_action in ['PickupObject','ReleaseObject', 'LookUp', 'LookDown']: - a = dict(action = word_action) - elif word_action in ['MoveArm', 'MoveArmBase']: - global_coord_ee = self.last_event.metadata["arm"]["joints"][3]['position'] - curr_x, curr_y, curr_z = global_coord_ee['x'], global_coord_ee['y'], global_coord_ee['z'] - x_del, y_del, z_del = self.bins["4"][num_action[0]], self.bins["5"][num_action[1]], self.bins["6"][num_action[2]] - if x_del == -1000 or y_del == -1000 or z_del == -1000: # if any of them are NoOp then skip all. Can do it another way where only skip the specific axis - print(f"Word Action: NoOP", end="\r") # for debugging - return None, None, self.last_event.metadata - new_x, new_y, new_z = curr_x + x_del, curr_y + y_del, curr_z + z_del - a = dict(action='MoveArm',position=dict(x=new_x, y=new_z, z=new_y),coordinateSpace="world",restrictMovement=False,speed=1,returnToStart=False,fixedDeltaTime=fixedDeltaTime) - elif word_action in ['RotateAgent']: - yaw_del = num_action.item() - new_yaw = self.bins["3"][yaw_del] - if new_yaw == -1000: #make it variable later - print(f"Word Action: NoOP", end="\r") # for debugging - return None, None, self.last_event.metadata - a = dict(action=word_action, degrees=new_yaw,returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - else: # move base - a = dict(action=word_action, moveMagnitude=move, returnToStart=False,speed=1,fixedDeltaTime=fixedDeltaTime) - - sleep(0.5) #for debugging/movement analysis - event = self.controller.step(a) - success = event.metadata['lastActionSuccess'] - error = event.metadata['errorMessage'] - self.last_event = event - #for debugging/movement analysis - sleep(0.5) - if rand_agent: - print(f"Random Word Action: {rand_word_action} ", end="\r") - # else: - # print(f"Word Action: {word_action} ", end="\r") - # print(f"Num Action: {num_action} ", end="\r") - - return success, error, self.last_event.metadata - - - - -if __name__ == '__main__': - - SCENE_NAME = 'FloorPlan_Train5_1' - TESTED_STEPS = 200 - - test = ThorEnv('Walk to the living room') - - event = test.reset(scene_name=SCENE_NAME) - - curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) - curr_body_yaw = event.metadata['agent']['rotation']['y'] - curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) - agent_holding = np.array([]) - - - test.controller.step( - action="MoveArmBase", - y=0.0, - speed=1, - returnToStart=True, - fixedDeltaTime=0.02 - ) - - - for i in range(TESTED_STEPS): - - print(''' - (1) Move X+ - (2) Move X- - (3) Move Z+ - (4) Move Z- - (5) Rotate Left - (6) Rotate Right - (7) Rotate Up - (8) Rotate Down - (9) Open Gripper - (0) Close Gripper - (h) Move Gripper up - (n) Move Gripper down - (b) Move Gripper left - (m) Move Gripper right - (z) Move Gripper forward - (x) Move Gripper backwards - ''') - - - action = input('>') - - - if action == '1': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[0] += 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '2': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[0] -= 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '3': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[2] += 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '4': - - temp_body_coordinate = copy.copy(curr_body_coordinate) - temp_body_coordinate[2] -= 0.05 - - success, error, event = test.step('MoveAgent', {'xyz_body': temp_body_coordinate, 'body_yaw_delta': 0}) - - elif action == '5': - - success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta': -90}) - - elif action == '6': - - success, error, event = test.step('RotateAgent', {'xyz_body': curr_body_coordinate, 'body_yaw_delta':+90}) - - elif action == '7': - - success, error, event = test.step('LookUp', {}) - - elif action == '8': - - success, error, event = test.step('LookDown', {}) - - elif action == '9': - - success, error, event = test.step('PickupObject', {}) - - elif action == '0': - - success, error, event = test.step('ReleaseObject', {}) - - elif action == 'h': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[1] += 0.20 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'n': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[1] -= 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'b': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[0] += 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'm': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[0] -= 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'z': - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[2] += 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) - - elif action == 'x': - - temp_arm_coordinate = copy.copy(curr_arm_coordinate) - temp_arm_coordinate[2] -= 0.05 - - success, error, event = test.step('MoveArm', {'arm_position': temp_arm_coordinate}) diff --git a/data.py b/data.py deleted file mode 100644 index 71bff29ba..000000000 --- a/data.py +++ /dev/null @@ -1,536 +0,0 @@ -# Taken from https://docs.google.com/spreadsheets/d/1rPBD77tk60AEIGZrGSODwyyzs5FgCU9Uz3h-3_t2A9g/edit#gid=0 -import abc -import dataclasses -from typing import Any, Dict, Iterable, Optional, Union -import pdb -import numpy as np -import reverb -import tensorflow as tf -import tensorflow_datasets as tfds -import tree -from rlds import rlds_types, transformations - -tf.config.experimental.set_visible_devices([], "GPU") - - -def dataset2path(name): - if name == "robo_net": - version = "1.0.0" - elif name == "language_table": - version = "0.0.1" - else: - version = "0.1.0" - return f"gs://gresearch/robotics/{name}/{version}" - - -def as_gif(images, path="temp.gif"): - # Render the images as the gif: - images[0].save(path, save_all=True, append_images=images[1:], duration=1000, loop=0) - gif_bytes = open(path, "rb").read() - return gif_bytes - - -def _features_to_tensor_spec(feature: tfds.features.FeatureConnector) -> tf.TensorSpec: - """Converts a tfds Feature into a TensorSpec.""" - - def _get_feature_spec(nested_feature: tfds.features.FeatureConnector): - if isinstance(nested_feature, tf.DType): - return tf.TensorSpec(shape=(), dtype=nested_feature) - else: - return nested_feature.get_tensor_spec() - - # FeaturesDict can sometimes be a plain dictionary, so we use tf.nest to - # make sure we deal with the nested structure. - return tf.nest.map_structure(_get_feature_spec, feature) - - -def _encoded_feature( - feature: Optional[tfds.features.FeatureConnector], - image_encoding: Optional[str], - tensor_encoding: Optional[tfds.features.Encoding], -): - """Adds encoding to Images and/or Tensors.""" - - def _apply_encoding( - feature: tfds.features.FeatureConnector, - image_encoding: Optional[str], - tensor_encoding: Optional[tfds.features.Encoding], - ): - if image_encoding and isinstance(feature, tfds.features.Image): - return tfds.features.Image( - shape=feature.shape, - dtype=feature.dtype, - use_colormap=feature.use_colormap, - encoding_format=image_encoding, - ) - if ( - tensor_encoding - and isinstance(feature, tfds.features.Tensor) - and feature.dtype != tf.string - ): - return tfds.features.Tensor( - shape=feature.shape, dtype=feature.dtype, encoding=tensor_encoding - ) - return feature - - if not feature: - return None - return tf.nest.map_structure( - lambda x: _apply_encoding(x, image_encoding, tensor_encoding), feature - ) - - -@dataclasses.dataclass -class RLDSSpec(metaclass=abc.ABCMeta): - """Specification of an RLDS Dataset. - - It is used to hold a spec that can be converted into a TFDS DatasetInfo or - a `tf.data.Dataset` spec. - """ - - observation_info: Optional[tfds.features.FeatureConnector] = None - action_info: Optional[tfds.features.FeatureConnector] = None - reward_info: Optional[tfds.features.FeatureConnector] = None - discount_info: Optional[tfds.features.FeatureConnector] = None - step_metadata_info: Optional[tfds.features.FeaturesDict] = None - episode_metadata_info: Optional[tfds.features.FeaturesDict] = None - - def step_tensor_spec(self) -> Dict[str, tf.TensorSpec]: - """Obtains the TensorSpec of an RLDS step.""" - step = {} - if self.observation_info: - step[rlds_types.OBSERVATION] = _features_to_tensor_spec( - self.observation_info - ) - if self.action_info: - step[rlds_types.ACTION] = _features_to_tensor_spec(self.action_info) - if self.discount_info: - step[rlds_types.DISCOUNT] = _features_to_tensor_spec(self.discount_info) - if self.reward_info: - step[rlds_types.REWARD] = _features_to_tensor_spec(self.reward_info) - if self.step_metadata_info: - for k, v in self.step_metadata_info.items(): - step[k] = _features_to_tensor_spec(v) - - step[rlds_types.IS_FIRST] = tf.TensorSpec(shape=(), dtype=bool) - step[rlds_types.IS_LAST] = tf.TensorSpec(shape=(), dtype=bool) - step[rlds_types.IS_TERMINAL] = tf.TensorSpec(shape=(), dtype=bool) - return step - - def episode_tensor_spec(self) -> Dict[str, tf.TensorSpec]: - """Obtains the TensorSpec of an RLDS step.""" - episode = {} - episode[rlds_types.STEPS] = tf.data.DatasetSpec( - element_spec=self.step_tensor_spec() - ) - if self.episode_metadata_info: - for k, v in self.episode_metadata_info.items(): - episode[k] = _features_to_tensor_spec(v) - return episode - - def to_dataset_config( - self, - name: str, - image_encoding: Optional[str] = None, - tensor_encoding: Optional[tfds.features.Encoding] = None, - citation: Optional[str] = None, - homepage: Optional[str] = None, - description: Optional[str] = None, - overall_description: Optional[str] = None, - ) -> tfds.rlds.rlds_base.DatasetConfig: - """Obtains the DatasetConfig for TFDS from the Spec.""" - return tfds.rlds.rlds_base.DatasetConfig( - name=name, - description=description, - overall_description=overall_description, - homepage=homepage, - citation=citation, - observation_info=_encoded_feature( - self.observation_info, image_encoding, tensor_encoding - ), - action_info=_encoded_feature( - self.action_info, image_encoding, tensor_encoding - ), - reward_info=_encoded_feature( - self.reward_info, image_encoding, tensor_encoding - ), - discount_info=_encoded_feature( - self.discount_info, image_encoding, tensor_encoding - ), - step_metadata_info=_encoded_feature( - self.step_metadata_info, image_encoding, tensor_encoding - ), - episode_metadata_info=_encoded_feature( - self.episode_metadata_info, image_encoding, tensor_encoding - ), - ) - - def to_features_dict(self): - """Returns a TFDS FeaturesDict representing the dataset config.""" - step_config = { - rlds_types.IS_FIRST: tf.bool, - rlds_types.IS_LAST: tf.bool, - rlds_types.IS_TERMINAL: tf.bool, - } - - if self.observation_info: - step_config[rlds_types.OBSERVATION] = self.observation_info - if self.action_info: - step_config[rlds_types.ACTION] = self.action_info - if self.discount_info: - step_config[rlds_types.DISCOUNT] = self.discount_info - if self.reward_info: - step_config[rlds_types.REWARD] = self.reward_info - - if self.step_metadata_info: - for k, v in self.step_metadata_info.items(): - step_config[k] = v - - if self.episode_metadata_info: - return tfds.features.FeaturesDict( - { - rlds_types.STEPS: tfds.features.Dataset(step_config), - **self.episode_metadata_info, - } - ) - else: - return tfds.features.FeaturesDict( - { - rlds_types.STEPS: tfds.features.Dataset(step_config), - } - ) - - -RLDS_SPEC = RLDSSpec -TENSOR_SPEC = Union[tf.TensorSpec, dict[str, tf.TensorSpec]] - - -@dataclasses.dataclass -class TrajectoryTransform(metaclass=abc.ABCMeta): - """Specification the TrajectoryTransform applied to a dataset of episodes. - - A TrajectoryTransform is a set of rules transforming a dataset - of RLDS episodes to a dataset of trajectories. - This involves three distinct stages: - - An optional `episode_to_steps_map_fn(episode)` is called at the episode - level, and can be used to select or modify steps. - - Augmentation: an `episode_key` could be propagated to `steps` for - debugging. - - Selection: Particular steps can be selected. - - Stripping: Features can be removed from steps. Prefer using `step_map_fn`. - - An optional `step_map_fn` is called at the flattened steps dataset for each - step, and can be used to featurize a step, e.g. add/remove features, or - augument images - - A `pattern` leverages DM patterns to set a rule of slicing an episode to a - dataset of overlapping trajectories. - - Importantly, each TrajectoryTransform must define a `expected_tensor_spec` - which specifies a nested TensorSpec of the resulting dataset. This is what - this TrajectoryTransform will produce, and can be used as an interface with - a neural network. - """ - - episode_dataset_spec: RLDS_SPEC - episode_to_steps_fn_dataset_spec: RLDS_SPEC - steps_dataset_spec: Any - pattern: reverb.structured_writer.Pattern - episode_to_steps_map_fn: Any - expected_tensor_spec: TENSOR_SPEC - step_map_fn: Optional[Any] = None - - def get_for_cached_trajectory_transform(self): - """Creates a copy of this traj transform to use with caching. - - The returned TrajectoryTransfrom copy will be initialized with the default - version of the `episode_to_steps_map_fn`, because the effect of that - function has already been materialized in the cached copy of the dataset. - Returns: - trajectory_transform: A copy of the TrajectoryTransform with overridden - `episode_to_steps_map_fn`. - """ - traj_copy = dataclasses.replace(self) - traj_copy.episode_dataset_spec = traj_copy.episode_to_steps_fn_dataset_spec - traj_copy.episode_to_steps_map_fn = lambda e: e[rlds_types.STEPS] - return traj_copy - - def transform_episodic_rlds_dataset(self, episodes_dataset: tf.data.Dataset): - """Applies this TrajectoryTransform to the dataset of episodes.""" - - # Convert the dataset of episodes to the dataset of steps. - steps_dataset = episodes_dataset.map( - self.episode_to_steps_map_fn, num_parallel_calls=tf.data.AUTOTUNE - ).flat_map(lambda x: x) - - return self._create_pattern_dataset(steps_dataset) - - def transform_steps_rlds_dataset( - self, steps_dataset: tf.data.Dataset - ) -> tf.data.Dataset: - """Applies this TrajectoryTransform to the dataset of episode steps.""" - - return self._create_pattern_dataset(steps_dataset) - - def create_test_dataset( - self, - ) -> tf.data.Dataset: - """Creates a test dataset of trajectories. - - It is guaranteed that the structure of this dataset will be the same as - when flowing real data. Hence this is a useful construct for tests or - initialization of JAX models. - Returns: - dataset: A test dataset made of zeros structurally identical to the - target dataset of trajectories. - """ - zeros = transformations.zeros_from_spec(self.expected_tensor_spec) - - return tf.data.Dataset.from_tensors(zeros) - - def _create_pattern_dataset( - self, steps_dataset: tf.data.Dataset - ) -> tf.data.Dataset: - """Create PatternDataset from the `steps_dataset`.""" - config = create_structured_writer_config("temp", self.pattern) - - # Further transform each step if the `step_map_fn` is provided. - if self.step_map_fn: - steps_dataset = steps_dataset.map(self.step_map_fn) - pattern_dataset = reverb.PatternDataset( - input_dataset=steps_dataset, - configs=[config], - respect_episode_boundaries=True, - is_end_of_episode=lambda x: x[rlds_types.IS_LAST], - ) - return pattern_dataset - - -class TrajectoryTransformBuilder(object): - """Facilitates creation of the `TrajectoryTransform`.""" - - def __init__( - self, - dataset_spec: RLDS_SPEC, - episode_to_steps_map_fn=lambda e: e[rlds_types.STEPS], - step_map_fn=None, - pattern_fn=None, - expected_tensor_spec=None, - ): - self._rds_dataset_spec = dataset_spec - self._steps_spec = None - self._episode_to_steps_map_fn = episode_to_steps_map_fn - self._step_map_fn = step_map_fn - self._pattern_fn = pattern_fn - self._expected_tensor_spec = expected_tensor_spec - - def build(self, validate_expected_tensor_spec: bool = True) -> TrajectoryTransform: - """Creates `TrajectoryTransform` from a `TrajectoryTransformBuilder`.""" - - if validate_expected_tensor_spec and self._expected_tensor_spec is None: - raise ValueError("`expected_tensor_spec` must be set.") - - episode_ds = zero_episode_dataset_from_spec(self._rds_dataset_spec) - - steps_ds = episode_ds.flat_map(self._episode_to_steps_map_fn) - - episode_to_steps_fn_dataset_spec = self._rds_dataset_spec - - if self._step_map_fn is not None: - steps_ds = steps_ds.map(self._step_map_fn) - - zeros_spec = transformations.zeros_from_spec( - steps_ds.element_spec - ) # pytype: disable=wrong-arg-types - - ref_step = reverb.structured_writer.create_reference_step(zeros_spec) - - pattern = self._pattern_fn(ref_step) - - steps_ds_spec = steps_ds.element_spec - - target_tensor_structure = create_reverb_table_signature( - "temp_table", steps_ds_spec, pattern - ) - - if ( - validate_expected_tensor_spec - and self._expected_tensor_spec != target_tensor_structure - ): - raise RuntimeError( - "The tensor spec of the TrajectoryTransform doesn't " - "match the expected spec.\n" - "Expected:\n%s\nActual:\n%s\n" - % ( - str(self._expected_tensor_spec).replace( - "TensorSpec", "tf.TensorSpec" - ), - str(target_tensor_structure).replace("TensorSpec", "tf.TensorSpec"), - ) - ) - - return TrajectoryTransform( - episode_dataset_spec=self._rds_dataset_spec, - episode_to_steps_fn_dataset_spec=episode_to_steps_fn_dataset_spec, - steps_dataset_spec=steps_ds_spec, - pattern=pattern, - episode_to_steps_map_fn=self._episode_to_steps_map_fn, - step_map_fn=self._step_map_fn, - expected_tensor_spec=target_tensor_structure, - ) - - -def zero_episode_dataset_from_spec(rlds_spec: RLDS_SPEC): - """Creates a zero valued dataset of episodes for the given RLDS Spec.""" - - def add_steps(episode, step_spec): - episode[rlds_types.STEPS] = transformations.zero_dataset_like( - tf.data.DatasetSpec(step_spec) - ) - if "fake" in episode: - del episode["fake"] - return episode - - episode_without_steps_spec = { - k: v - for k, v in rlds_spec.episode_tensor_spec().items() - if k != rlds_types.STEPS - } - - if episode_without_steps_spec: - episodes_dataset = transformations.zero_dataset_like( - tf.data.DatasetSpec(episode_without_steps_spec) - ) - else: - episodes_dataset = tf.data.Dataset.from_tensors({"fake": ""}) - - episodes_dataset_with_steps = episodes_dataset.map( - lambda episode: add_steps(episode, rlds_spec.step_tensor_spec()) - ) - return episodes_dataset_with_steps - - -def create_reverb_table_signature( - table_name: str, steps_dataset_spec, pattern: reverb.structured_writer.Pattern -) -> reverb.reverb_types.SpecNest: - config = create_structured_writer_config(table_name, pattern) - reverb_table_spec = reverb.structured_writer.infer_signature( - [config], steps_dataset_spec - ) - return reverb_table_spec - - -def create_structured_writer_config( - table_name: str, pattern: reverb.structured_writer.Pattern -) -> Any: - config = reverb.structured_writer.create_config( - pattern=pattern, table=table_name, conditions=[] - ) - return config - - -def n_step_pattern_builder(n: int) -> Any: - """Creates trajectory of length `n` from all fields of a `ref_step`.""" - - def transform_fn(ref_step): - traj = {} - for key in ref_step: - if isinstance(ref_step[key], dict): - transformed_entry = tree.map_structure( - lambda ref_node: ref_node[-n:], ref_step[key] - ) - traj[key] = transformed_entry - else: - traj[key] = ref_step[key][-n:] - - return traj - - return transform_fn - - -def get_observation_and_action_from_step(step): - return { - "observation": { - "image": step["observation"]["image"], - "embedding": step["observation"]["natural_language_embedding"], - "instruction": step["observation"]["natural_language_instruction"], - }, - # Decode one hot discrete actions - "action": { - k: tf.argmax(v, axis=-1) if v.dtype == tf.int32 else v - for k, v in step["action"].items() - }, - } - - -def create_dataset( - datasets=["fractal20220817_data"], - split="train", - trajectory_length=6, - batch_size=32, - num_epochs=1, -) -> Iterable[Dict[str, Union[np.ndarray, Dict[str, np.ndarray]]]]: - trajectory_datasets = [] - #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) - for dataset in datasets: - #tf.io.gfile.exists(builder_dir=dataset2path(dataset)) - - - # b = tfds.builder_from_directory(builder_dir='/oscar/data/stellex/shared/bridge/0.1.0') - #'~/data/sjulian2/bridge/0.1.0/' - # dataset = tfds.load('bridge', split='train') - #b = tfds.builder_from_directory(builder_dir='/users/sjulian2/data/sjulian2/jaco_play/0.1.0') - # b = tfds.builder_from_directory(builder_dir=dataset2path(dataset)) - - # pdb.set_trace() - b = tfds.builder_from_directory(builder_dir = '/oscar/data/stellex/ssunda11/NPM-Dataset/rt1-pytorch/rt1_dataset/0.1.0') - # ds = tfds.load("fractal20220817_data:0.1.0", data_dir="gs://gresearch/robotics") - - ds = b.as_dataset(split=split) - - # The RLDSSpec for the RT1 dataset. - rt1_spec = RLDSSpec( - observation_info=b.info.features["steps"]["observation"], - action_info=b.info.features["steps"]["action"], - ) - - trajectory_transform = TrajectoryTransformBuilder( - rt1_spec, pattern_fn=n_step_pattern_builder(trajectory_length) - ).build(validate_expected_tensor_spec=False) - - trajectory_dataset = trajectory_transform.transform_episodic_rlds_dataset(ds) - #pdb.set_trace() - trajectory_datasets.append(trajectory_dataset) - - trajectory_dataset = tf.data.Dataset.sample_from_datasets(trajectory_datasets) - - trajectory_dataset = trajectory_dataset.map( - get_observation_and_action_from_step, num_parallel_calls=tf.data.AUTOTUNE - ) - - # Shuffle, batch, prefetch, repeat - trajectory_dataset = trajectory_dataset.shuffle(batch_size * 16) - trajectory_dataset = trajectory_dataset.batch( - batch_size, - drop_remainder=True, - num_parallel_calls=tf.data.AUTOTUNE, - deterministic=False, - ) - trajectory_dataset = trajectory_dataset.repeat(num_epochs) - trajectory_dataset = trajectory_dataset.prefetch(tf.data.AUTOTUNE) - # pdb.set_trace() - return iter(trajectory_dataset.as_numpy_iterator()) - - -if __name__ == "__main__": - #pdb.set_trace() - ds = create_dataset(datasets=["fractal20220817_data"], split="train[:10]") - it = next(ds) - - def print_shape(x): - if isinstance(x, dict): - shapes = tree.map_structure(lambda x: x.shape, x) - else: - shapes = x.shape - return shapes - - shapes = tree.map_structure(print_shape, it) - print(shapes) diff --git a/gen/README.md b/gen/README.md deleted file mode 100644 index 607e80b9b..000000000 --- a/gen/README.md +++ /dev/null @@ -1,77 +0,0 @@ -# Data Generation - -We also provide code for generating PDDL-based expert demonstrations. This can be used to extend the training data, albiet without human language annotations. - -## Installation - -Get dependencies and compile the planner: -```bash -$ sudo apt-get install ffmpeg flex bison - -$ cd $ALFRED_ROOT/gen/ff_planner -$ make -``` - -## Generation - -To spawn multiple generation threads: - -```bash -$ cd $ALFRED_ROOT/gen -$ python scripts/generate_trajectories.py --save_path data/new_trajs --in_parallel --debug --num_threads 2 -``` - -This will sample tasks based on the sampling mechanism described in the paper. You might notice a lot of failed executions, which are automatically discarded by the script. - -**Note:** The first time you run the generation script, use `--num_threads 1` to allow the script to download the THOR binary. - -## Replay Checks - -In parallel with generation, replay saved trajectories to check if they are reproducable: - -```bash -$ python scripts/replay_checks.py --data_path data/new_trajs --in_parallel -``` -This will ensure that the interaction masks and expert actions can be deterministically executed in THOR. - -## Data Augmentation - -Currently, the dataset only provides 300x300 RGB images. However, each trajectory can be replayed to save any additional info available from the simulator. See the [augment_trajectories.py](scripts/augment_trajectories.py) script as an example for saving 600x600 RGB, depth and instance segmentation masks from the existing dataset: - -```bash -python scripts/augment_trajectories.py --data_path data/json_2.1.0 --num_threads 2 --smooth_nav --time_delays -``` - -![](../media/aug.png) - -Note that these files consume a lot of storage space. - -## PDDL Tasks - -The goals for the planner are specified in [goal_library.py](goal_library.py). Here is a simple pick-and-place PDDL goal definition: - -``` -# basic pick and place (e.g: "put the apple in the microwave") -gdict["pick_and_place_simple"] = ''' - (:goal - (and - ;; make sure all the cabinets and doors are closed in the end - (forall (?re # receptacle) - (not (opened ?re)) - ) - - ;; make sure some object {obj} exists inside some receptacle {recep} - (exists (?r # receptacle) - (exists (?o # object) - (and - (inReceptacle ?o ?r) - (objectType ?o {obj}Type) - (receptacleType ?r {recep}Type) - ) - ) - ) - ) - ) -) -``` - diff --git a/gen/__init__.py b/gen/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/gen/agents/agent_base.py b/gen/agents/agent_base.py deleted file mode 100644 index 34cb3f725..000000000 --- a/gen/agents/agent_base.py +++ /dev/null @@ -1,60 +0,0 @@ -import copy -import time -import numpy as np - - -class AgentBase(object): - def __init__(self, thread_id=0, game_state=None): - assert(game_state is not None) - self.game_state = game_state - self.thread_id = thread_id - self.timers = np.zeros((2, 2)) - self.total_frame_count = 0 - self.current_frame_count = 0 - self.gt_graph = None - self.bounds = None - self.pose = None - self.terminal = False - self.num_invalid_actions = 0 - self.total_num_invalid_actions = 0 - - def setup_problem(self, game_state_problem_args, scene=None, objs=None): - self.game_state.setup_problem(**game_state_problem_args, scene=scene, objs=objs) - - def reset(self, game_state_reset_args, scene=None, objs=None): - self.game_state.reset(**game_state_reset_args, scene=scene, objs=objs) - - self.timers = np.zeros((2, 2)) - self.current_frame_count = 0 - self.gt_graph = None - self.bounds = None - self.pose = None - self.terminal = False - self.num_invalid_actions = 0 - - self.total_frame_count += 1 - self.gt_graph = self.game_state.gt_graph - self.bounds = self.game_state.bounds - self.pose = self.game_state.pose - - def step(self, action): - self.total_frame_count += 1 - self.current_frame_count += 1 - t_start = time.time() - self.game_state.step(action) - if not self.game_state.event.metadata['lastActionSuccess']: - self.num_invalid_actions += 1 - self.total_num_invalid_actions += 1 - self.timers[0, 0] += time.time() - t_start - self.timers[0, 1] += 1 - if self.timers[0, 1] % 100 == 0: - print('game state step time %.3f' % (self.timers[0, 0] / self.timers[0, 1])) - self.timers[0, :] = 0 - self.pose = self.game_state.pose - - def get_action(self, action_ind): - action = copy.deepcopy(self.game_state.action_space[action_ind]) - if action['action'] == 'End': - # Remove other arguments - action = {'action': 'End'} - return action diff --git a/gen/agents/deterministic_planner_agent.py b/gen/agents/deterministic_planner_agent.py deleted file mode 100644 index b67e25457..000000000 --- a/gen/agents/deterministic_planner_agent.py +++ /dev/null @@ -1,26 +0,0 @@ -from agents.semantic_map_planner_agent import SemanticMapPlannerAgent - - -class DeterministicPlannerAgent(SemanticMapPlannerAgent): - def __init__(self, thread_id=0, game_state=None): - super(DeterministicPlannerAgent, self).__init__(thread_id, game_state) - self.action_sequence = None - self.question = None - - def reset(self, seed=None, info=None, scene=None, objs=None): - info = super(DeterministicPlannerAgent, self).reset(seed, info, scene=scene, objs=objs) - self.action_sequence = ['Plan', 'End'] - return info - - def step(self, action, executing_plan=False): - if not executing_plan: - self.action_sequence = self.action_sequence[1:] - super(DeterministicPlannerAgent, self).step(action) - - def get_action(self, action_ind=None): - assert(action_ind is None) - return {'action': self.action_sequence[0]} - - def get_reward(self): - return 0, self.terminal - diff --git a/gen/agents/plan_agent.py b/gen/agents/plan_agent.py deleted file mode 100644 index eda12f215..000000000 --- a/gen/agents/plan_agent.py +++ /dev/null @@ -1,94 +0,0 @@ -import constants -from agents.agent_base import AgentBase -from game_states.planned_game_state import PlannedGameState -from utils import game_util - - -class PlanAgent(AgentBase): - def __init__(self, thread_id=0, game_state=None, controller_agent=None): - super(PlanAgent, self).__init__(thread_id, game_state) - assert(isinstance(game_state, PlannedGameState)) - self.controller_agent = controller_agent - self.planned = False - - def reset(self): - self.planned = False - - def execute_plan(self): - step_count = 0 - self.planned = True - self.controller_agent.planning = True - if constants.OPEN_LOOP: - plan = self.game_state.get_current_plan(force_update=True) - - if plan[0]['action'] == 'End': - raise ValueError('Empty plan is successful, no work to do') - - elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: - print ("Planning failed. Possibly because the goal was already satisfied") - raise ValueError("Symbolic Planning Failed") - - for idx, plan_action in enumerate(plan): - self.save_plan(plan, idx) - - if plan_action['action'] == 'GotoLocation': - plan_action = self.game_state.get_teleport_action(plan_action) - elif plan_action['action'] == 'End': - break - self.controller_agent.step(plan_action, executing_plan=True) - step_count += 1 - if self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH: - break - else: - past_plans = [] - plan = self.game_state.get_current_plan(force_update=True) - - if plan[0]['action'] == 'End': - raise ValueError('Empty plan is successful, no work to do') - elif len(plan) == 0 or len(plan) > constants.PLANNER_MAX_STEPS: - print("Symbolic Planning Failed") - raise ValueError("Symbolic Planning Failed") - - plan_action = plan[0] - if constants.USE_DETERMINISTIC_CONTROLLER: - # Don't fail right away, just rotate a few times. - rotations = 0 - while rotations < 4 and (plan_action is None or plan_action['action'] == 'End'): - action = {'action': 'RotateLeft'} - self.controller_agent.step(action, executing_plan=True) - rotations += 1 - plan = self.game_state.get_current_plan(force_update=True) - plan_action = plan[0] - - while not(plan_action is None or plan_action['action'] == 'End'): - self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) - - # save data - self.save_plan(plan, 0) - - step_count += 1 - past_plans.append(plan) - if len(past_plans) > 5: - past_plans = past_plans[-5:] - plan = self.game_state.get_current_plan(force_update=True) - if plan[0]['action'] == 'End': - break - if (step_count >= constants.MAX_PLANNER_STEP_COUNT or - self.controller_agent.current_frame_count >= constants.MAX_EPISODE_LENGTH): - # Too many steps, plan may be looping. - break - if len(plan) > 1 and any([plan == past_plan for past_plan in past_plans]): - plan_action = plan[0] - self.controller_agent.step(self.game_state.get_plan_action(plan_action), executing_plan=True) - step_count += 1 - plan = plan[1:] - plan_action = plan[0] - - self.controller_agent.planning = False - - def save_plan(self, plan, idx=0): - plan_action = plan[idx] - constants.data_dict['plan']['high_pddl'].append({"high_idx": len(constants.data_dict['plan']['high_pddl']), - "planner_action": plan_action, - "discrete_action": game_util.get_discrete_hl_action(plan, idx)}) - constants.data_dict['template']['high_descs'].append(game_util.get_templated_action_str(plan, idx)) diff --git a/gen/agents/semantic_map_planner_agent.py b/gen/agents/semantic_map_planner_agent.py deleted file mode 100644 index 497ee242c..000000000 --- a/gen/agents/semantic_map_planner_agent.py +++ /dev/null @@ -1,72 +0,0 @@ -import glob -import cv2 -import constants -from agents.agent_base import AgentBase -from agents.plan_agent import PlanAgent -from game_states.planned_game_state import PlannedGameState - - -class SemanticMapPlannerAgent(AgentBase): - def __init__(self, thread_id=0, game_state=None): - assert(isinstance(game_state, PlannedGameState)) - super(SemanticMapPlannerAgent, self).__init__(thread_id, game_state) - - self.plan_agent = PlanAgent(thread_id, game_state, self) - self.planning = False - - def reset(self, seed=None, info=None, scene=None, objs=None): - self.planning = False - info = self.game_state.get_setup_info(info, scene=scene)[0] - super(SemanticMapPlannerAgent, self).reset({'seed': seed, 'info': info}, scene=scene, objs=objs) - if self.plan_agent is not None: - self.plan_agent.reset() - return info - - def setup_problem(self, game_state_problem_args, scene=None, objs=None): - super(SemanticMapPlannerAgent, self).setup_problem(game_state_problem_args, scene=scene, objs=objs) - self.pose = self.game_state.pose - - def get_reward(self): - raise NotImplementedError - - def step(self, action, executing_plan=False): - if action['action'] == 'End': - self.current_frame_count += 1 - self.total_frame_count += 1 - self.terminal = True - - if constants.RECORD_VIDEO_IMAGES: - im_ind = len(glob.glob(constants.save_path + '/*.png')) - for _ in range(10): - cv2.imwrite(constants.save_path + '/%09d.png' % im_ind, - self.game_state.s_t[:, :, ::-1]) - im_ind += 1 - else: - if 'Teleport' in action['action']: - start_pose = self.pose - end_angle = action['horizon'] - end_pose = (int(action['x'] / constants.AGENT_STEP_SIZE), - int(action['z'] / constants.AGENT_STEP_SIZE), - int(action['rotation'] / 90), - int(end_angle)) - - self.game_state.gt_graph.navigate_to_goal(self.game_state, start_pose, end_pose) - self.pose = self.game_state.pose - elif action['action'] == 'Plan': - self.plan_agent.execute_plan() - if not constants.EVAL: - self.current_frame_count += 1 - self.total_frame_count += 1 - elif action['action'] == 'Scan': - self.game_state.step(action) - if not constants.EVAL: - self.current_frame_count += 1 - self.total_frame_count += 1 - elif action['action'] == 'Explore': - if not constants.EVAL: - self.current_frame_count += 1 - self.total_frame_count += 1 - else: - super(SemanticMapPlannerAgent, self).step(action) - - diff --git a/gen/constants.py b/gen/constants.py deleted file mode 100644 index e646c660d..000000000 --- a/gen/constants.py +++ /dev/null @@ -1,1221 +0,0 @@ -from collections import OrderedDict - -######################################################################################################################## -# General Settings - -DEBUG = True -EVAL = False -LOG_FILE = 'logs_gen' - -RECORD_VIDEO_IMAGES = True -RECORD_SMOOTHING_FACTOR = 1 -DATA_SAVE_PATH = "dataset/new_trajectories" - -OPEN_LOOP = True -FULL_OBSERVABLE_STATE = True - -######################################################################################################################## -# Generation Ablations - -MAX_NUM_OF_OBJ_INSTANCES = 3 # when randomly initializing the scene, create duplicate instance up to this number -PICKUP_REPEAT_MAX = 4 # how many of the target pickup object to generate in [1, MAX] (randomly chosen) -RECEPTACLE_SPARSE_POINTS = 50 # increment for how many points to leave free for sparsely populated receptacles -RECEPTACLE_EMPTY_POINTS = 200 # increment for how many points to leave free for empty receptacles - -MIN_VISIBLE_RATIO = 0.0011 # minimum area ratio (with respect to image size) of visible object -PLANNER_MAX_STEPS = 100 # if the generated plan is more than these steps, discard the traj -MAX_EPISODE_LENGTH = 1000 # maximum number of API steps allowed per trajectory - -FORCED_SAMPLING = False # set True for debugging instead of proper sampling -PRUNE_UNREACHABLE_POINTS = True # prune navigation points that were deemed unreachable by the proprocessing script - -######################################################################################################################## -# Goals - -GOALS = [ - "pick_and_place_simple", - "pick_two_obj_and_place", - "look_at_obj_in_light", - "pick_clean_then_place_in_recep", - "pick_heat_then_place_in_recep", - "pick_cool_then_place_in_recep", - "pick_and_place_with_movable_recep", - ] -GOALS_VALID = {"pick_and_place_simple": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, - "pick_two_obj_and_place": {"Kitchen", "LivingRoom", "Bathroom", "Bedroom"}, - "look_at_obj_in_light": {"LivingRoom", "Bedroom"}, - "pick_clean_then_place_in_recep": {"Kitchen", "Bathroom"}, - "pick_heat_then_place_in_recep": {"Kitchen"}, - "pick_cool_then_place_in_recep": {"Kitchen"}, - "pick_and_place_with_movable_recep": {"Kitchen", "LivingRoom", "Bedroom"}} - -pddl_goal_type = "pick_and_place_simple" # default goal type - -######################################################################################################################## -# Video Settings - -# filler frame IDs -BEFORE = 0 -MIDDLE = 1 -AFTER = 2 - -# number of image frames to save before and after executing the specified action -SAVE_FRAME_BEFORE_AND_AFTER_COUNTS = { - 'OpenObject': [2, 0, 2], - 'CloseObject': [2, 0, 2], - 'PickupObject': [5, 0, 10], - 'PutObject': [5, 0, 10], - 'CleanObject': [3, 0, 5], - 'HeatObject': [3, 0, 5], - 'CoolObject': [3, 30, 5], - 'ToggleObjectOn': [3, 0, 15], - 'ToggleObjectOff': [1, 0, 5], - 'SliceObject': [3, 0, 7] -} - -# FPS -VIDEO_FRAME_RATE = 5 - -######################################################################################################################## -# Data & Storage - -save_path = DATA_SAVE_PATH -data_dict = OrderedDict() # dictionary for storing trajectory data to be dumped - -######################################################################################################################## -# Unity Hyperparameters - -BUILD_PATH = None -X_DISPLAY = '0' - -AGENT_STEP_SIZE = 0.25 -AGENT_HORIZON_ADJ = 30 -AGENT_ROTATE_ADJ = 90 -CAMERA_HEIGHT_OFFSET = 0.75 -VISIBILITY_DISTANCE = 1.5 -HORIZON_GRANULARITY = 30 - -RENDER_IMAGE = True -RENDER_DEPTH_IMAGE = True -RENDER_CLASS_IMAGE = True -RENDER_OBJECT_IMAGE = True - -MAX_DEPTH = 5000 -STEPS_AHEAD = 5 -SCENE_PADDING = STEPS_AHEAD * 3 -SCREEN_WIDTH = DETECTION_SCREEN_WIDTH = 300 -SCREEN_HEIGHT = DETECTION_SCREEN_HEIGHT = 300 -MIN_VISIBLE_PIXELS = 10 - -# (400) / (600*600) ~ 0.13% area of image -# int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float(DETECTION_SCREEN_HEIGHT)) -# MIN_VISIBLE_PIXELS = int(MIN_VISIBLE_RATIO * float(DETECTION_SCREEN_WIDTH) * float( -# DETECTION_SCREEN_HEIGHT)) # (400) / (600*600) ~ 0.13% area of image - -######################################################################################################################## -# Scenes and Objects - -TRAIN_SCENE_NUMBERS = list(range(7, 31)) # Train Kitchens (24/30) -TRAIN_SCENE_NUMBERS.extend(list(range(207, 231))) # Train Living Rooms (24/30) -TRAIN_SCENE_NUMBERS.extend(list(range(307, 331))) # Train Bedrooms (24/30) -TRAIN_SCENE_NUMBERS.extend(list(range(407, 431))) # Train Bathrooms (24/30) - -TEST_SCENE_NUMBERS = list(range(1, 7)) # Test Kitchens (6/30) -TEST_SCENE_NUMBERS.extend(list(range(201, 207))) # Test Living Rooms (6/30) -TEST_SCENE_NUMBERS.extend(list(range(301, 307))) # Test Bedrooms (6/30) -TEST_SCENE_NUMBERS.extend(list(range(401, 407))) # Test Bathrooms (6/30) - -SCENE_NUMBERS = TRAIN_SCENE_NUMBERS + TEST_SCENE_NUMBERS - -# Scene types. -SCENE_TYPE = {"Kitchen": range(1, 31), - "LivingRoom": range(201, 231), - "Bedroom": range(301, 331), - "Bathroom": range(401, 431)} - -OBJECTS = [ - 'AlarmClock', - 'Apple', - 'ArmChair', - 'BaseballBat', - 'BasketBall', - 'Bathtub', - 'BathtubBasin', - 'Bed', - 'Blinds', - 'Book', - 'Boots', - 'Bowl', - 'Box', - 'Bread', - 'ButterKnife', - 'Cabinet', - 'Candle', - 'Cart', - 'CD', - 'CellPhone', - 'Chair', - 'Cloth', - 'CoffeeMachine', - 'CounterTop', - 'CreditCard', - 'Cup', - 'Curtains', - 'Desk', - 'DeskLamp', - 'DishSponge', - 'Drawer', - 'Dresser', - 'Egg', - 'FloorLamp', - 'Footstool', - 'Fork', - 'Fridge', - 'GarbageCan', - 'Glassbottle', - 'HandTowel', - 'HandTowelHolder', - 'HousePlant', - 'Kettle', - 'KeyChain', - 'Knife', - 'Ladle', - 'Laptop', - 'LaundryHamper', - 'LaundryHamperLid', - 'Lettuce', - 'LightSwitch', - 'Microwave', - 'Mirror', - 'Mug', - 'Newspaper', - 'Ottoman', - 'Painting', - 'Pan', - 'PaperTowel', - 'PaperTowelRoll', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Pillow', - 'Plate', - 'Plunger', - 'Poster', - 'Pot', - 'Potato', - 'RemoteControl', - 'Safe', - 'SaltShaker', - 'ScrubBrush', - 'Shelf', - 'ShowerDoor', - 'ShowerGlass', - 'Sink', - 'SinkBasin', - 'SoapBar', - 'SoapBottle', - 'Sofa', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'Statue', - 'StoveBurner', - 'StoveKnob', - 'DiningTable', - 'CoffeeTable', - 'SideTable', - 'TeddyBear', - 'Television', - 'TennisRacket', - 'TissueBox', - 'Toaster', - 'Toilet', - 'ToiletPaper', - 'ToiletPaperHanger', - 'ToiletPaperRoll', - 'Tomato', - 'Towel', - 'TowelHolder', - 'TVStand', - 'Vase', - 'Watch', - 'WateringCan', - 'Window', - 'WineBottle', -] - -OBJECTS_LOWER_TO_UPPER = {obj.lower(): obj for obj in OBJECTS} - -OBJECTS_SINGULAR = [ - 'alarmclock', - 'apple', - 'armchair', - 'baseballbat', - 'basketball', - 'bathtub', - 'bathtubbasin', - 'bed', - 'blinds', - 'book', - 'boots', - 'bowl', - 'box', - 'bread', - 'butterknife', - 'cabinet', - 'candle', - 'cart', - 'cd', - 'cellphone', - 'chair', - 'cloth', - 'coffeemachine', - 'countertop', - 'creditcard', - 'cup', - 'curtains', - 'desk', - 'desklamp', - 'dishsponge', - 'drawer', - 'dresser', - 'egg', - 'floorlamp', - 'footstool', - 'fork', - 'fridge', - 'garbagecan', - 'glassbottle', - 'handtowel', - 'handtowelholder', - 'houseplant', - 'kettle', - 'keychain', - 'knife', - 'ladle', - 'laptop', - 'laundryhamper', - 'laundryhamperlid', - 'lettuce', - 'lightswitch', - 'microwave', - 'mirror', - 'mug', - 'newspaper', - 'ottoman', - 'painting', - 'pan', - 'papertowel', - 'papertowelroll', - 'pen', - 'pencil', - 'peppershaker', - 'pillow', - 'plate', - 'plunger', - 'poster', - 'pot', - 'potato', - 'remotecontrol', - 'safe', - 'saltshaker', - 'scrubbrush', - 'shelf', - 'showerdoor', - 'showerglass', - 'sink', - 'sinkbasin', - 'soapbar', - 'soapbottle', - 'sofa', - 'spatula', - 'spoon', - 'spraybottle', - 'statue', - 'stoveburner', - 'stoveknob', - 'diningtable', - 'coffeetable', - 'sidetable' - 'teddybear', - 'television', - 'tennisracket', - 'tissuebox', - 'toaster', - 'toilet', - 'toiletpaper', - 'toiletpaperhanger', - 'toiletpaperroll', - 'tomato', - 'towel', - 'towelholder', - 'tvstand', - 'vase', - 'watch', - 'wateringcan', - 'window', - 'winebottle', -] - -OBJECTS_PLURAL = [ - 'alarmclocks', - 'apples', - 'armchairs', - 'baseballbats', - 'basketballs', - 'bathtubs', - 'bathtubbasins', - 'beds', - 'blinds', - 'books', - 'boots', - 'bottles', - 'bowls', - 'boxes', - 'bread', - 'butterknives', - 'cabinets', - 'candles', - 'carts', - 'cds', - 'cellphones', - 'chairs', - 'cloths', - 'coffeemachines', - 'countertops', - 'creditcards', - 'cups', - 'curtains', - 'desks', - 'desklamps', - 'dishsponges', - 'drawers', - 'dressers', - 'eggs', - 'floorlamps', - 'footstools', - 'forks', - 'fridges', - 'garbagecans', - 'glassbottles', - 'handtowels', - 'handtowelholders', - 'houseplants', - 'kettles', - 'keychains', - 'knives', - 'ladles', - 'laptops', - 'laundryhampers', - 'laundryhamperlids', - 'lettuces', - 'lightswitches', - 'microwaves', - 'mirrors', - 'mugs', - 'newspapers', - 'ottomans', - 'paintings', - 'pans', - 'papertowels', - 'papertowelrolls', - 'pens', - 'pencils', - 'peppershakers', - 'pillows', - 'plates', - 'plungers', - 'posters', - 'pots', - 'potatoes', - 'remotecontrollers', - 'safes', - 'saltshakers', - 'scrubbrushes', - 'shelves', - 'showerdoors', - 'showerglassess', - 'sinks', - 'sinkbasins', - 'soapbars', - 'soapbottles', - 'sofas', - 'spatulas', - 'spoons', - 'spraybottles', - 'statues', - 'stoveburners', - 'stoveknobs', - 'diningtables', - 'coffeetables', - 'sidetable', - 'teddybears', - 'televisions', - 'tennisrackets', - 'tissueboxes', - 'toasters', - 'toilets', - 'toiletpapers', - 'toiletpaperhangers', - 'toiletpaperrolls', - 'tomatoes', - 'towels', - 'towelholders', - 'tvstands', - 'vases', - 'watches', - 'wateringcans', - 'windows', - 'winebottles', -] - -MOVABLE_RECEPTACLES = [ - 'Bowl', - 'Box', - 'Cup', - 'Mug', - 'Plate', - 'Pan', - 'Pot', -] - -MOVABLE_RECEPTACLES_SET = set(MOVABLE_RECEPTACLES) -OBJECTS_SET = set(OBJECTS) | MOVABLE_RECEPTACLES_SET - -OBJECT_CLASS_TO_ID = {obj: ii for (ii, obj) in enumerate(OBJECTS)} - -RECEPTACLES = { - 'BathtubBasin', - 'Bowl', - 'Cup', - 'Drawer', - 'Mug', - 'Plate', - 'Shelf', - 'SinkBasin', - 'Box', - 'Cabinet', - 'CoffeeMachine', - 'CounterTop', - 'Fridge', - 'GarbageCan', - 'HandTowelHolder', - 'Microwave', - 'PaintingHanger', - 'Pan', - 'Pot', - 'StoveBurner', - 'DiningTable', - 'CoffeeTable', - 'SideTable', - 'ToiletPaperHanger', - 'TowelHolder', - 'Safe', - 'BathtubBasin', - 'ArmChair', - 'Toilet', - 'Sofa', - 'Ottoman', - 'Dresser', - 'LaundryHamper', - 'Desk', - 'Bed', - 'Cart', - 'TVStand', - 'Toaster', - } - -NON_RECEPTACLES = OBJECTS_SET - RECEPTACLES - -NUM_RECEPTACLES = len(RECEPTACLES) -NUM_CLASSES = len(OBJECTS) - -# For generating questions -QUESTION_OBJECT_CLASS_LIST = [ - 'Spoon', - 'Potato', - 'Fork', - 'Plate', - 'Egg', - 'Tomato', - 'Bowl', - 'Lettuce', - 'Apple', - 'Knife', - 'Container', - 'Bread', - 'Mug', -] - -VAL_RECEPTACLE_OBJECTS = { - 'Pot': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced'}, - 'Pan': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced'}, - 'Bowl': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'KeyChain', - 'Mug', - 'PaperTowel', - 'Pen', - 'Pencil', - 'RemoteControl', - 'Watch'}, - 'CoffeeMachine': {'Mug'}, - 'Microwave': {'Apple', - 'AppleSliced', - 'Bowl', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Glassbottle', - 'Mug', - 'Plate', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced'}, - 'StoveBurner': {'Kettle', - 'Pan', - 'Pot'}, - 'Fridge': {'Apple', - 'AppleSliced', - 'Bowl', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Glassbottle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced', - 'WineBottle'}, - 'Mug': {'ButterKnife', - 'Fork', - 'Knife', - 'Pen', - 'Pencil', - 'Spoon', - 'KeyChain', - 'Watch'}, - 'Plate': {'Apple', - 'AppleSliced', - 'ButterKnife', - 'DishSponge', - 'Egg', - 'Fork', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Potato', - 'PotatoSliced', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced', - 'AlarmClock', - 'Book', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'Glassbottle', - 'KeyChain', - 'Mug', - 'PaperTowel', - 'Pen', - 'Pencil', - 'TissueBox', - 'Watch'}, - 'Cup': {'ButterKnife', - 'Fork', - 'Spoon'}, - 'Sofa': {'BasketBall', - 'Book', - 'Box', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'KeyChain', - 'Laptop', - 'Newspaper', - 'Pillow', - 'RemoteControl'}, - 'ArmChair': {'BasketBall', - 'Book', - 'Box', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'KeyChain', - 'Laptop', - 'Newspaper', - 'Pillow', - 'RemoteControl'}, - 'Box': {'AlarmClock', - 'Book', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'Glassbottle', - 'KeyChain', - 'Mug', - 'PaperTowel', - 'Pen', - 'Pencil', - 'RemoteControl', - 'Statue', - 'TissueBox', - 'Vase', - 'Watch'}, - 'Ottoman': {'BasketBall', - 'Book', - 'Box', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'KeyChain', - 'Laptop', - 'Newspaper', - 'Pillow', - 'RemoteControl'}, - 'Dresser': {'AlarmClock', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'Glassbottle', - 'KeyChain', - 'Laptop', - 'Mug', - 'Newspaper', - 'Pen', - 'Pencil', - 'Plate', - 'RemoteControl', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle'}, - 'LaundryHamper': {'Cloth'}, - 'Desk': {'AlarmClock', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'Glassbottle', - 'KeyChain', - 'Laptop', - 'Mug', - 'Newspaper', - 'Pen', - 'Pencil', - 'Plate', - 'RemoteControl', - 'SoapBottle', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle'}, - 'Bed': {'BaseballBat', - 'BasketBall', - 'Book', - 'CellPhone', - 'Laptop', - 'Newspaper', - 'Pillow', - 'TennisRacket'}, - 'Toilet': {'Candle', - 'Cloth', - 'DishSponge', - 'Newspaper', - 'PaperTowel', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'HandTowel'}, - 'ToiletPaperHanger': {'ToiletPaper', - 'ToiletPaperRoll'}, - 'TowelHolder': {'Towel'}, - 'HandTowelHolder': {'HandTowel'}, - 'Cart': {'Candle', - 'Cloth', - 'DishSponge', - 'Mug', - 'PaperTowel', - 'Plunger', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'Statue', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'HandTowel'}, - 'BathtubBasin': {'Cloth', - 'DishSponge', - 'SoapBar', - 'HandTowel'}, - 'SinkBasin': {'Apple', - 'AppleSliced', - 'Bowl', - 'ButterKnife', - 'Cloth', - 'Cup', - 'DishSponge', - 'Egg', - 'Glassbottle', - 'Fork', - 'Kettle', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'SoapBar', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced', - 'HandTowel'}, - 'Cabinet': {'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'Cloth', - 'Cup', - 'DishSponge', - 'Glassbottle', - 'Kettle', - 'Ladle', - 'Mug', - 'Newspaper', - 'Pan', - 'PepperShaker', - 'Plate', - 'Plunger', - 'Pot', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'TableTop': {'AlarmClock', - 'Apple', - 'AppleSliced', - 'BaseballBat', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Bread', - 'BreadSliced', - 'ButterKnife', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'DishSponge', - 'Glassbottle', - 'Egg', - 'Fork', - 'Kettle', - 'KeyChain', - 'Knife', - 'Ladle', - 'Laptop', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Newspaper', - 'Pan', - 'PaperTowel', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Tomato', - 'TomatoSliced', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'CounterTop': {'AlarmClock', - 'Apple', - 'AppleSliced', - 'BaseballBat', - 'BasketBall', - 'Book', - 'Bowl', - 'Box', - 'Bread', - 'BreadSliced', - 'ButterKnife', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'DishSponge', - 'Egg', - 'Glassbottle', - 'Fork', - 'Kettle', - 'KeyChain', - 'Knife', - 'Ladle', - 'Laptop', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Newspaper', - 'Pan', - 'PaperTowel', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'Statue', - 'TennisRacket', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Tomato', - 'TomatoSliced', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'Shelf': {'AlarmClock', - 'Book', - 'Bowl', - 'Box', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'Cup', - 'DishSponge', - 'Glassbottle', - 'Kettle', - 'KeyChain', - 'Mug', - 'Newspaper', - 'PaperTowel', - 'Pen', - 'Pencil', - 'PepperShaker', - 'Plate', - 'Pot', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'Statue', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Vase', - 'Watch', - 'WateringCan', - 'WineBottle', - 'HandTowel'}, - 'Drawer': {'Book', - 'ButterKnife', - 'Candle', - 'CD', - 'CellPhone', - 'Cloth', - 'CreditCard', - 'DishSponge', - 'Fork', - 'KeyChain', - 'Knife', - 'Ladle', - 'Newspaper', - 'Pen', - 'Pencil', - 'PepperShaker', - 'RemoteControl', - 'SaltShaker', - 'SoapBar', - 'SoapBottle', - 'Spatula', - 'Spoon', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Watch', - 'WateringCan', - 'HandTowel'}, - 'GarbageCan': {'Apple', - 'AppleSliced', - 'Bread', - 'BreadSliced', - 'CD', - 'Cloth', - 'DishSponge', - 'Egg', - 'Lettuce', - 'LettuceSliced', - 'Newspaper', - 'PaperTowel', - 'Pen', - 'Pencil', - 'Potato', - 'PotatoSliced', - 'SoapBar', - 'SoapBottle', - 'SprayBottle', - 'TissueBox', - 'ToiletPaper', - 'ToiletPaperRoll', - 'Tomato', - 'TomatoSliced', - 'WineBottle', - 'HandTowel'}, - 'Safe': {'CD', - 'CellPhone', - 'CreditCard', - 'KeyChain', - 'Statue', - 'Vase', - 'Watch'}, - 'TVStand': {'TissueBox'}, - 'Toaster': {'BreadSliced'}, -} -VAL_RECEPTACLE_OBJECTS['DiningTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] -VAL_RECEPTACLE_OBJECTS['CoffeeTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] -VAL_RECEPTACLE_OBJECTS['SideTable'] = VAL_RECEPTACLE_OBJECTS['TableTop'] -del VAL_RECEPTACLE_OBJECTS['TableTop'] - -NON_RECEPTACLES_SET = (OBJECTS_SET - set(VAL_RECEPTACLE_OBJECTS.keys())) | set(MOVABLE_RECEPTACLES) - -VAL_ACTION_OBJECTS = { - 'Heatable': {'Apple', - 'AppleSliced', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Mug', - 'Plate', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced'}, - 'Coolable': {'Apple', - 'AppleSliced', - 'Bowl', - 'Bread', - 'BreadSliced', - 'Cup', - 'Egg', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'Tomato', - 'TomatoSliced', - 'WineBottle'}, - 'Cleanable': {'Apple', - 'AppleSliced', - 'Bowl', - 'ButterKnife', - 'Cloth', - 'Cup', - 'DishSponge', - 'Egg', - 'Fork', - 'Kettle', - 'Knife', - 'Ladle', - 'Lettuce', - 'LettuceSliced', - 'Mug', - 'Pan', - 'Plate', - 'Pot', - 'Potato', - 'PotatoSliced', - 'SoapBar', - 'Spatula', - 'Spoon', - 'Tomato', - 'TomatoSliced'}, - 'Toggleable': {'DeskLamp', - 'FloorLamp'}, - 'Sliceable': {'Apple', - 'Bread', - 'Egg', - 'Lettuce', - 'Potato', - 'Tomato'} -} - -# object parents -OBJ_PARENTS = {obj: obj for obj in OBJECTS} -OBJ_PARENTS['AppleSliced'] = 'Apple' -OBJ_PARENTS['BreadSliced'] = 'Bread' -OBJ_PARENTS['LettuceSliced'] = 'Lettuce' -OBJ_PARENTS['PotatoSliced'] = 'Potato' -OBJ_PARENTS['TomatoSliced'] = 'Tomato' - -# force a different horizon view for objects of (type, location). If the location is None, force this horizon for all -# objects of that type. -FORCED_HORIZON_OBJS = { - ('FloorLamp', None): 0, - ('Fridge', 18): 30, - ('Toilet', None): 15, -} - -# openable objects with fixed states for transport. -FORCED_OPEN_STATE_ON_PICKUP = { - 'Laptop': False, -} - -# list of openable classes. -OPENABLE_CLASS_LIST = ['Fridge', 'Cabinet', 'Microwave', 'Drawer', 'Safe', 'Box'] -OPENABLE_CLASS_SET = set(OPENABLE_CLASS_LIST) - -######################################################################################################################## \ No newline at end of file diff --git a/gen/ff_planner/README.md b/gen/ff_planner/README.md deleted file mode 100644 index 81bc18c0f..000000000 --- a/gen/ff_planner/README.md +++ /dev/null @@ -1,13 +0,0 @@ -# Metric FF Planner -Credit: https://fai.cs.uni-saarland.de/hoffmann/metric-ff.html. -Specifically this uses the Metric-FF Version 2.1 (https://fai.cs.uni-saarland.de/hoffmann/ff/Metric-FF-v2.1.tgz). - -Note that the code here is not exactly the same as the one you can download from that website. -Their code had issues that threw segfaults which I was able to fix for this project. -It is possible that my changes caused some other issues that I am unaware of. - -To compile: -```bash -$ cd -$ make -``` diff --git a/gen/ff_planner/expressions.c b/gen/ff_planner/expressions.c deleted file mode 100644 index 8fb8d2404..000000000 --- a/gen/ff_planner/expressions.c +++ /dev/null @@ -1,2623 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/*********************************************************************** - * File: expressions.c - * Description: functions for handling numerical expressions - * - * - general utilities: - * comparisons between numbers etc. - * - * - LNF compilation: - * normalization of expressions - * translation of subtractions - * - * - LNF post-processing: - * summarization of effects - * encoding of non-minimal LNFs - * - * Author: Joerg Hoffmann 2001 - * - *********************************************************************/ - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - - - - - - - - - - - - - - - -/******************************************************* - * SIMPLE UTILITIES - *******************************************************/ - - - - - - - - - - - - - - - - -Bool number_comparison_holds( Comparator c, float l, float r ) - -{ - - switch ( c ) { - case LE: - if ( l < r ) return TRUE; - break; - case LEQ: - if ( l <= r ) return TRUE; - break; - case EQ: - if ( l == r ) return TRUE; - break; - case GEQ: - if ( l >= r ) return TRUE; - break; - case GE: - if ( l > r ) return TRUE; - break; - case IGUAL: - /* technical for non-required fluents - */ - return TRUE; - default: - printf("\n\nillegal comparator %d in number comp holds", c); - exit( 1 ); - } - - return FALSE; - -} - - - - - - - - - - - - - - - - - - - - - -/******************************************************* - * MACHINERY FOR LNF TRANSFORMATION!!!!!! - *******************************************************/ - - - - - - - - - - - - - - - - - - - - - - - - -Bool transform_to_LNF( void ) - -{ - - if ( !is_linear_task() ) { - return FALSE; - } - - normalize_expressions(); - if ( gcmd_line.display_info == 121 ) { - printf("\n\nnormalized expressions representation is:\n\n"); - print_lnf_representation(); - } - - translate_subtractions(); - if ( gcmd_line.display_info == 122 ) { - printf("\n\nLNF : translated subtractions representation is:\n\n"); - print_lnf_representation(); - } - - /* LNF computed. start post-processing. - */ - - /* do same-cond effects etc. summarization here so as to have - * as tight as possible an encoded LNF representation. - */ - summarize_effects(); - if ( gcmd_line.display_info == 123 ) { - printf("\n\nLNF - summarized effects representation is:\n\n"); - print_lnf_representation(); - } - - encode_lfns_as_artificial_fluents(); - /* optimization is translated into minimizing - * effect costs... here, determine the cost that - * each effect has. - * - * returns TRUE if a non-trivial optimization expression - * could be established. - */ - if ( setup_effect_costs() ) { - if ( gcmd_line.display_info > 1 ) { - printf("\nmetric established (normalized to minimize): "); - print_LnfExpNode( &glnf_metric ); - } - goptimization_established = TRUE; - } - if ( gcmd_line.display_info == 124 ) { - printf("\n\nencoded LNF representation is:\n\n"); - print_lnf_representation(); - } - - return TRUE; - -} - - - -/* simple syntax check - */ -Bool is_linear_task( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j; - - for ( a = gactions; a; a = a->next ) { - /* preconds - */ - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - if ( !is_linear_expression( a->numeric_preconds_lh[i] ) ) { - return FALSE; - } - if ( !is_linear_expression( a->numeric_preconds_rh[i] ) ) { - return FALSE; - } - } - - /* effects - */ - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - for ( j = 0; j < e->num_numeric_conditions; j++ ) { - if ( !is_linear_expression( e->numeric_conditions_lh[j] ) ) { - return FALSE; - } - if ( !is_linear_expression( e->numeric_conditions_rh[j] ) ) { - return FALSE; - } - } - - if ( e->illegal ) { - /* we don't care whether that one's ok or not- - * it won't be applied anyway. - */ - continue; - } - - for ( j = 0; j < e->num_numeric_effects; j++ ) { - if ( e->numeric_effects_neft[j] != INCREASE && - e->numeric_effects_neft[j] != DECREASE && - e->numeric_effects_neft[j] != ASSIGN ) { - return FALSE; - } - if ( !is_linear_expression( e->numeric_effects_rh[j] ) ) { - return FALSE; - } - } - } - } - - /* goal condition also... - */ - for ( i = 0; i < gnum_numeric_goal; i++ ) { - if ( !is_linear_expression( gnumeric_goal_lh[i] ) ) { - return FALSE; - } - if ( !is_linear_expression( gnumeric_goal_rh[i] ) ) { - return FALSE; - } - } - - if ( gmetric != NULL ) { - if ( !is_linear_expression( gmetric ) ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: metric is no linear expression. defaulting to plan length."); - } - free_ExpNode( gmetric ); - gmetric = NULL; - } - } - - return TRUE; - -} - - - -Bool is_linear_expression( ExpNode *n ) - -{ - - switch ( n->connective ) { - case MU: - if ( !is_linear_expression( n->leftson ) || - !is_linear_expression( n->rightson ) ) { - return FALSE; - } - if ( n->leftson->connective != NUMBER && - n->rightson->connective != NUMBER ) { - return FALSE; - } - break; - case DI: - if ( !is_linear_expression( n->leftson ) || - n->rightson->connective != NUMBER ) { - return FALSE; - } - break; - case AD: - case SU: - if ( !is_linear_expression( n->leftson ) || - !is_linear_expression( n->rightson ) ) { - return FALSE; - } - break; - case MINUS: - if ( !is_linear_expression( n->son ) ) { - return FALSE; - } - break; - case NUMBER: - case FHEAD: - break; - default: - printf("\n\nis linear exp: wrong specifier %d", - n->connective); - exit( 1 ); - } - - return TRUE; - -} - - - -void print_lnf_representation( void ) - -{ - - int i; - Action *a; - - for ( i = 0; i < gnum_operators; i++ ) { - printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); - for ( a = gactions; a; a = a->next ) { - if ( ( !a->norm_operator && - !a->pseudo_action ) || - ( a->norm_operator && - a->norm_operator->operator != goperators[i] ) || - ( a->pseudo_action && - a->pseudo_action->operator != goperators[i] ) ) { - continue; - } - print_lnf_Action( a ); - } - } - printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); - for ( a = gactions; a; a = a->next ) { - if ( !a->norm_operator && - !a->pseudo_action ) { - print_lnf_Action( a ); - } - } - - printf("\n\ninitial state is:\n\n"); - print_State( ginitial_state ); - - printf("\n\ngoal is:\n\n"); - for ( i = 0; i < gnum_logic_goal; i++ ) { - print_ft_name( glogic_goal[i] ); - printf("\n"); - } - for ( i = 0; i < gnum_lnf_goal; i++ ) { - switch ( glnf_goal_comp[i] ) { - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator in lnf goal %d\n\n", glnf_goal_comp[i]); - exit( 1 ); - } - print_LnfExpNode( glnf_goal_lh[i] ); - printf(" %f", glnf_goal_rh[i]); - printf(")\n"); - } - - if ( gmetric ) { - printf("\n\nmetric is (minimize) (constant part skipped):\n"); - print_LnfExpNode( &glnf_metric ); - } else { - printf("\n\nmetric: none, i.e. plan length\n"); - } - -} - - - - - - - - - - - - - - - - - - -/******************************************************* - * SUBPART I: NORMALIZE THE EXPRESSIONS - *******************************************************/ - - - - - - - - - - - - - - - - - -/* local globals. - */ - -Comparator lcomp; - -int lF[MAX_LNF_F]; -float lC[MAX_LNF_F]; -int lnum_F; - -float lc; - - - - - - - - - - - -void normalize_expressions( void ) - -{ - - Action *a, *p, *t; - ActionEffect *e; - int i, j, k; - Bool eq; - LnfExpNode *lnf; - - /* first, pre-normalize all the expressions, i.e. translate - * divisions, and push muliplications downwards. - */ - for ( i = 0; i < gnum_numeric_goal; i++ ) { - if ( !translate_divisions( &(gnumeric_goal_lh[i]) ) ) { - printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); - exit( 1 ); - } - push_multiplications_down( &(gnumeric_goal_lh[i]) ); - if ( !translate_divisions( &(gnumeric_goal_rh[i]) ) ) { - printf("\n\nff: division by zero in goal. no plan will solve it.\n\n"); - exit( 1 ); - } - push_multiplications_down( &(gnumeric_goal_rh[i]) ); - } - - a = gactions; p = NULL; - while ( a ) { - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - if ( !translate_divisions( &(a->numeric_preconds_lh[i]) ) ) break; - push_multiplications_down( &(a->numeric_preconds_lh[i]) ); - if ( !translate_divisions( &(a->numeric_preconds_rh[i]) ) ) break; - push_multiplications_down( &(a->numeric_preconds_rh[i]) ); - } - if ( i < a->num_numeric_preconds ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in precond of "); - print_Action_name( a ); - printf(". skipping action."); - } - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - for ( j = 0; j < e->num_numeric_conditions; j++ ) { - if ( !translate_divisions( &(e->numeric_conditions_lh[j]) ) ) break; - push_multiplications_down( &(e->numeric_conditions_lh[j]) ); - if ( !translate_divisions( &(e->numeric_conditions_rh[j]) ) ) break; - push_multiplications_down( &(e->numeric_conditions_rh[j]) ); - } - if ( j < e->num_numeric_conditions ) break; - - if ( e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_numeric_effects; j++ ) { - if ( !translate_divisions( &(e->numeric_effects_rh[j]) ) ) break; - push_multiplications_down( &(e->numeric_effects_rh[j]) ); - } - if ( j < e->num_numeric_effects ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in effect rh of "); - print_Action_name( a ); - printf(". marking effect as illegal."); - } - e->illegal = TRUE; - } - } - if ( i < a->num_effects ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in effect cond of "); - print_Action_name( a ); - printf(". skipping action."); - } - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - - p = a; - a = a->next; - } - if ( gmetric != NULL ) { - if ( !translate_divisions( &gmetric ) ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: division by zero in metric. replaced with plan length."); - } - free_ExpNode( gmetric ); - gmetric = NULL; - } - push_multiplications_down( &gmetric ); - } - - /* now, collect the normalized representations of all expressions. - */ - for ( a = gactions; a; a = a->next ) { - /* preconds - */ - a->lnf_preconds_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); - a->lnf_preconds_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); - a->lnf_preconds_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); - a->num_lnf_preconds = 0; - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - eq = FALSE; - if ( a->numeric_preconds_comp[i] == EQ ) { - eq = TRUE; - a->numeric_preconds_comp[i] = LEQ; - } - put_comp_into_normalized_locals( a->numeric_preconds_comp[i], - a->numeric_preconds_lh[i], - a->numeric_preconds_rh[i] ); - a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; - a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); - lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - a->lnf_preconds_rh[a->num_lnf_preconds] = lc; - a->num_lnf_preconds++; - if ( eq ) { - if ( a->num_lnf_preconds == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - a->numeric_preconds_comp[i] = EQ; - put_comp_into_normalized_locals( GEQ, - a->numeric_preconds_lh[i], - a->numeric_preconds_rh[i] ); - a->lnf_preconds_comp[a->num_lnf_preconds] = lcomp; - a->lnf_preconds_lh[a->num_lnf_preconds] = new_LnfExpNode(); - lnf = a->lnf_preconds_lh[a->num_lnf_preconds]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - a->lnf_preconds_rh[a->num_lnf_preconds] = lc; - a->num_lnf_preconds++; - } - } - - /* effects - */ - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - e->lnf_conditions_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); - e->lnf_conditions_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); - e->lnf_conditions_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); - e->num_lnf_conditions = 0; - for ( j = 0; j < e->num_numeric_conditions; j++ ) { - if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - eq = FALSE; - if ( e->numeric_conditions_comp[j] == EQ ) { - eq = TRUE; - e->numeric_conditions_comp[j] = LEQ; - } - put_comp_into_normalized_locals( e->numeric_conditions_comp[j], - e->numeric_conditions_lh[j], - e->numeric_conditions_rh[j] ); - e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; - e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); - lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; - for ( k = 0; k < lnum_F; k++ ) { - if ( lC[k] == 0 ) continue; - if ( lC[k] > 0 ) { - lnf->pF[lnf->num_pF] = lF[k]; - lnf->pC[lnf->num_pF++] = lC[k]; - } else { - lnf->nF[lnf->num_nF] = lF[k]; - lnf->nC[lnf->num_nF++] = (-1) * lC[k]; - } - } - e->lnf_conditions_rh[e->num_lnf_conditions] = lc; - e->num_lnf_conditions++; - if ( eq ) { - if ( e->num_lnf_conditions == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - e->numeric_conditions_comp[j] = EQ; - put_comp_into_normalized_locals( GEQ, - e->numeric_conditions_lh[j], - e->numeric_conditions_rh[j] ); - e->lnf_conditions_comp[e->num_lnf_conditions] = lcomp; - e->lnf_conditions_lh[e->num_lnf_conditions] = new_LnfExpNode(); - lnf = e->lnf_conditions_lh[e->num_lnf_conditions]; - for ( k = 0; k < lnum_F; k++ ) { - if ( lC[k] == 0 ) continue; - if ( lC[k] > 0 ) { - lnf->pF[lnf->num_pF] = lF[k]; - lnf->pC[lnf->num_pF++] = lC[k]; - } else { - lnf->nF[lnf->num_nF] = lF[k]; - lnf->nC[lnf->num_nF++] = (-1) * lC[k]; - } - } - e->lnf_conditions_rh[e->num_lnf_conditions] = lc; - e->num_lnf_conditions++; - } - } - - if ( e->illegal ) { - /* we do have the LNF to know whether the effect appears. - * if it does, then this one is illegal anyway, remembered - * in inst final due to undefined fl access. - * - * if it is LEGAL, then all fluents we're gonna find and - * collect below are relevant!!! - */ - continue; - } - - e->lnf_effects_neft = ( NumericEffectType * ) calloc( MAX_LNF_EFFS, sizeof( NumericEffectType ) ); - e->lnf_effects_fl = ( int * ) calloc( MAX_LNF_EFFS, sizeof( int ) ); - e->lnf_effects_rh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_EFFS, sizeof( LnfExpNode_pointer ) ); - e->num_lnf_effects = 0; - for ( j = 0; j < e->num_numeric_effects; j++ ) { - if ( e->num_lnf_effects == MAX_LNF_EFFS ) { - printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); - exit( 1 ); - } - e->lnf_effects_neft[e->num_lnf_effects] = e->numeric_effects_neft[j]; - e->lnf_effects_fl[e->num_lnf_effects] = e->numeric_effects_fl[j]; - lnum_F = 0; - lc = 0; - if ( e->lnf_effects_neft[e->num_lnf_effects] == DECREASE ) { - collect_normalized_locals( e->numeric_effects_rh[j], FALSE ); - e->lnf_effects_neft[e->num_lnf_effects] = INCREASE; - } else { - collect_normalized_locals( e->numeric_effects_rh[j], TRUE ); - } - e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); - lnf = e->lnf_effects_rh[e->num_lnf_effects]; - for ( k = 0; k < lnum_F; k++ ) { - if ( lC[k] == 0 ) continue; - if ( lC[k] > 0 ) { - lnf->pF[lnf->num_pF] = lF[k]; - lnf->pC[lnf->num_pF++] = lC[k]; - } else { - lnf->nF[lnf->num_nF] = lF[k]; - lnf->nC[lnf->num_nF++] = (-1) * lC[k]; - } - } - e->lnf_effects_rh[e->num_lnf_effects]->c = lc; - e->num_lnf_effects++; - } - } - } - - /* goal condition also... - */ - glnf_goal_comp = ( Comparator * ) calloc( MAX_LNF_COMPS, sizeof( Comparator ) ); - glnf_goal_lh = ( LnfExpNode_pointer * ) calloc( MAX_LNF_COMPS, sizeof( LnfExpNode_pointer ) ); - glnf_goal_rh = ( float * ) calloc( MAX_LNF_COMPS, sizeof( float ) ); - gnum_lnf_goal = 0; - for ( i = 0; i < gnum_numeric_goal; i++ ) { - if ( gnum_lnf_goal == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - eq = FALSE; - if ( gnumeric_goal_comp[i] == EQ ) { - eq = TRUE; - gnumeric_goal_comp[i] = LEQ; - } - put_comp_into_normalized_locals( gnumeric_goal_comp[i], - gnumeric_goal_lh[i], - gnumeric_goal_rh[i] ); - glnf_goal_comp[gnum_lnf_goal] = lcomp; - glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); - lnf = glnf_goal_lh[gnum_lnf_goal]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - glnf_goal_rh[gnum_lnf_goal] = lc; - gnum_lnf_goal++; - if ( eq ) { - if ( gnum_lnf_goal == MAX_LNF_COMPS ) { - printf("\n\nincrease MAX_LNF_COMPS! currently %d\n\n", MAX_LNF_COMPS); - exit( 1 ); - } - gnumeric_goal_comp[i] = EQ; - put_comp_into_normalized_locals( GEQ, - gnumeric_goal_lh[i], - gnumeric_goal_rh[i] ); - glnf_goal_comp[gnum_lnf_goal] = lcomp; - glnf_goal_lh[gnum_lnf_goal] = new_LnfExpNode(); - lnf = glnf_goal_lh[gnum_lnf_goal]; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - glnf_goal_rh[gnum_lnf_goal] = lc; - gnum_lnf_goal++; - } - } - /* metric... - */ - lnum_F = 0; - lc = 0; - glnf_metric.num_pF = 0; - glnf_metric.num_nF = 0; - glnf_metric.c = 0; - collect_normalized_locals( gmetric, TRUE ); - lnf = &glnf_metric; - for ( j = 0; j < lnum_F; j++ ) { - if ( lC[j] == 0 ) continue; - if ( lC[j] > 0 ) { - lnf->pF[lnf->num_pF] = lF[j]; - lnf->pC[lnf->num_pF++] = lC[j]; - } else { - lnf->nF[lnf->num_nF] = lF[j]; - lnf->nC[lnf->num_nF++] = (-1) * lC[j]; - } - } - - -} - - - -Bool translate_divisions( ExpNode **n ) - -{ - - ExpNode *tmp; - - /* "dirty": also normalize multiplications so that the constant - * is always on the left hand side --- - * simplifies function below a lot. - */ - switch ( (*n)->connective ) { - case DI: - /* rightson is number due to syntax check. - */ - if ( (*n)->rightson->value == 0 ) { - /* what needs to be done we can only decide further up. - */ - printf("\nwarning: division by zero."); - return FALSE; - } - if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; - (*n)->connective = MU; - (*n)->rightson->value = 1 / (*n)->rightson->value; - tmp = (*n)->rightson; - (*n)->rightson = (*n)->leftson; - (*n)->leftson = tmp; - break; - case MU: - if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; - if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->rightson->connective == NUMBER ) { - tmp = (*n)->rightson; - (*n)->rightson = (*n)->leftson; - (*n)->leftson = tmp; - } - break; - case AD: - case SU: - if ( !translate_divisions( &((*n)->leftson) ) ) return FALSE; - if ( !translate_divisions( &((*n)->rightson) ) ) return FALSE; - break; - case MINUS: - if ( !translate_divisions( &((*n)->son) ) ) return FALSE; - break; - case NUMBER: - case FHEAD: - break; - default: - printf("\n\ntranslate divisions: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - - return TRUE; - -} - - - -void push_multiplications_down( ExpNode **n ) - -{ - - ExpNode *tmp1, *tmp2; - - switch ( (*n)->connective ) { - case MU: - /* due to syntax check, at least one of sons is number, - * - * due to above, it's the left one. - * NOTE that this invariant is kept true troughout the - * modifications done here. - */ - if ( (*n)->rightson->connective == NUMBER ) { - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - free_ExpNode( (*n)->rightson ); - (*n)->leftson = NULL; - (*n)->rightson = NULL; - break; - } - if ( (*n)->rightson->connective == FHEAD ) { - (*n)->connective = FHEAD; - (*n)->fl = (*n)->rightson->fl; - (*n)->c = (*n)->leftson->value; - free_ExpNode( (*n)->leftson ); - free_ExpNode( (*n)->rightson ); - (*n)->leftson = NULL; - (*n)->rightson = NULL; - break; - } - if ( (*n)->rightson->connective == MINUS ) { - (*n)->connective = MINUS; - (*n)->son = (*n)->rightson; - (*n)->son->connective = MU; - (*n)->son->leftson = (*n)->leftson; - (*n)->son->rightson = (*n)->rightson->son; - (*n)->rightson = NULL; - (*n)->leftson = NULL; - (*n)->son->son = NULL; - push_multiplications_down( &((*n)->son) ); - break; - } - if ( (*n)->rightson->connective == MU ) { - (*n)->leftson->value *= (*n)->rightson->leftson->value; - tmp1 = (*n)->rightson->rightson; - (*n)->rightson->rightson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = tmp1; - push_multiplications_down( n ); - break; - } - - /* rigthson is either AD or SU - */ - tmp1 = new_ExpNode( NUMBER ); - tmp2 = new_ExpNode( NUMBER ); - tmp1->value = (*n)->leftson->value; - tmp2->value = (*n)->leftson->value; - - (*n)->connective = (*n)->rightson->connective; - (*n)->leftson->connective = MU; - (*n)->rightson->connective = MU; - (*n)->leftson->leftson = tmp1; - (*n)->leftson->rightson = (*n)->rightson->leftson; - (*n)->rightson->leftson = tmp2; - - push_multiplications_down( &((*n)->leftson) ); - push_multiplications_down( &((*n)->rightson) ); - break; - case AD: - case SU: - push_multiplications_down( &((*n)->leftson) ); - push_multiplications_down( &((*n)->rightson) ); - break; - case MINUS: - push_multiplications_down( &((*n)->son) ); - break; - case NUMBER: - case FHEAD: - break; - default: - printf("\n\ntranslate divisions: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -void put_comp_into_normalized_locals( Comparator comp, - ExpNode *lh, - ExpNode *rh ) - -{ - - ExpNode *tmp; - - tmp = new_ExpNode( SU ); - - /* initialisation of normalized locals - */ - lnum_F = 0; - lc = 0; - - lcomp = comp; - - /* if comparison is LE or LEQ, then subtract - * left hand side from right hand side to obtain - * new left hand side. - */ - if ( lcomp == LE ) { - tmp->leftson = rh; - tmp->rightson = lh; - collect_normalized_locals( tmp, TRUE ); - lcomp = GE; - /* "subtract" the constant to get it to the right hand - * side. - */ - lc *= (-1); - free( tmp ); - return; - } - if ( lcomp == LEQ ) { - tmp->leftson = rh; - tmp->rightson = lh; - collect_normalized_locals( tmp, TRUE ); - lcomp = GEQ; - lc *= (-1); - free( tmp ); - return; - } - - /* otherwise, subtract right hand side from left hand side. - */ - tmp->leftson = lh; - tmp->rightson = rh; - collect_normalized_locals( tmp, TRUE ); - lc *= (-1); - free( tmp ); - -} - - - -void collect_normalized_locals( ExpNode *n, Bool positive ) - -{ - - Bool negative = positive ? FALSE : TRUE; - int i; - - if ( !n ) return; - - switch ( n->connective ) { - case AD: - collect_normalized_locals( n->leftson, positive ); - collect_normalized_locals( n->rightson, positive ); - break; - case SU: - collect_normalized_locals( n->leftson, positive ); - collect_normalized_locals( n->rightson, negative ); - break; - case MINUS: - collect_normalized_locals( n->son, negative ); - break; - case NUMBER: - if ( positive ) { - lc += n->value; - } else { - lc -= n->value; - } - break; - case FHEAD: - if ( n->fl < 0 && n->fl != -2 ) { - printf("\n\ncollecting non-relevant fluent for LNF!!\n\n"); - exit( 1 ); - } - for ( i = 0; i < lnum_F; i++ ) { - if ( lF[i] == n->fl ) break; - } - if ( i < lnum_F ) { - lC[i] += positive ? n->c : ((-1) * n->c); - } else { - if ( lnum_F == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - lF[lnum_F] = n->fl; - lC[lnum_F] = positive ? n->c : ((-1) * n->c); - lnum_F++; - } - break; - default: - printf("\n\ncollect_normalized_locals: wrong specifier %d", - n->connective); - exit( 1 ); - } - -} - - - - - - - - - - - - - - - - - - - - - -/******************************************************* - * SUBPART II: TRANSLATE THE SUBTRACTIONS - *******************************************************/ - - - - - - - - - - - - - - - -/* local globals. - */ - -int lminus_fluent[MAX_RELEVANT_FLUENTS]; - - - - - - - - - - - - -void translate_subtractions( void ) - -{ - - int i, fl; - - /* minus_fluent[fl] gives the number of the fluent that - * takes on the negative value to fl, or -1 if there is - * no such fluent. - */ - for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { - lminus_fluent[i] = -1; - } - - while ( TRUE ) { - /* ex fl \in nF for pre, cond, eff or goal? - */ - if ( !ex_fl_in_nF_of_pre_cond_eff_goal( &fl ) ) { - /* no --> we are finished. - */ - break; - } - if ( fl < 0 ) { - if ( fl != -2 ) { - printf("\n\nnon-relevant fluent in non-illegal part!\n\n"); - exit( 1 ); - } else { - printf("\n\nwarning: total-time occurs negatively in metric. no optimization done.\n\n"); - glnf_metric.num_pF = 0; - glnf_metric.num_nF = 0; - continue; - } - } - /* set the new number and name, incrementing - * gnum_relevant_fluents, and setting - * minus_fluent value for both directions. - */ - introduce_minus_fluent( fl ); - /* replace all occurences in effects and conds and goals - */ - replace_fl_in_nF_with_minus_fl( fl ); - /* set the initial value of the new fluent - */ - set_minus_fl_initial( fl ); - /* adjust the effects accordingly - */ - introduce_minus_fl_effects( fl ); - } - -} - - - -Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ) - -{ - - Action *a; - ActionEffect *e; - int i, j; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - if ( glnf_goal_lh[i]->num_nF > 0 ) { - *fl = glnf_goal_lh[i]->nF[0]; - return TRUE; - } - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - if ( a->lnf_preconds_lh[i]->num_nF > 0 ) { - *fl = a->lnf_preconds_lh[i]->nF[0]; - return TRUE; - } - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( e->lnf_conditions_lh[j]->num_nF > 0 ) { - *fl = e->lnf_conditions_lh[j]->nF[0]; - return TRUE; - } - } - - if ( e->illegal ) { - /* we don't care if there's something in here that - * wants to be translated. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_rh[j]->num_nF > 0 ) { - *fl = e->lnf_effects_rh[j]->nF[0]; - return TRUE; - } - } - } - } - - /* no need to throw costs away, even if we're not explicitly asked to - * minimize them - */ - if ( (1 || gcost_minimizing) && glnf_metric.num_nF > 0 ) { - *fl = glnf_metric.nF[0]; - return TRUE; - } - - return FALSE; - -} - - - -void introduce_minus_fluent( int fl ) - -{ - - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = -1; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], "MINUS-" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], - grelevant_fluents_name[fl] ); - lminus_fluent[fl] = gnum_relevant_fluents; - lminus_fluent[gnum_relevant_fluents] = fl; - gnum_relevant_fluents++; - -} - - - -void replace_fl_in_nF_with_minus_fl( int fl ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k, l; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - for ( j = 0; j < glnf_goal_lh[i]->num_nF; j++ ) { - if ( glnf_goal_lh[i]->nF[j] == fl ) break; - } - if ( j == glnf_goal_lh[i]->num_nF ) continue; - /* now the jth fluent in subtraction is our translated one. - * - * first, put minus-fl into pF. Can't already be there - * because we have only just introduced it. - */ - if ( glnf_goal_lh[i]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - glnf_goal_lh[i]->pF[glnf_goal_lh[i]->num_pF] = lminus_fluent[fl]; - glnf_goal_lh[i]->pC[glnf_goal_lh[i]->num_pF++] = glnf_goal_lh[i]->nC[j]; - /* now remove fl from nF. - */ - for ( k = j; k < glnf_goal_lh[i]->num_nF - 1; k++ ) { - glnf_goal_lh[i]->nF[k] = glnf_goal_lh[i]->nF[k+1]; - glnf_goal_lh[i]->nC[k] = glnf_goal_lh[i]->nC[k+1]; - } - glnf_goal_lh[i]->num_nF--; - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - for ( j = 0; j < a->lnf_preconds_lh[i]->num_nF; j++ ) { - if ( a->lnf_preconds_lh[i]->nF[j] == fl ) break; - } - if ( j == a->lnf_preconds_lh[i]->num_nF ) continue; - if ( a->lnf_preconds_lh[i]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - a->lnf_preconds_lh[i]->pF[a->lnf_preconds_lh[i]->num_pF] = lminus_fluent[fl]; - a->lnf_preconds_lh[i]->pC[a->lnf_preconds_lh[i]->num_pF++] = a->lnf_preconds_lh[i]->nC[j]; - for ( k = j; k < a->lnf_preconds_lh[i]->num_nF - 1; k++ ) { - a->lnf_preconds_lh[i]->nF[k] = a->lnf_preconds_lh[i]->nF[k+1]; - a->lnf_preconds_lh[i]->nC[k] = a->lnf_preconds_lh[i]->nC[k+1]; - } - a->lnf_preconds_lh[i]->num_nF--; - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - for ( k = 0; k < e->lnf_conditions_lh[j]->num_nF; k++ ) { - if ( e->lnf_conditions_lh[j]->nF[k] == fl ) break; - } - if ( k == e->lnf_conditions_lh[j]->num_nF ) continue; - if ( e->lnf_conditions_lh[j]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - e->lnf_conditions_lh[j]->pF[e->lnf_conditions_lh[j]->num_pF] = lminus_fluent[fl]; - e->lnf_conditions_lh[j]->pC[e->lnf_conditions_lh[j]->num_pF++] = e->lnf_conditions_lh[j]->nC[k]; - for ( l = k; l < e->lnf_conditions_lh[j]->num_nF - 1; l++ ) { - e->lnf_conditions_lh[j]->nF[l] = e->lnf_conditions_lh[j]->nF[l+1]; - e->lnf_conditions_lh[j]->nC[l] = e->lnf_conditions_lh[j]->nC[l+1]; - } - e->lnf_conditions_lh[j]->num_nF--; - } - - if ( e->illegal ) { - /* like before, we don't care about effects that access - * irrelevant fluents - */ - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { - if ( e->lnf_effects_rh[j]->nF[k] == fl ) break; - } - if ( k == e->lnf_effects_rh[j]->num_nF ) continue; - if ( e->lnf_effects_rh[j]->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - e->lnf_effects_rh[j]->pF[e->lnf_effects_rh[j]->num_pF] = lminus_fluent[fl]; - e->lnf_effects_rh[j]->pC[e->lnf_effects_rh[j]->num_pF++] = e->lnf_effects_rh[j]->nC[k]; - for ( l = k; l < e->lnf_effects_rh[j]->num_nF - 1; l++ ) { - e->lnf_effects_rh[j]->nF[l] = e->lnf_effects_rh[j]->nF[l+1]; - e->lnf_effects_rh[j]->nC[l] = e->lnf_effects_rh[j]->nC[l+1]; - } - e->lnf_effects_rh[j]->num_nF--; - } - } - } - - for ( j = 0; j < glnf_metric.num_nF; j++ ) { - if ( glnf_metric.nF[j] == fl ) break; - } - if ( j < glnf_metric.num_nF ) { - if ( glnf_metric.num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - glnf_metric.pF[glnf_metric.num_pF] = lminus_fluent[fl]; - glnf_metric.pC[glnf_metric.num_pF++] = glnf_metric.nC[j]; - for ( k = j; k < glnf_metric.num_nF - 1; k++ ) { - glnf_metric.nF[k] = glnf_metric.nF[k+1]; - glnf_metric.nC[k] = glnf_metric.nC[k+1]; - } - glnf_metric.num_nF--; - } - -} - - - -void set_minus_fl_initial( int fl ) - -{ - - if ( ginitial_state.f_D[fl] ) { - ginitial_state.f_D[lminus_fluent[fl]] = TRUE; - ginitial_state.f_V[lminus_fluent[fl]] = (-1) * ginitial_state.f_V[fl]; - } - -} - - - -void introduce_minus_fl_effects( int fl ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k, pf, nf; - LnfExpNode *len; - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->illegal ) { - /* no need to translate illegal effects. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_fl[j] != fl ) { - continue; - } - /* here is an effect that affects our fl. - * introduce inverse effect for minus_fl, - * making use of all minus-fl's that are already - * there. - */ - if ( e->num_lnf_effects == MAX_LNF_EFFS ) { - printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); - exit( 1 ); - } - e->lnf_effects_neft[e->num_lnf_effects] = e->lnf_effects_neft[j]; - e->lnf_effects_fl[e->num_lnf_effects] = lminus_fluent[fl]; - e->lnf_effects_rh[e->num_lnf_effects] = new_LnfExpNode(); - len = e->lnf_effects_rh[e->num_lnf_effects]; - /* now the most "difficult" part: setup the inverted pF and nF - * informations. - * - * NOTE: as fluent occurences are unique in original ef, - * so will they be in new ef. (no len contains both - * a fluent and its minus-fluent) - * --> invariant is or should be that the absolute - * fluents occur at most once in |pF| \cup |nF|. - * holds in the beginning. only thing we do is - * we exchange in that set for some fluents the - * positive with the negative version, so the - * invariant is in fact preserved. - */ - for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { - pf = e->lnf_effects_rh[j]->pF[k]; - if ( lminus_fluent[pf] == -1 ) { - /* not translated yet --> insert it into nF - */ - if ( len->num_nF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - len->nF[len->num_nF] = pf; - len->nC[len->num_nF++] = e->lnf_effects_rh[j]->pC[k]; - } else { - /* else, insert minus-pf into pF - */ - if ( len->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - len->pF[len->num_pF] = lminus_fluent[pf]; - len->pC[len->num_pF++] = e->lnf_effects_rh[j]->pC[k]; - } - } - for ( k = 0; k < e->lnf_effects_rh[j]->num_nF; k++ ) { - nf = e->lnf_effects_rh[j]->nF[k]; - /* insert all of those into pF - */ - if ( len->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - len->pF[len->num_pF] = nf; - len->pC[len->num_pF++] = e->lnf_effects_rh[j]->nC[k]; - } - /* the constant must of course be inverted. - */ - len->c = (-1) * e->lnf_effects_rh[j]->c; - e->num_lnf_effects++; - } - } - } - -} - - - - - - - - - - - - - - - - - - -/************************************************************* - * LNF POST-PROCESSING I: SUMMARIZE EFFECTS. - *************************************************************/ - - - - - - - - - - - - - - - - - - - -int *lA, *lD; -int lnum_A, lnum_D; - - - - - - -void summarize_effects( void ) - -{ - - Action *a; - ActionEffect *e, *e_; - int i, j, k, l; - - lA = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); - lD = ( int * ) calloc( gnum_relevant_facts, sizeof( int ) ); - - for ( a = gactions; a; a = a->next ) { - i = 0; - while ( i < a->num_effects ) { - e = &(a->effects[i]); - if ( e->removed ) { - /* this one's already handled. - */ - i++; - continue; - } - - /* first, merge the effect's own effects together. logical: - */ - lnum_A = 0; - for ( j = 0; j < e->num_adds; j++ ) { - for ( k = 0; k < lnum_A; k++ ) { - if ( lA[k] == e->adds[j] ) break; - } - if ( k < lnum_A ) continue; - lA[lnum_A++] = e->adds[j]; - } - lnum_D = 0; - for ( j = 0; j < e->num_dels; j++ ) { - for ( k = 0; k < lnum_D; k++ ) { - if ( lD[k] == e->dels[j] ) break; - } - if ( k < lnum_D ) continue; - lD[lnum_D++] = e->dels[j]; - } - /* numerical: - */ - j = 0; - while ( j < e->num_lnf_effects ) { - /* merge all effects increasing the same fluent into - * effect j, and remove them. - */ - k = j + 1; - while ( k < e->num_lnf_effects ) { - if ( e->lnf_effects_fl[k] != e->lnf_effects_fl[j] ) { - k++; - continue; - } - if ( e->lnf_effects_neft[j] == ASSIGN ) { - if ( e->lnf_effects_neft[k] != ASSIGN || - !same_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ) ) { - e->illegal = TRUE; - break; - } - } else { - if ( e->lnf_effects_neft[k] == ASSIGN ) { - e->illegal = TRUE; - break; - } - merge_lnfs( e->lnf_effects_rh[j], e->lnf_effects_rh[k] ); - } - /* we also get here if we have two identical assigns. - */ - free( e->lnf_effects_rh[k] ); - for ( l = k; l < e->num_lnf_effects - 1; l++ ) { - e->lnf_effects_neft[l] = e->lnf_effects_neft[l+1]; - e->lnf_effects_fl[l] = e->lnf_effects_fl[l+1]; - e->lnf_effects_rh[l] = e->lnf_effects_rh[l+1]; - } - e->num_lnf_effects--; - } - if ( k < e->num_lnf_effects ) { - /* illegal combination - */ - break; - } - j++; - } - - /* now merge all effects after i with same condition - * into that. - */ - j = i + 1; - while ( j < a->num_effects ) { - e_ = &(a->effects[j]); - if ( e_->removed ) { - j++; - continue; - } - - if ( !same_condition( e, e_ ) ) { - j++; - continue; - } - /* no matter what happens, we can get rid of effect e_ - */ - e_->removed = TRUE; - - /* illegality is inherited in both directions. - */ - if ( e_->illegal ) { - e->illegal = TRUE; - } - if ( e->illegal ) { - /* just for docu; it is removed anyway. - */ - e_->illegal = TRUE; - } - - if ( !e->illegal ) { - /* the combined effect appears to be legal. merge it. - */ - merge_effects( e, e_ ); - if ( e->illegal ) { - /* e might have become illegal. again, docu this. - */ - e_->illegal = TRUE; - } - } - - j++; - } - - /* now put the updated A and D info into e. - * - * have to be careful: it might be that there are - * now too many facts and we need to re-allocate - * e's capabilities. - */ - if ( lnum_A > e->num_adds ) { - free( e->adds ); - e->adds = ( int * ) calloc( lnum_A, sizeof( int ) ); - } - for ( j = 0; j < lnum_A; j++ ) { - e->adds[j] = lA[j]; - } - e->num_adds = lnum_A; - if ( lnum_D > e->num_dels ) { - free( e->dels ); - e->dels = ( int * ) calloc( lnum_D, sizeof( int ) ); - } - for ( j = 0; j < lnum_D; j++ ) { - e->dels[j] = lD[j]; - } - e->num_dels = lnum_D; - - /* increment current effects counter. - */ - i++; - } - } - -} - - - -Bool same_condition( ActionEffect *e, ActionEffect *e_ ) - -{ - - int i, j; - - if ( e->num_conditions != e_->num_conditions || - e->num_lnf_conditions != e_->num_lnf_conditions ) return FALSE; - - for ( i = 0; i < e->num_conditions; i++ ) { - for ( j = 0; j < e_->num_conditions; j++ ) { - if ( e->conditions[i] == e_->conditions[j] ) break; - } - if ( j == e_->num_conditions ) break; - } - if ( i < e->num_conditions ) return FALSE; - - for ( i = 0; i < e->num_lnf_conditions; i++ ) { - for ( j = 0; j < e_->num_lnf_conditions; j++ ) { - if ( e_->lnf_conditions_comp[j] != e->lnf_conditions_comp[i] ) continue; - if ( e_->lnf_conditions_rh[j] != e->lnf_conditions_rh[i] ) continue; - if ( !same_lnfs( e_->lnf_conditions_lh[j], e->lnf_conditions_lh[i] ) ) continue; - break; - } - if ( j == e_->num_lnf_conditions ) break; - } - if ( i < e->num_lnf_conditions ) return FALSE; - - return TRUE; - -} - - - -Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ) - -{ - - int i, j; - - if ( l->num_pF != r->num_pF || - l->c != r->c ) return FALSE; - - for ( i = 0; i < l->num_pF; i++ ) { - for ( j = 0; j < r->num_pF; j++ ) { - if ( l->pF[i] != r->pF[j] ) continue; - if ( l->pC[i] != r->pC[j] ) { - /* same fluent with different weighting. - */ - return FALSE; - } - break; - } - if ( j == r->num_pF ) break; - } - if ( i < l->num_pF ) return FALSE; - - return TRUE; - -} - - - -void merge_effects( ActionEffect *e, ActionEffect *e_ ) - -{ - - int i, j; - - /* we don't care whether adds and dels intersect: - * they're allowed to by semantics. - */ - for ( i = 0; i < e_->num_adds; i++ ) { - for ( j = 0; j < lnum_A; j++ ) { - if ( lA[j] == e_->adds[i] ) break; - } - if ( j < lnum_A ) continue; - lA[lnum_A++] = e_->adds[i]; - } - for ( i = 0; i < e_->num_dels; i++ ) { - for ( j = 0; j < lnum_D; j++ ) { - if ( lD[j] == e_->dels[i] ) break; - } - if ( j < lnum_D ) continue; - lD[lnum_D++] = e_->dels[i]; - } - - for ( i = 0; i < e_->num_lnf_effects; i++ ) { - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_fl[j] == e_->lnf_effects_fl[i] ) break; - } - if ( j == e->num_lnf_effects ) { - /* new affected fluent! - */ - if ( e->num_lnf_effects == MAX_LNF_EFFS ) { - printf("\n\nincrease MAX_LNF_EFFS! currently %d\n\n", MAX_LNF_EFFS); - exit( 1 ); - } - e->lnf_effects_neft[e->num_lnf_effects] = e_->lnf_effects_neft[i]; - e->lnf_effects_fl[e->num_lnf_effects] = e_->lnf_effects_fl[i]; - /* we can also simply take the pointer: e_ is only marked as removed, - * but not freed. - */ - e->lnf_effects_rh[e->num_lnf_effects] = e_->lnf_effects_rh[i]; - e->num_lnf_effects++; - } else { - if ( e->lnf_effects_neft[j] == ASSIGN ) { - if ( e_->lnf_effects_neft[i] != ASSIGN || - !same_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ) ) { - e->illegal = TRUE; - return; - } - /* identical assigns. nothing needs to be done. - */ - } else { - if ( e_->lnf_effects_neft[i] == ASSIGN ) { - e->illegal = TRUE; - return; - } - merge_lnfs( e->lnf_effects_rh[j], e_->lnf_effects_rh[i] ); - } - } - } - -} - - - -/* merge both LNFs into the left one. - * (only pF needed as both are already - * fully transformed) - */ -void merge_lnfs( LnfExpNode *l, LnfExpNode *r ) - -{ - - int i, j, k; - - for ( i = 0; i < r->num_pF; i++ ) { - - for ( j = 0; j < l->num_pF; j++ ) { - if ( r->pF[i] == l->pF[j] ) break; - } - if ( j < l->num_pF ) { - /* got that one in dest LNF already - */ - l->pC[j] += r->pC[i]; - continue; - } - - if ( lminus_fluent[r->pF[i]] != -1 ) { - /* this one was already translated. let's see - * if its counterpart is in the left lnf. - */ - for ( j = 0; j < l->num_pF; j++ ) { - if ( lminus_fluent[r->pF[i]] == l->pF[j] ) break; - } - if ( j < l->num_pF ) { - /* for this, we got the inverse one! - */ - l->pC[j] -= r->pC[i]; - if ( l->pC[j] < 0 ) { - l->pF[j] = r->pF[i]; - l->pC[j] *= (-1); - } - if ( l->pC[j] == 0 ) { - /* remove this entirely. - */ - for ( k = j; k < l->num_pF - 1; k++ ) { - l->pF[k] = l->pF[k+1]; - l->pC[k] = l->pC[k+1]; - } - l->num_pF--; - } - continue; - } - } - - /* we got neither that nor its counterpart. - */ - if ( l->num_pF == MAX_LNF_F ) { - printf("\n\nincrease MAX_LNF_F! currently %d\n\n", MAX_LNF_F); - exit( 1 ); - } - l->pF[l->num_pF] = r->pF[i]; - l->pC[l->num_pF++] = r->pC[i]; - } - - - l->c += r->c; - -} - - - - - - - - - - - - - - - - - - - - - - -/************************************************************* - * LNF POST-PROCESSING II: ENCODE NON-MINIMAL LNFs. - *************************************************************/ - - - - - - - - - - - - - - - - - - - - - - - -void encode_lfns_as_artificial_fluents( void ) - -{ - - int i; - - /* for the artificial new ones, this will be set - * to the respective LNF. - */ - for ( i = 0; i < MAX_RELEVANT_FLUENTS; i++ ) { - grelevant_fluents_lnf[i] = NULL; - } - - while ( TRUE ) { - /* ex non-minimal lnf in pre, cond, eff, or goal? - * - * (i.e., lnf != fl + c) - */ - if ( !ex_non_minimal_lnf_in_pre_cond_goal_eff() ) { - /* no --> we are finished. - */ - break; - } - /* otherwise, the respective LNF, without the - * constant part, is set up in - * lF...; (local global borrowed from above); - * - * introduce a new artificial fluent for that - * LNF - */ - introduce_artificial_fluent(); - /* replace all occurences in pres, conds, effs, and goals - */ - replace_non_minimal_lnf_with_artificial_fl(); - } - -} - - - -Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - if ( glnf_goal_lh[i]->num_pF > 1 || - (glnf_goal_lh[i]->num_pF == 1 && glnf_goal_lh[i]->pC[0] != 1) ) { - for ( j = 0; j < glnf_goal_lh[i]->num_pF; j++ ) { - lF[j] = glnf_goal_lh[i]->pF[j]; - lC[j] = glnf_goal_lh[i]->pC[j]; - } - lnum_F = glnf_goal_lh[i]->num_pF; - return TRUE; - } - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - if ( a->lnf_preconds_lh[i]->num_pF > 1 || - (a->lnf_preconds_lh[i]->num_pF == 1 && a->lnf_preconds_lh[i]->pC[0] != 1) ) { - for ( j = 0; j < a->lnf_preconds_lh[i]->num_pF; j++ ) { - lF[j] = a->lnf_preconds_lh[i]->pF[j]; - lC[j] = a->lnf_preconds_lh[i]->pC[j]; - } - lnum_F = a->lnf_preconds_lh[i]->num_pF; - return TRUE; - } - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->removed ) { - /* these will not be included into conn: - * merged into somewhere else. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( e->lnf_conditions_lh[j]->num_pF > 1 || - (e->lnf_conditions_lh[j]->num_pF == 1 && e->lnf_conditions_lh[j]->pC[0] != 1) ) { - for ( k = 0; k < e->lnf_conditions_lh[j]->num_pF; k++ ) { - lF[k] = e->lnf_conditions_lh[j]->pF[k]; - lC[k] = e->lnf_conditions_lh[j]->pC[k]; - } - lnum_F = e->lnf_conditions_lh[j]->num_pF; - return TRUE; - } - } - - if ( e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_rh[j]->num_pF > 1 || - (e->lnf_effects_rh[j]->num_pF == 1 && e->lnf_effects_rh[j]->pC[0] != 1) ) { - for ( k = 0; k < e->lnf_effects_rh[j]->num_pF; k++ ) { - lF[k] = e->lnf_effects_rh[j]->pF[k]; - lC[k] = e->lnf_effects_rh[j]->pC[k]; - } - lnum_F = e->lnf_effects_rh[j]->num_pF; - return TRUE; - } - } - } - } - - return FALSE; - -} - - - -void introduce_artificial_fluent( void ) - -{ - - int i; - - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = -1; - - /* no name --> is inferred in this case from _lnf - */ - - grelevant_fluents_lnf[gnum_relevant_fluents] = new_LnfExpNode(); - for ( i = 0; i < lnum_F; i++ ) { - grelevant_fluents_lnf[gnum_relevant_fluents]->pF[i] = lF[i]; - grelevant_fluents_lnf[gnum_relevant_fluents]->pC[i] = lC[i]; - } - grelevant_fluents_lnf[gnum_relevant_fluents]->num_pF = lnum_F; - - gnum_relevant_fluents++; - -} - - - -void replace_non_minimal_lnf_with_artificial_fl( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j; - - for ( i = 0; i < gnum_lnf_goal; i++ ) { - if ( !is_artificial_fluent( glnf_goal_lh[i] ) ) { - continue; - } - /* the pF here is the pF we are currently replacing. - */ - glnf_goal_lh[i]->pF[0] = gnum_relevant_fluents - 1; - glnf_goal_lh[i]->pC[0] = 1; - glnf_goal_lh[i]->num_pF = 1; - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - if ( !is_artificial_fluent( a->lnf_preconds_lh[i] ) ) { - continue; - } - a->lnf_preconds_lh[i]->pF[0] = gnum_relevant_fluents - 1; - a->lnf_preconds_lh[i]->pC[0] = 1; - a->lnf_preconds_lh[i]->num_pF = 1; - } - - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->removed ) { - /* these will not be included into conn: - * merged into somewhere else. - */ - continue; - } - - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( !is_artificial_fluent( e->lnf_conditions_lh[j] ) ) { - continue; - } - e->lnf_conditions_lh[j]->pF[0] = gnum_relevant_fluents - 1; - e->lnf_conditions_lh[j]->pC[0] = 1; - e->lnf_conditions_lh[j]->num_pF = 1; - } - - if ( e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( !is_artificial_fluent( e->lnf_effects_rh[j] ) ) { - continue; - } - e->lnf_effects_rh[j]->pF[0] = gnum_relevant_fluents - 1; - e->lnf_effects_rh[j]->pC[0] = 1; - e->lnf_effects_rh[j]->num_pF = 1; - } - } - } - -} - - - -Bool is_artificial_fluent( LnfExpNode *n ) - -{ - - int i, j; - - if ( n->num_nF != 0 ) { - printf("\n\nchecking non-empty nF for multiple fl!\n\n"); - exit( 1 ); - } - - if ( n->num_pF != lnum_F ) { - return FALSE; - } - - for ( i = 0; i < lnum_F; i++ ) { - for ( j = 0; j < n->num_pF; j++ ) { - if ( n->pF[j] != lF[i] ) continue; - if ( n->pC[j] != lC[i] ) { - /* wrong constant multiplier! - */ - return FALSE; - } - break; - } - if ( j == n->num_pF ) { - /* didn't find this fluent i in here. - */ - return FALSE; - } - } - - return TRUE; - -} - - - - - - - - - - - - - - - - - - -/************************************************************* - * AT LAST: PREPARATIONS FOR METRIC FUNCTION - *************************************************************/ - - - - - - - - - - - - - - - - - - -Bool setup_effect_costs( void ) - -{ - - Action *a; - ActionEffect *e; - int i, j, k, fl; - Bool non_zero = FALSE; - - if ( glnf_metric.num_pF == 0 ) { - /* no metric, or previously failed - */ - if ( gcmd_line.display_info ) { - printf("\nno metric specified."); - } - return FALSE; - } - - /* also in here: check if all parts of metric are defined - * if not, then they won't ever be because we do not allow - * assigners anyway. - * - * also, setup gtt total-time multipl. - * currently needed since in h fn effect cists are summed up - * --> may count the same action more than once, if we insert the - * timing cost into the effect cost. - * - * ... this is AWKWARD... probably would be better to simply - * associate costs always (including relaxed plans) - * only with ACTIONS! - */ - gtt = 0; - for ( i = 0; i < glnf_metric.num_pF; i++ ) { - if ( glnf_metric.pF[i] == -2 ) { - gtt = glnf_metric.pC[i]; - continue; - } - if ( !ginitial_state.f_D[glnf_metric.pF[i]] ) break; - } - if ( i < glnf_metric.num_pF ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: metric undefined initially. no optimization done."); - } - return FALSE; - } - - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - e->cost = 0; - - if ( e->removed || - e->illegal ) { - continue; - } - - for ( j = 0; j < e->num_lnf_effects; j++ ) { - fl = e->lnf_effects_fl[j]; - for ( k = 0; k < glnf_metric.num_pF; k++ ) { - if ( fl == glnf_metric.pF[k] ) break; - } - if ( k == glnf_metric.num_pF ) continue; - - if ( e->lnf_effects_rh[j]->num_pF > 0 ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: non-constant effect on metric. no optimization done."); - } - return FALSE; - } - if ( e->lnf_effects_neft[j] != INCREASE ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: assign on metric. no optimization done."); - } - return FALSE; - } - if ( e->lnf_effects_rh[j]->c < 0 ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: change on metric in wrong direction. no optimization done."); - } - return FALSE; - } - - e->cost += glnf_metric.pC[k] * e->lnf_effects_rh[j]->c; - if ( e->cost > 0 ) { - non_zero = TRUE; - } - } - } - } - - if ( !non_zero ) { - if ( gtt == 0 ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: trivial metric, all costs 0. no optimization done."); - } - return FALSE; - } - } - - return TRUE; - -} - - - - - - - - - - - - - - - - - - - - - -/************************************************************* - * AT VERY LAST: ACYCLIC := EFFS, AND STATIC FL RELEVANCE - *************************************************************/ - - - - - - - - - - - - - - - - - - - - - - - -void check_assigncycles( void ) - -{ - - int i, j, k, c = 0; - - gassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); - gTassign_influence = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - gassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - gTassign_influence[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - } - - if ( gcmd_line.display_info > 1 ) { - printf("\n\nchecking for cyclic := effects"); - } - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - gassign_influence[i][j] = i_influences_j( i, j ); - gTassign_influence[i][j] = i_influences_j( i, j ); - } - } - /* compute transitive closure on dependencies - */ - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( gTassign_influence[i][j] ) { - for ( k = 0; k < gnum_real_fl_conn; k++ ) { - if ( gTassign_influence[j][k] ) { - gTassign_influence[i][k] = TRUE; - } - } - } - } - } - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( gTassign_influence[i][i] ) { - printf("\nnumerical variable "); - print_fl_name( i ); - printf(" lies on := propagation cycle!"); - c++; - } - } - if ( c > 0 ) { - printf("\nexit. (mneed computation not possible, RPG termination unclear)"); - printf("\n (questions to Joerg Hoffmann)\n\n"); - exit( 1 ); - } else { - if ( gcmd_line.display_info > 1 ) { - printf(" --- OK."); - } - } - -} - - - -Bool i_influences_j( int fi, int fj ) - -{ - - int i, j, fl_; - - for ( i = 0; i < gfl_conn[fj].num_AS; i++ ) { - fl_ = gfl_conn[fj].AS_fl_[i]; - if ( fl_ < 0 ) continue; - if ( fl_ == fi ) return TRUE; - if ( !gfl_conn[fl_].artificial ) continue; - for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { - if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; - } - } - - return FALSE; - -} - - - -void determine_fl_relevance( void ) - -{ - - int i, j, k, fl, fl_, ef, pc, g; - Bool **influenced_by; - - /* this here contains transfers from i to j i.e. if - * i is relevant then j is too - */ - influenced_by = ( Bool ** ) calloc( gnum_real_fl_conn, sizeof( Bool* ) ); - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - influenced_by[i] = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - } - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - influenced_by[i][j] = ( gassign_influence[j][i] || - i_inc_influences_j( j, i ) ); - } - } - /* transitive closure so we'll have direct access below. - */ - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( influenced_by[i][j] ) { - for ( k = 0; k < gnum_real_fl_conn; k++ ) { - if ( influenced_by[j][k] ) { - influenced_by[i][k] = TRUE; - } - } - } - } - } - - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - gfl_conn[i].relevant = FALSE; - } - /* relevance originates in effect preconds and goals. - */ - for ( ef = 0; ef < gnum_ef_conn; ef++ ) { - for ( pc = 0; pc < gef_conn[ef].num_f_PC; pc++ ) { - /* constraint here is gef_conn[ef].f_PC_fl[pc] >= [>] gef_conn[ef].f_PC_c[pc] - * where lh side can be lnf expression. - */ - fl = gef_conn[ef].f_PC_fl[pc]; - if ( fl < 0 ) { - printf("\nnegative constr lh??\n\n"); - exit( 1 ); - } - if ( !gfl_conn[fl].artificial ) { - gfl_conn[fl].relevant = TRUE; - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; - } - } else { - for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { - fl_ = gfl_conn[fl].lnf_F[i]; - gfl_conn[fl_].relevant = TRUE; - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; - } - } - } - } - } - for ( g = 0; g < gnum_fnumeric_goal; g++ ) { - /* constraint here is gfnumeric_goal_fl[g] >= [>] gfnumeric_goal_c[g] - * where lh side can be lnf expression. - */ - fl = gfnumeric_goal_fl[g]; - if ( fl < 0 ) { - printf("\nnegative constr lh??\n\n"); - exit( 1 ); - } - if ( !gfl_conn[fl].artificial ) { - gfl_conn[fl].relevant = TRUE; - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - if ( influenced_by[fl][i] ) gfl_conn[i].relevant = TRUE; - } - } else { - for ( i = 0; i < gfl_conn[fl].num_lnf; i++ ) { - fl_ = gfl_conn[fl].lnf_F[i]; - gfl_conn[fl_].relevant = TRUE; - for ( j = 0; j < gnum_real_fl_conn; j++ ) { - if ( influenced_by[fl_][j] ) gfl_conn[j].relevant = TRUE; - } - } - } - } - - if ( 0 ) { - for ( i = 0; i < gnum_real_fl_conn; i++ ) { - printf("\n"); print_fl_name( i ); - printf (" --- relevant: %d", gfl_conn[i].relevant); - } - } - -} - - - -Bool i_inc_influences_j( int fi, int fj ) - -{ - - int i, j, fl_; - - for ( i = 0; i < gfl_conn[fj].num_IN; i++ ) { - fl_ = gfl_conn[fj].IN_fl_[i]; - if ( fl_ < 0 ) continue; - if ( fl_ == fi ) return TRUE; - if ( !gfl_conn[fl_].artificial ) continue; - for ( j = 0; j < gfl_conn[fl_].num_lnf; j++ ) { - if ( gfl_conn[fl_].lnf_F[j] == fi ) return TRUE; - } - } - - return FALSE; - -} - diff --git a/gen/ff_planner/expressions.h b/gen/ff_planner/expressions.h deleted file mode 100644 index 3546f2acd..000000000 --- a/gen/ff_planner/expressions.h +++ /dev/null @@ -1,106 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - -/********************************************************************* - * File: expressions.h - * Description: headers for handling numerical expressions - * - * Author: Joerg Hoffmann 2001 - * - *********************************************************************/ - - - - - - - - - - - - - - -#ifndef _EXPRESSIONS_H -#define _EXPRESSIONS_H - - - - -Bool number_comparison_holds( Comparator c, float l, float r ); - - - -Bool transform_to_LNF( void ); -Bool is_linear_task( void ); -Bool is_linear_expression( ExpNode *n ); -void print_lnf_representation( void ); - - - -void normalize_expressions( void ); -Bool translate_divisions( ExpNode **n ); -void push_multiplications_down( ExpNode **n ); -void put_comp_into_normalized_locals( Comparator comp, - ExpNode *lh, - ExpNode *rh ); -void collect_normalized_locals( ExpNode *n, Bool positive ); - - - -void translate_subtractions( void ); -Bool ex_fl_in_nF_of_pre_cond_eff_goal( int *fl ); -void introduce_minus_fluent( int fl ); -void replace_fl_in_nF_with_minus_fl( int fl ); -void set_minus_fl_initial( int fl ); -void introduce_minus_fl_effects( int fl ); - - - -void summarize_effects( void ); -Bool same_condition( ActionEffect *e, ActionEffect *e_ ); -Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); -void merge_effects( ActionEffect *e, ActionEffect *e_ ); -void merge_lnfs( LnfExpNode *l, LnfExpNode *r ); - - - -void encode_lfns_as_artificial_fluents( void ); -Bool ex_non_minimal_lnf_in_pre_cond_goal_eff( void ); -void introduce_artificial_fluent( void ); -void replace_non_minimal_lnf_with_artificial_fl( void ); -Bool is_artificial_fluent( LnfExpNode *n ); - - - -Bool setup_effect_costs( void ); - - - -void check_assigncycles( void ); -Bool i_influences_j( int fi, int fj ); -void determine_fl_relevance( void ); -Bool i_inc_influences_j( int fi, int fj ); - - - -#endif /* _EXPRESSIONS_H */ diff --git a/gen/ff_planner/ff.h b/gen/ff_planner/ff.h deleted file mode 100644 index d244df7ae..000000000 --- a/gen/ff_planner/ff.h +++ /dev/null @@ -1,2044 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - -/********************************************************************* - * File: ff.h - * Description: Types and structures for the Metric-FastForward planner. - * Enhanced version with derived predicates and A*-epsilon - * - * --------- PDDL2.1 level 2 :: VERSION v 1.0 -------------- - * - * Author: Joerg Hoffmann 2012 - * Contact: hoffmann@cs.uni-saarland.de - * - *********************************************************************/ - - - - - - - - -#ifndef __FF_H -#define __FF_H - - - - - - -#include -#include -#include -#include -#include -#include -#include - - - - - - - - - -/* - * ------------------------------------ DEFINES ---------------------------- - */ - - - - - - - - - - - -/*********************** - * MEANINGLESS HELPERS * - ***********************/ - - - - -/* strcmp returns 0 if two strings are equal, which is not nice */ -#define SAME 0 - - - - - - - - - -/**************** - * PARSING ETC. * - ****************/ - - - - - - - - - -/* various defines used in parsing - */ -#define HIDDEN_STR "#" -#define AXIOM_STR "AXIOM" -#define NAME_STR "name\0" -#define VARIABLE_STR "variable\0" -#define STANDARD_TYPE "OBJECT\0" -#define EITHER_STR "EITHER" - - - - - - - - - -/*************************** - * SOME ARBITRARY SETTINGS * - ***************************/ - - - - - - - -/* maximal string length - */ -#define MAX_LENGTH 256 - - -/* marks border between connected items - */ -#define CONNECTOR "~" - - -/* size of goals_at array in 1P extraction - */ -#define RELAXED_STEPS_DEFAULT 25 - - -/* size of hash table for repeated states checking - * during EHC breadth first search - */ -#define EHC_HASH_SIZE 8192 -#define EHC_HASH_BITS 8191 - - -/* size of hash table for repeated states checking - * in plan construction - */ -#define PLAN_HASH_SIZE 1024 -#define PLAN_HASH_BITS 1023 - - -/* size of hash table for repeated states checking - * during BFS search - */ -#define BFS_HASH_SIZE 65536 -#define BFS_HASH_BITS 65535 - - -/* cut random values of facts off modulo this value, - * to make state sums fit into a single integer - */ -#define BIG_INT 1500000 - - -/* max number of different fluents in one list of LNF - */ -#define MAX_LNF_F 25 - - -/* max number of comps in one cond / precond / goal - */ -#define MAX_LNF_COMPS 100 - - -/* max number of lnf effects in one action effect - */ -#define MAX_LNF_EFFS 50 - - - - - - - -/************************ - * INSTANTIATION LIMITS * - ************************/ - - - - - - - - -#define MAX_CONSTANTS 2000 -#define MAX_PREDICATES 50 -#define MAX_FUNCTIONS 50 -#define MAX_TYPES 50 -#define MAX_ARITY 5 -#define MAX_VARS 15 - - -#define MAX_TYPE 2000 - - -#define MAX_OPERATORS 50000 - - -/* in DNF: AND with OR - sons - collect 'hitting set': - * one son of each OR node. - * - * this here is initial max number of such son s that can be collected - * (grows dynamically, if required) - */ -#define MAX_HITTING_SET_DEFAULT 1000 - - -#define MAX_TYPE_INTERSECTIONS 10 - - -#define MAX_RELEVANT_FACTS 150000 -#define MAX_RELEVANT_FLUENTS 1000 - - - - - - -/****************************************** - * DOMAIN STRUCTURE AND SEARCHING LIMITS * - ******************************************/ - - - - - - -#define MAX_STATE 800 - - -#define MAX_PLAN_LENGTH 500 - - - - - - -/**************** - * CODE DEFINES * - ****************/ - - - - - - - - - -/* not a real 'code' define; used in relax and search to encode - * infinite level number / plan length - */ -#ifndef INFINITY -#define INFINITY -1 -#endif - - - - - - - -/* define boolean types if not allready defined - */ -#ifndef Bool -typedef unsigned char Bool; -#ifndef TRUE /* we assume that FALSE is also not defined */ -#define TRUE 1 -#define FALSE 0 -#endif /* TRUE */ -#endif /* Bool */ - - -/* code a param number into a negative number and vice versa - */ -#define ENCODE_VAR( val ) (val * (-1)) - 1 -#define DECODE_VAR( val ) (val + 1) * (-1) - -#define GET_CONSTANT( val, pointer ) ( val >= 0 ) ? val : pointer->inst_table[DECODE_VAR( val )] - - -/* Check allocated memory - */ -#define CHECK_PTR(p) if (NULL == (p)) { \ - fprintf(stdout, "\n\aNO MEMORY in file %s:%d\n\n", __FILE__, __LINE__); \ - exit(1);} - - -/* add elapsed time from main local time vars to specified val - */ -#define TIME( val ) val += ( float ) ( ( end.tms_utime - start.tms_utime + \ - end.tms_stime - start.tms_stime ) / 100.0 ) - - - - - - - - - - - - -/* - * ------------------------------ DATA STRUCTURES ---------------------------- - */ - - - - - - - - - - - -/******************* - * GENERAL HELPERS * - *******************/ - - - - - - - - -/* all command switches - */ -struct _command_line { - - char path[MAX_LENGTH]; - char ops_file_name[MAX_LENGTH]; - char fct_file_name[MAX_LENGTH]; - int display_info; - int debug; - - int search_config; - Bool cost_rplans; - - int w; - - float cost_bound; - -}; - - -typedef char *Token; - - - - - - - - - - - - -/*********** - * PARSING * - ***********/ - - - - - - - - - - -/* A list of strings - */ -typedef struct _TokenList { - - char *item; - struct _TokenList *next; - -} TokenList; - - - -/* list of string lists - */ -typedef struct _FactList { - - TokenList *item; - struct _FactList *next; - -} FactList; - - - -/* structure to store typed-list-of /, - * as they are declared in PDDL files - */ -typedef struct _TypedList { - - char *name; - - /* each item in this list is the name of a type which - * our type is the union of (EITHER - types ...) - * - * usually, this will default to a single-item TokenList. - */ - TokenList *type; - /* after first sweep, this will contain the number in type table - */ - int n; - - struct _TypedList *next; - -} TypedList; - - - -/* only needed to parse in the predicates and their arg - * definitions - */ -typedef struct _TypedListList { - - char *predicate; - - TypedList *args; - - struct _TypedListList *next; - -} TypedListList; - - - -typedef enum _ExpConnective{FHEAD = 1000, - NUMBER, - MINUS, - AD, - SU, - MU, - DI} ExpConnective; - - - -typedef struct _ParseExpNode { - - ExpConnective connective; - - /* NULL anywhere except when node is FHEAD or NUMBER - * (in which case it is fn name ... resp. number (int or float) as string - */ - TokenList *atom; - - /* both NULL in FHEAD; - * in MINUS, left is son and right is NULL - * else (binary operators), left and right operand - */ - struct _ParseExpNode *leftson, *rightson; - -} ParseExpNode; - - - -/* This type indicates whether a node in the pddl tree stands for - * an atomic expression, a junctor or a quantor. - */ -typedef enum _Connective{TRU = 2000, - FAL, - ATOM, - COMP, - NEF, - NOT, - AND, - OR, - ALL, - EX, - WHEN} Connective; - - - -typedef enum _Comparator{IGUAL = 3000, /* technical if conds are array comp exp, resp float */ - LE, - LEQ, - EQ, - GEQ, - GE} Comparator; - - - - -typedef enum _NumericEffectType{ASSIGN = 4000, - SCALE_UP, - SCALE_DOWN, - INCREASE, - DECREASE} NumericEffectType; - - - - -/* - * This is a node in the tree to parse PDDL files - */ -typedef struct _PlNode { - - /* type of the node - */ - Connective connective; - - /* only for parsing: the var args in quantifiers - */ - TypedList *parse_vars; - - /* AND, OR, NOT, WHEN, - * COMP, NEF => NULL - * ALL, EX => the quantified variable with its type - * ATOM => the atom as predicate->param1->param2->... - */ - TokenList *atom; - /* all except COMP, NEF => NULL - * COMP, NEF => left hand, right hand - */ - Comparator comp; - NumericEffectType neft; - ParseExpNode *lh, *rh; - - /* (a) for AND, OR this is the list of sons(a AND b AND c...), - * (b) for the rest this is the son, e.g. a subtree that is negated - * (c) for WHEN, the first son is the condition and the next son - * is the effect - */ - struct _PlNode *sons; - - /* if you have a list of sons, they are connected by next - */ - struct _PlNode *next; - -} PlNode; - - -/* - * This resembles an uninstantiated PDDL operator - */ -typedef struct _PlOperator { - - char *name; - Bool axiom; - - /* only important for PDDL where :VARS may be added to the param list - * which must be hidden when writing the plan to an output file - */ - int number_of_real_params; - - /* the params, as they are declared in domain file - */ - TypedList *parse_params; - - /* params is a list of variable/type pairs, such that: - * factlist->item = [variable] -> [type] - */ - FactList *params; - PlNode *preconds; - PlNode *effects; - - struct _PlOperator *next; - -} PlOperator; - - - - - - - - - - - - - - - -/***************** - * INSTANTIATION * - *****************/ - - - - - - - - - -/* helpers - */ - -typedef int TypeArray[MAX_TYPE_INTERSECTIONS]; - -typedef int *int_pointer; - - - - -/* first step structures: parsing & preprocessing - */ - -typedef struct _Fact { - - int predicate, args[MAX_ARITY]; - -} Fact; - - - -typedef struct _Fluent { - - int function, args[MAX_ARITY]; - -} Fluent; - - - -typedef struct _FluentValue { - - Fluent fluent; - float value; - -} FluentValue; - - - -typedef struct _Facts { - - Fact *fact; - - struct _Facts *next; - -} Facts; - - - -typedef struct _FluentValues { - - Fluent fluent; - float value; - - struct _FluentValues *next; - -} FluentValues; - - - -typedef struct _ExpNode { - - ExpConnective connective; - - /* in FHEAD nodes, pre-processing - */ - Fluent *fluent; - /* in FHEAD nodes after pre-processes have finished. - * (internal number of relevant fluent, or -1 if not - * relevant) - */ - int fl; - /* helper for LNF: if that fl is multiplied, this is the - * respective constant after pre-normalization. - */ - float c; - - /* in NUMBER nodes - */ - float value; - - /* in MINUS nodes - */ - struct _ExpNode *son; - - /* in all others - */ - struct _ExpNode *leftson, *rightson; - -} ExpNode, *ExpNode_pointer; - - - -typedef struct _WffNode { - - Connective connective; - - /* in ALL/EX s - */ - int var, var_type; - char *var_name; - - /* in AND/OR s - */ - struct _WffNode *sons; - /* sons are doubly connected linear list - */ - struct _WffNode *next; - struct _WffNode *prev; - - /* in ATOMs - */ - Fact *fact; - /* after translation: mark NOT-p s for efficiency - */ - int NOT_p; - - /* in ALL/EX/NOT - */ - struct _WffNode *son; - - /* in COMP - */ - Comparator comp; - ExpNode *lh, *rh; - - /* for expansion speedup - */ - Bool visited; - - /* no WHEN s here... use Pl Connectives anyway for simplicity - */ - -} WffNode, *WffNode_pointer; - - - -typedef struct _Literal { - - Bool negated; - - Fact fact; - - struct _Literal *next; - struct _Literal *prev; - -} Literal; - - - -typedef struct _NumericEffect { - - Fluent fluent; - NumericEffectType neft; - - ExpNode *rh; - - struct _NumericEffect *next; - struct _NumericEffect *prev; - -} NumericEffect; - - - -typedef struct _Effect { - - int num_vars, var_types[MAX_VARS]; - char *var_names[MAX_VARS]; - - WffNode *conditions; - - Literal *effects; - NumericEffect *numeric_effects; - - struct _Effect *next; - struct _Effect *prev; - -} Effect; - - - -typedef struct _Operator { - - char *name, *var_names[MAX_VARS]; - int number_of_real_params; - Bool axiom; - - int num_vars, var_types[MAX_VARS]; - Bool removed[MAX_VARS]; - - WffNode *preconds; - - Effect *effects; - - Bool hard; - -} Operator, *Operator_pointer; - - - - - - -/* second step: structures that keep already normalized - * operators - */ - - - - -typedef struct _NormEffect { - - int num_vars, var_types[MAX_VARS]; - int inst_table[MAX_VARS]; - - Fact *conditions; - int num_conditions; - - Fact *adds; - int num_adds; - Fact *dels; - int num_dels; - - /* numerical parts: not yet normalized any further; seems that - * normalizing requires certain additional structures + - * transformation, and that these will better be done when - * the representation is fully instantiated already. - */ - Comparator *numeric_conditions_comp; - ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; - int num_numeric_conditions; - - NumericEffectType *numeric_effects_neft; - Fluent *numeric_effects_fluent; - ExpNode_pointer *numeric_effects_rh; - int num_numeric_effects; - - struct _NormEffect *prev; - struct _NormEffect *next; - -} NormEffect; - - - -typedef struct _NormOperator { - - Operator *operator; - - int num_vars, var_types[MAX_VARS]; - int inst_table[MAX_VARS]; - int removed_vars[MAX_VARS], num_removed_vars, type_removed_vars[MAX_VARS]; - - Fact *preconds; - int num_preconds; - /* numeric precondition still full scale represented, see above - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - NormEffect *effects; - - Bool out; - -} NormOperator, *NormOperator_pointer; - - - -/* minimal info for a fully instantiated easy operator; - * yields one action when expanded - */ -typedef struct _EasyTemplate { - - NormOperator *op; - int inst_table[MAX_VARS]; - - struct _EasyTemplate *prev; - struct _EasyTemplate *next; - -} EasyTemplate; - - - - - - -/* structures for hard ops - */ - - - - - -/* intermediate step: structure for keeping hard ops - * with normalized precondition, but arbitrary - * effect conditions - */ -typedef struct _MixedOperator { - - Operator *operator; - - int inst_table[MAX_VARS]; - - Fact *preconds; - int num_preconds; - /* numeric part, pre-normalized - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - Effect *effects; - - struct _MixedOperator *next; - -} MixedOperator; - - - -/* last hard step: everything is action - like, except that - * facts are not yet integer coded - */ - - - -typedef struct _PseudoActionEffect { - - Fact *conditions; - int num_conditions; - - Fact *adds; - int num_adds; - Fact *dels; - int num_dels; - - - /* and the numeric parts again... - */ - Comparator *numeric_conditions_comp; - ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; - int num_numeric_conditions; - - NumericEffectType *numeric_effects_neft; - Fluent *numeric_effects_fluent; - ExpNode_pointer *numeric_effects_rh; - int num_numeric_effects; - - struct _PseudoActionEffect *next; - -} PseudoActionEffect; - - - -typedef struct _PseudoAction { - - Operator *operator; - - int inst_table[MAX_VARS]; - - Fact *preconds; - int num_preconds; - /* numeric part, pre-normalized - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - PseudoActionEffect *effects; - int num_effects; - -} PseudoAction, *PseudoAction_pointer; - - - - -/* final domain representation structure - */ - - - -typedef struct _LnfExpNode { - - int pF[MAX_LNF_F]; - float pC[MAX_LNF_F]; - int num_pF; - - int nF[MAX_LNF_F]; - float nC[MAX_LNF_F]; - int num_nF; - - float c; - -} LnfExpNode, *LnfExpNode_pointer; - - - -typedef struct _ActionEffect { - - int *conditions; - int num_conditions; - - int *adds; - int num_adds; - int *dels; - int num_dels; - - /* and the numeric parts again; fluents all as fl ints; - * - * normalization for cond as below for pre; - * norm. for effects by restriction of types (?), - * right hand side float (?) - */ - Comparator *numeric_conditions_comp; - ExpNode_pointer *numeric_conditions_lh, *numeric_conditions_rh; - int num_numeric_conditions; - - NumericEffectType *numeric_effects_neft; - int *numeric_effects_fl; - ExpNode_pointer *numeric_effects_rh; - int num_numeric_effects; - - /* LNF - */ - Comparator *lnf_conditions_comp; - LnfExpNode_pointer *lnf_conditions_lh; - float *lnf_conditions_rh; - int num_lnf_conditions; - - NumericEffectType *lnf_effects_neft; - int *lnf_effects_fl; - LnfExpNode_pointer *lnf_effects_rh; - int num_lnf_effects; - - /* this is true iff the numerical part of the effects affects or accesses - * an undefined fluent (i.e. in numeric_effects_fl or numeric_effects_rh ) - * --- then, if the effect appears, the action is - * illegal. - */ - Bool illegal; - - /* helper - */ - Bool removed; - - float cost; - -} ActionEffect; - - - -typedef struct _Action { - - NormOperator *norm_operator; - PseudoAction *pseudo_action; - Bool axiom; - - char *name; - int num_name_vars; - int name_inst_table[MAX_VARS]; - - int inst_table[MAX_VARS]; - - int *preconds; - int num_preconds; - /* numeric part, in general format, with fluents encoded as fl ints - * - * also, will (?) be transformed to lh fl, rh float; then, expnodes as - * fast accessible as specialised structures. - */ - Comparator *numeric_preconds_comp; - ExpNode_pointer *numeric_preconds_lh, *numeric_preconds_rh; - int num_numeric_preconds; - - /* LNF - */ - Comparator *lnf_preconds_comp; - LnfExpNode_pointer *lnf_preconds_lh; - float *lnf_preconds_rh; - int num_lnf_preconds; - - ActionEffect *effects; - int num_effects; - - struct _Action *next; - -} Action; - - - - - - - - - - - -/***************************************************** - * BASIC OP AND FT STRUCTURES FOR CONNECTIVITY GRAPH * - *****************************************************/ - - - - - - - - - - - -typedef struct _OpConn { - - /* to get name - */ - Action *action; - Bool axiom; - - /* effects - */ - int *E; - int num_E; - - /* member for applicable actions extraction - */ - Bool is_in_A; - Bool is_in_A_axioms; - - /* members for 1Ph - H(S) extraction - */ - int is_used; - Bool is_in_H; - - /* this is a bit imprecise since actually, in this - * framework here, the cost of the action may depend on - * which conditional effects actually apply. - * ... anyway, this makes things much easier for the case - * where there aren't any effect conditions. all cost handling - * is now based on this..!! - */ - float cost; - -} OpConn; - - - -typedef struct _EfConn { - - int op; - - /* true if access to always undefined fluent, or - * conflicting assignments. - * - * if that is the case then nothing except condition is set: - * the effect is completely ignored except that - * it renders the op unapplicable when its condition - * is true. - */ - Bool illegal; - - /* this one means we found in conn that it is useless (empty) - */ - Bool removed; - - /* this is the cost; can be non-zero if a metric was specified - * and established - */ - float cost; - - int *PC; - int num_PC; - /* numeric part - */ - Comparator *f_PC_comp; /* either GEQ or GE */ - int *f_PC_fl; - float *f_PC_c; - int num_f_PC; - /* array indexed by fl number, to fast know whether - * new fluent value is high enough - */ - Comparator *f_PC_direct_comp; - float *f_PC_direct_c; - - /* logic effects - */ - int *A; - int num_A; - int *D; - int num_D; - /* and the numeric ones; fl_ is the encoding of the LNF - * on the right hand side, without constant part - * (special treatment for that as it's supposed - * to be the most common thing!!) - */ - int *IN_fl; - int *IN_fl_; - float *IN_c; - int num_IN; - - int *AS_fl; - int *AS_fl_; - float *AS_c; - int num_AS; - - /* implied effects - */ - int *I; - int num_I; - - /* members for relaxed fixpoint computation - */ - int level;/* first "cost level" where ef appears */ - float RPGcost;/* max_{p prec} cost(p)+cost(op(ef)) */ - - Bool in_E; - int num_active_PCs; - Bool ch; - - /* RPG - */ - int num_active_f_PCs; - - /* 1P; an effect can be selected several times - * for increasing a fluent. - */ - int in_plan; - -} EfConn; - - - -typedef struct _FtConn { - - /* effects it is union conds, pres element of - */ - int *PC; - int num_PC; - - /* efs that add or del it - */ - int *A; - int num_A; - - int *D; - int num_D; - - /* members for orderings preprocessing - */ - int *False; - int num_False; - - /* members for relaxed fixpoint computation - */ - int level;/* first "cost level" where ft appears */ - float RPGcost;/* min_{e adder} cost(e) */ - Bool in_F; - - /* members for 1Ph extraction - */ - int is_goal; - int is_true; - Bool ch; - - /* search - */ - int rand;/* for hashing */ - - /* is this the effect of an axiom? - * needed to quickly filter out derived facts, in state - * transitions! - */ - Bool axiom_added; - -} FtConn; - - - -typedef struct _FlConn { - - /* effects it is union conds, pres required - */ - int *PC; - int num_PC; - - /* efs that inc, ass it and by which encoded fluents and constants - */ - int *IN; - int *IN_fl_; - float *IN_c; - int num_IN; - - int *AS; - int *AS_fl_; - float *AS_c;/* see above */ - int num_AS; - - /* is it an artificial fluent? - */ - Bool artificial; - /* if so, then this here is the linear equation - * it stands for - */ - int *lnf_F; - float *lnf_C; - int num_lnf; - - - /* the termination criterion for RPG building is based on mneed, see - * JAIR article for definition; - * - * as the name suggests, we use the bool to indicate that this one is not - * needed at all - */ - Bool mneed_is_minusinfty; - float mneed; - /* see JAIR; shortcut for never needed at all. - */ - Bool relevant; - - /* the following are members handled within heuristic algorithms. - */ - - /* this are arrays saying what the max value at - * the levels in the RPG is, resp. whether the value - * can be defined there at all, resp. what the increasers - * at that level have added. - */ - Bool *def; - float *level; - - /* for handling assigners in RPG: is an assigner in there yet, - * and if so what is their max value? - */ - Bool curr_assigned; - float curr_max_assigned; - - int rand;/* for hashing */ - -} FlConn; - - - - - - - - - - - - -/**************************** - * STRUCTURES FOR SEARCHING * - ****************************/ - - - - - - - - - -typedef struct _State { - - int *F; - int num_F; - - Bool *f_D; - float *f_V; - -} State, *State_pointer; - - - -typedef struct _EhcNode { - - State S; - - int op; - int depth; - - struct _EhcNode *father; - struct _EhcNode *next; - -} EhcNode; - - - -typedef struct _EhcHashEntry { - - int sum; - - EhcNode *ehc_node; - - struct _EhcHashEntry *next; - -} EhcHashEntry, *EhcHashEntry_pointer; - - - -typedef struct _PlanHashEntry { - - int sum; - State S; - - /* step is number of op that is EXECUTED in S; - * -1 means that this state is no longer contained in plan - */ - int step; - struct _PlanHashEntry *next_step; - - struct _PlanHashEntry *next; - -} PlanHashEntry, *PlanHashEntry_pointer; - - - -typedef struct _BfsNode { - - State S; - int op; - - /* number of steps from ini state to here - */ - int ini_distance; - - /* number of steps in relaxed plan for this state - */ - int goal_distance; - - /* g-value and h-value, ie summed-up cost to here, - * summed-up cost in rplan for here. - * used in all optimization configs - */ - float g; - float h; - - /* f-value. in weighted A*, f=g+w*h; in A*epsilon, f=g+h - */ - float f; - - /* The applicable actions -- may be only the helpful ones, - * in case helpful actions are used! - */ - int *A; - int num_A; - - struct _BfsNode *father; - - struct _BfsNode *next; - struct _BfsNode *prev; - -} BfsNode; - - - -typedef struct _BfsHashEntry { - - int sum; - - BfsNode *bfs_node; - - struct _BfsHashEntry *next; - -} BfsHashEntry, *BfsHashEntry_pointer; - - - - - - - - - - - - - -/* - * -------------------------------- MAIN FN HEADERS ---------------------------- - */ - - - - - - - - - - - - - - - - - -void output_planner_info( void ); -void ff_usage( void ); -Bool process_command_line( int argc, char *argv[] ); - - - - - - - - - -/* - * ----------------------------- GLOBAL VARIABLES ---------------------------- - */ - - - - - - - - - - - - -/******************* - * GENERAL HELPERS * - *******************/ - - - - - - - - - - -/* used to time the different stages of the planner - */ -extern float gtempl_time, greach_time, grelev_time, gconn_time; -extern float gLNF_time, gsearch_time; - -/* the command line inputs - */ -extern struct _command_line gcmd_line; - -/* number of states that got heuristically evaluated - */ -extern int gevaluated_states; - -/* maximal depth of breadth first search - */ -extern int gmax_search_depth; - - - - - - - - - -/*********** - * PARSING * - ***********/ - - - - - - - - - - - -/* used for pddl parsing, flex only allows global variables - */ -extern int gbracket_count; -extern char *gproblem_name; - -/* The current input line number - */ -extern int lineno; - -/* The current input filename - */ -extern char *gact_filename; - -/* The pddl domain name - */ -extern char *gdomain_name; - -/* loaded, uninstantiated operators - */ -extern PlOperator *gloaded_ops; - -/* stores initials as fact_list - */ -extern PlNode *gorig_initial_facts; - -/* not yet preprocessed goal facts - */ -extern PlNode *gorig_goal_facts; - -/* the types, as defined in the domain file - */ -extern TypedList *gparse_types; - -/* the constants, as defined in domain file - */ -extern TypedList *gparse_constants; - -/* the predicates and their arg types, as defined in the domain file - */ -extern TypedListList *gparse_predicates; - -/* the functions and their arg types, as defined in the domain file - */ -extern TypedListList *gparse_functions; - -/* the objects, declared in the problem file - */ -extern TypedList *gparse_objects; - -/* the metric - */ -extern Token gparse_optimization; -extern ParseExpNode *gparse_metric; - - -/* connection to instantiation ( except ops, goal, initial ) - */ - -/* all typed objects - */ -extern FactList *gorig_constant_list; - -/* the predicates and their types - */ -extern FactList *gpredicates_and_types; - -/* the functions and their types - */ -extern FactList *gfunctions_and_types; - - - - - - - - - - - - - - -/***************** - * INSTANTIATING * - *****************/ - - - - - - - - - - -/* global arrays of constant names, - * type names (with their constants), - * predicate names, - * predicate aritys, - * defined types of predicate args - */ -extern Token gconstants[MAX_CONSTANTS]; -extern int gnum_constants; -extern Token gtype_names[MAX_TYPES]; -extern int gtype_consts[MAX_TYPES][MAX_TYPE]; -extern Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; -extern int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ -extern int gtype_size[MAX_TYPES]; -extern int gnum_types; -extern Token gpredicates[MAX_PREDICATES]; -extern int garity[MAX_PREDICATES]; -extern Bool gaxiom_added[MAX_PREDICATES]; -extern int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; -extern int gnum_predicates; -extern Token gfunctions[MAX_FUNCTIONS]; -extern int gf_arity[MAX_FUNCTIONS]; -extern int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; -extern int gnum_functions; - - - - -/* the domain in first step integer representation - */ -extern Operator_pointer goperators[MAX_OPERATORS]; -extern int gnum_operators; -extern Fact *gfull_initial; -extern int gnum_full_initial; -extern FluentValue *gfull_fluents_initial; -extern int gnum_full_fluents_initial; -extern WffNode *ggoal; - -extern ExpNode *gmetric; - - - -/* stores inertia - information: is any occurence of the predicate - * added / deleted in the uninstantiated ops ? - */ -extern Bool gis_added[MAX_PREDICATES]; -extern Bool gis_deleted[MAX_PREDICATES]; - -/* for functions we *might* want to say, symmetrically, whether it is - * increased resp. decreased at all. - * - * that is, however, somewhat involved because the right hand - * sides can be arbirtray expressions, so we have no guarantee - * that increasing really does adds to a functions value... - * - * thus (for the time being), we settle for "is the function changed at all?" - */ -extern Bool gis_changed[MAX_FUNCTIONS]; - - - -/* splitted initial state: - * initial non static facts, - * initial static facts, divided into predicates - * (will be two dimensional array, allocated directly before need) - */ -extern Facts *ginitial; -extern int gnum_initial; -extern Fact **ginitial_predicate; -extern int *gnum_initial_predicate; - -/* same thing for functions - */ -extern FluentValues *gf_initial; -extern int gnum_f_initial; -extern FluentValue **ginitial_function; -extern int *gnum_initial_function; - - - -/* the type numbers corresponding to any unary inertia - */ -extern int gtype_to_predicate[MAX_PREDICATES]; -extern int gpredicate_to_type[MAX_TYPES]; - -/* (ordered) numbers of types that new type is intersection of - */ -extern TypeArray gintersected_types[MAX_TYPES]; -extern int gnum_intersected_types[MAX_TYPES]; - - - -/* splitted domain: hard n easy ops - */ -extern Operator_pointer *ghard_operators; -extern int gnum_hard_operators; -extern NormOperator_pointer *geasy_operators; -extern int gnum_easy_operators; - - - -/* so called Templates for easy ops: possible inertia constrained - * instantiation constants - */ -extern EasyTemplate *geasy_templates; -extern int gnum_easy_templates; - - - -/* first step for hard ops: create mixed operators, with conjunctive - * precondition and arbitrary effects - */ -extern MixedOperator *ghard_mixed_operators; -extern int gnum_hard_mixed_operators; - - - -/* hard ''templates'' : pseudo actions - */ -extern PseudoAction_pointer *ghard_templates; -extern int gnum_hard_templates; - - - -/* store the final "relevant facts" - */ -extern Fact grelevant_facts[MAX_RELEVANT_FACTS]; -extern int gnum_relevant_facts; -extern int gnum_pp_facts; -/* store the "relevant fluents" - */ -extern Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; -extern int gnum_relevant_fluents; -extern Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; -/* this is NULL for normal, and the LNF for - * artificial fluents. - */ -extern LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; - - - -/* the final actions and problem representation - */ -extern Action *gactions; -extern int gnum_actions; -extern State ginitial_state; -extern int *glogic_goal; -extern int gnum_logic_goal; -extern Comparator *gnumeric_goal_comp; -extern ExpNode_pointer *gnumeric_goal_lh, *gnumeric_goal_rh; -extern int gnum_numeric_goal; - - - -/* to avoid memory leaks; too complicated to identify - * the exact state of the action to throw away (during construction), - * memory gain not worth the implementation effort. - */ -extern Action *gtrash_actions; - - - -/* additional lnf step between finalized inst and - * conn graph - */ -extern Comparator *glnf_goal_comp; -extern LnfExpNode_pointer *glnf_goal_lh; -extern float *glnf_goal_rh; -extern int gnum_lnf_goal; - -extern LnfExpNode glnf_metric; -extern Bool goptimization_established; - - - -/********************** - * CONNECTIVITY GRAPH * - **********************/ - - - - - -/* one ops (actions) array ... - */ -extern OpConn *gop_conn; -extern int gnum_op_conn; - - - -/* one effects array ... - */ -extern EfConn *gef_conn; -extern int gnum_ef_conn; - - - -/* one facts array. - */ -extern FtConn *gft_conn; -extern int gnum_ft_conn; - - - -/* and: one fluents array. - */ -extern FlConn *gfl_conn; -extern int gnum_fl_conn; -extern int gnum_real_fl_conn;/* number of non-artificial ones */ - - - -/* final goal is also transformed one more step. - */ -extern int *gflogic_goal; -extern int gnum_flogic_goal; -extern Comparator *gfnumeric_goal_comp; -extern int *gfnumeric_goal_fl; -extern float *gfnumeric_goal_c; -extern int gnum_fnumeric_goal; - -/* direct access (by relevant fluents) - */ -extern Comparator *gfnumeric_goal_direct_comp; -extern float *gfnumeric_goal_direct_c; - - - - - - - - - - - - - -/******************* - * SEARCHING NEEDS * - *******************/ - - - - - - - - - - - - -/* applicable actions - */ -extern int *gA;/* non-axioms */ -extern int gnum_A; -extern int *gA_axioms; /* axioms */ -extern int gnum_A_axioms; - - - -/* communication from extract 1.P. to search engine: - * 1P action choice - */ -extern int *gH; -extern int gnum_H; -/* added cost of relaxed plan - */ -extern float gh_cost; -/* hmax value - */ -extern float ghmax; - - - -/* to store plan - */ -extern int gplan_ops[MAX_PLAN_LENGTH]; -extern int gnum_plan_ops; - - - -/* stores the states that the current plan goes through - */ -extern State gplan_states[MAX_PLAN_LENGTH + 1]; - - - -/* dirty: multiplic. of total-time in final metric LNF - */ -extern float gtt; - - - - - - -/* the mneed structures - * - * assign propagation pairs i, j, and transitive such pairs. - */ -extern Bool **gassign_influence; -extern Bool **gTassign_influence; - - - -/* the real var input to the mneed computation. - */ -extern Bool *gmneed_start_D; -extern float *gmneed_start_V; - - - -/* does this contain conditional effects? - * (if it does then the state hashing has to be made more - * cautiously) - */ -extern Bool gconditional_effects; - - -/* easier to question: are we optimizing or no? - */ -extern Bool gcost_minimizing; - - -/* stores current A* weight: this is initially given by user, - * but changes during anytime search. - */ -extern float gw; -/* this is the minimum weight, ie we'll stop once the weight update - * does/would yield a value <= this. - * if no such minim weight is given, this will be -1 - */ -extern float gmin_w; - - -/* this one says whether or not we are actually using - * cost-minimizing rplans. - * this will be the case by default if we're running cost- - * minimizing searches. it can be switched off by a flag; - * it is automatically switched off in case there are - * numeric preconditions/goals: for this case, - * cost-minimizing rplans are not implemented (a numeric prec - * may cause an action to come in "later" on in the RPG although - * its logical pres are easy. in that case, any new effects will - * have a smaller RPGcost value than facts we already have waiting. - * in other words, the "Dijsktra" nature breaks. - * - * ... I suppose there may be a generic solution to this that - * can handle numeric precs/goals. Doesn't seem important enough - * to bother. - */ -extern Bool gcost_rplans; - - -#endif diff --git a/gen/ff_planner/inst_easy.c b/gen/ff_planner/inst_easy.c deleted file mode 100644 index db6c1681b..000000000 --- a/gen/ff_planner/inst_easy.c +++ /dev/null @@ -1,1220 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - -/********************************************************************* - * File: inst_easy.c - * Description: functions for multiplying easy operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_easy.h" - - - - - - - - -void build_easy_action_templates( void ) - -{ - - int i, j; - NormOperator *o; - EasyTemplate *t; - - cleanup_easy_domain(); - - if ( gcmd_line.display_info == 110 ) { - printf("\n\ncleaned up easy operators are:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - fflush( stdout ); - } - - encode_easy_unaries_as_types(); - - if ( gcmd_line.display_info == 111 ) { - printf("\n\nunaries encoded easy operators are:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - fflush( stdout ); - } - - multiply_easy_effect_parameters(); - - if ( gcmd_line.display_info == 112 ) { - printf("\n\neffects multiplied easy operators are:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - fflush( stdout ); - } - - multiply_easy_op_parameters(); - - if ( gcmd_line.display_info == 113 ) { - printf("\n\ninertia free easy operators are:"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - printf("\n\n"); - fflush( stdout ); - } - - if ( gcmd_line.display_info == 114 ) { - printf("\n\neasy operator templates are:\n"); - - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - printf("\n\n-----------operator %s:-----------", o->operator->name); - for ( t = geasy_templates; t; t = t->next ) { - if ( t->op != o ) { - continue; - } - printf("\ninst: "); - for ( j = 0; j < o->num_vars; j++ ) { - if ( t->inst_table[j] < 0 ) { - printf("\nuninstantiated param in template! debug me, please\n\n"); - exit( 1 ); - } - printf("x%d = %s", j, gconstants[t->inst_table[j]]); - if ( j < o->num_vars - 1 ) { - printf(", "); - } - } - } - } - fflush( stdout ); - } - -} - - - - - - - - - - - -/********************************* - * EASY DOMAIN CLEANUP FUNCTIONs * - *********************************/ - - - - - - - - - - - -void cleanup_easy_domain( void ) - -{ - - int i, i1, i2, i3, i4, a; - NormOperator *o; - NormEffect *e; - - /* most likely ( for sure ? ) we do not need this function call here, - * as empty types are recognised in translation already. - * - * however, who knows .. ? doesn't need any real computation time anyway. - * - * function DOES make sense after unaries encoding, as artificial types - * might well be empty. - */ - handle_empty_easy_parameters(); - - /* remove identical preconds and effects; - * VERY unlikely that such will get down to here, after all - * the formula preprocessing, but possible (?) in principle. - * takes no computation time. - * - * also, remove effect conditions that are contained in the - * preconditions. - */ - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - i1 = 0; - while ( i1 < o->num_preconds-1 ) { - i2 = i1+1; - while ( i2 < o->num_preconds ) { - if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) { - for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) { - o->preconds[i3].predicate = o->preconds[i3+1].predicate; - for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) { - o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4]; - } - } - o->num_preconds--; - } else { - i2++; - } - } - i1++; - } - - for ( e = o->effects; e; e = e->next ) { - i1 = 0; - while ( i1 < e->num_conditions-1 ) { - i2 = i1+1; - while ( i2 < e->num_conditions ) { - if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) { - for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) { - e->conditions[i3].predicate = e->conditions[i3+1].predicate; - /* here, we can still have equalities. nowhere else. - */ - a = ( e->conditions[i3].predicate < 0 ) ? - 2 : garity[e->conditions[i3].predicate]; - for ( i4 = 0; i4 < a; i4++ ) { - e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4]; - } - } - e->num_conditions--; - } else { - i2++; - } - } - i1++; - } - - i1 = 0; - while ( i1 < e->num_conditions ) { - for ( i2 = 0; i2 < o->num_preconds; i2++ ) { - if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) { - break; - } - } - if ( i2 == o->num_preconds ) { - i1++; - continue; - } - for ( i2 = i1; i2 < e->num_conditions-1; i2++ ) { - e->conditions[i2].predicate = e->conditions[i2+1].predicate; - for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) { - e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3]; - } - } - e->num_conditions--; - } - - i1 = 0; - while ( i1 < e->num_adds-1 ) { - i2 = i1+1; - while ( i2 < e->num_adds ) { - if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) { - for ( i3 = i2; i3 < e->num_adds-1; i3++ ) { - e->adds[i3].predicate = e->adds[i3+1].predicate; - for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) { - e->adds[i3].args[i4] = e->adds[i3+1].args[i4]; - } - } - e->num_adds--; - } else { - i2++; - } - } - i1++; - } - - i1 = 0; - while ( i1 < e->num_dels-1 ) { - i2 = i1+1; - while ( i2 < e->num_dels ) { - if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) { - for ( i3 = i2; i3 < e->num_dels-1; i3++ ) { - e->dels[i3].predicate = e->dels[i3+1].predicate; - for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) { - e->dels[i3].args[i4] = e->dels[i3+1].args[i4]; - } - } - e->num_dels--; - } else { - i2++; - } - } - i1++; - } - } - } - -} - - - -Bool identical_fact( Fact *f1, Fact *f2 ) - -{ - - int i, a; - - if ( f1->predicate != f2->predicate ) { - return FALSE; - } - - a = ( f1->predicate < 0 ) ? 2 : garity[f1->predicate]; - - for ( i = 0; i < a; i++ ) { - if ( f1->args[i] != f2->args[i] ) { - return FALSE; - } - } - - return TRUE; - -} - - - -/* this one needs ONLY be used after unaries encoding, as all empty types - * are already recognised during translation, except the artificial ones, - * of course. - */ -void handle_empty_easy_parameters( void ) - -{ - - int i, j, k; - NormOperator *o; - NormEffect *e, *tmp; - - i = 0; - while ( i < gnum_easy_operators ) { - o = geasy_operators[i]; - - for ( j = 0; j < o->num_vars; j++ ) { - if ( gtype_size[o->var_types[j]] == 0 ) { - break; - } - } - if ( j < o->num_vars ) { - free_NormOperator( o ); - for ( k = i; k < gnum_easy_operators - 1; k++ ) { - geasy_operators[k] = geasy_operators[k+1]; - } - gnum_easy_operators--; - } else { - i++; - } - } - - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - e = o->effects; - while ( e ) { - for ( j = 0; j < e->num_vars; j++ ) { - if ( gtype_size[e->var_types[j]] == 0 ) { - break; - } - } - if ( j < e->num_vars ) { - if ( e->prev ) { - e->prev->next = e->next; - } else { - o->effects = e->next; - } - if ( e->next ) { - e->next->prev = e->prev; - } - tmp = e->next; - free_single_NormEffect( e ); - e = tmp; - } else { - e = e->next; - } - } - } - -} - - - - - - - - - - -/**************************** - * UNARY INERTIA INTO TYPES * - ****************************/ - - - - - - - - - - - - -void encode_easy_unaries_as_types( void ) - -{ - - NormOperator *o; - int i1, i, j, k, l, new_T, p, a; - TypeArray T; - int num_T; - NormEffect *e; - int intersected_type, var; - - for ( i1 = 0; i1 < gnum_easy_operators; i1++ ) { - o = geasy_operators[i1]; - - for ( i = 0; i < o->num_vars; i++ ) { - - T[0] = o->var_types[i]; - num_T = 1; - - j = 0; - while ( j < o->num_preconds ) { - p = o->preconds[j].predicate; - if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && - ( o->preconds[j].args[0] == ENCODE_VAR( i ) ) ) { - if ( num_T == MAX_TYPE_INTERSECTIONS ) { - printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", - MAX_TYPE_INTERSECTIONS); - exit( 1 ); - } - /* insert new type number into ordered array T; - * ---- all type numbers in T are different: - * new nr. is of inferred type - can't be type declared for param - * precondition facts occur at most once - doubles are removed - * during cleanup - */ - for ( k = 0; k < num_T; k++ ) { - if ( new_T < T[k] ) { - break; - } - } - for ( l = num_T; l > k; l-- ) { - T[l] = T[l-1]; - } - T[k] = new_T; - num_T++; - /* now remove superfluous precondition - */ - for ( k = j; k < o->num_preconds-1; k++ ) { - o->preconds[k].predicate = o->preconds[k+1].predicate; - for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { - o->preconds[k].args[l] = o->preconds[k+1].args[l]; - } - } - o->num_preconds--; - } else { - j++; - } - } - - /* if we did not hit any unary inertia concerning this parameter - * in the preconds, skip parameter and go to next one - */ - if ( num_T == 1 ) { - continue; - } - - /* now we have the ordered array of types to intersect for param i - * of op o in array T of size num_T; - * if there already is this intersected type, set type of this - * param to its number, otherwise create the new intersected type. - */ - if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { - /* type already there - */ - o->var_types[i] = intersected_type; - continue; - } - - /* create new type - */ - o->var_types[i] = create_intersected_type( T, num_T ); - } - - for ( e = o->effects; e; e = e->next ) { - for ( i = 0; i < e->num_vars; i++ ) { - T[0] = e->var_types[i]; - var = o->num_vars + i; - num_T = 1; - j = 0; - while ( j < e->num_conditions ) { - p = e->conditions[j].predicate; - if ( p < 0 ) { - j++; - continue; - } - if ( ( (new_T = gtype_to_predicate[p]) != -1 ) && - ( e->conditions[j].args[0] == ENCODE_VAR( var ) ) ) { - if ( num_T == MAX_TYPE_INTERSECTIONS ) { - printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n", - MAX_TYPE_INTERSECTIONS); - exit( 1 ); - } - for ( k = 0; k < num_T; k++ ) { - if ( new_T < T[k] ) { - break; - } - } - for ( l = num_T; l > k; l-- ) { - T[l] = T[l-1]; - } - T[k] = new_T; - num_T++; - for ( k = j; k < e->num_conditions-1; k++ ) { - e->conditions[k].predicate = e->conditions[k+1].predicate; - a = ( e->conditions[k].predicate < 0 ) ? - 2 : garity[e->conditions[k].predicate]; - for ( l = 0; l < a; l++ ) { - e->conditions[k].args[l] = e->conditions[k+1].args[l]; - } - } - e->num_conditions--; - } else { - j++; - } - } - if ( num_T == 1 ) { - continue; - } - if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) { - e->var_types[i] = intersected_type; - continue; - } - e->var_types[i] = create_intersected_type( T, num_T ); - } - } - } - - handle_empty_easy_parameters(); - -} - - - -int create_intersected_type( TypeArray T, int num_T ) - -{ - - int i, j, k, intersected_type; - - if ( gnum_types == MAX_TYPES ) { - printf("\ntoo many (inferred and intersected) types! increase MAX_TYPES (currently %d)\n\n", - MAX_TYPES); - exit( 1 ); - } - gtype_names[gnum_types] = NULL; - gtype_size[gnum_types] = 0; - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - gis_member[i][gnum_types] = FALSE; - } - for ( i = 0; i < num_T; i++ ) { - gintersected_types[gnum_types][i] = T[i]; - } - gnum_intersected_types[gnum_types] = num_T; - intersected_type = gnum_types; - gnum_types++; - - for ( j = 0; j < gtype_size[T[0]]; j++ ) { - for ( k = 1; k < num_T; k++ ) { - if ( !gis_member[gtype_consts[T[0]][j]][T[k]] ) { - break; - } - } - if ( k < num_T ) { - continue; - } - /* add constant to new type - */ - if ( gtype_size[intersected_type] == MAX_TYPE ) { - printf("\ntoo many consts in intersected type! increase MAX_TYPE (currently %d)\n\n", - MAX_TYPE); - exit( 1 ); - } - gtype_consts[intersected_type][gtype_size[intersected_type]++] = gtype_consts[T[0]][j]; - gis_member[gtype_consts[T[0]][j]][intersected_type] = TRUE; - } - - /* now verify if the intersected type equals one of the types that we intersected. - * this is the case, iff one of the types in T has the same size as intersected_type - */ - for ( j = 0; j < num_T; j++ ) { - if ( gtype_size[intersected_type] != gtype_size[T[j]] ) { - continue; - } - /* type T[j] contains exactly the constants that we need! - * - * remove intersected type from table! - */ - gtype_size[intersected_type] = 0; - for ( k = 0; k < MAX_CONSTANTS; k++ ) { - gis_member[k][intersected_type] = FALSE; - } - gnum_intersected_types[intersected_type] = -1; - gnum_types--; - intersected_type = T[j]; - break; - } - - return intersected_type; - -} - - - -int find_intersected_type( TypeArray T, int num_T ) - -{ - - int i, j; - - for ( i = 0; i < gnum_types; i++ ) { - if ( gnum_intersected_types[i] == -1 ) { - continue; - } - - if ( gnum_intersected_types[i] != num_T ) { - continue; - } - - for ( j = 0; j < num_T; j++ ) { - if ( T[j] != gintersected_types[i][j] ) { - break; - } - } - if ( j < num_T ) { - continue; - } - - return i; - } - - return -1; - -} - - - - - - - - - - - - - - -/****************************** - * MULTIPLY EFFECT PARAMETERS * - ******************************/ - - - - - - - - - - - - -/* local globals for multiplying - */ - -int linertia_conds[MAX_VARS]; -int lnum_inertia_conds; - -int lmultiply_parameters[MAX_VARS]; -int lnum_multiply_parameters; - -NormOperator *lo; -NormEffect *le; - -NormEffect *lres; - - - - - - -void multiply_easy_effect_parameters( void ) - -{ - - int i, j, k, l, p, par; - NormEffect *e; - - for ( i = 0; i < gnum_easy_operators; i++ ) { - lo = geasy_operators[i]; - - lres = NULL; - for ( e = lo->effects; e; e = e->next ) { - le = e; - - lnum_inertia_conds = 0; - for ( j = 0; j < e->num_conditions; j++ ) { - for ( k = 0; k < garity[e->conditions[j].predicate]; k++ ) { - if ( e->conditions[j].args[k] < 0 && - DECODE_VAR( e->conditions[j].args[k] ) < lo->num_vars ) { - break; - } - } - if ( k < garity[e->conditions[j].predicate] ) { - /* only consider inertia constraining effect parameters - */ - continue; - } - if ( !gis_added[e->conditions[j].predicate] && - !gis_deleted[e->conditions[j].predicate] ) { - linertia_conds[lnum_inertia_conds++] = j; - } - } - - lnum_multiply_parameters = 0; - for ( j = 0; j < e->num_vars; j++ ) { - par = lo->num_vars + j; - for ( k = 0; k < lnum_inertia_conds; k++ ) { - p = e->conditions[linertia_conds[k]].predicate; - for ( l = 0; l < garity[p]; l++ ) { - if ( e->conditions[linertia_conds[k]].args[l] == - ENCODE_VAR( par ) ) { - break; - } - } - if ( l < garity[p] ) { - break; - } - } - if ( k < lnum_inertia_conds ) { - continue; - } - lmultiply_parameters[lnum_multiply_parameters++] = j; - } - - unify_easy_inertia_conditions( 0 ); - } - free_NormEffect( lo->effects ); - lo->effects = lres; - } - -} - - - -void unify_easy_inertia_conditions( int curr_inertia ) - -{ - - int p, i, j, af, hh; - int args[MAX_VARS]; - int affected_params[MAX_VARS]; - int num_affected_params = 0; - - if ( curr_inertia == lnum_inertia_conds ) { - multiply_easy_non_constrained_effect_parameters( 0 ); - return; - } - - p = le->conditions[linertia_conds[curr_inertia]].predicate; - for ( i = 0; i < garity[p]; i++ ) { - args[i] = le->conditions[linertia_conds[curr_inertia]].args[i]; - if ( args[i] < 0 ) { - hh = DECODE_VAR( args[i] ); - hh -= lo->num_vars; - if ( le->inst_table[hh] != -1 ) { - args[i] = le->inst_table[hh]; - } else { - affected_params[num_affected_params++] = hh; - } - } - } - - for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { - af = 0; - for ( j = 0; j < garity[p]; j++ ) { - if ( args[j] >= 0 ) { - if ( args[j] != ginitial_predicate[p][i].args[j] ) { - break; - } else { - continue; - } - } - le->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; - } - if ( j < garity[p] ) { - continue; - } - - unify_easy_inertia_conditions( curr_inertia + 1 ); - } - - for ( i = 0; i < num_affected_params; i++ ) { - le->inst_table[affected_params[i]] = -1; - } - -} - - - -void multiply_easy_non_constrained_effect_parameters( int curr_parameter ) - -{ - - int t, n, i, j, k, p, par; - NormEffect *tmp; - Bool rem; - - if ( curr_parameter == lnum_multiply_parameters ) { - /* create new effect, adjusting conds to inst, and - * partially instantiating effects; - * - * add result to lres - */ - tmp = new_NormEffect2( le ); - - /* instantiate param occurences - */ - for ( i = 0; i < le->num_vars; i++ ) { - par = lo->num_vars + i; - - /* numerical part - */ - for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { - replace_var_with_const_in_exp( &(tmp->numeric_conditions_lh[j]), - par, le->inst_table[i] ); - } - for ( j = 0; j < tmp->num_numeric_conditions; j++ ) { - replace_var_with_const_in_exp( &(tmp->numeric_conditions_rh[j]), - par, le->inst_table[i] ); - } - /* was that already enough to get numbers? if yes, - * see whether comparison holds or not. - */ - j = 0; - while ( j < tmp->num_numeric_conditions ) { - if ( tmp->numeric_conditions_lh[j]->connective == NUMBER && - tmp->numeric_conditions_rh[j]->connective == NUMBER ) { - if ( number_comparison_holds( tmp->numeric_conditions_comp[j], - tmp->numeric_conditions_lh[j]->value, - tmp->numeric_conditions_rh[j]->value ) ) { - free_ExpNode( tmp->numeric_conditions_lh[j] ); - free_ExpNode( tmp->numeric_conditions_rh[j] ); - for ( k = j; k < tmp->num_numeric_conditions-1; k++ ) { - tmp->numeric_conditions_comp[k] = tmp->numeric_conditions_comp[k+1]; - tmp->numeric_conditions_lh[k] = tmp->numeric_conditions_lh[k+1]; - tmp->numeric_conditions_rh[k] = tmp->numeric_conditions_rh[k+1]; - } - tmp->num_numeric_conditions--; - } else { - free_NormEffect( tmp ); - return; - } - } else { - j++; - } - } - for ( j = 0; j < tmp->num_numeric_effects; j++ ) { - for ( k = 0; k < gf_arity[tmp->numeric_effects_fluent[j].function]; k++ ) { - if ( tmp->numeric_effects_fluent[j].args[k] == ENCODE_VAR( par ) ) { - tmp->numeric_effects_fluent[j].args[k] = le->inst_table[i]; - } - } - } - for ( j = 0; j < tmp->num_numeric_effects; j++ ) { - replace_var_with_const_in_exp( &(tmp->numeric_effects_rh[j]), - par, le->inst_table[i] ); - } - - /* logical part - */ - for ( j = 0; j < tmp->num_conditions; j++ ) { - for ( k = 0; k < garity[tmp->conditions[j].predicate]; k++ ) { - if ( tmp->conditions[j].args[k] == ENCODE_VAR( par ) ) { - tmp->conditions[j].args[k] = le->inst_table[i]; - } - } - } - for ( j = 0; j < tmp->num_adds; j++ ) { - for ( k = 0; k < garity[tmp->adds[j].predicate]; k++ ) { - if ( tmp->adds[j].args[k] == ENCODE_VAR( par ) ) { - tmp->adds[j].args[k] = le->inst_table[i]; - } - } - } - for ( j = 0; j < tmp->num_dels; j++ ) { - for ( k = 0; k < garity[tmp->dels[j].predicate]; k++ ) { - if ( tmp->dels[j].args[k] == ENCODE_VAR( par ) ) { - tmp->dels[j].args[k] = le->inst_table[i]; - } - } - } - } - /* adjust conditions - */ - i = 0; - while ( i < tmp->num_conditions ) { - rem = FALSE; - p = tmp->conditions[i].predicate; - if ( !gis_added[p] && - !gis_deleted[p] ) { - for ( j = 0; j < garity[p]; j++ ) { - if ( tmp->conditions[i].args[j] < 0 && - DECODE_VAR( tmp->conditions[i].args[j] < lo->num_vars ) ) { - break; - } - } - if ( j == garity[p] ) { - /* inertia that constrain only effect params have been unified, - * are therefore TRUE - */ - rem = TRUE; - } - } - if ( rem ) { - for ( j = i; j < tmp->num_conditions - 1; j++ ) { - tmp->conditions[j].predicate = tmp->conditions[j+1].predicate; - for ( k = 0; k < garity[tmp->conditions[j+1].predicate]; k++ ) { - tmp->conditions[j].args[k] = tmp->conditions[j+1].args[k]; - } - } - tmp->num_conditions--; - } else { - i++; - } - } - /* add result to lres - */ - if ( lres ) { - lres->prev = tmp; - } - tmp->next = lres; - lres = tmp; - return; - } - - t = le->var_types[lmultiply_parameters[curr_parameter]]; - n = gtype_size[t]; - - for ( i = 0; i < n; i++ ) { - le->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; - multiply_easy_non_constrained_effect_parameters( curr_parameter + 1 ); - } - - le->inst_table[lmultiply_parameters[curr_parameter]] = -1; - -} - - - - - - - - - - - - - - - - - - - -/************************** - * MULTIPLY OP PARAMETERS * - **************************/ - - - - - - - - - - - - - - -/* Bool bla; */ - - - - -void multiply_easy_op_parameters( void ) - -{ - - int i, j, k, l, p; - NormOperator *o; - - geasy_templates = NULL; - gnum_easy_templates = 0; - - for ( i = 0; i < gnum_easy_operators; i++ ) { - lo = geasy_operators[i]; -/* if ( strcmp(lo->operator->name, "PORT445_WIN2000") == 0 ) { */ -/* printf("\nmultiply easy OP: %s", lo->operator->name); */ -/* bla = TRUE; */ -/* } else { */ -/* bla = FALSE; */ -/* } */ - - lnum_inertia_conds = 0; - for ( j = 0; j < lo->num_preconds; j++ ) { - if ( !gis_added[lo->preconds[j].predicate] && - !gis_deleted[lo->preconds[j].predicate] ) { - linertia_conds[lnum_inertia_conds++] = j; -/* if ( bla ) { */ -/* printf("\n:inertia cond: %d (pred %s)", j, gpredicates[lo->preconds[j].predicate]); */ -/* fflush(stdout); */ -/* } */ - } - } - - - lnum_multiply_parameters = 0; - for ( j = 0; j < lo->num_vars; j++ ) { - for ( k = 0; k < lnum_inertia_conds; k++ ) { - p = lo->preconds[linertia_conds[k]].predicate; - for ( l = 0; l < garity[p]; l++ ) { - if ( lo->preconds[linertia_conds[k]].args[l] == - ENCODE_VAR( j ) ) { - break; - } - } - if ( l < garity[p] ) { - break; - } - } - if ( k < lnum_inertia_conds ) { - continue; - } -/* if ( bla ) { */ -/* printf("\nmultiply parameter: %d", j); */ -/* fflush(stdout); */ -/* } */ - lmultiply_parameters[lnum_multiply_parameters++] = j; - } - - unify_easy_inertia_preconds( 0 ); - } - - /* now remove inertia preconditions from operator schemata - */ - for ( i = 0; i < gnum_easy_operators; i++ ) { - o = geasy_operators[i]; - - j = 0; - while ( j < o->num_preconds ) { - if ( !gis_added[o->preconds[j].predicate] && - !gis_deleted[o->preconds[j].predicate] ) { - for ( k = j; k < o->num_preconds - 1; k++ ) { - o->preconds[k].predicate = o->preconds[k+1].predicate; - for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) { - o->preconds[k].args[l] = o->preconds[k+1].args[l]; - } - } - o->num_preconds--; - } else { - j++; - } - } - } - -} - - - -void unify_easy_inertia_preconds( int curr_inertia ) - -{ - - int p, i, j, af, hh; - int args[MAX_VARS]; - int affected_params[MAX_VARS]; - int num_affected_params = 0; - - if ( curr_inertia == lnum_inertia_conds ) { - multiply_easy_non_constrained_op_parameters( 0 ); - return; - } - - p = lo->preconds[linertia_conds[curr_inertia]].predicate; - for ( i = 0; i < garity[p]; i++ ) { - args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i]; - if ( args[i] < 0 ) { - hh = DECODE_VAR( args[i] ); - if ( lo->inst_table[hh] != -1 ) { - args[i] = lo->inst_table[hh]; - } else { - affected_params[num_affected_params++] = hh; - } - } - } - - for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { - af = 0; - for ( j = 0; j < garity[p]; j++ ) { - if ( args[j] >= 0 ) { - if ( args[j] != ginitial_predicate[p][i].args[j] ) { - break; - } else { - continue; - } - } - /* check whether that constant has the correct type for that - * parameter (can be not fulfilled due to encoding of unary inertia - */ - if ( !gis_member[ginitial_predicate[p][i].args[j]][lo->var_types[affected_params[af]]] ) { - break; - } - /* legal constant; set op parameter instantiation to it - */ - lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j]; - } - if ( j < garity[p] ) { - continue; - } - - unify_easy_inertia_preconds( curr_inertia + 1 ); - } - - for ( i = 0; i < num_affected_params; i++ ) { - lo->inst_table[affected_params[i]] = -1; - } - -} - - - -void multiply_easy_non_constrained_op_parameters( int curr_parameter ) - -{ - - EasyTemplate *tmp; - int i, j, t, n; - -/* if ( bla ) { */ -/* printf("\nEntry multiply!"); */ -/* fflush(stdout); */ -/* } */ - - if ( curr_parameter == lnum_multiply_parameters ) { - tmp = new_EasyTemplate( lo ); - for ( i = 0; i < lo->num_vars; i++ ) { - tmp->inst_table[i] = lo->inst_table[i]; - } - tmp->next = geasy_templates; - if ( geasy_templates ) { - geasy_templates->prev = tmp; - } - geasy_templates = tmp; - gnum_easy_templates++; - return; - } - - if ( curr_parameter == lnum_multiply_parameters - 1 ) { -/* if ( bla ) { */ -/* printf("\nEntry 1 missing!"); */ -/* fflush(stdout); */ -/* } */ - t = lo->var_types[lmultiply_parameters[curr_parameter]]; - n = gtype_size[t]; - for ( i = 0; i < n; i++ ) { - lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; - -/* if ( bla ) { */ -/* printf("\nmaking instance (numvars %d):", lo->num_vars); */ -/* fflush(stdout); */ -/* } */ - tmp = new_EasyTemplate( lo ); - for ( j = 0; j < lo->num_vars; j++ ) { - tmp->inst_table[j] = lo->inst_table[j]; -/* if ( bla ) { */ -/* printf("%s (ID %d), ", gconstants[tmp->inst_table[j]], tmp->inst_table[j]); */ -/* fflush(stdout); */ -/* } */ - } - tmp->next = geasy_templates; - if ( geasy_templates ) { - geasy_templates->prev = tmp; - } - geasy_templates = tmp; - gnum_easy_templates++; - } - - lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; - - return; - } - - t = lo->var_types[lmultiply_parameters[curr_parameter]]; - n = gtype_size[t]; - for ( i = 0; i < n; i++ ) { - lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i]; - - multiply_easy_non_constrained_op_parameters( curr_parameter + 1 ); - } - - lo->inst_table[lmultiply_parameters[curr_parameter]] = -1; - -} diff --git a/gen/ff_planner/inst_easy.h b/gen/ff_planner/inst_easy.h deleted file mode 100644 index 1bc6eb1db..000000000 --- a/gen/ff_planner/inst_easy.h +++ /dev/null @@ -1,73 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - - - -/********************************************************************* - * File: inst_easy.h - * Description: headers for multiplying easy operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - -#ifndef _INST_EASY_H -#define _INST_EASY_H - - - -void build_easy_action_templates( void ); - - - -void cleanup_easy_domain( void ); -Bool identical_fact( Fact *f1, Fact *f2 ); -void handle_empty_easy_parameters( void ); - - - -void encode_easy_unaries_as_types( void ); -int create_intersected_type( TypeArray T, int num_T ); -int find_intersected_type( TypeArray T, int num_T ); - - - -void multiply_easy_effect_parameters( void ); -void unify_easy_inertia_conditions( int curr_inertia ); -void multiply_easy_non_constrained_effect_parameters( int curr_parameter ); - - - -void multiply_easy_op_parameters( void ); -void unify_easy_inertia_preconds( int curr_inertia ); -void multiply_easy_non_constrained_op_parameters( int curr_parameter ); - - - -#endif /* _INST_EASY_H */ diff --git a/gen/ff_planner/inst_final.c b/gen/ff_planner/inst_final.c deleted file mode 100644 index 3f51a89e6..000000000 --- a/gen/ff_planner/inst_final.c +++ /dev/null @@ -1,2797 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/********************************************************************* - * File: inst_final.c - * Description: final domain representation functions - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_final.h" - - - - - - - - - - - - - - -/******************************** - * POSSIBLY TRUE FACTS ANALYSIS * - ********************************/ - - - - - - - - -/* local globals for this part - */ - -int_pointer lpos[MAX_PREDICATES]; -int_pointer lneg[MAX_PREDICATES]; -int_pointer luse[MAX_PREDICATES]; -int_pointer lindex[MAX_PREDICATES]; - -int lp; -int largs[MAX_VARS]; - - - -/* for collecting poss. defined fluents - */ -int_pointer lf_def[MAX_FUNCTIONS]; -int_pointer lf_index[MAX_FUNCTIONS]; - -int lf; -int lf_args[MAX_VARS]; - - - - - - -void perform_reachability_analysis( void ) - -{ - - int size, i, j, k, adr, num, pargtype; - Bool fixpoint; - Facts *f; - NormOperator *no; - EasyTemplate *t1, *t2; - NormEffect *ne; - Action *tmp, *a; - Bool *had_hard_template; - PseudoAction *pa; - PseudoActionEffect *pae; - - gactions = NULL; - gnum_actions = 0; - - for ( i = 0; i < gnum_predicates; i++ ) { - size = 1; - for ( j = 0; j < garity[i]; j++ ) { - pargtype = gpredicates_args_type[i][j]; - size *= gtype_size[pargtype]; - } - - lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - luse[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - - for ( j = 0; j < size; j++ ) { - lpos[i][j] = 0; - lneg[i][j] = 1;/* all facts but initials are poss. negative */ - luse[i][j] = 0; - lindex[i][j] = -1; - } - } - - had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) ); - for ( i = 0; i < gnum_hard_templates; i++ ) { - had_hard_template[i] = FALSE; - } - - /* mark initial facts as possibly positive, not poss. negative - */ - for ( i = 0; i < gnum_predicates; i++ ) { - lp = i; - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - for ( k = 0; k < garity[i]; k++ ) { - largs[k] = ginitial_predicate[i][j].args[k]; - } - adr = fact_adress(); - lpos[lp][adr] = 1; - lneg[lp][adr] = 0; - } - } - - /* compute fixpoint - */ - fixpoint = FALSE; - while ( !fixpoint ) { - fixpoint = TRUE; - - /* assign next layer of easy templates to possibly positive fixpoint - */ - t1 = geasy_templates; - while ( t1 ) { - no = t1->op; - for ( i = 0; i < no->num_preconds; i++ ) { - lp = no->preconds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( no->preconds[i].args[j] >= 0 ) ? - no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; - } - if ( !lpos[lp][fact_adress()] ) { - break; - } - } - - if ( i < no->num_preconds ) { - t1 = t1->next; - continue; - } - - num = 0; - for ( ne = no->effects; ne; ne = ne->next ) { - num++; - /* currently, simply ignore effect conditions and assume - * they will all be made true eventually. - */ - for ( i = 0; i < ne->num_adds; i++ ) { - lp = ne->adds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->adds[i].args[j] >= 0 ) ? - ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) { - /* new relevant fact! (added non initial) - */ - lpos[lp][adr] = 1; - lneg[lp][adr] = 1; - luse[lp][adr] = 1; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( j = 0; j < garity[lp]; j++ ) { - grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - fixpoint = FALSE; - } - } - } - - tmp = new_Action(); - tmp->norm_operator = no; - tmp->axiom = no->operator->axiom; - for ( i = 0; i < no->num_vars; i++ ) { - tmp->inst_table[i] = t1->inst_table[i]; - } - tmp->name = no->operator->name; - tmp->num_name_vars = no->operator->number_of_real_params; - make_name_inst_table_from_NormOperator( tmp, no, t1 ); - tmp->next = gactions; - tmp->num_effects = num; - gactions = tmp; - gnum_actions++; - - t2 = t1->next; - if ( t1->next ) { - t1->next->prev = t1->prev; - } - if ( t1->prev ) { - t1->prev->next = t1->next; - } else { - geasy_templates = t1->next; - } - free_single_EasyTemplate( t1 ); - t1 = t2; - } - - /* now assign all hard templates that have not been transformed - * to actions yet. - */ - for ( i = 0; i < gnum_hard_templates; i++ ) { - if ( had_hard_template[i] ) { - continue; - } - pa = ghard_templates[i]; - - for ( j = 0; j < pa->num_preconds; j++ ) { - lp = pa->preconds[j].predicate; - for ( k = 0; k < garity[lp]; k++ ) { - largs[k] = pa->preconds[j].args[k]; - } - if ( !lpos[lp][fact_adress()] ) { - break; - } - } - - if ( j < pa->num_preconds ) { - continue; - } - - for ( pae = pa->effects; pae; pae = pae->next ) { - /* currently, simply ignore effect conditions and assume - * they will all be made true eventually. - */ - for ( j = 0; j < pae->num_adds; j++ ) { - lp = pae->adds[j].predicate; - for ( k = 0; k < garity[lp]; k++ ) { - largs[k] = pae->adds[j].args[k]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) { - /* new relevant fact! (added non initial) - */ - lpos[lp][adr] = 1; - lneg[lp][adr] = 1; - luse[lp][adr] = 1; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( k = 0; k < garity[lp]; k++ ) { - grelevant_facts[gnum_relevant_facts].args[k] = largs[k]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - fixpoint = FALSE; - } - } - } - - tmp = new_Action(); - tmp->pseudo_action = pa; - tmp->axiom = pa->operator->axiom; - for ( j = 0; j < pa->operator->num_vars; j++ ) { - tmp->inst_table[j] = pa->inst_table[j]; - } - tmp->name = pa->operator->name; - tmp->num_name_vars = pa->operator->number_of_real_params; - make_name_inst_table_from_PseudoAction( tmp, pa ); - tmp->next = gactions; - tmp->num_effects = pa->num_effects; - gactions = tmp; - gnum_actions++; - - had_hard_template[i] = TRUE; - } - } - - free( had_hard_template ); - - gnum_pp_facts = gnum_initial + gnum_relevant_facts; - - if ( gcmd_line.display_info == 118 ) { - printf("\nreachability analysys came up with:"); - - printf("\n\npossibly positive facts:"); - for ( f = ginitial; f; f = f->next ) { - printf("\n"); - print_Fact( f->fact ); - } - for ( i = 0; i < gnum_relevant_facts; i++ ) { - printf("\n"); - print_Fact( &(grelevant_facts[i]) ); - } - - printf("\n\nthis yields these %d action templates:", gnum_actions); - for ( i = 0; i < gnum_operators; i++ ) { - printf("\n\noperator %s:", goperators[i]->name); - for ( a = gactions; a; a = a->next ) { - if ( ( a->norm_operator && - a->norm_operator->operator != goperators[i] ) || - ( a->pseudo_action && - a->pseudo_action->operator != goperators[i] ) ) { - continue; - } - printf("\ntemplate: "); - if ( a->axiom ) printf("(axiom) "); - for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) { - printf("%s", gconstants[a->name_inst_table[j]]); - if ( j < goperators[i]->num_vars-1 ) { - printf(" "); - } - } - } - } - printf("\n\n"); - } - -} - - - -/* bit complicated to avoid memory explosion when high arity predicates take - * num_obs ^ arity space. take space for individual arg types only; - * must consider pred args in smallest - to - largest - type order to make - * mapping injective. - */ -int fact_adress( void ) - -{ - - int r = 0, b = 1, i, j, min, minj; - Bool done[MAX_ARITY]; - - for ( i = 0; i < garity[lp]; i++ ) { - done[i] = FALSE; - } - - for ( i = 0; i < garity[lp]; i++ ) { - min = -1; - minj = -1; - for ( j = 0; j < garity[lp]; j++ ) { - if ( !done[j] ) { - if ( min == -1 || - gtype_size[gpredicates_args_type[lp][j]] < min ) { - min = gtype_size[gpredicates_args_type[lp][j]]; - minj = j; - } - } - } - if ( minj == -1 || min == -1 ) { - printf("\n\nmin or minj not made in fact adress?\n\n"); - exit( 1 ); - } - /* now minj is remaining arg with lowest type size min - */ - /* need number **within type** here! */ - r += b * gmember_nr[largs[minj]][gpredicates_args_type[lp][minj]]; - b *= min; - done[minj] = TRUE; - } - - return r; - -} - - - -int fluent_adress( void ) - -{ - - int r = 0, b = 1, i; - - for ( i = gf_arity[lf] - 1; i > -1; i-- ) { - r += b * lf_args[i]; - b *= gnum_constants; - } - - return r; - -} - - - -void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ) - -{ - - int i, r = 0, m = 0; - - for ( i = 0; i < o->operator->number_of_real_params; i++ ) { - if ( o->num_removed_vars > r && - o->removed_vars[r] == i ) { - /* this var has been removed in NormOp; - * insert type constraint constant - * - * at least one there, as empty typed pars ops are removed - */ - a->name_inst_table[i] = gtype_consts[o->type_removed_vars[r]][0]; - r++; - } else { - /* this par corresponds to par m in NormOp - */ - a->name_inst_table[i] = t->inst_table[m]; - m++; - } - } - -} - - - -void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ) - -{ - - int i; - - for ( i = 0; i < pa->operator->number_of_real_params; i++ ) { - a->name_inst_table[i] = pa->inst_table[i]; - } - -} - - - - - - - - - - - - - - - - - - -/*********************************************************** - * RELEVANCE ANALYSIS AND FINAL DOMAIN AND PROBLEM CLEANUP * - ***********************************************************/ - - - - - - - - - -/* counts effects for later allocation - */ -int lnum_effects; - - - - - - - - - -void collect_relevant_facts_and_fluents( void ) - -{ - - Action *a; - NormOperator *no; - NormEffect *ne; - int i, j, adr, size; - PseudoAction *pa; - PseudoActionEffect *pae; - FluentValues *fvs; - - /* facts: mark all deleted facts; such facts, that are also pos, are relevant. - */ - for ( a = gactions; a; a = a->next ) { - if ( a->norm_operator ) { - no = a->norm_operator; - - for ( ne = no->effects; ne; ne = ne->next ) { - for ( i = 0; i < ne->num_dels; i++ ) { - lp = ne->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->dels[i].args[j] >= 0 ) ? - ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; - } - adr = fact_adress(); - - lneg[lp][adr] = 1; - if ( lpos[lp][adr] && - !luse[lp][adr] ) { - luse[lp][adr] = 1; - lindex[lp][adr] = gnum_relevant_facts; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( j = 0; j < garity[lp]; j++ ) { - grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - } - } - } - } else { - pa = a->pseudo_action; - - for ( pae = pa->effects; pae; pae = pae->next ) { - for ( i = 0; i < pae->num_dels; i++ ) { - lp = pae->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->dels[i].args[j]; - } - adr = fact_adress(); - - lneg[lp][adr] = 1; - if ( lpos[lp][adr] && - !luse[lp][adr] ) { - luse[lp][adr] = 1; - lindex[lp][adr] = gnum_relevant_facts; - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = lp; - for ( j = 0; j < garity[lp]; j++ ) { - grelevant_facts[gnum_relevant_facts].args[j] = largs[j]; - } - lindex[lp][adr] = gnum_relevant_facts; - gnum_relevant_facts++; - } - } - } - } - } - /* fluents: collect all that are defined in initial state, plus - * all that are assigned to by an effect of an action - * (i.e. preconds poss. pos. due to reachability) - * - * first initialise fast access structures - */ - for ( i = 0; i < gnum_functions; i++ ) { - size = 1; - for ( j = 0; j < gf_arity[i]; j++ ) { - size *= gnum_constants; - } - lf_def[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - lf_index[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - for ( j = 0; j < size; j++ ) { - lf_def[i][j] = 0; - lf_index[i][j] = -1; - } - } - /* from initial state, only those that are not static. - */ - for ( fvs = gf_initial; fvs; fvs = fvs->next ) { - lf = fvs->fluent.function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = fvs->fluent.args[j]; - } - adr = fluent_adress(); - if ( !lf_def[lf][adr] ) { - lf_def[lf][adr] = 1; - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = lf; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); - for ( j = 0; j < gf_arity[lf]; j++ ) { - grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; - strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); - } - lf_index[lf][adr] = gnum_relevant_fluents; - gnum_relevant_fluents++; - } else { - printf("\n\nfluent "); - print_Fluent( &(fvs->fluent) ); - printf(" defined twice in initial state! check input files\n\n"); - exit( 1 ); - } - } - /* from actions, all assigns (are non-static anyway) - */ - for ( a = gactions; a; a = a->next ) { - if ( a->norm_operator ) { - no = a->norm_operator; - for ( ne = no->effects; ne; ne = ne->next ) { - for ( i = 0; i < ne->num_numeric_effects; i++ ) { - if ( ne->numeric_effects_neft[i] != ASSIGN ) continue; - lf = ne->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? - ne->numeric_effects_fluent[i].args[j] : - a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; - } - adr = fluent_adress(); - if ( !lf_def[lf][adr] ) { - lf_def[lf][adr] = 1; - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = lf; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); - for ( j = 0; j < gf_arity[lf]; j++ ) { - grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; - strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); - } - lf_index[lf][adr] = gnum_relevant_fluents; - gnum_relevant_fluents++; - } - } - } - } else { - pa = a->pseudo_action; - for ( pae = pa->effects; pae; pae = pae->next ) { - for ( i = 0; i < pae->num_numeric_effects; i++ ) { - if ( pae->numeric_effects_neft[i] != ASSIGN ) continue; - lf = pae->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = ( pae->numeric_effects_fluent[i].args[j] >= 0 ) ? - pae->numeric_effects_fluent[i].args[j] : - a->inst_table[DECODE_VAR( pae->numeric_effects_fluent[i].args[j] )]; - } - adr = fluent_adress(); - if ( !lf_def[lf][adr] ) { - lf_def[lf][adr] = 1; - if ( gnum_relevant_fluents == MAX_RELEVANT_FLUENTS ) { - printf("\ntoo many relevant fluents! increase MAX_RELEVANT_FLUENTS (currently %d)\n\n", - MAX_RELEVANT_FLUENTS); - exit( 1 ); - } - grelevant_fluents[gnum_relevant_fluents].function = lf; - grelevant_fluents_name[gnum_relevant_fluents] = - ( char * ) calloc( MAX_LENGTH, sizeof( char ) ); - strcpy( grelevant_fluents_name[gnum_relevant_fluents], gfunctions[lf] ); - for ( j = 0; j < gf_arity[lf]; j++ ) { - grelevant_fluents[gnum_relevant_fluents].args[j] = lf_args[j]; - strcat( grelevant_fluents_name[gnum_relevant_fluents], "_" ); - strcat( grelevant_fluents_name[gnum_relevant_fluents], gconstants[lf_args[j]] ); - } - lf_index[lf][adr] = gnum_relevant_fluents; - gnum_relevant_fluents++; - } - } - } - } - } - - if ( gcmd_line.display_info == 119 ) { - printf("\n\nfacts selected as relevant:"); - for ( i = 0; i < gnum_relevant_facts; i++ ) { - printf("\n%d: ", i); - print_Fact( &(grelevant_facts[i]) ); - } - printf("\n\nfluents selected as relevant:"); - for ( i = 0; i < gnum_relevant_fluents; i++ ) { - printf("\n%d: ", i); - print_Fluent( &(grelevant_fluents[i]) ); - } - printf("\n\n"); - } - - lnum_effects = 0; - - create_final_goal_state(); - create_final_initial_state(); - create_final_actions(); - - if ( gmetric != NULL ) { - if ( !set_relevants_in_exp( &gmetric ) ) { - if ( gcmd_line.display_info ) { - printf("\nwarning: undefined fluent used in optimization expression. defaulting to plan length"); - } - free_ExpNode( gmetric ); - gmetric = NULL; - } - } - - if ( gcmd_line.display_info == 120 ) { - printf("\n\nfinal domain representation is:\n\n"); - - for ( i = 0; i < gnum_operators; i++ ) { - printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name); - for ( a = gactions; a; a = a->next ) { - if ( ( !a->norm_operator && - !a->pseudo_action ) || - ( a->norm_operator && - a->norm_operator->operator != goperators[i] ) || - ( a->pseudo_action && - a->pseudo_action->operator != goperators[i] ) ) { - continue; - } - print_Action( a ); - } - } - printf("\n\n--------------------GOAL REACHED ops-----------\n\n"); - for ( a = gactions; a; a = a->next ) { - if ( !a->norm_operator && - !a->pseudo_action ) { - print_Action( a ); - } - } - - printf("\n\nfinal initial state is:\n\n"); - print_State( ginitial_state ); - - printf("\n\nfinal goal is:\n\n"); - for ( i = 0; i < gnum_logic_goal; i++ ) { - print_ft_name( glogic_goal[i] ); - printf("\n"); - } - for ( i = 0; i < gnum_numeric_goal; i++ ) { - switch ( gnumeric_goal_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator in gnumeric_goal %d\n\n", gnumeric_goal_comp[i]); - exit( 1 ); - } - print_ExpNode( gnumeric_goal_lh[i] ); - print_ExpNode( gnumeric_goal_rh[i] ); - printf(")\n"); - } - - if ( gmetric ) { - printf("\n\nmetric is (minimize):\n"); - print_ExpNode( gmetric ); - } else { - printf("\n\nmetric: none, i.e. plan length\n"); - } - } - -} - - - -void create_final_goal_state( void ) - -{ - - WffNode *w, *ww; - int m, mn, i, adr; - Action *tmp; - - if ( !set_relevants_in_wff( &ggoal ) ) { - printf("\n\nff: goal accesses a fluent that will never have a defined value. Problem unsolvable.\n\n"); - exit( 1 ); - } - cleanup_wff( &ggoal ); - - if ( ggoal->connective == TRU ) { - printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); - gnum_plan_ops = 0; - exit( 1 ); - } - if ( ggoal->connective == FAL ) { - printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); - exit( 1 ); - } - - switch ( ggoal->connective ) { - case OR: - if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) { - printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n", - MAX_RELEVANT_FACTS); - exit( 1 ); - } - grelevant_facts[gnum_relevant_facts].predicate = -3; - gnum_relevant_facts++; - for ( w = ggoal->sons; w; w = w->next ) { - tmp = new_Action(); - if ( w->connective == AND ) { - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp->preconds = ( int * ) calloc( m, sizeof( int ) ); - tmp->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp->num_preconds = m; - tmp->num_numeric_preconds = mn; - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - lp = ww->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = ww->fact->args[i]; - } - adr = fact_adress(); - tmp->preconds[m] = lindex[lp][adr]; - m++; - } - if ( ww->connective == COMP ) { - tmp->numeric_preconds_comp[mn] = ww->comp; - tmp->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); - tmp->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); - mn++; - } - } - } else { - if ( w->connective == ATOM ) { - tmp->preconds = ( int * ) calloc( 1, sizeof( int ) ); - tmp->num_preconds = 1; - lp = w->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = w->fact->args[i]; - } - adr = fact_adress(); - tmp->preconds[0] = lindex[lp][adr]; - } - if ( w->connective == COMP ) { - tmp->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp->numeric_preconds_comp[0] = w->comp; - tmp->numeric_preconds_lh[0] = copy_Exp( w->lh ); - tmp->numeric_preconds_rh[0] = copy_Exp( w->rh ); - tmp->num_numeric_preconds = 1; - } - } - tmp->effects = ( ActionEffect * ) calloc( 1, sizeof( ActionEffect ) ); - tmp->num_effects = 1; - tmp->effects[0].conditions = NULL; - tmp->effects[0].num_conditions = 0; - tmp->effects[0].dels = NULL; - tmp->effects[0].num_dels = 0; - tmp->effects[0].adds = ( int * ) calloc( 1, sizeof( int ) ); - tmp->effects[0].adds[0] = gnum_relevant_facts - 1; - tmp->effects[0].num_adds = 1; - tmp->effects[0].numeric_conditions_comp = NULL; - tmp->effects[0].numeric_conditions_lh = NULL; - tmp->effects[0].numeric_conditions_rh = NULL; - tmp->effects[0].num_numeric_conditions = 0; - tmp->effects[0].numeric_effects_neft = NULL; - tmp->effects[0].numeric_effects_fl = NULL; - tmp->effects[0].numeric_effects_rh = NULL; - tmp->effects[0].num_numeric_effects = 0; - - tmp->next = gactions; - gactions = tmp; - gnum_actions++; - lnum_effects++; - } - glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); - glogic_goal[0] = gnum_relevant_facts - 1; - gnum_logic_goal = 1; - break; - case AND: - m = 0; mn = 0; - for ( w = ggoal->sons; w; w = w->next ) { - if ( w->connective == ATOM ) m++; - if ( w->connective == COMP ) mn++; - } - glogic_goal = ( int * ) calloc( m, sizeof( int ) ); - gnumeric_goal_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - gnum_logic_goal = m; - gnum_numeric_goal = mn; - m = 0; mn = 0; - for ( w = ggoal->sons; w; w = w->next ) { - if ( w->connective == ATOM ) { - lp = w->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = w->fact->args[i]; - } - adr = fact_adress(); - glogic_goal[m] = lindex[lp][adr]; - m++; - } - if ( w->connective == COMP ) { - gnumeric_goal_comp[mn] = w->comp; - gnumeric_goal_lh[mn] = copy_Exp( w->lh ); - gnumeric_goal_rh[mn] = copy_Exp( w->rh ); - mn++; - } - } - break; - case ATOM: - glogic_goal = ( int * ) calloc( 1, sizeof( int ) ); - gnum_logic_goal = 1; - lp = ggoal->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = ggoal->fact->args[i]; - } - adr = fact_adress(); - glogic_goal[0] = lindex[lp][adr]; - break; - case COMP: - gnumeric_goal_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - gnumeric_goal_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - gnumeric_goal_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - gnum_numeric_goal = 1; - gnumeric_goal_comp[0] = ggoal->comp; - gnumeric_goal_lh[0] = copy_Exp( ggoal->lh ); - gnumeric_goal_rh[0] = copy_Exp( ggoal->rh ); - break; - default: - printf("\n\nwon't get here: non COMP,ATOM,AND,OR in fully simplified goal\n\n"); - exit( 1 ); - } - -} - - - -Bool set_relevants_in_wff( WffNode **w ) - -{ - - WffNode *i; - int j, adr; - - switch ( (*w)->connective ) { - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - if ( !set_relevants_in_wff( &i ) ) { - return FALSE; - } - } - break; - case ATOM: - /* no equalities, as fully instantiated - */ - lp = (*w)->fact->predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = (*w)->fact->args[j]; - } - adr = fact_adress(); - - if ( !lneg[lp][adr] ) { - (*w)->connective = TRU; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - if ( !lpos[lp][adr] ) { - (*w)->connective = FAL; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - break; - case COMP: - if ( !set_relevants_in_exp( &((*w)->lh) ) || - !set_relevants_in_exp( &((*w)->rh) ) ) { - return FALSE; - } - break; - default: - printf("\n\nwon't get here: non ATOM,OR,AND in goal set relevants\n\n"); - exit( 1 ); - } - - return TRUE; - -} - - - -Bool set_relevants_in_exp( ExpNode **n ) - -{ - - int j, adr; - - /* can probably (for sure) forget about the simplification - * stuff here because it's been done before. - * - * igual.... - */ - switch ( (*n)->connective ) { - case AD: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - if ( !set_relevants_in_exp( &((*n)->leftson) ) ) return FALSE; - if ( !set_relevants_in_exp( &((*n)->rightson) ) ) return FALSE; - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - if ( !set_relevants_in_exp( &((*n)->son) ) ) return FALSE; - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - lf = (*n)->fluent->function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = (*n)->fluent->args[j]; - } - adr = fluent_adress(); - (*n)->fl = lf_index[lf][adr]; - free( (*n)->fluent ); - (*n)->fluent = NULL; - if ( lf_index[lf][adr] == -1 ) { - if ( lf == 0 ) { - /* ATTENTION!! FUNCTION 0 IS TOTAL-TIME WHICH IS *ONLY* USED - * IN OPTIMIZATION EXPRESSION. GETS A SPECIAL TREATMENT - * IN THE RESPECTIVE FUNCTION IN SEARCH.C!!!! - * - * we remember it as fluent -2!! - */ - (*n)->fl = -2; - } else { - return FALSE; - } - } - break; - default: - printf("\n\nset relevants in expnode: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - - return TRUE; - -} - - - -void create_final_initial_state( void ) - -{ - - Facts *f; - int i, adr, fl; - FluentValues *fvs; - - i = 0; -/* for ( f = ginitial; f; f = f->next ) i++; */ - /* we need space for transformation fluents to come! - * - * ALSO, we may need space for derived facts!!! - */ - make_state( &ginitial_state, gnum_relevant_facts + 1, MAX_RELEVANT_FLUENTS ); - - for ( f = ginitial; f; f = f->next ) { - lp = f->fact->predicate; - for ( i = 0; i < garity[lp]; i++ ) { - largs[i] = f->fact->args[i]; - } - adr = fact_adress(); - if ( !lneg[lp][adr] ) {/* non deleted ini */ - continue; - } - ginitial_state.F[ginitial_state.num_F++] = lindex[lp][adr]; - } - - for ( fvs = gf_initial; fvs; fvs = fvs->next ) { - lf = fvs->fluent.function; - for ( i = 0; i < gf_arity[lf]; i++ ) { - lf_args[i] = fvs->fluent.args[i]; - } - adr = fluent_adress(); - fl = lf_index[lf][adr]; - ginitial_state.f_D[fl] = TRUE; - ginitial_state.f_V[fl] = fvs->value; - } - -} - - - -void create_final_actions( void ) - -{ - - Action *a, *p, *t; - NormOperator *no; - NormEffect *ne; - int i, j, adr; - PseudoAction *pa; - PseudoActionEffect *pae; - ActionEffect *aa; - Bool false_cond; - - a = gactions; p = NULL; - while ( a ) { - if ( a->norm_operator ) { - /* action comes from an easy template NormOp - */ - no = a->norm_operator; - - if ( no->num_preconds > 0 ) { - a->preconds = ( int * ) calloc( no->num_preconds, sizeof( int ) ); - } - a->num_preconds = 0; - for ( i = 0; i < no->num_preconds; i++ ) { - lp = no->preconds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( no->preconds[i].args[j] >= 0 ) ? - no->preconds[i].args[j] : a->inst_table[DECODE_VAR( no->preconds[i].args[j] )]; - } - adr = fact_adress(); - /* preconds are lpos in all cases due to reachability analysis - */ - if ( !lneg[lp][adr] ) { - continue; - } - a->preconds[a->num_preconds++] = lindex[lp][adr]; - } - - /**************************NUMERIC PRECOND*************************/ - if ( no->num_numeric_preconds > 0 ) { - a->numeric_preconds_comp = ( Comparator * ) - calloc( no->num_numeric_preconds, sizeof( Comparator ) ); - a->numeric_preconds_lh = ( ExpNode_pointer * ) - calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->numeric_preconds_rh = ( ExpNode_pointer * ) - calloc( no->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->num_numeric_preconds = 0; - } - for ( i = 0; i < no->num_numeric_preconds; i++ ) { - a->numeric_preconds_comp[a->num_numeric_preconds] = no->numeric_preconds_comp[i]; - a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_lh[i] ); - instantiate_exp_by_action( &(a->numeric_preconds_lh[a->num_numeric_preconds]), a ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; - a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( no->numeric_preconds_rh[i] ); - instantiate_exp_by_action( &(a->numeric_preconds_rh[a->num_numeric_preconds]), a ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; - if ( a->numeric_preconds_lh[a->num_numeric_preconds]->connective == NUMBER && - a->numeric_preconds_rh[a->num_numeric_preconds]->connective == NUMBER ) { - /* trivial numeric precond - */ - if ( number_comparison_holds( a->numeric_preconds_comp[a->num_numeric_preconds], - a->numeric_preconds_lh[a->num_numeric_preconds]->value, - a->numeric_preconds_rh[a->num_numeric_preconds]->value ) ) { - /* true precond -> throw precond away. by not incrementing number of such. - */ - free_ExpNode( a->numeric_preconds_lh[a->num_numeric_preconds] ); - free_ExpNode( a->numeric_preconds_rh[a->num_numeric_preconds] ); - continue; - } else { - /* false precond -> throw action away. - */ - break; - } - } - a->num_numeric_preconds++; - } - if ( i < no->num_numeric_preconds ) { - /* a precond accesses an undefined fluent, or is false -> remove action! - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - /**************************NUMERIC PRECOND-END*************************/ - - /* and now for the effects - */ - if ( a->num_effects > 0 ) { - a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); - for ( i = 0; i < a->num_effects; i++ ) { - a->effects[i].illegal = FALSE; - a->effects[i].removed = FALSE; - } - } - a->num_effects = 0; - for ( ne = no->effects; ne; ne = ne->next ) { - aa = &(a->effects[a->num_effects]); - - if ( ne->num_conditions > 0 ) { - aa->conditions = ( int * ) calloc( ne->num_conditions, sizeof( int ) ); - } - aa->num_conditions = 0; - for ( i = 0; i < ne->num_conditions; i++ ) { - lp = ne->conditions[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->conditions[i].args[j] >= 0 ) ? - ne->conditions[i].args[j] : a->inst_table[DECODE_VAR( ne->conditions[i].args[j] )]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ - break; - } - if ( !lneg[lp][adr] ) {/* condition always true: skip it */ - continue; - } - aa->conditions[aa->num_conditions++] = lindex[lp][adr]; - } - if ( i < ne->num_conditions ) {/* found unreachable condition: free condition space */ - free( aa->conditions ); - continue; - } - - /**************************NUMERIC COND*************************/ - if ( ne->num_numeric_conditions > 0 ) { - aa->numeric_conditions_comp = ( Comparator * ) - calloc( ne->num_numeric_conditions, sizeof( Comparator ) ); - aa->numeric_conditions_lh = ( ExpNode_pointer * ) - calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - aa->numeric_conditions_rh = ( ExpNode_pointer * ) - calloc( ne->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < ne->num_numeric_conditions; i++ ) { - aa->numeric_conditions_lh[i] = NULL; - aa->numeric_conditions_rh[i] = NULL; - } - aa->num_numeric_conditions = 0; - } - false_cond = FALSE; - for ( i = 0; i < ne->num_numeric_conditions; i++ ) { - aa->numeric_conditions_comp[aa->num_numeric_conditions] = ne->numeric_conditions_comp[i]; - aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_lh[i] ); - instantiate_exp_by_action( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]), a ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; - aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( ne->numeric_conditions_rh[i] ); - instantiate_exp_by_action( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]), a ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; - if ( aa->numeric_conditions_lh[aa->num_numeric_conditions]->connective == NUMBER && - aa->numeric_conditions_rh[aa->num_numeric_conditions]->connective == NUMBER ) { - /* trivial numeric condition - */ - if ( number_comparison_holds( aa->numeric_conditions_comp[aa->num_numeric_conditions], - aa->numeric_conditions_lh[aa->num_numeric_conditions]->value, - aa->numeric_conditions_rh[aa->num_numeric_conditions]->value ) ) { - /* true cond -> throw cond away. by not incrementing number of such. - */ - free_ExpNode( aa->numeric_conditions_lh[aa->num_numeric_conditions] ); - free_ExpNode( aa->numeric_conditions_rh[aa->num_numeric_conditions] ); - aa->numeric_conditions_lh[aa->num_numeric_conditions] = NULL; - aa->numeric_conditions_rh[aa->num_numeric_conditions] = NULL; - continue; - } else { - /* false cond -> throw effect away. - */ - false_cond = TRUE; - break; - } - } - aa->num_numeric_conditions++; - } - if ( i < ne->num_numeric_conditions ) { - if ( false_cond ) { - /* false numeric cond: free what's been done so far, and skip effect - */ - for ( i = 0; i <= aa->num_numeric_conditions; i++ ) { - free_ExpNode( aa->numeric_conditions_lh[i] ); - free_ExpNode( aa->numeric_conditions_rh[i] ); - } - free( aa->numeric_conditions_comp ); - free( aa->numeric_conditions_lh ); - free( aa->numeric_conditions_rh ); - continue;/* next effect, without incrementing action counter */ - } else { - /* numeric effect uses undefined fluent in condition --> - * THROW WHOLE ACTION AWAY! done by breaking out of the - * effects loop, which will be catched below overall - * effect handling. - */ - break; - } - } - /**************************NUMERIC COND - END*************************/ - - /* now create the add and del effects. - */ - if ( ne->num_adds > 0 ) { - aa->adds = ( int * ) calloc( ne->num_adds, sizeof( int ) ); - } - aa->num_adds = 0; - for ( i = 0; i < ne->num_adds; i++ ) { - lp = ne->adds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->adds[i].args[j] >= 0 ) ? - ne->adds[i].args[j] : a->inst_table[DECODE_VAR( ne->adds[i].args[j] )]; - } - adr = fact_adress(); - if ( !lneg[lp][adr] ) {/* effect always true: skip it */ - continue; - } - aa->adds[aa->num_adds++] = lindex[lp][adr]; - } - - if ( ne->num_dels > 0 ) { - aa->dels = ( int * ) calloc( ne->num_dels, sizeof( int ) ); - } - aa->num_dels = 0; - for ( i = 0; i < ne->num_dels; i++ ) { - lp = ne->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = ( ne->dels[i].args[j] >= 0 ) ? - ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* effect always false: skip it */ - continue; - } - /* NO CHECK FOR ADD \CAP DEL!!!!! -> ALLOWED BY SEMANTICS!!! - */ - aa->dels[aa->num_dels++] = lindex[lp][adr]; - } - if ( i < ne->num_dels ) break; - - /**************************NUMERIC EFFECTS*************************/ - if ( ne->num_numeric_effects > 0 ) { - aa->numeric_effects_neft = ( NumericEffectType * ) - calloc( ne->num_numeric_effects, sizeof( NumericEffectType ) ); - aa->numeric_effects_fl = ( int * ) - calloc( ne->num_numeric_effects, sizeof( int ) ); - aa->numeric_effects_rh = ( ExpNode_pointer * ) - calloc( ne->num_numeric_effects, sizeof( ExpNode_pointer ) ); - aa->num_numeric_effects = 0; - } - for ( i = 0; i < ne->num_numeric_effects; i++ ) { - aa->numeric_effects_neft[aa->num_numeric_effects] = ne->numeric_effects_neft[i]; - lf = ne->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = ( ne->numeric_effects_fluent[i].args[j] >= 0 ) ? - ne->numeric_effects_fluent[i].args[j] : - a->inst_table[DECODE_VAR( ne->numeric_effects_fluent[i].args[j] )]; - } - adr = fluent_adress(); - /* if it's -1, simply let it in --- if that effect appears, then - * action is illegal, otherwise not. - */ - aa->numeric_effects_fl[i] = lf_index[lf][adr]; - if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; - aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( ne->numeric_effects_rh[i] ); - instantiate_exp_by_action( &(aa->numeric_effects_rh[aa->num_numeric_effects]), a ); - if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { - aa->illegal = TRUE; - } - if ( aa->illegal && - aa->num_conditions == 0 && - aa->num_numeric_conditions == 0 ) { - break; - } - /* that's it ???????????????? - !! - */ - aa->num_numeric_effects++; - } - if ( i < ne->num_numeric_effects ) { - /* an unconditional illegal effekt - */ - break; - } - /**************************NUMERIC EFFECTS - END*************************/ - - /* this effect is OK. go to next one in NormOp. - */ - a->num_effects++; - lnum_effects++; - } - if ( ne ) { - /* we get here if one effect was faulty - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - } else { - p = a; - a = a->next; - } - continue; - } - /**********************************second half: hard operators --> pseudo actions******************/ - if ( a->pseudo_action ) { - /* action is result of a PseudoAction - */ - pa = a->pseudo_action; - if ( pa->num_preconds > 0 ) { - a->preconds = ( int * ) calloc( pa->num_preconds, sizeof( int ) ); - } - a->num_preconds = 0; - for ( i = 0; i < pa->num_preconds; i++ ) { - lp = pa->preconds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pa->preconds[i].args[j]; - } - adr = fact_adress(); - /* preconds are lpos in all cases due to reachability analysis - */ - if ( !lneg[lp][adr] ) { - continue; - } - a->preconds[a->num_preconds++] = lindex[lp][adr]; - } - - /**************************NUMERIC PRECOND*************************/ - if ( pa->num_numeric_preconds > 0 ) { - a->numeric_preconds_comp = ( Comparator * ) - calloc( pa->num_numeric_preconds, sizeof( Comparator ) ); - a->numeric_preconds_lh = ( ExpNode_pointer * ) - calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->numeric_preconds_rh = ( ExpNode_pointer * ) - calloc( pa->num_numeric_preconds, sizeof( ExpNode_pointer ) ); - a->num_numeric_preconds = 0; - } - for ( i = 0; i < pa->num_numeric_preconds; i++ ) { - a->numeric_preconds_comp[a->num_numeric_preconds] = pa->numeric_preconds_comp[i]; - a->numeric_preconds_lh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_lh[i] ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_lh[a->num_numeric_preconds]) ) ) break; - a->numeric_preconds_rh[a->num_numeric_preconds] = copy_Exp( pa->numeric_preconds_rh[i] ); - if ( !set_relevants_in_exp( &(a->numeric_preconds_rh[a->num_numeric_preconds]) ) ) break; - a->num_numeric_preconds++; - } - if ( i < pa->num_numeric_preconds ) { - /* a precond accesses an undefined fluent -> remove action! - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - continue; - } - /**************************NUMERIC PRECOND-END*************************/ - - /* and now for the effects - */ - if ( a->num_effects > 0 ) { - a->effects = ( ActionEffect * ) calloc( a->num_effects, sizeof( ActionEffect ) ); - for ( i = 0; i < a->num_effects; i++ ) { - a->effects[i].illegal = FALSE; - a->effects[i].removed = FALSE; - } - } - a->num_effects = 0; - for ( pae = pa->effects; pae; pae = pae->next ) { - aa = &(a->effects[a->num_effects]); - - if ( pae->num_conditions > 0 ) { - aa->conditions = ( int * ) calloc( pae->num_conditions, sizeof( int ) ); - } - aa->num_conditions = 0; - for ( i = 0; i < pae->num_conditions; i++ ) { - lp = pae->conditions[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->conditions[i].args[j]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* condition not reachable: skip effect */ - break; - } - if ( !lneg[lp][adr] ) {/* condition always true: skip it */ - continue; - } - aa->conditions[aa->num_conditions++] = lindex[lp][adr]; - } - if ( i < pae->num_conditions ) {/* found unreachable condition: free condition space */ - free( aa->conditions ); - continue; - } - - /**************************NUMERIC COND*************************/ - if ( pae->num_numeric_conditions > 0 ) { - aa->numeric_conditions_comp = ( Comparator * ) - calloc( pae->num_numeric_conditions, sizeof( Comparator ) ); - aa->numeric_conditions_lh = ( ExpNode_pointer * ) - calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - aa->numeric_conditions_rh = ( ExpNode_pointer * ) - calloc( pae->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < pae->num_numeric_conditions; i++ ) { - aa->numeric_conditions_lh[i] = NULL; - aa->numeric_conditions_rh[i] = NULL; - } - aa->num_numeric_conditions = 0; - } - for ( i = 0; i < pae->num_numeric_conditions; i++ ) { - aa->numeric_conditions_comp[aa->num_numeric_conditions] = pae->numeric_conditions_comp[i]; - aa->numeric_conditions_lh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_lh[i] ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_lh[aa->num_numeric_conditions]) ) ) break; - aa->numeric_conditions_rh[aa->num_numeric_conditions] = copy_Exp( pae->numeric_conditions_rh[i] ); - if ( !set_relevants_in_exp( &(aa->numeric_conditions_rh[aa->num_numeric_conditions]) ) ) break; - aa->num_numeric_conditions++; - } - if ( i < pae->num_numeric_conditions ) { - /* numeric effect uses undefined fluent in condition --> - * THROW WHOLE ACTION AWAY! done by breaking out of the - * effects loop, which will be catched below overall - * effect handling. - */ - break; - } - /**************************NUMERIC COND - END*************************/ - - /* now create the add and del effects. - */ - if ( pae->num_adds > 0 ) { - aa->adds = ( int * ) calloc( pae->num_adds, sizeof( int ) ); - } - aa->num_adds = 0; - for ( i = 0; i < pae->num_adds; i++ ) { - lp = pae->adds[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->adds[i].args[j]; - } - adr = fact_adress(); - if ( !lneg[lp][adr] ) {/* effect always true: skip it */ - continue; - } - aa->adds[aa->num_adds++] = lindex[lp][adr]; - } - - if ( pae->num_dels > 0 ) { - aa->dels = ( int * ) calloc( pae->num_dels, sizeof( int ) ); - } - aa->num_dels = 0; - for ( i = 0; i < pae->num_dels; i++ ) { - lp = pae->dels[i].predicate; - for ( j = 0; j < garity[lp]; j++ ) { - largs[j] = pae->dels[i].args[j]; - } - adr = fact_adress(); - if ( !lpos[lp][adr] ) {/* effect always false: skip it */ - continue; - } - aa->dels[aa->num_dels++] = lindex[lp][adr]; - } - if ( i < pae->num_dels ) break; - - /**************************NUMERIC EFFECTS*************************/ - if ( pae->num_numeric_effects > 0 ) { - aa->numeric_effects_neft = ( NumericEffectType * ) - calloc( pae->num_numeric_effects, sizeof( NumericEffectType ) ); - aa->numeric_effects_fl = ( int * ) - calloc( pae->num_numeric_effects, sizeof( int ) ); - aa->numeric_effects_rh = ( ExpNode_pointer * ) - calloc( pae->num_numeric_effects, sizeof( ExpNode_pointer ) ); - aa->num_numeric_effects = 0; - } - for ( i = 0; i < pae->num_numeric_effects; i++ ) { - aa->numeric_effects_neft[aa->num_numeric_effects] = pae->numeric_effects_neft[i]; - lf = pae->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[lf]; j++ ) { - lf_args[j] = pae->numeric_effects_fluent[i].args[j]; - if ( lf_args[j] < 0 ) { - printf("\n\nuninstantiated affected fluent in final actions! debug me.\n\n"); - exit( 1 ); - } - } - adr = fluent_adress(); - /* if it's -1, simply let it in --- if that effect appears, then - * action is illegal, otherwise not. - */ - aa->numeric_effects_fl[i] = lf_index[lf][adr]; - if ( lf_index[lf][adr] == -1 ) aa->illegal = TRUE; - aa->numeric_effects_rh[aa->num_numeric_effects] = copy_Exp( pae->numeric_effects_rh[i] ); - if ( !set_relevants_in_exp( &(aa->numeric_effects_rh[aa->num_numeric_effects]) ) ) { - aa->illegal = TRUE; - } - if ( aa->illegal && - aa->num_conditions == 0 && - aa->num_numeric_conditions == 0 ) { - break; - } - /* that's it ???????????????? - !! - */ - aa->num_numeric_effects++; - } - if ( i < pae->num_numeric_effects ) { - /* an unconditional illegal effekt - */ - break; - } - /**************************NUMERIC EFFECTS - END*************************/ - - /* this effect is OK. go to next one in PseudoAction. - */ - a->num_effects++; - lnum_effects++; - } - if ( pae ) { - /* we get here if one effect was faulty - */ - gnum_actions--; - if ( p ) { - p->next = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } else { - gactions = a->next; - t = a; - a = a->next; - t->next = gtrash_actions; - gtrash_actions = t; - } - } else { - p = a; - a = a->next; - } - continue; - }/* end of if clause for PseudoAction */ - /* if action was neither normop, nor pseudo action determined, - * then it is an artificial action due to disjunctive goal - * conditions. - * - * these are already in final form. - */ - p = a; - a = a->next; - }/* endfor all actions ! */ - -} - - - -void instantiate_exp_by_action( ExpNode **n, Action *a ) - -{ - - int j, f, k, h; - Bool ok; - - switch ( (*n)->connective ) { - case AD: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - instantiate_exp_by_action( &((*n)->leftson), a ); - instantiate_exp_by_action( &((*n)->rightson), a ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - instantiate_exp_by_action( &((*n)->son), a ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - f = (*n)->fluent->function; - ok = TRUE; - for ( j = 0; j < gf_arity[f]; j++ ) { - h = ( (*n)->fluent->args[j] < 0 ) ? - a->inst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; - if ( h < 0 ) { - ok = FALSE; - } else { - (*n)->fluent->args[j] = h; - } - } - if ( !ok ) { - printf("\n\nnon-instantiated fluent in final actiona! debug me!!\n\n"); - exit( 1 ); - } - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\ninst. exp by action: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - - - - - - - - - - - - - - - - - - -/************************************************** - * CONNECTIVITY GRAPH. ULTRA CLEAN REPRESENTATION * - **************************************************/ - - - - - - - - - - - - - - - - - - - - -void build_connectivity_graph( void ) - -{ - - int i, j, k, l, n_op, n_ef, fl, ef, ef_, m; - float val; - Action *a; - ActionEffect *e; - - gnum_ft_conn = gnum_relevant_facts; - gnum_fl_conn = gnum_relevant_fluents; - gnum_op_conn = gnum_actions; - gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) ); - gfl_conn = ( FlConn * ) calloc( gnum_fl_conn, sizeof( FlConn ) ); - gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) ); - gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) ); - gnum_ef_conn = 0; - - for ( i = 0; i < gnum_ft_conn; i++ ) { - gft_conn[i].num_PC = 0; - gft_conn[i].num_A = 0; - gft_conn[i].num_D = 0; - - gft_conn[i].axiom_added = FALSE; - - gft_conn[i].rand = random() % BIG_INT; - } - - gnum_real_fl_conn = 0; - for ( i = 0; i < gnum_fl_conn; i++ ) { - gfl_conn[i].num_PC = 0; - gfl_conn[i].num_IN = 0; - gfl_conn[i].num_AS = 0; - - if ( grelevant_fluents_lnf[i] == NULL ) { - gfl_conn[i].artificial = FALSE; - gnum_real_fl_conn++; - gfl_conn[i].rand = random() % BIG_INT; - } else { - /* once we're in here we'll stay as all artificial - * fluents are appended to the end. - */ - gfl_conn[i].artificial = TRUE; - gfl_conn[i].lnf_F = ( int * ) - calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( int ) ); - gfl_conn[i].lnf_C = ( float * ) - calloc( grelevant_fluents_lnf[i]->num_pF, sizeof( float ) ); - for ( j = 0; j < grelevant_fluents_lnf[i]->num_pF; j++ ) { - gfl_conn[i].lnf_F[j] = grelevant_fluents_lnf[i]->pF[j]; - gfl_conn[i].lnf_C[j] = grelevant_fluents_lnf[i]->pC[j]; - } - gfl_conn[i].num_lnf = grelevant_fluents_lnf[i]->num_pF; - } - } - - - /* why not do this here? - */ - gmneed_start_D = ( Bool * ) calloc( gnum_real_fl_conn, sizeof( Bool ) ); - gmneed_start_V = ( float * ) calloc( gnum_real_fl_conn, sizeof( float ) ); - - - for ( i = 0; i < gnum_op_conn; i++ ) { - gop_conn[i].num_E = 0; - } - - for ( i = 0; i < lnum_effects; i++ ) { - gef_conn[i].num_PC = 0; - gef_conn[i].num_f_PC = 0; - gef_conn[i].num_A = 0; - gef_conn[i].num_D = 0; - gef_conn[i].num_I = 0; - gef_conn[i].num_IN = 0; - gef_conn[i].num_AS = 0; - - gef_conn[i].illegal = FALSE; - gef_conn[i].removed = FALSE; - } - - - /* determine if there are conditional effects. - */ - gconditional_effects = FALSE; - for ( a = gactions; a; a = a->next ) { - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - if ( e->num_conditions > 0 ) { - break; - } - if ( e->num_lnf_conditions > 0 ) { - break; - } - } - if ( i < a->num_effects ) break; - } - if ( a ) { - printf("\n\ntask contains conditional effects. turning off state domination.\n\n"); - gconditional_effects = TRUE; - } - - n_op = 0; - n_ef = 0; - for ( a = gactions; a; a = a->next ) { - gop_conn[n_op].action = a; - gop_conn[n_op].axiom = a->axiom; - if ( a->num_effects == 0 ) { - continue; - } - - gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) ); - for ( i = 0; i < a->num_effects; i++ ) { - e = &(a->effects[i]); - gef_conn[n_ef].cost = e->cost; - if ( e->removed ) { - /* this one disappeared through summarization - */ - continue; - } - gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef; - gef_conn[n_ef].op = n_op; - if ( e->illegal ) { - gef_conn[n_ef].illegal = TRUE; - } - - /*****************************CONDS********************************/ - gef_conn[n_ef].PC = ( int * ) - calloc( e->num_conditions + a->num_preconds, sizeof( int ) ); - for ( j = 0; j < a->num_preconds; j++ ) { - for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { - if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break; - } - if ( k < gef_conn[n_ef].num_PC ) continue; - gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j]; - } - for ( j = 0; j < e->num_conditions; j++ ) { - for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { - if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break; - } - if ( k < gef_conn[n_ef].num_PC ) continue; - gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j]; - } - /* similar thing for numeric conditions. - */ - gef_conn[n_ef].f_PC_comp = ( Comparator * ) - calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( Comparator ) ); - gef_conn[n_ef].f_PC_fl = ( int * ) - calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( int ) ); - gef_conn[n_ef].f_PC_c = ( float * ) - calloc( e->num_lnf_conditions + a->num_lnf_preconds, sizeof( float ) ); - gef_conn[n_ef].f_PC_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); - for ( j = 0; j < gnum_fl_conn; j++ ) { - gef_conn[n_ef].f_PC_direct_comp[j] = IGUAL; - } - gef_conn[n_ef].f_PC_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); - for ( j = 0; j < a->num_lnf_preconds; j++ ) { - if ( a->lnf_preconds_lh[j]->num_pF != 1 ) { - printf("\n\nnon 1 card. in comp lh final pre copyover.\n\n"); - exit( 1 ); - } - for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { - if ( gef_conn[n_ef].f_PC_fl[k] == a->lnf_preconds_lh[j]->pF[0] ) break; - } - if ( k < gef_conn[n_ef].num_f_PC ) { - if ( a->lnf_preconds_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { - /* weaker cond - */ - continue; - } - if ( a->lnf_preconds_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { - /* stronger cond - */ - gef_conn[n_ef].f_PC_c[k] = a->lnf_preconds_rh[j]; - gef_conn[n_ef].f_PC_comp[k] = a->lnf_preconds_comp[j]; - continue; - } - if ( a->lnf_preconds_comp[j] == GE ) { - /* we might need to strengthen our comp - */ - gef_conn[n_ef].f_PC_comp[k] = GE; - } - } else { - gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_comp[j]; - gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = a->lnf_preconds_lh[j]->pF[0]; - gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = a->lnf_preconds_rh[j]; - } - } - for ( j = 0; j < e->num_lnf_conditions; j++ ) { - if ( e->lnf_conditions_lh[j]->num_pF != 1 ) { - printf("\n\nnon 1 card. in comp lh final cond copyover.\n\n"); - exit( 1 ); - } - for ( k = 0; k < gef_conn[n_ef].num_f_PC; k++ ) { - if ( gef_conn[n_ef].f_PC_fl[k] == e->lnf_conditions_lh[j]->pF[0] ) break; - } - if ( k < gef_conn[n_ef].num_f_PC ) { - if ( e->lnf_conditions_rh[j] < gef_conn[n_ef].f_PC_c[k] ) { - continue; - } - if ( e->lnf_conditions_rh[j] > gef_conn[n_ef].f_PC_c[k] ) { - gef_conn[n_ef].f_PC_c[k] = e->lnf_conditions_rh[j]; - gef_conn[n_ef].f_PC_comp[k] = e->lnf_conditions_comp[j]; - continue; - } - if ( e->lnf_conditions_comp[j] == GE ) { - gef_conn[n_ef].f_PC_comp[k] = GE; - } - } else { - gef_conn[n_ef].f_PC_comp[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_comp[j]; - gef_conn[n_ef].f_PC_fl[gef_conn[n_ef].num_f_PC] = e->lnf_conditions_lh[j]->pF[0]; - gef_conn[n_ef].f_PC_c[gef_conn[n_ef].num_f_PC++] = e->lnf_conditions_rh[j]; - } - } - /* now arrange the direct access structures from that. - */ - for ( j = 0; j < gef_conn[n_ef].num_f_PC; j++ ) { - gef_conn[n_ef].f_PC_direct_comp[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_comp[j]; - gef_conn[n_ef].f_PC_direct_c[gef_conn[n_ef].f_PC_fl[j]] = gef_conn[n_ef].f_PC_c[j]; - } - /*****************************CONDS - END********************************/ - - - if ( e->illegal ) { - /* we don't care about the effects if they're illegal - - * all we care about is whether the condition is true or not. - */ - n_ef++; - gnum_ef_conn++; - continue; - } - /*****************************EFFECTS********************************/ - gef_conn[n_ef].A = ( int * ) calloc( e->num_adds, sizeof( int ) ); - gef_conn[n_ef].D = ( int * ) calloc( e->num_dels, sizeof( int ) ); - gef_conn[n_ef].IN_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].IN_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].IN_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); - gef_conn[n_ef].AS_fl = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].AS_fl_ = ( int * ) calloc( e->num_lnf_effects, sizeof( int ) ); - gef_conn[n_ef].AS_c = ( float * ) calloc( e->num_lnf_effects, sizeof( float ) ); - - /* duplicates removed in summarize already. - * - * but don't include adds that are in the conds. - * --- those are true anyway. - * - * and don't include dels that are in the adds - * --- those will be re-added anyway. - * - * NOTE: it is important that we use the *original* add list - * not the already reduced one, for the delete check! - * otherwise it may be that a delete that's in the add - * and also in the cond stays in! - * - * IT IS ALSO IMPORTANT THAT WE DO BOTH!!!, i.e. if we do - * the ads reduction then we *must* also do the dels - * reduction to avoid that things are deleted that - * would otherwise have been re-added. - */ - for ( j = 0; j < e->num_adds; j++ ) { - for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) { - if ( gef_conn[n_ef].PC[k] == e->adds[j] ) break; - } - if ( k < gef_conn[n_ef].num_PC ) continue; - gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j]; - } - for ( j = 0; j < e->num_dels; j++ ) { - for ( k = 0; k < e->num_adds; k++ ) { - if ( e->adds[k] == e->dels[j] ) break; - } - if ( k < e->num_adds ) continue; - gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j]; - } - - /* numeric part - */ - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_neft[j] != INCREASE ) continue; - gef_conn[n_ef].IN_fl[gef_conn[n_ef].num_IN] = e->lnf_effects_fl[j]; - if ( e->lnf_effects_rh[j]->num_pF == 1 ) { - if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { - printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); - exit( 1 ); - } - gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = e->lnf_effects_rh[j]->pF[0]; - } else { - if ( e->lnf_effects_rh[j]->num_pF != 0 ) { - printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); - exit( 1 ); - } - gef_conn[n_ef].IN_fl_[gef_conn[n_ef].num_IN] = -1; - } - gef_conn[n_ef].IN_c[gef_conn[n_ef].num_IN++] = e->lnf_effects_rh[j]->c; - } - /* now remove increasers by nothing. - */ - j = 0; - while ( j < gef_conn[n_ef].num_IN ) { - if ( gef_conn[n_ef].IN_fl_[j] != -1 || - gef_conn[n_ef].IN_c[j] != 0 ) { - j++; - continue; - } - for ( k = j; k < gef_conn[n_ef].num_IN - 1; k++ ) { - gef_conn[n_ef].IN_fl[k] = gef_conn[n_ef].IN_fl[k+1]; - gef_conn[n_ef].IN_fl_[k] = gef_conn[n_ef].IN_fl_[k+1]; - gef_conn[n_ef].IN_c[k] = gef_conn[n_ef].IN_c[k+1]; - } - gef_conn[n_ef].num_IN--; - } - /* now: the assigners... - */ - for ( j = 0; j < e->num_lnf_effects; j++ ) { - if ( e->lnf_effects_neft[j] != ASSIGN ) continue; - gef_conn[n_ef].AS_fl[gef_conn[n_ef].num_AS] = e->lnf_effects_fl[j]; - if ( e->lnf_effects_rh[j]->num_pF == 1 ) { - if ( e->lnf_effects_rh[j]->pF[0] < 0 ) { - printf("\n\nnon-relevant fluent in final copying to conn.\n\n"); - exit( 1 ); - } - gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = e->lnf_effects_rh[j]->pF[0]; - } else { - if ( e->lnf_effects_rh[j]->num_pF != 0 ) { - printf("\n\nnon-1 or 0 number of fl_ in copying to conn\n\n"); - exit( 1 ); - } - gef_conn[n_ef].AS_fl_[gef_conn[n_ef].num_AS] = -1; - } - gef_conn[n_ef].AS_c[gef_conn[n_ef].num_AS++] = e->lnf_effects_rh[j]->c; - } - /*****************************EFFECTS - END********************************/ - - n_ef++; - gnum_ef_conn++; - }/* end all a->effects */ - - - /*****************************EMPTY EFFECTS********************************/ - if ( gop_conn[n_op].num_E >= 1 ) { - /* CHECK EMPTY EFFECTS! - * - * two step process --- first, remove all effects that are entirely empty. - * second, check if all remaining effects are illegal - * or only delete: - * in that case, the op will never do any good so we - * remove all its effects. - */ - i = 0; - while ( i < gop_conn[n_op].num_E ) { - /* illegal effects *must* stay in!!! - */ - if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { - i++; - continue; - } - if ( gef_conn[gop_conn[n_op].E[i]].num_A != 0 || - gef_conn[gop_conn[n_op].E[i]].num_D != 0 || - gef_conn[gop_conn[n_op].E[i]].num_IN != 0 || - gef_conn[gop_conn[n_op].E[i]].num_AS != 0 ) { - i++; - continue; - } - /* we keep it in the gef_conn (seems easier), - * but mark it as removed, which will exclude it from everything. - */ - gef_conn[gop_conn[n_op].E[i]].removed = TRUE; - for ( j = i; j < gop_conn[n_op].num_E - 1; j++ ) { - gop_conn[n_op].E[j] = gop_conn[n_op].E[j+1]; - } - gop_conn[n_op].num_E--; - } - - m = 0; - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - if ( gef_conn[gop_conn[n_op].E[i]].illegal ) { - m++; - continue; - } - if ( gef_conn[gop_conn[n_op].E[i]].num_A == 0 && - gef_conn[gop_conn[n_op].E[i]].num_IN == 0 && - gef_conn[gop_conn[n_op].E[i]].num_AS == 0 ) { - m++; - } - } - if ( m == gop_conn[n_op].num_E ) { - /* all remaining effects illegal or solely-deleters. - */ - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - gef_conn[gop_conn[n_op].E[i]].removed = TRUE; - } - gop_conn[n_op].num_E = 0; - } - } - /*****************************EMPTY EFFECTS - END********************************/ - - - /*****************************IMPLIED EFFECTS********************************/ - if ( gop_conn[n_op].num_E > 1 ) { - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - ef = gop_conn[n_op].E[i]; - gef_conn[ef].I = ( int * ) calloc( gop_conn[n_op].num_E, sizeof( int ) ); - gef_conn[ef].num_I = 0; - } - for ( i = 0; i < gop_conn[n_op].num_E - 1; i++ ) { - ef = gop_conn[n_op].E[i]; - for ( j = i+1; j < gop_conn[n_op].num_E; j++ ) { - ef_ = gop_conn[n_op].E[j]; - /* ef ==> ef_ ? */ - for ( k = 0; k < gef_conn[ef_].num_PC; k++ ) { - for ( l = 0; l < gef_conn[ef].num_PC; l++ ) { - if ( gef_conn[ef].PC[l] == gef_conn[ef_].PC[k] ) break; - } - if ( l == gef_conn[ef].num_PC ) break; - } - if ( k == gef_conn[ef_].num_PC ) { - for ( k = 0; k < gnum_fl_conn; k++ ) { - if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL ) continue; - if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL || - gef_conn[ef].f_PC_direct_c[k] < gef_conn[ef_].f_PC_direct_c[k] || - ( gef_conn[ef].f_PC_direct_c[k] == gef_conn[ef_].f_PC_direct_c[k] && - gef_conn[ef].f_PC_direct_comp[k] == GEQ && - gef_conn[ef_].f_PC_direct_comp[k] == GE ) ) break; - } - if ( k == gnum_fl_conn ) { - gef_conn[ef].I[gef_conn[ef].num_I++] = ef_; - } - } - /* ef_ ==> ef ? */ - for ( k = 0; k < gef_conn[ef].num_PC; k++ ) { - for ( l = 0; l < gef_conn[ef_].num_PC; l++ ) { - if ( gef_conn[ef_].PC[l] == gef_conn[ef].PC[k] ) break; - } - if ( l == gef_conn[ef_].num_PC ) break; - } - if ( k == gef_conn[ef].num_PC ) { - for ( k = 0; k < gnum_fl_conn; k++ ) { - if ( gef_conn[ef].f_PC_direct_comp[k] == IGUAL ) continue; - if ( gef_conn[ef_].f_PC_direct_comp[k] == IGUAL || - gef_conn[ef_].f_PC_direct_c[k] < gef_conn[ef].f_PC_direct_c[k] || - ( gef_conn[ef_].f_PC_direct_c[k] == gef_conn[ef].f_PC_direct_c[k] && - gef_conn[ef_].f_PC_direct_comp[k] == GEQ && - gef_conn[ef].f_PC_direct_comp[k] == GE ) ) break; - } - if ( k == gnum_fl_conn ) { - gef_conn[ef_].I[gef_conn[ef_].num_I++] = ef; - } - } - } - } - } - /*****************************IMPLIED EFFECTS - END********************************/ - - /* op cost is sum of eff costs + gtt*1: - * [gtt is multiplicator of TOTAL-TIME in final metric; if no - * total-time part in metric, it is 0] - * ie eff-costs plus the cost for the time taken by 1 more step. - */ - gop_conn[n_op].cost = gtt; - if ( gop_conn[n_op].num_E > 0 ) { - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - ef = gop_conn[n_op].E[i]; - if ( gef_conn[ef].illegal ) { - continue; - } - if ( gef_conn[ef].removed ) { - continue; - } - gop_conn[n_op].cost += gef_conn[ef].cost; - } - } - - /* first sweep: only count the space we need for the fact arrays ! - */ - if ( gop_conn[n_op].num_E > 0 ) { - for ( i = 0; i < gop_conn[n_op].num_E; i++ ) { - ef = gop_conn[n_op].E[i]; - for ( j = 0; j < gef_conn[ef].num_PC; j++ ) { - gft_conn[gef_conn[ef].PC[j]].num_PC++; - } - for ( j = 0; j < gef_conn[ef].num_A; j++ ) { - gft_conn[gef_conn[ef].A[j]].num_A++; - if ( gop_conn[n_op].axiom ) { - gft_conn[gef_conn[ef].A[j]].axiom_added = TRUE; - } - } - for ( j = 0; j < gef_conn[ef].num_D; j++ ) { - gft_conn[gef_conn[ef].D[j]].num_D++; - } - /* similar increments for flconn - */ - for ( j = 0; j < gef_conn[ef].num_f_PC; j++ ) { - gfl_conn[gef_conn[ef].f_PC_fl[j]].num_PC++; - } - for ( j = 0; j < gef_conn[ef].num_IN; j++ ) { - gfl_conn[gef_conn[ef].IN_fl[j]].num_IN++; - } - for ( j = 0; j < gef_conn[ef].num_AS; j++ ) { - gfl_conn[gef_conn[ef].AS_fl[j]].num_AS++; - } - } - } - - - n_op++; - } - - /*****************************FLCONN********************************/ - for ( i = 0; i < gnum_ft_conn; i++ ) { - if ( gft_conn[i].num_PC > 0 ) { - gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) ); - } - gft_conn[i].num_PC = 0; - if ( gft_conn[i].num_A > 0 ) { - gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) ); - } - gft_conn[i].num_A = 0; - if ( gft_conn[i].num_D > 0 ) { - gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) ); - } - gft_conn[i].num_D = 0; - } - for ( i = 0; i < gnum_ef_conn; i++ ) { - if ( gef_conn[i].removed ) continue; - for ( j = 0; j < gef_conn[i].num_PC; j++ ) { - gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i; - } - for ( j = 0; j < gef_conn[i].num_A; j++ ) { - gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i; - } - for ( j = 0; j < gef_conn[i].num_D; j++ ) { - gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i; - } - } - /*****************************FTCONN - END********************************/ - - - /*****************************FLCONN********************************/ - /* similar thing for flconn - */ - for ( i = 0; i < gnum_fl_conn; i++ ) { - if ( gfl_conn[i].num_PC > 0 ) { - gfl_conn[i].PC = ( int * ) calloc( gfl_conn[i].num_PC, sizeof( int ) ); - } - gfl_conn[i].num_PC = 0; - if ( gfl_conn[i].num_IN > 0 ) { - gfl_conn[i].IN = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); - gfl_conn[i].IN_fl_ = ( int * ) calloc( gfl_conn[i].num_IN, sizeof( int ) ); - gfl_conn[i].IN_c = ( float * ) calloc( gfl_conn[i].num_IN, sizeof( float ) ); - } - gfl_conn[i].num_IN = 0; - if ( gfl_conn[i].num_AS > 0 ) { - gfl_conn[i].AS = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); - gfl_conn[i].AS_fl_ = ( int * ) calloc( gfl_conn[i].num_AS, sizeof( int ) ); - gfl_conn[i].AS_c = ( float * ) calloc( gfl_conn[i].num_AS, sizeof( float ) ); - } - gfl_conn[i].num_AS = 0; - } - for ( i = 0; i < gnum_ef_conn; i++ ) { - if ( gef_conn[i].removed ) continue; - /* PCs - */ - for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { - fl = gef_conn[i].f_PC_fl[j]; - gfl_conn[fl].PC[gfl_conn[fl].num_PC++] = i; - } - /* insert increasers by decreasing amount --> - * "best" - at least for constant part - are first! - */ - for ( j = 0; j < gef_conn[i].num_IN; j++ ) { - fl = gef_conn[i].IN_fl[j]; - val = gef_conn[i].IN_c[j]; - for ( k = 0; k < gfl_conn[fl].num_IN; k++ ) { - if ( gfl_conn[fl].IN_c[k] < val ) break; - } - for ( l = gfl_conn[fl].num_IN; l > k; l-- ) { - gfl_conn[fl].IN[l] = gfl_conn[fl].IN[l-1]; - gfl_conn[fl].IN_fl_[l] = gfl_conn[fl].IN_fl_[l-1]; - gfl_conn[fl].IN_c[l] = gfl_conn[fl].IN_c[l-1]; - } - gfl_conn[fl].IN[k] = i; - gfl_conn[fl].IN_fl_[k] = gef_conn[i].IN_fl_[j];/* the rh fluent */ - gfl_conn[fl].IN_c[k] = val; - gfl_conn[fl].num_IN++; - } - /* insert assigners by decreasing amount --> - * "best" - at least for constant part - are first! - */ - for ( j = 0; j < gef_conn[i].num_AS; j++ ) { - fl = gef_conn[i].AS_fl[j]; - val = gef_conn[i].AS_c[j]; - for ( k = 0; k < gfl_conn[fl].num_AS; k++ ) { - if ( gfl_conn[fl].AS_c[k] < val ) break; - } - for ( l = gfl_conn[fl].num_AS; l > k; l-- ) { - gfl_conn[fl].AS[l] = gfl_conn[fl].AS[l-1]; - gfl_conn[fl].AS_fl_[l] = gfl_conn[fl].AS_fl_[l-1]; - gfl_conn[fl].AS_c[l] = gfl_conn[fl].AS_c[l-1]; - } - gfl_conn[fl].AS[k] = i; - gfl_conn[fl].AS_fl_[k] = gef_conn[i].AS_fl_[j];/* the rh fluent */ - gfl_conn[fl].AS_c[k] = val; - gfl_conn[fl].num_AS++; - } - } - /*****************************FLCONN - END********************************/ - - - /*****************************GOAL********************************/ - gflogic_goal = ( int * ) calloc( gnum_logic_goal, sizeof( int ) ); - for ( j = 0; j < gnum_logic_goal; j++ ) { - for ( k = 0; k < gnum_flogic_goal; k++ ) { - if ( gflogic_goal[k] == glogic_goal[j] ) break; - } - if ( k < gnum_flogic_goal ) continue; - gflogic_goal[gnum_flogic_goal++] = glogic_goal[j]; - } - /* numeric part - */ - gfnumeric_goal_comp = ( Comparator * ) calloc( gnum_lnf_goal, sizeof( Comparator ) ); - gfnumeric_goal_fl = ( int * ) calloc( gnum_lnf_goal, sizeof( int ) ); - gfnumeric_goal_c = ( float * ) calloc( gnum_lnf_goal, sizeof( float ) ); - for ( j = 0; j < gnum_lnf_goal; j++ ) { - if ( glnf_goal_lh[j]->num_pF != 1 ) { - printf("\n\nnon 1 card. in comp lh final goal copyover.\n\n"); - exit( 1 ); - } - for ( k = 0; k < gnum_fnumeric_goal; k++ ) { - if ( gfnumeric_goal_fl[k] == glnf_goal_lh[j]->pF[0] ) break; - } - if ( k < gnum_fnumeric_goal ) { - if ( glnf_goal_rh[j] < gfnumeric_goal_c[k] ) continue; - if ( glnf_goal_rh[j] > gfnumeric_goal_c[k] ) { - gfnumeric_goal_comp[k] = glnf_goal_comp[j]; - gfnumeric_goal_c[k] = glnf_goal_rh[j]; - continue; - } - if ( glnf_goal_comp[j] == GE ) { - gfnumeric_goal_comp[k] = GE; - } - } else { - gfnumeric_goal_comp[gnum_fnumeric_goal] = glnf_goal_comp[j]; - gfnumeric_goal_fl[gnum_fnumeric_goal] = glnf_goal_lh[j]->pF[0]; - gfnumeric_goal_c[gnum_fnumeric_goal++] = glnf_goal_rh[j]; - } - } - gfnumeric_goal_direct_comp = ( Comparator * ) calloc( gnum_fl_conn, sizeof( Comparator ) ); - for ( j = 0; j < gnum_fl_conn; j++ ) { - gfnumeric_goal_direct_comp[j] = IGUAL; - } - gfnumeric_goal_direct_c = ( float * ) calloc( gnum_fl_conn, sizeof( float ) ); - for ( k = 0; k < gnum_fnumeric_goal; k++ ) { - gfnumeric_goal_direct_comp[gfnumeric_goal_fl[k]] = gfnumeric_goal_comp[k]; - gfnumeric_goal_direct_c[gfnumeric_goal_fl[k]] = gfnumeric_goal_c[k]; - } - /*****************************GOAL - END********************************/ - - - - /******************** - * safety: if there are numeric precs/goals, need to turn - * cost-minimizing rplans off!!! - * (see comments with def of gcost_rplans - */ - for ( i = 0; i < gnum_ef_conn; i++ ) { - if ( gcost_rplans && gef_conn[i].num_f_PC > 0 ) { - printf("\nwarning: numeric precondition. turning cost-minimizing relaxed plans OFF."); - gcost_rplans = FALSE; - break; - } - } - if ( gcost_rplans && gnum_fnumeric_goal > 0 ) { - printf("\nwarning: numeric goal. turning cost-minimizing relaxed plans OFF."); - gcost_rplans = FALSE; - } - - - - - if ( gcmd_line.display_info == 125 ) { - printf("\n\ncreated connectivity graph as follows:"); - - printf("\n\n------------------OP ARRAY:-----------------------"); - for ( i = 0; i < gnum_op_conn; i++ ) { - printf("\n\nOP %d: ", i); - if ( gop_conn[i].axiom ) printf("(axiom) "); - print_op_name( i ); - printf(" cost %f", gop_conn[i].cost); - printf("\n----------EFFS:"); - for ( j = 0; j < gop_conn[i].num_E; j++ ) { - printf("\neffect %d", gop_conn[i].E[j]); - } - } - - printf("\n\n-------------------EFFECT ARRAY:----------------------"); - for ( i = 0; i < gnum_ef_conn; i++ ) { - printf("\n\neffect %d of op %d cost %f: ", i, gef_conn[i].op, gef_conn[i].cost); - print_op_name( gef_conn[i].op ); - if ( gef_conn[i].illegal ) printf(" ******ILLEGAL************************"); - if ( gef_conn[i].removed ) printf(" ******REMOVED************************"); - printf("\n----------PCS:"); - for ( j = 0; j < gef_conn[i].num_PC; j++ ) { - printf("\n"); - print_ft_name( gef_conn[i].PC[j] ); - } - printf("\n----------f_PCS:"); - for ( j = 0; j < gef_conn[i].num_f_PC; j++ ) { - printf("\n"); - print_fl_name( gef_conn[i].f_PC_fl[j] ); - if ( gef_conn[i].f_PC_comp[j] == GEQ ) { - printf(" >= "); - } else { - printf(" > "); - } - printf("%f", gef_conn[i].f_PC_c[j]); - } - printf("\nDIRECT: "); - for ( j = 0; j < gnum_fl_conn; j++ ) { - if ( gef_conn[i].f_PC_direct_comp[j] == IGUAL ) { - printf("IGUAL | "); - } - if ( gef_conn[i].f_PC_direct_comp[j] == GEQ ) { - printf(">= %f | ", gef_conn[i].f_PC_direct_c[j]); - } - if ( gef_conn[i].f_PC_direct_comp[j] == GE ) { - printf("> %f | ", gef_conn[i].f_PC_direct_c[j]); - } - } - if ( gef_conn[i].illegal ) continue; - printf("\n----------ADDS:"); - for ( j = 0; j < gef_conn[i].num_A; j++ ) { - printf("\n"); - print_ft_name( gef_conn[i].A[j] ); - } - printf("\n----------DELS:"); - for ( j = 0; j < gef_conn[i].num_D; j++ ) { - printf("\n"); - print_ft_name( gef_conn[i].D[j] ); - } - printf("\n----------INCREASE:"); - for ( j = 0; j < gef_conn[i].num_IN; j++ ) { - printf("\n"); - print_fl_name( gef_conn[i].IN_fl[j] ); - printf(" by "); - if ( gef_conn[i].IN_fl_[j] >= 0 ) { - print_fl_name( gef_conn[i].IN_fl_[j] ); - printf(" + %f", gef_conn[i].IN_c[j]); - } else { - printf("%f", gef_conn[i].IN_c[j]); - } - } - printf("\n----------ASSIGN:"); - for ( j = 0; j < gef_conn[i].num_AS; j++ ) { - printf("\n"); - print_fl_name( gef_conn[i].AS_fl[j] ); - printf(" to "); - if ( gef_conn[i].AS_fl_[j] >= 0 ) { - print_fl_name( gef_conn[i].AS_fl_[j] ); - printf(" + %f", gef_conn[i].AS_c[j]); - } else { - printf("%f", gef_conn[i].AS_c[j]); - } - } - printf("\n----------IMPLIEDS:"); - for ( j = 0; j < gef_conn[i].num_I; j++ ) { - printf("\nimplied effect %d of op %d: ", - gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op); - print_op_name( gef_conn[gef_conn[i].I[j]].op ); - } - } - - printf("\n\n----------------------FT ARRAY:-----------------------------"); - for ( i = 0; i < gnum_ft_conn; i++ ) { - printf("\n\nFT: "); - print_ft_name( i ); - printf(" rand: %d", gft_conn[i].rand); - printf(" --------- AXIOM ADDED %d", gft_conn[i].axiom_added); - printf("\n----------PRE COND OF:"); - for ( j = 0; j < gft_conn[i].num_PC; j++ ) { - printf("\neffect %d", gft_conn[i].PC[j]); - printf(" - op "); print_op_name( gef_conn[gft_conn[i].PC[j]].op ); - } - printf("\n----------ADD BY:"); - for ( j = 0; j < gft_conn[i].num_A; j++ ) { - printf("\neffect %d", gft_conn[i].A[j]); - printf(" - op "); print_op_name( gef_conn[gft_conn[i].A[j]].op ); - } - printf("\n----------DEL BY:"); - for ( j = 0; j < gft_conn[i].num_D; j++ ) { - printf("\neffect %d", gft_conn[i].D[j]); - printf(" - op "); print_op_name( gef_conn[gft_conn[i].D[j]].op ); - } - } - - printf("\n\n----------------------FLUENT ARRAY:-----------------------------"); - for ( i = 0; i < gnum_fl_conn; i++ ) { - printf("\n\nFL: "); - print_fl_name( i ); - printf("\n----------PRE COND OF:"); - for ( j = 0; j < gfl_conn[i].num_PC; j++ ) { - printf("\neffect %d", gfl_conn[i].PC[j]); - printf(" - op "); print_op_name( gef_conn[gfl_conn[i].PC[j]].op ); - } - printf("\n----------INCREASED BY:"); - for ( j = 0; j < gfl_conn[i].num_IN; j++ ) { - if ( gfl_conn[i].IN_fl_[j] == -1 ) { - printf("\neffect %d --- %f", gfl_conn[i].IN[j], gfl_conn[i].IN_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); - } else { - printf("\neffect %d --- ", gfl_conn[i].IN[j]); - print_fl_name( gfl_conn[i].IN_fl_[j] ); - printf(" + %f", gfl_conn[i].IN_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].IN[j]].op ); - } - } - printf("\n----------ASSIGNED BY:"); - for ( j = 0; j < gfl_conn[i].num_AS; j++ ) { - if ( gfl_conn[i].AS_fl_[j] == -1 ) { - printf("\neffect %d --- %f", gfl_conn[i].AS[j], gfl_conn[i].AS_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); - } else { - printf("\neffect %d --- ", gfl_conn[i].AS[j]); - print_fl_name( gfl_conn[i].AS_fl_[j] ); - printf(" + %f", gfl_conn[i].AS_c[j]); - printf(" --- op "); print_op_name( gef_conn[gfl_conn[i].AS[j]].op ); - } - } - if ( gfl_conn[i].artificial ) { - printf("\n----------ARTIFICIAL FOR:"); - for ( j = 0; j < gfl_conn[i].num_lnf; j++ ) { - printf(" %f*", gfl_conn[i].lnf_C[j]); - print_fl_name( gfl_conn[i].lnf_F[j] ); - if ( j < gfl_conn[i].num_lnf - 1 ) { - printf(" +"); - } - } - } else { - printf("\n----------REAL"); - } - } - - printf("\n\n----------------------GOAL:-----------------------------"); - for ( j = 0; j < gnum_flogic_goal; j++ ) { - printf("\n"); - print_ft_name( gflogic_goal[j] ); - } - for ( j = 0; j < gnum_fnumeric_goal; j++ ) { - printf("\n"); - print_fl_name( gfnumeric_goal_fl[j] ); - if ( gfnumeric_goal_comp[j] == GEQ ) { - printf(" >= "); - } else { - printf(" > "); - } - printf("%f", gfnumeric_goal_c[j]); - } - printf("\nDIRECT: "); - for ( j = 0; j < gnum_fl_conn; j++ ) { - if ( gfnumeric_goal_direct_comp[j] == IGUAL ) { - printf("IGUAL | "); - } - if ( gfnumeric_goal_direct_comp[j] == GEQ ) { - printf(">= %f | ", gfnumeric_goal_direct_c[j]); - } - if ( gfnumeric_goal_direct_comp[j] == GE ) { - printf("> %f | ", gfnumeric_goal_direct_c[j]); - } - } - - printf("\n\n"); - } - -} - - - diff --git a/gen/ff_planner/inst_final.h b/gen/ff_planner/inst_final.h deleted file mode 100644 index ab42b6097..000000000 --- a/gen/ff_planner/inst_final.h +++ /dev/null @@ -1,69 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/********************************************************************* - * File: inst_final.h - * Description: headers for final domain representation functions - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - -#ifndef _INST_FINAL_H -#define _INST_FINAL_H - - - -void perform_reachability_analysis( void ); -int fact_adress( void ); -void make_name_inst_table_from_NormOperator( Action *a, NormOperator *o, EasyTemplate *t ); -void make_name_inst_table_from_PseudoAction( Action *a, PseudoAction *pa ); - - - -void collect_relevant_facts_and_fluents( void ); -void create_final_goal_state( void ); -Bool set_relevants_in_wff( WffNode **w ); -Bool set_relevants_in_exp( ExpNode **n ); -void create_final_initial_state( void ); -void create_final_actions( void ); -void instantiate_exp_by_action( ExpNode **n, Action *a ); - - - -void build_connectivity_graph( void ); - - - -void summarize_effects( void ); -Bool same_condition( ActionEffect *e, ActionEffect *e_ ); -Bool same_lnfs( LnfExpNode *l, LnfExpNode *r ); -void merge_effects( ActionEffect *e, ActionEffect *e_ ); - - - -#endif /* _INST_FINAL_H */ diff --git a/gen/ff_planner/inst_hard.c b/gen/ff_planner/inst_hard.c deleted file mode 100644 index 54f63d752..000000000 --- a/gen/ff_planner/inst_hard.c +++ /dev/null @@ -1,1306 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - - -/********************************************************************* - * File: inst_hard.c - * Description: functions for multiplying hard operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_hard.h" - - - - - - - - - - - -/* used in multiplying routines - */ -int linst_table[MAX_VARS]; -int_pointer lini[MAX_PREDICATES]; - - - - - - - - -void build_hard_action_templates( void ) - -{ - - int i, j, size, adr; - MixedOperator *o; - - /* remove unused params; empty types are already recognised during - * domain translation; have to be handled after (or while) - * unaries encoding (if done), though. - */ - cleanup_hard_domain(); - - if ( gcmd_line.display_info == 115 ) { - printf("\n\ncleaned up hard domain representation is:\n\n"); - for ( i = 0; i < gnum_hard_operators; i++ ) { - print_Operator( ghard_operators[i] ); - } - fflush( stdout ); - } - - /* create local table of instantiated facts that occur in the - * initial state. for fast finding out if fact is in ini or not. - */ - for ( i = 0; i < gnum_predicates; i++ ) { - size = 1; - for ( j = 0; j < garity[i]; j++ ) { - size *= gnum_constants; - } - lini[i] = ( int_pointer ) calloc( size, sizeof( int ) ); - for ( j = 0; j < size; j++ ) { - lini[i][j] = 0; - } - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - adr = instantiated_fact_adress( &ginitial_predicate[i][j] ); - lini[i][adr]++; - } - } - - - /* create mixed op for each param combination - */ - multiply_hard_op_parameters(); - - if ( gcmd_line.display_info == 116 ) { - printf("\n\nmixed hard domain representation is:\n\n"); - for ( o = ghard_mixed_operators; o; o = o->next ) { - print_MixedOperator( o ); - } - fflush( stdout ); - } - - /* create pseudo op for each mixed op - */ - multiply_hard_effect_parameters(); - - if ( gcmd_line.display_info == 117 ) { - printf("\n\npseudo hard domain representation is:\n\n"); - for ( i = 0; i < gnum_hard_templates; i++ ) { - print_PseudoAction( ghard_templates[i] ); - } - fflush( stdout ); - } - - -} - - - - - - - - - - - - -/**************** - * CLEANUP CODE * - ****************/ - - - - - - - - - - - - -void cleanup_hard_domain( void ) - -{ - - int i, j, k, par; - Operator *o; - Effect *e; - - /* so far, only unused parameters removal - */ - - for ( i = 0; i < gnum_hard_operators; i++ ) { - o = ghard_operators[i]; - - j = 0; - while ( j < o->num_vars ) { - if ( var_used_in_wff( ENCODE_VAR( j ), o->preconds ) ) { - j++; - continue; - } - - for ( e = o->effects; e; e = e->next ) { - if ( var_used_in_wff( ENCODE_VAR( j ), e->conditions ) ) { - break; - } - if ( var_used_in_literals( ENCODE_VAR( j ), e->effects ) ) { - break; - } - if ( var_used_in_numeric_effects( ENCODE_VAR( j ), e->numeric_effects ) ) { - break; - } - } - if ( e ) { - j++; - continue; - } - - o->removed[j] = TRUE; - j++; - } - - for ( e = o->effects; e; e = e->next ) { - j = 0; - while ( j < e->num_vars ) { - par = o->num_vars + j; - if ( var_used_in_wff( ENCODE_VAR( par ), e->conditions ) ) { - j++; - continue; - } - if ( var_used_in_literals( ENCODE_VAR( par ), e->effects ) ) { - j++; - continue; - } - if ( var_used_in_numeric_effects( ENCODE_VAR( par ), e->numeric_effects ) ) { - j++; - continue; - } - - if ( e->var_names[j] ) { - free( e->var_names[j] ); - } - for ( k = j; k < e->num_vars - 1; k++ ) { - e->var_names[k] = e->var_names[k+1]; - e->var_names[k] = e->var_names[k+1]; - } - e->num_vars--; - decrement_inferior_vars( par, e->conditions ); - decrement_inferior_vars_in_literals( par, e->effects ); - decrement_inferior_vars_in_numeric_effects( par, e->numeric_effects ); - } - } - } - -} - - - -Bool var_used_in_literals( int code_var, Literal *ef ) - -{ - - Literal *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - if ( l->fact.args[i] == code_var ) { - return TRUE; - } - } - } - - return FALSE; - -} - - - -Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ) - -{ - - NumericEffect *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { - if ( l->fluent.args[i] == code_var ) { - return TRUE; - } - } - if ( var_used_in_exp( code_var, l->rh ) ) { - return TRUE; - } - } - - return FALSE; - -} - - - -void decrement_inferior_vars_in_literals( int var, Literal *ef ) - -{ - - Literal *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - if ( l->fact.args[i] >= 0 ) { - continue; - } - if ( DECODE_VAR( l->fact.args[i] ) > var ) { - l->fact.args[i]++; - } - } - } - -} - - - -void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ) - -{ - - NumericEffect *l; - int i; - - for ( l = ef; l; l = l->next ) { - for ( i = 0; i < gf_arity[l->fluent.function]; i++ ) { - if ( l->fluent.args[i] >= 0 ) { - continue; - } - if ( DECODE_VAR( l->fluent.args[i] ) > var ) { - l->fluent.args[i]++; - } - } - decrement_inferior_vars_in_exp( var, l->rh ); - } - -} - - - - - - - - - - - - - - -/****************************** - * CODE THAT BUILDS MIXED OPS * - ******************************/ - - - - - - - - - - - - - - -void multiply_hard_op_parameters( void ) - -{ - - int i; - - ghard_mixed_operators = NULL; - - for ( i = 0; i < MAX_VARS; i++ ) { - linst_table[i] = -1; - } - - for ( i = 0; i < gnum_hard_operators; i++ ) { - create_hard_mixed_operators( ghard_operators[i], 0 ); - } - -} - - - -void create_hard_mixed_operators( Operator *o, int curr_var ) - -{ - - int t, i, m, mn; - WffNode *tmp1, *w, *ww; - MixedOperator *tmp2; - - if ( curr_var < o->num_vars ) { - if ( o->removed[curr_var] ) { - /* param doesn't matter -- select any appropriate type constant - * at least one there; otherwise, op would not have been translated. - */ - linst_table[curr_var] = gtype_consts[o->var_types[curr_var]][0]; - create_hard_mixed_operators( o, curr_var + 1 ); - linst_table[curr_var] = -1; - return; - } - - t = o->var_types[curr_var]; - for ( i = 0; i < gtype_size[t]; i++ ) { - linst_table[curr_var] = gtype_consts[t][i]; - - create_hard_mixed_operators( o, curr_var + 1 ); - - linst_table[curr_var] = -1; - } - return; - } - - - tmp1 = instantiate_wff( o->preconds ); - - if ( tmp1->connective == FAL ) { - free_WffNode( tmp1 ); - return; - } - - dnf( &tmp1 ); - cleanup_wff( &tmp1 ); - - if ( tmp1->connective == FAL ) { - free_WffNode( tmp1 ); - return; - } - - /* only debugging, REMOVE LATER - */ - if ( is_dnf( tmp1 ) == -1 ) { - printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", o->name); - print_Wff( tmp1, 0 ); - exit( 1 ); - } - - switch ( tmp1->connective ) { - case OR: - for ( w = tmp1->sons; w; w = w->next ) { - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - if ( w->connective == AND ) { - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_preconds = m; - tmp2->num_numeric_preconds = mn; - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp2->preconds[m].predicate = ww->fact->predicate; - for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { - tmp2->preconds[m].args[i] = ww->fact->args[i]; - } - m++; - } - if ( ww->connective == COMP ) { - tmp2->numeric_preconds_comp[mn] = ww->comp; - tmp2->numeric_preconds_lh[mn] = copy_Exp( ww->lh ); - tmp2->numeric_preconds_rh[mn] = copy_Exp( ww->rh ); - mn++; - } - } - } else { - if ( w->connective == ATOM ) { - tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_preconds = 1; - tmp2->preconds[0].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->preconds[0].args[i] = w->fact->args[i]; - } - } - if ( w->connective == COMP ) { - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_comp[0] = w->comp; - tmp2->numeric_preconds_lh[0] = copy_Exp( w->lh ); - tmp2->numeric_preconds_rh[0] = copy_Exp( w->rh ); - tmp2->num_numeric_preconds = 1; - } - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - } - break; - case AND: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - m = 0; - mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) m++; - if ( w->connective == COMP ) mn++; - } - tmp2->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_preconds = m; - tmp2->num_numeric_preconds = mn; - m = 0; mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) { - tmp2->preconds[m].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->preconds[m].args[i] = w->fact->args[i]; - } - m++; - } - if ( w->connective == COMP ) { - tmp2->numeric_preconds_comp[mn] = w->comp; - tmp2->numeric_preconds_lh[mn] = copy_Exp( w->lh ); - tmp2->numeric_preconds_rh[mn] = copy_Exp( w->rh ); - mn++; - } - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - case ATOM: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - tmp2->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_preconds = 1; - tmp2->preconds[0].predicate = tmp1->fact->predicate; - for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { - tmp2->preconds[0].args[i] = tmp1->fact->args[i]; - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - case COMP: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - tmp2->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_preconds_comp[0] = tmp1->comp; - tmp2->numeric_preconds_lh[0] = copy_Exp( tmp1->lh ); - tmp2->numeric_preconds_rh[0] = copy_Exp( tmp1->rh ); - tmp2->num_numeric_preconds = 1; - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - case TRU: - tmp2 = new_MixedOperator( o ); - for ( i = 0; i < o->num_vars; i++ ) { - tmp2->inst_table[i] = linst_table[i]; - } - tmp2->effects = instantiate_Effect( o->effects ); - tmp2->next = ghard_mixed_operators; - ghard_mixed_operators = tmp2; - gnum_hard_mixed_operators++; - break; - default: - printf("\n\nillegal connective %d in parsing DNF precond.\n\n", - tmp1->connective); - exit( 1 ); - } - - free_WffNode( tmp1 ); - -} - - - -Effect *instantiate_Effect( Effect *e ) - -{ - - Effect *res = NULL, *tmp, *i; - Literal *tt, *l; - NumericEffect *ne, *ttt; - int j; - - for ( i = e; i; i = i->next ) { - tmp = new_Effect(); - - for ( j = 0; j < i->num_vars; j++ ) { - tmp->var_types[j] = i->var_types[j]; - } - tmp->num_vars = i->num_vars; - - tmp->conditions = instantiate_wff( i->conditions ); - - if ( tmp->conditions->connective == FAL ) { - free_partial_Effect( tmp ); - continue; - } - - for ( l = i->effects; l; l = l->next ) { - tt = new_Literal(); - tt->negated = l->negated; - tt->fact.predicate = l->fact.predicate; - for ( j = 0; j < garity[tt->fact.predicate]; j++ ) { - tt->fact.args[j] = l->fact.args[j]; - if ( tt->fact.args[j] < 0 && - linst_table[DECODE_VAR( tt->fact.args[j] )] != -1 ) { - tt->fact.args[j] = linst_table[DECODE_VAR( tt->fact.args[j] )]; - } - } - tt->next = tmp->effects; - if ( tmp->effects ) { - tmp->effects->prev = tt; - } - tmp->effects = tt; - } - - for ( ne = i->numeric_effects; ne; ne = ne->next ) { - ttt = new_NumericEffect(); - ttt->neft = ne->neft; - ttt->fluent.function = ne->fluent.function; - for ( j = 0; j < gf_arity[ttt->fluent.function]; j++ ) { - ttt->fluent.args[j] = ne->fluent.args[j]; - if ( ttt->fluent.args[j] < 0 && - linst_table[DECODE_VAR( ttt->fluent.args[j] )] != -1 ) { - ttt->fluent.args[j] = linst_table[DECODE_VAR( ttt->fluent.args[j] )]; - } - } - ttt->rh = copy_Exp( ne->rh ); - instantiate_exp( &(ttt->rh) ); - ttt->next = tmp->numeric_effects; - if ( tmp->numeric_effects ) { - tmp->numeric_effects->prev = ttt; - } - tmp->numeric_effects = ttt; - } - - tmp->next = res; - if ( res ) { - res->prev = tmp; - } - res = tmp; - } - - return res; - -} - - - -WffNode *instantiate_wff( WffNode *w ) - -{ - - WffNode *res = NULL, *tmp, *i; - int j, m, h; - Bool ok, ct; - - switch ( w->connective ) { - case AND: - m = 0; - i = w->sons; - while ( i ) { - tmp = instantiate_wff( i ); - if ( tmp->connective == FAL ) { - free_WffNode( res ); - return tmp; - } - if ( tmp->connective == TRU ) { - free( tmp ); - i = i->next; - continue; - } - tmp->next = res; - if ( res ) { - res->prev = tmp; - } - res = tmp; - i = i->next; - m++; - } - if ( m == 0 ) { - res = new_WffNode( TRU ); - break; - } - if ( m == 1 ) { - break; - } - tmp = new_WffNode( AND ); - tmp->sons = res; - res = tmp; - break; - case OR: - m = 0; - i = w->sons; - while ( i ) { - tmp = instantiate_wff( i ); - if ( tmp->connective == TRU ) { - free_WffNode( res ); - return tmp; - } - if ( tmp->connective == FAL ) { - free( tmp ); - i = i->next; - continue; - } - tmp->next = res; - if ( res ) { - res->prev = tmp; - } - res = tmp; - i = i->next; - m++; - } - if ( m == 0 ) { - res = new_WffNode( FAL ); - break; - } - if ( m == 1 ) { - break; - } - tmp = new_WffNode( OR ); - tmp->sons = res; - res = tmp; - break; - case ATOM: - res = new_WffNode( ATOM ); - res->fact = new_Fact(); - res->fact->predicate = w->fact->predicate; - ok = TRUE; - for ( j = 0; j < garity[res->fact->predicate]; j++ ) { - h = ( w->fact->args[j] < 0 ) ? - linst_table[DECODE_VAR( w->fact->args[j] )] : w->fact->args[j]; - if ( h < 0 ) { - ok = FALSE; - res->fact->args[j] = w->fact->args[j]; - } else { - res->fact->args[j] = h; - } - } - if ( !ok ) {/* contains ef params */ - break; - } - if ( !full_possibly_negative( res->fact ) ) { - free( res->fact ); - res->fact = NULL; - res->connective = TRU; - break; - } - if ( !full_possibly_positive( res->fact ) ) { - free( res->fact ); - res->fact = NULL; - res->connective = FAL; - break; - } - break; - case COMP: - res = new_WffNode( COMP ); - res->comp = w->comp; - res->lh = copy_Exp( w->lh ); - res->rh = copy_Exp( w->rh ); - instantiate_exp( &(res->lh) ); - instantiate_exp( &(res->rh) ); - if ( res->lh->connective != NUMBER || - res->rh->connective != NUMBER ) { - /* logical simplification only possible if both parts are numbers - */ - break; - } - ct = number_comparison_holds( res->comp, res->lh->value, res->rh->value ); - if ( ct ) { - res->connective = TRU; - free_ExpNode( res->lh ); - res->lh = NULL; - free_ExpNode( res->rh ); - res->rh = NULL; - res->comp = -1; - } else { - res->connective = FAL; - free_ExpNode( res->lh ); - res->lh = NULL; - free_ExpNode( res->rh ); - res->rh = NULL; - res->comp = -1; - } - break; - case TRU: - case FAL: - res = new_WffNode( w->connective ); - break; - default: - printf("\n\nillegal connective %d in instantiate formula\n\n", - w->connective); - exit( 1 ); - } - - return res; - -} - - - -void instantiate_exp( ExpNode **n ) - -{ - - int j, f, k, h; - Bool ok; - - switch ( (*n)->connective ) { - case AD: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - instantiate_exp( &((*n)->leftson) ); - instantiate_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - instantiate_exp( &((*n)->son) ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - f = (*n)->fluent->function; - ok = TRUE; - for ( j = 0; j < gf_arity[f]; j++ ) { - h = ( (*n)->fluent->args[j] < 0 ) ? - linst_table[DECODE_VAR( (*n)->fluent->args[j] )] : (*n)->fluent->args[j]; - if ( h < 0 ) { - ok = FALSE; - } else { - (*n)->fluent->args[j] = h; - } - } - if ( !ok ) { - break; - } - /* we handle only the case where the fluent is fully instantiated, - * static, and in the initial state. - */ - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\ninst exp: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -Bool full_possibly_positive( Fact *f ) - -{ - - int adr; - - if ( gis_added[f->predicate] ) { - return TRUE; - } - - adr = instantiated_fact_adress( f ); - - if ( lini[f->predicate][adr] > 0 ) { - return TRUE; - } else { - return FALSE; - } - -} - - - -Bool full_possibly_negative( Fact *f ) - -{ - - int adr; - - if ( gis_deleted[f->predicate] ) { - return TRUE; - } - - adr = instantiated_fact_adress( f ); - - if ( lini[f->predicate][adr] > 0 ) { - return FALSE; - } else { - return TRUE; - } - -} - - - -int instantiated_fact_adress( Fact *f ) - -{ - - int r = 0, b = 1, i; - - for ( i = 0; i < garity[f->predicate]; i++ ) { - r += b * f->args[i]; - b *= gnum_constants; - } - - return r; - -} - - - - - - - - - - - - - - -/********************************************************* - * CODE THAT MULTIPLIES EFFECT PARAMS --> PSEUDO ACTIONS * - *********************************************************/ - - - - - - - - - - - - - - - -void multiply_hard_effect_parameters( void ) - -{ - - MixedOperator *o; - PseudoAction *tmp; - int i; - Effect *e; - - ghard_templates = ( PseudoAction_pointer * ) - calloc( gnum_hard_mixed_operators, sizeof ( PseudoAction_pointer ) ); - gnum_hard_templates = 0; - - for ( o = ghard_mixed_operators; o; o = o->next ) { - tmp = new_PseudoAction( o ); - - for ( i = 0; i < tmp->operator->num_vars; i++ ) { - linst_table[i] = tmp->inst_table[i]; - } - - for ( e = o->effects; e; e = e->next ) { - create_hard_pseudo_effects( tmp, e, 0 ); - } - - ghard_templates[gnum_hard_templates++] = tmp; - } -} - - - -void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ) - -{ - - int par, t, i, m, mn; - WffNode *tmp1, *w, *ww; - PseudoActionEffect *tmp2; - - if ( curr_var < e->num_vars ) { - par = a->operator->num_vars + curr_var; - - t = e->var_types[curr_var]; - for ( i = 0; i < gtype_size[t]; i++ ) { - linst_table[par] = gtype_consts[t][i]; - - create_hard_pseudo_effects( a, e, curr_var + 1 ); - - linst_table[par] = -1; - } - return; - } - - tmp1 = instantiate_wff( e->conditions ); - - if ( tmp1->connective == FAL ) { - free_WffNode( tmp1 ); - return; - } - - dnf( &tmp1 ); - cleanup_wff( &tmp1 ); - - /* only debugging, REMOVE LATER - */ - if ( is_dnf( tmp1 ) == -1 ) { - printf("\n\nILLEGAL DNF %s AFTER INSTANTIATION\n\n", a->operator->name); - print_Wff( tmp1, 0 ); - exit( 1 ); - } - - switch ( tmp1->connective ) { - case OR: - for ( w = tmp1->sons; w; w = w->next ) { - tmp2 = new_PseudoActionEffect(); - if ( w->connective == AND ) { - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_conditions = m; - tmp2->num_numeric_conditions = mn; - m = 0; mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp2->conditions[m].predicate = ww->fact->predicate; - for ( i = 0; i < garity[ww->fact->predicate]; i++ ) { - tmp2->conditions[m].args[i] = ww->fact->args[i]; - } - m++; - } - if ( ww->connective == COMP ) { - tmp2->numeric_conditions_comp[mn] = ww->comp; - tmp2->numeric_conditions_lh[mn] = copy_Exp( ww->lh ); - tmp2->numeric_conditions_rh[mn] = copy_Exp( ww->rh ); - mn++; - } - } - } else { - if ( w->connective == ATOM ) { - tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_conditions = 1; - tmp2->conditions[0].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->conditions[0].args[i] = w->fact->args[i]; - } - } - if ( w->connective == COMP ) { - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_comp[0] = w->comp; - tmp2->numeric_conditions_lh[0] = copy_Exp( w->lh ); - tmp2->numeric_conditions_rh[0] = copy_Exp( w->rh ); - tmp2->num_numeric_conditions = 1; - } - } - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - } - break; - case AND: - tmp2 = new_PseudoActionEffect(); - m = 0; - mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) m++; - if ( w->connective == COMP ) mn++; - } - tmp2->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp2->num_conditions = m; - tmp2->num_numeric_conditions = mn; - m = 0; mn = 0; - for ( w = tmp1->sons; w; w = w->next ) { - if ( w->connective == ATOM ) { - tmp2->conditions[m].predicate = w->fact->predicate; - for ( i = 0; i < garity[w->fact->predicate]; i++ ) { - tmp2->conditions[m].args[i] = w->fact->args[i]; - } - m++; - } - if ( w->connective == COMP ) { - tmp2->numeric_conditions_comp[mn] = w->comp; - tmp2->numeric_conditions_lh[mn] = copy_Exp( w->lh ); - tmp2->numeric_conditions_rh[mn] = copy_Exp( w->rh ); - mn++; - } - } - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - case ATOM: - tmp2 = new_PseudoActionEffect(); - tmp2->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp2->num_conditions = 1; - tmp2->conditions[0].predicate = tmp1->fact->predicate; - for ( i = 0; i < garity[tmp1->fact->predicate]; i++ ) { - tmp2->conditions[0].args[i] = tmp1->fact->args[i]; - } - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - case COMP: - tmp2 = new_PseudoActionEffect(); - tmp2->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp2->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp2->numeric_conditions_comp[0] = tmp1->comp; - tmp2->numeric_conditions_lh[0] = copy_Exp( tmp1->lh ); - tmp2->numeric_conditions_rh[0] = copy_Exp( tmp1->rh ); - tmp2->num_numeric_conditions = 1; - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - case TRU: - tmp2 = new_PseudoActionEffect(); - make_instantiate_literals( tmp2, e->effects ); - make_instantiate_numeric_effects( tmp2, e->numeric_effects ); - tmp2->next = a->effects; - a->effects = tmp2; - a->num_effects++; - break; - default: - printf("\n\nillegal connective %d in parsing DNF condition.\n\n", - tmp1->connective); - exit( 1 ); - } - - free_WffNode( tmp1 ); - -} - - - -void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ) - -{ - - int ma = 0, md = 0, i; - Literal *l; - - for ( l = ll; l; l = l->next ) { - if ( l->negated ) { - md++; - } else { - ma++; - } - } - - e->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - e->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - - for ( l = ll; l; l = l->next ) { - if ( l->negated ) { - e->dels[e->num_dels].predicate = l->fact.predicate; - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - e->dels[e->num_dels].args[i] = ( l->fact.args[i] < 0 ) ? - linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; - } - e->num_dels++; - } else { - e->adds[e->num_adds].predicate = l->fact.predicate; - for ( i = 0; i < garity[l->fact.predicate]; i++ ) { - e->adds[e->num_adds].args[i] = ( l->fact.args[i] < 0 ) ? - linst_table[DECODE_VAR( l->fact.args[i] )] : l->fact.args[i]; - } - e->num_adds++; - } - } - -} - - - -void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ) - -{ - - int m = 0, i; - NumericEffect *n; - - for ( n = ne; n; n = n->next ) m++; - - e->numeric_effects_neft = ( NumericEffectType * ) calloc( m, sizeof( NumericEffectType ) ); - e->numeric_effects_fluent = ( Fluent * ) calloc( m, sizeof( Fluent ) ); - e->numeric_effects_rh = ( ExpNode_pointer * ) calloc( m, sizeof( ExpNode_pointer ) ); - e->num_numeric_effects = m; - - m = 0; - for ( n = ne; n; n = n->next ) { - e->numeric_effects_neft[m] = n->neft; - e->numeric_effects_fluent[m].function = n->fluent.function; - for ( i = 0; i < gf_arity[n->fluent.function]; i++ ) { - e->numeric_effects_fluent[m].args[i] = ( n->fluent.args[i] < 0 ) ? - linst_table[DECODE_VAR( n->fluent.args[i] )] : n->fluent.args[i]; - } - e->numeric_effects_rh[m] = copy_Exp( n->rh ); - instantiate_exp( &(e->numeric_effects_rh[m]) ); - m++; - } - -} diff --git a/gen/ff_planner/inst_hard.h b/gen/ff_planner/inst_hard.h deleted file mode 100644 index babebc20e..000000000 --- a/gen/ff_planner/inst_hard.h +++ /dev/null @@ -1,71 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: inst_hard.h - * Description: headers for multiplying hard operators. - * - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - -#ifndef _INST_HARD_H -#define _INST_HARD_H - - - -void build_hard_action_templates( void ); - - - -void cleanup_hard_domain( void ); -Bool var_used_in_literals( int code_var, Literal *ef ); -Bool var_used_in_numeric_effects( int code_var, NumericEffect *ef ); -void decrement_inferior_vars_in_literals( int var, Literal *ef ); -void decrement_inferior_vars_in_numeric_effects( int var, NumericEffect *ef ); - - - -void multiply_hard_op_parameters( void ); -void create_hard_mixed_operators( Operator *o, int curr_var ); -Effect *instantiate_Effect( Effect *e ); -WffNode *instantiate_wff( WffNode *w ); -void instantiate_exp( ExpNode **n ); -Bool full_possibly_positive( Fact *f ); -Bool full_possibly_negative( Fact *f ); -int instantiated_fact_adress( Fact *f ); - - - -void multiply_hard_effect_parameters( void ); -void create_hard_pseudo_effects( PseudoAction *a, Effect *e, int curr_var ); -void make_instantiate_literals( PseudoActionEffect *e, Literal *ll ); -void make_instantiate_numeric_effects( PseudoActionEffect *e, NumericEffect *ne ); - - - -#endif /* _INST_HARD_H */ diff --git a/gen/ff_planner/inst_pre.c b/gen/ff_planner/inst_pre.c deleted file mode 100644 index 3e6877200..000000000 --- a/gen/ff_planner/inst_pre.c +++ /dev/null @@ -1,3854 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - - -/********************************************************************* - * File: inst_pre.c - * Description: functions for instantiating operators, preprocessing part. - * - transform domain into integers - * - inertia preprocessing: - * - collect inertia info - * - split initial state in special arrays - * - Wff normalization: - * - simplification - * - quantifier expansion - * - NOT s down - * - negative preconditions translation - * - split operators into easy and hard to instantiate - * - * - full DNF functions, only feasible for fully instantiated - * formulae - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "inst_pre.h" - - - - - - - - - - - - - - - - - - -/******************************************************* - * TRANSFORM DOMAIN INTO INTEGER (FACT) REPRESENTATION * - *******************************************************/ - - - - - - - - - -char *lvar_names[MAX_VARS]; -int lvar_types[MAX_VARS]; - - - - - - - - - - -void encode_domain_in_integers( void ) - -{ - - int i,j; - - collect_all_strings(); - create_member_nrs(); - - if ( gcmd_line.display_info == 103 ) { - printf("\nconstant table:"); - for ( i = 0; i < gnum_constants; i++ ) { - printf("\n%d --> %s", i, gconstants[i]); - } - - printf("\n\ntypes table:"); - for ( i = 0; i < gnum_types; i++ ) { - printf("\n%d --> %s: ", i, gtype_names[i]); - for ( j = 0; j < gtype_size[i]; j++ ) { - printf("%d ", gtype_consts[i][j]); - } - } - - printf("\n\npredicates table:"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n%3d --> %s: ", i, gpredicates[i]); - for ( j = 0; j < garity[i]; j++ ) { - printf("%s ", gtype_names[gpredicates_args_type[i][j]]); - } - } - - printf("\n\nfunctions table:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n%3d --> %s: ", i, gfunctions[i]); - for ( j = 0; j < gf_arity[i]; j++ ) { - printf("%s ", gtype_names[gfunctions_args_type[i][j]]); - } - } - printf("\n\n"); - } - - create_integer_representation(); - - if ( gcmd_line.display_info == 104 ) { - printf("\n\nfirst step initial state is:"); - for ( i = 0; i < gnum_full_initial; i++ ) { - printf("\n"); - print_Fact( &(gfull_initial[i]) ); - } - printf("\n\nfirst step fluent initial state is:"); - for ( i = 0; i < gnum_full_fluents_initial; i++ ) { - printf("\n"); - print_Fluent( &(gfull_fluents_initial[i].fluent) ); - printf(": %f", gfull_fluents_initial[i].value); - } - - printf("\n\nfirst step operators are:"); - for ( i = 0; i < gnum_operators; i++ ) { - print_Operator( goperators[i] ); - } - printf("\n\n"); - - printf("\n\nfirst step goal is:\n"); - print_Wff( ggoal, 0 ); - fflush( stdout ); - - printf("\n\nfirst step metric is: (normalized to minimize)\n"); - print_ExpNode( gmetric ); - fflush( stdout ); - } - -} - - - -void create_member_nrs( void ) - -{ - - int i, j, num; - - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - for ( j = 0; j < MAX_TYPES; j++ ) { - gmember_nr[i][j] = -1; - } - } - - for ( i = 0; i < gnum_types; i++ ) { - num = 0; - for ( j = 0; j < gtype_size[i]; j++ ) { - gmember_nr[gtype_consts[i][j]][i] = num; - num++; - } - } - -} - - - -void collect_all_strings( void ) - -{ - - FactList *f; - TokenList *t; - int p_num, type_num, c_num, ar; - int i; - - /* first are types and their objects. for = we make sure that there - * is one type that contains all objects. - */ - gtype_names[0] = new_Token( 50 ); - gtype_names[0] = "ARTFICIAL-ALL-OBJECTS"; - gtype_size[0] = 0; - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - gis_member[i][0] = FALSE; - } - gnum_types = 1; - - for ( f = gorig_constant_list; f; f = f->next ) { - if ( (type_num = position_in_types_table( f->item->next->item )) == -1 ) { - if ( gnum_types == MAX_TYPES ) { - printf("\ntoo many types! increase MAX_TYPES (currently %d)\n\n", - MAX_TYPES); - exit( 1 ); - } - gtype_names[gnum_types] = new_Token( strlen( f->item->next->item ) + 1 ); - strcpy( gtype_names[gnum_types], f->item->next->item ); - gtype_size[gnum_types] = 0; - for ( i = 0; i < MAX_CONSTANTS; i++ ) { - gis_member[i][gnum_types] = FALSE; - } - type_num = gnum_types++; - } - - if ( (c_num = position_in_constants_table( f->item->item )) == -1 ) { - if ( gnum_constants == MAX_CONSTANTS ) { - printf("\ntoo many constants! increase MAX_CONSTANTS (currently %d)\n\n", - MAX_CONSTANTS); - exit( 1 ); - } - gconstants[gnum_constants] = new_Token( strlen( f->item->item ) + 1 ); - strcpy( gconstants[gnum_constants], f->item->item ); - c_num = gnum_constants++; - - /* all constants into 0-type. - */ - if ( gtype_size[0] == MAX_TYPE ) { - printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", - gtype_names[0], MAX_TYPE); - exit( 1 ); - } - gtype_consts[0][gtype_size[0]++] = c_num; - gis_member[c_num][0] = TRUE; - } - - if ( !gis_member[c_num][type_num] ) { - if ( gtype_size[type_num] == MAX_TYPE ) { - printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", - gtype_names[type_num], MAX_TYPE); - exit( 1 ); - } - gtype_consts[type_num][gtype_size[type_num]++] = c_num; - gis_member[c_num][type_num] = TRUE; - } - } - - /* next are predicates; first of all, create in-built predicate = - */ - gpredicates[0] = new_Token( 5 ); - gpredicates[0] = "="; - gpredicates_args_type[0][0] = 0;/* all objects type */ - gpredicates_args_type[0][1] = 0; - garity[0] = 2; - gnum_predicates = 1; - - for ( f = gpredicates_and_types; f; f = f->next ) { - if ( (p_num = position_in_predicates_table( f->item->item )) != -1 ) { - printf("\npredicate %s declared twice!\n\n", f->item->item); - exit( 1 ); - } - if ( gnum_predicates == MAX_PREDICATES ) { - printf("\ntoo many predicates! increase MAX_PREDICATES (currently %d)\n\n", - MAX_PREDICATES); - exit( 1 ); - } - gpredicates[gnum_predicates] = new_Token( strlen( f->item->item ) + 1 ); - strcpy( gpredicates[gnum_predicates], f->item->item ); - ar = 0; - for ( t = f->item->next; t; t = t->next ) { - if ( (type_num = position_in_types_table( t->item )) == -1 ) { - printf("\npredicate %s is declared to use unknown or empty type %s\n\n", - f->item->item, t->item); - exit( 1 ); - } - if ( ar == MAX_ARITY ) { - printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", - gpredicates[gnum_predicates], MAX_ARITY); - exit( 1 ); - } - gpredicates_args_type[gnum_predicates][ar++] = type_num; - } - garity[gnum_predicates] = ar; - gaxiom_added[gnum_predicates] = FALSE; - gnum_predicates++; - } - - - /* next are functions; first of all, create in-built function total-time - * for sole use in metric - */ - gfunctions[0] = new_Token( 20 ); - gfunctions[0] = "TOTAL-TIME"; - gf_arity[0] = 0; - gnum_functions = 1; - - for ( f = gfunctions_and_types; f; f = f->next ) { - if ( (p_num = position_in_functions_table( f->item->item )) != -1 ) { - printf("\nfunction %s declared twice!\n\n", f->item->item); - exit( 1 ); - } - if ( gnum_functions == MAX_FUNCTIONS ) { - printf("\ntoo many functions! increase MAX_FUNCTIONS (currently %d)\n\n", - MAX_FUNCTIONS); - exit( 1 ); - } - gfunctions[gnum_functions] = new_Token( strlen( f->item->item ) + 1 ); - strcpy( gfunctions[gnum_functions], f->item->item ); - ar = 0; - for ( t = f->item->next; t; t = t->next ) { - if ( (type_num = position_in_types_table( t->item )) == -1 ) { - printf("\nfunction %s is declared to use unknown or empty type %s\n\n", - f->item->item, t->item); - exit( 1 ); - } - if ( ar == MAX_ARITY ) { - printf("\narity of %s to high! increase MAX_ARITY (currently %d)\n\n", - gfunctions[gnum_functions], MAX_ARITY); - exit( 1 ); - } - gfunctions_args_type[gnum_functions][ar++] = type_num; - } - gf_arity[gnum_functions++] = ar; - } - - free_FactList( gorig_constant_list ); - free_FactList( gpredicates_and_types ); - free_FactList( gfunctions_and_types ); - -} - - - -int position_in_types_table( char *str ) - -{ - - int i; - - /* start at 1 because 0 is our artificial one - */ - for ( i = 1; i < gnum_types; i++ ) { - if ( str == gtype_names[i] || - (strcmp( str, gtype_names[i] ) == SAME) ) { - break; - } - } - - return ( i == gnum_types ) ? -1 : i; - -} - - - -int position_in_constants_table( char *str ) - -{ - - int i; - - for ( i=0; isons; n; n = n->next ) sum++; - sum += gnum_constants;/* space for equalities */ - gfull_initial = ( Fact * ) calloc( sum, sizeof( Fact ) ); - gfull_fluents_initial = ( FluentValue * ) - calloc( sum, sizeof( FluentValue )); - - for ( n = gorig_initial_facts->sons; n; n = n->next ) { - if ( n->connective == ATOM ) { - make_Fact( &(gfull_initial[gnum_full_initial]), n, 0 ); - if ( gfull_initial[gnum_full_initial].predicate == 0 ) { - printf("\nequality in initial state! check input files.\n\n"); - exit( 1 ); - } - - /* duplicate check!! - */ - for ( i = 0; i < gnum_full_initial; i++ ) { - if ( gfull_initial[i].predicate != gfull_initial[gnum_full_initial].predicate ) { - /* predicate different --> this ini fact is not a duplicate! - */ - continue; - } - for ( j = 0; j < garity[gfull_initial[i].predicate]; j++ ) { - if ( gfull_initial[i].args[j] != gfull_initial[gnum_full_initial].args[j] ) { - /* arg different --> this ini fact is not a duplicate! - */ - break; - } - } - if ( j == garity[gfull_initial[i].predicate] ) { - /* found a duplicate! - */ - break; - } - } - if ( i < gnum_full_initial ) { - /* simply skip the second occurence... - */ - continue; - } - - gnum_full_initial++; - } else { - /* a fluent value assignment - */ - make_Fluent( &(gfull_fluents_initial[gnum_full_fluents_initial].fluent), - n->lh->atom, 0 ); - gfull_fluents_initial[gnum_full_fluents_initial].value = - ( float ) strtod( n->rh->atom->item, NULL); - gnum_full_fluents_initial++; - } - } - free_PlNode( gorig_initial_facts ); - } - - /* now insert all our artificial equality constraints into initial state. - */ - for ( i = 0; i < gnum_constants; i++ ) { - gfull_initial[gnum_full_initial].predicate = 0; - gfull_initial[gnum_full_initial].args[0] = i; - gfull_initial[gnum_full_initial].args[1] = i; - gnum_full_initial++; - } - /* FINITO. the rest of equality handling will fully - * automatically be done by the rest of the machinery. - */ - - ggoal = make_Wff( gorig_goal_facts, 0 ); - - if ( gparse_metric != NULL ) { - /* no need to throw costs away, even if we're not explicitly asked to - * minimize them - */ - if ( 0 && !gcost_minimizing ) { - if ( gcmd_line.display_info ) { - printf("\n\nno optimization required. skipping criterion.\n\n"); - } - } else { - gmetric = make_ExpNode( gparse_metric, 0 ); - if ( strcmp( gparse_optimization, "MINIMIZE" ) != SAME && - strcmp( gparse_optimization, "minimize" ) != SAME && - strcmp( gparse_optimization, "MAXIMIZE" ) != SAME && - strcmp( gparse_optimization, "maximize" ) != SAME ) { - if ( gcmd_line.display_info ) { - printf("\n\nunknown optimization method %s. check input files\n\n", - gparse_optimization); - } - exit( 1 ); - } - if ( strcmp( gparse_optimization, "MAXIMIZE" ) == SAME || - strcmp( gparse_optimization, "maximize" ) == SAME ) { - t = new_ExpNode( MINUS ); - t->son = gmetric; - gmetric = t; - } - } - } - - for ( o = gloaded_ops; o; o = o->next ) { - tmp = new_Operator( o->name, o->number_of_real_params ); - tmp->axiom = o->axiom; - - for ( ff = o->params; ff; ff = ff->next ) { - if ( (type_num = position_in_types_table( ff->item->next->item )) == -1 ) { - printf("\nwarning: parameter %s of op %s has unknown or empty type %s. skipping op", - ff->item->item, o->name, ff->item->next->item); - break; - } - if ( tmp->num_vars == MAX_VARS ) { - printf("\ntoo many parameters! increase MAX_VARS (currently %d)\n\n", - MAX_VARS); - exit( 1 ); - } - for ( i = 0; i < tmp->num_vars; i++ ) { - if ( tmp->var_names[i] == ff->item->item || - strcmp( tmp->var_names[i], ff->item->item ) == SAME ) { - printf("\nwarning: operator %s parameter %s overwrites previous declaration\n\n", - tmp->name, ff->item->item); - } - } - tmp->var_names[tmp->num_vars] = new_Token( strlen( ff->item->item ) + 1 ); - strcpy( tmp->var_names[tmp->num_vars], ff->item->item ); - tmp->var_types[tmp->num_vars++] = type_num; - } - if ( ff ) { - free_Operator( tmp ); - continue; - } - - for ( i = 0; i < tmp->num_vars; i++ ) { - lvar_types[i] = tmp->var_types[i]; - lvar_names[i] = tmp->var_names[i]; - } - - tmp->preconds = make_Wff( o->preconds, tmp->num_vars ); - - if ( o->effects ) { - /* in make_effect, make sure that no one afects equality. - */ - nn = o->effects->sons; - while ( nn && - (tmp->effects = make_effect( nn, tmp->num_vars )) == NULL ) { - nn = nn->next; - } - if ( nn ) { - for ( n = nn->next; n; n = n->next ) { - if ( (tmp->effects->prev = make_effect( n, tmp->num_vars )) == NULL ) { - continue; - } - tmp->effects->prev->next = tmp->effects; - tmp->effects = tmp->effects->prev; - } - } - } - - if ( gnum_operators == MAX_OPERATORS ) { - printf("\ntoo many operators! increase MAX_OPERATORS (currently %d)\n\n", - MAX_OPERATORS); - exit( 1 ); - } - goperators[gnum_operators++] = tmp; - } - - if ( 0 ) { - /* currently not in use; leads to free memory reads and - * free memory frees (no memory leaks), which are hard to explain. - * - * almost no memory consumption anyway. - */ - free_PlOperator( gloaded_ops ); - } - - /* establish gaxiom_added markers. - * ascertain that derived predicates do not appear in effects!! - */ - for ( i = 0; i < gnum_operators; i++ ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - for ( l = e->effects; l; l = l->next ) { - if ( goperators[i]->axiom ) { - gaxiom_added[l->fact.predicate] = TRUE; - } - } - } - } - for ( i = 0; i < gnum_operators; i++ ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - for ( l = e->effects; l; l = l->next ) { - if ( !goperators[i]->axiom && - gaxiom_added[l->fact.predicate] ) { - printf("\nA derived predicate appears in an operator effect."); - printf("\nSorry, this is not allowed. Bailing out.\n\n"); - exit( 1 ); - } - } - } - } - -} - - - -void make_Fact( Fact *f, PlNode *n, int num_vars ) - -{ - - int m, i; - TokenList *t; - - if ( !n->atom ) { - /* can't happen after previous syntax check. Oh well, whatever... - */ - printf("\nillegal (empty) atom used in domain. check input files\n\n"); - exit( 1 ); - } - - f->predicate = position_in_predicates_table( n->atom->item ); - if ( f->predicate == -1 ) { - printf("\nundeclared predicate %s used in domain definition\n\n", - n->atom->item); - exit( 1 ); - } - - m = 0; - for ( t = n->atom->next; t; t = t->next ) { - if ( t->item[0] == '?' ) { - for ( i=num_vars-1; i>-1; i-- ) { - /* downwards, to always get most recent declaration/quantification - * of that variable - */ - if ( lvar_names[i] == t->item || - strcmp( lvar_names[i], t->item ) == SAME ) { - break; - } - } - if ( i == -1 ) { - printf("\nundeclared variable %s in literal %s. check input files\n\n", - t->item, n->atom->item); - exit( 1 ); - } - if ( lvar_types[i] != gpredicates_args_type[f->predicate][m] && - !is_subtype( lvar_types[i], gpredicates_args_type[f->predicate][m] ) ) { - printf("\ntype of var %s does not match type of arg %d of predicate %s\n\n", - lvar_names[i], m, gpredicates[f->predicate]); - exit( 1 ); - } - f->args[m] = ENCODE_VAR( i ); - } else { - if ( (f->args[m] = - position_in_constants_table( t->item )) == -1 ) { - printf("\nunknown constant %s in literal %s. check input files\n\n", - t->item, n->atom->item); - exit( 1 ); - } - if ( !gis_member[f->args[m]][gpredicates_args_type[f->predicate][m]] ) { - printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", - gconstants[f->args[m]], m, gpredicates[f->predicate]); - exit( 1 ); - } - } - m++; - } - if ( m != garity[f->predicate] ) { - printf("\npredicate %s is declared to have %d (not %d) arguments. check input files\n\n", - gpredicates[f->predicate], - garity[f->predicate], m); - exit( 1 ); - } - -} - - - -void make_Fluent( Fluent *f, TokenList *atom, int num_vars ) - -{ - - int m, i; - TokenList *t; - - if ( !atom ) { - /* can't happen after previous syntax check. Oh well, whatever... - */ - printf("\nillegal (empty) atom used in domain. check input files\n\n"); - exit( 1 ); - } - - f->function = position_in_functions_table( atom->item ); - if ( f->function == -1 ) { - printf("\nundeclared function %s used in domain definition\n\n", - atom->item); - exit( 1 ); - } - - m = 0; - for ( t = atom->next; t; t = t->next ) { - if ( t->item[0] == '?' ) { - for ( i=num_vars-1; i>-1; i-- ) { - /* downwards, to always get most recent declaration/quantification - * of that variable - */ - if ( lvar_names[i] == t->item || - strcmp( lvar_names[i], t->item ) == SAME ) { - break; - } - } - if ( i == -1 ) { - printf("\nundeclared variable %s in function %s. check input files\n\n", - t->item, atom->item); - exit( 1 ); - } - if ( lvar_types[i] != gfunctions_args_type[f->function][m] && - !is_subtype( lvar_types[i], gfunctions_args_type[f->function][m] ) ) { - printf("\ntype of var %s does not match type of arg %d of function %s\n\n", - lvar_names[i], m, gfunctions[f->function]); - exit( 1 ); - } - f->args[m] = ENCODE_VAR( i ); - } else { - if ( (f->args[m] = - position_in_constants_table( t->item )) == -1 ) { - printf("\nunknown constant %s in function %s. check input files\n\n", - t->item, atom->item); - exit( 1 ); - } - if ( !gis_member[f->args[m]][gfunctions_args_type[f->function][m]] ) { - printf("\ntype mismatch: constant %s as arg %d of %s. check input files\n\n", - gconstants[f->args[m]], m, gfunctions[f->function]); - exit( 1 ); - } - } - m++; - } - - if ( m != gf_arity[f->function] ) { - printf("\nfunction %s is declared to have %d (not %d) arguments. check input files\n\n", - gfunctions[f->function], - gf_arity[f->function], m); - exit( 1 ); - } - -} - - - -Bool is_subtype( int t1, int t2 ) - -{ - - int i; - - for ( i = 0; i < gtype_size[t1]; i++ ) { - if ( !gis_member[gtype_consts[t1][i]][t2] ) { - return FALSE; - } - } - - return TRUE; - -} - - - -WffNode *make_Wff( PlNode *p, int num_vars ) - -{ - - WffNode *tmp; - int i, t; - PlNode *n; - - if ( !p ) { - tmp = NULL; - return tmp; - } - - tmp = new_WffNode( p->connective ); - switch ( p->connective ) { - case ALL: - case EX: - for ( i = 0; i < num_vars; i++ ) { - if ( lvar_names[i] == p->atom->item || - strcmp( lvar_names[i], p->atom->item ) == SAME ) { - printf("\nwarning: var quantification of %s overwrites previous declaration\n\n", - p->atom->item); - } - } - if ( (t = position_in_types_table( p->atom->next->item )) == -1 ) { - printf("\nwarning: quantified var %s has unknown or empty type %s. simplifying.\n\n", - p->atom->item, p->atom->next->item); - tmp->connective = ( p->connective == EX ) ? FAL : TRU; - break; - } - tmp->var = num_vars; - tmp->var_type = t; - tmp->var_name = new_Token( strlen( p->atom->item ) + 1 ); - strcpy( tmp->var_name, p->atom->item ); - lvar_names[num_vars] = p->atom->item; - lvar_types[num_vars] = t; - tmp->son = make_Wff( p->sons, num_vars + 1 ); - break; - case AND: - case OR: - if ( !p->sons ) { - printf("\nwarning: empty con/disjunction in domain definition. simplifying.\n\n"); - tmp->connective = ( p->connective == OR ) ? FAL : TRU; - break; - } - tmp->sons = make_Wff( p->sons, num_vars ); - for ( n = p->sons->next; n; n = n->next ) { - tmp->sons->prev = make_Wff( n, num_vars ); - tmp->sons->prev->next = tmp->sons; - tmp->sons = tmp->sons->prev; - } - break; - case NOT: - tmp->son = make_Wff( p->sons, num_vars ); - break; - case ATOM: - tmp->fact = new_Fact(); - make_Fact( tmp->fact, p, num_vars ); - break; - case TRU: - case FAL: - break; - case COMP: - tmp->comp = p->comp; - tmp->lh = make_ExpNode( p->lh, num_vars ); - tmp->rh = make_ExpNode( p->rh, num_vars ); - break; - default: - printf("\nforbidden connective %d in Pl Wff. must be a bug somewhere...\n\n", - p->connective); - exit( 1 ); - } - - return tmp; - -} - - - -ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ) - -{ - - ExpNode *tmp; - - if ( !p ) { - tmp = NULL; - return tmp; - } - - tmp = new_ExpNode( p->connective ); - switch ( p->connective ) { - case AD: - case SU: - case MU: - case DI: - tmp->leftson = make_ExpNode( p->leftson, num_vars ); - tmp->rightson = make_ExpNode( p->rightson, num_vars ); - break; - case MINUS: - tmp->son = make_ExpNode( p->leftson, num_vars ); - break; - case NUMBER: - tmp->value = ( float ) strtod( p->atom->item, NULL ); - break; - case FHEAD: - tmp->fluent = new_Fluent(); - make_Fluent( tmp->fluent, p->atom, num_vars ); - break; - default: - printf("\n\nmake expnode: wrong specifier %d", - p->connective); - exit( 1 ); - } - - return tmp; - -} - - - -Effect *make_effect( PlNode *p, int num_vars ) - -{ - - Effect *tmp = new_Effect(); - PlNode *n, *m; - int t, i; - - for ( n = p; n && n->connective == ALL; n = n->sons ) { - if ( (t = position_in_types_table( n->atom->next->item )) == -1 ) { - printf("\nwarning: effect parameter %s has unknown or empty type %s. skipping effect.\n\n", - n->atom->item, n->atom->next->item); - return NULL; - } - for ( i = 0; i < num_vars + tmp->num_vars; i++ ) { - if ( lvar_names[i] == n->atom->item || - strcmp( lvar_names[i], n->atom->item ) == SAME ) { - printf("\nwarning: effect parameter %s overwrites previous declaration\n\n", - n->atom->item); - } - } - lvar_types[num_vars + tmp->num_vars] = t; - lvar_names[num_vars + tmp->num_vars] = n->atom->item; - tmp->var_names[tmp->num_vars] = new_Token( strlen( n->atom->item ) + 1 ); - strcpy( tmp->var_names[tmp->num_vars], n->atom->item ); - tmp->var_types[tmp->num_vars++] = t; - } - - if ( !n || n->connective != WHEN ) { - printf("\nnon WHEN %d at end of effect parameters. debug me\n\n", - n->connective); - exit( 1 ); - } - - tmp->conditions = make_Wff( n->sons, num_vars + tmp->num_vars ); - - if ( n->sons->next->connective != AND ) { - printf("\nnon AND %d in front of literal effect list. debug me\n\n", - n->sons->next->connective); - exit( 1 ); - } - if ( !n->sons->next->sons ) { - return tmp; - } - for ( m = n->sons->next->sons; m; m = m->next ) { - if ( m->connective == NEF ) { - if ( tmp->numeric_effects != NULL ) { - tmp->numeric_effects->prev = new_NumericEffect(); - make_Fluent( &(tmp->numeric_effects->prev->fluent), - m->lh->atom, num_vars + tmp->num_vars ); - tmp->numeric_effects->prev->neft = m->neft; - tmp->numeric_effects->prev->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); - - tmp->numeric_effects->prev->next = tmp->numeric_effects; - tmp->numeric_effects = tmp->numeric_effects->prev; - } else { - tmp->numeric_effects = new_NumericEffect(); - make_Fluent( &(tmp->numeric_effects->fluent), - m->lh->atom, num_vars + tmp->num_vars ); - tmp->numeric_effects->neft = m->neft; - tmp->numeric_effects->rh = make_ExpNode( m->rh, num_vars + tmp->num_vars ); - } - } else { - if ( tmp->effects != NULL ) { - tmp->effects->prev = new_Literal(); - if ( m->connective == NOT ) { - tmp->effects->prev->negated = TRUE; - make_Fact( &(tmp->effects->prev->fact), m->sons, num_vars + tmp->num_vars ); - if ( (tmp->effects->prev->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } else { - tmp->effects->prev->negated = FALSE; - make_Fact( &(tmp->effects->prev->fact), m, num_vars + tmp->num_vars ); - if ( (tmp->effects->prev->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } - tmp->effects->prev->next = tmp->effects; - tmp->effects = tmp->effects->prev; - } else { - tmp->effects = new_Literal(); - if ( m->connective == NOT ) { - tmp->effects->negated = TRUE; - make_Fact( &(tmp->effects->fact), m->sons, num_vars + tmp->num_vars ); - if ( (tmp->effects->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } else { - tmp->effects->negated = FALSE; - make_Fact( &(tmp->effects->fact), m, num_vars + tmp->num_vars ); - if ( (tmp->effects->fact).predicate == 0 ) { - printf("\n\nequality in effect! check input files!\n\n"); - exit( 1 ); - } - } - } - } - } - - return tmp; - -} - - - - - - - - - - - -/************************* - * INERTIA PREPROCESSING * - *************************/ - - - - - - - - - - - -void do_inertia_preprocessing_step_1( void ) - -{ - - int i, j; - Facts *f; - FluentValues *ff; - - collect_inertia_information(); - - if ( gcmd_line.display_info == 105 ) { - printf("\n\npredicates inertia info:"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n%3d --> %s: ", i, gpredicates[i]); - printf(" is %s, %s", - gis_added[i] ? "ADDED" : "NOT ADDED", - gis_deleted[i] ? "DELETED" : "NOT DELETED"); - } - printf("\n\nfunctions inertia info:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n%3d --> %s: ", i, gfunctions[i]); - printf(" is %s", - gis_changed[i] ? "CHANGED" : "NOT CHANGED"); - } - printf("\n\n"); - } - - split_initial_state(); - - if ( gcmd_line.display_info == 106 ) { - printf("\n\nsplitted initial state is:"); - printf("\nindividual predicates:"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n\n%s:", gpredicates[i]); - if ( !gis_added[i] && - !gis_deleted[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - printf("\n"); - print_Fact( &(ginitial_predicate[i][j]) ); - } - } - printf("\n\nnon static part:"); - for ( f = ginitial; f; f = f->next ) { - printf("\n"); - print_Fact( f->fact ); - } - - printf("\n\nextended types table:"); - for ( i = 0; i < gnum_types; i++ ) { - printf("\n%d --> ", i); - if ( gpredicate_to_type[i] == -1 ) { - printf("%s ", gtype_names[i]); - } else { - printf("UNARY INERTIA TYPE (%s) ", gpredicates[gpredicate_to_type[i]]); - } - for ( j = 0; j < gtype_size[i]; j++ ) { - printf("%d ", gtype_consts[i][j]); - } - } - - printf("\nindividual functions:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n\n%s:", gfunctions[i]); - if ( !gis_changed[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_function[i]; j++ ) { - printf("\n"); - print_Fluent( &(ginitial_function[i][j].fluent) ); - printf(": %f", ginitial_function[i][j].value); - } - } - printf("\n\nnon static part:"); - for ( ff = gf_initial; ff; ff = ff->next ) { - printf("\n"); - print_Fluent( &(ff->fluent) ); - printf(": %f", ff->value); - } - } - -} - - - -void collect_inertia_information( void ) - -{ - - int i; - Effect *e; - Literal *l; - NumericEffect *ne; - - for ( i = 0; i < gnum_predicates; i++ ) { - gis_added[i] = FALSE; - gis_deleted[i] = FALSE; - } - for ( i = 0; i < gnum_functions; i++ ) { - gis_changed[i] = FALSE; - } - - for ( i = 0; i < gnum_operators; i++ ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - gis_deleted[l->fact.predicate] = TRUE; - } else { - gis_added[l->fact.predicate] = TRUE; - } - } - for ( ne = e->numeric_effects; ne; ne = ne->next ) { - gis_changed[ne->fluent.function] = TRUE; - } - } - } - -} - - - -void split_initial_state( void ) - -{ - - int i, j, p, t; - Facts *tmp; - FluentValues *ftmp; - - for ( i = 0; i < MAX_PREDICATES; i++ ) { - gtype_to_predicate[i] = -1; - } - for ( i = 0; i < MAX_TYPES; i++ ) { - gpredicate_to_type[i] = -1; - } - - for ( i = 0; i < gnum_predicates; i++ ) { - if ( !gis_added[i] && - !gis_deleted[i] && - garity[i] == 1 ) { - if ( gnum_types == MAX_TYPES ) { - printf("\ntoo many (inferred) types! increase MAX_TYPES (currently %d)\n\n", - MAX_TYPES); - exit( 1 ); - } - gtype_to_predicate[i] = gnum_types; - gpredicate_to_type[gnum_types] = i; - gtype_names[gnum_types] = NULL; - gtype_size[gnum_types] = 0; - for ( j = 0; j < MAX_CONSTANTS; j++ ) { - gis_member[j][gnum_types] = FALSE; - } - gnum_types++; - } - } - - - /* double size of predicates table as each predicate might need - * to be translated to NOT-p - */ - ginitial_predicate = ( Fact ** ) calloc( gnum_predicates * 2, sizeof( Fact * ) ); - gnum_initial_predicate = ( int * ) calloc( gnum_predicates * 2, sizeof( int ) ); - for ( i = 0; i < gnum_predicates * 2; i++ ) { - gnum_initial_predicate[i] = 0; - } - for ( i = 0; i < gnum_full_initial; i++ ) { - p = gfull_initial[i].predicate; - gnum_initial_predicate[p]++; - } - for ( i = 0; i < gnum_predicates; i++ ) { - ginitial_predicate[i] = ( Fact * ) calloc( gnum_initial_predicate[i], sizeof( Fact ) ); - gnum_initial_predicate[i] = 0; - } - ginitial = NULL; - gnum_initial = 0; - - for ( i = 0; i < gnum_full_initial; i++ ) { - p = gfull_initial[i].predicate; - ginitial_predicate[p][gnum_initial_predicate[p]].predicate = p; - for ( j = 0; j < garity[p]; j++ ) { - ginitial_predicate[p][gnum_initial_predicate[p]].args[j] = gfull_initial[i].args[j]; - } - gnum_initial_predicate[p]++; - if ( gis_added[p] || - gis_deleted[p] ) { - tmp = new_Facts(); - tmp->fact->predicate = p; - for ( j = 0; j < garity[p]; j++ ) { - tmp->fact->args[j] = gfull_initial[i].args[j]; - } - tmp->next = ginitial; - ginitial = tmp; - gnum_initial++; - } else { - if ( garity[p] == 1 ) { - t = gtype_to_predicate[p]; - if ( gtype_size[t] == MAX_TYPE ) { - printf("\ntoo many consts in type %s! increase MAX_TYPE (currently %d)\n\n", - gtype_names[t], MAX_TYPE); - exit( 1 ); - } - if ( !gis_member[gfull_initial[i].args[0]][gpredicates_args_type[p][0]] ) { - printf("\ntype mismatch in initial state! %s as arg 0 of %s\n\n", - gconstants[gfull_initial[i].args[0]], gpredicates[p]); - exit( 1 ); - } - gtype_consts[t][gtype_size[t]++] = gfull_initial[i].args[0]; - gis_member[gfull_initial[i].args[0]][t] = TRUE; - } - } - } - - ginitial_function = ( FluentValue ** ) - calloc( gnum_functions, sizeof( FluentValue * ) ); - gnum_initial_function = ( int * ) calloc( gnum_functions, sizeof( int ) ); - for ( i = 0; i < gnum_functions; i++ ) { - gnum_initial_function[i] = 0; - } - for ( i = 0; i < gnum_full_fluents_initial; i++ ) { - p = gfull_fluents_initial[i].fluent.function; - gnum_initial_function[p]++; - } - for ( i = 0; i < gnum_functions; i++ ) { - ginitial_function[i] = ( FluentValue * ) - calloc( gnum_initial_function[i], sizeof( FluentValue ) ); - gnum_initial_function[i] = 0; - } - gf_initial = NULL; - gnum_f_initial = 0; - - for ( i = 0; i < gnum_full_fluents_initial; i++ ) { - p = gfull_fluents_initial[i].fluent.function; - ginitial_function[p][gnum_initial_function[p]].fluent.function = p; - for ( j = 0; j < gf_arity[p]; j++ ) { - ginitial_function[p][gnum_initial_function[p]].fluent.args[j] = - gfull_fluents_initial[i].fluent.args[j]; - } - ginitial_function[p][gnum_initial_function[p]].value = - gfull_fluents_initial[i].value; - gnum_initial_function[p]++; - if ( gis_changed[p] ) { - ftmp = new_FluentValues(); - ftmp->fluent.function = p; - for ( j = 0; j < gf_arity[p]; j++ ) { - ftmp->fluent.args[j] = gfull_fluents_initial[i].fluent.args[j]; - } - ftmp->value = gfull_fluents_initial[i].value; - ftmp->next = gf_initial; - gf_initial = ftmp; - gnum_f_initial++; - } - } - -} - - - - - - - - - - - -/****************************** - * NORMALIZE ALL PL1 FORMULAE * - ******************************/ - - - - - - - - - - - - -void normalize_all_wffs( void ) - -{ - - int i; - Effect *e; - - simplify_wff( &ggoal ); - remove_unused_vars_in_wff( &ggoal ); - expand_quantifiers_in_wff( &ggoal, -1, -1 ); - NOTs_down_in_wff( &ggoal ); - cleanup_wff( &ggoal ); - - if ( ggoal->connective == TRU ) { - printf("\nff: goal can be simplified to TRUE. The empty plan solves it\n\n"); - gnum_plan_ops = 0; - exit( 1 ); - } - if ( ggoal->connective == FAL ) { - printf("\nff: goal can be simplified to FALSE. No plan will solve it\n\n"); - exit( 1 ); - } - - /* put goal into DNF right away: fully instantiated already - */ - dnf( &ggoal ); - cleanup_wff( &ggoal ); - - /* all we can do here is simplify if that's possible. - */ - if ( gmetric != NULL ) { - simplify_exp( &gmetric ); - } - - - for ( i = 0; i < gnum_operators; i++ ) { - simplify_wff( &(goperators[i]->preconds) ); - remove_unused_vars_in_wff( &(goperators[i]->preconds) ); - expand_quantifiers_in_wff( &(goperators[i]->preconds), -1, -1 ); - NOTs_down_in_wff( &(goperators[i]->preconds) ); - cleanup_wff( &(goperators[i]->preconds) ); - - for ( e = goperators[i]->effects; e; e = e->next ) { - simplify_wff( &(e->conditions) ); - remove_unused_vars_in_wff( &(e->conditions) ); - expand_quantifiers_in_wff( &(e->conditions), -1, -1 ); - NOTs_down_in_wff( &(e->conditions) ); - cleanup_wff( &(e->conditions) ); - } - } - - if ( gcmd_line.display_info == 107 ) { - printf("\n\ndomain with normalized PL1 formula:"); - - printf("\n\noperators are:"); - for ( i = 0; i < gnum_operators; i++ ) { - print_Operator( goperators[i] ); - } - printf("\n\n"); - - printf("\n\ngoal is:\n"); - print_Wff( ggoal, 0 ); - - if ( gmetric ) { - printf("\n\nmetric is (minimize):\n"); - print_ExpNode( gmetric ); - } else { - printf("\n\nmetric: none, i.e. plan length\n"); - } - } - -} - - - -void remove_unused_vars_in_wff( WffNode **w ) - -{ - - WffNode *tmp; - WffNode *i; - - switch ( (*w)->connective ) { - case ALL: - case EX: - remove_unused_vars_in_wff( &((*w)->son) ); - if ( !var_used_in_wff( ENCODE_VAR( (*w)->var ), (*w)->son ) ) { - decrement_inferior_vars((*w)->var, (*w)->son ); - (*w)->connective = (*w)->son->connective; - (*w)->var = (*w)->son->var; - (*w)->var_type = (*w)->son->var_type; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = (*w)->son->var_name; - (*w)->sons = (*w)->son->sons; - if ( (*w)->fact ) { - free( (*w)->fact ); - } - (*w)->fact = (*w)->son->fact; - (*w)->comp = (*w)->son->comp; - if ( (*w)->lh ) free_ExpNode( (*w)->lh ); - if ( (*w)->rh ) free_ExpNode( (*w)->rh ); - (*w)->lh = (*w)->son->lh; - (*w)->rh = (*w)->son->rh; - - tmp = (*w)->son; - (*w)->son = (*w)->son->son; - free( tmp ); - } - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - remove_unused_vars_in_wff( &i ); - } - break; - case NOT: - remove_unused_vars_in_wff( &((*w)->son) ); - break; - case COMP: - case ATOM: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: remove var, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -Bool var_used_in_wff( int code_var, WffNode *w ) - -{ - - WffNode *i; - int j; - - switch ( w->connective ) { - case ALL: - case EX: - return var_used_in_wff( code_var, w->son ); - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - if ( var_used_in_wff( code_var, i ) ) { - return TRUE; - } - } - return FALSE; - case NOT: - return var_used_in_wff( code_var, w->son ); - case ATOM: - for ( j = 0; j < garity[w->fact->predicate]; j++ ) { - if ( w->fact->args[j] >= 0 ) { - continue; - } - if ( w->fact->args[j] == code_var ) { - return TRUE; - } - } - return FALSE; - case COMP: - if ( var_used_in_exp( code_var, w->lh ) ) { - return TRUE; - } - if ( var_used_in_exp( code_var, w->rh ) ) { - return TRUE; - } - return FALSE; - case TRU: - case FAL: - return FALSE; - default: - printf("\nwon't get here: var used ?, non logical %d\n\n", - w->connective); - exit( 1 ); - } - - -} - - - -Bool var_used_in_exp( int code_var, ExpNode *n ) - -{ - - int i; - - switch ( n->connective ) { - case AD: - case SU: - case MU: - case DI: - if ( var_used_in_exp( code_var, n->leftson ) || - var_used_in_exp( code_var, n->rightson ) ) { - return TRUE; - } - return FALSE; - case MINUS: - if ( var_used_in_exp( code_var, n->son ) ) { - return TRUE; - } - return FALSE; - case NUMBER: - return FALSE; - case FHEAD: - if ( n->fluent ) { - for ( i = 0; i < gf_arity[n->fluent->function]; i++ ) { - if ( n->fluent->args[i] >= 0 ) { - continue; - } - if ( n->fluent->args[i] == code_var ) { - return TRUE; - } - } - } else { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - } - return FALSE; - default: - printf("\n\nvar used in expnode: wrong specifier %d", - n->connective); - exit( 1 ); - } - -} - - - -void decrement_inferior_vars( int var, WffNode *w ) - -{ - - WffNode *i; - int j; - - switch ( w->connective ) { - case ALL: - case EX: - w->var--; - decrement_inferior_vars( var, w->son ); - break; - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - decrement_inferior_vars( var, i ); - } - break; - case NOT: - decrement_inferior_vars( var, w->son ); - break; - case ATOM: - for ( j = 0; j < garity[w->fact->predicate]; j++ ) { - if ( w->fact->args[j] >= 0 ) { - continue; - } - if ( DECODE_VAR( w->fact->args[j] ) > var ) { - w->fact->args[j]++; - } - } - break; - case COMP: - decrement_inferior_vars_in_exp( var, w->lh ); - decrement_inferior_vars_in_exp( var, w->rh ); - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: decrement, non logical %d\n\n", - w->connective); - exit( 1 ); - } - -} - - - -void decrement_inferior_vars_in_exp( int var, ExpNode *n ) - -{ - - int j; - - switch ( n->connective ) { - case AD: - case SU: - case MU: - case DI: - decrement_inferior_vars_in_exp( var, n->leftson ); - decrement_inferior_vars_in_exp( var, n->rightson ); - break; - case MINUS: - decrement_inferior_vars_in_exp( var, n->son ); - break; - case NUMBER: - break; - case FHEAD: - if ( n->fluent ) { - for ( j = 0; j < gf_arity[n->fluent->function]; j++ ) { - if ( n->fluent->args[j] >= 0 ) { - continue; - } - if ( DECODE_VAR( n->fluent->args[j] ) > var ) { - n->fluent->args[j]++; - } - } - } else { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - } - break; - default: - printf("\n\ndecr inf vars in expnode: wrong specifier %d", - n->connective); - exit( 1 ); - } - -} - - - -void simplify_wff( WffNode **w ) - -{ - - WffNode *i, *tmp; - int m; - Bool ct; - - switch ( (*w)->connective ) { - case ALL: - case EX: - simplify_wff( &((*w)->son) ); - if ( (*w)->son->connective == TRU || - (*w)->son->connective == FAL ) { - (*w)->connective = (*w)->son->connective; - free( (*w)->son ); - (*w)->son = NULL; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - } - break; - case AND: - m = 0; - i = (*w)->sons; - while ( i ) { - simplify_wff( &i ); - if ( i->connective == FAL ) { - (*w)->connective = FAL; - /* free_WffNode( (*w)->sons ); */ - (*w)->sons = NULL; - return; - } - if ( i->connective == TRU ) { - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - if ( i->next ) { - i->next->prev = i->prev; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - m++; - } - if ( m == 0 ) { - (*w)->connective = TRU; - free_WffNode( (*w)->sons ); - (*w)->sons = NULL; - } - if ( m == 1 ) { - (*w)->connective = (*w)->sons->connective; - (*w)->var = (*w)->sons->var; - (*w)->var_type = (*w)->sons->var_type; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = (*w)->sons->var_name; - (*w)->son = (*w)->sons->son; - if ( (*w)->fact ) { - free( (*w)->fact ); - } - (*w)->fact = (*w)->sons->fact; - (*w)->comp = (*w)->sons->comp; - if ( (*w)->lh ) free_ExpNode( (*w)->lh ); - if ( (*w)->rh ) free_ExpNode( (*w)->rh ); - (*w)->lh = (*w)->sons->lh; - (*w)->rh = (*w)->sons->rh; - - tmp = (*w)->sons; - (*w)->sons = (*w)->sons->sons; - free( tmp ); - } - break; - case OR: - m = 0; - i = (*w)->sons; - while ( i ) { - simplify_wff( &i ); - if ( i->connective == TRU ) { - (*w)->connective = TRU; - free_WffNode( (*w)->sons ); - (*w)->sons = NULL; - return; - } - if ( i->connective == FAL ) { - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - if ( i->next ) { - i->next->prev = i->prev; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - m++; - } - if ( m == 0 ) { - (*w)->connective = FAL; - /* free_WffNode( (*w)->sons ); */ - (*w)->sons = NULL; - } - if ( m == 1 ) { - (*w)->connective = (*w)->sons->connective; - (*w)->var = (*w)->sons->var; - (*w)->var_type = (*w)->sons->var_type; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = (*w)->sons->var_name; - (*w)->son = (*w)->sons->son; - if ( (*w)->fact ) { - free( (*w)->fact ); - } - (*w)->fact = (*w)->sons->fact; - (*w)->comp = (*w)->sons->comp; - if ( (*w)->lh ) free_ExpNode( (*w)->lh ); - if ( (*w)->rh ) free_ExpNode( (*w)->rh ); - (*w)->lh = (*w)->sons->lh; - (*w)->rh = (*w)->sons->rh; - - tmp = (*w)->sons; - (*w)->sons = (*w)->sons->sons; - free( tmp ); - } - break; - case NOT: - simplify_wff( &((*w)->son) ); - if ( (*w)->son->connective == TRU || - (*w)->son->connective == FAL ) { - (*w)->connective = ( (*w)->son->connective == TRU ) ? FAL : TRU; - free( (*w)->son ); - (*w)->son = NULL; - } - break; - case ATOM: - if ( (*w)->visited ) { - /* already seen and not changed - */ - break; - } - if ( !possibly_negative( (*w)->fact ) ) { - (*w)->connective = TRU; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - if ( !possibly_positive( (*w)->fact ) ) { - (*w)->connective = FAL; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - (*w)->visited = TRUE; - break; - case COMP: - simplify_exp( &((*w)->lh) ); - simplify_exp( &((*w)->rh) ); - if ( (*w)->lh->connective != NUMBER || - (*w)->rh->connective != NUMBER ) { - /* logical simplification only possible if both parts are numbers - */ - break; - } - ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); - if ( ct ) { - (*w)->connective = TRU; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } else { - (*w)->connective = FAL; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: simplify, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void simplify_exp( ExpNode **n ) - -{ - - int j, f, k; - - switch ( (*n)->connective ) { - case AD: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - simplify_exp( &((*n)->leftson) ); - simplify_exp( &((*n)->rightson) ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - simplify_exp( &((*n)->son) ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - if ( !(*n)->fluent ) { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - break; - } - f = (*n)->fluent->function; - for ( j = 0; j < gf_arity[f]; j++ ) { - if ( (*n)->fluent->args[j] < 0 ) { - break; - } - } - if ( j < gf_arity[f] ) { - break; - } - /* we handle only the case where the fluent is fully instantiated, - * static, and in the initial state. - */ - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\nsimplify expnode: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -void expand_quantifiers_in_wff( WffNode **w, int var, int constant ) - -{ - - WffNode *r = NULL, *tmp, *i; - int j, l; - Bool change, ct; - - if ( !(*w) ) { - return; - } - - switch ( (*w)->connective ) { - case ALL: - case EX: - if ( var != -1 ) {/* depth first: upper node is active */ - expand_quantifiers_in_wff( &((*w)->son), var, constant ); - return; - } - - (*w)->connective = ( (*w)->connective == ALL ) ? AND : OR; - for ( j = 0; j < gtype_size[(*w)->var_type]; j++ ) { - tmp = copy_Wff( (*w)->son ); - expand_quantifiers_in_wff( &tmp, (*w)->var, gtype_consts[(*w)->var_type][j] ); - tmp->next = r; - if ( r ) { - r->prev = tmp; - } - r = tmp; - } - - free_WffNode( (*w)->son ); - (*w)->sons = r; - (*w)->var = -1; - (*w)->var_type = -1; - if ( (*w)->var_name ) { - free( (*w)->var_name ); - } - (*w)->var_name = NULL; - - /* now make all sons expand their quantifiers - */ - for ( i = (*w)->sons; i; i = i->next ) { - expand_quantifiers_in_wff( &i, -1, -1 ); - } - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - expand_quantifiers_in_wff( &i, var, constant ); - } - break; - case NOT: - expand_quantifiers_in_wff( &((*w)->son), var, constant ); - break; - case ATOM: - if ( var == -1 ) { - break; - } - - change = FALSE; - for ( l = 0; l < garity[(*w)->fact->predicate]; l++ ) { - if ( (*w)->fact->args[l] == ENCODE_VAR( var ) ) { - (*w)->fact->args[l] = constant; - change = TRUE; - } - } - if ( !change && (*w)->visited ) { - /* we did not change anything and we've already seen that node - * --> it cant be simplified - */ - break; - } - if ( !possibly_negative( (*w)->fact ) ) { - (*w)->connective = TRU; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - if ( !possibly_positive( (*w)->fact ) ) { - (*w)->connective = FAL; - free( (*w)->fact ); - (*w)->fact = NULL; - break; - } - (*w)->visited = TRUE; - break; - case COMP: - if ( var == -1 ) { - break; - } - - replace_var_with_const_in_exp( &((*w)->lh), var, constant ); - replace_var_with_const_in_exp( &((*w)->rh), var, constant ); - if ( (*w)->lh->connective != NUMBER || - (*w)->rh->connective != NUMBER ) { - /* logical simplification only possible if both parts are numbers - */ - break; - } - ct = number_comparison_holds( (*w)->comp, (*w)->lh->value, (*w)->rh->value ); - if ( ct ) { - (*w)->connective = TRU; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } else { - (*w)->connective = FAL; - free_ExpNode( (*w)->lh ); - (*w)->lh = NULL; - free_ExpNode( (*w)->rh ); - (*w)->rh = NULL; - (*w)->comp = -1; - break; - } - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: expansion, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ) - -{ - - int j, f, k; - - switch ( (*n)->connective ) { - case AD: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value + (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case SU: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value - (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MU: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value * (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case DI: - replace_var_with_const_in_exp( &((*n)->leftson), var, constant ); - replace_var_with_const_in_exp( &((*n)->rightson), var, constant ); - if ( (*n)->leftson->connective != NUMBER || - (*n)->rightson->connective != NUMBER ) { - break; - } - if ( (*n)->rightson->value == 0 ) { - /* kind of unclean: simply leave that in here; - * we will later determine the right thing - * to do with it. - */ - break; - } - (*n)->connective = NUMBER; - (*n)->value = (*n)->leftson->value / (*n)->rightson->value; - free_ExpNode( (*n)->leftson ); - (*n)->leftson = NULL; - free_ExpNode( (*n)->rightson ); - (*n)->rightson = NULL; - break; - case MINUS: - replace_var_with_const_in_exp( &((*n)->son), var, constant ); - if ( (*n)->son->connective != NUMBER ) break; - (*n)->connective = NUMBER; - (*n)->value = ((float) (-1)) * (*n)->son->value; - free_ExpNode( (*n)->son ); - (*n)->son = NULL; - break; - case NUMBER: - break; - case FHEAD: - if ( !(*n)->fluent ) { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - break; - } - f = (*n)->fluent->function; - for ( j = 0; j < gf_arity[f]; j++ ) { - if ( (*n)->fluent->args[j] == ENCODE_VAR( var ) ) { - (*n)->fluent->args[j] = constant; - } - } - for ( j = 0; j < gf_arity[f]; j++ ) { - if ( (*n)->fluent->args[j] < 0 ) { - break; - } - } - if ( j < gf_arity[f] ) { - break; - } - /* we handle only the case where the fluent is fully instantiated, - * static, and in the initial state. - */ - if ( gis_changed[f] ) break; - for ( j = 0; j < gnum_initial_function[f]; j++ ) { - for ( k = 0; k < gf_arity[f]; k++ ) { - if ( ginitial_function[f][j].fluent.args[k] != - (*n)->fluent->args[k] ) break; - } - if ( k < gf_arity[f] ) continue; - (*n)->connective = NUMBER; - (*n)->value = ginitial_function[f][j].value; - break; - } - break; - default: - printf("\n\nreplace var with const in expnode: wrong specifier %d", - (*n)->connective); - exit( 1 ); - } - -} - - - -WffNode *copy_Wff( WffNode *w ) - -{ - - WffNode *tmp, *tmp2, *i; - int j; - - tmp = new_WffNode( w->connective ); - - switch ( w->connective ) { - case ALL: - case EX: - tmp->var = w->var; - tmp->var_type = w->var_type; - tmp->son = copy_Wff( w->son ); - break; - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - tmp2 = copy_Wff( i ); - if ( tmp->sons ) { - tmp->sons->prev = tmp2; - } - tmp2->next = tmp->sons; - tmp->sons = tmp2; - } - break; - case NOT: - tmp->son = copy_Wff( w->son ); - break; - case ATOM: - tmp->fact = new_Fact(); - tmp->fact->predicate = w->fact->predicate; - for ( j = 0; j < garity[w->fact->predicate]; j++ ) { - tmp->fact->args[j] = w->fact->args[j]; - } - tmp->visited = w->visited; - break; - case COMP: - tmp->comp = w->comp; - tmp->lh = copy_Exp( w->lh ); - tmp->rh = copy_Exp( w->rh ); - break; - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: copy, non logical %d\n\n", - w->connective); - exit( 1 ); - } - - return tmp; - -} - - - -ExpNode *copy_Exp( ExpNode *n ) - -{ - - ExpNode *tmp; - int i; - - tmp = new_ExpNode( n->connective ); - - switch ( n->connective ) { - case AD: - case SU: - case MU: - case DI: - tmp->leftson = copy_Exp( n->leftson ); - tmp->rightson = copy_Exp( n->rightson ); - break; - case MINUS: - tmp->son = copy_Exp( n->son ); - break; - case NUMBER: - tmp->value = n->value; - break; - case FHEAD: - if ( n->fluent ) { - tmp->fluent = new_Fluent(); - tmp->fluent->function = n->fluent->function; - for ( i = 0; i < gf_arity[tmp->fluent->function]; i++ ) { - tmp->fluent->args[i] = n->fluent->args[i]; - } - } else { - /* in the case that this is called from ahead, where fluents - * have been replaced with their identifiers - */ - tmp->fl = n->fl; - } - break; - default: - printf("\n\ncopy expnode: wrong specifier %d", - n->connective); - exit( 1 ); - } - - return tmp; - -} - - - -Bool possibly_positive( Fact *f ) - -{ - - int i; - - if ( gis_added[f->predicate] ) { - return TRUE; - } - - for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { - if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { - return TRUE; - } - } - - return FALSE; - -} - - - -Bool possibly_negative( Fact *f ) - -{ - - int i; - - if ( gis_deleted[f->predicate] ) { - return TRUE; - } - - for ( i = 0; i < garity[f->predicate]; i++ ) { - if ( f->args[i] < 0 ) { - return TRUE; - } - } - - for ( i = 0; i < gnum_initial_predicate[f->predicate]; i++ ) { - if ( matches( f, &(ginitial_predicate[f->predicate][i]) ) ) { - return FALSE; - } - } - - return TRUE; - -} - - - -Bool matches( Fact *f1, Fact *f2 ) - -{ - - int i; - - for ( i = 0; i < garity[f1->predicate]; i++ ) { - if ( f1->args[i] >= 0 ) { - if ( f2->args[i] >= 0 && - f1->args[i] != f2->args[i] ) { - return FALSE; - } - } - } - - return TRUE; - -} - - - -void cleanup_wff( WffNode **w ) - -{ - - merge_ANDs_and_ORs_in_wff( w ); - detect_tautologies_in_wff( w ); - simplify_wff( w ); - detect_tautologies_in_wff( w ); - merge_ANDs_and_ORs_in_wff( w ); - -} - - - -void detect_tautologies_in_wff( WffNode **w ) - -{ - - WffNode *i, *j, *tmp; - - switch ( (*w)->connective ) { - case ALL: - case EX: - detect_tautologies_in_wff( &((*w)->son) ); - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - detect_tautologies_in_wff( &i ); - } - for ( i = (*w)->sons; i && i->next; i = i->next ) { - j = i->next; - while ( j ) { - if ( are_identical_ATOMs( i, j ) ) { - j->prev->next = j->next; - if ( j->next ) { - j->next->prev = j->prev; - } - tmp = j; - j = j->next; - if ( tmp->fact ) { - free( tmp->fact ); - } - free( tmp ); - continue; - } - if ( i->connective == NOT && - are_identical_ATOMs( i->son, j ) ) { - (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; - free_WffNode( (*w)->son ); - (*w)->son = NULL; - return; - } - if ( j->connective == NOT && - are_identical_ATOMs( i, j->son ) ) { - (*w)->connective = ( (*w)->connective == AND ) ? FAL : TRU; - free_WffNode( (*w)->son ); - (*w)->son = NULL; - return; - } - j = j->next; - } - } - break; - case NOT: - detect_tautologies_in_wff( &((*w)->son) ); - break; - case ATOM: - case COMP: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: tautologies, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ) - -{ - - int i; - - if ( w1->connective != ATOM || - w2->connective != ATOM ) { - return FALSE; - } - - if ( w1->fact->predicate != w2->fact->predicate ) { - return FALSE; - } - - for ( i = 0; i < garity[w1->fact->predicate]; i++ ) { - if ( w1->fact->args[i] != w2->fact->args[i] ) { - return FALSE; - } - } - - return TRUE; - -} - - - -void merge_ANDs_and_ORs_in_wff( WffNode **w ) - -{ - - WffNode *i, *j, *tmp; - - switch ( (*w)->connective ) { - case ALL: - case EX: - merge_ANDs_and_ORs_in_wff( &((*w)->son) ); - break; - case AND: - case OR: - i = (*w)->sons; - while ( i ) { - merge_ANDs_and_ORs_in_wff( &i ); - if ( i->connective == (*w)->connective ) { - if ( !(i->sons) ) { - if ( i->next ) { - i->next->prev = i->prev; - } - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - for ( j = i->sons; j->next; j = j->next ); - j->next = i->next; - if ( i->next ) { - i->next->prev = j; - } - if ( i->prev ) { - i->prev->next = i->sons; - i->sons->prev = i->prev; - } else { - (*w)->sons = i->sons; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - } - break; - case NOT: - merge_ANDs_and_ORs_in_wff( &((*w)->son) ); - break; - case COMP: - case ATOM: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: merge, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void NOTs_down_in_wff( WffNode **w ) - -{ - - WffNode *tmp1, *tmp2, *i; - - switch ( (*w)->connective ) { - case ALL: - case EX: - printf("\ntrying to put nots down in quantified formula! debug me\n\n"); - exit( 1 ); - break; - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - NOTs_down_in_wff( &i ); - } - break; - case NOT: - if ( (*w)->son->connective == NOT ) { - (*w)->connective = (*w)->son->son->connective; - (*w)->fact = (*w)->son->son->fact; - (*w)->comp = (*w)->son->son->comp; - (*w)->lh = (*w)->son->son->lh; - (*w)->rh = (*w)->son->son->rh; - tmp1 = (*w)->son; - tmp2 = (*w)->son->son; - (*w)->sons = (*w)->son->son->sons; - (*w)->son = (*w)->son->son->son; - /* don't need to remember (*w)->son->son->next: this is empty because - * otherwise the resp. father, (*w)->son, would have been an - * AND or OR - */ - free( tmp1 ); - free( tmp2 ); - NOTs_down_in_wff( w ); - break; - } - if ( (*w)->son->connective == AND || - (*w)->son->connective == OR ) { - (*w)->connective = ( (*w)->son->connective == AND ) ? OR : AND; - (*w)->sons = (*w)->son->sons; - free( (*w)->son ); - (*w)->son = NULL; - for ( i = (*w)->sons; i; i = i->next ) { - tmp1 = new_WffNode( i->connective ); - tmp1->son = i->son; - tmp1->sons = i->sons; - tmp1->fact = i->fact; - tmp1->comp = i->comp; - tmp1->lh = i->lh; - tmp1->rh = i->rh; - i->connective = NOT; - i->son = tmp1; - i->sons = NULL; - i->fact = NULL; - i->comp = -1; - i->lh = NULL; - i->rh = NULL; - NOTs_down_in_wff( &i ); - } - break; - } - if ( (*w)->son->connective == COMP ) { - if ( (*w)->son->comp != EQ ) { - (*w)->connective = COMP; - (*w)->lh = (*w)->son->lh; - (*w)->rh = (*w)->son->rh; - switch ( (*w)->son->comp ) { - case LE: - (*w)->comp = GEQ; - break; - case LEQ: - (*w)->comp = GE; - break; - case GEQ: - (*w)->comp = LE; - break; - case GE: - (*w)->comp = LEQ; - break; - default: - printf("\n\nillegal comparator not EQ %d in nots down", - (*w)->son->comp); - exit( 1 ); - } - free( (*w)->son ); - (*w)->son = NULL; - } else { - (*w)->connective = OR; - (*w)->sons = (*w)->son; - (*w)->son = NULL; - (*w)->sons->comp = LE; - tmp1 = new_WffNode( COMP ); - tmp1->lh = copy_Exp( (*w)->sons->lh ); - tmp1->rh = copy_Exp( (*w)->sons->rh ); - tmp1->comp = GE; - tmp1->prev = (*w)->sons; - (*w)->sons->next = tmp1; - } - } - break; - case COMP: - case ATOM: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: nots down, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - - -} - - - - - - - - - - - -/**************************************************** - * NEGATIVE PRE- AND EFFECT- CONDITIONS TRANSLATION * - ****************************************************/ - - - - - - - - -int lconsts[MAX_ARITY]; - - - - - - - - -void translate_negative_preconds( void ) - -{ - - int i, j; - Effect *e; - Facts *f; - FluentValues *ff; - - while ( translate_one_negative_cond( ggoal ) ); - - for ( i = 0; i < gnum_operators; i++ ) { - while ( translate_one_negative_cond( goperators[i]->preconds ) ); - - for ( e = goperators[i]->effects; e; e = e->next ) { - while ( translate_one_negative_cond( e->conditions ) ); - } - } - - if ( gcmd_line.display_info == 108 ) { - printf("\n\ndomain with translated negative conds:"); - - printf("\n\noperators are:"); - for ( i = 0; i < gnum_operators; i++ ) { - print_Operator( goperators[i] ); - } - printf("\n\n"); - - printf("\ninitial state is:\n"); - for ( f = ginitial; f; f = f->next ) { - printf("\n"); - print_Fact( f->fact ); - } - printf("\n"); - for ( ff = gf_initial; ff; ff = ff->next ) { - printf("\n"); - print_Fluent( &(ff->fluent) ); - printf(": %f", ff->value); - } - printf("\n\n"); - - printf("\n\nindividual predicates:\n"); - for ( i = 0; i < gnum_predicates; i++ ) { - printf("\n\n%s:", gpredicates[i]); - if ( !gis_added[i] && - !gis_deleted[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_predicate[i]; j++ ) { - printf("\n"); - print_Fact( &(ginitial_predicate[i][j]) ); - } - } - printf("\n\nindividual functions:"); - for ( i = 0; i < gnum_functions; i++ ) { - printf("\n\n%s:", gfunctions[i]); - if ( !gis_changed[i] ) { - printf(" --- STATIC"); - } - for ( j = 0; j < gnum_initial_function[i]; j++ ) { - printf("\n"); - print_Fluent( &(ginitial_function[i][j].fluent) ); - printf(": %f", ginitial_function[i][j].value); - } - } - printf("\n\n"); - - printf("\n\ngoal is:\n"); - print_Wff( ggoal, 0 ); - printf("\n\n"); - } - -} - - - -Bool translate_one_negative_cond( WffNode *w ) - -{ - - WffNode *i; - int p, j, k, m; - Effect *e; - Literal *l, *tmp; - - switch ( w->connective ) { - case ALL: - case EX: - printf("\ntranslating NOT in quantified formula! debug me\n\n"); - exit( 1 ); - case AND: - case OR: - for ( i = w->sons; i; i = i->next ) { - if ( translate_one_negative_cond( i ) ) { - return TRUE; - } - } - return FALSE; - case NOT: - if ( w->son->fact->predicate == -1 ) { - return FALSE; - } - break; - case COMP: - case ATOM: - case TRU: - case FAL: - return FALSE; - default: - printf("\nwon't get here: translate one neg cond, non logical %d\n\n", - w->connective); - exit( 1 ); - } - - - if ( gnum_predicates == MAX_PREDICATES ) { - printf("\ntoo many predicates in translation! increase MAX_PREDICATES (currently %d)\n\n", - MAX_PREDICATES); - exit( 1 ); - } - p = w->son->fact->predicate; - /* safety check: we disallow negative conds on derived preds!! - */ - if ( gaxiom_added[p]) { - printf("\nA derived predicate appears negated in the negation normal form of a derivation rule condition, an operator precondition, or the goal."); - printf("\nSorry, this version of FF does not allow any of this. Bailing out.\n\n"); - exit( 1 ); - } else { - printf("\ntranslating negated cond for predicate %s", gpredicates[p]); - } - - gpredicates[gnum_predicates] = new_Token( strlen( gpredicates[p] ) + 5 ); - sprintf( gpredicates[gnum_predicates], "NOT-%s", gpredicates[p] ); - garity[gnum_predicates] = garity[p]; - for ( j = 0; j < garity[p]; j++ ) { - gpredicates_args_type[gnum_predicates][j] = - gpredicates_args_type[p][j]; - } - gis_added[gnum_predicates] = FALSE; - gis_deleted[gnum_predicates] = FALSE; - m = 1; - for ( j = 0; j < garity[gnum_predicates]; j++ ) { - m *= gtype_size[gpredicates_args_type[gnum_predicates][j]]; - } - ginitial_predicate[gnum_predicates] = ( Fact * ) calloc( m, sizeof( Fact ) ); - gnum_predicates++; - - - replace_not_p_with_n_in_wff( p, gnum_predicates - 1, &ggoal ); - - for ( j = 0; j < gnum_operators; j++ ) { - replace_not_p_with_n_in_wff( p, gnum_predicates - 1, - &(goperators[j]->preconds) ); - - for ( e = goperators[j]->effects; e; e = e->next ) { - replace_not_p_with_n_in_wff( p, gnum_predicates - 1, - &(e->conditions) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->fact.predicate != p ) { - continue; - } - tmp = new_Literal(); - if ( l->negated ) { - tmp->negated = FALSE; - gis_added[gnum_predicates - 1] = TRUE; - } else { - tmp->negated = TRUE; - gis_deleted[gnum_predicates - 1] = TRUE; - } - tmp->fact.predicate = gnum_predicates - 1; - for ( k = 0; k < garity[p]; k++ ) { - tmp->fact.args[k] = l->fact.args[k]; - } - if ( l->prev ) { - tmp->prev = l->prev; - tmp->prev->next = tmp; - } else { - e->effects = tmp; - } - tmp->next = l; - l->prev = tmp; - } - } - } - - add_to_initial_state( p, gnum_predicates - 1, 0 ); - - return TRUE; - -} - - - -void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ) - -{ - - WffNode *i; - - switch ( (*w)->connective ) { - case ALL: - case EX: - printf("\nreplacing p with NOT-p in quantified formula! debug me\n\n"); - exit( 1 ); - case AND: - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - replace_not_p_with_n_in_wff( p, n, &i ); - } - break; - case NOT: - if ( (*w)->son->fact->predicate == p ) { - (*w)->connective = ATOM; - (*w)->NOT_p = p; - (*w)->fact = (*w)->son->fact; - (*w)->fact->predicate = n; - free( (*w)->son ); - (*w)->son = NULL; - } - break; - case ATOM: - case COMP: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: replace p with NOT-p, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void add_to_initial_state( int p, int n, int index ) - -{ - - int i, j; - Facts *tmp; - - if ( index == garity[p] ) { - /* see if contrary fact is there in ini - */ - for ( i = 0; i < gnum_initial_predicate[p]; i++ ) { - for ( j = 0; j < garity[p]; j++ ) { - if ( ginitial_predicate[p][i].args[j] != lconsts[j] ) { - break; - } - } - if ( j == garity[p] ) { - break; - } - } - if ( i < gnum_initial_predicate[p] ) { - return; - } - - /* no: add new fact to ini - */ - ginitial_predicate[n][gnum_initial_predicate[n]].predicate = n; - for ( i = 0; i < garity[n]; i++ ) { - ginitial_predicate[n][gnum_initial_predicate[n]].args[i] = lconsts[i]; - } - gnum_initial_predicate[n]++; - - if ( !gis_added[n] && - !gis_deleted[n] ) { - return; - } - - tmp = new_Facts(); - tmp->fact->predicate = n; - for ( i = 0; i < garity[p]; i++ ) { - tmp->fact->args[i] = lconsts[i]; - } - tmp->next = ginitial; - ginitial = tmp; - gnum_initial++; - return; - } - - for ( i = 0; i < gtype_size[gpredicates_args_type[p][index]]; i++ ) { - lconsts[index] = gtype_consts[gpredicates_args_type[p][index]][i]; - add_to_initial_state( p, n, index + 1 ); - } - -} - - - - - - - - - - - -/******************************************************************* - * SPLIT DOMAIN IN PREPARATION FOR SEPARATE INSTANTIATION ROUTINES * - *******************************************************************/ - - - - - - - - - - -void split_domain( void ) - -{ - - int i, j, m, s = 0, mn; - Effect *e; - WffNode *w, *ww, *www; - NormOperator *tmp_op; - Fact *tmp_ft; - - for ( i = 0; i < MAX_TYPES; i++ ) { - gnum_intersected_types[i] = -1; - } - - for ( i = 0; i < gnum_operators; i++ ) { - if ( (m = is_dnf( goperators[i]->preconds )) != -1 ) { - for ( e = goperators[i]->effects; e; e = e->next ) { - if ( is_dnf( e->conditions ) == -1 ) { - break; - } - } - if ( !e ) { - goperators[i]->hard = FALSE; - s += m; - } - } - } - - ghard_operators = ( Operator_pointer * ) calloc( MAX_OPERATORS, sizeof( Operator ) ); - gnum_hard_operators = 0; - geasy_operators = ( NormOperator_pointer * ) calloc( s, sizeof( NormOperator_pointer ) ); - gnum_easy_operators = 0; - - for ( i = 0; i < gnum_operators; i++ ) { - if ( goperators[i]->hard ) { - ghard_operators[gnum_hard_operators++] = goperators[i]; - continue; - } - w = goperators[i]->preconds; - switch ( w->connective ) { - case OR: - for ( ww = w->sons; ww; ww = ww->next ) { - tmp_op = new_NormOperator( goperators[i] ); - if ( ww->connective == AND ) { - m = 0; - mn = 0; - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) m++; - if ( www->connective == COMP ) mn++; - } - tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) { - tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); - tmp_ft->predicate = www->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = www->fact->args[j]; - } - tmp_op->num_preconds++; - } - if ( www->connective == COMP ) { - tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = www->comp; - tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( www->lh ); - tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( www->rh ); - tmp_op->num_numeric_preconds++; - } - } - } else { - if ( ww->connective == ATOM ) { - tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_op->preconds[0]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_op->num_preconds = 1; - } - if ( ww->connective == COMP ) { - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_comp[0] = ww->comp; - tmp_op->numeric_preconds_lh[0] = copy_Exp( ww->lh ); - tmp_op->numeric_preconds_rh[0] = copy_Exp( ww->rh ); - tmp_op->num_numeric_preconds = 1; - } - } - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - } - break; - case AND: - tmp_op = new_NormOperator( goperators[i] ); - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp_op->preconds = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp_ft = &(tmp_op->preconds[tmp_op->num_preconds]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_op->num_preconds++; - } - if ( ww->connective == COMP ) { - tmp_op->numeric_preconds_comp[tmp_op->num_numeric_preconds] = ww->comp; - tmp_op->numeric_preconds_lh[tmp_op->num_numeric_preconds] = copy_Exp( ww->lh ); - tmp_op->numeric_preconds_rh[tmp_op->num_numeric_preconds] = copy_Exp( ww->rh ); - tmp_op->num_numeric_preconds++; - } - } - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case ATOM: - tmp_op = new_NormOperator( goperators[i] ); - tmp_op->preconds = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_op->preconds[0]); - tmp_ft->predicate = w->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = w->fact->args[j]; - } - tmp_op->num_preconds = 1; - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case COMP: - tmp_op = new_NormOperator( goperators[i] ); - tmp_op->numeric_preconds_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_op->numeric_preconds_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_op->numeric_preconds_comp[0] = w->comp; - tmp_op->numeric_preconds_lh[0] = copy_Exp( w->lh ); - tmp_op->numeric_preconds_rh[0] = copy_Exp( w->rh ); - tmp_op->num_numeric_preconds = 1; - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case TRU: - tmp_op = new_NormOperator( goperators[i] ); - make_normal_effects( &tmp_op, goperators[i] ); - geasy_operators[gnum_easy_operators++] = tmp_op; - break; - case FAL: - break; - default: - printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); - exit( 1 ); - } - } - - if ( gcmd_line.display_info == 109 ) { - printf("\n\nsplitted operators are:\n"); - - printf("\nEASY:\n"); - for ( i = 0; i < gnum_easy_operators; i++ ) { - print_NormOperator( geasy_operators[i] ); - } - - printf("\n\n\nHARD:\n"); - for ( i = 0; i < gnum_hard_operators; i++ ) { - print_Operator( ghard_operators[i] ); - } - } - -} - - - -int is_dnf( WffNode *w ) - -{ - - WffNode *i; - int s = 0; - - switch ( w->connective ) { - case ALL: - case EX: - printf("\nchecking quantifier for dnf. debug me\n\n"); - exit( 1 ); - case AND: - for ( i = w->sons; i; i = i->next ) { - if ( i->connective == ATOM || - i->connective == COMP ) { - continue; - } - return -1; - } - return 1; - case OR: - for ( i = w->sons; i; i = i->next ) { - s++; - if ( i->connective == ATOM || - i->connective == COMP || - ( i->connective == AND && - is_dnf( i ) != -1 ) ) { - continue; - } - return -1; - } - return s; - case NOT: - printf("\n\nNOT in presimplified formula. debug me\n\n"); - exit( 1 ); - case ATOM: - case COMP: - case TRU: - case FAL: - return 1; - default: - printf("\nwon't get here: check dnf, conn %d\n\n", - w->connective); - exit( 1 ); - } - -} - - - -void make_normal_effects( NormOperator **nop, Operator *op ) - -{ - - Effect *e; - NormEffect *tmp_ef; - WffNode *w, *ww, *www; - int j, m, ma, md, mn; - Literal *l; - NumericEffect *ll; - Fact *tmp_ft; - Fluent *tmp_fl; - - for ( e = op->effects; e; e = e->next ) { - w = e->conditions; - switch ( w->connective ) { - case OR: - for ( ww = w->sons; ww; ww = ww->next ) { - tmp_ef = new_NormEffect1( e ); - if ( ww->connective == AND ) { - m = 0; - mn = 0; - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) m++; - if ( www->connective == COMP ) mn++; - } - tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( www = ww->sons; www; www = www->next ) { - if ( www->connective == ATOM ) { - tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); - tmp_ft->predicate = www->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = www->fact->args[j]; - } - tmp_ef->num_conditions++; - } - if ( www->connective == COMP ) { - tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = www->comp; - tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( www->lh ); - tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( www->rh ); - tmp_ef->num_numeric_conditions++; - } - } - } else { - if ( ww->connective == ATOM ) { - tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_ef->conditions[0]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_ef->num_conditions = 1; - } - if ( ww->connective == COMP ) { - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_comp[0] = ww->comp; - tmp_ef->numeric_conditions_lh[0] = copy_Exp( ww->lh ); - tmp_ef->numeric_conditions_rh[0] = copy_Exp( ww->rh ); - tmp_ef->num_numeric_conditions = 1; - } - } - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - } - break; - case AND: - tmp_ef = new_NormEffect1( e ); - m = 0; - mn = 0; - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) m++; - if ( ww->connective == COMP ) mn++; - } - tmp_ef->conditions = ( Fact * ) calloc( m, sizeof( Fact ) ); - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( mn, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( mn, sizeof( ExpNode_pointer ) ); - for ( ww = w->sons; ww; ww = ww->next ) { - if ( ww->connective == ATOM ) { - tmp_ft = &(tmp_ef->conditions[tmp_ef->num_conditions]); - tmp_ft->predicate = ww->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = ww->fact->args[j]; - } - tmp_ef->num_conditions++; - } - if ( ww->connective == COMP ) { - tmp_ef->numeric_conditions_comp[tmp_ef->num_numeric_conditions] = ww->comp; - tmp_ef->numeric_conditions_lh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->lh ); - tmp_ef->numeric_conditions_rh[tmp_ef->num_numeric_conditions] = copy_Exp( ww->rh ); - tmp_ef->num_numeric_conditions++; - } - } - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case ATOM: - tmp_ef = new_NormEffect1( e ); - tmp_ef->conditions = ( Fact * ) calloc( 1, sizeof( Fact ) ); - tmp_ft = &(tmp_ef->conditions[0]); - tmp_ft->predicate = w->fact->predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = w->fact->args[j]; - } - tmp_ef->num_conditions = 1; - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case COMP: - tmp_ef = new_NormEffect1( e ); - tmp_ef->numeric_conditions_comp = ( Comparator * ) calloc( 1, sizeof( Comparator ) ); - tmp_ef->numeric_conditions_lh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_rh = ( ExpNode_pointer * ) calloc( 1, sizeof( ExpNode_pointer ) ); - tmp_ef->numeric_conditions_comp[0] = w->comp; - tmp_ef->numeric_conditions_lh[0] = copy_Exp( w->lh ); - tmp_ef->numeric_conditions_rh[0] = copy_Exp( w->rh ); - tmp_ef->num_numeric_conditions = 1; - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case TRU: - tmp_ef = new_NormEffect1( e ); - ma = 0; md = 0; - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { md++; } else { ma++; } - } - tmp_ef->adds = ( Fact * ) calloc( ma, sizeof( Fact ) ); - tmp_ef->dels = ( Fact * ) calloc( md, sizeof( Fact ) ); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - tmp_ft = &(tmp_ef->dels[tmp_ef->num_dels++]); - } else { - tmp_ft = &(tmp_ef->adds[tmp_ef->num_adds++]); - } - tmp_ft->predicate = l->fact.predicate; - for ( j = 0; j < garity[tmp_ft->predicate]; j++ ) { - tmp_ft->args[j] = l->fact.args[j]; - } - } - ma = 0; - for ( ll = e->numeric_effects; ll; ll = ll->next ) ma++; - tmp_ef->numeric_effects_neft = ( NumericEffectType * ) calloc( ma, sizeof( NumericEffectType ) ); - tmp_ef->numeric_effects_fluent = ( Fluent * ) calloc( ma, sizeof( Fluent ) ); - tmp_ef->numeric_effects_rh = ( ExpNode_pointer * ) calloc( ma, sizeof( ExpNode_pointer ) ); - for ( ll = e->numeric_effects; ll; ll = ll->next ) { - tmp_ef->numeric_effects_neft[tmp_ef->num_numeric_effects] = ll->neft; - tmp_fl = &(tmp_ef->numeric_effects_fluent[tmp_ef->num_numeric_effects]); - tmp_fl->function = ll->fluent.function; - for ( j = 0; j < gf_arity[tmp_fl->function]; j++ ) { - tmp_fl->args[j] = ll->fluent.args[j]; - } - tmp_ef->numeric_effects_rh[tmp_ef->num_numeric_effects] = copy_Exp( ll->rh ); - tmp_ef->num_numeric_effects++; - } - tmp_ef->next = (*nop)->effects; - if ( (*nop)->effects ) { - (*nop)->effects->prev = tmp_ef; - } - (*nop)->effects = tmp_ef; - break; - case FAL: - break; - default: - printf("\nwon't get here: non OR, AND, ATOM, TRUE, FALSE in dnf. debug me\n\n"); - exit( 1 ); - } - } - -} - - - - - - - - - -/************************************************************************* - * ADDITIONAL: FULL DNF, only compute on fully instantiated formulae!!!! * - *************************************************************************/ - - - - - - - - - - -/* dnf - */ - -WffNode *lhitting_sets; -WffNode_pointer *lset; -int lmax_set; - - - - - - -void dnf( WffNode **w ) - -{ - - static Bool first_call = TRUE; - - if ( first_call ) { - lset = ( WffNode_pointer * ) - calloc( MAX_HITTING_SET_DEFAULT, sizeof( WffNode_pointer ) ); - lmax_set = MAX_HITTING_SET_DEFAULT; - first_call = FALSE; - } - - ANDs_below_ORs_in_wff( w ); - -} - - - -void ANDs_below_ORs_in_wff( WffNode **w ) - -{ - - WffNode *i, *tmp; - int c, m; - - switch ( (*w)->connective ) { - case ALL: - case EX: - printf("\ntrying to put quantified formula into DNF! (ands down) debug me\n\n"); - exit( 1 ); - break; - case AND: - c = 0; - m = 0; - for ( i = (*w)->sons; i; i = i->next ) { - ANDs_below_ORs_in_wff( &i ); - if ( i->connective == OR ) { - c++; - } - m++; - } - if ( c == 0 ) { - /* no ORs as sons --> all sons are literals. OK - */ - merge_next_step_ANDs_and_ORs_in_wff( w ); - break; - } - /* crucial part: AND node, sons can be merged OR's. - * (i.e., sons are either literals or disjunctions of - * conjunctions of literals) - * create OR node with one hitting set of w's sons for - * each disjunct - */ - lhitting_sets = NULL; - if ( m > lmax_set ) { - free( lset ); - lset = ( WffNode_pointer * ) calloc( m, sizeof( WffNode_pointer ) ); - lmax_set = m; - } - collect_hitting_sets( (*w)->sons, 0 ); - (*w)->connective = OR; - tmp = (*w)->sons; - (*w)->sons = lhitting_sets; - if ( 0 ) free_WffNode( tmp ); - merge_next_step_ANDs_and_ORs_in_wff( w ); - break; - case OR: - for ( i = (*w)->sons; i; i = i->next ) { - ANDs_below_ORs_in_wff( &i ); - } - merge_next_step_ANDs_and_ORs_in_wff( w ); - break; - case NOT: - case ATOM: - case COMP: - case TRU: - case FAL: - break; - default: - printf("\nwon't get here: ands down, non logical %d\n\n", - (*w)->connective); - exit( 1 ); - } - -} - - - -void collect_hitting_sets( WffNode *ORlist, int index ) - -{ - - WffNode *tmp1, *tmp2, *j; - int i; - - if ( !ORlist ) { - tmp1 = new_WffNode( AND ); - for ( i = 0; i < index; i++ ) { - tmp2 = copy_Wff( lset[i] ); - tmp2->next = tmp1->sons; - if ( tmp1->sons ) { - tmp1->sons->prev = tmp2; - } - tmp1->sons = tmp2; - } - tmp1->next = lhitting_sets; - if ( lhitting_sets ) { - lhitting_sets->prev = tmp1; - } - lhitting_sets = tmp1; - return; - } - - if ( ORlist->connective != OR ) { - lset[index] = ORlist; - collect_hitting_sets( ORlist->next, index + 1 ); - return; - } - - for ( j = ORlist->sons; j; j = j->next ) { - lset[index] = j; - collect_hitting_sets( ORlist->next, index + 1 ); - } - -} - - - -void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ) - -{ - - WffNode *i, *j, *tmp; - - i = (*w)->sons; - while ( i ) { - if ( i->connective == (*w)->connective ) { - if ( !(i->sons) ) { - if ( i->next ) { - i->next->prev = i->prev; - } - if ( i->prev ) { - i->prev->next = i->next; - } else { - (*w)->sons = i->next; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - for ( j = i->sons; j->next; j = j->next ); - j->next = i->next; - if ( i->next ) { - i->next->prev = j; - } - if ( i->prev ) { - i->prev->next = i->sons; - i->sons->prev = i->prev; - } else { - (*w)->sons = i->sons; - } - tmp = i; - i = i->next; - free( tmp ); - continue; - } - i = i->next; - } - -} - - - -/* switch ( (*w)->connective ) { */ -/* case ALL: */ -/* case EX: */ -/* break; */ -/* case AND: */ -/* case OR: */ -/* for ( i = (*w)->sons; i; i = i->next ) { */ -/* } */ -/* break; */ -/* case NOT: */ -/* break; */ -/* case ATOM: */ -/* case TRU: */ -/* case FAL: */ -/* break; */ -/* default: */ -/* printf("\nwon't get here: remove var, non logical %d\n\n", */ -/* (*w)->connective); */ -/* exit( 1 ); */ -/* } */ - - - - - - - - - diff --git a/gen/ff_planner/inst_pre.h b/gen/ff_planner/inst_pre.h deleted file mode 100644 index de859b385..000000000 --- a/gen/ff_planner/inst_pre.h +++ /dev/null @@ -1,123 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: inst_pre.h - * Description: headers for instantiating operators, preprocessing part. - * - transform domain into integers - * - inertia preprocessing: - * - collect inertia info - * - split initial state in special arrays - * - Wff normalization: - * - simplification - * - quantifier expansion - * - NOT s down - * - negative preconditions translation - * - split operators into easy and hard to instantiate ones - * - * - full DNF functions, only feasible for fully instantiated - * formulae - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - - - - - - -#ifndef _INST_PRE_H -#define _INST_PRE_H - - - -void encode_domain_in_integers( void ); -void collect_all_strings( void ); -void create_member_nrs( void ); -int position_in_types_table( char *str ); -int position_in_constants_table( char *str ); -int position_in_predicates_table( char *str ); -int position_in_functions_table( char *str ); -void create_integer_representation( void ); -void make_Fact( Fact *f, PlNode *n, int num_vars ); -void make_Fluent( Fluent *f, TokenList *atom, int num_vars ); -Bool is_subtype( int t1, int t2 ); -WffNode *make_Wff( PlNode *p, int num_vars ); -ExpNode *make_ExpNode( ParseExpNode *p, int num_vars ); -Effect *make_effect( PlNode *p, int num_vars ); - - - -void do_inertia_preprocessing_step_1( void ); -void collect_inertia_information( void ); -void split_initial_state( void ); - - - -void normalize_all_wffs( void ); -void remove_unused_vars_in_wff( WffNode **w ); -void decrement_inferior_vars( int var, WffNode *w ); -void decrement_inferior_vars_in_exp( int var, ExpNode *n ); -Bool var_used_in_wff( int code_var, WffNode *w ); -Bool var_used_in_exp( int code_var, ExpNode *n ); -void simplify_wff( WffNode **w ); -void simplify_exp( ExpNode **n ); -void expand_quantifiers_in_wff( WffNode **w, int var, int constant ); -void replace_var_with_const_in_exp( ExpNode **n, int var, int constant ); -WffNode *copy_Wff( WffNode *w ); -ExpNode *copy_Exp( ExpNode *n ); -Bool possibly_positive( Fact *f ); -Bool possibly_negative( Fact *f ); -Bool matches( Fact *f1, Fact *f2 ); -void cleanup_wff( WffNode **w ); -void detect_tautologies_in_wff( WffNode **w ); -Bool are_identical_ATOMs( WffNode *w1, WffNode *w2 ); -void merge_ANDs_and_ORs_in_wff( WffNode **w ); -void NOTs_down_in_wff( WffNode **w ); - - - -void translate_negative_preconds( void ); -Bool translate_one_negative_cond( WffNode *w ); -void replace_not_p_with_n_in_wff( int p, int n, WffNode **w ); -void add_to_initial_state( int p, int n, int index ); - - - -void split_domain( void ); -int is_dnf( WffNode *w ); -void make_normal_effects( NormOperator **nop, Operator *op ); - - - -void dnf( WffNode **w ); -void ANDs_below_ORs_in_wff( WffNode **w ); -void collect_hitting_sets( WffNode *ORlist, int index ); -void merge_next_step_ANDs_and_ORs_in_wff( WffNode **w ); - - - -#endif /* _INST_PRE_H */ diff --git a/gen/ff_planner/lex-fct_pddl.l b/gen/ff_planner/lex-fct_pddl.l deleted file mode 100644 index 850bbb407..000000000 --- a/gen/ff_planner/lex-fct_pddl.l +++ /dev/null @@ -1,139 +0,0 @@ -%{ -#include "ff.h" -#include "parse.h" - - /* default yywrap function - always treat EOF as an EOF */ -int fct_pddlwrap() { return 1; }; - -int gbracket_count = 0; - -%} - -a [Aa] -b [Bb] -c [Cc] -d [Dd] -e [Ee] -f [Ff] -g [Gg] -h [Hh] -i [Ii] -j [Jj] -k [Kk] -l [Ll] -m [Mm] -n [Nn] -o [Oo] -p [Pp] -q [Qq] -r [Rr] -s [Ss] -t [Tt] -u [Uu] -v [Vv] -w [Ww] -x [Xx] -y [Yy] -z [Zz] - -%x COMMENT OVERREAD - -%% - -"(" { return(OPEN_PAREN); } - -")" { return(CLOSE_PAREN); } - -\([ \t]*{i}{n}"-"{p}{a}{c}{k}{a}{g}{e} { gbracket_count = 1; - BEGIN OVERREAD; } - -\([ \t]*":"{l}{e}{n}{g}{t}{h} { gbracket_count = 1; - BEGIN OVERREAD; } - -\([ \t]*":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { gbracket_count = 1; - BEGIN OVERREAD; } - -{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } - -{p}{r}{o}{b}{l}{e}{m} { return(PROBLEM_TOK); } - -{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(SITUATION_TOK); } - -":"{s}{i}{t}{u}{a}{t}{i}{o}{n} { return(BSITUATION_TOK); } - -":"{o}{b}{j}{e}{c}{t}{s} { return(OBJECTS_TOK); } - -":"{g}{o}{a}{l} { return(GOAL_TOK); } - -":"{m}{e}{t}{r}{i}{c} { return(METRIC_TOK); } - -":"{i}{n}{i}{t} { return(INIT_TOK); } - -":"{d}{o}{m}{a}{i}{n} { return(BDOMAIN_TOK); } - -\([ \t]*":"{e}{x}{t}{e}{n}{d}{s} { gbracket_count = 1; - BEGIN OVERREAD; } - -{a}{n}{d} { return(AND_TOK); } - -{i}{m}{p}{l}{y} { return(IMPLY_TOK); } - -{o}{r} { return(OR_TOK); } - -{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } - -{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } - -{n}{o}{t} { return(NOT_TOK); } - -"<" { return(LE_TOK); } - -"<=" { return(LEQ_TOK); } - -"=" { return(EQ_TOK); } - -">=" { return(GEQ_TOK); } - -">" { return(GE_TOK); } - -"-" { return(MINUS_TOK); } - -"+" { return(AD_TOK); } - -"*" { return(MU_TOK); } - -"/" { return(DI_TOK); } - -:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase( yytext ); - strcpy(yylval.string, yytext ); return(NAME); } - -\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* {strupcase( yytext ); - strcpy(yylval.string, yytext); return(VARIABLE); } - -"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} - -"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } - -\;(.)*\n { lineno++; } -\;(.)* { /* this will hold only in files that end with - a comment but no linefeed */ } - -(.^\")*\n { lineno++; } ; - -\" { BEGIN COMMENT;} - -\" { BEGIN INITIAL;} - -\n { lineno++; } - -(.^\(\))*\n { lineno++; } - -[^\(\)] { } - -\( { gbracket_count++; } - -\) { gbracket_count--; - if (!gbracket_count) BEGIN INITIAL; } - -. {} -%% diff --git a/gen/ff_planner/lex-ops_pddl.l b/gen/ff_planner/lex-ops_pddl.l deleted file mode 100644 index 0e9d8499d..000000000 --- a/gen/ff_planner/lex-ops_pddl.l +++ /dev/null @@ -1,151 +0,0 @@ -%{ -#include "ff.h" -#include "parse.h" - -/* default yywrap function - always treat EOF as an EOF */ -int ops_pddlwrap() { return 1; }; - -%} - -a [Aa] -b [Bb] -c [Cc] -d [Dd] -e [Ee] -f [Ff] -g [Gg] -h [Hh] -i [Ii] -j [Jj] -k [Kk] -l [Ll] -m [Mm] -n [Nn] -o [Oo] -p [Pp] -q [Qq] -r [Rr] -s [Ss] -t [Tt] -u [Uu] -v [Vv] -w [Ww] -x [Xx] -y [Yy] -z [Zz] - -%x COMMENT OVERREAD - -%% - -"(" { return(OPEN_PAREN); } - -")" { return(CLOSE_PAREN); } - -{d}{e}{f}{i}{n}{e} { return(DEFINE_TOK); } - -{d}{o}{m}{a}{i}{n} { return(DOMAIN_TOK); } - -":"{r}{e}{q}{u}{i}{r}{e}{m}{e}{n}{t}{s} { return(REQUIREMENTS_TOK); } - -":"{t}{y}{p}{e}{s} { return(TYPES_TOK); } - -{n}{u}{m}{b}{e}{r} { return(NUMBER_TOK); } - -":"{c}{o}{n}{s}{t}{a}{n}{t}{s} { return(CONSTANTS_TOK); } - -":"{p}{r}{e}{d}{i}{c}{a}{t}{e}{s} { return(PREDICATES_TOK); } - -":"{f}{u}{n}{c}{t}{i}{o}{n}{s} { return(FUNCTIONS_TOK); } - -":"{a}{c}{t}{i}{o}{n} { return(ACTION_TOK); } - -":"{d}{e}{r}{i}{v}{e}{d} { return(AXIOM_TOK); } - -":"{p}{a}{r}{a}{m}{e}{t}{e}{r}{s} { return(PARAMETERS_TOK); } - -":"{v}{a}{r}{s} { return(VARS_TOK); } - -":"{p}{r}{e}{c}{o}{n}{d}{i}{t}{i}{o}{n} { return(PRECONDITION_TOK); } - -":"{e}{f}{f}{e}{c}{t} { return(EFFECT_TOK); } - -":"{i}{m}{p}{l}{i}{e}{s} { return(IMPLIES_TOK); } - -{a}{n}{d} { return(AND_TOK); } - -{n}{o}{t} { return(NOT_TOK); } - -{w}{h}{e}{n} { return(WHEN_TOK); } - -{i}{m}{p}{l}{y} { return(IMPLY_TOK); } - -{o}{r} { return(OR_TOK); } - -{f}{o}{r}{a}{l}{l} { return(FORALL_TOK); } - -{e}{x}{i}{s}{t}{s} { return(EXISTS_TOK); } - -"<" { return(LE_TOK); } - -"<=" { return(LEQ_TOK); } - -"=" { return(EQ_TOK); } - -">=" { return(GEQ_TOK); } - -">" { return(GE_TOK); } - -"-" { return(MINUS_TOK); } - -"+" { return(AD_TOK); } - -"*" { return(MU_TOK); } - -"/" { return(DI_TOK); } - -{a}{s}{s}{i}{g}{n} { return(ASSIGN_TOK); } - -{s}{c}{a}{l}{e}"-"{u}{p} { return(SCALE_UP_TOK); } - -{s}{c}{a}{l}{e}"-"{d}{o}{w}{n} { return(SCALE_DOWN_TOK); } - -{i}{n}{c}{r}{e}{a}{s}{e} { return(INCREASE_TOK); } - -{d}{e}{c}{r}{e}{a}{s}{e} { return(DECREASE_TOK); } - - -:?[a-zA-Z][a-zA-Z0-9\-_]* { strupcase(yytext); strcpy(yylval.string, yytext); - return(NAME); } - -\?[a-zA-Z][a-zA-Z0-9\-_\[\]]* { strupcase(yytext); strcpy(yylval.string, yytext); - return(VARIABLE); } - -"-"?[0-9]*[.]?[0-9]* { strcpy(yylval.string, yytext); return(NUM);} - - -"-"[ \t]*"("[ \t]*{e}{i}{t}{h}{e}{r} { return(EITHER_TOK); } - -\;(.)*\n { lineno++; } -\;(.)* { /* this will hold only in files that end with - a comment but no linefeed */ } - -(.^\")*\n { lineno++; } ; - -\" { BEGIN COMMENT;} - -\" { BEGIN INITIAL;} - -\n { lineno++; } - -(.^\(\))*\n { lineno++; } - -[^\(\)] { } - -\( { BEGIN OVERREAD; gbracket_count++; } - -\) { BEGIN OVERREAD; gbracket_count--; - if (!gbracket_count) BEGIN INITIAL; } - -. {} -%% diff --git a/gen/ff_planner/main.c b/gen/ff_planner/main.c deleted file mode 100644 index bc3a795b5..000000000 --- a/gen/ff_planner/main.c +++ /dev/null @@ -1,1230 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - -/********************************************************************* - * File: main.c - * Description: The main routine for the Metric-FastForward Planner. - * Modified July 2011 to allow more command-line search - * confiogurations, including improved cost-minimization - * - * Author: original version Joerg Hoffmann 2001/2002 - * modified version Joerg Hoffmann 2012 - * - *********************************************************************/ - - - - - - - - -#include "ff.h" - -#include "memory.h" -#include "output.h" - -#include "parse.h" - -#include "expressions.h" - -#include "inst_pre.h" -#include "inst_easy.h" -#include "inst_hard.h" -#include "inst_final.h" - -#include "relax.h" -#include "search.h" - - - - - - - - - - - -/* - * ----------------------------- GLOBAL VARIABLES ---------------------------- - */ - - - - - - - - - - - - -/******************* - * GENERAL HELPERS * - *******************/ - - - - - - - - -/* used to time the different stages of the planner - */ -float gtempl_time = 0, greach_time = 0, grelev_time = 0, gconn_time = 0; -float gLNF_time = 0, gsearch_time = 0; - - -/* the command line inputs - */ -struct _command_line gcmd_line; - -/* number of states that got heuristically evaluated - */ -int gevaluated_states = 0; - -/* maximal depth of breadth first search - */ -int gmax_search_depth = 0; - - - - - -/*********** - * PARSING * - ***********/ - - - - - - - -/* used for pddl parsing, flex only allows global variables - */ -int gbracket_count; -char *gproblem_name; - -/* The current input line number - */ -int lineno = 1; - -/* The current input filename - */ -char *gact_filename; - -/* The pddl domain name - */ -char *gdomain_name = NULL; - -/* loaded, uninstantiated operators - */ -PlOperator *gloaded_ops = NULL; - -/* stores initials as fact_list - */ -PlNode *gorig_initial_facts = NULL; - -/* not yet preprocessed goal facts - */ -PlNode *gorig_goal_facts = NULL; - -/* axioms as in UCPOP before being changed to ops - */ -PlOperator *gloaded_axioms = NULL; - -/* the types, as defined in the domain file - */ -TypedList *gparse_types = NULL; - -/* the constants, as defined in domain file - */ -TypedList *gparse_constants = NULL; - -/* the predicates and their arg types, as defined in the domain file - */ -TypedListList *gparse_predicates = NULL; - -/* the functions and their arg types, as defined in the domain file - */ -TypedListList *gparse_functions = NULL; - -/* the objects, declared in the problem file - */ -TypedList *gparse_objects = NULL; - -/* the metric - */ -Token gparse_optimization; -ParseExpNode *gparse_metric = NULL; - - -/* connection to instantiation ( except ops, goal, initial ) - */ - -/* all typed objects - */ -FactList *gorig_constant_list = NULL; - -/* the predicates and their types - */ -FactList *gpredicates_and_types = NULL; - -/* the functions and their types - */ -FactList *gfunctions_and_types = NULL; - - - - - - - - - - - - -/***************** - * INSTANTIATING * - *****************/ - - - - - - - - - -/* global arrays of constant names, - * type names (with their constants), - * predicate names, - * predicate aritys, - * defined types of predicate args - */ -Token gconstants[MAX_CONSTANTS]; -int gnum_constants = 0; -Token gtype_names[MAX_TYPES]; -int gtype_consts[MAX_TYPES][MAX_TYPE]; -Bool gis_member[MAX_CONSTANTS][MAX_TYPES]; -int gmember_nr[MAX_CONSTANTS][MAX_TYPES];/* nr of object within a type */ -int gtype_size[MAX_TYPES]; -int gnum_types = 0; -Token gpredicates[MAX_PREDICATES]; -int garity[MAX_PREDICATES]; -Bool gaxiom_added[MAX_PREDICATES]; -int gpredicates_args_type[MAX_PREDICATES][MAX_ARITY]; -int gnum_predicates = 0; -Token gfunctions[MAX_FUNCTIONS]; -int gf_arity[MAX_FUNCTIONS]; -int gfunctions_args_type[MAX_FUNCTIONS][MAX_ARITY]; -int gnum_functions = 0; - - - - - -/* the domain in integer (Fact) representation - */ -Operator_pointer goperators[MAX_OPERATORS]; -int gnum_operators = 0; -Fact *gfull_initial; -int gnum_full_initial = 0; -FluentValue *gfull_fluents_initial; -int gnum_full_fluents_initial = 0; -WffNode *ggoal = NULL; - -ExpNode *gmetric = NULL; - - - -/* stores inertia - information: is any occurence of the predicate - * added / deleted in the uninstantiated ops ? - */ -Bool gis_added[MAX_PREDICATES]; -Bool gis_deleted[MAX_PREDICATES]; - - -/* for functions we *might* want to say, symmetrically, whether it is - * increased resp. decreased at all. - * - * that is, however, somewhat involved because the right hand - * sides can be arbirtray expressions, so we have no guarantee - * that increasing really does adds to a functions value... - * - * thus (for the time being), we settle for "is the function changed at all?" - */ -Bool gis_changed[MAX_FUNCTIONS]; - - - -/* splitted initial state: - * initial non static facts, - * initial static facts, divided into predicates - * (will be two dimensional array, allocated directly before need) - */ -Facts *ginitial = NULL; -int gnum_initial = 0; -Fact **ginitial_predicate; -int *gnum_initial_predicate; - -/* same thing for functions - */ -FluentValues *gf_initial; -int gnum_f_initial = 0; -FluentValue **ginitial_function; -int *gnum_initial_function; - - - -/* the type numbers corresponding to any unary inertia - */ -int gtype_to_predicate[MAX_PREDICATES]; -int gpredicate_to_type[MAX_TYPES]; - -/* (ordered) numbers of types that new type is intersection of - */ -TypeArray gintersected_types[MAX_TYPES]; -int gnum_intersected_types[MAX_TYPES]; - - - -/* splitted domain: hard n easy ops - */ -Operator_pointer *ghard_operators; -int gnum_hard_operators; -NormOperator_pointer *geasy_operators; -int gnum_easy_operators; - - - -/* so called Templates for easy ops: possible inertia constrained - * instantiation constants - */ -EasyTemplate *geasy_templates; -int gnum_easy_templates; - - - -/* first step for hard ops: create mixed operators, with conjunctive - * precondition and arbitrary effects - */ -MixedOperator *ghard_mixed_operators; -int gnum_hard_mixed_operators; - - - -/* hard ''templates'' : pseudo actions - */ -PseudoAction_pointer *ghard_templates; -int gnum_hard_templates; - - - -/* store the final "relevant facts" - */ -Fact grelevant_facts[MAX_RELEVANT_FACTS]; -int gnum_relevant_facts = 0; -int gnum_pp_facts = 0; -/* store the "relevant fluents" - */ -Fluent grelevant_fluents[MAX_RELEVANT_FLUENTS]; -int gnum_relevant_fluents = 0; -Token grelevant_fluents_name[MAX_RELEVANT_FLUENTS]; -/* this is NULL for normal, and the LNF for - * artificial fluents. - */ -LnfExpNode_pointer grelevant_fluents_lnf[MAX_RELEVANT_FLUENTS]; - - - -/* the final actions and problem representation - */ -Action *gactions = NULL; -int gnum_actions; -State ginitial_state; -int *glogic_goal = NULL; -int gnum_logic_goal = 0; -Comparator *gnumeric_goal_comp = NULL; -ExpNode_pointer *gnumeric_goal_lh = NULL, *gnumeric_goal_rh = NULL; -int gnum_numeric_goal = 0; - -/* direct numeric goal access - */ -Comparator *gnumeric_goal_direct_comp; -float *gnumeric_goal_direct_c; - - - -/* to avoid memory leaks; too complicated to identify - * the exact state of the action to throw away (during construction), - * memory gain not worth the implementation effort. - */ -Action *gtrash_actions = NULL; - - - -/* additional lnf step between finalized inst and - * conn graph - */ -Comparator *glnf_goal_comp = NULL; -LnfExpNode_pointer *glnf_goal_lh = NULL; -float *glnf_goal_rh = NULL; -int gnum_lnf_goal = 0; - -LnfExpNode glnf_metric; -Bool goptimization_established = FALSE; - - - - - - - -/********************** - * CONNECTIVITY GRAPH * - **********************/ - - - - - - - -/* one ops (actions) array ... - */ -OpConn *gop_conn; -int gnum_op_conn; - - - -/* one effects array ... - */ -EfConn *gef_conn; -int gnum_ef_conn; - - - -/* one facts array. - */ -FtConn *gft_conn; -int gnum_ft_conn; - - - -/* and: one fluents array. - */ -FlConn *gfl_conn; -int gnum_fl_conn; -int gnum_real_fl_conn;/* number of non-artificial ones */ - - - -/* final goal is also transformed one more step. - */ -int *gflogic_goal = NULL; -int gnum_flogic_goal = 0; -Comparator *gfnumeric_goal_comp = NULL; -int *gfnumeric_goal_fl = NULL; -float *gfnumeric_goal_c = NULL; -int gnum_fnumeric_goal = 0; - -/* direct access (by relevant fluents) - */ -Comparator *gfnumeric_goal_direct_comp = NULL; -float *gfnumeric_goal_direct_c = NULL; - - - - - - - - - - - -/******************* - * SEARCHING NEEDS * - *******************/ - - - - - - - - - - - -/* applicable actions - */ -int *gA;/* non-axioms */ -int gnum_A; -int *gA_axioms; /* axioms */ -int gnum_A_axioms; - - - -/* communication from extract 1.P. to search engine: - * 1P action choice - */ -int *gH; -int gnum_H; -/* added cost of relaxed plan - */ -float gh_cost; -/* hmax value - */ -float ghmax; - - - -/* to store plan - */ -int gplan_ops[MAX_PLAN_LENGTH]; -int gnum_plan_ops = 0; - - - -/* stores the states that the current plan goes through - * ( for knowing where new agenda entry starts from ) - */ -State gplan_states[MAX_PLAN_LENGTH + 1]; - - - - - - - -/* dirty: multiplic. of total-time in final metric LNF - */ -float gtt; - - - - - - - -/* the mneed structures - */ -Bool **gassign_influence; -Bool **gTassign_influence; - - - -/* the real var input to the mneed computation. - */ -Bool *gmneed_start_D; -float *gmneed_start_V; - - - -/* does this contain conditional effects? - * (if it does then the state hashing has to be made more - * cautiously) - */ -Bool gconditional_effects; - - - -/* easier to question: are we optimizing or no? - */ -Bool gcost_minimizing; - - - -/* stores current A* weight: this is initially given by user, - * but changes during anytime search. - */ -float gw; -/* this is the minimum weight, ie we'll stop once the weight update - * does/would yield a value <= this. - * if no such minim weight is given, this will be -1 - */ -float gmin_w = -1; - - - -/* this one says whether or not we are actually using - * cost-minimizing rplans. - * this will be the case by default if we're running cost- - * minimizing searches. it can be switched off by a flag; - * it is automatically switched off in case there are - * numeric preconditions/goals: for this case, - * cost-minimizing rplans are not implemented (a numeric prec - * may cause an action to come in "later" on in the RPG although - * its logical pres are easy. in that case, any new effects will - * have a smaller RPGcost value than facts we already have waiting. - * in other words, the "Dijsktra" nature breaks. - * - * ... I suppose there may be a generic solution to this that - * can handle numeric precs/goals. Doesn't seem important enough - * to bother. - */ -Bool gcost_rplans; - - - - - - - - - - - - - -/* - * ----------------------------- HEADERS FOR PARSING ---------------------------- - * ( fns defined in the scan-* files ) - */ - - - - - - - -void get_fct_file_name( char *filename ); -void load_ops_file( char *filename ); -void load_fct_file( char *filename ); - - - - - - - - - - - -/* - * ----------------------------- MAIN ROUTINE ---------------------------- - */ - - - - - -struct tms lstart, lend; - - - - - -int main( int argc, char *argv[] ) - -{ - - /* resulting name for ops file - */ - char ops_file[MAX_LENGTH] = ""; - /* same for fct file - */ - char fct_file[MAX_LENGTH] = ""; - - struct tms start, end; - - Bool found_plan; - int i; - float cost; - - Bool prev_gcost_rplans; - - - - times ( &lstart ); - - /* command line treatment - */ - gcmd_line.display_info = 1; - gcmd_line.debug = 0; - - /* search settings - */ - gcmd_line.search_config = 5; - gcmd_line.cost_rplans = TRUE; - gcmd_line.w = 5; - gcmd_line.cost_bound = -1; - - memset(gcmd_line.ops_file_name, 0, MAX_LENGTH); - memset(gcmd_line.fct_file_name, 0, MAX_LENGTH); - memset(gcmd_line.path, 0, MAX_LENGTH); - - if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { - ff_usage(); - exit( 1 ); - } - if ( !process_command_line( argc, argv ) ) { - ff_usage(); - exit( 1 ); - } - - - /* make file names - */ - - /* one input name missing - */ - if ( !gcmd_line.ops_file_name || - !gcmd_line.fct_file_name ) { - fprintf(stdout, "\nff: two input files needed\n\n"); - ff_usage(); - exit( 1 ); - } - /* add path info, complete file names will be stored in - * ops_file and fct_file - */ - sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); - sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); - - - /* parse the input files - */ - - /* start parse & instantiation timing - */ - times( &start ); - /* domain file (ops) - */ - if ( gcmd_line.display_info >= 1 ) { - printf("\nff: parsing domain file"); - } - /* it is important for the pddl language to define the domain before - * reading the problem - */ - load_ops_file( ops_file ); - /* problem file (facts) - */ - if ( gcmd_line.display_info >= 1 ) { - printf(" ... done.\nff: parsing problem file"); - } - load_fct_file( fct_file ); - if ( gcmd_line.display_info >= 1 ) { - printf(" ... done.\n\n"); - } - - /* This is needed to get all types. - */ - build_orig_constant_list(); - - /* last step of parsing: see if it's an ADL domain! - */ - if ( !make_adl_domain() ) { - printf("\nff: this is not an ADL problem!"); - printf("\n can't be handled by this version.\n\n"); - exit( 1 ); - } - - - /* now instantiate operators; - */ - - - /************************** - * first do PREPROCESSING * - **************************/ - - /* start by collecting all strings and thereby encoding - * the domain in integers. - */ - encode_domain_in_integers(); - - /* inertia preprocessing, first step: - * - collect inertia information - * - split initial state into - * - arrays for individual predicates - * - arrays for all static relations - * - array containing non - static relations - */ - do_inertia_preprocessing_step_1(); - - /* normalize all PL1 formulae in domain description: - * (goal, preconds and effect conditions) - * - simplify formula - * - expand quantifiers - * - NOTs down - */ - normalize_all_wffs(); - - /* translate negative preconds: introduce symmetric new predicate - * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) - */ - translate_negative_preconds(); - - /* split domain in easy (disjunction of conjunctive preconds) - * and hard (non DNF preconds) part, to apply - * different instantiation algorithms - */ - split_domain(); - - /*********************************************** - * PREPROCESSING FINISHED * - * * - * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * - ***********************************************/ - - build_easy_action_templates(); - build_hard_action_templates(); - - times( &end ); - TIME( gtempl_time ); - - times( &start ); - - /* perform reachability analysis in terms of relaxed - * fixpoint - */ - perform_reachability_analysis(); - - times( &end ); - TIME( greach_time ); - - times( &start ); - - /* collect the relevant facts and build final domain - * and problem representations. - */ - collect_relevant_facts_and_fluents(); - - times( &end ); - TIME( grelev_time ); - - - /* now transform problem to additive normal form, - * if possible - */ - times( &start ); - if ( !transform_to_LNF() ) { - printf("\n\nThis is not a linear task!\n\n"); - exit( 1 ); - } - times( &end ); - TIME( gLNF_time ); - - times( &start ); - - /* now build globally accessable connectivity graph - */ - build_connectivity_graph(); - - /* now check for acyclic := effects (in expressions.c) - */ - check_assigncycles(); - /* set the relevanc info (in expressions.c) - */ - determine_fl_relevance(); - - times( &end ); - TIME( gconn_time ); - - /*********************************************************** - * we are finally through with preprocessing and can worry * - * bout finding a plan instead. * - ***********************************************************/ - - if ( gcmd_line.display_info ) { - printf("\n\nff: search configuration is "); - switch ( gcmd_line.search_config ) { - case 0: - printf("Enforced Hill-Climbing, if that fails then best-first search.\nMetric is plan length."); - printf("\nNO COST MINIMIZATION"); - if ( !gcost_rplans ) { - printf(" (and no cost-minimizing relaxed plans)."); - } else { - printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); - exit( 1 ); - } - break; - case 1: - printf("best-first search.\nMetric is plan length."); - printf("\nNO COST MINIMIZATION"); - if ( !gcost_rplans ) { - printf(" (and no cost-minimizing relaxed plans)."); - } else { - printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); - exit( 1 ); - } - break; - case 2: - printf("best-first search with helpful actions pruning.\nMetric is plan length."); - printf("\nNO COST MINIMIZATION."); - if ( !gcost_rplans ) { - printf(" (and no cost-minimizing relaxed plans)."); - } else { - printf("\nDEBUG ME: cost min rplans in non-cost minimizing search config?\n\n"); - exit( 1 ); - } - break; - case 3: - printf("weighted A* with weight %d.", gcmd_line.w); - if ( goptimization_established ) { - printf("\nMetric is "); - print_LnfExpNode( &glnf_metric ); - } else { - printf(" plan length"); - } - printf("\nCOST MINIMIZATION DONE"); - if ( !gcost_rplans ) { - printf(" (WITHOUT cost-minimizing relaxed plans)."); - } else { - printf(" (WITH cost-minimizing relaxed plans)."); - } - break; - case 4: - printf("A*epsilon with weight %d.", gcmd_line.w); - if ( goptimization_established ) { - printf("\nMetric is "); - print_LnfExpNode( &glnf_metric ); - } else { - printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); - exit( 1 ); - } - printf("\nCOST MINIMIZATION DONE"); - if ( !gcost_rplans ) { - printf(" (WITHOUT cost-minimizing relaxed plans)."); - } else { - printf(" (WITH cost-minimizing relaxed plans)."); - } - break; - case 5: - printf("Enforced Hill-Climbing, then A*epsilon with weight %d.", gcmd_line.w); - if ( goptimization_established ) { - printf("\nMetric is "); - print_LnfExpNode( &glnf_metric ); - } else { - printf("\nError! Optimization criterion not established.\nA*epsilon not defined.\n\n"); - exit( 1 ); - } - printf("\nCOST MINIMIZATION DONE"); - if ( !gcost_rplans ) { - printf(" (WITHOUT cost-minimizing relaxed plans)."); - } else { - printf(" (WITH cost-minimizing relaxed plans)."); - } - break; - default: - printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); - exit( 1 ); - } - } else { - if ( gcmd_line.search_config == 4 && !goptimization_established ) { - exit( 1 ); - } - } - - - times( &start ); - - - - /* need to evaluate derived predicates in initial state! - */ - do_axiom_update( &ginitial_state ); - - - if ( !gcost_rplans ) { - gcmd_line.cost_bound = -1; - } - - switch ( gcmd_line.search_config ) { - case 0: - found_plan = do_enforced_hill_climbing(); - if ( found_plan ) { - if ( gcmd_line.display_info ) { - print_plan(); - } - } else { - if ( gcmd_line.display_info ) { - printf("\n\nEnforced Hill-climbing failed !"); - printf("\nswitching to Best-first Search now.\n"); - } - do_best_first_search(); - } - break; - case 1: - case 2: - do_best_first_search(); - break; - case 3: - do_weighted_Astar(); - break; - case 4: - do_Astar_epsilon(); - break; - case 5: - /* gcost_rplans controls whether or not we compute cost-minimal relaxed plans - * gcost_minimizing is only used in h fn to decide whether or not we - * need to count the weights of the operators in the relaxed plan. - * - * gcost_rplans may be false even for search options 3,4,5, namely if there are - * numeric preconditions/goals which make this relaxed plan variant invalid. - * hence we need to remember, when switching it off for EHC, whether or not - * it was previously on. - */ - prev_gcost_rplans = gcost_rplans; - gcost_rplans = FALSE; - gcost_minimizing = FALSE; - found_plan = do_enforced_hill_climbing(); - if ( found_plan ) { - print_plan(); - } else { - if ( gcmd_line.display_info ) { - printf("\n\nEnforced Hill-climbing not successful."); - printf("\nSwitching to A*epsilon now."); - } - gcost_rplans = prev_gcost_rplans; - gcost_minimizing = TRUE; - do_Astar_epsilon(); - } - break; - default: - printf("\n\nUnknown search configuration: %d\n\n", gcmd_line.search_config ); - exit( 1 ); - } - - times( &end ); - TIME( gsearch_time ); - - - - output_planner_info(); - - printf("\n\n"); - exit( 0 ); - -} - - - - - - - - - - - -/* - * ----------------------------- HELPING FUNCTIONS ---------------------------- - */ - - - - - - - - - - - - -void output_planner_info( void ) - -{ - - printf( "\n\ntime spent: %7.2f seconds instantiating %d easy, %d hard action templates", - gtempl_time, gnum_easy_templates, gnum_hard_mixed_operators ); - printf( "\n %7.2f seconds reachability analysis, yielding %d facts and %d actions", - greach_time, gnum_pp_facts, gnum_actions ); - printf( "\n %7.2f seconds creating final representation with %d relevant facts, %d relevant fluents", - grelev_time, gnum_relevant_facts, gnum_relevant_fluents ); - printf( "\n %7.2f seconds computing LNF", - gLNF_time ); - printf( "\n %7.2f seconds building connectivity graph", - gconn_time ); - printf( "\n %7.2f seconds searching, evaluating %d states, to a max depth of %d", - gsearch_time, gevaluated_states, gmax_search_depth ); - printf( "\n %7.2f seconds total time", - gtempl_time + greach_time + grelev_time + gLNF_time + gconn_time + gsearch_time ); - - printf("\n\n"); - - exit( 0 ); - -} - - - -void ff_usage( void ) - -{ - - printf("\nusage of ff:\n"); - - printf("\nOPTIONS DESCRIPTIONS\n\n"); - printf("-p Path for operator and fact file\n"); - printf("-o Operator file name\n"); - printf("-f Fact file name\n\n"); - - printf("-r Random seed [used for random restarts; preset: 0]\n\n"); - - printf("-s Search configuration [preset: s=5]; '+H': helpful actions pruning\n"); - printf(" 0 Standard-FF: EHC+H then BFS (cost minimization: NO)\n"); - printf(" 1 BFS (cost minimization: NO)\n"); - printf(" 2 BFS+H (cost minimization: NO)\n"); - printf(" 3 Weighted A* (cost minimization: YES)\n"); - printf(" 4 A*epsilon (cost minimization: YES)\n"); - printf(" 5 EHC+H then A*epsilon (cost minimization: YES)\n"); - printf("-w Set weight w for search configs 3,4,5 [preset: w=5]\n\n"); - - printf("-C Do NOT use cost-minimizing relaxed plans for options 3,4,5\n\n"); - - printf("-b Fixed upper bound on solution cost (prune based on g+hmax); active only with cost minimization\n\n"); - - if ( 0 ) { - printf("-i run-time information level( preset: 1 )\n"); - printf(" 0 only times\n"); - printf(" 1 problem name, planning process infos\n"); - printf(" 101 parsed problem data\n"); - printf(" 102 cleaned up ADL problem\n"); - printf(" 103 collected string tables\n"); - printf(" 104 encoded domain\n"); - printf(" 105 predicates inertia info\n"); - printf(" 106 splitted initial state\n"); - printf(" 107 domain with Wff s normalized\n"); - printf(" 108 domain with NOT conds translated\n"); - printf(" 109 splitted domain\n"); - printf(" 110 cleaned up easy domain\n"); - printf(" 111 unaries encoded easy domain\n"); - printf(" 112 effects multiplied easy domain\n"); - printf(" 113 inertia removed easy domain\n"); - printf(" 114 easy action templates\n"); - printf(" 115 cleaned up hard domain representation\n"); - printf(" 116 mixed hard domain representation\n"); - printf(" 117 final hard domain representation\n"); - printf(" 118 reachability analysis results\n"); - printf(" 119 facts selected as relevant\n"); - printf(" 120 final domain and problem representations\n"); - printf(" 121 normalized expressions representation\n"); - printf(" 122 LNF: translated subtractions representation\n"); - printf(" 123 summarized effects LNF representation\n"); - printf(" 124 encoded LNF representation\n"); - printf(" 125 connectivity graph\n"); - printf(" 126 fixpoint result on each evaluated state\n"); - printf(" 127 1P extracted on each evaluated state\n"); - printf(" 128 H set collected for each evaluated state\n"); - - printf("\n-d switch on debugging\n\n"); - } - -} - - - -Bool process_command_line( int argc, char *argv[] ) - -{ - - char option; - - while ( --argc && ++argv ) { - if ( *argv[0] != '-' || strlen(*argv) != 2 ) { - return FALSE; - } - option = *++argv[0]; - switch ( option ) { -/* case 'E': */ -/* gcmd_line.ehc = FALSE; */ -/* break; */ -/* case 'O': */ -/* gcmd_line.optimize = TRUE; */ -/* gcmd_line.ehc = FALSE; */ -/* break; */ - case 'C': - gcmd_line.cost_rplans = FALSE; - break; - default: - if ( --argc && ++argv ) { - switch ( option ) { - case 'p': - strncpy( gcmd_line.path, *argv, MAX_LENGTH ); - break; - case 'o': - strncpy( gcmd_line.ops_file_name, *argv, MAX_LENGTH ); - break; - case 'f': - strncpy( gcmd_line.fct_file_name, *argv, MAX_LENGTH ); - break; - case 'i': - sscanf( *argv, "%d", &gcmd_line.display_info ); - break; - case 'd': - sscanf( *argv, "%d", &gcmd_line.debug ); - break; - case 's': - sscanf( *argv, "%d", &gcmd_line.search_config ); - break; - case 'w': - sscanf( *argv, "%d", &gcmd_line.w ); - break; - case 'b': - sscanf( *argv, "%f", &gcmd_line.cost_bound ); - break; - default: - printf( "\nff: unknown option: %c entered\n\n", option ); - return FALSE; - } - } else { - return FALSE; - } - } - } - - if ( 0 > gcmd_line.search_config || gcmd_line.search_config > 5 ) { - printf("\n\nff: unknown search configuration %d.\n\n", - gcmd_line.search_config); - return FALSE; - } - - if ( gcmd_line.search_config <= 2 ) { - gcost_minimizing = FALSE; - gcost_rplans = FALSE; - } else { - gcost_minimizing = TRUE; - gcost_rplans = TRUE; - } - - gw = gcmd_line.w; - - if ( !gcmd_line.cost_rplans ) { - gcost_rplans = FALSE; - } - - if ( gcmd_line.cost_bound != -1 && gcmd_line.cost_bound < 0 ) { - printf("\n\nff: invalid cost bound %f; must be >= 0.\n\n", - gcmd_line.cost_bound); - return FALSE; - } - - return TRUE; - -} - diff --git a/gen/ff_planner/makefile b/gen/ff_planner/makefile deleted file mode 100644 index b8ace7b81..000000000 --- a/gen/ff_planner/makefile +++ /dev/null @@ -1,89 +0,0 @@ -#!/bin/sh -# - - -####### FLAGS - -TYPE = -ADDONS = - -CC = gcc - -CFLAGS = -O6 -ansi $(TYPE) $(ADDONS) -g -# -g -pg - -LIBS = -lm - - -####### Files - -PDDL_PARSER_SRC = scan-fct_pddl.tab.c \ - scan-ops_pddl.tab.c \ - scan-probname.tab.c \ - lex.fct_pddl.c \ - lex.ops_pddl.c - -PDDL_PARSER_OBJ = scan-fct_pddl.tab.o \ - scan-ops_pddl.tab.o - - -SOURCES = main.c \ - memory.c \ - output.c \ - parse.c \ - expressions.c \ - inst_pre.c \ - inst_easy.c \ - inst_hard.c \ - inst_final.c \ - relax.c \ - search.c - -OBJECTS = $(SOURCES:.c=.o) - -####### Implicit rules - -.SUFFIXES: - -.SUFFIXES: .c .o - -.c.o:; $(CC) -c $(CFLAGS) $< - -####### Build rules - - -ff: $(OBJECTS) $(PDDL_PARSER_OBJ) - $(CC) -o ff $(OBJECTS) $(PDDL_PARSER_OBJ) $(CFLAGS) $(LIBS) - -# pddl syntax -scan-fct_pddl.tab.c: scan-fct_pddl.y lex.fct_pddl.c - bison -pfct_pddl -bscan-fct_pddl scan-fct_pddl.y - -scan-ops_pddl.tab.c: scan-ops_pddl.y lex.ops_pddl.c - bison -pops_pddl -bscan-ops_pddl scan-ops_pddl.y - -lex.fct_pddl.c: lex-fct_pddl.l - flex -Pfct_pddl lex-fct_pddl.l - -lex.ops_pddl.c: lex-ops_pddl.l - flex -Pops_pddl lex-ops_pddl.l - - -# misc -clean: - rm -f *.o *.bak *~ *% core *_pure_p9_c0_400.o.warnings \ - \#*\# $(RES_PARSER_SRC) $(PDDL_PARSER_SRC) - -veryclean: clean - rm -f ff H* J* K* L* O* graph.* *.symbex gmon.out \ - $(PDDL_PARSER_SRC) \ - lex.fct_pddl.c lex.ops_pddl.c lex.probname.c \ - *.output - -depend: - makedepend -- $(SOURCES) $(PDDL_PARSER_SRC) - -lint: - lclint -booltype Bool $(SOURCES) 2> output.lint - -# DO NOT DELETE diff --git a/gen/ff_planner/memory.c b/gen/ff_planner/memory.c deleted file mode 100644 index 601cea497..000000000 --- a/gen/ff_planner/memory.c +++ /dev/null @@ -1,1278 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: memory.c - * Description: Creation and Deletion functions for all data structures. - * - * Author: Joerg Hoffmann - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" -#include "memory.h" - - -#include "inst_pre.h" - - - - - - -/********************** - * CREATION FUNCTIONS * - **********************/ - - - - - - - - - - - -/* parsing - */ - - - - - - - - - -char *new_Token( int len ) - -{ - - char *tok = ( char * ) calloc( len, sizeof( char ) ); - CHECK_PTR(tok); - - return tok; - -} - - - -TokenList *new_TokenList( void ) - -{ - - TokenList *result = ( TokenList * ) calloc( 1, sizeof( TokenList ) ); - CHECK_PTR(result); - - result->item = NULL; - result->next = NULL; - - return result; - -} - - - -FactList *new_FactList( void ) - -{ - - FactList *result = ( FactList * ) calloc( 1, sizeof( FactList ) ); - CHECK_PTR(result); - - result->item = NULL; - result->next = NULL; - - return result; - -} - - - -TypedList *new_TypedList( void ) - -{ - - TypedList *result = ( TypedList * ) calloc( 1, sizeof( TypedList ) ); - CHECK_PTR(result); - - result->name = NULL; - result->type = NULL; - result->n = -1; - - return result; - -} - - - -TypedListList *new_TypedListList( void ) - -{ - - TypedListList *result = ( TypedListList * ) calloc( 1, sizeof( TypedListList ) ); - CHECK_PTR(result); - - result->predicate = NULL; - result->args = NULL; - - return result; - -} - - - -ParseExpNode *new_ParseExpNode( ExpConnective c ) - -{ - - ParseExpNode *result = ( ParseExpNode * ) calloc( 1, sizeof( ParseExpNode ) ); - CHECK_PTR(result); - - result->connective = c; - result->atom = NULL; - result->leftson = NULL; - result->rightson = NULL; - - return result; - -} - - - -PlNode *new_PlNode( Connective c ) - -{ - - PlNode *result = ( PlNode * ) calloc( 1, sizeof( PlNode ) ); - CHECK_PTR(result); - - result->connective = c; - result->atom = NULL; - - result->comp = -1; - result->neft = -1; - result->lh = NULL; - result->rh = NULL; - - result->sons = NULL; - result->next = NULL; - - return result; - -} - - - -PlOperator *new_PlOperator( char *name ) - -{ - - PlOperator *result = ( PlOperator * ) calloc( 1, sizeof( PlOperator ) ); - CHECK_PTR(result); - - if ( name ) { - result->name = new_Token(strlen(name)+1); - CHECK_PTR(result->name); - strcpy(result->name, name); - } else { - result->name = NULL; - } - - result->params = NULL; - result->preconds = NULL; - result->effects = NULL; - result->number_of_real_params = 0; - result->next = NULL; - - return result; - -} - - - -PlOperator *new_axiom_op_list( void ) - -{ - - static int count; - char *name; - PlOperator *ret; - - /* WARNING: count should not exceed 999 - */ - count++; - if ( count == 10000 ) { - printf("\ntoo many axioms! look into memory.c, line 157\n\n"); - exit( 1 ); - } - name = new_Token(strlen(HIDDEN_STR)+strlen(AXIOM_STR)+4+1); - sprintf(name, "%s%s%4d", HIDDEN_STR, AXIOM_STR, count); - - ret = new_PlOperator(name); - free(name); - - return ret; - -} - - - - - - - - - - - - - - -/* instantiation - */ - - - - - - - - - - - -Fact *new_Fact( void ) - -{ - - Fact *result = ( Fact * ) calloc( 1, sizeof( Fact ) ); - CHECK_PTR(result); - - return result; - -} - - - -Fluent *new_Fluent( void ) - -{ - - Fluent *result = ( Fluent * ) calloc( 1, sizeof( Fluent ) ); - CHECK_PTR(result); - - return result; - -} - - - -FluentValue *new_FluentValue( void ) - -{ - - FluentValue *result = ( FluentValue * ) calloc( 1, sizeof( FluentValue ) ); - CHECK_PTR(result); - - return result; - -} - - - -Facts *new_Facts( void ) - -{ - - Facts *result = ( Facts * ) calloc( 1, sizeof( Facts ) ); - CHECK_PTR(result); - - result->fact = new_Fact(); - - result->next = NULL; - - return result; - -} - - - -FluentValues *new_FluentValues( void ) - -{ - - FluentValues *result = ( FluentValues * ) calloc( 1, sizeof( FluentValues ) ); - CHECK_PTR(result); - - result->next = NULL; - - return result; - -} - - - -ExpNode *new_ExpNode( ExpConnective c ) - -{ - - ExpNode *result = ( ExpNode * ) calloc( 1, sizeof( ExpNode ) ); - CHECK_PTR(result); - - result->connective = c; - result->fluent = NULL; - result->fl = -2; - result->c = 1; - result->son = NULL; - result->leftson = NULL; - result->rightson = NULL; - - return result; - -} - - - -WffNode *new_WffNode( Connective c ) - -{ - - WffNode *result = ( WffNode * ) calloc( 1, sizeof( WffNode ) ); - CHECK_PTR(result); - - result->connective = c; - - result->var = -1; - result->var_type = -1; - result->var_name = NULL; - - result->sons = NULL; - result->next = NULL; - result->prev = NULL; - - result->fact = NULL; - result->NOT_p = -1; - - result->son = NULL; - - result->comp = -1; - result->lh = NULL; - result->rh = NULL; - - result->visited = FALSE; - - return result; - -} - - - -Literal *new_Literal( void ) - -{ - - Literal *result = ( Literal * ) calloc( 1, sizeof( Literal ) ); - CHECK_PTR(result); - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -NumericEffect *new_NumericEffect( void ) - -{ - - NumericEffect *result = ( NumericEffect * ) calloc( 1, sizeof( NumericEffect ) ); - CHECK_PTR(result); - - result->rh = NULL; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -Effect *new_Effect( void ) - -{ - - Effect *result = ( Effect * ) calloc( 1, sizeof( Effect ) ); - CHECK_PTR(result); - - result->num_vars = 0; - - result->conditions = NULL; - - result->effects = NULL; - result->numeric_effects = NULL; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -Operator *new_Operator( char *name, int norp ) - -{ - - int i; - - Operator *result = ( Operator * ) calloc( 1, sizeof( Operator ) ); - CHECK_PTR(result); - - if ( name ) { - result->name = new_Token( strlen( name ) + 1 ); - CHECK_PTR( result->name ); - strcpy( result->name, name ); - } else { - result->name = NULL; - } - - result->num_vars = 0; - result->number_of_real_params = norp; - - for ( i = 0; i < MAX_VARS; i++ ) { - result->removed[i] = FALSE; - } - - result->preconds = NULL; - - result->effects = NULL; - - result->hard = TRUE; - - return result; - -} - - - -NormEffect *new_NormEffect1( Effect *e ) - -{ - - int i; - - NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); - CHECK_PTR(result); - - result->num_vars = e->num_vars; - for ( i = 0; i < e->num_vars; i++ ) { - result->var_types[i] = e->var_types[i]; - result->inst_table[i] = -1; - } - - result->conditions = NULL; - result->num_conditions = 0; - - result->adds = NULL; - result->num_adds = 0; - result->dels = NULL; - result->num_dels = 0; - - result->numeric_conditions_comp = NULL; - result->numeric_conditions_lh = NULL; - result->numeric_conditions_rh = NULL; - result->num_numeric_conditions = 0; - - result->numeric_effects_neft = NULL; - result->numeric_effects_fluent = NULL; - result->numeric_effects_rh = NULL; - result->num_numeric_effects = 0; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -NormEffect *new_NormEffect2( NormEffect *e ) - -{ - - int i, j; - - NormEffect *result = ( NormEffect * ) calloc( 1, sizeof( NormEffect ) ); - CHECK_PTR(result); - - result->num_vars = 0; - - result->conditions = ( Fact * ) calloc( e->num_conditions, sizeof( Fact ) ); - result->num_conditions = e->num_conditions; - for ( i = 0; i < e->num_conditions; i++ ) { - result->conditions[i].predicate = e->conditions[i].predicate; - for ( j = 0; j < garity[e->conditions[i].predicate]; j++ ) { - result->conditions[i].args[j] = e->conditions[i].args[j]; - } - } - result->adds = ( Fact * ) calloc( e->num_adds, sizeof( Fact ) ); - result->num_adds = e->num_adds; - for ( i = 0; i < e->num_adds; i++ ) { - result->adds[i].predicate = e->adds[i].predicate; - for ( j = 0; j < garity[e->adds[i].predicate]; j++ ) { - result->adds[i].args[j] = e->adds[i].args[j]; - } - } - result->dels = ( Fact * ) calloc( e->num_dels, sizeof( Fact ) ); - result->num_dels = e->num_dels; - for ( i = 0; i < e->num_dels; i++ ) { - result->dels[i].predicate = e->dels[i].predicate; - for ( j = 0; j < garity[e->dels[i].predicate]; j++ ) { - result->dels[i].args[j] = e->dels[i].args[j]; - } - } - - result->numeric_conditions_comp = ( Comparator * ) - calloc( e->num_numeric_conditions, sizeof( Comparator ) ); - result->numeric_conditions_lh = ( ExpNode_pointer * ) - calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - result->numeric_conditions_rh = ( ExpNode_pointer * ) - calloc( e->num_numeric_conditions, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - result->numeric_conditions_comp[i] = e->numeric_conditions_comp[i]; - result->numeric_conditions_lh[i] = copy_Exp( e->numeric_conditions_lh[i] ); - result->numeric_conditions_rh[i] = copy_Exp( e->numeric_conditions_rh[i] ); - } - result->num_numeric_conditions = e->num_numeric_conditions; - result->numeric_effects_neft = ( NumericEffectType * ) - calloc( e->num_numeric_effects, sizeof( NumericEffectType ) ); - result->numeric_effects_fluent = ( Fluent * ) - calloc( e->num_numeric_effects, sizeof( Fluent ) ); - result->numeric_effects_rh = ( ExpNode_pointer * ) - calloc( e->num_numeric_effects, sizeof( ExpNode_pointer ) ); - for ( i = 0; i < e->num_numeric_effects; i++ ) { - result->numeric_effects_neft[i] = e->numeric_effects_neft[i]; - result->numeric_effects_fluent[i].function = e->numeric_effects_fluent[i].function; - for ( j = 0; j < gf_arity[e->numeric_effects_fluent[i].function]; j++ ) { - result->numeric_effects_fluent[i].args[j] = e->numeric_effects_fluent[i].args[j]; - } - result->numeric_effects_rh[i] = copy_Exp( e->numeric_effects_rh[i] ); - } - result->num_numeric_effects = e->num_numeric_effects; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -NormOperator *new_NormOperator( Operator *op ) - -{ - - int i; - - NormOperator *result = ( NormOperator * ) calloc( 1, sizeof( NormOperator ) ); - CHECK_PTR(result); - - result->operator = op; - - result->num_vars = op->num_vars; - for ( i = 0; i < op->num_vars; i++ ) { - result->var_types[i] = op->var_types[i]; - result->inst_table[i] = -1; - } - result->num_removed_vars = 0; - - result->preconds = NULL; - result->num_preconds = 0; - - result->numeric_preconds_comp = NULL; - result->numeric_preconds_lh = NULL; - result->numeric_preconds_rh = NULL; - result->num_numeric_preconds = 0; - - result->effects = NULL; - - return result; - -} - - - - -EasyTemplate *new_EasyTemplate( NormOperator *op ) - -{ - - EasyTemplate *result = ( EasyTemplate * ) calloc( 1, sizeof( EasyTemplate ) ); - CHECK_PTR(result); - - result->op = op; - - result->prev = NULL; - result->next = NULL; - - return result; - -} - - - -MixedOperator *new_MixedOperator( Operator *op ) - -{ - - MixedOperator *result = ( MixedOperator * ) calloc( 1, sizeof( MixedOperator ) ); - CHECK_PTR(result); - - result->operator = op; - - result->preconds = NULL; - result->num_preconds = 0; - - result->effects = NULL; - - return result; - -} - - - -PseudoActionEffect *new_PseudoActionEffect( void ) - -{ - - PseudoActionEffect *result = - ( PseudoActionEffect * ) calloc( 1, sizeof( PseudoActionEffect ) ); - CHECK_PTR(result); - - result->conditions = NULL; - result->num_conditions = 0; - - result->adds = NULL; - result->num_adds = 0; - result->dels = NULL; - result->num_dels = 0; - - result->numeric_conditions_comp = NULL; - result->numeric_conditions_lh = NULL; - result->numeric_conditions_rh = NULL; - result->num_numeric_conditions = 0; - - result->numeric_effects_neft = NULL; - result->numeric_effects_fluent = NULL; - result->numeric_effects_rh = NULL; - result->num_numeric_effects = 0; - - result->next = NULL; - - return result; - -} - - - -PseudoAction *new_PseudoAction( MixedOperator *op ) - -{ - - int i; - - PseudoAction *result = ( PseudoAction * ) calloc( 1, sizeof( PseudoAction ) ); - CHECK_PTR(result); - - result->operator = op->operator; - for ( i = 0; i < op->operator->num_vars; i++ ) { - result->inst_table[i] = op->inst_table[i]; - } - - result->preconds = op->preconds; - result->num_preconds = op->num_preconds; - - result->numeric_preconds_comp = op->numeric_preconds_comp; - result->numeric_preconds_lh = op->numeric_preconds_lh; - result->numeric_preconds_rh = op->numeric_preconds_rh; - result->num_numeric_preconds = op->num_numeric_preconds; - - result->effects = NULL; - result->num_effects = 0; - - return result; - -} - - - -LnfExpNode *new_LnfExpNode( void ) - -{ - - LnfExpNode *result = ( LnfExpNode * ) calloc( 1, sizeof( LnfExpNode ) ); - CHECK_PTR(result); - - result->num_pF = 0; - result->num_nF = 0; - - result->c = 0; - - return result; - -} - - - -Action *new_Action( void ) - -{ - - Action *result = ( Action * ) calloc( 1, sizeof( Action ) ); - CHECK_PTR(result); - - result->norm_operator = NULL; - result->pseudo_action = NULL; - - result->next = NULL; - - return result; - -} - - - -void make_state( State *pointer, int ft, int fl ) - -{ - - int i; - - pointer->F = ( int * ) calloc( ft, sizeof( int ) ); - pointer->f_D = ( Bool * ) calloc( fl, sizeof( Bool ) ); - pointer->f_V = ( float * ) calloc( fl, sizeof( float ) ); - - for ( i = 0; i < fl; i++ ) { - pointer->f_D[i] = FALSE; - } - -} - - - -EhcNode *new_EhcNode( void ) - -{ - - EhcNode *result = ( EhcNode * ) calloc( 1, sizeof( EhcNode ) ); - CHECK_PTR(result); - - make_state( &(result->S), gnum_ft_conn, gnum_fl_conn ); - - result->father = NULL; - result->next = NULL; - - return result; - -} - - - -EhcHashEntry *new_EhcHashEntry( void ) - -{ - - EhcHashEntry *result = ( EhcHashEntry * ) calloc( 1, sizeof( EhcHashEntry ) ); - CHECK_PTR(result); - - result->ehc_node = NULL; - - result->next = NULL; - - return result; - -} - - - -PlanHashEntry *new_PlanHashEntry( void ) - -{ - - PlanHashEntry *result = ( PlanHashEntry * ) calloc( 1, sizeof( PlanHashEntry ) ); - CHECK_PTR(result); - - result->next_step = NULL; - - result->next = NULL; - - return result; - -} - - - -BfsNode *new_BfsNode( void ) - -{ - - BfsNode *result = ( BfsNode * ) calloc( 1, sizeof( BfsNode ) ); - CHECK_PTR(result); - - result->father = NULL; - - result->next = NULL; - result->prev = NULL; - - return result; - -} - - - -BfsHashEntry *new_BfsHashEntry( void ) - -{ - - BfsHashEntry *result = ( BfsHashEntry * ) calloc( 1, sizeof( BfsHashEntry ) ); - CHECK_PTR(result); - - result->bfs_node = NULL; - - result->next = NULL; - - return result; - -} - - - - - - - - - - - -/********************** - * DELETION FUNCTIONS * - **********************/ - - - - - - - - - - - - -void free_TokenList( TokenList *source ) - -{ - - if ( source ) { - free_TokenList( source->next ); - if ( source->item ) { - free( source->item ); - } - free( source ); - } - -} - - - -void free_FactList( FactList *source ) - -{ - - if ( source ) { - free_FactList( source->next ); - free_TokenList( source->item ); - free( source ); - } - -} - - - -void free_ParseExpNode( ParseExpNode *n ) - -{ - - if ( n ) { - free_TokenList( n->atom ); - free_ParseExpNode( n->leftson ); - free_ParseExpNode( n->rightson ); - free( n ); - } - -} - - - -void free_PlNode( PlNode *node ) - -{ - - if ( node ) { - free_ParseExpNode( node->lh ); - free_ParseExpNode( node->rh ); - free_PlNode( node->sons ); - free_PlNode( node->next ); - free_TokenList( node->atom ); - free( node ); - } - -} - - - -void free_PlOperator( PlOperator *o ) - -{ - - if ( o ) { - free_PlOperator( o->next ); - - if ( o->name ) { - free( o->name ); - } - - free_FactList( o->params ); - free_PlNode( o->preconds ); - free_PlNode( o->effects ); - - free( o ); - } - -} - - - -void free_Operator( Operator *o ) - -{ - - if ( o ) { - /* need not free more: the only point where that happens - * is only directly after first allocation - */ - - if ( o->name ) { - free( o->name ); - } - - free( o ); - } - -} - - - -void free_ExpNode( ExpNode *n ) - -{ - - if ( n ) { - if ( n->fluent ) free( n->fluent ); - free_ExpNode( n->son ); - free_ExpNode( n->leftson ); - free_ExpNode( n->rightson ); - free( n ); - } - -} - - - -void free_WffNode( WffNode *w ) - -{ - - if ( w ) { - free_WffNode( w->son ); - free_WffNode( w->sons ); - free_WffNode( w->next ); - if ( w->var_name ) { - free( w->var_name ); - } - if ( w->fact ) free( w->fact ); - free_ExpNode( w->lh ); - free_ExpNode( w->rh ); - free( w ); - } - -} - - - -void free_NormEffect( NormEffect *e ) - -{ - - int i; - - if ( e ) { - free_NormEffect( e->next ); - - if ( e->conditions ) { - free( e->conditions ); - } - if ( e->adds ) { - free( e->adds ); - } - if ( e->dels ) { - free( e->dels ); - } - - if ( e->numeric_conditions_comp ) { - free( e->numeric_conditions_comp ); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - free_ExpNode( e->numeric_conditions_lh[i] ); - free_ExpNode( e->numeric_conditions_rh[i] ); - } - if ( e->numeric_conditions_lh ) { - free( e->numeric_conditions_lh ); - } - if ( e->numeric_conditions_rh ) { - free( e->numeric_conditions_rh ); - } - - if ( e->numeric_effects_neft ) { - free( e->numeric_effects_neft ); - } - if ( e->numeric_effects_fluent ) { - free( e->numeric_effects_fluent ); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - free_ExpNode( e->numeric_effects_rh[i] ); - } - if ( e->numeric_effects_rh ) { - free( e->numeric_effects_rh ); - } - - free( e ); - } - -} - - - -void free_partial_Effect( Effect *e ) - -{ - - if ( e ) { - free_partial_Effect( e->next ); - - free_WffNode( e->conditions ); - - free( e ); - } - -} - - - -void free_NormOperator( NormOperator *o ) - -{ - - int i; - - if ( o ) { - - if ( o->preconds ) { - free( o->preconds ); - } - if ( o->numeric_preconds_comp ) { - free( o->numeric_preconds_comp ); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - free_ExpNode( o->numeric_preconds_lh[i] ); - free_ExpNode( o->numeric_preconds_rh[i] ); - } - if ( o->numeric_preconds_lh ) { - free( o->numeric_preconds_lh ); - } - if ( o->numeric_preconds_rh ) { - free( o->numeric_preconds_rh ); - } - free_NormEffect( o->effects ); - - free( o ); - } - -} - - - -void free_single_NormEffect( NormEffect *e ) - -{ - - int i; - - if ( e ) { - if ( e->conditions ) { - free( e->conditions ); - } - if ( e->adds ) { - free( e->adds ); - } - if ( e->dels ) { - free( e->dels ); - } - - if ( e->numeric_conditions_comp ) { - free( e->numeric_conditions_comp ); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - free_ExpNode( e->numeric_conditions_lh[i] ); - free_ExpNode( e->numeric_conditions_rh[i] ); - } - if ( e->numeric_conditions_lh ) { - free( e->numeric_conditions_lh ); - } - if ( e->numeric_conditions_rh ) { - free( e->numeric_conditions_rh ); - } - - if ( e->numeric_effects_neft ) { - free( e->numeric_effects_neft ); - } - if ( e->numeric_effects_fluent ) { - free( e->numeric_effects_fluent ); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - free_ExpNode( e->numeric_effects_rh[i] ); - } - if ( e->numeric_effects_rh ) { - free( e->numeric_effects_rh ); - } - - free( e ); - } - -} - - - -void free_single_EasyTemplate( EasyTemplate *t ) - -{ - - if ( t ) { - free( t ); - } - -} - - - -void free_TypedList( TypedList *t ) - -{ - - if ( t ) { - if ( t->name ) { - free( t->name ); - t->name = NULL; - } - if ( t->type ) { - free_TokenList( t->type ); - t->type = NULL; - } - free_TypedList( t->next ); - - free( t ); - } - -} - - - -void free_TypedListList( TypedListList *t ) - -{ - - if ( t ) { - if ( t->predicate ) { - free( t->predicate ); - t->predicate = NULL; - } - if ( t->args ) { - free_TypedList( t->args ); - t->args = NULL; - } - free_TypedListList( t->next ); - - free( t ); - } - -} - - - -void free_BfsNode( BfsNode *n ) - -{ - - if ( n ) { - free_BfsNode( n->next ); - free( n ); - } - -} - - - -void free_BfsHashEntry( BfsHashEntry *n ) - -{ - - if ( n ) { - free_BfsHashEntry( n->next ); - free( n ); - } - -} diff --git a/gen/ff_planner/memory.h b/gen/ff_planner/memory.h deleted file mode 100644 index 13e8ddfb3..000000000 --- a/gen/ff_planner/memory.h +++ /dev/null @@ -1,109 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - -/********************************************************************* - * File: memory.h - * Description: Creation / Deletion functions for all data structures. - * - * Author: Joerg Hoffmann / Frank Rittinger - * - *********************************************************************/ - - - - - - -#ifndef _MEMORY_H -#define _MEMORY_H - - - - - -char *new_Token( int len ); -TokenList *new_TokenList( void ); -FactList *new_FactList( void ); -TypedList *new_TypedList( void ); -TypedListList *new_TypedListList( void ); -ParseExpNode *new_ParseExpNode( ExpConnective c ); -PlNode *new_PlNode( Connective c ); -PlOperator *new_PlOperator( char *name ); -PlOperator *new_axiom_op_list( void ); - - - -Fact *new_Fact( void ); -Fluent *new_Fluent( void ); -FluentValue *new_FluentValue( void ); -Facts *new_Facts( void ); -FluentValues *new_FluentValues( void ); -ExpNode *new_ExpNode( ExpConnective c ); -WffNode *new_WffNode( Connective c ); -Literal *new_Literal( void ); -NumericEffect *new_NumericEffect( void ); -Effect *new_Effect( void ); -Operator *new_Operator( char *name, int norp ); -NormEffect *new_NormEffect1( Effect *e ); -NormEffect *new_NormEffect2( NormEffect *e ); -NormOperator *new_NormOperator( Operator *op ); -EasyTemplate *new_EasyTemplate( NormOperator *op ); -MixedOperator *new_MixedOperator( Operator *op ); -PseudoActionEffect *new_PseudoActionEffect( void ); -PseudoAction *new_PseudoAction( MixedOperator *op ); -LnfExpNode *new_LnfExpNode( void ); -Action *new_Action( void ); -void make_state( State *pointer, int ft, int fl ); -EhcNode *new_EhcNode( void ); -EhcHashEntry *new_EhcHashEntry( void ); -PlanHashEntry *new_PlanHashEntry( void ); -BfsNode *new_BfsNode( void ); -BfsHashEntry *new_BfsHashEntry( void ); - - - - - - - -void free_TokenList( TokenList *source ); -void free_FactList( FactList *source ); -void free_ParseExpNode( ParseExpNode *n ); -void free_PlNode( PlNode *node ); -void free_PlOperator( PlOperator *o ); -void free_Operator( Operator *o ); -void free_ExpNode( ExpNode *n ); -void free_WffNode( WffNode *w ); -void free_NormEffect( NormEffect *e ); -void free_partial_Effect( Effect *e ); -void free_NormOperator( NormOperator *o ); -void free_single_NormEffect( NormEffect *e ); -void free_single_EasyTemplate( EasyTemplate *t ); -void free_TypedList( TypedList *t ); -void free_TypedListList( TypedListList *t ); -void free_ActionEffect( ActionEffect *e ); -void free_BfsNode( BfsNode *n ); -void free_BfsHashEntry( BfsHashEntry *n ); - - - - - - -#endif /* _MEMORY_H */ diff --git a/gen/ff_planner/output.c b/gen/ff_planner/output.c deleted file mode 100644 index 1341eff7a..000000000 --- a/gen/ff_planner/output.c +++ /dev/null @@ -1,1482 +0,0 @@ -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: output.c - * Description: printing info out - * - * Author: Joerg Hoffmann - * - *********************************************************************/ - - - - - -#include "ff.h" - -#include "output.h" - - - - - - - -/* parsing - */ - - - - - - - -void print_FactList( FactList *list, char *sepf, char *sept ) - -{ - - FactList *i_list; - TokenList *i_tl; - - if ( list ) { - i_tl = list->item; - if (NULL == i_tl || NULL == i_tl->item) { - printf("empty"); - } else { - printf("%s", i_tl->item); - i_tl = i_tl->next; - } - - while (NULL != i_tl) { - if (NULL != i_tl->item) { - printf("%s%s", sept, i_tl->item); - } - i_tl = i_tl->next; - } - - for ( i_list = list->next; i_list; i_list = i_list->next ) { - printf("%s", sepf); - i_tl = i_list->item; - if (NULL == i_tl || NULL == i_tl->item) { - printf("empty"); - } else { - printf("%s", i_tl->item); - i_tl = i_tl->next; - } - - while (NULL != i_tl) { - if (NULL != i_tl->item) { - printf("%s%s", sept, i_tl->item); - } - i_tl = i_tl->next; - } - } - } - -} - - - -void print_hidden_TokenList( TokenList *list, char *sep ) - -{ - - TokenList *i_tl; - - i_tl = list; - if (NULL!=i_tl) { - printf("%s", i_tl->item); - i_tl = i_tl->next; - } else { - printf("empty"); - } - - while (NULL != i_tl) { - printf("%s%s", sep, i_tl->item); - i_tl = i_tl->next; - } - -} - - - -void print_indent( int indent ) - -{ - - int i; - for (i=0;iconnective) { - case AD: - printf("(+ "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case SU: - printf("(- "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case MU: - printf("(* "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case DI: - printf("(/ "); - print_ParseExpNode( n->leftson ); - print_ParseExpNode( n->rightson ); - printf(")"); - break; - case MINUS: - printf("(- "); - print_ParseExpNode( n->leftson ); - printf(")"); - break; - case NUMBER: - printf("%s", n->atom->item); - break; - case FHEAD: - printf("("); - print_hidden_TokenList(n->atom, " "); - printf(")"); - break; - default: - printf("\n\nprint Parseexpnode: wrong specifier %d", - n->connective); - } - -} - - - -void print_PlNode( PlNode *plnode, int indent ) - -{ - - PlNode *i_son; - - if ( !plnode ) { - printf("none\n"); - return; - } - - switch (plnode->connective) { - case ALL: - printf("ALL %s : %s\n", plnode->atom->item, - plnode->atom->next->item); - print_indent(indent); - printf("( "); - print_PlNode(plnode->sons,indent+4); - print_indent(indent); - printf(")\n"); - break; - case EX: - printf("EX %s : %s\n", plnode->atom->item, - plnode->atom->next->item); - print_indent(indent); - printf("( "); - print_PlNode(plnode->sons,indent+4); - print_indent(indent); - printf(")\n"); - break; - case AND: - printf("A( "); - print_PlNode(plnode->sons, indent+4); - if ( plnode->sons ) { - for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { - print_indent(indent); - printf("AND "); - print_PlNode(i_son,indent+4); - } - } - print_indent(indent); - printf(")\n"); - break; - case OR: - printf("O( "); - print_PlNode(plnode->sons, indent+4); - for ( i_son = plnode->sons->next; i_son!=NULL; i_son = i_son->next ) { - print_indent(indent); - printf("OR "); - print_PlNode(i_son,indent+4); - } - print_indent(indent); - printf(")\n"); - break; - case WHEN: - printf("IF "); - print_PlNode(plnode->sons,indent+5); - print_indent(indent); - printf("THEN "); - print_PlNode(plnode->sons->next,indent+5); - print_indent(indent); - printf("ENDIF\n"); - break; - case NOT: - if (ATOM==plnode->sons->connective) { - printf("NOT "); - print_PlNode(plnode->sons,indent+4); - } else { - printf("NOT("); - print_PlNode(plnode->sons,indent+4); - print_indent(indent+3); - printf(")\n"); - } - break; - case ATOM: - printf("("); - print_hidden_TokenList(plnode->atom, " "); - printf(")\n"); - break; - case TRU: - printf("(TRUE)\n"); - break; - case FAL: - printf("(FALSE)\n"); - break; - case COMP: - switch (plnode->comp) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\n\nillegal comp in parse tree!\n\n"); - exit( 1 ); - } - print_ParseExpNode( plnode->lh ); - print_ParseExpNode( plnode->rh ); - printf(")\n"); - break; - case NEF: - switch (plnode->neft) { - case ASSIGN: - printf("(assign "); - break; - case SCALE_UP: - printf("(scale-up "); - break; - case SCALE_DOWN: - printf("(scale-down "); - break; - case INCREASE: - printf("(increase "); - break; - case DECREASE: - printf("(decrease "); - break; - } - print_ParseExpNode( plnode->lh ); - print_ParseExpNode( plnode->rh ); - printf(")\n"); - break; - default: - printf("\n***** ERROR ****"); - printf("\nprint_plnode: %d > Wrong Node specifier\n", plnode->connective); - exit(1); - } - -} - - - -void print_plops( PlOperator *plop ) - -{ - - PlOperator *i_plop; - int count = 0; - - if ( !plop ) { - printf("none\n"); - } - - for ( i_plop = plop; i_plop!=NULL; i_plop = i_plop->next ) { - printf("\n"); - if ( i_plop->axiom ) printf("AXIOM-"); - printf("OPERATOR "); - printf("%s", i_plop->name); - printf("\nparameters: (%d real)\n", i_plop->number_of_real_params); - print_FactList ( i_plop->params, "\n", " : "); - printf("\n\npreconditions:\n"); - print_PlNode(i_plop->preconds, 0); - printf("effects:\n"); - print_PlNode(i_plop->effects, 0); - printf("\n-----\n"); - count++; - } - printf("\nAnzahl der Operatoren: %d\n", count); - -} - - - -void print_ExpNode( ExpNode *n ) - -{ - - if ( !n ) return; - - switch ( n->connective) { - case AD: - printf("(+ "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case SU: - printf("(- "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case MU: - printf("(* "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case DI: - printf("(/ "); - print_ExpNode( n->leftson ); - print_ExpNode( n->rightson ); - printf(")"); - break; - case MINUS: - printf("(- "); - print_ExpNode( n->son ); - printf(")"); - break; - case NUMBER: - printf("%.2f", n->value); - break; - case FHEAD: - if ( n->fluent ) { - print_Fluent( n->fluent ); - } else { - if ( n->fl >= 0 ) { - printf(" %.2f*", n->c); - print_fl_name( n->fl ); - } else { - printf("[UNDEF]"); - } - } - break; - default: - printf("\n\nprint Expnode: wrong specifier %d", - n->connective); - } - -} - - - -void print_Wff( WffNode *n, int indent ) - -{ - - WffNode *i; - - if ( !n ) { - printf("none\n"); - return; - } - - switch (n->connective) { - case ALL: - printf("ALL x%d (%s): %s\n", n->var, n->var_name, - gtype_names[n->var_type]); - print_indent(indent); - printf("( "); - print_Wff(n->son,indent+4); - print_indent(indent); - printf(")\n"); - break; - case EX: - printf("EX x%d (%s) : %s\n", n->var, n->var_name, - gtype_names[n->var_type]); - print_indent(indent); - printf("( "); - print_Wff(n->son,indent+4); - print_indent(indent); - printf(")\n"); - break; - case AND: - printf("A( "); - print_Wff(n->sons, indent+4); - if ( n->sons ) { - for ( i = n->sons->next; i!=NULL; i = i->next ) { - if ( !i->prev ) { - printf("\nprev in AND not correctly set!\n\n"); - exit( 1 ); - } - print_indent(indent); - printf("AND "); - print_Wff(i,indent+4); - } - } - print_indent(indent); - printf(")\n"); - break; - case OR: - printf("O( "); - print_Wff(n->sons, indent+4); - for ( i = n->sons->next; i!=NULL; i = i->next ) { - print_indent(indent); - printf("OR "); - print_Wff(i,indent+4); - } - print_indent(indent); - printf(")\n"); - break; - case NOT: - if (ATOM==n->son->connective) { - printf("NOT "); - print_Wff(n->son,indent+4); - } else { - printf("NOT("); - print_Wff(n->son,indent+4); - print_indent(indent+3); - printf(")\n"); - } - break; - case ATOM: - print_Fact(n->fact); - if ( n->NOT_p != -1 ) printf(" - translation NOT"); - printf("\n"); - break; - case TRU: - printf("(TRUE)\n"); - break; - case FAL: - printf("(FALSE)\n"); - break; - case COMP: - switch (n->comp) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in WFF %d\n\n", n->comp); - exit( 1 ); - } - print_ExpNode( n->lh ); - print_ExpNode( n->rh ); - printf(")\n"); - break; - default: - printf("\n***** ERROR ****"); - printf("\nprint_Wff: %d > Wrong Node specifier\n", n->connective); - exit(1); - } - -} - - - -void print_Operator( Operator *o ) - -{ - - Effect *e; - Literal *l; - NumericEffect *ne; - int i, m = 0; - - printf("\n\n----------------Operator %s, axiom %d, translated form, step 1--------------\n", - o->name, o->axiom); - - for ( i = 0; i < o->num_vars; i++ ) { - printf("\nx%d (%s) of type %s, removed ? %s", - i, o->var_names[i], gtype_names[o->var_types[i]], - o->removed[i] ? "YES" : "NO"); - } - printf("\ntotal params %d, real params %d\n", - o->num_vars, o->number_of_real_params); - - printf("\nPreconds:\n"); - print_Wff( o->preconds, 0 ); - - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d, parameters %d", m++, e->num_vars); - - for ( i = 0; i < e->num_vars; i++ ) { - printf("\nx%d (%s) of type %s", - o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]); - } - printf("\nConditions\n"); - print_Wff( e->conditions, 0 ); - printf("\nEffect Literals"); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - printf("\nNOT "); - } else { - printf("\n"); - } - print_Fact( &(l->fact) ); - } - printf("\nNumeric Effects"); - for ( ne = e->numeric_effects; ne; ne = ne->next ) { - switch ( ne->neft ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); - exit( 1 ); - } - print_Fluent( &(ne->fluent) ); - print_ExpNode( ne->rh ); - } - } - -} - - - -void print_NormOperator( NormOperator *o ) - -{ - - NormEffect *e; - int i, m; - - printf("\n\n----------------Operator %s, normalized form--------------\n", - o->operator->name); - - for ( i = 0; i < o->num_vars; i++ ) { - printf("\nx%d of type ", i); - print_type( o->var_types[i] ); - } - printf("\n\n%d vars removed from original operator:", - o->num_removed_vars); - for ( i = 0; i < o->num_removed_vars; i++ ) { - m = o->removed_vars[i]; - printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m], - gtype_names[o->operator->var_types[m]]); - print_type( o->type_removed_vars[i] ); - } - - printf("\nPreconds:\n"); - for ( i = 0; i < o->num_preconds; i++ ) { - print_Fact( &(o->preconds[i]) ); - printf("\n"); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - switch ( o->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normpre %d\n\n", - o->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( o->numeric_preconds_lh[i] ); - print_ExpNode( o->numeric_preconds_rh[i] ); - printf(")\n"); - } - - m = 0; - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d, parameters %d", m++, e->num_vars); - - for ( i = 0; i < e->num_vars; i++ ) { - printf("\nx%d of type ", o->num_vars + i); - print_type( e->var_types[i] ); - } - printf("\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_Fact( &(e->conditions[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - switch ( e->numeric_conditions_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normeff %d\n\n", - e->numeric_conditions_comp[i]); - exit( 1 ); - } - print_ExpNode( e->numeric_conditions_lh[i] ); - print_ExpNode( e->numeric_conditions_rh[i] ); - printf(")\n"); - } - - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_Fact( &(e->adds[i]) ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_Fact( &(e->dels[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - switch ( e->numeric_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint normop: illegal neft %d\n\n", - e->numeric_effects_neft[i]); - exit( 1 ); - } - print_Fluent( &(e->numeric_effects_fluent[i]) ); - print_ExpNode( e->numeric_effects_rh[i] ); - } - } - -} - - - -void print_MixedOperator( MixedOperator *o ) - -{ - - int i, m; - Effect *e; - NumericEffect *ne; - Literal *l; - - printf("\n\n----------------Operator %s, mixed form--------------\n", - o->operator->name); - - for ( i = 0; i < o->operator->num_vars; i++ ) { - printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); - print_type( o->operator->var_types[i] ); - } - - printf("\nPreconds:\n"); - for ( i = 0; i < o->num_preconds; i++ ) { - print_Fact( &(o->preconds[i]) ); - printf("\n"); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - switch ( o->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", - o->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( o->numeric_preconds_lh[i] ); - print_ExpNode( o->numeric_preconds_rh[i] ); - printf(")\n"); - } - - m = 0; - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d, parameters %d", m++, e->num_vars); - - for ( i = 0; i < e->num_vars; i++ ) { - printf("\nx%d of type %s", - o->operator->num_vars + i, gtype_names[e->var_types[i]]); - } - printf("\nConditions\n"); - print_Wff( e->conditions, 0 ); - printf("\nEffect Literals"); - for ( l = e->effects; l; l = l->next ) { - if ( l->negated ) { - printf("\nNOT "); - } else { - printf("\n"); - } - print_Fact( &(l->fact) ); - } - printf("\nNumeric Effects"); - for ( ne = e->numeric_effects; ne; ne = ne->next ) { - switch ( ne->neft ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); - exit( 1 ); - } - print_Fluent( &(ne->fluent) ); - print_ExpNode( ne->rh ); - } - } - -} - - - -void print_PseudoAction( PseudoAction *o ) - -{ - - PseudoActionEffect *e; - int i, m; - - printf("\n\n----------------Pseudo Action %s--------------\n", - o->operator->name); - - for ( i = 0; i < o->operator->num_vars; i++ ) { - printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); - print_type( o->operator->var_types[i] ); - } - - printf("\nPreconds:\n"); - for ( i = 0; i < o->num_preconds; i++ ) { - print_Fact( &(o->preconds[i]) ); - printf("\n"); - } - for ( i = 0; i < o->num_numeric_preconds; i++ ) { - switch ( o->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", - o->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( o->numeric_preconds_lh[i] ); - print_ExpNode( o->numeric_preconds_rh[i] ); - printf(")\n"); - } - - m = 0; - printf("\n\nEffects:"); - for ( e = o->effects; e; e = e->next ) { - printf("\n\neffect %d", m++); - printf("\n\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_Fact( &(e->conditions[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - switch ( e->numeric_conditions_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normeff %d\n\n", - e->numeric_conditions_comp[i]); - exit( 1 ); - } - print_ExpNode( e->numeric_conditions_lh[i] ); - print_ExpNode( e->numeric_conditions_rh[i] ); - printf(")\n"); - } - - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_Fact( &(e->adds[i]) ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_Fact( &(e->dels[i]) ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - switch ( e->numeric_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint normop: illegal neft %d\n\n", - e->numeric_effects_neft[i]); - exit( 1 ); - } - print_Fluent( &(e->numeric_effects_fluent[i]) ); - print_ExpNode( e->numeric_effects_rh[i] ); - } - } - -} - - - -void print_Action( Action *a ) - -{ - - ActionEffect *e; - int i, j; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("\n\nAction REACH-GOAL"); - } else { - printf("\n\nAction %s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - - printf("\n\nPreconds:\n"); - for ( i = 0; i < a->num_preconds; i++ ) { - print_ft_name( a->preconds[i] ); - printf("\n"); - } - for ( i = 0; i < a->num_numeric_preconds; i++ ) { - switch ( a->numeric_preconds_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in actionpre %d\n\n", - a->numeric_preconds_comp[i]); - exit( 1 ); - } - print_ExpNode( a->numeric_preconds_lh[i] ); - print_ExpNode( a->numeric_preconds_rh[i] ); - printf(")\n"); - } - - printf("\n\nEffects:"); - for ( j = 0; j < a->num_effects; j++ ) { - printf("\n\neffect %d", j); - e = &(a->effects[j]); - if ( e->illegal ) printf(" ILLEGAL EFFECT!"); - printf("\n\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_ft_name( e->conditions[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_conditions; i++ ) { - switch ( e->numeric_conditions_comp[i] ) { - case LE: - printf("(< "); - break; - case LEQ: - printf("(<= "); - break; - case EQ: - printf("(= "); - break; - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in normeff %d\n\n", - e->numeric_conditions_comp[i]); - exit( 1 ); - } - print_ExpNode( e->numeric_conditions_lh[i] ); - print_ExpNode( e->numeric_conditions_rh[i] ); - printf(")\n"); - } - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_ft_name( e->adds[i] ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_ft_name( e->dels[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_numeric_effects; i++ ) { - switch ( e->numeric_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case SCALE_UP: - printf("\nscale-up "); - break; - case SCALE_DOWN: - printf("\nscale-down "); - break; - case INCREASE: - printf("\nincrease "); - break; - case DECREASE: - printf("\ndecrease "); - break; - default: - printf("\n\nprint normop: illegal neft %d\n\n", - e->numeric_effects_neft[i]); - exit( 1 ); - } - if ( e->numeric_effects_fl[i] >= 0 ) { - print_fl_name( e->numeric_effects_fl[i] ); - } else { - printf("[UNDEF]"); - } - print_ExpNode( e->numeric_effects_rh[i] ); - } - } - -} - - - -void print_Action_name( Action *a ) - -{ - - int i; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("REACH-GOAL"); - } else { - printf("%s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - -} - - - -void print_lnf_Action( Action *a ) - -{ - - ActionEffect *e; - int i, j; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("\n\nAction REACH-GOAL"); - } else { - printf("\n\nAction %s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - - printf("\n\nPreconds:\n"); - for ( i = 0; i < a->num_preconds; i++ ) { - print_ft_name( a->preconds[i] ); - printf("\n"); - } - for ( i = 0; i < a->num_lnf_preconds; i++ ) { - switch ( a->lnf_preconds_comp[i] ) { - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in lnf actionpre %d\n\n", - a->lnf_preconds_comp[i]); - exit( 1 ); - } - print_LnfExpNode( a->lnf_preconds_lh[i] ); - printf(" %.2f)\n", a->lnf_preconds_rh[i]); - } - - printf("\n\nEffects:"); - for ( j = 0; j < a->num_effects; j++ ) { - printf("\n\neffect %d COST %f", j, a->effects[j].cost); - e = &(a->effects[j]); - if ( e->illegal ) printf(" ILLEGAL EFFECT!"); - if ( e->removed ) printf(" REMOVED!!!"); - printf("\n\nConditions\n"); - for ( i = 0; i < e->num_conditions; i++ ) { - print_ft_name( e->conditions[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_lnf_conditions; i++ ) { - switch ( e->lnf_conditions_comp[i] ) { - case GEQ: - printf("(>= "); - break; - case GE: - printf("(> "); - break; - default: - printf("\nwrong comparator of Expnodes in lnf normeff %d\n\n", - e->lnf_conditions_comp[i]); - exit( 1 ); - } - print_LnfExpNode( e->lnf_conditions_lh[i] ); - printf(" %.2f)\n", e->lnf_conditions_rh[i] ); - } - printf("\nAdds\n"); - for ( i = 0; i < e->num_adds; i++ ) { - print_ft_name( e->adds[i] ); - printf("\n"); - } - printf("\nDels\n"); - for ( i = 0; i < e->num_dels; i++ ) { - print_ft_name( e->dels[i] ); - printf("\n"); - } - for ( i = 0; i < e->num_lnf_effects; i++ ) { - switch ( e->lnf_effects_neft[i] ) { - case ASSIGN: - printf("\nassign "); - break; - case INCREASE: - printf("\nincrease "); - break; - default: - printf("\n\nprint lnf normop: illegal neft %d\n\n", - e->lnf_effects_neft[i]); - exit( 1 ); - } - if ( e->lnf_effects_fl[i] >= 0 ) { - print_fl_name( e->lnf_effects_fl[i] ); - } else { - printf("[UNDEF]"); - } - print_LnfExpNode( e->lnf_effects_rh[i] ); - } - } - -} - - - -void print_type( int t ) - -{ - - int j; - - if ( gpredicate_to_type[t] == -1 ) { - if ( gnum_intersected_types[t] == -1 ) { - printf("%s", gtype_names[t]); - } else { - printf("INTERSECTED TYPE ("); - for ( j = 0; j < gnum_intersected_types[t]; j++ ) { - if ( gpredicate_to_type[gintersected_types[t][j]] == -1 ) { - printf("%s", gtype_names[gintersected_types[t][j]]); - } else { - printf("UNARY INERTIA TYPE (%s)", - gpredicates[gpredicate_to_type[gintersected_types[t][j]]]); - } - if ( j < gnum_intersected_types[t] - 1 ) { - printf(" and "); - } - } - printf(")"); - } - } else { - printf("UNARY INERTIA TYPE (%s)", gpredicates[gpredicate_to_type[t]]); - } - -} - - - -void print_Fact( Fact *f ) - -{ - - int j; - - if ( f->predicate == -3 ) { - printf("GOAL-REACHED"); - return; - } - - if ( f->predicate == -1 ) { - printf("(="); - for ( j=0; j<2; j++ ) { - printf(" "); - if ( f->args[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - return; - } - - if ( f->predicate == -2 ) { - printf("(!="); - for ( j=0; j<2; j++ ) { - printf(" "); - if ( f->args[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - return; - } - - printf("(%s", gpredicates[f->predicate]); - for ( j=0; jpredicate]; j++ ) { - printf(" "); - if ( f->args[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - -} - - - -void print_Fluent( Fluent *f ) - -{ - - int j, ff = f->function; - - printf("(%s", gfunctions[ff]); - for ( j=0; jargs[j] >= 0 ) { - printf("%s", gconstants[(f->args)[j]]); - } else { - printf("x%d", DECODE_VAR( f->args[j] )); - } - } - printf(")"); - -} - - - -void print_ft_name( int index ) - -{ - - print_Fact( &(grelevant_facts[index]) ); - -} - - - -void print_fl_name( int index ) - -{ - - int i; - - if ( index < 0 ) { - if ( index != -2 ) { - printf("[UNDEF]"); - } else { - printf("[TOTAL-TIME]"); - } - return; - } - - if ( grelevant_fluents_lnf[index] == NULL ) { - /* this is a non-artificial "atomic" one - * (or the mirrored version of one) - */ - printf("[RF%d](%s)", index, grelevant_fluents_name[index]); - } else { - /* this only summarizes a LNF requirement - */ - printf("[artRF%d]", index); - for ( i = 0; i < grelevant_fluents_lnf[index]->num_pF; i++ ) { - printf("%.2f*", grelevant_fluents_lnf[index]->pC[i] ); - print_fl_name( grelevant_fluents_lnf[index]->pF[i] ); - if ( i < grelevant_fluents_lnf[index]->num_pF - 1 ) { - printf(" + "); - } - } - } - -} - - - -void print_LnfExpNode( LnfExpNode *n ) - -{ - - int i; - - printf("(("); - for ( i = 0; i < n->num_pF; i++ ) { - printf("%.2f*", n->pC[i]); - print_fl_name( n->pF[i] ); - } - printf(") - ("); - for ( i = 0; i < n->num_nF; i++ ) { - printf("%.2f*", n->nC[i]); - print_fl_name( n->nF[i] ); - } - printf(") + %.2f)", n->c); - -} - - - -void print_op_name( int index ) - -{ - - int i; - Action *a = gop_conn[index].action; - - if ( !a->norm_operator && - !a->pseudo_action ) { - printf("REACH-GOAL"); - } else { - printf("%s", a->name ); - for ( i = 0; i < a->num_name_vars; i++ ) { - printf(" %s", gconstants[a->name_inst_table[i]]); - } - } - -} - - - -void print_State( State S ) - -{ - - int i; - - for ( i = 0; i < S.num_F; i++ ) { - printf("\n"); - print_ft_name( S.F[i] ); - } - for ( i = 0; i < gnum_relevant_fluents; i++ ) { - printf("\n"); - print_fl_name( i ); - printf(": "); - if ( S.f_D[i] ) { - printf("%.2f", S.f_V[i]); - } else { - printf("UNDEF"); - } - } - -} - - - - - - - - -/* - * program output routines - */ - - - - - - - - - -void print_plan( void ) - -{ - - int i; - float cost = 0; - - printf("\n\nff: found legal plan as follows"); - printf("\nstep "); - for ( i = 0; i < gnum_plan_ops; i++ ) { - printf("%4d: ", i); - print_op_name( gplan_ops[i] ); - if ( i < gnum_plan_ops-1 ) { - printf("\n "); - } - if ( goptimization_established ) { - cost += gop_conn[gplan_ops[i]].cost; - } - } - if ( goptimization_established ) { - printf("\nplan cost: %f", cost); - } - -} diff --git a/gen/ff_planner/output.h b/gen/ff_planner/output.h deleted file mode 100644 index a74e87607..000000000 --- a/gen/ff_planner/output.h +++ /dev/null @@ -1,68 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: output.h - * Description: print headers - * - * Author: Joerg Hoffmann 1999 - * - *********************************************************************/ - - - - - -#ifndef _OUTPUT_H -#define _OUTPUT_H - - - -void print_FactList( FactList *list, char *sepf, char *sept ); -void print_hidden_TokenList( TokenList *list, char *sep ); -void print_indent( int indent ); -void print_ParseExpNode( ParseExpNode *n ); -void print_PlNode( PlNode *plnode, int indent ); -void print_ExpNode( ExpNode *n ); -void print_Wff( WffNode *n, int indent ); -void print_plops( PlOperator *plop ); -void print_Operator( Operator *o ); -void print_NormOperator( NormOperator *o ); -void print_MixedOperator( MixedOperator *o ); -void print_PseudoAction( PseudoAction *o ); -void print_Action( Action *a ); -void print_Action_name( Action *a ); -void print_lnf_Action( Action *a ); -void print_type( int t ); -void print_Fact( Fact *f ); -void print_Fluent( Fluent *f ); -void print_ft_name( int index ); -void print_op_name( int index ); -void print_fl_name( int index ); -void print_LnfExpNode( LnfExpNode *n ); -void print_State( State S ); - - - -void print_plan( void ); - - - -#endif /* _OUTPUT_H */ diff --git a/gen/ff_planner/parse.c b/gen/ff_planner/parse.c deleted file mode 100644 index cc5a099f9..000000000 --- a/gen/ff_planner/parse.c +++ /dev/null @@ -1,1339 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: parse.c - * Description: Functions for the pddl parser - * - * Author: Joerg Hoffmann 2000 - * - *********************************************************************/ - - - - - - -#include "ff.h" - -#include "memory.h" -#include "output.h" - -#include "parse.h" - - - - - - - - - - - -/* simple parse helpers - */ - - - - - - - -char *copy_Token( char *s ) - -{ - - char *d = new_Token( strlen( s ) + 1 ); - strcpy(d, s); - - return d; - -} - - - -TokenList *copy_TokenList( TokenList *source ) - -{ - - TokenList *temp; - - if ( !source ) { - temp = NULL; - } else { - temp = new_TokenList(); - if ( source->item ) { - temp->item = new_Token( strlen( source->item ) + 1 ); - strcpy( temp->item, source->item ); - } - temp->next = copy_TokenList( source->next ); - } - - return temp; - -} - - - -void strupcase( char *from ) - -{ - - char tmp; - - tmp = *from; - while ('\0' != tmp) { - *from = (char) toupper((int) tmp); - tmp = *++from; - } - -} - - - -char *rmdash( char *s ) - -{ - - s++; - - for( ; (*s == ' ') || (*s == '\t'); s++ ); - - return s; - -} - - - - - - - - - - -/* typed-list-of preprocessing - */ - - - - - - - -Token ltype_names[MAX_TYPES]; -int lnum_types; - - -int leither_ty[MAX_TYPES][MAX_TYPES]; -int lnum_either_ty[MAX_TYPES]; - - - - - -void build_orig_constant_list( void ) - -{ - - char *tmp = NULL; - TypedList *tyl; - TypedListList *tyll; - TokenList *tl, *p_tl, *tmp_tl; - PlOperator *po; - - int i, j, k, n, std; - - Bool m[MAX_TYPES][MAX_TYPES]; - - FactList *fl, *p_fl; - - lnum_types = 0; - for ( tyl = gparse_types; tyl; tyl = tyl->next ) { - if ( get_type( tyl->name ) == -1 ) { - ltype_names[lnum_types++] = copy_Token( tyl->name ); - } - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - - for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - - for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - - for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - } - - for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - } - - collect_type_names_in_pl( gorig_goal_facts ); - - for ( po = gloaded_ops; po; po = po->next ) { - collect_type_names_in_pl( po->preconds ); - collect_type_names_in_pl( po->effects ); - for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (n = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = n; - } - free( tmp ); - tmp = NULL; - } - } - - - /* now get the numbers of all composed either types - */ - for ( i = 0; i < lnum_types; i++ ) { - lnum_either_ty[i] = 0; - } - for ( tyl = gparse_types; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - } - for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { - for ( tyl = tyll->args; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - } - make_either_ty_in_pl( gorig_goal_facts ); - for ( po = gloaded_ops; po; po = po->next ) { - make_either_ty_in_pl( po->preconds ); - make_either_ty_in_pl( po->effects ); - for ( tyl = po->parse_params; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - } - - - /* now, compute the transitive closure of all type inclusions. - * first initialize the matrix. - */ - for ( i = 0; i < lnum_types; i++ ) { - for ( j = 0; j < lnum_types; j++ ) { - m[i][j] = ( i == j ? TRUE : FALSE ); - } - } - std = -1; - for ( i = 0; i < lnum_types; i++ ) { - if ( strcmp( ltype_names[i], STANDARD_TYPE ) == SAME ) { - std = i; - break; - } - } - for ( i = 0; i < lnum_types; i++ ) { - m[i][std] = TRUE;/* all types are subtypes of OBJECT */ - } - for ( tyl = gparse_types; tyl; tyl = tyl->next ) { - /* all inclusions as are defined in domain file - */ - m[get_type( tyl->name )][tyl->n] = TRUE; - } - /* compute transitive closure on inclusions matrix - */ - for ( j = 0; j < lnum_types; j++ ) { - for ( i = 0; i < lnum_types; i++ ) { - if ( m[i][j] ) { - for ( k = 0; k < lnum_types; k++ ) { - if ( m[j][k] ) { - m[i][k] = TRUE; - } - } - } - } - } - /* union types are subsets of all those types that contain all - * their components, and - * all component types are subsets of the either type ! - */ - for ( i = 0; i < lnum_types; i++ ) { - if ( lnum_either_ty[i] < 2 ) continue; - for ( j = 0; j < lnum_types; j++ ) { - if ( j == i ) continue; - /* get supertypes of all component types - */ - for ( k = 0; k < lnum_either_ty[i]; k++ ) { - if ( !m[leither_ty[i][k]][j] ) break; - } - if ( k < lnum_either_ty[i] ) continue; - m[i][j] = TRUE; - /* make components subtypes of either type - */ - for ( k = 0; k < lnum_either_ty[i]; k++ ) { - m[leither_ty[i][k]][i] = TRUE; - } - } - } - /* and again, compute transitive closure on inclusions matrix. - * I guess, this won't change anything (?), but it also won't need - * any remarkable computation time, so why should one think about it ? - */ - for ( j = 0; j < lnum_types; j++ ) { - for ( i = 0; i < lnum_types; i++ ) { - if ( m[i][j] ) { - for ( k = 0; k < lnum_types; k++ ) { - if ( m[j][k] ) { - m[i][k] = TRUE; - } - } - } - } - } - - - /* now build FactList of ALL constant -> type pairs. - * for each constant / object, let it appear separately - * for each type it is a member of; compute type - * membership based on propagating constants / objects - * through inclusions matrix. - * - * this might make the same pair appear doubly, if an object - * is declared in type T as well as in some supertype T'. - * such cases will be filtered out in string collection. - */ - for ( tyl = gparse_constants; tyl; tyl = tyl->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyl->type->item ); - } - fl->next = gorig_constant_list; - gorig_constant_list = fl; - /* now add constant to all supertypes - */ - n = get_type( fl->item->next->item ); - for ( i = 0; i < lnum_types; i++ ) { - if ( i == n || - !m[n][i] ) continue; - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - fl->item->next->item = copy_Token( ltype_names[i] ); - fl->next = gorig_constant_list; - gorig_constant_list = fl; - } - } - for ( tyl = gparse_objects; tyl; tyl = tyl->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyl->type->item ); - } - fl->next = gorig_constant_list; - gorig_constant_list = fl; - /* now add constant to all supertypes - */ - n = get_type( fl->item->next->item ); - for ( i = 0; i < lnum_types; i++ ) { - if ( i == n || - !m[n][i] ) continue; - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - fl->item->next->item = copy_Token( ltype_names[i] ); - fl->next = gorig_constant_list; - gorig_constant_list = fl; - } - } - - - /* now, normalize all typed-list-of s in domain and problem def, - * i.e., in all PlNode quantifiers and in op parameters - * - * at the same time, remove typed-listof structures in these defs - */ - normalize_tyl_in_pl( &gorig_goal_facts ); - for ( po = gloaded_ops; po; po = po->next ) { - normalize_tyl_in_pl( &po->preconds ); - normalize_tyl_in_pl( &po->effects ); - /* be careful to maintain parameter ordering ! - */ - if ( !po->parse_params ) { - continue;/* no params at all */ - } - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( po->parse_params->name ); - if ( po->parse_params->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = po->parse_params->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( po->parse_params->type->item ); - } - po->params = fl; - p_fl = fl; - for ( tyl = po->parse_params->next; tyl; tyl = tyl->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->next = new_TokenList(); - fl->item->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyl->type->item ); - } - p_fl->next = fl; - p_fl = fl; - } - free_TypedList( po->parse_params ); - po->parse_params = NULL; - } - - - /* finally, build gpredicates_and_types by chaining predicate names - * together with the names of their args' types. - */ - for ( tyll = gparse_predicates; tyll; tyll = tyll->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->item = copy_Token( tyll->predicate ); - fl->next = gpredicates_and_types; - gpredicates_and_types = fl; - if ( !tyll->args ) continue; - /* add arg types; MAINTAIN ORDERING ! - */ - fl->item->next = new_TokenList(); - if ( tyll->args->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyll->args->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyll->args->type->item ); - } - p_tl = fl->item->next; - for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { - tmp_tl = new_TokenList(); - if ( tyl->type->next ) { - tmp_tl->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp_tl->item, CONNECTOR ); - strcat( tmp_tl->item, tl->item ); - } - } else { - tmp_tl->item = copy_Token( tyl->type->item ); - } - p_tl->next = tmp_tl; - p_tl = tmp_tl; - } - } - - for ( tyll = gparse_functions; tyll; tyll = tyll->next ) { - fl = new_FactList(); - fl->item = new_TokenList(); - fl->item->item = copy_Token( tyll->predicate ); - fl->next = gfunctions_and_types; - gfunctions_and_types = fl; - if ( !tyll->args ) continue; - /* add arg types; MAINTAIN ORDERING ! - */ - fl->item->next = new_TokenList(); - if ( tyll->args->type->next ) { - fl->item->next->item = new_Token( MAX_LENGTH ); - strcpy( fl->item->next->item, EITHER_STR ); - for ( tl = tyll->args->type; tl; tl = tl->next ) { - strcat( fl->item->next->item, CONNECTOR ); - strcat( fl->item->next->item, tl->item ); - } - } else { - fl->item->next->item = copy_Token( tyll->args->type->item ); - } - p_tl = fl->item->next; - for ( tyl = tyll->args->next; tyl; tyl = tyl->next ) { - tmp_tl = new_TokenList(); - if ( tyl->type->next ) { - tmp_tl->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp_tl->item, CONNECTOR ); - strcat( tmp_tl->item, tl->item ); - } - } else { - tmp_tl->item = copy_Token( tyl->type->item ); - } - p_tl->next = tmp_tl; - p_tl = tmp_tl; - } - } - - /* now get rid of remaining typed-list-of parsing structures - */ - free_TypedList( gparse_types ); - gparse_types = NULL; - free_TypedList( gparse_constants ); - gparse_constants = NULL; - free_TypedList( gparse_objects ); - gparse_objects = NULL; - free_TypedListList( gparse_predicates ); - gparse_predicates = NULL; - free_TypedListList( gparse_functions ); - gparse_functions = NULL; - -} - - - -void collect_type_names_in_pl( PlNode *n ) - -{ - - PlNode *i; - TypedList *tyl; - TokenList *tl; - char *tmp = NULL; - int nn; - - if ( !n ) { - return; - } - - switch( n->connective ) { - case ALL: - case EX: - for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { - if ( tyl->type->next ) { - tmp = new_Token( MAX_LENGTH ); - strcpy( tmp, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp, CONNECTOR ); - strcat( tmp, tl->item ); - } - } else { - tmp = copy_Token( tyl->type->item ); - } - if ( (nn = get_type( tmp )) == -1 ) { - tyl->n = lnum_types; - ltype_names[lnum_types++] = copy_Token( tmp ); - } else { - tyl->n = nn; - } - free( tmp ); - tmp = NULL; - } - collect_type_names_in_pl( n->sons ); - break; - case AND: - case OR: - for ( i = n->sons; i; i = i->next ) { - collect_type_names_in_pl( i ); - } - break; - case NOT: - collect_type_names_in_pl( n->sons ); - break; - case ATOM: - case TRU: - case FAL: - break; - case WHEN: - collect_type_names_in_pl( n->sons ); - collect_type_names_in_pl( n->sons->next ); - break; - default: - break; - } - -} - - - -int get_type( char *str ) - -{ - - int i; - - for ( i = 0; i < lnum_types; i++ ) { - if ( strcmp( str, ltype_names[i] ) == SAME ) return i; - } - - return -1; - -} - - - -void make_either_ty( TypedList *tyl ) - -{ - - TokenList *i; - - if ( lnum_either_ty[tyl->n] > 0 ) { - return; - } - - for ( i = tyl->type; i; i = i->next ) { - leither_ty[tyl->n][lnum_either_ty[tyl->n]++] = get_type( i->item ); - } - -} - - - -void make_either_ty_in_pl( PlNode *n ) - -{ - - PlNode *i; - TypedList *tyl; - - if ( !n ) { - return; - } - - switch( n->connective ) { - case ALL: - case EX: - for ( tyl = n->parse_vars; tyl; tyl = tyl->next ) { - make_either_ty( tyl ); - } - make_either_ty_in_pl( n->sons ); - break; - case AND: - case OR: - for ( i = n->sons; i; i = i->next ) { - make_either_ty_in_pl( i ); - } - break; - case NOT: - make_either_ty_in_pl( n->sons ); - break; - case ATOM: - case TRU: - case FAL: - break; - case WHEN: - make_either_ty_in_pl( n->sons ); - make_either_ty_in_pl( n->sons->next ); - break; - default: - break; - } - -} - - - -void normalize_tyl_in_pl( PlNode **n ) - -{ - - PlNode *i; - TypedList *tyl; - PlNode *tmp_pl = NULL, *sons, *p_pl; - TokenList *tmp_tl, *tl; - - - if ( !(*n) ) { - return; - } - - switch( (*n)->connective ) { - case ALL: - case EX: - /* we need to make a sequence of quantifiers ( ->sons ...) - * out of the given sequence of TypedList elements, - * with connected type names, var - name in TokenList - * and KEEPING THE SAME ORDERING !! - */ - if ( !(*n)->parse_vars ) { - printf("\n\nquantifier without argument !! check input files.\n\n"); - exit( 1 ); - } - tmp_tl = new_TokenList(); - tmp_tl->next = new_TokenList(); - tmp_tl->item = copy_Token( (*n)->parse_vars->name ); - if ( (*n)->parse_vars->type->next ) { - tmp_tl->next->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->next->item, EITHER_STR ); - for ( tl = (*n)->parse_vars->type; tl; tl = tl->next ) { - strcat( tmp_tl->next->item, CONNECTOR ); - strcat( tmp_tl->next->item, tl->item ); - } - } else { - tmp_tl->next->item = copy_Token( (*n)->parse_vars->type->item ); - } - (*n)->atom = tmp_tl; - /* now add list of sons - */ - sons = (*n)->sons; - p_pl = *n; - for ( tyl = (*n)->parse_vars->next; tyl; tyl = tyl->next ) { - tmp_tl = new_TokenList(); - tmp_tl->next = new_TokenList(); - tmp_tl->item = copy_Token( tyl->name ); - if ( tyl->type->next ) { - tmp_tl->next->item = new_Token( MAX_LENGTH ); - strcpy( tmp_tl->next->item, EITHER_STR ); - for ( tl = tyl->type; tl; tl = tl->next ) { - strcat( tmp_tl->next->item, CONNECTOR ); - strcat( tmp_tl->next->item, tl->item ); - } - } else { - tmp_tl->next->item = copy_Token( tyl->type->item ); - } - tmp_pl = new_PlNode( (*n)->connective ); - tmp_pl->atom = tmp_tl; - p_pl->sons = tmp_pl; - p_pl = tmp_pl; - } - /* remove typed-list-of info - */ - free_TypedList( (*n)->parse_vars ); - (*n)->parse_vars = NULL; - /* the last son in list takes over ->sons - */ - p_pl->sons = sons; - /* normalize this sons and get out - */ - normalize_tyl_in_pl( &(p_pl->sons) ); - break; - case AND: - case OR: - for ( i = (*n)->sons; i; i = i->next ) { - normalize_tyl_in_pl( &i ); - } - break; - case NOT: - normalize_tyl_in_pl( &((*n)->sons) ); - break; - case ATOM: - case TRU: - case FAL: - break; - case WHEN: - normalize_tyl_in_pl( &((*n)->sons) ); - normalize_tyl_in_pl( &((*n)->sons->next) ); - break; - default: - break; - } - -} - - - - - - - - - - - - -/* ADL syntax test - and normalization (AND s etc.) - */ - - - - - - - - - - - - -Bool make_adl_domain( void ) - -{ - - PlOperator *i; - FactList *ff; - - if ( gcmd_line.display_info == 101 ) { - printf("\noriginal problem parsing is:\n"); - printf("\nobjects:"); - for ( ff = gorig_constant_list; ff; ff = ff->next ) { - printf("\n%s : %s", ff->item->item, ff->item->next->item); - } - printf("\n\ninitial state:\n"); - print_PlNode( gorig_initial_facts, 0 ); - printf("\n\ngoal state:\n"); - print_PlNode( gorig_goal_facts, 0 ); - printf("\n\nops:"); - print_plops( gloaded_ops ); - } - - if ( !make_conjunction_of_atoms( &gorig_initial_facts ) ) { - printf("\nillegal initial state"); - return FALSE; - } - - if ( !gorig_goal_facts ) { - gorig_goal_facts = new_PlNode( TRU ); - } - - if ( !is_wff( gorig_goal_facts ) ) { - printf("\nillegal goal formula"); - print_PlNode( gorig_goal_facts, 0 ); - return FALSE; - } - - for ( i = gloaded_ops; i; i = i->next ) { - if ( !i->preconds ) { - i->preconds = new_PlNode( TRU ); - } - if ( !is_wff( i->preconds ) ) { - printf("\nop %s has illegal precondition", i->name); - return FALSE; - } - if ( !make_effects( &(i->effects) ) ) { - printf("\nop %s has illegal effects", i->name); - return FALSE; - } - } - - if ( gcmd_line.display_info == 102 ) { - printf("\nfinal ADL representation is:\n"); - printf("\nobjects:"); - for ( ff = gorig_constant_list; ff; ff = ff->next ) { - printf("\n%s : %s", ff->item->item, ff->item->next->item); - } - printf("\n\ninitial state:\n"); - print_PlNode( gorig_initial_facts, 0 ); - printf("\n\ngoal formula:\n"); - print_PlNode( gorig_goal_facts, 0 ); - printf("\n\nops:"); - print_plops( gloaded_ops ); - } - - return TRUE; - -} - - - -Bool make_conjunction_of_atoms( PlNode **n ) - -{ - - PlNode *tmp, *i, *p, *m; - - if ( !(*n) ) { - return TRUE; - } - - if ( (*n)->connective != AND ) { - switch ( (*n)->connective ) { - case ATOM: - tmp = new_PlNode( ATOM ); - tmp->atom = (*n)->atom; - (*n)->atom = NULL; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - case COMP: - tmp = new_PlNode( COMP ); - tmp->comp = (*n)->comp; - tmp->lh = (*n)->lh; - tmp->rh = (*n)->rh; - (*n)->lh = NULL; - (*n)->rh = NULL; - (*n)->comp = -1; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - case NOT: - free_PlNode( *n ); - (*n) = NULL; - return TRUE; - default: - return FALSE; - } - } - - p = NULL; - i = (*n)->sons; - while ( i ) { - switch ( i->connective ) { - case ATOM: - break; - case COMP: - break; - case NOT: - if ( p ) { - p->next = i->next; - } else { - (*n)->sons = i->next; - } - m = i->next; - i->next = NULL; - free_PlNode( i ); - i = m; - break; - default: - return FALSE; - } - if ( i->connective != NOT ) { - p = i; - i = i->next; - } - } - - return TRUE; - -} - - - -Bool is_wff( PlNode *n ) - -{ - - PlNode *i; - - if ( !n ) { - return FALSE; - } - - switch( n->connective ) { - case ALL: - case EX: - if ( !(n->atom) || - !(n->atom->next ) || - n->atom->next->next != NULL ) { - return FALSE; - } - return is_wff( n->sons ); - case AND: - case OR: - for ( i = n->sons; i; i = i->next ) { - if ( !is_wff( i ) ) { - return FALSE; - } - } - return TRUE; - case NOT: - return is_wff( n->sons ); - case ATOM: - if ( !(n->atom) || - n->sons != NULL ) { - return FALSE; - } - return TRUE; - case TRU: - case FAL: - if ( n->sons != NULL ) { - return FALSE; - } - return TRUE; - case COMP: - if ( n->sons != NULL || - n->atom != NULL || - n->lh == NULL || - n->rh == NULL || - n->comp < 0 ) { - return FALSE; - } - return TRUE; - default: - return FALSE; - } - -} - - - -Bool make_effects( PlNode **n ) - -{ - - PlNode *tmp, *i, *literals, *j, *k, *next; - int m = 0; - - if ( (*n)->connective != AND ) { - if ( !is_eff_literal( *n ) && - (*n)->connective != ALL && - (*n)->connective != WHEN ) { - return FALSE; - } - tmp = new_PlNode( (*n)->connective ); - tmp->atom = (*n)->atom; - tmp->sons = (*n)->sons; - tmp->neft = (*n)->neft; - tmp->lh = (*n)->lh; - tmp->rh = (*n)->rh; - (*n)->connective = AND; - (*n)->sons = tmp; - (*n)->lh = NULL; - (*n)->rh = NULL; - (*n)->neft = -1; - } - - for ( i = (*n)->sons; i; i = i->next ) { - if ( is_eff_literal( i ) ) { - m++; - continue; - } - if ( i->connective == AND ) { - for ( j = i->sons; j; j = j->next ) { - if ( !is_eff_literal( j ) ) { - return FALSE; - } - m++; - } - continue; - } - if ( i->connective == ALL ) { - for ( j = i->sons; j && j->connective == ALL; j = j->sons ) { - if ( !j->atom || - !j->atom->next || - j->atom->next->next != NULL ) { - return FALSE; - } - } - if ( !j ) { - return FALSE; - } - if ( is_eff_literal( j ) ) { - tmp = new_PlNode( AND ); - for ( k = i; k->sons->connective == ALL; k = k->sons ); - k->sons = tmp; - tmp->sons = j; - j = tmp; - } - if ( j->connective == AND ) { - for ( k = j->sons; k; k = k->next ) { - if ( !is_eff_literal( k ) ) { - return FALSE; - } - } - tmp = new_PlNode( WHEN ); - for ( k = i; k->sons->connective == ALL; k = k->sons ); - k->sons = tmp; - tmp->sons = new_PlNode( TRU ); - tmp->sons->next = j; - continue; - } - if ( j->connective != WHEN ) { - return FALSE; - } - if ( !(j->sons) ) { - j->sons = new_PlNode( TRU ); - } - if ( !is_wff( j->sons ) ) { - return FALSE; - } - if ( !make_conjunction_of_literals( &(j->sons->next) ) ) { - return FALSE; - } - continue; - } - if ( i->connective != WHEN ) { - return FALSE; - } - if ( !(i->sons) ) { - i->sons = new_PlNode( TRU ); - } - if ( !is_wff( i->sons ) ) { - return FALSE; - } - if ( !make_conjunction_of_literals( &(i->sons->next) ) ) { - return FALSE; - } - } - - if ( m == 0 ) { - return TRUE; - } - - tmp = new_PlNode( WHEN ); - tmp->sons = new_PlNode( TRU ); - literals = new_PlNode( AND ); - tmp->sons->next = literals; - tmp->next = (*n)->sons; - (*n)->sons = tmp; - i = (*n)->sons; - while ( i->next ) { - if ( is_eff_literal( i->next ) ) { - next = i->next->next; - i->next->next = literals->sons; - literals->sons = i->next; - i->next = next; - continue; - } - if ( i->next->connective == AND ) { - next = i->next->next; - for ( j = i->next->sons; j && j->next; j = j->next ); - if ( j ) { - j->next = literals->sons; - literals->sons = i->next->sons; - } - i->next = next; - continue; - } - i = i->next; - } - return TRUE; - -} - - - -Bool is_eff_literal( PlNode *n ) - -{ - - if ( !n ) { - return FALSE; - } - - if ( n->connective == NOT ) { - if ( !n->sons || - n->sons->connective != ATOM || - !n->sons->atom ) { - return FALSE; - } - return TRUE; - } - - if ( n->connective == ATOM ) { - if ( !n->atom ) { - return FALSE; - } - return TRUE; - } - - if ( n->connective == NEF ) { - if ( !n->lh || - !n->rh || - n->neft < 0 ) { - return FALSE; - } - return TRUE; - } - - return FALSE; - -} - - - -Bool make_conjunction_of_literals( PlNode **n ) - -{ - - PlNode *tmp, *i; - - if ( !(*n) ) { - return FALSE; - } - - if ( (*n)->connective != AND ) { - if ( (*n)->connective == NOT ) { - if ( !((*n)->sons) || - (*n)->sons->connective != ATOM ) { - return FALSE; - } - tmp = new_PlNode( NOT ); - tmp->sons = (*n)->sons; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - } - if ( (*n)->connective == NEF ) { - tmp = new_PlNode( NEF ); - tmp->neft = (*n)->neft; - tmp->lh = (*n)->lh; - tmp->rh = (*n)->rh; - (*n)->lh = NULL; - (*n)->rh = NULL; - (*n)->neft = -1; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - } - if ( (*n)->connective != ATOM ) { - return FALSE; - } - tmp = new_PlNode( ATOM ); - tmp->atom = (*n)->atom; - (*n)->atom = NULL; - (*n)->connective = AND; - (*n)->sons = tmp; - return TRUE; - } - - for ( i = (*n)->sons; i; i = i->next ) { - if ( !is_eff_literal( i ) ) { - return FALSE; - } - } - - return TRUE; - -} - - diff --git a/gen/ff_planner/parse.h b/gen/ff_planner/parse.h deleted file mode 100644 index f9924c085..000000000 --- a/gen/ff_planner/parse.h +++ /dev/null @@ -1,63 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: parse.h - * Description: Functions for the pddl parser - * - * Author: Frank Rittinger 1998 / Joerg Hoffmann 1999 - * - *********************************************************************/ - - - - - -#ifndef _PARSE_H -#define _PARSE_H - - - -char *copy_Token( char *s ); -TokenList *copy_TokenList( TokenList *source ); -void strupcase( char *from ); -char *rmdash( char *s ); - - - -void build_orig_constant_list( void ); -void collect_type_names_in_pl( PlNode *n ); -int get_type( char *str ); -void make_either_ty( TypedList *tyl ); -void make_either_ty_in_pl( PlNode *n ); -void normalize_tyl_in_pl( PlNode **n ); - - - -Bool make_adl_domain( void ); -Bool make_conjunction_of_atoms( PlNode **n ); -Bool is_wff( PlNode *n ); -Bool make_effects( PlNode **n ); -Bool is_eff_literal( PlNode *n ); -Bool make_conjunction_of_literals( PlNode **n ); - - - -#endif /* PARSE */ diff --git a/gen/ff_planner/relax.c b/gen/ff_planner/relax.c deleted file mode 100644 index dd657ac60..000000000 --- a/gen/ff_planner/relax.c +++ /dev/null @@ -1,2756 +0,0 @@ - -/********************************************************************* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - *********************************************************************/ - - -/********************************************************************* - * File: relax.c - * Description: this file handles the relaxed planning problem, i.e., - * the code is responsible for the heuristic evaluation - * of states during search. - * - * --- THE HEART PEACE OF THE FF PLANNER ! --- - * - * here: linear tasks +=,-=,:= / le / le le - * - * - * Author: Joerg Hoffmann 2000--2002, 2011 - * - *********************************************************************/ - - - - - - - - - -#include "ff.h" - -#include "output.h" -#include "memory.h" - -#include "expressions.h" - -#include "relax.h" -#include "search.h" - - - - - - - -/* local globals - */ - - - - - - - - -/* fixpoint - */ -int *lF; -int lnum_F; -int *lE; -int lnum_E; - -int *lch_E; -int lnum_ch_E; - -int *l0P_E; -int lnum_0P_E; - - - - - -/* 1P extraction - */ -int **lgoals_at; -int *lnum_goals_at; - -float **lf_goals_c_at; -Comparator **lf_goals_comp_at; - -int lh; - -int *lch_F; -int lnum_ch_F; - -int *lused_O; -int lnum_used_O; - -int *lin_plan_E; -int lnum_in_plan_E; - - -/* helpful actions numerical helpers - */ -Comparator *lHcomp; -float *lHc; - - - - - - - - - - - - - - - - - - - - -/************************************* - * helper, for -1 == INFINITY method * - *************************************/ - - - - - - - - - - - - -Bool LESS( int a, int b ) - -{ - - if ( a == INFINITY ) { - return FALSE; - } - - if ( b == INFINITY ) { - return TRUE; - } - - return ( a < b ? TRUE : FALSE ); - -} - - - -Bool FLOAT_LE( float a, float b ) - -{ - - if ( b == INFINITY ) { - return TRUE; - } - - if ( a == INFINITY ) { - return FALSE; - } - - return ( a <= b ? TRUE : FALSE ); - -} - - - - - - - - - - - - - - -/*********************************** - * FUNCTIONS ACCESSED FROM OUTSIDE * - ***********************************/ - - - - - - - - - - - - - - - - - -int get_1P( State *S ) - -{ - - int max, h; - Bool solvable; - - gevaluated_states++; - - solvable = build_fixpoint( S, &max ); - - if ( gcmd_line.display_info == 126 ) { - print_fixpoint_result(); - } - - if ( solvable ) { - h = extract_1P( max ); - } else { - h = INFINITY; - } - - reset_fixpoint( max ); - - return h; - -} - - - -int get_1P_and_H( State *S ) - -{ - - int max, h; - Bool solvable; - - gevaluated_states++; - - solvable = build_fixpoint( S, &max ); - - if ( gcmd_line.display_info == 126 ) { - print_fixpoint_result(); - } - - if ( solvable ) { - h = extract_1P( max ); - collect_H_info(); - } else { - h = INFINITY; - } - - reset_fixpoint( max ); - - return h; - -} - - - -int get_1P_and_A( State *S ) - -{ - - int max, h; - Bool solvable; - - gevaluated_states++; - - solvable = build_fixpoint( S, &max ); - - if ( gcmd_line.display_info == 126 ) { - print_fixpoint_result(); - } - - if ( solvable ) { - h = extract_1P( max ); - } else { - h = INFINITY; - } - - collect_1P_and_A_info(); - reset_fixpoint( max ); - - return h; - -} - - - -void collect_1P_and_A_info( void ) - -{ - - static Bool first_call = TRUE; - - int i; - - if ( first_call ) { - gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); - gnum_A = 0; - first_call = FALSE; - } - - if ( gcmd_line.debug ) { - printf("\ncollect_1P_and_A_info"); - } - - for ( i = 0; i < gnum_A; i++ ) { - gop_conn[gA[i]].is_in_A = FALSE; - } - gnum_A = 0; - - for ( i = 0; i < lnum_E; i++ ) { - if ( gef_conn[lE[i]].level != 0 ) break; - if ( gcmd_line.debug ) { - printf("\ngot applicable op: "); - print_op_name(gef_conn[lE[i]].op); - } - if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { - if ( gcmd_line.debug ) { - printf(" -- already in, skipping it!"); - } - continue; - } - if ( gop_conn[gef_conn[lE[i]].op].axiom ) { - if ( gcmd_line.debug ) { - printf(" -- axiom, skipping it!"); - } - continue; - } - if ( gcmd_line.debug ) { - printf(" -- adding it!"); - } - gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; - gA[gnum_A++] = gef_conn[lE[i]].op; - } - -} - - - -void get_A( State *S ) - -{ - - int i; - - initialize_fixpoint( S ); - - for ( i = 0; i < lnum_F; i++ ) { - activate_ft( lF[i], 0 ); - } - for ( i = 0; i < lnum_0P_E; i++ ) { - if ( gef_conn[l0P_E[i]].in_E ) { - continue; - } - new_ef( l0P_E[i] ); - } - for ( i = 0; i < gnum_fl_conn; i++ ) { - activate_fl( i, 0 ); - } - - collect_A_info(); - - /* 0 should be enough here... - */ - reset_fixpoint( 1 ); - -} - - - -void collect_A_info( void ) - -{ - - static Bool first_call = TRUE; - - int i; - - if ( first_call ) { - gA = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); - gnum_A = 0; - first_call = FALSE; - } - - if ( gcmd_line.debug ) { - printf("\ncollect_A_info"); - } - - for ( i = 0; i < gnum_A; i++ ) { - gop_conn[gA[i]].is_in_A = FALSE; - } - gnum_A = 0; - - for ( i = 0; i < lnum_E; i++ ) { - /* levels are not set unless we actually build the RPG! -/* if ( gef_conn[lE[i]].level != 0 ) break; */ - if ( gcmd_line.debug ) { - printf("\ngot applicable op: "); - print_op_name(gef_conn[lE[i]].op); - } - if ( gop_conn[gef_conn[lE[i]].op].is_in_A ) { - if ( gcmd_line.debug ) { - printf(" -- already in, skipping it!"); - } - continue; - } - if ( gop_conn[gef_conn[lE[i]].op].axiom ) { - if ( gcmd_line.debug ) { - printf(" -- axiom, skipping it!"); - } - continue; - } - if ( gcmd_line.debug ) { - printf(" -- adding it!"); - } - gop_conn[gef_conn[lE[i]].op].is_in_A = TRUE; - gA[gnum_A++] = gef_conn[lE[i]].op; - } - -} - - - -void get_A_axioms( State *S ) - -{ - - int i; - - initialize_fixpoint( S ); - - for ( i = 0; i < lnum_F; i++ ) { - activate_ft( lF[i], 0 ); - } - for ( i = 0; i < lnum_0P_E; i++ ) { - if ( gef_conn[l0P_E[i]].in_E ) { - continue; - } - new_ef( l0P_E[i] ); - } - for ( i = 0; i < gnum_fl_conn; i++ ) { - activate_fl( i, 0 ); - } - - collect_A_axioms_info(); - - /* 0 should be enough here... - */ - reset_fixpoint( 1 ); - -} - - - -void collect_A_axioms_info( void ) - -{ - - static Bool first_call = TRUE; - - int i; - - if ( first_call ) { - gA_axioms = ( int * ) calloc( gnum_op_conn, sizeof( int ) ); - gnum_A_axioms = 0; - first_call = FALSE; - } - - if ( gcmd_line.debug ) { - printf("\ncollect_A_axioms_info"); - } - - for ( i = 0; i < gnum_A_axioms; i++ ) { - gop_conn[gA_axioms[i]].is_in_A_axioms = FALSE; - } - gnum_A_axioms = 0; - - for ( i = 0; i < lnum_E; i++ ) { - /* levels are not set unless we actually build the RPG! -/* if ( gef_conn[lE[i]].level != 0 ) break; */ - if ( gcmd_line.debug ) { - printf("\ngot applicable op: "); - print_op_name(gef_conn[lE[i]].op); - } - if ( gop_conn[gef_conn[lE[i]].op].is_in_A_axioms ) { - if ( gcmd_line.debug ) { - printf(" -- already in, skipping it!"); - } - continue; - } - if ( !gop_conn[gef_conn[lE[i]].op].axiom ) { - if ( gcmd_line.debug ) { - printf(" -- no axiom, skipping it!"); - } - continue; - } - if ( gcmd_line.debug ) { - printf(" -- adding it!"); - } - - gop_conn[gef_conn[lE[i]].op].is_in_A_axioms = TRUE; - gA_axioms[gnum_A_axioms++] = gef_conn[lE[i]].op; - } - -} - - - - - - - - - - - - - - - - - - - - - - - - - - - -/******************************* - * RELAXED FIXPOINT ON A STATE * - *******************************/ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Bool build_fixpoint( State *S, int *max ) - -{ - - int start_ft, stop_ft, start_ef, stop_ef, i, time = 0; - float costlevel; - - initialize_fixpoint( S ); - - start_ft = 0; - start_ef = 0; - while ( TRUE ) { - if ( gcmd_line.debug ) { - printf("\n======================================FP time %d", time); - } - - if ( all_goals_activated( time ) ) { - break; - } - if ( time > 0 || lnum_0P_E == 0 ) { - if ( start_ft == lnum_F ) { - if ( fluents_hopeless( time ) ) { - /* fixpoint, goals not reached - */ - *max = time; - return FALSE; - } - } - } - /* make space if necessary, and copy over - * info from time to time+1 for fluents - */ - extend_fluent_levels( time ); - for ( i = 0; i < gnum_fl_conn; i++ ) { - if ( gfl_conn[i].def[time] ) { - gfl_conn[i].def[time+1] = TRUE; - gfl_conn[i].level[time+1] = gfl_conn[i].level[time]; - } - } - - /* determine the next effect layer: - * - activate the facts - * - if level 0 activate the no preconds-ops - * - activate the fluents at their

#+;>QM z@;Q!udd~bhxC?HB$KA4Qw|@F}|329HJ@5RypU&@G`mjE%H_PET>Sta*Zc{(jkK5FT zyI|kXeSPe!59`D7Sw72W`FhA_`7EF1vwW7{ruQPB<+FU2&+=Km_bi{~vwW7%@>%|F z-D3`!PI-O6B^RjguNBfz#AKR~+eglST B=!pOT diff --git a/gen/layouts/FloorPlan226-objects.json b/gen/layouts/FloorPlan226-objects.json deleted file mode 100644 index 955390880..000000000 --- a/gen/layouts/FloorPlan226-objects.json +++ /dev/null @@ -1,25 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Statue", - "Sofa", - "Blinds", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "Drawer", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "Newspaper", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan226-openable.json b/gen/layouts/FloorPlan226-openable.json deleted file mode 100644 index 3a0e5fab9..000000000 --- a/gen/layouts/FloorPlan226-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "ArmChair|+01.51|+00.00|-00.59": [ - 1.25, - -1.25, - 0, - 30 - ], - "CoffeeTable|-00.71|+00.01|-00.37": [ - -0.5, - -1.0, - 0, - 30 - ], - "Drawer|+01.74|+00.77|+00.33": [ - 0.75, - 0.0, - 90, - 0 - ], - "Drawer|-00.71|+00.08|-00.17": [ - 0.25, - 0.5, - 270, - 30 - ], - "Drawer|-00.71|+00.08|-00.56": [ - -1.75, - -1.25, - 90, - 30 - ], - "Drawer|-00.71|+00.24|-00.17": [ - 0.25, - 0.5, - 270, - 30 - ], - "Drawer|-00.71|+00.40|-00.17": [ - -1.25, - 0.5, - 180, - 30 - ], - "Drawer|-00.71|+00.40|-00.56": [ - -0.25, - -1.25, - 0, - 30 - ], - "Drawer|-00.72|+00.24|-00.56": [ - -1.0, - -1.25, - 90, - 30 - ], - "SideTable|+01.81|+00.00|+00.33": [ - 1.25, - 0.5, - 90, - 30 - ], - "Sofa|-00.50|+00.01|-01.89": [ - -0.5, - -1.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan227-layout.npy b/gen/layouts/FloorPlan227-layout.npy deleted file mode 100644 index 01fe02cc4a31f59c63203eb32ff53aed7fca0700..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3232 zcmbW(v2N2)6b9f+6j@aiRc+I>l*yYx$^v2lgj7%6in?@QLJ>{HfGA233*sqwAp9sD zJ7(yRAp@=N{gyN0rTSv~{`Z{YxcT$p^8DiClk_wFYOWTm&&%dr-Mqhk)6DAT`eylK zIsf+QW_h)E{QPYGb+vf-eD!7ieevMuFWfiN$9;4JBCtdz~dz$|~4L%M& z3Vv36SMIkSTaT^B*5hed?=W~0d=R`JycfJ1JPsZO?*v!D!{9-%{;W%X)Whmw^{{$a zJ**y9537gO!|Gx6uzEO^`gr>{^#^Z)?}OLDcfq&8`gMPrbM%Y#i}j23i}j23i}j1E zF6XlTu>P?Au>P?Au>SD6)X)0E`osFMDgDt8)(_SX)(_SXRu6B>{#gDtfdhB}kzTGX?yPv(E*m`U|w%%S?kIjcS<^96mk1U_% zvwZgdcfaJHbg4hs?-Ta>g#A9@X}JF|SifBFd1B8Kd!E?y#N)93DA@Dl`YN3FJUQ?C z!TQg>?`$4y9&8?L9&8?L9tUme5A$I2VDsRkQXfx)&BJ-~VDn(}VDn(}VDn(}VDsQA h?9V)$HxD)sHV-xrHV-xrHV=0Hq)q+des=$){Rg6}TU`JE diff --git a/gen/layouts/FloorPlan227-objects.json b/gen/layouts/FloorPlan227-objects.json deleted file mode 100644 index f87968d27..000000000 --- a/gen/layouts/FloorPlan227-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "FloorLamp", - "Plate", - "Pillow", - "Box", - "Statue", - "Sofa", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "Cabinet", - "Drawer", - "Painting", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "Vase", - "ArmChair", - "CoffeeTable", - "Shelf", - "Newspaper", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan227-openable.json b/gen/layouts/FloorPlan227-openable.json deleted file mode 100644 index 76136ed5f..000000000 --- a/gen/layouts/FloorPlan227-openable.json +++ /dev/null @@ -1,206 +0,0 @@ -{ - "ArmChair|-01.01|+00.03|+02.08": [ - -1.75, - 2.5, - 90, - 30 - ], - "ArmChair|-01.58|+00.03|+03.30": [ - -2.0, - 2.75, - 0, - 30 - ], - "Cabinet|-01.53|+01.87|+00.33": [ - -1.0, - 1.0, - 180, - 0 - ], - "Cabinet|-01.98|+01.17|+05.03": [ - -2.25, - 4.5, - 0, - 30 - ], - "Cabinet|-02.02|+01.71|+00.32": [ - -1.5, - 1.0, - 180, - 0 - ], - "Cabinet|-02.47|+01.33|+05.03": [ - -2.75, - 4.5, - 0, - 0 - ], - "Cabinet|-03.70|+01.71|+05.03": [ - -4.0, - 4.5, - 0, - 0 - ], - "Cabinet|-04.18|+01.87|+05.03": [ - -4.5, - 4.5, - 0, - 0 - ], - "Cabinet|-05.37|+01.17|+05.03": [ - -5.75, - 4.5, - 0, - 30 - ], - "Cabinet|-05.85|+01.33|+05.03": [ - -6.25, - 4.5, - 0, - 0 - ], - "CoffeeTable|-02.67|+00.03|+02.00": [ - -2.0, - 1.5, - 270, - 30 - ], - "DiningTable|-05.82|+00.03|+02.56": [ - -4.75, - 2.0, - 270, - 30 - ], - "Drawer|-01.09|+00.23|+00.46": [ - -1.0, - 1.25, - 180, - 30 - ], - "Drawer|-02.68|+00.23|+00.46": [ - -2.75, - 1.25, - 180, - 30 - ], - "Drawer|-02.94|+00.51|+05.00": [ - -3.25, - 4.5, - 0, - 30 - ], - "Drawer|-02.94|+00.82|+05.00": [ - -3.0, - 4.5, - 0, - 30 - ], - "Drawer|-04.26|+00.23|+00.46": [ - -4.75, - 1.25, - 180, - 30 - ], - "Drawer|-06.33|+00.51|+05.00": [ - -6.0, - 4.5, - 0, - 30 - ], - "Drawer|-06.33|+00.82|+05.00": [ - -6.25, - 4.5, - 0, - 30 - ], - "GarbageCan|-06.85|+00.02|+00.26": [ - -6.25, - 0.75, - 180, - 30 - ], - "Shelf|-00.81|+01.69|+00.19": [ - -1.0, - 1.0, - 180, - 0 - ], - "Shelf|-01.04|+01.00|+00.18": [ - -0.5, - 1.0, - 180, - 0 - ], - "Shelf|-01.04|+01.32|+00.18": [ - -0.5, - 1.0, - 180, - 0 - ], - "Shelf|-01.78|+00.99|+00.18": [ - -1.25, - 1.0, - 180, - 0 - ], - "Shelf|-02.22|+00.45|+05.17": [ - -2.75, - 4.25, - 90, - 30 - ], - "Shelf|-02.67|+00.61|+00.27": [ - -2.0, - 1.0, - 180, - 30 - ], - "Shelf|-03.19|+01.15|+05.17": [ - -3.25, - 4.5, - 0, - 0 - ], - "Shelf|-03.94|+00.99|+05.17": [ - -3.75, - 4.25, - 0, - 0 - ], - "Shelf|-04.67|+01.00|+05.17": [ - -4.75, - 4.5, - 0, - 30 - ], - "Shelf|-04.67|+01.32|+05.17": [ - -4.75, - 4.5, - 0, - 0 - ], - "Shelf|-04.90|+01.69|+05.17": [ - -4.75, - 4.5, - 0, - -30 - ], - "Shelf|-05.61|+00.45|+05.17": [ - -5.0, - 4.25, - 270, - 30 - ], - "Shelf|-06.57|+01.15|+05.17": [ - -6.5, - 4.5, - 0, - 0 - ], - "Sofa|-03.33|+00.02|+03.63": [ - -3.25, - 3.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan228-layout.npy b/gen/layouts/FloorPlan228-layout.npy deleted file mode 100644 index 7a07f8bf3aa03848dd6ebd588c90ecca0333f83c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2576 zcmbW%F>6y%7zW^D2!{|tXk*>)b}MADQV05uX-GAKmFT4KL<%@pZ^_N$>o89Ki z`PJ@X`|tUi&FB60;rag4=6d_!<7cPO*WJm}b@#pd&oxiuS`GE{_I3R{3_b{61}}o= z!L#5TJPm%_eAn{G$MUg!EFa6q^09m@AIrz`-M4(sXXmr?+4<~zc77^pT+Ub>%@e4K~6kLBY@c%OprTYmfXVSQL1)`#_B zedeX+^!w#S%ftGzzMR8;eZAM0^<{loU)GoPWqny+)^}0Txb$WJSM2|am#rV051S9q z!u}j=KK7drn-7~0n-7~0n-7~0n-81MvZQgD51S9051S9056@eFo(1P%^ReH2*nHT0 z*nHT0*nHT0*nId&%Xd)HxQ>F&&wKM@eL08k>+8L~tS{@!`m(;PFYC+t@=?ooSkk!k jWBph@mXGCQ`B*-dkL6?eRv{nD!}72^EDy`W@~p~VyiFZK9KteKEjq; zrbv+@h3n1v3Qy@Y%a=)J{_}^u`T6?ot2giNlyBvGcfQ(uSa;9b?)k-8w`jYI%k|gw z^7H%4_4(@W>o1p|Hmlp$Hy@W@R=0lm`0VMTee!70{%HSmHDy?*SI58CFOGljCGUUz zyMI6SZ{qzv&pyvS&$~E}AH;dvIM4a)e0DxNpLcOSZ*Emp=!5ma`e1#qK3E^D z57r0Qn2+_r`e1$VA^PBbvOetVgY{ARGAw( zKg-YZv-~VS%g^$&{477q&(|>zn`hjYVfjATJZv5|51WU})$v?551WV0!{%Z0uzA=# zwLji#9ySk~ht0#I$j>F&Joe4Q=3(=&dDuK`o=KXA&BNwl^RVX!Ph%eT{9w-yuIc^b zKm+ diff --git a/gen/layouts/FloorPlan229-objects.json b/gen/layouts/FloorPlan229-objects.json deleted file mode 100644 index 2aca56e1f..000000000 --- a/gen/layouts/FloorPlan229-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "FloorLamp", - "Pillow", - "Box", - "Boots", - "Sofa", - "Statue", - "Pencil", - "SideTable", - "KeyChain", - "Television", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "WateringCan", - "CellPhone", - "Drawer", - "Desk", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "TissueBox", - "Dresser", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan229-openable.json b/gen/layouts/FloorPlan229-openable.json deleted file mode 100644 index 27d4df17e..000000000 --- a/gen/layouts/FloorPlan229-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "ArmChair|-01.32|+00.03|+03.65": [ - -1.75, - 3.0, - 0, - 30 - ], - "CoffeeTable|-03.04|+00.00|+02.34": [ - -3.25, - 3.0, - 180, - 30 - ], - "Desk|-00.31|+00.03|+00.62": [ - -1.0, - 1.0, - 90, - 30 - ], - "Drawer|-05.50|+00.21|+02.13": [ - -5.25, - 1.5, - 0, - 30 - ], - "Drawer|-05.50|+00.21|+02.68": [ - -5.25, - 3.25, - 180, - 30 - ], - "Drawer|-05.50|+00.52|+02.13": [ - -5.25, - 1.5, - 0, - 30 - ], - "Drawer|-05.50|+00.52|+02.68": [ - -5.25, - 3.25, - 180, - 30 - ], - "Dresser|-05.70|+00.02|+02.40": [ - -5.25, - 1.5, - 0, - 30 - ], - "SideTable|-00.31|+00.02|+01.52": [ - -0.75, - 2.0, - 90, - 30 - ], - "SideTable|-05.57|+00.02|+00.29": [ - -5.0, - 0.75, - 270, - 30 - ], - "Sofa|-03.13|+00.03|+00.61": [ - -3.25, - 1.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan23-layout.npy b/gen/layouts/FloorPlan23-layout.npy deleted file mode 100644 index 9e63fce2cd289e0c50458690a443b21b3d1666b8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1648 zcmbW$u}T9$6a~;xL?np#3Db?jRslhSwVh&FAr+tv8;`erLVrgwOYacY}9=w}bV|)z7ilzEwZ# zXZ@_7Q$G)zN3MC;JnT7+t9k63ht0$0;h#m?T>KsU75o|Oeazu~*!!^eVg0P1^|OA~ z@4fZ2e3sAhSw746J<4bKET84Ge3tKbk;n2_9?N5Sa?Hzdm2Y1@%V+tXlh5wsxXQOL zpXIwx9=ng@>Up{5V|gr(<*~ev{@lxB=bN2x*2nr-AM0C&KGw(j*#DUQPuRI;=a8Kv MHb0x6&A(i%0CTJP2LJ#7 diff --git a/gen/layouts/FloorPlan23-objects.json b/gen/layouts/FloorPlan23-objects.json deleted file mode 100644 index f21beb23b..000000000 --- a/gen/layouts/FloorPlan23-objects.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Blinds", - "Pencil", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "Pen", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "DiningTable", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Shelf", - "Chair", - "LightSwitch", - "Bottle", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan23-openable.json b/gen/layouts/FloorPlan23-openable.json deleted file mode 100644 index 99352e9a3..000000000 --- a/gen/layouts/FloorPlan23-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "Cabinet|-00.30|+01.92|-02.50": [ - -1.0, - -2.75, - 90, - 0 - ], - "Cabinet|-00.33|+01.92|-03.39": [ - -1.0, - -2.75, - 180, - 0 - ], - "Cabinet|-00.58|+00.39|-01.80": [ - -1.25, - -2.25, - 0, - 30 - ], - "Cabinet|-00.58|+00.39|-02.20": [ - -1.5, - -2.75, - 0, - 30 - ], - "Cabinet|-00.58|+00.39|-03.40": [ - -1.75, - -3.0, - 90, - 30 - ], - "Cabinet|-00.88|+00.39|-03.42": [ - -1.25, - -2.5, - 90, - 30 - ], - "Cabinet|-00.88|+02.14|-03.69": [ - -1.5, - -2.75, - 180, - 0 - ], - "Cabinet|-01.76|+02.14|-03.69": [ - -1.25, - -2.75, - 180, - 0 - ], - "CounterTop|-00.30|+00.95|-02.79": [ - -1.0, - -3.0, - 90, - 30 - ], - "DiningTable|-02.43|+00.00|-01.69": [ - -1.75, - -1.5, - 270, - 30 - ], - "Fridge|-00.33|+00.00|-00.77": [ - -1.25, - -0.75, - 90, - 0 - ], - "GarbageCan|-01.94|00.00|-03.76": [ - -2.25, - -3.5, - 90, - 30 - ], - "Microwave|-01.32|+01.52|-03.80": [ - -1.25, - -3.0, - 180, - -30 - ], - "Shelf|-02.43|+00.15|-01.69": [ - -3.25, - -0.75, - 90, - 30 - ], - "Shelf|-02.43|+00.52|-01.69": [ - -3.75, - -1.75, - 90, - 0 - ], - "Sink|-00.35|+00.91|-02.01|SinkBasin": [ - -1.0, - -2.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan230-layout.npy b/gen/layouts/FloorPlan230-layout.npy deleted file mode 100644 index 35ea786ab0b1dda667f3723868c36a81bc2c172f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6448 zcmbW(y=oL;6b9hWunfx*mfigMubXNWQYnIpkg4nx8w)E5W`l(o*@%q@xd$)Ey_A$G zQ>54;h4I_-OmRx52~Q@O^PYDzGx`1Y{hN0mZj>M8=k#!P@@YPOIhnpXdOqEoOplJ| z-{%KkKOWByXaBzc`rymS?E3pBpAWvxuKnogi)VY2Cy)0gzb5~A3`#w=7pt#l`>U^8 z$(zX=$>ZepINU;QcdkZ+lMnS7CKzw`aob?nFXWBalFcog|~m~4ON?a%h- zCjGwsonK4mOR|3ayna|etRL3TMe2w3!}?+UuzpxStRL17>xcEj`eFUBepo-OAHIyg z7uFB!=Q8!f`eFUBepo-OAC{lxXZcxvzKDHT{$N4Sw5DJmU_s`o+m6X%ggfeGV-##EHBH;@~x$OEFa6q^09m@ zAIrz`v3#sgmbcfIdgznoWqDa%mY3yad0AeTm*r)7o0OO3WqDa%mY3yad0AeTm*r)7 z`zbHW%kr|kEHBH;^0K@vFU!mF4pLs0m*r)7Szh+M<>8{#gS~IKN#}dXCHX4uU%#&( z)(`84^~3sM{j9g89_|;`59^2Z!}?+U@G$n{^y!1#`ec2M z+ENdFvOZa#tWVY_>y!1#`s6|M#rotXo!6)H`ec2wK3SivPu3^vll3=lOFi_*TalOb z$NFRavHUDQ%g^$&{478Fdtm!)qvY#+7{+lTGL_F?<5eb_#1AGQz6yBYh)%kr|k zEHBH;^0K@vFU!mFvbKDt>e1>*gQ6m&13V}Jhm^Je>=@*^VxhhpUr3U*?cztPMXi=v-xa3o6qL6 z`E35(G@s39^VxhhpUr3U+5CHHKAX?xv-xa3o6qL6`S;U&HlNLB^VxhhpUr3UAEfzg zKAX?xv-xa3o6qJyO!L`%HlIDe*z=1$zu5DOn?dB*l* z`?3AFw^&`5{r|__-|YR(-rwx~&Gu#cvVA%BJ>}T9bL`tW_U#<|c8+~I$3C57pU$yQ e=h&xn?9y!1l+x`WazMf(L diff --git a/gen/layouts/FloorPlan230-objects.json b/gen/layouts/FloorPlan230-objects.json deleted file mode 100644 index 7ddc799b5..000000000 --- a/gen/layouts/FloorPlan230-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "FloorLamp", - "Plate", - "Candle", - "Pillow", - "Box", - "Boots", - "Statue", - "Sofa", - "SideTable", - "KeyChain", - "Watch", - "Television", - "Window", - "GarbageCan", - "CreditCard", - "DeskLamp", - "Mirror", - "Painting", - "RoomDecor", - "DiningTable", - "Floor", - "HousePlant", - "Laptop", - "ArmChair", - "CoffeeTable", - "TissueBox", - "Newspaper", - "Chair", - "LightSwitch", - "RemoteControl" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan230-openable.json b/gen/layouts/FloorPlan230-openable.json deleted file mode 100644 index b866dc6e2..000000000 --- a/gen/layouts/FloorPlan230-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "ArmChair|-02.69|+00.01|+04.62": [ - -3.0, - 5.25, - 180, - 30 - ], - "ArmChair|-03.66|+00.01|+04.56": [ - -4.25, - 5.0, - 90, - 30 - ], - "CoffeeTable|-03.13|+00.02|+08.53": [ - -3.5, - 7.75, - 0, - 30 - ], - "CoffeeTable|-03.24|+00.01|+06.60": [ - -2.5, - 6.5, - 270, - 30 - ], - "DiningTable|-02.90|+00.01|+02.23": [ - -1.5, - 2.25, - 270, - 30 - ], - "GarbageCan|-05.71|+00.01|+00.30": [ - -5.25, - 0.75, - 180, - 30 - ], - "SideTable|-00.40|+00.01|+00.36": [ - -1.0, - 0.75, - 90, - 30 - ], - "SideTable|-00.53|+00.01|+08.52": [ - -1.0, - 8.0, - 90, - 30 - ], - "Sofa|-01.71|+00.00|+06.45": [ - -2.5, - 6.5, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan24-layout.npy b/gen/layouts/FloorPlan24-layout.npy deleted file mode 100644 index 33ebd8c0cd3be20377e952e1aa38d20c79148755..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1152 zcmbW!JxT*X7=YnXL?q-8)2+f*A|fJWD?7!;!b%pi!9tAeij8;*59Aecgp`&R7AaB~ zoq3um-DY{_XTO)^{qp+a>Simvgx6}?4R?KY8mqI}Nma*cHt(PN_VIS!PrKjs^Y&rr zHtWNE`_yf`e|%KO!-G1$#s5B|@b|1g(t9;Y??vIX8iIZ2*ZKS^pJ(^keRe-IX~%v3 z&fnv&!k>kgh0S;0d^Uf(n9t_3`D{L$&*pQ;4=*NZf%WV(Y2EL^dRPzZVLhye)07Zc z59`@2dRPzZVLhye^{^h+!+Q3L9@fKpSP$!AJ*<$BQ7Y~){@?_Lfs#Ug7fmB&xZYH@L3zO>K`8vr<-JO@`0x@fb^X@$_#QJC av3);t%zWt0G5^QhA9?pN_c8DFJ&wQsFq4rjK=gk>!`;^SsFN@uYsMhc6G4dQ|;AzZyPI ztM&8g)9|%g`{?Yn$WD%n>@)lC>7~u-&YF8ZXzosM3SND0&o6@)!SmpsVEv21c0cQ9 z{j8t$^Ste2{j7f(`dL5gXZ@_7^|OA~zY6`VpI7bs@G@Ax-}SS8_PtZt{Qvq`AM0a% ztdI4v{hhYYezu?OXZzWHw!d4Z&9R^DXZtzLn%r*L-102X@+`j>@+{BtEZ+-xmS=gE i-w%0~XLZgFumnbwLnDT7n^*f&+1d9bpoQKp+r|tWWSu zYQDU`-)p<#s`Y?UoK_8|M(9|be+wVRhw)*2l{SBn`(b<-ALbn@{QxH- BbR7Ty diff --git a/gen/layouts/FloorPlan27-objects.json b/gen/layouts/FloorPlan27-objects.json deleted file mode 100644 index 3b62eb5e3..000000000 --- a/gen/layouts/FloorPlan27-objects.json +++ /dev/null @@ -1,43 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Curtains", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Bread", - "Sink", - "DiningTable", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Chair", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan27-openable.json b/gen/layouts/FloorPlan27-openable.json deleted file mode 100644 index 9dbe15133..000000000 --- a/gen/layouts/FloorPlan27-openable.json +++ /dev/null @@ -1,128 +0,0 @@ -{ - "Cabinet|+00.13|+00.39|+01.77": [ - 1.0, - 1.5, - 0, - 30 - ], - "Cabinet|+00.35|+00.39|+02.36": [ - 1.0, - 1.75, - 0, - 30 - ], - "Cabinet|+01.51|+00.39|+02.36": [ - 0.5, - 1.5, - 90, - 30 - ], - "Cabinet|+01.76|+00.39|+00.87": [ - 1.0, - 0.0, - 0, - 30 - ], - "Cabinet|+01.76|+00.39|+02.35": [ - 1.0, - 1.5, - 0, - 30 - ], - "Cabinet|+01.97|+02.11|+02.62": [ - 1.25, - 2.0, - 0, - 0 - ], - "Cabinet|+02.04|+01.81|+00.28": [ - 1.25, - 0.75, - 90, - 0 - ], - "Cabinet|+02.04|+01.81|+00.87": [ - 1.25, - 0.5, - 90, - 0 - ], - "Cabinet|+02.04|+02.11|+00.89": [ - 1.25, - 0.75, - 90, - 0 - ], - "Cabinet|+02.04|+02.11|+01.77": [ - 1.25, - 1.0, - 90, - 0 - ], - "Cabinet|+02.04|+02.11|+01.81": [ - 1.5, - 2.0, - 90, - -30 - ], - "Cabinet|+02.04|+02.11|+02.62": [ - 1.5, - 2.0, - 90, - -30 - ], - "CounterTop|+02.06|+00.97|+00.58": [ - 1.25, - 0.5, - 90, - 0 - ], - "DiningTable|-00.15|00.00|+01.07": [ - 0.5, - 1.0, - 270, - 30 - ], - "Drawer|+01.91|+00.77|+02.06": [ - 1.25, - 1.75, - 0, - 30 - ], - "Drawer|+02.17|+00.77|+00.58": [ - 1.25, - 1.0, - 180, - 30 - ], - "Drawer|-00.02|+00.77|+02.06": [ - 0.75, - 1.5, - 0, - 30 - ], - "Fridge|+02.10|+00.00|-00.28": [ - 1.0, - -0.25, - 90, - 30 - ], - "GarbageCan|-00.31|00.00|-00.81": [ - 0.25, - -0.25, - 180, - 30 - ], - "Microwave|-00.31|+00.93|+02.08": [ - 0.5, - 1.75, - 270, - 0 - ], - "Sink|+00.94|+00.94|+02.65|SinkBasin": [ - 1.0, - 2.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan28-layout.npy b/gen/layouts/FloorPlan28-layout.npy deleted file mode 100644 index 7b6b1a810345427619241bcd42635ed7ebe51d2a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1712 zcmbW%F-ikL6oBDTBuEg?Fx@C@Wo5+LPO-7DlErLDAx3t^Mm&WFN{*7!GDQjt3uD}` z@Re>ee3Rt8KLqlAb#r-ryOUnhYZ*7)eOu0QIiH-CDwoNueQxW=yIDJKe(o>ohpyS& zchmZ*+4yKQs`ANkmEZDzpJCcQdyC(5zdv__Q}EaP@B2T4*TJh``v(17``A9VkL_do z*gkgJ8&CV)+t2p1{cJzm&xeb&ee5|19tOwXVGv$7*SvV@cdwuIvwqgk`pwnP`dL5g zXZ>ss$5X$1{j8t$vwm~*vwqgk`dL5gXL~uG`rYei{jA^T^s|1}&-z(E>u3F}gX5{+ zy?)m3efn8H>u3F}pY^kT*3Y^)p62@==Ck>1KAX?xv-uzW|DyS9KAX?xv-xcPGR$Z5 M*?cyi&0o&H0c$G?VE_OC diff --git a/gen/layouts/FloorPlan28-objects.json b/gen/layouts/FloorPlan28-objects.json deleted file mode 100644 index 7abe48eea..000000000 --- a/gen/layouts/FloorPlan28-objects.json +++ /dev/null @@ -1,43 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Blinds", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "SideTable", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "DiningTable", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Shelf", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan28-openable.json b/gen/layouts/FloorPlan28-openable.json deleted file mode 100644 index a56b16123..000000000 --- a/gen/layouts/FloorPlan28-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "Cabinet|-00.33|+01.89|-02.51": [ - -1.0, - -2.75, - 90, - 0 - ], - "Cabinet|-00.34|+01.89|-01.29": [ - -1.0, - -1.75, - 90, - 0 - ], - "Cabinet|-00.35|+01.89|-03.29": [ - -1.25, - -3.0, - 90, - 0 - ], - "Cabinet|-00.63|+00.39|-01.61": [ - -1.5, - -2.0, - 0, - 30 - ], - "Cabinet|-00.63|+00.39|-02.51": [ - -1.25, - -3.0, - 90, - 30 - ], - "Cabinet|-00.63|+00.39|-03.01": [ - -1.25, - -2.5, - 90, - 30 - ], - "Cabinet|-01.01|+00.39|-03.37": [ - -1.75, - -2.5, - 90, - 30 - ], - "CounterTop|-00.33|+00.98|-01.45": [ - -1.0, - -1.75, - 90, - 30 - ], - "CounterTop|-01.94|+00.98|-03.67": [ - -1.0, - -3.0, - 90, - 30 - ], - "DiningTable|-03.22|00.00|-00.45": [ - -2.5, - -0.5, - 270, - 30 - ], - "DiningTable|-03.59|+00.00|-03.26": [ - -3.75, - -2.25, - 180, - 30 - ], - "Drawer|-00.48|+00.78|-02.74": [ - -1.5, - -2.25, - 90, - 0 - ], - "Drawer|-00.50|+00.78|-01.45": [ - -1.25, - -1.0, - 180, - 30 - ], - "Fridge|-00.31|+00.00|-00.65": [ - -1.25, - -0.75, - 90, - 30 - ], - "GarbageCan|-02.42|-00.03|-03.54": [ - -1.75, - -2.75, - 270, - 30 - ], - "Microwave|-00.22|+01.47|-02.06": [ - -1.0, - -2.0, - 90, - -30 - ], - "Shelf|-04.03|+00.26|-00.30": [ - -3.5, - -1.5, - 270, - 30 - ], - "Shelf|-04.03|+00.49|-00.30": [ - -3.5, - -1.25, - 270, - 30 - ], - "SideTable|-04.03|+00.00|-00.30": [ - -3.75, - -1.5, - 0, - 0 - ], - "Sink|-00.60|+00.93|-03.39|SinkBasin": [ - -1.0, - -3.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan29-layout.npy b/gen/layouts/FloorPlan29-layout.npy deleted file mode 100644 index 3ae68148a7960946b2d57b4b5964ef738dbcc3ce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1168 zcmbWzu}Z{16ouij^(oSgLMlNK5!}j7v9Yj{;AXK9R}!%ipTY;)SI8r5xn+tJ78b5% zzJLQZPILM1J#){QdB42AxVqU1FX1)L>-MgRCq+D69LKVVi)HiNRFAjIW?p~y&#Q;F z-uB!3>Z#uH-qB%M9PF3HTk+qs8-C7uHP%h4UB=@yglT^ETffeDlX0K(YP_HO;=IbE zFAwh0ek>1`2g`$p?EXi_eab7x^be_Tk9l6@o%(4%mKV#5<;6pGUtaS*<>D(ZmKW3e zM|w<;>E))!^qAhe=rKL+QvTtOcgj7zJLxcAY%lhom=EUvnfCI-{sHsD{4hVv5A((R V!;EvPiTRuJ$NVvW%pda)voGD%xz_*y diff --git a/gen/layouts/FloorPlan29-objects.json b/gen/layouts/FloorPlan29-objects.json deleted file mode 100644 index 017eb7373..000000000 --- a/gen/layouts/FloorPlan29-objects.json +++ /dev/null @@ -1,39 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Bread", - "Sink", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "Chair", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan29-openable.json b/gen/layouts/FloorPlan29-openable.json deleted file mode 100644 index f3cc8c38c..000000000 --- a/gen/layouts/FloorPlan29-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Cabinet|+01.32|+01.96|-01.31": [ - 1.0, - -0.75, - 180, - 0 - ], - "Cabinet|+01.34|+00.59|-01.11": [ - 0.75, - -0.75, - 180, - 30 - ], - "Cabinet|+01.99|+00.59|-01.11": [ - 1.25, - -0.5, - 90, - 30 - ], - "Cabinet|+01.99|+01.40|-01.11": [ - 1.5, - -0.5, - 180, - 0 - ], - "Cabinet|-00.85|+00.59|-01.11": [ - -0.25, - -0.75, - 180, - 30 - ], - "Cabinet|-00.87|+01.96|-01.31": [ - -0.5, - -0.75, - 180, - 0 - ], - "Cabinet|-01.53|+00.59|-01.11": [ - -0.75, - -0.5, - 180, - 30 - ], - "CounterTop|+00.20|+01.08|-01.51": [ - 0.25, - -0.75, - 180, - 30 - ], - "CounterTop|+00.97|+01.08|+00.42": [ - 0.5, - -0.25, - 0, - 30 - ], - "Fridge|-01.29|+00.02|+01.83": [ - -0.25, - 1.75, - 270, - 30 - ], - "GarbageCan|+01.86|-00.02|+02.39": [ - 1.5, - 2.0, - 0, - 30 - ], - "Microwave|-01.19|+01.62|-01.28": [ - -1.0, - -0.5, - 180, - 0 - ], - "Sink|+00.93|+00.94|+00.32|SinkBasin": [ - 1.5, - -0.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan3-layout.npy b/gen/layouts/FloorPlan3-layout.npy deleted file mode 100644 index e5a612c999fc9c14ac13d0d68e8f8c54b1fb94ce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1856 zcmbWzu};EJ6oBC?qfgPTnlPvnF(xv(XZ zABktQ%guL6|I_k$b9a4ve~{kNdpWM=k9B!oloyjh*)Ph;tbVOW(}!6-u72iMqvv_G zo6ny{FV)URrzeAcadzAdsa0GPnuuo=VB{dMWf+kM&rO^|pDh z_hUWQV?EZ}gdXd$9_z8*I`mkN^;nPfoW7U!xXF82kDWU4)HBy(J#H?$3G2rW$5Y>2 zpY>VabM~^|aXj_+^Zfq23|qHbpY>Uv^;y5o|BpWFvp(x{lRK=x4t>_=X3-T{pWA$Y6MC%2 mdaTEK+t6b@)?+=^OT+Gt|C9AtkM&ru7kaG6dYtmr8-4>qmmo+0 diff --git a/gen/layouts/FloorPlan3-objects.json b/gen/layouts/FloorPlan3-objects.json deleted file mode 100644 index 0f770854d..000000000 --- a/gen/layouts/FloorPlan3-objects.json +++ /dev/null @@ -1,45 +0,0 @@ -[ - "PaperTowelRoll", - "StoveBurner", - "Faucet", - "Stool", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "SideTable", - "Tomato", - "Window", - "Bowl", - "Knife", - "GarbageCan", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "Floor", - "HousePlant", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan3-openable.json b/gen/layouts/FloorPlan3-openable.json deleted file mode 100644 index 1d586c647..000000000 --- a/gen/layouts/FloorPlan3-openable.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "Cabinet|+00.58|+00.78|-02.05": [ - -0.25, - -1.25, - 180, - 30 - ], - "Cabinet|-01.46|+00.78|+00.47": [ - -0.75, - 1.0, - 180, - 30 - ], - "Cabinet|-01.46|+00.78|+01.31": [ - -0.75, - 0.75, - 0, - 30 - ], - "Cabinet|-01.46|+00.78|-02.00": [ - -0.75, - -1.5, - 180, - 30 - ], - "CounterTop|-01.81|+01.36|+01.18": [ - -1.0, - 1.5, - 270, - 30 - ], - "Drawer|+00.65|+00.60|+00.68": [ - 0.0, - 0.25, - 0, - 30 - ], - "Drawer|+00.65|+00.60|+01.02": [ - -0.25, - 0.5, - 0, - 30 - ], - "Drawer|+00.65|+00.84|+00.68": [ - 0.0, - 0.25, - 0, - 30 - ], - "Drawer|+00.65|+00.84|+01.02": [ - 0.0, - 1.5, - 180, - 30 - ], - "Drawer|+00.65|+01.06|+00.68": [ - -0.25, - 0.0, - 90, - 0 - ], - "Drawer|+00.65|+01.06|+01.02": [ - -0.25, - 1.75, - 90, - 0 - ], - "Drawer|-01.61|+00.68|-00.43": [ - -1.0, - -1.0, - 0, - 30 - ], - "Drawer|-01.61|+00.68|-01.22": [ - -1.0, - -1.75, - 0, - 30 - ], - "Fridge|+01.01|+00.23|+01.92": [ - 0.0, - 2.0, - 90, - 0 - ], - "GarbageCan|-01.63|+00.21|+02.19": [ - -0.75, - 1.5, - 0, - 30 - ], - "Microwave|+00.99|+01.31|-02.16": [ - 0.0, - -1.75, - 90, - 0 - ], - "SideTable|+00.98|+00.21|+00.87": [ - 0.5, - 0.0, - 0, - 30 - ], - "Sink|-01.99|+01.14|-00.98|SinkBasin": [ - -0.25, - 0.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan30-layout.npy b/gen/layouts/FloorPlan30-layout.npy deleted file mode 100644 index 4dff912e9ee932067c7ef80e65180eb5cb8d8469..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1296 zcmbW$u}Z^07zgk(h=Wg&Eef4}I^%e369XodD(80m# z-7ny|ndSI>x%|KH()8o%=JNV>C%lHYYTV53+v=>W&L^kUpsXg-_N5&?-A&tZ^Ig9f zJJLR!FmdAV9{%#(AF5hib2;8N9OQb)1NuXEXc) D)dQw{ diff --git a/gen/layouts/FloorPlan30-objects.json b/gen/layouts/FloorPlan30-objects.json deleted file mode 100644 index 03562e5d5..000000000 --- a/gen/layouts/FloorPlan30-objects.json +++ /dev/null @@ -1,45 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "PepperShaker", - "Pan", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "CellPhone", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Mirror", - "Bread", - "Sink", - "Floor", - "HousePlant", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "Bottle", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan30-openable.json b/gen/layouts/FloorPlan30-openable.json deleted file mode 100644 index 779e34a00..000000000 --- a/gen/layouts/FloorPlan30-openable.json +++ /dev/null @@ -1,218 +0,0 @@ -{ - "Cabinet|+00.14|+01.67|-01.56": [ - 0.5, - -0.75, - 180, - -30 - ], - "Cabinet|+00.62|+01.87|-01.26": [ - 0.25, - -0.5, - 180, - 0 - ], - "Cabinet|+01.40|+01.87|-01.26": [ - 0.5, - -0.75, - 90, - 0 - ], - "Cabinet|+02.82|+01.77|-01.05": [ - 2.25, - -1.25, - 90, - -30 - ], - "Cabinet|+02.85|+00.42|+00.41": [ - 2.0, - 0.25, - 0, - 30 - ], - "Cabinet|+02.85|+00.42|-00.61": [ - 2.0, - -1.0, - 0, - 30 - ], - "Cabinet|+02.85|+00.42|-00.96": [ - 2.0, - -1.25, - 90, - 30 - ], - "Cabinet|+03.07|+01.67|-00.71": [ - 2.25, - -1.0, - 90, - -30 - ], - "Cabinet|-00.19|+01.67|-01.34": [ - 0.25, - -0.75, - 180, - 0 - ], - "Cabinet|-00.92|+01.67|-00.62": [ - -0.25, - -0.5, - 270, - 0 - ], - "CounterTop|+00.13|+00.94|-01.46": [ - 0.5, - -0.75, - 180, - 30 - ], - "CounterTop|+01.21|+00.94|+00.46": [ - 2.0, - 0.5, - 270, - 30 - ], - "CounterTop|+03.11|+00.94|+00.02": [ - 2.5, - 0.0, - 90, - 30 - ], - "CounterTop|-01.01|+00.94|-00.04": [ - -0.25, - 0.0, - 270, - 30 - ], - "Drawer|+00.38|+00.19|-01.51": [ - -0.25, - -0.25, - 90, - 30 - ], - "Drawer|+00.38|+00.38|-01.51": [ - 0.0, - -0.5, - 90, - 30 - ], - "Drawer|+00.38|+00.57|-01.51": [ - -0.25, - -0.5, - 90, - 30 - ], - "Drawer|+00.38|+00.77|-01.51": [ - 0.0, - -0.75, - 90, - 30 - ], - "Drawer|+03.02|+00.77|+00.70": [ - 2.25, - 1.25, - 180, - 30 - ], - "Drawer|+03.02|+00.77|-00.41": [ - 2.25, - 0.0, - 180, - 30 - ], - "Drawer|+03.02|+00.77|-00.78": [ - 2.25, - -0.5, - 180, - 30 - ], - "Drawer|-00.86|+00.19|+00.66": [ - 0.0, - 1.5, - 270, - 30 - ], - "Drawer|-00.86|+00.19|+01.43": [ - 0.0, - 0.75, - 270, - 30 - ], - "Drawer|-00.86|+00.19|-00.10": [ - 0.0, - 0.75, - 270, - 30 - ], - "Drawer|-00.86|+00.39|+00.66": [ - 0.0, - 0.0, - 0, - 30 - ], - "Drawer|-00.86|+00.39|+01.43": [ - 0.0, - 0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.39|-00.10": [ - 0.0, - -0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.58|+00.66": [ - -0.25, - 1.25, - 180, - 30 - ], - "Drawer|-00.86|+00.58|+01.43": [ - -0.25, - 0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.58|-00.10": [ - -0.25, - 0.5, - 180, - 30 - ], - "Drawer|-00.86|+00.77|+00.66": [ - -0.25, - 1.25, - 180, - 30 - ], - "Drawer|-00.86|+00.77|+01.43": [ - -0.25, - 0.75, - 0, - 30 - ], - "Drawer|-00.86|+00.77|-00.10": [ - -0.25, - 0.75, - 180, - 30 - ], - "Fridge|+01.01|+00.03|-01.47": [ - 0.5, - -0.75, - 180, - 30 - ], - "Microwave|-01.03|+00.87|+01.43": [ - -0.25, - 1.25, - 270, - 0 - ], - "Sink|+03.08|+00.89|+00.09|SinkBasin": [ - 2.5, - 0.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan301-layout.npy b/gen/layouts/FloorPlan301-layout.npy deleted file mode 100644 index 3db3b80bbcf3897bfc7704cfaef557cb0288243f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1392 zcmbW#uTH~I7(nq$gW@Ub3P}})KOtEa4uV0TNW;1y7Dn1-hVT?T5U;RDn4GMrKp+_O z{z$lzns4XpUC&9kx9i)ho4dWR3NOX9=^onRJTES0r$w0;vqigX>!*V?=`Q@ZoSkvnJJG}FO**9a~&(47xre;%b~ED`TDE$T$1+Id(g)KA(+ATBOKs`(+6iVq+^gII%s$LM%s$LMES3G> M`#pT#53}DT9}otFVE_OC diff --git a/gen/layouts/FloorPlan302-objects.json b/gen/layouts/FloorPlan302-objects.json deleted file mode 100644 index 83f093816..000000000 --- a/gen/layouts/FloorPlan302-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "HousePlant", - "Safe", - "Laptop", - "Bed", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan302-openable.json b/gen/layouts/FloorPlan302-openable.json deleted file mode 100644 index 17003e4fb..000000000 --- a/gen/layouts/FloorPlan302-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bed|+01.24|+00.00|-00.90": [ - 0.25, - -0.75, - 90, - 30 - ], - "Desk|-00.79|+00.00|-01.03": [ - -0.5, - -0.75, - 270, - 30 - ], - "Drawer|+00.30|+00.17|+01.16": [ - 1.0, - 0.75, - 270, - 30 - ], - "Drawer|+00.30|+00.46|+01.16": [ - -0.25, - 0.75, - 90, - 30 - ], - "Drawer|+00.42|+00.53|-01.55": [ - 0.0, - -1.25, - 90, - 30 - ], - "Safe|+01.62|+00.00|+00.45": [ - 0.75, - 0.5, - 90, - 30 - ], - "Shelf|-00.47|+00.83|-02.04": [ - 0.0, - -0.75, - 180, - 30 - ], - "Shelf|-01.29|+01.45|-00.60": [ - -0.5, - -0.5, - 270, - 30 - ], - "Shelf|-01.29|+01.45|-01.34": [ - -0.25, - -1.0, - 270, - 30 - ], - "Shelf|-01.29|+01.81|-00.60": [ - -0.5, - -0.75, - 270, - 0 - ], - "Shelf|-01.29|+01.81|-01.34": [ - -0.5, - -0.75, - 270, - 0 - ], - "SideTable|+00.31|+00.00|+01.23": [ - 0.75, - 0.75, - 0, - 30 - ], - "SideTable|+00.41|+00.00|-01.68": [ - -0.25, - -1.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan303-layout.npy b/gen/layouts/FloorPlan303-layout.npy deleted file mode 100644 index 486b0356b0c3ee8b46af7af8a9dd36b5de09ae91..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1168 zcmbW#p-#g<9Khkj@)UK2q>2PW2+14{f7_p$qU$mbf@!K>gtIKSOwe?OaM*!yL@JcQ@RV9)7_qdxO}?qhwd zkM*%W*2ntT`((Ybi{q%*yk6GJdRZ^)WxcGI{omO4h+P~dF;HDz5#xW&Y}PS diff --git a/gen/layouts/FloorPlan303-objects.json b/gen/layouts/FloorPlan303-objects.json deleted file mode 100644 index 50bca7fac..000000000 --- a/gen/layouts/FloorPlan303-objects.json +++ /dev/null @@ -1,35 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "GarbageBag", - "Window", - "GarbageCan", - "Poster", - "Pen", - "Cloth", - "CreditCard", - "Book", - "CellPhone", - "Dumbbell", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Vase", - "Mug", - "Bed", - "ShelvingUnit", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan303-openable.json b/gen/layouts/FloorPlan303-openable.json deleted file mode 100644 index 8704b6b03..000000000 --- a/gen/layouts/FloorPlan303-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "Bed|-01.05|+00.00|-01.85": [ - -1.0, - -1.0, - 180, - 30 - ], - "Desk|-01.71|+00.00|-00.37": [ - -1.0, - -0.5, - 270, - 30 - ], - "Drawer|-01.79|+00.10|-01.14": [ - -0.5, - -0.5, - 180, - 30 - ], - "Drawer|-01.79|+00.25|-01.14": [ - -0.75, - -0.75, - 180, - 30 - ], - "Drawer|-01.79|+00.39|-01.14": [ - -1.0, - -0.75, - 180, - 30 - ], - "Shelf|+01.31|+00.97|-02.30": [ - 1.5, - -1.5, - 180, - 0 - ], - "Shelf|+01.31|+01.17|-02.30": [ - 1.25, - -1.75, - 180, - 0 - ], - "Shelf|+01.31|+01.37|-02.30": [ - 1.25, - -1.75, - 180, - -30 - ], - "Shelf|+01.31|+01.57|-02.30": [ - 1.25, - -1.75, - 180, - 30 - ], - "Shelf|+01.32|+00.16|-02.30": [ - 0.75, - -1.25, - 90, - 30 - ], - "Shelf|+01.32|+00.46|-02.30": [ - 1.75, - -1.5, - 270, - 30 - ], - "Shelf|+01.59|+00.61|-02.31": [ - 1.25, - -1.75, - 180, - 30 - ], - "Shelf|+01.84|+00.97|-02.30": [ - 1.5, - -1.5, - 180, - 0 - ], - "Shelf|+01.84|+01.17|-02.30": [ - 1.5, - -1.5, - 180, - 0 - ], - "Shelf|+01.84|+01.37|-02.30": [ - 1.75, - -1.5, - 180, - -30 - ], - "Shelf|+01.84|+01.57|-02.30": [ - 1.75, - -1.5, - 180, - 30 - ], - "Shelf|+01.85|+00.15|-02.29": [ - 1.25, - -1.25, - 90, - 30 - ], - "Shelf|+01.85|+00.45|-02.30": [ - 1.25, - -1.5, - 90, - 30 - ], - "SideTable|+00.44|+00.04|-02.65": [ - 0.5, - -2.0, - 180, - 30 - ], - "SideTable|-01.82|+00.00|-01.14": [ - -1.0, - -0.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan304-layout.npy b/gen/layouts/FloorPlan304-layout.npy deleted file mode 100644 index d6e9934a5c069b8d62bd8481899144452732f6d5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1808 zcmbW#p-#hK6o%n4$yL-9k_jLoA%tX8I0y!TA`9z+AdGYbL%0eqXt&Tyn4GMbKp+_O zJQGJUbMl_Q{ob$bKCf@DZtnJqx8l8;){BRxIxnk>*;zF#tJ%DHZ6?q6^JZHA?k^`# zi+a0XJWgKfEgu{ooes;B!(sVR{`0qA{QcTdKf7f=SBW>VU&nMEZqs?6QWU%M$iwpS zI-PfkH<_2wGp0VPV7WL?eeLzd-Urqf>x=cp`tCS-@#>3Rhx62Lw;%NztRL17>xVb# zetVugy$^dn%!m0fALh%sI8Q!%KHPbpn0(IpmHr^ZN$8vF={Pz6z{FooN>AUee=f^xaPyR3ei)C-b{Foo}V}8t!`7!@@ s@?(C?kNGh_=EwZFjpr@KOfiG`obzEm%!m1~yg}s4!}72^EN?LW0Vy~K!2kdN diff --git a/gen/layouts/FloorPlan304-objects.json b/gen/layouts/FloorPlan304-objects.json deleted file mode 100644 index 3aed39397..000000000 --- a/gen/layouts/FloorPlan304-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "LaundryHamper", - "BasketBall", - "Pillow", - "Box", - "Statue", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Mug", - "Bed", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan304-openable.json b/gen/layouts/FloorPlan304-openable.json deleted file mode 100644 index 74d9722a3..000000000 --- a/gen/layouts/FloorPlan304-openable.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "Bed|-01.30|+01.94|+01.44": [ - -0.25, - 1.75, - 270, - 0 - ], - "Desk|-00.99|+00.01|-01.41": [ - -1.0, - -0.75, - 180, - 30 - ], - "Drawer|-01.41|+00.23|-01.30": [ - -0.75, - -0.5, - 270, - 30 - ], - "Shelf|+00.00|+00.01|+00.04": [ - -1.0, - -0.75, - 180, - -30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan305-layout.npy b/gen/layouts/FloorPlan305-layout.npy deleted file mode 100644 index 0df7e536cd06e4bcfb2e6140507b7d48aca555e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1472 zcmbW#u}Z^G6o>J+`V`rskVzbh2;JNi7Y8Q^HpM}#B;r!~6h2U2A&=0pV}=YJt>*p$ zp3y9a@7#0#UvHDIyNBER$CKgH}Id&}O7Q8j(2i}Sp=7@rnpUW_O8Ydw6vpVXu3XMQ<+ znpT_n^l|u7ZG3okQs&1;W&V->_d3XauVueo*RyS}lIQ7ule`G_zWbhEhUeMyojv!* zIuG;qlv%b&bNjLLvHd!GFMQWNakXDJ@3#}SAKQxf$f4>*J8@w01AMAI| z(&cwx=j6Ehea-cp&SN-Nq>Sq0{pY^kT*3bG`KkH}x-8pA%A?s)T cte?B@rcQIKe%8Oe&5!wsO!Xi;`m*7-#35%uM)2l%lChX z`JYkc<5jxn*FdxhZ59z)AsP=>T;6A)DAKb@$ z%m?$qs@z=V>-Uk5D7bVe%@vRTBnrGR6cZH;s#flOa;#K*SW|V!R432rr?Rz{uF40|SFd z&(nl6+U4Z^{+##MhVXs&aC`rF6h6XdJ}DN@Wqy_A*VD_qpXJke`Cg7+pXTMH_^aQH zXNzK2U%ZUpiXER0&IkSM;;f&2W&eCm!v0we+jFyQ&vn98Ue(@``+WL*>%@ooFdyc_e3%dOtr8#R!+e+z^I<+*@x+tAs}I`>=EwY) zA2-Q9zrK?xB93^W!R+=hqL>?>qBj{~K5yT*v#dJXjtq508?#FKP z?bGe$QpNeD}Yn~#@*>$zpU>AroaeshVb8;!hdmE_9`-z3ykh5Y6*t27$q&h6@{~L$ z>*qQ3<2KG^{a8Qt9GtKExvwAV$NI5;tRF|M!uqj(tRL&g`tcn7SU=CDAM3~Zv3{%{ zJBRaCKlk-x{a8QNkM(2ySU=W}^<({5Ki1E4=*Rl8eykts$NI5zIbZd2Uq9B5^<({b zh@ThMkM-j*eO^EB>&N=ptsm>h`muhjAM3~Zu^pVR`nj(k4|lZ~>&HX%VEtG>9@FQi zWc_?zKRfkf{a8QNkM(2ySU=W}?c#jZ&;23#v3{%{>&N=Beykts$NJf&AM3~Zv3{%{ z>&N=Beyktc$@yx(j`p+tY(Lx2_OtzLKikh^d_UQKwx8|yeYcCC;Kd1d{Kikjtv;BOCJ#0VQ&-SzZY(Lw7Nc-7- zwx8{1`}q+2c}}+9`}VW_Y(Lvyx^jB?{bl>vezu?OXZv}M{cJzm&-SzZJfyEzpW^s$ zSN}I$#htLfTi*9~fXDRtDOs;3zMfv(_T}_yx_Vvo_1biC?c*BOs|oAHda+)t7wg4( zv0hx_#d@(`tQYIW`YgI~dg;S$U+=R%?B|I~`n*2g*N63CeOMpXhxOsQwiMQf^Q~l>+rHjseYi>Qmt=i>ULV$n^xcEjo787a zu?sv+$+BI2Hf6AVu=#ih_sv%qhcq|FKIHjzuM2g4cl9(M^Nab#{Ngd_`HjACjQq-X z$uH&?cWEBx7xRnx#r)#G{+Ta(Vmch7{p~@I=`lT~w>Lee$Ml%K3;%-YF+CpB`+HaO RF+HZo^!|Y!(_{L6_67EG(ZT=# diff --git a/gen/layouts/FloorPlan310-objects.json b/gen/layouts/FloorPlan310-objects.json deleted file mode 100644 index abcb8f2a2..000000000 --- a/gen/layouts/FloorPlan310-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "BasketBall", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Poster", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Bed", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan310-openable.json b/gen/layouts/FloorPlan310-openable.json deleted file mode 100644 index 586254660..000000000 --- a/gen/layouts/FloorPlan310-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "Cabinet|-00.24|+01.53|-02.10": [ - -0.5, - -1.25, - 180, - 30 - ], - "Cabinet|-00.62|+01.53|-02.10": [ - -0.5, - -1.25, - 180, - 30 - ], - "Desk|-00.96|00.00|-01.94": [ - -0.5, - -1.25, - 180, - 30 - ], - "Drawer|+01.62|+00.16|-00.99": [ - 1.0, - -1.75, - 90, - 30 - ], - "Drawer|+01.62|+00.45|-00.99": [ - 0.75, - -1.5, - 0, - 30 - ], - "GarbageCan|+00.13|-00.03|-02.15": [ - 0.25, - -1.5, - 180, - 30 - ], - "Shelf|-00.96|+01.53|-02.10": [ - -0.5, - -1.25, - 180, - 30 - ], - "SideTable|+01.69|+00.00|-00.99": [ - 1.25, - -1.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan311-layout.npy b/gen/layouts/FloorPlan311-layout.npy deleted file mode 100644 index 2cb922b71da809507481b3a1c9411bc8f03074aa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3760 zcmbW%ziJdw6bImI5RnkXzp1BNg{`(xL~tuRC5?rZEXf87F|sQ*;#2rQd4+j|lqsi} zB87!9bG`+CrQ2M-d*`0>JG06DdiVbA(T7{@d;2jvS#OUwvzOiM)#;1byqle#ZN6<* zUp}5~PS$_-->g1w*Vp^oPphx%Yd>8qp3l3*vw8Qk`_IpQyZKz4PwQ2!eRw);ZFm0q z-{&vFm*F8ihOffE!)+P;&L@wx%FEMfYur~omY3z_A)c4lxx6edd!Iw(WBItRek>o$ z$3r|nhUN3TJeQG&yM?}z1Q`B{D*iyf7pXF!yS$>wEckjRElwV)@S$>wE z)#Y5}w=X{r-gm9?JC~pR|FhpK9_#zi*L-X~HXoah&Byw1uI95p)Ld*nHXoah&Bx}` z$9!x)HXoah&Bx|reK}Y2**71XkIl#CW2?Hks&8L?R-e^p^|KD=s=j^oS$$UDJ$>18 zoU8iw)#ttC^o_B8?&-(+v3s1We)iS3uRg2K>a#kWtNP|rpVepeS$$UT_Oji4)MNEn zJ$C<2+-LXMeRltD+-LXMeKrq!e!uE@o}C}WIXk}>=d2%lU-#>I_gQ~-pZog#eNgvX zeYmgRL-zZ^-XF`u@~}KC5Bq!Ly~@SDcb5NQJy-D?%g^$&{477q&+@bUEI-T7^0WMp zB0tN|^0Ry_AIrz`v3x8a`#)j*9#>xdSU=W}^<({5{U=eM)o1lteO8~a-ucY_=ziyv5ch|S~C*du;SIf44?5c}cU9M(T9jn#4d+nN+hjq7XfA3#4&wYEm z-#;~*_UNGp2z0xi+OAwo5$v{d2AksMSkyj-lVXeUD3mOSPu_*Ki0!~SP$!AJ!5qU zelM(t_3)5;SP$!AJv>?XYrN`l)x&x?c^~M0!N^vq_D6Q-F*~O zy3OYe%=^G|wOOvWJ#|xeliGam%uJhkHZ_qp+1XuPa@w6;YQOVEa?EWz&kxDPwmcY5 zB0U;L`l0_lef2wa;qx65ehF>@S0Uk2u(v7I-H-hQ#!upd@xl1uGWcK;k4${b@xl1u zD)`}Aa3h$0*#pa@zncdiOg~INOg~INUfvt#Ians&&zydk{*DWO#U6byeK32lO!}D9 S2RHm5GW4^DA7&56SH&MW35^s0 diff --git a/gen/layouts/FloorPlan313-objects.json b/gen/layouts/FloorPlan313-objects.json deleted file mode 100644 index 31b0cedac..000000000 --- a/gen/layouts/FloorPlan313-objects.json +++ /dev/null @@ -1,34 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "HousePlant", - "Laptop", - "Mug", - "Bed", - "ShelvingUnit", - "TennisRacket", - "TissueBox", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan313-openable.json b/gen/layouts/FloorPlan313-openable.json deleted file mode 100644 index fa062d428..000000000 --- a/gen/layouts/FloorPlan313-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bed|-01.74|+00.00|-00.07": [ - -0.75, - 0.0, - 270, - 30 - ], - "Desk|+00.63|+00.00|-01.56": [ - -0.75, - -1.5, - 90, - 30 - ], - "Drawer|+00.27|+00.16|-01.43": [ - -0.25, - -0.25, - 90, - 30 - ], - "Drawer|+00.27|+00.35|-01.43": [ - -0.25, - -0.5, - 90, - 30 - ], - "Drawer|+00.27|+00.55|-01.43": [ - 0.75, - -0.5, - 270, - 30 - ], - "Drawer|-00.16|+00.16|-01.43": [ - -0.75, - -0.25, - 90, - 30 - ], - "Drawer|-00.16|+00.35|-01.43": [ - 0.5, - -0.25, - 270, - 30 - ], - "Drawer|-00.16|+00.55|-01.43": [ - 0.25, - -0.5, - 270, - 30 - ], - "Shelf|+01.41|+00.18|-01.51": [ - 0.75, - -0.25, - 90, - 30 - ], - "Shelf|+01.41|+00.38|-01.51": [ - 1.0, - -0.5, - 90, - 30 - ], - "Shelf|+01.41|+00.57|-01.51": [ - 1.0, - -0.5, - 90, - 30 - ], - "Shelf|+01.54|+00.49|-00.48": [ - 0.75, - 0.0, - 180, - 30 - ], - "SideTable|+01.56|+00.00|-00.47": [ - 1.0, - -0.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan314-layout.npy b/gen/layouts/FloorPlan314-layout.npy deleted file mode 100644 index f10c008a9a66b66ee3094394f56b5cc292d50f9a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1200 zcmbW!uTH~Y6o=t&lUzmJ2T2uT5JJKf4uV0TNW;1y$VOU%AzTF)v|HFEOioTzAP@}N zM{p!HC-3R+&*}DYeS39tH%hPREzj!qp~+`OKA)fFvdHsg^U_p{`(-n$fA*KvQ(N!% z?PK*^@A+_YQWnQYW$|A8_c=(v&-S99-Kw9vz+K?az+Zvo?N)#Duskde%fs@vArH&L z^6+}NZ!`Eef#rMe`>}j1AG;UpTZcZZ59`C-a39u(^Q-9?Y-F}=I#F+Fx4<~R8;<^9Q|NrwkbdQAU)M%DVMUw-FanOnh|!P~{VW!Ay&``mqYe<$2$_t|}}%01Q_ zg&ym%9_#VfbG3f>Gx#I;J@_s7HQ2spUG`@CvVGaUY+tr7+n4Rj_GSCBY0o(A>)gI< zU$!sXm+i~;W&5&yS>Imztk3$a&-$$Icj~h~>$5)Vv%ddLpY>Uv^;w_wO?}p9eb#4v zHg)6FcdpO+tk3$f!*S|6*Jpj!chC2-_c%^{=lZPgJ$=?^_c%^{=lag|S)cV;hyUg` D0lgP8 diff --git a/gen/layouts/FloorPlan315-objects.json b/gen/layouts/FloorPlan315-objects.json deleted file mode 100644 index 67d605fac..000000000 --- a/gen/layouts/FloorPlan315-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Mug", - "Bed", - "TableTopDecor", - "CoffeeTable", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan315-openable.json b/gen/layouts/FloorPlan315-openable.json deleted file mode 100644 index 9d1fe11f2..000000000 --- a/gen/layouts/FloorPlan315-openable.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "Bed|-02.98|+00.01|-01.18": [ - -1.75, - -1.0, - 270, - 30 - ], - "CoffeeTable|-00.50|+00.01|-03.99": [ - -1.0, - -2.5, - 180, - 0 - ], - "Desk|-00.86|+00.01|-04.03": [ - -0.75, - -3.25, - 180, - 30 - ], - "Drawer|-00.50|+00.07|-03.80": [ - -1.25, - -2.5, - 90, - 30 - ], - "Drawer|-00.50|+00.23|-03.80": [ - -1.25, - -2.75, - 90, - 30 - ], - "Drawer|-00.50|+00.39|-03.80": [ - -1.25, - -2.75, - 90, - 30 - ], - "Drawer|-03.61|+00.11|-03.26": [ - -2.25, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.11|-04.06": [ - -2.25, - -3.25, - 180, - 30 - ], - "Drawer|-03.61|+00.30|-03.26": [ - -2.75, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.30|-04.06": [ - -2.5, - -3.25, - 180, - 30 - ], - "Drawer|-03.61|+00.49|-03.26": [ - -2.5, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.49|-04.06": [ - -2.5, - -3.25, - 180, - 30 - ], - "Drawer|-03.61|+00.69|-03.26": [ - -2.75, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.69|-04.06": [ - -2.75, - -3.5, - 180, - 30 - ], - "Drawer|-03.61|+00.88|-03.26": [ - -2.75, - -4.0, - 0, - 30 - ], - "Drawer|-03.61|+00.88|-04.06": [ - -2.75, - -3.5, - 180, - 30 - ], - "Dresser|-03.65|+00.01|-03.66": [ - -3.0, - -3.5, - 270, - 30 - ], - "GarbageCan|-01.84|-00.02|-03.90": [ - -2.25, - -4.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan316-layout.npy b/gen/layouts/FloorPlan316-layout.npy deleted file mode 100644 index 6d83f59eb4e355ad5d0e7f104faadc30d538014d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1056 zcmbWzu}Z^G7>42F>Q!Vr3Yi3-pY!=jtDKl7{Rxo>y# z{;7FwcYJa_sjIWox>{BLeU8)bv;N%YSIHsp{%uN!_tU@UH|6}cq&}<<>%&9o!|TBM z$Iy@UWBph^){i&EhsVJD()Zz^?1lL;Kjz2$m>)~tnEdAam>=_Fe$0>gqX)<2Kg`Sj s#Qc~a^W$x}Zyz3eV)t-N|HIrq*gn`k*gjb5jj7*UKOTKwN&Un08!2+Cy8r+H diff --git a/gen/layouts/FloorPlan316-objects.json b/gen/layouts/FloorPlan316-objects.json deleted file mode 100644 index 98fd21897..000000000 --- a/gen/layouts/FloorPlan316-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "Desktop", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "HousePlant", - "Laptop", - "Bed", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan316-openable.json b/gen/layouts/FloorPlan316-openable.json deleted file mode 100644 index bf39297e3..000000000 --- a/gen/layouts/FloorPlan316-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Bed|-01.70|+00.00|-00.45": [ - -0.75, - -0.25, - 270, - 30 - ], - "Desk|+00.62|+00.00|-01.51": [ - 1.0, - -1.0, - 90, - 30 - ], - "Drawer|-00.56|+00.16|+00.46": [ - 0.25, - -0.25, - 0, - 30 - ], - "Drawer|-00.56|+00.46|+00.46": [ - 0.0, - -0.25, - 270, - 30 - ], - "GarbageCan|+01.66|-00.02|-00.39": [ - 1.0, - 0.0, - 90, - 30 - ], - "Shelf|+01.62|+00.56|-00.80": [ - 0.25, - -1.5, - 90, - 0 - ], - "SideTable|-00.56|00.00|+00.53": [ - 0.0, - 0.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan317-layout.npy b/gen/layouts/FloorPlan317-layout.npy deleted file mode 100644 index 8fb312dceb153889f4dd5423cd0fb302f6383aad..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1680 zcmbW$uTH~29Ki8nd5XG1GKJw!Na}D93<5(h&^dDR`j0LLXsrvZA75f>vr z%{O6x_qD!D>)z96eb#6Da2)l`>$AS+^jV+VbY9kH`*Ixh&Fh=jXMJu{pY>UvbvTat zO*yRSvp(yyKI^kS>$AS!xjuJ(AL)Gh*7aGR^;w_w{jc;{pY>Uv^;w_wS-%b6KkKtT Z>$5)VvpzSz*EBkp^*DCn`963z`Ui(uBv$|c diff --git a/gen/layouts/FloorPlan317-objects.json b/gen/layouts/FloorPlan317-objects.json deleted file mode 100644 index 0f7129662..000000000 --- a/gen/layouts/FloorPlan317-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "LaundryHamper", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Poster", - "Pen", - "Cloth", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Mirror", - "Floor", - "Safe", - "Laptop", - "Bed", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan317-openable.json b/gen/layouts/FloorPlan317-openable.json deleted file mode 100644 index 8145411a3..000000000 --- a/gen/layouts/FloorPlan317-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "Bed|+01.38|+00.00|+00.07": [ - 1.5, - 1.0, - 180, - 30 - ], - "Drawer|+00.41|+00.11|-01.63": [ - -0.5, - -0.25, - 90, - 30 - ], - "Drawer|+00.41|+00.29|-01.63": [ - -0.25, - -0.5, - 90, - 30 - ], - "Drawer|+00.41|+00.49|-01.63": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|+00.41|+00.68|-01.63": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|+00.41|+00.87|-01.63": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|-00.39|+00.11|-01.63": [ - -1.25, - -0.25, - 90, - 30 - ], - "Drawer|-00.39|+00.29|-01.63": [ - -1.25, - -0.5, - 90, - 30 - ], - "Drawer|-00.39|+00.49|-01.63": [ - -1.0, - -0.75, - 90, - 30 - ], - "Drawer|-00.39|+00.68|-01.63": [ - -1.0, - -0.75, - 90, - 30 - ], - "Drawer|-00.39|+00.87|-01.63": [ - -1.0, - -0.75, - 90, - 30 - ], - "Dresser|+00.01|+00.00|-01.68": [ - 1.0, - -1.25, - 270, - 30 - ], - "GarbageCan|-02.21|-00.02|-01.74": [ - -1.75, - -1.25, - 270, - 30 - ], - "Safe|+01.64|+00.00|-02.04": [ - 1.0, - -1.25, - 90, - 30 - ], - "SideTable|+02.24|00.00|+01.33": [ - 1.75, - 1.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan318-layout.npy b/gen/layouts/FloorPlan318-layout.npy deleted file mode 100644 index 998979a6b0345090aaf7d62dee99b1c068d3b895..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1632 zcmbW$u}Z^G6b9g{h!me9TNE;hgNo2hZiMP_CI(E#Ep@W09 z$+w)*ESK;0p8vlI^!xVy=I&uHeWcHPS}mUH{4&e0X6Jd4<+FMHUQb>h=k>Ju+rOT? zEUNAP;(78`ZGC)kR%E9qMfR2b_c=O^SRTt`c`UC9c`T3RvHAXMrR00Dc{a~hIdPR|UmmyN z-oBGL@5%1X`dKc=Rlj}b<37i=9rum)yI^_F>0xsm*Jj9*Yo5)sd3N6a!g+R{o&O2% z!OpY$rLzAH=2;(`XY>1Ep3Sp)_MYrL*gaX_L78@s`?5aP$NE?w>tlU~p^x>kKGw(j USRd;fg+A8D`dA<9V|}CY7Xp6Z6aWAK diff --git a/gen/layouts/FloorPlan318-objects.json b/gen/layouts/FloorPlan318-objects.json deleted file mode 100644 index 8d246757f..000000000 --- a/gen/layouts/FloorPlan318-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "ArmChair", - "TennisRacket", - "Shelf", - "Dresser", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan318-openable.json b/gen/layouts/FloorPlan318-openable.json deleted file mode 100644 index 3f9814429..000000000 --- a/gen/layouts/FloorPlan318-openable.json +++ /dev/null @@ -1,158 +0,0 @@ -{ - "ArmChair|+01.71|00.00|+01.53": [ - 1.5, - 2.25, - 180, - 30 - ], - "Bed|-00.87|+00.01|-00.92": [ - 0.25, - -0.75, - 270, - 30 - ], - "Cabinet|-00.65|+00.27|+02.25": [ - 0.75, - 1.5, - 0, - 30 - ], - "Desk|+01.81|+00.00|-00.01": [ - 1.25, - -1.0, - 90, - 30 - ], - "Desk|-00.66|+00.01|+01.81": [ - 0.25, - 2.0, - 270, - 30 - ], - "Drawer|+01.69|+00.16|-00.38": [ - 0.5, - 0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.16|-00.81": [ - 0.5, - -0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.35|-00.38": [ - 0.5, - 0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.35|-00.81": [ - 0.75, - -0.25, - 180, - 30 - ], - "Drawer|+01.69|+00.55|-00.38": [ - 0.75, - 0.0, - 180, - 30 - ], - "Drawer|+01.69|+00.55|-00.81": [ - 0.75, - -1.25, - 0, - 30 - ], - "Drawer|-00.55|+00.16|+02.94": [ - 0.25, - 2.25, - 0, - 30 - ], - "Drawer|-00.55|+00.38|+02.94": [ - 0.25, - 2.25, - 0, - 30 - ], - "Drawer|-00.55|+00.57|+02.94": [ - 0.25, - 2.5, - 270, - 30 - ], - "Drawer|-00.55|+00.58|+02.25": [ - 0.25, - 2.75, - 180, - 30 - ], - "Drawer|-00.66|+00.23|-01.31": [ - 0.5, - -0.5, - 180, - 30 - ], - "Drawer|-00.66|+00.55|-01.31": [ - 0.25, - -0.75, - 180, - 30 - ], - "Drawer|-00.66|+00.83|-01.31": [ - 0.25, - -0.75, - 180, - 30 - ], - "Dresser|-00.67|+00.00|+02.94": [ - 0.25, - 2.5, - 270, - 30 - ], - "GarbageCan|+02.02|-00.04|-01.24": [ - 1.5, - -1.5, - 90, - 30 - ], - "Shelf|+01.77|+00.18|+00.76": [ - 0.5, - 0.25, - 0, - 30 - ], - "Shelf|+01.77|+00.18|+00.94": [ - 0.5, - 0.5, - 0, - 30 - ], - "Shelf|+01.77|+00.38|+00.76": [ - 0.75, - 1.25, - 180, - 30 - ], - "Shelf|+01.77|+00.38|+00.94": [ - 0.75, - 0.5, - 0, - 30 - ], - "Shelf|+01.77|+00.57|+00.76": [ - 0.75, - 1.25, - 180, - 30 - ], - "Shelf|+01.77|+00.57|+00.94": [ - 0.75, - 0.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan319-layout.npy b/gen/layouts/FloorPlan319-layout.npy deleted file mode 100644 index 5d5660830bfc55bf6e7fb23ecc3720fa4ffb1095..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1680 zcmbW!ElvYb6o%nTC94=WkW^v#2}!GP5DWrE8af0)D47xrVHGT>TbLzOR#uFtsGxA~ zQ*k6?PTqTF-hAKO@0+{p+xvs`kv{8bGkkhSI;)3O{WNRe+sW(0terN$=U0=L zd9yp8KTqD89Uq;a4y%*nVf9u0_c=^|&vKOKc9CaScvILOuj0PE*O%D^&eoLn`|>^J z$NYF5-tPl%0&fGSaZbQD2)tb6{klx~ao(ncyW+?4WBIZCxDVgUZ!bTVAIpzdCAX;$ z?!sQ5{l4VE`e1#qKDZCx>tnAE)(7i@-IE@AV(;NN^>wZx=cp`eJ=C zpPYP{5A$I@%%^8x?gR5-KFo*ty5ix(e3%dO;dSx&&wQ8<^I<;B=brd5ALhe+n9t>tDDQ~+r8qoc&p}Zf8SMSWp%zdt?IH`EW4MkdAeJ6^Y&~1qIvAw z-G2YjJhwX^9G}$X(P3S_m;b%?i|=cgO>0_B>pJr$^O!khHg8=0p2y~~d7NS%JHLr} z&a?Bpjpy0(>v*1ru)b5xF1XZb9j<#4{rALBd9XZb9jq$$MRV|%V+tV UVxIrOnA!JmUmqT_^ZIOOp9X=z82|tP diff --git a/gen/layouts/FloorPlan320-objects.json b/gen/layouts/FloorPlan320-objects.json deleted file mode 100644 index 36b55cead..000000000 --- a/gen/layouts/FloorPlan320-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "Curtains", - "BasketBall", - "Pillow", - "Pencil", - "SideTable", - "KeyChain", - "GarbageBag", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "Dumbbell", - "DeskLamp", - "Footstool", - "Desk", - "Mirror", - "Floor", - "Laptop", - "Bed", - "TennisRacket", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan320-openable.json b/gen/layouts/FloorPlan320-openable.json deleted file mode 100644 index 4461adc3d..000000000 --- a/gen/layouts/FloorPlan320-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "Bed|-01.04|+00.01|-00.69": [ - -0.5, - 0.25, - 180, - 30 - ], - "Desk|+01.52|+00.00|+00.39": [ - 0.75, - 0.5, - 90, - 30 - ], - "Desk|-01.72|+00.00|+00.92": [ - -1.0, - 1.0, - 270, - 30 - ], - "Shelf|-01.70|+00.16|+01.54": [ - -0.5, - 0.75, - 0, - 30 - ], - "Shelf|-01.70|+00.38|+01.54": [ - -0.5, - 0.75, - 0, - 30 - ], - "Shelf|-01.70|+00.57|+01.54": [ - -0.75, - 1.0, - 0, - 30 - ], - "Shelf|-01.84|+01.08|+01.24": [ - -1.25, - 1.5, - 270, - 30 - ], - "SideTable|+00.63|+00.00|-01.71": [ - 0.25, - -1.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan321-layout.npy b/gen/layouts/FloorPlan321-layout.npy deleted file mode 100644 index 47b25677080275d02a7ad4d0d6c6cf0bced364f2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1600 zcmbW$u};E39KhkTA;$0&-Kq%_lNu8`xoKP+oD7i?1|y~z7vod-K=KGY0wW_s2L=Yw zyKlMCE|;(E{r;uE*X{ky-NR9M4#-i|aXUv^;v(F^;w_wS)cV; zKfbjPydTzQeb#4v)?ba{nWBy>>$5)Vvp(yuvp(yyKI^kS>-(L1e%5Dw)@Oaz-)7Ix c`mE3Ttk33jsqg>C{(tQAvH5I1o7atg0H)fy0{{R3 diff --git a/gen/layouts/FloorPlan321-objects.json b/gen/layouts/FloorPlan321-objects.json deleted file mode 100644 index 8749b01dc..000000000 --- a/gen/layouts/FloorPlan321-objects.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Bed", - "ArmChair", - "TissueBox", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan321-openable.json b/gen/layouts/FloorPlan321-openable.json deleted file mode 100644 index 6efd3c144..000000000 --- a/gen/layouts/FloorPlan321-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "ArmChair|+00.85|00.00|-02.14": [ - 1.5, - -1.75, - 270, - 30 - ], - "Bed|+00.91|+00.00|+00.14": [ - 0.75, - 1.25, - 180, - 30 - ], - "Desk|+03.24|+00.00|-01.59": [ - 3.0, - -1.0, - 180, - 30 - ], - "Drawer|+00.33|+00.62|+01.30": [ - 1.5, - 1.25, - 270, - 0 - ], - "Drawer|+00.33|+00.62|-01.02": [ - 1.5, - -1.75, - 270, - 0 - ], - "SideTable|+00.28|+00.00|+01.30": [ - 0.75, - 1.25, - 270, - 30 - ], - "SideTable|+00.28|+00.00|-01.02": [ - 0.75, - -1.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan322-layout.npy b/gen/layouts/FloorPlan322-layout.npy deleted file mode 100644 index d55bd506cbc30551aafd5e5009bd845a49075629..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1792 zcmbW$u};EJ6b9fcqfgPTnlPwwFvbKXH;s#flOa;#K*SW|Vtfi8h*#(%Ffw-N;J_f- z`_+y-~S zpTXN;dFGJE@>m|rV|ku~JeJ4uSRTvs9Obb*mdElqjr-@z@|#t^FQ4VJe3sAhd64^9 zU*DFJKJN1G!}?es>*K-Lr+(Gf&(aIWAkv6=V9}(dDuK`9*(Q~x9|S9qb~?*2~Yq4 diff --git a/gen/layouts/FloorPlan322-objects.json b/gen/layouts/FloorPlan322-objects.json deleted file mode 100644 index 43380c052..000000000 --- a/gen/layouts/FloorPlan322-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Curtains", - "Pillow", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "Cloth", - "CreditCard", - "Book", - "CellPhone", - "Cabinet", - "DeskLamp", - "Drawer", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "ArmChair", - "Shelf", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan322-openable.json b/gen/layouts/FloorPlan322-openable.json deleted file mode 100644 index ab36ff242..000000000 --- a/gen/layouts/FloorPlan322-openable.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "ArmChair|+02.57|+00.00|-00.82": [ - 2.0, - -0.5, - 90, - 30 - ], - "Bed|-00.75|-00.02|+00.11": [ - 0.75, - 0.0, - 270, - 30 - ], - "Cabinet|+02.48|+00.50|+01.00": [ - 1.75, - 0.25, - 0, - 30 - ], - "Cabinet|+02.48|+00.50|+01.01": [ - 1.75, - 1.75, - 180, - 30 - ], - "Cabinet|+02.48|+00.50|+02.03": [ - 1.75, - 1.25, - 0, - 30 - ], - "Cabinet|+02.48|+00.50|-00.02": [ - 1.75, - 0.75, - 180, - 30 - ], - "Drawer|+02.57|+00.90|+00.23": [ - 2.0, - -0.25, - 0, - 30 - ], - "Drawer|+02.57|+00.90|+00.75": [ - 2.0, - 1.0, - 180, - 30 - ], - "Drawer|+02.57|+00.90|+01.26": [ - 2.0, - 1.0, - 0, - 30 - ], - "Drawer|+02.57|+00.90|+01.78": [ - 2.0, - 1.5, - 0, - 30 - ], - "Drawer|-01.53|+00.46|+01.48": [ - -1.0, - 1.5, - 270, - 30 - ], - "Drawer|-01.53|+00.46|-01.25": [ - -1.0, - -1.25, - 270, - 30 - ], - "Dresser|+02.82|+00.00|+01.01": [ - 2.25, - 0.75, - 90, - 30 - ], - "GarbageCan|+01.35|+00.00|-01.69": [ - 0.75, - -1.0, - 90, - 30 - ], - "Shelf|-01.55|+00.04|+01.33": [ - 0.0, - 1.5, - 270, - 30 - ], - "Shelf|-01.55|+00.04|+01.60": [ - -0.5, - 1.5, - 270, - 30 - ], - "Shelf|-01.55|+00.04|-01.13": [ - -0.5, - -1.25, - 270, - 30 - ], - "Shelf|-01.55|+00.04|-01.40": [ - 0.0, - -1.25, - 270, - 30 - ], - "SideTable|-01.60|+00.00|+01.48": [ - -1.0, - 1.5, - 270, - 30 - ], - "SideTable|-01.60|+00.00|-01.25": [ - -1.0, - -1.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan323-layout.npy b/gen/layouts/FloorPlan323-layout.npy deleted file mode 100644 index 0add409d466e1b9f7b3b2198c7ab57455ca4ff83..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3184 zcmbW&u}ULB7{Kvy5jpNDwp)cXTAd=em7QX9#Z?kCVj(Jt*oaTz1G$f|k6>xJ#THwn zFvraAz^}X%PJRDv#|hKQWKZWAoTNHjmBYb(znp z&2#@bGgV!FqKEac9@fKpSP$!AJzTZ9gR?e2yZlTa>tlVakM*%W*2ns|YI6q{rS*G$ zrjPZpKGw(jcq-o?>tlUfwYh_{Qkp^^>tlVakM;3X`gk3z&+GbF-x&H>AM4|x%wv75 zkIfsxJT{NbWAk_{^VvN1d9dFbe+PX}>~mq=>>Q4(zo+*5a!+=D?n^(rKf6D>Kab)4 z?(cQ?XZP3X{_Otj{_OtjT#l>z+joCtQ`SmhXf0 zupYMRh^rp^dRPzZ;j#3v9@fKp;#`ia9{YND@OhL~kJt6E9@Z7-a9qu|Z$6vP=Ck`d z$9&es-p6q@-@f^5KAZ1-=Ck>1K0AlwYQBB*+2_yxe{j|2BG&6%z1)ZIU9Z>mvU54E fdhP3Fy{wn@IY%GsV|}cToy&36XI~%dn@+v}36aM& diff --git a/gen/layouts/FloorPlan323-objects.json b/gen/layouts/FloorPlan323-objects.json deleted file mode 100644 index 52144cfd1..000000000 --- a/gen/layouts/FloorPlan323-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Sofa", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "Bowl", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "Safe", - "Laptop", - "Mug", - "Bed", - "Dresser", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan323-openable.json b/gen/layouts/FloorPlan323-openable.json deleted file mode 100644 index e202bfd8c..000000000 --- a/gen/layouts/FloorPlan323-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bed|-01.61|-00.03|-01.86": [ - -1.5, - -0.75, - 180, - 30 - ], - "Desk|+02.32|-00.01|-03.22": [ - 2.0, - -2.5, - 180, - 30 - ], - "Drawer|+01.98|+00.21|-02.99": [ - 1.25, - -2.5, - 90, - 30 - ], - "Drawer|+01.98|+00.49|-02.99": [ - 1.25, - -2.5, - 90, - 30 - ], - "Drawer|+01.98|+00.73|-02.99": [ - 1.25, - -2.5, - 90, - 30 - ], - "Drawer|+02.64|+00.17|+01.51": [ - 2.0, - 1.0, - 0, - 30 - ], - "Drawer|+02.64|+00.45|+01.51": [ - 2.0, - 1.0, - 0, - 30 - ], - "Dresser|+02.68|+00.00|+01.51": [ - 2.25, - 1.5, - 90, - 30 - ], - "GarbageCan|+01.34|+00.00|-03.38": [ - 1.0, - -3.0, - 90, - 30 - ], - "Safe|+02.72|+01.23|+01.78": [ - 2.25, - 1.5, - 90, - 0 - ], - "SideTable|-02.42|00.00|-00.51": [ - -2.0, - -0.5, - 270, - 30 - ], - "SideTable|-02.42|00.00|-03.15": [ - -2.0, - -3.0, - 270, - 30 - ], - "Sofa|+02.38|+00.01|-00.29": [ - 1.5, - -0.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan324-layout.npy b/gen/layouts/FloorPlan324-layout.npy deleted file mode 100644 index 02f4fc67b619400618029e51b4123a4047667b80..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1552 zcmbW#y-LGS7=YoUh=^B_Eef5Sst9#*Q(PRJq}YgqSV_f2yb3R6bS@U)Q%+H+MVfJ$;m;YVuH*XGMAb*e`oU`8clM>fy`%xE@u%=P!rP zlWKi_@-%#{);{W=_KK6^Uh!G{_c%;{$70&8>APFo;Cb*YxCzeFl6lQwd;TnV9^3}& zTTQq7SRdtlVakM*(rI_+os*?!-F{cJzm?>_Bk z`+1SyFE4}5^PJ3M^VmE#k5_pt*vB?=i1zKAX?xv-xbkRX?}+dTjp2)2`J2+F;+I-+dR{g#GS& R^LxHNyDrC7uk(86gCBu)^&tQN diff --git a/gen/layouts/FloorPlan324-objects.json b/gen/layouts/FloorPlan324-objects.json deleted file mode 100644 index 00fe94151..000000000 --- a/gen/layouts/FloorPlan324-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "VacuumCleaner", - "CellPhone", - "DeskLamp", - "Drawer", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "ShelvingUnit", - "TennisRacket", - "Shelf", - "Dresser", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan324-openable.json b/gen/layouts/FloorPlan324-openable.json deleted file mode 100644 index 18df29209..000000000 --- a/gen/layouts/FloorPlan324-openable.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "Bed|-00.84|00.00|-00.36": [ - -0.75, - 0.75, - 180, - 30 - ], - "Drawer|+01.60|+00.09|-01.46": [ - 0.5, - -0.75, - 180, - 30 - ], - "Drawer|+01.60|+00.09|-02.20": [ - 0.25, - -1.5, - 180, - 30 - ], - "Drawer|+01.60|+00.25|-01.46": [ - 0.0, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.25|-02.20": [ - 0.0, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.41|-01.46": [ - 0.5, - -0.75, - 180, - 30 - ], - "Drawer|+01.60|+00.41|-02.20": [ - 0.5, - -1.5, - 180, - 30 - ], - "Drawer|+01.60|+00.57|-01.46": [ - 0.25, - -2.0, - 90, - 0 - ], - "Drawer|+01.60|+00.57|-02.20": [ - 0.25, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.73|-01.46": [ - 0.5, - -1.5, - 90, - 0 - ], - "Drawer|+01.60|+00.73|-02.20": [ - 0.5, - -2.0, - 90, - 0 - ], - "Dresser|+01.63|+00.00|-01.83": [ - 1.0, - -1.75, - 90, - 30 - ], - "GarbageCan|+03.38|+00.00|+00.22": [ - 2.5, - -0.25, - 0, - 30 - ], - "Shelf|+00.02|+00.18|-02.51": [ - -0.5, - -1.5, - 90, - 30 - ], - "Shelf|+00.24|+00.34|-02.51": [ - 0.75, - -1.75, - 270, - 30 - ], - "Shelf|+00.25|+00.67|-02.52": [ - 0.75, - -2.0, - 270, - 30 - ], - "Shelf|+00.36|+00.18|-02.51": [ - -0.25, - -1.5, - 90, - 30 - ], - "Shelf|+00.47|+00.34|-02.51": [ - 0.0, - -1.75, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan325-layout.npy b/gen/layouts/FloorPlan325-layout.npy deleted file mode 100644 index 56831d6298ed3e097660d18a1df40c23b83aca2c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3040 zcmbW&F-{vn6b9glg(8FyO5zJ_w;;K}6^fAJDjg9GMJi-rTNDV89i>4zMGj<+ut%VD zxy2SPTm+c;EcumjGx~NsZ~x!e%ikYY7neUjq~GbOo=g`v^ZIL5pU=+fK~>Kl=D+6S z`|F4KWcqgf`}l4#eZ9W89Y0QAeSCU098|-TLG`El&(}eEf4wa8x+!ZDoOe^&?tj~T z|4Z;H*!*>wYd)LLO*zlzv-xa(7v{71Y(AUM=5t%}a2LD|-UO#nPT+hmcrW;4@P647dIsz>(BbL{@jK0`rFr^_2*v6%lfnatUv3|`g2oyuR?#;pY><`S%2y#QSnw<#AmeZhanQmB+q3EDy`$K60}6aa`qby)8Ld z9+rpYVR_7zhvi}CIIi-zE)UDY^04o1NXOY zp68f(Y#y7(&U@}T&(5>wl;@)J>^wWa^>e<`8|8Jg-1R!R3vPquF;5)p=Q6OwX!8SxslnTQhojm^I_c&-JU( z^L(G7caEdTjA48NbvBF=srXHm!5Z{zIMarWCdi!^&_hRnNk zp8MO(U1q;;{W`n9%Dl`RQ-xsv@-klGQ2%w2SwHLbGxcNrSU=W}^<({5Kh}?9`Vd$@ z){pgL{n*qipZdA3AM3~Zv3{%{>&N=Beykts$Gtk8(8ejR9?oOuaZ$&8>^yd!={$BG zo1T;PY&~1=Ia<%F^nYgi*?!O6ezu?2={(+K?lNyP?=s8dJbAo#c~~Bnhvi{;SRR&# z4m;IYnI|slxClBfV{o?o8eoV9YoaQEQ3hew>UUwclkGHeQi|voR`Sm#E z^LP_jeh7IikL9s^AM#ip%VXbzQ}*~T`Ev@)hxxF)|0s{;u{_oX^O<~@5A$I@Z1Tj( zXPpo8VZNBdaq?N`!+g$p4|Wd6DbFj9<*_`DldsSBmJjn`KFo*X9P)h|vcC`PUfFjq pa0=)3``gc6tRL17>xcClLqDt^)(@xL59^0h_G108eptV8_64mfLl9g=T_LFfK?osP6%K+ypvc0yOb|v|f+1W57qna0B~(sUOdt>p zdVWiGB*%Pv&Y$o3-tP0}?)vtAFT92KVp6w{O>vPIm(%m2%!}!~d2Pne5A$YH|L$Ln zpW1q}-_FJ_^@fkmPRjiBxXeHD|E|OEx7MSf_KTr@CH$RmsCMrkB&^>m>4){h`r$10 z!}|&IIp^yVALhe+m=E(|KFqgFe3%dOVLr@<`S3b^{}7k|2lHV*oK=1emCr68mU9`s z=D_aZw07Rbx=OfDSU!E^!}4MIa8?ZyVfnCpSibF?i{U*UCpo_x;b S!}4MIa8~WkC!cfqy3r3)Rg?Pw diff --git a/gen/layouts/FloorPlan328-objects.json b/gen/layouts/FloorPlan328-objects.json deleted file mode 100644 index 1a17b7f1a..000000000 --- a/gen/layouts/FloorPlan328-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "AlarmClock", - "Pillow", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "TeddyBear", - "CellPhone", - "Dumbbell", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Floor", - "HousePlant", - "Laptop", - "Mug", - "Bed", - "TennisRacket", - "TissueBox", - "Shelf", - "Chair", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan328-openable.json b/gen/layouts/FloorPlan328-openable.json deleted file mode 100644 index 742c72d37..000000000 --- a/gen/layouts/FloorPlan328-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Bed|+00.23|00.00|-00.95": [ - 1.25, - -1.0, - 270, - 30 - ], - "Desk|+02.50|+00.00|-01.60": [ - 2.75, - -1.0, - 180, - 30 - ], - "Drawer|+01.24|+00.13|-01.55": [ - 1.75, - -0.5, - 270, - 30 - ], - "Drawer|+01.24|+00.35|-01.55": [ - 1.75, - -0.75, - 270, - 30 - ], - "GarbageCan|+03.17|-00.01|-00.26": [ - 2.5, - 0.25, - 180, - 30 - ], - "Shelf|+03.03|+00.64|-01.58": [ - 2.5, - -0.75, - 90, - 30 - ], - "SideTable|+01.24|+00.00|-01.55": [ - 2.0, - -0.75, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan329-layout.npy b/gen/layouts/FloorPlan329-layout.npy deleted file mode 100644 index 2328b0b89d500347af2954dd40046c6b4fb53b70..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1536 zcmbW!p-#hK6hPr(d5XG1QiW;=Nl~~F3<51LtC8Z#l^fT%Dk8_+Shjae7|UC&CmX7`m}8J z`{m>GrP=dIRh9YKX_a|3nSG6O2)qrv3!GgZzR$N?9r`dI=EHoLZyS7= z5A$I@%r^ud=EHoL5BKT+=z|aQVLr@<`8L6a`7j^m!@OPc+2c6Z={fuKbu+xK#|`cR zZvyM_{1EQzabFMCgY`J49_%?Br=GukIuF)^^^&T( z?_;kA>%n^Pkb1BltOx7CdYnTK)`Rt69vr70dp)@KJ<`%shfw@+TokNGh_ H=I`on>on)? diff --git a/gen/layouts/FloorPlan329-objects.json b/gen/layouts/FloorPlan329-objects.json deleted file mode 100644 index 96fb14e54..000000000 --- a/gen/layouts/FloorPlan329-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "BaseballBat", - "AlarmClock", - "Pillow", - "Box", - "Blinds", - "Pencil", - "SideTable", - "KeyChain", - "Window", - "GarbageCan", - "Pen", - "CreditCard", - "Book", - "CellPhone", - "DeskLamp", - "Drawer", - "Desk", - "Mirror", - "Painting", - "Floor", - "Laptop", - "Mug", - "Bed", - "Shelf", - "LightSwitch", - "CD" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan329-openable.json b/gen/layouts/FloorPlan329-openable.json deleted file mode 100644 index 549094674..000000000 --- a/gen/layouts/FloorPlan329-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "Bed|-00.12|00.00|-01.70": [ - 1.0, - -1.75, - 270, - 30 - ], - "Desk|-00.28|00.00|+00.83": [ - -0.75, - 0.25, - 0, - 30 - ], - "Drawer|+00.95|+00.17|-02.39": [ - 1.5, - -2.0, - 270, - 30 - ], - "Drawer|+00.95|+00.46|-02.39": [ - 1.5, - -2.0, - 270, - 30 - ], - "GarbageCan|+02.47|-00.03|+00.94": [ - 2.0, - 0.5, - 90, - 30 - ], - "Shelf|-00.28|+00.10|+00.83": [ - 1.25, - 0.25, - 0, - 30 - ], - "Shelf|-00.28|+00.35|+00.83": [ - 1.5, - 0.5, - 270, - 0 - ], - "SideTable|+00.95|+00.00|-02.46": [ - 1.5, - -2.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan330-layout.npy b/gen/layouts/FloorPlan330-layout.npy deleted file mode 100644 index 7a63bb699dd8cc91bd1229f78cf5b331ecdecbff..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2240 zcmbW%Jx*Iu5QgEy6{5&0Zg&&OO-K`=NZg8!C=CTwWCbG%6p$U!AXdSGoF&{PP*S>Z z;esNBGtZGSWll4G=jWUGEX$8y&rZLc@0Gi9KU^$UKbFH$KYY3TJk0vx@@DyKIsf_n zW_hvrn?IRfuNJTQ)z$oV@yhQ%emb1>haYDBL;s)eU3q((b&UtVYkW?uzMtw?y-Rhh zUQ!*azr?V^q-PGrjO}k`j|eZ|D5zOeN4Zxxrp|u+lRO7>UR_U_G8~4wjbM%t6C{|q8qXK z40eb99JgtHm-r=d8UOXuCFb9r?Yj22J&E~O=O0h0zp9ne>Tw_DAM=mfU1?68f6PDj zKiT@?KD2B6c>fg^V#*g!Q z^ZEQ?{9JE*aC}-7M~7AMUi|kNr0vsfckjh;_wEFz;PvO<-(LkUgBQX3xwjndI)mVT za4*$840f8T!AXMNUZeb(=V ZKBqQqAJ%7m)@S{G=(9fSvp(zhM?dB_q@(}< diff --git a/gen/layouts/FloorPlan4-objects.json b/gen/layouts/FloorPlan4-objects.json deleted file mode 100644 index 60ee2f021..000000000 --- a/gen/layouts/FloorPlan4-objects.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Bread", - "Sink", - "DiningTable", - "Floor", - "HousePlant", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan4-openable.json b/gen/layouts/FloorPlan4-openable.json deleted file mode 100644 index b61a84d71..000000000 --- a/gen/layouts/FloorPlan4-openable.json +++ /dev/null @@ -1,98 +0,0 @@ -{ - "Cabinet|-01.00|+00.39|+00.73": [ - -1.75, - 1.5, - 90, - 30 - ], - "Cabinet|-01.73|+00.39|+00.73": [ - -2.0, - 1.5, - 90, - 30 - ], - "CounterTop|-00.52|+01.16|+00.49": [ - -1.0, - 1.0, - 90, - 30 - ], - "CounterTop|-02.28|+01.16|+00.38": [ - -1.75, - 1.0, - 180, - 30 - ], - "CounterTop|-03.86|+01.16|+00.38": [ - -3.25, - 1.25, - 180, - 0 - ], - "DiningTable|-00.62|+00.02|+02.49": [ - -1.25, - 2.5, - 90, - 30 - ], - "Drawer|-02.04|+00.22|+00.59": [ - -1.5, - 1.5, - 270, - 30 - ], - "Drawer|-02.04|+00.61|+00.59": [ - -2.5, - 1.25, - 90, - 30 - ], - "Drawer|-02.04|+00.94|+00.60": [ - -1.5, - 1.0, - 270, - 30 - ], - "Drawer|-02.50|+00.22|+00.59": [ - -3.0, - 1.5, - 90, - 30 - ], - "Drawer|-02.50|+00.61|+00.59": [ - -3.0, - 1.25, - 90, - 30 - ], - "Drawer|-02.51|+00.94|+00.60": [ - -2.0, - 1.0, - 270, - 30 - ], - "Fridge|-03.52|+00.00|+02.72": [ - -2.5, - 2.75, - 270, - 30 - ], - "GarbageCan|-03.70|+00.00|+02.01": [ - -3.5, - 1.5, - 0, - 30 - ], - "Microwave|-00.37|+01.11|+00.43": [ - -1.0, - 1.0, - 90, - 30 - ], - "Sink|-01.39|+00.98|+00.44|SinkBasin": [ - -1.25, - 1.75, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan401-layout.npy b/gen/layouts/FloorPlan401-layout.npy deleted file mode 100644 index 8e4a04103feacbfd316e141080638154d285734a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1616 zcmbW#u};EJ6oBE{kj5AuqFXg#(nXDlo!m4o4o-$hiGvYSjEnIpd?5P>K7u170|Ntt z2a?uR#>ds5tj3e}r5!%qP1;fOd;eni zIBnMVrw_yDX6^lxqd|FiFeu;4|6Y69=IV9Z^Xq(j=83b!tIxmRUnbW3PI|1zdaTDq z%%4S1pY6-~tk3$qi2YfAp6t*1tk3$qh(7Btl0NIRKI^kS>o1c&>$5)Vvp(yul0NIR zJ}=|h1r``(=IBXMNUZ|EE0qy)N5ac^zjLXV|pFIy3(J!L!dDuM8lJA@6bMx3dp2z!R^LLZ^oX0#ipUr3U*?cyiXR#04XD``@ i?ZftA`>=i3K5QSh4|^Z|*vEV}kIiHA*gQ6`U;hA}V9Xo< diff --git a/gen/layouts/FloorPlan401-objects.json b/gen/layouts/FloorPlan401-objects.json deleted file mode 100644 index 233e0276d..000000000 --- a/gen/layouts/FloorPlan401-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "PaperTowelRoll", - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "LightSwitch", - "Sink", - "Floor", - "SoapBar", - "HandTowel", - "Shelf", - "ShowerHead", - "Bathtub", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan401-openable.json b/gen/layouts/FloorPlan401-openable.json deleted file mode 100644 index bfe92af8f..000000000 --- a/gen/layouts/FloorPlan401-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "Bathtub|-00.21|+00.36|+00.92|BathtubBasin": [ - -1.25, - 1.75, - 90, - 30 - ], - "GarbageCan|+00.05|00.00|+03.88": [ - -0.75, - 3.25, - 0, - 30 - ], - "Shelf|-02.59|+00.78|+03.91": [ - -2.25, - 3.0, - 0, - 0 - ], - "Shelf|-02.59|+01.03|+03.94": [ - -2.5, - 3.25, - 0, - 0 - ], - "Shelf|-02.59|+01.29|+03.94": [ - -2.5, - 3.5, - 0, - 0 - ], - "Shelf|-02.59|+01.53|+03.91": [ - -2.5, - 3.5, - 0, - 30 - ], - "SideTable|-03.17|+00.00|+00.17": [ - -2.75, - 0.75, - 180, - 30 - ], - "Sink|-03.12|-00.01|+01.53|SinkBasin": [ - -2.5, - 2.0, - 180, - 30 - ], - "Toilet|+00.06|+00.00|+03.10": [ - -0.75, - 3.5, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan402-layout.npy b/gen/layouts/FloorPlan402-layout.npy deleted file mode 100644 index fbbb5a2090f0968bd287946482cba894a287ca02..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1584 zcmbW!u}T9$6a~;Rge8O!)cnA9tB^)36^p6t6dMaG31)+Z7)iuN{0cwF{S-?}3kwSi zV`fj`luomp+2p?a*q5`5)AP%X@ED$|X}!E&R7YiXJUghyWi^{G9u||ktNCJD|K6WW zZkP4yet9#wuUFnV+#8qsyW{e?{O{?9_31R}8De^VzW((`=J(8RndNobywIdP{%(KI zUzyGK-h4Kn&1dtwF{IO^2b<64v-xa3o6qKRx1CqSG*=%E*?WDw*N63CeOMpXhxO@Y zeOMpXhxK87SbjgtXZb9j<+FU2KgjY~KFeqMET4-etj{o}r+M6I(mk8U=COHf9{Yam z`?2rGMLT~prXKpSeykts$NI5;tRL&g`th*sx7GF=WbS9~WiB$?PoDkQer!LsAKQ=Z i$M$3UvHiAVSRebb{n&n7H0ggVZxqwLJeJ4uM)3zd*{L7^ diff --git a/gen/layouts/FloorPlan402-objects.json b/gen/layouts/FloorPlan402-objects.json deleted file mode 100644 index 5135a1b2f..000000000 --- a/gen/layouts/FloorPlan402-objects.json +++ /dev/null @@ -1,33 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "Shelf", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan402-openable.json b/gen/layouts/FloorPlan402-openable.json deleted file mode 100644 index 44dc45846..000000000 --- a/gen/layouts/FloorPlan402-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "Bathtub|-02.90|+00.67|+02.86|BathtubBasin": [ - -2.75, - 3.75, - 270, - 30 - ], - "Cabinet|-00.12|+00.36|+04.63": [ - -1.0, - 3.75, - 90, - 30 - ], - "Cabinet|-01.03|+00.36|+04.63": [ - -1.5, - 3.75, - 90, - 30 - ], - "Cabinet|-01.06|+00.36|+04.63": [ - -0.75, - 3.75, - 270, - 30 - ], - "Cabinet|-01.96|+00.36|+04.63": [ - -2.25, - 4.0, - 90, - 30 - ], - "CounterTop|-01.02|+00.95|+04.88": [ - -0.75, - 4.25, - 0, - 30 - ], - "GarbageCan|-02.35|+00.00|+04.88": [ - -3.0, - 4.25, - 0, - 30 - ], - "HandTowelHolder|-00.07|+01.57|+04.81": [ - -0.5, - 4.25, - 0, - 30 - ], - "HandTowelHolder|-02.09|+01.54|+05.15": [ - -1.5, - 4.25, - 0, - -30 - ], - "Sink|-00.58|+00.93|+04.87|SinkBasin": [ - -0.75, - 4.25, - 0, - 0 - ], - "Sink|-01.53|+00.93|+04.87|SinkBasin": [ - -1.75, - 4.25, - 0, - 0 - ], - "ToiletPaperHanger|-00.07|+01.13|+03.69": [ - -0.5, - 4.0, - 180, - 30 - ], - "Toilet|-00.52|00.00|+03.22": [ - -0.5, - 2.75, - 0, - 30 - ], - "TowelHolder|-00.07|+01.41|+02.43": [ - -0.5, - 2.5, - 90, - 0 - ], - "TowelHolder|-01.72|+01.21|+01.74": [ - -1.75, - 2.25, - 180, - 0 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan403-layout.npy b/gen/layouts/FloorPlan403-layout.npy deleted file mode 100644 index 50071edd0cc8cf7d828ff704ed437190a79a84e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1008 zcmbW!F-pTw0LS5{h=Zrd7KKbgK}2Y#Zi2!IVsxmEC?NeJn+^pI~^Rs_e-*?Ss zzq_j+n~e`%QXY;)Gv7P(M^Si-Cu%7>& zm-SeW*ZI7xzYcxYXMNUZeb#4v*6%}~^;w_wdC2!;eb#6FA@o_F^;w_wxzFceebygC fpY>Uv^;w_wS)cW%&}V&~@_l#=*7seX^{4qam2{;B diff --git a/gen/layouts/FloorPlan404-objects.json b/gen/layouts/FloorPlan404-objects.json deleted file mode 100644 index 098f91eab..000000000 --- a/gen/layouts/FloorPlan404-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "ShowerHead", - "HandTowel", - "TissueBox", - "Shelf", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan404-openable.json b/gen/layouts/FloorPlan404-openable.json deleted file mode 100644 index 6b3129c2f..000000000 --- a/gen/layouts/FloorPlan404-openable.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "Bathtub|+00.22|+00.34|+00.64|BathtubBasin": [ - -0.75, - 1.25, - 90, - 30 - ], - "Shelf|-01.17|+00.28|+02.16": [ - -1.25, - 1.75, - 0, - 30 - ], - "Shelf|-01.17|+01.06|+02.16": [ - -1.0, - 1.75, - 0, - 30 - ], - "Shelf|-01.17|+01.76|+02.16": [ - -0.75, - 0.75, - 0, - 0 - ], - "Sink|-01.13|00.00|-00.59|SinkBasin": [ - -1.5, - 0.0, - 90, - 30 - ], - "Toilet|-02.15|+00.00|-00.41": [ - -1.5, - 0.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan405-layout.npy b/gen/layouts/FloorPlan405-layout.npy deleted file mode 100644 index b175551a305c675bce4672eaf23dc95cba71c2d0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 576 zcmbWzAr8VY6oBDEP@JN!kW@`Agk%l}!5~m%VO41ah)5C9UO~1fbaD_Cp_$wi7Y8Q^HpM}#B;q1og%@Nm!Ao#-ba2Sf z!D{*p{YTGocmny}mb{){o?Tq6q^I zvwgOoisgN77r%$?vwgPDAK`ty)zD)-)?+=^V?EYeE7ITbeOQn6SdaBskKY&nm(#TC zt{2^{&-$#-`mE3Ttk3!zq0joP&-$#-`mE3Tz0hZU)@OazXMNUZ{msy4eb#4v)@Oaz zXZ@|vXMNUZeb#4v)@S|g&}V(tXMNUZeb#6FozQ1})@OazXMNV|haT&(9_z6l>-CEt DyrtJD diff --git a/gen/layouts/FloorPlan406-objects.json b/gen/layouts/FloorPlan406-objects.json deleted file mode 100644 index fee4c2922..000000000 --- a/gen/layouts/FloorPlan406-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "SinkBasin", - "TowelHolder", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan406-openable.json b/gen/layouts/FloorPlan406-openable.json deleted file mode 100644 index 712dee310..000000000 --- a/gen/layouts/FloorPlan406-openable.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "Cabinet|+00.07|+00.38|+02.05": [ - -0.75, - 3.0, - 90, - 30 - ], - "CounterTop|+00.49|+01.02|+03.09": [ - -0.25, - 3.5, - 90, - 30 - ], - "Sink|+00.43|+01.04|+02.95|SinkBasin": [ - -0.25, - 3.0, - 90, - 0 - ], - "Toilet|+00.38|+00.00|+04.47": [ - -0.5, - 3.75, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan407-layout.npy b/gen/layouts/FloorPlan407-layout.npy deleted file mode 100644 index e53430e434d631d6fb74bcfe6bc1187099066062..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 672 zcmbV_Ar1mD5JijS6m^B93J`>ltiwSt2o!19ZV-eeEx`~@!GX9!kAOrX5J(ovGb5?_ zdA~FBF0;jSzHF(ZI+@bPbuc4s#?{bRZK^sPg4?a?Q2I|laogydK5pFJH{9tDtnPKK zKI?y9TYcZ_n)C6?r(k;WF8*(Vli++^DfaPk2OrEFEE69+J{TX2k3D=aKA1gNCO&$6 hFh1t+!T4Z&Fn3^?_~_ZEXCGz`WqnzeXjrj diff --git a/gen/layouts/FloorPlan407-objects.json b/gen/layouts/FloorPlan407-objects.json deleted file mode 100644 index 0cec3c67e..000000000 --- a/gen/layouts/FloorPlan407-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan407-openable.json b/gen/layouts/FloorPlan407-openable.json deleted file mode 100644 index e7f8e434c..000000000 --- a/gen/layouts/FloorPlan407-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "Bathtub|+00.88|+00.39|-01.15|BathtubBasin": [ - 0.0, - -0.5, - 90, - 30 - ], - "Cabinet|-00.07|+00.34|-01.33": [ - -1.0, - -0.5, - 90, - 30 - ], - "Cabinet|-01.04|+00.34|-01.33": [ - -1.5, - -0.5, - 90, - 30 - ], - "Cabinet|-01.05|+00.34|-01.33": [ - -1.25, - -0.75, - 180, - 30 - ], - "Cabinet|-02.02|+00.34|-01.33": [ - -1.0, - -0.25, - 270, - 30 - ], - "CounterTop|-01.04|+00.88|-01.53": [ - -1.5, - -1.0, - 180, - 30 - ], - "Sink|-00.53|+00.81|-01.60|SinkBasin": [ - -1.0, - -1.0, - 90, - 30 - ], - "Sink|-01.56|+00.81|-01.60|SinkBasin": [ - -1.25, - -1.0, - 180, - 30 - ], - "Toilet|-01.61|00.00|+00.21": [ - -1.25, - -0.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan408-layout.npy b/gen/layouts/FloorPlan408-layout.npy deleted file mode 100644 index 97a2514fc98772512785982fd1a708a0fb640592..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 704 zcmbW!F$%&k6oBCKC!C#D~MQz`xv)5r8NeayS0i^&IyoqELp diff --git a/gen/layouts/FloorPlan408-objects.json b/gen/layouts/FloorPlan408-objects.json deleted file mode 100644 index e855538bd..000000000 --- a/gen/layouts/FloorPlan408-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan408-openable.json b/gen/layouts/FloorPlan408-openable.json deleted file mode 100644 index a8048b4fb..000000000 --- a/gen/layouts/FloorPlan408-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "Bathtub|+00.29|+00.29|-00.08|BathtubBasin": [ - -0.5, - 0.25, - 90, - 30 - ], - "Cabinet|-01.50|+00.42|+00.43": [ - -2.25, - -0.5, - 90, - 30 - ], - "Cabinet|-02.29|+00.39|+00.42": [ - -2.5, - -0.25, - 90, - 30 - ], - "Cabinet|-02.31|+00.42|+00.43": [ - -2.25, - -0.25, - 0, - 30 - ], - "Cabinet|-03.09|+00.39|+00.42": [ - -2.5, - -0.5, - 0, - 30 - ], - "CounterTop|-02.30|+00.95|+00.69": [ - -2.25, - -0.25, - 0, - 0 - ], - "GarbageCan|-02.86|+00.02|-01.49": [ - -2.25, - -0.75, - 270, - 30 - ], - "Sink|-01.92|+00.93|+00.68|SinkBasin": [ - -1.75, - 0.0, - 0, - 0 - ], - "Sink|-02.68|+00.93|+00.68|SinkBasin": [ - -2.5, - 0.0, - 0, - 0 - ], - "Toilet|-01.05|+00.00|+00.55": [ - -0.5, - 0.25, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan409-layout.npy b/gen/layouts/FloorPlan409-layout.npy deleted file mode 100644 index 278e0a1d880584b4bedf2ea9897c33979fadd4dd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 752 zcmbWyF$%&!5J1sYL?q-8+pR(>ZK4RKvQum2HK7jKuDOYCPqjyJh2_W3&A*~0B! zKhWJypilbW@l-j_OZC1+)%y^>3*UsfSJCf1<{op8uiqY~R~J1@57Wc+Fug{k%He;Q v9;S!sVR}u`!}KscOb^p*i5{kh>0x@9o+o;k9;S!sVS2vkVS1Pzrsqd*d}L}c diff --git a/gen/layouts/FloorPlan409-objects.json b/gen/layouts/FloorPlan409-objects.json deleted file mode 100644 index 670bad826..000000000 --- a/gen/layouts/FloorPlan409-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan409-openable.json b/gen/layouts/FloorPlan409-openable.json deleted file mode 100644 index 2d50fa700..000000000 --- a/gen/layouts/FloorPlan409-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "CounterTop|+00.46|+00.79|+02.76": [ - -0.25, - 2.75, - 90, - 30 - ], - "Drawer|+00.44|+00.32|+02.19": [ - -0.75, - 1.75, - 0, - 30 - ], - "Drawer|+00.44|+00.32|+02.57": [ - -0.75, - 2.0, - 0, - 30 - ], - "Drawer|+00.44|+00.32|+02.94": [ - -0.75, - 2.25, - 0, - 30 - ], - "Drawer|+00.44|+00.32|+03.31": [ - -0.75, - 2.75, - 0, - 30 - ], - "Drawer|+00.44|+00.62|+02.19": [ - -0.5, - 1.75, - 0, - 30 - ], - "Drawer|+00.44|+00.62|+03.31": [ - -0.5, - 2.75, - 0, - 30 - ], - "GarbageCan|+00.41|-00.03|+03.73": [ - -0.25, - 3.25, - 0, - 30 - ], - "Sink|+00.50|+00.66|+02.76|SinkBasin": [ - -0.25, - 3.25, - 180, - 30 - ], - "Toilet|+00.27|+00.00|+01.46": [ - -0.25, - 2.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan410-layout.npy b/gen/layouts/FloorPlan410-layout.npy deleted file mode 100644 index 09bb6c6c837541d12eb2b3566f010329e8edca29..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1408 zcmbWxu}Z^07{Kwfl%s@F+Be7+g%09W#Nj44#l^u%icN74E2+4MPvHZZ$8vD6CiyKl z`Yqv??{fKnUf*8b+#Q9t@Lp}|{X0vz_ z+x{Hu;Ze5NW3Pwxu%1ck|D%WXa2)=}dRPzZVLhyeXT$wP3f)XI>$BI#F*~o%ULWgY zeXNgX!~N3~y3xn_SRcoB_%8KNefIiTAM0a%ycq7E4foG8>$lg>`gxLlA2aKBUO($+ z{j8t$&r|3|KkH}xTnv4zpJTSyZ?B*Avwqgk`WGp5qo4J&e%8fJZ=#%4Lb1b+W3^z-`m>gH}IyoL92*iIh0^1LW7MrUPJl%sL?+BMJj<8Ijgy}xXp zChhwDJYQd&|M*9@}Gk zY>(}+J+`;X_ShcVV|#3m?eQ}G{!nlJKDNj9*dE(sd)%AGH@!NZVH(d~9nV#|54#^P zvhVKayZf>GvHNjI59{yN@q<3=vp(x{$_LilOMN}oV?EYmz5T4mdaTEKtk=(atjBt+ N$FuZ5=6Ui#{R?)Il9d1e diff --git a/gen/layouts/FloorPlan411-objects.json b/gen/layouts/FloorPlan411-objects.json deleted file mode 100644 index f4d477e9d..000000000 --- a/gen/layouts/FloorPlan411-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan411-openable.json b/gen/layouts/FloorPlan411-openable.json deleted file mode 100644 index 96017b5b6..000000000 --- a/gen/layouts/FloorPlan411-openable.json +++ /dev/null @@ -1,62 +0,0 @@ -{ - "Bathtub|-01.06|+00.30|+00.43|BathtubBasin": [ - -0.75, - 1.25, - 180, - 30 - ], - "CounterTop|+00.73|+00.70|+01.96": [ - 0.0, - 2.0, - 90, - 30 - ], - "CounterTop|-00.30|+00.16|+00.53": [ - -0.25, - 1.5, - 180, - 30 - ], - "Drawer|+00.41|+00.32|+01.49": [ - -1.0, - 2.0, - 90, - 0 - ], - "Drawer|+00.41|+00.32|+02.42": [ - -1.0, - 2.0, - 90, - 0 - ], - "Drawer|+00.41|+00.55|+01.49": [ - -0.75, - 1.75, - 90, - 0 - ], - "Drawer|+00.41|+00.55|+02.42": [ - -0.75, - 1.75, - 90, - 0 - ], - "GarbageCan|+00.71|-00.03|+03.11": [ - 0.5, - 3.5, - 180, - 30 - ], - "Sink|+00.81|+00.70|+01.92|SinkBasin": [ - 0.0, - 2.5, - 180, - 30 - ], - "Toilet|-02.23|+00.00|+01.63": [ - -2.0, - 2.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan412-layout.npy b/gen/layouts/FloorPlan412-layout.npy deleted file mode 100644 index 1d3c8327df573213544b1cf76075351bfd9cf1d7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 784 zcmbV{Ar8Vo5JeY48q!m&TS#gk2tr8ea1aavMH*UyAe6KOLpTKoqDSZvDv<~T0zqNt znU##0zCW|CyVu!bI$t)_Nu5oc9)PCeUV+X2&eruhJ||zWF5D3A+vt$g z+!^!&-R}naqW>*l{mLtBf8A_vIsBBI`NLsP_Sxe+>~{9?un#xI2P=o)@_**;z3|_i z_rUmJ{4jnPU*-5W!-VAJ8ypPU(}CX zv%TLv)X&Y{)yD6`a^|3w<>Ecc5+pER{{j8t$ zvwlwXf%Wfa{j8t$vwqgkefl5Rcgns)w&x(*!}hQ}Y!BPR_OLx{58E@z_OLx{58K1` Vusv)K+r#!uvpsAN+r#!us~?!{m^1(Y diff --git a/gen/layouts/FloorPlan413-objects.json b/gen/layouts/FloorPlan413-objects.json deleted file mode 100644 index 0e607a3e9..000000000 --- a/gen/layouts/FloorPlan413-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "Dresser", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan413-openable.json b/gen/layouts/FloorPlan413-openable.json deleted file mode 100644 index 528e315b4..000000000 --- a/gen/layouts/FloorPlan413-openable.json +++ /dev/null @@ -1,92 +0,0 @@ -{ - "Bathtub|-01.41|00.00|+00.56|BathtubBasin": [ - -0.75, - 1.0, - 270, - 30 - ], - "Cabinet|-01.61|+00.31|+02.49": [ - -0.75, - 3.25, - 180, - 30 - ], - "Cabinet|-01.61|+00.31|+03.11": [ - -0.75, - 2.5, - 0, - 30 - ], - "Cabinet|-01.61|+00.31|+03.14": [ - -0.75, - 2.75, - 0, - 30 - ], - "Cabinet|-01.61|+00.31|+03.75": [ - -0.75, - 3.0, - 0, - 30 - ], - "CounterTop|-01.80|+00.75|+03.12": [ - -1.25, - 3.0, - 270, - 30 - ], - "Drawer|+00.20|+00.16|+03.81": [ - -0.5, - 3.25, - 90, - 30 - ], - "Drawer|+00.20|+00.42|+03.81": [ - 0.75, - 3.25, - 0, - 30 - ], - "Drawer|+00.20|+00.68|+03.81": [ - -0.5, - 3.5, - 90, - 30 - ], - "Drawer|+00.20|+00.94|+03.81": [ - -0.5, - 3.5, - 90, - 30 - ], - "Dresser|+00.21|+00.00|+03.83": [ - 0.25, - 3.25, - 0, - 0 - ], - "GarbageCan|+00.93|-00.03|+03.76": [ - 0.25, - 3.25, - 0, - 30 - ], - "Sink|-01.83|+00.69|+02.78|SinkBasin": [ - -1.25, - 3.25, - 180, - 30 - ], - "Sink|-01.83|+00.69|+03.47|SinkBasin": [ - -1.25, - 3.0, - 0, - 30 - ], - "Toilet|-01.57|00.00|+01.82": [ - -1.25, - 2.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan414-layout.npy b/gen/layouts/FloorPlan414-layout.npy deleted file mode 100644 index aa82fa1bb4208248476699ac51afd89bd2596dc5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 800 zcmbWxu?oU46oug^BE_f37KKj5K}4{Vo8sc&B*jJ?#7ZhI;#2rQ^>I3O=+L2qwducP zG)wp{Ip^lR*{!$xo_L6-igkK4YA)5{G*iA*r^MV%bUh>{*1!2Gx}>_9r|0OV8;_@f zFN29MU-I8G678uod*@4gSB^`^g=6xClgH$-_}D#V_ntgvKPHcPUpf0Q?=kyoXCG!C zCXdOB(EgkKm^>zr$@iT+CXdPEA`|Vw^bJBg=RcS}OdqBXlOJ|{49l1VyavA~qIQvLqWUf{|UZ33&=1D0!Te78Vv3#$><3 zTRP3*znuH;?7ZLJkM150(py@TNz;wna+S;V^s-dBOy})uTR%U}+ez~~zo}QO z^-Htmlk=^W1wZD; z{Foo}WB$Q9?T+`s{Foo}WBtS4r;qiqzI*6neXQ@E`dA<9OMR@5y$_c5V%j&ikL|}E Qj%nZAf0*-O-`T8w0KJ8raR2}S diff --git a/gen/layouts/FloorPlan415-objects.json b/gen/layouts/FloorPlan415-objects.json deleted file mode 100644 index 1e083ec30..000000000 --- a/gen/layouts/FloorPlan415-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "Shelf", - "Dresser", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan415-openable.json b/gen/layouts/FloorPlan415-openable.json deleted file mode 100644 index 78d0f5817..000000000 --- a/gen/layouts/FloorPlan415-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "Bathtub|-02.10|+00.53|-00.83|BathtubBasin": [ - -1.75, - -0.75, - 270, - 30 - ], - "CounterTop|-02.71|+01.03|-02.92": [ - -1.75, - -3.0, - 270, - 0 - ], - "Drawer|-00.23|+00.16|-03.40": [ - -1.25, - -2.75, - 180, - 30 - ], - "Drawer|-00.23|+00.42|-03.40": [ - -0.75, - -3.0, - 90, - 30 - ], - "Drawer|-00.23|+00.68|-03.40": [ - -0.75, - -3.0, - 90, - 30 - ], - "Drawer|-00.23|+00.94|-03.40": [ - -0.75, - -3.0, - 180, - 30 - ], - "Dresser|-00.20|+00.00|-03.40": [ - -0.75, - -3.25, - 90, - 0 - ], - "GarbageCan|-00.27|-00.03|-02.75": [ - -1.0, - -3.25, - 0, - 30 - ], - "Shelf|-02.58|+00.40|-02.92": [ - -1.25, - -2.75, - 270, - 0 - ], - "Sink|-00.31|+00.00|-02.08|SinkBasin": [ - -0.75, - -1.5, - 90, - 30 - ], - "Toilet|-00.41|00.00|-00.55": [ - -0.75, - -1.0, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan416-layout.npy b/gen/layouts/FloorPlan416-layout.npy deleted file mode 100644 index 97b05a34c900c4c1a2fa707d19b7fd11afd6c743..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 992 zcmbWzF-pWx6a~<)h)7nEE()ncK}2vWJH^JrN`jMN3UMS68*vpb$Sq_EQ(8_jg@uKq z`KNiMzX>OK_r4_WS2vf}w_E8Yy;jq+{@x9>To* zSMHN%d6wt#D^p^9-=UB7u|C$v`qE^4;{8}3>tp%tkY{<8XZf9wXL*+Aln?9M4SlSS n^|3x4@_%Oid!e88vwqgk`gxi6v3*6@$M&&(Y#-al_7#&KZ*++( diff --git a/gen/layouts/FloorPlan416-objects.json b/gen/layouts/FloorPlan416-objects.json deleted file mode 100644 index c8adda2c6..000000000 --- a/gen/layouts/FloorPlan416-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan416-openable.json b/gen/layouts/FloorPlan416-openable.json deleted file mode 100644 index afd6d54d0..000000000 --- a/gen/layouts/FloorPlan416-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "CounterTop|-01.61|+00.70|+02.83": [ - -1.0, - 2.25, - 270, - 30 - ], - "Drawer|-01.34|+00.30|+02.13": [ - -0.75, - 1.75, - 270, - 30 - ], - "Drawer|-01.34|+00.30|+03.33": [ - -0.75, - 3.0, - 270, - 30 - ], - "GarbageCan|-01.74|-00.03|+01.27": [ - -1.0, - 1.75, - 180, - 30 - ], - "Sink|-01.70|+00.62|+02.28|SinkBasin": [ - -1.0, - 2.75, - 180, - 30 - ], - "Sink|-01.70|+00.62|+03.37|SinkBasin": [ - -1.0, - 3.0, - 0, - 30 - ], - "Toilet|-01.55|+00.00|+00.69": [ - -1.25, - 1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan417-layout.npy b/gen/layouts/FloorPlan417-layout.npy deleted file mode 100644 index 0e72aa5468376744d0ad51f9911a9e4a1cf2be8d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1088 zcmbWxu};EJ6oBDE3U>X;-y&US=~M~`6}h{e3Z+S=gVf*REzs%Gpm31*VR*7@AvIv z^<3|LdU;-^i?cFq(tn>}@%OyH9_HZfF!`kONB6!T-m_VB@8kUL&fD*Tzk)x5^_};B ztRFiZr@p;D>$5)Vv%Y)%7yFLm)VJ4Xeb#4v_vo`eJI8VA+v~GF>pQ2<`mE3H;W+i} g^;zF{`mE3Ttk3S{IQ8xI?e$ro^;w_wS%;7F2ek>!DF6Tf diff --git a/gen/layouts/FloorPlan417-objects.json b/gen/layouts/FloorPlan417-objects.json deleted file mode 100644 index 6c7ccae54..000000000 --- a/gen/layouts/FloorPlan417-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan417-openable.json b/gen/layouts/FloorPlan417-openable.json deleted file mode 100644 index 111a6080f..000000000 --- a/gen/layouts/FloorPlan417-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Cabinet|-02.50|+00.40|-01.24": [ - -1.75, - -1.5, - 0, - 30 - ], - "Cabinet|-02.50|+00.40|-02.21": [ - -2.0, - -1.5, - 270, - 30 - ], - "Cabinet|-02.51|+00.43|-00.29": [ - -1.75, - -1.0, - 0, - 30 - ], - "Cabinet|-02.51|+00.43|-01.26": [ - -1.75, - -2.0, - 0, - 30 - ], - "CounterTop|-02.75|+00.99|-01.24": [ - -2.25, - -1.5, - 270, - 30 - ], - "Sink|-02.91|+00.99|-00.73|SinkBasin": [ - -2.25, - -1.0, - 0, - 30 - ], - "Sink|-02.91|+00.99|-01.76|SinkBasin": [ - -2.25, - -1.5, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan418-layout.npy b/gen/layouts/FloorPlan418-layout.npy deleted file mode 100644 index 3e47df778f8071a73ded546848c342dde1b5a976..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 864 zcmbW#u}Z^07{KvZq)6#Q+;$Z*l_FA{-4quGCkZyCgV>T37x5{4p!z5s9UUAT9IQ0I z!EbDq<9B!ej}Y>9eS39tcT_wVFL_qC4^5t?d@(=IWy)V`(-n$|MoAd$F|<> zw~K03?>w5Em1%rhrq^`nGbr}Y`+gaA>(A!Dzk|PmKZA>I&LGTV^VmGrpM;+EtY>{c z^sHw+>yJavdUn4T?z3~N@5|=c*RgvXSH1Vrv!3;=_Z{@CXFcov2YS}Cp7kHyf23zU M>)H9X>z!{mzctp3NB{r; diff --git a/gen/layouts/FloorPlan418-objects.json b/gen/layouts/FloorPlan418-objects.json deleted file mode 100644 index 6c7ccae54..000000000 --- a/gen/layouts/FloorPlan418-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan418-openable.json b/gen/layouts/FloorPlan418-openable.json deleted file mode 100644 index fb4ef1367..000000000 --- a/gen/layouts/FloorPlan418-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Cabinet|-02.29|+00.32|-03.25": [ - -1.5, - -3.5, - 0, - 30 - ], - "Cabinet|-02.29|+00.32|-03.81": [ - -1.5, - -3.0, - 180, - 30 - ], - "Cabinet|-02.30|+00.35|-02.25": [ - -1.5, - -3.0, - 0, - 30 - ], - "CounterTop|-02.63|+00.84|-03.04": [ - -2.0, - -3.0, - 270, - 30 - ], - "GarbageCan|-00.46|-00.04|-03.77": [ - -1.25, - -3.25, - 180, - 30 - ], - "Sink|-02.66|+00.79|-03.07|SinkBasin": [ - -2.0, - -3.5, - 0, - 30 - ], - "Toilet|-00.45|+00.00|-03.05": [ - -1.0, - -3.5, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan419-layout.npy b/gen/layouts/FloorPlan419-layout.npy deleted file mode 100644 index 191b53f1cfb6d90ecc8734f97572f8c9fded07b3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 608 zcmbV`p$@_@6h#Y?uc#{|6$A_+XdDECK#_)ZK@hgIWM<(j_#pTcBocu@AQ)^XBu`Rv zbMEUq?POQRUvYQXw|daC z`l$as9rZoWbDix=oe#mxm6*fKU(Fu-FmsYQ%stt|GVkJ@n_zt0;~f|uEE69+K6-pG YKA1gN=C%1RJ$`!pFn$<6j0gVZ8}dbb$N&HU diff --git a/gen/layouts/FloorPlan419-objects.json b/gen/layouts/FloorPlan419-objects.json deleted file mode 100644 index 0a56e852a..000000000 --- a/gen/layouts/FloorPlan419-objects.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "ShowerHead", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan419-openable.json b/gen/layouts/FloorPlan419-openable.json deleted file mode 100644 index 46cace91d..000000000 --- a/gen/layouts/FloorPlan419-openable.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "Bathtub|-00.98|-00.72|-02.93|BathtubBasin": [ - -1.25, - -2.25, - 180, - 30 - ], - "Drawer|-02.11|+00.16|-01.31": [ - -1.5, - -0.75, - 180, - 30 - ], - "Drawer|-02.11|+00.46|-01.31": [ - -1.75, - -0.75, - 180, - 30 - ], - "GarbageCan|-00.24|-00.03|-01.36": [ - -0.75, - -1.25, - 90, - 30 - ], - "SideTable|-02.18|00.00|-01.31": [ - -1.75, - -1.0, - 270, - 30 - ], - "Sink|-02.10|00.00|-02.03|SinkBasin": [ - -1.5, - -1.75, - 180, - 30 - ], - "Toilet|-00.47|+00.00|-01.88": [ - -0.75, - -1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan420-layout.npy b/gen/layouts/FloorPlan420-layout.npy deleted file mode 100644 index 3d239dd2e8222e42f8e0272eedc659e483177ba4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 560 zcmbV{p$Y;)6h+7CSG+a~leQ>gwkcZ-CK=pW4C2a+SY*G#5As)xMuWj%aMe8sFFNIN zF7FnLS_~`M$_+Wf`2kXQ~j}OMH?_izm=`ZbnVZ8bd*2$ip LJw0BSJNTC`QxbM; diff --git a/gen/layouts/FloorPlan420-objects.json b/gen/layouts/FloorPlan420-objects.json deleted file mode 100644 index 9c3deeaff..000000000 --- a/gen/layouts/FloorPlan420-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "HousePlant", - "SoapBar", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan420-openable.json b/gen/layouts/FloorPlan420-openable.json deleted file mode 100644 index c23df54f5..000000000 --- a/gen/layouts/FloorPlan420-openable.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "Bathtub|-01.28|+00.28|-02.53|SinkBasin": [ - -1.25, - -1.75, - 180, - 30 - ], - "Drawer|-00.22|+00.78|-01.47": [ - -1.25, - -1.5, - 90, - 0 - ], - "SideTable|-00.15|+00.00|-01.47": [ - -0.5, - -1.0, - 90, - 30 - ], - "Sink|-02.27|+00.00|-01.52|SinkBasin": [ - -1.75, - -1.25, - 180, - 30 - ], - "Toilet|-02.05|+00.00|-00.36": [ - -1.5, - -1.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan421-layout.npy b/gen/layouts/FloorPlan421-layout.npy deleted file mode 100644 index bed785d7e97473038a76e7b8d4ebb2ca0e9451bf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 608 zcmbW!F%AJi6oBC&BC^>-OgAJ`2#tuuRyv|lsAOYjqYx`Iq7kQXAXic-6bg&|3$OH= zm;YtHYA&q9i zb|GJT&po_0yY+TI5O?uViO!Ek&81qTGZjdcX69z%%ONv~{@t(QbFSO_{1jhx>v0$c zaykj*Q~rBKqC5Vl{}#*sJ9O+h7LJ>DpCey8_U(M>?8ofK?8ofK?8lYu!}L{7AEpn} shv~!gVft`s`*Gozd~N@SJSLCHW9A#1XC5<;nHQ1h4)d6I&w2NvFV&=L)c^nh diff --git a/gen/layouts/FloorPlan422-objects.json b/gen/layouts/FloorPlan422-objects.json deleted file mode 100644 index eed1f5ea6..000000000 --- a/gen/layouts/FloorPlan422-objects.json +++ /dev/null @@ -1,33 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "Shelf", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan422-openable.json b/gen/layouts/FloorPlan422-openable.json deleted file mode 100644 index 3da31098e..000000000 --- a/gen/layouts/FloorPlan422-openable.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "Bathtub|-03.45|+00.18|+01.03|BathtubBasin": [ - -2.75, - 1.25, - 270, - 30 - ], - "Cabinet|-00.61|+00.46|+00.52": [ - -1.25, - 1.25, - 90, - 30 - ], - "Cabinet|-00.61|+01.99|+00.52": [ - -1.25, - 1.0, - 180, - -30 - ], - "Cabinet|-01.89|+00.44|+01.98": [ - -1.25, - 1.75, - 0, - 30 - ], - "Cabinet|-01.89|+01.88|+02.39": [ - -1.25, - 2.25, - 270, - 0 - ], - "Cabinet|-02.34|+00.46|+00.52": [ - -1.75, - 1.0, - 180, - 30 - ], - "CounterTop|-00.81|+00.09|+00.29": [ - -1.25, - 1.0, - 180, - 0 - ], - "CounterTop|-01.92|+00.00|+00.29": [ - -2.0, - 0.75, - 180, - 30 - ], - "Drawer|-00.81|+00.96|+00.38": [ - -1.5, - 1.0, - 90, - 0 - ], - "Drawer|-02.03|+00.94|+02.19": [ - -1.5, - 1.5, - 0, - 0 - ], - "Shelf|-02.03|+01.18|+02.19": [ - -1.25, - 1.75, - 270, - 0 - ], - "Shelf|-02.12|+01.39|+02.19": [ - -1.25, - 2.25, - 270, - -30 - ], - "Sink|-01.93|+00.77|+00.33|SinkBasin": [ - -2.5, - 0.75, - 90, - 30 - ], - "Toilet|-00.46|00.00|+02.26": [ - -1.0, - 2.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan423-layout.npy b/gen/layouts/FloorPlan423-layout.npy deleted file mode 100644 index d85f2115b41423b356fe2292116cfad34b885d51..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1008 zcmbWyu}Z^G0EW?P2|;{{Y*EN06hs6wxhXCVP7-WN2eFcfi}(~ika--(4jnRNur~J$ zW;Dy?B+d7ypEq~cxAzC(ExhN8x_xZ&^DMtup5;ZBFW1d$Q$0Vdn??P5|EhXw>)ri! zRlU?ZAJ6ASc6w4|AK8Deqp-h{Zalv)$8$Dun0Wa5`+M(iChxQN+56nb9v{ZNZS18J z+wTkEq?%>>WG^F diff --git a/gen/layouts/FloorPlan423-objects.json b/gen/layouts/FloorPlan423-objects.json deleted file mode 100644 index 3045886b8..000000000 --- a/gen/layouts/FloorPlan423-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan423-openable.json b/gen/layouts/FloorPlan423-openable.json deleted file mode 100644 index 21ea750b4..000000000 --- a/gen/layouts/FloorPlan423-openable.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "Bathtub|-03.59|+00.11|+01.52|BathtubBasin": [ - -3.0, - 1.25, - 270, - 30 - ], - "CounterTop|-00.28|+00.79|+01.93": [ - -1.0, - 2.25, - 90, - 30 - ], - "CounterTop|-02.54|+00.81|+00.28": [ - -1.75, - 0.75, - 270, - 30 - ], - "Drawer|-00.33|+00.32|+01.72": [ - -1.5, - 2.25, - 180, - 30 - ], - "Drawer|-00.33|+00.32|+02.16": [ - -1.5, - 2.75, - 180, - 30 - ], - "Drawer|-00.33|+00.32|+02.59": [ - -1.5, - 2.0, - 0, - 30 - ], - "Drawer|-00.33|+00.32|+03.03": [ - -1.5, - 2.5, - 0, - 30 - ], - "Drawer|-00.33|+00.62|+02.59": [ - -1.25, - 2.0, - 0, - 30 - ], - "Drawer|-00.33|+00.62|+03.03": [ - -1.25, - 2.5, - 0, - 30 - ], - "Drawer|-02.25|+00.32|+00.28": [ - -1.5, - 1.5, - 270, - 30 - ], - "Drawer|-02.84|+00.32|+00.28": [ - -2.25, - 1.5, - 270, - 30 - ], - "GarbageCan|-01.75|+00.00|+00.23": [ - -2.0, - 0.75, - 180, - 30 - ], - "Sink|-00.26|+00.66|+01.92|SinkBasin": [ - -1.0, - 2.5, - 180, - 30 - ], - "Toilet|-02.84|+00.00|+02.76": [ - -2.25, - 2.5, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan424-layout.npy b/gen/layouts/FloorPlan424-layout.npy deleted file mode 100644 index 75490b8ceb8bb454345ff51e5d26c3a52caeaa75..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 736 zcmbWyF$%&k6oBCOA*0NZijFg;8U(`zNF8vcXnVS1Pz rrq>odOb^q;^f0}S=wW)89;S!s1)_)PVS1PzrWcAHribZadSUVgAzEoo diff --git a/gen/layouts/FloorPlan424-objects.json b/gen/layouts/FloorPlan424-objects.json deleted file mode 100644 index f3988fd79..000000000 --- a/gen/layouts/FloorPlan424-objects.json +++ /dev/null @@ -1,28 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Cabinet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "LightSwitch" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan424-openable.json b/gen/layouts/FloorPlan424-openable.json deleted file mode 100644 index 645647bca..000000000 --- a/gen/layouts/FloorPlan424-openable.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "Cabinet|-00.49|+00.41|+02.06": [ - -1.25, - 1.75, - 0, - 30 - ], - "Cabinet|-00.49|+00.41|+02.86": [ - -1.25, - 2.5, - 0, - 30 - ], - "Cabinet|-00.50|+00.38|+02.84": [ - -1.25, - 2.25, - 0, - 30 - ], - "Cabinet|-00.50|+00.38|+03.65": [ - -1.25, - 3.0, - 0, - 30 - ], - "CounterTop|-00.26|+00.93|+02.84": [ - -0.75, - 2.5, - 90, - 30 - ], - "GarbageCan|-02.16|00.00|+03.76": [ - -1.75, - 3.25, - 0, - 30 - ], - "Sink|-00.30|+00.80|+02.42|SinkBasin": [ - -0.75, - 2.0, - 0, - 30 - ], - "Sink|-00.30|+00.80|+03.26|SinkBasin": [ - -0.75, - 3.0, - 90, - 30 - ], - "Toilet|-00.54|+00.00|+01.49": [ - -1.0, - 2.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan425-layout.npy b/gen/layouts/FloorPlan425-layout.npy deleted file mode 100644 index a966f44e54c18b5049044de741c61d322c271a71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 512 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+i=qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I$7COQg6nmP)#3giMV1~B-rA431JhtMz3_z%$dF!c-$sOn*Sn0go=W*!q% zJxm_PzW_BK#)qkAK~oRo!_>q0F!gL`>S27CdKe$3o&!xij1N-}8F21LSSBNl^68f{|`q!o*J3J=7ibnMu{(81tO&v$S} zcacwf&+m8YI$KQV%bGcvvkRkiow$K@!?@>s>*9TKOoH8NpM=rp`6Sq;(ffJ22@cWQ zt#049owjc;_TSSq-_y8PzuD;5xwtOxu_rFneawAq)cxnpd=KwS<%e>ioGWL_p7cFN zRS(~X*$=ZHWADm08vMfQ~&?~ diff --git a/gen/layouts/FloorPlan426-objects.json b/gen/layouts/FloorPlan426-objects.json deleted file mode 100644 index f904e7328..000000000 --- a/gen/layouts/FloorPlan426-objects.json +++ /dev/null @@ -1,31 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan426-openable.json b/gen/layouts/FloorPlan426-openable.json deleted file mode 100644 index c1f4edd71..000000000 --- a/gen/layouts/FloorPlan426-openable.json +++ /dev/null @@ -1,68 +0,0 @@ -{ - "Bathtub|-03.50|+00.15|+00.94|BathtubBasin": [ - -2.75, - 1.25, - 270, - 30 - ], - "CounterTop|-01.85|+00.00|+00.34": [ - -1.0, - 1.0, - 180, - 30 - ], - "Drawer|-00.29|+00.31|+00.31": [ - -1.0, - 1.5, - 90, - 30 - ], - "Drawer|-00.29|+00.61|+00.31": [ - -0.75, - 1.25, - 90, - 30 - ], - "Drawer|-00.81|+00.31|+00.31": [ - -1.5, - 1.5, - 90, - 30 - ], - "Drawer|-00.81|+00.61|+00.31": [ - -1.25, - 1.25, - 90, - 30 - ], - "Drawer|-01.32|+00.61|+00.31": [ - -0.75, - 1.25, - 270, - 30 - ], - "Drawer|-01.84|+00.31|+00.31": [ - -1.25, - 1.5, - 270, - 30 - ], - "Drawer|-01.84|+00.61|+00.31": [ - -1.25, - 1.25, - 270, - 30 - ], - "Sink|-00.46|-00.01|+03.05|SinkBasin": [ - -0.75, - 2.5, - 0, - 30 - ], - "Toilet|-01.84|+00.00|+02.50": [ - -1.25, - 1.75, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan427-layout.npy b/gen/layouts/FloorPlan427-layout.npy deleted file mode 100644 index 78286bb77b667bbcec62afd1092b54c87bccbc53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 992 zcmbW!F-pWh6oBCvd?>#gFscu9+{O{T={?_bcy1VWKZwD8_#-i| zu^tb($9=H=SLm}o>$5)Vvp(yy{&(oJKI^kS>$5)Vvwk1?tk3$a&-y&%@6Gz`e-F8@ f$9k;CdaTEN?z7%H^jMG0XY<*7Hh;|XJs;;kiPn^8 diff --git a/gen/layouts/FloorPlan427-objects.json b/gen/layouts/FloorPlan427-objects.json deleted file mode 100644 index 44d2e8f28..000000000 --- a/gen/layouts/FloorPlan427-objects.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - "PaperTowelRoll", - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan427-openable.json b/gen/layouts/FloorPlan427-openable.json deleted file mode 100644 index 5cbe082d7..000000000 --- a/gen/layouts/FloorPlan427-openable.json +++ /dev/null @@ -1,80 +0,0 @@ -{ - "Bathtub|-03.71|+00.34|+00.64|BathtubBasin": [ - -2.75, - 1.0, - 270, - 30 - ], - "CounterTop|-02.80|+00.00|-00.59": [ - -2.0, - 0.0, - 180, - 30 - ], - "Drawer|-01.44|+00.27|-00.62": [ - -2.0, - 0.5, - 90, - 30 - ], - "Drawer|-01.44|+00.53|-00.62": [ - -1.0, - 0.25, - 270, - 30 - ], - "Drawer|-01.89|+00.27|-00.62": [ - -2.5, - 0.5, - 90, - 30 - ], - "Drawer|-01.89|+00.53|-00.62": [ - -2.5, - 0.75, - 180, - 0 - ], - "Drawer|-02.34|+00.27|-00.62": [ - -1.75, - 0.5, - 270, - 30 - ], - "Drawer|-02.34|+00.53|-00.62": [ - -2.75, - 1.0, - 180, - 0 - ], - "Drawer|-02.79|+00.27|-00.62": [ - -2.25, - 0.5, - 270, - 30 - ], - "Drawer|-02.79|+00.53|-00.62": [ - -2.25, - 0.25, - 270, - 30 - ], - "GarbageCan|-01.56|00.00|+01.91": [ - -1.0, - 1.75, - 270, - 30 - ], - "Sink|-01.92|+00.44|+02.03|SinkBasin": [ - -2.25, - 1.5, - 0, - 30 - ], - "Toilet|-00.72|+00.00|-00.31": [ - -1.25, - 0.0, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan428-layout.npy b/gen/layouts/FloorPlan428-layout.npy deleted file mode 100644 index 0c26e75d4946aea3c1fb14ac01ba8043cc639973..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 992 zcmbWyu}Z^07{KvUM5Oc~ZaalcVnIY`CO5^!!AXKmaS$tsxQI{T1NjPlgpM5@938A) zeuFo9OZZ*#ef;xwadm!qy%nCrOPaO)ZI@1BI-MVyYc?ysEUUNReX*AJ)`h@*6;cGHO+b$;(Lwx8{1`*}IdH@qsmF05y-=wUsqhxM=?*28*O m59=8fJ*Y^LY5SY58prB*dQ{c1n$Eh1uDQRSb(8jc|FpU5 z+x32b+sxawcMlKhxW8A&=lI`e6n>u9MOsJ8w7zBUWUmT4@4fTe#d&s~huq_kA0AH9 z2J3Gv)4q9FpY=I?Dg@SN{mr7!`mE3Ttk3$P=(9fSvp(yy{%5{d_rvW5F9R9E-T(jq diff --git a/gen/layouts/FloorPlan429-objects.json b/gen/layouts/FloorPlan429-objects.json deleted file mode 100644 index 07f7757be..000000000 --- a/gen/layouts/FloorPlan429-objects.json +++ /dev/null @@ -1,29 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "ShowerCurtain", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "BathtubBasin", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "SoapBar", - "HandTowel", - "TissueBox", - "LightSwitch", - "Bathtub" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan429-openable.json b/gen/layouts/FloorPlan429-openable.json deleted file mode 100644 index 850de0b4b..000000000 --- a/gen/layouts/FloorPlan429-openable.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "Bathtub|-02.12|-00.09|-03.12|BathtubBasin": [ - -1.0, - -2.75, - 270, - 30 - ], - "GarbageCan|-00.53|-00.05|-03.76": [ - -1.0, - -3.0, - 90, - 30 - ], - "SideTable|+00.78|+00.00|-00.67": [ - 0.25, - -1.25, - 90, - 30 - ], - "SideTable|+00.79|+00.00|-01.82": [ - 0.25, - -2.25, - 90, - 30 - ], - "SideTable|-01.53|+00.00|-00.17": [ - -1.0, - -0.75, - 0, - 30 - ], - "Toilet|+00.00|00.00|-03.44": [ - -0.5, - -3.25, - 90, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan430-layout.npy b/gen/layouts/FloorPlan430-layout.npy deleted file mode 100644 index 720285dc4d0a54d810408c8459f90780d16de92f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1760 zcmbW#p-#h46oBDEP&`FlA(?2RgN2>#x}RJm z>-Cmi*2``5vR>B9x;U@;no*oAwkzvnecbu};(dM2^|3zI$NF}To@LyxhxKq5J*tQ{thxM@kQx`q{@9g(uecZ+G t$8EAc=lZxw&+BupZ=L#BAM0a%+{QfC$NJd(KF#Mo?ql=Wd^W!y{Qy7=9rXYJ diff --git a/gen/layouts/FloorPlan430-objects.json b/gen/layouts/FloorPlan430-objects.json deleted file mode 100644 index 4ad43db6d..000000000 --- a/gen/layouts/FloorPlan430-objects.json +++ /dev/null @@ -1,35 +0,0 @@ -[ - "Faucet", - "Candle", - "Towel", - "HandTowelHolder", - "SideTable", - "Window", - "GarbageCan", - "Cloth", - "Plunger", - "ToiletPaperHanger", - "ScrubBrush", - "TowelHolder", - "SinkBasin", - "SoapBottle", - "Toilet", - "Footstool", - "Drawer", - "ToiletPaper", - "SprayBottle", - "Mirror", - "Sink", - "Floor", - "ShowerGlass", - "ShowerDoor", - "SoapBar", - "CounterTop", - "ShowerHead", - "HandTowel", - "TissueBox", - "Shelf", - "LightSwitch", - "Bathtub", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan430-openable.json b/gen/layouts/FloorPlan430-openable.json deleted file mode 100644 index ebaf98b49..000000000 --- a/gen/layouts/FloorPlan430-openable.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "CounterTop|+00.20|+00.43|-02.01": [ - 0.0, - -1.25, - 180, - 30 - ], - "Drawer|+00.30|+00.30|-01.82": [ - -0.25, - -0.75, - 90, - 30 - ], - "Drawer|+00.30|+00.49|-01.82": [ - -0.25, - -1.0, - 90, - 30 - ], - "Drawer|+00.30|+00.68|-01.82": [ - -0.25, - -1.0, - 90, - 30 - ], - "Drawer|+00.30|+00.83|-01.82": [ - -0.25, - -0.75, - 180, - 0 - ], - "SideTable|-02.85|+00.01|+01.51": [ - -2.25, - 1.5, - 270, - 30 - ], - "Sink|-02.80|+00.33|+00.76|SinkBasin": [ - -2.25, - 1.25, - 180, - 30 - ], - "Toilet|-00.06|+00.01|+01.84": [ - -0.75, - 1.25, - 0, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan5-layout.npy b/gen/layouts/FloorPlan5-layout.npy deleted file mode 100644 index 86f544e919f217f153d279dff30bf3b77c6ed5c8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1680 zcmbW%Jx;?w5QgCeAqr06&LFv>;YUcJq65)TP@#x8qCf;Whz4;A4wNhS2q{y#NRfhq z5bqO-DRDD;cPI1CXC?W%xx2o--%0Q3qa4-K$EG|l%8T)7Srz4Y(!4dpmxoC+s(;U~ zhR@S_eLj5}zSe6#JUgk1vwR8@RtsX?s8T+dmJy2;2qc>t_8N zKFo*P{CUiW`7j^mTLd5G!+e+z^I<;Br?%OP`7j^m!+e+zt30vtZO`-j#C(_!^I`qw z>c{%AemV7H{dj4=T=koyAM3}f{5h&~J@_TA?#qweKFb|GZKIigb`LKLgJ}e*Z oay}lvYb-BrL%;mn`n+a diff --git a/gen/layouts/FloorPlan5-objects.json b/gen/layouts/FloorPlan5-objects.json deleted file mode 100644 index 67be1200d..000000000 --- a/gen/layouts/FloorPlan5-objects.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - "PaperTowelRoll", - "StoveBurner", - "Faucet", - "Stool", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Statue", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Bowl", - "GarbageCan", - "Knife", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Ladle", - "Bread", - "Sink", - "Floor", - "HousePlant", - "Potato", - "Vase", - "Mug", - "CounterTop", - "ShelvingUnit", - "Spatula", - "Shelf", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan5-openable.json b/gen/layouts/FloorPlan5-openable.json deleted file mode 100644 index c4b6ea81e..000000000 --- a/gen/layouts/FloorPlan5-openable.json +++ /dev/null @@ -1,152 +0,0 @@ -{ - "Cabinet|+00.20|+02.02|-02.00": [ - 0.75, - -1.25, - 180, - 0 - ], - "Cabinet|+01.18|+02.02|-02.00": [ - 0.75, - -1.25, - 180, - 0 - ], - "Cabinet|+01.39|+00.47|-01.06": [ - 0.75, - -1.25, - 90, - 30 - ], - "Cabinet|+01.74|+02.02|-02.00": [ - 1.0, - -1.25, - 180, - 0 - ], - "Cabinet|+01.75|+02.02|-01.03": [ - 1.0, - -1.25, - 90, - 0 - ], - "Cabinet|-00.42|+00.37|-00.01": [ - 0.5, - -0.75, - 270, - 30 - ], - "Cabinet|-00.45|+00.47|-00.01": [ - 0.0, - -1.0, - 270, - 30 - ], - "Cabinet|-00.82|+00.47|-01.69": [ - 0.0, - -0.75, - 270, - 30 - ], - "Cabinet|-00.84|+00.47|-00.05": [ - -0.25, - -0.75, - 0, - 30 - ], - "Cabinet|-00.84|+00.47|-01.67": [ - 0.0, - -1.0, - 180, - 30 - ], - "Cabinet|-01.15|+02.02|+00.38": [ - -0.5, - -0.25, - 270, - 0 - ], - "Cabinet|-01.15|+02.02|-00.77": [ - -0.5, - -0.5, - 270, - 0 - ], - "Cabinet|-01.15|+02.02|-01.98": [ - -0.5, - -1.25, - 270, - 0 - ], - "CounterTop|+01.16|+00.95|-02.01": [ - 1.0, - -1.25, - 180, - 30 - ], - "CounterTop|-00.63|+01.17|+00.57": [ - 0.0, - 1.25, - 180, - 0 - ], - "CounterTop|-00.67|+00.95|+00.19": [ - -0.5, - -0.25, - 0, - 30 - ], - "Drawer|-00.07|+00.75|-00.01": [ - 0.5, - -1.0, - 0, - 0 - ], - "Drawer|-00.45|+00.75|-00.01": [ - -0.25, - -0.5, - 270, - 30 - ], - "Drawer|-00.82|+00.75|-01.69": [ - -0.5, - -0.75, - 180, - 0 - ], - "Fridge|+01.98|+00.00|-00.54": [ - 1.0, - -0.5, - 90, - 30 - ], - "GarbageCan|+01.92|-00.01|+00.14": [ - 1.25, - 0.25, - 90, - 30 - ], - "Microwave|+01.83|+00.90|-01.35": [ - 1.0, - -1.0, - 90, - 0 - ], - "Shelf|+02.76|+00.55|+00.15": [ - 2.25, - 0.75, - 180, - 30 - ], - "Shelf|+02.76|+00.88|+00.14": [ - 2.25, - 1.0, - 180, - 0 - ], - "Sink|-00.12|+00.88|-02.01|SinkBasin": [ - -0.5, - -1.25, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan6-layout.npy b/gen/layouts/FloorPlan6-layout.npy deleted file mode 100644 index eb8f5923c6598a033abf4ed882d8bcd55e632ffa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2176 zcmbW$Ax;BP5C-4}L2-(83rP)C4I!Zl2f-jvq@isPgpw`65Kh5?xWXO*iCj@pQ2})4 zs~E|emv7iN|I7j(S2vf}w|nKayw%g$^1i80tNLs{ss~j)Uo*OrB@IJ~|nW2G#I*P`y|Gd=AU@`Tp$Bb(~+x>Z_>dvrBdTyr&3#ikAI_)# z>iTmV{kh++6mHM^3V$VkC!0^MJy;*kr}@;|n2*iJ=411*`M8UD*}QVi%jRYGIG^TK zH!qu)&CBLx^XY3oHXoah_2GP)Z+!{%f2vHA2dA9wNlWBarItUqt!zI*am9_z>Y zv3}mukM-j&z6ZOnulwviyU*^cyU*^kdz{Zz%%`ruy8gV1@5%OJd8{wzQ{Fn}kjL^^ z9?N5SERQ!a|0dC<*_`L$MRSn%iB+RERVaGhyDMv|9@`N z`z4;;&*QtYeb_#1AGQzM=U`m6kMGC!Vf(Os*gk9@?o&$PHuhoruzlD*Y@dVi54~bm AHUIzs diff --git a/gen/layouts/FloorPlan6-objects.json b/gen/layouts/FloorPlan6-objects.json deleted file mode 100644 index b584a4738..000000000 --- a/gen/layouts/FloorPlan6-objects.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - "PaperTowelRoll", - "StoveBurner", - "Stool", - "Faucet", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Pan", - "PepperShaker", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "Knife", - "GarbageCan", - "ButterKnife", - "SaltShaker", - "Pot", - "Fridge", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "Floor", - "Potato", - "Mug", - "CounterTop", - "Spatula", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan6-openable.json b/gen/layouts/FloorPlan6-openable.json deleted file mode 100644 index 8337ad36d..000000000 --- a/gen/layouts/FloorPlan6-openable.json +++ /dev/null @@ -1,164 +0,0 @@ -{ - "Cabinet|+00.15|+02.01|-01.60": [ - 0.75, - -1.0, - 180, - 0 - ], - "Cabinet|+01.57|+02.01|+00.47": [ - 0.75, - 0.25, - 90, - 0 - ], - "Cabinet|+01.57|+02.01|-00.78": [ - 0.75, - -1.0, - 90, - 0 - ], - "Cabinet|-02.15|+00.40|+00.64": [ - -1.5, - 0.0, - 0, - 30 - ], - "Cabinet|-02.15|+00.40|+00.70": [ - -1.25, - 1.5, - 180, - 30 - ], - "Cabinet|-02.15|+00.40|+01.58": [ - -1.25, - 0.75, - 0, - 30 - ], - "Cabinet|-02.15|+00.40|-00.24": [ - -1.5, - -0.5, - 0, - 30 - ], - "Cabinet|-02.29|+01.97|-01.33": [ - -1.5, - -1.25, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+00.36": [ - -1.5, - -0.25, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+00.41": [ - -1.75, - 1.0, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+01.64": [ - -1.75, - 1.0, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+01.69": [ - -1.75, - 2.25, - 270, - 0 - ], - "Cabinet|-02.45|+01.95|+02.93": [ - -1.75, - 2.25, - 270, - 0 - ], - "Cabinet|-02.45|+02.15|-00.29": [ - -1.5, - 0.0, - 270, - 0 - ], - "Cabinet|-02.45|+02.15|-01.28": [ - -1.25, - -0.75, - 270, - 0 - ], - "CounterTop|+00.47|+00.95|-01.63": [ - 0.75, - -1.0, - 180, - 30 - ], - "CounterTop|+01.59|+00.95|+00.41": [ - 1.0, - 0.75, - 90, - 30 - ], - "CounterTop|-00.36|+00.95|+01.09": [ - 0.5, - 1.25, - 270, - 30 - ], - "CounterTop|-01.49|+00.95|+01.32": [ - -1.75, - 0.5, - 270, - 30 - ], - "Drawer|-02.28|+00.79|+00.44": [ - -1.5, - 0.0, - 0, - 30 - ], - "Drawer|-02.28|+00.79|+00.90": [ - -1.5, - 0.5, - 0, - 30 - ], - "Drawer|-02.28|+00.79|+01.37": [ - -1.5, - 1.75, - 180, - 30 - ], - "Drawer|-02.28|+00.79|-00.03": [ - -1.5, - -0.5, - 0, - 30 - ], - "Fridge|-02.48|+00.00|-00.78": [ - -1.5, - -0.75, - 270, - 30 - ], - "GarbageCan|+01.65|00.00|+00.68": [ - 1.0, - 1.0, - 90, - 30 - ], - "Microwave|-02.58|+00.90|+02.44": [ - -1.75, - 2.5, - 270, - 0 - ], - "Sink|+01.38|+00.81|-01.27|SinkBasin": [ - 0.75, - -1.0, - 180, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan7-layout.npy b/gen/layouts/FloorPlan7-layout.npy deleted file mode 100644 index 17b04ef444e20b59a55d337e4b7bd3e6962f4de5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4352 zcmbW%F>Vt<6b9g7WvwF1hj3?*Ttx_>2#KxeKr|Fo$Rds?P=ahkgE$2T@*crQNSSgA z7cN{7^5$D9ugo@+Z)SF9-v11LKYV)s@$<9ttNdPEuD4$|i;MZ<&DHD0a=y5_+5FtB zuD{%DF4zC(->trH*Z1?=Z>t~cdp|#a^>R5sf3ckZnLqKFmWOB7$9UMqI88oFZj-$~ zr1#nT?0xqBU3#Cr&)(xa-q!D!-zS&)jO%Y>f^U=Wl859&vU=P@o~#~L50CfQ#l6fM z)x+xHeZ3E>ht^H+@W zH7j41FUyzZJGzg*)G1$EcE# zf0jSXpXJZ;AKl0I)ggbDKeuVW{H@EM<o(te-sV<9qI*f2@Dp zrv3V7UH@4B_*C;{{bT*(A???{alQ6~)x~*~uX*`$)0KyZ<;(JA`LcXjzRr~|%a_|e z&S&|ud|AGHs(JA-S-#fg#qP~{l$ZIYOZQEdm;Lf$d9l2lBQKT*%Y)^?^5A35gXO`_ cSJ$ME`q+8wJa!&CkDbTP^E>lB_Pt5>5B$3_i~s-t diff --git a/gen/layouts/FloorPlan7-objects.json b/gen/layouts/FloorPlan7-objects.json deleted file mode 100644 index 02e51c382..000000000 --- a/gen/layouts/FloorPlan7-objects.json +++ /dev/null @@ -1,50 +0,0 @@ -[ - "StoveBurner", - "Faucet", - "Stool", - "Egg", - "Plate", - "StoveKnob", - "Fork", - "Statue", - "PepperShaker", - "Pan", - "Apple", - "CoffeeMachine", - "Tomato", - "Window", - "Bowl", - "Knife", - "GarbageCan", - "Book", - "ButterKnife", - "Pot", - "SaltShaker", - "Fridge", - "WineBottle", - "Microwave", - "Lettuce", - "Kettle", - "SinkBasin", - "Spoon", - "SoapBottle", - "Toaster", - "Cabinet", - "Cup", - "Drawer", - "Bread", - "Sink", - "DiningTable", - "Floor", - "HousePlant", - "Potato", - "Vase", - "Mug", - "CounterTop", - "ShelvingUnit", - "Spatula", - "Shelf", - "Chair", - "LightSwitch", - "DishSponge" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan7-openable.json b/gen/layouts/FloorPlan7-openable.json deleted file mode 100644 index f0f78366b..000000000 --- a/gen/layouts/FloorPlan7-openable.json +++ /dev/null @@ -1,146 +0,0 @@ -{ - "Cabinet|+00.38|+00.37|-01.24": [ - -0.25, - -0.5, - 90, - 30 - ], - "Cabinet|+00.52|+02.01|-01.54": [ - 0.25, - -0.75, - 180, - 0 - ], - "Cabinet|+00.78|+00.37|-01.24": [ - 0.0, - -0.5, - 90, - 30 - ], - "Cabinet|+01.45|+02.26|-01.54": [ - 1.0, - -0.75, - 180, - 0 - ], - "Cabinet|+01.78|+00.37|-01.24": [ - 1.25, - -0.5, - 90, - 30 - ], - "Cabinet|+01.78|+02.01|-01.54": [ - 1.25, - -0.75, - 180, - 0 - ], - "Cabinet|-00.57|+00.37|-01.24": [ - 0.25, - -0.5, - 270, - 30 - ], - "Cabinet|-00.71|+02.01|-01.54": [ - -0.5, - -0.75, - 180, - 0 - ], - "Cabinet|-01.48|+00.37|-01.24": [ - -0.75, - -0.25, - 180, - 30 - ], - "Cabinet|-01.67|+02.01|-01.54": [ - -1.0, - -0.75, - 180, - 0 - ], - "Cabinet|-02.17|+02.01|-01.54": [ - -2.75, - -1.0, - 90, - 0 - ], - "Cabinet|-02.22|+00.37|-01.87": [ - -2.75, - -1.25, - 90, - 30 - ], - "CounterTop|+01.65|+00.95|-01.53": [ - 1.25, - -0.75, - 90, - 30 - ], - "CounterTop|-01.87|+00.95|-00.61": [ - -2.5, - 0.5, - 90, - 30 - ], - "DiningTable|-02.66|+00.00|+03.21": [ - -2.5, - 2.25, - 0, - 30 - ], - "Drawer|+00.60|+00.68|-01.40": [ - 1.0, - -0.75, - 270, - 30 - ], - "Drawer|-01.64|+00.68|-00.93": [ - -1.0, - -0.25, - 270, - 30 - ], - "Drawer|-02.06|+00.68|-01.58": [ - -3.0, - -1.0, - 180, - 30 - ], - "Fridge|-00.04|+00.00|+02.18": [ - 0.0, - 1.25, - 0, - 30 - ], - "GarbageCan|-00.87|00.00|+02.14": [ - -1.75, - 1.5, - 0, - 30 - ], - "Microwave|+01.15|+01.66|-01.61": [ - 0.75, - -0.75, - 180, - 0 - ], - "Shelf|+03.73|+00.55|+01.67": [ - 2.5, - 1.75, - 90, - 0 - ], - "Shelf|+03.73|+00.88|+01.67": [ - 3.25, - 1.75, - 90, - 30 - ], - "Sink|+00.02|+00.77|-01.71|SinkBasin": [ - -0.75, - -0.75, - 180, - 0 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan8-layout.npy b/gen/layouts/FloorPlan8-layout.npy deleted file mode 100644 index f768a488c36e0b0a939b69a01e5488a6c8e1cd65..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2768 zcmbW$ze*!f6u{xDgcLr-bfb`Fgl@bI&ivyq^C#ySUsbPvyD2p3eWy+M}jDzWLpbn)c>?_Bfl|UER;F zr(gT0liT_9bASGC@-Y4M{*PZjN6q2EsCjAr^V%!l*Kk?a^`fr43J>BwyWgk#yc^GR zNp_C=d3}#_?U%T?JETD)wA7?@0<0o`QGc}`(X3ge0C1!)!)Ou`E0)D%xCl2 zd^Vq*%Xu~5{whANee>CTHlNLB^VuBEtNHKoJ(YWxcGI z^>R!rte5q&-reZa%X(Qa>t(&Hm-TXqi}kWz);k!N?@KT1WxcGI^|D^p%XMlgte5q2 eS=Kj(B9dbv(5h4r%D;rIgsV3kz> diff --git a/gen/layouts/FloorPlan8-objects.json b/gen/layouts/FloorPlan8-objects.json deleted file mode 100644 index 12da9582d..000000000 --- a/gen/layouts/FloorPlan8-objects.json +++ /dev/null @@ -1,46 +0,0 @@ -[ - "ButterKnife", - "Drawer", - "Lettuce", - "Toaster", - "StoveKnob", - "SaltShaker", - "Pot", - "Microwave", - "Stool", - "HousePlant", - "Floor", - "Apple", - "Fork", - "Cabinet", - "StoveBurner", - "LightSwitch", - "CoffeeMachine", - "SprayBottle", - "SinkBasin", - "Knife", - "Fridge", - "Spatula", - "Mug", - "Faucet", - "Ladle", - "SoapBottle", - "Sink", - "CounterTop", - "Kettle", - "Tomato", - "Cup", - "Egg", - "GarbageCan", - "Bowl", - "Bread", - "DishSponge", - "PepperShaker", - "Pen", - "Bottle", - "Plate", - "Window", - "Pan", - "Spoon", - "Potato" -] \ No newline at end of file diff --git a/gen/layouts/FloorPlan8-openable.json b/gen/layouts/FloorPlan8-openable.json deleted file mode 100644 index a327a281a..000000000 --- a/gen/layouts/FloorPlan8-openable.json +++ /dev/null @@ -1,170 +0,0 @@ -{ - "Cabinet|+00.49|+02.06|-01.69": [ - 0.5, - -0.75, - 180, - 0 - ], - "Cabinet|+00.83|+00.40|-01.39": [ - 0.0, - -0.5, - 90, - 30 - ], - "Cabinet|+00.86|+00.40|+00.67": [ - 0.0, - 0.0, - 90, - 30 - ], - "Cabinet|+00.86|+00.40|-00.55": [ - 0.0, - -0.75, - 90, - 30 - ], - "Cabinet|+00.86|+00.40|-01.37": [ - 0.0, - -1.0, - 90, - 30 - ], - "Cabinet|+01.16|+02.06|-00.34": [ - 0.5, - -0.75, - 90, - 0 - ], - "Cabinet|+01.16|+02.06|-01.02": [ - 0.25, - -1.0, - 90, - 0 - ], - "Cabinet|-00.19|+02.06|-01.69": [ - 0.0, - -1.0, - 180, - 0 - ], - "Cabinet|-00.20|+00.40|-01.39": [ - -0.5, - -0.5, - 90, - 30 - ], - "Cabinet|-00.24|+00.40|-01.39": [ - -0.75, - -0.75, - 90, - 30 - ], - "Cabinet|-00.82|+00.40|-01.39": [ - -1.25, - -0.5, - 90, - 30 - ], - "Cabinet|-00.82|+02.06|-01.69": [ - 0.0, - -1.0, - 180, - 0 - ], - "Cabinet|-00.87|+02.01|-01.69": [ - -1.5, - -0.5, - 180, - 0 - ], - "Cabinet|-01.61|+02.01|-01.69": [ - -2.0, - -0.5, - 180, - 0 - ], - "Cabinet|-01.66|+02.06|-01.68": [ - -2.25, - -1.0, - 180, - 0 - ], - "Cabinet|-01.67|+00.40|-01.39": [ - -2.0, - -1.0, - 180, - 30 - ], - "Cabinet|-02.24|+00.40|-01.39": [ - -2.5, - -1.0, - 180, - 30 - ], - "CounterTop|+01.17|+00.95|-00.65": [ - 0.5, - -0.75, - 90, - 30 - ], - "CounterTop|+01.50|+01.20|-00.66": [ - 0.5, - -1.0, - 90, - 0 - ], - "CounterTop|-01.97|+00.95|-01.71": [ - -2.5, - -1.25, - 90, - 30 - ], - "CounterTop|-02.10|+00.95|+00.29": [ - -1.5, - -0.25, - 0, - 30 - ], - "Drawer|+00.59|+00.75|-01.39": [ - 0.0, - -0.75, - 90, - 30 - ], - "Drawer|+00.86|+00.75|+00.43": [ - 0.0, - 1.0, - 90, - 0 - ], - "Drawer|+00.87|+00.75|-01.14": [ - 0.0, - -1.0, - 90, - 0 - ], - "Fridge|+01.42|+00.00|+02.10": [ - 0.5, - 2.0, - 90, - 0 - ], - "GarbageCan|+01.34|+00.02|+01.04": [ - 0.5, - 0.5, - 0, - 30 - ], - "Microwave|+01.42|+01.15|+00.02": [ - 0.5, - 0.5, - 90, - 0 - ], - "Sink|+00.16|+00.82|-01.80|SinkBasin": [ - 0.5, - -1.0, - 270, - 30 - ] -} \ No newline at end of file diff --git a/gen/layouts/FloorPlan9-layout.npy b/gen/layouts/FloorPlan9-layout.npy deleted file mode 100644 index bd4533e3927e8b5b7557a060a87f6091d6716e6a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1360 zcmbWzp-#h46b9hSLI~k0>I%seW`vMz3J1X;P^4j95QLGIUjvA*o7FV+|9i}l6&V) 0: - lock.acquire() - scene_num = all_scene_numbers.pop() - lock.release() - fn = os.path.join('layouts', ('FloorPlan%d-layout.npy') % scene_num) - if os.path.isfile(fn): - print("file %s already exists; skipping this floorplan" % fn) - continue - - openable_json_file = os.path.join('layouts', ('FloorPlan%d-openable.json') % scene_num) - scene_objs_json_file = os.path.join('layouts', ('FloorPlan%d-objects.json') % scene_num) - - scene_name = ('FloorPlan%d') % scene_num - print('Running ' + scene_name) - event = env.reset(scene_name, - render_image=False, - render_depth_image=False, - render_class_image=False, - render_object_image=True) - agent_height = event.metadata['agent']['position']['y'] - - scene_objs = list(set([obj['objectType'] for obj in event.metadata['objects']])) - with open(scene_objs_json_file, 'w') as sof: - json.dump(scene_objs, sof, sort_keys=True, indent=4) - - # Get all the reachable points through Unity for this step size. - event = env.step(dict(action='GetReachablePositions', - gridSize=constants.AGENT_STEP_SIZE / constants.RECORD_SMOOTHING_FACTOR)) - if event.metadata['actionReturn'] is None: - print("ERROR: scene %d 'GetReachablePositions' returns None" % scene_num) - else: - reachable_points = set() - for point in event.metadata['actionReturn']: - reachable_points.add((point['x'], point['z'])) - print("scene %d got %d reachable points, now checking" % (scene_num, len(reachable_points))) - - # Pick up a small object to use in testing whether points are good for openable objects. - open_test_objs = {'CD', 'CellPhone', 'Cloth', 'CreditCard', 'DishSponge', 'Fork', - 'KeyChain', 'Pen', 'Pencil', 'SoapBar', 'Spoon', 'Watch'} - good_obj_point = None - good_obj_point = get_obj(env, open_test_objs, reachable_points, agent_height, scene_name, good_obj_point) - - - best_open_point = {} # map from object names to the best point from which they can be successfully opened - best_sem_coverage = {} # number of pixels in the semantic map of the receptacle at the existing best openpt - checked_points = set() - scene_receptacles = set() - for point in reachable_points: - point_is_valid = True - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - } - event = env.step(action) - if event.metadata['lastActionSuccess']: - for horizon in [-30, 0, 30]: - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - 'rotateOnTeleport': True, - 'rotation': 0, - 'horizon': horizon - } - event = env.step(action) - if not event.metadata['lastActionSuccess']: - point_is_valid = False - break - for rotation in range(3): - action = {'action': 'RotateLeft'} - event = env.step(action) - if not event.metadata['lastActionSuccess']: - point_is_valid = False - break - if not point_is_valid: - break - if point_is_valid: - checked_points.add(point) - else: - continue - - # Check whether we can open objects from here in any direction with any tilt. - for rotation in range(4): - # First try up, then down, then return to the horizon before moving again. - for horizon in [-30, 0, 30]: - - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - 'rotateOnTeleport': True, - 'rotation': rotation * 90, - 'horizon': horizon - } - event = env.step(action) - for obj in event.metadata['objects']: - if (obj['visible'] and obj['objectId'] and obj['receptacle'] and not obj['pickupable'] - and obj['objectType'] in constants.VAL_RECEPTACLE_OBJECTS): - obj_name = obj['objectId'] - obj_point = (obj['position']['x'], obj['position']['y']) - scene_receptacles.add(obj_name) - - # Go ahead and attempt to close the object from this position if it's open. - if obj['openable'] and obj['isOpen']: - close_action = {'action': 'CloseObject', - 'objectId': obj['objectId']} - event = env.step(close_action) - - point_to_recep = np.linalg.norm(np.array(point) - np.array(obj_point)) - if len(env.last_event.metadata['inventoryObjects']) > 0: - inv_obj = env.last_event.metadata['inventoryObjects'][0]['objectId'] - else: - inv_obj = None - - # Heuristic implemented in task_game_state has agent 0.5 or farther in agent space. - heuristic_far_enough_from_recep = 0.5 < point_to_recep - # Ensure this point affords a larger view according to the semantic segmentation - # of the receptacle than the existing. - point_sem_coverage = get_mask_of_obj(env, obj['objectId']) - if point_sem_coverage is None: - use_sem_heuristic = False - better_sem_covereage = False - else: - use_sem_heuristic = True - better_sem_covereage = (obj_name not in best_sem_coverage or - best_sem_coverage[obj_name] is None or - point_sem_coverage > best_sem_coverage[obj_name]) - # Ensure that this point is farther away than our existing best candidate. - # We'd like to open each receptacle from as far away as possible while retaining - # the ability to pick/place from it. - farther_than_existing_good_point = (obj_name not in best_open_point or - point_to_recep > - np.linalg.norm( - np.array(point) - - np.array(best_open_point[obj_name][:2]))) - # If we don't have an inventory object, though, we'll fall back to the heuristic - # of being able to open/close as _close_ as possible. - closer_than_existing_good_point = (obj_name not in best_open_point or - point_to_recep < - np.linalg.norm( - np.array(point) - - np.array(best_open_point[obj_name][:2]))) - # Semantic segmentation heuristic. - if ((use_sem_heuristic and heuristic_far_enough_from_recep and better_sem_covereage) - or (not use_sem_heuristic and - # Distance heuristics. - (heuristic_far_enough_from_recep and - (inv_obj and farther_than_existing_good_point) or - (not inv_obj and closer_than_existing_good_point)))): - if obj['openable']: - action = {'action': 'OpenObject', - 'objectId': obj['objectId']} - event = env.step(action) - if not obj['openable'] or event.metadata['lastActionSuccess']: - # We can open the object, so try placing our small inventory obj inside. - # If it can be placed inside and retrieved, then this is a safe point. - action = {'action': 'PutObject', - 'objectId': obj['objectId'], - 'forceAction': True, - 'placeStationary': True} - if inv_obj: - event = env.step(action) - if inv_obj is None or event.metadata['lastActionSuccess']: - action = {'action': 'PickupObject', - 'objectId': inv_obj} - if inv_obj: - event = env.step(action) - if inv_obj is None or event.metadata['lastActionSuccess']: - - # Finally, ensure we can also close the receptacle. - if obj['openable']: - action = {'action': 'CloseObject', - 'objectId': obj['objectId']} - event = env.step(action) - if not obj['openable'] or event.metadata['lastActionSuccess']: - - # We can put/pick our inv object into the receptacle from here. - # We have already ensured this point is farther than any - # existing best, so this is the new best. - best_open_point[obj_name] = [point[0], point[1], rotation * 90, horizon] - best_sem_coverage[obj_name] = point_sem_coverage - - # We could not retrieve our inv object, so we need to go get another one - else: - good_obj_point = get_obj(env, open_test_objs, reachable_points, - agent_height, scene_name, good_obj_point) - action = {'action': 'TeleportFull', - 'x': point[0], - 'y': agent_height, - 'z': point[1], - 'rotateOnTeleport': True, - 'rotation': rotation * 90, - 'horizon': horizon - } - event = env.step(action) - - # Regardless of what happened up there, try to close the receptacle again if - # it remained open. - if obj['isOpen']: - action = {'action': 'CloseObject', - 'objectId': obj['objectId']} - event = env.step(action) - - essential_objs = [] - if scene_num in constants.SCENE_TYPE["Kitchen"]: - essential_objs.extend(["Microwave", "Fridge"]) - for obj in essential_objs: - if not np.any([obj in obj_key for obj_key in best_open_point]): - print("WARNING: Essential object %s has no open points in scene %d" % (obj, scene_num)) - - print("scene %d found open/pick/place/close positions for %d/%d receptacle objects" % - (scene_num, len(best_open_point), len(scene_receptacles))) - with open(openable_json_file, 'w') as f: - json.dump(best_open_point, f, sort_keys=True, indent=4) - - print("scene %d reachable %d, checked %d; taking intersection" % - (scene_num, len(reachable_points), len(checked_points))) - - points = np.array(list(checked_points))[:, :2] - points = points[np.lexsort((points[:, 0], points[:, 1])), :] - np.save(fn, points) - - env.stop() - print('Done') - - -threads = [] -for n in range(N_PROCS): - thread = threading.Thread(target=run, args=(n,)) - threads.append(thread) - thread.start() - time.sleep(1) diff --git a/gen/planner/__init__.py b/gen/planner/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/gen/planner/domains/PutTaskExtended_domain.pddl b/gen/planner/domains/PutTaskExtended_domain.pddl deleted file mode 100644 index 60280d713..000000000 --- a/gen/planner/domains/PutTaskExtended_domain.pddl +++ /dev/null @@ -1,302 +0,0 @@ -;; Specification in PDDL1 of the Extended Task domain - -(define (domain put_task) - (:requirements - :adl - ) - (:types - agent - location - receptacle - object - rtype - otype - ) - - - (:predicates - (atLocation ?a - agent ?l - location) ; true if the agent is at the location - (receptacleAtLocation ?r - receptacle ?l - location) ; true if the receptacle is at the location (constant) - (objectAtLocation ?o - object ?l - location) ; true if the object is at the location - (openable ?r - receptacle) ; true if a receptacle is openable - (opened ?r - receptacle) ; true if a receptacle is opened - (inReceptacle ?o - object ?r - receptacle) ; object ?o is in receptacle ?r - (isReceptacleObject ?o - object) ; true if the object can have things put inside it - (inReceptacleObject ?innerObject - object ?outerObject - object) ; object ?innerObject is inside object ?outerObject - (wasInReceptacle ?o - object ?r - receptacle) ; object ?o was or is in receptacle ?r now or some time in the past - ;(checked ?r - receptacle) ; whether the receptacle has been looked inside/visited - (receptacleType ?r - receptacle ?t - rtype) ; the type of receptacle (Cabinet vs Cabinet|01|2...) - (objectType ?o - object ?t - otype) ; the type of object (Apple vs Apple|01|2...) - (holds ?a - agent ?o - object) ; object ?o is held by agent ?a - (holdsAny ?a - agent) ; agent ?a holds an object - (holdsAnyReceptacleObject ?a - agent) ; agent ?a holds a receptacle object - ;(full ?r - receptacle) ; true if the receptacle has no remaining space - (isClean ?o - object) ; true if the object has been clean in sink - (cleanable ?o - object) ; true if the object can be placed in a sink - (isHot ?o - object) ; true if the object has been heated up - (heatable ?o - object) ; true if the object can be heated up in a microwave - (isCool ?o - object) ; true if the object has been cooled - (coolable ?o - object) ; true if the object can be cooled in the fridge - (toggleable ?o - object) ; true if the object can be turned on/off - (isOn ?o - object) ; true if the object is on - (isToggled ?o - object) ; true if the object has been toggled - (sliceable ?o - object) ; true if the object can be sliced - (isSliced ?o - object) ; true if the object is sliced - ) - - (:functions - (distance ?from ?to) - (totalCost) - ) - -;; All actions are specified such that the final arguments are the ones used -;; for performing actions in Unity. - -;; agent goes to receptacle - (:action GotoLocation - :parameters (?a - agent ?lStart - location ?lEnd - location) - :precondition (and - (atLocation ?a ?lStart) - (forall (?re - receptacle) - (not (opened ?re)) - ) - ) - :effect (and - (atLocation ?a ?lEnd) - (not (atLocation ?a ?lStart)) - (increase (totalCost) (distance ?lStart ?lEnd)) - ) - ) - -;; agent opens receptacle - (:action OpenObject - :parameters (?a - agent ?l - location ?r - receptacle) - :precondition (and - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (openable ?r) - (forall (?re - receptacle) - (not (opened ?re)) - ) - ) - :effect (and - (opened ?r) - (increase (totalCost) 1) - ) - ) -;; agent closes receptacle - (:action CloseObject - :parameters (?a - agent ?al - location ?r - receptacle) - :precondition (and - (atLocation ?a ?al) - (receptacleAtLocation ?r ?al) - (openable ?r) - (opened ?r) - ) - :effect (and - (not (opened ?r)) - (increase (totalCost) 1) - ) - - ) - -;; agent picks up object - (:action PickupObjectInReceptacle1 - :parameters (?a - agent ?l - location ?o - object ?r - receptacle) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?o ?l) - (inReceptacle ?o ?r) - (not (holdsAny ?a)) - ) - :effect (and - (forall (?re - receptacle) - (not (inReceptacle ?o ?re)) - ) - (not (objectAtLocation ?o ?l)) - (holds ?a ?o) - (holdsAny ?a) - (increase (totalCost) 1) - ) - ) - -;; agent picks up object not in a receptacle - (:action PickupObjectNoReceptacle - :parameters (?a - agent ?l - location ?o - object) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?o ?l) - (forall (?r - receptacle) - (not (inReceptacle ?o ?r)) - ) - (not (holdsAny ?a)) - ) - :effect (and - (not (objectAtLocation ?o ?l)) - (holds ?a ?o) - (holdsAny ?a) - (increase (totalCost) 1) - ) - ) - -;; agent puts down an object in a receptacle - (:action PutObjectInReceptacle1 - :parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle) ;?rt - rtype) - :precondition (and - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (objectType ?o ?ot) - (holds ?a ?o) - (not (holdsAnyReceptacleObject ?a)) - ) - :effect (and - (inReceptacle ?o ?r) - (not (holds ?a ?o)) - (not (holdsAny ?a)) - (increase (totalCost) 1) - (objectAtLocation ?o ?l) - ) - ) - -;; agent puts down an object - (:action PutObjectInReceptacleObject1 - :parameters (?a - agent ?l - location ?ot - otype ?o - object ?outerO - object ?outerR - receptacle) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?outerO ?l) - (isReceptacleObject ?outerO) - (not (isReceptacleObject ?o)) - (objectType ?o ?ot) - (holds ?a ?o) - (not (holdsAnyReceptacleObject ?a)) - (inReceptacle ?outerO ?outerR) - ) - :effect (and - (inReceptacleObject ?o ?outerO) - (inReceptacle ?o ?outerR) - (not (holds ?a ?o)) - (not (holdsAny ?a)) - (increase (totalCost) 1) - (objectAtLocation ?o ?l) - ) - ) - -;; agent puts down a receptacle object in a receptacle - (:action PutReceptacleObjectInReceptacle1 - :parameters (?a - agent ?l - location ?ot - otype ?outerO - object ?r - receptacle) ; ?rt - rtype) - :precondition (and - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (objectType ?outerO ?ot) - (holds ?a ?outerO) - (holdsAnyReceptacleObject ?a) - (isReceptacleObject ?outerO) - ) - :effect (and - (forall (?obj - object) - (when (holds ?a ?obj) - (and - (not (holds ?a ?obj)) - (objectAtLocation ?obj ?l) - (inReceptacle ?obj ?r) - ) - ) - ) - (not (holdsAny ?a)) - (not (holdsAnyReceptacleObject ?a)) - (increase (totalCost) 1) - ) - ) - -;; agent cleans some object - (:action CleanObject - :parameters (?a - agent ?l - location ?r - receptacle ?o - object) - :precondition (and - (receptacleType ?r SinkBasinType) - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (holds ?a ?o) - ) - :effect (and - (increase (totalCost) 5) - (isClean ?o) - ) - ) - - -;; agent heats-up some object - (:action HeatObject - :parameters (?a - agent ?l - location ?r - receptacle ?o - object) - :precondition (and - (or - (receptacleType ?r MicrowaveType) - ) - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (holds ?a ?o) - ) - :effect (and - (increase (totalCost) 5) - (isHot ?o) - ) - ) - -;; agent cools some object - (:action CoolObject - :parameters (?a - agent ?l - location ?r - receptacle ?o - object) - :precondition (and - (or - (receptacleType ?r FridgeType) - ) - (atLocation ?a ?l) - (receptacleAtLocation ?r ?l) - (holds ?a ?o) - ) - :effect (and - (increase (totalCost) 5) - (isCool ?o) - ) - ) - - -;; agent toggle object - (:action ToggleObject - :parameters (?a - agent ?l - location ?o - object) - :precondition (and - (atLocation ?a ?l) - (objectAtLocation ?o ?l) - (toggleable ?o) - ) - :effect (and - (increase (totalCost) 5) - (when (isOn ?o) - (not (isOn ?o))) - (when (not (isOn ?o)) - (isOn ?o)) - (isToggled ?o) - ) - ) - - -;; agent slices some object with a knife - (:action SliceObject - :parameters (?a - agent ?l - location ?co - object ?ko - object) - :precondition - (and - (or - (objectType ?ko KnifeType) - (objectType ?ko ButterKnifeType) - ) - (atLocation ?a ?l) - (objectAtLocation ?co ?l) - (sliceable ?co) - (holds ?a ?ko) - ) - :effect (and - (increase (totalCost) 5) - (isSliced ?co) - ) - ) - - -) diff --git a/gen/planner/ff_planner_handler.py b/gen/planner/ff_planner_handler.py deleted file mode 100644 index 50937c677..000000000 --- a/gen/planner/ff_planner_handler.py +++ /dev/null @@ -1,252 +0,0 @@ -import pdb -import ast -import multiprocessing -import re -import shlex -import subprocess -import time - -import constants -from utils import game_util -from utils import py_util - -DEBUG = False - -CAPS_ACTION_TO_PLAN_ACTION = { - 'GOTOLOCATION': 'GotoLocation', - 'SCAN': 'Scan', - 'OPENOBJECT': 'OpenObject', - 'CLOSEOBJECT': 'CloseObject', - 'PICKUPOBJECT': 'PickupObject', - 'PICKUPOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', - 'PICKUPOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', - 'PICKUPRECEPTACLEOBJECTINRECEPTACLE1': 'PickupObjectInReceptacle', - 'PICKUPRECEPTACLEOBJECTINRECEPTACLE2': 'PickupObjectInReceptacle', - 'PICKUPOBJECTINOBJECT1': 'PickupObjectInObject', - 'PICKUPOBJECTINOBJECT2': 'PickupObjectInObject', - 'PUTOBJECTINRECEPTACLE1': 'PutObjectInReceptacle', - 'PUTOBJECTINRECEPTACLE2': 'PutObjectInReceptacle', - 'PUTOBJECTINRECEPTACLEOBJECT1': 'PutObjectInReceptacleObject', - 'PUTOBJECTINRECEPTACLEOBJECT2': 'PutObjectInReceptacleObject', - 'PUTRECEPTACLEOBJECTINRECEPTACLE1': 'PutReceptacleObjectInReceptacle', - 'PUTRECEPTACLEOBJECTINRECEPTACLE2': 'PutReceptacleObjectInReceptacle', - 'PICKUPOBJECTNORECEPTACLE': 'PickupObjectNoReceptacle', - 'PUTOBJECT': 'PutObject', - 'CLEANOBJECT': 'CleanObject', - 'HEATOBJECT': 'HeatObject', - 'TOGGLEOBJECT': 'ToggleObject', - 'COOLOBJECT': 'CoolObject', - 'SLICEOBJECT': 'SliceObject', - 'REACH-GOAL': 'End' -} - -LOWER_TO_FULL = {name.lower(): name for name in constants.OBJECTS} - - -def lower_to_full(input_str): - arr = input_str.split('|') - new_arr = [] - for item in arr: - if item in LOWER_TO_FULL: - new_arr.append(LOWER_TO_FULL[item]) - else: - new_arr.append(item) - return '|'.join(new_arr) - - - -def parse_action_arg(action_arg): - action_arg = action_arg.lower() - action_arg = py_util.multireplace(action_arg, - {'_minus_': '-', - '-': '#', - '_bar_': '|', - '_plus_': '+', - '_dot_': '.', - '_comma_': ','}) - action_arg = lower_to_full(action_arg) - return action_arg - - -def parse_line(line): - line = re.sub(r'^\s*step|\d+:\s*', '', line) - line = line.strip() - line_args = line.split(' ') - if line_args[0] not in CAPS_ACTION_TO_PLAN_ACTION: - return None - action = CAPS_ACTION_TO_PLAN_ACTION[line_args[0]] - if action == 'End': - return {'action': 'End', 'value': 1} - action_dict = {'action': action} - line_args = line_args[1:] # Remove action name from line_args - - if action in {'GotoLocation', 'Scan'}: - action_arg = line_args[2].lower() - action_arg = py_util.multireplace(action_arg, - {'_minus_': '-', - '-': '#', - '_bar_': '|', - '_plus_': '+', - '_dot_': '.', - '_comma_': ','}) - action_dict['location'] = action_arg - elif action in {'OpenObject', 'CloseObject', 'ToggleObject'}: - action_dict['objectId'] = parse_action_arg(line_args[2]) - action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) - elif action in {'HeatObject', 'CoolObject'}: - action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) - elif action in {'PickupObjectInReceptacle', 'PickupObjectNoReceptacle'}: - action_dict['action'] = 'PickupObject' - action_dict['objectId'] = parse_action_arg(line_args[2]) - if action == 'PickupObjectInReceptacle': - action_dict['receptacleObjectId'] = parse_action_arg(line_args[3]) - elif action in {'SliceObject'}: - action_dict['objectId'] = parse_action_arg(line_args[2]) - elif action in {'CleanObject'}: - action_dict['objectId'] = parse_action_arg(line_args[3]) - action_dict['receptacleObjectId'] = parse_action_arg(line_args[2]) - elif action in {'PutObjectInReceptacle', - 'PutObjectInReceptacleObject', - 'PutReceptacleObjectInReceptacle'}: - action_dict['action'] = 'PutObject' - action_dict['objectId'] = parse_action_arg(line_args[3]) - action_dict['receptacleObjectId'] = parse_action_arg(line_args[4]) - elif action in {'PickupObjectInObject'}: - action_dict['action'] = 'PickupObject' - - - return action_dict - - -def parse_plan(lines): - plan = [] - for line in lines: - action_dict = parse_line(line) - if action_dict is not None: - plan.append(action_dict) - return plan - - -def parse_plan_from_file(self, path): - lines = [line for line in open(path)] - return self.parse_plan(lines) - - -def get_plan_from_file(args): - domain, filepath, solver_type = args - - start_t = time.time() - try: - command = ('ff_planner/ff ' - '-o %s ' - '-s %d ' - '-f %s ' % (domain, solver_type, filepath)) - if DEBUG: - print(command) - planner_output = subprocess.check_output(shlex.split(command), timeout=30) - except subprocess.CalledProcessError as error: - # Plan is done - output_str = error.output.decode('utf-8') - if DEBUG: - print('output', output_str) - if ('goal can be simplified to FALSE' in output_str or - "won't get here: simplify, non logical" in output_str): - return [{'action': 'End', 'value': 0}] - elif 'goal can be simplified to TRUE' in output_str: - return [{'action': 'End', 'value': 1}] - elif len(output_str) == 0: - # Usually indicates segfault with ffplanner - # This happens when the goal needs an object that hasn't been seen yet like - # Q: "is there an egg in the garbage can," but no garbage can has been seen. - print('Empty plan') - print('Seg Fault') - return [{'action': 'End', 'value': 0}] - else: - print('problem', filepath) - print(output_str) - print('Empty plan') - return [{'action': 'End', 'value': 0}] - except subprocess.TimeoutExpired: - print('timeout solver', solver_type, 'problem', filepath) - print('Empty plan') - return ['timeout', {'action': 'End', 'value': 0}] - unparsed_plan = planner_output.decode('utf-8').split('\n') - if DEBUG: - print('unparsed', '\n'.join(unparsed_plan)) - parsed_plan = parse_plan(unparsed_plan) - if constants.DEBUG: - print('planned %s in %.5f, plan length %d solver type %d' % ( - filepath, time.time() - start_t, len(parsed_plan), solver_type)) - if len(parsed_plan) == 0: - parsed_plan = [{'action': 'End', 'value': 1}] - return parsed_plan - - -# Example of how to call ff -# /path/to/Metric-FF-v2.1/ff -o planner/domains/Question_domain.pddl -f planner/exists_problem.pddl -def get_plan_async(args): - domain, problem_id, solver_type = args - filepath = '%s/planner/generated_problems/problem_%s.pddl' % (constants.LOG_FILE, problem_id) - return get_plan_from_file((domain, filepath, solver_type)) - - -class PlanParser(object): - def __init__(self, domain_file_path): - self.domain = domain_file_path - self.problem_id = -1 - self.process_pool = multiprocessing.Pool(3) - #from multiprocessing.pool import ThreadPool - #self.process_pool = ThreadPool(3) - - def get_plan(self): - parsed_plans = self.process_pool.map(get_plan_async, zip([self.domain] * 3, [self.problem_id] * 3, range(3, 6))) - return self.find_best_plan(parsed_plans) - - def get_plan_from_file(self, domain_path, filepath): - parsed_plans = self.process_pool.map(get_plan_from_file, zip([domain_path] * 3, [filepath] * 3, range(3, 6))) - return self.find_best_plan(parsed_plans) - - # Unncessary, planner should be optimal. But the planner produces some weird actions - def clean_plan(self, plan): - cleaned_plan = list() - for i in range(len(plan)-1): - if not (plan[i]['action'] == 'GotoLocation' and plan[i+1]['action'] == 'GotoLocation'): - cleaned_plan.append(plan[i]) - cleaned_plan.append(plan[len(plan)-1]) - return cleaned_plan - - def find_best_plan(self, parsed_plans): - - if all([parsed_plan[0] == 'timeout' for parsed_plan in parsed_plans]): - parsed_plan = parsed_plans[0][1:] - else: - parsed_plans = [self.clean_plan(parsed_plan) for parsed_plan in parsed_plans if parsed_plan[0] != 'timeout'] - parsed_plan = min(parsed_plans, key=len) - - if constants.DEBUG: - print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) - for pp, pl in enumerate(parsed_plan)])) - else: - print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) - for pp, pl in enumerate(parsed_plan)])) - return parsed_plan - - -class SinglePlanParser(PlanParser): - def get_plan(self): - parsed_plan = get_plan_async([self.domain, self.problem_id, 3]) - return parsed_plan - - def get_plan_from_file(self, domain_path, filepath): - parsed_plan = get_plan_from_file([domain_path, filepath, 3]) - return parsed_plan - - -if __name__ == '__main__': - import sys - - DEBUG = constants.DEBUG - parser = PlanParser('planner/domains/PutTaskExtended_domain.pddl') - parser.problem_id = sys.argv[1] - result_plan = parser.get_plan() - print('plan\n' + '\n'.join(['%03d: %s' % (pp, game_util.get_action_str(pl)) for pp, pl in enumerate(result_plan)])) diff --git a/gen/planner/pddl.pdf b/gen/planner/pddl.pdf deleted file mode 100644 index 4acd4e0a5c03c58ab1177920fd70eaf3ce523982..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 196613 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

wc5{pc71>6lps{#4t; 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 diff --git a/gen/scripts/augment_trajectories.py b/gen/scripts/augment_trajectories.py deleted file mode 100644 index 19aeb9be2..000000000 --- a/gen/scripts/augment_trajectories.py +++ /dev/null @@ -1,312 +0,0 @@ -import os -import sys -sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) -sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) - -import json -import glob -import os -import constants -import cv2 -import shutil -import numpy as np -import argparse -import threading -import time -import copy -import random -from utils.video_util import VideoSaver -from utils.py_util import walklevel -from env.thor_env import ThorEnv - - -TRAJ_DATA_JSON_FILENAME = "traj_data.json" -AUGMENTED_TRAJ_DATA_JSON_FILENAME = "augmented_traj_data.json" - -ORIGINAL_IMAGES_FORLDER = "raw_images" -HIGH_RES_IMAGES_FOLDER = "high_res_images" -DEPTH_IMAGES_FOLDER = "depth_images" -INSTANCE_MASKS_FOLDER = "instance_masks" - -IMAGE_WIDTH = 600 -IMAGE_HEIGHT = 600 - -render_settings = dict() -render_settings['renderImage'] = True -render_settings['renderDepthImage'] = True -render_settings['renderObjectImage'] = True -render_settings['renderClassImage'] = True - -video_saver = VideoSaver() - - -def get_image_index(save_path): - return len(glob.glob(save_path + '/*.png')) - - -def save_image_with_delays(env, action, - save_path, direction=constants.BEFORE): - im_ind = get_image_index(save_path) - counts = constants.SAVE_FRAME_BEFORE_AND_AFTER_COUNTS[action['action']][direction] - for i in range(counts): - save_image(env.last_event, save_path) - env.noop() - return im_ind - - -def save_image(event, save_path): - # rgb - rgb_save_path = os.path.join(save_path, HIGH_RES_IMAGES_FOLDER) - rgb_image = event.frame[:, :, ::-1] - - # depth - depth_save_path = os.path.join(save_path, DEPTH_IMAGES_FOLDER) - depth_image = event.depth_frame - depth_image = depth_image * (255 / 10000) - depth_image = depth_image.astype(np.uint8) - - # masks - mask_save_path = os.path.join(save_path, INSTANCE_MASKS_FOLDER) - mask_image = event.instance_segmentation_frame - - # dump images - im_ind = get_image_index(rgb_save_path) - cv2.imwrite(rgb_save_path + '/%09d.png' % im_ind, rgb_image) - cv2.imwrite(depth_save_path + '/%09d.png' % im_ind, depth_image) - cv2.imwrite(mask_save_path + '/%09d.png' % im_ind, mask_image) - - return im_ind - - -def save_images_in_events(events, root_dir): - for event in events: - save_image(event, root_dir) - - -def clear_and_create_dir(path): - if os.path.exists(path): - shutil.rmtree(path) - os.mkdir(path) - - -def augment_traj(env, json_file): - # load json data - with open(json_file) as f: - traj_data = json.load(f) - - # make directories - root_dir = json_file.replace(TRAJ_DATA_JSON_FILENAME, "") - - orig_images_dir = os.path.join(root_dir, ORIGINAL_IMAGES_FORLDER) - high_res_images_dir = os.path.join(root_dir, HIGH_RES_IMAGES_FOLDER) - depth_images_dir = os.path.join(root_dir, DEPTH_IMAGES_FOLDER) - instance_masks_dir = os.path.join(root_dir, INSTANCE_MASKS_FOLDER) - augmented_json_file = os.path.join(root_dir, AUGMENTED_TRAJ_DATA_JSON_FILENAME) - - # fresh images list - traj_data['images'] = list() - - clear_and_create_dir(high_res_images_dir) - clear_and_create_dir(depth_images_dir) - clear_and_create_dir(instance_masks_dir) - - # scene setup - scene_num = traj_data['scene']['scene_num'] - object_poses = traj_data['scene']['object_poses'] - object_toggles = traj_data['scene']['object_toggles'] - dirty_and_empty = traj_data['scene']['dirty_and_empty'] - - # reset - scene_name = 'FloorPlan%d' % scene_num - env.reset(scene_name) - env.restore_scene(object_poses, object_toggles, dirty_and_empty) - - env.step(dict(traj_data['scene']['init_action'])) - print("Task: %s" % (traj_data['template']['task_desc'])) - - # setup task - env.set_task(traj_data, args, reward_type='dense') - rewards = [] - - for ll_idx, ll_action in enumerate(traj_data['plan']['low_actions']): - # next cmd under the current hl_action - cmd = ll_action['api_action'] - hl_action = traj_data['plan']['high_pddl'][ll_action['high_idx']] - - # remove unnecessary keys - cmd = {k: cmd[k] for k in ['action', 'objectId', 'receptacleObjectId', 'placeStationary', 'forceAction'] if k in cmd} - - if "MoveAhead" in cmd['action']: - if args.smooth_nav: - save_image(env.last_event, root_dir) - events = env.smooth_move_ahead(cmd, render_settings) - save_images_in_events(events, root_dir) - event = events[-1] - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - elif "Rotate" in cmd['action']: - if args.smooth_nav: - save_image(env.last_event, root_dir) - events = env.smooth_rotate(cmd, render_settings) - save_images_in_events(events, root_dir) - event = events[-1] - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - elif "Look" in cmd['action']: - if args.smooth_nav: - save_image(env.last_event, root_dir) - events = env.smooth_look(cmd, render_settings) - save_images_in_events(events, root_dir) - event = events[-1] - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - # handle the exception for CoolObject tasks where the actual 'CoolObject' action is actually 'CloseObject' - # TODO: a proper fix for this issue - elif "CloseObject" in cmd['action'] and \ - "CoolObject" in hl_action['planner_action']['action'] and \ - "OpenObject" in traj_data['plan']['low_actions'][ll_idx + 1]['api_action']['action']: - if args.time_delays: - cool_action = hl_action['planner_action'] - save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.BEFORE) - event = env.step(cmd) - save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.MIDDLE) - save_image_with_delays(env, cool_action, save_path=root_dir, direction=constants.AFTER) - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - else: - if args.time_delays: - save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.BEFORE) - event = env.step(cmd) - save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.MIDDLE) - save_image_with_delays(env, cmd, save_path=root_dir, direction=constants.AFTER) - else: - save_image(env.last_event, root_dir) - event = env.step(cmd) - - # update image list - new_img_idx = get_image_index(high_res_images_dir) - last_img_idx = len(traj_data['images']) - num_new_images = new_img_idx - last_img_idx - for j in range(num_new_images): - traj_data['images'].append({ - 'low_idx': ll_idx, - 'high_idx': ll_action['high_idx'], - 'image_name': '%09d.png' % int(last_img_idx + j) - }) - - if not event.metadata['lastActionSuccess']: - raise Exception("Replay Failed: %s" % (env.last_event.metadata['errorMessage'])) - - reward, _ = env.get_transition_reward() - rewards.append(reward) - - # save 10 frames in the end as per the training data - for _ in range(10): - save_image(env.last_event, root_dir) - - # store color to object type dictionary - color_to_obj_id_type = {} - all_objects = env.last_event.metadata['objects'] - for color, object_id in env.last_event.color_to_object_id.items(): - for obj in all_objects: - if object_id == obj['objectId']: - color_to_obj_id_type[str(color)] = { - 'objectID': obj['objectId'], - 'objectType': obj['objectType'] - } - - augmented_traj_data = copy.deepcopy(traj_data) - augmented_traj_data['scene']['color_to_object_type'] = color_to_obj_id_type - augmented_traj_data['task'] = {'rewards': rewards, 'reward_upper_bound': sum(rewards)} - - with open(augmented_json_file, 'w') as aj: - json.dump(augmented_traj_data, aj, sort_keys=True, indent=4) - - # save video - images_path = os.path.join(high_res_images_dir, '*.png') - video_save_path = os.path.join(high_res_images_dir, 'high_res_video.mp4') - video_saver.save(images_path, video_save_path) - - # check if number of new images is the same as the number of original images - if args.smooth_nav and args.time_delays: - orig_img_count = get_image_index(high_res_images_dir) - new_img_count = get_image_index(orig_images_dir) - print ("Original Image Count %d, New Image Count %d" % (orig_img_count, new_img_count)) - if orig_img_count != new_img_count: - raise Exception("WARNING: the augmented sequence length doesn't match the original") - - -def run(): - ''' - replay loop - ''' - # start THOR env - env = ThorEnv(player_screen_width=IMAGE_WIDTH, - player_screen_height=IMAGE_HEIGHT) - - skipped_files = [] - - while len(traj_list) > 0: - lock.acquire() - json_file = traj_list.pop() - lock.release() - - print ("Augmenting: " + json_file) - try: - augment_traj(env, json_file) - except Exception as e: - import traceback - traceback.print_exc() - print ("Error: " + repr(e)) - print ("Skipping " + json_file) - skipped_files.append(json_file) - - env.stop() - print("Finished.") - - # skipped files - if len(skipped_files) > 0: - print("Skipped Files:") - print(skipped_files) - - -traj_list = [] -lock = threading.Lock() - -# parse arguments -parser = argparse.ArgumentParser() -parser.add_argument('--data_path', type=str, default="data/2.1.0") -parser.add_argument('--smooth_nav', dest='smooth_nav', action='store_true') -parser.add_argument('--time_delays', dest='time_delays', action='store_true') -parser.add_argument('--shuffle', dest='shuffle', action='store_true') -parser.add_argument('--num_threads', type=int, default=1) -parser.add_argument('--reward_config', type=str, default='../models/config/rewards.json') -args = parser.parse_args() - -# make a list of all the traj_data json files -for dir_name, subdir_list, file_list in walklevel(args.data_path, level=2): - if "trial_" in dir_name: - json_file = os.path.join(dir_name, TRAJ_DATA_JSON_FILENAME) - if not os.path.isfile(json_file): - continue - traj_list.append(json_file) - -# random shuffle -if args.shuffle: - random.shuffle(traj_list) - -# start threads -threads = [] -for n in range(args.num_threads): - thread = threading.Thread(target=run) - threads.append(thread) - thread.start() - time.sleep(1) \ No newline at end of file diff --git a/gen/scripts/generate_trajectories.py b/gen/scripts/generate_trajectories.py deleted file mode 100644 index 5e67ce0e8..000000000 --- a/gen/scripts/generate_trajectories.py +++ /dev/null @@ -1,752 +0,0 @@ -import os -import sys -sys.path.append(os.path.join('/Users/jiasenl/Code/alfred')) -sys.path.append(os.path.join('/Users/jiasenl/Code/alfred', 'gen')) - -import time -import multiprocessing as mp -import json -import random -import shutil -import argparse -import numpy as np -import pandas as pd -from collections import OrderedDict -from datetime import datetime -import glob -import constants -from agents.deterministic_planner_agent import DeterministicPlannerAgent -from env.thor_env import ThorEnv -from game_states.task_game_state_full_knowledge import TaskGameStateFullKnowledge -from utils.video_util import VideoSaver -from utils.dataset_management_util import load_successes_from_disk, load_fails_from_disk - -# params -RAW_IMAGES_FOLDER = 'raw_images/' -DATA_JSON_FILENAME = 'traj_data.json' -DEPTH_IMAGES_FOLDER = 'depth_images/' - -# video saver -video_saver = VideoSaver() - -# structures to help with constraint enforcement. -goal_to_required_variables = {"pick_and_place_simple": {"pickup", "receptacle", "scene"}, - "pick_two_obj_and_place": {"pickup", "receptacle", "scene"}, - "look_at_obj_in_light": {"pickup", "receptacle", "scene"}, - "pick_clean_then_place_in_recep": {"pickup", "receptacle", "scene"}, - "pick_heat_then_place_in_recep": {"pickup", "receptacle", "scene"}, - "pick_cool_then_place_in_recep": {"pickup", "receptacle", "scene"}, - "pick_and_place_with_movable_recep": {"pickup", "movable", "receptacle", "scene"}} -goal_to_pickup_type = {'pick_heat_then_place_in_recep': 'Heatable', - 'pick_cool_then_place_in_recep': 'Coolable', - 'pick_clean_then_place_in_recep': 'Cleanable'} -goal_to_receptacle_type = {'look_at_obj_in_light': "Toggleable"} -goal_to_invalid_receptacle = {'pick_heat_then_place_in_recep': {'Microwave'}, - 'pick_cool_then_place_in_recep': {'Fridge'}, - 'pick_clean_then_place_in_recep': {'SinkBasin'}, - 'pick_two_obj_and_place': {'CoffeeMachine', 'ToiletPaperHanger', 'HandTowelHolder'}} - -scene_id_to_objs = {} -obj_to_scene_ids = {} -scenes_for_goal = {g: [] for g in constants.GOALS} -scene_to_type = {} - - -def sample_task_params(succ_traj, full_traj, fail_traj, - goal_candidates, pickup_candidates, movable_candidates, receptacle_candidates, scene_candidates, - inject_noise=10): - # Get the current conditional distributions of all variables (goal/pickup/receptacle/scene). - goal_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + succ_traj.loc[ - (succ_traj['pickup'].isin(pickup_candidates) if 'pickup' in goal_to_required_variables[c] else True) & - (succ_traj['movable'].isin(movable_candidates) if 'movable' in goal_to_required_variables[c] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) if 'receptacle' in goal_to_required_variables[c] else True) - & (succ_traj['scene'].isin(scene_candidates) if 'scene' in goal_to_required_variables[c] else True)] - ['goal'].tolist().count(c))) # Conditional. - * (1 / (1 + succ_traj['goal'].tolist().count(c))) # Prior. - for c in goal_candidates] - goal_probs = [w / sum(goal_weight) for w in goal_weight] - - pickup_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['movable'].isin(movable_candidates) - if 'movable' in goal_to_required_variables[g] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) - if 'receptacle' in goal_to_required_variables[g] else True) & - (succ_traj['scene'].isin(scene_candidates) - if 'scene' in goal_to_required_variables[g] else True)] - ['pickup'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['pickup'].tolist().count(c))) - for c in pickup_candidates] - pickup_probs = [w / sum(pickup_weight) for w in pickup_weight] - - movable_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['pickup'].isin(pickup_candidates) - if 'pickup' in goal_to_required_variables[g] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) - if 'receptacle' in goal_to_required_variables[g] else True) & - (succ_traj['scene'].isin(scene_candidates) - if 'scene' in goal_to_required_variables[g] else True)] - ['movable'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['movable'].tolist().count(c))) - for c in movable_candidates] - movable_probs = [w / sum(movable_weight) for w in movable_weight] - - receptacle_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['pickup'].isin(pickup_candidates) - if 'pickup' in goal_to_required_variables[g] else True) & - (succ_traj['movable'].isin(movable_candidates) - if 'movable' in goal_to_required_variables[g] else True) & - (succ_traj['scene'].isin(scene_candidates) - if 'scene' in goal_to_required_variables[g] else True)] - ['receptacle'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['receptacle'].tolist().count(c))) - for c in receptacle_candidates] - receptacle_probs = [w / sum(receptacle_weight) for w in receptacle_weight] - scene_weight = [(1 / (1 + np.random.randint(0, inject_noise + 1) + - sum([succ_traj.loc[ - succ_traj['goal'].isin([g]) & - (succ_traj['pickup'].isin(pickup_candidates) - if 'pickup' in goal_to_required_variables[g] else True) & - (succ_traj['movable'].isin(movable_candidates) - if 'movable' in goal_to_required_variables[g] else True) & - (succ_traj['receptacle'].isin(receptacle_candidates) - if 'receptacle' in goal_to_required_variables[g] else True)] - ['scene'].tolist().count(c) for g in goal_candidates]))) - * (1 / (1 + succ_traj['scene'].tolist().count(c))) - for c in scene_candidates] - scene_probs = [w / sum(scene_weight) for w in scene_weight] - - # Calculate the probability difference between each value and the maximum so we can iterate over them to find a - # next-best candidate to sample subject to the constraints of knowing which will fail. - diffs = [("goal", goal_candidates[idx], goal_probs[idx] - min(goal_probs)) - for idx in range(len(goal_candidates)) if len(goal_candidates) > 1] - diffs.extend([("pickup", pickup_candidates[idx], pickup_probs[idx] - min(pickup_probs)) - for idx in range(len(pickup_candidates)) if len(pickup_candidates) > 1]) - diffs.extend([("movable", movable_candidates[idx], movable_probs[idx] - min(movable_probs)) - for idx in range(len(movable_candidates)) if len(movable_candidates) > 1]) - diffs.extend([("receptacle", receptacle_candidates[idx], receptacle_probs[idx] - min(receptacle_probs)) - for idx in range(len(receptacle_candidates)) if len(receptacle_candidates) > 1]) - diffs.extend([("scene", scene_candidates[idx], scene_probs[idx] - min(scene_probs)) - for idx in range(len(scene_candidates)) if len(scene_candidates) > 1]) - - # Iteratively pop the next biggest difference until we find a combination that is valid (e.g., not already - # flagged as impossible by the simulator). - variable_value_by_diff = {} - diffs_as_keys = [] # list of diffs; index into list will be used as key values. - for _, _, diff in diffs: - already_keyed = False - for existing_diff in diffs_as_keys: - if np.isclose(existing_diff, diff): - already_keyed = True - break - if not already_keyed: - diffs_as_keys.append(diff) - for variable, value, diff in diffs: - key = None - for kidx in range(len(diffs_as_keys)): - if np.isclose(diffs_as_keys[kidx], diff): - key = kidx - if key not in variable_value_by_diff: - variable_value_by_diff[key] = [] - variable_value_by_diff[key].append((variable, value)) - - for key, diff in sorted(enumerate(diffs_as_keys), key=lambda x: x[1], reverse=True): - variable_value = variable_value_by_diff[key] - random.shuffle(variable_value) - for variable, value in variable_value: - - # Select a goal. - if variable == "goal": - gtype = value - # print("sampled goal '%s' with prob %.4f" % (gtype, goal_probs[goal_candidates.index(gtype)])) - _goal_candidates = [gtype] - - _pickup_candidates = pickup_candidates[:] - _movable_candidates = movable_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a pickup object. - elif variable == "pickup": - pickup_obj = value - # print("sampled pickup object '%s' with prob %.4f" % - # (pickup_obj, pickup_probs[pickup_candidates.index(pickup_obj)])) - _pickup_candidates = [pickup_obj] - - _goal_candidates = goal_candidates[:] - _movable_candidates = movable_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a movable object. - elif variable == "movable": - movable_obj = value - # print("sampled movable object '%s' with prob %.4f" % - # (movable_obj, movable_probs[movable_candidates.index(movable_obj)])) - _movable_candidates = [movable_obj] - _goal_candidates = [g for g in goal_candidates if g == 'pick_and_place_with_movable_recep'] - - _pickup_candidates = pickup_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a receptacle. - elif variable == "receptacle": - receptacle_obj = value - # print("sampled receptacle object '%s' with prob %.4f" % - # (receptacle_obj, receptacle_probs[receptacle_candidates.index(receptacle_obj)])) - _receptacle_candidates = [receptacle_obj] - - _goal_candidates = goal_candidates[:] - _pickup_candidates = pickup_candidates[:] - _movable_candidates = movable_candidates[:] - _scene_candidates = scene_candidates[:] - - # Select a scene. - else: - sampled_scene = value - # print("sampled scene %s with prob %.4f" % - # (sampled_scene, scene_probs[scene_candidates.index(sampled_scene)])) - _scene_candidates = [sampled_scene] - - _goal_candidates = goal_candidates[:] - _pickup_candidates = pickup_candidates[:] - _movable_candidates = movable_candidates[:] - _receptacle_candidates = receptacle_candidates[:] - # Perform constraint propagation to determine whether this is a valid assignment. - propagation_finished = False - while not propagation_finished: - assignment_lens = (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), - len(_receptacle_candidates), len(_scene_candidates)) - # Constraints on goal. - _goal_candidates = [g for g in _goal_candidates if - (g not in goal_to_pickup_type or - len(set(_pickup_candidates).intersection( # Pickup constraint. - constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]])) > 0) - and (g not in goal_to_receptacle_type or - np.any([r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]] - for r in _receptacle_candidates])) # Valid by goal receptacle const. - and (g not in goal_to_invalid_receptacle or - len(set(_receptacle_candidates).difference( - goal_to_invalid_receptacle[g])) > 0) # Invalid by goal receptacle const. - and len(set(_scene_candidates).intersection( - scenes_for_goal[g])) > 0 # Scene constraint - ] - - # Define whether to consider constraints for each role based on current set of candidate goals. - pickup_constrained = np.any(["pickup" in goal_to_required_variables[g] for g in _goal_candidates]) - movable_constrained = np.any(["movable" in goal_to_required_variables[g] for g in _goal_candidates]) - receptacle_constrained = np.any(["receptacle" in goal_to_required_variables[g] - for g in _goal_candidates]) - scene_constrained = np.any(["scene" in goal_to_required_variables[g] for g in _goal_candidates]) - - # Constraints on pickup obj. - _pickup_candidates = [p for p in _pickup_candidates if - np.any([g not in goal_to_pickup_type or - p in constants.VAL_ACTION_OBJECTS[goal_to_pickup_type[g]] - for g in _goal_candidates]) # Goal constraint. - and (not movable_constrained or - np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] - for m in _movable_candidates])) # Movable constraint. - and (not receptacle_constrained or - np.any([r in constants.VAL_ACTION_OBJECTS["Toggleable"] or - p in constants.VAL_RECEPTACLE_OBJECTS[r] - for r in _receptacle_candidates])) # Receptacle constraint. - and (not scene_constrained or - np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[p]] - for s in _scene_candidates])) # Scene constraint - ] - # Constraints on movable obj. - _movable_candidates = [m for m in _movable_candidates if - 'pick_and_place_with_movable_recep' in _goal_candidates # Goal constraint - and (not pickup_constrained or - np.any([p in constants.VAL_RECEPTACLE_OBJECTS[m] - for p in _pickup_candidates])) # Pickup constraint. - and (not receptacle_constrained or - np.any([r in constants.VAL_RECEPTACLE_OBJECTS and - m in constants.VAL_RECEPTACLE_OBJECTS[r] - for r in _receptacle_candidates])) # Receptacle constraint. - and (not scene_constrained or - np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[m]] - for s in _scene_candidates])) # Scene constraint - ] - # Constraints on receptacle obj. - _receptacle_candidates = [r for r in _receptacle_candidates if - np.any([(g not in goal_to_receptacle_type or - r in constants.VAL_ACTION_OBJECTS[goal_to_receptacle_type[g]]) and - (g not in goal_to_invalid_receptacle or - r not in goal_to_invalid_receptacle[g]) - for g in _goal_candidates]) # Goal constraint. - and (not receptacle_constrained or - r in constants.VAL_ACTION_OBJECTS["Toggleable"] or - np.any([p in constants.VAL_RECEPTACLE_OBJECTS[r] - for p in _pickup_candidates])) # Pickup constraint. - and (not movable_constrained or - r in constants.VAL_ACTION_OBJECTS["Toggleable"] or - np.any([m in constants.VAL_RECEPTACLE_OBJECTS[r] - for m in _movable_candidates])) # Movable constraint. - and (not scene_constrained or - np.any([s in obj_to_scene_ids[constants.OBJ_PARENTS[r]] - for s in _scene_candidates])) # Scene constraint - ] - # Constraints on scene. - _scene_candidates = [s for s in _scene_candidates if - np.any([s in scenes_for_goal[g] - for g in _goal_candidates]) # Goal constraint. - and (not pickup_constrained or - np.any([obj_to_scene_ids[constants.OBJ_PARENTS[p]] - for p in _pickup_candidates])) # Pickup constraint. - and (not movable_constrained or - np.any([obj_to_scene_ids[constants.OBJ_PARENTS[m]] - for m in _movable_candidates])) # Movable constraint. - and (not receptacle_constrained or - np.any([obj_to_scene_ids[constants.OBJ_PARENTS[r]] - for r in _receptacle_candidates])) # Receptacle constraint. - ] - if assignment_lens == (len(_goal_candidates), len(_pickup_candidates), len(_movable_candidates), - len(_receptacle_candidates), len(_scene_candidates)): - propagation_finished = True - - candidate_lens = {"goal": len(_goal_candidates), "pickup": len(_pickup_candidates), - "movable": len(_movable_candidates), "receptacle": len(_receptacle_candidates), - "scene": len(_scene_candidates)} - if candidate_lens["goal"] == 0: - # print("Goal over-constrained; skipping") - continue - if np.all([0 in [candidate_lens[v] for v in goal_to_required_variables[g]] for g in _goal_candidates]): - continue - - # Ensure some combination of the remaining constraints is not in failures and is not already populated - # by the target number of repeats. - failure_ensured = True - full_ensured = True - for g in _goal_candidates: - pickup_iter = _pickup_candidates if "pickup" in goal_to_required_variables[g] else ["None"] - for p in pickup_iter: - movable_iter = _movable_candidates if "movable" in goal_to_required_variables[g] else ["None"] - for m in movable_iter: - receptacle_iter = _receptacle_candidates if "receptacle" in goal_to_required_variables[g] \ - else ["None"] - for r in receptacle_iter: - scene_iter = _scene_candidates if "scene" in goal_to_required_variables[g] else ["None"] - for s in scene_iter: - if (g, p, m, r, s) not in fail_traj: - failure_ensured = False - if (g, p, m, r, s) not in full_traj: - full_ensured = False - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if not failure_ensured and not full_ensured: - break - if failure_ensured: - continue - if full_ensured: - continue - - if candidate_lens["goal"] > 1 or np.any([np.any([candidate_lens[v] > 1 - for v in goal_to_required_variables[g]]) - for g in _goal_candidates]): - task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, - _goal_candidates, _pickup_candidates, _movable_candidates, - _receptacle_candidates, _scene_candidates) - sampled_task = next(task_sampler) - if sampled_task is None: - continue - else: - g = _goal_candidates[0] - p = _pickup_candidates[0] if "pickup" in goal_to_required_variables[g] else "None" - m = _movable_candidates[0] if "movable" in goal_to_required_variables[g] else "None" - r = _receptacle_candidates[0] if "receptacle" in goal_to_required_variables[g] else "None" - s = _scene_candidates[0] if "scene" in goal_to_required_variables[g] else "None" - sampled_task = (g, p, m, r, int(s)) - - yield sampled_task - - yield None # Discovered that there are no valid assignments remaining. - - -def print_successes(succ_traj): - print("###################################\n") - print("Successes: ") - print(succ_traj) - print("\n##################################") - - -def main(args, thread_num=0): - - print(thread_num) - # settings - alfred_dataset_path = '../data/json_2.1.0/train' - - constants.DATA_SAVE_PATH = args.save_path - print("Force Unsave Data: %s" % str(args.force_unsave)) - - # Set up data structure to track dataset balance and use for selecting next parameters. - # In actively gathering data, we will try to maximize entropy for each (e.g., uniform spread of goals, - # uniform spread over patient objects, uniform recipient objects, and uniform scenes). - succ_traj = pd.DataFrame(columns=["goal", "pickup", "movable", "receptacle", "scene"]) - - # objects-to-scene and scene-to-objects database - for scene_type, ids in constants.SCENE_TYPE.items(): - for id in ids: - obj_json_file = os.path.join('layouts', 'FloorPlan%d-objects.json' % id) - with open(obj_json_file, 'r') as of: - scene_objs = json.load(of) - - id_str = str(id) - scene_id_to_objs[id_str] = scene_objs - for obj in scene_objs: - if obj not in obj_to_scene_ids: - obj_to_scene_ids[obj] = set() - obj_to_scene_ids[obj].add(id_str) - - # scene-goal database - for g in constants.GOALS: - for st in constants.GOALS_VALID[g]: - scenes_for_goal[g].extend([str(s) for s in constants.SCENE_TYPE[st]]) - scenes_for_goal[g] = set(scenes_for_goal[g]) - - # scene-type database - for st in constants.SCENE_TYPE: - for s in constants.SCENE_TYPE[st]: - scene_to_type[str(s)] = st - - # pre-populate counts in this structure using saved trajectories path. - succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, args.just_examine, args.repeats_per_cond) - if args.just_examine: - print_successes(succ_traj) - return - - print(succ_traj.groupby('goal').count()) - # pre-populate failed trajectories. - fail_traj = load_fails_from_disk(args.save_path) - print("Loaded %d known failed tuples" % len(fail_traj)) - - # create env and agent - env = ThorEnv(x_display='0.%d' %(thread_num % 2)) - - game_state = TaskGameStateFullKnowledge(env) - agent = DeterministicPlannerAgent(thread_id=0, game_state=game_state) - - errors = {} # map from error strings to counts, to be shown after every failure. - goal_candidates = constants.GOALS[:] - pickup_candidates = list(set().union(*[constants.VAL_RECEPTACLE_OBJECTS[obj] # Union objects that can be placed. - for obj in constants.VAL_RECEPTACLE_OBJECTS])) - pickup_candidates = [p for p in pickup_candidates if constants.OBJ_PARENTS[p] in obj_to_scene_ids] - movable_candidates = list(set(constants.MOVABLE_RECEPTACLES).intersection(obj_to_scene_ids.keys())) - receptacle_candidates = [obj for obj in constants.VAL_RECEPTACLE_OBJECTS - if obj not in constants.MOVABLE_RECEPTACLES and obj in obj_to_scene_ids] + \ - [obj for obj in constants.VAL_ACTION_OBJECTS["Toggleable"] - if obj in obj_to_scene_ids] - - # toaster isn't interesting in terms of producing linguistic diversity - receptacle_candidates.remove('Toaster') - receptacle_candidates.sort() - - scene_candidates = list(scene_id_to_objs.keys()) - - n_until_load_successes = args.async_load_every_n_samples - print_successes(succ_traj) - task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, - goal_candidates, pickup_candidates, movable_candidates, - receptacle_candidates, scene_candidates) - - # main generation loop - # keeps trying out new task tuples as trajectories either fail or suceed - while True: - # for _ in range(20): - for ii, json_path in enumerate(glob.iglob(os.path.join(alfred_dataset_path, "**", "traj_data.json"), recursive=True)): - # if ii % args.num_threads == thread_num: - # if ii == 5: - sampled_task = json_path.split('/')[-3].split('-') - # sampled_task = next(task_sampler) - # print("===============") - # print(ii, json_path) - print(sampled_task) # DEBUG - # print("===============") - - if sampled_task is None: - sys.exit("No valid tuples left to sample (all are known to fail or already have %d trajectories" % - args.repeats_per_cond) - gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene = sampled_task - - sampled_scene = int(sampled_scene) - print("sampled tuple: " + str((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene))) - - tries_remaining = args.trials_before_fail - # only try to get the number of trajectories left to make this tuple full. - target_remaining = args.repeats_per_cond - len(succ_traj.loc[(succ_traj['goal'] == gtype) & - (succ_traj['pickup'] == pickup_obj) & - (succ_traj['movable'] == movable_obj) & - (succ_traj['receptacle'] == receptacle_obj) & - (succ_traj['scene'] == str(sampled_scene))]) - num_place_fails = 0 # count of errors related to placement failure for no valid positions. - - # continue until we're (out of tries + have never succeeded) or (have gathered the target number of instances) - while num_place_fails > args.trials_before_fail or target_remaining > 0: - - # environment setup - constants.pddl_goal_type = gtype - print("PDDLGoalType: " + constants.pddl_goal_type) - task_id = create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene) - - # setup data dictionary - setup_data_dict() - constants.data_dict['task_id'] = task_id - constants.data_dict['task_type'] = constants.pddl_goal_type - constants.data_dict['dataset_params']['video_frame_rate'] = constants.VIDEO_FRAME_RATE - - # plan & execute - try: - # if True: - # Agent reset to new scene. - constraint_objs = {'repeat': [(constants.OBJ_PARENTS[pickup_obj], # Generate multiple parent objs. - np.random.randint(2 if gtype == "pick_two_obj_and_place" else 1, - constants.PICKUP_REPEAT_MAX + 1))], - 'sparse': [(receptacle_obj.replace('Basin', ''), - num_place_fails * constants.RECEPTACLE_SPARSE_POINTS)]} - if movable_obj != "None": - constraint_objs['repeat'].append((movable_obj, - np.random.randint(1, constants.PICKUP_REPEAT_MAX + 1))) - for obj_type in scene_id_to_objs[str(sampled_scene)]: - if (obj_type in pickup_candidates and - obj_type != constants.OBJ_PARENTS[pickup_obj] and obj_type != movable_obj): - constraint_objs['repeat'].append((obj_type, - np.random.randint(1, constants.MAX_NUM_OF_OBJ_INSTANCES + 1))) - if gtype in goal_to_invalid_receptacle: - constraint_objs['empty'] = [(r.replace('Basin', ''), num_place_fails * constants.RECEPTACLE_EMPTY_POINTS) - for r in goal_to_invalid_receptacle[gtype]] - constraint_objs['seton'] = [] - if gtype == 'look_at_obj_in_light': - constraint_objs['seton'].append((receptacle_obj, False)) - if num_place_fails > 0: - print("Failed %d placements in the past; increased free point constraints: " % num_place_fails - + str(constraint_objs)) - scene_info = {'scene_num': sampled_scene, 'random_seed': random.randint(0, 2 ** 32)} - info = agent.reset(scene=scene_info, - objs=constraint_objs) - - # Problem initialization with given constraints. - task_objs = {'pickup': pickup_obj} - if movable_obj != "None": - task_objs['mrecep'] = movable_obj - if gtype == "look_at_obj_in_light": - task_objs['toggle'] = receptacle_obj - else: - task_objs['receptacle'] = receptacle_obj - agent.setup_problem({'info': info}, scene=scene_info, objs=task_objs) - - # Now that objects are in their initial places, record them. - object_poses = [{'objectName': obj['name'].split('(Clone)')[0], - 'position': obj['position'], - 'rotation': obj['rotation']} - for obj in env.last_event.metadata['objects'] if obj['pickupable']] - dirty_and_empty = gtype == 'pick_clean_then_place_in_recep' - object_toggles = [{'objectType': o, 'stateChange': 'toggleable', 'isToggled': v} - for o, v in constraint_objs['seton']] - constants.data_dict['scene']['object_poses'] = object_poses - constants.data_dict['scene']['dirty_and_empty'] = dirty_and_empty - constants.data_dict['scene']['object_toggles'] = object_toggles - - # Pre-restore the scene to cause objects to "jitter" like they will when the episode is replayed - # based on stored object and toggle info. This should put objects closer to the final positions they'll - # be inlay at inference time (e.g., mugs fallen and broken, knives fallen over, etc.). - print("Performing reset via thor_env API") - env.reset(sampled_scene) - print("Performing restore via thor_env API") - env.restore_scene(object_poses, object_toggles, dirty_and_empty) - event = env.step(dict(constants.data_dict['scene']['init_action'])) - - terminal = False - while not terminal and agent.current_frame_count <= constants.MAX_EPISODE_LENGTH: - action_dict = agent.get_action(None) - agent.step(action_dict) - reward, terminal = agent.get_reward() - - dump_data_dict() - save_video() - # else: - except Exception as e: - import traceback - traceback.print_exc() - print("Error: " + repr(e)) - print("Invalid Task: skipping...") - if args.debug: - print(traceback.format_exc()) - - deleted = delete_save(args.in_parallel) - if not deleted: # another thread is filling this task successfully, so leave it alone. - target_remaining = 0 # stop trying to do this task. - else: - if str(e) == "API Action Failed: No valid positions to place object found": - # Try increasing the space available on sparse and empty flagged objects. - num_place_fails += 1 - tries_remaining -= 1 - else: # generic error - tries_remaining -= 1 - - estr = str(e) - if len(estr) > 120: - estr = estr[:120] - if estr not in errors: - errors[estr] = 0 - errors[estr] += 1 - print("%%%%%%%%%%") - es = sum([errors[er] for er in errors]) - print("\terrors (%d):" % es) - for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): - if v / es < 0.01: # stop showing below 1% of errors. - break - print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) - print("%%%%%%%%%%") - - continue - - if args.force_unsave: - delete_save(args.in_parallel) - - # add to save structure. - succ_traj = succ_traj.append({ - "goal": gtype, - "movable": movable_obj, - "pickup": pickup_obj, - "receptacle": receptacle_obj, - "scene": str(sampled_scene)}, ignore_index=True) - target_remaining -= 1 - tries_remaining += args.trials_before_fail # on success, add more tries for future successes - - # if this combination resulted in a certain number of failures with no successes, flag it as not possible. - if tries_remaining == 0 and target_remaining == args.repeats_per_cond: - new_fails = [(gtype, pickup_obj, movable_obj, receptacle_obj, str(sampled_scene))] - fail_traj = load_fails_from_disk(args.save_path, to_write=new_fails) - print("%%%%%%%%%%") - print("failures (%d)" % len(fail_traj)) - # print("\t" + "\n\t".join([str(ft) for ft in fail_traj])) - print("%%%%%%%%%%") - - # if this combination gave us the repeats we wanted, note it as filled. - if target_remaining == 0: - full_traj.add((gtype, pickup_obj, movable_obj, receptacle_obj, sampled_scene)) - - # if we're sharing with other processes, reload successes from disk to update local copy with others' additions. - if args.in_parallel: - if n_until_load_successes > 0: - n_until_load_successes -= 1 - else: - print("Reloading trajectories from disk because of parallel processes...") - succ_traj = pd.DataFrame(columns=succ_traj.columns) # Drop all rows. - succ_traj, full_traj = load_successes_from_disk(args.save_path, succ_traj, False, args.repeats_per_cond) - print("... Loaded %d trajectories" % len(succ_traj.index)) - n_until_load_successes = args.async_load_every_n_samples - print_successes(succ_traj) - task_sampler = sample_task_params(succ_traj, full_traj, fail_traj, - goal_candidates, pickup_candidates, movable_candidates, - receptacle_candidates, scene_candidates) - print("... Created fresh instance of sample_task_params generator") - - -def create_dirs(gtype, pickup_obj, movable_obj, receptacle_obj, scene_num): - task_id = 'trial_T' + datetime.now().strftime("%Y%m%d_%H%M%S_%f") - save_name = '%s-%s-%s-%s-%d' % (gtype, pickup_obj, movable_obj, receptacle_obj, scene_num) + '/' + task_id - - constants.save_path = os.path.join(constants.DATA_SAVE_PATH, save_name, RAW_IMAGES_FOLDER) - constants.save_depth_path = os.path.join(constants.DATA_SAVE_PATH, save_name, DEPTH_IMAGES_FOLDER) - - if not os.path.exists(constants.save_path): - os.makedirs(constants.save_path) - - if not os.path.exists(constants.save_depth_path): - os.makedirs(constants.save_depth_path) - - print("Saving images to: " + constants.save_path) - return task_id - - -def save_video(): - images_path = constants.save_path + '*.png' - video_path = os.path.join(constants.save_path.replace(RAW_IMAGES_FOLDER, ''), 'video.mp4') - video_saver.save(images_path, video_path) - - -def setup_data_dict(): - constants.data_dict = OrderedDict() - constants.data_dict['task_id'] = "" - constants.data_dict['task_type'] = "" - constants.data_dict['scene'] = {'floor_plan': "", 'random_seed': -1, 'scene_num': -1, 'init_action': [], - 'object_poses': [], 'dirty_and_empty': None, 'object_toggles': []} - constants.data_dict['plan'] = {'high_pddl': [], 'low_actions': []} - constants.data_dict['images'] = [] - constants.data_dict['template'] = {'task_desc': "", 'high_descs': []} - constants.data_dict['pddl_params'] = {'object_target': -1, 'object_sliced': -1, - 'parent_target': -1, 'toggle_target': -1, - 'mrecep_target': -1} - constants.data_dict['dataset_params'] = {'video_frame_rate': -1} - constants.data_dict['pddl_state'] = [] - - -def dump_data_dict(): - data_save_path = constants.save_path.replace(RAW_IMAGES_FOLDER, '') - with open(os.path.join(data_save_path, DATA_JSON_FILENAME), 'w') as fp: - json.dump(constants.data_dict, fp, sort_keys=True, indent=4) - - -def delete_save(in_parallel): - save_folder = constants.save_path.replace(RAW_IMAGES_FOLDER, '') - if os.path.exists(save_folder): - try: - shutil.rmtree(save_folder) - except OSError as e: - if in_parallel: # another thread succeeded at this task while this one failed. - return False - else: - raise e # if we're not running in parallel, this is an actual. - return True - - -def parallel_main(args): - procs = [mp.Process(target=main, args=(args,thread_num)) for thread_num in range(args.num_threads)] - try: - for proc in procs: - proc.start() - time.sleep(0.1) - finally: - for proc in procs: - proc.join() - - -if __name__ == "__main__": - parser = argparse.ArgumentParser() - - # settings - parser.add_argument('--force_unsave', action='store_true', help="don't save any data (for debugging purposes)") - parser.add_argument('--debug', action='store_true') - parser.add_argument('--save_path', type=str, default="dataset/new_trajectories_valid_seen", help="where to save the generated data") - parser.add_argument('--x_display', type=str, required=False, default=constants.X_DISPLAY, help="x_display id") - parser.add_argument("--just_examine", action='store_true', help="just examine what data is gathered; don't gather more") - parser.add_argument("--in_parallel", action='store_true', help="this collection will run in parallel with others, so load from disk on every new sample") - parser.add_argument("-n", "--num_threads", type=int, default=1, help="number of processes for parallel mode") - parser.add_argument('--json_file', type=str, default="", help="path to json file with trajectory dump") - - # params - parser.add_argument("--repeats_per_cond", type=int, default=3) - parser.add_argument("--trials_before_fail", type=int, default=5) - parser.add_argument("--async_load_every_n_samples", type=int, default=10) - parser.add_argument('--gpu_id', type=int, default=0) - - parse_args = parser.parse_args() - - # if parse_args.in_parallel and parse_args.num_threads > 1: - # parallel_main(parse_args) - # else: - main(parse_args) diff --git a/gen/scripts/replay_checks.py b/gen/scripts/replay_checks.py deleted file mode 100644 index b0d31e82d..000000000 --- a/gen/scripts/replay_checks.py +++ /dev/null @@ -1,217 +0,0 @@ -import os -import sys -# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'])) -# sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen')) -sys.path.append(os.path.join('/home/jiasenl/code/alfred')) -sys.path.append(os.path.join('/home/jiasenl/code/alfred', 'gen')) - -import argparse -import json -import numpy as np -import shutil -import time -from env.thor_env import ThorEnv -from utils.replay_json import replay_json -import multiprocessing as mp -import time - - -JSON_FILENAME = "traj_data.json" - - -def parallel_replay_check(args): - procs = [mp.Process(target=replay_check, args=(args, thread_num)) for thread_num in range(args.num_threads)] - try: - for proc in procs: - proc.start() - time.sleep(0.1) - finally: - for proc in procs: - proc.join() - -def replay_check(args, thread_num=0): - env = ThorEnv(x_display='0.%d' %(thread_num % args.total_gpu)) - - # replay certificate filenames - replay_certificate_filenames = ["replay.certificate.%d" % idx for idx in range(args.num_replays)] - - # Clear existing failures in file recording. - if args.failure_filename is not None: - with open(args.failure_filename, 'w') as f: - f.write('') - - continue_check = True - total_checks, total_failures, crash_fails, unsat_fails, json_fails, nondet_fails = 0, 0, 0, 0, 0, 0 - errors = {} # map from error strings to counts, to be shown after every failure. - total_threads = args.total_gpu * args.num_threads - current_threads = args.gpu_id * args.num_threads + thread_num - - while continue_check: - - # Crawl the directory of trajectories and vet ones with no certificate. - failure_list = [] - valid_dirs = [] - count = 0 - for dir_name, subdir_list, file_list in os.walk(args.data_path): - if "trial_" in dir_name and (not "raw_images" in dir_name) and (not "pddl_states" in dir_name): - json_file = os.path.join(dir_name, JSON_FILENAME) - if not os.path.isfile(json_file): - continue - - # If we're just stripping certificates, do that and continue. - if args.remove_certificates: - for cidx in range(args.num_replays): - certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) - if os.path.isfile(certificate_file): - os.system("rm %s" % certificate_file) - continue - - if count % total_threads == current_threads: - valid_dirs.append(dir_name) - count += 1 - - print(len(valid_dirs)) - np.random.shuffle(valid_dirs) - for ii, dir_name in enumerate(valid_dirs): - - if not os.path.exists(dir_name): - continue - - json_file = os.path.join(dir_name, JSON_FILENAME) - if not os.path.isfile(json_file): - continue - - cidx = 0 - certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) - already_checked = False - while os.path.isfile(certificate_file): - cidx += 1 - if cidx == args.num_replays: - already_checked = True - break - certificate_file = os.path.join(dir_name, replay_certificate_filenames[cidx]) - if already_checked: - continue - - print(ii) - if not os.path.isfile(certificate_file): - total_checks += 1. / args.num_replays - failed = False - - with open(json_file) as f: - print("check %d/%d for file '%s'" % (cidx + 1, args.num_replays, json_file)) - try: - traj_data = json.load(f) - env.set_task(traj_data, args, reward_type='dense') - except json.decoder.JSONDecodeError: - failed = True - json_fails += 1 - - if not failed: - steps_taken = None - try: - steps_taken = replay_json(env, json_file) - except Exception as e: - import traceback - traceback.print_exc() - failed = True - crash_fails += 1 - - if str(e) not in errors: - errors[str(e)] = 0 - errors[str(e)] += 1 - print("%%%%%%%%%%") - es = sum([errors[er] for er in errors]) - print("\terrors (%d):" % es) - for er, v in sorted(errors.items(), key=lambda kv: kv[1], reverse=True): - # if v / es < 0.01: # stop showing below 1% of errors. - # break - print("\t(%.2f) (%d)\t%s" % (v / es, v, er)) - print("%%%%%%%%%%") - - if cidx > 1: - print("WARNING: replay that has succeeded before has failed at attempt %d" - % cidx) - nondet_fails += 1 - - if steps_taken is not None: # executed without crashing, so now we need to verify completion. - goal_satisfied = env.get_goal_satisfied() - - if goal_satisfied: - with open(certificate_file, 'w') as f: - f.write('%d' % steps_taken) - else: - failed = True - unsat_fails += 1 - print("Goal was not satisfied after execution!") - - if failed: - # Mark one failure and count the remainder of checks for this instance into the total. - total_failures += 1 - total_checks += args.num_replays - ((cidx + 1) / float(args.num_replays)) - - failure_list.append(json_file) - if args.failure_filename is not None: - with open(args.failure_filename, 'a') as f: - f.write("%s\n" % json_file) - # If we're deleting bad trajectories, do that here. - if args.move_failed_trajectories is not None: - print("Relocating failed trajectory '%s' to '%s'" % - (dir_name, os.path.join(args.move_failed_trajectories))) - try: - shutil.move(dir_name, args.move_failed_trajectories) - except shutil.Error as e: - print("WARNING: failed to perform move; error follows; deleting instead") - print(repr(e)) - shutil.rmtree(dir_name) - if args.remove_failed_trajectories: - print("Removing failed trajectory '%s'" % dir_name) - shutil.rmtree(dir_name) - - print("-------------------------") - print("Success Rate: %.2f/%.2f = %.3f" % - (total_checks - total_failures, total_checks, - float(total_checks - total_failures) / float(total_checks))) - if total_failures > 0: - print("Non-deterministic failure: %d/%d = %.3f" % (nondet_fails, total_failures, - float(nondet_fails) / total_failures)) - print("Failures by crash: %d/%d = %.3f" % (crash_fails, total_failures, - float(crash_fails) / total_failures)) - print("Failures by unsatisfied: %d/%d = %.3f" % (unsat_fails, total_failures, - float(unsat_fails) / total_failures)) - print("Failures by json decode error: %d/%d = %.3f" % (json_fails, total_failures, - float(json_fails) / total_failures)) - print("-------------------------") - - if not args.in_parallel: - continue_check = False - else: - time.sleep(60) - - -if __name__ == "__main__": - parser = argparse.ArgumentParser() - parser.add_argument('--data_path', type=str, default="dataset/2.1.0", - help="where to look for the generated data") - parser.add_argument("--failure_filename", type=str, required=False, - help="where to write failed trajectory dirs as strings, if anywhere") - parser.add_argument("--remove_failed_trajectories", dest='remove_failed_trajectories', action='store_true', - help="delete trajectory trials if they fail replay") - parser.add_argument("--move_failed_trajectories", type=str, required=False, - help="if given, relocate failed trajectories to this directory") - parser.add_argument("--remove_certificates", dest='remove_certificates', action='store_true', - help="instead of vetting trajectories, remove all vetting certificates") - parser.add_argument("--in_parallel", dest='in_parallel', action='store_true', - help="whether to run this script with parallel generation scripts in mind") - parser.add_argument('--reward_config', default='../models/config/rewards.json') - parser.add_argument('--num_replays', type=int, default=1) - parser.add_argument('--gpu_id', type=int, default=0) - parser.add_argument('--total_gpu', type=int, default=2) - parser.add_argument('--num_threads', type=int, default=2) - args = parser.parse_args() - - if args.num_threads > 1: - parallel_replay_check(args) - else: - replay_check(args) - diff --git a/gen/utils/__init__.py b/gen/utils/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/gen/utils/bb_util.py b/gen/utils/bb_util.py deleted file mode 100644 index 46b574b69..000000000 --- a/gen/utils/bb_util.py +++ /dev/null @@ -1,139 +0,0 @@ -import numbers -import numpy as np - -LIMIT = 99999999 - -def clip_bbox(bboxes, min_clip, max_x_clip, max_y_clip): - ''' - # BBoxes are [x1, y1, x2, y2] - ''' - bboxes_out = bboxes - added_axis = False - if len(bboxes_out.shape) == 1: - added_axis = True - bboxes_out = bboxes_out[:, np.newaxis] - bboxes_out[[0, 2], ...] = np.clip(bboxes_out[[0, 2], ...], min_clip, max_x_clip) - bboxes_out[[1, 3], ...] = np.clip(bboxes_out[[1, 3], ...], min_clip, max_y_clip) - if added_axis: - bboxes_out = bboxes_out[:, 0] - return bboxes_out - - -def xyxy_to_xywh(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): - ''' - [x1 y1, x2, y2] to [xMid, yMid, width, height] - ''' - added_axis = False - if isinstance(bboxes, list): - bboxes = np.array(bboxes).astype(np.float32) - if len(bboxes.shape) == 1: - added_axis = True - bboxes = bboxes[:, np.newaxis] - bboxes_out = np.zeros(bboxes.shape) - x1 = bboxes[0, ...] - y1 = bboxes[1, ...] - x2 = bboxes[2, ...] - y2 = bboxes[3, ...] - bboxes_out[0, ...] = (x1 + x2) / 2.0 - bboxes_out[1, ...] = (y1 + y2) / 2.0 - bboxes_out[2, ...] = x2 - x1 - bboxes_out[3, ...] = y2 - y1 - if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: - bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) - if bboxes_out.shape[0] > 4: - bboxes_out[4:, ...] = bboxes[4:, ...] - if added_axis: - bboxes_out = bboxes_out[:, 0] - if round: - bboxes_out = np.round(bboxes_out).astype(int) - return bboxes_out - - -def xywh_to_xyxy(bboxes, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False): - ''' - [xMid, yMid, width, height] to [x1 y1, x2, y2] - ''' - added_axis = False - if isinstance(bboxes, list): - bboxes = np.array(bboxes).astype(np.float32) - if len(bboxes.shape) == 1: - added_axis = True - bboxes = bboxes[:, np.newaxis] - bboxes_out = np.zeros(bboxes.shape) - x_mid = bboxes[0, ...] - y_mid = bboxes[1, ...] - width = bboxes[2, ...] - height = bboxes[3, ...] - bboxes_out[0, ...] = x_mid - width / 2.0 - bboxes_out[1, ...] = y_mid - height / 2.0 - bboxes_out[2, ...] = x_mid + width / 2.0 - bboxes_out[3, ...] = y_mid + height / 2.0 - if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: - bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) - if bboxes_out.shape[0] > 4: - bboxes_out[4:, ...] = bboxes[4:, ...] - if added_axis: - bboxes_out = bboxes_out[:, 0] - if round: - bboxes_out = np.round(bboxes_out).astype(int) - return bboxes_out - - -def scale_bbox(bboxes, scalars, clip_min=-LIMIT, clip_width=LIMIT, clip_height=LIMIT, round=False, in_place=False): - ''' - @bboxes {np.array} 4xn array of boxes to be scaled - @scalars{number or arraylike} scalars for width and height of boxes - @in_place{bool} If false, creates new bboxes. - ''' - added_axis = False - if isinstance(bboxes, list): - bboxes = np.array(bboxes, dtype=np.float32) - if len(bboxes.shape) == 1: - added_axis = True - bboxes = bboxes[:, np.newaxis] - if isinstance(scalars, numbers.Number): - scalars = np.full((2, bboxes.shape[1]), scalars, dtype=np.float32) - if not isinstance(scalars, np.ndarray): - scalars = np.array(scalars, dtype=np.float32) - if len(scalars.shape) == 1: - scalars = np.tile(scalars[:, np.newaxis], (1, bboxes.shape[1])) - - width = bboxes[2, ...] - bboxes[0, ...] - height = bboxes[3, ...] - bboxes[1, ...] - x_mid = (bboxes[0, ...] + bboxes[2, ...]) / 2.0 - y_mid = (bboxes[1, ...] + bboxes[3, ...]) / 2.0 - if not in_place: - bboxes_out = bboxes.copy() - else: - bboxes_out = bboxes - - bboxes_out[0, ...] = x_mid - width * scalars[0, ...] / 2.0 - bboxes_out[1, ...] = y_mid - height * scalars[1, ...] / 2.0 - bboxes_out[2, ...] = x_mid + width * scalars[0, ...] / 2.0 - bboxes_out[3, ...] = y_mid + height * scalars[1, ...] / 2.0 - - if clip_min != -LIMIT or clip_width != LIMIT or clip_height != LIMIT: - bboxes_out = clip_bbox(bboxes_out, clip_min, clip_width, clip_height) - if added_axis: - bboxes_out = bboxes_out[:, 0] - if round: - bboxes_out = np.round(bboxes_out).astype(int) - return bboxes_out - - -def make_square(bboxes, in_place=False): - if isinstance(bboxes, list): - bboxes = np.array(bboxes).astype(np.float32) - if len(bboxes.shape) == 1: - num_boxes = 1 - width = bboxes[2] - bboxes[0] - height = bboxes[3] - bboxes[1] - else: - num_boxes = bboxes.shape[1] - width = bboxes[2, ...] - bboxes[0, ...] - height = bboxes[3, ...] - bboxes[1, ...] - max_size = np.maximum(width, height) - scalars = np.zeros((2, num_boxes)) - scalars[0, ...] = max_size * 1.0 / width - scalars[1, ...] = max_size * 1.0 / height - return scale_bbox(bboxes, scalars, in_place=in_place) diff --git a/gen/utils/dataset_management_util.py b/gen/utils/dataset_management_util.py deleted file mode 100644 index de13fa535..000000000 --- a/gen/utils/dataset_management_util.py +++ /dev/null @@ -1,69 +0,0 @@ -import os -import shutil - - -def load_successes_from_disk(succ_dir, succ_traj, prune_trials, target_count, - cap_count=None, min_count=None): - tuple_counts = {} - for root, dirs, files in os.walk(succ_dir): - for d in dirs: - if d.count('-') == 4: - goal, pickup, movable, receptacle, scene_num = d.split('-') - # Add an entry for every successful trial folder in the directory. - queue_for_delete = [] - deleted_all = True - for _, _dirs, _ in os.walk(os.path.join(succ_dir, d)): - for _d in _dirs: - for _, _, _files in os.walk(os.path.join(succ_dir, d, _d)): - if 'video.mp4' in _files: - k = (goal, pickup, movable, receptacle, scene_num) - if k not in tuple_counts: - tuple_counts[k] = 0 - tuple_counts[k] += 1 - deleted_all = False - else: - queue_for_delete.append(_d) - break # only examine top level - break # only examine top level - if prune_trials: - if deleted_all: - print("Removing trial-less parent dir '%s'" % os.path.join(succ_dir, d)) - shutil.rmtree(os.path.join(succ_dir, d)) - else: - for _d in queue_for_delete: - print("Removing unfinished trial '%s'" % os.path.join(succ_dir, d, _d)) - shutil.rmtree(os.path.join(succ_dir, d, _d)) - break # only examine top level - - # Populate dataframe based on tuple constraints. - for k in tuple_counts: - if min_count is None or tuple_counts[k] >= min_count: - to_add = tuple_counts[k] if cap_count is None else cap_count - for _ in range(to_add): - succ_traj = succ_traj.append({ - "goal": k[0], - "pickup": k[1], - "movable": k[2], - "receptacle": k[3], - "scene": k[4]}, ignore_index=True) - tuples_at_target_count = set([t for t in tuple_counts if tuple_counts[t] >= target_count]) - - return succ_traj, tuples_at_target_count - - -def load_fails_from_disk(succ_dir, to_write=None): - fail_traj = set() - fail_dir = os.path.join(succ_dir, "fails") - if not os.path.isdir(fail_dir): - os.makedirs(fail_dir) - if to_write is not None: - for goal, pickup, movable, receptacle, scene_num in to_write: - with open(os.path.join(fail_dir, '-'.join([goal, pickup, movable, receptacle, scene_num])), 'w') as f: - f.write("0") - for root, dirs, files in os.walk(fail_dir): - for fn in files: - if fn.count('-') == 4: - goal, pickup, movable, receptacle, scene_num = fn.split('-') - fail_traj.add((goal, pickup, movable, receptacle, scene_num)) - break # only examine top level - return fail_traj diff --git a/gen/utils/game_util.py b/gen/utils/game_util.py deleted file mode 100644 index 476ef5122..000000000 --- a/gen/utils/game_util.py +++ /dev/null @@ -1,363 +0,0 @@ -import copy -import random -import cv2 -import numpy as np -import constants -import goal_library as glib - - -def get_pose(event): - pose = event.pose - return (int(np.round(pose[0] / (1000 * constants.AGENT_STEP_SIZE))), - int(np.round(pose[1] / (1000 * constants.AGENT_STEP_SIZE))), - int(np.round(pose[2] / (1000 * 90))), - int(np.round(pose[3] / (1000)))) - - -def get_object_data(metadata): - return [ - {"objectName": obj["name"].split("(Clone)")[0], "position": obj["position"], "rotation": obj["rotation"]} - for obj in metadata["objects"] - if obj["pickupable"] - ] - - -def imresize(image, size, rescale=True): - if image is None: - return None - if image.shape[0] != size[0] or image.shape[1] != size[1]: - image = cv2.resize(image, size) - if rescale: - if image.dtype != np.float32: - image = image.astype(np.float32) - image /= 255.0 - return image - - -def depth_imresize(image, size, rescale=True, max_depth=constants.MAX_DEPTH): - if image is None: - return None - if image.shape[0] != size[0] or image.shape[1] != size[1]: - image = cv2.resize(image, size) - image[image > max_depth] = max_depth - if rescale: - if image.dtype != np.float32: - image = image.astype(np.float32) - image /= max_depth - return image - - -def get_camera_matrix(pose, camera_height): - assert(pose[2] in {0, 1, 2, 3}) - sin_x = np.sin(pose[3] * np.pi / 180) - cos_x = np.cos(pose[3] * np.pi / 180) - x_rotation = np.matrix([ - [1, 0, 0], - [0, cos_x, -sin_x], - [0, sin_x, cos_x]]) - sin_y = np.sin(pose[2] * np.pi / 180) - cos_y = np.cos(pose[2] * np.pi / 180) - y_rotation = np.matrix([ - [cos_y, 0, sin_y], - [0, 1, 0], - [-sin_y, 0, cos_y]]) - rotation_matrix = np.matmul(x_rotation, y_rotation) - transformation_matrix = np.matrix([pose[0], camera_height, pose[1], 1]).T - extrinsic_matrix = np.concatenate((np.concatenate((rotation_matrix, np.matrix([0, 0, 0])), axis=0), - transformation_matrix), axis=1) - return extrinsic_matrix - - -def get_rotation_matrix(pose): - assert(pose[2] in {0, 1, 2, 3}), 'rotation was %s' % str(pose[2]) - sin_x = np.sin(-pose[3] * np.pi / 180) - cos_x = np.cos(-pose[3] * np.pi / 180) - x_rotation = np.matrix([ - [1, 0, 0], - [0, cos_x, -sin_x], - [0, sin_x, cos_x]], dtype=np.float32) - sin_y = np.sin((-pose[2] % 4) * 90 * np.pi / 180) - cos_y = np.cos((-pose[2] % 4) * 90 * np.pi / 180) - y_rotation = np.matrix([ - [cos_y, 0, sin_y], - [0, 1, 0], - [-sin_y, 0, cos_y]], dtype=np.float32) - rotation_matrix = np.matmul(x_rotation, y_rotation) - return rotation_matrix - - -def depth_to_world_coordinates(depth, pose, camera_height): - x_points = np.arange(-constants.SCREEN_WIDTH / 2, constants.SCREEN_WIDTH / 2, dtype=depth.dtype) - x_vals = (depth * x_points / constants.FOCAL_LENGTH) - - y_points = np.arange(constants.SCREEN_HEIGHT / 2, -constants.SCREEN_HEIGHT / 2, -1, dtype=depth.dtype) - y_vals = (depth.T * y_points / constants.FOCAL_LENGTH).T - - z_vals = depth - xyz = np.stack((x_vals, y_vals, z_vals), axis=2) / (1000 * constants.AGENT_STEP_SIZE) - rotation_matrix = np.linalg.inv(get_rotation_matrix(pose)) - xyz = np.array(np.dot(rotation_matrix, xyz.reshape(-1, 3).T).T).reshape( - constants.SCREEN_HEIGHT, constants.SCREEN_WIDTH, 3) - xzy = xyz[:, :, [0, 2, 1]] - xzy += np.array([pose[0], pose[1], camera_height]) - return xzy - - -# coordinates should be [n, (xzy)] -def world_to_camera_coordinates(coordinates, pose, camera_height): - coordinates = coordinates.copy() - coordinates -= np.array([pose[0], pose[1], camera_height]) - xyz = coordinates[:, [0, 2, 1]] # [n, (xyz)] - rotation_matrix = get_rotation_matrix(pose) - xyd = np.array(np.dot(rotation_matrix, xyz.T).T) - xyd *= (1000 * constants.AGENT_STEP_SIZE) - depth = np.maximum(xyd[:, -1], 0.01) - x_points = xyd[:, 0] * constants.FOCAL_LENGTH / depth + constants.SCREEN_WIDTH / 2 - y_points = constants.SCREEN_HEIGHT - (xyd[:, 1] * constants.FOCAL_LENGTH / depth + constants.SCREEN_HEIGHT / 2) - return np.stack((x_points, y_points, depth)).T - - -def get_templated_action_str(plan, idx=0): - action = copy.deepcopy(plan[idx]) - object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) - - a_type = action['action'] - templated_str = "" - - if 'GotoLocation' in a_type: - templated_str = "go to the %s" % (next_recep_name if next_recep_name != "" else prev_object_name) - elif 'OpenObject' in a_type: - templated_str = "open the %s" % (object_name) - elif 'CloseObject' in a_type: - templated_str = "close the %s" % (object_name) - elif 'PickupObject' in a_type: - templated_str = "pick up the %s" % (object_name) - elif 'PutObject' in a_type: - templated_str = "put the %s in the %s" % (object_name, recep_name) - elif 'CleanObject' in a_type: - templated_str = "wash the %s" % (prev_object_name) - elif 'HeatObject' in a_type: - templated_str = "heat the %s" % (prev_object_name) - elif 'CoolObject' in a_type: - templated_str = "cool the %s" % (prev_object_name) - elif 'ToggleObject' in a_type: - templated_str = "toggle %s" % (object_name) - elif 'SliceObject' in a_type: - templated_str = "slice the %s" % (object_name) - elif 'End' in a_type: - templated_str = "<>" - - return templated_str - - -def get_discrete_hl_action(plan, idx=0): - action = copy.deepcopy(plan[idx]) - object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name = get_relevant_objs(action, plan, idx) - - a_type = action['action'] - discrete_action = {'action': "", 'args': []} - - if 'GotoLocation' in a_type: - discrete_action['action'] = "GotoLocation" - discrete_action['args'] = [next_recep_name if next_recep_name != "" else next_object_name] - elif 'OpenObject' in a_type: - discrete_action['action'] = "OpenObject" - discrete_action['args'] = [object_name] - elif 'CloseObject' in a_type: - discrete_action['action'] = "CloseObject" - discrete_action['args'] = [object_name] - elif 'PickupObject' in a_type: - discrete_action['action'] = "PickupObject" - discrete_action['args'] = [object_name] - elif 'PutObject' in a_type: - discrete_action['action'] = "PutObject" - discrete_action['args'] = [object_name, recep_name] - elif 'CleanObject' in a_type: - discrete_action['action'] = "CleanObject" - discrete_action['args'] = [prev_object_name] - elif 'HeatObject' in a_type: - discrete_action['action'] = "HeatObject" - discrete_action['args'] = [prev_object_name] - elif 'CoolObject' in a_type: - discrete_action['action'] = "CoolObject" - discrete_action['args'] = [prev_object_name] - elif 'ToggleObject' in a_type: - discrete_action['action'] = "ToggleObject" - discrete_action['args'] = [object_name] - elif 'SliceObject' in a_type: - discrete_action['action'] = "SliceObject" - discrete_action['args'] = [object_name] - else: - discrete_action['action'] = "NoOp" - discrete_action['args'] = [] - - return discrete_action - - -def object_id_to_name(object_id): - return object_id.split('|')[0] - - -def get_relevant_objs(action, plan, idx=0): - object_name = object_id_to_name(action['objectId']).lower() if 'objectId' in action else "" - recep_name = object_id_to_name(action['receptacleObjectId']).lower() if 'receptacleObjectId' in action else "" - prev_object_name, prev_recep_name = "", "" - next_object_name, next_recep_name = "", "" - - prev_idx = idx - 2 - if prev_idx >= 0: - prev_action = copy.deepcopy(plan[prev_idx]) - prev_object_name = object_id_to_name(prev_action['objectId']).lower() if 'objectId' in prev_action else "" - prev_recep_name = object_id_to_name(prev_action['receptacleObjectId']).lower() if 'receptacleObjectId' in prev_action else "" - - next_idx = idx + 1 - if next_idx < len(plan): - next_action = copy.deepcopy(plan[next_idx]) - next_object_name = object_id_to_name(next_action['objectId']).lower() if 'objectId' in next_action else "" - next_recep_name = object_id_to_name(next_action['receptacleObjectId']).lower() if 'receptacleObjectId' in next_action else "" - - return object_name, recep_name, prev_object_name, prev_recep_name, next_object_name, next_recep_name - - -def get_action_str(action): - action = copy.deepcopy(action) - a_type = action['action'] - action_str = 'Action: ' + a_type - del action['action'] - - if 'Teleport' in a_type: - action_str = a_type - if 'x' in action: - action_str += ' x: %.03f' % action['x'] - del action['x'] - if 'y' in action: - action_str += ' y: %.03f' % action['y'] - del action['y'] - if 'z' in action: - action_str += ' z: %.03f' % action['z'] - del action['z'] - if 'rotation' in action and action.get('rotateOnTeleport', False): - if type(action['rotation']) == dict: - action_str += ' r: %d' % int(action['rotation']['y']) - else: - action_str += ' r: %d' % int(action['rotation']) - del action['rotation'] - del action['rotateOnTeleport'] - if 'horizon' in action: - action_str += ' h: %d' % int(action['horizon']) - del action['horizon'] - elif 'Goto' in a_type: - action_str = a_type - if 'location' in action: - action_str += ' loc: %s' % action['location'] - del action['location'] - elif a_type in {'OpenObject', 'CloseObject', 'PickupObject', 'ToggleObject', 'SliceObject'}: - if 'objectId' not in action: - action['objectId'] = 'None' - action_str = '%s %s' % (a_type, action['objectId']) - elif a_type in {'RotateByDegree', 'LookByDegree'}: - if type(action['rotation']) == dict: - action_str += ' r: %d' % int(action['rotation']['y']) - else: - action_str += ' r: %d' % int(action['rotation']) - action_str = '%s %d' % (a_type, action['rotation']['y']) - del action['rotation'] - elif a_type == 'PutObject': - action_str = a_type - if 'objectId' in action: - action_str += ' o: %s' % action['objectId'] - del action['objectId'] - if 'receptacleObjectId' in action: - action_str += ' r: %s' % action['receptacleObjectId'] - del action['receptacleObjectId'] - - if len(action) > 0: - action_str += '\tFull: ' + str(action) - return action_str - - -def get_object(object_id, metadata): - for obj in metadata['objects']: - if obj['objectId'] == object_id: - return obj - return None - - -def get_object_dict(metadata): - return {obj['objectId']: obj for obj in metadata['objects']} - - -def get_objects_of_type(object_type, metadata): - return [obj for obj in metadata['objects'] if obj['objectType'] == object_type] - - -def get_obj_of_type_closest_to_obj(object_type, ref_object_id, metadata): - objs_of_type = [obj for obj in metadata['objects'] if obj['objectType'] == object_type and obj['visible']] - ref_obj = get_object(ref_object_id, metadata) - closest_objs_of_type = sorted(objs_of_type, key=lambda o: np.linalg.norm(np.array([o['position']['x'], o['position']['y'], o['position']['z']]) - \ - np.array([ref_obj['position']['x'], ref_obj['position']['y'], ref_obj['position']['z']]))) - if len(closest_objs_of_type) == 0: - raise Exception("No closest %s found!" % (ref_obj)) - return closest_objs_of_type[0] # retrun the first closest visible object - - -def get_objects_with_name_and_prop(name, prop, metadata): - return [obj for obj in metadata['objects'] - if name in obj['objectId'] and obj[prop]] - - -def get_visible_objs(objs): - return [obj for obj in objs if obj['visible']] - - -def get_object_bounds(obj, scene_bounds): - # obj_bounds = np.array(obj['bounds3D'])[[0, 2, 3, 5]] # Get X and Z out - # Get a 'box' that is a singular point in (x,z) based on object position in place of now-unavailable 'bounds3d' - obj_bounds = np.array([obj['position']['x'], obj['position']['z'], obj['position']['x'], obj['position']['z']]) - obj_bounds /= constants.AGENT_STEP_SIZE - obj_bounds = np.round(obj_bounds).astype(np.int32) - obj_bounds[[2, 3]] = np.maximum(obj_bounds[[2, 3]], obj_bounds[[0, 1]] + 1) - obj_bounds[[0, 2]] = np.clip(obj_bounds[[0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) - obj_bounds[[1, 3]] = np.clip(obj_bounds[[1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) - obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] - return obj_bounds - - -def get_object_bounds_batch(boxes, scene_bounds): - obj_bounds = boxes[:, [0, 2, 3, 5]] # Get X and Z out - obj_bounds /= constants.AGENT_STEP_SIZE - obj_bounds = np.round(obj_bounds).astype(np.int32) - obj_bounds[:, [2, 3]] = np.maximum(obj_bounds[:, [2, 3]], obj_bounds[:, [0, 1]] + 1) - obj_bounds[:, [0, 2]] = np.clip(obj_bounds[:, [0, 2]], scene_bounds[0], scene_bounds[0] + scene_bounds[2]) - obj_bounds[:, [1, 3]] = np.clip(obj_bounds[:, [1, 3]], scene_bounds[1], scene_bounds[1] + scene_bounds[3]) - obj_bounds -= np.array(scene_bounds)[[0, 1, 0, 1]] - return obj_bounds - - -def get_task_str(object_ind, receptacle_ind=None, toggle_ind=None, mrecep_ind=None): - goal_str = constants.pddl_goal_type - if constants.data_dict['pddl_params']['object_sliced']: - goal_str += "_slice" - template = random.choice(glib.gdict[goal_str]['templates']) - obj = constants.OBJECTS[object_ind].lower() if object_ind is not None else "" - recep = constants.OBJECTS[receptacle_ind].lower() if receptacle_ind is not None else "" - tog = constants.OBJECTS[toggle_ind].lower() if toggle_ind is not None else "" - mrecep = constants.OBJECTS[mrecep_ind].lower() if mrecep_ind is not None else "" - filled_in_str = template.format(obj=obj, recep=recep, toggle=tog, mrecep=mrecep) - return filled_in_str - - -def get_last_hl_action_index(): - return len(constants.data_dict['plan']['high_pddl']) - 1 - - -def get_last_ll_action_index(): - return len(constants.data_dict['plan']['low_actions']) - 1 - - -def store_image_name(name): - constants.data_dict['images'].append({"high_idx": get_last_hl_action_index(), - "low_idx": get_last_ll_action_index(), - "image_name": name}) - - diff --git a/gen/utils/image_util.py b/gen/utils/image_util.py deleted file mode 100644 index 157812a2f..000000000 --- a/gen/utils/image_util.py +++ /dev/null @@ -1,57 +0,0 @@ -import numpy as np -import gen.constants as constants - -def bbox_to_mask(bbox): - ''' - bbox to rectangle pixelwise mask - ''' - x1, y1, x2, y2 = bbox - mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) - mask[y1:y2, x1:x2] = 1 - return mask - - -def point_to_mask(point): - ''' - single point to dense pixelwise mask - ''' - x, y = point - mask = np.zeros((constants.DETECTION_SCREEN_HEIGHT, constants.DETECTION_SCREEN_WIDTH)).astype(int) - mask[y, x] = 1 - return mask - - -def decompress_mask(compressed_mask): - ''' - decompress compressed mask array - ''' - mask = np.zeros((constants.DETECTION_SCREEN_WIDTH, constants.DETECTION_SCREEN_HEIGHT)) - for start_idx, run_len in compressed_mask: - for idx in range(start_idx, start_idx + run_len): - mask[idx // constants.DETECTION_SCREEN_WIDTH, idx % constants.DETECTION_SCREEN_HEIGHT] = 1 - return mask - - -def compress_mask(seg_mask): - ''' - compress mask array - ''' - run_len_compressed = [] # list of lists of run lengths for 1s, which are assumed to be less frequent. - idx = 0 - curr_run = False - run_len = 0 - for x_idx in range(len(seg_mask)): - for y_idx in range(len(seg_mask[x_idx])): - if seg_mask[x_idx][y_idx] == 1 and not curr_run: - curr_run = True - run_len_compressed.append([idx, None]) - if seg_mask[x_idx][y_idx] == 0 and curr_run: - curr_run = False - run_len_compressed[-1][1] = run_len - run_len = 0 - if curr_run: - run_len += 1 - idx += 1 - if curr_run: - run_len_compressed[-1][1] = run_len - return run_len_compressed \ No newline at end of file diff --git a/gen/utils/py_util.py b/gen/utils/py_util.py deleted file mode 100644 index 7a357f039..000000000 --- a/gen/utils/py_util.py +++ /dev/null @@ -1,84 +0,0 @@ -import random -import re -import time -import os -import string - - -def get_time_str(): - tt = time.localtime() - time_str = ('%04d_%02d_%02d_%02d_%02d_%02d' % - (tt.tm_year, tt.tm_mon, tt.tm_mday, tt.tm_hour, tt.tm_min, tt.tm_sec)) - return time_str - - -def encode(string, encoding='utf-8'): - return string.encode(encoding) - - -def decode(string, encoding='utf-8'): - return string.decode(encoding) - - -def multireplace(string, replacements): - """ - Given a string and a replacement map, it returns the replaced string. - :param str string: string to execute replacements on - :param dict replacements: replacement dictionary {value to find: value to replace} - :rtype: str - Source https://gist.github.com/bgusach/a967e0587d6e01e889fd1d776c5f3729 - """ - # Place longer ones first to keep shorter substrings from matching where the longer ones should take place - # For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against the string 'hey abc', it should produce - # 'hey ABC' and not 'hey ABc' - substrs = sorted(replacements, key=len, reverse=True) - - # Create a big OR regex that matches any of the substrings to replace - regexp = re.compile('|'.join(map(re.escape, substrs))) - - # For each match, look up the new string in the replacements - return regexp.sub(lambda match: replacements[match.group(0)], string) - - -class SetWithGet(set): - def get_any(self): - return random.sample(self, 1)[0] - - def __getitem__(self, item): - return self.get_any() - - -class Noop(object): - def noop(*args, **kw): - pass - - def __getattr__(self, _): - return self.noop - - -def walklevel(some_dir, level=1): - some_dir = some_dir.rstrip(os.path.sep) - assert os.path.isdir(some_dir) - num_sep = some_dir.count(os.path.sep) - for root, dirs, files in os.walk(some_dir): - yield root, dirs, files - num_sep_this = root.count(os.path.sep) - if num_sep + level <= num_sep_this: - del dirs[:] - - -def remove_spaces(s): - cs = ' '.join(s.split()) - return cs - - -def remove_spaces_and_lower(s): - cs = remove_spaces(s) - cs = cs.lower() - return cs - - -def remove_punctuation(s): - cs = s.translate(str.maketrans('', '', string.punctuation)) - cs = remove_spaces_and_lower(cs) - return cs \ No newline at end of file diff --git a/gen/utils/replay_json.py b/gen/utils/replay_json.py deleted file mode 100644 index 96949414c..000000000 --- a/gen/utils/replay_json.py +++ /dev/null @@ -1,52 +0,0 @@ -import json - -def replay_json(env, json_file): - # load json data - with open(json_file) as f: - traj_data = json.load(f) - - # setup - scene_num = traj_data['scene']['scene_num'] - object_poses = traj_data['scene']['object_poses'] - dirty_and_empty = traj_data['scene']['dirty_and_empty'] - object_toggles = traj_data['scene']['object_toggles'] - - scene_name = 'FloorPlan%d' % scene_num - env.reset(scene_name) - env.restore_scene(object_poses, object_toggles, dirty_and_empty) - - # initialize - event = env.step(dict(traj_data['scene']['init_action'])) - # print("Task: %s" % (traj_data['template']['task_desc'])) - - steps_taken = 0 - for ll_action in traj_data['plan']['low_actions']: - hl_action_idx, traj_api_cmd, traj_discrete_action = \ - ll_action['high_idx'], ll_action['api_action'], ll_action['discrete_action'] - - # print templated low-level instructions & discrete action - # print("HL Templ: %s, LL Cmd: %s" % (traj_data['template']['high_descs'][hl_action_idx], - # traj_discrete_action['action'])) - - # Use the va_interact that modelers will have to use at inference time. - action_name, action_args = traj_discrete_action['action'], traj_discrete_action['args'] - - # three ways to specify object of interest mask - # 1. create a rectangular mask from bbox - # mask = env.bbox_to_mask(action_args['bbox']) if 'bbox' in action_args else None # some commands don't require any arguments - # 2. create a point mask from bbox - # mask = env.point_to_mask(action_args['point']) if 'point' in action_args else None - # 3. use full pixel-wise segmentation mask - compressed_mask = action_args['mask'] if 'mask' in action_args else None - if compressed_mask is not None: - mask = env.decompress_mask(compressed_mask) - else: - mask = None - - success, event, target_instance_id, err, _ = env.va_interact(action_name, interact_mask=mask) - if not success: - raise RuntimeError(err) - - steps_taken += 1 - - return steps_taken diff --git a/gen/utils/video_util.py b/gen/utils/video_util.py deleted file mode 100644 index 4c21b8a3a..000000000 --- a/gen/utils/video_util.py +++ /dev/null @@ -1,11 +0,0 @@ -import subprocess -import constants - -class VideoSaver(object): - - def __init__(self, frame_rate=constants.VIDEO_FRAME_RATE): - self.frame_rate = frame_rate - - def save(self, image_path, save_path): - subprocess.call(["ffmpeg -r %d -pattern_type glob -y -i '%s' -c:v libx264 -pix_fmt yuv420p '%s'" % - (self.frame_rate, image_path, save_path)], shell=True) \ No newline at end of file diff --git a/lanmp_dataloader/attribute_limits.json b/lanmp_dataloader/attribute_limits.json deleted file mode 100644 index 0fdbbed9a..000000000 --- a/lanmp_dataloader/attribute_limits.json +++ /dev/null @@ -1 +0,0 @@ -[{"min_x": -0.40000009536743164, "max_x": 0.40000009536743164, "min_y": 0, "max_y": 0, "min_z": -0.40000009536743164, "max_z": 0.40000009536743164}, {"min_yaw": -347.422251701355, "max_yaw": 358.85895166755654}, {"min_x": -1.146158218383789, "max_x": 0.6427476406097412, "min_y": -0.533308207988739, "max_y": 0.8237500190734863, "min_z": -0.5759885311126709, "max_z": 1.0145864486694336}] \ No newline at end of file diff --git a/lanmp_dataloader/rt1_dataloader.py b/lanmp_dataloader/rt1_dataloader.py deleted file mode 100644 index 7d574597a..000000000 --- a/lanmp_dataloader/rt1_dataloader.py +++ /dev/null @@ -1,800 +0,0 @@ -import os -import sys - -import torch -from torchvision.io import read_image -from torch.utils.data import Dataset -from torch.utils.data import DataLoader -import h5py -from PIL import Image -from tqdm import tqdm -# from models.utils.data_utils import split_data -import pdb -#mainly for debugging -import matplotlib.pyplot as plt -import numpy as np -import re -import json -import sys -from copy import copy -import random - -sys.path.append('..') - -DATASET_PATH = '/oscar/data/stellex/shared/lanmp/sim_dataset.hdf5' - -''' -train_keys, val_keys, test_keys = split_data(self.args.data, splits['train'], splits['val'], splits['test']) -''' - -def split_data(hdf5_path, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1): - with h5py.File(hdf5_path, 'r') as hdf_file: - # Assuming trajectories or data units are top-level groups in the HDF5 file - keys = list(hdf_file.keys()) - total_items = len(keys) - - # Generate a shuffled array of indices - indices = np.arange(total_items) - np.random.shuffle(indices) - - # Calculate split sizes - train_end = int(train_ratio * total_items) - val_end = train_end + int(val_ratio * total_items) - - # Split the indices - train_indices = indices[:train_end] - val_indices = indices[train_end:val_end] - test_indices = indices[val_end:] - - # Convert indices back to keys (assuming order in keys list is stable and matches original order) - train_keys = [keys[i] for i in train_indices] - val_keys = [keys[i] for i in val_indices] - test_keys = [keys[i] for i in test_indices] - - return train_keys, val_keys, test_keys - -def split_by_scene(hdf5_path): - - #mapping which keys are relevant to specific scenes - scene_to_keys = {} - - with h5py.File(hdf5_path, 'r') as hdf_file: - - keys = list(hdf_file.keys()) - - for k in keys: - traj_json_dict = json.loads(hdf_file[k]['folder_0'].attrs['metadata']) - - if traj_json_dict['scene'] not in scene_to_keys: - scene_to_keys[traj_json_dict['scene']] = [] - - scene_to_keys[traj_json_dict['scene']].append(k) - - for k in scene_to_keys.keys(): - scene_to_keys[k] = list(sorted(scene_to_keys[k])) - - with open('./lanmp_dataloader/scene_to_keys.json', 'w') as f: - json.dump(scene_to_keys, f) - - return scene_to_keys - - - -def sort_folders(test_string): - return list(map(int, re.findall(r'\d+', test_string)))[0] - -class DatasetManager(object): - - ''' - NOTE: kwargs should contain a dictionary with keys {'train_split' : x, 'val_split': y, 'test_split':z} where x+y+z = 1 - ''' - def __init__(self, val_scene=1, train_split=0.8, val_split=0.1, test_split=0.1, split_style='task_split', diversity_scenes=1, max_trajectories=100): - - assert( train_split + val_split + test_split == 1.0, 'Error: train, val and test split do not sum to 1.0') - - - #train_keys, val_keys, test_keys = split_data(DATASET_PATH, train_split, val_split, test_split) - if 'scene_to_keys.json' not in os.listdir('./lanmp_dataloader'): - self.scene_to_keys = split_by_scene(DATASET_PATH) - else: - with open('./lanmp_dataloader/scene_to_keys.json') as f: - self.scene_to_keys = json.load(f) - - - self.scenes = list(sorted(list(self.scene_to_keys.keys()))) - - assert( split_style in ['k_fold_scene', 'task_split', 'diversity_ablation'], "Error: input split_style is invalid") - - if split_style == 'k_fold_scene': - assert( val_scene < len(self.scenes), "Error: input scene is out of index space") - train_keys = [] - for x in range(0, len(self.scenes)): - if x!=val_scene: - train_keys += self.scene_to_keys[self.scenes[x]] - - val_keys = self.scene_to_keys[self.scenes[val_scene]] - test_keys = None - - elif split_style == 'task_split': - - train_keys = [] - val_keys = [] - - for scene in self.scenes: - - scene_keys = copy(self.scene_to_keys[scene]) - random.shuffle(scene_keys) - - - split_idx = int(len(scene_keys)*(train_split + 0.5*val_split)) - - train_keys += scene_keys[:split_idx] - val_keys += scene_keys[split_idx:] - - print('Train Perc: ', len(train_keys) / (len(train_keys) + len(val_keys))) - - val_keys = ['data_13:02:17', 'data_19:58:40', 'data_15:50:55', 'data_16:22:44', 'data_15:40:22', 'data_17:08:14', 'data_15:37:13', 'data_18:38:30', 'data_13:56:07', 'data_15:22:59', 'data_13:33:54', 'data_13:18:11', 'data_19:36:17', 'data_14:38:16', 'data_13:04:13', 'data_12:04:43', 'data_16:37:57', 'data_15:38:38', 'data_16:40:44', 'data_17:59:00', 'data_20:57:07', 'data_16:03:52', 'data_16:40:36', 'data_19:31:51', 'data_16:45:24', 'data_21:09:57', 'data_17:26:17', 'data_15:01:27', 'data_14:02:16', 'data_13:29:09', 'data_14:22:29', 'data_16:43:00', 'data_13:46:04', 'data_15:13:04', 'data_16:45:58', 'data_13:33:29', 'data_17:17:50', 'data_11:19:28', 'data_17:45:27', 'data_16:00:55', 'data_15:03:19', 'data_16:06:05', 'data_16:02:46', 'data_17:41:00', 'data_17:35:45', 'data_14:05:06', 'data_18:22:47', 'data_17:02:46', 'data_15:08:23', 'data_16:15:15', 'data_19:00:23', 'data_11:50:57', 'data_15:19:33', 'data_14:52:27', 'data_16:58:53', 'data_11:44:50', 'data_16:10:21', 'data_13:10:05', 'data_17:48:24', 'data_18:09:10', 'data_18:01:35', 'data_13:34:59', 'data_12:48:23', 'data_22:17:48', 'data_16:57:05', 'data_16:49:20', 'data_17:51:34', 'data_12:54:21', 'data_16:23:48', 'data_14:24:32', 'data_16:18:35', 'data_14:26:22', 'data_16:11:06', 'data_11:58:17', 'data_17:13:00', 'data_19:34:02', 'data_13:29:42', 'data_17:20:01', 'data_15:20:09', 'data_16:53:34', 'data_15:25:56'] - - print('Train Keys: ', len(train_keys)) - print('Validation Keys: ', len(val_keys)) - print('Validation Keys: ', val_keys) - - elif split_style == 'diversity_ablation': - - assert(diversity_scenes < len(self.scene_to_keys.keys()), "Error: number of train scenes for diversity ablations cannot be {}".format(len(self.scene_to_keys.keys()))) - - ordered_scenes = []; ordered_trajs = [] - - for scene, traj in self.scene_to_keys.items(): - - ordered_scenes.append(scene) - ordered_trajs.append(len(traj)) - - - ordered_index = sorted(range(0, len(ordered_trajs)), key = lambda x: ordered_trajs[x]) - - ordered_trajs = list(sorted(ordered_trajs)) - ordered_scenes = [ordered_scenes[i] for i in ordered_index] - - print('EVAL SCENE: {} has {} trajectories'.format(ordered_scenes[-1], ordered_trajs[-1])) - val_keys = self.scene_to_keys[ordered_scenes[-1]] - other_scenes = list(reversed(ordered_scenes[:-1])) - other_trajs = list(reversed(ordered_trajs[:-1])) - - - num_per_scene = int(max_trajectories/diversity_scenes) - train_keys = [] - - for i in range(diversity_scenes): - train_keys += random.sample(self.scene_to_keys[other_scenes[i]], num_per_scene) - - if len(train_keys) < max_trajectories: - - random_scene = random.sample(other_scenes[:diversity_scenes], 1)[0] - train_keys += random.sample(self.scene_to_keys[random_scene], max_trajectories-len(train_keys)) - - - if 'attribute_limits.json' not in os.listdir('./lanmp_dataloader'): - body_pose_lim, body_orientation_lim, end_effector_pose_lim = self.determine_min_max_range([train_keys, val_keys, test_keys]) - else: - - with open('./lanmp_dataloader/attribute_limits.json') as f: - attribute_limits = json.load(f) - body_pose_lim, body_orientation_lim, end_effector_pose_lim = attribute_limits[0], attribute_limits[1], attribute_limits[2] - - self.train_dataset = RT1Dataset(train_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) - self.val_dataset = RT1Dataset(val_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) - # self.test_dataset = RT1Dataset(test_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim) - - def determine_min_max_range(self, data_subset_keys): - - body_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z':float('-inf')} - body_orientation = {'min_yaw': float('inf'), 'max_yaw': float('-inf')} - end_effector_pose = {'min_x': float('inf'), 'max_x': float('-inf'), 'min_y': float('inf'), 'max_y': float('-inf'), 'min_z': float('inf'), 'max_z': float('-inf')} - - - - - with h5py.File(DATASET_PATH, 'r') as hdf: - for dataset_keys in data_subset_keys: - - if dataset_keys is None: - continue - - - for i in range(len(dataset_keys)): - prev_body_x = None - prev_body_y = None - prev_body_z = None - prev_body_yaw = None - prev_ee_x = None - prev_ee_y = None - prev_ee_z = None - - print('Index: {} of {}'.format(i, len(dataset_keys))) - traj_group = hdf[dataset_keys[i]] - traj_steps = list(traj_group.keys()) - traj_steps.sort(key=sort_folders) - - for j in range(len(traj_steps)): - - step_metadata = json.loads(traj_group[traj_steps[j]].attrs['metadata']) - - body_x = step_metadata['steps'][0]['state_body'][0] - body_y = step_metadata['steps'][0]['state_body'][1] - body_z = step_metadata['steps'][0]['state_body'][2] - - body_yaw = step_metadata['steps'][0]['state_body'][3] - - - ee_x = step_metadata['steps'][0]['state_ee'][0] - ee_y = step_metadata['steps'][0]['state_ee'][1] - ee_z = step_metadata['steps'][0]['state_ee'][2] - - - - body_pose['min_x'] = min(body_pose['min_x'], body_x - prev_body_x if prev_body_x is not None else 0) - body_pose['max_x'] = max(body_pose['max_x'], body_x - prev_body_x if prev_body_x is not None else 0) - - body_pose['min_y'] = min(body_pose['min_y'], body_y - prev_body_y if prev_body_y is not None else 0) - body_pose['max_y'] = max(body_pose['max_y'], body_y - prev_body_y if prev_body_y is not None else 0) - - body_pose['min_z'] = min(body_pose['min_z'], body_z - prev_body_z if prev_body_z is not None else 0) - body_pose['max_z'] = max(body_pose['max_z'], body_z - prev_body_z if prev_body_z is not None else 0) - - body_orientation['min_yaw'] = min(body_orientation['min_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) - body_orientation['max_yaw'] = max(body_orientation['max_yaw'], body_yaw - prev_body_yaw if prev_body_yaw is not None else 0) - - end_effector_pose['min_x'] = min(end_effector_pose['min_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) - end_effector_pose['max_x'] = max(end_effector_pose['max_x'], ee_x - prev_ee_x if prev_ee_x is not None else 0) - - end_effector_pose['min_y'] = min(end_effector_pose['min_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) - end_effector_pose['max_y'] = max(end_effector_pose['max_y'], ee_y - prev_ee_y if prev_ee_y is not None else 0) - - end_effector_pose['min_z'] = min(end_effector_pose['min_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) - end_effector_pose['max_z'] = max(end_effector_pose['max_z'], ee_z - prev_ee_z if prev_ee_z is not None else 0) - - - prev_body_x = body_x - prev_body_y = body_y - prev_body_z = body_z - prev_body_yaw = body_yaw - prev_ee_x = ee_x - prev_ee_y = ee_y - prev_ee_z = ee_z - - - - #cache the saved max and min values if already computed to save time - attribute_limits = [body_pose, body_orientation, end_effector_pose] - with open('./lanmp_dataloader/attribute_limits.json', 'w') as f: - json.dump(attribute_limits, f) - - - return body_pose, body_orientation, end_effector_pose - - def collate_batches(self, batch, shuffle_batch = False): - - - collated_batch = [] - - # merging batch elements with variable length - for out in range(len(batch[0])): - collated_output = [] - for idx in range(len(batch)): - if batch[idx][out].dtype.type == np.str_: - collated_output.append(batch[idx][out]) - else: - collated_output.append(torch.from_numpy(batch[idx][out])) - - if batch[idx][out].dtype.type!=np.str_: - collated_output = torch.cat(collated_output, dim=0) - else: - - collated_output = np.concatenate(collated_output, axis=0) - - collated_batch.append(collated_output) - - #shuffling all the batched samples across the trajectories to get random order - if shuffle_batch: - permutation = torch.randperm(collated_batch[0].size(0)) - - for i in range(len(collated_batch)): - collated_batch[i] = collated_batch[i][permutation] - - return collated_batch - - - - - - - - - -class RT1Dataset(Dataset): - - - - def __init__(self, data_split_keys, body_pose_lim, body_orientation_lim, end_effector_pose_lim, tokenize_action=True): - - #stores the keys in the dataset for the appropriate split (train, validation or test) - self.dataset_keys = data_split_keys - self.body_pose_lim = body_pose_lim - self.body_orientation_lim = body_orientation_lim - self.end_effector_pose_lim = end_effector_pose_lim - self.num_bins = 254 - - self.tokenize_action = tokenize_action - - self.hdf = h5py.File(DATASET_PATH, 'r') - - def __len__(self): - return len(self.dataset_keys) - - - def make_data_discrete(self, dictionary): - - - - #body x, y, z coordinate - dictionary['body_position_deltas'][:,0] = 1 + (dictionary['body_position_deltas'][:,0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins - dictionary['body_position_deltas'][:,0] = dictionary['body_position_deltas'][:,0].astype(int) - - if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0: - dictionary['body_position_deltas'][:,1] = 1 + (dictionary['body_position_deltas'][:,1] - self.body_pose_lim['min_y'])/(self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins - else: - dictionary['body_position_deltas'][:,1].fill(0) - dictionary['body_position_deltas'][:,1] = dictionary['body_position_deltas'][:,1].astype(int) - - dictionary['body_position_deltas'][:,2] = 1 + (dictionary['body_position_deltas'][:,2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins - dictionary['body_position_deltas'][:,2] = dictionary['body_position_deltas'][:,2].astype(int) - - #body yaw and pitch - dictionary['body_yaw_deltas'] = 1 + (dictionary['body_yaw_deltas'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins - dictionary['body_yaw_deltas'] = dictionary['body_yaw_deltas'].astype(int) - - #end effector x, y, z coordinate - dictionary['arm_position_deltas'][:,0] = 1 + (dictionary['arm_position_deltas'][:,0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins - dictionary['arm_position_deltas'][:,0] = dictionary['arm_position_deltas'][:,0].astype(int) - - dictionary['arm_position_deltas'][:,1] = 1 + (dictionary['arm_position_deltas'][:,1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins - dictionary['arm_position_deltas'][:,1] = dictionary['arm_position_deltas'][:,1].astype(int) - - dictionary['arm_position_deltas'][:,2] = 1 + (dictionary['arm_position_deltas'][:,2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins - dictionary['arm_position_deltas'][:,2] = dictionary['arm_position_deltas'][:,2].astype(int) - - #find if and where episode terminates so you can fill those entries with 0s - if 1.0 in dictionary['terminate_episode']: - terminate_idx = np.where(np.array(dictionary['terminate_episode'])>0)[0][0] - - dictionary['body_position_deltas'][terminate_idx:,:].fill(0) - dictionary['body_yaw_deltas'][terminate_idx:].fill(0) - dictionary['arm_position_deltas'][terminate_idx:,:].fill(0) - - - return dictionary - - - def detokenize_continuous_data(self, dictionary): - - if dictionary['curr_mode'] == 'stop': - dictionary['body_position_delta'] = [[0.0, 0.0, 0.0]] - dictionary['body_yaw_delta'] = [[0.0]] - dictionary['arm_position_deltas'] = [[0.0, 0.0, 0.0]] - - else: - dictionary['body_position_delta'][0][0] = (dictionary['body_position_delta'][0][0] - 1) * (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x']) / self.num_bins + self.body_pose_lim['min_x'] - dictionary['body_position_delta'][0][1] = (dictionary['body_position_delta'][0][1] - 1) * (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y']) / self.num_bins + self.body_pose_lim['min_y'] - dictionary['body_position_delta'][0][2] = (dictionary['body_position_delta'][0][2] - 1) * (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z']) / self.num_bins + self.body_pose_lim['min_z'] - - dictionary['body_yaw_delta'][0][0] = (dictionary['body_yaw_delta'][0][0] - 1) * (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) / self.num_bins + self.body_orientation_lim['min_yaw'] - - - dictionary['arm_position_delta'][0][0] = (dictionary['arm_position_delta'][0][0] - 1) * (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x']) / self.num_bins + self.end_effector_pose_lim['min_x'] - dictionary['arm_position_delta'][0][1] = (dictionary['arm_position_delta'][0][1] - 1) * (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y']) / self.num_bins + self.end_effector_pose_lim['min_y'] - dictionary['arm_position_delta'][0][2] = (dictionary['arm_position_delta'][0][2] - 1) * (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z']) / self.num_bins + self.end_effector_pose_lim['min_z'] - return dictionary - - - def make_data_discrete_old(self, dictionary): - - if not bool(dictionary['is_terminal']): - - #body x, y, z coordinate - dictionary['body_position'][0] = 1 + int( (dictionary['body_position'][0] - self.body_pose_lim['min_x'])/ (self.body_pose_lim['max_x'] - self.body_pose_lim['min_x'] ) * self.num_bins) - - dictionary['body_position'][1] = 1 + int( (dictionary['body_position'][1] - self.body_pose_lim['min_y'])/ (self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] ) * self.num_bins) if self.body_pose_lim['max_y'] - self.body_pose_lim['min_y'] > 0 else 0 - - dictionary['body_position'][2] = 1 + int( (dictionary['body_position'][2] - self.body_pose_lim['min_z'])/ (self.body_pose_lim['max_z'] - self.body_pose_lim['min_z'] ) * self.num_bins) - - #body yaw and pitch - dictionary['body_yaw'] = 1 + int( (dictionary['body_yaw'] - self.body_orientation_lim['min_yaw']) / (self.body_orientation_lim['max_yaw'] - self.body_orientation_lim['min_yaw']) * self.num_bins) - - #end effector x, y, z coordinate - dictionary['arm_position'][0] = 1 + int( (dictionary['arm_position'][0] - self.end_effector_pose_lim['min_x'])/ (self.end_effector_pose_lim['max_x'] - self.end_effector_pose_lim['min_x'] ) * self.num_bins) - dictionary['arm_position'][1] = 1 + int( (dictionary['arm_position'][1] - self.end_effector_pose_lim['min_y'])/ (self.end_effector_pose_lim['max_y'] - self.end_effector_pose_lim['min_y'] ) * self.num_bins) - dictionary['arm_position'][2] = 1 + int( (dictionary['arm_position'][2] - self.end_effector_pose_lim['min_z'])/ (self.end_effector_pose_lim['max_z'] - self.end_effector_pose_lim['min_z'] ) * self.num_bins) - - #if terminal action is chosen, then produce 'no action' discrete value for each of the state variables - else: - dictionary['body_position'][0] = 0 - dictionary['body_position'][1] = 0 - dictionary['body_position'][2] = 0 - - dictionary['body_yaw'] = 0 - - dictionary['arm_position'][0] = 0 - dictionary['arm_position'][1] = 0 - dictionary['arm_position'][2] = 0 - - def get_head_pitch(self, action): - - value = 0 - - if action == 'LookDown': - value = 1 - elif action == 'LookUp': - value = 2 - - return value - - def detokenize_head_pitch(self, token): - - tokenization_dict = {0:None, 1:'LookDown', 2:'LookUp'} - - return tokenization_dict[token] - - def get_mode(self, action): - - #mode: (0) stop, (1) body, (2) yaw, (3) manipulation, (4) grasping, (5) head pitch - - value = None - - if action == 'stop': - value = 0 - elif action in set( ['LookDown', 'LookUp']): - value = 5 - elif action in set(['MoveAhead', 'MoveBack', 'MoveRight', 'MoveLeft']): - value = 1 - elif action in set(['PickupObject', 'ReleaseObject']): - value = 4 - elif action in set(['MoveArm', 'MoveArmBase']): - value = 3 - elif action == 'RotateAgent': - value = 2 - - assert(type(value)==int, 'Get Mode didn\'t return an int') - return value - - def detokenize_mode(self, token): - - tokenization_dict = {0: 'stop', 1:'MoveAgent', 2:'RotateAgent', 3:'MoveArm', 4:'PickupReleaseObject', 5:'PitchAgent'} - - return tokenization_dict[token] - - def detokenize_action(self, detokenized_mode, body_position_delta, body_yaw_delta, arm_position_delta, detokenized_pickup_release, detokenized_head_pitch): - - - if detokenized_mode == 'PickupReleaseObject': - return detokenized_pickup_release - - elif detokenized_mode == 'PitchAgent': - return detokenized_head_pitch - else: - return detokenized_mode - - - def get_pickup_release(self, action): - - if action == 'PickupObject': - value = 1 - elif action == 'ReleaseObject': - value = 2 - else: - value = 0 - - return value - - def detokenize_pickup_release(self, token): - - tokenization_dict = {0:None, 1:'PickupObject', 2:'ReleaseObject'} - return tokenization_dict[token] - - def __getitem__(self, idx): - - # pdb.set_trace() - - traj_group = self.hdf[self.dataset_keys[idx]] - - traj_steps = list(traj_group.keys()) - traj_steps.sort(key=sort_folders) - - #extract the NL command - json_str = traj_group[traj_steps[0]].attrs['metadata'] - traj_json_dict = json.loads(json_str) - nl_command = traj_json_dict['nl_command'] - - - #compute remainder in case padding of action tokens and observations needed - padding_length = 6 - (len(traj_steps)%6) if len(traj_steps)%6 > 0 else 0 - terminate = False - - start = 0; end = min(len(traj_steps), 6) - - #return list of dictionaries with attributes required for RT1 - all_image_obs = [] - all_nl_commands = [] - all_is_terminal = [] - all_pickup_release = [] - all_body_position_deltas = [] - all_body_yaw_deltas = [] - all_body_pitches = [] - all_arm_position_deltas = [] - all_control_mode = [] - - all_pad_lengths = [] - - - - #build the dictionary for each sequence - while end <= len(traj_steps) and not terminate: - - ''' - mode: stop, body, yaw, manipulation, grasping, head pitch - gripper: (x, y, z, grasp) - body: (x, y, yaw, look up/down) - ''' - image_obs = [] - nl_commands = [] - body_position_deltas = [] - body_yaw_deltas = [] - arm_position_deltas = [] - terminate_episodes = [] - pickup_releases = [] - body_pitches = [] - control_modes = [] - - for i in range(start, end): - - #visual observation - ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) - image_obs.append(ith_obs) - - #natural language command - nl_commands.append(nl_command) - - current_metadata = json.loads(traj_group[traj_steps[i]].attrs['metadata']) - - - if i < len(traj_steps)-1: - - next_metadata = json.loads(traj_group[traj_steps[i+1]].attrs['metadata']) - - #body position, body yaw, arm position - body_position_delta = np.array(next_metadata['steps'][0]['state_body'][:3])-np.array(current_metadata['steps'][0]['state_body'][:3]) - body_yaw_delta = next_metadata['steps'][0]['state_body'][3] - current_metadata['steps'][0]['state_body'][3] - arm_position_delta = np.array(next_metadata['steps'][0]['state_ee'][:3]) - np.array(current_metadata['steps'][0]['state_ee'][:3]) - - #terminate episode / pick up release / body pitch / mode - terminate_episode = int(i == len(traj_steps)-1) - pickup_release = self.get_pickup_release(next_metadata['steps'][0]['action']) - body_pitch = self.get_head_pitch(next_metadata['steps'][0]['action']) - control_mode = self.get_mode(next_metadata['steps'][0]['action']) - else: - - #body position, body yaw, arm positon -- for last step - body_position_delta = np.array([0.0, 0.0, 0.0]) - body_yaw_delta = 0.0 - arm_position_delta = np.array([0.0, 0.0, 0.0]) - - #is terminal / pick up release / body pitch / mode -- for last step - terminate_episode = int(i == len(traj_steps)-1) - pickup_release = self.get_pickup_release(None) - body_pitch = self.get_head_pitch(None) - control_mode = self.get_mode('stop') - - body_position_deltas.append(body_position_delta) - body_yaw_deltas.append(body_yaw_delta) - arm_position_deltas.append(arm_position_delta) - terminate_episodes.append(terminate_episode) - pickup_releases.append(pickup_release) - body_pitches.append(body_pitch) - control_modes.append(control_mode) - - - - #check for remainder and pad data with extra - if end >= len(traj_steps) and padding_length > 0: - - for pad in range(0, padding_length): - - image_obs.append(ith_obs) - nl_commands.append(nl_command) - - body_position_deltas.append(np.array([0.0, 0.0, 0.0])) - body_yaw_deltas.append(0.0) - arm_position_deltas.append(np.array([0.0, 0.0, 0.0])) - terminate_episodes.append(0) - pickup_releases.append(0.0) - body_pitches.append(0.0) - control_modes.append(0.0) - - terminate = True - elif end >= len(traj_steps): - terminate = True - - - - #pre-process and discretize numerical data - body_position_deltas = np.stack(body_position_deltas) - body_yaw_deltas = np.stack(body_yaw_deltas) - arm_position_deltas = np.stack(arm_position_deltas) - - if self.tokenize_action: - - tokenized_actions = { - 'body_position_deltas': body_position_deltas, - 'body_yaw_deltas': body_yaw_deltas, - 'arm_position_deltas': arm_position_deltas, - 'terminate_episode': terminate_episodes - } - - tokenized_actions = self.make_data_discrete(tokenized_actions) - - body_position_deltas = tokenized_actions['body_position_deltas'] - - body_yaw_deltas = np.expand_dims(tokenized_actions['body_yaw_deltas'], axis=1) - - arm_position_deltas = tokenized_actions['arm_position_deltas'] - - - - - all_image_obs.append(np.stack(image_obs)) - all_nl_commands.append(np.stack(nl_commands)) - all_is_terminal.append(np.stack(terminate_episodes)) - all_pickup_release.append(np.stack(pickup_releases)) - all_body_position_deltas.append(body_position_deltas) - all_body_yaw_deltas.append(body_yaw_deltas) - all_body_pitches.append(np.stack(body_pitches)) - all_arm_position_deltas.append(arm_position_deltas) - all_control_mode.append(np.stack(control_modes)) - - all_pad_lengths.append(0 if not end >= len(traj_steps) else padding_length) - - - start += 6 - end = min(end + 6, len(traj_steps)) - - - - - return np.stack(all_image_obs), np.stack(all_nl_commands), np.stack(all_is_terminal), np.stack(all_pickup_release), np.stack(all_body_position_deltas), np.stack(all_body_yaw_deltas), np.stack(all_body_pitches), np.stack(all_arm_position_deltas), np.stack(all_control_mode), np.stack(all_pad_lengths) - - - - def __getitem_old__(self, idx): - - - traj_group = self.hdf[self.dataset_keys[idx]] - - traj_steps = list(traj_group.keys()) - traj_steps.sort(key=sort_folders) - - #extract the NL command - json_str = traj_group[traj_steps[0]].attrs['metadata'] - traj_json_dict = json.loads(json_str) - nl_command = traj_json_dict['nl_command'] - - start = 0; end = min(len(traj_steps), 6) - - #return list of dictionaries with attributes required for RT1 - all_image_obs = [] - all_nl_commands = [] - all_is_terminal = [] - all_pickup_release = [] - all_body_position = [] - all_body_yaw = [] - all_body_pitch = [] - all_arm_position = [] - all_mode = [] - - - - #build the dictionary for each sequence - while end < len(traj_steps): - - ''' - mode: stop, body, yaw, manipulation, grasping, head pitch - gripper: (x, y, z, grasp) - body: (x, y, yaw, look up/down) - ''' - image_obs = [] - - for i in range(start, end): - ith_obs = np.array(traj_group[traj_steps[i]]['rgb_{}'.format(i)]) - - image_obs.append(ith_obs) - - image_obs = np.stack(image_obs) - - - - before_end_step_metadata = json.loads(traj_group[traj_steps[end-1]].attrs['metadata']) - end_step_metadata = json.loads(traj_group[traj_steps[end]].attrs['metadata']) - - - - dictionary = { - 'observation': image_obs, - 'nl_command': nl_command, #DONE - 'is_terminal': int(end_step_metadata['steps'][0]['action']=='stop'), #DONE - 'pickup_release': self.get_pickup_release(end_step_metadata['steps'][0]['action']), #DONE - 'body_position': np.array(end_step_metadata['steps'][0]['state_body'][:3])-np.array(before_end_step_metadata['steps'][0]['state_body'][:3]), #DONE - 'body_yaw': end_step_metadata['steps'][0]['state_body'][3] - before_end_step_metadata['steps'][0]['state_body'][3], #DONE - 'body_pitch': self.get_head_pitch(end_step_metadata['steps'][0]['action']), #DONE - 'arm_position': np.array(end_step_metadata['steps'][0]['state_ee'][:3]) - np.array(before_end_step_metadata['steps'][0]['state_ee'][:3]), #DONE - 'mode': self.get_mode(end_step_metadata['steps'][0]['action']) #DONE - } - - #pre-process the data dictonary - if self.tokenize_action: - self.make_data_discrete(dictionary) - - - all_image_obs.append(dictionary['observation']) - all_nl_commands.append(dictionary['nl_command']) - all_is_terminal.append(dictionary['is_terminal']) - all_pickup_release.append(dictionary['pickup_release']) - all_body_position.append(dictionary['body_position']) - all_body_yaw.append(dictionary['body_yaw']) - all_body_pitch.append(dictionary['body_pitch']) - all_arm_position.append(dictionary['arm_position']) - all_mode.append(dictionary['mode']) - - - start += 1 - end += 1 - - #add the terminal 'stop' step - all_image_obs.append(dictionary['observation']) - all_nl_commands.append(dictionary['nl_command']) - all_is_terminal.append(1) - all_pickup_release.append(0) - all_body_position.append([0,0,0]) - all_body_yaw.append(0) - all_body_pitch.append(0) - all_arm_position.append([0,0,0]) - all_mode.append(0) - - - - - - return np.stack(all_image_obs), np.stack(all_nl_commands), np.expand_dims(np.stack(all_is_terminal), axis=1), np.expand_dims(np.stack(all_pickup_release), axis=1), np.stack(all_body_position), np.expand_dims(np.stack(all_body_yaw),axis=1), np.expand_dims(np.stack(all_body_pitch), axis=1), np.stack(all_arm_position), np.expand_dims(np.stack(all_mode), axis=1) - - -if __name__ == '__main__': - - - dataset_manager = DatasetManager(0, 0.8, 0.1, 0.1) - - dataloader = DataLoader(dataset_manager.train_dataset, batch_size=3, - shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) - - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size=2, - shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches) - - - - for batch, sample_batch in enumerate(dataloader): - - # print('BATCH {}:'.format(batch)) - # print('Num Steps: {}'.format(sample_batch[0].shape[0])) - print('Batch {}: '.format(batch), sample_batch[0].shape[0]) - - - - - \ No newline at end of file diff --git a/lanmp_dataloader/scene_to_keys.json b/lanmp_dataloader/scene_to_keys.json deleted file mode 100644 index da07b6395..000000000 --- a/lanmp_dataloader/scene_to_keys.json +++ /dev/null @@ -1 +0,0 @@ -{"FloorPlan_Train8_1": ["data_11:11:28", "data_11:38:43", "data_11:48:40", "data_11:51:31", "data_11:56:47", "data_11:58:17", "data_12:18:24", "data_12:31:00", "data_12:49:55", "data_12:53:51", "data_12:54:21", "data_12:57:45", "data_12:59:43", "data_13:00:14", "data_13:13:47", "data_13:18:03", "data_13:22:48", "data_13:24:35", "data_13:29:42", "data_13:30:35", "data_13:36:19", "data_13:37:24", "data_13:38:39", "data_13:42:32", "data_13:48:30", "data_13:52:48", "data_13:56:06", "data_13:58:42", "data_14:01:23", "data_14:24:32", "data_14:26:22", "data_14:31:39", "data_14:36:13", "data_14:38:15", "data_14:44:47", "data_14:45:23", "data_14:49:15", "data_14:53:25", "data_14:58:54", "data_15:06:22", "data_15:09:43", "data_15:13:05", "data_15:13:36", "data_15:14:10", "data_15:16:32", "data_15:20:09", "data_15:22:18", "data_15:25:56", "data_15:26:42", "data_15:29:24", "data_15:29:51", "data_15:30:35", "data_15:32:34", "data_15:39:22", "data_15:41:58", "data_15:43:27", "data_15:43:51", "data_16:05:05", "data_16:09:25", "data_16:11:06", "data_16:13:53", "data_16:18:35", "data_16:23:48", "data_16:26:23", "data_16:30:54", "data_16:43:19", "data_16:49:20", "data_16:52:28", "data_16:53:34", "data_16:59:06", "data_17:00:51", "data_17:02:54", "data_17:04:35", "data_17:06:16", "data_17:13:00", "data_17:20:01", "data_17:23:07", "data_17:26:09", "data_17:33:07", "data_17:47:57", "data_17:51:34", "data_17:56:54", "data_17:58:11", "data_17:59:29", "data_18:01:53", "data_18:08:32", "data_18:18:37", "data_18:22:56", "data_18:25:09", "data_18:33:34", "data_18:45:42", "data_19:09:57", "data_19:15:07", "data_19:20:52", "data_19:25:51", "data_19:34:02", "data_19:43:09", "data_19:48:33", "data_19:52:25", "data_19:53:51", "data_20:29:26", "data_21:11:22", "data_21:14:13", "data_22:26:52"], "FloorPlan_Train1_3": ["data_11:14:08", "data_12:27:37", "data_12:28:44", "data_12:30:42", "data_12:42:59", "data_12:48:44", "data_13:01:08", "data_13:10:23", "data_13:16:27", "data_13:26:27", "data_13:29:09", "data_13:33:21", "data_13:35:43", "data_13:45:31", "data_13:49:19", "data_13:53:16", "data_13:59:05", "data_14:02:16", "data_14:19:36", "data_14:22:29", "data_14:24:31", "data_14:26:42", "data_14:32:06", "data_14:34:15", "data_14:35:23", "data_14:38:31", "data_14:43:46", "data_14:46:49", "data_14:48:48", "data_14:50:47", "data_14:56:50", "data_15:01:27", "data_15:35:48", "data_15:38:38", "data_15:39:32", "data_15:42:27", "data_15:49:15", "data_15:50:49", "data_15:51:26", "data_15:52:55", "data_15:54:45", "data_15:56:44", "data_15:58:10", "data_16:01:04", "data_16:03:52", "data_16:04:17", "data_16:10:32", "data_16:10:59", "data_16:33:34", "data_16:37:28", "data_16:40:36", "data_16:40:44", "data_16:42:54", "data_16:43:00", "data_16:43:00:00", "data_16:44:16", "data_16:45:24", "data_16:47:46", "data_16:49:24", "data_16:55:46", "data_17:05:08", "data_17:07:34", "data_17:07:43", "data_17:21:35", "data_17:26:17", "data_17:29:14", "data_17:32:17", "data_17:32:27", "data_17:43:33", "data_17:47:03", "data_17:51:39", "data_17:59:00", "data_18:04:56", "data_18:11:24", "data_18:17:16", "data_18:22:49", "data_18:25:44", "data_18:28:13", "data_18:28:43", "data_18:29:38", "data_18:31:13", "data_18:35:58", "data_18:37:04", "data_18:46:02", "data_19:14:43", "data_19:31:51", "data_19:35:53", "data_20:11:23", "data_20:15:34", "data_20:57:07", "data_21:09:57", "data_21:35:32", "data_21:40:45", "data_22:55:44", "data_22:59:37", "data_23:02:34"], "FloorPlan_Train5_1": ["data_11:19:28", "data_11:23:37", "data_12:05:09", "data_12:15:11", "data_12:22:25", "data_12:37:24", "data_12:40:41", "data_12:43:21", "data_12:58:49", "data_13:14:36", "data_13:22:30", "data_13:25:14", "data_13:28:56", "data_13:29:25", "data_13:31:07", "data_13:33:29", "data_13:40:50", "data_13:42:24", "data_13:46:04", "data_14:03:55", "data_14:05:06", "data_14:09:28", "data_14:10:09", "data_14:14:11", "data_14:18:16", "data_14:23:38", "data_14:36:10", "data_14:40:10", "data_14:47:53", "data_14:50:55", "data_14:56:41", "data_14:58:02", "data_14:58:08", "data_15:03:19", "data_15:05:49", "data_15:06:39", "data_15:08:16", "data_15:13:04", "data_15:19:26", "data_15:22:08", "data_15:27:41", "data_15:29:40", "data_15:40:49", "data_15:44:42", "data_15:56:53", "data_15:58:27", "data_16:00:55", "data_16:02:46", "data_16:05:15", "data_16:06:05", "data_16:07:40", "data_16:09:36", "data_16:12:08", "data_16:26:34", "data_16:29:17", "data_16:31:09", "data_16:31:36", "data_16:35:27", "data_16:43:42", "data_16:45:58", "data_16:47:16", "data_16:50:06", "data_16:51:03", "data_16:53:36", "data_16:53:39", "data_16:53:42", "data_16:54:39", "data_16:56:38", "data_16:57:05:00", "data_16:57:25", "data_17:12:32", "data_17:17:50", "data_17:35:45", "data_17:39:05:00", "data_17:41:00", "data_17:41:08", "data_17:45:27", "data_17:50:42", "data_17:54:05", "data_17:56:23", "data_18:22:47", "data_18:31:07", "data_18:33:51", "data_18:37:38", "data_18:42:03", "data_18:44:54", "data_18:47:01", "data_18:50:53", "data_18:58:07", "data_19:04:21", "data_19:08:32", "data_19:27:25", "data_19:53:59", "data_19:57:56", "data_20:07:12", "data_22:02:06", "data_22:10:19", "data_23:06:06", "data_23:09:41", "data_23:16:06"], "FloorPlan_Train12_3": ["data_11:24:25", "data_12:04:43", "data_12:04:44", "data_12:09:11", "data_12:12:18", "data_12:13:00", "data_12:48:09", "data_12:55:46", "data_13:02:17", "data_13:04:13", "data_13:06:18", "data_13:07:22", "data_13:07:34", "data_13:08:21", "data_13:10:24", "data_13:15:55", "data_13:18:11", "data_13:19:12", "data_13:33:54", "data_13:37:23", "data_13:39:28", "data_13:40:16", "data_13:51:04", "data_13:52:30", "data_13:56:07", "data_13:57:55", "data_14:04:08", "data_14:06:14", "data_14:06:28", "data_14:07:59", "data_14:10:04", "data_14:19:43", "data_14:23:01", "data_14:25:51", "data_14:36:45", "data_14:38:16", "data_14:40:46", "data_15:04:08", "data_15:06:03", "data_15:08:14", "data_15:10:38", "data_15:13:32", "data_15:15:15", "data_15:21:58", "data_15:22:59", "data_15:23:17", "data_15:25:19", "data_15:27:29", "data_15:27:52", "data_15:34:50", "data_15:37:13", "data_15:37:30", "data_15:39:06", "data_15:39:14", "data_15:40:22", "data_15:41:15", "data_15:46:13", "data_15:47:54", "data_15:48:04", "data_15:50:55", "data_16:03:07", "data_16:11:48", "data_16:12:38", "data_16:15:33", "data_16:21:47", "data_16:22:10", "data_16:22:44", "data_16:25:33", "data_16:27:27", "data_16:33:37", "data_16:33:42", "data_16:35:20", "data_16:37:57", "data_16:58:28", "data_16:59:59", "data_17:02:20", "data_17:05:07", "data_17:07:22", "data_17:08:14", "data_17:08:43", "data_17:10:41", "data_17:12:20", "data_17:16:57", "data_17:25:26", "data_17:31:59", "data_17:39:05", "data_18:05:31", "data_18:06:05", "data_18:09:48", "data_18:11:32", "data_18:20:49", "data_18:38:30", "data_18:40:29", "data_18:44:56", "data_19:32:42", "data_19:36:17", "data_19:38:40", "data_19:55:46", "data_19:58:40", "data_20:04:58", "data_20:36:00", "data_20:40:25", "data_20:40:56", "data_20:43:46", "data_21:22:47", "data_21:27:13", "data_21:36:02", "data_21:39:40"], "FloorPlan_Train7_5": ["data_11:33:11", "data_11:35:24", "data_11:38:27", "data_11:44:50", "data_11:50:57", "data_12:03:39", "data_12:30:12", "data_12:36:36", "data_12:41:02", "data_12:45:50", "data_12:46:17", "data_12:48:23", "data_12:50:47", "data_12:59:13", "data_13:01:06", "data_13:06:40", "data_13:10:05", "data_13:19:26", "data_13:33:39", "data_13:34:59", "data_13:39:14", "data_13:39:53", "data_13:41:08", "data_13:44:39", "data_13:48:45", "data_13:53:16:00", "data_14:17:20", "data_14:19:54", "data_14:22:51", "data_14:23:49", "data_14:29:19", "data_14:40:36", "data_14:43:02", "data_14:45:24", "data_14:52:27", "data_15:00:11", "data_15:02:05", "data_15:05:00", "data_15:06:51", "data_15:08:00", "data_15:08:23", "data_15:09:40", "data_15:10:35", "data_15:15:28", "data_15:18:01", "data_15:19:33", "data_15:20:32", "data_15:22:15", "data_15:24:10", "data_15:33:02", "data_15:35:16", "data_15:36:12", "data_15:37:15", "data_15:58:50", "data_16:00:52", "data_16:02:56", "data_16:03:52:00", "data_16:04:13", "data_16:08:41", "data_16:10:21", "data_16:12:36", "data_16:15:15", "data_16:18:47", "data_16:21:30", "data_16:33:14", "data_16:35:18", "data_16:36:47", "data_16:37:29", "data_16:43:59", "data_16:47:31", "data_16:55:23", "data_16:55:40", "data_16:57:05", "data_16:57:21", "data_16:58:20", "data_16:58:53", "data_16:59:33", "data_16:59:34", "data_17:00:42", "data_17:00:58", "data_17:02:46", "data_17:02:49", "data_17:03:08", "data_17:10:18", "data_17:32:08", "data_17:39:16", "data_17:43:47", "data_17:46:14", "data_17:48:24", "data_17:58:02", "data_17:59:14", "data_18:01:35", "data_18:06:24", "data_18:09:10", "data_18:12:41", "data_18:15:58", "data_18:26:13", "data_18:39:40", "data_18:41:38", "data_18:45:39", "data_18:54:32", "data_18:57:41", "data_18:59:56", "data_19:00:23", "data_19:02:18", "data_19:03:13", "data_19:15:22", "data_19:18:14", "data_19:20:26", "data_19:27:05", "data_20:26:48", "data_20:33:59", "data_22:17:48", "data_23:21:12", "data_23:26:05", "data_23:27:44"]} \ No newline at end of file diff --git a/main.py b/main.py deleted file mode 100644 index 29f6032bd..000000000 --- a/main.py +++ /dev/null @@ -1,257 +0,0 @@ -import argparse -import os -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -from tqdm import tqdm -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--datasets", - type=list, - default=['fractal20220817_data'], - ) - parser.add_argument( - "--train-split", - type=str, - default="train[:-1000]", - help="use e.g. train[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-split", - type=str, - default="train[-1000:]", - help="use e.g. eval[:100] for the first 100 episodes", - ) - parser.add_argument( - "--epochs", - type=int, - default=1, - help="number of training epochs", - ) - parser.add_argument( - "--lr", - type=float, - default=1e-4, - help="learning rate", - ) - parser.add_argument( - "--train-batch-size", - type=int, - default=8, - help="train batch size", - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=8, - help="eval batch size", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=6, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--eval-freq", - type=int, - default=0, - help="eval frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-freq", - type=int, - default=200, - help="checkpoint frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-dir", - type=str, - default="checkpoints/rt1_pretraining", - help="directory to save checkpoints", - ) - parser.add_argument( - "--load-checkpoint", - type=str, - default=None, - help="checkpoint to load from; defaults to None", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - if args.wandb: - wandb.init(project="rt1-pretraining-v1", config=vars(args)) - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - print("Loading dataset...") - - train_dataset = create_dataset( - datasets=args.datasets, - split=args.train_split, - trajectory_length=args.trajectory_length, - batch_size=args.train_batch_size, - num_epochs=args.epochs, - ) - # eval_dataset = create_dataset( - # datasets=args.datasets, - # split=args.eval_split, - # trajectory_length=args.trajectory_length, - # batch_size=args.eval_batch_size, - # num_epochs=args.epochs, - # ) - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - action_space = gym.spaces.Dict( - world_vector=gym.spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), - base_displacement_vertical_rotation=gym.spaces.Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 - ), - gripper_closedness_action=gym.spaces.Box( - low=-1.0, high=1.0, shape=(1,), dtype=np.float32 - ), - terminate_episode=gym.spaces.Discrete(3), - base_displacement_vector=gym.spaces.Box( - low=-1.0, - high=1.0, - shape=(2,), - dtype=np.float32, - ), - rotation_delta=gym.spaces.Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 - ), - ) - - print("Building policy...") - policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=args.load_checkpoint, - ) - - policy.model.train() - optimizer = Adam(policy.model.parameters(), lr=args.lr) - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else None - ) - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - def get_text_embedding(observation: Dict): - if text_embedding_model is not None: - return text_embedding_model.encode(observation["instruction"]) - else: - return observation["embedding"] - - print("Training...") - num_batches = 0 - - for batch in tqdm(train_dataset): - - policy.model.train() - - num_batches += 1 - - if num_batches <= 0: - continue - - #Image Shape: 8, 6, 480, 640, 3 => (batch, length, height, width, channel) - #Context Shape: 8, 6, 512 => (batch, length, embedding) - observations = { - "image": batch["observation"]["image"], - "context": get_text_embedding(batch["observation"]), - } - - - actions = batch["action"] - - try: - loss, loss_std = policy.loss(observations, actions) - except: - print('-------------LOSS COMPUTATION FAILED!!!--------') - continue - - if args.wandb: - wandb.log({"loss": loss.item(), "loss_std": loss_std.item()}, step=num_batches * args.train_batch_size) - print(f"Train loss Batch {num_batches}: {loss.item()}") - else: - print(f"Train loss Batch {num_batches}: {loss.item()}") - optimizer.zero_grad() - loss.backward() - optimizer.step() - if args.eval_freq and num_batches % args.eval_freq == 0: - print("Evaluating...") - policy.model.eval() - batch = next(eval_dataset) - observations = { - "image": batch["observation"]["image"], - "context": get_text_embedding(batch["observation"]), - } - actions = batch["action"] - eval_loss, eval_loss_std = policy.loss(observations, actions) - eval_loss = eval_loss.item() - if args.wandb: - wandb.log( - {"eval_loss": eval_loss, "eval_loss_std": eval_loss_std.item()}, - step=num_batches * args.train_batch_size, - ) - else: - print(f"Eval loss Batch {num_batches}: {eval_loss}") - if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: - checkpoint_path = ( - f"{args.checkpoint_dir}/checkpoint_" - + f"{num_batches}" - + f"_loss_{loss.item():.3f}.pt" - ) - torch.save(policy.model.state_dict(), checkpoint_path) - print(f"Saved checkpoint to {checkpoint_path}") - print("finished training") - -if __name__ == "__main__": - main() diff --git a/main_ft.py b/main_ft.py deleted file mode 100644 index dca6394ab..000000000 --- a/main_ft.py +++ /dev/null @@ -1,387 +0,0 @@ -import argparse -import os -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -import tensorflow_hub as hub -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy -from tqdm import tqdm -from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader -import gc - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--datasets", - type=list, - default=["fractal20220817_data"], - ) - parser.add_argument( - "--train-split", - type=str, - default="train[:-1000]", - help="use e.g. train[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-split", - type=str, - default="train[-1000:]", - help="use e.g. eval[:100] for the first 100 episodes", - ) - parser.add_argument( - "--epochs", - type=int, - default=4, - help="number of training epochs", - ) - parser.add_argument( - "--lr", - type=float, - default=1e-4, - help="learning rate", - ) - parser.add_argument( - "--train-batch-size", - type=int, - default=3, - help="train batch size", - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=3, - help="eval batch size", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=6, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--eval-freq", - type=int, - default=0, #200 - help="eval frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-freq", - type=int, - default=100, - help="checkpoint frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-dir", - type=str, - default="checkpoints/temp", #"checkpoints/diversity_v1_4" - help="directory to save checkpoints", - ) - parser.add_argument( - "--load-checkpoint", - type=str, - default='/oscar/data/stellex/shared/rt1-checkpoints/checkpoints/bridge/checkpoint_14400_loss_70.621.pt', #NOTE: include the path to load the checkpoint here - help="checkpoint to load from; defaults to None", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - - parser.add_argument( - "--eval-scene", - default=4, - help = "scene used as validation during k-fold cross validation", - ) - - parser.add_argument( - "--split-type", - default = 'k_fold_scene', - choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], - ) - - parser.add_argument( - "--num-diversity-scenes", - default = 4, - ) - - parser.add_argument( - "--max-diversity-trajectories", - default = 100, - ) - - - parser.add_argument( - "--train-subbatch", - default=8, - ) - parser.add_argument( - "--eval-subbatch", - default=5, - ) - return parser.parse_args() - - -def main(): - - - args = parse_args() - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - if args.wandb: - wandb.init(project="rt1-data-diversity-v1", config=vars(args)) - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - print("Loading dataset...") - - - dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) - - if args.wandb and args.split_type == 'diversity_ablation': - wandb.log({"task_keys": dataset_manager.train_dataset.dataset_keys}) - - train_dataloader = DataLoader(dataset_manager.train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=0, collate_fn= dataset_manager.collate_batches, drop_last = False) - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=True, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) - - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - - action_space = gym.spaces.Dict( - - body_yaw_delta = gym.spaces.Box( - low= 0, #train_dataloader.body_orientation_lim['min_yaw'] - high= 255, #train_dataloader.body_orientation_lim['max_yaw'] - shape=(1,), - dtype=int - ), - - body_pitch_delta = gym.spaces.Discrete(3), - - terminate_episode=gym.spaces.Discrete(2), - - pickup_release = gym.spaces.Discrete(3), - - body_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - arm_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - control_mode = gym.spaces.Discrete(7), - - ) - - print("Building policy...") - policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=args.load_checkpoint, - ) - - policy.model.train() - optimizer = Adam(policy.model.parameters(), lr=args.lr) - - #NOTE: has to be Not None because of raw instruction input - - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") - ) - - - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - def get_text_embedding(observation: Dict): - - if args.sentence_transformer is not None: - return text_embedding_model.encode(observation) - else: - embedded_observation = [] - - for i in range(0, observation.shape[1]): - - try: - embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) - except: - print('EMBEDDING FAILED!') - - - embedded_observation = np.stack(embedded_observation, axis=1) - return embedded_observation - - print("Training...") - num_batches = 0 - total_train_steps = 0 - total_val_steps = 0 - - - - - for epoch in range(args.epochs): - print("STARTING EPOCH {}".format(epoch+1)) - - for batch, train_batch in enumerate(train_dataloader): - - - batch_steps = train_batch[0].shape[0] - - for idx in range(0, batch_steps, args.train_subbatch): - - - - policy.model.train() - - num_batches += 1 - - - observations = { - "image": train_batch[0][idx : min(idx + args.train_subbatch, batch_steps)], - "context": get_text_embedding(train_batch[1][idx : min(idx + args.train_subbatch, batch_steps)]), - } - - - actions = { - 'terminate_episode': train_batch[2][idx : min(idx + args.train_subbatch, batch_steps)], - 'pickup_release': train_batch[3][idx : min(idx + args.train_subbatch, batch_steps)], - 'body_position_delta': train_batch[4][idx : min(idx + args.train_subbatch, batch_steps)], - 'body_yaw_delta': train_batch[5][idx : min(idx + args.train_subbatch, batch_steps)], - 'body_pitch_delta': train_batch[6][idx : min(idx + args.train_subbatch, batch_steps)], - 'arm_position_delta': train_batch[7][idx : min(idx + args.train_subbatch, batch_steps)], - 'control_mode': train_batch[8][idx : min(idx + args.train_subbatch, batch_steps)] - } - - padding = train_batch[9][idx : min(idx + args.train_subbatch, batch_steps)] - total_train_steps += batch_steps - - - loss, loss_std = policy.loss(observations, actions) - - if args.wandb: - print(f"Train loss Batch {num_batches}: {loss.item()} ± {loss_std.item()}") - wandb.log({"train_loss": loss.item(), "train_loss_std": loss_std.item()}, step= total_train_steps) - else: - print(f"Train loss Batch {num_batches}: {loss.item()}") - - optimizer.zero_grad() - loss.backward() - optimizer.step() - observations = {}; actions = {} - - - if args.eval_freq and num_batches % args.eval_freq == 0: - - # Clear cache and collected garbage - gc.collect() - torch.cuda.empty_cache() - - total_eval_loss = 0 - total_eval_loss_std = 0 - total_eval_count = 0 - - - - print("Evaluating...") - for batch, val_batch in enumerate(val_dataloader): - - batch_steps = val_batch[0].shape[0] - - print(f'Section {batch+1} of {len(val_dataloader)}') - - for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): - - - policy.model.eval() - - - total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - - observations = { - "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], - "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), - } - - - actions = { - 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], - 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], - 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], - 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] - } - - padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] - - eval_loss, eval_loss_std = policy.loss(observations, actions) - - - total_eval_loss += eval_loss.item()*observations['image'].shape[0] - total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] - - if args.wandb: - wandb.log( - {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, - step=total_train_steps, - ) - print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") - else: - print(f"Eval loss Batch {num_batches}: {total_eval_loss/total_eval_count}") - - if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: - checkpoint_path = ( - f"{args.checkpoint_dir}/checkpoint_" - + f"{total_train_steps}" - + f"_loss_{loss.item():.3f}.pt" - ) - torch.save(policy.model.state_dict(), checkpoint_path) - print(f"Saved checkpoint to {checkpoint_path}") - - print("FINISHED EPOCH {}".format(epoch+1)) - print("finished training") - -if __name__ == "__main__": - main() diff --git a/main_ft_eval.py b/main_ft_eval.py deleted file mode 100644 index 708243b25..000000000 --- a/main_ft_eval.py +++ /dev/null @@ -1,279 +0,0 @@ -import argparse -import os -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -import tensorflow_hub as hub -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy -from tqdm import tqdm -from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader -import gc - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--datasets", - type=list, - default=["fractal20220817_data"], - ) - parser.add_argument( - "--train-split", - type=str, - default="train[:-1000]", - help="use e.g. train[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-split", - type=str, - default="train[-1000:]", - help="use e.g. eval[:100] for the first 100 episodes", - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=3, - help="eval batch size", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=6, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--checkpoint-path", - type=str, - default="checkpoints/scene4", - help="directory to save checkpoints", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - - parser.add_argument( - "--eval-scene", - default=4, - help = "scene used as validation during k-fold cross validation", - ) - parser.add_argument( - "--eval-subbatch", - default=5, - ) - parser.add_argument( - "--split-type", - default = 'k_fold_scene', - choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], - ) - - parser.add_argument( - "--num-diversity-scenes", - default = 4, - ) - - parser.add_argument( - "--max-diversity-trajectories", - default = 100, - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - - os.makedirs(args.checkpoint_path, exist_ok=True) - - if args.wandb: - wandb.init(project="rt1-finetuning", config=vars(args)) - - os.makedirs(args.checkpoint_path, exist_ok=True) - - assert(len(os.listdir(args.checkpoint_path)) > 0 , "ERROR: checkpoint path is empty and has no saved checkpoints") - - print("Loading dataset...") - - - dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) - - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - - action_space = gym.spaces.Dict( - - body_yaw_delta = gym.spaces.Box( - low= 0, #train_dataloader.body_orientation_lim['min_yaw'] - high= 255, #train_dataloader.body_orientation_lim['max_yaw'] - shape=(1,), - dtype=int - ), - - body_pitch_delta = gym.spaces.Discrete(3), - - terminate_episode=gym.spaces.Discrete(2), - - pickup_release = gym.spaces.Discrete(3), - - body_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - arm_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - control_mode = gym.spaces.Discrete(7), - - ) - - - - #NOTE: has to be Not None because of raw instruction input - - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") - ) - - - - - def get_text_embedding(observation: Dict): - - if args.sentence_transformer is not None: - return text_embedding_model.encode(observation) - else: - embedded_observation = [] - - for i in range(0, observation.shape[1]): - - try: - embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) - except: - pdb.set_trace() - - embedded_observation = np.stack(embedded_observation, axis=1) - return embedded_observation - - - def extract_train_step(filepath): - return int(filepath.split('_')[1]) - - - print("Evaluating...") - - - for idx, checkpoint_file in enumerate(list(sorted(os.listdir(args.checkpoint_path), key=extract_train_step))): - - print(f'Evaluating file: {idx} of {len(os.listdir(args.checkpoint_path))}') - total_train_steps = int(checkpoint_file.split('_')[1]) - total_val_steps = 0 - - - total_eval_loss = 0 - total_eval_loss_std = 0 - total_eval_count = 0 - - print("Building policy...") - policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=os.path.join(args.checkpoint_path, checkpoint_file), - ) - - - - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - - - for batch, val_batch in enumerate(val_dataloader): - - batch_steps = val_batch[0].shape[0] - - print(f'Section {batch+1} of {len(val_dataloader)}') - - for idx in tqdm(range(0, batch_steps, args.eval_subbatch)): - - - policy.model.eval() - - - total_val_steps += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - total_eval_count += val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)].shape[0] - - observations = { - "image": val_batch[0][idx : min(idx + args.eval_subbatch, batch_steps)], - "context": get_text_embedding(val_batch[1][idx : min(idx + args.eval_subbatch, batch_steps)]), - } - - - actions = { - 'terminate_episode': val_batch[2][idx : min(idx + args.eval_subbatch, batch_steps)], - 'pickup_release': val_batch[3][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_position_delta': val_batch[4][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_yaw_delta': val_batch[5][idx : min(idx + args.eval_subbatch, batch_steps)], - 'body_pitch_delta': val_batch[6][idx : min(idx + args.eval_subbatch, batch_steps)], - 'arm_position_delta': val_batch[7][idx : min(idx + args.eval_subbatch, batch_steps)], - 'control_mode': val_batch[8][idx : min(idx + args.eval_subbatch, batch_steps)] - } - - padding = val_batch[9][idx : min(idx + args.eval_subbatch, batch_steps)] - - eval_loss, eval_loss_std = policy.loss(observations, actions) - - - total_eval_loss += eval_loss.item()*observations['image'].shape[0] - total_eval_loss_std += np.power(eval_loss_std.item(), 2)*observations['image'].shape[0] - - if args.wandb: - wandb.log( - {"eval_loss": total_eval_loss/total_eval_count, "eval_loss_std": np.sqrt(total_eval_loss_std/total_eval_count)}, - step=total_train_steps, - ) - print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") - else: - print(f"Eval loss Step {total_train_steps}: {total_eval_loss/total_eval_count}") - -if __name__ == "__main__": - main() diff --git a/rollout_ai2thor.py b/rollout_ai2thor.py deleted file mode 100644 index 0edf255ca..000000000 --- a/rollout_ai2thor.py +++ /dev/null @@ -1,366 +0,0 @@ -import argparse -import os -os.environ["CUDA_VISIBLE_DEVICES"] = "0" -from typing import Dict -import pdb -import gymnasium as gym -import numpy as np -import torch -import wandb -from sentence_transformers import SentenceTransformer -from torch.optim import Adam -import tensorflow_hub as hub -from data import create_dataset -from rt1_pytorch.rt1_policy import RT1Policy -from tqdm import tqdm -from lanmp_dataloader.rt1_dataloader import DatasetManager, DataLoader -import gc -import json -import pandas as pd -from ai2thor_env import ThorEnv -import pickle -import time -from tqdm import tqdm - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--sentence-transformer", - type=str, - default=None, - help="SentenceTransformer to use; default is None for original USE embeddings", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--checkpoint-file-path", - type=str, - default="checkpoints/scene2/checkpoint_299183_loss_152.175.pt", #NOTE: change according to checkpoint file that is to be loaded - help="directory to save checkpoints", - ) - - parser.add_argument( - "--trajectory-save-path", - type=str, - default="traj_rollouts/scene2", - help = "directory to save the generated trajectory predicted by the model" - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - parser.add_argument( - "--eval-scene", - default=2, - help = "scene used as validation during k-fold cross validation", - ) - parser.add_argument( - "--eval-subbatch", - default=1, - ) - parser.add_argument( - "--split-type", - default = 'k_fold_scene', - choices = ['k_fold_scene', 'task_split', 'diversity_ablation'], - ) - parser.add_argument( - "--num-diversity-scenes", - default = 3, - ) - parser.add_argument( - "--max-diversity-trajectories", - default = 100, - ) - parser.add_argument( - "--eval-batch-size", - type=int, - default=3, - help="eval batch size", - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - if args.wandb: - wandb.init(project="rt1-rollout-data", config=vars(args)) - - os.makedirs(args.trajectory_save_path, exist_ok=True) - - assert(os.path.isfile(args.checkpoint_file_path), "ERROR: checkpoint file does not exist") - - - print("Loading dataset...") - - dataset_manager = DatasetManager(args.eval_scene, 0.8, 0.1, 0.1, split_style = args.split_type, diversity_scenes = args.num_diversity_scenes, max_trajectories = args.max_diversity_trajectories) - val_dataloader = DataLoader(dataset_manager.val_dataset, batch_size = args.eval_batch_size, shuffle=False, num_workers=2, collate_fn= dataset_manager.collate_batches, drop_last = False) - - - observation_space = gym.spaces.Dict( - image=gym.spaces.Box(low=0, high=255, shape=(128, 128, 3)), - context=gym.spaces.Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - - action_space = gym.spaces.Dict( - - body_yaw_delta = gym.spaces.Box( - low= 0, #train_dataloader.body_orientation_lim['min_yaw'] - high= 255, #train_dataloader.body_orientation_lim['max_yaw'] - shape=(1,), - dtype=int - ), - - body_pitch_delta = gym.spaces.Discrete(3), - - terminate_episode=gym.spaces.Discrete(2), - - pickup_release = gym.spaces.Discrete(3), - - body_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - arm_position_delta = gym.spaces.Box( - low = 0, - high = 255, - shape = (3,), - dtype = np.int32 - ), - - control_mode = gym.spaces.Discrete(7), - - ) - - - - #NOTE: has to be Not None because of raw instruction input - text_embedding_model = ( - SentenceTransformer(args.sentence_transformer) - if args.sentence_transformer - else hub.load("https://tfhub.dev/google/universal-sentence-encoder/4") - ) - - - - - def get_text_embedding(observation: Dict): - - if args.sentence_transformer is not None: - return text_embedding_model.encode(observation) - else: - embedded_observation = [] - - for i in range(0, observation.shape[1]): - - try: - embedded_observation.append( np.array(text_embedding_model(observation[:, i]) ) ) - except: - raise Exception('Error: task descriptions could not be embedded') - - embedded_observation = np.stack(embedded_observation, axis=1) - return embedded_observation - - - - - print("Loading chosen checkpoint to model...") - rt1_model_policy = RT1Policy( - observation_space=observation_space, - action_space=action_space, - device=args.device, - checkpoint_path=args.checkpoint_file_path, - ) - rt1_model_policy.model.eval() - - # Total number of params - total_params = sum(p.numel() for p in rt1_model_policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in rt1_model_policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in rt1_model_policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - - print('Creating pandas dataframe for trajectories...') - - print_val = True - - - for task in tqdm(val_dataloader.dataset.dataset_keys): - - - #skip tasks that trajectory already generated for - if os.path.isfile(os.path.join(args.trajectory_save_path, task)): - continue - elif print_val: - print('START AT: ', val_dataloader.dataset.dataset_keys.index(task)) - print_val = False - - traj_group = val_dataloader.dataset.hdf[task] - - traj_steps = list(traj_group.keys()) - - #extract the NL command - json_str = traj_group[traj_steps[0]].attrs['metadata'] - traj_json_dict = json.loads(json_str) - language_command_embedding = get_text_embedding(np.array([[traj_json_dict['nl_command']]])) - language_command_embedding = np.repeat(language_command_embedding, 6, axis=1) - - - print('TASK: ', traj_json_dict['nl_command']) - - #initialize the AI2Thor environment - ai2thor_env = ThorEnv(traj_json_dict['nl_command']) - event = ai2thor_env.reset(traj_json_dict['scene']) - - - - #extract the visual observation from initialzed environment - curr_image = event.frame - visual_observation = np.expand_dims(np.expand_dims(curr_image, axis=0) , axis=0) - visual_observation = np.repeat(visual_observation, 6, axis=1) - - ''' - OLD OBS FROM DATASET - visual_observation = np.expand_dims(np.expand_dims(np.array(traj_group[traj_steps[0]]['rgb_0']), axis=0), axis=0) - visual_observation = np.repeat(visual_observation, 6, axis=1) - ''' - - #track the starting coordinates for body, yaw rotation and arm coordinate - curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) - curr_body_yaw = event.metadata['agent']['rotation']['y'] - curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) - agent_holding = np.array([]) - - - #track the total number of steps and the last control mode - num_steps = 0; curr_mode = None; is_terminal = False - - - #track data for all steps - trajectory_data = [] - - while (curr_mode != 'stop' or is_terminal) and num_steps < ai2thor_env.max_episode_length: - - #provide the current observation to the model - curr_observation = { - 'image': visual_observation, - 'context': language_command_embedding - } - - generated_action_tokens = rt1_model_policy.act(curr_observation) - - #de-tokenize the generated actions from RT1 - pickup_release = val_dataloader.dataset.detokenize_pickup_release(generated_action_tokens['pickup_release'][0]) - body_pitch = val_dataloader.dataset.detokenize_head_pitch(generated_action_tokens['body_pitch_delta'][0]) - curr_mode = val_dataloader.dataset.detokenize_mode(generated_action_tokens['control_mode'][0]) - - - - - terminate_episode = generated_action_tokens['terminate_episode'][0] - - continuous_variables = { - 'body_position_delta': generated_action_tokens['body_position_delta'], - 'body_yaw_delta': generated_action_tokens['body_yaw_delta'], - 'arm_position_delta': generated_action_tokens['arm_position_delta'], - 'curr_mode': curr_mode - } - - continuous_variables = val_dataloader.dataset.detokenize_continuous_data(continuous_variables) - body_position_delta = np.squeeze(continuous_variables['body_position_delta']) - body_yaw_delta = continuous_variables['body_yaw_delta'][0][0] - arm_position_delta = np.squeeze(continuous_variables['arm_position_delta']) - - curr_action = val_dataloader.dataset.detokenize_action(curr_mode, body_position_delta, body_yaw_delta, arm_position_delta, pickup_release, body_pitch) - - - - #update the tracked coordinate data based on model output - curr_body_coordinate += body_position_delta - curr_body_yaw += body_yaw_delta - curr_arm_coordinate += arm_position_delta - - - #execute the generated action in the AI2THOR simulator - step_args = { - 'xyz_body': curr_body_coordinate, - 'xyz_body_delta': body_position_delta, - 'curr_body_yaw': curr_body_yaw, - 'body_yaw_delta': body_yaw_delta, - 'arm_position_delta': arm_position_delta, - 'arm_position': curr_arm_coordinate - } - success, error, event = ai2thor_env.step(curr_action, step_args) - - time.sleep(0.25) - - #fetch object holding from simulator; also maybe fetch coordinate of body/arm + yaw from simulator - agent_holding = np.array(event.metadata['arm']['heldObjects']) - - #fetch the new visual observation from the simulator, update the current mode and increment number of steps - curr_image = np.expand_dims(np.expand_dims(event.frame, axis=0) , axis=0) - - visual_observation = visual_observation[:,1:,:,:,:] - visual_observation = np.concatenate((visual_observation, curr_image), axis=1) - num_steps +=1 - - curr_body_coordinate = np.array(list(event.metadata['agent']['position'].values())) - curr_body_yaw = event.metadata['agent']['rotation']['y'] - curr_arm_coordinate = np.array(list(event.metadata['arm']['handSphereCenter'].values())) - - - #add data to the dataframe CSV - step_data = { - 'task': traj_json_dict['nl_command'], - 'scene': traj_json_dict['scene'], - 'img': curr_image, - 'xyz_body': curr_body_coordinate, - 'xyz_body_delta': body_position_delta, - 'yaw_body': curr_body_yaw, - 'yaw_body_delta': body_yaw_delta, - 'pitch_body': body_pitch, - 'xyz_ee': curr_arm_coordinate, - 'xyz_ee_delta': arm_position_delta, - 'pickup_dropoff': pickup_release, - 'holding_obj': agent_holding, - 'control_mode': curr_mode, - 'action': curr_action, - 'terminate': terminate_episode, - 'step': num_steps, - 'timeout': num_steps >= ai2thor_env.max_episode_length, - 'error': error - } - - trajectory_data.append(step_data) - - #save the final event with all metadata: save as a json file dict - save_path = os.path.join(args.trajectory_save_path, task) - with open(save_path, 'wb') as file: - pickle.dump({'trajectory_data': trajectory_data, 'final_state': event.metadata}, file) - - #close the old GUI for AI2Thor after trajectory finishes - ai2thor_env.controller.stop() - time.sleep(0.5) - - - - - - - -if __name__ == "__main__": - main() diff --git a/rt1_env/bin/Activate.ps1 b/rt1_env/bin/Activate.ps1 deleted file mode 100644 index 9d3646a4f..000000000 --- a/rt1_env/bin/Activate.ps1 +++ /dev/null @@ -1,241 +0,0 @@ -<# -.Synopsis -Activate a Python virtual environment for the current PowerShell session. - -.Description -Pushes the python executable for a virtual environment to the front of the -$Env:PATH environment variable and sets the prompt to signify that you are -in a Python virtual environment. Makes use of the command line switches as -well as the `pyvenv.cfg` file values present in the virtual environment. - -.Parameter VenvDir -Path to the directory that contains the virtual environment to activate. The -default value for this is the parent of the directory that the Activate.ps1 -script is located within. - -.Parameter Prompt -The prompt prefix to display when this virtual environment is activated. By -default, this prompt is the name of the virtual environment folder (VenvDir) -surrounded by parentheses and followed by a single space (ie. '(.venv) '). - -.Example -Activate.ps1 -Activates the Python virtual environment that contains the Activate.ps1 script. - -.Example -Activate.ps1 -Verbose -Activates the Python virtual environment that contains the Activate.ps1 script, -and shows extra information about the activation as it executes. - -.Example -Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv -Activates the Python virtual environment located in the specified location. - -.Example -Activate.ps1 -Prompt "MyPython" -Activates the Python virtual environment that contains the Activate.ps1 script, -and prefixes the current prompt with the specified string (surrounded in -parentheses) while the virtual environment is active. - -.Notes -On Windows, it may be required to enable this Activate.ps1 script by setting the -execution policy for the user. You can do this by issuing the following PowerShell -command: - -PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser - -For more information on Execution Policies: -https://go.microsoft.com/fwlink/?LinkID=135170 - -#> -Param( - [Parameter(Mandatory = $false)] - [String] - $VenvDir, - [Parameter(Mandatory = $false)] - [String] - $Prompt -) - -<# Function declarations --------------------------------------------------- #> - -<# -.Synopsis -Remove all shell session elements added by the Activate script, including the -addition of the virtual environment's Python executable from the beginning of -the PATH variable. - -.Parameter NonDestructive -If present, do not remove this function from the global namespace for the -session. - -#> -function global:deactivate ([switch]$NonDestructive) { - # Revert to original values - - # The prior prompt: - if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { - Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt - Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT - } - - # The prior PYTHONHOME: - if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { - Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME - Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME - } - - # The prior PATH: - if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { - Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH - Remove-Item -Path Env:_OLD_VIRTUAL_PATH - } - - # Just remove the VIRTUAL_ENV altogether: - if (Test-Path -Path Env:VIRTUAL_ENV) { - Remove-Item -Path env:VIRTUAL_ENV - } - - # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: - if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { - Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force - } - - # Leave deactivate function in the global namespace if requested: - if (-not $NonDestructive) { - Remove-Item -Path function:deactivate - } -} - -<# -.Description -Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the -given folder, and returns them in a map. - -For each line in the pyvenv.cfg file, if that line can be parsed into exactly -two strings separated by `=` (with any amount of whitespace surrounding the =) -then it is considered a `key = value` line. The left hand string is the key, -the right hand is the value. - -If the value starts with a `'` or a `"` then the first and last character is -stripped from the value before being captured. - -.Parameter ConfigDir -Path to the directory that contains the `pyvenv.cfg` file. -#> -function Get-PyVenvConfig( - [String] - $ConfigDir -) { - Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" - - # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). - $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue - - # An empty map will be returned if no config file is found. - $pyvenvConfig = @{ } - - if ($pyvenvConfigPath) { - - Write-Verbose "File exists, parse `key = value` lines" - $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath - - $pyvenvConfigContent | ForEach-Object { - $keyval = $PSItem -split "\s*=\s*", 2 - if ($keyval[0] -and $keyval[1]) { - $val = $keyval[1] - - # Remove extraneous quotations around a string value. - if ("'""".Contains($val.Substring(0, 1))) { - $val = $val.Substring(1, $val.Length - 2) - } - - $pyvenvConfig[$keyval[0]] = $val - Write-Verbose "Adding Key: '$($keyval[0])'='$val'" - } - } - } - return $pyvenvConfig -} - - -<# Begin Activate script --------------------------------------------------- #> - -# Determine the containing directory of this script -$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition -$VenvExecDir = Get-Item -Path $VenvExecPath - -Write-Verbose "Activation script is located in path: '$VenvExecPath'" -Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" -Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" - -# Set values required in priority: CmdLine, ConfigFile, Default -# First, get the location of the virtual environment, it might not be -# VenvExecDir if specified on the command line. -if ($VenvDir) { - Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" -} -else { - Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." - $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") - Write-Verbose "VenvDir=$VenvDir" -} - -# Next, read the `pyvenv.cfg` file to determine any required value such -# as `prompt`. -$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir - -# Next, set the prompt from the command line, or the config file, or -# just use the name of the virtual environment folder. -if ($Prompt) { - Write-Verbose "Prompt specified as argument, using '$Prompt'" -} -else { - Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" - if ($pyvenvCfg -and $pyvenvCfg['prompt']) { - Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" - $Prompt = $pyvenvCfg['prompt']; - } - else { - Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" - Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" - $Prompt = Split-Path -Path $venvDir -Leaf - } -} - -Write-Verbose "Prompt = '$Prompt'" -Write-Verbose "VenvDir='$VenvDir'" - -# Deactivate any currently active virtual environment, but leave the -# deactivate function in place. -deactivate -nondestructive - -# Now set the environment variable VIRTUAL_ENV, used by many tools to determine -# that there is an activated venv. -$env:VIRTUAL_ENV = $VenvDir - -if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { - - Write-Verbose "Setting prompt to '$Prompt'" - - # Set the prompt to include the env name - # Make sure _OLD_VIRTUAL_PROMPT is global - function global:_OLD_VIRTUAL_PROMPT { "" } - Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT - New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt - - function global:prompt { - Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " - _OLD_VIRTUAL_PROMPT - } -} - -# Clear PYTHONHOME -if (Test-Path -Path Env:PYTHONHOME) { - Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME - Remove-Item -Path Env:PYTHONHOME -} - -# Add the venv to the PATH -Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH -$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/rt1_env/bin/activate b/rt1_env/bin/activate deleted file mode 100644 index 2fdaa7bfa..000000000 --- a/rt1_env/bin/activate +++ /dev/null @@ -1,66 +0,0 @@ -# This file must be used with "source bin/activate" *from bash* -# you cannot run it directly - -deactivate () { - # reset old environment variables - if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then - PATH="${_OLD_VIRTUAL_PATH:-}" - export PATH - unset _OLD_VIRTUAL_PATH - fi - if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then - PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" - export PYTHONHOME - unset _OLD_VIRTUAL_PYTHONHOME - fi - - # This should detect bash and zsh, which have a hash command that must - # be called to get it to forget past commands. Without forgetting - # past commands the $PATH changes we made may not be respected - if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then - hash -r 2> /dev/null - fi - - if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then - PS1="${_OLD_VIRTUAL_PS1:-}" - export PS1 - unset _OLD_VIRTUAL_PS1 - fi - - unset VIRTUAL_ENV - if [ ! "${1:-}" = "nondestructive" ] ; then - # Self destruct! - unset -f deactivate - fi -} - -# unset irrelevant variables -deactivate nondestructive - -VIRTUAL_ENV="/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" -export VIRTUAL_ENV - -_OLD_VIRTUAL_PATH="$PATH" -PATH="$VIRTUAL_ENV/bin:$PATH" -export PATH - -# unset PYTHONHOME if set -# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) -# could use `if (set -u; : $PYTHONHOME) ;` in bash -if [ -n "${PYTHONHOME:-}" ] ; then - _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" - unset PYTHONHOME -fi - -if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then - _OLD_VIRTUAL_PS1="${PS1:-}" - PS1="(rt1_env) ${PS1:-}" - export PS1 -fi - -# This should detect bash and zsh, which have a hash command that must -# be called to get it to forget past commands. Without forgetting -# past commands the $PATH changes we made may not be respected -if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then - hash -r 2> /dev/null -fi diff --git a/rt1_env/bin/activate.csh b/rt1_env/bin/activate.csh deleted file mode 100644 index af00fde95..000000000 --- a/rt1_env/bin/activate.csh +++ /dev/null @@ -1,25 +0,0 @@ -# This file must be used with "source bin/activate.csh" *from csh*. -# You cannot run it directly. -# Created by Davide Di Blasi . -# Ported to Python 3.3 venv by Andrew Svetlov - -alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate' - -# Unset irrelevant variables. -deactivate nondestructive - -setenv VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" - -set _OLD_VIRTUAL_PATH="$PATH" -setenv PATH "$VIRTUAL_ENV/bin:$PATH" - - -set _OLD_VIRTUAL_PROMPT="$prompt" - -if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then - set prompt = "(rt1_env) $prompt" -endif - -alias pydoc python -m pydoc - -rehash diff --git a/rt1_env/bin/activate.fish b/rt1_env/bin/activate.fish deleted file mode 100644 index 388919ed3..000000000 --- a/rt1_env/bin/activate.fish +++ /dev/null @@ -1,64 +0,0 @@ -# This file must be used with "source /bin/activate.fish" *from fish* -# (https://fishshell.com/); you cannot run it directly. - -function deactivate -d "Exit virtual environment and return to normal shell environment" - # reset old environment variables - if test -n "$_OLD_VIRTUAL_PATH" - set -gx PATH $_OLD_VIRTUAL_PATH - set -e _OLD_VIRTUAL_PATH - end - if test -n "$_OLD_VIRTUAL_PYTHONHOME" - set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME - set -e _OLD_VIRTUAL_PYTHONHOME - end - - if test -n "$_OLD_FISH_PROMPT_OVERRIDE" - functions -e fish_prompt - set -e _OLD_FISH_PROMPT_OVERRIDE - functions -c _old_fish_prompt fish_prompt - functions -e _old_fish_prompt - end - - set -e VIRTUAL_ENV - if test "$argv[1]" != "nondestructive" - # Self-destruct! - functions -e deactivate - end -end - -# Unset irrelevant variables. -deactivate nondestructive - -set -gx VIRTUAL_ENV "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env" - -set -gx _OLD_VIRTUAL_PATH $PATH -set -gx PATH "$VIRTUAL_ENV/bin" $PATH - -# Unset PYTHONHOME if set. -if set -q PYTHONHOME - set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME - set -e PYTHONHOME -end - -if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" - # fish uses a function instead of an env var to generate the prompt. - - # Save the current fish_prompt function as the function _old_fish_prompt. - functions -c fish_prompt _old_fish_prompt - - # With the original prompt function renamed, we can override with our own. - function fish_prompt - # Save the return status of the last command. - set -l old_status $status - - # Output the venv prompt; color taken from the blue of the Python logo. - printf "%s%s%s" (set_color 4B8BBE) "(rt1_env) " (set_color normal) - - # Restore the return status of the previous command. - echo "exit $old_status" | . - # Output the original/"old" prompt. - _old_fish_prompt - end - - set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" -end diff --git a/rt1_env/bin/ai2thor-xorg b/rt1_env/bin/ai2thor-xorg deleted file mode 100755 index 7bc6235a3..000000000 --- a/rt1_env/bin/ai2thor-xorg +++ /dev/null @@ -1,267 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 -import os -import sys -import time -import platform -import re -import shlex -import subprocess -import argparse -import signal - -# Turning off automatic black formatting for this script as it breaks quotes. -# fmt: off -from typing import List - -PID_FILE = "/var/run/ai2thor-xorg.pid" -CONFIG_FILE = "/tmp/ai2thor-xorg.conf" - -DEFAULT_HEIGHT = 768 -DEFAULT_WIDTH = 1024 - - -def process_alive(pid): - """ - Use kill(0) to determine if pid is alive - :param pid: process id - :rtype: bool - """ - try: - os.kill(pid, 0) - except OSError: - return False - - return True - - -def find_devices(excluded_device_ids): - devices = [] - id_counter = 0 - for r in pci_records(): - if r.get("Vendor", "") == "NVIDIA Corporation" and r["Class"] in [ - "VGA compatible controller", - "3D controller", - ]: - bus_id = "PCI:" + ":".join( - map(lambda x: str(int(x, 16)), re.split(r"[:\.]", r["Slot"])) - ) - - if id_counter not in excluded_device_ids: - devices.append(bus_id) - - id_counter += 1 - - if not devices: - print("Error: ai2thor-xorg requires at least one NVIDIA device") - sys.exit(1) - - return devices - -def active_display_bus_ids(): - # this determines whether a monitor is connected to the GPU - # if one is, the following Option is added for the Screen "UseDisplayDevice" "None" - command = "nvidia-smi --query-gpu=pci.bus_id,display_active --format=csv,noheader" - active_bus_ids = set() - result = subprocess.run(command, shell=True, stdout=subprocess.PIPE) - if result.returncode == 0: - for line in result.stdout.decode().strip().split("\n"): - nvidia_bus_id, display_status = re.split(r",\s?", line.strip()) - bus_id = "PCI:" + ":".join( - map(lambda x: str(int(x, 16)), re.split(r"[:\.]", nvidia_bus_id)[1:]) - ) - if display_status.lower() == "enabled": - active_bus_ids.add(bus_id) - - return active_bus_ids - -def pci_records(): - records = [] - command = shlex.split("lspci -vmm") - output = subprocess.check_output(command).decode() - - for devices in output.strip().split("\n\n"): - record = {} - records.append(record) - for row in devices.split("\n"): - key, value = row.split("\t") - record[key.split(":")[0]] = value - - return records - - -def read_pid(): - if os.path.isfile(PID_FILE): - with open(PID_FILE) as f: - return int(f.read()) - else: - return None - - -def start(display: str, excluded_device_ids: List[int], width: int, height: int): - pid = read_pid() - - if pid and process_alive(pid): - print("Error: ai2thor-xorg is already running with pid: %s" % pid) - sys.exit(1) - - with open(CONFIG_FILE, "w") as f: - f.write(generate_xorg_conf(excluded_device_ids, width=width, height=height)) - - log_file = "/var/log/ai2thor-xorg.%s.log" % display - error_log_file = "/var/log/ai2thor-xorg-error.%s.log" % display - command = shlex.split( - "Xorg -quiet -maxclients 1024 -noreset +extension GLX +extension RANDR +extension RENDER -logfile %s -config %s :%s" - % (log_file, CONFIG_FILE, display) - ) - - pid = None - with open(error_log_file, "w") as error_log_f: - proc = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=error_log_f) - pid = proc.pid - try: - proc.wait(timeout=0.25) - except subprocess.TimeoutExpired: - pass - - if pid and process_alive(pid): - with open(PID_FILE, "w") as f: - f.write(str(proc.pid)) - else: - print("Error: error with command '%s'" % " ".join(command)) - with open(error_log_file, "r") as f: - print(f.read()) - - -def print_config(excluded_device_ids: List[int], width: int, height: int): - print(generate_xorg_conf(excluded_device_ids, width=width, height=height)) - - -def stop(): - pid = read_pid() - if pid and process_alive(pid): - os.kill(pid, signal.SIGTERM) - - for i in range(10): - time.sleep(0.2) - if not process_alive(pid): - os.unlink(PID_FILE) - break - - -def generate_xorg_conf( - excluded_device_ids: List[int], width: int, height: int -): - devices = find_devices(excluded_device_ids) - active_display_devices = active_display_bus_ids() - - xorg_conf = [] - - device_section = """ -Section "Device" - Identifier "Device{device_id}" - Driver "nvidia" - VendorName "NVIDIA Corporation" - BusID "{bus_id}" -EndSection -""" - server_layout_section = """ -Section "ServerLayout" - Identifier "Layout0" - {screen_records} -EndSection -""" - screen_section = """ -Section "Screen" - Identifier "Screen{screen_id}" - Device "Device{device_id}" - DefaultDepth 24 - Option "AllowEmptyInitialConfiguration" "True" - Option "Interactive" "False" - {extra_options} - SubSection "Display" - Depth 24 - Virtual {width} {height} - EndSubSection -EndSection -""" - screen_records = [] - for i, bus_id in enumerate(devices): - extra_options = "" - if bus_id in active_display_devices: - # See https://github.com/allenai/ai2thor/pull/990 - # when a monitor is connected, this option must be used otherwise - # Xorg will fail to start - extra_options = 'Option "UseDisplayDevice" "None"' - xorg_conf.append(device_section.format(device_id=i, bus_id=bus_id)) - xorg_conf.append(screen_section.format(device_id=i, screen_id=i, width=width, height=height, extra_options=extra_options)) - screen_records.append( - 'Screen {screen_id} "Screen{screen_id}" 0 0'.format(screen_id=i) - ) - - xorg_conf.append( - server_layout_section.format(screen_records="\n ".join(screen_records)) - ) - - output = "\n".join(xorg_conf) - return output - - -# fmt: on - -if __name__ == "__main__": - if os.geteuid() != 0: - path = os.path.abspath(__file__) - print("Executing ai2thor-xorg with sudo") - args = ["--", path] + sys.argv[1:] - os.execvp("sudo", args) - - if platform.system() != "Linux": - print("Error: Can only run ai2thor-xorg on linux") - sys.exit(1) - - parser = argparse.ArgumentParser() - parser.add_argument( - "--exclude-device", - help="exclude a specific GPU device", - action="append", - type=int, - default=[], - ) - parser.add_argument( - "--width", - help="width of the screen to start (should be greater than the maximum" - f" width of any ai2thor instance you will start) [default: {DEFAULT_WIDTH}]", - type=int, - default=DEFAULT_WIDTH, - ) - parser.add_argument( - "--height", - help="height of the screen to start (should be greater than the maximum" - f" height of any ai2thor instance you will start) [default: {DEFAULT_HEIGHT}]", - type=int, - default=DEFAULT_HEIGHT, - ) - parser.add_argument( - "command", - help="command to be executed", - choices=["start", "stop", "print-config"], - ) - parser.add_argument( - "display", help="display to be used", nargs="?", type=int, default=0 - ) - args = parser.parse_args() - if args.command == "start": - start( - display=args.display, - excluded_device_ids=args.exclude_device, - height=args.height, - width=args.width, - ) - elif args.command == "stop": - stop() - elif args.command == "print-config": - print_config( - excluded_device_ids=args.exclude_device, - width=args.width, - height=args.height, - ) diff --git a/rt1_env/bin/convert-caffe2-to-onnx b/rt1_env/bin/convert-caffe2-to-onnx deleted file mode 100755 index 0294702e2..000000000 --- a/rt1_env/bin/convert-caffe2-to-onnx +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from caffe2.python.onnx.bin.conversion import caffe2_to_onnx -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(caffe2_to_onnx()) diff --git a/rt1_env/bin/convert-onnx-to-caffe2 b/rt1_env/bin/convert-onnx-to-caffe2 deleted file mode 100755 index daed37802..000000000 --- a/rt1_env/bin/convert-onnx-to-caffe2 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from caffe2.python.onnx.bin.conversion import onnx_to_caffe2 -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(onnx_to_caffe2()) diff --git a/rt1_env/bin/f2py b/rt1_env/bin/f2py deleted file mode 100755 index 6ae2c3109..000000000 --- a/rt1_env/bin/f2py +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from numpy.f2py.f2py2e import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/flask b/rt1_env/bin/flask deleted file mode 100755 index fa566a3ba..000000000 --- a/rt1_env/bin/flask +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from flask.cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/huggingface-cli b/rt1_env/bin/huggingface-cli deleted file mode 100755 index 5580d7dc9..000000000 --- a/rt1_env/bin/huggingface-cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from huggingface_hub.commands.huggingface_cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/imageio_download_bin b/rt1_env/bin/imageio_download_bin deleted file mode 100755 index 2e17ded5a..000000000 --- a/rt1_env/bin/imageio_download_bin +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from imageio.__main__ import download_bin_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(download_bin_main()) diff --git a/rt1_env/bin/imageio_remove_bin b/rt1_env/bin/imageio_remove_bin deleted file mode 100755 index bbbdac364..000000000 --- a/rt1_env/bin/imageio_remove_bin +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from imageio.__main__ import remove_bin_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(remove_bin_main()) diff --git a/rt1_env/bin/import_pb_to_tensorboard b/rt1_env/bin/import_pb_to_tensorboard deleted file mode 100755 index 47503b8c4..000000000 --- a/rt1_env/bin/import_pb_to_tensorboard +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.python.tools.import_pb_to_tensorboard import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/isympy b/rt1_env/bin/isympy deleted file mode 100755 index 8f709363b..000000000 --- a/rt1_env/bin/isympy +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from isympy import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/jp.py b/rt1_env/bin/jp.py deleted file mode 100755 index 2a3859f1f..000000000 --- a/rt1_env/bin/jp.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 - -import sys -import json -import argparse -from pprint import pformat - -import jmespath -from jmespath import exceptions - - -def main(): - parser = argparse.ArgumentParser() - parser.add_argument('expression') - parser.add_argument('-f', '--filename', - help=('The filename containing the input data. ' - 'If a filename is not given then data is ' - 'read from stdin.')) - parser.add_argument('--ast', action='store_true', - help=('Pretty print the AST, do not search the data.')) - args = parser.parse_args() - expression = args.expression - if args.ast: - # Only print the AST - expression = jmespath.compile(args.expression) - sys.stdout.write(pformat(expression.parsed)) - sys.stdout.write('\n') - return 0 - if args.filename: - with open(args.filename, 'r') as f: - data = json.load(f) - else: - data = sys.stdin.read() - data = json.loads(data) - try: - sys.stdout.write(json.dumps( - jmespath.search(expression, data), indent=4, ensure_ascii=False)) - sys.stdout.write('\n') - except exceptions.ArityError as e: - sys.stderr.write("invalid-arity: %s\n" % e) - return 1 - except exceptions.JMESPathTypeError as e: - sys.stderr.write("invalid-type: %s\n" % e) - return 1 - except exceptions.UnknownFunctionError as e: - sys.stderr.write("unknown-function: %s\n" % e) - return 1 - except exceptions.ParseError as e: - sys.stderr.write("syntax-error: %s\n" % e) - return 1 - - -if __name__ == '__main__': - sys.exit(main()) diff --git a/rt1_env/bin/lsm2bin b/rt1_env/bin/lsm2bin deleted file mode 100755 index a4b517af7..000000000 --- a/rt1_env/bin/lsm2bin +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile.lsm2bin import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/markdown-it b/rt1_env/bin/markdown-it deleted file mode 100755 index e58e8d1e4..000000000 --- a/rt1_env/bin/markdown-it +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from markdown_it.cli.parse import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/markdown_py b/rt1_env/bin/markdown_py deleted file mode 100755 index 8424ab33e..000000000 --- a/rt1_env/bin/markdown_py +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from markdown.__main__ import run -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(run()) diff --git a/rt1_env/bin/normalizer b/rt1_env/bin/normalizer deleted file mode 100755 index e3a575f79..000000000 --- a/rt1_env/bin/normalizer +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from charset_normalizer.cli import cli_detect -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(cli_detect()) diff --git a/rt1_env/bin/pip b/rt1_env/bin/pip deleted file mode 100755 index 95ae2f451..000000000 --- a/rt1_env/bin/pip +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pip._internal.cli.main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/pip3 b/rt1_env/bin/pip3 deleted file mode 100755 index 95ae2f451..000000000 --- a/rt1_env/bin/pip3 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pip._internal.cli.main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/pip3.9 b/rt1_env/bin/pip3.9 deleted file mode 100755 index 95ae2f451..000000000 --- a/rt1_env/bin/pip3.9 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pip._internal.cli.main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/portserver.py b/rt1_env/bin/portserver.py deleted file mode 100755 index 6cdc3c0f3..000000000 --- a/rt1_env/bin/portserver.py +++ /dev/null @@ -1,415 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 -# -# Copyright 2015 Google Inc. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -"""A server to hand out network ports to applications running on one host. - -Typical usage: - 1) Run one instance of this process on each of your unittest farm hosts. - 2) Set the PORTSERVER_ADDRESS environment variable in your test runner - environment to let the portpicker library know to use a port server - rather than attempt to find ports on its own. - -$ /path/to/portserver.py & -$ export PORTSERVER_ADDRESS=@unittest-portserver -$ # ... launch a bunch of unittest runners using portpicker ... -""" - -import argparse -import asyncio -import collections -import logging -import signal -import socket -import sys -import psutil -import subprocess -from datetime import datetime, timezone, timedelta - -log = None # Initialized to a logging.Logger by _configure_logging(). - -_PROTOS = [(socket.SOCK_STREAM, socket.IPPROTO_TCP), - (socket.SOCK_DGRAM, socket.IPPROTO_UDP)] - - -def _get_process_command_line(pid): - try: - return psutil.Process(pid).cmdline() - except psutil.NoSuchProcess: - return '' - - -def _get_process_start_time(pid): - try: - return psutil.Process(pid).create_time() - except psutil.NoSuchProcess: - return 0.0 - - -# TODO: Consider importing portpicker.bind() instead of duplicating the code. -def _bind(port, socket_type, socket_proto): - """Try to bind to a socket of the specified type, protocol, and port. - - For the port to be considered available, the kernel must support at least - one of (IPv6, IPv4), and the port must be available on each supported - family. - - Args: - port: The port number to bind to, or 0 to have the OS pick a free port. - socket_type: The type of the socket (ex: socket.SOCK_STREAM). - socket_proto: The protocol of the socket (ex: socket.IPPROTO_TCP). - - Returns: - The port number on success or None on failure. - """ - got_socket = False - for family in (socket.AF_INET6, socket.AF_INET): - try: - sock = socket.socket(family, socket_type, socket_proto) - got_socket = True - except socket.error: - continue - try: - sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - sock.bind(('', port)) - if socket_type == socket.SOCK_STREAM: - sock.listen(1) - port = sock.getsockname()[1] - except socket.error: - return None - finally: - sock.close() - return port if got_socket else None - - -def _is_port_free(port): - """Check if specified port is free. - - Args: - port: integer, port to check - Returns: - boolean, whether it is free to use for both TCP and UDP - """ - return _bind(port, *_PROTOS[0]) and _bind(port, *_PROTOS[1]) - - -def _should_allocate_port(pid): - """Determine if we should allocate a port for use by the given process id.""" - if pid <= 0: - log.info('Not allocating a port to invalid pid') - return False - if pid == 1: - # The client probably meant to send us its parent pid but - # had been reparented to init. - log.info('Not allocating a port to init.') - return False - - if not psutil.pid_exists(pid): - log.info('Not allocating a port to a non-existent process') - return False - return True - - -async def _start_windows_server(client_connected_cb, path): - """Start the server on Windows using named pipes.""" - def protocol_factory(): - stream_reader = asyncio.StreamReader() - stream_reader_protocol = asyncio.StreamReaderProtocol( - stream_reader, client_connected_cb) - return stream_reader_protocol - - loop = asyncio.get_event_loop() - server, *_ = await loop.start_serving_pipe(protocol_factory, address=path) - - return server - - -class _PortInfo(object): - """Container class for information about a given port assignment. - - Attributes: - port: integer port number - pid: integer process id or 0 if unassigned. - start_time: Time in seconds since the epoch that the process started. - """ - - __slots__ = ('port', 'pid', 'start_time') - - def __init__(self, port): - self.port = port - self.pid = 0 - self.start_time = 0.0 - - -class _PortPool(object): - """Manage available ports for processes. - - Ports are reclaimed when the reserving process exits and the reserved port - is no longer in use. Only ports which are free for both TCP and UDP will be - handed out. It is easier to not differentiate between protocols. - - The pool must be pre-seeded with add_port_to_free_pool() calls - after which get_port_for_process() will allocate and reclaim ports. - The len() of a _PortPool returns the total number of ports being managed. - - Attributes: - ports_checked_for_last_request: The number of ports examined in order to - return from the most recent get_port_for_process() request. A high - number here likely means the number of available ports with no active - process using them is getting low. - """ - - def __init__(self): - self._port_queue = collections.deque() - self.ports_checked_for_last_request = 0 - - def num_ports(self): - return len(self._port_queue) - - def get_port_for_process(self, pid): - """Allocates and returns port for pid or 0 if none could be allocated.""" - if not self._port_queue: - raise RuntimeError('No ports being managed.') - - # Avoid an infinite loop if all ports are currently assigned. - check_count = 0 - max_ports_to_test = len(self._port_queue) - while check_count < max_ports_to_test: - # Get the next candidate port and move it to the back of the queue. - candidate = self._port_queue.pop() - self._port_queue.appendleft(candidate) - check_count += 1 - if (candidate.start_time == 0.0 or - candidate.start_time != _get_process_start_time(candidate.pid)): - if _is_port_free(candidate.port): - candidate.pid = pid - candidate.start_time = _get_process_start_time(pid) - if not candidate.start_time: - log.info("Can't read start time for pid %d.", pid) - self.ports_checked_for_last_request = check_count - return candidate.port - else: - log.info( - 'Port %d unexpectedly in use, last owning pid %d.', - candidate.port, candidate.pid) - - log.info('All ports in use.') - self.ports_checked_for_last_request = check_count - return 0 - - def add_port_to_free_pool(self, port): - """Add a new port to the free pool for allocation.""" - if port < 1 or port > 65535: - raise ValueError( - 'Port must be in the [1, 65535] range, not %d.' % port) - port_info = _PortInfo(port=port) - self._port_queue.append(port_info) - - -class _PortServerRequestHandler(object): - """A class to handle port allocation and status requests. - - Allocates ports to process ids via the dead simple port server protocol - when the handle_port_request asyncio.coroutine handler has been registered. - Statistics can be logged using the dump_stats method. - """ - - def __init__(self, ports_to_serve): - """Initialize a new port server. - - Args: - ports_to_serve: A sequence of unique port numbers to test and offer - up to clients. - """ - self._port_pool = _PortPool() - self._total_allocations = 0 - self._denied_allocations = 0 - self._client_request_errors = 0 - for port in ports_to_serve: - self._port_pool.add_port_to_free_pool(port) - - async def handle_port_request(self, reader, writer): - client_data = await reader.read(100) - self._handle_port_request(client_data, writer) - writer.close() - - def _handle_port_request(self, client_data, writer): - """Given a port request body, parse it and respond appropriately. - - Args: - client_data: The request bytes from the client. - writer: The asyncio Writer for the response to be written to. - """ - try: - if len(client_data) > 20: - raise ValueError('More than 20 characters in "pid".') - pid = int(client_data) - except ValueError as error: - self._client_request_errors += 1 - log.warning('Could not parse request: %s', error) - return - - log.info('Request on behalf of pid %d.', pid) - log.info('cmdline: %s', _get_process_command_line(pid)) - - if not _should_allocate_port(pid): - self._denied_allocations += 1 - return - - port = self._port_pool.get_port_for_process(pid) - if port > 0: - self._total_allocations += 1 - writer.write('{:d}\n'.format(port).encode('utf-8')) - log.debug('Allocated port %d to pid %d', port, pid) - else: - self._denied_allocations += 1 - - def dump_stats(self): - """Logs statistics of our operation.""" - log.info('Dumping statistics:') - stats = [] - stats.append( - 'client-request-errors {}'.format(self._client_request_errors)) - stats.append('denied-allocations {}'.format(self._denied_allocations)) - stats.append('num-ports-managed {}'.format(self._port_pool.num_ports())) - stats.append('num-ports-checked-for-last-request {}'.format( - self._port_pool.ports_checked_for_last_request)) - stats.append('total-allocations {}'.format(self._total_allocations)) - for stat in stats: - log.info(stat) - - -def _parse_command_line(): - """Configure and parse our command line flags.""" - parser = argparse.ArgumentParser() - parser.add_argument( - '--portserver_static_pool', - type=str, - default='15000-24999', - help='Comma separated N-P Range(s) of ports to manage (inclusive).') - parser.add_argument( - '--portserver_address', - '--portserver_unix_socket_address', # Alias to be backward compatible - type=str, - default='@unittest-portserver', - help='Address of AF_UNIX socket on which to listen on Unix (first @ is ' - 'a NUL) or the name of the pipe on Windows (first @ is the ' - r'\\.\pipe\ prefix).') - parser.add_argument('--verbose', - action='store_true', - default=False, - help='Enable verbose messages.') - parser.add_argument('--debug', - action='store_true', - default=False, - help='Enable full debug messages.') - return parser.parse_args(sys.argv[1:]) - - -def _parse_port_ranges(pool_str): - """Given a 'N-P,X-Y' description of port ranges, return a set of ints.""" - ports = set() - for range_str in pool_str.split(','): - try: - a, b = range_str.split('-', 1) - start, end = int(a), int(b) - except ValueError: - log.error('Ignoring unparsable port range %r.', range_str) - continue - if start < 1 or end > 65535: - log.error('Ignoring out of bounds port range %r.', range_str) - continue - ports.update(set(range(start, end + 1))) - return ports - - -def _configure_logging(verbose=False, debug=False): - """Configure the log global, message format, and verbosity settings.""" - overall_level = logging.DEBUG if debug else logging.INFO - logging.basicConfig( - format=('{levelname[0]}{asctime}.{msecs:03.0f} {thread} ' - '{filename}:{lineno}] {message}'), - datefmt='%m%d %H:%M:%S', - style='{', - level=overall_level) - global log - log = logging.getLogger('portserver') - # The verbosity controls our loggers logging level, not the global - # one above. This avoids debug messages from libraries such as asyncio. - log.setLevel(logging.DEBUG if verbose else overall_level) - - -def main(): - config = _parse_command_line() - if config.debug: - # Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access - asyncio.tasks._DEBUG = True - _configure_logging(verbose=config.verbose, debug=config.debug) - ports_to_serve = _parse_port_ranges(config.portserver_static_pool) - if not ports_to_serve: - log.error('No ports. Invalid port ranges in --portserver_static_pool?') - sys.exit(1) - - request_handler = _PortServerRequestHandler(ports_to_serve) - - if sys.platform == 'win32': - asyncio.set_event_loop(asyncio.ProactorEventLoop()) - - event_loop = asyncio.get_event_loop() - - if sys.platform == 'win32': - # On Windows, we need to periodically pause the loop to allow the user - # to send a break signal (e.g. ctrl+c) - def listen_for_signal(): - event_loop.call_later(0.5, listen_for_signal) - - event_loop.call_later(0.5, listen_for_signal) - - coro = _start_windows_server( - request_handler.handle_port_request, - path=config.portserver_address.replace('@', '\\\\.\\pipe\\', 1)) - else: - event_loop.add_signal_handler( - signal.SIGUSR1, request_handler.dump_stats) # pylint: disable=no-member - - old_py_loop = {'loop': event_loop} if sys.version_info < (3, 10) else {} - coro = asyncio.start_unix_server( - request_handler.handle_port_request, - path=config.portserver_address.replace('@', '\0', 1), - **old_py_loop) - - server_address = config.portserver_address - - server = event_loop.run_until_complete(coro) - log.info('Serving on %s', server_address) - try: - event_loop.run_forever() - except KeyboardInterrupt: - log.info('Stopping due to ^C.') - - server.close() - - if sys.platform != 'win32': - # PipeServer doesn't have a wait_closed() function - event_loop.run_until_complete(server.wait_closed()) - event_loop.remove_signal_handler(signal.SIGUSR1) # pylint: disable=no-member - - event_loop.close() - request_handler.dump_stats() - log.info('Goodbye.') - - -if __name__ == '__main__': - main() diff --git a/rt1_env/bin/progressbar b/rt1_env/bin/progressbar deleted file mode 100755 index 1136ebc7c..000000000 --- a/rt1_env/bin/progressbar +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from progressbar.__main__ import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/pygmentize b/rt1_env/bin/pygmentize deleted file mode 100755 index 623ccdf50..000000000 --- a/rt1_env/bin/pygmentize +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from pygments.cmdline import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/python b/rt1_env/bin/python deleted file mode 120000 index b8a0adbbb..000000000 --- a/rt1_env/bin/python +++ /dev/null @@ -1 +0,0 @@ -python3 \ No newline at end of file diff --git a/rt1_env/bin/python3 b/rt1_env/bin/python3 deleted file mode 120000 index ae65fdaa1..000000000 --- a/rt1_env/bin/python3 +++ /dev/null @@ -1 +0,0 @@ -/usr/bin/python3 \ No newline at end of file diff --git a/rt1_env/bin/python3.9 b/rt1_env/bin/python3.9 deleted file mode 120000 index b8a0adbbb..000000000 --- a/rt1_env/bin/python3.9 +++ /dev/null @@ -1 +0,0 @@ -python3 \ No newline at end of file diff --git a/rt1_env/bin/pythoni b/rt1_env/bin/pythoni deleted file mode 100755 index 2d650f825..000000000 --- a/rt1_env/bin/pythoni +++ /dev/null @@ -1,36 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 - -# Copyright 2000-2002 Michael Hudson mwh@python.net -# -# All Rights Reserved -# -# -# Permission to use, copy, modify, and distribute this software and -# its documentation for any purpose is hereby granted without fee, -# provided that the above copyright notice appear in all copies and -# that both that copyright notice and this permission notice appear in -# supporting documentation. -# -# THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO -# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY -# AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, -# INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER -# RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF -# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN -# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import locale, pdb, sys -# I forget exactly why this is necessary: -try: - locale.setlocale(locale.LC_ALL, '') -except locale.Error: - pass # oh well - - -from pyrepl.python_reader import main -from pyrepl import cmdrepl - -# whizzy feature: graft pyrepl support onto pdb -#pdb.Pdb = cmdrepl.replize(pdb.Pdb, 1) - -main(use_pygame_console=('pg' in sys.argv)) diff --git a/rt1_env/bin/pythoni1 b/rt1_env/bin/pythoni1 deleted file mode 100755 index f0a75c79d..000000000 --- a/rt1_env/bin/pythoni1 +++ /dev/null @@ -1,17 +0,0 @@ -#!/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3 -""" This is an alternative to pythoni which tries to look like the -CPython prompt as much as possible, with the exception of allowing -multiline input and multiline history entries. -""" - -import os, sys -from pyrepl import readline -from pyrepl.simple_interact import run_multiline_interactive_console - -sys.modules['readline'] = readline - -if os.getenv('PYTHONSTARTUP'): - execfile(os.getenv('PYTHONSTARTUP')) - -print 'Python', sys.version -run_multiline_interactive_console() diff --git a/rt1_env/bin/reverb_server b/rt1_env/bin/reverb_server deleted file mode 100755 index b9d8a78f5..000000000 --- a/rt1_env/bin/reverb_server +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from reverb.server_executable.server_main import app_run_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(app_run_main()) diff --git a/rt1_env/bin/saved_model_cli b/rt1_env/bin/saved_model_cli deleted file mode 100755 index 44f84317c..000000000 --- a/rt1_env/bin/saved_model_cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.python.tools.saved_model_cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tensorboard b/rt1_env/bin/tensorboard deleted file mode 100755 index 2ee3b3204..000000000 --- a/rt1_env/bin/tensorboard +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorboard.main import run_main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(run_main()) diff --git a/rt1_env/bin/tf_upgrade_v2 b/rt1_env/bin/tf_upgrade_v2 deleted file mode 100755 index aee84bff1..000000000 --- a/rt1_env/bin/tf_upgrade_v2 +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.tools.compatibility.tf_upgrade_v2_main import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tfds b/rt1_env/bin/tfds deleted file mode 100755 index 0f5636bc8..000000000 --- a/rt1_env/bin/tfds +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow_datasets.scripts.cli.main import launch_cli -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(launch_cli()) diff --git a/rt1_env/bin/tflite_convert b/rt1_env/bin/tflite_convert deleted file mode 100755 index 0ebb370c7..000000000 --- a/rt1_env/bin/tflite_convert +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.lite.python.tflite_convert import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tiff2fsspec b/rt1_env/bin/tiff2fsspec deleted file mode 100755 index 72322f48d..000000000 --- a/rt1_env/bin/tiff2fsspec +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile.tiff2fsspec import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tiffcomment b/rt1_env/bin/tiffcomment deleted file mode 100755 index 81e89dd82..000000000 --- a/rt1_env/bin/tiffcomment +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile.tiffcomment import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tifffile b/rt1_env/bin/tifffile deleted file mode 100755 index 024aaecb3..000000000 --- a/rt1_env/bin/tifffile +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tifffile import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/toco b/rt1_env/bin/toco deleted file mode 100755 index 0ebb370c7..000000000 --- a/rt1_env/bin/toco +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.lite.python.tflite_convert import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/toco_from_protos b/rt1_env/bin/toco_from_protos deleted file mode 100755 index 4a0931477..000000000 --- a/rt1_env/bin/toco_from_protos +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tensorflow.lite.toco.python.toco_from_protos import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/torchrun b/rt1_env/bin/torchrun deleted file mode 100755 index bbd4216d0..000000000 --- a/rt1_env/bin/torchrun +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from torch.distributed.run import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tqdm b/rt1_env/bin/tqdm deleted file mode 100755 index 52aa9b22d..000000000 --- a/rt1_env/bin/tqdm +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from tqdm.cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/transformers-cli b/rt1_env/bin/transformers-cli deleted file mode 100755 index 3cb3dba5c..000000000 --- a/rt1_env/bin/transformers-cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from transformers.commands.transformers_cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/bin/tree-cli b/rt1_env/bin/tree-cli deleted file mode 100755 index 822fcbe27..000000000 --- a/rt1_env/bin/tree-cli +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from Tree.cli import create_tree -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(create_tree()) diff --git a/rt1_env/bin/wandb b/rt1_env/bin/wandb deleted file mode 100755 index ad3846609..000000000 --- a/rt1_env/bin/wandb +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from wandb.cli.cli import cli -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(cli()) diff --git a/rt1_env/bin/wb b/rt1_env/bin/wb deleted file mode 100755 index ad3846609..000000000 --- a/rt1_env/bin/wb +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from wandb.cli.cli import cli -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(cli()) diff --git a/rt1_env/bin/wheel b/rt1_env/bin/wheel deleted file mode 100755 index 47a52e82e..000000000 --- a/rt1_env/bin/wheel +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -'''exec' "/oscar/data/stellex/ssunda11/NPM-Dataset copy/rt1_env/bin/python3" "$0" "$@" -' ''' -# -*- coding: utf-8 -*- -import re -import sys -from wheel.cli import main -if __name__ == '__main__': - sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) - sys.exit(main()) diff --git a/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto b/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto deleted file mode 100644 index 39512921e..000000000 --- a/rt1_env/include/site/python3.9/dm-reverb/checkpoint.proto +++ /dev/null @@ -1,77 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "reverb/cc/schema.proto"; -import "tensorflow/core/protobuf/struct.proto"; - -// Configs for reconstructing a distribution to its initial state. - -// Next ID: 11. -message PriorityTableCheckpoint { - // Name of the table. - string table_name = 1; - - // Maximum number of items in the table. - // If an insert would result in this value getting exceeded, `remover` is used - // to select an item to remove before proceeding with the insert. - int64 max_size = 6; - - // The maximum number of times an item can be sampled before being removed. - int32 max_times_sampled = 7; - - // Items in the table ordered by `inserted_at` (asc). - // When loading a checkpoint the items should be added in the same order so - // position based item selectors (e.g fifo) are reconstructed correctly. - // - // *NOTE*: This field is deprecated; instead, a separate record file is - // written with PrioritizedItem records for checkpointing (in the same - // order as described here). - repeated PrioritizedItem deprecated_items = 2 [deprecated = true]; - - // Checkpoint of the associated rate limiter. - RateLimiterCheckpoint rate_limiter = 3; - - // Options for constructing new samplers and removers of the correct type. - // Note that this does not include the state that they currently hold as it - // will be reproduced using the order of `items. - KeyDistributionOptions sampler = 4; - KeyDistributionOptions remover = 5; - - // The total number of episodes that were at some point referenced by items - // in the table but have since been removed. - int64 num_deleted_episodes = 8; - - // Optional data signature for tensors stored in the table. - tensorflow.StructuredValue signature = 9; - - // Number of unique items sampled from the table since the last reset. - int64 num_unique_samples = 10; -} - -message RateLimiterCheckpoint { - reserved 1; // Deprecated field `name`. - - // The average number of times each item should be sampled during its - // lifetime. - double samples_per_insert = 2; - - // The minimum and maximum values the cursor is allowed to reach. The cursor - // value is calculated as `insert_count * samples_per_insert - - // sample_count`. If the value would go beyond these limits then the call is - // blocked until it can proceed without violating the constraints. - double min_diff = 3; - double max_diff = 4; - - // The minimum number of inserts required before any sample operation. - int64 min_size_to_sample = 5; - - // The total number of samples that occurred before the checkpoint. - int64 sample_count = 6; - - // The total number of inserts that occurred before the checkpoint. - int64 insert_count = 7; - - // The total number of deletes that occurred before the checkpoint. - int64 delete_count = 8; -} diff --git a/rt1_env/include/site/python3.9/dm-reverb/patterns.proto b/rt1_env/include/site/python3.9/dm-reverb/patterns.proto deleted file mode 100644 index 3428db5a5..000000000 --- a/rt1_env/include/site/python3.9/dm-reverb/patterns.proto +++ /dev/null @@ -1,123 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "tensorflow/core/protobuf/struct.proto"; - -message PatternNode { - // Index of the source column in the flattened step structure. - int32 flat_source_index = 1; - - // Slicing of the source column relative to the most recent step. - // - // These fields mimics the behavior of `slice` in Python. That is: - // - // * x[-1:] => (start=-1, stop=null) - // * x[-2] => (start=null, stop=-2) - // * x[-3:-1] => (start=-3, stop=-1) - // * x[-3:-1:2] => (start=-3, stop=-1, step=2) - // - // Furthermore, the following requirements applies: - // - // * Slices with undefined `start` (e.g. x[:-2]) are not supported. - // * For slices, `start` must be < 0 and `stop` must be <= 0. - // * `step` must be > 0 when defined. - // - oneof start_or_none { - int32 start = 2; - } - oneof stop_or_none { - int32 stop = 3; - } - oneof step_or_none { - int32 step = 4; - } -} - -message Condition { - // Given int32 `left`: `left % mod == eq`. - message ModuloEq { - int32 mod = 1; - int32 eq = 2; - } - - oneof left { - // The index of the most recent step within the episode. - bool step_index = 1; - - // The number of steps since the pattern was most recently applied. - bool steps_since_applied = 2; - - // The number of steps currently held by the buffer. - bool buffer_length = 3; - - // Set to 1 when `EndEpisode` is called, else 0. - bool is_end_episode = 4; - - // Extract scalar integer value from a column in the most recent step. If - // the column is not present in the data or it isn't a scalar of a supported - // type then the condition will return false. - // - // All integer types are casted to int32 and bool is converted to 1 if true - // and 0 if false. - // - int32 flat_source_index = 9; - } - - // TODO(b/205278205): Remove le and just use inverse + ge instead. - oneof cmp { - // `left == eq`. - int32 eq = 5; - - // `left >= ge`. - int32 ge = 6; - - // `left % mod_eq.mod == mod_eq.eq`. - ModuloEq mod_eq = 7; - } - - // Whether the condition result should be inversed. - bool inverse = 8; -} - -message Priority { - // Priority function that always return the same value. - message ConstantPriorityFn { - // Value to be returned by the priority function. - double value = 1; - } - - // Priority function that computes the trajectory TD Error using the per-step - // TD Error. See details of the TD Error in - // https://openreview.net/pdf?id=r1lyTjAqYX. - message TDError { - // Weight for the max priority in the TD Error computation. - double max_priority_weight = 1; - // Index of the field in the input step that contais the per-step TD Error. - int32 flat_source_index = 2; - } - - oneof priority_fn { - ConstantPriorityFn constant_fn = 1; - TDError td_error = 2; - } -} - -message StructuredWriterConfig { - // Flattened output structure. - repeated PatternNode flat = 1; - - // Serialised structure of the pattern. All leaf nodes must be None. If empty - // then pattern will be treated as a flat list. - tensorflow.StructuredValue pattern_structure = 2; - - // The table that generated trajectories will be inserted into. - string table = 3; - - // The priority assigned to all trajectories generated by this config. - Priority priority = 4; - - // Conditions which must be fulfilled for the configuration to be applied at - // the current step. - repeated Condition conditions = 5; -} diff --git a/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto b/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto deleted file mode 100644 index a14a6ce56..000000000 --- a/rt1_env/include/site/python3.9/dm-reverb/reverb_config.proto +++ /dev/null @@ -1,10 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "reverb/cc/checkpointing/checkpoint.proto"; - -message ReverbServerConfig { - repeated PriorityTableCheckpoint tables = 1; - int32 port = 2; -} diff --git a/rt1_env/include/site/python3.9/dm-reverb/schema.proto b/rt1_env/include/site/python3.9/dm-reverb/schema.proto deleted file mode 100644 index 3c37454c3..000000000 --- a/rt1_env/include/site/python3.9/dm-reverb/schema.proto +++ /dev/null @@ -1,289 +0,0 @@ -syntax = "proto3"; - -package deepmind.reverb; - -import "google/protobuf/timestamp.proto"; -import "tensorflow/core/framework/tensor.proto"; -import "tensorflow/core/protobuf/struct.proto"; - -// The actual data is stored in chunks. The data can be arbitrary tensors. We do -// not interpret the bytes data of the tensors on the server side. It is up to -// the client to compress the bytes blob within the tensors. -message ChunkData { - // Unique identifier of the chunk. - uint64 chunk_key = 1; - - // The timesteps within the episode that the chunk covers. - SequenceRange sequence_range = 2; - - // Actual tensor data. - message Data { - repeated tensorflow.TensorProto tensors = 1; - } - Data data = 5 [lazy = true]; - - // Number of tensors in the data field. Set explicitly so that Reverb server - // can check it without accessing lazy data field (which is expensive to - // parse). - int32 data_tensors_len = 6; - - // Size of the tensors in `data` before compression. - int64 data_uncompressed_size = 7; - - // True if delta encoding has been applied before compressing data. - bool delta_encoded = 4; - - // Deprecated December 2020 and retained to provide backward - // compatibility with checkpoints created before this point. - repeated tensorflow.TensorProto deprecated_data = 3 [deprecated = true]; -} - -// A range that specifies which items to slice out from a sequence of chunks. -// The length of all chunks must at least be `offset`+`length`. -message SliceRange { - // Offset where the slice should start. - int32 offset = 1; - - // Length of the slice. Can span multiple chunks. - int32 length = 2; -} - -message SequenceRange { - // Globally unique identifier of the episode the sequence belongs to. - uint64 episode_id = 1; - - // Index within the episode of the first timestep covered by the range. - int32 start = 2; - - // Index within the episode of the last timestep covered by the range. - // Must be >= start_index. - int32 end = 3; - - // If set then at least one step is missing from the data. The number of steps - // (i.e batch size) present in the data is unknown and thus must be manually - // checked. However, the `start` and `end` step is guaranteed to be at first - // and last position in the data. - bool sparse = 4; -} - -message FlatTrajectory { - message ChunkSlice { - // Unique identifier of the ChunkData which owns the compressed data. - uint64 chunk_key = 1; - - // Index of the first element in the chunk to include. - int32 offset = 2; - - // Number of elements from the chunk to include. - int32 length = 3; - - // Tensor index of the tensor within the chunk. - int32 index = 4; - } - - message Column { - // Chunk slices to concat. - repeated ChunkSlice chunk_slices = 1; - - // If true then the batch dim (must be 1) is emitted when unpacked. - // Requires that column is made up of exactly one ChunkSlice of length 1. - bool squeeze = 2; - } - - // Flattened columns of the trajectory. - repeated Column columns = 1; -} - -// A prioritized item is part of a table and references a chunk of -// data. Sampling happens based on the priority of items. -// -// Next ID: 9. -// LINT.IfChange -message PrioritizedItem { - // Unique identifier of this item. - uint64 key = 1; - - // Priority table that the item belongs to. - string table = 2; - - // Priority used for sampling. - double priority = 5; - - // The number of times the item has been sampled. - int32 times_sampled = 6; - - // The time when the item was first inserted. - google.protobuf.Timestamp inserted_at = 7; - - // Flattened representation of item's trajectory. - FlatTrajectory flat_trajectory = 8; - - // Deprecated January 2021 and retained to provide backward compatibility - // with checkpoints created before this point. - repeated uint64 deprecated_chunk_keys = 3 [deprecated = true]; - SliceRange deprecated_sequence_range = 4 [deprecated = true]; -} -// LINT.ThenChange(reverb_service_impl.cc) - -// Used for updating an existing PrioritizedItem. -message KeyWithPriority { - // Identifier of the PrioritizedItem. - uint64 key = 1; - - // Priority used for sampling. - double priority = 2; -} - -message SampleInfo { - // Item from that was sampled from the table. - PrioritizedItem item = 1; - - // Probability that this item had at sampling time. Useful for importance - // sampling. - double probability = 2; - - // Number of items in the table at the time of the sample operation. - int64 table_size = 3; - - // Whether the sample was delayed due to rate limiting of the sampler. - bool rate_limited = 4; -} - -// LINT.IfChange -// Metadata about the table, including (optional) data signature. -// -// These fields correspond to initialization arguments of the -// `Table` class, unless noted otherwise. -// -// Next ID: 13. -message TableInfo { - // Table's name. - string name = 8; - - // Sampler and remover metadata. - KeyDistributionOptions sampler_options = 1; - KeyDistributionOptions remover_options = 2; - - // Max size of the table. - int64 max_size = 3; - - // Max number of times an element can be sampled before being - // removed. - int32 max_times_sampled = 4; - - // How data read/write is rate limited. - RateLimiterInfo rate_limiter_info = 5; - - // Optional data signature for tensors stored in the table. Note - // that this data type is more flexible than we use. For example, - // we only store tensors (TensorSpecProto, TypeSpecProto) and not - // any special data types (no NoneValue or other special fixed values). - tensorflow.StructuredValue signature = 6; - - // Current size of table. - int64 current_size = 7; - - // Number of episodes referenced by the items in the table. - int64 num_episodes = 9; - - // Number of episodes once referenced by items in the table but no longer is. - // The total number of episodes thus is `num_episodes + num_deleted_episodes`. - int64 num_deleted_episodes = 10; - - // Number of unique items sampled from the table since the last reset. - int64 num_unique_samples = 11; - - // Table worker execution time distribution. - TableWorkerTime table_worker_time = 12; -} -// LINT.ThenChange(../py/reverb/reverb_types.py) - -message RateLimiterCallStats { - // The total number of completed calls. - int64 completed = 2; - - reserved 1, 3, 4, 5; -} - -message RateLimiterInfo { - // The average number of times each item should be sampled during its - // lifetime. - double samples_per_insert = 1; - - // The minimum and maximum values the cursor is allowed to reach. The cursor - // value is calculated as `insert_count * samples_per_insert - - // sample_count`. If the value would go beyond these limits then the call is - // blocked until it can proceed without violating the constraints. - double min_diff = 2; - double max_diff = 3; - - // The minimum number of inserts required before any sample operation. - int64 min_size_to_sample = 4; - - // Stats regarding the limiting of insert calls. - RateLimiterCallStats insert_stats = 5; - - // Stats regarding the limiting of sample calls. - RateLimiterCallStats sample_stats = 6; -} - -message TableWorkerTime { - // Cumulative time the table worker is performing general work. - int64 running_ms = 1; - - // Cumulative time the table worker is actively processing sampling requests. - int64 sampling_ms = 2; - - // Cumulative time the table worker is actively processing insert requests. - int64 inserting_ms = 3; - - // Cumulative time the table worker is sleeping as there is no work to do - // (there are no pending insert/sample requests to process). - int64 sleeping_ms = 4; - - // Cumulative time the table worker is blocked waiting for sampling requests - // There are pending insert requests which are blocked by the rate limiter, - // while there are no sampling requests which could unblock inserts. - // The system can't make further progress and the worker is put to sleep until - // sample request arives. - int64 waiting_for_sampling_ms = 5; - - // Cumulative time the table worker is blocked waiting for insert requests - // There are pending sample requests which are blocked by the rate - // limiter, while there are no insert requests which could unblock sampling. - // The system can't make further progress and the worker is put to sleep until - // insert request arives. - int64 waiting_for_inserts_ms = 6; -} - -// Metadata about sampler or remover. Describes its configuration. -message KeyDistributionOptions { - message Prioritized { - double priority_exponent = 1; - } - - message Heap { - bool min_heap = 1; - } - - oneof distribution { - bool fifo = 1; - bool uniform = 2; - Prioritized prioritized = 3; - Heap heap = 4; - bool lifo = 6; - } - reserved 5; - bool is_deterministic = 7; -} - -// Uint128 representation. Can be used for unique identifiers. -message Uint128 { - uint64 high = 1; - uint64 low = 2; -} - -// Representation of a timeout. A value < 0 means never time out. -message Timeout { - int64 milliseconds = 1; -} diff --git a/rt1_env/lib64 b/rt1_env/lib64 deleted file mode 120000 index 7951405f8..000000000 --- a/rt1_env/lib64 +++ /dev/null @@ -1 +0,0 @@ -lib \ No newline at end of file diff --git a/rt1_env/pyvenv.cfg b/rt1_env/pyvenv.cfg deleted file mode 100644 index 1997c5b53..000000000 --- a/rt1_env/pyvenv.cfg +++ /dev/null @@ -1,3 +0,0 @@ -home = /usr/bin -include-system-site-packages = false -version = 3.9.16 diff --git a/rt1_env/share/man/man1/isympy.1 b/rt1_env/share/man/man1/isympy.1 deleted file mode 100644 index 0ff966158..000000000 --- a/rt1_env/share/man/man1/isympy.1 +++ /dev/null @@ -1,188 +0,0 @@ -'\" -*- coding: us-ascii -*- -.if \n(.g .ds T< \\FC -.if \n(.g .ds T> \\F[\n[.fam]] -.de URL -\\$2 \(la\\$1\(ra\\$3 -.. -.if \n(.g .mso www.tmac -.TH isympy 1 2007-10-8 "" "" -.SH NAME -isympy \- interactive shell for SymPy -.SH SYNOPSIS -'nh -.fi -.ad l -\fBisympy\fR \kx -.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) -'in \n(.iu+\nxu -[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [ --- | PYTHONOPTIONS] -'in \n(.iu-\nxu -.ad b -'hy -'nh -.fi -.ad l -\fBisympy\fR \kx -.if (\nx>(\n(.l/2)) .nr x (\n(.l/5) -'in \n(.iu+\nxu -[ -{\fB-h\fR | \fB--help\fR} -| -{\fB-v\fR | \fB--version\fR} -] -'in \n(.iu-\nxu -.ad b -'hy -.SH DESCRIPTION -isympy is a Python shell for SymPy. It is just a normal python shell -(ipython shell if you have the ipython package installed) that executes -the following commands so that you don't have to: -.PP -.nf -\*(T< ->>> from __future__ import division ->>> from sympy import * ->>> x, y, z = symbols("x,y,z") ->>> k, m, n = symbols("k,m,n", integer=True) - \*(T> -.fi -.PP -So starting isympy is equivalent to starting python (or ipython) and -executing the above commands by hand. It is intended for easy and quick -experimentation with SymPy. For more complicated programs, it is recommended -to write a script and import things explicitly (using the "from sympy -import sin, log, Symbol, ..." idiom). -.SH OPTIONS -.TP -\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR -Use the specified shell (python or ipython) as -console backend instead of the default one (ipython -if present or python otherwise). - -Example: isympy -c python - -\fISHELL\fR could be either -\&'ipython' or 'python' -.TP -\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR -Setup pretty printing in SymPy. By default, the most pretty, unicode -printing is enabled (if the terminal supports it). You can use less -pretty ASCII printing instead or no pretty printing at all. - -Example: isympy -p no - -\fIENCODING\fR must be one of 'unicode', -\&'ascii' or 'no'. -.TP -\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR -Setup the ground types for the polys. By default, gmpy ground types -are used if gmpy2 or gmpy is installed, otherwise it falls back to python -ground types, which are a little bit slower. You can manually -choose python ground types even if gmpy is installed (e.g., for testing purposes). - -Note that sympy ground types are not supported, and should be used -only for experimental purposes. - -Note that the gmpy1 ground type is primarily intended for testing; it the -use of gmpy even if gmpy2 is available. - -This is the same as setting the environment variable -SYMPY_GROUND_TYPES to the given ground type (e.g., -SYMPY_GROUND_TYPES='gmpy') - -The ground types can be determined interactively from the variable -sympy.polys.domains.GROUND_TYPES inside the isympy shell itself. - -Example: isympy -t python - -\fITYPE\fR must be one of 'gmpy', -\&'gmpy1' or 'python'. -.TP -\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR -Setup the ordering of terms for printing. The default is lex, which -orders terms lexicographically (e.g., x**2 + x + 1). You can choose -other orderings, such as rev-lex, which will use reverse -lexicographic ordering (e.g., 1 + x + x**2). - -Note that for very large expressions, ORDER='none' may speed up -printing considerably, with the tradeoff that the order of the terms -in the printed expression will have no canonical order - -Example: isympy -o rev-lax - -\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex', -\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'. -.TP -\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T> -Print only Python's and SymPy's versions to stdout at startup, and nothing else. -.TP -\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T> -Use the same format that should be used for doctests. This is -equivalent to '\fIisympy -c python -p no\fR'. -.TP -\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T> -Disable the caching mechanism. Disabling the cache may slow certain -operations down considerably. This is useful for testing the cache, -or for benchmarking, as the cache can result in deceptive benchmark timings. - -This is the same as setting the environment variable SYMPY_USE_CACHE -to 'no'. -.TP -\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T> -Automatically create missing symbols. Normally, typing a name of a -Symbol that has not been instantiated first would raise NameError, -but with this option enabled, any undefined name will be -automatically created as a Symbol. This only works in IPython 0.11. - -Note that this is intended only for interactive, calculator style -usage. In a script that uses SymPy, Symbols should be instantiated -at the top, so that it's clear what they are. - -This will not override any names that are already defined, which -includes the single character letters represented by the mnemonic -QCOSINE (see the "Gotchas and Pitfalls" document in the -documentation). You can delete existing names by executing "del -name" in the shell itself. You can see if a name is defined by typing -"'name' in globals()". - -The Symbols that are created using this have default assumptions. -If you want to place assumptions on symbols, you should create them -using symbols() or var(). - -Finally, this only works in the top level namespace. So, for -example, if you define a function in isympy with an undefined -Symbol, it will not work. -.TP -\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T> -Enable debugging output. This is the same as setting the -environment variable SYMPY_DEBUG to 'True'. The debug status is set -in the variable SYMPY_DEBUG within isympy. -.TP --- \fIPYTHONOPTIONS\fR -These options will be passed on to \fIipython (1)\fR shell. -Only supported when ipython is being used (standard python shell not supported). - -Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR -from the other isympy options. - -For example, to run iSymPy without startup banner and colors: - -isympy -q -c ipython -- --colors=NoColor -.TP -\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T> -Print help output and exit. -.TP -\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T> -Print isympy version information and exit. -.SH FILES -.TP -\*(T<\fI${HOME}/.sympy\-history\fR\*(T> -Saves the history of commands when using the python -shell as backend. -.SH BUGS -The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra -Please report all bugs that you find in there, this will help improve -the overall quality of SymPy. -.SH "SEE ALSO" -\fBipython\fR(1), \fBpython\fR(1) diff --git a/rt1_pytorch/__init__.py b/rt1_pytorch/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/rt1_pytorch/film_efficientnet/__init__.py b/rt1_pytorch/film_efficientnet/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/rt1_pytorch/film_efficientnet/film_conditioning_layer.py b/rt1_pytorch/film_efficientnet/film_conditioning_layer.py deleted file mode 100644 index 8524676fd..000000000 --- a/rt1_pytorch/film_efficientnet/film_conditioning_layer.py +++ /dev/null @@ -1,38 +0,0 @@ -import torch -from torch import nn - - -class FilmConditioning(nn.Module): - def __init__(self, embedding_dim, num_channels): - super().__init__() - self._projection_add = nn.Linear(embedding_dim, num_channels) - self._projection_mult = nn.Linear(embedding_dim, num_channels) - self.num_channels = num_channels - self.embedding_dim = embedding_dim - # From the paper - nn.init.zeros_(self._projection_add.weight) - nn.init.zeros_(self._projection_mult.weight) - nn.init.zeros_(self._projection_add.bias) - nn.init.zeros_(self._projection_mult.bias) - - def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" - assert ( - context.shape[1] == self.embedding_dim - ), f"Unexpected context shape: {context.shape}" - assert ( - x.shape[0] == context.shape[0] - ), f"x and context must have the same batch size, but got {x.shape} and {context.shape}" - projected_cond_add = self._projection_add(context) - projected_cond_mult = self._projection_mult(context) - - if len(x.shape) == 4: - projected_cond_add = projected_cond_add.unsqueeze(2).unsqueeze(3) - projected_cond_mult = projected_cond_mult.unsqueeze(2).unsqueeze(3) - else: - assert len(x.shape) == 2 - - # Original FiLM paper argues that 1 + gamma centers the initialization at - # identity transform. - result = (1 + projected_cond_mult) * x + projected_cond_add - return result \ No newline at end of file diff --git a/rt1_pytorch/film_efficientnet/film_efficientnet.py b/rt1_pytorch/film_efficientnet/film_efficientnet.py deleted file mode 100644 index a9c03573b..000000000 --- a/rt1_pytorch/film_efficientnet/film_efficientnet.py +++ /dev/null @@ -1,446 +0,0 @@ -"""EfficientNet models modified with added film layers. - -Mostly taken from: -https://github.com/pytorch/vision/blob/main/torchvision/models/efficientnet.py -""" -import copy -import math -from functools import partial -from typing import Any, Callable, List, Optional, Sequence, Union - -import torch -from torch import nn -from torchvision.models._api import Weights -from torchvision.models._meta import _IMAGENET_CATEGORIES -from torchvision.models._utils import _ovewrite_named_param -from torchvision.models.efficientnet import ( - EfficientNet_B0_Weights, - EfficientNet_B1_Weights, - EfficientNet_B2_Weights, - EfficientNet_B3_Weights, - EfficientNet_B4_Weights, - EfficientNet_B5_Weights, - EfficientNet_B6_Weights, - EfficientNet_B7_Weights, - EfficientNet_V2_L_Weights, - EfficientNet_V2_M_Weights, - EfficientNet_V2_S_Weights, - FusedMBConv, - FusedMBConvConfig, - MBConv, - MBConvConfig, - _efficientnet_conf, - _MBConvConfig, -) -from torchvision.ops.misc import Conv2dNormActivation -from torchvision.utils import _log_api_usage_once - -from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning - - -class MBConvFilm(nn.Module): - """MBConv or FusedMBConv with FiLM context""" - - def __init__(self, embedding_dim: int, mbconv: Union[MBConv, FusedMBConv]): - super().__init__() - self.mbconv = mbconv - num_channels = mbconv.block[-1][1].num_features - self.film = FilmConditioning( - embedding_dim=embedding_dim, num_channels=num_channels - ) - - def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - x = self.mbconv(x) - x = self.film(x, context) - return x - - -class _FilmEfficientNet(nn.Module): - def __init__( - self, - inverted_residual_setting: Sequence[Union[MBConvConfig, FusedMBConvConfig]], - dropout: float, - include_top: bool = False, - stochastic_depth_prob: float = 0.2, - num_classes: int = 1000, - norm_layer: Optional[Callable[..., nn.Module]] = None, - last_channel: Optional[int] = None, - embedding_dim: Optional[int] = 512, - ) -> None: - """ - EfficientNet V1 and V2 main class with additional FiLM context layer - - Args: - inverted_residual_setting (Sequence[Union[MBConvConfig, FusedMBConvConfig]]): Network structure - dropout (float): The droupout probability - include_top (bool): Whether to include the classification head - stochastic_depth_prob (float): The stochastic depth probability - num_classes (int): Number of classes - norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use - last_channel (int): The number of channels on the penultimate layer - embedding_dim (int): The dimension of the embedding space - """ - super().__init__() - _log_api_usage_once(self) - - if not inverted_residual_setting: - raise ValueError("The inverted_residual_setting should not be empty") - elif not ( - isinstance(inverted_residual_setting, Sequence) - and all([isinstance(s, _MBConvConfig) for s in inverted_residual_setting]) - ): - raise TypeError( - "The inverted_residual_setting should be List[MBConvConfig]" - ) - - if norm_layer is None: - norm_layer = nn.BatchNorm2d - - layers: List[nn.Module] = [] - - # building first layer - firstconv_output_channels = inverted_residual_setting[0].input_channels - layers.append( - Conv2dNormActivation( - 3, - firstconv_output_channels, - kernel_size=3, - stride=2, - norm_layer=norm_layer, - activation_layer=nn.SiLU, - ) - ) - - # building inverted residual blocks - total_stage_blocks = sum(cnf.num_layers for cnf in inverted_residual_setting) - stage_block_id = 0 - for cnf in inverted_residual_setting: - stage: List[nn.Module] = [] - for _ in range(cnf.num_layers): - # copy to avoid modifications. shallow copy is enough - block_cnf = copy.copy(cnf) - - # overwrite info if not the first conv in the stage - if stage: - block_cnf.input_channels = block_cnf.out_channels - block_cnf.stride = 1 - - # adjust stochastic depth probability based on the depth of the stage block - sd_prob = ( - stochastic_depth_prob * float(stage_block_id) / total_stage_blocks - ) - stage.append( - MBConvFilm( - embedding_dim=embedding_dim, - mbconv=block_cnf.block(block_cnf, sd_prob, norm_layer), - ) - ) - stage_block_id += 1 - - layers.append(nn.Sequential(*stage)) - - # building last several layers - lastconv_input_channels = inverted_residual_setting[-1].out_channels - lastconv_output_channels = ( - last_channel if last_channel is not None else 4 * lastconv_input_channels - ) - layers.append( - Conv2dNormActivation( - lastconv_input_channels, - lastconv_output_channels, - kernel_size=1, - norm_layer=norm_layer, - activation_layer=nn.SiLU, - ) - ) - - self.features = nn.Sequential(*layers) - if include_top: - self.avgpool = nn.AdaptiveAvgPool2d(1) - self.classifier = nn.Sequential( - nn.Dropout(p=dropout, inplace=True), - nn.Linear(lastconv_output_channels, num_classes), - nn.Softmax(dim=1), - ) - else: - self.avgpool = nn.Identity() - self.classifier = nn.Identity() - - for m in self.modules(): - if isinstance(m, nn.Conv2d): - nn.init.kaiming_normal_(m.weight, mode="fan_out") - if m.bias is not None: - nn.init.zeros_(m.bias) - elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): - nn.init.ones_(m.weight) - nn.init.zeros_(m.bias) - elif isinstance(m, nn.Linear): - init_range = 1.0 / math.sqrt(m.out_features) - nn.init.uniform_(m.weight, -init_range, init_range) - nn.init.zeros_(m.bias) - - self.embedding_dim = embedding_dim - - def forward(self, x: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - for feature in self.features: - for layer in feature: - if isinstance(layer, MBConvFilm): - x = layer(x, context) - else: - x = layer(x) - - x = self.avgpool(x) - x = torch.squeeze(x, dim=(2, 3)) # squeeze if h = w = 1 - x = self.classifier(x) - - return x - - -def get_weights(arch: str) -> Weights: - """ - Returns the default weights for the given EfficientNet model. - - Parameters: - arch (str): The EfficientNet variant to use. Allowed values are: - - 'efficientnet_b0' - - 'efficientnet_b1' - - 'efficientnet_b2' - - 'efficientnet_b3' - - 'efficientnet_b4' - - 'efficientnet_b5' - - 'efficientnet_b6' - - 'efficientnet_b7' - - 'efficientnet_v2_s' - - 'efficientnet_v2_m' - - 'efficientnet_v2_l' - - Returns: - WeightsEnum: The default weights for the given architecture. - - Raises: - ValueError: If the given architecture is not supported. - """ - - if arch == "efficientnet_b0": - weights = EfficientNet_B0_Weights.DEFAULT - elif arch == "efficientnet_b1": - weights = EfficientNet_B1_Weights.DEFAULT - elif arch == "efficientnet_b2": - weights = EfficientNet_B2_Weights.DEFAULT - elif arch == "efficientnet_b3": - weights = EfficientNet_B3_Weights.DEFAULT - elif arch == "efficientnet_b4": - weights = EfficientNet_B4_Weights.DEFAULT - elif arch == "efficientnet_b5": - weights = EfficientNet_B5_Weights.DEFAULT - elif arch == "efficientnet_b6": - weights = EfficientNet_B6_Weights.DEFAULT - elif arch == "efficientnet_b7": - weights = EfficientNet_B7_Weights.DEFAULT - elif arch == "efficientnet_v2_s": - weights = EfficientNet_V2_S_Weights.DEFAULT - elif arch == "efficientnet_v2_m": - weights = EfficientNet_V2_M_Weights.DEFAULT - elif arch == "efficientnet_v2_l": - weights = EfficientNet_V2_L_Weights.DEFAULT - else: - raise ValueError(f"Unsupported model type `{arch}`") - - return weights - - -class FilmEfficientNet(nn.Module): - def __init__( - self, - arch: str, - include_top: bool = False, - embedding_dim: int = 512, - pretrained: Optional[bool] = True, - weights: Optional[Weights] = None, - progress: Optional[bool] = True, - device: Optional[Union[str, torch.device]] = "cuda", - **kwargs, - ): - """Builds a FilmEfficientNet model. - - Args: - arch (str): The EfficientNet variant to use. Allowed values are: - - 'efficientnet_b0' - - 'efficientnet_b1' - - 'efficientnet_b2' - - 'efficientnet_b3' - - 'efficientnet_b4' - - 'efficientnet_b5' - - 'efficientnet_b6' - - 'efficientnet_b7' - - 'efficientnet_v2_s' - - 'efficientnet_v2_m' - - 'efficientnet_v2_l' - include_top (bool, optional): Whether to include the classification head - embedding_dim (int, optional): The dimensionality of the output embeddings. - pretrained (bool, optional): Whether to load pretrained EfficientNet weights. - Defaults to True. - weights (WeightsEnum, optional): The pretrained weights to use. - only allowed if `pretrained==False`. Defaults to None. - progress (bool, optional): If True, displays a progress bar of the - download to stderr. Default is True. - device (torch.device, optional): The device on which the model will be - **kwargs: parameters passed to the `FilmEfficientNet` class. - """ - super().__init__() - norm_layer = None - if arch == "efficientnet_b0": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.0, depth_mult=1.0 - ) - dropout = 0.2 - self.output_hw = 7 - elif arch == "efficientnet_b1": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.0, depth_mult=1.1 - ) - dropout = 0.2 - self.output_hw = 8 - elif arch == "efficientnet_b2": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.1, depth_mult=1.2 - ) - dropout = 0.3 - self.output_hw = 9 - elif arch == "efficientnet_b3": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.2, depth_mult=1.4 - ) - dropout = 0.3 - self.output_hw = 10 - elif arch == "efficientnet_b4": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.4, depth_mult=1.8 - ) - dropout = 0.4 - self.output_hw = 12 - elif arch == "efficientnet_b5": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.6, depth_mult=2.2 - ) - dropout = 0.4 - norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) - self.output_hw = 15 - elif arch == "efficientnet_b6": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=1.8, depth_mult=2.6 - ) - dropout = 0.5 - norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) - self.output_hw = 17 - elif arch == "efficientnet_b7": - inverted_residual_setting, last_channel = _efficientnet_conf( - arch, width_mult=2.0, depth_mult=3.1 - ) - dropout = 0.5 - norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01) - self.output_hw = 20 - elif arch == "efficientnet_v2_s": - inverted_residual_setting, last_channel = _efficientnet_conf(arch) - dropout = 0.2 - norm_layer = partial(nn.BatchNorm2d, eps=1e-03) - self.output_hw = 12 - elif arch == "efficientnet_v2_m": - inverted_residual_setting, last_channel = _efficientnet_conf(arch) - dropout = 0.3 - norm_layer = partial(nn.BatchNorm2d, eps=1e-03) - self.output_hw = 15 - elif arch == "efficientnet_v2_l": - inverted_residual_setting, last_channel = _efficientnet_conf(arch) - dropout = 0.4 - norm_layer = partial(nn.BatchNorm2d, eps=1e-03) - self.output_hw = 15 - - assert ( - weights is None or not pretrained - ), "Cannot pass in custom weights with pretrained=True" - weights = get_weights(arch) if pretrained else weights - - if weights is not None: - _ovewrite_named_param( - kwargs, "num_classes", len(weights.meta["categories"]) - ) - - model = _FilmEfficientNet( - inverted_residual_setting, - dropout, - include_top=include_top, - last_channel=last_channel, - norm_layer=norm_layer, - embedding_dim=embedding_dim, - **kwargs, - ) - - if weights is not None: - state_dict = weights.get_state_dict(progress=progress) - new_state_dict = {} - for k, v in state_dict.items(): - if ".block" in k: - new_state_dict[k.replace(".block", ".mbconv.block")] = v - else: - new_state_dict[k] = v - model.load_state_dict( - new_state_dict, - strict=False, - ) - - self.model = model.to(device) - self.preprocess = weights.transforms(antialias=True) if weights else lambda x: x - - self.conv1x1 = nn.Conv2d( - in_channels=self.model.features[-1].out_channels, - out_channels=embedding_dim, - kernel_size=(1, 1), - stride=(1, 1), - padding="same", - bias=False, - device=device, - ) - nn.init.kaiming_normal_(self.conv1x1.weight) - self.film_layer = FilmConditioning(embedding_dim, embedding_dim).to(device) - self.include_top = include_top - self.embedding_dim = embedding_dim - - def forward( - self, image: torch.Tensor, context: Optional[torch.Tensor] = None - ) -> torch.Tensor: - if len(image.shape) == 3: - # Add batch dimension - image = image.unsqueeze(0) - assert len(image.shape) == 4, f"Unexpected image shape: {image.shape}" - if image.shape[-1] == 3: - # (B, H, W, C) -> (B, C, H, W) - image = image.permute(0, 3, 1, 2) - if torch.max(image) >= 1.0: - # Normalize to [0, 1] - image = image / 255.0 - assert torch.min(image) >= 0.0 and torch.max(image) <= 1.0 - image = self.preprocess(image) - - if context is not None and self.include_top: - raise ValueError("Context cannot be passed in if include_top=True") - elif context is None: - context = torch.zeros( - image.shape[0], self.embedding_dim, device=image.device - ) - - features = self.model(image, context) - if not self.include_top: - features = self.conv1x1(features) - features = self.film_layer(features, context) - return features - - -def decode_predictions(preds: torch.Tensor, top=5): - preds = preds.detach().cpu().numpy() - results = [] - for pred in preds: - top_indices = pred.argsort()[-top:][::-1] - result = [(_IMAGENET_CATEGORIES[i], pred[i]) for i in top_indices] - results.append(result) - return results \ No newline at end of file diff --git a/rt1_pytorch/rt1_model.py b/rt1_pytorch/rt1_model.py deleted file mode 100644 index 30388f638..000000000 --- a/rt1_pytorch/rt1_model.py +++ /dev/null @@ -1,217 +0,0 @@ -from typing import Optional - -import torch -from einops import rearrange -from torch import nn - -from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer - - -def posemb_sincos_1d(seq, dim, temperature=10000, device=None, dtype=torch.float32): - """ - Generate positional embeddings using sine and cosine functions for a 1-dimensional sequence. - - Parameters: - seq (int): The length of the sequence. - dim (int): The dimension of the positional embeddings. - temperature (float, optional): The temperature parameter for the sine function. Defaults to 10000. - device (torch.device, optional): The device for tensor operations. Defaults to None. - dtype (torch.dtype, optional): The data type of the positional embeddings. Defaults to torch.float32. - - Returns: - torch.Tensor: The positional embeddings of shape (seq, dim), with each element computed as the concatenation of the sine and cosine values. - - """ - n = torch.arange(seq, device=device) - omega = torch.arange(dim // 2, device=device) / (dim // 2 - 1) - omega = 1.0 / (temperature**omega) - - n = n[:, None] * omega[None, :] - pos_emb = torch.cat((n.sin(), n.cos()), dim=1) - return pos_emb.type(dtype) - - -# Robotic Transformer -class RT1Model(nn.Module): - def __init__( - self, - arch: str = "efficientnet_b3", - tokens_per_action=11, - action_bins=256, - num_layers=4, - num_heads=8, - feed_forward_size=512, - dropout_rate=0.1, - time_sequence_length=6, - embedding_dim=512, - use_token_learner=True, - token_learner_bottleneck_dim=64, - token_learner_num_output_tokens=8, - device="cuda", - ): - """ - Initializes the RT1Model. - - Parameters: - arch (str): The efficientnet variant to use. Default is "efficientnet_b3". - tokens_per_action (int): The number of tokens per action. Default is 11. - action_bins (int): The number of action bins. Default is 256. - num_layers (int): The number of transformer layers. Default is 6. - num_heads (int): The number of attention heads. Default is 8. - feed_forward_size (int): The size of the feed-forward layer. Default is 512. - dropout_rate (float): The dropout rate. Default is 0.1. - time_sequence_length (int): The length of the time sequence. Default is 6. - embedding_dim (int): The dimension of the embedding. Default is 512. - use_token_learner (bool): Whether to use token learner. Default is True. - token_learner_bottleneck_dim (int): The dimension of the token learner bottleneck. Default is 64. - token_learner_num_output_tokens (int): The number of output tokens of the token learner. Default is 8. - device (torch.device, optional): The device for tensor operations. Defaults to "cuda". - - Returns: - None - """ - super().__init__() - self.time_sequence_length = time_sequence_length - self.action_encoder = nn.Linear(action_bins, embedding_dim, device=device) - self.image_tokenizer = RT1ImageTokenizer( - arch=arch, - embedding_dim=embedding_dim, - use_token_learner=use_token_learner, - token_learner_bottleneck_dim=token_learner_bottleneck_dim, - token_learner_num_output_tokens=token_learner_num_output_tokens, - dropout_rate=dropout_rate, - device=device, - ) - - self.num_tokens = self.image_tokenizer.num_output_tokens - - self.transformer = nn.Transformer( - d_model=embedding_dim, - nhead=num_heads, - num_encoder_layers=num_layers, - num_decoder_layers=num_layers, - dim_feedforward=feed_forward_size, - dropout=dropout_rate, - activation="gelu", - batch_first=True, - device=device, - ) - - self.to_logits = nn.Sequential( - nn.LayerNorm(embedding_dim), - nn.Linear(embedding_dim, action_bins), - ).to(device) - - self.tokens_per_action = tokens_per_action - self.action_bins = action_bins - self.embedding_dim = embedding_dim - self.device = device - - def forward( - self, - videos: torch.Tensor, - texts: Optional[torch.Tensor] = None, - action_logits: Optional[torch.Tensor] = None, - ): - """ - Forward pass of the model. - - Args: - videos (torch.Tensor): The input videos. - Shape is (b, f, h, w, c) or (b, f, c, h, w). - texts (Optional[torch.Tensor]): The input text embedding. - Shape is (b, f, embedding_dim). - action_logits (Optional[torch.Tensor]): The input action_logits. - Shape is (b, f, tokens_per_action, action_bins). - - Returns: - torch.Tensor: The output logits. - Shape is (b, f, tokens_per_action, action_bins). - """ - b, f, *_ = videos.shape - assert ( - f == self.time_sequence_length - ), f"Expected {self.time_sequence_length} frames, got videos.shape[1] = {f}" - - if texts is None: - texts = torch.zeros((b, f, self.embedding_dim), device=self.device) - if action_logits is None: - action_logits = torch.zeros( - (b, f, self.tokens_per_action, self.action_bins), device=self.device - ) - elif action_logits.shape != (b, f, self.tokens_per_action, self.action_bins): - raise ValueError( - f"""Expected action_logits.shape = (b, f, tokens_per_action, action_bins), - got {action_logits.shape}; did you pass in raw actions instead?""" - ) - - # pack time dimension into batch dimension - videos = rearrange(videos, "b f ... -> (b f) ...") - texts = rearrange(texts, "b f d -> (b f) d") - - # tokenize images and texts - tokens = self.image_tokenizer(videos, texts) - - # unpack time dimension from batch dimension - tokens = rearrange(tokens, "(b f) c n -> b f c n", b=b, f=f) - - # pack time dimension into token dimension - tokens = rearrange(tokens, "b f c n -> b (f n) c") - action_logits = rearrange(action_logits, "b f a d -> b (f a) d") - - # sinusoidal positional embedding - pos_emb = posemb_sincos_1d(tokens.shape[1], tokens.shape[2], device=self.device) - tokens = tokens + pos_emb - - # causal mask for tokens - token_mask = torch.ones( - tokens.shape[1], tokens.shape[1], dtype=torch.bool - ).tril(0) - token_mask = ~token_mask - token_mask = token_mask.to(self.device) - - # encode action_logits to have the same embedding dimension as tokens - action_tokens = self.action_encoder(action_logits) - - pos_emb = posemb_sincos_1d( - action_tokens.shape[1], action_tokens.shape[2], device=self.device - ) - action_tokens = action_tokens + pos_emb - - # action mask: do not let action_logits attend to previous action_logits, - # a_t is independent of a_{t-1} given pi and s_t - action_mask = torch.ones( - self.time_sequence_length, self.time_sequence_length, dtype=torch.bool - ).tril(0) - action_mask = torch.kron( - torch.eye(self.tokens_per_action, self.tokens_per_action, dtype=torch.bool), - action_mask, - ) - action_mask = ~action_mask - action_mask = action_mask.to(self.device) - - # causal mask between tokens and action_logits; - # a_t attends to s_t' for all t'<=t - memory_mask = torch.ones( - self.time_sequence_length, self.time_sequence_length, dtype=torch.bool - ).tril(0) - memory_mask = torch.kron( - memory_mask, - torch.ones(self.tokens_per_action, self.num_tokens, dtype=torch.bool), - ) - memory_mask = ~memory_mask - memory_mask = memory_mask.to(self.device) - - attended_tokens = self.transformer( - src=tokens, - src_mask=token_mask, - tgt=action_tokens, - tgt_mask=action_mask, - memory_mask=memory_mask, - ) - - # unpack time dimension from token dimension - attended_tokens = rearrange(attended_tokens, "b (f n) c -> b f n c", b=b, f=f) - - logits = self.to_logits(attended_tokens) - return logits \ No newline at end of file diff --git a/rt1_pytorch/rt1_policy.py b/rt1_pytorch/rt1_policy.py deleted file mode 100644 index f68155a56..000000000 --- a/rt1_pytorch/rt1_policy.py +++ /dev/null @@ -1,234 +0,0 @@ -from typing import Dict, List, Optional, Tuple, Union - -import gymnasium as gym -import numpy as np -import torch -import tree -from einops import rearrange -from torch.nn import functional as F -import pdb - -from rt1_pytorch.rt1_model import RT1Model -from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer - - -class RT1Policy: - def __init__( - self, - observation_space: gym.spaces.Dict, - action_space: gym.spaces.Dict, - arch: str = "efficientnet_b3", - action_bins=256, - num_layers=4, - num_heads=8, - feed_forward_size=256, - dropout_rate=0.1, - time_sequence_length=6, - embedding_dim=512, - use_token_learner=True, - token_learner_bottleneck_dim=64, - token_learner_num_output_tokens=8, - device="cuda", - checkpoint_path: Optional[str] = None, - ): - """ - Initializes an instance of the class. - - Args: - observation_space (gym.spaces.Dict): The observation space of the environment. - action_space (gym.spaces.Dict): The action space of the environment. - arch (str, optional): The architecture of the model. Defaults to "efficientnet_b3". - action_bins (int, optional): The number of bins for discretizing continuous action spaces. Defaults to 256. - num_layers (int, optional): The number of transformer layers in the model. Defaults to 8. - num_heads (int, optional): The number of attention heads in each transformer layer. Defaults to 8. - feed_forward_size (int, optional): The size of the feed-forward layer in the transformer. Defaults to 256. - dropout_rate (float, optional): The dropout rate for the transformer layers. Defaults to 0.1. - time_sequence_length (int, optional): The length of the time sequence for the model. Defaults to 6. - embedding_dim (int, optional): The dimensionality of the input embeddings. Defaults to 512. - use_token_learner (bool, optional): Whether to use the token learner module. Defaults to True. - token_learner_bottleneck_dim (int, optional): The dimensionality of the bottleneck layer in the token learner. Defaults to 64. - token_learner_num_output_tokens (int, optional): The number of output tokens from the token learner. Defaults to 8. - device (str, optional): The device to use for the model. Defaults to "cuda". - checkpoint_path (str, optional): load checkpoint from path. Defaults to None. - - Returns: - None - """ - self.observation_space = observation_space - self.action_space = action_space - self.action_bins = action_bins - self.action_tokenizer = RT1ActionTokenizer( - action_space=action_space, - action_bins=action_bins, - action_order=list(action_space.keys()), - ) - - self.model = RT1Model( - arch=arch, - tokens_per_action=self.action_tokenizer.tokens_per_action, - action_bins=action_bins, - num_layers=num_layers, - num_heads=num_heads, - feed_forward_size=feed_forward_size, - dropout_rate=dropout_rate, - time_sequence_length=time_sequence_length, - embedding_dim=embedding_dim, - use_token_learner=use_token_learner, - token_learner_bottleneck_dim=token_learner_bottleneck_dim, - token_learner_num_output_tokens=token_learner_num_output_tokens, - device=device, - ) - - self.embedding_dim = embedding_dim - - for action_space in self.action_space.values(): - if ( - isinstance(action_space, gym.spaces.Discrete) - and action_space.n == time_sequence_length - ): - raise ValueError( - f"""stupid hack:Time sequence length ({time_sequence_length}) - must be different from action space length ({action_space.n}).""" - ) - - self.device = device - if checkpoint_path is not None: - print(f"Loading checkpoint from {checkpoint_path}...") - self.model.load_state_dict(torch.load(checkpoint_path)) - - def preprocess( - self, - videos: Union[np.ndarray, List[np.ndarray]], - texts: Union[np.ndarray, List[np.ndarray]], - actions: Optional[Dict] = None, - ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: - """ - Preprocesses the given videos, texts, and actions. - - Args: - videos (Union[np.ndarray, List[np.ndarray]]): The input videos to preprocess. - shape: (b, t, c, h, w) or (b, t, h, w, c) - texts (Union[np.ndarray, List[np.ndarray]]): The input texts to preprocess. - shape: (b, t, d) - actions (Optional[Dict]): The input actions to preprocess. Defaults to None. - shape: (b, t, a) - - Returns: - Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: A tuple containing the preprocessed videos, texts, and actions. - """ - if isinstance(videos, torch.Tensor): - videos = videos.to(self.device) - elif not isinstance(videos, np.ndarray): - videos = np.stack(videos, axis=0) - - if not isinstance(videos, torch.Tensor): - videos = torch.tensor(videos, device=self.device, dtype=torch.float32) - - if isinstance(texts, torch.Tensor): - texts = texts.to(self.device) - elif not isinstance(texts, np.ndarray): - texts = np.stack(texts, axis=0) - if not isinstance(texts, torch.Tensor): - texts = torch.tensor(texts, device=self.device, dtype=torch.float32) - - - if actions is not None: - actions = { - k: np.stack(v, axis=0) if not (isinstance(v, np.ndarray)) else v - for k, v in actions.items() - } - - - actions = tree.map_structure( - lambda a: rearrange(a, "b f ... -> (b f) ..."), actions - ) - actions = self.action_tokenizer.tokenize(actions) - actions = torch.tensor(actions, device=self.device, dtype=torch.long) - actions = rearrange(actions, "(b f) ... -> b f ...", b=videos.shape[0]) - - return videos, texts, actions - - def forward( - self, - videos: torch.Tensor, - texts: torch.Tensor, - action_logits: Optional[torch.Tensor] = None, - ) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Forward pass through the model. - - Args: - videos (torch.Tensor): Input videos. - texts (torch.Tensor): input contexts. - action_logits (Optional[torch.Tensor]): Optional input action logits. - - Returns: - action_logits (Tuple[torch.Tensor, torch.Tensor]): - A tuple containing the sampled actions and the action logits. - """ - action_logits = self.model(videos, texts, action_logits) - actions = torch.distributions.Categorical(logits=action_logits) - actions = actions.sample() - return actions, action_logits - - def loss(self, observations: Dict, target_actions: Dict) -> torch.Tensor: - """ - Calculates the loss function for the given inputs. - - Args: - observations (Dict): A dictionary containing the observations. - It should have the following keys: - - "image" (np.ndarray): The video observations. - - "context" (np.ndarray): The context. - target_actions (Dict): A dictionary containing the target actions. - - Returns: - torch.Tensor: The calculated loss value. - - Raises: - None - """ - videos = observations["image"] - texts = observations["context"] - videos, texts, target_actions = self.preprocess( - videos, - texts, - target_actions, - ) - _, action_logits = self.forward(videos, texts) - - action_logits = rearrange(action_logits, "b f a d -> (b f a) d") - target_actions = rearrange(target_actions, "b f a -> (b f a)") - loss = F.cross_entropy(action_logits, target_actions, reduction="sum") - loss = loss / videos.shape[0] - - - dummy_loss = F.cross_entropy(action_logits, target_actions, reduction="none") - loss_std = torch.std(dummy_loss) - - return loss, loss_std - - def act(self, observations: Dict) -> Dict[str, np.ndarray]: - """ - Performs an action based on the given observations. - Note that this takes in observations of shape (b,t, ...) - but only returns the last action for each trajectory of shape (b, ...). - - Args: - observations (Dict): A dictionary containing the observations. It should have the following keys: - - "image" (np.ndarray): The video observations. - - "context" (np.ndarray): The context. - - Returns: - Dict[str, np.ndarray]: A dictionary containing the actions. It has the following keys: - - "actions" (np.ndarray): The actions performed based on the observations. - """ - videos = observations["image"] - texts = observations["context"] - videos, texts, _ = self.preprocess(videos, texts) - with torch.no_grad(): - actions, _ = self.forward(videos, texts) - actions = actions.detach().cpu().numpy() - actions = self.action_tokenizer.detokenize(actions) - actions = tree.map_structure(lambda a: a[:, -1], actions) - return actions diff --git a/rt1_pytorch/tokenizers/__init__.py b/rt1_pytorch/tokenizers/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/rt1_pytorch/tokenizers/action_tokenizer.py b/rt1_pytorch/tokenizers/action_tokenizer.py deleted file mode 100644 index 542aa6ec3..000000000 --- a/rt1_pytorch/tokenizers/action_tokenizer.py +++ /dev/null @@ -1,184 +0,0 @@ -"""A simple action tokenizer used with Robotics Transformer 1. - -As an example, if an action is: -{ - 'base_displacement_vector': - , - 'base_displacement_vertical_rotation': - , - 'gripper_closedness_action': - , - 'rotation_delta': - , - 'terminate_episode': - , - 'world_vector': - -} - -Then we build a sequence of tokens of length 11 [one for each dimension]. -The int32 type action dimensions are already tokenized, -the float dimensions are bucketed according to the spaces min and max. Each -dimension has 'action_bins' buckets. - -Currently, this tokenizer assumes one action space and it is highly recommended -to spaceify the 'action_order', i.e. the order of keys in the dict. -Since after tokenization you lose that information, this -will be useful for debugging. Actions may also be subselected for prediction, -since not all actions are needed in the action_order. -""" -from typing import Dict, Optional - -import gymnasium as gym -import numpy as np -from gymnasium.spaces import Box, Discrete -import pdb - -class RT1ActionTokenizer: - """Tokenizes based on vocab size.""" - - def __init__( - self, - action_space: gym.spaces.Dict, - action_bins: int, - action_order: Optional[list[str]] = None, - ): - """Instantiates an RT1ActionTokenizer. - - Args: - action_bins: Number of buckets to discretize action to. - action_order: Order of the action names, used to discern the order of - tokenized actions to detokenize and assemble back to action tensor - """ - self._action_bins = action_bins - - # filter the action keys - lanmp_keys = ['terminate_episode', 'pickup_release', 'body_position_delta', 'body_yaw_delta','body_pitch_delta','arm_position_delta','control_mode'] - bridge_keys = ['terminate_episode','world_vector', 'open_gripper', "rotation_delta"] - jaco_keys = ['terminate_episode','world_vector', 'gripper_closedness_action'] - - #NOTE: change both lines below to the specific dataset keys - action_order = lanmp_keys #bridge_keys #jaco_keys - action_space = {key: action_space[key] for key in lanmp_keys if key in set(action_space.keys())} - self._action_space = action_space - if action_order is None: - self._action_order = list(action_space.keys()) - else: - for action in action_order: - assert ( - action in action_space.keys() - ), f"action: {action} not in action_space: {action_space.keys()}" - self._action_order = action_order - self._tokens_per_action = 0 - for action in self._action_order: - action_shape = action_space[action].shape - if isinstance(action_space, gym.spaces.Box) and len(action_shape) != 1: - raise ValueError( - f"Only action shapes with single dimension supported, got {action_shape}" - ) - if isinstance(action_space[action], Discrete): - # Int32 actions are already assumed to be tokens. - self._tokens_per_action += 1 - elif isinstance(action_space[action], Box): - if len(action_shape) != 1: - raise ValueError( - f"Only action shapes with single dimension supported, got {action_shape}" - ) - self._tokens_per_action += action_shape[0] - else: - raise ValueError( - f"Unsupported action space: {type(action_space[action])}" - ) - - # We measure # of action tokens in two different way. One is by checking - # from action_order (above) and the other is by looping through the - # action space (below). We aseert the # of action tokens are the same - # calculated by these two ways. This will assure action_order is correctly - # configured, otherwise, it will throw an error in the assert. - num_action_token = 0 - for space in action_space.values(): - if space.dtype == np.int_: - num_action_token += 1 - else: - num_action_token += space.shape[-1] - assert ( - self._tokens_per_action == num_action_token - ), f"{self._tokens_per_action} != {num_action_token}" - - @property - def tokens_per_action(self) -> int: - return self._tokens_per_action - - @property - def action_space(self) -> gym.spaces.Dict: - return self._action_space - - @property - def action_order(self) -> list[str]: - return self._action_order - - def tokenize(self, action: Dict) -> np.ndarray: - """Tokenizes an action.""" - - action_tokens = [] - for k in self._action_order: - #print("k equals " + str(k)) - #print(action.keys()) - #print(action) - act = action[k] # a is [batch, (time), action_size] - space = self._action_space[k] - if isinstance(space, gym.spaces.Discrete): - # Int32 actions are already assumed to be tokens - if not (isinstance(act, np.ndarray)): - act = np.array(act, dtype=np.int32) - act = np.expand_dims(act, axis=-1) - if not np.all(act < space.n): - raise ValueError(f"Invalid action: {act} >= {space.n}") - token = act - elif isinstance(space, gym.spaces.Box): - low = space.low[0] - high = space.high[0] - act = np.clip(act, low, high) - # Normalize the action [batch, actions_size] - token = (act - low) / (high - low) - # Bucket and discretize the action to action_bins, [batch, actions_size] - token = (token * (self._action_bins - 1)).astype(np.int32) - #TODO: bridge - if k == 'open_gripper': - token = token[:,None] - action_tokens.append(token) - #print(k, token.shape) - # Append all actions, [batch, (time), all_actions_size] - action_tokens = np.concatenate(action_tokens, axis=-1) - return action_tokens - - def detokenize(self, action_tokens: np.ndarray) -> Dict: - """Detokenizes an action.""" - action = {} - token_index = 0 - if not action_tokens.shape[-1] == self._tokens_per_action: - action_tokens = action_tokens.reshape( - *action_tokens.shape[:-1], self._tokens_per_action - ) - for k in self._action_order: - space = self._action_space[k] - if isinstance(space, gym.spaces.Discrete): - # Int32 actions are already assumed to be tokens. - action[k] = action_tokens[..., token_index] - # A poor model may output tokens outside the allowed range, in that case - # set them to a default value, the 0 token in this case. - action[k] = np.where( - action[k] >= space.n, np.zeros_like(action[k]), action[k] - ) - token_index += 1 - elif isinstance(space, gym.spaces.Box): - actions = [] - for _ in range(space.shape[0]): - a = action_tokens[..., token_index : token_index + 1] - a = a.astype(np.float32) - a = a / (self._action_bins - 1) - a = (a * (space.high[0] - space.low[0])) + space.low[0] - actions.append(a) - token_index += 1 - action[k] = np.concatenate(actions, axis=-1) - return action diff --git a/rt1_pytorch/tokenizers/image_tokenizer.py b/rt1_pytorch/tokenizers/image_tokenizer.py deleted file mode 100644 index 9cf4cdcb0..000000000 --- a/rt1_pytorch/tokenizers/image_tokenizer.py +++ /dev/null @@ -1,77 +0,0 @@ -"""The image tokenizer combining the FiLMEfficientNet and TokenLearner from RT1. -""" -import torch -from torch import nn - -from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning -from rt1_pytorch.film_efficientnet.film_efficientnet import FilmEfficientNet -from rt1_pytorch.tokenizers.token_learner import TokenLearner - - -class RT1ImageTokenizer(nn.Module): - """Tokenizes based on vocab size.""" - - def __init__( - self, - arch: str = "efficientnet_b3", - embedding_dim: int = 512, - use_token_learner=True, - token_learner_bottleneck_dim=64, - token_learner_num_output_tokens=8, - dropout_rate=0.1, - device="cuda", - ): - """Instantiates a RT1ImageTokenizer. - - Args: - arch: The efficientnet variant to use. - embedding_dim: The embedding size of the tokens. - use_token_learner: Whether to use token learner. See - https://arxiv.org/abs/2106.11297 - num_tokens: Relevant only for token learner - the number of learned - tokens. - token_learner_bottleneck_dim: Relevant only for token learner - the - dimension of the bottleneck layer. - token_learner_num_output_tokens: Relevant only for token learner - - the number of output tokens. - dropout_rate: Relevant only for token learner - the dropout rate. - device: The device to place the model on. - """ - super().__init__() - - self.film_efficientnet = FilmEfficientNet( - arch=arch, embedding_dim=embedding_dim, device=device - ) - self.num_output_tokens = self.film_efficientnet.output_hw**2 - - self._use_token_learner = use_token_learner - if self._use_token_learner: - self._token_learner = TokenLearner( - embedding_dim=embedding_dim, - num_tokens=token_learner_num_output_tokens, - bottleneck_dim=token_learner_bottleneck_dim, - dropout_rate=dropout_rate, - device=device, - ) - self.num_output_tokens = token_learner_num_output_tokens - - def forward(self, image: torch.Tensor, context: torch.Tensor) -> torch.Tensor: - """Gets image tokens. - - Args: - image: Images of shape (b, h, w, 3) to tokenize. - context: A context vector (e.g., a natural language embedding). - Expected to have shape (b, embedding_dim). - - Returns: - tokens: has shape (batch, num_tokens_per_timestep, embedding_dim) - """ - assert len(context.shape) == 2, f"Unexpected context shape: {context.shape}" - - tokens = self.film_efficientnet(image, context) - if len(tokens.shape) == 4: - # (b, c, h, w) -> (b, c, h*w) - tokens = tokens.reshape(tokens.shape[0], tokens.shape[1], -1) - if self._use_token_learner: - tokens = self._token_learner(tokens) - return tokens \ No newline at end of file diff --git a/rt1_pytorch/tokenizers/token_learner.py b/rt1_pytorch/tokenizers/token_learner.py deleted file mode 100644 index 8e04a4c30..000000000 --- a/rt1_pytorch/tokenizers/token_learner.py +++ /dev/null @@ -1,89 +0,0 @@ -"""Pytorch implementation of TokenLearner(Ryoo et al 2021).""" - -import torch -from torch import nn - - -class MlpBlock(nn.Module): - """Transformer MLP / feed-forward block.""" - - def __init__( - self, - input_dim: int, - mlp_dim: int, - out_dim: int, - dropout_rate: float = 0.1, - device="cuda", - ): - """Initializer for the MLP Block. - - This computes outer_dense(gelu(hidden_dense(input))), with dropout - applied as necessary. - - Args: - input_dim: The dimension of the input. - mlp_dim: The dimension of the inner representation (output of hidden - layer). Usually larger than the input/output dim. - out_dim: The output dimension of the block. - dropout_rate: Dropout rate to be applied after dense ( & activation) - layers. - device: The device to place the model on. - """ - super().__init__() - self._hidden_dropout = nn.Dropout(dropout_rate) - self._output_dropout = nn.Dropout(dropout_rate) - self._hidden_layer = nn.Linear(input_dim, mlp_dim, device=device) - self._output_layer = nn.Linear(mlp_dim, out_dim, device=device) - nn.init.xavier_uniform_(self._hidden_layer.weight) - nn.init.xavier_uniform_(self._output_layer.weight) - nn.init.normal_(self._hidden_layer.bias, std=1e-6) - nn.init.normal_(self._output_layer.bias, std=1e-6) - - def forward(self, inputs: torch.Tensor) -> torch.Tensor: - """Applies Transformer MlpBlock module.""" - x = self._hidden_layer(inputs) - x = nn.functional.gelu(x) - x = self._hidden_dropout(x) - x = self._output_layer(x) - x = self._output_dropout(x) - return x - - -class TokenLearner(nn.Module): - """TokenLearner module V1.1 (https://arxiv.org/abs/2106.11297).""" - - def __init__( - self, - embedding_dim: int, - num_tokens: int, - bottleneck_dim: int = 64, - dropout_rate: float = 0.0, - device="cuda", - ): - super().__init__() - - self.layernorm = nn.LayerNorm(embedding_dim, eps=1e-6, device=device) - self.mlp = MlpBlock( - input_dim=embedding_dim, - mlp_dim=bottleneck_dim, - out_dim=num_tokens, - dropout_rate=dropout_rate, - device=device, - ) - - def forward(self, inputs: torch.Tensor) -> torch.Tensor: - if len(inputs.shape) == 4: - bs, c, h, w = inputs.shape - inputs = torch.reshape(inputs, [bs, c, h * w]) - inputs = inputs.permute(0, 2, 1) # Shape: [bs, h*w, c] - - selected = self.layernorm(inputs) - - selected = self.mlp(selected) # Shape: [bs, h*w, n_token]. - selected = nn.functional.softmax(selected, dim=-1) - selected = selected.permute(0, 2, 1) # Shape: [bs, n_token, h*w] - - feat = torch.einsum("...si,...id->...sd", selected, inputs) - feat = feat.permute(0, 2, 1) - - return feat # Shape: [bs, c, n_token] \ No newline at end of file diff --git a/setup.py b/setup.py deleted file mode 100644 index 4c3290111..000000000 --- a/setup.py +++ /dev/null @@ -1,44 +0,0 @@ -from setuptools import find_packages, setup - -setup( - name="rt1-pytorch", - packages=find_packages(exclude=[]), - version="0.1.0", - license="MIT", - description="PyTorch implementation of the RT-1.", - author="Rohan Potdar", - author_email="rohanpotdar138@gmail.com", - long_description_content_type="text/markdown", - url="https://github.com/Rohan138/rt1-pytorch", - keywords=[ - "artificial intelligence", - "deep learning", - "transformers", - "attention mechanism", - "robotics", - ], - install_requires=[ - "torch>=1.9", - "scikit-image", - "sentence-transformers", - "tensorflow", - "tensorflow_datasets", - "transformers", - "gymnasium[mujoco]", - "dm-reverb", - "dm-control", - "rlds", - "einops", - "dmc2gymnasium@git+https://github.com/imgeorgiev/dmc2gymnasium.git", - "h5py", - "wandb", - "tqdm", - ], - classifiers=[ - "Development Status :: 4 - Beta", - "Intended Audience :: Developers", - "Topic :: Scientific/Engineering :: Artificial Intelligence", - "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3.6", - ], -) \ No newline at end of file diff --git a/tests/action_tokenizer_test.py b/tests/action_tokenizer_test.py deleted file mode 100644 index 6b082840b..000000000 --- a/tests/action_tokenizer_test.py +++ /dev/null @@ -1,166 +0,0 @@ -"""Tests for action_tokenizer.""" -import unittest - -import numpy as np -from gymnasium.spaces import Box, Dict, Discrete - -from rt1_pytorch.tokenizers.action_tokenizer import RT1ActionTokenizer - - -class ActionTokenizerTest(unittest.TestCase): - def testTokenize_int32(self): - action_space = Dict(terminate_episode=Discrete(2)) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(1, tokenizer.tokens_per_action) - action = dict(terminate_episode=np.array([1], dtype=np.int32)) - action_tokens = tokenizer.tokenize(action) - self.assertEqual(action["terminate_episode"], action_tokens) - - def testTokenize_int32_out_of_bounds(self): - action_space = Dict(terminate_episode=Discrete(2)) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(1, tokenizer.tokens_per_action) - action = dict(terminate_episode=np.array([3], dtype=np.int32)) - with self.assertRaises(ValueError): - tokenizer.tokenize(action) - - def testDetokenize_int32(self): - action_space = Dict(terminate_episode=Discrete(2)) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - action = tokenizer.detokenize(np.array([0], dtype=np.int32)) - self.assertEqual(action["terminate_episode"], np.array([0])) - # OOV 3 token should become a default one hot: [1, 0] - action = tokenizer.detokenize(np.array([3], dtype=np.int32)) - self.assertEqual(action["terminate_episode"], np.array([0])) - - def testTokenize_float(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) - ) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(3, tokenizer.tokens_per_action) - action = dict(world_vector=[0.1, 0.5, -0.8]) - action_tokens = tokenizer.tokenize(action) - self.assertSequenceEqual([4, 6, 0], list(action_tokens.tolist())) - - def testTokenize_float_with_time_dimension(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32) - ) - tokenizer = RT1ActionTokenizer(action_space, action_bins=10) - self.assertEqual(3, tokenizer.tokens_per_action) - batch_size = 2 - time_dimension = 3 - action = dict( - world_vector=np.array( - [ - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - [0.1, 0.5, -0.8], - ], - ).reshape((batch_size, time_dimension, 3)), - ) - action_tokens = tokenizer.tokenize(action) - self.assertSequenceEqual( - [batch_size, time_dimension, tokenizer.tokens_per_action], - action_tokens.shape, - ) - - def testTokenize_float_at_limits(self): - minimum = -1.0 - maximum = 1.0 - action_bins = 10 - action_space = Dict( - world_vector=Box(low=minimum, high=maximum, shape=(2,), dtype=np.float32) - ) - tokenizer = RT1ActionTokenizer(action_space, action_bins=action_bins) - self.assertEqual(2, tokenizer.tokens_per_action) - action = dict(world_vector=[minimum, maximum]) - action_tokens = tokenizer.tokenize(action) - # Minimum value will go to 0 - # Maximum value witll go to action_bins-1 - self.assertSequenceEqual([0, action_bins - 1], action_tokens.tolist()) - - def testTokenize_invalid_action_space_shape(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(2, 2), dtype=np.float32) - ) - with self.assertRaises(ValueError): - RT1ActionTokenizer(action_space, action_bins=10) - - def testTokenizeAndDetokenizeIsEqual(self): - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), - rotation_delta=Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 - ), - gripper_closedness_action=Box( - low=-1.0, high=1.0, shape=(1,), dtype=np.float32 - ), - terminate_episode=Discrete(3), - ) - - tokenizer = RT1ActionTokenizer( - action_space, - action_bins=256, - action_order=[ - "terminate_episode", - "world_vector", - "rotation_delta", - "gripper_closedness_action", - ], - ) - self.assertEqual(8, tokenizer.tokens_per_action) - - # Repeat the following test N times with fuzzy inputs. - n_repeat = 10 - for _ in range(n_repeat): - action = dict( - world_vector=np.random.uniform(low=-1.0, high=1.0, size=3), - rotation_delta=np.random.uniform( - low=-np.pi / 2.0, high=np.pi / 2.0, size=3 - ), - gripper_closedness_action=np.random.uniform(low=0.0, high=1.0, size=1), - terminate_episode=np.array(0, dtype=np.int32), - ) - action_tokens = tokenizer.tokenize(action) - policy_action = tokenizer.detokenize(action_tokens) - - for k in action: - self.assertTrue( - np.allclose(action[k], policy_action[k], atol=1e-1), - f"Failed at {k} with {action[k]} != {policy_action[k]}.", - ) - - # Repeat the test with batched actions - batched_action = dict( - world_vector=[ - np.random.uniform(low=-1.0, high=1.0, size=3), - np.random.uniform(low=-1.0, high=1.0, size=3), - ], - rotation_delta=[ - np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), - np.random.uniform(low=-np.pi / 2.0, high=np.pi / 2.0, size=3), - ], - gripper_closedness_action=[ - np.random.uniform(low=0.0, high=1.0, size=1), - np.random.uniform(low=0.0, high=1.0, size=1), - ], - terminate_episode=[0, 1], - ) - action_tokens = tokenizer.tokenize(batched_action) - policy_action = tokenizer.detokenize(action_tokens) - - for k in batched_action: - for a, policy_a in zip(batched_action[k], policy_action[k]): - self.assertTrue( - np.allclose(a, policy_a, atol=1e-1), - f"Failed at {k} with {a} != {policy_a}.", - ) - - -if __name__ == "__main__": - unittest.main() \ No newline at end of file diff --git a/tests/film_conditioning_layer_test.py b/tests/film_conditioning_layer_test.py deleted file mode 100644 index 0cefd44b0..000000000 --- a/tests/film_conditioning_layer_test.py +++ /dev/null @@ -1,27 +0,0 @@ -"""Tests for film_conditioning_layer.""" -import torch -from absl.testing import absltest, parameterized - -from rt1_pytorch.film_efficientnet.film_conditioning_layer import FilmConditioning - - -class FilmConditioningLayerTest(parameterized.TestCase): - @parameterized.parameters([2, 4]) - def test_film_conditioning_rank_two_and_four(self, conv_rank): - batch = 2 - num_channels = 3 - embedding_dim = 512 - if conv_rank == 2: - conv_layer = torch.randn(size=(batch, num_channels)) - elif conv_rank == 4: - conv_layer = torch.randn(size=(batch, 1, 1, num_channels)) - else: - raise ValueError(f"Unexpected conv rank: {conv_rank}") - context = torch.rand(batch, embedding_dim) - film_layer = FilmConditioning(embedding_dim, num_channels) - out = film_layer(conv_layer, context) - assert len(out.shape) == conv_rank - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/tests/film_efficientnet_test.py b/tests/film_efficientnet_test.py deleted file mode 100644 index 8fa2944cc..000000000 --- a/tests/film_efficientnet_test.py +++ /dev/null @@ -1,57 +0,0 @@ -"""Tests for pretrained_efficientnet_encoder.""" - -import torch -from absl.testing import absltest, parameterized -from skimage import data - -from rt1_pytorch.film_efficientnet.film_efficientnet import ( - FilmEfficientNet, - decode_predictions, -) - -MODELS = [ - "efficientnet_b0", - "efficientnet_b1", - "efficientnet_b2", - "efficientnet_b3", - # "efficientnet_b4", - # "efficientnet_b5", - # "efficientnet_b6", - # "efficientnet_b7", - "efficientnet_v2_s", - # "efficientnet_v2_m", - # "efficientnet_v2_l", -] - - -class FilmEfficientNetTest(parameterized.TestCase): - @parameterized.parameters(MODELS) - def test_encoding(self, model_name): - """Test that we get a correctly shaped encoding.""" - embedding_dim = 512 - batch_size = 4 - device = "cuda" if torch.cuda.is_available() else "cpu" - image = torch.tensor(data.chelsea()).repeat(batch_size, 1, 1, 1) - context = torch.FloatTensor(size=(batch_size, embedding_dim)).uniform_(-1, 1) - model = FilmEfficientNet(model_name, device=device).eval() - image = image.to(device) - context = context.to(device) - preds = model(image, context) - self.assertEqual( - preds.shape, (batch_size, 512, model.output_hw, model.output_hw) - ) - - @parameterized.parameters(MODELS) - def test_imagenet_classification(self, model_name): - """Test that we can correctly classify an image of a cat.""" - device = "cuda" if torch.cuda.is_available() else "cpu" - image = torch.tensor(data.chelsea()) - model = FilmEfficientNet(model_name, include_top=True, device=device).eval() - image = image.to(device) - preds = model(image) - predicted_names = [n[0] for n in decode_predictions(preds, top=3)[0]] - self.assertIn("tabby", predicted_names) - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/tests/image_tokenizer_test.py b/tests/image_tokenizer_test.py deleted file mode 100644 index 3b1dbd0e0..000000000 --- a/tests/image_tokenizer_test.py +++ /dev/null @@ -1,53 +0,0 @@ - -"""Tests for image_tokenizer.""" -import unittest - -import torch -from absl.testing import parameterized - -from rt1_pytorch.tokenizers.image_tokenizer import RT1ImageTokenizer - -MODELS = [ - "efficientnet_b0", - "efficientnet_b1", - "efficientnet_b2", - "efficientnet_b3", - # "efficientnet_b4", - # "efficientnet_b5", - # "efficientnet_b6", - # "efficientnet_b7", - "efficientnet_v2_s", - # "efficientnet_v2_m", - # "efficientnet_v2_l", -] - - -class ImageTokenizerTest(parameterized.TestCase): - @parameterized.named_parameters( - *[(f"sample_image_{m}", m, 512, 224, False, 8) for m in MODELS], - *[(f"sample_image_token_learner_{m}", m, 512, 224, True, 8) for m in MODELS], - ) - def testTokenize( - self, arch, embedding_dim, image_resolution, use_token_learner, num_tokens - ): - batch = 4 - device = "cuda" - tokenizer = RT1ImageTokenizer( - arch=arch, - embedding_dim=embedding_dim, - use_token_learner=use_token_learner, - token_learner_num_output_tokens=num_tokens, - device=device, - ) - - image = torch.randn((batch, image_resolution, image_resolution, 3)) - image = torch.clip(image, 0.0, 1.0) - image = image.to(device) - context_vector = torch.FloatTensor(size=(batch, 512)).uniform_() - context_vector = context_vector.to(device) - image_tokens = tokenizer(image, context_vector) - self.assertEqual(image_tokens.shape, (batch, 512, tokenizer.num_output_tokens)) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/rt1_model_test.py b/tests/rt1_model_test.py deleted file mode 100644 index 6ac8b07dd..000000000 --- a/tests/rt1_model_test.py +++ /dev/null @@ -1,54 +0,0 @@ -import torch -from absl.testing import absltest, parameterized - -from rt1_pytorch.rt1_model import RT1Model - - -class RT1ModelTest(parameterized.TestCase): - @parameterized.parameters(["cpu", "cuda"]) - def test_videos(self, device): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - logits = model(videos) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - @parameterized.parameters(["cpu", "cuda"]) - def test_videos_and_texts(self, device="cpu"): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - texts = torch.rand(batch_size, 6, 512, device=device) - logits = model(videos, texts) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - @parameterized.parameters(["cpu", "cuda"]) - def test_videos_and_action_logits(self, device="cpu"): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - action_logits = torch.rand(batch_size, 6, 11, 256, device=device) - logits = model(videos, action_logits=action_logits) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - @parameterized.parameters(["cpu", "cuda"]) - def test_videos_and_texts_and_action_logits(self, device="cpu"): - model = RT1Model(device=device) - - batch_size = 1 - videos = torch.rand(batch_size, 6, 3, 224, 224, device=device) - texts = torch.rand(batch_size, 6, 512, device=device) - action_logits = torch.rand(batch_size, 6, 11, 256, device=device) - logits = model(videos, texts, action_logits) - self.assertFalse(torch.isnan(logits).any()) - self.assertEqual(logits.shape, (batch_size, 6, 11, 256)) - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/tests/rt1_policy_test.py b/tests/rt1_policy_test.py deleted file mode 100644 index 2d861dc58..000000000 --- a/tests/rt1_policy_test.py +++ /dev/null @@ -1,64 +0,0 @@ -import numpy as np -from absl.testing import absltest, parameterized -from gymnasium.spaces import Box, Dict, Discrete -from skimage import data - -from rt1_pytorch.rt1_policy import RT1Policy - - -class RT1PolicyTest(parameterized.TestCase): - @parameterized.parameters(["cpu", "cuda"]) - def test_policy_act_and_loss(self, device="cpu"): - observation_space = Dict( - image=Box(low=0, high=255, shape=(300, 451, 3), dtype=np.uint8), - context=Box(low=0.0, high=1.0, shape=(512,), dtype=np.float32), - ) - action_space = Dict( - world_vector=Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32), - base_displacement_vertical_rotation=Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(1,), dtype=np.float32 - ), - gripper_closedness_action=Box( - low=-1.0, high=1.0, shape=(1,), dtype=np.float32 - ), - terminate_episode=Discrete(3), - base_displacement_vector=Box( - low=-1.0, - high=1.0, - shape=(3,), - dtype=np.float32, - ), - rotation_delta=Box( - low=-np.pi / 2.0, high=np.pi / 2.0, shape=(3,), dtype=np.float32 - ), - ) - policy = RT1Policy(observation_space, action_space, device=device) - - image = data.chelsea() - videos = np.reshape(image, (1, 1, *image.shape)).repeat(6, axis=1) - # videos (b, f, h, w, c) = (1, 6, 300, 451, 3) - context = np.random.rand(1, 6, 512).astype(np.float32) - # context (b, f, d) = (1, 6, 512) - observations = {"image": videos, "context": context} - actions = policy.act(observations) - - action_tokens = policy.action_tokenizer.tokenize(actions) - - self.assertEqual(action_tokens.shape, (1, 12)) - obs = {k: v[0][0] for k, v in observations.items()} - act = {k: v[0] for k, v in actions.items()} - self.assertTrue(observation_space.contains(obs)) - self.assertTrue(action_space.contains(act)) - - target_actions = { - k: np.expand_dims(v, axis=1).repeat(6, axis=1) for k, v in actions.items() - } - - loss = policy.loss(observations=observations, target_actions=target_actions) - self.assertGreater(loss, 0) - - # TODO (Rohan138): Add more tests - - -if __name__ == "__main__": - absltest.main() \ No newline at end of file diff --git a/tests/token_learner_test.py b/tests/token_learner_test.py deleted file mode 100644 index a856b256d..000000000 --- a/tests/token_learner_test.py +++ /dev/null @@ -1,40 +0,0 @@ -"""Tests for token_learner.""" -import unittest - -import torch - -from rt1_pytorch.tokenizers.token_learner import TokenLearner - - -class TokenLearnerTest(unittest.TestCase): - def testTokenLearner_h_w_split(self): - batch = 5 - embedding_dim = 512 - num_tokens = 8 - device = "cuda" if torch.cuda.is_available() else "cpu" - token_learner_layer = TokenLearner( - embedding_dim=embedding_dim, num_tokens=num_tokens, device=device - ) - - inputvec = torch.randn((batch, embedding_dim, 10, 10), device=device) - - learnedtokens = token_learner_layer(inputvec) - self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) - - def testTokenLearner_hw(self): - batch = 5 - embedding_dim = 512 - num_tokens = 8 - device = "cuda" if torch.cuda.is_available() else "cpu" - token_learner_layer = TokenLearner( - embedding_dim=embedding_dim, num_tokens=num_tokens, device=device - ) - - inputvec = torch.randn((batch, embedding_dim, 100), device=device) - - learnedtokens = token_learner_layer(inputvec) - self.assertEqual(learnedtokens.shape, (batch, embedding_dim, num_tokens)) - - -if __name__ == "__main__": - unittest.main() \ No newline at end of file diff --git a/vd4rl_main.py b/vd4rl_main.py deleted file mode 100644 index bd7a6dc06..000000000 --- a/vd4rl_main.py +++ /dev/null @@ -1,389 +0,0 @@ -import argparse -import os -from typing import Dict, Iterable - -import gymnasium as gym -import h5py -import numpy as np -import requests -import torch -import tqdm -import wandb -from dmc2gymnasium import DMCGym -from sentence_transformers import SentenceTransformer -from torch.optim import Adam - -from rt1_pytorch.rt1_policy import RT1Policy - -DATASET_URL = "https://huggingface.co/datasets/conglu/vd4rl/resolve/main/vd4rl/main/{domain}_{task}/expert/84px/{index}_{domain}_{task}_expert.hdf5" -ACTION_REPEAT = 2 - - -class VD4RLEnv(gym.Env): - def __init__( - self, - env_id: str, - embedding: np.ndarray, - embedding_dim: int, - num_frames: int, - dataset_dir: str, - ): - super().__init__() - self.domain, self.task = env_id.split("-") - self.env = DMCGym(self.domain, self.task) - self.embedding = embedding - self.embedding_dim = embedding_dim - self.num_frames = num_frames - self._load_dataset(dataset_dir) - - @property - def observation_space(self): - return gym.spaces.Dict( - { - "image": gym.spaces.Box( - low=0, high=255, shape=(84, 84, 3), dtype=np.uint8 - ), - "embedding": gym.spaces.Box( - low=-1.0, high=1.0, shape=(self.embedding_dim,), dtype=np.float32 - ), - } - ) - - @property - def action_space(self): - return gym.spaces.Dict({"action_key": self.env.action_space}) - - def reset(self): - _, info = self.env.reset() - obs = self.env.render(84, 84) - return ({"image": obs, "embedding": self.embedding}, info) - - def step(self, action): - action = action["action_key"] - term = False - trunc = False - for _ in range(ACTION_REPEAT): - _, r, term, trunc, info = self.env.step(action) - if term or trunc: - break - o = self.env.render(84, 84) - return ({"image": o, "embedding": self.embedding}, r, term, trunc, info) - - def _load_dataset(self, dataset_dir: str): - os.makedirs(dataset_dir, exist_ok=True) - observations = [] - actions = [] - for index in tqdm.trange(4): - file = f"{index}_{self.domain}_{self.task}_expert.hdf5" - path = os.path.join(dataset_dir, file) - if not os.path.exists(path): - url = DATASET_URL.format( - domain=self.domain, - task=self.task, - index=index, - ) - if self.domain == "humanoid" and self.task == "walk": - url = url.rsplit("/")[0] + f"/{index}_expert.hdf5" - response = requests.get(url) - if response.status_code == 200: - with open(path, "wb") as f: - f.write(response.content) - with h5py.File(path, "r") as f: - observations.append(f["observation"][:]) - actions.append(f["action"][:]) - self.observations = np.concatenate(observations) - self.actions = np.concatenate(actions) - - def get_dataset(self, batch_size: int) -> Iterable[Dict]: - # We expect self.num_frames trajectories per episode - num_episodes = np.ceil(batch_size / self.num_frames).astype(int) - # Leftover trajectories from last episode - prev_obs = None - prev_act = None - for idx in range(0, self.actions.shape[0], num_episodes * 501): - # Get `batch_size` number of episodes - obs = self.observations[idx : idx + num_episodes * 501] - act = self.actions[idx : idx + num_episodes * 501] - - # Convert to (b, t, ...) - obs = np.reshape(obs, (num_episodes, 501, *obs.shape[1:])) - act = np.reshape(act, (num_episodes, 501, *act.shape[1:])) - - # drop the last timestep and action from each episode - obs = obs[:, :-1] - act = act[:, :-1] - - # frame-stack by rolling self.num_frames times over t - num_traj = 500 - self.num_frames + 1 - indices = np.stack( - [np.arange(s, s + num_traj) for s in range(self.num_frames)], - axis=-1, - ) - - # (b, t, ...) -> (b, t - f + 1, f, ...) - obs = np.take(obs, indices, axis=1) - act = np.take(act, indices, axis=1) - - # (b, t - f + 1, f, ...) -> (b * (t - f + 1), f, ...) - obs = np.reshape(obs, (num_episodes * num_traj, *obs.shape[2:])) - act = np.reshape(act, (num_episodes * num_traj, *act.shape[2:])) - - # Concatenate with leftover trajectories from last episode - if prev_obs is not None: - obs = np.concatenate([prev_obs, obs], axis=0) - act = np.concatenate([prev_act, act], axis=0) - - for batch in range(0, obs.shape[0], batch_size): - if batch + batch_size > obs.shape[0]: - # Save leftover trajectories and break - prev_obs = obs[batch:] - prev_act = act[batch:] - break - - yield { - "observation": { - "image": obs[batch : batch + batch_size], - "embedding": np.tile( - np.expand_dims(self.embedding, (0, 1)), - (batch_size, self.num_frames, 1), - ), - }, - "action": {"action_key": act[batch : batch + batch_size]}, - } - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--env", - type=str, - default="walker-walk", - help="name of the environment", - choices=[ - "walker-walk", - "cheetah-run", - "humanoid-walk", - ], - ) - parser.add_argument( - "--context", - type=str, - default="""Move forward by walking upright on two legs, - while maintaining balance and stability""", - ) - # cheetah-run: """Run forward rapidly on all four legs, - # coordinating movements for speed and efficiency""" - parser.add_argument( - "--epochs", - type=int, - default=10, - help="number of training epochs", - ) - parser.add_argument( - "--lr", - type=float, - default=1e-4, - help="learning rate", - ) - parser.add_argument( - "--batch-size", - type=int, - default=32, - help="batch size in number of trajectories", - ) - parser.add_argument( - "--trajectory-length", - type=int, - default=4, - help="number of frames per trajectory", - ) - parser.add_argument( - "--sentence-transformer", - type=str, - default="all-MiniLM-L6-v2", - help="SentenceTransformer to use for text embedding", - ) - parser.add_argument( - "--device", - type=str, - default="cuda", - help="device to use for training", - ) - parser.add_argument( - "--eval-freq", - type=int, - default=None, - help="eval frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-freq", - type=int, - default=None, - help="checkpoint frequency in number of batches; defaults to None", - ) - parser.add_argument( - "--checkpoint-dir", - type=str, - default="checkpoints/vd4rl", - help="directory to save checkpoints", - ) - parser.add_argument( - "--load-checkpoint", - type=str, - default=None, - help="checkpoint to load from; defaults to None", - ) - parser.add_argument( - "--dataset-dir", - type=str, - default="datasets", - help="local directory for datasets", - ) - parser.add_argument( - "--wandb", - action="store_true", - help="use wandb for logging", - default=False, - ) - return parser.parse_args() - - -def main(): - args = parse_args() - - if args.wandb: - wandb.init(project="rt1-vd4rl", config=vars(args)) - - os.makedirs(args.checkpoint_dir, exist_ok=True) - - text_embedding_model = SentenceTransformer(args.sentence_transformer) - embedding_dim = text_embedding_model.get_sentence_embedding_dimension() - embedding = text_embedding_model.encode(args.context) - - print("Loading dataset...") - env = VD4RLEnv( - env_id=args.env, - embedding=embedding, - embedding_dim=embedding_dim, - num_frames=args.trajectory_length, - dataset_dir=args.dataset_dir, - ) - - print("Building policy...") - policy = RT1Policy( - observation_space=env.observation_space, - action_space=env.action_space, - arch="efficientnet_b0", - action_bins=512, - num_layers=4, - num_heads=4, - feed_forward_size=512, - dropout_rate=0.01, - time_sequence_length=args.trajectory_length, - embedding_dim=embedding_dim, - use_token_learner=True, - token_learner_bottleneck_dim=32, - token_learner_num_output_tokens=8, - device=args.device, - checkpoint_path=args.load_checkpoint, - ) - policy.model.train() - optimizer = Adam(policy.model.parameters(), lr=args.lr) - # Total number of params - total_params = sum(p.numel() for p in policy.model.parameters()) - # Transformer params - transformer_params = sum(p.numel() for p in policy.model.transformer.parameters()) - # FiLM-EfficientNet and TokenLearner params - tokenizer_params = sum(p.numel() for p in policy.model.image_tokenizer.parameters()) - print(f"Total params: {total_params}") - print(f"Transformer params: {transformer_params}") - print(f"FiLM-EfficientNet+TokenLearner params: {tokenizer_params}") - - def get_text_embedding(observation: Dict): - return observation["embedding"] - - print("Training...") - num_batches = 0 - for epoch in range(1, args.epochs + 1): - train_dataset = env.get_dataset(batch_size=args.batch_size) - for batch in train_dataset: - policy.model.train() - num_batches += 1 - observations = { - "image": batch["observation"]["image"], - "context": get_text_embedding(batch["observation"]), - } - actions = batch["action"] - loss = policy.loss(observations, actions) - if args.wandb: - wandb.log( - {"train_loss": loss.item()}, - step=num_batches * args.batch_size, - ) - else: - print(f"Batch {num_batches} train loss: {loss.item()}") - optimizer.zero_grad() - loss.backward() - optimizer.step() - if args.eval_freq and num_batches % args.eval_freq == 0: - print("Evaluating...") - policy.model.eval() - obs, _ = env.reset() - obs_stacked = { - k: np.stack([v for _ in range(args.trajectory_length)]) - for k, v in obs.items() - } - observations = {"image": [], "context": []} - actions = {"action_key": []} - term = False - trunc = False - reward = 0.0 - ts = 0 - while not (term or trunc): - cur_obs = { - "image": obs_stacked["image"], - "context": get_text_embedding(obs_stacked), - } - - # add batch dimension - cur_obs["image"] = np.expand_dims(cur_obs["image"], axis=0) - cur_obs["context"] = np.expand_dims(cur_obs["context"], axis=0) - - act = policy.act(cur_obs) - - # remove batch dimension - act = {k: v[0] for k, v in act.items()} - new_obs, rew, term, trunc, info = env.step(act) - obs_stacked = { - k: np.concatenate( - [ - obs_stacked[k][1:], - np.expand_dims(new_obs[k], axis=0), - ] - ) - for k in new_obs.keys() - } - observations["image"].append(obs_stacked["image"]) - observations["context"].append(get_text_embedding(obs_stacked)) - actions["action_key"].append(act["action_key"]) - reward += rew * (info["discount"] ** ts) - ts += 1 - if args.wandb: - wandb.log( - {"eval_return": reward}, - step=num_batches * args.batch_size, - ) - else: - print(f"Batch {num_batches} eval return: {reward}") - if args.checkpoint_freq and num_batches % args.checkpoint_freq == 0: - checkpoint_path = ( - f"{args.checkpoint_dir}/checkpoint_" - + f"{num_batches * args.batch_size * epoch}" - + f"_loss_{loss.item():.3f}.pt" - ) - torch.save(policy.model.state_dict(), checkpoint_path) - print(f"Saved checkpoint to {checkpoint_path}") - - -if __name__ == "__main__": - main() \ No newline at end of file From 78c0f6389d54c3200c821daddd5b214cbf9bdeae Mon Sep 17 00:00:00 2001 From: Shreyas Raman Date: Thu, 20 Jun 2024 19:08:17 -0400 Subject: [PATCH 12/12] integrated RT1 readme --- README.md | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 66 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b7ca07004..1d25ae046 100644 --- a/README.md +++ b/README.md @@ -121,9 +121,72 @@ The detailed metadata can be found in the dataset card. | all_joint_velocities | {"fl.hx": -0.0014713359996676445, "fl.hy": -0.0019799235742539167, "fl.kn": 0.011371612548828125, "fr.hx": -0.007194998674094677, "fr.hy": 0.0033285804092884064, "fr.kn": -0.01216356735676527, "hl.hx": 0.004889719653874636, "hl.hy": -0.0077947331592440605, "hl.kn": 0.005902839358896017, "hr.hx": 0.01074210461229086, "hr.hy": 0.005369353573769331, "hr.kn": -0.019331036135554314, "arm0.sh0": -0.009795751422643661, "arm0.sh1": 0.011766805313527584, "arm0.hr0": 0.0, "arm0.el0": 0.010913466103374958, "arm0.el1": -0.007954984903335571, "arm0.wr0": 0.004147909115999937, "arm0.wr1": 0.003433068050071597, "arm0.f1x": -0.0011129062622785568} | --> ## RT-1 -The RT-1 model from the paper ["RT-1: Robotics Transformer for Real-World Control at Scale"](https://www.roboticsproceedings.org/rss19/p025.pdf) by _Brohan et al._ was modified and fine-tuned on LaNMP. +The RT-1 model from the paper ["RT-1: Robotics Transformer for Real-World Control at Scale"](https://www.roboticsproceedings.org/rss19/p025.pdf) by _Brohan et al._ was modified and fine-tuned on LaNMP. This model was trained and run on an NVIDIA 3090 GPU. + + + +A forked implementation of RT1 (Robotic Transformer) originally inspired by the Google Research paper. + +This implemenetation of RT-1 was pretrained on the Bridge dataset and further fine-tuned on our LaNMP dataset for evaluation. Please find details of the repository below + +### Setup Instructions + +```bash +git clone git@github.com:h2r/LaNPM-Dataset.git +cd models/main_models/rt1 +pip install -e . +``` + +### Overview of files + +This repository has 7 critical files/folders whose use cases are described below + +1) ```main.py```: used to pretrain RT-1 on the bridge dataset. Modifying this file to accomodate different datasets requires changing the ```observation_space``` and ```action_space``` according to the dataset being loaded, as well as changing the dataset keys in ```rt1_pytorch/tokenizers/action_tokenizer.py```. Running this file saves a series of checkpoints and logs losses using weights and biases +2) ```main_ft.py```: used to finetune RT-1 on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset finetuning (AI2Thor). Running this file saves a series of checkpoints and logs losses using weights and biases +3) ```main_ft_eval.py```: used to run RT-1 in inference mode on the LaNMP dataset. This file has the ```observation_space``` and ```action_space``` and PyTorch ```DataLoader``` already modified to accomodate for the LaNMP dataset (AI2Thor). The file iterates/loads all saved checkpoints from finetuning and runs RT-1 on inference mode for the validation dataset on each checkpoint. The script logs the test losses using weights and biases +4) ```ai2thor_env.py```: contains a Gym environment style class to load and take steps in AI2Thor enivironment. This file is used to generate real-time trajectories based on the action tokens generated by a finetuned RT-1 model (specific for AI2Thor). The main ```step()``` function takes/executes the generated action by RT-1 and returns a success message along with information about the environment state e.g. object or agent metadata, which can be saved to capture the trajectory taken by the agent for a given task +5) ```rollout_ai2thor.py```: interfaces between the finetuned RT-1 model (from a loaded checkpoint after finetuning on LaNMP) and the ```ai2thor_env.py``` Gym environment, in order to send observations from the AI2Thor environment to RT-1 and execute proposed action tokens by RT-1 on AI2Thor. Note that this file should not be run on a headless machine since it requires/deploys AI2Thor simulator GUI +6) ```rt1_pytorch/rt1_policy.py```: contains the RT-1 model implementation in PyTorch. The ```loss()``` function performs forward pass of RT-1 for training and ```act()``` function performs the forward pass during inference. +7) ```lanmp_dataloader/rt1_dataloader.py```: contains the ```DatasetManager``` class that extracts trajectories from the LaNMP ```sim_data.hdf5``` dataset file. The script automatically separates train and validation subsets according to different splits e.g. k-fold by scene, task wise or for diversity ablation. The ```DatasetManager``` also handles tokenizing/detokenizing the raw trajectory data into 256 discrete buckets, whilst also chunking trajectories across non-overlapping window lengths of 6 steps + +### Details about file arguments + +Most relevant files in this repository accept the same set of arguments that are detailed below +* ```dataset```: only for the ```main.py``` file, specifies the dataset on which the RT-1 model should be pretrained +* ```train-split```: specifies what fraction of the loaded dataset should be used for training v.s. evaluation +* ```eval-split```: specifies what fraction of the laoded dataset should be used for evaluation v.s. training +* ```epochs```: total number of passes over the all batches of the training set +* ```lr```: learning rate for cross-entropy loss of RT1 +* ```train-batch-size```: the number of trajectories from which to sample data for the current training batch +* ```eval-batch-size```: the number of trajectories from which to sample data for the current evaluation batch +* ```trajectory-length```: the window size (context history of ```trajecotry-length``` previous images) used for each trajectory when feeding data to RT-1 model; this is set to 6 based on the RT-1 implementation +* ```sentence-transformer```: the language embedding to apply on the language-specified task +* ```device```: the device to load the model/data onto during training/inference +* ```eval-freq```: the interval of batches at which to run evaluation/inference on the validation dataset (currently set to 0 in ```main_ft.py```) +* ```checkpoint-freq```: the interval of batches at which to save a checkpoint during training +* ```checkpoint-dir```: the directory path at which to save a checkpoint during training +* ```load-checkpoint```: (optional) path of the pretrained checkpoint to load for further fine-tuning +* ```wandb```: boolean determining if logging to weights and biases should happen +* ```eval-scene```: the AI2Thor scene number in the dataset that is held out of the training set for evaluation during k-fold cross validation across scenes +* ```split-type```: determines the split type (i.e. k-fold by scene, task wise or diversity ablation) between train and evaluation used by the ```DatasetManager``` in ```rt1_dataloader.py``` +* ```num-diversity-scenes```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of scenes to perform diversity ablation over i.e. maximum of 4 for LaNMP simulation data +* ```max-diversity-trajectories```: only if ```split-type``` is ```diversity-ablation```, this is used to determine the total number of trajectories that are divided evenly across the number of ```num-diversity-scenes``` scenes +* ```train-subbatch```: the batch size to use during training/finetuning +* ```eval-subbatch```: the batch size to use during evaluation + +### Checkpoint samples + +Please find the follow checkpoints samples that can be loaded to the RT-1 model. These can be found on the supplementary Google Drive associated with this project +* ```sample_checkpoints/pretrained_bridge```: the final checkpoint saved when pretraining the RT-1 model on the Bridge dataset +* ```sample_checkpoints/task_gen```: the final checkpoint saved after finetuning RT-1 model on the task-wise split for the task generalization experiment + +### Additional notes + +When running any of the finetuning or pretraining scripts, please ensure the following modules are loaded +```module load cuda/11.8.0-lpttyok``` +```module load cudnn/8.7.0.84-11.8-lg2dpd5``` + -To be continued... ## ALFRED Seq2Seq The ALFRED Seq2Seq model from the paper ["ALFRED A Benchmark for Interpreting Grounded Instructions for Everyday Tasks"](https://openaccess.thecvf.com/content_CVPR_2020/papers/Shridhar_ALFRED_A_Benchmark_for_Interpreting_Grounded_Instructions_for_Everyday_Tasks_CVPR_2020_paper.pdf) by _Shridhar et al._ was modified and fine-tuned on LaNMP. @@ -180,4 +243,4 @@ python models/eval/eval_seq2seq.py --model_path exp/best_test_fold1.pth --gpu -- ``` * The command assumes it is run on a machine with a GUI in order to run the AI2THOR simulator, i.e. not on a headless machine. * To run other models instead of the "fold1" model, change any part that has "fold1" in the command to the desired model, e.g. "task" for the "best_test_task.pth" model. -* More details on all the command-line arguments can be found at `LaNMP-Dataset/models/main_models/eval/eval_seq2seq.py`. \ No newline at end of file +* More details on all the command-line arguments can be found at `LaNMP-Dataset/models/main_models/eval/eval_seq2seq.py`.